bfd/elf32-s390.c

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