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