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