bfd/elf64-s390.c

   1 /* IBM S/390-specific support for 64-bit ELF
   2    Copyright (C) 2000-2024 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_late_size_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_late_size_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     return true;
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
2479           /* Replace relative long addressing instructions of weak
2480              symbols, which will definitely resolve to zero, with
2481              either a load address of 0, a NOP, or a trapping insn.
2482              This prevents the PC32DBL relocation from overflowing in
2483              case the binary will be loaded at 4GB or more.  */
2484           if (h != NULL
2485               && h->root.type == bfd_link_hash_undefweak
2486               && !h->root.linker_def
2487               && (bfd_link_executable (info)
2488                   || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2489               && r_type == R_390_PC32DBL
2490               && rel->r_offset >= 2)
2491             {
2492               void *insn_start = contents + rel->r_offset - 2;
2493               uint16_t op = bfd_get_16 (input_bfd, insn_start) & 0xff0f;
2494               uint8_t reg = bfd_get_8 (input_bfd, insn_start + 1) & 0xf0;
2495
2496               /* NOTE: The order of the if's is important!  */
2497               /* Replace load address relative long (larl) with load
2498                  address (lay) */
2499               if (op == 0xc000)
2500                 {
2501                   /* larl rX,<weak sym> -> lay rX,0(0)  */
2502                   bfd_put_16 (output_bfd, 0xe300 | reg, insn_start);
2503                   bfd_put_32 (output_bfd, 0x71, insn_start + 2);
2504                   continue;
2505                 }
2506               /* Replace prefetch data relative long (pfdrl) with a NOP  */
2507               else if (op == 0xc602)
2508                 {
2509                   /* Emit a 6-byte NOP: jgnop .  */
2510                   bfd_put_16 (output_bfd, 0xc004, insn_start);
2511                   bfd_put_32 (output_bfd, 0x0, insn_start + 2);
2512                   continue;
2513                 }
2514               /* Replace the following instructions with a trap:
2515                  - branch relative and save long (brasl)
2516                  - load (logical) relative long (lrl, lgrl, lgfrl, llgfrl)
2517                  - load (logical) halfword relative long (lhrl, lghrl, llhrl, llghrl)
2518                  - store relative long (strl, stgrl)
2519                  - store halfword relative long (sthrl)
2520                  - execute relative long (exrl)
2521                  - compare (logical) relative long (crl, clrl, cgrl, clgrl, cgfrl, clgfrl)
2522                  - compare (logical) halfword relative long (chrl, cghrl, clhrl, clghrl)
2523                  - branch relative on count high (brcth)  */
2524               else if (op == 0xc005 || (op & 0xff00) == 0xc400
2525                        || (op & 0xff00) == 0xc600 || op == 0xcc06)
2526                 {
2527                   /* Emit a 6-byte trap: jg .+2  */
2528                   bfd_put_16 (output_bfd, 0xc0f4, insn_start);
2529                   bfd_put_32 (output_bfd, 0x1, insn_start + 2);
2530                   continue;
2531                 }
2532             }
2533           /* Fall through.  */
2534
2535         case R_390_8:
2536         case R_390_16:
2537         case R_390_32:
2538         case R_390_64:
2539
2540           if ((input_section->flags & SEC_ALLOC) == 0)
2541             break;
2542
2543           if (h != NULL
2544               && s390_is_ifunc_symbol_p (h)
2545               && h->def_regular)
2546             {
2547               if (!bfd_link_pic (info))
2548                 {
2549                   /* For a non-shared object the symbol will not
2550                      change.  Hence we can write the address of the
2551                      target IPLT slot now.  */
2552                   relocation = (htab->elf.iplt->output_section->vma
2553                                 + htab->elf.iplt->output_offset
2554                                 + h ->plt.offset);
2555                   goto do_relocation;
2556                 }
2557               else
2558                 {
2559                   /* For shared objects a runtime relocation is needed.  */
2560
2561                   Elf_Internal_Rela outrel;
2562                   asection *sreloc;
2563
2564                   /* Need a dynamic relocation to get the real function
2565                      address.  */
2566                   outrel.r_offset = _bfd_elf_section_offset (output_bfd,
2567                                                              info,
2568                                                              input_section,
2569                                                              rel->r_offset);
2570                   if (outrel.r_offset == (bfd_vma) -1
2571                       || outrel.r_offset == (bfd_vma) -2)
2572                     abort ();
2573
2574                   outrel.r_offset += (input_section->output_section->vma
2575                                       + input_section->output_offset);
2576
2577                   if (h->dynindx == -1
2578                       || h->forced_local
2579                       || bfd_link_executable (info))
2580                     {
2581                       /* This symbol is resolved locally.  */
2582                       outrel.r_info = ELF64_R_INFO (0, R_390_IRELATIVE);
2583                       outrel.r_addend = (h->root.u.def.value
2584                                          + h->root.u.def.section->output_section->vma
2585                                          + h->root.u.def.section->output_offset);
2586                     }
2587                   else
2588                     {
2589                       outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
2590                       outrel.r_addend = 0;
2591                     }
2592
2593                   sreloc = htab->elf.irelifunc;
2594                   elf_append_rela (output_bfd, sreloc, &outrel);
2595
2596                   /* If this reloc is against an external symbol, we
2597                      do not want to fiddle with the addend.  Otherwise,
2598                      we need to include the symbol value so that it
2599                      becomes an addend for the dynamic reloc.  For an
2600                      internal symbol, we have updated addend.  */
2601                   continue;
2602                 }
2603             }
2604
2605           if ((bfd_link_pic (info)
2606                && (h == NULL
2607                    || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2608                        && !resolved_to_zero)
2609                    || h->root.type != bfd_link_hash_undefweak)
2610                && ((r_type != R_390_PC16
2611                     && r_type != R_390_PC12DBL
2612                     && r_type != R_390_PC16DBL
2613                     && r_type != R_390_PC24DBL
2614                     && r_type != R_390_PC32
2615                     && r_type != R_390_PC32DBL
2616                     && r_type != R_390_PC64)
2617                    || !SYMBOL_CALLS_LOCAL (info, h)))
2618               || (ELIMINATE_COPY_RELOCS
2619                   && !bfd_link_pic (info)
2620                   && h != NULL
2621                   && h->dynindx != -1
2622                   && !h->non_got_ref
2623                   && ((h->def_dynamic
2624                        && !h->def_regular)
2625                       || h->root.type == bfd_link_hash_undefweak
2626                       || h->root.type == bfd_link_hash_undefined)))
2627             {
2628               Elf_Internal_Rela outrel;
2629               bool skip, relocate;
2630               asection *sreloc;
2631               bfd_byte *loc;
2632
2633               /* When generating a shared object, these relocations
2634                  are copied into the output file to be resolved at run
2635                  time.  */
2636               skip = false;
2637               relocate = false;
2638
2639               outrel.r_offset =
2640                 _bfd_elf_section_offset (output_bfd, info, input_section,
2641                                          rel->r_offset);
2642               if (outrel.r_offset == (bfd_vma) -1)
2643                 skip = true;
2644               else if (outrel.r_offset == (bfd_vma) -2)
2645                 skip = true, relocate = true;
2646
2647               outrel.r_offset += (input_section->output_section->vma
2648                                   + input_section->output_offset);
2649
2650               if (skip)
2651                 memset (&outrel, 0, sizeof outrel);
2652               else if (h != NULL
2653                        && h->dynindx != -1
2654                        && (r_type == R_390_PC16
2655                            || r_type == R_390_PC12DBL
2656                            || r_type == R_390_PC16DBL
2657                            || r_type == R_390_PC24DBL
2658                            || r_type == R_390_PC32
2659                            || r_type == R_390_PC32DBL
2660                            || r_type == R_390_PC64
2661                            || !bfd_link_pic (info)
2662                            || !SYMBOLIC_BIND (info, h)
2663                            || !h->def_regular))
2664                 {
2665                   outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
2666                   outrel.r_addend = rel->r_addend;
2667                 }
2668               else
2669                 {
2670                   /* This symbol is local, or marked to become local.  */
2671                   outrel.r_addend = relocation + rel->r_addend;
2672                   if (r_type == R_390_64)
2673                     {
2674                       relocate = true;
2675                       outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2676                     }
2677                   else
2678                     {
2679                       long sindx;
2680
2681                       if (bfd_is_abs_section (sec))
2682                         sindx = 0;
2683                       else if (sec == NULL || sec->owner == NULL)
2684                         {
2685                           bfd_set_error(bfd_error_bad_value);
2686                           return false;
2687                         }
2688                       else
2689                         {
2690                           asection *osec;
2691
2692                           osec = sec->output_section;
2693                           sindx = elf_section_data (osec)->dynindx;
2694
2695                           if (sindx == 0)
2696                             {
2697                               osec = htab->elf.text_index_section;
2698                               sindx = elf_section_data (osec)->dynindx;
2699                             }
2700                           BFD_ASSERT (sindx != 0);
2701
2702                           /* We are turning this relocation into one
2703                              against a section symbol, so subtract out
2704                              the output section's address but not the
2705                              offset of the input section in the output
2706                              section.  */
2707                           outrel.r_addend -= osec->vma;
2708                         }
2709                       outrel.r_info = ELF64_R_INFO (sindx, r_type);
2710                     }
2711                 }
2712
2713               sreloc = elf_section_data (input_section)->sreloc;
2714               if (sreloc == NULL)
2715                 abort ();
2716
2717               loc = sreloc->contents;
2718               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2719               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2720
2721               /* If this reloc is against an external symbol, we do
2722                  not want to fiddle with the addend.  Otherwise, we
2723                  need to include the symbol value so that it becomes
2724                  an addend for the dynamic reloc.  */
2725               if (! relocate)
2726                 continue;
2727             }
2728
2729           break;
2730
2731           /* Relocations for tls literal pool entries.  */
2732         case R_390_TLS_IE64:
2733           if (bfd_link_dll (info))
2734             {
2735               Elf_Internal_Rela outrel;
2736               asection *sreloc;
2737               bfd_byte *loc;
2738
2739               outrel.r_offset = rel->r_offset
2740                                 + input_section->output_section->vma
2741                                 + input_section->output_offset;
2742               outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2743               sreloc = elf_section_data (input_section)->sreloc;
2744               if (sreloc == NULL)
2745                 abort ();
2746               loc = sreloc->contents;
2747               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2748               bfd_elf64_swap_reloc_out (output_bfd, &outrel, loc);
2749             }
2750           /* Fall through.  */
2751
2752         case R_390_TLS_GD64:
2753         case R_390_TLS_GOTIE64:
2754           r_type = elf_s390_tls_transition (info, r_type, h == NULL);
2755           tls_type = GOT_UNKNOWN;
2756           if (h == NULL && local_got_offsets)
2757             tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
2758           else if (h != NULL)
2759             {
2760               tls_type = elf_s390_hash_entry(h)->tls_type;
2761               if (!bfd_link_dll (info) && h->dynindx == -1 && tls_type >= GOT_TLS_IE)
2762                 r_type = R_390_TLS_LE64;
2763             }
2764           if (r_type == R_390_TLS_GD64 && tls_type >= GOT_TLS_IE)
2765             r_type = R_390_TLS_IE64;
2766
2767           if (r_type == R_390_TLS_LE64)
2768             {
2769               /* This relocation gets optimized away by the local exec
2770                  access optimization.  */
2771               BFD_ASSERT (! unresolved_reloc);
2772               bfd_put_64 (output_bfd, -tpoff (info, relocation) + rel->r_addend,
2773                           contents + rel->r_offset);
2774               continue;
2775             }
2776
2777           if (htab->elf.sgot == NULL)
2778             abort ();
2779
2780           if (h != NULL)
2781             off = h->got.offset;
2782           else
2783             {
2784               if (local_got_offsets == NULL)
2785                 abort ();
2786
2787               off = local_got_offsets[r_symndx];
2788             }
2789
2790         emit_tls_relocs:
2791
2792           if ((off & 1) != 0)
2793             off &= ~1;
2794           else
2795             {
2796               Elf_Internal_Rela outrel;
2797               bfd_byte *loc;
2798               int dr_type, indx;
2799
2800               if (htab->elf.srelgot == NULL)
2801                 abort ();
2802
2803               outrel.r_offset = (htab->elf.sgot->output_section->vma
2804                                  + htab->elf.sgot->output_offset + off);
2805
2806               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2807               if (r_type == R_390_TLS_GD64)
2808                 dr_type = R_390_TLS_DTPMOD;
2809               else
2810                 dr_type = R_390_TLS_TPOFF;
2811               if (dr_type == R_390_TLS_TPOFF && indx == 0)
2812                 outrel.r_addend = relocation - dtpoff_base (info);
2813               else
2814                 outrel.r_addend = 0;
2815               outrel.r_info = ELF64_R_INFO (indx, dr_type);
2816               loc = htab->elf.srelgot->contents;
2817               loc += htab->elf.srelgot->reloc_count++
2818                 * sizeof (Elf64_External_Rela);
2819               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2820
2821               if (r_type == R_390_TLS_GD64)
2822                 {
2823                   if (indx == 0)
2824                     {
2825                       BFD_ASSERT (! unresolved_reloc);
2826                       bfd_put_64 (output_bfd,
2827                                   relocation - dtpoff_base (info),
2828                                   htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
2829                     }
2830                   else
2831                     {
2832                       outrel.r_info = ELF64_R_INFO (indx, R_390_TLS_DTPOFF);
2833                       outrel.r_offset += GOT_ENTRY_SIZE;
2834                       outrel.r_addend = 0;
2835                       htab->elf.srelgot->reloc_count++;
2836                       loc += sizeof (Elf64_External_Rela);
2837                       bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2838                     }
2839                 }
2840
2841               if (h != NULL)
2842                 h->got.offset |= 1;
2843               else
2844                 local_got_offsets[r_symndx] |= 1;
2845             }
2846
2847           if (off >= (bfd_vma) -2)
2848             abort ();
2849           if (r_type == ELF64_R_TYPE (rel->r_info))
2850             {
2851               relocation = htab->elf.sgot->output_offset + off;
2852               if (r_type == R_390_TLS_IE64 || r_type == R_390_TLS_IEENT)
2853                 relocation += htab->elf.sgot->output_section->vma;
2854               unresolved_reloc = false;
2855             }
2856           else
2857             {
2858               bfd_put_64 (output_bfd, htab->elf.sgot->output_offset + off,
2859                           contents + rel->r_offset);
2860               continue;
2861             }
2862           break;
2863
2864         case R_390_TLS_GOTIE12:
2865         case R_390_TLS_GOTIE20:
2866         case R_390_TLS_IEENT:
2867           if (h == NULL)
2868             {
2869               if (local_got_offsets == NULL)
2870                 abort();
2871               off = local_got_offsets[r_symndx];
2872               if (bfd_link_dll (info))
2873                 goto emit_tls_relocs;
2874             }
2875           else
2876             {
2877               off = h->got.offset;
2878               tls_type = elf_s390_hash_entry(h)->tls_type;
2879               if (bfd_link_dll (info) || h->dynindx != -1 || tls_type < GOT_TLS_IE)
2880                 goto emit_tls_relocs;
2881             }
2882
2883           if (htab->elf.sgot == NULL)
2884             abort ();
2885
2886           BFD_ASSERT (! unresolved_reloc);
2887           bfd_put_64 (output_bfd, -tpoff (info, relocation),
2888                       htab->elf.sgot->contents + off);
2889           relocation = htab->elf.sgot->output_offset + off;
2890           if (r_type == R_390_TLS_IEENT)
2891             relocation += htab->elf.sgot->output_section->vma;
2892           unresolved_reloc = false;
2893           break;
2894
2895         case R_390_TLS_LDM64:
2896           if (! bfd_link_dll (info))
2897             /* The literal pool entry this relocation refers to gets ignored
2898                by the optimized code of the local exec model. Do nothing
2899                and the value will turn out zero.  */
2900             continue;
2901
2902           if (htab->elf.sgot == NULL)
2903             abort ();
2904
2905           off = htab->tls_ldm_got.offset;
2906           if (off & 1)
2907             off &= ~1;
2908           else
2909             {
2910               Elf_Internal_Rela outrel;
2911               bfd_byte *loc;
2912
2913               if (htab->elf.srelgot == NULL)
2914                 abort ();
2915
2916               outrel.r_offset = (htab->elf.sgot->output_section->vma
2917                                  + htab->elf.sgot->output_offset + off);
2918
2919               bfd_put_64 (output_bfd, 0,
2920                           htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
2921               outrel.r_info = ELF64_R_INFO (0, R_390_TLS_DTPMOD);
2922               outrel.r_addend = 0;
2923               loc = htab->elf.srelgot->contents;
2924               loc += htab->elf.srelgot->reloc_count++
2925                 * sizeof (Elf64_External_Rela);
2926               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2927               htab->tls_ldm_got.offset |= 1;
2928             }
2929           relocation = htab->elf.sgot->output_offset + off;
2930           unresolved_reloc = false;
2931           break;
2932
2933         case R_390_TLS_LE64:
2934           if (bfd_link_dll (info))
2935             {
2936               /* Linking a shared library with non-fpic code requires
2937                  a R_390_TLS_TPOFF relocation.  */
2938               Elf_Internal_Rela outrel;
2939               asection *sreloc;
2940               bfd_byte *loc;
2941               int indx;
2942
2943               outrel.r_offset = rel->r_offset
2944                                 + input_section->output_section->vma
2945                                 + input_section->output_offset;
2946               if (h != NULL && h->dynindx != -1)
2947                 indx = h->dynindx;
2948               else
2949                 indx = 0;
2950               outrel.r_info = ELF64_R_INFO (indx, R_390_TLS_TPOFF);
2951               if (indx == 0)
2952                 outrel.r_addend = relocation - dtpoff_base (info);
2953               else
2954                 outrel.r_addend = 0;
2955               sreloc = elf_section_data (input_section)->sreloc;
2956               if (sreloc == NULL)
2957                 abort ();
2958               loc = sreloc->contents;
2959               loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2960               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2961             }
2962           else
2963             {
2964               BFD_ASSERT (! unresolved_reloc);
2965               bfd_put_64 (output_bfd, -tpoff (info, relocation) + rel->r_addend,
2966                           contents + rel->r_offset);
2967             }
2968           continue;
2969
2970         case R_390_TLS_LDO64:
2971           if (bfd_link_dll (info) || (input_section->flags & SEC_DEBUGGING))
2972             relocation -= dtpoff_base (info);
2973           else
2974             /* When converting LDO to LE, we must negate.  */
2975             relocation = -tpoff (info, relocation);
2976           break;
2977
2978           /* Relocations for tls instructions.  */
2979         case R_390_TLS_LOAD:
2980         case R_390_TLS_GDCALL:
2981         case R_390_TLS_LDCALL:
2982           tls_type = GOT_UNKNOWN;
2983           if (h == NULL && local_got_offsets)
2984             tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
2985           else if (h != NULL)
2986             tls_type = elf_s390_hash_entry(h)->tls_type;
2987
2988           if (tls_type == GOT_TLS_GD)
2989             continue;
2990
2991           if (r_type == R_390_TLS_LOAD)
2992             {
2993               if (!bfd_link_dll (info) && (h == NULL || h->dynindx == -1))
2994                 {
2995                   /* IE->LE transition. Four valid cases:
2996                      lg %rx,(0,%ry)    -> sllg %rx,%ry,0
2997                      lg %rx,(%ry,0)    -> sllg %rx,%ry,0
2998                      lg %rx,(%ry,%r12) -> sllg %rx,%ry,0
2999                      lg %rx,(%r12,%ry) -> sllg %rx,%ry,0  */
3000                   unsigned int insn0, insn1, ry;
3001
3002                   insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset);
3003                   insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4);
3004                   if (insn1 != 0x0004)
3005                     {
3006                       invalid_tls_insn (input_bfd, input_section, rel);
3007                       return false;
3008                     }
3009                   if ((insn0 & 0xff00f000) == 0xe3000000)
3010                     /* lg %rx,0(%ry,0) -> sllg %rx,%ry,0  */
3011                     ry = (insn0 & 0x000f0000);
3012                   else if ((insn0 & 0xff0f0000) == 0xe3000000)
3013                     /* lg %rx,0(0,%ry) -> sllg %rx,%ry,0  */
3014                     ry = (insn0 & 0x0000f000) << 4;
3015                   else if ((insn0 & 0xff00f000) == 0xe300c000)
3016                     /* lg %rx,0(%ry,%r12) -> sllg %rx,%ry,0  */
3017                     ry = (insn0 & 0x000f0000);
3018                   else if ((insn0 & 0xff0f0000) == 0xe30c0000)
3019                     /* lg %rx,0(%r12,%ry) -> sllg %rx,%ry,0  */
3020                     ry = (insn0 & 0x0000f000) << 4;
3021                   else
3022                     {
3023                       invalid_tls_insn (input_bfd, input_section, rel);
3024                       return false;
3025                     }
3026                   insn0 = 0xeb000000 | (insn0 & 0x00f00000) | ry;
3027                   insn1 = 0x000d;
3028                   bfd_put_32 (output_bfd, insn0, contents + rel->r_offset);
3029                   bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4);
3030                 }
3031             }
3032           else if (r_type == R_390_TLS_GDCALL)
3033             {
3034               unsigned int insn0, insn1;
3035
3036               insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset);
3037               insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4);
3038               if ((insn0 & 0xffff0000) != 0xc0e50000)
3039                 {
3040                   invalid_tls_insn (input_bfd, input_section, rel);
3041                   return false;
3042                 }
3043               if (!bfd_link_dll (info) && (h == NULL || h->dynindx == -1))
3044                 {
3045                   /* GD->LE transition.
3046                      brasl %r14,__tls_get_addr@plt -> brcl 0,. */
3047                   insn0 = 0xc0040000;
3048                   insn1 = 0x0000;
3049                 }
3050               else
3051                 {
3052                   /* GD->IE transition.
3053                      brasl %r14,__tls_get_addr@plt -> lg %r2,0(%r2,%r12)  */
3054                   insn0 = 0xe322c000;
3055                   insn1 = 0x0004;
3056                 }
3057               bfd_put_32 (output_bfd, insn0, contents + rel->r_offset);
3058               bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4);
3059             }
3060           else if (r_type == R_390_TLS_LDCALL)
3061             {
3062               if (!bfd_link_dll (info))
3063                 {
3064                   unsigned int insn0, insn1;
3065
3066                   insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset);
3067                   insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4);
3068                   if ((insn0 & 0xffff0000) != 0xc0e50000)
3069                     {
3070                       invalid_tls_insn (input_bfd, input_section, rel);
3071                       return false;
3072                     }
3073                   /* LD->LE transition.
3074                      brasl %r14,__tls_get_addr@plt -> brcl 0,. */
3075                   insn0 = 0xc0040000;
3076                   insn1 = 0x0000;
3077                   bfd_put_32 (output_bfd, insn0, contents + rel->r_offset);
3078                   bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4);
3079                 }
3080             }
3081           continue;
3082
3083         default:
3084           break;
3085         }
3086
3087       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3088          because such sections are not SEC_ALLOC and thus ld.so will
3089          not process them.  */
3090       if (unresolved_reloc
3091           && !((input_section->flags & SEC_DEBUGGING) != 0
3092                && h->def_dynamic)
3093           && _bfd_elf_section_offset (output_bfd, info, input_section,
3094                                       rel->r_offset) != (bfd_vma) -1)
3095         _bfd_error_handler
3096           /* xgettext:c-format */
3097           (_("%pB(%pA+%#" PRIx64 "): "
3098              "unresolvable %s relocation against symbol `%s'"),
3099            input_bfd,
3100            input_section,
3101            (uint64_t) rel->r_offset,
3102            howto->name,
3103            h->root.root.string);
3104
3105     do_relocation:
3106
3107       /* When applying a 24 bit reloc we need to start one byte
3108          earlier.  Otherwise the 32 bit get/put bfd operations might
3109          access a byte after the actual section.  */
3110       if (r_type == R_390_PC24DBL
3111           || r_type == R_390_PLT24DBL)
3112         rel->r_offset--;
3113
3114       /* Issue an error if the right shift implied by the relocation
3115          would drop bits from the symbol value.  */
3116       if (howto->rightshift
3117           && (relocation & (((bfd_vma)1 << howto->rightshift) - 1)))
3118         {
3119           _bfd_error_handler
3120             /* xgettext:c-format */
3121             (_("%pB(%pA+%#" PRIx64 "): "
3122                "misaligned symbol `%s' (%#" PRIx64 ") for relocation %s"),
3123              input_bfd,
3124              input_section,
3125              (uint64_t) rel->r_offset,
3126              h->root.root.string,
3127              (uint64_t)relocation,
3128              howto->name);
3129           return false;
3130         }
3131
3132       if (r_type == R_390_20
3133           || r_type == R_390_GOT20
3134           || r_type == R_390_GOTPLT20
3135           || r_type == R_390_TLS_GOTIE20)
3136         {
3137           relocation += rel->r_addend;
3138           relocation = (relocation&0xfff) << 8 | (relocation&0xff000) >> 12;
3139           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3140                                         contents, rel->r_offset,
3141                                         relocation, 0);
3142         }
3143       else
3144         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3145                                       contents, rel->r_offset,
3146                                       relocation, rel->r_addend);
3147
3148       if (r != bfd_reloc_ok)
3149         {
3150           const char *name;
3151
3152           if (h != NULL)
3153             name = h->root.root.string;
3154           else
3155             {
3156               name = bfd_elf_string_from_elf_section (input_bfd,
3157                                                       symtab_hdr->sh_link,
3158                                                       sym->st_name);
3159               if (name == NULL)
3160                 return false;
3161               if (*name == '\0')
3162                 name = bfd_section_name (sec);
3163             }
3164
3165           if (r == bfd_reloc_overflow)
3166             (*info->callbacks->reloc_overflow)
3167               (info, (h ? &h->root : NULL), name, howto->name,
3168                (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
3169           else
3170             {
3171               _bfd_error_handler
3172                 /* xgettext:c-format */
3173                 (_("%pB(%pA+%#" PRIx64 "): reloc against `%s': error %d"),
3174                  input_bfd, input_section,
3175                  (uint64_t) rel->r_offset, name, (int) r);
3176               return false;
3177             }
3178         }
3179     }
3180
3181   return true;
3182 }
3183
3184 /* Generate the PLT slots together with the dynamic relocations needed
3185    for IFUNC symbols.  */
3186
3187 static void
3188 elf_s390_finish_ifunc_symbol (bfd *output_bfd,
3189                               struct bfd_link_info *info,
3190                               struct elf_link_hash_entry *h,
3191                               struct elf_s390_link_hash_table *htab,
3192                               bfd_vma plt_offset,
3193                               bfd_vma resolver_address)
3194 {
3195   bfd_vma plt_index;
3196   bfd_vma got_offset;
3197   Elf_Internal_Rela rela;
3198   bfd_byte *loc;
3199   asection *plt, *gotplt, *relplt;
3200
3201   if (htab->elf.iplt == NULL
3202       || htab->elf.igotplt == NULL
3203       || htab->elf.irelplt == NULL)
3204     abort ();
3205
3206   /* Index of the PLT slot within iplt section.  */
3207   plt_index = plt_offset / PLT_ENTRY_SIZE;
3208   plt = htab->elf.iplt;
3209   /* Offset into the igot.plt section.  */
3210   got_offset = plt_index * GOT_ENTRY_SIZE;
3211   gotplt = htab->elf.igotplt;
3212   relplt = htab->elf.irelplt;
3213
3214   /* Fill in the blueprint of a PLT.  */
3215   memcpy (plt->contents + plt_offset, elf_s390x_plt_entry,
3216           PLT_ENTRY_SIZE);
3217
3218   /* Fixup the relative address to the GOT entry */
3219   bfd_put_32 (output_bfd,
3220               (gotplt->output_section->vma +
3221                gotplt->output_offset + got_offset
3222                - (plt->output_section->vma +
3223                   plt->output_offset +
3224                   plt_offset))/2,
3225               plt->contents + plt_offset + 2);
3226   /* Fixup the relative branch to PLT 0 */
3227   bfd_put_32 (output_bfd, - (plt->output_offset +
3228                              (PLT_ENTRY_SIZE * plt_index) + 22)/2,
3229               plt->contents + plt_offset + 24);
3230   /* Fixup offset into .rela.plt section.  */
3231   bfd_put_32 (output_bfd, relplt->output_offset +
3232               plt_index * sizeof (Elf64_External_Rela),
3233               plt->contents + plt_offset + 28);
3234
3235   /* Fill in the entry in the global offset table.
3236      Points to instruction after GOT offset.  */
3237   bfd_put_64 (output_bfd,
3238               (plt->output_section->vma
3239                + plt->output_offset
3240                + plt_offset
3241                + 14),
3242               gotplt->contents + got_offset);
3243
3244   /* Fill in the entry in the .rela.plt section.  */
3245   rela.r_offset = (gotplt->output_section->vma
3246                    + gotplt->output_offset
3247                    + got_offset);
3248
3249   if (!h
3250       || h->dynindx == -1
3251       || ((bfd_link_executable (info)
3252            || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
3253           && h->def_regular))
3254     {
3255       /* The symbol can be locally resolved.  */
3256       rela.r_info = ELF64_R_INFO (0, R_390_IRELATIVE);
3257       rela.r_addend = resolver_address;
3258     }
3259   else
3260     {
3261       rela.r_info = ELF64_R_INFO (h->dynindx, R_390_JMP_SLOT);
3262       rela.r_addend = 0;
3263     }
3264
3265   loc = relplt->contents + plt_index * sizeof (Elf64_External_Rela);
3266   bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3267 }
3268
3269
3270 /* Finish up dynamic symbol handling.  We set the contents of various
3271    dynamic sections here.  */
3272
3273 static bool
3274 elf_s390_finish_dynamic_symbol (bfd *output_bfd,
3275                                 struct bfd_link_info *info,
3276                                 struct elf_link_hash_entry *h,
3277                                 Elf_Internal_Sym *sym)
3278 {
3279   struct elf_s390_link_hash_table *htab;
3280   struct elf_s390_link_hash_entry *eh = (struct elf_s390_link_hash_entry*)h;
3281
3282   htab = elf_s390_hash_table (info);
3283
3284   if (h->plt.offset != (bfd_vma) -1)
3285     {
3286       bfd_vma plt_index;
3287       bfd_vma gotplt_offset;
3288       Elf_Internal_Rela rela;
3289       bfd_byte *loc;
3290
3291       /* This symbol has an entry in the procedure linkage table.  Set
3292          it up.  */
3293       if (s390_is_ifunc_symbol_p (h) && h->def_regular)
3294         {
3295           elf_s390_finish_ifunc_symbol (output_bfd, info, h,
3296             htab, h->plt.offset,
3297             eh->ifunc_resolver_address +
3298             eh->ifunc_resolver_section->output_offset +
3299             eh->ifunc_resolver_section->output_section->vma);
3300
3301           /* Do not return yet.  Handling of explicit GOT slots of
3302              IFUNC symbols is below.  */
3303         }
3304       else
3305         {
3306           if (h->dynindx == -1
3307               || htab->elf.splt == NULL
3308               || htab->elf.sgotplt == NULL
3309               || htab->elf.srelplt == NULL)
3310             abort ();
3311
3312           /* Calc. index no.
3313              Current offset - size first entry / entry size.  */
3314           plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3315
3316           /* The slots in the .got.plt correspond to the PLT slots in
3317              the same order.  */
3318           gotplt_offset = plt_index * GOT_ENTRY_SIZE;
3319
3320           /* If .got.plt comes first it needs to contain the 3 header
3321              entries.  */
3322           if (!s390_gotplt_after_got_p (info))
3323             gotplt_offset += 3 * GOT_ENTRY_SIZE;
3324
3325           /* Fill in the blueprint of a PLT.  */
3326           memcpy (htab->elf.splt->contents + h->plt.offset, elf_s390x_plt_entry,
3327                   PLT_ENTRY_SIZE);
3328
3329           /* The first instruction in the PLT entry is a LARL loading
3330              the address of the GOT slot.  We write the 4 byte
3331              immediate operand of the LARL instruction here.  */
3332           bfd_put_32 (output_bfd,
3333                       (htab->elf.sgotplt->output_section->vma +
3334                        htab->elf.sgotplt->output_offset + gotplt_offset
3335                        - (htab->elf.splt->output_section->vma +
3336                           htab->elf.splt->output_offset +
3337                           h->plt.offset))/2,
3338                       htab->elf.splt->contents + h->plt.offset + 2);
3339           /* Fixup the relative branch to PLT 0 */
3340           bfd_put_32 (output_bfd, - (PLT_FIRST_ENTRY_SIZE +
3341                                      (PLT_ENTRY_SIZE * plt_index) + 22)/2,
3342                       htab->elf.splt->contents + h->plt.offset + 24);
3343           /* Fixup offset into .rela.plt section.  */
3344           bfd_put_32 (output_bfd, plt_index * sizeof (Elf64_External_Rela),
3345                       htab->elf.splt->contents + h->plt.offset + 28);
3346
3347           /* Fill in the entry in the global offset table.
3348              Points to instruction after GOT offset.  */
3349           bfd_put_64 (output_bfd,
3350                       (htab->elf.splt->output_section->vma
3351                        + htab->elf.splt->output_offset
3352                        + h->plt.offset
3353                        + 14),
3354                       htab->elf.sgotplt->contents + gotplt_offset);
3355
3356           /* Fill in the entry in the .rela.plt section.  */
3357           rela.r_offset = (htab->elf.sgotplt->output_section->vma
3358                            + htab->elf.sgotplt->output_offset
3359                            + gotplt_offset);
3360           rela.r_info = ELF64_R_INFO (h->dynindx, R_390_JMP_SLOT);
3361           rela.r_addend = 0;
3362           loc = htab->elf.srelplt->contents + plt_index *
3363             sizeof (Elf64_External_Rela);
3364           bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3365
3366           if (!h->def_regular)
3367             {
3368               /* Mark the symbol as undefined, rather than as defined in
3369                  the .plt section.  Leave the value alone.  This is a clue
3370                  for the dynamic linker, to make function pointer
3371                  comparisons work between an application and shared
3372                  library.  */
3373               sym->st_shndx = SHN_UNDEF;
3374             }
3375         }
3376     }
3377
3378   if (h->got.offset != (bfd_vma) -1
3379       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_GD
3380       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE
3381       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE_NLT)
3382     {
3383       Elf_Internal_Rela rela;
3384       bfd_byte *loc;
3385
3386       /* This symbol has an entry in the global offset table.  Set it
3387          up.  */
3388       if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
3389         abort ();
3390
3391       rela.r_offset = (htab->elf.sgot->output_section->vma
3392                        + htab->elf.sgot->output_offset
3393                        + (h->got.offset &~ (bfd_vma) 1));
3394
3395       if (h->def_regular && s390_is_ifunc_symbol_p (h))
3396         {
3397           if (bfd_link_pic (info))
3398             {
3399               /* An explicit GOT slot usage needs GLOB_DAT.  If the
3400                  symbol references local the implicit got.iplt slot
3401                  will be used and the IRELATIVE reloc has been created
3402                  above.  */
3403               goto do_glob_dat;
3404             }
3405           else
3406             {
3407               /* For non-shared objects explicit GOT slots must be
3408                  filled with the PLT slot address for pointer
3409                  equality reasons.  */
3410               bfd_put_64 (output_bfd, (htab->elf.iplt->output_section->vma
3411                                        + htab->elf.iplt->output_offset
3412                                        + h->plt.offset),
3413                           htab->elf.sgot->contents + h->got.offset);
3414               return true;
3415             }
3416         }
3417       else if (bfd_link_pic (info)
3418                && SYMBOL_REFERENCES_LOCAL (info, h))
3419         {
3420           if (UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
3421             return true;
3422
3423           /* If this is a static link, or it is a -Bsymbolic link and
3424              the symbol is defined locally or was forced to be local
3425              because of a version file, we just want to emit a
3426              RELATIVE reloc.  The entry in the global offset table
3427              will already have been initialized in the
3428              relocate_section function.  */
3429           if (!(h->def_regular || ELF_COMMON_DEF_P (h)))
3430             return false;
3431           BFD_ASSERT((h->got.offset & 1) != 0);
3432           rela.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
3433           rela.r_addend = (h->root.u.def.value
3434                            + h->root.u.def.section->output_section->vma
3435                            + h->root.u.def.section->output_offset);
3436         }
3437       else
3438         {
3439           BFD_ASSERT((h->got.offset & 1) == 0);
3440         do_glob_dat:
3441           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgot->contents + h->got.offset);
3442           rela.r_info = ELF64_R_INFO (h->dynindx, R_390_GLOB_DAT);
3443           rela.r_addend = 0;
3444         }
3445
3446       loc = htab->elf.srelgot->contents;
3447       loc += htab->elf.srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
3448       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3449     }
3450
3451   if (h->needs_copy)
3452     {
3453       Elf_Internal_Rela rela;
3454       asection *s;
3455       bfd_byte *loc;
3456
3457       /* This symbols needs a copy reloc.  Set it up.  */
3458
3459       if (h->dynindx == -1
3460           || (h->root.type != bfd_link_hash_defined
3461               && h->root.type != bfd_link_hash_defweak)
3462           || htab->elf.srelbss == NULL)
3463         abort ();
3464
3465       rela.r_offset = (h->root.u.def.value
3466                        + h->root.u.def.section->output_section->vma
3467                        + h->root.u.def.section->output_offset);
3468       rela.r_info = ELF64_R_INFO (h->dynindx, R_390_COPY);
3469       rela.r_addend = 0;
3470       if (h->root.u.def.section == htab->elf.sdynrelro)
3471         s = htab->elf.sreldynrelro;
3472       else
3473         s = htab->elf.srelbss;
3474       loc = s->contents + s->reloc_count++ * sizeof (Elf64_External_Rela);
3475       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3476     }
3477
3478   /* Mark some specially defined symbols as absolute.  */
3479   if (h == htab->elf.hdynamic
3480       || h == htab->elf.hgot
3481       || h == htab->elf.hplt)
3482     sym->st_shndx = SHN_ABS;
3483
3484   return true;
3485 }
3486
3487 /* Used to decide how to sort relocs in an optimal manner for the
3488    dynamic linker, before writing them out.  */
3489
3490 static enum elf_reloc_type_class
3491 elf_s390_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
3492                            const asection *rel_sec ATTRIBUTE_UNUSED,
3493                            const Elf_Internal_Rela *rela)
3494 {
3495   bfd *abfd = info->output_bfd;
3496   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3497   struct elf_s390_link_hash_table *htab = elf_s390_hash_table (info);
3498   unsigned long r_symndx = ELF64_R_SYM (rela->r_info);
3499   Elf_Internal_Sym sym;
3500
3501   if (htab->elf.dynsym == NULL
3502       || !bed->s->swap_symbol_in (abfd,
3503                                   (htab->elf.dynsym->contents
3504                                    + r_symndx * bed->s->sizeof_sym),
3505                                   0, &sym))
3506     abort ();
3507
3508   /* Check relocation against STT_GNU_IFUNC symbol.  */
3509   if (ELF_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
3510     return reloc_class_ifunc;
3511
3512   switch ((int) ELF64_R_TYPE (rela->r_info))
3513     {
3514     case R_390_RELATIVE:
3515       return reloc_class_relative;
3516     case R_390_JMP_SLOT:
3517       return reloc_class_plt;
3518     case R_390_COPY:
3519       return reloc_class_copy;
3520     default:
3521       return reloc_class_normal;
3522     }
3523 }
3524
3525 /* Finish up the dynamic sections.  */
3526
3527 static bool
3528 elf_s390_finish_dynamic_sections (bfd *output_bfd,
3529                                   struct bfd_link_info *info)
3530 {
3531   struct elf_s390_link_hash_table *htab;
3532   bfd *dynobj;
3533   asection *sdyn;
3534   bfd *ibfd;
3535   unsigned int i;
3536
3537   htab = elf_s390_hash_table (info);
3538   if (htab == NULL)
3539     return false;
3540
3541   dynobj = htab->elf.dynobj;
3542   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3543
3544   if (htab->elf.dynamic_sections_created)
3545     {
3546       Elf64_External_Dyn *dyncon, *dynconend;
3547
3548       if (sdyn == NULL || htab->elf.sgot == NULL)
3549         abort ();
3550
3551       dyncon = (Elf64_External_Dyn *) sdyn->contents;
3552       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
3553       for (; dyncon < dynconend; dyncon++)
3554         {
3555           Elf_Internal_Dyn dyn;
3556           asection *s;
3557
3558           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3559
3560           switch (dyn.d_tag)
3561             {
3562             default:
3563               continue;
3564
3565             case DT_PLTGOT:
3566               /* DT_PLTGOT matches _GLOBAL_OFFSET_TABLE_ */
3567               dyn.d_un.d_ptr = s390_got_pointer (info);
3568               break;
3569
3570             case DT_JMPREL:
3571               s = htab->elf.srelplt;
3572               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3573               break;
3574
3575             case DT_PLTRELSZ:
3576               dyn.d_un.d_val = htab->elf.srelplt->size;
3577               if (htab->elf.irelplt)
3578                 dyn.d_un.d_val += htab->elf.irelplt->size;
3579               break;
3580
3581             case DT_RELASZ:
3582               /* The procedure linkage table relocs (DT_JMPREL) should
3583                  not be included in the overall relocs (DT_RELA).
3584                  Therefore, we override the DT_RELASZ entry here to
3585                  make it not include the JMPREL relocs.  Since the
3586                  linker script arranges for .rela.plt to follow all
3587                  other relocation sections, we don't have to worry
3588                  about changing the DT_RELA entry.  */
3589               dyn.d_un.d_val -= htab->elf.srelplt->size;
3590               if (htab->elf.irelplt)
3591                 dyn.d_un.d_val -= htab->elf.irelplt->size;
3592               break;
3593             }
3594
3595           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3596         }
3597
3598       /* Fill in the special first entry in the procedure linkage table.  */
3599       if (htab->elf.splt && htab->elf.splt->size > 0)
3600         {
3601           /* fill in blueprint for plt 0 entry */
3602           memcpy (htab->elf.splt->contents, elf_s390x_first_plt_entry,
3603                   PLT_FIRST_ENTRY_SIZE);
3604           /* The second instruction in the first PLT entry is a LARL
3605              loading the GOT pointer.  Fill in the LARL immediate
3606              address.  */
3607           bfd_put_32 (output_bfd,
3608                       (s390_got_pointer (info)
3609                        - htab->elf.splt->output_section->vma
3610                        - htab->elf.splt->output_offset - 6)/2,
3611                       htab->elf.splt->contents + 8);
3612         }
3613       if (elf_section_data (htab->elf.splt->output_section) != NULL)
3614         elf_section_data (htab->elf.splt->output_section)->this_hdr.sh_entsize
3615           = PLT_ENTRY_SIZE;
3616     }
3617
3618   if (htab->elf.hgot && htab->elf.hgot->root.u.def.section)
3619     {
3620       /* Fill in the first three entries in the global offset table.  */
3621       if (htab->elf.hgot->root.u.def.section->size > 0)
3622         {
3623           bfd_put_64 (output_bfd,
3624                       (sdyn == NULL ? (bfd_vma) 0
3625                        : sdyn->output_section->vma + sdyn->output_offset),
3626                       htab->elf.hgot->root.u.def.section->contents);
3627           /* One entry for shared object struct ptr.  */
3628           bfd_put_64 (output_bfd, (bfd_vma) 0,
3629                       htab->elf.hgot->root.u.def.section->contents + 8);
3630           /* One entry for _dl_runtime_resolve.  */
3631           bfd_put_64 (output_bfd, (bfd_vma) 0,
3632                       htab->elf.hgot->root.u.def.section->contents + 16);
3633         }
3634       if (htab->elf.sgot != NULL && htab->elf.sgot->size > 0)
3635         elf_section_data (htab->elf.sgot->output_section)
3636           ->this_hdr.sh_entsize = 8;
3637     }
3638
3639   /* Finish dynamic symbol for local IFUNC symbols.  */
3640   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3641     {
3642       struct plt_entry *local_plt;
3643       Elf_Internal_Sym *isym;
3644       Elf_Internal_Shdr *symtab_hdr;
3645
3646       symtab_hdr = &elf_symtab_hdr (ibfd);
3647
3648       if (!is_s390_elf (ibfd))
3649         continue;
3650
3651       local_plt = elf_s390_local_plt (ibfd);
3652       if (local_plt != NULL)
3653         for (i = 0; i < symtab_hdr->sh_info; i++)
3654           {
3655             if (local_plt[i].plt.offset != (bfd_vma) -1)
3656               {
3657                 asection *sec = local_plt[i].sec;
3658                 isym = bfd_sym_from_r_symndx (&htab->elf.sym_cache, ibfd, i);
3659                 if (isym == NULL)
3660                   return false;
3661
3662                 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
3663                   elf_s390_finish_ifunc_symbol (output_bfd, info, NULL, htab,
3664                                                 local_plt[i].plt.offset,
3665                                                 isym->st_value
3666                                                 + sec->output_section->vma
3667                                                 + sec->output_offset);
3668
3669               }
3670           }
3671     }
3672
3673   return true;
3674 }
3675 \f
3676 /* Support for core dump NOTE sections.  */
3677
3678 static bool
3679 elf_s390_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3680 {
3681   int offset;
3682   size_t size;
3683
3684   switch (note->descsz)
3685     {
3686     default:
3687       return false;
3688
3689     case 336:                   /* sizeof(struct elf_prstatus) on s390x */
3690       /* pr_cursig */
3691       elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3692
3693       /* pr_pid */
3694       elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
3695
3696       /* pr_reg */
3697       offset = 112;
3698       size = 216;
3699       break;
3700     }
3701
3702   /* Make a ".reg/999" section.  */
3703   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3704                                           size, note->descpos + offset);
3705 }
3706
3707 static bool
3708 elf_s390_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3709 {
3710   switch (note->descsz)
3711     {
3712     default:
3713       return false;
3714
3715     case 136:                   /* sizeof(struct elf_prpsinfo) on s390x */
3716       elf_tdata (abfd)->core->pid
3717         = bfd_get_32 (abfd, note->descdata + 24);
3718       elf_tdata (abfd)->core->program
3719         = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
3720       elf_tdata (abfd)->core->command
3721         = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
3722     }
3723
3724   /* Note that for some reason, a spurious space is tacked
3725      onto the end of the args in some (at least one anyway)
3726      implementations, so strip it off if it exists.  */
3727
3728   {
3729     char *command = elf_tdata (abfd)->core->command;
3730     int n = strlen (command);
3731
3732     if (0 < n && command[n - 1] == ' ')
3733       command[n - 1] = '\0';
3734   }
3735
3736   return true;
3737 }
3738
3739 static char *
3740 elf_s390_write_core_note (bfd *abfd, char *buf, int *bufsiz,
3741                           int note_type, ...)
3742 {
3743   va_list ap;
3744
3745   switch (note_type)
3746     {
3747     default:
3748       return NULL;
3749
3750     case NT_PRPSINFO:
3751       {
3752         char data[136] ATTRIBUTE_NONSTRING = { 0 };
3753         const char *fname, *psargs;
3754
3755         va_start (ap, note_type);
3756         fname = va_arg (ap, const char *);
3757         psargs = va_arg (ap, const char *);
3758         va_end (ap);
3759
3760         strncpy (data + 40, fname, 16);
3761 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
3762         DIAGNOSTIC_PUSH;
3763         /* GCC 8.0 and 8.1 warn about 80 equals destination size with
3764            -Wstringop-truncation:
3765            https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643
3766          */
3767         DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION;
3768 #endif
3769         strncpy (data + 56, psargs, 80);
3770 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
3771         DIAGNOSTIC_POP;
3772 #endif
3773         return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
3774                                    &data, sizeof (data));
3775       }
3776
3777     case NT_PRSTATUS:
3778       {
3779         char data[336] = { 0 };
3780         long pid;
3781         int cursig;
3782         const void *gregs;
3783
3784         va_start (ap, note_type);
3785         pid = va_arg (ap, long);
3786         cursig = va_arg (ap, int);
3787         gregs = va_arg (ap, const void *);
3788         va_end (ap);
3789
3790         bfd_put_16 (abfd, cursig, data + 12);
3791         bfd_put_32 (abfd, pid, data + 32);
3792         memcpy (data + 112, gregs, 216);
3793         return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
3794                                    &data, sizeof (data));
3795       }
3796     }
3797   /* NOTREACHED */
3798 }
3799 \f
3800 /* Return address for Ith PLT stub in section PLT, for relocation REL
3801    or (bfd_vma) -1 if it should not be included.  */
3802
3803 static bfd_vma
3804 elf_s390_plt_sym_val (bfd_vma i, const asection *plt,
3805                       const arelent *rel ATTRIBUTE_UNUSED)
3806 {
3807   return plt->vma + PLT_FIRST_ENTRY_SIZE + i * PLT_ENTRY_SIZE;
3808 }
3809
3810 /* Merge backend specific data from an object file to the output
3811    object file when linking.  */
3812
3813 static bool
3814 elf64_s390_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
3815 {
3816   if (!is_s390_elf (ibfd) || !is_s390_elf (info->output_bfd))
3817     return true;
3818
3819   return elf_s390_merge_obj_attributes (ibfd, info);
3820 }
3821
3822 /* We may add a PT_S390_PGSTE program header.  */
3823
3824 static int
3825 elf_s390_additional_program_headers (bfd *abfd ATTRIBUTE_UNUSED,
3826                                      struct bfd_link_info *info)
3827 {
3828   struct elf_s390_link_hash_table *htab;
3829
3830   if (info)
3831     {
3832       htab = elf_s390_hash_table (info);
3833       if (htab)
3834         return htab->params->pgste;
3835     }
3836   return 0;
3837 }
3838
3839
3840 /* Add the PT_S390_PGSTE program header.  */
3841
3842 static bool
3843 elf_s390_modify_segment_map (bfd *abfd, struct bfd_link_info *info)
3844 {
3845   struct elf_s390_link_hash_table *htab;
3846   struct elf_segment_map *m, *pm = NULL;
3847
3848   if (!abfd || !info)
3849     return true;
3850
3851   htab = elf_s390_hash_table (info);
3852   if (!htab || !htab->params->pgste)
3853     return true;
3854
3855   /* If there is already a PT_S390_PGSTE header, avoid adding
3856      another.  */
3857   m = elf_seg_map (abfd);
3858   while (m && m->p_type != PT_S390_PGSTE)
3859     {
3860       pm = m;
3861       m = m->next;
3862     }
3863
3864   if (m)
3865     return true;
3866
3867   m = (struct elf_segment_map *)
3868     bfd_zalloc (abfd, sizeof (struct elf_segment_map));
3869   if (m == NULL)
3870     return false;
3871   m->p_type = PT_S390_PGSTE;
3872   m->count = 0;
3873   m->next = NULL;
3874   if (pm)
3875     pm->next = m;
3876
3877   return true;
3878 }
3879
3880 bool
3881 bfd_elf_s390_set_options (struct bfd_link_info *info,
3882                           struct s390_elf_params *params)
3883 {
3884   struct elf_s390_link_hash_table *htab;
3885
3886   if (info)
3887     {
3888       htab = elf_s390_hash_table (info);
3889       if (htab)
3890         htab->params = params;
3891     }
3892
3893   return true;
3894 }
3895
3896
3897 /* Why was the hash table entry size definition changed from
3898    ARCH_SIZE/8 to 4? This breaks the 64 bit dynamic linker and
3899    this is the only reason for the s390_elf64_size_info structure.  */
3900
3901 const struct elf_size_info s390_elf64_size_info =
3902 {
3903   sizeof (Elf64_External_Ehdr),
3904   sizeof (Elf64_External_Phdr),
3905   sizeof (Elf64_External_Shdr),
3906   sizeof (Elf64_External_Rel),
3907   sizeof (Elf64_External_Rela),
3908   sizeof (Elf64_External_Sym),
3909   sizeof (Elf64_External_Dyn),
3910   sizeof (Elf_External_Note),
3911   8,            /* hash-table entry size.  */
3912   1,            /* internal relocations per external relocations.  */
3913   64,           /* arch_size.  */
3914   3,            /* log_file_align.  */
3915   ELFCLASS64, EV_CURRENT,
3916   bfd_elf64_write_out_phdrs,
3917   bfd_elf64_write_shdrs_and_ehdr,
3918   bfd_elf64_checksum_contents,
3919   bfd_elf64_write_relocs,
3920   bfd_elf64_swap_symbol_in,
3921   bfd_elf64_swap_symbol_out,
3922   bfd_elf64_slurp_reloc_table,
3923   bfd_elf64_slurp_symbol_table,
3924   bfd_elf64_swap_dyn_in,
3925   bfd_elf64_swap_dyn_out,
3926   bfd_elf64_swap_reloc_in,
3927   bfd_elf64_swap_reloc_out,
3928   bfd_elf64_swap_reloca_in,
3929   bfd_elf64_swap_reloca_out
3930 };
3931
3932 #define TARGET_BIG_SYM  s390_elf64_vec
3933 #define TARGET_BIG_NAME "elf64-s390"
3934 #define ELF_ARCH        bfd_arch_s390
3935 #define ELF_TARGET_ID   S390_ELF_DATA
3936 #define ELF_MACHINE_CODE EM_S390
3937 #define ELF_MACHINE_ALT1 EM_S390_OLD
3938 #define ELF_MAXPAGESIZE 0x1000
3939
3940 #define elf_backend_size_info           s390_elf64_size_info
3941
3942 #define elf_backend_can_gc_sections     1
3943 #define elf_backend_can_refcount        1
3944 #define elf_backend_want_got_plt        1
3945 #define elf_backend_plt_readonly        1
3946 #define elf_backend_want_plt_sym        0
3947 #define elf_backend_got_header_size     24
3948 #define elf_backend_want_dynrelro       1
3949 #define elf_backend_rela_normal         1
3950
3951 #define elf_info_to_howto               elf_s390_info_to_howto
3952
3953 #define bfd_elf64_bfd_is_local_label_name     elf_s390_is_local_label_name
3954 #define bfd_elf64_bfd_link_hash_table_create  elf_s390_link_hash_table_create
3955 #define bfd_elf64_bfd_reloc_type_lookup       elf_s390_reloc_type_lookup
3956 #define bfd_elf64_bfd_reloc_name_lookup       elf_s390_reloc_name_lookup
3957 #define bfd_elf64_bfd_merge_private_bfd_data  elf64_s390_merge_private_bfd_data
3958
3959 #define elf_backend_adjust_dynamic_symbol     elf_s390_adjust_dynamic_symbol
3960 #define elf_backend_check_relocs              elf_s390_check_relocs
3961 #define elf_backend_copy_indirect_symbol      elf_s390_copy_indirect_symbol
3962 #define elf_backend_create_dynamic_sections   _bfd_elf_create_dynamic_sections
3963 #define elf_backend_finish_dynamic_sections   elf_s390_finish_dynamic_sections
3964 #define elf_backend_finish_dynamic_symbol     elf_s390_finish_dynamic_symbol
3965 #define elf_backend_gc_mark_hook              elf_s390_gc_mark_hook
3966 #define elf_backend_reloc_type_class          elf_s390_reloc_type_class
3967 #define elf_backend_relocate_section          elf_s390_relocate_section
3968 #define elf_backend_late_size_sections        elf_s390_late_size_sections
3969 #define elf_backend_init_index_section        _bfd_elf_init_1_index_section
3970 #define elf_backend_grok_prstatus             elf_s390_grok_prstatus
3971 #define elf_backend_grok_psinfo               elf_s390_grok_psinfo
3972 #define elf_backend_write_core_note           elf_s390_write_core_note
3973 #define elf_backend_plt_sym_val               elf_s390_plt_sym_val
3974 #define elf_backend_sort_relocs_p             elf_s390_elf_sort_relocs_p
3975 #define elf_backend_additional_program_headers elf_s390_additional_program_headers
3976 #define elf_backend_modify_segment_map        elf_s390_modify_segment_map
3977
3978 #define bfd_elf64_mkobject              elf_s390_mkobject
3979 #define elf_backend_object_p            elf_s390_object_p
3980
3981 #include "elf64-target.h"