bfd/elf64-s390.c

   1 /* IBM S/390-specific support for 64-bit ELF
   2    Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
   3    2010, 2011, 2012 Free Software Foundation, Inc.
   4    Contributed Martin Schwidefsky (schwidefsky@de.ibm.com).
   5
   6    This file is part of BFD, the Binary File Descriptor library.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  21    02110-1301, USA.  */
  22
  23 #include "sysdep.h"
  24 #include "bfd.h"
  25 #include "bfdlink.h"
  26 #include "libbfd.h"
  27 #include "elf-bfd.h"
  28
  29 static reloc_howto_type *elf_s390_reloc_type_lookup
  30   PARAMS ((bfd *, bfd_reloc_code_real_type));
  31 static void elf_s390_info_to_howto
  32   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
  33 static bfd_boolean elf_s390_is_local_label_name
  34   PARAMS ((bfd *, const char *));
  35 static struct bfd_hash_entry *link_hash_newfunc
  36   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
  37 static struct bfd_link_hash_table *elf_s390_link_hash_table_create
  38   PARAMS ((bfd *));
  39 static bfd_boolean create_got_section
  40   PARAMS((bfd *, struct bfd_link_info *));
  41 static bfd_boolean elf_s390_create_dynamic_sections
  42   PARAMS((bfd *, struct bfd_link_info *));
  43 static void elf_s390_copy_indirect_symbol
  44   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *,
  45            struct elf_link_hash_entry *));
  46 static bfd_boolean elf_s390_check_relocs
  47   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  48            const Elf_Internal_Rela *));
  49 struct elf_s390_link_hash_entry;
  50 static void elf_s390_adjust_gotplt
  51   PARAMS ((struct elf_s390_link_hash_entry *));
  52 static bfd_boolean elf_s390_adjust_dynamic_symbol
  53   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
  54 static bfd_boolean allocate_dynrelocs
  55   PARAMS ((struct elf_link_hash_entry *, PTR));
  56 static bfd_boolean readonly_dynrelocs
  57   PARAMS ((struct elf_link_hash_entry *, PTR));
  58 static bfd_boolean elf_s390_size_dynamic_sections
  59   PARAMS ((bfd *, struct bfd_link_info *));
  60 static bfd_boolean elf_s390_relocate_section
  61   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  62            Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
  63 static bfd_boolean elf_s390_finish_dynamic_symbol
  64   PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
  65            Elf_Internal_Sym *));
  66 static enum elf_reloc_type_class elf_s390_reloc_type_class
  67   PARAMS ((const Elf_Internal_Rela *));
  68 static bfd_boolean elf_s390_finish_dynamic_sections
  69   PARAMS ((bfd *, struct bfd_link_info *));
  70 static bfd_boolean elf_s390_object_p
  71   PARAMS ((bfd *));
  72 static int elf_s390_tls_transition
  73   PARAMS ((struct bfd_link_info *, int, int));
  74 static bfd_reloc_status_type s390_tls_reloc
  75   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  76 static bfd_vma dtpoff_base
  77   PARAMS ((struct bfd_link_info *));
  78 static bfd_vma tpoff
  79   PARAMS ((struct bfd_link_info *, bfd_vma));
  80 static void invalid_tls_insn
  81   PARAMS ((bfd *, asection *, Elf_Internal_Rela *));
  82 static bfd_reloc_status_type s390_elf_ldisp_reloc
  83   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  84
  85 #include "elf/s390.h"
  86
  87 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
  88    from smaller values.  Start with zero, widen, *then* decrement.  */
  89 #define MINUS_ONE      (((bfd_vma)0) - 1)
  90
  91 /* The relocation "howto" table.  */
  92 static reloc_howto_type elf_howto_table[] =
  93 {
  94   HOWTO (R_390_NONE,            /* type */
  95          0,                     /* rightshift */
  96          0,                     /* size (0 = byte, 1 = short, 2 = long) */
  97          0,                     /* bitsize */
  98          FALSE,                 /* pc_relative */
  99          0,                     /* bitpos */
 100          complain_overflow_dont, /* complain_on_overflow */
 101          bfd_elf_generic_reloc, /* special_function */
 102          "R_390_NONE",          /* name */
 103          FALSE,                 /* partial_inplace */
 104          0,                     /* src_mask */
 105          0,                     /* dst_mask */
 106          FALSE),                /* pcrel_offset */
 107
 108   HOWTO(R_390_8,         0, 0,  8, FALSE, 0, complain_overflow_bitfield,
 109         bfd_elf_generic_reloc, "R_390_8",        FALSE, 0,0x000000ff, FALSE),
 110   HOWTO(R_390_12,        0, 1, 12, FALSE, 0, complain_overflow_dont,
 111         bfd_elf_generic_reloc, "R_390_12",       FALSE, 0,0x00000fff, FALSE),
 112   HOWTO(R_390_16,        0, 1, 16, FALSE, 0, complain_overflow_bitfield,
 113         bfd_elf_generic_reloc, "R_390_16",       FALSE, 0,0x0000ffff, FALSE),
 114   HOWTO(R_390_32,        0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 115         bfd_elf_generic_reloc, "R_390_32",       FALSE, 0,0xffffffff, FALSE),
 116   HOWTO(R_390_PC32,      0, 2, 32,  TRUE, 0, complain_overflow_bitfield,
 117         bfd_elf_generic_reloc, "R_390_PC32",     FALSE, 0,0xffffffff, TRUE),
 118   HOWTO(R_390_GOT12,     0, 1, 12, FALSE, 0, complain_overflow_bitfield,
 119         bfd_elf_generic_reloc, "R_390_GOT12",    FALSE, 0,0x00000fff, FALSE),
 120   HOWTO(R_390_GOT32,     0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 121         bfd_elf_generic_reloc, "R_390_GOT32",    FALSE, 0,0xffffffff, FALSE),
 122   HOWTO(R_390_PLT32,     0, 2, 32,  TRUE, 0, complain_overflow_bitfield,
 123         bfd_elf_generic_reloc, "R_390_PLT32",    FALSE, 0,0xffffffff, TRUE),
 124   HOWTO(R_390_COPY,      0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 125         bfd_elf_generic_reloc, "R_390_COPY",     FALSE, 0,MINUS_ONE,  FALSE),
 126   HOWTO(R_390_GLOB_DAT,  0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 127         bfd_elf_generic_reloc, "R_390_GLOB_DAT", FALSE, 0,MINUS_ONE,  FALSE),
 128   HOWTO(R_390_JMP_SLOT,  0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 129         bfd_elf_generic_reloc, "R_390_JMP_SLOT", FALSE, 0,MINUS_ONE,  FALSE),
 130   HOWTO(R_390_RELATIVE,  0, 4, 64,  TRUE, 0, complain_overflow_bitfield,
 131         bfd_elf_generic_reloc, "R_390_RELATIVE", FALSE, 0,MINUS_ONE,  FALSE),
 132   HOWTO(R_390_GOTOFF32,  0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 133         bfd_elf_generic_reloc, "R_390_GOTOFF32", FALSE, 0,MINUS_ONE,  FALSE),
 134   HOWTO(R_390_GOTPC,     0, 4, 64,  TRUE, 0, complain_overflow_bitfield,
 135         bfd_elf_generic_reloc, "R_390_GOTPC",    FALSE, 0,MINUS_ONE,  TRUE),
 136   HOWTO(R_390_GOT16,     0, 1, 16, FALSE, 0, complain_overflow_bitfield,
 137         bfd_elf_generic_reloc, "R_390_GOT16",    FALSE, 0,0x0000ffff, FALSE),
 138   HOWTO(R_390_PC16,      0, 1, 16,  TRUE, 0, complain_overflow_bitfield,
 139         bfd_elf_generic_reloc, "R_390_PC16",     FALSE, 0,0x0000ffff, TRUE),
 140   HOWTO(R_390_PC16DBL,   1, 1, 16,  TRUE, 0, complain_overflow_bitfield,
 141         bfd_elf_generic_reloc, "R_390_PC16DBL",  FALSE, 0,0x0000ffff, TRUE),
 142   HOWTO(R_390_PLT16DBL,  1, 1, 16,  TRUE, 0, complain_overflow_bitfield,
 143         bfd_elf_generic_reloc, "R_390_PLT16DBL", FALSE, 0,0x0000ffff, TRUE),
 144   HOWTO(R_390_PC32DBL,   1, 2, 32,  TRUE, 0, complain_overflow_bitfield,
 145         bfd_elf_generic_reloc, "R_390_PC32DBL",  FALSE, 0,0xffffffff, TRUE),
 146   HOWTO(R_390_PLT32DBL,  1, 2, 32,  TRUE, 0, complain_overflow_bitfield,
 147         bfd_elf_generic_reloc, "R_390_PLT32DBL", FALSE, 0,0xffffffff, TRUE),
 148   HOWTO(R_390_GOTPCDBL,  1, 2, 32,  TRUE, 0, complain_overflow_bitfield,
 149         bfd_elf_generic_reloc, "R_390_GOTPCDBL", FALSE, 0,MINUS_ONE,  TRUE),
 150   HOWTO(R_390_64,        0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 151         bfd_elf_generic_reloc, "R_390_64",       FALSE, 0,MINUS_ONE,  FALSE),
 152   HOWTO(R_390_PC64,      0, 4, 64,  TRUE, 0, complain_overflow_bitfield,
 153         bfd_elf_generic_reloc, "R_390_PC64",     FALSE, 0,MINUS_ONE,  TRUE),
 154   HOWTO(R_390_GOT64,     0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 155         bfd_elf_generic_reloc, "R_390_GOT64",    FALSE, 0,MINUS_ONE,  FALSE),
 156   HOWTO(R_390_PLT64,     0, 4, 64,  TRUE, 0, complain_overflow_bitfield,
 157         bfd_elf_generic_reloc, "R_390_PLT64",    FALSE, 0,MINUS_ONE,  TRUE),
 158   HOWTO(R_390_GOTENT,    1, 2, 32,  TRUE, 0, complain_overflow_bitfield,
 159         bfd_elf_generic_reloc, "R_390_GOTENT",   FALSE, 0,MINUS_ONE,  TRUE),
 160   HOWTO(R_390_GOTOFF16,  0, 1, 16, FALSE, 0, complain_overflow_bitfield,
 161         bfd_elf_generic_reloc, "R_390_GOTOFF16", FALSE, 0,0x0000ffff, FALSE),
 162   HOWTO(R_390_GOTOFF64,  0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 163         bfd_elf_generic_reloc, "R_390_GOTOFF64", FALSE, 0,MINUS_ONE,  FALSE),
 164   HOWTO(R_390_GOTPLT12,  0, 1, 12, FALSE, 0, complain_overflow_dont,
 165         bfd_elf_generic_reloc, "R_390_GOTPLT12", FALSE, 0,0x00000fff, FALSE),
 166   HOWTO(R_390_GOTPLT16,  0, 1, 16, FALSE, 0, complain_overflow_bitfield,
 167         bfd_elf_generic_reloc, "R_390_GOTPLT16", FALSE, 0,0x0000ffff, FALSE),
 168   HOWTO(R_390_GOTPLT32,  0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 169         bfd_elf_generic_reloc, "R_390_GOTPLT32", FALSE, 0,0xffffffff, FALSE),
 170   HOWTO(R_390_GOTPLT64,  0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 171         bfd_elf_generic_reloc, "R_390_GOTPLT64", FALSE, 0,MINUS_ONE,  FALSE),
 172   HOWTO(R_390_GOTPLTENT, 1, 2, 32,  TRUE, 0, complain_overflow_bitfield,
 173         bfd_elf_generic_reloc, "R_390_GOTPLTENT",FALSE, 0,MINUS_ONE,  TRUE),
 174   HOWTO(R_390_PLTOFF16,  0, 1, 16, FALSE, 0, complain_overflow_bitfield,
 175         bfd_elf_generic_reloc, "R_390_PLTOFF16", FALSE, 0,0x0000ffff, FALSE),
 176   HOWTO(R_390_PLTOFF32,  0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 177         bfd_elf_generic_reloc, "R_390_PLTOFF32", FALSE, 0,0xffffffff, FALSE),
 178   HOWTO(R_390_PLTOFF64,  0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 179         bfd_elf_generic_reloc, "R_390_PLTOFF64", FALSE, 0,MINUS_ONE,  FALSE),
 180   HOWTO(R_390_TLS_LOAD, 0, 0, 0, FALSE, 0, complain_overflow_dont,
 181         s390_tls_reloc, "R_390_TLS_LOAD", FALSE, 0, 0, FALSE),
 182   HOWTO(R_390_TLS_GDCALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
 183         s390_tls_reloc, "R_390_TLS_GDCALL", FALSE, 0, 0, FALSE),
 184   HOWTO(R_390_TLS_LDCALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
 185         s390_tls_reloc, "R_390_TLS_LDCALL", FALSE, 0, 0, FALSE),
 186   EMPTY_HOWTO (R_390_TLS_GD32), /* Empty entry for R_390_TLS_GD32.  */
 187   HOWTO(R_390_TLS_GD64,  0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 188         bfd_elf_generic_reloc, "R_390_TLS_GD64", FALSE, 0, MINUS_ONE, FALSE),
 189   HOWTO(R_390_TLS_GOTIE12, 0, 1, 12, FALSE, 0, complain_overflow_dont,
 190         bfd_elf_generic_reloc, "R_390_TLS_GOTIE12", FALSE, 0, 0x00000fff, FALSE),
 191   EMPTY_HOWTO (R_390_TLS_GOTIE32),      /* Empty entry for R_390_TLS_GOTIE32.  */
 192   HOWTO(R_390_TLS_GOTIE64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 193         bfd_elf_generic_reloc, "R_390_TLS_GOTIE64", FALSE, 0, MINUS_ONE, FALSE),
 194   EMPTY_HOWTO (R_390_TLS_LDM32),        /* Empty entry for R_390_TLS_LDM32.  */
 195   HOWTO(R_390_TLS_LDM64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 196         bfd_elf_generic_reloc, "R_390_TLS_LDM64", FALSE, 0, MINUS_ONE, FALSE),
 197   EMPTY_HOWTO (R_390_TLS_IE32), /* Empty entry for R_390_TLS_IE32.  */
 198   HOWTO(R_390_TLS_IE64,  0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 199         bfd_elf_generic_reloc, "R_390_TLS_IE64", FALSE, 0, MINUS_ONE, FALSE),
 200   HOWTO(R_390_TLS_IEENT, 1, 2, 32, TRUE, 0, complain_overflow_bitfield,
 201         bfd_elf_generic_reloc, "R_390_TLS_IEENT", FALSE, 0, MINUS_ONE, TRUE),
 202   EMPTY_HOWTO (R_390_TLS_LE32), /* Empty entry for R_390_TLS_LE32.  */
 203   HOWTO(R_390_TLS_LE64,  0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 204         bfd_elf_generic_reloc, "R_390_TLS_LE64", FALSE, 0, MINUS_ONE, FALSE),
 205   EMPTY_HOWTO (R_390_TLS_LDO32),        /* Empty entry for R_390_TLS_LDO32.  */
 206   HOWTO(R_390_TLS_LDO64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 207         bfd_elf_generic_reloc, "R_390_TLS_LDO64", FALSE, 0, MINUS_ONE, FALSE),
 208   HOWTO(R_390_TLS_DTPMOD, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 209         bfd_elf_generic_reloc, "R_390_TLS_DTPMOD", FALSE, 0, MINUS_ONE, FALSE),
 210   HOWTO(R_390_TLS_DTPOFF, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 211         bfd_elf_generic_reloc, "R_390_TLS_DTPOFF", FALSE, 0, MINUS_ONE, FALSE),
 212   HOWTO(R_390_TLS_TPOFF, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
 213         bfd_elf_generic_reloc, "R_390_TLS_TPOFF", FALSE, 0, MINUS_ONE, FALSE),
 214   HOWTO(R_390_20,        0, 2, 20, FALSE, 8, complain_overflow_dont,
 215         s390_elf_ldisp_reloc, "R_390_20",      FALSE, 0,0x0fffff00, FALSE),
 216   HOWTO(R_390_GOT20,     0, 2, 20, FALSE, 8, complain_overflow_dont,
 217         s390_elf_ldisp_reloc, "R_390_GOT20",   FALSE, 0,0x0fffff00, FALSE),
 218   HOWTO(R_390_GOTPLT20,  0, 2, 20, FALSE, 8, complain_overflow_dont,
 219         s390_elf_ldisp_reloc, "R_390_GOTPLT20", FALSE, 0,0x0fffff00, FALSE),
 220   HOWTO(R_390_TLS_GOTIE20, 0, 2, 20, FALSE, 8, complain_overflow_dont,
 221         s390_elf_ldisp_reloc, "R_390_TLS_GOTIE20", FALSE, 0,0x0fffff00, FALSE),
 222 };
 223
 224 /* GNU extension to record C++ vtable hierarchy.  */
 225 static reloc_howto_type elf64_s390_vtinherit_howto =
 226   HOWTO (R_390_GNU_VTINHERIT, 0,4,0,FALSE,0,complain_overflow_dont, NULL, "R_390_GNU_VTINHERIT", FALSE,0, 0, FALSE);
 227 static reloc_howto_type elf64_s390_vtentry_howto =
 228   HOWTO (R_390_GNU_VTENTRY, 0,4,0,FALSE,0,complain_overflow_dont, _bfd_elf_rel_vtable_reloc_fn,"R_390_GNU_VTENTRY", FALSE,0,0, FALSE);
 229
 230 static reloc_howto_type *
 231 elf_s390_reloc_type_lookup (abfd, code)
 232      bfd *abfd ATTRIBUTE_UNUSED;
 233      bfd_reloc_code_real_type code;
 234 {
 235   switch (code)
 236     {
 237     case BFD_RELOC_NONE:
 238       return &elf_howto_table[(int) R_390_NONE];
 239     case BFD_RELOC_8:
 240       return &elf_howto_table[(int) R_390_8];
 241     case BFD_RELOC_390_12:
 242       return &elf_howto_table[(int) R_390_12];
 243     case BFD_RELOC_16:
 244       return &elf_howto_table[(int) R_390_16];
 245     case BFD_RELOC_32:
 246       return &elf_howto_table[(int) R_390_32];
 247     case BFD_RELOC_CTOR:
 248       return &elf_howto_table[(int) R_390_32];
 249     case BFD_RELOC_32_PCREL:
 250       return &elf_howto_table[(int) R_390_PC32];
 251     case BFD_RELOC_390_GOT12:
 252       return &elf_howto_table[(int) R_390_GOT12];
 253     case BFD_RELOC_32_GOT_PCREL:
 254       return &elf_howto_table[(int) R_390_GOT32];
 255     case BFD_RELOC_390_PLT32:
 256       return &elf_howto_table[(int) R_390_PLT32];
 257     case BFD_RELOC_390_COPY:
 258       return &elf_howto_table[(int) R_390_COPY];
 259     case BFD_RELOC_390_GLOB_DAT:
 260       return &elf_howto_table[(int) R_390_GLOB_DAT];
 261     case BFD_RELOC_390_JMP_SLOT:
 262       return &elf_howto_table[(int) R_390_JMP_SLOT];
 263     case BFD_RELOC_390_RELATIVE:
 264       return &elf_howto_table[(int) R_390_RELATIVE];
 265     case BFD_RELOC_32_GOTOFF:
 266       return &elf_howto_table[(int) R_390_GOTOFF32];
 267     case BFD_RELOC_390_GOTPC:
 268       return &elf_howto_table[(int) R_390_GOTPC];
 269     case BFD_RELOC_390_GOT16:
 270       return &elf_howto_table[(int) R_390_GOT16];
 271     case BFD_RELOC_16_PCREL:
 272       return &elf_howto_table[(int) R_390_PC16];
 273     case BFD_RELOC_390_PC16DBL:
 274       return &elf_howto_table[(int) R_390_PC16DBL];
 275     case BFD_RELOC_390_PLT16DBL:
 276       return &elf_howto_table[(int) R_390_PLT16DBL];
 277     case BFD_RELOC_390_PC32DBL:
 278       return &elf_howto_table[(int) R_390_PC32DBL];
 279     case BFD_RELOC_390_PLT32DBL:
 280       return &elf_howto_table[(int) R_390_PLT32DBL];
 281     case BFD_RELOC_390_GOTPCDBL:
 282       return &elf_howto_table[(int) R_390_GOTPCDBL];
 283     case BFD_RELOC_64:
 284       return &elf_howto_table[(int) R_390_64];
 285     case BFD_RELOC_64_PCREL:
 286       return &elf_howto_table[(int) R_390_PC64];
 287     case BFD_RELOC_390_GOT64:
 288       return &elf_howto_table[(int) R_390_GOT64];
 289     case BFD_RELOC_390_PLT64:
 290       return &elf_howto_table[(int) R_390_PLT64];
 291     case BFD_RELOC_390_GOTENT:
 292       return &elf_howto_table[(int) R_390_GOTENT];
 293     case BFD_RELOC_16_GOTOFF:
 294       return &elf_howto_table[(int) R_390_GOTOFF16];
 295     case BFD_RELOC_390_GOTOFF64:
 296       return &elf_howto_table[(int) R_390_GOTOFF64];
 297     case BFD_RELOC_390_GOTPLT12:
 298       return &elf_howto_table[(int) R_390_GOTPLT12];
 299     case BFD_RELOC_390_GOTPLT16:
 300       return &elf_howto_table[(int) R_390_GOTPLT16];
 301     case BFD_RELOC_390_GOTPLT32:
 302       return &elf_howto_table[(int) R_390_GOTPLT32];
 303     case BFD_RELOC_390_GOTPLT64:
 304       return &elf_howto_table[(int) R_390_GOTPLT64];
 305     case BFD_RELOC_390_GOTPLTENT:
 306       return &elf_howto_table[(int) R_390_GOTPLTENT];
 307     case BFD_RELOC_390_PLTOFF16:
 308       return &elf_howto_table[(int) R_390_PLTOFF16];
 309     case BFD_RELOC_390_PLTOFF32:
 310       return &elf_howto_table[(int) R_390_PLTOFF32];
 311     case BFD_RELOC_390_PLTOFF64:
 312       return &elf_howto_table[(int) R_390_PLTOFF64];
 313     case BFD_RELOC_390_TLS_LOAD:
 314       return &elf_howto_table[(int) R_390_TLS_LOAD];
 315     case BFD_RELOC_390_TLS_GDCALL:
 316       return &elf_howto_table[(int) R_390_TLS_GDCALL];
 317     case BFD_RELOC_390_TLS_LDCALL:
 318       return &elf_howto_table[(int) R_390_TLS_LDCALL];
 319     case BFD_RELOC_390_TLS_GD64:
 320       return &elf_howto_table[(int) R_390_TLS_GD64];
 321     case BFD_RELOC_390_TLS_GOTIE12:
 322       return &elf_howto_table[(int) R_390_TLS_GOTIE12];
 323     case BFD_RELOC_390_TLS_GOTIE64:
 324       return &elf_howto_table[(int) R_390_TLS_GOTIE64];
 325     case BFD_RELOC_390_TLS_LDM64:
 326       return &elf_howto_table[(int) R_390_TLS_LDM64];
 327     case BFD_RELOC_390_TLS_IE64:
 328       return &elf_howto_table[(int) R_390_TLS_IE64];
 329     case BFD_RELOC_390_TLS_IEENT:
 330       return &elf_howto_table[(int) R_390_TLS_IEENT];
 331     case BFD_RELOC_390_TLS_LE64:
 332       return &elf_howto_table[(int) R_390_TLS_LE64];
 333     case BFD_RELOC_390_TLS_LDO64:
 334       return &elf_howto_table[(int) R_390_TLS_LDO64];
 335     case BFD_RELOC_390_TLS_DTPMOD:
 336       return &elf_howto_table[(int) R_390_TLS_DTPMOD];
 337     case BFD_RELOC_390_TLS_DTPOFF:
 338       return &elf_howto_table[(int) R_390_TLS_DTPOFF];
 339     case BFD_RELOC_390_TLS_TPOFF:
 340       return &elf_howto_table[(int) R_390_TLS_TPOFF];
 341     case BFD_RELOC_390_20:
 342       return &elf_howto_table[(int) R_390_20];
 343     case BFD_RELOC_390_GOT20:
 344       return &elf_howto_table[(int) R_390_GOT20];
 345     case BFD_RELOC_390_GOTPLT20:
 346       return &elf_howto_table[(int) R_390_GOTPLT20];
 347     case BFD_RELOC_390_TLS_GOTIE20:
 348       return &elf_howto_table[(int) R_390_TLS_GOTIE20];
 349     case BFD_RELOC_VTABLE_INHERIT:
 350       return &elf64_s390_vtinherit_howto;
 351     case BFD_RELOC_VTABLE_ENTRY:
 352       return &elf64_s390_vtentry_howto;
 353     default:
 354       break;
 355     }
 356   return 0;
 357 }
 358
 359 static reloc_howto_type *
 360 elf_s390_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 361                             const char *r_name)
 362 {
 363   unsigned int i;
 364
 365   for (i = 0;
 366        i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]);
 367        i++)
 368     if (elf_howto_table[i].name != NULL
 369         && strcasecmp (elf_howto_table[i].name, r_name) == 0)
 370       return &elf_howto_table[i];
 371
 372     if (strcasecmp (elf64_s390_vtinherit_howto.name, r_name) == 0)
 373       return &elf64_s390_vtinherit_howto;
 374     if (strcasecmp (elf64_s390_vtentry_howto.name, r_name) == 0)
 375       return &elf64_s390_vtentry_howto;
 376
 377   return NULL;
 378 }
 379
 380 /* We need to use ELF64_R_TYPE so we have our own copy of this function,
 381    and elf64-s390.c has its own copy.  */
 382
 383 static void
 384 elf_s390_info_to_howto (abfd, cache_ptr, dst)
 385      bfd *abfd ATTRIBUTE_UNUSED;
 386      arelent *cache_ptr;
 387      Elf_Internal_Rela *dst;
 388 {
 389   unsigned int r_type = ELF64_R_TYPE(dst->r_info);
 390   switch (r_type)
 391     {
 392     case R_390_GNU_VTINHERIT:
 393       cache_ptr->howto = &elf64_s390_vtinherit_howto;
 394       break;
 395
 396     case R_390_GNU_VTENTRY:
 397       cache_ptr->howto = &elf64_s390_vtentry_howto;
 398       break;
 399
 400     default:
 401       if (r_type >= sizeof (elf_howto_table) / sizeof (elf_howto_table[0]))
 402         {
 403           (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
 404                                  abfd, (int) r_type);
 405           r_type = R_390_NONE;
 406         }
 407       cache_ptr->howto = &elf_howto_table[r_type];
 408     }
 409 }
 410
 411 /* A relocation function which doesn't do anything.  */
 412 static bfd_reloc_status_type
 413 s390_tls_reloc (abfd, reloc_entry, symbol, data, input_section,
 414                 output_bfd, error_message)
 415      bfd *abfd ATTRIBUTE_UNUSED;
 416      arelent *reloc_entry;
 417      asymbol *symbol ATTRIBUTE_UNUSED;
 418      PTR data ATTRIBUTE_UNUSED;
 419      asection *input_section;
 420      bfd *output_bfd;
 421      char **error_message ATTRIBUTE_UNUSED;
 422 {
 423   if (output_bfd)
 424     reloc_entry->address += input_section->output_offset;
 425   return bfd_reloc_ok;
 426 }
 427
 428 /* Handle the large displacement relocs.  */
 429 static bfd_reloc_status_type
 430 s390_elf_ldisp_reloc (abfd, reloc_entry, symbol, data, input_section,
 431                       output_bfd, error_message)
 432      bfd *abfd;
 433      arelent *reloc_entry;
 434      asymbol *symbol;
 435      PTR data;
 436      asection *input_section;
 437      bfd *output_bfd;
 438      char **error_message ATTRIBUTE_UNUSED;
 439 {
 440   reloc_howto_type *howto = reloc_entry->howto;
 441   bfd_vma relocation;
 442   bfd_vma insn;
 443
 444   if (output_bfd != (bfd *) NULL
 445       && (symbol->flags & BSF_SECTION_SYM) == 0
 446       && (! howto->partial_inplace
 447           || reloc_entry->addend == 0))
 448     {
 449       reloc_entry->address += input_section->output_offset;
 450       return bfd_reloc_ok;
 451     }
 452   if (output_bfd != NULL)
 453     return bfd_reloc_continue;
 454
 455   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
 456     return bfd_reloc_outofrange;
 457
 458   relocation = (symbol->value
 459                 + symbol->section->output_section->vma
 460                 + symbol->section->output_offset);
 461   relocation += reloc_entry->addend;
 462   if (howto->pc_relative)
 463     {
 464       relocation -= (input_section->output_section->vma
 465                      + input_section->output_offset);
 466       relocation -= reloc_entry->address;
 467     }
 468
 469   insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
 470   insn |= (relocation & 0xfff) << 16 | (relocation & 0xff000) >> 4;
 471   bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
 472
 473   if ((bfd_signed_vma) relocation < - 0x80000
 474       || (bfd_signed_vma) relocation > 0x7ffff)
 475     return bfd_reloc_overflow;
 476   else
 477     return bfd_reloc_ok;
 478 }
 479
 480 static bfd_boolean
 481 elf_s390_is_local_label_name (abfd, name)
 482      bfd *abfd;
 483      const char *name;
 484 {
 485   if (name[0] == '.' && (name[1] == 'X' || name[1] == 'L'))
 486     return TRUE;
 487
 488   return _bfd_elf_is_local_label_name (abfd, name);
 489 }
 490
 491 /* Functions for the 390 ELF linker.  */
 492
 493 /* The name of the dynamic interpreter.  This is put in the .interp
 494    section.  */
 495
 496 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 497
 498 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
 499    copying dynamic variables from a shared lib into an app's dynbss
 500    section, and instead use a dynamic relocation to point into the
 501    shared lib.  */
 502 #define ELIMINATE_COPY_RELOCS 1
 503
 504 /* The size in bytes of the first entry in the procedure linkage table.  */
 505 #define PLT_FIRST_ENTRY_SIZE 32
 506 /* The size in bytes of an entry in the procedure linkage table.  */
 507 #define PLT_ENTRY_SIZE 32
 508
 509 #define GOT_ENTRY_SIZE 8
 510
 511 /* The first three entries in a procedure linkage table are reserved,
 512    and the initial contents are unimportant (we zero them out).
 513    Subsequent entries look like this.  See the SVR4 ABI 386
 514    supplement to see how this works.  */
 515
 516 /* For the s390, simple addr offset can only be 0 - 4096.
 517    To use the full 16777216 TB address space, several instructions
 518    are needed to load an address in a register and execute
 519    a branch( or just saving the address)
 520
 521    Furthermore, only r 0 and 1 are free to use!!!  */
 522
 523 /* The first 3 words in the GOT are then reserved.
 524    Word 0 is the address of the dynamic table.
 525    Word 1 is a pointer to a structure describing the object
 526    Word 2 is used to point to the loader entry address.
 527
 528    The code for PLT entries looks like this:
 529
 530    The GOT holds the address in the PLT to be executed.
 531    The loader then gets:
 532    24(15) =  Pointer to the structure describing the object.
 533    28(15) =  Offset in symbol table
 534    The loader  must  then find the module where the function is
 535    and insert the address in the GOT.
 536
 537    PLT1: LARL 1,<fn>@GOTENT # 6 bytes  Load address of GOT entry in r1
 538          LG   1,0(1)      # 6 bytes  Load address from GOT in r1
 539          BCR  15,1        # 2 bytes  Jump to address
 540    RET1: BASR 1,0         # 2 bytes  Return from GOT 1st time
 541          LGF  1,12(1)     # 6 bytes  Load offset in symbl table in r1
 542          BRCL 15,-x       # 6 bytes  Jump to start of PLT
 543          .long ?          # 4 bytes  offset into symbol table
 544
 545    Total = 32 bytes per PLT entry
 546    Fixup at offset 2: relative address to GOT entry
 547    Fixup at offset 22: relative branch to PLT0
 548    Fixup at offset 28: 32 bit offset into symbol table
 549
 550    A 32 bit offset into the symbol table is enough. It allows for symbol
 551    tables up to a size of 2 gigabyte. A single dynamic object (the main
 552    program, any shared library) is limited to 4GB in size and I want to see
 553    the program that manages to have a symbol table of more than 2 GB with a
 554    total size of at max 4 GB.  */
 555
 556 static const bfd_byte elf_s390x_plt_entry[PLT_ENTRY_SIZE] =
 557   {
 558     0xc0, 0x10, 0x00, 0x00, 0x00, 0x00,     /* larl    %r1,.       */
 559     0xe3, 0x10, 0x10, 0x00, 0x00, 0x04,     /* lg      %r1,0(%r1)  */
 560     0x07, 0xf1,                             /* br      %r1         */
 561     0x0d, 0x10,                             /* basr    %r1,%r0     */
 562     0xe3, 0x10, 0x10, 0x0c, 0x00, 0x14,     /* lgf     %r1,12(%r1) */
 563     0xc0, 0xf4, 0x00, 0x00, 0x00, 0x00,     /* jg      first plt   */
 564     0x00, 0x00, 0x00, 0x00                  /* .long   0x00000000  */
 565   };
 566
 567 /* The first PLT entry pushes the offset into the symbol table
 568    from R1 onto the stack at 8(15) and the loader object info
 569    at 12(15), loads the loader address in R1 and jumps to it.  */
 570
 571 /* The first entry in the PLT:
 572
 573   PLT0:
 574      STG  1,56(15)  # r1 contains the offset into the symbol table
 575      LARL 1,_GLOBAL_OFFSET_TABLE # load address of global offset table
 576      MVC  48(8,15),8(1) # move loader ino (object struct address) to stack
 577      LG   1,16(1)   # get entry address of loader
 578      BCR  15,1      # jump to loader
 579
 580      Fixup at offset 8: relative address to start of GOT.  */
 581
 582 static const bfd_byte elf_s390x_first_plt_entry[PLT_FIRST_ENTRY_SIZE] =
 583   {
 584     0xe3, 0x10, 0xf0, 0x38, 0x00, 0x24,     /* stg     %r1,56(%r15)      */
 585     0xc0, 0x10, 0x00, 0x00, 0x00, 0x00,     /* larl    %r1,.             */
 586     0xd2, 0x07, 0xf0, 0x30, 0x10, 0x08,     /* mvc     48(8,%r15),8(%r1) */
 587     0xe3, 0x10, 0x10, 0x10, 0x00, 0x04,     /* lg      %r1,16(%r1)       */
 588     0x07, 0xf1,                             /* br      %r1               */
 589     0x07, 0x00,                             /* nopr    %r0               */
 590     0x07, 0x00,                             /* nopr    %r0               */
 591     0x07, 0x00                              /* nopr    %r0               */
 592   };
 593
 594
 595 /* s390 ELF linker hash entry.  */
 596
 597 struct elf_s390_link_hash_entry
 598 {
 599   struct elf_link_hash_entry elf;
 600
 601   /* Track dynamic relocs copied for this symbol.  */
 602   struct elf_dyn_relocs *dyn_relocs;
 603
 604   /* Number of GOTPLT references for a function.  */
 605   bfd_signed_vma gotplt_refcount;
 606
 607 #define GOT_UNKNOWN     0
 608 #define GOT_NORMAL      1
 609 #define GOT_TLS_GD      2
 610 #define GOT_TLS_IE      3
 611 #define GOT_TLS_IE_NLT  3
 612   unsigned char tls_type;
 613 };
 614
 615 #define elf_s390_hash_entry(ent) \
 616   ((struct elf_s390_link_hash_entry *)(ent))
 617
 618 /* NOTE: Keep this structure in sync with
 619    the one declared in elf32-s390.c.  */
 620 struct elf_s390_obj_tdata
 621 {
 622   struct elf_obj_tdata root;
 623
 624   /* TLS type for each local got entry.  */
 625   char *local_got_tls_type;
 626 };
 627
 628 #define elf_s390_tdata(abfd) \
 629   ((struct elf_s390_obj_tdata *) (abfd)->tdata.any)
 630
 631 #define elf_s390_local_got_tls_type(abfd) \
 632   (elf_s390_tdata (abfd)->local_got_tls_type)
 633
 634 #define is_s390_elf(bfd)                                \
 635   (bfd_get_flavour (bfd) == bfd_target_elf_flavour      \
 636    && elf_tdata (bfd) != NULL                           \
 637    && elf_object_id (bfd) == S390_ELF_DATA)
 638
 639 static bfd_boolean
 640 elf_s390_mkobject (bfd *abfd)
 641 {
 642   return bfd_elf_allocate_object (abfd, sizeof (struct elf_s390_obj_tdata),
 643                                   S390_ELF_DATA);
 644 }
 645
 646 static bfd_boolean
 647 elf_s390_object_p (abfd)
 648      bfd *abfd;
 649 {
 650   /* Set the right machine number for an s390 elf32 file.  */
 651   return bfd_default_set_arch_mach (abfd, bfd_arch_s390, bfd_mach_s390_64);
 652 }
 653
 654 /* s390 ELF linker hash table.  */
 655
 656 struct elf_s390_link_hash_table
 657 {
 658   struct elf_link_hash_table elf;
 659
 660   /* Short-cuts to get to dynamic linker sections.  */
 661   asection *sgot;
 662   asection *sgotplt;
 663   asection *srelgot;
 664   asection *splt;
 665   asection *srelplt;
 666   asection *sdynbss;
 667   asection *srelbss;
 668
 669   union {
 670     bfd_signed_vma refcount;
 671     bfd_vma offset;
 672   } tls_ldm_got;
 673
 674   /* Small local sym cache.  */
 675   struct sym_cache sym_cache;
 676 };
 677
 678 /* Get the s390 ELF linker hash table from a link_info structure.  */
 679
 680 #define elf_s390_hash_table(p) \
 681   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
 682   == S390_ELF_DATA ? ((struct elf_s390_link_hash_table *) ((p)->hash)) : NULL)
 683
 684 /* Create an entry in an s390 ELF linker hash table.  */
 685
 686 static struct bfd_hash_entry *
 687 link_hash_newfunc (entry, table, string)
 688      struct bfd_hash_entry *entry;
 689      struct bfd_hash_table *table;
 690      const char *string;
 691 {
 692   /* Allocate the structure if it has not already been allocated by a
 693      subclass.  */
 694   if (entry == NULL)
 695     {
 696       entry = bfd_hash_allocate (table,
 697                                  sizeof (struct elf_s390_link_hash_entry));
 698       if (entry == NULL)
 699         return entry;
 700     }
 701
 702   /* Call the allocation method of the superclass.  */
 703   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
 704   if (entry != NULL)
 705     {
 706       struct elf_s390_link_hash_entry *eh;
 707
 708       eh = (struct elf_s390_link_hash_entry *) entry;
 709       eh->dyn_relocs = NULL;
 710       eh->gotplt_refcount = 0;
 711       eh->tls_type = GOT_UNKNOWN;
 712     }
 713
 714   return entry;
 715 }
 716
 717 /* Create an s390 ELF linker hash table.  */
 718
 719 static struct bfd_link_hash_table *
 720 elf_s390_link_hash_table_create (abfd)
 721      bfd *abfd;
 722 {
 723   struct elf_s390_link_hash_table *ret;
 724   bfd_size_type amt = sizeof (struct elf_s390_link_hash_table);
 725
 726   ret = (struct elf_s390_link_hash_table *) bfd_malloc (amt);
 727   if (ret == NULL)
 728     return NULL;
 729
 730   if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
 731                                       sizeof (struct elf_s390_link_hash_entry),
 732                                       S390_ELF_DATA))
 733     {
 734       free (ret);
 735       return NULL;
 736     }
 737
 738   ret->sgot = NULL;
 739   ret->sgotplt = NULL;
 740   ret->srelgot = NULL;
 741   ret->splt = NULL;
 742   ret->srelplt = NULL;
 743   ret->sdynbss = NULL;
 744   ret->srelbss = NULL;
 745   ret->tls_ldm_got.refcount = 0;
 746   ret->sym_cache.abfd = NULL;
 747
 748   return &ret->elf.root;
 749 }
 750
 751 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
 752    shortcuts to them in our hash table.  */
 753
 754 static bfd_boolean
 755 create_got_section (bfd *dynobj,
 756                     struct bfd_link_info *info)
 757 {
 758   struct elf_s390_link_hash_table *htab;
 759
 760   if (! _bfd_elf_create_got_section (dynobj, info))
 761     return FALSE;
 762
 763   htab = elf_s390_hash_table (info);
 764   if (htab == NULL)
 765     return FALSE;
 766
 767   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
 768   htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
 769   htab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
 770   if (!htab->sgot || !htab->sgotplt || !htab->srelgot)
 771     abort ();
 772   return TRUE;
 773 }
 774
 775 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
 776    .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
 777    hash table.  */
 778
 779 static bfd_boolean
 780 elf_s390_create_dynamic_sections (bfd *dynobj,
 781                                   struct bfd_link_info *info)
 782 {
 783   struct elf_s390_link_hash_table *htab;
 784
 785   htab = elf_s390_hash_table (info);
 786   if (htab == NULL)
 787     return FALSE;
 788
 789   if (!htab->sgot && !create_got_section (dynobj, info))
 790     return FALSE;
 791
 792   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
 793     return FALSE;
 794
 795   htab->splt = bfd_get_section_by_name (dynobj, ".plt");
 796   htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
 797   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
 798   if (!info->shared)
 799     htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
 800
 801   if (!htab->splt || !htab->srelplt || !htab->sdynbss
 802       || (!info->shared && !htab->srelbss))
 803     abort ();
 804
 805   return TRUE;
 806 }
 807
 808 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
 809
 810 static void
 811 elf_s390_copy_indirect_symbol (info, dir, ind)
 812      struct bfd_link_info *info;
 813      struct elf_link_hash_entry *dir, *ind;
 814 {
 815   struct elf_s390_link_hash_entry *edir, *eind;
 816
 817   edir = (struct elf_s390_link_hash_entry *) dir;
 818   eind = (struct elf_s390_link_hash_entry *) ind;
 819
 820   if (eind->dyn_relocs != NULL)
 821     {
 822       if (edir->dyn_relocs != NULL)
 823         {
 824           struct elf_dyn_relocs **pp;
 825           struct elf_dyn_relocs *p;
 826
 827           /* Add reloc counts against the indirect sym to the direct sym
 828              list.  Merge any entries against the same section.  */
 829           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
 830             {
 831               struct elf_dyn_relocs *q;
 832
 833               for (q = edir->dyn_relocs; q != NULL; q = q->next)
 834                 if (q->sec == p->sec)
 835                   {
 836                     q->pc_count += p->pc_count;
 837                     q->count += p->count;
 838                     *pp = p->next;
 839                     break;
 840                   }
 841               if (q == NULL)
 842                 pp = &p->next;
 843             }
 844           *pp = edir->dyn_relocs;
 845         }
 846
 847       edir->dyn_relocs = eind->dyn_relocs;
 848       eind->dyn_relocs = NULL;
 849     }
 850
 851   if (ind->root.type == bfd_link_hash_indirect
 852       && dir->got.refcount <= 0)
 853     {
 854       edir->tls_type = eind->tls_type;
 855       eind->tls_type = GOT_UNKNOWN;
 856     }
 857
 858   if (ELIMINATE_COPY_RELOCS
 859       && ind->root.type != bfd_link_hash_indirect
 860       && dir->dynamic_adjusted)
 861     {
 862       /* If called to transfer flags for a weakdef during processing
 863          of elf_adjust_dynamic_symbol, don't copy non_got_ref.
 864          We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
 865       dir->ref_dynamic |= ind->ref_dynamic;
 866       dir->ref_regular |= ind->ref_regular;
 867       dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
 868       dir->needs_plt |= ind->needs_plt;
 869     }
 870   else
 871     _bfd_elf_link_hash_copy_indirect (info, dir, ind);
 872 }
 873
 874 static int
 875 elf_s390_tls_transition (info, r_type, is_local)
 876      struct bfd_link_info *info;
 877      int r_type;
 878      int is_local;
 879 {
 880   if (info->shared)
 881     return r_type;
 882
 883   switch (r_type)
 884     {
 885     case R_390_TLS_GD64:
 886     case R_390_TLS_IE64:
 887       if (is_local)
 888         return R_390_TLS_LE64;
 889       return R_390_TLS_IE64;
 890     case R_390_TLS_GOTIE64:
 891       if (is_local)
 892         return R_390_TLS_LE64;
 893       return R_390_TLS_GOTIE64;
 894     case R_390_TLS_LDM64:
 895       return R_390_TLS_LE64;
 896     }
 897
 898   return r_type;
 899 }
 900
 901 /* Look through the relocs for a section during the first phase, and
 902    allocate space in the global offset table or procedure linkage
 903    table.  */
 904
 905 static bfd_boolean
 906 elf_s390_check_relocs (bfd *abfd,
 907                        struct bfd_link_info *info,
 908                        asection *sec,
 909                        const Elf_Internal_Rela *relocs)
 910 {
 911   struct elf_s390_link_hash_table *htab;
 912   Elf_Internal_Shdr *symtab_hdr;
 913   struct elf_link_hash_entry **sym_hashes;
 914   const Elf_Internal_Rela *rel;
 915   const Elf_Internal_Rela *rel_end;
 916   asection *sreloc;
 917   bfd_signed_vma *local_got_refcounts;
 918   int tls_type, old_tls_type;
 919
 920   if (info->relocatable)
 921     return TRUE;
 922
 923   BFD_ASSERT (is_s390_elf (abfd));
 924
 925   htab = elf_s390_hash_table (info);
 926   if (htab == NULL)
 927     return FALSE;
 928
 929   symtab_hdr = &elf_symtab_hdr (abfd);
 930   sym_hashes = elf_sym_hashes (abfd);
 931   local_got_refcounts = elf_local_got_refcounts (abfd);
 932
 933   sreloc = NULL;
 934
 935   rel_end = relocs + sec->reloc_count;
 936   for (rel = relocs; rel < rel_end; rel++)
 937     {
 938       unsigned int r_type;
 939       unsigned long r_symndx;
 940       struct elf_link_hash_entry *h;
 941
 942       r_symndx = ELF64_R_SYM (rel->r_info);
 943
 944       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
 945         {
 946           (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
 947                                  abfd,
 948                                  r_symndx);
 949           return FALSE;
 950         }
 951
 952       if (r_symndx < symtab_hdr->sh_info)
 953         h = NULL;
 954       else
 955         {
 956           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 957           while (h->root.type == bfd_link_hash_indirect
 958                  || h->root.type == bfd_link_hash_warning)
 959             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 960         }
 961
 962       /* Create got section and local_got_refcounts array if they
 963          are needed.  */
 964       r_type = elf_s390_tls_transition (info,
 965                                         ELF64_R_TYPE (rel->r_info),
 966                                         h == NULL);
 967       switch (r_type)
 968         {
 969         case R_390_GOT12:
 970         case R_390_GOT16:
 971         case R_390_GOT20:
 972         case R_390_GOT32:
 973         case R_390_GOT64:
 974         case R_390_GOTENT:
 975         case R_390_GOTPLT12:
 976         case R_390_GOTPLT16:
 977         case R_390_GOTPLT20:
 978         case R_390_GOTPLT32:
 979         case R_390_GOTPLT64:
 980         case R_390_GOTPLTENT:
 981         case R_390_TLS_GD64:
 982         case R_390_TLS_GOTIE12:
 983         case R_390_TLS_GOTIE20:
 984         case R_390_TLS_GOTIE64:
 985         case R_390_TLS_IEENT:
 986         case R_390_TLS_IE64:
 987         case R_390_TLS_LDM64:
 988           if (h == NULL
 989               && local_got_refcounts == NULL)
 990             {
 991               bfd_size_type size;
 992
 993               size = symtab_hdr->sh_info;
 994               size *= (sizeof (bfd_signed_vma) + sizeof(char));
 995               local_got_refcounts = ((bfd_signed_vma *)
 996                                      bfd_zalloc (abfd, size));
 997               if (local_got_refcounts == NULL)
 998                 return FALSE;
 999               elf_local_got_refcounts (abfd) = local_got_refcounts;
1000               elf_s390_local_got_tls_type (abfd)
1001                 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
1002             }
1003           /* Fall through.  */
1004         case R_390_GOTOFF16:
1005         case R_390_GOTOFF32:
1006         case R_390_GOTOFF64:
1007         case R_390_GOTPC:
1008         case R_390_GOTPCDBL:
1009           if (htab->sgot == NULL)
1010             {
1011               if (htab->elf.dynobj == NULL)
1012                 htab->elf.dynobj = abfd;
1013               if (!create_got_section (htab->elf.dynobj, info))
1014                 return FALSE;
1015             }
1016         }
1017
1018       switch (r_type)
1019         {
1020         case R_390_GOTOFF16:
1021         case R_390_GOTOFF32:
1022         case R_390_GOTOFF64:
1023         case R_390_GOTPC:
1024         case R_390_GOTPCDBL:
1025           /* Got is created, nothing to be done.  */
1026           break;
1027
1028         case R_390_PLT16DBL:
1029         case R_390_PLT32:
1030         case R_390_PLT32DBL:
1031         case R_390_PLT64:
1032         case R_390_PLTOFF16:
1033         case R_390_PLTOFF32:
1034         case R_390_PLTOFF64:
1035           /* This symbol requires a procedure linkage table entry.  We
1036              actually build the entry in adjust_dynamic_symbol,
1037              because this might be a case of linking PIC code which is
1038              never referenced by a dynamic object, in which case we
1039              don't need to generate a procedure linkage table entry
1040              after all.  */
1041
1042           /* If this is a local symbol, we resolve it directly without
1043              creating a procedure linkage table entry.  */
1044           if (h != NULL)
1045             {
1046               h->needs_plt = 1;
1047               h->plt.refcount += 1;
1048             }
1049           break;
1050
1051         case R_390_GOTPLT12:
1052         case R_390_GOTPLT16:
1053         case R_390_GOTPLT20:
1054         case R_390_GOTPLT32:
1055         case R_390_GOTPLT64:
1056         case R_390_GOTPLTENT:
1057           /* This symbol requires either a procedure linkage table entry
1058              or an entry in the local got. We actually build the entry
1059              in adjust_dynamic_symbol because whether this is really a
1060              global reference can change and with it the fact if we have
1061              to create a plt entry or a local got entry. To be able to
1062              make a once global symbol a local one we have to keep track
1063              of the number of gotplt references that exist for this
1064              symbol.  */
1065           if (h != NULL)
1066             {
1067               ((struct elf_s390_link_hash_entry *) h)->gotplt_refcount++;
1068               h->needs_plt = 1;
1069               h->plt.refcount += 1;
1070             }
1071           else
1072             local_got_refcounts[r_symndx] += 1;
1073           break;
1074
1075         case R_390_TLS_LDM64:
1076           htab->tls_ldm_got.refcount += 1;
1077           break;
1078
1079         case R_390_TLS_IE64:
1080         case R_390_TLS_GOTIE12:
1081         case R_390_TLS_GOTIE20:
1082         case R_390_TLS_GOTIE64:
1083         case R_390_TLS_IEENT:
1084           if (info->shared)
1085             info->flags |= DF_STATIC_TLS;
1086           /* Fall through */
1087
1088         case R_390_GOT12:
1089         case R_390_GOT16:
1090         case R_390_GOT20:
1091         case R_390_GOT32:
1092         case R_390_GOT64:
1093         case R_390_GOTENT:
1094         case R_390_TLS_GD64:
1095           /* This symbol requires a global offset table entry.  */
1096           switch (r_type)
1097             {
1098             default:
1099             case R_390_GOT12:
1100             case R_390_GOT16:
1101             case R_390_GOT20:
1102             case R_390_GOT32:
1103             case R_390_GOTENT:
1104               tls_type = GOT_NORMAL;
1105               break;
1106             case R_390_TLS_GD64:
1107               tls_type = GOT_TLS_GD;
1108               break;
1109             case R_390_TLS_IE64:
1110             case R_390_TLS_GOTIE64:
1111               tls_type = GOT_TLS_IE;
1112               break;
1113             case R_390_TLS_GOTIE12:
1114             case R_390_TLS_GOTIE20:
1115             case R_390_TLS_IEENT:
1116               tls_type = GOT_TLS_IE_NLT;
1117               break;
1118             }
1119
1120           if (h != NULL)
1121             {
1122               h->got.refcount += 1;
1123               old_tls_type = elf_s390_hash_entry(h)->tls_type;
1124             }
1125           else
1126             {
1127               local_got_refcounts[r_symndx] += 1;
1128               old_tls_type = elf_s390_local_got_tls_type (abfd) [r_symndx];
1129             }
1130           /* If a TLS symbol is accessed using IE at least once,
1131              there is no point to use dynamic model for it.  */
1132           if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN)
1133             {
1134               if (old_tls_type == GOT_NORMAL || tls_type == GOT_NORMAL)
1135                 {
1136                   (*_bfd_error_handler)
1137                     (_("%B: `%s' accessed both as normal and thread local symbol"),
1138                      abfd, h->root.root.string);
1139                   return FALSE;
1140                 }
1141               if (old_tls_type > tls_type)
1142                 tls_type = old_tls_type;
1143             }
1144
1145           if (old_tls_type != tls_type)
1146             {
1147               if (h != NULL)
1148                 elf_s390_hash_entry (h)->tls_type = tls_type;
1149               else
1150                 elf_s390_local_got_tls_type (abfd) [r_symndx] = tls_type;
1151             }
1152
1153           if (r_type != R_390_TLS_IE64)
1154             break;
1155           /* Fall through */
1156
1157         case R_390_TLS_LE64:
1158           if (!info->shared)
1159             break;
1160           info->flags |= DF_STATIC_TLS;
1161           /* Fall through */
1162
1163         case R_390_8:
1164         case R_390_16:
1165         case R_390_32:
1166         case R_390_64:
1167         case R_390_PC16:
1168         case R_390_PC16DBL:
1169         case R_390_PC32:
1170         case R_390_PC32DBL:
1171         case R_390_PC64:
1172           if (h != NULL && !info->shared)
1173             {
1174               /* If this reloc is in a read-only section, we might
1175                  need a copy reloc.  We can't check reliably at this
1176                  stage whether the section is read-only, as input
1177                  sections have not yet been mapped to output sections.
1178                  Tentatively set the flag for now, and correct in
1179                  adjust_dynamic_symbol.  */
1180               h->non_got_ref = 1;
1181
1182               /* We may need a .plt entry if the function this reloc
1183                  refers to is in a shared lib.  */
1184               h->plt.refcount += 1;
1185             }
1186
1187           /* If we are creating a shared library, and this is a reloc
1188              against a global symbol, or a non PC relative reloc
1189              against a local symbol, then we need to copy the reloc
1190              into the shared library.  However, if we are linking with
1191              -Bsymbolic, we do not need to copy a reloc against a
1192              global symbol which is defined in an object we are
1193              including in the link (i.e., DEF_REGULAR is set).  At
1194              this point we have not seen all the input files, so it is
1195              possible that DEF_REGULAR is not set now but will be set
1196              later (it is never cleared).  In case of a weak definition,
1197              DEF_REGULAR may be cleared later by a strong definition in
1198              a shared library. We account for that possibility below by
1199              storing information in the relocs_copied field of the hash
1200              table entry.  A similar situation occurs when creating
1201              shared libraries and symbol visibility changes render the
1202              symbol local.
1203
1204              If on the other hand, we are creating an executable, we
1205              may need to keep relocations for symbols satisfied by a
1206              dynamic library if we manage to avoid copy relocs for the
1207              symbol.  */
1208           if ((info->shared
1209                && (sec->flags & SEC_ALLOC) != 0
1210                && ((ELF64_R_TYPE (rel->r_info) != R_390_PC16
1211                     && ELF64_R_TYPE (rel->r_info) != R_390_PC16DBL
1212                     && ELF64_R_TYPE (rel->r_info) != R_390_PC32
1213                     && ELF64_R_TYPE (rel->r_info) != R_390_PC32DBL
1214                     && ELF64_R_TYPE (rel->r_info) != R_390_PC64)
1215                    || (h != NULL
1216                        && (! SYMBOLIC_BIND (info, h)
1217                            || h->root.type == bfd_link_hash_defweak
1218                            || !h->def_regular))))
1219               || (ELIMINATE_COPY_RELOCS
1220                   && !info->shared
1221                   && (sec->flags & SEC_ALLOC) != 0
1222                   && h != NULL
1223                   && (h->root.type == bfd_link_hash_defweak
1224                       || !h->def_regular)))
1225             {
1226               struct elf_dyn_relocs *p;
1227               struct elf_dyn_relocs **head;
1228
1229               /* We must copy these reloc types into the output file.
1230                  Create a reloc section in dynobj and make room for
1231                  this reloc.  */
1232               if (sreloc == NULL)
1233                 {
1234                   if (htab->elf.dynobj == NULL)
1235                     htab->elf.dynobj = abfd;
1236
1237                   sreloc = _bfd_elf_make_dynamic_reloc_section
1238                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
1239
1240                   if (sreloc == NULL)
1241                     return FALSE;
1242                 }
1243
1244               /* If this is a global symbol, we count the number of
1245                  relocations we need for this symbol.  */
1246               if (h != NULL)
1247                 {
1248                   head = &((struct elf_s390_link_hash_entry *) h)->dyn_relocs;
1249                 }
1250               else
1251                 {
1252                   /* Track dynamic relocs needed for local syms too.
1253                      We really need local syms available to do this
1254                      easily.  Oh well.  */
1255                   asection *s;
1256                   void *vpp;
1257                   Elf_Internal_Sym *isym;
1258
1259                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1260                                                 abfd, r_symndx);
1261                   if (isym == NULL)
1262                     return FALSE;
1263
1264                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1265                   if (s == NULL)
1266                     s = sec;
1267
1268                   vpp = &elf_section_data (s)->local_dynrel;
1269                   head = (struct elf_dyn_relocs **) vpp;
1270                 }
1271
1272               p = *head;
1273               if (p == NULL || p->sec != sec)
1274                 {
1275                   bfd_size_type amt = sizeof *p;
1276                   p = ((struct elf_dyn_relocs *)
1277                        bfd_alloc (htab->elf.dynobj, amt));
1278                   if (p == NULL)
1279                     return FALSE;
1280                   p->next = *head;
1281                   *head = p;
1282                   p->sec = sec;
1283                   p->count = 0;
1284                   p->pc_count = 0;
1285                 }
1286
1287               p->count += 1;
1288               if (ELF64_R_TYPE (rel->r_info) == R_390_PC16
1289                   || ELF64_R_TYPE (rel->r_info) == R_390_PC16DBL
1290                   || ELF64_R_TYPE (rel->r_info) == R_390_PC32
1291                   || ELF64_R_TYPE (rel->r_info) == R_390_PC32DBL
1292                   || ELF64_R_TYPE (rel->r_info) == R_390_PC64)
1293                 p->pc_count += 1;
1294             }
1295           break;
1296
1297           /* This relocation describes the C++ object vtable hierarchy.
1298              Reconstruct it for later use during GC.  */
1299         case R_390_GNU_VTINHERIT:
1300           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1301             return FALSE;
1302           break;
1303
1304           /* This relocation describes which C++ vtable entries are actually
1305              used.  Record for later use during GC.  */
1306         case R_390_GNU_VTENTRY:
1307           BFD_ASSERT (h != NULL);
1308           if (h != NULL
1309               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1310             return FALSE;
1311           break;
1312
1313         default:
1314           break;
1315         }
1316     }
1317
1318   return TRUE;
1319 }
1320
1321 /* Return the section that should be marked against GC for a given
1322    relocation.  */
1323
1324 static asection *
1325 elf_s390_gc_mark_hook (asection *sec,
1326                        struct bfd_link_info *info,
1327                        Elf_Internal_Rela *rel,
1328                        struct elf_link_hash_entry *h,
1329                        Elf_Internal_Sym *sym)
1330 {
1331   if (h != NULL)
1332     switch (ELF64_R_TYPE (rel->r_info))
1333       {
1334       case R_390_GNU_VTINHERIT:
1335       case R_390_GNU_VTENTRY:
1336         return NULL;
1337       }
1338
1339   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1340 }
1341
1342 /* Update the got entry reference counts for the section being removed.  */
1343
1344 static bfd_boolean
1345 elf_s390_gc_sweep_hook (bfd *abfd,
1346                         struct bfd_link_info *info,
1347                         asection *sec,
1348                         const Elf_Internal_Rela *relocs)
1349 {
1350   struct elf_s390_link_hash_table *htab;
1351   Elf_Internal_Shdr *symtab_hdr;
1352   struct elf_link_hash_entry **sym_hashes;
1353   bfd_signed_vma *local_got_refcounts;
1354   const Elf_Internal_Rela *rel, *relend;
1355
1356   if (info->relocatable)
1357     return TRUE;
1358
1359   htab = elf_s390_hash_table (info);
1360   if (htab == NULL)
1361     return FALSE;
1362
1363   elf_section_data (sec)->local_dynrel = NULL;
1364
1365   symtab_hdr = &elf_symtab_hdr (abfd);
1366   sym_hashes = elf_sym_hashes (abfd);
1367   local_got_refcounts = elf_local_got_refcounts (abfd);
1368
1369   relend = relocs + sec->reloc_count;
1370   for (rel = relocs; rel < relend; rel++)
1371     {
1372       unsigned long r_symndx;
1373       unsigned int r_type;
1374       struct elf_link_hash_entry *h = NULL;
1375
1376       r_symndx = ELF64_R_SYM (rel->r_info);
1377       if (r_symndx >= symtab_hdr->sh_info)
1378         {
1379           struct elf_s390_link_hash_entry *eh;
1380           struct elf_dyn_relocs **pp;
1381           struct elf_dyn_relocs *p;
1382
1383           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1384           while (h->root.type == bfd_link_hash_indirect
1385                  || h->root.type == bfd_link_hash_warning)
1386             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1387           eh = (struct elf_s390_link_hash_entry *) h;
1388
1389           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1390             if (p->sec == sec)
1391               {
1392                 /* Everything must go for SEC.  */
1393                 *pp = p->next;
1394                 break;
1395               }
1396         }
1397
1398       r_type = ELF64_R_TYPE (rel->r_info);
1399       r_type = elf_s390_tls_transition (info, r_type, h != NULL);
1400       switch (r_type)
1401         {
1402         case R_390_TLS_LDM64:
1403           if (htab->tls_ldm_got.refcount > 0)
1404             htab->tls_ldm_got.refcount -= 1;
1405           break;
1406
1407         case R_390_TLS_GD64:
1408         case R_390_TLS_IE64:
1409         case R_390_TLS_GOTIE12:
1410         case R_390_TLS_GOTIE20:
1411         case R_390_TLS_GOTIE64:
1412         case R_390_TLS_IEENT:
1413         case R_390_GOT12:
1414         case R_390_GOT16:
1415         case R_390_GOT20:
1416         case R_390_GOT32:
1417         case R_390_GOT64:
1418         case R_390_GOTOFF16:
1419         case R_390_GOTOFF32:
1420         case R_390_GOTOFF64:
1421         case R_390_GOTPC:
1422         case R_390_GOTPCDBL:
1423         case R_390_GOTENT:
1424           if (h != NULL)
1425             {
1426               if (h->got.refcount > 0)
1427                 h->got.refcount -= 1;
1428             }
1429           else if (local_got_refcounts != NULL)
1430             {
1431               if (local_got_refcounts[r_symndx] > 0)
1432                 local_got_refcounts[r_symndx] -= 1;
1433             }
1434           break;
1435
1436         case R_390_8:
1437         case R_390_12:
1438         case R_390_16:
1439         case R_390_20:
1440         case R_390_32:
1441         case R_390_64:
1442         case R_390_PC16:
1443         case R_390_PC16DBL:
1444         case R_390_PC32:
1445         case R_390_PC32DBL:
1446         case R_390_PC64:
1447           if (info->shared)
1448             break;
1449           /* Fall through */
1450
1451         case R_390_PLT16DBL:
1452         case R_390_PLT32:
1453         case R_390_PLT32DBL:
1454         case R_390_PLT64:
1455         case R_390_PLTOFF16:
1456         case R_390_PLTOFF32:
1457         case R_390_PLTOFF64:
1458           if (h != NULL)
1459             {
1460               if (h->plt.refcount > 0)
1461                 h->plt.refcount -= 1;
1462             }
1463           break;
1464
1465         case R_390_GOTPLT12:
1466         case R_390_GOTPLT16:
1467         case R_390_GOTPLT20:
1468         case R_390_GOTPLT32:
1469         case R_390_GOTPLT64:
1470         case R_390_GOTPLTENT:
1471           if (h != NULL)
1472             {
1473               if (h->plt.refcount > 0)
1474                 {
1475                   ((struct elf_s390_link_hash_entry *) h)->gotplt_refcount--;
1476                   h->plt.refcount -= 1;
1477                 }
1478             }
1479           else if (local_got_refcounts != NULL)
1480             {
1481               if (local_got_refcounts[r_symndx] > 0)
1482                 local_got_refcounts[r_symndx] -= 1;
1483             }
1484           break;
1485
1486         default:
1487           break;
1488         }
1489     }
1490
1491   return TRUE;
1492 }
1493
1494 /* Make sure we emit a GOT entry if the symbol was supposed to have a PLT
1495    entry but we found we will not create any.  Called when we find we will
1496    not have any PLT for this symbol, by for example
1497    elf_s390_adjust_dynamic_symbol when we're doing a proper dynamic link,
1498    or elf_s390_size_dynamic_sections if no dynamic sections will be
1499    created (we're only linking static objects).  */
1500
1501 static void
1502 elf_s390_adjust_gotplt (h)
1503      struct elf_s390_link_hash_entry *h;
1504 {
1505   if (h->elf.root.type == bfd_link_hash_warning)
1506     h = (struct elf_s390_link_hash_entry *) h->elf.root.u.i.link;
1507
1508   if (h->gotplt_refcount <= 0)
1509     return;
1510
1511   /* We simply add the number of gotplt references to the number
1512    * of got references for this symbol.  */
1513   h->elf.got.refcount += h->gotplt_refcount;
1514   h->gotplt_refcount = -1;
1515 }
1516
1517 /* Adjust a symbol defined by a dynamic object and referenced by a
1518    regular object.  The current definition is in some section of the
1519    dynamic object, but we're not including those sections.  We have to
1520    change the definition to something the rest of the link can
1521    understand.  */
1522
1523 static bfd_boolean
1524 elf_s390_adjust_dynamic_symbol (struct bfd_link_info *info,
1525                                 struct elf_link_hash_entry *h)
1526 {
1527   struct elf_s390_link_hash_table *htab;
1528   asection *s;
1529
1530   /* If this is a function, put it in the procedure linkage table.  We
1531      will fill in the contents of the procedure linkage table later
1532      (although we could actually do it here).  */
1533   if (h->type == STT_FUNC
1534       || h->needs_plt)
1535     {
1536       if (h->plt.refcount <= 0
1537           || SYMBOL_CALLS_LOCAL (info, h)
1538           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1539               && h->root.type == bfd_link_hash_undefweak))
1540         {
1541           /* This case can occur if we saw a PLT32 reloc in an input
1542              file, but the symbol was never referred to by a dynamic
1543              object, or if all references were garbage collected.  In
1544              such a case, we don't actually need to build a procedure
1545              linkage table, and we can just do a PC32 reloc instead.  */
1546           h->plt.offset = (bfd_vma) -1;
1547           h->needs_plt = 0;
1548           elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1549         }
1550
1551       return TRUE;
1552     }
1553   else
1554     /* It's possible that we incorrectly decided a .plt reloc was
1555        needed for an R_390_PC32 reloc to a non-function sym in
1556        check_relocs.  We can't decide accurately between function and
1557        non-function syms in check-relocs;  Objects loaded later in
1558        the link may change h->type.  So fix it now.  */
1559     h->plt.offset = (bfd_vma) -1;
1560
1561   /* If this is a weak symbol, and there is a real definition, the
1562      processor independent code will have arranged for us to see the
1563      real definition first, and we can just use the same value.  */
1564   if (h->u.weakdef != NULL)
1565     {
1566       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1567                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1568       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1569       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1570       if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1571         h->non_got_ref = h->u.weakdef->non_got_ref;
1572       return TRUE;
1573     }
1574
1575   /* This is a reference to a symbol defined by a dynamic object which
1576      is not a function.  */
1577
1578   /* If we are creating a shared library, we must presume that the
1579      only references to the symbol are via the global offset table.
1580      For such cases we need not do anything here; the relocations will
1581      be handled correctly by relocate_section.  */
1582   if (info->shared)
1583     return TRUE;
1584
1585   /* If there are no references to this symbol that do not use the
1586      GOT, we don't need to generate a copy reloc.  */
1587   if (!h->non_got_ref)
1588     return TRUE;
1589
1590   /* If -z nocopyreloc was given, we won't generate them either.  */
1591   if (info->nocopyreloc)
1592     {
1593       h->non_got_ref = 0;
1594       return TRUE;
1595     }
1596
1597   if (ELIMINATE_COPY_RELOCS)
1598     {
1599       struct elf_s390_link_hash_entry * eh;
1600       struct elf_dyn_relocs *p;
1601
1602       eh = (struct elf_s390_link_hash_entry *) h;
1603       for (p = eh->dyn_relocs; p != NULL; p = p->next)
1604         {
1605           s = p->sec->output_section;
1606           if (s != NULL && (s->flags & SEC_READONLY) != 0)
1607             break;
1608         }
1609
1610       /* If we didn't find any dynamic relocs in read-only sections, then
1611          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
1612       if (p == NULL)
1613         {
1614           h->non_got_ref = 0;
1615           return TRUE;
1616         }
1617     }
1618
1619   /* We must allocate the symbol in our .dynbss section, which will
1620      become part of the .bss section of the executable.  There will be
1621      an entry for this symbol in the .dynsym section.  The dynamic
1622      object will contain position independent code, so all references
1623      from the dynamic object to this symbol will go through the global
1624      offset table.  The dynamic linker will use the .dynsym entry to
1625      determine the address it must put in the global offset table, so
1626      both the dynamic object and the regular object will refer to the
1627      same memory location for the variable.  */
1628
1629   htab = elf_s390_hash_table (info);
1630   if (htab == NULL)
1631     return FALSE;
1632
1633   /* We must generate a R_390_COPY reloc to tell the dynamic linker to
1634      copy the initial value out of the dynamic object and into the
1635      runtime process image.  */
1636   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1637     {
1638       htab->srelbss->size += sizeof (Elf64_External_Rela);
1639       h->needs_copy = 1;
1640     }
1641
1642   s = htab->sdynbss;
1643
1644   return _bfd_elf_adjust_dynamic_copy (h, s);
1645 }
1646
1647 /* Allocate space in .plt, .got and associated reloc sections for
1648    dynamic relocs.  */
1649
1650 static bfd_boolean
1651 allocate_dynrelocs (struct elf_link_hash_entry *h,
1652                     void * inf)
1653 {
1654   struct bfd_link_info *info;
1655   struct elf_s390_link_hash_table *htab;
1656   struct elf_s390_link_hash_entry *eh;
1657   struct elf_dyn_relocs *p;
1658
1659   if (h->root.type == bfd_link_hash_indirect)
1660     return TRUE;
1661
1662   info = (struct bfd_link_info *) inf;
1663   htab = elf_s390_hash_table (info);
1664   if (htab == NULL)
1665     return FALSE;
1666
1667   if (htab->elf.dynamic_sections_created
1668       && h->plt.refcount > 0)
1669     {
1670       /* Make sure this symbol is output as a dynamic symbol.
1671          Undefined weak syms won't yet be marked as dynamic.  */
1672       if (h->dynindx == -1
1673           && !h->forced_local)
1674         {
1675           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1676             return FALSE;
1677         }
1678
1679       if (info->shared
1680           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1681         {
1682           asection *s = htab->splt;
1683
1684           /* If this is the first .plt entry, make room for the special
1685              first entry.  */
1686           if (s->size == 0)
1687             s->size += PLT_FIRST_ENTRY_SIZE;
1688
1689           h->plt.offset = s->size;
1690
1691           /* If this symbol is not defined in a regular file, and we are
1692              not generating a shared library, then set the symbol to this
1693              location in the .plt.  This is required to make function
1694              pointers compare as equal between the normal executable and
1695              the shared library.  */
1696           if (! info->shared
1697               && !h->def_regular)
1698             {
1699               h->root.u.def.section = s;
1700               h->root.u.def.value = h->plt.offset;
1701             }
1702
1703           /* Make room for this entry.  */
1704           s->size += PLT_ENTRY_SIZE;
1705
1706           /* We also need to make an entry in the .got.plt section, which
1707              will be placed in the .got section by the linker script.  */
1708           htab->sgotplt->size += GOT_ENTRY_SIZE;
1709
1710           /* We also need to make an entry in the .rela.plt section.  */
1711           htab->srelplt->size += sizeof (Elf64_External_Rela);
1712         }
1713       else
1714         {
1715           h->plt.offset = (bfd_vma) -1;
1716           h->needs_plt = 0;
1717           elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1718         }
1719     }
1720   else
1721     {
1722       h->plt.offset = (bfd_vma) -1;
1723       h->needs_plt = 0;
1724       elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1725     }
1726
1727   /* If R_390_TLS_{IE64,GOTIE64,GOTIE12,IEENT} symbol is now local to
1728      the binary, we can optimize a bit. IE64 and GOTIE64 get converted
1729      to R_390_TLS_LE64 requiring no TLS entry. For GOTIE12 and IEENT
1730      we can save the dynamic TLS relocation.  */
1731   if (h->got.refcount > 0
1732       && !info->shared
1733       && h->dynindx == -1
1734       && elf_s390_hash_entry(h)->tls_type >= GOT_TLS_IE)
1735     {
1736       if (elf_s390_hash_entry(h)->tls_type == GOT_TLS_IE_NLT)
1737         /* For the GOTIE access without a literal pool entry the offset has
1738            to be stored somewhere. The immediate value in the instruction
1739            is not bit enough so the value is stored in the got.  */
1740         {
1741           h->got.offset = htab->sgot->size;
1742           htab->sgot->size += GOT_ENTRY_SIZE;
1743         }
1744       else
1745         h->got.offset = (bfd_vma) -1;
1746     }
1747   else if (h->got.refcount > 0)
1748     {
1749       asection *s;
1750       bfd_boolean dyn;
1751       int tls_type = elf_s390_hash_entry(h)->tls_type;
1752
1753       /* Make sure this symbol is output as a dynamic symbol.
1754          Undefined weak syms won't yet be marked as dynamic.  */
1755       if (h->dynindx == -1
1756           && !h->forced_local)
1757         {
1758           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1759             return FALSE;
1760         }
1761
1762       s = htab->sgot;
1763       h->got.offset = s->size;
1764       s->size += GOT_ENTRY_SIZE;
1765       /* R_390_TLS_GD64 needs 2 consecutive GOT slots.  */
1766       if (tls_type == GOT_TLS_GD)
1767         s->size += GOT_ENTRY_SIZE;
1768       dyn = htab->elf.dynamic_sections_created;
1769       /* R_390_TLS_IE64 needs one dynamic relocation,
1770          R_390_TLS_GD64 needs one if local symbol and two if global.  */
1771       if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1772           || tls_type >= GOT_TLS_IE)
1773         htab->srelgot->size += sizeof (Elf64_External_Rela);
1774       else if (tls_type == GOT_TLS_GD)
1775         htab->srelgot->size += 2 * sizeof (Elf64_External_Rela);
1776       else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1777                 || h->root.type != bfd_link_hash_undefweak)
1778                && (info->shared
1779                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1780         htab->srelgot->size += sizeof (Elf64_External_Rela);
1781     }
1782   else
1783     h->got.offset = (bfd_vma) -1;
1784
1785   eh = (struct elf_s390_link_hash_entry *) h;
1786   if (eh->dyn_relocs == NULL)
1787     return TRUE;
1788
1789   /* In the shared -Bsymbolic case, discard space allocated for
1790      dynamic pc-relative relocs against symbols which turn out to be
1791      defined in regular objects.  For the normal shared case, discard
1792      space for pc-relative relocs that have become local due to symbol
1793      visibility changes.  */
1794
1795   if (info->shared)
1796     {
1797       if (SYMBOL_CALLS_LOCAL (info, h))
1798         {
1799           struct elf_dyn_relocs **pp;
1800
1801           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1802             {
1803               p->count -= p->pc_count;
1804               p->pc_count = 0;
1805               if (p->count == 0)
1806                 *pp = p->next;
1807               else
1808                 pp = &p->next;
1809             }
1810         }
1811
1812       /* Also discard relocs on undefined weak syms with non-default
1813          visibility.  */
1814       if (eh->dyn_relocs != NULL
1815           && h->root.type == bfd_link_hash_undefweak)
1816         {
1817           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1818             eh->dyn_relocs = NULL;
1819
1820           /* Make sure undefined weak symbols are output as a dynamic
1821              symbol in PIEs.  */
1822           else if (h->dynindx == -1
1823                    && !h->forced_local)
1824             {
1825               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1826                 return FALSE;
1827             }
1828         }
1829     }
1830   else if (ELIMINATE_COPY_RELOCS)
1831     {
1832       /* For the non-shared case, discard space for relocs against
1833          symbols which turn out to need copy relocs or are not
1834          dynamic.  */
1835
1836       if (!h->non_got_ref
1837           && ((h->def_dynamic
1838                && !h->def_regular)
1839               || (htab->elf.dynamic_sections_created
1840                   && (h->root.type == bfd_link_hash_undefweak
1841                       || h->root.type == bfd_link_hash_undefined))))
1842         {
1843           /* Make sure this symbol is output as a dynamic symbol.
1844              Undefined weak syms won't yet be marked as dynamic.  */
1845           if (h->dynindx == -1
1846               && !h->forced_local)
1847             {
1848               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1849                 return FALSE;
1850             }
1851
1852           /* If that succeeded, we know we'll be keeping all the
1853              relocs.  */
1854           if (h->dynindx != -1)
1855             goto keep;
1856         }
1857
1858       eh->dyn_relocs = NULL;
1859
1860     keep: ;
1861     }
1862
1863   /* Finally, allocate space.  */
1864   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1865     {
1866       asection *sreloc = elf_section_data (p->sec)->sreloc;
1867       sreloc->size += p->count * sizeof (Elf64_External_Rela);
1868     }
1869
1870   return TRUE;
1871 }
1872
1873 /* Find any dynamic relocs that apply to read-only sections.  */
1874
1875 static bfd_boolean
1876 readonly_dynrelocs (h, inf)
1877      struct elf_link_hash_entry *h;
1878      PTR inf;
1879 {
1880   struct elf_s390_link_hash_entry *eh;
1881   struct elf_dyn_relocs *p;
1882
1883   eh = (struct elf_s390_link_hash_entry *) h;
1884   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1885     {
1886       asection *s = p->sec->output_section;
1887
1888       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1889         {
1890           struct bfd_link_info *info = (struct bfd_link_info *) inf;
1891
1892           info->flags |= DF_TEXTREL;
1893
1894           /* Not an error, just cut short the traversal.  */
1895           return FALSE;
1896         }
1897     }
1898   return TRUE;
1899 }
1900
1901 /* Set the sizes of the dynamic sections.  */
1902
1903 static bfd_boolean
1904 elf_s390_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1905                                 struct bfd_link_info *info)
1906 {
1907   struct elf_s390_link_hash_table *htab;
1908   bfd *dynobj;
1909   asection *s;
1910   bfd_boolean relocs;
1911   bfd *ibfd;
1912
1913   htab = elf_s390_hash_table (info);
1914   if (htab == NULL)
1915     return FALSE;
1916
1917   dynobj = htab->elf.dynobj;
1918   if (dynobj == NULL)
1919     abort ();
1920
1921   if (htab->elf.dynamic_sections_created)
1922     {
1923       /* Set the contents of the .interp section to the interpreter.  */
1924       if (info->executable)
1925         {
1926           s = bfd_get_section_by_name (dynobj, ".interp");
1927           if (s == NULL)
1928             abort ();
1929           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1930           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1931         }
1932     }
1933
1934   /* Set up .got offsets for local syms, and space for local dynamic
1935      relocs.  */
1936   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1937     {
1938       bfd_signed_vma *local_got;
1939       bfd_signed_vma *end_local_got;
1940       char *local_tls_type;
1941       bfd_size_type locsymcount;
1942       Elf_Internal_Shdr *symtab_hdr;
1943       asection *srela;
1944
1945       if (! is_s390_elf (ibfd))
1946         continue;
1947
1948       for (s = ibfd->sections; s != NULL; s = s->next)
1949         {
1950           struct elf_dyn_relocs *p;
1951
1952           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
1953             {
1954               if (!bfd_is_abs_section (p->sec)
1955                   && bfd_is_abs_section (p->sec->output_section))
1956                 {
1957                   /* Input section has been discarded, either because
1958                      it is a copy of a linkonce section or due to
1959                      linker script /DISCARD/, so we'll be discarding
1960                      the relocs too.  */
1961                 }
1962               else if (p->count != 0)
1963                 {
1964                   srela = elf_section_data (p->sec)->sreloc;
1965                   srela->size += p->count * sizeof (Elf64_External_Rela);
1966                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1967                     info->flags |= DF_TEXTREL;
1968                 }
1969             }
1970         }
1971
1972       local_got = elf_local_got_refcounts (ibfd);
1973       if (!local_got)
1974         continue;
1975
1976       symtab_hdr = &elf_symtab_hdr (ibfd);
1977       locsymcount = symtab_hdr->sh_info;
1978       end_local_got = local_got + locsymcount;
1979       local_tls_type = elf_s390_local_got_tls_type (ibfd);
1980       s = htab->sgot;
1981       srela = htab->srelgot;
1982       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1983         {
1984           if (*local_got > 0)
1985             {
1986               *local_got = s->size;
1987               s->size += GOT_ENTRY_SIZE;
1988               if (*local_tls_type == GOT_TLS_GD)
1989                 s->size += GOT_ENTRY_SIZE;
1990               if (info->shared)
1991                 srela->size += sizeof (Elf64_External_Rela);
1992             }
1993           else
1994             *local_got = (bfd_vma) -1;
1995         }
1996     }
1997
1998   if (htab->tls_ldm_got.refcount > 0)
1999     {
2000       /* Allocate 2 got entries and 1 dynamic reloc for R_390_TLS_LDM64
2001          relocs.  */
2002       htab->tls_ldm_got.offset = htab->sgot->size;
2003       htab->sgot->size += 2 * GOT_ENTRY_SIZE;
2004       htab->srelgot->size += sizeof (Elf64_External_Rela);
2005     }
2006   else
2007     htab->tls_ldm_got.offset = -1;
2008
2009   /* Allocate global sym .plt and .got entries, and space for global
2010      sym dynamic relocs.  */
2011   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
2012
2013   /* We now have determined the sizes of the various dynamic sections.
2014      Allocate memory for them.  */
2015   relocs = FALSE;
2016   for (s = dynobj->sections; s != NULL; s = s->next)
2017     {
2018       if ((s->flags & SEC_LINKER_CREATED) == 0)
2019         continue;
2020
2021       if (s == htab->splt
2022           || s == htab->sgot
2023           || s == htab->sgotplt
2024           || s == htab->sdynbss)
2025         {
2026           /* Strip this section if we don't need it; see the
2027              comment below.  */
2028         }
2029       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2030         {
2031           if (s->size != 0 && s != htab->srelplt)
2032             relocs = TRUE;
2033
2034           /* We use the reloc_count field as a counter if we need
2035              to copy relocs into the output file.  */
2036           s->reloc_count = 0;
2037         }
2038       else
2039         {
2040           /* It's not one of our sections, so don't allocate space.  */
2041           continue;
2042         }
2043
2044       if (s->size == 0)
2045         {
2046           /* If we don't need this section, strip it from the
2047              output file.  This is to handle .rela.bss and
2048              .rela.plt.  We must create it in
2049              create_dynamic_sections, because it must be created
2050              before the linker maps input sections to output
2051              sections.  The linker does that before
2052              adjust_dynamic_symbol is called, and it is that
2053              function which decides whether anything needs to go
2054              into these sections.  */
2055
2056           s->flags |= SEC_EXCLUDE;
2057           continue;
2058         }
2059
2060       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2061         continue;
2062
2063       /* Allocate memory for the section contents.  We use bfd_zalloc
2064          here in case unused entries are not reclaimed before the
2065          section's contents are written out.  This should not happen,
2066          but this way if it does, we get a R_390_NONE reloc instead
2067          of garbage.  */
2068       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2069       if (s->contents == NULL)
2070         return FALSE;
2071     }
2072
2073   if (htab->elf.dynamic_sections_created)
2074     {
2075       /* Add some entries to the .dynamic section.  We fill in the
2076          values later, in elf_s390_finish_dynamic_sections, but we
2077          must add the entries now so that we get the correct size for
2078          the .dynamic section.  The DT_DEBUG entry is filled in by the
2079          dynamic linker and used by the debugger.  */
2080 #define add_dynamic_entry(TAG, VAL) \
2081   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2082
2083       if (info->executable)
2084         {
2085           if (!add_dynamic_entry (DT_DEBUG, 0))
2086             return FALSE;
2087         }
2088
2089       if (htab->splt->size != 0)
2090         {
2091           if (!add_dynamic_entry (DT_PLTGOT, 0)
2092               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2093               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2094               || !add_dynamic_entry (DT_JMPREL, 0))
2095             return FALSE;
2096         }
2097
2098       if (relocs)
2099         {
2100           if (!add_dynamic_entry (DT_RELA, 0)
2101               || !add_dynamic_entry (DT_RELASZ, 0)
2102               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
2103             return FALSE;
2104
2105           /* If any dynamic relocs apply to a read-only section,
2106              then we need a DT_TEXTREL entry.  */
2107           if ((info->flags & DF_TEXTREL) == 0)
2108             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2109                                     (PTR) info);
2110
2111           if ((info->flags & DF_TEXTREL) != 0)
2112             {
2113               if (!add_dynamic_entry (DT_TEXTREL, 0))
2114                 return FALSE;
2115             }
2116         }
2117     }
2118 #undef add_dynamic_entry
2119
2120   return TRUE;
2121 }
2122
2123 /* Return the base VMA address which should be subtracted from real addresses
2124    when resolving @dtpoff relocation.
2125    This is PT_TLS segment p_vaddr.  */
2126
2127 static bfd_vma
2128 dtpoff_base (info)
2129      struct bfd_link_info *info;
2130 {
2131   /* If tls_sec is NULL, we should have signalled an error already.  */
2132   if (elf_hash_table (info)->tls_sec == NULL)
2133     return 0;
2134   return elf_hash_table (info)->tls_sec->vma;
2135 }
2136
2137 /* Return the relocation value for @tpoff relocation
2138    if STT_TLS virtual address is ADDRESS.  */
2139
2140 static bfd_vma
2141 tpoff (info, address)
2142      struct bfd_link_info *info;
2143      bfd_vma address;
2144 {
2145   struct elf_link_hash_table *htab = elf_hash_table (info);
2146
2147   /* If tls_sec is NULL, we should have signalled an error already.  */
2148   if (htab->tls_sec == NULL)
2149     return 0;
2150   return htab->tls_size + htab->tls_sec->vma - address;
2151 }
2152
2153 /* Complain if TLS instruction relocation is against an invalid
2154    instruction.  */
2155
2156 static void
2157 invalid_tls_insn (input_bfd, input_section, rel)
2158      bfd *input_bfd;
2159      asection *input_section;
2160      Elf_Internal_Rela *rel;
2161 {
2162   reloc_howto_type *howto;
2163
2164   howto = elf_howto_table + ELF64_R_TYPE (rel->r_info);
2165   (*_bfd_error_handler)
2166     (_("%B(%A+0x%lx): invalid instruction for TLS relocation %s"),
2167      input_bfd,
2168      input_section,
2169      (long) rel->r_offset,
2170      howto->name);
2171   bfd_set_error (bfd_error_bad_value);
2172 }
2173
2174 /* Relocate a 390 ELF section.  */
2175
2176 static bfd_boolean
2177 elf_s390_relocate_section (bfd *output_bfd,
2178                            struct bfd_link_info *info,
2179                            bfd *input_bfd,
2180                            asection *input_section,
2181                            bfd_byte *contents,
2182                            Elf_Internal_Rela *relocs,
2183                            Elf_Internal_Sym *local_syms,
2184                            asection **local_sections)
2185 {
2186   struct elf_s390_link_hash_table *htab;
2187   Elf_Internal_Shdr *symtab_hdr;
2188   struct elf_link_hash_entry **sym_hashes;
2189   bfd_vma *local_got_offsets;
2190   Elf_Internal_Rela *rel;
2191   Elf_Internal_Rela *relend;
2192
2193   BFD_ASSERT (is_s390_elf (input_bfd));
2194
2195   htab = elf_s390_hash_table (info);
2196   if (htab == NULL)
2197     return FALSE;
2198
2199   symtab_hdr = &elf_symtab_hdr (input_bfd);
2200   sym_hashes = elf_sym_hashes (input_bfd);
2201   local_got_offsets = elf_local_got_offsets (input_bfd);
2202
2203   rel = relocs;
2204   relend = relocs + input_section->reloc_count;
2205   for (; rel < relend; rel++)
2206     {
2207       unsigned int r_type;
2208       reloc_howto_type *howto;
2209       unsigned long r_symndx;
2210       struct elf_link_hash_entry *h;
2211       Elf_Internal_Sym *sym;
2212       asection *sec;
2213       bfd_vma off;
2214       bfd_vma relocation;
2215       bfd_boolean unresolved_reloc;
2216       bfd_reloc_status_type r;
2217       int tls_type;
2218
2219       r_type = ELF64_R_TYPE (rel->r_info);
2220       if (r_type == (int) R_390_GNU_VTINHERIT
2221           || r_type == (int) R_390_GNU_VTENTRY)
2222         continue;
2223       if (r_type >= (int) R_390_max)
2224         {
2225           bfd_set_error (bfd_error_bad_value);
2226           return FALSE;
2227         }
2228
2229       howto = elf_howto_table + r_type;
2230       r_symndx = ELF64_R_SYM (rel->r_info);
2231
2232       h = NULL;
2233       sym = NULL;
2234       sec = NULL;
2235       unresolved_reloc = FALSE;
2236       if (r_symndx < symtab_hdr->sh_info)
2237         {
2238           sym = local_syms + r_symndx;
2239           sec = local_sections[r_symndx];
2240           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2241         }
2242       else
2243         {
2244           bfd_boolean warned ATTRIBUTE_UNUSED;
2245
2246           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2247                                    r_symndx, symtab_hdr, sym_hashes,
2248                                    h, sec, relocation,
2249                                    unresolved_reloc, warned);
2250         }
2251
2252       if (sec != NULL && elf_discarded_section (sec))
2253         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2254                                          rel, relend, howto, contents);
2255
2256       if (info->relocatable)
2257         continue;
2258
2259       switch (r_type)
2260         {
2261         case R_390_GOTPLT12:
2262         case R_390_GOTPLT16:
2263         case R_390_GOTPLT20:
2264         case R_390_GOTPLT32:
2265         case R_390_GOTPLT64:
2266         case R_390_GOTPLTENT:
2267           /* There are three cases for a GOTPLT relocation. 1) The
2268              relocation is against the jump slot entry of a plt that
2269              will get emitted to the output file. 2) The relocation
2270              is against the jump slot of a plt entry that has been
2271              removed. elf_s390_adjust_gotplt has created a GOT entry
2272              as replacement. 3) The relocation is against a local symbol.
2273              Cases 2) and 3) are the same as the GOT relocation code
2274              so we just have to test for case 1 and fall through for
2275              the other two.  */
2276           if (h != NULL && h->plt.offset != (bfd_vma) -1)
2277             {
2278               bfd_vma plt_index;
2279
2280               /* Calc. index no.
2281                  Current offset - size first entry / entry size.  */
2282               plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) /
2283                 PLT_ENTRY_SIZE;
2284
2285               /* Offset in GOT is PLT index plus GOT headers(3) times 4,
2286                  addr & GOT addr.  */
2287               relocation = (plt_index + 3) * GOT_ENTRY_SIZE;
2288               unresolved_reloc = FALSE;
2289
2290               if (r_type == R_390_GOTPLTENT)
2291                 relocation += htab->sgot->output_section->vma;
2292               break;
2293             }
2294           /* Fall through.  */
2295
2296         case R_390_GOT12:
2297         case R_390_GOT16:
2298         case R_390_GOT20:
2299         case R_390_GOT32:
2300         case R_390_GOT64:
2301         case R_390_GOTENT:
2302           /* Relocation is to the entry for this symbol in the global
2303              offset table.  */
2304           if (htab->sgot == NULL)
2305             abort ();
2306
2307           if (h != NULL)
2308             {
2309               bfd_boolean dyn;
2310
2311               off = h->got.offset;
2312               dyn = htab->elf.dynamic_sections_created;
2313               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2314                   || (info->shared
2315                       && SYMBOL_REFERENCES_LOCAL (info, h))
2316                   || (ELF_ST_VISIBILITY (h->other)
2317                       && h->root.type == bfd_link_hash_undefweak))
2318                 {
2319                   /* This is actually a static link, or it is a
2320                      -Bsymbolic link and the symbol is defined
2321                      locally, or the symbol was forced to be local
2322                      because of a version file.  We must initialize
2323                      this entry in the global offset table.  Since the
2324                      offset must always be a multiple of 2, we use the
2325                      least significant bit to record whether we have
2326                      initialized it already.
2327
2328                      When doing a dynamic link, we create a .rel.got
2329                      relocation entry to initialize the value.  This
2330                      is done in the finish_dynamic_symbol routine.  */
2331                   if ((off & 1) != 0)
2332                     off &= ~1;
2333                   else
2334                     {
2335                       bfd_put_64 (output_bfd, relocation,
2336                                   htab->sgot->contents + off);
2337                       h->got.offset |= 1;
2338                     }
2339                 }
2340               else
2341                 unresolved_reloc = FALSE;
2342             }
2343           else
2344             {
2345               if (local_got_offsets == NULL)
2346                 abort ();
2347
2348               off = local_got_offsets[r_symndx];
2349
2350               /* The offset must always be a multiple of 8.  We use
2351                  the least significant bit to record whether we have
2352                  already generated the necessary reloc.  */
2353               if ((off & 1) != 0)
2354                 off &= ~1;
2355               else
2356                 {
2357                   bfd_put_64 (output_bfd, relocation,
2358                               htab->sgot->contents + off);
2359
2360                   if (info->shared)
2361                     {
2362                       asection *s;
2363                       Elf_Internal_Rela outrel;
2364                       bfd_byte *loc;
2365
2366                       s = htab->srelgot;
2367                       if (s == NULL)
2368                         abort ();
2369
2370                       outrel.r_offset = (htab->sgot->output_section->vma
2371                                          + htab->sgot->output_offset
2372                                          + off);
2373                       outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2374                       outrel.r_addend = relocation;
2375                       loc = s->contents;
2376                       loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
2377                       bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2378                     }
2379
2380                   local_got_offsets[r_symndx] |= 1;
2381                 }
2382             }
2383
2384           if (off >= (bfd_vma) -2)
2385             abort ();
2386
2387           relocation = htab->sgot->output_offset + off;
2388
2389           /* For @GOTENT the relocation is against the offset between
2390              the instruction and the symbols entry in the GOT and not
2391              between the start of the GOT and the symbols entry. We
2392              add the vma of the GOT to get the correct value.  */
2393           if (   r_type == R_390_GOTENT
2394               || r_type == R_390_GOTPLTENT)
2395             relocation += htab->sgot->output_section->vma;
2396
2397           break;
2398
2399         case R_390_GOTOFF16:
2400         case R_390_GOTOFF32:
2401         case R_390_GOTOFF64:
2402           /* Relocation is relative to the start of the global offset
2403              table.  */
2404
2405           /* Note that sgot->output_offset is not involved in this
2406              calculation.  We always want the start of .got.  If we
2407              defined _GLOBAL_OFFSET_TABLE in a different way, as is
2408              permitted by the ABI, we might have to change this
2409              calculation.  */
2410           relocation -= htab->sgot->output_section->vma;
2411           break;
2412
2413         case R_390_GOTPC:
2414         case R_390_GOTPCDBL:
2415           /* Use global offset table as symbol value.  */
2416           relocation = htab->sgot->output_section->vma;
2417           unresolved_reloc = FALSE;
2418           break;
2419
2420         case R_390_PLT16DBL:
2421         case R_390_PLT32:
2422         case R_390_PLT32DBL:
2423         case R_390_PLT64:
2424           /* Relocation is to the entry for this symbol in the
2425              procedure linkage table.  */
2426
2427           /* Resolve a PLT32 reloc against a local symbol directly,
2428              without using the procedure linkage table.  */
2429           if (h == NULL)
2430             break;
2431
2432           if (h->plt.offset == (bfd_vma) -1
2433               || htab->splt == NULL)
2434             {
2435               /* We didn't make a PLT entry for this symbol.  This
2436                  happens when statically linking PIC code, or when
2437                  using -Bsymbolic.  */
2438               break;
2439             }
2440
2441           relocation = (htab->splt->output_section->vma
2442                         + htab->splt->output_offset
2443                         + h->plt.offset);
2444           unresolved_reloc = FALSE;
2445           break;
2446
2447         case R_390_PLTOFF16:
2448         case R_390_PLTOFF32:
2449         case R_390_PLTOFF64:
2450           /* Relocation is to the entry for this symbol in the
2451              procedure linkage table relative to the start of the GOT.  */
2452
2453           /* For local symbols or if we didn't make a PLT entry for
2454              this symbol resolve the symbol directly.  */
2455           if (   h == NULL
2456               || h->plt.offset == (bfd_vma) -1
2457               || htab->splt == NULL)
2458             {
2459               relocation -= htab->sgot->output_section->vma;
2460               break;
2461             }
2462
2463           relocation = (htab->splt->output_section->vma
2464                         + htab->splt->output_offset
2465                         + h->plt.offset
2466                         - htab->sgot->output_section->vma);
2467           unresolved_reloc = FALSE;
2468           break;
2469
2470         case R_390_8:
2471         case R_390_16:
2472         case R_390_32:
2473         case R_390_64:
2474         case R_390_PC16:
2475         case R_390_PC16DBL:
2476         case R_390_PC32:
2477         case R_390_PC32DBL:
2478         case R_390_PC64:
2479           if ((input_section->flags & SEC_ALLOC) == 0)
2480             break;
2481
2482           if ((info->shared
2483                && (h == NULL
2484                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2485                    || h->root.type != bfd_link_hash_undefweak)
2486                && ((r_type != R_390_PC16
2487                     && r_type != R_390_PC16DBL
2488                     && r_type != R_390_PC32
2489                     && r_type != R_390_PC32DBL
2490                     && r_type != R_390_PC64)
2491                    || !SYMBOL_CALLS_LOCAL (info, h)))
2492               || (ELIMINATE_COPY_RELOCS
2493                   && !info->shared
2494                   && h != NULL
2495                   && h->dynindx != -1
2496                   && !h->non_got_ref
2497                   && ((h->def_dynamic
2498                        && !h->def_regular)
2499                       || h->root.type == bfd_link_hash_undefweak
2500                       || h->root.type == bfd_link_hash_undefined)))
2501             {
2502               Elf_Internal_Rela outrel;
2503               bfd_boolean skip, relocate;
2504               asection *sreloc;
2505               bfd_byte *loc;
2506
2507               /* When generating a shared object, these relocations
2508                  are copied into the output file to be resolved at run
2509                  time.  */
2510               skip = FALSE;
2511               relocate = FALSE;
2512
2513               outrel.r_offset =
2514                 _bfd_elf_section_offset (output_bfd, info, input_section,
2515                                          rel->r_offset);
2516               if (outrel.r_offset == (bfd_vma) -1)
2517                 skip = TRUE;
2518               else if (outrel.r_offset == (bfd_vma) -2)
2519                 skip = TRUE, relocate = TRUE;
2520
2521               outrel.r_offset += (input_section->output_section->vma
2522                                   + input_section->output_offset);
2523
2524               if (skip)
2525                 memset (&outrel, 0, sizeof outrel);
2526               else if (h != NULL
2527                        && h->dynindx != -1
2528                        && (r_type == R_390_PC16
2529                            || r_type == R_390_PC16DBL
2530                            || r_type == R_390_PC32
2531                            || r_type == R_390_PC32DBL
2532                            || r_type == R_390_PC64
2533                            || !info->shared
2534                            || !SYMBOLIC_BIND (info, h)
2535                            || !h->def_regular))
2536                 {
2537                   outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
2538                   outrel.r_addend = rel->r_addend;
2539                 }
2540               else
2541                 {
2542                   /* This symbol is local, or marked to become local.  */
2543                   outrel.r_addend = relocation + rel->r_addend;
2544                   if (r_type == R_390_64)
2545                     {
2546                       relocate = TRUE;
2547                       outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2548                     }
2549                   else
2550                     {
2551                       long sindx;
2552
2553                       if (bfd_is_abs_section (sec))
2554                         sindx = 0;
2555                       else if (sec == NULL || sec->owner == NULL)
2556                         {
2557                           bfd_set_error(bfd_error_bad_value);
2558                           return FALSE;
2559                         }
2560                       else
2561                         {
2562                           asection *osec;
2563
2564                           osec = sec->output_section;
2565                           sindx = elf_section_data (osec)->dynindx;
2566
2567                           if (sindx == 0)
2568                             {
2569                               osec = htab->elf.text_index_section;
2570                               sindx = elf_section_data (osec)->dynindx;
2571                             }
2572                           BFD_ASSERT (sindx != 0);
2573
2574                           /* We are turning this relocation into one
2575                              against a section symbol, so subtract out
2576                              the output section's address but not the
2577                              offset of the input section in the output
2578                              section.  */
2579                           outrel.r_addend -= osec->vma;
2580                         }
2581                       outrel.r_info = ELF64_R_INFO (sindx, r_type);
2582                     }
2583                 }
2584
2585               sreloc = elf_section_data (input_section)->sreloc;
2586               if (sreloc == NULL)
2587                 abort ();
2588
2589               loc = sreloc->contents;
2590               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2591               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2592
2593               /* If this reloc is against an external symbol, we do
2594                  not want to fiddle with the addend.  Otherwise, we
2595                  need to include the symbol value so that it becomes
2596                  an addend for the dynamic reloc.  */
2597               if (! relocate)
2598                 continue;
2599             }
2600
2601           break;
2602
2603           /* Relocations for tls literal pool entries.  */
2604         case R_390_TLS_IE64:
2605           if (info->shared)
2606             {
2607               Elf_Internal_Rela outrel;
2608               asection *sreloc;
2609               bfd_byte *loc;
2610
2611               outrel.r_offset = rel->r_offset
2612                                 + input_section->output_section->vma
2613                                 + input_section->output_offset;
2614               outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2615               sreloc = elf_section_data (input_section)->sreloc;
2616               if (sreloc == NULL)
2617                 abort ();
2618               loc = sreloc->contents;
2619               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2620               bfd_elf64_swap_reloc_out (output_bfd, &outrel, loc);
2621             }
2622           /* Fall through.  */
2623
2624         case R_390_TLS_GD64:
2625         case R_390_TLS_GOTIE64:
2626           r_type = elf_s390_tls_transition (info, r_type, h == NULL);
2627           tls_type = GOT_UNKNOWN;
2628           if (h == NULL && local_got_offsets)
2629             tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
2630           else if (h != NULL)
2631             {
2632               tls_type = elf_s390_hash_entry(h)->tls_type;
2633               if (!info->shared && h->dynindx == -1 && tls_type >= GOT_TLS_IE)
2634                 r_type = R_390_TLS_LE64;
2635             }
2636           if (r_type == R_390_TLS_GD64 && tls_type >= GOT_TLS_IE)
2637             r_type = R_390_TLS_IE64;
2638
2639           if (r_type == R_390_TLS_LE64)
2640             {
2641               /* This relocation gets optimized away by the local exec
2642                  access optimization.  */
2643               BFD_ASSERT (! unresolved_reloc);
2644               bfd_put_64 (output_bfd, -tpoff (info, relocation),
2645                           contents + rel->r_offset);
2646               continue;
2647             }
2648
2649           if (htab->sgot == NULL)
2650             abort ();
2651
2652           if (h != NULL)
2653             off = h->got.offset;
2654           else
2655             {
2656               if (local_got_offsets == NULL)
2657                 abort ();
2658
2659               off = local_got_offsets[r_symndx];
2660             }
2661
2662         emit_tls_relocs:
2663
2664           if ((off & 1) != 0)
2665             off &= ~1;
2666           else
2667             {
2668               Elf_Internal_Rela outrel;
2669               bfd_byte *loc;
2670               int dr_type, indx;
2671
2672               if (htab->srelgot == NULL)
2673                 abort ();
2674
2675               outrel.r_offset = (htab->sgot->output_section->vma
2676                                  + htab->sgot->output_offset + off);
2677
2678               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2679               if (r_type == R_390_TLS_GD64)
2680                 dr_type = R_390_TLS_DTPMOD;
2681               else
2682                 dr_type = R_390_TLS_TPOFF;
2683               if (dr_type == R_390_TLS_TPOFF && indx == 0)
2684                 outrel.r_addend = relocation - dtpoff_base (info);
2685               else
2686                 outrel.r_addend = 0;
2687               outrel.r_info = ELF64_R_INFO (indx, dr_type);
2688               loc = htab->srelgot->contents;
2689               loc += htab->srelgot->reloc_count++
2690                 * sizeof (Elf64_External_Rela);
2691               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2692
2693               if (r_type == R_390_TLS_GD64)
2694                 {
2695                   if (indx == 0)
2696                     {
2697                       BFD_ASSERT (! unresolved_reloc);
2698                       bfd_put_64 (output_bfd,
2699                                   relocation - dtpoff_base (info),
2700                                   htab->sgot->contents + off + GOT_ENTRY_SIZE);
2701                     }
2702                   else
2703                     {
2704                       outrel.r_info = ELF64_R_INFO (indx, R_390_TLS_DTPOFF);
2705                       outrel.r_offset += GOT_ENTRY_SIZE;
2706                       outrel.r_addend = 0;
2707                       htab->srelgot->reloc_count++;
2708                       loc += sizeof (Elf64_External_Rela);
2709                       bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2710                     }
2711                 }
2712
2713               if (h != NULL)
2714                 h->got.offset |= 1;
2715               else
2716                 local_got_offsets[r_symndx] |= 1;
2717             }
2718
2719           if (off >= (bfd_vma) -2)
2720             abort ();
2721           if (r_type == ELF64_R_TYPE (rel->r_info))
2722             {
2723               relocation = htab->sgot->output_offset + off;
2724               if (r_type == R_390_TLS_IE64 || r_type == R_390_TLS_IEENT)
2725                 relocation += htab->sgot->output_section->vma;
2726               unresolved_reloc = FALSE;
2727             }
2728           else
2729             {
2730               bfd_put_64 (output_bfd, htab->sgot->output_offset + off,
2731                           contents + rel->r_offset);
2732               continue;
2733             }
2734           break;
2735
2736         case R_390_TLS_GOTIE12:
2737         case R_390_TLS_GOTIE20:
2738         case R_390_TLS_IEENT:
2739           if (h == NULL)
2740             {
2741               if (local_got_offsets == NULL)
2742                 abort();
2743               off = local_got_offsets[r_symndx];
2744               if (info->shared)
2745                 goto emit_tls_relocs;
2746             }
2747           else
2748             {
2749               off = h->got.offset;
2750               tls_type = elf_s390_hash_entry(h)->tls_type;
2751               if (info->shared || h->dynindx != -1 || tls_type < GOT_TLS_IE)
2752                 goto emit_tls_relocs;
2753             }
2754
2755           if (htab->sgot == NULL)
2756             abort ();
2757
2758           BFD_ASSERT (! unresolved_reloc);
2759           bfd_put_64 (output_bfd, -tpoff (info, relocation),
2760                       htab->sgot->contents + off);
2761           relocation = htab->sgot->output_offset + off;
2762           if (r_type == R_390_TLS_IEENT)
2763             relocation += htab->sgot->output_section->vma;
2764           unresolved_reloc = FALSE;
2765           break;
2766
2767         case R_390_TLS_LDM64:
2768           if (! info->shared)
2769             /* The literal pool entry this relocation refers to gets ignored
2770                by the optimized code of the local exec model. Do nothing
2771                and the value will turn out zero.  */
2772             continue;
2773
2774           if (htab->sgot == NULL)
2775             abort ();
2776
2777           off = htab->tls_ldm_got.offset;
2778           if (off & 1)
2779             off &= ~1;
2780           else
2781             {
2782               Elf_Internal_Rela outrel;
2783               bfd_byte *loc;
2784
2785               if (htab->srelgot == NULL)
2786                 abort ();
2787
2788               outrel.r_offset = (htab->sgot->output_section->vma
2789                                  + htab->sgot->output_offset + off);
2790
2791               bfd_put_64 (output_bfd, 0,
2792                           htab->sgot->contents + off + GOT_ENTRY_SIZE);
2793               outrel.r_info = ELF64_R_INFO (0, R_390_TLS_DTPMOD);
2794               outrel.r_addend = 0;
2795               loc = htab->srelgot->contents;
2796               loc += htab->srelgot->reloc_count++
2797                 * sizeof (Elf64_External_Rela);
2798               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2799               htab->tls_ldm_got.offset |= 1;
2800             }
2801           relocation = htab->sgot->output_offset + off;
2802           unresolved_reloc = FALSE;
2803           break;
2804
2805         case R_390_TLS_LE64:
2806           if (info->shared)
2807             {
2808               /* Linking a shared library with non-fpic code requires
2809                  a R_390_TLS_TPOFF relocation.  */
2810               Elf_Internal_Rela outrel;
2811               asection *sreloc;
2812               bfd_byte *loc;
2813               int indx;
2814
2815               outrel.r_offset = rel->r_offset
2816                                 + input_section->output_section->vma
2817                                 + input_section->output_offset;
2818               if (h != NULL && h->dynindx != -1)
2819                 indx = h->dynindx;
2820               else
2821                 indx = 0;
2822               outrel.r_info = ELF64_R_INFO (indx, R_390_TLS_TPOFF);
2823               if (indx == 0)
2824                 outrel.r_addend = relocation - dtpoff_base (info);
2825               else
2826                 outrel.r_addend = 0;
2827               sreloc = elf_section_data (input_section)->sreloc;
2828               if (sreloc == NULL)
2829                 abort ();
2830               loc = sreloc->contents;
2831               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2832               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2833             }
2834           else
2835             {
2836               BFD_ASSERT (! unresolved_reloc);
2837               bfd_put_64 (output_bfd, -tpoff (info, relocation),
2838                           contents + rel->r_offset);
2839             }
2840           continue;
2841
2842         case R_390_TLS_LDO64:
2843           if (info->shared || (input_section->flags & SEC_DEBUGGING))
2844             relocation -= dtpoff_base (info);
2845           else
2846             /* When converting LDO to LE, we must negate.  */
2847             relocation = -tpoff (info, relocation);
2848           break;
2849
2850           /* Relocations for tls instructions.  */
2851         case R_390_TLS_LOAD:
2852         case R_390_TLS_GDCALL:
2853         case R_390_TLS_LDCALL:
2854           tls_type = GOT_UNKNOWN;
2855           if (h == NULL && local_got_offsets)
2856             tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
2857           else if (h != NULL)
2858             tls_type = elf_s390_hash_entry(h)->tls_type;
2859
2860           if (tls_type == GOT_TLS_GD)
2861             continue;
2862
2863           if (r_type == R_390_TLS_LOAD)
2864             {
2865               if (!info->shared && (h == NULL || h->dynindx == -1))
2866                 {
2867                   /* IE->LE transition. Four valid cases:
2868                      lg %rx,(0,%ry)    -> sllg %rx,%ry,0
2869                      lg %rx,(%ry,0)    -> sllg %rx,%ry,0
2870                      lg %rx,(%ry,%r12) -> sllg %rx,%ry,0
2871                      lg %rx,(%r12,%ry) -> sllg %rx,%ry,0  */
2872                   unsigned int insn0, insn1, ry;
2873
2874                   insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset);
2875                   insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4);
2876                   if (insn1 != 0x0004)
2877                     invalid_tls_insn (input_bfd, input_section, rel);
2878                   ry = 0;
2879                   if ((insn0 & 0xff00f000) == 0xe3000000)
2880                     /* lg %rx,0(%ry,0) -> sllg %rx,%ry,0  */
2881                     ry = (insn0 & 0x000f0000);
2882                   else if ((insn0 & 0xff0f0000) == 0xe3000000)
2883                     /* lg %rx,0(0,%ry) -> sllg %rx,%ry,0  */
2884                     ry = (insn0 & 0x0000f000) << 4;
2885                   else if ((insn0 & 0xff00f000) == 0xe300c000)
2886                     /* lg %rx,0(%ry,%r12) -> sllg %rx,%ry,0  */
2887                     ry = (insn0 & 0x000f0000);
2888                   else if ((insn0 & 0xff0f0000) == 0xe30c0000)
2889                     /* lg %rx,0(%r12,%ry) -> sllg %rx,%ry,0  */
2890                     ry = (insn0 & 0x0000f000) << 4;
2891                   else
2892                     invalid_tls_insn (input_bfd, input_section, rel);
2893                   insn0 = 0xeb000000 | (insn0 & 0x00f00000) | ry;
2894                   insn1 = 0x000d;
2895                   bfd_put_32 (output_bfd, insn0, contents + rel->r_offset);
2896                   bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4);
2897                 }
2898             }
2899           else if (r_type == R_390_TLS_GDCALL)
2900             {
2901               unsigned int insn0, insn1;
2902
2903               insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset);
2904               insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4);
2905               if ((insn0 & 0xffff0000) != 0xc0e50000)
2906                 invalid_tls_insn (input_bfd, input_section, rel);
2907               if (!info->shared && (h == NULL || h->dynindx == -1))
2908                 {
2909                   /* GD->LE transition.
2910                      brasl %r14,__tls_get_addr@plt -> brcl 0,. */
2911                   insn0 = 0xc0040000;
2912                   insn1 = 0x0000;
2913                 }
2914               else
2915                 {
2916                   /* GD->IE transition.
2917                      brasl %r14,__tls_get_addr@plt -> lg %r2,0(%r2,%r12)  */
2918                   insn0 = 0xe322c000;
2919                   insn1 = 0x0004;
2920                 }
2921               bfd_put_32 (output_bfd, insn0, contents + rel->r_offset);
2922               bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4);
2923             }
2924           else if (r_type == R_390_TLS_LDCALL)
2925             {
2926               if (!info->shared)
2927                 {
2928                   unsigned int insn0, insn1;
2929
2930                   insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset);
2931                   insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4);
2932                   if ((insn0 & 0xffff0000) != 0xc0e50000)
2933                     invalid_tls_insn (input_bfd, input_section, rel);
2934                   /* LD->LE transition.
2935                      brasl %r14,__tls_get_addr@plt -> brcl 0,. */
2936                   insn0 = 0xc0040000;
2937                   insn1 = 0x0000;
2938                   bfd_put_32 (output_bfd, insn0, contents + rel->r_offset);
2939                   bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4);
2940                 }
2941             }
2942           continue;
2943
2944         default:
2945           break;
2946         }
2947
2948       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2949          because such sections are not SEC_ALLOC and thus ld.so will
2950          not process them.  */
2951       if (unresolved_reloc
2952           && !((input_section->flags & SEC_DEBUGGING) != 0
2953                && h->def_dynamic)
2954           && _bfd_elf_section_offset (output_bfd, info, input_section,
2955                                       rel->r_offset) != (bfd_vma) -1)
2956         (*_bfd_error_handler)
2957           (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
2958            input_bfd,
2959            input_section,
2960            (long) rel->r_offset,
2961            howto->name,
2962            h->root.root.string);
2963
2964       if (r_type == R_390_20
2965           || r_type == R_390_GOT20
2966           || r_type == R_390_GOTPLT20
2967           || r_type == R_390_TLS_GOTIE20)
2968         {
2969           relocation += rel->r_addend;
2970           relocation = (relocation&0xfff) << 8 | (relocation&0xff000) >> 12;
2971           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2972                                         contents, rel->r_offset,
2973                                         relocation, 0);
2974         }
2975       else
2976         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2977                                       contents, rel->r_offset,
2978                                       relocation, rel->r_addend);
2979
2980       if (r != bfd_reloc_ok)
2981         {
2982           const char *name;
2983
2984           if (h != NULL)
2985             name = h->root.root.string;
2986           else
2987             {
2988               name = bfd_elf_string_from_elf_section (input_bfd,
2989                                                       symtab_hdr->sh_link,
2990                                                       sym->st_name);
2991               if (name == NULL)
2992                 return FALSE;
2993               if (*name == '\0')
2994                 name = bfd_section_name (input_bfd, sec);
2995             }
2996
2997           if (r == bfd_reloc_overflow)
2998             {
2999
3000               if (! ((*info->callbacks->reloc_overflow)
3001                      (info, (h ? &h->root : NULL), name, howto->name,
3002                       (bfd_vma) 0, input_bfd, input_section,
3003                       rel->r_offset)))
3004                 return FALSE;
3005             }
3006           else
3007             {
3008               (*_bfd_error_handler)
3009                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3010                  input_bfd, input_section,
3011                  (long) rel->r_offset, name, (int) r);
3012               return FALSE;
3013             }
3014         }
3015     }
3016
3017   return TRUE;
3018 }
3019
3020 /* Finish up dynamic symbol handling.  We set the contents of various
3021    dynamic sections here.  */
3022
3023 static bfd_boolean
3024 elf_s390_finish_dynamic_symbol (bfd *output_bfd,
3025                                 struct bfd_link_info *info,
3026                                 struct elf_link_hash_entry *h,
3027                                 Elf_Internal_Sym *sym)
3028 {
3029   struct elf_s390_link_hash_table *htab;
3030
3031   htab = elf_s390_hash_table (info);
3032   if (htab == NULL)
3033     return FALSE;
3034
3035   if (h->plt.offset != (bfd_vma) -1)
3036     {
3037       bfd_vma plt_index;
3038       bfd_vma got_offset;
3039       Elf_Internal_Rela rela;
3040       bfd_byte *loc;
3041
3042       /* This symbol has an entry in the procedure linkage table.  Set
3043          it up.  */
3044
3045       if (h->dynindx == -1
3046           || htab->splt == NULL
3047           || htab->sgotplt == NULL
3048           || htab->srelplt == NULL)
3049         abort ();
3050
3051       /* Calc. index no.
3052          Current offset - size first entry / entry size.  */
3053       plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3054
3055       /* Offset in GOT is PLT index plus GOT headers(3) times 8,
3056          addr & GOT addr.  */
3057       got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
3058
3059       /* Fill in the blueprint of a PLT.  */
3060       memcpy (htab->splt->contents + h->plt.offset, elf_s390x_plt_entry,
3061               PLT_ENTRY_SIZE);
3062
3063       /* Fixup the relative address to the GOT entry */
3064       bfd_put_32 (output_bfd,
3065                   (htab->sgotplt->output_section->vma +
3066                    htab->sgotplt->output_offset + got_offset
3067                    - (htab->splt->output_section->vma + h->plt.offset))/2,
3068                   htab->splt->contents + h->plt.offset + 2);
3069       /* Fixup the relative branch to PLT 0 */
3070       bfd_put_32 (output_bfd, - (PLT_FIRST_ENTRY_SIZE +
3071                                  (PLT_ENTRY_SIZE * plt_index) + 22)/2,
3072                   htab->splt->contents + h->plt.offset + 24);
3073       /* Fixup offset into symbol table */
3074       bfd_put_32 (output_bfd, plt_index * sizeof (Elf64_External_Rela),
3075                   htab->splt->contents + h->plt.offset + 28);
3076
3077       /* Fill in the entry in the global offset table.
3078          Points to instruction after GOT offset.  */
3079       bfd_put_64 (output_bfd,
3080                   (htab->splt->output_section->vma
3081                    + htab->splt->output_offset
3082                    + h->plt.offset
3083                    + 14),
3084                   htab->sgotplt->contents + got_offset);
3085
3086       /* Fill in the entry in the .rela.plt section.  */
3087       rela.r_offset = (htab->sgotplt->output_section->vma
3088                        + htab->sgotplt->output_offset
3089                        + got_offset);
3090       rela.r_info = ELF64_R_INFO (h->dynindx, R_390_JMP_SLOT);
3091       rela.r_addend = 0;
3092       loc = htab->srelplt->contents + plt_index * sizeof (Elf64_External_Rela);
3093       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3094
3095       if (!h->def_regular)
3096         {
3097           /* Mark the symbol as undefined, rather than as defined in
3098              the .plt section.  Leave the value alone.  This is a clue
3099              for the dynamic linker, to make function pointer
3100              comparisons work between an application and shared
3101              library.  */
3102           sym->st_shndx = SHN_UNDEF;
3103         }
3104     }
3105
3106   if (h->got.offset != (bfd_vma) -1
3107       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_GD
3108       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE
3109       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE_NLT)
3110     {
3111       Elf_Internal_Rela rela;
3112       bfd_byte *loc;
3113
3114       /* This symbol has an entry in the global offset table.  Set it
3115          up.  */
3116       if (htab->sgot == NULL || htab->srelgot == NULL)
3117         abort ();
3118
3119       rela.r_offset = (htab->sgot->output_section->vma
3120                        + htab->sgot->output_offset
3121                        + (h->got.offset &~ (bfd_vma) 1));
3122
3123       /* If this is a static link, or it is a -Bsymbolic link and the
3124          symbol is defined locally or was forced to be local because
3125          of a version file, we just want to emit a RELATIVE reloc.
3126          The entry in the global offset table will already have been
3127          initialized in the relocate_section function.  */
3128       if (info->shared
3129           && SYMBOL_REFERENCES_LOCAL (info, h))
3130         {
3131           if (!h->def_regular)
3132             return FALSE;
3133           BFD_ASSERT((h->got.offset & 1) != 0);
3134           rela.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
3135           rela.r_addend = (h->root.u.def.value
3136                            + h->root.u.def.section->output_section->vma
3137                            + h->root.u.def.section->output_offset);
3138         }
3139       else
3140         {
3141           BFD_ASSERT((h->got.offset & 1) == 0);
3142           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgot->contents + h->got.offset);
3143           rela.r_info = ELF64_R_INFO (h->dynindx, R_390_GLOB_DAT);
3144           rela.r_addend = 0;
3145         }
3146
3147       loc = htab->srelgot->contents;
3148       loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
3149       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3150     }
3151
3152   if (h->needs_copy)
3153     {
3154       Elf_Internal_Rela rela;
3155       bfd_byte *loc;
3156
3157       /* This symbols needs a copy reloc.  Set it up.  */
3158
3159       if (h->dynindx == -1
3160           || (h->root.type != bfd_link_hash_defined
3161               && h->root.type != bfd_link_hash_defweak)
3162           || htab->srelbss == NULL)
3163         abort ();
3164
3165       rela.r_offset = (h->root.u.def.value
3166                        + h->root.u.def.section->output_section->vma
3167                        + h->root.u.def.section->output_offset);
3168       rela.r_info = ELF64_R_INFO (h->dynindx, R_390_COPY);
3169       rela.r_addend = 0;
3170       loc = htab->srelbss->contents;
3171       loc += htab->srelbss->reloc_count++ * sizeof (Elf64_External_Rela);
3172       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3173     }
3174
3175   /* Mark some specially defined symbols as absolute.  */
3176   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3177       || h == htab->elf.hgot
3178       || h == htab->elf.hplt)
3179     sym->st_shndx = SHN_ABS;
3180
3181   return TRUE;
3182 }
3183
3184 /* Used to decide how to sort relocs in an optimal manner for the
3185    dynamic linker, before writing them out.  */
3186
3187 static enum elf_reloc_type_class
3188 elf_s390_reloc_type_class (rela)
3189      const Elf_Internal_Rela *rela;
3190 {
3191   switch ((int) ELF64_R_TYPE (rela->r_info))
3192     {
3193     case R_390_RELATIVE:
3194       return reloc_class_relative;
3195     case R_390_JMP_SLOT:
3196       return reloc_class_plt;
3197     case R_390_COPY:
3198       return reloc_class_copy;
3199     default:
3200       return reloc_class_normal;
3201     }
3202 }
3203
3204 /* Finish up the dynamic sections.  */
3205
3206 static bfd_boolean
3207 elf_s390_finish_dynamic_sections (bfd *output_bfd,
3208                                   struct bfd_link_info *info)
3209 {
3210   struct elf_s390_link_hash_table *htab;
3211   bfd *dynobj;
3212   asection *sdyn;
3213
3214   htab = elf_s390_hash_table (info);
3215   if (htab == NULL)
3216     return FALSE;
3217
3218   dynobj = htab->elf.dynobj;
3219   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3220
3221   if (htab->elf.dynamic_sections_created)
3222     {
3223       Elf64_External_Dyn *dyncon, *dynconend;
3224
3225       if (sdyn == NULL || htab->sgot == NULL)
3226         abort ();
3227
3228       dyncon = (Elf64_External_Dyn *) sdyn->contents;
3229       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
3230       for (; dyncon < dynconend; dyncon++)
3231         {
3232           Elf_Internal_Dyn dyn;
3233           asection *s;
3234
3235           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3236
3237           switch (dyn.d_tag)
3238             {
3239             default:
3240               continue;
3241
3242             case DT_PLTGOT:
3243               dyn.d_un.d_ptr = htab->sgot->output_section->vma;
3244               break;
3245
3246             case DT_JMPREL:
3247               dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
3248               break;
3249
3250             case DT_PLTRELSZ:
3251               s = htab->srelplt->output_section;
3252               dyn.d_un.d_val = s->size;
3253               break;
3254
3255             case DT_RELASZ:
3256               /* The procedure linkage table relocs (DT_JMPREL) should
3257                  not be included in the overall relocs (DT_RELA).
3258                  Therefore, we override the DT_RELASZ entry here to
3259                  make it not include the JMPREL relocs.  Since the
3260                  linker script arranges for .rela.plt to follow all
3261                  other relocation sections, we don't have to worry
3262                  about changing the DT_RELA entry.  */
3263               s = htab->srelplt->output_section;
3264               dyn.d_un.d_val -= s->size;
3265               break;
3266             }
3267
3268           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3269         }
3270
3271       /* Fill in the special first entry in the procedure linkage table.  */
3272       if (htab->splt && htab->splt->size > 0)
3273         {
3274           /* fill in blueprint for plt 0 entry */
3275           memcpy (htab->splt->contents, elf_s390x_first_plt_entry,
3276                   PLT_FIRST_ENTRY_SIZE);
3277           /* Fixup relative address to start of GOT */
3278           bfd_put_32 (output_bfd,
3279                       (htab->sgotplt->output_section->vma +
3280                        htab->sgotplt->output_offset
3281                        - htab->splt->output_section->vma - 6)/2,
3282                       htab->splt->contents + 8);
3283         }
3284       elf_section_data (htab->splt->output_section)
3285         ->this_hdr.sh_entsize = PLT_ENTRY_SIZE;
3286     }
3287
3288   if (htab->sgotplt)
3289     {
3290       /* Fill in the first three entries in the global offset table.  */
3291       if (htab->sgotplt->size > 0)
3292         {
3293           bfd_put_64 (output_bfd,
3294                       (sdyn == NULL ? (bfd_vma) 0
3295                        : sdyn->output_section->vma + sdyn->output_offset),
3296                       htab->sgotplt->contents);
3297           /* One entry for shared object struct ptr.  */
3298           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
3299           /* One entry for _dl_runtime_resolve.  */
3300           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 12);
3301         }
3302
3303       elf_section_data (htab->sgot->output_section)
3304         ->this_hdr.sh_entsize = 8;
3305     }
3306   return TRUE;
3307 }
3308
3309 /* Return address for Ith PLT stub in section PLT, for relocation REL
3310    or (bfd_vma) -1 if it should not be included.  */
3311
3312 static bfd_vma
3313 elf_s390_plt_sym_val (bfd_vma i, const asection *plt,
3314                       const arelent *rel ATTRIBUTE_UNUSED)
3315 {
3316   return plt->vma + PLT_FIRST_ENTRY_SIZE + i * PLT_ENTRY_SIZE;
3317 }
3318
3319
3320 /* Why was the hash table entry size definition changed from
3321    ARCH_SIZE/8 to 4? This breaks the 64 bit dynamic linker and
3322    this is the only reason for the s390_elf64_size_info structure.  */
3323
3324 const struct elf_size_info s390_elf64_size_info =
3325 {
3326   sizeof (Elf64_External_Ehdr),
3327   sizeof (Elf64_External_Phdr),
3328   sizeof (Elf64_External_Shdr),
3329   sizeof (Elf64_External_Rel),
3330   sizeof (Elf64_External_Rela),
3331   sizeof (Elf64_External_Sym),
3332   sizeof (Elf64_External_Dyn),
3333   sizeof (Elf_External_Note),
3334   8,            /* hash-table entry size.  */
3335   1,            /* internal relocations per external relocations.  */
3336   64,           /* arch_size.  */
3337   3,            /* log_file_align.  */
3338   ELFCLASS64, EV_CURRENT,
3339   bfd_elf64_write_out_phdrs,
3340   bfd_elf64_write_shdrs_and_ehdr,
3341   bfd_elf64_checksum_contents,
3342   bfd_elf64_write_relocs,
3343   bfd_elf64_swap_symbol_in,
3344   bfd_elf64_swap_symbol_out,
3345   bfd_elf64_slurp_reloc_table,
3346   bfd_elf64_slurp_symbol_table,
3347   bfd_elf64_swap_dyn_in,
3348   bfd_elf64_swap_dyn_out,
3349   bfd_elf64_swap_reloc_in,
3350   bfd_elf64_swap_reloc_out,
3351   bfd_elf64_swap_reloca_in,
3352   bfd_elf64_swap_reloca_out
3353 };
3354
3355 #define TARGET_BIG_SYM  bfd_elf64_s390_vec
3356 #define TARGET_BIG_NAME "elf64-s390"
3357 #define ELF_ARCH        bfd_arch_s390
3358 #define ELF_TARGET_ID   S390_ELF_DATA
3359 #define ELF_MACHINE_CODE EM_S390
3360 #define ELF_MACHINE_ALT1 EM_S390_OLD
3361 #define ELF_MAXPAGESIZE 0x1000
3362
3363 #define elf_backend_size_info           s390_elf64_size_info
3364
3365 #define elf_backend_can_gc_sections     1
3366 #define elf_backend_can_refcount        1
3367 #define elf_backend_want_got_plt        1
3368 #define elf_backend_plt_readonly        1
3369 #define elf_backend_want_plt_sym        0
3370 #define elf_backend_got_header_size     24
3371 #define elf_backend_rela_normal         1
3372
3373 #define elf_info_to_howto               elf_s390_info_to_howto
3374
3375 #define bfd_elf64_bfd_is_local_label_name     elf_s390_is_local_label_name
3376 #define bfd_elf64_bfd_link_hash_table_create  elf_s390_link_hash_table_create
3377 #define bfd_elf64_bfd_reloc_type_lookup       elf_s390_reloc_type_lookup
3378 #define bfd_elf64_bfd_reloc_name_lookup elf_s390_reloc_name_lookup
3379
3380 #define elf_backend_adjust_dynamic_symbol     elf_s390_adjust_dynamic_symbol
3381 #define elf_backend_check_relocs              elf_s390_check_relocs
3382 #define elf_backend_copy_indirect_symbol      elf_s390_copy_indirect_symbol
3383 #define elf_backend_create_dynamic_sections   elf_s390_create_dynamic_sections
3384 #define elf_backend_finish_dynamic_sections   elf_s390_finish_dynamic_sections
3385 #define elf_backend_finish_dynamic_symbol     elf_s390_finish_dynamic_symbol
3386 #define elf_backend_gc_mark_hook              elf_s390_gc_mark_hook
3387 #define elf_backend_gc_sweep_hook             elf_s390_gc_sweep_hook
3388 #define elf_backend_reloc_type_class          elf_s390_reloc_type_class
3389 #define elf_backend_relocate_section          elf_s390_relocate_section
3390 #define elf_backend_size_dynamic_sections     elf_s390_size_dynamic_sections
3391 #define elf_backend_init_index_section        _bfd_elf_init_1_index_section
3392 #define elf_backend_reloc_type_class          elf_s390_reloc_type_class
3393 #define elf_backend_plt_sym_val               elf_s390_plt_sym_val
3394
3395 #define bfd_elf64_mkobject              elf_s390_mkobject
3396 #define elf_backend_object_p            elf_s390_object_p
3397
3398 #include "elf64-target.h"