bfd/elf64-x86-64.c

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