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                        && (! info->symbolic
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           || (! info->shared
1570               && !h->def_dynamic
1571               && !h->ref_dynamic
1572               && h->root.type != bfd_link_hash_undefweak
1573               && h->root.type != bfd_link_hash_undefined))
1574         {
1575           /* This case can occur if we saw a PLT32 reloc in an input
1576              file, but the symbol was never referred to by a dynamic
1577              object, or if all references were garbage collected.  In
1578              such a case, we don't actually need to build a procedure
1579              linkage table, and we can just do a PC32 reloc instead.  */
1580           h->plt.offset = (bfd_vma) -1;
1581           h->needs_plt = 0;
1582           elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1583         }
1584
1585       return TRUE;
1586     }
1587   else
1588     /* It's possible that we incorrectly decided a .plt reloc was
1589        needed for an R_390_PC32 reloc to a non-function sym in
1590        check_relocs.  We can't decide accurately between function and
1591        non-function syms in check-relocs;  Objects loaded later in
1592        the link may change h->type.  So fix it now.  */
1593     h->plt.offset = (bfd_vma) -1;
1594
1595   /* If this is a weak symbol, and there is a real definition, the
1596      processor independent code will have arranged for us to see the
1597      real definition first, and we can just use the same value.  */
1598   if (h->u.weakdef != NULL)
1599     {
1600       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1601                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1602       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1603       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1604       if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1605         h->non_got_ref = h->u.weakdef->non_got_ref;
1606       return TRUE;
1607     }
1608
1609   /* This is a reference to a symbol defined by a dynamic object which
1610      is not a function.  */
1611
1612   /* If we are creating a shared library, we must presume that the
1613      only references to the symbol are via the global offset table.
1614      For such cases we need not do anything here; the relocations will
1615      be handled correctly by relocate_section.  */
1616   if (info->shared)
1617     return TRUE;
1618
1619   /* If there are no references to this symbol that do not use the
1620      GOT, we don't need to generate a copy reloc.  */
1621   if (!h->non_got_ref)
1622     return TRUE;
1623
1624   /* If -z nocopyreloc was given, we won't generate them either.  */
1625   if (info->nocopyreloc)
1626     {
1627       h->non_got_ref = 0;
1628       return TRUE;
1629     }
1630
1631   if (ELIMINATE_COPY_RELOCS)
1632     {
1633       struct elf_s390_link_hash_entry * eh;
1634       struct elf_s390_dyn_relocs *p;
1635
1636       eh = (struct elf_s390_link_hash_entry *) h;
1637       for (p = eh->dyn_relocs; p != NULL; p = p->next)
1638         {
1639           s = p->sec->output_section;
1640           if (s != NULL && (s->flags & SEC_READONLY) != 0)
1641             break;
1642         }
1643
1644       /* If we didn't find any dynamic relocs in read-only sections, then
1645          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
1646       if (p == NULL)
1647         {
1648           h->non_got_ref = 0;
1649           return TRUE;
1650         }
1651     }
1652
1653   if (h->size == 0)
1654     {
1655       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1656                              h->root.root.string);
1657       return TRUE;
1658     }
1659
1660   /* We must allocate the symbol in our .dynbss section, which will
1661      become part of the .bss section of the executable.  There will be
1662      an entry for this symbol in the .dynsym section.  The dynamic
1663      object will contain position independent code, so all references
1664      from the dynamic object to this symbol will go through the global
1665      offset table.  The dynamic linker will use the .dynsym entry to
1666      determine the address it must put in the global offset table, so
1667      both the dynamic object and the regular object will refer to the
1668      same memory location for the variable.  */
1669
1670   htab = elf_s390_hash_table (info);
1671
1672   /* We must generate a R_390_COPY reloc to tell the dynamic linker to
1673      copy the initial value out of the dynamic object and into the
1674      runtime process image.  */
1675   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1676     {
1677       htab->srelbss->size += sizeof (Elf32_External_Rela);
1678       h->needs_copy = 1;
1679     }
1680
1681   s = htab->sdynbss;
1682
1683   return _bfd_elf_adjust_dynamic_copy (h, s);
1684 }
1685
1686 /* Allocate space in .plt, .got and associated reloc sections for
1687    dynamic relocs.  */
1688
1689 static bfd_boolean
1690 allocate_dynrelocs (h, inf)
1691      struct elf_link_hash_entry *h;
1692      PTR inf;
1693 {
1694   struct bfd_link_info *info;
1695   struct elf_s390_link_hash_table *htab;
1696   struct elf_s390_link_hash_entry *eh;
1697   struct elf_s390_dyn_relocs *p;
1698
1699   if (h->root.type == bfd_link_hash_indirect)
1700     return TRUE;
1701
1702   if (h->root.type == bfd_link_hash_warning)
1703     /* When warning symbols are created, they **replace** the "real"
1704        entry in the hash table, thus we never get to see the real
1705        symbol in a hash traversal.  So look at it now.  */
1706     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1707
1708   info = (struct bfd_link_info *) inf;
1709   htab = elf_s390_hash_table (info);
1710
1711   if (htab->elf.dynamic_sections_created
1712       && h->plt.refcount > 0
1713       && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1714           || h->root.type != bfd_link_hash_undefweak))
1715     {
1716       /* Make sure this symbol is output as a dynamic symbol.
1717          Undefined weak syms won't yet be marked as dynamic.  */
1718       if (h->dynindx == -1
1719           && !h->forced_local)
1720         {
1721           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1722             return FALSE;
1723         }
1724
1725       if (info->shared
1726           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1727         {
1728           asection *s = htab->splt;
1729
1730           /* If this is the first .plt entry, make room for the special
1731              first entry.  */
1732           if (s->size == 0)
1733             s->size += PLT_FIRST_ENTRY_SIZE;
1734
1735           h->plt.offset = s->size;
1736
1737           /* If this symbol is not defined in a regular file, and we are
1738              not generating a shared library, then set the symbol to this
1739              location in the .plt.  This is required to make function
1740              pointers compare as equal between the normal executable and
1741              the shared library.  */
1742           if (! info->shared
1743               && !h->def_regular)
1744             {
1745               h->root.u.def.section = s;
1746               h->root.u.def.value = h->plt.offset;
1747             }
1748
1749           /* Make room for this entry.  */
1750           s->size += PLT_ENTRY_SIZE;
1751
1752           /* We also need to make an entry in the .got.plt section, which
1753              will be placed in the .got section by the linker script.  */
1754           htab->sgotplt->size += GOT_ENTRY_SIZE;
1755
1756           /* We also need to make an entry in the .rela.plt section.  */
1757           htab->srelplt->size += sizeof (Elf32_External_Rela);
1758         }
1759       else
1760         {
1761           h->plt.offset = (bfd_vma) -1;
1762           h->needs_plt = 0;
1763           elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1764         }
1765     }
1766   else
1767     {
1768       h->plt.offset = (bfd_vma) -1;
1769       h->needs_plt = 0;
1770       elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1771     }
1772
1773   /* If R_390_TLS_{IE32,GOTIE32,GOTIE12,IEENT} symbol is now local to
1774      the binary, we can optimize a bit. IE32 and GOTIE32 get converted
1775      to R_390_TLS_LE32 requiring no TLS entry. For GOTIE12 and IEENT
1776      we can save the dynamic TLS relocation.  */
1777   if (h->got.refcount > 0
1778       && !info->shared
1779       && h->dynindx == -1
1780       && elf_s390_hash_entry(h)->tls_type >= GOT_TLS_IE)
1781     {
1782       if (elf_s390_hash_entry(h)->tls_type == GOT_TLS_IE_NLT)
1783         /* For the GOTIE access without a literal pool entry the offset has
1784            to be stored somewhere. The immediate value in the instruction
1785            is not bit enough so the value is stored in the got.  */
1786         {
1787           h->got.offset = htab->sgot->size;
1788           htab->sgot->size += GOT_ENTRY_SIZE;
1789         }
1790       else
1791         h->got.offset = (bfd_vma) -1;
1792     }
1793   else if (h->got.refcount > 0)
1794    {
1795       asection *s;
1796       bfd_boolean dyn;
1797       int tls_type = elf_s390_hash_entry(h)->tls_type;
1798
1799       /* Make sure this symbol is output as a dynamic symbol.
1800          Undefined weak syms won't yet be marked as dynamic.  */
1801       if (h->dynindx == -1
1802           && !h->forced_local)
1803         {
1804           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1805             return FALSE;
1806         }
1807
1808       s = htab->sgot;
1809       h->got.offset = s->size;
1810       s->size += GOT_ENTRY_SIZE;
1811       /* R_390_TLS_GD32 needs 2 consecutive GOT slots.  */
1812       if (tls_type == GOT_TLS_GD)
1813         s->size += GOT_ENTRY_SIZE;
1814       dyn = htab->elf.dynamic_sections_created;
1815       /* R_390_TLS_IE32 needs one dynamic relocation,
1816          R_390_TLS_GD32 needs one if local symbol and two if global.  */
1817       if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1818           || tls_type >= GOT_TLS_IE)
1819         htab->srelgot->size += sizeof (Elf32_External_Rela);
1820       else if (tls_type == GOT_TLS_GD)
1821         htab->srelgot->size += 2 * sizeof (Elf32_External_Rela);
1822       else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1823                 || h->root.type != bfd_link_hash_undefweak)
1824                && (info->shared
1825                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1826         htab->srelgot->size += sizeof (Elf32_External_Rela);
1827     }
1828   else
1829     h->got.offset = (bfd_vma) -1;
1830
1831   eh = (struct elf_s390_link_hash_entry *) h;
1832   if (eh->dyn_relocs == NULL)
1833     return TRUE;
1834
1835   /* In the shared -Bsymbolic case, discard space allocated for
1836      dynamic pc-relative relocs against symbols which turn out to be
1837      defined in regular objects.  For the normal shared case, discard
1838      space for pc-relative relocs that have become local due to symbol
1839      visibility changes.  */
1840
1841   if (info->shared)
1842     {
1843       if (SYMBOL_REFERENCES_LOCAL (info, h))
1844         {
1845           struct elf_s390_dyn_relocs **pp;
1846
1847           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1848             {
1849               p->count -= p->pc_count;
1850               p->pc_count = 0;
1851               if (p->count == 0)
1852                 *pp = p->next;
1853               else
1854                 pp = &p->next;
1855             }
1856         }
1857
1858       /* Also discard relocs on undefined weak syms with non-default
1859          visibility.  */
1860       if (eh->dyn_relocs != NULL
1861           && h->root.type == bfd_link_hash_undefweak)
1862         {
1863           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1864             eh->dyn_relocs = NULL;
1865
1866           /* Make sure undefined weak symbols are output as a dynamic
1867              symbol in PIEs.  */
1868           else if (h->dynindx == -1
1869                    && !h->forced_local)
1870             {
1871               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1872                 return FALSE;
1873             }
1874         }
1875     }
1876   else if (ELIMINATE_COPY_RELOCS)
1877     {
1878       /* For the non-shared case, discard space for relocs against
1879          symbols which turn out to need copy relocs or are not
1880          dynamic.  */
1881
1882       if (!h->non_got_ref
1883           && ((h->def_dynamic
1884                && !h->def_regular)
1885               || (htab->elf.dynamic_sections_created
1886                   && (h->root.type == bfd_link_hash_undefweak
1887                       || h->root.type == bfd_link_hash_undefined))))
1888         {
1889           /* Make sure this symbol is output as a dynamic symbol.
1890              Undefined weak syms won't yet be marked as dynamic.  */
1891           if (h->dynindx == -1
1892               && !h->forced_local)
1893             {
1894               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1895                 return FALSE;
1896             }
1897
1898           /* If that succeeded, we know we'll be keeping all the
1899              relocs.  */
1900           if (h->dynindx != -1)
1901             goto keep;
1902         }
1903
1904       eh->dyn_relocs = NULL;
1905
1906     keep: ;
1907     }
1908
1909   /* Finally, allocate space.  */
1910   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1911     {
1912       asection *sreloc = elf_section_data (p->sec)->sreloc;
1913
1914       sreloc->size += p->count * sizeof (Elf32_External_Rela);
1915     }
1916
1917   return TRUE;
1918 }
1919
1920 /* Find any dynamic relocs that apply to read-only sections.  */
1921
1922 static bfd_boolean
1923 readonly_dynrelocs (h, inf)
1924      struct elf_link_hash_entry *h;
1925      PTR inf;
1926 {
1927   struct elf_s390_link_hash_entry *eh;
1928   struct elf_s390_dyn_relocs *p;
1929
1930   if (h->root.type == bfd_link_hash_warning)
1931     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1932
1933   eh = (struct elf_s390_link_hash_entry *) h;
1934   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1935     {
1936       asection *s = p->sec->output_section;
1937
1938       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1939         {
1940           struct bfd_link_info *info = (struct bfd_link_info *) inf;
1941
1942           info->flags |= DF_TEXTREL;
1943
1944           /* Not an error, just cut short the traversal.  */
1945           return FALSE;
1946         }
1947     }
1948   return TRUE;
1949 }
1950
1951 /* Set the sizes of the dynamic sections.  */
1952
1953 static bfd_boolean
1954 elf_s390_size_dynamic_sections (output_bfd, info)
1955      bfd *output_bfd ATTRIBUTE_UNUSED;
1956      struct bfd_link_info *info;
1957 {
1958   struct elf_s390_link_hash_table *htab;
1959   bfd *dynobj;
1960   asection *s;
1961   bfd_boolean relocs;
1962   bfd *ibfd;
1963
1964   htab = elf_s390_hash_table (info);
1965   dynobj = htab->elf.dynobj;
1966   if (dynobj == NULL)
1967     abort ();
1968
1969   if (htab->elf.dynamic_sections_created)
1970     {
1971       /* Set the contents of the .interp section to the interpreter.  */
1972       if (info->executable)
1973         {
1974           s = bfd_get_section_by_name (dynobj, ".interp");
1975           if (s == NULL)
1976             abort ();
1977           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1978           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1979         }
1980     }
1981
1982   /* Set up .got offsets for local syms, and space for local dynamic
1983      relocs.  */
1984   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1985     {
1986       bfd_signed_vma *local_got;
1987       bfd_signed_vma *end_local_got;
1988       char *local_tls_type;
1989       bfd_size_type locsymcount;
1990       Elf_Internal_Shdr *symtab_hdr;
1991       asection *srela;
1992
1993       if (! is_s390_elf (ibfd))
1994         continue;
1995
1996       for (s = ibfd->sections; s != NULL; s = s->next)
1997         {
1998           struct elf_s390_dyn_relocs *p;
1999
2000           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
2001             {
2002               if (!bfd_is_abs_section (p->sec)
2003                   && bfd_is_abs_section (p->sec->output_section))
2004                 {
2005                   /* Input section has been discarded, either because
2006                      it is a copy of a linkonce section or due to
2007                      linker script /DISCARD/, so we'll be discarding
2008                      the relocs too.  */
2009                 }
2010               else if (p->count != 0)
2011                 {
2012                   srela = elf_section_data (p->sec)->sreloc;
2013                   srela->size += p->count * sizeof (Elf32_External_Rela);
2014                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2015                     info->flags |= DF_TEXTREL;
2016                 }
2017             }
2018         }
2019
2020       local_got = elf_local_got_refcounts (ibfd);
2021       if (!local_got)
2022         continue;
2023
2024       symtab_hdr = &elf_symtab_hdr (ibfd);
2025       locsymcount = symtab_hdr->sh_info;
2026       end_local_got = local_got + locsymcount;
2027       local_tls_type = elf_s390_local_got_tls_type (ibfd);
2028       s = htab->sgot;
2029       srela = htab->srelgot;
2030       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2031         {
2032           if (*local_got > 0)
2033             {
2034               *local_got = s->size;
2035               s->size += GOT_ENTRY_SIZE;
2036               if (*local_tls_type == GOT_TLS_GD)
2037                 s->size += GOT_ENTRY_SIZE;
2038               if (info->shared)
2039                 srela->size += sizeof (Elf32_External_Rela);
2040             }
2041           else
2042             *local_got = (bfd_vma) -1;
2043         }
2044     }
2045
2046   if (htab->tls_ldm_got.refcount > 0)
2047     {
2048       /* Allocate 2 got entries and 1 dynamic reloc for R_390_TLS_LDM32
2049          relocs.  */
2050       htab->tls_ldm_got.offset = htab->sgot->size;
2051       htab->sgot->size += 2 * GOT_ENTRY_SIZE;
2052       htab->srelgot->size += sizeof (Elf32_External_Rela);
2053     }
2054   else
2055     htab->tls_ldm_got.offset = -1;
2056
2057   /* Allocate global sym .plt and .got entries, and space for global
2058      sym dynamic relocs.  */
2059   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
2060
2061   /* We now have determined the sizes of the various dynamic sections.
2062      Allocate memory for them.  */
2063   relocs = FALSE;
2064   for (s = dynobj->sections; s != NULL; s = s->next)
2065     {
2066       if ((s->flags & SEC_LINKER_CREATED) == 0)
2067         continue;
2068
2069       if (s == htab->splt
2070           || s == htab->sgot
2071           || s == htab->sgotplt
2072           || s == htab->sdynbss)
2073         {
2074           /* Strip this section if we don't need it; see the
2075              comment below.  */
2076         }
2077       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2078         {
2079           if (s->size != 0)
2080             relocs = TRUE;
2081
2082           /* We use the reloc_count field as a counter if we need
2083              to copy relocs into the output file.  */
2084           s->reloc_count = 0;
2085         }
2086       else
2087         {
2088           /* It's not one of our sections, so don't allocate space.  */
2089           continue;
2090         }
2091
2092       if (s->size == 0)
2093         {
2094           /* If we don't need this section, strip it from the
2095              output file.  This is to handle .rela.bss and
2096              .rela.plt.  We must create it in
2097              create_dynamic_sections, because it must be created
2098              before the linker maps input sections to output
2099              sections.  The linker does that before
2100              adjust_dynamic_symbol is called, and it is that
2101              function which decides whether anything needs to go
2102              into these sections.  */
2103
2104           s->flags |= SEC_EXCLUDE;
2105           continue;
2106         }
2107
2108       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2109         continue;
2110
2111       /* Allocate memory for the section contents.  We use bfd_zalloc
2112          here in case unused entries are not reclaimed before the
2113          section's contents are written out.  This should not happen,
2114          but this way if it does, we get a R_390_NONE reloc instead
2115          of garbage.  */
2116       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2117       if (s->contents == NULL)
2118         return FALSE;
2119     }
2120
2121   if (htab->elf.dynamic_sections_created)
2122     {
2123       /* Add some entries to the .dynamic section.  We fill in the
2124          values later, in elf_s390_finish_dynamic_sections, but we
2125          must add the entries now so that we get the correct size for
2126          the .dynamic section.  The DT_DEBUG entry is filled in by the
2127          dynamic linker and used by the debugger.  */
2128 #define add_dynamic_entry(TAG, VAL) \
2129   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2130
2131       if (info->executable)
2132         {
2133           if (!add_dynamic_entry (DT_DEBUG, 0))
2134             return FALSE;
2135         }
2136
2137       if (htab->splt->size != 0)
2138         {
2139           if (!add_dynamic_entry (DT_PLTGOT, 0)
2140               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2141               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2142               || !add_dynamic_entry (DT_JMPREL, 0))
2143             return FALSE;
2144         }
2145
2146       if (relocs)
2147         {
2148           if (!add_dynamic_entry (DT_RELA, 0)
2149               || !add_dynamic_entry (DT_RELASZ, 0)
2150               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
2151             return FALSE;
2152
2153           /* If any dynamic relocs apply to a read-only section,
2154              then we need a DT_TEXTREL entry.  */
2155           if ((info->flags & DF_TEXTREL) == 0)
2156             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2157                                     (PTR) info);
2158
2159           if ((info->flags & DF_TEXTREL) != 0)
2160             {
2161               if (!add_dynamic_entry (DT_TEXTREL, 0))
2162                 return FALSE;
2163             }
2164         }
2165     }
2166 #undef add_dynamic_entry
2167
2168   return TRUE;
2169 }
2170
2171 /* Return the base VMA address which should be subtracted from real addresses
2172    when resolving @dtpoff relocation.
2173    This is PT_TLS segment p_vaddr.  */
2174
2175 static bfd_vma
2176 dtpoff_base (info)
2177      struct bfd_link_info *info;
2178 {
2179   /* If tls_sec is NULL, we should have signalled an error already.  */
2180   if (elf_hash_table (info)->tls_sec == NULL)
2181     return 0;
2182   return elf_hash_table (info)->tls_sec->vma;
2183 }
2184
2185 /* Return the relocation value for @tpoff relocation
2186    if STT_TLS virtual address is ADDRESS.  */
2187
2188 static bfd_vma
2189 tpoff (info, address)
2190      struct bfd_link_info *info;
2191      bfd_vma address;
2192 {
2193   struct elf_link_hash_table *htab = elf_hash_table (info);
2194
2195   /* If tls_sec is NULL, we should have signalled an error already.  */
2196   if (htab->tls_sec == NULL)
2197     return 0;
2198   return htab->tls_size + htab->tls_sec->vma - address;
2199 }
2200
2201 /* Complain if TLS instruction relocation is against an invalid
2202    instruction.  */
2203
2204 static void
2205 invalid_tls_insn (input_bfd, input_section, rel)
2206      bfd *input_bfd;
2207      asection *input_section;
2208      Elf_Internal_Rela *rel;
2209 {
2210   reloc_howto_type *howto;
2211
2212   howto = elf_howto_table + ELF32_R_TYPE (rel->r_info);
2213   (*_bfd_error_handler)
2214     (_("%B(%A+0x%lx): invalid instruction for TLS relocation %s"),
2215      input_bfd,
2216      input_section,
2217      (long) rel->r_offset,
2218      howto->name);
2219   bfd_set_error (bfd_error_bad_value);
2220 }
2221
2222 /* Relocate a 390 ELF section.  */
2223
2224 static bfd_boolean
2225 elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
2226                               contents, relocs, local_syms, local_sections)
2227      bfd *output_bfd;
2228      struct bfd_link_info *info;
2229      bfd *input_bfd;
2230      asection *input_section;
2231      bfd_byte *contents;
2232      Elf_Internal_Rela *relocs;
2233      Elf_Internal_Sym *local_syms;
2234      asection **local_sections;
2235 {
2236   struct elf_s390_link_hash_table *htab;
2237   Elf_Internal_Shdr *symtab_hdr;
2238   struct elf_link_hash_entry **sym_hashes;
2239   bfd_vma *local_got_offsets;
2240   Elf_Internal_Rela *rel;
2241   Elf_Internal_Rela *relend;
2242
2243   BFD_ASSERT (is_s390_elf (input_bfd));
2244
2245   htab = elf_s390_hash_table (info);
2246   symtab_hdr = &elf_symtab_hdr (input_bfd);
2247   sym_hashes = elf_sym_hashes (input_bfd);
2248   local_got_offsets = elf_local_got_offsets (input_bfd);
2249
2250   rel = relocs;
2251   relend = relocs + input_section->reloc_count;
2252   for (; rel < relend; rel++)
2253     {
2254       unsigned int r_type;
2255       reloc_howto_type *howto;
2256       unsigned long r_symndx;
2257       struct elf_link_hash_entry *h;
2258       Elf_Internal_Sym *sym;
2259       asection *sec;
2260       bfd_vma off;
2261       bfd_vma relocation;
2262       bfd_boolean unresolved_reloc;
2263       bfd_reloc_status_type r;
2264       int tls_type;
2265
2266       r_type = ELF32_R_TYPE (rel->r_info);
2267       if (r_type == (int) R_390_GNU_VTINHERIT
2268           || r_type == (int) R_390_GNU_VTENTRY)
2269         continue;
2270       if (r_type >= (int) R_390_max)
2271         {
2272           bfd_set_error (bfd_error_bad_value);
2273           return FALSE;
2274         }
2275
2276       howto = elf_howto_table + r_type;
2277       r_symndx = ELF32_R_SYM (rel->r_info);
2278
2279       h = NULL;
2280       sym = NULL;
2281       sec = NULL;
2282       unresolved_reloc = FALSE;
2283       if (r_symndx < symtab_hdr->sh_info)
2284         {
2285           sym = local_syms + r_symndx;
2286           sec = local_sections[r_symndx];
2287           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2288         }
2289       else
2290         {
2291           bfd_boolean warned ATTRIBUTE_UNUSED;
2292
2293           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2294                                    r_symndx, symtab_hdr, sym_hashes,
2295                                    h, sec, relocation,
2296                                    unresolved_reloc, warned);
2297         }
2298
2299       if (sec != NULL && elf_discarded_section (sec))
2300         {
2301           /* For relocs against symbols from removed linkonce sections,
2302              or sections discarded by a linker script, we just want the
2303              section contents zeroed.  Avoid any special processing.  */
2304           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2305           rel->r_info = 0;
2306           rel->r_addend = 0;
2307           continue;
2308         }
2309
2310       if (info->relocatable)
2311         continue;
2312
2313       switch (r_type)
2314         {
2315         case R_390_GOTPLT12:
2316         case R_390_GOTPLT16:
2317         case R_390_GOTPLT20:
2318         case R_390_GOTPLT32:
2319         case R_390_GOTPLTENT:
2320           /* There are three cases for a GOTPLT relocation. 1) The
2321              relocation is against the jump slot entry of a plt that
2322              will get emitted to the output file. 2) The relocation
2323              is against the jump slot of a plt entry that has been
2324              removed. elf_s390_adjust_gotplt has created a GOT entry
2325              as replacement. 3) The relocation is against a local symbol.
2326              Cases 2) and 3) are the same as the GOT relocation code
2327              so we just have to test for case 1 and fall through for
2328              the other two.  */
2329           if (h != NULL && h->plt.offset != (bfd_vma) -1)
2330             {
2331               bfd_vma plt_index;
2332
2333               /* Calc. index no.
2334                  Current offset - size first entry / entry size.  */
2335               plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) /
2336                 PLT_ENTRY_SIZE;
2337
2338               /* Offset in GOT is PLT index plus GOT headers(3) times 4,
2339                  addr & GOT addr.  */
2340               relocation = (plt_index + 3) * GOT_ENTRY_SIZE;
2341               unresolved_reloc = FALSE;
2342
2343               if (r_type == R_390_GOTPLTENT)
2344                 relocation += htab->sgot->output_section->vma;
2345               break;
2346             }
2347           /* Fall through.  */
2348
2349         case R_390_GOT12:
2350         case R_390_GOT16:
2351         case R_390_GOT20:
2352         case R_390_GOT32:
2353         case R_390_GOTENT:
2354           /* Relocation is to the entry for this symbol in the global
2355              offset table.  */
2356           if (htab->sgot == NULL)
2357             abort ();
2358
2359           if (h != NULL)
2360             {
2361               bfd_boolean dyn;
2362
2363               off = h->got.offset;
2364               dyn = htab->elf.dynamic_sections_created;
2365               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2366                   || (info->shared
2367                       && (info->symbolic
2368                           || h->dynindx == -1
2369                           || h->forced_local)
2370                       && h->def_regular)
2371                   || (ELF_ST_VISIBILITY (h->other)
2372                       && h->root.type == bfd_link_hash_undefweak))
2373                 {
2374                   /* This is actually a static link, or it is a
2375                      -Bsymbolic link and the symbol is defined
2376                      locally, or the symbol was forced to be local
2377                      because of a version file.  We must initialize
2378                      this entry in the global offset table.  Since the
2379                      offset must always be a multiple of 2, we use the
2380                      least significant bit to record whether we have
2381                      initialized it already.
2382
2383                      When doing a dynamic link, we create a .rel.got
2384                      relocation entry to initialize the value.  This
2385                      is done in the finish_dynamic_symbol routine.  */
2386                   if ((off & 1) != 0)
2387                     off &= ~1;
2388                   else
2389                     {
2390                       bfd_put_32 (output_bfd, relocation,
2391                                   htab->sgot->contents + off);
2392                       h->got.offset |= 1;
2393                     }
2394                 }
2395               else
2396                 unresolved_reloc = FALSE;
2397             }
2398           else
2399             {
2400               if (local_got_offsets == NULL)
2401                 abort ();
2402
2403               off = local_got_offsets[r_symndx];
2404
2405               /* The offset must always be a multiple of 4.  We use
2406                  the least significant bit to record whether we have
2407                  already generated the necessary reloc.  */
2408               if ((off & 1) != 0)
2409                 off &= ~1;
2410               else
2411                 {
2412                   bfd_put_32 (output_bfd, relocation,
2413                               htab->sgot->contents + off);
2414
2415                   if (info->shared)
2416                     {
2417                       asection *srelgot;
2418                       Elf_Internal_Rela outrel;
2419                       bfd_byte *loc;
2420
2421                       srelgot = htab->srelgot;
2422                       if (srelgot == NULL)
2423                         abort ();
2424
2425                       outrel.r_offset = (htab->sgot->output_section->vma
2426                                          + htab->sgot->output_offset
2427                                          + off);
2428                       outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2429                       outrel.r_addend = relocation;
2430                       loc = srelgot->contents;
2431                       loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
2432                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2433                     }
2434
2435                   local_got_offsets[r_symndx] |= 1;
2436                 }
2437             }
2438
2439           if (off >= (bfd_vma) -2)
2440             abort ();
2441
2442           relocation = htab->sgot->output_offset + off;
2443
2444           /* For @GOTENT the relocation is against the offset between
2445              the instruction and the symbols entry in the GOT and not
2446              between the start of the GOT and the symbols entry. We
2447              add the vma of the GOT to get the correct value.  */
2448           if (   r_type == R_390_GOTENT
2449               || r_type == R_390_GOTPLTENT)
2450             relocation += htab->sgot->output_section->vma;
2451
2452           break;
2453
2454         case R_390_GOTOFF16:
2455         case R_390_GOTOFF32:
2456           /* Relocation is relative to the start of the global offset
2457              table.  */
2458
2459           /* Note that sgot->output_offset is not involved in this
2460              calculation.  We always want the start of .got.  If we
2461              defined _GLOBAL_OFFSET_TABLE in a different way, as is
2462              permitted by the ABI, we might have to change this
2463              calculation.  */
2464           relocation -= htab->sgot->output_section->vma;
2465           break;
2466
2467         case R_390_GOTPC:
2468         case R_390_GOTPCDBL:
2469           /* Use global offset table as symbol value.  */
2470           relocation = htab->sgot->output_section->vma;
2471           unresolved_reloc = FALSE;
2472           break;
2473
2474         case R_390_PLT16DBL:
2475         case R_390_PLT32DBL:
2476         case R_390_PLT32:
2477           /* Relocation is to the entry for this symbol in the
2478              procedure linkage table.  */
2479
2480           /* Resolve a PLT32 reloc against a local symbol directly,
2481              without using the procedure linkage table.  */
2482           if (h == NULL)
2483             break;
2484
2485           if (h->plt.offset == (bfd_vma) -1
2486               || htab->splt == NULL)
2487             {
2488               /* We didn't make a PLT entry for this symbol.  This
2489                  happens when statically linking PIC code, or when
2490                  using -Bsymbolic.  */
2491               break;
2492             }
2493
2494           relocation = (htab->splt->output_section->vma
2495                         + htab->splt->output_offset
2496                         + h->plt.offset);
2497           unresolved_reloc = FALSE;
2498           break;
2499
2500         case R_390_PLTOFF16:
2501         case R_390_PLTOFF32:
2502           /* Relocation is to the entry for this symbol in the
2503              procedure linkage table relative to the start of the GOT.  */
2504
2505           /* For local symbols or if we didn't make a PLT entry for
2506              this symbol resolve the symbol directly.  */
2507           if (   h == NULL
2508               || h->plt.offset == (bfd_vma) -1
2509               || htab->splt == NULL)
2510             {
2511               relocation -= htab->sgot->output_section->vma;
2512               break;
2513             }
2514
2515           relocation = (htab->splt->output_section->vma
2516                         + htab->splt->output_offset
2517                         + h->plt.offset
2518                         - htab->sgot->output_section->vma);
2519           unresolved_reloc = FALSE;
2520           break;
2521
2522         case R_390_8:
2523         case R_390_16:
2524         case R_390_32:
2525         case R_390_PC16:
2526         case R_390_PC16DBL:
2527         case R_390_PC32DBL:
2528         case R_390_PC32:
2529           if ((input_section->flags & SEC_ALLOC) == 0)
2530             break;
2531
2532           if ((info->shared
2533                && (h == NULL
2534                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2535                    || h->root.type != bfd_link_hash_undefweak)
2536                && ((r_type != R_390_PC16
2537                     && r_type != R_390_PC16DBL
2538                     && r_type != R_390_PC32DBL
2539                     && r_type != R_390_PC32)
2540                    || (h != NULL
2541                        && !SYMBOL_REFERENCES_LOCAL (info, h))))
2542               || (ELIMINATE_COPY_RELOCS
2543                   && !info->shared
2544                   && h != NULL
2545                   && h->dynindx != -1
2546                   && !h->non_got_ref
2547                   && ((h->def_dynamic
2548                        && !h->def_regular)
2549                       || h->root.type == bfd_link_hash_undefweak
2550                       || h->root.type == bfd_link_hash_undefined)))
2551             {
2552               Elf_Internal_Rela outrel;
2553               bfd_boolean skip, relocate;
2554               asection *sreloc;
2555               bfd_byte *loc;
2556
2557               /* When generating a shared object, these relocations
2558                  are copied into the output file to be resolved at run
2559                  time.  */
2560
2561               skip = FALSE;
2562               relocate = FALSE;
2563
2564               outrel.r_offset =
2565                 _bfd_elf_section_offset (output_bfd, info, input_section,
2566                                          rel->r_offset);
2567               if (outrel.r_offset == (bfd_vma) -1)
2568                 skip = TRUE;
2569               else if (outrel.r_offset == (bfd_vma) -2)
2570                 skip = TRUE, relocate = TRUE;
2571               outrel.r_offset += (input_section->output_section->vma
2572                                   + input_section->output_offset);
2573
2574               if (skip)
2575                 memset (&outrel, 0, sizeof outrel);
2576               else if (h != NULL
2577                        && h->dynindx != -1
2578                        && (r_type == R_390_PC16
2579                            || r_type == R_390_PC16DBL
2580                            || r_type == R_390_PC32DBL
2581                            || r_type == R_390_PC32
2582                            || !info->shared
2583                            || !info->symbolic
2584                            || !h->def_regular))
2585                 {
2586                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2587                   outrel.r_addend = rel->r_addend;
2588                 }
2589               else
2590                 {
2591                   /* This symbol is local, or marked to become local.  */
2592                   outrel.r_addend = relocation + rel->r_addend;
2593                   if (r_type == R_390_32)
2594                     {
2595                       relocate = TRUE;
2596                       outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2597                     }
2598                   else
2599                     {
2600                       long sindx;
2601
2602                       if (bfd_is_abs_section (sec))
2603                         sindx = 0;
2604                       else if (sec == NULL || sec->owner == NULL)
2605                         {
2606                           bfd_set_error(bfd_error_bad_value);
2607                           return FALSE;
2608                         }
2609                       else
2610                         {
2611                           asection *osec;
2612
2613                           osec = sec->output_section;
2614                           sindx = elf_section_data (osec)->dynindx;
2615                           if (sindx == 0)
2616                             {
2617                               osec = htab->elf.text_index_section;
2618                               sindx = elf_section_data (osec)->dynindx;
2619                             }
2620                           BFD_ASSERT (sindx != 0);
2621
2622                           /* We are turning this relocation into one
2623                              against a section symbol, so subtract out
2624                              the output section's address but not the
2625                              offset of the input section in the output
2626                              section.  */
2627                           outrel.r_addend -= osec->vma;
2628                         }
2629                       outrel.r_info = ELF32_R_INFO (sindx, r_type);
2630                     }
2631                 }
2632
2633               sreloc = elf_section_data (input_section)->sreloc;
2634               if (sreloc == NULL)
2635                 abort ();
2636
2637               loc = sreloc->contents;
2638               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2639               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2640
2641               /* If this reloc is against an external symbol, we do
2642                  not want to fiddle with the addend.  Otherwise, we
2643                  need to include the symbol value so that it becomes
2644                  an addend for the dynamic reloc.  */
2645               if (! relocate)
2646                 continue;
2647             }
2648           break;
2649
2650           /* Relocations for tls literal pool entries.  */
2651         case R_390_TLS_IE32:
2652           if (info->shared)
2653             {
2654               Elf_Internal_Rela outrel;
2655               asection *sreloc;
2656               bfd_byte *loc;
2657
2658               outrel.r_offset = rel->r_offset
2659                                 + input_section->output_section->vma
2660                                 + input_section->output_offset;
2661               outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2662               sreloc = elf_section_data (input_section)->sreloc;
2663               if (sreloc == NULL)
2664                 abort ();
2665               loc = sreloc->contents;
2666               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2667               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2668             }
2669           /* Fall through.  */
2670
2671         case R_390_TLS_GD32:
2672         case R_390_TLS_GOTIE32:
2673           r_type = elf_s390_tls_transition (info, r_type, h == NULL);
2674           tls_type = GOT_UNKNOWN;
2675           if (h == NULL && local_got_offsets)
2676             tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
2677           else if (h != NULL)
2678             {
2679               tls_type = elf_s390_hash_entry(h)->tls_type;
2680               if (!info->shared && h->dynindx == -1 && tls_type >= GOT_TLS_IE)
2681                 r_type = R_390_TLS_LE32;
2682             }
2683           if (r_type == R_390_TLS_GD32 && tls_type >= GOT_TLS_IE)
2684             r_type = R_390_TLS_IE32;
2685
2686           if (r_type == R_390_TLS_LE32)
2687             {
2688               /* This relocation gets optimized away by the local exec
2689                  access optimization.  */
2690               BFD_ASSERT (! unresolved_reloc);
2691               bfd_put_32 (output_bfd, -tpoff (info, relocation),
2692                           contents + rel->r_offset);
2693               continue;
2694             }
2695
2696           if (htab->sgot == NULL)
2697             abort ();
2698
2699           if (h != NULL)
2700             off = h->got.offset;
2701           else
2702             {
2703               if (local_got_offsets == NULL)
2704                 abort ();
2705
2706               off = local_got_offsets[r_symndx];
2707             }
2708
2709         emit_tls_relocs:
2710
2711           if ((off & 1) != 0)
2712             off &= ~1;
2713           else
2714             {
2715               Elf_Internal_Rela outrel;
2716               bfd_byte *loc;
2717               int dr_type, indx;
2718
2719               if (htab->srelgot == NULL)
2720                 abort ();
2721
2722               outrel.r_offset = (htab->sgot->output_section->vma
2723                                  + htab->sgot->output_offset + off);
2724
2725               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2726               if (r_type == R_390_TLS_GD32)
2727                 dr_type = R_390_TLS_DTPMOD;
2728               else
2729                 dr_type = R_390_TLS_TPOFF;
2730               if (dr_type == R_390_TLS_TPOFF && indx == 0)
2731                 outrel.r_addend = relocation - dtpoff_base (info);
2732               else
2733                 outrel.r_addend = 0;
2734               outrel.r_info = ELF32_R_INFO (indx, dr_type);
2735               loc = htab->srelgot->contents;
2736               loc += htab->srelgot->reloc_count++
2737                 * sizeof (Elf32_External_Rela);
2738               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2739
2740               if (r_type == R_390_TLS_GD32)
2741                 {
2742                   if (indx == 0)
2743                     {
2744                       BFD_ASSERT (! unresolved_reloc);
2745                       bfd_put_32 (output_bfd,
2746                                   relocation - dtpoff_base (info),
2747                                   htab->sgot->contents + off + GOT_ENTRY_SIZE);
2748                     }
2749                   else
2750                     {
2751                       outrel.r_info = ELF32_R_INFO (indx, R_390_TLS_DTPOFF);
2752                       outrel.r_offset += GOT_ENTRY_SIZE;
2753                       outrel.r_addend = 0;
2754                       htab->srelgot->reloc_count++;
2755                       loc += sizeof (Elf32_External_Rela);
2756                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2757                     }
2758                 }
2759
2760               if (h != NULL)
2761                 h->got.offset |= 1;
2762               else
2763                 local_got_offsets[r_symndx] |= 1;
2764             }
2765
2766           if (off >= (bfd_vma) -2)
2767             abort ();
2768           if (r_type == ELF32_R_TYPE (rel->r_info))
2769             {
2770               relocation = htab->sgot->output_offset + off;
2771               if (r_type == R_390_TLS_IE32 || r_type == R_390_TLS_IEENT)
2772                 relocation += htab->sgot->output_section->vma;
2773               unresolved_reloc = FALSE;
2774             }
2775           else
2776             {
2777               bfd_put_32 (output_bfd, htab->sgot->output_offset + off,
2778                           contents + rel->r_offset);
2779               continue;
2780             }
2781           break;
2782
2783         case R_390_TLS_GOTIE12:
2784         case R_390_TLS_GOTIE20:
2785         case R_390_TLS_IEENT:
2786           if (h == NULL)
2787             {
2788               if (local_got_offsets == NULL)
2789                 abort();
2790               off = local_got_offsets[r_symndx];
2791               if (info->shared)
2792                 goto emit_tls_relocs;
2793             }
2794           else
2795             {
2796               off = h->got.offset;
2797               tls_type = elf_s390_hash_entry(h)->tls_type;
2798               if (info->shared || h->dynindx != -1 || tls_type < GOT_TLS_IE)
2799                 goto emit_tls_relocs;
2800             }
2801
2802           if (htab->sgot == NULL)
2803             abort ();
2804
2805           BFD_ASSERT (! unresolved_reloc);
2806           bfd_put_32 (output_bfd, -tpoff (info, relocation),
2807                       htab->sgot->contents + off);
2808           relocation = htab->sgot->output_offset + off;
2809           if (r_type == R_390_TLS_IEENT)
2810             relocation += htab->sgot->output_section->vma;
2811           unresolved_reloc = FALSE;
2812           break;
2813
2814         case R_390_TLS_LDM32:
2815           if (! info->shared)
2816             /* The literal pool entry this relocation refers to gets ignored
2817                by the optimized code of the local exec model. Do nothing
2818                and the value will turn out zero.  */
2819             continue;
2820
2821           if (htab->sgot == NULL)
2822             abort ();
2823
2824           off = htab->tls_ldm_got.offset;
2825           if (off & 1)
2826             off &= ~1;
2827           else
2828             {
2829               Elf_Internal_Rela outrel;
2830               bfd_byte *loc;
2831
2832               if (htab->srelgot == NULL)
2833                 abort ();
2834
2835               outrel.r_offset = (htab->sgot->output_section->vma
2836                                  + htab->sgot->output_offset + off);
2837
2838               bfd_put_32 (output_bfd, 0,
2839                           htab->sgot->contents + off + GOT_ENTRY_SIZE);
2840               outrel.r_info = ELF32_R_INFO (0, R_390_TLS_DTPMOD);
2841               outrel.r_addend = 0;
2842               loc = htab->srelgot->contents;
2843               loc += htab->srelgot->reloc_count++
2844                 * sizeof (Elf32_External_Rela);
2845               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2846               htab->tls_ldm_got.offset |= 1;
2847             }
2848           relocation = htab->sgot->output_offset + off;
2849           unresolved_reloc = FALSE;
2850           break;
2851
2852         case R_390_TLS_LE32:
2853           if (info->shared)
2854             {
2855               /* Linking a shared library with non-fpic code requires
2856                  a R_390_TLS_TPOFF relocation.  */
2857               Elf_Internal_Rela outrel;
2858               asection *sreloc;
2859               bfd_byte *loc;
2860               int indx;
2861
2862               outrel.r_offset = rel->r_offset
2863                                 + input_section->output_section->vma
2864                                 + input_section->output_offset;
2865               if (h != NULL && h->dynindx != -1)
2866                 indx = h->dynindx;
2867               else
2868                 indx = 0;
2869               outrel.r_info = ELF32_R_INFO (indx, R_390_TLS_TPOFF);
2870               if (indx == 0)
2871                 outrel.r_addend = relocation - dtpoff_base (info);
2872               else
2873                 outrel.r_addend = 0;
2874               sreloc = elf_section_data (input_section)->sreloc;
2875               if (sreloc == NULL)
2876                 abort ();
2877               loc = sreloc->contents;
2878               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2879               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2880             }
2881           else
2882             {
2883               BFD_ASSERT (! unresolved_reloc);
2884               bfd_put_32 (output_bfd, -tpoff (info, relocation),
2885                           contents + rel->r_offset);
2886             }
2887           continue;
2888
2889         case R_390_TLS_LDO32:
2890           if (info->shared)
2891             relocation -= dtpoff_base (info);
2892           else
2893             /* When converting LDO to LE, we must negate.  */
2894             relocation = -tpoff (info, relocation);
2895           break;
2896
2897           /* Relocations for tls instructions.  */
2898         case R_390_TLS_LOAD:
2899         case R_390_TLS_GDCALL:
2900         case R_390_TLS_LDCALL:
2901           tls_type = GOT_UNKNOWN;
2902           if (h == NULL && local_got_offsets)
2903             tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
2904           else if (h != NULL)
2905             tls_type = elf_s390_hash_entry(h)->tls_type;
2906
2907           if (tls_type == GOT_TLS_GD)
2908             continue;
2909
2910           if (r_type == R_390_TLS_LOAD)
2911             {
2912               if (!info->shared && (h == NULL || h->dynindx == -1))
2913                 {
2914                   /* IE->LE transition. Four valid cases:
2915                      l %rx,0(0,%ry)    -> lr %rx,%ry + bcr 0,0
2916                      l %rx,0(%ry,0)    -> lr %rx,%ry + bcr 0,0
2917                      l %rx,0(%ry,%r12) -> lr %rx,%ry + bcr 0,0
2918                      l %rx,0(%r12,%ry) -> lr %rx,%ry + bcr 0,0 */
2919                   unsigned int insn, ry;
2920
2921                   insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2922                   ry = 0;
2923                   if ((insn & 0xff00f000) == 0x58000000)
2924                     /* l %rx,0(%ry,0) -> lr %rx,%ry + bcr 0,0  */
2925                     ry = (insn & 0x000f0000);
2926                   else if ((insn & 0xff0f0000) == 0x58000000)
2927                     /* l %rx,0(0,%ry) -> lr %rx,%ry + bcr 0,0  */
2928                     ry = (insn & 0x0000f000) << 4;
2929                   else if ((insn & 0xff00f000) == 0x5800c000)
2930                     /* l %rx,0(%ry,%r12) -> lr %rx,%ry + bcr 0,0  */
2931                     ry = (insn & 0x000f0000);
2932                   else if ((insn & 0xff0f0000) == 0x580c0000)
2933                     /* l %rx,0(%r12,%ry) -> lr %rx,%ry + bcr 0,0  */
2934                     ry = (insn & 0x0000f000) << 4;
2935                   else
2936                     invalid_tls_insn (input_bfd, input_section, rel);
2937                   insn = 0x18000700 | (insn & 0x00f00000) | ry;
2938                   bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
2939                 }
2940             }
2941           else if (r_type == R_390_TLS_GDCALL)
2942             {
2943               unsigned int insn;
2944
2945               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2946               if ((insn & 0xff000fff) != 0x4d000000 &&
2947                   (insn & 0xffff0000) != 0xc0e50000)
2948                 invalid_tls_insn (input_bfd, input_section, rel);
2949               if (!info->shared && (h == NULL || h->dynindx == -1))
2950                 {
2951                   if ((insn & 0xff000000) == 0x4d000000)
2952                     {
2953                       /* GD->LE transition.
2954                          bas %r14,0(%rx,%r13) -> bc 0,0  */
2955                       insn = 0x47000000;
2956                     }
2957                   else
2958                     {
2959                       /* GD->LE transition.
2960                          brasl %r14,_tls_get_addr@plt -> brcl 0,.  */
2961                       insn = 0xc0040000;
2962                       bfd_put_16 (output_bfd, 0x0000,
2963                                   contents + rel->r_offset + 4);
2964                     }
2965                 }
2966               else
2967                 {
2968                   if ((insn & 0xff000000) == 0x4d000000)
2969                     {
2970                       /* GD->IE transition.
2971                          bas %r14,0(%rx,%r13) -> l %r2,0(%r2,%r12)  */
2972                       insn = 0x5822c000;
2973                     }
2974                   else
2975                     {
2976                       /* GD->IE transition.
2977                          brasl %r14,__tls_get_addr@plt ->
2978                                 l %r2,0(%r2,%r12) ; bcr 0,0 */
2979                       insn = 0x5822c000;
2980                       bfd_put_16 (output_bfd, 0x0700,
2981                                   contents + rel->r_offset + 4);
2982                     }
2983                 }
2984               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
2985             }
2986           else if (r_type == R_390_TLS_LDCALL)
2987             {
2988               if (!info->shared)
2989                 {
2990                   unsigned int insn;
2991
2992                   insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2993                   if ((insn & 0xff000fff) != 0x4d000000 &&
2994                       (insn & 0xffff0000) != 0xc0e50000)
2995                     invalid_tls_insn (input_bfd, input_section, rel);
2996                   if ((insn & 0xff000000) == 0x4d000000)
2997                     {
2998                       /* LD->LE transition.
2999                          bas %r14,0(%rx,%r13) -> bc 0,0  */
3000                       insn = 0x47000000;
3001                     }
3002                   else
3003                     {
3004                       /* LD->LE transition.
3005                          brasl %r14,__tls_get_addr@plt -> brcl 0,. */
3006                       insn = 0xc0040000;
3007                       bfd_put_16 (output_bfd, 0x0000,
3008                                   contents + rel->r_offset + 4);
3009                     }
3010                   bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3011                 }
3012             }
3013           continue;
3014
3015         default:
3016           break;
3017         }
3018
3019       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3020          because such sections are not SEC_ALLOC and thus ld.so will
3021          not process them.  */
3022       if (unresolved_reloc
3023           && !((input_section->flags & SEC_DEBUGGING) != 0
3024                && h->def_dynamic))
3025         (*_bfd_error_handler)
3026           (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3027            input_bfd,
3028            input_section,
3029            (long) rel->r_offset,
3030            howto->name,
3031            h->root.root.string);
3032
3033       if (r_type == R_390_20
3034           || r_type == R_390_GOT20
3035           || r_type == R_390_GOTPLT20
3036           || r_type == R_390_TLS_GOTIE20)
3037         {
3038           relocation += rel->r_addend;
3039           relocation = (relocation&0xfff) << 8 | (relocation&0xff000) >> 12;
3040           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3041                                         contents, rel->r_offset,
3042                                         relocation, 0);
3043         }
3044       else
3045         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3046                                       contents, rel->r_offset,
3047                                       relocation, rel->r_addend);
3048
3049       if (r != bfd_reloc_ok)
3050         {
3051           const char *name;
3052
3053           if (h != NULL)
3054             name = h->root.root.string;
3055           else
3056             {
3057               name = bfd_elf_string_from_elf_section (input_bfd,
3058                                                       symtab_hdr->sh_link,
3059                                                       sym->st_name);
3060               if (name == NULL)
3061                 return FALSE;
3062               if (*name == '\0')
3063                 name = bfd_section_name (input_bfd, sec);
3064             }
3065
3066           if (r == bfd_reloc_overflow)
3067             {
3068
3069               if (! ((*info->callbacks->reloc_overflow)
3070                      (info, (h ? &h->root : NULL), name, howto->name,
3071                       (bfd_vma) 0, input_bfd, input_section,
3072                       rel->r_offset)))
3073                 return FALSE;
3074             }
3075           else
3076             {
3077               (*_bfd_error_handler)
3078                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3079                  input_bfd, input_section,
3080                  (long) rel->r_offset, name, (int) r);
3081               return FALSE;
3082             }
3083         }
3084     }
3085
3086   return TRUE;
3087 }
3088
3089 /* Finish up dynamic symbol handling.  We set the contents of various
3090    dynamic sections here.  */
3091
3092 static bfd_boolean
3093 elf_s390_finish_dynamic_symbol (output_bfd, info, h, sym)
3094      bfd *output_bfd;
3095      struct bfd_link_info *info;
3096      struct elf_link_hash_entry *h;
3097      Elf_Internal_Sym *sym;
3098 {
3099   struct elf_s390_link_hash_table *htab;
3100
3101   htab = elf_s390_hash_table (info);
3102
3103   if (h->plt.offset != (bfd_vma) -1)
3104     {
3105       bfd_vma plt_index;
3106       bfd_vma got_offset;
3107       Elf_Internal_Rela rela;
3108       bfd_byte *loc;
3109       bfd_vma relative_offset;
3110
3111       /* This symbol has an entry in the procedure linkage table.  Set
3112          it up.  */
3113       if (h->dynindx == -1
3114           || htab->splt == NULL
3115           || htab->sgotplt == NULL
3116           || htab->srelplt == NULL)
3117         abort ();
3118
3119       /* Calc. index no.
3120          Current offset - size first entry / entry size.  */
3121       plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3122
3123       /* Offset in GOT is PLT index plus GOT headers(3) times 4,
3124          addr & GOT addr.  */
3125       got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
3126
3127       /* S390 uses halfwords for relative branch calc!  */
3128       relative_offset = - ((PLT_FIRST_ENTRY_SIZE +
3129                             (PLT_ENTRY_SIZE * plt_index) + 18) / 2);
3130       /* If offset is > 32768, branch to a previous branch
3131          390 can only handle +-64 K jumps.  */
3132       if ( -32768 > (int) relative_offset )
3133         relative_offset
3134           = -(unsigned) (((65536 / PLT_ENTRY_SIZE - 1) * PLT_ENTRY_SIZE) / 2);
3135
3136       /* Fill in the entry in the procedure linkage table.  */
3137       if (!info->shared)
3138         {
3139           bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD0,
3140                       htab->splt->contents + h->plt.offset);
3141           bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD1,
3142                       htab->splt->contents + h->plt.offset + 4);
3143           bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD2,
3144                       htab->splt->contents + h->plt.offset + 8);
3145           bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD3,
3146                       htab->splt->contents + h->plt.offset + 12);
3147           bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD4,
3148                       htab->splt->contents + h->plt.offset + 16);
3149           bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3150                       htab->splt->contents + h->plt.offset + 20);
3151           bfd_put_32 (output_bfd,
3152                       (htab->sgotplt->output_section->vma
3153                        + htab->sgotplt->output_offset
3154                        + got_offset),
3155                       htab->splt->contents + h->plt.offset + 24);
3156         }
3157       else if (got_offset < 4096)
3158         {
3159           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC12_ENTRY_WORD0 + got_offset,
3160                       htab->splt->contents + h->plt.offset);
3161           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC12_ENTRY_WORD1,
3162                       htab->splt->contents + h->plt.offset + 4);
3163           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC12_ENTRY_WORD2,
3164                       htab->splt->contents + h->plt.offset + 8);
3165           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC12_ENTRY_WORD3,
3166                       htab->splt->contents + h->plt.offset + 12);
3167           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC12_ENTRY_WORD4,
3168                       htab->splt->contents + h->plt.offset + 16);
3169           bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3170                       htab->splt->contents + h->plt.offset + 20);
3171           bfd_put_32 (output_bfd, (bfd_vma) 0,
3172                       htab->splt->contents + h->plt.offset + 24);
3173         }
3174       else if (got_offset < 32768)
3175         {
3176           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC16_ENTRY_WORD0 + got_offset,
3177                       htab->splt->contents + h->plt.offset);
3178           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC16_ENTRY_WORD1,
3179                       htab->splt->contents + h->plt.offset + 4);
3180           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC16_ENTRY_WORD2,
3181                       htab->splt->contents + h->plt.offset + 8);
3182           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC16_ENTRY_WORD3,
3183                       htab->splt->contents + h->plt.offset + 12);
3184           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC16_ENTRY_WORD4,
3185                       htab->splt->contents + h->plt.offset + 16);
3186           bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3187                       htab->splt->contents + h->plt.offset + 20);
3188           bfd_put_32 (output_bfd, (bfd_vma) 0,
3189                       htab->splt->contents + h->plt.offset + 24);
3190         }
3191       else
3192         {
3193           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_ENTRY_WORD0,
3194                       htab->splt->contents + h->plt.offset);
3195           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_ENTRY_WORD1,
3196                       htab->splt->contents + h->plt.offset + 4);
3197           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_ENTRY_WORD2,
3198                       htab->splt->contents + h->plt.offset + 8);
3199           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_ENTRY_WORD3,
3200                       htab->splt->contents + h->plt.offset + 12);
3201           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_ENTRY_WORD4,
3202                       htab->splt->contents + h->plt.offset + 16);
3203           bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3204                       htab->splt->contents + h->plt.offset + 20);
3205           bfd_put_32 (output_bfd, got_offset,
3206                       htab->splt->contents + h->plt.offset + 24);
3207         }
3208       /* Insert offset into  reloc. table here.  */
3209       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
3210                   htab->splt->contents + h->plt.offset + 28);
3211
3212       /* Fill in the entry in the global offset table.
3213          Points to instruction after GOT offset.  */
3214       bfd_put_32 (output_bfd,
3215                   (htab->splt->output_section->vma
3216                    + htab->splt->output_offset
3217                    + h->plt.offset
3218                    + 12),
3219                   htab->sgotplt->contents + got_offset);
3220
3221       /* Fill in the entry in the .rela.plt section.  */
3222       rela.r_offset = (htab->sgotplt->output_section->vma
3223                        + htab->sgotplt->output_offset
3224                        + got_offset);
3225       rela.r_info = ELF32_R_INFO (h->dynindx, R_390_JMP_SLOT);
3226       rela.r_addend = 0;
3227       loc = htab->srelplt->contents + plt_index * sizeof (Elf32_External_Rela);
3228       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3229
3230       if (!h->def_regular)
3231         {
3232           /* Mark the symbol as undefined, rather than as defined in
3233              the .plt section.  Leave the value alone.  This is a clue
3234              for the dynamic linker, to make function pointer
3235              comparisons work between an application and shared
3236              library.  */
3237           sym->st_shndx = SHN_UNDEF;
3238         }
3239     }
3240
3241   if (h->got.offset != (bfd_vma) -1
3242       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_GD
3243       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE
3244       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE_NLT)
3245     {
3246       Elf_Internal_Rela rela;
3247       bfd_byte *loc;
3248
3249       /* This symbol has an entry in the global offset table.  Set it
3250          up.  */
3251
3252       if (htab->sgot == NULL || htab->srelgot == NULL)
3253         abort ();
3254
3255       rela.r_offset = (htab->sgot->output_section->vma
3256                        + htab->sgot->output_offset
3257                        + (h->got.offset &~ (bfd_vma) 1));
3258
3259       /* If this is a static link, or it is a -Bsymbolic link and the
3260          symbol is defined locally or was forced to be local because
3261          of a version file, we just want to emit a RELATIVE reloc.
3262          The entry in the global offset table will already have been
3263          initialized in the relocate_section function.  */
3264       if (info->shared
3265           && (info->symbolic
3266               || h->dynindx == -1
3267               || h->forced_local)
3268           && h->def_regular)
3269         {
3270           BFD_ASSERT((h->got.offset & 1) != 0);
3271           rela.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
3272           rela.r_addend = (h->root.u.def.value
3273                            + h->root.u.def.section->output_section->vma
3274                            + h->root.u.def.section->output_offset);
3275         }
3276       else
3277         {
3278           BFD_ASSERT((h->got.offset & 1) == 0);
3279           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgot->contents + h->got.offset);
3280           rela.r_info = ELF32_R_INFO (h->dynindx, R_390_GLOB_DAT);
3281           rela.r_addend = 0;
3282         }
3283
3284       loc = htab->srelgot->contents;
3285       loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
3286       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3287     }
3288
3289   if (h->needs_copy)
3290     {
3291       Elf_Internal_Rela rela;
3292       bfd_byte *loc;
3293
3294       /* This symbols needs a copy reloc.  Set it up.  */
3295
3296       if (h->dynindx == -1
3297           || (h->root.type != bfd_link_hash_defined
3298               && h->root.type != bfd_link_hash_defweak)
3299           || htab->srelbss == NULL)
3300         abort ();
3301
3302       rela.r_offset = (h->root.u.def.value
3303                        + h->root.u.def.section->output_section->vma
3304                        + h->root.u.def.section->output_offset);
3305       rela.r_info = ELF32_R_INFO (h->dynindx, R_390_COPY);
3306       rela.r_addend = 0;
3307       loc = htab->srelbss->contents;
3308       loc += htab->srelbss->reloc_count++ * sizeof (Elf32_External_Rela);
3309       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3310     }
3311
3312   /* Mark some specially defined symbols as absolute.  */
3313   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3314       || h == htab->elf.hgot
3315       || h == htab->elf.hplt)
3316     sym->st_shndx = SHN_ABS;
3317
3318   return TRUE;
3319 }
3320
3321 /* Used to decide how to sort relocs in an optimal manner for the
3322    dynamic linker, before writing them out.  */
3323
3324 static enum elf_reloc_type_class
3325 elf_s390_reloc_type_class (rela)
3326      const Elf_Internal_Rela *rela;
3327 {
3328   switch ((int) ELF32_R_TYPE (rela->r_info))
3329     {
3330     case R_390_RELATIVE:
3331       return reloc_class_relative;
3332     case R_390_JMP_SLOT:
3333       return reloc_class_plt;
3334     case R_390_COPY:
3335       return reloc_class_copy;
3336     default:
3337       return reloc_class_normal;
3338     }
3339 }
3340
3341 /* Finish up the dynamic sections.  */
3342
3343 static bfd_boolean
3344 elf_s390_finish_dynamic_sections (output_bfd, info)
3345      bfd *output_bfd;
3346      struct bfd_link_info *info;
3347 {
3348   struct elf_s390_link_hash_table *htab;
3349   bfd *dynobj;
3350   asection *sdyn;
3351
3352   htab = elf_s390_hash_table (info);
3353   dynobj = htab->elf.dynobj;
3354   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3355
3356   if (htab->elf.dynamic_sections_created)
3357     {
3358       Elf32_External_Dyn *dyncon, *dynconend;
3359
3360       if (sdyn == NULL || htab->sgot == NULL)
3361         abort ();
3362
3363       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3364       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3365       for (; dyncon < dynconend; dyncon++)
3366         {
3367           Elf_Internal_Dyn dyn;
3368           asection *s;
3369
3370           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3371
3372           switch (dyn.d_tag)
3373             {
3374             default:
3375               continue;
3376
3377             case DT_PLTGOT:
3378               dyn.d_un.d_ptr = htab->sgot->output_section->vma;
3379               break;
3380
3381             case DT_JMPREL:
3382               dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
3383               break;
3384
3385             case DT_PLTRELSZ:
3386               s = htab->srelplt->output_section;
3387               dyn.d_un.d_val = s->size;
3388               break;
3389             }
3390
3391           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3392         }
3393
3394       /* Fill in the special first entry in the procedure linkage table.  */
3395       if (htab->splt && htab->splt->size > 0)
3396         {
3397           memset (htab->splt->contents, 0, PLT_FIRST_ENTRY_SIZE);
3398           if (info->shared)
3399             {
3400               bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_FIRST_ENTRY_WORD0,
3401                           htab->splt->contents );
3402               bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_FIRST_ENTRY_WORD1,
3403                           htab->splt->contents +4 );
3404               bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_FIRST_ENTRY_WORD2,
3405                           htab->splt->contents +8 );
3406               bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_FIRST_ENTRY_WORD3,
3407                           htab->splt->contents +12 );
3408               bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_FIRST_ENTRY_WORD4,
3409                           htab->splt->contents +16 );
3410            }
3411           else
3412            {
3413               bfd_put_32 (output_bfd, (bfd_vma)PLT_FIRST_ENTRY_WORD0,
3414                           htab->splt->contents );
3415               bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD1,
3416                           htab->splt->contents +4 );
3417               bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD2,
3418                           htab->splt->contents +8 );
3419               bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD3,
3420                           htab->splt->contents +12 );
3421               bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD4,
3422                           htab->splt->contents +16 );
3423               bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD5,
3424                           htab->splt->contents +20 );
3425               bfd_put_32 (output_bfd,
3426                           htab->sgotplt->output_section->vma
3427                           + htab->sgotplt->output_offset,
3428                           htab->splt->contents + 24);
3429            }
3430           elf_section_data (htab->splt->output_section)
3431             ->this_hdr.sh_entsize = 4;
3432         }
3433
3434     }
3435
3436   if (htab->sgotplt)
3437     {
3438       /* Fill in the first three entries in the global offset table.  */
3439       if (htab->sgotplt->size > 0)
3440         {
3441           bfd_put_32 (output_bfd,
3442                       (sdyn == NULL ? (bfd_vma) 0
3443                        : sdyn->output_section->vma + sdyn->output_offset),
3444                       htab->sgotplt->contents);
3445           /* One entry for shared object struct ptr.  */
3446           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 4);
3447           /* One entry for _dl_runtime_resolve.  */
3448           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
3449         }
3450
3451       elf_section_data (htab->sgotplt->output_section)
3452         ->this_hdr.sh_entsize = 4;
3453     }
3454   return TRUE;
3455 }
3456
3457 static bfd_boolean
3458 elf_s390_grok_prstatus (abfd, note)
3459      bfd * abfd;
3460      Elf_Internal_Note * note;
3461 {
3462   int offset;
3463   unsigned int size;
3464
3465   switch (note->descsz)
3466     {
3467       default:
3468         return FALSE;
3469
3470       case 224:         /* S/390 Linux.  */
3471         /* pr_cursig */
3472         elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
3473
3474         /* pr_pid */
3475         elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
3476
3477         /* pr_reg */
3478         offset = 72;
3479         size = 144;
3480         break;
3481     }
3482
3483   /* Make a ".reg/999" section.  */
3484   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3485                                           size, note->descpos + offset);
3486 }
3487
3488 /* Return address for Ith PLT stub in section PLT, for relocation REL
3489    or (bfd_vma) -1 if it should not be included.  */
3490
3491 static bfd_vma
3492 elf_s390_plt_sym_val (bfd_vma i, const asection *plt,
3493                       const arelent *rel ATTRIBUTE_UNUSED)
3494 {
3495   return plt->vma + PLT_FIRST_ENTRY_SIZE + i * PLT_ENTRY_SIZE;
3496 }
3497
3498
3499 #define TARGET_BIG_SYM  bfd_elf32_s390_vec
3500 #define TARGET_BIG_NAME "elf32-s390"
3501 #define ELF_ARCH        bfd_arch_s390
3502 #define ELF_MACHINE_CODE EM_S390
3503 #define ELF_MACHINE_ALT1 EM_S390_OLD
3504 #define ELF_MAXPAGESIZE 0x1000
3505
3506 #define elf_backend_can_gc_sections     1
3507 #define elf_backend_can_refcount        1
3508 #define elf_backend_want_got_plt        1
3509 #define elf_backend_plt_readonly        1
3510 #define elf_backend_want_plt_sym        0
3511 #define elf_backend_got_header_size     12
3512 #define elf_backend_rela_normal         1
3513
3514 #define elf_info_to_howto                     elf_s390_info_to_howto
3515
3516 #define bfd_elf32_bfd_is_local_label_name     elf_s390_is_local_label_name
3517 #define bfd_elf32_bfd_link_hash_table_create  elf_s390_link_hash_table_create
3518 #define bfd_elf32_bfd_reloc_type_lookup       elf_s390_reloc_type_lookup
3519 #define bfd_elf32_bfd_reloc_name_lookup elf_s390_reloc_name_lookup
3520
3521 #define elf_backend_adjust_dynamic_symbol     elf_s390_adjust_dynamic_symbol
3522 #define elf_backend_check_relocs              elf_s390_check_relocs
3523 #define elf_backend_copy_indirect_symbol      elf_s390_copy_indirect_symbol
3524 #define elf_backend_create_dynamic_sections   elf_s390_create_dynamic_sections
3525 #define elf_backend_finish_dynamic_sections   elf_s390_finish_dynamic_sections
3526 #define elf_backend_finish_dynamic_symbol     elf_s390_finish_dynamic_symbol
3527 #define elf_backend_gc_mark_hook              elf_s390_gc_mark_hook
3528 #define elf_backend_gc_sweep_hook             elf_s390_gc_sweep_hook
3529 #define elf_backend_reloc_type_class          elf_s390_reloc_type_class
3530 #define elf_backend_relocate_section          elf_s390_relocate_section
3531 #define elf_backend_size_dynamic_sections     elf_s390_size_dynamic_sections
3532 #define elf_backend_init_index_section        _bfd_elf_init_1_index_section
3533 #define elf_backend_reloc_type_class          elf_s390_reloc_type_class
3534 #define elf_backend_grok_prstatus             elf_s390_grok_prstatus
3535 #define elf_backend_plt_sym_val               elf_s390_plt_sym_val
3536
3537 #define bfd_elf32_mkobject              elf_s390_mkobject
3538 #define elf_backend_object_p            elf_s390_object_p
3539
3540 #include "elf32-target.h"