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