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