bfd/elf64-s390.c

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