bfd/elf64-x86-64.c

   1 /* X86-64 specific support for 64-bit ELF
   2    Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
   3    Free Software Foundation, Inc.
   4    Contributed by Jan Hubicka <jh@suse.cz>.
   5
   6    This file is part of BFD, the Binary File Descriptor library.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21    MA 02110-1301, USA.  */
  22
  23 #include "sysdep.h"
  24 #include "bfd.h"
  25 #include "bfdlink.h"
  26 #include "libbfd.h"
  27 #include "elf-bfd.h"
  28
  29 #include "elf/x86-64.h"
  30
  31 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value.  */
  32 #define MINUS_ONE (~ (bfd_vma) 0)
  33
  34 /* The relocation "howto" table.  Order of fields:
  35    type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
  36    special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset.  */
  37 static reloc_howto_type x86_64_elf_howto_table[] =
  38 {
  39   HOWTO(R_X86_64_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
  40         bfd_elf_generic_reloc, "R_X86_64_NONE", FALSE, 0x00000000, 0x00000000,
  41         FALSE),
  42   HOWTO(R_X86_64_64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  43         bfd_elf_generic_reloc, "R_X86_64_64", FALSE, MINUS_ONE, MINUS_ONE,
  44         FALSE),
  45   HOWTO(R_X86_64_PC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
  46         bfd_elf_generic_reloc, "R_X86_64_PC32", FALSE, 0xffffffff, 0xffffffff,
  47         TRUE),
  48   HOWTO(R_X86_64_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
  49         bfd_elf_generic_reloc, "R_X86_64_GOT32", FALSE, 0xffffffff, 0xffffffff,
  50         FALSE),
  51   HOWTO(R_X86_64_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
  52         bfd_elf_generic_reloc, "R_X86_64_PLT32", FALSE, 0xffffffff, 0xffffffff,
  53         TRUE),
  54   HOWTO(R_X86_64_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  55         bfd_elf_generic_reloc, "R_X86_64_COPY", FALSE, 0xffffffff, 0xffffffff,
  56         FALSE),
  57   HOWTO(R_X86_64_GLOB_DAT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  58         bfd_elf_generic_reloc, "R_X86_64_GLOB_DAT", FALSE, MINUS_ONE,
  59         MINUS_ONE, FALSE),
  60   HOWTO(R_X86_64_JUMP_SLOT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  61         bfd_elf_generic_reloc, "R_X86_64_JUMP_SLOT", FALSE, MINUS_ONE,
  62         MINUS_ONE, FALSE),
  63   HOWTO(R_X86_64_RELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  64         bfd_elf_generic_reloc, "R_X86_64_RELATIVE", FALSE, MINUS_ONE,
  65         MINUS_ONE, FALSE),
  66   HOWTO(R_X86_64_GOTPCREL, 0, 2, 32, TRUE, 0, complain_overflow_signed,
  67         bfd_elf_generic_reloc, "R_X86_64_GOTPCREL", FALSE, 0xffffffff,
  68         0xffffffff, TRUE),
  69   HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
  70         bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
  71         FALSE),
  72   HOWTO(R_X86_64_32S, 0, 2, 32, FALSE, 0, complain_overflow_signed,
  73         bfd_elf_generic_reloc, "R_X86_64_32S", FALSE, 0xffffffff, 0xffffffff,
  74         FALSE),
  75   HOWTO(R_X86_64_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
  76         bfd_elf_generic_reloc, "R_X86_64_16", FALSE, 0xffff, 0xffff, FALSE),
  77   HOWTO(R_X86_64_PC16,0, 1, 16, TRUE, 0, complain_overflow_bitfield,
  78         bfd_elf_generic_reloc, "R_X86_64_PC16", FALSE, 0xffff, 0xffff, TRUE),
  79   HOWTO(R_X86_64_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
  80         bfd_elf_generic_reloc, "R_X86_64_8", FALSE, 0xff, 0xff, FALSE),
  81   HOWTO(R_X86_64_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
  82         bfd_elf_generic_reloc, "R_X86_64_PC8", FALSE, 0xff, 0xff, TRUE),
  83   HOWTO(R_X86_64_DTPMOD64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  84         bfd_elf_generic_reloc, "R_X86_64_DTPMOD64", FALSE, MINUS_ONE,
  85         MINUS_ONE, FALSE),
  86   HOWTO(R_X86_64_DTPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  87         bfd_elf_generic_reloc, "R_X86_64_DTPOFF64", FALSE, MINUS_ONE,
  88         MINUS_ONE, FALSE),
  89   HOWTO(R_X86_64_TPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  90         bfd_elf_generic_reloc, "R_X86_64_TPOFF64", FALSE, MINUS_ONE,
  91         MINUS_ONE, FALSE),
  92   HOWTO(R_X86_64_TLSGD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
  93         bfd_elf_generic_reloc, "R_X86_64_TLSGD", FALSE, 0xffffffff,
  94         0xffffffff, TRUE),
  95   HOWTO(R_X86_64_TLSLD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
  96         bfd_elf_generic_reloc, "R_X86_64_TLSLD", FALSE, 0xffffffff,
  97         0xffffffff, TRUE),
  98   HOWTO(R_X86_64_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
  99         bfd_elf_generic_reloc, "R_X86_64_DTPOFF32", FALSE, 0xffffffff,
 100         0xffffffff, FALSE),
 101   HOWTO(R_X86_64_GOTTPOFF, 0, 2, 32, TRUE, 0, complain_overflow_signed,
 102         bfd_elf_generic_reloc, "R_X86_64_GOTTPOFF", FALSE, 0xffffffff,
 103         0xffffffff, TRUE),
 104   HOWTO(R_X86_64_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
 105         bfd_elf_generic_reloc, "R_X86_64_TPOFF32", FALSE, 0xffffffff,
 106         0xffffffff, FALSE),
 107   HOWTO(R_X86_64_PC64, 0, 4, 64, TRUE, 0, complain_overflow_bitfield,
 108         bfd_elf_generic_reloc, "R_X86_64_PC64", FALSE, MINUS_ONE, MINUS_ONE,
 109         TRUE),
 110   HOWTO(R_X86_64_GOTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 111         bfd_elf_generic_reloc, "R_X86_64_GOTOFF64",
 112         FALSE, MINUS_ONE, MINUS_ONE, FALSE),
 113   HOWTO(R_X86_64_GOTPC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
 114         bfd_elf_generic_reloc, "R_X86_64_GOTPC32",
 115         FALSE, 0xffffffff, 0xffffffff, TRUE),
 116   HOWTO(R_X86_64_GOT64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
 117         bfd_elf_generic_reloc, "R_X86_64_GOT64", FALSE, MINUS_ONE, MINUS_ONE,
 118         FALSE),
 119   HOWTO(R_X86_64_GOTPCREL64, 0, 4, 64, TRUE, 0, complain_overflow_signed,
 120         bfd_elf_generic_reloc, "R_X86_64_GOTPCREL64", FALSE, MINUS_ONE,
 121         MINUS_ONE, TRUE),
 122   HOWTO(R_X86_64_GOTPC64, 0, 4, 64, TRUE, 0, complain_overflow_signed,
 123         bfd_elf_generic_reloc, "R_X86_64_GOTPC64",
 124         FALSE, MINUS_ONE, MINUS_ONE, TRUE),
 125   HOWTO(R_X86_64_GOTPLT64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
 126         bfd_elf_generic_reloc, "R_X86_64_GOTPLT64", FALSE, MINUS_ONE,
 127         MINUS_ONE, FALSE),
 128   HOWTO(R_X86_64_PLTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
 129         bfd_elf_generic_reloc, "R_X86_64_PLTOFF64", FALSE, MINUS_ONE,
 130         MINUS_ONE, FALSE),
 131   EMPTY_HOWTO (32),
 132   EMPTY_HOWTO (33),
 133   HOWTO(R_X86_64_GOTPC32_TLSDESC, 0, 2, 32, TRUE, 0,
 134         complain_overflow_bitfield, bfd_elf_generic_reloc,
 135         "R_X86_64_GOTPC32_TLSDESC",
 136         FALSE, 0xffffffff, 0xffffffff, TRUE),
 137   HOWTO(R_X86_64_TLSDESC_CALL, 0, 0, 0, FALSE, 0,
 138         complain_overflow_dont, bfd_elf_generic_reloc,
 139         "R_X86_64_TLSDESC_CALL",
 140         FALSE, 0, 0, FALSE),
 141   HOWTO(R_X86_64_TLSDESC, 0, 4, 64, FALSE, 0,
 142         complain_overflow_bitfield, bfd_elf_generic_reloc,
 143         "R_X86_64_TLSDESC",
 144         FALSE, MINUS_ONE, MINUS_ONE, FALSE),
 145
 146   /* We have a gap in the reloc numbers here.
 147      R_X86_64_standard counts the number up to this point, and
 148      R_X86_64_vt_offset is the value to subtract from a reloc type of
 149      R_X86_64_GNU_VT* to form an index into this table.  */
 150 #define R_X86_64_standard (R_X86_64_TLSDESC + 1)
 151 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
 152
 153 /* GNU extension to record C++ vtable hierarchy.  */
 154   HOWTO (R_X86_64_GNU_VTINHERIT, 0, 4, 0, FALSE, 0, complain_overflow_dont,
 155          NULL, "R_X86_64_GNU_VTINHERIT", FALSE, 0, 0, FALSE),
 156
 157 /* GNU extension to record C++ vtable member usage.  */
 158   HOWTO (R_X86_64_GNU_VTENTRY, 0, 4, 0, FALSE, 0, complain_overflow_dont,
 159          _bfd_elf_rel_vtable_reloc_fn, "R_X86_64_GNU_VTENTRY", FALSE, 0, 0,
 160          FALSE)
 161 };
 162
 163 /* Map BFD relocs to the x86_64 elf relocs.  */
 164 struct elf_reloc_map
 165 {
 166   bfd_reloc_code_real_type bfd_reloc_val;
 167   unsigned char elf_reloc_val;
 168 };
 169
 170 static const struct elf_reloc_map x86_64_reloc_map[] =
 171 {
 172   { BFD_RELOC_NONE,             R_X86_64_NONE, },
 173   { BFD_RELOC_64,               R_X86_64_64,   },
 174   { BFD_RELOC_32_PCREL,         R_X86_64_PC32, },
 175   { BFD_RELOC_X86_64_GOT32,     R_X86_64_GOT32,},
 176   { BFD_RELOC_X86_64_PLT32,     R_X86_64_PLT32,},
 177   { BFD_RELOC_X86_64_COPY,      R_X86_64_COPY, },
 178   { BFD_RELOC_X86_64_GLOB_DAT,  R_X86_64_GLOB_DAT, },
 179   { BFD_RELOC_X86_64_JUMP_SLOT, R_X86_64_JUMP_SLOT, },
 180   { BFD_RELOC_X86_64_RELATIVE,  R_X86_64_RELATIVE, },
 181   { BFD_RELOC_X86_64_GOTPCREL,  R_X86_64_GOTPCREL, },
 182   { BFD_RELOC_32,               R_X86_64_32, },
 183   { BFD_RELOC_X86_64_32S,       R_X86_64_32S, },
 184   { BFD_RELOC_16,               R_X86_64_16, },
 185   { BFD_RELOC_16_PCREL,         R_X86_64_PC16, },
 186   { BFD_RELOC_8,                R_X86_64_8, },
 187   { BFD_RELOC_8_PCREL,          R_X86_64_PC8, },
 188   { BFD_RELOC_X86_64_DTPMOD64,  R_X86_64_DTPMOD64, },
 189   { BFD_RELOC_X86_64_DTPOFF64,  R_X86_64_DTPOFF64, },
 190   { BFD_RELOC_X86_64_TPOFF64,   R_X86_64_TPOFF64, },
 191   { BFD_RELOC_X86_64_TLSGD,     R_X86_64_TLSGD, },
 192   { BFD_RELOC_X86_64_TLSLD,     R_X86_64_TLSLD, },
 193   { BFD_RELOC_X86_64_DTPOFF32,  R_X86_64_DTPOFF32, },
 194   { BFD_RELOC_X86_64_GOTTPOFF,  R_X86_64_GOTTPOFF, },
 195   { BFD_RELOC_X86_64_TPOFF32,   R_X86_64_TPOFF32, },
 196   { BFD_RELOC_64_PCREL,         R_X86_64_PC64, },
 197   { BFD_RELOC_X86_64_GOTOFF64,  R_X86_64_GOTOFF64, },
 198   { BFD_RELOC_X86_64_GOTPC32,   R_X86_64_GOTPC32, },
 199   { BFD_RELOC_X86_64_GOT64,     R_X86_64_GOT64, },
 200   { BFD_RELOC_X86_64_GOTPCREL64,R_X86_64_GOTPCREL64, },
 201   { BFD_RELOC_X86_64_GOTPC64,   R_X86_64_GOTPC64, },
 202   { BFD_RELOC_X86_64_GOTPLT64,  R_X86_64_GOTPLT64, },
 203   { BFD_RELOC_X86_64_PLTOFF64,  R_X86_64_PLTOFF64, },
 204   { BFD_RELOC_X86_64_GOTPC32_TLSDESC, R_X86_64_GOTPC32_TLSDESC, },
 205   { BFD_RELOC_X86_64_TLSDESC_CALL, R_X86_64_TLSDESC_CALL, },
 206   { BFD_RELOC_X86_64_TLSDESC,   R_X86_64_TLSDESC, },
 207   { BFD_RELOC_VTABLE_INHERIT,   R_X86_64_GNU_VTINHERIT, },
 208   { BFD_RELOC_VTABLE_ENTRY,     R_X86_64_GNU_VTENTRY, },
 209 };
 210
 211 static reloc_howto_type *
 212 elf64_x86_64_rtype_to_howto (bfd *abfd, unsigned r_type)
 213 {
 214   unsigned i;
 215
 216   if (r_type < (unsigned int) R_X86_64_GNU_VTINHERIT
 217       || r_type >= (unsigned int) R_X86_64_max)
 218     {
 219       if (r_type >= (unsigned int) R_X86_64_standard)
 220         {
 221           (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
 222                                  abfd, (int) r_type);
 223           r_type = R_X86_64_NONE;
 224         }
 225       i = r_type;
 226     }
 227   else
 228     i = r_type - (unsigned int) R_X86_64_vt_offset;
 229   BFD_ASSERT (x86_64_elf_howto_table[i].type == r_type);
 230   return &x86_64_elf_howto_table[i];
 231 }
 232
 233 /* Given a BFD reloc type, return a HOWTO structure.  */
 234 static reloc_howto_type *
 235 elf64_x86_64_reloc_type_lookup (bfd *abfd,
 236                                 bfd_reloc_code_real_type code)
 237 {
 238   unsigned int i;
 239
 240   for (i = 0; i < sizeof (x86_64_reloc_map) / sizeof (struct elf_reloc_map);
 241        i++)
 242     {
 243       if (x86_64_reloc_map[i].bfd_reloc_val == code)
 244         return elf64_x86_64_rtype_to_howto (abfd,
 245                                             x86_64_reloc_map[i].elf_reloc_val);
 246     }
 247   return 0;
 248 }
 249
 250 static reloc_howto_type *
 251 elf64_x86_64_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 252                                 const char *r_name)
 253 {
 254   unsigned int i;
 255
 256   for (i = 0;
 257        i < (sizeof (x86_64_elf_howto_table)
 258             / sizeof (x86_64_elf_howto_table[0]));
 259        i++)
 260     if (x86_64_elf_howto_table[i].name != NULL
 261         && strcasecmp (x86_64_elf_howto_table[i].name, r_name) == 0)
 262       return &x86_64_elf_howto_table[i];
 263
 264   return NULL;
 265 }
 266
 267 /* Given an x86_64 ELF reloc type, fill in an arelent structure.  */
 268
 269 static void
 270 elf64_x86_64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
 271                             Elf_Internal_Rela *dst)
 272 {
 273   unsigned r_type;
 274
 275   r_type = ELF64_R_TYPE (dst->r_info);
 276   cache_ptr->howto = elf64_x86_64_rtype_to_howto (abfd, r_type);
 277   BFD_ASSERT (r_type == cache_ptr->howto->type);
 278 }
 279 \f
 280 /* Support for core dump NOTE sections.  */
 281 static bfd_boolean
 282 elf64_x86_64_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
 283 {
 284   int offset;
 285   size_t size;
 286
 287   switch (note->descsz)
 288     {
 289       default:
 290         return FALSE;
 291
 292       case 336:         /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
 293         /* pr_cursig */
 294         elf_tdata (abfd)->core_signal
 295           = bfd_get_16 (abfd, note->descdata + 12);
 296
 297         /* pr_pid */
 298         elf_tdata (abfd)->core_pid
 299           = bfd_get_32 (abfd, note->descdata + 32);
 300
 301         /* pr_reg */
 302         offset = 112;
 303         size = 216;
 304
 305         break;
 306     }
 307
 308   /* Make a ".reg/999" section.  */
 309   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
 310                                           size, note->descpos + offset);
 311 }
 312
 313 static bfd_boolean
 314 elf64_x86_64_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
 315 {
 316   switch (note->descsz)
 317     {
 318       default:
 319         return FALSE;
 320
 321       case 136:         /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
 322         elf_tdata (abfd)->core_program
 323          = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
 324         elf_tdata (abfd)->core_command
 325          = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
 326     }
 327
 328   /* Note that for some reason, a spurious space is tacked
 329      onto the end of the args in some (at least one anyway)
 330      implementations, so strip it off if it exists.  */
 331
 332   {
 333     char *command = elf_tdata (abfd)->core_command;
 334     int n = strlen (command);
 335
 336     if (0 < n && command[n - 1] == ' ')
 337       command[n - 1] = '\0';
 338   }
 339
 340   return TRUE;
 341 }
 342 \f
 343 /* Functions for the x86-64 ELF linker.  */
 344
 345 /* The name of the dynamic interpreter.  This is put in the .interp
 346    section.  */
 347
 348 #define ELF_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
 349
 350 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
 351    copying dynamic variables from a shared lib into an app's dynbss
 352    section, and instead use a dynamic relocation to point into the
 353    shared lib.  */
 354 #define ELIMINATE_COPY_RELOCS 1
 355
 356 /* The size in bytes of an entry in the global offset table.  */
 357
 358 #define GOT_ENTRY_SIZE 8
 359
 360 /* The size in bytes of an entry in the procedure linkage table.  */
 361
 362 #define PLT_ENTRY_SIZE 16
 363
 364 /* The first entry in a procedure linkage table looks like this.  See the
 365    SVR4 ABI i386 supplement and the x86-64 ABI to see how this works.  */
 366
 367 static const bfd_byte elf64_x86_64_plt0_entry[PLT_ENTRY_SIZE] =
 368 {
 369   0xff, 0x35, 8, 0, 0, 0,       /* pushq GOT+8(%rip)  */
 370   0xff, 0x25, 16, 0, 0, 0,      /* jmpq *GOT+16(%rip) */
 371   0x0f, 0x1f, 0x40, 0x00        /* nopl 0(%rax)       */
 372 };
 373
 374 /* Subsequent entries in a procedure linkage table look like this.  */
 375
 376 static const bfd_byte elf64_x86_64_plt_entry[PLT_ENTRY_SIZE] =
 377 {
 378   0xff, 0x25,   /* jmpq *name@GOTPC(%rip) */
 379   0, 0, 0, 0,   /* replaced with offset to this symbol in .got.  */
 380   0x68,         /* pushq immediate */
 381   0, 0, 0, 0,   /* replaced with index into relocation table.  */
 382   0xe9,         /* jmp relative */
 383   0, 0, 0, 0    /* replaced with offset to start of .plt0.  */
 384 };
 385
 386 /* The x86-64 linker needs to keep track of the number of relocs that
 387    it decides to copy as dynamic relocs in check_relocs for each symbol.
 388    This is so that it can later discard them if they are found to be
 389    unnecessary.  We store the information in a field extending the
 390    regular ELF linker hash table.  */
 391
 392 struct elf64_x86_64_dyn_relocs
 393 {
 394   /* Next section.  */
 395   struct elf64_x86_64_dyn_relocs *next;
 396
 397   /* The input section of the reloc.  */
 398   asection *sec;
 399
 400   /* Total number of relocs copied for the input section.  */
 401   bfd_size_type count;
 402
 403   /* Number of pc-relative relocs copied for the input section.  */
 404   bfd_size_type pc_count;
 405 };
 406
 407 /* x86-64 ELF linker hash entry.  */
 408
 409 struct elf64_x86_64_link_hash_entry
 410 {
 411   struct elf_link_hash_entry elf;
 412
 413   /* Track dynamic relocs copied for this symbol.  */
 414   struct elf64_x86_64_dyn_relocs *dyn_relocs;
 415
 416 #define GOT_UNKNOWN     0
 417 #define GOT_NORMAL      1
 418 #define GOT_TLS_GD      2
 419 #define GOT_TLS_IE      3
 420 #define GOT_TLS_GDESC   4
 421 #define GOT_TLS_GD_BOTH_P(type) \
 422   ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
 423 #define GOT_TLS_GD_P(type) \
 424   ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
 425 #define GOT_TLS_GDESC_P(type) \
 426   ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
 427 #define GOT_TLS_GD_ANY_P(type) \
 428   (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
 429   unsigned char tls_type;
 430
 431   /* Offset of the GOTPLT entry reserved for the TLS descriptor,
 432      starting at the end of the jump table.  */
 433   bfd_vma tlsdesc_got;
 434 };
 435
 436 #define elf64_x86_64_hash_entry(ent) \
 437   ((struct elf64_x86_64_link_hash_entry *)(ent))
 438
 439 struct elf64_x86_64_obj_tdata
 440 {
 441   struct elf_obj_tdata root;
 442
 443   /* tls_type for each local got entry.  */
 444   char *local_got_tls_type;
 445
 446   /* GOTPLT entries for TLS descriptors.  */
 447   bfd_vma *local_tlsdesc_gotent;
 448 };
 449
 450 #define elf64_x86_64_tdata(abfd) \
 451   ((struct elf64_x86_64_obj_tdata *) (abfd)->tdata.any)
 452
 453 #define elf64_x86_64_local_got_tls_type(abfd) \
 454   (elf64_x86_64_tdata (abfd)->local_got_tls_type)
 455
 456 #define elf64_x86_64_local_tlsdesc_gotent(abfd) \
 457   (elf64_x86_64_tdata (abfd)->local_tlsdesc_gotent)
 458
 459 /* x86-64 ELF linker hash table.  */
 460
 461 struct elf64_x86_64_link_hash_table
 462 {
 463   struct elf_link_hash_table elf;
 464
 465   /* Short-cuts to get to dynamic linker sections.  */
 466   asection *sgot;
 467   asection *sgotplt;
 468   asection *srelgot;
 469   asection *splt;
 470   asection *srelplt;
 471   asection *sdynbss;
 472   asection *srelbss;
 473
 474   /* The offset into splt of the PLT entry for the TLS descriptor
 475      resolver.  Special values are 0, if not necessary (or not found
 476      to be necessary yet), and -1 if needed but not determined
 477      yet.  */
 478   bfd_vma tlsdesc_plt;
 479   /* The offset into sgot of the GOT entry used by the PLT entry
 480      above.  */
 481   bfd_vma tlsdesc_got;
 482
 483   union {
 484     bfd_signed_vma refcount;
 485     bfd_vma offset;
 486   } tls_ld_got;
 487
 488   /* The amount of space used by the jump slots in the GOT.  */
 489   bfd_vma sgotplt_jump_table_size;
 490
 491   /* Small local sym to section mapping cache.  */
 492   struct sym_sec_cache sym_sec;
 493 };
 494
 495 /* Get the x86-64 ELF linker hash table from a link_info structure.  */
 496
 497 #define elf64_x86_64_hash_table(p) \
 498   ((struct elf64_x86_64_link_hash_table *) ((p)->hash))
 499
 500 #define elf64_x86_64_compute_jump_table_size(htab) \
 501   ((htab)->srelplt->reloc_count * GOT_ENTRY_SIZE)
 502
 503 /* Create an entry in an x86-64 ELF linker hash table.  */
 504
 505 static struct bfd_hash_entry *
 506 link_hash_newfunc (struct bfd_hash_entry *entry, struct bfd_hash_table *table,
 507                    const char *string)
 508 {
 509   /* Allocate the structure if it has not already been allocated by a
 510      subclass.  */
 511   if (entry == NULL)
 512     {
 513       entry = bfd_hash_allocate (table,
 514                                  sizeof (struct elf64_x86_64_link_hash_entry));
 515       if (entry == NULL)
 516         return entry;
 517     }
 518
 519   /* Call the allocation method of the superclass.  */
 520   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
 521   if (entry != NULL)
 522     {
 523       struct elf64_x86_64_link_hash_entry *eh;
 524
 525       eh = (struct elf64_x86_64_link_hash_entry *) entry;
 526       eh->dyn_relocs = NULL;
 527       eh->tls_type = GOT_UNKNOWN;
 528       eh->tlsdesc_got = (bfd_vma) -1;
 529     }
 530
 531   return entry;
 532 }
 533
 534 /* Create an X86-64 ELF linker hash table.  */
 535
 536 static struct bfd_link_hash_table *
 537 elf64_x86_64_link_hash_table_create (bfd *abfd)
 538 {
 539   struct elf64_x86_64_link_hash_table *ret;
 540   bfd_size_type amt = sizeof (struct elf64_x86_64_link_hash_table);
 541
 542   ret = (struct elf64_x86_64_link_hash_table *) bfd_malloc (amt);
 543   if (ret == NULL)
 544     return NULL;
 545
 546   if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
 547                                       sizeof (struct elf64_x86_64_link_hash_entry)))
 548     {
 549       free (ret);
 550       return NULL;
 551     }
 552
 553   ret->sgot = NULL;
 554   ret->sgotplt = NULL;
 555   ret->srelgot = NULL;
 556   ret->splt = NULL;
 557   ret->srelplt = NULL;
 558   ret->sdynbss = NULL;
 559   ret->srelbss = NULL;
 560   ret->sym_sec.abfd = NULL;
 561   ret->tlsdesc_plt = 0;
 562   ret->tlsdesc_got = 0;
 563   ret->tls_ld_got.refcount = 0;
 564   ret->sgotplt_jump_table_size = 0;
 565
 566   return &ret->elf.root;
 567 }
 568
 569 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
 570    shortcuts to them in our hash table.  */
 571
 572 static bfd_boolean
 573 create_got_section (bfd *dynobj, struct bfd_link_info *info)
 574 {
 575   struct elf64_x86_64_link_hash_table *htab;
 576
 577   if (! _bfd_elf_create_got_section (dynobj, info))
 578     return FALSE;
 579
 580   htab = elf64_x86_64_hash_table (info);
 581   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
 582   htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
 583   if (!htab->sgot || !htab->sgotplt)
 584     abort ();
 585
 586   htab->srelgot = bfd_make_section_with_flags (dynobj, ".rela.got",
 587                                                (SEC_ALLOC | SEC_LOAD
 588                                                 | SEC_HAS_CONTENTS
 589                                                 | SEC_IN_MEMORY
 590                                                 | SEC_LINKER_CREATED
 591                                                 | SEC_READONLY));
 592   if (htab->srelgot == NULL
 593       || ! bfd_set_section_alignment (dynobj, htab->srelgot, 3))
 594     return FALSE;
 595   return TRUE;
 596 }
 597
 598 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
 599    .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
 600    hash table.  */
 601
 602 static bfd_boolean
 603 elf64_x86_64_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
 604 {
 605   struct elf64_x86_64_link_hash_table *htab;
 606
 607   htab = elf64_x86_64_hash_table (info);
 608   if (!htab->sgot && !create_got_section (dynobj, info))
 609     return FALSE;
 610
 611   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
 612     return FALSE;
 613
 614   htab->splt = bfd_get_section_by_name (dynobj, ".plt");
 615   htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
 616   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
 617   if (!info->shared)
 618     htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
 619
 620   if (!htab->splt || !htab->srelplt || !htab->sdynbss
 621       || (!info->shared && !htab->srelbss))
 622     abort ();
 623
 624   return TRUE;
 625 }
 626
 627 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
 628
 629 static void
 630 elf64_x86_64_copy_indirect_symbol (struct bfd_link_info *info,
 631                                    struct elf_link_hash_entry *dir,
 632                                    struct elf_link_hash_entry *ind)
 633 {
 634   struct elf64_x86_64_link_hash_entry *edir, *eind;
 635
 636   edir = (struct elf64_x86_64_link_hash_entry *) dir;
 637   eind = (struct elf64_x86_64_link_hash_entry *) ind;
 638
 639   if (eind->dyn_relocs != NULL)
 640     {
 641       if (edir->dyn_relocs != NULL)
 642         {
 643           struct elf64_x86_64_dyn_relocs **pp;
 644           struct elf64_x86_64_dyn_relocs *p;
 645
 646           /* Add reloc counts against the indirect sym to the direct sym
 647              list.  Merge any entries against the same section.  */
 648           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
 649             {
 650               struct elf64_x86_64_dyn_relocs *q;
 651
 652               for (q = edir->dyn_relocs; q != NULL; q = q->next)
 653                 if (q->sec == p->sec)
 654                   {
 655                     q->pc_count += p->pc_count;
 656                     q->count += p->count;
 657                     *pp = p->next;
 658                     break;
 659                   }
 660               if (q == NULL)
 661                 pp = &p->next;
 662             }
 663           *pp = edir->dyn_relocs;
 664         }
 665
 666       edir->dyn_relocs = eind->dyn_relocs;
 667       eind->dyn_relocs = NULL;
 668     }
 669
 670   if (ind->root.type == bfd_link_hash_indirect
 671       && dir->got.refcount <= 0)
 672     {
 673       edir->tls_type = eind->tls_type;
 674       eind->tls_type = GOT_UNKNOWN;
 675     }
 676
 677   if (ELIMINATE_COPY_RELOCS
 678       && ind->root.type != bfd_link_hash_indirect
 679       && dir->dynamic_adjusted)
 680     {
 681       /* If called to transfer flags for a weakdef during processing
 682          of elf_adjust_dynamic_symbol, don't copy non_got_ref.
 683          We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
 684       dir->ref_dynamic |= ind->ref_dynamic;
 685       dir->ref_regular |= ind->ref_regular;
 686       dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
 687       dir->needs_plt |= ind->needs_plt;
 688       dir->pointer_equality_needed |= ind->pointer_equality_needed;
 689     }
 690   else
 691     _bfd_elf_link_hash_copy_indirect (info, dir, ind);
 692 }
 693
 694 static bfd_boolean
 695 elf64_x86_64_mkobject (bfd *abfd)
 696 {
 697   if (abfd->tdata.any == NULL)
 698     {
 699       bfd_size_type amt = sizeof (struct elf64_x86_64_obj_tdata);
 700       abfd->tdata.any = bfd_zalloc (abfd, amt);
 701       if (abfd->tdata.any == NULL)
 702         return FALSE;
 703     }
 704   return bfd_elf_mkobject (abfd);
 705 }
 706
 707 static bfd_boolean
 708 elf64_x86_64_elf_object_p (bfd *abfd)
 709 {
 710   /* Set the right machine number for an x86-64 elf64 file.  */
 711   bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64);
 712   return TRUE;
 713 }
 714
 715 static int
 716 elf64_x86_64_tls_transition (struct bfd_link_info *info, int r_type, int is_local)
 717 {
 718   if (info->shared)
 719     return r_type;
 720
 721   switch (r_type)
 722     {
 723     case R_X86_64_TLSGD:
 724     case R_X86_64_GOTPC32_TLSDESC:
 725     case R_X86_64_TLSDESC_CALL:
 726     case R_X86_64_GOTTPOFF:
 727       if (is_local)
 728         return R_X86_64_TPOFF32;
 729       return R_X86_64_GOTTPOFF;
 730     case R_X86_64_TLSLD:
 731       return R_X86_64_TPOFF32;
 732     }
 733
 734    return r_type;
 735 }
 736
 737 /* Look through the relocs for a section during the first phase, and
 738    calculate needed space in the global offset table, procedure
 739    linkage table, and dynamic reloc sections.  */
 740
 741 static bfd_boolean
 742 elf64_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec,
 743                            const Elf_Internal_Rela *relocs)
 744 {
 745   struct elf64_x86_64_link_hash_table *htab;
 746   Elf_Internal_Shdr *symtab_hdr;
 747   struct elf_link_hash_entry **sym_hashes;
 748   const Elf_Internal_Rela *rel;
 749   const Elf_Internal_Rela *rel_end;
 750   asection *sreloc;
 751
 752   if (info->relocatable)
 753     return TRUE;
 754
 755   htab = elf64_x86_64_hash_table (info);
 756   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 757   sym_hashes = elf_sym_hashes (abfd);
 758
 759   sreloc = NULL;
 760
 761   rel_end = relocs + sec->reloc_count;
 762   for (rel = relocs; rel < rel_end; rel++)
 763     {
 764       unsigned int r_type;
 765       unsigned long r_symndx;
 766       struct elf_link_hash_entry *h;
 767
 768       r_symndx = ELF64_R_SYM (rel->r_info);
 769       r_type = ELF64_R_TYPE (rel->r_info);
 770
 771       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
 772         {
 773           (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
 774                                  abfd, r_symndx);
 775           return FALSE;
 776         }
 777
 778       if (r_symndx < symtab_hdr->sh_info)
 779         h = NULL;
 780       else
 781         {
 782           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 783           while (h->root.type == bfd_link_hash_indirect
 784                  || h->root.type == bfd_link_hash_warning)
 785             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 786         }
 787
 788       r_type = elf64_x86_64_tls_transition (info, r_type, h == NULL);
 789       switch (r_type)
 790         {
 791         case R_X86_64_TLSLD:
 792           htab->tls_ld_got.refcount += 1;
 793           goto create_got;
 794
 795         case R_X86_64_TPOFF32:
 796           if (info->shared)
 797             {
 798               (*_bfd_error_handler)
 799                 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
 800                  abfd,
 801                  x86_64_elf_howto_table[r_type].name,
 802                  (h) ? h->root.root.string : "a local symbol");
 803               bfd_set_error (bfd_error_bad_value);
 804               return FALSE;
 805             }
 806           break;
 807
 808         case R_X86_64_GOTTPOFF:
 809           if (info->shared)
 810             info->flags |= DF_STATIC_TLS;
 811           /* Fall through */
 812
 813         case R_X86_64_GOT32:
 814         case R_X86_64_GOTPCREL:
 815         case R_X86_64_TLSGD:
 816         case R_X86_64_GOT64:
 817         case R_X86_64_GOTPCREL64:
 818         case R_X86_64_GOTPLT64:
 819         case R_X86_64_GOTPC32_TLSDESC:
 820         case R_X86_64_TLSDESC_CALL:
 821           /* This symbol requires a global offset table entry.  */
 822           {
 823             int tls_type, old_tls_type;
 824
 825             switch (r_type)
 826               {
 827               default: tls_type = GOT_NORMAL; break;
 828               case R_X86_64_TLSGD: tls_type = GOT_TLS_GD; break;
 829               case R_X86_64_GOTTPOFF: tls_type = GOT_TLS_IE; break;
 830               case R_X86_64_GOTPC32_TLSDESC:
 831               case R_X86_64_TLSDESC_CALL:
 832                 tls_type = GOT_TLS_GDESC; break;
 833               }
 834
 835             if (h != NULL)
 836               {
 837                 if (r_type == R_X86_64_GOTPLT64)
 838                   {
 839                     /* This relocation indicates that we also need
 840                        a PLT entry, as this is a function.  We don't need
 841                        a PLT entry for local symbols.  */
 842                     h->needs_plt = 1;
 843                     h->plt.refcount += 1;
 844                   }
 845                 h->got.refcount += 1;
 846                 old_tls_type = elf64_x86_64_hash_entry (h)->tls_type;
 847               }
 848             else
 849               {
 850                 bfd_signed_vma *local_got_refcounts;
 851
 852                 /* This is a global offset table entry for a local symbol.  */
 853                 local_got_refcounts = elf_local_got_refcounts (abfd);
 854                 if (local_got_refcounts == NULL)
 855                   {
 856                     bfd_size_type size;
 857
 858                     size = symtab_hdr->sh_info;
 859                     size *= sizeof (bfd_signed_vma)
 860                       + sizeof (bfd_vma) + sizeof (char);
 861                     local_got_refcounts = ((bfd_signed_vma *)
 862                                            bfd_zalloc (abfd, size));
 863                     if (local_got_refcounts == NULL)
 864                       return FALSE;
 865                     elf_local_got_refcounts (abfd) = local_got_refcounts;
 866                     elf64_x86_64_local_tlsdesc_gotent (abfd)
 867                       = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
 868                     elf64_x86_64_local_got_tls_type (abfd)
 869                       = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
 870                   }
 871                 local_got_refcounts[r_symndx] += 1;
 872                 old_tls_type
 873                   = elf64_x86_64_local_got_tls_type (abfd) [r_symndx];
 874               }
 875
 876             /* If a TLS symbol is accessed using IE at least once,
 877                there is no point to use dynamic model for it.  */
 878             if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
 879                 && (! GOT_TLS_GD_ANY_P (old_tls_type)
 880                     || tls_type != GOT_TLS_IE))
 881               {
 882                 if (old_tls_type == GOT_TLS_IE && GOT_TLS_GD_ANY_P (tls_type))
 883                   tls_type = old_tls_type;
 884                 else if (GOT_TLS_GD_ANY_P (old_tls_type)
 885                          && GOT_TLS_GD_ANY_P (tls_type))
 886                   tls_type |= old_tls_type;
 887                 else
 888                   {
 889                     (*_bfd_error_handler)
 890                       (_("%B: %s' accessed both as normal and thread local symbol"),
 891                        abfd, h ? h->root.root.string : "<local>");
 892                     return FALSE;
 893                   }
 894               }
 895
 896             if (old_tls_type != tls_type)
 897               {
 898                 if (h != NULL)
 899                   elf64_x86_64_hash_entry (h)->tls_type = tls_type;
 900                 else
 901                   elf64_x86_64_local_got_tls_type (abfd) [r_symndx] = tls_type;
 902               }
 903           }
 904           /* Fall through */
 905
 906         case R_X86_64_GOTOFF64:
 907         case R_X86_64_GOTPC32:
 908         case R_X86_64_GOTPC64:
 909         create_got:
 910           if (htab->sgot == NULL)
 911             {
 912               if (htab->elf.dynobj == NULL)
 913                 htab->elf.dynobj = abfd;
 914               if (!create_got_section (htab->elf.dynobj, info))
 915                 return FALSE;
 916             }
 917           break;
 918
 919         case R_X86_64_PLT32:
 920           /* This symbol requires a procedure linkage table entry.  We
 921              actually build the entry in adjust_dynamic_symbol,
 922              because this might be a case of linking PIC code which is
 923              never referenced by a dynamic object, in which case we
 924              don't need to generate a procedure linkage table entry
 925              after all.  */
 926
 927           /* If this is a local symbol, we resolve it directly without
 928              creating a procedure linkage table entry.  */
 929           if (h == NULL)
 930             continue;
 931
 932           h->needs_plt = 1;
 933           h->plt.refcount += 1;
 934           break;
 935
 936         case R_X86_64_PLTOFF64:
 937           /* This tries to form the 'address' of a function relative
 938              to GOT.  For global symbols we need a PLT entry.  */
 939           if (h != NULL)
 940             {
 941               h->needs_plt = 1;
 942               h->plt.refcount += 1;
 943             }
 944           goto create_got;
 945
 946         case R_X86_64_8:
 947         case R_X86_64_16:
 948         case R_X86_64_32:
 949         case R_X86_64_32S:
 950           /* Let's help debug shared library creation.  These relocs
 951              cannot be used in shared libs.  Don't error out for
 952              sections we don't care about, such as debug sections or
 953              non-constant sections.  */
 954           if (info->shared
 955               && (sec->flags & SEC_ALLOC) != 0
 956               && (sec->flags & SEC_READONLY) != 0)
 957             {
 958               (*_bfd_error_handler)
 959                 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
 960                  abfd,
 961                  x86_64_elf_howto_table[r_type].name,
 962                  (h) ? h->root.root.string : "a local symbol");
 963               bfd_set_error (bfd_error_bad_value);
 964               return FALSE;
 965             }
 966           /* Fall through.  */
 967
 968         case R_X86_64_PC8:
 969         case R_X86_64_PC16:
 970         case R_X86_64_PC32:
 971         case R_X86_64_PC64:
 972         case R_X86_64_64:
 973           if (h != NULL && !info->shared)
 974             {
 975               /* If this reloc is in a read-only section, we might
 976                  need a copy reloc.  We can't check reliably at this
 977                  stage whether the section is read-only, as input
 978                  sections have not yet been mapped to output sections.
 979                  Tentatively set the flag for now, and correct in
 980                  adjust_dynamic_symbol.  */
 981               h->non_got_ref = 1;
 982
 983               /* We may need a .plt entry if the function this reloc
 984                  refers to is in a shared lib.  */
 985               h->plt.refcount += 1;
 986               if (r_type != R_X86_64_PC32 && r_type != R_X86_64_PC64)
 987                 h->pointer_equality_needed = 1;
 988             }
 989
 990           /* If we are creating a shared library, and this is a reloc
 991              against a global symbol, or a non PC relative reloc
 992              against a local symbol, then we need to copy the reloc
 993              into the shared library.  However, if we are linking with
 994              -Bsymbolic, we do not need to copy a reloc against a
 995              global symbol which is defined in an object we are
 996              including in the link (i.e., DEF_REGULAR is set).  At
 997              this point we have not seen all the input files, so it is
 998              possible that DEF_REGULAR is not set now but will be set
 999              later (it is never cleared).  In case of a weak definition,
1000              DEF_REGULAR may be cleared later by a strong definition in
1001              a shared library.  We account for that possibility below by
1002              storing information in the relocs_copied field of the hash
1003              table entry.  A similar situation occurs when creating
1004              shared libraries and symbol visibility changes render the
1005              symbol local.
1006
1007              If on the other hand, we are creating an executable, we
1008              may need to keep relocations for symbols satisfied by a
1009              dynamic library if we manage to avoid copy relocs for the
1010              symbol.  */
1011           if ((info->shared
1012                && (sec->flags & SEC_ALLOC) != 0
1013                && (((r_type != R_X86_64_PC8)
1014                     && (r_type != R_X86_64_PC16)
1015                     && (r_type != R_X86_64_PC32)
1016                     && (r_type != R_X86_64_PC64))
1017                    || (h != NULL
1018                        && (! SYMBOLIC_BIND (info, h)
1019                            || h->root.type == bfd_link_hash_defweak
1020                            || !h->def_regular))))
1021               || (ELIMINATE_COPY_RELOCS
1022                   && !info->shared
1023                   && (sec->flags & SEC_ALLOC) != 0
1024                   && h != NULL
1025                   && (h->root.type == bfd_link_hash_defweak
1026                       || !h->def_regular)))
1027             {
1028               struct elf64_x86_64_dyn_relocs *p;
1029               struct elf64_x86_64_dyn_relocs **head;
1030
1031               /* We must copy these reloc types into the output file.
1032                  Create a reloc section in dynobj and make room for
1033                  this reloc.  */
1034               if (sreloc == NULL)
1035                 {
1036                   const char *name;
1037                   bfd *dynobj;
1038
1039                   name = (bfd_elf_string_from_elf_section
1040                           (abfd,
1041                            elf_elfheader (abfd)->e_shstrndx,
1042                            elf_section_data (sec)->rel_hdr.sh_name));
1043                   if (name == NULL)
1044                     return FALSE;
1045
1046                   if (! CONST_STRNEQ (name, ".rela")
1047                       || strcmp (bfd_get_section_name (abfd, sec),
1048                                  name + 5) != 0)
1049                     {
1050                       (*_bfd_error_handler)
1051                         (_("%B: bad relocation section name `%s\'"),
1052                          abfd, name);
1053                     }
1054
1055                   if (htab->elf.dynobj == NULL)
1056                     htab->elf.dynobj = abfd;
1057
1058                   dynobj = htab->elf.dynobj;
1059
1060                   sreloc = bfd_get_section_by_name (dynobj, name);
1061                   if (sreloc == NULL)
1062                     {
1063                       flagword flags;
1064
1065                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
1066                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1067                       if ((sec->flags & SEC_ALLOC) != 0)
1068                         flags |= SEC_ALLOC | SEC_LOAD;
1069                       sreloc = bfd_make_section_with_flags (dynobj,
1070                                                             name,
1071                                                             flags);
1072                       if (sreloc == NULL
1073                           || ! bfd_set_section_alignment (dynobj, sreloc, 3))
1074                         return FALSE;
1075                     }
1076                   elf_section_data (sec)->sreloc = sreloc;
1077                 }
1078
1079               /* If this is a global symbol, we count the number of
1080                  relocations we need for this symbol.  */
1081               if (h != NULL)
1082                 {
1083                   head = &((struct elf64_x86_64_link_hash_entry *) h)->dyn_relocs;
1084                 }
1085               else
1086                 {
1087                   void **vpp;
1088                   /* Track dynamic relocs needed for local syms too.
1089                      We really need local syms available to do this
1090                      easily.  Oh well.  */
1091
1092                   asection *s;
1093                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1094                                                  sec, r_symndx);
1095                   if (s == NULL)
1096                     return FALSE;
1097
1098                   /* Beware of type punned pointers vs strict aliasing
1099                      rules.  */
1100                   vpp = &(elf_section_data (s)->local_dynrel);
1101                   head = (struct elf64_x86_64_dyn_relocs **)vpp;
1102                 }
1103
1104               p = *head;
1105               if (p == NULL || p->sec != sec)
1106                 {
1107                   bfd_size_type amt = sizeof *p;
1108                   p = ((struct elf64_x86_64_dyn_relocs *)
1109                        bfd_alloc (htab->elf.dynobj, amt));
1110                   if (p == NULL)
1111                     return FALSE;
1112                   p->next = *head;
1113                   *head = p;
1114                   p->sec = sec;
1115                   p->count = 0;
1116                   p->pc_count = 0;
1117                 }
1118
1119               p->count += 1;
1120               if (r_type == R_X86_64_PC8
1121                   || r_type == R_X86_64_PC16
1122                   || r_type == R_X86_64_PC32
1123                   || r_type == R_X86_64_PC64)
1124                 p->pc_count += 1;
1125             }
1126           break;
1127
1128           /* This relocation describes the C++ object vtable hierarchy.
1129              Reconstruct it for later use during GC.  */
1130         case R_X86_64_GNU_VTINHERIT:
1131           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1132             return FALSE;
1133           break;
1134
1135           /* This relocation describes which C++ vtable entries are actually
1136              used.  Record for later use during GC.  */
1137         case R_X86_64_GNU_VTENTRY:
1138           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1139             return FALSE;
1140           break;
1141
1142         default:
1143           break;
1144         }
1145     }
1146
1147   return TRUE;
1148 }
1149
1150 /* Return the section that should be marked against GC for a given
1151    relocation.  */
1152
1153 static asection *
1154 elf64_x86_64_gc_mark_hook (asection *sec,
1155                            struct bfd_link_info *info,
1156                            Elf_Internal_Rela *rel,
1157                            struct elf_link_hash_entry *h,
1158                            Elf_Internal_Sym *sym)
1159 {
1160   if (h != NULL)
1161     switch (ELF64_R_TYPE (rel->r_info))
1162       {
1163       case R_X86_64_GNU_VTINHERIT:
1164       case R_X86_64_GNU_VTENTRY:
1165         return NULL;
1166       }
1167
1168   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1169 }
1170
1171 /* Update the got entry reference counts for the section being removed.  */
1172
1173 static bfd_boolean
1174 elf64_x86_64_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1175                             asection *sec, const Elf_Internal_Rela *relocs)
1176 {
1177   Elf_Internal_Shdr *symtab_hdr;
1178   struct elf_link_hash_entry **sym_hashes;
1179   bfd_signed_vma *local_got_refcounts;
1180   const Elf_Internal_Rela *rel, *relend;
1181
1182   elf_section_data (sec)->local_dynrel = NULL;
1183
1184   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1185   sym_hashes = elf_sym_hashes (abfd);
1186   local_got_refcounts = elf_local_got_refcounts (abfd);
1187
1188   relend = relocs + sec->reloc_count;
1189   for (rel = relocs; rel < relend; rel++)
1190     {
1191       unsigned long r_symndx;
1192       unsigned int r_type;
1193       struct elf_link_hash_entry *h = NULL;
1194
1195       r_symndx = ELF64_R_SYM (rel->r_info);
1196       if (r_symndx >= symtab_hdr->sh_info)
1197         {
1198           struct elf64_x86_64_link_hash_entry *eh;
1199           struct elf64_x86_64_dyn_relocs **pp;
1200           struct elf64_x86_64_dyn_relocs *p;
1201
1202           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1203           while (h->root.type == bfd_link_hash_indirect
1204                  || h->root.type == bfd_link_hash_warning)
1205             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1206           eh = (struct elf64_x86_64_link_hash_entry *) h;
1207
1208           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1209             if (p->sec == sec)
1210               {
1211                 /* Everything must go for SEC.  */
1212                 *pp = p->next;
1213                 break;
1214               }
1215         }
1216
1217       r_type = ELF64_R_TYPE (rel->r_info);
1218       r_type = elf64_x86_64_tls_transition (info, r_type, h != NULL);
1219       switch (r_type)
1220         {
1221         case R_X86_64_TLSLD:
1222           if (elf64_x86_64_hash_table (info)->tls_ld_got.refcount > 0)
1223             elf64_x86_64_hash_table (info)->tls_ld_got.refcount -= 1;
1224           break;
1225
1226         case R_X86_64_TLSGD:
1227         case R_X86_64_GOTPC32_TLSDESC:
1228         case R_X86_64_TLSDESC_CALL:
1229         case R_X86_64_GOTTPOFF:
1230         case R_X86_64_GOT32:
1231         case R_X86_64_GOTPCREL:
1232         case R_X86_64_GOT64:
1233         case R_X86_64_GOTPCREL64:
1234         case R_X86_64_GOTPLT64:
1235           if (h != NULL)
1236             {
1237               if (r_type == R_X86_64_GOTPLT64 && h->plt.refcount > 0)
1238                 h->plt.refcount -= 1;
1239               if (h->got.refcount > 0)
1240                 h->got.refcount -= 1;
1241             }
1242           else if (local_got_refcounts != NULL)
1243             {
1244               if (local_got_refcounts[r_symndx] > 0)
1245                 local_got_refcounts[r_symndx] -= 1;
1246             }
1247           break;
1248
1249         case R_X86_64_8:
1250         case R_X86_64_16:
1251         case R_X86_64_32:
1252         case R_X86_64_64:
1253         case R_X86_64_32S:
1254         case R_X86_64_PC8:
1255         case R_X86_64_PC16:
1256         case R_X86_64_PC32:
1257         case R_X86_64_PC64:
1258           if (info->shared)
1259             break;
1260           /* Fall thru */
1261
1262         case R_X86_64_PLT32:
1263         case R_X86_64_PLTOFF64:
1264           if (h != NULL)
1265             {
1266               if (h->plt.refcount > 0)
1267                 h->plt.refcount -= 1;
1268             }
1269           break;
1270
1271         default:
1272           break;
1273         }
1274     }
1275
1276   return TRUE;
1277 }
1278
1279 /* Adjust a symbol defined by a dynamic object and referenced by a
1280    regular object.  The current definition is in some section of the
1281    dynamic object, but we're not including those sections.  We have to
1282    change the definition to something the rest of the link can
1283    understand.  */
1284
1285 static bfd_boolean
1286 elf64_x86_64_adjust_dynamic_symbol (struct bfd_link_info *info,
1287                                     struct elf_link_hash_entry *h)
1288 {
1289   struct elf64_x86_64_link_hash_table *htab;
1290   asection *s;
1291
1292   /* If this is a function, put it in the procedure linkage table.  We
1293      will fill in the contents of the procedure linkage table later,
1294      when we know the address of the .got section.  */
1295   if (h->type == STT_FUNC
1296       || h->needs_plt)
1297     {
1298       if (h->plt.refcount <= 0
1299           || SYMBOL_CALLS_LOCAL (info, h)
1300           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1301               && h->root.type == bfd_link_hash_undefweak))
1302         {
1303           /* This case can occur if we saw a PLT32 reloc in an input
1304              file, but the symbol was never referred to by a dynamic
1305              object, or if all references were garbage collected.  In
1306              such a case, we don't actually need to build a procedure
1307              linkage table, and we can just do a PC32 reloc instead.  */
1308           h->plt.offset = (bfd_vma) -1;
1309           h->needs_plt = 0;
1310         }
1311
1312       return TRUE;
1313     }
1314   else
1315     /* It's possible that we incorrectly decided a .plt reloc was
1316        needed for an R_X86_64_PC32 reloc to a non-function sym in
1317        check_relocs.  We can't decide accurately between function and
1318        non-function syms in check-relocs;  Objects loaded later in
1319        the link may change h->type.  So fix it now.  */
1320     h->plt.offset = (bfd_vma) -1;
1321
1322   /* If this is a weak symbol, and there is a real definition, the
1323      processor independent code will have arranged for us to see the
1324      real definition first, and we can just use the same value.  */
1325   if (h->u.weakdef != NULL)
1326     {
1327       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1328                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1329       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1330       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1331       if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1332         h->non_got_ref = h->u.weakdef->non_got_ref;
1333       return TRUE;
1334     }
1335
1336   /* This is a reference to a symbol defined by a dynamic object which
1337      is not a function.  */
1338
1339   /* If we are creating a shared library, we must presume that the
1340      only references to the symbol are via the global offset table.
1341      For such cases we need not do anything here; the relocations will
1342      be handled correctly by relocate_section.  */
1343   if (info->shared)
1344     return TRUE;
1345
1346   /* If there are no references to this symbol that do not use the
1347      GOT, we don't need to generate a copy reloc.  */
1348   if (!h->non_got_ref)
1349     return TRUE;
1350
1351   /* If -z nocopyreloc was given, we won't generate them either.  */
1352   if (info->nocopyreloc)
1353     {
1354       h->non_got_ref = 0;
1355       return TRUE;
1356     }
1357
1358   if (ELIMINATE_COPY_RELOCS)
1359     {
1360       struct elf64_x86_64_link_hash_entry * eh;
1361       struct elf64_x86_64_dyn_relocs *p;
1362
1363       eh = (struct elf64_x86_64_link_hash_entry *) h;
1364       for (p = eh->dyn_relocs; p != NULL; p = p->next)
1365         {
1366           s = p->sec->output_section;
1367           if (s != NULL && (s->flags & SEC_READONLY) != 0)
1368             break;
1369         }
1370
1371       /* If we didn't find any dynamic relocs in read-only sections, then
1372          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
1373       if (p == NULL)
1374         {
1375           h->non_got_ref = 0;
1376           return TRUE;
1377         }
1378     }
1379
1380   if (h->size == 0)
1381     {
1382       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1383                              h->root.root.string);
1384       return TRUE;
1385     }
1386
1387   /* We must allocate the symbol in our .dynbss section, which will
1388      become part of the .bss section of the executable.  There will be
1389      an entry for this symbol in the .dynsym section.  The dynamic
1390      object will contain position independent code, so all references
1391      from the dynamic object to this symbol will go through the global
1392      offset table.  The dynamic linker will use the .dynsym entry to
1393      determine the address it must put in the global offset table, so
1394      both the dynamic object and the regular object will refer to the
1395      same memory location for the variable.  */
1396
1397   htab = elf64_x86_64_hash_table (info);
1398
1399   /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
1400      to copy the initial value out of the dynamic object and into the
1401      runtime process image.  */
1402   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1403     {
1404       htab->srelbss->size += sizeof (Elf64_External_Rela);
1405       h->needs_copy = 1;
1406     }
1407
1408   s = htab->sdynbss;
1409
1410   return _bfd_elf_adjust_dynamic_copy (h, s);
1411 }
1412
1413 /* Allocate space in .plt, .got and associated reloc sections for
1414    dynamic relocs.  */
1415
1416 static bfd_boolean
1417 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1418 {
1419   struct bfd_link_info *info;
1420   struct elf64_x86_64_link_hash_table *htab;
1421   struct elf64_x86_64_link_hash_entry *eh;
1422   struct elf64_x86_64_dyn_relocs *p;
1423
1424   if (h->root.type == bfd_link_hash_indirect)
1425     return TRUE;
1426
1427   if (h->root.type == bfd_link_hash_warning)
1428     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1429
1430   info = (struct bfd_link_info *) inf;
1431   htab = elf64_x86_64_hash_table (info);
1432
1433   if (htab->elf.dynamic_sections_created
1434       && h->plt.refcount > 0)
1435     {
1436       /* Make sure this symbol is output as a dynamic symbol.
1437          Undefined weak syms won't yet be marked as dynamic.  */
1438       if (h->dynindx == -1
1439           && !h->forced_local)
1440         {
1441           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1442             return FALSE;
1443         }
1444
1445       if (info->shared
1446           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1447         {
1448           asection *s = htab->splt;
1449
1450           /* If this is the first .plt entry, make room for the special
1451              first entry.  */
1452           if (s->size == 0)
1453             s->size += PLT_ENTRY_SIZE;
1454
1455           h->plt.offset = s->size;
1456
1457           /* If this symbol is not defined in a regular file, and we are
1458              not generating a shared library, then set the symbol to this
1459              location in the .plt.  This is required to make function
1460              pointers compare as equal between the normal executable and
1461              the shared library.  */
1462           if (! info->shared
1463               && !h->def_regular)
1464             {
1465               h->root.u.def.section = s;
1466               h->root.u.def.value = h->plt.offset;
1467             }
1468
1469           /* Make room for this entry.  */
1470           s->size += PLT_ENTRY_SIZE;
1471
1472           /* We also need to make an entry in the .got.plt section, which
1473              will be placed in the .got section by the linker script.  */
1474           htab->sgotplt->size += GOT_ENTRY_SIZE;
1475
1476           /* We also need to make an entry in the .rela.plt section.  */
1477           htab->srelplt->size += sizeof (Elf64_External_Rela);
1478           htab->srelplt->reloc_count++;
1479         }
1480       else
1481         {
1482           h->plt.offset = (bfd_vma) -1;
1483           h->needs_plt = 0;
1484         }
1485     }
1486   else
1487     {
1488       h->plt.offset = (bfd_vma) -1;
1489       h->needs_plt = 0;
1490     }
1491
1492   eh = (struct elf64_x86_64_link_hash_entry *) h;
1493   eh->tlsdesc_got = (bfd_vma) -1;
1494
1495   /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
1496      make it a R_X86_64_TPOFF32 requiring no GOT entry.  */
1497   if (h->got.refcount > 0
1498       && !info->shared
1499       && h->dynindx == -1
1500       && elf64_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE)
1501     h->got.offset = (bfd_vma) -1;
1502   else if (h->got.refcount > 0)
1503     {
1504       asection *s;
1505       bfd_boolean dyn;
1506       int tls_type = elf64_x86_64_hash_entry (h)->tls_type;
1507
1508       /* Make sure this symbol is output as a dynamic symbol.
1509          Undefined weak syms won't yet be marked as dynamic.  */
1510       if (h->dynindx == -1
1511           && !h->forced_local)
1512         {
1513           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1514             return FALSE;
1515         }
1516
1517       if (GOT_TLS_GDESC_P (tls_type))
1518         {
1519           eh->tlsdesc_got = htab->sgotplt->size
1520             - elf64_x86_64_compute_jump_table_size (htab);
1521           htab->sgotplt->size += 2 * GOT_ENTRY_SIZE;
1522           h->got.offset = (bfd_vma) -2;
1523         }
1524       if (! GOT_TLS_GDESC_P (tls_type)
1525           || GOT_TLS_GD_P (tls_type))
1526         {
1527           s = htab->sgot;
1528           h->got.offset = s->size;
1529           s->size += GOT_ENTRY_SIZE;
1530           if (GOT_TLS_GD_P (tls_type))
1531             s->size += GOT_ENTRY_SIZE;
1532         }
1533       dyn = htab->elf.dynamic_sections_created;
1534       /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
1535          and two if global.
1536          R_X86_64_GOTTPOFF needs one dynamic relocation.  */
1537       if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
1538           || tls_type == GOT_TLS_IE)
1539         htab->srelgot->size += sizeof (Elf64_External_Rela);
1540       else if (GOT_TLS_GD_P (tls_type))
1541         htab->srelgot->size += 2 * sizeof (Elf64_External_Rela);
1542       else if (! GOT_TLS_GDESC_P (tls_type)
1543                && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1544                    || h->root.type != bfd_link_hash_undefweak)
1545                && (info->shared
1546                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1547         htab->srelgot->size += sizeof (Elf64_External_Rela);
1548       if (GOT_TLS_GDESC_P (tls_type))
1549         {
1550           htab->srelplt->size += sizeof (Elf64_External_Rela);
1551           htab->tlsdesc_plt = (bfd_vma) -1;
1552         }
1553     }
1554   else
1555     h->got.offset = (bfd_vma) -1;
1556
1557   if (eh->dyn_relocs == NULL)
1558     return TRUE;
1559
1560   /* In the shared -Bsymbolic case, discard space allocated for
1561      dynamic pc-relative relocs against symbols which turn out to be
1562      defined in regular objects.  For the normal shared case, discard
1563      space for pc-relative relocs that have become local due to symbol
1564      visibility changes.  */
1565
1566   if (info->shared)
1567     {
1568       /* Relocs that use pc_count are those that appear on a call
1569          insn, or certain REL relocs that can generated via assembly.
1570          We want calls to protected symbols to resolve directly to the
1571          function rather than going via the plt.  If people want
1572          function pointer comparisons to work as expected then they
1573          should avoid writing weird assembly.  */
1574       if (SYMBOL_CALLS_LOCAL (info, h))
1575         {
1576           struct elf64_x86_64_dyn_relocs **pp;
1577
1578           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1579             {
1580               p->count -= p->pc_count;
1581               p->pc_count = 0;
1582               if (p->count == 0)
1583                 *pp = p->next;
1584               else
1585                 pp = &p->next;
1586             }
1587         }
1588
1589       /* Also discard relocs on undefined weak syms with non-default
1590          visibility.  */
1591       if (eh->dyn_relocs != NULL
1592           && h->root.type == bfd_link_hash_undefweak)
1593         {
1594           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1595             eh->dyn_relocs = NULL;
1596
1597           /* Make sure undefined weak symbols are output as a dynamic
1598              symbol in PIEs.  */
1599           else if (h->dynindx == -1
1600                    && !h->forced_local)
1601             {
1602               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1603                 return FALSE;
1604             }
1605         }
1606     }
1607   else if (ELIMINATE_COPY_RELOCS)
1608     {
1609       /* For the non-shared case, discard space for relocs against
1610          symbols which turn out to need copy relocs or are not
1611          dynamic.  */
1612
1613       if (!h->non_got_ref
1614           && ((h->def_dynamic
1615                && !h->def_regular)
1616               || (htab->elf.dynamic_sections_created
1617                   && (h->root.type == bfd_link_hash_undefweak
1618                       || h->root.type == bfd_link_hash_undefined))))
1619         {
1620           /* Make sure this symbol is output as a dynamic symbol.
1621              Undefined weak syms won't yet be marked as dynamic.  */
1622           if (h->dynindx == -1
1623               && !h->forced_local)
1624             {
1625               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1626                 return FALSE;
1627             }
1628
1629           /* If that succeeded, we know we'll be keeping all the
1630              relocs.  */
1631           if (h->dynindx != -1)
1632             goto keep;
1633         }
1634
1635       eh->dyn_relocs = NULL;
1636
1637     keep: ;
1638     }
1639
1640   /* Finally, allocate space.  */
1641   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1642     {
1643       asection *sreloc = elf_section_data (p->sec)->sreloc;
1644       sreloc->size += p->count * sizeof (Elf64_External_Rela);
1645     }
1646
1647   return TRUE;
1648 }
1649
1650 /* Find any dynamic relocs that apply to read-only sections.  */
1651
1652 static bfd_boolean
1653 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1654 {
1655   struct elf64_x86_64_link_hash_entry *eh;
1656   struct elf64_x86_64_dyn_relocs *p;
1657
1658   if (h->root.type == bfd_link_hash_warning)
1659     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1660
1661   eh = (struct elf64_x86_64_link_hash_entry *) h;
1662   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1663     {
1664       asection *s = p->sec->output_section;
1665
1666       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1667         {
1668           struct bfd_link_info *info = (struct bfd_link_info *) inf;
1669
1670           info->flags |= DF_TEXTREL;
1671
1672           /* Not an error, just cut short the traversal.  */
1673           return FALSE;
1674         }
1675     }
1676   return TRUE;
1677 }
1678
1679 /* Set the sizes of the dynamic sections.  */
1680
1681 static bfd_boolean
1682 elf64_x86_64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1683                                     struct bfd_link_info *info)
1684 {
1685   struct elf64_x86_64_link_hash_table *htab;
1686   bfd *dynobj;
1687   asection *s;
1688   bfd_boolean relocs;
1689   bfd *ibfd;
1690
1691   htab = elf64_x86_64_hash_table (info);
1692   dynobj = htab->elf.dynobj;
1693   if (dynobj == NULL)
1694     abort ();
1695
1696   if (htab->elf.dynamic_sections_created)
1697     {
1698       /* Set the contents of the .interp section to the interpreter.  */
1699       if (info->executable)
1700         {
1701           s = bfd_get_section_by_name (dynobj, ".interp");
1702           if (s == NULL)
1703             abort ();
1704           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1705           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1706         }
1707     }
1708
1709   /* Set up .got offsets for local syms, and space for local dynamic
1710      relocs.  */
1711   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1712     {
1713       bfd_signed_vma *local_got;
1714       bfd_signed_vma *end_local_got;
1715       char *local_tls_type;
1716       bfd_vma *local_tlsdesc_gotent;
1717       bfd_size_type locsymcount;
1718       Elf_Internal_Shdr *symtab_hdr;
1719       asection *srel;
1720
1721       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1722         continue;
1723
1724       for (s = ibfd->sections; s != NULL; s = s->next)
1725         {
1726           struct elf64_x86_64_dyn_relocs *p;
1727
1728           for (p = (struct elf64_x86_64_dyn_relocs *)
1729                     (elf_section_data (s)->local_dynrel);
1730                p != NULL;
1731                p = p->next)
1732             {
1733               if (!bfd_is_abs_section (p->sec)
1734                   && bfd_is_abs_section (p->sec->output_section))
1735                 {
1736                   /* Input section has been discarded, either because
1737                      it is a copy of a linkonce section or due to
1738                      linker script /DISCARD/, so we'll be discarding
1739                      the relocs too.  */
1740                 }
1741               else if (p->count != 0)
1742                 {
1743                   srel = elf_section_data (p->sec)->sreloc;
1744                   srel->size += p->count * sizeof (Elf64_External_Rela);
1745                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1746                     info->flags |= DF_TEXTREL;
1747
1748                 }
1749             }
1750         }
1751
1752       local_got = elf_local_got_refcounts (ibfd);
1753       if (!local_got)
1754         continue;
1755
1756       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1757       locsymcount = symtab_hdr->sh_info;
1758       end_local_got = local_got + locsymcount;
1759       local_tls_type = elf64_x86_64_local_got_tls_type (ibfd);
1760       local_tlsdesc_gotent = elf64_x86_64_local_tlsdesc_gotent (ibfd);
1761       s = htab->sgot;
1762       srel = htab->srelgot;
1763       for (; local_got < end_local_got;
1764            ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
1765         {
1766           *local_tlsdesc_gotent = (bfd_vma) -1;
1767           if (*local_got > 0)
1768             {
1769               if (GOT_TLS_GDESC_P (*local_tls_type))
1770                 {
1771                   *local_tlsdesc_gotent = htab->sgotplt->size
1772                     - elf64_x86_64_compute_jump_table_size (htab);
1773                   htab->sgotplt->size += 2 * GOT_ENTRY_SIZE;
1774                   *local_got = (bfd_vma) -2;
1775                 }
1776               if (! GOT_TLS_GDESC_P (*local_tls_type)
1777                   || GOT_TLS_GD_P (*local_tls_type))
1778                 {
1779                   *local_got = s->size;
1780                   s->size += GOT_ENTRY_SIZE;
1781                   if (GOT_TLS_GD_P (*local_tls_type))
1782                     s->size += GOT_ENTRY_SIZE;
1783                 }
1784               if (info->shared
1785                   || GOT_TLS_GD_ANY_P (*local_tls_type)
1786                   || *local_tls_type == GOT_TLS_IE)
1787                 {
1788                   if (GOT_TLS_GDESC_P (*local_tls_type))
1789                     {
1790                       htab->srelplt->size += sizeof (Elf64_External_Rela);
1791                       htab->tlsdesc_plt = (bfd_vma) -1;
1792                     }
1793                   if (! GOT_TLS_GDESC_P (*local_tls_type)
1794                       || GOT_TLS_GD_P (*local_tls_type))
1795                     srel->size += sizeof (Elf64_External_Rela);
1796                 }
1797             }
1798           else
1799             *local_got = (bfd_vma) -1;
1800         }
1801     }
1802
1803   if (htab->tls_ld_got.refcount > 0)
1804     {
1805       /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
1806          relocs.  */
1807       htab->tls_ld_got.offset = htab->sgot->size;
1808       htab->sgot->size += 2 * GOT_ENTRY_SIZE;
1809       htab->srelgot->size += sizeof (Elf64_External_Rela);
1810     }
1811   else
1812     htab->tls_ld_got.offset = -1;
1813
1814   /* Allocate global sym .plt and .got entries, and space for global
1815      sym dynamic relocs.  */
1816   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
1817
1818   /* For every jump slot reserved in the sgotplt, reloc_count is
1819      incremented.  However, when we reserve space for TLS descriptors,
1820      it's not incremented, so in order to compute the space reserved
1821      for them, it suffices to multiply the reloc count by the jump
1822      slot size.  */
1823   if (htab->srelplt)
1824     htab->sgotplt_jump_table_size
1825       = elf64_x86_64_compute_jump_table_size (htab);
1826
1827   if (htab->tlsdesc_plt)
1828     {
1829       /* If we're not using lazy TLS relocations, don't generate the
1830          PLT and GOT entries they require.  */
1831       if ((info->flags & DF_BIND_NOW))
1832         htab->tlsdesc_plt = 0;
1833       else
1834         {
1835           htab->tlsdesc_got = htab->sgot->size;
1836           htab->sgot->size += GOT_ENTRY_SIZE;
1837           /* Reserve room for the initial entry.
1838              FIXME: we could probably do away with it in this case.  */
1839           if (htab->splt->size == 0)
1840             htab->splt->size += PLT_ENTRY_SIZE;
1841           htab->tlsdesc_plt = htab->splt->size;
1842           htab->splt->size += PLT_ENTRY_SIZE;
1843         }
1844     }
1845
1846   /* We now have determined the sizes of the various dynamic sections.
1847      Allocate memory for them.  */
1848   relocs = FALSE;
1849   for (s = dynobj->sections; s != NULL; s = s->next)
1850     {
1851       if ((s->flags & SEC_LINKER_CREATED) == 0)
1852         continue;
1853
1854       if (s == htab->splt
1855           || s == htab->sgot
1856           || s == htab->sgotplt
1857           || s == htab->sdynbss)
1858         {
1859           /* Strip this section if we don't need it; see the
1860              comment below.  */
1861         }
1862       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
1863         {
1864           if (s->size != 0 && s != htab->srelplt)
1865             relocs = TRUE;
1866
1867           /* We use the reloc_count field as a counter if we need
1868              to copy relocs into the output file.  */
1869           if (s != htab->srelplt)
1870             s->reloc_count = 0;
1871         }
1872       else
1873         {
1874           /* It's not one of our sections, so don't allocate space.  */
1875           continue;
1876         }
1877
1878       if (s->size == 0)
1879         {
1880           /* If we don't need this section, strip it from the
1881              output file.  This is mostly to handle .rela.bss and
1882              .rela.plt.  We must create both sections in
1883              create_dynamic_sections, because they must be created
1884              before the linker maps input sections to output
1885              sections.  The linker does that before
1886              adjust_dynamic_symbol is called, and it is that
1887              function which decides whether anything needs to go
1888              into these sections.  */
1889
1890           s->flags |= SEC_EXCLUDE;
1891           continue;
1892         }
1893
1894       if ((s->flags & SEC_HAS_CONTENTS) == 0)
1895         continue;
1896
1897       /* Allocate memory for the section contents.  We use bfd_zalloc
1898          here in case unused entries are not reclaimed before the
1899          section's contents are written out.  This should not happen,
1900          but this way if it does, we get a R_X86_64_NONE reloc instead
1901          of garbage.  */
1902       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1903       if (s->contents == NULL)
1904         return FALSE;
1905     }
1906
1907   if (htab->elf.dynamic_sections_created)
1908     {
1909       /* Add some entries to the .dynamic section.  We fill in the
1910          values later, in elf64_x86_64_finish_dynamic_sections, but we
1911          must add the entries now so that we get the correct size for
1912          the .dynamic section.  The DT_DEBUG entry is filled in by the
1913          dynamic linker and used by the debugger.  */
1914 #define add_dynamic_entry(TAG, VAL) \
1915   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1916
1917       if (info->executable)
1918         {
1919           if (!add_dynamic_entry (DT_DEBUG, 0))
1920             return FALSE;
1921         }
1922
1923       if (htab->splt->size != 0)
1924         {
1925           if (!add_dynamic_entry (DT_PLTGOT, 0)
1926               || !add_dynamic_entry (DT_PLTRELSZ, 0)
1927               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1928               || !add_dynamic_entry (DT_JMPREL, 0))
1929             return FALSE;
1930
1931           if (htab->tlsdesc_plt
1932               && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
1933                   || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
1934             return FALSE;
1935         }
1936
1937       if (relocs)
1938         {
1939           if (!add_dynamic_entry (DT_RELA, 0)
1940               || !add_dynamic_entry (DT_RELASZ, 0)
1941               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
1942             return FALSE;
1943
1944           /* If any dynamic relocs apply to a read-only section,
1945              then we need a DT_TEXTREL entry.  */
1946           if ((info->flags & DF_TEXTREL) == 0)
1947             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
1948                                     (PTR) info);
1949
1950           if ((info->flags & DF_TEXTREL) != 0)
1951             {
1952               if (!add_dynamic_entry (DT_TEXTREL, 0))
1953                 return FALSE;
1954             }
1955         }
1956     }
1957 #undef add_dynamic_entry
1958
1959   return TRUE;
1960 }
1961
1962 static bfd_boolean
1963 elf64_x86_64_always_size_sections (bfd *output_bfd,
1964                                    struct bfd_link_info *info)
1965 {
1966   asection *tls_sec = elf_hash_table (info)->tls_sec;
1967
1968   if (tls_sec)
1969     {
1970       struct elf_link_hash_entry *tlsbase;
1971
1972       tlsbase = elf_link_hash_lookup (elf_hash_table (info),
1973                                       "_TLS_MODULE_BASE_",
1974                                       FALSE, FALSE, FALSE);
1975
1976       if (tlsbase && tlsbase->type == STT_TLS)
1977         {
1978           struct bfd_link_hash_entry *bh = NULL;
1979           const struct elf_backend_data *bed
1980             = get_elf_backend_data (output_bfd);
1981
1982           if (!(_bfd_generic_link_add_one_symbol
1983                 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
1984                  tls_sec, 0, NULL, FALSE,
1985                  bed->collect, &bh)))
1986             return FALSE;
1987           tlsbase = (struct elf_link_hash_entry *)bh;
1988           tlsbase->def_regular = 1;
1989           tlsbase->other = STV_HIDDEN;
1990           (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
1991         }
1992     }
1993
1994   return TRUE;
1995 }
1996
1997 /* Return the base VMA address which should be subtracted from real addresses
1998    when resolving @dtpoff relocation.
1999    This is PT_TLS segment p_vaddr.  */
2000
2001 static bfd_vma
2002 dtpoff_base (struct bfd_link_info *info)
2003 {
2004   /* If tls_sec is NULL, we should have signalled an error already.  */
2005   if (elf_hash_table (info)->tls_sec == NULL)
2006     return 0;
2007   return elf_hash_table (info)->tls_sec->vma;
2008 }
2009
2010 /* Return the relocation value for @tpoff relocation
2011    if STT_TLS virtual address is ADDRESS.  */
2012
2013 static bfd_vma
2014 tpoff (struct bfd_link_info *info, bfd_vma address)
2015 {
2016   struct elf_link_hash_table *htab = elf_hash_table (info);
2017
2018   /* If tls_segment is NULL, we should have signalled an error already.  */
2019   if (htab->tls_sec == NULL)
2020     return 0;
2021   return address - htab->tls_size - htab->tls_sec->vma;
2022 }
2023
2024 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
2025    branch?  */
2026
2027 static bfd_boolean
2028 is_32bit_relative_branch (bfd_byte *contents, bfd_vma offset)
2029 {
2030   /* Opcode             Instruction
2031      0xe8               call
2032      0xe9               jump
2033      0x0f 0x8x          conditional jump */
2034   return ((offset > 0
2035            && (contents [offset - 1] == 0xe8
2036                || contents [offset - 1] == 0xe9))
2037           || (offset > 1
2038               && contents [offset - 2] == 0x0f
2039               && (contents [offset - 1] & 0xf0) == 0x80));
2040 }
2041
2042 /* Relocate an x86_64 ELF section.  */
2043
2044 static bfd_boolean
2045 elf64_x86_64_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
2046                                bfd *input_bfd, asection *input_section,
2047                                bfd_byte *contents, Elf_Internal_Rela *relocs,
2048                                Elf_Internal_Sym *local_syms,
2049                                asection **local_sections)
2050 {
2051   struct elf64_x86_64_link_hash_table *htab;
2052   Elf_Internal_Shdr *symtab_hdr;
2053   struct elf_link_hash_entry **sym_hashes;
2054   bfd_vma *local_got_offsets;
2055   bfd_vma *local_tlsdesc_gotents;
2056   Elf_Internal_Rela *rel;
2057   Elf_Internal_Rela *relend;
2058
2059   htab = elf64_x86_64_hash_table (info);
2060   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2061   sym_hashes = elf_sym_hashes (input_bfd);
2062   local_got_offsets = elf_local_got_offsets (input_bfd);
2063   local_tlsdesc_gotents = elf64_x86_64_local_tlsdesc_gotent (input_bfd);
2064
2065   rel = relocs;
2066   relend = relocs + input_section->reloc_count;
2067   for (; rel < relend; rel++)
2068     {
2069       unsigned int r_type;
2070       reloc_howto_type *howto;
2071       unsigned long r_symndx;
2072       struct elf_link_hash_entry *h;
2073       Elf_Internal_Sym *sym;
2074       asection *sec;
2075       bfd_vma off, offplt;
2076       bfd_vma relocation;
2077       bfd_boolean unresolved_reloc;
2078       bfd_reloc_status_type r;
2079       int tls_type;
2080
2081       r_type = ELF64_R_TYPE (rel->r_info);
2082       if (r_type == (int) R_X86_64_GNU_VTINHERIT
2083           || r_type == (int) R_X86_64_GNU_VTENTRY)
2084         continue;
2085
2086       if (r_type >= R_X86_64_max)
2087         {
2088           bfd_set_error (bfd_error_bad_value);
2089           return FALSE;
2090         }
2091
2092       howto = x86_64_elf_howto_table + r_type;
2093       r_symndx = ELF64_R_SYM (rel->r_info);
2094       h = NULL;
2095       sym = NULL;
2096       sec = NULL;
2097       unresolved_reloc = FALSE;
2098       if (r_symndx < symtab_hdr->sh_info)
2099         {
2100           sym = local_syms + r_symndx;
2101           sec = local_sections[r_symndx];
2102
2103           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2104         }
2105       else
2106         {
2107           bfd_boolean warned;
2108
2109           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2110                                    r_symndx, symtab_hdr, sym_hashes,
2111                                    h, sec, relocation,
2112                                    unresolved_reloc, warned);
2113         }
2114
2115       if (sec != NULL && elf_discarded_section (sec))
2116         {
2117           /* For relocs against symbols from removed linkonce sections,
2118              or sections discarded by a linker script, we just want the
2119              section contents zeroed.  Avoid any special processing.  */
2120           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2121           rel->r_info = 0;
2122           rel->r_addend = 0;
2123           continue;
2124         }
2125
2126       if (info->relocatable)
2127         continue;
2128
2129       /* When generating a shared object, the relocations handled here are
2130          copied into the output file to be resolved at run time.  */
2131       switch (r_type)
2132         {
2133         asection *base_got;
2134         case R_X86_64_GOT32:
2135         case R_X86_64_GOT64:
2136           /* Relocation is to the entry for this symbol in the global
2137              offset table.  */
2138         case R_X86_64_GOTPCREL:
2139         case R_X86_64_GOTPCREL64:
2140           /* Use global offset table entry as symbol value.  */
2141         case R_X86_64_GOTPLT64:
2142           /* This is the same as GOT64 for relocation purposes, but
2143              indicates the existence of a PLT entry.  The difficulty is,
2144              that we must calculate the GOT slot offset from the PLT
2145              offset, if this symbol got a PLT entry (it was global).
2146              Additionally if it's computed from the PLT entry, then that
2147              GOT offset is relative to .got.plt, not to .got.  */
2148           base_got = htab->sgot;
2149
2150           if (htab->sgot == NULL)
2151             abort ();
2152
2153           if (h != NULL)
2154             {
2155               bfd_boolean dyn;
2156
2157               off = h->got.offset;
2158               if (h->needs_plt
2159                   && h->plt.offset != (bfd_vma)-1
2160                   && off == (bfd_vma)-1)
2161                 {
2162                   /* We can't use h->got.offset here to save
2163                      state, or even just remember the offset, as
2164                      finish_dynamic_symbol would use that as offset into
2165                      .got.  */
2166                   bfd_vma plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2167                   off = (plt_index + 3) * GOT_ENTRY_SIZE;
2168                   base_got = htab->sgotplt;
2169                 }
2170
2171               dyn = htab->elf.dynamic_sections_created;
2172
2173               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2174                   || (info->shared
2175                       && SYMBOL_REFERENCES_LOCAL (info, h))
2176                   || (ELF_ST_VISIBILITY (h->other)
2177                       && h->root.type == bfd_link_hash_undefweak))
2178                 {
2179                   /* This is actually a static link, or it is a -Bsymbolic
2180                      link and the symbol is defined locally, or the symbol
2181                      was forced to be local because of a version file.  We
2182                      must initialize this entry in the global offset table.
2183                      Since the offset must always be a multiple of 8, we
2184                      use the least significant bit to record whether we
2185                      have initialized it already.
2186
2187                      When doing a dynamic link, we create a .rela.got
2188                      relocation entry to initialize the value.  This is
2189                      done in the finish_dynamic_symbol routine.  */
2190                   if ((off & 1) != 0)
2191                     off &= ~1;
2192                   else
2193                     {
2194                       bfd_put_64 (output_bfd, relocation,
2195                                   base_got->contents + off);
2196                       /* Note that this is harmless for the GOTPLT64 case,
2197                          as -1 | 1 still is -1.  */
2198                       h->got.offset |= 1;
2199                     }
2200                 }
2201               else
2202                 unresolved_reloc = FALSE;
2203             }
2204           else
2205             {
2206               if (local_got_offsets == NULL)
2207                 abort ();
2208
2209               off = local_got_offsets[r_symndx];
2210
2211               /* The offset must always be a multiple of 8.  We use
2212                  the least significant bit to record whether we have
2213                  already generated the necessary reloc.  */
2214               if ((off & 1) != 0)
2215                 off &= ~1;
2216               else
2217                 {
2218                   bfd_put_64 (output_bfd, relocation,
2219                               base_got->contents + off);
2220
2221                   if (info->shared)
2222                     {
2223                       asection *s;
2224                       Elf_Internal_Rela outrel;
2225                       bfd_byte *loc;
2226
2227                       /* We need to generate a R_X86_64_RELATIVE reloc
2228                          for the dynamic linker.  */
2229                       s = htab->srelgot;
2230                       if (s == NULL)
2231                         abort ();
2232
2233                       outrel.r_offset = (base_got->output_section->vma
2234                                          + base_got->output_offset
2235                                          + off);
2236                       outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
2237                       outrel.r_addend = relocation;
2238                       loc = s->contents;
2239                       loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
2240                       bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2241                     }
2242
2243                   local_got_offsets[r_symndx] |= 1;
2244                 }
2245             }
2246
2247           if (off >= (bfd_vma) -2)
2248             abort ();
2249
2250           relocation = base_got->output_section->vma
2251                        + base_got->output_offset + off;
2252           if (r_type != R_X86_64_GOTPCREL && r_type != R_X86_64_GOTPCREL64)
2253             relocation -= htab->sgotplt->output_section->vma
2254                           - htab->sgotplt->output_offset;
2255
2256           break;
2257
2258         case R_X86_64_GOTOFF64:
2259           /* Relocation is relative to the start of the global offset
2260              table.  */
2261
2262           /* Check to make sure it isn't a protected function symbol
2263              for shared library since it may not be local when used
2264              as function address.  */
2265           if (info->shared
2266               && h
2267               && h->def_regular
2268               && h->type == STT_FUNC
2269               && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
2270             {
2271               (*_bfd_error_handler)
2272                 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
2273                  input_bfd, h->root.root.string);
2274               bfd_set_error (bfd_error_bad_value);
2275               return FALSE;
2276             }
2277
2278           /* Note that sgot is not involved in this
2279              calculation.  We always want the start of .got.plt.  If we
2280              defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
2281              permitted by the ABI, we might have to change this
2282              calculation.  */
2283           relocation -= htab->sgotplt->output_section->vma
2284                         + htab->sgotplt->output_offset;
2285           break;
2286
2287         case R_X86_64_GOTPC32:
2288         case R_X86_64_GOTPC64:
2289           /* Use global offset table as symbol value.  */
2290           relocation = htab->sgotplt->output_section->vma
2291                        + htab->sgotplt->output_offset;
2292           unresolved_reloc = FALSE;
2293           break;
2294
2295         case R_X86_64_PLTOFF64:
2296           /* Relocation is PLT entry relative to GOT.  For local
2297              symbols it's the symbol itself relative to GOT.  */
2298           if (h != NULL
2299               /* See PLT32 handling.  */
2300               && h->plt.offset != (bfd_vma) -1
2301               && htab->splt != NULL)
2302             {
2303               relocation = (htab->splt->output_section->vma
2304                             + htab->splt->output_offset
2305                             + h->plt.offset);
2306               unresolved_reloc = FALSE;
2307             }
2308
2309           relocation -= htab->sgotplt->output_section->vma
2310                         + htab->sgotplt->output_offset;
2311           break;
2312
2313         case R_X86_64_PLT32:
2314           /* Relocation is to the entry for this symbol in the
2315              procedure linkage table.  */
2316
2317           /* Resolve a PLT32 reloc against a local symbol directly,
2318              without using the procedure linkage table.  */
2319           if (h == NULL)
2320             break;
2321
2322           if (h->plt.offset == (bfd_vma) -1
2323               || htab->splt == NULL)
2324             {
2325               /* We didn't make a PLT entry for this symbol.  This
2326                  happens when statically linking PIC code, or when
2327                  using -Bsymbolic.  */
2328               break;
2329             }
2330
2331           relocation = (htab->splt->output_section->vma
2332                         + htab->splt->output_offset
2333                         + h->plt.offset);
2334           unresolved_reloc = FALSE;
2335           break;
2336
2337         case R_X86_64_PC8:
2338         case R_X86_64_PC16:
2339         case R_X86_64_PC32:
2340           if (info->shared
2341               && !SYMBOL_REFERENCES_LOCAL (info, h)
2342               && (input_section->flags & SEC_ALLOC) != 0
2343               && (input_section->flags & SEC_READONLY) != 0
2344               && (!h->def_regular
2345                   || r_type != R_X86_64_PC32
2346                   || h->type != STT_FUNC
2347                   || ELF_ST_VISIBILITY (h->other) != STV_PROTECTED
2348                   || !is_32bit_relative_branch (contents,
2349                                                 rel->r_offset)))
2350             {
2351               if (h->def_regular
2352                   && r_type == R_X86_64_PC32
2353                   && h->type == STT_FUNC
2354                   && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
2355                 (*_bfd_error_handler)
2356                    (_("%B: relocation R_X86_64_PC32 against protected function `%s' can not be used when making a shared object"),
2357                     input_bfd, h->root.root.string);
2358               else
2359                 (*_bfd_error_handler)
2360                   (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
2361                    input_bfd, x86_64_elf_howto_table[r_type].name,
2362                    h->root.root.string);
2363               bfd_set_error (bfd_error_bad_value);
2364               return FALSE;
2365             }
2366           /* Fall through.  */
2367
2368         case R_X86_64_8:
2369         case R_X86_64_16:
2370         case R_X86_64_32:
2371         case R_X86_64_PC64:
2372         case R_X86_64_64:
2373           /* FIXME: The ABI says the linker should make sure the value is
2374              the same when it's zeroextended to 64 bit.  */
2375
2376           if ((input_section->flags & SEC_ALLOC) == 0)
2377             break;
2378
2379           if ((info->shared
2380                && (h == NULL
2381                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2382                    || h->root.type != bfd_link_hash_undefweak)
2383                && ((r_type != R_X86_64_PC8
2384                     && r_type != R_X86_64_PC16
2385                     && r_type != R_X86_64_PC32
2386                     && r_type != R_X86_64_PC64)
2387                    || !SYMBOL_CALLS_LOCAL (info, h)))
2388               || (ELIMINATE_COPY_RELOCS
2389                   && !info->shared
2390                   && h != NULL
2391                   && h->dynindx != -1
2392                   && !h->non_got_ref
2393                   && ((h->def_dynamic
2394                        && !h->def_regular)
2395                       || h->root.type == bfd_link_hash_undefweak
2396                       || h->root.type == bfd_link_hash_undefined)))
2397             {
2398               Elf_Internal_Rela outrel;
2399               bfd_byte *loc;
2400               bfd_boolean skip, relocate;
2401               asection *sreloc;
2402
2403               /* When generating a shared object, these relocations
2404                  are copied into the output file to be resolved at run
2405                  time.  */
2406               skip = FALSE;
2407               relocate = FALSE;
2408
2409               outrel.r_offset =
2410                 _bfd_elf_section_offset (output_bfd, info, input_section,
2411                                          rel->r_offset);
2412               if (outrel.r_offset == (bfd_vma) -1)
2413                 skip = TRUE;
2414               else if (outrel.r_offset == (bfd_vma) -2)
2415                 skip = TRUE, relocate = TRUE;
2416
2417               outrel.r_offset += (input_section->output_section->vma
2418                                   + input_section->output_offset);
2419
2420               if (skip)
2421                 memset (&outrel, 0, sizeof outrel);
2422
2423               /* h->dynindx may be -1 if this symbol was marked to
2424                  become local.  */
2425               else if (h != NULL
2426                        && h->dynindx != -1
2427                        && (r_type == R_X86_64_PC8
2428                            || r_type == R_X86_64_PC16
2429                            || r_type == R_X86_64_PC32
2430                            || r_type == R_X86_64_PC64
2431                            || !info->shared
2432                            || !SYMBOLIC_BIND (info, h)
2433                            || !h->def_regular))
2434                 {
2435                   outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
2436                   outrel.r_addend = rel->r_addend;
2437                 }
2438               else
2439                 {
2440                   /* This symbol is local, or marked to become local.  */
2441                   if (r_type == R_X86_64_64)
2442                     {
2443                       relocate = TRUE;
2444                       outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
2445                       outrel.r_addend = relocation + rel->r_addend;
2446                     }
2447                   else
2448                     {
2449                       long sindx;
2450
2451                       if (bfd_is_abs_section (sec))
2452                         sindx = 0;
2453                       else if (sec == NULL || sec->owner == NULL)
2454                         {
2455                           bfd_set_error (bfd_error_bad_value);
2456                           return FALSE;
2457                         }
2458                       else
2459                         {
2460                           asection *osec;
2461
2462                           /* We are turning this relocation into one
2463                              against a section symbol.  It would be
2464                              proper to subtract the symbol's value,
2465                              osec->vma, from the emitted reloc addend,
2466                              but ld.so expects buggy relocs.  */
2467                           osec = sec->output_section;
2468                           sindx = elf_section_data (osec)->dynindx;
2469                           if (sindx == 0)
2470                             {
2471                               asection *oi = htab->elf.text_index_section;
2472                               sindx = elf_section_data (oi)->dynindx;
2473                             }
2474                           BFD_ASSERT (sindx != 0);
2475                         }
2476
2477                       outrel.r_info = ELF64_R_INFO (sindx, r_type);
2478                       outrel.r_addend = relocation + rel->r_addend;
2479                     }
2480                 }
2481
2482               sreloc = elf_section_data (input_section)->sreloc;
2483               if (sreloc == NULL)
2484                 abort ();
2485
2486               loc = sreloc->contents;
2487               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2488               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2489
2490               /* If this reloc is against an external symbol, we do
2491                  not want to fiddle with the addend.  Otherwise, we
2492                  need to include the symbol value so that it becomes
2493                  an addend for the dynamic reloc.  */
2494               if (! relocate)
2495                 continue;
2496             }
2497
2498           break;
2499
2500         case R_X86_64_TLSGD:
2501         case R_X86_64_GOTPC32_TLSDESC:
2502         case R_X86_64_TLSDESC_CALL:
2503         case R_X86_64_GOTTPOFF:
2504           r_type = elf64_x86_64_tls_transition (info, r_type, h == NULL);
2505           tls_type = GOT_UNKNOWN;
2506           if (h == NULL && local_got_offsets)
2507             tls_type = elf64_x86_64_local_got_tls_type (input_bfd) [r_symndx];
2508           else if (h != NULL)
2509             {
2510               tls_type = elf64_x86_64_hash_entry (h)->tls_type;
2511               if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
2512                 r_type = R_X86_64_TPOFF32;
2513             }
2514           if (r_type == R_X86_64_TLSGD
2515               || r_type == R_X86_64_GOTPC32_TLSDESC
2516               || r_type == R_X86_64_TLSDESC_CALL)
2517             {
2518               if (tls_type == GOT_TLS_IE)
2519                 r_type = R_X86_64_GOTTPOFF;
2520             }
2521
2522           if (r_type == R_X86_64_TPOFF32)
2523             {
2524               BFD_ASSERT (! unresolved_reloc);
2525               if (ELF64_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
2526                 {
2527                   unsigned int i;
2528                   static unsigned char tlsgd[8]
2529                     = { 0x66, 0x48, 0x8d, 0x3d, 0x66, 0x66, 0x48, 0xe8 };
2530
2531                   /* GD->LE transition.
2532                      .byte 0x66; leaq foo@tlsgd(%rip), %rdi
2533                      .word 0x6666; rex64; call __tls_get_addr@plt
2534                      Change it into:
2535                      movq %fs:0, %rax
2536                      leaq foo@tpoff(%rax), %rax */
2537                   BFD_ASSERT (rel->r_offset >= 4);
2538                   for (i = 0; i < 4; i++)
2539                     BFD_ASSERT (bfd_get_8 (input_bfd,
2540                                            contents + rel->r_offset - 4 + i)
2541                                 == tlsgd[i]);
2542                   BFD_ASSERT (rel->r_offset + 12 <= input_section->size);
2543                   for (i = 0; i < 4; i++)
2544                     BFD_ASSERT (bfd_get_8 (input_bfd,
2545                                            contents + rel->r_offset + 4 + i)
2546                                 == tlsgd[i+4]);
2547                   BFD_ASSERT (rel + 1 < relend);
2548                   BFD_ASSERT (ELF64_R_TYPE (rel[1].r_info) == R_X86_64_PLT32);
2549                   memcpy (contents + rel->r_offset - 4,
2550                           "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
2551                           16);
2552                   bfd_put_32 (output_bfd, tpoff (info, relocation),
2553                               contents + rel->r_offset + 8);
2554                   /* Skip R_X86_64_PLT32.  */
2555                   rel++;
2556                   continue;
2557                 }
2558               else if (ELF64_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
2559                 {
2560                   /* GDesc -> LE transition.
2561                      It's originally something like:
2562                      leaq x@tlsdesc(%rip), %rax
2563
2564                      Change it to:
2565                      movl $x@tpoff, %rax
2566
2567                      Registers other than %rax may be set up here.  */
2568
2569                   unsigned int val, type, type2;
2570                   bfd_vma roff;
2571
2572                   /* First, make sure it's a leaq adding rip to a
2573                      32-bit offset into any register, although it's
2574                      probably almost always going to be rax.  */
2575                   roff = rel->r_offset;
2576                   BFD_ASSERT (roff >= 3);
2577                   type = bfd_get_8 (input_bfd, contents + roff - 3);
2578                   BFD_ASSERT ((type & 0xfb) == 0x48);
2579                   type2 = bfd_get_8 (input_bfd, contents + roff - 2);
2580                   BFD_ASSERT (type2 == 0x8d);
2581                   val = bfd_get_8 (input_bfd, contents + roff - 1);
2582                   BFD_ASSERT ((val & 0xc7) == 0x05);
2583                   BFD_ASSERT (roff + 4 <= input_section->size);
2584
2585                   /* Now modify the instruction as appropriate.  */
2586                   bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1),
2587                              contents + roff - 3);
2588                   bfd_put_8 (output_bfd, 0xc7, contents + roff - 2);
2589                   bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
2590                              contents + roff - 1);
2591                   bfd_put_32 (output_bfd, tpoff (info, relocation),
2592                               contents + roff);
2593                   continue;
2594                 }
2595               else if (ELF64_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
2596                 {
2597                   /* GDesc -> LE transition.
2598                      It's originally:
2599                      call *(%rax)
2600                      Turn it into:
2601                      nop; nop.  */
2602
2603                   unsigned int val, type;
2604                   bfd_vma roff;
2605
2606                   /* First, make sure it's a call *(%rax).  */
2607                   roff = rel->r_offset;
2608                   BFD_ASSERT (roff + 2 <= input_section->size);
2609                   type = bfd_get_8 (input_bfd, contents + roff);
2610                   BFD_ASSERT (type == 0xff);
2611                   val = bfd_get_8 (input_bfd, contents + roff + 1);
2612                   BFD_ASSERT (val == 0x10);
2613
2614                   /* Now modify the instruction as appropriate.  Use
2615                      xchg %ax,%ax instead of 2 nops.  */
2616                   bfd_put_8 (output_bfd, 0x66, contents + roff);
2617                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
2618                   continue;
2619                 }
2620               else
2621                 {
2622                   unsigned int val, type, reg;
2623
2624                   /* IE->LE transition:
2625                      Originally it can be one of:
2626                      movq foo@gottpoff(%rip), %reg
2627                      addq foo@gottpoff(%rip), %reg
2628                      We change it into:
2629                      movq $foo, %reg
2630                      leaq foo(%reg), %reg
2631                      addq $foo, %reg.  */
2632                   BFD_ASSERT (rel->r_offset >= 3);
2633                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 3);
2634                   BFD_ASSERT (val == 0x48 || val == 0x4c);
2635                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2636                   BFD_ASSERT (type == 0x8b || type == 0x03);
2637                   reg = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2638                   BFD_ASSERT ((reg & 0xc7) == 5);
2639                   reg >>= 3;
2640                   BFD_ASSERT (rel->r_offset + 4 <= input_section->size);
2641                   if (type == 0x8b)
2642                     {
2643                       /* movq */
2644                       if (val == 0x4c)
2645                         bfd_put_8 (output_bfd, 0x49,
2646                                    contents + rel->r_offset - 3);
2647                       bfd_put_8 (output_bfd, 0xc7,
2648                                  contents + rel->r_offset - 2);
2649                       bfd_put_8 (output_bfd, 0xc0 | reg,
2650                                  contents + rel->r_offset - 1);
2651                     }
2652                   else if (reg == 4)
2653                     {
2654                       /* addq -> addq - addressing with %rsp/%r12 is
2655                          special  */
2656                       if (val == 0x4c)
2657                         bfd_put_8 (output_bfd, 0x49,
2658                                    contents + rel->r_offset - 3);
2659                       bfd_put_8 (output_bfd, 0x81,
2660                                  contents + rel->r_offset - 2);
2661                       bfd_put_8 (output_bfd, 0xc0 | reg,
2662                                  contents + rel->r_offset - 1);
2663                     }
2664                   else
2665                     {
2666                       /* addq -> leaq */
2667                       if (val == 0x4c)
2668                         bfd_put_8 (output_bfd, 0x4d,
2669                                    contents + rel->r_offset - 3);
2670                       bfd_put_8 (output_bfd, 0x8d,
2671                                  contents + rel->r_offset - 2);
2672                       bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
2673                                  contents + rel->r_offset - 1);
2674                     }
2675                   bfd_put_32 (output_bfd, tpoff (info, relocation),
2676                               contents + rel->r_offset);
2677                   continue;
2678                 }
2679             }
2680
2681           if (htab->sgot == NULL)
2682             abort ();
2683
2684           if (h != NULL)
2685             {
2686               off = h->got.offset;
2687               offplt = elf64_x86_64_hash_entry (h)->tlsdesc_got;
2688             }
2689           else
2690             {
2691               if (local_got_offsets == NULL)
2692                 abort ();
2693
2694               off = local_got_offsets[r_symndx];
2695               offplt = local_tlsdesc_gotents[r_symndx];
2696             }
2697
2698           if ((off & 1) != 0)
2699             off &= ~1;
2700           else
2701             {
2702               Elf_Internal_Rela outrel;
2703               bfd_byte *loc;
2704               int dr_type, indx;
2705               asection *sreloc;
2706
2707               if (htab->srelgot == NULL)
2708                 abort ();
2709
2710               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2711
2712               if (GOT_TLS_GDESC_P (tls_type))
2713                 {
2714                   outrel.r_info = ELF64_R_INFO (indx, R_X86_64_TLSDESC);
2715                   BFD_ASSERT (htab->sgotplt_jump_table_size + offplt
2716                               + 2 * GOT_ENTRY_SIZE <= htab->sgotplt->size);
2717                   outrel.r_offset = (htab->sgotplt->output_section->vma
2718                                      + htab->sgotplt->output_offset
2719                                      + offplt
2720                                      + htab->sgotplt_jump_table_size);
2721                   sreloc = htab->srelplt;
2722                   loc = sreloc->contents;
2723                   loc += sreloc->reloc_count++
2724                     * sizeof (Elf64_External_Rela);
2725                   BFD_ASSERT (loc + sizeof (Elf64_External_Rela)
2726                               <= sreloc->contents + sreloc->size);
2727                   if (indx == 0)
2728                     outrel.r_addend = relocation - dtpoff_base (info);
2729                   else
2730                     outrel.r_addend = 0;
2731                   bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2732                 }
2733
2734               sreloc = htab->srelgot;
2735
2736               outrel.r_offset = (htab->sgot->output_section->vma
2737                                  + htab->sgot->output_offset + off);
2738
2739               if (GOT_TLS_GD_P (tls_type))
2740                 dr_type = R_X86_64_DTPMOD64;
2741               else if (GOT_TLS_GDESC_P (tls_type))
2742                 goto dr_done;
2743               else
2744                 dr_type = R_X86_64_TPOFF64;
2745
2746               bfd_put_64 (output_bfd, 0, htab->sgot->contents + off);
2747               outrel.r_addend = 0;
2748               if ((dr_type == R_X86_64_TPOFF64
2749                    || dr_type == R_X86_64_TLSDESC) && indx == 0)
2750                 outrel.r_addend = relocation - dtpoff_base (info);
2751               outrel.r_info = ELF64_R_INFO (indx, dr_type);
2752
2753               loc = sreloc->contents;
2754               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2755               BFD_ASSERT (loc + sizeof (Elf64_External_Rela)
2756                           <= sreloc->contents + sreloc->size);
2757               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2758
2759               if (GOT_TLS_GD_P (tls_type))
2760                 {
2761                   if (indx == 0)
2762                     {
2763                       BFD_ASSERT (! unresolved_reloc);
2764                       bfd_put_64 (output_bfd,
2765                                   relocation - dtpoff_base (info),
2766                                   htab->sgot->contents + off + GOT_ENTRY_SIZE);
2767                     }
2768                   else
2769                     {
2770                       bfd_put_64 (output_bfd, 0,
2771                                   htab->sgot->contents + off + GOT_ENTRY_SIZE);
2772                       outrel.r_info = ELF64_R_INFO (indx,
2773                                                     R_X86_64_DTPOFF64);
2774                       outrel.r_offset += GOT_ENTRY_SIZE;
2775                       sreloc->reloc_count++;
2776                       loc += sizeof (Elf64_External_Rela);
2777                       BFD_ASSERT (loc + sizeof (Elf64_External_Rela)
2778                                   <= sreloc->contents + sreloc->size);
2779                       bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2780                     }
2781                 }
2782
2783             dr_done:
2784               if (h != NULL)
2785                 h->got.offset |= 1;
2786               else
2787                 local_got_offsets[r_symndx] |= 1;
2788             }
2789
2790           if (off >= (bfd_vma) -2
2791               && ! GOT_TLS_GDESC_P (tls_type))
2792             abort ();
2793           if (r_type == ELF64_R_TYPE (rel->r_info))
2794             {
2795               if (r_type == R_X86_64_GOTPC32_TLSDESC
2796                   || r_type == R_X86_64_TLSDESC_CALL)
2797                 relocation = htab->sgotplt->output_section->vma
2798                   + htab->sgotplt->output_offset
2799                   + offplt + htab->sgotplt_jump_table_size;
2800               else
2801                 relocation = htab->sgot->output_section->vma
2802                   + htab->sgot->output_offset + off;
2803               unresolved_reloc = FALSE;
2804             }
2805           else if (ELF64_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
2806             {
2807               unsigned int i;
2808               static unsigned char tlsgd[8]
2809                 = { 0x66, 0x48, 0x8d, 0x3d, 0x66, 0x66, 0x48, 0xe8 };
2810
2811               /* GD->IE transition.
2812                  .byte 0x66; leaq foo@tlsgd(%rip), %rdi
2813                  .word 0x6666; rex64; call __tls_get_addr@plt
2814                  Change it into:
2815                  movq %fs:0, %rax
2816                  addq foo@gottpoff(%rip), %rax */
2817               BFD_ASSERT (rel->r_offset >= 4);
2818               for (i = 0; i < 4; i++)
2819                 BFD_ASSERT (bfd_get_8 (input_bfd,
2820                                        contents + rel->r_offset - 4 + i)
2821                             == tlsgd[i]);
2822               BFD_ASSERT (rel->r_offset + 12 <= input_section->size);
2823               for (i = 0; i < 4; i++)
2824                 BFD_ASSERT (bfd_get_8 (input_bfd,
2825                                        contents + rel->r_offset + 4 + i)
2826                             == tlsgd[i+4]);
2827               BFD_ASSERT (rel + 1 < relend);
2828               BFD_ASSERT (ELF64_R_TYPE (rel[1].r_info) == R_X86_64_PLT32);
2829               memcpy (contents + rel->r_offset - 4,
2830                       "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
2831                       16);
2832
2833               relocation = (htab->sgot->output_section->vma
2834                             + htab->sgot->output_offset + off
2835                             - rel->r_offset
2836                             - input_section->output_section->vma
2837                             - input_section->output_offset
2838                             - 12);
2839               bfd_put_32 (output_bfd, relocation,
2840                           contents + rel->r_offset + 8);
2841               /* Skip R_X86_64_PLT32.  */
2842               rel++;
2843               continue;
2844             }
2845           else if (ELF64_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
2846             {
2847               /* GDesc -> IE transition.
2848                  It's originally something like:
2849                  leaq x@tlsdesc(%rip), %rax
2850
2851                  Change it to:
2852                  movq x@gottpoff(%rip), %rax # before nop; nop
2853
2854                  Registers other than %rax may be set up here.  */
2855
2856               unsigned int val, type, type2;
2857               bfd_vma roff;
2858
2859               /* First, make sure it's a leaq adding rip to a 32-bit
2860                  offset into any register, although it's probably
2861                  almost always going to be rax.  */
2862               roff = rel->r_offset;
2863               BFD_ASSERT (roff >= 3);
2864               type = bfd_get_8 (input_bfd, contents + roff - 3);
2865               BFD_ASSERT ((type & 0xfb) == 0x48);
2866               type2 = bfd_get_8 (input_bfd, contents + roff - 2);
2867               BFD_ASSERT (type2 == 0x8d);
2868               val = bfd_get_8 (input_bfd, contents + roff - 1);
2869               BFD_ASSERT ((val & 0xc7) == 0x05);
2870               BFD_ASSERT (roff + 4 <= input_section->size);
2871
2872               /* Now modify the instruction as appropriate.  */
2873               /* To turn a leaq into a movq in the form we use it, it
2874                  suffices to change the second byte from 0x8d to
2875                  0x8b.  */
2876               bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
2877
2878               bfd_put_32 (output_bfd,
2879                           htab->sgot->output_section->vma
2880                           + htab->sgot->output_offset + off
2881                           - rel->r_offset
2882                           - input_section->output_section->vma
2883                           - input_section->output_offset
2884                           - 4,
2885                           contents + roff);
2886               continue;
2887             }
2888           else if (ELF64_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
2889             {
2890               /* GDesc -> IE transition.
2891                  It's originally:
2892                  call *(%rax)
2893
2894                  Change it to:
2895                  nop; nop.  */
2896
2897               unsigned int val, type;
2898               bfd_vma roff;
2899
2900               /* First, make sure it's a call *(%eax).  */
2901               roff = rel->r_offset;
2902               BFD_ASSERT (roff + 2 <= input_section->size);
2903               type = bfd_get_8 (input_bfd, contents + roff);
2904               BFD_ASSERT (type == 0xff);
2905               val = bfd_get_8 (input_bfd, contents + roff + 1);
2906               BFD_ASSERT (val == 0x10);
2907
2908               /* Now modify the instruction as appropriate.  Use
2909                  xchg %ax,%ax instead of 2 nops.  */
2910               bfd_put_8 (output_bfd, 0x66, contents + roff);
2911               bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
2912
2913               continue;
2914             }
2915           else
2916             BFD_ASSERT (FALSE);
2917           break;
2918
2919         case R_X86_64_TLSLD:
2920           if (! info->shared)
2921             {
2922               /* LD->LE transition:
2923                  Ensure it is:
2924                  leaq foo@tlsld(%rip), %rdi; call __tls_get_addr@plt.
2925                  We change it into:
2926                  .word 0x6666; .byte 0x66; movl %fs:0, %rax.  */
2927               BFD_ASSERT (rel->r_offset >= 3);
2928               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 3)
2929                           == 0x48);
2930               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2)
2931                           == 0x8d);
2932               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 1)
2933                           == 0x3d);
2934               BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
2935               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2936                           == 0xe8);
2937               BFD_ASSERT (rel + 1 < relend);
2938               BFD_ASSERT (ELF64_R_TYPE (rel[1].r_info) == R_X86_64_PLT32);
2939               memcpy (contents + rel->r_offset - 3,
2940                       "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
2941               /* Skip R_X86_64_PLT32.  */
2942               rel++;
2943               continue;
2944             }
2945
2946           if (htab->sgot == NULL)
2947             abort ();
2948
2949           off = htab->tls_ld_got.offset;
2950           if (off & 1)
2951             off &= ~1;
2952           else
2953             {
2954               Elf_Internal_Rela outrel;
2955               bfd_byte *loc;
2956
2957               if (htab->srelgot == NULL)
2958                 abort ();
2959
2960               outrel.r_offset = (htab->sgot->output_section->vma
2961                                  + htab->sgot->output_offset + off);
2962
2963               bfd_put_64 (output_bfd, 0,
2964                           htab->sgot->contents + off);
2965               bfd_put_64 (output_bfd, 0,
2966                           htab->sgot->contents + off + GOT_ENTRY_SIZE);
2967               outrel.r_info = ELF64_R_INFO (0, R_X86_64_DTPMOD64);
2968               outrel.r_addend = 0;
2969               loc = htab->srelgot->contents;
2970               loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
2971               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2972               htab->tls_ld_got.offset |= 1;
2973             }
2974           relocation = htab->sgot->output_section->vma
2975                        + htab->sgot->output_offset + off;
2976           unresolved_reloc = FALSE;
2977           break;
2978
2979         case R_X86_64_DTPOFF32:
2980           if (info->shared || (input_section->flags & SEC_CODE) == 0)
2981             relocation -= dtpoff_base (info);
2982           else
2983             relocation = tpoff (info, relocation);
2984           break;
2985
2986         case R_X86_64_TPOFF32:
2987           BFD_ASSERT (! info->shared);
2988           relocation = tpoff (info, relocation);
2989           break;
2990
2991         default:
2992           break;
2993         }
2994
2995       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2996          because such sections are not SEC_ALLOC and thus ld.so will
2997          not process them.  */
2998       if (unresolved_reloc
2999           && !((input_section->flags & SEC_DEBUGGING) != 0
3000                && h->def_dynamic))
3001         (*_bfd_error_handler)
3002           (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3003            input_bfd,
3004            input_section,
3005            (long) rel->r_offset,
3006            howto->name,
3007            h->root.root.string);
3008
3009       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3010                                     contents, rel->r_offset,
3011                                     relocation, rel->r_addend);
3012
3013       if (r != bfd_reloc_ok)
3014         {
3015           const char *name;
3016
3017           if (h != NULL)
3018             name = h->root.root.string;
3019           else
3020             {
3021               name = bfd_elf_string_from_elf_section (input_bfd,
3022                                                       symtab_hdr->sh_link,
3023                                                       sym->st_name);
3024               if (name == NULL)
3025                 return FALSE;
3026               if (*name == '\0')
3027                 name = bfd_section_name (input_bfd, sec);
3028             }
3029
3030           if (r == bfd_reloc_overflow)
3031             {
3032               if (! ((*info->callbacks->reloc_overflow)
3033                      (info, (h ? &h->root : NULL), name, howto->name,
3034                       (bfd_vma) 0, input_bfd, input_section,
3035                       rel->r_offset)))
3036                 return FALSE;
3037             }
3038           else
3039             {
3040               (*_bfd_error_handler)
3041                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3042                  input_bfd, input_section,
3043                  (long) rel->r_offset, name, (int) r);
3044               return FALSE;
3045             }
3046         }
3047     }
3048
3049   return TRUE;
3050 }
3051
3052 /* Finish up dynamic symbol handling.  We set the contents of various
3053    dynamic sections here.  */
3054
3055 static bfd_boolean
3056 elf64_x86_64_finish_dynamic_symbol (bfd *output_bfd,
3057                                     struct bfd_link_info *info,
3058                                     struct elf_link_hash_entry *h,
3059                                     Elf_Internal_Sym *sym)
3060 {
3061   struct elf64_x86_64_link_hash_table *htab;
3062
3063   htab = elf64_x86_64_hash_table (info);
3064
3065   if (h->plt.offset != (bfd_vma) -1)
3066     {
3067       bfd_vma plt_index;
3068       bfd_vma got_offset;
3069       Elf_Internal_Rela rela;
3070       bfd_byte *loc;
3071
3072       /* This symbol has an entry in the procedure linkage table.  Set
3073          it up.  */
3074       if (h->dynindx == -1
3075           || htab->splt == NULL
3076           || htab->sgotplt == NULL
3077           || htab->srelplt == NULL)
3078         abort ();
3079
3080       /* Get the index in the procedure linkage table which
3081          corresponds to this symbol.  This is the index of this symbol
3082          in all the symbols for which we are making plt entries.  The
3083          first entry in the procedure linkage table is reserved.  */
3084       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3085
3086       /* Get the offset into the .got table of the entry that
3087          corresponds to this function.  Each .got entry is GOT_ENTRY_SIZE
3088          bytes. The first three are reserved for the dynamic linker.  */
3089       got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
3090
3091       /* Fill in the entry in the procedure linkage table.  */
3092       memcpy (htab->splt->contents + h->plt.offset, elf64_x86_64_plt_entry,
3093               PLT_ENTRY_SIZE);
3094
3095       /* Insert the relocation positions of the plt section.  The magic
3096          numbers at the end of the statements are the positions of the
3097          relocations in the plt section.  */
3098       /* Put offset for jmp *name@GOTPCREL(%rip), since the
3099          instruction uses 6 bytes, subtract this value.  */
3100       bfd_put_32 (output_bfd,
3101                       (htab->sgotplt->output_section->vma
3102                        + htab->sgotplt->output_offset
3103                        + got_offset
3104                        - htab->splt->output_section->vma
3105                        - htab->splt->output_offset
3106                        - h->plt.offset
3107                        - 6),
3108                   htab->splt->contents + h->plt.offset + 2);
3109       /* Put relocation index.  */
3110       bfd_put_32 (output_bfd, plt_index,
3111                   htab->splt->contents + h->plt.offset + 7);
3112       /* Put offset for jmp .PLT0.  */
3113       bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
3114                   htab->splt->contents + h->plt.offset + 12);
3115
3116       /* Fill in the entry in the global offset table, initially this
3117          points to the pushq instruction in the PLT which is at offset 6.  */
3118       bfd_put_64 (output_bfd, (htab->splt->output_section->vma
3119                                + htab->splt->output_offset
3120                                + h->plt.offset + 6),
3121                   htab->sgotplt->contents + got_offset);
3122
3123       /* Fill in the entry in the .rela.plt section.  */
3124       rela.r_offset = (htab->sgotplt->output_section->vma
3125                        + htab->sgotplt->output_offset
3126                        + got_offset);
3127       rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_JUMP_SLOT);
3128       rela.r_addend = 0;
3129       loc = htab->srelplt->contents + plt_index * sizeof (Elf64_External_Rela);
3130       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3131
3132       if (!h->def_regular)
3133         {
3134           /* Mark the symbol as undefined, rather than as defined in
3135              the .plt section.  Leave the value if there were any
3136              relocations where pointer equality matters (this is a clue
3137              for the dynamic linker, to make function pointer
3138              comparisons work between an application and shared
3139              library), otherwise set it to zero.  If a function is only
3140              called from a binary, there is no need to slow down
3141              shared libraries because of that.  */
3142           sym->st_shndx = SHN_UNDEF;
3143           if (!h->pointer_equality_needed)
3144             sym->st_value = 0;
3145         }
3146     }
3147
3148   if (h->got.offset != (bfd_vma) -1
3149       && ! GOT_TLS_GD_ANY_P (elf64_x86_64_hash_entry (h)->tls_type)
3150       && elf64_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE)
3151     {
3152       Elf_Internal_Rela rela;
3153       bfd_byte *loc;
3154
3155       /* This symbol has an entry in the global offset table.  Set it
3156          up.  */
3157       if (htab->sgot == NULL || htab->srelgot == NULL)
3158         abort ();
3159
3160       rela.r_offset = (htab->sgot->output_section->vma
3161                        + htab->sgot->output_offset
3162                        + (h->got.offset &~ (bfd_vma) 1));
3163
3164       /* If this is a static link, or it is a -Bsymbolic link and the
3165          symbol is defined locally or was forced to be local because
3166          of a version file, we just want to emit a RELATIVE reloc.
3167          The entry in the global offset table will already have been
3168          initialized in the relocate_section function.  */
3169       if (info->shared
3170           && SYMBOL_REFERENCES_LOCAL (info, h))
3171         {
3172           BFD_ASSERT((h->got.offset & 1) != 0);
3173           rela.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
3174           rela.r_addend = (h->root.u.def.value
3175                            + h->root.u.def.section->output_section->vma
3176                            + h->root.u.def.section->output_offset);
3177         }
3178       else
3179         {
3180           BFD_ASSERT((h->got.offset & 1) == 0);
3181           bfd_put_64 (output_bfd, (bfd_vma) 0,
3182                       htab->sgot->contents + h->got.offset);
3183           rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_GLOB_DAT);
3184           rela.r_addend = 0;
3185         }
3186
3187       loc = htab->srelgot->contents;
3188       loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
3189       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3190     }
3191
3192   if (h->needs_copy)
3193     {
3194       Elf_Internal_Rela rela;
3195       bfd_byte *loc;
3196
3197       /* This symbol needs a copy reloc.  Set it up.  */
3198
3199       if (h->dynindx == -1
3200           || (h->root.type != bfd_link_hash_defined
3201               && h->root.type != bfd_link_hash_defweak)
3202           || htab->srelbss == NULL)
3203         abort ();
3204
3205       rela.r_offset = (h->root.u.def.value
3206                        + h->root.u.def.section->output_section->vma
3207                        + h->root.u.def.section->output_offset);
3208       rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_COPY);
3209       rela.r_addend = 0;
3210       loc = htab->srelbss->contents;
3211       loc += htab->srelbss->reloc_count++ * sizeof (Elf64_External_Rela);
3212       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3213     }
3214
3215   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
3216   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3217       || h == htab->elf.hgot)
3218     sym->st_shndx = SHN_ABS;
3219
3220   return TRUE;
3221 }
3222
3223 /* Used to decide how to sort relocs in an optimal manner for the
3224    dynamic linker, before writing them out.  */
3225
3226 static enum elf_reloc_type_class
3227 elf64_x86_64_reloc_type_class (const Elf_Internal_Rela *rela)
3228 {
3229   switch ((int) ELF64_R_TYPE (rela->r_info))
3230     {
3231     case R_X86_64_RELATIVE:
3232       return reloc_class_relative;
3233     case R_X86_64_JUMP_SLOT:
3234       return reloc_class_plt;
3235     case R_X86_64_COPY:
3236       return reloc_class_copy;
3237     default:
3238       return reloc_class_normal;
3239     }
3240 }
3241
3242 /* Finish up the dynamic sections.  */
3243
3244 static bfd_boolean
3245 elf64_x86_64_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
3246 {
3247   struct elf64_x86_64_link_hash_table *htab;
3248   bfd *dynobj;
3249   asection *sdyn;
3250
3251   htab = elf64_x86_64_hash_table (info);
3252   dynobj = htab->elf.dynobj;
3253   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3254
3255   if (htab->elf.dynamic_sections_created)
3256     {
3257       Elf64_External_Dyn *dyncon, *dynconend;
3258
3259       if (sdyn == NULL || htab->sgot == NULL)
3260         abort ();
3261
3262       dyncon = (Elf64_External_Dyn *) sdyn->contents;
3263       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
3264       for (; dyncon < dynconend; dyncon++)
3265         {
3266           Elf_Internal_Dyn dyn;
3267           asection *s;
3268
3269           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3270
3271           switch (dyn.d_tag)
3272             {
3273             default:
3274               continue;
3275
3276             case DT_PLTGOT:
3277               s = htab->sgotplt;
3278               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3279               break;
3280
3281             case DT_JMPREL:
3282               dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
3283               break;
3284
3285             case DT_PLTRELSZ:
3286               s = htab->srelplt->output_section;
3287               dyn.d_un.d_val = s->size;
3288               break;
3289
3290             case DT_RELASZ:
3291               /* The procedure linkage table relocs (DT_JMPREL) should
3292                  not be included in the overall relocs (DT_RELA).
3293                  Therefore, we override the DT_RELASZ entry here to
3294                  make it not include the JMPREL relocs.  Since the
3295                  linker script arranges for .rela.plt to follow all
3296                  other relocation sections, we don't have to worry
3297                  about changing the DT_RELA entry.  */
3298               if (htab->srelplt != NULL)
3299                 {
3300                   s = htab->srelplt->output_section;
3301                   dyn.d_un.d_val -= s->size;
3302                 }
3303               break;
3304
3305             case DT_TLSDESC_PLT:
3306               s = htab->splt;
3307               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
3308                 + htab->tlsdesc_plt;
3309               break;
3310
3311             case DT_TLSDESC_GOT:
3312               s = htab->sgot;
3313               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
3314                 + htab->tlsdesc_got;
3315               break;
3316             }
3317
3318           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3319         }
3320
3321       /* Fill in the special first entry in the procedure linkage table.  */
3322       if (htab->splt && htab->splt->size > 0)
3323         {
3324           /* Fill in the first entry in the procedure linkage table.  */
3325           memcpy (htab->splt->contents, elf64_x86_64_plt0_entry,
3326                   PLT_ENTRY_SIZE);
3327           /* Add offset for pushq GOT+8(%rip), since the instruction
3328              uses 6 bytes subtract this value.  */
3329           bfd_put_32 (output_bfd,
3330                       (htab->sgotplt->output_section->vma
3331                        + htab->sgotplt->output_offset
3332                        + 8
3333                        - htab->splt->output_section->vma
3334                        - htab->splt->output_offset
3335                        - 6),
3336                       htab->splt->contents + 2);
3337           /* Add offset for jmp *GOT+16(%rip). The 12 is the offset to
3338              the end of the instruction.  */
3339           bfd_put_32 (output_bfd,
3340                       (htab->sgotplt->output_section->vma
3341                        + htab->sgotplt->output_offset
3342                        + 16
3343                        - htab->splt->output_section->vma
3344                        - htab->splt->output_offset
3345                        - 12),
3346                       htab->splt->contents + 8);
3347
3348           elf_section_data (htab->splt->output_section)->this_hdr.sh_entsize =
3349             PLT_ENTRY_SIZE;
3350
3351           if (htab->tlsdesc_plt)
3352             {
3353               bfd_put_64 (output_bfd, (bfd_vma) 0,
3354                           htab->sgot->contents + htab->tlsdesc_got);
3355
3356               memcpy (htab->splt->contents + htab->tlsdesc_plt,
3357                       elf64_x86_64_plt0_entry,
3358                       PLT_ENTRY_SIZE);
3359
3360               /* Add offset for pushq GOT+8(%rip), since the
3361                  instruction uses 6 bytes subtract this value.  */
3362               bfd_put_32 (output_bfd,
3363                           (htab->sgotplt->output_section->vma
3364                            + htab->sgotplt->output_offset
3365                            + 8
3366                            - htab->splt->output_section->vma
3367                            - htab->splt->output_offset
3368                            - htab->tlsdesc_plt
3369                            - 6),
3370                           htab->splt->contents + htab->tlsdesc_plt + 2);
3371               /* Add offset for jmp *GOT+TDG(%rip), where TGD stands for
3372                  htab->tlsdesc_got. The 12 is the offset to the end of
3373                  the instruction.  */
3374               bfd_put_32 (output_bfd,
3375                           (htab->sgot->output_section->vma
3376                            + htab->sgot->output_offset
3377                            + htab->tlsdesc_got
3378                            - htab->splt->output_section->vma
3379                            - htab->splt->output_offset
3380                            - htab->tlsdesc_plt
3381                            - 12),
3382                           htab->splt->contents + htab->tlsdesc_plt + 8);
3383             }
3384         }
3385     }
3386
3387   if (htab->sgotplt)
3388     {
3389       /* Fill in the first three entries in the global offset table.  */
3390       if (htab->sgotplt->size > 0)
3391         {
3392           /* Set the first entry in the global offset table to the address of
3393              the dynamic section.  */
3394           if (sdyn == NULL)
3395             bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents);
3396           else
3397             bfd_put_64 (output_bfd,
3398                         sdyn->output_section->vma + sdyn->output_offset,
3399                         htab->sgotplt->contents);
3400           /* Write GOT[1] and GOT[2], needed for the dynamic linker.  */
3401           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + GOT_ENTRY_SIZE);
3402           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + GOT_ENTRY_SIZE*2);
3403         }
3404
3405       elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize =
3406         GOT_ENTRY_SIZE;
3407     }
3408
3409   if (htab->sgot && htab->sgot->size > 0)
3410     elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize
3411       = GOT_ENTRY_SIZE;
3412
3413   return TRUE;
3414 }
3415
3416 /* Return address for Ith PLT stub in section PLT, for relocation REL
3417    or (bfd_vma) -1 if it should not be included.  */
3418
3419 static bfd_vma
3420 elf64_x86_64_plt_sym_val (bfd_vma i, const asection *plt,
3421                           const arelent *rel ATTRIBUTE_UNUSED)
3422 {
3423   return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
3424 }
3425
3426 /* Handle an x86-64 specific section when reading an object file.  This
3427    is called when elfcode.h finds a section with an unknown type.  */
3428
3429 static bfd_boolean
3430 elf64_x86_64_section_from_shdr (bfd *abfd,
3431                                 Elf_Internal_Shdr *hdr,
3432                                 const char *name,
3433                                 int shindex)
3434 {
3435   if (hdr->sh_type != SHT_X86_64_UNWIND)
3436     return FALSE;
3437
3438   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
3439     return FALSE;
3440
3441   return TRUE;
3442 }
3443
3444 /* Hook called by the linker routine which adds symbols from an object
3445    file.  We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
3446    of .bss.  */
3447
3448 static bfd_boolean
3449 elf64_x86_64_add_symbol_hook (bfd *abfd,
3450                               struct bfd_link_info *info ATTRIBUTE_UNUSED,
3451                               Elf_Internal_Sym *sym,
3452                               const char **namep ATTRIBUTE_UNUSED,
3453                               flagword *flagsp ATTRIBUTE_UNUSED,
3454                               asection **secp, bfd_vma *valp)
3455 {
3456   asection *lcomm;
3457
3458   switch (sym->st_shndx)
3459     {
3460     case SHN_X86_64_LCOMMON:
3461       lcomm = bfd_get_section_by_name (abfd, "LARGE_COMMON");
3462       if (lcomm == NULL)
3463         {
3464           lcomm = bfd_make_section_with_flags (abfd,
3465                                                "LARGE_COMMON",
3466                                                (SEC_ALLOC
3467                                                 | SEC_IS_COMMON
3468                                                 | SEC_LINKER_CREATED));
3469           if (lcomm == NULL)
3470             return FALSE;
3471           elf_section_flags (lcomm) |= SHF_X86_64_LARGE;
3472         }
3473       *secp = lcomm;
3474       *valp = sym->st_size;
3475       break;
3476     }
3477   return TRUE;
3478 }
3479
3480
3481 /* Given a BFD section, try to locate the corresponding ELF section
3482    index.  */
3483
3484 static bfd_boolean
3485 elf64_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
3486                                            asection *sec, int *index)
3487 {
3488   if (sec == &_bfd_elf_large_com_section)
3489     {
3490       *index = SHN_X86_64_LCOMMON;
3491       return TRUE;
3492     }
3493   return FALSE;
3494 }
3495
3496 /* Process a symbol.  */
3497
3498 static void
3499 elf64_x86_64_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
3500                                 asymbol *asym)
3501 {
3502   elf_symbol_type *elfsym = (elf_symbol_type *) asym;
3503
3504   switch (elfsym->internal_elf_sym.st_shndx)
3505     {
3506     case SHN_X86_64_LCOMMON:
3507       asym->section = &_bfd_elf_large_com_section;
3508       asym->value = elfsym->internal_elf_sym.st_size;
3509       /* Common symbol doesn't set BSF_GLOBAL.  */
3510       asym->flags &= ~BSF_GLOBAL;
3511       break;
3512     }
3513 }
3514
3515 static bfd_boolean
3516 elf64_x86_64_common_definition (Elf_Internal_Sym *sym)
3517 {
3518   return (sym->st_shndx == SHN_COMMON
3519           || sym->st_shndx == SHN_X86_64_LCOMMON);
3520 }
3521
3522 static unsigned int
3523 elf64_x86_64_common_section_index (asection *sec)
3524 {
3525   if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
3526     return SHN_COMMON;
3527   else
3528     return SHN_X86_64_LCOMMON;
3529 }
3530
3531 static asection *
3532 elf64_x86_64_common_section (asection *sec)
3533 {
3534   if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
3535     return bfd_com_section_ptr;
3536   else
3537     return &_bfd_elf_large_com_section;
3538 }
3539
3540 static bfd_boolean
3541 elf64_x86_64_merge_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
3542                            struct elf_link_hash_entry **sym_hash ATTRIBUTE_UNUSED,
3543                            struct elf_link_hash_entry *h,
3544                            Elf_Internal_Sym *sym,
3545                            asection **psec,
3546                            bfd_vma *pvalue ATTRIBUTE_UNUSED,
3547                            unsigned int *pold_alignment ATTRIBUTE_UNUSED,
3548                            bfd_boolean *skip ATTRIBUTE_UNUSED,
3549                            bfd_boolean *override ATTRIBUTE_UNUSED,
3550                            bfd_boolean *type_change_ok ATTRIBUTE_UNUSED,
3551                            bfd_boolean *size_change_ok ATTRIBUTE_UNUSED,
3552                            bfd_boolean *newdef ATTRIBUTE_UNUSED,
3553                            bfd_boolean *newdyn,
3554                            bfd_boolean *newdyncommon ATTRIBUTE_UNUSED,
3555                            bfd_boolean *newweak ATTRIBUTE_UNUSED,
3556                            bfd *abfd ATTRIBUTE_UNUSED,
3557                            asection **sec,
3558                            bfd_boolean *olddef ATTRIBUTE_UNUSED,
3559                            bfd_boolean *olddyn,
3560                            bfd_boolean *olddyncommon ATTRIBUTE_UNUSED,
3561                            bfd_boolean *oldweak ATTRIBUTE_UNUSED,
3562                            bfd *oldbfd,
3563                            asection **oldsec)
3564 {
3565   /* A normal common symbol and a large common symbol result in a
3566      normal common symbol.  We turn the large common symbol into a
3567      normal one.  */
3568   if (!*olddyn
3569       && h->root.type == bfd_link_hash_common
3570       && !*newdyn
3571       && bfd_is_com_section (*sec)
3572       && *oldsec != *sec)
3573     {
3574       if (sym->st_shndx == SHN_COMMON
3575           && (elf_section_flags (*oldsec) & SHF_X86_64_LARGE) != 0)
3576         {
3577           h->root.u.c.p->section
3578             = bfd_make_section_old_way (oldbfd, "COMMON");
3579           h->root.u.c.p->section->flags = SEC_ALLOC;
3580         }
3581       else if (sym->st_shndx == SHN_X86_64_LCOMMON
3582                && (elf_section_flags (*oldsec) & SHF_X86_64_LARGE) == 0)
3583         *psec = *sec = bfd_com_section_ptr;
3584     }
3585
3586   return TRUE;
3587 }
3588
3589 static int
3590 elf64_x86_64_additional_program_headers (bfd *abfd,
3591                                          struct bfd_link_info *info ATTRIBUTE_UNUSED)
3592 {
3593   asection *s;
3594   int count = 0;
3595
3596   /* Check to see if we need a large readonly segment.  */
3597   s = bfd_get_section_by_name (abfd, ".lrodata");
3598   if (s && (s->flags & SEC_LOAD))
3599     count++;
3600
3601   /* Check to see if we need a large data segment.  Since .lbss sections
3602      is placed right after the .bss section, there should be no need for
3603      a large data segment just because of .lbss.  */
3604   s = bfd_get_section_by_name (abfd, ".ldata");
3605   if (s && (s->flags & SEC_LOAD))
3606     count++;
3607
3608   return count;
3609 }
3610
3611 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
3612
3613 static bfd_boolean
3614 elf64_x86_64_hash_symbol (struct elf_link_hash_entry *h)
3615 {
3616   if (h->plt.offset != (bfd_vma) -1
3617       && !h->def_regular
3618       && !h->pointer_equality_needed)
3619     return FALSE;
3620
3621   return _bfd_elf_hash_symbol (h);
3622 }
3623
3624 static const struct bfd_elf_special_section
3625   elf64_x86_64_special_sections[]=
3626 {
3627   { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
3628   { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
3629   { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE},
3630   { STRING_COMMA_LEN (".lbss"),            -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
3631   { STRING_COMMA_LEN (".ldata"),           -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
3632   { STRING_COMMA_LEN (".lrodata"),         -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
3633   { NULL,                       0,          0, 0,            0 }
3634 };
3635
3636 #define TARGET_LITTLE_SYM                   bfd_elf64_x86_64_vec
3637 #define TARGET_LITTLE_NAME                  "elf64-x86-64"
3638 #define ELF_ARCH                            bfd_arch_i386
3639 #define ELF_MACHINE_CODE                    EM_X86_64
3640 #define ELF_MAXPAGESIZE                     0x200000
3641 #define ELF_MINPAGESIZE                     0x1000
3642 #define ELF_COMMONPAGESIZE                  0x1000
3643
3644 #define elf_backend_can_gc_sections         1
3645 #define elf_backend_can_refcount            1
3646 #define elf_backend_want_got_plt            1
3647 #define elf_backend_plt_readonly            1
3648 #define elf_backend_want_plt_sym            0
3649 #define elf_backend_got_header_size         (GOT_ENTRY_SIZE*3)
3650 #define elf_backend_rela_normal             1
3651
3652 #define elf_info_to_howto                   elf64_x86_64_info_to_howto
3653
3654 #define bfd_elf64_bfd_link_hash_table_create \
3655   elf64_x86_64_link_hash_table_create
3656 #define bfd_elf64_bfd_reloc_type_lookup     elf64_x86_64_reloc_type_lookup
3657 #define bfd_elf64_bfd_reloc_name_lookup \
3658   elf64_x86_64_reloc_name_lookup
3659
3660 #define elf_backend_adjust_dynamic_symbol   elf64_x86_64_adjust_dynamic_symbol
3661 #define elf_backend_check_relocs            elf64_x86_64_check_relocs
3662 #define elf_backend_copy_indirect_symbol    elf64_x86_64_copy_indirect_symbol
3663 #define elf_backend_create_dynamic_sections elf64_x86_64_create_dynamic_sections
3664 #define elf_backend_finish_dynamic_sections elf64_x86_64_finish_dynamic_sections
3665 #define elf_backend_finish_dynamic_symbol   elf64_x86_64_finish_dynamic_symbol
3666 #define elf_backend_gc_mark_hook            elf64_x86_64_gc_mark_hook
3667 #define elf_backend_gc_sweep_hook           elf64_x86_64_gc_sweep_hook
3668 #define elf_backend_grok_prstatus           elf64_x86_64_grok_prstatus
3669 #define elf_backend_grok_psinfo             elf64_x86_64_grok_psinfo
3670 #define elf_backend_reloc_type_class        elf64_x86_64_reloc_type_class
3671 #define elf_backend_relocate_section        elf64_x86_64_relocate_section
3672 #define elf_backend_size_dynamic_sections   elf64_x86_64_size_dynamic_sections
3673 #define elf_backend_always_size_sections    elf64_x86_64_always_size_sections
3674 #define elf_backend_init_index_section      _bfd_elf_init_1_index_section
3675 #define elf_backend_plt_sym_val             elf64_x86_64_plt_sym_val
3676 #define elf_backend_object_p                elf64_x86_64_elf_object_p
3677 #define bfd_elf64_mkobject                  elf64_x86_64_mkobject
3678
3679 #define elf_backend_section_from_shdr \
3680         elf64_x86_64_section_from_shdr
3681
3682 #define elf_backend_section_from_bfd_section \
3683   elf64_x86_64_elf_section_from_bfd_section
3684 #define elf_backend_add_symbol_hook \
3685   elf64_x86_64_add_symbol_hook
3686 #define elf_backend_symbol_processing \
3687   elf64_x86_64_symbol_processing
3688 #define elf_backend_common_section_index \
3689   elf64_x86_64_common_section_index
3690 #define elf_backend_common_section \
3691   elf64_x86_64_common_section
3692 #define elf_backend_common_definition \
3693   elf64_x86_64_common_definition
3694 #define elf_backend_merge_symbol \
3695   elf64_x86_64_merge_symbol
3696 #define elf_backend_special_sections \
3697   elf64_x86_64_special_sections
3698 #define elf_backend_additional_program_headers \
3699   elf64_x86_64_additional_program_headers
3700 #define elf_backend_hash_symbol \
3701   elf64_x86_64_hash_symbol
3702
3703 #include "elf64-target.h"
3704
3705 /* FreeBSD support.  */
3706
3707 #undef  TARGET_LITTLE_SYM
3708 #define TARGET_LITTLE_SYM                   bfd_elf64_x86_64_freebsd_vec
3709 #undef  TARGET_LITTLE_NAME
3710 #define TARGET_LITTLE_NAME                  "elf64-x86-64-freebsd"
3711
3712 #undef  ELF_OSABI
3713 #define ELF_OSABI                           ELFOSABI_FREEBSD
3714
3715 #undef  elf_backend_post_process_headers
3716 #define elf_backend_post_process_headers  _bfd_elf_set_osabi
3717
3718 #undef  elf64_bed
3719 #define elf64_bed elf64_x86_64_fbsd_bed
3720
3721 #include "elf64-target.h"