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