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