bfd/elf32-s390.c

   1 /* IBM S/390-specific support for 32-bit ELF
   2    Copyright (C) 2000-2015 Free Software Foundation, Inc.
   3    Contributed by Carl B. Pedersen and Martin Schwidefsky.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  20    02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "bfdlink.h"
  25 #include "libbfd.h"
  26 #include "elf-bfd.h"
  27 #include "elf/s390.h"
  28
  29 static bfd_reloc_status_type
  30 s390_tls_reloc (bfd *, arelent *, asymbol *, void *,
  31                 asection *, bfd *, char **);
  32 static bfd_reloc_status_type
  33 s390_elf_ldisp_reloc (bfd *, arelent *, asymbol *, void *,
  34                       asection *, bfd *, char **);
  35
  36 /* The relocation "howto" table.  */
  37
  38 static reloc_howto_type elf_howto_table[] =
  39 {
  40   HOWTO (R_390_NONE,            /* type */
  41          0,                     /* rightshift */
  42          3,                     /* size (0 = byte, 1 = 2 byte, 2 = 4 byte) */
  43          0,                     /* bitsize */
  44          FALSE,                 /* pc_relative */
  45          0,                     /* bitpos */
  46          complain_overflow_dont, /* complain_on_overflow */
  47          bfd_elf_generic_reloc, /* special_function */
  48          "R_390_NONE",          /* name */
  49          FALSE,                 /* partial_inplace */
  50          0,                     /* src_mask */
  51          0,                     /* dst_mask */
  52          FALSE),                /* pcrel_offset */
  53
  54   HOWTO(R_390_8,         0, 0,  8, FALSE, 0, complain_overflow_bitfield,
  55         bfd_elf_generic_reloc, "R_390_8",        FALSE, 0,0x000000ff, FALSE),
  56   HOWTO(R_390_12,        0, 1, 12, FALSE, 0, complain_overflow_dont,
  57         bfd_elf_generic_reloc, "R_390_12",       FALSE, 0,0x00000fff, FALSE),
  58   HOWTO(R_390_16,        0, 1, 16, FALSE, 0, complain_overflow_bitfield,
  59         bfd_elf_generic_reloc, "R_390_16",       FALSE, 0,0x0000ffff, FALSE),
  60   HOWTO(R_390_32,        0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  61         bfd_elf_generic_reloc, "R_390_32",       FALSE, 0,0xffffffff, FALSE),
  62   HOWTO(R_390_PC32,      0, 2, 32,  TRUE, 0, complain_overflow_bitfield,
  63         bfd_elf_generic_reloc, "R_390_PC32",     FALSE, 0,0xffffffff, TRUE),
  64   HOWTO(R_390_GOT12,     0, 1, 12, FALSE, 0, complain_overflow_bitfield,
  65         bfd_elf_generic_reloc, "R_390_GOT12",    FALSE, 0,0x00000fff, FALSE),
  66   HOWTO(R_390_GOT32,     0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  67         bfd_elf_generic_reloc, "R_390_GOT32",    FALSE, 0,0xffffffff, FALSE),
  68   HOWTO(R_390_PLT32,     0, 2, 32,  TRUE, 0, complain_overflow_bitfield,
  69         bfd_elf_generic_reloc, "R_390_PLT32",    FALSE, 0,0xffffffff, TRUE),
  70   HOWTO(R_390_COPY,      0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  71         bfd_elf_generic_reloc, "R_390_COPY",     FALSE, 0,0xffffffff, FALSE),
  72   HOWTO(R_390_GLOB_DAT,  0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  73         bfd_elf_generic_reloc, "R_390_GLOB_DAT", FALSE, 0,0xffffffff, FALSE),
  74   HOWTO(R_390_JMP_SLOT,  0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  75         bfd_elf_generic_reloc, "R_390_JMP_SLOT", FALSE, 0,0xffffffff, FALSE),
  76   HOWTO(R_390_RELATIVE,  0, 2, 32,  TRUE, 0, complain_overflow_bitfield,
  77         bfd_elf_generic_reloc, "R_390_RELATIVE", FALSE, 0,0xffffffff, FALSE),
  78   HOWTO(R_390_GOTOFF32,  0, 2, 32, FALSE, 0, complain_overflow_bitfield,
  79         bfd_elf_generic_reloc, "R_390_GOTOFF32", FALSE, 0,0xffffffff, FALSE),
  80   HOWTO(R_390_GOTPC,     0, 2, 32,  TRUE, 0, complain_overflow_bitfield,
  81         bfd_elf_generic_reloc, "R_390_GOTPC",    FALSE, 0,0xffffffff, TRUE),
  82   HOWTO(R_390_GOT16,     0, 1, 16, FALSE, 0, complain_overflow_bitfield,
  83         bfd_elf_generic_reloc, "R_390_GOT16",    FALSE, 0,0x0000ffff, FALSE),
  84   HOWTO(R_390_PC16,      0, 1, 16,  TRUE, 0, complain_overflow_bitfield,
  85         bfd_elf_generic_reloc, "R_390_PC16",     FALSE, 0,0x0000ffff, TRUE),
  86   HOWTO(R_390_PC16DBL,   1, 1, 16,  TRUE, 0, complain_overflow_bitfield,
  87         bfd_elf_generic_reloc, "R_390_PC16DBL",  FALSE, 0,0x0000ffff, TRUE),
  88   HOWTO(R_390_PLT16DBL,  1, 1, 16,  TRUE, 0, complain_overflow_bitfield,
  89         bfd_elf_generic_reloc, "R_390_PLT16DBL", FALSE, 0,0x0000ffff, TRUE),
  90   HOWTO(R_390_PC32DBL,   1, 2, 32,  TRUE, 0, complain_overflow_bitfield,
  91         bfd_elf_generic_reloc, "R_390_PC32DBL",  FALSE, 0,0xffffffff, TRUE),
  92   HOWTO(R_390_PLT32DBL,  1, 2, 32,  TRUE, 0, complain_overflow_bitfield,
  93         bfd_elf_generic_reloc, "R_390_PLT32DBL", FALSE, 0,0xffffffff, TRUE),
  94   HOWTO(R_390_GOTPCDBL,  1, 2, 32,  TRUE, 0, complain_overflow_bitfield,
  95         bfd_elf_generic_reloc, "R_390_GOTPCDBL", FALSE, 0,0xffffffff, TRUE),
  96   EMPTY_HOWTO (R_390_64),       /* Empty entry for R_390_64.  */
  97   EMPTY_HOWTO (R_390_PC64),     /* Empty entry for R_390_PC64.  */
  98   EMPTY_HOWTO (R_390_GOT64),    /* Empty entry for R_390_GOT64.  */
  99   EMPTY_HOWTO (R_390_PLT64),    /* Empty entry for R_390_PLT64.  */
 100   HOWTO(R_390_GOTENT,    1, 2, 32,  TRUE, 0, complain_overflow_bitfield,
 101         bfd_elf_generic_reloc, "R_390_GOTENT",   FALSE, 0,0xffffffff, TRUE),
 102   HOWTO(R_390_GOTOFF16,  0, 1, 16, FALSE, 0, complain_overflow_bitfield,
 103         bfd_elf_generic_reloc, "R_390_GOTOFF16", FALSE, 0,0x0000ffff, FALSE),
 104   EMPTY_HOWTO (R_390_GOTOFF64), /* Empty entry for R_390_GOTOFF64.  */
 105   HOWTO(R_390_GOTPLT12,  0, 1, 12, FALSE, 0, complain_overflow_dont,
 106         bfd_elf_generic_reloc, "R_390_GOTPLT12", FALSE, 0,0x00000fff, FALSE),
 107   HOWTO(R_390_GOTPLT16,  0, 1, 16, FALSE, 0, complain_overflow_bitfield,
 108         bfd_elf_generic_reloc, "R_390_GOTPLT16", FALSE, 0,0x0000ffff, FALSE),
 109   HOWTO(R_390_GOTPLT32,  0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 110         bfd_elf_generic_reloc, "R_390_GOTPLT32", FALSE, 0,0xffffffff, FALSE),
 111   EMPTY_HOWTO (R_390_GOTPLT64), /* Empty entry for R_390_GOTPLT64.  */
 112   HOWTO(R_390_GOTPLTENT, 1, 2, 32,  TRUE, 0, complain_overflow_bitfield,
 113         bfd_elf_generic_reloc, "R_390_GOTPLTENT",FALSE, 0,0xffffffff, TRUE),
 114   HOWTO(R_390_PLTOFF16,  0, 1, 16, FALSE, 0, complain_overflow_bitfield,
 115         bfd_elf_generic_reloc, "R_390_PLTOFF16", FALSE, 0,0x0000ffff, FALSE),
 116   HOWTO(R_390_PLTOFF32,  0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 117         bfd_elf_generic_reloc, "R_390_PLTOFF32", FALSE, 0,0xffffffff, FALSE),
 118   EMPTY_HOWTO (R_390_PLTOFF64), /* Empty entry for R_390_PLTOFF64.  */
 119   HOWTO(R_390_TLS_LOAD, 0, 0, 0, FALSE, 0, complain_overflow_dont,
 120         s390_tls_reloc, "R_390_TLS_LOAD", FALSE, 0, 0, FALSE),
 121   HOWTO(R_390_TLS_GDCALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
 122         s390_tls_reloc, "R_390_TLS_GDCALL", FALSE, 0, 0, FALSE),
 123   HOWTO(R_390_TLS_LDCALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
 124         s390_tls_reloc, "R_390_TLS_LDCALL", FALSE, 0, 0, FALSE),
 125   HOWTO(R_390_TLS_GD32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 126         bfd_elf_generic_reloc, "R_390_TLS_GD32", FALSE, 0, 0xffffffff, FALSE),
 127   EMPTY_HOWTO (R_390_TLS_GD64), /* Empty entry for R_390_TLS_GD64.  */
 128   HOWTO(R_390_TLS_GOTIE12, 0, 1, 12, FALSE, 0, complain_overflow_dont,
 129         bfd_elf_generic_reloc, "R_390_TLS_GOTIE12", FALSE, 0, 0x00000fff, FALSE),
 130   HOWTO(R_390_TLS_GOTIE32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 131         bfd_elf_generic_reloc, "R_390_TLS_GOTIE32", FALSE, 0, 0xffffffff, FALSE),
 132   EMPTY_HOWTO (R_390_TLS_GOTIE64),      /* Empty entry for R_390_TLS_GOTIE64.  */
 133   HOWTO(R_390_TLS_LDM32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 134         bfd_elf_generic_reloc, "R_390_TLS_LDM32", FALSE, 0, 0xffffffff, FALSE),
 135   EMPTY_HOWTO (R_390_TLS_LDM64),        /* Empty entry for R_390_TLS_LDM64.  */
 136   HOWTO(R_390_TLS_IE32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 137         bfd_elf_generic_reloc, "R_390_TLS_IE32", FALSE, 0, 0xffffffff, FALSE),
 138   EMPTY_HOWTO (R_390_TLS_IE64), /* Empty entry for R_390_TLS_IE64.  */
 139   HOWTO(R_390_TLS_IEENT, 1, 2, 32, TRUE, 0, complain_overflow_bitfield,
 140         bfd_elf_generic_reloc, "R_390_TLS_IEENT", FALSE, 0, 0xffffffff, TRUE),
 141   HOWTO(R_390_TLS_LE32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 142         bfd_elf_generic_reloc, "R_390_TLS_LE32", FALSE, 0, 0xffffffff, FALSE),
 143   EMPTY_HOWTO (R_390_TLS_LE64), /* Empty entry for R_390_TLS_LE64.  */
 144   HOWTO(R_390_TLS_LDO32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 145         bfd_elf_generic_reloc, "R_390_TLS_LDO32", FALSE, 0, 0xffffffff, FALSE),
 146   EMPTY_HOWTO (R_390_TLS_LDO64),        /* Empty entry for R_390_TLS_LDO64.  */
 147   HOWTO(R_390_TLS_DTPMOD, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 148         bfd_elf_generic_reloc, "R_390_TLS_DTPMOD", FALSE, 0, 0xffffffff, FALSE),
 149   HOWTO(R_390_TLS_DTPOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 150         bfd_elf_generic_reloc, "R_390_TLS_DTPOFF", FALSE, 0, 0xffffffff, FALSE),
 151   HOWTO(R_390_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
 152         bfd_elf_generic_reloc, "R_390_TLS_TPOFF", FALSE, 0, 0xffffffff, FALSE),
 153   HOWTO(R_390_20,        0, 2, 20, FALSE, 8, complain_overflow_dont,
 154         s390_elf_ldisp_reloc, "R_390_20",      FALSE, 0,0x0fffff00, FALSE),
 155   HOWTO(R_390_GOT20,     0, 2, 20, FALSE, 8, complain_overflow_dont,
 156         s390_elf_ldisp_reloc, "R_390_GOT20",   FALSE, 0,0x0fffff00, FALSE),
 157   HOWTO(R_390_GOTPLT20,  0, 2, 20, FALSE, 8, complain_overflow_dont,
 158         s390_elf_ldisp_reloc, "R_390_GOTPLT20", FALSE, 0,0x0fffff00, FALSE),
 159   HOWTO(R_390_TLS_GOTIE20, 0, 2, 20, FALSE, 8, complain_overflow_dont,
 160         s390_elf_ldisp_reloc, "R_390_TLS_GOTIE20", FALSE, 0,0x0fffff00, FALSE),
 161   HOWTO(R_390_IRELATIVE, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
 162         bfd_elf_generic_reloc, "R_390_IRELATIVE", FALSE, 0, 0xffffffff, FALSE),
 163   HOWTO(R_390_PC12DBL,   1, 1, 12,  TRUE, 0, complain_overflow_bitfield,
 164         bfd_elf_generic_reloc, "R_390_PC12DBL",  FALSE, 0,0x00000fff, TRUE),
 165   HOWTO(R_390_PLT12DBL,  1, 1, 12,  TRUE, 0, complain_overflow_bitfield,
 166         bfd_elf_generic_reloc, "R_390_PLT12DBL", FALSE, 0,0x00000fff, TRUE),
 167   HOWTO(R_390_PC24DBL,   1, 2, 24,  TRUE, 0, complain_overflow_bitfield,
 168         bfd_elf_generic_reloc, "R_390_PC24DBL",  FALSE, 0,0x00ffffff, TRUE),
 169   HOWTO(R_390_PLT24DBL,  1, 2, 24,  TRUE, 0, complain_overflow_bitfield,
 170         bfd_elf_generic_reloc, "R_390_PLT24DBL", FALSE, 0,0x00ffffff, TRUE),
 171 };
 172
 173 /* GNU extension to record C++ vtable hierarchy.  */
 174 static reloc_howto_type elf32_s390_vtinherit_howto =
 175   HOWTO (R_390_GNU_VTINHERIT, 0,2,0,FALSE,0,complain_overflow_dont, NULL, "R_390_GNU_VTINHERIT", FALSE,0, 0, FALSE);
 176 static reloc_howto_type elf32_s390_vtentry_howto =
 177   HOWTO (R_390_GNU_VTENTRY, 0,2,0,FALSE,0,complain_overflow_dont, _bfd_elf_rel_vtable_reloc_fn,"R_390_GNU_VTENTRY", FALSE,0,0, FALSE);
 178
 179 static reloc_howto_type *
 180 elf_s390_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 181                             bfd_reloc_code_real_type code)
 182 {
 183   switch (code)
 184     {
 185     case BFD_RELOC_NONE:
 186       return &elf_howto_table[(int) R_390_NONE];
 187     case BFD_RELOC_8:
 188       return &elf_howto_table[(int) R_390_8];
 189     case BFD_RELOC_390_12:
 190       return &elf_howto_table[(int) R_390_12];
 191     case BFD_RELOC_16:
 192       return &elf_howto_table[(int) R_390_16];
 193     case BFD_RELOC_32:
 194       return &elf_howto_table[(int) R_390_32];
 195     case BFD_RELOC_CTOR:
 196       return &elf_howto_table[(int) R_390_32];
 197     case BFD_RELOC_32_PCREL:
 198       return &elf_howto_table[(int) R_390_PC32];
 199     case BFD_RELOC_390_GOT12:
 200       return &elf_howto_table[(int) R_390_GOT12];
 201     case BFD_RELOC_32_GOT_PCREL:
 202       return &elf_howto_table[(int) R_390_GOT32];
 203     case BFD_RELOC_390_PLT32:
 204       return &elf_howto_table[(int) R_390_PLT32];
 205     case BFD_RELOC_390_COPY:
 206       return &elf_howto_table[(int) R_390_COPY];
 207     case BFD_RELOC_390_GLOB_DAT:
 208       return &elf_howto_table[(int) R_390_GLOB_DAT];
 209     case BFD_RELOC_390_JMP_SLOT:
 210       return &elf_howto_table[(int) R_390_JMP_SLOT];
 211     case BFD_RELOC_390_RELATIVE:
 212       return &elf_howto_table[(int) R_390_RELATIVE];
 213     case BFD_RELOC_32_GOTOFF:
 214       return &elf_howto_table[(int) R_390_GOTOFF32];
 215     case BFD_RELOC_390_GOTPC:
 216       return &elf_howto_table[(int) R_390_GOTPC];
 217     case BFD_RELOC_390_GOT16:
 218       return &elf_howto_table[(int) R_390_GOT16];
 219     case BFD_RELOC_16_PCREL:
 220       return &elf_howto_table[(int) R_390_PC16];
 221     case BFD_RELOC_390_PC12DBL:
 222       return &elf_howto_table[(int) R_390_PC12DBL];
 223     case BFD_RELOC_390_PLT12DBL:
 224       return &elf_howto_table[(int) R_390_PLT12DBL];
 225     case BFD_RELOC_390_PC16DBL:
 226       return &elf_howto_table[(int) R_390_PC16DBL];
 227     case BFD_RELOC_390_PLT16DBL:
 228       return &elf_howto_table[(int) R_390_PLT16DBL];
 229     case BFD_RELOC_390_PC24DBL:
 230       return &elf_howto_table[(int) R_390_PC24DBL];
 231     case BFD_RELOC_390_PLT24DBL:
 232       return &elf_howto_table[(int) R_390_PLT24DBL];
 233     case BFD_RELOC_390_PC32DBL:
 234       return &elf_howto_table[(int) R_390_PC32DBL];
 235     case BFD_RELOC_390_PLT32DBL:
 236       return &elf_howto_table[(int) R_390_PLT32DBL];
 237     case BFD_RELOC_390_GOTPCDBL:
 238       return &elf_howto_table[(int) R_390_GOTPCDBL];
 239     case BFD_RELOC_390_GOTENT:
 240       return &elf_howto_table[(int) R_390_GOTENT];
 241     case BFD_RELOC_16_GOTOFF:
 242       return &elf_howto_table[(int) R_390_GOTOFF16];
 243     case BFD_RELOC_390_GOTPLT12:
 244       return &elf_howto_table[(int) R_390_GOTPLT12];
 245     case BFD_RELOC_390_GOTPLT16:
 246       return &elf_howto_table[(int) R_390_GOTPLT16];
 247     case BFD_RELOC_390_GOTPLT32:
 248       return &elf_howto_table[(int) R_390_GOTPLT32];
 249     case BFD_RELOC_390_GOTPLTENT:
 250       return &elf_howto_table[(int) R_390_GOTPLTENT];
 251     case BFD_RELOC_390_PLTOFF16:
 252       return &elf_howto_table[(int) R_390_PLTOFF16];
 253     case BFD_RELOC_390_PLTOFF32:
 254       return &elf_howto_table[(int) R_390_PLTOFF32];
 255     case BFD_RELOC_390_TLS_LOAD:
 256       return &elf_howto_table[(int) R_390_TLS_LOAD];
 257     case BFD_RELOC_390_TLS_GDCALL:
 258       return &elf_howto_table[(int) R_390_TLS_GDCALL];
 259     case BFD_RELOC_390_TLS_LDCALL:
 260       return &elf_howto_table[(int) R_390_TLS_LDCALL];
 261     case BFD_RELOC_390_TLS_GD32:
 262       return &elf_howto_table[(int) R_390_TLS_GD32];
 263     case BFD_RELOC_390_TLS_GOTIE12:
 264       return &elf_howto_table[(int) R_390_TLS_GOTIE12];
 265     case BFD_RELOC_390_TLS_GOTIE32:
 266       return &elf_howto_table[(int) R_390_TLS_GOTIE32];
 267     case BFD_RELOC_390_TLS_LDM32:
 268       return &elf_howto_table[(int) R_390_TLS_LDM32];
 269     case BFD_RELOC_390_TLS_IE32:
 270       return &elf_howto_table[(int) R_390_TLS_IE32];
 271     case BFD_RELOC_390_TLS_IEENT:
 272       return &elf_howto_table[(int) R_390_TLS_IEENT];
 273     case BFD_RELOC_390_TLS_LE32:
 274       return &elf_howto_table[(int) R_390_TLS_LE32];
 275     case BFD_RELOC_390_TLS_LDO32:
 276       return &elf_howto_table[(int) R_390_TLS_LDO32];
 277     case BFD_RELOC_390_TLS_DTPMOD:
 278       return &elf_howto_table[(int) R_390_TLS_DTPMOD];
 279     case BFD_RELOC_390_TLS_DTPOFF:
 280       return &elf_howto_table[(int) R_390_TLS_DTPOFF];
 281     case BFD_RELOC_390_TLS_TPOFF:
 282       return &elf_howto_table[(int) R_390_TLS_TPOFF];
 283     case BFD_RELOC_390_20:
 284       return &elf_howto_table[(int) R_390_20];
 285     case BFD_RELOC_390_GOT20:
 286       return &elf_howto_table[(int) R_390_GOT20];
 287     case BFD_RELOC_390_GOTPLT20:
 288       return &elf_howto_table[(int) R_390_GOTPLT20];
 289     case BFD_RELOC_390_TLS_GOTIE20:
 290       return &elf_howto_table[(int) R_390_TLS_GOTIE20];
 291     case BFD_RELOC_390_IRELATIVE:
 292       return &elf_howto_table[(int) R_390_IRELATIVE];
 293     case BFD_RELOC_VTABLE_INHERIT:
 294       return &elf32_s390_vtinherit_howto;
 295     case BFD_RELOC_VTABLE_ENTRY:
 296       return &elf32_s390_vtentry_howto;
 297     default:
 298       break;
 299     }
 300   return 0;
 301 }
 302
 303 static reloc_howto_type *
 304 elf_s390_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 305                             const char *r_name)
 306 {
 307   unsigned int i;
 308
 309   for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
 310     if (elf_howto_table[i].name != NULL
 311         && strcasecmp (elf_howto_table[i].name, r_name) == 0)
 312       return &elf_howto_table[i];
 313
 314   if (strcasecmp (elf32_s390_vtinherit_howto.name, r_name) == 0)
 315     return &elf32_s390_vtinherit_howto;
 316   if (strcasecmp (elf32_s390_vtentry_howto.name, r_name) == 0)
 317     return &elf32_s390_vtentry_howto;
 318
 319   return NULL;
 320 }
 321
 322 /* We need to use ELF32_R_TYPE so we have our own copy of this function,
 323    and elf32-s390.c has its own copy.  */
 324
 325 static void
 326 elf_s390_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
 327                         arelent *cache_ptr,
 328                         Elf_Internal_Rela *dst)
 329 {
 330   unsigned int r_type = ELF32_R_TYPE(dst->r_info);
 331   switch (r_type)
 332     {
 333     case R_390_GNU_VTINHERIT:
 334       cache_ptr->howto = &elf32_s390_vtinherit_howto;
 335       break;
 336
 337     case R_390_GNU_VTENTRY:
 338       cache_ptr->howto = &elf32_s390_vtentry_howto;
 339       break;
 340
 341     default:
 342       if (r_type >= sizeof (elf_howto_table) / sizeof (elf_howto_table[0]))
 343         {
 344           (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
 345                                  abfd, (int) r_type);
 346           r_type = R_390_NONE;
 347         }
 348       cache_ptr->howto = &elf_howto_table[r_type];
 349     }
 350 }
 351
 352 /* A relocation function which doesn't do anything.  */
 353 static bfd_reloc_status_type
 354 s390_tls_reloc (bfd *abfd ATTRIBUTE_UNUSED,
 355                 arelent *reloc_entry,
 356                 asymbol *symbol ATTRIBUTE_UNUSED,
 357                 void * data ATTRIBUTE_UNUSED,
 358                 asection *input_section,
 359                 bfd *output_bfd,
 360                 char **error_message ATTRIBUTE_UNUSED)
 361 {
 362   if (output_bfd)
 363     reloc_entry->address += input_section->output_offset;
 364   return bfd_reloc_ok;
 365 }
 366
 367 /* Handle the large displacement relocs.  */
 368 static bfd_reloc_status_type
 369 s390_elf_ldisp_reloc (bfd *abfd ATTRIBUTE_UNUSED,
 370                       arelent *reloc_entry,
 371                       asymbol *symbol,
 372                       void * data ATTRIBUTE_UNUSED,
 373                       asection *input_section,
 374                       bfd *output_bfd,
 375                       char **error_message ATTRIBUTE_UNUSED)
 376 {
 377   reloc_howto_type *howto = reloc_entry->howto;
 378   bfd_vma relocation;
 379   bfd_vma insn;
 380
 381   if (output_bfd != (bfd *) NULL
 382       && (symbol->flags & BSF_SECTION_SYM) == 0
 383       && (! howto->partial_inplace
 384           || reloc_entry->addend == 0))
 385     {
 386       reloc_entry->address += input_section->output_offset;
 387       return bfd_reloc_ok;
 388     }
 389
 390   if (output_bfd != NULL)
 391     return bfd_reloc_continue;
 392
 393   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
 394     return bfd_reloc_outofrange;
 395
 396   relocation = (symbol->value
 397                 + symbol->section->output_section->vma
 398                 + symbol->section->output_offset);
 399   relocation += reloc_entry->addend;
 400   if (howto->pc_relative)
 401     {
 402       relocation -= (input_section->output_section->vma
 403                      + input_section->output_offset);
 404       relocation -= reloc_entry->address;
 405     }
 406
 407   insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
 408   insn |= (relocation & 0xfff) << 16 | (relocation & 0xff000) >> 4;
 409   bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
 410
 411   if ((bfd_signed_vma) relocation < - 0x80000
 412       || (bfd_signed_vma) relocation > 0x7ffff)
 413     return bfd_reloc_overflow;
 414   else
 415     return bfd_reloc_ok;
 416 }
 417
 418 static bfd_boolean
 419 elf_s390_is_local_label_name (bfd *abfd, const char *name)
 420 {
 421   if (name[0] == '.' && (name[1] == 'X' || name[1] == 'L'))
 422     return TRUE;
 423
 424   return _bfd_elf_is_local_label_name (abfd, name);
 425 }
 426
 427 /* Functions for the 390 ELF linker.  */
 428
 429 /* The name of the dynamic interpreter.  This is put in the .interp
 430    section.  */
 431
 432 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
 433
 434 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
 435    copying dynamic variables from a shared lib into an app's dynbss
 436    section, and instead use a dynamic relocation to point into the
 437    shared lib.  */
 438 #define ELIMINATE_COPY_RELOCS 1
 439
 440 /* The size in bytes of the first entry in the procedure linkage table.  */
 441 #define PLT_FIRST_ENTRY_SIZE 32
 442 /* The size in bytes of an entry in the procedure linkage table.  */
 443 #define PLT_ENTRY_SIZE 32
 444
 445 #define GOT_ENTRY_SIZE 4
 446
 447 #define RELA_ENTRY_SIZE sizeof (Elf32_External_Rela)
 448
 449 /* The first three entries in a procedure linkage table are reserved,
 450    and the initial contents are unimportant (we zero them out).
 451    Subsequent entries look like this.  See the SVR4 ABI 386
 452    supplement to see how this works.  */
 453
 454 /* For the s390, simple addr offset can only be 0 - 4096.
 455    To use the full 2 GB address space, several instructions
 456    are needed to load an address in a register and execute
 457    a branch( or just saving the address)
 458
 459    Furthermore, only r 0 and 1 are free to use!!!  */
 460
 461 /* The first 3 words in the GOT are then reserved.
 462    Word 0 is the address of the dynamic table.
 463    Word 1 is a pointer to a structure describing the object
 464    Word 2 is used to point to the loader entry address.
 465
 466    The code for position independent PLT entries looks like this:
 467
 468    r12 holds addr of the current GOT at entry to the PLT
 469
 470    The GOT holds the address in the PLT to be executed.
 471    The loader then gets:
 472    24(15) =  Pointer to the structure describing the object.
 473    28(15) =  Offset into rela.plt
 474
 475    The loader  must  then find the module where the function is
 476    and insert the address in the GOT.
 477
 478   Note: 390 can only address +- 64 K relative.
 479         We check if offset > 65536, then make a relative branch -64xxx
 480         back to a previous defined branch
 481
 482 PLT1: BASR 1,0         # 2 bytes
 483       L    1,22(1)     # 4 bytes  Load offset in GOT in r 1
 484       L    1,(1,12)    # 4 bytes  Load address from GOT in r1
 485       BCR  15,1        # 2 bytes  Jump to address
 486 RET1: BASR 1,0         # 2 bytes  Return from GOT 1st time
 487       L    1,14(1)     # 4 bytes  Load offset in symol table in r1
 488       BRC  15,-x       # 4 bytes  Jump to start of PLT
 489       .word 0          # 2 bytes filler
 490       .long ?          # 4 bytes  offset in GOT
 491       .long ?          # 4 bytes  offset into rela.plt
 492
 493   This was the general case. There are two additional, optimizes PLT
 494   definitions. One for GOT offsets < 4096 and one for GOT offsets < 32768.
 495   First the one for GOT offsets < 4096:
 496
 497 PLT1: L    1,<offset>(12) # 4 bytes  Load address from GOT in R1
 498       BCR  15,1           # 2 bytes  Jump to address
 499       .word 0,0,0         # 6 bytes  filler
 500 RET1: BASR 1,0            # 2 bytes  Return from GOT 1st time
 501       L    1,14(1)        # 4 bytes  Load offset in rela.plt in r1
 502       BRC  15,-x          # 4 bytes  Jump to start of PLT
 503       .word 0,0,0         # 6 bytes  filler
 504       .long ?             # 4 bytes  offset into rela.plt
 505
 506   Second the one for GOT offsets < 32768:
 507
 508 PLT1: LHI  1,<offset>     # 4 bytes  Load offset in GOT to r1
 509       L    1,(1,12)       # 4 bytes  Load address from GOT to r1
 510       BCR  15,1           # 2 bytes  Jump to address
 511       .word 0             # 2 bytes  filler
 512 RET1: BASR 1,0            # 2 bytes  Return from GOT 1st time
 513       L    1,14(1)        # 4 bytes  Load offset in rela.plt in r1
 514       BRC  15,-x          # 4 bytes  Jump to start of PLT
 515       .word 0,0,0         # 6 bytes  filler
 516       .long ?             # 4 bytes  offset into rela.plt
 517
 518 Total = 32 bytes per PLT entry
 519
 520    The code for static build PLT entries looks like this:
 521
 522 PLT1: BASR 1,0         # 2 bytes
 523       L    1,22(1)     # 4 bytes  Load address of GOT entry
 524       L    1,0(0,1)    # 4 bytes  Load address from GOT in r1
 525       BCR  15,1        # 2 bytes  Jump to address
 526 RET1: BASR 1,0         # 2 bytes  Return from GOT 1st time
 527       L    1,14(1)     # 4 bytes  Load offset in symbol table in r1
 528       BRC  15,-x       # 4 bytes  Jump to start of PLT
 529       .word 0          # 2 bytes  filler
 530       .long ?          # 4 bytes  address of GOT entry
 531       .long ?          # 4 bytes  offset into rela.plt  */
 532
 533 static const bfd_byte elf_s390_plt_entry[PLT_ENTRY_SIZE] =
 534   {
 535     0x0d, 0x10,                             /* basr    %r1,%r0     */
 536     0x58, 0x10, 0x10, 0x16,                 /* l       %r1,22(%r1) */
 537     0x58, 0x10, 0x10, 0x00,                 /* l       %r1,0(%r1)  */
 538     0x07, 0xf1,                             /* br      %r1         */
 539     0x0d, 0x10,                             /* basr    %r1,%r0     */
 540     0x58, 0x10, 0x10, 0x0e,                 /* l       %r1,14(%r1) */
 541     0xa7, 0xf4, 0x00, 0x00,                 /* j       first plt   */
 542     0x00, 0x00,                             /* padding             */
 543     0x00, 0x00, 0x00, 0x00,                 /* GOT offset          */
 544     0x00, 0x00, 0x00, 0x00                  /* rela.plt offset     */
 545   };
 546
 547 /* Generic PLT pic entry.  */
 548 static const bfd_byte elf_s390_plt_pic_entry[PLT_ENTRY_SIZE] =
 549   {
 550     0x0d, 0x10,                             /* basr    %r1,%r0         */
 551     0x58, 0x10, 0x10, 0x16,                 /* l       %r1,22(%r1)     */
 552     0x58, 0x11, 0xc0, 0x00,                 /* l       %r1,0(%r1,%r12) */
 553     0x07, 0xf1,                             /* br      %r1             */
 554     0x0d, 0x10,                             /* basr    %r1,%r0         */
 555     0x58, 0x10, 0x10, 0x0e,                 /* l       %r1,14(%r1)     */
 556     0xa7, 0xf4, 0x00, 0x00,                 /* j       first plt       */
 557     0x00, 0x00,                             /* padding                 */
 558     0x00, 0x00, 0x00, 0x00,                 /* GOT offset              */
 559     0x00, 0x00, 0x00, 0x00                  /* rela.plt offset         */
 560   };
 561
 562 /* Optimized PLT pic entry for GOT offset < 4k.  xx will be replaced
 563    when generating the PLT slot with the GOT offset.  */
 564 static const bfd_byte elf_s390_plt_pic12_entry[PLT_ENTRY_SIZE] =
 565   {
 566     0x58, 0x10, 0xc0, 0x00,                 /* l       %r1,xx(%r12) */
 567     0x07, 0xf1,                             /* br      %r1          */
 568     0x00, 0x00, 0x00, 0x00,                 /* padding              */
 569     0x00, 0x00,
 570     0x0d, 0x10,                             /* basr    %r1,%r0      */
 571     0x58, 0x10, 0x10, 0x0e,                 /* l       %r1,14(%r1)  */
 572     0xa7, 0xf4, 0x00, 0x00,                 /* j       first plt    */
 573     0x00, 0x00, 0x00, 0x00,
 574     0x00, 0x00, 0x00, 0x00
 575   };
 576
 577 /* Optimized PLT pic entry for GOT offset < 32k.  xx will be replaced
 578    when generating the PLT slot with the GOT offset.  */
 579 static const bfd_byte elf_s390_plt_pic16_entry[PLT_ENTRY_SIZE] =
 580   {
 581     0xa7, 0x18, 0x00, 0x00,                 /* lhi     %r1,xx          */
 582     0x58, 0x11, 0xc0, 0x00,                 /* l       %r1,0(%r1,%r12) */
 583     0x07, 0xf1,                             /* br      %r1             */
 584     0x00, 0x00,
 585     0x0d, 0x10,                             /* basr    %r1,%r0         */
 586     0x58, 0x10, 0x10, 0x0e,                 /* l       %r1,14(%r1)     */
 587     0xa7, 0xf4, 0x00, 0x00,                 /* j       first plt       */
 588     0x00, 0x00, 0x00, 0x00,
 589     0x00, 0x00, 0x00, 0x00,
 590     0x00, 0x00
 591   };
 592
 593 /* The first PLT entry pushes the offset into the rela.plt
 594    from R1 onto the stack at 8(15) and the loader object info
 595    at 12(15), loads the loader address in R1 and jumps to it.  */
 596
 597 /* The first entry in the PLT for PIC code:
 598
 599 PLT0:
 600    ST   1,28(15)  # R1 has offset into rela.plt
 601    L    1,4(12)   # Get loader ino(object struct address)
 602    ST   1,24(15)  # Store address
 603    L    1,8(12)   # Entry address of loader in R1
 604    BR   1         # Jump to loader
 605
 606    The first entry in the PLT for static code:
 607
 608 PLT0:
 609    ST   1,28(15)      # R1 has offset into rela.plt
 610    BASR 1,0
 611    L    1,18(0,1)     # Get address of GOT
 612    MVC  24(4,15),4(1) # Move loader ino to stack
 613    L    1,8(1)        # Get address of loader
 614    BR   1             # Jump to loader
 615    .word 0            # filler
 616    .long got          # address of GOT  */
 617
 618 static const bfd_byte elf_s390_plt_first_entry[PLT_FIRST_ENTRY_SIZE] =
 619   {
 620     0x50, 0x10, 0xf0, 0x1c,                   /* st      %r1,28(%r15)      */
 621     0x0d, 0x10,                               /* basr    %r1,%r0           */
 622     0x58, 0x10, 0x10, 0x12,                   /* l       %r1,18(%r1)       */
 623     0xd2, 0x03, 0xf0, 0x18, 0x10, 0x04,       /* mvc     24(4,%r15),4(%r1) */
 624     0x58, 0x10, 0x10, 0x08,                   /* l       %r1,8(%r1)        */
 625     0x07, 0xf1,                               /* br      %r1               */
 626     0x00, 0x00, 0x00, 0x00,
 627     0x00, 0x00, 0x00, 0x00,
 628     0x00, 0x00
 629   };
 630
 631 static const bfd_byte elf_s390_plt_pic_first_entry[PLT_FIRST_ENTRY_SIZE] =
 632   {
 633     0x50, 0x10, 0xf0, 0x1c,                     /* st      %r1,28(%r15)  */
 634     0x58, 0x10, 0xc0, 0x04,                     /* l       %r1,4(%r12)   */
 635     0x50, 0x10, 0xf0, 0x18,                     /* st      %r1,24(%r15)  */
 636     0x58, 0x10, 0xc0, 0x08,                     /* l       %r1,8(%r12)   */
 637     0x07, 0xf1,                                 /* br      %r1           */
 638     0x00, 0x00, 0x00, 0x00,
 639     0x00, 0x00, 0x00, 0x00,
 640     0x00, 0x00, 0x00, 0x00,
 641     0x00, 0x00
 642   };
 643
 644
 645 /* s390 ELF linker hash entry.  */
 646
 647 struct elf_s390_link_hash_entry
 648 {
 649   struct elf_link_hash_entry elf;
 650
 651   /* Track dynamic relocs copied for this symbol.  */
 652   struct elf_dyn_relocs *dyn_relocs;
 653
 654   /* Number of GOTPLT references for a function.  */
 655   bfd_signed_vma gotplt_refcount;
 656
 657 #define GOT_UNKNOWN     0
 658 #define GOT_NORMAL      1
 659 #define GOT_TLS_GD      2
 660 #define GOT_TLS_IE      3
 661 #define GOT_TLS_IE_NLT  4
 662   unsigned char tls_type;
 663
 664   /* For pointer equality reasons we might need to change the symbol
 665      type from STT_GNU_IFUNC to STT_FUNC together with its value and
 666      section entry.  So after alloc_dynrelocs only these values should
 667      be used.  In order to check whether a symbol is IFUNC use
 668      s390_is_ifunc_symbol_p.  */
 669   bfd_vma ifunc_resolver_address;
 670   asection *ifunc_resolver_section;
 671 };
 672
 673 #define elf_s390_hash_entry(ent) \
 674   ((struct elf_s390_link_hash_entry *)(ent))
 675
 676 /* This structure represents an entry in the local PLT list needed for
 677    local IFUNC symbols.  */
 678 struct plt_entry
 679 {
 680   /* The section of the local symbol.
 681      Set in relocate_section and used in finish_dynamic_sections.  */
 682   asection *sec;
 683
 684   union
 685   {
 686     bfd_signed_vma refcount;
 687     bfd_vma offset;
 688   } plt;
 689 };
 690
 691 /* NOTE: Keep this structure in sync with
 692    the one declared in elf64-s390.c.  */
 693 struct elf_s390_obj_tdata
 694 {
 695   struct elf_obj_tdata root;
 696
 697   /* A local PLT is needed for ifunc symbols.  */
 698   struct plt_entry *local_plt;
 699
 700   /* TLS type for each local got entry.  */
 701   char *local_got_tls_type;
 702 };
 703
 704 #define elf_s390_tdata(abfd) \
 705   ((struct elf_s390_obj_tdata *) (abfd)->tdata.any)
 706
 707 #define elf_s390_local_plt(abfd)                \
 708   (elf_s390_tdata (abfd)->local_plt)
 709
 710 #define elf_s390_local_got_tls_type(abfd) \
 711   (elf_s390_tdata (abfd)->local_got_tls_type)
 712
 713 #define is_s390_elf(bfd) \
 714   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
 715    && elf_tdata (bfd) != NULL \
 716    && elf_object_id (bfd) == S390_ELF_DATA)
 717
 718 static bfd_boolean
 719 elf_s390_mkobject (bfd *abfd)
 720 {
 721   return bfd_elf_allocate_object (abfd, sizeof (struct elf_s390_obj_tdata),
 722                                   S390_ELF_DATA);
 723 }
 724
 725 static bfd_boolean
 726 elf_s390_object_p (bfd *abfd)
 727 {
 728   /* Set the right machine number for an s390 elf32 file.  */
 729   return bfd_default_set_arch_mach (abfd, bfd_arch_s390, bfd_mach_s390_31);
 730 }
 731
 732 /* s390 ELF linker hash table.  */
 733
 734 struct elf_s390_link_hash_table
 735 {
 736   struct elf_link_hash_table elf;
 737
 738   /* Short-cuts to get to dynamic linker sections.  */
 739   asection *sdynbss;
 740   asection *srelbss;
 741   asection *irelifunc;
 742
 743   union
 744   {
 745     bfd_signed_vma refcount;
 746     bfd_vma offset;
 747   } tls_ldm_got;
 748
 749   /* Small local sym cache.  */
 750   struct sym_cache sym_cache;
 751 };
 752
 753 /* Get the s390 ELF linker hash table from a link_info structure.  */
 754
 755 #define elf_s390_hash_table(p) \
 756   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
 757   == S390_ELF_DATA ? ((struct elf_s390_link_hash_table *) ((p)->hash)) : NULL)
 758
 759 #undef ELF64
 760 #include "elf-s390-common.c"
 761
 762 /* Create an entry in an s390 ELF linker hash table.  */
 763
 764 static struct bfd_hash_entry *
 765 link_hash_newfunc (struct bfd_hash_entry *entry,
 766                    struct bfd_hash_table *table,
 767                    const char *string)
 768 {
 769   /* Allocate the structure if it has not already been allocated by a
 770      subclass.  */
 771   if (entry == NULL)
 772     {
 773       entry = bfd_hash_allocate (table,
 774                                  sizeof (struct elf_s390_link_hash_entry));
 775       if (entry == NULL)
 776         return entry;
 777     }
 778
 779   /* Call the allocation method of the superclass.  */
 780   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
 781   if (entry != NULL)
 782     {
 783       struct elf_s390_link_hash_entry *eh;
 784
 785       eh = (struct elf_s390_link_hash_entry *) entry;
 786       eh->dyn_relocs = NULL;
 787       eh->gotplt_refcount = 0;
 788       eh->tls_type = GOT_UNKNOWN;
 789       eh->ifunc_resolver_address = 0;
 790       eh->ifunc_resolver_section = NULL;
 791     }
 792
 793   return entry;
 794 }
 795
 796 /* Create an s390 ELF linker hash table.  */
 797
 798 static struct bfd_link_hash_table *
 799 elf_s390_link_hash_table_create (bfd *abfd)
 800 {
 801   struct elf_s390_link_hash_table *ret;
 802   bfd_size_type amt = sizeof (struct elf_s390_link_hash_table);
 803
 804   ret = (struct elf_s390_link_hash_table *) bfd_zmalloc (amt);
 805   if (ret == NULL)
 806     return NULL;
 807
 808   if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
 809                                       sizeof (struct elf_s390_link_hash_entry),
 810                                       S390_ELF_DATA))
 811     {
 812       free (ret);
 813       return NULL;
 814     }
 815
 816   return &ret->elf.root;
 817 }
 818
 819 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
 820    shortcuts to them in our hash table.  */
 821
 822 static bfd_boolean
 823 create_got_section (bfd *dynobj, struct bfd_link_info *info)
 824 {
 825   struct elf_s390_link_hash_table *htab;
 826
 827   if (! _bfd_elf_create_got_section (dynobj, info))
 828     return FALSE;
 829
 830   htab = elf_s390_hash_table (info);
 831   htab->elf.sgot = bfd_get_linker_section (dynobj, ".got");
 832   htab->elf.sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
 833   htab->elf.srelgot = bfd_get_linker_section (dynobj, ".rela.got");
 834   if (!htab->elf.sgot || !htab->elf.sgotplt || !htab->elf.srelgot)
 835     abort ();
 836
 837   return TRUE;
 838 }
 839
 840 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
 841    .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
 842    hash table.  */
 843
 844 static bfd_boolean
 845 elf_s390_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
 846 {
 847   struct elf_s390_link_hash_table *htab;
 848
 849   htab = elf_s390_hash_table (info);
 850   if (!htab->elf.sgot && !create_got_section (dynobj, info))
 851     return FALSE;
 852
 853   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
 854     return FALSE;
 855
 856   htab->elf.splt = bfd_get_linker_section (dynobj, ".plt");
 857   htab->elf.srelplt = bfd_get_linker_section (dynobj, ".rela.plt");
 858   htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
 859   if (!bfd_link_pic (info))
 860     htab->srelbss = bfd_get_linker_section (dynobj, ".rela.bss");
 861
 862   if (!htab->elf.splt || !htab->elf.srelplt || !htab->sdynbss
 863       || (!bfd_link_pic (info) && !htab->srelbss))
 864     abort ();
 865
 866   return TRUE;
 867 }
 868
 869 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
 870
 871 static void
 872 elf_s390_copy_indirect_symbol (struct bfd_link_info *info,
 873                                struct elf_link_hash_entry *dir,
 874                                struct elf_link_hash_entry *ind)
 875 {
 876   struct elf_s390_link_hash_entry *edir, *eind;
 877
 878   edir = (struct elf_s390_link_hash_entry *) dir;
 879   eind = (struct elf_s390_link_hash_entry *) ind;
 880
 881   if (eind->dyn_relocs != NULL)
 882     {
 883       if (edir->dyn_relocs != NULL)
 884         {
 885           struct elf_dyn_relocs **pp;
 886           struct elf_dyn_relocs *p;
 887
 888           /* Add reloc counts against the indirect sym to the direct sym
 889              list.  Merge any entries against the same section.  */
 890           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
 891             {
 892               struct elf_dyn_relocs *q;
 893
 894               for (q = edir->dyn_relocs; q != NULL; q = q->next)
 895                 if (q->sec == p->sec)
 896                   {
 897                     q->pc_count += p->pc_count;
 898                     q->count += p->count;
 899                     *pp = p->next;
 900                     break;
 901                   }
 902               if (q == NULL)
 903                 pp = &p->next;
 904             }
 905           *pp = edir->dyn_relocs;
 906         }
 907
 908       edir->dyn_relocs = eind->dyn_relocs;
 909       eind->dyn_relocs = NULL;
 910     }
 911
 912   if (ind->root.type == bfd_link_hash_indirect
 913       && dir->got.refcount <= 0)
 914     {
 915       edir->tls_type = eind->tls_type;
 916       eind->tls_type = GOT_UNKNOWN;
 917     }
 918
 919   if (ELIMINATE_COPY_RELOCS
 920       && ind->root.type != bfd_link_hash_indirect
 921       && dir->dynamic_adjusted)
 922     {
 923       /* If called to transfer flags for a weakdef during processing
 924          of elf_adjust_dynamic_symbol, don't copy non_got_ref.
 925          We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
 926       dir->ref_dynamic |= ind->ref_dynamic;
 927       dir->ref_regular |= ind->ref_regular;
 928       dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
 929       dir->needs_plt |= ind->needs_plt;
 930     }
 931   else
 932     _bfd_elf_link_hash_copy_indirect (info, dir, ind);
 933 }
 934
 935 static int
 936 elf_s390_tls_transition (struct bfd_link_info *info,
 937                          int r_type,
 938                          int is_local)
 939 {
 940   if (bfd_link_pic (info))
 941     return r_type;
 942
 943   switch (r_type)
 944     {
 945     case R_390_TLS_GD32:
 946     case R_390_TLS_IE32:
 947       if (is_local)
 948         return R_390_TLS_LE32;
 949       return R_390_TLS_IE32;
 950     case R_390_TLS_GOTIE32:
 951       if (is_local)
 952         return R_390_TLS_LE32;
 953       return R_390_TLS_GOTIE32;
 954     case R_390_TLS_LDM32:
 955       return R_390_TLS_LE32;
 956     }
 957
 958   return r_type;
 959 }
 960
 961 /* Look through the relocs for a section during the first phase, and
 962    allocate space in the global offset table or procedure linkage
 963    table.  */
 964
 965 static bfd_boolean
 966 elf_s390_check_relocs (bfd *abfd,
 967                        struct bfd_link_info *info,
 968                        asection *sec,
 969                        const Elf_Internal_Rela *relocs)
 970 {
 971   struct elf_s390_link_hash_table *htab;
 972   Elf_Internal_Shdr *symtab_hdr;
 973   struct elf_link_hash_entry **sym_hashes;
 974   const Elf_Internal_Rela *rel;
 975   const Elf_Internal_Rela *rel_end;
 976   asection *sreloc;
 977   bfd_signed_vma *local_got_refcounts;
 978   int tls_type, old_tls_type;
 979   Elf_Internal_Sym *isym;
 980
 981   if (bfd_link_relocatable (info))
 982     return TRUE;
 983
 984   BFD_ASSERT (is_s390_elf (abfd));
 985
 986   htab = elf_s390_hash_table (info);
 987   symtab_hdr = &elf_symtab_hdr (abfd);
 988   sym_hashes = elf_sym_hashes (abfd);
 989   local_got_refcounts = elf_local_got_refcounts (abfd);
 990
 991   sreloc = NULL;
 992
 993   rel_end = relocs + sec->reloc_count;
 994   for (rel = relocs; rel < rel_end; rel++)
 995     {
 996       unsigned int r_type;
 997       unsigned long r_symndx;
 998       struct elf_link_hash_entry *h;
 999
1000       r_symndx = ELF32_R_SYM (rel->r_info);
1001
1002       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1003         {
1004           (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1005                                  abfd, r_symndx);
1006           return FALSE;
1007         }
1008
1009       if (r_symndx < symtab_hdr->sh_info)
1010         {
1011           /* A local symbol.  */
1012           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1013                                         abfd, r_symndx);
1014           if (isym == NULL)
1015             return FALSE;
1016
1017           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1018             {
1019               struct plt_entry *plt;
1020
1021               if (htab->elf.dynobj == NULL)
1022                 htab->elf.dynobj = abfd;
1023
1024               if (!s390_elf_create_ifunc_sections (htab->elf.dynobj, info))
1025                 return FALSE;
1026
1027               if (local_got_refcounts == NULL)
1028                 {
1029                   if (!elf_s390_allocate_local_syminfo (abfd, symtab_hdr))
1030                     return FALSE;
1031                   local_got_refcounts = elf_local_got_refcounts (abfd);
1032                 }
1033               plt = elf_s390_local_plt (abfd);
1034               plt[r_symndx].plt.refcount++;
1035             }
1036           h = NULL;
1037         }
1038       else
1039         {
1040           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1041           while (h->root.type == bfd_link_hash_indirect
1042                  || h->root.type == bfd_link_hash_warning)
1043             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1044
1045           /* PR15323, ref flags aren't set for references in the same
1046              object.  */
1047           h->root.non_ir_ref = 1;
1048         }
1049
1050       /* Create got section and local_got_refcounts array if they
1051          are needed.  */
1052       r_type = elf_s390_tls_transition (info,
1053                                         ELF32_R_TYPE (rel->r_info),
1054                                         h == NULL);
1055       switch (r_type)
1056         {
1057         case R_390_GOT12:
1058         case R_390_GOT16:
1059         case R_390_GOT20:
1060         case R_390_GOT32:
1061         case R_390_GOTENT:
1062         case R_390_GOTPLT12:
1063         case R_390_GOTPLT16:
1064         case R_390_GOTPLT20:
1065         case R_390_GOTPLT32:
1066         case R_390_GOTPLTENT:
1067         case R_390_TLS_GD32:
1068         case R_390_TLS_GOTIE12:
1069         case R_390_TLS_GOTIE20:
1070         case R_390_TLS_GOTIE32:
1071         case R_390_TLS_IEENT:
1072         case R_390_TLS_IE32:
1073         case R_390_TLS_LDM32:
1074           if (h == NULL
1075               && local_got_refcounts == NULL)
1076             {
1077               if (!elf_s390_allocate_local_syminfo (abfd, symtab_hdr))
1078                 return FALSE;
1079               local_got_refcounts = elf_local_got_refcounts (abfd);
1080             }
1081           /* Fall through.  */
1082         case R_390_GOTOFF16:
1083         case R_390_GOTOFF32:
1084         case R_390_GOTPC:
1085         case R_390_GOTPCDBL:
1086           if (htab->elf.sgot == NULL)
1087             {
1088               if (htab->elf.dynobj == NULL)
1089                 htab->elf.dynobj = abfd;
1090               if (!create_got_section (htab->elf.dynobj, info))
1091                 return FALSE;
1092             }
1093         }
1094
1095       if (h != NULL)
1096         {
1097           if (htab->elf.dynobj == NULL)
1098             htab->elf.dynobj = abfd;
1099           if (!s390_elf_create_ifunc_sections (htab->elf.dynobj, info))
1100             return FALSE;
1101
1102           /* Make sure an IFUNC symbol defined in a non-shared object
1103              always gets a PLT slot.  */
1104           if (s390_is_ifunc_symbol_p (h) && h->def_regular)
1105             {
1106               /* The symbol is called by the dynamic loader in order
1107                  to resolve the relocation.  So it is in fact also
1108                  referenced.  */
1109               h->ref_regular = 1;
1110               h->needs_plt = 1;
1111             }
1112         }
1113       switch (r_type)
1114         {
1115         case R_390_GOTOFF16:
1116         case R_390_GOTOFF32:
1117         case R_390_GOTPC:
1118         case R_390_GOTPCDBL:
1119           /* These relocs do not need a GOT slot.  They just load the
1120              GOT pointer itself or address something else relative to
1121              the GOT.  Since the GOT pointer has been set up above we
1122              are done.  */
1123           break;
1124
1125         case R_390_PLT12DBL:
1126         case R_390_PLT16DBL:
1127         case R_390_PLT24DBL:
1128         case R_390_PLT32DBL:
1129         case R_390_PLT32:
1130         case R_390_PLTOFF16:
1131         case R_390_PLTOFF32:
1132           /* This symbol requires a procedure linkage table entry.  We
1133              actually build the entry in adjust_dynamic_symbol,
1134              because this might be a case of linking PIC code which is
1135              never referenced by a dynamic object, in which case we
1136              don't need to generate a procedure linkage table entry
1137              after all.  */
1138
1139           /* If this is a local symbol, we resolve it directly without
1140              creating a procedure linkage table entry.  */
1141           if (h != NULL)
1142             {
1143               h->needs_plt = 1;
1144               h->plt.refcount += 1;
1145             }
1146           break;
1147
1148         case R_390_GOTPLT12:
1149         case R_390_GOTPLT16:
1150         case R_390_GOTPLT20:
1151         case R_390_GOTPLT32:
1152         case R_390_GOTPLTENT:
1153           /* This symbol requires either a procedure linkage table entry
1154              or an entry in the local got. We actually build the entry
1155              in adjust_dynamic_symbol because whether this is really a
1156              global reference can change and with it the fact if we have
1157              to create a plt entry or a local got entry. To be able to
1158              make a once global symbol a local one we have to keep track
1159              of the number of gotplt references that exist for this
1160              symbol.  */
1161           if (h != NULL)
1162             {
1163               ((struct elf_s390_link_hash_entry *) h)->gotplt_refcount++;
1164               h->needs_plt = 1;
1165               h->plt.refcount += 1;
1166             }
1167           else
1168             local_got_refcounts[r_symndx] += 1;
1169           break;
1170
1171         case R_390_TLS_LDM32:
1172           htab->tls_ldm_got.refcount += 1;
1173           break;
1174
1175         case R_390_TLS_IE32:
1176         case R_390_TLS_GOTIE12:
1177         case R_390_TLS_GOTIE20:
1178         case R_390_TLS_GOTIE32:
1179         case R_390_TLS_IEENT:
1180           if (bfd_link_pic (info))
1181             info->flags |= DF_STATIC_TLS;
1182           /* Fall through.  */
1183
1184         case R_390_GOT12:
1185         case R_390_GOT16:
1186         case R_390_GOT20:
1187         case R_390_GOT32:
1188         case R_390_GOTENT:
1189         case R_390_TLS_GD32:
1190           /* This symbol requires a global offset table entry.  */
1191           switch (r_type)
1192             {
1193             default:
1194             case R_390_GOT12:
1195             case R_390_GOT16:
1196             case R_390_GOT20:
1197             case R_390_GOT32:
1198             case R_390_GOTENT:
1199               tls_type = GOT_NORMAL;
1200               break;
1201             case R_390_TLS_GD32:
1202               tls_type = GOT_TLS_GD;
1203               break;
1204             case R_390_TLS_IE32:
1205             case R_390_TLS_GOTIE32:
1206               tls_type = GOT_TLS_IE;
1207               break;
1208             case R_390_TLS_GOTIE12:
1209             case R_390_TLS_GOTIE20:
1210             case R_390_TLS_IEENT:
1211               tls_type = GOT_TLS_IE_NLT;
1212               break;
1213             }
1214
1215           if (h != NULL)
1216             {
1217               h->got.refcount += 1;
1218               old_tls_type = elf_s390_hash_entry(h)->tls_type;
1219             }
1220           else
1221             {
1222               local_got_refcounts[r_symndx] += 1;
1223               old_tls_type = elf_s390_local_got_tls_type (abfd) [r_symndx];
1224             }
1225           /* If a TLS symbol is accessed using IE at least once,
1226              there is no point to use dynamic model for it.  */
1227           if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN)
1228             {
1229               if (old_tls_type == GOT_NORMAL || tls_type == GOT_NORMAL)
1230                 {
1231                   (*_bfd_error_handler)
1232                     (_("%B: `%s' accessed both as normal and thread local symbol"),
1233                      abfd, h->root.root.string);
1234                   return FALSE;
1235                 }
1236               if (old_tls_type > tls_type)
1237                 tls_type = old_tls_type;
1238             }
1239
1240           if (old_tls_type != tls_type)
1241             {
1242               if (h != NULL)
1243                 elf_s390_hash_entry (h)->tls_type = tls_type;
1244               else
1245                 elf_s390_local_got_tls_type (abfd) [r_symndx] = tls_type;
1246             }
1247
1248           if (r_type != R_390_TLS_IE32)
1249             break;
1250           /* Fall through.  */
1251
1252         case R_390_TLS_LE32:
1253           /* For static linking and executables this reloc will be
1254              calculated at linktime otherwise a TLS_TPOFF runtime
1255              reloc will be generated.  */
1256           if (r_type == R_390_TLS_LE32 && bfd_link_pie (info))
1257             break;
1258
1259           if (!bfd_link_pic (info))
1260             break;
1261           info->flags |= DF_STATIC_TLS;
1262           /* Fall through.  */
1263
1264         case R_390_8:
1265         case R_390_16:
1266         case R_390_32:
1267         case R_390_PC16:
1268         case R_390_PC12DBL:
1269         case R_390_PC16DBL:
1270         case R_390_PC24DBL:
1271         case R_390_PC32DBL:
1272         case R_390_PC32:
1273           if (h != NULL)
1274             {
1275               /* If this reloc is in a read-only section, we might
1276                  need a copy reloc.  We can't check reliably at this
1277                  stage whether the section is read-only, as input
1278                  sections have not yet been mapped to output sections.
1279                  Tentatively set the flag for now, and correct in
1280                  adjust_dynamic_symbol.  */
1281               h->non_got_ref = 1;
1282
1283               if (!bfd_link_pic (info))
1284                 {
1285                   /* We may need a .plt entry if the function this reloc
1286                      refers to is in a shared lib.  */
1287                   h->plt.refcount += 1;
1288                 }
1289             }
1290
1291           /* If we are creating a shared library, and this is a reloc
1292              against a global symbol, or a non PC relative reloc
1293              against a local symbol, then we need to copy the reloc
1294              into the shared library.  However, if we are linking with
1295              -Bsymbolic, we do not need to copy a reloc against a
1296              global symbol which is defined in an object we are
1297              including in the link (i.e., DEF_REGULAR is set).  At
1298              this point we have not seen all the input files, so it is
1299              possible that DEF_REGULAR is not set now but will be set
1300              later (it is never cleared).  In case of a weak definition,
1301              DEF_REGULAR may be cleared later by a strong definition in
1302              a shared library. We account for that possibility below by
1303              storing information in the relocs_copied field of the hash
1304              table entry.  A similar situation occurs when creating
1305              shared libraries and symbol visibility changes render the
1306              symbol local.
1307
1308              If on the other hand, we are creating an executable, we
1309              may need to keep relocations for symbols satisfied by a
1310              dynamic library if we manage to avoid copy relocs for the
1311              symbol.  */
1312           if ((bfd_link_pic (info)
1313                && (sec->flags & SEC_ALLOC) != 0
1314                && ((ELF32_R_TYPE (rel->r_info) != R_390_PC16
1315                     && ELF32_R_TYPE (rel->r_info) != R_390_PC12DBL
1316                     && ELF32_R_TYPE (rel->r_info) != R_390_PC16DBL
1317                     && ELF32_R_TYPE (rel->r_info) != R_390_PC24DBL
1318                     && ELF32_R_TYPE (rel->r_info) != R_390_PC32DBL
1319                     && ELF32_R_TYPE (rel->r_info) != R_390_PC32)
1320                    || (h != NULL
1321                        && (! SYMBOLIC_BIND (info, h)
1322                            || h->root.type == bfd_link_hash_defweak
1323                            || !h->def_regular))))
1324               || (ELIMINATE_COPY_RELOCS
1325                   && !bfd_link_pic (info)
1326                   && (sec->flags & SEC_ALLOC) != 0
1327                   && h != NULL
1328                   && (h->root.type == bfd_link_hash_defweak
1329                       || !h->def_regular)))
1330             {
1331               struct elf_dyn_relocs *p;
1332               struct elf_dyn_relocs **head;
1333
1334               /* We must copy these reloc types into the output file.
1335                  Create a reloc section in dynobj and make room for
1336                  this reloc.  */
1337               if (sreloc == NULL)
1338                 {
1339                   if (htab->elf.dynobj == NULL)
1340                     htab->elf.dynobj = abfd;
1341
1342                   sreloc = _bfd_elf_make_dynamic_reloc_section
1343                     (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ TRUE);
1344
1345                   if (sreloc == NULL)
1346                     return FALSE;
1347                 }
1348
1349               /* If this is a global symbol, we count the number of
1350                  relocations we need for this symbol.  */
1351               if (h != NULL)
1352                 {
1353                   head = &((struct elf_s390_link_hash_entry *) h)->dyn_relocs;
1354                 }
1355               else
1356                 {
1357                   /* Track dynamic relocs needed for local syms too.
1358                      We really need local syms available to do this
1359                      easily.  Oh well.  */
1360                   asection *s;
1361                   void *vpp;
1362
1363                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1364                                                 abfd, r_symndx);
1365                   if (isym == NULL)
1366                     return FALSE;
1367
1368                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1369                   if (s == NULL)
1370                     s = sec;
1371
1372                   vpp = &elf_section_data (s)->local_dynrel;
1373                   head = (struct elf_dyn_relocs **) vpp;
1374                 }
1375
1376               p = *head;
1377               if (p == NULL || p->sec != sec)
1378                 {
1379                   bfd_size_type amt = sizeof *p;
1380
1381                   p = ((struct elf_dyn_relocs *)
1382                        bfd_alloc (htab->elf.dynobj, amt));
1383                   if (p == NULL)
1384                     return FALSE;
1385                   p->next = *head;
1386                   *head = p;
1387                   p->sec = sec;
1388                   p->count = 0;
1389                   p->pc_count = 0;
1390                 }
1391
1392               p->count += 1;
1393               if (ELF32_R_TYPE (rel->r_info) == R_390_PC16
1394                   || ELF32_R_TYPE (rel->r_info) == R_390_PC12DBL
1395                   || ELF32_R_TYPE (rel->r_info) == R_390_PC16DBL
1396                   || ELF32_R_TYPE (rel->r_info) == R_390_PC24DBL
1397                   || ELF32_R_TYPE (rel->r_info) == R_390_PC32DBL
1398                   || ELF32_R_TYPE (rel->r_info) == R_390_PC32)
1399                 p->pc_count += 1;
1400             }
1401           break;
1402
1403           /* This relocation describes the C++ object vtable hierarchy.
1404              Reconstruct it for later use during GC.  */
1405         case R_390_GNU_VTINHERIT:
1406           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1407             return FALSE;
1408           break;
1409
1410           /* This relocation describes which C++ vtable entries are actually
1411              used.  Record for later use during GC.  */
1412         case R_390_GNU_VTENTRY:
1413           BFD_ASSERT (h != NULL);
1414           if (h != NULL
1415               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1416             return FALSE;
1417           break;
1418
1419         default:
1420           break;
1421         }
1422     }
1423
1424   return TRUE;
1425 }
1426
1427 /* Return the section that should be marked against GC for a given
1428    relocation.  */
1429
1430 static asection *
1431 elf_s390_gc_mark_hook (asection *sec,
1432                        struct bfd_link_info *info,
1433                        Elf_Internal_Rela *rel,
1434                        struct elf_link_hash_entry *h,
1435                        Elf_Internal_Sym *sym)
1436 {
1437   if (h != NULL)
1438     switch (ELF32_R_TYPE (rel->r_info))
1439       {
1440       case R_390_GNU_VTINHERIT:
1441       case R_390_GNU_VTENTRY:
1442         return NULL;
1443       }
1444   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1445
1446 }
1447
1448 /* Update the got entry reference counts for the section being removed.  */
1449
1450 static bfd_boolean
1451 elf_s390_gc_sweep_hook (bfd *abfd,
1452                         struct bfd_link_info *info,
1453                         asection *sec,
1454                         const Elf_Internal_Rela *relocs)
1455 {
1456   struct elf_s390_link_hash_table *htab;
1457   Elf_Internal_Shdr *symtab_hdr;
1458   struct elf_link_hash_entry **sym_hashes;
1459   bfd_signed_vma *local_got_refcounts;
1460   const Elf_Internal_Rela *rel, *relend;
1461
1462   if (bfd_link_relocatable (info))
1463     return TRUE;
1464
1465   htab = elf_s390_hash_table (info);
1466   if (htab == NULL)
1467     return FALSE;
1468
1469   elf_section_data (sec)->local_dynrel = NULL;
1470
1471   symtab_hdr = &elf_symtab_hdr (abfd);
1472   sym_hashes = elf_sym_hashes (abfd);
1473   local_got_refcounts = elf_local_got_refcounts (abfd);
1474
1475   relend = relocs + sec->reloc_count;
1476   for (rel = relocs; rel < relend; rel++)
1477     {
1478       unsigned long r_symndx;
1479       unsigned int r_type;
1480       struct elf_link_hash_entry *h = NULL;
1481
1482       r_symndx = ELF32_R_SYM (rel->r_info);
1483       if (r_symndx >= symtab_hdr->sh_info)
1484         {
1485           struct elf_s390_link_hash_entry *eh;
1486           struct elf_dyn_relocs **pp;
1487           struct elf_dyn_relocs *p;
1488
1489           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1490           while (h->root.type == bfd_link_hash_indirect
1491                  || h->root.type == bfd_link_hash_warning)
1492             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1493           eh = (struct elf_s390_link_hash_entry *) h;
1494
1495           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1496             if (p->sec == sec)
1497               {
1498                 /* Everything must go for SEC.  */
1499                 *pp = p->next;
1500                 break;
1501               }
1502         }
1503       else
1504         {
1505           Elf_Internal_Sym *isym;
1506
1507           /* A local symbol.  */
1508           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1509                                         abfd, r_symndx);
1510           if (isym == NULL)
1511             return FALSE;
1512
1513           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1514             {
1515               struct plt_entry *plt = elf_s390_local_plt (abfd);
1516               if (plt[r_symndx].plt.refcount > 0)
1517                 plt[r_symndx].plt.refcount--;
1518             }
1519         }
1520
1521       r_type = ELF32_R_TYPE (rel->r_info);
1522       r_type = elf_s390_tls_transition (info, r_type, h != NULL);
1523       switch (r_type)
1524         {
1525         case R_390_TLS_LDM32:
1526           if (elf_s390_hash_table (info)->tls_ldm_got.refcount > 0)
1527             elf_s390_hash_table (info)->tls_ldm_got.refcount -= 1;
1528           break;
1529
1530         case R_390_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 (bfd_link_pic (info))
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 (bfd_link_pic (info))
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 (info, 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 (bfd_link_pic (info)
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 (! bfd_link_pic (info)
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       && !bfd_link_pic (info)
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                && (bfd_link_pic (info)
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 (bfd_link_pic (info))
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 (bfd_link_executable (info))
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 (bfd_link_pic (info))
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 (bfd_link_executable (info))
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 (bfd_link_relocatable (info))
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,
2519                                                           bfd_link_pic (info),
2520                                                           h)
2521                        || (bfd_link_pic (info)
2522                            && SYMBOL_REFERENCES_LOCAL (info, h))
2523                        || (ELF_ST_VISIBILITY (h->other)
2524                            && h->root.type == bfd_link_hash_undefweak))
2525
2526                 {
2527                   /* This is actually a static link, or it is a
2528                      -Bsymbolic link and the symbol is defined
2529                      locally, or the symbol was forced to be local
2530                      because of a version file.  We must initialize
2531                      this entry in the global offset table.  Since the
2532                      offset must always be a multiple of 2, we use the
2533                      least significant bit to record whether we have
2534                      initialized it already.
2535
2536                      When doing a dynamic link, we create a .rel.got
2537                      relocation entry to initialize the value.  This
2538                      is done in the finish_dynamic_symbol routine.  */
2539                   if ((off & 1) != 0)
2540                     off &= ~1;
2541                   else
2542                     {
2543                       bfd_put_32 (output_bfd, relocation,
2544                                   base_got->contents + off);
2545                       h->got.offset |= 1;
2546                     }
2547
2548                   if ((h->def_regular
2549                        && bfd_link_pic (info)
2550                        && SYMBOL_REFERENCES_LOCAL (info, h))
2551                       /* lrl rx,sym@GOTENT -> larl rx, sym */
2552                       && ((r_type == R_390_GOTENT
2553                            && (bfd_get_16 (input_bfd,
2554                                            contents + rel->r_offset - 2)
2555                                & 0xff0f) == 0xc40d)
2556                           /* ly rx, sym@GOT(r12) -> larl rx, sym */
2557                           || (r_type == R_390_GOT20
2558                               && (bfd_get_32 (input_bfd,
2559                                               contents + rel->r_offset - 2)
2560                                   & 0xff00f000) == 0xe300c000
2561                               && bfd_get_8 (input_bfd,
2562                                             contents + rel->r_offset + 3) == 0x58)))
2563                     {
2564                       unsigned short new_insn =
2565                         (0xc000 | (bfd_get_8 (input_bfd,
2566                                               contents + rel->r_offset - 1) & 0xf0));
2567                       bfd_put_16 (output_bfd, new_insn,
2568                                   contents + rel->r_offset - 2);
2569                       r_type = R_390_PC32DBL;
2570                       rel->r_addend = 2;
2571                       howto = elf_howto_table + r_type;
2572                       relocation = h->root.u.def.value
2573                         + h->root.u.def.section->output_section->vma
2574                         + h->root.u.def.section->output_offset;
2575                       goto do_relocation;
2576                     }
2577                 }
2578               else
2579                 unresolved_reloc = FALSE;
2580             }
2581           else
2582             {
2583               if (local_got_offsets == NULL)
2584                 abort ();
2585
2586               off = local_got_offsets[r_symndx];
2587
2588               /* The offset must always be a multiple of 4.  We use
2589                  the least significant bit to record whether we have
2590                  already generated the necessary reloc.  */
2591               if ((off & 1) != 0)
2592                 off &= ~1;
2593               else
2594                 {
2595                   bfd_put_32 (output_bfd, relocation,
2596                               htab->elf.sgot->contents + off);
2597
2598                   if (bfd_link_pic (info))
2599                     {
2600                       asection *srelgot;
2601                       Elf_Internal_Rela outrel;
2602                       bfd_byte *loc;
2603
2604                       srelgot = htab->elf.srelgot;
2605                       if (srelgot == NULL)
2606                         abort ();
2607
2608                       outrel.r_offset = (htab->elf.sgot->output_section->vma
2609                                          + htab->elf.sgot->output_offset
2610                                          + off);
2611                       outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2612                       outrel.r_addend = relocation;
2613                       loc = srelgot->contents;
2614                       loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
2615                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2616                     }
2617
2618                   local_got_offsets[r_symndx] |= 1;
2619                 }
2620             }
2621
2622           if (off >= (bfd_vma) -2)
2623             abort ();
2624
2625           relocation = base_got->output_offset + off;
2626
2627           /* For @GOTENT the relocation is against the offset between
2628              the instruction and the symbols entry in the GOT and not
2629              between the start of the GOT and the symbols entry. We
2630              add the vma of the GOT to get the correct value.  */
2631           if (   r_type == R_390_GOTENT
2632               || r_type == R_390_GOTPLTENT)
2633             relocation += base_got->output_section->vma;
2634
2635           break;
2636
2637         case R_390_GOTOFF16:
2638         case R_390_GOTOFF32:
2639           /* Relocation is relative to the start of the global offset
2640              table.  */
2641
2642           /* Note that sgot->output_offset is not involved in this
2643              calculation.  We always want the start of .got.  If we
2644              defined _GLOBAL_OFFSET_TABLE in a different way, as is
2645              permitted by the ABI, we might have to change this
2646              calculation.  */
2647           relocation -= htab->elf.sgot->output_section->vma;
2648           break;
2649
2650         case R_390_GOTPC:
2651         case R_390_GOTPCDBL:
2652           /* Use global offset table as symbol value.  */
2653           relocation = htab->elf.sgot->output_section->vma;
2654           unresolved_reloc = FALSE;
2655           break;
2656
2657         case R_390_PLT12DBL:
2658         case R_390_PLT16DBL:
2659         case R_390_PLT24DBL:
2660         case R_390_PLT32DBL:
2661         case R_390_PLT32:
2662           /* Relocation is to the entry for this symbol in the
2663              procedure linkage table.  */
2664
2665           /* Resolve a PLT32 reloc against a local symbol directly,
2666              without using the procedure linkage table.  */
2667           if (h == NULL)
2668             break;
2669
2670           if (h->plt.offset == (bfd_vma) -1
2671               || (htab->elf.splt == NULL && htab->elf.iplt == NULL))
2672             {
2673               /* We didn't make a PLT entry for this symbol.  This
2674                  happens when statically linking PIC code, or when
2675                  using -Bsymbolic.  */
2676               break;
2677             }
2678
2679           if (s390_is_ifunc_symbol_p (h))
2680             relocation = (htab->elf.iplt->output_section->vma
2681                           + htab->elf.iplt->output_offset
2682                           + h->plt.offset);
2683           else
2684             relocation = (htab->elf.splt->output_section->vma
2685                           + htab->elf.splt->output_offset
2686                           + h->plt.offset);
2687           unresolved_reloc = FALSE;
2688           break;
2689
2690         case R_390_PLTOFF16:
2691         case R_390_PLTOFF32:
2692           /* Relocation is to the entry for this symbol in the
2693              procedure linkage table relative to the start of the GOT.  */
2694
2695           /* For local symbols or if we didn't make a PLT entry for
2696              this symbol resolve the symbol directly.  */
2697           if (h == NULL
2698               || h->plt.offset == (bfd_vma) -1
2699               || (htab->elf.splt == NULL && !s390_is_ifunc_symbol_p (h)))
2700             {
2701               relocation -= htab->elf.sgot->output_section->vma;
2702               break;
2703             }
2704
2705           if (s390_is_ifunc_symbol_p (h))
2706             relocation = (htab->elf.iplt->output_section->vma
2707                           + htab->elf.iplt->output_offset
2708                           + h->plt.offset
2709                           - htab->elf.sgot->output_section->vma);
2710           else
2711             relocation = (htab->elf.splt->output_section->vma
2712                           + htab->elf.splt->output_offset
2713                           + h->plt.offset
2714                           - htab->elf.sgot->output_section->vma);
2715           unresolved_reloc = FALSE;
2716           break;
2717
2718         case R_390_8:
2719         case R_390_16:
2720         case R_390_32:
2721         case R_390_PC16:
2722         case R_390_PC12DBL:
2723         case R_390_PC16DBL:
2724         case R_390_PC24DBL:
2725         case R_390_PC32DBL:
2726         case R_390_PC32:
2727           if (h != NULL
2728               && s390_is_ifunc_symbol_p (h)
2729               && h->def_regular)
2730             {
2731               if (!bfd_link_pic (info) || !h->non_got_ref)
2732                 {
2733                   /* For a non-shared object STT_GNU_IFUNC symbol must
2734                      go through PLT.  */
2735                   relocation = (htab->elf.iplt->output_section->vma
2736                                 + htab->elf.iplt->output_offset
2737                                 + h ->plt.offset);
2738                   goto do_relocation;
2739                 }
2740               else
2741                 {
2742                   /* For shared objects a runtime relocation is needed.  */
2743
2744                   Elf_Internal_Rela outrel;
2745                   asection *sreloc;
2746
2747                   /* Need a dynamic relocation to get the real function
2748                      address.  */
2749                   outrel.r_offset = _bfd_elf_section_offset (output_bfd,
2750                                                              info,
2751                                                              input_section,
2752                                                              rel->r_offset);
2753                   if (outrel.r_offset == (bfd_vma) -1
2754                       || outrel.r_offset == (bfd_vma) -2)
2755                     abort ();
2756
2757                   outrel.r_offset += (input_section->output_section->vma
2758                                       + input_section->output_offset);
2759
2760                   if (h->dynindx == -1
2761                       || h->forced_local
2762                       || bfd_link_executable (info))
2763                     {
2764                       /* This symbol is resolved locally.  */
2765                       outrel.r_info = ELF32_R_INFO (0, R_390_IRELATIVE);
2766                       outrel.r_addend = (h->root.u.def.value
2767                                          + h->root.u.def.section->output_section->vma
2768                                          + h->root.u.def.section->output_offset);
2769                     }
2770                   else
2771                     {
2772                       outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2773                       outrel.r_addend = 0;
2774                     }
2775
2776                   sreloc = htab->elf.irelifunc;
2777                   elf_append_rela (output_bfd, sreloc, &outrel);
2778
2779                   /* If this reloc is against an external symbol, we
2780                      do not want to fiddle with the addend.  Otherwise,
2781                      we need to include the symbol value so that it
2782                      becomes an addend for the dynamic reloc.  For an
2783                      internal symbol, we have updated addend.  */
2784                   continue;
2785                 }
2786             }
2787
2788           if ((input_section->flags & SEC_ALLOC) == 0)
2789             break;
2790
2791           if ((bfd_link_pic (info)
2792                && (h == NULL
2793                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2794                    || h->root.type != bfd_link_hash_undefweak)
2795                && ((r_type != R_390_PC16
2796                     && r_type != R_390_PC12DBL
2797                     && r_type != R_390_PC16DBL
2798                     && r_type != R_390_PC24DBL
2799                     && r_type != R_390_PC32DBL
2800                     && r_type != R_390_PC32)
2801                    || !SYMBOL_CALLS_LOCAL (info, h)))
2802               || (ELIMINATE_COPY_RELOCS
2803                   && !bfd_link_pic (info)
2804                   && h != NULL
2805                   && h->dynindx != -1
2806                   && !h->non_got_ref
2807                   && ((h->def_dynamic
2808                        && !h->def_regular)
2809                       || h->root.type == bfd_link_hash_undefweak
2810                       || h->root.type == bfd_link_hash_undefined)))
2811             {
2812               Elf_Internal_Rela outrel;
2813               bfd_boolean skip, relocate;
2814               asection *sreloc;
2815               bfd_byte *loc;
2816
2817               /* When generating a shared object, these relocations
2818                  are copied into the output file to be resolved at run
2819                  time.  */
2820
2821               skip = FALSE;
2822               relocate = FALSE;
2823
2824               outrel.r_offset =
2825                 _bfd_elf_section_offset (output_bfd, info, input_section,
2826                                          rel->r_offset);
2827               if (outrel.r_offset == (bfd_vma) -1)
2828                 skip = TRUE;
2829               else if (outrel.r_offset == (bfd_vma) -2)
2830                 skip = TRUE, relocate = TRUE;
2831               outrel.r_offset += (input_section->output_section->vma
2832                                   + input_section->output_offset);
2833
2834               if (skip)
2835                 memset (&outrel, 0, sizeof outrel);
2836               else if (h != NULL
2837                        && h->dynindx != -1
2838                        && (r_type == R_390_PC16
2839                            || r_type == R_390_PC12DBL
2840                            || r_type == R_390_PC16DBL
2841                            || r_type == R_390_PC24DBL
2842                            || r_type == R_390_PC32DBL
2843                            || r_type == R_390_PC32
2844                            || !bfd_link_pic (info)
2845                            || !SYMBOLIC_BIND (info, h)
2846                            || !h->def_regular))
2847                 {
2848                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2849                   outrel.r_addend = rel->r_addend;
2850                 }
2851               else
2852                 {
2853                   /* This symbol is local, or marked to become local.  */
2854                   outrel.r_addend = relocation + rel->r_addend;
2855                   if (r_type == R_390_32)
2856                     {
2857                       relocate = TRUE;
2858                       outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2859                     }
2860                   else
2861                     {
2862                       long sindx;
2863
2864                       if (bfd_is_abs_section (sec))
2865                         sindx = 0;
2866                       else if (sec == NULL || sec->owner == NULL)
2867                         {
2868                           bfd_set_error(bfd_error_bad_value);
2869                           return FALSE;
2870                         }
2871                       else
2872                         {
2873                           asection *osec;
2874
2875                           osec = sec->output_section;
2876                           sindx = elf_section_data (osec)->dynindx;
2877                           if (sindx == 0)
2878                             {
2879                               osec = htab->elf.text_index_section;
2880                               sindx = elf_section_data (osec)->dynindx;
2881                             }
2882                           BFD_ASSERT (sindx != 0);
2883
2884                           /* We are turning this relocation into one
2885                              against a section symbol, so subtract out
2886                              the output section's address but not the
2887                              offset of the input section in the output
2888                              section.  */
2889                           outrel.r_addend -= osec->vma;
2890                         }
2891                       outrel.r_info = ELF32_R_INFO (sindx, r_type);
2892                     }
2893                 }
2894
2895               sreloc = elf_section_data (input_section)->sreloc;
2896               if (sreloc == NULL)
2897                 abort ();
2898
2899               loc = sreloc->contents;
2900               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2901               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2902
2903               /* If this reloc is against an external symbol, we do
2904                  not want to fiddle with the addend.  Otherwise, we
2905                  need to include the symbol value so that it becomes
2906                  an addend for the dynamic reloc.  */
2907               if (! relocate)
2908                 continue;
2909             }
2910           break;
2911
2912           /* Relocations for tls literal pool entries.  */
2913         case R_390_TLS_IE32:
2914           if (bfd_link_pic (info))
2915             {
2916               Elf_Internal_Rela outrel;
2917               asection *sreloc;
2918               bfd_byte *loc;
2919
2920               outrel.r_offset = rel->r_offset
2921                                 + input_section->output_section->vma
2922                                 + input_section->output_offset;
2923               outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2924               sreloc = elf_section_data (input_section)->sreloc;
2925               if (sreloc == NULL)
2926                 abort ();
2927               loc = sreloc->contents;
2928               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2929               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2930             }
2931           /* Fall through.  */
2932
2933         case R_390_TLS_GD32:
2934         case R_390_TLS_GOTIE32:
2935           r_type = elf_s390_tls_transition (info, r_type, h == NULL);
2936           tls_type = GOT_UNKNOWN;
2937           if (h == NULL && local_got_offsets)
2938             tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
2939           else if (h != NULL)
2940             {
2941               tls_type = elf_s390_hash_entry(h)->tls_type;
2942               if (!bfd_link_pic (info)
2943                   && h->dynindx == -1
2944                   && tls_type >= GOT_TLS_IE)
2945                 r_type = R_390_TLS_LE32;
2946             }
2947           if (r_type == R_390_TLS_GD32 && tls_type >= GOT_TLS_IE)
2948             r_type = R_390_TLS_IE32;
2949
2950           if (r_type == R_390_TLS_LE32)
2951             {
2952               /* This relocation gets optimized away by the local exec
2953                  access optimization.  */
2954               BFD_ASSERT (! unresolved_reloc);
2955               bfd_put_32 (output_bfd, -tpoff (info, relocation),
2956                           contents + rel->r_offset);
2957               continue;
2958             }
2959
2960           if (htab->elf.sgot == NULL)
2961             abort ();
2962
2963           if (h != NULL)
2964             off = h->got.offset;
2965           else
2966             {
2967               if (local_got_offsets == NULL)
2968                 abort ();
2969
2970               off = local_got_offsets[r_symndx];
2971             }
2972
2973         emit_tls_relocs:
2974
2975           if ((off & 1) != 0)
2976             off &= ~1;
2977           else
2978             {
2979               Elf_Internal_Rela outrel;
2980               bfd_byte *loc;
2981               int dr_type, indx;
2982
2983               if (htab->elf.srelgot == NULL)
2984                 abort ();
2985
2986               outrel.r_offset = (htab->elf.sgot->output_section->vma
2987                                  + htab->elf.sgot->output_offset + off);
2988
2989               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2990               if (r_type == R_390_TLS_GD32)
2991                 dr_type = R_390_TLS_DTPMOD;
2992               else
2993                 dr_type = R_390_TLS_TPOFF;
2994               if (dr_type == R_390_TLS_TPOFF && indx == 0)
2995                 outrel.r_addend = relocation - dtpoff_base (info);
2996               else
2997                 outrel.r_addend = 0;
2998               outrel.r_info = ELF32_R_INFO (indx, dr_type);
2999               loc = htab->elf.srelgot->contents;
3000               loc += htab->elf.srelgot->reloc_count++
3001                 * sizeof (Elf32_External_Rela);
3002               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3003
3004               if (r_type == R_390_TLS_GD32)
3005                 {
3006                   if (indx == 0)
3007                     {
3008                       BFD_ASSERT (! unresolved_reloc);
3009                       bfd_put_32 (output_bfd,
3010                                   relocation - dtpoff_base (info),
3011                                   htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3012                     }
3013                   else
3014                     {
3015                       outrel.r_info = ELF32_R_INFO (indx, R_390_TLS_DTPOFF);
3016                       outrel.r_offset += GOT_ENTRY_SIZE;
3017                       outrel.r_addend = 0;
3018                       htab->elf.srelgot->reloc_count++;
3019                       loc += sizeof (Elf32_External_Rela);
3020                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3021                     }
3022                 }
3023
3024               if (h != NULL)
3025                 h->got.offset |= 1;
3026               else
3027                 local_got_offsets[r_symndx] |= 1;
3028             }
3029
3030           if (off >= (bfd_vma) -2)
3031             abort ();
3032           if (r_type == ELF32_R_TYPE (rel->r_info))
3033             {
3034               relocation = htab->elf.sgot->output_offset + off;
3035               if (r_type == R_390_TLS_IE32 || r_type == R_390_TLS_IEENT)
3036                 relocation += htab->elf.sgot->output_section->vma;
3037               unresolved_reloc = FALSE;
3038             }
3039           else
3040             {
3041               bfd_put_32 (output_bfd, htab->elf.sgot->output_offset + off,
3042                           contents + rel->r_offset);
3043               continue;
3044             }
3045           break;
3046
3047         case R_390_TLS_GOTIE12:
3048         case R_390_TLS_GOTIE20:
3049         case R_390_TLS_IEENT:
3050           if (h == NULL)
3051             {
3052               if (local_got_offsets == NULL)
3053                 abort();
3054               off = local_got_offsets[r_symndx];
3055               if (bfd_link_pic (info))
3056                 goto emit_tls_relocs;
3057             }
3058           else
3059             {
3060               off = h->got.offset;
3061               tls_type = elf_s390_hash_entry(h)->tls_type;
3062               if (bfd_link_pic (info)
3063                   || h->dynindx != -1
3064                   || tls_type < GOT_TLS_IE)
3065                 goto emit_tls_relocs;
3066             }
3067
3068           if (htab->elf.sgot == NULL)
3069             abort ();
3070
3071           BFD_ASSERT (! unresolved_reloc);
3072           bfd_put_32 (output_bfd, -tpoff (info, relocation),
3073                       htab->elf.sgot->contents + off);
3074           relocation = htab->elf.sgot->output_offset + off;
3075           if (r_type == R_390_TLS_IEENT)
3076             relocation += htab->elf.sgot->output_section->vma;
3077           unresolved_reloc = FALSE;
3078           break;
3079
3080         case R_390_TLS_LDM32:
3081           if (! bfd_link_pic (info))
3082             /* The literal pool entry this relocation refers to gets ignored
3083                by the optimized code of the local exec model. Do nothing
3084                and the value will turn out zero.  */
3085             continue;
3086
3087           if (htab->elf.sgot == NULL)
3088             abort ();
3089
3090           off = htab->tls_ldm_got.offset;
3091           if (off & 1)
3092             off &= ~1;
3093           else
3094             {
3095               Elf_Internal_Rela outrel;
3096               bfd_byte *loc;
3097
3098               if (htab->elf.srelgot == NULL)
3099                 abort ();
3100
3101               outrel.r_offset = (htab->elf.sgot->output_section->vma
3102                                  + htab->elf.sgot->output_offset + off);
3103
3104               bfd_put_32 (output_bfd, 0,
3105                           htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3106               outrel.r_info = ELF32_R_INFO (0, R_390_TLS_DTPMOD);
3107               outrel.r_addend = 0;
3108               loc = htab->elf.srelgot->contents;
3109               loc += htab->elf.srelgot->reloc_count++
3110                 * sizeof (Elf32_External_Rela);
3111               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3112               htab->tls_ldm_got.offset |= 1;
3113             }
3114           relocation = htab->elf.sgot->output_offset + off;
3115           unresolved_reloc = FALSE;
3116           break;
3117
3118         case R_390_TLS_LE32:
3119           if (bfd_link_dll (info))
3120             {
3121               /* Linking a shared library with non-fpic code requires
3122                  a R_390_TLS_TPOFF relocation.  */
3123               Elf_Internal_Rela outrel;
3124               asection *sreloc;
3125               bfd_byte *loc;
3126               int indx;
3127
3128               outrel.r_offset = rel->r_offset
3129                                 + input_section->output_section->vma
3130                                 + input_section->output_offset;
3131               if (h != NULL && h->dynindx != -1)
3132                 indx = h->dynindx;
3133               else
3134                 indx = 0;
3135               outrel.r_info = ELF32_R_INFO (indx, R_390_TLS_TPOFF);
3136               if (indx == 0)
3137                 outrel.r_addend = relocation - dtpoff_base (info);
3138               else
3139                 outrel.r_addend = 0;
3140               sreloc = elf_section_data (input_section)->sreloc;
3141               if (sreloc == NULL)
3142                 abort ();
3143               loc = sreloc->contents;
3144               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
3145               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3146             }
3147           else
3148             {
3149               BFD_ASSERT (! unresolved_reloc);
3150               bfd_put_32 (output_bfd, -tpoff (info, relocation),
3151                           contents + rel->r_offset);
3152             }
3153           continue;
3154
3155         case R_390_TLS_LDO32:
3156           if (bfd_link_pic (info) || (input_section->flags & SEC_DEBUGGING))
3157             relocation -= dtpoff_base (info);
3158           else
3159             /* When converting LDO to LE, we must negate.  */
3160             relocation = -tpoff (info, relocation);
3161           break;
3162
3163           /* Relocations for tls instructions.  */
3164         case R_390_TLS_LOAD:
3165         case R_390_TLS_GDCALL:
3166         case R_390_TLS_LDCALL:
3167           tls_type = GOT_UNKNOWN;
3168           if (h == NULL && local_got_offsets)
3169             tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
3170           else if (h != NULL)
3171             tls_type = elf_s390_hash_entry(h)->tls_type;
3172
3173           if (tls_type == GOT_TLS_GD)
3174             continue;
3175
3176           if (r_type == R_390_TLS_LOAD)
3177             {
3178               if (!bfd_link_pic (info) && (h == NULL || h->dynindx == -1))
3179                 {
3180                   /* IE->LE transition. Four valid cases:
3181                      l %rx,0(0,%ry)    -> lr %rx,%ry + bcr 0,0
3182                      l %rx,0(%ry,0)    -> lr %rx,%ry + bcr 0,0
3183                      l %rx,0(%ry,%r12) -> lr %rx,%ry + bcr 0,0
3184                      l %rx,0(%r12,%ry) -> lr %rx,%ry + bcr 0,0 */
3185                   unsigned int insn, ry;
3186
3187                   insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3188                   ry = 0;
3189                   if ((insn & 0xff00f000) == 0x58000000)
3190                     /* l %rx,0(%ry,0) -> lr %rx,%ry + bcr 0,0  */
3191                     ry = (insn & 0x000f0000);
3192                   else if ((insn & 0xff0f0000) == 0x58000000)
3193                     /* l %rx,0(0,%ry) -> lr %rx,%ry + bcr 0,0  */
3194                     ry = (insn & 0x0000f000) << 4;
3195                   else if ((insn & 0xff00f000) == 0x5800c000)
3196                     /* l %rx,0(%ry,%r12) -> lr %rx,%ry + bcr 0,0  */
3197                     ry = (insn & 0x000f0000);
3198                   else if ((insn & 0xff0f0000) == 0x580c0000)
3199                     /* l %rx,0(%r12,%ry) -> lr %rx,%ry + bcr 0,0  */
3200                     ry = (insn & 0x0000f000) << 4;
3201                   else
3202                     invalid_tls_insn (input_bfd, input_section, rel);
3203                   insn = 0x18000700 | (insn & 0x00f00000) | ry;
3204                   bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3205                 }
3206             }
3207           else if (r_type == R_390_TLS_GDCALL)
3208             {
3209               unsigned int insn;
3210
3211               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3212               if ((insn & 0xff000fff) != 0x4d000000 &&
3213                   (insn & 0xffff0000) != 0xc0e50000 &&
3214                   (insn & 0xff000000) != 0x0d000000)
3215                 invalid_tls_insn (input_bfd, input_section, rel);
3216               if (!bfd_link_pic (info) && (h == NULL || h->dynindx == -1))
3217                 {
3218                   if ((insn & 0xff000000) == 0x0d000000)
3219                     {
3220                       /* GD->LE transition.
3221                          basr rx, ry -> nopr r7 */
3222                       insn = 0x07070000 | (insn & 0xffff);
3223                     }
3224                   else if ((insn & 0xff000000) == 0x4d000000)
3225                     {
3226                       /* GD->LE transition.
3227                          bas %r14,0(%rx,%r13) -> bc 0,0  */
3228                       insn = 0x47000000;
3229                     }
3230                   else
3231                     {
3232                       /* GD->LE transition.
3233                          brasl %r14,_tls_get_offset@plt -> brcl 0,.  */
3234                       insn = 0xc0040000;
3235                       bfd_put_16 (output_bfd, 0x0000,
3236                                   contents + rel->r_offset + 4);
3237                     }
3238                 }
3239               else
3240                 {
3241                   /* If basr is used in the pic case to invoke
3242                      _tls_get_offset, something went wrong before.  */
3243                   if ((insn & 0xff000000) == 0x0d000000)
3244                     invalid_tls_insn (input_bfd, input_section, rel);
3245
3246                   if ((insn & 0xff000000) == 0x4d000000)
3247                     {
3248                       /* GD->IE transition.
3249                          bas %r14,0(%rx,%r13) -> l %r2,0(%r2,%r12)  */
3250                       insn = 0x5822c000;
3251                     }
3252                   else
3253                     {
3254                       /* GD->IE transition.
3255                          brasl %r14,__tls_get_addr@plt ->
3256                                 l %r2,0(%r2,%r12) ; bcr 0,0 */
3257                       insn = 0x5822c000;
3258                       bfd_put_16 (output_bfd, 0x0700,
3259                                   contents + rel->r_offset + 4);
3260                     }
3261                 }
3262               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3263             }
3264           else if (r_type == R_390_TLS_LDCALL)
3265             {
3266               if (!bfd_link_pic (info))
3267                 {
3268                   unsigned int insn;
3269
3270                   insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3271                   if ((insn & 0xff000fff) != 0x4d000000 &&
3272                       (insn & 0xffff0000) != 0xc0e50000 &&
3273                       (insn & 0xff000000) != 0x0d000000)
3274                     invalid_tls_insn (input_bfd, input_section, rel);
3275
3276                   if ((insn & 0xff000000) == 0x0d000000)
3277                     {
3278                       /* LD->LE transition.
3279                          basr rx, ry -> nopr r7 */
3280                       insn = 0x07070000 | (insn & 0xffff);
3281                     }
3282                   else if ((insn & 0xff000000) == 0x4d000000)
3283                     {
3284                       /* LD->LE transition.
3285                          bas %r14,0(%rx,%r13) -> bc 0,0  */
3286                       insn = 0x47000000;
3287                     }
3288                   else
3289                     {
3290                       /* LD->LE transition.
3291                          brasl %r14,__tls_get_offset@plt -> brcl 0,. */
3292                       insn = 0xc0040000;
3293                       bfd_put_16 (output_bfd, 0x0000,
3294                                   contents + rel->r_offset + 4);
3295                     }
3296                   bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3297                 }
3298             }
3299           continue;
3300
3301         default:
3302           break;
3303         }
3304
3305       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3306          because such sections are not SEC_ALLOC and thus ld.so will
3307          not process them.  */
3308       if (unresolved_reloc
3309           && !((input_section->flags & SEC_DEBUGGING) != 0
3310                && h->def_dynamic)
3311           && _bfd_elf_section_offset (output_bfd, info, input_section,
3312                                       rel->r_offset) != (bfd_vma) -1)
3313         (*_bfd_error_handler)
3314           (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3315            input_bfd,
3316            input_section,
3317            (long) rel->r_offset,
3318            howto->name,
3319            h->root.root.string);
3320
3321     do_relocation:
3322
3323       /* When applying a 24 bit reloc we need to start one byte
3324          earlier.  Otherwise the 32 bit get/put bfd operations might
3325          access a byte after the actual section.  */
3326       if (r_type == R_390_PC24DBL
3327           || r_type == R_390_PLT24DBL)
3328         rel->r_offset--;
3329
3330       if (r_type == R_390_20
3331           || r_type == R_390_GOT20
3332           || r_type == R_390_GOTPLT20
3333           || r_type == R_390_TLS_GOTIE20)
3334         {
3335           relocation += rel->r_addend;
3336           relocation = (relocation&0xfff) << 8 | (relocation&0xff000) >> 12;
3337           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3338                                         contents, rel->r_offset,
3339                                         relocation, 0);
3340         }
3341       else
3342         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3343                                       contents, rel->r_offset,
3344                                       relocation, rel->r_addend);
3345
3346       if (r != bfd_reloc_ok)
3347         {
3348           const char *name;
3349
3350           if (h != NULL)
3351             name = h->root.root.string;
3352           else
3353             {
3354               name = bfd_elf_string_from_elf_section (input_bfd,
3355                                                       symtab_hdr->sh_link,
3356                                                       sym->st_name);
3357               if (name == NULL)
3358                 return FALSE;
3359               if (*name == '\0')
3360                 name = bfd_section_name (input_bfd, sec);
3361             }
3362
3363           if (r == bfd_reloc_overflow)
3364             {
3365
3366               if (! ((*info->callbacks->reloc_overflow)
3367                      (info, (h ? &h->root : NULL), name, howto->name,
3368                       (bfd_vma) 0, input_bfd, input_section,
3369                       rel->r_offset)))
3370                 return FALSE;
3371             }
3372           else
3373             {
3374               (*_bfd_error_handler)
3375                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3376                  input_bfd, input_section,
3377                  (long) rel->r_offset, name, (int) r);
3378               return FALSE;
3379             }
3380         }
3381     }
3382
3383   return TRUE;
3384 }
3385
3386 /* Generate the PLT slots together with the dynamic relocations needed
3387    for IFUNC symbols.  */
3388
3389 static void
3390 elf_s390_finish_ifunc_symbol (bfd *output_bfd,
3391                               struct bfd_link_info *info,
3392                               struct elf_link_hash_entry *h,
3393                               struct elf_s390_link_hash_table *htab,
3394                               bfd_vma iplt_offset,
3395                               bfd_vma resolver_address)
3396 {
3397   bfd_vma iplt_index;
3398   bfd_vma got_offset;
3399   bfd_vma igotiplt_offset;
3400   Elf_Internal_Rela rela;
3401   bfd_byte *loc;
3402   asection *plt, *gotplt, *relplt;
3403   bfd_vma relative_offset;
3404
3405   if (htab->elf.iplt == NULL
3406       || htab->elf.igotplt == NULL
3407       || htab->elf.irelplt == NULL)
3408     abort ();
3409
3410   gotplt = htab->elf.igotplt;
3411   relplt = htab->elf.irelplt;
3412
3413   /* Index of the PLT slot within iplt section.  */
3414   iplt_index = iplt_offset / PLT_ENTRY_SIZE;
3415   plt = htab->elf.iplt;
3416   /* Offset into the igot.plt section.  */
3417   igotiplt_offset = iplt_index * GOT_ENTRY_SIZE;
3418   /* Offset into the got section.  */
3419   got_offset = igotiplt_offset + gotplt->output_offset;
3420
3421   /* S390 uses halfwords for relative branch calc!  */
3422   relative_offset = - (plt->output_offset +
3423                        (PLT_ENTRY_SIZE * iplt_index) + 18) / 2;
3424 /* If offset is > 32768, branch to a previous branch
3425    390 can only handle +-64 K jumps.  */
3426   if ( -32768 > (int) relative_offset )
3427     relative_offset
3428       = -(unsigned) (((65536 / PLT_ENTRY_SIZE - 1) * PLT_ENTRY_SIZE) / 2);
3429
3430   /* Fill in the entry in the procedure linkage table.  */
3431   if (!bfd_link_pic (info))
3432     {
3433       memcpy (plt->contents + iplt_offset, elf_s390_plt_entry,
3434               PLT_ENTRY_SIZE);
3435
3436       /* Adjust jump to the first plt entry.  */
3437       bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3438                   plt->contents + iplt_offset + 20);
3439
3440       /* Push the GOT offset field.  */
3441       bfd_put_32 (output_bfd,
3442                   (gotplt->output_section->vma
3443                    + got_offset),
3444                   plt->contents + iplt_offset + 24);
3445     }
3446   else if (got_offset < 4096)
3447     {
3448       /* The GOT offset is small enough to be used directly as
3449          displacement.  */
3450       memcpy (plt->contents + iplt_offset,
3451               elf_s390_plt_pic12_entry,
3452               PLT_ENTRY_SIZE);
3453
3454       /* Put in the GOT offset as displacement value.  The 0xc000
3455          value comes from the first word of the plt entry.  Look
3456          at the elf_s390_plt_pic16_entry content.  */
3457       bfd_put_16 (output_bfd, (bfd_vma)0xc000 | got_offset,
3458                   plt->contents + iplt_offset + 2);
3459
3460       /* Adjust the jump to the first plt entry.  */
3461       bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3462                   plt->contents + iplt_offset + 20);
3463     }
3464   else if (got_offset < 32768)
3465     {
3466       /* The GOT offset is too big for a displacement but small
3467          enough to be a signed 16 bit immediate value as it can be
3468          used in an lhi instruction.  */
3469       memcpy (plt->contents + iplt_offset,
3470               elf_s390_plt_pic16_entry,
3471               PLT_ENTRY_SIZE);
3472
3473       /* Put in the GOT offset for the lhi instruction.  */
3474       bfd_put_16 (output_bfd, (bfd_vma)got_offset,
3475                   plt->contents + iplt_offset + 2);
3476
3477       /* Adjust the jump to the first plt entry.  */
3478       bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3479                   plt->contents + iplt_offset + 20);
3480     }
3481   else
3482     {
3483       memcpy (plt->contents + iplt_offset,
3484               elf_s390_plt_pic_entry,
3485               PLT_ENTRY_SIZE);
3486
3487       /* Adjust the jump to the first plt entry.  */
3488       bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3489                   plt->contents + iplt_offset + 20);
3490
3491       /* Push the GOT offset field.  */
3492       bfd_put_32 (output_bfd, got_offset,
3493                   plt->contents + iplt_offset + 24);
3494     }
3495   /* Insert offset into  reloc. table here.  */
3496   bfd_put_32 (output_bfd, relplt->output_offset +
3497               iplt_index * RELA_ENTRY_SIZE,
3498               plt->contents + iplt_offset + 28);
3499
3500   /* Fill in the entry in the global offset table.
3501      Points to instruction after GOT offset.  */
3502   bfd_put_32 (output_bfd,
3503               (plt->output_section->vma
3504                + plt->output_offset
3505                + iplt_offset
3506                + 12),
3507               gotplt->contents + igotiplt_offset);
3508
3509   /* Fill in the entry in the .rela.plt section.  */
3510   rela.r_offset = gotplt->output_section->vma + got_offset;
3511
3512   if (!h
3513       || h->dynindx == -1
3514       || ((bfd_link_executable (info)
3515            || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
3516           && h->def_regular))
3517     {
3518       /* The symbol can be locally resolved.  */
3519       rela.r_info = ELF32_R_INFO (0, R_390_IRELATIVE);
3520       rela.r_addend = resolver_address;
3521     }
3522   else
3523     {
3524       rela.r_info = ELF32_R_INFO (h->dynindx, R_390_JMP_SLOT);
3525       rela.r_addend = 0;
3526     }
3527
3528   loc = relplt->contents + iplt_index * RELA_ENTRY_SIZE;
3529   bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3530 }
3531
3532 /* Finish up dynamic symbol handling.  We set the contents of various
3533    dynamic sections here.  */
3534
3535 static bfd_boolean
3536 elf_s390_finish_dynamic_symbol (bfd *output_bfd,
3537                                 struct bfd_link_info *info,
3538                                 struct elf_link_hash_entry *h,
3539                                 Elf_Internal_Sym *sym)
3540 {
3541   struct elf_s390_link_hash_table *htab;
3542   struct elf_s390_link_hash_entry *eh = (struct elf_s390_link_hash_entry*)h;
3543
3544   htab = elf_s390_hash_table (info);
3545
3546   if (h->plt.offset != (bfd_vma) -1)
3547     {
3548       bfd_vma plt_index;
3549       bfd_vma got_offset;
3550       Elf_Internal_Rela rela;
3551       bfd_byte *loc;
3552       bfd_vma relative_offset;
3553
3554       /* This symbol has an entry in the procedure linkage table.  Set
3555          it up.  */
3556       if (s390_is_ifunc_symbol_p (h))
3557         {
3558           /* If we can resolve the IFUNC symbol locally we generate an
3559              IRELATIVE reloc.  */
3560           elf_s390_finish_ifunc_symbol (output_bfd, info, h, htab, h->plt.offset,
3561                                         eh->ifunc_resolver_address +
3562                                         eh->ifunc_resolver_section->output_offset +
3563                                         eh->ifunc_resolver_section->output_section->vma);
3564           /* Fallthrough.  Handling of explicit GOT slots of IFUNC
3565              symbols is below.  */
3566         }
3567       else
3568         {
3569           if (h->dynindx == -1
3570               || htab->elf.splt == NULL
3571               || htab->elf.sgotplt == NULL
3572               || htab->elf.srelplt == NULL)
3573             abort ();
3574
3575           /* Calc. index no.
3576              Current offset - size first entry / entry size.  */
3577           plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3578
3579           /* Offset in GOT is PLT index plus GOT headers(3) times 4,
3580              addr & GOT addr.  */
3581           got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
3582
3583           /* S390 uses halfwords for relative branch calc!  */
3584           relative_offset = - ((PLT_FIRST_ENTRY_SIZE +
3585                                 (PLT_ENTRY_SIZE * plt_index) + 18) / 2);
3586           /* If offset is > 32768, branch to a previous branch
3587              390 can only handle +-64 K jumps.  */
3588           if ( -32768 > (int) relative_offset )
3589             relative_offset
3590               = -(unsigned) (((65536 / PLT_ENTRY_SIZE - 1) * PLT_ENTRY_SIZE) / 2);
3591
3592           /* Fill in the entry in the procedure linkage table.  */
3593           if (!bfd_link_pic (info))
3594             {
3595               memcpy (htab->elf.splt->contents + h->plt.offset, elf_s390_plt_entry,
3596                       PLT_ENTRY_SIZE);
3597
3598               /* Adjust jump to the first plt entry.  */
3599               bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3600                           htab->elf.splt->contents + h->plt.offset + 20);
3601
3602               /* Push the GOT offset field.  */
3603               bfd_put_32 (output_bfd,
3604                           (htab->elf.sgotplt->output_section->vma
3605                            + htab->elf.sgotplt->output_offset
3606                            + got_offset),
3607                           htab->elf.splt->contents + h->plt.offset + 24);
3608             }
3609           else if (got_offset < 4096)
3610             {
3611               /* The GOT offset is small enough to be used directly as
3612                  displacement.  */
3613               memcpy (htab->elf.splt->contents + h->plt.offset,
3614                       elf_s390_plt_pic12_entry,
3615                       PLT_ENTRY_SIZE);
3616
3617               /* Put in the GOT offset as displacement value.  The 0xc000
3618                  value comes from the first word of the plt entry.  Look
3619                  at the elf_s390_plt_pic16_entry content.  */
3620               bfd_put_16 (output_bfd, (bfd_vma)0xc000 | got_offset,
3621                           htab->elf.splt->contents + h->plt.offset + 2);
3622
3623               /* Adjust the jump to the first plt entry.  */
3624               bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3625                           htab->elf.splt->contents + h->plt.offset + 20);
3626             }
3627           else if (got_offset < 32768)
3628             {
3629               /* The GOT offset is too big for a displacement but small
3630                  enough to be a signed 16 bit immediate value as it can be
3631                  used in an lhi instruction.  */
3632               memcpy (htab->elf.splt->contents + h->plt.offset,
3633                       elf_s390_plt_pic16_entry,
3634                       PLT_ENTRY_SIZE);
3635
3636               /* Put in the GOT offset for the lhi instruction.  */
3637               bfd_put_16 (output_bfd, (bfd_vma)got_offset,
3638                           htab->elf.splt->contents + h->plt.offset + 2);
3639
3640               /* Adjust the jump to the first plt entry.  */
3641               bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3642                           htab->elf.splt->contents + h->plt.offset + 20);
3643             }
3644           else
3645             {
3646               memcpy (htab->elf.splt->contents + h->plt.offset,
3647                       elf_s390_plt_pic_entry,
3648                       PLT_ENTRY_SIZE);
3649
3650               /* Adjust the jump to the first plt entry.  */
3651               bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3652                           htab->elf.splt->contents + h->plt.offset + 20);
3653
3654               /* Push the GOT offset field.  */
3655               bfd_put_32 (output_bfd, got_offset,
3656                           htab->elf.splt->contents + h->plt.offset + 24);
3657             }
3658           /* Insert offset into  reloc. table here.  */
3659           bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
3660                       htab->elf.splt->contents + h->plt.offset + 28);
3661
3662           /* Fill in the entry in the global offset table.
3663              Points to instruction after GOT offset.  */
3664           bfd_put_32 (output_bfd,
3665                       (htab->elf.splt->output_section->vma
3666                        + htab->elf.splt->output_offset
3667                        + h->plt.offset
3668                        + 12),
3669                       htab->elf.sgotplt->contents + got_offset);
3670
3671           /* Fill in the entry in the .rela.plt section.  */
3672           rela.r_offset = (htab->elf.sgotplt->output_section->vma
3673                            + htab->elf.sgotplt->output_offset
3674                            + got_offset);
3675           rela.r_info = ELF32_R_INFO (h->dynindx, R_390_JMP_SLOT);
3676           rela.r_addend = 0;
3677           loc = htab->elf.srelplt->contents + plt_index * sizeof (Elf32_External_Rela);
3678           bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3679
3680           if (!h->def_regular)
3681             {
3682               /* Mark the symbol as undefined, rather than as defined in
3683                  the .plt section.  Leave the value alone.  This is a clue
3684                  for the dynamic linker, to make function pointer
3685                  comparisons work between an application and shared
3686                  library.  */
3687               sym->st_shndx = SHN_UNDEF;
3688             }
3689         }
3690     }
3691
3692   if (h->got.offset != (bfd_vma) -1
3693       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_GD
3694       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE
3695       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE_NLT)
3696     {
3697       Elf_Internal_Rela rela;
3698       bfd_byte *loc;
3699
3700       /* This symbol has an entry in the global offset table.  Set it
3701          up.  */
3702
3703       if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
3704         abort ();
3705
3706       rela.r_offset = (htab->elf.sgot->output_section->vma
3707                        + htab->elf.sgot->output_offset
3708                        + (h->got.offset &~ (bfd_vma) 1));
3709
3710       /* If this is a static link, or it is a -Bsymbolic link and the
3711          symbol is defined locally or was forced to be local because
3712          of a version file, we just want to emit a RELATIVE reloc.
3713          The entry in the global offset table will already have been
3714          initialized in the relocate_section function.  */
3715       if (h->def_regular && s390_is_ifunc_symbol_p (h))
3716         {
3717           if (bfd_link_pic (info))
3718             {
3719               /* An explicit GOT slot usage needs GLOB_DAT.  If the
3720                  symbol references local the implicit got.iplt slot
3721                  will be used and the IRELATIVE reloc has been created
3722                  above.  */
3723               goto do_glob_dat;
3724             }
3725           else
3726             {
3727               /* For non-shared objects explicit GOT slots must be
3728                  filled with the PLT slot address for pointer
3729                  equality reasons.  */
3730               bfd_put_32 (output_bfd, (htab->elf.iplt->output_section->vma
3731                                        + htab->elf.iplt->output_offset
3732                                        + h->plt.offset),
3733                           htab->elf.sgot->contents + h->got.offset);
3734               return TRUE;
3735             }
3736         }
3737       else if (bfd_link_pic (info)
3738           && SYMBOL_REFERENCES_LOCAL (info, h))
3739         {
3740           /* If this is a static link, or it is a -Bsymbolic link and
3741              the symbol is defined locally or was forced to be local
3742              because of a version file, we just want to emit a
3743              RELATIVE reloc.  The entry in the global offset table
3744              will already have been initialized in the
3745              relocate_section function.  */
3746           if (!h->def_regular)
3747             return FALSE;
3748           BFD_ASSERT((h->got.offset & 1) != 0);
3749           rela.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
3750           rela.r_addend = (h->root.u.def.value
3751                            + h->root.u.def.section->output_section->vma
3752                            + h->root.u.def.section->output_offset);
3753         }
3754       else
3755         {
3756           BFD_ASSERT((h->got.offset & 1) == 0);
3757         do_glob_dat:
3758           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->elf.sgot->contents + h->got.offset);
3759           rela.r_info = ELF32_R_INFO (h->dynindx, R_390_GLOB_DAT);
3760           rela.r_addend = 0;
3761         }
3762
3763       loc = htab->elf.srelgot->contents;
3764       loc += htab->elf.srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
3765       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3766     }
3767
3768   if (h->needs_copy)
3769     {
3770       Elf_Internal_Rela rela;
3771       bfd_byte *loc;
3772
3773       /* This symbols needs a copy reloc.  Set it up.  */
3774
3775       if (h->dynindx == -1
3776           || (h->root.type != bfd_link_hash_defined
3777               && h->root.type != bfd_link_hash_defweak)
3778           || htab->srelbss == NULL)
3779         abort ();
3780
3781       rela.r_offset = (h->root.u.def.value
3782                        + h->root.u.def.section->output_section->vma
3783                        + h->root.u.def.section->output_offset);
3784       rela.r_info = ELF32_R_INFO (h->dynindx, R_390_COPY);
3785       rela.r_addend = 0;
3786       loc = htab->srelbss->contents;
3787       loc += htab->srelbss->reloc_count++ * sizeof (Elf32_External_Rela);
3788       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3789     }
3790
3791   /* Mark some specially defined symbols as absolute.  */
3792   if (h == htab->elf.hdynamic
3793       || h == htab->elf.hgot
3794       || h == htab->elf.hplt)
3795     sym->st_shndx = SHN_ABS;
3796
3797   return TRUE;
3798 }
3799
3800 /* Used to decide how to sort relocs in an optimal manner for the
3801    dynamic linker, before writing them out.  */
3802
3803 static enum elf_reloc_type_class
3804 elf_s390_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
3805                            const asection *rel_sec ATTRIBUTE_UNUSED,
3806                            const Elf_Internal_Rela *rela)
3807 {
3808   switch ((int) ELF32_R_TYPE (rela->r_info))
3809     {
3810     case R_390_RELATIVE:
3811       return reloc_class_relative;
3812     case R_390_JMP_SLOT:
3813       return reloc_class_plt;
3814     case R_390_COPY:
3815       return reloc_class_copy;
3816     default:
3817       return reloc_class_normal;
3818     }
3819 }
3820
3821 /* Finish up the dynamic sections.  */
3822
3823 static bfd_boolean
3824 elf_s390_finish_dynamic_sections (bfd *output_bfd,
3825                                   struct bfd_link_info *info)
3826 {
3827   struct elf_s390_link_hash_table *htab;
3828   bfd *dynobj;
3829   asection *sdyn;
3830   bfd *ibfd;
3831   unsigned int i;
3832
3833   htab = elf_s390_hash_table (info);
3834   dynobj = htab->elf.dynobj;
3835   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3836
3837   if (htab->elf.dynamic_sections_created)
3838     {
3839       Elf32_External_Dyn *dyncon, *dynconend;
3840
3841       if (sdyn == NULL || htab->elf.sgot == NULL)
3842         abort ();
3843
3844       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3845       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3846       for (; dyncon < dynconend; dyncon++)
3847         {
3848           Elf_Internal_Dyn dyn;
3849           asection *s;
3850
3851           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3852
3853           switch (dyn.d_tag)
3854             {
3855             default:
3856               continue;
3857
3858             case DT_PLTGOT:
3859               dyn.d_un.d_ptr = htab->elf.sgot->output_section->vma;
3860               break;
3861
3862             case DT_JMPREL:
3863               dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
3864               break;
3865
3866             case DT_PLTRELSZ:
3867               s = htab->elf.srelplt->output_section;
3868               dyn.d_un.d_val = s->size;
3869               break;
3870             }
3871
3872           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3873         }
3874
3875       /* Fill in the special first entry in the procedure linkage table.  */
3876       if (htab->elf.splt && htab->elf.splt->size > 0)
3877         {
3878           memset (htab->elf.splt->contents, 0, PLT_FIRST_ENTRY_SIZE);
3879           if (bfd_link_pic (info))
3880             {
3881               memcpy (htab->elf.splt->contents, elf_s390_plt_pic_first_entry,
3882                       PLT_FIRST_ENTRY_SIZE);
3883             }
3884           else
3885             {
3886               memcpy (htab->elf.splt->contents, elf_s390_plt_first_entry,
3887                       PLT_FIRST_ENTRY_SIZE);
3888               bfd_put_32 (output_bfd,
3889                           htab->elf.sgotplt->output_section->vma
3890                           + htab->elf.sgotplt->output_offset,
3891                           htab->elf.splt->contents + 24);
3892            }
3893           elf_section_data (htab->elf.splt->output_section)
3894             ->this_hdr.sh_entsize = 4;
3895         }
3896
3897     }
3898
3899   if (htab->elf.sgotplt)
3900     {
3901       /* Fill in the first three entries in the global offset table.  */
3902       if (htab->elf.sgotplt->size > 0)
3903         {
3904           bfd_put_32 (output_bfd,
3905                       (sdyn == NULL ? (bfd_vma) 0
3906                        : sdyn->output_section->vma + sdyn->output_offset),
3907                       htab->elf.sgotplt->contents);
3908           /* One entry for shared object struct ptr.  */
3909           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + 4);
3910           /* One entry for _dl_runtime_resolve.  */
3911           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + 8);
3912         }
3913
3914       elf_section_data (htab->elf.sgotplt->output_section)
3915         ->this_hdr.sh_entsize = 4;
3916     }
3917   /* Finish dynamic symbol for local IFUNC symbols.  */
3918   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3919     {
3920       struct plt_entry *local_plt;
3921       Elf_Internal_Sym *isym;
3922       Elf_Internal_Shdr *symtab_hdr;
3923
3924       symtab_hdr = &elf_symtab_hdr (ibfd);
3925
3926       local_plt = elf_s390_local_plt (ibfd);
3927       if (local_plt != NULL)
3928         for (i = 0; i < symtab_hdr->sh_info; i++)
3929           {
3930             if (local_plt[i].plt.offset != (bfd_vma) -1)
3931               {
3932                 asection *sec = local_plt[i].sec;
3933                 isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, i);
3934                 if (isym == NULL)
3935                   return FALSE;
3936
3937                 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
3938                   elf_s390_finish_ifunc_symbol (output_bfd, info, NULL, htab,
3939                                                 local_plt[i].plt.offset,
3940                                                 isym->st_value
3941                                                 + sec->output_section->vma
3942                                                 + sec->output_offset);
3943
3944               }
3945           }
3946     }
3947   return TRUE;
3948 }
3949
3950 static bfd_boolean
3951 elf_s390_grok_prstatus (bfd * abfd, Elf_Internal_Note * note)
3952 {
3953   int offset;
3954   unsigned int size;
3955
3956   switch (note->descsz)
3957     {
3958       default:
3959         return FALSE;
3960
3961       case 224:         /* S/390 Linux.  */
3962         /* pr_cursig */
3963         elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3964
3965         /* pr_pid */
3966         elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
3967
3968         /* pr_reg */
3969         offset = 72;
3970         size = 144;
3971         break;
3972     }
3973
3974   /* Make a ".reg/999" section.  */
3975   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3976                                           size, note->descpos + offset);
3977 }
3978
3979 /* Return address for Ith PLT stub in section PLT, for relocation REL
3980    or (bfd_vma) -1 if it should not be included.  */
3981
3982 static bfd_vma
3983 elf_s390_plt_sym_val (bfd_vma i, const asection *plt,
3984                       const arelent *rel ATTRIBUTE_UNUSED)
3985 {
3986   return plt->vma + PLT_FIRST_ENTRY_SIZE + i * PLT_ENTRY_SIZE;
3987 }
3988
3989 /* Merge backend specific data from an object file to the output
3990    object file when linking.  */
3991
3992 static bfd_boolean
3993 elf32_s390_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
3994 {
3995   if (!is_s390_elf (ibfd) || !is_s390_elf (obfd))
3996     return TRUE;
3997
3998   if (!elf_s390_merge_obj_attributes (ibfd, obfd))
3999     return FALSE;
4000
4001   elf_elfheader (obfd)->e_flags |= elf_elfheader (ibfd)->e_flags;
4002   return TRUE;
4003 }
4004
4005
4006 #define TARGET_BIG_SYM  s390_elf32_vec
4007 #define TARGET_BIG_NAME "elf32-s390"
4008 #define ELF_ARCH        bfd_arch_s390
4009 #define ELF_TARGET_ID   S390_ELF_DATA
4010 #define ELF_MACHINE_CODE EM_S390
4011 #define ELF_MACHINE_ALT1 EM_S390_OLD
4012 #define ELF_MAXPAGESIZE 0x1000
4013
4014 #define elf_backend_can_gc_sections     1
4015 #define elf_backend_can_refcount        1
4016 #define elf_backend_want_got_plt        1
4017 #define elf_backend_plt_readonly        1
4018 #define elf_backend_want_plt_sym        0
4019 #define elf_backend_got_header_size     12
4020 #define elf_backend_rela_normal         1
4021
4022 #define elf_info_to_howto                     elf_s390_info_to_howto
4023
4024 #define bfd_elf32_bfd_is_local_label_name     elf_s390_is_local_label_name
4025 #define bfd_elf32_bfd_link_hash_table_create  elf_s390_link_hash_table_create
4026 #define bfd_elf32_bfd_reloc_type_lookup       elf_s390_reloc_type_lookup
4027 #define bfd_elf32_bfd_reloc_name_lookup elf_s390_reloc_name_lookup
4028
4029 #define bfd_elf32_bfd_merge_private_bfd_data  elf32_s390_merge_private_bfd_data
4030
4031 #define elf_backend_adjust_dynamic_symbol     elf_s390_adjust_dynamic_symbol
4032 #define elf_backend_check_relocs              elf_s390_check_relocs
4033 #define elf_backend_copy_indirect_symbol      elf_s390_copy_indirect_symbol
4034 #define elf_backend_create_dynamic_sections   elf_s390_create_dynamic_sections
4035 #define elf_backend_finish_dynamic_sections   elf_s390_finish_dynamic_sections
4036 #define elf_backend_finish_dynamic_symbol     elf_s390_finish_dynamic_symbol
4037 #define elf_backend_gc_mark_hook              elf_s390_gc_mark_hook
4038 #define elf_backend_gc_sweep_hook             elf_s390_gc_sweep_hook
4039 #define elf_backend_reloc_type_class          elf_s390_reloc_type_class
4040 #define elf_backend_relocate_section          elf_s390_relocate_section
4041 #define elf_backend_size_dynamic_sections     elf_s390_size_dynamic_sections
4042 #define elf_backend_init_index_section        _bfd_elf_init_1_index_section
4043 #define elf_backend_grok_prstatus             elf_s390_grok_prstatus
4044 #define elf_backend_plt_sym_val               elf_s390_plt_sym_val
4045 #define elf_backend_add_symbol_hook           elf_s390_add_symbol_hook
4046 #define elf_backend_sort_relocs_p             elf_s390_elf_sort_relocs_p
4047
4048 #define bfd_elf32_mkobject              elf_s390_mkobject
4049 #define elf_backend_object_p            elf_s390_object_p
4050
4051 #include "elf32-target.h"