bfd/elf32-s390.c

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