bfd/elf64-x86-64.c

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