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