bfd/elf64-x86-64.c

   1 /* X86-64 specific support for ELF
   2    Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
   3    2010, 2011, 2012
   4    Free Software Foundation, Inc.
   5    Contributed by Jan Hubicka <jh@suse.cz>.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  22    MA 02110-1301, USA.  */
  23
  24 #include "sysdep.h"
  25 #include "bfd.h"
  26 #include "bfdlink.h"
  27 #include "libbfd.h"
  28 #include "elf-bfd.h"
  29 #include "elf-nacl.h"
  30 #include "bfd_stdint.h"
  31 #include "objalloc.h"
  32 #include "hashtab.h"
  33 #include "dwarf2.h"
  34 #include "libiberty.h"
  35
  36 #include "elf/x86-64.h"
  37
  38 #ifdef CORE_HEADER
  39 #include <stdarg.h>
  40 #include CORE_HEADER
  41 #endif
  42
  43 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value.  */
  44 #define MINUS_ONE (~ (bfd_vma) 0)
  45
  46 /* Since both 32-bit and 64-bit x86-64 encode relocation type in the
  47    identical manner, we use ELF32_R_TYPE instead of ELF64_R_TYPE to get
  48    relocation type.  We also use ELF_ST_TYPE instead of ELF64_ST_TYPE
  49    since they are the same.  */
  50
  51 #define ABI_64_P(abfd) \
  52   (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64)
  53
  54 /* The relocation "howto" table.  Order of fields:
  55    type, rightshift, size, bitsize, pc_relative, bitpos, complain_on_overflow,
  56    special_function, name, partial_inplace, src_mask, dst_mask, pcrel_offset.  */
  57 static reloc_howto_type x86_64_elf_howto_table[] =
  58 {
  59   HOWTO(R_X86_64_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
  60         bfd_elf_generic_reloc, "R_X86_64_NONE", FALSE, 0x00000000, 0x00000000,
  61         FALSE),
  62   HOWTO(R_X86_64_64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  63         bfd_elf_generic_reloc, "R_X86_64_64", FALSE, MINUS_ONE, MINUS_ONE,
  64         FALSE),
  65   HOWTO(R_X86_64_PC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
  66         bfd_elf_generic_reloc, "R_X86_64_PC32", FALSE, 0xffffffff, 0xffffffff,
  67         TRUE),
  68   HOWTO(R_X86_64_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
  69         bfd_elf_generic_reloc, "R_X86_64_GOT32", FALSE, 0xffffffff, 0xffffffff,
  70         FALSE),
  71   HOWTO(R_X86_64_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
  72         bfd_elf_generic_reloc, "R_X86_64_PLT32", FALSE, 0xffffffff, 0xffffffff,
  73         TRUE),
  74   HOWTO(R_X86_64_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  75         bfd_elf_generic_reloc, "R_X86_64_COPY", FALSE, 0xffffffff, 0xffffffff,
  76         FALSE),
  77   HOWTO(R_X86_64_GLOB_DAT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  78         bfd_elf_generic_reloc, "R_X86_64_GLOB_DAT", FALSE, MINUS_ONE,
  79         MINUS_ONE, FALSE),
  80   HOWTO(R_X86_64_JUMP_SLOT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  81         bfd_elf_generic_reloc, "R_X86_64_JUMP_SLOT", FALSE, MINUS_ONE,
  82         MINUS_ONE, FALSE),
  83   HOWTO(R_X86_64_RELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  84         bfd_elf_generic_reloc, "R_X86_64_RELATIVE", FALSE, MINUS_ONE,
  85         MINUS_ONE, FALSE),
  86   HOWTO(R_X86_64_GOTPCREL, 0, 2, 32, TRUE, 0, complain_overflow_signed,
  87         bfd_elf_generic_reloc, "R_X86_64_GOTPCREL", FALSE, 0xffffffff,
  88         0xffffffff, TRUE),
  89   HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
  90         bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
  91         FALSE),
  92   HOWTO(R_X86_64_32S, 0, 2, 32, FALSE, 0, complain_overflow_signed,
  93         bfd_elf_generic_reloc, "R_X86_64_32S", FALSE, 0xffffffff, 0xffffffff,
  94         FALSE),
  95   HOWTO(R_X86_64_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
  96         bfd_elf_generic_reloc, "R_X86_64_16", FALSE, 0xffff, 0xffff, FALSE),
  97   HOWTO(R_X86_64_PC16,0, 1, 16, TRUE, 0, complain_overflow_bitfield,
  98         bfd_elf_generic_reloc, "R_X86_64_PC16", FALSE, 0xffff, 0xffff, TRUE),
  99   HOWTO(R_X86_64_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
 100         bfd_elf_generic_reloc, "R_X86_64_8", FALSE, 0xff, 0xff, FALSE),
 101   HOWTO(R_X86_64_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
 102         bfd_elf_generic_reloc, "R_X86_64_PC8", FALSE, 0xff, 0xff, TRUE),
 103   HOWTO(R_X86_64_DTPMOD64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 104         bfd_elf_generic_reloc, "R_X86_64_DTPMOD64", FALSE, MINUS_ONE,
 105         MINUS_ONE, FALSE),
 106   HOWTO(R_X86_64_DTPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 107         bfd_elf_generic_reloc, "R_X86_64_DTPOFF64", FALSE, MINUS_ONE,
 108         MINUS_ONE, FALSE),
 109   HOWTO(R_X86_64_TPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 110         bfd_elf_generic_reloc, "R_X86_64_TPOFF64", FALSE, MINUS_ONE,
 111         MINUS_ONE, FALSE),
 112   HOWTO(R_X86_64_TLSGD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
 113         bfd_elf_generic_reloc, "R_X86_64_TLSGD", FALSE, 0xffffffff,
 114         0xffffffff, TRUE),
 115   HOWTO(R_X86_64_TLSLD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
 116         bfd_elf_generic_reloc, "R_X86_64_TLSLD", FALSE, 0xffffffff,
 117         0xffffffff, TRUE),
 118   HOWTO(R_X86_64_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
 119         bfd_elf_generic_reloc, "R_X86_64_DTPOFF32", FALSE, 0xffffffff,
 120         0xffffffff, FALSE),
 121   HOWTO(R_X86_64_GOTTPOFF, 0, 2, 32, TRUE, 0, complain_overflow_signed,
 122         bfd_elf_generic_reloc, "R_X86_64_GOTTPOFF", FALSE, 0xffffffff,
 123         0xffffffff, TRUE),
 124   HOWTO(R_X86_64_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
 125         bfd_elf_generic_reloc, "R_X86_64_TPOFF32", FALSE, 0xffffffff,
 126         0xffffffff, FALSE),
 127   HOWTO(R_X86_64_PC64, 0, 4, 64, TRUE, 0, complain_overflow_bitfield,
 128         bfd_elf_generic_reloc, "R_X86_64_PC64", FALSE, MINUS_ONE, MINUS_ONE,
 129         TRUE),
 130   HOWTO(R_X86_64_GOTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 131         bfd_elf_generic_reloc, "R_X86_64_GOTOFF64",
 132         FALSE, MINUS_ONE, MINUS_ONE, FALSE),
 133   HOWTO(R_X86_64_GOTPC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
 134         bfd_elf_generic_reloc, "R_X86_64_GOTPC32",
 135         FALSE, 0xffffffff, 0xffffffff, TRUE),
 136   HOWTO(R_X86_64_GOT64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
 137         bfd_elf_generic_reloc, "R_X86_64_GOT64", FALSE, MINUS_ONE, MINUS_ONE,
 138         FALSE),
 139   HOWTO(R_X86_64_GOTPCREL64, 0, 4, 64, TRUE, 0, complain_overflow_signed,
 140         bfd_elf_generic_reloc, "R_X86_64_GOTPCREL64", FALSE, MINUS_ONE,
 141         MINUS_ONE, TRUE),
 142   HOWTO(R_X86_64_GOTPC64, 0, 4, 64, TRUE, 0, complain_overflow_signed,
 143         bfd_elf_generic_reloc, "R_X86_64_GOTPC64",
 144         FALSE, MINUS_ONE, MINUS_ONE, TRUE),
 145   HOWTO(R_X86_64_GOTPLT64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
 146         bfd_elf_generic_reloc, "R_X86_64_GOTPLT64", FALSE, MINUS_ONE,
 147         MINUS_ONE, FALSE),
 148   HOWTO(R_X86_64_PLTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_signed,
 149         bfd_elf_generic_reloc, "R_X86_64_PLTOFF64", FALSE, MINUS_ONE,
 150         MINUS_ONE, FALSE),
 151   EMPTY_HOWTO (32),
 152   EMPTY_HOWTO (33),
 153   HOWTO(R_X86_64_GOTPC32_TLSDESC, 0, 2, 32, TRUE, 0,
 154         complain_overflow_bitfield, bfd_elf_generic_reloc,
 155         "R_X86_64_GOTPC32_TLSDESC",
 156         FALSE, 0xffffffff, 0xffffffff, TRUE),
 157   HOWTO(R_X86_64_TLSDESC_CALL, 0, 0, 0, FALSE, 0,
 158         complain_overflow_dont, bfd_elf_generic_reloc,
 159         "R_X86_64_TLSDESC_CALL",
 160         FALSE, 0, 0, FALSE),
 161   HOWTO(R_X86_64_TLSDESC, 0, 4, 64, FALSE, 0,
 162         complain_overflow_bitfield, bfd_elf_generic_reloc,
 163         "R_X86_64_TLSDESC",
 164         FALSE, MINUS_ONE, MINUS_ONE, FALSE),
 165   HOWTO(R_X86_64_IRELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 166         bfd_elf_generic_reloc, "R_X86_64_IRELATIVE", FALSE, MINUS_ONE,
 167         MINUS_ONE, FALSE),
 168   HOWTO(R_X86_64_RELATIVE64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 169         bfd_elf_generic_reloc, "R_X86_64_RELATIVE64", FALSE, MINUS_ONE,
 170         MINUS_ONE, FALSE),
 171
 172   /* We have a gap in the reloc numbers here.
 173      R_X86_64_standard counts the number up to this point, and
 174      R_X86_64_vt_offset is the value to subtract from a reloc type of
 175      R_X86_64_GNU_VT* to form an index into this table.  */
 176 #define R_X86_64_standard (R_X86_64_IRELATIVE + 1)
 177 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
 178
 179 /* GNU extension to record C++ vtable hierarchy.  */
 180   HOWTO (R_X86_64_GNU_VTINHERIT, 0, 4, 0, FALSE, 0, complain_overflow_dont,
 181          NULL, "R_X86_64_GNU_VTINHERIT", FALSE, 0, 0, FALSE),
 182
 183 /* GNU extension to record C++ vtable member usage.  */
 184   HOWTO (R_X86_64_GNU_VTENTRY, 0, 4, 0, FALSE, 0, complain_overflow_dont,
 185          _bfd_elf_rel_vtable_reloc_fn, "R_X86_64_GNU_VTENTRY", FALSE, 0, 0,
 186          FALSE),
 187
 188 /* Use complain_overflow_bitfield on R_X86_64_32 for x32.  */
 189   HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 190         bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
 191         FALSE)
 192 };
 193
 194 #define IS_X86_64_PCREL_TYPE(TYPE)      \
 195   (   ((TYPE) == R_X86_64_PC8)          \
 196    || ((TYPE) == R_X86_64_PC16)         \
 197    || ((TYPE) == R_X86_64_PC32)         \
 198    || ((TYPE) == R_X86_64_PC64))
 199
 200 /* Map BFD relocs to the x86_64 elf relocs.  */
 201 struct elf_reloc_map
 202 {
 203   bfd_reloc_code_real_type bfd_reloc_val;
 204   unsigned char elf_reloc_val;
 205 };
 206
 207 static const struct elf_reloc_map x86_64_reloc_map[] =
 208 {
 209   { BFD_RELOC_NONE,             R_X86_64_NONE, },
 210   { BFD_RELOC_64,               R_X86_64_64,   },
 211   { BFD_RELOC_32_PCREL,         R_X86_64_PC32, },
 212   { BFD_RELOC_X86_64_GOT32,     R_X86_64_GOT32,},
 213   { BFD_RELOC_X86_64_PLT32,     R_X86_64_PLT32,},
 214   { BFD_RELOC_X86_64_COPY,      R_X86_64_COPY, },
 215   { BFD_RELOC_X86_64_GLOB_DAT,  R_X86_64_GLOB_DAT, },
 216   { BFD_RELOC_X86_64_JUMP_SLOT, R_X86_64_JUMP_SLOT, },
 217   { BFD_RELOC_X86_64_RELATIVE,  R_X86_64_RELATIVE, },
 218   { BFD_RELOC_X86_64_GOTPCREL,  R_X86_64_GOTPCREL, },
 219   { BFD_RELOC_32,               R_X86_64_32, },
 220   { BFD_RELOC_X86_64_32S,       R_X86_64_32S, },
 221   { BFD_RELOC_16,               R_X86_64_16, },
 222   { BFD_RELOC_16_PCREL,         R_X86_64_PC16, },
 223   { BFD_RELOC_8,                R_X86_64_8, },
 224   { BFD_RELOC_8_PCREL,          R_X86_64_PC8, },
 225   { BFD_RELOC_X86_64_DTPMOD64,  R_X86_64_DTPMOD64, },
 226   { BFD_RELOC_X86_64_DTPOFF64,  R_X86_64_DTPOFF64, },
 227   { BFD_RELOC_X86_64_TPOFF64,   R_X86_64_TPOFF64, },
 228   { BFD_RELOC_X86_64_TLSGD,     R_X86_64_TLSGD, },
 229   { BFD_RELOC_X86_64_TLSLD,     R_X86_64_TLSLD, },
 230   { BFD_RELOC_X86_64_DTPOFF32,  R_X86_64_DTPOFF32, },
 231   { BFD_RELOC_X86_64_GOTTPOFF,  R_X86_64_GOTTPOFF, },
 232   { BFD_RELOC_X86_64_TPOFF32,   R_X86_64_TPOFF32, },
 233   { BFD_RELOC_64_PCREL,         R_X86_64_PC64, },
 234   { BFD_RELOC_X86_64_GOTOFF64,  R_X86_64_GOTOFF64, },
 235   { BFD_RELOC_X86_64_GOTPC32,   R_X86_64_GOTPC32, },
 236   { BFD_RELOC_X86_64_GOT64,     R_X86_64_GOT64, },
 237   { BFD_RELOC_X86_64_GOTPCREL64,R_X86_64_GOTPCREL64, },
 238   { BFD_RELOC_X86_64_GOTPC64,   R_X86_64_GOTPC64, },
 239   { BFD_RELOC_X86_64_GOTPLT64,  R_X86_64_GOTPLT64, },
 240   { BFD_RELOC_X86_64_PLTOFF64,  R_X86_64_PLTOFF64, },
 241   { BFD_RELOC_X86_64_GOTPC32_TLSDESC, R_X86_64_GOTPC32_TLSDESC, },
 242   { BFD_RELOC_X86_64_TLSDESC_CALL, R_X86_64_TLSDESC_CALL, },
 243   { BFD_RELOC_X86_64_TLSDESC,   R_X86_64_TLSDESC, },
 244   { BFD_RELOC_X86_64_IRELATIVE, R_X86_64_IRELATIVE, },
 245   { BFD_RELOC_VTABLE_INHERIT,   R_X86_64_GNU_VTINHERIT, },
 246   { BFD_RELOC_VTABLE_ENTRY,     R_X86_64_GNU_VTENTRY, },
 247 };
 248
 249 static reloc_howto_type *
 250 elf_x86_64_rtype_to_howto (bfd *abfd, unsigned r_type)
 251 {
 252   unsigned i;
 253
 254   if (r_type == (unsigned int) R_X86_64_32)
 255     {
 256       if (ABI_64_P (abfd))
 257         i = r_type;
 258       else
 259         i = ARRAY_SIZE (x86_64_elf_howto_table) - 1;
 260     }
 261   else if (r_type < (unsigned int) R_X86_64_GNU_VTINHERIT
 262            || r_type >= (unsigned int) R_X86_64_max)
 263     {
 264       if (r_type >= (unsigned int) R_X86_64_standard)
 265         {
 266           (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
 267                                  abfd, (int) r_type);
 268           r_type = R_X86_64_NONE;
 269         }
 270       i = r_type;
 271     }
 272   else
 273     i = r_type - (unsigned int) R_X86_64_vt_offset;
 274   BFD_ASSERT (x86_64_elf_howto_table[i].type == r_type);
 275   return &x86_64_elf_howto_table[i];
 276 }
 277
 278 /* Given a BFD reloc type, return a HOWTO structure.  */
 279 static reloc_howto_type *
 280 elf_x86_64_reloc_type_lookup (bfd *abfd,
 281                               bfd_reloc_code_real_type code)
 282 {
 283   unsigned int i;
 284
 285   for (i = 0; i < sizeof (x86_64_reloc_map) / sizeof (struct elf_reloc_map);
 286        i++)
 287     {
 288       if (x86_64_reloc_map[i].bfd_reloc_val == code)
 289         return elf_x86_64_rtype_to_howto (abfd,
 290                                           x86_64_reloc_map[i].elf_reloc_val);
 291     }
 292   return 0;
 293 }
 294
 295 static reloc_howto_type *
 296 elf_x86_64_reloc_name_lookup (bfd *abfd,
 297                               const char *r_name)
 298 {
 299   unsigned int i;
 300
 301   if (!ABI_64_P (abfd) && strcasecmp (r_name, "R_X86_64_32") == 0)
 302     {
 303       /* Get x32 R_X86_64_32.  */
 304       reloc_howto_type *reloc
 305         = &x86_64_elf_howto_table[ARRAY_SIZE (x86_64_elf_howto_table) - 1];
 306       BFD_ASSERT (reloc->type == (unsigned int) R_X86_64_32);
 307       return reloc;
 308     }
 309
 310   for (i = 0; i < ARRAY_SIZE (x86_64_elf_howto_table); i++)
 311     if (x86_64_elf_howto_table[i].name != NULL
 312         && strcasecmp (x86_64_elf_howto_table[i].name, r_name) == 0)
 313       return &x86_64_elf_howto_table[i];
 314
 315   return NULL;
 316 }
 317
 318 /* Given an x86_64 ELF reloc type, fill in an arelent structure.  */
 319
 320 static void
 321 elf_x86_64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
 322                           Elf_Internal_Rela *dst)
 323 {
 324   unsigned r_type;
 325
 326   r_type = ELF32_R_TYPE (dst->r_info);
 327   cache_ptr->howto = elf_x86_64_rtype_to_howto (abfd, r_type);
 328   BFD_ASSERT (r_type == cache_ptr->howto->type);
 329 }
 330 \f
 331 /* Support for core dump NOTE sections.  */
 332 static bfd_boolean
 333 elf_x86_64_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
 334 {
 335   int offset;
 336   size_t size;
 337
 338   switch (note->descsz)
 339     {
 340       default:
 341         return FALSE;
 342
 343       case 296:         /* sizeof(istruct elf_prstatus) on Linux/x32 */
 344         /* pr_cursig */
 345         elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
 346
 347         /* pr_pid */
 348         elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24);
 349
 350         /* pr_reg */
 351         offset = 72;
 352         size = 216;
 353
 354         break;
 355
 356       case 336:         /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
 357         /* pr_cursig */
 358         elf_tdata (abfd)->core_signal
 359           = bfd_get_16 (abfd, note->descdata + 12);
 360
 361         /* pr_pid */
 362         elf_tdata (abfd)->core_lwpid
 363           = bfd_get_32 (abfd, note->descdata + 32);
 364
 365         /* pr_reg */
 366         offset = 112;
 367         size = 216;
 368
 369         break;
 370     }
 371
 372   /* Make a ".reg/999" section.  */
 373   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
 374                                           size, note->descpos + offset);
 375 }
 376
 377 static bfd_boolean
 378 elf_x86_64_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
 379 {
 380   switch (note->descsz)
 381     {
 382       default:
 383         return FALSE;
 384
 385       case 124:         /* sizeof(struct elf_prpsinfo) on Linux/x32 */
 386         elf_tdata (abfd)->core_pid
 387           = bfd_get_32 (abfd, note->descdata + 12);
 388         elf_tdata (abfd)->core_program
 389           = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
 390         elf_tdata (abfd)->core_command
 391           = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
 392         break;
 393
 394       case 136:         /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
 395         elf_tdata (abfd)->core_pid
 396           = bfd_get_32 (abfd, note->descdata + 24);
 397         elf_tdata (abfd)->core_program
 398          = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
 399         elf_tdata (abfd)->core_command
 400          = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
 401     }
 402
 403   /* Note that for some reason, a spurious space is tacked
 404      onto the end of the args in some (at least one anyway)
 405      implementations, so strip it off if it exists.  */
 406
 407   {
 408     char *command = elf_tdata (abfd)->core_command;
 409     int n = strlen (command);
 410
 411     if (0 < n && command[n - 1] == ' ')
 412       command[n - 1] = '\0';
 413   }
 414
 415   return TRUE;
 416 }
 417
 418 #ifdef CORE_HEADER
 419 static char *
 420 elf_x86_64_write_core_note (bfd *abfd, char *buf, int *bufsiz,
 421                             int note_type, ...)
 422 {
 423   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
 424   va_list ap;
 425   const char *fname, *psargs;
 426   long pid;
 427   int cursig;
 428   const void *gregs;
 429
 430   switch (note_type)
 431     {
 432     default:
 433       return NULL;
 434
 435     case NT_PRPSINFO:
 436       va_start (ap, note_type);
 437       fname = va_arg (ap, const char *);
 438       psargs = va_arg (ap, const char *);
 439       va_end (ap);
 440
 441       if (bed->s->elfclass == ELFCLASS32)
 442         {
 443           prpsinfo32_t data;
 444           memset (&data, 0, sizeof (data));
 445           strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
 446           strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
 447           return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
 448                                      &data, sizeof (data));
 449         }
 450       else
 451         {
 452           prpsinfo_t data;
 453           memset (&data, 0, sizeof (data));
 454           strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
 455           strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
 456           return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
 457                                      &data, sizeof (data));
 458         }
 459       /* NOTREACHED */
 460
 461     case NT_PRSTATUS:
 462       va_start (ap, note_type);
 463       pid = va_arg (ap, long);
 464       cursig = va_arg (ap, int);
 465       gregs = va_arg (ap, const void *);
 466       va_end (ap);
 467
 468       if (bed->s->elfclass == ELFCLASS32)
 469         {
 470           if (bed->elf_machine_code == EM_X86_64)
 471             {
 472               prstatusx32_t prstat;
 473               memset (&prstat, 0, sizeof (prstat));
 474               prstat.pr_pid = pid;
 475               prstat.pr_cursig = cursig;
 476               memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
 477               return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
 478                                          &prstat, sizeof (prstat));
 479             }
 480           else
 481             {
 482               prstatus32_t prstat;
 483               memset (&prstat, 0, sizeof (prstat));
 484               prstat.pr_pid = pid;
 485               prstat.pr_cursig = cursig;
 486               memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
 487               return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
 488                                          &prstat, sizeof (prstat));
 489             }
 490         }
 491       else
 492         {
 493           prstatus_t prstat;
 494           memset (&prstat, 0, sizeof (prstat));
 495           prstat.pr_pid = pid;
 496           prstat.pr_cursig = cursig;
 497           memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
 498           return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
 499                                      &prstat, sizeof (prstat));
 500         }
 501     }
 502   /* NOTREACHED */
 503 }
 504 #endif
 505 \f
 506 /* Functions for the x86-64 ELF linker.  */
 507
 508 /* The name of the dynamic interpreter.  This is put in the .interp
 509    section.  */
 510
 511 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
 512 #define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
 513
 514 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
 515    copying dynamic variables from a shared lib into an app's dynbss
 516    section, and instead use a dynamic relocation to point into the
 517    shared lib.  */
 518 #define ELIMINATE_COPY_RELOCS 1
 519
 520 /* The size in bytes of an entry in the global offset table.  */
 521
 522 #define GOT_ENTRY_SIZE 8
 523
 524 /* The size in bytes of an entry in the procedure linkage table.  */
 525
 526 #define PLT_ENTRY_SIZE 16
 527
 528 /* The first entry in a procedure linkage table looks like this.  See the
 529    SVR4 ABI i386 supplement and the x86-64 ABI to see how this works.  */
 530
 531 static const bfd_byte elf_x86_64_plt0_entry[PLT_ENTRY_SIZE] =
 532 {
 533   0xff, 0x35, 8, 0, 0, 0,       /* pushq GOT+8(%rip)  */
 534   0xff, 0x25, 16, 0, 0, 0,      /* jmpq *GOT+16(%rip) */
 535   0x0f, 0x1f, 0x40, 0x00        /* nopl 0(%rax)       */
 536 };
 537
 538 /* Subsequent entries in a procedure linkage table look like this.  */
 539
 540 static const bfd_byte elf_x86_64_plt_entry[PLT_ENTRY_SIZE] =
 541 {
 542   0xff, 0x25,   /* jmpq *name@GOTPC(%rip) */
 543   0, 0, 0, 0,   /* replaced with offset to this symbol in .got.  */
 544   0x68,         /* pushq immediate */
 545   0, 0, 0, 0,   /* replaced with index into relocation table.  */
 546   0xe9,         /* jmp relative */
 547   0, 0, 0, 0    /* replaced with offset to start of .plt0.  */
 548 };
 549
 550 /* .eh_frame covering the .plt section.  */
 551
 552 static const bfd_byte elf_x86_64_eh_frame_plt[] =
 553 {
 554 #define PLT_CIE_LENGTH          20
 555 #define PLT_FDE_LENGTH          36
 556 #define PLT_FDE_START_OFFSET    4 + PLT_CIE_LENGTH + 8
 557 #define PLT_FDE_LEN_OFFSET      4 + PLT_CIE_LENGTH + 12
 558   PLT_CIE_LENGTH, 0, 0, 0,      /* CIE length */
 559   0, 0, 0, 0,                   /* CIE ID */
 560   1,                            /* CIE version */
 561   'z', 'R', 0,                  /* Augmentation string */
 562   1,                            /* Code alignment factor */
 563   0x78,                         /* Data alignment factor */
 564   16,                           /* Return address column */
 565   1,                            /* Augmentation size */
 566   DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
 567   DW_CFA_def_cfa, 7, 8,         /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
 568   DW_CFA_offset + 16, 1,        /* DW_CFA_offset: r16 (rip) at cfa-8 */
 569   DW_CFA_nop, DW_CFA_nop,
 570
 571   PLT_FDE_LENGTH, 0, 0, 0,      /* FDE length */
 572   PLT_CIE_LENGTH + 8, 0, 0, 0,  /* CIE pointer */
 573   0, 0, 0, 0,                   /* R_X86_64_PC32 .plt goes here */
 574   0, 0, 0, 0,                   /* .plt size goes here */
 575   0,                            /* Augmentation size */
 576   DW_CFA_def_cfa_offset, 16,    /* DW_CFA_def_cfa_offset: 16 */
 577   DW_CFA_advance_loc + 6,       /* DW_CFA_advance_loc: 6 to __PLT__+6 */
 578   DW_CFA_def_cfa_offset, 24,    /* DW_CFA_def_cfa_offset: 24 */
 579   DW_CFA_advance_loc + 10,      /* DW_CFA_advance_loc: 10 to __PLT__+16 */
 580   DW_CFA_def_cfa_expression,    /* DW_CFA_def_cfa_expression */
 581   11,                           /* Block length */
 582   DW_OP_breg7, 8,               /* DW_OP_breg7 (rsp): 8 */
 583   DW_OP_breg16, 0,              /* DW_OP_breg16 (rip): 0 */
 584   DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
 585   DW_OP_lit3, DW_OP_shl, DW_OP_plus,
 586   DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
 587 };
 588
 589 /* Architecture-specific backend data for x86-64.  */
 590
 591 struct elf_x86_64_backend_data
 592 {
 593   /* Templates for the initial PLT entry and for subsequent entries.  */
 594   const bfd_byte *plt0_entry;
 595   const bfd_byte *plt_entry;
 596   unsigned int plt_entry_size;          /* Size of each PLT entry.  */
 597
 598   /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2].  */
 599   unsigned int plt0_got1_offset;
 600   unsigned int plt0_got2_offset;
 601
 602   /* Offset of the end of the PC-relative instruction containing
 603      plt0_got2_offset.  */
 604   unsigned int plt0_got2_insn_end;
 605
 606   /* Offsets into plt_entry that are to be replaced with...  */
 607   unsigned int plt_got_offset;    /* ... address of this symbol in .got. */
 608   unsigned int plt_reloc_offset;  /* ... offset into relocation table. */
 609   unsigned int plt_plt_offset;    /* ... offset to start of .plt. */
 610
 611   /* Length of the PC-relative instruction containing plt_got_offset.  */
 612   unsigned int plt_got_insn_size;
 613
 614   /* Offset of the end of the PC-relative jump to plt0_entry.  */
 615   unsigned int plt_plt_insn_end;
 616
 617   /* Offset into plt_entry where the initial value of the GOT entry points.  */
 618   unsigned int plt_lazy_offset;
 619
 620   /* .eh_frame covering the .plt section.  */
 621   const bfd_byte *eh_frame_plt;
 622   unsigned int eh_frame_plt_size;
 623 };
 624
 625 #define get_elf_x86_64_backend_data(abfd) \
 626   ((const struct elf_x86_64_backend_data *) \
 627    get_elf_backend_data (abfd)->arch_data)
 628
 629 #define GET_PLT_ENTRY_SIZE(abfd) \
 630   get_elf_x86_64_backend_data (abfd)->plt_entry_size
 631
 632 /* These are the standard parameters.  */
 633 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed =
 634   {
 635     elf_x86_64_plt0_entry,              /* plt0_entry */
 636     elf_x86_64_plt_entry,               /* plt_entry */
 637     sizeof (elf_x86_64_plt_entry),      /* plt_entry_size */
 638     2,                                  /* plt0_got1_offset */
 639     8,                                  /* plt0_got2_offset */
 640     12,                                 /* plt0_got2_insn_end */
 641     2,                                  /* plt_got_offset */
 642     7,                                  /* plt_reloc_offset */
 643     12,                                 /* plt_plt_offset */
 644     6,                                  /* plt_got_insn_size */
 645     PLT_ENTRY_SIZE,                     /* plt_plt_insn_end */
 646     6,                                  /* plt_lazy_offset */
 647     elf_x86_64_eh_frame_plt,            /* eh_frame_plt */
 648     sizeof (elf_x86_64_eh_frame_plt),   /* eh_frame_plt_size */
 649   };
 650
 651 #define elf_backend_arch_data   &elf_x86_64_arch_bed
 652
 653 /* x86-64 ELF linker hash entry.  */
 654
 655 struct elf_x86_64_link_hash_entry
 656 {
 657   struct elf_link_hash_entry elf;
 658
 659   /* Track dynamic relocs copied for this symbol.  */
 660   struct elf_dyn_relocs *dyn_relocs;
 661
 662 #define GOT_UNKNOWN     0
 663 #define GOT_NORMAL      1
 664 #define GOT_TLS_GD      2
 665 #define GOT_TLS_IE      3
 666 #define GOT_TLS_GDESC   4
 667 #define GOT_TLS_GD_BOTH_P(type) \
 668   ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
 669 #define GOT_TLS_GD_P(type) \
 670   ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
 671 #define GOT_TLS_GDESC_P(type) \
 672   ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
 673 #define GOT_TLS_GD_ANY_P(type) \
 674   (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
 675   unsigned char tls_type;
 676
 677   /* Offset of the GOTPLT entry reserved for the TLS descriptor,
 678      starting at the end of the jump table.  */
 679   bfd_vma tlsdesc_got;
 680 };
 681
 682 #define elf_x86_64_hash_entry(ent) \
 683   ((struct elf_x86_64_link_hash_entry *)(ent))
 684
 685 struct elf_x86_64_obj_tdata
 686 {
 687   struct elf_obj_tdata root;
 688
 689   /* tls_type for each local got entry.  */
 690   char *local_got_tls_type;
 691
 692   /* GOTPLT entries for TLS descriptors.  */
 693   bfd_vma *local_tlsdesc_gotent;
 694 };
 695
 696 #define elf_x86_64_tdata(abfd) \
 697   ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
 698
 699 #define elf_x86_64_local_got_tls_type(abfd) \
 700   (elf_x86_64_tdata (abfd)->local_got_tls_type)
 701
 702 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
 703   (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
 704
 705 #define is_x86_64_elf(bfd)                              \
 706   (bfd_get_flavour (bfd) == bfd_target_elf_flavour      \
 707    && elf_tdata (bfd) != NULL                           \
 708    && elf_object_id (bfd) == X86_64_ELF_DATA)
 709
 710 static bfd_boolean
 711 elf_x86_64_mkobject (bfd *abfd)
 712 {
 713   return bfd_elf_allocate_object (abfd, sizeof (struct elf_x86_64_obj_tdata),
 714                                   X86_64_ELF_DATA);
 715 }
 716
 717 /* x86-64 ELF linker hash table.  */
 718
 719 struct elf_x86_64_link_hash_table
 720 {
 721   struct elf_link_hash_table elf;
 722
 723   /* Short-cuts to get to dynamic linker sections.  */
 724   asection *sdynbss;
 725   asection *srelbss;
 726   asection *plt_eh_frame;
 727
 728   union
 729   {
 730     bfd_signed_vma refcount;
 731     bfd_vma offset;
 732   } tls_ld_got;
 733
 734   /* The amount of space used by the jump slots in the GOT.  */
 735   bfd_vma sgotplt_jump_table_size;
 736
 737   /* Small local sym cache.  */
 738   struct sym_cache sym_cache;
 739
 740   bfd_vma (*r_info) (bfd_vma, bfd_vma);
 741   bfd_vma (*r_sym) (bfd_vma);
 742   unsigned int pointer_r_type;
 743   const char *dynamic_interpreter;
 744   int dynamic_interpreter_size;
 745
 746   /* _TLS_MODULE_BASE_ symbol.  */
 747   struct bfd_link_hash_entry *tls_module_base;
 748
 749   /* Used by local STT_GNU_IFUNC symbols.  */
 750   htab_t loc_hash_table;
 751   void * loc_hash_memory;
 752
 753   /* The offset into splt of the PLT entry for the TLS descriptor
 754      resolver.  Special values are 0, if not necessary (or not found
 755      to be necessary yet), and -1 if needed but not determined
 756      yet.  */
 757   bfd_vma tlsdesc_plt;
 758   /* The offset into sgot of the GOT entry used by the PLT entry
 759      above.  */
 760   bfd_vma tlsdesc_got;
 761
 762   /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt.  */
 763   bfd_vma next_jump_slot_index;
 764   /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt.  */
 765   bfd_vma next_irelative_index;
 766 };
 767
 768 /* Get the x86-64 ELF linker hash table from a link_info structure.  */
 769
 770 #define elf_x86_64_hash_table(p) \
 771   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
 772   == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
 773
 774 #define elf_x86_64_compute_jump_table_size(htab) \
 775   ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
 776
 777 /* Create an entry in an x86-64 ELF linker hash table.  */
 778
 779 static struct bfd_hash_entry *
 780 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry *entry,
 781                               struct bfd_hash_table *table,
 782                               const char *string)
 783 {
 784   /* Allocate the structure if it has not already been allocated by a
 785      subclass.  */
 786   if (entry == NULL)
 787     {
 788       entry = (struct bfd_hash_entry *)
 789           bfd_hash_allocate (table,
 790                              sizeof (struct elf_x86_64_link_hash_entry));
 791       if (entry == NULL)
 792         return entry;
 793     }
 794
 795   /* Call the allocation method of the superclass.  */
 796   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
 797   if (entry != NULL)
 798     {
 799       struct elf_x86_64_link_hash_entry *eh;
 800
 801       eh = (struct elf_x86_64_link_hash_entry *) entry;
 802       eh->dyn_relocs = NULL;
 803       eh->tls_type = GOT_UNKNOWN;
 804       eh->tlsdesc_got = (bfd_vma) -1;
 805     }
 806
 807   return entry;
 808 }
 809
 810 /* Compute a hash of a local hash entry.  We use elf_link_hash_entry
 811   for local symbol so that we can handle local STT_GNU_IFUNC symbols
 812   as global symbol.  We reuse indx and dynstr_index for local symbol
 813   hash since they aren't used by global symbols in this backend.  */
 814
 815 static hashval_t
 816 elf_x86_64_local_htab_hash (const void *ptr)
 817 {
 818   struct elf_link_hash_entry *h
 819     = (struct elf_link_hash_entry *) ptr;
 820   return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
 821 }
 822
 823 /* Compare local hash entries.  */
 824
 825 static int
 826 elf_x86_64_local_htab_eq (const void *ptr1, const void *ptr2)
 827 {
 828   struct elf_link_hash_entry *h1
 829      = (struct elf_link_hash_entry *) ptr1;
 830   struct elf_link_hash_entry *h2
 831     = (struct elf_link_hash_entry *) ptr2;
 832
 833   return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
 834 }
 835
 836 /* Find and/or create a hash entry for local symbol.  */
 837
 838 static struct elf_link_hash_entry *
 839 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table *htab,
 840                                bfd *abfd, const Elf_Internal_Rela *rel,
 841                                bfd_boolean create)
 842 {
 843   struct elf_x86_64_link_hash_entry e, *ret;
 844   asection *sec = abfd->sections;
 845   hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
 846                                        htab->r_sym (rel->r_info));
 847   void **slot;
 848
 849   e.elf.indx = sec->id;
 850   e.elf.dynstr_index = htab->r_sym (rel->r_info);
 851   slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
 852                                    create ? INSERT : NO_INSERT);
 853
 854   if (!slot)
 855     return NULL;
 856
 857   if (*slot)
 858     {
 859       ret = (struct elf_x86_64_link_hash_entry *) *slot;
 860       return &ret->elf;
 861     }
 862
 863   ret = (struct elf_x86_64_link_hash_entry *)
 864         objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
 865                         sizeof (struct elf_x86_64_link_hash_entry));
 866   if (ret)
 867     {
 868       memset (ret, 0, sizeof (*ret));
 869       ret->elf.indx = sec->id;
 870       ret->elf.dynstr_index = htab->r_sym (rel->r_info);
 871       ret->elf.dynindx = -1;
 872       *slot = ret;
 873     }
 874   return &ret->elf;
 875 }
 876
 877 /* Create an X86-64 ELF linker hash table.  */
 878
 879 static struct bfd_link_hash_table *
 880 elf_x86_64_link_hash_table_create (bfd *abfd)
 881 {
 882   struct elf_x86_64_link_hash_table *ret;
 883   bfd_size_type amt = sizeof (struct elf_x86_64_link_hash_table);
 884
 885   ret = (struct elf_x86_64_link_hash_table *) bfd_malloc (amt);
 886   if (ret == NULL)
 887     return NULL;
 888
 889   if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
 890                                       elf_x86_64_link_hash_newfunc,
 891                                       sizeof (struct elf_x86_64_link_hash_entry),
 892                                       X86_64_ELF_DATA))
 893     {
 894       free (ret);
 895       return NULL;
 896     }
 897
 898   ret->sdynbss = NULL;
 899   ret->srelbss = NULL;
 900   ret->plt_eh_frame = NULL;
 901   ret->sym_cache.abfd = NULL;
 902   ret->tlsdesc_plt = 0;
 903   ret->tlsdesc_got = 0;
 904   ret->tls_ld_got.refcount = 0;
 905   ret->sgotplt_jump_table_size = 0;
 906   ret->tls_module_base = NULL;
 907   ret->next_jump_slot_index = 0;
 908   ret->next_irelative_index = 0;
 909
 910   if (ABI_64_P (abfd))
 911     {
 912       ret->r_info = elf64_r_info;
 913       ret->r_sym = elf64_r_sym;
 914       ret->pointer_r_type = R_X86_64_64;
 915       ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
 916       ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
 917     }
 918   else
 919     {
 920       ret->r_info = elf32_r_info;
 921       ret->r_sym = elf32_r_sym;
 922       ret->pointer_r_type = R_X86_64_32;
 923       ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
 924       ret->dynamic_interpreter_size = sizeof ELF32_DYNAMIC_INTERPRETER;
 925     }
 926
 927   ret->loc_hash_table = htab_try_create (1024,
 928                                          elf_x86_64_local_htab_hash,
 929                                          elf_x86_64_local_htab_eq,
 930                                          NULL);
 931   ret->loc_hash_memory = objalloc_create ();
 932   if (!ret->loc_hash_table || !ret->loc_hash_memory)
 933     {
 934       free (ret);
 935       return NULL;
 936     }
 937
 938   return &ret->elf.root;
 939 }
 940
 941 /* Destroy an X86-64 ELF linker hash table.  */
 942
 943 static void
 944 elf_x86_64_link_hash_table_free (struct bfd_link_hash_table *hash)
 945 {
 946   struct elf_x86_64_link_hash_table *htab
 947     = (struct elf_x86_64_link_hash_table *) hash;
 948
 949   if (htab->loc_hash_table)
 950     htab_delete (htab->loc_hash_table);
 951   if (htab->loc_hash_memory)
 952     objalloc_free ((struct objalloc *) htab->loc_hash_memory);
 953   _bfd_generic_link_hash_table_free (hash);
 954 }
 955
 956 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
 957    .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
 958    hash table.  */
 959
 960 static bfd_boolean
 961 elf_x86_64_create_dynamic_sections (bfd *dynobj,
 962                                     struct bfd_link_info *info)
 963 {
 964   struct elf_x86_64_link_hash_table *htab;
 965
 966   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
 967     return FALSE;
 968
 969   htab = elf_x86_64_hash_table (info);
 970   if (htab == NULL)
 971     return FALSE;
 972
 973   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
 974   if (!info->shared)
 975     htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
 976
 977   if (!htab->sdynbss
 978       || (!info->shared && !htab->srelbss))
 979     abort ();
 980
 981   if (!info->no_ld_generated_unwind_info
 982       && htab->plt_eh_frame == NULL
 983       && htab->elf.splt != NULL)
 984     {
 985       flagword flags = get_elf_backend_data (dynobj)->dynamic_sec_flags;
 986       htab->plt_eh_frame
 987         = bfd_make_section_anyway_with_flags (dynobj, ".eh_frame",
 988                                               (flags
 989                                                | SEC_LINKER_CREATED
 990                                                | SEC_READONLY));
 991       if (htab->plt_eh_frame == NULL
 992           || !bfd_set_section_alignment (dynobj, htab->plt_eh_frame, 3))
 993         return FALSE;
 994     }
 995   return TRUE;
 996 }
 997
 998 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
 999
1000 static void
1001 elf_x86_64_copy_indirect_symbol (struct bfd_link_info *info,
1002                                  struct elf_link_hash_entry *dir,
1003                                  struct elf_link_hash_entry *ind)
1004 {
1005   struct elf_x86_64_link_hash_entry *edir, *eind;
1006
1007   edir = (struct elf_x86_64_link_hash_entry *) dir;
1008   eind = (struct elf_x86_64_link_hash_entry *) ind;
1009
1010   if (eind->dyn_relocs != NULL)
1011     {
1012       if (edir->dyn_relocs != NULL)
1013         {
1014           struct elf_dyn_relocs **pp;
1015           struct elf_dyn_relocs *p;
1016
1017           /* Add reloc counts against the indirect sym to the direct sym
1018              list.  Merge any entries against the same section.  */
1019           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1020             {
1021               struct elf_dyn_relocs *q;
1022
1023               for (q = edir->dyn_relocs; q != NULL; q = q->next)
1024                 if (q->sec == p->sec)
1025                   {
1026                     q->pc_count += p->pc_count;
1027                     q->count += p->count;
1028                     *pp = p->next;
1029                     break;
1030                   }
1031               if (q == NULL)
1032                 pp = &p->next;
1033             }
1034           *pp = edir->dyn_relocs;
1035         }
1036
1037       edir->dyn_relocs = eind->dyn_relocs;
1038       eind->dyn_relocs = NULL;
1039     }
1040
1041   if (ind->root.type == bfd_link_hash_indirect
1042       && dir->got.refcount <= 0)
1043     {
1044       edir->tls_type = eind->tls_type;
1045       eind->tls_type = GOT_UNKNOWN;
1046     }
1047
1048   if (ELIMINATE_COPY_RELOCS
1049       && ind->root.type != bfd_link_hash_indirect
1050       && dir->dynamic_adjusted)
1051     {
1052       /* If called to transfer flags for a weakdef during processing
1053          of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1054          We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
1055       dir->ref_dynamic |= ind->ref_dynamic;
1056       dir->ref_regular |= ind->ref_regular;
1057       dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1058       dir->needs_plt |= ind->needs_plt;
1059       dir->pointer_equality_needed |= ind->pointer_equality_needed;
1060     }
1061   else
1062     _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1063 }
1064
1065 static bfd_boolean
1066 elf64_x86_64_elf_object_p (bfd *abfd)
1067 {
1068   /* Set the right machine number for an x86-64 elf64 file.  */
1069   bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64);
1070   return TRUE;
1071 }
1072
1073 static bfd_boolean
1074 elf32_x86_64_elf_object_p (bfd *abfd)
1075 {
1076   /* Set the right machine number for an x86-64 elf32 file.  */
1077   bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32);
1078   return TRUE;
1079 }
1080
1081 /* Return TRUE if the TLS access code sequence support transition
1082    from R_TYPE.  */
1083
1084 static bfd_boolean
1085 elf_x86_64_check_tls_transition (bfd *abfd,
1086                                  struct bfd_link_info *info,
1087                                  asection *sec,
1088                                  bfd_byte *contents,
1089                                  Elf_Internal_Shdr *symtab_hdr,
1090                                  struct elf_link_hash_entry **sym_hashes,
1091                                  unsigned int r_type,
1092                                  const Elf_Internal_Rela *rel,
1093                                  const Elf_Internal_Rela *relend)
1094 {
1095   unsigned int val;
1096   unsigned long r_symndx;
1097   struct elf_link_hash_entry *h;
1098   bfd_vma offset;
1099   struct elf_x86_64_link_hash_table *htab;
1100
1101   /* Get the section contents.  */
1102   if (contents == NULL)
1103     {
1104       if (elf_section_data (sec)->this_hdr.contents != NULL)
1105         contents = elf_section_data (sec)->this_hdr.contents;
1106       else
1107         {
1108           /* FIXME: How to better handle error condition?  */
1109           if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1110             return FALSE;
1111
1112           /* Cache the section contents for elf_link_input_bfd.  */
1113           elf_section_data (sec)->this_hdr.contents = contents;
1114         }
1115     }
1116
1117   htab = elf_x86_64_hash_table (info);
1118   offset = rel->r_offset;
1119   switch (r_type)
1120     {
1121     case R_X86_64_TLSGD:
1122     case R_X86_64_TLSLD:
1123       if ((rel + 1) >= relend)
1124         return FALSE;
1125
1126       if (r_type == R_X86_64_TLSGD)
1127         {
1128           /* Check transition from GD access model.  For 64bit, only
1129                 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1130                 .word 0x6666; rex64; call __tls_get_addr
1131              can transit to different access model.  For 32bit, only
1132                 leaq foo@tlsgd(%rip), %rdi
1133                 .word 0x6666; rex64; call __tls_get_addr
1134              can transit to different access model.  */
1135
1136           static const unsigned char call[] = { 0x66, 0x66, 0x48, 0xe8 };
1137           static const unsigned char leaq[] = { 0x66, 0x48, 0x8d, 0x3d };
1138
1139           if ((offset + 12) > sec->size
1140               || memcmp (contents + offset + 4, call, 4) != 0)
1141             return FALSE;
1142
1143           if (ABI_64_P (abfd))
1144             {
1145               if (offset < 4
1146                   || memcmp (contents + offset - 4, leaq, 4) != 0)
1147                 return FALSE;
1148             }
1149           else
1150             {
1151               if (offset < 3
1152                   || memcmp (contents + offset - 3, leaq + 1, 3) != 0)
1153                 return FALSE;
1154             }
1155         }
1156       else
1157         {
1158           /* Check transition from LD access model.  Only
1159                 leaq foo@tlsld(%rip), %rdi;
1160                 call __tls_get_addr
1161              can transit to different access model.  */
1162
1163           static const unsigned char lea[] = { 0x48, 0x8d, 0x3d };
1164
1165           if (offset < 3 || (offset + 9) > sec->size)
1166             return FALSE;
1167
1168           if (memcmp (contents + offset - 3, lea, 3) != 0
1169               || 0xe8 != *(contents + offset + 4))
1170             return FALSE;
1171         }
1172
1173       r_symndx = htab->r_sym (rel[1].r_info);
1174       if (r_symndx < symtab_hdr->sh_info)
1175         return FALSE;
1176
1177       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1178       /* Use strncmp to check __tls_get_addr since __tls_get_addr
1179          may be versioned.  */
1180       return (h != NULL
1181               && h->root.root.string != NULL
1182               && (ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PC32
1183                   || ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PLT32)
1184               && (strncmp (h->root.root.string,
1185                            "__tls_get_addr", 14) == 0));
1186
1187     case R_X86_64_GOTTPOFF:
1188       /* Check transition from IE access model:
1189                 mov foo@gottpoff(%rip), %reg
1190                 add foo@gottpoff(%rip), %reg
1191        */
1192
1193       /* Check REX prefix first.  */
1194       if (offset >= 3 && (offset + 4) <= sec->size)
1195         {
1196           val = bfd_get_8 (abfd, contents + offset - 3);
1197           if (val != 0x48 && val != 0x4c)
1198             {
1199               /* X32 may have 0x44 REX prefix or no REX prefix.  */
1200               if (ABI_64_P (abfd))
1201                 return FALSE;
1202             }
1203         }
1204       else
1205         {
1206           /* X32 may not have any REX prefix.  */
1207           if (ABI_64_P (abfd))
1208             return FALSE;
1209           if (offset < 2 || (offset + 3) > sec->size)
1210             return FALSE;
1211         }
1212
1213       val = bfd_get_8 (abfd, contents + offset - 2);
1214       if (val != 0x8b && val != 0x03)
1215         return FALSE;
1216
1217       val = bfd_get_8 (abfd, contents + offset - 1);
1218       return (val & 0xc7) == 5;
1219
1220     case R_X86_64_GOTPC32_TLSDESC:
1221       /* Check transition from GDesc access model:
1222                 leaq x@tlsdesc(%rip), %rax
1223
1224          Make sure it's a leaq adding rip to a 32-bit offset
1225          into any register, although it's probably almost always
1226          going to be rax.  */
1227
1228       if (offset < 3 || (offset + 4) > sec->size)
1229         return FALSE;
1230
1231       val = bfd_get_8 (abfd, contents + offset - 3);
1232       if ((val & 0xfb) != 0x48)
1233         return FALSE;
1234
1235       if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1236         return FALSE;
1237
1238       val = bfd_get_8 (abfd, contents + offset - 1);
1239       return (val & 0xc7) == 0x05;
1240
1241     case R_X86_64_TLSDESC_CALL:
1242       /* Check transition from GDesc access model:
1243                 call *x@tlsdesc(%rax)
1244        */
1245       if (offset + 2 <= sec->size)
1246         {
1247           /* Make sure that it's a call *x@tlsdesc(%rax).  */
1248           static const unsigned char call[] = { 0xff, 0x10 };
1249           return memcmp (contents + offset, call, 2) == 0;
1250         }
1251
1252       return FALSE;
1253
1254     default:
1255       abort ();
1256     }
1257 }
1258
1259 /* Return TRUE if the TLS access transition is OK or no transition
1260    will be performed.  Update R_TYPE if there is a transition.  */
1261
1262 static bfd_boolean
1263 elf_x86_64_tls_transition (struct bfd_link_info *info, bfd *abfd,
1264                            asection *sec, bfd_byte *contents,
1265                            Elf_Internal_Shdr *symtab_hdr,
1266                            struct elf_link_hash_entry **sym_hashes,
1267                            unsigned int *r_type, int tls_type,
1268                            const Elf_Internal_Rela *rel,
1269                            const Elf_Internal_Rela *relend,
1270                            struct elf_link_hash_entry *h,
1271                            unsigned long r_symndx)
1272 {
1273   unsigned int from_type = *r_type;
1274   unsigned int to_type = from_type;
1275   bfd_boolean check = TRUE;
1276
1277   /* Skip TLS transition for functions.  */
1278   if (h != NULL
1279       && (h->type == STT_FUNC
1280           || h->type == STT_GNU_IFUNC))
1281     return TRUE;
1282
1283   switch (from_type)
1284     {
1285     case R_X86_64_TLSGD:
1286     case R_X86_64_GOTPC32_TLSDESC:
1287     case R_X86_64_TLSDESC_CALL:
1288     case R_X86_64_GOTTPOFF:
1289       if (info->executable)
1290         {
1291           if (h == NULL)
1292             to_type = R_X86_64_TPOFF32;
1293           else
1294             to_type = R_X86_64_GOTTPOFF;
1295         }
1296
1297       /* When we are called from elf_x86_64_relocate_section,
1298          CONTENTS isn't NULL and there may be additional transitions
1299          based on TLS_TYPE.  */
1300       if (contents != NULL)
1301         {
1302           unsigned int new_to_type = to_type;
1303
1304           if (info->executable
1305               && h != NULL
1306               && h->dynindx == -1
1307               && tls_type == GOT_TLS_IE)
1308             new_to_type = R_X86_64_TPOFF32;
1309
1310           if (to_type == R_X86_64_TLSGD
1311               || to_type == R_X86_64_GOTPC32_TLSDESC
1312               || to_type == R_X86_64_TLSDESC_CALL)
1313             {
1314               if (tls_type == GOT_TLS_IE)
1315                 new_to_type = R_X86_64_GOTTPOFF;
1316             }
1317
1318           /* We checked the transition before when we were called from
1319              elf_x86_64_check_relocs.  We only want to check the new
1320              transition which hasn't been checked before.  */
1321           check = new_to_type != to_type && from_type == to_type;
1322           to_type = new_to_type;
1323         }
1324
1325       break;
1326
1327     case R_X86_64_TLSLD:
1328       if (info->executable)
1329         to_type = R_X86_64_TPOFF32;
1330       break;
1331
1332     default:
1333       return TRUE;
1334     }
1335
1336   /* Return TRUE if there is no transition.  */
1337   if (from_type == to_type)
1338     return TRUE;
1339
1340   /* Check if the transition can be performed.  */
1341   if (check
1342       && ! elf_x86_64_check_tls_transition (abfd, info, sec, contents,
1343                                             symtab_hdr, sym_hashes,
1344                                             from_type, rel, relend))
1345     {
1346       reloc_howto_type *from, *to;
1347       const char *name;
1348
1349       from = elf_x86_64_rtype_to_howto (abfd, from_type);
1350       to = elf_x86_64_rtype_to_howto (abfd, to_type);
1351
1352       if (h)
1353         name = h->root.root.string;
1354       else
1355         {
1356           struct elf_x86_64_link_hash_table *htab;
1357
1358           htab = elf_x86_64_hash_table (info);
1359           if (htab == NULL)
1360             name = "*unknown*";
1361           else
1362             {
1363               Elf_Internal_Sym *isym;
1364
1365               isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1366                                             abfd, r_symndx);
1367               name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1368             }
1369         }
1370
1371       (*_bfd_error_handler)
1372         (_("%B: TLS transition from %s to %s against `%s' at 0x%lx "
1373            "in section `%A' failed"),
1374          abfd, sec, from->name, to->name, name,
1375          (unsigned long) rel->r_offset);
1376       bfd_set_error (bfd_error_bad_value);
1377       return FALSE;
1378     }
1379
1380   *r_type = to_type;
1381   return TRUE;
1382 }
1383
1384 /* Look through the relocs for a section during the first phase, and
1385    calculate needed space in the global offset table, procedure
1386    linkage table, and dynamic reloc sections.  */
1387
1388 static bfd_boolean
1389 elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info,
1390                          asection *sec,
1391                          const Elf_Internal_Rela *relocs)
1392 {
1393   struct elf_x86_64_link_hash_table *htab;
1394   Elf_Internal_Shdr *symtab_hdr;
1395   struct elf_link_hash_entry **sym_hashes;
1396   const Elf_Internal_Rela *rel;
1397   const Elf_Internal_Rela *rel_end;
1398   asection *sreloc;
1399
1400   if (info->relocatable)
1401     return TRUE;
1402
1403   BFD_ASSERT (is_x86_64_elf (abfd));
1404
1405   htab = elf_x86_64_hash_table (info);
1406   if (htab == NULL)
1407     return FALSE;
1408
1409   symtab_hdr = &elf_symtab_hdr (abfd);
1410   sym_hashes = elf_sym_hashes (abfd);
1411
1412   sreloc = NULL;
1413
1414   rel_end = relocs + sec->reloc_count;
1415   for (rel = relocs; rel < rel_end; rel++)
1416     {
1417       unsigned int r_type;
1418       unsigned long r_symndx;
1419       struct elf_link_hash_entry *h;
1420       Elf_Internal_Sym *isym;
1421       const char *name;
1422
1423       r_symndx = htab->r_sym (rel->r_info);
1424       r_type = ELF32_R_TYPE (rel->r_info);
1425
1426       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1427         {
1428           (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1429                                  abfd, r_symndx);
1430           return FALSE;
1431         }
1432
1433       if (r_symndx < symtab_hdr->sh_info)
1434         {
1435           /* A local symbol.  */
1436           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1437                                         abfd, r_symndx);
1438           if (isym == NULL)
1439             return FALSE;
1440
1441           /* Check relocation against local STT_GNU_IFUNC symbol.  */
1442           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1443             {
1444               h = elf_x86_64_get_local_sym_hash (htab, abfd, rel,
1445                                                  TRUE);
1446               if (h == NULL)
1447                 return FALSE;
1448
1449               /* Fake a STT_GNU_IFUNC symbol.  */
1450               h->type = STT_GNU_IFUNC;
1451               h->def_regular = 1;
1452               h->ref_regular = 1;
1453               h->forced_local = 1;
1454               h->root.type = bfd_link_hash_defined;
1455             }
1456           else
1457             h = NULL;
1458         }
1459       else
1460         {
1461           isym = NULL;
1462           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1463           while (h->root.type == bfd_link_hash_indirect
1464                  || h->root.type == bfd_link_hash_warning)
1465             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1466         }
1467
1468       /* Check invalid x32 relocations.  */
1469       if (!ABI_64_P (abfd))
1470         switch (r_type)
1471           {
1472           default:
1473             break;
1474
1475           case R_X86_64_DTPOFF64:
1476           case R_X86_64_TPOFF64:
1477           case R_X86_64_PC64:
1478           case R_X86_64_GOTOFF64:
1479           case R_X86_64_GOT64:
1480           case R_X86_64_GOTPCREL64:
1481           case R_X86_64_GOTPC64:
1482           case R_X86_64_GOTPLT64:
1483           case R_X86_64_PLTOFF64:
1484               {
1485                 if (h)
1486                   name = h->root.root.string;
1487                 else
1488                   name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1489                                            NULL);
1490                 (*_bfd_error_handler)
1491                   (_("%B: relocation %s against symbol `%s' isn't "
1492                      "supported in x32 mode"), abfd,
1493                    x86_64_elf_howto_table[r_type].name, name);
1494                 bfd_set_error (bfd_error_bad_value);
1495                 return FALSE;
1496               }
1497             break;
1498           }
1499
1500       if (h != NULL)
1501         {
1502           /* Create the ifunc sections for static executables.  If we
1503              never see an indirect function symbol nor we are building
1504              a static executable, those sections will be empty and
1505              won't appear in output.  */
1506           switch (r_type)
1507             {
1508             default:
1509               break;
1510
1511             case R_X86_64_32S:
1512             case R_X86_64_32:
1513             case R_X86_64_64:
1514             case R_X86_64_PC32:
1515             case R_X86_64_PC64:
1516             case R_X86_64_PLT32:
1517             case R_X86_64_GOTPCREL:
1518             case R_X86_64_GOTPCREL64:
1519               if (htab->elf.dynobj == NULL)
1520                 htab->elf.dynobj = abfd;
1521               if (!_bfd_elf_create_ifunc_sections (htab->elf.dynobj, info))
1522                 return FALSE;
1523               break;
1524             }
1525
1526           /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
1527              it here if it is defined in a non-shared object.  */
1528           if (h->type == STT_GNU_IFUNC
1529               && h->def_regular)
1530             {
1531               /* It is referenced by a non-shared object. */
1532               h->ref_regular = 1;
1533               h->needs_plt = 1;
1534
1535               /* STT_GNU_IFUNC symbol must go through PLT.  */
1536               h->plt.refcount += 1;
1537
1538               /* STT_GNU_IFUNC needs dynamic sections.  */
1539               if (htab->elf.dynobj == NULL)
1540                 htab->elf.dynobj = abfd;
1541
1542               switch (r_type)
1543                 {
1544                 default:
1545                   if (h->root.root.string)
1546                     name = h->root.root.string;
1547                   else
1548                     name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1549                                              NULL);
1550                   (*_bfd_error_handler)
1551                     (_("%B: relocation %s against STT_GNU_IFUNC "
1552                        "symbol `%s' isn't handled by %s"), abfd,
1553                      x86_64_elf_howto_table[r_type].name,
1554                      name, __FUNCTION__);
1555                   bfd_set_error (bfd_error_bad_value);
1556                   return FALSE;
1557
1558                 case R_X86_64_32:
1559                   if (ABI_64_P (abfd))
1560                     goto not_pointer;
1561                 case R_X86_64_64:
1562                   h->non_got_ref = 1;
1563                   h->pointer_equality_needed = 1;
1564                   if (info->shared)
1565                     {
1566                       /* We must copy these reloc types into the output
1567                          file.  Create a reloc section in dynobj and
1568                          make room for this reloc.  */
1569                       sreloc = _bfd_elf_create_ifunc_dyn_reloc
1570                         (abfd, info, sec, sreloc,
1571                          &((struct elf_x86_64_link_hash_entry *) h)->dyn_relocs);
1572                       if (sreloc == NULL)
1573                         return FALSE;
1574                     }
1575                   break;
1576
1577                 case R_X86_64_32S:
1578                 case R_X86_64_PC32:
1579                 case R_X86_64_PC64:
1580 not_pointer:
1581                   h->non_got_ref = 1;
1582                   if (r_type != R_X86_64_PC32
1583                       && r_type != R_X86_64_PC64)
1584                     h->pointer_equality_needed = 1;
1585                   break;
1586
1587                 case R_X86_64_PLT32:
1588                   break;
1589
1590                 case R_X86_64_GOTPCREL:
1591                 case R_X86_64_GOTPCREL64:
1592                   h->got.refcount += 1;
1593                   if (htab->elf.sgot == NULL
1594                       && !_bfd_elf_create_got_section (htab->elf.dynobj,
1595                                                        info))
1596                     return FALSE;
1597                   break;
1598                 }
1599
1600               continue;
1601             }
1602         }
1603
1604       if (! elf_x86_64_tls_transition (info, abfd, sec, NULL,
1605                                        symtab_hdr, sym_hashes,
1606                                        &r_type, GOT_UNKNOWN,
1607                                        rel, rel_end, h, r_symndx))
1608         return FALSE;
1609
1610       switch (r_type)
1611         {
1612         case R_X86_64_TLSLD:
1613           htab->tls_ld_got.refcount += 1;
1614           goto create_got;
1615
1616         case R_X86_64_TPOFF32:
1617           if (!info->executable && ABI_64_P (abfd))
1618             {
1619               if (h)
1620                 name = h->root.root.string;
1621               else
1622                 name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
1623                                          NULL);
1624               (*_bfd_error_handler)
1625                 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1626                  abfd,
1627                  x86_64_elf_howto_table[r_type].name, name);
1628               bfd_set_error (bfd_error_bad_value);
1629               return FALSE;
1630             }
1631           break;
1632
1633         case R_X86_64_GOTTPOFF:
1634           if (!info->executable)
1635             info->flags |= DF_STATIC_TLS;
1636           /* Fall through */
1637
1638         case R_X86_64_GOT32:
1639         case R_X86_64_GOTPCREL:
1640         case R_X86_64_TLSGD:
1641         case R_X86_64_GOT64:
1642         case R_X86_64_GOTPCREL64:
1643         case R_X86_64_GOTPLT64:
1644         case R_X86_64_GOTPC32_TLSDESC:
1645         case R_X86_64_TLSDESC_CALL:
1646           /* This symbol requires a global offset table entry.  */
1647           {
1648             int tls_type, old_tls_type;
1649
1650             switch (r_type)
1651               {
1652               default: tls_type = GOT_NORMAL; break;
1653               case R_X86_64_TLSGD: tls_type = GOT_TLS_GD; break;
1654               case R_X86_64_GOTTPOFF: tls_type = GOT_TLS_IE; break;
1655               case R_X86_64_GOTPC32_TLSDESC:
1656               case R_X86_64_TLSDESC_CALL:
1657                 tls_type = GOT_TLS_GDESC; break;
1658               }
1659
1660             if (h != NULL)
1661               {
1662                 if (r_type == R_X86_64_GOTPLT64)
1663                   {
1664                     /* This relocation indicates that we also need
1665                        a PLT entry, as this is a function.  We don't need
1666                        a PLT entry for local symbols.  */
1667                     h->needs_plt = 1;
1668                     h->plt.refcount += 1;
1669                   }
1670                 h->got.refcount += 1;
1671                 old_tls_type = elf_x86_64_hash_entry (h)->tls_type;
1672               }
1673             else
1674               {
1675                 bfd_signed_vma *local_got_refcounts;
1676
1677                 /* This is a global offset table entry for a local symbol.  */
1678                 local_got_refcounts = elf_local_got_refcounts (abfd);
1679                 if (local_got_refcounts == NULL)
1680                   {
1681                     bfd_size_type size;
1682
1683                     size = symtab_hdr->sh_info;
1684                     size *= sizeof (bfd_signed_vma)
1685                       + sizeof (bfd_vma) + sizeof (char);
1686                     local_got_refcounts = ((bfd_signed_vma *)
1687                                            bfd_zalloc (abfd, size));
1688                     if (local_got_refcounts == NULL)
1689                       return FALSE;
1690                     elf_local_got_refcounts (abfd) = local_got_refcounts;
1691                     elf_x86_64_local_tlsdesc_gotent (abfd)
1692                       = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
1693                     elf_x86_64_local_got_tls_type (abfd)
1694                       = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
1695                   }
1696                 local_got_refcounts[r_symndx] += 1;
1697                 old_tls_type
1698                   = elf_x86_64_local_got_tls_type (abfd) [r_symndx];
1699               }
1700
1701             /* If a TLS symbol is accessed using IE at least once,
1702                there is no point to use dynamic model for it.  */
1703             if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
1704                 && (! GOT_TLS_GD_ANY_P (old_tls_type)
1705                     || tls_type != GOT_TLS_IE))
1706               {
1707                 if (old_tls_type == GOT_TLS_IE && GOT_TLS_GD_ANY_P (tls_type))
1708                   tls_type = old_tls_type;
1709                 else if (GOT_TLS_GD_ANY_P (old_tls_type)
1710                          && GOT_TLS_GD_ANY_P (tls_type))
1711                   tls_type |= old_tls_type;
1712                 else
1713                   {
1714                     if (h)
1715                       name = h->root.root.string;
1716                     else
1717                       name = bfd_elf_sym_name (abfd, symtab_hdr,
1718                                                isym, NULL);
1719                     (*_bfd_error_handler)
1720                       (_("%B: '%s' accessed both as normal and thread local symbol"),
1721                        abfd, name);
1722                     return FALSE;
1723                   }
1724               }
1725
1726             if (old_tls_type != tls_type)
1727               {
1728                 if (h != NULL)
1729                   elf_x86_64_hash_entry (h)->tls_type = tls_type;
1730                 else
1731                   elf_x86_64_local_got_tls_type (abfd) [r_symndx] = tls_type;
1732               }
1733           }
1734           /* Fall through */
1735
1736         case R_X86_64_GOTOFF64:
1737         case R_X86_64_GOTPC32:
1738         case R_X86_64_GOTPC64:
1739         create_got:
1740           if (htab->elf.sgot == NULL)
1741             {
1742               if (htab->elf.dynobj == NULL)
1743                 htab->elf.dynobj = abfd;
1744               if (!_bfd_elf_create_got_section (htab->elf.dynobj,
1745                                                 info))
1746                 return FALSE;
1747             }
1748           break;
1749
1750         case R_X86_64_PLT32:
1751           /* This symbol requires a procedure linkage table entry.  We
1752              actually build the entry in adjust_dynamic_symbol,
1753              because this might be a case of linking PIC code which is
1754              never referenced by a dynamic object, in which case we
1755              don't need to generate a procedure linkage table entry
1756              after all.  */
1757
1758           /* If this is a local symbol, we resolve it directly without
1759              creating a procedure linkage table entry.  */
1760           if (h == NULL)
1761             continue;
1762
1763           h->needs_plt = 1;
1764           h->plt.refcount += 1;
1765           break;
1766
1767         case R_X86_64_PLTOFF64:
1768           /* This tries to form the 'address' of a function relative
1769              to GOT.  For global symbols we need a PLT entry.  */
1770           if (h != NULL)
1771             {
1772               h->needs_plt = 1;
1773               h->plt.refcount += 1;
1774             }
1775           goto create_got;
1776
1777         case R_X86_64_32:
1778           if (!ABI_64_P (abfd))
1779             goto pointer;
1780         case R_X86_64_8:
1781         case R_X86_64_16:
1782         case R_X86_64_32S:
1783           /* Let's help debug shared library creation.  These relocs
1784              cannot be used in shared libs.  Don't error out for
1785              sections we don't care about, such as debug sections or
1786              non-constant sections.  */
1787           if (info->shared
1788               && (sec->flags & SEC_ALLOC) != 0
1789               && (sec->flags & SEC_READONLY) != 0)
1790             {
1791               if (h)
1792                 name = h->root.root.string;
1793               else
1794                 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1795               (*_bfd_error_handler)
1796                 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1797                  abfd, x86_64_elf_howto_table[r_type].name, name);
1798               bfd_set_error (bfd_error_bad_value);
1799               return FALSE;
1800             }
1801           /* Fall through.  */
1802
1803         case R_X86_64_PC8:
1804         case R_X86_64_PC16:
1805         case R_X86_64_PC32:
1806         case R_X86_64_PC64:
1807         case R_X86_64_64:
1808 pointer:
1809           if (h != NULL && info->executable)
1810             {
1811               /* If this reloc is in a read-only section, we might
1812                  need a copy reloc.  We can't check reliably at this
1813                  stage whether the section is read-only, as input
1814                  sections have not yet been mapped to output sections.
1815                  Tentatively set the flag for now, and correct in
1816                  adjust_dynamic_symbol.  */
1817               h->non_got_ref = 1;
1818
1819               /* We may need a .plt entry if the function this reloc
1820                  refers to is in a shared lib.  */
1821               h->plt.refcount += 1;
1822               if (r_type != R_X86_64_PC32 && r_type != R_X86_64_PC64)
1823                 h->pointer_equality_needed = 1;
1824             }
1825
1826           /* If we are creating a shared library, and this is a reloc
1827              against a global symbol, or a non PC relative reloc
1828              against a local symbol, then we need to copy the reloc
1829              into the shared library.  However, if we are linking with
1830              -Bsymbolic, we do not need to copy a reloc against a
1831              global symbol which is defined in an object we are
1832              including in the link (i.e., DEF_REGULAR is set).  At
1833              this point we have not seen all the input files, so it is
1834              possible that DEF_REGULAR is not set now but will be set
1835              later (it is never cleared).  In case of a weak definition,
1836              DEF_REGULAR may be cleared later by a strong definition in
1837              a shared library.  We account for that possibility below by
1838              storing information in the relocs_copied field of the hash
1839              table entry.  A similar situation occurs when creating
1840              shared libraries and symbol visibility changes render the
1841              symbol local.
1842
1843              If on the other hand, we are creating an executable, we
1844              may need to keep relocations for symbols satisfied by a
1845              dynamic library if we manage to avoid copy relocs for the
1846              symbol.  */
1847           if ((info->shared
1848                && (sec->flags & SEC_ALLOC) != 0
1849                && (! IS_X86_64_PCREL_TYPE (r_type)
1850                    || (h != NULL
1851                        && (! SYMBOLIC_BIND (info, h)
1852                            || h->root.type == bfd_link_hash_defweak
1853                            || !h->def_regular))))
1854               || (ELIMINATE_COPY_RELOCS
1855                   && !info->shared
1856                   && (sec->flags & SEC_ALLOC) != 0
1857                   && h != NULL
1858                   && (h->root.type == bfd_link_hash_defweak
1859                       || !h->def_regular)))
1860             {
1861               struct elf_dyn_relocs *p;
1862               struct elf_dyn_relocs **head;
1863
1864               /* We must copy these reloc types into the output file.
1865                  Create a reloc section in dynobj and make room for
1866                  this reloc.  */
1867               if (sreloc == NULL)
1868                 {
1869                   if (htab->elf.dynobj == NULL)
1870                     htab->elf.dynobj = abfd;
1871
1872                   sreloc = _bfd_elf_make_dynamic_reloc_section
1873                     (sec, htab->elf.dynobj, ABI_64_P (abfd) ? 3 : 2,
1874                      abfd, /*rela?*/ TRUE);
1875
1876                   if (sreloc == NULL)
1877                     return FALSE;
1878                 }
1879
1880               /* If this is a global symbol, we count the number of
1881                  relocations we need for this symbol.  */
1882               if (h != NULL)
1883                 {
1884                   head = &((struct elf_x86_64_link_hash_entry *) h)->dyn_relocs;
1885                 }
1886               else
1887                 {
1888                   /* Track dynamic relocs needed for local syms too.
1889                      We really need local syms available to do this
1890                      easily.  Oh well.  */
1891                   asection *s;
1892                   void **vpp;
1893
1894                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1895                                                 abfd, r_symndx);
1896                   if (isym == NULL)
1897                     return FALSE;
1898
1899                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1900                   if (s == NULL)
1901                     s = sec;
1902
1903                   /* Beware of type punned pointers vs strict aliasing
1904                      rules.  */
1905                   vpp = &(elf_section_data (s)->local_dynrel);
1906                   head = (struct elf_dyn_relocs **)vpp;
1907                 }
1908
1909               p = *head;
1910               if (p == NULL || p->sec != sec)
1911                 {
1912                   bfd_size_type amt = sizeof *p;
1913
1914                   p = ((struct elf_dyn_relocs *)
1915                        bfd_alloc (htab->elf.dynobj, amt));
1916                   if (p == NULL)
1917                     return FALSE;
1918                   p->next = *head;
1919                   *head = p;
1920                   p->sec = sec;
1921                   p->count = 0;
1922                   p->pc_count = 0;
1923                 }
1924
1925               p->count += 1;
1926               if (IS_X86_64_PCREL_TYPE (r_type))
1927                 p->pc_count += 1;
1928             }
1929           break;
1930
1931           /* This relocation describes the C++ object vtable hierarchy.
1932              Reconstruct it for later use during GC.  */
1933         case R_X86_64_GNU_VTINHERIT:
1934           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1935             return FALSE;
1936           break;
1937
1938           /* This relocation describes which C++ vtable entries are actually
1939              used.  Record for later use during GC.  */
1940         case R_X86_64_GNU_VTENTRY:
1941           BFD_ASSERT (h != NULL);
1942           if (h != NULL
1943               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1944             return FALSE;
1945           break;
1946
1947         default:
1948           break;
1949         }
1950     }
1951
1952   return TRUE;
1953 }
1954
1955 /* Return the section that should be marked against GC for a given
1956    relocation.  */
1957
1958 static asection *
1959 elf_x86_64_gc_mark_hook (asection *sec,
1960                          struct bfd_link_info *info,
1961                          Elf_Internal_Rela *rel,
1962                          struct elf_link_hash_entry *h,
1963                          Elf_Internal_Sym *sym)
1964 {
1965   if (h != NULL)
1966     switch (ELF32_R_TYPE (rel->r_info))
1967       {
1968       case R_X86_64_GNU_VTINHERIT:
1969       case R_X86_64_GNU_VTENTRY:
1970         return NULL;
1971       }
1972
1973   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1974 }
1975
1976 /* Update the got entry reference counts for the section being removed.  */
1977
1978 static bfd_boolean
1979 elf_x86_64_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1980                           asection *sec,
1981                           const Elf_Internal_Rela *relocs)
1982 {
1983   struct elf_x86_64_link_hash_table *htab;
1984   Elf_Internal_Shdr *symtab_hdr;
1985   struct elf_link_hash_entry **sym_hashes;
1986   bfd_signed_vma *local_got_refcounts;
1987   const Elf_Internal_Rela *rel, *relend;
1988
1989   if (info->relocatable)
1990     return TRUE;
1991
1992   htab = elf_x86_64_hash_table (info);
1993   if (htab == NULL)
1994     return FALSE;
1995
1996   elf_section_data (sec)->local_dynrel = NULL;
1997
1998   symtab_hdr = &elf_symtab_hdr (abfd);
1999   sym_hashes = elf_sym_hashes (abfd);
2000   local_got_refcounts = elf_local_got_refcounts (abfd);
2001
2002   htab = elf_x86_64_hash_table (info);
2003   relend = relocs + sec->reloc_count;
2004   for (rel = relocs; rel < relend; rel++)
2005     {
2006       unsigned long r_symndx;
2007       unsigned int r_type;
2008       struct elf_link_hash_entry *h = NULL;
2009
2010       r_symndx = htab->r_sym (rel->r_info);
2011       if (r_symndx >= symtab_hdr->sh_info)
2012         {
2013           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2014           while (h->root.type == bfd_link_hash_indirect
2015                  || h->root.type == bfd_link_hash_warning)
2016             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2017         }
2018       else
2019         {
2020           /* A local symbol.  */
2021           Elf_Internal_Sym *isym;
2022
2023           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2024                                         abfd, r_symndx);
2025
2026           /* Check relocation against local STT_GNU_IFUNC symbol.  */
2027           if (isym != NULL
2028               && ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
2029             {
2030               h = elf_x86_64_get_local_sym_hash (htab, abfd, rel, FALSE);
2031               if (h == NULL)
2032                 abort ();
2033             }
2034         }
2035
2036       if (h)
2037         {
2038           struct elf_x86_64_link_hash_entry *eh;
2039           struct elf_dyn_relocs **pp;
2040           struct elf_dyn_relocs *p;
2041
2042           eh = (struct elf_x86_64_link_hash_entry *) h;
2043
2044           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
2045             if (p->sec == sec)
2046               {
2047                 /* Everything must go for SEC.  */
2048                 *pp = p->next;
2049                 break;
2050               }
2051         }
2052
2053       r_type = ELF32_R_TYPE (rel->r_info);
2054       if (! elf_x86_64_tls_transition (info, abfd, sec, NULL,
2055                                        symtab_hdr, sym_hashes,
2056                                        &r_type, GOT_UNKNOWN,
2057                                        rel, relend, h, r_symndx))
2058         return FALSE;
2059
2060       switch (r_type)
2061         {
2062         case R_X86_64_TLSLD:
2063           if (htab->tls_ld_got.refcount > 0)
2064             htab->tls_ld_got.refcount -= 1;
2065           break;
2066
2067         case R_X86_64_TLSGD:
2068         case R_X86_64_GOTPC32_TLSDESC:
2069         case R_X86_64_TLSDESC_CALL:
2070         case R_X86_64_GOTTPOFF:
2071         case R_X86_64_GOT32:
2072         case R_X86_64_GOTPCREL:
2073         case R_X86_64_GOT64:
2074         case R_X86_64_GOTPCREL64:
2075         case R_X86_64_GOTPLT64:
2076           if (h != NULL)
2077             {
2078               if (r_type == R_X86_64_GOTPLT64 && h->plt.refcount > 0)
2079                 h->plt.refcount -= 1;
2080               if (h->got.refcount > 0)
2081                 h->got.refcount -= 1;
2082               if (h->type == STT_GNU_IFUNC)
2083                 {
2084                   if (h->plt.refcount > 0)
2085                     h->plt.refcount -= 1;
2086                 }
2087             }
2088           else if (local_got_refcounts != NULL)
2089             {
2090               if (local_got_refcounts[r_symndx] > 0)
2091                 local_got_refcounts[r_symndx] -= 1;
2092             }
2093           break;
2094
2095         case R_X86_64_8:
2096         case R_X86_64_16:
2097         case R_X86_64_32:
2098         case R_X86_64_64:
2099         case R_X86_64_32S:
2100         case R_X86_64_PC8:
2101         case R_X86_64_PC16:
2102         case R_X86_64_PC32:
2103         case R_X86_64_PC64:
2104           if (info->shared
2105               && (h == NULL || h->type != STT_GNU_IFUNC))
2106             break;
2107           /* Fall thru */
2108
2109         case R_X86_64_PLT32:
2110         case R_X86_64_PLTOFF64:
2111           if (h != NULL)
2112             {
2113               if (h->plt.refcount > 0)
2114                 h->plt.refcount -= 1;
2115             }
2116           break;
2117
2118         default:
2119           break;
2120         }
2121     }
2122
2123   return TRUE;
2124 }
2125
2126 /* Adjust a symbol defined by a dynamic object and referenced by a
2127    regular object.  The current definition is in some section of the
2128    dynamic object, but we're not including those sections.  We have to
2129    change the definition to something the rest of the link can
2130    understand.  */
2131
2132 static bfd_boolean
2133 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info *info,
2134                                   struct elf_link_hash_entry *h)
2135 {
2136   struct elf_x86_64_link_hash_table *htab;
2137   asection *s;
2138
2139   /* STT_GNU_IFUNC symbol must go through PLT. */
2140   if (h->type == STT_GNU_IFUNC)
2141     {
2142       if (h->plt.refcount <= 0)
2143         {
2144           h->plt.offset = (bfd_vma) -1;
2145           h->needs_plt = 0;
2146         }
2147       return TRUE;
2148     }
2149
2150   /* If this is a function, put it in the procedure linkage table.  We
2151      will fill in the contents of the procedure linkage table later,
2152      when we know the address of the .got section.  */
2153   if (h->type == STT_FUNC
2154       || h->needs_plt)
2155     {
2156       if (h->plt.refcount <= 0
2157           || SYMBOL_CALLS_LOCAL (info, h)
2158           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
2159               && h->root.type == bfd_link_hash_undefweak))
2160         {
2161           /* This case can occur if we saw a PLT32 reloc in an input
2162              file, but the symbol was never referred to by a dynamic
2163              object, or if all references were garbage collected.  In
2164              such a case, we don't actually need to build a procedure
2165              linkage table, and we can just do a PC32 reloc instead.  */
2166           h->plt.offset = (bfd_vma) -1;
2167           h->needs_plt = 0;
2168         }
2169
2170       return TRUE;
2171     }
2172   else
2173     /* It's possible that we incorrectly decided a .plt reloc was
2174        needed for an R_X86_64_PC32 reloc to a non-function sym in
2175        check_relocs.  We can't decide accurately between function and
2176        non-function syms in check-relocs;  Objects loaded later in
2177        the link may change h->type.  So fix it now.  */
2178     h->plt.offset = (bfd_vma) -1;
2179
2180   /* If this is a weak symbol, and there is a real definition, the
2181      processor independent code will have arranged for us to see the
2182      real definition first, and we can just use the same value.  */
2183   if (h->u.weakdef != NULL)
2184     {
2185       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2186                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
2187       h->root.u.def.section = h->u.weakdef->root.u.def.section;
2188       h->root.u.def.value = h->u.weakdef->root.u.def.value;
2189       if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
2190         h->non_got_ref = h->u.weakdef->non_got_ref;
2191       return TRUE;
2192     }
2193
2194   /* This is a reference to a symbol defined by a dynamic object which
2195      is not a function.  */
2196
2197   /* If we are creating a shared library, we must presume that the
2198      only references to the symbol are via the global offset table.
2199      For such cases we need not do anything here; the relocations will
2200      be handled correctly by relocate_section.  */
2201   if (info->shared)
2202     return TRUE;
2203
2204   /* If there are no references to this symbol that do not use the
2205      GOT, we don't need to generate a copy reloc.  */
2206   if (!h->non_got_ref)
2207     return TRUE;
2208
2209   /* If -z nocopyreloc was given, we won't generate them either.  */
2210   if (info->nocopyreloc)
2211     {
2212       h->non_got_ref = 0;
2213       return TRUE;
2214     }
2215
2216   if (ELIMINATE_COPY_RELOCS)
2217     {
2218       struct elf_x86_64_link_hash_entry * eh;
2219       struct elf_dyn_relocs *p;
2220
2221       eh = (struct elf_x86_64_link_hash_entry *) h;
2222       for (p = eh->dyn_relocs; p != NULL; p = p->next)
2223         {
2224           s = p->sec->output_section;
2225           if (s != NULL && (s->flags & SEC_READONLY) != 0)
2226             break;
2227         }
2228
2229       /* If we didn't find any dynamic relocs in read-only sections, then
2230          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
2231       if (p == NULL)
2232         {
2233           h->non_got_ref = 0;
2234           return TRUE;
2235         }
2236     }
2237
2238   /* We must allocate the symbol in our .dynbss section, which will
2239      become part of the .bss section of the executable.  There will be
2240      an entry for this symbol in the .dynsym section.  The dynamic
2241      object will contain position independent code, so all references
2242      from the dynamic object to this symbol will go through the global
2243      offset table.  The dynamic linker will use the .dynsym entry to
2244      determine the address it must put in the global offset table, so
2245      both the dynamic object and the regular object will refer to the
2246      same memory location for the variable.  */
2247
2248   htab = elf_x86_64_hash_table (info);
2249   if (htab == NULL)
2250     return FALSE;
2251
2252   /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
2253      to copy the initial value out of the dynamic object and into the
2254      runtime process image.  */
2255   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
2256     {
2257       const struct elf_backend_data *bed;
2258       bed = get_elf_backend_data (info->output_bfd);
2259       htab->srelbss->size += bed->s->sizeof_rela;
2260       h->needs_copy = 1;
2261     }
2262
2263   s = htab->sdynbss;
2264
2265   return _bfd_elf_adjust_dynamic_copy (h, s);
2266 }
2267
2268 /* Allocate space in .plt, .got and associated reloc sections for
2269    dynamic relocs.  */
2270
2271 static bfd_boolean
2272 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2273 {
2274   struct bfd_link_info *info;
2275   struct elf_x86_64_link_hash_table *htab;
2276   struct elf_x86_64_link_hash_entry *eh;
2277   struct elf_dyn_relocs *p;
2278   const struct elf_backend_data *bed;
2279   unsigned int plt_entry_size;
2280
2281   if (h->root.type == bfd_link_hash_indirect)
2282     return TRUE;
2283
2284   eh = (struct elf_x86_64_link_hash_entry *) h;
2285
2286   info = (struct bfd_link_info *) inf;
2287   htab = elf_x86_64_hash_table (info);
2288   if (htab == NULL)
2289     return FALSE;
2290   bed = get_elf_backend_data (info->output_bfd);
2291   plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
2292
2293   /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
2294      here if it is defined and referenced in a non-shared object.  */
2295   if (h->type == STT_GNU_IFUNC
2296       && h->def_regular)
2297     return _bfd_elf_allocate_ifunc_dyn_relocs (info, h,
2298                                                &eh->dyn_relocs,
2299                                                plt_entry_size,
2300                                                GOT_ENTRY_SIZE);
2301   else if (htab->elf.dynamic_sections_created
2302            && h->plt.refcount > 0)
2303     {
2304       /* Make sure this symbol is output as a dynamic symbol.
2305          Undefined weak syms won't yet be marked as dynamic.  */
2306       if (h->dynindx == -1
2307           && !h->forced_local)
2308         {
2309           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2310             return FALSE;
2311         }
2312
2313       if (info->shared
2314           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
2315         {
2316           asection *s = htab->elf.splt;
2317
2318           /* If this is the first .plt entry, make room for the special
2319              first entry.  */
2320           if (s->size == 0)
2321             s->size += plt_entry_size;
2322
2323           h->plt.offset = s->size;
2324
2325           /* If this symbol is not defined in a regular file, and we are
2326              not generating a shared library, then set the symbol to this
2327              location in the .plt.  This is required to make function
2328              pointers compare as equal between the normal executable and
2329              the shared library.  */
2330           if (! info->shared
2331               && !h->def_regular)
2332             {
2333               h->root.u.def.section = s;
2334               h->root.u.def.value = h->plt.offset;
2335             }
2336
2337           /* Make room for this entry.  */
2338           s->size += plt_entry_size;
2339
2340           /* We also need to make an entry in the .got.plt section, which
2341              will be placed in the .got section by the linker script.  */
2342           htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
2343
2344           /* We also need to make an entry in the .rela.plt section.  */
2345           htab->elf.srelplt->size += bed->s->sizeof_rela;
2346           htab->elf.srelplt->reloc_count++;
2347         }
2348       else
2349         {
2350           h->plt.offset = (bfd_vma) -1;
2351           h->needs_plt = 0;
2352         }
2353     }
2354   else
2355     {
2356       h->plt.offset = (bfd_vma) -1;
2357       h->needs_plt = 0;
2358     }
2359
2360   eh->tlsdesc_got = (bfd_vma) -1;
2361
2362   /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
2363      make it a R_X86_64_TPOFF32 requiring no GOT entry.  */
2364   if (h->got.refcount > 0
2365       && info->executable
2366       && h->dynindx == -1
2367       && elf_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE)
2368     {
2369       h->got.offset = (bfd_vma) -1;
2370     }
2371   else if (h->got.refcount > 0)
2372     {
2373       asection *s;
2374       bfd_boolean dyn;
2375       int tls_type = elf_x86_64_hash_entry (h)->tls_type;
2376
2377       /* Make sure this symbol is output as a dynamic symbol.
2378          Undefined weak syms won't yet be marked as dynamic.  */
2379       if (h->dynindx == -1
2380           && !h->forced_local)
2381         {
2382           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2383             return FALSE;
2384         }
2385
2386       if (GOT_TLS_GDESC_P (tls_type))
2387         {
2388           eh->tlsdesc_got = htab->elf.sgotplt->size
2389             - elf_x86_64_compute_jump_table_size (htab);
2390           htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
2391           h->got.offset = (bfd_vma) -2;
2392         }
2393       if (! GOT_TLS_GDESC_P (tls_type)
2394           || GOT_TLS_GD_P (tls_type))
2395         {
2396           s = htab->elf.sgot;
2397           h->got.offset = s->size;
2398           s->size += GOT_ENTRY_SIZE;
2399           if (GOT_TLS_GD_P (tls_type))
2400             s->size += GOT_ENTRY_SIZE;
2401         }
2402       dyn = htab->elf.dynamic_sections_created;
2403       /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
2404          and two if global.
2405          R_X86_64_GOTTPOFF needs one dynamic relocation.  */
2406       if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
2407           || tls_type == GOT_TLS_IE)
2408         htab->elf.srelgot->size += bed->s->sizeof_rela;
2409       else if (GOT_TLS_GD_P (tls_type))
2410         htab->elf.srelgot->size += 2 * bed->s->sizeof_rela;
2411       else if (! GOT_TLS_GDESC_P (tls_type)
2412                && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2413                    || h->root.type != bfd_link_hash_undefweak)
2414                && (info->shared
2415                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
2416         htab->elf.srelgot->size += bed->s->sizeof_rela;
2417       if (GOT_TLS_GDESC_P (tls_type))
2418         {
2419           htab->elf.srelplt->size += bed->s->sizeof_rela;
2420           htab->tlsdesc_plt = (bfd_vma) -1;
2421         }
2422     }
2423   else
2424     h->got.offset = (bfd_vma) -1;
2425
2426   if (eh->dyn_relocs == NULL)
2427     return TRUE;
2428
2429   /* In the shared -Bsymbolic case, discard space allocated for
2430      dynamic pc-relative relocs against symbols which turn out to be
2431      defined in regular objects.  For the normal shared case, discard
2432      space for pc-relative relocs that have become local due to symbol
2433      visibility changes.  */
2434
2435   if (info->shared)
2436     {
2437       /* Relocs that use pc_count are those that appear on a call
2438          insn, or certain REL relocs that can generated via assembly.
2439          We want calls to protected symbols to resolve directly to the
2440          function rather than going via the plt.  If people want
2441          function pointer comparisons to work as expected then they
2442          should avoid writing weird assembly.  */
2443       if (SYMBOL_CALLS_LOCAL (info, h))
2444         {
2445           struct elf_dyn_relocs **pp;
2446
2447           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2448             {
2449               p->count -= p->pc_count;
2450               p->pc_count = 0;
2451               if (p->count == 0)
2452                 *pp = p->next;
2453               else
2454                 pp = &p->next;
2455             }
2456         }
2457
2458       /* Also discard relocs on undefined weak syms with non-default
2459          visibility.  */
2460       if (eh->dyn_relocs != NULL
2461           && h->root.type == bfd_link_hash_undefweak)
2462         {
2463           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2464             eh->dyn_relocs = NULL;
2465
2466           /* Make sure undefined weak symbols are output as a dynamic
2467              symbol in PIEs.  */
2468           else if (h->dynindx == -1
2469                    && ! h->forced_local
2470                    && ! bfd_elf_link_record_dynamic_symbol (info, h))
2471             return FALSE;
2472         }
2473
2474     }
2475   else if (ELIMINATE_COPY_RELOCS)
2476     {
2477       /* For the non-shared case, discard space for relocs against
2478          symbols which turn out to need copy relocs or are not
2479          dynamic.  */
2480
2481       if (!h->non_got_ref
2482           && ((h->def_dynamic
2483                && !h->def_regular)
2484               || (htab->elf.dynamic_sections_created
2485                   && (h->root.type == bfd_link_hash_undefweak
2486                       || h->root.type == bfd_link_hash_undefined))))
2487         {
2488           /* Make sure this symbol is output as a dynamic symbol.
2489              Undefined weak syms won't yet be marked as dynamic.  */
2490           if (h->dynindx == -1
2491               && ! h->forced_local
2492               && ! bfd_elf_link_record_dynamic_symbol (info, h))
2493             return FALSE;
2494
2495           /* If that succeeded, we know we'll be keeping all the
2496              relocs.  */
2497           if (h->dynindx != -1)
2498             goto keep;
2499         }
2500
2501       eh->dyn_relocs = NULL;
2502
2503     keep: ;
2504     }
2505
2506   /* Finally, allocate space.  */
2507   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2508     {
2509       asection * sreloc;
2510
2511       sreloc = elf_section_data (p->sec)->sreloc;
2512
2513       BFD_ASSERT (sreloc != NULL);
2514
2515       sreloc->size += p->count * bed->s->sizeof_rela;
2516     }
2517
2518   return TRUE;
2519 }
2520
2521 /* Allocate space in .plt, .got and associated reloc sections for
2522    local dynamic relocs.  */
2523
2524 static bfd_boolean
2525 elf_x86_64_allocate_local_dynrelocs (void **slot, void *inf)
2526 {
2527   struct elf_link_hash_entry *h
2528     = (struct elf_link_hash_entry *) *slot;
2529
2530   if (h->type != STT_GNU_IFUNC
2531       || !h->def_regular
2532       || !h->ref_regular
2533       || !h->forced_local
2534       || h->root.type != bfd_link_hash_defined)
2535     abort ();
2536
2537   return elf_x86_64_allocate_dynrelocs (h, inf);
2538 }
2539
2540 /* Find any dynamic relocs that apply to read-only sections.  */
2541
2542 static bfd_boolean
2543 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry *h,
2544                                void * inf)
2545 {
2546   struct elf_x86_64_link_hash_entry *eh;
2547   struct elf_dyn_relocs *p;
2548
2549   /* Skip local IFUNC symbols. */
2550   if (h->forced_local && h->type == STT_GNU_IFUNC)
2551     return TRUE;
2552
2553   eh = (struct elf_x86_64_link_hash_entry *) h;
2554   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2555     {
2556       asection *s = p->sec->output_section;
2557
2558       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2559         {
2560           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2561
2562           info->flags |= DF_TEXTREL;
2563
2564           if (info->warn_shared_textrel && info->shared)
2565             info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'.\n"),
2566                                     p->sec->owner, h->root.root.string,
2567                                     p->sec);
2568
2569           /* Not an error, just cut short the traversal.  */
2570           return FALSE;
2571         }
2572     }
2573   return TRUE;
2574 }
2575
2576 /* Set the sizes of the dynamic sections.  */
2577
2578 static bfd_boolean
2579 elf_x86_64_size_dynamic_sections (bfd *output_bfd,
2580                                   struct bfd_link_info *info)
2581 {
2582   struct elf_x86_64_link_hash_table *htab;
2583   bfd *dynobj;
2584   asection *s;
2585   bfd_boolean relocs;
2586   bfd *ibfd;
2587   const struct elf_backend_data *bed;
2588
2589   htab = elf_x86_64_hash_table (info);
2590   if (htab == NULL)
2591     return FALSE;
2592   bed = get_elf_backend_data (output_bfd);
2593
2594   dynobj = htab->elf.dynobj;
2595   if (dynobj == NULL)
2596     abort ();
2597
2598   if (htab->elf.dynamic_sections_created)
2599     {
2600       /* Set the contents of the .interp section to the interpreter.  */
2601       if (info->executable)
2602         {
2603           s = bfd_get_section_by_name (dynobj, ".interp");
2604           if (s == NULL)
2605             abort ();
2606           s->size = htab->dynamic_interpreter_size;
2607           s->contents = (unsigned char *) htab->dynamic_interpreter;
2608         }
2609     }
2610
2611   /* Set up .got offsets for local syms, and space for local dynamic
2612      relocs.  */
2613   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2614     {
2615       bfd_signed_vma *local_got;
2616       bfd_signed_vma *end_local_got;
2617       char *local_tls_type;
2618       bfd_vma *local_tlsdesc_gotent;
2619       bfd_size_type locsymcount;
2620       Elf_Internal_Shdr *symtab_hdr;
2621       asection *srel;
2622
2623       if (! is_x86_64_elf (ibfd))
2624         continue;
2625
2626       for (s = ibfd->sections; s != NULL; s = s->next)
2627         {
2628           struct elf_dyn_relocs *p;
2629
2630           for (p = (struct elf_dyn_relocs *)
2631                     (elf_section_data (s)->local_dynrel);
2632                p != NULL;
2633                p = p->next)
2634             {
2635               if (!bfd_is_abs_section (p->sec)
2636                   && bfd_is_abs_section (p->sec->output_section))
2637                 {
2638                   /* Input section has been discarded, either because
2639                      it is a copy of a linkonce section or due to
2640                      linker script /DISCARD/, so we'll be discarding
2641                      the relocs too.  */
2642                 }
2643               else if (p->count != 0)
2644                 {
2645                   srel = elf_section_data (p->sec)->sreloc;
2646                   srel->size += p->count * bed->s->sizeof_rela;
2647                   if ((p->sec->output_section->flags & SEC_READONLY) != 0
2648                       && (info->flags & DF_TEXTREL) == 0)
2649                     {
2650                       info->flags |= DF_TEXTREL;
2651                       if (info->warn_shared_textrel && info->shared)
2652                         info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'.\n"),
2653                                                 p->sec->owner, p->sec);
2654                     }
2655                 }
2656             }
2657         }
2658
2659       local_got = elf_local_got_refcounts (ibfd);
2660       if (!local_got)
2661         continue;
2662
2663       symtab_hdr = &elf_symtab_hdr (ibfd);
2664       locsymcount = symtab_hdr->sh_info;
2665       end_local_got = local_got + locsymcount;
2666       local_tls_type = elf_x86_64_local_got_tls_type (ibfd);
2667       local_tlsdesc_gotent = elf_x86_64_local_tlsdesc_gotent (ibfd);
2668       s = htab->elf.sgot;
2669       srel = htab->elf.srelgot;
2670       for (; local_got < end_local_got;
2671            ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
2672         {
2673           *local_tlsdesc_gotent = (bfd_vma) -1;
2674           if (*local_got > 0)
2675             {
2676               if (GOT_TLS_GDESC_P (*local_tls_type))
2677                 {
2678                   *local_tlsdesc_gotent = htab->elf.sgotplt->size
2679                     - elf_x86_64_compute_jump_table_size (htab);
2680                   htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
2681                   *local_got = (bfd_vma) -2;
2682                 }
2683               if (! GOT_TLS_GDESC_P (*local_tls_type)
2684                   || GOT_TLS_GD_P (*local_tls_type))
2685                 {
2686                   *local_got = s->size;
2687                   s->size += GOT_ENTRY_SIZE;
2688                   if (GOT_TLS_GD_P (*local_tls_type))
2689                     s->size += GOT_ENTRY_SIZE;
2690                 }
2691               if (info->shared
2692                   || GOT_TLS_GD_ANY_P (*local_tls_type)
2693                   || *local_tls_type == GOT_TLS_IE)
2694                 {
2695                   if (GOT_TLS_GDESC_P (*local_tls_type))
2696                     {
2697                       htab->elf.srelplt->size
2698                         += bed->s->sizeof_rela;
2699                       htab->tlsdesc_plt = (bfd_vma) -1;
2700                     }
2701                   if (! GOT_TLS_GDESC_P (*local_tls_type)
2702                       || GOT_TLS_GD_P (*local_tls_type))
2703                     srel->size += bed->s->sizeof_rela;
2704                 }
2705             }
2706           else
2707             *local_got = (bfd_vma) -1;
2708         }
2709     }
2710
2711   if (htab->tls_ld_got.refcount > 0)
2712     {
2713       /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
2714          relocs.  */
2715       htab->tls_ld_got.offset = htab->elf.sgot->size;
2716       htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
2717       htab->elf.srelgot->size += bed->s->sizeof_rela;
2718     }
2719   else
2720     htab->tls_ld_got.offset = -1;
2721
2722   /* Allocate global sym .plt and .got entries, and space for global
2723      sym dynamic relocs.  */
2724   elf_link_hash_traverse (&htab->elf, elf_x86_64_allocate_dynrelocs,
2725                           info);
2726
2727   /* Allocate .plt and .got entries, and space for local symbols.  */
2728   htab_traverse (htab->loc_hash_table,
2729                  elf_x86_64_allocate_local_dynrelocs,
2730                  info);
2731
2732   /* For every jump slot reserved in the sgotplt, reloc_count is
2733      incremented.  However, when we reserve space for TLS descriptors,
2734      it's not incremented, so in order to compute the space reserved
2735      for them, it suffices to multiply the reloc count by the jump
2736      slot size.
2737
2738      PR ld/13302: We start next_irelative_index at the end of .rela.plt
2739      so that R_X86_64_IRELATIVE entries come last.  */
2740   if (htab->elf.srelplt)
2741     {
2742       htab->sgotplt_jump_table_size
2743         = elf_x86_64_compute_jump_table_size (htab);
2744       htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
2745     }
2746   else if (htab->elf.irelplt)
2747     htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
2748
2749   if (htab->tlsdesc_plt)
2750     {
2751       /* If we're not using lazy TLS relocations, don't generate the
2752          PLT and GOT entries they require.  */
2753       if ((info->flags & DF_BIND_NOW))
2754         htab->tlsdesc_plt = 0;
2755       else
2756         {
2757           htab->tlsdesc_got = htab->elf.sgot->size;
2758           htab->elf.sgot->size += GOT_ENTRY_SIZE;
2759           /* Reserve room for the initial entry.
2760              FIXME: we could probably do away with it in this case.  */
2761           if (htab->elf.splt->size == 0)
2762             htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd);
2763           htab->tlsdesc_plt = htab->elf.splt->size;
2764           htab->elf.splt->size += GET_PLT_ENTRY_SIZE (output_bfd);
2765         }
2766     }
2767
2768   if (htab->elf.sgotplt)
2769     {
2770       struct elf_link_hash_entry *got;
2771       got = elf_link_hash_lookup (elf_hash_table (info),
2772                                   "_GLOBAL_OFFSET_TABLE_",
2773                                   FALSE, FALSE, FALSE);
2774
2775       /* Don't allocate .got.plt section if there are no GOT nor PLT
2776          entries and there is no refeence to _GLOBAL_OFFSET_TABLE_.  */
2777       if ((got == NULL
2778            || !got->ref_regular_nonweak)
2779           && (htab->elf.sgotplt->size
2780               == get_elf_backend_data (output_bfd)->got_header_size)
2781           && (htab->elf.splt == NULL
2782               || htab->elf.splt->size == 0)
2783           && (htab->elf.sgot == NULL
2784               || htab->elf.sgot->size == 0)
2785           && (htab->elf.iplt == NULL
2786               || htab->elf.iplt->size == 0)
2787           && (htab->elf.igotplt == NULL
2788               || htab->elf.igotplt->size == 0))
2789         htab->elf.sgotplt->size = 0;
2790     }
2791
2792   if (htab->plt_eh_frame != NULL
2793       && htab->elf.splt != NULL
2794       && htab->elf.splt->size != 0
2795       && !bfd_is_abs_section (htab->elf.splt->output_section)
2796       && _bfd_elf_eh_frame_present (info))
2797     {
2798       const struct elf_x86_64_backend_data *arch_data
2799         = (const struct elf_x86_64_backend_data *) bed->arch_data;
2800       htab->plt_eh_frame->size = arch_data->eh_frame_plt_size;
2801     }
2802
2803   /* We now have determined the sizes of the various dynamic sections.
2804      Allocate memory for them.  */
2805   relocs = FALSE;
2806   for (s = dynobj->sections; s != NULL; s = s->next)
2807     {
2808       if ((s->flags & SEC_LINKER_CREATED) == 0)
2809         continue;
2810
2811       if (s == htab->elf.splt
2812           || s == htab->elf.sgot
2813           || s == htab->elf.sgotplt
2814           || s == htab->elf.iplt
2815           || s == htab->elf.igotplt
2816           || s == htab->plt_eh_frame
2817           || s == htab->sdynbss)
2818         {
2819           /* Strip this section if we don't need it; see the
2820              comment below.  */
2821         }
2822       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2823         {
2824           if (s->size != 0 && s != htab->elf.srelplt)
2825             relocs = TRUE;
2826
2827           /* We use the reloc_count field as a counter if we need
2828              to copy relocs into the output file.  */
2829           if (s != htab->elf.srelplt)
2830             s->reloc_count = 0;
2831         }
2832       else
2833         {
2834           /* It's not one of our sections, so don't allocate space.  */
2835           continue;
2836         }
2837
2838       if (s->size == 0)
2839         {
2840           /* If we don't need this section, strip it from the
2841              output file.  This is mostly to handle .rela.bss and
2842              .rela.plt.  We must create both sections in
2843              create_dynamic_sections, because they must be created
2844              before the linker maps input sections to output
2845              sections.  The linker does that before
2846              adjust_dynamic_symbol is called, and it is that
2847              function which decides whether anything needs to go
2848              into these sections.  */
2849
2850           s->flags |= SEC_EXCLUDE;
2851           continue;
2852         }
2853
2854       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2855         continue;
2856
2857       /* Allocate memory for the section contents.  We use bfd_zalloc
2858          here in case unused entries are not reclaimed before the
2859          section's contents are written out.  This should not happen,
2860          but this way if it does, we get a R_X86_64_NONE reloc instead
2861          of garbage.  */
2862       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2863       if (s->contents == NULL)
2864         return FALSE;
2865     }
2866
2867   if (htab->plt_eh_frame != NULL
2868       && htab->plt_eh_frame->contents != NULL)
2869     {
2870       const struct elf_x86_64_backend_data *arch_data
2871         = (const struct elf_x86_64_backend_data *) bed->arch_data;
2872
2873       memcpy (htab->plt_eh_frame->contents,
2874               arch_data->eh_frame_plt, htab->plt_eh_frame->size);
2875       bfd_put_32 (dynobj, htab->elf.splt->size,
2876                   htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
2877     }
2878
2879   if (htab->elf.dynamic_sections_created)
2880     {
2881       /* Add some entries to the .dynamic section.  We fill in the
2882          values later, in elf_x86_64_finish_dynamic_sections, but we
2883          must add the entries now so that we get the correct size for
2884          the .dynamic section.  The DT_DEBUG entry is filled in by the
2885          dynamic linker and used by the debugger.  */
2886 #define add_dynamic_entry(TAG, VAL) \
2887   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2888
2889       if (info->executable)
2890         {
2891           if (!add_dynamic_entry (DT_DEBUG, 0))
2892             return FALSE;
2893         }
2894
2895       if (htab->elf.splt->size != 0)
2896         {
2897           if (!add_dynamic_entry (DT_PLTGOT, 0)
2898               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2899               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2900               || !add_dynamic_entry (DT_JMPREL, 0))
2901             return FALSE;
2902
2903           if (htab->tlsdesc_plt
2904               && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
2905                   || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
2906             return FALSE;
2907         }
2908
2909       if (relocs)
2910         {
2911           if (!add_dynamic_entry (DT_RELA, 0)
2912               || !add_dynamic_entry (DT_RELASZ, 0)
2913               || !add_dynamic_entry (DT_RELAENT, bed->s->sizeof_rela))
2914             return FALSE;
2915
2916           /* If any dynamic relocs apply to a read-only section,
2917              then we need a DT_TEXTREL entry.  */
2918           if ((info->flags & DF_TEXTREL) == 0)
2919             elf_link_hash_traverse (&htab->elf,
2920                                     elf_x86_64_readonly_dynrelocs,
2921                                     info);
2922
2923           if ((info->flags & DF_TEXTREL) != 0)
2924             {
2925               if (!add_dynamic_entry (DT_TEXTREL, 0))
2926                 return FALSE;
2927             }
2928         }
2929     }
2930 #undef add_dynamic_entry
2931
2932   return TRUE;
2933 }
2934
2935 static bfd_boolean
2936 elf_x86_64_always_size_sections (bfd *output_bfd,
2937                                  struct bfd_link_info *info)
2938 {
2939   asection *tls_sec = elf_hash_table (info)->tls_sec;
2940
2941   if (tls_sec)
2942     {
2943       struct elf_link_hash_entry *tlsbase;
2944
2945       tlsbase = elf_link_hash_lookup (elf_hash_table (info),
2946                                       "_TLS_MODULE_BASE_",
2947                                       FALSE, FALSE, FALSE);
2948
2949       if (tlsbase && tlsbase->type == STT_TLS)
2950         {
2951           struct elf_x86_64_link_hash_table *htab;
2952           struct bfd_link_hash_entry *bh = NULL;
2953           const struct elf_backend_data *bed
2954             = get_elf_backend_data (output_bfd);
2955
2956           htab = elf_x86_64_hash_table (info);
2957           if (htab == NULL)
2958             return FALSE;
2959
2960           if (!(_bfd_generic_link_add_one_symbol
2961                 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
2962                  tls_sec, 0, NULL, FALSE,
2963                  bed->collect, &bh)))
2964             return FALSE;
2965
2966           htab->tls_module_base = bh;
2967
2968           tlsbase = (struct elf_link_hash_entry *)bh;
2969           tlsbase->def_regular = 1;
2970           tlsbase->other = STV_HIDDEN;
2971           (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
2972         }
2973     }
2974
2975   return TRUE;
2976 }
2977
2978 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
2979    executables.  Rather than setting it to the beginning of the TLS
2980    section, we have to set it to the end.  This function may be called
2981    multiple times, it is idempotent.  */
2982
2983 static void
2984 elf_x86_64_set_tls_module_base (struct bfd_link_info *info)
2985 {
2986   struct elf_x86_64_link_hash_table *htab;
2987   struct bfd_link_hash_entry *base;
2988
2989   if (!info->executable)
2990     return;
2991
2992   htab = elf_x86_64_hash_table (info);
2993   if (htab == NULL)
2994     return;
2995
2996   base = htab->tls_module_base;
2997   if (base == NULL)
2998     return;
2999
3000   base->u.def.value = htab->elf.tls_size;
3001 }
3002
3003 /* Return the base VMA address which should be subtracted from real addresses
3004    when resolving @dtpoff relocation.
3005    This is PT_TLS segment p_vaddr.  */
3006
3007 static bfd_vma
3008 elf_x86_64_dtpoff_base (struct bfd_link_info *info)
3009 {
3010   /* If tls_sec is NULL, we should have signalled an error already.  */
3011   if (elf_hash_table (info)->tls_sec == NULL)
3012     return 0;
3013   return elf_hash_table (info)->tls_sec->vma;
3014 }
3015
3016 /* Return the relocation value for @tpoff relocation
3017    if STT_TLS virtual address is ADDRESS.  */
3018
3019 static bfd_vma
3020 elf_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address)
3021 {
3022   struct elf_link_hash_table *htab = elf_hash_table (info);
3023   const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
3024   bfd_vma static_tls_size;
3025
3026   /* If tls_segment is NULL, we should have signalled an error already.  */
3027   if (htab->tls_sec == NULL)
3028     return 0;
3029
3030   /* Consider special static TLS alignment requirements.  */
3031   static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
3032   return address - static_tls_size - htab->tls_sec->vma;
3033 }
3034
3035 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
3036    branch?  */
3037
3038 static bfd_boolean
3039 is_32bit_relative_branch (bfd_byte *contents, bfd_vma offset)
3040 {
3041   /* Opcode             Instruction
3042      0xe8               call
3043      0xe9               jump
3044      0x0f 0x8x          conditional jump */
3045   return ((offset > 0
3046            && (contents [offset - 1] == 0xe8
3047                || contents [offset - 1] == 0xe9))
3048           || (offset > 1
3049               && contents [offset - 2] == 0x0f
3050               && (contents [offset - 1] & 0xf0) == 0x80));
3051 }
3052
3053 /* Relocate an x86_64 ELF section.  */
3054
3055 static bfd_boolean
3056 elf_x86_64_relocate_section (bfd *output_bfd,
3057                              struct bfd_link_info *info,
3058                              bfd *input_bfd,
3059                              asection *input_section,
3060                              bfd_byte *contents,
3061                              Elf_Internal_Rela *relocs,
3062                              Elf_Internal_Sym *local_syms,
3063                              asection **local_sections)
3064 {
3065   struct elf_x86_64_link_hash_table *htab;
3066   Elf_Internal_Shdr *symtab_hdr;
3067   struct elf_link_hash_entry **sym_hashes;
3068   bfd_vma *local_got_offsets;
3069   bfd_vma *local_tlsdesc_gotents;
3070   Elf_Internal_Rela *rel;
3071   Elf_Internal_Rela *relend;
3072   const unsigned int plt_entry_size = GET_PLT_ENTRY_SIZE (info->output_bfd);
3073
3074   BFD_ASSERT (is_x86_64_elf (input_bfd));
3075
3076   htab = elf_x86_64_hash_table (info);
3077   if (htab == NULL)
3078     return FALSE;
3079   symtab_hdr = &elf_symtab_hdr (input_bfd);
3080   sym_hashes = elf_sym_hashes (input_bfd);
3081   local_got_offsets = elf_local_got_offsets (input_bfd);
3082   local_tlsdesc_gotents = elf_x86_64_local_tlsdesc_gotent (input_bfd);
3083
3084   elf_x86_64_set_tls_module_base (info);
3085
3086   rel = relocs;
3087   relend = relocs + input_section->reloc_count;
3088   for (; rel < relend; rel++)
3089     {
3090       unsigned int r_type;
3091       reloc_howto_type *howto;
3092       unsigned long r_symndx;
3093       struct elf_link_hash_entry *h;
3094       Elf_Internal_Sym *sym;
3095       asection *sec;
3096       bfd_vma off, offplt;
3097       bfd_vma relocation;
3098       bfd_boolean unresolved_reloc;
3099       bfd_reloc_status_type r;
3100       int tls_type;
3101       asection *base_got;
3102
3103       r_type = ELF32_R_TYPE (rel->r_info);
3104       if (r_type == (int) R_X86_64_GNU_VTINHERIT
3105           || r_type == (int) R_X86_64_GNU_VTENTRY)
3106         continue;
3107
3108       if (r_type >= R_X86_64_max)
3109         {
3110           bfd_set_error (bfd_error_bad_value);
3111           return FALSE;
3112         }
3113
3114       if (r_type != (int) R_X86_64_32
3115           || ABI_64_P (output_bfd))
3116         howto = x86_64_elf_howto_table + r_type;
3117       else
3118         howto = (x86_64_elf_howto_table
3119                  + ARRAY_SIZE (x86_64_elf_howto_table) - 1);
3120       r_symndx = htab->r_sym (rel->r_info);
3121       h = NULL;
3122       sym = NULL;
3123       sec = NULL;
3124       unresolved_reloc = FALSE;
3125       if (r_symndx < symtab_hdr->sh_info)
3126         {
3127           sym = local_syms + r_symndx;
3128           sec = local_sections[r_symndx];
3129
3130           relocation = _bfd_elf_rela_local_sym (output_bfd, sym,
3131                                                 &sec, rel);
3132
3133           /* Relocate against local STT_GNU_IFUNC symbol.  */
3134           if (!info->relocatable
3135               && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
3136             {
3137               h = elf_x86_64_get_local_sym_hash (htab, input_bfd,
3138                                                  rel, FALSE);
3139               if (h == NULL)
3140                 abort ();
3141
3142               /* Set STT_GNU_IFUNC symbol value.  */
3143               h->root.u.def.value = sym->st_value;
3144               h->root.u.def.section = sec;
3145             }
3146         }
3147       else
3148         {
3149           bfd_boolean warned ATTRIBUTE_UNUSED;
3150
3151           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3152                                    r_symndx, symtab_hdr, sym_hashes,
3153                                    h, sec, relocation,
3154                                    unresolved_reloc, warned);
3155         }
3156
3157       if (sec != NULL && discarded_section (sec))
3158         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3159                                          rel, 1, relend, howto, 0, contents);
3160
3161       if (info->relocatable)
3162         continue;
3163
3164       if (rel->r_addend == 0
3165           && r_type == R_X86_64_64
3166           && !ABI_64_P (output_bfd))
3167         {
3168           /* For x32, treat R_X86_64_64 like R_X86_64_32 and zero-extend
3169              it to 64bit if addend is zero.  */
3170           r_type = R_X86_64_32;
3171           memset (contents + rel->r_offset + 4, 0, 4);
3172         }
3173
3174       /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
3175          it here if it is defined in a non-shared object.  */
3176       if (h != NULL
3177           && h->type == STT_GNU_IFUNC
3178           && h->def_regular)
3179         {
3180           asection *plt;
3181           bfd_vma plt_index;
3182           const char *name;
3183
3184           if ((input_section->flags & SEC_ALLOC) == 0
3185               || h->plt.offset == (bfd_vma) -1)
3186             abort ();
3187
3188           /* STT_GNU_IFUNC symbol must go through PLT.  */
3189           plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
3190           relocation = (plt->output_section->vma
3191                         + plt->output_offset + h->plt.offset);
3192
3193           switch (r_type)
3194             {
3195             default:
3196               if (h->root.root.string)
3197                 name = h->root.root.string;
3198               else
3199                 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3200                                          NULL);
3201               (*_bfd_error_handler)
3202                 (_("%B: relocation %s against STT_GNU_IFUNC "
3203                    "symbol `%s' isn't handled by %s"), input_bfd,
3204                  x86_64_elf_howto_table[r_type].name,
3205                  name, __FUNCTION__);
3206               bfd_set_error (bfd_error_bad_value);
3207               return FALSE;
3208
3209             case R_X86_64_32S:
3210               if (info->shared)
3211                 abort ();
3212               goto do_relocation;
3213
3214             case R_X86_64_32:
3215               if (ABI_64_P (output_bfd))
3216                 goto do_relocation;
3217               /* FALLTHROUGH */
3218             case R_X86_64_64:
3219               if (rel->r_addend != 0)
3220                 {
3221                   if (h->root.root.string)
3222                     name = h->root.root.string;
3223                   else
3224                     name = bfd_elf_sym_name (input_bfd, symtab_hdr,
3225                                              sym, NULL);
3226                   (*_bfd_error_handler)
3227                     (_("%B: relocation %s against STT_GNU_IFUNC "
3228                        "symbol `%s' has non-zero addend: %d"),
3229                      input_bfd, x86_64_elf_howto_table[r_type].name,
3230                      name, rel->r_addend);
3231                   bfd_set_error (bfd_error_bad_value);
3232                   return FALSE;
3233                 }
3234
3235               /* Generate dynamic relcoation only when there is a
3236                  non-GOT reference in a shared object.  */
3237               if (info->shared && h->non_got_ref)
3238                 {
3239                   Elf_Internal_Rela outrel;
3240                   asection *sreloc;
3241
3242                   /* Need a dynamic relocation to get the real function
3243                      address.  */
3244                   outrel.r_offset = _bfd_elf_section_offset (output_bfd,
3245                                                              info,
3246                                                              input_section,
3247                                                              rel->r_offset);
3248                   if (outrel.r_offset == (bfd_vma) -1
3249                       || outrel.r_offset == (bfd_vma) -2)
3250                     abort ();
3251
3252                   outrel.r_offset += (input_section->output_section->vma
3253                                       + input_section->output_offset);
3254
3255                   if (h->dynindx == -1
3256                       || h->forced_local
3257                       || info->executable)
3258                     {
3259                       /* This symbol is resolved locally.  */
3260                       outrel.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
3261                       outrel.r_addend = (h->root.u.def.value
3262                                          + h->root.u.def.section->output_section->vma
3263                                          + h->root.u.def.section->output_offset);
3264                     }
3265                   else
3266                     {
3267                       outrel.r_info = htab->r_info (h->dynindx, r_type);
3268                       outrel.r_addend = 0;
3269                     }
3270
3271                   sreloc = htab->elf.irelifunc;
3272                   elf_append_rela (output_bfd, sreloc, &outrel);
3273
3274                   /* If this reloc is against an external symbol, we
3275                      do not want to fiddle with the addend.  Otherwise,
3276                      we need to include the symbol value so that it
3277                      becomes an addend for the dynamic reloc.  For an
3278                      internal symbol, we have updated addend.  */
3279                   continue;
3280                 }
3281               /* FALLTHROUGH */
3282             case R_X86_64_PC32:
3283             case R_X86_64_PC64:
3284             case R_X86_64_PLT32:
3285               goto do_relocation;
3286
3287             case R_X86_64_GOTPCREL:
3288             case R_X86_64_GOTPCREL64:
3289               base_got = htab->elf.sgot;
3290               off = h->got.offset;
3291
3292               if (base_got == NULL)
3293                 abort ();
3294
3295               if (off == (bfd_vma) -1)
3296                 {
3297                   /* We can't use h->got.offset here to save state, or
3298                      even just remember the offset, as finish_dynamic_symbol
3299                      would use that as offset into .got.  */
3300
3301                   if (htab->elf.splt != NULL)
3302                     {
3303                       plt_index = h->plt.offset / plt_entry_size - 1;
3304                       off = (plt_index + 3) * GOT_ENTRY_SIZE;
3305                       base_got = htab->elf.sgotplt;
3306                     }
3307                   else
3308                     {
3309                       plt_index = h->plt.offset / plt_entry_size;
3310                       off = plt_index * GOT_ENTRY_SIZE;
3311                       base_got = htab->elf.igotplt;
3312                     }
3313
3314                   if (h->dynindx == -1
3315                       || h->forced_local
3316                       || info->symbolic)
3317                     {
3318                       /* This references the local defitionion.  We must
3319                          initialize this entry in the global offset table.
3320                          Since the offset must always be a multiple of 8,
3321                          we use the least significant bit to record
3322                          whether we have initialized it already.
3323
3324                          When doing a dynamic link, we create a .rela.got
3325                          relocation entry to initialize the value.  This
3326                          is done in the finish_dynamic_symbol routine.   */
3327                       if ((off & 1) != 0)
3328                         off &= ~1;
3329                       else
3330                         {
3331                           bfd_put_64 (output_bfd, relocation,
3332                                       base_got->contents + off);
3333                           /* Note that this is harmless for the GOTPLT64
3334                              case, as -1 | 1 still is -1.  */
3335                           h->got.offset |= 1;
3336                         }
3337                     }
3338                 }
3339
3340               relocation = (base_got->output_section->vma
3341                             + base_got->output_offset + off);
3342
3343               goto do_relocation;
3344             }
3345         }
3346
3347       /* When generating a shared object, the relocations handled here are
3348          copied into the output file to be resolved at run time.  */
3349       switch (r_type)
3350         {
3351         case R_X86_64_GOT32:
3352         case R_X86_64_GOT64:
3353           /* Relocation is to the entry for this symbol in the global
3354              offset table.  */
3355         case R_X86_64_GOTPCREL:
3356         case R_X86_64_GOTPCREL64:
3357           /* Use global offset table entry as symbol value.  */
3358         case R_X86_64_GOTPLT64:
3359           /* This is the same as GOT64 for relocation purposes, but
3360              indicates the existence of a PLT entry.  The difficulty is,
3361              that we must calculate the GOT slot offset from the PLT
3362              offset, if this symbol got a PLT entry (it was global).
3363              Additionally if it's computed from the PLT entry, then that
3364              GOT offset is relative to .got.plt, not to .got.  */
3365           base_got = htab->elf.sgot;
3366
3367           if (htab->elf.sgot == NULL)
3368             abort ();
3369
3370           if (h != NULL)
3371             {
3372               bfd_boolean dyn;
3373
3374               off = h->got.offset;
3375               if (h->needs_plt
3376                   && h->plt.offset != (bfd_vma)-1
3377                   && off == (bfd_vma)-1)
3378                 {
3379                   /* We can't use h->got.offset here to save
3380                      state, or even just remember the offset, as
3381                      finish_dynamic_symbol would use that as offset into
3382                      .got.  */
3383                   bfd_vma plt_index = h->plt.offset / plt_entry_size - 1;
3384                   off = (plt_index + 3) * GOT_ENTRY_SIZE;
3385                   base_got = htab->elf.sgotplt;
3386                 }
3387
3388               dyn = htab->elf.dynamic_sections_created;
3389
3390               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3391                   || (info->shared
3392                       && SYMBOL_REFERENCES_LOCAL (info, h))
3393                   || (ELF_ST_VISIBILITY (h->other)
3394                       && h->root.type == bfd_link_hash_undefweak))
3395                 {
3396                   /* This is actually a static link, or it is a -Bsymbolic
3397                      link and the symbol is defined locally, or the symbol
3398                      was forced to be local because of a version file.  We
3399                      must initialize this entry in the global offset table.
3400                      Since the offset must always be a multiple of 8, we
3401                      use the least significant bit to record whether we
3402                      have initialized it already.
3403
3404                      When doing a dynamic link, we create a .rela.got
3405                      relocation entry to initialize the value.  This is
3406                      done in the finish_dynamic_symbol routine.  */
3407                   if ((off & 1) != 0)
3408                     off &= ~1;
3409                   else
3410                     {
3411                       bfd_put_64 (output_bfd, relocation,
3412                                   base_got->contents + off);
3413                       /* Note that this is harmless for the GOTPLT64 case,
3414                          as -1 | 1 still is -1.  */
3415                       h->got.offset |= 1;
3416                     }
3417                 }
3418               else
3419                 unresolved_reloc = FALSE;
3420             }
3421           else
3422             {
3423               if (local_got_offsets == NULL)
3424                 abort ();
3425
3426               off = local_got_offsets[r_symndx];
3427
3428               /* The offset must always be a multiple of 8.  We use
3429                  the least significant bit to record whether we have
3430                  already generated the necessary reloc.  */
3431               if ((off & 1) != 0)
3432                 off &= ~1;
3433               else
3434                 {
3435                   bfd_put_64 (output_bfd, relocation,
3436                               base_got->contents + off);
3437
3438                   if (info->shared)
3439                     {
3440                       asection *s;
3441                       Elf_Internal_Rela outrel;
3442
3443                       /* We need to generate a R_X86_64_RELATIVE reloc
3444                          for the dynamic linker.  */
3445                       s = htab->elf.srelgot;
3446                       if (s == NULL)
3447                         abort ();
3448
3449                       outrel.r_offset = (base_got->output_section->vma
3450                                          + base_got->output_offset
3451                                          + off);
3452                       outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
3453                       outrel.r_addend = relocation;
3454                       elf_append_rela (output_bfd, s, &outrel);
3455                     }
3456
3457                   local_got_offsets[r_symndx] |= 1;
3458                 }
3459             }
3460
3461           if (off >= (bfd_vma) -2)
3462             abort ();
3463
3464           relocation = base_got->output_section->vma
3465                        + base_got->output_offset + off;
3466           if (r_type != R_X86_64_GOTPCREL && r_type != R_X86_64_GOTPCREL64)
3467             relocation -= htab->elf.sgotplt->output_section->vma
3468                           - htab->elf.sgotplt->output_offset;
3469
3470           break;
3471
3472         case R_X86_64_GOTOFF64:
3473           /* Relocation is relative to the start of the global offset
3474              table.  */
3475
3476           /* Check to make sure it isn't a protected function symbol
3477              for shared library since it may not be local when used
3478              as function address.  */
3479           if (!info->executable
3480               && h
3481               && !SYMBOLIC_BIND (info, h)
3482               && h->def_regular
3483               && h->type == STT_FUNC
3484               && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
3485             {
3486               (*_bfd_error_handler)
3487                 (_("%B: relocation R_X86_64_GOTOFF64 against protected function `%s' can not be used when making a shared object"),
3488                  input_bfd, h->root.root.string);
3489               bfd_set_error (bfd_error_bad_value);
3490               return FALSE;
3491             }
3492
3493           /* Note that sgot is not involved in this
3494              calculation.  We always want the start of .got.plt.  If we
3495              defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
3496              permitted by the ABI, we might have to change this
3497              calculation.  */
3498           relocation -= htab->elf.sgotplt->output_section->vma
3499                         + htab->elf.sgotplt->output_offset;
3500           break;
3501
3502         case R_X86_64_GOTPC32:
3503         case R_X86_64_GOTPC64:
3504           /* Use global offset table as symbol value.  */
3505           relocation = htab->elf.sgotplt->output_section->vma
3506                        + htab->elf.sgotplt->output_offset;
3507           unresolved_reloc = FALSE;
3508           break;
3509
3510         case R_X86_64_PLTOFF64:
3511           /* Relocation is PLT entry relative to GOT.  For local
3512              symbols it's the symbol itself relative to GOT.  */
3513           if (h != NULL
3514               /* See PLT32 handling.  */
3515               && h->plt.offset != (bfd_vma) -1
3516               && htab->elf.splt != NULL)
3517             {
3518               relocation = (htab->elf.splt->output_section->vma
3519                             + htab->elf.splt->output_offset
3520                             + h->plt.offset);
3521               unresolved_reloc = FALSE;
3522             }
3523
3524           relocation -= htab->elf.sgotplt->output_section->vma
3525                         + htab->elf.sgotplt->output_offset;
3526           break;
3527
3528         case R_X86_64_PLT32:
3529           /* Relocation is to the entry for this symbol in the
3530              procedure linkage table.  */
3531
3532           /* Resolve a PLT32 reloc against a local symbol directly,
3533              without using the procedure linkage table.  */
3534           if (h == NULL)
3535             break;
3536
3537           if (h->plt.offset == (bfd_vma) -1
3538               || htab->elf.splt == NULL)
3539             {
3540               /* We didn't make a PLT entry for this symbol.  This
3541                  happens when statically linking PIC code, or when
3542                  using -Bsymbolic.  */
3543               break;
3544             }
3545
3546           relocation = (htab->elf.splt->output_section->vma
3547                         + htab->elf.splt->output_offset
3548                         + h->plt.offset);
3549           unresolved_reloc = FALSE;
3550           break;
3551
3552         case R_X86_64_PC8:
3553         case R_X86_64_PC16:
3554         case R_X86_64_PC32:
3555           if (info->shared
3556               && (input_section->flags & SEC_ALLOC) != 0
3557               && (input_section->flags & SEC_READONLY) != 0
3558               && h != NULL)
3559             {
3560               bfd_boolean fail = FALSE;
3561               bfd_boolean branch
3562                 = (r_type == R_X86_64_PC32
3563                    && is_32bit_relative_branch (contents, rel->r_offset));
3564
3565               if (SYMBOL_REFERENCES_LOCAL (info, h))
3566                 {
3567                   /* Symbol is referenced locally.  Make sure it is
3568                      defined locally or for a branch.  */
3569                   fail = !h->def_regular && !branch;
3570                 }
3571               else
3572                 {
3573                   /* Symbol isn't referenced locally.  We only allow
3574                      branch to symbol with non-default visibility. */
3575                   fail = (!branch
3576                           || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT);
3577                 }
3578
3579               if (fail)
3580                 {
3581                   const char *fmt;
3582                   const char *v;
3583                   const char *pic = "";
3584
3585                   switch (ELF_ST_VISIBILITY (h->other))
3586                     {
3587                     case STV_HIDDEN:
3588                       v = _("hidden symbol");
3589                       break;
3590                     case STV_INTERNAL:
3591                       v = _("internal symbol");
3592                       break;
3593                     case STV_PROTECTED:
3594                       v = _("protected symbol");
3595                       break;
3596                     default:
3597                       v = _("symbol");
3598                       pic = _("; recompile with -fPIC");
3599                       break;
3600                     }
3601
3602                   if (h->def_regular)
3603                     fmt = _("%B: relocation %s against %s `%s' can not be used when making a shared object%s");
3604                   else
3605                     fmt = _("%B: relocation %s against undefined %s `%s' can not be used when making a shared object%s");
3606
3607                   (*_bfd_error_handler) (fmt, input_bfd,
3608                                          x86_64_elf_howto_table[r_type].name,
3609                                          v,  h->root.root.string, pic);
3610                   bfd_set_error (bfd_error_bad_value);
3611                   return FALSE;
3612                 }
3613             }
3614           /* Fall through.  */
3615
3616         case R_X86_64_8:
3617         case R_X86_64_16:
3618         case R_X86_64_32:
3619         case R_X86_64_PC64:
3620         case R_X86_64_64:
3621           /* FIXME: The ABI says the linker should make sure the value is
3622              the same when it's zeroextended to 64 bit.  */
3623
3624           if ((input_section->flags & SEC_ALLOC) == 0)
3625             break;
3626
3627           if ((info->shared
3628                && (h == NULL
3629                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3630                    || h->root.type != bfd_link_hash_undefweak)
3631                && (! IS_X86_64_PCREL_TYPE (r_type)
3632                    || ! SYMBOL_CALLS_LOCAL (info, h)))
3633               || (ELIMINATE_COPY_RELOCS
3634                   && !info->shared
3635                   && h != NULL
3636                   && h->dynindx != -1
3637                   && !h->non_got_ref
3638                   && ((h->def_dynamic
3639                        && !h->def_regular)
3640                       || h->root.type == bfd_link_hash_undefweak
3641                       || h->root.type == bfd_link_hash_undefined)))
3642             {
3643               Elf_Internal_Rela outrel;
3644               bfd_boolean skip, relocate;
3645               asection *sreloc;
3646
3647               /* When generating a shared object, these relocations
3648                  are copied into the output file to be resolved at run
3649                  time.  */
3650               skip = FALSE;
3651               relocate = FALSE;
3652
3653               outrel.r_offset =
3654                 _bfd_elf_section_offset (output_bfd, info, input_section,
3655                                          rel->r_offset);
3656               if (outrel.r_offset == (bfd_vma) -1)
3657                 skip = TRUE;
3658               else if (outrel.r_offset == (bfd_vma) -2)
3659                 skip = TRUE, relocate = TRUE;
3660
3661               outrel.r_offset += (input_section->output_section->vma
3662                                   + input_section->output_offset);
3663
3664               if (skip)
3665                 memset (&outrel, 0, sizeof outrel);
3666
3667               /* h->dynindx may be -1 if this symbol was marked to
3668                  become local.  */
3669               else if (h != NULL
3670                        && h->dynindx != -1
3671                        && (IS_X86_64_PCREL_TYPE (r_type)
3672                            || ! info->shared
3673                            || ! SYMBOLIC_BIND (info, h)
3674                            || ! h->def_regular))
3675                 {
3676                   outrel.r_info = htab->r_info (h->dynindx, r_type);
3677                   outrel.r_addend = rel->r_addend;
3678                 }
3679               else
3680                 {
3681                   /* This symbol is local, or marked to become local.  */
3682                   if (r_type == htab->pointer_r_type)
3683                     {
3684                       relocate = TRUE;
3685                       outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
3686                       outrel.r_addend = relocation + rel->r_addend;
3687                     }
3688                   else if (r_type == R_X86_64_64
3689                            && !ABI_64_P (output_bfd))
3690                     {
3691                       relocate = TRUE;
3692                       outrel.r_info = htab->r_info (0,
3693                                                     R_X86_64_RELATIVE64);
3694                       outrel.r_addend = relocation + rel->r_addend;
3695                       /* Check addend overflow.  */
3696                       if ((outrel.r_addend & 0x80000000)
3697                           != (rel->r_addend & 0x80000000))
3698                         {
3699                           const char *name;
3700                           int addend = rel->r_addend;
3701                           if (h && h->root.root.string)
3702                             name = h->root.root.string;
3703                           else
3704                             name = bfd_elf_sym_name (input_bfd, symtab_hdr,
3705                                                      sym, NULL);
3706                           if (addend < 0)
3707                             (*_bfd_error_handler)
3708                               (_("%B: addend -0x%x in relocation %s against "
3709                                  "symbol `%s' at 0x%lx in section `%A' is "
3710                                  "out of range"),
3711                                input_bfd, input_section, addend,
3712                                x86_64_elf_howto_table[r_type].name,
3713                                name, (unsigned long) rel->r_offset);
3714                           else
3715                             (*_bfd_error_handler)
3716                               (_("%B: addend 0x%x in relocation %s against "
3717                                  "symbol `%s' at 0x%lx in section `%A' is "
3718                                  "out of range"),
3719                                input_bfd, input_section, addend,
3720                                x86_64_elf_howto_table[r_type].name,
3721                                name, (unsigned long) rel->r_offset);
3722                           bfd_set_error (bfd_error_bad_value);
3723                           return FALSE;
3724                         }
3725                     }
3726                   else
3727                     {
3728                       long sindx;
3729
3730                       if (bfd_is_abs_section (sec))
3731                         sindx = 0;
3732                       else if (sec == NULL || sec->owner == NULL)
3733                         {
3734                           bfd_set_error (bfd_error_bad_value);
3735                           return FALSE;
3736                         }
3737                       else
3738                         {
3739                           asection *osec;
3740
3741                           /* We are turning this relocation into one
3742                              against a section symbol.  It would be
3743                              proper to subtract the symbol's value,
3744                              osec->vma, from the emitted reloc addend,
3745                              but ld.so expects buggy relocs.  */
3746                           osec = sec->output_section;
3747                           sindx = elf_section_data (osec)->dynindx;
3748                           if (sindx == 0)
3749                             {
3750                               asection *oi = htab->elf.text_index_section;
3751                               sindx = elf_section_data (oi)->dynindx;
3752                             }
3753                           BFD_ASSERT (sindx != 0);
3754                         }
3755
3756                       outrel.r_info = htab->r_info (sindx, r_type);
3757                       outrel.r_addend = relocation + rel->r_addend;
3758                     }
3759                 }
3760
3761               sreloc = elf_section_data (input_section)->sreloc;
3762
3763               if (sreloc == NULL || sreloc->contents == NULL)
3764                 {
3765                   r = bfd_reloc_notsupported;
3766                   goto check_relocation_error;
3767                 }
3768
3769               elf_append_rela (output_bfd, sreloc, &outrel);
3770
3771               /* If this reloc is against an external symbol, we do
3772                  not want to fiddle with the addend.  Otherwise, we
3773                  need to include the symbol value so that it becomes
3774                  an addend for the dynamic reloc.  */
3775               if (! relocate)
3776                 continue;
3777             }
3778
3779           break;
3780
3781         case R_X86_64_TLSGD:
3782         case R_X86_64_GOTPC32_TLSDESC:
3783         case R_X86_64_TLSDESC_CALL:
3784         case R_X86_64_GOTTPOFF:
3785           tls_type = GOT_UNKNOWN;
3786           if (h == NULL && local_got_offsets)
3787             tls_type = elf_x86_64_local_got_tls_type (input_bfd) [r_symndx];
3788           else if (h != NULL)
3789             tls_type = elf_x86_64_hash_entry (h)->tls_type;
3790
3791           if (! elf_x86_64_tls_transition (info, input_bfd,
3792                                            input_section, contents,
3793                                            symtab_hdr, sym_hashes,
3794                                            &r_type, tls_type, rel,
3795                                            relend, h, r_symndx))
3796             return FALSE;
3797
3798           if (r_type == R_X86_64_TPOFF32)
3799             {
3800               bfd_vma roff = rel->r_offset;
3801
3802               BFD_ASSERT (! unresolved_reloc);
3803
3804               if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
3805                 {
3806                   /* GD->LE transition.  For 64bit, change
3807                      .byte 0x66; leaq foo@tlsgd(%rip), %rdi
3808                      .word 0x6666; rex64; call __tls_get_addr
3809                      into:
3810                      movq %fs:0, %rax
3811                      leaq foo@tpoff(%rax), %rax
3812                      For 32bit, change
3813                      leaq foo@tlsgd(%rip), %rdi
3814                      .word 0x6666; rex64; call __tls_get_addr
3815                      into:
3816                      movl %fs:0, %eax
3817                      leaq foo@tpoff(%rax), %rax */
3818                   if (ABI_64_P (output_bfd))
3819                     memcpy (contents + roff - 4,
3820                             "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3821                             16);
3822                   else
3823                     memcpy (contents + roff - 3,
3824                             "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
3825                             15);
3826                   bfd_put_32 (output_bfd,
3827                               elf_x86_64_tpoff (info, relocation),
3828                               contents + roff + 8);
3829                   /* Skip R_X86_64_PC32/R_X86_64_PLT32.  */
3830                   rel++;
3831                   continue;
3832                 }
3833               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
3834                 {
3835                   /* GDesc -> LE transition.
3836                      It's originally something like:
3837                      leaq x@tlsdesc(%rip), %rax
3838
3839                      Change it to:
3840                      movl $x@tpoff, %rax.  */
3841
3842                   unsigned int val, type;
3843
3844                   type = bfd_get_8 (input_bfd, contents + roff - 3);
3845                   val = bfd_get_8 (input_bfd, contents + roff - 1);
3846                   bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1),
3847                              contents + roff - 3);
3848                   bfd_put_8 (output_bfd, 0xc7, contents + roff - 2);
3849                   bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
3850                              contents + roff - 1);
3851                   bfd_put_32 (output_bfd,
3852                               elf_x86_64_tpoff (info, relocation),
3853                               contents + roff);
3854                   continue;
3855                 }
3856               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
3857                 {
3858                   /* GDesc -> LE transition.
3859                      It's originally:
3860                      call *(%rax)
3861                      Turn it into:
3862                      xchg %ax,%ax.  */
3863                   bfd_put_8 (output_bfd, 0x66, contents + roff);
3864                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
3865                   continue;
3866                 }
3867               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTTPOFF)
3868                 {
3869                   /* IE->LE transition:
3870                      Originally it can be one of:
3871                      movq foo@gottpoff(%rip), %reg
3872                      addq foo@gottpoff(%rip), %reg
3873                      We change it into:
3874                      movq $foo, %reg
3875                      leaq foo(%reg), %reg
3876                      addq $foo, %reg.  */
3877
3878                   unsigned int val, type, reg;
3879
3880                   val = bfd_get_8 (input_bfd, contents + roff - 3);
3881                   type = bfd_get_8 (input_bfd, contents + roff - 2);
3882                   reg = bfd_get_8 (input_bfd, contents + roff - 1);
3883                   reg >>= 3;
3884                   if (type == 0x8b)
3885                     {
3886                       /* movq */
3887                       if (val == 0x4c)
3888                         bfd_put_8 (output_bfd, 0x49,
3889                                    contents + roff - 3);
3890                       else if (!ABI_64_P (output_bfd) && val == 0x44)
3891                         bfd_put_8 (output_bfd, 0x41,
3892                                    contents + roff - 3);
3893                       bfd_put_8 (output_bfd, 0xc7,
3894                                  contents + roff - 2);
3895                       bfd_put_8 (output_bfd, 0xc0 | reg,
3896                                  contents + roff - 1);
3897                     }
3898                   else if (reg == 4)
3899                     {
3900                       /* addq -> addq - addressing with %rsp/%r12 is
3901                          special  */
3902                       if (val == 0x4c)
3903                         bfd_put_8 (output_bfd, 0x49,
3904                                    contents + roff - 3);
3905                       else if (!ABI_64_P (output_bfd) && val == 0x44)
3906                         bfd_put_8 (output_bfd, 0x41,
3907                                    contents + roff - 3);
3908                       bfd_put_8 (output_bfd, 0x81,
3909                                  contents + roff - 2);
3910                       bfd_put_8 (output_bfd, 0xc0 | reg,
3911                                  contents + roff - 1);
3912                     }
3913                   else
3914                     {
3915                       /* addq -> leaq */
3916                       if (val == 0x4c)
3917                         bfd_put_8 (output_bfd, 0x4d,
3918                                    contents + roff - 3);
3919                       else if (!ABI_64_P (output_bfd) && val == 0x44)
3920                         bfd_put_8 (output_bfd, 0x45,
3921                                    contents + roff - 3);
3922                       bfd_put_8 (output_bfd, 0x8d,
3923                                  contents + roff - 2);
3924                       bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
3925                                  contents + roff - 1);
3926                     }
3927                   bfd_put_32 (output_bfd,
3928                               elf_x86_64_tpoff (info, relocation),
3929                               contents + roff);
3930                   continue;
3931                 }
3932               else
3933                 BFD_ASSERT (FALSE);
3934             }
3935
3936           if (htab->elf.sgot == NULL)
3937             abort ();
3938
3939           if (h != NULL)
3940             {
3941               off = h->got.offset;
3942               offplt = elf_x86_64_hash_entry (h)->tlsdesc_got;
3943             }
3944           else
3945             {
3946               if (local_got_offsets == NULL)
3947                 abort ();
3948
3949               off = local_got_offsets[r_symndx];
3950               offplt = local_tlsdesc_gotents[r_symndx];
3951             }
3952
3953           if ((off & 1) != 0)
3954             off &= ~1;
3955           else
3956             {
3957               Elf_Internal_Rela outrel;
3958               int dr_type, indx;
3959               asection *sreloc;
3960
3961               if (htab->elf.srelgot == NULL)
3962                 abort ();
3963
3964               indx = h && h->dynindx != -1 ? h->dynindx : 0;
3965
3966               if (GOT_TLS_GDESC_P (tls_type))
3967                 {
3968                   outrel.r_info = htab->r_info (indx, R_X86_64_TLSDESC);
3969                   BFD_ASSERT (htab->sgotplt_jump_table_size + offplt
3970                               + 2 * GOT_ENTRY_SIZE <= htab->elf.sgotplt->size);
3971                   outrel.r_offset = (htab->elf.sgotplt->output_section->vma
3972                                      + htab->elf.sgotplt->output_offset
3973                                      + offplt
3974                                      + htab->sgotplt_jump_table_size);
3975                   sreloc = htab->elf.srelplt;
3976                   if (indx == 0)
3977                     outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
3978                   else
3979                     outrel.r_addend = 0;
3980                   elf_append_rela (output_bfd, sreloc, &outrel);
3981                 }
3982
3983               sreloc = htab->elf.srelgot;
3984
3985               outrel.r_offset = (htab->elf.sgot->output_section->vma
3986                                  + htab->elf.sgot->output_offset + off);
3987
3988               if (GOT_TLS_GD_P (tls_type))
3989                 dr_type = R_X86_64_DTPMOD64;
3990               else if (GOT_TLS_GDESC_P (tls_type))
3991                 goto dr_done;
3992               else
3993                 dr_type = R_X86_64_TPOFF64;
3994
3995               bfd_put_64 (output_bfd, 0, htab->elf.sgot->contents + off);
3996               outrel.r_addend = 0;
3997               if ((dr_type == R_X86_64_TPOFF64
3998                    || dr_type == R_X86_64_TLSDESC) && indx == 0)
3999                 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
4000               outrel.r_info = htab->r_info (indx, dr_type);
4001
4002               elf_append_rela (output_bfd, sreloc, &outrel);
4003
4004               if (GOT_TLS_GD_P (tls_type))
4005                 {
4006                   if (indx == 0)
4007                     {
4008                       BFD_ASSERT (! unresolved_reloc);
4009                       bfd_put_64 (output_bfd,
4010                                   relocation - elf_x86_64_dtpoff_base (info),
4011                                   htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4012                     }
4013                   else
4014                     {
4015                       bfd_put_64 (output_bfd, 0,
4016                                   htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4017                       outrel.r_info = htab->r_info (indx,
4018                                                     R_X86_64_DTPOFF64);
4019                       outrel.r_offset += GOT_ENTRY_SIZE;
4020                       elf_append_rela (output_bfd, sreloc,
4021                                                 &outrel);
4022                     }
4023                 }
4024
4025             dr_done:
4026               if (h != NULL)
4027                 h->got.offset |= 1;
4028               else
4029                 local_got_offsets[r_symndx] |= 1;
4030             }
4031
4032           if (off >= (bfd_vma) -2
4033               && ! GOT_TLS_GDESC_P (tls_type))
4034             abort ();
4035           if (r_type == ELF32_R_TYPE (rel->r_info))
4036             {
4037               if (r_type == R_X86_64_GOTPC32_TLSDESC
4038                   || r_type == R_X86_64_TLSDESC_CALL)
4039                 relocation = htab->elf.sgotplt->output_section->vma
4040                   + htab->elf.sgotplt->output_offset
4041                   + offplt + htab->sgotplt_jump_table_size;
4042               else
4043                 relocation = htab->elf.sgot->output_section->vma
4044                   + htab->elf.sgot->output_offset + off;
4045               unresolved_reloc = FALSE;
4046             }
4047           else
4048             {
4049               bfd_vma roff = rel->r_offset;
4050
4051               if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
4052                 {
4053                   /* GD->IE transition.  For 64bit, change
4054                      .byte 0x66; leaq foo@tlsgd(%rip), %rdi
4055                      .word 0x6666; rex64; call __tls_get_addr@plt
4056                      into:
4057                      movq %fs:0, %rax
4058                      addq foo@gottpoff(%rip), %rax
4059                      For 32bit, change
4060                      leaq foo@tlsgd(%rip), %rdi
4061                      .word 0x6666; rex64; call __tls_get_addr@plt
4062                      into:
4063                      movl %fs:0, %eax
4064                      addq foo@gottpoff(%rip), %rax */
4065                   if (ABI_64_P (output_bfd))
4066                     memcpy (contents + roff - 4,
4067                             "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4068                             16);
4069                   else
4070                     memcpy (contents + roff - 3,
4071                             "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
4072                             15);
4073
4074                   relocation = (htab->elf.sgot->output_section->vma
4075                                 + htab->elf.sgot->output_offset + off
4076                                 - roff
4077                                 - input_section->output_section->vma
4078                                 - input_section->output_offset
4079                                 - 12);
4080                   bfd_put_32 (output_bfd, relocation,
4081                               contents + roff + 8);
4082                   /* Skip R_X86_64_PLT32.  */
4083                   rel++;
4084                   continue;
4085                 }
4086               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
4087                 {
4088                   /* GDesc -> IE transition.
4089                      It's originally something like:
4090                      leaq x@tlsdesc(%rip), %rax
4091
4092                      Change it to:
4093                      movq x@gottpoff(%rip), %rax # before xchg %ax,%ax.  */
4094
4095                   /* Now modify the instruction as appropriate. To
4096                      turn a leaq into a movq in the form we use it, it
4097                      suffices to change the second byte from 0x8d to
4098                      0x8b.  */
4099                   bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
4100
4101                   bfd_put_32 (output_bfd,
4102                               htab->elf.sgot->output_section->vma
4103                               + htab->elf.sgot->output_offset + off
4104                               - rel->r_offset
4105                               - input_section->output_section->vma
4106                               - input_section->output_offset
4107                               - 4,
4108                               contents + roff);
4109                   continue;
4110                 }
4111               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
4112                 {
4113                   /* GDesc -> IE transition.
4114                      It's originally:
4115                      call *(%rax)
4116
4117                      Change it to:
4118                      xchg %ax, %ax.  */
4119
4120                   bfd_put_8 (output_bfd, 0x66, contents + roff);
4121                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
4122                   continue;
4123                 }
4124               else
4125                 BFD_ASSERT (FALSE);
4126             }
4127           break;
4128
4129         case R_X86_64_TLSLD:
4130           if (! elf_x86_64_tls_transition (info, input_bfd,
4131                                            input_section, contents,
4132                                            symtab_hdr, sym_hashes,
4133                                            &r_type, GOT_UNKNOWN,
4134                                            rel, relend, h, r_symndx))
4135             return FALSE;
4136
4137           if (r_type != R_X86_64_TLSLD)
4138             {
4139               /* LD->LE transition:
4140                  leaq foo@tlsld(%rip), %rdi; call __tls_get_addr.
4141                  For 64bit, we change it into:
4142                  .word 0x6666; .byte 0x66; movq %fs:0, %rax.
4143                  For 32bit, we change it into:
4144                  nopl 0x0(%rax); movl %fs:0, %eax.  */
4145
4146               BFD_ASSERT (r_type == R_X86_64_TPOFF32);
4147               if (ABI_64_P (output_bfd))
4148                 memcpy (contents + rel->r_offset - 3,
4149                         "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
4150               else
4151                 memcpy (contents + rel->r_offset - 3,
4152                         "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
4153               /* Skip R_X86_64_PC32/R_X86_64_PLT32.  */
4154               rel++;
4155               continue;
4156             }
4157
4158           if (htab->elf.sgot == NULL)
4159             abort ();
4160
4161           off = htab->tls_ld_got.offset;
4162           if (off & 1)
4163             off &= ~1;
4164           else
4165             {
4166               Elf_Internal_Rela outrel;
4167
4168               if (htab->elf.srelgot == NULL)
4169                 abort ();
4170
4171               outrel.r_offset = (htab->elf.sgot->output_section->vma
4172                                  + htab->elf.sgot->output_offset + off);
4173
4174               bfd_put_64 (output_bfd, 0,
4175                           htab->elf.sgot->contents + off);
4176               bfd_put_64 (output_bfd, 0,
4177                           htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
4178               outrel.r_info = htab->r_info (0, R_X86_64_DTPMOD64);
4179               outrel.r_addend = 0;
4180               elf_append_rela (output_bfd, htab->elf.srelgot,
4181                                         &outrel);
4182               htab->tls_ld_got.offset |= 1;
4183             }
4184           relocation = htab->elf.sgot->output_section->vma
4185                        + htab->elf.sgot->output_offset + off;
4186           unresolved_reloc = FALSE;
4187           break;
4188
4189         case R_X86_64_DTPOFF32:
4190           if (!info->executable|| (input_section->flags & SEC_CODE) == 0)
4191             relocation -= elf_x86_64_dtpoff_base (info);
4192           else
4193             relocation = elf_x86_64_tpoff (info, relocation);
4194           break;
4195
4196         case R_X86_64_TPOFF32:
4197         case R_X86_64_TPOFF64:
4198           BFD_ASSERT (info->executable);
4199           relocation = elf_x86_64_tpoff (info, relocation);
4200           break;
4201
4202         default:
4203           break;
4204         }
4205
4206       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4207          because such sections are not SEC_ALLOC and thus ld.so will
4208          not process them.  */
4209       if (unresolved_reloc
4210           && !((input_section->flags & SEC_DEBUGGING) != 0
4211                && h->def_dynamic)
4212           && _bfd_elf_section_offset (output_bfd, info, input_section,
4213                                       rel->r_offset) != (bfd_vma) -1)
4214         (*_bfd_error_handler)
4215           (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4216            input_bfd,
4217            input_section,
4218            (long) rel->r_offset,
4219            howto->name,
4220            h->root.root.string);
4221
4222 do_relocation:
4223       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4224                                     contents, rel->r_offset,
4225                                     relocation, rel->r_addend);
4226
4227 check_relocation_error:
4228       if (r != bfd_reloc_ok)
4229         {
4230           const char *name;
4231
4232           if (h != NULL)
4233             name = h->root.root.string;
4234           else
4235             {
4236               name = bfd_elf_string_from_elf_section (input_bfd,
4237                                                       symtab_hdr->sh_link,
4238                                                       sym->st_name);
4239               if (name == NULL)
4240                 return FALSE;
4241               if (*name == '\0')
4242                 name = bfd_section_name (input_bfd, sec);
4243             }
4244
4245           if (r == bfd_reloc_overflow)
4246             {
4247               if (! ((*info->callbacks->reloc_overflow)
4248                      (info, (h ? &h->root : NULL), name, howto->name,
4249                       (bfd_vma) 0, input_bfd, input_section,
4250                       rel->r_offset)))
4251                 return FALSE;
4252             }
4253           else
4254             {
4255               (*_bfd_error_handler)
4256                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
4257                  input_bfd, input_section,
4258                  (long) rel->r_offset, name, (int) r);
4259               return FALSE;
4260             }
4261         }
4262     }
4263
4264   return TRUE;
4265 }
4266
4267 /* Finish up dynamic symbol handling.  We set the contents of various
4268    dynamic sections here.  */
4269
4270 static bfd_boolean
4271 elf_x86_64_finish_dynamic_symbol (bfd *output_bfd,
4272                                   struct bfd_link_info *info,
4273                                   struct elf_link_hash_entry *h,
4274                                   Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
4275 {
4276   struct elf_x86_64_link_hash_table *htab;
4277   const struct elf_x86_64_backend_data *const abed
4278     = get_elf_x86_64_backend_data (output_bfd);
4279
4280   htab = elf_x86_64_hash_table (info);
4281   if (htab == NULL)
4282     return FALSE;
4283
4284   if (h->plt.offset != (bfd_vma) -1)
4285     {
4286       bfd_vma plt_index;
4287       bfd_vma got_offset;
4288       Elf_Internal_Rela rela;
4289       bfd_byte *loc;
4290       asection *plt, *gotplt, *relplt;
4291       const struct elf_backend_data *bed;
4292
4293       /* When building a static executable, use .iplt, .igot.plt and
4294          .rela.iplt sections for STT_GNU_IFUNC symbols.  */
4295       if (htab->elf.splt != NULL)
4296         {
4297           plt = htab->elf.splt;
4298           gotplt = htab->elf.sgotplt;
4299           relplt = htab->elf.srelplt;
4300         }
4301       else
4302         {
4303           plt = htab->elf.iplt;
4304           gotplt = htab->elf.igotplt;
4305           relplt = htab->elf.irelplt;
4306         }
4307
4308       /* This symbol has an entry in the procedure linkage table.  Set
4309          it up.  */
4310       if ((h->dynindx == -1
4311            && !((h->forced_local || info->executable)
4312                 && h->def_regular
4313                 && h->type == STT_GNU_IFUNC))
4314           || plt == NULL
4315           || gotplt == NULL
4316           || relplt == NULL)
4317         return FALSE;
4318
4319       /* Get the index in the procedure linkage table which
4320          corresponds to this symbol.  This is the index of this symbol
4321          in all the symbols for which we are making plt entries.  The
4322          first entry in the procedure linkage table is reserved.
4323
4324          Get the offset into the .got table of the entry that
4325          corresponds to this function.  Each .got entry is GOT_ENTRY_SIZE
4326          bytes. The first three are reserved for the dynamic linker.
4327
4328          For static executables, we don't reserve anything.  */
4329
4330       if (plt == htab->elf.splt)
4331         {
4332           got_offset = h->plt.offset / abed->plt_entry_size - 1;
4333           got_offset = (got_offset + 3) * GOT_ENTRY_SIZE;
4334         }
4335       else
4336         {
4337           got_offset = h->plt.offset / abed->plt_entry_size;
4338           got_offset = got_offset * GOT_ENTRY_SIZE;
4339         }
4340
4341       /* Fill in the entry in the procedure linkage table.  */
4342       memcpy (plt->contents + h->plt.offset, abed->plt_entry,
4343               abed->plt_entry_size);
4344
4345       /* Insert the relocation positions of the plt section.  */
4346
4347       /* Put offset the PC-relative instruction referring to the GOT entry,
4348          subtracting the size of that instruction.  */
4349       bfd_put_32 (output_bfd,
4350                   (gotplt->output_section->vma
4351                    + gotplt->output_offset
4352                    + got_offset
4353                    - plt->output_section->vma
4354                    - plt->output_offset
4355                    - h->plt.offset
4356                    - abed->plt_got_insn_size),
4357                   plt->contents + h->plt.offset + abed->plt_got_offset);
4358
4359       /* Fill in the entry in the global offset table, initially this
4360          points to the second part of the PLT entry.  */
4361       bfd_put_64 (output_bfd, (plt->output_section->vma
4362                                + plt->output_offset
4363                                + h->plt.offset + abed->plt_lazy_offset),
4364                   gotplt->contents + got_offset);
4365
4366       /* Fill in the entry in the .rela.plt section.  */
4367       rela.r_offset = (gotplt->output_section->vma
4368                        + gotplt->output_offset
4369                        + got_offset);
4370       if (h->dynindx == -1
4371           || ((info->executable
4372                || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
4373               && h->def_regular
4374               && h->type == STT_GNU_IFUNC))
4375         {
4376           /* If an STT_GNU_IFUNC symbol is locally defined, generate
4377              R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT.  */
4378           rela.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
4379           rela.r_addend = (h->root.u.def.value
4380                            + h->root.u.def.section->output_section->vma
4381                            + h->root.u.def.section->output_offset);
4382           /* R_X86_64_IRELATIVE comes last.  */
4383           plt_index = htab->next_irelative_index--;
4384         }
4385       else
4386         {
4387           rela.r_info = htab->r_info (h->dynindx, R_X86_64_JUMP_SLOT);
4388           rela.r_addend = 0;
4389           plt_index = htab->next_jump_slot_index++;
4390         }
4391
4392       /* Don't fill PLT entry for static executables.  */
4393       if (plt == htab->elf.splt)
4394         {
4395           /* Put relocation index.  */
4396           bfd_put_32 (output_bfd, plt_index,
4397                       plt->contents + h->plt.offset + abed->plt_reloc_offset);
4398           /* Put offset for jmp .PLT0.  */
4399           bfd_put_32 (output_bfd, - (h->plt.offset + abed->plt_plt_insn_end),
4400                       plt->contents + h->plt.offset + abed->plt_plt_offset);
4401         }
4402
4403       bed = get_elf_backend_data (output_bfd);
4404       loc = relplt->contents + plt_index * bed->s->sizeof_rela;
4405       bed->s->swap_reloca_out (output_bfd, &rela, loc);
4406
4407       if (!h->def_regular)
4408         {
4409           /* Mark the symbol as undefined, rather than as defined in
4410              the .plt section.  Leave the value if there were any
4411              relocations where pointer equality matters (this is a clue
4412              for the dynamic linker, to make function pointer
4413              comparisons work between an application and shared
4414              library), otherwise set it to zero.  If a function is only
4415              called from a binary, there is no need to slow down
4416              shared libraries because of that.  */
4417           sym->st_shndx = SHN_UNDEF;
4418           if (!h->pointer_equality_needed)
4419             sym->st_value = 0;
4420         }
4421     }
4422
4423   if (h->got.offset != (bfd_vma) -1
4424       && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h)->tls_type)
4425       && elf_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE)
4426     {
4427       Elf_Internal_Rela rela;
4428
4429       /* This symbol has an entry in the global offset table.  Set it
4430          up.  */
4431       if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
4432         abort ();
4433
4434       rela.r_offset = (htab->elf.sgot->output_section->vma
4435                        + htab->elf.sgot->output_offset
4436                        + (h->got.offset &~ (bfd_vma) 1));
4437
4438       /* If this is a static link, or it is a -Bsymbolic link and the
4439          symbol is defined locally or was forced to be local because
4440          of a version file, we just want to emit a RELATIVE reloc.
4441          The entry in the global offset table will already have been
4442          initialized in the relocate_section function.  */
4443       if (h->def_regular
4444           && h->type == STT_GNU_IFUNC)
4445         {
4446           if (info->shared)
4447             {
4448               /* Generate R_X86_64_GLOB_DAT.  */
4449               goto do_glob_dat;
4450             }
4451           else
4452             {
4453               asection *plt;
4454
4455               if (!h->pointer_equality_needed)
4456                 abort ();
4457
4458               /* For non-shared object, we can't use .got.plt, which
4459                  contains the real function addres if we need pointer
4460                  equality.  We load the GOT entry with the PLT entry.  */
4461               plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
4462               bfd_put_64 (output_bfd, (plt->output_section->vma
4463                                        + plt->output_offset
4464                                        + h->plt.offset),
4465                           htab->elf.sgot->contents + h->got.offset);
4466               return TRUE;
4467             }
4468         }
4469       else if (info->shared
4470                && SYMBOL_REFERENCES_LOCAL (info, h))
4471         {
4472           if (!h->def_regular)
4473             return FALSE;
4474           BFD_ASSERT((h->got.offset & 1) != 0);
4475           rela.r_info = htab->r_info (0, R_X86_64_RELATIVE);
4476           rela.r_addend = (h->root.u.def.value
4477                            + h->root.u.def.section->output_section->vma
4478                            + h->root.u.def.section->output_offset);
4479         }
4480       else
4481         {
4482           BFD_ASSERT((h->got.offset & 1) == 0);
4483 do_glob_dat:
4484           bfd_put_64 (output_bfd, (bfd_vma) 0,
4485                       htab->elf.sgot->contents + h->got.offset);
4486           rela.r_info = htab->r_info (h->dynindx, R_X86_64_GLOB_DAT);
4487           rela.r_addend = 0;
4488         }
4489
4490       elf_append_rela (output_bfd, htab->elf.srelgot, &rela);
4491     }
4492
4493   if (h->needs_copy)
4494     {
4495       Elf_Internal_Rela rela;
4496
4497       /* This symbol needs a copy reloc.  Set it up.  */
4498
4499       if (h->dynindx == -1
4500           || (h->root.type != bfd_link_hash_defined
4501               && h->root.type != bfd_link_hash_defweak)
4502           || htab->srelbss == NULL)
4503         abort ();
4504
4505       rela.r_offset = (h->root.u.def.value
4506                        + h->root.u.def.section->output_section->vma
4507                        + h->root.u.def.section->output_offset);
4508       rela.r_info = htab->r_info (h->dynindx, R_X86_64_COPY);
4509       rela.r_addend = 0;
4510       elf_append_rela (output_bfd, htab->srelbss, &rela);
4511     }
4512
4513   return TRUE;
4514 }
4515
4516 /* Finish up local dynamic symbol handling.  We set the contents of
4517    various dynamic sections here.  */
4518
4519 static bfd_boolean
4520 elf_x86_64_finish_local_dynamic_symbol (void **slot, void *inf)
4521 {
4522   struct elf_link_hash_entry *h
4523     = (struct elf_link_hash_entry *) *slot;
4524   struct bfd_link_info *info
4525     = (struct bfd_link_info *) inf;
4526
4527   return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
4528                                              info, h, NULL);
4529 }
4530
4531 /* Used to decide how to sort relocs in an optimal manner for the
4532    dynamic linker, before writing them out.  */
4533
4534 static enum elf_reloc_type_class
4535 elf_x86_64_reloc_type_class (const Elf_Internal_Rela *rela)
4536 {
4537   switch ((int) ELF32_R_TYPE (rela->r_info))
4538     {
4539     case R_X86_64_RELATIVE:
4540     case R_X86_64_RELATIVE64:
4541       return reloc_class_relative;
4542     case R_X86_64_JUMP_SLOT:
4543       return reloc_class_plt;
4544     case R_X86_64_COPY:
4545       return reloc_class_copy;
4546     default:
4547       return reloc_class_normal;
4548     }
4549 }
4550
4551 /* Finish up the dynamic sections.  */
4552
4553 static bfd_boolean
4554 elf_x86_64_finish_dynamic_sections (bfd *output_bfd,
4555                                     struct bfd_link_info *info)
4556 {
4557   struct elf_x86_64_link_hash_table *htab;
4558   bfd *dynobj;
4559   asection *sdyn;
4560   const struct elf_x86_64_backend_data *const abed
4561     = get_elf_x86_64_backend_data (output_bfd);
4562
4563   htab = elf_x86_64_hash_table (info);
4564   if (htab == NULL)
4565     return FALSE;
4566
4567   dynobj = htab->elf.dynobj;
4568   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4569
4570   if (htab->elf.dynamic_sections_created)
4571     {
4572       bfd_byte *dyncon, *dynconend;
4573       const struct elf_backend_data *bed;
4574       bfd_size_type sizeof_dyn;
4575
4576       if (sdyn == NULL || htab->elf.sgot == NULL)
4577         abort ();
4578
4579       bed = get_elf_backend_data (dynobj);
4580       sizeof_dyn = bed->s->sizeof_dyn;
4581       dyncon = sdyn->contents;
4582       dynconend = sdyn->contents + sdyn->size;
4583       for (; dyncon < dynconend; dyncon += sizeof_dyn)
4584         {
4585           Elf_Internal_Dyn dyn;
4586           asection *s;
4587
4588           (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
4589
4590           switch (dyn.d_tag)
4591             {
4592             default:
4593               continue;
4594
4595             case DT_PLTGOT:
4596               s = htab->elf.sgotplt;
4597               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4598               break;
4599
4600             case DT_JMPREL:
4601               dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
4602               break;
4603
4604             case DT_PLTRELSZ:
4605               s = htab->elf.srelplt->output_section;
4606               dyn.d_un.d_val = s->size;
4607               break;
4608
4609             case DT_RELASZ:
4610               /* The procedure linkage table relocs (DT_JMPREL) should
4611                  not be included in the overall relocs (DT_RELA).
4612                  Therefore, we override the DT_RELASZ entry here to
4613                  make it not include the JMPREL relocs.  Since the
4614                  linker script arranges for .rela.plt to follow all
4615                  other relocation sections, we don't have to worry
4616                  about changing the DT_RELA entry.  */
4617               if (htab->elf.srelplt != NULL)
4618                 {
4619                   s = htab->elf.srelplt->output_section;
4620                   dyn.d_un.d_val -= s->size;
4621                 }
4622               break;
4623
4624             case DT_TLSDESC_PLT:
4625               s = htab->elf.splt;
4626               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
4627                 + htab->tlsdesc_plt;
4628               break;
4629
4630             case DT_TLSDESC_GOT:
4631               s = htab->elf.sgot;
4632               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
4633                 + htab->tlsdesc_got;
4634               break;
4635             }
4636
4637           (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
4638         }
4639
4640       /* Fill in the special first entry in the procedure linkage table.  */
4641       if (htab->elf.splt && htab->elf.splt->size > 0)
4642         {
4643           /* Fill in the first entry in the procedure linkage table.  */
4644           memcpy (htab->elf.splt->contents,
4645                   abed->plt0_entry, abed->plt_entry_size);
4646           /* Add offset for pushq GOT+8(%rip), since the instruction
4647              uses 6 bytes subtract this value.  */
4648           bfd_put_32 (output_bfd,
4649                       (htab->elf.sgotplt->output_section->vma
4650                        + htab->elf.sgotplt->output_offset
4651                        + 8
4652                        - htab->elf.splt->output_section->vma
4653                        - htab->elf.splt->output_offset
4654                        - 6),
4655                       htab->elf.splt->contents + abed->plt0_got1_offset);
4656           /* Add offset for the PC-relative instruction accessing GOT+16,
4657              subtracting the offset to the end of that instruction.  */
4658           bfd_put_32 (output_bfd,
4659                       (htab->elf.sgotplt->output_section->vma
4660                        + htab->elf.sgotplt->output_offset
4661                        + 16
4662                        - htab->elf.splt->output_section->vma
4663                        - htab->elf.splt->output_offset
4664                        - abed->plt0_got2_insn_end),
4665                       htab->elf.splt->contents + abed->plt0_got2_offset);
4666
4667           elf_section_data (htab->elf.splt->output_section)
4668             ->this_hdr.sh_entsize = abed->plt_entry_size;
4669
4670           if (htab->tlsdesc_plt)
4671             {
4672               bfd_put_64 (output_bfd, (bfd_vma) 0,
4673                           htab->elf.sgot->contents + htab->tlsdesc_got);
4674
4675               memcpy (htab->elf.splt->contents + htab->tlsdesc_plt,
4676                       abed->plt0_entry, abed->plt_entry_size);
4677
4678               /* Add offset for pushq GOT+8(%rip), since the
4679                  instruction uses 6 bytes subtract this value.  */
4680               bfd_put_32 (output_bfd,
4681                           (htab->elf.sgotplt->output_section->vma
4682                            + htab->elf.sgotplt->output_offset
4683                            + 8
4684                            - htab->elf.splt->output_section->vma
4685                            - htab->elf.splt->output_offset
4686                            - htab->tlsdesc_plt
4687                            - 6),
4688                           htab->elf.splt->contents
4689                           + htab->tlsdesc_plt + abed->plt0_got1_offset);
4690           /* Add offset for the PC-relative instruction accessing GOT+TDG,
4691              where TGD stands for htab->tlsdesc_got, subtracting the offset
4692              to the end of that instruction.  */
4693               bfd_put_32 (output_bfd,
4694                           (htab->elf.sgot->output_section->vma
4695                            + htab->elf.sgot->output_offset
4696                            + htab->tlsdesc_got
4697                            - htab->elf.splt->output_section->vma
4698                            - htab->elf.splt->output_offset
4699                            - htab->tlsdesc_plt
4700                            - abed->plt0_got2_insn_end),
4701                           htab->elf.splt->contents
4702                           + htab->tlsdesc_plt + abed->plt0_got2_offset);
4703             }
4704         }
4705     }
4706
4707   if (htab->elf.sgotplt)
4708     {
4709       if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
4710         {
4711           (*_bfd_error_handler)
4712             (_("discarded output section: `%A'"), htab->elf.sgotplt);
4713           return FALSE;
4714         }
4715
4716       /* Fill in the first three entries in the global offset table.  */
4717       if (htab->elf.sgotplt->size > 0)
4718         {
4719           /* Set the first entry in the global offset table to the address of
4720              the dynamic section.  */
4721           if (sdyn == NULL)
4722             bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents);
4723           else
4724             bfd_put_64 (output_bfd,
4725                         sdyn->output_section->vma + sdyn->output_offset,
4726                         htab->elf.sgotplt->contents);
4727           /* Write GOT[1] and GOT[2], needed for the dynamic linker.  */
4728           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
4729           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + GOT_ENTRY_SIZE*2);
4730         }
4731
4732       elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize =
4733         GOT_ENTRY_SIZE;
4734     }
4735
4736   /* Adjust .eh_frame for .plt section.  */
4737   if (htab->plt_eh_frame != NULL
4738       && htab->plt_eh_frame->contents != NULL)
4739     {
4740       if (htab->elf.splt != NULL
4741           && htab->elf.splt->size != 0
4742           && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
4743           && htab->elf.splt->output_section != NULL
4744           && htab->plt_eh_frame->output_section != NULL)
4745         {
4746           bfd_vma plt_start = htab->elf.splt->output_section->vma;
4747           bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
4748                                    + htab->plt_eh_frame->output_offset
4749                                    + PLT_FDE_START_OFFSET;
4750           bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
4751                              htab->plt_eh_frame->contents
4752                              + PLT_FDE_START_OFFSET);
4753         }
4754       if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
4755         {
4756           if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
4757                                                  htab->plt_eh_frame,
4758                                                  htab->plt_eh_frame->contents))
4759             return FALSE;
4760         }
4761     }
4762
4763   if (htab->elf.sgot && htab->elf.sgot->size > 0)
4764     elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
4765       = GOT_ENTRY_SIZE;
4766
4767   /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols.  */
4768   htab_traverse (htab->loc_hash_table,
4769                  elf_x86_64_finish_local_dynamic_symbol,
4770                  info);
4771
4772   return TRUE;
4773 }
4774
4775 /* Return address for Ith PLT stub in section PLT, for relocation REL
4776    or (bfd_vma) -1 if it should not be included.  */
4777
4778 static bfd_vma
4779 elf_x86_64_plt_sym_val (bfd_vma i, const asection *plt,
4780                         const arelent *rel ATTRIBUTE_UNUSED)
4781 {
4782   return plt->vma + (i + 1) * GET_PLT_ENTRY_SIZE (plt->owner);
4783 }
4784
4785 /* Handle an x86-64 specific section when reading an object file.  This
4786    is called when elfcode.h finds a section with an unknown type.  */
4787
4788 static bfd_boolean
4789 elf_x86_64_section_from_shdr (bfd *abfd,
4790                                 Elf_Internal_Shdr *hdr,
4791                                 const char *name,
4792                                 int shindex)
4793 {
4794   if (hdr->sh_type != SHT_X86_64_UNWIND)
4795     return FALSE;
4796
4797   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
4798     return FALSE;
4799
4800   return TRUE;
4801 }
4802
4803 /* Hook called by the linker routine which adds symbols from an object
4804    file.  We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
4805    of .bss.  */
4806
4807 static bfd_boolean
4808 elf_x86_64_add_symbol_hook (bfd *abfd,
4809                             struct bfd_link_info *info,
4810                             Elf_Internal_Sym *sym,
4811                             const char **namep ATTRIBUTE_UNUSED,
4812                             flagword *flagsp ATTRIBUTE_UNUSED,
4813                             asection **secp,
4814                             bfd_vma *valp)
4815 {
4816   asection *lcomm;
4817
4818   switch (sym->st_shndx)
4819     {
4820     case SHN_X86_64_LCOMMON:
4821       lcomm = bfd_get_section_by_name (abfd, "LARGE_COMMON");
4822       if (lcomm == NULL)
4823         {
4824           lcomm = bfd_make_section_with_flags (abfd,
4825                                                "LARGE_COMMON",
4826                                                (SEC_ALLOC
4827                                                 | SEC_IS_COMMON
4828                                                 | SEC_LINKER_CREATED));
4829           if (lcomm == NULL)
4830             return FALSE;
4831           elf_section_flags (lcomm) |= SHF_X86_64_LARGE;
4832         }
4833       *secp = lcomm;
4834       *valp = sym->st_size;
4835       return TRUE;
4836     }
4837
4838   if ((abfd->flags & DYNAMIC) == 0
4839       && (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
4840           || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE))
4841     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
4842
4843   return TRUE;
4844 }
4845
4846
4847 /* Given a BFD section, try to locate the corresponding ELF section
4848    index.  */
4849
4850 static bfd_boolean
4851 elf_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
4852                                          asection *sec, int *index_return)
4853 {
4854   if (sec == &_bfd_elf_large_com_section)
4855     {
4856       *index_return = SHN_X86_64_LCOMMON;
4857       return TRUE;
4858     }
4859   return FALSE;
4860 }
4861
4862 /* Process a symbol.  */
4863
4864 static void
4865 elf_x86_64_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
4866                               asymbol *asym)
4867 {
4868   elf_symbol_type *elfsym = (elf_symbol_type *) asym;
4869
4870   switch (elfsym->internal_elf_sym.st_shndx)
4871     {
4872     case SHN_X86_64_LCOMMON:
4873       asym->section = &_bfd_elf_large_com_section;
4874       asym->value = elfsym->internal_elf_sym.st_size;
4875       /* Common symbol doesn't set BSF_GLOBAL.  */
4876       asym->flags &= ~BSF_GLOBAL;
4877       break;
4878     }
4879 }
4880
4881 static bfd_boolean
4882 elf_x86_64_common_definition (Elf_Internal_Sym *sym)
4883 {
4884   return (sym->st_shndx == SHN_COMMON
4885           || sym->st_shndx == SHN_X86_64_LCOMMON);
4886 }
4887
4888 static unsigned int
4889 elf_x86_64_common_section_index (asection *sec)
4890 {
4891   if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
4892     return SHN_COMMON;
4893   else
4894     return SHN_X86_64_LCOMMON;
4895 }
4896
4897 static asection *
4898 elf_x86_64_common_section (asection *sec)
4899 {
4900   if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
4901     return bfd_com_section_ptr;
4902   else
4903     return &_bfd_elf_large_com_section;
4904 }
4905
4906 static bfd_boolean
4907 elf_x86_64_merge_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
4908                          struct elf_link_hash_entry **sym_hash ATTRIBUTE_UNUSED,
4909                          struct elf_link_hash_entry *h,
4910                          Elf_Internal_Sym *sym,
4911                          asection **psec,
4912                          bfd_vma *pvalue ATTRIBUTE_UNUSED,
4913                          unsigned int *pold_alignment ATTRIBUTE_UNUSED,
4914                          bfd_boolean *skip ATTRIBUTE_UNUSED,
4915                          bfd_boolean *override ATTRIBUTE_UNUSED,
4916                          bfd_boolean *type_change_ok ATTRIBUTE_UNUSED,
4917                          bfd_boolean *size_change_ok ATTRIBUTE_UNUSED,
4918                          bfd_boolean *newdyn ATTRIBUTE_UNUSED,
4919                          bfd_boolean *newdef,
4920                          bfd_boolean *newdyncommon ATTRIBUTE_UNUSED,
4921                          bfd_boolean *newweak ATTRIBUTE_UNUSED,
4922                          bfd *abfd ATTRIBUTE_UNUSED,
4923                          asection **sec,
4924                          bfd_boolean *olddyn ATTRIBUTE_UNUSED,
4925                          bfd_boolean *olddef,
4926                          bfd_boolean *olddyncommon ATTRIBUTE_UNUSED,
4927                          bfd_boolean *oldweak ATTRIBUTE_UNUSED,
4928                          bfd *oldbfd,
4929                          asection **oldsec)
4930 {
4931   /* A normal common symbol and a large common symbol result in a
4932      normal common symbol.  We turn the large common symbol into a
4933      normal one.  */
4934   if (!*olddef
4935       && h->root.type == bfd_link_hash_common
4936       && !*newdef
4937       && bfd_is_com_section (*sec)
4938       && *oldsec != *sec)
4939     {
4940       if (sym->st_shndx == SHN_COMMON
4941           && (elf_section_flags (*oldsec) & SHF_X86_64_LARGE) != 0)
4942         {
4943           h->root.u.c.p->section
4944             = bfd_make_section_old_way (oldbfd, "COMMON");
4945           h->root.u.c.p->section->flags = SEC_ALLOC;
4946         }
4947       else if (sym->st_shndx == SHN_X86_64_LCOMMON
4948                && (elf_section_flags (*oldsec) & SHF_X86_64_LARGE) == 0)
4949         *psec = *sec = bfd_com_section_ptr;
4950     }
4951
4952   return TRUE;
4953 }
4954
4955 static int
4956 elf_x86_64_additional_program_headers (bfd *abfd,
4957                                        struct bfd_link_info *info ATTRIBUTE_UNUSED)
4958 {
4959   asection *s;
4960   int count = 0;
4961
4962   /* Check to see if we need a large readonly segment.  */
4963   s = bfd_get_section_by_name (abfd, ".lrodata");
4964   if (s && (s->flags & SEC_LOAD))
4965     count++;
4966
4967   /* Check to see if we need a large data segment.  Since .lbss sections
4968      is placed right after the .bss section, there should be no need for
4969      a large data segment just because of .lbss.  */
4970   s = bfd_get_section_by_name (abfd, ".ldata");
4971   if (s && (s->flags & SEC_LOAD))
4972     count++;
4973
4974   return count;
4975 }
4976
4977 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
4978
4979 static bfd_boolean
4980 elf_x86_64_hash_symbol (struct elf_link_hash_entry *h)
4981 {
4982   if (h->plt.offset != (bfd_vma) -1
4983       && !h->def_regular
4984       && !h->pointer_equality_needed)
4985     return FALSE;
4986
4987   return _bfd_elf_hash_symbol (h);
4988 }
4989
4990 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
4991
4992 static bfd_boolean
4993 elf_x86_64_relocs_compatible (const bfd_target *input,
4994                               const bfd_target *output)
4995 {
4996   return ((xvec_get_elf_backend_data (input)->s->elfclass
4997            == xvec_get_elf_backend_data (output)->s->elfclass)
4998           && _bfd_elf_relocs_compatible (input, output));
4999 }
5000
5001 static const struct bfd_elf_special_section
5002   elf_x86_64_special_sections[]=
5003 {
5004   { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5005   { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
5006   { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE},
5007   { STRING_COMMA_LEN (".lbss"),            -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5008   { STRING_COMMA_LEN (".ldata"),           -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
5009   { STRING_COMMA_LEN (".lrodata"),         -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
5010   { NULL,                       0,          0, 0,            0 }
5011 };
5012
5013 #define TARGET_LITTLE_SYM                   bfd_elf64_x86_64_vec
5014 #define TARGET_LITTLE_NAME                  "elf64-x86-64"
5015 #define ELF_ARCH                            bfd_arch_i386
5016 #define ELF_TARGET_ID                       X86_64_ELF_DATA
5017 #define ELF_MACHINE_CODE                    EM_X86_64
5018 #define ELF_MAXPAGESIZE                     0x200000
5019 #define ELF_MINPAGESIZE                     0x1000
5020 #define ELF_COMMONPAGESIZE                  0x1000
5021
5022 #define elf_backend_can_gc_sections         1
5023 #define elf_backend_can_refcount            1
5024 #define elf_backend_want_got_plt            1
5025 #define elf_backend_plt_readonly            1
5026 #define elf_backend_want_plt_sym            0
5027 #define elf_backend_got_header_size         (GOT_ENTRY_SIZE*3)
5028 #define elf_backend_rela_normal             1
5029 #define elf_backend_plt_alignment           4
5030
5031 #define elf_info_to_howto                   elf_x86_64_info_to_howto
5032
5033 #define bfd_elf64_bfd_link_hash_table_create \
5034   elf_x86_64_link_hash_table_create
5035 #define bfd_elf64_bfd_link_hash_table_free \
5036   elf_x86_64_link_hash_table_free
5037 #define bfd_elf64_bfd_reloc_type_lookup     elf_x86_64_reloc_type_lookup
5038 #define bfd_elf64_bfd_reloc_name_lookup \
5039   elf_x86_64_reloc_name_lookup
5040
5041 #define elf_backend_adjust_dynamic_symbol   elf_x86_64_adjust_dynamic_symbol
5042 #define elf_backend_relocs_compatible       elf_x86_64_relocs_compatible
5043 #define elf_backend_check_relocs            elf_x86_64_check_relocs
5044 #define elf_backend_copy_indirect_symbol    elf_x86_64_copy_indirect_symbol
5045 #define elf_backend_create_dynamic_sections elf_x86_64_create_dynamic_sections
5046 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
5047 #define elf_backend_finish_dynamic_symbol   elf_x86_64_finish_dynamic_symbol
5048 #define elf_backend_gc_mark_hook            elf_x86_64_gc_mark_hook
5049 #define elf_backend_gc_sweep_hook           elf_x86_64_gc_sweep_hook
5050 #define elf_backend_grok_prstatus           elf_x86_64_grok_prstatus
5051 #define elf_backend_grok_psinfo             elf_x86_64_grok_psinfo
5052 #ifdef CORE_HEADER
5053 #define elf_backend_write_core_note         elf_x86_64_write_core_note
5054 #endif
5055 #define elf_backend_reloc_type_class        elf_x86_64_reloc_type_class
5056 #define elf_backend_relocate_section        elf_x86_64_relocate_section
5057 #define elf_backend_size_dynamic_sections   elf_x86_64_size_dynamic_sections
5058 #define elf_backend_always_size_sections    elf_x86_64_always_size_sections
5059 #define elf_backend_init_index_section      _bfd_elf_init_1_index_section
5060 #define elf_backend_plt_sym_val             elf_x86_64_plt_sym_val
5061 #define elf_backend_object_p                elf64_x86_64_elf_object_p
5062 #define bfd_elf64_mkobject                  elf_x86_64_mkobject
5063
5064 #define elf_backend_section_from_shdr \
5065         elf_x86_64_section_from_shdr
5066
5067 #define elf_backend_section_from_bfd_section \
5068   elf_x86_64_elf_section_from_bfd_section
5069 #define elf_backend_add_symbol_hook \
5070   elf_x86_64_add_symbol_hook
5071 #define elf_backend_symbol_processing \
5072   elf_x86_64_symbol_processing
5073 #define elf_backend_common_section_index \
5074   elf_x86_64_common_section_index
5075 #define elf_backend_common_section \
5076   elf_x86_64_common_section
5077 #define elf_backend_common_definition \
5078   elf_x86_64_common_definition
5079 #define elf_backend_merge_symbol \
5080   elf_x86_64_merge_symbol
5081 #define elf_backend_special_sections \
5082   elf_x86_64_special_sections
5083 #define elf_backend_additional_program_headers \
5084   elf_x86_64_additional_program_headers
5085 #define elf_backend_hash_symbol \
5086   elf_x86_64_hash_symbol
5087
5088 #define elf_backend_post_process_headers  _bfd_elf_set_osabi
5089
5090 #include "elf64-target.h"
5091
5092 /* FreeBSD support.  */
5093
5094 #undef  TARGET_LITTLE_SYM
5095 #define TARGET_LITTLE_SYM                   bfd_elf64_x86_64_freebsd_vec
5096 #undef  TARGET_LITTLE_NAME
5097 #define TARGET_LITTLE_NAME                  "elf64-x86-64-freebsd"
5098
5099 #undef  ELF_OSABI
5100 #define ELF_OSABI                           ELFOSABI_FREEBSD
5101
5102 #undef  elf64_bed
5103 #define elf64_bed elf64_x86_64_fbsd_bed
5104
5105 #include "elf64-target.h"
5106
5107 /* Solaris 2 support.  */
5108
5109 #undef  TARGET_LITTLE_SYM
5110 #define TARGET_LITTLE_SYM                   bfd_elf64_x86_64_sol2_vec
5111 #undef  TARGET_LITTLE_NAME
5112 #define TARGET_LITTLE_NAME                  "elf64-x86-64-sol2"
5113
5114 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
5115    objects won't be recognized.  */
5116 #undef ELF_OSABI
5117
5118 #undef  elf64_bed
5119 #define elf64_bed                           elf64_x86_64_sol2_bed
5120
5121 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
5122    boundary.  */
5123 #undef elf_backend_static_tls_alignment
5124 #define elf_backend_static_tls_alignment    16
5125
5126 /* The Solaris 2 ABI requires a plt symbol on all platforms.
5127
5128    Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
5129    File, p.63.  */
5130 #undef elf_backend_want_plt_sym
5131 #define elf_backend_want_plt_sym            1
5132
5133 #include "elf64-target.h"
5134
5135 /* Native Client support.  */
5136
5137 #undef  TARGET_LITTLE_SYM
5138 #define TARGET_LITTLE_SYM               bfd_elf64_x86_64_nacl_vec
5139 #undef  TARGET_LITTLE_NAME
5140 #define TARGET_LITTLE_NAME              "elf64-x86-64-nacl"
5141 #undef  elf64_bed
5142 #define elf64_bed                       elf64_x86_64_nacl_bed
5143
5144 #undef  ELF_MAXPAGESIZE
5145 #undef  ELF_MINPAGESIZE
5146 #undef  ELF_COMMONPAGESIZE
5147 #define ELF_MAXPAGESIZE                 0x10000
5148 #define ELF_MINPAGESIZE                 0x10000
5149 #define ELF_COMMONPAGESIZE              0x10000
5150
5151 /* Restore defaults.  */
5152 #undef  ELF_OSABI
5153 #undef  elf_backend_static_tls_alignment
5154 #undef  elf_backend_want_plt_sym
5155 #define elf_backend_want_plt_sym        0
5156
5157 /* NaCl uses substantially different PLT entries for the same effects.  */
5158
5159 #undef  elf_backend_plt_alignment
5160 #define elf_backend_plt_alignment       5
5161 #define NACL_PLT_ENTRY_SIZE             64
5162 #define NACLMASK                        0xe0 /* 32-byte alignment mask.  */
5163
5164 static const bfd_byte elf_x86_64_nacl_plt0_entry[NACL_PLT_ENTRY_SIZE] =
5165   {
5166     0xff, 0x35, 8, 0, 0, 0,             /* pushq GOT+8(%rip)            */
5167     0x4c, 0x8b, 0x1d, 16, 0, 0, 0,      /* mov GOT+16(%rip), %r11       */
5168     0x41, 0x83, 0xe3, NACLMASK,         /* and $-32, %r11d              */
5169     0x4d, 0x01, 0xfb,                   /* add %r15, %r11               */
5170     0x41, 0xff, 0xe3,                   /* jmpq *%r11                   */
5171
5172     /* 9-byte nop sequence to pad out to the next 32-byte boundary.  */
5173     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopl %cs:0x0(%rax,%rax,1) */
5174
5175     /* 32 bytes of nop to pad out to the standard size.  */
5176     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data32 prefixes    */
5177     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5178     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data32 prefixes    */
5179     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5180     0x66,                                  /* excess data32 prefix      */
5181     0x90                                   /* nop */
5182   };
5183
5184 static const bfd_byte elf_x86_64_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
5185   {
5186     0x4c, 0x8b, 0x1d, 0, 0, 0, 0,       /* mov name@GOTPCREL(%rip),%r11 */
5187     0x41, 0x83, 0xe3, NACLMASK,         /* and $-32, %r11d              */
5188     0x4d, 0x01, 0xfb,                   /* add %r15, %r11               */
5189     0x41, 0xff, 0xe3,                   /* jmpq *%r11                   */
5190
5191     /* 15-byte nop sequence to pad out to the next 32-byte boundary.  */
5192     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data32 prefixes    */
5193     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5194
5195     /* Lazy GOT entries point here (32-byte aligned).  */
5196     0x68,                 /* pushq immediate */
5197     0, 0, 0, 0,           /* replaced with index into relocation table.  */
5198     0xe9,                 /* jmp relative */
5199     0, 0, 0, 0,           /* replaced with offset to start of .plt0.  */
5200
5201     /* 22 bytes of nop to pad out to the standard size.  */
5202     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data32 prefixes    */
5203     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
5204     0x0f, 0x1f, 0x80, 0, 0, 0, 0,          /* nopl 0x0(%rax)            */
5205   };
5206
5207 /* .eh_frame covering the .plt section.  */
5208
5209 static const bfd_byte elf_x86_64_nacl_eh_frame_plt[] =
5210   {
5211 #if (PLT_CIE_LENGTH != 20                               \
5212      || PLT_FDE_LENGTH != 36                            \
5213      || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8  \
5214      || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
5215 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
5216 #endif
5217     PLT_CIE_LENGTH, 0, 0, 0,    /* CIE length */
5218     0, 0, 0, 0,                 /* CIE ID */
5219     1,                          /* CIE version */
5220     'z', 'R', 0,                /* Augmentation string */
5221     1,                          /* Code alignment factor */
5222     0x78,                       /* Data alignment factor */
5223     16,                         /* Return address column */
5224     1,                          /* Augmentation size */
5225     DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
5226     DW_CFA_def_cfa, 7, 8,       /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
5227     DW_CFA_offset + 16, 1,      /* DW_CFA_offset: r16 (rip) at cfa-8 */
5228     DW_CFA_nop, DW_CFA_nop,
5229
5230     PLT_FDE_LENGTH, 0, 0, 0,    /* FDE length */
5231     PLT_CIE_LENGTH + 8, 0, 0, 0,/* CIE pointer */
5232     0, 0, 0, 0,                 /* R_X86_64_PC32 .plt goes here */
5233     0, 0, 0, 0,                 /* .plt size goes here */
5234     0,                          /* Augmentation size */
5235     DW_CFA_def_cfa_offset, 16,  /* DW_CFA_def_cfa_offset: 16 */
5236     DW_CFA_advance_loc + 6,     /* DW_CFA_advance_loc: 6 to __PLT__+6 */
5237     DW_CFA_def_cfa_offset, 24,  /* DW_CFA_def_cfa_offset: 24 */
5238     DW_CFA_advance_loc + 58,    /* DW_CFA_advance_loc: 58 to __PLT__+64 */
5239     DW_CFA_def_cfa_expression,  /* DW_CFA_def_cfa_expression */
5240     13,                         /* Block length */
5241     DW_OP_breg7, 8,             /* DW_OP_breg7 (rsp): 8 */
5242     DW_OP_breg16, 0,            /* DW_OP_breg16 (rip): 0 */
5243     DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
5244     DW_OP_lit3, DW_OP_shl, DW_OP_plus,
5245     DW_CFA_nop, DW_CFA_nop
5246   };
5247
5248 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed =
5249   {
5250     elf_x86_64_nacl_plt0_entry,              /* plt0_entry */
5251     elf_x86_64_nacl_plt_entry,               /* plt_entry */
5252     NACL_PLT_ENTRY_SIZE,                     /* plt_entry_size */
5253     2,                                       /* plt0_got1_offset */
5254     9,                                       /* plt0_got2_offset */
5255     13,                                      /* plt0_got2_insn_end */
5256     3,                                       /* plt_got_offset */
5257     33,                                      /* plt_reloc_offset */
5258     38,                                      /* plt_plt_offset */
5259     7,                                       /* plt_got_insn_size */
5260     42,                                      /* plt_plt_insn_end */
5261     32,                                      /* plt_lazy_offset */
5262     elf_x86_64_nacl_eh_frame_plt,            /* eh_frame_plt */
5263     sizeof (elf_x86_64_nacl_eh_frame_plt),   /* eh_frame_plt_size */
5264   };
5265
5266 #undef  elf_backend_arch_data
5267 #define elf_backend_arch_data   &elf_x86_64_nacl_arch_bed
5268
5269 #undef  elf_backend_modify_segment_map
5270 #define elf_backend_modify_segment_map          nacl_modify_segment_map
5271 #undef  elf_backend_modify_program_headers
5272 #define elf_backend_modify_program_headers      nacl_modify_program_headers
5273
5274 #include "elf64-target.h"
5275
5276 /* Native Client x32 support.  */
5277
5278 #undef  TARGET_LITTLE_SYM
5279 #define TARGET_LITTLE_SYM               bfd_elf32_x86_64_nacl_vec
5280 #undef  TARGET_LITTLE_NAME
5281 #define TARGET_LITTLE_NAME              "elf32-x86-64-nacl"
5282 #undef  elf32_bed
5283 #define elf32_bed                       elf32_x86_64_nacl_bed
5284
5285 #define bfd_elf32_bfd_link_hash_table_create \
5286   elf_x86_64_link_hash_table_create
5287 #define bfd_elf32_bfd_link_hash_table_free \
5288   elf_x86_64_link_hash_table_free
5289 #define bfd_elf32_bfd_reloc_type_lookup \
5290   elf_x86_64_reloc_type_lookup
5291 #define bfd_elf32_bfd_reloc_name_lookup \
5292   elf_x86_64_reloc_name_lookup
5293 #define bfd_elf32_mkobject \
5294   elf_x86_64_mkobject
5295
5296 #undef elf_backend_object_p
5297 #define elf_backend_object_p \
5298   elf32_x86_64_elf_object_p
5299
5300 #undef elf_backend_bfd_from_remote_memory
5301 #define elf_backend_bfd_from_remote_memory \
5302   _bfd_elf32_bfd_from_remote_memory
5303
5304 #undef elf_backend_size_info
5305 #define elf_backend_size_info \
5306   _bfd_elf32_size_info
5307
5308 #include "elf32-target.h"
5309
5310 /* Restore defaults.  */
5311 #undef  elf_backend_object_p
5312 #define elf_backend_object_p                elf64_x86_64_elf_object_p
5313 #undef  elf_backend_bfd_from_remote_memory
5314 #undef  elf_backend_size_info
5315 #undef  elf_backend_modify_segment_map
5316 #undef  elf_backend_modify_program_headers
5317
5318 /* Intel L1OM support.  */
5319
5320 static bfd_boolean
5321 elf64_l1om_elf_object_p (bfd *abfd)
5322 {
5323   /* Set the right machine number for an L1OM elf64 file.  */
5324   bfd_default_set_arch_mach (abfd, bfd_arch_l1om, bfd_mach_l1om);
5325   return TRUE;
5326 }
5327
5328 #undef  TARGET_LITTLE_SYM
5329 #define TARGET_LITTLE_SYM                   bfd_elf64_l1om_vec
5330 #undef  TARGET_LITTLE_NAME
5331 #define TARGET_LITTLE_NAME                  "elf64-l1om"
5332 #undef ELF_ARCH
5333 #define ELF_ARCH                            bfd_arch_l1om
5334
5335 #undef  ELF_MACHINE_CODE
5336 #define ELF_MACHINE_CODE                    EM_L1OM
5337
5338 #undef  ELF_OSABI
5339
5340 #undef  elf64_bed
5341 #define elf64_bed elf64_l1om_bed
5342
5343 #undef elf_backend_object_p
5344 #define elf_backend_object_p                elf64_l1om_elf_object_p
5345
5346 /* Restore defaults.  */
5347 #undef  ELF_MAXPAGESIZE
5348 #undef  ELF_MINPAGESIZE
5349 #undef  ELF_COMMONPAGESIZE
5350 #define ELF_MAXPAGESIZE                 0x200000
5351 #define ELF_MINPAGESIZE                 0x1000
5352 #define ELF_COMMONPAGESIZE              0x1000
5353 #undef  elf_backend_plt_alignment
5354 #define elf_backend_plt_alignment       4
5355 #undef  elf_backend_arch_data
5356 #define elf_backend_arch_data   &elf_x86_64_arch_bed
5357
5358 #include "elf64-target.h"
5359
5360 /* FreeBSD L1OM support.  */
5361
5362 #undef  TARGET_LITTLE_SYM
5363 #define TARGET_LITTLE_SYM                   bfd_elf64_l1om_freebsd_vec
5364 #undef  TARGET_LITTLE_NAME
5365 #define TARGET_LITTLE_NAME                  "elf64-l1om-freebsd"
5366
5367 #undef  ELF_OSABI
5368 #define ELF_OSABI                           ELFOSABI_FREEBSD
5369
5370 #undef  elf64_bed
5371 #define elf64_bed elf64_l1om_fbsd_bed
5372
5373 #include "elf64-target.h"
5374
5375 /* Intel K1OM support.  */
5376
5377 static bfd_boolean
5378 elf64_k1om_elf_object_p (bfd *abfd)
5379 {
5380   /* Set the right machine number for an K1OM elf64 file.  */
5381   bfd_default_set_arch_mach (abfd, bfd_arch_k1om, bfd_mach_k1om);
5382   return TRUE;
5383 }
5384
5385 #undef  TARGET_LITTLE_SYM
5386 #define TARGET_LITTLE_SYM                   bfd_elf64_k1om_vec
5387 #undef  TARGET_LITTLE_NAME
5388 #define TARGET_LITTLE_NAME                  "elf64-k1om"
5389 #undef ELF_ARCH
5390 #define ELF_ARCH                            bfd_arch_k1om
5391
5392 #undef  ELF_MACHINE_CODE
5393 #define ELF_MACHINE_CODE                    EM_K1OM
5394
5395 #undef  ELF_OSABI
5396
5397 #undef  elf64_bed
5398 #define elf64_bed elf64_k1om_bed
5399
5400 #undef elf_backend_object_p
5401 #define elf_backend_object_p                elf64_k1om_elf_object_p
5402
5403 #undef  elf_backend_static_tls_alignment
5404
5405 #undef elf_backend_want_plt_sym
5406 #define elf_backend_want_plt_sym            0
5407
5408 #include "elf64-target.h"
5409
5410 /* FreeBSD K1OM support.  */
5411
5412 #undef  TARGET_LITTLE_SYM
5413 #define TARGET_LITTLE_SYM                   bfd_elf64_k1om_freebsd_vec
5414 #undef  TARGET_LITTLE_NAME
5415 #define TARGET_LITTLE_NAME                  "elf64-k1om-freebsd"
5416
5417 #undef  ELF_OSABI
5418 #define ELF_OSABI                           ELFOSABI_FREEBSD
5419
5420 #undef  elf64_bed
5421 #define elf64_bed elf64_k1om_fbsd_bed
5422
5423 #include "elf64-target.h"
5424
5425 /* 32bit x86-64 support.  */
5426
5427 #undef  TARGET_LITTLE_SYM
5428 #define TARGET_LITTLE_SYM                   bfd_elf32_x86_64_vec
5429 #undef  TARGET_LITTLE_NAME
5430 #define TARGET_LITTLE_NAME                  "elf32-x86-64"
5431 #undef  elf32_bed
5432
5433 #undef ELF_ARCH
5434 #define ELF_ARCH                            bfd_arch_i386
5435
5436 #undef  ELF_MACHINE_CODE
5437 #define ELF_MACHINE_CODE                    EM_X86_64
5438
5439 #undef  ELF_OSABI
5440
5441 #undef elf_backend_object_p
5442 #define elf_backend_object_p \
5443   elf32_x86_64_elf_object_p
5444
5445 #undef elf_backend_bfd_from_remote_memory
5446 #define elf_backend_bfd_from_remote_memory \
5447   _bfd_elf32_bfd_from_remote_memory
5448
5449 #undef elf_backend_size_info
5450 #define elf_backend_size_info \
5451   _bfd_elf32_size_info
5452
5453 #include "elf32-target.h"