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 (htab->elf.dynobj == NULL)
 941                 htab->elf.dynobj = abfd;
 942
 943               if (!s390_elf_create_ifunc_sections (htab->elf.dynobj, info))
 944                 return FALSE;
 945
 946               if (local_got_refcounts == NULL)
 947                 {
 948                   if (!elf_s390_allocate_local_syminfo (abfd, symtab_hdr))
 949                     return FALSE;
 950                   local_got_refcounts = elf_local_got_refcounts (abfd);
 951                 }
 952               plt = elf_s390_local_plt (abfd);
 953               plt[r_symndx].plt.refcount++;
 954             }
 955           h = NULL;
 956         }
 957       else
 958         {
 959           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 960           while (h->root.type == bfd_link_hash_indirect
 961                  || h->root.type == bfd_link_hash_warning)
 962             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 963         }
 964
 965       /* Create got section and local_got_refcounts array if they
 966          are needed.  */
 967       r_type = elf_s390_tls_transition (info,
 968                                         ELF64_R_TYPE (rel->r_info),
 969                                         h == NULL);
 970       switch (r_type)
 971         {
 972         case R_390_GOT12:
 973         case R_390_GOT16:
 974         case R_390_GOT20:
 975         case R_390_GOT32:
 976         case R_390_GOT64:
 977         case R_390_GOTENT:
 978         case R_390_GOTPLT12:
 979         case R_390_GOTPLT16:
 980         case R_390_GOTPLT20:
 981         case R_390_GOTPLT32:
 982         case R_390_GOTPLT64:
 983         case R_390_GOTPLTENT:
 984         case R_390_TLS_GD64:
 985         case R_390_TLS_GOTIE12:
 986         case R_390_TLS_GOTIE20:
 987         case R_390_TLS_GOTIE64:
 988         case R_390_TLS_IEENT:
 989         case R_390_TLS_IE64:
 990         case R_390_TLS_LDM64:
 991           if (h == NULL
 992               && local_got_refcounts == NULL)
 993             {
 994               if (!elf_s390_allocate_local_syminfo (abfd, symtab_hdr))
 995                 return FALSE;
 996               local_got_refcounts = elf_local_got_refcounts (abfd);
 997             }
 998
 999           /* Fall through.  */
1000         case R_390_GOTOFF16:
1001         case R_390_GOTOFF32:
1002         case R_390_GOTOFF64:
1003         case R_390_GOTPC:
1004         case R_390_GOTPCDBL:
1005           if (htab->elf.sgot == NULL)
1006             {
1007               if (htab->elf.dynobj == NULL)
1008                 htab->elf.dynobj = abfd;
1009               if (!create_got_section (htab->elf.dynobj, info))
1010                 return FALSE;
1011             }
1012         }
1013
1014       if (h != NULL)
1015         {
1016           if (htab->elf.dynobj == NULL)
1017             htab->elf.dynobj = abfd;
1018           if (!s390_elf_create_ifunc_sections (htab->elf.dynobj, info))
1019             return FALSE;
1020
1021           /* Make sure an IFUNC symbol defined in a non-shared object
1022              always gets a PLT slot.  */
1023           if (s390_is_ifunc_symbol_p (h) && h->def_regular)
1024             {
1025               /* The symbol is called by the dynamic loader in order
1026                  to resolve the relocation.  So it is in fact also
1027                  referenced.  */
1028               h->ref_regular = 1;
1029               h->needs_plt = 1;
1030             }
1031         }
1032
1033       switch (r_type)
1034         {
1035         case R_390_GOTOFF16:
1036         case R_390_GOTOFF32:
1037         case R_390_GOTOFF64:
1038         case R_390_GOTPC:
1039         case R_390_GOTPCDBL:
1040           /* These relocs do not need a GOT slot.  They just load the
1041              GOT pointer itself or address something else relative to
1042              the GOT.  Since the GOT pointer has been set up above we
1043              are done.  */
1044           break;
1045
1046         case R_390_PLT16DBL:
1047         case R_390_PLT32:
1048         case R_390_PLT32DBL:
1049         case R_390_PLT64:
1050         case R_390_PLTOFF16:
1051         case R_390_PLTOFF32:
1052         case R_390_PLTOFF64:
1053           /* This symbol requires a procedure linkage table entry.  We
1054              actually build the entry in adjust_dynamic_symbol,
1055              because this might be a case of linking PIC code which is
1056              never referenced by a dynamic object, in which case we
1057              don't need to generate a procedure linkage table entry
1058              after all.  */
1059
1060           /* If this is a local symbol, we resolve it directly without
1061              creating a procedure linkage table entry.  */
1062           if (h != NULL)
1063             {
1064               h->needs_plt = 1;
1065               h->plt.refcount += 1;
1066             }
1067           break;
1068
1069         case R_390_GOTPLT12:
1070         case R_390_GOTPLT16:
1071         case R_390_GOTPLT20:
1072         case R_390_GOTPLT32:
1073         case R_390_GOTPLT64:
1074         case R_390_GOTPLTENT:
1075           /* This symbol requires either a procedure linkage table entry
1076              or an entry in the local got. We actually build the entry
1077              in adjust_dynamic_symbol because whether this is really a
1078              global reference can change and with it the fact if we have
1079              to create a plt entry or a local got entry. To be able to
1080              make a once global symbol a local one we have to keep track
1081              of the number of gotplt references that exist for this
1082              symbol.  */
1083           if (h != NULL)
1084             {
1085               ((struct elf_s390_link_hash_entry *) h)->gotplt_refcount++;
1086               h->needs_plt = 1;
1087               h->plt.refcount += 1;
1088             }
1089           else
1090             local_got_refcounts[r_symndx] += 1;
1091           break;
1092
1093         case R_390_TLS_LDM64:
1094           htab->tls_ldm_got.refcount += 1;
1095           break;
1096
1097         case R_390_TLS_IE64:
1098         case R_390_TLS_GOTIE12:
1099         case R_390_TLS_GOTIE20:
1100         case R_390_TLS_GOTIE64:
1101         case R_390_TLS_IEENT:
1102           if (info->shared)
1103             info->flags |= DF_STATIC_TLS;
1104           /* Fall through */
1105
1106         case R_390_GOT12:
1107         case R_390_GOT16:
1108         case R_390_GOT20:
1109         case R_390_GOT32:
1110         case R_390_GOT64:
1111         case R_390_GOTENT:
1112         case R_390_TLS_GD64:
1113           /* This symbol requires a global offset table entry.  */
1114           switch (r_type)
1115             {
1116             default:
1117             case R_390_GOT12:
1118             case R_390_GOT16:
1119             case R_390_GOT20:
1120             case R_390_GOT32:
1121             case R_390_GOTENT:
1122               tls_type = GOT_NORMAL;
1123               break;
1124             case R_390_TLS_GD64:
1125               tls_type = GOT_TLS_GD;
1126               break;
1127             case R_390_TLS_IE64:
1128             case R_390_TLS_GOTIE64:
1129               tls_type = GOT_TLS_IE;
1130               break;
1131             case R_390_TLS_GOTIE12:
1132             case R_390_TLS_GOTIE20:
1133             case R_390_TLS_IEENT:
1134               tls_type = GOT_TLS_IE_NLT;
1135               break;
1136             }
1137
1138           if (h != NULL)
1139             {
1140               h->got.refcount += 1;
1141               old_tls_type = elf_s390_hash_entry(h)->tls_type;
1142             }
1143           else
1144             {
1145               local_got_refcounts[r_symndx] += 1;
1146               old_tls_type = elf_s390_local_got_tls_type (abfd) [r_symndx];
1147             }
1148           /* If a TLS symbol is accessed using IE at least once,
1149              there is no point to use dynamic model for it.  */
1150           if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN)
1151             {
1152               if (old_tls_type == GOT_NORMAL || tls_type == GOT_NORMAL)
1153                 {
1154                   (*_bfd_error_handler)
1155                     (_("%B: `%s' accessed both as normal and thread local symbol"),
1156                      abfd, h->root.root.string);
1157                   return FALSE;
1158                 }
1159               if (old_tls_type > tls_type)
1160                 tls_type = old_tls_type;
1161             }
1162
1163           if (old_tls_type != tls_type)
1164             {
1165               if (h != NULL)
1166                 elf_s390_hash_entry (h)->tls_type = tls_type;
1167               else
1168                 elf_s390_local_got_tls_type (abfd) [r_symndx] = tls_type;
1169             }
1170
1171           if (r_type != R_390_TLS_IE64)
1172             break;
1173           /* Fall through */
1174
1175         case R_390_TLS_LE64:
1176           if (!info->shared)
1177             break;
1178           info->flags |= DF_STATIC_TLS;
1179           /* Fall through */
1180
1181         case R_390_8:
1182         case R_390_16:
1183         case R_390_32:
1184         case R_390_64:
1185         case R_390_PC16:
1186         case R_390_PC16DBL:
1187         case R_390_PC32:
1188         case R_390_PC32DBL:
1189         case R_390_PC64:
1190           if (h != NULL)
1191             {
1192               /* If this reloc is in a read-only section, we might
1193                  need a copy reloc.  We can't check reliably at this
1194                  stage whether the section is read-only, as input
1195                  sections have not yet been mapped to output sections.
1196                  Tentatively set the flag for now, and correct in
1197                  adjust_dynamic_symbol.  */
1198               h->non_got_ref = 1;
1199
1200               if (!info->shared)
1201                 {
1202                   /* We may need a .plt entry if the function this reloc
1203                      refers to is in a shared lib.  */
1204                   h->plt.refcount += 1;
1205                 }
1206             }
1207
1208           /* If we are creating a shared library, and this is a reloc
1209              against a global symbol, or a non PC relative reloc
1210              against a local symbol, then we need to copy the reloc
1211              into the shared library.  However, if we are linking with
1212              -Bsymbolic, we do not need to copy a reloc against a
1213              global symbol which is defined in an object we are
1214              including in the link (i.e., DEF_REGULAR is set).  At
1215              this point we have not seen all the input files, so it is
1216              possible that DEF_REGULAR is not set now but will be set
1217              later (it is never cleared).  In case of a weak definition,
1218              DEF_REGULAR may be cleared later by a strong definition in
1219              a shared library. We account for that possibility below by
1220              storing information in the relocs_copied field of the hash
1221              table entry.  A similar situation occurs when creating
1222              shared libraries and symbol visibility changes render the
1223              symbol local.
1224
1225              If on the other hand, we are creating an executable, we
1226              may need to keep relocations for symbols satisfied by a
1227              dynamic library if we manage to avoid copy relocs for the
1228              symbol.  */
1229           if ((info->shared
1230                && (sec->flags & SEC_ALLOC) != 0
1231                && ((ELF64_R_TYPE (rel->r_info) != R_390_PC16
1232                     && ELF64_R_TYPE (rel->r_info) != R_390_PC16DBL
1233                     && ELF64_R_TYPE (rel->r_info) != R_390_PC32
1234                     && ELF64_R_TYPE (rel->r_info) != R_390_PC32DBL
1235                     && ELF64_R_TYPE (rel->r_info) != R_390_PC64)
1236                    || (h != NULL
1237                        && (! SYMBOLIC_BIND (info, h)
1238                            || h->root.type == bfd_link_hash_defweak
1239                            || !h->def_regular))))
1240               || (ELIMINATE_COPY_RELOCS
1241                   && !info->shared
1242                   && (sec->flags & SEC_ALLOC) != 0
1243                   && h != NULL
1244                   && (h->root.type == bfd_link_hash_defweak
1245                       || !h->def_regular)))
1246             {
1247               struct elf_dyn_relocs *p;
1248               struct elf_dyn_relocs **head;
1249
1250               /* We must copy these reloc types into the output file.
1251                  Create a reloc section in dynobj and make room for
1252                  this reloc.  */
1253               if (sreloc == NULL)
1254                 {
1255                   if (htab->elf.dynobj == NULL)
1256                     htab->elf.dynobj = abfd;
1257
1258                   sreloc = _bfd_elf_make_dynamic_reloc_section
1259                     (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
1260
1261                   if (sreloc == NULL)
1262                     return FALSE;
1263                 }
1264
1265               /* If this is a global symbol, we count the number of
1266                  relocations we need for this symbol.  */
1267               if (h != NULL)
1268                 {
1269                   head = &((struct elf_s390_link_hash_entry *) h)->dyn_relocs;
1270                 }
1271               else
1272                 {
1273                   /* Track dynamic relocs needed for local syms too.
1274                      We really need local syms available to do this
1275                      easily.  Oh well.  */
1276                   asection *s;
1277                   void *vpp;
1278
1279                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1280                                                 abfd, r_symndx);
1281                   if (isym == NULL)
1282                     return FALSE;
1283
1284                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1285                   if (s == NULL)
1286                     s = sec;
1287
1288                   vpp = &elf_section_data (s)->local_dynrel;
1289                   head = (struct elf_dyn_relocs **) vpp;
1290                 }
1291
1292               p = *head;
1293               if (p == NULL || p->sec != sec)
1294                 {
1295                   bfd_size_type amt = sizeof *p;
1296                   p = ((struct elf_dyn_relocs *)
1297                        bfd_alloc (htab->elf.dynobj, amt));
1298                   if (p == NULL)
1299                     return FALSE;
1300                   p->next = *head;
1301                   *head = p;
1302                   p->sec = sec;
1303                   p->count = 0;
1304                   p->pc_count = 0;
1305                 }
1306
1307               p->count += 1;
1308               if (ELF64_R_TYPE (rel->r_info) == R_390_PC16
1309                   || ELF64_R_TYPE (rel->r_info) == R_390_PC16DBL
1310                   || ELF64_R_TYPE (rel->r_info) == R_390_PC32
1311                   || ELF64_R_TYPE (rel->r_info) == R_390_PC32DBL
1312                   || ELF64_R_TYPE (rel->r_info) == R_390_PC64)
1313                 p->pc_count += 1;
1314             }
1315           break;
1316
1317           /* This relocation describes the C++ object vtable hierarchy.
1318              Reconstruct it for later use during GC.  */
1319         case R_390_GNU_VTINHERIT:
1320           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1321             return FALSE;
1322           break;
1323
1324           /* This relocation describes which C++ vtable entries are actually
1325              used.  Record for later use during GC.  */
1326         case R_390_GNU_VTENTRY:
1327           BFD_ASSERT (h != NULL);
1328           if (h != NULL
1329               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1330             return FALSE;
1331           break;
1332
1333         default:
1334           break;
1335         }
1336     }
1337
1338   return TRUE;
1339 }
1340
1341 /* Return the section that should be marked against GC for a given
1342    relocation.  */
1343
1344 static asection *
1345 elf_s390_gc_mark_hook (asection *sec,
1346                        struct bfd_link_info *info,
1347                        Elf_Internal_Rela *rel,
1348                        struct elf_link_hash_entry *h,
1349                        Elf_Internal_Sym *sym)
1350 {
1351   if (h != NULL)
1352     switch (ELF64_R_TYPE (rel->r_info))
1353       {
1354       case R_390_GNU_VTINHERIT:
1355       case R_390_GNU_VTENTRY:
1356         return NULL;
1357       }
1358
1359   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1360 }
1361
1362 /* Update the got entry reference counts for the section being removed.  */
1363
1364 static bfd_boolean
1365 elf_s390_gc_sweep_hook (bfd *abfd,
1366                         struct bfd_link_info *info,
1367                         asection *sec,
1368                         const Elf_Internal_Rela *relocs)
1369 {
1370   struct elf_s390_link_hash_table *htab;
1371   Elf_Internal_Shdr *symtab_hdr;
1372   struct elf_link_hash_entry **sym_hashes;
1373   bfd_signed_vma *local_got_refcounts;
1374   const Elf_Internal_Rela *rel, *relend;
1375
1376   if (info->relocatable)
1377     return TRUE;
1378
1379   htab = elf_s390_hash_table (info);
1380   if (htab == NULL)
1381     return FALSE;
1382
1383   elf_section_data (sec)->local_dynrel = NULL;
1384
1385   symtab_hdr = &elf_symtab_hdr (abfd);
1386   sym_hashes = elf_sym_hashes (abfd);
1387   local_got_refcounts = elf_local_got_refcounts (abfd);
1388
1389   relend = relocs + sec->reloc_count;
1390   for (rel = relocs; rel < relend; rel++)
1391     {
1392       unsigned long r_symndx;
1393       unsigned int r_type;
1394       struct elf_link_hash_entry *h = NULL;
1395
1396       r_symndx = ELF64_R_SYM (rel->r_info);
1397       if (r_symndx >= symtab_hdr->sh_info)
1398         {
1399           struct elf_s390_link_hash_entry *eh;
1400           struct elf_dyn_relocs **pp;
1401           struct elf_dyn_relocs *p;
1402
1403           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1404           while (h->root.type == bfd_link_hash_indirect
1405                  || h->root.type == bfd_link_hash_warning)
1406             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1407           eh = (struct elf_s390_link_hash_entry *) h;
1408
1409           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1410             if (p->sec == sec)
1411               {
1412                 /* Everything must go for SEC.  */
1413                 *pp = p->next;
1414                 break;
1415               }
1416         }
1417       else
1418         {
1419           Elf_Internal_Sym *isym;
1420
1421           /* A local symbol.  */
1422           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1423                                         abfd, r_symndx);
1424           if (isym == NULL)
1425             return FALSE;
1426
1427           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1428             {
1429               struct plt_entry *plt = elf_s390_local_plt (abfd);
1430               if (plt[r_symndx].plt.refcount > 0)
1431                 plt[r_symndx].plt.refcount--;
1432             }
1433         }
1434
1435       r_type = ELF64_R_TYPE (rel->r_info);
1436       r_type = elf_s390_tls_transition (info, r_type, h != NULL);
1437       switch (r_type)
1438         {
1439         case R_390_TLS_LDM64:
1440           if (htab->tls_ldm_got.refcount > 0)
1441             htab->tls_ldm_got.refcount -= 1;
1442           break;
1443
1444         case R_390_TLS_GD64:
1445         case R_390_TLS_IE64:
1446         case R_390_TLS_GOTIE12:
1447         case R_390_TLS_GOTIE20:
1448         case R_390_TLS_GOTIE64:
1449         case R_390_TLS_IEENT:
1450         case R_390_GOT12:
1451         case R_390_GOT16:
1452         case R_390_GOT20:
1453         case R_390_GOT32:
1454         case R_390_GOT64:
1455         case R_390_GOTOFF16:
1456         case R_390_GOTOFF32:
1457         case R_390_GOTOFF64:
1458         case R_390_GOTPC:
1459         case R_390_GOTPCDBL:
1460         case R_390_GOTENT:
1461           if (h != NULL)
1462             {
1463               if (h->got.refcount > 0)
1464                 h->got.refcount -= 1;
1465             }
1466           else if (local_got_refcounts != NULL)
1467             {
1468               if (local_got_refcounts[r_symndx] > 0)
1469                 local_got_refcounts[r_symndx] -= 1;
1470             }
1471           break;
1472
1473         case R_390_8:
1474         case R_390_12:
1475         case R_390_16:
1476         case R_390_20:
1477         case R_390_32:
1478         case R_390_64:
1479         case R_390_PC16:
1480         case R_390_PC16DBL:
1481         case R_390_PC32:
1482         case R_390_PC32DBL:
1483         case R_390_PC64:
1484           if (info->shared)
1485             break;
1486           /* Fall through */
1487
1488         case R_390_PLT16DBL:
1489         case R_390_PLT32:
1490         case R_390_PLT32DBL:
1491         case R_390_PLT64:
1492         case R_390_PLTOFF16:
1493         case R_390_PLTOFF32:
1494         case R_390_PLTOFF64:
1495           if (h != NULL)
1496             {
1497               if (h->plt.refcount > 0)
1498                 h->plt.refcount -= 1;
1499             }
1500           break;
1501
1502         case R_390_GOTPLT12:
1503         case R_390_GOTPLT16:
1504         case R_390_GOTPLT20:
1505         case R_390_GOTPLT32:
1506         case R_390_GOTPLT64:
1507         case R_390_GOTPLTENT:
1508           if (h != NULL)
1509             {
1510               if (h->plt.refcount > 0)
1511                 {
1512                   ((struct elf_s390_link_hash_entry *) h)->gotplt_refcount--;
1513                   h->plt.refcount -= 1;
1514                 }
1515             }
1516           else if (local_got_refcounts != NULL)
1517             {
1518               if (local_got_refcounts[r_symndx] > 0)
1519                 local_got_refcounts[r_symndx] -= 1;
1520             }
1521           break;
1522
1523         default:
1524           break;
1525         }
1526     }
1527
1528   return TRUE;
1529 }
1530
1531 /* Make sure we emit a GOT entry if the symbol was supposed to have a PLT
1532    entry but we found we will not create any.  Called when we find we will
1533    not have any PLT for this symbol, by for example
1534    elf_s390_adjust_dynamic_symbol when we're doing a proper dynamic link,
1535    or elf_s390_size_dynamic_sections if no dynamic sections will be
1536    created (we're only linking static objects).  */
1537
1538 static void
1539 elf_s390_adjust_gotplt (struct elf_s390_link_hash_entry *h)
1540 {
1541   if (h->elf.root.type == bfd_link_hash_warning)
1542     h = (struct elf_s390_link_hash_entry *) h->elf.root.u.i.link;
1543
1544   if (h->gotplt_refcount <= 0)
1545     return;
1546
1547   /* We simply add the number of gotplt references to the number
1548    * of got references for this symbol.  */
1549   h->elf.got.refcount += h->gotplt_refcount;
1550   h->gotplt_refcount = -1;
1551 }
1552
1553 /* Adjust a symbol defined by a dynamic object and referenced by a
1554    regular object.  The current definition is in some section of the
1555    dynamic object, but we're not including those sections.  We have to
1556    change the definition to something the rest of the link can
1557    understand.  */
1558
1559 static bfd_boolean
1560 elf_s390_adjust_dynamic_symbol (struct bfd_link_info *info,
1561                                 struct elf_link_hash_entry *h)
1562 {
1563   struct elf_s390_link_hash_table *htab;
1564   asection *s;
1565
1566   /* STT_GNU_IFUNC symbol must go through PLT. */
1567   if (s390_is_ifunc_symbol_p (h))
1568     return TRUE;
1569
1570   /* If this is a function, put it in the procedure linkage table.  We
1571      will fill in the contents of the procedure linkage table later
1572      (although we could actually do it here).  */
1573   if (h->type == STT_FUNC
1574       || h->needs_plt)
1575     {
1576       if (h->plt.refcount <= 0
1577           || SYMBOL_CALLS_LOCAL (info, h)
1578           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1579               && h->root.type == bfd_link_hash_undefweak))
1580         {
1581           /* This case can occur if we saw a PLT32 reloc in an input
1582              file, but the symbol was never referred to by a dynamic
1583              object, or if all references were garbage collected.  In
1584              such a case, we don't actually need to build a procedure
1585              linkage table, and we can just do a PC32 reloc instead.  */
1586           h->plt.offset = (bfd_vma) -1;
1587           h->needs_plt = 0;
1588           elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1589         }
1590
1591       return TRUE;
1592     }
1593   else
1594     /* It's possible that we incorrectly decided a .plt reloc was
1595        needed for an R_390_PC32 reloc to a non-function sym in
1596        check_relocs.  We can't decide accurately between function and
1597        non-function syms in check-relocs;  Objects loaded later in
1598        the link may change h->type.  So fix it now.  */
1599     h->plt.offset = (bfd_vma) -1;
1600
1601   /* If this is a weak symbol, and there is a real definition, the
1602      processor independent code will have arranged for us to see the
1603      real definition first, and we can just use the same value.  */
1604   if (h->u.weakdef != NULL)
1605     {
1606       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1607                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1608       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1609       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1610       if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1611         h->non_got_ref = h->u.weakdef->non_got_ref;
1612       return TRUE;
1613     }
1614
1615   /* This is a reference to a symbol defined by a dynamic object which
1616      is not a function.  */
1617
1618   /* If we are creating a shared library, we must presume that the
1619      only references to the symbol are via the global offset table.
1620      For such cases we need not do anything here; the relocations will
1621      be handled correctly by relocate_section.  */
1622   if (info->shared)
1623     return TRUE;
1624
1625   /* If there are no references to this symbol that do not use the
1626      GOT, we don't need to generate a copy reloc.  */
1627   if (!h->non_got_ref)
1628     return TRUE;
1629
1630   /* If -z nocopyreloc was given, we won't generate them either.  */
1631   if (info->nocopyreloc)
1632     {
1633       h->non_got_ref = 0;
1634       return TRUE;
1635     }
1636
1637   if (ELIMINATE_COPY_RELOCS)
1638     {
1639       struct elf_s390_link_hash_entry * eh;
1640       struct elf_dyn_relocs *p;
1641
1642       eh = (struct elf_s390_link_hash_entry *) h;
1643       for (p = eh->dyn_relocs; p != NULL; p = p->next)
1644         {
1645           s = p->sec->output_section;
1646           if (s != NULL && (s->flags & SEC_READONLY) != 0)
1647             break;
1648         }
1649
1650       /* If we didn't find any dynamic relocs in read-only sections, then
1651          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
1652       if (p == NULL)
1653         {
1654           h->non_got_ref = 0;
1655           return TRUE;
1656         }
1657     }
1658
1659   /* We must allocate the symbol in our .dynbss section, which will
1660      become part of the .bss section of the executable.  There will be
1661      an entry for this symbol in the .dynsym section.  The dynamic
1662      object will contain position independent code, so all references
1663      from the dynamic object to this symbol will go through the global
1664      offset table.  The dynamic linker will use the .dynsym entry to
1665      determine the address it must put in the global offset table, so
1666      both the dynamic object and the regular object will refer to the
1667      same memory location for the variable.  */
1668
1669   htab = elf_s390_hash_table (info);
1670   if (htab == NULL)
1671     return FALSE;
1672
1673   /* We must generate a R_390_COPY reloc to tell the dynamic linker to
1674      copy the initial value out of the dynamic object and into the
1675      runtime process image.  */
1676   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1677     {
1678       htab->srelbss->size += sizeof (Elf64_External_Rela);
1679       h->needs_copy = 1;
1680     }
1681
1682   s = htab->sdynbss;
1683
1684   return _bfd_elf_adjust_dynamic_copy (h, s);
1685 }
1686
1687 /* Allocate space in .plt, .got and associated reloc sections for
1688    dynamic relocs.  */
1689
1690 static bfd_boolean
1691 allocate_dynrelocs (struct elf_link_hash_entry *h,
1692                     void * inf)
1693 {
1694   struct bfd_link_info *info;
1695   struct elf_s390_link_hash_table *htab;
1696   struct elf_s390_link_hash_entry *eh = (struct elf_s390_link_hash_entry *)h;
1697   struct elf_dyn_relocs *p;
1698
1699   if (h->root.type == bfd_link_hash_indirect)
1700     return TRUE;
1701
1702   info = (struct bfd_link_info *) inf;
1703   htab = elf_s390_hash_table (info);
1704   if (htab == NULL)
1705     return FALSE;
1706
1707   /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
1708      here if it is defined and referenced in a non-shared object.  */
1709   if (s390_is_ifunc_symbol_p (h) && h->def_regular)
1710     return s390_elf_allocate_ifunc_dyn_relocs (info, h,
1711                                                &eh->dyn_relocs);
1712   else if (htab->elf.dynamic_sections_created
1713            && h->plt.refcount > 0)
1714     {
1715       /* Make sure this symbol is output as a dynamic symbol.
1716          Undefined weak syms won't yet be marked as dynamic.  */
1717       if (h->dynindx == -1
1718           && !h->forced_local)
1719         {
1720           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1721             return FALSE;
1722         }
1723
1724       if (info->shared
1725           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1726         {
1727           asection *s = htab->elf.splt;
1728
1729           /* If this is the first .plt entry, make room for the special
1730              first entry.  */
1731           if (s->size == 0)
1732             s->size += PLT_FIRST_ENTRY_SIZE;
1733
1734           h->plt.offset = s->size;
1735
1736           /* If this symbol is not defined in a regular file, and we are
1737              not generating a shared library, then set the symbol to this
1738              location in the .plt.  This is required to make function
1739              pointers compare as equal between the normal executable and
1740              the shared library.  */
1741           if (! info->shared
1742               && !h->def_regular)
1743             {
1744               h->root.u.def.section = s;
1745               h->root.u.def.value = h->plt.offset;
1746             }
1747
1748           /* Make room for this entry.  */
1749           s->size += PLT_ENTRY_SIZE;
1750
1751           /* We also need to make an entry in the .got.plt section, which
1752              will be placed in the .got section by the linker script.  */
1753           htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
1754
1755           /* We also need to make an entry in the .rela.plt section.  */
1756           htab->elf.srelplt->size += sizeof (Elf64_External_Rela);
1757         }
1758       else
1759         {
1760           h->plt.offset = (bfd_vma) -1;
1761           h->needs_plt = 0;
1762           elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1763         }
1764     }
1765   else
1766     {
1767       h->plt.offset = (bfd_vma) -1;
1768       h->needs_plt = 0;
1769       elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1770     }
1771
1772   /* If R_390_TLS_{IE64,GOTIE64,GOTIE12,IEENT} symbol is now local to
1773      the binary, we can optimize a bit. IE64 and GOTIE64 get converted
1774      to R_390_TLS_LE64 requiring no TLS entry. For GOTIE12 and IEENT
1775      we can save the dynamic TLS relocation.  */
1776   if (h->got.refcount > 0
1777       && !info->shared
1778       && h->dynindx == -1
1779       && elf_s390_hash_entry(h)->tls_type >= GOT_TLS_IE)
1780     {
1781       if (elf_s390_hash_entry(h)->tls_type == GOT_TLS_IE_NLT)
1782         /* For the GOTIE access without a literal pool entry the offset has
1783            to be stored somewhere. The immediate value in the instruction
1784            is not bit enough so the value is stored in the got.  */
1785         {
1786           h->got.offset = htab->elf.sgot->size;
1787           htab->elf.sgot->size += GOT_ENTRY_SIZE;
1788         }
1789       else
1790         h->got.offset = (bfd_vma) -1;
1791     }
1792   else if (h->got.refcount > 0)
1793     {
1794       asection *s;
1795       bfd_boolean dyn;
1796       int tls_type = elf_s390_hash_entry(h)->tls_type;
1797
1798       /* Make sure this symbol is output as a dynamic symbol.
1799          Undefined weak syms won't yet be marked as dynamic.  */
1800       if (h->dynindx == -1
1801           && !h->forced_local)
1802         {
1803           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1804             return FALSE;
1805         }
1806
1807       s = htab->elf.sgot;
1808       h->got.offset = s->size;
1809       s->size += GOT_ENTRY_SIZE;
1810       /* R_390_TLS_GD64 needs 2 consecutive GOT slots.  */
1811       if (tls_type == GOT_TLS_GD)
1812         s->size += GOT_ENTRY_SIZE;
1813       dyn = htab->elf.dynamic_sections_created;
1814       /* R_390_TLS_IE64 needs one dynamic relocation,
1815          R_390_TLS_GD64 needs one if local symbol and two if global.  */
1816       if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1817           || tls_type >= GOT_TLS_IE)
1818         htab->elf.srelgot->size += sizeof (Elf64_External_Rela);
1819       else if (tls_type == GOT_TLS_GD)
1820         htab->elf.srelgot->size += 2 * sizeof (Elf64_External_Rela);
1821       else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1822                 || h->root.type != bfd_link_hash_undefweak)
1823                && (info->shared
1824                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1825         htab->elf.srelgot->size += sizeof (Elf64_External_Rela);
1826     }
1827   else
1828     h->got.offset = (bfd_vma) -1;
1829
1830   if (eh->dyn_relocs == NULL)
1831     return TRUE;
1832
1833   /* In the shared -Bsymbolic case, discard space allocated for
1834      dynamic pc-relative relocs against symbols which turn out to be
1835      defined in regular objects.  For the normal shared case, discard
1836      space for pc-relative relocs that have become local due to symbol
1837      visibility changes.  */
1838
1839   if (info->shared)
1840     {
1841       if (SYMBOL_CALLS_LOCAL (info, h))
1842         {
1843           struct elf_dyn_relocs **pp;
1844
1845           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1846             {
1847               p->count -= p->pc_count;
1848               p->pc_count = 0;
1849               if (p->count == 0)
1850                 *pp = p->next;
1851               else
1852                 pp = &p->next;
1853             }
1854         }
1855
1856       /* Also discard relocs on undefined weak syms with non-default
1857          visibility.  */
1858       if (eh->dyn_relocs != NULL
1859           && h->root.type == bfd_link_hash_undefweak)
1860         {
1861           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1862             eh->dyn_relocs = NULL;
1863
1864           /* Make sure undefined weak symbols are output as a dynamic
1865              symbol in PIEs.  */
1866           else if (h->dynindx == -1
1867                    && !h->forced_local)
1868             {
1869               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1870                 return FALSE;
1871             }
1872         }
1873     }
1874   else if (ELIMINATE_COPY_RELOCS)
1875     {
1876       /* For the non-shared case, discard space for relocs against
1877          symbols which turn out to need copy relocs or are not
1878          dynamic.  */
1879
1880       if (!h->non_got_ref
1881           && ((h->def_dynamic
1882                && !h->def_regular)
1883               || (htab->elf.dynamic_sections_created
1884                   && (h->root.type == bfd_link_hash_undefweak
1885                       || h->root.type == bfd_link_hash_undefined))))
1886         {
1887           /* Make sure this symbol is output as a dynamic symbol.
1888              Undefined weak syms won't yet be marked as dynamic.  */
1889           if (h->dynindx == -1
1890               && !h->forced_local)
1891             {
1892               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1893                 return FALSE;
1894             }
1895
1896           /* If that succeeded, we know we'll be keeping all the
1897              relocs.  */
1898           if (h->dynindx != -1)
1899             goto keep;
1900         }
1901
1902       eh->dyn_relocs = NULL;
1903
1904     keep: ;
1905     }
1906
1907   /* Finally, allocate space.  */
1908   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1909     {
1910       asection *sreloc = elf_section_data (p->sec)->sreloc;
1911       sreloc->size += p->count * sizeof (Elf64_External_Rela);
1912     }
1913
1914   return TRUE;
1915 }
1916
1917 /* Find any dynamic relocs that apply to read-only sections.  */
1918
1919 static bfd_boolean
1920 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1921 {
1922   struct elf_s390_link_hash_entry *eh;
1923   struct elf_dyn_relocs *p;
1924
1925   eh = (struct elf_s390_link_hash_entry *) h;
1926   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1927     {
1928       asection *s = p->sec->output_section;
1929
1930       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1931         {
1932           struct bfd_link_info *info = (struct bfd_link_info *) inf;
1933
1934           info->flags |= DF_TEXTREL;
1935
1936           /* Not an error, just cut short the traversal.  */
1937           return FALSE;
1938         }
1939     }
1940   return TRUE;
1941 }
1942
1943 /* Set the sizes of the dynamic sections.  */
1944
1945 static bfd_boolean
1946 elf_s390_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1947                                 struct bfd_link_info *info)
1948 {
1949   struct elf_s390_link_hash_table *htab;
1950   bfd *dynobj;
1951   asection *s;
1952   bfd_boolean relocs;
1953   bfd *ibfd;
1954
1955   htab = elf_s390_hash_table (info);
1956   if (htab == NULL)
1957     return FALSE;
1958
1959   dynobj = htab->elf.dynobj;
1960   if (dynobj == NULL)
1961     abort ();
1962
1963   if (htab->elf.dynamic_sections_created)
1964     {
1965       /* Set the contents of the .interp section to the interpreter.  */
1966       if (info->executable)
1967         {
1968           s = bfd_get_linker_section (dynobj, ".interp");
1969           if (s == NULL)
1970             abort ();
1971           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1972           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1973         }
1974     }
1975
1976   /* Set up .got offsets for local syms, and space for local dynamic
1977      relocs.  */
1978   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1979     {
1980       bfd_signed_vma *local_got;
1981       bfd_signed_vma *end_local_got;
1982       char *local_tls_type;
1983       bfd_size_type locsymcount;
1984       Elf_Internal_Shdr *symtab_hdr;
1985       asection *srela;
1986       struct plt_entry *local_plt;
1987       unsigned int i;
1988
1989       if (! is_s390_elf (ibfd))
1990         continue;
1991
1992       for (s = ibfd->sections; s != NULL; s = s->next)
1993         {
1994           struct elf_dyn_relocs *p;
1995
1996           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
1997             {
1998               if (!bfd_is_abs_section (p->sec)
1999                   && bfd_is_abs_section (p->sec->output_section))
2000                 {
2001                   /* Input section has been discarded, either because
2002                      it is a copy of a linkonce section or due to
2003                      linker script /DISCARD/, so we'll be discarding
2004                      the relocs too.  */
2005                 }
2006               else if (p->count != 0)
2007                 {
2008                   srela = elf_section_data (p->sec)->sreloc;
2009                   srela->size += p->count * sizeof (Elf64_External_Rela);
2010                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2011                     info->flags |= DF_TEXTREL;
2012                 }
2013             }
2014         }
2015
2016       local_got = elf_local_got_refcounts (ibfd);
2017       if (!local_got)
2018         continue;
2019
2020       symtab_hdr = &elf_symtab_hdr (ibfd);
2021       locsymcount = symtab_hdr->sh_info;
2022       end_local_got = local_got + locsymcount;
2023       local_tls_type = elf_s390_local_got_tls_type (ibfd);
2024       s = htab->elf.sgot;
2025       srela = htab->elf.srelgot;
2026       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2027         {
2028           if (*local_got > 0)
2029             {
2030               *local_got = s->size;
2031               s->size += GOT_ENTRY_SIZE;
2032               if (*local_tls_type == GOT_TLS_GD)
2033                 s->size += GOT_ENTRY_SIZE;
2034               if (info->shared)
2035                 srela->size += sizeof (Elf64_External_Rela);
2036             }
2037           else
2038             *local_got = (bfd_vma) -1;
2039         }
2040
2041       local_plt = elf_s390_local_plt (ibfd);
2042       for (i = 0; i < symtab_hdr->sh_info; i++)
2043         {
2044           if (local_plt[i].plt.refcount > 0)
2045             {
2046               local_plt[i].plt.offset = htab->elf.iplt->size;
2047               htab->elf.iplt->size += PLT_ENTRY_SIZE;
2048               htab->elf.igotplt->size += GOT_ENTRY_SIZE;
2049               htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
2050             }
2051           else
2052             local_plt[i].plt.offset = (bfd_vma) -1;
2053         }
2054     }
2055
2056   if (htab->tls_ldm_got.refcount > 0)
2057     {
2058       /* Allocate 2 got entries and 1 dynamic reloc for R_390_TLS_LDM64
2059          relocs.  */
2060       htab->tls_ldm_got.offset = htab->elf.sgot->size;
2061       htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
2062       htab->elf.srelgot->size += sizeof (Elf64_External_Rela);
2063     }
2064   else
2065     htab->tls_ldm_got.offset = -1;
2066
2067   /* Allocate global sym .plt and .got entries, and space for global
2068      sym dynamic relocs.  */
2069   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
2070
2071   /* We now have determined the sizes of the various dynamic sections.
2072      Allocate memory for them.  */
2073   relocs = FALSE;
2074   for (s = dynobj->sections; s != NULL; s = s->next)
2075     {
2076       if ((s->flags & SEC_LINKER_CREATED) == 0)
2077         continue;
2078
2079       if (s == htab->elf.splt
2080           || s == htab->elf.sgot
2081           || s == htab->elf.sgotplt
2082           || s == htab->sdynbss
2083           || s == htab->elf.iplt
2084           || s == htab->elf.igotplt
2085           || s == htab->irelifunc)
2086         {
2087           /* Strip this section if we don't need it; see the
2088              comment below.  */
2089         }
2090       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2091         {
2092           if (s->size != 0 && s != htab->elf.srelplt)
2093             relocs = TRUE;
2094
2095           /* We use the reloc_count field as a counter if we need
2096              to copy relocs into the output file.  */
2097           s->reloc_count = 0;
2098         }
2099       else
2100         {
2101           /* It's not one of our sections, so don't allocate space.  */
2102           continue;
2103         }
2104
2105       if (s->size == 0)
2106         {
2107           /* If we don't need this section, strip it from the
2108              output file.  This is to handle .rela.bss and
2109              .rela.plt.  We must create it in
2110              create_dynamic_sections, because it must be created
2111              before the linker maps input sections to output
2112              sections.  The linker does that before
2113              adjust_dynamic_symbol is called, and it is that
2114              function which decides whether anything needs to go
2115              into these sections.  */
2116
2117           s->flags |= SEC_EXCLUDE;
2118           continue;
2119         }
2120
2121       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2122         continue;
2123
2124       /* Allocate memory for the section contents.  We use bfd_zalloc
2125          here in case unused entries are not reclaimed before the
2126          section's contents are written out.  This should not happen,
2127          but this way if it does, we get a R_390_NONE reloc instead
2128          of garbage.  */
2129       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2130       if (s->contents == NULL)
2131         return FALSE;
2132     }
2133
2134   if (htab->elf.dynamic_sections_created)
2135     {
2136       /* Add some entries to the .dynamic section.  We fill in the
2137          values later, in elf_s390_finish_dynamic_sections, but we
2138          must add the entries now so that we get the correct size for
2139          the .dynamic section.  The DT_DEBUG entry is filled in by the
2140          dynamic linker and used by the debugger.  */
2141 #define add_dynamic_entry(TAG, VAL) \
2142   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2143
2144       if (info->executable)
2145         {
2146           if (!add_dynamic_entry (DT_DEBUG, 0))
2147             return FALSE;
2148         }
2149
2150       if (htab->elf.splt->size != 0)
2151         {
2152           if (!add_dynamic_entry (DT_PLTGOT, 0)
2153               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2154               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2155               || !add_dynamic_entry (DT_JMPREL, 0))
2156             return FALSE;
2157         }
2158
2159       if (relocs)
2160         {
2161           if (!add_dynamic_entry (DT_RELA, 0)
2162               || !add_dynamic_entry (DT_RELASZ, 0)
2163               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
2164             return FALSE;
2165
2166           /* If any dynamic relocs apply to a read-only section,
2167              then we need a DT_TEXTREL entry.  */
2168           if ((info->flags & DF_TEXTREL) == 0)
2169             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2170                                     info);
2171
2172           if ((info->flags & DF_TEXTREL) != 0)
2173             {
2174               if (!add_dynamic_entry (DT_TEXTREL, 0))
2175                 return FALSE;
2176             }
2177         }
2178     }
2179 #undef add_dynamic_entry
2180
2181   return TRUE;
2182 }
2183
2184 /* Return the base VMA address which should be subtracted from real addresses
2185    when resolving @dtpoff relocation.
2186    This is PT_TLS segment p_vaddr.  */
2187
2188 static bfd_vma
2189 dtpoff_base (struct bfd_link_info *info)
2190 {
2191   /* If tls_sec is NULL, we should have signalled an error already.  */
2192   if (elf_hash_table (info)->tls_sec == NULL)
2193     return 0;
2194   return elf_hash_table (info)->tls_sec->vma;
2195 }
2196
2197 /* Return the relocation value for @tpoff relocation
2198    if STT_TLS virtual address is ADDRESS.  */
2199
2200 static bfd_vma
2201 tpoff (struct bfd_link_info *info, bfd_vma address)
2202 {
2203   struct elf_link_hash_table *htab = elf_hash_table (info);
2204
2205   /* If tls_sec is NULL, we should have signalled an error already.  */
2206   if (htab->tls_sec == NULL)
2207     return 0;
2208   return htab->tls_size + htab->tls_sec->vma - address;
2209 }
2210
2211 /* Complain if TLS instruction relocation is against an invalid
2212    instruction.  */
2213
2214 static void
2215 invalid_tls_insn (bfd *input_bfd,
2216                   asection *input_section,
2217                   Elf_Internal_Rela *rel)
2218 {
2219   reloc_howto_type *howto;
2220
2221   howto = elf_howto_table + ELF64_R_TYPE (rel->r_info);
2222   (*_bfd_error_handler)
2223     (_("%B(%A+0x%lx): invalid instruction for TLS relocation %s"),
2224      input_bfd,
2225      input_section,
2226      (long) rel->r_offset,
2227      howto->name);
2228   bfd_set_error (bfd_error_bad_value);
2229 }
2230
2231 /* Relocate a 390 ELF section.  */
2232
2233 static bfd_boolean
2234 elf_s390_relocate_section (bfd *output_bfd,
2235                            struct bfd_link_info *info,
2236                            bfd *input_bfd,
2237                            asection *input_section,
2238                            bfd_byte *contents,
2239                            Elf_Internal_Rela *relocs,
2240                            Elf_Internal_Sym *local_syms,
2241                            asection **local_sections)
2242 {
2243   struct elf_s390_link_hash_table *htab;
2244   Elf_Internal_Shdr *symtab_hdr;
2245   struct elf_link_hash_entry **sym_hashes;
2246   bfd_vma *local_got_offsets;
2247   Elf_Internal_Rela *rel;
2248   Elf_Internal_Rela *relend;
2249
2250   BFD_ASSERT (is_s390_elf (input_bfd));
2251
2252   htab = elf_s390_hash_table (info);
2253   if (htab == NULL)
2254     return FALSE;
2255
2256   symtab_hdr = &elf_symtab_hdr (input_bfd);
2257   sym_hashes = elf_sym_hashes (input_bfd);
2258   local_got_offsets = elf_local_got_offsets (input_bfd);
2259
2260   rel = relocs;
2261   relend = relocs + input_section->reloc_count;
2262   for (; rel < relend; rel++)
2263     {
2264       unsigned int r_type;
2265       reloc_howto_type *howto;
2266       unsigned long r_symndx;
2267       struct elf_link_hash_entry *h;
2268       Elf_Internal_Sym *sym;
2269       asection *sec;
2270       bfd_vma off;
2271       bfd_vma relocation;
2272       bfd_boolean unresolved_reloc;
2273       bfd_reloc_status_type r;
2274       int tls_type;
2275       asection *base_got = htab->elf.sgot;
2276
2277       r_type = ELF64_R_TYPE (rel->r_info);
2278       if (r_type == (int) R_390_GNU_VTINHERIT
2279           || r_type == (int) R_390_GNU_VTENTRY)
2280         continue;
2281       if (r_type >= (int) R_390_max)
2282         {
2283           bfd_set_error (bfd_error_bad_value);
2284           return FALSE;
2285         }
2286
2287       howto = elf_howto_table + r_type;
2288       r_symndx = ELF64_R_SYM (rel->r_info);
2289
2290       h = NULL;
2291       sym = NULL;
2292       sec = NULL;
2293       unresolved_reloc = FALSE;
2294       if (r_symndx < symtab_hdr->sh_info)
2295         {
2296           sym = local_syms + r_symndx;
2297           sec = local_sections[r_symndx];
2298
2299           if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
2300             {
2301               struct plt_entry *local_plt = elf_s390_local_plt (input_bfd);
2302               if (local_plt == NULL)
2303                 return FALSE;
2304
2305               /* Address of the PLT slot.  */
2306               relocation = (htab->elf.iplt->output_section->vma
2307                             + htab->elf.iplt->output_offset
2308                             + local_plt[r_symndx].plt.offset);
2309
2310               switch (r_type)
2311                 {
2312                 case R_390_PLTOFF16:
2313                 case R_390_PLTOFF32:
2314                 case R_390_PLTOFF64:
2315                   relocation -= htab->elf.sgot->output_section->vma;
2316                   break;
2317                 case R_390_GOTPLT12:
2318                 case R_390_GOTPLT16:
2319                 case R_390_GOTPLT20:
2320                 case R_390_GOTPLT32:
2321                 case R_390_GOTPLT64:
2322                 case R_390_GOTPLTENT:
2323                 case R_390_GOT12:
2324                 case R_390_GOT16:
2325                 case R_390_GOT20:
2326                 case R_390_GOT32:
2327                 case R_390_GOT64:
2328                 case R_390_GOTENT:
2329                   {
2330                     /* Write the PLT slot address into the GOT slot.  */
2331                     bfd_put_64 (output_bfd, relocation,
2332                                 htab->elf.sgot->contents +
2333                                 local_got_offsets[r_symndx]);
2334                     relocation = (local_got_offsets[r_symndx] +
2335                                   htab->elf.sgot->output_offset);
2336
2337                     if (r_type == R_390_GOTENT || r_type == R_390_GOTPLTENT)
2338                       relocation += htab->elf.sgot->output_section->vma;
2339                     break;
2340                   }
2341                 default:
2342                   break;
2343                 }
2344               /* The output section is needed later in
2345                  finish_dynamic_section when creating the dynamic
2346                  relocation.  */
2347               local_plt[r_symndx].sec = sec;
2348               goto do_relocation;
2349             }
2350           else
2351             relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2352         }
2353       else
2354         {
2355           bfd_boolean warned ATTRIBUTE_UNUSED;
2356
2357           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2358                                    r_symndx, symtab_hdr, sym_hashes,
2359                                    h, sec, relocation,
2360                                    unresolved_reloc, warned);
2361         }
2362
2363       if (sec != NULL && discarded_section (sec))
2364         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2365                                          rel, 1, relend, howto, 0, contents);
2366
2367       if (info->relocatable)
2368         continue;
2369
2370       switch (r_type)
2371         {
2372         case R_390_GOTPLT12:
2373         case R_390_GOTPLT16:
2374         case R_390_GOTPLT20:
2375         case R_390_GOTPLT32:
2376         case R_390_GOTPLT64:
2377         case R_390_GOTPLTENT:
2378           /* There are three cases for a GOTPLT relocation. 1) The
2379              relocation is against the jump slot entry of a plt that
2380              will get emitted to the output file. 2) The relocation
2381              is against the jump slot of a plt entry that has been
2382              removed. elf_s390_adjust_gotplt has created a GOT entry
2383              as replacement. 3) The relocation is against a local symbol.
2384              Cases 2) and 3) are the same as the GOT relocation code
2385              so we just have to test for case 1 and fall through for
2386              the other two.  */
2387           if (h != NULL && h->plt.offset != (bfd_vma) -1)
2388             {
2389               bfd_vma plt_index;
2390
2391               if (s390_is_ifunc_symbol_p (h))
2392                 {
2393                   plt_index = h->plt.offset / PLT_ENTRY_SIZE;
2394                   relocation = (plt_index * GOT_ENTRY_SIZE +
2395                                 htab->elf.igotplt->output_offset);
2396                   if (r_type == R_390_GOTPLTENT)
2397                     relocation += htab->elf.igotplt->output_section->vma;
2398                 }
2399               else
2400                 {
2401                   /* Calc. index no.
2402                      Current offset - size first entry / entry size.  */
2403                   plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) /
2404                     PLT_ENTRY_SIZE;
2405
2406                   /* Offset in GOT is PLT index plus GOT headers(3)
2407                      times 4, addr & GOT addr.  */
2408                   relocation = (plt_index + 3) * GOT_ENTRY_SIZE;
2409                   if (r_type == R_390_GOTPLTENT)
2410                     relocation += htab->elf.sgot->output_section->vma;
2411                 }
2412               unresolved_reloc = FALSE;
2413               break;
2414             }
2415           /* Fall through.  */
2416
2417         case R_390_GOT12:
2418         case R_390_GOT16:
2419         case R_390_GOT20:
2420         case R_390_GOT32:
2421         case R_390_GOT64:
2422         case R_390_GOTENT:
2423           /* Relocation is to the entry for this symbol in the global
2424              offset table.  */
2425           if (base_got == NULL)
2426             abort ();
2427
2428           if (h != NULL)
2429             {
2430               bfd_boolean dyn;
2431
2432               off = h->got.offset;
2433               dyn = htab->elf.dynamic_sections_created;
2434
2435               if (s390_is_ifunc_symbol_p (h))
2436                 {
2437                   BFD_ASSERT (h->plt.offset != (bfd_vma) -1);
2438                   if (off == (bfd_vma)-1)
2439                     {
2440                       /* No explicit GOT usage so redirect to the
2441                          got.iplt slot.  */
2442                       base_got = htab->elf.igotplt;
2443                       off = h->plt.offset / PLT_ENTRY_SIZE * GOT_ENTRY_SIZE;
2444                     }
2445                   else
2446                     {
2447                       /* Explicit GOT slots must contain the address
2448                          of the PLT slot. This will be handled in
2449                          finish_dynamic_symbol.  */
2450                     }
2451                 }
2452               else if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2453                        || (info->shared
2454                            && SYMBOL_REFERENCES_LOCAL (info, h))
2455                        || (ELF_ST_VISIBILITY (h->other)
2456                            && h->root.type == bfd_link_hash_undefweak))
2457                 {
2458                   /* This is actually a static link, or it is a
2459                      -Bsymbolic link and the symbol is defined
2460                      locally, or the symbol was forced to be local
2461                      because of a version file.  We must initialize
2462                      this entry in the global offset table.  Since the
2463                      offset must always be a multiple of 2, we use the
2464                      least significant bit to record whether we have
2465                      initialized it already.
2466
2467                      When doing a dynamic link, we create a .rel.got
2468                      relocation entry to initialize the value.  This
2469                      is done in the finish_dynamic_symbol routine.  */
2470                   if ((off & 1) != 0)
2471                     off &= ~1;
2472                   else
2473                     {
2474                       bfd_put_64 (output_bfd, relocation,
2475                                   base_got->contents + off);
2476                       h->got.offset |= 1;
2477                     }
2478                 }
2479               else
2480                 unresolved_reloc = FALSE;
2481             }
2482           else
2483             {
2484               if (local_got_offsets == NULL)
2485                 abort ();
2486
2487               off = local_got_offsets[r_symndx];
2488
2489               /* The offset must always be a multiple of 8.  We use
2490                  the least significant bit to record whether we have
2491                  already generated the necessary reloc.  */
2492               if ((off & 1) != 0)
2493                 off &= ~1;
2494               else
2495                 {
2496                   bfd_put_64 (output_bfd, relocation,
2497                               htab->elf.sgot->contents + off);
2498
2499                   if (info->shared)
2500                     {
2501                       asection *s;
2502                       Elf_Internal_Rela outrel;
2503                       bfd_byte *loc;
2504
2505                       s = htab->elf.srelgot;
2506                       if (s == NULL)
2507                         abort ();
2508
2509                       outrel.r_offset = (htab->elf.sgot->output_section->vma
2510                                          + htab->elf.sgot->output_offset
2511                                          + off);
2512                       outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2513                       outrel.r_addend = relocation;
2514                       loc = s->contents;
2515                       loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
2516                       bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2517                     }
2518
2519                   local_got_offsets[r_symndx] |= 1;
2520                 }
2521             }
2522
2523           if (off >= (bfd_vma) -2)
2524             abort ();
2525
2526           relocation = base_got->output_offset + off;
2527
2528           /* For @GOTENT the relocation is against the offset between
2529              the instruction and the symbols entry in the GOT and not
2530              between the start of the GOT and the symbols entry. We
2531              add the vma of the GOT to get the correct value.  */
2532           if (   r_type == R_390_GOTENT
2533               || r_type == R_390_GOTPLTENT)
2534             relocation += base_got->output_section->vma;
2535
2536           break;
2537
2538         case R_390_GOTOFF16:
2539         case R_390_GOTOFF32:
2540         case R_390_GOTOFF64:
2541           /* Relocation is relative to the start of the global offset
2542              table.  */
2543
2544           /* Note that sgot->output_offset is not involved in this
2545              calculation.  We always want the start of .got.  If we
2546              defined _GLOBAL_OFFSET_TABLE in a different way, as is
2547              permitted by the ABI, we might have to change this
2548              calculation.  */
2549           relocation -= htab->elf.sgot->output_section->vma;
2550           break;
2551
2552         case R_390_GOTPC:
2553         case R_390_GOTPCDBL:
2554           /* Use global offset table as symbol value.  */
2555           relocation = htab->elf.sgot->output_section->vma;
2556           unresolved_reloc = FALSE;
2557           break;
2558
2559         case R_390_PLT16DBL:
2560         case R_390_PLT32:
2561         case R_390_PLT32DBL:
2562         case R_390_PLT64:
2563           /* Relocation is to the entry for this symbol in the
2564              procedure linkage table.  */
2565
2566           /* Resolve a PLT32 reloc against a local symbol directly,
2567              without using the procedure linkage table.  */
2568           if (h == NULL)
2569             break;
2570
2571           if (h->plt.offset == (bfd_vma) -1
2572               || (htab->elf.splt == NULL && !s390_is_ifunc_symbol_p (h)))
2573             {
2574               /* We didn't make a PLT entry for this symbol.  This
2575                  happens when statically linking PIC code, or when
2576                  using -Bsymbolic.  */
2577               break;
2578             }
2579           if (s390_is_ifunc_symbol_p (h))
2580             relocation = (htab->elf.iplt->output_section->vma
2581                           + htab->elf.iplt->output_offset
2582                           + h->plt.offset);
2583           else
2584             relocation = (htab->elf.splt->output_section->vma
2585                           + htab->elf.splt->output_offset
2586                           + h->plt.offset);
2587           unresolved_reloc = FALSE;
2588           break;
2589
2590         case R_390_PLTOFF16:
2591         case R_390_PLTOFF32:
2592         case R_390_PLTOFF64:
2593           /* Relocation is to the entry for this symbol in the
2594              procedure linkage table relative to the start of the GOT.  */
2595
2596           /* For local symbols or if we didn't make a PLT entry for
2597              this symbol resolve the symbol directly.  */
2598           if (h == NULL
2599               || h->plt.offset == (bfd_vma) -1
2600               || (htab->elf.splt == NULL && !s390_is_ifunc_symbol_p (h)))
2601             {
2602               relocation -= htab->elf.sgot->output_section->vma;
2603               break;
2604             }
2605
2606           if (s390_is_ifunc_symbol_p (h))
2607             relocation = (htab->elf.iplt->output_section->vma
2608                           + htab->elf.iplt->output_offset
2609                           + h->plt.offset
2610                           - htab->elf.sgot->output_section->vma);
2611           else
2612             relocation = (htab->elf.splt->output_section->vma
2613                           + htab->elf.splt->output_offset
2614                           + h->plt.offset
2615                           - htab->elf.sgot->output_section->vma);
2616           unresolved_reloc = FALSE;
2617           break;
2618
2619         case R_390_8:
2620         case R_390_16:
2621         case R_390_32:
2622         case R_390_64:
2623         case R_390_PC16:
2624         case R_390_PC16DBL:
2625         case R_390_PC32:
2626         case R_390_PC32DBL:
2627         case R_390_PC64:
2628
2629           if (h != NULL
2630               && s390_is_ifunc_symbol_p (h)
2631               && h->def_regular)
2632             {
2633               if (!info->shared || !h->non_got_ref)
2634                 {
2635                   /* For a non-shared object STT_GNU_IFUNC symbol must
2636                      go through PLT.  */
2637                   relocation = (htab->elf.iplt->output_section->vma
2638                                 + htab->elf.iplt->output_offset
2639                                 + h ->plt.offset);
2640                   goto do_relocation;
2641                 }
2642               else
2643                 {
2644                   /* For shared objects a runtime relocation is needed.  */
2645
2646                   Elf_Internal_Rela outrel;
2647                   asection *sreloc;
2648
2649                   /* Need a dynamic relocation to get the real function
2650                      address.  */
2651                   outrel.r_offset = _bfd_elf_section_offset (output_bfd,
2652                                                              info,
2653                                                              input_section,
2654                                                              rel->r_offset);
2655                   if (outrel.r_offset == (bfd_vma) -1
2656                       || outrel.r_offset == (bfd_vma) -2)
2657                     abort ();
2658
2659                   outrel.r_offset += (input_section->output_section->vma
2660                                       + input_section->output_offset);
2661
2662                   if (h->dynindx == -1
2663                       || h->forced_local
2664                       || info->executable)
2665                     {
2666                       /* This symbol is resolved locally.  */
2667                       outrel.r_info = ELF64_R_INFO (0, R_390_IRELATIVE);
2668                       outrel.r_addend = (h->root.u.def.value
2669                                          + h->root.u.def.section->output_section->vma
2670                                          + h->root.u.def.section->output_offset);
2671                     }
2672                   else
2673                     {
2674                       outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
2675                       outrel.r_addend = 0;
2676                     }
2677
2678                   sreloc = htab->elf.irelifunc;
2679                   elf_append_rela (output_bfd, sreloc, &outrel);
2680
2681                   /* If this reloc is against an external symbol, we
2682                      do not want to fiddle with the addend.  Otherwise,
2683                      we need to include the symbol value so that it
2684                      becomes an addend for the dynamic reloc.  For an
2685                      internal symbol, we have updated addend.  */
2686                   continue;
2687                 }
2688             }
2689
2690           if ((input_section->flags & SEC_ALLOC) == 0)
2691             break;
2692
2693           if ((info->shared
2694                && (h == NULL
2695                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2696                    || h->root.type != bfd_link_hash_undefweak)
2697                && ((r_type != R_390_PC16
2698                     && r_type != R_390_PC16DBL
2699                     && r_type != R_390_PC32
2700                     && r_type != R_390_PC32DBL
2701                     && r_type != R_390_PC64)
2702                    || !SYMBOL_CALLS_LOCAL (info, h)))
2703               || (ELIMINATE_COPY_RELOCS
2704                   && !info->shared
2705                   && h != NULL
2706                   && h->dynindx != -1
2707                   && !h->non_got_ref
2708                   && ((h->def_dynamic
2709                        && !h->def_regular)
2710                       || h->root.type == bfd_link_hash_undefweak
2711                       || h->root.type == bfd_link_hash_undefined)))
2712             {
2713               Elf_Internal_Rela outrel;
2714               bfd_boolean skip, relocate;
2715               asection *sreloc;
2716               bfd_byte *loc;
2717
2718               /* When generating a shared object, these relocations
2719                  are copied into the output file to be resolved at run
2720                  time.  */
2721               skip = FALSE;
2722               relocate = FALSE;
2723
2724               outrel.r_offset =
2725                 _bfd_elf_section_offset (output_bfd, info, input_section,
2726                                          rel->r_offset);
2727               if (outrel.r_offset == (bfd_vma) -1)
2728                 skip = TRUE;
2729               else if (outrel.r_offset == (bfd_vma) -2)
2730                 skip = TRUE, relocate = TRUE;
2731
2732               outrel.r_offset += (input_section->output_section->vma
2733                                   + input_section->output_offset);
2734
2735               if (skip)
2736                 memset (&outrel, 0, sizeof outrel);
2737               else if (h != NULL
2738                        && h->dynindx != -1
2739                        && (r_type == R_390_PC16
2740                            || r_type == R_390_PC16DBL
2741                            || r_type == R_390_PC32
2742                            || r_type == R_390_PC32DBL
2743                            || r_type == R_390_PC64
2744                            || !info->shared
2745                            || !SYMBOLIC_BIND (info, h)
2746                            || !h->def_regular))
2747                 {
2748                   outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
2749                   outrel.r_addend = rel->r_addend;
2750                 }
2751               else
2752                 {
2753                   /* This symbol is local, or marked to become local.  */
2754                   outrel.r_addend = relocation + rel->r_addend;
2755                   if (r_type == R_390_64)
2756                     {
2757                       relocate = TRUE;
2758                       outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2759                     }
2760                   else
2761                     {
2762                       long sindx;
2763
2764                       if (bfd_is_abs_section (sec))
2765                         sindx = 0;
2766                       else if (sec == NULL || sec->owner == NULL)
2767                         {
2768                           bfd_set_error(bfd_error_bad_value);
2769                           return FALSE;
2770                         }
2771                       else
2772                         {
2773                           asection *osec;
2774
2775                           osec = sec->output_section;
2776                           sindx = elf_section_data (osec)->dynindx;
2777
2778                           if (sindx == 0)
2779                             {
2780                               osec = htab->elf.text_index_section;
2781                               sindx = elf_section_data (osec)->dynindx;
2782                             }
2783                           BFD_ASSERT (sindx != 0);
2784
2785                           /* We are turning this relocation into one
2786                              against a section symbol, so subtract out
2787                              the output section's address but not the
2788                              offset of the input section in the output
2789                              section.  */
2790                           outrel.r_addend -= osec->vma;
2791                         }
2792                       outrel.r_info = ELF64_R_INFO (sindx, r_type);
2793                     }
2794                 }
2795
2796               sreloc = elf_section_data (input_section)->sreloc;
2797               if (sreloc == NULL)
2798                 abort ();
2799
2800               loc = sreloc->contents;
2801               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2802               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2803
2804               /* If this reloc is against an external symbol, we do
2805                  not want to fiddle with the addend.  Otherwise, we
2806                  need to include the symbol value so that it becomes
2807                  an addend for the dynamic reloc.  */
2808               if (! relocate)
2809                 continue;
2810             }
2811
2812           break;
2813
2814           /* Relocations for tls literal pool entries.  */
2815         case R_390_TLS_IE64:
2816           if (info->shared)
2817             {
2818               Elf_Internal_Rela outrel;
2819               asection *sreloc;
2820               bfd_byte *loc;
2821
2822               outrel.r_offset = rel->r_offset
2823                                 + input_section->output_section->vma
2824                                 + input_section->output_offset;
2825               outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2826               sreloc = elf_section_data (input_section)->sreloc;
2827               if (sreloc == NULL)
2828                 abort ();
2829               loc = sreloc->contents;
2830               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2831               bfd_elf64_swap_reloc_out (output_bfd, &outrel, loc);
2832             }
2833           /* Fall through.  */
2834
2835         case R_390_TLS_GD64:
2836         case R_390_TLS_GOTIE64:
2837           r_type = elf_s390_tls_transition (info, r_type, h == NULL);
2838           tls_type = GOT_UNKNOWN;
2839           if (h == NULL && local_got_offsets)
2840             tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
2841           else if (h != NULL)
2842             {
2843               tls_type = elf_s390_hash_entry(h)->tls_type;
2844               if (!info->shared && h->dynindx == -1 && tls_type >= GOT_TLS_IE)
2845                 r_type = R_390_TLS_LE64;
2846             }
2847           if (r_type == R_390_TLS_GD64 && tls_type >= GOT_TLS_IE)
2848             r_type = R_390_TLS_IE64;
2849
2850           if (r_type == R_390_TLS_LE64)
2851             {
2852               /* This relocation gets optimized away by the local exec
2853                  access optimization.  */
2854               BFD_ASSERT (! unresolved_reloc);
2855               bfd_put_64 (output_bfd, -tpoff (info, relocation),
2856                           contents + rel->r_offset);
2857               continue;
2858             }
2859
2860           if (htab->elf.sgot == NULL)
2861             abort ();
2862
2863           if (h != NULL)
2864             off = h->got.offset;
2865           else
2866             {
2867               if (local_got_offsets == NULL)
2868                 abort ();
2869
2870               off = local_got_offsets[r_symndx];
2871             }
2872
2873         emit_tls_relocs:
2874
2875           if ((off & 1) != 0)
2876             off &= ~1;
2877           else
2878             {
2879               Elf_Internal_Rela outrel;
2880               bfd_byte *loc;
2881               int dr_type, indx;
2882
2883               if (htab->elf.srelgot == NULL)
2884                 abort ();
2885
2886               outrel.r_offset = (htab->elf.sgot->output_section->vma
2887                                  + htab->elf.sgot->output_offset + off);
2888
2889               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2890               if (r_type == R_390_TLS_GD64)
2891                 dr_type = R_390_TLS_DTPMOD;
2892               else
2893                 dr_type = R_390_TLS_TPOFF;
2894               if (dr_type == R_390_TLS_TPOFF && indx == 0)
2895                 outrel.r_addend = relocation - dtpoff_base (info);
2896               else
2897                 outrel.r_addend = 0;
2898               outrel.r_info = ELF64_R_INFO (indx, dr_type);
2899               loc = htab->elf.srelgot->contents;
2900               loc += htab->elf.srelgot->reloc_count++
2901                 * sizeof (Elf64_External_Rela);
2902               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2903
2904               if (r_type == R_390_TLS_GD64)
2905                 {
2906                   if (indx == 0)
2907                     {
2908                       BFD_ASSERT (! unresolved_reloc);
2909                       bfd_put_64 (output_bfd,
2910                                   relocation - dtpoff_base (info),
2911                                   htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
2912                     }
2913                   else
2914                     {
2915                       outrel.r_info = ELF64_R_INFO (indx, R_390_TLS_DTPOFF);
2916                       outrel.r_offset += GOT_ENTRY_SIZE;
2917                       outrel.r_addend = 0;
2918                       htab->elf.srelgot->reloc_count++;
2919                       loc += sizeof (Elf64_External_Rela);
2920                       bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2921                     }
2922                 }
2923
2924               if (h != NULL)
2925                 h->got.offset |= 1;
2926               else
2927                 local_got_offsets[r_symndx] |= 1;
2928             }
2929
2930           if (off >= (bfd_vma) -2)
2931             abort ();
2932           if (r_type == ELF64_R_TYPE (rel->r_info))
2933             {
2934               relocation = htab->elf.sgot->output_offset + off;
2935               if (r_type == R_390_TLS_IE64 || r_type == R_390_TLS_IEENT)
2936                 relocation += htab->elf.sgot->output_section->vma;
2937               unresolved_reloc = FALSE;
2938             }
2939           else
2940             {
2941               bfd_put_64 (output_bfd, htab->elf.sgot->output_offset + off,
2942                           contents + rel->r_offset);
2943               continue;
2944             }
2945           break;
2946
2947         case R_390_TLS_GOTIE12:
2948         case R_390_TLS_GOTIE20:
2949         case R_390_TLS_IEENT:
2950           if (h == NULL)
2951             {
2952               if (local_got_offsets == NULL)
2953                 abort();
2954               off = local_got_offsets[r_symndx];
2955               if (info->shared)
2956                 goto emit_tls_relocs;
2957             }
2958           else
2959             {
2960               off = h->got.offset;
2961               tls_type = elf_s390_hash_entry(h)->tls_type;
2962               if (info->shared || h->dynindx != -1 || tls_type < GOT_TLS_IE)
2963                 goto emit_tls_relocs;
2964             }
2965
2966           if (htab->elf.sgot == NULL)
2967             abort ();
2968
2969           BFD_ASSERT (! unresolved_reloc);
2970           bfd_put_64 (output_bfd, -tpoff (info, relocation),
2971                       htab->elf.sgot->contents + off);
2972           relocation = htab->elf.sgot->output_offset + off;
2973           if (r_type == R_390_TLS_IEENT)
2974             relocation += htab->elf.sgot->output_section->vma;
2975           unresolved_reloc = FALSE;
2976           break;
2977
2978         case R_390_TLS_LDM64:
2979           if (! info->shared)
2980             /* The literal pool entry this relocation refers to gets ignored
2981                by the optimized code of the local exec model. Do nothing
2982                and the value will turn out zero.  */
2983             continue;
2984
2985           if (htab->elf.sgot == NULL)
2986             abort ();
2987
2988           off = htab->tls_ldm_got.offset;
2989           if (off & 1)
2990             off &= ~1;
2991           else
2992             {
2993               Elf_Internal_Rela outrel;
2994               bfd_byte *loc;
2995
2996               if (htab->elf.srelgot == NULL)
2997                 abort ();
2998
2999               outrel.r_offset = (htab->elf.sgot->output_section->vma
3000                                  + htab->elf.sgot->output_offset + off);
3001
3002               bfd_put_64 (output_bfd, 0,
3003                           htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3004               outrel.r_info = ELF64_R_INFO (0, R_390_TLS_DTPMOD);
3005               outrel.r_addend = 0;
3006               loc = htab->elf.srelgot->contents;
3007               loc += htab->elf.srelgot->reloc_count++
3008                 * sizeof (Elf64_External_Rela);
3009               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
3010               htab->tls_ldm_got.offset |= 1;
3011             }
3012           relocation = htab->elf.sgot->output_offset + off;
3013           unresolved_reloc = FALSE;
3014           break;
3015
3016         case R_390_TLS_LE64:
3017           if (info->shared)
3018             {
3019               /* Linking a shared library with non-fpic code requires
3020                  a R_390_TLS_TPOFF relocation.  */
3021               Elf_Internal_Rela outrel;
3022               asection *sreloc;
3023               bfd_byte *loc;
3024               int indx;
3025
3026               outrel.r_offset = rel->r_offset
3027                                 + input_section->output_section->vma
3028                                 + input_section->output_offset;
3029               if (h != NULL && h->dynindx != -1)
3030                 indx = h->dynindx;
3031               else
3032                 indx = 0;
3033               outrel.r_info = ELF64_R_INFO (indx, R_390_TLS_TPOFF);
3034               if (indx == 0)
3035                 outrel.r_addend = relocation - dtpoff_base (info);
3036               else
3037                 outrel.r_addend = 0;
3038               sreloc = elf_section_data (input_section)->sreloc;
3039               if (sreloc == NULL)
3040                 abort ();
3041               loc = sreloc->contents;
3042               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
3043               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
3044             }
3045           else
3046             {
3047               BFD_ASSERT (! unresolved_reloc);
3048               bfd_put_64 (output_bfd, -tpoff (info, relocation),
3049                           contents + rel->r_offset);
3050             }
3051           continue;
3052
3053         case R_390_TLS_LDO64:
3054           if (info->shared || (input_section->flags & SEC_DEBUGGING))
3055             relocation -= dtpoff_base (info);
3056           else
3057             /* When converting LDO to LE, we must negate.  */
3058             relocation = -tpoff (info, relocation);
3059           break;
3060
3061           /* Relocations for tls instructions.  */
3062         case R_390_TLS_LOAD:
3063         case R_390_TLS_GDCALL:
3064         case R_390_TLS_LDCALL:
3065           tls_type = GOT_UNKNOWN;
3066           if (h == NULL && local_got_offsets)
3067             tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
3068           else if (h != NULL)
3069             tls_type = elf_s390_hash_entry(h)->tls_type;
3070
3071           if (tls_type == GOT_TLS_GD)
3072             continue;
3073
3074           if (r_type == R_390_TLS_LOAD)
3075             {
3076               if (!info->shared && (h == NULL || h->dynindx == -1))
3077                 {
3078                   /* IE->LE transition. Four valid cases:
3079                      lg %rx,(0,%ry)    -> sllg %rx,%ry,0
3080                      lg %rx,(%ry,0)    -> sllg %rx,%ry,0
3081                      lg %rx,(%ry,%r12) -> sllg %rx,%ry,0
3082                      lg %rx,(%r12,%ry) -> sllg %rx,%ry,0  */
3083                   unsigned int insn0, insn1, ry;
3084
3085                   insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset);
3086                   insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4);
3087                   if (insn1 != 0x0004)
3088                     invalid_tls_insn (input_bfd, input_section, rel);
3089                   ry = 0;
3090                   if ((insn0 & 0xff00f000) == 0xe3000000)
3091                     /* lg %rx,0(%ry,0) -> sllg %rx,%ry,0  */
3092                     ry = (insn0 & 0x000f0000);
3093                   else if ((insn0 & 0xff0f0000) == 0xe3000000)
3094                     /* lg %rx,0(0,%ry) -> sllg %rx,%ry,0  */
3095                     ry = (insn0 & 0x0000f000) << 4;
3096                   else if ((insn0 & 0xff00f000) == 0xe300c000)
3097                     /* lg %rx,0(%ry,%r12) -> sllg %rx,%ry,0  */
3098                     ry = (insn0 & 0x000f0000);
3099                   else if ((insn0 & 0xff0f0000) == 0xe30c0000)
3100                     /* lg %rx,0(%r12,%ry) -> sllg %rx,%ry,0  */
3101                     ry = (insn0 & 0x0000f000) << 4;
3102                   else
3103                     invalid_tls_insn (input_bfd, input_section, rel);
3104                   insn0 = 0xeb000000 | (insn0 & 0x00f00000) | ry;
3105                   insn1 = 0x000d;
3106                   bfd_put_32 (output_bfd, insn0, contents + rel->r_offset);
3107                   bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4);
3108                 }
3109             }
3110           else if (r_type == R_390_TLS_GDCALL)
3111             {
3112               unsigned int insn0, insn1;
3113
3114               insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset);
3115               insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4);
3116               if ((insn0 & 0xffff0000) != 0xc0e50000)
3117                 invalid_tls_insn (input_bfd, input_section, rel);
3118               if (!info->shared && (h == NULL || h->dynindx == -1))
3119                 {
3120                   /* GD->LE transition.
3121                      brasl %r14,__tls_get_addr@plt -> brcl 0,. */
3122                   insn0 = 0xc0040000;
3123                   insn1 = 0x0000;
3124                 }
3125               else
3126                 {
3127                   /* GD->IE transition.
3128                      brasl %r14,__tls_get_addr@plt -> lg %r2,0(%r2,%r12)  */
3129                   insn0 = 0xe322c000;
3130                   insn1 = 0x0004;
3131                 }
3132               bfd_put_32 (output_bfd, insn0, contents + rel->r_offset);
3133               bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4);
3134             }
3135           else if (r_type == R_390_TLS_LDCALL)
3136             {
3137               if (!info->shared)
3138                 {
3139                   unsigned int insn0, insn1;
3140
3141                   insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset);
3142                   insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4);
3143                   if ((insn0 & 0xffff0000) != 0xc0e50000)
3144                     invalid_tls_insn (input_bfd, input_section, rel);
3145                   /* LD->LE transition.
3146                      brasl %r14,__tls_get_addr@plt -> brcl 0,. */
3147                   insn0 = 0xc0040000;
3148                   insn1 = 0x0000;
3149                   bfd_put_32 (output_bfd, insn0, contents + rel->r_offset);
3150                   bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4);
3151                 }
3152             }
3153           continue;
3154
3155         default:
3156           break;
3157         }
3158
3159       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3160          because such sections are not SEC_ALLOC and thus ld.so will
3161          not process them.  */
3162       if (unresolved_reloc
3163           && !((input_section->flags & SEC_DEBUGGING) != 0
3164                && h->def_dynamic)
3165           && _bfd_elf_section_offset (output_bfd, info, input_section,
3166                                       rel->r_offset) != (bfd_vma) -1)
3167         (*_bfd_error_handler)
3168           (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3169            input_bfd,
3170            input_section,
3171            (long) rel->r_offset,
3172            howto->name,
3173            h->root.root.string);
3174
3175     do_relocation:
3176
3177       if (r_type == R_390_20
3178           || r_type == R_390_GOT20
3179           || r_type == R_390_GOTPLT20
3180           || r_type == R_390_TLS_GOTIE20)
3181         {
3182           relocation += rel->r_addend;
3183           relocation = (relocation&0xfff) << 8 | (relocation&0xff000) >> 12;
3184           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3185                                         contents, rel->r_offset,
3186                                         relocation, 0);
3187         }
3188       else
3189         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3190                                       contents, rel->r_offset,
3191                                       relocation, rel->r_addend);
3192
3193       if (r != bfd_reloc_ok)
3194         {
3195           const char *name;
3196
3197           if (h != NULL)
3198             name = h->root.root.string;
3199           else
3200             {
3201               name = bfd_elf_string_from_elf_section (input_bfd,
3202                                                       symtab_hdr->sh_link,
3203                                                       sym->st_name);
3204               if (name == NULL)
3205                 return FALSE;
3206               if (*name == '\0')
3207                 name = bfd_section_name (input_bfd, sec);
3208             }
3209
3210           if (r == bfd_reloc_overflow)
3211             {
3212
3213               if (! ((*info->callbacks->reloc_overflow)
3214                      (info, (h ? &h->root : NULL), name, howto->name,
3215                       (bfd_vma) 0, input_bfd, input_section,
3216                       rel->r_offset)))
3217                 return FALSE;
3218             }
3219           else
3220             {
3221               (*_bfd_error_handler)
3222                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3223                  input_bfd, input_section,
3224                  (long) rel->r_offset, name, (int) r);
3225               return FALSE;
3226             }
3227         }
3228     }
3229
3230   return TRUE;
3231 }
3232
3233 /* Generate the PLT slots together with the dynamic relocations needed
3234    for IFUNC symbols.  */
3235
3236 static void
3237 elf_s390_finish_ifunc_symbol (bfd *output_bfd,
3238                               struct bfd_link_info *info,
3239                               struct elf_link_hash_entry *h,
3240                               struct elf_s390_link_hash_table *htab,
3241                               bfd_vma plt_offset,
3242                               bfd_vma resolver_address)
3243 {
3244   bfd_vma plt_index;
3245   bfd_vma got_offset;
3246   Elf_Internal_Rela rela;
3247   bfd_byte *loc;
3248   asection *plt, *gotplt, *relplt;
3249
3250   if (htab->elf.iplt == NULL
3251       || htab->elf.igotplt == NULL
3252       || htab->elf.irelplt == NULL)
3253     abort ();
3254
3255   /* Index of the PLT slot within iplt section.  */
3256   plt_index = plt_offset / PLT_ENTRY_SIZE;
3257   plt = htab->elf.iplt;
3258   /* Offset into the igot.plt section.  */
3259   got_offset = plt_index * GOT_ENTRY_SIZE;
3260   gotplt = htab->elf.igotplt;
3261   relplt = htab->elf.irelplt;
3262
3263   /* Fill in the blueprint of a PLT.  */
3264   memcpy (plt->contents + plt_offset, elf_s390x_plt_entry,
3265           PLT_ENTRY_SIZE);
3266
3267   /* Fixup the relative address to the GOT entry */
3268   bfd_put_32 (output_bfd,
3269               (gotplt->output_section->vma +
3270                gotplt->output_offset + got_offset
3271                - (plt->output_section->vma +
3272                   plt->output_offset +
3273                   plt_offset))/2,
3274               plt->contents + plt_offset + 2);
3275   /* Fixup the relative branch to PLT 0 */
3276   bfd_put_32 (output_bfd, - (plt->output_offset +
3277                              (PLT_ENTRY_SIZE * plt_index) + 22)/2,
3278               plt->contents + plt_offset + 24);
3279   /* Fixup offset into .rela.plt section.  */
3280   bfd_put_32 (output_bfd, relplt->output_offset +
3281               plt_index * sizeof (Elf64_External_Rela),
3282               plt->contents + plt_offset + 28);
3283
3284   /* Fill in the entry in the global offset table.
3285      Points to instruction after GOT offset.  */
3286   bfd_put_64 (output_bfd,
3287               (plt->output_section->vma
3288                + plt->output_offset
3289                + plt_offset
3290                + 14),
3291               gotplt->contents + got_offset);
3292
3293   /* Fill in the entry in the .rela.plt section.  */
3294   rela.r_offset = (gotplt->output_section->vma
3295                    + gotplt->output_offset
3296                    + got_offset);
3297
3298   if (!h
3299       || h->dynindx == -1
3300       || ((info->executable
3301            || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
3302           && h->def_regular))
3303     {
3304       /* The symbol can be locally resolved.  */
3305       rela.r_info = ELF64_R_INFO (0, R_390_IRELATIVE);
3306       rela.r_addend = resolver_address;
3307     }
3308   else
3309     {
3310       rela.r_info = ELF64_R_INFO (h->dynindx, R_390_JMP_SLOT);
3311       rela.r_addend = 0;
3312     }
3313
3314   loc = relplt->contents + plt_index * sizeof (Elf64_External_Rela);
3315   bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3316 }
3317
3318
3319 /* Finish up dynamic symbol handling.  We set the contents of various
3320    dynamic sections here.  */
3321
3322 static bfd_boolean
3323 elf_s390_finish_dynamic_symbol (bfd *output_bfd,
3324                                 struct bfd_link_info *info,
3325                                 struct elf_link_hash_entry *h,
3326                                 Elf_Internal_Sym *sym)
3327 {
3328   struct elf_s390_link_hash_table *htab;
3329   struct elf_s390_link_hash_entry *eh = (struct elf_s390_link_hash_entry*)h;
3330
3331   htab = elf_s390_hash_table (info);
3332   if (htab == NULL)
3333     return FALSE;
3334
3335   if (h->plt.offset != (bfd_vma) -1)
3336     {
3337       bfd_vma plt_index;
3338       bfd_vma got_offset;
3339       Elf_Internal_Rela rela;
3340       bfd_byte *loc;
3341
3342       /* This symbol has an entry in the procedure linkage table.  Set
3343          it up.  */
3344       if (s390_is_ifunc_symbol_p (h))
3345         {
3346           /* If we can resolve the IFUNC symbol locally we generate an
3347              IRELATIVE reloc.  */
3348           elf_s390_finish_ifunc_symbol (output_bfd, info, h, htab, h->plt.offset,
3349                                         eh->ifunc_resolver_address +
3350                                         eh->ifunc_resolver_section->output_offset +
3351                                         eh->ifunc_resolver_section->output_section->vma);
3352                                  ;
3353           /* Fallthrough.  Handling of explicit GOT slots of IFUNC
3354              symbols is below.  */
3355         }
3356       else
3357         {
3358           if (h->dynindx == -1
3359               || htab->elf.splt == NULL
3360               || htab->elf.sgotplt == NULL
3361               || htab->elf.srelplt == NULL)
3362             abort ();
3363
3364           /* Calc. index no.
3365              Current offset - size first entry / entry size.  */
3366           plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3367
3368           /* Offset in GOT is PLT index plus GOT headers(3) times 8,
3369              addr & GOT addr.  */
3370           got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
3371
3372           /* Fill in the blueprint of a PLT.  */
3373           memcpy (htab->elf.splt->contents + h->plt.offset, elf_s390x_plt_entry,
3374                   PLT_ENTRY_SIZE);
3375
3376           /* Fixup the relative address to the GOT entry */
3377           bfd_put_32 (output_bfd,
3378                       (htab->elf.sgotplt->output_section->vma +
3379                        htab->elf.sgotplt->output_offset + got_offset
3380                        - (htab->elf.splt->output_section->vma +
3381                           htab->elf.splt->output_offset +
3382                           h->plt.offset))/2,
3383                       htab->elf.splt->contents + h->plt.offset + 2);
3384           /* Fixup the relative branch to PLT 0 */
3385           bfd_put_32 (output_bfd, - (PLT_FIRST_ENTRY_SIZE +
3386                                      (PLT_ENTRY_SIZE * plt_index) + 22)/2,
3387                       htab->elf.splt->contents + h->plt.offset + 24);
3388           /* Fixup offset into .rela.plt section.  */
3389           bfd_put_32 (output_bfd, plt_index * sizeof (Elf64_External_Rela),
3390                       htab->elf.splt->contents + h->plt.offset + 28);
3391
3392           /* Fill in the entry in the global offset table.
3393              Points to instruction after GOT offset.  */
3394           bfd_put_64 (output_bfd,
3395                       (htab->elf.splt->output_section->vma
3396                        + htab->elf.splt->output_offset
3397                        + h->plt.offset
3398                        + 14),
3399                       htab->elf.sgotplt->contents + got_offset);
3400
3401           /* Fill in the entry in the .rela.plt section.  */
3402           rela.r_offset = (htab->elf.sgotplt->output_section->vma
3403                            + htab->elf.sgotplt->output_offset
3404                            + got_offset);
3405           rela.r_info = ELF64_R_INFO (h->dynindx, R_390_JMP_SLOT);
3406           rela.r_addend = 0;
3407           loc = htab->elf.srelplt->contents + plt_index *
3408             sizeof (Elf64_External_Rela);
3409           bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3410
3411           if (!h->def_regular)
3412             {
3413               /* Mark the symbol as undefined, rather than as defined in
3414                  the .plt section.  Leave the value alone.  This is a clue
3415                  for the dynamic linker, to make function pointer
3416                  comparisons work between an application and shared
3417                  library.  */
3418               sym->st_shndx = SHN_UNDEF;
3419             }
3420         }
3421     }
3422
3423   if (h->got.offset != (bfd_vma) -1
3424       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_GD
3425       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE
3426       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE_NLT)
3427     {
3428       Elf_Internal_Rela rela;
3429       bfd_byte *loc;
3430
3431       /* This symbol has an entry in the global offset table.  Set it
3432          up.  */
3433       if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
3434         abort ();
3435
3436       rela.r_offset = (htab->elf.sgot->output_section->vma
3437                        + htab->elf.sgot->output_offset
3438                        + (h->got.offset &~ (bfd_vma) 1));
3439
3440       if (h->def_regular && s390_is_ifunc_symbol_p (h))
3441         {
3442           if (info->shared)
3443             {
3444               /* An explicit GOT slot usage needs GLOB_DAT.  If the
3445                  symbol references local the implicit got.iplt slot
3446                  will be used and the IRELATIVE reloc has been created
3447                  above.  */
3448               goto do_glob_dat;
3449             }
3450           else
3451             {
3452               /* For non-shared objects explicit GOT slots must be
3453                  filled with the PLT slot address for pointer
3454                  equality reasons.  */
3455               bfd_put_64 (output_bfd, (htab->elf.iplt->output_section->vma
3456                                        + htab->elf.iplt->output_offset
3457                                        + h->plt.offset),
3458                           htab->elf.sgot->contents + h->got.offset);
3459               return TRUE;
3460             }
3461         }
3462       else if (info->shared
3463           && SYMBOL_REFERENCES_LOCAL (info, h))
3464         {
3465           /* If this is a static link, or it is a -Bsymbolic link and
3466              the symbol is defined locally or was forced to be local
3467              because of a version file, we just want to emit a
3468              RELATIVE reloc.  The entry in the global offset table
3469              will already have been initialized in the
3470              relocate_section function.  */
3471           if (!h->def_regular)
3472             return FALSE;
3473           BFD_ASSERT((h->got.offset & 1) != 0);
3474           rela.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
3475           rela.r_addend = (h->root.u.def.value
3476                            + h->root.u.def.section->output_section->vma
3477                            + h->root.u.def.section->output_offset);
3478         }
3479       else
3480         {
3481           BFD_ASSERT((h->got.offset & 1) == 0);
3482 do_glob_dat:
3483           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgot->contents + h->got.offset);
3484           rela.r_info = ELF64_R_INFO (h->dynindx, R_390_GLOB_DAT);
3485           rela.r_addend = 0;
3486         }
3487
3488       loc = htab->elf.srelgot->contents;
3489       loc += htab->elf.srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
3490       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3491     }
3492
3493   if (h->needs_copy)
3494     {
3495       Elf_Internal_Rela rela;
3496       bfd_byte *loc;
3497
3498       /* This symbols needs a copy reloc.  Set it up.  */
3499
3500       if (h->dynindx == -1
3501           || (h->root.type != bfd_link_hash_defined
3502               && h->root.type != bfd_link_hash_defweak)
3503           || htab->srelbss == NULL)
3504         abort ();
3505
3506       rela.r_offset = (h->root.u.def.value
3507                        + h->root.u.def.section->output_section->vma
3508                        + h->root.u.def.section->output_offset);
3509       rela.r_info = ELF64_R_INFO (h->dynindx, R_390_COPY);
3510       rela.r_addend = 0;
3511       loc = htab->srelbss->contents;
3512       loc += htab->srelbss->reloc_count++ * sizeof (Elf64_External_Rela);
3513       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3514     }
3515
3516   /* Mark some specially defined symbols as absolute.  */
3517   if (h == htab->elf.hdynamic
3518       || h == htab->elf.hgot
3519       || h == htab->elf.hplt)
3520     sym->st_shndx = SHN_ABS;
3521
3522   return TRUE;
3523 }
3524
3525 /* Used to decide how to sort relocs in an optimal manner for the
3526    dynamic linker, before writing them out.  */
3527
3528 static enum elf_reloc_type_class
3529 elf_s390_reloc_type_class (const Elf_Internal_Rela *rela)
3530 {
3531   switch ((int) ELF64_R_TYPE (rela->r_info))
3532     {
3533     case R_390_RELATIVE:
3534       return reloc_class_relative;
3535     case R_390_JMP_SLOT:
3536       return reloc_class_plt;
3537     case R_390_COPY:
3538       return reloc_class_copy;
3539     default:
3540       return reloc_class_normal;
3541     }
3542 }
3543
3544 /* Finish up the dynamic sections.  */
3545
3546 static bfd_boolean
3547 elf_s390_finish_dynamic_sections (bfd *output_bfd,
3548                                   struct bfd_link_info *info)
3549 {
3550   struct elf_s390_link_hash_table *htab;
3551   bfd *dynobj;
3552   asection *sdyn;
3553   bfd *ibfd;
3554   unsigned int i;
3555
3556   htab = elf_s390_hash_table (info);
3557   if (htab == NULL)
3558     return FALSE;
3559
3560   dynobj = htab->elf.dynobj;
3561   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3562
3563   if (htab->elf.dynamic_sections_created)
3564     {
3565       Elf64_External_Dyn *dyncon, *dynconend;
3566
3567       if (sdyn == NULL || htab->elf.sgot == NULL)
3568         abort ();
3569
3570       dyncon = (Elf64_External_Dyn *) sdyn->contents;
3571       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
3572       for (; dyncon < dynconend; dyncon++)
3573         {
3574           Elf_Internal_Dyn dyn;
3575           asection *s;
3576
3577           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3578
3579           switch (dyn.d_tag)
3580             {
3581             default:
3582               continue;
3583
3584             case DT_PLTGOT:
3585               dyn.d_un.d_ptr = htab->elf.sgot->output_section->vma;
3586               break;
3587
3588             case DT_JMPREL:
3589               dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
3590               break;
3591
3592             case DT_PLTRELSZ:
3593               s = htab->elf.srelplt->output_section;
3594               dyn.d_un.d_val = s->size;
3595               break;
3596
3597             case DT_RELASZ:
3598               /* The procedure linkage table relocs (DT_JMPREL) should
3599                  not be included in the overall relocs (DT_RELA).
3600                  Therefore, we override the DT_RELASZ entry here to
3601                  make it not include the JMPREL relocs.  Since the
3602                  linker script arranges for .rela.plt to follow all
3603                  other relocation sections, we don't have to worry
3604                  about changing the DT_RELA entry.  */
3605               s = htab->elf.srelplt->output_section;
3606               dyn.d_un.d_val -= s->size;
3607               break;
3608             }
3609
3610           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3611         }
3612
3613       /* Fill in the special first entry in the procedure linkage table.  */
3614       if (htab->elf.splt && htab->elf.splt->size > 0)
3615         {
3616           /* fill in blueprint for plt 0 entry */
3617           memcpy (htab->elf.splt->contents, elf_s390x_first_plt_entry,
3618                   PLT_FIRST_ENTRY_SIZE);
3619           /* Fixup relative address to start of GOT */
3620           bfd_put_32 (output_bfd,
3621                       (htab->elf.sgotplt->output_section->vma +
3622                        htab->elf.sgotplt->output_offset
3623                        - htab->elf.splt->output_section->vma - 6)/2,
3624                       htab->elf.splt->contents + 8);
3625         }
3626       elf_section_data (htab->elf.splt->output_section)
3627         ->this_hdr.sh_entsize = PLT_ENTRY_SIZE;
3628     }
3629
3630   if (htab->elf.sgotplt)
3631     {
3632       /* Fill in the first three entries in the global offset table.  */
3633       if (htab->elf.sgotplt->size > 0)
3634         {
3635           bfd_put_64 (output_bfd,
3636                       (sdyn == NULL ? (bfd_vma) 0
3637                        : sdyn->output_section->vma + sdyn->output_offset),
3638                       htab->elf.sgotplt->contents);
3639           /* One entry for shared object struct ptr.  */
3640           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + 8);
3641           /* One entry for _dl_runtime_resolve.  */
3642           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + 12);
3643         }
3644
3645       elf_section_data (htab->elf.sgot->output_section)
3646         ->this_hdr.sh_entsize = 8;
3647     }
3648
3649   /* Finish dynamic symbol for local IFUNC symbols.  */
3650   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3651     {
3652       struct plt_entry *local_plt;
3653       Elf_Internal_Sym *isym;
3654       Elf_Internal_Shdr *symtab_hdr;
3655
3656       symtab_hdr = &elf_symtab_hdr (ibfd);
3657
3658       local_plt = elf_s390_local_plt (ibfd);
3659       if (local_plt != NULL)
3660         for (i = 0; i < symtab_hdr->sh_info; i++)
3661           {
3662             if (local_plt[i].plt.offset != (bfd_vma) -1)
3663               {
3664                 asection *sec = local_plt[i].sec;
3665                 isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, i);
3666                 if (isym == NULL)
3667                   return FALSE;
3668
3669                 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
3670                   elf_s390_finish_ifunc_symbol (output_bfd, info, NULL, htab,
3671                                                 local_plt[i].plt.offset,
3672                                                 isym->st_value
3673                                                 + sec->output_section->vma
3674                                                 + sec->output_offset);
3675
3676               }
3677           }
3678     }
3679
3680   return TRUE;
3681 }
3682
3683 /* Return address for Ith PLT stub in section PLT, for relocation REL
3684    or (bfd_vma) -1 if it should not be included.  */
3685
3686 static bfd_vma
3687 elf_s390_plt_sym_val (bfd_vma i, const asection *plt,
3688                       const arelent *rel ATTRIBUTE_UNUSED)
3689 {
3690   return plt->vma + PLT_FIRST_ENTRY_SIZE + i * PLT_ENTRY_SIZE;
3691 }
3692
3693 /* Why was the hash table entry size definition changed from
3694    ARCH_SIZE/8 to 4? This breaks the 64 bit dynamic linker and
3695    this is the only reason for the s390_elf64_size_info structure.  */
3696
3697 const struct elf_size_info s390_elf64_size_info =
3698 {
3699   sizeof (Elf64_External_Ehdr),
3700   sizeof (Elf64_External_Phdr),
3701   sizeof (Elf64_External_Shdr),
3702   sizeof (Elf64_External_Rel),
3703   sizeof (Elf64_External_Rela),
3704   sizeof (Elf64_External_Sym),
3705   sizeof (Elf64_External_Dyn),
3706   sizeof (Elf_External_Note),
3707   8,            /* hash-table entry size.  */
3708   1,            /* internal relocations per external relocations.  */
3709   64,           /* arch_size.  */
3710   3,            /* log_file_align.  */
3711   ELFCLASS64, EV_CURRENT,
3712   bfd_elf64_write_out_phdrs,
3713   bfd_elf64_write_shdrs_and_ehdr,
3714   bfd_elf64_checksum_contents,
3715   bfd_elf64_write_relocs,
3716   bfd_elf64_swap_symbol_in,
3717   bfd_elf64_swap_symbol_out,
3718   bfd_elf64_slurp_reloc_table,
3719   bfd_elf64_slurp_symbol_table,
3720   bfd_elf64_swap_dyn_in,
3721   bfd_elf64_swap_dyn_out,
3722   bfd_elf64_swap_reloc_in,
3723   bfd_elf64_swap_reloc_out,
3724   bfd_elf64_swap_reloca_in,
3725   bfd_elf64_swap_reloca_out
3726 };
3727
3728 #define TARGET_BIG_SYM  bfd_elf64_s390_vec
3729 #define TARGET_BIG_NAME "elf64-s390"
3730 #define ELF_ARCH        bfd_arch_s390
3731 #define ELF_TARGET_ID   S390_ELF_DATA
3732 #define ELF_MACHINE_CODE EM_S390
3733 #define ELF_MACHINE_ALT1 EM_S390_OLD
3734 #define ELF_MAXPAGESIZE 0x1000
3735
3736 #define elf_backend_size_info           s390_elf64_size_info
3737
3738 #define elf_backend_can_gc_sections     1
3739 #define elf_backend_can_refcount        1
3740 #define elf_backend_want_got_plt        1
3741 #define elf_backend_plt_readonly        1
3742 #define elf_backend_want_plt_sym        0
3743 #define elf_backend_got_header_size     24
3744 #define elf_backend_rela_normal         1
3745
3746 #define elf_info_to_howto               elf_s390_info_to_howto
3747
3748 #define bfd_elf64_bfd_is_local_label_name     elf_s390_is_local_label_name
3749 #define bfd_elf64_bfd_link_hash_table_create  elf_s390_link_hash_table_create
3750 #define bfd_elf64_bfd_reloc_type_lookup       elf_s390_reloc_type_lookup
3751 #define bfd_elf64_bfd_reloc_name_lookup elf_s390_reloc_name_lookup
3752
3753 #define elf_backend_adjust_dynamic_symbol     elf_s390_adjust_dynamic_symbol
3754 #define elf_backend_check_relocs              elf_s390_check_relocs
3755 #define elf_backend_copy_indirect_symbol      elf_s390_copy_indirect_symbol
3756 #define elf_backend_create_dynamic_sections   elf_s390_create_dynamic_sections
3757 #define elf_backend_finish_dynamic_sections   elf_s390_finish_dynamic_sections
3758 #define elf_backend_finish_dynamic_symbol     elf_s390_finish_dynamic_symbol
3759 #define elf_backend_gc_mark_hook              elf_s390_gc_mark_hook
3760 #define elf_backend_gc_sweep_hook             elf_s390_gc_sweep_hook
3761 #define elf_backend_reloc_type_class          elf_s390_reloc_type_class
3762 #define elf_backend_relocate_section          elf_s390_relocate_section
3763 #define elf_backend_size_dynamic_sections     elf_s390_size_dynamic_sections
3764 #define elf_backend_init_index_section        _bfd_elf_init_1_index_section
3765 #define elf_backend_reloc_type_class          elf_s390_reloc_type_class
3766 #define elf_backend_plt_sym_val               elf_s390_plt_sym_val
3767 #define elf_backend_add_symbol_hook           elf_s390_add_symbol_hook
3768
3769 #define bfd_elf64_mkobject              elf_s390_mkobject
3770 #define elf_backend_object_p            elf_s390_object_p
3771
3772 /* Enable ELF64 archive functions.  */
3773 #define bfd_elf64_archive_functions
3774 extern bfd_boolean bfd_elf64_archive_slurp_armap (bfd *);
3775 extern bfd_boolean bfd_elf64_archive_write_armap (bfd *, unsigned int, struct orl *, unsigned int, int);
3776
3777 #define bfd_elf64_archive_slurp_extended_name_table     _bfd_archive_coff_slurp_extended_name_table
3778 #define bfd_elf64_archive_construct_extended_name_table _bfd_archive_coff_construct_extended_name_table
3779 #define bfd_elf64_archive_truncate_arname               _bfd_archive_coff_truncate_arname
3780 #define bfd_elf64_archive_read_ar_hdr                   _bfd_archive_coff_read_ar_hdr
3781 #define bfd_elf64_archive_write_ar_hdr                  _bfd_archive_coff_write_ar_hdr
3782 #define bfd_elf64_archive_openr_next_archived_file      _bfd_archive_coff_openr_next_archived_file
3783 #define bfd_elf64_archive_get_elt_at_index              _bfd_archive_coff_get_elt_at_index
3784 #define bfd_elf64_archive_generic_stat_arch_elt         _bfd_archive_coff_generic_stat_arch_elt
3785 #define bfd_elf64_archive_update_armap_timestamp        _bfd_archive_coff_update_armap_timestamp
3786
3787 #include "elf64-target.h"