bfd/elf64-s390.c

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