bfd/elf32-s390.c

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