bfd/elf64-s390.c

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