bfd/elf32-s390.c

   1 /* IBM S/390-specific support for 32-bit ELF
   2    Copyright (C) 2000-2016 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 *sdynbss;
 742   asection *srelbss;
 743   asection *irelifunc;
 744
 745   union
 746   {
 747     bfd_signed_vma refcount;
 748     bfd_vma offset;
 749   } tls_ldm_got;
 750
 751   /* Small local sym cache.  */
 752   struct sym_cache sym_cache;
 753 };
 754
 755 /* Get the s390 ELF linker hash table from a link_info structure.  */
 756
 757 #define elf_s390_hash_table(p) \
 758   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
 759   == S390_ELF_DATA ? ((struct elf_s390_link_hash_table *) ((p)->hash)) : NULL)
 760
 761 #undef ELF64
 762 #include "elf-s390-common.c"
 763
 764 /* Create an entry in an s390 ELF linker hash table.  */
 765
 766 static struct bfd_hash_entry *
 767 link_hash_newfunc (struct bfd_hash_entry *entry,
 768                    struct bfd_hash_table *table,
 769                    const char *string)
 770 {
 771   /* Allocate the structure if it has not already been allocated by a
 772      subclass.  */
 773   if (entry == NULL)
 774     {
 775       entry = bfd_hash_allocate (table,
 776                                  sizeof (struct elf_s390_link_hash_entry));
 777       if (entry == NULL)
 778         return entry;
 779     }
 780
 781   /* Call the allocation method of the superclass.  */
 782   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
 783   if (entry != NULL)
 784     {
 785       struct elf_s390_link_hash_entry *eh;
 786
 787       eh = (struct elf_s390_link_hash_entry *) entry;
 788       eh->dyn_relocs = NULL;
 789       eh->gotplt_refcount = 0;
 790       eh->tls_type = GOT_UNKNOWN;
 791       eh->ifunc_resolver_address = 0;
 792       eh->ifunc_resolver_section = NULL;
 793     }
 794
 795   return entry;
 796 }
 797
 798 /* Create an s390 ELF linker hash table.  */
 799
 800 static struct bfd_link_hash_table *
 801 elf_s390_link_hash_table_create (bfd *abfd)
 802 {
 803   struct elf_s390_link_hash_table *ret;
 804   bfd_size_type amt = sizeof (struct elf_s390_link_hash_table);
 805
 806   ret = (struct elf_s390_link_hash_table *) bfd_zmalloc (amt);
 807   if (ret == NULL)
 808     return NULL;
 809
 810   if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
 811                                       sizeof (struct elf_s390_link_hash_entry),
 812                                       S390_ELF_DATA))
 813     {
 814       free (ret);
 815       return NULL;
 816     }
 817
 818   return &ret->elf.root;
 819 }
 820
 821 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
 822    shortcuts to them in our hash table.  */
 823
 824 static bfd_boolean
 825 create_got_section (bfd *dynobj, struct bfd_link_info *info)
 826 {
 827   struct elf_s390_link_hash_table *htab;
 828
 829   if (! _bfd_elf_create_got_section (dynobj, info))
 830     return FALSE;
 831
 832   htab = elf_s390_hash_table (info);
 833   htab->elf.sgot = bfd_get_linker_section (dynobj, ".got");
 834   htab->elf.sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
 835   htab->elf.srelgot = bfd_get_linker_section (dynobj, ".rela.got");
 836   if (!htab->elf.sgot || !htab->elf.sgotplt || !htab->elf.srelgot)
 837     abort ();
 838
 839   return TRUE;
 840 }
 841
 842 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
 843    .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
 844    hash table.  */
 845
 846 static bfd_boolean
 847 elf_s390_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
 848 {
 849   struct elf_s390_link_hash_table *htab;
 850
 851   htab = elf_s390_hash_table (info);
 852   if (!htab->elf.sgot && !create_got_section (dynobj, info))
 853     return FALSE;
 854
 855   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
 856     return FALSE;
 857
 858   htab->elf.splt = bfd_get_linker_section (dynobj, ".plt");
 859   htab->elf.srelplt = bfd_get_linker_section (dynobj, ".rela.plt");
 860   htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
 861   if (!bfd_link_pic (info))
 862     htab->srelbss = bfd_get_linker_section (dynobj, ".rela.bss");
 863
 864   if (!htab->elf.splt || !htab->elf.srelplt || !htab->sdynbss
 865       || (!bfd_link_pic (info) && !htab->srelbss))
 866     abort ();
 867
 868   return TRUE;
 869 }
 870
 871 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
 872
 873 static void
 874 elf_s390_copy_indirect_symbol (struct bfd_link_info *info,
 875                                struct elf_link_hash_entry *dir,
 876                                struct elf_link_hash_entry *ind)
 877 {
 878   struct elf_s390_link_hash_entry *edir, *eind;
 879
 880   edir = (struct elf_s390_link_hash_entry *) dir;
 881   eind = (struct elf_s390_link_hash_entry *) ind;
 882
 883   if (eind->dyn_relocs != NULL)
 884     {
 885       if (edir->dyn_relocs != NULL)
 886         {
 887           struct elf_dyn_relocs **pp;
 888           struct elf_dyn_relocs *p;
 889
 890           /* Add reloc counts against the indirect sym to the direct sym
 891              list.  Merge any entries against the same section.  */
 892           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
 893             {
 894               struct elf_dyn_relocs *q;
 895
 896               for (q = edir->dyn_relocs; q != NULL; q = q->next)
 897                 if (q->sec == p->sec)
 898                   {
 899                     q->pc_count += p->pc_count;
 900                     q->count += p->count;
 901                     *pp = p->next;
 902                     break;
 903                   }
 904               if (q == NULL)
 905                 pp = &p->next;
 906             }
 907           *pp = edir->dyn_relocs;
 908         }
 909
 910       edir->dyn_relocs = eind->dyn_relocs;
 911       eind->dyn_relocs = NULL;
 912     }
 913
 914   if (ind->root.type == bfd_link_hash_indirect
 915       && dir->got.refcount <= 0)
 916     {
 917       edir->tls_type = eind->tls_type;
 918       eind->tls_type = GOT_UNKNOWN;
 919     }
 920
 921   if (ELIMINATE_COPY_RELOCS
 922       && ind->root.type != bfd_link_hash_indirect
 923       && dir->dynamic_adjusted)
 924     {
 925       /* If called to transfer flags for a weakdef during processing
 926          of elf_adjust_dynamic_symbol, don't copy non_got_ref.
 927          We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
 928       dir->ref_dynamic |= ind->ref_dynamic;
 929       dir->ref_regular |= ind->ref_regular;
 930       dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
 931       dir->needs_plt |= ind->needs_plt;
 932     }
 933   else
 934     _bfd_elf_link_hash_copy_indirect (info, dir, ind);
 935 }
 936
 937 static int
 938 elf_s390_tls_transition (struct bfd_link_info *info,
 939                          int r_type,
 940                          int is_local)
 941 {
 942   if (bfd_link_pic (info))
 943     return r_type;
 944
 945   switch (r_type)
 946     {
 947     case R_390_TLS_GD32:
 948     case R_390_TLS_IE32:
 949       if (is_local)
 950         return R_390_TLS_LE32;
 951       return R_390_TLS_IE32;
 952     case R_390_TLS_GOTIE32:
 953       if (is_local)
 954         return R_390_TLS_LE32;
 955       return R_390_TLS_GOTIE32;
 956     case R_390_TLS_LDM32:
 957       return R_390_TLS_LE32;
 958     }
 959
 960   return r_type;
 961 }
 962
 963 /* Look through the relocs for a section during the first phase, and
 964    allocate space in the global offset table or procedure linkage
 965    table.  */
 966
 967 static bfd_boolean
 968 elf_s390_check_relocs (bfd *abfd,
 969                        struct bfd_link_info *info,
 970                        asection *sec,
 971                        const Elf_Internal_Rela *relocs)
 972 {
 973   struct elf_s390_link_hash_table *htab;
 974   Elf_Internal_Shdr *symtab_hdr;
 975   struct elf_link_hash_entry **sym_hashes;
 976   const Elf_Internal_Rela *rel;
 977   const Elf_Internal_Rela *rel_end;
 978   asection *sreloc;
 979   bfd_signed_vma *local_got_refcounts;
 980   int tls_type, old_tls_type;
 981   Elf_Internal_Sym *isym;
 982
 983   if (bfd_link_relocatable (info))
 984     return TRUE;
 985
 986   BFD_ASSERT (is_s390_elf (abfd));
 987
 988   htab = elf_s390_hash_table (info);
 989   symtab_hdr = &elf_symtab_hdr (abfd);
 990   sym_hashes = elf_sym_hashes (abfd);
 991   local_got_refcounts = elf_local_got_refcounts (abfd);
 992
 993   sreloc = NULL;
 994
 995   rel_end = relocs + sec->reloc_count;
 996   for (rel = relocs; rel < rel_end; rel++)
 997     {
 998       unsigned int r_type;
 999       unsigned long r_symndx;
1000       struct elf_link_hash_entry *h;
1001
1002       r_symndx = ELF32_R_SYM (rel->r_info);
1003
1004       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1005         {
1006           /* xgettext:c-format */
1007           _bfd_error_handler (_("%B: bad symbol index: %d"),
1008                               abfd, r_symndx);
1009           return FALSE;
1010         }
1011
1012       if (r_symndx < symtab_hdr->sh_info)
1013         {
1014           /* A local symbol.  */
1015           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1016                                         abfd, r_symndx);
1017           if (isym == NULL)
1018             return FALSE;
1019
1020           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1021             {
1022               struct plt_entry *plt;
1023
1024               if (htab->elf.dynobj == NULL)
1025                 htab->elf.dynobj = abfd;
1026
1027               if (!s390_elf_create_ifunc_sections (htab->elf.dynobj, info))
1028                 return FALSE;
1029
1030               if (local_got_refcounts == NULL)
1031                 {
1032                   if (!elf_s390_allocate_local_syminfo (abfd, symtab_hdr))
1033                     return FALSE;
1034                   local_got_refcounts = elf_local_got_refcounts (abfd);
1035                 }
1036               plt = elf_s390_local_plt (abfd);
1037               plt[r_symndx].plt.refcount++;
1038             }
1039           h = NULL;
1040         }
1041       else
1042         {
1043           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1044           while (h->root.type == bfd_link_hash_indirect
1045                  || h->root.type == bfd_link_hash_warning)
1046             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1047
1048           /* PR15323, ref flags aren't set for references in the same
1049              object.  */
1050           h->root.non_ir_ref = 1;
1051         }
1052
1053       /* Create got section and local_got_refcounts array if they
1054          are needed.  */
1055       r_type = elf_s390_tls_transition (info,
1056                                         ELF32_R_TYPE (rel->r_info),
1057                                         h == NULL);
1058       switch (r_type)
1059         {
1060         case R_390_GOT12:
1061         case R_390_GOT16:
1062         case R_390_GOT20:
1063         case R_390_GOT32:
1064         case R_390_GOTENT:
1065         case R_390_GOTPLT12:
1066         case R_390_GOTPLT16:
1067         case R_390_GOTPLT20:
1068         case R_390_GOTPLT32:
1069         case R_390_GOTPLTENT:
1070         case R_390_TLS_GD32:
1071         case R_390_TLS_GOTIE12:
1072         case R_390_TLS_GOTIE20:
1073         case R_390_TLS_GOTIE32:
1074         case R_390_TLS_IEENT:
1075         case R_390_TLS_IE32:
1076         case R_390_TLS_LDM32:
1077           if (h == NULL
1078               && local_got_refcounts == NULL)
1079             {
1080               if (!elf_s390_allocate_local_syminfo (abfd, symtab_hdr))
1081                 return FALSE;
1082               local_got_refcounts = elf_local_got_refcounts (abfd);
1083             }
1084           /* Fall through.  */
1085         case R_390_GOTOFF16:
1086         case R_390_GOTOFF32:
1087         case R_390_GOTPC:
1088         case R_390_GOTPCDBL:
1089           if (htab->elf.sgot == NULL)
1090             {
1091               if (htab->elf.dynobj == NULL)
1092                 htab->elf.dynobj = abfd;
1093               if (!create_got_section (htab->elf.dynobj, info))
1094                 return FALSE;
1095             }
1096         }
1097
1098       if (h != NULL)
1099         {
1100           if (htab->elf.dynobj == NULL)
1101             htab->elf.dynobj = abfd;
1102           if (!s390_elf_create_ifunc_sections (htab->elf.dynobj, info))
1103             return FALSE;
1104
1105           /* Make sure an IFUNC symbol defined in a non-shared object
1106              always gets a PLT slot.  */
1107           if (s390_is_ifunc_symbol_p (h) && h->def_regular)
1108             {
1109               /* The symbol is called by the dynamic loader in order
1110                  to resolve the relocation.  So it is in fact also
1111                  referenced.  */
1112               h->ref_regular = 1;
1113               h->needs_plt = 1;
1114             }
1115         }
1116       switch (r_type)
1117         {
1118         case R_390_GOTPC:
1119         case R_390_GOTPCDBL:
1120           /* These relocs do not need a GOT slot.  They just load the
1121              GOT pointer itself or address something else relative to
1122              the GOT.  Since the GOT pointer has been set up above we
1123              are done.  */
1124           break;
1125         case R_390_GOTOFF16:
1126         case R_390_GOTOFF32:
1127           if (h == NULL || !s390_is_ifunc_symbol_p (h) || !h->def_regular)
1128             break;
1129           /* Fall through.  */
1130
1131         case R_390_PLT12DBL:
1132         case R_390_PLT16DBL:
1133         case R_390_PLT24DBL:
1134         case R_390_PLT32DBL:
1135         case R_390_PLT32:
1136         case R_390_PLTOFF16:
1137         case R_390_PLTOFF32:
1138           /* This symbol requires a procedure linkage table entry.  We
1139              actually build the entry in adjust_dynamic_symbol,
1140              because this might be a case of linking PIC code which is
1141              never referenced by a dynamic object, in which case we
1142              don't need to generate a procedure linkage table entry
1143              after all.  */
1144
1145           /* If this is a local symbol, we resolve it directly without
1146              creating a procedure linkage table entry.  */
1147           if (h != NULL)
1148             {
1149               h->needs_plt = 1;
1150               h->plt.refcount += 1;
1151             }
1152           break;
1153
1154         case R_390_GOTPLT12:
1155         case R_390_GOTPLT16:
1156         case R_390_GOTPLT20:
1157         case R_390_GOTPLT32:
1158         case R_390_GOTPLTENT:
1159           /* This symbol requires either a procedure linkage table entry
1160              or an entry in the local got. We actually build the entry
1161              in adjust_dynamic_symbol because whether this is really a
1162              global reference can change and with it the fact if we have
1163              to create a plt entry or a local got entry. To be able to
1164              make a once global symbol a local one we have to keep track
1165              of the number of gotplt references that exist for this
1166              symbol.  */
1167           if (h != NULL)
1168             {
1169               ((struct elf_s390_link_hash_entry *) h)->gotplt_refcount++;
1170               h->needs_plt = 1;
1171               h->plt.refcount += 1;
1172             }
1173           else
1174             local_got_refcounts[r_symndx] += 1;
1175           break;
1176
1177         case R_390_TLS_LDM32:
1178           htab->tls_ldm_got.refcount += 1;
1179           break;
1180
1181         case R_390_TLS_IE32:
1182         case R_390_TLS_GOTIE12:
1183         case R_390_TLS_GOTIE20:
1184         case R_390_TLS_GOTIE32:
1185         case R_390_TLS_IEENT:
1186           if (bfd_link_pic (info))
1187             info->flags |= DF_STATIC_TLS;
1188           /* Fall through.  */
1189
1190         case R_390_GOT12:
1191         case R_390_GOT16:
1192         case R_390_GOT20:
1193         case R_390_GOT32:
1194         case R_390_GOTENT:
1195         case R_390_TLS_GD32:
1196           /* This symbol requires a global offset table entry.  */
1197           switch (r_type)
1198             {
1199             default:
1200             case R_390_GOT12:
1201             case R_390_GOT16:
1202             case R_390_GOT20:
1203             case R_390_GOT32:
1204             case R_390_GOTENT:
1205               tls_type = GOT_NORMAL;
1206               break;
1207             case R_390_TLS_GD32:
1208               tls_type = GOT_TLS_GD;
1209               break;
1210             case R_390_TLS_IE32:
1211             case R_390_TLS_GOTIE32:
1212               tls_type = GOT_TLS_IE;
1213               break;
1214             case R_390_TLS_GOTIE12:
1215             case R_390_TLS_GOTIE20:
1216             case R_390_TLS_IEENT:
1217               tls_type = GOT_TLS_IE_NLT;
1218               break;
1219             }
1220
1221           if (h != NULL)
1222             {
1223               h->got.refcount += 1;
1224               old_tls_type = elf_s390_hash_entry(h)->tls_type;
1225             }
1226           else
1227             {
1228               local_got_refcounts[r_symndx] += 1;
1229               old_tls_type = elf_s390_local_got_tls_type (abfd) [r_symndx];
1230             }
1231           /* If a TLS symbol is accessed using IE at least once,
1232              there is no point to use dynamic model for it.  */
1233           if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN)
1234             {
1235               if (old_tls_type == GOT_NORMAL || tls_type == GOT_NORMAL)
1236                 {
1237                   _bfd_error_handler
1238                     /* xgettext:c-format */
1239                     (_("%B: `%s' accessed both as normal and thread local symbol"),
1240                      abfd, h->root.root.string);
1241                   return FALSE;
1242                 }
1243               if (old_tls_type > tls_type)
1244                 tls_type = old_tls_type;
1245             }
1246
1247           if (old_tls_type != tls_type)
1248             {
1249               if (h != NULL)
1250                 elf_s390_hash_entry (h)->tls_type = tls_type;
1251               else
1252                 elf_s390_local_got_tls_type (abfd) [r_symndx] = tls_type;
1253             }
1254
1255           if (r_type != R_390_TLS_IE32)
1256             break;
1257           /* Fall through.  */
1258
1259         case R_390_TLS_LE32:
1260           /* For static linking and executables this reloc will be
1261              calculated at linktime otherwise a TLS_TPOFF runtime
1262              reloc will be generated.  */
1263           if (r_type == R_390_TLS_LE32 && bfd_link_pie (info))
1264             break;
1265
1266           if (!bfd_link_pic (info))
1267             break;
1268           info->flags |= DF_STATIC_TLS;
1269           /* Fall through.  */
1270
1271         case R_390_8:
1272         case R_390_16:
1273         case R_390_32:
1274         case R_390_PC16:
1275         case R_390_PC12DBL:
1276         case R_390_PC16DBL:
1277         case R_390_PC24DBL:
1278         case R_390_PC32DBL:
1279         case R_390_PC32:
1280           if (h != NULL && bfd_link_executable (info))
1281             {
1282               /* If this reloc is in a read-only section, we might
1283                  need a copy reloc.  We can't check reliably at this
1284                  stage whether the section is read-only, as input
1285                  sections have not yet been mapped to output sections.
1286                  Tentatively set the flag for now, and correct in
1287                  adjust_dynamic_symbol.  */
1288               h->non_got_ref = 1;
1289
1290               if (!bfd_link_pic (info))
1291                 {
1292                   /* We may need a .plt entry if the function this reloc
1293                      refers to is in a shared lib.  */
1294                   h->plt.refcount += 1;
1295                 }
1296             }
1297
1298           /* If we are creating a shared library, and this is a reloc
1299              against a global symbol, or a non PC relative reloc
1300              against a local symbol, then we need to copy the reloc
1301              into the shared library.  However, if we are linking with
1302              -Bsymbolic, we do not need to copy a reloc against a
1303              global symbol which is defined in an object we are
1304              including in the link (i.e., DEF_REGULAR is set).  At
1305              this point we have not seen all the input files, so it is
1306              possible that DEF_REGULAR is not set now but will be set
1307              later (it is never cleared).  In case of a weak definition,
1308              DEF_REGULAR may be cleared later by a strong definition in
1309              a shared library. We account for that possibility below by
1310              storing information in the relocs_copied field of the hash
1311              table entry.  A similar situation occurs when creating
1312              shared libraries and symbol visibility changes render the
1313              symbol local.
1314
1315              If on the other hand, we are creating an executable, we
1316              may need to keep relocations for symbols satisfied by a
1317              dynamic library if we manage to avoid copy relocs for the
1318              symbol.  */
1319           if ((bfd_link_pic (info)
1320                && (sec->flags & SEC_ALLOC) != 0
1321                && ((ELF32_R_TYPE (rel->r_info) != R_390_PC16
1322                     && ELF32_R_TYPE (rel->r_info) != R_390_PC12DBL
1323                     && ELF32_R_TYPE (rel->r_info) != R_390_PC16DBL
1324                     && ELF32_R_TYPE (rel->r_info) != R_390_PC24DBL
1325                     && ELF32_R_TYPE (rel->r_info) != R_390_PC32DBL
1326                     && ELF32_R_TYPE (rel->r_info) != R_390_PC32)
1327                    || (h != NULL
1328                        && (! SYMBOLIC_BIND (info, h)
1329                            || h->root.type == bfd_link_hash_defweak
1330                            || !h->def_regular))))
1331               || (ELIMINATE_COPY_RELOCS
1332                   && !bfd_link_pic (info)
1333                   && (sec->flags & SEC_ALLOC) != 0
1334                   && h != NULL
1335                   && (h->root.type == bfd_link_hash_defweak
1336                       || !h->def_regular)))
1337             {
1338               struct elf_dyn_relocs *p;
1339               struct elf_dyn_relocs **head;
1340
1341               /* We must copy these reloc types into the output file.
1342                  Create a reloc section in dynobj and make room for
1343                  this reloc.  */
1344               if (sreloc == NULL)
1345                 {
1346                   if (htab->elf.dynobj == NULL)
1347                     htab->elf.dynobj = abfd;
1348
1349                   sreloc = _bfd_elf_make_dynamic_reloc_section
1350                     (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ TRUE);
1351
1352                   if (sreloc == NULL)
1353                     return FALSE;
1354                 }
1355
1356               /* If this is a global symbol, we count the number of
1357                  relocations we need for this symbol.  */
1358               if (h != NULL)
1359                 {
1360                   head = &((struct elf_s390_link_hash_entry *) h)->dyn_relocs;
1361                 }
1362               else
1363                 {
1364                   /* Track dynamic relocs needed for local syms too.
1365                      We really need local syms available to do this
1366                      easily.  Oh well.  */
1367                   asection *s;
1368                   void *vpp;
1369
1370                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1371                                                 abfd, r_symndx);
1372                   if (isym == NULL)
1373                     return FALSE;
1374
1375                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1376                   if (s == NULL)
1377                     s = sec;
1378
1379                   vpp = &elf_section_data (s)->local_dynrel;
1380                   head = (struct elf_dyn_relocs **) vpp;
1381                 }
1382
1383               p = *head;
1384               if (p == NULL || p->sec != sec)
1385                 {
1386                   bfd_size_type amt = sizeof *p;
1387
1388                   p = ((struct elf_dyn_relocs *)
1389                        bfd_alloc (htab->elf.dynobj, amt));
1390                   if (p == NULL)
1391                     return FALSE;
1392                   p->next = *head;
1393                   *head = p;
1394                   p->sec = sec;
1395                   p->count = 0;
1396                   p->pc_count = 0;
1397                 }
1398
1399               p->count += 1;
1400               if (ELF32_R_TYPE (rel->r_info) == R_390_PC16
1401                   || ELF32_R_TYPE (rel->r_info) == R_390_PC12DBL
1402                   || ELF32_R_TYPE (rel->r_info) == R_390_PC16DBL
1403                   || ELF32_R_TYPE (rel->r_info) == R_390_PC24DBL
1404                   || ELF32_R_TYPE (rel->r_info) == R_390_PC32DBL
1405                   || ELF32_R_TYPE (rel->r_info) == R_390_PC32)
1406                 p->pc_count += 1;
1407             }
1408           break;
1409
1410           /* This relocation describes the C++ object vtable hierarchy.
1411              Reconstruct it for later use during GC.  */
1412         case R_390_GNU_VTINHERIT:
1413           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1414             return FALSE;
1415           break;
1416
1417           /* This relocation describes which C++ vtable entries are actually
1418              used.  Record for later use during GC.  */
1419         case R_390_GNU_VTENTRY:
1420           BFD_ASSERT (h != NULL);
1421           if (h != NULL
1422               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1423             return FALSE;
1424           break;
1425
1426         default:
1427           break;
1428         }
1429     }
1430
1431   return TRUE;
1432 }
1433
1434 /* Return the section that should be marked against GC for a given
1435    relocation.  */
1436
1437 static asection *
1438 elf_s390_gc_mark_hook (asection *sec,
1439                        struct bfd_link_info *info,
1440                        Elf_Internal_Rela *rel,
1441                        struct elf_link_hash_entry *h,
1442                        Elf_Internal_Sym *sym)
1443 {
1444   if (h != NULL)
1445     switch (ELF32_R_TYPE (rel->r_info))
1446       {
1447       case R_390_GNU_VTINHERIT:
1448       case R_390_GNU_VTENTRY:
1449         return NULL;
1450       }
1451   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1452
1453 }
1454
1455 /* Update the got entry reference counts for the section being removed.  */
1456
1457 static bfd_boolean
1458 elf_s390_gc_sweep_hook (bfd *abfd,
1459                         struct bfd_link_info *info,
1460                         asection *sec,
1461                         const Elf_Internal_Rela *relocs)
1462 {
1463   struct elf_s390_link_hash_table *htab;
1464   Elf_Internal_Shdr *symtab_hdr;
1465   struct elf_link_hash_entry **sym_hashes;
1466   bfd_signed_vma *local_got_refcounts;
1467   const Elf_Internal_Rela *rel, *relend;
1468
1469   if (bfd_link_relocatable (info))
1470     return TRUE;
1471
1472   htab = elf_s390_hash_table (info);
1473   if (htab == NULL)
1474     return FALSE;
1475
1476   elf_section_data (sec)->local_dynrel = NULL;
1477
1478   symtab_hdr = &elf_symtab_hdr (abfd);
1479   sym_hashes = elf_sym_hashes (abfd);
1480   local_got_refcounts = elf_local_got_refcounts (abfd);
1481
1482   relend = relocs + sec->reloc_count;
1483   for (rel = relocs; rel < relend; rel++)
1484     {
1485       unsigned long r_symndx;
1486       unsigned int r_type;
1487       struct elf_link_hash_entry *h = NULL;
1488
1489       r_symndx = ELF32_R_SYM (rel->r_info);
1490       if (r_symndx >= symtab_hdr->sh_info)
1491         {
1492           struct elf_s390_link_hash_entry *eh;
1493           struct elf_dyn_relocs **pp;
1494           struct elf_dyn_relocs *p;
1495
1496           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1497           while (h->root.type == bfd_link_hash_indirect
1498                  || h->root.type == bfd_link_hash_warning)
1499             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1500           eh = (struct elf_s390_link_hash_entry *) h;
1501
1502           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1503             if (p->sec == sec)
1504               {
1505                 /* Everything must go for SEC.  */
1506                 *pp = p->next;
1507                 break;
1508               }
1509         }
1510       else
1511         {
1512           Elf_Internal_Sym *isym;
1513
1514           /* A local symbol.  */
1515           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1516                                         abfd, r_symndx);
1517           if (isym == NULL)
1518             return FALSE;
1519
1520           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1521             {
1522               struct plt_entry *plt = elf_s390_local_plt (abfd);
1523               if (plt[r_symndx].plt.refcount > 0)
1524                 plt[r_symndx].plt.refcount--;
1525             }
1526         }
1527
1528       r_type = ELF32_R_TYPE (rel->r_info);
1529       r_type = elf_s390_tls_transition (info, r_type, h != NULL);
1530       switch (r_type)
1531         {
1532         case R_390_TLS_LDM32:
1533           if (elf_s390_hash_table (info)->tls_ldm_got.refcount > 0)
1534             elf_s390_hash_table (info)->tls_ldm_got.refcount -= 1;
1535           break;
1536
1537         case R_390_GOTOFF16:
1538         case R_390_GOTOFF32:
1539           if (h != NULL && s390_is_ifunc_symbol_p (h) && h->def_regular)
1540             {
1541               h->plt.refcount--;
1542               break;
1543             }
1544
1545         case R_390_GOTPC:
1546         case R_390_GOTPCDBL:
1547           break;
1548
1549         case R_390_TLS_GD32:
1550         case R_390_TLS_IE32:
1551         case R_390_TLS_GOTIE12:
1552         case R_390_TLS_GOTIE20:
1553         case R_390_TLS_GOTIE32:
1554         case R_390_TLS_IEENT:
1555         case R_390_GOT12:
1556         case R_390_GOT16:
1557         case R_390_GOT20:
1558         case R_390_GOT32:
1559         case R_390_GOTENT:
1560           if (h != NULL)
1561             {
1562               if (h->got.refcount > 0)
1563                 h->got.refcount -= 1;
1564             }
1565           else if (local_got_refcounts != NULL)
1566             {
1567               if (local_got_refcounts[r_symndx] > 0)
1568                 local_got_refcounts[r_symndx] -= 1;
1569             }
1570           break;
1571
1572         case R_390_8:
1573         case R_390_12:
1574         case R_390_16:
1575         case R_390_20:
1576         case R_390_32:
1577         case R_390_PC16:
1578         case R_390_PC12DBL:
1579         case R_390_PC16DBL:
1580         case R_390_PC24DBL:
1581         case R_390_PC32DBL:
1582         case R_390_PC32:
1583           if (bfd_link_pic (info))
1584             break;
1585           /* Fall through.  */
1586
1587         case R_390_PLT12DBL:
1588         case R_390_PLT16DBL:
1589         case R_390_PLT24DBL:
1590         case R_390_PLT32DBL:
1591         case R_390_PLT32:
1592         case R_390_PLTOFF16:
1593         case R_390_PLTOFF32:
1594           if (h != NULL)
1595             {
1596               if (h->plt.refcount > 0)
1597                 h->plt.refcount -= 1;
1598             }
1599           break;
1600
1601         case R_390_GOTPLT12:
1602         case R_390_GOTPLT16:
1603         case R_390_GOTPLT20:
1604         case R_390_GOTPLT32:
1605         case R_390_GOTPLTENT:
1606           if (h != NULL)
1607             {
1608               if (h->plt.refcount > 0)
1609                 {
1610                   ((struct elf_s390_link_hash_entry *) h)->gotplt_refcount--;
1611                   h->plt.refcount -= 1;
1612                 }
1613             }
1614           else if (local_got_refcounts != NULL)
1615             {
1616               if (local_got_refcounts[r_symndx] > 0)
1617                 local_got_refcounts[r_symndx] -= 1;
1618             }
1619           break;
1620
1621         default:
1622           break;
1623         }
1624     }
1625
1626   return TRUE;
1627 }
1628
1629 /* Make sure we emit a GOT entry if the symbol was supposed to have a PLT
1630    entry but we found we will not create any.  Called when we find we will
1631    not have any PLT for this symbol, by for example
1632    elf_s390_adjust_dynamic_symbol when we're doing a proper dynamic link,
1633    or elf_s390_size_dynamic_sections if no dynamic sections will be
1634    created (we're only linking static objects).  */
1635
1636 static void
1637 elf_s390_adjust_gotplt (struct elf_s390_link_hash_entry *h)
1638 {
1639   if (h->elf.root.type == bfd_link_hash_warning)
1640     h = (struct elf_s390_link_hash_entry *) h->elf.root.u.i.link;
1641
1642   if (h->gotplt_refcount <= 0)
1643     return;
1644
1645   /* We simply add the number of gotplt references to the number
1646    * of got references for this symbol.  */
1647   h->elf.got.refcount += h->gotplt_refcount;
1648   h->gotplt_refcount = -1;
1649 }
1650
1651 /* Adjust a symbol defined by a dynamic object and referenced by a
1652    regular object.  The current definition is in some section of the
1653    dynamic object, but we're not including those sections.  We have to
1654    change the definition to something the rest of the link can
1655    understand.  */
1656
1657 static bfd_boolean
1658 elf_s390_adjust_dynamic_symbol (struct bfd_link_info *info,
1659                                 struct elf_link_hash_entry *h)
1660 {
1661   struct elf_s390_link_hash_table *htab;
1662   asection *s;
1663
1664   /* STT_GNU_IFUNC symbol must go through PLT. */
1665   if (s390_is_ifunc_symbol_p (h))
1666     {
1667       /* All local STT_GNU_IFUNC references must be treated as local
1668          calls via local PLT.  */
1669       if (h->ref_regular && SYMBOL_CALLS_LOCAL (info, h))
1670         {
1671           bfd_size_type pc_count = 0, count = 0;
1672           struct elf_dyn_relocs **pp;
1673           struct elf_s390_link_hash_entry *eh;
1674           struct elf_dyn_relocs *p;
1675
1676           eh = (struct elf_s390_link_hash_entry *) h;
1677           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1678             {
1679               pc_count += p->pc_count;
1680               p->count -= p->pc_count;
1681               p->pc_count = 0;
1682               count += p->count;
1683               if (p->count == 0)
1684                 *pp = p->next;
1685               else
1686                 pp = &p->next;
1687             }
1688
1689           if (pc_count || count)
1690             {
1691               h->needs_plt = 1;
1692               h->non_got_ref = 1;
1693               if (h->plt.refcount <= 0)
1694                 h->plt.refcount = 1;
1695               else
1696                 h->plt.refcount += 1;
1697             }
1698         }
1699
1700       if (h->plt.refcount <= 0)
1701         {
1702           h->plt.offset = (bfd_vma) -1;
1703           h->needs_plt = 0;
1704         }
1705       return TRUE;
1706     }
1707
1708   /* If this is a function, put it in the procedure linkage table.  We
1709      will fill in the contents of the procedure linkage table later
1710      (although we could actually do it here).  */
1711   if (h->type == STT_FUNC
1712       || h->needs_plt)
1713     {
1714       if (h->plt.refcount <= 0
1715           || SYMBOL_CALLS_LOCAL (info, h)
1716           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1717               && h->root.type != bfd_link_hash_undefweak))
1718         {
1719           /* This case can occur if we saw a PLT32 reloc in an input
1720              file, but the symbol was never referred to by a dynamic
1721              object, or if all references were garbage collected.  In
1722              such a case, we don't actually need to build a procedure
1723              linkage table, and we can just do a PC32 reloc instead.  */
1724           h->plt.offset = (bfd_vma) -1;
1725           h->needs_plt = 0;
1726           elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1727         }
1728
1729       return TRUE;
1730     }
1731   else
1732     /* It's possible that we incorrectly decided a .plt reloc was
1733        needed for an R_390_PC32 reloc to a non-function sym in
1734        check_relocs.  We can't decide accurately between function and
1735        non-function syms in check-relocs;  Objects loaded later in
1736        the link may change h->type.  So fix it now.  */
1737     h->plt.offset = (bfd_vma) -1;
1738
1739   /* If this is a weak symbol, and there is a real definition, the
1740      processor independent code will have arranged for us to see the
1741      real definition first, and we can just use the same value.  */
1742   if (h->u.weakdef != NULL)
1743     {
1744       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1745                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1746       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1747       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1748       if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1749         h->non_got_ref = h->u.weakdef->non_got_ref;
1750       return TRUE;
1751     }
1752
1753   /* This is a reference to a symbol defined by a dynamic object which
1754      is not a function.  */
1755
1756   /* If we are creating a shared library, we must presume that the
1757      only references to the symbol are via the global offset table.
1758      For such cases we need not do anything here; the relocations will
1759      be handled correctly by relocate_section.  */
1760   if (bfd_link_pic (info))
1761     return TRUE;
1762
1763   /* If there are no references to this symbol that do not use the
1764      GOT, we don't need to generate a copy reloc.  */
1765   if (!h->non_got_ref)
1766     return TRUE;
1767
1768   /* If -z nocopyreloc was given, we won't generate them either.  */
1769   if (info->nocopyreloc)
1770     {
1771       h->non_got_ref = 0;
1772       return TRUE;
1773     }
1774
1775   if (ELIMINATE_COPY_RELOCS)
1776     {
1777       struct elf_s390_link_hash_entry * eh;
1778       struct elf_dyn_relocs *p;
1779
1780       eh = (struct elf_s390_link_hash_entry *) h;
1781       for (p = eh->dyn_relocs; p != NULL; p = p->next)
1782         {
1783           s = p->sec->output_section;
1784           if (s != NULL && (s->flags & SEC_READONLY) != 0)
1785             break;
1786         }
1787
1788       /* If we didn't find any dynamic relocs in read-only sections, then
1789          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
1790       if (p == NULL)
1791         {
1792           h->non_got_ref = 0;
1793           return TRUE;
1794         }
1795     }
1796
1797   /* We must allocate the symbol in our .dynbss section, which will
1798      become part of the .bss section of the executable.  There will be
1799      an entry for this symbol in the .dynsym section.  The dynamic
1800      object will contain position independent code, so all references
1801      from the dynamic object to this symbol will go through the global
1802      offset table.  The dynamic linker will use the .dynsym entry to
1803      determine the address it must put in the global offset table, so
1804      both the dynamic object and the regular object will refer to the
1805      same memory location for the variable.  */
1806
1807   htab = elf_s390_hash_table (info);
1808
1809   /* We must generate a R_390_COPY reloc to tell the dynamic linker to
1810      copy the initial value out of the dynamic object and into the
1811      runtime process image.  */
1812   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1813     {
1814       htab->srelbss->size += sizeof (Elf32_External_Rela);
1815       h->needs_copy = 1;
1816     }
1817
1818   s = htab->sdynbss;
1819
1820   return _bfd_elf_adjust_dynamic_copy (info, h, s);
1821 }
1822
1823 /* Allocate space in .plt, .got and associated reloc sections for
1824    dynamic relocs.  */
1825
1826 static bfd_boolean
1827 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1828 {
1829   struct bfd_link_info *info;
1830   struct elf_s390_link_hash_table *htab;
1831   struct elf_s390_link_hash_entry *eh = (struct elf_s390_link_hash_entry *)h;
1832   struct elf_dyn_relocs *p;
1833
1834   if (h->root.type == bfd_link_hash_indirect)
1835     return TRUE;
1836
1837   info = (struct bfd_link_info *) inf;
1838   htab = elf_s390_hash_table (info);
1839
1840   /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
1841      here if it is defined and referenced in a non-shared object.  */
1842   if (s390_is_ifunc_symbol_p (h) && h->def_regular)
1843     return s390_elf_allocate_ifunc_dyn_relocs (info, h);
1844   else if (htab->elf.dynamic_sections_created
1845            && h->plt.refcount > 0)
1846     {
1847       /* Make sure this symbol is output as a dynamic symbol.
1848          Undefined weak syms won't yet be marked as dynamic.  */
1849       if (h->dynindx == -1
1850           && !h->forced_local)
1851         {
1852           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1853             return FALSE;
1854         }
1855
1856       if (bfd_link_pic (info)
1857           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1858         {
1859           asection *s = htab->elf.splt;
1860
1861           /* If this is the first .plt entry, make room for the special
1862              first entry.  */
1863           if (s->size == 0)
1864             s->size += PLT_FIRST_ENTRY_SIZE;
1865
1866           h->plt.offset = s->size;
1867
1868           /* If this symbol is not defined in a regular file, and we are
1869              not generating a shared library, then set the symbol to this
1870              location in the .plt.  This is required to make function
1871              pointers compare as equal between the normal executable and
1872              the shared library.  */
1873           if (! bfd_link_pic (info)
1874               && !h->def_regular)
1875             {
1876               h->root.u.def.section = s;
1877               h->root.u.def.value = h->plt.offset;
1878             }
1879
1880           /* Make room for this entry.  */
1881           s->size += PLT_ENTRY_SIZE;
1882
1883           /* We also need to make an entry in the .got.plt section, which
1884              will be placed in the .got section by the linker script.  */
1885           htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
1886
1887           /* We also need to make an entry in the .rela.plt section.  */
1888           htab->elf.srelplt->size += sizeof (Elf32_External_Rela);
1889         }
1890       else
1891         {
1892           h->plt.offset = (bfd_vma) -1;
1893           h->needs_plt = 0;
1894           elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1895         }
1896     }
1897   else
1898     {
1899       h->plt.offset = (bfd_vma) -1;
1900       h->needs_plt = 0;
1901       elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1902     }
1903
1904   /* If R_390_TLS_{IE32,GOTIE32,GOTIE12,IEENT} symbol is now local to
1905      the binary, we can optimize a bit. IE32 and GOTIE32 get converted
1906      to R_390_TLS_LE32 requiring no TLS entry. For GOTIE12 and IEENT
1907      we can save the dynamic TLS relocation.  */
1908   if (h->got.refcount > 0
1909       && !bfd_link_pic (info)
1910       && h->dynindx == -1
1911       && elf_s390_hash_entry(h)->tls_type >= GOT_TLS_IE)
1912     {
1913       if (elf_s390_hash_entry(h)->tls_type == GOT_TLS_IE_NLT)
1914         /* For the GOTIE access without a literal pool entry the offset has
1915            to be stored somewhere. The immediate value in the instruction
1916            is not bit enough so the value is stored in the got.  */
1917         {
1918           h->got.offset = htab->elf.sgot->size;
1919           htab->elf.sgot->size += GOT_ENTRY_SIZE;
1920         }
1921       else
1922         h->got.offset = (bfd_vma) -1;
1923     }
1924   else if (h->got.refcount > 0)
1925     {
1926       asection *s;
1927       bfd_boolean dyn;
1928       int tls_type = elf_s390_hash_entry(h)->tls_type;
1929
1930       /* Make sure this symbol is output as a dynamic symbol.
1931          Undefined weak syms won't yet be marked as dynamic.  */
1932       if (h->dynindx == -1
1933           && !h->forced_local)
1934         {
1935           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1936             return FALSE;
1937         }
1938
1939       s = htab->elf.sgot;
1940       h->got.offset = s->size;
1941       s->size += GOT_ENTRY_SIZE;
1942       /* R_390_TLS_GD32 needs 2 consecutive GOT slots.  */
1943       if (tls_type == GOT_TLS_GD)
1944         s->size += GOT_ENTRY_SIZE;
1945       dyn = htab->elf.dynamic_sections_created;
1946       /* R_390_TLS_IE32 needs one dynamic relocation,
1947          R_390_TLS_GD32 needs one if local symbol and two if global.  */
1948       if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1949           || tls_type >= GOT_TLS_IE)
1950         htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
1951       else if (tls_type == GOT_TLS_GD)
1952         htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rela);
1953       else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1954                 || h->root.type != bfd_link_hash_undefweak)
1955                && (bfd_link_pic (info)
1956                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1957         htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
1958     }
1959   else
1960     h->got.offset = (bfd_vma) -1;
1961
1962   if (eh->dyn_relocs == NULL)
1963     return TRUE;
1964
1965   /* In the shared -Bsymbolic case, discard space allocated for
1966      dynamic pc-relative relocs against symbols which turn out to be
1967      defined in regular objects.  For the normal shared case, discard
1968      space for pc-relative relocs that have become local due to symbol
1969      visibility changes.  */
1970
1971   if (bfd_link_pic (info))
1972     {
1973       if (SYMBOL_CALLS_LOCAL (info, h))
1974         {
1975           struct elf_dyn_relocs **pp;
1976
1977           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1978             {
1979               p->count -= p->pc_count;
1980               p->pc_count = 0;
1981               if (p->count == 0)
1982                 *pp = p->next;
1983               else
1984                 pp = &p->next;
1985             }
1986         }
1987
1988       /* Also discard relocs on undefined weak syms with non-default
1989          visibility.  */
1990       if (eh->dyn_relocs != NULL
1991           && h->root.type == bfd_link_hash_undefweak)
1992         {
1993           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1994             eh->dyn_relocs = NULL;
1995
1996           /* Make sure undefined weak symbols are output as a dynamic
1997              symbol in PIEs.  */
1998           else if (h->dynindx == -1
1999                    && !h->forced_local)
2000             {
2001               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2002                 return FALSE;
2003             }
2004         }
2005     }
2006   else if (ELIMINATE_COPY_RELOCS)
2007     {
2008       /* For the non-shared case, discard space for relocs against
2009          symbols which turn out to need copy relocs or are not
2010          dynamic.  */
2011
2012       if (!h->non_got_ref
2013           && ((h->def_dynamic
2014                && !h->def_regular)
2015               || (htab->elf.dynamic_sections_created
2016                   && (h->root.type == bfd_link_hash_undefweak
2017                       || h->root.type == bfd_link_hash_undefined))))
2018         {
2019           /* Make sure this symbol is output as a dynamic symbol.
2020              Undefined weak syms won't yet be marked as dynamic.  */
2021           if (h->dynindx == -1
2022               && !h->forced_local)
2023             {
2024               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2025                 return FALSE;
2026             }
2027
2028           /* If that succeeded, we know we'll be keeping all the
2029              relocs.  */
2030           if (h->dynindx != -1)
2031             goto keep;
2032         }
2033
2034       eh->dyn_relocs = NULL;
2035
2036     keep: ;
2037     }
2038
2039   /* Finally, allocate space.  */
2040   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2041     {
2042       asection *sreloc = elf_section_data (p->sec)->sreloc;
2043
2044       sreloc->size += p->count * sizeof (Elf32_External_Rela);
2045     }
2046
2047   return TRUE;
2048 }
2049
2050 /* Find any dynamic relocs that apply to read-only sections.  */
2051
2052 static bfd_boolean
2053 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2054 {
2055   struct elf_s390_link_hash_entry *eh;
2056   struct elf_dyn_relocs *p;
2057
2058   eh = (struct elf_s390_link_hash_entry *) h;
2059   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2060     {
2061       asection *s = p->sec->output_section;
2062
2063       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2064         {
2065           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2066
2067           info->flags |= DF_TEXTREL;
2068
2069           /* Not an error, just cut short the traversal.  */
2070           return FALSE;
2071         }
2072     }
2073   return TRUE;
2074 }
2075
2076 /* Set the sizes of the dynamic sections.  */
2077
2078 static bfd_boolean
2079 elf_s390_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2080                                 struct bfd_link_info *info)
2081 {
2082   struct elf_s390_link_hash_table *htab;
2083   bfd *dynobj;
2084   asection *s;
2085   bfd_boolean relocs;
2086   bfd *ibfd;
2087
2088   htab = elf_s390_hash_table (info);
2089   dynobj = htab->elf.dynobj;
2090   if (dynobj == NULL)
2091     abort ();
2092
2093   if (htab->elf.dynamic_sections_created)
2094     {
2095       /* Set the contents of the .interp section to the interpreter.  */
2096       if (bfd_link_executable (info) && !info->nointerp)
2097         {
2098           s = bfd_get_linker_section (dynobj, ".interp");
2099           if (s == NULL)
2100             abort ();
2101           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2102           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2103         }
2104     }
2105
2106   /* Set up .got offsets for local syms, and space for local dynamic
2107      relocs.  */
2108   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2109     {
2110       bfd_signed_vma *local_got;
2111       bfd_signed_vma *end_local_got;
2112       char *local_tls_type;
2113       bfd_size_type locsymcount;
2114       Elf_Internal_Shdr *symtab_hdr;
2115       asection *srela;
2116       struct plt_entry *local_plt;
2117       unsigned int i;
2118
2119       if (! is_s390_elf (ibfd))
2120         continue;
2121
2122       for (s = ibfd->sections; s != NULL; s = s->next)
2123         {
2124           struct elf_dyn_relocs *p;
2125
2126           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
2127             {
2128               if (!bfd_is_abs_section (p->sec)
2129                   && bfd_is_abs_section (p->sec->output_section))
2130                 {
2131                   /* Input section has been discarded, either because
2132                      it is a copy of a linkonce section or due to
2133                      linker script /DISCARD/, so we'll be discarding
2134                      the relocs too.  */
2135                 }
2136               else if (p->count != 0)
2137                 {
2138                   srela = elf_section_data (p->sec)->sreloc;
2139                   srela->size += p->count * sizeof (Elf32_External_Rela);
2140                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2141                     info->flags |= DF_TEXTREL;
2142                 }
2143             }
2144         }
2145
2146       local_got = elf_local_got_refcounts (ibfd);
2147       if (!local_got)
2148         continue;
2149
2150       symtab_hdr = &elf_symtab_hdr (ibfd);
2151       locsymcount = symtab_hdr->sh_info;
2152       end_local_got = local_got + locsymcount;
2153       local_tls_type = elf_s390_local_got_tls_type (ibfd);
2154       s = htab->elf.sgot;
2155       srela = htab->elf.srelgot;
2156       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2157         {
2158           if (*local_got > 0)
2159             {
2160               *local_got = s->size;
2161               s->size += GOT_ENTRY_SIZE;
2162               if (*local_tls_type == GOT_TLS_GD)
2163                 s->size += GOT_ENTRY_SIZE;
2164               if (bfd_link_pic (info))
2165                 srela->size += sizeof (Elf32_External_Rela);
2166             }
2167           else
2168             *local_got = (bfd_vma) -1;
2169         }
2170       local_plt = elf_s390_local_plt (ibfd);
2171       for (i = 0; i < symtab_hdr->sh_info; i++)
2172         {
2173           if (local_plt[i].plt.refcount > 0)
2174             {
2175               local_plt[i].plt.offset = htab->elf.iplt->size;
2176               htab->elf.iplt->size += PLT_ENTRY_SIZE;
2177               htab->elf.igotplt->size += GOT_ENTRY_SIZE;
2178               htab->elf.irelplt->size += RELA_ENTRY_SIZE;
2179             }
2180           else
2181             local_plt[i].plt.offset = (bfd_vma) -1;
2182         }
2183     }
2184
2185   if (htab->tls_ldm_got.refcount > 0)
2186     {
2187       /* Allocate 2 got entries and 1 dynamic reloc for R_390_TLS_LDM32
2188          relocs.  */
2189       htab->tls_ldm_got.offset = htab->elf.sgot->size;
2190       htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
2191       htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
2192     }
2193   else
2194     htab->tls_ldm_got.offset = -1;
2195
2196   /* Allocate global sym .plt and .got entries, and space for global
2197      sym dynamic relocs.  */
2198   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
2199
2200   /* We now have determined the sizes of the various dynamic sections.
2201      Allocate memory for them.  */
2202   relocs = FALSE;
2203   for (s = dynobj->sections; s != NULL; s = s->next)
2204     {
2205       if ((s->flags & SEC_LINKER_CREATED) == 0)
2206         continue;
2207
2208       if (s == htab->elf.splt
2209           || s == htab->elf.sgot
2210           || s == htab->elf.sgotplt
2211           || s == htab->sdynbss
2212           || s == htab->elf.iplt
2213           || s == htab->elf.igotplt
2214           || s == htab->irelifunc)
2215         {
2216           /* Strip this section if we don't need it; see the
2217              comment below.  */
2218         }
2219       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2220         {
2221           if (s->size != 0)
2222             relocs = TRUE;
2223
2224           /* We use the reloc_count field as a counter if we need
2225              to copy relocs into the output file.  */
2226           s->reloc_count = 0;
2227         }
2228       else
2229         {
2230           /* It's not one of our sections, so don't allocate space.  */
2231           continue;
2232         }
2233
2234       if (s->size == 0)
2235         {
2236           /* If we don't need this section, strip it from the
2237              output file.  This is to handle .rela.bss and
2238              .rela.plt.  We must create it in
2239              create_dynamic_sections, because it must be created
2240              before the linker maps input sections to output
2241              sections.  The linker does that before
2242              adjust_dynamic_symbol is called, and it is that
2243              function which decides whether anything needs to go
2244              into these sections.  */
2245
2246           s->flags |= SEC_EXCLUDE;
2247           continue;
2248         }
2249
2250       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2251         continue;
2252
2253       /* Allocate memory for the section contents.  We use bfd_zalloc
2254          here in case unused entries are not reclaimed before the
2255          section's contents are written out.  This should not happen,
2256          but this way if it does, we get a R_390_NONE reloc instead
2257          of garbage.  */
2258       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2259       if (s->contents == NULL)
2260         return FALSE;
2261     }
2262
2263   if (htab->elf.dynamic_sections_created)
2264     {
2265       /* Add some entries to the .dynamic section.  We fill in the
2266          values later, in elf_s390_finish_dynamic_sections, but we
2267          must add the entries now so that we get the correct size for
2268          the .dynamic section.  The DT_DEBUG entry is filled in by the
2269          dynamic linker and used by the debugger.  */
2270 #define add_dynamic_entry(TAG, VAL) \
2271   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2272
2273       if (bfd_link_executable (info))
2274         {
2275           if (!add_dynamic_entry (DT_DEBUG, 0))
2276             return FALSE;
2277         }
2278
2279       if (htab->elf.splt->size != 0)
2280         {
2281           if (!add_dynamic_entry (DT_PLTGOT, 0)
2282               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2283               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2284               || !add_dynamic_entry (DT_JMPREL, 0))
2285             return FALSE;
2286         }
2287
2288       if (relocs)
2289         {
2290           if (!add_dynamic_entry (DT_RELA, 0)
2291               || !add_dynamic_entry (DT_RELASZ, 0)
2292               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
2293             return FALSE;
2294
2295           /* If any dynamic relocs apply to a read-only section,
2296              then we need a DT_TEXTREL entry.  */
2297           if ((info->flags & DF_TEXTREL) == 0)
2298             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
2299
2300           if ((info->flags & DF_TEXTREL) != 0)
2301             {
2302               if (!add_dynamic_entry (DT_TEXTREL, 0))
2303                 return FALSE;
2304             }
2305         }
2306     }
2307 #undef add_dynamic_entry
2308
2309   return TRUE;
2310 }
2311
2312 /* Return the base VMA address which should be subtracted from real addresses
2313    when resolving @dtpoff relocation.
2314    This is PT_TLS segment p_vaddr.  */
2315
2316 static bfd_vma
2317 dtpoff_base (struct bfd_link_info *info)
2318 {
2319   /* If tls_sec is NULL, we should have signalled an error already.  */
2320   if (elf_hash_table (info)->tls_sec == NULL)
2321     return 0;
2322   return elf_hash_table (info)->tls_sec->vma;
2323 }
2324
2325 /* Return the relocation value for @tpoff relocation
2326    if STT_TLS virtual address is ADDRESS.  */
2327
2328 static bfd_vma
2329 tpoff (struct bfd_link_info *info, bfd_vma address)
2330 {
2331   struct elf_link_hash_table *htab = elf_hash_table (info);
2332
2333   /* If tls_sec is NULL, we should have signalled an error already.  */
2334   if (htab->tls_sec == NULL)
2335     return 0;
2336   return htab->tls_size + htab->tls_sec->vma - address;
2337 }
2338
2339 /* Complain if TLS instruction relocation is against an invalid
2340    instruction.  */
2341
2342 static void
2343 invalid_tls_insn (bfd *input_bfd,
2344                   asection *input_section,
2345                   Elf_Internal_Rela *rel)
2346 {
2347   reloc_howto_type *howto;
2348
2349   howto = elf_howto_table + ELF32_R_TYPE (rel->r_info);
2350   _bfd_error_handler
2351     /* xgettext:c-format */
2352     (_("%B(%A+0x%lx): invalid instruction for TLS relocation %s"),
2353      input_bfd,
2354      input_section,
2355      (long) rel->r_offset,
2356      howto->name);
2357   bfd_set_error (bfd_error_bad_value);
2358 }
2359
2360 /* Relocate a 390 ELF section.  */
2361
2362 static bfd_boolean
2363 elf_s390_relocate_section (bfd *output_bfd,
2364                            struct bfd_link_info *info,
2365                            bfd *input_bfd,
2366                            asection *input_section,
2367                            bfd_byte *contents,
2368                            Elf_Internal_Rela *relocs,
2369                            Elf_Internal_Sym *local_syms,
2370                            asection **local_sections)
2371 {
2372   struct elf_s390_link_hash_table *htab;
2373   Elf_Internal_Shdr *symtab_hdr;
2374   struct elf_link_hash_entry **sym_hashes;
2375   bfd_vma *local_got_offsets;
2376   Elf_Internal_Rela *rel;
2377   Elf_Internal_Rela *relend;
2378
2379   BFD_ASSERT (is_s390_elf (input_bfd));
2380
2381   htab = elf_s390_hash_table (info);
2382   symtab_hdr = &elf_symtab_hdr (input_bfd);
2383   sym_hashes = elf_sym_hashes (input_bfd);
2384   local_got_offsets = elf_local_got_offsets (input_bfd);
2385
2386   rel = relocs;
2387   relend = relocs + input_section->reloc_count;
2388   for (; rel < relend; rel++)
2389     {
2390       unsigned int r_type;
2391       reloc_howto_type *howto;
2392       unsigned long r_symndx;
2393       struct elf_link_hash_entry *h;
2394       Elf_Internal_Sym *sym;
2395       asection *sec;
2396       bfd_vma off;
2397       bfd_vma relocation;
2398       bfd_boolean unresolved_reloc;
2399       bfd_reloc_status_type r;
2400       int tls_type;
2401       asection *base_got = htab->elf.sgot;
2402
2403       r_type = ELF32_R_TYPE (rel->r_info);
2404       if (r_type == (int) R_390_GNU_VTINHERIT
2405           || r_type == (int) R_390_GNU_VTENTRY)
2406         continue;
2407       if (r_type >= (int) R_390_max)
2408         {
2409           bfd_set_error (bfd_error_bad_value);
2410           return FALSE;
2411         }
2412
2413       howto = elf_howto_table + r_type;
2414       r_symndx = ELF32_R_SYM (rel->r_info);
2415
2416       h = NULL;
2417       sym = NULL;
2418       sec = NULL;
2419       unresolved_reloc = FALSE;
2420       if (r_symndx < symtab_hdr->sh_info)
2421         {
2422           sym = local_syms + r_symndx;
2423           sec = local_sections[r_symndx];
2424           if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
2425             {
2426               struct plt_entry *local_plt = elf_s390_local_plt (input_bfd);
2427               if (local_plt == NULL)
2428                 return FALSE;
2429
2430               /* Address of the PLT slot.  */
2431               relocation = (htab->elf.iplt->output_section->vma
2432                             + htab->elf.iplt->output_offset
2433                             + local_plt[r_symndx].plt.offset);
2434
2435               switch (r_type)
2436                 {
2437                 case R_390_PLTOFF16:
2438                 case R_390_PLTOFF32:
2439                   relocation -= htab->elf.sgot->output_section->vma;
2440                   break;
2441                 case R_390_GOTPLT12:
2442                 case R_390_GOTPLT16:
2443                 case R_390_GOTPLT20:
2444                 case R_390_GOTPLT32:
2445                 case R_390_GOTPLTENT:
2446                 case R_390_GOT12:
2447                 case R_390_GOT16:
2448                 case R_390_GOT20:
2449                 case R_390_GOT32:
2450                 case R_390_GOTENT:
2451                   {
2452                     /* Write the PLT slot address into the GOT slot.  */
2453                     bfd_put_32 (output_bfd, relocation,
2454                                 htab->elf.sgot->contents +
2455                                 local_got_offsets[r_symndx]);
2456                     relocation = (local_got_offsets[r_symndx] +
2457                                   htab->elf.sgot->output_offset);
2458
2459                     if (r_type == R_390_GOTENT || r_type == R_390_GOTPLTENT)
2460                       relocation += htab->elf.sgot->output_section->vma;
2461                     break;
2462                   }
2463                 default:
2464                   break;
2465                 }
2466               /* The output section is needed later in
2467                  finish_dynamic_section when creating the dynamic
2468                  relocation.  */
2469               local_plt[r_symndx].sec = sec;
2470               goto do_relocation;
2471             }
2472           else
2473             relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2474         }
2475       else
2476         {
2477           bfd_boolean warned ATTRIBUTE_UNUSED;
2478           bfd_boolean ignored ATTRIBUTE_UNUSED;
2479
2480           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2481                                    r_symndx, symtab_hdr, sym_hashes,
2482                                    h, sec, relocation,
2483                                    unresolved_reloc, warned, ignored);
2484         }
2485
2486       if (sec != NULL && discarded_section (sec))
2487         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2488                                          rel, 1, relend, howto, 0, contents);
2489
2490       if (bfd_link_relocatable (info))
2491         continue;
2492
2493       switch (r_type)
2494         {
2495         case R_390_GOTPLT12:
2496         case R_390_GOTPLT16:
2497         case R_390_GOTPLT20:
2498         case R_390_GOTPLT32:
2499         case R_390_GOTPLTENT:
2500           /* There are three cases for a GOTPLT relocation. 1) The
2501              relocation is against the jump slot entry of a plt that
2502              will get emitted to the output file. 2) The relocation
2503              is against the jump slot of a plt entry that has been
2504              removed. elf_s390_adjust_gotplt has created a GOT entry
2505              as replacement. 3) The relocation is against a local symbol.
2506              Cases 2) and 3) are the same as the GOT relocation code
2507              so we just have to test for case 1 and fall through for
2508              the other two.  */
2509           if (h != NULL && h->plt.offset != (bfd_vma) -1)
2510             {
2511               bfd_vma plt_index;
2512
2513               if (s390_is_ifunc_symbol_p (h))
2514                 {
2515                   plt_index = h->plt.offset / PLT_ENTRY_SIZE;
2516                   relocation = (plt_index * GOT_ENTRY_SIZE +
2517                                 htab->elf.igotplt->output_offset);
2518                   if (r_type == R_390_GOTPLTENT)
2519                     relocation += htab->elf.igotplt->output_section->vma;
2520                 }
2521               else
2522                 {
2523                   /* Calc. index no.
2524                      Current offset - size first entry / entry size.  */
2525                   plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) /
2526                     PLT_ENTRY_SIZE;
2527
2528                   /* Offset in GOT is PLT index plus GOT headers(3)
2529                      times 4, addr & GOT addr.  */
2530                   relocation = (plt_index + 3) * GOT_ENTRY_SIZE;
2531                   if (r_type == R_390_GOTPLTENT)
2532                     relocation += htab->elf.sgot->output_section->vma;
2533                 }
2534               unresolved_reloc = FALSE;
2535
2536             }
2537           /* Fall through.  */
2538
2539         case R_390_GOT12:
2540         case R_390_GOT16:
2541         case R_390_GOT20:
2542         case R_390_GOT32:
2543         case R_390_GOTENT:
2544           /* Relocation is to the entry for this symbol in the global
2545              offset table.  */
2546           if (base_got == NULL)
2547             abort ();
2548
2549           if (h != NULL)
2550             {
2551               bfd_boolean dyn;
2552
2553               off = h->got.offset;
2554               dyn = htab->elf.dynamic_sections_created;
2555
2556               if (s390_is_ifunc_symbol_p (h))
2557                 {
2558                   BFD_ASSERT (h->plt.offset != (bfd_vma) -1);
2559                   if (off == (bfd_vma)-1)
2560                     {
2561                       /* No explicit GOT usage so redirect to the
2562                          got.iplt slot.  */
2563                       base_got = htab->elf.igotplt;
2564                       off = h->plt.offset / PLT_ENTRY_SIZE * GOT_ENTRY_SIZE;
2565                     }
2566                   else
2567                     {
2568                       /* Explicit GOT slots must contain the address
2569                          of the PLT slot. This will be handled in
2570                          finish_dynamic_symbol.  */
2571                     }
2572                 }
2573               else if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
2574                                                           bfd_link_pic (info),
2575                                                           h)
2576                        || (bfd_link_pic (info)
2577                            && SYMBOL_REFERENCES_LOCAL (info, h))
2578                        || (ELF_ST_VISIBILITY (h->other)
2579                            && h->root.type == bfd_link_hash_undefweak))
2580
2581                 {
2582                   /* This is actually a static link, or it is a
2583                      -Bsymbolic link and the symbol is defined
2584                      locally, or the symbol was forced to be local
2585                      because of a version file.  We must initialize
2586                      this entry in the global offset table.  Since the
2587                      offset must always be a multiple of 2, we use the
2588                      least significant bit to record whether we have
2589                      initialized it already.
2590
2591                      When doing a dynamic link, we create a .rel.got
2592                      relocation entry to initialize the value.  This
2593                      is done in the finish_dynamic_symbol routine.  */
2594                   if ((off & 1) != 0)
2595                     off &= ~1;
2596                   else
2597                     {
2598                       bfd_put_32 (output_bfd, relocation,
2599                                   base_got->contents + off);
2600                       h->got.offset |= 1;
2601                     }
2602
2603                   if ((h->def_regular
2604                        && bfd_link_pic (info)
2605                        && SYMBOL_REFERENCES_LOCAL (info, h))
2606                       /* lrl rx,sym@GOTENT -> larl rx, sym */
2607                       && ((r_type == R_390_GOTENT
2608                            && (bfd_get_16 (input_bfd,
2609                                            contents + rel->r_offset - 2)
2610                                & 0xff0f) == 0xc40d)
2611                           /* ly rx, sym@GOT(r12) -> larl rx, sym */
2612                           || (r_type == R_390_GOT20
2613                               && (bfd_get_32 (input_bfd,
2614                                               contents + rel->r_offset - 2)
2615                                   & 0xff00f000) == 0xe300c000
2616                               && bfd_get_8 (input_bfd,
2617                                             contents + rel->r_offset + 3) == 0x58)))
2618                     {
2619                       unsigned short new_insn =
2620                         (0xc000 | (bfd_get_8 (input_bfd,
2621                                               contents + rel->r_offset - 1) & 0xf0));
2622                       bfd_put_16 (output_bfd, new_insn,
2623                                   contents + rel->r_offset - 2);
2624                       r_type = R_390_PC32DBL;
2625                       rel->r_addend = 2;
2626                       howto = elf_howto_table + r_type;
2627                       relocation = h->root.u.def.value
2628                         + h->root.u.def.section->output_section->vma
2629                         + h->root.u.def.section->output_offset;
2630                       goto do_relocation;
2631                     }
2632                 }
2633               else
2634                 unresolved_reloc = FALSE;
2635             }
2636           else
2637             {
2638               if (local_got_offsets == NULL)
2639                 abort ();
2640
2641               off = local_got_offsets[r_symndx];
2642
2643               /* The offset must always be a multiple of 4.  We use
2644                  the least significant bit to record whether we have
2645                  already generated the necessary reloc.  */
2646               if ((off & 1) != 0)
2647                 off &= ~1;
2648               else
2649                 {
2650                   bfd_put_32 (output_bfd, relocation,
2651                               htab->elf.sgot->contents + off);
2652
2653                   if (bfd_link_pic (info))
2654                     {
2655                       asection *srelgot;
2656                       Elf_Internal_Rela outrel;
2657                       bfd_byte *loc;
2658
2659                       srelgot = htab->elf.srelgot;
2660                       if (srelgot == NULL)
2661                         abort ();
2662
2663                       outrel.r_offset = (htab->elf.sgot->output_section->vma
2664                                          + htab->elf.sgot->output_offset
2665                                          + off);
2666                       outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2667                       outrel.r_addend = relocation;
2668                       loc = srelgot->contents;
2669                       loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
2670                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2671                     }
2672
2673                   local_got_offsets[r_symndx] |= 1;
2674                 }
2675             }
2676
2677           if (off >= (bfd_vma) -2)
2678             abort ();
2679
2680           relocation = base_got->output_offset + off;
2681
2682           /* For @GOTENT the relocation is against the offset between
2683              the instruction and the symbols entry in the GOT and not
2684              between the start of the GOT and the symbols entry. We
2685              add the vma of the GOT to get the correct value.  */
2686           if (   r_type == R_390_GOTENT
2687               || r_type == R_390_GOTPLTENT)
2688             relocation += base_got->output_section->vma;
2689
2690           break;
2691
2692         case R_390_GOTOFF16:
2693         case R_390_GOTOFF32:
2694           /* Relocation is relative to the start of the global offset
2695              table.  */
2696
2697           if (h != NULL
2698               && s390_is_ifunc_symbol_p (h)
2699               && h->def_regular
2700               && !bfd_link_executable (info))
2701             {
2702               relocation = (htab->elf.iplt->output_section->vma
2703                             + htab->elf.iplt->output_offset
2704                             + h->plt.offset
2705                             - htab->elf.sgot->output_section->vma);
2706               goto do_relocation;
2707             }
2708
2709           /* Note that sgot->output_offset is not involved in this
2710              calculation.  We always want the start of .got.  If we
2711              defined _GLOBAL_OFFSET_TABLE in a different way, as is
2712              permitted by the ABI, we might have to change this
2713              calculation.  */
2714           relocation -= htab->elf.sgot->output_section->vma;
2715           break;
2716
2717         case R_390_GOTPC:
2718         case R_390_GOTPCDBL:
2719           /* Use global offset table as symbol value.  */
2720           relocation = htab->elf.sgot->output_section->vma;
2721           unresolved_reloc = FALSE;
2722           break;
2723
2724         case R_390_PLT12DBL:
2725         case R_390_PLT16DBL:
2726         case R_390_PLT24DBL:
2727         case R_390_PLT32DBL:
2728         case R_390_PLT32:
2729           /* Relocation is to the entry for this symbol in the
2730              procedure linkage table.  */
2731
2732           /* Resolve a PLT32 reloc against a local symbol directly,
2733              without using the procedure linkage table.  */
2734           if (h == NULL)
2735             break;
2736
2737           if (h->plt.offset == (bfd_vma) -1
2738               || (htab->elf.splt == NULL && htab->elf.iplt == NULL))
2739             {
2740               /* We didn't make a PLT entry for this symbol.  This
2741                  happens when statically linking PIC code, or when
2742                  using -Bsymbolic.  */
2743               break;
2744             }
2745
2746           if (s390_is_ifunc_symbol_p (h))
2747             relocation = (htab->elf.iplt->output_section->vma
2748                           + htab->elf.iplt->output_offset
2749                           + h->plt.offset);
2750           else
2751             relocation = (htab->elf.splt->output_section->vma
2752                           + htab->elf.splt->output_offset
2753                           + h->plt.offset);
2754           unresolved_reloc = FALSE;
2755           break;
2756
2757         case R_390_PLTOFF16:
2758         case R_390_PLTOFF32:
2759           /* Relocation is to the entry for this symbol in the
2760              procedure linkage table relative to the start of the GOT.  */
2761
2762           /* For local symbols or if we didn't make a PLT entry for
2763              this symbol resolve the symbol directly.  */
2764           if (h == NULL
2765               || h->plt.offset == (bfd_vma) -1
2766               || (htab->elf.splt == NULL && !s390_is_ifunc_symbol_p (h)))
2767             {
2768               relocation -= htab->elf.sgot->output_section->vma;
2769               break;
2770             }
2771
2772           if (s390_is_ifunc_symbol_p (h))
2773             relocation = (htab->elf.iplt->output_section->vma
2774                           + htab->elf.iplt->output_offset
2775                           + h->plt.offset
2776                           - htab->elf.sgot->output_section->vma);
2777           else
2778             relocation = (htab->elf.splt->output_section->vma
2779                           + htab->elf.splt->output_offset
2780                           + h->plt.offset
2781                           - htab->elf.sgot->output_section->vma);
2782           unresolved_reloc = FALSE;
2783           break;
2784
2785         case R_390_PC16:
2786         case R_390_PC12DBL:
2787         case R_390_PC16DBL:
2788         case R_390_PC24DBL:
2789         case R_390_PC32DBL:
2790         case R_390_PC32:
2791           if (h != NULL
2792               && s390_is_ifunc_symbol_p (h)
2793               && h->def_regular
2794               && !bfd_link_executable (info))
2795             {
2796               /* This will not work our if the function does not
2797                  happen to set up the GOT pointer for some other
2798                  reason.  31 bit PLT entries require r12 to hold the
2799                  GOT pointer.
2800                  FIXME: Implement an errorcheck.
2801                  NOTE: It will work when brasl is not available
2802                  (e.g. with -m31 -march=g5) since a local function
2803                  call then does use GOTOFF which implies r12 being set
2804                  up.  */
2805               relocation = (htab->elf.iplt->output_section->vma
2806                             + htab->elf.iplt->output_offset
2807                             + h ->plt.offset);
2808               goto do_relocation;
2809             }
2810           /* Fall through.  */
2811
2812         case R_390_8:
2813         case R_390_16:
2814         case R_390_32:
2815           if (h != NULL
2816               && s390_is_ifunc_symbol_p (h)
2817               && h->def_regular)
2818             {
2819               if (!bfd_link_pic (info) || !h->non_got_ref)
2820                 {
2821                   /* For a non-shared object STT_GNU_IFUNC symbol must
2822                      go through PLT.  */
2823                   relocation = (htab->elf.iplt->output_section->vma
2824                                 + htab->elf.iplt->output_offset
2825                                 + h ->plt.offset);
2826                   goto do_relocation;
2827                 }
2828               else
2829                 {
2830                   /* For shared objects a runtime relocation is needed.  */
2831
2832                   Elf_Internal_Rela outrel;
2833                   asection *sreloc;
2834
2835                   /* Need a dynamic relocation to get the real function
2836                      address.  */
2837                   outrel.r_offset = _bfd_elf_section_offset (output_bfd,
2838                                                              info,
2839                                                              input_section,
2840                                                              rel->r_offset);
2841                   if (outrel.r_offset == (bfd_vma) -1
2842                       || outrel.r_offset == (bfd_vma) -2)
2843                     abort ();
2844
2845                   outrel.r_offset += (input_section->output_section->vma
2846                                       + input_section->output_offset);
2847
2848                   if (h->dynindx == -1
2849                       || h->forced_local
2850                       || bfd_link_executable (info))
2851                     {
2852                       /* This symbol is resolved locally.  */
2853                       outrel.r_info = ELF32_R_INFO (0, R_390_IRELATIVE);
2854                       outrel.r_addend = (h->root.u.def.value
2855                                          + h->root.u.def.section->output_section->vma
2856                                          + h->root.u.def.section->output_offset);
2857                     }
2858                   else
2859                     {
2860                       outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2861                       outrel.r_addend = 0;
2862                     }
2863
2864                   sreloc = htab->elf.irelifunc;
2865                   elf_append_rela (output_bfd, sreloc, &outrel);
2866
2867                   /* If this reloc is against an external symbol, we
2868                      do not want to fiddle with the addend.  Otherwise,
2869                      we need to include the symbol value so that it
2870                      becomes an addend for the dynamic reloc.  For an
2871                      internal symbol, we have updated addend.  */
2872                   continue;
2873                 }
2874             }
2875
2876           if ((input_section->flags & SEC_ALLOC) == 0)
2877             break;
2878
2879           if ((bfd_link_pic (info)
2880                && (h == NULL
2881                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2882                    || h->root.type != bfd_link_hash_undefweak)
2883                && ((r_type != R_390_PC16
2884                     && r_type != R_390_PC12DBL
2885                     && r_type != R_390_PC16DBL
2886                     && r_type != R_390_PC24DBL
2887                     && r_type != R_390_PC32DBL
2888                     && r_type != R_390_PC32)
2889                    || !SYMBOL_CALLS_LOCAL (info, h)))
2890               || (ELIMINATE_COPY_RELOCS
2891                   && !bfd_link_pic (info)
2892                   && h != NULL
2893                   && h->dynindx != -1
2894                   && !h->non_got_ref
2895                   && ((h->def_dynamic
2896                        && !h->def_regular)
2897                       || h->root.type == bfd_link_hash_undefweak
2898                       || h->root.type == bfd_link_hash_undefined)))
2899             {
2900               Elf_Internal_Rela outrel;
2901               bfd_boolean skip, relocate;
2902               asection *sreloc;
2903               bfd_byte *loc;
2904
2905               /* When generating a shared object, these relocations
2906                  are copied into the output file to be resolved at run
2907                  time.  */
2908
2909               skip = FALSE;
2910               relocate = FALSE;
2911
2912               outrel.r_offset =
2913                 _bfd_elf_section_offset (output_bfd, info, input_section,
2914                                          rel->r_offset);
2915               if (outrel.r_offset == (bfd_vma) -1)
2916                 skip = TRUE;
2917               else if (outrel.r_offset == (bfd_vma) -2)
2918                 skip = TRUE, relocate = TRUE;
2919               outrel.r_offset += (input_section->output_section->vma
2920                                   + input_section->output_offset);
2921
2922               if (skip)
2923                 memset (&outrel, 0, sizeof outrel);
2924               else if (h != NULL
2925                        && h->dynindx != -1
2926                        && (r_type == R_390_PC16
2927                            || r_type == R_390_PC12DBL
2928                            || r_type == R_390_PC16DBL
2929                            || r_type == R_390_PC24DBL
2930                            || r_type == R_390_PC32DBL
2931                            || r_type == R_390_PC32
2932                            || !bfd_link_pic (info)
2933                            || !SYMBOLIC_BIND (info, h)
2934                            || !h->def_regular))
2935                 {
2936                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2937                   outrel.r_addend = rel->r_addend;
2938                 }
2939               else
2940                 {
2941                   /* This symbol is local, or marked to become local.  */
2942                   outrel.r_addend = relocation + rel->r_addend;
2943                   if (r_type == R_390_32)
2944                     {
2945                       relocate = TRUE;
2946                       outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2947                     }
2948                   else
2949                     {
2950                       long sindx;
2951
2952                       if (bfd_is_abs_section (sec))
2953                         sindx = 0;
2954                       else if (sec == NULL || sec->owner == NULL)
2955                         {
2956                           bfd_set_error(bfd_error_bad_value);
2957                           return FALSE;
2958                         }
2959                       else
2960                         {
2961                           asection *osec;
2962
2963                           osec = sec->output_section;
2964                           sindx = elf_section_data (osec)->dynindx;
2965                           if (sindx == 0)
2966                             {
2967                               osec = htab->elf.text_index_section;
2968                               sindx = elf_section_data (osec)->dynindx;
2969                             }
2970                           BFD_ASSERT (sindx != 0);
2971
2972                           /* We are turning this relocation into one
2973                              against a section symbol, so subtract out
2974                              the output section's address but not the
2975                              offset of the input section in the output
2976                              section.  */
2977                           outrel.r_addend -= osec->vma;
2978                         }
2979                       outrel.r_info = ELF32_R_INFO (sindx, r_type);
2980                     }
2981                 }
2982
2983               sreloc = elf_section_data (input_section)->sreloc;
2984               if (sreloc == NULL)
2985                 abort ();
2986
2987               loc = sreloc->contents;
2988               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2989               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2990
2991               /* If this reloc is against an external symbol, we do
2992                  not want to fiddle with the addend.  Otherwise, we
2993                  need to include the symbol value so that it becomes
2994                  an addend for the dynamic reloc.  */
2995               if (! relocate)
2996                 continue;
2997             }
2998           break;
2999
3000           /* Relocations for tls literal pool entries.  */
3001         case R_390_TLS_IE32:
3002           if (bfd_link_pic (info))
3003             {
3004               Elf_Internal_Rela outrel;
3005               asection *sreloc;
3006               bfd_byte *loc;
3007
3008               outrel.r_offset = rel->r_offset
3009                                 + input_section->output_section->vma
3010                                 + input_section->output_offset;
3011               outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
3012               sreloc = elf_section_data (input_section)->sreloc;
3013               if (sreloc == NULL)
3014                 abort ();
3015               loc = sreloc->contents;
3016               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
3017               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3018             }
3019           /* Fall through.  */
3020
3021         case R_390_TLS_GD32:
3022         case R_390_TLS_GOTIE32:
3023           r_type = elf_s390_tls_transition (info, r_type, h == NULL);
3024           tls_type = GOT_UNKNOWN;
3025           if (h == NULL && local_got_offsets)
3026             tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
3027           else if (h != NULL)
3028             {
3029               tls_type = elf_s390_hash_entry(h)->tls_type;
3030               if (!bfd_link_pic (info)
3031                   && h->dynindx == -1
3032                   && tls_type >= GOT_TLS_IE)
3033                 r_type = R_390_TLS_LE32;
3034             }
3035           if (r_type == R_390_TLS_GD32 && tls_type >= GOT_TLS_IE)
3036             r_type = R_390_TLS_IE32;
3037
3038           if (r_type == R_390_TLS_LE32)
3039             {
3040               /* This relocation gets optimized away by the local exec
3041                  access optimization.  */
3042               BFD_ASSERT (! unresolved_reloc);
3043               bfd_put_32 (output_bfd, -tpoff (info, relocation),
3044                           contents + rel->r_offset);
3045               continue;
3046             }
3047
3048           if (htab->elf.sgot == NULL)
3049             abort ();
3050
3051           if (h != NULL)
3052             off = h->got.offset;
3053           else
3054             {
3055               if (local_got_offsets == NULL)
3056                 abort ();
3057
3058               off = local_got_offsets[r_symndx];
3059             }
3060
3061         emit_tls_relocs:
3062
3063           if ((off & 1) != 0)
3064             off &= ~1;
3065           else
3066             {
3067               Elf_Internal_Rela outrel;
3068               bfd_byte *loc;
3069               int dr_type, indx;
3070
3071               if (htab->elf.srelgot == NULL)
3072                 abort ();
3073
3074               outrel.r_offset = (htab->elf.sgot->output_section->vma
3075                                  + htab->elf.sgot->output_offset + off);
3076
3077               indx = h && h->dynindx != -1 ? h->dynindx : 0;
3078               if (r_type == R_390_TLS_GD32)
3079                 dr_type = R_390_TLS_DTPMOD;
3080               else
3081                 dr_type = R_390_TLS_TPOFF;
3082               if (dr_type == R_390_TLS_TPOFF && indx == 0)
3083                 outrel.r_addend = relocation - dtpoff_base (info);
3084               else
3085                 outrel.r_addend = 0;
3086               outrel.r_info = ELF32_R_INFO (indx, dr_type);
3087               loc = htab->elf.srelgot->contents;
3088               loc += htab->elf.srelgot->reloc_count++
3089                 * sizeof (Elf32_External_Rela);
3090               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3091
3092               if (r_type == R_390_TLS_GD32)
3093                 {
3094                   if (indx == 0)
3095                     {
3096                       BFD_ASSERT (! unresolved_reloc);
3097                       bfd_put_32 (output_bfd,
3098                                   relocation - dtpoff_base (info),
3099                                   htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3100                     }
3101                   else
3102                     {
3103                       outrel.r_info = ELF32_R_INFO (indx, R_390_TLS_DTPOFF);
3104                       outrel.r_offset += GOT_ENTRY_SIZE;
3105                       outrel.r_addend = 0;
3106                       htab->elf.srelgot->reloc_count++;
3107                       loc += sizeof (Elf32_External_Rela);
3108                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3109                     }
3110                 }
3111
3112               if (h != NULL)
3113                 h->got.offset |= 1;
3114               else
3115                 local_got_offsets[r_symndx] |= 1;
3116             }
3117
3118           if (off >= (bfd_vma) -2)
3119             abort ();
3120           if (r_type == ELF32_R_TYPE (rel->r_info))
3121             {
3122               relocation = htab->elf.sgot->output_offset + off;
3123               if (r_type == R_390_TLS_IE32 || r_type == R_390_TLS_IEENT)
3124                 relocation += htab->elf.sgot->output_section->vma;
3125               unresolved_reloc = FALSE;
3126             }
3127           else
3128             {
3129               bfd_put_32 (output_bfd, htab->elf.sgot->output_offset + off,
3130                           contents + rel->r_offset);
3131               continue;
3132             }
3133           break;
3134
3135         case R_390_TLS_GOTIE12:
3136         case R_390_TLS_GOTIE20:
3137         case R_390_TLS_IEENT:
3138           if (h == NULL)
3139             {
3140               if (local_got_offsets == NULL)
3141                 abort();
3142               off = local_got_offsets[r_symndx];
3143               if (bfd_link_pic (info))
3144                 goto emit_tls_relocs;
3145             }
3146           else
3147             {
3148               off = h->got.offset;
3149               tls_type = elf_s390_hash_entry(h)->tls_type;
3150               if (bfd_link_pic (info)
3151                   || h->dynindx != -1
3152                   || tls_type < GOT_TLS_IE)
3153                 goto emit_tls_relocs;
3154             }
3155
3156           if (htab->elf.sgot == NULL)
3157             abort ();
3158
3159           BFD_ASSERT (! unresolved_reloc);
3160           bfd_put_32 (output_bfd, -tpoff (info, relocation),
3161                       htab->elf.sgot->contents + off);
3162           relocation = htab->elf.sgot->output_offset + off;
3163           if (r_type == R_390_TLS_IEENT)
3164             relocation += htab->elf.sgot->output_section->vma;
3165           unresolved_reloc = FALSE;
3166           break;
3167
3168         case R_390_TLS_LDM32:
3169           if (! bfd_link_pic (info))
3170             /* The literal pool entry this relocation refers to gets ignored
3171                by the optimized code of the local exec model. Do nothing
3172                and the value will turn out zero.  */
3173             continue;
3174
3175           if (htab->elf.sgot == NULL)
3176             abort ();
3177
3178           off = htab->tls_ldm_got.offset;
3179           if (off & 1)
3180             off &= ~1;
3181           else
3182             {
3183               Elf_Internal_Rela outrel;
3184               bfd_byte *loc;
3185
3186               if (htab->elf.srelgot == NULL)
3187                 abort ();
3188
3189               outrel.r_offset = (htab->elf.sgot->output_section->vma
3190                                  + htab->elf.sgot->output_offset + off);
3191
3192               bfd_put_32 (output_bfd, 0,
3193                           htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3194               outrel.r_info = ELF32_R_INFO (0, R_390_TLS_DTPMOD);
3195               outrel.r_addend = 0;
3196               loc = htab->elf.srelgot->contents;
3197               loc += htab->elf.srelgot->reloc_count++
3198                 * sizeof (Elf32_External_Rela);
3199               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3200               htab->tls_ldm_got.offset |= 1;
3201             }
3202           relocation = htab->elf.sgot->output_offset + off;
3203           unresolved_reloc = FALSE;
3204           break;
3205
3206         case R_390_TLS_LE32:
3207           if (bfd_link_dll (info))
3208             {
3209               /* Linking a shared library with non-fpic code requires
3210                  a R_390_TLS_TPOFF relocation.  */
3211               Elf_Internal_Rela outrel;
3212               asection *sreloc;
3213               bfd_byte *loc;
3214               int indx;
3215
3216               outrel.r_offset = rel->r_offset
3217                                 + input_section->output_section->vma
3218                                 + input_section->output_offset;
3219               if (h != NULL && h->dynindx != -1)
3220                 indx = h->dynindx;
3221               else
3222                 indx = 0;
3223               outrel.r_info = ELF32_R_INFO (indx, R_390_TLS_TPOFF);
3224               if (indx == 0)
3225                 outrel.r_addend = relocation - dtpoff_base (info);
3226               else
3227                 outrel.r_addend = 0;
3228               sreloc = elf_section_data (input_section)->sreloc;
3229               if (sreloc == NULL)
3230                 abort ();
3231               loc = sreloc->contents;
3232               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
3233               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3234             }
3235           else
3236             {
3237               BFD_ASSERT (! unresolved_reloc);
3238               bfd_put_32 (output_bfd, -tpoff (info, relocation),
3239                           contents + rel->r_offset);
3240             }
3241           continue;
3242
3243         case R_390_TLS_LDO32:
3244           if (bfd_link_pic (info) || (input_section->flags & SEC_DEBUGGING))
3245             relocation -= dtpoff_base (info);
3246           else
3247             /* When converting LDO to LE, we must negate.  */
3248             relocation = -tpoff (info, relocation);
3249           break;
3250
3251           /* Relocations for tls instructions.  */
3252         case R_390_TLS_LOAD:
3253         case R_390_TLS_GDCALL:
3254         case R_390_TLS_LDCALL:
3255           tls_type = GOT_UNKNOWN;
3256           if (h == NULL && local_got_offsets)
3257             tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
3258           else if (h != NULL)
3259             tls_type = elf_s390_hash_entry(h)->tls_type;
3260
3261           if (tls_type == GOT_TLS_GD)
3262             continue;
3263
3264           if (r_type == R_390_TLS_LOAD)
3265             {
3266               if (!bfd_link_pic (info) && (h == NULL || h->dynindx == -1))
3267                 {
3268                   /* IE->LE transition. Four valid cases:
3269                      l %rx,0(0,%ry)    -> lr %rx,%ry + bcr 0,0
3270                      l %rx,0(%ry,0)    -> lr %rx,%ry + bcr 0,0
3271                      l %rx,0(%ry,%r12) -> lr %rx,%ry + bcr 0,0
3272                      l %rx,0(%r12,%ry) -> lr %rx,%ry + bcr 0,0 */
3273                   unsigned int insn, ry;
3274
3275                   insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3276                   ry = 0;
3277                   if ((insn & 0xff00f000) == 0x58000000)
3278                     /* l %rx,0(%ry,0) -> lr %rx,%ry + bcr 0,0  */
3279                     ry = (insn & 0x000f0000);
3280                   else if ((insn & 0xff0f0000) == 0x58000000)
3281                     /* l %rx,0(0,%ry) -> lr %rx,%ry + bcr 0,0  */
3282                     ry = (insn & 0x0000f000) << 4;
3283                   else if ((insn & 0xff00f000) == 0x5800c000)
3284                     /* l %rx,0(%ry,%r12) -> lr %rx,%ry + bcr 0,0  */
3285                     ry = (insn & 0x000f0000);
3286                   else if ((insn & 0xff0f0000) == 0x580c0000)
3287                     /* l %rx,0(%r12,%ry) -> lr %rx,%ry + bcr 0,0  */
3288                     ry = (insn & 0x0000f000) << 4;
3289                   else
3290                     invalid_tls_insn (input_bfd, input_section, rel);
3291                   insn = 0x18000700 | (insn & 0x00f00000) | ry;
3292                   bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3293                 }
3294             }
3295           else if (r_type == R_390_TLS_GDCALL)
3296             {
3297               unsigned int insn;
3298
3299               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3300               if ((insn & 0xff000fff) != 0x4d000000 &&
3301                   (insn & 0xffff0000) != 0xc0e50000 &&
3302                   (insn & 0xff000000) != 0x0d000000)
3303                 invalid_tls_insn (input_bfd, input_section, rel);
3304               if (!bfd_link_pic (info) && (h == NULL || h->dynindx == -1))
3305                 {
3306                   if ((insn & 0xff000000) == 0x0d000000)
3307                     {
3308                       /* GD->LE transition.
3309                          basr rx, ry -> nopr r7 */
3310                       insn = 0x07070000 | (insn & 0xffff);
3311                     }
3312                   else if ((insn & 0xff000000) == 0x4d000000)
3313                     {
3314                       /* GD->LE transition.
3315                          bas %r14,0(%rx,%r13) -> bc 0,0  */
3316                       insn = 0x47000000;
3317                     }
3318                   else
3319                     {
3320                       /* GD->LE transition.
3321                          brasl %r14,_tls_get_offset@plt -> brcl 0,.  */
3322                       insn = 0xc0040000;
3323                       bfd_put_16 (output_bfd, 0x0000,
3324                                   contents + rel->r_offset + 4);
3325                     }
3326                 }
3327               else
3328                 {
3329                   /* If basr is used in the pic case to invoke
3330                      _tls_get_offset, something went wrong before.  */
3331                   if ((insn & 0xff000000) == 0x0d000000)
3332                     invalid_tls_insn (input_bfd, input_section, rel);
3333
3334                   if ((insn & 0xff000000) == 0x4d000000)
3335                     {
3336                       /* GD->IE transition.
3337                          bas %r14,0(%rx,%r13) -> l %r2,0(%r2,%r12)  */
3338                       insn = 0x5822c000;
3339                     }
3340                   else
3341                     {
3342                       /* GD->IE transition.
3343                          brasl %r14,__tls_get_addr@plt ->
3344                                 l %r2,0(%r2,%r12) ; bcr 0,0 */
3345                       insn = 0x5822c000;
3346                       bfd_put_16 (output_bfd, 0x0700,
3347                                   contents + rel->r_offset + 4);
3348                     }
3349                 }
3350               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3351             }
3352           else if (r_type == R_390_TLS_LDCALL)
3353             {
3354               if (!bfd_link_pic (info))
3355                 {
3356                   unsigned int insn;
3357
3358                   insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3359                   if ((insn & 0xff000fff) != 0x4d000000 &&
3360                       (insn & 0xffff0000) != 0xc0e50000 &&
3361                       (insn & 0xff000000) != 0x0d000000)
3362                     invalid_tls_insn (input_bfd, input_section, rel);
3363
3364                   if ((insn & 0xff000000) == 0x0d000000)
3365                     {
3366                       /* LD->LE transition.
3367                          basr rx, ry -> nopr r7 */
3368                       insn = 0x07070000 | (insn & 0xffff);
3369                     }
3370                   else if ((insn & 0xff000000) == 0x4d000000)
3371                     {
3372                       /* LD->LE transition.
3373                          bas %r14,0(%rx,%r13) -> bc 0,0  */
3374                       insn = 0x47000000;
3375                     }
3376                   else
3377                     {
3378                       /* LD->LE transition.
3379                          brasl %r14,__tls_get_offset@plt -> brcl 0,. */
3380                       insn = 0xc0040000;
3381                       bfd_put_16 (output_bfd, 0x0000,
3382                                   contents + rel->r_offset + 4);
3383                     }
3384                   bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3385                 }
3386             }
3387           continue;
3388
3389         default:
3390           break;
3391         }
3392
3393       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3394          because such sections are not SEC_ALLOC and thus ld.so will
3395          not process them.  */
3396       if (unresolved_reloc
3397           && !((input_section->flags & SEC_DEBUGGING) != 0
3398                && h->def_dynamic)
3399           && _bfd_elf_section_offset (output_bfd, info, input_section,
3400                                       rel->r_offset) != (bfd_vma) -1)
3401         _bfd_error_handler
3402           /* xgettext:c-format */
3403           (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3404            input_bfd,
3405            input_section,
3406            (long) rel->r_offset,
3407            howto->name,
3408            h->root.root.string);
3409
3410     do_relocation:
3411
3412       /* When applying a 24 bit reloc we need to start one byte
3413          earlier.  Otherwise the 32 bit get/put bfd operations might
3414          access a byte after the actual section.  */
3415       if (r_type == R_390_PC24DBL
3416           || r_type == R_390_PLT24DBL)
3417         rel->r_offset--;
3418
3419       if (r_type == R_390_20
3420           || r_type == R_390_GOT20
3421           || r_type == R_390_GOTPLT20
3422           || r_type == R_390_TLS_GOTIE20)
3423         {
3424           relocation += rel->r_addend;
3425           relocation = (relocation&0xfff) << 8 | (relocation&0xff000) >> 12;
3426           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3427                                         contents, rel->r_offset,
3428                                         relocation, 0);
3429         }
3430       else
3431         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3432                                       contents, rel->r_offset,
3433                                       relocation, rel->r_addend);
3434
3435       if (r != bfd_reloc_ok)
3436         {
3437           const char *name;
3438
3439           if (h != NULL)
3440             name = h->root.root.string;
3441           else
3442             {
3443               name = bfd_elf_string_from_elf_section (input_bfd,
3444                                                       symtab_hdr->sh_link,
3445                                                       sym->st_name);
3446               if (name == NULL)
3447                 return FALSE;
3448               if (*name == '\0')
3449                 name = bfd_section_name (input_bfd, sec);
3450             }
3451
3452           if (r == bfd_reloc_overflow)
3453             (*info->callbacks->reloc_overflow)
3454               (info, (h ? &h->root : NULL), name, howto->name,
3455                (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
3456           else
3457             {
3458               _bfd_error_handler
3459                 /* xgettext:c-format */
3460                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3461                  input_bfd, input_section,
3462                  (long) rel->r_offset, name, (int) r);
3463               return FALSE;
3464             }
3465         }
3466     }
3467
3468   return TRUE;
3469 }
3470
3471 /* Generate the PLT slots together with the dynamic relocations needed
3472    for IFUNC symbols.  */
3473
3474 static void
3475 elf_s390_finish_ifunc_symbol (bfd *output_bfd,
3476                               struct bfd_link_info *info,
3477                               struct elf_link_hash_entry *h,
3478                               struct elf_s390_link_hash_table *htab,
3479                               bfd_vma iplt_offset,
3480                               bfd_vma resolver_address)
3481 {
3482   bfd_vma iplt_index;
3483   bfd_vma got_offset;
3484   bfd_vma igotiplt_offset;
3485   Elf_Internal_Rela rela;
3486   bfd_byte *loc;
3487   asection *plt, *gotplt, *relplt;
3488   bfd_vma relative_offset;
3489
3490   if (htab->elf.iplt == NULL
3491       || htab->elf.igotplt == NULL
3492       || htab->elf.irelplt == NULL)
3493     abort ();
3494
3495   gotplt = htab->elf.igotplt;
3496   relplt = htab->elf.irelplt;
3497
3498   /* Index of the PLT slot within iplt section.  */
3499   iplt_index = iplt_offset / PLT_ENTRY_SIZE;
3500   plt = htab->elf.iplt;
3501   /* Offset into the igot.plt section.  */
3502   igotiplt_offset = iplt_index * GOT_ENTRY_SIZE;
3503   /* Offset into the got section.  */
3504   got_offset = igotiplt_offset + gotplt->output_offset;
3505
3506   /* S390 uses halfwords for relative branch calc!  */
3507   relative_offset = - (plt->output_offset +
3508                        (PLT_ENTRY_SIZE * iplt_index) + 18) / 2;
3509   /* If offset is > 32768, branch to a previous branch
3510      390 can only handle +-64 K jumps.  */
3511   if ( -32768 > (int) relative_offset )
3512     relative_offset
3513       = -(unsigned) (((65536 / PLT_ENTRY_SIZE - 1) * PLT_ENTRY_SIZE) / 2);
3514
3515   /* Fill in the entry in the procedure linkage table.  */
3516   if (!bfd_link_pic (info))
3517     {
3518       memcpy (plt->contents + iplt_offset, elf_s390_plt_entry,
3519               PLT_ENTRY_SIZE);
3520
3521       /* Adjust jump to the first plt entry.  */
3522       bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3523                   plt->contents + iplt_offset + 20);
3524
3525       /* Push the GOT offset field.  */
3526       bfd_put_32 (output_bfd,
3527                   (gotplt->output_section->vma
3528                    + got_offset),
3529                   plt->contents + iplt_offset + 24);
3530     }
3531   else if (got_offset < 4096)
3532     {
3533       /* The GOT offset is small enough to be used directly as
3534          displacement.  */
3535       memcpy (plt->contents + iplt_offset,
3536               elf_s390_plt_pic12_entry,
3537               PLT_ENTRY_SIZE);
3538
3539       /* Put in the GOT offset as displacement value.  The 0xc000
3540          value comes from the first word of the plt entry.  Look
3541          at the elf_s390_plt_pic16_entry content.  */
3542       bfd_put_16 (output_bfd, (bfd_vma)0xc000 | got_offset,
3543                   plt->contents + iplt_offset + 2);
3544
3545       /* Adjust the jump to the first plt entry.  */
3546       bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3547                   plt->contents + iplt_offset + 20);
3548     }
3549   else if (got_offset < 32768)
3550     {
3551       /* The GOT offset is too big for a displacement but small
3552          enough to be a signed 16 bit immediate value as it can be
3553          used in an lhi instruction.  */
3554       memcpy (plt->contents + iplt_offset,
3555               elf_s390_plt_pic16_entry,
3556               PLT_ENTRY_SIZE);
3557
3558       /* Put in the GOT offset for the lhi instruction.  */
3559       bfd_put_16 (output_bfd, (bfd_vma)got_offset,
3560                   plt->contents + iplt_offset + 2);
3561
3562       /* Adjust the jump to the first plt entry.  */
3563       bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3564                   plt->contents + iplt_offset + 20);
3565     }
3566   else
3567     {
3568       memcpy (plt->contents + iplt_offset,
3569               elf_s390_plt_pic_entry,
3570               PLT_ENTRY_SIZE);
3571
3572       /* Adjust the jump to the first plt entry.  */
3573       bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3574                   plt->contents + iplt_offset + 20);
3575
3576       /* Push the GOT offset field.  */
3577       bfd_put_32 (output_bfd, got_offset,
3578                   plt->contents + iplt_offset + 24);
3579     }
3580   /* Insert offset into  reloc. table here.  */
3581   bfd_put_32 (output_bfd, relplt->output_offset +
3582               iplt_index * RELA_ENTRY_SIZE,
3583               plt->contents + iplt_offset + 28);
3584
3585   /* Fill in the entry in the global offset table.
3586      Points to instruction after GOT offset.  */
3587   bfd_put_32 (output_bfd,
3588               (plt->output_section->vma
3589                + plt->output_offset
3590                + iplt_offset
3591                + 12),
3592               gotplt->contents + igotiplt_offset);
3593
3594   /* Fill in the entry in the .rela.plt section.  */
3595   rela.r_offset = gotplt->output_section->vma + got_offset;
3596
3597   if (!h
3598       || h->dynindx == -1
3599       || ((bfd_link_executable (info)
3600            || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
3601           && h->def_regular))
3602     {
3603       /* The symbol can be locally resolved.  */
3604       rela.r_info = ELF32_R_INFO (0, R_390_IRELATIVE);
3605       rela.r_addend = resolver_address;
3606     }
3607   else
3608     {
3609       rela.r_info = ELF32_R_INFO (h->dynindx, R_390_JMP_SLOT);
3610       rela.r_addend = 0;
3611     }
3612
3613   loc = relplt->contents + iplt_index * RELA_ENTRY_SIZE;
3614   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3615 }
3616
3617 /* Finish up dynamic symbol handling.  We set the contents of various
3618    dynamic sections here.  */
3619
3620 static bfd_boolean
3621 elf_s390_finish_dynamic_symbol (bfd *output_bfd,
3622                                 struct bfd_link_info *info,
3623                                 struct elf_link_hash_entry *h,
3624                                 Elf_Internal_Sym *sym)
3625 {
3626   struct elf_s390_link_hash_table *htab;
3627   struct elf_s390_link_hash_entry *eh = (struct elf_s390_link_hash_entry*)h;
3628
3629   htab = elf_s390_hash_table (info);
3630
3631   if (h->plt.offset != (bfd_vma) -1)
3632     {
3633       bfd_vma plt_index;
3634       bfd_vma got_offset;
3635       Elf_Internal_Rela rela;
3636       bfd_byte *loc;
3637       bfd_vma relative_offset;
3638
3639       /* This symbol has an entry in the procedure linkage table.  Set
3640          it up.  */
3641       if (s390_is_ifunc_symbol_p (h) && h->def_regular)
3642         {
3643           elf_s390_finish_ifunc_symbol (output_bfd, info, h,
3644             htab, h->plt.offset,
3645             eh->ifunc_resolver_address +
3646             eh->ifunc_resolver_section->output_offset +
3647             eh->ifunc_resolver_section->output_section->vma);
3648           /* Do not return yet.  Handling of explicit GOT slots of
3649              IFUNC symbols is below.  */
3650         }
3651       else
3652         {
3653           if (h->dynindx == -1
3654               || htab->elf.splt == NULL
3655               || htab->elf.sgotplt == NULL
3656               || htab->elf.srelplt == NULL)
3657             abort ();
3658
3659           /* Calc. index no.
3660              Current offset - size first entry / entry size.  */
3661           plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3662
3663           /* Offset in GOT is PLT index plus GOT headers(3) times 4,
3664              addr & GOT addr.  */
3665           got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
3666
3667           /* S390 uses halfwords for relative branch calc!  */
3668           relative_offset = - ((PLT_FIRST_ENTRY_SIZE +
3669                                 (PLT_ENTRY_SIZE * plt_index) + 18) / 2);
3670           /* If offset is > 32768, branch to a previous branch
3671              390 can only handle +-64 K jumps.  */
3672           if ( -32768 > (int) relative_offset )
3673             relative_offset
3674               = -(unsigned) (((65536 / PLT_ENTRY_SIZE - 1) * PLT_ENTRY_SIZE) / 2);
3675
3676           /* Fill in the entry in the procedure linkage table.  */
3677           if (!bfd_link_pic (info))
3678             {
3679               memcpy (htab->elf.splt->contents + h->plt.offset, elf_s390_plt_entry,
3680                       PLT_ENTRY_SIZE);
3681
3682               /* Adjust jump to the first plt entry.  */
3683               bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3684                           htab->elf.splt->contents + h->plt.offset + 20);
3685
3686               /* Push the GOT offset field.  */
3687               bfd_put_32 (output_bfd,
3688                           (htab->elf.sgotplt->output_section->vma
3689                            + htab->elf.sgotplt->output_offset
3690                            + got_offset),
3691                           htab->elf.splt->contents + h->plt.offset + 24);
3692             }
3693           else if (got_offset < 4096)
3694             {
3695               /* The GOT offset is small enough to be used directly as
3696                  displacement.  */
3697               memcpy (htab->elf.splt->contents + h->plt.offset,
3698                       elf_s390_plt_pic12_entry,
3699                       PLT_ENTRY_SIZE);
3700
3701               /* Put in the GOT offset as displacement value.  The 0xc000
3702                  value comes from the first word of the plt entry.  Look
3703                  at the elf_s390_plt_pic12_entry content.  */
3704               bfd_put_16 (output_bfd, (bfd_vma)0xc000 | got_offset,
3705                           htab->elf.splt->contents + h->plt.offset + 2);
3706
3707               /* Adjust the jump to the first plt entry.  */
3708               bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3709                           htab->elf.splt->contents + h->plt.offset + 20);
3710             }
3711           else if (got_offset < 32768)
3712             {
3713               /* The GOT offset is too big for a displacement but small
3714                  enough to be a signed 16 bit immediate value as it can be
3715                  used in an lhi instruction.  */
3716               memcpy (htab->elf.splt->contents + h->plt.offset,
3717                       elf_s390_plt_pic16_entry,
3718                       PLT_ENTRY_SIZE);
3719
3720               /* Put in the GOT offset for the lhi instruction.  */
3721               bfd_put_16 (output_bfd, (bfd_vma)got_offset,
3722                           htab->elf.splt->contents + h->plt.offset + 2);
3723
3724               /* Adjust the jump to the first plt entry.  */
3725               bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3726                           htab->elf.splt->contents + h->plt.offset + 20);
3727             }
3728           else
3729             {
3730               memcpy (htab->elf.splt->contents + h->plt.offset,
3731                       elf_s390_plt_pic_entry,
3732                       PLT_ENTRY_SIZE);
3733
3734               /* Adjust the jump to the first plt entry.  */
3735               bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3736                           htab->elf.splt->contents + h->plt.offset + 20);
3737
3738               /* Push the GOT offset field.  */
3739               bfd_put_32 (output_bfd, got_offset,
3740                           htab->elf.splt->contents + h->plt.offset + 24);
3741             }
3742           /* Insert offset into  reloc. table here.  */
3743           bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
3744                       htab->elf.splt->contents + h->plt.offset + 28);
3745
3746           /* Fill in the entry in the global offset table.
3747              Points to instruction after GOT offset.  */
3748           bfd_put_32 (output_bfd,
3749                       (htab->elf.splt->output_section->vma
3750                        + htab->elf.splt->output_offset
3751                        + h->plt.offset
3752                        + 12),
3753                       htab->elf.sgotplt->contents + got_offset);
3754
3755           /* Fill in the entry in the .rela.plt section.  */
3756           rela.r_offset = (htab->elf.sgotplt->output_section->vma
3757                            + htab->elf.sgotplt->output_offset
3758                            + got_offset);
3759           rela.r_info = ELF32_R_INFO (h->dynindx, R_390_JMP_SLOT);
3760           rela.r_addend = 0;
3761           loc = htab->elf.srelplt->contents + plt_index * sizeof (Elf32_External_Rela);
3762           bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3763
3764           if (!h->def_regular)
3765             {
3766               /* Mark the symbol as undefined, rather than as defined in
3767                  the .plt section.  Leave the value alone.  This is a clue
3768                  for the dynamic linker, to make function pointer
3769                  comparisons work between an application and shared
3770                  library.  */
3771               sym->st_shndx = SHN_UNDEF;
3772             }
3773         }
3774     }
3775
3776   if (h->got.offset != (bfd_vma) -1
3777       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_GD
3778       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE
3779       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE_NLT)
3780     {
3781       Elf_Internal_Rela rela;
3782       bfd_byte *loc;
3783
3784       /* This symbol has an entry in the global offset table.  Set it
3785          up.  */
3786
3787       if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
3788         abort ();
3789
3790       rela.r_offset = (htab->elf.sgot->output_section->vma
3791                        + htab->elf.sgot->output_offset
3792                        + (h->got.offset &~ (bfd_vma) 1));
3793
3794       /* If this is a static link, or it is a -Bsymbolic link and the
3795          symbol is defined locally or was forced to be local because
3796          of a version file, we just want to emit a RELATIVE reloc.
3797          The entry in the global offset table will already have been
3798          initialized in the relocate_section function.  */
3799       if (h->def_regular && s390_is_ifunc_symbol_p (h))
3800         {
3801           if (bfd_link_pic (info))
3802             {
3803               /* An explicit GOT slot usage needs GLOB_DAT.  If the
3804                  symbol references local the implicit got.iplt slot
3805                  will be used and the IRELATIVE reloc has been created
3806                  above.  */
3807               goto do_glob_dat;
3808             }
3809           else
3810             {
3811               /* For non-shared objects explicit GOT slots must be
3812                  filled with the PLT slot address for pointer
3813                  equality reasons.  */
3814               bfd_put_32 (output_bfd, (htab->elf.iplt->output_section->vma
3815                                        + htab->elf.iplt->output_offset
3816                                        + h->plt.offset),
3817                           htab->elf.sgot->contents + h->got.offset);
3818               return TRUE;
3819             }
3820         }
3821       else if (bfd_link_pic (info)
3822                && SYMBOL_REFERENCES_LOCAL (info, h))
3823         {
3824           /* If this is a static link, or it is a -Bsymbolic link and
3825              the symbol is defined locally or was forced to be local
3826              because of a version file, we just want to emit a
3827              RELATIVE reloc.  The entry in the global offset table
3828              will already have been initialized in the
3829              relocate_section function.  */
3830           if (!h->def_regular)
3831             return FALSE;
3832           BFD_ASSERT((h->got.offset & 1) != 0);
3833           rela.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
3834           rela.r_addend = (h->root.u.def.value
3835                            + h->root.u.def.section->output_section->vma
3836                            + h->root.u.def.section->output_offset);
3837         }
3838       else
3839         {
3840           BFD_ASSERT((h->got.offset & 1) == 0);
3841         do_glob_dat:
3842           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->elf.sgot->contents + h->got.offset);
3843           rela.r_info = ELF32_R_INFO (h->dynindx, R_390_GLOB_DAT);
3844           rela.r_addend = 0;
3845         }
3846
3847       loc = htab->elf.srelgot->contents;
3848       loc += htab->elf.srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
3849       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3850     }
3851
3852   if (h->needs_copy)
3853     {
3854       Elf_Internal_Rela rela;
3855       bfd_byte *loc;
3856
3857       /* This symbols needs a copy reloc.  Set it up.  */
3858
3859       if (h->dynindx == -1
3860           || (h->root.type != bfd_link_hash_defined
3861               && h->root.type != bfd_link_hash_defweak)
3862           || htab->srelbss == NULL)
3863         abort ();
3864
3865       rela.r_offset = (h->root.u.def.value
3866                        + h->root.u.def.section->output_section->vma
3867                        + h->root.u.def.section->output_offset);
3868       rela.r_info = ELF32_R_INFO (h->dynindx, R_390_COPY);
3869       rela.r_addend = 0;
3870       loc = htab->srelbss->contents;
3871       loc += htab->srelbss->reloc_count++ * sizeof (Elf32_External_Rela);
3872       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3873     }
3874
3875   /* Mark some specially defined symbols as absolute.  */
3876   if (h == htab->elf.hdynamic
3877       || h == htab->elf.hgot
3878       || h == htab->elf.hplt)
3879     sym->st_shndx = SHN_ABS;
3880
3881   return TRUE;
3882 }
3883
3884 /* Used to decide how to sort relocs in an optimal manner for the
3885    dynamic linker, before writing them out.  */
3886
3887 static enum elf_reloc_type_class
3888 elf_s390_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
3889                            const asection *rel_sec ATTRIBUTE_UNUSED,
3890                            const Elf_Internal_Rela *rela)
3891 {
3892   bfd *abfd = info->output_bfd;
3893   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3894   struct elf_s390_link_hash_table *htab = elf_s390_hash_table (info);
3895   unsigned long r_symndx = ELF32_R_SYM (rela->r_info);
3896   Elf_Internal_Sym sym;
3897
3898   if (htab->elf.dynsym == NULL
3899       || !bed->s->swap_symbol_in (abfd,
3900                                   (htab->elf.dynsym->contents
3901                                    + r_symndx * bed->s->sizeof_sym),
3902                                   0, &sym))
3903     abort ();
3904
3905   /* Check relocation against STT_GNU_IFUNC symbol.  */
3906   if (ELF_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
3907     return reloc_class_ifunc;
3908
3909   switch ((int) ELF32_R_TYPE (rela->r_info))
3910     {
3911     case R_390_RELATIVE:
3912       return reloc_class_relative;
3913     case R_390_JMP_SLOT:
3914       return reloc_class_plt;
3915     case R_390_COPY:
3916       return reloc_class_copy;
3917     default:
3918       return reloc_class_normal;
3919     }
3920 }
3921
3922 /* Finish up the dynamic sections.  */
3923
3924 static bfd_boolean
3925 elf_s390_finish_dynamic_sections (bfd *output_bfd,
3926                                   struct bfd_link_info *info)
3927 {
3928   struct elf_s390_link_hash_table *htab;
3929   bfd *dynobj;
3930   asection *sdyn;
3931   bfd *ibfd;
3932   unsigned int i;
3933
3934   htab = elf_s390_hash_table (info);
3935   dynobj = htab->elf.dynobj;
3936   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3937
3938   if (htab->elf.dynamic_sections_created)
3939     {
3940       Elf32_External_Dyn *dyncon, *dynconend;
3941
3942       if (sdyn == NULL || htab->elf.sgot == NULL)
3943         abort ();
3944
3945       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3946       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3947       for (; dyncon < dynconend; dyncon++)
3948         {
3949           Elf_Internal_Dyn dyn;
3950           asection *s;
3951
3952           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3953
3954           switch (dyn.d_tag)
3955             {
3956             default:
3957               continue;
3958
3959             case DT_PLTGOT:
3960               s = htab->elf.sgotplt;
3961               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3962               break;
3963
3964             case DT_JMPREL:
3965               s = htab->elf.srelplt;
3966               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3967               break;
3968
3969             case DT_PLTRELSZ:
3970               dyn.d_un.d_val = htab->elf.srelplt->size + htab->elf.irelplt->size;
3971               break;
3972             }
3973
3974           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3975         }
3976
3977       /* Fill in the special first entry in the procedure linkage table.  */
3978       if (htab->elf.splt && htab->elf.splt->size > 0)
3979         {
3980           memset (htab->elf.splt->contents, 0, PLT_FIRST_ENTRY_SIZE);
3981           if (bfd_link_pic (info))
3982             {
3983               memcpy (htab->elf.splt->contents, elf_s390_plt_pic_first_entry,
3984                       PLT_FIRST_ENTRY_SIZE);
3985             }
3986           else
3987             {
3988               memcpy (htab->elf.splt->contents, elf_s390_plt_first_entry,
3989                       PLT_FIRST_ENTRY_SIZE);
3990               bfd_put_32 (output_bfd,
3991                           htab->elf.sgotplt->output_section->vma
3992                           + htab->elf.sgotplt->output_offset,
3993                           htab->elf.splt->contents + 24);
3994             }
3995           elf_section_data (htab->elf.splt->output_section)
3996             ->this_hdr.sh_entsize = 4;
3997         }
3998
3999     }
4000
4001   if (htab->elf.sgotplt)
4002     {
4003       /* Fill in the first three entries in the global offset table.  */
4004       if (htab->elf.sgotplt->size > 0)
4005         {
4006           bfd_put_32 (output_bfd,
4007                       (sdyn == NULL ? (bfd_vma) 0
4008                        : sdyn->output_section->vma + sdyn->output_offset),
4009                       htab->elf.sgotplt->contents);
4010           /* One entry for shared object struct ptr.  */
4011           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + 4);
4012           /* One entry for _dl_runtime_resolve.  */
4013           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + 8);
4014         }
4015
4016       elf_section_data (htab->elf.sgotplt->output_section)
4017         ->this_hdr.sh_entsize = 4;
4018     }
4019   /* Finish dynamic symbol for local IFUNC symbols.  */
4020   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
4021     {
4022       struct plt_entry *local_plt;
4023       Elf_Internal_Sym *isym;
4024       Elf_Internal_Shdr *symtab_hdr;
4025
4026       symtab_hdr = &elf_symtab_hdr (ibfd);
4027
4028       local_plt = elf_s390_local_plt (ibfd);
4029       if (local_plt != NULL)
4030         for (i = 0; i < symtab_hdr->sh_info; i++)
4031           {
4032             if (local_plt[i].plt.offset != (bfd_vma) -1)
4033               {
4034                 asection *sec = local_plt[i].sec;
4035                 isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, i);
4036                 if (isym == NULL)
4037                   return FALSE;
4038
4039                 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
4040                   elf_s390_finish_ifunc_symbol (output_bfd, info, NULL, htab,
4041                                                 local_plt[i].plt.offset,
4042                                                 isym->st_value
4043                                                 + sec->output_section->vma
4044                                                 + sec->output_offset);
4045
4046               }
4047           }
4048     }
4049   return TRUE;
4050 }
4051 \f
4052 /* Support for core dump NOTE sections.  */
4053
4054 static bfd_boolean
4055 elf_s390_grok_prstatus (bfd * abfd, Elf_Internal_Note * note)
4056 {
4057   int offset;
4058   unsigned int size;
4059
4060   switch (note->descsz)
4061     {
4062     default:
4063       return FALSE;
4064
4065     case 224:                   /* S/390 Linux.  */
4066       /* pr_cursig */
4067       elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
4068
4069       /* pr_pid */
4070       elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
4071
4072       /* pr_reg */
4073       offset = 72;
4074       size = 144;
4075       break;
4076     }
4077
4078   /* Make a ".reg/999" section.  */
4079   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
4080                                           size, note->descpos + offset);
4081 }
4082
4083 static bfd_boolean
4084 elf_s390_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
4085 {
4086   switch (note->descsz)
4087     {
4088     default:
4089       return FALSE;
4090
4091     case 124:                   /* sizeof(struct elf_prpsinfo) on s390 */
4092       elf_tdata (abfd)->core->pid
4093         = bfd_get_32 (abfd, note->descdata + 12);
4094       elf_tdata (abfd)->core->program
4095         = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
4096       elf_tdata (abfd)->core->command
4097         = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
4098       break;
4099     }
4100
4101   /* Note that for some reason, a spurious space is tacked
4102      onto the end of the args in some (at least one anyway)
4103      implementations, so strip it off if it exists.  */
4104
4105   {
4106     char *command = elf_tdata (abfd)->core->command;
4107     int n = strlen (command);
4108
4109     if (0 < n && command[n - 1] == ' ')
4110       command[n - 1] = '\0';
4111   }
4112
4113   return TRUE;
4114 }
4115
4116 static char *
4117 elf_s390_write_core_note (bfd *abfd, char *buf, int *bufsiz,
4118                           int note_type, ...)
4119 {
4120   va_list ap;
4121
4122   switch (note_type)
4123     {
4124     default:
4125       return NULL;
4126
4127     case NT_PRPSINFO:
4128       {
4129         char data[124] = { 0 };
4130         const char *fname, *psargs;
4131
4132         va_start (ap, note_type);
4133         fname = va_arg (ap, const char *);
4134         psargs = va_arg (ap, const char *);
4135         va_end (ap);
4136
4137         strncpy (data + 28, fname, 16);
4138         strncpy (data + 44, psargs, 80);
4139         return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
4140                                    &data, sizeof (data));
4141       }
4142
4143     case NT_PRSTATUS:
4144       {
4145         char data[224] = { 0 };
4146         long pid;
4147         int cursig;
4148         const void *gregs;
4149
4150         va_start (ap, note_type);
4151         pid = va_arg (ap, long);
4152         cursig = va_arg (ap, int);
4153         gregs = va_arg (ap, const void *);
4154         va_end (ap);
4155
4156         bfd_put_16 (abfd, cursig, data + 12);
4157         bfd_put_32 (abfd, pid, data + 24);
4158         memcpy (data + 72, gregs, 144);
4159         return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
4160                                    &data, sizeof (data));
4161       }
4162     }
4163   /* NOTREACHED */
4164 }
4165 \f
4166 /* Return address for Ith PLT stub in section PLT, for relocation REL
4167    or (bfd_vma) -1 if it should not be included.  */
4168
4169 static bfd_vma
4170 elf_s390_plt_sym_val (bfd_vma i, const asection *plt,
4171                       const arelent *rel ATTRIBUTE_UNUSED)
4172 {
4173   return plt->vma + PLT_FIRST_ENTRY_SIZE + i * PLT_ENTRY_SIZE;
4174 }
4175
4176 /* Merge backend specific data from an object file to the output
4177    object file when linking.  */
4178
4179 static bfd_boolean
4180 elf32_s390_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
4181 {
4182   bfd *obfd = info->output_bfd;
4183
4184   if (!is_s390_elf (ibfd) || !is_s390_elf (obfd))
4185     return TRUE;
4186
4187   if (!elf_s390_merge_obj_attributes (ibfd, info))
4188     return FALSE;
4189
4190   elf_elfheader (obfd)->e_flags |= elf_elfheader (ibfd)->e_flags;
4191   return TRUE;
4192 }
4193
4194
4195 #define TARGET_BIG_SYM  s390_elf32_vec
4196 #define TARGET_BIG_NAME "elf32-s390"
4197 #define ELF_ARCH        bfd_arch_s390
4198 #define ELF_TARGET_ID   S390_ELF_DATA
4199 #define ELF_MACHINE_CODE EM_S390
4200 #define ELF_MACHINE_ALT1 EM_S390_OLD
4201 #define ELF_MAXPAGESIZE 0x1000
4202
4203 #define elf_backend_can_gc_sections     1
4204 #define elf_backend_can_refcount        1
4205 #define elf_backend_want_got_plt        1
4206 #define elf_backend_plt_readonly        1
4207 #define elf_backend_want_plt_sym        0
4208 #define elf_backend_got_header_size     12
4209 #define elf_backend_rela_normal         1
4210
4211 #define elf_info_to_howto                     elf_s390_info_to_howto
4212
4213 #define bfd_elf32_bfd_is_local_label_name     elf_s390_is_local_label_name
4214 #define bfd_elf32_bfd_link_hash_table_create  elf_s390_link_hash_table_create
4215 #define bfd_elf32_bfd_reloc_type_lookup       elf_s390_reloc_type_lookup
4216 #define bfd_elf32_bfd_reloc_name_lookup elf_s390_reloc_name_lookup
4217
4218 #define bfd_elf32_bfd_merge_private_bfd_data  elf32_s390_merge_private_bfd_data
4219
4220 #define elf_backend_adjust_dynamic_symbol     elf_s390_adjust_dynamic_symbol
4221 #define elf_backend_check_relocs              elf_s390_check_relocs
4222 #define elf_backend_copy_indirect_symbol      elf_s390_copy_indirect_symbol
4223 #define elf_backend_create_dynamic_sections   elf_s390_create_dynamic_sections
4224 #define elf_backend_finish_dynamic_sections   elf_s390_finish_dynamic_sections
4225 #define elf_backend_finish_dynamic_symbol     elf_s390_finish_dynamic_symbol
4226 #define elf_backend_gc_mark_hook              elf_s390_gc_mark_hook
4227 #define elf_backend_gc_sweep_hook             elf_s390_gc_sweep_hook
4228 #define elf_backend_reloc_type_class          elf_s390_reloc_type_class
4229 #define elf_backend_relocate_section          elf_s390_relocate_section
4230 #define elf_backend_size_dynamic_sections     elf_s390_size_dynamic_sections
4231 #define elf_backend_init_index_section        _bfd_elf_init_1_index_section
4232 #define elf_backend_grok_prstatus             elf_s390_grok_prstatus
4233 #define elf_backend_grok_psinfo               elf_s390_grok_psinfo
4234 #define elf_backend_write_core_note           elf_s390_write_core_note
4235 #define elf_backend_plt_sym_val               elf_s390_plt_sym_val
4236 #define elf_backend_add_symbol_hook           elf_s390_add_symbol_hook
4237 #define elf_backend_sort_relocs_p             elf_s390_elf_sort_relocs_p
4238
4239 #define bfd_elf32_mkobject              elf_s390_mkobject
4240 #define elf_backend_object_p            elf_s390_object_p
4241
4242 #include "elf32-target.h"