bfd/elf32-s390.c

   1 /* IBM S/390-specific support for 32-bit ELF
   2    Copyright (C) 2000-2018 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 (_("%pB: 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 (_("%pB: 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                     (_("%pB: `%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 /* Find dynamic relocs for H that apply to read-only sections.  */
1423
1424 static asection *
1425 readonly_dynrelocs (struct elf_link_hash_entry *h)
1426 {
1427   struct elf_dyn_relocs *p;
1428
1429   for (p = elf_s390_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
1430     {
1431       asection *s = p->sec->output_section;
1432
1433       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1434         return p->sec;
1435     }
1436   return NULL;
1437 }
1438
1439 /* Adjust a symbol defined by a dynamic object and referenced by a
1440    regular object.  The current definition is in some section of the
1441    dynamic object, but we're not including those sections.  We have to
1442    change the definition to something the rest of the link can
1443    understand.  */
1444
1445 static bfd_boolean
1446 elf_s390_adjust_dynamic_symbol (struct bfd_link_info *info,
1447                                 struct elf_link_hash_entry *h)
1448 {
1449   struct elf_s390_link_hash_table *htab;
1450   asection *s, *srel;
1451
1452   /* STT_GNU_IFUNC symbol must go through PLT. */
1453   if (s390_is_ifunc_symbol_p (h))
1454     {
1455       /* All local STT_GNU_IFUNC references must be treated as local
1456          calls via local PLT.  */
1457       if (h->ref_regular && SYMBOL_CALLS_LOCAL (info, h))
1458         {
1459           bfd_size_type pc_count = 0, count = 0;
1460           struct elf_dyn_relocs **pp;
1461           struct elf_s390_link_hash_entry *eh;
1462           struct elf_dyn_relocs *p;
1463
1464           eh = (struct elf_s390_link_hash_entry *) h;
1465           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1466             {
1467               pc_count += p->pc_count;
1468               p->count -= p->pc_count;
1469               p->pc_count = 0;
1470               count += p->count;
1471               if (p->count == 0)
1472                 *pp = p->next;
1473               else
1474                 pp = &p->next;
1475             }
1476
1477           if (pc_count || count)
1478             {
1479               h->needs_plt = 1;
1480               h->non_got_ref = 1;
1481               if (h->plt.refcount <= 0)
1482                 h->plt.refcount = 1;
1483               else
1484                 h->plt.refcount += 1;
1485             }
1486         }
1487
1488       if (h->plt.refcount <= 0)
1489         {
1490           h->plt.offset = (bfd_vma) -1;
1491           h->needs_plt = 0;
1492         }
1493       return TRUE;
1494     }
1495
1496   /* If this is a function, put it in the procedure linkage table.  We
1497      will fill in the contents of the procedure linkage table later
1498      (although we could actually do it here).  */
1499   if (h->type == STT_FUNC
1500       || h->needs_plt)
1501     {
1502       if (h->plt.refcount <= 0
1503           || SYMBOL_CALLS_LOCAL (info, h)
1504           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1505               && h->root.type != bfd_link_hash_undefweak))
1506         {
1507           /* This case can occur if we saw a PLT32 reloc in an input
1508              file, but the symbol was never referred to by a dynamic
1509              object, or if all references were garbage collected.  In
1510              such a case, we don't actually need to build a procedure
1511              linkage table, and we can just do a PC32 reloc instead.  */
1512           h->plt.offset = (bfd_vma) -1;
1513           h->needs_plt = 0;
1514           elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1515         }
1516
1517       return TRUE;
1518     }
1519   else
1520     /* It's possible that we incorrectly decided a .plt reloc was
1521        needed for an R_390_PC32 reloc to a non-function sym in
1522        check_relocs.  We can't decide accurately between function and
1523        non-function syms in check-relocs;  Objects loaded later in
1524        the link may change h->type.  So fix it now.  */
1525     h->plt.offset = (bfd_vma) -1;
1526
1527   /* If this is a weak symbol, and there is a real definition, the
1528      processor independent code will have arranged for us to see the
1529      real definition first, and we can just use the same value.  */
1530   if (h->is_weakalias)
1531     {
1532       struct elf_link_hash_entry *def = weakdef (h);
1533       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
1534       h->root.u.def.section = def->root.u.def.section;
1535       h->root.u.def.value = def->root.u.def.value;
1536       if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1537         h->non_got_ref = def->non_got_ref;
1538       return TRUE;
1539     }
1540
1541   /* This is a reference to a symbol defined by a dynamic object which
1542      is not a function.  */
1543
1544   /* If we are creating a shared library, we must presume that the
1545      only references to the symbol are via the global offset table.
1546      For such cases we need not do anything here; the relocations will
1547      be handled correctly by relocate_section.  */
1548   if (bfd_link_pic (info))
1549     return TRUE;
1550
1551   /* If there are no references to this symbol that do not use the
1552      GOT, we don't need to generate a copy reloc.  */
1553   if (!h->non_got_ref)
1554     return TRUE;
1555
1556   /* If -z nocopyreloc was given, we won't generate them either.  */
1557   if (info->nocopyreloc)
1558     {
1559       h->non_got_ref = 0;
1560       return TRUE;
1561     }
1562
1563   /* If we don't find any dynamic relocs in read-only sections, then
1564      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
1565   if (ELIMINATE_COPY_RELOCS && !readonly_dynrelocs (h))
1566     {
1567       h->non_got_ref = 0;
1568       return TRUE;
1569     }
1570
1571   /* We must allocate the symbol in our .dynbss section, which will
1572      become part of the .bss section of the executable.  There will be
1573      an entry for this symbol in the .dynsym section.  The dynamic
1574      object will contain position independent code, so all references
1575      from the dynamic object to this symbol will go through the global
1576      offset table.  The dynamic linker will use the .dynsym entry to
1577      determine the address it must put in the global offset table, so
1578      both the dynamic object and the regular object will refer to the
1579      same memory location for the variable.  */
1580
1581   htab = elf_s390_hash_table (info);
1582
1583   /* We must generate a R_390_COPY reloc to tell the dynamic linker to
1584      copy the initial value out of the dynamic object and into the
1585      runtime process image.  */
1586   if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
1587     {
1588       s = htab->elf.sdynrelro;
1589       srel = htab->elf.sreldynrelro;
1590     }
1591   else
1592     {
1593       s = htab->elf.sdynbss;
1594       srel = htab->elf.srelbss;
1595     }
1596   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1597     {
1598       srel->size += sizeof (Elf32_External_Rela);
1599       h->needs_copy = 1;
1600     }
1601
1602   return _bfd_elf_adjust_dynamic_copy (info, h, s);
1603 }
1604
1605 /* Allocate space in .plt, .got and associated reloc sections for
1606    dynamic relocs.  */
1607
1608 static bfd_boolean
1609 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1610 {
1611   struct bfd_link_info *info;
1612   struct elf_s390_link_hash_table *htab;
1613   struct elf_s390_link_hash_entry *eh = (struct elf_s390_link_hash_entry *)h;
1614   struct elf_dyn_relocs *p;
1615
1616   if (h->root.type == bfd_link_hash_indirect)
1617     return TRUE;
1618
1619   info = (struct bfd_link_info *) inf;
1620   htab = elf_s390_hash_table (info);
1621
1622   /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
1623      here if it is defined and referenced in a non-shared object.  */
1624   if (s390_is_ifunc_symbol_p (h) && h->def_regular)
1625     return s390_elf_allocate_ifunc_dyn_relocs (info, h);
1626   else if (htab->elf.dynamic_sections_created
1627            && h->plt.refcount > 0)
1628     {
1629       /* Make sure this symbol is output as a dynamic symbol.
1630          Undefined weak syms won't yet be marked as dynamic.  */
1631       if (h->dynindx == -1
1632           && !h->forced_local)
1633         {
1634           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1635             return FALSE;
1636         }
1637
1638       if (bfd_link_pic (info)
1639           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1640         {
1641           asection *s = htab->elf.splt;
1642
1643           /* If this is the first .plt entry, make room for the special
1644              first entry.  */
1645           if (s->size == 0)
1646             s->size += PLT_FIRST_ENTRY_SIZE;
1647
1648           h->plt.offset = s->size;
1649
1650           /* If this symbol is not defined in a regular file, and we are
1651              not generating a shared library, then set the symbol to this
1652              location in the .plt.  This is required to make function
1653              pointers compare as equal between the normal executable and
1654              the shared library.  */
1655           if (! bfd_link_pic (info)
1656               && !h->def_regular)
1657             {
1658               h->root.u.def.section = s;
1659               h->root.u.def.value = h->plt.offset;
1660             }
1661
1662           /* Make room for this entry.  */
1663           s->size += PLT_ENTRY_SIZE;
1664
1665           /* We also need to make an entry in the .got.plt section, which
1666              will be placed in the .got section by the linker script.  */
1667           htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
1668
1669           /* We also need to make an entry in the .rela.plt section.  */
1670           htab->elf.srelplt->size += sizeof (Elf32_External_Rela);
1671         }
1672       else
1673         {
1674           h->plt.offset = (bfd_vma) -1;
1675           h->needs_plt = 0;
1676           elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1677         }
1678     }
1679   else
1680     {
1681       h->plt.offset = (bfd_vma) -1;
1682       h->needs_plt = 0;
1683       elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1684     }
1685
1686   /* If R_390_TLS_{IE32,GOTIE32,GOTIE12,IEENT} symbol is now local to
1687      the binary, we can optimize a bit. IE32 and GOTIE32 get converted
1688      to R_390_TLS_LE32 requiring no TLS entry. For GOTIE12 and IEENT
1689      we can save the dynamic TLS relocation.  */
1690   if (h->got.refcount > 0
1691       && !bfd_link_pic (info)
1692       && h->dynindx == -1
1693       && elf_s390_hash_entry(h)->tls_type >= GOT_TLS_IE)
1694     {
1695       if (elf_s390_hash_entry(h)->tls_type == GOT_TLS_IE_NLT)
1696         /* For the GOTIE access without a literal pool entry the offset has
1697            to be stored somewhere. The immediate value in the instruction
1698            is not bit enough so the value is stored in the got.  */
1699         {
1700           h->got.offset = htab->elf.sgot->size;
1701           htab->elf.sgot->size += GOT_ENTRY_SIZE;
1702         }
1703       else
1704         h->got.offset = (bfd_vma) -1;
1705     }
1706   else if (h->got.refcount > 0)
1707     {
1708       asection *s;
1709       bfd_boolean dyn;
1710       int tls_type = elf_s390_hash_entry(h)->tls_type;
1711
1712       /* Make sure this symbol is output as a dynamic symbol.
1713          Undefined weak syms won't yet be marked as dynamic.  */
1714       if (h->dynindx == -1
1715           && !h->forced_local)
1716         {
1717           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1718             return FALSE;
1719         }
1720
1721       s = htab->elf.sgot;
1722       h->got.offset = s->size;
1723       s->size += GOT_ENTRY_SIZE;
1724       /* R_390_TLS_GD32 needs 2 consecutive GOT slots.  */
1725       if (tls_type == GOT_TLS_GD)
1726         s->size += GOT_ENTRY_SIZE;
1727       dyn = htab->elf.dynamic_sections_created;
1728       /* R_390_TLS_IE32 needs one dynamic relocation,
1729          R_390_TLS_GD32 needs one if local symbol and two if global.  */
1730       if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1731           || tls_type >= GOT_TLS_IE)
1732         htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
1733       else if (tls_type == GOT_TLS_GD)
1734         htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rela);
1735       else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1736                 || h->root.type != bfd_link_hash_undefweak)
1737                && (bfd_link_pic (info)
1738                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1739         htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
1740     }
1741   else
1742     h->got.offset = (bfd_vma) -1;
1743
1744   if (eh->dyn_relocs == NULL)
1745     return TRUE;
1746
1747   /* In the shared -Bsymbolic case, discard space allocated for
1748      dynamic pc-relative relocs against symbols which turn out to be
1749      defined in regular objects.  For the normal shared case, discard
1750      space for pc-relative relocs that have become local due to symbol
1751      visibility changes.  */
1752
1753   if (bfd_link_pic (info))
1754     {
1755       if (SYMBOL_CALLS_LOCAL (info, h))
1756         {
1757           struct elf_dyn_relocs **pp;
1758
1759           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1760             {
1761               p->count -= p->pc_count;
1762               p->pc_count = 0;
1763               if (p->count == 0)
1764                 *pp = p->next;
1765               else
1766                 pp = &p->next;
1767             }
1768         }
1769
1770       /* Also discard relocs on undefined weak syms with non-default
1771          visibility.  */
1772       if (eh->dyn_relocs != NULL
1773           && h->root.type == bfd_link_hash_undefweak)
1774         {
1775           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1776               || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
1777             eh->dyn_relocs = NULL;
1778
1779           /* Make sure undefined weak symbols are output as a dynamic
1780              symbol in PIEs.  */
1781           else if (h->dynindx == -1
1782                    && !h->forced_local)
1783             {
1784               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1785                 return FALSE;
1786             }
1787         }
1788     }
1789   else if (ELIMINATE_COPY_RELOCS)
1790     {
1791       /* For the non-shared case, discard space for relocs against
1792          symbols which turn out to need copy relocs or are not
1793          dynamic.  */
1794
1795       if (!h->non_got_ref
1796           && ((h->def_dynamic
1797                && !h->def_regular)
1798               || (htab->elf.dynamic_sections_created
1799                   && (h->root.type == bfd_link_hash_undefweak
1800                       || h->root.type == bfd_link_hash_undefined))))
1801         {
1802           /* Make sure this symbol is output as a dynamic symbol.
1803              Undefined weak syms won't yet be marked as dynamic.  */
1804           if (h->dynindx == -1
1805               && !h->forced_local)
1806             {
1807               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1808                 return FALSE;
1809             }
1810
1811           /* If that succeeded, we know we'll be keeping all the
1812              relocs.  */
1813           if (h->dynindx != -1)
1814             goto keep;
1815         }
1816
1817       eh->dyn_relocs = NULL;
1818
1819     keep: ;
1820     }
1821
1822   /* Finally, allocate space.  */
1823   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1824     {
1825       asection *sreloc = elf_section_data (p->sec)->sreloc;
1826
1827       sreloc->size += p->count * sizeof (Elf32_External_Rela);
1828     }
1829
1830   return TRUE;
1831 }
1832
1833 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
1834    read-only sections.  */
1835
1836 static bfd_boolean
1837 maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
1838 {
1839   asection *sec;
1840
1841   if (h->root.type == bfd_link_hash_indirect)
1842     return TRUE;
1843
1844   sec = readonly_dynrelocs (h);
1845   if (sec != NULL)
1846     {
1847       struct bfd_link_info *info = (struct bfd_link_info *) info_p;
1848
1849       info->flags |= DF_TEXTREL;
1850       info->callbacks->minfo
1851         (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
1852          sec->owner, h->root.root.string, sec);
1853
1854       /* Not an error, just cut short the traversal.  */
1855       return FALSE;
1856     }
1857   return TRUE;
1858 }
1859
1860 /* Set the sizes of the dynamic sections.  */
1861
1862 static bfd_boolean
1863 elf_s390_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1864                                 struct bfd_link_info *info)
1865 {
1866   struct elf_s390_link_hash_table *htab;
1867   bfd *dynobj;
1868   asection *s;
1869   bfd_boolean relocs;
1870   bfd *ibfd;
1871
1872   htab = elf_s390_hash_table (info);
1873   dynobj = htab->elf.dynobj;
1874   if (dynobj == NULL)
1875     abort ();
1876
1877   if (htab->elf.dynamic_sections_created)
1878     {
1879       /* Set the contents of the .interp section to the interpreter.  */
1880       if (bfd_link_executable (info) && !info->nointerp)
1881         {
1882           s = bfd_get_linker_section (dynobj, ".interp");
1883           if (s == NULL)
1884             abort ();
1885           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1886           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1887         }
1888     }
1889
1890   /* Set up .got offsets for local syms, and space for local dynamic
1891      relocs.  */
1892   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
1893     {
1894       bfd_signed_vma *local_got;
1895       bfd_signed_vma *end_local_got;
1896       char *local_tls_type;
1897       bfd_size_type locsymcount;
1898       Elf_Internal_Shdr *symtab_hdr;
1899       asection *srela;
1900       struct plt_entry *local_plt;
1901       unsigned int i;
1902
1903       if (! is_s390_elf (ibfd))
1904         continue;
1905
1906       for (s = ibfd->sections; s != NULL; s = s->next)
1907         {
1908           struct elf_dyn_relocs *p;
1909
1910           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
1911             {
1912               if (!bfd_is_abs_section (p->sec)
1913                   && bfd_is_abs_section (p->sec->output_section))
1914                 {
1915                   /* Input section has been discarded, either because
1916                      it is a copy of a linkonce section or due to
1917                      linker script /DISCARD/, so we'll be discarding
1918                      the relocs too.  */
1919                 }
1920               else if (p->count != 0)
1921                 {
1922                   srela = elf_section_data (p->sec)->sreloc;
1923                   srela->size += p->count * sizeof (Elf32_External_Rela);
1924                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1925                     info->flags |= DF_TEXTREL;
1926                 }
1927             }
1928         }
1929
1930       local_got = elf_local_got_refcounts (ibfd);
1931       if (!local_got)
1932         continue;
1933
1934       symtab_hdr = &elf_symtab_hdr (ibfd);
1935       locsymcount = symtab_hdr->sh_info;
1936       end_local_got = local_got + locsymcount;
1937       local_tls_type = elf_s390_local_got_tls_type (ibfd);
1938       s = htab->elf.sgot;
1939       srela = htab->elf.srelgot;
1940       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1941         {
1942           if (*local_got > 0)
1943             {
1944               *local_got = s->size;
1945               s->size += GOT_ENTRY_SIZE;
1946               if (*local_tls_type == GOT_TLS_GD)
1947                 s->size += GOT_ENTRY_SIZE;
1948               if (bfd_link_pic (info))
1949                 srela->size += sizeof (Elf32_External_Rela);
1950             }
1951           else
1952             *local_got = (bfd_vma) -1;
1953         }
1954       local_plt = elf_s390_local_plt (ibfd);
1955       for (i = 0; i < symtab_hdr->sh_info; i++)
1956         {
1957           if (local_plt[i].plt.refcount > 0)
1958             {
1959               local_plt[i].plt.offset = htab->elf.iplt->size;
1960               htab->elf.iplt->size += PLT_ENTRY_SIZE;
1961               htab->elf.igotplt->size += GOT_ENTRY_SIZE;
1962               htab->elf.irelplt->size += RELA_ENTRY_SIZE;
1963             }
1964           else
1965             local_plt[i].plt.offset = (bfd_vma) -1;
1966         }
1967     }
1968
1969   if (htab->tls_ldm_got.refcount > 0)
1970     {
1971       /* Allocate 2 got entries and 1 dynamic reloc for R_390_TLS_LDM32
1972          relocs.  */
1973       htab->tls_ldm_got.offset = htab->elf.sgot->size;
1974       htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
1975       htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
1976     }
1977   else
1978     htab->tls_ldm_got.offset = -1;
1979
1980   /* Allocate global sym .plt and .got entries, and space for global
1981      sym dynamic relocs.  */
1982   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
1983
1984   /* We now have determined the sizes of the various dynamic sections.
1985      Allocate memory for them.  */
1986   relocs = FALSE;
1987   for (s = dynobj->sections; s != NULL; s = s->next)
1988     {
1989       if ((s->flags & SEC_LINKER_CREATED) == 0)
1990         continue;
1991
1992       if (s == htab->elf.splt
1993           || s == htab->elf.sgot
1994           || s == htab->elf.sgotplt
1995           || s == htab->elf.sdynbss
1996           || s == htab->elf.sdynrelro
1997           || s == htab->elf.iplt
1998           || s == htab->elf.igotplt
1999           || s == htab->irelifunc)
2000         {
2001           /* Strip this section if we don't need it; see the
2002              comment below.  */
2003         }
2004       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2005         {
2006           if (s->size != 0)
2007             relocs = TRUE;
2008
2009           /* We use the reloc_count field as a counter if we need
2010              to copy relocs into the output file.  */
2011           s->reloc_count = 0;
2012         }
2013       else
2014         {
2015           /* It's not one of our sections, so don't allocate space.  */
2016           continue;
2017         }
2018
2019       if (s->size == 0)
2020         {
2021           /* If we don't need this section, strip it from the
2022              output file.  This is to handle .rela.bss and
2023              .rela.plt.  We must create it in
2024              create_dynamic_sections, because it must be created
2025              before the linker maps input sections to output
2026              sections.  The linker does that before
2027              adjust_dynamic_symbol is called, and it is that
2028              function which decides whether anything needs to go
2029              into these sections.  */
2030
2031           s->flags |= SEC_EXCLUDE;
2032           continue;
2033         }
2034
2035       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2036         continue;
2037
2038       /* Allocate memory for the section contents.  We use bfd_zalloc
2039          here in case unused entries are not reclaimed before the
2040          section's contents are written out.  This should not happen,
2041          but this way if it does, we get a R_390_NONE reloc instead
2042          of garbage.  */
2043       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2044       if (s->contents == NULL)
2045         return FALSE;
2046     }
2047
2048   if (htab->elf.dynamic_sections_created)
2049     {
2050       /* Add some entries to the .dynamic section.  We fill in the
2051          values later, in elf_s390_finish_dynamic_sections, but we
2052          must add the entries now so that we get the correct size for
2053          the .dynamic section.  The DT_DEBUG entry is filled in by the
2054          dynamic linker and used by the debugger.  */
2055 #define add_dynamic_entry(TAG, VAL) \
2056   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2057
2058       if (bfd_link_executable (info))
2059         {
2060           if (!add_dynamic_entry (DT_DEBUG, 0))
2061             return FALSE;
2062         }
2063
2064       if (htab->elf.splt->size != 0)
2065         {
2066           if (!add_dynamic_entry (DT_PLTGOT, 0)
2067               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2068               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2069               || !add_dynamic_entry (DT_JMPREL, 0))
2070             return FALSE;
2071         }
2072
2073       if (relocs)
2074         {
2075           if (!add_dynamic_entry (DT_RELA, 0)
2076               || !add_dynamic_entry (DT_RELASZ, 0)
2077               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
2078             return FALSE;
2079
2080           /* If any dynamic relocs apply to a read-only section,
2081              then we need a DT_TEXTREL entry.  */
2082           if ((info->flags & DF_TEXTREL) == 0)
2083             elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
2084
2085           if ((info->flags & DF_TEXTREL) != 0)
2086             {
2087               if (!add_dynamic_entry (DT_TEXTREL, 0))
2088                 return FALSE;
2089             }
2090         }
2091     }
2092 #undef add_dynamic_entry
2093
2094   return TRUE;
2095 }
2096
2097 /* Return the base VMA address which should be subtracted from real addresses
2098    when resolving @dtpoff relocation.
2099    This is PT_TLS segment p_vaddr.  */
2100
2101 static bfd_vma
2102 dtpoff_base (struct bfd_link_info *info)
2103 {
2104   /* If tls_sec is NULL, we should have signalled an error already.  */
2105   if (elf_hash_table (info)->tls_sec == NULL)
2106     return 0;
2107   return elf_hash_table (info)->tls_sec->vma;
2108 }
2109
2110 /* Return the relocation value for @tpoff relocation
2111    if STT_TLS virtual address is ADDRESS.  */
2112
2113 static bfd_vma
2114 tpoff (struct bfd_link_info *info, bfd_vma address)
2115 {
2116   struct elf_link_hash_table *htab = elf_hash_table (info);
2117
2118   /* If tls_sec is NULL, we should have signalled an error already.  */
2119   if (htab->tls_sec == NULL)
2120     return 0;
2121   return htab->tls_size + htab->tls_sec->vma - address;
2122 }
2123
2124 /* Complain if TLS instruction relocation is against an invalid
2125    instruction.  */
2126
2127 static void
2128 invalid_tls_insn (bfd *input_bfd,
2129                   asection *input_section,
2130                   Elf_Internal_Rela *rel)
2131 {
2132   reloc_howto_type *howto;
2133
2134   howto = elf_howto_table + ELF32_R_TYPE (rel->r_info);
2135   _bfd_error_handler
2136     /* xgettext:c-format */
2137     (_("%pB(%pA+%#" PRIx64 "): invalid instruction for TLS relocation %s"),
2138      input_bfd,
2139      input_section,
2140      (uint64_t) rel->r_offset,
2141      howto->name);
2142   bfd_set_error (bfd_error_bad_value);
2143 }
2144
2145 /* Relocate a 390 ELF section.  */
2146
2147 static bfd_boolean
2148 elf_s390_relocate_section (bfd *output_bfd,
2149                            struct bfd_link_info *info,
2150                            bfd *input_bfd,
2151                            asection *input_section,
2152                            bfd_byte *contents,
2153                            Elf_Internal_Rela *relocs,
2154                            Elf_Internal_Sym *local_syms,
2155                            asection **local_sections)
2156 {
2157   struct elf_s390_link_hash_table *htab;
2158   Elf_Internal_Shdr *symtab_hdr;
2159   struct elf_link_hash_entry **sym_hashes;
2160   bfd_vma *local_got_offsets;
2161   Elf_Internal_Rela *rel;
2162   Elf_Internal_Rela *relend;
2163
2164   BFD_ASSERT (is_s390_elf (input_bfd));
2165
2166   htab = elf_s390_hash_table (info);
2167   symtab_hdr = &elf_symtab_hdr (input_bfd);
2168   sym_hashes = elf_sym_hashes (input_bfd);
2169   local_got_offsets = elf_local_got_offsets (input_bfd);
2170
2171   rel = relocs;
2172   relend = relocs + input_section->reloc_count;
2173   for (; rel < relend; rel++)
2174     {
2175       unsigned int r_type;
2176       reloc_howto_type *howto;
2177       unsigned long r_symndx;
2178       struct elf_link_hash_entry *h;
2179       Elf_Internal_Sym *sym;
2180       asection *sec;
2181       bfd_vma off;
2182       bfd_vma relocation;
2183       bfd_boolean unresolved_reloc;
2184       bfd_reloc_status_type r;
2185       int tls_type;
2186       asection *base_got = htab->elf.sgot;
2187       bfd_boolean resolved_to_zero;
2188
2189       r_type = ELF32_R_TYPE (rel->r_info);
2190       if (r_type == (int) R_390_GNU_VTINHERIT
2191           || r_type == (int) R_390_GNU_VTENTRY)
2192         continue;
2193       if (r_type >= (int) R_390_max)
2194         {
2195           bfd_set_error (bfd_error_bad_value);
2196           return FALSE;
2197         }
2198
2199       howto = elf_howto_table + r_type;
2200       r_symndx = ELF32_R_SYM (rel->r_info);
2201
2202       h = NULL;
2203       sym = NULL;
2204       sec = NULL;
2205       unresolved_reloc = FALSE;
2206       if (r_symndx < symtab_hdr->sh_info)
2207         {
2208           sym = local_syms + r_symndx;
2209           sec = local_sections[r_symndx];
2210           if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
2211             {
2212               struct plt_entry *local_plt = elf_s390_local_plt (input_bfd);
2213               if (local_plt == NULL)
2214                 return FALSE;
2215
2216               /* Address of the PLT slot.  */
2217               relocation = (htab->elf.iplt->output_section->vma
2218                             + htab->elf.iplt->output_offset
2219                             + local_plt[r_symndx].plt.offset);
2220
2221               switch (r_type)
2222                 {
2223                 case R_390_PLTOFF16:
2224                 case R_390_PLTOFF32:
2225                   relocation -= htab->elf.sgot->output_section->vma;
2226                   break;
2227                 case R_390_GOTPLT12:
2228                 case R_390_GOTPLT16:
2229                 case R_390_GOTPLT20:
2230                 case R_390_GOTPLT32:
2231                 case R_390_GOTPLTENT:
2232                 case R_390_GOT12:
2233                 case R_390_GOT16:
2234                 case R_390_GOT20:
2235                 case R_390_GOT32:
2236                 case R_390_GOTENT:
2237                   {
2238                     /* Write the PLT slot address into the GOT slot.  */
2239                     bfd_put_32 (output_bfd, relocation,
2240                                 htab->elf.sgot->contents +
2241                                 local_got_offsets[r_symndx]);
2242                     relocation = (local_got_offsets[r_symndx] +
2243                                   htab->elf.sgot->output_offset);
2244
2245                     if (r_type == R_390_GOTENT || r_type == R_390_GOTPLTENT)
2246                       relocation += htab->elf.sgot->output_section->vma;
2247                     break;
2248                   }
2249                 default:
2250                   break;
2251                 }
2252               /* The output section is needed later in
2253                  finish_dynamic_section when creating the dynamic
2254                  relocation.  */
2255               local_plt[r_symndx].sec = sec;
2256               goto do_relocation;
2257             }
2258           else
2259             relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2260         }
2261       else
2262         {
2263           bfd_boolean warned ATTRIBUTE_UNUSED;
2264           bfd_boolean ignored ATTRIBUTE_UNUSED;
2265
2266           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2267                                    r_symndx, symtab_hdr, sym_hashes,
2268                                    h, sec, relocation,
2269                                    unresolved_reloc, warned, ignored);
2270         }
2271
2272       if (sec != NULL && discarded_section (sec))
2273         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2274                                          rel, 1, relend, howto, 0, contents);
2275
2276       if (bfd_link_relocatable (info))
2277         continue;
2278
2279       resolved_to_zero = (h != NULL
2280                           && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
2281
2282       switch (r_type)
2283         {
2284         case R_390_GOTPLT12:
2285         case R_390_GOTPLT16:
2286         case R_390_GOTPLT20:
2287         case R_390_GOTPLT32:
2288         case R_390_GOTPLTENT:
2289           /* There are three cases for a GOTPLT relocation. 1) The
2290              relocation is against the jump slot entry of a plt that
2291              will get emitted to the output file. 2) The relocation
2292              is against the jump slot of a plt entry that has been
2293              removed. elf_s390_adjust_gotplt has created a GOT entry
2294              as replacement. 3) The relocation is against a local symbol.
2295              Cases 2) and 3) are the same as the GOT relocation code
2296              so we just have to test for case 1 and fall through for
2297              the other two.  */
2298           if (h != NULL && h->plt.offset != (bfd_vma) -1)
2299             {
2300               bfd_vma plt_index;
2301
2302               if (s390_is_ifunc_symbol_p (h))
2303                 {
2304                   plt_index = h->plt.offset / PLT_ENTRY_SIZE;
2305                   relocation = (plt_index * GOT_ENTRY_SIZE +
2306                                 htab->elf.igotplt->output_offset);
2307                   if (r_type == R_390_GOTPLTENT)
2308                     relocation += htab->elf.igotplt->output_section->vma;
2309                 }
2310               else
2311                 {
2312                   /* Calc. index no.
2313                      Current offset - size first entry / entry size.  */
2314                   plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) /
2315                     PLT_ENTRY_SIZE;
2316
2317                   /* Offset in GOT is PLT index plus GOT headers(3)
2318                      times 4, addr & GOT addr.  */
2319                   relocation = (plt_index + 3) * GOT_ENTRY_SIZE;
2320                   if (r_type == R_390_GOTPLTENT)
2321                     relocation += htab->elf.sgot->output_section->vma;
2322                 }
2323               unresolved_reloc = FALSE;
2324
2325             }
2326           /* Fall through.  */
2327
2328         case R_390_GOT12:
2329         case R_390_GOT16:
2330         case R_390_GOT20:
2331         case R_390_GOT32:
2332         case R_390_GOTENT:
2333           /* Relocation is to the entry for this symbol in the global
2334              offset table.  */
2335           if (base_got == NULL)
2336             abort ();
2337
2338           if (h != NULL)
2339             {
2340               bfd_boolean dyn;
2341
2342               off = h->got.offset;
2343               dyn = htab->elf.dynamic_sections_created;
2344
2345               if (s390_is_ifunc_symbol_p (h))
2346                 {
2347                   BFD_ASSERT (h->plt.offset != (bfd_vma) -1);
2348                   if (off == (bfd_vma)-1)
2349                     {
2350                       /* No explicit GOT usage so redirect to the
2351                          got.iplt slot.  */
2352                       base_got = htab->elf.igotplt;
2353                       off = h->plt.offset / PLT_ENTRY_SIZE * GOT_ENTRY_SIZE;
2354                     }
2355                   else
2356                     {
2357                       /* Explicit GOT slots must contain the address
2358                          of the PLT slot. This will be handled in
2359                          finish_dynamic_symbol.  */
2360                     }
2361                 }
2362               else if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
2363                                                           bfd_link_pic (info),
2364                                                           h)
2365                        || (bfd_link_pic (info)
2366                            && SYMBOL_REFERENCES_LOCAL (info, h))
2367                        || (ELF_ST_VISIBILITY (h->other)
2368                            && h->root.type == bfd_link_hash_undefweak))
2369
2370                 {
2371                   /* This is actually a static link, or it is a
2372                      -Bsymbolic link and the symbol is defined
2373                      locally, or the symbol was forced to be local
2374                      because of a version file.  We must initialize
2375                      this entry in the global offset table.  Since the
2376                      offset must always be a multiple of 2, we use the
2377                      least significant bit to record whether we have
2378                      initialized it already.
2379
2380                      When doing a dynamic link, we create a .rel.got
2381                      relocation entry to initialize the value.  This
2382                      is done in the finish_dynamic_symbol routine.  */
2383                   if ((off & 1) != 0)
2384                     off &= ~1;
2385                   else
2386                     {
2387                       bfd_put_32 (output_bfd, relocation,
2388                                   base_got->contents + off);
2389                       h->got.offset |= 1;
2390                     }
2391
2392                   if ((h->def_regular
2393                        && bfd_link_pic (info)
2394                        && SYMBOL_REFERENCES_LOCAL (info, h))
2395                       /* lrl rx,sym@GOTENT -> larl rx, sym */
2396                       && ((r_type == R_390_GOTENT
2397                            && (bfd_get_16 (input_bfd,
2398                                            contents + rel->r_offset - 2)
2399                                & 0xff0f) == 0xc40d)
2400                           /* ly rx, sym@GOT(r12) -> larl rx, sym */
2401                           || (r_type == R_390_GOT20
2402                               && (bfd_get_32 (input_bfd,
2403                                               contents + rel->r_offset - 2)
2404                                   & 0xff00f000) == 0xe300c000
2405                               && bfd_get_8 (input_bfd,
2406                                             contents + rel->r_offset + 3) == 0x58)))
2407                     {
2408                       unsigned short new_insn =
2409                         (0xc000 | (bfd_get_8 (input_bfd,
2410                                               contents + rel->r_offset - 1) & 0xf0));
2411                       bfd_put_16 (output_bfd, new_insn,
2412                                   contents + rel->r_offset - 2);
2413                       r_type = R_390_PC32DBL;
2414                       rel->r_addend = 2;
2415                       howto = elf_howto_table + r_type;
2416                       relocation = h->root.u.def.value
2417                         + h->root.u.def.section->output_section->vma
2418                         + h->root.u.def.section->output_offset;
2419                       goto do_relocation;
2420                     }
2421                 }
2422               else
2423                 unresolved_reloc = FALSE;
2424             }
2425           else
2426             {
2427               if (local_got_offsets == NULL)
2428                 abort ();
2429
2430               off = local_got_offsets[r_symndx];
2431
2432               /* The offset must always be a multiple of 4.  We use
2433                  the least significant bit to record whether we have
2434                  already generated the necessary reloc.  */
2435               if ((off & 1) != 0)
2436                 off &= ~1;
2437               else
2438                 {
2439                   bfd_put_32 (output_bfd, relocation,
2440                               htab->elf.sgot->contents + off);
2441
2442                   if (bfd_link_pic (info))
2443                     {
2444                       asection *srelgot;
2445                       Elf_Internal_Rela outrel;
2446                       bfd_byte *loc;
2447
2448                       srelgot = htab->elf.srelgot;
2449                       if (srelgot == NULL)
2450                         abort ();
2451
2452                       outrel.r_offset = (htab->elf.sgot->output_section->vma
2453                                          + htab->elf.sgot->output_offset
2454                                          + off);
2455                       outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2456                       outrel.r_addend = relocation;
2457                       loc = srelgot->contents;
2458                       loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
2459                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2460                     }
2461
2462                   local_got_offsets[r_symndx] |= 1;
2463                 }
2464             }
2465
2466           if (off >= (bfd_vma) -2)
2467             abort ();
2468
2469           relocation = base_got->output_offset + off;
2470
2471           /* For @GOTENT the relocation is against the offset between
2472              the instruction and the symbols entry in the GOT and not
2473              between the start of the GOT and the symbols entry. We
2474              add the vma of the GOT to get the correct value.  */
2475           if (   r_type == R_390_GOTENT
2476               || r_type == R_390_GOTPLTENT)
2477             relocation += base_got->output_section->vma;
2478
2479           break;
2480
2481         case R_390_GOTOFF16:
2482         case R_390_GOTOFF32:
2483           /* Relocation is relative to the start of the global offset
2484              table.  */
2485
2486           if (h != NULL
2487               && s390_is_ifunc_symbol_p (h)
2488               && h->def_regular
2489               && !bfd_link_executable (info))
2490             {
2491               relocation = (htab->elf.iplt->output_section->vma
2492                             + htab->elf.iplt->output_offset
2493                             + h->plt.offset
2494                             - htab->elf.sgot->output_section->vma);
2495               goto do_relocation;
2496             }
2497
2498           /* Note that sgot->output_offset is not involved in this
2499              calculation.  We always want the start of .got.  If we
2500              defined _GLOBAL_OFFSET_TABLE in a different way, as is
2501              permitted by the ABI, we might have to change this
2502              calculation.  */
2503           relocation -= htab->elf.sgot->output_section->vma;
2504           break;
2505
2506         case R_390_GOTPC:
2507         case R_390_GOTPCDBL:
2508           /* Use global offset table as symbol value.  */
2509           relocation = htab->elf.sgot->output_section->vma;
2510           unresolved_reloc = FALSE;
2511           break;
2512
2513         case R_390_PLT12DBL:
2514         case R_390_PLT16DBL:
2515         case R_390_PLT24DBL:
2516         case R_390_PLT32DBL:
2517         case R_390_PLT32:
2518           /* Relocation is to the entry for this symbol in the
2519              procedure linkage table.  */
2520
2521           /* Resolve a PLT32 reloc against a local symbol directly,
2522              without using the procedure linkage table.  */
2523           if (h == NULL)
2524             break;
2525
2526           if (h->plt.offset == (bfd_vma) -1
2527               || (htab->elf.splt == NULL && htab->elf.iplt == NULL))
2528             {
2529               /* We didn't make a PLT entry for this symbol.  This
2530                  happens when statically linking PIC code, or when
2531                  using -Bsymbolic.  */
2532               break;
2533             }
2534
2535           if (s390_is_ifunc_symbol_p (h))
2536             relocation = (htab->elf.iplt->output_section->vma
2537                           + htab->elf.iplt->output_offset
2538                           + h->plt.offset);
2539           else
2540             relocation = (htab->elf.splt->output_section->vma
2541                           + htab->elf.splt->output_offset
2542                           + h->plt.offset);
2543           unresolved_reloc = FALSE;
2544           break;
2545
2546         case R_390_PLTOFF16:
2547         case R_390_PLTOFF32:
2548           /* Relocation is to the entry for this symbol in the
2549              procedure linkage table relative to the start of the GOT.  */
2550
2551           /* For local symbols or if we didn't make a PLT entry for
2552              this symbol resolve the symbol directly.  */
2553           if (h == NULL
2554               || h->plt.offset == (bfd_vma) -1
2555               || (htab->elf.splt == NULL && !s390_is_ifunc_symbol_p (h)))
2556             {
2557               relocation -= htab->elf.sgot->output_section->vma;
2558               break;
2559             }
2560
2561           if (s390_is_ifunc_symbol_p (h))
2562             relocation = (htab->elf.iplt->output_section->vma
2563                           + htab->elf.iplt->output_offset
2564                           + h->plt.offset
2565                           - htab->elf.sgot->output_section->vma);
2566           else
2567             relocation = (htab->elf.splt->output_section->vma
2568                           + htab->elf.splt->output_offset
2569                           + h->plt.offset
2570                           - htab->elf.sgot->output_section->vma);
2571           unresolved_reloc = FALSE;
2572           break;
2573
2574         case R_390_PC16:
2575         case R_390_PC12DBL:
2576         case R_390_PC16DBL:
2577         case R_390_PC24DBL:
2578         case R_390_PC32DBL:
2579         case R_390_PC32:
2580           if (h != NULL
2581               && s390_is_ifunc_symbol_p (h)
2582               && h->def_regular
2583               && !bfd_link_executable (info))
2584             {
2585               /* This will not work our if the function does not
2586                  happen to set up the GOT pointer for some other
2587                  reason.  31 bit PLT entries require r12 to hold the
2588                  GOT pointer.
2589                  FIXME: Implement an errorcheck.
2590                  NOTE: It will work when brasl is not available
2591                  (e.g. with -m31 -march=g5) since a local function
2592                  call then does use GOTOFF which implies r12 being set
2593                  up.  */
2594               relocation = (htab->elf.iplt->output_section->vma
2595                             + htab->elf.iplt->output_offset
2596                             + h ->plt.offset);
2597               goto do_relocation;
2598             }
2599           /* Fall through.  */
2600
2601         case R_390_8:
2602         case R_390_16:
2603         case R_390_32:
2604           if (h != NULL
2605               && s390_is_ifunc_symbol_p (h)
2606               && h->def_regular)
2607             {
2608               if (!bfd_link_pic (info))
2609                 {
2610                   /* For a non-shared object STT_GNU_IFUNC symbol must
2611                      go through PLT.  */
2612                   relocation = (htab->elf.iplt->output_section->vma
2613                                 + htab->elf.iplt->output_offset
2614                                 + h ->plt.offset);
2615                   goto do_relocation;
2616                 }
2617               else
2618                 {
2619                   /* For shared objects a runtime relocation is needed.  */
2620
2621                   Elf_Internal_Rela outrel;
2622                   asection *sreloc;
2623
2624                   /* Need a dynamic relocation to get the real function
2625                      address.  */
2626                   outrel.r_offset = _bfd_elf_section_offset (output_bfd,
2627                                                              info,
2628                                                              input_section,
2629                                                              rel->r_offset);
2630                   if (outrel.r_offset == (bfd_vma) -1
2631                       || outrel.r_offset == (bfd_vma) -2)
2632                     abort ();
2633
2634                   outrel.r_offset += (input_section->output_section->vma
2635                                       + input_section->output_offset);
2636
2637                   if (h->dynindx == -1
2638                       || h->forced_local
2639                       || bfd_link_executable (info))
2640                     {
2641                       /* This symbol is resolved locally.  */
2642                       outrel.r_info = ELF32_R_INFO (0, R_390_IRELATIVE);
2643                       outrel.r_addend = (h->root.u.def.value
2644                                          + h->root.u.def.section->output_section->vma
2645                                          + h->root.u.def.section->output_offset);
2646                     }
2647                   else
2648                     {
2649                       outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2650                       outrel.r_addend = 0;
2651                     }
2652
2653                   sreloc = htab->elf.irelifunc;
2654                   elf_append_rela (output_bfd, sreloc, &outrel);
2655
2656                   /* If this reloc is against an external symbol, we
2657                      do not want to fiddle with the addend.  Otherwise,
2658                      we need to include the symbol value so that it
2659                      becomes an addend for the dynamic reloc.  For an
2660                      internal symbol, we have updated addend.  */
2661                   continue;
2662                 }
2663             }
2664
2665           if ((input_section->flags & SEC_ALLOC) == 0)
2666             break;
2667
2668           if ((bfd_link_pic (info)
2669                && (h == NULL
2670                    || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2671                        && !resolved_to_zero)
2672                    || h->root.type != bfd_link_hash_undefweak)
2673                && ((r_type != R_390_PC16
2674                     && r_type != R_390_PC12DBL
2675                     && r_type != R_390_PC16DBL
2676                     && r_type != R_390_PC24DBL
2677                     && r_type != R_390_PC32DBL
2678                     && r_type != R_390_PC32)
2679                    || !SYMBOL_CALLS_LOCAL (info, h)))
2680               || (ELIMINATE_COPY_RELOCS
2681                   && !bfd_link_pic (info)
2682                   && h != NULL
2683                   && h->dynindx != -1
2684                   && !h->non_got_ref
2685                   && ((h->def_dynamic
2686                        && !h->def_regular)
2687                       || h->root.type == bfd_link_hash_undefweak
2688                       || h->root.type == bfd_link_hash_undefined)))
2689             {
2690               Elf_Internal_Rela outrel;
2691               bfd_boolean skip, relocate;
2692               asection *sreloc;
2693               bfd_byte *loc;
2694
2695               /* When generating a shared object, these relocations
2696                  are copied into the output file to be resolved at run
2697                  time.  */
2698
2699               skip = FALSE;
2700               relocate = FALSE;
2701
2702               outrel.r_offset =
2703                 _bfd_elf_section_offset (output_bfd, info, input_section,
2704                                          rel->r_offset);
2705               if (outrel.r_offset == (bfd_vma) -1)
2706                 skip = TRUE;
2707               else if (outrel.r_offset == (bfd_vma) -2)
2708                 skip = TRUE, relocate = TRUE;
2709               outrel.r_offset += (input_section->output_section->vma
2710                                   + input_section->output_offset);
2711
2712               if (skip)
2713                 memset (&outrel, 0, sizeof outrel);
2714               else if (h != NULL
2715                        && h->dynindx != -1
2716                        && (r_type == R_390_PC16
2717                            || r_type == R_390_PC12DBL
2718                            || r_type == R_390_PC16DBL
2719                            || r_type == R_390_PC24DBL
2720                            || r_type == R_390_PC32DBL
2721                            || r_type == R_390_PC32
2722                            || !bfd_link_pic (info)
2723                            || !SYMBOLIC_BIND (info, h)
2724                            || !h->def_regular))
2725                 {
2726                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2727                   outrel.r_addend = rel->r_addend;
2728                 }
2729               else
2730                 {
2731                   /* This symbol is local, or marked to become local.  */
2732                   outrel.r_addend = relocation + rel->r_addend;
2733                   if (r_type == R_390_32)
2734                     {
2735                       relocate = TRUE;
2736                       outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2737                     }
2738                   else
2739                     {
2740                       long sindx;
2741
2742                       if (bfd_is_abs_section (sec))
2743                         sindx = 0;
2744                       else if (sec == NULL || sec->owner == NULL)
2745                         {
2746                           bfd_set_error(bfd_error_bad_value);
2747                           return FALSE;
2748                         }
2749                       else
2750                         {
2751                           asection *osec;
2752
2753                           osec = sec->output_section;
2754                           sindx = elf_section_data (osec)->dynindx;
2755                           if (sindx == 0)
2756                             {
2757                               osec = htab->elf.text_index_section;
2758                               sindx = elf_section_data (osec)->dynindx;
2759                             }
2760                           BFD_ASSERT (sindx != 0);
2761
2762                           /* We are turning this relocation into one
2763                              against a section symbol, so subtract out
2764                              the output section's address but not the
2765                              offset of the input section in the output
2766                              section.  */
2767                           outrel.r_addend -= osec->vma;
2768                         }
2769                       outrel.r_info = ELF32_R_INFO (sindx, r_type);
2770                     }
2771                 }
2772
2773               sreloc = elf_section_data (input_section)->sreloc;
2774               if (sreloc == NULL)
2775                 abort ();
2776
2777               loc = sreloc->contents;
2778               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2779               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2780
2781               /* If this reloc is against an external symbol, we do
2782                  not want to fiddle with the addend.  Otherwise, we
2783                  need to include the symbol value so that it becomes
2784                  an addend for the dynamic reloc.  */
2785               if (! relocate)
2786                 continue;
2787             }
2788           break;
2789
2790           /* Relocations for tls literal pool entries.  */
2791         case R_390_TLS_IE32:
2792           if (bfd_link_pic (info))
2793             {
2794               Elf_Internal_Rela outrel;
2795               asection *sreloc;
2796               bfd_byte *loc;
2797
2798               outrel.r_offset = rel->r_offset
2799                                 + input_section->output_section->vma
2800                                 + input_section->output_offset;
2801               outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2802               sreloc = elf_section_data (input_section)->sreloc;
2803               if (sreloc == NULL)
2804                 abort ();
2805               loc = sreloc->contents;
2806               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2807               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2808             }
2809           /* Fall through.  */
2810
2811         case R_390_TLS_GD32:
2812         case R_390_TLS_GOTIE32:
2813           r_type = elf_s390_tls_transition (info, r_type, h == NULL);
2814           tls_type = GOT_UNKNOWN;
2815           if (h == NULL && local_got_offsets)
2816             tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
2817           else if (h != NULL)
2818             {
2819               tls_type = elf_s390_hash_entry(h)->tls_type;
2820               if (!bfd_link_pic (info)
2821                   && h->dynindx == -1
2822                   && tls_type >= GOT_TLS_IE)
2823                 r_type = R_390_TLS_LE32;
2824             }
2825           if (r_type == R_390_TLS_GD32 && tls_type >= GOT_TLS_IE)
2826             r_type = R_390_TLS_IE32;
2827
2828           if (r_type == R_390_TLS_LE32)
2829             {
2830               /* This relocation gets optimized away by the local exec
2831                  access optimization.  */
2832               BFD_ASSERT (! unresolved_reloc);
2833               bfd_put_32 (output_bfd, -tpoff (info, relocation),
2834                           contents + rel->r_offset);
2835               continue;
2836             }
2837
2838           if (htab->elf.sgot == NULL)
2839             abort ();
2840
2841           if (h != NULL)
2842             off = h->got.offset;
2843           else
2844             {
2845               if (local_got_offsets == NULL)
2846                 abort ();
2847
2848               off = local_got_offsets[r_symndx];
2849             }
2850
2851         emit_tls_relocs:
2852
2853           if ((off & 1) != 0)
2854             off &= ~1;
2855           else
2856             {
2857               Elf_Internal_Rela outrel;
2858               bfd_byte *loc;
2859               int dr_type, indx;
2860
2861               if (htab->elf.srelgot == NULL)
2862                 abort ();
2863
2864               outrel.r_offset = (htab->elf.sgot->output_section->vma
2865                                  + htab->elf.sgot->output_offset + off);
2866
2867               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2868               if (r_type == R_390_TLS_GD32)
2869                 dr_type = R_390_TLS_DTPMOD;
2870               else
2871                 dr_type = R_390_TLS_TPOFF;
2872               if (dr_type == R_390_TLS_TPOFF && indx == 0)
2873                 outrel.r_addend = relocation - dtpoff_base (info);
2874               else
2875                 outrel.r_addend = 0;
2876               outrel.r_info = ELF32_R_INFO (indx, dr_type);
2877               loc = htab->elf.srelgot->contents;
2878               loc += htab->elf.srelgot->reloc_count++
2879                 * sizeof (Elf32_External_Rela);
2880               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2881
2882               if (r_type == R_390_TLS_GD32)
2883                 {
2884                   if (indx == 0)
2885                     {
2886                       BFD_ASSERT (! unresolved_reloc);
2887                       bfd_put_32 (output_bfd,
2888                                   relocation - dtpoff_base (info),
2889                                   htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
2890                     }
2891                   else
2892                     {
2893                       outrel.r_info = ELF32_R_INFO (indx, R_390_TLS_DTPOFF);
2894                       outrel.r_offset += GOT_ENTRY_SIZE;
2895                       outrel.r_addend = 0;
2896                       htab->elf.srelgot->reloc_count++;
2897                       loc += sizeof (Elf32_External_Rela);
2898                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2899                     }
2900                 }
2901
2902               if (h != NULL)
2903                 h->got.offset |= 1;
2904               else
2905                 local_got_offsets[r_symndx] |= 1;
2906             }
2907
2908           if (off >= (bfd_vma) -2)
2909             abort ();
2910           if (r_type == ELF32_R_TYPE (rel->r_info))
2911             {
2912               relocation = htab->elf.sgot->output_offset + off;
2913               if (r_type == R_390_TLS_IE32 || r_type == R_390_TLS_IEENT)
2914                 relocation += htab->elf.sgot->output_section->vma;
2915               unresolved_reloc = FALSE;
2916             }
2917           else
2918             {
2919               bfd_put_32 (output_bfd, htab->elf.sgot->output_offset + off,
2920                           contents + rel->r_offset);
2921               continue;
2922             }
2923           break;
2924
2925         case R_390_TLS_GOTIE12:
2926         case R_390_TLS_GOTIE20:
2927         case R_390_TLS_IEENT:
2928           if (h == NULL)
2929             {
2930               if (local_got_offsets == NULL)
2931                 abort();
2932               off = local_got_offsets[r_symndx];
2933               if (bfd_link_pic (info))
2934                 goto emit_tls_relocs;
2935             }
2936           else
2937             {
2938               off = h->got.offset;
2939               tls_type = elf_s390_hash_entry(h)->tls_type;
2940               if (bfd_link_pic (info)
2941                   || h->dynindx != -1
2942                   || tls_type < GOT_TLS_IE)
2943                 goto emit_tls_relocs;
2944             }
2945
2946           if (htab->elf.sgot == NULL)
2947             abort ();
2948
2949           BFD_ASSERT (! unresolved_reloc);
2950           bfd_put_32 (output_bfd, -tpoff (info, relocation),
2951                       htab->elf.sgot->contents + off);
2952           relocation = htab->elf.sgot->output_offset + off;
2953           if (r_type == R_390_TLS_IEENT)
2954             relocation += htab->elf.sgot->output_section->vma;
2955           unresolved_reloc = FALSE;
2956           break;
2957
2958         case R_390_TLS_LDM32:
2959           if (! bfd_link_pic (info))
2960             /* The literal pool entry this relocation refers to gets ignored
2961                by the optimized code of the local exec model. Do nothing
2962                and the value will turn out zero.  */
2963             continue;
2964
2965           if (htab->elf.sgot == NULL)
2966             abort ();
2967
2968           off = htab->tls_ldm_got.offset;
2969           if (off & 1)
2970             off &= ~1;
2971           else
2972             {
2973               Elf_Internal_Rela outrel;
2974               bfd_byte *loc;
2975
2976               if (htab->elf.srelgot == NULL)
2977                 abort ();
2978
2979               outrel.r_offset = (htab->elf.sgot->output_section->vma
2980                                  + htab->elf.sgot->output_offset + off);
2981
2982               bfd_put_32 (output_bfd, 0,
2983                           htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
2984               outrel.r_info = ELF32_R_INFO (0, R_390_TLS_DTPMOD);
2985               outrel.r_addend = 0;
2986               loc = htab->elf.srelgot->contents;
2987               loc += htab->elf.srelgot->reloc_count++
2988                 * sizeof (Elf32_External_Rela);
2989               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2990               htab->tls_ldm_got.offset |= 1;
2991             }
2992           relocation = htab->elf.sgot->output_offset + off;
2993           unresolved_reloc = FALSE;
2994           break;
2995
2996         case R_390_TLS_LE32:
2997           if (bfd_link_dll (info))
2998             {
2999               /* Linking a shared library with non-fpic code requires
3000                  a R_390_TLS_TPOFF relocation.  */
3001               Elf_Internal_Rela outrel;
3002               asection *sreloc;
3003               bfd_byte *loc;
3004               int indx;
3005
3006               outrel.r_offset = rel->r_offset
3007                                 + input_section->output_section->vma
3008                                 + input_section->output_offset;
3009               if (h != NULL && h->dynindx != -1)
3010                 indx = h->dynindx;
3011               else
3012                 indx = 0;
3013               outrel.r_info = ELF32_R_INFO (indx, R_390_TLS_TPOFF);
3014               if (indx == 0)
3015                 outrel.r_addend = relocation - dtpoff_base (info);
3016               else
3017                 outrel.r_addend = 0;
3018               sreloc = elf_section_data (input_section)->sreloc;
3019               if (sreloc == NULL)
3020                 abort ();
3021               loc = sreloc->contents;
3022               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
3023               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3024             }
3025           else
3026             {
3027               BFD_ASSERT (! unresolved_reloc);
3028               bfd_put_32 (output_bfd, -tpoff (info, relocation),
3029                           contents + rel->r_offset);
3030             }
3031           continue;
3032
3033         case R_390_TLS_LDO32:
3034           if (bfd_link_pic (info) || (input_section->flags & SEC_DEBUGGING))
3035             relocation -= dtpoff_base (info);
3036           else
3037             /* When converting LDO to LE, we must negate.  */
3038             relocation = -tpoff (info, relocation);
3039           break;
3040
3041           /* Relocations for tls instructions.  */
3042         case R_390_TLS_LOAD:
3043         case R_390_TLS_GDCALL:
3044         case R_390_TLS_LDCALL:
3045           tls_type = GOT_UNKNOWN;
3046           if (h == NULL && local_got_offsets)
3047             tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
3048           else if (h != NULL)
3049             tls_type = elf_s390_hash_entry(h)->tls_type;
3050
3051           if (tls_type == GOT_TLS_GD)
3052             continue;
3053
3054           if (r_type == R_390_TLS_LOAD)
3055             {
3056               if (!bfd_link_pic (info) && (h == NULL || h->dynindx == -1))
3057                 {
3058                   /* IE->LE transition. Four valid cases:
3059                      l %rx,0(0,%ry)    -> lr %rx,%ry + bcr 0,0
3060                      l %rx,0(%ry,0)    -> lr %rx,%ry + bcr 0,0
3061                      l %rx,0(%ry,%r12) -> lr %rx,%ry + bcr 0,0
3062                      l %rx,0(%r12,%ry) -> lr %rx,%ry + bcr 0,0 */
3063                   unsigned int insn, ry;
3064
3065                   insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3066                   if ((insn & 0xff00f000) == 0x58000000)
3067                     /* l %rx,0(%ry,0) -> lr %rx,%ry + bcr 0,0  */
3068                     ry = (insn & 0x000f0000);
3069                   else if ((insn & 0xff0f0000) == 0x58000000)
3070                     /* l %rx,0(0,%ry) -> lr %rx,%ry + bcr 0,0  */
3071                     ry = (insn & 0x0000f000) << 4;
3072                   else if ((insn & 0xff00f000) == 0x5800c000)
3073                     /* l %rx,0(%ry,%r12) -> lr %rx,%ry + bcr 0,0  */
3074                     ry = (insn & 0x000f0000);
3075                   else if ((insn & 0xff0f0000) == 0x580c0000)
3076                     /* l %rx,0(%r12,%ry) -> lr %rx,%ry + bcr 0,0  */
3077                     ry = (insn & 0x0000f000) << 4;
3078                   else
3079                     {
3080                       invalid_tls_insn (input_bfd, input_section, rel);
3081                       return FALSE;
3082                     }
3083                   insn = 0x18000700 | (insn & 0x00f00000) | ry;
3084                   bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3085                 }
3086             }
3087           else if (r_type == R_390_TLS_GDCALL)
3088             {
3089               unsigned int insn;
3090
3091               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3092               if ((insn & 0xff000fff) != 0x4d000000 &&
3093                   (insn & 0xffff0000) != 0xc0e50000 &&
3094                   (insn & 0xff000000) != 0x0d000000)
3095                 {
3096                   invalid_tls_insn (input_bfd, input_section, rel);
3097                   return FALSE;
3098                 }
3099               if (!bfd_link_pic (info) && (h == NULL || h->dynindx == -1))
3100                 {
3101                   if ((insn & 0xff000000) == 0x0d000000)
3102                     {
3103                       /* GD->LE transition.
3104                          basr rx, ry -> nopr r7 */
3105                       insn = 0x07070000 | (insn & 0xffff);
3106                     }
3107                   else if ((insn & 0xff000000) == 0x4d000000)
3108                     {
3109                       /* GD->LE transition.
3110                          bas %r14,0(%rx,%r13) -> bc 0,0  */
3111                       insn = 0x47000000;
3112                     }
3113                   else
3114                     {
3115                       /* GD->LE transition.
3116                          brasl %r14,_tls_get_offset@plt -> brcl 0,.  */
3117                       insn = 0xc0040000;
3118                       bfd_put_16 (output_bfd, 0x0000,
3119                                   contents + rel->r_offset + 4);
3120                     }
3121                 }
3122               else
3123                 {
3124                   /* If basr is used in the pic case to invoke
3125                      _tls_get_offset, something went wrong before.  */
3126                   if ((insn & 0xff000000) == 0x0d000000)
3127                     {
3128                       invalid_tls_insn (input_bfd, input_section, rel);
3129                       return FALSE;
3130                     }
3131
3132                   if ((insn & 0xff000000) == 0x4d000000)
3133                     {
3134                       /* GD->IE transition.
3135                          bas %r14,0(%rx,%r13) -> l %r2,0(%r2,%r12)  */
3136                       insn = 0x5822c000;
3137                     }
3138                   else
3139                     {
3140                       /* GD->IE transition.
3141                          brasl %r14,__tls_get_addr@plt ->
3142                                 l %r2,0(%r2,%r12) ; bcr 0,0 */
3143                       insn = 0x5822c000;
3144                       bfd_put_16 (output_bfd, 0x0700,
3145                                   contents + rel->r_offset + 4);
3146                     }
3147                 }
3148               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3149             }
3150           else if (r_type == R_390_TLS_LDCALL)
3151             {
3152               if (!bfd_link_pic (info))
3153                 {
3154                   unsigned int insn;
3155
3156                   insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3157                   if ((insn & 0xff000fff) != 0x4d000000 &&
3158                       (insn & 0xffff0000) != 0xc0e50000 &&
3159                       (insn & 0xff000000) != 0x0d000000)
3160                     {
3161                       invalid_tls_insn (input_bfd, input_section, rel);
3162                       return FALSE;
3163                     }
3164
3165                   if ((insn & 0xff000000) == 0x0d000000)
3166                     {
3167                       /* LD->LE transition.
3168                          basr rx, ry -> nopr r7 */
3169                       insn = 0x07070000 | (insn & 0xffff);
3170                     }
3171                   else if ((insn & 0xff000000) == 0x4d000000)
3172                     {
3173                       /* LD->LE transition.
3174                          bas %r14,0(%rx,%r13) -> bc 0,0  */
3175                       insn = 0x47000000;
3176                     }
3177                   else
3178                     {
3179                       /* LD->LE transition.
3180                          brasl %r14,__tls_get_offset@plt -> brcl 0,. */
3181                       insn = 0xc0040000;
3182                       bfd_put_16 (output_bfd, 0x0000,
3183                                   contents + rel->r_offset + 4);
3184                     }
3185                   bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3186                 }
3187             }
3188           continue;
3189
3190         default:
3191           break;
3192         }
3193
3194       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3195          because such sections are not SEC_ALLOC and thus ld.so will
3196          not process them.  */
3197       if (unresolved_reloc
3198           && !((input_section->flags & SEC_DEBUGGING) != 0
3199                && h->def_dynamic)
3200           && _bfd_elf_section_offset (output_bfd, info, input_section,
3201                                       rel->r_offset) != (bfd_vma) -1)
3202         _bfd_error_handler
3203           /* xgettext:c-format */
3204           (_("%pB(%pA+%#" PRIx64 "): "
3205              "unresolvable %s relocation against symbol `%s'"),
3206            input_bfd,
3207            input_section,
3208            (uint64_t) rel->r_offset,
3209            howto->name,
3210            h->root.root.string);
3211
3212     do_relocation:
3213
3214       /* When applying a 24 bit reloc we need to start one byte
3215          earlier.  Otherwise the 32 bit get/put bfd operations might
3216          access a byte after the actual section.  */
3217       if (r_type == R_390_PC24DBL
3218           || r_type == R_390_PLT24DBL)
3219         rel->r_offset--;
3220
3221       if (r_type == R_390_20
3222           || r_type == R_390_GOT20
3223           || r_type == R_390_GOTPLT20
3224           || r_type == R_390_TLS_GOTIE20)
3225         {
3226           relocation += rel->r_addend;
3227           relocation = (relocation&0xfff) << 8 | (relocation&0xff000) >> 12;
3228           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3229                                         contents, rel->r_offset,
3230                                         relocation, 0);
3231         }
3232       else
3233         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3234                                       contents, rel->r_offset,
3235                                       relocation, rel->r_addend);
3236
3237       if (r != bfd_reloc_ok)
3238         {
3239           const char *name;
3240
3241           if (h != NULL)
3242             name = h->root.root.string;
3243           else
3244             {
3245               name = bfd_elf_string_from_elf_section (input_bfd,
3246                                                       symtab_hdr->sh_link,
3247                                                       sym->st_name);
3248               if (name == NULL)
3249                 return FALSE;
3250               if (*name == '\0')
3251                 name = bfd_section_name (input_bfd, sec);
3252             }
3253
3254           if (r == bfd_reloc_overflow)
3255             (*info->callbacks->reloc_overflow)
3256               (info, (h ? &h->root : NULL), name, howto->name,
3257                (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
3258           else
3259             {
3260               _bfd_error_handler
3261                 /* xgettext:c-format */
3262                 (_("%pB(%pA+%#" PRIx64 "): reloc against `%s': error %d"),
3263                  input_bfd, input_section,
3264                  (uint64_t) rel->r_offset, name, (int) r);
3265               return FALSE;
3266             }
3267         }
3268     }
3269
3270   return TRUE;
3271 }
3272
3273 /* Generate the PLT slots together with the dynamic relocations needed
3274    for IFUNC symbols.  */
3275
3276 static void
3277 elf_s390_finish_ifunc_symbol (bfd *output_bfd,
3278                               struct bfd_link_info *info,
3279                               struct elf_link_hash_entry *h,
3280                               struct elf_s390_link_hash_table *htab,
3281                               bfd_vma iplt_offset,
3282                               bfd_vma resolver_address)
3283 {
3284   bfd_vma iplt_index;
3285   bfd_vma got_offset;
3286   bfd_vma igotiplt_offset;
3287   Elf_Internal_Rela rela;
3288   bfd_byte *loc;
3289   asection *plt, *gotplt, *relplt;
3290   bfd_vma relative_offset;
3291
3292   if (htab->elf.iplt == NULL
3293       || htab->elf.igotplt == NULL
3294       || htab->elf.irelplt == NULL)
3295     abort ();
3296
3297   gotplt = htab->elf.igotplt;
3298   relplt = htab->elf.irelplt;
3299
3300   /* Index of the PLT slot within iplt section.  */
3301   iplt_index = iplt_offset / PLT_ENTRY_SIZE;
3302   plt = htab->elf.iplt;
3303   /* Offset into the igot.plt section.  */
3304   igotiplt_offset = iplt_index * GOT_ENTRY_SIZE;
3305   /* Offset into the got section.  */
3306   got_offset = igotiplt_offset + gotplt->output_offset;
3307
3308   /* S390 uses halfwords for relative branch calc!  */
3309   relative_offset = - (plt->output_offset +
3310                        (PLT_ENTRY_SIZE * iplt_index) + 18) / 2;
3311   /* If offset is > 32768, branch to a previous branch
3312      390 can only handle +-64 K jumps.  */
3313   if ( -32768 > (int) relative_offset )
3314     relative_offset
3315       = -(unsigned) (((65536 / PLT_ENTRY_SIZE - 1) * PLT_ENTRY_SIZE) / 2);
3316
3317   /* Fill in the entry in the procedure linkage table.  */
3318   if (!bfd_link_pic (info))
3319     {
3320       memcpy (plt->contents + iplt_offset, elf_s390_plt_entry,
3321               PLT_ENTRY_SIZE);
3322
3323       /* Adjust jump to the first plt entry.  */
3324       bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3325                   plt->contents + iplt_offset + 20);
3326
3327       /* Push the GOT offset field.  */
3328       bfd_put_32 (output_bfd,
3329                   (gotplt->output_section->vma
3330                    + got_offset),
3331                   plt->contents + iplt_offset + 24);
3332     }
3333   else if (got_offset < 4096)
3334     {
3335       /* The GOT offset is small enough to be used directly as
3336          displacement.  */
3337       memcpy (plt->contents + iplt_offset,
3338               elf_s390_plt_pic12_entry,
3339               PLT_ENTRY_SIZE);
3340
3341       /* Put in the GOT offset as displacement value.  The 0xc000
3342          value comes from the first word of the plt entry.  Look
3343          at the elf_s390_plt_pic16_entry content.  */
3344       bfd_put_16 (output_bfd, (bfd_vma)0xc000 | got_offset,
3345                   plt->contents + iplt_offset + 2);
3346
3347       /* Adjust the jump to the first plt entry.  */
3348       bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3349                   plt->contents + iplt_offset + 20);
3350     }
3351   else if (got_offset < 32768)
3352     {
3353       /* The GOT offset is too big for a displacement but small
3354          enough to be a signed 16 bit immediate value as it can be
3355          used in an lhi instruction.  */
3356       memcpy (plt->contents + iplt_offset,
3357               elf_s390_plt_pic16_entry,
3358               PLT_ENTRY_SIZE);
3359
3360       /* Put in the GOT offset for the lhi instruction.  */
3361       bfd_put_16 (output_bfd, (bfd_vma)got_offset,
3362                   plt->contents + iplt_offset + 2);
3363
3364       /* Adjust the jump to the first plt entry.  */
3365       bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3366                   plt->contents + iplt_offset + 20);
3367     }
3368   else
3369     {
3370       memcpy (plt->contents + iplt_offset,
3371               elf_s390_plt_pic_entry,
3372               PLT_ENTRY_SIZE);
3373
3374       /* Adjust the jump to the first plt entry.  */
3375       bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3376                   plt->contents + iplt_offset + 20);
3377
3378       /* Push the GOT offset field.  */
3379       bfd_put_32 (output_bfd, got_offset,
3380                   plt->contents + iplt_offset + 24);
3381     }
3382   /* Insert offset into  reloc. table here.  */
3383   bfd_put_32 (output_bfd, relplt->output_offset +
3384               iplt_index * RELA_ENTRY_SIZE,
3385               plt->contents + iplt_offset + 28);
3386
3387   /* Fill in the entry in the global offset table.
3388      Points to instruction after GOT offset.  */
3389   bfd_put_32 (output_bfd,
3390               (plt->output_section->vma
3391                + plt->output_offset
3392                + iplt_offset
3393                + 12),
3394               gotplt->contents + igotiplt_offset);
3395
3396   /* Fill in the entry in the .rela.plt section.  */
3397   rela.r_offset = gotplt->output_section->vma + got_offset;
3398
3399   if (!h
3400       || h->dynindx == -1
3401       || ((bfd_link_executable (info)
3402            || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
3403           && h->def_regular))
3404     {
3405       /* The symbol can be locally resolved.  */
3406       rela.r_info = ELF32_R_INFO (0, R_390_IRELATIVE);
3407       rela.r_addend = resolver_address;
3408     }
3409   else
3410     {
3411       rela.r_info = ELF32_R_INFO (h->dynindx, R_390_JMP_SLOT);
3412       rela.r_addend = 0;
3413     }
3414
3415   loc = relplt->contents + iplt_index * RELA_ENTRY_SIZE;
3416   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3417 }
3418
3419 /* Finish up dynamic symbol handling.  We set the contents of various
3420    dynamic sections here.  */
3421
3422 static bfd_boolean
3423 elf_s390_finish_dynamic_symbol (bfd *output_bfd,
3424                                 struct bfd_link_info *info,
3425                                 struct elf_link_hash_entry *h,
3426                                 Elf_Internal_Sym *sym)
3427 {
3428   struct elf_s390_link_hash_table *htab;
3429   struct elf_s390_link_hash_entry *eh = (struct elf_s390_link_hash_entry*)h;
3430
3431   htab = elf_s390_hash_table (info);
3432
3433   if (h->plt.offset != (bfd_vma) -1)
3434     {
3435       bfd_vma plt_index;
3436       bfd_vma got_offset;
3437       Elf_Internal_Rela rela;
3438       bfd_byte *loc;
3439       bfd_vma relative_offset;
3440
3441       /* This symbol has an entry in the procedure linkage table.  Set
3442          it up.  */
3443       if (s390_is_ifunc_symbol_p (h) && h->def_regular)
3444         {
3445           elf_s390_finish_ifunc_symbol (output_bfd, info, h,
3446             htab, h->plt.offset,
3447             eh->ifunc_resolver_address +
3448             eh->ifunc_resolver_section->output_offset +
3449             eh->ifunc_resolver_section->output_section->vma);
3450           /* Do not return yet.  Handling of explicit GOT slots of
3451              IFUNC symbols is below.  */
3452         }
3453       else
3454         {
3455           if (h->dynindx == -1
3456               || htab->elf.splt == NULL
3457               || htab->elf.sgotplt == NULL
3458               || htab->elf.srelplt == NULL)
3459             abort ();
3460
3461           /* Calc. index no.
3462              Current offset - size first entry / entry size.  */
3463           plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3464
3465           /* Offset in GOT is PLT index plus GOT headers(3) times 4,
3466              addr & GOT addr.  */
3467           got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
3468
3469           /* S390 uses halfwords for relative branch calc!  */
3470           relative_offset = - ((PLT_FIRST_ENTRY_SIZE +
3471                                 (PLT_ENTRY_SIZE * plt_index) + 18) / 2);
3472           /* If offset is > 32768, branch to a previous branch
3473              390 can only handle +-64 K jumps.  */
3474           if ( -32768 > (int) relative_offset )
3475             relative_offset
3476               = -(unsigned) (((65536 / PLT_ENTRY_SIZE - 1) * PLT_ENTRY_SIZE) / 2);
3477
3478           /* Fill in the entry in the procedure linkage table.  */
3479           if (!bfd_link_pic (info))
3480             {
3481               memcpy (htab->elf.splt->contents + h->plt.offset, elf_s390_plt_entry,
3482                       PLT_ENTRY_SIZE);
3483
3484               /* Adjust jump to the first plt entry.  */
3485               bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3486                           htab->elf.splt->contents + h->plt.offset + 20);
3487
3488               /* Push the GOT offset field.  */
3489               bfd_put_32 (output_bfd,
3490                           (htab->elf.sgotplt->output_section->vma
3491                            + htab->elf.sgotplt->output_offset
3492                            + got_offset),
3493                           htab->elf.splt->contents + h->plt.offset + 24);
3494             }
3495           else if (got_offset < 4096)
3496             {
3497               /* The GOT offset is small enough to be used directly as
3498                  displacement.  */
3499               memcpy (htab->elf.splt->contents + h->plt.offset,
3500                       elf_s390_plt_pic12_entry,
3501                       PLT_ENTRY_SIZE);
3502
3503               /* Put in the GOT offset as displacement value.  The 0xc000
3504                  value comes from the first word of the plt entry.  Look
3505                  at the elf_s390_plt_pic12_entry content.  */
3506               bfd_put_16 (output_bfd, (bfd_vma)0xc000 | got_offset,
3507                           htab->elf.splt->contents + h->plt.offset + 2);
3508
3509               /* Adjust the jump to the first plt entry.  */
3510               bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3511                           htab->elf.splt->contents + h->plt.offset + 20);
3512             }
3513           else if (got_offset < 32768)
3514             {
3515               /* The GOT offset is too big for a displacement but small
3516                  enough to be a signed 16 bit immediate value as it can be
3517                  used in an lhi instruction.  */
3518               memcpy (htab->elf.splt->contents + h->plt.offset,
3519                       elf_s390_plt_pic16_entry,
3520                       PLT_ENTRY_SIZE);
3521
3522               /* Put in the GOT offset for the lhi instruction.  */
3523               bfd_put_16 (output_bfd, (bfd_vma)got_offset,
3524                           htab->elf.splt->contents + h->plt.offset + 2);
3525
3526               /* Adjust the jump to the first plt entry.  */
3527               bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3528                           htab->elf.splt->contents + h->plt.offset + 20);
3529             }
3530           else
3531             {
3532               memcpy (htab->elf.splt->contents + h->plt.offset,
3533                       elf_s390_plt_pic_entry,
3534                       PLT_ENTRY_SIZE);
3535
3536               /* Adjust the jump to the first plt entry.  */
3537               bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3538                           htab->elf.splt->contents + h->plt.offset + 20);
3539
3540               /* Push the GOT offset field.  */
3541               bfd_put_32 (output_bfd, got_offset,
3542                           htab->elf.splt->contents + h->plt.offset + 24);
3543             }
3544           /* Insert offset into  reloc. table here.  */
3545           bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
3546                       htab->elf.splt->contents + h->plt.offset + 28);
3547
3548           /* Fill in the entry in the global offset table.
3549              Points to instruction after GOT offset.  */
3550           bfd_put_32 (output_bfd,
3551                       (htab->elf.splt->output_section->vma
3552                        + htab->elf.splt->output_offset
3553                        + h->plt.offset
3554                        + 12),
3555                       htab->elf.sgotplt->contents + got_offset);
3556
3557           /* Fill in the entry in the .rela.plt section.  */
3558           rela.r_offset = (htab->elf.sgotplt->output_section->vma
3559                            + htab->elf.sgotplt->output_offset
3560                            + got_offset);
3561           rela.r_info = ELF32_R_INFO (h->dynindx, R_390_JMP_SLOT);
3562           rela.r_addend = 0;
3563           loc = htab->elf.srelplt->contents + plt_index * sizeof (Elf32_External_Rela);
3564           bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3565
3566           if (!h->def_regular)
3567             {
3568               /* Mark the symbol as undefined, rather than as defined in
3569                  the .plt section.  Leave the value alone.  This is a clue
3570                  for the dynamic linker, to make function pointer
3571                  comparisons work between an application and shared
3572                  library.  */
3573               sym->st_shndx = SHN_UNDEF;
3574             }
3575         }
3576     }
3577
3578   if (h->got.offset != (bfd_vma) -1
3579       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_GD
3580       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE
3581       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE_NLT)
3582     {
3583       Elf_Internal_Rela rela;
3584       bfd_byte *loc;
3585
3586       /* This symbol has an entry in the global offset table.  Set it
3587          up.  */
3588
3589       if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
3590         abort ();
3591
3592       rela.r_offset = (htab->elf.sgot->output_section->vma
3593                        + htab->elf.sgot->output_offset
3594                        + (h->got.offset &~ (bfd_vma) 1));
3595
3596       /* If this is a static link, or it is a -Bsymbolic link and the
3597          symbol is defined locally or was forced to be local because
3598          of a version file, we just want to emit a RELATIVE reloc.
3599          The entry in the global offset table will already have been
3600          initialized in the relocate_section function.  */
3601       if (h->def_regular && s390_is_ifunc_symbol_p (h))
3602         {
3603           if (bfd_link_pic (info))
3604             {
3605               /* An explicit GOT slot usage needs GLOB_DAT.  If the
3606                  symbol references local the implicit got.iplt slot
3607                  will be used and the IRELATIVE reloc has been created
3608                  above.  */
3609               goto do_glob_dat;
3610             }
3611           else
3612             {
3613               /* For non-shared objects explicit GOT slots must be
3614                  filled with the PLT slot address for pointer
3615                  equality reasons.  */
3616               bfd_put_32 (output_bfd, (htab->elf.iplt->output_section->vma
3617                                        + htab->elf.iplt->output_offset
3618                                        + h->plt.offset),
3619                           htab->elf.sgot->contents + h->got.offset);
3620               return TRUE;
3621             }
3622         }
3623       else if (bfd_link_pic (info)
3624                && SYMBOL_REFERENCES_LOCAL (info, h))
3625         {
3626           /* If this is a static link, or it is a -Bsymbolic link and
3627              the symbol is defined locally or was forced to be local
3628              because of a version file, we just want to emit a
3629              RELATIVE reloc.  The entry in the global offset table
3630              will already have been initialized in the
3631              relocate_section function.  */
3632           if (!(h->def_regular || ELF_COMMON_DEF_P (h)))
3633             return FALSE;
3634           BFD_ASSERT((h->got.offset & 1) != 0);
3635           rela.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
3636           rela.r_addend = (h->root.u.def.value
3637                            + h->root.u.def.section->output_section->vma
3638                            + h->root.u.def.section->output_offset);
3639         }
3640       else
3641         {
3642           BFD_ASSERT((h->got.offset & 1) == 0);
3643         do_glob_dat:
3644           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->elf.sgot->contents + h->got.offset);
3645           rela.r_info = ELF32_R_INFO (h->dynindx, R_390_GLOB_DAT);
3646           rela.r_addend = 0;
3647         }
3648
3649       loc = htab->elf.srelgot->contents;
3650       loc += htab->elf.srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
3651       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3652     }
3653
3654   if (h->needs_copy)
3655     {
3656       Elf_Internal_Rela rela;
3657       asection *s;
3658       bfd_byte *loc;
3659
3660       /* This symbols needs a copy reloc.  Set it up.  */
3661
3662       if (h->dynindx == -1
3663           || (h->root.type != bfd_link_hash_defined
3664               && h->root.type != bfd_link_hash_defweak)
3665           || htab->elf.srelbss == NULL
3666           || htab->elf.sreldynrelro == NULL)
3667         abort ();
3668
3669       rela.r_offset = (h->root.u.def.value
3670                        + h->root.u.def.section->output_section->vma
3671                        + h->root.u.def.section->output_offset);
3672       rela.r_info = ELF32_R_INFO (h->dynindx, R_390_COPY);
3673       rela.r_addend = 0;
3674       if (h->root.u.def.section == htab->elf.sdynrelro)
3675         s = htab->elf.sreldynrelro;
3676       else
3677         s = htab->elf.srelbss;
3678       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
3679       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3680     }
3681
3682   /* Mark some specially defined symbols as absolute.  */
3683   if (h == htab->elf.hdynamic
3684       || h == htab->elf.hgot
3685       || h == htab->elf.hplt)
3686     sym->st_shndx = SHN_ABS;
3687
3688   return TRUE;
3689 }
3690
3691 /* Used to decide how to sort relocs in an optimal manner for the
3692    dynamic linker, before writing them out.  */
3693
3694 static enum elf_reloc_type_class
3695 elf_s390_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
3696                            const asection *rel_sec ATTRIBUTE_UNUSED,
3697                            const Elf_Internal_Rela *rela)
3698 {
3699   bfd *abfd = info->output_bfd;
3700   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3701   struct elf_s390_link_hash_table *htab = elf_s390_hash_table (info);
3702   unsigned long r_symndx = ELF32_R_SYM (rela->r_info);
3703   Elf_Internal_Sym sym;
3704
3705   if (htab->elf.dynsym == NULL
3706       || !bed->s->swap_symbol_in (abfd,
3707                                   (htab->elf.dynsym->contents
3708                                    + r_symndx * bed->s->sizeof_sym),
3709                                   0, &sym))
3710     abort ();
3711
3712   /* Check relocation against STT_GNU_IFUNC symbol.  */
3713   if (ELF_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
3714     return reloc_class_ifunc;
3715
3716   switch ((int) ELF32_R_TYPE (rela->r_info))
3717     {
3718     case R_390_RELATIVE:
3719       return reloc_class_relative;
3720     case R_390_JMP_SLOT:
3721       return reloc_class_plt;
3722     case R_390_COPY:
3723       return reloc_class_copy;
3724     default:
3725       return reloc_class_normal;
3726     }
3727 }
3728
3729 /* Finish up the dynamic sections.  */
3730
3731 static bfd_boolean
3732 elf_s390_finish_dynamic_sections (bfd *output_bfd,
3733                                   struct bfd_link_info *info)
3734 {
3735   struct elf_s390_link_hash_table *htab;
3736   bfd *dynobj;
3737   asection *sdyn;
3738   bfd *ibfd;
3739   unsigned int i;
3740
3741   htab = elf_s390_hash_table (info);
3742   dynobj = htab->elf.dynobj;
3743   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3744
3745   if (htab->elf.dynamic_sections_created)
3746     {
3747       Elf32_External_Dyn *dyncon, *dynconend;
3748
3749       if (sdyn == NULL || htab->elf.sgot == NULL)
3750         abort ();
3751
3752       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3753       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3754       for (; dyncon < dynconend; dyncon++)
3755         {
3756           Elf_Internal_Dyn dyn;
3757           asection *s;
3758
3759           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3760
3761           switch (dyn.d_tag)
3762             {
3763             default:
3764               continue;
3765
3766             case DT_PLTGOT:
3767               s = htab->elf.sgotplt;
3768               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3769               break;
3770
3771             case DT_JMPREL:
3772               s = htab->elf.srelplt;
3773               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3774               break;
3775
3776             case DT_PLTRELSZ:
3777               dyn.d_un.d_val = htab->elf.srelplt->size;
3778               if (htab->elf.irelplt)
3779                 dyn.d_un.d_val += htab->elf.irelplt->size;
3780               break;
3781             }
3782
3783           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3784         }
3785
3786       /* Fill in the special first entry in the procedure linkage table.  */
3787       if (htab->elf.splt && htab->elf.splt->size > 0)
3788         {
3789           memset (htab->elf.splt->contents, 0, PLT_FIRST_ENTRY_SIZE);
3790           if (bfd_link_pic (info))
3791             {
3792               memcpy (htab->elf.splt->contents, elf_s390_plt_pic_first_entry,
3793                       PLT_FIRST_ENTRY_SIZE);
3794             }
3795           else
3796             {
3797               memcpy (htab->elf.splt->contents, elf_s390_plt_first_entry,
3798                       PLT_FIRST_ENTRY_SIZE);
3799               bfd_put_32 (output_bfd,
3800                           htab->elf.sgotplt->output_section->vma
3801                           + htab->elf.sgotplt->output_offset,
3802                           htab->elf.splt->contents + 24);
3803             }
3804           elf_section_data (htab->elf.splt->output_section)
3805             ->this_hdr.sh_entsize = 4;
3806         }
3807
3808     }
3809
3810   if (htab->elf.sgotplt)
3811     {
3812       /* Fill in the first three entries in the global offset table.  */
3813       if (htab->elf.sgotplt->size > 0)
3814         {
3815           bfd_put_32 (output_bfd,
3816                       (sdyn == NULL ? (bfd_vma) 0
3817                        : sdyn->output_section->vma + sdyn->output_offset),
3818                       htab->elf.sgotplt->contents);
3819           /* One entry for shared object struct ptr.  */
3820           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + 4);
3821           /* One entry for _dl_runtime_resolve.  */
3822           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + 8);
3823         }
3824
3825       elf_section_data (htab->elf.sgotplt->output_section)
3826         ->this_hdr.sh_entsize = 4;
3827     }
3828   /* Finish dynamic symbol for local IFUNC symbols.  */
3829   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3830     {
3831       struct plt_entry *local_plt;
3832       Elf_Internal_Sym *isym;
3833       Elf_Internal_Shdr *symtab_hdr;
3834
3835       symtab_hdr = &elf_symtab_hdr (ibfd);
3836
3837       if (!is_s390_elf (ibfd))
3838         continue;
3839
3840       local_plt = elf_s390_local_plt (ibfd);
3841       if (local_plt != NULL)
3842         for (i = 0; i < symtab_hdr->sh_info; i++)
3843           {
3844             if (local_plt[i].plt.offset != (bfd_vma) -1)
3845               {
3846                 asection *sec = local_plt[i].sec;
3847                 isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, i);
3848                 if (isym == NULL)
3849                   return FALSE;
3850
3851                 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
3852                   elf_s390_finish_ifunc_symbol (output_bfd, info, NULL, htab,
3853                                                 local_plt[i].plt.offset,
3854                                                 isym->st_value
3855                                                 + sec->output_section->vma
3856                                                 + sec->output_offset);
3857
3858               }
3859           }
3860     }
3861   return TRUE;
3862 }
3863 \f
3864 /* Support for core dump NOTE sections.  */
3865
3866 static bfd_boolean
3867 elf_s390_grok_prstatus (bfd * abfd, Elf_Internal_Note * note)
3868 {
3869   int offset;
3870   unsigned int size;
3871
3872   switch (note->descsz)
3873     {
3874     default:
3875       return FALSE;
3876
3877     case 224:                   /* S/390 Linux.  */
3878       /* pr_cursig */
3879       elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3880
3881       /* pr_pid */
3882       elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
3883
3884       /* pr_reg */
3885       offset = 72;
3886       size = 144;
3887       break;
3888     }
3889
3890   /* Make a ".reg/999" section.  */
3891   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3892                                           size, note->descpos + offset);
3893 }
3894
3895 static bfd_boolean
3896 elf_s390_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3897 {
3898   switch (note->descsz)
3899     {
3900     default:
3901       return FALSE;
3902
3903     case 124:                   /* sizeof(struct elf_prpsinfo) on s390 */
3904       elf_tdata (abfd)->core->pid
3905         = bfd_get_32 (abfd, note->descdata + 12);
3906       elf_tdata (abfd)->core->program
3907         = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
3908       elf_tdata (abfd)->core->command
3909         = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
3910       break;
3911     }
3912
3913   /* Note that for some reason, a spurious space is tacked
3914      onto the end of the args in some (at least one anyway)
3915      implementations, so strip it off if it exists.  */
3916
3917   {
3918     char *command = elf_tdata (abfd)->core->command;
3919     int n = strlen (command);
3920
3921     if (0 < n && command[n - 1] == ' ')
3922       command[n - 1] = '\0';
3923   }
3924
3925   return TRUE;
3926 }
3927
3928 static char *
3929 elf_s390_write_core_note (bfd *abfd, char *buf, int *bufsiz,
3930                           int note_type, ...)
3931 {
3932   va_list ap;
3933
3934   switch (note_type)
3935     {
3936     default:
3937       return NULL;
3938
3939     case NT_PRPSINFO:
3940       {
3941         char data[124] = { 0 };
3942         const char *fname, *psargs;
3943
3944         va_start (ap, note_type);
3945         fname = va_arg (ap, const char *);
3946         psargs = va_arg (ap, const char *);
3947         va_end (ap);
3948
3949         strncpy (data + 28, fname, 16);
3950         strncpy (data + 44, psargs, 80);
3951         return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
3952                                    &data, sizeof (data));
3953       }
3954
3955     case NT_PRSTATUS:
3956       {
3957         char data[224] = { 0 };
3958         long pid;
3959         int cursig;
3960         const void *gregs;
3961
3962         va_start (ap, note_type);
3963         pid = va_arg (ap, long);
3964         cursig = va_arg (ap, int);
3965         gregs = va_arg (ap, const void *);
3966         va_end (ap);
3967
3968         bfd_put_16 (abfd, cursig, data + 12);
3969         bfd_put_32 (abfd, pid, data + 24);
3970         memcpy (data + 72, gregs, 144);
3971         return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
3972                                    &data, sizeof (data));
3973       }
3974     }
3975   /* NOTREACHED */
3976 }
3977 \f
3978 /* Return address for Ith PLT stub in section PLT, for relocation REL
3979    or (bfd_vma) -1 if it should not be included.  */
3980
3981 static bfd_vma
3982 elf_s390_plt_sym_val (bfd_vma i, const asection *plt,
3983                       const arelent *rel ATTRIBUTE_UNUSED)
3984 {
3985   return plt->vma + PLT_FIRST_ENTRY_SIZE + i * PLT_ENTRY_SIZE;
3986 }
3987
3988 /* Merge backend specific data from an object file to the output
3989    object file when linking.  */
3990
3991 static bfd_boolean
3992 elf32_s390_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
3993 {
3994   bfd *obfd = info->output_bfd;
3995
3996   if (!is_s390_elf (ibfd) || !is_s390_elf (obfd))
3997     return TRUE;
3998
3999   if (!elf_s390_merge_obj_attributes (ibfd, info))
4000     return FALSE;
4001
4002   elf_elfheader (obfd)->e_flags |= elf_elfheader (ibfd)->e_flags;
4003   return TRUE;
4004 }
4005
4006
4007 #define TARGET_BIG_SYM  s390_elf32_vec
4008 #define TARGET_BIG_NAME "elf32-s390"
4009 #define ELF_ARCH        bfd_arch_s390
4010 #define ELF_TARGET_ID   S390_ELF_DATA
4011 #define ELF_MACHINE_CODE EM_S390
4012 #define ELF_MACHINE_ALT1 EM_S390_OLD
4013 #define ELF_MAXPAGESIZE 0x1000
4014
4015 #define elf_backend_can_gc_sections     1
4016 #define elf_backend_can_refcount        1
4017 #define elf_backend_want_got_plt        1
4018 #define elf_backend_plt_readonly        1
4019 #define elf_backend_want_plt_sym        0
4020 #define elf_backend_got_header_size     12
4021 #define elf_backend_want_dynrelro       1
4022 #define elf_backend_rela_normal         1
4023
4024 #define elf_info_to_howto                     elf_s390_info_to_howto
4025
4026 #define bfd_elf32_bfd_is_local_label_name     elf_s390_is_local_label_name
4027 #define bfd_elf32_bfd_link_hash_table_create  elf_s390_link_hash_table_create
4028 #define bfd_elf32_bfd_reloc_type_lookup       elf_s390_reloc_type_lookup
4029 #define bfd_elf32_bfd_reloc_name_lookup elf_s390_reloc_name_lookup
4030
4031 #define bfd_elf32_bfd_merge_private_bfd_data  elf32_s390_merge_private_bfd_data
4032
4033 #define elf_backend_adjust_dynamic_symbol     elf_s390_adjust_dynamic_symbol
4034 #define elf_backend_check_relocs              elf_s390_check_relocs
4035 #define elf_backend_copy_indirect_symbol      elf_s390_copy_indirect_symbol
4036 #define elf_backend_create_dynamic_sections   _bfd_elf_create_dynamic_sections
4037 #define elf_backend_finish_dynamic_sections   elf_s390_finish_dynamic_sections
4038 #define elf_backend_finish_dynamic_symbol     elf_s390_finish_dynamic_symbol
4039 #define elf_backend_gc_mark_hook              elf_s390_gc_mark_hook
4040 #define elf_backend_reloc_type_class          elf_s390_reloc_type_class
4041 #define elf_backend_relocate_section          elf_s390_relocate_section
4042 #define elf_backend_size_dynamic_sections     elf_s390_size_dynamic_sections
4043 #define elf_backend_init_index_section        _bfd_elf_init_1_index_section
4044 #define elf_backend_grok_prstatus             elf_s390_grok_prstatus
4045 #define elf_backend_grok_psinfo               elf_s390_grok_psinfo
4046 #define elf_backend_write_core_note           elf_s390_write_core_note
4047 #define elf_backend_plt_sym_val               elf_s390_plt_sym_val
4048 #define elf_backend_add_symbol_hook           elf_s390_add_symbol_hook
4049 #define elf_backend_sort_relocs_p             elf_s390_elf_sort_relocs_p
4050
4051 #define bfd_elf32_mkobject              elf_s390_mkobject
4052 #define elf_backend_object_p            elf_s390_object_p
4053
4054 #define elf_backend_linux_prpsinfo32_ugid16     TRUE
4055
4056 #include "elf32-target.h"