bfd/elf64-s390.c

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