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_GOTPLT12:
2353                 case R_390_GOTPLT16:
2354                 case R_390_GOTPLT20:
2355                 case R_390_GOTPLT32:
2356                 case R_390_GOTPLTENT:
2357                 case R_390_GOT12:
2358                 case R_390_GOT16:
2359                 case R_390_GOT20:
2360                 case R_390_GOT32:
2361                 case R_390_GOTENT:
2362                   {
2363                     /* Write the PLT slot address into the GOT slot.  */
2364                     bfd_put_32 (output_bfd, relocation,
2365                                 htab->elf.sgot->contents +
2366                                 local_got_offsets[r_symndx]);
2367                     relocation = (local_got_offsets[r_symndx] +
2368                                   htab->elf.sgot->output_offset);
2369
2370                     if (r_type == R_390_GOTENT || r_type == R_390_GOTPLTENT)
2371                       relocation += htab->elf.sgot->output_section->vma;
2372                     break;
2373                   }
2374                 default:
2375                   break;
2376                 }
2377               /* The output section is needed later in
2378                  finish_dynamic_section when creating the dynamic
2379                  relocation.  */
2380               local_plt[r_symndx].sec = sec;
2381               goto do_relocation;
2382             }
2383           else
2384             relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2385         }
2386       else
2387         {
2388           bfd_boolean warned ATTRIBUTE_UNUSED;
2389
2390           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2391                                    r_symndx, symtab_hdr, sym_hashes,
2392                                    h, sec, relocation,
2393                                    unresolved_reloc, warned);
2394         }
2395
2396       if (sec != NULL && discarded_section (sec))
2397         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2398                                          rel, 1, relend, howto, 0, contents);
2399
2400       if (info->relocatable)
2401         continue;
2402
2403       switch (r_type)
2404         {
2405         case R_390_GOTPLT12:
2406         case R_390_GOTPLT16:
2407         case R_390_GOTPLT20:
2408         case R_390_GOTPLT32:
2409         case R_390_GOTPLTENT:
2410           /* There are three cases for a GOTPLT relocation. 1) The
2411              relocation is against the jump slot entry of a plt that
2412              will get emitted to the output file. 2) The relocation
2413              is against the jump slot of a plt entry that has been
2414              removed. elf_s390_adjust_gotplt has created a GOT entry
2415              as replacement. 3) The relocation is against a local symbol.
2416              Cases 2) and 3) are the same as the GOT relocation code
2417              so we just have to test for case 1 and fall through for
2418              the other two.  */
2419           if (h != NULL && h->plt.offset != (bfd_vma) -1)
2420             {
2421               bfd_vma plt_index;
2422
2423               if (s390_is_ifunc_symbol_p (h))
2424                 {
2425                   plt_index = h->plt.offset / PLT_ENTRY_SIZE;
2426                   relocation = (plt_index * GOT_ENTRY_SIZE +
2427                                 htab->elf.igotplt->output_offset);
2428                   if (r_type == R_390_GOTPLTENT)
2429                     relocation += htab->elf.igotplt->output_section->vma;
2430                 }
2431               else
2432                 {
2433                   /* Calc. index no.
2434                      Current offset - size first entry / entry size.  */
2435                   plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) /
2436                     PLT_ENTRY_SIZE;
2437
2438                   /* Offset in GOT is PLT index plus GOT headers(3)
2439                      times 4, addr & GOT addr.  */
2440                   relocation = (plt_index + 3) * GOT_ENTRY_SIZE;
2441                   if (r_type == R_390_GOTPLTENT)
2442                     relocation += htab->elf.sgot->output_section->vma;
2443                 }
2444               unresolved_reloc = FALSE;
2445
2446             }
2447           /* Fall through.  */
2448
2449         case R_390_GOT12:
2450         case R_390_GOT16:
2451         case R_390_GOT20:
2452         case R_390_GOT32:
2453         case R_390_GOTENT:
2454           /* Relocation is to the entry for this symbol in the global
2455              offset table.  */
2456           if (base_got == NULL)
2457             abort ();
2458
2459           if (h != NULL)
2460             {
2461               bfd_boolean dyn;
2462
2463               off = h->got.offset;
2464               dyn = htab->elf.dynamic_sections_created;
2465
2466               if (s390_is_ifunc_symbol_p (h))
2467                 {
2468                   BFD_ASSERT (h->plt.offset != (bfd_vma) -1);
2469                   if (off == (bfd_vma)-1)
2470                     {
2471                       /* No explicit GOT usage so redirect to the
2472                          got.iplt slot.  */
2473                       base_got = htab->elf.igotplt;
2474                       off = h->plt.offset / PLT_ENTRY_SIZE * GOT_ENTRY_SIZE;
2475                     }
2476                   else
2477                     {
2478                       /* Explicit GOT slots must contain the address
2479                          of the PLT slot. This will be handled in
2480                          finish_dynamic_symbol.  */
2481                     }
2482                 }
2483               else if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2484                        || (info->shared
2485                            && SYMBOL_REFERENCES_LOCAL (info, h))
2486                        || (ELF_ST_VISIBILITY (h->other)
2487                            && h->root.type == bfd_link_hash_undefweak))
2488
2489                 {
2490                   /* This is actually a static link, or it is a
2491                      -Bsymbolic link and the symbol is defined
2492                      locally, or the symbol was forced to be local
2493                      because of a version file.  We must initialize
2494                      this entry in the global offset table.  Since the
2495                      offset must always be a multiple of 2, we use the
2496                      least significant bit to record whether we have
2497                      initialized it already.
2498
2499                      When doing a dynamic link, we create a .rel.got
2500                      relocation entry to initialize the value.  This
2501                      is done in the finish_dynamic_symbol routine.  */
2502                   if ((off & 1) != 0)
2503                     off &= ~1;
2504                   else
2505                     {
2506                       bfd_put_32 (output_bfd, relocation,
2507                                   base_got->contents + off);
2508                       h->got.offset |= 1;
2509                     }
2510                 }
2511               else
2512                 unresolved_reloc = FALSE;
2513             }
2514           else
2515             {
2516               if (local_got_offsets == NULL)
2517                 abort ();
2518
2519               off = local_got_offsets[r_symndx];
2520
2521               /* The offset must always be a multiple of 4.  We use
2522                  the least significant bit to record whether we have
2523                  already generated the necessary reloc.  */
2524               if ((off & 1) != 0)
2525                 off &= ~1;
2526               else
2527                 {
2528                   bfd_put_32 (output_bfd, relocation,
2529                               htab->elf.sgot->contents + off);
2530
2531                   if (info->shared)
2532                     {
2533                       asection *srelgot;
2534                       Elf_Internal_Rela outrel;
2535                       bfd_byte *loc;
2536
2537                       srelgot = htab->elf.srelgot;
2538                       if (srelgot == NULL)
2539                         abort ();
2540
2541                       outrel.r_offset = (htab->elf.sgot->output_section->vma
2542                                          + htab->elf.sgot->output_offset
2543                                          + off);
2544                       outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2545                       outrel.r_addend = relocation;
2546                       loc = srelgot->contents;
2547                       loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
2548                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2549                     }
2550
2551                   local_got_offsets[r_symndx] |= 1;
2552                 }
2553             }
2554
2555           if (off >= (bfd_vma) -2)
2556             abort ();
2557
2558           relocation = base_got->output_offset + off;
2559
2560           /* For @GOTENT the relocation is against the offset between
2561              the instruction and the symbols entry in the GOT and not
2562              between the start of the GOT and the symbols entry. We
2563              add the vma of the GOT to get the correct value.  */
2564           if (   r_type == R_390_GOTENT
2565               || r_type == R_390_GOTPLTENT)
2566             relocation += base_got->output_section->vma;
2567
2568           break;
2569
2570         case R_390_GOTOFF16:
2571         case R_390_GOTOFF32:
2572           /* Relocation is relative to the start of the global offset
2573              table.  */
2574
2575           /* Note that sgot->output_offset is not involved in this
2576              calculation.  We always want the start of .got.  If we
2577              defined _GLOBAL_OFFSET_TABLE in a different way, as is
2578              permitted by the ABI, we might have to change this
2579              calculation.  */
2580           relocation -= htab->elf.sgot->output_section->vma;
2581           break;
2582
2583         case R_390_GOTPC:
2584         case R_390_GOTPCDBL:
2585           /* Use global offset table as symbol value.  */
2586           relocation = htab->elf.sgot->output_section->vma;
2587           unresolved_reloc = FALSE;
2588           break;
2589
2590         case R_390_PLT16DBL:
2591         case R_390_PLT32DBL:
2592         case R_390_PLT32:
2593           /* Relocation is to the entry for this symbol in the
2594              procedure linkage table.  */
2595
2596           /* Resolve a PLT32 reloc against a local symbol directly,
2597              without using the procedure linkage table.  */
2598           if (h == NULL)
2599             break;
2600
2601           if (h->plt.offset == (bfd_vma) -1
2602               || (htab->elf.splt == NULL && htab->elf.iplt == NULL))
2603             {
2604               /* We didn't make a PLT entry for this symbol.  This
2605                  happens when statically linking PIC code, or when
2606                  using -Bsymbolic.  */
2607               break;
2608             }
2609
2610           if (s390_is_ifunc_symbol_p (h))
2611             relocation = (htab->elf.iplt->output_section->vma
2612                           + htab->elf.iplt->output_offset
2613                           + h->plt.offset);
2614           else
2615             relocation = (htab->elf.splt->output_section->vma
2616                           + htab->elf.splt->output_offset
2617                           + h->plt.offset);
2618           unresolved_reloc = FALSE;
2619           break;
2620
2621         case R_390_PLTOFF16:
2622         case R_390_PLTOFF32:
2623           /* Relocation is to the entry for this symbol in the
2624              procedure linkage table relative to the start of the GOT.  */
2625
2626           /* For local symbols or if we didn't make a PLT entry for
2627              this symbol resolve the symbol directly.  */
2628           if (   h == NULL
2629               || h->plt.offset == (bfd_vma) -1
2630               || htab->elf.splt == NULL)
2631             {
2632               relocation -= htab->elf.sgot->output_section->vma;
2633               break;
2634             }
2635
2636           if (s390_is_ifunc_symbol_p (h))
2637             relocation = (htab->elf.iplt->output_section->vma
2638                           + htab->elf.iplt->output_offset
2639                           + h->plt.offset
2640                           - htab->elf.sgot->output_section->vma);
2641           else
2642             relocation = (htab->elf.splt->output_section->vma
2643                           + htab->elf.splt->output_offset
2644                           + h->plt.offset
2645                           - htab->elf.sgot->output_section->vma);
2646           unresolved_reloc = FALSE;
2647           break;
2648
2649         case R_390_8:
2650         case R_390_16:
2651         case R_390_32:
2652         case R_390_PC16:
2653         case R_390_PC16DBL:
2654         case R_390_PC32DBL:
2655         case R_390_PC32:
2656           if (h != NULL
2657               && s390_is_ifunc_symbol_p (h)
2658               && h->def_regular)
2659             {
2660               if (!info->shared || !h->non_got_ref)
2661                 {
2662                   /* For a non-shared object STT_GNU_IFUNC symbol must
2663                      go through PLT.  */
2664                   relocation = (htab->elf.iplt->output_section->vma
2665                                 + htab->elf.iplt->output_offset
2666                                 + h ->plt.offset);
2667                   goto do_relocation;
2668                 }
2669               else
2670                 {
2671                   /* For shared objects a runtime relocation is needed.  */
2672
2673                   Elf_Internal_Rela outrel;
2674                   asection *sreloc;
2675
2676                   /* Need a dynamic relocation to get the real function
2677                      address.  */
2678                   outrel.r_offset = _bfd_elf_section_offset (output_bfd,
2679                                                              info,
2680                                                              input_section,
2681                                                              rel->r_offset);
2682                   if (outrel.r_offset == (bfd_vma) -1
2683                       || outrel.r_offset == (bfd_vma) -2)
2684                     abort ();
2685
2686                   outrel.r_offset += (input_section->output_section->vma
2687                                       + input_section->output_offset);
2688
2689                   if (h->dynindx == -1
2690                       || h->forced_local
2691                       || info->executable)
2692                     {
2693                       /* This symbol is resolved locally.  */
2694                       outrel.r_info = ELF32_R_INFO (0, R_390_IRELATIVE);
2695                       outrel.r_addend = (h->root.u.def.value
2696                                          + h->root.u.def.section->output_section->vma
2697                                          + h->root.u.def.section->output_offset);
2698                     }
2699                   else
2700                     {
2701                       outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2702                       outrel.r_addend = 0;
2703                     }
2704
2705                   sreloc = htab->elf.irelifunc;
2706                   elf_append_rela (output_bfd, sreloc, &outrel);
2707
2708                   /* If this reloc is against an external symbol, we
2709                      do not want to fiddle with the addend.  Otherwise,
2710                      we need to include the symbol value so that it
2711                      becomes an addend for the dynamic reloc.  For an
2712                      internal symbol, we have updated addend.  */
2713                   continue;
2714                 }
2715             }
2716
2717           if ((input_section->flags & SEC_ALLOC) == 0)
2718             break;
2719
2720           if ((info->shared
2721                && (h == NULL
2722                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2723                    || h->root.type != bfd_link_hash_undefweak)
2724                && ((r_type != R_390_PC16
2725                     && r_type != R_390_PC16DBL
2726                     && r_type != R_390_PC32DBL
2727                     && r_type != R_390_PC32)
2728                    || !SYMBOL_CALLS_LOCAL (info, h)))
2729               || (ELIMINATE_COPY_RELOCS
2730                   && !info->shared
2731                   && h != NULL
2732                   && h->dynindx != -1
2733                   && !h->non_got_ref
2734                   && ((h->def_dynamic
2735                        && !h->def_regular)
2736                       || h->root.type == bfd_link_hash_undefweak
2737                       || h->root.type == bfd_link_hash_undefined)))
2738             {
2739               Elf_Internal_Rela outrel;
2740               bfd_boolean skip, relocate;
2741               asection *sreloc;
2742               bfd_byte *loc;
2743
2744               /* When generating a shared object, these relocations
2745                  are copied into the output file to be resolved at run
2746                  time.  */
2747
2748               skip = FALSE;
2749               relocate = FALSE;
2750
2751               outrel.r_offset =
2752                 _bfd_elf_section_offset (output_bfd, info, input_section,
2753                                          rel->r_offset);
2754               if (outrel.r_offset == (bfd_vma) -1)
2755                 skip = TRUE;
2756               else if (outrel.r_offset == (bfd_vma) -2)
2757                 skip = TRUE, relocate = TRUE;
2758               outrel.r_offset += (input_section->output_section->vma
2759                                   + input_section->output_offset);
2760
2761               if (skip)
2762                 memset (&outrel, 0, sizeof outrel);
2763               else if (h != NULL
2764                        && h->dynindx != -1
2765                        && (r_type == R_390_PC16
2766                            || r_type == R_390_PC16DBL
2767                            || r_type == R_390_PC32DBL
2768                            || r_type == R_390_PC32
2769                            || !info->shared
2770                            || !SYMBOLIC_BIND (info, h)
2771                            || !h->def_regular))
2772                 {
2773                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2774                   outrel.r_addend = rel->r_addend;
2775                 }
2776               else
2777                 {
2778                   /* This symbol is local, or marked to become local.  */
2779                   outrel.r_addend = relocation + rel->r_addend;
2780                   if (r_type == R_390_32)
2781                     {
2782                       relocate = TRUE;
2783                       outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2784                     }
2785                   else
2786                     {
2787                       long sindx;
2788
2789                       if (bfd_is_abs_section (sec))
2790                         sindx = 0;
2791                       else if (sec == NULL || sec->owner == NULL)
2792                         {
2793                           bfd_set_error(bfd_error_bad_value);
2794                           return FALSE;
2795                         }
2796                       else
2797                         {
2798                           asection *osec;
2799
2800                           osec = sec->output_section;
2801                           sindx = elf_section_data (osec)->dynindx;
2802                           if (sindx == 0)
2803                             {
2804                               osec = htab->elf.text_index_section;
2805                               sindx = elf_section_data (osec)->dynindx;
2806                             }
2807                           BFD_ASSERT (sindx != 0);
2808
2809                           /* We are turning this relocation into one
2810                              against a section symbol, so subtract out
2811                              the output section's address but not the
2812                              offset of the input section in the output
2813                              section.  */
2814                           outrel.r_addend -= osec->vma;
2815                         }
2816                       outrel.r_info = ELF32_R_INFO (sindx, r_type);
2817                     }
2818                 }
2819
2820               sreloc = elf_section_data (input_section)->sreloc;
2821               if (sreloc == NULL)
2822                 abort ();
2823
2824               loc = sreloc->contents;
2825               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2826               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2827
2828               /* If this reloc is against an external symbol, we do
2829                  not want to fiddle with the addend.  Otherwise, we
2830                  need to include the symbol value so that it becomes
2831                  an addend for the dynamic reloc.  */
2832               if (! relocate)
2833                 continue;
2834             }
2835           break;
2836
2837           /* Relocations for tls literal pool entries.  */
2838         case R_390_TLS_IE32:
2839           if (info->shared)
2840             {
2841               Elf_Internal_Rela outrel;
2842               asection *sreloc;
2843               bfd_byte *loc;
2844
2845               outrel.r_offset = rel->r_offset
2846                                 + input_section->output_section->vma
2847                                 + input_section->output_offset;
2848               outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2849               sreloc = elf_section_data (input_section)->sreloc;
2850               if (sreloc == NULL)
2851                 abort ();
2852               loc = sreloc->contents;
2853               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2854               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2855             }
2856           /* Fall through.  */
2857
2858         case R_390_TLS_GD32:
2859         case R_390_TLS_GOTIE32:
2860           r_type = elf_s390_tls_transition (info, r_type, h == NULL);
2861           tls_type = GOT_UNKNOWN;
2862           if (h == NULL && local_got_offsets)
2863             tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
2864           else if (h != NULL)
2865             {
2866               tls_type = elf_s390_hash_entry(h)->tls_type;
2867               if (!info->shared && h->dynindx == -1 && tls_type >= GOT_TLS_IE)
2868                 r_type = R_390_TLS_LE32;
2869             }
2870           if (r_type == R_390_TLS_GD32 && tls_type >= GOT_TLS_IE)
2871             r_type = R_390_TLS_IE32;
2872
2873           if (r_type == R_390_TLS_LE32)
2874             {
2875               /* This relocation gets optimized away by the local exec
2876                  access optimization.  */
2877               BFD_ASSERT (! unresolved_reloc);
2878               bfd_put_32 (output_bfd, -tpoff (info, relocation),
2879                           contents + rel->r_offset);
2880               continue;
2881             }
2882
2883           if (htab->elf.sgot == NULL)
2884             abort ();
2885
2886           if (h != NULL)
2887             off = h->got.offset;
2888           else
2889             {
2890               if (local_got_offsets == NULL)
2891                 abort ();
2892
2893               off = local_got_offsets[r_symndx];
2894             }
2895
2896         emit_tls_relocs:
2897
2898           if ((off & 1) != 0)
2899             off &= ~1;
2900           else
2901             {
2902               Elf_Internal_Rela outrel;
2903               bfd_byte *loc;
2904               int dr_type, indx;
2905
2906               if (htab->elf.srelgot == NULL)
2907                 abort ();
2908
2909               outrel.r_offset = (htab->elf.sgot->output_section->vma
2910                                  + htab->elf.sgot->output_offset + off);
2911
2912               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2913               if (r_type == R_390_TLS_GD32)
2914                 dr_type = R_390_TLS_DTPMOD;
2915               else
2916                 dr_type = R_390_TLS_TPOFF;
2917               if (dr_type == R_390_TLS_TPOFF && indx == 0)
2918                 outrel.r_addend = relocation - dtpoff_base (info);
2919               else
2920                 outrel.r_addend = 0;
2921               outrel.r_info = ELF32_R_INFO (indx, dr_type);
2922               loc = htab->elf.srelgot->contents;
2923               loc += htab->elf.srelgot->reloc_count++
2924                 * sizeof (Elf32_External_Rela);
2925               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2926
2927               if (r_type == R_390_TLS_GD32)
2928                 {
2929                   if (indx == 0)
2930                     {
2931                       BFD_ASSERT (! unresolved_reloc);
2932                       bfd_put_32 (output_bfd,
2933                                   relocation - dtpoff_base (info),
2934                                   htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
2935                     }
2936                   else
2937                     {
2938                       outrel.r_info = ELF32_R_INFO (indx, R_390_TLS_DTPOFF);
2939                       outrel.r_offset += GOT_ENTRY_SIZE;
2940                       outrel.r_addend = 0;
2941                       htab->elf.srelgot->reloc_count++;
2942                       loc += sizeof (Elf32_External_Rela);
2943                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2944                     }
2945                 }
2946
2947               if (h != NULL)
2948                 h->got.offset |= 1;
2949               else
2950                 local_got_offsets[r_symndx] |= 1;
2951             }
2952
2953           if (off >= (bfd_vma) -2)
2954             abort ();
2955           if (r_type == ELF32_R_TYPE (rel->r_info))
2956             {
2957               relocation = htab->elf.sgot->output_offset + off;
2958               if (r_type == R_390_TLS_IE32 || r_type == R_390_TLS_IEENT)
2959                 relocation += htab->elf.sgot->output_section->vma;
2960               unresolved_reloc = FALSE;
2961             }
2962           else
2963             {
2964               bfd_put_32 (output_bfd, htab->elf.sgot->output_offset + off,
2965                           contents + rel->r_offset);
2966               continue;
2967             }
2968           break;
2969
2970         case R_390_TLS_GOTIE12:
2971         case R_390_TLS_GOTIE20:
2972         case R_390_TLS_IEENT:
2973           if (h == NULL)
2974             {
2975               if (local_got_offsets == NULL)
2976                 abort();
2977               off = local_got_offsets[r_symndx];
2978               if (info->shared)
2979                 goto emit_tls_relocs;
2980             }
2981           else
2982             {
2983               off = h->got.offset;
2984               tls_type = elf_s390_hash_entry(h)->tls_type;
2985               if (info->shared || h->dynindx != -1 || tls_type < GOT_TLS_IE)
2986                 goto emit_tls_relocs;
2987             }
2988
2989           if (htab->elf.sgot == NULL)
2990             abort ();
2991
2992           BFD_ASSERT (! unresolved_reloc);
2993           bfd_put_32 (output_bfd, -tpoff (info, relocation),
2994                       htab->elf.sgot->contents + off);
2995           relocation = htab->elf.sgot->output_offset + off;
2996           if (r_type == R_390_TLS_IEENT)
2997             relocation += htab->elf.sgot->output_section->vma;
2998           unresolved_reloc = FALSE;
2999           break;
3000
3001         case R_390_TLS_LDM32:
3002           if (! info->shared)
3003             /* The literal pool entry this relocation refers to gets ignored
3004                by the optimized code of the local exec model. Do nothing
3005                and the value will turn out zero.  */
3006             continue;
3007
3008           if (htab->elf.sgot == NULL)
3009             abort ();
3010
3011           off = htab->tls_ldm_got.offset;
3012           if (off & 1)
3013             off &= ~1;
3014           else
3015             {
3016               Elf_Internal_Rela outrel;
3017               bfd_byte *loc;
3018
3019               if (htab->elf.srelgot == NULL)
3020                 abort ();
3021
3022               outrel.r_offset = (htab->elf.sgot->output_section->vma
3023                                  + htab->elf.sgot->output_offset + off);
3024
3025               bfd_put_32 (output_bfd, 0,
3026                           htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3027               outrel.r_info = ELF32_R_INFO (0, R_390_TLS_DTPMOD);
3028               outrel.r_addend = 0;
3029               loc = htab->elf.srelgot->contents;
3030               loc += htab->elf.srelgot->reloc_count++
3031                 * sizeof (Elf32_External_Rela);
3032               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3033               htab->tls_ldm_got.offset |= 1;
3034             }
3035           relocation = htab->elf.sgot->output_offset + off;
3036           unresolved_reloc = FALSE;
3037           break;
3038
3039         case R_390_TLS_LE32:
3040           if (info->shared)
3041             {
3042               /* Linking a shared library with non-fpic code requires
3043                  a R_390_TLS_TPOFF relocation.  */
3044               Elf_Internal_Rela outrel;
3045               asection *sreloc;
3046               bfd_byte *loc;
3047               int indx;
3048
3049               outrel.r_offset = rel->r_offset
3050                                 + input_section->output_section->vma
3051                                 + input_section->output_offset;
3052               if (h != NULL && h->dynindx != -1)
3053                 indx = h->dynindx;
3054               else
3055                 indx = 0;
3056               outrel.r_info = ELF32_R_INFO (indx, R_390_TLS_TPOFF);
3057               if (indx == 0)
3058                 outrel.r_addend = relocation - dtpoff_base (info);
3059               else
3060                 outrel.r_addend = 0;
3061               sreloc = elf_section_data (input_section)->sreloc;
3062               if (sreloc == NULL)
3063                 abort ();
3064               loc = sreloc->contents;
3065               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
3066               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3067             }
3068           else
3069             {
3070               BFD_ASSERT (! unresolved_reloc);
3071               bfd_put_32 (output_bfd, -tpoff (info, relocation),
3072                           contents + rel->r_offset);
3073             }
3074           continue;
3075
3076         case R_390_TLS_LDO32:
3077           if (info->shared || (input_section->flags & SEC_DEBUGGING))
3078             relocation -= dtpoff_base (info);
3079           else
3080             /* When converting LDO to LE, we must negate.  */
3081             relocation = -tpoff (info, relocation);
3082           break;
3083
3084           /* Relocations for tls instructions.  */
3085         case R_390_TLS_LOAD:
3086         case R_390_TLS_GDCALL:
3087         case R_390_TLS_LDCALL:
3088           tls_type = GOT_UNKNOWN;
3089           if (h == NULL && local_got_offsets)
3090             tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
3091           else if (h != NULL)
3092             tls_type = elf_s390_hash_entry(h)->tls_type;
3093
3094           if (tls_type == GOT_TLS_GD)
3095             continue;
3096
3097           if (r_type == R_390_TLS_LOAD)
3098             {
3099               if (!info->shared && (h == NULL || h->dynindx == -1))
3100                 {
3101                   /* IE->LE transition. Four valid cases:
3102                      l %rx,0(0,%ry)    -> lr %rx,%ry + bcr 0,0
3103                      l %rx,0(%ry,0)    -> lr %rx,%ry + bcr 0,0
3104                      l %rx,0(%ry,%r12) -> lr %rx,%ry + bcr 0,0
3105                      l %rx,0(%r12,%ry) -> lr %rx,%ry + bcr 0,0 */
3106                   unsigned int insn, ry;
3107
3108                   insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3109                   ry = 0;
3110                   if ((insn & 0xff00f000) == 0x58000000)
3111                     /* l %rx,0(%ry,0) -> lr %rx,%ry + bcr 0,0  */
3112                     ry = (insn & 0x000f0000);
3113                   else if ((insn & 0xff0f0000) == 0x58000000)
3114                     /* l %rx,0(0,%ry) -> lr %rx,%ry + bcr 0,0  */
3115                     ry = (insn & 0x0000f000) << 4;
3116                   else if ((insn & 0xff00f000) == 0x5800c000)
3117                     /* l %rx,0(%ry,%r12) -> lr %rx,%ry + bcr 0,0  */
3118                     ry = (insn & 0x000f0000);
3119                   else if ((insn & 0xff0f0000) == 0x580c0000)
3120                     /* l %rx,0(%r12,%ry) -> lr %rx,%ry + bcr 0,0  */
3121                     ry = (insn & 0x0000f000) << 4;
3122                   else
3123                     invalid_tls_insn (input_bfd, input_section, rel);
3124                   insn = 0x18000700 | (insn & 0x00f00000) | ry;
3125                   bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3126                 }
3127             }
3128           else if (r_type == R_390_TLS_GDCALL)
3129             {
3130               unsigned int insn;
3131
3132               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3133               if ((insn & 0xff000fff) != 0x4d000000 &&
3134                   (insn & 0xffff0000) != 0xc0e50000 &&
3135                   (insn & 0xff000000) != 0x0d000000)
3136                 invalid_tls_insn (input_bfd, input_section, rel);
3137               if (!info->shared && (h == NULL || h->dynindx == -1))
3138                 {
3139                   if ((insn & 0xff000000) == 0x0d000000)
3140                     {
3141                       /* GD->LE transition.
3142                          basr rx, ry -> nopr r7 */
3143                       insn = 0x07070000 | (insn & 0xffff);
3144                     }
3145                   else if ((insn & 0xff000000) == 0x4d000000)
3146                     {
3147                       /* GD->LE transition.
3148                          bas %r14,0(%rx,%r13) -> bc 0,0  */
3149                       insn = 0x47000000;
3150                     }
3151                   else
3152                     {
3153                       /* GD->LE transition.
3154                          brasl %r14,_tls_get_offset@plt -> brcl 0,.  */
3155                       insn = 0xc0040000;
3156                       bfd_put_16 (output_bfd, 0x0000,
3157                                   contents + rel->r_offset + 4);
3158                     }
3159                 }
3160               else
3161                 {
3162                   /* If basr is used in the pic case to invoke
3163                      _tls_get_offset, something went wrong before.  */
3164                   if ((insn & 0xff000000) == 0x0d000000)
3165                     invalid_tls_insn (input_bfd, input_section, rel);
3166
3167                   if ((insn & 0xff000000) == 0x4d000000)
3168                     {
3169                       /* GD->IE transition.
3170                          bas %r14,0(%rx,%r13) -> l %r2,0(%r2,%r12)  */
3171                       insn = 0x5822c000;
3172                     }
3173                   else
3174                     {
3175                       /* GD->IE transition.
3176                          brasl %r14,__tls_get_addr@plt ->
3177                                 l %r2,0(%r2,%r12) ; bcr 0,0 */
3178                       insn = 0x5822c000;
3179                       bfd_put_16 (output_bfd, 0x0700,
3180                                   contents + rel->r_offset + 4);
3181                     }
3182                 }
3183               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3184             }
3185           else if (r_type == R_390_TLS_LDCALL)
3186             {
3187               if (!info->shared)
3188                 {
3189                   unsigned int insn;
3190
3191                   insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3192                   if ((insn & 0xff000fff) != 0x4d000000 &&
3193                       (insn & 0xffff0000) != 0xc0e50000 &&
3194                       (insn & 0xff000000) != 0x0d000000)
3195                     invalid_tls_insn (input_bfd, input_section, rel);
3196
3197                   if ((insn & 0xff000000) == 0x0d000000)
3198                     {
3199                       /* LD->LE transition.
3200                          basr rx, ry -> nopr r7 */
3201                       insn = 0x07070000 | (insn & 0xffff);
3202                     }
3203                   else if ((insn & 0xff000000) == 0x4d000000)
3204                     {
3205                       /* LD->LE transition.
3206                          bas %r14,0(%rx,%r13) -> bc 0,0  */
3207                       insn = 0x47000000;
3208                     }
3209                   else
3210                     {
3211                       /* LD->LE transition.
3212                          brasl %r14,__tls_get_offset@plt -> brcl 0,. */
3213                       insn = 0xc0040000;
3214                       bfd_put_16 (output_bfd, 0x0000,
3215                                   contents + rel->r_offset + 4);
3216                     }
3217                   bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3218                 }
3219             }
3220           continue;
3221
3222         default:
3223           break;
3224         }
3225
3226       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3227          because such sections are not SEC_ALLOC and thus ld.so will
3228          not process them.  */
3229       if (unresolved_reloc
3230           && !((input_section->flags & SEC_DEBUGGING) != 0
3231                && h->def_dynamic)
3232           && _bfd_elf_section_offset (output_bfd, info, input_section,
3233                                       rel->r_offset) != (bfd_vma) -1)
3234         (*_bfd_error_handler)
3235           (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3236            input_bfd,
3237            input_section,
3238            (long) rel->r_offset,
3239            howto->name,
3240            h->root.root.string);
3241
3242     do_relocation:
3243
3244       if (r_type == R_390_20
3245           || r_type == R_390_GOT20
3246           || r_type == R_390_GOTPLT20
3247           || r_type == R_390_TLS_GOTIE20)
3248         {
3249           relocation += rel->r_addend;
3250           relocation = (relocation&0xfff) << 8 | (relocation&0xff000) >> 12;
3251           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3252                                         contents, rel->r_offset,
3253                                         relocation, 0);
3254         }
3255       else
3256         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3257                                       contents, rel->r_offset,
3258                                       relocation, rel->r_addend);
3259
3260       if (r != bfd_reloc_ok)
3261         {
3262           const char *name;
3263
3264           if (h != NULL)
3265             name = h->root.root.string;
3266           else
3267             {
3268               name = bfd_elf_string_from_elf_section (input_bfd,
3269                                                       symtab_hdr->sh_link,
3270                                                       sym->st_name);
3271               if (name == NULL)
3272                 return FALSE;
3273               if (*name == '\0')
3274                 name = bfd_section_name (input_bfd, sec);
3275             }
3276
3277           if (r == bfd_reloc_overflow)
3278             {
3279
3280               if (! ((*info->callbacks->reloc_overflow)
3281                      (info, (h ? &h->root : NULL), name, howto->name,
3282                       (bfd_vma) 0, input_bfd, input_section,
3283                       rel->r_offset)))
3284                 return FALSE;
3285             }
3286           else
3287             {
3288               (*_bfd_error_handler)
3289                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3290                  input_bfd, input_section,
3291                  (long) rel->r_offset, name, (int) r);
3292               return FALSE;
3293             }
3294         }
3295     }
3296
3297   return TRUE;
3298 }
3299
3300 /* Generate the PLT slots together with the dynamic relocations needed
3301    for IFUNC symbols.  */
3302
3303 static void
3304 elf_s390_finish_ifunc_symbol (bfd *output_bfd,
3305                               struct bfd_link_info *info,
3306                               struct elf_link_hash_entry *h,
3307                               struct elf_s390_link_hash_table *htab,
3308                               bfd_vma iplt_offset,
3309                               bfd_vma resolver_address)
3310 {
3311   bfd_vma iplt_index;
3312   bfd_vma got_offset;
3313   bfd_vma igotiplt_offset;
3314   Elf_Internal_Rela rela;
3315   bfd_byte *loc;
3316   asection *plt, *gotplt, *relplt;
3317   bfd_vma relative_offset;
3318
3319   if (htab->elf.iplt == NULL
3320       || htab->elf.igotplt == NULL
3321       || htab->elf.irelplt == NULL)
3322     abort ();
3323
3324   gotplt = htab->elf.igotplt;
3325   relplt = htab->elf.irelplt;
3326
3327   /* Index of the PLT slot within iplt section.  */
3328   iplt_index = iplt_offset / PLT_ENTRY_SIZE;
3329   plt = htab->elf.iplt;
3330   /* Offset into the igot.plt section.  */
3331   igotiplt_offset = iplt_index * GOT_ENTRY_SIZE;
3332   /* Offset into the got section.  */
3333   got_offset = igotiplt_offset + gotplt->output_offset;
3334
3335   /* S390 uses halfwords for relative branch calc!  */
3336   relative_offset = - (plt->output_offset +
3337                        (PLT_ENTRY_SIZE * iplt_index) + 18) / 2;
3338 /* If offset is > 32768, branch to a previous branch
3339    390 can only handle +-64 K jumps.  */
3340   if ( -32768 > (int) relative_offset )
3341     relative_offset
3342       = -(unsigned) (((65536 / PLT_ENTRY_SIZE - 1) * PLT_ENTRY_SIZE) / 2);
3343
3344   /* Fill in the entry in the procedure linkage table.  */
3345   if (!info->shared)
3346     {
3347       memcpy (plt->contents + iplt_offset, elf_s390_plt_entry,
3348               PLT_ENTRY_SIZE);
3349
3350       /* Adjust jump to the first plt entry.  */
3351       bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3352                   plt->contents + iplt_offset + 20);
3353
3354       /* Push the GOT offset field.  */
3355       bfd_put_32 (output_bfd,
3356                   (gotplt->output_section->vma
3357                    + got_offset),
3358                   plt->contents + iplt_offset + 24);
3359     }
3360   else if (got_offset < 4096)
3361     {
3362       /* The GOT offset is small enough to be used directly as
3363          displacement.  */
3364       memcpy (plt->contents + iplt_offset,
3365               elf_s390_plt_pic12_entry,
3366               PLT_ENTRY_SIZE);
3367
3368       /* Put in the GOT offset as displacement value.  The 0xc000
3369          value comes from the first word of the plt entry.  Look
3370          at the elf_s390_plt_pic16_entry content.  */
3371       bfd_put_16 (output_bfd, (bfd_vma)0xc000 | got_offset,
3372                   plt->contents + iplt_offset + 2);
3373
3374       /* Adjust the jump to the first plt entry.  */
3375       bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3376                   plt->contents + iplt_offset + 20);
3377     }
3378   else if (got_offset < 32768)
3379     {
3380       /* The GOT offset is too big for a displacement but small
3381          enough to be a signed 16 bit immediate value as it can be
3382          used in an lhi instruction.  */
3383       memcpy (plt->contents + iplt_offset,
3384               elf_s390_plt_pic16_entry,
3385               PLT_ENTRY_SIZE);
3386
3387       /* Put in the GOT offset for the lhi instruction.  */
3388       bfd_put_16 (output_bfd, (bfd_vma)got_offset,
3389                   plt->contents + iplt_offset + 2);
3390
3391       /* Adjust the jump to the first plt entry.  */
3392       bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3393                   plt->contents + iplt_offset + 20);
3394     }
3395   else
3396     {
3397       memcpy (plt->contents + iplt_offset,
3398               elf_s390_plt_pic_entry,
3399               PLT_ENTRY_SIZE);
3400
3401       /* Adjust the jump to the first plt entry.  */
3402       bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3403                   plt->contents + iplt_offset + 20);
3404
3405       /* Push the GOT offset field.  */
3406       bfd_put_32 (output_bfd, got_offset,
3407                   plt->contents + iplt_offset + 24);
3408     }
3409   /* Insert offset into  reloc. table here.  */
3410   bfd_put_32 (output_bfd, relplt->output_offset +
3411               iplt_index * RELA_ENTRY_SIZE,
3412               plt->contents + iplt_offset + 28);
3413
3414   /* Fill in the entry in the global offset table.
3415      Points to instruction after GOT offset.  */
3416   bfd_put_32 (output_bfd,
3417               (plt->output_section->vma
3418                + plt->output_offset
3419                + iplt_offset
3420                + 12),
3421               gotplt->contents + igotiplt_offset);
3422
3423   /* Fill in the entry in the .rela.plt section.  */
3424   rela.r_offset = gotplt->output_section->vma + got_offset;
3425
3426   if (!h
3427       || h->dynindx == -1
3428       || ((info->executable
3429            || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
3430           && h->def_regular))
3431     {
3432       /* The symbol can be locally resolved.  */
3433       rela.r_info = ELF32_R_INFO (0, R_390_IRELATIVE);
3434       rela.r_addend = resolver_address;
3435     }
3436   else
3437     {
3438       rela.r_info = ELF32_R_INFO (h->dynindx, R_390_JMP_SLOT);
3439       rela.r_addend = 0;
3440     }
3441
3442   loc = relplt->contents + iplt_index * RELA_ENTRY_SIZE;
3443   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3444 }
3445
3446 /* Finish up dynamic symbol handling.  We set the contents of various
3447    dynamic sections here.  */
3448
3449 static bfd_boolean
3450 elf_s390_finish_dynamic_symbol (bfd *output_bfd,
3451                                 struct bfd_link_info *info,
3452                                 struct elf_link_hash_entry *h,
3453                                 Elf_Internal_Sym *sym)
3454 {
3455   struct elf_s390_link_hash_table *htab;
3456   struct elf_s390_link_hash_entry *eh = (struct elf_s390_link_hash_entry*)h;
3457
3458   htab = elf_s390_hash_table (info);
3459
3460   if (h->plt.offset != (bfd_vma) -1)
3461     {
3462       bfd_vma plt_index;
3463       bfd_vma got_offset;
3464       Elf_Internal_Rela rela;
3465       bfd_byte *loc;
3466       bfd_vma relative_offset;
3467
3468       /* This symbol has an entry in the procedure linkage table.  Set
3469          it up.  */
3470       if (s390_is_ifunc_symbol_p (h))
3471         {
3472           /* If we can resolve the IFUNC symbol locally we generate an
3473              IRELATIVE reloc.  */
3474           elf_s390_finish_ifunc_symbol (output_bfd, info, h, htab, h->plt.offset,
3475                                         eh->ifunc_resolver_address +
3476                                         eh->ifunc_resolver_section->output_offset +
3477                                         eh->ifunc_resolver_section->output_section->vma);
3478           /* Fallthrough.  Handling of explicit GOT slots of IFUNC
3479              symbols is below.  */
3480         }
3481       else
3482         {
3483           if (h->dynindx == -1
3484               || htab->elf.splt == NULL
3485               || htab->elf.sgotplt == NULL
3486               || htab->elf.srelplt == NULL)
3487             abort ();
3488
3489           /* Calc. index no.
3490              Current offset - size first entry / entry size.  */
3491           plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3492
3493           /* Offset in GOT is PLT index plus GOT headers(3) times 4,
3494              addr & GOT addr.  */
3495           got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
3496
3497           /* S390 uses halfwords for relative branch calc!  */
3498           relative_offset = - ((PLT_FIRST_ENTRY_SIZE +
3499                                 (PLT_ENTRY_SIZE * plt_index) + 18) / 2);
3500           /* If offset is > 32768, branch to a previous branch
3501              390 can only handle +-64 K jumps.  */
3502           if ( -32768 > (int) relative_offset )
3503             relative_offset
3504               = -(unsigned) (((65536 / PLT_ENTRY_SIZE - 1) * PLT_ENTRY_SIZE) / 2);
3505
3506           /* Fill in the entry in the procedure linkage table.  */
3507           if (!info->shared)
3508             {
3509               memcpy (htab->elf.splt->contents + h->plt.offset, elf_s390_plt_entry,
3510                       PLT_ENTRY_SIZE);
3511
3512               /* Adjust jump to the first plt entry.  */
3513               bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3514                           htab->elf.splt->contents + h->plt.offset + 20);
3515
3516               /* Push the GOT offset field.  */
3517               bfd_put_32 (output_bfd,
3518                           (htab->elf.sgotplt->output_section->vma
3519                            + htab->elf.sgotplt->output_offset
3520                            + got_offset),
3521                           htab->elf.splt->contents + h->plt.offset + 24);
3522             }
3523           else if (got_offset < 4096)
3524             {
3525               /* The GOT offset is small enough to be used directly as
3526                  displacement.  */
3527               memcpy (htab->elf.splt->contents + h->plt.offset,
3528                       elf_s390_plt_pic12_entry,
3529                       PLT_ENTRY_SIZE);
3530
3531               /* Put in the GOT offset as displacement value.  The 0xc000
3532                  value comes from the first word of the plt entry.  Look
3533                  at the elf_s390_plt_pic16_entry content.  */
3534               bfd_put_16 (output_bfd, (bfd_vma)0xc000 | got_offset,
3535                           htab->elf.splt->contents + h->plt.offset + 2);
3536
3537               /* Adjust the jump to the first plt entry.  */
3538               bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3539                           htab->elf.splt->contents + h->plt.offset + 20);
3540             }
3541           else if (got_offset < 32768)
3542             {
3543               /* The GOT offset is too big for a displacement but small
3544                  enough to be a signed 16 bit immediate value as it can be
3545                  used in an lhi instruction.  */
3546               memcpy (htab->elf.splt->contents + h->plt.offset,
3547                       elf_s390_plt_pic16_entry,
3548                       PLT_ENTRY_SIZE);
3549
3550               /* Put in the GOT offset for the lhi instruction.  */
3551               bfd_put_16 (output_bfd, (bfd_vma)got_offset,
3552                           htab->elf.splt->contents + h->plt.offset + 2);
3553
3554               /* Adjust the jump to the first plt entry.  */
3555               bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3556                           htab->elf.splt->contents + h->plt.offset + 20);
3557             }
3558           else
3559             {
3560               memcpy (htab->elf.splt->contents + h->plt.offset,
3561                       elf_s390_plt_pic_entry,
3562                       PLT_ENTRY_SIZE);
3563
3564               /* Adjust the jump to the first plt entry.  */
3565               bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3566                           htab->elf.splt->contents + h->plt.offset + 20);
3567
3568               /* Push the GOT offset field.  */
3569               bfd_put_32 (output_bfd, got_offset,
3570                           htab->elf.splt->contents + h->plt.offset + 24);
3571             }
3572           /* Insert offset into  reloc. table here.  */
3573           bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
3574                       htab->elf.splt->contents + h->plt.offset + 28);
3575
3576           /* Fill in the entry in the global offset table.
3577              Points to instruction after GOT offset.  */
3578           bfd_put_32 (output_bfd,
3579                       (htab->elf.splt->output_section->vma
3580                        + htab->elf.splt->output_offset
3581                        + h->plt.offset
3582                        + 12),
3583                       htab->elf.sgotplt->contents + got_offset);
3584
3585           /* Fill in the entry in the .rela.plt section.  */
3586           rela.r_offset = (htab->elf.sgotplt->output_section->vma
3587                            + htab->elf.sgotplt->output_offset
3588                            + got_offset);
3589           rela.r_info = ELF32_R_INFO (h->dynindx, R_390_JMP_SLOT);
3590           rela.r_addend = 0;
3591           loc = htab->elf.srelplt->contents + plt_index * sizeof (Elf32_External_Rela);
3592           bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3593
3594           if (!h->def_regular)
3595             {
3596               /* Mark the symbol as undefined, rather than as defined in
3597                  the .plt section.  Leave the value alone.  This is a clue
3598                  for the dynamic linker, to make function pointer
3599                  comparisons work between an application and shared
3600                  library.  */
3601               sym->st_shndx = SHN_UNDEF;
3602             }
3603         }
3604     }
3605
3606   if (h->got.offset != (bfd_vma) -1
3607       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_GD
3608       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE
3609       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE_NLT)
3610     {
3611       Elf_Internal_Rela rela;
3612       bfd_byte *loc;
3613
3614       /* This symbol has an entry in the global offset table.  Set it
3615          up.  */
3616
3617       if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
3618         abort ();
3619
3620       rela.r_offset = (htab->elf.sgot->output_section->vma
3621                        + htab->elf.sgot->output_offset
3622                        + (h->got.offset &~ (bfd_vma) 1));
3623
3624       /* If this is a static link, or it is a -Bsymbolic link and the
3625          symbol is defined locally or was forced to be local because
3626          of a version file, we just want to emit a RELATIVE reloc.
3627          The entry in the global offset table will already have been
3628          initialized in the relocate_section function.  */
3629       if (h->def_regular && s390_is_ifunc_symbol_p (h))
3630         {
3631           if (info->shared)
3632             {
3633               /* An explicit GOT slot usage needs GLOB_DAT.  If the
3634                  symbol references local the implicit got.iplt slot
3635                  will be used and the IRELATIVE reloc has been created
3636                  above.  */
3637               goto do_glob_dat;
3638             }
3639           else
3640             {
3641               /* For non-shared objects explicit GOT slots must be
3642                  filled with the PLT slot address for pointer
3643                  equality reasons.  */
3644               bfd_put_32 (output_bfd, (htab->elf.iplt->output_section->vma
3645                                        + htab->elf.iplt->output_offset
3646                                        + h->plt.offset),
3647                           htab->elf.sgot->contents + h->got.offset);
3648               return TRUE;
3649             }
3650         }
3651       else if (info->shared
3652           && SYMBOL_REFERENCES_LOCAL (info, h))
3653         {
3654           /* If this is a static link, or it is a -Bsymbolic link and
3655              the symbol is defined locally or was forced to be local
3656              because of a version file, we just want to emit a
3657              RELATIVE reloc.  The entry in the global offset table
3658              will already have been initialized in the
3659              relocate_section function.  */
3660           if (!h->def_regular)
3661             return FALSE;
3662           BFD_ASSERT((h->got.offset & 1) != 0);
3663           rela.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
3664           rela.r_addend = (h->root.u.def.value
3665                            + h->root.u.def.section->output_section->vma
3666                            + h->root.u.def.section->output_offset);
3667         }
3668       else
3669         {
3670           BFD_ASSERT((h->got.offset & 1) == 0);
3671         do_glob_dat:
3672           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->elf.sgot->contents + h->got.offset);
3673           rela.r_info = ELF32_R_INFO (h->dynindx, R_390_GLOB_DAT);
3674           rela.r_addend = 0;
3675         }
3676
3677       loc = htab->elf.srelgot->contents;
3678       loc += htab->elf.srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
3679       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3680     }
3681
3682   if (h->needs_copy)
3683     {
3684       Elf_Internal_Rela rela;
3685       bfd_byte *loc;
3686
3687       /* This symbols needs a copy reloc.  Set it up.  */
3688
3689       if (h->dynindx == -1
3690           || (h->root.type != bfd_link_hash_defined
3691               && h->root.type != bfd_link_hash_defweak)
3692           || htab->srelbss == NULL)
3693         abort ();
3694
3695       rela.r_offset = (h->root.u.def.value
3696                        + h->root.u.def.section->output_section->vma
3697                        + h->root.u.def.section->output_offset);
3698       rela.r_info = ELF32_R_INFO (h->dynindx, R_390_COPY);
3699       rela.r_addend = 0;
3700       loc = htab->srelbss->contents;
3701       loc += htab->srelbss->reloc_count++ * sizeof (Elf32_External_Rela);
3702       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3703     }
3704
3705   /* Mark some specially defined symbols as absolute.  */
3706   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3707       || h == htab->elf.hgot
3708       || h == htab->elf.hplt)
3709     sym->st_shndx = SHN_ABS;
3710
3711   return TRUE;
3712 }
3713
3714 /* Used to decide how to sort relocs in an optimal manner for the
3715    dynamic linker, before writing them out.  */
3716
3717 static enum elf_reloc_type_class
3718 elf_s390_reloc_type_class (const Elf_Internal_Rela *rela)
3719 {
3720   switch ((int) ELF32_R_TYPE (rela->r_info))
3721     {
3722     case R_390_RELATIVE:
3723       return reloc_class_relative;
3724     case R_390_JMP_SLOT:
3725       return reloc_class_plt;
3726     case R_390_COPY:
3727       return reloc_class_copy;
3728     default:
3729       return reloc_class_normal;
3730     }
3731 }
3732
3733 /* Finish up the dynamic sections.  */
3734
3735 static bfd_boolean
3736 elf_s390_finish_dynamic_sections (bfd *output_bfd,
3737                                   struct bfd_link_info *info)
3738 {
3739   struct elf_s390_link_hash_table *htab;
3740   bfd *dynobj;
3741   asection *sdyn;
3742   bfd *ibfd;
3743   unsigned int i;
3744
3745   htab = elf_s390_hash_table (info);
3746   dynobj = htab->elf.dynobj;
3747   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3748
3749   if (htab->elf.dynamic_sections_created)
3750     {
3751       Elf32_External_Dyn *dyncon, *dynconend;
3752
3753       if (sdyn == NULL || htab->elf.sgot == NULL)
3754         abort ();
3755
3756       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3757       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3758       for (; dyncon < dynconend; dyncon++)
3759         {
3760           Elf_Internal_Dyn dyn;
3761           asection *s;
3762
3763           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3764
3765           switch (dyn.d_tag)
3766             {
3767             default:
3768               continue;
3769
3770             case DT_PLTGOT:
3771               dyn.d_un.d_ptr = htab->elf.sgot->output_section->vma;
3772               break;
3773
3774             case DT_JMPREL:
3775               dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
3776               break;
3777
3778             case DT_PLTRELSZ:
3779               s = htab->elf.srelplt->output_section;
3780               dyn.d_un.d_val = s->size;
3781               break;
3782             }
3783
3784           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3785         }
3786
3787       /* Fill in the special first entry in the procedure linkage table.  */
3788       if (htab->elf.splt && htab->elf.splt->size > 0)
3789         {
3790           memset (htab->elf.splt->contents, 0, PLT_FIRST_ENTRY_SIZE);
3791           if (info->shared)
3792             {
3793               memcpy (htab->elf.splt->contents, elf_s390_plt_pic_first_entry,
3794                       PLT_FIRST_ENTRY_SIZE);
3795             }
3796           else
3797             {
3798               memcpy (htab->elf.splt->contents, elf_s390_plt_first_entry,
3799                       PLT_FIRST_ENTRY_SIZE);
3800               bfd_put_32 (output_bfd,
3801                           htab->elf.sgotplt->output_section->vma
3802                           + htab->elf.sgotplt->output_offset,
3803                           htab->elf.splt->contents + 24);
3804            }
3805           elf_section_data (htab->elf.splt->output_section)
3806             ->this_hdr.sh_entsize = 4;
3807         }
3808
3809     }
3810
3811   if (htab->elf.sgotplt)
3812     {
3813       /* Fill in the first three entries in the global offset table.  */
3814       if (htab->elf.sgotplt->size > 0)
3815         {
3816           bfd_put_32 (output_bfd,
3817                       (sdyn == NULL ? (bfd_vma) 0
3818                        : sdyn->output_section->vma + sdyn->output_offset),
3819                       htab->elf.sgotplt->contents);
3820           /* One entry for shared object struct ptr.  */
3821           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + 4);
3822           /* One entry for _dl_runtime_resolve.  */
3823           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + 8);
3824         }
3825
3826       elf_section_data (htab->elf.sgotplt->output_section)
3827         ->this_hdr.sh_entsize = 4;
3828     }
3829   /* Finish dynamic symbol for local IFUNC symbols.  */
3830   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3831     {
3832       struct plt_entry *local_plt;
3833       Elf_Internal_Sym *isym;
3834       Elf_Internal_Shdr *symtab_hdr;
3835
3836       symtab_hdr = &elf_symtab_hdr (ibfd);
3837
3838       local_plt = elf_s390_local_plt (ibfd);
3839       if (local_plt != NULL)
3840         for (i = 0; i < symtab_hdr->sh_info; i++)
3841           {
3842             if (local_plt[i].plt.offset != (bfd_vma) -1)
3843               {
3844                 asection *sec = local_plt[i].sec;
3845                 isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, i);
3846                 if (isym == NULL)
3847                   return FALSE;
3848
3849                 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
3850                   elf_s390_finish_ifunc_symbol (output_bfd, info, NULL, htab,
3851                                                 local_plt[i].plt.offset,
3852                                                 isym->st_value
3853                                                 + sec->output_section->vma
3854                                                 + sec->output_offset);
3855
3856               }
3857           }
3858     }
3859   return TRUE;
3860 }
3861
3862 static bfd_boolean
3863 elf_s390_grok_prstatus (bfd * abfd, Elf_Internal_Note * note)
3864 {
3865   int offset;
3866   unsigned int size;
3867
3868   switch (note->descsz)
3869     {
3870       default:
3871         return FALSE;
3872
3873       case 224:         /* S/390 Linux.  */
3874         /* pr_cursig */
3875         elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
3876
3877         /* pr_pid */
3878         elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24);
3879
3880         /* pr_reg */
3881         offset = 72;
3882         size = 144;
3883         break;
3884     }
3885
3886   /* Make a ".reg/999" section.  */
3887   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3888                                           size, note->descpos + offset);
3889 }
3890
3891 /* Return address for Ith PLT stub in section PLT, for relocation REL
3892    or (bfd_vma) -1 if it should not be included.  */
3893
3894 static bfd_vma
3895 elf_s390_plt_sym_val (bfd_vma i, const asection *plt,
3896                       const arelent *rel ATTRIBUTE_UNUSED)
3897 {
3898   return plt->vma + PLT_FIRST_ENTRY_SIZE + i * PLT_ENTRY_SIZE;
3899 }
3900
3901 static bfd_boolean
3902 elf32_s390_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
3903 {
3904   elf_elfheader (obfd)->e_flags |= elf_elfheader (ibfd)->e_flags;
3905   return TRUE;
3906 }
3907
3908
3909 #define TARGET_BIG_SYM  bfd_elf32_s390_vec
3910 #define TARGET_BIG_NAME "elf32-s390"
3911 #define ELF_ARCH        bfd_arch_s390
3912 #define ELF_TARGET_ID   S390_ELF_DATA
3913 #define ELF_MACHINE_CODE EM_S390
3914 #define ELF_MACHINE_ALT1 EM_S390_OLD
3915 #define ELF_MAXPAGESIZE 0x1000
3916
3917 #define elf_backend_can_gc_sections     1
3918 #define elf_backend_can_refcount        1
3919 #define elf_backend_want_got_plt        1
3920 #define elf_backend_plt_readonly        1
3921 #define elf_backend_want_plt_sym        0
3922 #define elf_backend_got_header_size     12
3923 #define elf_backend_rela_normal         1
3924
3925 #define elf_info_to_howto                     elf_s390_info_to_howto
3926
3927 #define bfd_elf32_bfd_is_local_label_name     elf_s390_is_local_label_name
3928 #define bfd_elf32_bfd_link_hash_table_create  elf_s390_link_hash_table_create
3929 #define bfd_elf32_bfd_reloc_type_lookup       elf_s390_reloc_type_lookup
3930 #define bfd_elf32_bfd_reloc_name_lookup elf_s390_reloc_name_lookup
3931
3932 #define bfd_elf32_bfd_merge_private_bfd_data  elf32_s390_merge_private_bfd_data
3933
3934 #define elf_backend_adjust_dynamic_symbol     elf_s390_adjust_dynamic_symbol
3935 #define elf_backend_check_relocs              elf_s390_check_relocs
3936 #define elf_backend_copy_indirect_symbol      elf_s390_copy_indirect_symbol
3937 #define elf_backend_create_dynamic_sections   elf_s390_create_dynamic_sections
3938 #define elf_backend_finish_dynamic_sections   elf_s390_finish_dynamic_sections
3939 #define elf_backend_finish_dynamic_symbol     elf_s390_finish_dynamic_symbol
3940 #define elf_backend_gc_mark_hook              elf_s390_gc_mark_hook
3941 #define elf_backend_gc_sweep_hook             elf_s390_gc_sweep_hook
3942 #define elf_backend_reloc_type_class          elf_s390_reloc_type_class
3943 #define elf_backend_relocate_section          elf_s390_relocate_section
3944 #define elf_backend_size_dynamic_sections     elf_s390_size_dynamic_sections
3945 #define elf_backend_init_index_section        _bfd_elf_init_1_index_section
3946 #define elf_backend_reloc_type_class          elf_s390_reloc_type_class
3947 #define elf_backend_grok_prstatus             elf_s390_grok_prstatus
3948 #define elf_backend_plt_sym_val               elf_s390_plt_sym_val
3949 #define elf_backend_add_symbol_hook           elf_s390_add_symbol_hook
3950
3951 #define bfd_elf32_mkobject              elf_s390_mkobject
3952 #define elf_backend_object_p            elf_s390_object_p
3953
3954 #include "elf32-target.h"