bfd/elf64-s390.c

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