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