1/* X86-64 specific support for 64-bit ELF 2 Copyright 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. 3 Contributed by Jan Hubicka <jh@suse.cz>. 4 5 This file is part of BFD, the Binary File Descriptor library. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 20 21#include "bfd.h" 22#include "sysdep.h" 23#include "bfdlink.h" 24#include "libbfd.h" 25#include "elf-bfd.h" 26 27#include "elf/x86-64.h" 28 29/* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */ 30#define MINUS_ONE (~ (bfd_vma) 0) 31 32/* The relocation "howto" table. Order of fields: 33 type, size, bitsize, pc_relative, complain_on_overflow, 34 special_function, name, partial_inplace, src_mask, dst_pack, pcrel_offset. */ 35static reloc_howto_type x86_64_elf_howto_table[] = 36{ 37 HOWTO(R_X86_64_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont, 38 bfd_elf_generic_reloc, "R_X86_64_NONE", FALSE, 0x00000000, 0x00000000, 39 FALSE), 40 HOWTO(R_X86_64_64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 41 bfd_elf_generic_reloc, "R_X86_64_64", FALSE, MINUS_ONE, MINUS_ONE, 42 FALSE), 43 HOWTO(R_X86_64_PC32, 0, 2, 32, TRUE, 0, complain_overflow_signed, 44 bfd_elf_generic_reloc, "R_X86_64_PC32", FALSE, 0xffffffff, 0xffffffff, 45 TRUE), 46 HOWTO(R_X86_64_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_signed, 47 bfd_elf_generic_reloc, "R_X86_64_GOT32", FALSE, 0xffffffff, 0xffffffff, 48 FALSE), 49 HOWTO(R_X86_64_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_signed, 50 bfd_elf_generic_reloc, "R_X86_64_PLT32", FALSE, 0xffffffff, 0xffffffff, 51 TRUE), 52 HOWTO(R_X86_64_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, 53 bfd_elf_generic_reloc, "R_X86_64_COPY", FALSE, 0xffffffff, 0xffffffff, 54 FALSE), 55 HOWTO(R_X86_64_GLOB_DAT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 56 bfd_elf_generic_reloc, "R_X86_64_GLOB_DAT", FALSE, MINUS_ONE, 57 MINUS_ONE, FALSE), 58 HOWTO(R_X86_64_JUMP_SLOT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 59 bfd_elf_generic_reloc, "R_X86_64_JUMP_SLOT", FALSE, MINUS_ONE, 60 MINUS_ONE, FALSE), 61 HOWTO(R_X86_64_RELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 62 bfd_elf_generic_reloc, "R_X86_64_RELATIVE", FALSE, MINUS_ONE, 63 MINUS_ONE, FALSE), 64 HOWTO(R_X86_64_GOTPCREL, 0, 2, 32, TRUE, 0, complain_overflow_signed, 65 bfd_elf_generic_reloc, "R_X86_64_GOTPCREL", FALSE, 0xffffffff, 66 0xffffffff, TRUE), 67 HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned, 68 bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff, 69 FALSE), 70 HOWTO(R_X86_64_32S, 0, 2, 32, FALSE, 0, complain_overflow_signed, 71 bfd_elf_generic_reloc, "R_X86_64_32S", FALSE, 0xffffffff, 0xffffffff, 72 FALSE), 73 HOWTO(R_X86_64_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield, 74 bfd_elf_generic_reloc, "R_X86_64_16", FALSE, 0xffff, 0xffff, FALSE), 75 HOWTO(R_X86_64_PC16,0, 1, 16, TRUE, 0, complain_overflow_bitfield, 76 bfd_elf_generic_reloc, "R_X86_64_PC16", FALSE, 0xffff, 0xffff, TRUE), 77 HOWTO(R_X86_64_8, 0, 0, 8, FALSE, 0, complain_overflow_signed, 78 bfd_elf_generic_reloc, "R_X86_64_8", FALSE, 0xff, 0xff, FALSE), 79 HOWTO(R_X86_64_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed, 80 bfd_elf_generic_reloc, "R_X86_64_PC8", FALSE, 0xff, 0xff, TRUE), 81 HOWTO(R_X86_64_DTPMOD64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 82 bfd_elf_generic_reloc, "R_X86_64_DTPMOD64", FALSE, MINUS_ONE, 83 MINUS_ONE, FALSE), 84 HOWTO(R_X86_64_DTPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 85 bfd_elf_generic_reloc, "R_X86_64_DTPOFF64", FALSE, MINUS_ONE, 86 MINUS_ONE, FALSE), 87 HOWTO(R_X86_64_TPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield, 88 bfd_elf_generic_reloc, "R_X86_64_TPOFF64", FALSE, MINUS_ONE, 89 MINUS_ONE, FALSE), 90 HOWTO(R_X86_64_TLSGD, 0, 2, 32, TRUE, 0, complain_overflow_signed, 91 bfd_elf_generic_reloc, "R_X86_64_TLSGD", FALSE, 0xffffffff, 92 0xffffffff, TRUE), 93 HOWTO(R_X86_64_TLSLD, 0, 2, 32, TRUE, 0, complain_overflow_signed, 94 bfd_elf_generic_reloc, "R_X86_64_TLSLD", FALSE, 0xffffffff, 95 0xffffffff, TRUE), 96 HOWTO(R_X86_64_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, 97 bfd_elf_generic_reloc, "R_X86_64_DTPOFF32", FALSE, 0xffffffff, 98 0xffffffff, FALSE), 99 HOWTO(R_X86_64_GOTTPOFF, 0, 2, 32, TRUE, 0, complain_overflow_signed, 100 bfd_elf_generic_reloc, "R_X86_64_GOTTPOFF", FALSE, 0xffffffff, 101 0xffffffff, TRUE), 102 HOWTO(R_X86_64_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed, 103 bfd_elf_generic_reloc, "R_X86_64_TPOFF32", FALSE, 0xffffffff, 104 0xffffffff, FALSE), 105 106/* GNU extension to record C++ vtable hierarchy. */ 107 HOWTO (R_X86_64_GNU_VTINHERIT, 0, 4, 0, FALSE, 0, complain_overflow_dont, 108 NULL, "R_X86_64_GNU_VTINHERIT", FALSE, 0, 0, FALSE), 109 110/* GNU extension to record C++ vtable member usage. */ 111 HOWTO (R_X86_64_GNU_VTENTRY, 0, 4, 0, FALSE, 0, complain_overflow_dont, 112 _bfd_elf_rel_vtable_reloc_fn, "R_X86_64_GNU_VTENTRY", FALSE, 0, 0, 113 FALSE) 114}; 115 116/* Map BFD relocs to the x86_64 elf relocs. */ 117struct elf_reloc_map 118{ 119 bfd_reloc_code_real_type bfd_reloc_val; 120 unsigned char elf_reloc_val; 121}; 122 123static const struct elf_reloc_map x86_64_reloc_map[] = 124{ 125 { BFD_RELOC_NONE, R_X86_64_NONE, }, 126 { BFD_RELOC_64, R_X86_64_64, }, 127 { BFD_RELOC_32_PCREL, R_X86_64_PC32, }, 128 { BFD_RELOC_X86_64_GOT32, R_X86_64_GOT32,}, 129 { BFD_RELOC_X86_64_PLT32, R_X86_64_PLT32,}, 130 { BFD_RELOC_X86_64_COPY, R_X86_64_COPY, }, 131 { BFD_RELOC_X86_64_GLOB_DAT, R_X86_64_GLOB_DAT, }, 132 { BFD_RELOC_X86_64_JUMP_SLOT, R_X86_64_JUMP_SLOT, }, 133 { BFD_RELOC_X86_64_RELATIVE, R_X86_64_RELATIVE, }, 134 { BFD_RELOC_X86_64_GOTPCREL, R_X86_64_GOTPCREL, }, 135 { BFD_RELOC_32, R_X86_64_32, }, 136 { BFD_RELOC_X86_64_32S, R_X86_64_32S, }, 137 { BFD_RELOC_16, R_X86_64_16, }, 138 { BFD_RELOC_16_PCREL, R_X86_64_PC16, }, 139 { BFD_RELOC_8, R_X86_64_8, }, 140 { BFD_RELOC_8_PCREL, R_X86_64_PC8, }, 141 { BFD_RELOC_X86_64_DTPMOD64, R_X86_64_DTPMOD64, }, 142 { BFD_RELOC_X86_64_DTPOFF64, R_X86_64_DTPOFF64, }, 143 { BFD_RELOC_X86_64_TPOFF64, R_X86_64_TPOFF64, }, 144 { BFD_RELOC_X86_64_TLSGD, R_X86_64_TLSGD, }, 145 { BFD_RELOC_X86_64_TLSLD, R_X86_64_TLSLD, }, 146 { BFD_RELOC_X86_64_DTPOFF32, R_X86_64_DTPOFF32, }, 147 { BFD_RELOC_X86_64_GOTTPOFF, R_X86_64_GOTTPOFF, }, 148 { BFD_RELOC_X86_64_TPOFF32, R_X86_64_TPOFF32, }, 149 { BFD_RELOC_VTABLE_INHERIT, R_X86_64_GNU_VTINHERIT, }, 150 { BFD_RELOC_VTABLE_ENTRY, R_X86_64_GNU_VTENTRY, }, 151}; 152 153 154/* Given a BFD reloc type, return a HOWTO structure. */ 155static reloc_howto_type * 156elf64_x86_64_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, 157 bfd_reloc_code_real_type code) 158{ 159 unsigned int i; 160 161 for (i = 0; i < sizeof (x86_64_reloc_map) / sizeof (struct elf_reloc_map); 162 i++) 163 { 164 if (x86_64_reloc_map[i].bfd_reloc_val == code) 165 return &x86_64_elf_howto_table[i]; 166 } 167 return 0; 168} 169 170/* Given an x86_64 ELF reloc type, fill in an arelent structure. */ 171 172static void 173elf64_x86_64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr, 174 Elf_Internal_Rela *dst) 175{ 176 unsigned r_type, i; 177 178 r_type = ELF64_R_TYPE (dst->r_info); 179 if (r_type < (unsigned int) R_X86_64_GNU_VTINHERIT) 180 { 181 BFD_ASSERT (r_type <= (unsigned int) R_X86_64_TPOFF32); 182 i = r_type; 183 } 184 else 185 { 186 BFD_ASSERT (r_type < (unsigned int) R_X86_64_max); 187 i = r_type - ((unsigned int) R_X86_64_GNU_VTINHERIT - R_X86_64_TPOFF32 - 1); 188 } 189 cache_ptr->howto = &x86_64_elf_howto_table[i]; 190 BFD_ASSERT (r_type == cache_ptr->howto->type); 191} 192 193/* Support for core dump NOTE sections. */ 194static bfd_boolean 195elf64_x86_64_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) 196{ 197 int offset; 198 size_t size; 199 200 switch (note->descsz) 201 { 202 default: 203 return FALSE; 204 205 case 336: /* sizeof(istruct elf_prstatus) on Linux/x86_64 */ 206 /* pr_cursig */ 207 elf_tdata (abfd)->core_signal 208 = bfd_get_16 (abfd, note->descdata + 12); 209 210 /* pr_pid */ 211 elf_tdata (abfd)->core_pid 212 = bfd_get_32 (abfd, note->descdata + 32); 213 214 /* pr_reg */ 215 offset = 112; 216 size = 216; 217 218 break; 219 } 220 221 /* Make a ".reg/999" section. */ 222 return _bfd_elfcore_make_pseudosection (abfd, ".reg", 223 size, note->descpos + offset); 224} 225 226static bfd_boolean 227elf64_x86_64_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 228{ 229 switch (note->descsz) 230 { 231 default: 232 return FALSE; 233 234 case 136: /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */ 235 elf_tdata (abfd)->core_program 236 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16); 237 elf_tdata (abfd)->core_command 238 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80); 239 } 240 241 /* Note that for some reason, a spurious space is tacked 242 onto the end of the args in some (at least one anyway) 243 implementations, so strip it off if it exists. */ 244 245 { 246 char *command = elf_tdata (abfd)->core_command; 247 int n = strlen (command); 248 249 if (0 < n && command[n - 1] == ' ') 250 command[n - 1] = '\0'; 251 } 252 253 return TRUE; 254} 255 256/* Functions for the x86-64 ELF linker. */ 257 258/* The name of the dynamic interpreter. This is put in the .interp 259 section. */ 260 261#define ELF_DYNAMIC_INTERPRETER "/lib/ld64.so.1" 262 263/* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid 264 copying dynamic variables from a shared lib into an app's dynbss 265 section, and instead use a dynamic relocation to point into the 266 shared lib. */ 267#define ELIMINATE_COPY_RELOCS 1 268 269/* The size in bytes of an entry in the global offset table. */ 270 271#define GOT_ENTRY_SIZE 8 272 273/* The size in bytes of an entry in the procedure linkage table. */ 274 275#define PLT_ENTRY_SIZE 16 276 277/* The first entry in a procedure linkage table looks like this. See the 278 SVR4 ABI i386 supplement and the x86-64 ABI to see how this works. */ 279 280static const bfd_byte elf64_x86_64_plt0_entry[PLT_ENTRY_SIZE] = 281{ 282 0xff, 0x35, 8, 0, 0, 0, /* pushq GOT+8(%rip) */ 283 0xff, 0x25, 16, 0, 0, 0, /* jmpq *GOT+16(%rip) */ 284 0x90, 0x90, 0x90, 0x90 /* pad out to 16 bytes with nops. */ 285}; 286 287/* Subsequent entries in a procedure linkage table look like this. */ 288 289static const bfd_byte elf64_x86_64_plt_entry[PLT_ENTRY_SIZE] = 290{ 291 0xff, 0x25, /* jmpq *name@GOTPC(%rip) */ 292 0, 0, 0, 0, /* replaced with offset to this symbol in .got. */ 293 0x68, /* pushq immediate */ 294 0, 0, 0, 0, /* replaced with index into relocation table. */ 295 0xe9, /* jmp relative */ 296 0, 0, 0, 0 /* replaced with offset to start of .plt0. */ 297}; 298 299/* The x86-64 linker needs to keep track of the number of relocs that 300 it decides to copy as dynamic relocs in check_relocs for each symbol. 301 This is so that it can later discard them if they are found to be 302 unnecessary. We store the information in a field extending the 303 regular ELF linker hash table. */ 304 305struct elf64_x86_64_dyn_relocs 306{ 307 /* Next section. */ 308 struct elf64_x86_64_dyn_relocs *next; 309 310 /* The input section of the reloc. */ 311 asection *sec; 312 313 /* Total number of relocs copied for the input section. */ 314 bfd_size_type count; 315 316 /* Number of pc-relative relocs copied for the input section. */ 317 bfd_size_type pc_count; 318}; 319 320/* x86-64 ELF linker hash entry. */ 321 322struct elf64_x86_64_link_hash_entry 323{ 324 struct elf_link_hash_entry elf; 325 326 /* Track dynamic relocs copied for this symbol. */ 327 struct elf64_x86_64_dyn_relocs *dyn_relocs; 328 329#define GOT_UNKNOWN 0 330#define GOT_NORMAL 1 331#define GOT_TLS_GD 2 332#define GOT_TLS_IE 3 333 unsigned char tls_type; 334}; 335 336#define elf64_x86_64_hash_entry(ent) \ 337 ((struct elf64_x86_64_link_hash_entry *)(ent)) 338 339struct elf64_x86_64_obj_tdata 340{ 341 struct elf_obj_tdata root; 342 343 /* tls_type for each local got entry. */ 344 char *local_got_tls_type; 345}; 346 347#define elf64_x86_64_tdata(abfd) \ 348 ((struct elf64_x86_64_obj_tdata *) (abfd)->tdata.any) 349 350#define elf64_x86_64_local_got_tls_type(abfd) \ 351 (elf64_x86_64_tdata (abfd)->local_got_tls_type) 352 353 354/* x86-64 ELF linker hash table. */ 355 356struct elf64_x86_64_link_hash_table 357{ 358 struct elf_link_hash_table elf; 359 360 /* Short-cuts to get to dynamic linker sections. */ 361 asection *sgot; 362 asection *sgotplt; 363 asection *srelgot; 364 asection *splt; 365 asection *srelplt; 366 asection *sdynbss; 367 asection *srelbss; 368 369 union { 370 bfd_signed_vma refcount; 371 bfd_vma offset; 372 } tls_ld_got; 373 374 /* Small local sym to section mapping cache. */ 375 struct sym_sec_cache sym_sec; 376}; 377 378/* Get the x86-64 ELF linker hash table from a link_info structure. */ 379 380#define elf64_x86_64_hash_table(p) \ 381 ((struct elf64_x86_64_link_hash_table *) ((p)->hash)) 382 383/* Create an entry in an x86-64 ELF linker hash table. */ 384 385static struct bfd_hash_entry * 386link_hash_newfunc (struct bfd_hash_entry *entry, struct bfd_hash_table *table, 387 const char *string) 388{ 389 /* Allocate the structure if it has not already been allocated by a 390 subclass. */ 391 if (entry == NULL) 392 { 393 entry = bfd_hash_allocate (table, 394 sizeof (struct elf64_x86_64_link_hash_entry)); 395 if (entry == NULL) 396 return entry; 397 } 398 399 /* Call the allocation method of the superclass. */ 400 entry = _bfd_elf_link_hash_newfunc (entry, table, string); 401 if (entry != NULL) 402 { 403 struct elf64_x86_64_link_hash_entry *eh; 404 405 eh = (struct elf64_x86_64_link_hash_entry *) entry; 406 eh->dyn_relocs = NULL; 407 eh->tls_type = GOT_UNKNOWN; 408 } 409 410 return entry; 411} 412 413/* Create an X86-64 ELF linker hash table. */ 414 415static struct bfd_link_hash_table * 416elf64_x86_64_link_hash_table_create (bfd *abfd) 417{ 418 struct elf64_x86_64_link_hash_table *ret; 419 bfd_size_type amt = sizeof (struct elf64_x86_64_link_hash_table); 420 421 ret = (struct elf64_x86_64_link_hash_table *) bfd_malloc (amt); 422 if (ret == NULL) 423 return NULL; 424 425 if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc)) 426 { 427 free (ret); 428 return NULL; 429 } 430 431 ret->sgot = NULL; 432 ret->sgotplt = NULL; 433 ret->srelgot = NULL; 434 ret->splt = NULL; 435 ret->srelplt = NULL; 436 ret->sdynbss = NULL; 437 ret->srelbss = NULL; 438 ret->sym_sec.abfd = NULL; 439 ret->tls_ld_got.refcount = 0; 440 441 return &ret->elf.root; 442} 443 444/* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up 445 shortcuts to them in our hash table. */ 446 447static bfd_boolean 448create_got_section (bfd *dynobj, struct bfd_link_info *info) 449{ 450 struct elf64_x86_64_link_hash_table *htab; 451 452 if (! _bfd_elf_create_got_section (dynobj, info)) 453 return FALSE; 454 455 htab = elf64_x86_64_hash_table (info); 456 htab->sgot = bfd_get_section_by_name (dynobj, ".got"); 457 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt"); 458 if (!htab->sgot || !htab->sgotplt) 459 abort (); 460 461 htab->srelgot = bfd_make_section (dynobj, ".rela.got"); 462 if (htab->srelgot == NULL 463 || ! bfd_set_section_flags (dynobj, htab->srelgot, 464 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS 465 | SEC_IN_MEMORY | SEC_LINKER_CREATED 466 | SEC_READONLY)) 467 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 3)) 468 return FALSE; 469 return TRUE; 470} 471 472/* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and 473 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our 474 hash table. */ 475 476static bfd_boolean 477elf64_x86_64_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info) 478{ 479 struct elf64_x86_64_link_hash_table *htab; 480 481 htab = elf64_x86_64_hash_table (info); 482 if (!htab->sgot && !create_got_section (dynobj, info)) 483 return FALSE; 484 485 if (!_bfd_elf_create_dynamic_sections (dynobj, info)) 486 return FALSE; 487 488 htab->splt = bfd_get_section_by_name (dynobj, ".plt"); 489 htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt"); 490 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss"); 491 if (!info->shared) 492 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss"); 493 494 if (!htab->splt || !htab->srelplt || !htab->sdynbss 495 || (!info->shared && !htab->srelbss)) 496 abort (); 497 498 return TRUE; 499} 500 501/* Copy the extra info we tack onto an elf_link_hash_entry. */ 502 503static void 504elf64_x86_64_copy_indirect_symbol (const struct elf_backend_data *bed, 505 struct elf_link_hash_entry *dir, 506 struct elf_link_hash_entry *ind) 507{ 508 struct elf64_x86_64_link_hash_entry *edir, *eind; 509 510 edir = (struct elf64_x86_64_link_hash_entry *) dir; 511 eind = (struct elf64_x86_64_link_hash_entry *) ind; 512 513 if (eind->dyn_relocs != NULL) 514 { 515 if (edir->dyn_relocs != NULL) 516 { 517 struct elf64_x86_64_dyn_relocs **pp; 518 struct elf64_x86_64_dyn_relocs *p; 519 520 if (ind->root.type == bfd_link_hash_indirect) 521 abort (); 522 523 /* Add reloc counts against the weak sym to the strong sym 524 list. Merge any entries against the same section. */ 525 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; ) 526 { 527 struct elf64_x86_64_dyn_relocs *q; 528 529 for (q = edir->dyn_relocs; q != NULL; q = q->next) 530 if (q->sec == p->sec) 531 { 532 q->pc_count += p->pc_count; 533 q->count += p->count; 534 *pp = p->next; 535 break; 536 } 537 if (q == NULL) 538 pp = &p->next; 539 } 540 *pp = edir->dyn_relocs; 541 } 542 543 edir->dyn_relocs = eind->dyn_relocs; 544 eind->dyn_relocs = NULL; 545 } 546 547 if (ind->root.type == bfd_link_hash_indirect 548 && dir->got.refcount <= 0) 549 { 550 edir->tls_type = eind->tls_type; 551 eind->tls_type = GOT_UNKNOWN; 552 } 553 554 if (ELIMINATE_COPY_RELOCS 555 && ind->root.type != bfd_link_hash_indirect 556 && dir->dynamic_adjusted) 557 { 558 /* If called to transfer flags for a weakdef during processing 559 of elf_adjust_dynamic_symbol, don't copy non_got_ref. 560 We clear it ourselves for ELIMINATE_COPY_RELOCS. */ 561 dir->ref_dynamic |= ind->ref_dynamic; 562 dir->ref_regular |= ind->ref_regular; 563 dir->ref_regular_nonweak |= ind->ref_regular_nonweak; 564 dir->needs_plt |= ind->needs_plt; 565 dir->pointer_equality_needed |= ind->pointer_equality_needed; 566 } 567 else 568 _bfd_elf_link_hash_copy_indirect (bed, dir, ind); 569} 570 571static bfd_boolean 572elf64_x86_64_mkobject (bfd *abfd) 573{ 574 bfd_size_type amt = sizeof (struct elf64_x86_64_obj_tdata); 575 abfd->tdata.any = bfd_zalloc (abfd, amt); 576 if (abfd->tdata.any == NULL) 577 return FALSE; 578 return TRUE; 579} 580 581static bfd_boolean 582elf64_x86_64_elf_object_p (bfd *abfd) 583{ 584 /* Set the right machine number for an x86-64 elf64 file. */ 585 bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64); 586 return TRUE; 587} 588 589static int 590elf64_x86_64_tls_transition (struct bfd_link_info *info, int r_type, int is_local) 591{ 592 if (info->shared) 593 return r_type; 594 595 switch (r_type) 596 { 597 case R_X86_64_TLSGD: 598 case R_X86_64_GOTTPOFF: 599 if (is_local) 600 return R_X86_64_TPOFF32; 601 return R_X86_64_GOTTPOFF; 602 case R_X86_64_TLSLD: 603 return R_X86_64_TPOFF32; 604 } 605 606 return r_type; 607} 608 609/* Look through the relocs for a section during the first phase, and 610 calculate needed space in the global offset table, procedure 611 linkage table, and dynamic reloc sections. */ 612 613static bfd_boolean 614elf64_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec, 615 const Elf_Internal_Rela *relocs) 616{ 617 struct elf64_x86_64_link_hash_table *htab; 618 Elf_Internal_Shdr *symtab_hdr; 619 struct elf_link_hash_entry **sym_hashes; 620 const Elf_Internal_Rela *rel; 621 const Elf_Internal_Rela *rel_end; 622 asection *sreloc; 623 624 if (info->relocatable) 625 return TRUE; 626 627 htab = elf64_x86_64_hash_table (info); 628 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 629 sym_hashes = elf_sym_hashes (abfd); 630 631 sreloc = NULL; 632 633 rel_end = relocs + sec->reloc_count; 634 for (rel = relocs; rel < rel_end; rel++) 635 { 636 unsigned int r_type; 637 unsigned long r_symndx; 638 struct elf_link_hash_entry *h; 639 640 r_symndx = ELF64_R_SYM (rel->r_info); 641 r_type = ELF64_R_TYPE (rel->r_info); 642 643 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr)) 644 { 645 (*_bfd_error_handler) (_("%B: bad symbol index: %d"), 646 abfd, r_symndx); 647 return FALSE; 648 } 649 650 if (r_symndx < symtab_hdr->sh_info) 651 h = NULL; 652 else 653 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 654 655 r_type = elf64_x86_64_tls_transition (info, r_type, h == NULL); 656 switch (r_type) 657 { 658 case R_X86_64_TLSLD: 659 htab->tls_ld_got.refcount += 1; 660 goto create_got; 661 662 case R_X86_64_TPOFF32: 663 if (info->shared) 664 { 665 (*_bfd_error_handler) 666 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"), 667 abfd, 668 x86_64_elf_howto_table[r_type].name, 669 (h) ? h->root.root.string : "a local symbol"); 670 bfd_set_error (bfd_error_bad_value); 671 return FALSE; 672 } 673 break; 674 675 case R_X86_64_GOTTPOFF: 676 if (info->shared) 677 info->flags |= DF_STATIC_TLS; 678 /* Fall through */ 679 680 case R_X86_64_GOT32: 681 case R_X86_64_GOTPCREL: 682 case R_X86_64_TLSGD: 683 /* This symbol requires a global offset table entry. */ 684 { 685 int tls_type, old_tls_type; 686 687 switch (r_type) 688 { 689 default: tls_type = GOT_NORMAL; break; 690 case R_X86_64_TLSGD: tls_type = GOT_TLS_GD; break; 691 case R_X86_64_GOTTPOFF: tls_type = GOT_TLS_IE; break; 692 } 693 694 if (h != NULL) 695 { 696 h->got.refcount += 1; 697 old_tls_type = elf64_x86_64_hash_entry (h)->tls_type; 698 } 699 else 700 { 701 bfd_signed_vma *local_got_refcounts; 702 703 /* This is a global offset table entry for a local symbol. */ 704 local_got_refcounts = elf_local_got_refcounts (abfd); 705 if (local_got_refcounts == NULL) 706 { 707 bfd_size_type size; 708 709 size = symtab_hdr->sh_info; 710 size *= sizeof (bfd_signed_vma) + sizeof (char); 711 local_got_refcounts = ((bfd_signed_vma *) 712 bfd_zalloc (abfd, size)); 713 if (local_got_refcounts == NULL) 714 return FALSE; 715 elf_local_got_refcounts (abfd) = local_got_refcounts; 716 elf64_x86_64_local_got_tls_type (abfd) 717 = (char *) (local_got_refcounts + symtab_hdr->sh_info); 718 } 719 local_got_refcounts[r_symndx] += 1; 720 old_tls_type 721 = elf64_x86_64_local_got_tls_type (abfd) [r_symndx]; 722 } 723 724 /* If a TLS symbol is accessed using IE at least once, 725 there is no point to use dynamic model for it. */ 726 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN 727 && (old_tls_type != GOT_TLS_GD || tls_type != GOT_TLS_IE)) 728 { 729 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD) 730 tls_type = old_tls_type; 731 else 732 { 733 (*_bfd_error_handler) 734 (_("%B: %s' accessed both as normal and thread local symbol"), 735 abfd, h ? h->root.root.string : "<local>"); 736 return FALSE; 737 } 738 } 739 740 if (old_tls_type != tls_type) 741 { 742 if (h != NULL) 743 elf64_x86_64_hash_entry (h)->tls_type = tls_type; 744 else 745 elf64_x86_64_local_got_tls_type (abfd) [r_symndx] = tls_type; 746 } 747 } 748 /* Fall through */ 749 750 //case R_X86_64_GOTPCREL: 751 create_got: 752 if (htab->sgot == NULL) 753 { 754 if (htab->elf.dynobj == NULL) 755 htab->elf.dynobj = abfd; 756 if (!create_got_section (htab->elf.dynobj, info)) 757 return FALSE; 758 } 759 break; 760 761 case R_X86_64_PLT32: 762 /* This symbol requires a procedure linkage table entry. We 763 actually build the entry in adjust_dynamic_symbol, 764 because this might be a case of linking PIC code which is 765 never referenced by a dynamic object, in which case we 766 don't need to generate a procedure linkage table entry 767 after all. */ 768 769 /* If this is a local symbol, we resolve it directly without 770 creating a procedure linkage table entry. */ 771 if (h == NULL) 772 continue; 773 774 h->needs_plt = 1; 775 h->plt.refcount += 1; 776 break; 777 778 case R_X86_64_8: 779 case R_X86_64_16: 780 case R_X86_64_32: 781 case R_X86_64_32S: 782 /* Let's help debug shared library creation. These relocs 783 cannot be used in shared libs. Don't error out for 784 sections we don't care about, such as debug sections or 785 non-constant sections. */ 786 if (info->shared 787 && (sec->flags & SEC_ALLOC) != 0 788 && (sec->flags & SEC_READONLY) != 0) 789 { 790 (*_bfd_error_handler) 791 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"), 792 abfd, 793 x86_64_elf_howto_table[r_type].name, 794 (h) ? h->root.root.string : "a local symbol"); 795 bfd_set_error (bfd_error_bad_value); 796 return FALSE; 797 } 798 /* Fall through. */ 799 800 case R_X86_64_PC8: 801 case R_X86_64_PC16: 802 case R_X86_64_PC32: 803 case R_X86_64_64: 804 if (h != NULL && !info->shared) 805 { 806 /* If this reloc is in a read-only section, we might 807 need a copy reloc. We can't check reliably at this 808 stage whether the section is read-only, as input 809 sections have not yet been mapped to output sections. 810 Tentatively set the flag for now, and correct in 811 adjust_dynamic_symbol. */ 812 h->non_got_ref = 1; 813 814 /* We may need a .plt entry if the function this reloc 815 refers to is in a shared lib. */ 816 h->plt.refcount += 1; 817 if (r_type != R_X86_64_PC32) 818 h->pointer_equality_needed = 1; 819 } 820 821 /* If we are creating a shared library, and this is a reloc 822 against a global symbol, or a non PC relative reloc 823 against a local symbol, then we need to copy the reloc 824 into the shared library. However, if we are linking with 825 -Bsymbolic, we do not need to copy a reloc against a 826 global symbol which is defined in an object we are 827 including in the link (i.e., DEF_REGULAR is set). At 828 this point we have not seen all the input files, so it is 829 possible that DEF_REGULAR is not set now but will be set 830 later (it is never cleared). In case of a weak definition, 831 DEF_REGULAR may be cleared later by a strong definition in 832 a shared library. We account for that possibility below by 833 storing information in the relocs_copied field of the hash 834 table entry. A similar situation occurs when creating 835 shared libraries and symbol visibility changes render the 836 symbol local. 837 838 If on the other hand, we are creating an executable, we 839 may need to keep relocations for symbols satisfied by a 840 dynamic library if we manage to avoid copy relocs for the 841 symbol. */ 842 if ((info->shared 843 && (sec->flags & SEC_ALLOC) != 0 844 && (((r_type != R_X86_64_PC8) 845 && (r_type != R_X86_64_PC16) 846 && (r_type != R_X86_64_PC32)) 847 || (h != NULL 848 && (! info->symbolic 849 || h->root.type == bfd_link_hash_defweak 850 || !h->def_regular)))) 851 || (ELIMINATE_COPY_RELOCS 852 && !info->shared 853 && (sec->flags & SEC_ALLOC) != 0 854 && h != NULL 855 && (h->root.type == bfd_link_hash_defweak 856 || !h->def_regular))) 857 { 858 struct elf64_x86_64_dyn_relocs *p; 859 struct elf64_x86_64_dyn_relocs **head; 860 861 /* We must copy these reloc types into the output file. 862 Create a reloc section in dynobj and make room for 863 this reloc. */ 864 if (sreloc == NULL) 865 { 866 const char *name; 867 bfd *dynobj; 868 869 name = (bfd_elf_string_from_elf_section 870 (abfd, 871 elf_elfheader (abfd)->e_shstrndx, 872 elf_section_data (sec)->rel_hdr.sh_name)); 873 if (name == NULL) 874 return FALSE; 875 876 if (strncmp (name, ".rela", 5) != 0 877 || strcmp (bfd_get_section_name (abfd, sec), 878 name + 5) != 0) 879 { 880 (*_bfd_error_handler) 881 (_("%B: bad relocation section name `%s\'"), 882 abfd, name); 883 } 884 885 if (htab->elf.dynobj == NULL) 886 htab->elf.dynobj = abfd; 887 888 dynobj = htab->elf.dynobj; 889 890 sreloc = bfd_get_section_by_name (dynobj, name); 891 if (sreloc == NULL) 892 { 893 flagword flags; 894 895 sreloc = bfd_make_section (dynobj, name); 896 flags = (SEC_HAS_CONTENTS | SEC_READONLY 897 | SEC_IN_MEMORY | SEC_LINKER_CREATED); 898 if ((sec->flags & SEC_ALLOC) != 0) 899 flags |= SEC_ALLOC | SEC_LOAD; 900 if (sreloc == NULL 901 || ! bfd_set_section_flags (dynobj, sreloc, flags) 902 || ! bfd_set_section_alignment (dynobj, sreloc, 3)) 903 return FALSE; 904 } 905 elf_section_data (sec)->sreloc = sreloc; 906 } 907 908 /* If this is a global symbol, we count the number of 909 relocations we need for this symbol. */ 910 if (h != NULL) 911 { 912 head = &((struct elf64_x86_64_link_hash_entry *) h)->dyn_relocs; 913 } 914 else 915 { 916 /* Track dynamic relocs needed for local syms too. 917 We really need local syms available to do this 918 easily. Oh well. */ 919 920 asection *s; 921 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec, 922 sec, r_symndx); 923 if (s == NULL) 924 return FALSE; 925 926 head = ((struct elf64_x86_64_dyn_relocs **) 927 &elf_section_data (s)->local_dynrel); 928 } 929 930 p = *head; 931 if (p == NULL || p->sec != sec) 932 { 933 bfd_size_type amt = sizeof *p; 934 p = ((struct elf64_x86_64_dyn_relocs *) 935 bfd_alloc (htab->elf.dynobj, amt)); 936 if (p == NULL) 937 return FALSE; 938 p->next = *head; 939 *head = p; 940 p->sec = sec; 941 p->count = 0; 942 p->pc_count = 0; 943 } 944 945 p->count += 1; 946 if (r_type == R_X86_64_PC8 947 || r_type == R_X86_64_PC16 948 || r_type == R_X86_64_PC32) 949 p->pc_count += 1; 950 } 951 break; 952 953 /* This relocation describes the C++ object vtable hierarchy. 954 Reconstruct it for later use during GC. */ 955 case R_X86_64_GNU_VTINHERIT: 956 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 957 return FALSE; 958 break; 959 960 /* This relocation describes which C++ vtable entries are actually 961 used. Record for later use during GC. */ 962 case R_X86_64_GNU_VTENTRY: 963 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 964 return FALSE; 965 break; 966 967 default: 968 break; 969 } 970 } 971 972 return TRUE; 973} 974 975/* Return the section that should be marked against GC for a given 976 relocation. */ 977 978static asection * 979elf64_x86_64_gc_mark_hook (asection *sec, 980 struct bfd_link_info *info ATTRIBUTE_UNUSED, 981 Elf_Internal_Rela *rel, 982 struct elf_link_hash_entry *h, 983 Elf_Internal_Sym *sym) 984{ 985 if (h != NULL) 986 { 987 switch (ELF64_R_TYPE (rel->r_info)) 988 { 989 case R_X86_64_GNU_VTINHERIT: 990 case R_X86_64_GNU_VTENTRY: 991 break; 992 993 default: 994 switch (h->root.type) 995 { 996 case bfd_link_hash_defined: 997 case bfd_link_hash_defweak: 998 return h->root.u.def.section; 999 1000 case bfd_link_hash_common: 1001 return h->root.u.c.p->section; 1002 1003 default: 1004 break; 1005 } 1006 } 1007 } 1008 else 1009 return bfd_section_from_elf_index (sec->owner, sym->st_shndx); 1010 1011 return NULL; 1012} 1013 1014/* Update the got entry reference counts for the section being removed. */ 1015 1016static bfd_boolean 1017elf64_x86_64_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info, 1018 asection *sec, const Elf_Internal_Rela *relocs) 1019{ 1020 Elf_Internal_Shdr *symtab_hdr; 1021 struct elf_link_hash_entry **sym_hashes; 1022 bfd_signed_vma *local_got_refcounts; 1023 const Elf_Internal_Rela *rel, *relend; 1024 1025 elf_section_data (sec)->local_dynrel = NULL; 1026 1027 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1028 sym_hashes = elf_sym_hashes (abfd); 1029 local_got_refcounts = elf_local_got_refcounts (abfd); 1030 1031 relend = relocs + sec->reloc_count; 1032 for (rel = relocs; rel < relend; rel++) 1033 { 1034 unsigned long r_symndx; 1035 unsigned int r_type; 1036 struct elf_link_hash_entry *h = NULL; 1037 1038 r_symndx = ELF64_R_SYM (rel->r_info); 1039 if (r_symndx >= symtab_hdr->sh_info) 1040 { 1041 struct elf64_x86_64_link_hash_entry *eh; 1042 struct elf64_x86_64_dyn_relocs **pp; 1043 struct elf64_x86_64_dyn_relocs *p; 1044 1045 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1046 eh = (struct elf64_x86_64_link_hash_entry *) h; 1047 1048 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next) 1049 if (p->sec == sec) 1050 { 1051 /* Everything must go for SEC. */ 1052 *pp = p->next; 1053 break; 1054 } 1055 } 1056 1057 r_type = ELF64_R_TYPE (rel->r_info); 1058 r_type = elf64_x86_64_tls_transition (info, r_type, h != NULL); 1059 switch (r_type) 1060 { 1061 case R_X86_64_TLSLD: 1062 if (elf64_x86_64_hash_table (info)->tls_ld_got.refcount > 0) 1063 elf64_x86_64_hash_table (info)->tls_ld_got.refcount -= 1; 1064 break; 1065 1066 case R_X86_64_TLSGD: 1067 case R_X86_64_GOTTPOFF: 1068 case R_X86_64_GOT32: 1069 case R_X86_64_GOTPCREL: 1070 if (h != NULL) 1071 { 1072 if (h->got.refcount > 0) 1073 h->got.refcount -= 1; 1074 } 1075 else if (local_got_refcounts != NULL) 1076 { 1077 if (local_got_refcounts[r_symndx] > 0) 1078 local_got_refcounts[r_symndx] -= 1; 1079 } 1080 break; 1081 1082 case R_X86_64_8: 1083 case R_X86_64_16: 1084 case R_X86_64_32: 1085 case R_X86_64_64: 1086 case R_X86_64_32S: 1087 case R_X86_64_PC8: 1088 case R_X86_64_PC16: 1089 case R_X86_64_PC32: 1090 if (info->shared) 1091 break; 1092 /* Fall thru */ 1093 1094 case R_X86_64_PLT32: 1095 if (h != NULL) 1096 { 1097 if (h->plt.refcount > 0) 1098 h->plt.refcount -= 1; 1099 } 1100 break; 1101 1102 default: 1103 break; 1104 } 1105 } 1106 1107 return TRUE; 1108} 1109 1110/* Adjust a symbol defined by a dynamic object and referenced by a 1111 regular object. The current definition is in some section of the 1112 dynamic object, but we're not including those sections. We have to 1113 change the definition to something the rest of the link can 1114 understand. */ 1115 1116static bfd_boolean 1117elf64_x86_64_adjust_dynamic_symbol (struct bfd_link_info *info, 1118 struct elf_link_hash_entry *h) 1119{ 1120 struct elf64_x86_64_link_hash_table *htab; 1121 asection *s; 1122 unsigned int power_of_two; 1123 1124 /* If this is a function, put it in the procedure linkage table. We 1125 will fill in the contents of the procedure linkage table later, 1126 when we know the address of the .got section. */ 1127 if (h->type == STT_FUNC 1128 || h->needs_plt) 1129 { 1130 if (h->plt.refcount <= 0 1131 || SYMBOL_CALLS_LOCAL (info, h) 1132 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 1133 && h->root.type == bfd_link_hash_undefweak)) 1134 { 1135 /* This case can occur if we saw a PLT32 reloc in an input 1136 file, but the symbol was never referred to by a dynamic 1137 object, or if all references were garbage collected. In 1138 such a case, we don't actually need to build a procedure 1139 linkage table, and we can just do a PC32 reloc instead. */ 1140 h->plt.offset = (bfd_vma) -1; 1141 h->needs_plt = 0; 1142 } 1143 1144 return TRUE; 1145 } 1146 else 1147 /* It's possible that we incorrectly decided a .plt reloc was 1148 needed for an R_X86_64_PC32 reloc to a non-function sym in 1149 check_relocs. We can't decide accurately between function and 1150 non-function syms in check-relocs; Objects loaded later in 1151 the link may change h->type. So fix it now. */ 1152 h->plt.offset = (bfd_vma) -1; 1153 1154 /* If this is a weak symbol, and there is a real definition, the 1155 processor independent code will have arranged for us to see the 1156 real definition first, and we can just use the same value. */ 1157 if (h->u.weakdef != NULL) 1158 { 1159 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 1160 || h->u.weakdef->root.type == bfd_link_hash_defweak); 1161 h->root.u.def.section = h->u.weakdef->root.u.def.section; 1162 h->root.u.def.value = h->u.weakdef->root.u.def.value; 1163 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc) 1164 h->non_got_ref = h->u.weakdef->non_got_ref; 1165 return TRUE; 1166 } 1167 1168 /* This is a reference to a symbol defined by a dynamic object which 1169 is not a function. */ 1170 1171 /* If we are creating a shared library, we must presume that the 1172 only references to the symbol are via the global offset table. 1173 For such cases we need not do anything here; the relocations will 1174 be handled correctly by relocate_section. */ 1175 if (info->shared) 1176 return TRUE; 1177 1178 /* If there are no references to this symbol that do not use the 1179 GOT, we don't need to generate a copy reloc. */ 1180 if (!h->non_got_ref) 1181 return TRUE; 1182 1183 /* If -z nocopyreloc was given, we won't generate them either. */ 1184 if (info->nocopyreloc) 1185 { 1186 h->non_got_ref = 0; 1187 return TRUE; 1188 } 1189 1190 if (ELIMINATE_COPY_RELOCS) 1191 { 1192 struct elf64_x86_64_link_hash_entry * eh; 1193 struct elf64_x86_64_dyn_relocs *p; 1194 1195 eh = (struct elf64_x86_64_link_hash_entry *) h; 1196 for (p = eh->dyn_relocs; p != NULL; p = p->next) 1197 { 1198 s = p->sec->output_section; 1199 if (s != NULL && (s->flags & SEC_READONLY) != 0) 1200 break; 1201 } 1202 1203 /* If we didn't find any dynamic relocs in read-only sections, then 1204 we'll be keeping the dynamic relocs and avoiding the copy reloc. */ 1205 if (p == NULL) 1206 { 1207 h->non_got_ref = 0; 1208 return TRUE; 1209 } 1210 } 1211 1212 /* We must allocate the symbol in our .dynbss section, which will 1213 become part of the .bss section of the executable. There will be 1214 an entry for this symbol in the .dynsym section. The dynamic 1215 object will contain position independent code, so all references 1216 from the dynamic object to this symbol will go through the global 1217 offset table. The dynamic linker will use the .dynsym entry to 1218 determine the address it must put in the global offset table, so 1219 both the dynamic object and the regular object will refer to the 1220 same memory location for the variable. */ 1221 1222 htab = elf64_x86_64_hash_table (info); 1223 1224 /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker 1225 to copy the initial value out of the dynamic object and into the 1226 runtime process image. */ 1227 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) 1228 { 1229 htab->srelbss->size += sizeof (Elf64_External_Rela); 1230 h->needs_copy = 1; 1231 } 1232 1233 /* We need to figure out the alignment required for this symbol. I 1234 have no idea how ELF linkers handle this. 16-bytes is the size 1235 of the largest type that requires hard alignment -- long double. */ 1236 /* FIXME: This is VERY ugly. Should be fixed for all architectures using 1237 this construct. */ 1238 power_of_two = bfd_log2 (h->size); 1239 if (power_of_two > 4) 1240 power_of_two = 4; 1241 1242 /* Apply the required alignment. */ 1243 s = htab->sdynbss; 1244 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two)); 1245 if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s)) 1246 { 1247 if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two)) 1248 return FALSE; 1249 } 1250 1251 /* Define the symbol as being at this point in the section. */ 1252 h->root.u.def.section = s; 1253 h->root.u.def.value = s->size; 1254 1255 /* Increment the section size to make room for the symbol. */ 1256 s->size += h->size; 1257 1258 return TRUE; 1259} 1260 1261/* Allocate space in .plt, .got and associated reloc sections for 1262 dynamic relocs. */ 1263 1264static bfd_boolean 1265allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf) 1266{ 1267 struct bfd_link_info *info; 1268 struct elf64_x86_64_link_hash_table *htab; 1269 struct elf64_x86_64_link_hash_entry *eh; 1270 struct elf64_x86_64_dyn_relocs *p; 1271 1272 if (h->root.type == bfd_link_hash_indirect) 1273 return TRUE; 1274 1275 if (h->root.type == bfd_link_hash_warning) 1276 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1277 1278 info = (struct bfd_link_info *) inf; 1279 htab = elf64_x86_64_hash_table (info); 1280 1281 if (htab->elf.dynamic_sections_created 1282 && h->plt.refcount > 0) 1283 { 1284 /* Make sure this symbol is output as a dynamic symbol. 1285 Undefined weak syms won't yet be marked as dynamic. */ 1286 if (h->dynindx == -1 1287 && !h->forced_local) 1288 { 1289 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 1290 return FALSE; 1291 } 1292 1293 if (info->shared 1294 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h)) 1295 { 1296 asection *s = htab->splt; 1297 1298 /* If this is the first .plt entry, make room for the special 1299 first entry. */ 1300 if (s->size == 0) 1301 s->size += PLT_ENTRY_SIZE; 1302 1303 h->plt.offset = s->size; 1304 1305 /* If this symbol is not defined in a regular file, and we are 1306 not generating a shared library, then set the symbol to this 1307 location in the .plt. This is required to make function 1308 pointers compare as equal between the normal executable and 1309 the shared library. */ 1310 if (! info->shared 1311 && !h->def_regular) 1312 { 1313 h->root.u.def.section = s; 1314 h->root.u.def.value = h->plt.offset; 1315 } 1316 1317 /* Make room for this entry. */ 1318 s->size += PLT_ENTRY_SIZE; 1319 1320 /* We also need to make an entry in the .got.plt section, which 1321 will be placed in the .got section by the linker script. */ 1322 htab->sgotplt->size += GOT_ENTRY_SIZE; 1323 1324 /* We also need to make an entry in the .rela.plt section. */ 1325 htab->srelplt->size += sizeof (Elf64_External_Rela); 1326 } 1327 else 1328 { 1329 h->plt.offset = (bfd_vma) -1; 1330 h->needs_plt = 0; 1331 } 1332 } 1333 else 1334 { 1335 h->plt.offset = (bfd_vma) -1; 1336 h->needs_plt = 0; 1337 } 1338 1339 /* If R_X86_64_GOTTPOFF symbol is now local to the binary, 1340 make it a R_X86_64_TPOFF32 requiring no GOT entry. */ 1341 if (h->got.refcount > 0 1342 && !info->shared 1343 && h->dynindx == -1 1344 && elf64_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE) 1345 h->got.offset = (bfd_vma) -1; 1346 else if (h->got.refcount > 0) 1347 { 1348 asection *s; 1349 bfd_boolean dyn; 1350 int tls_type = elf64_x86_64_hash_entry (h)->tls_type; 1351 1352 /* Make sure this symbol is output as a dynamic symbol. 1353 Undefined weak syms won't yet be marked as dynamic. */ 1354 if (h->dynindx == -1 1355 && !h->forced_local) 1356 { 1357 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 1358 return FALSE; 1359 } 1360 1361 s = htab->sgot; 1362 h->got.offset = s->size; 1363 s->size += GOT_ENTRY_SIZE; 1364 /* R_X86_64_TLSGD needs 2 consecutive GOT slots. */ 1365 if (tls_type == GOT_TLS_GD) 1366 s->size += GOT_ENTRY_SIZE; 1367 dyn = htab->elf.dynamic_sections_created; 1368 /* R_X86_64_TLSGD needs one dynamic relocation if local symbol 1369 and two if global. 1370 R_X86_64_GOTTPOFF needs one dynamic relocation. */ 1371 if ((tls_type == GOT_TLS_GD && h->dynindx == -1) 1372 || tls_type == GOT_TLS_IE) 1373 htab->srelgot->size += sizeof (Elf64_External_Rela); 1374 else if (tls_type == GOT_TLS_GD) 1375 htab->srelgot->size += 2 * sizeof (Elf64_External_Rela); 1376 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 1377 || h->root.type != bfd_link_hash_undefweak) 1378 && (info->shared 1379 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))) 1380 htab->srelgot->size += sizeof (Elf64_External_Rela); 1381 } 1382 else 1383 h->got.offset = (bfd_vma) -1; 1384 1385 eh = (struct elf64_x86_64_link_hash_entry *) h; 1386 if (eh->dyn_relocs == NULL) 1387 return TRUE; 1388 1389 /* In the shared -Bsymbolic case, discard space allocated for 1390 dynamic pc-relative relocs against symbols which turn out to be 1391 defined in regular objects. For the normal shared case, discard 1392 space for pc-relative relocs that have become local due to symbol 1393 visibility changes. */ 1394 1395 if (info->shared) 1396 { 1397 /* Relocs that use pc_count are those that appear on a call 1398 insn, or certain REL relocs that can generated via assembly. 1399 We want calls to protected symbols to resolve directly to the 1400 function rather than going via the plt. If people want 1401 function pointer comparisons to work as expected then they 1402 should avoid writing weird assembly. */ 1403 if (SYMBOL_CALLS_LOCAL (info, h)) 1404 { 1405 struct elf64_x86_64_dyn_relocs **pp; 1406 1407 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) 1408 { 1409 p->count -= p->pc_count; 1410 p->pc_count = 0; 1411 if (p->count == 0) 1412 *pp = p->next; 1413 else 1414 pp = &p->next; 1415 } 1416 } 1417 1418 /* Also discard relocs on undefined weak syms with non-default 1419 visibility. */ 1420 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 1421 && h->root.type == bfd_link_hash_undefweak) 1422 eh->dyn_relocs = NULL; 1423 } 1424 else if (ELIMINATE_COPY_RELOCS) 1425 { 1426 /* For the non-shared case, discard space for relocs against 1427 symbols which turn out to need copy relocs or are not 1428 dynamic. */ 1429 1430 if (!h->non_got_ref 1431 && ((h->def_dynamic 1432 && !h->def_regular) 1433 || (htab->elf.dynamic_sections_created 1434 && (h->root.type == bfd_link_hash_undefweak 1435 || h->root.type == bfd_link_hash_undefined)))) 1436 { 1437 /* Make sure this symbol is output as a dynamic symbol. 1438 Undefined weak syms won't yet be marked as dynamic. */ 1439 if (h->dynindx == -1 1440 && !h->forced_local) 1441 { 1442 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 1443 return FALSE; 1444 } 1445 1446 /* If that succeeded, we know we'll be keeping all the 1447 relocs. */ 1448 if (h->dynindx != -1) 1449 goto keep; 1450 } 1451 1452 eh->dyn_relocs = NULL; 1453 1454 keep: ; 1455 } 1456 1457 /* Finally, allocate space. */ 1458 for (p = eh->dyn_relocs; p != NULL; p = p->next) 1459 { 1460 asection *sreloc = elf_section_data (p->sec)->sreloc; 1461 sreloc->size += p->count * sizeof (Elf64_External_Rela); 1462 } 1463 1464 return TRUE; 1465} 1466 1467/* Find any dynamic relocs that apply to read-only sections. */ 1468 1469static bfd_boolean 1470readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf) 1471{ 1472 struct elf64_x86_64_link_hash_entry *eh; 1473 struct elf64_x86_64_dyn_relocs *p; 1474 1475 if (h->root.type == bfd_link_hash_warning) 1476 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1477 1478 eh = (struct elf64_x86_64_link_hash_entry *) h; 1479 for (p = eh->dyn_relocs; p != NULL; p = p->next) 1480 { 1481 asection *s = p->sec->output_section; 1482 1483 if (s != NULL && (s->flags & SEC_READONLY) != 0) 1484 { 1485 struct bfd_link_info *info = (struct bfd_link_info *) inf; 1486 1487 info->flags |= DF_TEXTREL; 1488 1489 /* Not an error, just cut short the traversal. */ 1490 return FALSE; 1491 } 1492 } 1493 return TRUE; 1494} 1495 1496/* Set the sizes of the dynamic sections. */ 1497 1498static bfd_boolean 1499elf64_x86_64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 1500 struct bfd_link_info *info) 1501{ 1502 struct elf64_x86_64_link_hash_table *htab; 1503 bfd *dynobj; 1504 asection *s; 1505 bfd_boolean relocs; 1506 bfd *ibfd; 1507 1508 htab = elf64_x86_64_hash_table (info); 1509 dynobj = htab->elf.dynobj; 1510 if (dynobj == NULL) 1511 abort (); 1512 1513 if (htab->elf.dynamic_sections_created) 1514 { 1515 /* Set the contents of the .interp section to the interpreter. */ 1516 if (info->executable) 1517 { 1518 s = bfd_get_section_by_name (dynobj, ".interp"); 1519 if (s == NULL) 1520 abort (); 1521 s->size = sizeof ELF_DYNAMIC_INTERPRETER; 1522 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 1523 } 1524 } 1525 1526 /* Set up .got offsets for local syms, and space for local dynamic 1527 relocs. */ 1528 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) 1529 { 1530 bfd_signed_vma *local_got; 1531 bfd_signed_vma *end_local_got; 1532 char *local_tls_type; 1533 bfd_size_type locsymcount; 1534 Elf_Internal_Shdr *symtab_hdr; 1535 asection *srel; 1536 1537 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour) 1538 continue; 1539 1540 for (s = ibfd->sections; s != NULL; s = s->next) 1541 { 1542 struct elf64_x86_64_dyn_relocs *p; 1543 1544 for (p = *((struct elf64_x86_64_dyn_relocs **) 1545 &elf_section_data (s)->local_dynrel); 1546 p != NULL; 1547 p = p->next) 1548 { 1549 if (!bfd_is_abs_section (p->sec) 1550 && bfd_is_abs_section (p->sec->output_section)) 1551 { 1552 /* Input section has been discarded, either because 1553 it is a copy of a linkonce section or due to 1554 linker script /DISCARD/, so we'll be discarding 1555 the relocs too. */ 1556 } 1557 else if (p->count != 0) 1558 { 1559 srel = elf_section_data (p->sec)->sreloc; 1560 srel->size += p->count * sizeof (Elf64_External_Rela); 1561 if ((p->sec->output_section->flags & SEC_READONLY) != 0) 1562 info->flags |= DF_TEXTREL; 1563 1564 } 1565 } 1566 } 1567 1568 local_got = elf_local_got_refcounts (ibfd); 1569 if (!local_got) 1570 continue; 1571 1572 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr; 1573 locsymcount = symtab_hdr->sh_info; 1574 end_local_got = local_got + locsymcount; 1575 local_tls_type = elf64_x86_64_local_got_tls_type (ibfd); 1576 s = htab->sgot; 1577 srel = htab->srelgot; 1578 for (; local_got < end_local_got; ++local_got, ++local_tls_type) 1579 { 1580 if (*local_got > 0) 1581 { 1582 *local_got = s->size; 1583 s->size += GOT_ENTRY_SIZE; 1584 if (*local_tls_type == GOT_TLS_GD) 1585 s->size += GOT_ENTRY_SIZE; 1586 if (info->shared 1587 || *local_tls_type == GOT_TLS_GD 1588 || *local_tls_type == GOT_TLS_IE) 1589 srel->size += sizeof (Elf64_External_Rela); 1590 } 1591 else 1592 *local_got = (bfd_vma) -1; 1593 } 1594 } 1595 1596 if (htab->tls_ld_got.refcount > 0) 1597 { 1598 /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD 1599 relocs. */ 1600 htab->tls_ld_got.offset = htab->sgot->size; 1601 htab->sgot->size += 2 * GOT_ENTRY_SIZE; 1602 htab->srelgot->size += sizeof (Elf64_External_Rela); 1603 } 1604 else 1605 htab->tls_ld_got.offset = -1; 1606 1607 /* Allocate global sym .plt and .got entries, and space for global 1608 sym dynamic relocs. */ 1609 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info); 1610 1611 /* We now have determined the sizes of the various dynamic sections. 1612 Allocate memory for them. */ 1613 relocs = FALSE; 1614 for (s = dynobj->sections; s != NULL; s = s->next) 1615 { 1616 if ((s->flags & SEC_LINKER_CREATED) == 0) 1617 continue; 1618 1619 if (s == htab->splt 1620 || s == htab->sgot 1621 || s == htab->sgotplt) 1622 { 1623 /* Strip this section if we don't need it; see the 1624 comment below. */ 1625 } 1626 else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0) 1627 { 1628 if (s->size != 0 && s != htab->srelplt) 1629 relocs = TRUE; 1630 1631 /* We use the reloc_count field as a counter if we need 1632 to copy relocs into the output file. */ 1633 s->reloc_count = 0; 1634 } 1635 else 1636 { 1637 /* It's not one of our sections, so don't allocate space. */ 1638 continue; 1639 } 1640 1641 if (s->size == 0) 1642 { 1643 /* If we don't need this section, strip it from the 1644 output file. This is mostly to handle .rela.bss and 1645 .rela.plt. We must create both sections in 1646 create_dynamic_sections, because they must be created 1647 before the linker maps input sections to output 1648 sections. The linker does that before 1649 adjust_dynamic_symbol is called, and it is that 1650 function which decides whether anything needs to go 1651 into these sections. */ 1652 1653 _bfd_strip_section_from_output (info, s); 1654 continue; 1655 } 1656 1657 /* Allocate memory for the section contents. We use bfd_zalloc 1658 here in case unused entries are not reclaimed before the 1659 section's contents are written out. This should not happen, 1660 but this way if it does, we get a R_X86_64_NONE reloc instead 1661 of garbage. */ 1662 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size); 1663 if (s->contents == NULL) 1664 return FALSE; 1665 } 1666 1667 if (htab->elf.dynamic_sections_created) 1668 { 1669 /* Add some entries to the .dynamic section. We fill in the 1670 values later, in elf64_x86_64_finish_dynamic_sections, but we 1671 must add the entries now so that we get the correct size for 1672 the .dynamic section. The DT_DEBUG entry is filled in by the 1673 dynamic linker and used by the debugger. */ 1674#define add_dynamic_entry(TAG, VAL) \ 1675 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 1676 1677 if (info->executable) 1678 { 1679 if (!add_dynamic_entry (DT_DEBUG, 0)) 1680 return FALSE; 1681 } 1682 1683 if (htab->splt->size != 0) 1684 { 1685 if (!add_dynamic_entry (DT_PLTGOT, 0) 1686 || !add_dynamic_entry (DT_PLTRELSZ, 0) 1687 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 1688 || !add_dynamic_entry (DT_JMPREL, 0)) 1689 return FALSE; 1690 } 1691 1692 if (relocs) 1693 { 1694 if (!add_dynamic_entry (DT_RELA, 0) 1695 || !add_dynamic_entry (DT_RELASZ, 0) 1696 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela))) 1697 return FALSE; 1698 1699 /* If any dynamic relocs apply to a read-only section, 1700 then we need a DT_TEXTREL entry. */ 1701 if ((info->flags & DF_TEXTREL) == 0) 1702 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, 1703 (PTR) info); 1704 1705 if ((info->flags & DF_TEXTREL) != 0) 1706 { 1707 if (!add_dynamic_entry (DT_TEXTREL, 0)) 1708 return FALSE; 1709 } 1710 } 1711 } 1712#undef add_dynamic_entry 1713 1714 return TRUE; 1715} 1716 1717/* Return the base VMA address which should be subtracted from real addresses 1718 when resolving @dtpoff relocation. 1719 This is PT_TLS segment p_vaddr. */ 1720 1721static bfd_vma 1722dtpoff_base (struct bfd_link_info *info) 1723{ 1724 /* If tls_sec is NULL, we should have signalled an error already. */ 1725 if (elf_hash_table (info)->tls_sec == NULL) 1726 return 0; 1727 return elf_hash_table (info)->tls_sec->vma; 1728} 1729 1730/* Return the relocation value for @tpoff relocation 1731 if STT_TLS virtual address is ADDRESS. */ 1732 1733static bfd_vma 1734tpoff (struct bfd_link_info *info, bfd_vma address) 1735{ 1736 struct elf_link_hash_table *htab = elf_hash_table (info); 1737 1738 /* If tls_segment is NULL, we should have signalled an error already. */ 1739 if (htab->tls_sec == NULL) 1740 return 0; 1741 return address - htab->tls_size - htab->tls_sec->vma; 1742} 1743 1744/* Relocate an x86_64 ELF section. */ 1745 1746static bfd_boolean 1747elf64_x86_64_relocate_section (bfd *output_bfd, struct bfd_link_info *info, 1748 bfd *input_bfd, asection *input_section, 1749 bfd_byte *contents, Elf_Internal_Rela *relocs, 1750 Elf_Internal_Sym *local_syms, 1751 asection **local_sections) 1752{ 1753 struct elf64_x86_64_link_hash_table *htab; 1754 Elf_Internal_Shdr *symtab_hdr; 1755 struct elf_link_hash_entry **sym_hashes; 1756 bfd_vma *local_got_offsets; 1757 Elf_Internal_Rela *rel; 1758 Elf_Internal_Rela *relend; 1759 1760 if (info->relocatable) 1761 return TRUE; 1762 1763 htab = elf64_x86_64_hash_table (info); 1764 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 1765 sym_hashes = elf_sym_hashes (input_bfd); 1766 local_got_offsets = elf_local_got_offsets (input_bfd); 1767 1768 rel = relocs; 1769 relend = relocs + input_section->reloc_count; 1770 for (; rel < relend; rel++) 1771 { 1772 unsigned int r_type; 1773 reloc_howto_type *howto; 1774 unsigned long r_symndx; 1775 struct elf_link_hash_entry *h; 1776 Elf_Internal_Sym *sym; 1777 asection *sec; 1778 bfd_vma off; 1779 bfd_vma relocation; 1780 bfd_boolean unresolved_reloc; 1781 bfd_reloc_status_type r; 1782 int tls_type; 1783 1784 r_type = ELF64_R_TYPE (rel->r_info); 1785 if (r_type == (int) R_X86_64_GNU_VTINHERIT 1786 || r_type == (int) R_X86_64_GNU_VTENTRY) 1787 continue; 1788 1789 if (r_type >= R_X86_64_max) 1790 { 1791 bfd_set_error (bfd_error_bad_value); 1792 return FALSE; 1793 } 1794 1795 howto = x86_64_elf_howto_table + r_type; 1796 r_symndx = ELF64_R_SYM (rel->r_info); 1797 h = NULL; 1798 sym = NULL; 1799 sec = NULL; 1800 unresolved_reloc = FALSE; 1801 if (r_symndx < symtab_hdr->sh_info) 1802 { 1803 sym = local_syms + r_symndx; 1804 sec = local_sections[r_symndx]; 1805 1806 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 1807 } 1808 else 1809 { 1810 bfd_boolean warned; 1811 1812 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 1813 r_symndx, symtab_hdr, sym_hashes, 1814 h, sec, relocation, 1815 unresolved_reloc, warned); 1816 } 1817 /* When generating a shared object, the relocations handled here are 1818 copied into the output file to be resolved at run time. */ 1819 switch (r_type) 1820 { 1821 case R_X86_64_GOT32: 1822 /* Relocation is to the entry for this symbol in the global 1823 offset table. */ 1824 case R_X86_64_GOTPCREL: 1825 /* Use global offset table as symbol value. */ 1826 if (htab->sgot == NULL) 1827 abort (); 1828 1829 if (h != NULL) 1830 { 1831 bfd_boolean dyn; 1832 1833 off = h->got.offset; 1834 dyn = htab->elf.dynamic_sections_created; 1835 1836 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h) 1837 || (info->shared 1838 && SYMBOL_REFERENCES_LOCAL (info, h)) 1839 || (ELF_ST_VISIBILITY (h->other) 1840 && h->root.type == bfd_link_hash_undefweak)) 1841 { 1842 /* This is actually a static link, or it is a -Bsymbolic 1843 link and the symbol is defined locally, or the symbol 1844 was forced to be local because of a version file. We 1845 must initialize this entry in the global offset table. 1846 Since the offset must always be a multiple of 8, we 1847 use the least significant bit to record whether we 1848 have initialized it already. 1849 1850 When doing a dynamic link, we create a .rela.got 1851 relocation entry to initialize the value. This is 1852 done in the finish_dynamic_symbol routine. */ 1853 if ((off & 1) != 0) 1854 off &= ~1; 1855 else 1856 { 1857 bfd_put_64 (output_bfd, relocation, 1858 htab->sgot->contents + off); 1859 h->got.offset |= 1; 1860 } 1861 } 1862 else 1863 unresolved_reloc = FALSE; 1864 } 1865 else 1866 { 1867 if (local_got_offsets == NULL) 1868 abort (); 1869 1870 off = local_got_offsets[r_symndx]; 1871 1872 /* The offset must always be a multiple of 8. We use 1873 the least significant bit to record whether we have 1874 already generated the necessary reloc. */ 1875 if ((off & 1) != 0) 1876 off &= ~1; 1877 else 1878 { 1879 bfd_put_64 (output_bfd, relocation, 1880 htab->sgot->contents + off); 1881 1882 if (info->shared) 1883 { 1884 asection *s; 1885 Elf_Internal_Rela outrel; 1886 bfd_byte *loc; 1887 1888 /* We need to generate a R_X86_64_RELATIVE reloc 1889 for the dynamic linker. */ 1890 s = htab->srelgot; 1891 if (s == NULL) 1892 abort (); 1893 1894 outrel.r_offset = (htab->sgot->output_section->vma 1895 + htab->sgot->output_offset 1896 + off); 1897 outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE); 1898 outrel.r_addend = relocation; 1899 loc = s->contents; 1900 loc += s->reloc_count++ * sizeof (Elf64_External_Rela); 1901 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc); 1902 } 1903 1904 local_got_offsets[r_symndx] |= 1; 1905 } 1906 } 1907 1908 if (off >= (bfd_vma) -2) 1909 abort (); 1910 1911 relocation = htab->sgot->output_section->vma 1912 + htab->sgot->output_offset + off; 1913 if (r_type != R_X86_64_GOTPCREL) 1914 relocation -= htab->sgotplt->output_section->vma 1915 - htab->sgotplt->output_offset; 1916 1917 break; 1918 1919 case R_X86_64_PLT32: 1920 /* Relocation is to the entry for this symbol in the 1921 procedure linkage table. */ 1922 1923 /* Resolve a PLT32 reloc against a local symbol directly, 1924 without using the procedure linkage table. */ 1925 if (h == NULL) 1926 break; 1927 1928 if (h->plt.offset == (bfd_vma) -1 1929 || htab->splt == NULL) 1930 { 1931 /* We didn't make a PLT entry for this symbol. This 1932 happens when statically linking PIC code, or when 1933 using -Bsymbolic. */ 1934 break; 1935 } 1936 1937 relocation = (htab->splt->output_section->vma 1938 + htab->splt->output_offset 1939 + h->plt.offset); 1940 unresolved_reloc = FALSE; 1941 break; 1942 1943 case R_X86_64_PC8: 1944 case R_X86_64_PC16: 1945 case R_X86_64_PC32: 1946 if (info->shared 1947 && !SYMBOL_REFERENCES_LOCAL (info, h) 1948 && (input_section->flags & SEC_ALLOC) != 0 1949 && (input_section->flags & SEC_READONLY) != 0) 1950 { 1951 (*_bfd_error_handler) 1952 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"), 1953 input_bfd, 1954 x86_64_elf_howto_table[r_type].name, 1955 (h) ? h->root.root.string : "a local symbol"); 1956 bfd_set_error (bfd_error_bad_value); 1957 return FALSE; 1958 } 1959 /* Fall through. */ 1960 1961 case R_X86_64_8: 1962 case R_X86_64_16: 1963 case R_X86_64_32: 1964 case R_X86_64_64: 1965 /* FIXME: The ABI says the linker should make sure the value is 1966 the same when it's zeroextended to 64 bit. */ 1967 1968 /* r_symndx will be zero only for relocs against symbols 1969 from removed linkonce sections, or sections discarded by 1970 a linker script. */ 1971 if (r_symndx == 0 1972 || (input_section->flags & SEC_ALLOC) == 0) 1973 break; 1974 1975 if ((info->shared 1976 && (h == NULL 1977 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 1978 || h->root.type != bfd_link_hash_undefweak) 1979 && ((r_type != R_X86_64_PC8 1980 && r_type != R_X86_64_PC16 1981 && r_type != R_X86_64_PC32) 1982 || !SYMBOL_CALLS_LOCAL (info, h))) 1983 || (ELIMINATE_COPY_RELOCS 1984 && !info->shared 1985 && h != NULL 1986 && h->dynindx != -1 1987 && !h->non_got_ref 1988 && ((h->def_dynamic 1989 && !h->def_regular) 1990 || h->root.type == bfd_link_hash_undefweak 1991 || h->root.type == bfd_link_hash_undefined))) 1992 { 1993 Elf_Internal_Rela outrel; 1994 bfd_byte *loc; 1995 bfd_boolean skip, relocate; 1996 asection *sreloc; 1997 1998 /* When generating a shared object, these relocations 1999 are copied into the output file to be resolved at run 2000 time. */ 2001 skip = FALSE; 2002 relocate = FALSE; 2003 2004 outrel.r_offset = 2005 _bfd_elf_section_offset (output_bfd, info, input_section, 2006 rel->r_offset); 2007 if (outrel.r_offset == (bfd_vma) -1) 2008 skip = TRUE; 2009 else if (outrel.r_offset == (bfd_vma) -2) 2010 skip = TRUE, relocate = TRUE; 2011 2012 outrel.r_offset += (input_section->output_section->vma 2013 + input_section->output_offset); 2014 2015 if (skip) 2016 memset (&outrel, 0, sizeof outrel); 2017 2018 /* h->dynindx may be -1 if this symbol was marked to 2019 become local. */ 2020 else if (h != NULL 2021 && h->dynindx != -1 2022 && (r_type == R_X86_64_PC8 2023 || r_type == R_X86_64_PC16 2024 || r_type == R_X86_64_PC32 2025 || !info->shared 2026 || !info->symbolic 2027 || !h->def_regular)) 2028 { 2029 outrel.r_info = ELF64_R_INFO (h->dynindx, r_type); 2030 outrel.r_addend = rel->r_addend; 2031 } 2032 else 2033 { 2034 /* This symbol is local, or marked to become local. */ 2035 if (r_type == R_X86_64_64) 2036 { 2037 relocate = TRUE; 2038 outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE); 2039 outrel.r_addend = relocation + rel->r_addend; 2040 } 2041 else 2042 { 2043 long sindx; 2044 2045 if (bfd_is_abs_section (sec)) 2046 sindx = 0; 2047 else if (sec == NULL || sec->owner == NULL) 2048 { 2049 bfd_set_error (bfd_error_bad_value); 2050 return FALSE; 2051 } 2052 else 2053 { 2054 asection *osec; 2055 2056 osec = sec->output_section; 2057 sindx = elf_section_data (osec)->dynindx; 2058 BFD_ASSERT (sindx > 0); 2059 } 2060 2061 outrel.r_info = ELF64_R_INFO (sindx, r_type); 2062 outrel.r_addend = relocation + rel->r_addend; 2063 } 2064 } 2065 2066 sreloc = elf_section_data (input_section)->sreloc; 2067 if (sreloc == NULL) 2068 abort (); 2069 2070 loc = sreloc->contents; 2071 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela); 2072 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc); 2073 2074 /* If this reloc is against an external symbol, we do 2075 not want to fiddle with the addend. Otherwise, we 2076 need to include the symbol value so that it becomes 2077 an addend for the dynamic reloc. */ 2078 if (! relocate) 2079 continue; 2080 } 2081 2082 break; 2083 2084 case R_X86_64_TLSGD: 2085 case R_X86_64_GOTTPOFF: 2086 r_type = elf64_x86_64_tls_transition (info, r_type, h == NULL); 2087 tls_type = GOT_UNKNOWN; 2088 if (h == NULL && local_got_offsets) 2089 tls_type = elf64_x86_64_local_got_tls_type (input_bfd) [r_symndx]; 2090 else if (h != NULL) 2091 { 2092 tls_type = elf64_x86_64_hash_entry (h)->tls_type; 2093 if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE) 2094 r_type = R_X86_64_TPOFF32; 2095 } 2096 if (r_type == R_X86_64_TLSGD) 2097 { 2098 if (tls_type == GOT_TLS_IE) 2099 r_type = R_X86_64_GOTTPOFF; 2100 } 2101 2102 if (r_type == R_X86_64_TPOFF32) 2103 { 2104 BFD_ASSERT (! unresolved_reloc); 2105 if (ELF64_R_TYPE (rel->r_info) == R_X86_64_TLSGD) 2106 { 2107 unsigned int i; 2108 static unsigned char tlsgd[8] 2109 = { 0x66, 0x48, 0x8d, 0x3d, 0x66, 0x66, 0x48, 0xe8 }; 2110 2111 /* GD->LE transition. 2112 .byte 0x66; leaq foo@tlsgd(%rip), %rdi 2113 .word 0x6666; rex64; call __tls_get_addr@plt 2114 Change it into: 2115 movq %fs:0, %rax 2116 leaq foo@tpoff(%rax), %rax */ 2117 BFD_ASSERT (rel->r_offset >= 4); 2118 for (i = 0; i < 4; i++) 2119 BFD_ASSERT (bfd_get_8 (input_bfd, 2120 contents + rel->r_offset - 4 + i) 2121 == tlsgd[i]); 2122 BFD_ASSERT (rel->r_offset + 12 <= input_section->size); 2123 for (i = 0; i < 4; i++) 2124 BFD_ASSERT (bfd_get_8 (input_bfd, 2125 contents + rel->r_offset + 4 + i) 2126 == tlsgd[i+4]); 2127 BFD_ASSERT (rel + 1 < relend); 2128 BFD_ASSERT (ELF64_R_TYPE (rel[1].r_info) == R_X86_64_PLT32); 2129 memcpy (contents + rel->r_offset - 4, 2130 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0", 2131 16); 2132 bfd_put_32 (output_bfd, tpoff (info, relocation), 2133 contents + rel->r_offset + 8); 2134 /* Skip R_X86_64_PLT32. */ 2135 rel++; 2136 continue; 2137 } 2138 else 2139 { 2140 unsigned int val, type, reg; 2141 2142 /* IE->LE transition: 2143 Originally it can be one of: 2144 movq foo@gottpoff(%rip), %reg 2145 addq foo@gottpoff(%rip), %reg 2146 We change it into: 2147 movq $foo, %reg 2148 leaq foo(%reg), %reg 2149 addq $foo, %reg. */ 2150 BFD_ASSERT (rel->r_offset >= 3); 2151 val = bfd_get_8 (input_bfd, contents + rel->r_offset - 3); 2152 BFD_ASSERT (val == 0x48 || val == 0x4c); 2153 type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2); 2154 BFD_ASSERT (type == 0x8b || type == 0x03); 2155 reg = bfd_get_8 (input_bfd, contents + rel->r_offset - 1); 2156 BFD_ASSERT ((reg & 0xc7) == 5); 2157 reg >>= 3; 2158 BFD_ASSERT (rel->r_offset + 4 <= input_section->size); 2159 if (type == 0x8b) 2160 { 2161 /* movq */ 2162 if (val == 0x4c) 2163 bfd_put_8 (output_bfd, 0x49, 2164 contents + rel->r_offset - 3); 2165 bfd_put_8 (output_bfd, 0xc7, 2166 contents + rel->r_offset - 2); 2167 bfd_put_8 (output_bfd, 0xc0 | reg, 2168 contents + rel->r_offset - 1); 2169 } 2170 else if (reg == 4) 2171 { 2172 /* addq -> addq - addressing with %rsp/%r12 is 2173 special */ 2174 if (val == 0x4c) 2175 bfd_put_8 (output_bfd, 0x49, 2176 contents + rel->r_offset - 3); 2177 bfd_put_8 (output_bfd, 0x81, 2178 contents + rel->r_offset - 2); 2179 bfd_put_8 (output_bfd, 0xc0 | reg, 2180 contents + rel->r_offset - 1); 2181 } 2182 else 2183 { 2184 /* addq -> leaq */ 2185 if (val == 0x4c) 2186 bfd_put_8 (output_bfd, 0x4d, 2187 contents + rel->r_offset - 3); 2188 bfd_put_8 (output_bfd, 0x8d, 2189 contents + rel->r_offset - 2); 2190 bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3), 2191 contents + rel->r_offset - 1); 2192 } 2193 bfd_put_32 (output_bfd, tpoff (info, relocation), 2194 contents + rel->r_offset); 2195 continue; 2196 } 2197 } 2198 2199 if (htab->sgot == NULL) 2200 abort (); 2201 2202 if (h != NULL) 2203 off = h->got.offset; 2204 else 2205 { 2206 if (local_got_offsets == NULL) 2207 abort (); 2208 2209 off = local_got_offsets[r_symndx]; 2210 } 2211 2212 if ((off & 1) != 0) 2213 off &= ~1; 2214 else 2215 { 2216 Elf_Internal_Rela outrel; 2217 bfd_byte *loc; 2218 int dr_type, indx; 2219 2220 if (htab->srelgot == NULL) 2221 abort (); 2222 2223 outrel.r_offset = (htab->sgot->output_section->vma 2224 + htab->sgot->output_offset + off); 2225 2226 indx = h && h->dynindx != -1 ? h->dynindx : 0; 2227 if (r_type == R_X86_64_TLSGD) 2228 dr_type = R_X86_64_DTPMOD64; 2229 else 2230 dr_type = R_X86_64_TPOFF64; 2231 2232 bfd_put_64 (output_bfd, 0, htab->sgot->contents + off); 2233 outrel.r_addend = 0; 2234 if (dr_type == R_X86_64_TPOFF64 && indx == 0) 2235 outrel.r_addend = relocation - dtpoff_base (info); 2236 outrel.r_info = ELF64_R_INFO (indx, dr_type); 2237 2238 loc = htab->srelgot->contents; 2239 loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela); 2240 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc); 2241 2242 if (r_type == R_X86_64_TLSGD) 2243 { 2244 if (indx == 0) 2245 { 2246 BFD_ASSERT (! unresolved_reloc); 2247 bfd_put_64 (output_bfd, 2248 relocation - dtpoff_base (info), 2249 htab->sgot->contents + off + GOT_ENTRY_SIZE); 2250 } 2251 else 2252 { 2253 bfd_put_64 (output_bfd, 0, 2254 htab->sgot->contents + off + GOT_ENTRY_SIZE); 2255 outrel.r_info = ELF64_R_INFO (indx, 2256 R_X86_64_DTPOFF64); 2257 outrel.r_offset += GOT_ENTRY_SIZE; 2258 htab->srelgot->reloc_count++; 2259 loc += sizeof (Elf64_External_Rela); 2260 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc); 2261 } 2262 } 2263 2264 if (h != NULL) 2265 h->got.offset |= 1; 2266 else 2267 local_got_offsets[r_symndx] |= 1; 2268 } 2269 2270 if (off >= (bfd_vma) -2) 2271 abort (); 2272 if (r_type == ELF64_R_TYPE (rel->r_info)) 2273 { 2274 relocation = htab->sgot->output_section->vma 2275 + htab->sgot->output_offset + off; 2276 unresolved_reloc = FALSE; 2277 } 2278 else 2279 { 2280 unsigned int i; 2281 static unsigned char tlsgd[8] 2282 = { 0x66, 0x48, 0x8d, 0x3d, 0x66, 0x66, 0x48, 0xe8 }; 2283 2284 /* GD->IE transition. 2285 .byte 0x66; leaq foo@tlsgd(%rip), %rdi 2286 .word 0x6666; rex64; call __tls_get_addr@plt 2287 Change it into: 2288 movq %fs:0, %rax 2289 addq foo@gottpoff(%rip), %rax */ 2290 BFD_ASSERT (rel->r_offset >= 4); 2291 for (i = 0; i < 4; i++) 2292 BFD_ASSERT (bfd_get_8 (input_bfd, 2293 contents + rel->r_offset - 4 + i) 2294 == tlsgd[i]); 2295 BFD_ASSERT (rel->r_offset + 12 <= input_section->size); 2296 for (i = 0; i < 4; i++) 2297 BFD_ASSERT (bfd_get_8 (input_bfd, 2298 contents + rel->r_offset + 4 + i) 2299 == tlsgd[i+4]); 2300 BFD_ASSERT (rel + 1 < relend); 2301 BFD_ASSERT (ELF64_R_TYPE (rel[1].r_info) == R_X86_64_PLT32); 2302 memcpy (contents + rel->r_offset - 4, 2303 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0", 2304 16); 2305 2306 relocation = (htab->sgot->output_section->vma 2307 + htab->sgot->output_offset + off 2308 - rel->r_offset 2309 - input_section->output_section->vma 2310 - input_section->output_offset 2311 - 12); 2312 bfd_put_32 (output_bfd, relocation, 2313 contents + rel->r_offset + 8); 2314 /* Skip R_X86_64_PLT32. */ 2315 rel++; 2316 continue; 2317 } 2318 break; 2319 2320 case R_X86_64_TLSLD: 2321 if (! info->shared) 2322 { 2323 /* LD->LE transition: 2324 Ensure it is: 2325 leaq foo@tlsld(%rip), %rdi; call __tls_get_addr@plt. 2326 We change it into: 2327 .word 0x6666; .byte 0x66; movl %fs:0, %rax. */ 2328 BFD_ASSERT (rel->r_offset >= 3); 2329 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 3) 2330 == 0x48); 2331 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2) 2332 == 0x8d); 2333 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 1) 2334 == 0x3d); 2335 BFD_ASSERT (rel->r_offset + 9 <= input_section->size); 2336 BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4) 2337 == 0xe8); 2338 BFD_ASSERT (rel + 1 < relend); 2339 BFD_ASSERT (ELF64_R_TYPE (rel[1].r_info) == R_X86_64_PLT32); 2340 memcpy (contents + rel->r_offset - 3, 2341 "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12); 2342 /* Skip R_X86_64_PLT32. */ 2343 rel++; 2344 continue; 2345 } 2346 2347 if (htab->sgot == NULL) 2348 abort (); 2349 2350 off = htab->tls_ld_got.offset; 2351 if (off & 1) 2352 off &= ~1; 2353 else 2354 { 2355 Elf_Internal_Rela outrel; 2356 bfd_byte *loc; 2357 2358 if (htab->srelgot == NULL) 2359 abort (); 2360 2361 outrel.r_offset = (htab->sgot->output_section->vma 2362 + htab->sgot->output_offset + off); 2363 2364 bfd_put_64 (output_bfd, 0, 2365 htab->sgot->contents + off); 2366 bfd_put_64 (output_bfd, 0, 2367 htab->sgot->contents + off + GOT_ENTRY_SIZE); 2368 outrel.r_info = ELF64_R_INFO (0, R_X86_64_DTPMOD64); 2369 outrel.r_addend = 0; 2370 loc = htab->srelgot->contents; 2371 loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela); 2372 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc); 2373 htab->tls_ld_got.offset |= 1; 2374 } 2375 relocation = htab->sgot->output_section->vma 2376 + htab->sgot->output_offset + off; 2377 unresolved_reloc = FALSE; 2378 break; 2379 2380 case R_X86_64_DTPOFF32: 2381 if (info->shared || (input_section->flags & SEC_CODE) == 0) 2382 relocation -= dtpoff_base (info); 2383 else 2384 relocation = tpoff (info, relocation); 2385 break; 2386 2387 case R_X86_64_TPOFF32: 2388 BFD_ASSERT (! info->shared); 2389 relocation = tpoff (info, relocation); 2390 break; 2391 2392 default: 2393 break; 2394 } 2395 2396 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections 2397 because such sections are not SEC_ALLOC and thus ld.so will 2398 not process them. */ 2399 if (unresolved_reloc 2400 && !((input_section->flags & SEC_DEBUGGING) != 0 2401 && h->def_dynamic)) 2402 (*_bfd_error_handler) 2403 (_("%B(%A+0x%lx): unresolvable relocation against symbol `%s'"), 2404 input_bfd, 2405 input_section, 2406 (long) rel->r_offset, 2407 h->root.root.string); 2408 2409 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 2410 contents, rel->r_offset, 2411 relocation, rel->r_addend); 2412 2413 if (r != bfd_reloc_ok) 2414 { 2415 const char *name; 2416 2417 if (h != NULL) 2418 name = h->root.root.string; 2419 else 2420 { 2421 name = bfd_elf_string_from_elf_section (input_bfd, 2422 symtab_hdr->sh_link, 2423 sym->st_name); 2424 if (name == NULL) 2425 return FALSE; 2426 if (*name == '\0') 2427 name = bfd_section_name (input_bfd, sec); 2428 } 2429 2430 if (r == bfd_reloc_overflow) 2431 { 2432 if (h != NULL 2433 && h->root.type == bfd_link_hash_undefweak 2434 && howto->pc_relative) 2435 /* Ignore reloc overflow on branches to undefweak syms. */ 2436 continue; 2437 2438 if (! ((*info->callbacks->reloc_overflow) 2439 (info, name, howto->name, (bfd_vma) 0, 2440 input_bfd, input_section, rel->r_offset))) 2441 return FALSE; 2442 } 2443 else 2444 { 2445 (*_bfd_error_handler) 2446 (_("%B(%A+0x%lx): reloc against `%s': error %d"), 2447 input_bfd, input_section, 2448 (long) rel->r_offset, name, (int) r); 2449 return FALSE; 2450 } 2451 } 2452 } 2453 2454 return TRUE; 2455} 2456 2457/* Finish up dynamic symbol handling. We set the contents of various 2458 dynamic sections here. */ 2459 2460static bfd_boolean 2461elf64_x86_64_finish_dynamic_symbol (bfd *output_bfd, 2462 struct bfd_link_info *info, 2463 struct elf_link_hash_entry *h, 2464 Elf_Internal_Sym *sym) 2465{ 2466 struct elf64_x86_64_link_hash_table *htab; 2467 2468 htab = elf64_x86_64_hash_table (info); 2469 2470 if (h->plt.offset != (bfd_vma) -1) 2471 { 2472 bfd_vma plt_index; 2473 bfd_vma got_offset; 2474 Elf_Internal_Rela rela; 2475 bfd_byte *loc; 2476 2477 /* This symbol has an entry in the procedure linkage table. Set 2478 it up. */ 2479 if (h->dynindx == -1 2480 || htab->splt == NULL 2481 || htab->sgotplt == NULL 2482 || htab->srelplt == NULL) 2483 abort (); 2484 2485 /* Get the index in the procedure linkage table which 2486 corresponds to this symbol. This is the index of this symbol 2487 in all the symbols for which we are making plt entries. The 2488 first entry in the procedure linkage table is reserved. */ 2489 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1; 2490 2491 /* Get the offset into the .got table of the entry that 2492 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE 2493 bytes. The first three are reserved for the dynamic linker. */ 2494 got_offset = (plt_index + 3) * GOT_ENTRY_SIZE; 2495 2496 /* Fill in the entry in the procedure linkage table. */ 2497 memcpy (htab->splt->contents + h->plt.offset, elf64_x86_64_plt_entry, 2498 PLT_ENTRY_SIZE); 2499 2500 /* Insert the relocation positions of the plt section. The magic 2501 numbers at the end of the statements are the positions of the 2502 relocations in the plt section. */ 2503 /* Put offset for jmp *name@GOTPCREL(%rip), since the 2504 instruction uses 6 bytes, subtract this value. */ 2505 bfd_put_32 (output_bfd, 2506 (htab->sgotplt->output_section->vma 2507 + htab->sgotplt->output_offset 2508 + got_offset 2509 - htab->splt->output_section->vma 2510 - htab->splt->output_offset 2511 - h->plt.offset 2512 - 6), 2513 htab->splt->contents + h->plt.offset + 2); 2514 /* Put relocation index. */ 2515 bfd_put_32 (output_bfd, plt_index, 2516 htab->splt->contents + h->plt.offset + 7); 2517 /* Put offset for jmp .PLT0. */ 2518 bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE), 2519 htab->splt->contents + h->plt.offset + 12); 2520 2521 /* Fill in the entry in the global offset table, initially this 2522 points to the pushq instruction in the PLT which is at offset 6. */ 2523 bfd_put_64 (output_bfd, (htab->splt->output_section->vma 2524 + htab->splt->output_offset 2525 + h->plt.offset + 6), 2526 htab->sgotplt->contents + got_offset); 2527 2528 /* Fill in the entry in the .rela.plt section. */ 2529 rela.r_offset = (htab->sgotplt->output_section->vma 2530 + htab->sgotplt->output_offset 2531 + got_offset); 2532 rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_JUMP_SLOT); 2533 rela.r_addend = 0; 2534 loc = htab->srelplt->contents + plt_index * sizeof (Elf64_External_Rela); 2535 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc); 2536 2537 if (!h->def_regular) 2538 { 2539 /* Mark the symbol as undefined, rather than as defined in 2540 the .plt section. Leave the value if there were any 2541 relocations where pointer equality matters (this is a clue 2542 for the dynamic linker, to make function pointer 2543 comparisons work between an application and shared 2544 library), otherwise set it to zero. If a function is only 2545 called from a binary, there is no need to slow down 2546 shared libraries because of that. */ 2547 sym->st_shndx = SHN_UNDEF; 2548 if (!h->pointer_equality_needed) 2549 sym->st_value = 0; 2550 } 2551 } 2552 2553 if (h->got.offset != (bfd_vma) -1 2554 && elf64_x86_64_hash_entry (h)->tls_type != GOT_TLS_GD 2555 && elf64_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE) 2556 { 2557 Elf_Internal_Rela rela; 2558 bfd_byte *loc; 2559 2560 /* This symbol has an entry in the global offset table. Set it 2561 up. */ 2562 if (htab->sgot == NULL || htab->srelgot == NULL) 2563 abort (); 2564 2565 rela.r_offset = (htab->sgot->output_section->vma 2566 + htab->sgot->output_offset 2567 + (h->got.offset &~ (bfd_vma) 1)); 2568 2569 /* If this is a static link, or it is a -Bsymbolic link and the 2570 symbol is defined locally or was forced to be local because 2571 of a version file, we just want to emit a RELATIVE reloc. 2572 The entry in the global offset table will already have been 2573 initialized in the relocate_section function. */ 2574 if (info->shared 2575 && SYMBOL_REFERENCES_LOCAL (info, h)) 2576 { 2577 BFD_ASSERT((h->got.offset & 1) != 0); 2578 rela.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE); 2579 rela.r_addend = (h->root.u.def.value 2580 + h->root.u.def.section->output_section->vma 2581 + h->root.u.def.section->output_offset); 2582 } 2583 else 2584 { 2585 BFD_ASSERT((h->got.offset & 1) == 0); 2586 bfd_put_64 (output_bfd, (bfd_vma) 0, 2587 htab->sgot->contents + h->got.offset); 2588 rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_GLOB_DAT); 2589 rela.r_addend = 0; 2590 } 2591 2592 loc = htab->srelgot->contents; 2593 loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela); 2594 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc); 2595 } 2596 2597 if (h->needs_copy) 2598 { 2599 Elf_Internal_Rela rela; 2600 bfd_byte *loc; 2601 2602 /* This symbol needs a copy reloc. Set it up. */ 2603 2604 if (h->dynindx == -1 2605 || (h->root.type != bfd_link_hash_defined 2606 && h->root.type != bfd_link_hash_defweak) 2607 || htab->srelbss == NULL) 2608 abort (); 2609 2610 rela.r_offset = (h->root.u.def.value 2611 + h->root.u.def.section->output_section->vma 2612 + h->root.u.def.section->output_offset); 2613 rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_COPY); 2614 rela.r_addend = 0; 2615 loc = htab->srelbss->contents; 2616 loc += htab->srelbss->reloc_count++ * sizeof (Elf64_External_Rela); 2617 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc); 2618 } 2619 2620 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */ 2621 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 2622 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 2623 sym->st_shndx = SHN_ABS; 2624 2625 return TRUE; 2626} 2627 2628/* Used to decide how to sort relocs in an optimal manner for the 2629 dynamic linker, before writing them out. */ 2630 2631static enum elf_reloc_type_class 2632elf64_x86_64_reloc_type_class (const Elf_Internal_Rela *rela) 2633{ 2634 switch ((int) ELF64_R_TYPE (rela->r_info)) 2635 { 2636 case R_X86_64_RELATIVE: 2637 return reloc_class_relative; 2638 case R_X86_64_JUMP_SLOT: 2639 return reloc_class_plt; 2640 case R_X86_64_COPY: 2641 return reloc_class_copy; 2642 default: 2643 return reloc_class_normal; 2644 } 2645} 2646 2647/* Finish up the dynamic sections. */ 2648 2649static bfd_boolean 2650elf64_x86_64_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info) 2651{ 2652 struct elf64_x86_64_link_hash_table *htab; 2653 bfd *dynobj; 2654 asection *sdyn; 2655 2656 htab = elf64_x86_64_hash_table (info); 2657 dynobj = htab->elf.dynobj; 2658 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 2659 2660 if (htab->elf.dynamic_sections_created) 2661 { 2662 Elf64_External_Dyn *dyncon, *dynconend; 2663 2664 if (sdyn == NULL || htab->sgot == NULL) 2665 abort (); 2666 2667 dyncon = (Elf64_External_Dyn *) sdyn->contents; 2668 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size); 2669 for (; dyncon < dynconend; dyncon++) 2670 { 2671 Elf_Internal_Dyn dyn; 2672 asection *s; 2673 2674 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn); 2675 2676 switch (dyn.d_tag) 2677 { 2678 default: 2679 continue; 2680 2681 case DT_PLTGOT: 2682 s = htab->sgotplt; 2683 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 2684 break; 2685 2686 case DT_JMPREL: 2687 dyn.d_un.d_ptr = htab->srelplt->output_section->vma; 2688 break; 2689 2690 case DT_PLTRELSZ: 2691 s = htab->srelplt->output_section; 2692 dyn.d_un.d_val = s->size; 2693 break; 2694 2695 case DT_RELASZ: 2696 /* The procedure linkage table relocs (DT_JMPREL) should 2697 not be included in the overall relocs (DT_RELA). 2698 Therefore, we override the DT_RELASZ entry here to 2699 make it not include the JMPREL relocs. Since the 2700 linker script arranges for .rela.plt to follow all 2701 other relocation sections, we don't have to worry 2702 about changing the DT_RELA entry. */ 2703 if (htab->srelplt != NULL) 2704 { 2705 s = htab->srelplt->output_section; 2706 dyn.d_un.d_val -= s->size; 2707 } 2708 break; 2709 } 2710 2711 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon); 2712 } 2713 2714 /* Fill in the special first entry in the procedure linkage table. */ 2715 if (htab->splt && htab->splt->size > 0) 2716 { 2717 /* Fill in the first entry in the procedure linkage table. */ 2718 memcpy (htab->splt->contents, elf64_x86_64_plt0_entry, 2719 PLT_ENTRY_SIZE); 2720 /* Add offset for pushq GOT+8(%rip), since the instruction 2721 uses 6 bytes subtract this value. */ 2722 bfd_put_32 (output_bfd, 2723 (htab->sgotplt->output_section->vma 2724 + htab->sgotplt->output_offset 2725 + 8 2726 - htab->splt->output_section->vma 2727 - htab->splt->output_offset 2728 - 6), 2729 htab->splt->contents + 2); 2730 /* Add offset for jmp *GOT+16(%rip). The 12 is the offset to 2731 the end of the instruction. */ 2732 bfd_put_32 (output_bfd, 2733 (htab->sgotplt->output_section->vma 2734 + htab->sgotplt->output_offset 2735 + 16 2736 - htab->splt->output_section->vma 2737 - htab->splt->output_offset 2738 - 12), 2739 htab->splt->contents + 8); 2740 2741 elf_section_data (htab->splt->output_section)->this_hdr.sh_entsize = 2742 PLT_ENTRY_SIZE; 2743 } 2744 } 2745 2746 if (htab->sgotplt) 2747 { 2748 /* Fill in the first three entries in the global offset table. */ 2749 if (htab->sgotplt->size > 0) 2750 { 2751 /* Set the first entry in the global offset table to the address of 2752 the dynamic section. */ 2753 if (sdyn == NULL) 2754 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents); 2755 else 2756 bfd_put_64 (output_bfd, 2757 sdyn->output_section->vma + sdyn->output_offset, 2758 htab->sgotplt->contents); 2759 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */ 2760 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + GOT_ENTRY_SIZE); 2761 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + GOT_ENTRY_SIZE*2); 2762 } 2763 2764 elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize = 2765 GOT_ENTRY_SIZE; 2766 } 2767 2768 if (htab->sgot && htab->sgot->size > 0) 2769 elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize 2770 = GOT_ENTRY_SIZE; 2771 2772 return TRUE; 2773} 2774 2775/* Return address for Ith PLT stub in section PLT, for relocation REL 2776 or (bfd_vma) -1 if it should not be included. */ 2777 2778static bfd_vma 2779elf64_x86_64_plt_sym_val (bfd_vma i, const asection *plt, 2780 const arelent *rel ATTRIBUTE_UNUSED) 2781{ 2782 return plt->vma + (i + 1) * PLT_ENTRY_SIZE; 2783} 2784 2785/* Handle an x86-64 specific section when reading an object file. This 2786 is called when elfcode.h finds a section with an unknown type. */ 2787 2788static bfd_boolean 2789elf64_x86_64_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr, const char *name) 2790{ 2791 if (hdr->sh_type != SHT_X86_64_UNWIND) 2792 return FALSE; 2793 2794 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name)) 2795 return FALSE; 2796 2797 return TRUE; 2798} 2799 2800#define TARGET_LITTLE_SYM bfd_elf64_x86_64_vec 2801#define TARGET_LITTLE_NAME "elf64-x86-64" 2802#define ELF_ARCH bfd_arch_i386 2803#define ELF_MACHINE_CODE EM_X86_64 2804#define ELF_MAXPAGESIZE 0x100000 2805 2806#define elf_backend_can_gc_sections 1 2807#define elf_backend_can_refcount 1 2808#define elf_backend_want_got_plt 1 2809#define elf_backend_plt_readonly 1 2810#define elf_backend_want_plt_sym 0 2811#define elf_backend_got_header_size (GOT_ENTRY_SIZE*3) 2812#define elf_backend_rela_normal 1 2813 2814#define elf_info_to_howto elf64_x86_64_info_to_howto 2815 2816#define bfd_elf64_bfd_link_hash_table_create \ 2817 elf64_x86_64_link_hash_table_create 2818#define bfd_elf64_bfd_reloc_type_lookup elf64_x86_64_reloc_type_lookup 2819 2820#define elf_backend_adjust_dynamic_symbol elf64_x86_64_adjust_dynamic_symbol 2821#define elf_backend_check_relocs elf64_x86_64_check_relocs 2822#define elf_backend_copy_indirect_symbol elf64_x86_64_copy_indirect_symbol 2823#define elf_backend_create_dynamic_sections elf64_x86_64_create_dynamic_sections 2824#define elf_backend_finish_dynamic_sections elf64_x86_64_finish_dynamic_sections 2825#define elf_backend_finish_dynamic_symbol elf64_x86_64_finish_dynamic_symbol 2826#define elf_backend_gc_mark_hook elf64_x86_64_gc_mark_hook 2827#define elf_backend_gc_sweep_hook elf64_x86_64_gc_sweep_hook 2828#define elf_backend_grok_prstatus elf64_x86_64_grok_prstatus 2829#define elf_backend_grok_psinfo elf64_x86_64_grok_psinfo 2830#define elf_backend_reloc_type_class elf64_x86_64_reloc_type_class 2831#define elf_backend_relocate_section elf64_x86_64_relocate_section 2832#define elf_backend_size_dynamic_sections elf64_x86_64_size_dynamic_sections 2833#define elf_backend_plt_sym_val elf64_x86_64_plt_sym_val 2834#define elf_backend_object_p elf64_x86_64_elf_object_p 2835#define bfd_elf64_mkobject elf64_x86_64_mkobject 2836 2837#define elf_backend_section_from_shdr \ 2838 elf64_x86_64_section_from_shdr 2839 2840#include "elf64-target.h" 2841