bfd/elf32-s390.c

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