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