bfd/elf64-x86-64.c

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