bfd/elf32-s390.c

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