bfd/elf64-x86-64.c

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