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