elf32-i386.c revision 94543
1/* Intel 80386/80486-specific support for 32-bit ELF 2 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 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 94543 2002-04-12 19:50:32Z 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 unsigned int strndx = elf_elfheader (abfd)->e_shstrndx; 857 unsigned int shnam = elf_section_data (sec)->rel_hdr.sh_name; 858 859 name = bfd_elf_string_from_elf_section (abfd, strndx, shnam); 860 if (name == NULL) 861 return false; 862 863 if (strncmp (name, ".rel", 4) != 0 864 || strcmp (bfd_get_section_name (abfd, sec), 865 name + 4) != 0) 866 { 867 (*_bfd_error_handler) 868 (_("%s: bad relocation section name `%s\'"), 869 bfd_archive_filename (abfd), name); 870 } 871 872 if (htab->elf.dynobj == NULL) 873 htab->elf.dynobj = abfd; 874 875 dynobj = htab->elf.dynobj; 876 sreloc = bfd_get_section_by_name (dynobj, name); 877 if (sreloc == NULL) 878 { 879 flagword flags; 880 881 sreloc = bfd_make_section (dynobj, name); 882 flags = (SEC_HAS_CONTENTS | SEC_READONLY 883 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 884 if ((sec->flags & SEC_ALLOC) != 0) 885 flags |= SEC_ALLOC | SEC_LOAD; 886 if (sreloc == NULL 887 || ! bfd_set_section_flags (dynobj, sreloc, flags) 888 || ! bfd_set_section_alignment (dynobj, sreloc, 2)) 889 return false; 890 } 891 elf_section_data (sec)->sreloc = sreloc; 892 } 893 894 /* If this is a global symbol, we count the number of 895 relocations we need for this symbol. */ 896 if (h != NULL) 897 { 898 head = &((struct elf_i386_link_hash_entry *) h)->dyn_relocs; 899 } 900 else 901 { 902 /* Track dynamic relocs needed for local syms too. 903 We really need local syms available to do this 904 easily. Oh well. */ 905 906 asection *s; 907 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec, 908 sec, r_symndx); 909 if (s == NULL) 910 return false; 911 912 head = ((struct elf_i386_dyn_relocs **) 913 &elf_section_data (s)->local_dynrel); 914 } 915 916 p = *head; 917 if (p == NULL || p->sec != sec) 918 { 919 bfd_size_type amt = sizeof *p; 920 p = ((struct elf_i386_dyn_relocs *) 921 bfd_alloc (htab->elf.dynobj, amt)); 922 if (p == NULL) 923 return false; 924 p->next = *head; 925 *head = p; 926 p->sec = sec; 927 p->count = 0; 928 p->pc_count = 0; 929 } 930 931 p->count += 1; 932 if (ELF32_R_TYPE (rel->r_info) == R_386_PC32) 933 p->pc_count += 1; 934 } 935 break; 936 937 /* This relocation describes the C++ object vtable hierarchy. 938 Reconstruct it for later use during GC. */ 939 case R_386_GNU_VTINHERIT: 940 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 941 return false; 942 break; 943 944 /* This relocation describes which C++ vtable entries are actually 945 used. Record for later use during GC. */ 946 case R_386_GNU_VTENTRY: 947 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset)) 948 return false; 949 break; 950 951 default: 952 break; 953 } 954 } 955 956 return true; 957} 958 959/* Return the section that should be marked against GC for a given 960 relocation. */ 961 962static asection * 963elf_i386_gc_mark_hook (abfd, info, rel, h, sym) 964 bfd *abfd; 965 struct bfd_link_info *info ATTRIBUTE_UNUSED; 966 Elf_Internal_Rela *rel; 967 struct elf_link_hash_entry *h; 968 Elf_Internal_Sym *sym; 969{ 970 if (h != NULL) 971 { 972 switch (ELF32_R_TYPE (rel->r_info)) 973 { 974 case R_386_GNU_VTINHERIT: 975 case R_386_GNU_VTENTRY: 976 break; 977 978 default: 979 switch (h->root.type) 980 { 981 case bfd_link_hash_defined: 982 case bfd_link_hash_defweak: 983 return h->root.u.def.section; 984 985 case bfd_link_hash_common: 986 return h->root.u.c.p->section; 987 988 default: 989 break; 990 } 991 } 992 } 993 else 994 { 995 return bfd_section_from_elf_index (abfd, sym->st_shndx); 996 } 997 998 return NULL; 999} 1000 1001/* Update the got entry reference counts for the section being removed. */ 1002 1003static boolean 1004elf_i386_gc_sweep_hook (abfd, info, sec, relocs) 1005 bfd *abfd; 1006 struct bfd_link_info *info; 1007 asection *sec; 1008 const Elf_Internal_Rela *relocs; 1009{ 1010 Elf_Internal_Shdr *symtab_hdr; 1011 struct elf_link_hash_entry **sym_hashes; 1012 bfd_signed_vma *local_got_refcounts; 1013 const Elf_Internal_Rela *rel, *relend; 1014 unsigned long r_symndx; 1015 struct elf_link_hash_entry *h; 1016 1017 elf_section_data (sec)->local_dynrel = NULL; 1018 1019 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1020 sym_hashes = elf_sym_hashes (abfd); 1021 local_got_refcounts = elf_local_got_refcounts (abfd); 1022 1023 relend = relocs + sec->reloc_count; 1024 for (rel = relocs; rel < relend; rel++) 1025 switch (ELF32_R_TYPE (rel->r_info)) 1026 { 1027 case R_386_GOT32: 1028 case R_386_GOTOFF: 1029 case R_386_GOTPC: 1030 r_symndx = ELF32_R_SYM (rel->r_info); 1031 if (r_symndx >= symtab_hdr->sh_info) 1032 { 1033 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1034 if (h->got.refcount > 0) 1035 h->got.refcount -= 1; 1036 } 1037 else if (local_got_refcounts != NULL) 1038 { 1039 if (local_got_refcounts[r_symndx] > 0) 1040 local_got_refcounts[r_symndx] -= 1; 1041 } 1042 break; 1043 1044 case R_386_32: 1045 case R_386_PC32: 1046 r_symndx = ELF32_R_SYM (rel->r_info); 1047 if (r_symndx >= symtab_hdr->sh_info) 1048 { 1049 struct elf_i386_link_hash_entry *eh; 1050 struct elf_i386_dyn_relocs **pp; 1051 struct elf_i386_dyn_relocs *p; 1052 1053 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1054 1055 if (!info->shared && h->plt.refcount > 0) 1056 h->plt.refcount -= 1; 1057 1058 eh = (struct elf_i386_link_hash_entry *) h; 1059 1060 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next) 1061 if (p->sec == sec) 1062 { 1063 if (ELF32_R_TYPE (rel->r_info) == R_386_PC32) 1064 p->pc_count -= 1; 1065 p->count -= 1; 1066 if (p->count == 0) 1067 *pp = p->next; 1068 break; 1069 } 1070 } 1071 break; 1072 1073 case R_386_PLT32: 1074 r_symndx = ELF32_R_SYM (rel->r_info); 1075 if (r_symndx >= symtab_hdr->sh_info) 1076 { 1077 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1078 if (h->plt.refcount > 0) 1079 h->plt.refcount -= 1; 1080 } 1081 break; 1082 1083 default: 1084 break; 1085 } 1086 1087 return true; 1088} 1089 1090/* Adjust a symbol defined by a dynamic object and referenced by a 1091 regular object. The current definition is in some section of the 1092 dynamic object, but we're not including those sections. We have to 1093 change the definition to something the rest of the link can 1094 understand. */ 1095 1096static boolean 1097elf_i386_adjust_dynamic_symbol (info, h) 1098 struct bfd_link_info *info; 1099 struct elf_link_hash_entry *h; 1100{ 1101 struct elf_i386_link_hash_table *htab; 1102 struct elf_i386_link_hash_entry * eh; 1103 struct elf_i386_dyn_relocs *p; 1104 asection *s; 1105 unsigned int power_of_two; 1106 1107 /* If this is a function, put it in the procedure linkage table. We 1108 will fill in the contents of the procedure linkage table later, 1109 when we know the address of the .got section. */ 1110 if (h->type == STT_FUNC 1111 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0) 1112 { 1113 if (h->plt.refcount <= 0 1114 || (! info->shared 1115 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0 1116 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0 1117 && h->root.type != bfd_link_hash_undefweak 1118 && h->root.type != bfd_link_hash_undefined)) 1119 { 1120 /* This case can occur if we saw a PLT32 reloc in an input 1121 file, but the symbol was never referred to by a dynamic 1122 object, or if all references were garbage collected. In 1123 such a case, we don't actually need to build a procedure 1124 linkage table, and we can just do a PC32 reloc instead. */ 1125 h->plt.offset = (bfd_vma) -1; 1126 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT; 1127 } 1128 1129 return true; 1130 } 1131 else 1132 /* It's possible that we incorrectly decided a .plt reloc was 1133 needed for an R_386_PC32 reloc to a non-function sym in 1134 check_relocs. We can't decide accurately between function and 1135 non-function syms in check-relocs; Objects loaded later in 1136 the link may change h->type. So fix it now. */ 1137 h->plt.offset = (bfd_vma) -1; 1138 1139 /* If this is a weak symbol, and there is a real definition, the 1140 processor independent code will have arranged for us to see the 1141 real definition first, and we can just use the same value. */ 1142 if (h->weakdef != NULL) 1143 { 1144 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined 1145 || h->weakdef->root.type == bfd_link_hash_defweak); 1146 h->root.u.def.section = h->weakdef->root.u.def.section; 1147 h->root.u.def.value = h->weakdef->root.u.def.value; 1148 return true; 1149 } 1150 1151 /* This is a reference to a symbol defined by a dynamic object which 1152 is not a function. */ 1153 1154 /* If we are creating a shared library, we must presume that the 1155 only references to the symbol are via the global offset table. 1156 For such cases we need not do anything here; the relocations will 1157 be handled correctly by relocate_section. */ 1158 if (info->shared) 1159 return true; 1160 1161 /* If there are no references to this symbol that do not use the 1162 GOT, we don't need to generate a copy reloc. */ 1163 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0) 1164 return true; 1165 1166 /* If -z nocopyreloc was given, we won't generate them either. */ 1167 if (info->nocopyreloc) 1168 { 1169 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF; 1170 return true; 1171 } 1172 1173 eh = (struct elf_i386_link_hash_entry *) h; 1174 for (p = eh->dyn_relocs; p != NULL; p = p->next) 1175 { 1176 s = p->sec->output_section; 1177 if (s != NULL && (s->flags & SEC_READONLY) != 0) 1178 break; 1179 } 1180 1181 /* If we didn't find any dynamic relocs in read-only sections, then 1182 we'll be keeping the dynamic relocs and avoiding the copy reloc. */ 1183 if (p == NULL) 1184 { 1185 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF; 1186 return true; 1187 } 1188 1189 /* We must allocate the symbol in our .dynbss section, which will 1190 become part of the .bss section of the executable. There will be 1191 an entry for this symbol in the .dynsym section. The dynamic 1192 object will contain position independent code, so all references 1193 from the dynamic object to this symbol will go through the global 1194 offset table. The dynamic linker will use the .dynsym entry to 1195 determine the address it must put in the global offset table, so 1196 both the dynamic object and the regular object will refer to the 1197 same memory location for the variable. */ 1198 1199 htab = elf_i386_hash_table (info); 1200 1201 /* We must generate a R_386_COPY reloc to tell the dynamic linker to 1202 copy the initial value out of the dynamic object and into the 1203 runtime process image. */ 1204 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) 1205 { 1206 htab->srelbss->_raw_size += sizeof (Elf32_External_Rel); 1207 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY; 1208 } 1209 1210 /* We need to figure out the alignment required for this symbol. I 1211 have no idea how ELF linkers handle this. */ 1212 power_of_two = bfd_log2 (h->size); 1213 if (power_of_two > 3) 1214 power_of_two = 3; 1215 1216 /* Apply the required alignment. */ 1217 s = htab->sdynbss; 1218 s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two)); 1219 if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s)) 1220 { 1221 if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two)) 1222 return false; 1223 } 1224 1225 /* Define the symbol as being at this point in the section. */ 1226 h->root.u.def.section = s; 1227 h->root.u.def.value = s->_raw_size; 1228 1229 /* Increment the section size to make room for the symbol. */ 1230 s->_raw_size += h->size; 1231 1232 return true; 1233} 1234 1235/* This is the condition under which elf_i386_finish_dynamic_symbol 1236 will be called from elflink.h. If elflink.h doesn't call our 1237 finish_dynamic_symbol routine, we'll need to do something about 1238 initializing any .plt and .got entries in elf_i386_relocate_section. */ 1239#define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \ 1240 ((DYN) \ 1241 && ((INFO)->shared \ 1242 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \ 1243 && ((H)->dynindx != -1 \ 1244 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)) 1245 1246/* Allocate space in .plt, .got and associated reloc sections for 1247 dynamic relocs. */ 1248 1249static boolean 1250allocate_dynrelocs (h, inf) 1251 struct elf_link_hash_entry *h; 1252 PTR inf; 1253{ 1254 struct bfd_link_info *info; 1255 struct elf_i386_link_hash_table *htab; 1256 struct elf_i386_link_hash_entry *eh; 1257 struct elf_i386_dyn_relocs *p; 1258 1259 if (h->root.type == bfd_link_hash_indirect) 1260 return true; 1261 1262 if (h->root.type == bfd_link_hash_warning) 1263 /* When warning symbols are created, they **replace** the "real" 1264 entry in the hash table, thus we never get to see the real 1265 symbol in a hash traversal. So look at it now. */ 1266 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1267 1268 info = (struct bfd_link_info *) inf; 1269 htab = elf_i386_hash_table (info); 1270 1271 if (htab->elf.dynamic_sections_created 1272 && h->plt.refcount > 0) 1273 { 1274 /* Make sure this symbol is output as a dynamic symbol. 1275 Undefined weak syms won't yet be marked as dynamic. */ 1276 if (h->dynindx == -1 1277 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) 1278 { 1279 if (! bfd_elf32_link_record_dynamic_symbol (info, h)) 1280 return false; 1281 } 1282 1283 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h)) 1284 { 1285 asection *s = htab->splt; 1286 1287 /* If this is the first .plt entry, make room for the special 1288 first entry. */ 1289 if (s->_raw_size == 0) 1290 s->_raw_size += PLT_ENTRY_SIZE; 1291 1292 h->plt.offset = s->_raw_size; 1293 1294 /* If this symbol is not defined in a regular file, and we are 1295 not generating a shared library, then set the symbol to this 1296 location in the .plt. This is required to make function 1297 pointers compare as equal between the normal executable and 1298 the shared library. */ 1299 if (! info->shared 1300 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 1301 { 1302 h->root.u.def.section = s; 1303 h->root.u.def.value = h->plt.offset; 1304 } 1305 1306 /* Make room for this entry. */ 1307 s->_raw_size += PLT_ENTRY_SIZE; 1308 1309 /* We also need to make an entry in the .got.plt section, which 1310 will be placed in the .got section by the linker script. */ 1311 htab->sgotplt->_raw_size += 4; 1312 1313 /* We also need to make an entry in the .rel.plt section. */ 1314 htab->srelplt->_raw_size += sizeof (Elf32_External_Rel); 1315 } 1316 else 1317 { 1318 h->plt.offset = (bfd_vma) -1; 1319 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT; 1320 } 1321 } 1322 else 1323 { 1324 h->plt.offset = (bfd_vma) -1; 1325 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT; 1326 } 1327 1328 if (h->got.refcount > 0) 1329 { 1330 asection *s; 1331 boolean dyn; 1332 1333 /* Make sure this symbol is output as a dynamic symbol. 1334 Undefined weak syms won't yet be marked as dynamic. */ 1335 if (h->dynindx == -1 1336 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) 1337 { 1338 if (! bfd_elf32_link_record_dynamic_symbol (info, h)) 1339 return false; 1340 } 1341 1342 s = htab->sgot; 1343 h->got.offset = s->_raw_size; 1344 s->_raw_size += 4; 1345 dyn = htab->elf.dynamic_sections_created; 1346 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)) 1347 htab->srelgot->_raw_size += sizeof (Elf32_External_Rel); 1348 } 1349 else 1350 h->got.offset = (bfd_vma) -1; 1351 1352 eh = (struct elf_i386_link_hash_entry *) h; 1353 if (eh->dyn_relocs == NULL) 1354 return true; 1355 1356 /* In the shared -Bsymbolic case, discard space allocated for 1357 dynamic pc-relative relocs against symbols which turn out to be 1358 defined in regular objects. For the normal shared case, discard 1359 space for pc-relative relocs that have become local due to symbol 1360 visibility changes. */ 1361 1362 if (info->shared) 1363 { 1364 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0 1365 && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0 1366 || info->symbolic)) 1367 { 1368 struct elf_i386_dyn_relocs **pp; 1369 1370 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) 1371 { 1372 p->count -= p->pc_count; 1373 p->pc_count = 0; 1374 if (p->count == 0) 1375 *pp = p->next; 1376 else 1377 pp = &p->next; 1378 } 1379 } 1380 } 1381 else 1382 { 1383 /* For the non-shared case, discard space for relocs against 1384 symbols which turn out to need copy relocs or are not 1385 dynamic. */ 1386 1387 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0 1388 && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0 1389 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 1390 || (htab->elf.dynamic_sections_created 1391 && (h->root.type == bfd_link_hash_undefweak 1392 || h->root.type == bfd_link_hash_undefined)))) 1393 { 1394 /* Make sure this symbol is output as a dynamic symbol. 1395 Undefined weak syms won't yet be marked as dynamic. */ 1396 if (h->dynindx == -1 1397 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) 1398 { 1399 if (! bfd_elf32_link_record_dynamic_symbol (info, h)) 1400 return false; 1401 } 1402 1403 /* If that succeeded, we know we'll be keeping all the 1404 relocs. */ 1405 if (h->dynindx != -1) 1406 goto keep; 1407 } 1408 1409 eh->dyn_relocs = NULL; 1410 1411 keep: ; 1412 } 1413 1414 /* Finally, allocate space. */ 1415 for (p = eh->dyn_relocs; p != NULL; p = p->next) 1416 { 1417 asection *sreloc = elf_section_data (p->sec)->sreloc; 1418 sreloc->_raw_size += p->count * sizeof (Elf32_External_Rel); 1419 } 1420 1421 return true; 1422} 1423 1424/* Find any dynamic relocs that apply to read-only sections. */ 1425 1426static boolean 1427readonly_dynrelocs (h, inf) 1428 struct elf_link_hash_entry *h; 1429 PTR inf; 1430{ 1431 struct elf_i386_link_hash_entry *eh; 1432 struct elf_i386_dyn_relocs *p; 1433 1434 if (h->root.type == bfd_link_hash_warning) 1435 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1436 1437 eh = (struct elf_i386_link_hash_entry *) h; 1438 for (p = eh->dyn_relocs; p != NULL; p = p->next) 1439 { 1440 asection *s = p->sec->output_section; 1441 1442 if (s != NULL && (s->flags & SEC_READONLY) != 0) 1443 { 1444 struct bfd_link_info *info = (struct bfd_link_info *) inf; 1445 1446 info->flags |= DF_TEXTREL; 1447 1448 /* Not an error, just cut short the traversal. */ 1449 return false; 1450 } 1451 } 1452 return true; 1453} 1454 1455/* Set the sizes of the dynamic sections. */ 1456 1457static boolean 1458elf_i386_size_dynamic_sections (output_bfd, info) 1459 bfd *output_bfd ATTRIBUTE_UNUSED; 1460 struct bfd_link_info *info; 1461{ 1462 struct elf_i386_link_hash_table *htab; 1463 bfd *dynobj; 1464 asection *s; 1465 boolean relocs; 1466 bfd *ibfd; 1467 1468 htab = elf_i386_hash_table (info); 1469 dynobj = htab->elf.dynobj; 1470 if (dynobj == NULL) 1471 abort (); 1472 1473 if (htab->elf.dynamic_sections_created) 1474 { 1475 /* Set the contents of the .interp section to the interpreter. */ 1476 if (! info->shared) 1477 { 1478 s = bfd_get_section_by_name (dynobj, ".interp"); 1479 if (s == NULL) 1480 abort (); 1481 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER; 1482 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 1483 } 1484 } 1485 1486 /* Set up .got offsets for local syms, and space for local dynamic 1487 relocs. */ 1488 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) 1489 { 1490 bfd_signed_vma *local_got; 1491 bfd_signed_vma *end_local_got; 1492 bfd_size_type locsymcount; 1493 Elf_Internal_Shdr *symtab_hdr; 1494 asection *srel; 1495 1496 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour) 1497 continue; 1498 1499 for (s = ibfd->sections; s != NULL; s = s->next) 1500 { 1501 struct elf_i386_dyn_relocs *p; 1502 1503 for (p = *((struct elf_i386_dyn_relocs **) 1504 &elf_section_data (s)->local_dynrel); 1505 p != NULL; 1506 p = p->next) 1507 { 1508 if (!bfd_is_abs_section (p->sec) 1509 && bfd_is_abs_section (p->sec->output_section)) 1510 { 1511 /* Input section has been discarded, either because 1512 it is a copy of a linkonce section or due to 1513 linker script /DISCARD/, so we'll be discarding 1514 the relocs too. */ 1515 } 1516 else if (p->count != 0) 1517 { 1518 srel = elf_section_data (p->sec)->sreloc; 1519 srel->_raw_size += p->count * sizeof (Elf32_External_Rel); 1520 if ((p->sec->output_section->flags & SEC_READONLY) != 0) 1521 info->flags |= DF_TEXTREL; 1522 } 1523 } 1524 } 1525 1526 local_got = elf_local_got_refcounts (ibfd); 1527 if (!local_got) 1528 continue; 1529 1530 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr; 1531 locsymcount = symtab_hdr->sh_info; 1532 end_local_got = local_got + locsymcount; 1533 s = htab->sgot; 1534 srel = htab->srelgot; 1535 for (; local_got < end_local_got; ++local_got) 1536 { 1537 if (*local_got > 0) 1538 { 1539 *local_got = s->_raw_size; 1540 s->_raw_size += 4; 1541 if (info->shared) 1542 srel->_raw_size += sizeof (Elf32_External_Rel); 1543 } 1544 else 1545 *local_got = (bfd_vma) -1; 1546 } 1547 } 1548 1549 /* Allocate global sym .plt and .got entries, and space for global 1550 sym dynamic relocs. */ 1551 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info); 1552 1553 /* We now have determined the sizes of the various dynamic sections. 1554 Allocate memory for them. */ 1555 relocs = false; 1556 for (s = dynobj->sections; s != NULL; s = s->next) 1557 { 1558 if ((s->flags & SEC_LINKER_CREATED) == 0) 1559 continue; 1560 1561 if (s == htab->splt 1562 || s == htab->sgot 1563 || s == htab->sgotplt) 1564 { 1565 /* Strip this section if we don't need it; see the 1566 comment below. */ 1567 } 1568 else if (strncmp (bfd_get_section_name (dynobj, s), ".rel", 4) == 0) 1569 { 1570 if (s->_raw_size != 0 && s != htab->srelplt) 1571 relocs = true; 1572 1573 /* We use the reloc_count field as a counter if we need 1574 to copy relocs into the output file. */ 1575 s->reloc_count = 0; 1576 } 1577 else 1578 { 1579 /* It's not one of our sections, so don't allocate space. */ 1580 continue; 1581 } 1582 1583 if (s->_raw_size == 0) 1584 { 1585 /* If we don't need this section, strip it from the 1586 output file. This is mostly to handle .rel.bss and 1587 .rel.plt. We must create both sections in 1588 create_dynamic_sections, because they must be created 1589 before the linker maps input sections to output 1590 sections. The linker does that before 1591 adjust_dynamic_symbol is called, and it is that 1592 function which decides whether anything needs to go 1593 into these sections. */ 1594 1595 _bfd_strip_section_from_output (info, s); 1596 continue; 1597 } 1598 1599 /* Allocate memory for the section contents. We use bfd_zalloc 1600 here in case unused entries are not reclaimed before the 1601 section's contents are written out. This should not happen, 1602 but this way if it does, we get a R_386_NONE reloc instead 1603 of garbage. */ 1604 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size); 1605 if (s->contents == NULL) 1606 return false; 1607 } 1608 1609 if (htab->elf.dynamic_sections_created) 1610 { 1611 /* Add some entries to the .dynamic section. We fill in the 1612 values later, in elf_i386_finish_dynamic_sections, but we 1613 must add the entries now so that we get the correct size for 1614 the .dynamic section. The DT_DEBUG entry is filled in by the 1615 dynamic linker and used by the debugger. */ 1616#define add_dynamic_entry(TAG, VAL) \ 1617 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL)) 1618 1619 if (! info->shared) 1620 { 1621 if (!add_dynamic_entry (DT_DEBUG, 0)) 1622 return false; 1623 } 1624 1625 if (htab->splt->_raw_size != 0) 1626 { 1627 if (!add_dynamic_entry (DT_PLTGOT, 0) 1628 || !add_dynamic_entry (DT_PLTRELSZ, 0) 1629 || !add_dynamic_entry (DT_PLTREL, DT_REL) 1630 || !add_dynamic_entry (DT_JMPREL, 0)) 1631 return false; 1632 } 1633 1634 if (relocs) 1635 { 1636 if (!add_dynamic_entry (DT_REL, 0) 1637 || !add_dynamic_entry (DT_RELSZ, 0) 1638 || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel))) 1639 return false; 1640 1641 /* If any dynamic relocs apply to a read-only section, 1642 then we need a DT_TEXTREL entry. */ 1643 if ((info->flags & DF_TEXTREL) == 0) 1644 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, 1645 (PTR) info); 1646 1647 if ((info->flags & DF_TEXTREL) != 0) 1648 { 1649 if (!add_dynamic_entry (DT_TEXTREL, 0)) 1650 return false; 1651 } 1652 } 1653 } 1654#undef add_dynamic_entry 1655 1656 return true; 1657} 1658 1659/* Set the correct type for an x86 ELF section. We do this by the 1660 section name, which is a hack, but ought to work. */ 1661 1662static boolean 1663elf_i386_fake_sections (abfd, hdr, sec) 1664 bfd *abfd ATTRIBUTE_UNUSED; 1665 Elf32_Internal_Shdr *hdr; 1666 asection *sec; 1667{ 1668 register const char *name; 1669 1670 name = bfd_get_section_name (abfd, sec); 1671 1672 /* This is an ugly, but unfortunately necessary hack that is 1673 needed when producing EFI binaries on x86. It tells 1674 elf.c:elf_fake_sections() not to consider ".reloc" as a section 1675 containing ELF relocation info. We need this hack in order to 1676 be able to generate ELF binaries that can be translated into 1677 EFI applications (which are essentially COFF objects). Those 1678 files contain a COFF ".reloc" section inside an ELFNN object, 1679 which would normally cause BFD to segfault because it would 1680 attempt to interpret this section as containing relocation 1681 entries for section "oc". With this hack enabled, ".reloc" 1682 will be treated as a normal data section, which will avoid the 1683 segfault. However, you won't be able to create an ELFNN binary 1684 with a section named "oc" that needs relocations, but that's 1685 the kind of ugly side-effects you get when detecting section 1686 types based on their names... In practice, this limitation is 1687 unlikely to bite. */ 1688 if (strcmp (name, ".reloc") == 0) 1689 hdr->sh_type = SHT_PROGBITS; 1690 1691 return true; 1692} 1693 1694/* Relocate an i386 ELF section. */ 1695 1696static boolean 1697elf_i386_relocate_section (output_bfd, info, input_bfd, input_section, 1698 contents, relocs, local_syms, local_sections) 1699 bfd *output_bfd; 1700 struct bfd_link_info *info; 1701 bfd *input_bfd; 1702 asection *input_section; 1703 bfd_byte *contents; 1704 Elf_Internal_Rela *relocs; 1705 Elf_Internal_Sym *local_syms; 1706 asection **local_sections; 1707{ 1708 struct elf_i386_link_hash_table *htab; 1709 Elf_Internal_Shdr *symtab_hdr; 1710 struct elf_link_hash_entry **sym_hashes; 1711 bfd_vma *local_got_offsets; 1712 Elf_Internal_Rela *rel; 1713 Elf_Internal_Rela *relend; 1714 1715 htab = elf_i386_hash_table (info); 1716 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 1717 sym_hashes = elf_sym_hashes (input_bfd); 1718 local_got_offsets = elf_local_got_offsets (input_bfd); 1719 1720 rel = relocs; 1721 relend = relocs + input_section->reloc_count; 1722 for (; rel < relend; rel++) 1723 { 1724 int r_type; 1725 reloc_howto_type *howto; 1726 unsigned long r_symndx; 1727 struct elf_link_hash_entry *h; 1728 Elf_Internal_Sym *sym; 1729 asection *sec; 1730 bfd_vma off; 1731 bfd_vma relocation; 1732 boolean unresolved_reloc; 1733 bfd_reloc_status_type r; 1734 unsigned int indx; 1735 1736 r_type = ELF32_R_TYPE (rel->r_info); 1737 if (r_type == (int) R_386_GNU_VTINHERIT 1738 || r_type == (int) R_386_GNU_VTENTRY) 1739 continue; 1740 1741 if ((indx = (unsigned) r_type) >= R_386_standard 1742 && ((indx = (unsigned) r_type - R_386_ext_offset) - R_386_standard 1743 >= R_386_ext - R_386_standard)) 1744 { 1745 bfd_set_error (bfd_error_bad_value); 1746 return false; 1747 } 1748 howto = elf_howto_table + indx; 1749 1750 r_symndx = ELF32_R_SYM (rel->r_info); 1751 1752 if (info->relocateable) 1753 { 1754 /* This is a relocatable link. We don't have to change 1755 anything, unless the reloc is against a section symbol, 1756 in which case we have to adjust according to where the 1757 section symbol winds up in the output section. */ 1758 if (r_symndx < symtab_hdr->sh_info) 1759 { 1760 sym = local_syms + r_symndx; 1761 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) 1762 { 1763 bfd_vma val; 1764 1765 sec = local_sections[r_symndx]; 1766 val = bfd_get_32 (input_bfd, contents + rel->r_offset); 1767 val += sec->output_offset + sym->st_value; 1768 bfd_put_32 (input_bfd, val, contents + rel->r_offset); 1769 } 1770 } 1771 continue; 1772 } 1773 1774 /* This is a final link. */ 1775 h = NULL; 1776 sym = NULL; 1777 sec = NULL; 1778 unresolved_reloc = false; 1779 if (r_symndx < symtab_hdr->sh_info) 1780 { 1781 sym = local_syms + r_symndx; 1782 sec = local_sections[r_symndx]; 1783 relocation = (sec->output_section->vma 1784 + sec->output_offset 1785 + sym->st_value); 1786 if ((sec->flags & SEC_MERGE) 1787 && ELF_ST_TYPE (sym->st_info) == STT_SECTION) 1788 { 1789 asection *msec; 1790 bfd_vma addend; 1791 1792 if (howto->src_mask != 0xffffffff) 1793 { 1794 (*_bfd_error_handler) 1795 (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"), 1796 bfd_archive_filename (input_bfd), 1797 bfd_get_section_name (input_bfd, input_section), 1798 (long) rel->r_offset, howto->name); 1799 return false; 1800 } 1801 1802 addend = bfd_get_32 (input_bfd, contents + rel->r_offset); 1803 msec = sec; 1804 addend = 1805 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend) 1806 - relocation; 1807 addend += msec->output_section->vma + msec->output_offset; 1808 bfd_put_32 (input_bfd, addend, contents + rel->r_offset); 1809 } 1810 } 1811 else 1812 { 1813 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1814 while (h->root.type == bfd_link_hash_indirect 1815 || h->root.type == bfd_link_hash_warning) 1816 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1817 1818 relocation = 0; 1819 if (h->root.type == bfd_link_hash_defined 1820 || h->root.type == bfd_link_hash_defweak) 1821 { 1822 sec = h->root.u.def.section; 1823 if (sec->output_section == NULL) 1824 /* Set a flag that will be cleared later if we find a 1825 relocation value for this symbol. output_section 1826 is typically NULL for symbols satisfied by a shared 1827 library. */ 1828 unresolved_reloc = true; 1829 else 1830 relocation = (h->root.u.def.value 1831 + sec->output_section->vma 1832 + sec->output_offset); 1833 } 1834 else if (h->root.type == bfd_link_hash_undefweak) 1835 ; 1836 else if (info->shared 1837 && (!info->symbolic || info->allow_shlib_undefined) 1838 && !info->no_undefined 1839 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT) 1840 ; 1841 else 1842 { 1843 if (! ((*info->callbacks->undefined_symbol) 1844 (info, h->root.root.string, input_bfd, 1845 input_section, rel->r_offset, 1846 (!info->shared || info->no_undefined 1847 || ELF_ST_VISIBILITY (h->other))))) 1848 return false; 1849 } 1850 } 1851 1852 switch (r_type) 1853 { 1854 case R_386_GOT32: 1855 /* Relocation is to the entry for this symbol in the global 1856 offset table. */ 1857 if (htab->sgot == NULL) 1858 abort (); 1859 1860 if (h != NULL) 1861 { 1862 boolean dyn; 1863 1864 off = h->got.offset; 1865 dyn = htab->elf.dynamic_sections_created; 1866 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h) 1867 || (info->shared 1868 && (info->symbolic 1869 || h->dynindx == -1 1870 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)) 1871 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))) 1872 { 1873 /* This is actually a static link, or it is a 1874 -Bsymbolic link and the symbol is defined 1875 locally, or the symbol was forced to be local 1876 because of a version file. We must initialize 1877 this entry in the global offset table. Since the 1878 offset must always be a multiple of 4, we use the 1879 least significant bit to record whether we have 1880 initialized it already. 1881 1882 When doing a dynamic link, we create a .rel.got 1883 relocation entry to initialize the value. This 1884 is done in the finish_dynamic_symbol routine. */ 1885 if ((off & 1) != 0) 1886 off &= ~1; 1887 else 1888 { 1889 bfd_put_32 (output_bfd, relocation, 1890 htab->sgot->contents + off); 1891 h->got.offset |= 1; 1892 } 1893 } 1894 else 1895 unresolved_reloc = false; 1896 } 1897 else 1898 { 1899 if (local_got_offsets == NULL) 1900 abort (); 1901 1902 off = local_got_offsets[r_symndx]; 1903 1904 /* The offset must always be a multiple of 4. We use 1905 the least significant bit to record whether we have 1906 already generated the necessary reloc. */ 1907 if ((off & 1) != 0) 1908 off &= ~1; 1909 else 1910 { 1911 bfd_put_32 (output_bfd, relocation, 1912 htab->sgot->contents + off); 1913 1914 if (info->shared) 1915 { 1916 asection *srelgot; 1917 Elf_Internal_Rel outrel; 1918 Elf32_External_Rel *loc; 1919 1920 srelgot = htab->srelgot; 1921 if (srelgot == NULL) 1922 abort (); 1923 1924 outrel.r_offset = (htab->sgot->output_section->vma 1925 + htab->sgot->output_offset 1926 + off); 1927 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE); 1928 loc = (Elf32_External_Rel *) srelgot->contents; 1929 loc += srelgot->reloc_count++; 1930 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc); 1931 } 1932 1933 local_got_offsets[r_symndx] |= 1; 1934 } 1935 } 1936 1937 if (off >= (bfd_vma) -2) 1938 abort (); 1939 1940 relocation = htab->sgot->output_offset + off; 1941 break; 1942 1943 case R_386_GOTOFF: 1944 /* Relocation is relative to the start of the global offset 1945 table. */ 1946 1947 /* Note that sgot->output_offset is not involved in this 1948 calculation. We always want the start of .got. If we 1949 defined _GLOBAL_OFFSET_TABLE in a different way, as is 1950 permitted by the ABI, we might have to change this 1951 calculation. */ 1952 relocation -= htab->sgot->output_section->vma; 1953 break; 1954 1955 case R_386_GOTPC: 1956 /* Use global offset table as symbol value. */ 1957 relocation = htab->sgot->output_section->vma; 1958 unresolved_reloc = false; 1959 break; 1960 1961 case R_386_PLT32: 1962 /* Relocation is to the entry for this symbol in the 1963 procedure linkage table. */ 1964 1965 /* Resolve a PLT32 reloc against a local symbol directly, 1966 without using the procedure linkage table. */ 1967 if (h == NULL) 1968 break; 1969 1970 if (h->plt.offset == (bfd_vma) -1 1971 || htab->splt == NULL) 1972 { 1973 /* We didn't make a PLT entry for this symbol. This 1974 happens when statically linking PIC code, or when 1975 using -Bsymbolic. */ 1976 break; 1977 } 1978 1979 relocation = (htab->splt->output_section->vma 1980 + htab->splt->output_offset 1981 + h->plt.offset); 1982 unresolved_reloc = false; 1983 break; 1984 1985 case R_386_32: 1986 case R_386_PC32: 1987 /* r_symndx will be zero only for relocs against symbols 1988 from removed linkonce sections, or sections discarded by 1989 a linker script. */ 1990 if (r_symndx == 0 1991 || (input_section->flags & SEC_ALLOC) == 0) 1992 break; 1993 1994 if ((info->shared 1995 && (r_type != R_386_PC32 1996 || (h != NULL 1997 && h->dynindx != -1 1998 && (! info->symbolic 1999 || (h->elf_link_hash_flags 2000 & ELF_LINK_HASH_DEF_REGULAR) == 0)))) 2001 || (!info->shared 2002 && h != NULL 2003 && h->dynindx != -1 2004 && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0 2005 && (((h->elf_link_hash_flags 2006 & ELF_LINK_HASH_DEF_DYNAMIC) != 0 2007 && (h->elf_link_hash_flags 2008 & ELF_LINK_HASH_DEF_REGULAR) == 0) 2009 || h->root.type == bfd_link_hash_undefweak 2010 || h->root.type == bfd_link_hash_undefined))) 2011 { 2012 Elf_Internal_Rel outrel; 2013 boolean skip, relocate; 2014 asection *sreloc; 2015 Elf32_External_Rel *loc; 2016 2017 /* When generating a shared object, these relocations 2018 are copied into the output file to be resolved at run 2019 time. */ 2020 2021 skip = false; 2022 relocate = false; 2023 2024 outrel.r_offset = 2025 _bfd_elf_section_offset (output_bfd, info, input_section, 2026 rel->r_offset); 2027 if (outrel.r_offset == (bfd_vma) -1) 2028 skip = true; 2029 else if (outrel.r_offset == (bfd_vma) -2) 2030 skip = true, relocate = true; 2031 outrel.r_offset += (input_section->output_section->vma 2032 + input_section->output_offset); 2033 2034 if (skip) 2035 memset (&outrel, 0, sizeof outrel); 2036 else if (h != NULL 2037 && h->dynindx != -1 2038 && (r_type == R_386_PC32 2039 || !info->shared 2040 || !info->symbolic 2041 || (h->elf_link_hash_flags 2042 & ELF_LINK_HASH_DEF_REGULAR) == 0)) 2043 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type); 2044 else 2045 { 2046 /* This symbol is local, or marked to become local. */ 2047 relocate = true; 2048 outrel.r_info = ELF32_R_INFO (0, R_386_RELATIVE); 2049 } 2050 2051 sreloc = elf_section_data (input_section)->sreloc; 2052 if (sreloc == NULL) 2053 abort (); 2054 2055 loc = (Elf32_External_Rel *) sreloc->contents; 2056 loc += sreloc->reloc_count++; 2057 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc); 2058 2059 /* If this reloc is against an external symbol, we do 2060 not want to fiddle with the addend. Otherwise, we 2061 need to include the symbol value so that it becomes 2062 an addend for the dynamic reloc. */ 2063 if (! relocate) 2064 continue; 2065 } 2066 break; 2067 2068 default: 2069 break; 2070 } 2071 2072 /* FIXME: Why do we allow debugging sections to escape this error? 2073 More importantly, why do we not emit dynamic relocs for 2074 R_386_32 above in debugging sections (which are ! SEC_ALLOC)? 2075 If we had emitted the dynamic reloc, we could remove the 2076 fudge here. */ 2077 if (unresolved_reloc 2078 && !(info->shared 2079 && (input_section->flags & SEC_DEBUGGING) != 0 2080 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0)) 2081 (*_bfd_error_handler) 2082 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"), 2083 bfd_archive_filename (input_bfd), 2084 bfd_get_section_name (input_bfd, input_section), 2085 (long) rel->r_offset, 2086 h->root.root.string); 2087 2088 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 2089 contents, rel->r_offset, 2090 relocation, (bfd_vma) 0); 2091 2092 if (r != bfd_reloc_ok) 2093 { 2094 const char *name; 2095 2096 if (h != NULL) 2097 name = h->root.root.string; 2098 else 2099 { 2100 name = bfd_elf_string_from_elf_section (input_bfd, 2101 symtab_hdr->sh_link, 2102 sym->st_name); 2103 if (name == NULL) 2104 return false; 2105 if (*name == '\0') 2106 name = bfd_section_name (input_bfd, sec); 2107 } 2108 2109 if (r == bfd_reloc_overflow) 2110 { 2111 2112 if (! ((*info->callbacks->reloc_overflow) 2113 (info, name, howto->name, (bfd_vma) 0, 2114 input_bfd, input_section, rel->r_offset))) 2115 return false; 2116 } 2117 else 2118 { 2119 (*_bfd_error_handler) 2120 (_("%s(%s+0x%lx): reloc against `%s': error %d"), 2121 bfd_archive_filename (input_bfd), 2122 bfd_get_section_name (input_bfd, input_section), 2123 (long) rel->r_offset, name, (int) r); 2124 return false; 2125 } 2126 } 2127 } 2128 2129 return true; 2130} 2131 2132/* Finish up dynamic symbol handling. We set the contents of various 2133 dynamic sections here. */ 2134 2135static boolean 2136elf_i386_finish_dynamic_symbol (output_bfd, info, h, sym) 2137 bfd *output_bfd; 2138 struct bfd_link_info *info; 2139 struct elf_link_hash_entry *h; 2140 Elf_Internal_Sym *sym; 2141{ 2142 struct elf_i386_link_hash_table *htab; 2143 2144 htab = elf_i386_hash_table (info); 2145 2146 if (h->plt.offset != (bfd_vma) -1) 2147 { 2148 bfd_vma plt_index; 2149 bfd_vma got_offset; 2150 Elf_Internal_Rel rel; 2151 Elf32_External_Rel *loc; 2152 2153 /* This symbol has an entry in the procedure linkage table. Set 2154 it up. */ 2155 2156 if (h->dynindx == -1 2157 || htab->splt == NULL 2158 || htab->sgotplt == NULL 2159 || htab->srelplt == NULL) 2160 abort (); 2161 2162 /* Get the index in the procedure linkage table which 2163 corresponds to this symbol. This is the index of this symbol 2164 in all the symbols for which we are making plt entries. The 2165 first entry in the procedure linkage table is reserved. */ 2166 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1; 2167 2168 /* Get the offset into the .got table of the entry that 2169 corresponds to this function. Each .got entry is 4 bytes. 2170 The first three are reserved. */ 2171 got_offset = (plt_index + 3) * 4; 2172 2173 /* Fill in the entry in the procedure linkage table. */ 2174 if (! info->shared) 2175 { 2176 memcpy (htab->splt->contents + h->plt.offset, elf_i386_plt_entry, 2177 PLT_ENTRY_SIZE); 2178 bfd_put_32 (output_bfd, 2179 (htab->sgotplt->output_section->vma 2180 + htab->sgotplt->output_offset 2181 + got_offset), 2182 htab->splt->contents + h->plt.offset + 2); 2183 } 2184 else 2185 { 2186 memcpy (htab->splt->contents + h->plt.offset, elf_i386_pic_plt_entry, 2187 PLT_ENTRY_SIZE); 2188 bfd_put_32 (output_bfd, got_offset, 2189 htab->splt->contents + h->plt.offset + 2); 2190 } 2191 2192 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rel), 2193 htab->splt->contents + h->plt.offset + 7); 2194 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE), 2195 htab->splt->contents + h->plt.offset + 12); 2196 2197 /* Fill in the entry in the global offset table. */ 2198 bfd_put_32 (output_bfd, 2199 (htab->splt->output_section->vma 2200 + htab->splt->output_offset 2201 + h->plt.offset 2202 + 6), 2203 htab->sgotplt->contents + got_offset); 2204 2205 /* Fill in the entry in the .rel.plt section. */ 2206 rel.r_offset = (htab->sgotplt->output_section->vma 2207 + htab->sgotplt->output_offset 2208 + got_offset); 2209 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_JUMP_SLOT); 2210 loc = (Elf32_External_Rel *) htab->srelplt->contents + plt_index; 2211 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); 2212 2213 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0) 2214 { 2215 /* Mark the symbol as undefined, rather than as defined in 2216 the .plt section. Leave the value alone. This is a clue 2217 for the dynamic linker, to make function pointer 2218 comparisons work between an application and shared 2219 library. */ 2220 sym->st_shndx = SHN_UNDEF; 2221 } 2222 } 2223 2224 if (h->got.offset != (bfd_vma) -1) 2225 { 2226 Elf_Internal_Rel rel; 2227 Elf32_External_Rel *loc; 2228 2229 /* This symbol has an entry in the global offset table. Set it 2230 up. */ 2231 2232 if (htab->sgot == NULL || htab->srelgot == NULL) 2233 abort (); 2234 2235 rel.r_offset = (htab->sgot->output_section->vma 2236 + htab->sgot->output_offset 2237 + (h->got.offset & ~(bfd_vma) 1)); 2238 2239 /* If this is a static link, or it is a -Bsymbolic link and the 2240 symbol is defined locally or was forced to be local because 2241 of a version file, we just want to emit a RELATIVE reloc. 2242 The entry in the global offset table will already have been 2243 initialized in the relocate_section function. */ 2244 if (info->shared 2245 && (info->symbolic 2246 || h->dynindx == -1 2247 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)) 2248 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)) 2249 { 2250 BFD_ASSERT((h->got.offset & 1) != 0); 2251 rel.r_info = ELF32_R_INFO (0, R_386_RELATIVE); 2252 } 2253 else 2254 { 2255 BFD_ASSERT((h->got.offset & 1) == 0); 2256 bfd_put_32 (output_bfd, (bfd_vma) 0, 2257 htab->sgot->contents + h->got.offset); 2258 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_GLOB_DAT); 2259 } 2260 2261 loc = (Elf32_External_Rel *) htab->srelgot->contents; 2262 loc += htab->srelgot->reloc_count++; 2263 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); 2264 } 2265 2266 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0) 2267 { 2268 Elf_Internal_Rel rel; 2269 Elf32_External_Rel *loc; 2270 2271 /* This symbol needs a copy reloc. Set it up. */ 2272 2273 if (h->dynindx == -1 2274 || (h->root.type != bfd_link_hash_defined 2275 && h->root.type != bfd_link_hash_defweak) 2276 || htab->srelbss == NULL) 2277 abort (); 2278 2279 rel.r_offset = (h->root.u.def.value 2280 + h->root.u.def.section->output_section->vma 2281 + h->root.u.def.section->output_offset); 2282 rel.r_info = ELF32_R_INFO (h->dynindx, R_386_COPY); 2283 loc = (Elf32_External_Rel *) htab->srelbss->contents; 2284 loc += htab->srelbss->reloc_count++; 2285 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); 2286 } 2287 2288 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */ 2289 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 2290 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 2291 sym->st_shndx = SHN_ABS; 2292 2293 return true; 2294} 2295 2296/* Used to decide how to sort relocs in an optimal manner for the 2297 dynamic linker, before writing them out. */ 2298 2299static enum elf_reloc_type_class 2300elf_i386_reloc_type_class (rela) 2301 const Elf_Internal_Rela *rela; 2302{ 2303 switch ((int) ELF32_R_TYPE (rela->r_info)) 2304 { 2305 case R_386_RELATIVE: 2306 return reloc_class_relative; 2307 case R_386_JUMP_SLOT: 2308 return reloc_class_plt; 2309 case R_386_COPY: 2310 return reloc_class_copy; 2311 default: 2312 return reloc_class_normal; 2313 } 2314} 2315 2316/* Finish up the dynamic sections. */ 2317 2318static boolean 2319elf_i386_finish_dynamic_sections (output_bfd, info) 2320 bfd *output_bfd; 2321 struct bfd_link_info *info; 2322{ 2323 struct elf_i386_link_hash_table *htab; 2324 bfd *dynobj; 2325 asection *sdyn; 2326 2327 htab = elf_i386_hash_table (info); 2328 dynobj = htab->elf.dynobj; 2329 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 2330 2331 if (htab->elf.dynamic_sections_created) 2332 { 2333 Elf32_External_Dyn *dyncon, *dynconend; 2334 2335 if (sdyn == NULL || htab->sgot == NULL) 2336 abort (); 2337 2338 dyncon = (Elf32_External_Dyn *) sdyn->contents; 2339 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size); 2340 for (; dyncon < dynconend; dyncon++) 2341 { 2342 Elf_Internal_Dyn dyn; 2343 asection *s; 2344 2345 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 2346 2347 switch (dyn.d_tag) 2348 { 2349 default: 2350 continue; 2351 2352 case DT_PLTGOT: 2353 dyn.d_un.d_ptr = htab->sgot->output_section->vma; 2354 break; 2355 2356 case DT_JMPREL: 2357 dyn.d_un.d_ptr = htab->srelplt->output_section->vma; 2358 break; 2359 2360 case DT_PLTRELSZ: 2361 s = htab->srelplt->output_section; 2362 if (s->_cooked_size != 0) 2363 dyn.d_un.d_val = s->_cooked_size; 2364 else 2365 dyn.d_un.d_val = s->_raw_size; 2366 break; 2367 2368 case DT_RELSZ: 2369 /* My reading of the SVR4 ABI indicates that the 2370 procedure linkage table relocs (DT_JMPREL) should be 2371 included in the overall relocs (DT_REL). This is 2372 what Solaris does. However, UnixWare can not handle 2373 that case. Therefore, we override the DT_RELSZ entry 2374 here to make it not include the JMPREL relocs. Since 2375 the linker script arranges for .rel.plt to follow all 2376 other relocation sections, we don't have to worry 2377 about changing the DT_REL entry. */ 2378 if (htab->srelplt != NULL) 2379 { 2380 s = htab->srelplt->output_section; 2381 if (s->_cooked_size != 0) 2382 dyn.d_un.d_val -= s->_cooked_size; 2383 else 2384 dyn.d_un.d_val -= s->_raw_size; 2385 } 2386 break; 2387 } 2388 2389 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 2390 } 2391 2392 /* Fill in the first entry in the procedure linkage table. */ 2393 if (htab->splt && htab->splt->_raw_size > 0) 2394 { 2395 if (info->shared) 2396 memcpy (htab->splt->contents, 2397 elf_i386_pic_plt0_entry, PLT_ENTRY_SIZE); 2398 else 2399 { 2400 memcpy (htab->splt->contents, 2401 elf_i386_plt0_entry, PLT_ENTRY_SIZE); 2402 bfd_put_32 (output_bfd, 2403 (htab->sgotplt->output_section->vma 2404 + htab->sgotplt->output_offset 2405 + 4), 2406 htab->splt->contents + 2); 2407 bfd_put_32 (output_bfd, 2408 (htab->sgotplt->output_section->vma 2409 + htab->sgotplt->output_offset 2410 + 8), 2411 htab->splt->contents + 8); 2412 } 2413 2414 /* UnixWare sets the entsize of .plt to 4, although that doesn't 2415 really seem like the right value. */ 2416 elf_section_data (htab->splt->output_section) 2417 ->this_hdr.sh_entsize = 4; 2418 } 2419 } 2420 2421 if (htab->sgotplt) 2422 { 2423 /* Fill in the first three entries in the global offset table. */ 2424 if (htab->sgotplt->_raw_size > 0) 2425 { 2426 bfd_put_32 (output_bfd, 2427 (sdyn == NULL ? (bfd_vma) 0 2428 : sdyn->output_section->vma + sdyn->output_offset), 2429 htab->sgotplt->contents); 2430 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 4); 2431 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8); 2432 } 2433 2434 elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 4; 2435 } 2436 return true; 2437} 2438 2439#define TARGET_LITTLE_SYM bfd_elf32_i386_vec 2440#define TARGET_LITTLE_NAME "elf32-i386" 2441#define ELF_ARCH bfd_arch_i386 2442#define ELF_MACHINE_CODE EM_386 2443#define ELF_MAXPAGESIZE 0x1000 2444 2445#define elf_backend_can_gc_sections 1 2446#define elf_backend_can_refcount 1 2447#define elf_backend_want_got_plt 1 2448#define elf_backend_plt_readonly 1 2449#define elf_backend_want_plt_sym 0 2450#define elf_backend_got_header_size 12 2451#define elf_backend_plt_header_size PLT_ENTRY_SIZE 2452 2453#define elf_info_to_howto elf_i386_info_to_howto 2454#define elf_info_to_howto_rel elf_i386_info_to_howto_rel 2455 2456#define bfd_elf32_bfd_is_local_label_name elf_i386_is_local_label_name 2457#define bfd_elf32_bfd_link_hash_table_create elf_i386_link_hash_table_create 2458#define bfd_elf32_bfd_reloc_type_lookup elf_i386_reloc_type_lookup 2459 2460#define elf_backend_adjust_dynamic_symbol elf_i386_adjust_dynamic_symbol 2461#define elf_backend_check_relocs elf_i386_check_relocs 2462#define elf_backend_copy_indirect_symbol elf_i386_copy_indirect_symbol 2463#define elf_backend_create_dynamic_sections elf_i386_create_dynamic_sections 2464#define elf_backend_fake_sections elf_i386_fake_sections 2465#define elf_backend_finish_dynamic_sections elf_i386_finish_dynamic_sections 2466#define elf_backend_finish_dynamic_symbol elf_i386_finish_dynamic_symbol 2467#define elf_backend_gc_mark_hook elf_i386_gc_mark_hook 2468#define elf_backend_gc_sweep_hook elf_i386_gc_sweep_hook 2469#define elf_backend_grok_prstatus elf_i386_grok_prstatus 2470#define elf_backend_grok_psinfo elf_i386_grok_psinfo 2471#define elf_backend_reloc_type_class elf_i386_reloc_type_class 2472#define elf_backend_relocate_section elf_i386_relocate_section 2473#define elf_backend_size_dynamic_sections elf_i386_size_dynamic_sections 2474 2475#include "elf32-target.h" 2476