bfd/elf64-x86-64.c

   1 /* X86-64 specific support for 64-bit ELF
   2    Copyright 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   3    Contributed by Jan Hubicka <jh@suse.cz>.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "bfd.h"
  22 #include "sysdep.h"
  23 #include "bfdlink.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26
  27 #include "elf/x86-64.h"
  28
  29 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value.  */
  30 #define MINUS_ONE (~ (bfd_vma) 0)
  31
  32 /* The relocation "howto" table.  Order of fields:
  33    type, size, bitsize, pc_relative, complain_on_overflow,
  34    special_function, name, partial_inplace, src_mask, dst_pack, pcrel_offset.  */
  35 static reloc_howto_type x86_64_elf_howto_table[] =
  36 {
  37   HOWTO(R_X86_64_NONE, 0, 0, 0, FALSE, 0, complain_overflow_dont,
  38         bfd_elf_generic_reloc, "R_X86_64_NONE", FALSE, 0x00000000, 0x00000000,
  39         FALSE),
  40   HOWTO(R_X86_64_64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  41         bfd_elf_generic_reloc, "R_X86_64_64", FALSE, MINUS_ONE, MINUS_ONE,
  42         FALSE),
  43   HOWTO(R_X86_64_PC32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
  44         bfd_elf_generic_reloc, "R_X86_64_PC32", FALSE, 0xffffffff, 0xffffffff,
  45         TRUE),
  46   HOWTO(R_X86_64_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
  47         bfd_elf_generic_reloc, "R_X86_64_GOT32", FALSE, 0xffffffff, 0xffffffff,
  48         FALSE),
  49   HOWTO(R_X86_64_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_signed,
  50         bfd_elf_generic_reloc, "R_X86_64_PLT32", FALSE, 0xffffffff, 0xffffffff,
  51         TRUE),
  52   HOWTO(R_X86_64_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  53         bfd_elf_generic_reloc, "R_X86_64_COPY", FALSE, 0xffffffff, 0xffffffff,
  54         FALSE),
  55   HOWTO(R_X86_64_GLOB_DAT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  56         bfd_elf_generic_reloc, "R_X86_64_GLOB_DAT", FALSE, MINUS_ONE,
  57         MINUS_ONE, FALSE),
  58   HOWTO(R_X86_64_JUMP_SLOT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  59         bfd_elf_generic_reloc, "R_X86_64_JUMP_SLOT", FALSE, MINUS_ONE,
  60         MINUS_ONE, FALSE),
  61   HOWTO(R_X86_64_RELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  62         bfd_elf_generic_reloc, "R_X86_64_RELATIVE", FALSE, MINUS_ONE,
  63         MINUS_ONE, FALSE),
  64   HOWTO(R_X86_64_GOTPCREL, 0, 2, 32, TRUE, 0, complain_overflow_signed,
  65         bfd_elf_generic_reloc, "R_X86_64_GOTPCREL", FALSE, 0xffffffff,
  66         0xffffffff, TRUE),
  67   HOWTO(R_X86_64_32, 0, 2, 32, FALSE, 0, complain_overflow_unsigned,
  68         bfd_elf_generic_reloc, "R_X86_64_32", FALSE, 0xffffffff, 0xffffffff,
  69         FALSE),
  70   HOWTO(R_X86_64_32S, 0, 2, 32, FALSE, 0, complain_overflow_signed,
  71         bfd_elf_generic_reloc, "R_X86_64_32S", FALSE, 0xffffffff, 0xffffffff,
  72         FALSE),
  73   HOWTO(R_X86_64_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
  74         bfd_elf_generic_reloc, "R_X86_64_16", FALSE, 0xffff, 0xffff, FALSE),
  75   HOWTO(R_X86_64_PC16,0, 1, 16, TRUE, 0, complain_overflow_bitfield,
  76         bfd_elf_generic_reloc, "R_X86_64_PC16", FALSE, 0xffff, 0xffff, TRUE),
  77   HOWTO(R_X86_64_8, 0, 0, 8, FALSE, 0, complain_overflow_signed,
  78         bfd_elf_generic_reloc, "R_X86_64_8", FALSE, 0xff, 0xff, FALSE),
  79   HOWTO(R_X86_64_PC8, 0, 0, 8, TRUE, 0, complain_overflow_signed,
  80         bfd_elf_generic_reloc, "R_X86_64_PC8", FALSE, 0xff, 0xff, TRUE),
  81   HOWTO(R_X86_64_DTPMOD64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  82         bfd_elf_generic_reloc, "R_X86_64_DTPMOD64", FALSE, MINUS_ONE,
  83         MINUS_ONE, FALSE),
  84   HOWTO(R_X86_64_DTPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  85         bfd_elf_generic_reloc, "R_X86_64_DTPOFF64", FALSE, MINUS_ONE,
  86         MINUS_ONE, FALSE),
  87   HOWTO(R_X86_64_TPOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
  88         bfd_elf_generic_reloc, "R_X86_64_TPOFF64", FALSE, MINUS_ONE,
  89         MINUS_ONE, FALSE),
  90   HOWTO(R_X86_64_TLSGD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
  91         bfd_elf_generic_reloc, "R_X86_64_TLSGD", FALSE, 0xffffffff,
  92         0xffffffff, TRUE),
  93   HOWTO(R_X86_64_TLSLD, 0, 2, 32, TRUE, 0, complain_overflow_signed,
  94         bfd_elf_generic_reloc, "R_X86_64_TLSLD", FALSE, 0xffffffff,
  95         0xffffffff, TRUE),
  96   HOWTO(R_X86_64_DTPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  97         bfd_elf_generic_reloc, "R_X86_64_DTPOFF32", FALSE, 0xffffffff,
  98         0xffffffff, FALSE),
  99   HOWTO(R_X86_64_GOTTPOFF, 0, 2, 32, TRUE, 0, complain_overflow_signed,
 100         bfd_elf_generic_reloc, "R_X86_64_GOTTPOFF", FALSE, 0xffffffff,
 101         0xffffffff, TRUE),
 102   HOWTO(R_X86_64_TPOFF32, 0, 2, 32, FALSE, 0, complain_overflow_signed,
 103         bfd_elf_generic_reloc, "R_X86_64_TPOFF32", FALSE, 0xffffffff,
 104         0xffffffff, FALSE),
 105
 106 /* GNU extension to record C++ vtable hierarchy.  */
 107   HOWTO (R_X86_64_GNU_VTINHERIT, 0, 4, 0, FALSE, 0, complain_overflow_dont,
 108          NULL, "R_X86_64_GNU_VTINHERIT", FALSE, 0, 0, FALSE),
 109
 110 /* GNU extension to record C++ vtable member usage.  */
 111   HOWTO (R_X86_64_GNU_VTENTRY, 0, 4, 0, FALSE, 0, complain_overflow_dont,
 112          _bfd_elf_rel_vtable_reloc_fn, "R_X86_64_GNU_VTENTRY", FALSE, 0, 0,
 113          FALSE)
 114 };
 115
 116 /* Map BFD relocs to the x86_64 elf relocs.  */
 117 struct elf_reloc_map
 118 {
 119   bfd_reloc_code_real_type bfd_reloc_val;
 120   unsigned char elf_reloc_val;
 121 };
 122
 123 static const struct elf_reloc_map x86_64_reloc_map[] =
 124 {
 125   { BFD_RELOC_NONE,             R_X86_64_NONE, },
 126   { BFD_RELOC_64,               R_X86_64_64,   },
 127   { BFD_RELOC_32_PCREL,         R_X86_64_PC32, },
 128   { BFD_RELOC_X86_64_GOT32,     R_X86_64_GOT32,},
 129   { BFD_RELOC_X86_64_PLT32,     R_X86_64_PLT32,},
 130   { BFD_RELOC_X86_64_COPY,      R_X86_64_COPY, },
 131   { BFD_RELOC_X86_64_GLOB_DAT,  R_X86_64_GLOB_DAT, },
 132   { BFD_RELOC_X86_64_JUMP_SLOT, R_X86_64_JUMP_SLOT, },
 133   { BFD_RELOC_X86_64_RELATIVE,  R_X86_64_RELATIVE, },
 134   { BFD_RELOC_X86_64_GOTPCREL,  R_X86_64_GOTPCREL, },
 135   { BFD_RELOC_32,               R_X86_64_32, },
 136   { BFD_RELOC_X86_64_32S,       R_X86_64_32S, },
 137   { BFD_RELOC_16,               R_X86_64_16, },
 138   { BFD_RELOC_16_PCREL,         R_X86_64_PC16, },
 139   { BFD_RELOC_8,                R_X86_64_8, },
 140   { BFD_RELOC_8_PCREL,          R_X86_64_PC8, },
 141   { BFD_RELOC_X86_64_DTPMOD64,  R_X86_64_DTPMOD64, },
 142   { BFD_RELOC_X86_64_DTPOFF64,  R_X86_64_DTPOFF64, },
 143   { BFD_RELOC_X86_64_TPOFF64,   R_X86_64_TPOFF64, },
 144   { BFD_RELOC_X86_64_TLSGD,     R_X86_64_TLSGD, },
 145   { BFD_RELOC_X86_64_TLSLD,     R_X86_64_TLSLD, },
 146   { BFD_RELOC_X86_64_DTPOFF32,  R_X86_64_DTPOFF32, },
 147   { BFD_RELOC_X86_64_GOTTPOFF,  R_X86_64_GOTTPOFF, },
 148   { BFD_RELOC_X86_64_TPOFF32,   R_X86_64_TPOFF32, },
 149   { BFD_RELOC_VTABLE_INHERIT,   R_X86_64_GNU_VTINHERIT, },
 150   { BFD_RELOC_VTABLE_ENTRY,     R_X86_64_GNU_VTENTRY, },
 151 };
 152
 153
 154 /* Given a BFD reloc type, return a HOWTO structure.  */
 155 static reloc_howto_type *
 156 elf64_x86_64_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 157                                 bfd_reloc_code_real_type code)
 158 {
 159   unsigned int i;
 160
 161   for (i = 0; i < sizeof (x86_64_reloc_map) / sizeof (struct elf_reloc_map);
 162        i++)
 163     {
 164       if (x86_64_reloc_map[i].bfd_reloc_val == code)
 165         return &x86_64_elf_howto_table[i];
 166     }
 167   return 0;
 168 }
 169
 170 /* Given an x86_64 ELF reloc type, fill in an arelent structure.  */
 171
 172 static void
 173 elf64_x86_64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
 174                             Elf_Internal_Rela *dst)
 175 {
 176   unsigned r_type, i;
 177
 178   r_type = ELF64_R_TYPE (dst->r_info);
 179   if (r_type < (unsigned int) R_X86_64_GNU_VTINHERIT)
 180     {
 181       BFD_ASSERT (r_type <= (unsigned int) R_X86_64_TPOFF32);
 182       i = r_type;
 183     }
 184   else
 185     {
 186       BFD_ASSERT (r_type < (unsigned int) R_X86_64_max);
 187       i = r_type - ((unsigned int) R_X86_64_GNU_VTINHERIT - R_X86_64_TPOFF32 - 1);
 188     }
 189   cache_ptr->howto = &x86_64_elf_howto_table[i];
 190   BFD_ASSERT (r_type == cache_ptr->howto->type);
 191 }
 192 \f
 193 /* Support for core dump NOTE sections.  */
 194 static bfd_boolean
 195 elf64_x86_64_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
 196 {
 197   int offset;
 198   size_t size;
 199
 200   switch (note->descsz)
 201     {
 202       default:
 203         return FALSE;
 204
 205       case 336:         /* sizeof(istruct elf_prstatus) on Linux/x86_64 */
 206         /* pr_cursig */
 207         elf_tdata (abfd)->core_signal
 208           = bfd_get_16 (abfd, note->descdata + 12);
 209
 210         /* pr_pid */
 211         elf_tdata (abfd)->core_pid
 212           = bfd_get_32 (abfd, note->descdata + 32);
 213
 214         /* pr_reg */
 215         offset = 112;
 216         size = 216;
 217
 218         break;
 219     }
 220
 221   /* Make a ".reg/999" section.  */
 222   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
 223                                           size, note->descpos + offset);
 224 }
 225
 226 static bfd_boolean
 227 elf64_x86_64_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
 228 {
 229   switch (note->descsz)
 230     {
 231       default:
 232         return FALSE;
 233
 234       case 136:         /* sizeof(struct elf_prpsinfo) on Linux/x86_64 */
 235         elf_tdata (abfd)->core_program
 236          = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
 237         elf_tdata (abfd)->core_command
 238          = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
 239     }
 240
 241   /* Note that for some reason, a spurious space is tacked
 242      onto the end of the args in some (at least one anyway)
 243      implementations, so strip it off if it exists.  */
 244
 245   {
 246     char *command = elf_tdata (abfd)->core_command;
 247     int n = strlen (command);
 248
 249     if (0 < n && command[n - 1] == ' ')
 250       command[n - 1] = '\0';
 251   }
 252
 253   return TRUE;
 254 }
 255 \f
 256 /* Functions for the x86-64 ELF linker.  */
 257
 258 /* The name of the dynamic interpreter.  This is put in the .interp
 259    section.  */
 260
 261 #define ELF_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
 262
 263 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
 264    copying dynamic variables from a shared lib into an app's dynbss
 265    section, and instead use a dynamic relocation to point into the
 266    shared lib.  */
 267 #define ELIMINATE_COPY_RELOCS 1
 268
 269 /* The size in bytes of an entry in the global offset table.  */
 270
 271 #define GOT_ENTRY_SIZE 8
 272
 273 /* The size in bytes of an entry in the procedure linkage table.  */
 274
 275 #define PLT_ENTRY_SIZE 16
 276
 277 /* The first entry in a procedure linkage table looks like this.  See the
 278    SVR4 ABI i386 supplement and the x86-64 ABI to see how this works.  */
 279
 280 static const bfd_byte elf64_x86_64_plt0_entry[PLT_ENTRY_SIZE] =
 281 {
 282   0xff, 0x35, 8, 0, 0, 0,       /* pushq GOT+8(%rip)  */
 283   0xff, 0x25, 16, 0, 0, 0,      /* jmpq *GOT+16(%rip) */
 284   0x90, 0x90, 0x90, 0x90        /* pad out to 16 bytes with nops.  */
 285 };
 286
 287 /* Subsequent entries in a procedure linkage table look like this.  */
 288
 289 static const bfd_byte elf64_x86_64_plt_entry[PLT_ENTRY_SIZE] =
 290 {
 291   0xff, 0x25,   /* jmpq *name@GOTPC(%rip) */
 292   0, 0, 0, 0,   /* replaced with offset to this symbol in .got.  */
 293   0x68,         /* pushq immediate */
 294   0, 0, 0, 0,   /* replaced with index into relocation table.  */
 295   0xe9,         /* jmp relative */
 296   0, 0, 0, 0    /* replaced with offset to start of .plt0.  */
 297 };
 298
 299 /* The x86-64 linker needs to keep track of the number of relocs that
 300    it decides to copy as dynamic relocs in check_relocs for each symbol.
 301    This is so that it can later discard them if they are found to be
 302    unnecessary.  We store the information in a field extending the
 303    regular ELF linker hash table.  */
 304
 305 struct elf64_x86_64_dyn_relocs
 306 {
 307   /* Next section.  */
 308   struct elf64_x86_64_dyn_relocs *next;
 309
 310   /* The input section of the reloc.  */
 311   asection *sec;
 312
 313   /* Total number of relocs copied for the input section.  */
 314   bfd_size_type count;
 315
 316   /* Number of pc-relative relocs copied for the input section.  */
 317   bfd_size_type pc_count;
 318 };
 319
 320 /* x86-64 ELF linker hash entry.  */
 321
 322 struct elf64_x86_64_link_hash_entry
 323 {
 324   struct elf_link_hash_entry elf;
 325
 326   /* Track dynamic relocs copied for this symbol.  */
 327   struct elf64_x86_64_dyn_relocs *dyn_relocs;
 328
 329 #define GOT_UNKNOWN     0
 330 #define GOT_NORMAL      1
 331 #define GOT_TLS_GD      2
 332 #define GOT_TLS_IE      3
 333   unsigned char tls_type;
 334 };
 335
 336 #define elf64_x86_64_hash_entry(ent) \
 337   ((struct elf64_x86_64_link_hash_entry *)(ent))
 338
 339 struct elf64_x86_64_obj_tdata
 340 {
 341   struct elf_obj_tdata root;
 342
 343   /* tls_type for each local got entry.  */
 344   char *local_got_tls_type;
 345 };
 346
 347 #define elf64_x86_64_tdata(abfd) \
 348   ((struct elf64_x86_64_obj_tdata *) (abfd)->tdata.any)
 349
 350 #define elf64_x86_64_local_got_tls_type(abfd) \
 351   (elf64_x86_64_tdata (abfd)->local_got_tls_type)
 352
 353
 354 /* x86-64 ELF linker hash table.  */
 355
 356 struct elf64_x86_64_link_hash_table
 357 {
 358   struct elf_link_hash_table elf;
 359
 360   /* Short-cuts to get to dynamic linker sections.  */
 361   asection *sgot;
 362   asection *sgotplt;
 363   asection *srelgot;
 364   asection *splt;
 365   asection *srelplt;
 366   asection *sdynbss;
 367   asection *srelbss;
 368
 369   union {
 370     bfd_signed_vma refcount;
 371     bfd_vma offset;
 372   } tls_ld_got;
 373
 374   /* Small local sym to section mapping cache.  */
 375   struct sym_sec_cache sym_sec;
 376 };
 377
 378 /* Get the x86-64 ELF linker hash table from a link_info structure.  */
 379
 380 #define elf64_x86_64_hash_table(p) \
 381   ((struct elf64_x86_64_link_hash_table *) ((p)->hash))
 382
 383 /* Create an entry in an x86-64 ELF linker hash table.  */
 384
 385 static struct bfd_hash_entry *
 386 link_hash_newfunc (struct bfd_hash_entry *entry, struct bfd_hash_table *table,
 387                    const char *string)
 388 {
 389   /* Allocate the structure if it has not already been allocated by a
 390      subclass.  */
 391   if (entry == NULL)
 392     {
 393       entry = bfd_hash_allocate (table,
 394                                  sizeof (struct elf64_x86_64_link_hash_entry));
 395       if (entry == NULL)
 396         return entry;
 397     }
 398
 399   /* Call the allocation method of the superclass.  */
 400   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
 401   if (entry != NULL)
 402     {
 403       struct elf64_x86_64_link_hash_entry *eh;
 404
 405       eh = (struct elf64_x86_64_link_hash_entry *) entry;
 406       eh->dyn_relocs = NULL;
 407       eh->tls_type = GOT_UNKNOWN;
 408     }
 409
 410   return entry;
 411 }
 412
 413 /* Create an X86-64 ELF linker hash table.  */
 414
 415 static struct bfd_link_hash_table *
 416 elf64_x86_64_link_hash_table_create (bfd *abfd)
 417 {
 418   struct elf64_x86_64_link_hash_table *ret;
 419   bfd_size_type amt = sizeof (struct elf64_x86_64_link_hash_table);
 420
 421   ret = (struct elf64_x86_64_link_hash_table *) bfd_malloc (amt);
 422   if (ret == NULL)
 423     return NULL;
 424
 425   if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
 426     {
 427       free (ret);
 428       return NULL;
 429     }
 430
 431   ret->sgot = NULL;
 432   ret->sgotplt = NULL;
 433   ret->srelgot = NULL;
 434   ret->splt = NULL;
 435   ret->srelplt = NULL;
 436   ret->sdynbss = NULL;
 437   ret->srelbss = NULL;
 438   ret->sym_sec.abfd = NULL;
 439   ret->tls_ld_got.refcount = 0;
 440
 441   return &ret->elf.root;
 442 }
 443
 444 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
 445    shortcuts to them in our hash table.  */
 446
 447 static bfd_boolean
 448 create_got_section (bfd *dynobj, struct bfd_link_info *info)
 449 {
 450   struct elf64_x86_64_link_hash_table *htab;
 451
 452   if (! _bfd_elf_create_got_section (dynobj, info))
 453     return FALSE;
 454
 455   htab = elf64_x86_64_hash_table (info);
 456   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
 457   htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
 458   if (!htab->sgot || !htab->sgotplt)
 459     abort ();
 460
 461   htab->srelgot = bfd_make_section (dynobj, ".rela.got");
 462   if (htab->srelgot == NULL
 463       || ! bfd_set_section_flags (dynobj, htab->srelgot,
 464                                   (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
 465                                    | SEC_IN_MEMORY | SEC_LINKER_CREATED
 466                                    | SEC_READONLY))
 467       || ! bfd_set_section_alignment (dynobj, htab->srelgot, 3))
 468     return FALSE;
 469   return TRUE;
 470 }
 471
 472 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
 473    .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
 474    hash table.  */
 475
 476 static bfd_boolean
 477 elf64_x86_64_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
 478 {
 479   struct elf64_x86_64_link_hash_table *htab;
 480
 481   htab = elf64_x86_64_hash_table (info);
 482   if (!htab->sgot && !create_got_section (dynobj, info))
 483     return FALSE;
 484
 485   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
 486     return FALSE;
 487
 488   htab->splt = bfd_get_section_by_name (dynobj, ".plt");
 489   htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
 490   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
 491   if (!info->shared)
 492     htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
 493
 494   if (!htab->splt || !htab->srelplt || !htab->sdynbss
 495       || (!info->shared && !htab->srelbss))
 496     abort ();
 497
 498   return TRUE;
 499 }
 500
 501 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
 502
 503 static void
 504 elf64_x86_64_copy_indirect_symbol (const struct elf_backend_data *bed,
 505                                    struct elf_link_hash_entry *dir,
 506                                    struct elf_link_hash_entry *ind)
 507 {
 508   struct elf64_x86_64_link_hash_entry *edir, *eind;
 509
 510   edir = (struct elf64_x86_64_link_hash_entry *) dir;
 511   eind = (struct elf64_x86_64_link_hash_entry *) ind;
 512
 513   if (eind->dyn_relocs != NULL)
 514     {
 515       if (edir->dyn_relocs != NULL)
 516         {
 517           struct elf64_x86_64_dyn_relocs **pp;
 518           struct elf64_x86_64_dyn_relocs *p;
 519
 520           if (ind->root.type == bfd_link_hash_indirect)
 521             abort ();
 522
 523           /* Add reloc counts against the weak sym to the strong sym
 524              list.  Merge any entries against the same section.  */
 525           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
 526             {
 527               struct elf64_x86_64_dyn_relocs *q;
 528
 529               for (q = edir->dyn_relocs; q != NULL; q = q->next)
 530                 if (q->sec == p->sec)
 531                   {
 532                     q->pc_count += p->pc_count;
 533                     q->count += p->count;
 534                     *pp = p->next;
 535                     break;
 536                   }
 537               if (q == NULL)
 538                 pp = &p->next;
 539             }
 540           *pp = edir->dyn_relocs;
 541         }
 542
 543       edir->dyn_relocs = eind->dyn_relocs;
 544       eind->dyn_relocs = NULL;
 545     }
 546
 547   if (ind->root.type == bfd_link_hash_indirect
 548       && dir->got.refcount <= 0)
 549     {
 550       edir->tls_type = eind->tls_type;
 551       eind->tls_type = GOT_UNKNOWN;
 552     }
 553
 554   if (ELIMINATE_COPY_RELOCS
 555       && ind->root.type != bfd_link_hash_indirect
 556       && dir->dynamic_adjusted)
 557     {
 558       /* If called to transfer flags for a weakdef during processing
 559          of elf_adjust_dynamic_symbol, don't copy non_got_ref.
 560          We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
 561       dir->ref_dynamic |= ind->ref_dynamic;
 562       dir->ref_regular |= ind->ref_regular;
 563       dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
 564       dir->needs_plt |= ind->needs_plt;
 565       dir->pointer_equality_needed |= ind->pointer_equality_needed;
 566     }
 567   else
 568     _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
 569 }
 570
 571 static bfd_boolean
 572 elf64_x86_64_mkobject (bfd *abfd)
 573 {
 574   bfd_size_type amt = sizeof (struct elf64_x86_64_obj_tdata);
 575   abfd->tdata.any = bfd_zalloc (abfd, amt);
 576   if (abfd->tdata.any == NULL)
 577     return FALSE;
 578   return TRUE;
 579 }
 580
 581 static bfd_boolean
 582 elf64_x86_64_elf_object_p (bfd *abfd)
 583 {
 584   /* Set the right machine number for an x86-64 elf64 file.  */
 585   bfd_default_set_arch_mach (abfd, bfd_arch_i386, bfd_mach_x86_64);
 586   return TRUE;
 587 }
 588
 589 static int
 590 elf64_x86_64_tls_transition (struct bfd_link_info *info, int r_type, int is_local)
 591 {
 592   if (info->shared)
 593     return r_type;
 594
 595   switch (r_type)
 596     {
 597     case R_X86_64_TLSGD:
 598     case R_X86_64_GOTTPOFF:
 599       if (is_local)
 600         return R_X86_64_TPOFF32;
 601       return R_X86_64_GOTTPOFF;
 602     case R_X86_64_TLSLD:
 603       return R_X86_64_TPOFF32;
 604     }
 605
 606    return r_type;
 607 }
 608
 609 /* Look through the relocs for a section during the first phase, and
 610    calculate needed space in the global offset table, procedure
 611    linkage table, and dynamic reloc sections.  */
 612
 613 static bfd_boolean
 614 elf64_x86_64_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec,
 615                            const Elf_Internal_Rela *relocs)
 616 {
 617   struct elf64_x86_64_link_hash_table *htab;
 618   Elf_Internal_Shdr *symtab_hdr;
 619   struct elf_link_hash_entry **sym_hashes;
 620   const Elf_Internal_Rela *rel;
 621   const Elf_Internal_Rela *rel_end;
 622   asection *sreloc;
 623
 624   if (info->relocatable)
 625     return TRUE;
 626
 627   htab = elf64_x86_64_hash_table (info);
 628   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 629   sym_hashes = elf_sym_hashes (abfd);
 630
 631   sreloc = NULL;
 632
 633   rel_end = relocs + sec->reloc_count;
 634   for (rel = relocs; rel < rel_end; rel++)
 635     {
 636       unsigned int r_type;
 637       unsigned long r_symndx;
 638       struct elf_link_hash_entry *h;
 639
 640       r_symndx = ELF64_R_SYM (rel->r_info);
 641       r_type = ELF64_R_TYPE (rel->r_info);
 642
 643       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
 644         {
 645           (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
 646                                  abfd, r_symndx);
 647           return FALSE;
 648         }
 649
 650       if (r_symndx < symtab_hdr->sh_info)
 651         h = NULL;
 652       else
 653         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 654
 655       r_type = elf64_x86_64_tls_transition (info, r_type, h == NULL);
 656       switch (r_type)
 657         {
 658         case R_X86_64_TLSLD:
 659           htab->tls_ld_got.refcount += 1;
 660           goto create_got;
 661
 662         case R_X86_64_TPOFF32:
 663           if (info->shared)
 664             {
 665               (*_bfd_error_handler)
 666                 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
 667                  abfd,
 668                  x86_64_elf_howto_table[r_type].name,
 669                  (h) ? h->root.root.string : "a local symbol");
 670               bfd_set_error (bfd_error_bad_value);
 671               return FALSE;
 672             }
 673           break;
 674
 675         case R_X86_64_GOTTPOFF:
 676           if (info->shared)
 677             info->flags |= DF_STATIC_TLS;
 678           /* Fall through */
 679
 680         case R_X86_64_GOT32:
 681         case R_X86_64_GOTPCREL:
 682         case R_X86_64_TLSGD:
 683           /* This symbol requires a global offset table entry.  */
 684           {
 685             int tls_type, old_tls_type;
 686
 687             switch (r_type)
 688               {
 689               default: tls_type = GOT_NORMAL; break;
 690               case R_X86_64_TLSGD: tls_type = GOT_TLS_GD; break;
 691               case R_X86_64_GOTTPOFF: tls_type = GOT_TLS_IE; break;
 692               }
 693
 694             if (h != NULL)
 695               {
 696                 h->got.refcount += 1;
 697                 old_tls_type = elf64_x86_64_hash_entry (h)->tls_type;
 698               }
 699             else
 700               {
 701                 bfd_signed_vma *local_got_refcounts;
 702
 703                 /* This is a global offset table entry for a local symbol.  */
 704                 local_got_refcounts = elf_local_got_refcounts (abfd);
 705                 if (local_got_refcounts == NULL)
 706                   {
 707                     bfd_size_type size;
 708
 709                     size = symtab_hdr->sh_info;
 710                     size *= sizeof (bfd_signed_vma) + sizeof (char);
 711                     local_got_refcounts = ((bfd_signed_vma *)
 712                                            bfd_zalloc (abfd, size));
 713                     if (local_got_refcounts == NULL)
 714                       return FALSE;
 715                     elf_local_got_refcounts (abfd) = local_got_refcounts;
 716                     elf64_x86_64_local_got_tls_type (abfd)
 717                       = (char *) (local_got_refcounts + symtab_hdr->sh_info);
 718                   }
 719                 local_got_refcounts[r_symndx] += 1;
 720                 old_tls_type
 721                   = elf64_x86_64_local_got_tls_type (abfd) [r_symndx];
 722               }
 723
 724             /* If a TLS symbol is accessed using IE at least once,
 725                there is no point to use dynamic model for it.  */
 726             if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN
 727                 && (old_tls_type != GOT_TLS_GD || tls_type != GOT_TLS_IE))
 728               {
 729                 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD)
 730                   tls_type = old_tls_type;
 731                 else
 732                   {
 733                     (*_bfd_error_handler)
 734                       (_("%B: %s' accessed both as normal and thread local symbol"),
 735                        abfd, h ? h->root.root.string : "<local>");
 736                     return FALSE;
 737                   }
 738               }
 739
 740             if (old_tls_type != tls_type)
 741               {
 742                 if (h != NULL)
 743                   elf64_x86_64_hash_entry (h)->tls_type = tls_type;
 744                 else
 745                   elf64_x86_64_local_got_tls_type (abfd) [r_symndx] = tls_type;
 746               }
 747           }
 748           /* Fall through */
 749
 750           //case R_X86_64_GOTPCREL:
 751         create_got:
 752           if (htab->sgot == NULL)
 753             {
 754               if (htab->elf.dynobj == NULL)
 755                 htab->elf.dynobj = abfd;
 756               if (!create_got_section (htab->elf.dynobj, info))
 757                 return FALSE;
 758             }
 759           break;
 760
 761         case R_X86_64_PLT32:
 762           /* This symbol requires a procedure linkage table entry.  We
 763              actually build the entry in adjust_dynamic_symbol,
 764              because this might be a case of linking PIC code which is
 765              never referenced by a dynamic object, in which case we
 766              don't need to generate a procedure linkage table entry
 767              after all.  */
 768
 769           /* If this is a local symbol, we resolve it directly without
 770              creating a procedure linkage table entry.  */
 771           if (h == NULL)
 772             continue;
 773
 774           h->needs_plt = 1;
 775           h->plt.refcount += 1;
 776           break;
 777
 778         case R_X86_64_8:
 779         case R_X86_64_16:
 780         case R_X86_64_32:
 781         case R_X86_64_32S:
 782           /* Let's help debug shared library creation.  These relocs
 783              cannot be used in shared libs.  Don't error out for
 784              sections we don't care about, such as debug sections or
 785              non-constant sections.  */
 786           if (info->shared
 787               && (sec->flags & SEC_ALLOC) != 0
 788               && (sec->flags & SEC_READONLY) != 0)
 789             {
 790               (*_bfd_error_handler)
 791                 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
 792                  abfd,
 793                  x86_64_elf_howto_table[r_type].name,
 794                  (h) ? h->root.root.string : "a local symbol");
 795               bfd_set_error (bfd_error_bad_value);
 796               return FALSE;
 797             }
 798           /* Fall through.  */
 799
 800         case R_X86_64_PC8:
 801         case R_X86_64_PC16:
 802         case R_X86_64_PC32:
 803         case R_X86_64_64:
 804           if (h != NULL && !info->shared)
 805             {
 806               /* If this reloc is in a read-only section, we might
 807                  need a copy reloc.  We can't check reliably at this
 808                  stage whether the section is read-only, as input
 809                  sections have not yet been mapped to output sections.
 810                  Tentatively set the flag for now, and correct in
 811                  adjust_dynamic_symbol.  */
 812               h->non_got_ref = 1;
 813
 814               /* We may need a .plt entry if the function this reloc
 815                  refers to is in a shared lib.  */
 816               h->plt.refcount += 1;
 817               if (r_type != R_X86_64_PC32)
 818                 h->pointer_equality_needed = 1;
 819             }
 820
 821           /* If we are creating a shared library, and this is a reloc
 822              against a global symbol, or a non PC relative reloc
 823              against a local symbol, then we need to copy the reloc
 824              into the shared library.  However, if we are linking with
 825              -Bsymbolic, we do not need to copy a reloc against a
 826              global symbol which is defined in an object we are
 827              including in the link (i.e., DEF_REGULAR is set).  At
 828              this point we have not seen all the input files, so it is
 829              possible that DEF_REGULAR is not set now but will be set
 830              later (it is never cleared).  In case of a weak definition,
 831              DEF_REGULAR may be cleared later by a strong definition in
 832              a shared library.  We account for that possibility below by
 833              storing information in the relocs_copied field of the hash
 834              table entry.  A similar situation occurs when creating
 835              shared libraries and symbol visibility changes render the
 836              symbol local.
 837
 838              If on the other hand, we are creating an executable, we
 839              may need to keep relocations for symbols satisfied by a
 840              dynamic library if we manage to avoid copy relocs for the
 841              symbol.  */
 842           if ((info->shared
 843                && (sec->flags & SEC_ALLOC) != 0
 844                && (((r_type != R_X86_64_PC8)
 845                     && (r_type != R_X86_64_PC16)
 846                     && (r_type != R_X86_64_PC32))
 847                    || (h != NULL
 848                        && (! info->symbolic
 849                            || h->root.type == bfd_link_hash_defweak
 850                            || !h->def_regular))))
 851               || (ELIMINATE_COPY_RELOCS
 852                   && !info->shared
 853                   && (sec->flags & SEC_ALLOC) != 0
 854                   && h != NULL
 855                   && (h->root.type == bfd_link_hash_defweak
 856                       || !h->def_regular)))
 857             {
 858               struct elf64_x86_64_dyn_relocs *p;
 859               struct elf64_x86_64_dyn_relocs **head;
 860
 861               /* We must copy these reloc types into the output file.
 862                  Create a reloc section in dynobj and make room for
 863                  this reloc.  */
 864               if (sreloc == NULL)
 865                 {
 866                   const char *name;
 867                   bfd *dynobj;
 868
 869                   name = (bfd_elf_string_from_elf_section
 870                           (abfd,
 871                            elf_elfheader (abfd)->e_shstrndx,
 872                            elf_section_data (sec)->rel_hdr.sh_name));
 873                   if (name == NULL)
 874                     return FALSE;
 875
 876                   if (strncmp (name, ".rela", 5) != 0
 877                       || strcmp (bfd_get_section_name (abfd, sec),
 878                                  name + 5) != 0)
 879                     {
 880                       (*_bfd_error_handler)
 881                         (_("%B: bad relocation section name `%s\'"),
 882                          abfd, name);
 883                     }
 884
 885                   if (htab->elf.dynobj == NULL)
 886                     htab->elf.dynobj = abfd;
 887
 888                   dynobj = htab->elf.dynobj;
 889
 890                   sreloc = bfd_get_section_by_name (dynobj, name);
 891                   if (sreloc == NULL)
 892                     {
 893                       flagword flags;
 894
 895                       sreloc = bfd_make_section (dynobj, name);
 896                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
 897                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
 898                       if ((sec->flags & SEC_ALLOC) != 0)
 899                         flags |= SEC_ALLOC | SEC_LOAD;
 900                       if (sreloc == NULL
 901                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
 902                           || ! bfd_set_section_alignment (dynobj, sreloc, 3))
 903                         return FALSE;
 904                     }
 905                   elf_section_data (sec)->sreloc = sreloc;
 906                 }
 907
 908               /* If this is a global symbol, we count the number of
 909                  relocations we need for this symbol.  */
 910               if (h != NULL)
 911                 {
 912                   head = &((struct elf64_x86_64_link_hash_entry *) h)->dyn_relocs;
 913                 }
 914               else
 915                 {
 916                   /* Track dynamic relocs needed for local syms too.
 917                      We really need local syms available to do this
 918                      easily.  Oh well.  */
 919
 920                   asection *s;
 921                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
 922                                                  sec, r_symndx);
 923                   if (s == NULL)
 924                     return FALSE;
 925
 926                   head = ((struct elf64_x86_64_dyn_relocs **)
 927                           &elf_section_data (s)->local_dynrel);
 928                 }
 929
 930               p = *head;
 931               if (p == NULL || p->sec != sec)
 932                 {
 933                   bfd_size_type amt = sizeof *p;
 934                   p = ((struct elf64_x86_64_dyn_relocs *)
 935                        bfd_alloc (htab->elf.dynobj, amt));
 936                   if (p == NULL)
 937                     return FALSE;
 938                   p->next = *head;
 939                   *head = p;
 940                   p->sec = sec;
 941                   p->count = 0;
 942                   p->pc_count = 0;
 943                 }
 944
 945               p->count += 1;
 946               if (r_type == R_X86_64_PC8
 947                   || r_type == R_X86_64_PC16
 948                   || r_type == R_X86_64_PC32)
 949                 p->pc_count += 1;
 950             }
 951           break;
 952
 953           /* This relocation describes the C++ object vtable hierarchy.
 954              Reconstruct it for later use during GC.  */
 955         case R_X86_64_GNU_VTINHERIT:
 956           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 957             return FALSE;
 958           break;
 959
 960           /* This relocation describes which C++ vtable entries are actually
 961              used.  Record for later use during GC.  */
 962         case R_X86_64_GNU_VTENTRY:
 963           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
 964             return FALSE;
 965           break;
 966
 967         default:
 968           break;
 969         }
 970     }
 971
 972   return TRUE;
 973 }
 974
 975 /* Return the section that should be marked against GC for a given
 976    relocation.  */
 977
 978 static asection *
 979 elf64_x86_64_gc_mark_hook (asection *sec,
 980                            struct bfd_link_info *info ATTRIBUTE_UNUSED,
 981                            Elf_Internal_Rela *rel,
 982                            struct elf_link_hash_entry *h,
 983                            Elf_Internal_Sym *sym)
 984 {
 985   if (h != NULL)
 986     {
 987       switch (ELF64_R_TYPE (rel->r_info))
 988         {
 989         case R_X86_64_GNU_VTINHERIT:
 990         case R_X86_64_GNU_VTENTRY:
 991           break;
 992
 993         default:
 994           switch (h->root.type)
 995             {
 996             case bfd_link_hash_defined:
 997             case bfd_link_hash_defweak:
 998               return h->root.u.def.section;
 999
1000             case bfd_link_hash_common:
1001               return h->root.u.c.p->section;
1002
1003             default:
1004               break;
1005             }
1006         }
1007     }
1008   else
1009     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1010
1011   return NULL;
1012 }
1013
1014 /* Update the got entry reference counts for the section being removed.  */
1015
1016 static bfd_boolean
1017 elf64_x86_64_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info,
1018                             asection *sec, const Elf_Internal_Rela *relocs)
1019 {
1020   Elf_Internal_Shdr *symtab_hdr;
1021   struct elf_link_hash_entry **sym_hashes;
1022   bfd_signed_vma *local_got_refcounts;
1023   const Elf_Internal_Rela *rel, *relend;
1024
1025   elf_section_data (sec)->local_dynrel = NULL;
1026
1027   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1028   sym_hashes = elf_sym_hashes (abfd);
1029   local_got_refcounts = elf_local_got_refcounts (abfd);
1030
1031   relend = relocs + sec->reloc_count;
1032   for (rel = relocs; rel < relend; rel++)
1033     {
1034       unsigned long r_symndx;
1035       unsigned int r_type;
1036       struct elf_link_hash_entry *h = NULL;
1037
1038       r_symndx = ELF64_R_SYM (rel->r_info);
1039       if (r_symndx >= symtab_hdr->sh_info)
1040         {
1041           struct elf64_x86_64_link_hash_entry *eh;
1042           struct elf64_x86_64_dyn_relocs **pp;
1043           struct elf64_x86_64_dyn_relocs *p;
1044
1045           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1046           eh = (struct elf64_x86_64_link_hash_entry *) h;
1047
1048           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1049             if (p->sec == sec)
1050               {
1051                 /* Everything must go for SEC.  */
1052                 *pp = p->next;
1053                 break;
1054               }
1055         }
1056
1057       r_type = ELF64_R_TYPE (rel->r_info);
1058       r_type = elf64_x86_64_tls_transition (info, r_type, h != NULL);
1059       switch (r_type)
1060         {
1061         case R_X86_64_TLSLD:
1062           if (elf64_x86_64_hash_table (info)->tls_ld_got.refcount > 0)
1063             elf64_x86_64_hash_table (info)->tls_ld_got.refcount -= 1;
1064           break;
1065
1066         case R_X86_64_TLSGD:
1067         case R_X86_64_GOTTPOFF:
1068         case R_X86_64_GOT32:
1069         case R_X86_64_GOTPCREL:
1070           if (h != NULL)
1071             {
1072               if (h->got.refcount > 0)
1073                 h->got.refcount -= 1;
1074             }
1075           else if (local_got_refcounts != NULL)
1076             {
1077               if (local_got_refcounts[r_symndx] > 0)
1078                 local_got_refcounts[r_symndx] -= 1;
1079             }
1080           break;
1081
1082         case R_X86_64_8:
1083         case R_X86_64_16:
1084         case R_X86_64_32:
1085         case R_X86_64_64:
1086         case R_X86_64_32S:
1087         case R_X86_64_PC8:
1088         case R_X86_64_PC16:
1089         case R_X86_64_PC32:
1090           if (info->shared)
1091             break;
1092           /* Fall thru */
1093
1094         case R_X86_64_PLT32:
1095           if (h != NULL)
1096             {
1097               if (h->plt.refcount > 0)
1098                 h->plt.refcount -= 1;
1099             }
1100           break;
1101
1102         default:
1103           break;
1104         }
1105     }
1106
1107   return TRUE;
1108 }
1109
1110 /* Adjust a symbol defined by a dynamic object and referenced by a
1111    regular object.  The current definition is in some section of the
1112    dynamic object, but we're not including those sections.  We have to
1113    change the definition to something the rest of the link can
1114    understand.  */
1115
1116 static bfd_boolean
1117 elf64_x86_64_adjust_dynamic_symbol (struct bfd_link_info *info,
1118                                     struct elf_link_hash_entry *h)
1119 {
1120   struct elf64_x86_64_link_hash_table *htab;
1121   asection *s;
1122   unsigned int power_of_two;
1123
1124   /* If this is a function, put it in the procedure linkage table.  We
1125      will fill in the contents of the procedure linkage table later,
1126      when we know the address of the .got section.  */
1127   if (h->type == STT_FUNC
1128       || h->needs_plt)
1129     {
1130       if (h->plt.refcount <= 0
1131           || SYMBOL_CALLS_LOCAL (info, h)
1132           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1133               && h->root.type == bfd_link_hash_undefweak))
1134         {
1135           /* This case can occur if we saw a PLT32 reloc in an input
1136              file, but the symbol was never referred to by a dynamic
1137              object, or if all references were garbage collected.  In
1138              such a case, we don't actually need to build a procedure
1139              linkage table, and we can just do a PC32 reloc instead.  */
1140           h->plt.offset = (bfd_vma) -1;
1141           h->needs_plt = 0;
1142         }
1143
1144       return TRUE;
1145     }
1146   else
1147     /* It's possible that we incorrectly decided a .plt reloc was
1148        needed for an R_X86_64_PC32 reloc to a non-function sym in
1149        check_relocs.  We can't decide accurately between function and
1150        non-function syms in check-relocs;  Objects loaded later in
1151        the link may change h->type.  So fix it now.  */
1152     h->plt.offset = (bfd_vma) -1;
1153
1154   /* If this is a weak symbol, and there is a real definition, the
1155      processor independent code will have arranged for us to see the
1156      real definition first, and we can just use the same value.  */
1157   if (h->u.weakdef != NULL)
1158     {
1159       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1160                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1161       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1162       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1163       if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1164         h->non_got_ref = h->u.weakdef->non_got_ref;
1165       return TRUE;
1166     }
1167
1168   /* This is a reference to a symbol defined by a dynamic object which
1169      is not a function.  */
1170
1171   /* If we are creating a shared library, we must presume that the
1172      only references to the symbol are via the global offset table.
1173      For such cases we need not do anything here; the relocations will
1174      be handled correctly by relocate_section.  */
1175   if (info->shared)
1176     return TRUE;
1177
1178   /* If there are no references to this symbol that do not use the
1179      GOT, we don't need to generate a copy reloc.  */
1180   if (!h->non_got_ref)
1181     return TRUE;
1182
1183   /* If -z nocopyreloc was given, we won't generate them either.  */
1184   if (info->nocopyreloc)
1185     {
1186       h->non_got_ref = 0;
1187       return TRUE;
1188     }
1189
1190   if (ELIMINATE_COPY_RELOCS)
1191     {
1192       struct elf64_x86_64_link_hash_entry * eh;
1193       struct elf64_x86_64_dyn_relocs *p;
1194
1195       eh = (struct elf64_x86_64_link_hash_entry *) h;
1196       for (p = eh->dyn_relocs; p != NULL; p = p->next)
1197         {
1198           s = p->sec->output_section;
1199           if (s != NULL && (s->flags & SEC_READONLY) != 0)
1200             break;
1201         }
1202
1203       /* If we didn't find any dynamic relocs in read-only sections, then
1204          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
1205       if (p == NULL)
1206         {
1207           h->non_got_ref = 0;
1208           return TRUE;
1209         }
1210     }
1211
1212   /* We must allocate the symbol in our .dynbss section, which will
1213      become part of the .bss section of the executable.  There will be
1214      an entry for this symbol in the .dynsym section.  The dynamic
1215      object will contain position independent code, so all references
1216      from the dynamic object to this symbol will go through the global
1217      offset table.  The dynamic linker will use the .dynsym entry to
1218      determine the address it must put in the global offset table, so
1219      both the dynamic object and the regular object will refer to the
1220      same memory location for the variable.  */
1221
1222   htab = elf64_x86_64_hash_table (info);
1223
1224   /* We must generate a R_X86_64_COPY reloc to tell the dynamic linker
1225      to copy the initial value out of the dynamic object and into the
1226      runtime process image.  */
1227   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1228     {
1229       htab->srelbss->size += sizeof (Elf64_External_Rela);
1230       h->needs_copy = 1;
1231     }
1232
1233   /* We need to figure out the alignment required for this symbol.  I
1234      have no idea how ELF linkers handle this.  16-bytes is the size
1235      of the largest type that requires hard alignment -- long double.  */
1236   /* FIXME: This is VERY ugly. Should be fixed for all architectures using
1237      this construct.  */
1238   power_of_two = bfd_log2 (h->size);
1239   if (power_of_two > 4)
1240     power_of_two = 4;
1241
1242   /* Apply the required alignment.  */
1243   s = htab->sdynbss;
1244   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
1245   if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
1246     {
1247       if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
1248         return FALSE;
1249     }
1250
1251   /* Define the symbol as being at this point in the section.  */
1252   h->root.u.def.section = s;
1253   h->root.u.def.value = s->size;
1254
1255   /* Increment the section size to make room for the symbol.  */
1256   s->size += h->size;
1257
1258   return TRUE;
1259 }
1260
1261 /* Allocate space in .plt, .got and associated reloc sections for
1262    dynamic relocs.  */
1263
1264 static bfd_boolean
1265 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1266 {
1267   struct bfd_link_info *info;
1268   struct elf64_x86_64_link_hash_table *htab;
1269   struct elf64_x86_64_link_hash_entry *eh;
1270   struct elf64_x86_64_dyn_relocs *p;
1271
1272   if (h->root.type == bfd_link_hash_indirect)
1273     return TRUE;
1274
1275   if (h->root.type == bfd_link_hash_warning)
1276     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1277
1278   info = (struct bfd_link_info *) inf;
1279   htab = elf64_x86_64_hash_table (info);
1280
1281   if (htab->elf.dynamic_sections_created
1282       && h->plt.refcount > 0)
1283     {
1284       /* Make sure this symbol is output as a dynamic symbol.
1285          Undefined weak syms won't yet be marked as dynamic.  */
1286       if (h->dynindx == -1
1287           && !h->forced_local)
1288         {
1289           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1290             return FALSE;
1291         }
1292
1293       if (info->shared
1294           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1295         {
1296           asection *s = htab->splt;
1297
1298           /* If this is the first .plt entry, make room for the special
1299              first entry.  */
1300           if (s->size == 0)
1301             s->size += PLT_ENTRY_SIZE;
1302
1303           h->plt.offset = s->size;
1304
1305           /* If this symbol is not defined in a regular file, and we are
1306              not generating a shared library, then set the symbol to this
1307              location in the .plt.  This is required to make function
1308              pointers compare as equal between the normal executable and
1309              the shared library.  */
1310           if (! info->shared
1311               && !h->def_regular)
1312             {
1313               h->root.u.def.section = s;
1314               h->root.u.def.value = h->plt.offset;
1315             }
1316
1317           /* Make room for this entry.  */
1318           s->size += PLT_ENTRY_SIZE;
1319
1320           /* We also need to make an entry in the .got.plt section, which
1321              will be placed in the .got section by the linker script.  */
1322           htab->sgotplt->size += GOT_ENTRY_SIZE;
1323
1324           /* We also need to make an entry in the .rela.plt section.  */
1325           htab->srelplt->size += sizeof (Elf64_External_Rela);
1326         }
1327       else
1328         {
1329           h->plt.offset = (bfd_vma) -1;
1330           h->needs_plt = 0;
1331         }
1332     }
1333   else
1334     {
1335       h->plt.offset = (bfd_vma) -1;
1336       h->needs_plt = 0;
1337     }
1338
1339   /* If R_X86_64_GOTTPOFF symbol is now local to the binary,
1340      make it a R_X86_64_TPOFF32 requiring no GOT entry.  */
1341   if (h->got.refcount > 0
1342       && !info->shared
1343       && h->dynindx == -1
1344       && elf64_x86_64_hash_entry (h)->tls_type == GOT_TLS_IE)
1345     h->got.offset = (bfd_vma) -1;
1346   else if (h->got.refcount > 0)
1347     {
1348       asection *s;
1349       bfd_boolean dyn;
1350       int tls_type = elf64_x86_64_hash_entry (h)->tls_type;
1351
1352       /* Make sure this symbol is output as a dynamic symbol.
1353          Undefined weak syms won't yet be marked as dynamic.  */
1354       if (h->dynindx == -1
1355           && !h->forced_local)
1356         {
1357           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1358             return FALSE;
1359         }
1360
1361       s = htab->sgot;
1362       h->got.offset = s->size;
1363       s->size += GOT_ENTRY_SIZE;
1364       /* R_X86_64_TLSGD needs 2 consecutive GOT slots.  */
1365       if (tls_type == GOT_TLS_GD)
1366         s->size += GOT_ENTRY_SIZE;
1367       dyn = htab->elf.dynamic_sections_created;
1368       /* R_X86_64_TLSGD needs one dynamic relocation if local symbol
1369          and two if global.
1370          R_X86_64_GOTTPOFF needs one dynamic relocation.  */
1371       if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1372           || tls_type == GOT_TLS_IE)
1373         htab->srelgot->size += sizeof (Elf64_External_Rela);
1374       else if (tls_type == GOT_TLS_GD)
1375         htab->srelgot->size += 2 * sizeof (Elf64_External_Rela);
1376       else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1377                 || h->root.type != bfd_link_hash_undefweak)
1378                && (info->shared
1379                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1380         htab->srelgot->size += sizeof (Elf64_External_Rela);
1381     }
1382   else
1383     h->got.offset = (bfd_vma) -1;
1384
1385   eh = (struct elf64_x86_64_link_hash_entry *) h;
1386   if (eh->dyn_relocs == NULL)
1387     return TRUE;
1388
1389   /* In the shared -Bsymbolic case, discard space allocated for
1390      dynamic pc-relative relocs against symbols which turn out to be
1391      defined in regular objects.  For the normal shared case, discard
1392      space for pc-relative relocs that have become local due to symbol
1393      visibility changes.  */
1394
1395   if (info->shared)
1396     {
1397       /* Relocs that use pc_count are those that appear on a call
1398          insn, or certain REL relocs that can generated via assembly.
1399          We want calls to protected symbols to resolve directly to the
1400          function rather than going via the plt.  If people want
1401          function pointer comparisons to work as expected then they
1402          should avoid writing weird assembly.  */
1403       if (SYMBOL_CALLS_LOCAL (info, h))
1404         {
1405           struct elf64_x86_64_dyn_relocs **pp;
1406
1407           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1408             {
1409               p->count -= p->pc_count;
1410               p->pc_count = 0;
1411               if (p->count == 0)
1412                 *pp = p->next;
1413               else
1414                 pp = &p->next;
1415             }
1416         }
1417
1418       /* Also discard relocs on undefined weak syms with non-default
1419          visibility.  */
1420       if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1421           && h->root.type == bfd_link_hash_undefweak)
1422         eh->dyn_relocs = NULL;
1423     }
1424   else if (ELIMINATE_COPY_RELOCS)
1425     {
1426       /* For the non-shared case, discard space for relocs against
1427          symbols which turn out to need copy relocs or are not
1428          dynamic.  */
1429
1430       if (!h->non_got_ref
1431           && ((h->def_dynamic
1432                && !h->def_regular)
1433               || (htab->elf.dynamic_sections_created
1434                   && (h->root.type == bfd_link_hash_undefweak
1435                       || h->root.type == bfd_link_hash_undefined))))
1436         {
1437           /* Make sure this symbol is output as a dynamic symbol.
1438              Undefined weak syms won't yet be marked as dynamic.  */
1439           if (h->dynindx == -1
1440               && !h->forced_local)
1441             {
1442               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1443                 return FALSE;
1444             }
1445
1446           /* If that succeeded, we know we'll be keeping all the
1447              relocs.  */
1448           if (h->dynindx != -1)
1449             goto keep;
1450         }
1451
1452       eh->dyn_relocs = NULL;
1453
1454     keep: ;
1455     }
1456
1457   /* Finally, allocate space.  */
1458   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1459     {
1460       asection *sreloc = elf_section_data (p->sec)->sreloc;
1461       sreloc->size += p->count * sizeof (Elf64_External_Rela);
1462     }
1463
1464   return TRUE;
1465 }
1466
1467 /* Find any dynamic relocs that apply to read-only sections.  */
1468
1469 static bfd_boolean
1470 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1471 {
1472   struct elf64_x86_64_link_hash_entry *eh;
1473   struct elf64_x86_64_dyn_relocs *p;
1474
1475   if (h->root.type == bfd_link_hash_warning)
1476     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1477
1478   eh = (struct elf64_x86_64_link_hash_entry *) h;
1479   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1480     {
1481       asection *s = p->sec->output_section;
1482
1483       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1484         {
1485           struct bfd_link_info *info = (struct bfd_link_info *) inf;
1486
1487           info->flags |= DF_TEXTREL;
1488
1489           /* Not an error, just cut short the traversal.  */
1490           return FALSE;
1491         }
1492     }
1493   return TRUE;
1494 }
1495
1496 /* Set the sizes of the dynamic sections.  */
1497
1498 static bfd_boolean
1499 elf64_x86_64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1500                                     struct bfd_link_info *info)
1501 {
1502   struct elf64_x86_64_link_hash_table *htab;
1503   bfd *dynobj;
1504   asection *s;
1505   bfd_boolean relocs;
1506   bfd *ibfd;
1507
1508   htab = elf64_x86_64_hash_table (info);
1509   dynobj = htab->elf.dynobj;
1510   if (dynobj == NULL)
1511     abort ();
1512
1513   if (htab->elf.dynamic_sections_created)
1514     {
1515       /* Set the contents of the .interp section to the interpreter.  */
1516       if (info->executable)
1517         {
1518           s = bfd_get_section_by_name (dynobj, ".interp");
1519           if (s == NULL)
1520             abort ();
1521           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1522           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1523         }
1524     }
1525
1526   /* Set up .got offsets for local syms, and space for local dynamic
1527      relocs.  */
1528   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1529     {
1530       bfd_signed_vma *local_got;
1531       bfd_signed_vma *end_local_got;
1532       char *local_tls_type;
1533       bfd_size_type locsymcount;
1534       Elf_Internal_Shdr *symtab_hdr;
1535       asection *srel;
1536
1537       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1538         continue;
1539
1540       for (s = ibfd->sections; s != NULL; s = s->next)
1541         {
1542           struct elf64_x86_64_dyn_relocs *p;
1543
1544           for (p = *((struct elf64_x86_64_dyn_relocs **)
1545                      &elf_section_data (s)->local_dynrel);
1546                p != NULL;
1547                p = p->next)
1548             {
1549               if (!bfd_is_abs_section (p->sec)
1550                   && bfd_is_abs_section (p->sec->output_section))
1551                 {
1552                   /* Input section has been discarded, either because
1553                      it is a copy of a linkonce section or due to
1554                      linker script /DISCARD/, so we'll be discarding
1555                      the relocs too.  */
1556                 }
1557               else if (p->count != 0)
1558                 {
1559                   srel = elf_section_data (p->sec)->sreloc;
1560                   srel->size += p->count * sizeof (Elf64_External_Rela);
1561                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1562                     info->flags |= DF_TEXTREL;
1563
1564                 }
1565             }
1566         }
1567
1568       local_got = elf_local_got_refcounts (ibfd);
1569       if (!local_got)
1570         continue;
1571
1572       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1573       locsymcount = symtab_hdr->sh_info;
1574       end_local_got = local_got + locsymcount;
1575       local_tls_type = elf64_x86_64_local_got_tls_type (ibfd);
1576       s = htab->sgot;
1577       srel = htab->srelgot;
1578       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1579         {
1580           if (*local_got > 0)
1581             {
1582               *local_got = s->size;
1583               s->size += GOT_ENTRY_SIZE;
1584               if (*local_tls_type == GOT_TLS_GD)
1585                 s->size += GOT_ENTRY_SIZE;
1586               if (info->shared
1587                   || *local_tls_type == GOT_TLS_GD
1588                   || *local_tls_type == GOT_TLS_IE)
1589                 srel->size += sizeof (Elf64_External_Rela);
1590             }
1591           else
1592             *local_got = (bfd_vma) -1;
1593         }
1594     }
1595
1596   if (htab->tls_ld_got.refcount > 0)
1597     {
1598       /* Allocate 2 got entries and 1 dynamic reloc for R_X86_64_TLSLD
1599          relocs.  */
1600       htab->tls_ld_got.offset = htab->sgot->size;
1601       htab->sgot->size += 2 * GOT_ENTRY_SIZE;
1602       htab->srelgot->size += sizeof (Elf64_External_Rela);
1603     }
1604   else
1605     htab->tls_ld_got.offset = -1;
1606
1607   /* Allocate global sym .plt and .got entries, and space for global
1608      sym dynamic relocs.  */
1609   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
1610
1611   /* We now have determined the sizes of the various dynamic sections.
1612      Allocate memory for them.  */
1613   relocs = FALSE;
1614   for (s = dynobj->sections; s != NULL; s = s->next)
1615     {
1616       if ((s->flags & SEC_LINKER_CREATED) == 0)
1617         continue;
1618
1619       if (s == htab->splt
1620           || s == htab->sgot
1621           || s == htab->sgotplt)
1622         {
1623           /* Strip this section if we don't need it; see the
1624              comment below.  */
1625         }
1626       else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
1627         {
1628           if (s->size != 0 && s != htab->srelplt)
1629             relocs = TRUE;
1630
1631           /* We use the reloc_count field as a counter if we need
1632              to copy relocs into the output file.  */
1633           s->reloc_count = 0;
1634         }
1635       else
1636         {
1637           /* It's not one of our sections, so don't allocate space.  */
1638           continue;
1639         }
1640
1641       if (s->size == 0)
1642         {
1643           /* If we don't need this section, strip it from the
1644              output file.  This is mostly to handle .rela.bss and
1645              .rela.plt.  We must create both sections in
1646              create_dynamic_sections, because they must be created
1647              before the linker maps input sections to output
1648              sections.  The linker does that before
1649              adjust_dynamic_symbol is called, and it is that
1650              function which decides whether anything needs to go
1651              into these sections.  */
1652
1653           _bfd_strip_section_from_output (info, s);
1654           continue;
1655         }
1656
1657       /* Allocate memory for the section contents.  We use bfd_zalloc
1658          here in case unused entries are not reclaimed before the
1659          section's contents are written out.  This should not happen,
1660          but this way if it does, we get a R_X86_64_NONE reloc instead
1661          of garbage.  */
1662       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1663       if (s->contents == NULL)
1664         return FALSE;
1665     }
1666
1667   if (htab->elf.dynamic_sections_created)
1668     {
1669       /* Add some entries to the .dynamic section.  We fill in the
1670          values later, in elf64_x86_64_finish_dynamic_sections, but we
1671          must add the entries now so that we get the correct size for
1672          the .dynamic section.  The DT_DEBUG entry is filled in by the
1673          dynamic linker and used by the debugger.  */
1674 #define add_dynamic_entry(TAG, VAL) \
1675   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1676
1677       if (info->executable)
1678         {
1679           if (!add_dynamic_entry (DT_DEBUG, 0))
1680             return FALSE;
1681         }
1682
1683       if (htab->splt->size != 0)
1684         {
1685           if (!add_dynamic_entry (DT_PLTGOT, 0)
1686               || !add_dynamic_entry (DT_PLTRELSZ, 0)
1687               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1688               || !add_dynamic_entry (DT_JMPREL, 0))
1689             return FALSE;
1690         }
1691
1692       if (relocs)
1693         {
1694           if (!add_dynamic_entry (DT_RELA, 0)
1695               || !add_dynamic_entry (DT_RELASZ, 0)
1696               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
1697             return FALSE;
1698
1699           /* If any dynamic relocs apply to a read-only section,
1700              then we need a DT_TEXTREL entry.  */
1701           if ((info->flags & DF_TEXTREL) == 0)
1702             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
1703                                     (PTR) info);
1704
1705           if ((info->flags & DF_TEXTREL) != 0)
1706             {
1707               if (!add_dynamic_entry (DT_TEXTREL, 0))
1708                 return FALSE;
1709             }
1710         }
1711     }
1712 #undef add_dynamic_entry
1713
1714   return TRUE;
1715 }
1716
1717 /* Return the base VMA address which should be subtracted from real addresses
1718    when resolving @dtpoff relocation.
1719    This is PT_TLS segment p_vaddr.  */
1720
1721 static bfd_vma
1722 dtpoff_base (struct bfd_link_info *info)
1723 {
1724   /* If tls_sec is NULL, we should have signalled an error already.  */
1725   if (elf_hash_table (info)->tls_sec == NULL)
1726     return 0;
1727   return elf_hash_table (info)->tls_sec->vma;
1728 }
1729
1730 /* Return the relocation value for @tpoff relocation
1731    if STT_TLS virtual address is ADDRESS.  */
1732
1733 static bfd_vma
1734 tpoff (struct bfd_link_info *info, bfd_vma address)
1735 {
1736   struct elf_link_hash_table *htab = elf_hash_table (info);
1737
1738   /* If tls_segment is NULL, we should have signalled an error already.  */
1739   if (htab->tls_sec == NULL)
1740     return 0;
1741   return address - htab->tls_size - htab->tls_sec->vma;
1742 }
1743
1744 /* Relocate an x86_64 ELF section.  */
1745
1746 static bfd_boolean
1747 elf64_x86_64_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
1748                                bfd *input_bfd, asection *input_section,
1749                                bfd_byte *contents, Elf_Internal_Rela *relocs,
1750                                Elf_Internal_Sym *local_syms,
1751                                asection **local_sections)
1752 {
1753   struct elf64_x86_64_link_hash_table *htab;
1754   Elf_Internal_Shdr *symtab_hdr;
1755   struct elf_link_hash_entry **sym_hashes;
1756   bfd_vma *local_got_offsets;
1757   Elf_Internal_Rela *rel;
1758   Elf_Internal_Rela *relend;
1759
1760   if (info->relocatable)
1761     return TRUE;
1762
1763   htab = elf64_x86_64_hash_table (info);
1764   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1765   sym_hashes = elf_sym_hashes (input_bfd);
1766   local_got_offsets = elf_local_got_offsets (input_bfd);
1767
1768   rel = relocs;
1769   relend = relocs + input_section->reloc_count;
1770   for (; rel < relend; rel++)
1771     {
1772       unsigned int r_type;
1773       reloc_howto_type *howto;
1774       unsigned long r_symndx;
1775       struct elf_link_hash_entry *h;
1776       Elf_Internal_Sym *sym;
1777       asection *sec;
1778       bfd_vma off;
1779       bfd_vma relocation;
1780       bfd_boolean unresolved_reloc;
1781       bfd_reloc_status_type r;
1782       int tls_type;
1783
1784       r_type = ELF64_R_TYPE (rel->r_info);
1785       if (r_type == (int) R_X86_64_GNU_VTINHERIT
1786           || r_type == (int) R_X86_64_GNU_VTENTRY)
1787         continue;
1788
1789       if (r_type >= R_X86_64_max)
1790         {
1791           bfd_set_error (bfd_error_bad_value);
1792           return FALSE;
1793         }
1794
1795       howto = x86_64_elf_howto_table + r_type;
1796       r_symndx = ELF64_R_SYM (rel->r_info);
1797       h = NULL;
1798       sym = NULL;
1799       sec = NULL;
1800       unresolved_reloc = FALSE;
1801       if (r_symndx < symtab_hdr->sh_info)
1802         {
1803           sym = local_syms + r_symndx;
1804           sec = local_sections[r_symndx];
1805
1806           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1807         }
1808       else
1809         {
1810           bfd_boolean warned;
1811
1812           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1813                                    r_symndx, symtab_hdr, sym_hashes,
1814                                    h, sec, relocation,
1815                                    unresolved_reloc, warned);
1816         }
1817       /* When generating a shared object, the relocations handled here are
1818          copied into the output file to be resolved at run time.  */
1819       switch (r_type)
1820         {
1821         case R_X86_64_GOT32:
1822           /* Relocation is to the entry for this symbol in the global
1823              offset table.  */
1824         case R_X86_64_GOTPCREL:
1825           /* Use global offset table as symbol value.  */
1826           if (htab->sgot == NULL)
1827             abort ();
1828
1829           if (h != NULL)
1830             {
1831               bfd_boolean dyn;
1832
1833               off = h->got.offset;
1834               dyn = htab->elf.dynamic_sections_created;
1835
1836               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
1837                   || (info->shared
1838                       && SYMBOL_REFERENCES_LOCAL (info, h))
1839                   || (ELF_ST_VISIBILITY (h->other)
1840                       && h->root.type == bfd_link_hash_undefweak))
1841                 {
1842                   /* This is actually a static link, or it is a -Bsymbolic
1843                      link and the symbol is defined locally, or the symbol
1844                      was forced to be local because of a version file.  We
1845                      must initialize this entry in the global offset table.
1846                      Since the offset must always be a multiple of 8, we
1847                      use the least significant bit to record whether we
1848                      have initialized it already.
1849
1850                      When doing a dynamic link, we create a .rela.got
1851                      relocation entry to initialize the value.  This is
1852                      done in the finish_dynamic_symbol routine.  */
1853                   if ((off & 1) != 0)
1854                     off &= ~1;
1855                   else
1856                     {
1857                       bfd_put_64 (output_bfd, relocation,
1858                                   htab->sgot->contents + off);
1859                       h->got.offset |= 1;
1860                     }
1861                 }
1862               else
1863                 unresolved_reloc = FALSE;
1864             }
1865           else
1866             {
1867               if (local_got_offsets == NULL)
1868                 abort ();
1869
1870               off = local_got_offsets[r_symndx];
1871
1872               /* The offset must always be a multiple of 8.  We use
1873                  the least significant bit to record whether we have
1874                  already generated the necessary reloc.  */
1875               if ((off & 1) != 0)
1876                 off &= ~1;
1877               else
1878                 {
1879                   bfd_put_64 (output_bfd, relocation,
1880                               htab->sgot->contents + off);
1881
1882                   if (info->shared)
1883                     {
1884                       asection *s;
1885                       Elf_Internal_Rela outrel;
1886                       bfd_byte *loc;
1887
1888                       /* We need to generate a R_X86_64_RELATIVE reloc
1889                          for the dynamic linker.  */
1890                       s = htab->srelgot;
1891                       if (s == NULL)
1892                         abort ();
1893
1894                       outrel.r_offset = (htab->sgot->output_section->vma
1895                                          + htab->sgot->output_offset
1896                                          + off);
1897                       outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
1898                       outrel.r_addend = relocation;
1899                       loc = s->contents;
1900                       loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
1901                       bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
1902                     }
1903
1904                   local_got_offsets[r_symndx] |= 1;
1905                 }
1906             }
1907
1908           if (off >= (bfd_vma) -2)
1909             abort ();
1910
1911           relocation = htab->sgot->output_section->vma
1912                        + htab->sgot->output_offset + off;
1913           if (r_type != R_X86_64_GOTPCREL)
1914             relocation -= htab->sgotplt->output_section->vma
1915                           - htab->sgotplt->output_offset;
1916
1917           break;
1918
1919         case R_X86_64_PLT32:
1920           /* Relocation is to the entry for this symbol in the
1921              procedure linkage table.  */
1922
1923           /* Resolve a PLT32 reloc against a local symbol directly,
1924              without using the procedure linkage table.  */
1925           if (h == NULL)
1926             break;
1927
1928           if (h->plt.offset == (bfd_vma) -1
1929               || htab->splt == NULL)
1930             {
1931               /* We didn't make a PLT entry for this symbol.  This
1932                  happens when statically linking PIC code, or when
1933                  using -Bsymbolic.  */
1934               break;
1935             }
1936
1937           relocation = (htab->splt->output_section->vma
1938                         + htab->splt->output_offset
1939                         + h->plt.offset);
1940           unresolved_reloc = FALSE;
1941           break;
1942
1943         case R_X86_64_PC8:
1944         case R_X86_64_PC16:
1945         case R_X86_64_PC32:
1946           if (info->shared
1947               && !SYMBOL_REFERENCES_LOCAL (info, h)
1948               && (input_section->flags & SEC_ALLOC) != 0
1949               && (input_section->flags & SEC_READONLY) != 0)
1950             {
1951               (*_bfd_error_handler)
1952                 (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1953                  input_bfd,
1954                  x86_64_elf_howto_table[r_type].name,
1955                  (h) ? h->root.root.string : "a local symbol");
1956               bfd_set_error (bfd_error_bad_value);
1957               return FALSE;
1958             }
1959           /* Fall through.  */
1960
1961         case R_X86_64_8:
1962         case R_X86_64_16:
1963         case R_X86_64_32:
1964         case R_X86_64_64:
1965           /* FIXME: The ABI says the linker should make sure the value is
1966              the same when it's zeroextended to 64 bit.  */
1967
1968           /* r_symndx will be zero only for relocs against symbols
1969              from removed linkonce sections, or sections discarded by
1970              a linker script.  */
1971           if (r_symndx == 0
1972               || (input_section->flags & SEC_ALLOC) == 0)
1973             break;
1974
1975           if ((info->shared
1976                && (h == NULL
1977                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1978                    || h->root.type != bfd_link_hash_undefweak)
1979                && ((r_type != R_X86_64_PC8
1980                     && r_type != R_X86_64_PC16
1981                     && r_type != R_X86_64_PC32)
1982                    || !SYMBOL_CALLS_LOCAL (info, h)))
1983               || (ELIMINATE_COPY_RELOCS
1984                   && !info->shared
1985                   && h != NULL
1986                   && h->dynindx != -1
1987                   && !h->non_got_ref
1988                   && ((h->def_dynamic
1989                        && !h->def_regular)
1990                       || h->root.type == bfd_link_hash_undefweak
1991                       || h->root.type == bfd_link_hash_undefined)))
1992             {
1993               Elf_Internal_Rela outrel;
1994               bfd_byte *loc;
1995               bfd_boolean skip, relocate;
1996               asection *sreloc;
1997
1998               /* When generating a shared object, these relocations
1999                  are copied into the output file to be resolved at run
2000                  time.  */
2001               skip = FALSE;
2002               relocate = FALSE;
2003
2004               outrel.r_offset =
2005                 _bfd_elf_section_offset (output_bfd, info, input_section,
2006                                          rel->r_offset);
2007               if (outrel.r_offset == (bfd_vma) -1)
2008                 skip = TRUE;
2009               else if (outrel.r_offset == (bfd_vma) -2)
2010                 skip = TRUE, relocate = TRUE;
2011
2012               outrel.r_offset += (input_section->output_section->vma
2013                                   + input_section->output_offset);
2014
2015               if (skip)
2016                 memset (&outrel, 0, sizeof outrel);
2017
2018               /* h->dynindx may be -1 if this symbol was marked to
2019                  become local.  */
2020               else if (h != NULL
2021                        && h->dynindx != -1
2022                        && (r_type == R_X86_64_PC8
2023                            || r_type == R_X86_64_PC16
2024                            || r_type == R_X86_64_PC32
2025                            || !info->shared
2026                            || !info->symbolic
2027                            || !h->def_regular))
2028                 {
2029                   outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
2030                   outrel.r_addend = rel->r_addend;
2031                 }
2032               else
2033                 {
2034                   /* This symbol is local, or marked to become local.  */
2035                   if (r_type == R_X86_64_64)
2036                     {
2037                       relocate = TRUE;
2038                       outrel.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
2039                       outrel.r_addend = relocation + rel->r_addend;
2040                     }
2041                   else
2042                     {
2043                       long sindx;
2044
2045                       if (bfd_is_abs_section (sec))
2046                         sindx = 0;
2047                       else if (sec == NULL || sec->owner == NULL)
2048                         {
2049                           bfd_set_error (bfd_error_bad_value);
2050                           return FALSE;
2051                         }
2052                       else
2053                         {
2054                           asection *osec;
2055
2056                           osec = sec->output_section;
2057                           sindx = elf_section_data (osec)->dynindx;
2058                           BFD_ASSERT (sindx > 0);
2059                         }
2060
2061                       outrel.r_info = ELF64_R_INFO (sindx, r_type);
2062                       outrel.r_addend = relocation + rel->r_addend;
2063                     }
2064                 }
2065
2066               sreloc = elf_section_data (input_section)->sreloc;
2067               if (sreloc == NULL)
2068                 abort ();
2069
2070               loc = sreloc->contents;
2071               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2072               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2073
2074               /* If this reloc is against an external symbol, we do
2075                  not want to fiddle with the addend.  Otherwise, we
2076                  need to include the symbol value so that it becomes
2077                  an addend for the dynamic reloc.  */
2078               if (! relocate)
2079                 continue;
2080             }
2081
2082           break;
2083
2084         case R_X86_64_TLSGD:
2085         case R_X86_64_GOTTPOFF:
2086           r_type = elf64_x86_64_tls_transition (info, r_type, h == NULL);
2087           tls_type = GOT_UNKNOWN;
2088           if (h == NULL && local_got_offsets)
2089             tls_type = elf64_x86_64_local_got_tls_type (input_bfd) [r_symndx];
2090           else if (h != NULL)
2091             {
2092               tls_type = elf64_x86_64_hash_entry (h)->tls_type;
2093               if (!info->shared && h->dynindx == -1 && tls_type == GOT_TLS_IE)
2094                 r_type = R_X86_64_TPOFF32;
2095             }
2096           if (r_type == R_X86_64_TLSGD)
2097             {
2098               if (tls_type == GOT_TLS_IE)
2099                 r_type = R_X86_64_GOTTPOFF;
2100             }
2101
2102           if (r_type == R_X86_64_TPOFF32)
2103             {
2104               BFD_ASSERT (! unresolved_reloc);
2105               if (ELF64_R_TYPE (rel->r_info) == R_X86_64_TLSGD)
2106                 {
2107                   unsigned int i;
2108                   static unsigned char tlsgd[8]
2109                     = { 0x66, 0x48, 0x8d, 0x3d, 0x66, 0x66, 0x48, 0xe8 };
2110
2111                   /* GD->LE transition.
2112                      .byte 0x66; leaq foo@tlsgd(%rip), %rdi
2113                      .word 0x6666; rex64; call __tls_get_addr@plt
2114                      Change it into:
2115                      movq %fs:0, %rax
2116                      leaq foo@tpoff(%rax), %rax */
2117                   BFD_ASSERT (rel->r_offset >= 4);
2118                   for (i = 0; i < 4; i++)
2119                     BFD_ASSERT (bfd_get_8 (input_bfd,
2120                                            contents + rel->r_offset - 4 + i)
2121                                 == tlsgd[i]);
2122                   BFD_ASSERT (rel->r_offset + 12 <= input_section->size);
2123                   for (i = 0; i < 4; i++)
2124                     BFD_ASSERT (bfd_get_8 (input_bfd,
2125                                            contents + rel->r_offset + 4 + i)
2126                                 == tlsgd[i+4]);
2127                   BFD_ASSERT (rel + 1 < relend);
2128                   BFD_ASSERT (ELF64_R_TYPE (rel[1].r_info) == R_X86_64_PLT32);
2129                   memcpy (contents + rel->r_offset - 4,
2130                           "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x8d\x80\0\0\0",
2131                           16);
2132                   bfd_put_32 (output_bfd, tpoff (info, relocation),
2133                               contents + rel->r_offset + 8);
2134                   /* Skip R_X86_64_PLT32.  */
2135                   rel++;
2136                   continue;
2137                 }
2138               else
2139                 {
2140                   unsigned int val, type, reg;
2141
2142                   /* IE->LE transition:
2143                      Originally it can be one of:
2144                      movq foo@gottpoff(%rip), %reg
2145                      addq foo@gottpoff(%rip), %reg
2146                      We change it into:
2147                      movq $foo, %reg
2148                      leaq foo(%reg), %reg
2149                      addq $foo, %reg.  */
2150                   BFD_ASSERT (rel->r_offset >= 3);
2151                   val = bfd_get_8 (input_bfd, contents + rel->r_offset - 3);
2152                   BFD_ASSERT (val == 0x48 || val == 0x4c);
2153                   type = bfd_get_8 (input_bfd, contents + rel->r_offset - 2);
2154                   BFD_ASSERT (type == 0x8b || type == 0x03);
2155                   reg = bfd_get_8 (input_bfd, contents + rel->r_offset - 1);
2156                   BFD_ASSERT ((reg & 0xc7) == 5);
2157                   reg >>= 3;
2158                   BFD_ASSERT (rel->r_offset + 4 <= input_section->size);
2159                   if (type == 0x8b)
2160                     {
2161                       /* movq */
2162                       if (val == 0x4c)
2163                         bfd_put_8 (output_bfd, 0x49,
2164                                    contents + rel->r_offset - 3);
2165                       bfd_put_8 (output_bfd, 0xc7,
2166                                  contents + rel->r_offset - 2);
2167                       bfd_put_8 (output_bfd, 0xc0 | reg,
2168                                  contents + rel->r_offset - 1);
2169                     }
2170                   else if (reg == 4)
2171                     {
2172                       /* addq -> addq - addressing with %rsp/%r12 is
2173                          special  */
2174                       if (val == 0x4c)
2175                         bfd_put_8 (output_bfd, 0x49,
2176                                    contents + rel->r_offset - 3);
2177                       bfd_put_8 (output_bfd, 0x81,
2178                                  contents + rel->r_offset - 2);
2179                       bfd_put_8 (output_bfd, 0xc0 | reg,
2180                                  contents + rel->r_offset - 1);
2181                     }
2182                   else
2183                     {
2184                       /* addq -> leaq */
2185                       if (val == 0x4c)
2186                         bfd_put_8 (output_bfd, 0x4d,
2187                                    contents + rel->r_offset - 3);
2188                       bfd_put_8 (output_bfd, 0x8d,
2189                                  contents + rel->r_offset - 2);
2190                       bfd_put_8 (output_bfd, 0x80 | reg | (reg << 3),
2191                                  contents + rel->r_offset - 1);
2192                     }
2193                   bfd_put_32 (output_bfd, tpoff (info, relocation),
2194                               contents + rel->r_offset);
2195                   continue;
2196                 }
2197             }
2198
2199           if (htab->sgot == NULL)
2200             abort ();
2201
2202           if (h != NULL)
2203             off = h->got.offset;
2204           else
2205             {
2206               if (local_got_offsets == NULL)
2207                 abort ();
2208
2209               off = local_got_offsets[r_symndx];
2210             }
2211
2212           if ((off & 1) != 0)
2213             off &= ~1;
2214           else
2215             {
2216               Elf_Internal_Rela outrel;
2217               bfd_byte *loc;
2218               int dr_type, indx;
2219
2220               if (htab->srelgot == NULL)
2221                 abort ();
2222
2223               outrel.r_offset = (htab->sgot->output_section->vma
2224                                  + htab->sgot->output_offset + off);
2225
2226               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2227               if (r_type == R_X86_64_TLSGD)
2228                 dr_type = R_X86_64_DTPMOD64;
2229               else
2230                 dr_type = R_X86_64_TPOFF64;
2231
2232               bfd_put_64 (output_bfd, 0, htab->sgot->contents + off);
2233               outrel.r_addend = 0;
2234               if (dr_type == R_X86_64_TPOFF64 && indx == 0)
2235                 outrel.r_addend = relocation - dtpoff_base (info);
2236               outrel.r_info = ELF64_R_INFO (indx, dr_type);
2237
2238               loc = htab->srelgot->contents;
2239               loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
2240               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2241
2242               if (r_type == R_X86_64_TLSGD)
2243                 {
2244                   if (indx == 0)
2245                     {
2246                       BFD_ASSERT (! unresolved_reloc);
2247                       bfd_put_64 (output_bfd,
2248                                   relocation - dtpoff_base (info),
2249                                   htab->sgot->contents + off + GOT_ENTRY_SIZE);
2250                     }
2251                   else
2252                     {
2253                       bfd_put_64 (output_bfd, 0,
2254                                   htab->sgot->contents + off + GOT_ENTRY_SIZE);
2255                       outrel.r_info = ELF64_R_INFO (indx,
2256                                                     R_X86_64_DTPOFF64);
2257                       outrel.r_offset += GOT_ENTRY_SIZE;
2258                       htab->srelgot->reloc_count++;
2259                       loc += sizeof (Elf64_External_Rela);
2260                       bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2261                     }
2262                 }
2263
2264               if (h != NULL)
2265                 h->got.offset |= 1;
2266               else
2267                 local_got_offsets[r_symndx] |= 1;
2268             }
2269
2270           if (off >= (bfd_vma) -2)
2271             abort ();
2272           if (r_type == ELF64_R_TYPE (rel->r_info))
2273             {
2274               relocation = htab->sgot->output_section->vma
2275                            + htab->sgot->output_offset + off;
2276               unresolved_reloc = FALSE;
2277             }
2278           else
2279             {
2280               unsigned int i;
2281               static unsigned char tlsgd[8]
2282                 = { 0x66, 0x48, 0x8d, 0x3d, 0x66, 0x66, 0x48, 0xe8 };
2283
2284               /* GD->IE transition.
2285                  .byte 0x66; leaq foo@tlsgd(%rip), %rdi
2286                  .word 0x6666; rex64; call __tls_get_addr@plt
2287                  Change it into:
2288                  movq %fs:0, %rax
2289                  addq foo@gottpoff(%rip), %rax */
2290               BFD_ASSERT (rel->r_offset >= 4);
2291               for (i = 0; i < 4; i++)
2292                 BFD_ASSERT (bfd_get_8 (input_bfd,
2293                                        contents + rel->r_offset - 4 + i)
2294                             == tlsgd[i]);
2295               BFD_ASSERT (rel->r_offset + 12 <= input_section->size);
2296               for (i = 0; i < 4; i++)
2297                 BFD_ASSERT (bfd_get_8 (input_bfd,
2298                                        contents + rel->r_offset + 4 + i)
2299                             == tlsgd[i+4]);
2300               BFD_ASSERT (rel + 1 < relend);
2301               BFD_ASSERT (ELF64_R_TYPE (rel[1].r_info) == R_X86_64_PLT32);
2302               memcpy (contents + rel->r_offset - 4,
2303                       "\x64\x48\x8b\x04\x25\0\0\0\0\x48\x03\x05\0\0\0",
2304                       16);
2305
2306               relocation = (htab->sgot->output_section->vma
2307                             + htab->sgot->output_offset + off
2308                             - rel->r_offset
2309                             - input_section->output_section->vma
2310                             - input_section->output_offset
2311                             - 12);
2312               bfd_put_32 (output_bfd, relocation,
2313                           contents + rel->r_offset + 8);
2314               /* Skip R_X86_64_PLT32.  */
2315               rel++;
2316               continue;
2317             }
2318           break;
2319
2320         case R_X86_64_TLSLD:
2321           if (! info->shared)
2322             {
2323               /* LD->LE transition:
2324                  Ensure it is:
2325                  leaq foo@tlsld(%rip), %rdi; call __tls_get_addr@plt.
2326                  We change it into:
2327                  .word 0x6666; .byte 0x66; movl %fs:0, %rax.  */
2328               BFD_ASSERT (rel->r_offset >= 3);
2329               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 3)
2330                           == 0x48);
2331               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 2)
2332                           == 0x8d);
2333               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset - 1)
2334                           == 0x3d);
2335               BFD_ASSERT (rel->r_offset + 9 <= input_section->size);
2336               BFD_ASSERT (bfd_get_8 (input_bfd, contents + rel->r_offset + 4)
2337                           == 0xe8);
2338               BFD_ASSERT (rel + 1 < relend);
2339               BFD_ASSERT (ELF64_R_TYPE (rel[1].r_info) == R_X86_64_PLT32);
2340               memcpy (contents + rel->r_offset - 3,
2341                       "\x66\x66\x66\x64\x48\x8b\x04\x25\0\0\0", 12);
2342               /* Skip R_X86_64_PLT32.  */
2343               rel++;
2344               continue;
2345             }
2346
2347           if (htab->sgot == NULL)
2348             abort ();
2349
2350           off = htab->tls_ld_got.offset;
2351           if (off & 1)
2352             off &= ~1;
2353           else
2354             {
2355               Elf_Internal_Rela outrel;
2356               bfd_byte *loc;
2357
2358               if (htab->srelgot == NULL)
2359                 abort ();
2360
2361               outrel.r_offset = (htab->sgot->output_section->vma
2362                                  + htab->sgot->output_offset + off);
2363
2364               bfd_put_64 (output_bfd, 0,
2365                           htab->sgot->contents + off);
2366               bfd_put_64 (output_bfd, 0,
2367                           htab->sgot->contents + off + GOT_ENTRY_SIZE);
2368               outrel.r_info = ELF64_R_INFO (0, R_X86_64_DTPMOD64);
2369               outrel.r_addend = 0;
2370               loc = htab->srelgot->contents;
2371               loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
2372               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2373               htab->tls_ld_got.offset |= 1;
2374             }
2375           relocation = htab->sgot->output_section->vma
2376                        + htab->sgot->output_offset + off;
2377           unresolved_reloc = FALSE;
2378           break;
2379
2380         case R_X86_64_DTPOFF32:
2381           if (info->shared || (input_section->flags & SEC_CODE) == 0)
2382             relocation -= dtpoff_base (info);
2383           else
2384             relocation = tpoff (info, relocation);
2385           break;
2386
2387         case R_X86_64_TPOFF32:
2388           BFD_ASSERT (! info->shared);
2389           relocation = tpoff (info, relocation);
2390           break;
2391
2392         default:
2393           break;
2394         }
2395
2396       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2397          because such sections are not SEC_ALLOC and thus ld.so will
2398          not process them.  */
2399       if (unresolved_reloc
2400           && !((input_section->flags & SEC_DEBUGGING) != 0
2401                && h->def_dynamic))
2402         (*_bfd_error_handler)
2403           (_("%B(%A+0x%lx): unresolvable relocation against symbol `%s'"),
2404            input_bfd,
2405            input_section,
2406            (long) rel->r_offset,
2407            h->root.root.string);
2408
2409       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2410                                     contents, rel->r_offset,
2411                                     relocation, rel->r_addend);
2412
2413       if (r != bfd_reloc_ok)
2414         {
2415           const char *name;
2416
2417           if (h != NULL)
2418             name = h->root.root.string;
2419           else
2420             {
2421               name = bfd_elf_string_from_elf_section (input_bfd,
2422                                                       symtab_hdr->sh_link,
2423                                                       sym->st_name);
2424               if (name == NULL)
2425                 return FALSE;
2426               if (*name == '\0')
2427                 name = bfd_section_name (input_bfd, sec);
2428             }
2429
2430           if (r == bfd_reloc_overflow)
2431             {
2432               if (h != NULL
2433                   && h->root.type == bfd_link_hash_undefweak
2434                   && howto->pc_relative)
2435                 /* Ignore reloc overflow on branches to undefweak syms.  */
2436                 continue;
2437
2438               if (! ((*info->callbacks->reloc_overflow)
2439                      (info, (h ? &h->root : NULL), name, howto->name,
2440                       (bfd_vma) 0, input_bfd, input_section,
2441                       rel->r_offset)))
2442                 return FALSE;
2443             }
2444           else
2445             {
2446               (*_bfd_error_handler)
2447                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
2448                  input_bfd, input_section,
2449                  (long) rel->r_offset, name, (int) r);
2450               return FALSE;
2451             }
2452         }
2453     }
2454
2455   return TRUE;
2456 }
2457
2458 /* Finish up dynamic symbol handling.  We set the contents of various
2459    dynamic sections here.  */
2460
2461 static bfd_boolean
2462 elf64_x86_64_finish_dynamic_symbol (bfd *output_bfd,
2463                                     struct bfd_link_info *info,
2464                                     struct elf_link_hash_entry *h,
2465                                     Elf_Internal_Sym *sym)
2466 {
2467   struct elf64_x86_64_link_hash_table *htab;
2468
2469   htab = elf64_x86_64_hash_table (info);
2470
2471   if (h->plt.offset != (bfd_vma) -1)
2472     {
2473       bfd_vma plt_index;
2474       bfd_vma got_offset;
2475       Elf_Internal_Rela rela;
2476       bfd_byte *loc;
2477
2478       /* This symbol has an entry in the procedure linkage table.  Set
2479          it up.  */
2480       if (h->dynindx == -1
2481           || htab->splt == NULL
2482           || htab->sgotplt == NULL
2483           || htab->srelplt == NULL)
2484         abort ();
2485
2486       /* Get the index in the procedure linkage table which
2487          corresponds to this symbol.  This is the index of this symbol
2488          in all the symbols for which we are making plt entries.  The
2489          first entry in the procedure linkage table is reserved.  */
2490       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2491
2492       /* Get the offset into the .got table of the entry that
2493          corresponds to this function.  Each .got entry is GOT_ENTRY_SIZE
2494          bytes. The first three are reserved for the dynamic linker.  */
2495       got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
2496
2497       /* Fill in the entry in the procedure linkage table.  */
2498       memcpy (htab->splt->contents + h->plt.offset, elf64_x86_64_plt_entry,
2499               PLT_ENTRY_SIZE);
2500
2501       /* Insert the relocation positions of the plt section.  The magic
2502          numbers at the end of the statements are the positions of the
2503          relocations in the plt section.  */
2504       /* Put offset for jmp *name@GOTPCREL(%rip), since the
2505          instruction uses 6 bytes, subtract this value.  */
2506       bfd_put_32 (output_bfd,
2507                       (htab->sgotplt->output_section->vma
2508                        + htab->sgotplt->output_offset
2509                        + got_offset
2510                        - htab->splt->output_section->vma
2511                        - htab->splt->output_offset
2512                        - h->plt.offset
2513                        - 6),
2514                   htab->splt->contents + h->plt.offset + 2);
2515       /* Put relocation index.  */
2516       bfd_put_32 (output_bfd, plt_index,
2517                   htab->splt->contents + h->plt.offset + 7);
2518       /* Put offset for jmp .PLT0.  */
2519       bfd_put_32 (output_bfd, - (h->plt.offset + PLT_ENTRY_SIZE),
2520                   htab->splt->contents + h->plt.offset + 12);
2521
2522       /* Fill in the entry in the global offset table, initially this
2523          points to the pushq instruction in the PLT which is at offset 6.  */
2524       bfd_put_64 (output_bfd, (htab->splt->output_section->vma
2525                                + htab->splt->output_offset
2526                                + h->plt.offset + 6),
2527                   htab->sgotplt->contents + got_offset);
2528
2529       /* Fill in the entry in the .rela.plt section.  */
2530       rela.r_offset = (htab->sgotplt->output_section->vma
2531                        + htab->sgotplt->output_offset
2532                        + got_offset);
2533       rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_JUMP_SLOT);
2534       rela.r_addend = 0;
2535       loc = htab->srelplt->contents + plt_index * sizeof (Elf64_External_Rela);
2536       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
2537
2538       if (!h->def_regular)
2539         {
2540           /* Mark the symbol as undefined, rather than as defined in
2541              the .plt section.  Leave the value if there were any
2542              relocations where pointer equality matters (this is a clue
2543              for the dynamic linker, to make function pointer
2544              comparisons work between an application and shared
2545              library), otherwise set it to zero.  If a function is only
2546              called from a binary, there is no need to slow down
2547              shared libraries because of that.  */
2548           sym->st_shndx = SHN_UNDEF;
2549           if (!h->pointer_equality_needed)
2550             sym->st_value = 0;
2551         }
2552     }
2553
2554   if (h->got.offset != (bfd_vma) -1
2555       && elf64_x86_64_hash_entry (h)->tls_type != GOT_TLS_GD
2556       && elf64_x86_64_hash_entry (h)->tls_type != GOT_TLS_IE)
2557     {
2558       Elf_Internal_Rela rela;
2559       bfd_byte *loc;
2560
2561       /* This symbol has an entry in the global offset table.  Set it
2562          up.  */
2563       if (htab->sgot == NULL || htab->srelgot == NULL)
2564         abort ();
2565
2566       rela.r_offset = (htab->sgot->output_section->vma
2567                        + htab->sgot->output_offset
2568                        + (h->got.offset &~ (bfd_vma) 1));
2569
2570       /* If this is a static link, or it is a -Bsymbolic link and the
2571          symbol is defined locally or was forced to be local because
2572          of a version file, we just want to emit a RELATIVE reloc.
2573          The entry in the global offset table will already have been
2574          initialized in the relocate_section function.  */
2575       if (info->shared
2576           && SYMBOL_REFERENCES_LOCAL (info, h))
2577         {
2578           BFD_ASSERT((h->got.offset & 1) != 0);
2579           rela.r_info = ELF64_R_INFO (0, R_X86_64_RELATIVE);
2580           rela.r_addend = (h->root.u.def.value
2581                            + h->root.u.def.section->output_section->vma
2582                            + h->root.u.def.section->output_offset);
2583         }
2584       else
2585         {
2586           BFD_ASSERT((h->got.offset & 1) == 0);
2587           bfd_put_64 (output_bfd, (bfd_vma) 0,
2588                       htab->sgot->contents + h->got.offset);
2589           rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_GLOB_DAT);
2590           rela.r_addend = 0;
2591         }
2592
2593       loc = htab->srelgot->contents;
2594       loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
2595       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
2596     }
2597
2598   if (h->needs_copy)
2599     {
2600       Elf_Internal_Rela rela;
2601       bfd_byte *loc;
2602
2603       /* This symbol needs a copy reloc.  Set it up.  */
2604
2605       if (h->dynindx == -1
2606           || (h->root.type != bfd_link_hash_defined
2607               && h->root.type != bfd_link_hash_defweak)
2608           || htab->srelbss == NULL)
2609         abort ();
2610
2611       rela.r_offset = (h->root.u.def.value
2612                        + h->root.u.def.section->output_section->vma
2613                        + h->root.u.def.section->output_offset);
2614       rela.r_info = ELF64_R_INFO (h->dynindx, R_X86_64_COPY);
2615       rela.r_addend = 0;
2616       loc = htab->srelbss->contents;
2617       loc += htab->srelbss->reloc_count++ * sizeof (Elf64_External_Rela);
2618       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
2619     }
2620
2621   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
2622   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2623       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
2624     sym->st_shndx = SHN_ABS;
2625
2626   return TRUE;
2627 }
2628
2629 /* Used to decide how to sort relocs in an optimal manner for the
2630    dynamic linker, before writing them out.  */
2631
2632 static enum elf_reloc_type_class
2633 elf64_x86_64_reloc_type_class (const Elf_Internal_Rela *rela)
2634 {
2635   switch ((int) ELF64_R_TYPE (rela->r_info))
2636     {
2637     case R_X86_64_RELATIVE:
2638       return reloc_class_relative;
2639     case R_X86_64_JUMP_SLOT:
2640       return reloc_class_plt;
2641     case R_X86_64_COPY:
2642       return reloc_class_copy;
2643     default:
2644       return reloc_class_normal;
2645     }
2646 }
2647
2648 /* Finish up the dynamic sections.  */
2649
2650 static bfd_boolean
2651 elf64_x86_64_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
2652 {
2653   struct elf64_x86_64_link_hash_table *htab;
2654   bfd *dynobj;
2655   asection *sdyn;
2656
2657   htab = elf64_x86_64_hash_table (info);
2658   dynobj = htab->elf.dynobj;
2659   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2660
2661   if (htab->elf.dynamic_sections_created)
2662     {
2663       Elf64_External_Dyn *dyncon, *dynconend;
2664
2665       if (sdyn == NULL || htab->sgot == NULL)
2666         abort ();
2667
2668       dyncon = (Elf64_External_Dyn *) sdyn->contents;
2669       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
2670       for (; dyncon < dynconend; dyncon++)
2671         {
2672           Elf_Internal_Dyn dyn;
2673           asection *s;
2674
2675           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
2676
2677           switch (dyn.d_tag)
2678             {
2679             default:
2680               continue;
2681
2682             case DT_PLTGOT:
2683               s = htab->sgotplt;
2684               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2685               break;
2686
2687             case DT_JMPREL:
2688               dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
2689               break;
2690
2691             case DT_PLTRELSZ:
2692               s = htab->srelplt->output_section;
2693               dyn.d_un.d_val = s->size;
2694               break;
2695
2696             case DT_RELASZ:
2697               /* The procedure linkage table relocs (DT_JMPREL) should
2698                  not be included in the overall relocs (DT_RELA).
2699                  Therefore, we override the DT_RELASZ entry here to
2700                  make it not include the JMPREL relocs.  Since the
2701                  linker script arranges for .rela.plt to follow all
2702                  other relocation sections, we don't have to worry
2703                  about changing the DT_RELA entry.  */
2704               if (htab->srelplt != NULL)
2705                 {
2706                   s = htab->srelplt->output_section;
2707                   dyn.d_un.d_val -= s->size;
2708                 }
2709               break;
2710             }
2711
2712           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2713         }
2714
2715       /* Fill in the special first entry in the procedure linkage table.  */
2716       if (htab->splt && htab->splt->size > 0)
2717         {
2718           /* Fill in the first entry in the procedure linkage table.  */
2719           memcpy (htab->splt->contents, elf64_x86_64_plt0_entry,
2720                   PLT_ENTRY_SIZE);
2721           /* Add offset for pushq GOT+8(%rip), since the instruction
2722              uses 6 bytes subtract this value.  */
2723           bfd_put_32 (output_bfd,
2724                       (htab->sgotplt->output_section->vma
2725                        + htab->sgotplt->output_offset
2726                        + 8
2727                        - htab->splt->output_section->vma
2728                        - htab->splt->output_offset
2729                        - 6),
2730                       htab->splt->contents + 2);
2731           /* Add offset for jmp *GOT+16(%rip). The 12 is the offset to
2732              the end of the instruction.  */
2733           bfd_put_32 (output_bfd,
2734                       (htab->sgotplt->output_section->vma
2735                        + htab->sgotplt->output_offset
2736                        + 16
2737                        - htab->splt->output_section->vma
2738                        - htab->splt->output_offset
2739                        - 12),
2740                       htab->splt->contents + 8);
2741
2742           elf_section_data (htab->splt->output_section)->this_hdr.sh_entsize =
2743             PLT_ENTRY_SIZE;
2744         }
2745     }
2746
2747   if (htab->sgotplt)
2748     {
2749       /* Fill in the first three entries in the global offset table.  */
2750       if (htab->sgotplt->size > 0)
2751         {
2752           /* Set the first entry in the global offset table to the address of
2753              the dynamic section.  */
2754           if (sdyn == NULL)
2755             bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents);
2756           else
2757             bfd_put_64 (output_bfd,
2758                         sdyn->output_section->vma + sdyn->output_offset,
2759                         htab->sgotplt->contents);
2760           /* Write GOT[1] and GOT[2], needed for the dynamic linker.  */
2761           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + GOT_ENTRY_SIZE);
2762           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + GOT_ENTRY_SIZE*2);
2763         }
2764
2765       elf_section_data (htab->sgotplt->output_section)->this_hdr.sh_entsize =
2766         GOT_ENTRY_SIZE;
2767     }
2768
2769   if (htab->sgot && htab->sgot->size > 0)
2770     elf_section_data (htab->sgot->output_section)->this_hdr.sh_entsize
2771       = GOT_ENTRY_SIZE;
2772
2773   return TRUE;
2774 }
2775
2776 /* Return address for Ith PLT stub in section PLT, for relocation REL
2777    or (bfd_vma) -1 if it should not be included.  */
2778
2779 static bfd_vma
2780 elf64_x86_64_plt_sym_val (bfd_vma i, const asection *plt,
2781                           const arelent *rel ATTRIBUTE_UNUSED)
2782 {
2783   return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
2784 }
2785
2786 /* Handle an x86-64 specific section when reading an object file.  This
2787    is called when elfcode.h finds a section with an unknown type.  */
2788
2789 static bfd_boolean
2790 elf64_x86_64_section_from_shdr (bfd *abfd, Elf_Internal_Shdr *hdr, const char *name)
2791 {
2792   if (hdr->sh_type != SHT_X86_64_UNWIND)
2793     return FALSE;
2794
2795   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
2796     return FALSE;
2797
2798   return TRUE;
2799 }
2800
2801 #define TARGET_LITTLE_SYM                   bfd_elf64_x86_64_vec
2802 #define TARGET_LITTLE_NAME                  "elf64-x86-64"
2803 #define ELF_ARCH                            bfd_arch_i386
2804 #define ELF_MACHINE_CODE                    EM_X86_64
2805 #define ELF_MAXPAGESIZE                     0x100000
2806
2807 #define elf_backend_can_gc_sections         1
2808 #define elf_backend_can_refcount            1
2809 #define elf_backend_want_got_plt            1
2810 #define elf_backend_plt_readonly            1
2811 #define elf_backend_want_plt_sym            0
2812 #define elf_backend_got_header_size         (GOT_ENTRY_SIZE*3)
2813 #define elf_backend_rela_normal             1
2814
2815 #define elf_info_to_howto                   elf64_x86_64_info_to_howto
2816
2817 #define bfd_elf64_bfd_link_hash_table_create \
2818   elf64_x86_64_link_hash_table_create
2819 #define bfd_elf64_bfd_reloc_type_lookup     elf64_x86_64_reloc_type_lookup
2820
2821 #define elf_backend_adjust_dynamic_symbol   elf64_x86_64_adjust_dynamic_symbol
2822 #define elf_backend_check_relocs            elf64_x86_64_check_relocs
2823 #define elf_backend_copy_indirect_symbol    elf64_x86_64_copy_indirect_symbol
2824 #define elf_backend_create_dynamic_sections elf64_x86_64_create_dynamic_sections
2825 #define elf_backend_finish_dynamic_sections elf64_x86_64_finish_dynamic_sections
2826 #define elf_backend_finish_dynamic_symbol   elf64_x86_64_finish_dynamic_symbol
2827 #define elf_backend_gc_mark_hook            elf64_x86_64_gc_mark_hook
2828 #define elf_backend_gc_sweep_hook           elf64_x86_64_gc_sweep_hook
2829 #define elf_backend_grok_prstatus           elf64_x86_64_grok_prstatus
2830 #define elf_backend_grok_psinfo             elf64_x86_64_grok_psinfo
2831 #define elf_backend_reloc_type_class        elf64_x86_64_reloc_type_class
2832 #define elf_backend_relocate_section        elf64_x86_64_relocate_section
2833 #define elf_backend_size_dynamic_sections   elf64_x86_64_size_dynamic_sections
2834 #define elf_backend_plt_sym_val             elf64_x86_64_plt_sym_val
2835 #define elf_backend_object_p                elf64_x86_64_elf_object_p
2836 #define bfd_elf64_mkobject                  elf64_x86_64_mkobject
2837
2838 #define elf_backend_section_from_shdr \
2839         elf64_x86_64_section_from_shdr
2840
2841 #include "elf64-target.h"