bfd/elf64-x86-64.c

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