bfd/elf64-x86-64.c

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