bfd/elf32-s390.c

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