bfd/elf64-x86-64.c

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