contrib/binutils-2.22/bfd/elf64-x86-64.c

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