bfd/elf64-x86-64.c

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