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