bfd/elf64-x86-64.c

   1 /* X86-64 specific support for ELF
   2    Copyright (C) 2000-2017 Free Software Foundation, Inc.
   3    Contributed by Jan Hubicka <jh@suse.cz>.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "bfdlink.h"
  25 #include "libbfd.h"
  26 #include "elf-bfd.h"
  27 #include "elf-nacl.h"
  28 #include "bfd_stdint.h"
  29 #include "objalloc.h"
  30 #include "hashtab.h"
  31 #include "dwarf2.h"
  32 #include "libiberty.h"
  33
  34 #include "opcode/i386.h"
  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, 3, 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   HOWTO(R_X86_64_SIZE32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
 151         bfd_elf_generic_reloc, "R_X86_64_SIZE32", FALSE, 0xffffffff, 0xffffffff,
 152         FALSE),
 153   HOWTO(R_X86_64_SIZE64, 0, 4, 64, FALSE, 0, complain_overflow_unsigned,
 154         bfd_elf_generic_reloc, "R_X86_64_SIZE64", FALSE, MINUS_ONE, MINUS_ONE,
 155         FALSE),
 156   HOWTO(R_X86_64_GOTPC32_TLSDESC, 0, 2, 32, TRUE, 0,
 157         complain_overflow_bitfield, bfd_elf_generic_reloc,
 158         "R_X86_64_GOTPC32_TLSDESC",
 159         FALSE, 0xffffffff, 0xffffffff, TRUE),
 160   HOWTO(R_X86_64_TLSDESC_CALL, 0, 0, 0, FALSE, 0,
 161         complain_overflow_dont, bfd_elf_generic_reloc,
 162         "R_X86_64_TLSDESC_CALL",
 163         FALSE, 0, 0, FALSE),
 164   HOWTO(R_X86_64_TLSDESC, 0, 4, 64, FALSE, 0,
 165         complain_overflow_bitfield, bfd_elf_generic_reloc,
 166         "R_X86_64_TLSDESC",
 167         FALSE, MINUS_ONE, MINUS_ONE, FALSE),
 168   HOWTO(R_X86_64_IRELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 169         bfd_elf_generic_reloc, "R_X86_64_IRELATIVE", FALSE, MINUS_ONE,
 170         MINUS_ONE, FALSE),
 171   HOWTO(R_X86_64_RELATIVE64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 172         bfd_elf_generic_reloc, "R_X86_64_RELATIVE64", FALSE, MINUS_ONE,
 173         MINUS_ONE, FALSE),
 174   HOWTO(R_X86_64_PC32_BND, 0, 2, 32, TRUE, 0, complain_overflow_signed,
 175         bfd_elf_generic_reloc, "R_X86_64_PC32_BND", FALSE, 0xffffffff, 0xffffffff,
 176         TRUE),
 177   HOWTO(R_X86_64_PLT32_BND, 0, 2, 32, TRUE, 0, complain_overflow_signed,
 178         bfd_elf_generic_reloc, "R_X86_64_PLT32_BND", FALSE, 0xffffffff, 0xffffffff,
 179         TRUE),
 180   HOWTO(R_X86_64_GOTPCRELX, 0, 2, 32, TRUE, 0, complain_overflow_signed,
 181         bfd_elf_generic_reloc, "R_X86_64_GOTPCRELX", FALSE, 0xffffffff,
 182         0xffffffff, TRUE),
 183   HOWTO(R_X86_64_REX_GOTPCRELX, 0, 2, 32, TRUE, 0, complain_overflow_signed,
 184         bfd_elf_generic_reloc, "R_X86_64_REX_GOTPCRELX", FALSE, 0xffffffff,
 185         0xffffffff, TRUE),
 186
 187   /* We have a gap in the reloc numbers here.
 188      R_X86_64_standard counts the number up to this point, and
 189      R_X86_64_vt_offset is the value to subtract from a reloc type of
 190      R_X86_64_GNU_VT* to form an index into this table.  */
 191 #define R_X86_64_standard (R_X86_64_REX_GOTPCRELX + 1)
 192 #define R_X86_64_vt_offset (R_X86_64_GNU_VTINHERIT - R_X86_64_standard)
 193
 194 /* GNU extension to record C++ vtable hierarchy.  */
 195   HOWTO (R_X86_64_GNU_VTINHERIT, 0, 4, 0, FALSE, 0, complain_overflow_dont,
 196          NULL, "R_X86_64_GNU_VTINHERIT", FALSE, 0, 0, FALSE),
 197
 198 /* GNU extension to record C++ vtable member usage.  */
 199   HOWTO (R_X86_64_GNU_VTENTRY, 0, 4, 0, FALSE, 0, complain_overflow_dont,
 200          _bfd_elf_rel_vtable_reloc_fn, "R_X86_64_GNU_VTENTRY", FALSE, 0, 0,
 201          FALSE),
 202
 203 /* Use complain_overflow_bitfield on R_X86_64_32 for x32.  */
 204   HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 205         bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
 206         FALSE)
 207 };
 208
 209 #define IS_X86_64_PCREL_TYPE(TYPE)      \
 210   (   ((TYPE) == R_X86_64_PC8)          \
 211    || ((TYPE) == R_X86_64_PC16)         \
 212    || ((TYPE) == R_X86_64_PC32)         \
 213    || ((TYPE) == R_X86_64_PC32_BND)     \
 214    || ((TYPE) == R_X86_64_PC64))
 215
 216 /* Map BFD relocs to the x86_64 elf relocs.  */
 217 struct elf_reloc_map
 218 {
 219   bfd_reloc_code_real_type bfd_reloc_val;
 220   unsigned char elf_reloc_val;
 221 };
 222
 223 static const struct elf_reloc_map x86_64_reloc_map[] =
 224 {
 225   { BFD_RELOC_NONE,             R_X86_64_NONE, },
 226   { BFD_RELOC_64,               R_X86_64_64,   },
 227   { BFD_RELOC_32_PCREL,         R_X86_64_PC32, },
 228   { BFD_RELOC_X86_64_GOT32,     R_X86_64_GOT32,},
 229   { BFD_RELOC_X86_64_PLT32,     R_X86_64_PLT32,},
 230   { BFD_RELOC_X86_64_COPY,      R_X86_64_COPY, },
 231   { BFD_RELOC_X86_64_GLOB_DAT,  R_X86_64_GLOB_DAT, },
 232   { BFD_RELOC_X86_64_JUMP_SLOT, R_X86_64_JUMP_SLOT, },
 233   { BFD_RELOC_X86_64_RELATIVE,  R_X86_64_RELATIVE, },
 234   { BFD_RELOC_X86_64_GOTPCREL,  R_X86_64_GOTPCREL, },
 235   { BFD_RELOC_32,               R_X86_64_32, },
 236   { BFD_RELOC_X86_64_32S,       R_X86_64_32S, },
 237   { BFD_RELOC_16,               R_X86_64_16, },
 238   { BFD_RELOC_16_PCREL,         R_X86_64_PC16, },
 239   { BFD_RELOC_8,                R_X86_64_8, },
 240   { BFD_RELOC_8_PCREL,          R_X86_64_PC8, },
 241   { BFD_RELOC_X86_64_DTPMOD64,  R_X86_64_DTPMOD64, },
 242   { BFD_RELOC_X86_64_DTPOFF64,  R_X86_64_DTPOFF64, },
 243   { BFD_RELOC_X86_64_TPOFF64,   R_X86_64_TPOFF64, },
 244   { BFD_RELOC_X86_64_TLSGD,     R_X86_64_TLSGD, },
 245   { BFD_RELOC_X86_64_TLSLD,     R_X86_64_TLSLD, },
 246   { BFD_RELOC_X86_64_DTPOFF32,  R_X86_64_DTPOFF32, },
 247   { BFD_RELOC_X86_64_GOTTPOFF,  R_X86_64_GOTTPOFF, },
 248   { BFD_RELOC_X86_64_TPOFF32,   R_X86_64_TPOFF32, },
 249   { BFD_RELOC_64_PCREL,         R_X86_64_PC64, },
 250   { BFD_RELOC_X86_64_GOTOFF64,  R_X86_64_GOTOFF64, },
 251   { BFD_RELOC_X86_64_GOTPC32,   R_X86_64_GOTPC32, },
 252   { BFD_RELOC_X86_64_GOT64,     R_X86_64_GOT64, },
 253   { BFD_RELOC_X86_64_GOTPCREL64,R_X86_64_GOTPCREL64, },
 254   { BFD_RELOC_X86_64_GOTPC64,   R_X86_64_GOTPC64, },
 255   { BFD_RELOC_X86_64_GOTPLT64,  R_X86_64_GOTPLT64, },
 256   { BFD_RELOC_X86_64_PLTOFF64,  R_X86_64_PLTOFF64, },
 257   { BFD_RELOC_SIZE32,           R_X86_64_SIZE32, },
 258   { BFD_RELOC_SIZE64,           R_X86_64_SIZE64, },
 259   { BFD_RELOC_X86_64_GOTPC32_TLSDESC, R_X86_64_GOTPC32_TLSDESC, },
 260   { BFD_RELOC_X86_64_TLSDESC_CALL, R_X86_64_TLSDESC_CALL, },
 261   { BFD_RELOC_X86_64_TLSDESC,   R_X86_64_TLSDESC, },
 262   { BFD_RELOC_X86_64_IRELATIVE, R_X86_64_IRELATIVE, },
 263   { BFD_RELOC_X86_64_PC32_BND,  R_X86_64_PC32_BND, },
 264   { BFD_RELOC_X86_64_PLT32_BND, R_X86_64_PLT32_BND, },
 265   { BFD_RELOC_X86_64_GOTPCRELX, R_X86_64_GOTPCRELX, },
 266   { BFD_RELOC_X86_64_REX_GOTPCRELX, R_X86_64_REX_GOTPCRELX, },
 267   { BFD_RELOC_VTABLE_INHERIT,   R_X86_64_GNU_VTINHERIT, },
 268   { BFD_RELOC_VTABLE_ENTRY,     R_X86_64_GNU_VTENTRY, },
 269 };
 270
 271 static reloc_howto_type *
 272 elf_x86_64_rtype_to_howto (bfd *abfd, unsigned r_type)
 273 {
 274   unsigned i;
 275
 276   if (r_type == (unsigned int) R_X86_64_32)
 277     {
 278       if (ABI_64_P (abfd))
 279         i = r_type;
 280       else
 281         i = ARRAY_SIZE (x86_64_elf_howto_table) - 1;
 282     }
 283   else if (r_type < (unsigned int) R_X86_64_GNU_VTINHERIT
 284            || r_type >= (unsigned int) R_X86_64_max)
 285     {
 286       if (r_type >= (unsigned int) R_X86_64_standard)
 287         {
 288           /* xgettext:c-format */
 289           _bfd_error_handler (_("%B: invalid relocation type %d"),
 290                               abfd, (int) r_type);
 291           r_type = R_X86_64_NONE;
 292         }
 293       i = r_type;
 294     }
 295   else
 296     i = r_type - (unsigned int) R_X86_64_vt_offset;
 297   BFD_ASSERT (x86_64_elf_howto_table[i].type == r_type);
 298   return &x86_64_elf_howto_table[i];
 299 }
 300
 301 /* Given a BFD reloc type, return a HOWTO structure.  */
 302 static reloc_howto_type *
 303 elf_x86_64_reloc_type_lookup (bfd *abfd,
 304                               bfd_reloc_code_real_type code)
 305 {
 306   unsigned int i;
 307
 308   for (i = 0; i < sizeof (x86_64_reloc_map) / sizeof (struct elf_reloc_map);
 309        i++)
 310     {
 311       if (x86_64_reloc_map[i].bfd_reloc_val == code)
 312         return elf_x86_64_rtype_to_howto (abfd,
 313                                           x86_64_reloc_map[i].elf_reloc_val);
 314     }
 315   return NULL;
 316 }
 317
 318 static reloc_howto_type *
 319 elf_x86_64_reloc_name_lookup (bfd *abfd,
 320                               const char *r_name)
 321 {
 322   unsigned int i;
 323
 324   if (!ABI_64_P (abfd) && strcasecmp (r_name, "R_X86_64_32") == 0)
 325     {
 326       /* Get x32 R_X86_64_32.  */
 327       reloc_howto_type *reloc
 328         = &x86_64_elf_howto_table[ARRAY_SIZE (x86_64_elf_howto_table) - 1];
 329       BFD_ASSERT (reloc->type == (unsigned int) R_X86_64_32);
 330       return reloc;
 331     }
 332
 333   for (i = 0; i < ARRAY_SIZE (x86_64_elf_howto_table); i++)
 334     if (x86_64_elf_howto_table[i].name != NULL
 335         && strcasecmp (x86_64_elf_howto_table[i].name, r_name) == 0)
 336       return &x86_64_elf_howto_table[i];
 337
 338   return NULL;
 339 }
 340
 341 /* Given an x86_64 ELF reloc type, fill in an arelent structure.  */
 342
 343 static void
 344 elf_x86_64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
 345                           Elf_Internal_Rela *dst)
 346 {
 347   unsigned r_type;
 348
 349   r_type = ELF32_R_TYPE (dst->r_info);
 350   cache_ptr->howto = elf_x86_64_rtype_to_howto (abfd, r_type);
 351   BFD_ASSERT (r_type == cache_ptr->howto->type);
 352 }
 353 \f
 354 /* Support for core dump NOTE sections.  */
 355 static bfd_boolean
 356 elf_x86_64_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
 357 {
 358   int offset;
 359   size_t size;
 360
 361   switch (note->descsz)
 362     {
 363       default:
 364         return FALSE;
 365
 366       case 296:         /* sizeof(istruct elf_prstatus) on Linux/x32 */
 367         /* pr_cursig */
 368         elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
 369
 370         /* pr_pid */
 371         elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
 372
 373         /* pr_reg */
 374         offset = 72;
 375         size = 216;
 376
 377         break;
 378
 379       case 336:         /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
 380         /* pr_cursig */
 381         elf_tdata (abfd)->core->signal
 382           = bfd_get_16 (abfd, note->descdata + 12);
 383
 384         /* pr_pid */
 385         elf_tdata (abfd)->core->lwpid
 386           = bfd_get_32 (abfd, note->descdata + 32);
 387
 388         /* pr_reg */
 389         offset = 112;
 390         size = 216;
 391
 392         break;
 393     }
 394
 395   /* Make a ".reg/999" section.  */
 396   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
 397                                           size, note->descpos + offset);
 398 }
 399
 400 static bfd_boolean
 401 elf_x86_64_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
 402 {
 403   switch (note->descsz)
 404     {
 405       default:
 406         return FALSE;
 407
 408       case 124:         /* sizeof(struct elf_prpsinfo) on Linux/x32 */
 409         elf_tdata (abfd)->core->pid
 410           = bfd_get_32 (abfd, note->descdata + 12);
 411         elf_tdata (abfd)->core->program
 412           = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
 413         elf_tdata (abfd)->core->command
 414           = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
 415         break;
 416
 417       case 136:         /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
 418         elf_tdata (abfd)->core->pid
 419           = bfd_get_32 (abfd, note->descdata + 24);
 420         elf_tdata (abfd)->core->program
 421          = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
 422         elf_tdata (abfd)->core->command
 423          = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
 424     }
 425
 426   /* Note that for some reason, a spurious space is tacked
 427      onto the end of the args in some (at least one anyway)
 428      implementations, so strip it off if it exists.  */
 429
 430   {
 431     char *command = elf_tdata (abfd)->core->command;
 432     int n = strlen (command);
 433
 434     if (0 < n && command[n - 1] == ' ')
 435       command[n - 1] = '\0';
 436   }
 437
 438   return TRUE;
 439 }
 440
 441 #ifdef CORE_HEADER
 442 static char *
 443 elf_x86_64_write_core_note (bfd *abfd, char *buf, int *bufsiz,
 444                             int note_type, ...)
 445 {
 446   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
 447   va_list ap;
 448   const char *fname, *psargs;
 449   long pid;
 450   int cursig;
 451   const void *gregs;
 452
 453   switch (note_type)
 454     {
 455     default:
 456       return NULL;
 457
 458     case NT_PRPSINFO:
 459       va_start (ap, note_type);
 460       fname = va_arg (ap, const char *);
 461       psargs = va_arg (ap, const char *);
 462       va_end (ap);
 463
 464       if (bed->s->elfclass == ELFCLASS32)
 465         {
 466           prpsinfo32_t data;
 467           memset (&data, 0, sizeof (data));
 468           strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
 469           strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
 470           return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
 471                                      &data, sizeof (data));
 472         }
 473       else
 474         {
 475           prpsinfo64_t data;
 476           memset (&data, 0, sizeof (data));
 477           strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
 478           strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
 479           return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
 480                                      &data, sizeof (data));
 481         }
 482       /* NOTREACHED */
 483
 484     case NT_PRSTATUS:
 485       va_start (ap, note_type);
 486       pid = va_arg (ap, long);
 487       cursig = va_arg (ap, int);
 488       gregs = va_arg (ap, const void *);
 489       va_end (ap);
 490
 491       if (bed->s->elfclass == ELFCLASS32)
 492         {
 493           if (bed->elf_machine_code == EM_X86_64)
 494             {
 495               prstatusx32_t prstat;
 496               memset (&prstat, 0, sizeof (prstat));
 497               prstat.pr_pid = pid;
 498               prstat.pr_cursig = cursig;
 499               memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
 500               return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
 501                                          &prstat, sizeof (prstat));
 502             }
 503           else
 504             {
 505               prstatus32_t prstat;
 506               memset (&prstat, 0, sizeof (prstat));
 507               prstat.pr_pid = pid;
 508               prstat.pr_cursig = cursig;
 509               memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
 510               return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
 511                                          &prstat, sizeof (prstat));
 512             }
 513         }
 514       else
 515         {
 516           prstatus64_t prstat;
 517           memset (&prstat, 0, sizeof (prstat));
 518           prstat.pr_pid = pid;
 519           prstat.pr_cursig = cursig;
 520           memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
 521           return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
 522                                      &prstat, sizeof (prstat));
 523         }
 524     }
 525   /* NOTREACHED */
 526 }
 527 #endif
 528 \f
 529 /* Functions for the x86-64 ELF linker.  */
 530
 531 /* The name of the dynamic interpreter.  This is put in the .interp
 532    section.  */
 533
 534 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
 535 #define ELF32_DYNAMIC_INTERPRETER "/lib/ldx32.so.1"
 536
 537 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
 538    copying dynamic variables from a shared lib into an app's dynbss
 539    section, and instead use a dynamic relocation to point into the
 540    shared lib.  */
 541 #define ELIMINATE_COPY_RELOCS 1
 542
 543 /* The size in bytes of an entry in the global offset table.  */
 544
 545 #define GOT_ENTRY_SIZE 8
 546
 547 /* The size in bytes of an entry in the lazy procedure linkage table.  */
 548
 549 #define LAZY_PLT_ENTRY_SIZE 16
 550
 551 /* The size in bytes of an entry in the non-lazy procedure linkage
 552    table.  */
 553
 554 #define NON_LAZY_PLT_ENTRY_SIZE 8
 555
 556 /* The first entry in a lazy procedure linkage table looks like this.
 557    See the SVR4 ABI i386 supplement and the x86-64 ABI to see how this
 558    works.  */
 559
 560 static const bfd_byte elf_x86_64_lazy_plt0_entry[LAZY_PLT_ENTRY_SIZE] =
 561 {
 562   0xff, 0x35, 8, 0, 0, 0,       /* pushq GOT+8(%rip)  */
 563   0xff, 0x25, 16, 0, 0, 0,      /* jmpq *GOT+16(%rip) */
 564   0x0f, 0x1f, 0x40, 0x00        /* nopl 0(%rax)       */
 565 };
 566
 567 /* Subsequent entries in a lazy procedure linkage table look like this.  */
 568
 569 static const bfd_byte elf_x86_64_lazy_plt_entry[LAZY_PLT_ENTRY_SIZE] =
 570 {
 571   0xff, 0x25,   /* jmpq *name@GOTPC(%rip) */
 572   0, 0, 0, 0,   /* replaced with offset to this symbol in .got.  */
 573   0x68,         /* pushq immediate */
 574   0, 0, 0, 0,   /* replaced with index into relocation table.  */
 575   0xe9,         /* jmp relative */
 576   0, 0, 0, 0    /* replaced with offset to start of .plt0.  */
 577 };
 578
 579 /* The first entry in a lazy procedure linkage table with BND prefix
 580    like this.  */
 581
 582 static const bfd_byte elf_x86_64_lazy_bnd_plt0_entry[LAZY_PLT_ENTRY_SIZE] =
 583 {
 584   0xff, 0x35, 8, 0, 0, 0,         /* pushq GOT+8(%rip)        */
 585   0xf2, 0xff, 0x25, 16, 0, 0, 0,  /* bnd jmpq *GOT+16(%rip)   */
 586   0x0f, 0x1f, 0                   /* nopl (%rax)              */
 587 };
 588
 589 /* Subsequent entries for branches with BND prefx in a lazy procedure
 590    linkage table look like this.  */
 591
 592 static const bfd_byte elf_x86_64_lazy_bnd_plt_entry[LAZY_PLT_ENTRY_SIZE] =
 593 {
 594   0x68, 0, 0, 0, 0,             /* pushq immediate            */
 595   0xf2, 0xe9, 0, 0, 0, 0,       /* bnd jmpq relative          */
 596   0x0f, 0x1f, 0x44, 0, 0        /* nopl 0(%rax,%rax,1)        */
 597 };
 598
 599 /* The first entry in the IBT-enabled lazy procedure linkage table is the
 600    the same as the lazy PLT with BND prefix so that bound registers are
 601    preserved when control is passed to dynamic linker.  Subsequent
 602    entries for a IBT-enabled lazy procedure linkage table look like
 603    this.  */
 604
 605 static const bfd_byte elf_x86_64_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] =
 606 {
 607   0xf3, 0x0f, 0x1e, 0xfa,       /* endbr64                    */
 608   0x68, 0, 0, 0, 0,             /* pushq immediate            */
 609   0xf2, 0xe9, 0, 0, 0, 0,       /* bnd jmpq relative          */
 610   0x90                          /* nop                        */
 611 };
 612
 613 /* The first entry in the x32 IBT-enabled lazy procedure linkage table
 614    is the same as the normal lazy PLT.  Subsequent entries for an
 615    x32 IBT-enabled lazy procedure linkage table look like this.  */
 616
 617 static const bfd_byte elf_x32_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] =
 618 {
 619   0xf3, 0x0f, 0x1e, 0xfa,       /* endbr64                    */
 620   0x68, 0, 0, 0, 0,             /* pushq immediate            */
 621   0xe9, 0, 0, 0, 0,             /* jmpq relative              */
 622   0x66, 0x90                    /* xchg %ax,%ax               */
 623 };
 624
 625 /* Entries in the non-lazey procedure linkage table look like this.  */
 626
 627 static const bfd_byte elf_x86_64_non_lazy_plt_entry[NON_LAZY_PLT_ENTRY_SIZE] =
 628 {
 629   0xff, 0x25,        /* jmpq *name@GOTPC(%rip)                        */
 630   0, 0, 0, 0,        /* replaced with offset to this symbol in .got.  */
 631   0x66, 0x90         /* xchg %ax,%ax                                  */
 632 };
 633
 634 /* Entries for branches with BND prefix in the non-lazey procedure
 635    linkage table look like this.  */
 636
 637 static const bfd_byte elf_x86_64_non_lazy_bnd_plt_entry[NON_LAZY_PLT_ENTRY_SIZE] =
 638 {
 639   0xf2, 0xff, 0x25,  /* bnd jmpq *name@GOTPC(%rip)                    */
 640   0, 0, 0, 0,        /* replaced with offset to this symbol in .got.  */
 641   0x90               /* nop                                           */
 642 };
 643
 644 /* Entries for branches with IBT-enabled in the non-lazey procedure
 645    linkage table look like this.  They have the same size as the lazy
 646    PLT entry.  */
 647
 648 static const bfd_byte elf_x86_64_non_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] =
 649 {
 650   0xf3, 0x0f, 0x1e, 0xfa,       /* endbr64                     */
 651   0xf2, 0xff, 0x25,             /* bnd jmpq *name@GOTPC(%rip)  */
 652   0, 0, 0, 0,  /* replaced with offset to this symbol in .got. */
 653   0x0f, 0x1f, 0x44, 0x00, 0x00  /* nopl 0x0(%rax,%rax,1)       */
 654 };
 655
 656 /* Entries for branches with IBT-enabled in the x32 non-lazey procedure
 657    linkage table look like this.  They have the same size as the lazy
 658    PLT entry.  */
 659
 660 static const bfd_byte elf_x32_non_lazy_ibt_plt_entry[LAZY_PLT_ENTRY_SIZE] =
 661 {
 662   0xf3, 0x0f, 0x1e, 0xfa,            /* endbr64                */
 663   0xff, 0x25,                        /* jmpq *name@GOTPC(%rip) */
 664   0, 0, 0, 0,  /* replaced with offset to this symbol in .got. */
 665   0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00 /* nopw 0x0(%rax,%rax,1)  */
 666 };
 667
 668 /* .eh_frame covering the lazy .plt section.  */
 669
 670 static const bfd_byte elf_x86_64_eh_frame_lazy_plt[] =
 671 {
 672 #define PLT_CIE_LENGTH          20
 673 #define PLT_FDE_LENGTH          36
 674 #define PLT_FDE_START_OFFSET    4 + PLT_CIE_LENGTH + 8
 675 #define PLT_FDE_LEN_OFFSET      4 + PLT_CIE_LENGTH + 12
 676   PLT_CIE_LENGTH, 0, 0, 0,      /* CIE length */
 677   0, 0, 0, 0,                   /* CIE ID */
 678   1,                            /* CIE version */
 679   'z', 'R', 0,                  /* Augmentation string */
 680   1,                            /* Code alignment factor */
 681   0x78,                         /* Data alignment factor */
 682   16,                           /* Return address column */
 683   1,                            /* Augmentation size */
 684   DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
 685   DW_CFA_def_cfa, 7, 8,         /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
 686   DW_CFA_offset + 16, 1,        /* DW_CFA_offset: r16 (rip) at cfa-8 */
 687   DW_CFA_nop, DW_CFA_nop,
 688
 689   PLT_FDE_LENGTH, 0, 0, 0,      /* FDE length */
 690   PLT_CIE_LENGTH + 8, 0, 0, 0,  /* CIE pointer */
 691   0, 0, 0, 0,                   /* R_X86_64_PC32 .plt goes here */
 692   0, 0, 0, 0,                   /* .plt size goes here */
 693   0,                            /* Augmentation size */
 694   DW_CFA_def_cfa_offset, 16,    /* DW_CFA_def_cfa_offset: 16 */
 695   DW_CFA_advance_loc + 6,       /* DW_CFA_advance_loc: 6 to __PLT__+6 */
 696   DW_CFA_def_cfa_offset, 24,    /* DW_CFA_def_cfa_offset: 24 */
 697   DW_CFA_advance_loc + 10,      /* DW_CFA_advance_loc: 10 to __PLT__+16 */
 698   DW_CFA_def_cfa_expression,    /* DW_CFA_def_cfa_expression */
 699   11,                           /* Block length */
 700   DW_OP_breg7, 8,               /* DW_OP_breg7 (rsp): 8 */
 701   DW_OP_breg16, 0,              /* DW_OP_breg16 (rip): 0 */
 702   DW_OP_lit15, DW_OP_and, DW_OP_lit11, DW_OP_ge,
 703   DW_OP_lit3, DW_OP_shl, DW_OP_plus,
 704   DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
 705 };
 706
 707 /* .eh_frame covering the lazy BND .plt section.  */
 708
 709 static const bfd_byte elf_x86_64_eh_frame_lazy_bnd_plt[] =
 710 {
 711   PLT_CIE_LENGTH, 0, 0, 0,      /* CIE length */
 712   0, 0, 0, 0,                   /* CIE ID */
 713   1,                            /* CIE version */
 714   'z', 'R', 0,                  /* Augmentation string */
 715   1,                            /* Code alignment factor */
 716   0x78,                         /* Data alignment factor */
 717   16,                           /* Return address column */
 718   1,                            /* Augmentation size */
 719   DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
 720   DW_CFA_def_cfa, 7, 8,         /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
 721   DW_CFA_offset + 16, 1,        /* DW_CFA_offset: r16 (rip) at cfa-8 */
 722   DW_CFA_nop, DW_CFA_nop,
 723
 724   PLT_FDE_LENGTH, 0, 0, 0,      /* FDE length */
 725   PLT_CIE_LENGTH + 8, 0, 0, 0,  /* CIE pointer */
 726   0, 0, 0, 0,                   /* R_X86_64_PC32 .plt goes here */
 727   0, 0, 0, 0,                   /* .plt size goes here */
 728   0,                            /* Augmentation size */
 729   DW_CFA_def_cfa_offset, 16,    /* DW_CFA_def_cfa_offset: 16 */
 730   DW_CFA_advance_loc + 6,       /* DW_CFA_advance_loc: 6 to __PLT__+6 */
 731   DW_CFA_def_cfa_offset, 24,    /* DW_CFA_def_cfa_offset: 24 */
 732   DW_CFA_advance_loc + 10,      /* DW_CFA_advance_loc: 10 to __PLT__+16 */
 733   DW_CFA_def_cfa_expression,    /* DW_CFA_def_cfa_expression */
 734   11,                           /* Block length */
 735   DW_OP_breg7, 8,               /* DW_OP_breg7 (rsp): 8 */
 736   DW_OP_breg16, 0,              /* DW_OP_breg16 (rip): 0 */
 737   DW_OP_lit15, DW_OP_and, DW_OP_lit5, DW_OP_ge,
 738   DW_OP_lit3, DW_OP_shl, DW_OP_plus,
 739   DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
 740 };
 741
 742 /* .eh_frame covering the lazy .plt section with IBT-enabled.  */
 743
 744 static const bfd_byte elf_x86_64_eh_frame_lazy_ibt_plt[] =
 745 {
 746   PLT_CIE_LENGTH, 0, 0, 0,      /* CIE length */
 747   0, 0, 0, 0,                   /* CIE ID */
 748   1,                            /* CIE version */
 749   'z', 'R', 0,                  /* Augmentation string */
 750   1,                            /* Code alignment factor */
 751   0x78,                         /* Data alignment factor */
 752   16,                           /* Return address column */
 753   1,                            /* Augmentation size */
 754   DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
 755   DW_CFA_def_cfa, 7, 8,         /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
 756   DW_CFA_offset + 16, 1,        /* DW_CFA_offset: r16 (rip) at cfa-8 */
 757   DW_CFA_nop, DW_CFA_nop,
 758
 759   PLT_FDE_LENGTH, 0, 0, 0,      /* FDE length */
 760   PLT_CIE_LENGTH + 8, 0, 0, 0,  /* CIE pointer */
 761   0, 0, 0, 0,                   /* R_X86_64_PC32 .plt goes here */
 762   0, 0, 0, 0,                   /* .plt size goes here */
 763   0,                            /* Augmentation size */
 764   DW_CFA_def_cfa_offset, 16,    /* DW_CFA_def_cfa_offset: 16 */
 765   DW_CFA_advance_loc + 6,       /* DW_CFA_advance_loc: 6 to __PLT__+6 */
 766   DW_CFA_def_cfa_offset, 24,    /* DW_CFA_def_cfa_offset: 24 */
 767   DW_CFA_advance_loc + 10,      /* DW_CFA_advance_loc: 10 to __PLT__+16 */
 768   DW_CFA_def_cfa_expression,    /* DW_CFA_def_cfa_expression */
 769   11,                           /* Block length */
 770   DW_OP_breg7, 8,               /* DW_OP_breg7 (rsp): 8 */
 771   DW_OP_breg16, 0,              /* DW_OP_breg16 (rip): 0 */
 772   DW_OP_lit15, DW_OP_and, DW_OP_lit10, DW_OP_ge,
 773   DW_OP_lit3, DW_OP_shl, DW_OP_plus,
 774   DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
 775 };
 776
 777 /* .eh_frame covering the x32 lazy .plt section with IBT-enabled.  */
 778
 779 static const bfd_byte elf_x32_eh_frame_lazy_ibt_plt[] =
 780 {
 781   PLT_CIE_LENGTH, 0, 0, 0,      /* CIE length */
 782   0, 0, 0, 0,                   /* CIE ID */
 783   1,                            /* CIE version */
 784   'z', 'R', 0,                  /* Augmentation string */
 785   1,                            /* Code alignment factor */
 786   0x78,                         /* Data alignment factor */
 787   16,                           /* Return address column */
 788   1,                            /* Augmentation size */
 789   DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
 790   DW_CFA_def_cfa, 7, 8,         /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
 791   DW_CFA_offset + 16, 1,        /* DW_CFA_offset: r16 (rip) at cfa-8 */
 792   DW_CFA_nop, DW_CFA_nop,
 793
 794   PLT_FDE_LENGTH, 0, 0, 0,      /* FDE length */
 795   PLT_CIE_LENGTH + 8, 0, 0, 0,  /* CIE pointer */
 796   0, 0, 0, 0,                   /* R_X86_64_PC32 .plt goes here */
 797   0, 0, 0, 0,                   /* .plt size goes here */
 798   0,                            /* Augmentation size */
 799   DW_CFA_def_cfa_offset, 16,    /* DW_CFA_def_cfa_offset: 16 */
 800   DW_CFA_advance_loc + 6,       /* DW_CFA_advance_loc: 6 to __PLT__+6 */
 801   DW_CFA_def_cfa_offset, 24,    /* DW_CFA_def_cfa_offset: 24 */
 802   DW_CFA_advance_loc + 10,      /* DW_CFA_advance_loc: 10 to __PLT__+16 */
 803   DW_CFA_def_cfa_expression,    /* DW_CFA_def_cfa_expression */
 804   11,                           /* Block length */
 805   DW_OP_breg7, 8,               /* DW_OP_breg7 (rsp): 8 */
 806   DW_OP_breg16, 0,              /* DW_OP_breg16 (rip): 0 */
 807   DW_OP_lit15, DW_OP_and, DW_OP_lit9, DW_OP_ge,
 808   DW_OP_lit3, DW_OP_shl, DW_OP_plus,
 809   DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
 810 };
 811
 812 /* .eh_frame covering the non-lazy .plt section.  */
 813
 814 static const bfd_byte elf_x86_64_eh_frame_non_lazy_plt[] =
 815 {
 816 #define PLT_GOT_FDE_LENGTH              20
 817   PLT_CIE_LENGTH, 0, 0, 0,      /* CIE length */
 818   0, 0, 0, 0,                   /* CIE ID */
 819   1,                            /* CIE version */
 820   'z', 'R', 0,                  /* Augmentation string */
 821   1,                            /* Code alignment factor */
 822   0x78,                         /* Data alignment factor */
 823   16,                           /* Return address column */
 824   1,                            /* Augmentation size */
 825   DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
 826   DW_CFA_def_cfa, 7, 8,         /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
 827   DW_CFA_offset + 16, 1,        /* DW_CFA_offset: r16 (rip) at cfa-8 */
 828   DW_CFA_nop, DW_CFA_nop,
 829
 830   PLT_GOT_FDE_LENGTH, 0, 0, 0,  /* FDE length */
 831   PLT_CIE_LENGTH + 8, 0, 0, 0,  /* CIE pointer */
 832   0, 0, 0, 0,                   /* the start of non-lazy .plt goes here */
 833   0, 0, 0, 0,                   /* non-lazy .plt size goes here */
 834   0,                            /* Augmentation size */
 835   DW_CFA_nop, DW_CFA_nop, DW_CFA_nop, DW_CFA_nop,
 836   DW_CFA_nop, DW_CFA_nop, DW_CFA_nop
 837 };
 838
 839 struct elf_x86_64_lazy_plt_layout
 840 {
 841   /* Templates for the initial PLT entry and for subsequent entries.  */
 842   const bfd_byte *plt0_entry;
 843   const bfd_byte *plt_entry;
 844   unsigned int plt_entry_size;          /* Size of each PLT entry.  */
 845
 846   /* Offsets into plt0_entry that are to be replaced with GOT[1] and GOT[2].  */
 847   unsigned int plt0_got1_offset;
 848   unsigned int plt0_got2_offset;
 849
 850   /* Offset of the end of the PC-relative instruction containing
 851      plt0_got2_offset.  */
 852   unsigned int plt0_got2_insn_end;
 853
 854   /* Offsets into plt_entry that are to be replaced with...  */
 855   unsigned int plt_got_offset;    /* ... address of this symbol in .got. */
 856   unsigned int plt_reloc_offset;  /* ... offset into relocation table. */
 857   unsigned int plt_plt_offset;    /* ... offset to start of .plt. */
 858
 859   /* Length of the PC-relative instruction containing plt_got_offset.  */
 860   unsigned int plt_got_insn_size;
 861
 862   /* Offset of the end of the PC-relative jump to plt0_entry.  */
 863   unsigned int plt_plt_insn_end;
 864
 865   /* Offset into plt_entry where the initial value of the GOT entry points.  */
 866   unsigned int plt_lazy_offset;
 867
 868   /* .eh_frame covering the lazy .plt section.  */
 869   const bfd_byte *eh_frame_plt;
 870   unsigned int eh_frame_plt_size;
 871 };
 872
 873 struct elf_x86_64_non_lazy_plt_layout
 874 {
 875   /* Template for the lazy PLT entries.  */
 876   const bfd_byte *plt_entry;
 877   unsigned int plt_entry_size;          /* Size of each PLT entry.  */
 878
 879   /* Offsets into plt_entry that are to be replaced with...  */
 880   unsigned int plt_got_offset;    /* ... address of this symbol in .got. */
 881
 882   /* Length of the PC-relative instruction containing plt_got_offset.  */
 883   unsigned int plt_got_insn_size;
 884
 885   /* .eh_frame covering the non-lazy .plt section.  */
 886   const bfd_byte *eh_frame_plt;
 887   unsigned int eh_frame_plt_size;
 888 };
 889
 890 struct elf_x86_64_plt_layout
 891 {
 892   /* Template for the PLT entries.  */
 893   const bfd_byte *plt_entry;
 894   unsigned int plt_entry_size;          /* Size of each PLT entry.  */
 895
 896   /* 1 has PLT0.  */
 897    unsigned int has_plt0;
 898
 899   /* Offsets into plt_entry that are to be replaced with...  */
 900   unsigned int plt_got_offset;    /* ... address of this symbol in .got. */
 901
 902   /* Length of the PC-relative instruction containing plt_got_offset.  */
 903   unsigned int plt_got_insn_size;
 904
 905   /* .eh_frame covering the .plt section.  */
 906   const bfd_byte *eh_frame_plt;
 907   unsigned int eh_frame_plt_size;
 908 };
 909
 910 /* Architecture-specific backend data for x86-64.  */
 911
 912 struct elf_x86_64_backend_data
 913 {
 914   /* Target system.  */
 915   enum
 916     {
 917       is_normal,
 918       is_nacl
 919     } os;
 920 };
 921
 922 #define get_elf_x86_64_arch_data(bed) \
 923   ((const struct elf_x86_64_backend_data *) (bed)->arch_data)
 924
 925 #define get_elf_x86_64_backend_data(abfd) \
 926   get_elf_x86_64_arch_data (get_elf_backend_data (abfd))
 927
 928 /* These are the standard parameters.  */
 929 static const struct elf_x86_64_lazy_plt_layout elf_x86_64_lazy_plt =
 930   {
 931     elf_x86_64_lazy_plt0_entry,         /* plt0_entry */
 932     elf_x86_64_lazy_plt_entry,          /* plt_entry */
 933     LAZY_PLT_ENTRY_SIZE,                /* plt_entry_size */
 934     2,                                  /* plt0_got1_offset */
 935     8,                                  /* plt0_got2_offset */
 936     12,                                 /* plt0_got2_insn_end */
 937     2,                                  /* plt_got_offset */
 938     7,                                  /* plt_reloc_offset */
 939     12,                                 /* plt_plt_offset */
 940     6,                                  /* plt_got_insn_size */
 941     LAZY_PLT_ENTRY_SIZE,                /* plt_plt_insn_end */
 942     6,                                  /* plt_lazy_offset */
 943     elf_x86_64_eh_frame_lazy_plt,       /* eh_frame_plt */
 944     sizeof (elf_x86_64_eh_frame_lazy_plt) /* eh_frame_plt_size */
 945   };
 946
 947 static const struct elf_x86_64_non_lazy_plt_layout elf_x86_64_non_lazy_plt =
 948   {
 949     elf_x86_64_non_lazy_plt_entry,      /* plt_entry */
 950     NON_LAZY_PLT_ENTRY_SIZE,            /* plt_entry_size */
 951     2,                                  /* plt_got_offset */
 952     6,                                  /* plt_got_insn_size */
 953     elf_x86_64_eh_frame_non_lazy_plt,   /* eh_frame_plt */
 954     sizeof (elf_x86_64_eh_frame_non_lazy_plt) /* eh_frame_plt_size */
 955   };
 956
 957 static const struct elf_x86_64_lazy_plt_layout elf_x86_64_lazy_bnd_plt =
 958   {
 959     elf_x86_64_lazy_bnd_plt0_entry,     /* plt0_entry */
 960     elf_x86_64_lazy_bnd_plt_entry,      /* plt_entry */
 961     LAZY_PLT_ENTRY_SIZE,                /* plt_entry_size */
 962     2,                                  /* plt0_got1_offset */
 963     1+8,                                /* plt0_got2_offset */
 964     1+12,                               /* plt0_got2_insn_end */
 965     1+2,                                /* plt_got_offset */
 966     1,                                  /* plt_reloc_offset */
 967     7,                                  /* plt_plt_offset */
 968     1+6,                                /* plt_got_insn_size */
 969     11,                                 /* plt_plt_insn_end */
 970     0,                                  /* plt_lazy_offset */
 971     elf_x86_64_eh_frame_lazy_bnd_plt,   /* eh_frame_plt */
 972     sizeof (elf_x86_64_eh_frame_lazy_bnd_plt) /* eh_frame_plt_size */
 973   };
 974
 975 static const struct elf_x86_64_non_lazy_plt_layout elf_x86_64_non_lazy_bnd_plt =
 976   {
 977     elf_x86_64_non_lazy_bnd_plt_entry,  /* plt_entry */
 978     NON_LAZY_PLT_ENTRY_SIZE,            /* plt_entry_size */
 979     1+2,                                /* plt_got_offset */
 980     1+6,                                /* plt_got_insn_size */
 981     elf_x86_64_eh_frame_non_lazy_plt,   /* eh_frame_plt */
 982     sizeof (elf_x86_64_eh_frame_non_lazy_plt) /* eh_frame_plt_size */
 983   };
 984
 985 static const struct elf_x86_64_lazy_plt_layout elf_x86_64_lazy_ibt_plt =
 986   {
 987     elf_x86_64_lazy_bnd_plt0_entry,     /* plt0_entry */
 988     elf_x86_64_lazy_ibt_plt_entry,      /* plt_entry */
 989     LAZY_PLT_ENTRY_SIZE,                /* plt_entry_size */
 990     2,                                  /* plt0_got1_offset */
 991     1+8,                                /* plt0_got2_offset */
 992     1+12,                               /* plt0_got2_insn_end */
 993     4+1+2,                              /* plt_got_offset */
 994     4+1,                                /* plt_reloc_offset */
 995     4+1+6,                              /* plt_plt_offset */
 996     4+1+6,                              /* plt_got_insn_size */
 997     4+1+5+5,                            /* plt_plt_insn_end */
 998     0,                                  /* plt_lazy_offset */
 999     elf_x86_64_eh_frame_lazy_ibt_plt,   /* eh_frame_plt */
1000     sizeof (elf_x86_64_eh_frame_lazy_ibt_plt) /* eh_frame_plt_size */
1001   };
1002
1003 static const struct elf_x86_64_lazy_plt_layout elf_x32_lazy_ibt_plt =
1004   {
1005     elf_x86_64_lazy_plt0_entry,         /* plt0_entry */
1006     elf_x32_lazy_ibt_plt_entry,         /* plt_entry */
1007     LAZY_PLT_ENTRY_SIZE,                /* plt_entry_size */
1008     2,                                  /* plt0_got1_offset */
1009     8,                                  /* plt0_got2_offset */
1010     12,                                 /* plt0_got2_insn_end */
1011     4+2,                                /* plt_got_offset */
1012     4+1,                                /* plt_reloc_offset */
1013     4+6,                                /* plt_plt_offset */
1014     4+6,                                /* plt_got_insn_size */
1015     4+5+5,                              /* plt_plt_insn_end */
1016     0,                                  /* plt_lazy_offset */
1017     elf_x32_eh_frame_lazy_ibt_plt,      /* eh_frame_plt */
1018     sizeof (elf_x32_eh_frame_lazy_ibt_plt) /* eh_frame_plt_size */
1019   };
1020
1021 static const struct elf_x86_64_non_lazy_plt_layout elf_x86_64_non_lazy_ibt_plt =
1022   {
1023     elf_x86_64_non_lazy_ibt_plt_entry,  /* plt_entry */
1024     LAZY_PLT_ENTRY_SIZE,                /* plt_entry_size */
1025     4+1+2,                              /* plt_got_offset */
1026     4+1+6,                              /* plt_got_insn_size */
1027     elf_x86_64_eh_frame_non_lazy_plt,   /* eh_frame_plt */
1028     sizeof (elf_x86_64_eh_frame_non_lazy_plt) /* eh_frame_plt_size */
1029   };
1030
1031 static const struct elf_x86_64_non_lazy_plt_layout elf_x32_non_lazy_ibt_plt =
1032   {
1033     elf_x32_non_lazy_ibt_plt_entry,     /* plt_entry */
1034     LAZY_PLT_ENTRY_SIZE,                /* plt_entry_size */
1035     4+2,                                /* plt_got_offset */
1036     4+6,                                /* plt_got_insn_size */
1037     elf_x86_64_eh_frame_non_lazy_plt,   /* eh_frame_plt */
1038     sizeof (elf_x86_64_eh_frame_non_lazy_plt) /* eh_frame_plt_size */
1039   };
1040
1041 static const struct elf_x86_64_backend_data elf_x86_64_arch_bed =
1042   {
1043     is_normal                            /* os */
1044   };
1045
1046 #define elf_backend_arch_data   &elf_x86_64_arch_bed
1047
1048 /* Is a undefined weak symbol which is resolved to 0.  Reference to an
1049    undefined weak symbol is resolved to 0 when building executable if
1050    it isn't dynamic and
1051    1. Has non-GOT/non-PLT relocations in text section.  Or
1052    2. Has no GOT/PLT relocation.
1053    Local undefined weak symbol is always resolved to 0.
1054  */
1055 #define UNDEFINED_WEAK_RESOLVED_TO_ZERO(INFO, GOT_RELOC, EH)    \
1056   ((EH)->elf.root.type == bfd_link_hash_undefweak               \
1057    && ((EH)->elf.forced_local                                   \
1058        || (bfd_link_executable (INFO)                           \
1059            && (elf_x86_64_hash_table (INFO)->interp == NULL     \
1060                || !(GOT_RELOC)                                  \
1061                || (EH)->has_non_got_reloc                       \
1062                || !(INFO)->dynamic_undefined_weak))))
1063
1064 /* x86-64 ELF linker hash entry.  */
1065
1066 struct elf_x86_64_link_hash_entry
1067 {
1068   struct elf_link_hash_entry elf;
1069
1070   /* Track dynamic relocs copied for this symbol.  */
1071   struct elf_dyn_relocs *dyn_relocs;
1072
1073 #define GOT_UNKNOWN     0
1074 #define GOT_NORMAL      1
1075 #define GOT_TLS_GD      2
1076 #define GOT_TLS_IE      3
1077 #define GOT_TLS_GDESC   4
1078 #define GOT_TLS_GD_BOTH_P(type) \
1079   ((type) == (GOT_TLS_GD | GOT_TLS_GDESC))
1080 #define GOT_TLS_GD_P(type) \
1081   ((type) == GOT_TLS_GD || GOT_TLS_GD_BOTH_P (type))
1082 #define GOT_TLS_GDESC_P(type) \
1083   ((type) == GOT_TLS_GDESC || GOT_TLS_GD_BOTH_P (type))
1084 #define GOT_TLS_GD_ANY_P(type) \
1085   (GOT_TLS_GD_P (type) || GOT_TLS_GDESC_P (type))
1086   unsigned char tls_type;
1087
1088   /* TRUE if a weak symbol with a real definition needs a copy reloc.
1089      When there is a weak symbol with a real definition, the processor
1090      independent code will have arranged for us to see the real
1091      definition first.  We need to copy the needs_copy bit from the
1092      real definition and check it when allowing copy reloc in PIE.  */
1093   unsigned int needs_copy : 1;
1094
1095   /* TRUE if symbol has GOT or PLT relocations.  */
1096   unsigned int has_got_reloc : 1;
1097
1098   /* TRUE if symbol has non-GOT/non-PLT relocations in text sections.  */
1099   unsigned int has_non_got_reloc : 1;
1100
1101   /* Don't call finish_dynamic_symbol on this symbol.  */
1102   unsigned int no_finish_dynamic_symbol : 1;
1103
1104   /* TRUE if symbol symbol is __tls_get_addr.  */
1105   unsigned int tls_get_addr : 1;
1106
1107   /* Reference count of C/C++ function pointer relocations in read-write
1108      section which can be resolved at run-time.  */
1109   bfd_signed_vma func_pointer_refcount;
1110
1111   /* Information about the GOT PLT entry. Filled when there are both
1112      GOT and PLT relocations against the same function.  */
1113   union gotplt_union plt_got;
1114
1115   /* Information about the second PLT entry.   */
1116   union gotplt_union plt_second;
1117
1118   /* Offset of the GOTPLT entry reserved for the TLS descriptor,
1119      starting at the end of the jump table.  */
1120   bfd_vma tlsdesc_got;
1121 };
1122
1123 #define elf_x86_64_hash_entry(ent) \
1124   ((struct elf_x86_64_link_hash_entry *)(ent))
1125
1126 struct elf_x86_64_obj_tdata
1127 {
1128   struct elf_obj_tdata root;
1129
1130   /* tls_type for each local got entry.  */
1131   char *local_got_tls_type;
1132
1133   /* GOTPLT entries for TLS descriptors.  */
1134   bfd_vma *local_tlsdesc_gotent;
1135 };
1136
1137 #define elf_x86_64_tdata(abfd) \
1138   ((struct elf_x86_64_obj_tdata *) (abfd)->tdata.any)
1139
1140 #define elf_x86_64_local_got_tls_type(abfd) \
1141   (elf_x86_64_tdata (abfd)->local_got_tls_type)
1142
1143 #define elf_x86_64_local_tlsdesc_gotent(abfd) \
1144   (elf_x86_64_tdata (abfd)->local_tlsdesc_gotent)
1145
1146 #define is_x86_64_elf(bfd)                              \
1147   (bfd_get_flavour (bfd) == bfd_target_elf_flavour      \
1148    && elf_tdata (bfd) != NULL                           \
1149    && elf_object_id (bfd) == X86_64_ELF_DATA)
1150
1151 static bfd_boolean
1152 elf_x86_64_mkobject (bfd *abfd)
1153 {
1154   return bfd_elf_allocate_object (abfd, sizeof (struct elf_x86_64_obj_tdata),
1155                                   X86_64_ELF_DATA);
1156 }
1157
1158 /* x86-64 ELF linker hash table.  */
1159
1160 struct elf_x86_64_link_hash_table
1161 {
1162   struct elf_link_hash_table elf;
1163
1164   /* Short-cuts to get to dynamic linker sections.  */
1165   asection *interp;
1166   asection *plt_eh_frame;
1167   asection *plt_second;
1168   asection *plt_second_eh_frame;
1169   asection *plt_got;
1170   asection *plt_got_eh_frame;
1171
1172   /* Parameters describing PLT generation, lazy or non-lazy.  */
1173   struct elf_x86_64_plt_layout plt;
1174
1175   /* Parameters describing lazy PLT generation.  */
1176   const struct elf_x86_64_lazy_plt_layout *lazy_plt;
1177
1178   /* Parameters describing non-lazy PLT generation.  */
1179   const struct elf_x86_64_non_lazy_plt_layout *non_lazy_plt;
1180
1181   union
1182   {
1183     bfd_signed_vma refcount;
1184     bfd_vma offset;
1185   } tls_ld_got;
1186
1187   /* The amount of space used by the jump slots in the GOT.  */
1188   bfd_vma sgotplt_jump_table_size;
1189
1190   /* Small local sym cache.  */
1191   struct sym_cache sym_cache;
1192
1193   bfd_vma (*r_info) (bfd_vma, bfd_vma);
1194   bfd_vma (*r_sym) (bfd_vma);
1195   unsigned int pointer_r_type;
1196   const char *dynamic_interpreter;
1197   int dynamic_interpreter_size;
1198
1199   /* _TLS_MODULE_BASE_ symbol.  */
1200   struct bfd_link_hash_entry *tls_module_base;
1201
1202   /* Used by local STT_GNU_IFUNC symbols.  */
1203   htab_t loc_hash_table;
1204   void * loc_hash_memory;
1205
1206   /* The offset into splt of the PLT entry for the TLS descriptor
1207      resolver.  Special values are 0, if not necessary (or not found
1208      to be necessary yet), and -1 if needed but not determined
1209      yet.  */
1210   bfd_vma tlsdesc_plt;
1211   /* The offset into sgot of the GOT entry used by the PLT entry
1212      above.  */
1213   bfd_vma tlsdesc_got;
1214
1215   /* The index of the next R_X86_64_JUMP_SLOT entry in .rela.plt.  */
1216   bfd_vma next_jump_slot_index;
1217   /* The index of the next R_X86_64_IRELATIVE entry in .rela.plt.  */
1218   bfd_vma next_irelative_index;
1219
1220   /* TRUE if there are dynamic relocs against IFUNC symbols that apply
1221      to read-only sections.  */
1222   bfd_boolean readonly_dynrelocs_against_ifunc;
1223 };
1224
1225 /* Get the x86-64 ELF linker hash table from a link_info structure.  */
1226
1227 #define elf_x86_64_hash_table(p) \
1228   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
1229   == X86_64_ELF_DATA ? ((struct elf_x86_64_link_hash_table *) ((p)->hash)) : NULL)
1230
1231 #define elf_x86_64_compute_jump_table_size(htab) \
1232   ((htab)->elf.srelplt->reloc_count * GOT_ENTRY_SIZE)
1233
1234 /* Create an entry in an x86-64 ELF linker hash table.  */
1235
1236 static struct bfd_hash_entry *
1237 elf_x86_64_link_hash_newfunc (struct bfd_hash_entry *entry,
1238                               struct bfd_hash_table *table,
1239                               const char *string)
1240 {
1241   /* Allocate the structure if it has not already been allocated by a
1242      subclass.  */
1243   if (entry == NULL)
1244     {
1245       entry = (struct bfd_hash_entry *)
1246           bfd_hash_allocate (table,
1247                              sizeof (struct elf_x86_64_link_hash_entry));
1248       if (entry == NULL)
1249         return entry;
1250     }
1251
1252   /* Call the allocation method of the superclass.  */
1253   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
1254   if (entry != NULL)
1255     {
1256       struct elf_x86_64_link_hash_entry *eh;
1257
1258       eh = (struct elf_x86_64_link_hash_entry *) entry;
1259       eh->dyn_relocs = NULL;
1260       eh->tls_type = GOT_UNKNOWN;
1261       eh->needs_copy = 0;
1262       eh->has_got_reloc = 0;
1263       eh->has_non_got_reloc = 0;
1264       eh->no_finish_dynamic_symbol = 0;
1265       eh->tls_get_addr = 0;
1266       eh->func_pointer_refcount = 0;
1267       eh->plt_second.offset = (bfd_vma) -1;
1268       eh->plt_got.offset = (bfd_vma) -1;
1269       eh->tlsdesc_got = (bfd_vma) -1;
1270     }
1271
1272   return entry;
1273 }
1274
1275 /* Compute a hash of a local hash entry.  We use elf_link_hash_entry
1276   for local symbol so that we can handle local STT_GNU_IFUNC symbols
1277   as global symbol.  We reuse indx and dynstr_index for local symbol
1278   hash since they aren't used by global symbols in this backend.  */
1279
1280 static hashval_t
1281 elf_x86_64_local_htab_hash (const void *ptr)
1282 {
1283   struct elf_link_hash_entry *h
1284     = (struct elf_link_hash_entry *) ptr;
1285   return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
1286 }
1287
1288 /* Compare local hash entries.  */
1289
1290 static int
1291 elf_x86_64_local_htab_eq (const void *ptr1, const void *ptr2)
1292 {
1293   struct elf_link_hash_entry *h1
1294      = (struct elf_link_hash_entry *) ptr1;
1295   struct elf_link_hash_entry *h2
1296     = (struct elf_link_hash_entry *) ptr2;
1297
1298   return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
1299 }
1300
1301 /* Find and/or create a hash entry for local symbol.  */
1302
1303 static struct elf_link_hash_entry *
1304 elf_x86_64_get_local_sym_hash (struct elf_x86_64_link_hash_table *htab,
1305                                bfd *abfd, const Elf_Internal_Rela *rel,
1306                                bfd_boolean create)
1307 {
1308   struct elf_x86_64_link_hash_entry e, *ret;
1309   asection *sec = abfd->sections;
1310   hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
1311                                        htab->r_sym (rel->r_info));
1312   void **slot;
1313
1314   e.elf.indx = sec->id;
1315   e.elf.dynstr_index = htab->r_sym (rel->r_info);
1316   slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
1317                                    create ? INSERT : NO_INSERT);
1318
1319   if (!slot)
1320     return NULL;
1321
1322   if (*slot)
1323     {
1324       ret = (struct elf_x86_64_link_hash_entry *) *slot;
1325       return &ret->elf;
1326     }
1327
1328   ret = (struct elf_x86_64_link_hash_entry *)
1329         objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
1330                         sizeof (struct elf_x86_64_link_hash_entry));
1331   if (ret)
1332     {
1333       memset (ret, 0, sizeof (*ret));
1334       ret->elf.indx = sec->id;
1335       ret->elf.dynstr_index = htab->r_sym (rel->r_info);
1336       ret->elf.dynindx = -1;
1337       ret->func_pointer_refcount = 0;
1338       ret->plt_got.offset = (bfd_vma) -1;
1339       *slot = ret;
1340     }
1341   return &ret->elf;
1342 }
1343
1344 /* Destroy an X86-64 ELF linker hash table.  */
1345
1346 static void
1347 elf_x86_64_link_hash_table_free (bfd *obfd)
1348 {
1349   struct elf_x86_64_link_hash_table *htab
1350     = (struct elf_x86_64_link_hash_table *) obfd->link.hash;
1351
1352   if (htab->loc_hash_table)
1353     htab_delete (htab->loc_hash_table);
1354   if (htab->loc_hash_memory)
1355     objalloc_free ((struct objalloc *) htab->loc_hash_memory);
1356   _bfd_elf_link_hash_table_free (obfd);
1357 }
1358
1359 /* Create an X86-64 ELF linker hash table.  */
1360
1361 static struct bfd_link_hash_table *
1362 elf_x86_64_link_hash_table_create (bfd *abfd)
1363 {
1364   struct elf_x86_64_link_hash_table *ret;
1365   bfd_size_type amt = sizeof (struct elf_x86_64_link_hash_table);
1366
1367   ret = (struct elf_x86_64_link_hash_table *) bfd_zmalloc (amt);
1368   if (ret == NULL)
1369     return NULL;
1370
1371   if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
1372                                       elf_x86_64_link_hash_newfunc,
1373                                       sizeof (struct elf_x86_64_link_hash_entry),
1374                                       X86_64_ELF_DATA))
1375     {
1376       free (ret);
1377       return NULL;
1378     }
1379
1380   if (ABI_64_P (abfd))
1381     {
1382       ret->r_info = elf64_r_info;
1383       ret->r_sym = elf64_r_sym;
1384       ret->pointer_r_type = R_X86_64_64;
1385       ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER;
1386       ret->dynamic_interpreter_size = sizeof ELF64_DYNAMIC_INTERPRETER;
1387     }
1388   else
1389     {
1390       ret->r_info = elf32_r_info;
1391       ret->r_sym = elf32_r_sym;
1392       ret->pointer_r_type = R_X86_64_32;
1393       ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER;
1394       ret->dynamic_interpreter_size = sizeof ELF32_DYNAMIC_INTERPRETER;
1395     }
1396
1397   ret->loc_hash_table = htab_try_create (1024,
1398                                          elf_x86_64_local_htab_hash,
1399                                          elf_x86_64_local_htab_eq,
1400                                          NULL);
1401   ret->loc_hash_memory = objalloc_create ();
1402   if (!ret->loc_hash_table || !ret->loc_hash_memory)
1403     {
1404       elf_x86_64_link_hash_table_free (abfd);
1405       return NULL;
1406     }
1407   ret->elf.root.hash_table_free = elf_x86_64_link_hash_table_free;
1408
1409   return &ret->elf.root;
1410 }
1411
1412 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
1413
1414 static void
1415 elf_x86_64_copy_indirect_symbol (struct bfd_link_info *info,
1416                                  struct elf_link_hash_entry *dir,
1417                                  struct elf_link_hash_entry *ind)
1418 {
1419   struct elf_x86_64_link_hash_entry *edir, *eind;
1420
1421   edir = (struct elf_x86_64_link_hash_entry *) dir;
1422   eind = (struct elf_x86_64_link_hash_entry *) ind;
1423
1424   edir->has_got_reloc |= eind->has_got_reloc;
1425   edir->has_non_got_reloc |= eind->has_non_got_reloc;
1426
1427   if (eind->dyn_relocs != NULL)
1428     {
1429       if (edir->dyn_relocs != NULL)
1430         {
1431           struct elf_dyn_relocs **pp;
1432           struct elf_dyn_relocs *p;
1433
1434           /* Add reloc counts against the indirect sym to the direct sym
1435              list.  Merge any entries against the same section.  */
1436           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1437             {
1438               struct elf_dyn_relocs *q;
1439
1440               for (q = edir->dyn_relocs; q != NULL; q = q->next)
1441                 if (q->sec == p->sec)
1442                   {
1443                     q->pc_count += p->pc_count;
1444                     q->count += p->count;
1445                     *pp = p->next;
1446                     break;
1447                   }
1448               if (q == NULL)
1449                 pp = &p->next;
1450             }
1451           *pp = edir->dyn_relocs;
1452         }
1453
1454       edir->dyn_relocs = eind->dyn_relocs;
1455       eind->dyn_relocs = NULL;
1456     }
1457
1458   if (ind->root.type == bfd_link_hash_indirect
1459       && dir->got.refcount <= 0)
1460     {
1461       edir->tls_type = eind->tls_type;
1462       eind->tls_type = GOT_UNKNOWN;
1463     }
1464
1465   if (ELIMINATE_COPY_RELOCS
1466       && ind->root.type != bfd_link_hash_indirect
1467       && dir->dynamic_adjusted)
1468     {
1469       /* If called to transfer flags for a weakdef during processing
1470          of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1471          We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
1472       if (dir->versioned != versioned_hidden)
1473         dir->ref_dynamic |= ind->ref_dynamic;
1474       dir->ref_regular |= ind->ref_regular;
1475       dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
1476       dir->needs_plt |= ind->needs_plt;
1477       dir->pointer_equality_needed |= ind->pointer_equality_needed;
1478     }
1479   else
1480     {
1481       if (eind->func_pointer_refcount > 0)
1482         {
1483           edir->func_pointer_refcount += eind->func_pointer_refcount;
1484           eind->func_pointer_refcount = 0;
1485         }
1486
1487       _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1488     }
1489 }
1490
1491 static bfd_boolean
1492 elf64_x86_64_elf_object_p (bfd *abfd)
1493 {
1494   /* Set the right machine number for an x86-64 elf64 file.  */
1495   bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64);
1496   return TRUE;
1497 }
1498
1499 static bfd_boolean
1500 elf32_x86_64_elf_object_p (bfd *abfd)
1501 {
1502   /* Set the right machine number for an x86-64 elf32 file.  */
1503   bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32);
1504   return TRUE;
1505 }
1506
1507 /* Return TRUE if the TLS access code sequence support transition
1508    from R_TYPE.  */
1509
1510 static bfd_boolean
1511 elf_x86_64_check_tls_transition (bfd *abfd,
1512                                  struct bfd_link_info *info,
1513                                  asection *sec,
1514                                  bfd_byte *contents,
1515                                  Elf_Internal_Shdr *symtab_hdr,
1516                                  struct elf_link_hash_entry **sym_hashes,
1517                                  unsigned int r_type,
1518                                  const Elf_Internal_Rela *rel,
1519                                  const Elf_Internal_Rela *relend)
1520 {
1521   unsigned int val;
1522   unsigned long r_symndx;
1523   bfd_boolean largepic = FALSE;
1524   struct elf_link_hash_entry *h;
1525   bfd_vma offset;
1526   struct elf_x86_64_link_hash_table *htab;
1527   bfd_byte *call;
1528   bfd_boolean indirect_call;
1529
1530   htab = elf_x86_64_hash_table (info);
1531   offset = rel->r_offset;
1532   switch (r_type)
1533     {
1534     case R_X86_64_TLSGD:
1535     case R_X86_64_TLSLD:
1536       if ((rel + 1) >= relend)
1537         return FALSE;
1538
1539       if (r_type == R_X86_64_TLSGD)
1540         {
1541           /* Check transition from GD access model.  For 64bit, only
1542                 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1543                 .word 0x6666; rex64; call __tls_get_addr@PLT
1544              or
1545                 .byte 0x66; leaq foo@tlsgd(%rip), %rdi
1546                 .byte 0x66; rex64
1547                 call *__tls_get_addr@GOTPCREL(%rip)
1548                 which may be converted to
1549                 addr32 call __tls_get_addr
1550              can transit to different access model.  For 32bit, only
1551                 leaq foo@tlsgd(%rip), %rdi
1552                 .word 0x6666; rex64; call __tls_get_addr@PLT
1553              or
1554                 leaq foo@tlsgd(%rip), %rdi
1555                 .byte 0x66; rex64
1556                 call *__tls_get_addr@GOTPCREL(%rip)
1557                 which may be converted to
1558                 addr32 call __tls_get_addr
1559              can transit to different access model.  For largepic,
1560              we also support:
1561                 leaq foo@tlsgd(%rip), %rdi
1562                 movabsq $__tls_get_addr@pltoff, %rax
1563                 addq $r15, %rax
1564                 call *%rax
1565              or
1566                 leaq foo@tlsgd(%rip), %rdi
1567                 movabsq $__tls_get_addr@pltoff, %rax
1568                 addq $rbx, %rax
1569                 call *%rax  */
1570
1571           static const unsigned char leaq[] = { 0x66, 0x48, 0x8d, 0x3d };
1572
1573           if ((offset + 12) > sec->size)
1574             return FALSE;
1575
1576           call = contents + offset + 4;
1577           if (call[0] != 0x66
1578               || !((call[1] == 0x48
1579                     && call[2] == 0xff
1580                     && call[3] == 0x15)
1581                    || (call[1] == 0x48
1582                        && call[2] == 0x67
1583                        && call[3] == 0xe8)
1584                    || (call[1] == 0x66
1585                        && call[2] == 0x48
1586                        && call[3] == 0xe8)))
1587             {
1588               if (!ABI_64_P (abfd)
1589                   || (offset + 19) > sec->size
1590                   || offset < 3
1591                   || memcmp (call - 7, leaq + 1, 3) != 0
1592                   || memcmp (call, "\x48\xb8", 2) != 0
1593                   || call[11] != 0x01
1594                   || call[13] != 0xff
1595                   || call[14] != 0xd0
1596                   || !((call[10] == 0x48 && call[12] == 0xd8)
1597                        || (call[10] == 0x4c && call[12] == 0xf8)))
1598                 return FALSE;
1599               largepic = TRUE;
1600             }
1601           else if (ABI_64_P (abfd))
1602             {
1603               if (offset < 4
1604                   || memcmp (contents + offset - 4, leaq, 4) != 0)
1605                 return FALSE;
1606             }
1607           else
1608             {
1609               if (offset < 3
1610                   || memcmp (contents + offset - 3, leaq + 1, 3) != 0)
1611                 return FALSE;
1612             }
1613           indirect_call = call[2] == 0xff;
1614         }
1615       else
1616         {
1617           /* Check transition from LD access model.  Only
1618                 leaq foo@tlsld(%rip), %rdi;
1619                 call __tls_get_addr@PLT
1620              or
1621                 leaq foo@tlsld(%rip), %rdi;
1622                 call *__tls_get_addr@GOTPCREL(%rip)
1623                 which may be converted to
1624                 addr32 call __tls_get_addr
1625              can transit to different access model.  For largepic
1626              we also support:
1627                 leaq foo@tlsld(%rip), %rdi
1628                 movabsq $__tls_get_addr@pltoff, %rax
1629                 addq $r15, %rax
1630                 call *%rax
1631              or
1632                 leaq foo@tlsld(%rip), %rdi
1633                 movabsq $__tls_get_addr@pltoff, %rax
1634                 addq $rbx, %rax
1635                 call *%rax  */
1636
1637           static const unsigned char lea[] = { 0x48, 0x8d, 0x3d };
1638
1639           if (offset < 3 || (offset + 9) > sec->size)
1640             return FALSE;
1641
1642           if (memcmp (contents + offset - 3, lea, 3) != 0)
1643             return FALSE;
1644
1645           call = contents + offset + 4;
1646           if (!(call[0] == 0xe8
1647                 || (call[0] == 0xff && call[1] == 0x15)
1648                 || (call[0] == 0x67 && call[1] == 0xe8)))
1649             {
1650               if (!ABI_64_P (abfd)
1651                   || (offset + 19) > sec->size
1652                   || memcmp (call, "\x48\xb8", 2) != 0
1653                   || call[11] != 0x01
1654                   || call[13] != 0xff
1655                   || call[14] != 0xd0
1656                   || !((call[10] == 0x48 && call[12] == 0xd8)
1657                        || (call[10] == 0x4c && call[12] == 0xf8)))
1658                 return FALSE;
1659               largepic = TRUE;
1660             }
1661           indirect_call = call[0] == 0xff;
1662         }
1663
1664       r_symndx = htab->r_sym (rel[1].r_info);
1665       if (r_symndx < symtab_hdr->sh_info)
1666         return FALSE;
1667
1668       h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1669       if (h == NULL
1670           || !((struct elf_x86_64_link_hash_entry *) h)->tls_get_addr)
1671         return FALSE;
1672       else if (largepic)
1673         return ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PLTOFF64;
1674       else if (indirect_call)
1675         return ELF32_R_TYPE (rel[1].r_info) == R_X86_64_GOTPCRELX;
1676       else
1677         return (ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PC32
1678                 || ELF32_R_TYPE (rel[1].r_info) == R_X86_64_PLT32);
1679
1680     case R_X86_64_GOTTPOFF:
1681       /* Check transition from IE access model:
1682                 mov foo@gottpoff(%rip), %reg
1683                 add foo@gottpoff(%rip), %reg
1684        */
1685
1686       /* Check REX prefix first.  */
1687       if (offset >= 3 && (offset + 4) <= sec->size)
1688         {
1689           val = bfd_get_8 (abfd, contents + offset - 3);
1690           if (val != 0x48 && val != 0x4c)
1691             {
1692               /* X32 may have 0x44 REX prefix or no REX prefix.  */
1693               if (ABI_64_P (abfd))
1694                 return FALSE;
1695             }
1696         }
1697       else
1698         {
1699           /* X32 may not have any REX prefix.  */
1700           if (ABI_64_P (abfd))
1701             return FALSE;
1702           if (offset < 2 || (offset + 3) > sec->size)
1703             return FALSE;
1704         }
1705
1706       val = bfd_get_8 (abfd, contents + offset - 2);
1707       if (val != 0x8b && val != 0x03)
1708         return FALSE;
1709
1710       val = bfd_get_8 (abfd, contents + offset - 1);
1711       return (val & 0xc7) == 5;
1712
1713     case R_X86_64_GOTPC32_TLSDESC:
1714       /* Check transition from GDesc access model:
1715                 leaq x@tlsdesc(%rip), %rax
1716
1717          Make sure it's a leaq adding rip to a 32-bit offset
1718          into any register, although it's probably almost always
1719          going to be rax.  */
1720
1721       if (offset < 3 || (offset + 4) > sec->size)
1722         return FALSE;
1723
1724       val = bfd_get_8 (abfd, contents + offset - 3);
1725       if ((val & 0xfb) != 0x48)
1726         return FALSE;
1727
1728       if (bfd_get_8 (abfd, contents + offset - 2) != 0x8d)
1729         return FALSE;
1730
1731       val = bfd_get_8 (abfd, contents + offset - 1);
1732       return (val & 0xc7) == 0x05;
1733
1734     case R_X86_64_TLSDESC_CALL:
1735       /* Check transition from GDesc access model:
1736                 call *x@tlsdesc(%rax)
1737        */
1738       if (offset + 2 <= sec->size)
1739         {
1740           /* Make sure that it's a call *x@tlsdesc(%rax).  */
1741           call = contents + offset;
1742           return call[0] == 0xff && call[1] == 0x10;
1743         }
1744
1745       return FALSE;
1746
1747     default:
1748       abort ();
1749     }
1750 }
1751
1752 /* Return TRUE if the TLS access transition is OK or no transition
1753    will be performed.  Update R_TYPE if there is a transition.  */
1754
1755 static bfd_boolean
1756 elf_x86_64_tls_transition (struct bfd_link_info *info, bfd *abfd,
1757                            asection *sec, bfd_byte *contents,
1758                            Elf_Internal_Shdr *symtab_hdr,
1759                            struct elf_link_hash_entry **sym_hashes,
1760                            unsigned int *r_type, int tls_type,
1761                            const Elf_Internal_Rela *rel,
1762                            const Elf_Internal_Rela *relend,
1763                            struct elf_link_hash_entry *h,
1764                            unsigned long r_symndx,
1765                            bfd_boolean from_relocate_section)
1766 {
1767   unsigned int from_type = *r_type;
1768   unsigned int to_type = from_type;
1769   bfd_boolean check = TRUE;
1770
1771   /* Skip TLS transition for functions.  */
1772   if (h != NULL
1773       && (h->type == STT_FUNC
1774           || h->type == STT_GNU_IFUNC))
1775     return TRUE;
1776
1777   switch (from_type)
1778     {
1779     case R_X86_64_TLSGD:
1780     case R_X86_64_GOTPC32_TLSDESC:
1781     case R_X86_64_TLSDESC_CALL:
1782     case R_X86_64_GOTTPOFF:
1783       if (bfd_link_executable (info))
1784         {
1785           if (h == NULL)
1786             to_type = R_X86_64_TPOFF32;
1787           else
1788             to_type = R_X86_64_GOTTPOFF;
1789         }
1790
1791       /* When we are called from elf_x86_64_relocate_section, there may
1792          be additional transitions based on TLS_TYPE.  */
1793       if (from_relocate_section)
1794         {
1795           unsigned int new_to_type = to_type;
1796
1797           if (bfd_link_executable (info)
1798               && h != NULL
1799               && h->dynindx == -1
1800               && tls_type == GOT_TLS_IE)
1801             new_to_type = R_X86_64_TPOFF32;
1802
1803           if (to_type == R_X86_64_TLSGD
1804               || to_type == R_X86_64_GOTPC32_TLSDESC
1805               || to_type == R_X86_64_TLSDESC_CALL)
1806             {
1807               if (tls_type == GOT_TLS_IE)
1808                 new_to_type = R_X86_64_GOTTPOFF;
1809             }
1810
1811           /* We checked the transition before when we were called from
1812              elf_x86_64_check_relocs.  We only want to check the new
1813              transition which hasn't been checked before.  */
1814           check = new_to_type != to_type && from_type == to_type;
1815           to_type = new_to_type;
1816         }
1817
1818       break;
1819
1820     case R_X86_64_TLSLD:
1821       if (bfd_link_executable (info))
1822         to_type = R_X86_64_TPOFF32;
1823       break;
1824
1825     default:
1826       return TRUE;
1827     }
1828
1829   /* Return TRUE if there is no transition.  */
1830   if (from_type == to_type)
1831     return TRUE;
1832
1833   /* Check if the transition can be performed.  */
1834   if (check
1835       && ! elf_x86_64_check_tls_transition (abfd, info, sec, contents,
1836                                             symtab_hdr, sym_hashes,
1837                                             from_type, rel, relend))
1838     {
1839       reloc_howto_type *from, *to;
1840       const char *name;
1841
1842       from = elf_x86_64_rtype_to_howto (abfd, from_type);
1843       to = elf_x86_64_rtype_to_howto (abfd, to_type);
1844
1845       if (h)
1846         name = h->root.root.string;
1847       else
1848         {
1849           struct elf_x86_64_link_hash_table *htab;
1850
1851           htab = elf_x86_64_hash_table (info);
1852           if (htab == NULL)
1853             name = "*unknown*";
1854           else
1855             {
1856               Elf_Internal_Sym *isym;
1857
1858               isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1859                                             abfd, r_symndx);
1860               name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1861             }
1862         }
1863
1864       _bfd_error_handler
1865         /* xgettext:c-format */
1866         (_("%B: TLS transition from %s to %s against `%s' at %#Lx "
1867            "in section `%A' failed"),
1868          abfd, from->name, to->name, name, rel->r_offset, sec);
1869       bfd_set_error (bfd_error_bad_value);
1870       return FALSE;
1871     }
1872
1873   *r_type = to_type;
1874   return TRUE;
1875 }
1876
1877 /* Rename some of the generic section flags to better document how they
1878    are used here.  */
1879 #define need_convert_load       sec_flg0
1880 #define check_relocs_failed     sec_flg1
1881
1882 static bfd_boolean
1883 elf_x86_64_need_pic (bfd *input_bfd, asection *sec,
1884                      struct elf_link_hash_entry *h,
1885                      Elf_Internal_Shdr *symtab_hdr,
1886                      Elf_Internal_Sym *isym,
1887                      reloc_howto_type *howto)
1888 {
1889   const char *v = "";
1890   const char *und = "";
1891   const char *pic = "";
1892
1893   const char *name;
1894   if (h)
1895     {
1896       name = h->root.root.string;
1897       switch (ELF_ST_VISIBILITY (h->other))
1898         {
1899         case STV_HIDDEN:
1900           v = _("hidden symbol ");
1901           break;
1902         case STV_INTERNAL:
1903           v = _("internal symbol ");
1904           break;
1905         case STV_PROTECTED:
1906           v = _("protected symbol ");
1907           break;
1908         default:
1909           v = _("symbol ");
1910           pic = _("; recompile with -fPIC");
1911           break;
1912         }
1913
1914       if (!h->def_regular && !h->def_dynamic)
1915         und = _("undefined ");
1916     }
1917   else
1918     {
1919       name = bfd_elf_sym_name (input_bfd, symtab_hdr, isym, NULL);
1920       pic = _("; recompile with -fPIC");
1921     }
1922
1923   /* xgettext:c-format */
1924   _bfd_error_handler (_("%B: relocation %s against %s%s`%s' can "
1925                         "not be used when making a shared object%s"),
1926                       input_bfd, howto->name, und, v, name, pic);
1927   bfd_set_error (bfd_error_bad_value);
1928   sec->check_relocs_failed = 1;
1929   return FALSE;
1930 }
1931
1932 /* With the local symbol, foo, we convert
1933    mov foo@GOTPCREL(%rip), %reg
1934    to
1935    lea foo(%rip), %reg
1936    and convert
1937    call/jmp *foo@GOTPCREL(%rip)
1938    to
1939    nop call foo/jmp foo nop
1940    When PIC is false, convert
1941    test %reg, foo@GOTPCREL(%rip)
1942    to
1943    test $foo, %reg
1944    and convert
1945    binop foo@GOTPCREL(%rip), %reg
1946    to
1947    binop $foo, %reg
1948    where binop is one of adc, add, and, cmp, or, sbb, sub, xor
1949    instructions.  */
1950
1951 static bfd_boolean
1952 elf_x86_64_convert_load_reloc (bfd *abfd, asection *sec,
1953                                bfd_byte *contents,
1954                                Elf_Internal_Rela *irel,
1955                                struct elf_link_hash_entry *h,
1956                                bfd_boolean *converted,
1957                                struct bfd_link_info *link_info)
1958 {
1959   struct elf_x86_64_link_hash_table *htab;
1960   bfd_boolean is_pic;
1961   bfd_boolean require_reloc_pc32;
1962   bfd_boolean relocx;
1963   bfd_boolean to_reloc_pc32;
1964   asection *tsec;
1965   char symtype;
1966   bfd_signed_vma raddend;
1967   unsigned int opcode;
1968   unsigned int modrm;
1969   unsigned int r_type = ELF32_R_TYPE (irel->r_info);
1970   unsigned int r_symndx;
1971   bfd_vma toff;
1972   bfd_vma roff = irel->r_offset;
1973
1974   if (roff < (r_type == R_X86_64_REX_GOTPCRELX ? 3 : 2))
1975     return TRUE;
1976
1977   raddend = irel->r_addend;
1978   /* Addend for 32-bit PC-relative relocation must be -4.  */
1979   if (raddend != -4)
1980     return TRUE;
1981
1982   htab = elf_x86_64_hash_table (link_info);
1983   is_pic = bfd_link_pic (link_info);
1984
1985   relocx = (r_type == R_X86_64_GOTPCRELX
1986             || r_type == R_X86_64_REX_GOTPCRELX);
1987
1988   /* TRUE if we can convert only to R_X86_64_PC32.  Enable it for
1989      --no-relax.  */
1990   require_reloc_pc32
1991     = link_info->disable_target_specific_optimizations > 1;
1992
1993   r_symndx = htab->r_sym (irel->r_info);
1994
1995   opcode = bfd_get_8 (abfd, contents + roff - 2);
1996
1997   /* Convert mov to lea since it has been done for a while.  */
1998   if (opcode != 0x8b)
1999     {
2000       /* Only convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX
2001          for call, jmp or one of adc, add, and, cmp, or, sbb, sub,
2002          test, xor instructions.  */
2003       if (!relocx)
2004         return TRUE;
2005     }
2006
2007   /* We convert only to R_X86_64_PC32:
2008      1. Branch.
2009      2. R_X86_64_GOTPCREL since we can't modify REX byte.
2010      3. require_reloc_pc32 is true.
2011      4. PIC.
2012      */
2013   to_reloc_pc32 = (opcode == 0xff
2014                    || !relocx
2015                    || require_reloc_pc32
2016                    || is_pic);
2017
2018   /* Get the symbol referred to by the reloc.  */
2019   if (h == NULL)
2020     {
2021       Elf_Internal_Sym *isym
2022         = bfd_sym_from_r_symndx (&htab->sym_cache, abfd, r_symndx);
2023
2024       /* Skip relocation against undefined symbols.  */
2025       if (isym->st_shndx == SHN_UNDEF)
2026         return TRUE;
2027
2028       symtype = ELF_ST_TYPE (isym->st_info);
2029
2030       if (isym->st_shndx == SHN_ABS)
2031         tsec = bfd_abs_section_ptr;
2032       else if (isym->st_shndx == SHN_COMMON)
2033         tsec = bfd_com_section_ptr;
2034       else if (isym->st_shndx == SHN_X86_64_LCOMMON)
2035         tsec = &_bfd_elf_large_com_section;
2036       else
2037         tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2038
2039       toff = isym->st_value;
2040     }
2041   else
2042     {
2043       /* Undefined weak symbol is only bound locally in executable
2044          and its reference is resolved as 0 without relocation
2045          overflow.  We can only perform this optimization for
2046          GOTPCRELX relocations since we need to modify REX byte.
2047          It is OK convert mov with R_X86_64_GOTPCREL to
2048          R_X86_64_PC32.  */
2049       if ((relocx || opcode == 0x8b)
2050           && UNDEFINED_WEAK_RESOLVED_TO_ZERO (link_info,
2051                                               TRUE,
2052                                               elf_x86_64_hash_entry (h)))
2053         {
2054           if (opcode == 0xff)
2055             {
2056               /* Skip for branch instructions since R_X86_64_PC32
2057                  may overflow.  */
2058               if (require_reloc_pc32)
2059                 return TRUE;
2060             }
2061           else if (relocx)
2062             {
2063               /* For non-branch instructions, we can convert to
2064                  R_X86_64_32/R_X86_64_32S since we know if there
2065                  is a REX byte.  */
2066               to_reloc_pc32 = FALSE;
2067             }
2068
2069           /* Since we don't know the current PC when PIC is true,
2070              we can't convert to R_X86_64_PC32.  */
2071           if (to_reloc_pc32 && is_pic)
2072             return TRUE;
2073
2074           goto convert;
2075         }
2076       /* Avoid optimizing GOTPCREL relocations againt _DYNAMIC since
2077          ld.so may use its link-time address.  */
2078       else if (h->start_stop
2079                || ((h->def_regular
2080                     || h->root.type == bfd_link_hash_defined
2081                     || h->root.type == bfd_link_hash_defweak)
2082                    && h != htab->elf.hdynamic
2083                    && SYMBOL_REFERENCES_LOCAL (link_info, h)))
2084         {
2085           /* bfd_link_hash_new or bfd_link_hash_undefined is
2086              set by an assignment in a linker script in
2087              bfd_elf_record_link_assignment.  start_stop is set
2088              on __start_SECNAME/__stop_SECNAME which mark section
2089              SECNAME.  */
2090           if (h->start_stop
2091               || (h->def_regular
2092                   && (h->root.type == bfd_link_hash_new
2093                       || h->root.type == bfd_link_hash_undefined
2094                       || ((h->root.type == bfd_link_hash_defined
2095                            || h->root.type == bfd_link_hash_defweak)
2096                           && h->root.u.def.section == bfd_und_section_ptr))))
2097             {
2098               /* Skip since R_X86_64_32/R_X86_64_32S may overflow.  */
2099               if (require_reloc_pc32)
2100                 return TRUE;
2101               goto convert;
2102             }
2103           tsec = h->root.u.def.section;
2104           toff = h->root.u.def.value;
2105           symtype = h->type;
2106         }
2107       else
2108         return TRUE;
2109     }
2110
2111   /* Don't convert GOTPCREL relocation against large section.  */
2112   if (elf_section_data (tsec) !=  NULL
2113       && (elf_section_flags (tsec) & SHF_X86_64_LARGE) != 0)
2114     return TRUE;
2115
2116   /* We can only estimate relocation overflow for R_X86_64_PC32.  */
2117   if (!to_reloc_pc32)
2118     goto convert;
2119
2120   if (tsec->sec_info_type == SEC_INFO_TYPE_MERGE)
2121     {
2122       /* At this stage in linking, no SEC_MERGE symbol has been
2123          adjusted, so all references to such symbols need to be
2124          passed through _bfd_merged_section_offset.  (Later, in
2125          relocate_section, all SEC_MERGE symbols *except* for
2126          section symbols have been adjusted.)
2127
2128          gas may reduce relocations against symbols in SEC_MERGE
2129          sections to a relocation against the section symbol when
2130          the original addend was zero.  When the reloc is against
2131          a section symbol we should include the addend in the
2132          offset passed to _bfd_merged_section_offset, since the
2133          location of interest is the original symbol.  On the
2134          other hand, an access to "sym+addend" where "sym" is not
2135          a section symbol should not include the addend;  Such an
2136          access is presumed to be an offset from "sym";  The
2137          location of interest is just "sym".  */
2138       if (symtype == STT_SECTION)
2139         toff += raddend;
2140
2141       toff = _bfd_merged_section_offset (abfd, &tsec,
2142                                          elf_section_data (tsec)->sec_info,
2143                                          toff);
2144
2145       if (symtype != STT_SECTION)
2146         toff += raddend;
2147     }
2148   else
2149     toff += raddend;
2150
2151   /* Don't convert if R_X86_64_PC32 relocation overflows.  */
2152   if (tsec->output_section == sec->output_section)
2153     {
2154       if ((toff - roff + 0x80000000) > 0xffffffff)
2155         return TRUE;
2156     }
2157   else
2158     {
2159       bfd_signed_vma distance;
2160
2161       /* At this point, we don't know the load addresses of TSEC
2162          section nor SEC section.  We estimate the distrance between
2163          SEC and TSEC.  We store the estimated distances in the
2164          compressed_size field of the output section, which is only
2165          used to decompress the compressed input section.  */
2166       if (sec->output_section->compressed_size == 0)
2167         {
2168           asection *asect;
2169           bfd_size_type size = 0;
2170           for (asect = link_info->output_bfd->sections;
2171                asect != NULL;
2172                asect = asect->next)
2173             /* Skip debug sections since compressed_size is used to
2174                compress debug sections.  */
2175             if ((asect->flags & SEC_DEBUGGING) == 0)
2176               {
2177                 asection *i;
2178                 for (i = asect->map_head.s;
2179                      i != NULL;
2180                      i = i->map_head.s)
2181                   {
2182                     size = align_power (size, i->alignment_power);
2183                     size += i->size;
2184                   }
2185                 asect->compressed_size = size;
2186               }
2187         }
2188
2189       /* Don't convert GOTPCREL relocations if TSEC isn't placed
2190          after SEC.  */
2191       distance = (tsec->output_section->compressed_size
2192                   - sec->output_section->compressed_size);
2193       if (distance < 0)
2194         return TRUE;
2195
2196       /* Take PT_GNU_RELRO segment into account by adding
2197          maxpagesize.  */
2198       if ((toff + distance + get_elf_backend_data (abfd)->maxpagesize
2199            - roff + 0x80000000) > 0xffffffff)
2200         return TRUE;
2201     }
2202
2203 convert:
2204   if (opcode == 0xff)
2205     {
2206       /* We have "call/jmp *foo@GOTPCREL(%rip)".  */
2207       unsigned int nop;
2208       unsigned int disp;
2209       bfd_vma nop_offset;
2210
2211       /* Convert R_X86_64_GOTPCRELX and R_X86_64_REX_GOTPCRELX to
2212          R_X86_64_PC32.  */
2213       modrm = bfd_get_8 (abfd, contents + roff - 1);
2214       if (modrm == 0x25)
2215         {
2216           /* Convert to "jmp foo nop".  */
2217           modrm = 0xe9;
2218           nop = NOP_OPCODE;
2219           nop_offset = irel->r_offset + 3;
2220           disp = bfd_get_32 (abfd, contents + irel->r_offset);
2221           irel->r_offset -= 1;
2222           bfd_put_32 (abfd, disp, contents + irel->r_offset);
2223         }
2224       else
2225         {
2226           struct elf_x86_64_link_hash_entry *eh
2227             = (struct elf_x86_64_link_hash_entry *) h;
2228
2229           /* Convert to "nop call foo".  ADDR_PREFIX_OPCODE
2230              is a nop prefix.  */
2231           modrm = 0xe8;
2232           /* To support TLS optimization, always use addr32 prefix for
2233              "call *__tls_get_addr@GOTPCREL(%rip)".  */
2234           if (eh && eh->tls_get_addr)
2235             {
2236               nop = 0x67;
2237               nop_offset = irel->r_offset - 2;
2238             }
2239           else
2240             {
2241               nop = link_info->call_nop_byte;
2242               if (link_info->call_nop_as_suffix)
2243                 {
2244                   nop_offset = irel->r_offset + 3;
2245                   disp = bfd_get_32 (abfd, contents + irel->r_offset);
2246                   irel->r_offset -= 1;
2247                   bfd_put_32 (abfd, disp, contents + irel->r_offset);
2248                 }
2249               else
2250                 nop_offset = irel->r_offset - 2;
2251             }
2252         }
2253       bfd_put_8 (abfd, nop, contents + nop_offset);
2254       bfd_put_8 (abfd, modrm, contents + irel->r_offset - 1);
2255       r_type = R_X86_64_PC32;
2256     }
2257   else
2258     {
2259       unsigned int rex;
2260       unsigned int rex_mask = REX_R;
2261
2262       if (r_type == R_X86_64_REX_GOTPCRELX)
2263         rex = bfd_get_8 (abfd, contents + roff - 3);
2264       else
2265         rex = 0;
2266
2267       if (opcode == 0x8b)
2268         {
2269           if (to_reloc_pc32)
2270             {
2271               /* Convert "mov foo@GOTPCREL(%rip), %reg" to
2272                  "lea foo(%rip), %reg".  */
2273               opcode = 0x8d;
2274               r_type = R_X86_64_PC32;
2275             }
2276           else
2277             {
2278               /* Convert "mov foo@GOTPCREL(%rip), %reg" to
2279                  "mov $foo, %reg".  */
2280               opcode = 0xc7;
2281               modrm = bfd_get_8 (abfd, contents + roff - 1);
2282               modrm = 0xc0 | (modrm & 0x38) >> 3;
2283               if ((rex & REX_W) != 0
2284                   && ABI_64_P (link_info->output_bfd))
2285                 {
2286                   /* Keep the REX_W bit in REX byte for LP64.  */
2287                   r_type = R_X86_64_32S;
2288                   goto rewrite_modrm_rex;
2289                 }
2290               else
2291                 {
2292                   /* If the REX_W bit in REX byte isn't needed,
2293                      use R_X86_64_32 and clear the W bit to avoid
2294                      sign-extend imm32 to imm64.  */
2295                   r_type = R_X86_64_32;
2296                   /* Clear the W bit in REX byte.  */
2297                   rex_mask |= REX_W;
2298                   goto rewrite_modrm_rex;
2299                 }
2300             }
2301         }
2302       else
2303         {
2304           /* R_X86_64_PC32 isn't supported.  */
2305           if (to_reloc_pc32)
2306             return TRUE;
2307
2308           modrm = bfd_get_8 (abfd, contents + roff - 1);
2309           if (opcode == 0x85)
2310             {
2311               /* Convert "test %reg, foo@GOTPCREL(%rip)" to
2312                  "test $foo, %reg".  */
2313               modrm = 0xc0 | (modrm & 0x38) >> 3;
2314               opcode = 0xf7;
2315             }
2316           else
2317             {
2318               /* Convert "binop foo@GOTPCREL(%rip), %reg" to
2319                  "binop $foo, %reg".  */
2320               modrm = 0xc0 | (modrm & 0x38) >> 3 | (opcode & 0x3c);
2321               opcode = 0x81;
2322             }
2323
2324           /* Use R_X86_64_32 with 32-bit operand to avoid relocation
2325              overflow when sign-extending imm32 to imm64.  */
2326           r_type = (rex & REX_W) != 0 ? R_X86_64_32S : R_X86_64_32;
2327
2328 rewrite_modrm_rex:
2329           bfd_put_8 (abfd, modrm, contents + roff - 1);
2330
2331           if (rex)
2332             {
2333               /* Move the R bit to the B bit in REX byte.  */
2334               rex = (rex & ~rex_mask) | (rex & REX_R) >> 2;
2335               bfd_put_8 (abfd, rex, contents + roff - 3);
2336             }
2337
2338           /* No addend for R_X86_64_32/R_X86_64_32S relocations.  */
2339           irel->r_addend = 0;
2340         }
2341
2342       bfd_put_8 (abfd, opcode, contents + roff - 2);
2343     }
2344
2345   irel->r_info = htab->r_info (r_symndx, r_type);
2346
2347   *converted = TRUE;
2348
2349   return TRUE;
2350 }
2351
2352 /* Look through the relocs for a section during the first phase, and
2353    calculate needed space in the global offset table, procedure
2354    linkage table, and dynamic reloc sections.  */
2355
2356 static bfd_boolean
2357 elf_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info,
2358                          asection *sec,
2359                          const Elf_Internal_Rela *relocs)
2360 {
2361   struct elf_x86_64_link_hash_table *htab;
2362   Elf_Internal_Shdr *symtab_hdr;
2363   struct elf_link_hash_entry **sym_hashes;
2364   const Elf_Internal_Rela *rel;
2365   const Elf_Internal_Rela *rel_end;
2366   asection *sreloc;
2367   bfd_byte *contents;
2368
2369   if (bfd_link_relocatable (info))
2370     return TRUE;
2371
2372   /* Don't do anything special with non-loaded, non-alloced sections.
2373      In particular, any relocs in such sections should not affect GOT
2374      and PLT reference counting (ie. we don't allow them to create GOT
2375      or PLT entries), there's no possibility or desire to optimize TLS
2376      relocs, and there's not much point in propagating relocs to shared
2377      libs that the dynamic linker won't relocate.  */
2378   if ((sec->flags & SEC_ALLOC) == 0)
2379     return TRUE;
2380
2381   BFD_ASSERT (is_x86_64_elf (abfd));
2382
2383   htab = elf_x86_64_hash_table (info);
2384   if (htab == NULL)
2385     {
2386       sec->check_relocs_failed = 1;
2387       return FALSE;
2388     }
2389
2390   /* Get the section contents.  */
2391   if (elf_section_data (sec)->this_hdr.contents != NULL)
2392     contents = elf_section_data (sec)->this_hdr.contents;
2393   else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
2394     {
2395       sec->check_relocs_failed = 1;
2396       return FALSE;
2397     }
2398
2399   symtab_hdr = &elf_symtab_hdr (abfd);
2400   sym_hashes = elf_sym_hashes (abfd);
2401
2402   sreloc = NULL;
2403
2404   rel_end = relocs + sec->reloc_count;
2405   for (rel = relocs; rel < rel_end; rel++)
2406     {
2407       unsigned int r_type;
2408       unsigned int r_symndx;
2409       struct elf_link_hash_entry *h;
2410       struct elf_x86_64_link_hash_entry *eh;
2411       Elf_Internal_Sym *isym;
2412       const char *name;
2413       bfd_boolean size_reloc;
2414
2415       r_symndx = htab->r_sym (rel->r_info);
2416       r_type = ELF32_R_TYPE (rel->r_info);
2417
2418       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
2419         {
2420           /* xgettext:c-format */
2421           _bfd_error_handler (_("%B: bad symbol index: %d"),
2422                               abfd, r_symndx);
2423           goto error_return;
2424         }
2425
2426       if (r_symndx < symtab_hdr->sh_info)
2427         {
2428           /* A local symbol.  */
2429           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2430                                         abfd, r_symndx);
2431           if (isym == NULL)
2432             goto error_return;
2433
2434           /* Check relocation against local STT_GNU_IFUNC symbol.  */
2435           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
2436             {
2437               h = elf_x86_64_get_local_sym_hash (htab, abfd, rel,
2438                                                  TRUE);
2439               if (h == NULL)
2440                 goto error_return;
2441
2442               /* Fake a STT_GNU_IFUNC symbol.  */
2443               h->root.root.string = bfd_elf_sym_name (abfd, symtab_hdr,
2444                                                       isym, NULL);
2445               h->type = STT_GNU_IFUNC;
2446               h->def_regular = 1;
2447               h->ref_regular = 1;
2448               h->forced_local = 1;
2449               h->root.type = bfd_link_hash_defined;
2450             }
2451           else
2452             h = NULL;
2453         }
2454       else
2455         {
2456           isym = NULL;
2457           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2458           while (h->root.type == bfd_link_hash_indirect
2459                  || h->root.type == bfd_link_hash_warning)
2460             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2461         }
2462
2463       /* Check invalid x32 relocations.  */
2464       if (!ABI_64_P (abfd))
2465         switch (r_type)
2466           {
2467           default:
2468             break;
2469
2470           case R_X86_64_DTPOFF64:
2471           case R_X86_64_TPOFF64:
2472           case R_X86_64_PC64:
2473           case R_X86_64_GOTOFF64:
2474           case R_X86_64_GOT64:
2475           case R_X86_64_GOTPCREL64:
2476           case R_X86_64_GOTPC64:
2477           case R_X86_64_GOTPLT64:
2478           case R_X86_64_PLTOFF64:
2479               {
2480                 if (h)
2481                   name = h->root.root.string;
2482                 else
2483                   name = bfd_elf_sym_name (abfd, symtab_hdr, isym,
2484                                            NULL);
2485                 _bfd_error_handler
2486                   /* xgettext:c-format */
2487                   (_("%B: relocation %s against symbol `%s' isn't "
2488                      "supported in x32 mode"), abfd,
2489                    x86_64_elf_howto_table[r_type].name, name);
2490                 bfd_set_error (bfd_error_bad_value);
2491                 goto error_return;
2492               }
2493             break;
2494           }
2495
2496       if (h != NULL)
2497         {
2498           /* It is referenced by a non-shared object. */
2499           h->ref_regular = 1;
2500           h->root.non_ir_ref_regular = 1;
2501
2502           if (h->type == STT_GNU_IFUNC)
2503             elf_tdata (info->output_bfd)->has_gnu_symbols
2504               |= elf_gnu_symbol_ifunc;
2505         }
2506
2507       if (! elf_x86_64_tls_transition (info, abfd, sec, contents,
2508                                        symtab_hdr, sym_hashes,
2509                                        &r_type, GOT_UNKNOWN,
2510                                        rel, rel_end, h, r_symndx, FALSE))
2511         goto error_return;
2512
2513       eh = (struct elf_x86_64_link_hash_entry *) h;
2514       switch (r_type)
2515         {
2516         case R_X86_64_TLSLD:
2517           htab->tls_ld_got.refcount += 1;
2518           goto create_got;
2519
2520         case R_X86_64_TPOFF32:
2521           if (!bfd_link_executable (info) && ABI_64_P (abfd))
2522             return elf_x86_64_need_pic (abfd, sec, h, symtab_hdr, isym,
2523                                         &x86_64_elf_howto_table[r_type]);
2524           if (eh != NULL)
2525             eh->has_got_reloc = 1;
2526           break;
2527
2528         case R_X86_64_GOTTPOFF:
2529           if (!bfd_link_executable (info))
2530             info->flags |= DF_STATIC_TLS;
2531           /* Fall through */
2532
2533         case R_X86_64_GOT32:
2534         case R_X86_64_GOTPCREL:
2535         case R_X86_64_GOTPCRELX:
2536         case R_X86_64_REX_GOTPCRELX:
2537         case R_X86_64_TLSGD:
2538         case R_X86_64_GOT64:
2539         case R_X86_64_GOTPCREL64:
2540         case R_X86_64_GOTPLT64:
2541         case R_X86_64_GOTPC32_TLSDESC:
2542         case R_X86_64_TLSDESC_CALL:
2543           /* This symbol requires a global offset table entry.  */
2544           {
2545             int tls_type, old_tls_type;
2546
2547             switch (r_type)
2548               {
2549               default: tls_type = GOT_NORMAL; break;
2550               case R_X86_64_TLSGD: tls_type = GOT_TLS_GD; break;
2551               case R_X86_64_GOTTPOFF: tls_type = GOT_TLS_IE; break;
2552               case R_X86_64_GOTPC32_TLSDESC:
2553               case R_X86_64_TLSDESC_CALL:
2554                 tls_type = GOT_TLS_GDESC; break;
2555               }
2556
2557             if (h != NULL)
2558               {
2559                 h->got.refcount += 1;
2560                 old_tls_type = eh->tls_type;
2561               }
2562             else
2563               {
2564                 bfd_signed_vma *local_got_refcounts;
2565
2566                 /* This is a global offset table entry for a local symbol.  */
2567                 local_got_refcounts = elf_local_got_refcounts (abfd);
2568                 if (local_got_refcounts == NULL)
2569                   {
2570                     bfd_size_type size;
2571
2572                     size = symtab_hdr->sh_info;
2573                     size *= sizeof (bfd_signed_vma)
2574                       + sizeof (bfd_vma) + sizeof (char);
2575                     local_got_refcounts = ((bfd_signed_vma *)
2576                                            bfd_zalloc (abfd, size));
2577                     if (local_got_refcounts == NULL)
2578                       goto error_return;
2579                     elf_local_got_refcounts (abfd) = local_got_refcounts;
2580                     elf_x86_64_local_tlsdesc_gotent (abfd)
2581                       = (bfd_vma *) (local_got_refcounts + symtab_hdr->sh_info);
2582                     elf_x86_64_local_got_tls_type (abfd)
2583                       = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info);
2584                   }
2585                 local_got_refcounts[r_symndx] += 1;
2586                 old_tls_type
2587                   = elf_x86_64_local_got_tls_type (abfd) [r_symndx];
2588               }
2589
2590             /* If a TLS symbol is accessed using IE at least once,
2591                there is no point to use dynamic model for it.  */
2592             if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
2593                 && (! GOT_TLS_GD_ANY_P (old_tls_type)
2594                     || tls_type != GOT_TLS_IE))
2595               {
2596                 if (old_tls_type == GOT_TLS_IE && GOT_TLS_GD_ANY_P (tls_type))
2597                   tls_type = old_tls_type;
2598                 else if (GOT_TLS_GD_ANY_P (old_tls_type)
2599                          && GOT_TLS_GD_ANY_P (tls_type))
2600                   tls_type |= old_tls_type;
2601                 else
2602                   {
2603                     if (h)
2604                       name = h->root.root.string;
2605                     else
2606                       name = bfd_elf_sym_name (abfd, symtab_hdr,
2607                                                isym, NULL);
2608                     _bfd_error_handler
2609                       /* xgettext:c-format */
2610                       (_("%B: '%s' accessed both as normal and"
2611                          " thread local symbol"),
2612                        abfd, name);
2613                     bfd_set_error (bfd_error_bad_value);
2614                     goto error_return;
2615                   }
2616               }
2617
2618             if (old_tls_type != tls_type)
2619               {
2620                 if (eh != NULL)
2621                   eh->tls_type = tls_type;
2622                 else
2623                   elf_x86_64_local_got_tls_type (abfd) [r_symndx] = tls_type;
2624               }
2625           }
2626           /* Fall through */
2627
2628         case R_X86_64_GOTOFF64:
2629         case R_X86_64_GOTPC32:
2630         case R_X86_64_GOTPC64:
2631         create_got:
2632           if (eh != NULL)
2633             eh->has_got_reloc = 1;
2634           break;
2635
2636         case R_X86_64_PLT32:
2637         case R_X86_64_PLT32_BND:
2638           /* This symbol requires a procedure linkage table entry.  We
2639              actually build the entry in adjust_dynamic_symbol,
2640              because this might be a case of linking PIC code which is
2641              never referenced by a dynamic object, in which case we
2642              don't need to generate a procedure linkage table entry
2643              after all.  */
2644
2645           /* If this is a local symbol, we resolve it directly without
2646              creating a procedure linkage table entry.  */
2647           if (h == NULL)
2648             continue;
2649
2650           eh->has_got_reloc = 1;
2651           h->needs_plt = 1;
2652           h->plt.refcount += 1;
2653           break;
2654
2655         case R_X86_64_PLTOFF64:
2656           /* This tries to form the 'address' of a function relative
2657              to GOT.  For global symbols we need a PLT entry.  */
2658           if (h != NULL)
2659             {
2660               h->needs_plt = 1;
2661               h->plt.refcount += 1;
2662             }
2663           goto create_got;
2664
2665         case R_X86_64_SIZE32:
2666         case R_X86_64_SIZE64:
2667           size_reloc = TRUE;
2668           goto do_size;
2669
2670         case R_X86_64_32:
2671           if (!ABI_64_P (abfd))
2672             goto pointer;
2673           /* Fall through.  */
2674         case R_X86_64_8:
2675         case R_X86_64_16:
2676         case R_X86_64_32S:
2677           /* Check relocation overflow as these relocs may lead to
2678              run-time relocation overflow.  Don't error out for
2679              sections we don't care about, such as debug sections or
2680              when relocation overflow check is disabled.  */
2681           if (!info->no_reloc_overflow_check
2682               && (bfd_link_pic (info)
2683                   || (bfd_link_executable (info)
2684                       && h != NULL
2685                       && !h->def_regular
2686                       && h->def_dynamic
2687                       && (sec->flags & SEC_READONLY) == 0)))
2688             return elf_x86_64_need_pic (abfd, sec, h, symtab_hdr, isym,
2689                                         &x86_64_elf_howto_table[r_type]);
2690           /* Fall through.  */
2691
2692         case R_X86_64_PC8:
2693         case R_X86_64_PC16:
2694         case R_X86_64_PC32:
2695         case R_X86_64_PC32_BND:
2696         case R_X86_64_PC64:
2697         case R_X86_64_64:
2698 pointer:
2699           if (eh != NULL && (sec->flags & SEC_CODE) != 0)
2700             eh->has_non_got_reloc = 1;
2701           /* We are called after all symbols have been resolved.  Only
2702              relocation against STT_GNU_IFUNC symbol must go through
2703              PLT.  */
2704           if (h != NULL
2705               && (bfd_link_executable (info)
2706                   || h->type == STT_GNU_IFUNC))
2707             {
2708               /* If this reloc is in a read-only section, we might
2709                  need a copy reloc.  We can't check reliably at this
2710                  stage whether the section is read-only, as input
2711                  sections have not yet been mapped to output sections.
2712                  Tentatively set the flag for now, and correct in
2713                  adjust_dynamic_symbol.  */
2714               h->non_got_ref = 1;
2715
2716               /* We may need a .plt entry if the symbol is a function
2717                  defined in a shared lib or is a STT_GNU_IFUNC function
2718                  referenced from the code or read-only section.  */
2719               if (!h->def_regular
2720                   || (sec->flags & (SEC_CODE | SEC_READONLY)) != 0)
2721                 h->plt.refcount += 1;
2722
2723               if (r_type == R_X86_64_PC32)
2724                 {
2725                   /* Since something like ".long foo - ." may be used
2726                      as pointer, make sure that PLT is used if foo is
2727                      a function defined in a shared library.  */
2728                   if ((sec->flags & SEC_CODE) == 0)
2729                     h->pointer_equality_needed = 1;
2730                 }
2731               else if (r_type != R_X86_64_PC32_BND
2732                        && r_type != R_X86_64_PC64)
2733                 {
2734                   h->pointer_equality_needed = 1;
2735                   /* At run-time, R_X86_64_64 can be resolved for both
2736                      x86-64 and x32. But R_X86_64_32 and R_X86_64_32S
2737                      can only be resolved for x32.  */
2738                   if ((sec->flags & SEC_READONLY) == 0
2739                       && (r_type == R_X86_64_64
2740                           || (!ABI_64_P (abfd)
2741                               && (r_type == R_X86_64_32
2742                                   || r_type == R_X86_64_32S))))
2743                     eh->func_pointer_refcount += 1;
2744                 }
2745             }
2746
2747           size_reloc = FALSE;
2748 do_size:
2749           /* If we are creating a shared library, and this is a reloc
2750              against a global symbol, or a non PC relative reloc
2751              against a local symbol, then we need to copy the reloc
2752              into the shared library.  However, if we are linking with
2753              -Bsymbolic, we do not need to copy a reloc against a
2754              global symbol which is defined in an object we are
2755              including in the link (i.e., DEF_REGULAR is set).  At
2756              this point we have not seen all the input files, so it is
2757              possible that DEF_REGULAR is not set now but will be set
2758              later (it is never cleared).  In case of a weak definition,
2759              DEF_REGULAR may be cleared later by a strong definition in
2760              a shared library.  We account for that possibility below by
2761              storing information in the relocs_copied field of the hash
2762              table entry.  A similar situation occurs when creating
2763              shared libraries and symbol visibility changes render the
2764              symbol local.
2765
2766              If on the other hand, we are creating an executable, we
2767              may need to keep relocations for symbols satisfied by a
2768              dynamic library if we manage to avoid copy relocs for the
2769              symbol.
2770
2771              Generate dynamic pointer relocation against STT_GNU_IFUNC
2772              symbol in the non-code section.  */
2773           if ((bfd_link_pic (info)
2774                && (! IS_X86_64_PCREL_TYPE (r_type)
2775                    || (h != NULL
2776                        && (! (bfd_link_pie (info)
2777                               || SYMBOLIC_BIND (info, h))
2778                            || h->root.type == bfd_link_hash_defweak
2779                            || !h->def_regular))))
2780               || (h != NULL
2781                   && h->type == STT_GNU_IFUNC
2782                   && r_type == htab->pointer_r_type
2783                   && (sec->flags & SEC_CODE) == 0)
2784               || (ELIMINATE_COPY_RELOCS
2785                   && !bfd_link_pic (info)
2786                   && h != NULL
2787                   && (h->root.type == bfd_link_hash_defweak
2788                       || !h->def_regular)))
2789             {
2790               struct elf_dyn_relocs *p;
2791               struct elf_dyn_relocs **head;
2792
2793               /* We must copy these reloc types into the output file.
2794                  Create a reloc section in dynobj and make room for
2795                  this reloc.  */
2796               if (sreloc == NULL)
2797                 {
2798                   sreloc = _bfd_elf_make_dynamic_reloc_section
2799                     (sec, htab->elf.dynobj, ABI_64_P (abfd) ? 3 : 2,
2800                      abfd, /*rela?*/ TRUE);
2801
2802                   if (sreloc == NULL)
2803                     goto error_return;
2804                 }
2805
2806               /* If this is a global symbol, we count the number of
2807                  relocations we need for this symbol.  */
2808               if (h != NULL)
2809                 head = &eh->dyn_relocs;
2810               else
2811                 {
2812                   /* Track dynamic relocs needed for local syms too.
2813                      We really need local syms available to do this
2814                      easily.  Oh well.  */
2815                   asection *s;
2816                   void **vpp;
2817
2818                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2819                                                 abfd, r_symndx);
2820                   if (isym == NULL)
2821                     goto error_return;
2822
2823                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2824                   if (s == NULL)
2825                     s = sec;
2826
2827                   /* Beware of type punned pointers vs strict aliasing
2828                      rules.  */
2829                   vpp = &(elf_section_data (s)->local_dynrel);
2830                   head = (struct elf_dyn_relocs **)vpp;
2831                 }
2832
2833               p = *head;
2834               if (p == NULL || p->sec != sec)
2835                 {
2836                   bfd_size_type amt = sizeof *p;
2837
2838                   p = ((struct elf_dyn_relocs *)
2839                        bfd_alloc (htab->elf.dynobj, amt));
2840                   if (p == NULL)
2841                     goto error_return;
2842                   p->next = *head;
2843                   *head = p;
2844                   p->sec = sec;
2845                   p->count = 0;
2846                   p->pc_count = 0;
2847                 }
2848
2849               p->count += 1;
2850               /* Count size relocation as PC-relative relocation.  */
2851               if (IS_X86_64_PCREL_TYPE (r_type) || size_reloc)
2852                 p->pc_count += 1;
2853             }
2854           break;
2855
2856           /* This relocation describes the C++ object vtable hierarchy.
2857              Reconstruct it for later use during GC.  */
2858         case R_X86_64_GNU_VTINHERIT:
2859           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2860             goto error_return;
2861           break;
2862
2863           /* This relocation describes which C++ vtable entries are actually
2864              used.  Record for later use during GC.  */
2865         case R_X86_64_GNU_VTENTRY:
2866           BFD_ASSERT (h != NULL);
2867           if (h != NULL
2868               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2869             goto error_return;
2870           break;
2871
2872         default:
2873           break;
2874         }
2875
2876       if ((r_type == R_X86_64_GOTPCREL
2877            || r_type == R_X86_64_GOTPCRELX
2878            || r_type == R_X86_64_REX_GOTPCRELX)
2879           && (h == NULL || h->type != STT_GNU_IFUNC))
2880         sec->need_convert_load = 1;
2881     }
2882
2883   if (elf_section_data (sec)->this_hdr.contents != contents)
2884     {
2885       if (!info->keep_memory)
2886         free (contents);
2887       else
2888         {
2889           /* Cache the section contents for elf_link_input_bfd.  */
2890           elf_section_data (sec)->this_hdr.contents = contents;
2891         }
2892     }
2893
2894   return TRUE;
2895
2896 error_return:
2897   if (elf_section_data (sec)->this_hdr.contents != contents)
2898     free (contents);
2899   sec->check_relocs_failed = 1;
2900   return FALSE;
2901 }
2902
2903 /* Return the section that should be marked against GC for a given
2904    relocation.  */
2905
2906 static asection *
2907 elf_x86_64_gc_mark_hook (asection *sec,
2908                          struct bfd_link_info *info,
2909                          Elf_Internal_Rela *rel,
2910                          struct elf_link_hash_entry *h,
2911                          Elf_Internal_Sym *sym)
2912 {
2913   if (h != NULL)
2914     switch (ELF32_R_TYPE (rel->r_info))
2915       {
2916       case R_X86_64_GNU_VTINHERIT:
2917       case R_X86_64_GNU_VTENTRY:
2918         return NULL;
2919       }
2920
2921   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2922 }
2923
2924 /* Remove undefined weak symbol from the dynamic symbol table if it
2925    is resolved to 0.   */
2926
2927 static bfd_boolean
2928 elf_x86_64_fixup_symbol (struct bfd_link_info *info,
2929                        struct elf_link_hash_entry *h)
2930 {
2931   if (h->dynindx != -1
2932       && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
2933                                           elf_x86_64_hash_entry (h)->has_got_reloc,
2934                                           elf_x86_64_hash_entry (h)))
2935     {
2936       h->dynindx = -1;
2937       _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
2938                               h->dynstr_index);
2939     }
2940   return TRUE;
2941 }
2942
2943 /* Adjust a symbol defined by a dynamic object and referenced by a
2944    regular object.  The current definition is in some section of the
2945    dynamic object, but we're not including those sections.  We have to
2946    change the definition to something the rest of the link can
2947    understand.  */
2948
2949 static bfd_boolean
2950 elf_x86_64_adjust_dynamic_symbol (struct bfd_link_info *info,
2951                                   struct elf_link_hash_entry *h)
2952 {
2953   struct elf_x86_64_link_hash_table *htab;
2954   asection *s, *srel;
2955   struct elf_x86_64_link_hash_entry *eh;
2956   struct elf_dyn_relocs *p;
2957
2958   /* STT_GNU_IFUNC symbol must go through PLT. */
2959   if (h->type == STT_GNU_IFUNC)
2960     {
2961       /* All local STT_GNU_IFUNC references must be treate as local
2962          calls via local PLT.  */
2963       if (h->ref_regular
2964           && SYMBOL_CALLS_LOCAL (info, h))
2965         {
2966           bfd_size_type pc_count = 0, count = 0;
2967           struct elf_dyn_relocs **pp;
2968
2969           eh = (struct elf_x86_64_link_hash_entry *) h;
2970           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2971             {
2972               pc_count += p->pc_count;
2973               p->count -= p->pc_count;
2974               p->pc_count = 0;
2975               count += p->count;
2976               if (p->count == 0)
2977                 *pp = p->next;
2978               else
2979                 pp = &p->next;
2980             }
2981
2982           if (pc_count || count)
2983             {
2984               h->non_got_ref = 1;
2985               if (pc_count)
2986                 {
2987                   /* Increment PLT reference count only for PC-relative
2988                      references.  */
2989                   h->needs_plt = 1;
2990                   if (h->plt.refcount <= 0)
2991                     h->plt.refcount = 1;
2992                   else
2993                     h->plt.refcount += 1;
2994                 }
2995             }
2996         }
2997
2998       if (h->plt.refcount <= 0)
2999         {
3000           h->plt.offset = (bfd_vma) -1;
3001           h->needs_plt = 0;
3002         }
3003       return TRUE;
3004     }
3005
3006   /* If this is a function, put it in the procedure linkage table.  We
3007      will fill in the contents of the procedure linkage table later,
3008      when we know the address of the .got section.  */
3009   if (h->type == STT_FUNC
3010       || h->needs_plt)
3011     {
3012       if (h->plt.refcount <= 0
3013           || SYMBOL_CALLS_LOCAL (info, h)
3014           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
3015               && h->root.type == bfd_link_hash_undefweak))
3016         {
3017           /* This case can occur if we saw a PLT32 reloc in an input
3018              file, but the symbol was never referred to by a dynamic
3019              object, or if all references were garbage collected.  In
3020              such a case, we don't actually need to build a procedure
3021              linkage table, and we can just do a PC32 reloc instead.  */
3022           h->plt.offset = (bfd_vma) -1;
3023           h->needs_plt = 0;
3024         }
3025
3026       return TRUE;
3027     }
3028   else
3029     /* It's possible that we incorrectly decided a .plt reloc was
3030        needed for an R_X86_64_PC32 reloc to a non-function sym in
3031        check_relocs.  We can't decide accurately between function and
3032        non-function syms in check-relocs;  Objects loaded later in
3033        the link may change h->type.  So fix it now.  */
3034     h->plt.offset = (bfd_vma) -1;
3035
3036   /* If this is a weak symbol, and there is a real definition, the
3037      processor independent code will have arranged for us to see the
3038      real definition first, and we can just use the same value.  */
3039   if (h->u.weakdef != NULL)
3040     {
3041       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
3042                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
3043       h->root.u.def.section = h->u.weakdef->root.u.def.section;
3044       h->root.u.def.value = h->u.weakdef->root.u.def.value;
3045       if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
3046         {
3047           eh = (struct elf_x86_64_link_hash_entry *) h;
3048           h->non_got_ref = h->u.weakdef->non_got_ref;
3049           eh->needs_copy = h->u.weakdef->needs_copy;
3050         }
3051       return TRUE;
3052     }
3053
3054   /* This is a reference to a symbol defined by a dynamic object which
3055      is not a function.  */
3056
3057   /* If we are creating a shared library, we must presume that the
3058      only references to the symbol are via the global offset table.
3059      For such cases we need not do anything here; the relocations will
3060      be handled correctly by relocate_section.  */
3061   if (!bfd_link_executable (info))
3062     return TRUE;
3063
3064   /* If there are no references to this symbol that do not use the
3065      GOT, we don't need to generate a copy reloc.  */
3066   if (!h->non_got_ref)
3067     return TRUE;
3068
3069   /* If -z nocopyreloc was given, we won't generate them either.  */
3070   if (info->nocopyreloc)
3071     {
3072       h->non_got_ref = 0;
3073       return TRUE;
3074     }
3075
3076   if (ELIMINATE_COPY_RELOCS)
3077     {
3078       eh = (struct elf_x86_64_link_hash_entry *) h;
3079       for (p = eh->dyn_relocs; p != NULL; p = p->next)
3080         {
3081           s = p->sec->output_section;
3082           if (s != NULL && (s->flags & SEC_READONLY) != 0)
3083             break;
3084         }
3085
3086       /* If we didn't find any dynamic relocs in read-only sections, then
3087          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
3088       if (p == NULL)
3089         {
3090           h->non_got_ref = 0;
3091           return TRUE;
3092         }
3093     }
3094
3095   /* We must allocate the symbol in our .dynbss section, which will
3096      become part of the .bss section of the executable.  There will be
3097      an entry for this symbol in the .dynsym section.  The dynamic
3098      object will contain position independent code, so all references
3099      from the dynamic object to this symbol will go through the global
3100      offset table.  The dynamic linker will use the .dynsym entry to
3101      determine the address it must put in the global offset table, so
3102      both the dynamic object and the regular object will refer to the
3103      same memory location for the variable.  */
3104
3105   htab = elf_x86_64_hash_table (info);
3106   if (htab == NULL)
3107     return FALSE;
3108
3109   /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
3110      to copy the initial value out of the dynamic object and into the
3111      runtime process image.  */
3112   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
3113     {
3114       s = htab->elf.sdynrelro;
3115       srel = htab->elf.sreldynrelro;
3116     }
3117   else
3118     {
3119       s = htab->elf.sdynbss;
3120       srel = htab->elf.srelbss;
3121     }
3122   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
3123     {
3124       const struct elf_backend_data *bed;
3125       bed = get_elf_backend_data (info->output_bfd);
3126       srel->size += bed->s->sizeof_rela;
3127       h->needs_copy = 1;
3128     }
3129
3130   return _bfd_elf_adjust_dynamic_copy (info, h, s);
3131 }
3132
3133 /* Allocate space in .plt, .got and associated reloc sections for
3134    dynamic relocs.  */
3135
3136 static bfd_boolean
3137 elf_x86_64_allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
3138 {
3139   struct bfd_link_info *info;
3140   struct elf_x86_64_link_hash_table *htab;
3141   struct elf_x86_64_link_hash_entry *eh;
3142   struct elf_dyn_relocs *p;
3143   const struct elf_backend_data *bed;
3144   unsigned int plt_entry_size;
3145   bfd_boolean resolved_to_zero;
3146
3147   if (h->root.type == bfd_link_hash_indirect)
3148     return TRUE;
3149
3150   eh = (struct elf_x86_64_link_hash_entry *) h;
3151
3152   info = (struct bfd_link_info *) inf;
3153   htab = elf_x86_64_hash_table (info);
3154   if (htab == NULL)
3155     return FALSE;
3156   bed = get_elf_backend_data (info->output_bfd);
3157   plt_entry_size = htab->plt.plt_entry_size;
3158
3159   resolved_to_zero = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
3160                                                       eh->has_got_reloc,
3161                                                       eh);
3162
3163   /* We can't use the GOT PLT if pointer equality is needed since
3164      finish_dynamic_symbol won't clear symbol value and the dynamic
3165      linker won't update the GOT slot.  We will get into an infinite
3166      loop at run-time.  */
3167   if (htab->plt_got != NULL
3168       && h->type != STT_GNU_IFUNC
3169       && !h->pointer_equality_needed
3170       && h->plt.refcount > 0
3171       && h->got.refcount > 0)
3172     {
3173       /* Don't use the regular PLT if there are both GOT and GOTPLT
3174          reloctions.  */
3175       h->plt.offset = (bfd_vma) -1;
3176
3177       /* Use the GOT PLT.  */
3178       eh->plt_got.refcount = 1;
3179     }
3180
3181   /* Clear the reference count of function pointer relocations if
3182      symbol isn't a normal function.  */
3183   if (h->type != STT_FUNC)
3184     eh->func_pointer_refcount = 0;
3185
3186   /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
3187      here if it is defined and referenced in a non-shared object.  */
3188   if (h->type == STT_GNU_IFUNC
3189       && h->def_regular)
3190     {
3191       if (_bfd_elf_allocate_ifunc_dyn_relocs (info, h,
3192                                               &eh->dyn_relocs,
3193                                               &htab->readonly_dynrelocs_against_ifunc,
3194                                               plt_entry_size,
3195                                               (htab->plt.has_plt0
3196                                                * plt_entry_size),
3197                                               GOT_ENTRY_SIZE, TRUE))
3198         {
3199           asection *s = htab->plt_second;
3200           if (h->plt.offset != (bfd_vma) -1 && s != NULL)
3201             {
3202               /* Use the second PLT section if it is created.  */
3203               eh->plt_second.offset = s->size;
3204
3205               /* Make room for this entry in the second PLT section.  */
3206               s->size += htab->non_lazy_plt->plt_entry_size;
3207             }
3208
3209           return TRUE;
3210         }
3211       else
3212         return FALSE;
3213     }
3214   /* Don't create the PLT entry if there are only function pointer
3215      relocations which can be resolved at run-time.  */
3216   else if (htab->elf.dynamic_sections_created
3217            && (h->plt.refcount > eh->func_pointer_refcount
3218                || eh->plt_got.refcount > 0))
3219     {
3220       bfd_boolean use_plt_got = eh->plt_got.refcount > 0;
3221
3222       /* Clear the reference count of function pointer relocations
3223          if PLT is used.  */
3224       eh->func_pointer_refcount = 0;
3225
3226       /* Make sure this symbol is output as a dynamic symbol.
3227          Undefined weak syms won't yet be marked as dynamic.  */
3228       if (h->dynindx == -1
3229           && !h->forced_local
3230           && !resolved_to_zero
3231           && h->root.type == bfd_link_hash_undefweak)
3232         {
3233           if (! bfd_elf_link_record_dynamic_symbol (info, h))
3234             return FALSE;
3235         }
3236
3237       if (bfd_link_pic (info)
3238           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
3239         {
3240           asection *s = htab->elf.splt;
3241           asection *second_s = htab->plt_second;
3242           asection *got_s = htab->plt_got;
3243
3244           /* If this is the first .plt entry, make room for the special
3245              first entry.  The .plt section is used by prelink to undo
3246              prelinking for dynamic relocations.  */
3247           if (s->size == 0)
3248             s->size = htab->plt.has_plt0 * plt_entry_size;
3249
3250           if (use_plt_got)
3251             eh->plt_got.offset = got_s->size;
3252           else
3253             {
3254               h->plt.offset = s->size;
3255               if (second_s)
3256                 eh->plt_second.offset = second_s->size;
3257             }
3258
3259           /* If this symbol is not defined in a regular file, and we are
3260              not generating a shared library, then set the symbol to this
3261              location in the .plt.  This is required to make function
3262              pointers compare as equal between the normal executable and
3263              the shared library.  */
3264           if (! bfd_link_pic (info)
3265               && !h->def_regular)
3266             {
3267               if (use_plt_got)
3268                 {
3269                   /* We need to make a call to the entry of the GOT PLT
3270                      instead of regular PLT entry.  */
3271                   h->root.u.def.section = got_s;
3272                   h->root.u.def.value = eh->plt_got.offset;
3273                 }
3274               else
3275                 {
3276                   if (second_s)
3277                     {
3278                       /* We need to make a call to the entry of the
3279                          second PLT instead of regular PLT entry.  */
3280                       h->root.u.def.section = second_s;
3281                       h->root.u.def.value = eh->plt_second.offset;
3282                     }
3283                   else
3284                     {
3285                       h->root.u.def.section = s;
3286                       h->root.u.def.value = h->plt.offset;
3287                     }
3288                 }
3289             }
3290
3291           /* Make room for this entry.  */
3292           if (use_plt_got)
3293             got_s->size += htab->non_lazy_plt->plt_entry_size;
3294           else
3295             {
3296               s->size += plt_entry_size;
3297               if (second_s)
3298                 second_s->size += htab->non_lazy_plt->plt_entry_size;
3299
3300               /* We also need to make an entry in the .got.plt section,
3301                  which will be placed in the .got section by the linker
3302                  script.  */
3303               htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
3304
3305               /* There should be no PLT relocation against resolved
3306                  undefined weak symbol in executable.  */
3307               if (!resolved_to_zero)
3308                 {
3309                   /* We also need to make an entry in the .rela.plt
3310                      section.  */
3311                   htab->elf.srelplt->size += bed->s->sizeof_rela;
3312                   htab->elf.srelplt->reloc_count++;
3313                 }
3314             }
3315         }
3316       else
3317         {
3318           eh->plt_got.offset = (bfd_vma) -1;
3319           h->plt.offset = (bfd_vma) -1;
3320           h->needs_plt = 0;
3321         }
3322     }
3323   else
3324     {
3325       eh->plt_got.offset = (bfd_vma) -1;
3326       h->plt.offset = (bfd_vma) -1;
3327       h->needs_plt = 0;
3328     }
3329
3330   eh->tlsdesc_got = (bfd_vma) -1;
3331
3332   /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
3333      make it a R_X86_64_TPOFF32 requiring no GOT entry.  */
3334   if (h->got.refcount > 0
3335       && bfd_link_executable (info)
3336       && h->dynindx == -1
3337       && elf_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE)
3338     {
3339       h->got.offset = (bfd_vma) -1;
3340     }
3341   else if (h->got.refcount > 0)
3342     {
3343       asection *s;
3344       bfd_boolean dyn;
3345       int tls_type = elf_x86_64_hash_entry (h)->tls_type;
3346
3347       /* Make sure this symbol is output as a dynamic symbol.
3348          Undefined weak syms won't yet be marked as dynamic.  */
3349       if (h->dynindx == -1
3350           && !h->forced_local
3351           && !resolved_to_zero
3352           && h->root.type == bfd_link_hash_undefweak)
3353         {
3354           if (! bfd_elf_link_record_dynamic_symbol (info, h))
3355             return FALSE;
3356         }
3357
3358       if (GOT_TLS_GDESC_P (tls_type))
3359         {
3360           eh->tlsdesc_got = htab->elf.sgotplt->size
3361             - elf_x86_64_compute_jump_table_size (htab);
3362           htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
3363           h->got.offset = (bfd_vma) -2;
3364         }
3365       if (! GOT_TLS_GDESC_P (tls_type)
3366           || GOT_TLS_GD_P (tls_type))
3367         {
3368           s = htab->elf.sgot;
3369           h->got.offset = s->size;
3370           s->size += GOT_ENTRY_SIZE;
3371           if (GOT_TLS_GD_P (tls_type))
3372             s->size += GOT_ENTRY_SIZE;
3373         }
3374       dyn = htab->elf.dynamic_sections_created;
3375       /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
3376          and two if global.  R_X86_64_GOTTPOFF needs one dynamic
3377          relocation.  No dynamic relocation against resolved undefined
3378          weak symbol in executable.  */
3379       if ((GOT_TLS_GD_P (tls_type) && h->dynindx == -1)
3380           || tls_type == GOT_TLS_IE)
3381         htab->elf.srelgot->size += bed->s->sizeof_rela;
3382       else if (GOT_TLS_GD_P (tls_type))
3383         htab->elf.srelgot->size += 2 * bed->s->sizeof_rela;
3384       else if (! GOT_TLS_GDESC_P (tls_type)
3385                && ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3386                     && !resolved_to_zero)
3387                    || h->root.type != bfd_link_hash_undefweak)
3388                && (bfd_link_pic (info)
3389                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
3390         htab->elf.srelgot->size += bed->s->sizeof_rela;
3391       if (GOT_TLS_GDESC_P (tls_type))
3392         {
3393           htab->elf.srelplt->size += bed->s->sizeof_rela;
3394           htab->tlsdesc_plt = (bfd_vma) -1;
3395         }
3396     }
3397   else
3398     h->got.offset = (bfd_vma) -1;
3399
3400   if (eh->dyn_relocs == NULL)
3401     return TRUE;
3402
3403   /* In the shared -Bsymbolic case, discard space allocated for
3404      dynamic pc-relative relocs against symbols which turn out to be
3405      defined in regular objects.  For the normal shared case, discard
3406      space for pc-relative relocs that have become local due to symbol
3407      visibility changes.  */
3408
3409   if (bfd_link_pic (info))
3410     {
3411       /* Relocs that use pc_count are those that appear on a call
3412          insn, or certain REL relocs that can generated via assembly.
3413          We want calls to protected symbols to resolve directly to the
3414          function rather than going via the plt.  If people want
3415          function pointer comparisons to work as expected then they
3416          should avoid writing weird assembly.  */
3417       if (SYMBOL_CALLS_LOCAL (info, h))
3418         {
3419           struct elf_dyn_relocs **pp;
3420
3421           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
3422             {
3423               p->count -= p->pc_count;
3424               p->pc_count = 0;
3425               if (p->count == 0)
3426                 *pp = p->next;
3427               else
3428                 pp = &p->next;
3429             }
3430         }
3431
3432       /* Also discard relocs on undefined weak syms with non-default
3433          visibility or in PIE.  */
3434       if (eh->dyn_relocs != NULL)
3435         {
3436           if (h->root.type == bfd_link_hash_undefweak)
3437             {
3438               /* Undefined weak symbol is never bound locally in shared
3439                  library.  */
3440               if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
3441                   || resolved_to_zero)
3442                 eh->dyn_relocs = NULL;
3443               else if (h->dynindx == -1
3444                        && ! h->forced_local
3445                        && ! bfd_elf_link_record_dynamic_symbol (info, h))
3446                 return FALSE;
3447             }
3448           /* For PIE, discard space for pc-relative relocs against
3449              symbols which turn out to need copy relocs.  */
3450           else if (bfd_link_executable (info)
3451                    && (h->needs_copy || eh->needs_copy)
3452                    && h->def_dynamic
3453                    && !h->def_regular)
3454             {
3455               struct elf_dyn_relocs **pp;
3456
3457               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
3458                 {
3459                   if (p->pc_count != 0)
3460                     *pp = p->next;
3461                   else
3462                     pp = &p->next;
3463                 }
3464             }
3465         }
3466     }
3467   else if (ELIMINATE_COPY_RELOCS)
3468     {
3469       /* For the non-shared case, discard space for relocs against
3470          symbols which turn out to need copy relocs or are not
3471          dynamic.  Keep dynamic relocations for run-time function
3472          pointer initialization.  */
3473
3474       if ((!h->non_got_ref
3475            || eh->func_pointer_refcount > 0
3476            || (h->root.type == bfd_link_hash_undefweak
3477                && !resolved_to_zero))
3478           && ((h->def_dynamic
3479                && !h->def_regular)
3480               || (htab->elf.dynamic_sections_created
3481                   && (h->root.type == bfd_link_hash_undefweak
3482                       || h->root.type == bfd_link_hash_undefined))))
3483         {
3484           /* Make sure this symbol is output as a dynamic symbol.
3485              Undefined weak syms won't yet be marked as dynamic.  */
3486           if (h->dynindx == -1
3487               && ! h->forced_local
3488               && ! resolved_to_zero
3489               && h->root.type == bfd_link_hash_undefweak
3490               && ! bfd_elf_link_record_dynamic_symbol (info, h))
3491             return FALSE;
3492
3493           /* If that succeeded, we know we'll be keeping all the
3494              relocs.  */
3495           if (h->dynindx != -1)
3496             goto keep;
3497         }
3498
3499       eh->dyn_relocs = NULL;
3500       eh->func_pointer_refcount = 0;
3501
3502     keep: ;
3503     }
3504
3505   /* Finally, allocate space.  */
3506   for (p = eh->dyn_relocs; p != NULL; p = p->next)
3507     {
3508       asection * sreloc;
3509
3510       sreloc = elf_section_data (p->sec)->sreloc;
3511
3512       BFD_ASSERT (sreloc != NULL);
3513
3514       sreloc->size += p->count * bed->s->sizeof_rela;
3515     }
3516
3517   return TRUE;
3518 }
3519
3520 /* Allocate space in .plt, .got and associated reloc sections for
3521    local dynamic relocs.  */
3522
3523 static bfd_boolean
3524 elf_x86_64_allocate_local_dynrelocs (void **slot, void *inf)
3525 {
3526   struct elf_link_hash_entry *h
3527     = (struct elf_link_hash_entry *) *slot;
3528
3529   if (h->type != STT_GNU_IFUNC
3530       || !h->def_regular
3531       || !h->ref_regular
3532       || !h->forced_local
3533       || h->root.type != bfd_link_hash_defined)
3534     abort ();
3535
3536   return elf_x86_64_allocate_dynrelocs (h, inf);
3537 }
3538
3539 /* Find any dynamic relocs that apply to read-only sections.  */
3540
3541 static bfd_boolean
3542 elf_x86_64_readonly_dynrelocs (struct elf_link_hash_entry *h,
3543                                void * inf)
3544 {
3545   struct elf_x86_64_link_hash_entry *eh;
3546   struct elf_dyn_relocs *p;
3547
3548   /* Skip local IFUNC symbols. */
3549   if (h->forced_local && h->type == STT_GNU_IFUNC)
3550     return TRUE;
3551
3552   eh = (struct elf_x86_64_link_hash_entry *) h;
3553   for (p = eh->dyn_relocs; p != NULL; p = p->next)
3554     {
3555       asection *s = p->sec->output_section;
3556
3557       if (s != NULL && (s->flags & SEC_READONLY) != 0)
3558         {
3559           struct bfd_link_info *info = (struct bfd_link_info *) inf;
3560
3561           info->flags |= DF_TEXTREL;
3562
3563           if ((info->warn_shared_textrel && bfd_link_pic (info))
3564               || info->error_textrel)
3565             /* xgettext:c-format */
3566             info->callbacks->einfo (_("%P: %B: warning: relocation against `%s' in readonly section `%A'\n"),
3567                                     p->sec->owner, h->root.root.string,
3568                                     p->sec);
3569
3570           /* Not an error, just cut short the traversal.  */
3571           return FALSE;
3572         }
3573     }
3574   return TRUE;
3575 }
3576
3577 /* Convert load via the GOT slot to load immediate.  */
3578
3579 static bfd_boolean
3580 elf_x86_64_convert_load (bfd *abfd, asection *sec,
3581                          struct bfd_link_info *link_info)
3582 {
3583   Elf_Internal_Shdr *symtab_hdr;
3584   Elf_Internal_Rela *internal_relocs;
3585   Elf_Internal_Rela *irel, *irelend;
3586   bfd_byte *contents;
3587   struct elf_x86_64_link_hash_table *htab;
3588   bfd_boolean changed;
3589   bfd_signed_vma *local_got_refcounts;
3590
3591   /* Don't even try to convert non-ELF outputs.  */
3592   if (!is_elf_hash_table (link_info->hash))
3593     return FALSE;
3594
3595   /* Nothing to do if there is no need or no output.  */
3596   if ((sec->flags & (SEC_CODE | SEC_RELOC)) != (SEC_CODE | SEC_RELOC)
3597       || sec->need_convert_load == 0
3598       || bfd_is_abs_section (sec->output_section))
3599     return TRUE;
3600
3601   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3602
3603   /* Load the relocations for this section.  */
3604   internal_relocs = (_bfd_elf_link_read_relocs
3605                      (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
3606                       link_info->keep_memory));
3607   if (internal_relocs == NULL)
3608     return FALSE;
3609
3610   changed = FALSE;
3611   htab = elf_x86_64_hash_table (link_info);
3612   local_got_refcounts = elf_local_got_refcounts (abfd);
3613
3614   /* Get the section contents.  */
3615   if (elf_section_data (sec)->this_hdr.contents != NULL)
3616     contents = elf_section_data (sec)->this_hdr.contents;
3617   else
3618     {
3619       if (!bfd_malloc_and_get_section (abfd, sec, &contents))
3620         goto error_return;
3621     }
3622
3623   irelend = internal_relocs + sec->reloc_count;
3624   for (irel = internal_relocs; irel < irelend; irel++)
3625     {
3626       unsigned int r_type = ELF32_R_TYPE (irel->r_info);
3627       unsigned int r_symndx;
3628       struct elf_link_hash_entry *h;
3629       bfd_boolean converted;
3630
3631       if (r_type != R_X86_64_GOTPCRELX
3632           && r_type != R_X86_64_REX_GOTPCRELX
3633           && r_type != R_X86_64_GOTPCREL)
3634         continue;
3635
3636       r_symndx = htab->r_sym (irel->r_info);
3637       if (r_symndx < symtab_hdr->sh_info)
3638         h = elf_x86_64_get_local_sym_hash (htab, sec->owner,
3639                                            (const Elf_Internal_Rela *) irel,
3640                                            FALSE);
3641       else
3642         {
3643           h = elf_sym_hashes (abfd)[r_symndx - symtab_hdr->sh_info];
3644           while (h->root.type == bfd_link_hash_indirect
3645                  || h->root.type == bfd_link_hash_warning)
3646             h = (struct elf_link_hash_entry *) h->root.u.i.link;
3647         }
3648
3649       /* STT_GNU_IFUNC must keep GOTPCREL relocations.  */
3650       if (h != NULL && h->type == STT_GNU_IFUNC)
3651         continue;
3652
3653       converted = FALSE;
3654       if (!elf_x86_64_convert_load_reloc (abfd, sec, contents, irel, h,
3655                                           &converted, link_info))
3656         goto error_return;
3657
3658       if (converted)
3659         {
3660           changed = converted;
3661           if (h)
3662             {
3663               if (h->got.refcount > 0)
3664                 h->got.refcount -= 1;
3665             }
3666           else
3667             {
3668               if (local_got_refcounts != NULL
3669                   && local_got_refcounts[r_symndx] > 0)
3670                 local_got_refcounts[r_symndx] -= 1;
3671             }
3672         }
3673     }
3674
3675   if (contents != NULL
3676       && elf_section_data (sec)->this_hdr.contents != contents)
3677     {
3678       if (!changed && !link_info->keep_memory)
3679         free (contents);
3680       else
3681         {
3682           /* Cache the section contents for elf_link_input_bfd.  */
3683           elf_section_data (sec)->this_hdr.contents = contents;
3684         }
3685     }
3686
3687   if (elf_section_data (sec)->relocs != internal_relocs)
3688     {
3689       if (!changed)
3690         free (internal_relocs);
3691       else
3692         elf_section_data (sec)->relocs = internal_relocs;
3693     }
3694
3695   return TRUE;
3696
3697  error_return:
3698   if (contents != NULL
3699       && elf_section_data (sec)->this_hdr.contents != contents)
3700     free (contents);
3701   if (internal_relocs != NULL
3702       && elf_section_data (sec)->relocs != internal_relocs)
3703     free (internal_relocs);
3704   return FALSE;
3705 }
3706
3707 /* Set the sizes of the dynamic sections.  */
3708
3709 static bfd_boolean
3710 elf_x86_64_size_dynamic_sections (bfd *output_bfd,
3711                                   struct bfd_link_info *info)
3712 {
3713   struct elf_x86_64_link_hash_table *htab;
3714   bfd *dynobj;
3715   asection *s;
3716   bfd_boolean relocs;
3717   bfd *ibfd;
3718   const struct elf_backend_data *bed;
3719
3720   htab = elf_x86_64_hash_table (info);
3721   if (htab == NULL)
3722     return FALSE;
3723   bed = get_elf_backend_data (output_bfd);
3724
3725   dynobj = htab->elf.dynobj;
3726   if (dynobj == NULL)
3727     abort ();
3728
3729   /* Set up .got offsets for local syms, and space for local dynamic
3730      relocs.  */
3731   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3732     {
3733       bfd_signed_vma *local_got;
3734       bfd_signed_vma *end_local_got;
3735       char *local_tls_type;
3736       bfd_vma *local_tlsdesc_gotent;
3737       bfd_size_type locsymcount;
3738       Elf_Internal_Shdr *symtab_hdr;
3739       asection *srel;
3740
3741       if (! is_x86_64_elf (ibfd))
3742         continue;
3743
3744       for (s = ibfd->sections; s != NULL; s = s->next)
3745         {
3746           struct elf_dyn_relocs *p;
3747
3748           if (!elf_x86_64_convert_load (ibfd, s, info))
3749             return FALSE;
3750
3751           for (p = (struct elf_dyn_relocs *)
3752                     (elf_section_data (s)->local_dynrel);
3753                p != NULL;
3754                p = p->next)
3755             {
3756               if (!bfd_is_abs_section (p->sec)
3757                   && bfd_is_abs_section (p->sec->output_section))
3758                 {
3759                   /* Input section has been discarded, either because
3760                      it is a copy of a linkonce section or due to
3761                      linker script /DISCARD/, so we'll be discarding
3762                      the relocs too.  */
3763                 }
3764               else if (p->count != 0)
3765                 {
3766                   srel = elf_section_data (p->sec)->sreloc;
3767                   srel->size += p->count * bed->s->sizeof_rela;
3768                   if ((p->sec->output_section->flags & SEC_READONLY) != 0
3769                       && (info->flags & DF_TEXTREL) == 0)
3770                     {
3771                       info->flags |= DF_TEXTREL;
3772                       if ((info->warn_shared_textrel && bfd_link_pic (info))
3773                           || info->error_textrel)
3774                         /* xgettext:c-format */
3775                         info->callbacks->einfo (_("%P: %B: warning: relocation in readonly section `%A'\n"),
3776                                                 p->sec->owner, p->sec);
3777                     }
3778                 }
3779             }
3780         }
3781
3782       local_got = elf_local_got_refcounts (ibfd);
3783       if (!local_got)
3784         continue;
3785
3786       symtab_hdr = &elf_symtab_hdr (ibfd);
3787       locsymcount = symtab_hdr->sh_info;
3788       end_local_got = local_got + locsymcount;
3789       local_tls_type = elf_x86_64_local_got_tls_type (ibfd);
3790       local_tlsdesc_gotent = elf_x86_64_local_tlsdesc_gotent (ibfd);
3791       s = htab->elf.sgot;
3792       srel = htab->elf.srelgot;
3793       for (; local_got < end_local_got;
3794            ++local_got, ++local_tls_type, ++local_tlsdesc_gotent)
3795         {
3796           *local_tlsdesc_gotent = (bfd_vma) -1;
3797           if (*local_got > 0)
3798             {
3799               if (GOT_TLS_GDESC_P (*local_tls_type))
3800                 {
3801                   *local_tlsdesc_gotent = htab->elf.sgotplt->size
3802                     - elf_x86_64_compute_jump_table_size (htab);
3803                   htab->elf.sgotplt->size += 2 * GOT_ENTRY_SIZE;
3804                   *local_got = (bfd_vma) -2;
3805                 }
3806               if (! GOT_TLS_GDESC_P (*local_tls_type)
3807                   || GOT_TLS_GD_P (*local_tls_type))
3808                 {
3809                   *local_got = s->size;
3810                   s->size += GOT_ENTRY_SIZE;
3811                   if (GOT_TLS_GD_P (*local_tls_type))
3812                     s->size += GOT_ENTRY_SIZE;
3813                 }
3814               if (bfd_link_pic (info)
3815                   || GOT_TLS_GD_ANY_P (*local_tls_type)
3816                   || *local_tls_type == GOT_TLS_IE)
3817                 {
3818                   if (GOT_TLS_GDESC_P (*local_tls_type))
3819                     {
3820                       htab->elf.srelplt->size
3821                         += bed->s->sizeof_rela;
3822                       htab->tlsdesc_plt = (bfd_vma) -1;
3823                     }
3824                   if (! GOT_TLS_GDESC_P (*local_tls_type)
3825                       || GOT_TLS_GD_P (*local_tls_type))
3826                     srel->size += bed->s->sizeof_rela;
3827                 }
3828             }
3829           else
3830             *local_got = (bfd_vma) -1;
3831         }
3832     }
3833
3834   if (htab->tls_ld_got.refcount > 0)
3835     {
3836       /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
3837          relocs.  */
3838       htab->tls_ld_got.offset = htab->elf.sgot->size;
3839       htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
3840       htab->elf.srelgot->size += bed->s->sizeof_rela;
3841     }
3842   else
3843     htab->tls_ld_got.offset = -1;
3844
3845   /* Allocate global sym .plt and .got entries, and space for global
3846      sym dynamic relocs.  */
3847   elf_link_hash_traverse (&htab->elf, elf_x86_64_allocate_dynrelocs,
3848                           info);
3849
3850   /* Allocate .plt and .got entries, and space for local symbols.  */
3851   htab_traverse (htab->loc_hash_table,
3852                  elf_x86_64_allocate_local_dynrelocs,
3853                  info);
3854
3855   /* For every jump slot reserved in the sgotplt, reloc_count is
3856      incremented.  However, when we reserve space for TLS descriptors,
3857      it's not incremented, so in order to compute the space reserved
3858      for them, it suffices to multiply the reloc count by the jump
3859      slot size.
3860
3861      PR ld/13302: We start next_irelative_index at the end of .rela.plt
3862      so that R_X86_64_IRELATIVE entries come last.  */
3863   if (htab->elf.srelplt)
3864     {
3865       htab->sgotplt_jump_table_size
3866         = elf_x86_64_compute_jump_table_size (htab);
3867       htab->next_irelative_index = htab->elf.srelplt->reloc_count - 1;
3868     }
3869   else if (htab->elf.irelplt)
3870     htab->next_irelative_index = htab->elf.irelplt->reloc_count - 1;
3871
3872   if (htab->tlsdesc_plt)
3873     {
3874       /* If we're not using lazy TLS relocations, don't generate the
3875          PLT and GOT entries they require.  */
3876       if ((info->flags & DF_BIND_NOW))
3877         htab->tlsdesc_plt = 0;
3878       else
3879         {
3880           htab->tlsdesc_got = htab->elf.sgot->size;
3881           htab->elf.sgot->size += GOT_ENTRY_SIZE;
3882           /* Reserve room for the initial entry.
3883              FIXME: we could probably do away with it in this case.  */
3884           if (htab->elf.splt->size == 0)
3885             htab->elf.splt->size = htab->plt.plt_entry_size;
3886           htab->tlsdesc_plt = htab->elf.splt->size;
3887           htab->elf.splt->size += htab->plt.plt_entry_size;
3888         }
3889     }
3890
3891   if (htab->elf.sgotplt)
3892     {
3893       /* Don't allocate .got.plt section if there are no GOT nor PLT
3894          entries and there is no refeence to _GLOBAL_OFFSET_TABLE_.  */
3895       if ((htab->elf.hgot == NULL
3896            || !htab->elf.hgot->ref_regular_nonweak)
3897           && (htab->elf.sgotplt->size
3898               == get_elf_backend_data (output_bfd)->got_header_size)
3899           && (htab->elf.splt == NULL
3900               || htab->elf.splt->size == 0)
3901           && (htab->elf.sgot == NULL
3902               || htab->elf.sgot->size == 0)
3903           && (htab->elf.iplt == NULL
3904               || htab->elf.iplt->size == 0)
3905           && (htab->elf.igotplt == NULL
3906               || htab->elf.igotplt->size == 0))
3907         htab->elf.sgotplt->size = 0;
3908     }
3909
3910   if (_bfd_elf_eh_frame_present (info))
3911     {
3912       if (htab->plt_eh_frame != NULL
3913           && htab->elf.splt != NULL
3914           && htab->elf.splt->size != 0
3915           && !bfd_is_abs_section (htab->elf.splt->output_section))
3916         htab->plt_eh_frame->size = htab->plt.eh_frame_plt_size;
3917
3918       if (htab->plt_got_eh_frame != NULL
3919           && htab->plt_got != NULL
3920           && htab->plt_got->size != 0
3921           && !bfd_is_abs_section (htab->plt_got->output_section))
3922         htab->plt_got_eh_frame->size
3923           = htab->non_lazy_plt->eh_frame_plt_size;
3924
3925       /* Unwind info for the second PLT and .plt.got sections are
3926          identical.  */
3927       if (htab->plt_second_eh_frame != NULL
3928           && htab->plt_second != NULL
3929           && htab->plt_second->size != 0
3930           && !bfd_is_abs_section (htab->plt_second->output_section))
3931         htab->plt_second_eh_frame->size
3932           = htab->non_lazy_plt->eh_frame_plt_size;
3933     }
3934
3935   /* We now have determined the sizes of the various dynamic sections.
3936      Allocate memory for them.  */
3937   relocs = FALSE;
3938   for (s = dynobj->sections; s != NULL; s = s->next)
3939     {
3940       if ((s->flags & SEC_LINKER_CREATED) == 0)
3941         continue;
3942
3943       if (s == htab->elf.splt
3944           || s == htab->elf.sgot
3945           || s == htab->elf.sgotplt
3946           || s == htab->elf.iplt
3947           || s == htab->elf.igotplt
3948           || s == htab->plt_second
3949           || s == htab->plt_got
3950           || s == htab->plt_eh_frame
3951           || s == htab->plt_got_eh_frame
3952           || s == htab->plt_second_eh_frame
3953           || s == htab->elf.sdynbss
3954           || s == htab->elf.sdynrelro)
3955         {
3956           /* Strip this section if we don't need it; see the
3957              comment below.  */
3958         }
3959       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
3960         {
3961           if (s->size != 0 && s != htab->elf.srelplt)
3962             relocs = TRUE;
3963
3964           /* We use the reloc_count field as a counter if we need
3965              to copy relocs into the output file.  */
3966           if (s != htab->elf.srelplt)
3967             s->reloc_count = 0;
3968         }
3969       else
3970         {
3971           /* It's not one of our sections, so don't allocate space.  */
3972           continue;
3973         }
3974
3975       if (s->size == 0)
3976         {
3977           /* If we don't need this section, strip it from the
3978              output file.  This is mostly to handle .rela.bss and
3979              .rela.plt.  We must create both sections in
3980              create_dynamic_sections, because they must be created
3981              before the linker maps input sections to output
3982              sections.  The linker does that before
3983              adjust_dynamic_symbol is called, and it is that
3984              function which decides whether anything needs to go
3985              into these sections.  */
3986
3987           s->flags |= SEC_EXCLUDE;
3988           continue;
3989         }
3990
3991       if ((s->flags & SEC_HAS_CONTENTS) == 0)
3992         continue;
3993
3994       /* Allocate memory for the section contents.  We use bfd_zalloc
3995          here in case unused entries are not reclaimed before the
3996          section's contents are written out.  This should not happen,
3997          but this way if it does, we get a R_X86_64_NONE reloc instead
3998          of garbage.  */
3999       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
4000       if (s->contents == NULL)
4001         return FALSE;
4002     }
4003
4004   if (htab->plt_eh_frame != NULL
4005       && htab->plt_eh_frame->contents != NULL)
4006     {
4007       memcpy (htab->plt_eh_frame->contents,
4008               htab->plt.eh_frame_plt, htab->plt_eh_frame->size);
4009       bfd_put_32 (dynobj, htab->elf.splt->size,
4010                   htab->plt_eh_frame->contents + PLT_FDE_LEN_OFFSET);
4011     }
4012
4013   if (htab->plt_got_eh_frame != NULL
4014       && htab->plt_got_eh_frame->contents != NULL)
4015     {
4016       memcpy (htab->plt_got_eh_frame->contents,
4017               htab->non_lazy_plt->eh_frame_plt,
4018               htab->plt_got_eh_frame->size);
4019       bfd_put_32 (dynobj, htab->plt_got->size,
4020                   (htab->plt_got_eh_frame->contents
4021                    + PLT_FDE_LEN_OFFSET));
4022     }
4023
4024   if (htab->plt_second_eh_frame != NULL
4025       && htab->plt_second_eh_frame->contents != NULL)
4026     {
4027       memcpy (htab->plt_second_eh_frame->contents,
4028               htab->non_lazy_plt->eh_frame_plt,
4029               htab->plt_second_eh_frame->size);
4030       bfd_put_32 (dynobj, htab->plt_second->size,
4031                   (htab->plt_second_eh_frame->contents
4032                    + PLT_FDE_LEN_OFFSET));
4033     }
4034
4035   if (htab->elf.dynamic_sections_created)
4036     {
4037       /* Add some entries to the .dynamic section.  We fill in the
4038          values later, in elf_x86_64_finish_dynamic_sections, but we
4039          must add the entries now so that we get the correct size for
4040          the .dynamic section.  The DT_DEBUG entry is filled in by the
4041          dynamic linker and used by the debugger.  */
4042 #define add_dynamic_entry(TAG, VAL) \
4043   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
4044
4045       if (bfd_link_executable (info))
4046         {
4047           if (!add_dynamic_entry (DT_DEBUG, 0))
4048             return FALSE;
4049         }
4050
4051       if (htab->elf.splt->size != 0)
4052         {
4053           /* DT_PLTGOT is used by prelink even if there is no PLT
4054              relocation.  */
4055           if (!add_dynamic_entry (DT_PLTGOT, 0))
4056             return FALSE;
4057         }
4058
4059       if (htab->elf.srelplt->size != 0)
4060         {
4061           if (!add_dynamic_entry (DT_PLTRELSZ, 0)
4062               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
4063               || !add_dynamic_entry (DT_JMPREL, 0))
4064             return FALSE;
4065         }
4066
4067       if (htab->tlsdesc_plt
4068           && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
4069               || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
4070         return FALSE;
4071
4072       if (relocs)
4073         {
4074           if (!add_dynamic_entry (DT_RELA, 0)
4075               || !add_dynamic_entry (DT_RELASZ, 0)
4076               || !add_dynamic_entry (DT_RELAENT, bed->s->sizeof_rela))
4077             return FALSE;
4078
4079           /* If any dynamic relocs apply to a read-only section,
4080              then we need a DT_TEXTREL entry.  */
4081           if ((info->flags & DF_TEXTREL) == 0)
4082             elf_link_hash_traverse (&htab->elf,
4083                                     elf_x86_64_readonly_dynrelocs,
4084                                     info);
4085
4086           if ((info->flags & DF_TEXTREL) != 0)
4087             {
4088               if (htab->readonly_dynrelocs_against_ifunc)
4089                 {
4090                   info->callbacks->einfo
4091                     (_("%P%X: read-only segment has dynamic IFUNC relocations; recompile with -fPIC\n"));
4092                   bfd_set_error (bfd_error_bad_value);
4093                   return FALSE;
4094                 }
4095
4096               if (!add_dynamic_entry (DT_TEXTREL, 0))
4097                 return FALSE;
4098             }
4099         }
4100     }
4101 #undef add_dynamic_entry
4102
4103   return TRUE;
4104 }
4105
4106 static bfd_boolean
4107 elf_x86_64_always_size_sections (bfd *output_bfd,
4108                                  struct bfd_link_info *info)
4109 {
4110   asection *tls_sec = elf_hash_table (info)->tls_sec;
4111
4112   if (tls_sec)
4113     {
4114       struct elf_link_hash_entry *tlsbase;
4115
4116       tlsbase = elf_link_hash_lookup (elf_hash_table (info),
4117                                       "_TLS_MODULE_BASE_",
4118                                       FALSE, FALSE, FALSE);
4119
4120       if (tlsbase && tlsbase->type == STT_TLS)
4121         {
4122           struct elf_x86_64_link_hash_table *htab;
4123           struct bfd_link_hash_entry *bh = NULL;
4124           const struct elf_backend_data *bed
4125             = get_elf_backend_data (output_bfd);
4126
4127           htab = elf_x86_64_hash_table (info);
4128           if (htab == NULL)
4129             return FALSE;
4130
4131           if (!(_bfd_generic_link_add_one_symbol
4132                 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
4133                  tls_sec, 0, NULL, FALSE,
4134                  bed->collect, &bh)))
4135             return FALSE;
4136
4137           htab->tls_module_base = bh;
4138
4139           tlsbase = (struct elf_link_hash_entry *)bh;
4140           tlsbase->def_regular = 1;
4141           tlsbase->other = STV_HIDDEN;
4142           tlsbase->root.linker_def = 1;
4143           (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
4144         }
4145     }
4146
4147   return TRUE;
4148 }
4149
4150 /* _TLS_MODULE_BASE_ needs to be treated especially when linking
4151    executables.  Rather than setting it to the beginning of the TLS
4152    section, we have to set it to the end.  This function may be called
4153    multiple times, it is idempotent.  */
4154
4155 static void
4156 elf_x86_64_set_tls_module_base (struct bfd_link_info *info)
4157 {
4158   struct elf_x86_64_link_hash_table *htab;
4159   struct bfd_link_hash_entry *base;
4160
4161   if (!bfd_link_executable (info))
4162     return;
4163
4164   htab = elf_x86_64_hash_table (info);
4165   if (htab == NULL)
4166     return;
4167
4168   base = htab->tls_module_base;
4169   if (base == NULL)
4170     return;
4171
4172   base->u.def.value = htab->elf.tls_size;
4173 }
4174
4175 /* Return the base VMA address which should be subtracted from real addresses
4176    when resolving @dtpoff relocation.
4177    This is PT_TLS segment p_vaddr.  */
4178
4179 static bfd_vma
4180 elf_x86_64_dtpoff_base (struct bfd_link_info *info)
4181 {
4182   /* If tls_sec is NULL, we should have signalled an error already.  */
4183   if (elf_hash_table (info)->tls_sec == NULL)
4184     return 0;
4185   return elf_hash_table (info)->tls_sec->vma;
4186 }
4187
4188 /* Return the relocation value for @tpoff relocation
4189    if STT_TLS virtual address is ADDRESS.  */
4190
4191 static bfd_vma
4192 elf_x86_64_tpoff (struct bfd_link_info *info, bfd_vma address)
4193 {
4194   struct elf_link_hash_table *htab = elf_hash_table (info);
4195   const struct elf_backend_data *bed = get_elf_backend_data (info->output_bfd);
4196   bfd_vma static_tls_size;
4197
4198   /* If tls_segment is NULL, we should have signalled an error already.  */
4199   if (htab->tls_sec == NULL)
4200     return 0;
4201
4202   /* Consider special static TLS alignment requirements.  */
4203   static_tls_size = BFD_ALIGN (htab->tls_size, bed->static_tls_alignment);
4204   return address - static_tls_size - htab->tls_sec->vma;
4205 }
4206
4207 /* Is the instruction before OFFSET in CONTENTS a 32bit relative
4208    branch?  */
4209
4210 static bfd_boolean
4211 is_32bit_relative_branch (bfd_byte *contents, bfd_vma offset)
4212 {
4213   /* Opcode             Instruction
4214      0xe8               call
4215      0xe9               jump
4216      0x0f 0x8x          conditional jump */
4217   return ((offset > 0
4218            && (contents [offset - 1] == 0xe8
4219                || contents [offset - 1] == 0xe9))
4220           || (offset > 1
4221               && contents [offset - 2] == 0x0f
4222               && (contents [offset - 1] & 0xf0) == 0x80));
4223 }
4224
4225 /* Relocate an x86_64 ELF section.  */
4226
4227 static bfd_boolean
4228 elf_x86_64_relocate_section (bfd *output_bfd,
4229                              struct bfd_link_info *info,
4230                              bfd *input_bfd,
4231                              asection *input_section,
4232                              bfd_byte *contents,
4233                              Elf_Internal_Rela *relocs,
4234                              Elf_Internal_Sym *local_syms,
4235                              asection **local_sections)
4236 {
4237   struct elf_x86_64_link_hash_table *htab;
4238   Elf_Internal_Shdr *symtab_hdr;
4239   struct elf_link_hash_entry **sym_hashes;
4240   bfd_vma *local_got_offsets;
4241   bfd_vma *local_tlsdesc_gotents;
4242   Elf_Internal_Rela *rel;
4243   Elf_Internal_Rela *wrel;
4244   Elf_Internal_Rela *relend;
4245   unsigned int plt_entry_size;
4246
4247   BFD_ASSERT (is_x86_64_elf (input_bfd));
4248
4249   /* Skip if check_relocs failed.  */
4250   if (input_section->check_relocs_failed)
4251     return FALSE;
4252
4253   htab = elf_x86_64_hash_table (info);
4254   if (htab == NULL)
4255     return FALSE;
4256   plt_entry_size = htab->plt.plt_entry_size;
4257   symtab_hdr = &elf_symtab_hdr (input_bfd);
4258   sym_hashes = elf_sym_hashes (input_bfd);
4259   local_got_offsets = elf_local_got_offsets (input_bfd);
4260   local_tlsdesc_gotents = elf_x86_64_local_tlsdesc_gotent (input_bfd);
4261
4262   elf_x86_64_set_tls_module_base (info);
4263
4264   rel = wrel = relocs;
4265   relend = relocs + input_section->reloc_count;
4266   for (; rel < relend; wrel++, rel++)
4267     {
4268       unsigned int r_type;
4269       reloc_howto_type *howto;
4270       unsigned long r_symndx;
4271       struct elf_link_hash_entry *h;
4272       struct elf_x86_64_link_hash_entry *eh;
4273       Elf_Internal_Sym *sym;
4274       asection *sec;
4275       bfd_vma off, offplt, plt_offset;
4276       bfd_vma relocation;
4277       bfd_boolean unresolved_reloc;
4278       bfd_reloc_status_type r;
4279       int tls_type;
4280       asection *base_got, *resolved_plt;
4281       bfd_vma st_size;
4282       bfd_boolean resolved_to_zero;
4283       bfd_boolean relative_reloc;
4284
4285       r_type = ELF32_R_TYPE (rel->r_info);
4286       if (r_type == (int) R_X86_64_GNU_VTINHERIT
4287           || r_type == (int) R_X86_64_GNU_VTENTRY)
4288         {
4289           if (wrel != rel)
4290             *wrel = *rel;
4291           continue;
4292         }
4293
4294       if (r_type >= (int) R_X86_64_standard)
4295         return _bfd_unrecognized_reloc (input_bfd, input_section, r_type);
4296
4297       if (r_type != (int) R_X86_64_32
4298           || ABI_64_P (output_bfd))
4299         howto = x86_64_elf_howto_table + r_type;
4300       else
4301         howto = (x86_64_elf_howto_table
4302                  + ARRAY_SIZE (x86_64_elf_howto_table) - 1);
4303       r_symndx = htab->r_sym (rel->r_info);
4304       h = NULL;
4305       sym = NULL;
4306       sec = NULL;
4307       unresolved_reloc = FALSE;
4308       if (r_symndx < symtab_hdr->sh_info)
4309         {
4310           sym = local_syms + r_symndx;
4311           sec = local_sections[r_symndx];
4312
4313           relocation = _bfd_elf_rela_local_sym (output_bfd, sym,
4314                                                 &sec, rel);
4315           st_size = sym->st_size;
4316
4317           /* Relocate against local STT_GNU_IFUNC symbol.  */
4318           if (!bfd_link_relocatable (info)
4319               && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
4320             {
4321               h = elf_x86_64_get_local_sym_hash (htab, input_bfd,
4322                                                  rel, FALSE);
4323               if (h == NULL)
4324                 abort ();
4325
4326               /* Set STT_GNU_IFUNC symbol value.  */
4327               h->root.u.def.value = sym->st_value;
4328               h->root.u.def.section = sec;
4329             }
4330         }
4331       else
4332         {
4333           bfd_boolean warned ATTRIBUTE_UNUSED;
4334           bfd_boolean ignored ATTRIBUTE_UNUSED;
4335
4336           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4337                                    r_symndx, symtab_hdr, sym_hashes,
4338                                    h, sec, relocation,
4339                                    unresolved_reloc, warned, ignored);
4340           st_size = h->size;
4341         }
4342
4343       if (sec != NULL && discarded_section (sec))
4344         {
4345           _bfd_clear_contents (howto, input_bfd, input_section,
4346                                contents + rel->r_offset);
4347           wrel->r_offset = rel->r_offset;
4348           wrel->r_info = 0;
4349           wrel->r_addend = 0;
4350
4351           /* For ld -r, remove relocations in debug sections against
4352              sections defined in discarded sections.  Not done for
4353              eh_frame editing code expects to be present.  */
4354            if (bfd_link_relocatable (info)
4355                && (input_section->flags & SEC_DEBUGGING))
4356              wrel--;
4357
4358           continue;
4359         }
4360
4361       if (bfd_link_relocatable (info))
4362         {
4363           if (wrel != rel)
4364             *wrel = *rel;
4365           continue;
4366         }
4367
4368       if (rel->r_addend == 0 && !ABI_64_P (output_bfd))
4369         {
4370           if (r_type == R_X86_64_64)
4371             {
4372               /* For x32, treat R_X86_64_64 like R_X86_64_32 and
4373                  zero-extend it to 64bit if addend is zero.  */
4374               r_type = R_X86_64_32;
4375               memset (contents + rel->r_offset + 4, 0, 4);
4376             }
4377           else if (r_type == R_X86_64_SIZE64)
4378             {
4379               /* For x32, treat R_X86_64_SIZE64 like R_X86_64_SIZE32 and
4380                  zero-extend it to 64bit if addend is zero.  */
4381               r_type = R_X86_64_SIZE32;
4382               memset (contents + rel->r_offset + 4, 0, 4);
4383             }
4384         }
4385
4386       eh = (struct elf_x86_64_link_hash_entry *) h;
4387
4388       /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
4389          it here if it is defined in a non-shared object.  */
4390       if (h != NULL
4391           && h->type == STT_GNU_IFUNC
4392           && h->def_regular)
4393         {
4394           bfd_vma plt_index;
4395           const char *name;
4396
4397           if ((input_section->flags & SEC_ALLOC) == 0)
4398             {
4399               /* Dynamic relocs are not propagated for SEC_DEBUGGING
4400                  sections because such sections are not SEC_ALLOC and
4401                  thus ld.so will not process them.  */
4402               if ((input_section->flags & SEC_DEBUGGING) != 0)
4403                 continue;
4404               abort ();
4405             }
4406
4407           switch (r_type)
4408             {
4409             default:
4410               break;
4411
4412             case R_X86_64_GOTPCREL:
4413             case R_X86_64_GOTPCRELX:
4414             case R_X86_64_REX_GOTPCRELX:
4415             case R_X86_64_GOTPCREL64:
4416               base_got = htab->elf.sgot;
4417               off = h->got.offset;
4418
4419               if (base_got == NULL)
4420                 abort ();
4421
4422               if (off == (bfd_vma) -1)
4423                 {
4424                   /* We can't use h->got.offset here to save state, or
4425                      even just remember the offset, as finish_dynamic_symbol
4426                      would use that as offset into .got.  */
4427
4428                   if (h->plt.offset == (bfd_vma) -1)
4429                     abort ();
4430
4431                   if (htab->elf.splt != NULL)
4432                     {
4433                       plt_index = (h->plt.offset / plt_entry_size
4434                                    - htab->plt.has_plt0);
4435                       off = (plt_index + 3) * GOT_ENTRY_SIZE;
4436                       base_got = htab->elf.sgotplt;
4437                     }
4438                   else
4439                     {
4440                       plt_index = h->plt.offset / plt_entry_size;
4441                       off = plt_index * GOT_ENTRY_SIZE;
4442                       base_got = htab->elf.igotplt;
4443                     }
4444
4445                   if (h->dynindx == -1
4446                       || h->forced_local
4447                       || info->symbolic)
4448                     {
4449                       /* This references the local defitionion.  We must
4450                          initialize this entry in the global offset table.
4451                          Since the offset must always be a multiple of 8,
4452                          we use the least significant bit to record
4453                          whether we have initialized it already.
4454
4455                          When doing a dynamic link, we create a .rela.got
4456                          relocation entry to initialize the value.  This
4457                          is done in the finish_dynamic_symbol routine.   */
4458                       if ((off & 1) != 0)
4459                         off &= ~1;
4460                       else
4461                         {
4462                           bfd_put_64 (output_bfd, relocation,
4463                                       base_got->contents + off);
4464                           /* Note that this is harmless for the GOTPLT64
4465                              case, as -1 | 1 still is -1.  */
4466                           h->got.offset |= 1;
4467                         }
4468                     }
4469                 }
4470
4471               relocation = (base_got->output_section->vma
4472                             + base_got->output_offset + off);
4473
4474               goto do_relocation;
4475             }
4476
4477           if (h->plt.offset == (bfd_vma) -1)
4478             {
4479               /* Handle static pointers of STT_GNU_IFUNC symbols.  */
4480               if (r_type == htab->pointer_r_type
4481                   && (input_section->flags & SEC_CODE) == 0)
4482                 goto do_ifunc_pointer;
4483               goto bad_ifunc_reloc;
4484             }
4485
4486           /* STT_GNU_IFUNC symbol must go through PLT.  */
4487           if (htab->elf.splt != NULL)
4488             {
4489               if (htab->plt_second != NULL)
4490                 {
4491                   resolved_plt = htab->plt_second;
4492                   plt_offset = eh->plt_second.offset;
4493                 }
4494               else
4495                 {
4496                   resolved_plt = htab->elf.splt;
4497                   plt_offset =  h->plt.offset;
4498                 }
4499             }
4500           else
4501             {
4502               resolved_plt = htab->elf.iplt;
4503               plt_offset =  h->plt.offset;
4504             }
4505
4506           relocation = (resolved_plt->output_section->vma
4507                         + resolved_plt->output_offset + plt_offset);
4508
4509           switch (r_type)
4510             {
4511             default:
4512 bad_ifunc_reloc:
4513               if (h->root.root.string)
4514                 name = h->root.root.string;
4515               else
4516                 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4517                                          NULL);
4518               _bfd_error_handler
4519                 /* xgettext:c-format */
4520                 (_("%B: relocation %s against STT_GNU_IFUNC "
4521                    "symbol `%s' isn't supported"), input_bfd,
4522                  howto->name, name);
4523               bfd_set_error (bfd_error_bad_value);
4524               return FALSE;
4525
4526             case R_X86_64_32S:
4527               if (bfd_link_pic (info))
4528                 abort ();
4529               goto do_relocation;
4530
4531             case R_X86_64_32:
4532               if (ABI_64_P (output_bfd))
4533                 goto do_relocation;
4534               /* FALLTHROUGH */
4535             case R_X86_64_64:
4536 do_ifunc_pointer:
4537               if (rel->r_addend != 0)
4538                 {
4539                   if (h->root.root.string)
4540                     name = h->root.root.string;
4541                   else
4542                     name = bfd_elf_sym_name (input_bfd, symtab_hdr,
4543                                              sym, NULL);
4544                   _bfd_error_handler
4545                     /* xgettext:c-format */
4546                     (_("%B: relocation %s against STT_GNU_IFUNC "
4547                        "symbol `%s' has non-zero addend: %Ld"),
4548                      input_bfd, howto->name, name, rel->r_addend);
4549                   bfd_set_error (bfd_error_bad_value);
4550                   return FALSE;
4551                 }
4552
4553               /* Generate dynamic relcoation only when there is a
4554                  non-GOT reference in a shared object or there is no
4555                  PLT.  */
4556               if ((bfd_link_pic (info) && h->non_got_ref)
4557                   || h->plt.offset == (bfd_vma) -1)
4558                 {
4559                   Elf_Internal_Rela outrel;
4560                   asection *sreloc;
4561
4562                   /* Need a dynamic relocation to get the real function
4563                      address.  */
4564                   outrel.r_offset = _bfd_elf_section_offset (output_bfd,
4565                                                              info,
4566                                                              input_section,
4567                                                              rel->r_offset);
4568                   if (outrel.r_offset == (bfd_vma) -1
4569                       || outrel.r_offset == (bfd_vma) -2)
4570                     abort ();
4571
4572                   outrel.r_offset += (input_section->output_section->vma
4573                                       + input_section->output_offset);
4574
4575                   if (h->dynindx == -1
4576                       || h->forced_local
4577                       || bfd_link_executable (info))
4578                     {
4579                       info->callbacks->minfo (_("Local IFUNC function `%s' in %B\n"),
4580                                               h->root.root.string,
4581                                               h->root.u.def.section->owner);
4582
4583                       /* This symbol is resolved locally.  */
4584                       outrel.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
4585                       outrel.r_addend = (h->root.u.def.value
4586                                          + h->root.u.def.section->output_section->vma
4587                                          + h->root.u.def.section->output_offset);
4588                     }
4589                   else
4590                     {
4591                       outrel.r_info = htab->r_info (h->dynindx, r_type);
4592                       outrel.r_addend = 0;
4593                     }
4594
4595                   /* Dynamic relocations are stored in
4596                      1. .rela.ifunc section in PIC object.
4597                      2. .rela.got section in dynamic executable.
4598                      3. .rela.iplt section in static executable.  */
4599                   if (bfd_link_pic (info))
4600                     sreloc = htab->elf.irelifunc;
4601                   else if (htab->elf.splt != NULL)
4602                     sreloc = htab->elf.srelgot;
4603                   else
4604                     sreloc = htab->elf.irelplt;
4605                   elf_append_rela (output_bfd, sreloc, &outrel);
4606
4607                   /* If this reloc is against an external symbol, we
4608                      do not want to fiddle with the addend.  Otherwise,
4609                      we need to include the symbol value so that it
4610                      becomes an addend for the dynamic reloc.  For an
4611                      internal symbol, we have updated addend.  */
4612                   continue;
4613                 }
4614               /* FALLTHROUGH */
4615             case R_X86_64_PC32:
4616             case R_X86_64_PC32_BND:
4617             case R_X86_64_PC64:
4618             case R_X86_64_PLT32:
4619             case R_X86_64_PLT32_BND:
4620               goto do_relocation;
4621             }
4622         }
4623
4624       resolved_to_zero = (eh != NULL
4625                           && UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
4626                                                               eh->has_got_reloc,
4627                                                               eh));
4628
4629       /* When generating a shared object, the relocations handled here are
4630          copied into the output file to be resolved at run time.  */
4631       switch (r_type)
4632         {
4633         case R_X86_64_GOT32:
4634         case R_X86_64_GOT64:
4635           /* Relocation is to the entry for this symbol in the global
4636              offset table.  */
4637         case R_X86_64_GOTPCREL:
4638         case R_X86_64_GOTPCRELX:
4639         case R_X86_64_REX_GOTPCRELX:
4640         case R_X86_64_GOTPCREL64:
4641           /* Use global offset table entry as symbol value.  */
4642         case R_X86_64_GOTPLT64:
4643           /* This is obsolete and treated the same as GOT64.  */
4644           base_got = htab->elf.sgot;
4645
4646           if (htab->elf.sgot == NULL)
4647             abort ();
4648
4649           relative_reloc = FALSE;
4650           if (h != NULL)
4651             {
4652               bfd_boolean dyn;
4653
4654               off = h->got.offset;
4655               if (h->needs_plt
4656                   && h->plt.offset != (bfd_vma)-1
4657                   && off == (bfd_vma)-1)
4658                 {
4659                   /* We can't use h->got.offset here to save
4660                      state, or even just remember the offset, as
4661                      finish_dynamic_symbol would use that as offset into
4662                      .got.  */
4663                   bfd_vma plt_index = (h->plt.offset / plt_entry_size
4664                                        - htab->plt.has_plt0);
4665                   off = (plt_index + 3) * GOT_ENTRY_SIZE;
4666                   base_got = htab->elf.sgotplt;
4667                 }
4668
4669               dyn = htab->elf.dynamic_sections_created;
4670
4671               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
4672                   || (bfd_link_pic (info)
4673                       && SYMBOL_REFERENCES_LOCAL (info, h))
4674                   || (ELF_ST_VISIBILITY (h->other)
4675                       && h->root.type == bfd_link_hash_undefweak))
4676                 {
4677                   /* This is actually a static link, or it is a -Bsymbolic
4678                      link and the symbol is defined locally, or the symbol
4679                      was forced to be local because of a version file.  We
4680                      must initialize this entry in the global offset table.
4681                      Since the offset must always be a multiple of 8, we
4682                      use the least significant bit to record whether we
4683                      have initialized it already.
4684
4685                      When doing a dynamic link, we create a .rela.got
4686                      relocation entry to initialize the value.  This is
4687                      done in the finish_dynamic_symbol routine.  */
4688                   if ((off & 1) != 0)
4689                     off &= ~1;
4690                   else
4691                     {
4692                       bfd_put_64 (output_bfd, relocation,
4693                                   base_got->contents + off);
4694                       /* Note that this is harmless for the GOTPLT64 case,
4695                          as -1 | 1 still is -1.  */
4696                       h->got.offset |= 1;
4697
4698                       if (h->dynindx == -1
4699                           && !h->forced_local
4700                           && h->root.type != bfd_link_hash_undefweak
4701                           && bfd_link_pic (info))
4702                         {
4703                           /* If this symbol isn't dynamic in PIC,
4704                              generate R_X86_64_RELATIVE here.  */
4705                           eh->no_finish_dynamic_symbol = 1;
4706                           relative_reloc = TRUE;
4707                         }
4708                     }
4709                 }
4710               else
4711                 unresolved_reloc = FALSE;
4712             }
4713           else
4714             {
4715               if (local_got_offsets == NULL)
4716                 abort ();
4717
4718               off = local_got_offsets[r_symndx];
4719
4720               /* The offset must always be a multiple of 8.  We use
4721                  the least significant bit to record whether we have
4722                  already generated the necessary reloc.  */
4723               if ((off & 1) != 0)
4724                 off &= ~1;
4725               else
4726                 {
4727                   bfd_put_64 (output_bfd, relocation,
4728                               base_got->contents + off);
4729                   local_got_offsets[r_symndx] |= 1;
4730
4731                   if (bfd_link_pic (info))
4732                     relative_reloc = TRUE;
4733                 }
4734             }
4735
4736           if (relative_reloc)
4737             {
4738               asection *s;
4739               Elf_Internal_Rela outrel;
4740
4741               /* We need to generate a R_X86_64_RELATIVE reloc
4742                  for the dynamic linker.  */
4743               s = htab->elf.srelgot;
4744               if (s == NULL)
4745                 abort ();
4746
4747               outrel.r_offset = (base_got->output_section->vma
4748                                  + base_got->output_offset
4749                                  + off);
4750               outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
4751               outrel.r_addend = relocation;
4752               elf_append_rela (output_bfd, s, &outrel);
4753             }
4754
4755           if (off >= (bfd_vma) -2)
4756             abort ();
4757
4758           relocation = base_got->output_section->vma
4759                        + base_got->output_offset + off;
4760           if (r_type != R_X86_64_GOTPCREL
4761               && r_type != R_X86_64_GOTPCRELX
4762               && r_type != R_X86_64_REX_GOTPCRELX
4763               && r_type != R_X86_64_GOTPCREL64)
4764             relocation -= htab->elf.sgotplt->output_section->vma
4765                           - htab->elf.sgotplt->output_offset;
4766
4767           break;
4768
4769         case R_X86_64_GOTOFF64:
4770           /* Relocation is relative to the start of the global offset
4771              table.  */
4772
4773           /* Check to make sure it isn't a protected function or data
4774              symbol for shared library since it may not be local when
4775              used as function address or with copy relocation.  We also
4776              need to make sure that a symbol is referenced locally.  */
4777           if (bfd_link_pic (info) && h)
4778             {
4779               if (!h->def_regular)
4780                 {
4781                   const char *v;
4782
4783                   switch (ELF_ST_VISIBILITY (h->other))
4784                     {
4785                     case STV_HIDDEN:
4786                       v = _("hidden symbol");
4787                       break;
4788                     case STV_INTERNAL:
4789                       v = _("internal symbol");
4790                       break;
4791                     case STV_PROTECTED:
4792                       v = _("protected symbol");
4793                       break;
4794                     default:
4795                       v = _("symbol");
4796                       break;
4797                     }
4798
4799                   _bfd_error_handler
4800                     /* xgettext:c-format */
4801                     (_("%B: relocation R_X86_64_GOTOFF64 against undefined %s"
4802                        " `%s' can not be used when making a shared object"),
4803                      input_bfd, v, h->root.root.string);
4804                   bfd_set_error (bfd_error_bad_value);
4805                   return FALSE;
4806                 }
4807               else if (!bfd_link_executable (info)
4808                        && !SYMBOL_REFERENCES_LOCAL (info, h)
4809                        && (h->type == STT_FUNC
4810                            || h->type == STT_OBJECT)
4811                        && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED)
4812                 {
4813                   _bfd_error_handler
4814               /* xgettext:c-format */
4815                     (_("%B: relocation R_X86_64_GOTOFF64 against protected %s"
4816                        " `%s' can not be used when making a shared object"),
4817                      input_bfd,
4818                      h->type == STT_FUNC ? "function" : "data",
4819                      h->root.root.string);
4820                   bfd_set_error (bfd_error_bad_value);
4821               return FALSE;
4822                 }
4823             }
4824
4825           /* Note that sgot is not involved in this
4826              calculation.  We always want the start of .got.plt.  If we
4827              defined _GLOBAL_OFFSET_TABLE_ in a different way, as is
4828              permitted by the ABI, we might have to change this
4829              calculation.  */
4830           relocation -= htab->elf.sgotplt->output_section->vma
4831                         + htab->elf.sgotplt->output_offset;
4832           break;
4833
4834         case R_X86_64_GOTPC32:
4835         case R_X86_64_GOTPC64:
4836           /* Use global offset table as symbol value.  */
4837           relocation = htab->elf.sgotplt->output_section->vma
4838                        + htab->elf.sgotplt->output_offset;
4839           unresolved_reloc = FALSE;
4840           break;
4841
4842         case R_X86_64_PLTOFF64:
4843           /* Relocation is PLT entry relative to GOT.  For local
4844              symbols it's the symbol itself relative to GOT.  */
4845           if (h != NULL
4846               /* See PLT32 handling.  */
4847               && (h->plt.offset != (bfd_vma) -1
4848                   || eh->plt_got.offset != (bfd_vma) -1)
4849               && htab->elf.splt != NULL)
4850             {
4851               if (eh->plt_got.offset != (bfd_vma) -1)
4852                 {
4853                   /* Use the GOT PLT.  */
4854                   resolved_plt = htab->plt_got;
4855                   plt_offset = eh->plt_got.offset;
4856                 }
4857               else if (htab->plt_second != NULL)
4858                 {
4859                   resolved_plt = htab->plt_second;
4860                   plt_offset = eh->plt_second.offset;
4861                 }
4862               else
4863                 {
4864                   resolved_plt = htab->elf.splt;
4865                   plt_offset = h->plt.offset;
4866                 }
4867
4868               relocation = (resolved_plt->output_section->vma
4869                             + resolved_plt->output_offset
4870                             + plt_offset);
4871               unresolved_reloc = FALSE;
4872             }
4873
4874           relocation -= htab->elf.sgotplt->output_section->vma
4875                         + htab->elf.sgotplt->output_offset;
4876           break;
4877
4878         case R_X86_64_PLT32:
4879         case R_X86_64_PLT32_BND:
4880           /* Relocation is to the entry for this symbol in the
4881              procedure linkage table.  */
4882
4883           /* Resolve a PLT32 reloc against a local symbol directly,
4884              without using the procedure linkage table.  */
4885           if (h == NULL)
4886             break;
4887
4888           if ((h->plt.offset == (bfd_vma) -1
4889                && eh->plt_got.offset == (bfd_vma) -1)
4890               || htab->elf.splt == NULL)
4891             {
4892               /* We didn't make a PLT entry for this symbol.  This
4893                  happens when statically linking PIC code, or when
4894                  using -Bsymbolic.  */
4895               break;
4896             }
4897
4898           if (h->plt.offset != (bfd_vma) -1)
4899             {
4900               if (htab->plt_second != NULL)
4901                 {
4902                   resolved_plt = htab->plt_second;
4903                   plt_offset = eh->plt_second.offset;
4904                 }
4905               else
4906                 {
4907                   resolved_plt = htab->elf.splt;
4908                   plt_offset = h->plt.offset;
4909                 }
4910             }
4911           else
4912             {
4913               /* Use the GOT PLT.  */
4914               resolved_plt = htab->plt_got;
4915               plt_offset = eh->plt_got.offset;
4916             }
4917
4918           relocation = (resolved_plt->output_section->vma
4919                         + resolved_plt->output_offset
4920                         + plt_offset);
4921           unresolved_reloc = FALSE;
4922           break;
4923
4924         case R_X86_64_SIZE32:
4925         case R_X86_64_SIZE64:
4926           /* Set to symbol size.  */
4927           relocation = st_size;
4928           goto direct;
4929
4930         case R_X86_64_PC8:
4931         case R_X86_64_PC16:
4932         case R_X86_64_PC32:
4933         case R_X86_64_PC32_BND:
4934           /* Don't complain about -fPIC if the symbol is undefined when
4935              building executable unless it is unresolved weak symbol.  */
4936           if ((input_section->flags & SEC_ALLOC) != 0
4937               && (input_section->flags & SEC_READONLY) != 0
4938               && h != NULL
4939               && ((bfd_link_executable (info)
4940                    && h->root.type == bfd_link_hash_undefweak
4941                    && !resolved_to_zero)
4942                   || bfd_link_dll (info)))
4943             {
4944               bfd_boolean fail = FALSE;
4945               bfd_boolean branch
4946                 = ((r_type == R_X86_64_PC32
4947                     || r_type == R_X86_64_PC32_BND)
4948                    && is_32bit_relative_branch (contents, rel->r_offset));
4949
4950               if (SYMBOL_REFERENCES_LOCAL (info, h))
4951                 {
4952                   /* Symbol is referenced locally.  Make sure it is
4953                      defined locally or for a branch.  */
4954                   fail = (!(h->def_regular || ELF_COMMON_DEF_P (h))
4955                           && !branch);
4956                 }
4957               else if (!(bfd_link_pie (info)
4958                          && (h->needs_copy || eh->needs_copy)))
4959                 {
4960                   /* Symbol doesn't need copy reloc and isn't referenced
4961                      locally.  We only allow branch to symbol with
4962                      non-default visibility. */
4963                   fail = (!branch
4964                           || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT);
4965                 }
4966
4967               if (fail)
4968                 return elf_x86_64_need_pic (input_bfd, input_section,
4969                                             h, NULL, NULL, howto);
4970             }
4971           /* Fall through.  */
4972
4973         case R_X86_64_8:
4974         case R_X86_64_16:
4975         case R_X86_64_32:
4976         case R_X86_64_PC64:
4977         case R_X86_64_64:
4978           /* FIXME: The ABI says the linker should make sure the value is
4979              the same when it's zeroextended to 64 bit.  */
4980
4981 direct:
4982           if ((input_section->flags & SEC_ALLOC) == 0)
4983             break;
4984
4985            /* Don't copy a pc-relative relocation into the output file
4986               if the symbol needs copy reloc or the symbol is undefined
4987               when building executable.  Copy dynamic function pointer
4988               relocations.  Don't generate dynamic relocations against
4989               resolved undefined weak symbols in PIE.  */
4990           if ((bfd_link_pic (info)
4991                && !(bfd_link_pie (info)
4992                     && h != NULL
4993                     && (h->needs_copy
4994                         || eh->needs_copy
4995                         || h->root.type == bfd_link_hash_undefined)
4996                     && (IS_X86_64_PCREL_TYPE (r_type)
4997                         || r_type == R_X86_64_SIZE32
4998                         || r_type == R_X86_64_SIZE64))
4999                && (h == NULL
5000                    || ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5001                         && !resolved_to_zero)
5002                        || h->root.type != bfd_link_hash_undefweak))
5003                && ((! IS_X86_64_PCREL_TYPE (r_type)
5004                       && r_type != R_X86_64_SIZE32
5005                       && r_type != R_X86_64_SIZE64)
5006                    || ! SYMBOL_CALLS_LOCAL (info, h)))
5007               || (ELIMINATE_COPY_RELOCS
5008                   && !bfd_link_pic (info)
5009                   && h != NULL
5010                   && h->dynindx != -1
5011                   && (!h->non_got_ref
5012                       || eh->func_pointer_refcount > 0
5013                       || (h->root.type == bfd_link_hash_undefweak
5014                           && !resolved_to_zero))
5015                   && ((h->def_dynamic && !h->def_regular)
5016                       /* Undefined weak symbol is bound locally when
5017                          PIC is false.  */
5018                       || h->root.type == bfd_link_hash_undefined)))
5019             {
5020               Elf_Internal_Rela outrel;
5021               bfd_boolean skip, relocate;
5022               asection *sreloc;
5023
5024               /* When generating a shared object, these relocations
5025                  are copied into the output file to be resolved at run
5026                  time.  */
5027               skip = FALSE;
5028               relocate = FALSE;
5029
5030               outrel.r_offset =
5031                 _bfd_elf_section_offset (output_bfd, info, input_section,
5032                                          rel->r_offset);
5033               if (outrel.r_offset == (bfd_vma) -1)
5034                 skip = TRUE;
5035               else if (outrel.r_offset == (bfd_vma) -2)
5036                 skip = TRUE, relocate = TRUE;
5037
5038               outrel.r_offset += (input_section->output_section->vma
5039                                   + input_section->output_offset);
5040
5041               if (skip)
5042                 memset (&outrel, 0, sizeof outrel);
5043
5044               /* h->dynindx may be -1 if this symbol was marked to
5045                  become local.  */
5046               else if (h != NULL
5047                        && h->dynindx != -1
5048                        && (IS_X86_64_PCREL_TYPE (r_type)
5049                            || !(bfd_link_executable (info)
5050                                 || SYMBOLIC_BIND (info, h))
5051                            || ! h->def_regular))
5052                 {
5053                   outrel.r_info = htab->r_info (h->dynindx, r_type);
5054                   outrel.r_addend = rel->r_addend;
5055                 }
5056               else
5057                 {
5058                   /* This symbol is local, or marked to become local.
5059                      When relocation overflow check is disabled, we
5060                      convert R_X86_64_32 to dynamic R_X86_64_RELATIVE.  */
5061                   if (r_type == htab->pointer_r_type
5062                       || (r_type == R_X86_64_32
5063                           && info->no_reloc_overflow_check))
5064                     {
5065                       relocate = TRUE;
5066                       outrel.r_info = htab->r_info (0, R_X86_64_RELATIVE);
5067                       outrel.r_addend = relocation + rel->r_addend;
5068                     }
5069                   else if (r_type == R_X86_64_64
5070                            && !ABI_64_P (output_bfd))
5071                     {
5072                       relocate = TRUE;
5073                       outrel.r_info = htab->r_info (0,
5074                                                     R_X86_64_RELATIVE64);
5075                       outrel.r_addend = relocation + rel->r_addend;
5076                       /* Check addend overflow.  */
5077                       if ((outrel.r_addend & 0x80000000)
5078                           != (rel->r_addend & 0x80000000))
5079                         {
5080                           const char *name;
5081                           int addend = rel->r_addend;
5082                           if (h && h->root.root.string)
5083                             name = h->root.root.string;
5084                           else
5085                             name = bfd_elf_sym_name (input_bfd, symtab_hdr,
5086                                                      sym, NULL);
5087                           _bfd_error_handler
5088                             /* xgettext:c-format */
5089                             (_("%B: addend %s%#x in relocation %s against "
5090                                "symbol `%s' at %#Lx in section `%A' is "
5091                                "out of range"),
5092                              input_bfd, addend < 0 ? "-" : "", addend,
5093                              howto->name, name, rel->r_offset, input_section);
5094                           bfd_set_error (bfd_error_bad_value);
5095                           return FALSE;
5096                         }
5097                     }
5098                   else
5099                     {
5100                       long sindx;
5101
5102                       if (bfd_is_abs_section (sec))
5103                         sindx = 0;
5104                       else if (sec == NULL || sec->owner == NULL)
5105                         {
5106                           bfd_set_error (bfd_error_bad_value);
5107                           return FALSE;
5108                         }
5109                       else
5110                         {
5111                           asection *osec;
5112
5113                           /* We are turning this relocation into one
5114                              against a section symbol.  It would be
5115                              proper to subtract the symbol's value,
5116                              osec->vma, from the emitted reloc addend,
5117                              but ld.so expects buggy relocs.  */
5118                           osec = sec->output_section;
5119                           sindx = elf_section_data (osec)->dynindx;
5120                           if (sindx == 0)
5121                             {
5122                               asection *oi = htab->elf.text_index_section;
5123                               sindx = elf_section_data (oi)->dynindx;
5124                             }
5125                           BFD_ASSERT (sindx != 0);
5126                         }
5127
5128                       outrel.r_info = htab->r_info (sindx, r_type);
5129                       outrel.r_addend = relocation + rel->r_addend;
5130                     }
5131                 }
5132
5133               sreloc = elf_section_data (input_section)->sreloc;
5134
5135               if (sreloc == NULL || sreloc->contents == NULL)
5136                 {
5137                   r = bfd_reloc_notsupported;
5138                   goto check_relocation_error;
5139                 }
5140
5141               elf_append_rela (output_bfd, sreloc, &outrel);
5142
5143               /* If this reloc is against an external symbol, we do
5144                  not want to fiddle with the addend.  Otherwise, we
5145                  need to include the symbol value so that it becomes
5146                  an addend for the dynamic reloc.  */
5147               if (! relocate)
5148                 continue;
5149             }
5150
5151           break;
5152
5153         case R_X86_64_TLSGD:
5154         case R_X86_64_GOTPC32_TLSDESC:
5155         case R_X86_64_TLSDESC_CALL:
5156         case R_X86_64_GOTTPOFF:
5157           tls_type = GOT_UNKNOWN;
5158           if (h == NULL && local_got_offsets)
5159             tls_type = elf_x86_64_local_got_tls_type (input_bfd) [r_symndx];
5160           else if (h != NULL)
5161             tls_type = elf_x86_64_hash_entry (h)->tls_type;
5162
5163           if (! elf_x86_64_tls_transition (info, input_bfd,
5164                                            input_section, contents,
5165                                            symtab_hdr, sym_hashes,
5166                                            &r_type, tls_type, rel,
5167                                            relend, h, r_symndx, TRUE))
5168             return FALSE;
5169
5170           if (r_type == R_X86_64_TPOFF32)
5171             {
5172               bfd_vma roff = rel->r_offset;
5173
5174               BFD_ASSERT (! unresolved_reloc);
5175
5176               if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
5177                 {
5178                   /* GD->LE transition.  For 64bit, change
5179                         .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5180                         .word 0x6666; rex64; call __tls_get_addr@PLT
5181                      or
5182                         .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5183                         .byte 0x66; rex64
5184                         call *__tls_get_addr@GOTPCREL(%rip)
5185                         which may be converted to
5186                         addr32 call __tls_get_addr
5187                      into:
5188                         movq %fs:0, %rax
5189                         leaq foo@tpoff(%rax), %rax
5190                      For 32bit, change
5191                         leaq foo@tlsgd(%rip), %rdi
5192                         .word 0x6666; rex64; call __tls_get_addr@PLT
5193                      or
5194                         leaq foo@tlsgd(%rip), %rdi
5195                         .byte 0x66; rex64
5196                         call *__tls_get_addr@GOTPCREL(%rip)
5197                         which may be converted to
5198                         addr32 call __tls_get_addr
5199                      into:
5200                         movl %fs:0, %eax
5201                         leaq foo@tpoff(%rax), %rax
5202                      For largepic, change:
5203                         leaq foo@tlsgd(%rip), %rdi
5204                         movabsq $__tls_get_addr@pltoff, %rax
5205                         addq %r15, %rax
5206                         call *%rax
5207                      into:
5208                         movq %fs:0, %rax
5209                         leaq foo@tpoff(%rax), %rax
5210                         nopw 0x0(%rax,%rax,1)  */
5211                   int largepic = 0;
5212                   if (ABI_64_P (output_bfd))
5213                     {
5214                       if (contents[roff + 5] == 0xb8)
5215                         {
5216                           memcpy (contents + roff - 3,
5217                                   "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80"
5218                                   "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5219                           largepic = 1;
5220                         }
5221                       else
5222                         memcpy (contents + roff - 4,
5223                                 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5224                                 16);
5225                     }
5226                   else
5227                     memcpy (contents + roff - 3,
5228                             "\x64\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
5229                             15);
5230                   bfd_put_32 (output_bfd,
5231                               elf_x86_64_tpoff (info, relocation),
5232                               contents + roff + 8 + largepic);
5233                   /* Skip R_X86_64_PC32, R_X86_64_PLT32,
5234                      R_X86_64_GOTPCRELX and R_X86_64_PLTOFF64.  */
5235                   rel++;
5236                   wrel++;
5237                   continue;
5238                 }
5239               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
5240                 {
5241                   /* GDesc -> LE transition.
5242                      It's originally something like:
5243                      leaq x@tlsdesc(%rip), %rax
5244
5245                      Change it to:
5246                      movl $x@tpoff, %rax.  */
5247
5248                   unsigned int val, type;
5249
5250                   type = bfd_get_8 (input_bfd, contents + roff - 3);
5251                   val = bfd_get_8 (input_bfd, contents + roff - 1);
5252                   bfd_put_8 (output_bfd, 0x48 | ((type >> 2) & 1),
5253                              contents + roff - 3);
5254                   bfd_put_8 (output_bfd, 0xc7, contents + roff - 2);
5255                   bfd_put_8 (output_bfd, 0xc0 | ((val >> 3) & 7),
5256                              contents + roff - 1);
5257                   bfd_put_32 (output_bfd,
5258                               elf_x86_64_tpoff (info, relocation),
5259                               contents + roff);
5260                   continue;
5261                 }
5262               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
5263                 {
5264                   /* GDesc -> LE transition.
5265                      It's originally:
5266                      call *(%rax)
5267                      Turn it into:
5268                      xchg %ax,%ax.  */
5269                   bfd_put_8 (output_bfd, 0x66, contents + roff);
5270                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
5271                   continue;
5272                 }
5273               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTTPOFF)
5274                 {
5275                   /* IE->LE transition:
5276                      For 64bit, originally it can be one of:
5277                      movq foo@gottpoff(%rip), %reg
5278                      addq foo@gottpoff(%rip), %reg
5279                      We change it into:
5280                      movq $foo, %reg
5281                      leaq foo(%reg), %reg
5282                      addq $foo, %reg.
5283                      For 32bit, originally it can be one of:
5284                      movq foo@gottpoff(%rip), %reg
5285                      addl foo@gottpoff(%rip), %reg
5286                      We change it into:
5287                      movq $foo, %reg
5288                      leal foo(%reg), %reg
5289                      addl $foo, %reg. */
5290
5291                   unsigned int val, type, reg;
5292
5293                   if (roff >= 3)
5294                     val = bfd_get_8 (input_bfd, contents + roff - 3);
5295                   else
5296                     val = 0;
5297                   type = bfd_get_8 (input_bfd, contents + roff - 2);
5298                   reg = bfd_get_8 (input_bfd, contents + roff - 1);
5299                   reg >>= 3;
5300                   if (type == 0x8b)
5301                     {
5302                       /* movq */
5303                       if (val == 0x4c)
5304                         bfd_put_8 (output_bfd, 0x49,
5305                                    contents + roff - 3);
5306                       else if (!ABI_64_P (output_bfd) && val == 0x44)
5307                         bfd_put_8 (output_bfd, 0x41,
5308                                    contents + roff - 3);
5309                       bfd_put_8 (output_bfd, 0xc7,
5310                                  contents + roff - 2);
5311                       bfd_put_8 (output_bfd, 0xc0 | reg,
5312                                  contents + roff - 1);
5313                     }
5314                   else if (reg == 4)
5315                     {
5316                       /* addq/addl -> addq/addl - addressing with %rsp/%r12
5317                          is special  */
5318                       if (val == 0x4c)
5319                         bfd_put_8 (output_bfd, 0x49,
5320                                    contents + roff - 3);
5321                       else if (!ABI_64_P (output_bfd) && val == 0x44)
5322                         bfd_put_8 (output_bfd, 0x41,
5323                                    contents + roff - 3);
5324                       bfd_put_8 (output_bfd, 0x81,
5325                                  contents + roff - 2);
5326                       bfd_put_8 (output_bfd, 0xc0 | reg,
5327                                  contents + roff - 1);
5328                     }
5329                   else
5330                     {
5331                       /* addq/addl -> leaq/leal */
5332                       if (val == 0x4c)
5333                         bfd_put_8 (output_bfd, 0x4d,
5334                                    contents + roff - 3);
5335                       else if (!ABI_64_P (output_bfd) && val == 0x44)
5336                         bfd_put_8 (output_bfd, 0x45,
5337                                    contents + roff - 3);
5338                       bfd_put_8 (output_bfd, 0x8d,
5339                                  contents + roff - 2);
5340                       bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
5341                                  contents + roff - 1);
5342                     }
5343                   bfd_put_32 (output_bfd,
5344                               elf_x86_64_tpoff (info, relocation),
5345                               contents + roff);
5346                   continue;
5347                 }
5348               else
5349                 BFD_ASSERT (FALSE);
5350             }
5351
5352           if (htab->elf.sgot == NULL)
5353             abort ();
5354
5355           if (h != NULL)
5356             {
5357               off = h->got.offset;
5358               offplt = elf_x86_64_hash_entry (h)->tlsdesc_got;
5359             }
5360           else
5361             {
5362               if (local_got_offsets == NULL)
5363                 abort ();
5364
5365               off = local_got_offsets[r_symndx];
5366               offplt = local_tlsdesc_gotents[r_symndx];
5367             }
5368
5369           if ((off & 1) != 0)
5370             off &= ~1;
5371           else
5372             {
5373               Elf_Internal_Rela outrel;
5374               int dr_type, indx;
5375               asection *sreloc;
5376
5377               if (htab->elf.srelgot == NULL)
5378                 abort ();
5379
5380               indx = h && h->dynindx != -1 ? h->dynindx : 0;
5381
5382               if (GOT_TLS_GDESC_P (tls_type))
5383                 {
5384                   outrel.r_info = htab->r_info (indx, R_X86_64_TLSDESC);
5385                   BFD_ASSERT (htab->sgotplt_jump_table_size + offplt
5386                               + 2 * GOT_ENTRY_SIZE <= htab->elf.sgotplt->size);
5387                   outrel.r_offset = (htab->elf.sgotplt->output_section->vma
5388                                      + htab->elf.sgotplt->output_offset
5389                                      + offplt
5390                                      + htab->sgotplt_jump_table_size);
5391                   sreloc = htab->elf.srelplt;
5392                   if (indx == 0)
5393                     outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
5394                   else
5395                     outrel.r_addend = 0;
5396                   elf_append_rela (output_bfd, sreloc, &outrel);
5397                 }
5398
5399               sreloc = htab->elf.srelgot;
5400
5401               outrel.r_offset = (htab->elf.sgot->output_section->vma
5402                                  + htab->elf.sgot->output_offset + off);
5403
5404               if (GOT_TLS_GD_P (tls_type))
5405                 dr_type = R_X86_64_DTPMOD64;
5406               else if (GOT_TLS_GDESC_P (tls_type))
5407                 goto dr_done;
5408               else
5409                 dr_type = R_X86_64_TPOFF64;
5410
5411               bfd_put_64 (output_bfd, 0, htab->elf.sgot->contents + off);
5412               outrel.r_addend = 0;
5413               if ((dr_type == R_X86_64_TPOFF64
5414                    || dr_type == R_X86_64_TLSDESC) && indx == 0)
5415                 outrel.r_addend = relocation - elf_x86_64_dtpoff_base (info);
5416               outrel.r_info = htab->r_info (indx, dr_type);
5417
5418               elf_append_rela (output_bfd, sreloc, &outrel);
5419
5420               if (GOT_TLS_GD_P (tls_type))
5421                 {
5422                   if (indx == 0)
5423                     {
5424                       BFD_ASSERT (! unresolved_reloc);
5425                       bfd_put_64 (output_bfd,
5426                                   relocation - elf_x86_64_dtpoff_base (info),
5427                                   htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
5428                     }
5429                   else
5430                     {
5431                       bfd_put_64 (output_bfd, 0,
5432                                   htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
5433                       outrel.r_info = htab->r_info (indx,
5434                                                     R_X86_64_DTPOFF64);
5435                       outrel.r_offset += GOT_ENTRY_SIZE;
5436                       elf_append_rela (output_bfd, sreloc,
5437                                                 &outrel);
5438                     }
5439                 }
5440
5441             dr_done:
5442               if (h != NULL)
5443                 h->got.offset |= 1;
5444               else
5445                 local_got_offsets[r_symndx] |= 1;
5446             }
5447
5448           if (off >= (bfd_vma) -2
5449               && ! GOT_TLS_GDESC_P (tls_type))
5450             abort ();
5451           if (r_type == ELF32_R_TYPE (rel->r_info))
5452             {
5453               if (r_type == R_X86_64_GOTPC32_TLSDESC
5454                   || r_type == R_X86_64_TLSDESC_CALL)
5455                 relocation = htab->elf.sgotplt->output_section->vma
5456                   + htab->elf.sgotplt->output_offset
5457                   + offplt + htab->sgotplt_jump_table_size;
5458               else
5459                 relocation = htab->elf.sgot->output_section->vma
5460                   + htab->elf.sgot->output_offset + off;
5461               unresolved_reloc = FALSE;
5462             }
5463           else
5464             {
5465               bfd_vma roff = rel->r_offset;
5466
5467               if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
5468                 {
5469                   /* GD->IE transition.  For 64bit, change
5470                         .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5471                         .word 0x6666; rex64; call __tls_get_addr@PLT
5472                      or
5473                         .byte 0x66; leaq foo@tlsgd(%rip), %rdi
5474                         .byte 0x66; rex64
5475                         call *__tls_get_addr@GOTPCREL(%rip
5476                         which may be converted to
5477                         addr32 call __tls_get_addr
5478                      into:
5479                         movq %fs:0, %rax
5480                         addq foo@gottpoff(%rip), %rax
5481                      For 32bit, change
5482                         leaq foo@tlsgd(%rip), %rdi
5483                         .word 0x6666; rex64; call __tls_get_addr@PLT
5484                      or
5485                         leaq foo@tlsgd(%rip), %rdi
5486                         .byte 0x66; rex64;
5487                         call *__tls_get_addr@GOTPCREL(%rip)
5488                         which may be converted to
5489                         addr32 call __tls_get_addr
5490                      into:
5491                         movl %fs:0, %eax
5492                         addq foo@gottpoff(%rip), %rax
5493                      For largepic, change:
5494                         leaq foo@tlsgd(%rip), %rdi
5495                         movabsq $__tls_get_addr@pltoff, %rax
5496                         addq %r15, %rax
5497                         call *%rax
5498                      into:
5499                         movq %fs:0, %rax
5500                         addq foo@gottpoff(%rax), %rax
5501                         nopw 0x0(%rax,%rax,1)  */
5502                   int largepic = 0;
5503                   if (ABI_64_P (output_bfd))
5504                     {
5505                       if (contents[roff + 5] == 0xb8)
5506                         {
5507                           memcpy (contents + roff - 3,
5508                                   "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05"
5509                                   "\0\0\0\0\x66\x0f\x1f\x44\0", 22);
5510                           largepic = 1;
5511                         }
5512                       else
5513                         memcpy (contents + roff - 4,
5514                                 "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5515                                 16);
5516                     }
5517                   else
5518                     memcpy (contents + roff - 3,
5519                             "\x64\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
5520                             15);
5521
5522                   relocation = (htab->elf.sgot->output_section->vma
5523                                 + htab->elf.sgot->output_offset + off
5524                                 - roff
5525                                 - largepic
5526                                 - input_section->output_section->vma
5527                                 - input_section->output_offset
5528                                 - 12);
5529                   bfd_put_32 (output_bfd, relocation,
5530                               contents + roff + 8 + largepic);
5531                   /* Skip R_X86_64_PLT32/R_X86_64_PLTOFF64.  */
5532                   rel++;
5533                   wrel++;
5534                   continue;
5535                 }
5536               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_GOTPC32_TLSDESC)
5537                 {
5538                   /* GDesc -> IE transition.
5539                      It's originally something like:
5540                      leaq x@tlsdesc(%rip), %rax
5541
5542                      Change it to:
5543                      movq x@gottpoff(%rip), %rax # before xchg %ax,%ax.  */
5544
5545                   /* Now modify the instruction as appropriate. To
5546                      turn a leaq into a movq in the form we use it, it
5547                      suffices to change the second byte from 0x8d to
5548                      0x8b.  */
5549                   bfd_put_8 (output_bfd, 0x8b, contents + roff - 2);
5550
5551                   bfd_put_32 (output_bfd,
5552                               htab->elf.sgot->output_section->vma
5553                               + htab->elf.sgot->output_offset + off
5554                               - rel->r_offset
5555                               - input_section->output_section->vma
5556                               - input_section->output_offset
5557                               - 4,
5558                               contents + roff);
5559                   continue;
5560                 }
5561               else if (ELF32_R_TYPE (rel->r_info) == R_X86_64_TLSDESC_CALL)
5562                 {
5563                   /* GDesc -> IE transition.
5564                      It's originally:
5565                      call *(%rax)
5566
5567                      Change it to:
5568                      xchg %ax, %ax.  */
5569
5570                   bfd_put_8 (output_bfd, 0x66, contents + roff);
5571                   bfd_put_8 (output_bfd, 0x90, contents + roff + 1);
5572                   continue;
5573                 }
5574               else
5575                 BFD_ASSERT (FALSE);
5576             }
5577           break;
5578
5579         case R_X86_64_TLSLD:
5580           if (! elf_x86_64_tls_transition (info, input_bfd,
5581                                            input_section, contents,
5582                                            symtab_hdr, sym_hashes,
5583                                            &r_type, GOT_UNKNOWN, rel,
5584                                            relend, h, r_symndx, TRUE))
5585             return FALSE;
5586
5587           if (r_type != R_X86_64_TLSLD)
5588             {
5589               /* LD->LE transition:
5590                         leaq foo@tlsld(%rip), %rdi
5591                         call __tls_get_addr@PLT
5592                  For 64bit, we change it into:
5593                         .word 0x6666; .byte 0x66; movq %fs:0, %rax
5594                  For 32bit, we change it into:
5595                         nopl 0x0(%rax); movl %fs:0, %eax
5596                  Or
5597                         leaq foo@tlsld(%rip), %rdi;
5598                         call *__tls_get_addr@GOTPCREL(%rip)
5599                         which may be converted to
5600                         addr32 call __tls_get_addr
5601                  For 64bit, we change it into:
5602                         .word 0x6666; .word 0x6666; movq %fs:0, %rax
5603                  For 32bit, we change it into:
5604                         nopw 0x0(%rax); movl %fs:0, %eax
5605                  For largepic, change:
5606                         leaq foo@tlsgd(%rip), %rdi
5607                         movabsq $__tls_get_addr@pltoff, %rax
5608                         addq %rbx, %rax
5609                         call *%rax
5610                  into
5611                         data16 data16 data16 nopw %cs:0x0(%rax,%rax,1)
5612                         movq %fs:0, %eax  */
5613
5614               BFD_ASSERT (r_type == R_X86_64_TPOFF32);
5615               if (ABI_64_P (output_bfd))
5616                 {
5617                   if (contents[rel->r_offset + 5] == 0xb8)
5618                     memcpy (contents + rel->r_offset - 3,
5619                             "\x66\x66\x66\x66\x2e\x0f\x1f\x84\0\0\0\0\0"
5620                             "\x64\x48\x8b\x04\x25\0\0\0", 22);
5621                   else if (contents[rel->r_offset + 4] == 0xff
5622                            || contents[rel->r_offset + 4] == 0x67)
5623                     memcpy (contents + rel->r_offset - 3,
5624                             "\x66\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0",
5625                             13);
5626                   else
5627                     memcpy (contents + rel->r_offset - 3,
5628                             "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
5629                 }
5630               else
5631                 {
5632                   if (contents[rel->r_offset + 4] == 0xff)
5633                     memcpy (contents + rel->r_offset - 3,
5634                             "\x66\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0",
5635                             13);
5636                   else
5637                     memcpy (contents + rel->r_offset - 3,
5638                             "\x0f\x1f\x40\x00\x64\x8b\x04\x25\0\0\0", 12);
5639                 }
5640               /* Skip R_X86_64_PC32, R_X86_64_PLT32, R_X86_64_GOTPCRELX
5641                  and R_X86_64_PLTOFF64.  */
5642               rel++;
5643               wrel++;
5644               continue;
5645             }
5646
5647           if (htab->elf.sgot == NULL)
5648             abort ();
5649
5650           off = htab->tls_ld_got.offset;
5651           if (off & 1)
5652             off &= ~1;
5653           else
5654             {
5655               Elf_Internal_Rela outrel;
5656
5657               if (htab->elf.srelgot == NULL)
5658                 abort ();
5659
5660               outrel.r_offset = (htab->elf.sgot->output_section->vma
5661                                  + htab->elf.sgot->output_offset + off);
5662
5663               bfd_put_64 (output_bfd, 0,
5664                           htab->elf.sgot->contents + off);
5665               bfd_put_64 (output_bfd, 0,
5666                           htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
5667               outrel.r_info = htab->r_info (0, R_X86_64_DTPMOD64);
5668               outrel.r_addend = 0;
5669               elf_append_rela (output_bfd, htab->elf.srelgot,
5670                                         &outrel);
5671               htab->tls_ld_got.offset |= 1;
5672             }
5673           relocation = htab->elf.sgot->output_section->vma
5674                        + htab->elf.sgot->output_offset + off;
5675           unresolved_reloc = FALSE;
5676           break;
5677
5678         case R_X86_64_DTPOFF32:
5679           if (!bfd_link_executable (info)
5680               || (input_section->flags & SEC_CODE) == 0)
5681             relocation -= elf_x86_64_dtpoff_base (info);
5682           else
5683             relocation = elf_x86_64_tpoff (info, relocation);
5684           break;
5685
5686         case R_X86_64_TPOFF32:
5687         case R_X86_64_TPOFF64:
5688           BFD_ASSERT (bfd_link_executable (info));
5689           relocation = elf_x86_64_tpoff (info, relocation);
5690           break;
5691
5692         case R_X86_64_DTPOFF64:
5693           BFD_ASSERT ((input_section->flags & SEC_CODE) == 0);
5694           relocation -= elf_x86_64_dtpoff_base (info);
5695           break;
5696
5697         default:
5698           break;
5699         }
5700
5701       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
5702          because such sections are not SEC_ALLOC and thus ld.so will
5703          not process them.  */
5704       if (unresolved_reloc
5705           && !((input_section->flags & SEC_DEBUGGING) != 0
5706                && h->def_dynamic)
5707           && _bfd_elf_section_offset (output_bfd, info, input_section,
5708                                       rel->r_offset) != (bfd_vma) -1)
5709         {
5710           _bfd_error_handler
5711             /* xgettext:c-format */
5712             (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
5713              input_bfd,
5714              input_section,
5715              rel->r_offset,
5716              howto->name,
5717              h->root.root.string);
5718           return FALSE;
5719         }
5720
5721 do_relocation:
5722       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
5723                                     contents, rel->r_offset,
5724                                     relocation, rel->r_addend);
5725
5726 check_relocation_error:
5727       if (r != bfd_reloc_ok)
5728         {
5729           const char *name;
5730
5731           if (h != NULL)
5732             name = h->root.root.string;
5733           else
5734             {
5735               name = bfd_elf_string_from_elf_section (input_bfd,
5736                                                       symtab_hdr->sh_link,
5737                                                       sym->st_name);
5738               if (name == NULL)
5739                 return FALSE;
5740               if (*name == '\0')
5741                 name = bfd_section_name (input_bfd, sec);
5742             }
5743
5744           if (r == bfd_reloc_overflow)
5745             (*info->callbacks->reloc_overflow)
5746               (info, (h ? &h->root : NULL), name, howto->name,
5747                (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
5748           else
5749             {
5750               _bfd_error_handler
5751                 /* xgettext:c-format */
5752                 (_("%B(%A+%#Lx): reloc against `%s': error %d"),
5753                  input_bfd, input_section,
5754                  rel->r_offset, name, (int) r);
5755               return FALSE;
5756             }
5757         }
5758
5759       if (wrel != rel)
5760         *wrel = *rel;
5761     }
5762
5763   if (wrel != rel)
5764     {
5765       Elf_Internal_Shdr *rel_hdr;
5766       size_t deleted = rel - wrel;
5767
5768       rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section);
5769       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
5770       if (rel_hdr->sh_size == 0)
5771         {
5772           /* It is too late to remove an empty reloc section.  Leave
5773              one NONE reloc.
5774              ??? What is wrong with an empty section???  */
5775           rel_hdr->sh_size = rel_hdr->sh_entsize;
5776           deleted -= 1;
5777         }
5778       rel_hdr = _bfd_elf_single_rel_hdr (input_section);
5779       rel_hdr->sh_size -= rel_hdr->sh_entsize * deleted;
5780       input_section->reloc_count -= deleted;
5781     }
5782
5783   return TRUE;
5784 }
5785
5786 /* Finish up dynamic symbol handling.  We set the contents of various
5787    dynamic sections here.  */
5788
5789 static bfd_boolean
5790 elf_x86_64_finish_dynamic_symbol (bfd *output_bfd,
5791                                   struct bfd_link_info *info,
5792                                   struct elf_link_hash_entry *h,
5793                                   Elf_Internal_Sym *sym)
5794 {
5795   struct elf_x86_64_link_hash_table *htab;
5796   bfd_boolean use_plt_second;
5797   struct elf_x86_64_link_hash_entry *eh;
5798   bfd_boolean local_undefweak;
5799
5800   htab = elf_x86_64_hash_table (info);
5801   if (htab == NULL)
5802     return FALSE;
5803
5804   /* Use the second PLT section only if there is .plt section.  */
5805   use_plt_second = htab->elf.splt != NULL && htab->plt_second != NULL;
5806
5807   eh = (struct elf_x86_64_link_hash_entry *) h;
5808   if (eh->no_finish_dynamic_symbol)
5809     abort ();
5810
5811   /* We keep PLT/GOT entries without dynamic PLT/GOT relocations for
5812      resolved undefined weak symbols in executable so that their
5813      references have value 0 at run-time.  */
5814   local_undefweak = UNDEFINED_WEAK_RESOLVED_TO_ZERO (info,
5815                                                      eh->has_got_reloc,
5816                                                      eh);
5817
5818   if (h->plt.offset != (bfd_vma) -1)
5819     {
5820       bfd_vma plt_index;
5821       bfd_vma got_offset, plt_offset;
5822       Elf_Internal_Rela rela;
5823       bfd_byte *loc;
5824       asection *plt, *gotplt, *relplt, *resolved_plt;
5825       const struct elf_backend_data *bed;
5826       bfd_vma plt_got_pcrel_offset;
5827
5828       /* When building a static executable, use .iplt, .igot.plt and
5829          .rela.iplt sections for STT_GNU_IFUNC symbols.  */
5830       if (htab->elf.splt != NULL)
5831         {
5832           plt = htab->elf.splt;
5833           gotplt = htab->elf.sgotplt;
5834           relplt = htab->elf.srelplt;
5835         }
5836       else
5837         {
5838           plt = htab->elf.iplt;
5839           gotplt = htab->elf.igotplt;
5840           relplt = htab->elf.irelplt;
5841         }
5842
5843       /* This symbol has an entry in the procedure linkage table.  Set
5844          it up.  */
5845       if ((h->dynindx == -1
5846            && !local_undefweak
5847            && !((h->forced_local || bfd_link_executable (info))
5848                 && h->def_regular
5849                 && h->type == STT_GNU_IFUNC))
5850           || plt == NULL
5851           || gotplt == NULL
5852           || relplt == NULL)
5853         abort ();
5854
5855       /* Get the index in the procedure linkage table which
5856          corresponds to this symbol.  This is the index of this symbol
5857          in all the symbols for which we are making plt entries.  The
5858          first entry in the procedure linkage table is reserved.
5859
5860          Get the offset into the .got table of the entry that
5861          corresponds to this function.  Each .got entry is GOT_ENTRY_SIZE
5862          bytes. The first three are reserved for the dynamic linker.
5863
5864          For static executables, we don't reserve anything.  */
5865
5866       if (plt == htab->elf.splt)
5867         {
5868           got_offset = (h->plt.offset / htab->plt.plt_entry_size
5869                         - htab->plt.has_plt0);
5870           got_offset = (got_offset + 3) * GOT_ENTRY_SIZE;
5871         }
5872       else
5873         {
5874           got_offset = h->plt.offset / htab->plt.plt_entry_size;
5875           got_offset = got_offset * GOT_ENTRY_SIZE;
5876         }
5877
5878       /* Fill in the entry in the procedure linkage table.  */
5879       memcpy (plt->contents + h->plt.offset, htab->plt.plt_entry,
5880               htab->plt.plt_entry_size);
5881       if (use_plt_second)
5882         {
5883           memcpy (htab->plt_second->contents + eh->plt_second.offset,
5884                   htab->non_lazy_plt->plt_entry,
5885                   htab->non_lazy_plt->plt_entry_size);
5886
5887           resolved_plt = htab->plt_second;
5888           plt_offset = eh->plt_second.offset;
5889         }
5890       else
5891         {
5892           resolved_plt = plt;
5893           plt_offset = h->plt.offset;
5894         }
5895
5896       /* Insert the relocation positions of the plt section.  */
5897
5898       /* Put offset the PC-relative instruction referring to the GOT entry,
5899          subtracting the size of that instruction.  */
5900       plt_got_pcrel_offset = (gotplt->output_section->vma
5901                               + gotplt->output_offset
5902                               + got_offset
5903                               - resolved_plt->output_section->vma
5904                               - resolved_plt->output_offset
5905                               - plt_offset
5906                               - htab->plt.plt_got_insn_size);
5907
5908       /* Check PC-relative offset overflow in PLT entry.  */
5909       if ((plt_got_pcrel_offset + 0x80000000) > 0xffffffff)
5910         /* xgettext:c-format */
5911         info->callbacks->einfo (_("%F%B: PC-relative offset overflow in PLT entry for `%s'\n"),
5912                                 output_bfd, h->root.root.string);
5913
5914       bfd_put_32 (output_bfd, plt_got_pcrel_offset,
5915                   (resolved_plt->contents + plt_offset
5916                    + htab->plt.plt_got_offset));
5917
5918       /* Fill in the entry in the global offset table, initially this
5919          points to the second part of the PLT entry.  Leave the entry
5920          as zero for undefined weak symbol in PIE.  No PLT relocation
5921          against undefined weak symbol in PIE.  */
5922       if (!local_undefweak)
5923         {
5924           if (htab->plt.has_plt0)
5925             bfd_put_64 (output_bfd, (plt->output_section->vma
5926                                      + plt->output_offset
5927                                      + h->plt.offset
5928                                      + htab->lazy_plt->plt_lazy_offset),
5929                         gotplt->contents + got_offset);
5930
5931           /* Fill in the entry in the .rela.plt section.  */
5932           rela.r_offset = (gotplt->output_section->vma
5933                            + gotplt->output_offset
5934                            + got_offset);
5935           if (h->dynindx == -1
5936               || ((bfd_link_executable (info)
5937                    || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
5938                   && h->def_regular
5939                   && h->type == STT_GNU_IFUNC))
5940             {
5941               info->callbacks->minfo (_("Local IFUNC function `%s' in %B\n"),
5942                                       h->root.root.string,
5943                                       h->root.u.def.section->owner);
5944
5945               /* If an STT_GNU_IFUNC symbol is locally defined, generate
5946                  R_X86_64_IRELATIVE instead of R_X86_64_JUMP_SLOT.  */
5947               rela.r_info = htab->r_info (0, R_X86_64_IRELATIVE);
5948               rela.r_addend = (h->root.u.def.value
5949                                + h->root.u.def.section->output_section->vma
5950                                + h->root.u.def.section->output_offset);
5951               /* R_X86_64_IRELATIVE comes last.  */
5952               plt_index = htab->next_irelative_index--;
5953             }
5954           else
5955             {
5956               rela.r_info = htab->r_info (h->dynindx, R_X86_64_JUMP_SLOT);
5957               rela.r_addend = 0;
5958               plt_index = htab->next_jump_slot_index++;
5959             }
5960
5961           /* Don't fill the second and third slots in PLT entry for
5962              static executables nor without PLT0.  */
5963           if (plt == htab->elf.splt && htab->plt.has_plt0)
5964             {
5965               bfd_vma plt0_offset
5966                 = h->plt.offset + htab->lazy_plt->plt_plt_insn_end;
5967
5968               /* Put relocation index.  */
5969               bfd_put_32 (output_bfd, plt_index,
5970                           (plt->contents + h->plt.offset
5971                            + htab->lazy_plt->plt_reloc_offset));
5972
5973               /* Put offset for jmp .PLT0 and check for overflow.  We don't
5974                  check relocation index for overflow since branch displacement
5975                  will overflow first.  */
5976               if (plt0_offset > 0x80000000)
5977                 /* xgettext:c-format */
5978                 info->callbacks->einfo (_("%F%B: branch displacement overflow in PLT entry for `%s'\n"),
5979                                         output_bfd, h->root.root.string);
5980               bfd_put_32 (output_bfd, - plt0_offset,
5981                           (plt->contents + h->plt.offset
5982                            + htab->lazy_plt->plt_plt_offset));
5983             }
5984
5985           bed = get_elf_backend_data (output_bfd);
5986           loc = relplt->contents + plt_index * bed->s->sizeof_rela;
5987           bed->s->swap_reloca_out (output_bfd, &rela, loc);
5988         }
5989     }
5990   else if (eh->plt_got.offset != (bfd_vma) -1)
5991     {
5992       bfd_vma got_offset, plt_offset;
5993       asection *plt, *got;
5994       bfd_boolean got_after_plt;
5995       int32_t got_pcrel_offset;
5996
5997       /* Set the entry in the GOT procedure linkage table.  */
5998       plt = htab->plt_got;
5999       got = htab->elf.sgot;
6000       got_offset = h->got.offset;
6001
6002       if (got_offset == (bfd_vma) -1
6003           || (h->type == STT_GNU_IFUNC && h->def_regular)
6004           || plt == NULL
6005           || got == NULL)
6006         abort ();
6007
6008       /* Use the non-lazy PLT entry template for the GOT PLT since they
6009          are the identical.  */
6010       /* Fill in the entry in the GOT procedure linkage table.  */
6011       plt_offset = eh->plt_got.offset;
6012       memcpy (plt->contents + plt_offset,
6013               htab->non_lazy_plt->plt_entry,
6014               htab->non_lazy_plt->plt_entry_size);
6015
6016       /* Put offset the PC-relative instruction referring to the GOT
6017          entry, subtracting the size of that instruction.  */
6018       got_pcrel_offset = (got->output_section->vma
6019                           + got->output_offset
6020                           + got_offset
6021                           - plt->output_section->vma
6022                           - plt->output_offset
6023                           - plt_offset
6024                           - htab->non_lazy_plt->plt_got_insn_size);
6025
6026       /* Check PC-relative offset overflow in GOT PLT entry.  */
6027       got_after_plt = got->output_section->vma > plt->output_section->vma;
6028       if ((got_after_plt && got_pcrel_offset < 0)
6029           || (!got_after_plt && got_pcrel_offset > 0))
6030         /* xgettext:c-format */
6031         info->callbacks->einfo (_("%F%B: PC-relative offset overflow in GOT PLT entry for `%s'\n"),
6032                                 output_bfd, h->root.root.string);
6033
6034       bfd_put_32 (output_bfd, got_pcrel_offset,
6035                   (plt->contents + plt_offset
6036                    + htab->non_lazy_plt->plt_got_offset));
6037     }
6038
6039   if (!local_undefweak
6040       && !h->def_regular
6041       && (h->plt.offset != (bfd_vma) -1
6042           || eh->plt_got.offset != (bfd_vma) -1))
6043     {
6044       /* Mark the symbol as undefined, rather than as defined in
6045          the .plt section.  Leave the value if there were any
6046          relocations where pointer equality matters (this is a clue
6047          for the dynamic linker, to make function pointer
6048          comparisons work between an application and shared
6049          library), otherwise set it to zero.  If a function is only
6050          called from a binary, there is no need to slow down
6051          shared libraries because of that.  */
6052       sym->st_shndx = SHN_UNDEF;
6053       if (!h->pointer_equality_needed)
6054         sym->st_value = 0;
6055     }
6056
6057   /* Don't generate dynamic GOT relocation against undefined weak
6058      symbol in executable.  */
6059   if (h->got.offset != (bfd_vma) -1
6060       && ! GOT_TLS_GD_ANY_P (elf_x86_64_hash_entry (h)->tls_type)
6061       && elf_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE
6062       && !local_undefweak)
6063     {
6064       Elf_Internal_Rela rela;
6065       asection *relgot = htab->elf.srelgot;
6066
6067       /* This symbol has an entry in the global offset table.  Set it
6068          up.  */
6069       if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
6070         abort ();
6071
6072       rela.r_offset = (htab->elf.sgot->output_section->vma
6073                        + htab->elf.sgot->output_offset
6074                        + (h->got.offset &~ (bfd_vma) 1));
6075
6076       /* If this is a static link, or it is a -Bsymbolic link and the
6077          symbol is defined locally or was forced to be local because
6078          of a version file, we just want to emit a RELATIVE reloc.
6079          The entry in the global offset table will already have been
6080          initialized in the relocate_section function.  */
6081       if (h->def_regular
6082           && h->type == STT_GNU_IFUNC)
6083         {
6084           if (h->plt.offset == (bfd_vma) -1)
6085             {
6086               /* STT_GNU_IFUNC is referenced without PLT.  */
6087               if (htab->elf.splt == NULL)
6088                 {
6089                   /* use .rel[a].iplt section to store .got relocations
6090                      in static executable.  */
6091                   relgot = htab->elf.irelplt;
6092                 }
6093               if (SYMBOL_REFERENCES_LOCAL (info, h))
6094                 {
6095                   info->callbacks->minfo (_("Local IFUNC function `%s' in %B\n"),
6096                                           output_bfd,
6097                                           h->root.root.string,
6098                                           h->root.u.def.section->owner);
6099
6100                   rela.r_info = htab->r_info (0,
6101                                               R_X86_64_IRELATIVE);
6102                   rela.r_addend = (h->root.u.def.value
6103                                    + h->root.u.def.section->output_section->vma
6104                                    + h->root.u.def.section->output_offset);
6105                 }
6106               else
6107                 goto do_glob_dat;
6108             }
6109           else if (bfd_link_pic (info))
6110             {
6111               /* Generate R_X86_64_GLOB_DAT.  */
6112               goto do_glob_dat;
6113             }
6114           else
6115             {
6116               asection *plt;
6117               bfd_vma plt_offset;
6118
6119               if (!h->pointer_equality_needed)
6120                 abort ();
6121
6122               /* For non-shared object, we can't use .got.plt, which
6123                  contains the real function addres if we need pointer
6124                  equality.  We load the GOT entry with the PLT entry.  */
6125               if (htab->plt_second != NULL)
6126                 {
6127                   plt = htab->plt_second;
6128                   plt_offset = eh->plt_second.offset;
6129                 }
6130               else
6131                 {
6132                   plt = htab->elf.splt ? htab->elf.splt : htab->elf.iplt;
6133                   plt_offset =  h->plt.offset;
6134                 }
6135               bfd_put_64 (output_bfd, (plt->output_section->vma
6136                                        + plt->output_offset
6137                                        + plt_offset),
6138                           htab->elf.sgot->contents + h->got.offset);
6139               return TRUE;
6140             }
6141         }
6142       else if (bfd_link_pic (info)
6143                && SYMBOL_REFERENCES_LOCAL (info, h))
6144         {
6145           if (!h->def_regular)
6146             return FALSE;
6147           BFD_ASSERT((h->got.offset & 1) != 0);
6148           rela.r_info = htab->r_info (0, R_X86_64_RELATIVE);
6149           rela.r_addend = (h->root.u.def.value
6150                            + h->root.u.def.section->output_section->vma
6151                            + h->root.u.def.section->output_offset);
6152         }
6153       else
6154         {
6155           BFD_ASSERT((h->got.offset & 1) == 0);
6156 do_glob_dat:
6157           bfd_put_64 (output_bfd, (bfd_vma) 0,
6158                       htab->elf.sgot->contents + h->got.offset);
6159           rela.r_info = htab->r_info (h->dynindx, R_X86_64_GLOB_DAT);
6160           rela.r_addend = 0;
6161         }
6162
6163       elf_append_rela (output_bfd, relgot, &rela);
6164     }
6165
6166   if (h->needs_copy)
6167     {
6168       Elf_Internal_Rela rela;
6169       asection *s;
6170
6171       /* This symbol needs a copy reloc.  Set it up.  */
6172
6173       if (h->dynindx == -1
6174           || (h->root.type != bfd_link_hash_defined
6175               && h->root.type != bfd_link_hash_defweak)
6176           || htab->elf.srelbss == NULL
6177           || htab->elf.sreldynrelro == NULL)
6178         abort ();
6179
6180       rela.r_offset = (h->root.u.def.value
6181                        + h->root.u.def.section->output_section->vma
6182                        + h->root.u.def.section->output_offset);
6183       rela.r_info = htab->r_info (h->dynindx, R_X86_64_COPY);
6184       rela.r_addend = 0;
6185       if (h->root.u.def.section == htab->elf.sdynrelro)
6186         s = htab->elf.sreldynrelro;
6187       else
6188         s = htab->elf.srelbss;
6189       elf_append_rela (output_bfd, s, &rela);
6190     }
6191
6192   return TRUE;
6193 }
6194
6195 /* Finish up local dynamic symbol handling.  We set the contents of
6196    various dynamic sections here.  */
6197
6198 static bfd_boolean
6199 elf_x86_64_finish_local_dynamic_symbol (void **slot, void *inf)
6200 {
6201   struct elf_link_hash_entry *h
6202     = (struct elf_link_hash_entry *) *slot;
6203   struct bfd_link_info *info
6204     = (struct bfd_link_info *) inf;
6205
6206   return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
6207                                              info, h, NULL);
6208 }
6209
6210 /* Finish up undefined weak symbol handling in PIE.  Fill its PLT entry
6211    here since undefined weak symbol may not be dynamic and may not be
6212    called for elf_x86_64_finish_dynamic_symbol.  */
6213
6214 static bfd_boolean
6215 elf_x86_64_pie_finish_undefweak_symbol (struct bfd_hash_entry *bh,
6216                                         void *inf)
6217 {
6218   struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) bh;
6219   struct bfd_link_info *info = (struct bfd_link_info *) inf;
6220
6221   if (h->root.type != bfd_link_hash_undefweak
6222       || h->dynindx != -1)
6223     return TRUE;
6224
6225   return elf_x86_64_finish_dynamic_symbol (info->output_bfd,
6226                                              info, h, NULL);
6227 }
6228
6229 /* Used to decide how to sort relocs in an optimal manner for the
6230    dynamic linker, before writing them out.  */
6231
6232 static enum elf_reloc_type_class
6233 elf_x86_64_reloc_type_class (const struct bfd_link_info *info,
6234                              const asection *rel_sec ATTRIBUTE_UNUSED,
6235                              const Elf_Internal_Rela *rela)
6236 {
6237   bfd *abfd = info->output_bfd;
6238   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6239   struct elf_x86_64_link_hash_table *htab = elf_x86_64_hash_table (info);
6240
6241   if (htab->elf.dynsym != NULL
6242       && htab->elf.dynsym->contents != NULL)
6243     {
6244       /* Check relocation against STT_GNU_IFUNC symbol if there are
6245          dynamic symbols.  */
6246       unsigned long r_symndx = htab->r_sym (rela->r_info);
6247       if (r_symndx != STN_UNDEF)
6248         {
6249           Elf_Internal_Sym sym;
6250           if (!bed->s->swap_symbol_in (abfd,
6251                                        (htab->elf.dynsym->contents
6252                                         + r_symndx * bed->s->sizeof_sym),
6253                                        0, &sym))
6254             abort ();
6255
6256           if (ELF_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
6257             return reloc_class_ifunc;
6258         }
6259     }
6260
6261   switch ((int) ELF32_R_TYPE (rela->r_info))
6262     {
6263     case R_X86_64_IRELATIVE:
6264       return reloc_class_ifunc;
6265     case R_X86_64_RELATIVE:
6266     case R_X86_64_RELATIVE64:
6267       return reloc_class_relative;
6268     case R_X86_64_JUMP_SLOT:
6269       return reloc_class_plt;
6270     case R_X86_64_COPY:
6271       return reloc_class_copy;
6272     default:
6273       return reloc_class_normal;
6274     }
6275 }
6276
6277 /* Finish up the dynamic sections.  */
6278
6279 static bfd_boolean
6280 elf_x86_64_finish_dynamic_sections (bfd *output_bfd,
6281                                     struct bfd_link_info *info)
6282 {
6283   struct elf_x86_64_link_hash_table *htab;
6284   bfd *dynobj;
6285   asection *sdyn;
6286
6287   htab = elf_x86_64_hash_table (info);
6288   if (htab == NULL)
6289     return FALSE;
6290
6291   dynobj = htab->elf.dynobj;
6292   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
6293
6294   if (htab->elf.dynamic_sections_created)
6295     {
6296       bfd_byte *dyncon, *dynconend;
6297       const struct elf_backend_data *bed;
6298       bfd_size_type sizeof_dyn;
6299
6300       if (sdyn == NULL || htab->elf.sgot == NULL)
6301         abort ();
6302
6303       bed = get_elf_backend_data (dynobj);
6304       sizeof_dyn = bed->s->sizeof_dyn;
6305       dyncon = sdyn->contents;
6306       dynconend = sdyn->contents + sdyn->size;
6307       for (; dyncon < dynconend; dyncon += sizeof_dyn)
6308         {
6309           Elf_Internal_Dyn dyn;
6310           asection *s;
6311
6312           (*bed->s->swap_dyn_in) (dynobj, dyncon, &dyn);
6313
6314           switch (dyn.d_tag)
6315             {
6316             default:
6317               continue;
6318
6319             case DT_PLTGOT:
6320               s = htab->elf.sgotplt;
6321               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
6322               break;
6323
6324             case DT_JMPREL:
6325               dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
6326               break;
6327
6328             case DT_PLTRELSZ:
6329               s = htab->elf.srelplt->output_section;
6330               dyn.d_un.d_val = s->size;
6331               break;
6332
6333             case DT_TLSDESC_PLT:
6334               s = htab->elf.splt;
6335               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
6336                 + htab->tlsdesc_plt;
6337               break;
6338
6339             case DT_TLSDESC_GOT:
6340               s = htab->elf.sgot;
6341               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
6342                 + htab->tlsdesc_got;
6343               break;
6344             }
6345
6346           (*bed->s->swap_dyn_out) (output_bfd, &dyn, dyncon);
6347         }
6348
6349       if (htab->elf.splt && htab->elf.splt->size > 0)
6350         {
6351           elf_section_data (htab->elf.splt->output_section)
6352             ->this_hdr.sh_entsize = htab->plt.plt_entry_size;
6353
6354           if (htab->plt.has_plt0)
6355             {
6356               /* Fill in the special first entry in the procedure linkage
6357                  table.  */
6358               memcpy (htab->elf.splt->contents,
6359                       htab->lazy_plt->plt0_entry,
6360                       htab->lazy_plt->plt_entry_size);
6361               /* Add offset for pushq GOT+8(%rip), since the instruction
6362                  uses 6 bytes subtract this value.  */
6363               bfd_put_32 (output_bfd,
6364                           (htab->elf.sgotplt->output_section->vma
6365                            + htab->elf.sgotplt->output_offset
6366                            + 8
6367                            - htab->elf.splt->output_section->vma
6368                            - htab->elf.splt->output_offset
6369                            - 6),
6370                           (htab->elf.splt->contents
6371                            + htab->lazy_plt->plt0_got1_offset));
6372               /* Add offset for the PC-relative instruction accessing
6373                  GOT+16, subtracting the offset to the end of that
6374                  instruction.  */
6375               bfd_put_32 (output_bfd,
6376                           (htab->elf.sgotplt->output_section->vma
6377                            + htab->elf.sgotplt->output_offset
6378                            + 16
6379                            - htab->elf.splt->output_section->vma
6380                            - htab->elf.splt->output_offset
6381                            - htab->lazy_plt->plt0_got2_insn_end),
6382                           (htab->elf.splt->contents
6383                            + htab->lazy_plt->plt0_got2_offset));
6384
6385               if (htab->tlsdesc_plt)
6386                 {
6387                   bfd_put_64 (output_bfd, (bfd_vma) 0,
6388                               htab->elf.sgot->contents + htab->tlsdesc_got);
6389
6390                   memcpy (htab->elf.splt->contents + htab->tlsdesc_plt,
6391                           htab->lazy_plt->plt0_entry,
6392                           htab->lazy_plt->plt_entry_size);
6393
6394                   /* Add offset for pushq GOT+8(%rip), since the
6395                      instruction uses 6 bytes subtract this value.  */
6396                   bfd_put_32 (output_bfd,
6397                               (htab->elf.sgotplt->output_section->vma
6398                                + htab->elf.sgotplt->output_offset
6399                                + 8
6400                                - htab->elf.splt->output_section->vma
6401                                - htab->elf.splt->output_offset
6402                                - htab->tlsdesc_plt
6403                                - 6),
6404                               (htab->elf.splt->contents
6405                                + htab->tlsdesc_plt
6406                                + htab->lazy_plt->plt0_got1_offset));
6407                   /* Add offset for the PC-relative instruction accessing
6408                      GOT+TDG, where TDG stands for htab->tlsdesc_got,
6409                      subtracting the offset to the end of that
6410                      instruction.  */
6411                   bfd_put_32 (output_bfd,
6412                               (htab->elf.sgot->output_section->vma
6413                                + htab->elf.sgot->output_offset
6414                                + htab->tlsdesc_got
6415                                - htab->elf.splt->output_section->vma
6416                                - htab->elf.splt->output_offset
6417                                - htab->tlsdesc_plt
6418                                - htab->lazy_plt->plt0_got2_insn_end),
6419                               (htab->elf.splt->contents
6420                                + htab->tlsdesc_plt
6421                                + htab->lazy_plt->plt0_got2_offset));
6422                 }
6423             }
6424         }
6425     }
6426
6427   if (htab->plt_got != NULL && htab->plt_got->size > 0)
6428     elf_section_data (htab->plt_got->output_section)
6429       ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size;
6430
6431   if (htab->plt_second != NULL && htab->plt_second->size > 0)
6432     elf_section_data (htab->plt_second->output_section)
6433       ->this_hdr.sh_entsize = htab->non_lazy_plt->plt_entry_size;
6434
6435   /* GOT is always created in setup_gnu_properties.  But it may not be
6436      needed.  */
6437   if (htab->elf.sgotplt && htab->elf.sgotplt->size > 0)
6438     {
6439       if (bfd_is_abs_section (htab->elf.sgotplt->output_section))
6440         {
6441           _bfd_error_handler
6442             (_("discarded output section: `%A'"), htab->elf.sgotplt);
6443           return FALSE;
6444         }
6445
6446       /* Set the first entry in the global offset table to the address of
6447          the dynamic section.  */
6448       if (sdyn == NULL)
6449         bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents);
6450       else
6451         bfd_put_64 (output_bfd,
6452                     sdyn->output_section->vma + sdyn->output_offset,
6453                     htab->elf.sgotplt->contents);
6454       /* Write GOT[1] and GOT[2], needed for the dynamic linker.  */
6455       bfd_put_64 (output_bfd, (bfd_vma) 0,
6456                   htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
6457       bfd_put_64 (output_bfd, (bfd_vma) 0,
6458                   htab->elf.sgotplt->contents + GOT_ENTRY_SIZE*2);
6459
6460       elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize
6461         = GOT_ENTRY_SIZE;
6462     }
6463
6464   /* Adjust .eh_frame for .plt section.  */
6465   if (htab->plt_eh_frame != NULL
6466       && htab->plt_eh_frame->contents != NULL)
6467     {
6468       if (htab->elf.splt != NULL
6469           && htab->elf.splt->size != 0
6470           && (htab->elf.splt->flags & SEC_EXCLUDE) == 0
6471           && htab->elf.splt->output_section != NULL
6472           && htab->plt_eh_frame->output_section != NULL)
6473         {
6474           bfd_vma plt_start = htab->elf.splt->output_section->vma;
6475           bfd_vma eh_frame_start = htab->plt_eh_frame->output_section->vma
6476                                    + htab->plt_eh_frame->output_offset
6477                                    + PLT_FDE_START_OFFSET;
6478           bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
6479                              htab->plt_eh_frame->contents
6480                              + PLT_FDE_START_OFFSET);
6481         }
6482       if (htab->plt_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
6483         {
6484           if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
6485                                                  htab->plt_eh_frame,
6486                                                  htab->plt_eh_frame->contents))
6487             return FALSE;
6488         }
6489     }
6490
6491   /* Adjust .eh_frame for .plt.got section.  */
6492   if (htab->plt_got_eh_frame != NULL
6493       && htab->plt_got_eh_frame->contents != NULL)
6494     {
6495       if (htab->plt_got != NULL
6496           && htab->plt_got->size != 0
6497           && (htab->plt_got->flags & SEC_EXCLUDE) == 0
6498           && htab->plt_got->output_section != NULL
6499           && htab->plt_got_eh_frame->output_section != NULL)
6500         {
6501           bfd_vma plt_start = htab->plt_got->output_section->vma;
6502           bfd_vma eh_frame_start = htab->plt_got_eh_frame->output_section->vma
6503                                    + htab->plt_got_eh_frame->output_offset
6504                                    + PLT_FDE_START_OFFSET;
6505           bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
6506                              htab->plt_got_eh_frame->contents
6507                              + PLT_FDE_START_OFFSET);
6508         }
6509       if (htab->plt_got_eh_frame->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
6510         {
6511           if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
6512                                                  htab->plt_got_eh_frame,
6513                                                  htab->plt_got_eh_frame->contents))
6514             return FALSE;
6515         }
6516     }
6517
6518   /* Adjust .eh_frame for the second PLT section.  */
6519   if (htab->plt_second_eh_frame != NULL
6520       && htab->plt_second_eh_frame->contents != NULL)
6521     {
6522       if (htab->plt_second != NULL
6523           && htab->plt_second->size != 0
6524           && (htab->plt_second->flags & SEC_EXCLUDE) == 0
6525           && htab->plt_second->output_section != NULL
6526           && htab->plt_second_eh_frame->output_section != NULL)
6527         {
6528           bfd_vma plt_start = htab->plt_second->output_section->vma;
6529           bfd_vma eh_frame_start
6530             = (htab->plt_second_eh_frame->output_section->vma
6531                + htab->plt_second_eh_frame->output_offset
6532                + PLT_FDE_START_OFFSET);
6533           bfd_put_signed_32 (dynobj, plt_start - eh_frame_start,
6534                              htab->plt_second_eh_frame->contents
6535                              + PLT_FDE_START_OFFSET);
6536         }
6537       if (htab->plt_second_eh_frame->sec_info_type
6538           == SEC_INFO_TYPE_EH_FRAME)
6539         {
6540           if (! _bfd_elf_write_section_eh_frame (output_bfd, info,
6541                                                  htab->plt_second_eh_frame,
6542                                                  htab->plt_second_eh_frame->contents))
6543             return FALSE;
6544         }
6545     }
6546
6547   if (htab->elf.sgot && htab->elf.sgot->size > 0)
6548     elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize
6549       = GOT_ENTRY_SIZE;
6550
6551   /* Fill PLT entries for undefined weak symbols in PIE.  */
6552   if (bfd_link_pie (info))
6553     bfd_hash_traverse (&info->hash->table,
6554                        elf_x86_64_pie_finish_undefweak_symbol,
6555                        info);
6556
6557   return TRUE;
6558 }
6559
6560 /* Fill PLT/GOT entries and allocate dynamic relocations for local
6561    STT_GNU_IFUNC symbols, which aren't in the ELF linker hash table.
6562    It has to be done before elf_link_sort_relocs is called so that
6563    dynamic relocations are properly sorted.  */
6564
6565 static bfd_boolean
6566 elf_x86_64_output_arch_local_syms
6567   (bfd *output_bfd ATTRIBUTE_UNUSED,
6568    struct bfd_link_info *info,
6569    void *flaginfo ATTRIBUTE_UNUSED,
6570    int (*func) (void *, const char *,
6571                 Elf_Internal_Sym *,
6572                 asection *,
6573                 struct elf_link_hash_entry *) ATTRIBUTE_UNUSED)
6574 {
6575   struct elf_x86_64_link_hash_table *htab = elf_x86_64_hash_table (info);
6576   if (htab == NULL)
6577     return FALSE;
6578
6579   /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols.  */
6580   htab_traverse (htab->loc_hash_table,
6581                  elf_x86_64_finish_local_dynamic_symbol,
6582                  info);
6583
6584   return TRUE;
6585 }
6586
6587 /* Sort relocs into address order.  */
6588
6589 static int
6590 compare_relocs (const void *ap, const void *bp)
6591 {
6592   const arelent *a = * (const arelent **) ap;
6593   const arelent *b = * (const arelent **) bp;
6594
6595   if (a->address > b->address)
6596     return 1;
6597   else if (a->address < b->address)
6598     return -1;
6599   else
6600     return 0;
6601 }
6602
6603 enum elf_x86_64_plt_type
6604 {
6605   plt_non_lazy = 0,
6606   plt_lazy = 1 << 0,
6607   plt_second = 1 << 1,
6608   plt_unknown = -1
6609 };
6610
6611 struct elf_x86_64_plt
6612 {
6613   const char *name;
6614   asection *sec;
6615   bfd_byte *contents;
6616   enum elf_x86_64_plt_type type;
6617   unsigned int plt_got_offset;
6618   unsigned int plt_got_insn_size;
6619   unsigned int plt_entry_size;
6620   long count;
6621 };
6622
6623 /* Forward declaration.  */
6624 static const struct elf_x86_64_lazy_plt_layout elf_x86_64_nacl_plt;
6625
6626 /* Similar to _bfd_elf_get_synthetic_symtab.  Support PLTs with all
6627    dynamic relocations.   */
6628
6629 static long
6630 elf_x86_64_get_synthetic_symtab (bfd *abfd,
6631                                  long symcount ATTRIBUTE_UNUSED,
6632                                  asymbol **syms ATTRIBUTE_UNUSED,
6633                                  long dynsymcount,
6634                                  asymbol **dynsyms,
6635                                  asymbol **ret)
6636 {
6637   long size, count, i, n, len;
6638   int j;
6639   unsigned int plt_got_offset, plt_entry_size, plt_got_insn_size;
6640   asymbol *s;
6641   bfd_byte *plt_contents;
6642   long dynrelcount, relsize;
6643   arelent **dynrelbuf, *p;
6644   const struct elf_x86_64_lazy_plt_layout *lazy_plt;
6645   const struct elf_x86_64_non_lazy_plt_layout *non_lazy_plt;
6646   const struct elf_x86_64_lazy_plt_layout *lazy_bnd_plt;
6647   const struct elf_x86_64_non_lazy_plt_layout *non_lazy_bnd_plt;
6648   const struct elf_x86_64_lazy_plt_layout *lazy_ibt_plt;
6649   const struct elf_x86_64_non_lazy_plt_layout *non_lazy_ibt_plt;
6650   asection *plt;
6651   char *names;
6652   enum elf_x86_64_plt_type plt_type;
6653   struct elf_x86_64_plt plts[] =
6654     {
6655       { ".plt", NULL, NULL, plt_unknown, 0, 0, 0, 0 },
6656       { ".plt.got", NULL, NULL, plt_non_lazy, 0, 0, 0, 0 },
6657       { ".plt.sec", NULL, NULL, plt_second, 0, 0, 0, 0 },
6658       { ".plt.bnd", NULL, NULL, plt_second, 0, 0, 0, 0 },
6659       { NULL, NULL, NULL, plt_non_lazy, 0, 0, 0, 0 }
6660     };
6661
6662   *ret = NULL;
6663
6664   if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
6665     return 0;
6666
6667   if (dynsymcount <= 0)
6668     return 0;
6669
6670   relsize = bfd_get_dynamic_reloc_upper_bound (abfd);
6671   if (relsize <= 0)
6672     return -1;
6673
6674   dynrelbuf = (arelent **) bfd_malloc (relsize);
6675   if (dynrelbuf == NULL)
6676     return -1;
6677
6678   dynrelcount = bfd_canonicalize_dynamic_reloc (abfd, dynrelbuf,
6679                                                 dynsyms);
6680
6681   /* Sort the relocs by address.  */
6682   qsort (dynrelbuf, dynrelcount, sizeof (arelent *), compare_relocs);
6683
6684   if (get_elf_x86_64_backend_data (abfd)->os == is_normal)
6685     {
6686       lazy_plt = &elf_x86_64_lazy_plt;
6687       non_lazy_plt = &elf_x86_64_non_lazy_plt;
6688       lazy_bnd_plt = &elf_x86_64_lazy_bnd_plt;
6689       non_lazy_bnd_plt = &elf_x86_64_non_lazy_bnd_plt;
6690       if (ABI_64_P (abfd))
6691         {
6692           lazy_ibt_plt = &elf_x86_64_lazy_ibt_plt;
6693           non_lazy_ibt_plt = &elf_x86_64_non_lazy_ibt_plt;
6694         }
6695       else
6696         {
6697           lazy_ibt_plt = &elf_x32_lazy_ibt_plt;
6698           non_lazy_ibt_plt = &elf_x32_non_lazy_ibt_plt;
6699         }
6700     }
6701   else
6702     {
6703       lazy_plt = &elf_x86_64_nacl_plt;
6704       non_lazy_plt = NULL;
6705       lazy_bnd_plt = NULL;
6706       non_lazy_bnd_plt = NULL;
6707       lazy_ibt_plt = NULL;
6708       non_lazy_ibt_plt = NULL;
6709     }
6710
6711   count = 0;
6712   for (j = 0; plts[j].name != NULL; j++)
6713     {
6714       plt = bfd_get_section_by_name (abfd, plts[j].name);
6715       if (plt == NULL)
6716         continue;
6717
6718       /* Get the PLT section contents.  */
6719       plt_contents = (bfd_byte *) bfd_malloc (plt->size);
6720       if (plt_contents == NULL)
6721         break;
6722       if (!bfd_get_section_contents (abfd, (asection *) plt,
6723                                      plt_contents, 0, plt->size))
6724         {
6725           free (plt_contents);
6726           break;
6727         }
6728
6729       /* Check what kind of PLT it is.  */
6730       plt_type = plt_unknown;
6731       if (plts[j].type == plt_unknown)
6732         {
6733           /* Match lazy PLT first.  Need to check the first two
6734              instructions.   */
6735           if ((memcmp (plt_contents, lazy_plt->plt0_entry,
6736                        lazy_plt->plt0_got1_offset) == 0)
6737               && (memcmp (plt_contents + 6, lazy_plt->plt0_entry + 6,
6738                           2) == 0))
6739             plt_type = plt_lazy;
6740           else if (lazy_bnd_plt != NULL
6741                    && (memcmp (plt_contents, lazy_bnd_plt->plt0_entry,
6742                                lazy_bnd_plt->plt0_got1_offset) == 0)
6743                    && (memcmp (plt_contents + 6,
6744                                lazy_bnd_plt->plt0_entry + 6, 3) == 0))
6745             {
6746               plt_type = plt_lazy | plt_second;
6747               /* The fist entry in the lazy IBT PLT is the same as the
6748                  lazy BND PLT.  */
6749               if ((memcmp (plt_contents + lazy_ibt_plt->plt_entry_size,
6750                            lazy_ibt_plt->plt_entry,
6751                            lazy_ibt_plt->plt_got_offset) == 0))
6752                 lazy_plt = lazy_ibt_plt;
6753               else
6754                 lazy_plt = lazy_bnd_plt;
6755             }
6756         }
6757
6758       if (non_lazy_plt != NULL
6759           && (plt_type == plt_unknown || plt_type == plt_non_lazy))
6760         {
6761           /* Match non-lazy PLT.  */
6762           if (memcmp (plt_contents, non_lazy_plt->plt_entry,
6763                       non_lazy_plt->plt_got_offset) == 0)
6764             plt_type = plt_non_lazy;
6765         }
6766
6767       if (plt_type == plt_unknown || plt_type == plt_second)
6768         {
6769           if (non_lazy_bnd_plt != NULL
6770               && (memcmp (plt_contents, non_lazy_bnd_plt->plt_entry,
6771                           non_lazy_bnd_plt->plt_got_offset) == 0))
6772             {
6773               /* Match BND PLT.  */
6774               plt_type = plt_second;
6775               non_lazy_plt = non_lazy_bnd_plt;
6776             }
6777           else if (non_lazy_ibt_plt != NULL
6778                    && (memcmp (plt_contents,
6779                                non_lazy_ibt_plt->plt_entry,
6780                                non_lazy_ibt_plt->plt_got_offset) == 0))
6781             {
6782               /* Match IBT PLT.  */
6783               plt_type = plt_second;
6784               non_lazy_plt = non_lazy_ibt_plt;
6785             }
6786         }
6787
6788       if (plt_type == plt_unknown)
6789         continue;
6790
6791       plts[j].sec = plt;
6792       plts[j].type = plt_type;
6793
6794       if ((plt_type & plt_lazy))
6795         {
6796           plts[j].plt_got_offset = lazy_plt->plt_got_offset;
6797           plts[j].plt_got_insn_size = lazy_plt->plt_got_insn_size;
6798           plts[j].plt_entry_size = lazy_plt->plt_entry_size;
6799           /* Skip PLT0 in lazy PLT.  */
6800           i = 1;
6801         }
6802       else
6803         {
6804           plts[j].plt_got_offset = non_lazy_plt->plt_got_offset;
6805           plts[j].plt_got_insn_size = non_lazy_plt->plt_got_insn_size;
6806           plts[j].plt_entry_size = non_lazy_plt->plt_entry_size;
6807           i = 0;
6808         }
6809
6810       /* Skip lazy PLT when the second PLT is used.  */
6811       if (plt_type == (plt_lazy | plt_second))
6812         plts[j].count = 0;
6813       else
6814         {
6815           n = plt->size / plts[j].plt_entry_size;
6816           plts[j].count = n;
6817           count += n - i;
6818         }
6819
6820       plts[j].contents = plt_contents;
6821     }
6822
6823   size = count * sizeof (asymbol);
6824
6825   /* Allocate space for @plt suffixes.  */
6826   n = 0;
6827   for (i = 0; i < dynrelcount; i++)
6828     {
6829       p = dynrelbuf[i];
6830       size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
6831       if (p->addend != 0)
6832         size += sizeof ("+0x") - 1 + 8 + 8 * ABI_64_P (abfd);
6833     }
6834
6835   s = *ret = (asymbol *) bfd_zmalloc (size);
6836   if (s == NULL)
6837     {
6838 bad_return:
6839       for (j = 0; plts[j].name != NULL; j++)
6840         if (plts[j].contents != NULL)
6841           free (plts[j].contents);
6842       free (dynrelbuf);
6843       return -1;
6844     }
6845
6846   /* Check for each PLT section.  */
6847   names = (char *) (s + count);
6848   size = 0;
6849   n = 0;
6850   for (j = 0; plts[j].name != NULL; j++)
6851     if ((plt_contents = plts[j].contents) != NULL)
6852       {
6853         long k;
6854         bfd_vma offset;
6855
6856         plt_got_offset = plts[j].plt_got_offset;
6857         plt_got_insn_size = plts[j].plt_got_insn_size;
6858         plt_entry_size = plts[j].plt_entry_size;
6859
6860         plt = plts[j].sec;
6861
6862         if ((plts[j].type & plt_lazy))
6863           {
6864             /* Skip PLT0 in lazy PLT.  */
6865             k = 1;
6866             offset = plt_entry_size;
6867           }
6868         else
6869           {
6870             k = 0;
6871             offset = 0;
6872           }
6873
6874         /* Check each PLT entry against dynamic relocations.  */
6875         for (; k < plts[j].count; k++)
6876           {
6877             int off;
6878             bfd_vma got_vma;
6879             long min, max, mid;
6880
6881             /* Get the PC-relative offset, a signed 32-bit integer.  */
6882             off = H_GET_32 (abfd, (plt_contents + offset
6883                                    + plt_got_offset));
6884             got_vma = plt->vma + offset + off + plt_got_insn_size;
6885
6886             /* Binary search.  */
6887             p = dynrelbuf[0];
6888             min = 0;
6889             max = dynrelcount;
6890             while ((min + 1) < max)
6891               {
6892                 arelent *r;
6893
6894                 mid = (min + max) / 2;
6895                 r = dynrelbuf[mid];
6896                 if (got_vma > r->address)
6897                   min = mid;
6898                 else if (got_vma < r->address)
6899                   max = mid;
6900                 else
6901                   {
6902                     p = r;
6903                     break;
6904                   }
6905               }
6906
6907             /* Skip unknown relocation.  PR 17512: file: bc9d6cf5.  */
6908             if (got_vma == p->address
6909                 && p->howto != NULL
6910                 && (p->howto->type == R_X86_64_JUMP_SLOT
6911                     || p->howto->type == R_X86_64_GLOB_DAT
6912                     || p->howto->type == R_X86_64_IRELATIVE))
6913               {
6914                 *s = **p->sym_ptr_ptr;
6915                 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL
6916                    set.  Since we are defining a symbol, ensure one
6917                    of them is set.  */
6918                 if ((s->flags & BSF_LOCAL) == 0)
6919                   s->flags |= BSF_GLOBAL;
6920                 s->flags |= BSF_SYNTHETIC;
6921                 /* This is no longer a section symbol.  */
6922                 s->flags &= ~BSF_SECTION_SYM;
6923                 s->section = plt;
6924                 s->the_bfd = plt->owner;
6925                 s->value = offset;
6926                 s->udata.p = NULL;
6927                 s->name = names;
6928                 len = strlen ((*p->sym_ptr_ptr)->name);
6929                 memcpy (names, (*p->sym_ptr_ptr)->name, len);
6930                 names += len;
6931                 if (p->addend != 0)
6932                   {
6933                     char buf[30], *a;
6934
6935                     memcpy (names, "+0x", sizeof ("+0x") - 1);
6936                     names += sizeof ("+0x") - 1;
6937                     bfd_sprintf_vma (abfd, buf, p->addend);
6938                     for (a = buf; *a == '0'; ++a)
6939                       ;
6940                     size = strlen (a);
6941                     memcpy (names, a, size);
6942                     names += size;
6943                   }
6944                 memcpy (names, "@plt", sizeof ("@plt"));
6945                 names += sizeof ("@plt");
6946                 n++;
6947                 s++;
6948               }
6949             offset += plt_entry_size;
6950           }
6951       }
6952
6953   /* PLT entries with R_X86_64_TLSDESC relocations are skipped.  */
6954   if (n == 0)
6955     goto bad_return;
6956
6957   count = n;
6958
6959   for (j = 0; plts[j].name != NULL; j++)
6960     if (plts[j].contents != NULL)
6961       free (plts[j].contents);
6962
6963   free (dynrelbuf);
6964
6965   return count;
6966 }
6967
6968 /* Handle an x86-64 specific section when reading an object file.  This
6969    is called when elfcode.h finds a section with an unknown type.  */
6970
6971 static bfd_boolean
6972 elf_x86_64_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr,
6973                               const char *name, int shindex)
6974 {
6975   if (hdr->sh_type != SHT_X86_64_UNWIND)
6976     return FALSE;
6977
6978   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
6979     return FALSE;
6980
6981   return TRUE;
6982 }
6983
6984 /* Hook called by the linker routine which adds symbols from an object
6985    file.  We use it to put SHN_X86_64_LCOMMON items in .lbss, instead
6986    of .bss.  */
6987
6988 static bfd_boolean
6989 elf_x86_64_add_symbol_hook (bfd *abfd,
6990                             struct bfd_link_info *info ATTRIBUTE_UNUSED,
6991                             Elf_Internal_Sym *sym,
6992                             const char **namep ATTRIBUTE_UNUSED,
6993                             flagword *flagsp ATTRIBUTE_UNUSED,
6994                             asection **secp,
6995                             bfd_vma *valp)
6996 {
6997   asection *lcomm;
6998
6999   switch (sym->st_shndx)
7000     {
7001     case SHN_X86_64_LCOMMON:
7002       lcomm = bfd_get_section_by_name (abfd, "LARGE_COMMON");
7003       if (lcomm == NULL)
7004         {
7005           lcomm = bfd_make_section_with_flags (abfd,
7006                                                "LARGE_COMMON",
7007                                                (SEC_ALLOC
7008                                                 | SEC_IS_COMMON
7009                                                 | SEC_LINKER_CREATED));
7010           if (lcomm == NULL)
7011             return FALSE;
7012           elf_section_flags (lcomm) |= SHF_X86_64_LARGE;
7013         }
7014       *secp = lcomm;
7015       *valp = sym->st_size;
7016       return TRUE;
7017     }
7018
7019   return TRUE;
7020 }
7021
7022
7023 /* Given a BFD section, try to locate the corresponding ELF section
7024    index.  */
7025
7026 static bfd_boolean
7027 elf_x86_64_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
7028                                          asection *sec, int *index_return)
7029 {
7030   if (sec == &_bfd_elf_large_com_section)
7031     {
7032       *index_return = SHN_X86_64_LCOMMON;
7033       return TRUE;
7034     }
7035   return FALSE;
7036 }
7037
7038 /* Process a symbol.  */
7039
7040 static void
7041 elf_x86_64_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
7042                               asymbol *asym)
7043 {
7044   elf_symbol_type *elfsym = (elf_symbol_type *) asym;
7045
7046   switch (elfsym->internal_elf_sym.st_shndx)
7047     {
7048     case SHN_X86_64_LCOMMON:
7049       asym->section = &_bfd_elf_large_com_section;
7050       asym->value = elfsym->internal_elf_sym.st_size;
7051       /* Common symbol doesn't set BSF_GLOBAL.  */
7052       asym->flags &= ~BSF_GLOBAL;
7053       break;
7054     }
7055 }
7056
7057 static bfd_boolean
7058 elf_x86_64_common_definition (Elf_Internal_Sym *sym)
7059 {
7060   return (sym->st_shndx == SHN_COMMON
7061           || sym->st_shndx == SHN_X86_64_LCOMMON);
7062 }
7063
7064 static unsigned int
7065 elf_x86_64_common_section_index (asection *sec)
7066 {
7067   if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
7068     return SHN_COMMON;
7069   else
7070     return SHN_X86_64_LCOMMON;
7071 }
7072
7073 static asection *
7074 elf_x86_64_common_section (asection *sec)
7075 {
7076   if ((elf_section_flags (sec) & SHF_X86_64_LARGE) == 0)
7077     return bfd_com_section_ptr;
7078   else
7079     return &_bfd_elf_large_com_section;
7080 }
7081
7082 static bfd_boolean
7083 elf_x86_64_merge_symbol (struct elf_link_hash_entry *h,
7084                          const Elf_Internal_Sym *sym,
7085                          asection **psec,
7086                          bfd_boolean newdef,
7087                          bfd_boolean olddef,
7088                          bfd *oldbfd,
7089                          const asection *oldsec)
7090 {
7091   /* A normal common symbol and a large common symbol result in a
7092      normal common symbol.  We turn the large common symbol into a
7093      normal one.  */
7094   if (!olddef
7095       && h->root.type == bfd_link_hash_common
7096       && !newdef
7097       && bfd_is_com_section (*psec)
7098       && oldsec != *psec)
7099     {
7100       if (sym->st_shndx == SHN_COMMON
7101           && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) != 0)
7102         {
7103           h->root.u.c.p->section
7104             = bfd_make_section_old_way (oldbfd, "COMMON");
7105           h->root.u.c.p->section->flags = SEC_ALLOC;
7106         }
7107       else if (sym->st_shndx == SHN_X86_64_LCOMMON
7108                && (elf_section_flags (oldsec) & SHF_X86_64_LARGE) == 0)
7109         *psec = bfd_com_section_ptr;
7110     }
7111
7112   return TRUE;
7113 }
7114
7115 static int
7116 elf_x86_64_additional_program_headers (bfd *abfd,
7117                                        struct bfd_link_info *info ATTRIBUTE_UNUSED)
7118 {
7119   asection *s;
7120   int count = 0;
7121
7122   /* Check to see if we need a large readonly segment.  */
7123   s = bfd_get_section_by_name (abfd, ".lrodata");
7124   if (s && (s->flags & SEC_LOAD))
7125     count++;
7126
7127   /* Check to see if we need a large data segment.  Since .lbss sections
7128      is placed right after the .bss section, there should be no need for
7129      a large data segment just because of .lbss.  */
7130   s = bfd_get_section_by_name (abfd, ".ldata");
7131   if (s && (s->flags & SEC_LOAD))
7132     count++;
7133
7134   return count;
7135 }
7136
7137 /* Return TRUE if symbol should be hashed in the `.gnu.hash' section.  */
7138
7139 static bfd_boolean
7140 elf_x86_64_hash_symbol (struct elf_link_hash_entry *h)
7141 {
7142   if (h->plt.offset != (bfd_vma) -1
7143       && !h->def_regular
7144       && !h->pointer_equality_needed)
7145     return FALSE;
7146
7147   return _bfd_elf_hash_symbol (h);
7148 }
7149
7150 /* Return TRUE iff relocations for INPUT are compatible with OUTPUT. */
7151
7152 static bfd_boolean
7153 elf_x86_64_relocs_compatible (const bfd_target *input,
7154                               const bfd_target *output)
7155 {
7156   return ((xvec_get_elf_backend_data (input)->s->elfclass
7157            == xvec_get_elf_backend_data (output)->s->elfclass)
7158           && _bfd_elf_relocs_compatible (input, output));
7159 }
7160
7161 /* Parse x86-64 GNU properties.  */
7162
7163 static enum elf_property_kind
7164 elf_x86_64_parse_gnu_properties (bfd *abfd, unsigned int type,
7165                                  bfd_byte *ptr, unsigned int datasz)
7166 {
7167   elf_property *prop;
7168
7169   switch (type)
7170     {
7171     case GNU_PROPERTY_X86_ISA_1_USED:
7172     case GNU_PROPERTY_X86_ISA_1_NEEDED:
7173     case GNU_PROPERTY_X86_FEATURE_1_AND:
7174       if (datasz != 4)
7175         {
7176           _bfd_error_handler
7177             ((type == GNU_PROPERTY_X86_ISA_1_USED
7178               ? _("error: %B: <corrupt x86 ISA used size: 0x%x>")
7179               : (type == GNU_PROPERTY_X86_ISA_1_NEEDED
7180                  ? _("error: %B: <corrupt x86 ISA needed size: 0x%x>")
7181                  : _("error: %B: <corrupt x86 feature size: 0x%x>"))),
7182              abfd, datasz);
7183           return property_corrupt;
7184         }
7185       prop = _bfd_elf_get_property (abfd, type, datasz);
7186       /* Combine properties of the same type.  */
7187       prop->u.number |= bfd_h_get_32 (abfd, ptr);
7188       prop->pr_kind = property_number;
7189       break;
7190
7191     default:
7192       return property_ignored;
7193     }
7194
7195   return property_number;
7196 }
7197
7198 /* Merge x86-64 GNU property BPROP with APROP.  If APROP isn't NULL,
7199    return TRUE if APROP is updated.  Otherwise, return TRUE if BPROP
7200    should be merged with ABFD.  */
7201
7202 static bfd_boolean
7203 elf_x86_64_merge_gnu_properties (struct bfd_link_info *info,
7204                                  bfd *abfd ATTRIBUTE_UNUSED,
7205                                  elf_property *aprop,
7206                                  elf_property *bprop)
7207 {
7208   unsigned int number, features;
7209   bfd_boolean updated = FALSE;
7210   unsigned int pr_type = aprop != NULL ? aprop->pr_type : bprop->pr_type;
7211
7212   switch (pr_type)
7213     {
7214     case GNU_PROPERTY_X86_ISA_1_USED:
7215     case GNU_PROPERTY_X86_ISA_1_NEEDED:
7216       if (aprop != NULL && bprop != NULL)
7217         {
7218           number = aprop->u.number;
7219           aprop->u.number = number | bprop->u.number;
7220           updated = number != (unsigned int) aprop->u.number;
7221         }
7222       else
7223         {
7224           /* Return TRUE if APROP is NULL to indicate that BPROP should
7225              be added to ABFD.  */
7226           updated = aprop == NULL;
7227         }
7228       break;
7229
7230     case GNU_PROPERTY_X86_FEATURE_1_AND:
7231       /* Only one of APROP and BPROP can be NULL:
7232          1. APROP & BPROP when both APROP and BPROP aren't NULL.
7233          2. If APROP is NULL, remove x86 feature.
7234          3. Otherwise, do nothing.
7235        */
7236       if (aprop != NULL && bprop != NULL)
7237         {
7238           features = 0;
7239           if (info->ibt)
7240             features = GNU_PROPERTY_X86_FEATURE_1_IBT;
7241           if (info->shstk)
7242             features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
7243           number = aprop->u.number;
7244           /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
7245              GNU_PROPERTY_X86_FEATURE_1_SHSTK.  */
7246           aprop->u.number = (number & bprop->u.number) | features;
7247           updated = number != (unsigned int) aprop->u.number;
7248           /* Remove the property if all feature bits are cleared.  */
7249           if (aprop->u.number == 0)
7250             aprop->pr_kind = property_remove;
7251         }
7252       else
7253         {
7254           features = 0;
7255           if (info->ibt)
7256             features = GNU_PROPERTY_X86_FEATURE_1_IBT;
7257           if (info->shstk)
7258             features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
7259           if (features)
7260             {
7261               /* Add GNU_PROPERTY_X86_FEATURE_1_IBT and
7262                  GNU_PROPERTY_X86_FEATURE_1_SHSTK.  */
7263               if (aprop != NULL)
7264                 {
7265                   number = aprop->u.number;
7266                   aprop->u.number = number | features;
7267                   updated = number != (unsigned int) aprop->u.number;
7268                 }
7269               else
7270                 {
7271                   bprop->u.number |= features;
7272                   updated = TRUE;
7273                 }
7274             }
7275           else if (aprop != NULL)
7276             {
7277               aprop->pr_kind = property_remove;
7278               updated = TRUE;
7279             }
7280         }
7281       break;
7282
7283     default:
7284       /* Never should happen.  */
7285       abort ();
7286     }
7287
7288   return updated;
7289 }
7290
7291 /* Set up x86-64 GNU properties.  Return the first relocatable ELF input
7292    with GNU properties if found.  Otherwise, return NULL.  */
7293
7294 static bfd *
7295 elf_x86_64_link_setup_gnu_properties (struct bfd_link_info *info)
7296 {
7297   bfd_boolean normal_target;
7298   bfd_boolean lazy_plt;
7299   asection *sec, *pltsec;
7300   bfd *dynobj;
7301   bfd_boolean use_ibt_plt;
7302   unsigned int plt_alignment, features;
7303   struct elf_x86_64_link_hash_table *htab;
7304   bfd *pbfd;
7305   bfd *ebfd = NULL;
7306   elf_property *prop;
7307
7308   features = 0;
7309   if (info->ibt)
7310     features = GNU_PROPERTY_X86_FEATURE_1_IBT;
7311   if (info->shstk)
7312     features |= GNU_PROPERTY_X86_FEATURE_1_SHSTK;
7313
7314   /* Find a normal input file with GNU property note.  */
7315   for (pbfd = info->input_bfds;
7316        pbfd != NULL;
7317        pbfd = pbfd->link.next)
7318     if (bfd_get_flavour (pbfd) == bfd_target_elf_flavour
7319         && bfd_count_sections (pbfd) != 0)
7320       {
7321         ebfd = pbfd;
7322
7323         if (elf_properties (pbfd) != NULL)
7324           break;
7325       }
7326
7327   if (ebfd != NULL)
7328     {
7329       if (features)
7330         {
7331           /* If features is set, add GNU_PROPERTY_X86_FEATURE_1_IBT and
7332              GNU_PROPERTY_X86_FEATURE_1_SHSTK.  */
7333           prop = _bfd_elf_get_property (ebfd,
7334                                         GNU_PROPERTY_X86_FEATURE_1_AND,
7335                                         4);
7336           prop->u.number |= features;
7337           prop->pr_kind = property_number;
7338
7339           /* Create the GNU property note section if needed.  */
7340           if (pbfd == NULL)
7341             {
7342               sec = bfd_make_section_with_flags (ebfd,
7343                                                  NOTE_GNU_PROPERTY_SECTION_NAME,
7344                                                  (SEC_ALLOC
7345                                                   | SEC_LOAD
7346                                                   | SEC_IN_MEMORY
7347                                                   | SEC_READONLY
7348                                                   | SEC_HAS_CONTENTS
7349                                                   | SEC_DATA));
7350               if (sec == NULL)
7351                 info->callbacks->einfo (_("%F: failed to create GNU property section\n"));
7352
7353               if (!bfd_set_section_alignment (ebfd, sec,
7354                                               ABI_64_P (ebfd) ? 3 : 2))
7355                 {
7356 error_alignment:
7357                   info->callbacks->einfo (_("%F%A: failed to align section\n"),
7358                                           sec);
7359                 }
7360
7361               elf_section_type (sec) = SHT_NOTE;
7362             }
7363         }
7364
7365       /* Check GNU_PROPERTY_NO_COPY_ON_PROTECTED.  */
7366       for (; pbfd != NULL; pbfd = pbfd->link.next)
7367         if (bfd_get_flavour (pbfd) == bfd_target_elf_flavour
7368             && (pbfd->flags
7369                 & (DYNAMIC | BFD_LINKER_CREATED | BFD_PLUGIN)) == 0)
7370           {
7371             elf_property_list *p;
7372
7373             /* The property list is sorted in order of type.  */
7374             for (p = elf_properties (pbfd); p != NULL; p = p->next)
7375               {
7376                 if (GNU_PROPERTY_NO_COPY_ON_PROTECTED
7377                     == p->property.pr_type)
7378                   {
7379                     /* Clear extern_protected_data if
7380                        GNU_PROPERTY_NO_COPY_ON_PROTECTED is
7381                        set on any input relocatable file.  */
7382                     info->extern_protected_data = FALSE;
7383                     break;
7384                   }
7385                 else if (GNU_PROPERTY_NO_COPY_ON_PROTECTED
7386                          < p->property.pr_type)
7387                   break;
7388               }
7389           }
7390     }
7391
7392   pbfd = _bfd_elf_link_setup_gnu_properties (info);
7393
7394   if (bfd_link_relocatable (info))
7395     return pbfd;
7396
7397   htab = elf_x86_64_hash_table (info);
7398   if (htab == NULL)
7399     return pbfd;
7400
7401   use_ibt_plt = info->ibtplt || info->ibt;
7402   if (!use_ibt_plt && pbfd != NULL)
7403     {
7404       /* Check if GNU_PROPERTY_X86_FEATURE_1_IBT is on.  */
7405       elf_property_list *p;
7406
7407       /* The property list is sorted in order of type.  */
7408       for (p = elf_properties (pbfd); p; p = p->next)
7409         {
7410           if (GNU_PROPERTY_X86_FEATURE_1_AND == p->property.pr_type)
7411             {
7412               use_ibt_plt = !!(p->property.u.number
7413                                & GNU_PROPERTY_X86_FEATURE_1_IBT);
7414               break;
7415             }
7416           else if (GNU_PROPERTY_X86_FEATURE_1_AND < p->property.pr_type)
7417             break;
7418         }
7419     }
7420
7421   dynobj = htab->elf.dynobj;
7422
7423   /* Set htab->elf.dynobj here so that there is no need to check and
7424      set it in check_relocs.  */
7425   if (dynobj == NULL)
7426     {
7427       if (pbfd != NULL)
7428         {
7429           htab->elf.dynobj = pbfd;
7430           dynobj = pbfd;
7431         }
7432       else
7433         {
7434           bfd *abfd;
7435
7436           /* Find a normal input file to hold linker created
7437              sections.  */
7438           for (abfd = info->input_bfds;
7439                abfd != NULL;
7440                abfd = abfd->link.next)
7441             if (bfd_get_flavour (abfd) == bfd_target_elf_flavour
7442                 && (abfd->flags
7443                     & (DYNAMIC | BFD_LINKER_CREATED | BFD_PLUGIN)) == 0)
7444               {
7445                 htab->elf.dynobj = abfd;
7446                 dynobj = abfd;
7447                 break;
7448               }
7449         }
7450     }
7451
7452   /* Even when lazy binding is disabled by "-z now", the PLT0 entry may
7453      still be used with LD_AUDIT or LD_PROFILE if PLT entry is used for
7454      canonical function address.  */
7455   htab->plt.has_plt0 = 1;
7456
7457   if (get_elf_x86_64_backend_data (info->output_bfd)->os
7458       == is_normal)
7459     {
7460       if (use_ibt_plt)
7461         {
7462           if (ABI_64_P (dynobj))
7463             {
7464               htab->lazy_plt = &elf_x86_64_lazy_ibt_plt;
7465               htab->non_lazy_plt = &elf_x86_64_non_lazy_ibt_plt;
7466             }
7467           else
7468             {
7469               htab->lazy_plt = &elf_x32_lazy_ibt_plt;
7470               htab->non_lazy_plt = &elf_x32_non_lazy_ibt_plt;
7471             }
7472         }
7473       else if (info->bndplt)
7474         {
7475           htab->lazy_plt = &elf_x86_64_lazy_bnd_plt;
7476           htab->non_lazy_plt = &elf_x86_64_non_lazy_bnd_plt;
7477         }
7478       else
7479         {
7480           htab->lazy_plt = &elf_x86_64_lazy_plt;
7481           htab->non_lazy_plt = &elf_x86_64_non_lazy_plt;
7482         }
7483       normal_target = TRUE;
7484     }
7485   else
7486     {
7487       htab->lazy_plt = &elf_x86_64_nacl_plt;
7488       htab->non_lazy_plt = NULL;
7489       normal_target = FALSE;
7490     }
7491
7492   pltsec = htab->elf.splt;
7493
7494   /* If the non-lazy PLT is available, use it for all PLT entries if
7495      there are no PLT0 or no .plt section.  */
7496   if (htab->non_lazy_plt != NULL
7497       && (!htab->plt.has_plt0 || pltsec == NULL))
7498     {
7499       lazy_plt = FALSE;
7500       htab->plt.plt_entry
7501         = htab->non_lazy_plt->plt_entry;
7502       htab->plt.plt_entry_size
7503         = htab->non_lazy_plt->plt_entry_size;
7504       htab->plt.plt_got_offset
7505         = htab->non_lazy_plt->plt_got_offset;
7506       htab->plt.plt_got_insn_size
7507         = htab->non_lazy_plt->plt_got_insn_size;
7508       htab->plt.eh_frame_plt_size
7509         = htab->non_lazy_plt->eh_frame_plt_size;
7510       htab->plt.eh_frame_plt
7511         = htab->non_lazy_plt->eh_frame_plt;
7512     }
7513   else
7514     {
7515       lazy_plt = TRUE;
7516       htab->plt.plt_entry
7517         = htab->lazy_plt->plt_entry;
7518       htab->plt.plt_entry_size
7519         = htab->lazy_plt->plt_entry_size;
7520       htab->plt.plt_got_offset
7521         = htab->lazy_plt->plt_got_offset;
7522       htab->plt.plt_got_insn_size
7523         = htab->lazy_plt->plt_got_insn_size;
7524       htab->plt.eh_frame_plt_size
7525         = htab->lazy_plt->eh_frame_plt_size;
7526       htab->plt.eh_frame_plt
7527         = htab->lazy_plt->eh_frame_plt;
7528     }
7529
7530   /* Return if there are no normal input files.  */
7531   if (dynobj == NULL)
7532     return pbfd;
7533
7534   /* Since create_dynamic_sections isn't always called, but GOT
7535      relocations need GOT relocations, create them here so that we
7536      don't need to do it in check_relocs.  */
7537   if (htab->elf.sgot == NULL
7538       && !_bfd_elf_create_got_section (dynobj, info))
7539     info->callbacks->einfo (_("%F: failed to create GOT sections\n"));
7540
7541   /* Align .got and .got.plt sections to their entry size.  Do it here
7542      instead of in create_dynamic_sections so that they are always
7543      properly aligned even if create_dynamic_sections isn't called.  */
7544   sec = htab->elf.sgot;
7545   if (!bfd_set_section_alignment (dynobj, sec, 3))
7546     goto error_alignment;
7547
7548   sec = htab->elf.sgotplt;
7549   if (!bfd_set_section_alignment (dynobj, sec, 3))
7550     goto error_alignment;
7551
7552   /* Create the ifunc sections here so that check_relocs can be
7553      simplified.  */
7554   if (!_bfd_elf_create_ifunc_sections (dynobj, info))
7555     info->callbacks->einfo (_("%F: failed to create ifunc sections\n"));
7556
7557   plt_alignment = bfd_log2 (htab->plt.plt_entry_size);
7558
7559   if (pltsec != NULL)
7560     {
7561       /* Whe creating executable, set the contents of the .interp
7562          section to the interpreter.  */
7563       if (bfd_link_executable (info) && !info->nointerp)
7564         {
7565           asection *s = bfd_get_linker_section (dynobj, ".interp");
7566           if (s == NULL)
7567             abort ();
7568           s->size = htab->dynamic_interpreter_size;
7569           s->contents = (unsigned char *) htab->dynamic_interpreter;
7570           htab->interp = s;
7571         }
7572
7573       /* Don't change PLT section alignment for NaCl since it uses
7574          64-byte PLT entry and sets PLT section alignment to 32
7575          bytes.  Don't create additional PLT sections for NaCl.  */
7576       if (normal_target)
7577         {
7578           const struct elf_backend_data *bed
7579             = get_elf_backend_data (dynobj);
7580           flagword pltflags = (bed->dynamic_sec_flags
7581                                | SEC_ALLOC
7582                                | SEC_CODE
7583                                | SEC_LOAD
7584                                | SEC_READONLY);
7585           unsigned int non_lazy_plt_alignment
7586             = bfd_log2 (htab->non_lazy_plt->plt_entry_size);
7587
7588           sec = pltsec;
7589           if (!bfd_set_section_alignment (sec->owner, sec,
7590                                           plt_alignment))
7591             goto error_alignment;
7592
7593           /* Create the GOT procedure linkage table.  */
7594           sec = bfd_make_section_anyway_with_flags (dynobj,
7595                                                     ".plt.got",
7596                                                     pltflags);
7597           if (sec == NULL)
7598             info->callbacks->einfo (_("%F: failed to create GOT PLT section\n"));
7599
7600           if (!bfd_set_section_alignment (dynobj, sec,
7601                                           non_lazy_plt_alignment))
7602             goto error_alignment;
7603
7604           htab->plt_got = sec;
7605
7606           if (lazy_plt)
7607             {
7608               sec = NULL;
7609
7610               if (use_ibt_plt)
7611                 {
7612                   /* Create the second PLT for Intel IBT support.  IBT
7613                      PLT is supported only for non-NaCl target and is
7614                      is needed only for lazy binding.  */
7615                   sec = bfd_make_section_anyway_with_flags (dynobj,
7616                                                             ".plt.sec",
7617                                                             pltflags);
7618                   if (sec == NULL)
7619                     info->callbacks->einfo (_("%F: failed to create IBT-enabled PLT section\n"));
7620
7621                   if (!bfd_set_section_alignment (dynobj, sec,
7622                                                   plt_alignment))
7623                     goto error_alignment;
7624                 }
7625               else if (info->bndplt && ABI_64_P (dynobj))
7626                 {
7627                   /* Create the second PLT for Intel MPX support.  MPX
7628                      PLT is supported only for non-NaCl target in 64-bit
7629                      mode and is needed only for lazy binding.  */
7630                   sec = bfd_make_section_anyway_with_flags (dynobj,
7631                                                             ".plt.sec",
7632                                                             pltflags);
7633                   if (sec == NULL)
7634                     info->callbacks->einfo (_("%F: failed to create BND PLT section\n"));
7635
7636                   if (!bfd_set_section_alignment (dynobj, sec,
7637                                                   non_lazy_plt_alignment))
7638                     goto error_alignment;
7639                 }
7640
7641               htab->plt_second = sec;
7642             }
7643         }
7644
7645       if (!info->no_ld_generated_unwind_info)
7646         {
7647           flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_READONLY
7648                             | SEC_HAS_CONTENTS | SEC_IN_MEMORY
7649                             | SEC_LINKER_CREATED);
7650
7651           sec = bfd_make_section_anyway_with_flags (dynobj,
7652                                                     ".eh_frame",
7653                                                     flags);
7654           if (sec == NULL)
7655             info->callbacks->einfo (_("%F: failed to create PLT .eh_frame section\n"));
7656
7657           if (!bfd_set_section_alignment (dynobj, sec,
7658                                           ABI_64_P (dynobj) ? 3 : 2))
7659             goto error_alignment;
7660
7661           htab->plt_eh_frame = sec;
7662
7663           if (htab->plt_got != NULL)
7664             {
7665               sec = bfd_make_section_anyway_with_flags (dynobj,
7666                                                         ".eh_frame",
7667                                                         flags);
7668               if (sec == NULL)
7669                 info->callbacks->einfo (_("%F: failed to create GOT PLT .eh_frame section\n"));
7670
7671               if (!bfd_set_section_alignment (dynobj, sec,
7672                                               ABI_64_P (dynobj) ? 3 : 2))
7673                 goto error_alignment;
7674
7675               htab->plt_got_eh_frame = sec;
7676             }
7677
7678           if (htab->plt_second != NULL)
7679             {
7680               sec = bfd_make_section_anyway_with_flags (dynobj,
7681                                                         ".eh_frame",
7682                                                         flags);
7683               if (sec == NULL)
7684                 info->callbacks->einfo (_("%F: failed to create BND PLT .eh_frame section\n"));
7685
7686               if (!bfd_set_section_alignment (dynobj, sec, 3))
7687                 goto error_alignment;
7688
7689               htab->plt_second_eh_frame = sec;
7690             }
7691         }
7692     }
7693
7694   if (normal_target)
7695     {
7696       /* The .iplt section is used for IFUNC symbols in static
7697          executables.  */
7698       sec = htab->elf.iplt;
7699       if (sec != NULL
7700           && !bfd_set_section_alignment (sec->owner, sec,
7701                                          plt_alignment))
7702         goto error_alignment;
7703     }
7704
7705   return pbfd;
7706 }
7707
7708 static bfd_boolean
7709 elf_x86_64_link_check_relocs (bfd *abfd, struct bfd_link_info *info)
7710 {
7711   if (!bfd_link_relocatable (info))
7712     {
7713       /* Check for __tls_get_addr reference.  */
7714       struct elf_link_hash_entry *h;
7715       h = elf_link_hash_lookup (elf_hash_table (info), "__tls_get_addr",
7716                                 FALSE, FALSE, FALSE);
7717       if (h != NULL)
7718         ((struct elf_x86_64_link_hash_entry *) h)->tls_get_addr = 1;
7719     }
7720
7721   /* Invoke the regular ELF backend linker to do all the work.  */
7722   return _bfd_elf_link_check_relocs (abfd, info);
7723 }
7724
7725 static const struct bfd_elf_special_section
7726 elf_x86_64_special_sections[]=
7727 {
7728   { STRING_COMMA_LEN (".gnu.linkonce.lb"), -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
7729   { STRING_COMMA_LEN (".gnu.linkonce.lr"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
7730   { STRING_COMMA_LEN (".gnu.linkonce.lt"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR + SHF_X86_64_LARGE},
7731   { STRING_COMMA_LEN (".lbss"),            -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
7732   { STRING_COMMA_LEN (".ldata"),           -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_X86_64_LARGE},
7733   { STRING_COMMA_LEN (".lrodata"),         -2, SHT_PROGBITS, SHF_ALLOC + SHF_X86_64_LARGE},
7734   { NULL,                       0,          0, 0,            0 }
7735 };
7736
7737 #define TARGET_LITTLE_SYM                   x86_64_elf64_vec
7738 #define TARGET_LITTLE_NAME                  "elf64-x86-64"
7739 #define ELF_ARCH                            bfd_arch_i386
7740 #define ELF_TARGET_ID                       X86_64_ELF_DATA
7741 #define ELF_MACHINE_CODE                    EM_X86_64
7742 #define ELF_MAXPAGESIZE                     0x200000
7743 #define ELF_MINPAGESIZE                     0x1000
7744 #define ELF_COMMONPAGESIZE                  0x1000
7745
7746 #define elf_backend_can_gc_sections         1
7747 #define elf_backend_can_refcount            1
7748 #define elf_backend_want_got_plt            1
7749 #define elf_backend_plt_readonly            1
7750 #define elf_backend_want_plt_sym            0
7751 #define elf_backend_got_header_size         (GOT_ENTRY_SIZE*3)
7752 #define elf_backend_rela_normal             1
7753 #define elf_backend_plt_alignment           4
7754 #define elf_backend_extern_protected_data   1
7755 #define elf_backend_caches_rawsize          1
7756 #define elf_backend_dtrel_excludes_plt      1
7757 #define elf_backend_want_dynrelro           1
7758
7759 #define elf_info_to_howto                   elf_x86_64_info_to_howto
7760
7761 #define bfd_elf64_bfd_link_hash_table_create \
7762   elf_x86_64_link_hash_table_create
7763 #define bfd_elf64_bfd_reloc_type_lookup     elf_x86_64_reloc_type_lookup
7764 #define bfd_elf64_bfd_reloc_name_lookup \
7765   elf_x86_64_reloc_name_lookup
7766
7767 #define elf_backend_adjust_dynamic_symbol   elf_x86_64_adjust_dynamic_symbol
7768 #define elf_backend_relocs_compatible       elf_x86_64_relocs_compatible
7769 #define elf_backend_check_relocs            elf_x86_64_check_relocs
7770 #define elf_backend_copy_indirect_symbol    elf_x86_64_copy_indirect_symbol
7771 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
7772 #define elf_backend_finish_dynamic_sections elf_x86_64_finish_dynamic_sections
7773 #define elf_backend_finish_dynamic_symbol   elf_x86_64_finish_dynamic_symbol
7774 #define elf_backend_output_arch_local_syms  elf_x86_64_output_arch_local_syms
7775 #define elf_backend_gc_mark_hook            elf_x86_64_gc_mark_hook
7776 #define elf_backend_grok_prstatus           elf_x86_64_grok_prstatus
7777 #define elf_backend_grok_psinfo             elf_x86_64_grok_psinfo
7778 #ifdef CORE_HEADER
7779 #define elf_backend_write_core_note         elf_x86_64_write_core_note
7780 #endif
7781 #define elf_backend_reloc_type_class        elf_x86_64_reloc_type_class
7782 #define elf_backend_relocate_section        elf_x86_64_relocate_section
7783 #define elf_backend_size_dynamic_sections   elf_x86_64_size_dynamic_sections
7784 #define elf_backend_always_size_sections    elf_x86_64_always_size_sections
7785 #define elf_backend_init_index_section      _bfd_elf_init_1_index_section
7786 #define elf_backend_object_p                elf64_x86_64_elf_object_p
7787 #define bfd_elf64_mkobject                  elf_x86_64_mkobject
7788 #define bfd_elf64_get_synthetic_symtab      elf_x86_64_get_synthetic_symtab
7789 #define bfd_elf64_bfd_link_check_relocs     elf_x86_64_link_check_relocs
7790
7791 #define elf_backend_section_from_shdr \
7792         elf_x86_64_section_from_shdr
7793
7794 #define elf_backend_section_from_bfd_section \
7795   elf_x86_64_elf_section_from_bfd_section
7796 #define elf_backend_add_symbol_hook \
7797   elf_x86_64_add_symbol_hook
7798 #define elf_backend_symbol_processing \
7799   elf_x86_64_symbol_processing
7800 #define elf_backend_common_section_index \
7801   elf_x86_64_common_section_index
7802 #define elf_backend_common_section \
7803   elf_x86_64_common_section
7804 #define elf_backend_common_definition \
7805   elf_x86_64_common_definition
7806 #define elf_backend_merge_symbol \
7807   elf_x86_64_merge_symbol
7808 #define elf_backend_special_sections \
7809   elf_x86_64_special_sections
7810 #define elf_backend_additional_program_headers \
7811   elf_x86_64_additional_program_headers
7812 #define elf_backend_hash_symbol \
7813   elf_x86_64_hash_symbol
7814 #define elf_backend_omit_section_dynsym \
7815   ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
7816 #define elf_backend_fixup_symbol \
7817   elf_x86_64_fixup_symbol
7818 #define elf_backend_parse_gnu_properties \
7819   elf_x86_64_parse_gnu_properties
7820 #define elf_backend_merge_gnu_properties \
7821  elf_x86_64_merge_gnu_properties
7822 #define elf_backend_setup_gnu_properties \
7823  elf_x86_64_link_setup_gnu_properties
7824
7825 #include "elf64-target.h"
7826
7827 /* CloudABI support.  */
7828
7829 #undef  TARGET_LITTLE_SYM
7830 #define TARGET_LITTLE_SYM                   x86_64_elf64_cloudabi_vec
7831 #undef  TARGET_LITTLE_NAME
7832 #define TARGET_LITTLE_NAME                  "elf64-x86-64-cloudabi"
7833
7834 #undef  ELF_OSABI
7835 #define ELF_OSABI                           ELFOSABI_CLOUDABI
7836
7837 #undef  elf64_bed
7838 #define elf64_bed elf64_x86_64_cloudabi_bed
7839
7840 #include "elf64-target.h"
7841
7842 /* FreeBSD support.  */
7843
7844 #undef  TARGET_LITTLE_SYM
7845 #define TARGET_LITTLE_SYM                   x86_64_elf64_fbsd_vec
7846 #undef  TARGET_LITTLE_NAME
7847 #define TARGET_LITTLE_NAME                  "elf64-x86-64-freebsd"
7848
7849 #undef  ELF_OSABI
7850 #define ELF_OSABI                           ELFOSABI_FREEBSD
7851
7852 #undef  elf64_bed
7853 #define elf64_bed elf64_x86_64_fbsd_bed
7854
7855 #include "elf64-target.h"
7856
7857 /* Solaris 2 support.  */
7858
7859 #undef  TARGET_LITTLE_SYM
7860 #define TARGET_LITTLE_SYM                   x86_64_elf64_sol2_vec
7861 #undef  TARGET_LITTLE_NAME
7862 #define TARGET_LITTLE_NAME                  "elf64-x86-64-sol2"
7863
7864 /* Restore default: we cannot use ELFOSABI_SOLARIS, otherwise ELFOSABI_NONE
7865    objects won't be recognized.  */
7866 #undef ELF_OSABI
7867
7868 #undef  elf64_bed
7869 #define elf64_bed                           elf64_x86_64_sol2_bed
7870
7871 /* The 64-bit static TLS arena size is rounded to the nearest 16-byte
7872    boundary.  */
7873 #undef  elf_backend_static_tls_alignment
7874 #define elf_backend_static_tls_alignment    16
7875
7876 /* The Solaris 2 ABI requires a plt symbol on all platforms.
7877
7878    Cf. Linker and Libraries Guide, Ch. 2, Link-Editor, Generating the Output
7879    File, p.63.  */
7880 #undef  elf_backend_want_plt_sym
7881 #define elf_backend_want_plt_sym            1
7882
7883 #undef  elf_backend_strtab_flags
7884 #define elf_backend_strtab_flags        SHF_STRINGS
7885
7886 static bfd_boolean
7887 elf64_x86_64_copy_solaris_special_section_fields (const bfd *ibfd ATTRIBUTE_UNUSED,
7888                                                   bfd *obfd ATTRIBUTE_UNUSED,
7889                                                   const Elf_Internal_Shdr *isection ATTRIBUTE_UNUSED,
7890                                                   Elf_Internal_Shdr *osection ATTRIBUTE_UNUSED)
7891 {
7892   /* PR 19938: FIXME: Need to add code for setting the sh_info
7893      and sh_link fields of Solaris specific section types.  */
7894   return FALSE;
7895 }
7896
7897 #undef  elf_backend_copy_special_section_fields
7898 #define elf_backend_copy_special_section_fields elf64_x86_64_copy_solaris_special_section_fields
7899
7900 #include "elf64-target.h"
7901
7902 /* Native Client support.  */
7903
7904 static bfd_boolean
7905 elf64_x86_64_nacl_elf_object_p (bfd *abfd)
7906 {
7907   /* Set the right machine number for a NaCl x86-64 ELF64 file.  */
7908   bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64_nacl);
7909   return TRUE;
7910 }
7911
7912 #undef  TARGET_LITTLE_SYM
7913 #define TARGET_LITTLE_SYM               x86_64_elf64_nacl_vec
7914 #undef  TARGET_LITTLE_NAME
7915 #define TARGET_LITTLE_NAME              "elf64-x86-64-nacl"
7916 #undef  elf64_bed
7917 #define elf64_bed                       elf64_x86_64_nacl_bed
7918
7919 #undef  ELF_MAXPAGESIZE
7920 #undef  ELF_MINPAGESIZE
7921 #undef  ELF_COMMONPAGESIZE
7922 #define ELF_MAXPAGESIZE                 0x10000
7923 #define ELF_MINPAGESIZE                 0x10000
7924 #define ELF_COMMONPAGESIZE              0x10000
7925
7926 /* Restore defaults.  */
7927 #undef  ELF_OSABI
7928 #undef  elf_backend_static_tls_alignment
7929 #undef  elf_backend_want_plt_sym
7930 #define elf_backend_want_plt_sym        0
7931 #undef  elf_backend_strtab_flags
7932 #undef  elf_backend_copy_special_section_fields
7933
7934 /* NaCl uses substantially different PLT entries for the same effects.  */
7935
7936 #undef  elf_backend_plt_alignment
7937 #define elf_backend_plt_alignment       5
7938 #define NACL_PLT_ENTRY_SIZE             64
7939 #define NACLMASK                        0xe0 /* 32-byte alignment mask.  */
7940
7941 static const bfd_byte elf_x86_64_nacl_plt0_entry[NACL_PLT_ENTRY_SIZE] =
7942   {
7943     0xff, 0x35, 8, 0, 0, 0,             /* pushq GOT+8(%rip)            */
7944     0x4c, 0x8b, 0x1d, 16, 0, 0, 0,      /* mov GOT+16(%rip), %r11       */
7945     0x41, 0x83, 0xe3, NACLMASK,         /* and $-32, %r11d              */
7946     0x4d, 0x01, 0xfb,                   /* add %r15, %r11               */
7947     0x41, 0xff, 0xe3,                   /* jmpq *%r11                   */
7948
7949     /* 9-byte nop sequence to pad out to the next 32-byte boundary.  */
7950     0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw 0x0(%rax,%rax,1)     */
7951
7952     /* 32 bytes of nop to pad out to the standard size.  */
7953     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data16 prefixes    */
7954     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
7955     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data16 prefixes    */
7956     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
7957     0x66,                                  /* excess data16 prefix      */
7958     0x90                                   /* nop */
7959   };
7960
7961 static const bfd_byte elf_x86_64_nacl_plt_entry[NACL_PLT_ENTRY_SIZE] =
7962   {
7963     0x4c, 0x8b, 0x1d, 0, 0, 0, 0,       /* mov name@GOTPCREL(%rip),%r11 */
7964     0x41, 0x83, 0xe3, NACLMASK,         /* and $-32, %r11d              */
7965     0x4d, 0x01, 0xfb,                   /* add %r15, %r11               */
7966     0x41, 0xff, 0xe3,                   /* jmpq *%r11                   */
7967
7968     /* 15-byte nop sequence to pad out to the next 32-byte boundary.  */
7969     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data16 prefixes    */
7970     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
7971
7972     /* Lazy GOT entries point here (32-byte aligned).  */
7973     0x68,                 /* pushq immediate */
7974     0, 0, 0, 0,           /* replaced with index into relocation table.  */
7975     0xe9,                 /* jmp relative */
7976     0, 0, 0, 0,           /* replaced with offset to start of .plt0.  */
7977
7978     /* 22 bytes of nop to pad out to the standard size.  */
7979     0x66, 0x66, 0x66, 0x66, 0x66, 0x66,    /* excess data16 prefixes    */
7980     0x2e, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0, /* nopw %cs:0x0(%rax,%rax,1) */
7981     0x0f, 0x1f, 0x80, 0, 0, 0, 0,          /* nopl 0x0(%rax)            */
7982   };
7983
7984 /* .eh_frame covering the .plt section.  */
7985
7986 static const bfd_byte elf_x86_64_nacl_eh_frame_plt[] =
7987   {
7988 #if (PLT_CIE_LENGTH != 20                               \
7989      || PLT_FDE_LENGTH != 36                            \
7990      || PLT_FDE_START_OFFSET != 4 + PLT_CIE_LENGTH + 8  \
7991      || PLT_FDE_LEN_OFFSET != 4 + PLT_CIE_LENGTH + 12)
7992 # error "Need elf_x86_64_backend_data parameters for eh_frame_plt offsets!"
7993 #endif
7994     PLT_CIE_LENGTH, 0, 0, 0,    /* CIE length */
7995     0, 0, 0, 0,                 /* CIE ID */
7996     1,                          /* CIE version */
7997     'z', 'R', 0,                /* Augmentation string */
7998     1,                          /* Code alignment factor */
7999     0x78,                       /* Data alignment factor */
8000     16,                         /* Return address column */
8001     1,                          /* Augmentation size */
8002     DW_EH_PE_pcrel | DW_EH_PE_sdata4, /* FDE encoding */
8003     DW_CFA_def_cfa, 7, 8,       /* DW_CFA_def_cfa: r7 (rsp) ofs 8 */
8004     DW_CFA_offset + 16, 1,      /* DW_CFA_offset: r16 (rip) at cfa-8 */
8005     DW_CFA_nop, DW_CFA_nop,
8006
8007     PLT_FDE_LENGTH, 0, 0, 0,    /* FDE length */
8008     PLT_CIE_LENGTH + 8, 0, 0, 0,/* CIE pointer */
8009     0, 0, 0, 0,                 /* R_X86_64_PC32 .plt goes here */
8010     0, 0, 0, 0,                 /* .plt size goes here */
8011     0,                          /* Augmentation size */
8012     DW_CFA_def_cfa_offset, 16,  /* DW_CFA_def_cfa_offset: 16 */
8013     DW_CFA_advance_loc + 6,     /* DW_CFA_advance_loc: 6 to __PLT__+6 */
8014     DW_CFA_def_cfa_offset, 24,  /* DW_CFA_def_cfa_offset: 24 */
8015     DW_CFA_advance_loc + 58,    /* DW_CFA_advance_loc: 58 to __PLT__+64 */
8016     DW_CFA_def_cfa_expression,  /* DW_CFA_def_cfa_expression */
8017     13,                         /* Block length */
8018     DW_OP_breg7, 8,             /* DW_OP_breg7 (rsp): 8 */
8019     DW_OP_breg16, 0,            /* DW_OP_breg16 (rip): 0 */
8020     DW_OP_const1u, 63, DW_OP_and, DW_OP_const1u, 37, DW_OP_ge,
8021     DW_OP_lit3, DW_OP_shl, DW_OP_plus,
8022     DW_CFA_nop, DW_CFA_nop
8023   };
8024
8025 static const struct elf_x86_64_lazy_plt_layout elf_x86_64_nacl_plt =
8026   {
8027     elf_x86_64_nacl_plt0_entry,              /* plt0_entry */
8028     elf_x86_64_nacl_plt_entry,               /* plt_entry */
8029     NACL_PLT_ENTRY_SIZE,                     /* plt_entry_size */
8030     2,                                       /* plt0_got1_offset */
8031     9,                                       /* plt0_got2_offset */
8032     13,                                      /* plt0_got2_insn_end */
8033     3,                                       /* plt_got_offset */
8034     33,                                      /* plt_reloc_offset */
8035     38,                                      /* plt_plt_offset */
8036     7,                                       /* plt_got_insn_size */
8037     42,                                      /* plt_plt_insn_end */
8038     32,                                      /* plt_lazy_offset */
8039     elf_x86_64_nacl_eh_frame_plt,            /* eh_frame_plt */
8040     sizeof (elf_x86_64_nacl_eh_frame_plt)    /* eh_frame_plt_size */
8041   };
8042
8043 static const struct elf_x86_64_backend_data elf_x86_64_nacl_arch_bed =
8044   {
8045     is_nacl                                  /* os */
8046   };
8047
8048 #undef  elf_backend_arch_data
8049 #define elf_backend_arch_data   &elf_x86_64_nacl_arch_bed
8050
8051 #undef  elf_backend_object_p
8052 #define elf_backend_object_p                    elf64_x86_64_nacl_elf_object_p
8053 #undef  elf_backend_modify_segment_map
8054 #define elf_backend_modify_segment_map          nacl_modify_segment_map
8055 #undef  elf_backend_modify_program_headers
8056 #define elf_backend_modify_program_headers      nacl_modify_program_headers
8057 #undef  elf_backend_final_write_processing
8058 #define elf_backend_final_write_processing      nacl_final_write_processing
8059
8060 #include "elf64-target.h"
8061
8062 /* Native Client x32 support.  */
8063
8064 static bfd_boolean
8065 elf32_x86_64_nacl_elf_object_p (bfd *abfd)
8066 {
8067   /* Set the right machine number for a NaCl x86-64 ELF32 file.  */
8068   bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x64_32_nacl);
8069   return TRUE;
8070 }
8071
8072 #undef  TARGET_LITTLE_SYM
8073 #define TARGET_LITTLE_SYM               x86_64_elf32_nacl_vec
8074 #undef  TARGET_LITTLE_NAME
8075 #define TARGET_LITTLE_NAME              "elf32-x86-64-nacl"
8076 #undef  elf32_bed
8077 #define elf32_bed                       elf32_x86_64_nacl_bed
8078
8079 #define bfd_elf32_bfd_link_hash_table_create \
8080   elf_x86_64_link_hash_table_create
8081 #define bfd_elf32_bfd_reloc_type_lookup \
8082   elf_x86_64_reloc_type_lookup
8083 #define bfd_elf32_bfd_reloc_name_lookup \
8084   elf_x86_64_reloc_name_lookup
8085 #define bfd_elf32_mkobject \
8086   elf_x86_64_mkobject
8087 #define bfd_elf32_get_synthetic_symtab \
8088   elf_x86_64_get_synthetic_symtab
8089 #define bfd_elf32_bfd_link_check_relocs \
8090   elf_x86_64_link_check_relocs
8091
8092 #undef elf_backend_object_p
8093 #define elf_backend_object_p \
8094   elf32_x86_64_nacl_elf_object_p
8095
8096 #undef elf_backend_bfd_from_remote_memory
8097 #define elf_backend_bfd_from_remote_memory \
8098   _bfd_elf32_bfd_from_remote_memory
8099
8100 #undef elf_backend_size_info
8101 #define elf_backend_size_info \
8102   _bfd_elf32_size_info
8103
8104 #include "elf32-target.h"
8105
8106 /* Restore defaults.  */
8107 #undef  elf_backend_object_p
8108 #define elf_backend_object_p                elf64_x86_64_elf_object_p
8109 #undef  elf_backend_bfd_from_remote_memory
8110 #undef  elf_backend_size_info
8111 #undef  elf_backend_modify_segment_map
8112 #undef  elf_backend_modify_program_headers
8113 #undef  elf_backend_final_write_processing
8114
8115 /* Intel L1OM support.  */
8116
8117 static bfd_boolean
8118 elf64_l1om_elf_object_p (bfd *abfd)
8119 {
8120   /* Set the right machine number for an L1OM elf64 file.  */
8121   bfd_default_set_arch_mach (abfd, bfd_arch_l1om, bfd_mach_l1om);
8122   return TRUE;
8123 }
8124
8125 #undef  TARGET_LITTLE_SYM
8126 #define TARGET_LITTLE_SYM                   l1om_elf64_vec
8127 #undef  TARGET_LITTLE_NAME
8128 #define TARGET_LITTLE_NAME                  "elf64-l1om"
8129 #undef ELF_ARCH
8130 #define ELF_ARCH                            bfd_arch_l1om
8131
8132 #undef  ELF_MACHINE_CODE
8133 #define ELF_MACHINE_CODE                    EM_L1OM
8134
8135 #undef  ELF_OSABI
8136
8137 #undef  elf64_bed
8138 #define elf64_bed elf64_l1om_bed
8139
8140 #undef elf_backend_object_p
8141 #define elf_backend_object_p                elf64_l1om_elf_object_p
8142
8143 /* Restore defaults.  */
8144 #undef  ELF_MAXPAGESIZE
8145 #undef  ELF_MINPAGESIZE
8146 #undef  ELF_COMMONPAGESIZE
8147 #define ELF_MAXPAGESIZE                 0x200000
8148 #define ELF_MINPAGESIZE                 0x1000
8149 #define ELF_COMMONPAGESIZE              0x1000
8150 #undef  elf_backend_plt_alignment
8151 #define elf_backend_plt_alignment       4
8152 #undef  elf_backend_arch_data
8153 #define elf_backend_arch_data   &elf_x86_64_arch_bed
8154
8155 #include "elf64-target.h"
8156
8157 /* FreeBSD L1OM support.  */
8158
8159 #undef  TARGET_LITTLE_SYM
8160 #define TARGET_LITTLE_SYM                   l1om_elf64_fbsd_vec
8161 #undef  TARGET_LITTLE_NAME
8162 #define TARGET_LITTLE_NAME                  "elf64-l1om-freebsd"
8163
8164 #undef  ELF_OSABI
8165 #define ELF_OSABI                           ELFOSABI_FREEBSD
8166
8167 #undef  elf64_bed
8168 #define elf64_bed elf64_l1om_fbsd_bed
8169
8170 #include "elf64-target.h"
8171
8172 /* Intel K1OM support.  */
8173
8174 static bfd_boolean
8175 elf64_k1om_elf_object_p (bfd *abfd)
8176 {
8177   /* Set the right machine number for an K1OM elf64 file.  */
8178   bfd_default_set_arch_mach (abfd, bfd_arch_k1om, bfd_mach_k1om);
8179   return TRUE;
8180 }
8181
8182 #undef  TARGET_LITTLE_SYM
8183 #define TARGET_LITTLE_SYM                   k1om_elf64_vec
8184 #undef  TARGET_LITTLE_NAME
8185 #define TARGET_LITTLE_NAME                  "elf64-k1om"
8186 #undef ELF_ARCH
8187 #define ELF_ARCH                            bfd_arch_k1om
8188
8189 #undef  ELF_MACHINE_CODE
8190 #define ELF_MACHINE_CODE                    EM_K1OM
8191
8192 #undef  ELF_OSABI
8193
8194 #undef  elf64_bed
8195 #define elf64_bed elf64_k1om_bed
8196
8197 #undef elf_backend_object_p
8198 #define elf_backend_object_p                elf64_k1om_elf_object_p
8199
8200 #undef  elf_backend_static_tls_alignment
8201
8202 #undef elf_backend_want_plt_sym
8203 #define elf_backend_want_plt_sym            0
8204
8205 #include "elf64-target.h"
8206
8207 /* FreeBSD K1OM support.  */
8208
8209 #undef  TARGET_LITTLE_SYM
8210 #define TARGET_LITTLE_SYM                   k1om_elf64_fbsd_vec
8211 #undef  TARGET_LITTLE_NAME
8212 #define TARGET_LITTLE_NAME                  "elf64-k1om-freebsd"
8213
8214 #undef  ELF_OSABI
8215 #define ELF_OSABI                           ELFOSABI_FREEBSD
8216
8217 #undef  elf64_bed
8218 #define elf64_bed elf64_k1om_fbsd_bed
8219
8220 #include "elf64-target.h"
8221
8222 /* 32bit x86-64 support.  */
8223
8224 #undef  TARGET_LITTLE_SYM
8225 #define TARGET_LITTLE_SYM                   x86_64_elf32_vec
8226 #undef  TARGET_LITTLE_NAME
8227 #define TARGET_LITTLE_NAME                  "elf32-x86-64"
8228 #undef  elf32_bed
8229
8230 #undef ELF_ARCH
8231 #define ELF_ARCH                            bfd_arch_i386
8232
8233 #undef  ELF_MACHINE_CODE
8234 #define ELF_MACHINE_CODE                    EM_X86_64
8235
8236 #undef  ELF_OSABI
8237
8238 #undef elf_backend_object_p
8239 #define elf_backend_object_p \
8240   elf32_x86_64_elf_object_p
8241
8242 #undef elf_backend_bfd_from_remote_memory
8243 #define elf_backend_bfd_from_remote_memory \
8244   _bfd_elf32_bfd_from_remote_memory
8245
8246 #undef elf_backend_size_info
8247 #define elf_backend_size_info \
8248   _bfd_elf32_size_info
8249
8250 #include "elf32-target.h"