bfd/elf32-s390.c

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