bfd/elf32-s390.c

   1 /* IBM S/390-specific support for 32-bit ELF
   2    Copyright (C) 2000-2015 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_GOTOFF16:
1116         case R_390_GOTOFF32:
1117         case R_390_GOTPC:
1118         case R_390_GOTPCDBL:
1119           /* These relocs do not need a GOT slot.  They just load the
1120              GOT pointer itself or address something else relative to
1121              the GOT.  Since the GOT pointer has been set up above we
1122              are done.  */
1123           break;
1124
1125         case R_390_PLT12DBL:
1126         case R_390_PLT16DBL:
1127         case R_390_PLT24DBL:
1128         case R_390_PLT32DBL:
1129         case R_390_PLT32:
1130         case R_390_PLTOFF16:
1131         case R_390_PLTOFF32:
1132           /* This symbol requires a procedure linkage table entry.  We
1133              actually build the entry in adjust_dynamic_symbol,
1134              because this might be a case of linking PIC code which is
1135              never referenced by a dynamic object, in which case we
1136              don't need to generate a procedure linkage table entry
1137              after all.  */
1138
1139           /* If this is a local symbol, we resolve it directly without
1140              creating a procedure linkage table entry.  */
1141           if (h != NULL)
1142             {
1143               h->needs_plt = 1;
1144               h->plt.refcount += 1;
1145             }
1146           break;
1147
1148         case R_390_GOTPLT12:
1149         case R_390_GOTPLT16:
1150         case R_390_GOTPLT20:
1151         case R_390_GOTPLT32:
1152         case R_390_GOTPLTENT:
1153           /* This symbol requires either a procedure linkage table entry
1154              or an entry in the local got. We actually build the entry
1155              in adjust_dynamic_symbol because whether this is really a
1156              global reference can change and with it the fact if we have
1157              to create a plt entry or a local got entry. To be able to
1158              make a once global symbol a local one we have to keep track
1159              of the number of gotplt references that exist for this
1160              symbol.  */
1161           if (h != NULL)
1162             {
1163               ((struct elf_s390_link_hash_entry *) h)->gotplt_refcount++;
1164               h->needs_plt = 1;
1165               h->plt.refcount += 1;
1166             }
1167           else
1168             local_got_refcounts[r_symndx] += 1;
1169           break;
1170
1171         case R_390_TLS_LDM32:
1172           htab->tls_ldm_got.refcount += 1;
1173           break;
1174
1175         case R_390_TLS_IE32:
1176         case R_390_TLS_GOTIE12:
1177         case R_390_TLS_GOTIE20:
1178         case R_390_TLS_GOTIE32:
1179         case R_390_TLS_IEENT:
1180           if (bfd_link_pic (info))
1181             info->flags |= DF_STATIC_TLS;
1182           /* Fall through.  */
1183
1184         case R_390_GOT12:
1185         case R_390_GOT16:
1186         case R_390_GOT20:
1187         case R_390_GOT32:
1188         case R_390_GOTENT:
1189         case R_390_TLS_GD32:
1190           /* This symbol requires a global offset table entry.  */
1191           switch (r_type)
1192             {
1193             default:
1194             case R_390_GOT12:
1195             case R_390_GOT16:
1196             case R_390_GOT20:
1197             case R_390_GOT32:
1198             case R_390_GOTENT:
1199               tls_type = GOT_NORMAL;
1200               break;
1201             case R_390_TLS_GD32:
1202               tls_type = GOT_TLS_GD;
1203               break;
1204             case R_390_TLS_IE32:
1205             case R_390_TLS_GOTIE32:
1206               tls_type = GOT_TLS_IE;
1207               break;
1208             case R_390_TLS_GOTIE12:
1209             case R_390_TLS_GOTIE20:
1210             case R_390_TLS_IEENT:
1211               tls_type = GOT_TLS_IE_NLT;
1212               break;
1213             }
1214
1215           if (h != NULL)
1216             {
1217               h->got.refcount += 1;
1218               old_tls_type = elf_s390_hash_entry(h)->tls_type;
1219             }
1220           else
1221             {
1222               local_got_refcounts[r_symndx] += 1;
1223               old_tls_type = elf_s390_local_got_tls_type (abfd) [r_symndx];
1224             }
1225           /* If a TLS symbol is accessed using IE at least once,
1226              there is no point to use dynamic model for it.  */
1227           if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN)
1228             {
1229               if (old_tls_type == GOT_NORMAL || tls_type == GOT_NORMAL)
1230                 {
1231                   (*_bfd_error_handler)
1232                     (_("%B: `%s' accessed both as normal and thread local symbol"),
1233                      abfd, h->root.root.string);
1234                   return FALSE;
1235                 }
1236               if (old_tls_type > tls_type)
1237                 tls_type = old_tls_type;
1238             }
1239
1240           if (old_tls_type != tls_type)
1241             {
1242               if (h != NULL)
1243                 elf_s390_hash_entry (h)->tls_type = tls_type;
1244               else
1245                 elf_s390_local_got_tls_type (abfd) [r_symndx] = tls_type;
1246             }
1247
1248           if (r_type != R_390_TLS_IE32)
1249             break;
1250           /* Fall through.  */
1251
1252         case R_390_TLS_LE32:
1253           /* For static linking and executables this reloc will be
1254              calculated at linktime otherwise a TLS_TPOFF runtime
1255              reloc will be generated.  */
1256           if (r_type == R_390_TLS_LE32 && bfd_link_pie (info))
1257             break;
1258
1259           if (!bfd_link_pic (info))
1260             break;
1261           info->flags |= DF_STATIC_TLS;
1262           /* Fall through.  */
1263
1264         case R_390_8:
1265         case R_390_16:
1266         case R_390_32:
1267         case R_390_PC16:
1268         case R_390_PC12DBL:
1269         case R_390_PC16DBL:
1270         case R_390_PC24DBL:
1271         case R_390_PC32DBL:
1272         case R_390_PC32:
1273           if (h != NULL)
1274             {
1275               /* If this reloc is in a read-only section, we might
1276                  need a copy reloc.  We can't check reliably at this
1277                  stage whether the section is read-only, as input
1278                  sections have not yet been mapped to output sections.
1279                  Tentatively set the flag for now, and correct in
1280                  adjust_dynamic_symbol.  */
1281               h->non_got_ref = 1;
1282
1283               if (!bfd_link_pic (info))
1284                 {
1285                   /* We may need a .plt entry if the function this reloc
1286                      refers to is in a shared lib.  */
1287                   h->plt.refcount += 1;
1288                 }
1289             }
1290
1291           /* If we are creating a shared library, and this is a reloc
1292              against a global symbol, or a non PC relative reloc
1293              against a local symbol, then we need to copy the reloc
1294              into the shared library.  However, if we are linking with
1295              -Bsymbolic, we do not need to copy a reloc against a
1296              global symbol which is defined in an object we are
1297              including in the link (i.e., DEF_REGULAR is set).  At
1298              this point we have not seen all the input files, so it is
1299              possible that DEF_REGULAR is not set now but will be set
1300              later (it is never cleared).  In case of a weak definition,
1301              DEF_REGULAR may be cleared later by a strong definition in
1302              a shared library. We account for that possibility below by
1303              storing information in the relocs_copied field of the hash
1304              table entry.  A similar situation occurs when creating
1305              shared libraries and symbol visibility changes render the
1306              symbol local.
1307
1308              If on the other hand, we are creating an executable, we
1309              may need to keep relocations for symbols satisfied by a
1310              dynamic library if we manage to avoid copy relocs for the
1311              symbol.  */
1312           if ((bfd_link_pic (info)
1313                && (sec->flags & SEC_ALLOC) != 0
1314                && ((ELF32_R_TYPE (rel->r_info) != R_390_PC16
1315                     && ELF32_R_TYPE (rel->r_info) != R_390_PC12DBL
1316                     && ELF32_R_TYPE (rel->r_info) != R_390_PC16DBL
1317                     && ELF32_R_TYPE (rel->r_info) != R_390_PC24DBL
1318                     && ELF32_R_TYPE (rel->r_info) != R_390_PC32DBL
1319                     && ELF32_R_TYPE (rel->r_info) != R_390_PC32)
1320                    || (h != NULL
1321                        && (! SYMBOLIC_BIND (info, h)
1322                            || h->root.type == bfd_link_hash_defweak
1323                            || !h->def_regular))))
1324               || (ELIMINATE_COPY_RELOCS
1325                   && !bfd_link_pic (info)
1326                   && (sec->flags & SEC_ALLOC) != 0
1327                   && h != NULL
1328                   && (h->root.type == bfd_link_hash_defweak
1329                       || !h->def_regular)))
1330             {
1331               struct elf_dyn_relocs *p;
1332               struct elf_dyn_relocs **head;
1333
1334               /* We must copy these reloc types into the output file.
1335                  Create a reloc section in dynobj and make room for
1336                  this reloc.  */
1337               if (sreloc == NULL)
1338                 {
1339                   if (htab->elf.dynobj == NULL)
1340                     htab->elf.dynobj = abfd;
1341
1342                   sreloc = _bfd_elf_make_dynamic_reloc_section
1343                     (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ TRUE);
1344
1345                   if (sreloc == NULL)
1346                     return FALSE;
1347                 }
1348
1349               /* If this is a global symbol, we count the number of
1350                  relocations we need for this symbol.  */
1351               if (h != NULL)
1352                 {
1353                   head = &((struct elf_s390_link_hash_entry *) h)->dyn_relocs;
1354                 }
1355               else
1356                 {
1357                   /* Track dynamic relocs needed for local syms too.
1358                      We really need local syms available to do this
1359                      easily.  Oh well.  */
1360                   asection *s;
1361                   void *vpp;
1362
1363                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1364                                                 abfd, r_symndx);
1365                   if (isym == NULL)
1366                     return FALSE;
1367
1368                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1369                   if (s == NULL)
1370                     s = sec;
1371
1372                   vpp = &elf_section_data (s)->local_dynrel;
1373                   head = (struct elf_dyn_relocs **) vpp;
1374                 }
1375
1376               p = *head;
1377               if (p == NULL || p->sec != sec)
1378                 {
1379                   bfd_size_type amt = sizeof *p;
1380
1381                   p = ((struct elf_dyn_relocs *)
1382                        bfd_alloc (htab->elf.dynobj, amt));
1383                   if (p == NULL)
1384                     return FALSE;
1385                   p->next = *head;
1386                   *head = p;
1387                   p->sec = sec;
1388                   p->count = 0;
1389                   p->pc_count = 0;
1390                 }
1391
1392               p->count += 1;
1393               if (ELF32_R_TYPE (rel->r_info) == R_390_PC16
1394                   || ELF32_R_TYPE (rel->r_info) == R_390_PC12DBL
1395                   || ELF32_R_TYPE (rel->r_info) == R_390_PC16DBL
1396                   || ELF32_R_TYPE (rel->r_info) == R_390_PC24DBL
1397                   || ELF32_R_TYPE (rel->r_info) == R_390_PC32DBL
1398                   || ELF32_R_TYPE (rel->r_info) == R_390_PC32)
1399                 p->pc_count += 1;
1400             }
1401           break;
1402
1403           /* This relocation describes the C++ object vtable hierarchy.
1404              Reconstruct it for later use during GC.  */
1405         case R_390_GNU_VTINHERIT:
1406           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1407             return FALSE;
1408           break;
1409
1410           /* This relocation describes which C++ vtable entries are actually
1411              used.  Record for later use during GC.  */
1412         case R_390_GNU_VTENTRY:
1413           BFD_ASSERT (h != NULL);
1414           if (h != NULL
1415               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1416             return FALSE;
1417           break;
1418
1419         default:
1420           break;
1421         }
1422     }
1423
1424   return TRUE;
1425 }
1426
1427 /* Return the section that should be marked against GC for a given
1428    relocation.  */
1429
1430 static asection *
1431 elf_s390_gc_mark_hook (asection *sec,
1432                        struct bfd_link_info *info,
1433                        Elf_Internal_Rela *rel,
1434                        struct elf_link_hash_entry *h,
1435                        Elf_Internal_Sym *sym)
1436 {
1437   if (h != NULL)
1438     switch (ELF32_R_TYPE (rel->r_info))
1439       {
1440       case R_390_GNU_VTINHERIT:
1441       case R_390_GNU_VTENTRY:
1442         return NULL;
1443       }
1444   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1445
1446 }
1447
1448 /* Update the got entry reference counts for the section being removed.  */
1449
1450 static bfd_boolean
1451 elf_s390_gc_sweep_hook (bfd *abfd,
1452                         struct bfd_link_info *info,
1453                         asection *sec,
1454                         const Elf_Internal_Rela *relocs)
1455 {
1456   struct elf_s390_link_hash_table *htab;
1457   Elf_Internal_Shdr *symtab_hdr;
1458   struct elf_link_hash_entry **sym_hashes;
1459   bfd_signed_vma *local_got_refcounts;
1460   const Elf_Internal_Rela *rel, *relend;
1461
1462   if (bfd_link_relocatable (info))
1463     return TRUE;
1464
1465   htab = elf_s390_hash_table (info);
1466   if (htab == NULL)
1467     return FALSE;
1468
1469   elf_section_data (sec)->local_dynrel = NULL;
1470
1471   symtab_hdr = &elf_symtab_hdr (abfd);
1472   sym_hashes = elf_sym_hashes (abfd);
1473   local_got_refcounts = elf_local_got_refcounts (abfd);
1474
1475   relend = relocs + sec->reloc_count;
1476   for (rel = relocs; rel < relend; rel++)
1477     {
1478       unsigned long r_symndx;
1479       unsigned int r_type;
1480       struct elf_link_hash_entry *h = NULL;
1481
1482       r_symndx = ELF32_R_SYM (rel->r_info);
1483       if (r_symndx >= symtab_hdr->sh_info)
1484         {
1485           struct elf_s390_link_hash_entry *eh;
1486           struct elf_dyn_relocs **pp;
1487           struct elf_dyn_relocs *p;
1488
1489           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1490           while (h->root.type == bfd_link_hash_indirect
1491                  || h->root.type == bfd_link_hash_warning)
1492             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1493           eh = (struct elf_s390_link_hash_entry *) h;
1494
1495           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1496             if (p->sec == sec)
1497               {
1498                 /* Everything must go for SEC.  */
1499                 *pp = p->next;
1500                 break;
1501               }
1502         }
1503       else
1504         {
1505           Elf_Internal_Sym *isym;
1506
1507           /* A local symbol.  */
1508           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1509                                         abfd, r_symndx);
1510           if (isym == NULL)
1511             return FALSE;
1512
1513           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1514             {
1515               struct plt_entry *plt = elf_s390_local_plt (abfd);
1516               if (plt[r_symndx].plt.refcount > 0)
1517                 plt[r_symndx].plt.refcount--;
1518             }
1519         }
1520
1521       r_type = ELF32_R_TYPE (rel->r_info);
1522       r_type = elf_s390_tls_transition (info, r_type, h != NULL);
1523       switch (r_type)
1524         {
1525         case R_390_TLS_LDM32:
1526           if (elf_s390_hash_table (info)->tls_ldm_got.refcount > 0)
1527             elf_s390_hash_table (info)->tls_ldm_got.refcount -= 1;
1528           break;
1529
1530         case R_390_GOTOFF16:
1531         case R_390_GOTOFF32:
1532         case R_390_GOTPC:
1533         case R_390_GOTPCDBL:
1534           break;
1535
1536         case R_390_TLS_GD32:
1537         case R_390_TLS_IE32:
1538         case R_390_TLS_GOTIE12:
1539         case R_390_TLS_GOTIE20:
1540         case R_390_TLS_GOTIE32:
1541         case R_390_TLS_IEENT:
1542         case R_390_GOT12:
1543         case R_390_GOT16:
1544         case R_390_GOT20:
1545         case R_390_GOT32:
1546         case R_390_GOTENT:
1547           if (h != NULL)
1548             {
1549               if (h->got.refcount > 0)
1550                 h->got.refcount -= 1;
1551             }
1552           else if (local_got_refcounts != NULL)
1553             {
1554               if (local_got_refcounts[r_symndx] > 0)
1555                 local_got_refcounts[r_symndx] -= 1;
1556             }
1557           break;
1558
1559         case R_390_8:
1560         case R_390_12:
1561         case R_390_16:
1562         case R_390_20:
1563         case R_390_32:
1564         case R_390_PC16:
1565         case R_390_PC12DBL:
1566         case R_390_PC16DBL:
1567         case R_390_PC24DBL:
1568         case R_390_PC32DBL:
1569         case R_390_PC32:
1570           if (bfd_link_pic (info))
1571             break;
1572           /* Fall through.  */
1573
1574         case R_390_PLT12DBL:
1575         case R_390_PLT16DBL:
1576         case R_390_PLT24DBL:
1577         case R_390_PLT32DBL:
1578         case R_390_PLT32:
1579         case R_390_PLTOFF16:
1580         case R_390_PLTOFF32:
1581           if (h != NULL)
1582             {
1583               if (h->plt.refcount > 0)
1584                 h->plt.refcount -= 1;
1585             }
1586           break;
1587
1588         case R_390_GOTPLT12:
1589         case R_390_GOTPLT16:
1590         case R_390_GOTPLT20:
1591         case R_390_GOTPLT32:
1592         case R_390_GOTPLTENT:
1593           if (h != NULL)
1594             {
1595               if (h->plt.refcount > 0)
1596                 {
1597                   ((struct elf_s390_link_hash_entry *) h)->gotplt_refcount--;
1598                   h->plt.refcount -= 1;
1599                 }
1600             }
1601           else if (local_got_refcounts != NULL)
1602             {
1603               if (local_got_refcounts[r_symndx] > 0)
1604                 local_got_refcounts[r_symndx] -= 1;
1605             }
1606           break;
1607
1608         default:
1609           break;
1610         }
1611     }
1612
1613   return TRUE;
1614 }
1615
1616 /* Make sure we emit a GOT entry if the symbol was supposed to have a PLT
1617    entry but we found we will not create any.  Called when we find we will
1618    not have any PLT for this symbol, by for example
1619    elf_s390_adjust_dynamic_symbol when we're doing a proper dynamic link,
1620    or elf_s390_size_dynamic_sections if no dynamic sections will be
1621    created (we're only linking static objects).  */
1622
1623 static void
1624 elf_s390_adjust_gotplt (struct elf_s390_link_hash_entry *h)
1625 {
1626   if (h->elf.root.type == bfd_link_hash_warning)
1627     h = (struct elf_s390_link_hash_entry *) h->elf.root.u.i.link;
1628
1629   if (h->gotplt_refcount <= 0)
1630     return;
1631
1632   /* We simply add the number of gotplt references to the number
1633    * of got references for this symbol.  */
1634   h->elf.got.refcount += h->gotplt_refcount;
1635   h->gotplt_refcount = -1;
1636 }
1637
1638 /* Adjust a symbol defined by a dynamic object and referenced by a
1639    regular object.  The current definition is in some section of the
1640    dynamic object, but we're not including those sections.  We have to
1641    change the definition to something the rest of the link can
1642    understand.  */
1643
1644 static bfd_boolean
1645 elf_s390_adjust_dynamic_symbol (struct bfd_link_info *info,
1646                                 struct elf_link_hash_entry *h)
1647 {
1648   struct elf_s390_link_hash_table *htab;
1649   asection *s;
1650
1651   /* STT_GNU_IFUNC symbol must go through PLT. */
1652   if (s390_is_ifunc_symbol_p (h))
1653     return TRUE;
1654
1655   /* If this is a function, put it in the procedure linkage table.  We
1656      will fill in the contents of the procedure linkage table later
1657      (although we could actually do it here).  */
1658   if (h->type == STT_FUNC
1659       || h->needs_plt)
1660     {
1661       if (h->plt.refcount <= 0
1662           || SYMBOL_CALLS_LOCAL (info, h)
1663           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1664               && h->root.type != bfd_link_hash_undefweak))
1665         {
1666           /* This case can occur if we saw a PLT32 reloc in an input
1667              file, but the symbol was never referred to by a dynamic
1668              object, or if all references were garbage collected.  In
1669              such a case, we don't actually need to build a procedure
1670              linkage table, and we can just do a PC32 reloc instead.  */
1671           h->plt.offset = (bfd_vma) -1;
1672           h->needs_plt = 0;
1673           elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1674         }
1675
1676       return TRUE;
1677     }
1678   else
1679     /* It's possible that we incorrectly decided a .plt reloc was
1680        needed for an R_390_PC32 reloc to a non-function sym in
1681        check_relocs.  We can't decide accurately between function and
1682        non-function syms in check-relocs;  Objects loaded later in
1683        the link may change h->type.  So fix it now.  */
1684     h->plt.offset = (bfd_vma) -1;
1685
1686   /* If this is a weak symbol, and there is a real definition, the
1687      processor independent code will have arranged for us to see the
1688      real definition first, and we can just use the same value.  */
1689   if (h->u.weakdef != NULL)
1690     {
1691       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1692                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1693       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1694       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1695       if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1696         h->non_got_ref = h->u.weakdef->non_got_ref;
1697       return TRUE;
1698     }
1699
1700   /* This is a reference to a symbol defined by a dynamic object which
1701      is not a function.  */
1702
1703   /* If we are creating a shared library, we must presume that the
1704      only references to the symbol are via the global offset table.
1705      For such cases we need not do anything here; the relocations will
1706      be handled correctly by relocate_section.  */
1707   if (bfd_link_pic (info))
1708     return TRUE;
1709
1710   /* If there are no references to this symbol that do not use the
1711      GOT, we don't need to generate a copy reloc.  */
1712   if (!h->non_got_ref)
1713     return TRUE;
1714
1715   /* If -z nocopyreloc was given, we won't generate them either.  */
1716   if (info->nocopyreloc)
1717     {
1718       h->non_got_ref = 0;
1719       return TRUE;
1720     }
1721
1722   if (ELIMINATE_COPY_RELOCS)
1723     {
1724       struct elf_s390_link_hash_entry * eh;
1725       struct elf_dyn_relocs *p;
1726
1727       eh = (struct elf_s390_link_hash_entry *) h;
1728       for (p = eh->dyn_relocs; p != NULL; p = p->next)
1729         {
1730           s = p->sec->output_section;
1731           if (s != NULL && (s->flags & SEC_READONLY) != 0)
1732             break;
1733         }
1734
1735       /* If we didn't find any dynamic relocs in read-only sections, then
1736          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
1737       if (p == NULL)
1738         {
1739           h->non_got_ref = 0;
1740           return TRUE;
1741         }
1742     }
1743
1744   /* We must allocate the symbol in our .dynbss section, which will
1745      become part of the .bss section of the executable.  There will be
1746      an entry for this symbol in the .dynsym section.  The dynamic
1747      object will contain position independent code, so all references
1748      from the dynamic object to this symbol will go through the global
1749      offset table.  The dynamic linker will use the .dynsym entry to
1750      determine the address it must put in the global offset table, so
1751      both the dynamic object and the regular object will refer to the
1752      same memory location for the variable.  */
1753
1754   htab = elf_s390_hash_table (info);
1755
1756   /* We must generate a R_390_COPY reloc to tell the dynamic linker to
1757      copy the initial value out of the dynamic object and into the
1758      runtime process image.  */
1759   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1760     {
1761       htab->srelbss->size += sizeof (Elf32_External_Rela);
1762       h->needs_copy = 1;
1763     }
1764
1765   s = htab->sdynbss;
1766
1767   return _bfd_elf_adjust_dynamic_copy (info, h, s);
1768 }
1769
1770 /* Allocate space in .plt, .got and associated reloc sections for
1771    dynamic relocs.  */
1772
1773 static bfd_boolean
1774 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1775 {
1776   struct bfd_link_info *info;
1777   struct elf_s390_link_hash_table *htab;
1778   struct elf_s390_link_hash_entry *eh = (struct elf_s390_link_hash_entry *)h;
1779   struct elf_dyn_relocs *p;
1780
1781   if (h->root.type == bfd_link_hash_indirect)
1782     return TRUE;
1783
1784   info = (struct bfd_link_info *) inf;
1785   htab = elf_s390_hash_table (info);
1786
1787   /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
1788      here if it is defined and referenced in a non-shared object.  */
1789   if (s390_is_ifunc_symbol_p (h) && h->def_regular)
1790     return s390_elf_allocate_ifunc_dyn_relocs (info, h,
1791                                                &eh->dyn_relocs);
1792   else if (htab->elf.dynamic_sections_created
1793            && h->plt.refcount > 0)
1794     {
1795       /* Make sure this symbol is output as a dynamic symbol.
1796          Undefined weak syms won't yet be marked as dynamic.  */
1797       if (h->dynindx == -1
1798           && !h->forced_local)
1799         {
1800           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1801             return FALSE;
1802         }
1803
1804       if (bfd_link_pic (info)
1805           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1806         {
1807           asection *s = htab->elf.splt;
1808
1809           /* If this is the first .plt entry, make room for the special
1810              first entry.  */
1811           if (s->size == 0)
1812             s->size += PLT_FIRST_ENTRY_SIZE;
1813
1814           h->plt.offset = s->size;
1815
1816           /* If this symbol is not defined in a regular file, and we are
1817              not generating a shared library, then set the symbol to this
1818              location in the .plt.  This is required to make function
1819              pointers compare as equal between the normal executable and
1820              the shared library.  */
1821           if (! bfd_link_pic (info)
1822               && !h->def_regular)
1823             {
1824               h->root.u.def.section = s;
1825               h->root.u.def.value = h->plt.offset;
1826             }
1827
1828           /* Make room for this entry.  */
1829           s->size += PLT_ENTRY_SIZE;
1830
1831           /* We also need to make an entry in the .got.plt section, which
1832              will be placed in the .got section by the linker script.  */
1833           htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
1834
1835           /* We also need to make an entry in the .rela.plt section.  */
1836           htab->elf.srelplt->size += sizeof (Elf32_External_Rela);
1837         }
1838       else
1839         {
1840           h->plt.offset = (bfd_vma) -1;
1841           h->needs_plt = 0;
1842           elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1843         }
1844     }
1845   else
1846     {
1847       h->plt.offset = (bfd_vma) -1;
1848       h->needs_plt = 0;
1849       elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1850     }
1851
1852   /* If R_390_TLS_{IE32,GOTIE32,GOTIE12,IEENT} symbol is now local to
1853      the binary, we can optimize a bit. IE32 and GOTIE32 get converted
1854      to R_390_TLS_LE32 requiring no TLS entry. For GOTIE12 and IEENT
1855      we can save the dynamic TLS relocation.  */
1856   if (h->got.refcount > 0
1857       && !bfd_link_pic (info)
1858       && h->dynindx == -1
1859       && elf_s390_hash_entry(h)->tls_type >= GOT_TLS_IE)
1860     {
1861       if (elf_s390_hash_entry(h)->tls_type == GOT_TLS_IE_NLT)
1862         /* For the GOTIE access without a literal pool entry the offset has
1863            to be stored somewhere. The immediate value in the instruction
1864            is not bit enough so the value is stored in the got.  */
1865         {
1866           h->got.offset = htab->elf.sgot->size;
1867           htab->elf.sgot->size += GOT_ENTRY_SIZE;
1868         }
1869       else
1870         h->got.offset = (bfd_vma) -1;
1871     }
1872   else if (h->got.refcount > 0)
1873    {
1874       asection *s;
1875       bfd_boolean dyn;
1876       int tls_type = elf_s390_hash_entry(h)->tls_type;
1877
1878       /* Make sure this symbol is output as a dynamic symbol.
1879          Undefined weak syms won't yet be marked as dynamic.  */
1880       if (h->dynindx == -1
1881           && !h->forced_local)
1882         {
1883           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1884             return FALSE;
1885         }
1886
1887       s = htab->elf.sgot;
1888       h->got.offset = s->size;
1889       s->size += GOT_ENTRY_SIZE;
1890       /* R_390_TLS_GD32 needs 2 consecutive GOT slots.  */
1891       if (tls_type == GOT_TLS_GD)
1892         s->size += GOT_ENTRY_SIZE;
1893       dyn = htab->elf.dynamic_sections_created;
1894       /* R_390_TLS_IE32 needs one dynamic relocation,
1895          R_390_TLS_GD32 needs one if local symbol and two if global.  */
1896       if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1897           || tls_type >= GOT_TLS_IE)
1898         htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
1899       else if (tls_type == GOT_TLS_GD)
1900         htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rela);
1901       else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1902                 || h->root.type != bfd_link_hash_undefweak)
1903                && (bfd_link_pic (info)
1904                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1905         htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
1906     }
1907   else
1908     h->got.offset = (bfd_vma) -1;
1909
1910   if (eh->dyn_relocs == NULL)
1911     return TRUE;
1912
1913   /* In the shared -Bsymbolic case, discard space allocated for
1914      dynamic pc-relative relocs against symbols which turn out to be
1915      defined in regular objects.  For the normal shared case, discard
1916      space for pc-relative relocs that have become local due to symbol
1917      visibility changes.  */
1918
1919   if (bfd_link_pic (info))
1920     {
1921       if (SYMBOL_CALLS_LOCAL (info, h))
1922         {
1923           struct elf_dyn_relocs **pp;
1924
1925           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1926             {
1927               p->count -= p->pc_count;
1928               p->pc_count = 0;
1929               if (p->count == 0)
1930                 *pp = p->next;
1931               else
1932                 pp = &p->next;
1933             }
1934         }
1935
1936       /* Also discard relocs on undefined weak syms with non-default
1937          visibility.  */
1938       if (eh->dyn_relocs != NULL
1939           && h->root.type == bfd_link_hash_undefweak)
1940         {
1941           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1942             eh->dyn_relocs = NULL;
1943
1944           /* Make sure undefined weak symbols are output as a dynamic
1945              symbol in PIEs.  */
1946           else if (h->dynindx == -1
1947                    && !h->forced_local)
1948             {
1949               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1950                 return FALSE;
1951             }
1952         }
1953     }
1954   else if (ELIMINATE_COPY_RELOCS)
1955     {
1956       /* For the non-shared case, discard space for relocs against
1957          symbols which turn out to need copy relocs or are not
1958          dynamic.  */
1959
1960       if (!h->non_got_ref
1961           && ((h->def_dynamic
1962                && !h->def_regular)
1963               || (htab->elf.dynamic_sections_created
1964                   && (h->root.type == bfd_link_hash_undefweak
1965                       || h->root.type == bfd_link_hash_undefined))))
1966         {
1967           /* Make sure this symbol is output as a dynamic symbol.
1968              Undefined weak syms won't yet be marked as dynamic.  */
1969           if (h->dynindx == -1
1970               && !h->forced_local)
1971             {
1972               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1973                 return FALSE;
1974             }
1975
1976           /* If that succeeded, we know we'll be keeping all the
1977              relocs.  */
1978           if (h->dynindx != -1)
1979             goto keep;
1980         }
1981
1982       eh->dyn_relocs = NULL;
1983
1984     keep: ;
1985     }
1986
1987   /* Finally, allocate space.  */
1988   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1989     {
1990       asection *sreloc = elf_section_data (p->sec)->sreloc;
1991
1992       sreloc->size += p->count * sizeof (Elf32_External_Rela);
1993     }
1994
1995   return TRUE;
1996 }
1997
1998 /* Find any dynamic relocs that apply to read-only sections.  */
1999
2000 static bfd_boolean
2001 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2002 {
2003   struct elf_s390_link_hash_entry *eh;
2004   struct elf_dyn_relocs *p;
2005
2006   eh = (struct elf_s390_link_hash_entry *) h;
2007   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2008     {
2009       asection *s = p->sec->output_section;
2010
2011       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2012         {
2013           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2014
2015           info->flags |= DF_TEXTREL;
2016
2017           /* Not an error, just cut short the traversal.  */
2018           return FALSE;
2019         }
2020     }
2021   return TRUE;
2022 }
2023
2024 /* Set the sizes of the dynamic sections.  */
2025
2026 static bfd_boolean
2027 elf_s390_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2028                                 struct bfd_link_info *info)
2029 {
2030   struct elf_s390_link_hash_table *htab;
2031   bfd *dynobj;
2032   asection *s;
2033   bfd_boolean relocs;
2034   bfd *ibfd;
2035
2036   htab = elf_s390_hash_table (info);
2037   dynobj = htab->elf.dynobj;
2038   if (dynobj == NULL)
2039     abort ();
2040
2041   if (htab->elf.dynamic_sections_created)
2042     {
2043       /* Set the contents of the .interp section to the interpreter.  */
2044       if (bfd_link_executable (info) && !info->nointerp)
2045         {
2046           s = bfd_get_linker_section (dynobj, ".interp");
2047           if (s == NULL)
2048             abort ();
2049           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2050           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2051         }
2052     }
2053
2054   /* Set up .got offsets for local syms, and space for local dynamic
2055      relocs.  */
2056   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2057     {
2058       bfd_signed_vma *local_got;
2059       bfd_signed_vma *end_local_got;
2060       char *local_tls_type;
2061       bfd_size_type locsymcount;
2062       Elf_Internal_Shdr *symtab_hdr;
2063       asection *srela;
2064       struct plt_entry *local_plt;
2065       unsigned int i;
2066
2067       if (! is_s390_elf (ibfd))
2068         continue;
2069
2070       for (s = ibfd->sections; s != NULL; s = s->next)
2071         {
2072           struct elf_dyn_relocs *p;
2073
2074           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
2075             {
2076               if (!bfd_is_abs_section (p->sec)
2077                   && bfd_is_abs_section (p->sec->output_section))
2078                 {
2079                   /* Input section has been discarded, either because
2080                      it is a copy of a linkonce section or due to
2081                      linker script /DISCARD/, so we'll be discarding
2082                      the relocs too.  */
2083                 }
2084               else if (p->count != 0)
2085                 {
2086                   srela = elf_section_data (p->sec)->sreloc;
2087                   srela->size += p->count * sizeof (Elf32_External_Rela);
2088                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2089                     info->flags |= DF_TEXTREL;
2090                 }
2091             }
2092         }
2093
2094       local_got = elf_local_got_refcounts (ibfd);
2095       if (!local_got)
2096         continue;
2097
2098       symtab_hdr = &elf_symtab_hdr (ibfd);
2099       locsymcount = symtab_hdr->sh_info;
2100       end_local_got = local_got + locsymcount;
2101       local_tls_type = elf_s390_local_got_tls_type (ibfd);
2102       s = htab->elf.sgot;
2103       srela = htab->elf.srelgot;
2104       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2105         {
2106           if (*local_got > 0)
2107             {
2108               *local_got = s->size;
2109               s->size += GOT_ENTRY_SIZE;
2110               if (*local_tls_type == GOT_TLS_GD)
2111                 s->size += GOT_ENTRY_SIZE;
2112               if (bfd_link_pic (info))
2113                 srela->size += sizeof (Elf32_External_Rela);
2114             }
2115           else
2116             *local_got = (bfd_vma) -1;
2117         }
2118       local_plt = elf_s390_local_plt (ibfd);
2119       for (i = 0; i < symtab_hdr->sh_info; i++)
2120         {
2121           if (local_plt[i].plt.refcount > 0)
2122             {
2123               local_plt[i].plt.offset = htab->elf.iplt->size;
2124               htab->elf.iplt->size += PLT_ENTRY_SIZE;
2125               htab->elf.igotplt->size += GOT_ENTRY_SIZE;
2126               htab->elf.irelplt->size += RELA_ENTRY_SIZE;
2127             }
2128           else
2129             local_plt[i].plt.offset = (bfd_vma) -1;
2130         }
2131     }
2132
2133   if (htab->tls_ldm_got.refcount > 0)
2134     {
2135       /* Allocate 2 got entries and 1 dynamic reloc for R_390_TLS_LDM32
2136          relocs.  */
2137       htab->tls_ldm_got.offset = htab->elf.sgot->size;
2138       htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
2139       htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
2140     }
2141   else
2142     htab->tls_ldm_got.offset = -1;
2143
2144   /* Allocate global sym .plt and .got entries, and space for global
2145      sym dynamic relocs.  */
2146   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
2147
2148   /* We now have determined the sizes of the various dynamic sections.
2149      Allocate memory for them.  */
2150   relocs = FALSE;
2151   for (s = dynobj->sections; s != NULL; s = s->next)
2152     {
2153       if ((s->flags & SEC_LINKER_CREATED) == 0)
2154         continue;
2155
2156       if (s == htab->elf.splt
2157           || s == htab->elf.sgot
2158           || s == htab->elf.sgotplt
2159           || s == htab->sdynbss
2160           || s == htab->elf.iplt
2161           || s == htab->elf.igotplt
2162           || s == htab->irelifunc)
2163         {
2164           /* Strip this section if we don't need it; see the
2165              comment below.  */
2166         }
2167       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2168         {
2169           if (s->size != 0)
2170             relocs = TRUE;
2171
2172           /* We use the reloc_count field as a counter if we need
2173              to copy relocs into the output file.  */
2174           s->reloc_count = 0;
2175         }
2176       else
2177         {
2178           /* It's not one of our sections, so don't allocate space.  */
2179           continue;
2180         }
2181
2182       if (s->size == 0)
2183         {
2184           /* If we don't need this section, strip it from the
2185              output file.  This is to handle .rela.bss and
2186              .rela.plt.  We must create it in
2187              create_dynamic_sections, because it must be created
2188              before the linker maps input sections to output
2189              sections.  The linker does that before
2190              adjust_dynamic_symbol is called, and it is that
2191              function which decides whether anything needs to go
2192              into these sections.  */
2193
2194           s->flags |= SEC_EXCLUDE;
2195           continue;
2196         }
2197
2198       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2199         continue;
2200
2201       /* Allocate memory for the section contents.  We use bfd_zalloc
2202          here in case unused entries are not reclaimed before the
2203          section's contents are written out.  This should not happen,
2204          but this way if it does, we get a R_390_NONE reloc instead
2205          of garbage.  */
2206       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2207       if (s->contents == NULL)
2208         return FALSE;
2209     }
2210
2211   if (htab->elf.dynamic_sections_created)
2212     {
2213       /* Add some entries to the .dynamic section.  We fill in the
2214          values later, in elf_s390_finish_dynamic_sections, but we
2215          must add the entries now so that we get the correct size for
2216          the .dynamic section.  The DT_DEBUG entry is filled in by the
2217          dynamic linker and used by the debugger.  */
2218 #define add_dynamic_entry(TAG, VAL) \
2219   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2220
2221       if (bfd_link_executable (info))
2222         {
2223           if (!add_dynamic_entry (DT_DEBUG, 0))
2224             return FALSE;
2225         }
2226
2227       if (htab->elf.splt->size != 0)
2228         {
2229           if (!add_dynamic_entry (DT_PLTGOT, 0)
2230               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2231               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2232               || !add_dynamic_entry (DT_JMPREL, 0))
2233             return FALSE;
2234         }
2235
2236       if (relocs)
2237         {
2238           if (!add_dynamic_entry (DT_RELA, 0)
2239               || !add_dynamic_entry (DT_RELASZ, 0)
2240               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
2241             return FALSE;
2242
2243           /* If any dynamic relocs apply to a read-only section,
2244              then we need a DT_TEXTREL entry.  */
2245           if ((info->flags & DF_TEXTREL) == 0)
2246             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
2247
2248           if ((info->flags & DF_TEXTREL) != 0)
2249             {
2250               if (!add_dynamic_entry (DT_TEXTREL, 0))
2251                 return FALSE;
2252             }
2253         }
2254     }
2255 #undef add_dynamic_entry
2256
2257   return TRUE;
2258 }
2259
2260 /* Return the base VMA address which should be subtracted from real addresses
2261    when resolving @dtpoff relocation.
2262    This is PT_TLS segment p_vaddr.  */
2263
2264 static bfd_vma
2265 dtpoff_base (struct bfd_link_info *info)
2266 {
2267   /* If tls_sec is NULL, we should have signalled an error already.  */
2268   if (elf_hash_table (info)->tls_sec == NULL)
2269     return 0;
2270   return elf_hash_table (info)->tls_sec->vma;
2271 }
2272
2273 /* Return the relocation value for @tpoff relocation
2274    if STT_TLS virtual address is ADDRESS.  */
2275
2276 static bfd_vma
2277 tpoff (struct bfd_link_info *info, bfd_vma address)
2278 {
2279   struct elf_link_hash_table *htab = elf_hash_table (info);
2280
2281   /* If tls_sec is NULL, we should have signalled an error already.  */
2282   if (htab->tls_sec == NULL)
2283     return 0;
2284   return htab->tls_size + htab->tls_sec->vma - address;
2285 }
2286
2287 /* Complain if TLS instruction relocation is against an invalid
2288    instruction.  */
2289
2290 static void
2291 invalid_tls_insn (bfd *input_bfd,
2292                   asection *input_section,
2293                   Elf_Internal_Rela *rel)
2294 {
2295   reloc_howto_type *howto;
2296
2297   howto = elf_howto_table + ELF32_R_TYPE (rel->r_info);
2298   (*_bfd_error_handler)
2299     (_("%B(%A+0x%lx): invalid instruction for TLS relocation %s"),
2300      input_bfd,
2301      input_section,
2302      (long) rel->r_offset,
2303      howto->name);
2304   bfd_set_error (bfd_error_bad_value);
2305 }
2306
2307 /* Relocate a 390 ELF section.  */
2308
2309 static bfd_boolean
2310 elf_s390_relocate_section (bfd *output_bfd,
2311                            struct bfd_link_info *info,
2312                            bfd *input_bfd,
2313                            asection *input_section,
2314                            bfd_byte *contents,
2315                            Elf_Internal_Rela *relocs,
2316                            Elf_Internal_Sym *local_syms,
2317                            asection **local_sections)
2318 {
2319   struct elf_s390_link_hash_table *htab;
2320   Elf_Internal_Shdr *symtab_hdr;
2321   struct elf_link_hash_entry **sym_hashes;
2322   bfd_vma *local_got_offsets;
2323   Elf_Internal_Rela *rel;
2324   Elf_Internal_Rela *relend;
2325
2326   BFD_ASSERT (is_s390_elf (input_bfd));
2327
2328   htab = elf_s390_hash_table (info);
2329   symtab_hdr = &elf_symtab_hdr (input_bfd);
2330   sym_hashes = elf_sym_hashes (input_bfd);
2331   local_got_offsets = elf_local_got_offsets (input_bfd);
2332
2333   rel = relocs;
2334   relend = relocs + input_section->reloc_count;
2335   for (; rel < relend; rel++)
2336     {
2337       unsigned int r_type;
2338       reloc_howto_type *howto;
2339       unsigned long r_symndx;
2340       struct elf_link_hash_entry *h;
2341       Elf_Internal_Sym *sym;
2342       asection *sec;
2343       bfd_vma off;
2344       bfd_vma relocation;
2345       bfd_boolean unresolved_reloc;
2346       bfd_reloc_status_type r;
2347       int tls_type;
2348       asection *base_got = htab->elf.sgot;
2349
2350       r_type = ELF32_R_TYPE (rel->r_info);
2351       if (r_type == (int) R_390_GNU_VTINHERIT
2352           || r_type == (int) R_390_GNU_VTENTRY)
2353         continue;
2354       if (r_type >= (int) R_390_max)
2355         {
2356           bfd_set_error (bfd_error_bad_value);
2357           return FALSE;
2358         }
2359
2360       howto = elf_howto_table + r_type;
2361       r_symndx = ELF32_R_SYM (rel->r_info);
2362
2363       h = NULL;
2364       sym = NULL;
2365       sec = NULL;
2366       unresolved_reloc = FALSE;
2367       if (r_symndx < symtab_hdr->sh_info)
2368         {
2369           sym = local_syms + r_symndx;
2370           sec = local_sections[r_symndx];
2371           if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
2372             {
2373               struct plt_entry *local_plt = elf_s390_local_plt (input_bfd);
2374               if (local_plt == NULL)
2375                 return FALSE;
2376
2377               /* Address of the PLT slot.  */
2378               relocation = (htab->elf.iplt->output_section->vma
2379                             + htab->elf.iplt->output_offset
2380                             + local_plt[r_symndx].plt.offset);
2381
2382               switch (r_type)
2383                 {
2384                 case R_390_PLTOFF16:
2385                 case R_390_PLTOFF32:
2386                   relocation -= htab->elf.sgot->output_section->vma;
2387                   break;
2388                 case R_390_GOTPLT12:
2389                 case R_390_GOTPLT16:
2390                 case R_390_GOTPLT20:
2391                 case R_390_GOTPLT32:
2392                 case R_390_GOTPLTENT:
2393                 case R_390_GOT12:
2394                 case R_390_GOT16:
2395                 case R_390_GOT20:
2396                 case R_390_GOT32:
2397                 case R_390_GOTENT:
2398                   {
2399                     /* Write the PLT slot address into the GOT slot.  */
2400                     bfd_put_32 (output_bfd, relocation,
2401                                 htab->elf.sgot->contents +
2402                                 local_got_offsets[r_symndx]);
2403                     relocation = (local_got_offsets[r_symndx] +
2404                                   htab->elf.sgot->output_offset);
2405
2406                     if (r_type == R_390_GOTENT || r_type == R_390_GOTPLTENT)
2407                       relocation += htab->elf.sgot->output_section->vma;
2408                     break;
2409                   }
2410                 default:
2411                   break;
2412                 }
2413               /* The output section is needed later in
2414                  finish_dynamic_section when creating the dynamic
2415                  relocation.  */
2416               local_plt[r_symndx].sec = sec;
2417               goto do_relocation;
2418             }
2419           else
2420             relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2421         }
2422       else
2423         {
2424           bfd_boolean warned ATTRIBUTE_UNUSED;
2425           bfd_boolean ignored ATTRIBUTE_UNUSED;
2426
2427           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2428                                    r_symndx, symtab_hdr, sym_hashes,
2429                                    h, sec, relocation,
2430                                    unresolved_reloc, warned, ignored);
2431         }
2432
2433       if (sec != NULL && discarded_section (sec))
2434         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2435                                          rel, 1, relend, howto, 0, contents);
2436
2437       if (bfd_link_relocatable (info))
2438         continue;
2439
2440       switch (r_type)
2441         {
2442         case R_390_GOTPLT12:
2443         case R_390_GOTPLT16:
2444         case R_390_GOTPLT20:
2445         case R_390_GOTPLT32:
2446         case R_390_GOTPLTENT:
2447           /* There are three cases for a GOTPLT relocation. 1) The
2448              relocation is against the jump slot entry of a plt that
2449              will get emitted to the output file. 2) The relocation
2450              is against the jump slot of a plt entry that has been
2451              removed. elf_s390_adjust_gotplt has created a GOT entry
2452              as replacement. 3) The relocation is against a local symbol.
2453              Cases 2) and 3) are the same as the GOT relocation code
2454              so we just have to test for case 1 and fall through for
2455              the other two.  */
2456           if (h != NULL && h->plt.offset != (bfd_vma) -1)
2457             {
2458               bfd_vma plt_index;
2459
2460               if (s390_is_ifunc_symbol_p (h))
2461                 {
2462                   plt_index = h->plt.offset / PLT_ENTRY_SIZE;
2463                   relocation = (plt_index * GOT_ENTRY_SIZE +
2464                                 htab->elf.igotplt->output_offset);
2465                   if (r_type == R_390_GOTPLTENT)
2466                     relocation += htab->elf.igotplt->output_section->vma;
2467                 }
2468               else
2469                 {
2470                   /* Calc. index no.
2471                      Current offset - size first entry / entry size.  */
2472                   plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) /
2473                     PLT_ENTRY_SIZE;
2474
2475                   /* Offset in GOT is PLT index plus GOT headers(3)
2476                      times 4, addr & GOT addr.  */
2477                   relocation = (plt_index + 3) * GOT_ENTRY_SIZE;
2478                   if (r_type == R_390_GOTPLTENT)
2479                     relocation += htab->elf.sgot->output_section->vma;
2480                 }
2481               unresolved_reloc = FALSE;
2482
2483             }
2484           /* Fall through.  */
2485
2486         case R_390_GOT12:
2487         case R_390_GOT16:
2488         case R_390_GOT20:
2489         case R_390_GOT32:
2490         case R_390_GOTENT:
2491           /* Relocation is to the entry for this symbol in the global
2492              offset table.  */
2493           if (base_got == NULL)
2494             abort ();
2495
2496           if (h != NULL)
2497             {
2498               bfd_boolean dyn;
2499
2500               off = h->got.offset;
2501               dyn = htab->elf.dynamic_sections_created;
2502
2503               if (s390_is_ifunc_symbol_p (h))
2504                 {
2505                   BFD_ASSERT (h->plt.offset != (bfd_vma) -1);
2506                   if (off == (bfd_vma)-1)
2507                     {
2508                       /* No explicit GOT usage so redirect to the
2509                          got.iplt slot.  */
2510                       base_got = htab->elf.igotplt;
2511                       off = h->plt.offset / PLT_ENTRY_SIZE * GOT_ENTRY_SIZE;
2512                     }
2513                   else
2514                     {
2515                       /* Explicit GOT slots must contain the address
2516                          of the PLT slot. This will be handled in
2517                          finish_dynamic_symbol.  */
2518                     }
2519                 }
2520               else if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
2521                                                           bfd_link_pic (info),
2522                                                           h)
2523                        || (bfd_link_pic (info)
2524                            && SYMBOL_REFERENCES_LOCAL (info, h))
2525                        || (ELF_ST_VISIBILITY (h->other)
2526                            && h->root.type == bfd_link_hash_undefweak))
2527
2528                 {
2529                   /* This is actually a static link, or it is a
2530                      -Bsymbolic link and the symbol is defined
2531                      locally, or the symbol was forced to be local
2532                      because of a version file.  We must initialize
2533                      this entry in the global offset table.  Since the
2534                      offset must always be a multiple of 2, we use the
2535                      least significant bit to record whether we have
2536                      initialized it already.
2537
2538                      When doing a dynamic link, we create a .rel.got
2539                      relocation entry to initialize the value.  This
2540                      is done in the finish_dynamic_symbol routine.  */
2541                   if ((off & 1) != 0)
2542                     off &= ~1;
2543                   else
2544                     {
2545                       bfd_put_32 (output_bfd, relocation,
2546                                   base_got->contents + off);
2547                       h->got.offset |= 1;
2548                     }
2549
2550                   if ((h->def_regular
2551                        && bfd_link_pic (info)
2552                        && SYMBOL_REFERENCES_LOCAL (info, h))
2553                       /* lrl rx,sym@GOTENT -> larl rx, sym */
2554                       && ((r_type == R_390_GOTENT
2555                            && (bfd_get_16 (input_bfd,
2556                                            contents + rel->r_offset - 2)
2557                                & 0xff0f) == 0xc40d)
2558                           /* ly rx, sym@GOT(r12) -> larl rx, sym */
2559                           || (r_type == R_390_GOT20
2560                               && (bfd_get_32 (input_bfd,
2561                                               contents + rel->r_offset - 2)
2562                                   & 0xff00f000) == 0xe300c000
2563                               && bfd_get_8 (input_bfd,
2564                                             contents + rel->r_offset + 3) == 0x58)))
2565                     {
2566                       unsigned short new_insn =
2567                         (0xc000 | (bfd_get_8 (input_bfd,
2568                                               contents + rel->r_offset - 1) & 0xf0));
2569                       bfd_put_16 (output_bfd, new_insn,
2570                                   contents + rel->r_offset - 2);
2571                       r_type = R_390_PC32DBL;
2572                       rel->r_addend = 2;
2573                       howto = elf_howto_table + r_type;
2574                       relocation = h->root.u.def.value
2575                         + h->root.u.def.section->output_section->vma
2576                         + h->root.u.def.section->output_offset;
2577                       goto do_relocation;
2578                     }
2579                 }
2580               else
2581                 unresolved_reloc = FALSE;
2582             }
2583           else
2584             {
2585               if (local_got_offsets == NULL)
2586                 abort ();
2587
2588               off = local_got_offsets[r_symndx];
2589
2590               /* The offset must always be a multiple of 4.  We use
2591                  the least significant bit to record whether we have
2592                  already generated the necessary reloc.  */
2593               if ((off & 1) != 0)
2594                 off &= ~1;
2595               else
2596                 {
2597                   bfd_put_32 (output_bfd, relocation,
2598                               htab->elf.sgot->contents + off);
2599
2600                   if (bfd_link_pic (info))
2601                     {
2602                       asection *srelgot;
2603                       Elf_Internal_Rela outrel;
2604                       bfd_byte *loc;
2605
2606                       srelgot = htab->elf.srelgot;
2607                       if (srelgot == NULL)
2608                         abort ();
2609
2610                       outrel.r_offset = (htab->elf.sgot->output_section->vma
2611                                          + htab->elf.sgot->output_offset
2612                                          + off);
2613                       outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2614                       outrel.r_addend = relocation;
2615                       loc = srelgot->contents;
2616                       loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
2617                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2618                     }
2619
2620                   local_got_offsets[r_symndx] |= 1;
2621                 }
2622             }
2623
2624           if (off >= (bfd_vma) -2)
2625             abort ();
2626
2627           relocation = base_got->output_offset + off;
2628
2629           /* For @GOTENT the relocation is against the offset between
2630              the instruction and the symbols entry in the GOT and not
2631              between the start of the GOT and the symbols entry. We
2632              add the vma of the GOT to get the correct value.  */
2633           if (   r_type == R_390_GOTENT
2634               || r_type == R_390_GOTPLTENT)
2635             relocation += base_got->output_section->vma;
2636
2637           break;
2638
2639         case R_390_GOTOFF16:
2640         case R_390_GOTOFF32:
2641           /* Relocation is relative to the start of the global offset
2642              table.  */
2643
2644           /* Note that sgot->output_offset is not involved in this
2645              calculation.  We always want the start of .got.  If we
2646              defined _GLOBAL_OFFSET_TABLE in a different way, as is
2647              permitted by the ABI, we might have to change this
2648              calculation.  */
2649           relocation -= htab->elf.sgot->output_section->vma;
2650           break;
2651
2652         case R_390_GOTPC:
2653         case R_390_GOTPCDBL:
2654           /* Use global offset table as symbol value.  */
2655           relocation = htab->elf.sgot->output_section->vma;
2656           unresolved_reloc = FALSE;
2657           break;
2658
2659         case R_390_PLT12DBL:
2660         case R_390_PLT16DBL:
2661         case R_390_PLT24DBL:
2662         case R_390_PLT32DBL:
2663         case R_390_PLT32:
2664           /* Relocation is to the entry for this symbol in the
2665              procedure linkage table.  */
2666
2667           /* Resolve a PLT32 reloc against a local symbol directly,
2668              without using the procedure linkage table.  */
2669           if (h == NULL)
2670             break;
2671
2672           if (h->plt.offset == (bfd_vma) -1
2673               || (htab->elf.splt == NULL && htab->elf.iplt == NULL))
2674             {
2675               /* We didn't make a PLT entry for this symbol.  This
2676                  happens when statically linking PIC code, or when
2677                  using -Bsymbolic.  */
2678               break;
2679             }
2680
2681           if (s390_is_ifunc_symbol_p (h))
2682             relocation = (htab->elf.iplt->output_section->vma
2683                           + htab->elf.iplt->output_offset
2684                           + h->plt.offset);
2685           else
2686             relocation = (htab->elf.splt->output_section->vma
2687                           + htab->elf.splt->output_offset
2688                           + h->plt.offset);
2689           unresolved_reloc = FALSE;
2690           break;
2691
2692         case R_390_PLTOFF16:
2693         case R_390_PLTOFF32:
2694           /* Relocation is to the entry for this symbol in the
2695              procedure linkage table relative to the start of the GOT.  */
2696
2697           /* For local symbols or if we didn't make a PLT entry for
2698              this symbol resolve the symbol directly.  */
2699           if (h == NULL
2700               || h->plt.offset == (bfd_vma) -1
2701               || (htab->elf.splt == NULL && !s390_is_ifunc_symbol_p (h)))
2702             {
2703               relocation -= htab->elf.sgot->output_section->vma;
2704               break;
2705             }
2706
2707           if (s390_is_ifunc_symbol_p (h))
2708             relocation = (htab->elf.iplt->output_section->vma
2709                           + htab->elf.iplt->output_offset
2710                           + h->plt.offset
2711                           - htab->elf.sgot->output_section->vma);
2712           else
2713             relocation = (htab->elf.splt->output_section->vma
2714                           + htab->elf.splt->output_offset
2715                           + h->plt.offset
2716                           - htab->elf.sgot->output_section->vma);
2717           unresolved_reloc = FALSE;
2718           break;
2719
2720         case R_390_8:
2721         case R_390_16:
2722         case R_390_32:
2723         case R_390_PC16:
2724         case R_390_PC12DBL:
2725         case R_390_PC16DBL:
2726         case R_390_PC24DBL:
2727         case R_390_PC32DBL:
2728         case R_390_PC32:
2729           if (h != NULL
2730               && s390_is_ifunc_symbol_p (h)
2731               && h->def_regular)
2732             {
2733               if (!bfd_link_pic (info) || !h->non_got_ref)
2734                 {
2735                   /* For a non-shared object STT_GNU_IFUNC symbol must
2736                      go through PLT.  */
2737                   relocation = (htab->elf.iplt->output_section->vma
2738                                 + htab->elf.iplt->output_offset
2739                                 + h ->plt.offset);
2740                   goto do_relocation;
2741                 }
2742               else
2743                 {
2744                   /* For shared objects a runtime relocation is needed.  */
2745
2746                   Elf_Internal_Rela outrel;
2747                   asection *sreloc;
2748
2749                   /* Need a dynamic relocation to get the real function
2750                      address.  */
2751                   outrel.r_offset = _bfd_elf_section_offset (output_bfd,
2752                                                              info,
2753                                                              input_section,
2754                                                              rel->r_offset);
2755                   if (outrel.r_offset == (bfd_vma) -1
2756                       || outrel.r_offset == (bfd_vma) -2)
2757                     abort ();
2758
2759                   outrel.r_offset += (input_section->output_section->vma
2760                                       + input_section->output_offset);
2761
2762                   if (h->dynindx == -1
2763                       || h->forced_local
2764                       || bfd_link_executable (info))
2765                     {
2766                       /* This symbol is resolved locally.  */
2767                       outrel.r_info = ELF32_R_INFO (0, R_390_IRELATIVE);
2768                       outrel.r_addend = (h->root.u.def.value
2769                                          + h->root.u.def.section->output_section->vma
2770                                          + h->root.u.def.section->output_offset);
2771                     }
2772                   else
2773                     {
2774                       outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2775                       outrel.r_addend = 0;
2776                     }
2777
2778                   sreloc = htab->elf.irelifunc;
2779                   elf_append_rela (output_bfd, sreloc, &outrel);
2780
2781                   /* If this reloc is against an external symbol, we
2782                      do not want to fiddle with the addend.  Otherwise,
2783                      we need to include the symbol value so that it
2784                      becomes an addend for the dynamic reloc.  For an
2785                      internal symbol, we have updated addend.  */
2786                   continue;
2787                 }
2788             }
2789
2790           if ((input_section->flags & SEC_ALLOC) == 0)
2791             break;
2792
2793           if ((bfd_link_pic (info)
2794                && (h == NULL
2795                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2796                    || h->root.type != bfd_link_hash_undefweak)
2797                && ((r_type != R_390_PC16
2798                     && r_type != R_390_PC12DBL
2799                     && r_type != R_390_PC16DBL
2800                     && r_type != R_390_PC24DBL
2801                     && r_type != R_390_PC32DBL
2802                     && r_type != R_390_PC32)
2803                    || !SYMBOL_CALLS_LOCAL (info, h)))
2804               || (ELIMINATE_COPY_RELOCS
2805                   && !bfd_link_pic (info)
2806                   && h != NULL
2807                   && h->dynindx != -1
2808                   && !h->non_got_ref
2809                   && ((h->def_dynamic
2810                        && !h->def_regular)
2811                       || h->root.type == bfd_link_hash_undefweak
2812                       || h->root.type == bfd_link_hash_undefined)))
2813             {
2814               Elf_Internal_Rela outrel;
2815               bfd_boolean skip, relocate;
2816               asection *sreloc;
2817               bfd_byte *loc;
2818
2819               /* When generating a shared object, these relocations
2820                  are copied into the output file to be resolved at run
2821                  time.  */
2822
2823               skip = FALSE;
2824               relocate = FALSE;
2825
2826               outrel.r_offset =
2827                 _bfd_elf_section_offset (output_bfd, info, input_section,
2828                                          rel->r_offset);
2829               if (outrel.r_offset == (bfd_vma) -1)
2830                 skip = TRUE;
2831               else if (outrel.r_offset == (bfd_vma) -2)
2832                 skip = TRUE, relocate = TRUE;
2833               outrel.r_offset += (input_section->output_section->vma
2834                                   + input_section->output_offset);
2835
2836               if (skip)
2837                 memset (&outrel, 0, sizeof outrel);
2838               else if (h != NULL
2839                        && h->dynindx != -1
2840                        && (r_type == R_390_PC16
2841                            || r_type == R_390_PC12DBL
2842                            || r_type == R_390_PC16DBL
2843                            || r_type == R_390_PC24DBL
2844                            || r_type == R_390_PC32DBL
2845                            || r_type == R_390_PC32
2846                            || !bfd_link_pic (info)
2847                            || !SYMBOLIC_BIND (info, h)
2848                            || !h->def_regular))
2849                 {
2850                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2851                   outrel.r_addend = rel->r_addend;
2852                 }
2853               else
2854                 {
2855                   /* This symbol is local, or marked to become local.  */
2856                   outrel.r_addend = relocation + rel->r_addend;
2857                   if (r_type == R_390_32)
2858                     {
2859                       relocate = TRUE;
2860                       outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2861                     }
2862                   else
2863                     {
2864                       long sindx;
2865
2866                       if (bfd_is_abs_section (sec))
2867                         sindx = 0;
2868                       else if (sec == NULL || sec->owner == NULL)
2869                         {
2870                           bfd_set_error(bfd_error_bad_value);
2871                           return FALSE;
2872                         }
2873                       else
2874                         {
2875                           asection *osec;
2876
2877                           osec = sec->output_section;
2878                           sindx = elf_section_data (osec)->dynindx;
2879                           if (sindx == 0)
2880                             {
2881                               osec = htab->elf.text_index_section;
2882                               sindx = elf_section_data (osec)->dynindx;
2883                             }
2884                           BFD_ASSERT (sindx != 0);
2885
2886                           /* We are turning this relocation into one
2887                              against a section symbol, so subtract out
2888                              the output section's address but not the
2889                              offset of the input section in the output
2890                              section.  */
2891                           outrel.r_addend -= osec->vma;
2892                         }
2893                       outrel.r_info = ELF32_R_INFO (sindx, r_type);
2894                     }
2895                 }
2896
2897               sreloc = elf_section_data (input_section)->sreloc;
2898               if (sreloc == NULL)
2899                 abort ();
2900
2901               loc = sreloc->contents;
2902               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2903               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2904
2905               /* If this reloc is against an external symbol, we do
2906                  not want to fiddle with the addend.  Otherwise, we
2907                  need to include the symbol value so that it becomes
2908                  an addend for the dynamic reloc.  */
2909               if (! relocate)
2910                 continue;
2911             }
2912           break;
2913
2914           /* Relocations for tls literal pool entries.  */
2915         case R_390_TLS_IE32:
2916           if (bfd_link_pic (info))
2917             {
2918               Elf_Internal_Rela outrel;
2919               asection *sreloc;
2920               bfd_byte *loc;
2921
2922               outrel.r_offset = rel->r_offset
2923                                 + input_section->output_section->vma
2924                                 + input_section->output_offset;
2925               outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2926               sreloc = elf_section_data (input_section)->sreloc;
2927               if (sreloc == NULL)
2928                 abort ();
2929               loc = sreloc->contents;
2930               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2931               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2932             }
2933           /* Fall through.  */
2934
2935         case R_390_TLS_GD32:
2936         case R_390_TLS_GOTIE32:
2937           r_type = elf_s390_tls_transition (info, r_type, h == NULL);
2938           tls_type = GOT_UNKNOWN;
2939           if (h == NULL && local_got_offsets)
2940             tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
2941           else if (h != NULL)
2942             {
2943               tls_type = elf_s390_hash_entry(h)->tls_type;
2944               if (!bfd_link_pic (info)
2945                   && h->dynindx == -1
2946                   && tls_type >= GOT_TLS_IE)
2947                 r_type = R_390_TLS_LE32;
2948             }
2949           if (r_type == R_390_TLS_GD32 && tls_type >= GOT_TLS_IE)
2950             r_type = R_390_TLS_IE32;
2951
2952           if (r_type == R_390_TLS_LE32)
2953             {
2954               /* This relocation gets optimized away by the local exec
2955                  access optimization.  */
2956               BFD_ASSERT (! unresolved_reloc);
2957               bfd_put_32 (output_bfd, -tpoff (info, relocation),
2958                           contents + rel->r_offset);
2959               continue;
2960             }
2961
2962           if (htab->elf.sgot == NULL)
2963             abort ();
2964
2965           if (h != NULL)
2966             off = h->got.offset;
2967           else
2968             {
2969               if (local_got_offsets == NULL)
2970                 abort ();
2971
2972               off = local_got_offsets[r_symndx];
2973             }
2974
2975         emit_tls_relocs:
2976
2977           if ((off & 1) != 0)
2978             off &= ~1;
2979           else
2980             {
2981               Elf_Internal_Rela outrel;
2982               bfd_byte *loc;
2983               int dr_type, indx;
2984
2985               if (htab->elf.srelgot == NULL)
2986                 abort ();
2987
2988               outrel.r_offset = (htab->elf.sgot->output_section->vma
2989                                  + htab->elf.sgot->output_offset + off);
2990
2991               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2992               if (r_type == R_390_TLS_GD32)
2993                 dr_type = R_390_TLS_DTPMOD;
2994               else
2995                 dr_type = R_390_TLS_TPOFF;
2996               if (dr_type == R_390_TLS_TPOFF && indx == 0)
2997                 outrel.r_addend = relocation - dtpoff_base (info);
2998               else
2999                 outrel.r_addend = 0;
3000               outrel.r_info = ELF32_R_INFO (indx, dr_type);
3001               loc = htab->elf.srelgot->contents;
3002               loc += htab->elf.srelgot->reloc_count++
3003                 * sizeof (Elf32_External_Rela);
3004               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3005
3006               if (r_type == R_390_TLS_GD32)
3007                 {
3008                   if (indx == 0)
3009                     {
3010                       BFD_ASSERT (! unresolved_reloc);
3011                       bfd_put_32 (output_bfd,
3012                                   relocation - dtpoff_base (info),
3013                                   htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3014                     }
3015                   else
3016                     {
3017                       outrel.r_info = ELF32_R_INFO (indx, R_390_TLS_DTPOFF);
3018                       outrel.r_offset += GOT_ENTRY_SIZE;
3019                       outrel.r_addend = 0;
3020                       htab->elf.srelgot->reloc_count++;
3021                       loc += sizeof (Elf32_External_Rela);
3022                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3023                     }
3024                 }
3025
3026               if (h != NULL)
3027                 h->got.offset |= 1;
3028               else
3029                 local_got_offsets[r_symndx] |= 1;
3030             }
3031
3032           if (off >= (bfd_vma) -2)
3033             abort ();
3034           if (r_type == ELF32_R_TYPE (rel->r_info))
3035             {
3036               relocation = htab->elf.sgot->output_offset + off;
3037               if (r_type == R_390_TLS_IE32 || r_type == R_390_TLS_IEENT)
3038                 relocation += htab->elf.sgot->output_section->vma;
3039               unresolved_reloc = FALSE;
3040             }
3041           else
3042             {
3043               bfd_put_32 (output_bfd, htab->elf.sgot->output_offset + off,
3044                           contents + rel->r_offset);
3045               continue;
3046             }
3047           break;
3048
3049         case R_390_TLS_GOTIE12:
3050         case R_390_TLS_GOTIE20:
3051         case R_390_TLS_IEENT:
3052           if (h == NULL)
3053             {
3054               if (local_got_offsets == NULL)
3055                 abort();
3056               off = local_got_offsets[r_symndx];
3057               if (bfd_link_pic (info))
3058                 goto emit_tls_relocs;
3059             }
3060           else
3061             {
3062               off = h->got.offset;
3063               tls_type = elf_s390_hash_entry(h)->tls_type;
3064               if (bfd_link_pic (info)
3065                   || h->dynindx != -1
3066                   || tls_type < GOT_TLS_IE)
3067                 goto emit_tls_relocs;
3068             }
3069
3070           if (htab->elf.sgot == NULL)
3071             abort ();
3072
3073           BFD_ASSERT (! unresolved_reloc);
3074           bfd_put_32 (output_bfd, -tpoff (info, relocation),
3075                       htab->elf.sgot->contents + off);
3076           relocation = htab->elf.sgot->output_offset + off;
3077           if (r_type == R_390_TLS_IEENT)
3078             relocation += htab->elf.sgot->output_section->vma;
3079           unresolved_reloc = FALSE;
3080           break;
3081
3082         case R_390_TLS_LDM32:
3083           if (! bfd_link_pic (info))
3084             /* The literal pool entry this relocation refers to gets ignored
3085                by the optimized code of the local exec model. Do nothing
3086                and the value will turn out zero.  */
3087             continue;
3088
3089           if (htab->elf.sgot == NULL)
3090             abort ();
3091
3092           off = htab->tls_ldm_got.offset;
3093           if (off & 1)
3094             off &= ~1;
3095           else
3096             {
3097               Elf_Internal_Rela outrel;
3098               bfd_byte *loc;
3099
3100               if (htab->elf.srelgot == NULL)
3101                 abort ();
3102
3103               outrel.r_offset = (htab->elf.sgot->output_section->vma
3104                                  + htab->elf.sgot->output_offset + off);
3105
3106               bfd_put_32 (output_bfd, 0,
3107                           htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3108               outrel.r_info = ELF32_R_INFO (0, R_390_TLS_DTPMOD);
3109               outrel.r_addend = 0;
3110               loc = htab->elf.srelgot->contents;
3111               loc += htab->elf.srelgot->reloc_count++
3112                 * sizeof (Elf32_External_Rela);
3113               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3114               htab->tls_ldm_got.offset |= 1;
3115             }
3116           relocation = htab->elf.sgot->output_offset + off;
3117           unresolved_reloc = FALSE;
3118           break;
3119
3120         case R_390_TLS_LE32:
3121           if (bfd_link_dll (info))
3122             {
3123               /* Linking a shared library with non-fpic code requires
3124                  a R_390_TLS_TPOFF relocation.  */
3125               Elf_Internal_Rela outrel;
3126               asection *sreloc;
3127               bfd_byte *loc;
3128               int indx;
3129
3130               outrel.r_offset = rel->r_offset
3131                                 + input_section->output_section->vma
3132                                 + input_section->output_offset;
3133               if (h != NULL && h->dynindx != -1)
3134                 indx = h->dynindx;
3135               else
3136                 indx = 0;
3137               outrel.r_info = ELF32_R_INFO (indx, R_390_TLS_TPOFF);
3138               if (indx == 0)
3139                 outrel.r_addend = relocation - dtpoff_base (info);
3140               else
3141                 outrel.r_addend = 0;
3142               sreloc = elf_section_data (input_section)->sreloc;
3143               if (sreloc == NULL)
3144                 abort ();
3145               loc = sreloc->contents;
3146               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
3147               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3148             }
3149           else
3150             {
3151               BFD_ASSERT (! unresolved_reloc);
3152               bfd_put_32 (output_bfd, -tpoff (info, relocation),
3153                           contents + rel->r_offset);
3154             }
3155           continue;
3156
3157         case R_390_TLS_LDO32:
3158           if (bfd_link_pic (info) || (input_section->flags & SEC_DEBUGGING))
3159             relocation -= dtpoff_base (info);
3160           else
3161             /* When converting LDO to LE, we must negate.  */
3162             relocation = -tpoff (info, relocation);
3163           break;
3164
3165           /* Relocations for tls instructions.  */
3166         case R_390_TLS_LOAD:
3167         case R_390_TLS_GDCALL:
3168         case R_390_TLS_LDCALL:
3169           tls_type = GOT_UNKNOWN;
3170           if (h == NULL && local_got_offsets)
3171             tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
3172           else if (h != NULL)
3173             tls_type = elf_s390_hash_entry(h)->tls_type;
3174
3175           if (tls_type == GOT_TLS_GD)
3176             continue;
3177
3178           if (r_type == R_390_TLS_LOAD)
3179             {
3180               if (!bfd_link_pic (info) && (h == NULL || h->dynindx == -1))
3181                 {
3182                   /* IE->LE transition. Four valid cases:
3183                      l %rx,0(0,%ry)    -> lr %rx,%ry + bcr 0,0
3184                      l %rx,0(%ry,0)    -> lr %rx,%ry + bcr 0,0
3185                      l %rx,0(%ry,%r12) -> lr %rx,%ry + bcr 0,0
3186                      l %rx,0(%r12,%ry) -> lr %rx,%ry + bcr 0,0 */
3187                   unsigned int insn, ry;
3188
3189                   insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3190                   ry = 0;
3191                   if ((insn & 0xff00f000) == 0x58000000)
3192                     /* l %rx,0(%ry,0) -> lr %rx,%ry + bcr 0,0  */
3193                     ry = (insn & 0x000f0000);
3194                   else if ((insn & 0xff0f0000) == 0x58000000)
3195                     /* l %rx,0(0,%ry) -> lr %rx,%ry + bcr 0,0  */
3196                     ry = (insn & 0x0000f000) << 4;
3197                   else if ((insn & 0xff00f000) == 0x5800c000)
3198                     /* l %rx,0(%ry,%r12) -> lr %rx,%ry + bcr 0,0  */
3199                     ry = (insn & 0x000f0000);
3200                   else if ((insn & 0xff0f0000) == 0x580c0000)
3201                     /* l %rx,0(%r12,%ry) -> lr %rx,%ry + bcr 0,0  */
3202                     ry = (insn & 0x0000f000) << 4;
3203                   else
3204                     invalid_tls_insn (input_bfd, input_section, rel);
3205                   insn = 0x18000700 | (insn & 0x00f00000) | ry;
3206                   bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3207                 }
3208             }
3209           else if (r_type == R_390_TLS_GDCALL)
3210             {
3211               unsigned int insn;
3212
3213               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3214               if ((insn & 0xff000fff) != 0x4d000000 &&
3215                   (insn & 0xffff0000) != 0xc0e50000 &&
3216                   (insn & 0xff000000) != 0x0d000000)
3217                 invalid_tls_insn (input_bfd, input_section, rel);
3218               if (!bfd_link_pic (info) && (h == NULL || h->dynindx == -1))
3219                 {
3220                   if ((insn & 0xff000000) == 0x0d000000)
3221                     {
3222                       /* GD->LE transition.
3223                          basr rx, ry -> nopr r7 */
3224                       insn = 0x07070000 | (insn & 0xffff);
3225                     }
3226                   else if ((insn & 0xff000000) == 0x4d000000)
3227                     {
3228                       /* GD->LE transition.
3229                          bas %r14,0(%rx,%r13) -> bc 0,0  */
3230                       insn = 0x47000000;
3231                     }
3232                   else
3233                     {
3234                       /* GD->LE transition.
3235                          brasl %r14,_tls_get_offset@plt -> brcl 0,.  */
3236                       insn = 0xc0040000;
3237                       bfd_put_16 (output_bfd, 0x0000,
3238                                   contents + rel->r_offset + 4);
3239                     }
3240                 }
3241               else
3242                 {
3243                   /* If basr is used in the pic case to invoke
3244                      _tls_get_offset, something went wrong before.  */
3245                   if ((insn & 0xff000000) == 0x0d000000)
3246                     invalid_tls_insn (input_bfd, input_section, rel);
3247
3248                   if ((insn & 0xff000000) == 0x4d000000)
3249                     {
3250                       /* GD->IE transition.
3251                          bas %r14,0(%rx,%r13) -> l %r2,0(%r2,%r12)  */
3252                       insn = 0x5822c000;
3253                     }
3254                   else
3255                     {
3256                       /* GD->IE transition.
3257                          brasl %r14,__tls_get_addr@plt ->
3258                                 l %r2,0(%r2,%r12) ; bcr 0,0 */
3259                       insn = 0x5822c000;
3260                       bfd_put_16 (output_bfd, 0x0700,
3261                                   contents + rel->r_offset + 4);
3262                     }
3263                 }
3264               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3265             }
3266           else if (r_type == R_390_TLS_LDCALL)
3267             {
3268               if (!bfd_link_pic (info))
3269                 {
3270                   unsigned int insn;
3271
3272                   insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3273                   if ((insn & 0xff000fff) != 0x4d000000 &&
3274                       (insn & 0xffff0000) != 0xc0e50000 &&
3275                       (insn & 0xff000000) != 0x0d000000)
3276                     invalid_tls_insn (input_bfd, input_section, rel);
3277
3278                   if ((insn & 0xff000000) == 0x0d000000)
3279                     {
3280                       /* LD->LE transition.
3281                          basr rx, ry -> nopr r7 */
3282                       insn = 0x07070000 | (insn & 0xffff);
3283                     }
3284                   else if ((insn & 0xff000000) == 0x4d000000)
3285                     {
3286                       /* LD->LE transition.
3287                          bas %r14,0(%rx,%r13) -> bc 0,0  */
3288                       insn = 0x47000000;
3289                     }
3290                   else
3291                     {
3292                       /* LD->LE transition.
3293                          brasl %r14,__tls_get_offset@plt -> brcl 0,. */
3294                       insn = 0xc0040000;
3295                       bfd_put_16 (output_bfd, 0x0000,
3296                                   contents + rel->r_offset + 4);
3297                     }
3298                   bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3299                 }
3300             }
3301           continue;
3302
3303         default:
3304           break;
3305         }
3306
3307       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3308          because such sections are not SEC_ALLOC and thus ld.so will
3309          not process them.  */
3310       if (unresolved_reloc
3311           && !((input_section->flags & SEC_DEBUGGING) != 0
3312                && h->def_dynamic)
3313           && _bfd_elf_section_offset (output_bfd, info, input_section,
3314                                       rel->r_offset) != (bfd_vma) -1)
3315         (*_bfd_error_handler)
3316           (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3317            input_bfd,
3318            input_section,
3319            (long) rel->r_offset,
3320            howto->name,
3321            h->root.root.string);
3322
3323     do_relocation:
3324
3325       /* When applying a 24 bit reloc we need to start one byte
3326          earlier.  Otherwise the 32 bit get/put bfd operations might
3327          access a byte after the actual section.  */
3328       if (r_type == R_390_PC24DBL
3329           || r_type == R_390_PLT24DBL)
3330         rel->r_offset--;
3331
3332       if (r_type == R_390_20
3333           || r_type == R_390_GOT20
3334           || r_type == R_390_GOTPLT20
3335           || r_type == R_390_TLS_GOTIE20)
3336         {
3337           relocation += rel->r_addend;
3338           relocation = (relocation&0xfff) << 8 | (relocation&0xff000) >> 12;
3339           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3340                                         contents, rel->r_offset,
3341                                         relocation, 0);
3342         }
3343       else
3344         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3345                                       contents, rel->r_offset,
3346                                       relocation, rel->r_addend);
3347
3348       if (r != bfd_reloc_ok)
3349         {
3350           const char *name;
3351
3352           if (h != NULL)
3353             name = h->root.root.string;
3354           else
3355             {
3356               name = bfd_elf_string_from_elf_section (input_bfd,
3357                                                       symtab_hdr->sh_link,
3358                                                       sym->st_name);
3359               if (name == NULL)
3360                 return FALSE;
3361               if (*name == '\0')
3362                 name = bfd_section_name (input_bfd, sec);
3363             }
3364
3365           if (r == bfd_reloc_overflow)
3366             {
3367
3368               if (! ((*info->callbacks->reloc_overflow)
3369                      (info, (h ? &h->root : NULL), name, howto->name,
3370                       (bfd_vma) 0, input_bfd, input_section,
3371                       rel->r_offset)))
3372                 return FALSE;
3373             }
3374           else
3375             {
3376               (*_bfd_error_handler)
3377                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3378                  input_bfd, input_section,
3379                  (long) rel->r_offset, name, (int) r);
3380               return FALSE;
3381             }
3382         }
3383     }
3384
3385   return TRUE;
3386 }
3387
3388 /* Generate the PLT slots together with the dynamic relocations needed
3389    for IFUNC symbols.  */
3390
3391 static void
3392 elf_s390_finish_ifunc_symbol (bfd *output_bfd,
3393                               struct bfd_link_info *info,
3394                               struct elf_link_hash_entry *h,
3395                               struct elf_s390_link_hash_table *htab,
3396                               bfd_vma iplt_offset,
3397                               bfd_vma resolver_address)
3398 {
3399   bfd_vma iplt_index;
3400   bfd_vma got_offset;
3401   bfd_vma igotiplt_offset;
3402   Elf_Internal_Rela rela;
3403   bfd_byte *loc;
3404   asection *plt, *gotplt, *relplt;
3405   bfd_vma relative_offset;
3406
3407   if (htab->elf.iplt == NULL
3408       || htab->elf.igotplt == NULL
3409       || htab->elf.irelplt == NULL)
3410     abort ();
3411
3412   gotplt = htab->elf.igotplt;
3413   relplt = htab->elf.irelplt;
3414
3415   /* Index of the PLT slot within iplt section.  */
3416   iplt_index = iplt_offset / PLT_ENTRY_SIZE;
3417   plt = htab->elf.iplt;
3418   /* Offset into the igot.plt section.  */
3419   igotiplt_offset = iplt_index * GOT_ENTRY_SIZE;
3420   /* Offset into the got section.  */
3421   got_offset = igotiplt_offset + gotplt->output_offset;
3422
3423   /* S390 uses halfwords for relative branch calc!  */
3424   relative_offset = - (plt->output_offset +
3425                        (PLT_ENTRY_SIZE * iplt_index) + 18) / 2;
3426 /* If offset is > 32768, branch to a previous branch
3427    390 can only handle +-64 K jumps.  */
3428   if ( -32768 > (int) relative_offset )
3429     relative_offset
3430       = -(unsigned) (((65536 / PLT_ENTRY_SIZE - 1) * PLT_ENTRY_SIZE) / 2);
3431
3432   /* Fill in the entry in the procedure linkage table.  */
3433   if (!bfd_link_pic (info))
3434     {
3435       memcpy (plt->contents + iplt_offset, elf_s390_plt_entry,
3436               PLT_ENTRY_SIZE);
3437
3438       /* Adjust jump to the first plt entry.  */
3439       bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3440                   plt->contents + iplt_offset + 20);
3441
3442       /* Push the GOT offset field.  */
3443       bfd_put_32 (output_bfd,
3444                   (gotplt->output_section->vma
3445                    + got_offset),
3446                   plt->contents + iplt_offset + 24);
3447     }
3448   else if (got_offset < 4096)
3449     {
3450       /* The GOT offset is small enough to be used directly as
3451          displacement.  */
3452       memcpy (plt->contents + iplt_offset,
3453               elf_s390_plt_pic12_entry,
3454               PLT_ENTRY_SIZE);
3455
3456       /* Put in the GOT offset as displacement value.  The 0xc000
3457          value comes from the first word of the plt entry.  Look
3458          at the elf_s390_plt_pic16_entry content.  */
3459       bfd_put_16 (output_bfd, (bfd_vma)0xc000 | got_offset,
3460                   plt->contents + iplt_offset + 2);
3461
3462       /* Adjust the jump to the first plt entry.  */
3463       bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3464                   plt->contents + iplt_offset + 20);
3465     }
3466   else if (got_offset < 32768)
3467     {
3468       /* The GOT offset is too big for a displacement but small
3469          enough to be a signed 16 bit immediate value as it can be
3470          used in an lhi instruction.  */
3471       memcpy (plt->contents + iplt_offset,
3472               elf_s390_plt_pic16_entry,
3473               PLT_ENTRY_SIZE);
3474
3475       /* Put in the GOT offset for the lhi instruction.  */
3476       bfd_put_16 (output_bfd, (bfd_vma)got_offset,
3477                   plt->contents + iplt_offset + 2);
3478
3479       /* Adjust the jump to the first plt entry.  */
3480       bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3481                   plt->contents + iplt_offset + 20);
3482     }
3483   else
3484     {
3485       memcpy (plt->contents + iplt_offset,
3486               elf_s390_plt_pic_entry,
3487               PLT_ENTRY_SIZE);
3488
3489       /* Adjust the jump to the first plt entry.  */
3490       bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3491                   plt->contents + iplt_offset + 20);
3492
3493       /* Push the GOT offset field.  */
3494       bfd_put_32 (output_bfd, got_offset,
3495                   plt->contents + iplt_offset + 24);
3496     }
3497   /* Insert offset into  reloc. table here.  */
3498   bfd_put_32 (output_bfd, relplt->output_offset +
3499               iplt_index * RELA_ENTRY_SIZE,
3500               plt->contents + iplt_offset + 28);
3501
3502   /* Fill in the entry in the global offset table.
3503      Points to instruction after GOT offset.  */
3504   bfd_put_32 (output_bfd,
3505               (plt->output_section->vma
3506                + plt->output_offset
3507                + iplt_offset
3508                + 12),
3509               gotplt->contents + igotiplt_offset);
3510
3511   /* Fill in the entry in the .rela.plt section.  */
3512   rela.r_offset = gotplt->output_section->vma + got_offset;
3513
3514   if (!h
3515       || h->dynindx == -1
3516       || ((bfd_link_executable (info)
3517            || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
3518           && h->def_regular))
3519     {
3520       /* The symbol can be locally resolved.  */
3521       rela.r_info = ELF32_R_INFO (0, R_390_IRELATIVE);
3522       rela.r_addend = resolver_address;
3523     }
3524   else
3525     {
3526       rela.r_info = ELF32_R_INFO (h->dynindx, R_390_JMP_SLOT);
3527       rela.r_addend = 0;
3528     }
3529
3530   loc = relplt->contents + iplt_index * RELA_ENTRY_SIZE;
3531   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3532 }
3533
3534 /* Finish up dynamic symbol handling.  We set the contents of various
3535    dynamic sections here.  */
3536
3537 static bfd_boolean
3538 elf_s390_finish_dynamic_symbol (bfd *output_bfd,
3539                                 struct bfd_link_info *info,
3540                                 struct elf_link_hash_entry *h,
3541                                 Elf_Internal_Sym *sym)
3542 {
3543   struct elf_s390_link_hash_table *htab;
3544   struct elf_s390_link_hash_entry *eh = (struct elf_s390_link_hash_entry*)h;
3545
3546   htab = elf_s390_hash_table (info);
3547
3548   if (h->plt.offset != (bfd_vma) -1)
3549     {
3550       bfd_vma plt_index;
3551       bfd_vma got_offset;
3552       Elf_Internal_Rela rela;
3553       bfd_byte *loc;
3554       bfd_vma relative_offset;
3555
3556       /* This symbol has an entry in the procedure linkage table.  Set
3557          it up.  */
3558       if (s390_is_ifunc_symbol_p (h))
3559         {
3560           /* If we can resolve the IFUNC symbol locally we generate an
3561              IRELATIVE reloc.  */
3562           elf_s390_finish_ifunc_symbol (output_bfd, info, h, htab, h->plt.offset,
3563                                         eh->ifunc_resolver_address +
3564                                         eh->ifunc_resolver_section->output_offset +
3565                                         eh->ifunc_resolver_section->output_section->vma);
3566           /* Fallthrough.  Handling of explicit GOT slots of IFUNC
3567              symbols is below.  */
3568         }
3569       else
3570         {
3571           if (h->dynindx == -1
3572               || htab->elf.splt == NULL
3573               || htab->elf.sgotplt == NULL
3574               || htab->elf.srelplt == NULL)
3575             abort ();
3576
3577           /* Calc. index no.
3578              Current offset - size first entry / entry size.  */
3579           plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3580
3581           /* Offset in GOT is PLT index plus GOT headers(3) times 4,
3582              addr & GOT addr.  */
3583           got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
3584
3585           /* S390 uses halfwords for relative branch calc!  */
3586           relative_offset = - ((PLT_FIRST_ENTRY_SIZE +
3587                                 (PLT_ENTRY_SIZE * plt_index) + 18) / 2);
3588           /* If offset is > 32768, branch to a previous branch
3589              390 can only handle +-64 K jumps.  */
3590           if ( -32768 > (int) relative_offset )
3591             relative_offset
3592               = -(unsigned) (((65536 / PLT_ENTRY_SIZE - 1) * PLT_ENTRY_SIZE) / 2);
3593
3594           /* Fill in the entry in the procedure linkage table.  */
3595           if (!bfd_link_pic (info))
3596             {
3597               memcpy (htab->elf.splt->contents + h->plt.offset, elf_s390_plt_entry,
3598                       PLT_ENTRY_SIZE);
3599
3600               /* Adjust jump to the first plt entry.  */
3601               bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3602                           htab->elf.splt->contents + h->plt.offset + 20);
3603
3604               /* Push the GOT offset field.  */
3605               bfd_put_32 (output_bfd,
3606                           (htab->elf.sgotplt->output_section->vma
3607                            + htab->elf.sgotplt->output_offset
3608                            + got_offset),
3609                           htab->elf.splt->contents + h->plt.offset + 24);
3610             }
3611           else if (got_offset < 4096)
3612             {
3613               /* The GOT offset is small enough to be used directly as
3614                  displacement.  */
3615               memcpy (htab->elf.splt->contents + h->plt.offset,
3616                       elf_s390_plt_pic12_entry,
3617                       PLT_ENTRY_SIZE);
3618
3619               /* Put in the GOT offset as displacement value.  The 0xc000
3620                  value comes from the first word of the plt entry.  Look
3621                  at the elf_s390_plt_pic16_entry content.  */
3622               bfd_put_16 (output_bfd, (bfd_vma)0xc000 | got_offset,
3623                           htab->elf.splt->contents + h->plt.offset + 2);
3624
3625               /* Adjust the jump to the first plt entry.  */
3626               bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3627                           htab->elf.splt->contents + h->plt.offset + 20);
3628             }
3629           else if (got_offset < 32768)
3630             {
3631               /* The GOT offset is too big for a displacement but small
3632                  enough to be a signed 16 bit immediate value as it can be
3633                  used in an lhi instruction.  */
3634               memcpy (htab->elf.splt->contents + h->plt.offset,
3635                       elf_s390_plt_pic16_entry,
3636                       PLT_ENTRY_SIZE);
3637
3638               /* Put in the GOT offset for the lhi instruction.  */
3639               bfd_put_16 (output_bfd, (bfd_vma)got_offset,
3640                           htab->elf.splt->contents + h->plt.offset + 2);
3641
3642               /* Adjust the jump to the first plt entry.  */
3643               bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3644                           htab->elf.splt->contents + h->plt.offset + 20);
3645             }
3646           else
3647             {
3648               memcpy (htab->elf.splt->contents + h->plt.offset,
3649                       elf_s390_plt_pic_entry,
3650                       PLT_ENTRY_SIZE);
3651
3652               /* Adjust the jump to the first plt entry.  */
3653               bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3654                           htab->elf.splt->contents + h->plt.offset + 20);
3655
3656               /* Push the GOT offset field.  */
3657               bfd_put_32 (output_bfd, got_offset,
3658                           htab->elf.splt->contents + h->plt.offset + 24);
3659             }
3660           /* Insert offset into  reloc. table here.  */
3661           bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
3662                       htab->elf.splt->contents + h->plt.offset + 28);
3663
3664           /* Fill in the entry in the global offset table.
3665              Points to instruction after GOT offset.  */
3666           bfd_put_32 (output_bfd,
3667                       (htab->elf.splt->output_section->vma
3668                        + htab->elf.splt->output_offset
3669                        + h->plt.offset
3670                        + 12),
3671                       htab->elf.sgotplt->contents + got_offset);
3672
3673           /* Fill in the entry in the .rela.plt section.  */
3674           rela.r_offset = (htab->elf.sgotplt->output_section->vma
3675                            + htab->elf.sgotplt->output_offset
3676                            + got_offset);
3677           rela.r_info = ELF32_R_INFO (h->dynindx, R_390_JMP_SLOT);
3678           rela.r_addend = 0;
3679           loc = htab->elf.srelplt->contents + plt_index * sizeof (Elf32_External_Rela);
3680           bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3681
3682           if (!h->def_regular)
3683             {
3684               /* Mark the symbol as undefined, rather than as defined in
3685                  the .plt section.  Leave the value alone.  This is a clue
3686                  for the dynamic linker, to make function pointer
3687                  comparisons work between an application and shared
3688                  library.  */
3689               sym->st_shndx = SHN_UNDEF;
3690             }
3691         }
3692     }
3693
3694   if (h->got.offset != (bfd_vma) -1
3695       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_GD
3696       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE
3697       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE_NLT)
3698     {
3699       Elf_Internal_Rela rela;
3700       bfd_byte *loc;
3701
3702       /* This symbol has an entry in the global offset table.  Set it
3703          up.  */
3704
3705       if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
3706         abort ();
3707
3708       rela.r_offset = (htab->elf.sgot->output_section->vma
3709                        + htab->elf.sgot->output_offset
3710                        + (h->got.offset &~ (bfd_vma) 1));
3711
3712       /* If this is a static link, or it is a -Bsymbolic link and the
3713          symbol is defined locally or was forced to be local because
3714          of a version file, we just want to emit a RELATIVE reloc.
3715          The entry in the global offset table will already have been
3716          initialized in the relocate_section function.  */
3717       if (h->def_regular && s390_is_ifunc_symbol_p (h))
3718         {
3719           if (bfd_link_pic (info))
3720             {
3721               /* An explicit GOT slot usage needs GLOB_DAT.  If the
3722                  symbol references local the implicit got.iplt slot
3723                  will be used and the IRELATIVE reloc has been created
3724                  above.  */
3725               goto do_glob_dat;
3726             }
3727           else
3728             {
3729               /* For non-shared objects explicit GOT slots must be
3730                  filled with the PLT slot address for pointer
3731                  equality reasons.  */
3732               bfd_put_32 (output_bfd, (htab->elf.iplt->output_section->vma
3733                                        + htab->elf.iplt->output_offset
3734                                        + h->plt.offset),
3735                           htab->elf.sgot->contents + h->got.offset);
3736               return TRUE;
3737             }
3738         }
3739       else if (bfd_link_pic (info)
3740           && SYMBOL_REFERENCES_LOCAL (info, h))
3741         {
3742           /* If this is a static link, or it is a -Bsymbolic link and
3743              the symbol is defined locally or was forced to be local
3744              because of a version file, we just want to emit a
3745              RELATIVE reloc.  The entry in the global offset table
3746              will already have been initialized in the
3747              relocate_section function.  */
3748           if (!h->def_regular)
3749             return FALSE;
3750           BFD_ASSERT((h->got.offset & 1) != 0);
3751           rela.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
3752           rela.r_addend = (h->root.u.def.value
3753                            + h->root.u.def.section->output_section->vma
3754                            + h->root.u.def.section->output_offset);
3755         }
3756       else
3757         {
3758           BFD_ASSERT((h->got.offset & 1) == 0);
3759         do_glob_dat:
3760           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->elf.sgot->contents + h->got.offset);
3761           rela.r_info = ELF32_R_INFO (h->dynindx, R_390_GLOB_DAT);
3762           rela.r_addend = 0;
3763         }
3764
3765       loc = htab->elf.srelgot->contents;
3766       loc += htab->elf.srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
3767       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3768     }
3769
3770   if (h->needs_copy)
3771     {
3772       Elf_Internal_Rela rela;
3773       bfd_byte *loc;
3774
3775       /* This symbols needs a copy reloc.  Set it up.  */
3776
3777       if (h->dynindx == -1
3778           || (h->root.type != bfd_link_hash_defined
3779               && h->root.type != bfd_link_hash_defweak)
3780           || htab->srelbss == NULL)
3781         abort ();
3782
3783       rela.r_offset = (h->root.u.def.value
3784                        + h->root.u.def.section->output_section->vma
3785                        + h->root.u.def.section->output_offset);
3786       rela.r_info = ELF32_R_INFO (h->dynindx, R_390_COPY);
3787       rela.r_addend = 0;
3788       loc = htab->srelbss->contents;
3789       loc += htab->srelbss->reloc_count++ * sizeof (Elf32_External_Rela);
3790       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3791     }
3792
3793   /* Mark some specially defined symbols as absolute.  */
3794   if (h == htab->elf.hdynamic
3795       || h == htab->elf.hgot
3796       || h == htab->elf.hplt)
3797     sym->st_shndx = SHN_ABS;
3798
3799   return TRUE;
3800 }
3801
3802 /* Used to decide how to sort relocs in an optimal manner for the
3803    dynamic linker, before writing them out.  */
3804
3805 static enum elf_reloc_type_class
3806 elf_s390_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
3807                            const asection *rel_sec ATTRIBUTE_UNUSED,
3808                            const Elf_Internal_Rela *rela)
3809 {
3810   switch ((int) ELF32_R_TYPE (rela->r_info))
3811     {
3812     case R_390_RELATIVE:
3813       return reloc_class_relative;
3814     case R_390_JMP_SLOT:
3815       return reloc_class_plt;
3816     case R_390_COPY:
3817       return reloc_class_copy;
3818     default:
3819       return reloc_class_normal;
3820     }
3821 }
3822
3823 /* Finish up the dynamic sections.  */
3824
3825 static bfd_boolean
3826 elf_s390_finish_dynamic_sections (bfd *output_bfd,
3827                                   struct bfd_link_info *info)
3828 {
3829   struct elf_s390_link_hash_table *htab;
3830   bfd *dynobj;
3831   asection *sdyn;
3832   bfd *ibfd;
3833   unsigned int i;
3834
3835   htab = elf_s390_hash_table (info);
3836   dynobj = htab->elf.dynobj;
3837   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3838
3839   if (htab->elf.dynamic_sections_created)
3840     {
3841       Elf32_External_Dyn *dyncon, *dynconend;
3842
3843       if (sdyn == NULL || htab->elf.sgot == NULL)
3844         abort ();
3845
3846       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3847       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3848       for (; dyncon < dynconend; dyncon++)
3849         {
3850           Elf_Internal_Dyn dyn;
3851           asection *s;
3852
3853           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3854
3855           switch (dyn.d_tag)
3856             {
3857             default:
3858               continue;
3859
3860             case DT_PLTGOT:
3861               dyn.d_un.d_ptr = htab->elf.sgot->output_section->vma;
3862               break;
3863
3864             case DT_JMPREL:
3865               dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
3866               break;
3867
3868             case DT_PLTRELSZ:
3869               s = htab->elf.srelplt->output_section;
3870               dyn.d_un.d_val = s->size;
3871               break;
3872             }
3873
3874           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3875         }
3876
3877       /* Fill in the special first entry in the procedure linkage table.  */
3878       if (htab->elf.splt && htab->elf.splt->size > 0)
3879         {
3880           memset (htab->elf.splt->contents, 0, PLT_FIRST_ENTRY_SIZE);
3881           if (bfd_link_pic (info))
3882             {
3883               memcpy (htab->elf.splt->contents, elf_s390_plt_pic_first_entry,
3884                       PLT_FIRST_ENTRY_SIZE);
3885             }
3886           else
3887             {
3888               memcpy (htab->elf.splt->contents, elf_s390_plt_first_entry,
3889                       PLT_FIRST_ENTRY_SIZE);
3890               bfd_put_32 (output_bfd,
3891                           htab->elf.sgotplt->output_section->vma
3892                           + htab->elf.sgotplt->output_offset,
3893                           htab->elf.splt->contents + 24);
3894            }
3895           elf_section_data (htab->elf.splt->output_section)
3896             ->this_hdr.sh_entsize = 4;
3897         }
3898
3899     }
3900
3901   if (htab->elf.sgotplt)
3902     {
3903       /* Fill in the first three entries in the global offset table.  */
3904       if (htab->elf.sgotplt->size > 0)
3905         {
3906           bfd_put_32 (output_bfd,
3907                       (sdyn == NULL ? (bfd_vma) 0
3908                        : sdyn->output_section->vma + sdyn->output_offset),
3909                       htab->elf.sgotplt->contents);
3910           /* One entry for shared object struct ptr.  */
3911           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + 4);
3912           /* One entry for _dl_runtime_resolve.  */
3913           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + 8);
3914         }
3915
3916       elf_section_data (htab->elf.sgotplt->output_section)
3917         ->this_hdr.sh_entsize = 4;
3918     }
3919   /* Finish dynamic symbol for local IFUNC symbols.  */
3920   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3921     {
3922       struct plt_entry *local_plt;
3923       Elf_Internal_Sym *isym;
3924       Elf_Internal_Shdr *symtab_hdr;
3925
3926       symtab_hdr = &elf_symtab_hdr (ibfd);
3927
3928       local_plt = elf_s390_local_plt (ibfd);
3929       if (local_plt != NULL)
3930         for (i = 0; i < symtab_hdr->sh_info; i++)
3931           {
3932             if (local_plt[i].plt.offset != (bfd_vma) -1)
3933               {
3934                 asection *sec = local_plt[i].sec;
3935                 isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, i);
3936                 if (isym == NULL)
3937                   return FALSE;
3938
3939                 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
3940                   elf_s390_finish_ifunc_symbol (output_bfd, info, NULL, htab,
3941                                                 local_plt[i].plt.offset,
3942                                                 isym->st_value
3943                                                 + sec->output_section->vma
3944                                                 + sec->output_offset);
3945
3946               }
3947           }
3948     }
3949   return TRUE;
3950 }
3951
3952 static bfd_boolean
3953 elf_s390_grok_prstatus (bfd * abfd, Elf_Internal_Note * note)
3954 {
3955   int offset;
3956   unsigned int size;
3957
3958   switch (note->descsz)
3959     {
3960       default:
3961         return FALSE;
3962
3963       case 224:         /* S/390 Linux.  */
3964         /* pr_cursig */
3965         elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3966
3967         /* pr_pid */
3968         elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
3969
3970         /* pr_reg */
3971         offset = 72;
3972         size = 144;
3973         break;
3974     }
3975
3976   /* Make a ".reg/999" section.  */
3977   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3978                                           size, note->descpos + offset);
3979 }
3980
3981 /* Return address for Ith PLT stub in section PLT, for relocation REL
3982    or (bfd_vma) -1 if it should not be included.  */
3983
3984 static bfd_vma
3985 elf_s390_plt_sym_val (bfd_vma i, const asection *plt,
3986                       const arelent *rel ATTRIBUTE_UNUSED)
3987 {
3988   return plt->vma + PLT_FIRST_ENTRY_SIZE + i * PLT_ENTRY_SIZE;
3989 }
3990
3991 /* Merge backend specific data from an object file to the output
3992    object file when linking.  */
3993
3994 static bfd_boolean
3995 elf32_s390_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
3996 {
3997   if (!is_s390_elf (ibfd) || !is_s390_elf (obfd))
3998     return TRUE;
3999
4000   if (!elf_s390_merge_obj_attributes (ibfd, obfd))
4001     return FALSE;
4002
4003   elf_elfheader (obfd)->e_flags |= elf_elfheader (ibfd)->e_flags;
4004   return TRUE;
4005 }
4006
4007
4008 #define TARGET_BIG_SYM  s390_elf32_vec
4009 #define TARGET_BIG_NAME "elf32-s390"
4010 #define ELF_ARCH        bfd_arch_s390
4011 #define ELF_TARGET_ID   S390_ELF_DATA
4012 #define ELF_MACHINE_CODE EM_S390
4013 #define ELF_MACHINE_ALT1 EM_S390_OLD
4014 #define ELF_MAXPAGESIZE 0x1000
4015
4016 #define elf_backend_can_gc_sections     1
4017 #define elf_backend_can_refcount        1
4018 #define elf_backend_want_got_plt        1
4019 #define elf_backend_plt_readonly        1
4020 #define elf_backend_want_plt_sym        0
4021 #define elf_backend_got_header_size     12
4022 #define elf_backend_rela_normal         1
4023
4024 #define elf_info_to_howto                     elf_s390_info_to_howto
4025
4026 #define bfd_elf32_bfd_is_local_label_name     elf_s390_is_local_label_name
4027 #define bfd_elf32_bfd_link_hash_table_create  elf_s390_link_hash_table_create
4028 #define bfd_elf32_bfd_reloc_type_lookup       elf_s390_reloc_type_lookup
4029 #define bfd_elf32_bfd_reloc_name_lookup elf_s390_reloc_name_lookup
4030
4031 #define bfd_elf32_bfd_merge_private_bfd_data  elf32_s390_merge_private_bfd_data
4032
4033 #define elf_backend_adjust_dynamic_symbol     elf_s390_adjust_dynamic_symbol
4034 #define elf_backend_check_relocs              elf_s390_check_relocs
4035 #define elf_backend_copy_indirect_symbol      elf_s390_copy_indirect_symbol
4036 #define elf_backend_create_dynamic_sections   elf_s390_create_dynamic_sections
4037 #define elf_backend_finish_dynamic_sections   elf_s390_finish_dynamic_sections
4038 #define elf_backend_finish_dynamic_symbol     elf_s390_finish_dynamic_symbol
4039 #define elf_backend_gc_mark_hook              elf_s390_gc_mark_hook
4040 #define elf_backend_gc_sweep_hook             elf_s390_gc_sweep_hook
4041 #define elf_backend_reloc_type_class          elf_s390_reloc_type_class
4042 #define elf_backend_relocate_section          elf_s390_relocate_section
4043 #define elf_backend_size_dynamic_sections     elf_s390_size_dynamic_sections
4044 #define elf_backend_init_index_section        _bfd_elf_init_1_index_section
4045 #define elf_backend_grok_prstatus             elf_s390_grok_prstatus
4046 #define elf_backend_plt_sym_val               elf_s390_plt_sym_val
4047 #define elf_backend_add_symbol_hook           elf_s390_add_symbol_hook
4048 #define elf_backend_sort_relocs_p             elf_s390_elf_sort_relocs_p
4049
4050 #define bfd_elf32_mkobject              elf_s390_mkobject
4051 #define elf_backend_object_p            elf_s390_object_p
4052
4053 #include "elf32-target.h"