bfd/elf64-s390.c

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