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             eh->dyn_relocs = NULL;
1895
1896           /* Make sure undefined weak symbols are output as a dynamic
1897              symbol in PIEs.  */
1898           else if (h->dynindx == -1
1899                    && !h->forced_local)
1900             {
1901               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1902                 return FALSE;
1903             }
1904         }
1905     }
1906   else if (ELIMINATE_COPY_RELOCS)
1907     {
1908       /* For the non-shared case, discard space for relocs against
1909          symbols which turn out to need copy relocs or are not
1910          dynamic.  */
1911
1912       if (!h->non_got_ref
1913           && ((h->def_dynamic
1914                && !h->def_regular)
1915               || (htab->elf.dynamic_sections_created
1916                   && (h->root.type == bfd_link_hash_undefweak
1917                       || h->root.type == bfd_link_hash_undefined))))
1918         {
1919           /* Make sure this symbol is output as a dynamic symbol.
1920              Undefined weak syms won't yet be marked as dynamic.  */
1921           if (h->dynindx == -1
1922               && !h->forced_local)
1923             {
1924               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1925                 return FALSE;
1926             }
1927
1928           /* If that succeeded, we know we'll be keeping all the
1929              relocs.  */
1930           if (h->dynindx != -1)
1931             goto keep;
1932         }
1933
1934       eh->dyn_relocs = NULL;
1935
1936     keep: ;
1937     }
1938
1939   /* Finally, allocate space.  */
1940   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1941     {
1942       asection *sreloc = elf_section_data (p->sec)->sreloc;
1943       sreloc->size += p->count * sizeof (Elf64_External_Rela);
1944     }
1945
1946   return TRUE;
1947 }
1948
1949 /* Find any dynamic relocs that apply to read-only sections.  */
1950
1951 static bfd_boolean
1952 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1953 {
1954   struct elf_s390_link_hash_entry *eh;
1955   struct elf_dyn_relocs *p;
1956
1957   eh = (struct elf_s390_link_hash_entry *) h;
1958   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1959     {
1960       asection *s = p->sec->output_section;
1961
1962       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1963         {
1964           struct bfd_link_info *info = (struct bfd_link_info *) inf;
1965
1966           info->flags |= DF_TEXTREL;
1967
1968           /* Not an error, just cut short the traversal.  */
1969           return FALSE;
1970         }
1971     }
1972   return TRUE;
1973 }
1974
1975 /* Set the sizes of the dynamic sections.  */
1976
1977 static bfd_boolean
1978 elf_s390_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1979                                 struct bfd_link_info *info)
1980 {
1981   struct elf_s390_link_hash_table *htab;
1982   bfd *dynobj;
1983   asection *s;
1984   bfd_boolean relocs;
1985   bfd *ibfd;
1986
1987   htab = elf_s390_hash_table (info);
1988   if (htab == NULL)
1989     return FALSE;
1990
1991   dynobj = htab->elf.dynobj;
1992   if (dynobj == NULL)
1993     abort ();
1994
1995   if (htab->elf.dynamic_sections_created)
1996     {
1997       /* Set the contents of the .interp section to the interpreter.  */
1998       if (bfd_link_executable (info) && !info->nointerp)
1999         {
2000           s = bfd_get_linker_section (dynobj, ".interp");
2001           if (s == NULL)
2002             abort ();
2003           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2004           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2005         }
2006     }
2007
2008   /* Set up .got offsets for local syms, and space for local dynamic
2009      relocs.  */
2010   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2011     {
2012       bfd_signed_vma *local_got;
2013       bfd_signed_vma *end_local_got;
2014       char *local_tls_type;
2015       bfd_size_type locsymcount;
2016       Elf_Internal_Shdr *symtab_hdr;
2017       asection *srela;
2018       struct plt_entry *local_plt;
2019       unsigned int i;
2020
2021       if (! is_s390_elf (ibfd))
2022         continue;
2023
2024       for (s = ibfd->sections; s != NULL; s = s->next)
2025         {
2026           struct elf_dyn_relocs *p;
2027
2028           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
2029             {
2030               if (!bfd_is_abs_section (p->sec)
2031                   && bfd_is_abs_section (p->sec->output_section))
2032                 {
2033                   /* Input section has been discarded, either because
2034                      it is a copy of a linkonce section or due to
2035                      linker script /DISCARD/, so we'll be discarding
2036                      the relocs too.  */
2037                 }
2038               else if (p->count != 0)
2039                 {
2040                   srela = elf_section_data (p->sec)->sreloc;
2041                   srela->size += p->count * sizeof (Elf64_External_Rela);
2042                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2043                     info->flags |= DF_TEXTREL;
2044                 }
2045             }
2046         }
2047
2048       local_got = elf_local_got_refcounts (ibfd);
2049       if (!local_got)
2050         continue;
2051
2052       symtab_hdr = &elf_symtab_hdr (ibfd);
2053       locsymcount = symtab_hdr->sh_info;
2054       end_local_got = local_got + locsymcount;
2055       local_tls_type = elf_s390_local_got_tls_type (ibfd);
2056       s = htab->elf.sgot;
2057       srela = htab->elf.srelgot;
2058       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2059         {
2060           if (*local_got > 0)
2061             {
2062               *local_got = s->size;
2063               s->size += GOT_ENTRY_SIZE;
2064               if (*local_tls_type == GOT_TLS_GD)
2065                 s->size += GOT_ENTRY_SIZE;
2066               if (bfd_link_pic (info))
2067                 srela->size += sizeof (Elf64_External_Rela);
2068             }
2069           else
2070             *local_got = (bfd_vma) -1;
2071         }
2072
2073       local_plt = elf_s390_local_plt (ibfd);
2074       for (i = 0; i < symtab_hdr->sh_info; i++)
2075         {
2076           if (local_plt[i].plt.refcount > 0)
2077             {
2078               local_plt[i].plt.offset = htab->elf.iplt->size;
2079               htab->elf.iplt->size += PLT_ENTRY_SIZE;
2080               htab->elf.igotplt->size += GOT_ENTRY_SIZE;
2081               htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
2082             }
2083           else
2084             local_plt[i].plt.offset = (bfd_vma) -1;
2085         }
2086     }
2087
2088   if (htab->tls_ldm_got.refcount > 0)
2089     {
2090       /* Allocate 2 got entries and 1 dynamic reloc for R_390_TLS_LDM64
2091          relocs.  */
2092       htab->tls_ldm_got.offset = htab->elf.sgot->size;
2093       htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
2094       htab->elf.srelgot->size += sizeof (Elf64_External_Rela);
2095     }
2096   else
2097     htab->tls_ldm_got.offset = -1;
2098
2099   /* Allocate global sym .plt and .got entries, and space for global
2100      sym dynamic relocs.  */
2101   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
2102
2103   /* We now have determined the sizes of the various dynamic sections.
2104      Allocate memory for them.  */
2105   relocs = FALSE;
2106   for (s = dynobj->sections; s != NULL; s = s->next)
2107     {
2108       if ((s->flags & SEC_LINKER_CREATED) == 0)
2109         continue;
2110
2111       if (s == htab->elf.splt
2112           || s == htab->elf.sgot
2113           || s == htab->elf.sgotplt
2114           || s == htab->elf.sdynbss
2115           || s == htab->elf.sdynrelro
2116           || s == htab->elf.iplt
2117           || s == htab->elf.igotplt
2118           || s == htab->irelifunc)
2119         {
2120           /* Strip this section if we don't need it; see the
2121              comment below.  */
2122         }
2123       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2124         {
2125           if (s->size != 0 && s != htab->elf.srelplt)
2126             relocs = TRUE;
2127
2128           /* We use the reloc_count field as a counter if we need
2129              to copy relocs into the output file.  */
2130           s->reloc_count = 0;
2131         }
2132       else
2133         {
2134           /* It's not one of our sections, so don't allocate space.  */
2135           continue;
2136         }
2137
2138       if (s->size == 0)
2139         {
2140           /* If we don't need this section, strip it from the
2141              output file.  This is to handle .rela.bss and
2142              .rela.plt.  We must create it in
2143              create_dynamic_sections, because it must be created
2144              before the linker maps input sections to output
2145              sections.  The linker does that before
2146              adjust_dynamic_symbol is called, and it is that
2147              function which decides whether anything needs to go
2148              into these sections.  */
2149
2150           s->flags |= SEC_EXCLUDE;
2151           continue;
2152         }
2153
2154       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2155         continue;
2156
2157       /* Allocate memory for the section contents.  We use bfd_zalloc
2158          here in case unused entries are not reclaimed before the
2159          section's contents are written out.  This should not happen,
2160          but this way if it does, we get a R_390_NONE reloc instead
2161          of garbage.  */
2162       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2163       if (s->contents == NULL)
2164         return FALSE;
2165     }
2166
2167   if (htab->elf.dynamic_sections_created)
2168     {
2169       /* Add some entries to the .dynamic section.  We fill in the
2170          values later, in elf_s390_finish_dynamic_sections, but we
2171          must add the entries now so that we get the correct size for
2172          the .dynamic section.  The DT_DEBUG entry is filled in by the
2173          dynamic linker and used by the debugger.  */
2174 #define add_dynamic_entry(TAG, VAL) \
2175   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2176
2177       if (bfd_link_executable (info))
2178         {
2179           if (!add_dynamic_entry (DT_DEBUG, 0))
2180             return FALSE;
2181         }
2182
2183       if (htab->elf.splt->size != 0)
2184         {
2185           if (!add_dynamic_entry (DT_PLTGOT, 0)
2186               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2187               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2188               || !add_dynamic_entry (DT_JMPREL, 0))
2189             return FALSE;
2190         }
2191
2192       if (relocs)
2193         {
2194           if (!add_dynamic_entry (DT_RELA, 0)
2195               || !add_dynamic_entry (DT_RELASZ, 0)
2196               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
2197             return FALSE;
2198
2199           /* If any dynamic relocs apply to a read-only section,
2200              then we need a DT_TEXTREL entry.  */
2201           if ((info->flags & DF_TEXTREL) == 0)
2202             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2203                                     info);
2204
2205           if ((info->flags & DF_TEXTREL) != 0)
2206             {
2207               if (!add_dynamic_entry (DT_TEXTREL, 0))
2208                 return FALSE;
2209             }
2210         }
2211     }
2212 #undef add_dynamic_entry
2213
2214   return TRUE;
2215 }
2216
2217 /* Return the base VMA address which should be subtracted from real addresses
2218    when resolving @dtpoff relocation.
2219    This is PT_TLS segment p_vaddr.  */
2220
2221 static bfd_vma
2222 dtpoff_base (struct bfd_link_info *info)
2223 {
2224   /* If tls_sec is NULL, we should have signalled an error already.  */
2225   if (elf_hash_table (info)->tls_sec == NULL)
2226     return 0;
2227   return elf_hash_table (info)->tls_sec->vma;
2228 }
2229
2230 /* Return the relocation value for @tpoff relocation
2231    if STT_TLS virtual address is ADDRESS.  */
2232
2233 static bfd_vma
2234 tpoff (struct bfd_link_info *info, bfd_vma address)
2235 {
2236   struct elf_link_hash_table *htab = elf_hash_table (info);
2237
2238   /* If tls_sec is NULL, we should have signalled an error already.  */
2239   if (htab->tls_sec == NULL)
2240     return 0;
2241   return htab->tls_size + htab->tls_sec->vma - address;
2242 }
2243
2244 /* Complain if TLS instruction relocation is against an invalid
2245    instruction.  */
2246
2247 static void
2248 invalid_tls_insn (bfd *input_bfd,
2249                   asection *input_section,
2250                   Elf_Internal_Rela *rel)
2251 {
2252   reloc_howto_type *howto;
2253
2254   howto = elf_howto_table + ELF64_R_TYPE (rel->r_info);
2255   _bfd_error_handler
2256     /* xgettext:c-format */
2257     (_("%B(%A+%#Lx): invalid instruction for TLS relocation %s"),
2258      input_bfd,
2259      input_section,
2260      rel->r_offset,
2261      howto->name);
2262   bfd_set_error (bfd_error_bad_value);
2263 }
2264
2265 /* Relocate a 390 ELF section.  */
2266
2267 static bfd_boolean
2268 elf_s390_relocate_section (bfd *output_bfd,
2269                            struct bfd_link_info *info,
2270                            bfd *input_bfd,
2271                            asection *input_section,
2272                            bfd_byte *contents,
2273                            Elf_Internal_Rela *relocs,
2274                            Elf_Internal_Sym *local_syms,
2275                            asection **local_sections)
2276 {
2277   struct elf_s390_link_hash_table *htab;
2278   Elf_Internal_Shdr *symtab_hdr;
2279   struct elf_link_hash_entry **sym_hashes;
2280   bfd_vma *local_got_offsets;
2281   Elf_Internal_Rela *rel;
2282   Elf_Internal_Rela *relend;
2283
2284   BFD_ASSERT (is_s390_elf (input_bfd));
2285
2286   htab = elf_s390_hash_table (info);
2287   if (htab == NULL)
2288     return FALSE;
2289
2290   symtab_hdr = &elf_symtab_hdr (input_bfd);
2291   sym_hashes = elf_sym_hashes (input_bfd);
2292   local_got_offsets = elf_local_got_offsets (input_bfd);
2293
2294   rel = relocs;
2295   relend = relocs + input_section->reloc_count;
2296   for (; rel < relend; rel++)
2297     {
2298       unsigned int r_type;
2299       reloc_howto_type *howto;
2300       unsigned long r_symndx;
2301       struct elf_link_hash_entry *h;
2302       Elf_Internal_Sym *sym;
2303       asection *sec;
2304       bfd_vma off;
2305       bfd_vma relocation;
2306       bfd_boolean unresolved_reloc;
2307       bfd_reloc_status_type r;
2308       int tls_type;
2309       asection *base_got = htab->elf.sgot;
2310
2311       r_type = ELF64_R_TYPE (rel->r_info);
2312       if (r_type == (int) R_390_GNU_VTINHERIT
2313           || r_type == (int) R_390_GNU_VTENTRY)
2314         continue;
2315       if (r_type >= (int) R_390_max)
2316         {
2317           bfd_set_error (bfd_error_bad_value);
2318           return FALSE;
2319         }
2320
2321       howto = elf_howto_table + r_type;
2322       r_symndx = ELF64_R_SYM (rel->r_info);
2323
2324       h = NULL;
2325       sym = NULL;
2326       sec = NULL;
2327       unresolved_reloc = FALSE;
2328       if (r_symndx < symtab_hdr->sh_info)
2329         {
2330           sym = local_syms + r_symndx;
2331           sec = local_sections[r_symndx];
2332
2333           if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
2334             {
2335               struct plt_entry *local_plt = elf_s390_local_plt (input_bfd);
2336               if (local_plt == NULL)
2337                 return FALSE;
2338
2339               /* Address of the PLT slot.  */
2340               relocation = (htab->elf.iplt->output_section->vma
2341                             + htab->elf.iplt->output_offset
2342                             + local_plt[r_symndx].plt.offset);
2343
2344               switch (r_type)
2345                 {
2346                 case R_390_PLTOFF16:
2347                 case R_390_PLTOFF32:
2348                 case R_390_PLTOFF64:
2349                   relocation -= htab->elf.sgot->output_section->vma;
2350                   break;
2351                 case R_390_GOTPLT12:
2352                 case R_390_GOTPLT16:
2353                 case R_390_GOTPLT20:
2354                 case R_390_GOTPLT32:
2355                 case R_390_GOTPLT64:
2356                 case R_390_GOTPLTENT:
2357                 case R_390_GOT12:
2358                 case R_390_GOT16:
2359                 case R_390_GOT20:
2360                 case R_390_GOT32:
2361                 case R_390_GOT64:
2362                 case R_390_GOTENT:
2363                   {
2364                     /* Write the PLT slot address into the GOT slot.  */
2365                     bfd_put_64 (output_bfd, relocation,
2366                                 htab->elf.sgot->contents +
2367                                 local_got_offsets[r_symndx]);
2368                     relocation = (local_got_offsets[r_symndx] +
2369                                   htab->elf.sgot->output_offset);
2370
2371                     if (r_type == R_390_GOTENT || r_type == R_390_GOTPLTENT)
2372                       relocation += htab->elf.sgot->output_section->vma;
2373                     break;
2374                   }
2375                 default:
2376                   break;
2377                 }
2378               /* The output section is needed later in
2379                  finish_dynamic_section when creating the dynamic
2380                  relocation.  */
2381               local_plt[r_symndx].sec = sec;
2382               goto do_relocation;
2383             }
2384           else
2385             relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2386         }
2387       else
2388         {
2389           bfd_boolean warned ATTRIBUTE_UNUSED;
2390           bfd_boolean ignored ATTRIBUTE_UNUSED;
2391
2392           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2393                                    r_symndx, symtab_hdr, sym_hashes,
2394                                    h, sec, relocation,
2395                                    unresolved_reloc, warned, ignored);
2396         }
2397
2398       if (sec != NULL && discarded_section (sec))
2399         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2400                                          rel, 1, relend, howto, 0, contents);
2401
2402       if (bfd_link_relocatable (info))
2403         continue;
2404
2405       switch (r_type)
2406         {
2407         case R_390_GOTPLT12:
2408         case R_390_GOTPLT16:
2409         case R_390_GOTPLT20:
2410         case R_390_GOTPLT32:
2411         case R_390_GOTPLT64:
2412         case R_390_GOTPLTENT:
2413           /* There are three cases for a GOTPLT relocation. 1) The
2414              relocation is against the jump slot entry of a plt that
2415              will get emitted to the output file. 2) The relocation
2416              is against the jump slot of a plt entry that has been
2417              removed. elf_s390_adjust_gotplt has created a GOT entry
2418              as replacement. 3) The relocation is against a local symbol.
2419              Cases 2) and 3) are the same as the GOT relocation code
2420              so we just have to test for case 1 and fall through for
2421              the other two.  */
2422           if (h != NULL && h->plt.offset != (bfd_vma) -1)
2423             {
2424               bfd_vma plt_index;
2425
2426               if (s390_is_ifunc_symbol_p (h))
2427                 {
2428                   plt_index = h->plt.offset / PLT_ENTRY_SIZE;
2429                   relocation = (plt_index * GOT_ENTRY_SIZE +
2430                                 htab->elf.igotplt->output_offset);
2431                   if (r_type == R_390_GOTPLTENT)
2432                     relocation += htab->elf.igotplt->output_section->vma;
2433                 }
2434               else
2435                 {
2436                   /* Calc. index no.
2437                      Current offset - size first entry / entry size.  */
2438                   plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) /
2439                     PLT_ENTRY_SIZE;
2440
2441                   /* Offset in GOT is PLT index plus GOT headers(3)
2442                      times 8, addr & GOT addr.  */
2443                   relocation = (plt_index + 3) * GOT_ENTRY_SIZE;
2444                   if (r_type == R_390_GOTPLTENT)
2445                     relocation += htab->elf.sgot->output_section->vma;
2446                 }
2447               unresolved_reloc = FALSE;
2448               break;
2449             }
2450           /* Fall through.  */
2451
2452         case R_390_GOT12:
2453         case R_390_GOT16:
2454         case R_390_GOT20:
2455         case R_390_GOT32:
2456         case R_390_GOT64:
2457         case R_390_GOTENT:
2458           /* Relocation is to the entry for this symbol in the global
2459              offset table.  */
2460           if (base_got == NULL)
2461             abort ();
2462
2463           if (h != NULL)
2464             {
2465               bfd_boolean dyn;
2466
2467               off = h->got.offset;
2468               dyn = htab->elf.dynamic_sections_created;
2469
2470               if (s390_is_ifunc_symbol_p (h))
2471                 {
2472                   BFD_ASSERT (h->plt.offset != (bfd_vma) -1);
2473                   if (off == (bfd_vma)-1)
2474                     {
2475                       /* No explicit GOT usage so redirect to the
2476                          got.iplt slot.  */
2477                       base_got = htab->elf.igotplt;
2478                       off = h->plt.offset / PLT_ENTRY_SIZE * GOT_ENTRY_SIZE;
2479                     }
2480                   else
2481                     {
2482                       /* Explicit GOT slots must contain the address
2483                          of the PLT slot. This will be handled in
2484                          finish_dynamic_symbol.  */
2485                     }
2486                 }
2487               else if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
2488                                                           bfd_link_pic (info),
2489                                                           h)
2490                        || (bfd_link_pic (info)
2491                            && SYMBOL_REFERENCES_LOCAL (info, h))
2492                        || (ELF_ST_VISIBILITY (h->other)
2493                            && h->root.type == bfd_link_hash_undefweak))
2494                 {
2495                   /* This is actually a static link, or it is a
2496                      -Bsymbolic link and the symbol is defined
2497                      locally, or the symbol was forced to be local
2498                      because of a version file.  We must initialize
2499                      this entry in the global offset table.  Since the
2500                      offset must always be a multiple of 2, we use the
2501                      least significant bit to record whether we have
2502                      initialized it already.
2503
2504                      When doing a dynamic link, we create a .rel.got
2505                      relocation entry to initialize the value.  This
2506                      is done in the finish_dynamic_symbol routine.  */
2507                   if ((off & 1) != 0)
2508                     off &= ~1;
2509                   else
2510                     {
2511                       bfd_put_64 (output_bfd, relocation,
2512                                   base_got->contents + off);
2513                       h->got.offset |= 1;
2514                     }
2515
2516                   if ((h->def_regular
2517                        && bfd_link_pic (info)
2518                        && SYMBOL_REFERENCES_LOCAL (info, h))
2519                       /* lgrl rx,sym@GOTENT -> larl rx, sym */
2520                       && ((r_type == R_390_GOTENT
2521                            && (bfd_get_16 (input_bfd,
2522                                            contents + rel->r_offset - 2)
2523                                & 0xff0f) == 0xc408)
2524                           /* lg rx, sym@GOT(r12) -> larl rx, sym */
2525                           || (r_type == R_390_GOT20
2526                               && (bfd_get_32 (input_bfd,
2527                                               contents + rel->r_offset - 2)
2528                                   & 0xff00f000) == 0xe300c000
2529                               && bfd_get_8 (input_bfd,
2530                                             contents + rel->r_offset + 3) == 0x04)))
2531
2532                     {
2533                       unsigned short new_insn =
2534                         (0xc000 | (bfd_get_8 (input_bfd,
2535                                               contents + rel->r_offset - 1) & 0xf0));
2536                       bfd_put_16 (output_bfd, new_insn,
2537                                   contents + rel->r_offset - 2);
2538                       r_type = R_390_PC32DBL;
2539                       rel->r_addend = 2;
2540                       howto = elf_howto_table + r_type;
2541                       relocation = h->root.u.def.value
2542                         + h->root.u.def.section->output_section->vma
2543                         + h->root.u.def.section->output_offset;
2544                       goto do_relocation;
2545                     }
2546                 }
2547               else
2548                 unresolved_reloc = FALSE;
2549             }
2550           else
2551             {
2552               if (local_got_offsets == NULL)
2553                 abort ();
2554
2555               off = local_got_offsets[r_symndx];
2556
2557               /* The offset must always be a multiple of 8.  We use
2558                  the least significant bit to record whether we have
2559                  already generated the necessary reloc.  */
2560               if ((off & 1) != 0)
2561                 off &= ~1;
2562               else
2563                 {
2564                   bfd_put_64 (output_bfd, relocation,
2565                               htab->elf.sgot->contents + off);
2566
2567                   if (bfd_link_pic (info))
2568                     {
2569                       asection *s;
2570                       Elf_Internal_Rela outrel;
2571                       bfd_byte *loc;
2572
2573                       s = htab->elf.srelgot;
2574                       if (s == NULL)
2575                         abort ();
2576
2577                       outrel.r_offset = (htab->elf.sgot->output_section->vma
2578                                          + htab->elf.sgot->output_offset
2579                                          + off);
2580                       outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2581                       outrel.r_addend = relocation;
2582                       loc = s->contents;
2583                       loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
2584                       bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2585                     }
2586
2587                   local_got_offsets[r_symndx] |= 1;
2588                 }
2589             }
2590
2591           if (off >= (bfd_vma) -2)
2592             abort ();
2593
2594           relocation = base_got->output_offset + off;
2595
2596           /* For @GOTENT the relocation is against the offset between
2597              the instruction and the symbols entry in the GOT and not
2598              between the start of the GOT and the symbols entry. We
2599              add the vma of the GOT to get the correct value.  */
2600           if (   r_type == R_390_GOTENT
2601               || r_type == R_390_GOTPLTENT)
2602             relocation += base_got->output_section->vma;
2603
2604           break;
2605
2606         case R_390_GOTOFF16:
2607         case R_390_GOTOFF32:
2608         case R_390_GOTOFF64:
2609           /* Relocation is relative to the start of the global offset
2610              table.  */
2611
2612           if (h != NULL
2613               && s390_is_ifunc_symbol_p (h)
2614               && h->def_regular
2615               && !bfd_link_executable (info))
2616             {
2617               relocation = (htab->elf.iplt->output_section->vma
2618                             + htab->elf.iplt->output_offset
2619                             + h->plt.offset
2620                             - htab->elf.sgot->output_section->vma);
2621               goto do_relocation;
2622             }
2623
2624           /* Note that sgot->output_offset is not involved in this
2625              calculation.  We always want the start of .got.  If we
2626              defined _GLOBAL_OFFSET_TABLE in a different way, as is
2627              permitted by the ABI, we might have to change this
2628              calculation.  */
2629           relocation -= htab->elf.sgot->output_section->vma;
2630           break;
2631
2632         case R_390_GOTPC:
2633         case R_390_GOTPCDBL:
2634           /* Use global offset table as symbol value.  */
2635           relocation = htab->elf.sgot->output_section->vma;
2636           unresolved_reloc = FALSE;
2637           break;
2638
2639         case R_390_PLT12DBL:
2640         case R_390_PLT16DBL:
2641         case R_390_PLT24DBL:
2642         case R_390_PLT32:
2643         case R_390_PLT32DBL:
2644         case R_390_PLT64:
2645           /* Relocation is to the entry for this symbol in the
2646              procedure linkage table.  */
2647
2648           /* Resolve a PLT32 reloc against a local symbol directly,
2649              without using the procedure linkage table.  */
2650           if (h == NULL)
2651             break;
2652
2653           if (h->plt.offset == (bfd_vma) -1
2654               || (htab->elf.splt == NULL && !s390_is_ifunc_symbol_p (h)))
2655             {
2656               /* We didn't make a PLT entry for this symbol.  This
2657                  happens when statically linking PIC code, or when
2658                  using -Bsymbolic.  */
2659               break;
2660             }
2661           if (s390_is_ifunc_symbol_p (h))
2662             relocation = (htab->elf.iplt->output_section->vma
2663                           + htab->elf.iplt->output_offset
2664                           + h->plt.offset);
2665           else
2666             relocation = (htab->elf.splt->output_section->vma
2667                           + htab->elf.splt->output_offset
2668                           + h->plt.offset);
2669           unresolved_reloc = FALSE;
2670           break;
2671
2672         case R_390_PLTOFF16:
2673         case R_390_PLTOFF32:
2674         case R_390_PLTOFF64:
2675           /* Relocation is to the entry for this symbol in the
2676              procedure linkage table relative to the start of the GOT.  */
2677
2678           /* For local symbols or if we didn't make a PLT entry for
2679              this symbol resolve the symbol directly.  */
2680           if (h == NULL
2681               || h->plt.offset == (bfd_vma) -1
2682               || (htab->elf.splt == NULL && !s390_is_ifunc_symbol_p (h)))
2683             {
2684               relocation -= htab->elf.sgot->output_section->vma;
2685               break;
2686             }
2687
2688           if (s390_is_ifunc_symbol_p (h))
2689             relocation = (htab->elf.iplt->output_section->vma
2690                           + htab->elf.iplt->output_offset
2691                           + h->plt.offset
2692                           - htab->elf.sgot->output_section->vma);
2693           else
2694             relocation = (htab->elf.splt->output_section->vma
2695                           + htab->elf.splt->output_offset
2696                           + h->plt.offset
2697                           - htab->elf.sgot->output_section->vma);
2698           unresolved_reloc = FALSE;
2699           break;
2700
2701         case R_390_PC16:
2702         case R_390_PC12DBL:
2703         case R_390_PC16DBL:
2704         case R_390_PC24DBL:
2705         case R_390_PC32:
2706         case R_390_PC32DBL:
2707         case R_390_PC64:
2708           if (h != NULL
2709               && bfd_link_pie (info)
2710               && !h->def_regular)
2711             {
2712               _bfd_error_handler (_("%B: `%s' non-PLT reloc for symbol defined "
2713                                     "in shared library and accessed "
2714                                     "from executable "
2715                                     "(rebuild file with -fPIC ?)"),
2716                                   input_bfd, h->root.root.string);
2717               bfd_set_error (bfd_error_bad_value);
2718               return FALSE;
2719             }
2720           /* The target of these relocs are instruction operands
2721              residing in read-only sections.  We cannot emit a runtime
2722              reloc for it.  */
2723           if (h != NULL
2724               && s390_is_ifunc_symbol_p (h)
2725               && h->def_regular
2726               && bfd_link_pic (info))
2727             {
2728               relocation = (htab->elf.iplt->output_section->vma
2729                             + htab->elf.iplt->output_offset
2730                             + h->plt.offset);
2731               goto do_relocation;
2732             }
2733           /* Fall through.  */
2734
2735         case R_390_8:
2736         case R_390_16:
2737         case R_390_32:
2738         case R_390_64:
2739
2740           if (h != NULL
2741               && s390_is_ifunc_symbol_p (h)
2742               && h->def_regular)
2743             {
2744               if (!bfd_link_pic (info))
2745                 {
2746                   /* For a non-shared object the symbol will not
2747                      change.  Hence we can write the address of the
2748                      target IPLT slot now.  */
2749                   relocation = (htab->elf.iplt->output_section->vma
2750                                 + htab->elf.iplt->output_offset
2751                                 + h ->plt.offset);
2752                   goto do_relocation;
2753                 }
2754               else
2755                 {
2756                   /* For shared objects a runtime relocation is needed.  */
2757
2758                   Elf_Internal_Rela outrel;
2759                   asection *sreloc;
2760
2761                   /* Need a dynamic relocation to get the real function
2762                      address.  */
2763                   outrel.r_offset = _bfd_elf_section_offset (output_bfd,
2764                                                              info,
2765                                                              input_section,
2766                                                              rel->r_offset);
2767                   if (outrel.r_offset == (bfd_vma) -1
2768                       || outrel.r_offset == (bfd_vma) -2)
2769                     abort ();
2770
2771                   outrel.r_offset += (input_section->output_section->vma
2772                                       + input_section->output_offset);
2773
2774                   if (h->dynindx == -1
2775                       || h->forced_local
2776                       || bfd_link_executable (info))
2777                     {
2778                       /* This symbol is resolved locally.  */
2779                       outrel.r_info = ELF64_R_INFO (0, R_390_IRELATIVE);
2780                       outrel.r_addend = (h->root.u.def.value
2781                                          + h->root.u.def.section->output_section->vma
2782                                          + h->root.u.def.section->output_offset);
2783                     }
2784                   else
2785                     {
2786                       outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
2787                       outrel.r_addend = 0;
2788                     }
2789
2790                   sreloc = htab->elf.irelifunc;
2791                   elf_append_rela (output_bfd, sreloc, &outrel);
2792
2793                   /* If this reloc is against an external symbol, we
2794                      do not want to fiddle with the addend.  Otherwise,
2795                      we need to include the symbol value so that it
2796                      becomes an addend for the dynamic reloc.  For an
2797                      internal symbol, we have updated addend.  */
2798                   continue;
2799                 }
2800             }
2801
2802           if ((input_section->flags & SEC_ALLOC) == 0)
2803             break;
2804
2805           if ((bfd_link_pic (info)
2806                && (h == NULL
2807                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2808                    || h->root.type != bfd_link_hash_undefweak)
2809                && ((r_type != R_390_PC16
2810                     && r_type != R_390_PC12DBL
2811                     && r_type != R_390_PC16DBL
2812                     && r_type != R_390_PC24DBL
2813                     && r_type != R_390_PC32
2814                     && r_type != R_390_PC32DBL
2815                     && r_type != R_390_PC64)
2816                    || !SYMBOL_CALLS_LOCAL (info, h)))
2817               || (ELIMINATE_COPY_RELOCS
2818                   && !bfd_link_pic (info)
2819                   && h != NULL
2820                   && h->dynindx != -1
2821                   && !h->non_got_ref
2822                   && ((h->def_dynamic
2823                        && !h->def_regular)
2824                       || h->root.type == bfd_link_hash_undefweak
2825                       || h->root.type == bfd_link_hash_undefined)))
2826             {
2827               Elf_Internal_Rela outrel;
2828               bfd_boolean skip, relocate;
2829               asection *sreloc;
2830               bfd_byte *loc;
2831
2832               /* When generating a shared object, these relocations
2833                  are copied into the output file to be resolved at run
2834                  time.  */
2835               skip = FALSE;
2836               relocate = FALSE;
2837
2838               outrel.r_offset =
2839                 _bfd_elf_section_offset (output_bfd, info, input_section,
2840                                          rel->r_offset);
2841               if (outrel.r_offset == (bfd_vma) -1)
2842                 skip = TRUE;
2843               else if (outrel.r_offset == (bfd_vma) -2)
2844                 skip = TRUE, relocate = TRUE;
2845
2846               outrel.r_offset += (input_section->output_section->vma
2847                                   + input_section->output_offset);
2848
2849               if (skip)
2850                 memset (&outrel, 0, sizeof outrel);
2851               else if (h != NULL
2852                        && h->dynindx != -1
2853                        && (r_type == R_390_PC16
2854                            || r_type == R_390_PC12DBL
2855                            || r_type == R_390_PC16DBL
2856                            || r_type == R_390_PC24DBL
2857                            || r_type == R_390_PC32
2858                            || r_type == R_390_PC32DBL
2859                            || r_type == R_390_PC64
2860                            || !bfd_link_pic (info)
2861                            || !SYMBOLIC_BIND (info, h)
2862                            || !h->def_regular))
2863                 {
2864                   outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
2865                   outrel.r_addend = rel->r_addend;
2866                 }
2867               else
2868                 {
2869                   /* This symbol is local, or marked to become local.  */
2870                   outrel.r_addend = relocation + rel->r_addend;
2871                   if (r_type == R_390_64)
2872                     {
2873                       relocate = TRUE;
2874                       outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2875                     }
2876                   else
2877                     {
2878                       long sindx;
2879
2880                       if (bfd_is_abs_section (sec))
2881                         sindx = 0;
2882                       else if (sec == NULL || sec->owner == NULL)
2883                         {
2884                           bfd_set_error(bfd_error_bad_value);
2885                           return FALSE;
2886                         }
2887                       else
2888                         {
2889                           asection *osec;
2890
2891                           osec = sec->output_section;
2892                           sindx = elf_section_data (osec)->dynindx;
2893
2894                           if (sindx == 0)
2895                             {
2896                               osec = htab->elf.text_index_section;
2897                               sindx = elf_section_data (osec)->dynindx;
2898                             }
2899                           BFD_ASSERT (sindx != 0);
2900
2901                           /* We are turning this relocation into one
2902                              against a section symbol, so subtract out
2903                              the output section's address but not the
2904                              offset of the input section in the output
2905                              section.  */
2906                           outrel.r_addend -= osec->vma;
2907                         }
2908                       outrel.r_info = ELF64_R_INFO (sindx, r_type);
2909                     }
2910                 }
2911
2912               sreloc = elf_section_data (input_section)->sreloc;
2913               if (sreloc == NULL)
2914                 abort ();
2915
2916               loc = sreloc->contents;
2917               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2918               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2919
2920               /* If this reloc is against an external symbol, we do
2921                  not want to fiddle with the addend.  Otherwise, we
2922                  need to include the symbol value so that it becomes
2923                  an addend for the dynamic reloc.  */
2924               if (! relocate)
2925                 continue;
2926             }
2927
2928           break;
2929
2930           /* Relocations for tls literal pool entries.  */
2931         case R_390_TLS_IE64:
2932           if (bfd_link_pic (info))
2933             {
2934               Elf_Internal_Rela outrel;
2935               asection *sreloc;
2936               bfd_byte *loc;
2937
2938               outrel.r_offset = rel->r_offset
2939                                 + input_section->output_section->vma
2940                                 + input_section->output_offset;
2941               outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2942               sreloc = elf_section_data (input_section)->sreloc;
2943               if (sreloc == NULL)
2944                 abort ();
2945               loc = sreloc->contents;
2946               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2947               bfd_elf64_swap_reloc_out (output_bfd, &outrel, loc);
2948             }
2949           /* Fall through.  */
2950
2951         case R_390_TLS_GD64:
2952         case R_390_TLS_GOTIE64:
2953           r_type = elf_s390_tls_transition (info, r_type, h == NULL);
2954           tls_type = GOT_UNKNOWN;
2955           if (h == NULL && local_got_offsets)
2956             tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
2957           else if (h != NULL)
2958             {
2959               tls_type = elf_s390_hash_entry(h)->tls_type;
2960               if (!bfd_link_pic (info) && h->dynindx == -1 && tls_type >= GOT_TLS_IE)
2961                 r_type = R_390_TLS_LE64;
2962             }
2963           if (r_type == R_390_TLS_GD64 && tls_type >= GOT_TLS_IE)
2964             r_type = R_390_TLS_IE64;
2965
2966           if (r_type == R_390_TLS_LE64)
2967             {
2968               /* This relocation gets optimized away by the local exec
2969                  access optimization.  */
2970               BFD_ASSERT (! unresolved_reloc);
2971               bfd_put_64 (output_bfd, -tpoff (info, relocation),
2972                           contents + rel->r_offset);
2973               continue;
2974             }
2975
2976           if (htab->elf.sgot == NULL)
2977             abort ();
2978
2979           if (h != NULL)
2980             off = h->got.offset;
2981           else
2982             {
2983               if (local_got_offsets == NULL)
2984                 abort ();
2985
2986               off = local_got_offsets[r_symndx];
2987             }
2988
2989         emit_tls_relocs:
2990
2991           if ((off & 1) != 0)
2992             off &= ~1;
2993           else
2994             {
2995               Elf_Internal_Rela outrel;
2996               bfd_byte *loc;
2997               int dr_type, indx;
2998
2999               if (htab->elf.srelgot == NULL)
3000                 abort ();
3001
3002               outrel.r_offset = (htab->elf.sgot->output_section->vma
3003                                  + htab->elf.sgot->output_offset + off);
3004
3005               indx = h && h->dynindx != -1 ? h->dynindx : 0;
3006               if (r_type == R_390_TLS_GD64)
3007                 dr_type = R_390_TLS_DTPMOD;
3008               else
3009                 dr_type = R_390_TLS_TPOFF;
3010               if (dr_type == R_390_TLS_TPOFF && indx == 0)
3011                 outrel.r_addend = relocation - dtpoff_base (info);
3012               else
3013                 outrel.r_addend = 0;
3014               outrel.r_info = ELF64_R_INFO (indx, dr_type);
3015               loc = htab->elf.srelgot->contents;
3016               loc += htab->elf.srelgot->reloc_count++
3017                 * sizeof (Elf64_External_Rela);
3018               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
3019
3020               if (r_type == R_390_TLS_GD64)
3021                 {
3022                   if (indx == 0)
3023                     {
3024                       BFD_ASSERT (! unresolved_reloc);
3025                       bfd_put_64 (output_bfd,
3026                                   relocation - dtpoff_base (info),
3027                                   htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3028                     }
3029                   else
3030                     {
3031                       outrel.r_info = ELF64_R_INFO (indx, R_390_TLS_DTPOFF);
3032                       outrel.r_offset += GOT_ENTRY_SIZE;
3033                       outrel.r_addend = 0;
3034                       htab->elf.srelgot->reloc_count++;
3035                       loc += sizeof (Elf64_External_Rela);
3036                       bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
3037                     }
3038                 }
3039
3040               if (h != NULL)
3041                 h->got.offset |= 1;
3042               else
3043                 local_got_offsets[r_symndx] |= 1;
3044             }
3045
3046           if (off >= (bfd_vma) -2)
3047             abort ();
3048           if (r_type == ELF64_R_TYPE (rel->r_info))
3049             {
3050               relocation = htab->elf.sgot->output_offset + off;
3051               if (r_type == R_390_TLS_IE64 || r_type == R_390_TLS_IEENT)
3052                 relocation += htab->elf.sgot->output_section->vma;
3053               unresolved_reloc = FALSE;
3054             }
3055           else
3056             {
3057               bfd_put_64 (output_bfd, htab->elf.sgot->output_offset + off,
3058                           contents + rel->r_offset);
3059               continue;
3060             }
3061           break;
3062
3063         case R_390_TLS_GOTIE12:
3064         case R_390_TLS_GOTIE20:
3065         case R_390_TLS_IEENT:
3066           if (h == NULL)
3067             {
3068               if (local_got_offsets == NULL)
3069                 abort();
3070               off = local_got_offsets[r_symndx];
3071               if (bfd_link_pic (info))
3072                 goto emit_tls_relocs;
3073             }
3074           else
3075             {
3076               off = h->got.offset;
3077               tls_type = elf_s390_hash_entry(h)->tls_type;
3078               if (bfd_link_pic (info) || h->dynindx != -1 || tls_type < GOT_TLS_IE)
3079                 goto emit_tls_relocs;
3080             }
3081
3082           if (htab->elf.sgot == NULL)
3083             abort ();
3084
3085           BFD_ASSERT (! unresolved_reloc);
3086           bfd_put_64 (output_bfd, -tpoff (info, relocation),
3087                       htab->elf.sgot->contents + off);
3088           relocation = htab->elf.sgot->output_offset + off;
3089           if (r_type == R_390_TLS_IEENT)
3090             relocation += htab->elf.sgot->output_section->vma;
3091           unresolved_reloc = FALSE;
3092           break;
3093
3094         case R_390_TLS_LDM64:
3095           if (! bfd_link_pic (info))
3096             /* The literal pool entry this relocation refers to gets ignored
3097                by the optimized code of the local exec model. Do nothing
3098                and the value will turn out zero.  */
3099             continue;
3100
3101           if (htab->elf.sgot == NULL)
3102             abort ();
3103
3104           off = htab->tls_ldm_got.offset;
3105           if (off & 1)
3106             off &= ~1;
3107           else
3108             {
3109               Elf_Internal_Rela outrel;
3110               bfd_byte *loc;
3111
3112               if (htab->elf.srelgot == NULL)
3113                 abort ();
3114
3115               outrel.r_offset = (htab->elf.sgot->output_section->vma
3116                                  + htab->elf.sgot->output_offset + off);
3117
3118               bfd_put_64 (output_bfd, 0,
3119                           htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3120               outrel.r_info = ELF64_R_INFO (0, R_390_TLS_DTPMOD);
3121               outrel.r_addend = 0;
3122               loc = htab->elf.srelgot->contents;
3123               loc += htab->elf.srelgot->reloc_count++
3124                 * sizeof (Elf64_External_Rela);
3125               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
3126               htab->tls_ldm_got.offset |= 1;
3127             }
3128           relocation = htab->elf.sgot->output_offset + off;
3129           unresolved_reloc = FALSE;
3130           break;
3131
3132         case R_390_TLS_LE64:
3133           if (bfd_link_dll (info))
3134             {
3135               /* Linking a shared library with non-fpic code requires
3136                  a R_390_TLS_TPOFF relocation.  */
3137               Elf_Internal_Rela outrel;
3138               asection *sreloc;
3139               bfd_byte *loc;
3140               int indx;
3141
3142               outrel.r_offset = rel->r_offset
3143                                 + input_section->output_section->vma
3144                                 + input_section->output_offset;
3145               if (h != NULL && h->dynindx != -1)
3146                 indx = h->dynindx;
3147               else
3148                 indx = 0;
3149               outrel.r_info = ELF64_R_INFO (indx, R_390_TLS_TPOFF);
3150               if (indx == 0)
3151                 outrel.r_addend = relocation - dtpoff_base (info);
3152               else
3153                 outrel.r_addend = 0;
3154               sreloc = elf_section_data (input_section)->sreloc;
3155               if (sreloc == NULL)
3156                 abort ();
3157               loc = sreloc->contents;
3158               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
3159               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
3160             }
3161           else
3162             {
3163               BFD_ASSERT (! unresolved_reloc);
3164               bfd_put_64 (output_bfd, -tpoff (info, relocation),
3165                           contents + rel->r_offset);
3166             }
3167           continue;
3168
3169         case R_390_TLS_LDO64:
3170           if (bfd_link_pic (info) || (input_section->flags & SEC_DEBUGGING))
3171             relocation -= dtpoff_base (info);
3172           else
3173             /* When converting LDO to LE, we must negate.  */
3174             relocation = -tpoff (info, relocation);
3175           break;
3176
3177           /* Relocations for tls instructions.  */
3178         case R_390_TLS_LOAD:
3179         case R_390_TLS_GDCALL:
3180         case R_390_TLS_LDCALL:
3181           tls_type = GOT_UNKNOWN;
3182           if (h == NULL && local_got_offsets)
3183             tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
3184           else if (h != NULL)
3185             tls_type = elf_s390_hash_entry(h)->tls_type;
3186
3187           if (tls_type == GOT_TLS_GD)
3188             continue;
3189
3190           if (r_type == R_390_TLS_LOAD)
3191             {
3192               if (!bfd_link_pic (info) && (h == NULL || h->dynindx == -1))
3193                 {
3194                   /* IE->LE transition. Four valid cases:
3195                      lg %rx,(0,%ry)    -> sllg %rx,%ry,0
3196                      lg %rx,(%ry,0)    -> sllg %rx,%ry,0
3197                      lg %rx,(%ry,%r12) -> sllg %rx,%ry,0
3198                      lg %rx,(%r12,%ry) -> sllg %rx,%ry,0  */
3199                   unsigned int insn0, insn1, ry;
3200
3201                   insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset);
3202                   insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4);
3203                   if (insn1 != 0x0004)
3204                     {
3205                       invalid_tls_insn (input_bfd, input_section, rel);
3206                       return FALSE;
3207                     }
3208                   if ((insn0 & 0xff00f000) == 0xe3000000)
3209                     /* lg %rx,0(%ry,0) -> sllg %rx,%ry,0  */
3210                     ry = (insn0 & 0x000f0000);
3211                   else if ((insn0 & 0xff0f0000) == 0xe3000000)
3212                     /* lg %rx,0(0,%ry) -> sllg %rx,%ry,0  */
3213                     ry = (insn0 & 0x0000f000) << 4;
3214                   else if ((insn0 & 0xff00f000) == 0xe300c000)
3215                     /* lg %rx,0(%ry,%r12) -> sllg %rx,%ry,0  */
3216                     ry = (insn0 & 0x000f0000);
3217                   else if ((insn0 & 0xff0f0000) == 0xe30c0000)
3218                     /* lg %rx,0(%r12,%ry) -> sllg %rx,%ry,0  */
3219                     ry = (insn0 & 0x0000f000) << 4;
3220                   else
3221                     {
3222                       invalid_tls_insn (input_bfd, input_section, rel);
3223                       return FALSE;
3224                     }
3225                   insn0 = 0xeb000000 | (insn0 & 0x00f00000) | ry;
3226                   insn1 = 0x000d;
3227                   bfd_put_32 (output_bfd, insn0, contents + rel->r_offset);
3228                   bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4);
3229                 }
3230             }
3231           else if (r_type == R_390_TLS_GDCALL)
3232             {
3233               unsigned int insn0, insn1;
3234
3235               insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset);
3236               insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4);
3237               if ((insn0 & 0xffff0000) != 0xc0e50000)
3238                 {
3239                   invalid_tls_insn (input_bfd, input_section, rel);
3240                   return FALSE;
3241                 }
3242               if (!bfd_link_pic (info) && (h == NULL || h->dynindx == -1))
3243                 {
3244                   /* GD->LE transition.
3245                      brasl %r14,__tls_get_addr@plt -> brcl 0,. */
3246                   insn0 = 0xc0040000;
3247                   insn1 = 0x0000;
3248                 }
3249               else
3250                 {
3251                   /* GD->IE transition.
3252                      brasl %r14,__tls_get_addr@plt -> lg %r2,0(%r2,%r12)  */
3253                   insn0 = 0xe322c000;
3254                   insn1 = 0x0004;
3255                 }
3256               bfd_put_32 (output_bfd, insn0, contents + rel->r_offset);
3257               bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4);
3258             }
3259           else if (r_type == R_390_TLS_LDCALL)
3260             {
3261               if (!bfd_link_pic (info))
3262                 {
3263                   unsigned int insn0, insn1;
3264
3265                   insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset);
3266                   insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4);
3267                   if ((insn0 & 0xffff0000) != 0xc0e50000)
3268                     {
3269                       invalid_tls_insn (input_bfd, input_section, rel);
3270                       return FALSE;
3271                     }
3272                   /* LD->LE transition.
3273                      brasl %r14,__tls_get_addr@plt -> brcl 0,. */
3274                   insn0 = 0xc0040000;
3275                   insn1 = 0x0000;
3276                   bfd_put_32 (output_bfd, insn0, contents + rel->r_offset);
3277                   bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4);
3278                 }
3279             }
3280           continue;
3281
3282         default:
3283           break;
3284         }
3285
3286       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3287          because such sections are not SEC_ALLOC and thus ld.so will
3288          not process them.  */
3289       if (unresolved_reloc
3290           && !((input_section->flags & SEC_DEBUGGING) != 0
3291                && h->def_dynamic)
3292           && _bfd_elf_section_offset (output_bfd, info, input_section,
3293                                       rel->r_offset) != (bfd_vma) -1)
3294         _bfd_error_handler
3295           /* xgettext:c-format */
3296           (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
3297            input_bfd,
3298            input_section,
3299            rel->r_offset,
3300            howto->name,
3301            h->root.root.string);
3302
3303     do_relocation:
3304
3305       /* When applying a 24 bit reloc we need to start one byte
3306          earlier.  Otherwise the 32 bit get/put bfd operations might
3307          access a byte after the actual section.  */
3308       if (r_type == R_390_PC24DBL
3309           || r_type == R_390_PLT24DBL)
3310         rel->r_offset--;
3311
3312       if (r_type == R_390_20
3313           || r_type == R_390_GOT20
3314           || r_type == R_390_GOTPLT20
3315           || r_type == R_390_TLS_GOTIE20)
3316         {
3317           relocation += rel->r_addend;
3318           relocation = (relocation&0xfff) << 8 | (relocation&0xff000) >> 12;
3319           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3320                                         contents, rel->r_offset,
3321                                         relocation, 0);
3322         }
3323       else
3324         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3325                                       contents, rel->r_offset,
3326                                       relocation, rel->r_addend);
3327
3328       if (r != bfd_reloc_ok)
3329         {
3330           const char *name;
3331
3332           if (h != NULL)
3333             name = h->root.root.string;
3334           else
3335             {
3336               name = bfd_elf_string_from_elf_section (input_bfd,
3337                                                       symtab_hdr->sh_link,
3338                                                       sym->st_name);
3339               if (name == NULL)
3340                 return FALSE;
3341               if (*name == '\0')
3342                 name = bfd_section_name (input_bfd, sec);
3343             }
3344
3345           if (r == bfd_reloc_overflow)
3346             (*info->callbacks->reloc_overflow)
3347               (info, (h ? &h->root : NULL), name, howto->name,
3348                (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
3349           else
3350             {
3351               _bfd_error_handler
3352                 /* xgettext:c-format */
3353                 (_("%B(%A+%#Lx): reloc against `%s': error %d"),
3354                  input_bfd, input_section,
3355                  rel->r_offset, name, (int) r);
3356               return FALSE;
3357             }
3358         }
3359     }
3360
3361   return TRUE;
3362 }
3363
3364 /* Generate the PLT slots together with the dynamic relocations needed
3365    for IFUNC symbols.  */
3366
3367 static void
3368 elf_s390_finish_ifunc_symbol (bfd *output_bfd,
3369                               struct bfd_link_info *info,
3370                               struct elf_link_hash_entry *h,
3371                               struct elf_s390_link_hash_table *htab,
3372                               bfd_vma plt_offset,
3373                               bfd_vma resolver_address)
3374 {
3375   bfd_vma plt_index;
3376   bfd_vma got_offset;
3377   Elf_Internal_Rela rela;
3378   bfd_byte *loc;
3379   asection *plt, *gotplt, *relplt;
3380
3381   if (htab->elf.iplt == NULL
3382       || htab->elf.igotplt == NULL
3383       || htab->elf.irelplt == NULL)
3384     abort ();
3385
3386   /* Index of the PLT slot within iplt section.  */
3387   plt_index = plt_offset / PLT_ENTRY_SIZE;
3388   plt = htab->elf.iplt;
3389   /* Offset into the igot.plt section.  */
3390   got_offset = plt_index * GOT_ENTRY_SIZE;
3391   gotplt = htab->elf.igotplt;
3392   relplt = htab->elf.irelplt;
3393
3394   /* Fill in the blueprint of a PLT.  */
3395   memcpy (plt->contents + plt_offset, elf_s390x_plt_entry,
3396           PLT_ENTRY_SIZE);
3397
3398   /* Fixup the relative address to the GOT entry */
3399   bfd_put_32 (output_bfd,
3400               (gotplt->output_section->vma +
3401                gotplt->output_offset + got_offset
3402                - (plt->output_section->vma +
3403                   plt->output_offset +
3404                   plt_offset))/2,
3405               plt->contents + plt_offset + 2);
3406   /* Fixup the relative branch to PLT 0 */
3407   bfd_put_32 (output_bfd, - (plt->output_offset +
3408                              (PLT_ENTRY_SIZE * plt_index) + 22)/2,
3409               plt->contents + plt_offset + 24);
3410   /* Fixup offset into .rela.plt section.  */
3411   bfd_put_32 (output_bfd, relplt->output_offset +
3412               plt_index * sizeof (Elf64_External_Rela),
3413               plt->contents + plt_offset + 28);
3414
3415   /* Fill in the entry in the global offset table.
3416      Points to instruction after GOT offset.  */
3417   bfd_put_64 (output_bfd,
3418               (plt->output_section->vma
3419                + plt->output_offset
3420                + plt_offset
3421                + 14),
3422               gotplt->contents + got_offset);
3423
3424   /* Fill in the entry in the .rela.plt section.  */
3425   rela.r_offset = (gotplt->output_section->vma
3426                    + gotplt->output_offset
3427                    + got_offset);
3428
3429   if (!h
3430       || h->dynindx == -1
3431       || ((bfd_link_executable (info)
3432            || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
3433           && h->def_regular))
3434     {
3435       /* The symbol can be locally resolved.  */
3436       rela.r_info = ELF64_R_INFO (0, R_390_IRELATIVE);
3437       rela.r_addend = resolver_address;
3438     }
3439   else
3440     {
3441       rela.r_info = ELF64_R_INFO (h->dynindx, R_390_JMP_SLOT);
3442       rela.r_addend = 0;
3443     }
3444
3445   loc = relplt->contents + plt_index * sizeof (Elf64_External_Rela);
3446   bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3447 }
3448
3449
3450 /* Finish up dynamic symbol handling.  We set the contents of various
3451    dynamic sections here.  */
3452
3453 static bfd_boolean
3454 elf_s390_finish_dynamic_symbol (bfd *output_bfd,
3455                                 struct bfd_link_info *info,
3456                                 struct elf_link_hash_entry *h,
3457                                 Elf_Internal_Sym *sym)
3458 {
3459   struct elf_s390_link_hash_table *htab;
3460   struct elf_s390_link_hash_entry *eh = (struct elf_s390_link_hash_entry*)h;
3461
3462   htab = elf_s390_hash_table (info);
3463   if (htab == NULL)
3464     return FALSE;
3465
3466   if (h->plt.offset != (bfd_vma) -1)
3467     {
3468       bfd_vma plt_index;
3469       bfd_vma got_offset;
3470       Elf_Internal_Rela rela;
3471       bfd_byte *loc;
3472
3473       /* This symbol has an entry in the procedure linkage table.  Set
3474          it up.  */
3475       if (s390_is_ifunc_symbol_p (h) && h->def_regular)
3476         {
3477           elf_s390_finish_ifunc_symbol (output_bfd, info, h,
3478             htab, h->plt.offset,
3479             eh->ifunc_resolver_address +
3480             eh->ifunc_resolver_section->output_offset +
3481             eh->ifunc_resolver_section->output_section->vma);
3482
3483           /* Do not return yet.  Handling of explicit GOT slots of
3484              IFUNC symbols is below.  */
3485         }
3486       else
3487         {
3488           if (h->dynindx == -1
3489               || htab->elf.splt == NULL
3490               || htab->elf.sgotplt == NULL
3491               || htab->elf.srelplt == NULL)
3492             abort ();
3493
3494           /* Calc. index no.
3495              Current offset - size first entry / entry size.  */
3496           plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3497
3498           /* Offset in GOT is PLT index plus GOT headers(3) times 8,
3499              addr & GOT addr.  */
3500           got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
3501
3502           /* Fill in the blueprint of a PLT.  */
3503           memcpy (htab->elf.splt->contents + h->plt.offset, elf_s390x_plt_entry,
3504                   PLT_ENTRY_SIZE);
3505
3506           /* Fixup the relative address to the GOT entry */
3507           bfd_put_32 (output_bfd,
3508                       (htab->elf.sgotplt->output_section->vma +
3509                        htab->elf.sgotplt->output_offset + got_offset
3510                        - (htab->elf.splt->output_section->vma +
3511                           htab->elf.splt->output_offset +
3512                           h->plt.offset))/2,
3513                       htab->elf.splt->contents + h->plt.offset + 2);
3514           /* Fixup the relative branch to PLT 0 */
3515           bfd_put_32 (output_bfd, - (PLT_FIRST_ENTRY_SIZE +
3516                                      (PLT_ENTRY_SIZE * plt_index) + 22)/2,
3517                       htab->elf.splt->contents + h->plt.offset + 24);
3518           /* Fixup offset into .rela.plt section.  */
3519           bfd_put_32 (output_bfd, plt_index * sizeof (Elf64_External_Rela),
3520                       htab->elf.splt->contents + h->plt.offset + 28);
3521
3522           /* Fill in the entry in the global offset table.
3523              Points to instruction after GOT offset.  */
3524           bfd_put_64 (output_bfd,
3525                       (htab->elf.splt->output_section->vma
3526                        + htab->elf.splt->output_offset
3527                        + h->plt.offset
3528                        + 14),
3529                       htab->elf.sgotplt->contents + got_offset);
3530
3531           /* Fill in the entry in the .rela.plt section.  */
3532           rela.r_offset = (htab->elf.sgotplt->output_section->vma
3533                            + htab->elf.sgotplt->output_offset
3534                            + got_offset);
3535           rela.r_info = ELF64_R_INFO (h->dynindx, R_390_JMP_SLOT);
3536           rela.r_addend = 0;
3537           loc = htab->elf.srelplt->contents + plt_index *
3538             sizeof (Elf64_External_Rela);
3539           bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3540
3541           if (!h->def_regular)
3542             {
3543               /* Mark the symbol as undefined, rather than as defined in
3544                  the .plt section.  Leave the value alone.  This is a clue
3545                  for the dynamic linker, to make function pointer
3546                  comparisons work between an application and shared
3547                  library.  */
3548               sym->st_shndx = SHN_UNDEF;
3549             }
3550         }
3551     }
3552
3553   if (h->got.offset != (bfd_vma) -1
3554       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_GD
3555       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE
3556       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE_NLT)
3557     {
3558       Elf_Internal_Rela rela;
3559       bfd_byte *loc;
3560
3561       /* This symbol has an entry in the global offset table.  Set it
3562          up.  */
3563       if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
3564         abort ();
3565
3566       rela.r_offset = (htab->elf.sgot->output_section->vma
3567                        + htab->elf.sgot->output_offset
3568                        + (h->got.offset &~ (bfd_vma) 1));
3569
3570       if (h->def_regular && s390_is_ifunc_symbol_p (h))
3571         {
3572           if (bfd_link_pic (info))
3573             {
3574               /* An explicit GOT slot usage needs GLOB_DAT.  If the
3575                  symbol references local the implicit got.iplt slot
3576                  will be used and the IRELATIVE reloc has been created
3577                  above.  */
3578               goto do_glob_dat;
3579             }
3580           else
3581             {
3582               /* For non-shared objects explicit GOT slots must be
3583                  filled with the PLT slot address for pointer
3584                  equality reasons.  */
3585               bfd_put_64 (output_bfd, (htab->elf.iplt->output_section->vma
3586                                        + htab->elf.iplt->output_offset
3587                                        + h->plt.offset),
3588                           htab->elf.sgot->contents + h->got.offset);
3589               return TRUE;
3590             }
3591         }
3592       else if (bfd_link_pic (info)
3593                && SYMBOL_REFERENCES_LOCAL (info, h))
3594         {
3595           /* If this is a static link, or it is a -Bsymbolic link and
3596              the symbol is defined locally or was forced to be local
3597              because of a version file, we just want to emit a
3598              RELATIVE reloc.  The entry in the global offset table
3599              will already have been initialized in the
3600              relocate_section function.  */
3601           if (!(h->def_regular || ELF_COMMON_DEF_P (h)))
3602             return FALSE;
3603           BFD_ASSERT((h->got.offset & 1) != 0);
3604           rela.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
3605           rela.r_addend = (h->root.u.def.value
3606                            + h->root.u.def.section->output_section->vma
3607                            + h->root.u.def.section->output_offset);
3608         }
3609       else
3610         {
3611           BFD_ASSERT((h->got.offset & 1) == 0);
3612         do_glob_dat:
3613           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgot->contents + h->got.offset);
3614           rela.r_info = ELF64_R_INFO (h->dynindx, R_390_GLOB_DAT);
3615           rela.r_addend = 0;
3616         }
3617
3618       loc = htab->elf.srelgot->contents;
3619       loc += htab->elf.srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
3620       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3621     }
3622
3623   if (h->needs_copy)
3624     {
3625       Elf_Internal_Rela rela;
3626       asection *s;
3627       bfd_byte *loc;
3628
3629       /* This symbols needs a copy reloc.  Set it up.  */
3630
3631       if (h->dynindx == -1
3632           || (h->root.type != bfd_link_hash_defined
3633               && h->root.type != bfd_link_hash_defweak)
3634           || htab->elf.srelbss == NULL)
3635         abort ();
3636
3637       rela.r_offset = (h->root.u.def.value
3638                        + h->root.u.def.section->output_section->vma
3639                        + h->root.u.def.section->output_offset);
3640       rela.r_info = ELF64_R_INFO (h->dynindx, R_390_COPY);
3641       rela.r_addend = 0;
3642       if (h->root.u.def.section == htab->elf.sdynrelro)
3643         s = htab->elf.sreldynrelro;
3644       else
3645         s = htab->elf.srelbss;
3646       loc = s->contents + s->reloc_count++ * sizeof (Elf64_External_Rela);
3647       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3648     }
3649
3650   /* Mark some specially defined symbols as absolute.  */
3651   if (h == htab->elf.hdynamic
3652       || h == htab->elf.hgot
3653       || h == htab->elf.hplt)
3654     sym->st_shndx = SHN_ABS;
3655
3656   return TRUE;
3657 }
3658
3659 /* Used to decide how to sort relocs in an optimal manner for the
3660    dynamic linker, before writing them out.  */
3661
3662 static enum elf_reloc_type_class
3663 elf_s390_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
3664                            const asection *rel_sec ATTRIBUTE_UNUSED,
3665                            const Elf_Internal_Rela *rela)
3666 {
3667   bfd *abfd = info->output_bfd;
3668   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3669   struct elf_s390_link_hash_table *htab = elf_s390_hash_table (info);
3670   unsigned long r_symndx = ELF64_R_SYM (rela->r_info);
3671   Elf_Internal_Sym sym;
3672
3673   if (htab->elf.dynsym == NULL
3674       || !bed->s->swap_symbol_in (abfd,
3675                                   (htab->elf.dynsym->contents
3676                                    + r_symndx * bed->s->sizeof_sym),
3677                                   0, &sym))
3678     abort ();
3679
3680   /* Check relocation against STT_GNU_IFUNC symbol.  */
3681   if (ELF_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
3682     return reloc_class_ifunc;
3683
3684   switch ((int) ELF64_R_TYPE (rela->r_info))
3685     {
3686     case R_390_RELATIVE:
3687       return reloc_class_relative;
3688     case R_390_JMP_SLOT:
3689       return reloc_class_plt;
3690     case R_390_COPY:
3691       return reloc_class_copy;
3692     default:
3693       return reloc_class_normal;
3694     }
3695 }
3696
3697 /* Finish up the dynamic sections.  */
3698
3699 static bfd_boolean
3700 elf_s390_finish_dynamic_sections (bfd *output_bfd,
3701                                   struct bfd_link_info *info)
3702 {
3703   struct elf_s390_link_hash_table *htab;
3704   bfd *dynobj;
3705   asection *sdyn;
3706   bfd *ibfd;
3707   unsigned int i;
3708
3709   htab = elf_s390_hash_table (info);
3710   if (htab == NULL)
3711     return FALSE;
3712
3713   dynobj = htab->elf.dynobj;
3714   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3715
3716   if (htab->elf.dynamic_sections_created)
3717     {
3718       Elf64_External_Dyn *dyncon, *dynconend;
3719
3720       if (sdyn == NULL || htab->elf.sgot == NULL)
3721         abort ();
3722
3723       dyncon = (Elf64_External_Dyn *) sdyn->contents;
3724       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
3725       for (; dyncon < dynconend; dyncon++)
3726         {
3727           Elf_Internal_Dyn dyn;
3728           asection *s;
3729
3730           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3731
3732           switch (dyn.d_tag)
3733             {
3734             default:
3735               continue;
3736
3737             case DT_PLTGOT:
3738               s = htab->elf.sgotplt;
3739               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3740               break;
3741
3742             case DT_JMPREL:
3743               s = htab->elf.srelplt;
3744               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3745               break;
3746
3747             case DT_PLTRELSZ:
3748               dyn.d_un.d_val = htab->elf.srelplt->size + htab->elf.irelplt->size;
3749               break;
3750
3751             case DT_RELASZ:
3752               /* The procedure linkage table relocs (DT_JMPREL) should
3753                  not be included in the overall relocs (DT_RELA).
3754                  Therefore, we override the DT_RELASZ entry here to
3755                  make it not include the JMPREL relocs.  Since the
3756                  linker script arranges for .rela.plt to follow all
3757                  other relocation sections, we don't have to worry
3758                  about changing the DT_RELA entry.  */
3759               dyn.d_un.d_val -= htab->elf.srelplt->size + htab->elf.irelplt->size;
3760               break;
3761             }
3762
3763           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3764         }
3765
3766       /* Fill in the special first entry in the procedure linkage table.  */
3767       if (htab->elf.splt && htab->elf.splt->size > 0)
3768         {
3769           /* fill in blueprint for plt 0 entry */
3770           memcpy (htab->elf.splt->contents, elf_s390x_first_plt_entry,
3771                   PLT_FIRST_ENTRY_SIZE);
3772           /* Fixup relative address to start of GOT */
3773           bfd_put_32 (output_bfd,
3774                       (htab->elf.sgotplt->output_section->vma
3775                        + htab->elf.sgotplt->output_offset
3776                        - htab->elf.splt->output_section->vma
3777                        - htab->elf.splt->output_offset - 6)/2,
3778                       htab->elf.splt->contents + 8);
3779         }
3780       if (elf_section_data (htab->elf.splt->output_section) != NULL)
3781         elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
3782           = PLT_ENTRY_SIZE;
3783     }
3784
3785   if (htab->elf.sgotplt)
3786     {
3787       /* Fill in the first three entries in the global offset table.  */
3788       if (htab->elf.sgotplt->size > 0)
3789         {
3790           bfd_put_64 (output_bfd,
3791                       (sdyn == NULL ? (bfd_vma) 0
3792                        : sdyn->output_section->vma + sdyn->output_offset),
3793                       htab->elf.sgotplt->contents);
3794           /* One entry for shared object struct ptr.  */
3795           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + 8);
3796           /* One entry for _dl_runtime_resolve.  */
3797           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + 16);
3798         }
3799
3800       elf_section_data (htab->elf.sgot->output_section)
3801         ->this_hdr.sh_entsize = 8;
3802     }
3803
3804   /* Finish dynamic symbol for local IFUNC symbols.  */
3805   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3806     {
3807       struct plt_entry *local_plt;
3808       Elf_Internal_Sym *isym;
3809       Elf_Internal_Shdr *symtab_hdr;
3810
3811       symtab_hdr = &elf_symtab_hdr (ibfd);
3812
3813       local_plt = elf_s390_local_plt (ibfd);
3814       if (local_plt != NULL)
3815         for (i = 0; i < symtab_hdr->sh_info; i++)
3816           {
3817             if (local_plt[i].plt.offset != (bfd_vma) -1)
3818               {
3819                 asection *sec = local_plt[i].sec;
3820                 isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, i);
3821                 if (isym == NULL)
3822                   return FALSE;
3823
3824                 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
3825                   elf_s390_finish_ifunc_symbol (output_bfd, info, NULL, htab,
3826                                                 local_plt[i].plt.offset,
3827                                                 isym->st_value
3828                                                 + sec->output_section->vma
3829                                                 + sec->output_offset);
3830
3831               }
3832           }
3833     }
3834
3835   return TRUE;
3836 }
3837 \f
3838 /* Support for core dump NOTE sections.  */
3839
3840 static bfd_boolean
3841 elf_s390_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3842 {
3843   int offset;
3844   size_t size;
3845
3846   switch (note->descsz)
3847     {
3848     default:
3849       return FALSE;
3850
3851     case 336:                   /* sizeof(struct elf_prstatus) on s390x */
3852       /* pr_cursig */
3853       elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3854
3855       /* pr_pid */
3856       elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
3857
3858       /* pr_reg */
3859       offset = 112;
3860       size = 216;
3861       break;
3862     }
3863
3864   /* Make a ".reg/999" section.  */
3865   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3866                                           size, note->descpos + offset);
3867 }
3868
3869 static bfd_boolean
3870 elf_s390_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3871 {
3872   switch (note->descsz)
3873     {
3874     default:
3875       return FALSE;
3876
3877     case 136:                   /* sizeof(struct elf_prpsinfo) on s390x */
3878       elf_tdata (abfd)->core->pid
3879         = bfd_get_32 (abfd, note->descdata + 24);
3880       elf_tdata (abfd)->core->program
3881         = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
3882       elf_tdata (abfd)->core->command
3883         = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
3884     }
3885
3886   /* Note that for some reason, a spurious space is tacked
3887      onto the end of the args in some (at least one anyway)
3888      implementations, so strip it off if it exists.  */
3889
3890   {
3891     char *command = elf_tdata (abfd)->core->command;
3892     int n = strlen (command);
3893
3894     if (0 < n && command[n - 1] == ' ')
3895       command[n - 1] = '\0';
3896   }
3897
3898   return TRUE;
3899 }
3900
3901 static char *
3902 elf_s390_write_core_note (bfd *abfd, char *buf, int *bufsiz,
3903                           int note_type, ...)
3904 {
3905   va_list ap;
3906
3907   switch (note_type)
3908     {
3909     default:
3910       return NULL;
3911
3912     case NT_PRPSINFO:
3913       {
3914         char data[136] = { 0 };
3915         const char *fname, *psargs;
3916
3917         va_start (ap, note_type);
3918         fname = va_arg (ap, const char *);
3919         psargs = va_arg (ap, const char *);
3920         va_end (ap);
3921
3922         strncpy (data + 40, fname, 16);
3923         strncpy (data + 56, psargs, 80);
3924         return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
3925                                    &data, sizeof (data));
3926       }
3927
3928     case NT_PRSTATUS:
3929       {
3930         char data[336] = { 0 };
3931         long pid;
3932         int cursig;
3933         const void *gregs;
3934
3935         va_start (ap, note_type);
3936         pid = va_arg (ap, long);
3937         cursig = va_arg (ap, int);
3938         gregs = va_arg (ap, const void *);
3939         va_end (ap);
3940
3941         bfd_put_16 (abfd, cursig, data + 12);
3942         bfd_put_32 (abfd, pid, data + 32);
3943         memcpy (data + 112, gregs, 216);
3944         return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
3945                                    &data, sizeof (data));
3946       }
3947     }
3948   /* NOTREACHED */
3949 }
3950 \f
3951 /* Return address for Ith PLT stub in section PLT, for relocation REL
3952    or (bfd_vma) -1 if it should not be included.  */
3953
3954 static bfd_vma
3955 elf_s390_plt_sym_val (bfd_vma i, const asection *plt,
3956                       const arelent *rel ATTRIBUTE_UNUSED)
3957 {
3958   return plt->vma + PLT_FIRST_ENTRY_SIZE + i * PLT_ENTRY_SIZE;
3959 }
3960
3961 /* Merge backend specific data from an object file to the output
3962    object file when linking.  */
3963
3964 static bfd_boolean
3965 elf64_s390_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
3966 {
3967   if (!is_s390_elf (ibfd) || !is_s390_elf (info->output_bfd))
3968     return TRUE;
3969
3970   return elf_s390_merge_obj_attributes (ibfd, info);
3971 }
3972
3973 /* We may add a PT_S390_PGSTE program header.  */
3974
3975 static int
3976 elf_s390_additional_program_headers (bfd *abfd ATTRIBUTE_UNUSED,
3977                                      struct bfd_link_info *info)
3978 {
3979   struct elf_s390_link_hash_table *htab;
3980
3981   if (info)
3982     {
3983       htab = elf_s390_hash_table (info);
3984       if (htab)
3985         return htab->params->pgste;
3986     }
3987   return 0;
3988 }
3989
3990
3991 /* Add the PT_S390_PGSTE program header.  */
3992
3993 static bfd_boolean
3994 elf_s390_modify_segment_map (bfd *abfd, struct bfd_link_info *info)
3995 {
3996   struct elf_s390_link_hash_table *htab;
3997   struct elf_segment_map *m, *pm = NULL;
3998
3999   if (!abfd || !info)
4000     return TRUE;
4001
4002   htab = elf_s390_hash_table (info);
4003   if (!htab || !htab->params->pgste)
4004     return TRUE;
4005
4006   /* If there is already a PT_S390_PGSTE header, avoid adding
4007      another.  */
4008   m = elf_seg_map (abfd);
4009   while (m && m->p_type != PT_S390_PGSTE)
4010     {
4011       pm = m;
4012       m = m->next;
4013     }
4014
4015   if (m)
4016     return TRUE;
4017
4018   m = (struct elf_segment_map *)
4019     bfd_zalloc (abfd, sizeof (struct elf_segment_map));
4020   if (m == NULL)
4021     return FALSE;
4022   m->p_type = PT_S390_PGSTE;
4023   m->count = 0;
4024   m->next = NULL;
4025   if (pm)
4026     pm->next = m;
4027
4028   return TRUE;
4029 }
4030
4031 bfd_boolean
4032 bfd_elf_s390_set_options (struct bfd_link_info *info,
4033                           struct s390_elf_params *params)
4034 {
4035   struct elf_s390_link_hash_table *htab;
4036
4037   if (info)
4038     {
4039       htab = elf_s390_hash_table (info);
4040       if (htab)
4041         htab->params = params;
4042     }
4043
4044   return TRUE;
4045 }
4046
4047
4048 /* Why was the hash table entry size definition changed from
4049    ARCH_SIZE/8 to 4? This breaks the 64 bit dynamic linker and
4050    this is the only reason for the s390_elf64_size_info structure.  */
4051
4052 const struct elf_size_info s390_elf64_size_info =
4053 {
4054   sizeof (Elf64_External_Ehdr),
4055   sizeof (Elf64_External_Phdr),
4056   sizeof (Elf64_External_Shdr),
4057   sizeof (Elf64_External_Rel),
4058   sizeof (Elf64_External_Rela),
4059   sizeof (Elf64_External_Sym),
4060   sizeof (Elf64_External_Dyn),
4061   sizeof (Elf_External_Note),
4062   8,            /* hash-table entry size.  */
4063   1,            /* internal relocations per external relocations.  */
4064   64,           /* arch_size.  */
4065   3,            /* log_file_align.  */
4066   ELFCLASS64, EV_CURRENT,
4067   bfd_elf64_write_out_phdrs,
4068   bfd_elf64_write_shdrs_and_ehdr,
4069   bfd_elf64_checksum_contents,
4070   bfd_elf64_write_relocs,
4071   bfd_elf64_swap_symbol_in,
4072   bfd_elf64_swap_symbol_out,
4073   bfd_elf64_slurp_reloc_table,
4074   bfd_elf64_slurp_symbol_table,
4075   bfd_elf64_swap_dyn_in,
4076   bfd_elf64_swap_dyn_out,
4077   bfd_elf64_swap_reloc_in,
4078   bfd_elf64_swap_reloc_out,
4079   bfd_elf64_swap_reloca_in,
4080   bfd_elf64_swap_reloca_out
4081 };
4082
4083 #define TARGET_BIG_SYM  s390_elf64_vec
4084 #define TARGET_BIG_NAME "elf64-s390"
4085 #define ELF_ARCH        bfd_arch_s390
4086 #define ELF_TARGET_ID   S390_ELF_DATA
4087 #define ELF_MACHINE_CODE EM_S390
4088 #define ELF_MACHINE_ALT1 EM_S390_OLD
4089 #define ELF_MAXPAGESIZE 0x1000
4090
4091 #define elf_backend_size_info           s390_elf64_size_info
4092
4093 #define elf_backend_can_gc_sections     1
4094 #define elf_backend_can_refcount        1
4095 #define elf_backend_want_got_plt        1
4096 #define elf_backend_plt_readonly        1
4097 #define elf_backend_want_plt_sym        0
4098 #define elf_backend_got_header_size     24
4099 #define elf_backend_want_dynrelro       1
4100 #define elf_backend_rela_normal         1
4101
4102 #define elf_info_to_howto               elf_s390_info_to_howto
4103
4104 #define bfd_elf64_bfd_is_local_label_name     elf_s390_is_local_label_name
4105 #define bfd_elf64_bfd_link_hash_table_create  elf_s390_link_hash_table_create
4106 #define bfd_elf64_bfd_reloc_type_lookup       elf_s390_reloc_type_lookup
4107 #define bfd_elf64_bfd_reloc_name_lookup       elf_s390_reloc_name_lookup
4108 #define bfd_elf64_bfd_merge_private_bfd_data  elf64_s390_merge_private_bfd_data
4109
4110 #define elf_backend_adjust_dynamic_symbol     elf_s390_adjust_dynamic_symbol
4111 #define elf_backend_check_relocs              elf_s390_check_relocs
4112 #define elf_backend_copy_indirect_symbol      elf_s390_copy_indirect_symbol
4113 #define elf_backend_create_dynamic_sections   _bfd_elf_create_dynamic_sections
4114 #define elf_backend_finish_dynamic_sections   elf_s390_finish_dynamic_sections
4115 #define elf_backend_finish_dynamic_symbol     elf_s390_finish_dynamic_symbol
4116 #define elf_backend_gc_mark_hook              elf_s390_gc_mark_hook
4117 #define elf_backend_gc_sweep_hook             elf_s390_gc_sweep_hook
4118 #define elf_backend_reloc_type_class          elf_s390_reloc_type_class
4119 #define elf_backend_relocate_section          elf_s390_relocate_section
4120 #define elf_backend_size_dynamic_sections     elf_s390_size_dynamic_sections
4121 #define elf_backend_init_index_section        _bfd_elf_init_1_index_section
4122 #define elf_backend_grok_prstatus             elf_s390_grok_prstatus
4123 #define elf_backend_grok_psinfo               elf_s390_grok_psinfo
4124 #define elf_backend_write_core_note           elf_s390_write_core_note
4125 #define elf_backend_plt_sym_val               elf_s390_plt_sym_val
4126 #define elf_backend_add_symbol_hook           elf_s390_add_symbol_hook
4127 #define elf_backend_sort_relocs_p             elf_s390_elf_sort_relocs_p
4128 #define elf_backend_additional_program_headers elf_s390_additional_program_headers
4129 #define elf_backend_modify_segment_map        elf_s390_modify_segment_map
4130
4131 #define bfd_elf64_mkobject              elf_s390_mkobject
4132 #define elf_backend_object_p            elf_s390_object_p
4133
4134 #include "elf64-target.h"