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