bfd/elf64-s390.c

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