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