bfd/elf64-s390.c

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