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