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