elf32-i386.c revision 91048
1/* Intel 80386/80486-specific support for 32-bit ELF 2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001 3 Free Software Foundation, Inc. 4 5This file is part of BFD, the Binary File Descriptor library. 6 7This program is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 2 of the License, or 10(at your option) any later version. 11 12This program is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with this program; if not, write to the Free Software 19Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 20 21/* $FreeBSD: head/contrib/binutils/bfd/elf32-i386.c 91048 2002-02-22 04:45:47Z obrien $ */ 22 23#include "bfd.h" 24#include "sysdep.h" 25#include "bfdlink.h" 26#include "libbfd.h" 27#include "elf-bfd.h" 28 29static reloc_howto_type *elf_i386_reloc_type_lookup 30 PARAMS ((bfd *, bfd_reloc_code_real_type)); 31static void elf_i386_info_to_howto 32 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *)); 33static void elf_i386_info_to_howto_rel 34 PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *)); 35static boolean elf_i386_is_local_label_name 36 PARAMS ((bfd *, const char *)); 37static boolean elf_i386_grok_prstatus 38 PARAMS ((bfd *abfd, Elf_Internal_Note *note)); 39static boolean elf_i386_grok_psinfo 40 PARAMS ((bfd *abfd, Elf_Internal_Note *note)); 41static struct bfd_hash_entry *link_hash_newfunc 42 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *)); 43static struct bfd_link_hash_table *elf_i386_link_hash_table_create 44 PARAMS ((bfd *)); 45static boolean create_got_section 46 PARAMS((bfd *, struct bfd_link_info *)); 47static boolean elf_i386_create_dynamic_sections 48 PARAMS((bfd *, struct bfd_link_info *)); 49static void elf_i386_copy_indirect_symbol 50 PARAMS ((struct elf_link_hash_entry *, struct elf_link_hash_entry *)); 51static boolean elf_i386_check_relocs 52 PARAMS ((bfd *, struct bfd_link_info *, asection *, 53 const Elf_Internal_Rela *)); 54static asection *elf_i386_gc_mark_hook 55 PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *, 56 struct elf_link_hash_entry *, Elf_Internal_Sym *)); 57static boolean elf_i386_gc_sweep_hook 58 PARAMS ((bfd *, struct bfd_link_info *, asection *, 59 const Elf_Internal_Rela *)); 60static boolean elf_i386_adjust_dynamic_symbol 61 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *)); 62static boolean allocate_dynrelocs 63 PARAMS ((struct elf_link_hash_entry *, PTR)); 64static boolean readonly_dynrelocs 65 PARAMS ((struct elf_link_hash_entry *, PTR)); 66static boolean elf_i386_fake_sections 67 PARAMS ((bfd *, Elf32_Internal_Shdr *, asection *)); 68static boolean elf_i386_size_dynamic_sections 69 PARAMS ((bfd *, struct bfd_link_info *)); 70static boolean elf_i386_relocate_section 71 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, 72 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **)); 73static boolean elf_i386_finish_dynamic_symbol 74 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, 75 Elf_Internal_Sym *)); 76static enum elf_reloc_type_class elf_i386_reloc_type_class 77 PARAMS ((const Elf_Internal_Rela *)); 78static boolean elf_i386_finish_dynamic_sections 79 PARAMS ((bfd *, struct bfd_link_info *)); 80 81#define USE_REL 1 /* 386 uses REL relocations instead of RELA */ 82 83#include "elf/i386.h" 84 85static reloc_howto_type elf_howto_table[]= 86{ 87 HOWTO(R_386_NONE, 0, 0, 0, false, 0, complain_overflow_bitfield, 88 bfd_elf_generic_reloc, "R_386_NONE", 89 true, 0x00000000, 0x00000000, false), 90 HOWTO(R_386_32, 0, 2, 32, false, 0, complain_overflow_bitfield, 91 bfd_elf_generic_reloc, "R_386_32", 92 true, 0xffffffff, 0xffffffff, false), 93 HOWTO(R_386_PC32, 0, 2, 32, true, 0, complain_overflow_bitfield, 94 bfd_elf_generic_reloc, "R_386_PC32", 95 true, 0xffffffff, 0xffffffff, true), 96 HOWTO(R_386_GOT32, 0, 2, 32, false, 0, complain_overflow_bitfield, 97 bfd_elf_generic_reloc, "R_386_GOT32", 98 true, 0xffffffff, 0xffffffff, false), 99 HOWTO(R_386_PLT32, 0, 2, 32, true, 0, complain_overflow_bitfield, 100 bfd_elf_generic_reloc, "R_386_PLT32", 101 true, 0xffffffff, 0xffffffff, true), 102 HOWTO(R_386_COPY, 0, 2, 32, false, 0, complain_overflow_bitfield, 103 bfd_elf_generic_reloc, "R_386_COPY", 104 true, 0xffffffff, 0xffffffff, false), 105 HOWTO(R_386_GLOB_DAT, 0, 2, 32, false, 0, complain_overflow_bitfield, 106 bfd_elf_generic_reloc, "R_386_GLOB_DAT", 107 true, 0xffffffff, 0xffffffff, false), 108 HOWTO(R_386_JUMP_SLOT, 0, 2, 32, false, 0, complain_overflow_bitfield, 109 bfd_elf_generic_reloc, "R_386_JUMP_SLOT", 110 true, 0xffffffff, 0xffffffff, false), 111 HOWTO(R_386_RELATIVE, 0, 2, 32, false, 0, complain_overflow_bitfield, 112 bfd_elf_generic_reloc, "R_386_RELATIVE", 113 true, 0xffffffff, 0xffffffff, false), 114 HOWTO(R_386_GOTOFF, 0, 2, 32, false, 0, complain_overflow_bitfield, 115 bfd_elf_generic_reloc, "R_386_GOTOFF", 116 true, 0xffffffff, 0xffffffff, false), 117 HOWTO(R_386_GOTPC, 0, 2, 32, true, 0, complain_overflow_bitfield, 118 bfd_elf_generic_reloc, "R_386_GOTPC", 119 true, 0xffffffff, 0xffffffff, true), 120 121 /* We have a gap in the reloc numbers here. 122 R_386_standard counts the number up to this point, and 123 R_386_ext_offset is the value to subtract from a reloc type of 124 R_386_16 thru R_386_PC8 to form an index into this table. */ 125#define R_386_standard ((unsigned int) R_386_GOTPC + 1) 126#define R_386_ext_offset ((unsigned int) R_386_16 - R_386_standard) 127 128 /* The remaining relocs are a GNU extension. */ 129 HOWTO(R_386_16, 0, 1, 16, false, 0, complain_overflow_bitfield, 130 bfd_elf_generic_reloc, "R_386_16", 131 true, 0xffff, 0xffff, false), 132 HOWTO(R_386_PC16, 0, 1, 16, true, 0, complain_overflow_bitfield, 133 bfd_elf_generic_reloc, "R_386_PC16", 134 true, 0xffff, 0xffff, true), 135 HOWTO(R_386_8, 0, 0, 8, false, 0, complain_overflow_bitfield, 136 bfd_elf_generic_reloc, "R_386_8", 137 true, 0xff, 0xff, false), 138 HOWTO(R_386_PC8, 0, 0, 8, true, 0, complain_overflow_signed, 139 bfd_elf_generic_reloc, "R_386_PC8", 140 true, 0xff, 0xff, true), 141 142 /* Another gap. */ 143#define R_386_ext ((unsigned int) R_386_PC8 + 1 - R_386_ext_offset) 144#define R_386_vt_offset ((unsigned int) R_386_GNU_VTINHERIT - R_386_ext) 145 146/* GNU extension to record C++ vtable hierarchy. */ 147 HOWTO (R_386_GNU_VTINHERIT, /* type */ 148 0, /* rightshift */ 149 2, /* size (0 = byte, 1 = short, 2 = long) */ 150 0, /* bitsize */ 151 false, /* pc_relative */ 152 0, /* bitpos */ 153 complain_overflow_dont, /* complain_on_overflow */ 154 NULL, /* special_function */ 155 "R_386_GNU_VTINHERIT", /* name */ 156 false, /* partial_inplace */ 157 0, /* src_mask */ 158 0, /* dst_mask */ 159 false), 160 161/* GNU extension to record C++ vtable member usage. */ 162 HOWTO (R_386_GNU_VTENTRY, /* type */ 163 0, /* rightshift */ 164 2, /* size (0 = byte, 1 = short, 2 = long) */ 165 0, /* bitsize */ 166 false, /* pc_relative */ 167 0, /* bitpos */ 168 complain_overflow_dont, /* complain_on_overflow */ 169 _bfd_elf_rel_vtable_reloc_fn, /* special_function */ 170 "R_386_GNU_VTENTRY", /* name */ 171 false, /* partial_inplace */ 172 0, /* src_mask */ 173 0, /* dst_mask */ 174 false) 175 176#define R_386_vt ((unsigned int) R_386_GNU_VTENTRY + 1 - R_386_vt_offset) 177 178}; 179 180#ifdef DEBUG_GEN_RELOC 181#define TRACE(str) fprintf (stderr, "i386 bfd reloc lookup %d (%s)\n", code, str) 182#else 183#define TRACE(str) 184#endif 185 186static reloc_howto_type * 187elf_i386_reloc_type_lookup (abfd, code) 188 bfd *abfd ATTRIBUTE_UNUSED; 189 bfd_reloc_code_real_type code; 190{ 191 switch (code) 192 { 193 case BFD_RELOC_NONE: 194 TRACE ("BFD_RELOC_NONE"); 195 return &elf_howto_table[(unsigned int) R_386_NONE ]; 196 197 case BFD_RELOC_32: 198 TRACE ("BFD_RELOC_32"); 199 return &elf_howto_table[(unsigned int) R_386_32 ]; 200 201 case BFD_RELOC_CTOR: 202 TRACE ("BFD_RELOC_CTOR"); 203 return &elf_howto_table[(unsigned int) R_386_32 ]; 204 205 case BFD_RELOC_32_PCREL: 206 TRACE ("BFD_RELOC_PC32"); 207 return &elf_howto_table[(unsigned int) R_386_PC32 ]; 208 209 case BFD_RELOC_386_GOT32: 210 TRACE ("BFD_RELOC_386_GOT32"); 211 return &elf_howto_table[(unsigned int) R_386_GOT32 ]; 212 213 case BFD_RELOC_386_PLT32: 214 TRACE ("BFD_RELOC_386_PLT32"); 215 return &elf_howto_table[(unsigned int) R_386_PLT32 ]; 216 217 case BFD_RELOC_386_COPY: 218 TRACE ("BFD_RELOC_386_COPY"); 219 return &elf_howto_table[(unsigned int) R_386_COPY ]; 220 221 case BFD_RELOC_386_GLOB_DAT: 222 TRACE ("BFD_RELOC_386_GLOB_DAT"); 223 return &elf_howto_table[(unsigned int) R_386_GLOB_DAT ]; 224 225 case BFD_RELOC_386_JUMP_SLOT: 226 TRACE ("BFD_RELOC_386_JUMP_SLOT"); 227 return &elf_howto_table[(unsigned int) R_386_JUMP_SLOT ]; 228 229 case BFD_RELOC_386_RELATIVE: 230 TRACE ("BFD_RELOC_386_RELATIVE"); 231 return &elf_howto_table[(unsigned int) R_386_RELATIVE ]; 232 233 case BFD_RELOC_386_GOTOFF: 234 TRACE ("BFD_RELOC_386_GOTOFF"); 235 return &elf_howto_table[(unsigned int) R_386_GOTOFF ]; 236 237 case BFD_RELOC_386_GOTPC: 238 TRACE ("BFD_RELOC_386_GOTPC"); 239 return &elf_howto_table[(unsigned int) R_386_GOTPC ]; 240 241 /* The remaining relocs are a GNU extension. */ 242 case BFD_RELOC_16: 243 TRACE ("BFD_RELOC_16"); 244 return &elf_howto_table[(unsigned int) R_386_16 - R_386_ext_offset]; 245 246 case BFD_RELOC_16_PCREL: 247 TRACE ("BFD_RELOC_16_PCREL"); 248 return &elf_howto_table[(unsigned int) R_386_PC16 - R_386_ext_offset]; 249 250 case BFD_RELOC_8: 251 TRACE ("BFD_RELOC_8"); 252 return &elf_howto_table[(unsigned int) R_386_8 - R_386_ext_offset]; 253 254 case BFD_RELOC_8_PCREL: 255 TRACE ("BFD_RELOC_8_PCREL"); 256 return &elf_howto_table[(unsigned int) R_386_PC8 - R_386_ext_offset]; 257 258 case BFD_RELOC_VTABLE_INHERIT: 259 TRACE ("BFD_RELOC_VTABLE_INHERIT"); 260 return &elf_howto_table[(unsigned int) R_386_GNU_VTINHERIT 261 - R_386_vt_offset]; 262 263 case BFD_RELOC_VTABLE_ENTRY: 264 TRACE ("BFD_RELOC_VTABLE_ENTRY"); 265 return &elf_howto_table[(unsigned int) R_386_GNU_VTENTRY 266 - R_386_vt_offset]; 267 268 default: 269 break; 270 } 271 272 TRACE ("Unknown"); 273 return 0; 274} 275 276static void 277elf_i386_info_to_howto (abfd, cache_ptr, dst) 278 bfd *abfd ATTRIBUTE_UNUSED; 279 arelent *cache_ptr ATTRIBUTE_UNUSED; 280 Elf32_Internal_Rela *dst ATTRIBUTE_UNUSED; 281{ 282 abort (); 283} 284 285static void 286elf_i386_info_to_howto_rel (abfd, cache_ptr, dst) 287 bfd *abfd ATTRIBUTE_UNUSED; 288 arelent *cache_ptr; 289 Elf32_Internal_Rel *dst; 290{ 291 unsigned int r_type = ELF32_R_TYPE (dst->r_info); 292 unsigned int indx; 293 294 if ((indx = r_type) >= R_386_standard 295 && ((indx = r_type - R_386_ext_offset) - R_386_standard 296 >= R_386_ext - R_386_standard) 297 && ((indx = r_type - R_386_vt_offset) - R_386_ext 298 >= R_386_vt - R_386_ext)) 299 { 300 (*_bfd_error_handler) (_("%s: invalid relocation type %d"), 301 bfd_archive_filename (abfd), (int) r_type); 302 indx = (unsigned int) R_386_NONE; 303 } 304 cache_ptr->howto = &elf_howto_table[indx]; 305} 306 307/* Return whether a symbol name implies a local label. The UnixWare 308 2.1 cc generates temporary symbols that start with .X, so we 309 recognize them here. FIXME: do other SVR4 compilers also use .X?. 310 If so, we should move the .X recognition into 311 _bfd_elf_is_local_label_name. */ 312 313static boolean 314elf_i386_is_local_label_name (abfd, name) 315 bfd *abfd; 316 const char *name; 317{ 318 if (name[0] == '.' && name[1] == 'X') 319 return true; 320 321 return _bfd_elf_is_local_label_name (abfd, name); 322} 323 324/* Support for core dump NOTE sections. */ 325static boolean 326elf_i386_grok_prstatus (abfd, note) 327 bfd *abfd; 328 Elf_Internal_Note *note; 329{ 330 int offset; 331 size_t raw_size; 332 333 switch (note->descsz) 334 { 335 default: 336 return false; 337 338 case 144: /* Linux/i386 */ 339 /* pr_cursig */ 340 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12); 341 342 /* pr_pid */ 343 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24); 344 345 /* pr_reg */ 346 offset = 72; 347 raw_size = 68; 348 349 break; 350 } 351 352 /* Make a ".reg/999" section. */ 353 return _bfd_elfcore_make_pseudosection (abfd, ".reg", 354 raw_size, note->descpos + offset); 355} 356 357static boolean 358elf_i386_grok_psinfo (abfd, note) 359 bfd *abfd; 360 Elf_Internal_Note *note; 361{ 362 switch (note->descsz) 363 { 364 default: 365 return false; 366 367 case 124: /* Linux/i386 elf_prpsinfo */ 368 elf_tdata (abfd)->core_program 369 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16); 370 elf_tdata (abfd)->core_command 371 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80); 372 } 373 374 /* Note that for some reason, a spurious space is tacked 375 onto the end of the args in some (at least one anyway) 376 implementations, so strip it off if it exists. */ 377 378 { 379 char *command = elf_tdata (abfd)->core_command; 380 int n = strlen (command); 381 382 if (0 < n && command[n - 1] == ' ') 383 command[n - 1] = '\0'; 384 } 385 386 return true; 387} 388 389/* Functions for the i386 ELF linker. 390 391 In order to gain some understanding of code in this file without 392 knowing all the intricate details of the linker, note the 393 following: 394 395 Functions named elf_i386_* are called by external routines, other 396 functions are only called locally. elf_i386_* functions appear 397 in this file more or less in the order in which they are called 398 from external routines. eg. elf_i386_check_relocs is called 399 early in the link process, elf_i386_finish_dynamic_sections is 400 one of the last functions. */ 401 402 403/* The name of the dynamic interpreter. This is put in the .interp 404 section. */ 405 406 407#ifndef ELF_DYNAMIC_INTERPRETER 408#define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1" 409#endif 410 411 412/* The size in bytes of an entry in the procedure linkage table. */ 413 414#define PLT_ENTRY_SIZE 16 415 416/* The first entry in an absolute procedure linkage table looks like 417 this. See the SVR4 ABI i386 supplement to see how this works. */ 418 419static const bfd_byte elf_i386_plt0_entry[PLT_ENTRY_SIZE] = 420{ 421 0xff, 0x35, /* pushl contents of address */ 422 0, 0, 0, 0, /* replaced with address of .got + 4. */ 423 0xff, 0x25, /* jmp indirect */ 424 0, 0, 0, 0, /* replaced with address of .got + 8. */ 425 0, 0, 0, 0 /* pad out to 16 bytes. */ 426}; 427 428/* Subsequent entries in an absolute procedure linkage table look like 429 this. */ 430 431static const bfd_byte elf_i386_plt_entry[PLT_ENTRY_SIZE] = 432{ 433 0xff, 0x25, /* jmp indirect */ 434 0, 0, 0, 0, /* replaced with address of this symbol in .got. */ 435 0x68, /* pushl immediate */ 436 0, 0, 0, 0, /* replaced with offset into relocation table. */ 437 0xe9, /* jmp relative */ 438 0, 0, 0, 0 /* replaced with offset to start of .plt. */ 439}; 440 441/* The first entry in a PIC procedure linkage table look like this. */ 442 443static const bfd_byte elf_i386_pic_plt0_entry[PLT_ENTRY_SIZE] = 444{ 445 0xff, 0xb3, 4, 0, 0, 0, /* pushl 4(%ebx) */ 446 0xff, 0xa3, 8, 0, 0, 0, /* jmp *8(%ebx) */ 447 0, 0, 0, 0 /* pad out to 16 bytes. */ 448}; 449 450/* Subsequent entries in a PIC procedure linkage table look like this. */ 451 452static const bfd_byte elf_i386_pic_plt_entry[PLT_ENTRY_SIZE] = 453{ 454 0xff, 0xa3, /* jmp *offset(%ebx) */ 455 0, 0, 0, 0, /* replaced with offset of this symbol in .got. */ 456 0x68, /* pushl immediate */ 457 0, 0, 0, 0, /* replaced with offset into relocation table. */ 458 0xe9, /* jmp relative */ 459 0, 0, 0, 0 /* replaced with offset to start of .plt. */ 460}; 461 462/* The i386 linker needs to keep track of the number of relocs that it 463 decides to copy as dynamic relocs in check_relocs for each symbol. 464 This is so that it can later discard them if they are found to be 465 unnecessary. We store the information in a field extending the 466 regular ELF linker hash table. */ 467 468struct elf_i386_dyn_relocs 469{ 470 struct elf_i386_dyn_relocs *next; 471 472 /* The input section of the reloc. */ 473 asection *sec; 474 475 /* Total number of relocs copied for the input section. */ 476 bfd_size_type count; 477 478 /* Number of pc-relative relocs copied for the input section. */ 479 bfd_size_type pc_count; 480}; 481 482/* i386 ELF linker hash entry. */ 483 484struct elf_i386_link_hash_entry 485{ 486 struct elf_link_hash_entry elf; 487 488 /* Track dynamic relocs copied for this symbol. */ 489 struct elf_i386_dyn_relocs *dyn_relocs; 490}; 491 492/* i386 ELF linker hash table. */ 493 494struct elf_i386_link_hash_table 495{ 496 struct elf_link_hash_table elf; 497 498 /* Short-cuts to get to dynamic linker sections. */ 499 asection *sgot; 500 asection *sgotplt; 501 asection *srelgot; 502 asection *splt; 503 asection *srelplt; 504 asection *sdynbss; 505 asection *srelbss; 506 507 /* Small local sym to section mapping cache. */ 508 struct sym_sec_cache sym_sec; 509}; 510 511/* Get the i386 ELF linker hash table from a link_info structure. */ 512 513#define elf_i386_hash_table(p) \ 514 ((struct elf_i386_link_hash_table *) ((p)->hash)) 515 516/* Create an entry in an i386 ELF linker hash table. */ 517 518static struct bfd_hash_entry * 519link_hash_newfunc (entry, table, string) 520 struct bfd_hash_entry *entry; 521 struct bfd_hash_table *table; 522 const char *string; 523{ 524 /* Allocate the structure if it has not already been allocated by a 525 subclass. */ 526 if (entry == NULL) 527 { 528 entry = bfd_hash_allocate (table, 529 sizeof (struct elf_i386_link_hash_entry)); 530 if (entry == NULL) 531 return entry; 532 } 533 534 /* Call the allocation method of the superclass. */ 535 entry = _bfd_elf_link_hash_newfunc (entry, table, string); 536 if (entry != NULL) 537 { 538 struct elf_i386_link_hash_entry *eh; 539 540 eh = (struct elf_i386_link_hash_entry *) entry; 541 eh->dyn_relocs = NULL; 542 } 543 544 return entry; 545} 546 547/* Create an i386 ELF linker hash table. */ 548 549static struct bfd_link_hash_table * 550elf_i386_link_hash_table_create (abfd) 551 bfd *abfd; 552{ 553 struct elf_i386_link_hash_table *ret; 554 bfd_size_type amt = sizeof (struct elf_i386_link_hash_table); 555 556 ret = (struct elf_i386_link_hash_table *) bfd_alloc (abfd, amt); 557 if (ret == NULL) 558 return NULL; 559 560 if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc)) 561 { 562 bfd_release (abfd, ret); 563 return NULL; 564 } 565 566 ret->sgot = NULL; 567 ret->sgotplt = NULL; 568 ret->srelgot = NULL; 569 ret->splt = NULL; 570 ret->srelplt = NULL; 571 ret->sdynbss = NULL; 572 ret->srelbss = NULL; 573 ret->sym_sec.abfd = NULL; 574 575 return &ret->elf.root; 576} 577 578/* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up 579 shortcuts to them in our hash table. */ 580 581static boolean 582create_got_section (dynobj, info) 583 bfd *dynobj; 584 struct bfd_link_info *info; 585{ 586 struct elf_i386_link_hash_table *htab; 587 588 if (! _bfd_elf_create_got_section (dynobj, info)) 589 return false; 590 591 htab = elf_i386_hash_table (info); 592 htab->sgot = bfd_get_section_by_name (dynobj, ".got"); 593 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt"); 594 if (!htab->sgot || !htab->sgotplt) 595 abort (); 596 597 htab->srelgot = bfd_make_section (dynobj, ".rel.got"); 598 if (htab->srelgot == NULL 599 || ! bfd_set_section_flags (dynobj, htab->srelgot, 600 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS 601 | SEC_IN_MEMORY | SEC_LINKER_CREATED 602 | SEC_READONLY)) 603 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2)) 604 return false; 605 return true; 606} 607 608/* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and 609 .rel.bss sections in DYNOBJ, and set up shortcuts to them in our 610 hash table. */ 611 612static boolean 613elf_i386_create_dynamic_sections (dynobj, info) 614 bfd *dynobj; 615 struct bfd_link_info *info; 616{ 617 struct elf_i386_link_hash_table *htab; 618 619 htab = elf_i386_hash_table (info); 620 if (!htab->sgot && !create_got_section (dynobj, info)) 621 return false; 622 623 if (!_bfd_elf_create_dynamic_sections (dynobj, info)) 624 return false; 625 626 htab->splt = bfd_get_section_by_name (dynobj, ".plt"); 627 htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt"); 628 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss"); 629 if (!info->shared) 630 htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss"); 631 632 if (!htab->splt || !htab->srelplt || !htab->sdynbss 633 || (!info->shared && !htab->srelbss)) 634 abort (); 635 636 return true; 637} 638 639/* Copy the extra info we tack onto an elf_link_hash_entry. */ 640 641static void 642elf_i386_copy_indirect_symbol (dir, ind) 643 struct elf_link_hash_entry *dir, *ind; 644{ 645 struct elf_i386_link_hash_entry *edir, *eind; 646 647 edir = (struct elf_i386_link_hash_entry *) dir; 648 eind = (struct elf_i386_link_hash_entry *) ind; 649 650 if (eind->dyn_relocs != NULL) 651 { 652 if (edir->dyn_relocs != NULL) 653 { 654 struct elf_i386_dyn_relocs **pp; 655 struct elf_i386_dyn_relocs *p; 656 657 if (ind->root.type == bfd_link_hash_indirect) 658 abort (); 659 660 /* Add reloc counts against the weak sym to the strong sym 661 list. Merge any entries against the same section. */ 662 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; ) 663 { 664 struct elf_i386_dyn_relocs *q; 665 666 for (q = edir->dyn_relocs; q != NULL; q = q->next) 667 if (q->sec == p->sec) 668 { 669 q->pc_count += p->pc_count; 670 q->count += p->count; 671 *pp = p->next; 672 break; 673 } 674 if (q == NULL) 675 pp = &p->next; 676 } 677 *pp = edir->dyn_relocs; 678 } 679 680 edir->dyn_relocs = eind->dyn_relocs; 681 eind->dyn_relocs = NULL; 682 } 683 684 _bfd_elf_link_hash_copy_indirect (dir, ind); 685} 686 687/* Look through the relocs for a section during the first phase, and 688 calculate needed space in the global offset table, procedure linkage 689 table, and dynamic reloc sections. */ 690 691static boolean 692elf_i386_check_relocs (abfd, info, sec, relocs) 693 bfd *abfd; 694 struct bfd_link_info *info; 695 asection *sec; 696 const Elf_Internal_Rela *relocs; 697{ 698 struct elf_i386_link_hash_table *htab; 699 Elf_Internal_Shdr *symtab_hdr; 700 struct elf_link_hash_entry **sym_hashes; 701 const Elf_Internal_Rela *rel; 702 const Elf_Internal_Rela *rel_end; 703 asection *sreloc; 704 705 if (info->relocateable) 706 return true; 707 708 htab = elf_i386_hash_table (info); 709 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 710 sym_hashes = elf_sym_hashes (abfd); 711 712 sreloc = NULL; 713 714 rel_end = relocs + sec->reloc_count; 715 for (rel = relocs; rel < rel_end; rel++) 716 { 717 unsigned long r_symndx; 718 struct elf_link_hash_entry *h; 719 720 r_symndx = ELF32_R_SYM (rel->r_info); 721 722 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr)) 723 { 724 (*_bfd_error_handler) (_("%s: bad symbol index: %d"), 725 bfd_archive_filename (abfd), 726 r_symndx); 727 return false; 728 } 729 730 if (r_symndx < symtab_hdr->sh_info) 731 h = NULL; 732 else 733 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 734 735 switch (ELF32_R_TYPE (rel->r_info)) 736 { 737 case R_386_GOT32: 738 /* This symbol requires a global offset table entry. */ 739 if (h != NULL) 740 { 741 h->got.refcount += 1; 742 } 743 else 744 { 745 bfd_signed_vma *local_got_refcounts; 746 747 /* This is a global offset table entry for a local symbol. */ 748 local_got_refcounts = elf_local_got_refcounts (abfd); 749 if (local_got_refcounts == NULL) 750 { 751 bfd_size_type size; 752 753 size = symtab_hdr->sh_info; 754 size *= sizeof (bfd_signed_vma); 755 local_got_refcounts = ((bfd_signed_vma *) 756 bfd_zalloc (abfd, size)); 757 if (local_got_refcounts == NULL) 758 return false; 759 elf_local_got_refcounts (abfd) = local_got_refcounts; 760 } 761 local_got_refcounts[r_symndx] += 1; 762 } 763 /* Fall through */ 764 765 case R_386_GOTOFF: 766 case R_386_GOTPC: 767 if (htab->sgot == NULL) 768 { 769 if (htab->elf.dynobj == NULL) 770 htab->elf.dynobj = abfd; 771 if (!create_got_section (htab->elf.dynobj, info)) 772 return false; 773 } 774 break; 775 776 case R_386_PLT32: 777 /* This symbol requires a procedure linkage table entry. We 778 actually build the entry in adjust_dynamic_symbol, 779 because this might be a case of linking PIC code which is 780 never referenced by a dynamic object, in which case we 781 don't need to generate a procedure linkage table entry 782 after all. */ 783 784 /* If this is a local symbol, we resolve it directly without 785 creating a procedure linkage table entry. */ 786 if (h == NULL) 787 continue; 788 789 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT; 790 h->plt.refcount += 1; 791 break; 792 793 case R_386_32: 794 case R_386_PC32: 795 if (h != NULL && !info->shared) 796 { 797 /* If this reloc is in a read-only section, we might 798 need a copy reloc. We can't check reliably at this 799 stage whether the section is read-only, as input 800 sections have not yet been mapped to output sections. 801 Tentatively set the flag for now, and correct in 802 adjust_dynamic_symbol. */ 803 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF; 804 805 /* We may need a .plt entry if the function this reloc 806 refers to is in a shared lib. */ 807 h->plt.refcount += 1; 808 } 809 810 /* If we are creating a shared library, and this is a reloc 811 against a global symbol, or a non PC relative reloc 812 against a local symbol, then we need to copy the reloc 813 into the shared library. However, if we are linking with 814 -Bsymbolic, we do not need to copy a reloc against a 815 global symbol which is defined in an object we are 816 including in the link (i.e., DEF_REGULAR is set). At 817 this point we have not seen all the input files, so it is 818 possible that DEF_REGULAR is not set now but will be set 819 later (it is never cleared). In case of a weak definition, 820 DEF_REGULAR may be cleared later by a strong definition in 821 a shared library. We account for that possibility below by 822 storing information in the relocs_copied field of the hash 823 table entry. A similar situation occurs when creating 824 shared libraries and symbol visibility changes render the 825 symbol local. 826 827 If on the other hand, we are creating an executable, we 828 may need to keep relocations for symbols satisfied by a 829 dynamic library if we manage to avoid copy relocs for the 830 symbol. */ 831 if ((info->shared 832 && (sec->flags & SEC_ALLOC) != 0 833 && (ELF32_R_TYPE (rel->r_info) != R_386_PC32 834 || (h != NULL 835 && (! info->symbolic 836 || h->root.type == bfd_link_hash_defweak 837 || (h->elf_link_hash_flags 838 & ELF_LINK_HASH_DEF_REGULAR) == 0)))) 839 || (!info->shared 840 && (sec->flags & SEC_ALLOC) != 0 841 && h != NULL 842 && (h->root.type == bfd_link_hash_defweak 843 || (h->elf_link_hash_flags 844 & ELF_LINK_HASH_DEF_REGULAR) == 0))) 845 { 846 struct elf_i386_dyn_relocs *p; 847 struct elf_i386_dyn_relocs **head; 848 849 /* We must copy these reloc types into the output file. 850 Create a reloc section in dynobj and make room for 851 this reloc. */ 852 if (sreloc == NULL) 853 { 854 const char *name; 855 bfd *dynobj; 856 857 name = (bfd_elf_string_from_elf_section 858 (abfd, 859 elf_elfheader (abfd)->e_shstrndx, 860 elf_section_data (sec)->rel_hdr.sh_name)); 861 if (name == NULL) 862 return false; 863 864 if (strncmp (name, ".rel", 4) != 0 865 || strcmp (bfd_get_section_name (abfd, sec), 866 name + 4) != 0) 867 { 868 (*_bfd_error_handler) 869 (_("%s: bad relocation section name `%s\'"), 870 bfd_archive_filename (abfd), name); 871 } 872 873 if (htab->elf.dynobj == NULL) 874 htab->elf.dynobj = abfd; 875 876 dynobj = htab->elf.dynobj; 877 sreloc = bfd_get_section_by_name (dynobj, name); 878 if (sreloc == NULL) 879 { 880 flagword flags; 881 882 sreloc = bfd_make_section (dynobj, name); 883 flags = (SEC_HAS_CONTENTS | SEC_READONLY 884 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 885 if ((sec->flags & SEC_ALLOC) != 0) 886 flags |= SEC_ALLOC | SEC_LOAD; 887 if (sreloc == NULL 888 || ! bfd_set_section_flags (dynobj, sreloc, flags) 889 || ! bfd_set_section_alignment (dynobj, sreloc, 2)) 890 return false; 891 } 892 elf_section_data (sec)->sreloc = sreloc; 893 } 894 895 /* If this is a global symbol, we count the number of 896 relocations we need for this symbol. */ 897 if (h != NULL) 898 { 899 head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs; 900 } 901 else 902 { 903 /* Track dynamic relocs needed for local syms too. 904 We really need local syms available to do this 905 easily. Oh well. */ 906 907 asection *s; 908 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec, 909 sec, r_symndx); 910 if (s == NULL) 911 return false; 912 913 head = ((struct elf_i386_dyn_relocs **) 914 &elf_section_data (s)->local_dynrel); 915 } 916 917 p = *head; 918 if (p == NULL || p->sec != sec) 919 { 920 bfd_size_type amt = sizeof *p; 921 p = ((struct elf_i386_dyn_relocs *) 922 bfd_alloc (htab->elf.dynobj, amt)); 923 if (p == NULL) 924 return false; 925 p->next = *head; 926 *head = p; 927 p->sec = sec; 928 p->count = 0; 929 p->pc_count = 0; 930 } 931 932 p->count += 1; 933 if (ELF32_R_TYPE (rel->r_info) == R_386_PC32) 934 p->pc_count += 1; 935 } 936 break; 937 938 /* This relocation describes the C++ object vtable hierarchy. 939 Reconstruct it for later use during GC. */ 940 case R_386_GNU_VTINHERIT: 941 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 942 return false; 943 break; 944 945 /* This relocation describes which C++ vtable entries are actually 946 used. Record for later use during GC. */ 947 case R_386_GNU_VTENTRY: 948 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset)) 949 return false; 950 break; 951 952 default: 953 break; 954 } 955 } 956 957 return true; 958} 959 960/* Return the section that should be marked against GC for a given 961 relocation. */ 962 963static asection * 964elf_i386_gc_mark_hook (abfd, info, rel, h, sym) 965 bfd *abfd; 966 struct bfd_link_info *info ATTRIBUTE_UNUSED; 967 Elf_Internal_Rela *rel; 968 struct elf_link_hash_entry *h; 969 Elf_Internal_Sym *sym; 970{ 971 if (h != NULL) 972 { 973 switch (ELF32_R_TYPE (rel->r_info)) 974 { 975 case R_386_GNU_VTINHERIT: 976 case R_386_GNU_VTENTRY: 977 break; 978 979 default: 980 switch (h->root.type) 981 { 982 case bfd_link_hash_defined: 983 case bfd_link_hash_defweak: 984 return h->root.u.def.section; 985 986 case bfd_link_hash_common: 987 return h->root.u.c.p->section; 988 989 default: 990 break; 991 } 992 } 993 } 994 else 995 { 996 return bfd_section_from_elf_index (abfd, sym->st_shndx); 997 } 998 999 return NULL; 1000} 1001 1002/* Update the got entry reference counts for the section being removed. */ 1003 1004static boolean 1005elf_i386_gc_sweep_hook (abfd, info, sec, relocs) 1006 bfd *abfd; 1007 struct bfd_link_info *info; 1008 asection *sec; 1009 const Elf_Internal_Rela *relocs; 1010{ 1011 Elf_Internal_Shdr *symtab_hdr; 1012 struct elf_link_hash_entry **sym_hashes; 1013 bfd_signed_vma *local_got_refcounts; 1014 const Elf_Internal_Rela *rel, *relend; 1015 unsigned long r_symndx; 1016 struct elf_link_hash_entry *h; 1017 1018 elf_section_data (sec)->local_dynrel = NULL; 1019 1020 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1021 sym_hashes = elf_sym_hashes (abfd); 1022 local_got_refcounts = elf_local_got_refcounts (abfd); 1023 1024 relend = relocs + sec->reloc_count; 1025 for (rel = relocs; rel < relend; rel++) 1026 switch (ELF32_R_TYPE (rel->r_info)) 1027 { 1028 case R_386_GOT32: 1029 case R_386_GOTOFF: 1030 case R_386_GOTPC: 1031 r_symndx = ELF32_R_SYM (rel->r_info); 1032 if (r_symndx >= symtab_hdr->sh_info) 1033 { 1034 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1035 if (h->got.refcount > 0) 1036 h->got.refcount -= 1; 1037 } 1038 else if (local_got_refcounts != NULL) 1039 { 1040 if (local_got_refcounts[r_symndx] > 0) 1041 local_got_refcounts[r_symndx] -= 1; 1042 } 1043 break; 1044 1045 case R_386_32: 1046 case R_386_PC32: 1047 r_symndx = ELF32_R_SYM (rel->r_info); 1048 if (r_symndx >= symtab_hdr->sh_info) 1049 { 1050 struct elf_i386_link_hash_entry *eh; 1051 struct elf_i386_dyn_relocs **pp; 1052 struct elf_i386_dyn_relocs *p; 1053 1054 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1055 1056 if (!info->shared && h->plt.refcount > 0) 1057 h->plt.refcount -= 1; 1058 1059 eh = (struct elf_i386_link_hash_entry *) h; 1060 1061 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next) 1062 if (p->sec == sec) 1063 { 1064 if (ELF32_R_TYPE (rel->r_info) == R_386_PC32) 1065 p->pc_count -= 1; 1066 p->count -= 1; 1067 if (p->count == 0) 1068 *pp = p->next; 1069 break; 1070 } 1071 } 1072 break; 1073 1074 case R_386_PLT32: 1075 r_symndx = ELF32_R_SYM (rel->r_info); 1076 if (r_symndx >= symtab_hdr->sh_info) 1077 { 1078 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1079 if (h->plt.refcount > 0) 1080 h->plt.refcount -= 1; 1081 } 1082 break; 1083 1084 default: 1085 break; 1086 } 1087 1088 return true; 1089} 1090 1091/* Adjust a symbol defined by a dynamic object and referenced by a 1092 regular object. The current definition is in some section of the 1093 dynamic object, but we're not including those sections. We have to 1094 change the definition to something the rest of the link can 1095 understand. */ 1096 1097static boolean 1098elf_i386_adjust_dynamic_symbol (info, h) 1099 struct bfd_link_info *info; 1100 struct elf_link_hash_entry *h; 1101{ 1102 struct elf_i386_link_hash_table *htab; 1103 struct elf_i386_link_hash_entry * eh; 1104 struct elf_i386_dyn_relocs *p; 1105 asection *s; 1106 unsigned int power_of_two; 1107 1108 /* If this is a function, put it in the procedure linkage table. We 1109 will fill in the contents of the procedure linkage table later, 1110 when we know the address of the .got section. */ 1111 if (h->type == STT_FUNC 1112 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0) 1113 { 1114 if (h->plt.refcount <= 0 1115 || (! info->shared 1116 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0 1117 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0 1118 && h->root.type != bfd_link_hash_undefweak 1119 && h->root.type != bfd_link_hash_undefined)) 1120 { 1121 /* This case can occur if we saw a PLT32 reloc in an input 1122 file, but the symbol was never referred to by a dynamic 1123 object, or if all references were garbage collected. In 1124 such a case, we don't actually need to build a procedure 1125 linkage table, and we can just do a PC32 reloc instead. */ 1126 h->plt.offset = (bfd_vma) -1; 1127 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT; 1128 } 1129 1130 return true; 1131 } 1132 else 1133 /* It's possible that we incorrectly decided a .plt reloc was 1134 needed for an R_386_PC32 reloc to a non-function sym in 1135 check_relocs. We can't decide accurately between function and 1136 non-function syms in check-relocs; Objects loaded later in 1137 the link may change h->type. So fix it now. */ 1138 h->plt.offset = (bfd_vma) -1; 1139 1140 /* If this is a weak symbol, and there is a real definition, the 1141 processor independent code will have arranged for us to see the 1142 real definition first, and we can just use the same value. */ 1143 if (h->weakdef != NULL) 1144 { 1145 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined 1146 || h->weakdef->root.type == bfd_link_hash_defweak); 1147 h->root.u.def.section = h->weakdef->root.u.def.section; 1148 h->root.u.def.value = h->weakdef->root.u.def.value; 1149 return true; 1150 } 1151 1152 /* This is a reference to a symbol defined by a dynamic object which 1153 is not a function. */ 1154 1155 /* If we are creating a shared library, we must presume that the 1156 only references to the symbol are via the global offset table. 1157 For such cases we need not do anything here; the relocations will 1158 be handled correctly by relocate_section. */ 1159 if (info->shared) 1160 return true; 1161 1162 /* If there are no references to this symbol that do not use the 1163 GOT, we don't need to generate a copy reloc. */ 1164 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0) 1165 return true; 1166 1167 /* If -z nocopyreloc was given, we won't generate them either. */ 1168 if (info->nocopyreloc) 1169 { 1170 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF; 1171 return true; 1172 } 1173 1174 eh = (struct elf_i386_link_hash_entry *) h; 1175 for (p = eh->dyn_relocs; p != NULL; p = p->next) 1176 { 1177 s = p->sec->output_section; 1178 if (s != NULL && (s->flags & SEC_READONLY) != 0) 1179 break; 1180 } 1181 1182 /* If we didn't find any dynamic relocs in read-only sections, then 1183 we'll be keeping the dynamic relocs and avoiding the copy reloc. */ 1184 if (p == NULL) 1185 { 1186 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF; 1187 return true; 1188 } 1189 1190 /* We must allocate the symbol in our .dynbss section, which will 1191 become part of the .bss section of the executable. There will be 1192 an entry for this symbol in the .dynsym section. The dynamic 1193 object will contain position independent code, so all references 1194 from the dynamic object to this symbol will go through the global 1195 offset table. The dynamic linker will use the .dynsym entry to 1196 determine the address it must put in the global offset table, so 1197 both the dynamic object and the regular object will refer to the 1198 same memory location for the variable. */ 1199 1200 htab = elf_i386_hash_table (info); 1201 1202 /* We must generate a R_386_COPY reloc to tell the dynamic linker to 1203 copy the initial value out of the dynamic object and into the 1204 runtime process image. */ 1205 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) 1206 { 1207 htab->srelbss->_raw_size += sizeof (Elf32_External_Rel); 1208 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY; 1209 } 1210 1211 /* We need to figure out the alignment required for this symbol. I 1212 have no idea how ELF linkers handle this. */ 1213 power_of_two = bfd_log2 (h->size); 1214 if (power_of_two > 3) 1215 power_of_two = 3; 1216 1217 /* Apply the required alignment. */ 1218 s = htab->sdynbss; 1219 s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two)); 1220 if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s)) 1221 { 1222 if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two)) 1223 return false; 1224 } 1225 1226 /* Define the symbol as being at this point in the section. */ 1227 h->root.u.def.section = s; 1228 h->root.u.def.value = s->_raw_size; 1229 1230 /* Increment the section size to make room for the symbol. */ 1231 s->_raw_size += h->size; 1232 1233 return true; 1234} 1235 1236/* This is the condition under which elf_i386_finish_dynamic_symbol 1237 will be called from elflink.h. If elflink.h doesn't call our 1238 finish_dynamic_symbol routine, we'll need to do something about 1239 initializing any .plt and .got entries in elf_i386_relocate_section. */ 1240#define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \ 1241 ((DYN) \ 1242 && ((INFO)->shared \ 1243 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \ 1244 && ((H)->dynindx != -1 \ 1245 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)) 1246 1247/* Allocate space in .plt, .got and associated reloc sections for 1248 dynamic relocs. */ 1249 1250static boolean 1251allocate_dynrelocs (h, inf) 1252 struct elf_link_hash_entry *h; 1253 PTR inf; 1254{ 1255 struct bfd_link_info *info; 1256 struct elf_i386_link_hash_table *htab; 1257 struct elf_i386_link_hash_entry *eh; 1258 struct elf_i386_dyn_relocs *p; 1259 1260 if (h->root.type == bfd_link_hash_indirect 1261 || h->root.type == bfd_link_hash_warning) 1262 return true; 1263 1264 info = (struct bfd_link_info *) inf; 1265 htab = elf_i386_hash_table (info); 1266 1267 if (htab->elf.dynamic_sections_created 1268 && h->plt.refcount > 0) 1269 { 1270 /* Make sure this symbol is output as a dynamic symbol. 1271 Undefined weak syms won't yet be marked as dynamic. */ 1272 if (h->dynindx == -1 1273 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) 1274 { 1275 if (! bfd_elf32_link_record_dynamic_symbol (info, h)) 1276 return false; 1277 } 1278 1279 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h)) 1280 { 1281 asection *s = htab->splt; 1282 1283 /* If this is the first .plt entry, make room for the special 1284 first entry. */ 1285 if (s->_raw_size == 0) 1286 s->_raw_size += PLT_ENTRY_SIZE; 1287 1288 h->plt.offset = s->_raw_size; 1289 1290 /* If this symbol is not defined in a regular file, and we are 1291 not generating a shared library, then set the symbol to this 1292 location in the .plt. This is required to make function 1293 pointers compare as equal between the normal executable and 1294 the shared library. */ 1295 if (! info->shared 1296 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 1297 { 1298 h->root.u.def.section = s; 1299 h->root.u.def.value = h->plt.offset; 1300 } 1301 1302 /* Make room for this entry. */ 1303 s->_raw_size += PLT_ENTRY_SIZE; 1304 1305 /* We also need to make an entry in the .got.plt section, which 1306 will be placed in the .got section by the linker script. */ 1307 htab->sgotplt->_raw_size += 4; 1308 1309 /* We also need to make an entry in the .rel.plt section. */ 1310 htab->srelplt->_raw_size += sizeof (Elf32_External_Rel); 1311 } 1312 else 1313 { 1314 h->plt.offset = (bfd_vma) -1; 1315 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT; 1316 } 1317 } 1318 else 1319 { 1320 h->plt.offset = (bfd_vma) -1; 1321 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT; 1322 } 1323 1324 if (h->got.refcount > 0) 1325 { 1326 asection *s; 1327 boolean dyn; 1328 1329 /* Make sure this symbol is output as a dynamic symbol. 1330 Undefined weak syms won't yet be marked as dynamic. */ 1331 if (h->dynindx == -1 1332 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) 1333 { 1334 if (! bfd_elf32_link_record_dynamic_symbol (info, h)) 1335 return false; 1336 } 1337 1338 s = htab->sgot; 1339 h->got.offset = s->_raw_size; 1340 s->_raw_size += 4; 1341 dyn = htab->elf.dynamic_sections_created; 1342 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)) 1343 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel); 1344 } 1345 else 1346 h->got.offset = (bfd_vma) -1; 1347 1348 eh = (struct elf_i386_link_hash_entry *) h; 1349 if (eh->dyn_relocs == NULL) 1350 return true; 1351 1352 /* In the shared -Bsymbolic case, discard space allocated for 1353 dynamic pc-relative relocs against symbols which turn out to be 1354 defined in regular objects. For the normal shared case, discard 1355 space for pc-relative relocs that have become local due to symbol 1356 visibility changes. */ 1357 1358 if (info->shared) 1359 { 1360 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0 1361 && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0 1362 || info->symbolic)) 1363 { 1364 struct elf_i386_dyn_relocs **pp; 1365 1366 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) 1367 { 1368 p->count -= p->pc_count; 1369 p->pc_count = 0; 1370 if (p->count == 0) 1371 *pp = p->next; 1372 else 1373 pp = &p->next; 1374 } 1375 } 1376 } 1377 else 1378 { 1379 /* For the non-shared case, discard space for relocs against 1380 symbols which turn out to need copy relocs or are not 1381 dynamic. */ 1382 1383 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0 1384 && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0 1385 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 1386 || (htab->elf.dynamic_sections_created 1387 && (h->root.type == bfd_link_hash_undefweak 1388 || h->root.type == bfd_link_hash_undefined)))) 1389 { 1390 /* Make sure this symbol is output as a dynamic symbol. 1391 Undefined weak syms won't yet be marked as dynamic. */ 1392 if (h->dynindx == -1 1393 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) 1394 { 1395 if (! bfd_elf32_link_record_dynamic_symbol (info, h)) 1396 return false; 1397 } 1398 1399 /* If that succeeded, we know we'll be keeping all the 1400 relocs. */ 1401 if (h->dynindx != -1) 1402 goto keep; 1403 } 1404 1405 eh->dyn_relocs = NULL; 1406 1407 keep: ; 1408 } 1409 1410 /* Finally, allocate space. */ 1411 for (p = eh->dyn_relocs; p != NULL; p = p->next) 1412 { 1413 asection *sreloc = elf_section_data (p->sec)->sreloc; 1414 sreloc->_raw_size += p->count * sizeof (Elf32_External_Rel); 1415 } 1416 1417 return true; 1418} 1419 1420/* Find any dynamic relocs that apply to read-only sections. */ 1421 1422static boolean 1423readonly_dynrelocs (h, inf) 1424 struct elf_link_hash_entry *h; 1425 PTR inf; 1426{ 1427 struct elf_i386_link_hash_entry *eh; 1428 struct elf_i386_dyn_relocs *p; 1429 1430 eh = (struct elf_i386_link_hash_entry *) h; 1431 for (p = eh->dyn_relocs; p != NULL; p = p->next) 1432 { 1433 asection *s = p->sec->output_section; 1434 1435 if (s != NULL && (s->flags & SEC_READONLY) != 0) 1436 { 1437 struct bfd_link_info *info = (struct bfd_link_info *) inf; 1438 1439 info->flags |= DF_TEXTREL; 1440 1441 /* Not an error, just cut short the traversal. */ 1442 return false; 1443 } 1444 } 1445 return true; 1446} 1447 1448/* Set the sizes of the dynamic sections. */ 1449 1450static boolean 1451elf_i386_size_dynamic_sections (output_bfd, info) 1452 bfd *output_bfd ATTRIBUTE_UNUSED; 1453 struct bfd_link_info *info; 1454{ 1455 struct elf_i386_link_hash_table *htab; 1456 bfd *dynobj; 1457 asection *s; 1458 boolean relocs; 1459 bfd *ibfd; 1460 1461 htab = elf_i386_hash_table (info); 1462 dynobj = htab->elf.dynobj; 1463 if (dynobj == NULL) 1464 abort (); 1465 1466 if (htab->elf.dynamic_sections_created) 1467 { 1468 /* Set the contents of the .interp section to the interpreter. */ 1469 if (! info->shared) 1470 { 1471 s = bfd_get_section_by_name (dynobj, ".interp"); 1472 if (s == NULL) 1473 abort (); 1474 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER; 1475 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 1476 } 1477 } 1478 1479 /* Set up .got offsets for local syms, and space for local dynamic 1480 relocs. */ 1481 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) 1482 { 1483 bfd_signed_vma *local_got; 1484 bfd_signed_vma *end_local_got; 1485 bfd_size_type locsymcount; 1486 Elf_Internal_Shdr *symtab_hdr; 1487 asection *srel; 1488 1489 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour) 1490 continue; 1491 1492 for (s = ibfd->sections; s != NULL; s = s->next) 1493 { 1494 struct elf_i386_dyn_relocs *p; 1495 1496 for (p = *((struct elf_i386_dyn_relocs **) 1497 &elf_section_data (s)->local_dynrel); 1498 p != NULL; 1499 p = p->next) 1500 { 1501 if (!bfd_is_abs_section (p->sec) 1502 && bfd_is_abs_section (p->sec->output_section)) 1503 { 1504 /* Input section has been discarded, either because 1505 it is a copy of a linkonce section or due to 1506 linker script /DISCARD/, so we'll be discarding 1507 the relocs too. */ 1508 } 1509 else if (p->count != 0) 1510 { 1511 srel = elf_section_data (p->sec)->sreloc; 1512 srel->_raw_size += p->count * sizeof (Elf32_External_Rel); 1513 if ((p->sec->output_section->flags & SEC_READONLY) != 0) 1514 info->flags |= DF_TEXTREL; 1515 } 1516 } 1517 } 1518 1519 local_got = elf_local_got_refcounts (ibfd); 1520 if (!local_got) 1521 continue; 1522 1523 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr; 1524 locsymcount = symtab_hdr->sh_info; 1525 end_local_got = local_got + locsymcount; 1526 s = htab->sgot; 1527 srel = htab->srelgot; 1528 for (; local_got < end_local_got; ++local_got) 1529 { 1530 if (*local_got > 0) 1531 { 1532 *local_got = s->_raw_size; 1533 s->_raw_size += 4; 1534 if (info->shared) 1535 srel->_raw_size += sizeof (Elf32_External_Rel); 1536 } 1537 else 1538 *local_got = (bfd_vma) -1; 1539 } 1540 } 1541 1542 /* Allocate global sym .plt and .got entries, and space for global 1543 sym dynamic relocs. */ 1544 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info); 1545 1546 /* We now have determined the sizes of the various dynamic sections. 1547 Allocate memory for them. */ 1548 relocs = false; 1549 for (s = dynobj->sections; s != NULL; s = s->next) 1550 { 1551 if ((s->flags & SEC_LINKER_CREATED) == 0) 1552 continue; 1553 1554 if (s == htab->splt 1555 || s == htab->sgot 1556 || s == htab->sgotplt) 1557 { 1558 /* Strip this section if we don't need it; see the 1559 comment below. */ 1560 } 1561 else if (strncmp (bfd_get_section_name (dynobj, s), ".rel", 4) == 0) 1562 { 1563 if (s->_raw_size != 0 && s != htab->srelplt) 1564 relocs = true; 1565 1566 /* We use the reloc_count field as a counter if we need 1567 to copy relocs into the output file. */ 1568 s->reloc_count = 0; 1569 } 1570 else 1571 { 1572 /* It's not one of our sections, so don't allocate space. */ 1573 continue; 1574 } 1575 1576 if (s->_raw_size == 0) 1577 { 1578 /* If we don't need this section, strip it from the 1579 output file. This is mostly to handle .rel.bss and 1580 .rel.plt. We must create both sections in 1581 create_dynamic_sections, because they must be created 1582 before the linker maps input sections to output 1583 sections. The linker does that before 1584 adjust_dynamic_symbol is called, and it is that 1585 function which decides whether anything needs to go 1586 into these sections. */ 1587 1588 _bfd_strip_section_from_output (info, s); 1589 continue; 1590 } 1591 1592 /* Allocate memory for the section contents. We use bfd_zalloc 1593 here in case unused entries are not reclaimed before the 1594 section's contents are written out. This should not happen, 1595 but this way if it does, we get a R_386_NONE reloc instead 1596 of garbage. */ 1597 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size); 1598 if (s->contents == NULL) 1599 return false; 1600 } 1601 1602 if (htab->elf.dynamic_sections_created) 1603 { 1604 /* Add some entries to the .dynamic section. We fill in the 1605 values later, in elf_i386_finish_dynamic_sections, but we 1606 must add the entries now so that we get the correct size for 1607 the .dynamic section. The DT_DEBUG entry is filled in by the 1608 dynamic linker and used by the debugger. */ 1609#define add_dynamic_entry(TAG, VAL) \ 1610 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL)) 1611 1612 if (! info->shared) 1613 { 1614 if (!add_dynamic_entry (DT_DEBUG, 0)) 1615 return false; 1616 } 1617 1618 if (htab->splt->_raw_size != 0) 1619 { 1620 if (!add_dynamic_entry (DT_PLTGOT, 0) 1621 || !add_dynamic_entry (DT_PLTRELSZ, 0) 1622 || !add_dynamic_entry (DT_PLTREL, DT_REL) 1623 || !add_dynamic_entry (DT_JMPREL, 0)) 1624 return false; 1625 } 1626 1627 if (relocs) 1628 { 1629 if (!add_dynamic_entry (DT_REL, 0) 1630 || !add_dynamic_entry (DT_RELSZ, 0) 1631 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel))) 1632 return false; 1633 1634 /* If any dynamic relocs apply to a read-only section, 1635 then we need a DT_TEXTREL entry. */ 1636 if ((info->flags & DF_TEXTREL) == 0) 1637 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, 1638 (PTR) info); 1639 1640 if ((info->flags & DF_TEXTREL) != 0) 1641 { 1642 if (!add_dynamic_entry (DT_TEXTREL, 0)) 1643 return false; 1644 } 1645 } 1646 } 1647#undef add_dynamic_entry 1648 1649 return true; 1650} 1651 1652/* Set the correct type for an x86 ELF section. We do this by the 1653 section name, which is a hack, but ought to work. */ 1654 1655static boolean 1656elf_i386_fake_sections (abfd, hdr, sec) 1657 bfd *abfd ATTRIBUTE_UNUSED; 1658 Elf32_Internal_Shdr *hdr; 1659 asection *sec; 1660{ 1661 register const char *name; 1662 1663 name = bfd_get_section_name (abfd, sec); 1664 1665 /* This is an ugly, but unfortunately necessary hack that is 1666 needed when producing EFI binaries on x86. It tells 1667 elf.c:elf_fake_sections() not to consider ".reloc" as a section 1668 containing ELF relocation info. We need this hack in order to 1669 be able to generate ELF binaries that can be translated into 1670 EFI applications (which are essentially COFF objects). Those 1671 files contain a COFF ".reloc" section inside an ELFNN object, 1672 which would normally cause BFD to segfault because it would 1673 attempt to interpret this section as containing relocation 1674 entries for section "oc". With this hack enabled, ".reloc" 1675 will be treated as a normal data section, which will avoid the 1676 segfault. However, you won't be able to create an ELFNN binary 1677 with a section named "oc" that needs relocations, but that's 1678 the kind of ugly side-effects you get when detecting section 1679 types based on their names... In practice, this limitation is 1680 unlikely to bite. */ 1681 if (strcmp (name, ".reloc") == 0) 1682 hdr->sh_type = SHT_PROGBITS; 1683 1684 return true; 1685} 1686 1687/* Relocate an i386 ELF section. */ 1688 1689static boolean 1690elf_i386_relocate_section (output_bfd, info, input_bfd, input_section, 1691 contents, relocs, local_syms, local_sections) 1692 bfd *output_bfd; 1693 struct bfd_link_info *info; 1694 bfd *input_bfd; 1695 asection *input_section; 1696 bfd_byte *contents; 1697 Elf_Internal_Rela *relocs; 1698 Elf_Internal_Sym *local_syms; 1699 asection **local_sections; 1700{ 1701 struct elf_i386_link_hash_table *htab; 1702 Elf_Internal_Shdr *symtab_hdr; 1703 struct elf_link_hash_entry **sym_hashes; 1704 bfd_vma *local_got_offsets; 1705 Elf_Internal_Rela *rel; 1706 Elf_Internal_Rela *relend; 1707 1708 htab = elf_i386_hash_table (info); 1709 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 1710 sym_hashes = elf_sym_hashes (input_bfd); 1711 local_got_offsets = elf_local_got_offsets (input_bfd); 1712 1713 rel = relocs; 1714 relend = relocs + input_section->reloc_count; 1715 for (; rel < relend; rel++) 1716 { 1717 int r_type; 1718 reloc_howto_type *howto; 1719 unsigned long r_symndx; 1720 struct elf_link_hash_entry *h; 1721 Elf_Internal_Sym *sym; 1722 asection *sec; 1723 bfd_vma off; 1724 bfd_vma relocation; 1725 boolean unresolved_reloc; 1726 bfd_reloc_status_type r; 1727 unsigned int indx; 1728 1729 r_type = ELF32_R_TYPE (rel->r_info); 1730 if (r_type == (int) R_386_GNU_VTINHERIT 1731 || r_type == (int) R_386_GNU_VTENTRY) 1732 continue; 1733 1734 if ((indx = (unsigned) r_type) >= R_386_standard 1735 && ((indx = (unsigned) r_type - R_386_ext_offset) - R_386_standard 1736 >= R_386_ext - R_386_standard)) 1737 { 1738 bfd_set_error (bfd_error_bad_value); 1739 return false; 1740 } 1741 howto = elf_howto_table + indx; 1742 1743 r_symndx = ELF32_R_SYM (rel->r_info); 1744 1745 if (info->relocateable) 1746 { 1747 /* This is a relocatable link. We don't have to change 1748 anything, unless the reloc is against a section symbol, 1749 in which case we have to adjust according to where the 1750 section symbol winds up in the output section. */ 1751 if (r_symndx < symtab_hdr->sh_info) 1752 { 1753 sym = local_syms + r_symndx; 1754 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) 1755 { 1756 bfd_vma val; 1757 1758 sec = local_sections[r_symndx]; 1759 val = bfd_get_32 (input_bfd, contents + rel->r_offset); 1760 val += sec->output_offset + sym->st_value; 1761 bfd_put_32 (input_bfd, val, contents + rel->r_offset); 1762 } 1763 } 1764 continue; 1765 } 1766 1767 /* This is a final link. */ 1768 h = NULL; 1769 sym = NULL; 1770 sec = NULL; 1771 unresolved_reloc = false; 1772 if (r_symndx < symtab_hdr->sh_info) 1773 { 1774 sym = local_syms + r_symndx; 1775 sec = local_sections[r_symndx]; 1776 relocation = (sec->output_section->vma 1777 + sec->output_offset 1778 + sym->st_value); 1779 if ((sec->flags & SEC_MERGE) 1780 && ELF_ST_TYPE (sym->st_info) == STT_SECTION) 1781 { 1782 asection *msec; 1783 bfd_vma addend; 1784 1785 if (howto->src_mask != 0xffffffff) 1786 { 1787 (*_bfd_error_handler) 1788 (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"), 1789 bfd_archive_filename (input_bfd), 1790 bfd_get_section_name (input_bfd, input_section), 1791 (long) rel->r_offset, howto->name); 1792 return false; 1793 } 1794 1795 addend = bfd_get_32 (input_bfd, contents + rel->r_offset); 1796 msec = sec; 1797 addend = 1798 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend) 1799 - relocation; 1800 addend += msec->output_section->vma + msec->output_offset; 1801 bfd_put_32 (input_bfd, addend, contents + rel->r_offset); 1802 } 1803 } 1804 else 1805 { 1806 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1807 while (h->root.type == bfd_link_hash_indirect 1808 || h->root.type == bfd_link_hash_warning) 1809 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1810 1811 relocation = 0; 1812 if (h->root.type == bfd_link_hash_defined 1813 || h->root.type == bfd_link_hash_defweak) 1814 { 1815 sec = h->root.u.def.section; 1816 if (sec->output_section == NULL) 1817 /* Set a flag that will be cleared later if we find a 1818 relocation value for this symbol. output_section 1819 is typically NULL for symbols satisfied by a shared 1820 library. */ 1821 unresolved_reloc = true; 1822 else 1823 relocation = (h->root.u.def.value 1824 + sec->output_section->vma 1825 + sec->output_offset); 1826 } 1827 else if (h->root.type == bfd_link_hash_undefweak) 1828 ; 1829 else if (info->shared 1830 && (!info->symbolic || info->allow_shlib_undefined) 1831 && !info->no_undefined 1832 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT) 1833 ; 1834 else 1835 { 1836 if (! ((*info->callbacks->undefined_symbol) 1837 (info, h->root.root.string, input_bfd, 1838 input_section, rel->r_offset, 1839 (!info->shared || info->no_undefined 1840 || ELF_ST_VISIBILITY (h->other))))) 1841 return false; 1842 } 1843 } 1844 1845 switch (r_type) 1846 { 1847 case R_386_GOT32: 1848 /* Relocation is to the entry for this symbol in the global 1849 offset table. */ 1850 if (htab->sgot == NULL) 1851 abort (); 1852 1853 if (h != NULL) 1854 { 1855 boolean dyn; 1856 1857 off = h->got.offset; 1858 dyn = htab->elf.dynamic_sections_created; 1859 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h) 1860 || (info->shared 1861 && (info->symbolic 1862 || h->dynindx == -1 1863 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)) 1864 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))) 1865 { 1866 /* This is actually a static link, or it is a 1867 -Bsymbolic link and the symbol is defined 1868 locally, or the symbol was forced to be local 1869 because of a version file. We must initialize 1870 this entry in the global offset table. Since the 1871 offset must always be a multiple of 4, we use the 1872 least significant bit to record whether we have 1873 initialized it already. 1874 1875 When doing a dynamic link, we create a .rel.got 1876 relocation entry to initialize the value. This 1877 is done in the finish_dynamic_symbol routine. */ 1878 if ((off & 1) != 0) 1879 off &= ~1; 1880 else 1881 { 1882 bfd_put_32 (output_bfd, relocation, 1883 htab->sgot->contents + off); 1884 h->got.offset |= 1; 1885 } 1886 } 1887 else 1888 unresolved_reloc = false; 1889 } 1890 else 1891 { 1892 if (local_got_offsets == NULL) 1893 abort (); 1894 1895 off = local_got_offsets[r_symndx]; 1896 1897 /* The offset must always be a multiple of 4. We use 1898 the least significant bit to record whether we have 1899 already generated the necessary reloc. */ 1900 if ((off & 1) != 0) 1901 off &= ~1; 1902 else 1903 { 1904 bfd_put_32 (output_bfd, relocation, 1905 htab->sgot->contents + off); 1906 1907 if (info->shared) 1908 { 1909 asection *srelgot; 1910 Elf_Internal_Rel outrel; 1911 Elf32_External_Rel *loc; 1912 1913 srelgot = htab->srelgot; 1914 if (srelgot == NULL) 1915 abort (); 1916 1917 outrel.r_offset = (htab->sgot->output_section->vma 1918 + htab->sgot->output_offset 1919 + off); 1920 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE); 1921 loc = (Elf32_External_Rel *) srelgot->contents; 1922 loc += srelgot->reloc_count++; 1923 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc); 1924 } 1925 1926 local_got_offsets[r_symndx] |= 1; 1927 } 1928 } 1929 1930 if (off >= (bfd_vma) -2) 1931 abort (); 1932 1933 relocation = htab->sgot->output_offset + off; 1934 break; 1935 1936 case R_386_GOTOFF: 1937 /* Relocation is relative to the start of the global offset 1938 table. */ 1939 1940 /* Note that sgot->output_offset is not involved in this 1941 calculation. We always want the start of .got. If we 1942 defined _GLOBAL_OFFSET_TABLE in a different way, as is 1943 permitted by the ABI, we might have to change this 1944 calculation. */ 1945 relocation -= htab->sgot->output_section->vma; 1946 break; 1947 1948 case R_386_GOTPC: 1949 /* Use global offset table as symbol value. */ 1950 relocation = htab->sgot->output_section->vma; 1951 unresolved_reloc = false; 1952 break; 1953 1954 case R_386_PLT32: 1955 /* Relocation is to the entry for this symbol in the 1956 procedure linkage table. */ 1957 1958 /* Resolve a PLT32 reloc against a local symbol directly, 1959 without using the procedure linkage table. */ 1960 if (h == NULL) 1961 break; 1962 1963 if (h->plt.offset == (bfd_vma) -1 1964 || htab->splt == NULL) 1965 { 1966 /* We didn't make a PLT entry for this symbol. This 1967 happens when statically linking PIC code, or when 1968 using -Bsymbolic. */ 1969 break; 1970 } 1971 1972 relocation = (htab->splt->output_section->vma 1973 + htab->splt->output_offset 1974 + h->plt.offset); 1975 unresolved_reloc = false; 1976 break; 1977 1978 case R_386_32: 1979 case R_386_PC32: 1980 /* r_symndx will be zero only for relocs against symbols 1981 from removed linkonce sections, or sections discarded by 1982 a linker script. */ 1983 if (r_symndx == 0 1984 || (input_section->flags & SEC_ALLOC) == 0) 1985 break; 1986 1987 if ((info->shared 1988 && (r_type != R_386_PC32 1989 || (h != NULL 1990 && h->dynindx != -1 1991 && (! info->symbolic 1992 || (h->elf_link_hash_flags 1993 & ELF_LINK_HASH_DEF_REGULAR) == 0)))) 1994 || (!info->shared 1995 && h != NULL 1996 && h->dynindx != -1 1997 && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0 1998 && (((h->elf_link_hash_flags 1999 & ELF_LINK_HASH_DEF_DYNAMIC) != 0 2000 && (h->elf_link_hash_flags 2001 & ELF_LINK_HASH_DEF_REGULAR) == 0) 2002 || h->root.type == bfd_link_hash_undefweak 2003 || h->root.type == bfd_link_hash_undefined))) 2004 { 2005 Elf_Internal_Rel outrel; 2006 boolean skip, relocate; 2007 asection *sreloc; 2008 Elf32_External_Rel *loc; 2009 2010 /* When generating a shared object, these relocations 2011 are copied into the output file to be resolved at run 2012 time. */ 2013 2014 skip = false; 2015 relocate = false; 2016 2017 outrel.r_offset = 2018 _bfd_elf_section_offset (output_bfd, info, input_section, 2019 rel->r_offset); 2020 if (outrel.r_offset == (bfd_vma) -1) 2021 skip = true; 2022 else if (outrel.r_offset == (bfd_vma) -2) 2023 skip = true, relocate = true; 2024 outrel.r_offset += (input_section->output_section->vma 2025 + input_section->output_offset); 2026 2027 if (skip) 2028 memset (&outrel, 0, sizeof outrel); 2029 else if (h != NULL 2030 && h->dynindx != -1 2031 && (r_type == R_386_PC32 2032 || !info->shared 2033 || !info->symbolic 2034 || (h->elf_link_hash_flags 2035 & ELF_LINK_HASH_DEF_REGULAR) == 0)) 2036 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type); 2037 else 2038 { 2039 /* This symbol is local, or marked to become local. */ 2040 relocate = true; 2041 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE); 2042 } 2043 2044 sreloc = elf_section_data (input_section)->sreloc; 2045 if (sreloc == NULL) 2046 abort (); 2047 2048 loc = (Elf32_External_Rel *) sreloc->contents; 2049 loc += sreloc->reloc_count++; 2050 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc); 2051 2052 /* If this reloc is against an external symbol, we do 2053 not want to fiddle with the addend. Otherwise, we 2054 need to include the symbol value so that it becomes 2055 an addend for the dynamic reloc. */ 2056 if (! relocate) 2057 continue; 2058 } 2059 break; 2060 2061 default: 2062 break; 2063 } 2064 2065 /* FIXME: Why do we allow debugging sections to escape this error? 2066 More importantly, why do we not emit dynamic relocs for 2067 R_386_32 above in debugging sections (which are ! SEC_ALLOC)? 2068 If we had emitted the dynamic reloc, we could remove the 2069 fudge here. */ 2070 if (unresolved_reloc 2071 && !(info->shared 2072 && (input_section->flags & SEC_DEBUGGING) != 0 2073 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0)) 2074 (*_bfd_error_handler) 2075 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"), 2076 bfd_archive_filename (input_bfd), 2077 bfd_get_section_name (input_bfd, input_section), 2078 (long) rel->r_offset, 2079 h->root.root.string); 2080 2081 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 2082 contents, rel->r_offset, 2083 relocation, (bfd_vma) 0); 2084 2085 if (r != bfd_reloc_ok) 2086 { 2087 const char *name; 2088 2089 if (h != NULL) 2090 name = h->root.root.string; 2091 else 2092 { 2093 name = bfd_elf_string_from_elf_section (input_bfd, 2094 symtab_hdr->sh_link, 2095 sym->st_name); 2096 if (name == NULL) 2097 return false; 2098 if (*name == '\0') 2099 name = bfd_section_name (input_bfd, sec); 2100 } 2101 2102 if (r == bfd_reloc_overflow) 2103 { 2104 2105 if (! ((*info->callbacks->reloc_overflow) 2106 (info, name, howto->name, (bfd_vma) 0, 2107 input_bfd, input_section, rel->r_offset))) 2108 return false; 2109 } 2110 else 2111 { 2112 (*_bfd_error_handler) 2113 (_("%s(%s+0x%lx): reloc against `%s': error %d"), 2114 bfd_archive_filename (input_bfd), 2115 bfd_get_section_name (input_bfd, input_section), 2116 (long) rel->r_offset, name, (int) r); 2117 return false; 2118 } 2119 } 2120 } 2121 2122 return true; 2123} 2124 2125/* Finish up dynamic symbol handling. We set the contents of various 2126 dynamic sections here. */ 2127 2128static boolean 2129elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym) 2130 bfd *output_bfd; 2131 struct bfd_link_info *info; 2132 struct elf_link_hash_entry *h; 2133 Elf_Internal_Sym *sym; 2134{ 2135 struct elf_i386_link_hash_table *htab; 2136 2137 htab = elf_i386_hash_table (info); 2138 2139 if (h->plt.offset != (bfd_vma) -1) 2140 { 2141 bfd_vma plt_index; 2142 bfd_vma got_offset; 2143 Elf_Internal_Rel rel; 2144 Elf32_External_Rel *loc; 2145 2146 /* This symbol has an entry in the procedure linkage table. Set 2147 it up. */ 2148 2149 if (h->dynindx == -1 2150 || htab->splt == NULL 2151 || htab->sgotplt == NULL 2152 || htab->srelplt == NULL) 2153 abort (); 2154 2155 /* Get the index in the procedure linkage table which 2156 corresponds to this symbol. This is the index of this symbol 2157 in all the symbols for which we are making plt entries. The 2158 first entry in the procedure linkage table is reserved. */ 2159 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1; 2160 2161 /* Get the offset into the .got table of the entry that 2162 corresponds to this function. Each .got entry is 4 bytes. 2163 The first three are reserved. */ 2164 got_offset = (plt_index + 3) * 4; 2165 2166 /* Fill in the entry in the procedure linkage table. */ 2167 if (! info->shared) 2168 { 2169 memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry, 2170 PLT_ENTRY_SIZE); 2171 bfd_put_32 (output_bfd, 2172 (htab->sgotplt->output_section->vma 2173 + htab->sgotplt->output_offset 2174 + got_offset), 2175 htab->splt->contents + h->plt.offset + 2); 2176 } 2177 else 2178 { 2179 memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry, 2180 PLT_ENTRY_SIZE); 2181 bfd_put_32 (output_bfd, got_offset, 2182 htab->splt->contents + h->plt.offset + 2); 2183 } 2184 2185 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel), 2186 htab->splt->contents + h->plt.offset + 7); 2187 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE), 2188 htab->splt->contents + h->plt.offset + 12); 2189 2190 /* Fill in the entry in the global offset table. */ 2191 bfd_put_32 (output_bfd, 2192 (htab->splt->output_section->vma 2193 + htab->splt->output_offset 2194 + h->plt.offset 2195 + 6), 2196 htab->sgotplt->contents + got_offset); 2197 2198 /* Fill in the entry in the .rel.plt section. */ 2199 rel.r_offset = (htab->sgotplt->output_section->vma 2200 + htab->sgotplt->output_offset 2201 + got_offset); 2202 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT); 2203 loc = (Elf32_External_Rel *) htab->srelplt->contents + plt_index; 2204 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); 2205 2206 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 2207 { 2208 /* Mark the symbol as undefined, rather than as defined in 2209 the .plt section. Leave the value alone. This is a clue 2210 for the dynamic linker, to make function pointer 2211 comparisons work between an application and shared 2212 library. */ 2213 sym->st_shndx = SHN_UNDEF; 2214 } 2215 } 2216 2217 if (h->got.offset != (bfd_vma) -1) 2218 { 2219 Elf_Internal_Rel rel; 2220 Elf32_External_Rel *loc; 2221 2222 /* This symbol has an entry in the global offset table. Set it 2223 up. */ 2224 2225 if (htab->sgot == NULL || htab->srelgot == NULL) 2226 abort (); 2227 2228 rel.r_offset = (htab->sgot->output_section->vma 2229 + htab->sgot->output_offset 2230 + (h->got.offset & ~(bfd_vma) 1)); 2231 2232 /* If this is a static link, or it is a -Bsymbolic link and the 2233 symbol is defined locally or was forced to be local because 2234 of a version file, we just want to emit a RELATIVE reloc. 2235 The entry in the global offset table will already have been 2236 initialized in the relocate_section function. */ 2237 if (info->shared 2238 && (info->symbolic 2239 || h->dynindx == -1 2240 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)) 2241 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)) 2242 { 2243 BFD_ASSERT((h->got.offset & 1) != 0); 2244 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE); 2245 } 2246 else 2247 { 2248 BFD_ASSERT((h->got.offset & 1) == 0); 2249 bfd_put_32 (output_bfd, (bfd_vma) 0, 2250 htab->sgot->contents + h->got.offset); 2251 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT); 2252 } 2253 2254 loc = (Elf32_External_Rel *) htab->srelgot->contents; 2255 loc += htab->srelgot->reloc_count++; 2256 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); 2257 } 2258 2259 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0) 2260 { 2261 Elf_Internal_Rel rel; 2262 Elf32_External_Rel *loc; 2263 2264 /* This symbol needs a copy reloc. Set it up. */ 2265 2266 if (h->dynindx == -1 2267 || (h->root.type != bfd_link_hash_defined 2268 && h->root.type != bfd_link_hash_defweak) 2269 || htab->srelbss == NULL) 2270 abort (); 2271 2272 rel.r_offset = (h->root.u.def.value 2273 + h->root.u.def.section->output_section->vma 2274 + h->root.u.def.section->output_offset); 2275 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY); 2276 loc = (Elf32_External_Rel *) htab->srelbss->contents; 2277 loc += htab->srelbss->reloc_count++; 2278 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); 2279 } 2280 2281 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */ 2282 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 2283 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 2284 sym->st_shndx = SHN_ABS; 2285 2286 return true; 2287} 2288 2289/* Used to decide how to sort relocs in an optimal manner for the 2290 dynamic linker, before writing them out. */ 2291 2292static enum elf_reloc_type_class 2293elf_i386_reloc_type_class (rela) 2294 const Elf_Internal_Rela *rela; 2295{ 2296 switch ((int) ELF32_R_TYPE (rela->r_info)) 2297 { 2298 case R_386_RELATIVE: 2299 return reloc_class_relative; 2300 case R_386_JUMP_SLOT: 2301 return reloc_class_plt; 2302 case R_386_COPY: 2303 return reloc_class_copy; 2304 default: 2305 return reloc_class_normal; 2306 } 2307} 2308 2309/* Finish up the dynamic sections. */ 2310 2311static boolean 2312elf_i386_finish_dynamic_sections (output_bfd, info) 2313 bfd *output_bfd; 2314 struct bfd_link_info *info; 2315{ 2316 struct elf_i386_link_hash_table *htab; 2317 bfd *dynobj; 2318 asection *sdyn; 2319 2320 htab = elf_i386_hash_table (info); 2321 dynobj = htab->elf.dynobj; 2322 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 2323 2324 if (htab->elf.dynamic_sections_created) 2325 { 2326 Elf32_External_Dyn *dyncon, *dynconend; 2327 2328 if (sdyn == NULL || htab->sgot == NULL) 2329 abort (); 2330 2331 dyncon = (Elf32_External_Dyn *) sdyn->contents; 2332 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size); 2333 for (; dyncon < dynconend; dyncon++) 2334 { 2335 Elf_Internal_Dyn dyn; 2336 asection *s; 2337 2338 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 2339 2340 switch (dyn.d_tag) 2341 { 2342 default: 2343 continue; 2344 2345 case DT_PLTGOT: 2346 dyn.d_un.d_ptr = htab->sgot->output_section->vma; 2347 break; 2348 2349 case DT_JMPREL: 2350 dyn.d_un.d_ptr = htab->srelplt->output_section->vma; 2351 break; 2352 2353 case DT_PLTRELSZ: 2354 s = htab->srelplt->output_section; 2355 if (s->_cooked_size != 0) 2356 dyn.d_un.d_val = s->_cooked_size; 2357 else 2358 dyn.d_un.d_val = s->_raw_size; 2359 break; 2360 2361 case DT_RELSZ: 2362 /* My reading of the SVR4 ABI indicates that the 2363 procedure linkage table relocs (DT_JMPREL) should be 2364 included in the overall relocs (DT_REL). This is 2365 what Solaris does. However, UnixWare can not handle 2366 that case. Therefore, we override the DT_RELSZ entry 2367 here to make it not include the JMPREL relocs. Since 2368 the linker script arranges for .rel.plt to follow all 2369 other relocation sections, we don't have to worry 2370 about changing the DT_REL entry. */ 2371 if (htab->srelplt != NULL) 2372 { 2373 s = htab->srelplt->output_section; 2374 if (s->_cooked_size != 0) 2375 dyn.d_un.d_val -= s->_cooked_size; 2376 else 2377 dyn.d_un.d_val -= s->_raw_size; 2378 } 2379 break; 2380 } 2381 2382 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 2383 } 2384 2385 /* Fill in the first entry in the procedure linkage table. */ 2386 if (htab->splt && htab->splt->_raw_size > 0) 2387 { 2388 if (info->shared) 2389 memcpy (htab->splt->contents, 2390 elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE); 2391 else 2392 { 2393 memcpy (htab->splt->contents, 2394 elf_i386_plt0_entry, PLT_ENTRY_SIZE); 2395 bfd_put_32 (output_bfd, 2396 (htab->sgotplt->output_section->vma 2397 + htab->sgotplt->output_offset 2398 + 4), 2399 htab->splt->contents + 2); 2400 bfd_put_32 (output_bfd, 2401 (htab->sgotplt->output_section->vma 2402 + htab->sgotplt->output_offset 2403 + 8), 2404 htab->splt->contents + 8); 2405 } 2406 2407 /* UnixWare sets the entsize of .plt to 4, although that doesn't 2408 really seem like the right value. */ 2409 elf_section_data (htab->splt->output_section) 2410 ->this_hdr.sh_entsize = 4; 2411 } 2412 } 2413 2414 if (htab->sgotplt) 2415 { 2416 /* Fill in the first three entries in the global offset table. */ 2417 if (htab->sgotplt->_raw_size > 0) 2418 { 2419 bfd_put_32 (output_bfd, 2420 (sdyn == NULL ? (bfd_vma) 0 2421 : sdyn->output_section->vma + sdyn->output_offset), 2422 htab->sgotplt->contents); 2423 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 4); 2424 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8); 2425 } 2426 2427 elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4; 2428 } 2429 return true; 2430} 2431 2432#define TARGET_LITTLE_SYM bfd_elf32_i386_vec 2433#define TARGET_LITTLE_NAME "elf32-i386" 2434#define ELF_ARCH bfd_arch_i386 2435#define ELF_MACHINE_CODE EM_386 2436#define ELF_MAXPAGESIZE 0x1000 2437 2438#define elf_backend_can_gc_sections 1 2439#define elf_backend_can_refcount 1 2440#define elf_backend_want_got_plt 1 2441#define elf_backend_plt_readonly 1 2442#define elf_backend_want_plt_sym 0 2443#define elf_backend_got_header_size 12 2444#define elf_backend_plt_header_size PLT_ENTRY_SIZE 2445 2446#define elf_info_to_howto elf_i386_info_to_howto 2447#define elf_info_to_howto_rel elf_i386_info_to_howto_rel 2448 2449#define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name 2450#define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create 2451#define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup 2452 2453#define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol 2454#define elf_backend_check_relocs elf_i386_check_relocs 2455#define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol 2456#define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections 2457#define elf_backend_fake_sections elf_i386_fake_sections 2458#define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections 2459#define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol 2460#define elf_backend_gc_mark_hook elf_i386_gc_mark_hook 2461#define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook 2462#define elf_backend_grok_prstatus elf_i386_grok_prstatus 2463#define elf_backend_grok_psinfo elf_i386_grok_psinfo 2464#define elf_backend_reloc_type_class elf_i386_reloc_type_class 2465#define elf_backend_relocate_section elf_i386_relocate_section 2466#define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections 2467 2468#include "elf32-target.h" 2469