bfd/elf32-s390.c

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