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