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