bfd/elf32-s390.c

   1 /* IBM S/390-specific support for 32-bit ELF
   2    Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
   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 2 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 "bfd.h"
  24 #include "sysdep.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 struct elf_s390_obj_tdata
 678 {
 679   struct elf_obj_tdata root;
 680
 681   /* tls_type for each local got entry.  */
 682   char *local_got_tls_type;
 683 };
 684
 685 #define elf_s390_tdata(abfd) \
 686   ((struct elf_s390_obj_tdata *) (abfd)->tdata.any)
 687
 688 #define elf_s390_local_got_tls_type(abfd) \
 689   (elf_s390_tdata (abfd)->local_got_tls_type)
 690
 691 static bfd_boolean
 692 elf_s390_mkobject (bfd *abfd)
 693 {
 694   if (abfd->tdata.any == NULL)
 695     {
 696       bfd_size_type amt = sizeof (struct elf_s390_obj_tdata);
 697       abfd->tdata.any = bfd_zalloc (abfd, amt);
 698       if (abfd->tdata.any == NULL)
 699         return FALSE;
 700     }
 701   return bfd_elf_mkobject (abfd);
 702 }
 703
 704 static bfd_boolean
 705 elf_s390_object_p (abfd)
 706      bfd *abfd;
 707 {
 708   /* Set the right machine number for an s390 elf32 file.  */
 709   return bfd_default_set_arch_mach (abfd, bfd_arch_s390, bfd_mach_s390_31);
 710 }
 711
 712 /* s390 ELF linker hash table.  */
 713
 714 struct elf_s390_link_hash_table
 715 {
 716   struct elf_link_hash_table elf;
 717
 718   /* Short-cuts to get to dynamic linker sections.  */
 719   asection *sgot;
 720   asection *sgotplt;
 721   asection *srelgot;
 722   asection *splt;
 723   asection *srelplt;
 724   asection *sdynbss;
 725   asection *srelbss;
 726
 727   union {
 728     bfd_signed_vma refcount;
 729     bfd_vma offset;
 730   } tls_ldm_got;
 731
 732   /* Small local sym to section mapping cache.  */
 733   struct sym_sec_cache sym_sec;
 734 };
 735
 736 /* Get the s390 ELF linker hash table from a link_info structure.  */
 737
 738 #define elf_s390_hash_table(p) \
 739   ((struct elf_s390_link_hash_table *) ((p)->hash))
 740
 741 /* Create an entry in an s390 ELF linker hash table.  */
 742
 743 static struct bfd_hash_entry *
 744 link_hash_newfunc (entry, table, string)
 745      struct bfd_hash_entry *entry;
 746      struct bfd_hash_table *table;
 747      const char *string;
 748 {
 749   /* Allocate the structure if it has not already been allocated by a
 750      subclass.  */
 751   if (entry == NULL)
 752     {
 753       entry = bfd_hash_allocate (table,
 754                                  sizeof (struct elf_s390_link_hash_entry));
 755       if (entry == NULL)
 756         return entry;
 757     }
 758
 759   /* Call the allocation method of the superclass.  */
 760   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
 761   if (entry != NULL)
 762     {
 763       struct elf_s390_link_hash_entry *eh;
 764
 765       eh = (struct elf_s390_link_hash_entry *) entry;
 766       eh->dyn_relocs = NULL;
 767       eh->gotplt_refcount = 0;
 768       eh->tls_type = GOT_UNKNOWN;
 769     }
 770
 771   return entry;
 772 }
 773
 774 /* Create an s390 ELF linker hash table.  */
 775
 776 static struct bfd_link_hash_table *
 777 elf_s390_link_hash_table_create (abfd)
 778      bfd *abfd;
 779 {
 780   struct elf_s390_link_hash_table *ret;
 781   bfd_size_type amt = sizeof (struct elf_s390_link_hash_table);
 782
 783   ret = (struct elf_s390_link_hash_table *) bfd_malloc (amt);
 784   if (ret == NULL)
 785     return NULL;
 786
 787   if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
 788                                       sizeof (struct elf_s390_link_hash_entry)))
 789     {
 790       free (ret);
 791       return NULL;
 792     }
 793
 794   ret->sgot = NULL;
 795   ret->sgotplt = NULL;
 796   ret->srelgot = NULL;
 797   ret->splt = NULL;
 798   ret->srelplt = NULL;
 799   ret->sdynbss = NULL;
 800   ret->srelbss = NULL;
 801   ret->tls_ldm_got.refcount = 0;
 802   ret->sym_sec.abfd = NULL;
 803
 804   return &ret->elf.root;
 805 }
 806
 807 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
 808    shortcuts to them in our hash table.  */
 809
 810 static bfd_boolean
 811 create_got_section (dynobj, info)
 812      bfd *dynobj;
 813      struct bfd_link_info *info;
 814 {
 815   struct elf_s390_link_hash_table *htab;
 816
 817   if (! _bfd_elf_create_got_section (dynobj, info))
 818     return FALSE;
 819
 820   htab = elf_s390_hash_table (info);
 821   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
 822   htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
 823   if (!htab->sgot || !htab->sgotplt)
 824     abort ();
 825
 826   htab->srelgot = bfd_make_section_with_flags (dynobj, ".rela.got",
 827                                                (SEC_ALLOC | SEC_LOAD
 828                                                 | SEC_HAS_CONTENTS
 829                                                 | SEC_IN_MEMORY
 830                                                 | SEC_LINKER_CREATED
 831                                                 | SEC_READONLY));
 832   if (htab->srelgot == NULL
 833       || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
 834     return FALSE;
 835   return TRUE;
 836 }
 837
 838 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
 839    .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
 840    hash table.  */
 841
 842 static bfd_boolean
 843 elf_s390_create_dynamic_sections (dynobj, info)
 844      bfd *dynobj;
 845      struct bfd_link_info *info;
 846 {
 847   struct elf_s390_link_hash_table *htab;
 848
 849   htab = elf_s390_hash_table (info);
 850   if (!htab->sgot && !create_got_section (dynobj, info))
 851     return FALSE;
 852
 853   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
 854     return FALSE;
 855
 856   htab->splt = bfd_get_section_by_name (dynobj, ".plt");
 857   htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
 858   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
 859   if (!info->shared)
 860     htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
 861
 862   if (!htab->splt || !htab->srelplt || !htab->sdynbss
 863       || (!info->shared && !htab->srelbss))
 864     abort ();
 865
 866   return TRUE;
 867 }
 868
 869 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
 870
 871 static void
 872 elf_s390_copy_indirect_symbol (info, dir, ind)
 873      struct bfd_link_info *info;
 874      struct elf_link_hash_entry *dir, *ind;
 875 {
 876   struct elf_s390_link_hash_entry *edir, *eind;
 877
 878   edir = (struct elf_s390_link_hash_entry *) dir;
 879   eind = (struct elf_s390_link_hash_entry *) ind;
 880
 881   if (eind->dyn_relocs != NULL)
 882     {
 883       if (edir->dyn_relocs != NULL)
 884         {
 885           struct elf_s390_dyn_relocs **pp;
 886           struct elf_s390_dyn_relocs *p;
 887
 888           /* Add reloc counts against the indirect sym to the direct sym
 889              list.  Merge any entries against the same section.  */
 890           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
 891             {
 892               struct elf_s390_dyn_relocs *q;
 893
 894               for (q = edir->dyn_relocs; q != NULL; q = q->next)
 895                 if (q->sec == p->sec)
 896                   {
 897                     q->pc_count += p->pc_count;
 898                     q->count += p->count;
 899                     *pp = p->next;
 900                     break;
 901                   }
 902               if (q == NULL)
 903                 pp = &p->next;
 904             }
 905           *pp = edir->dyn_relocs;
 906         }
 907
 908       edir->dyn_relocs = eind->dyn_relocs;
 909       eind->dyn_relocs = NULL;
 910     }
 911
 912   if (ind->root.type == bfd_link_hash_indirect
 913       && dir->got.refcount <= 0)
 914     {
 915       edir->tls_type = eind->tls_type;
 916       eind->tls_type = GOT_UNKNOWN;
 917     }
 918
 919   if (ELIMINATE_COPY_RELOCS
 920       && ind->root.type != bfd_link_hash_indirect
 921       && dir->dynamic_adjusted)
 922     {
 923       /* If called to transfer flags for a weakdef during processing
 924          of elf_adjust_dynamic_symbol, don't copy non_got_ref.
 925          We clear it ourselves for ELIMINATE_COPY_RELOCS.  */
 926       dir->ref_dynamic |= ind->ref_dynamic;
 927       dir->ref_regular |= ind->ref_regular;
 928       dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
 929       dir->needs_plt |= ind->needs_plt;
 930     }
 931   else
 932     _bfd_elf_link_hash_copy_indirect (info, dir, ind);
 933 }
 934
 935 static int
 936 elf_s390_tls_transition (info, r_type, is_local)
 937      struct bfd_link_info *info;
 938      int r_type;
 939      int is_local;
 940 {
 941   if (info->shared)
 942     return r_type;
 943
 944   switch (r_type)
 945     {
 946     case R_390_TLS_GD32:
 947     case R_390_TLS_IE32:
 948       if (is_local)
 949         return R_390_TLS_LE32;
 950       return R_390_TLS_IE32;
 951     case R_390_TLS_GOTIE32:
 952       if (is_local)
 953         return R_390_TLS_LE32;
 954       return R_390_TLS_GOTIE32;
 955     case R_390_TLS_LDM32:
 956       return R_390_TLS_LE32;
 957     }
 958
 959   return r_type;
 960 }
 961
 962 /* Look through the relocs for a section during the first phase, and
 963    allocate space in the global offset table or procedure linkage
 964    table.  */
 965
 966 static bfd_boolean
 967 elf_s390_check_relocs (abfd, info, sec, relocs)
 968      bfd *abfd;
 969      struct bfd_link_info *info;
 970      asection *sec;
 971      const Elf_Internal_Rela *relocs;
 972 {
 973   struct elf_s390_link_hash_table *htab;
 974   Elf_Internal_Shdr *symtab_hdr;
 975   struct elf_link_hash_entry **sym_hashes;
 976   const Elf_Internal_Rela *rel;
 977   const Elf_Internal_Rela *rel_end;
 978   asection *sreloc;
 979   bfd_signed_vma *local_got_refcounts;
 980   int tls_type, old_tls_type;
 981
 982   if (info->relocatable)
 983     return TRUE;
 984
 985   htab = elf_s390_hash_table (info);
 986   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 987   sym_hashes = elf_sym_hashes (abfd);
 988   local_got_refcounts = elf_local_got_refcounts (abfd);
 989
 990   sreloc = NULL;
 991
 992   rel_end = relocs + sec->reloc_count;
 993   for (rel = relocs; rel < rel_end; rel++)
 994     {
 995       unsigned int r_type;
 996       unsigned long r_symndx;
 997       struct elf_link_hash_entry *h;
 998
 999       r_symndx = ELF32_R_SYM (rel->r_info);
1000
1001       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
1002         {
1003           (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1004                                  abfd, r_symndx);
1005           return FALSE;
1006         }
1007
1008       if (r_symndx < symtab_hdr->sh_info)
1009         h = NULL;
1010       else
1011         {
1012           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1013           while (h->root.type == bfd_link_hash_indirect
1014                  || h->root.type == bfd_link_hash_warning)
1015             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1016         }
1017
1018       /* Create got section and local_got_refcounts array if they
1019          are needed.  */
1020       r_type = elf_s390_tls_transition (info,
1021                                         ELF32_R_TYPE (rel->r_info),
1022                                         h == NULL);
1023       switch (r_type)
1024         {
1025         case R_390_GOT12:
1026         case R_390_GOT16:
1027         case R_390_GOT20:
1028         case R_390_GOT32:
1029         case R_390_GOTENT:
1030         case R_390_GOTPLT12:
1031         case R_390_GOTPLT16:
1032         case R_390_GOTPLT20:
1033         case R_390_GOTPLT32:
1034         case R_390_GOTPLTENT:
1035         case R_390_TLS_GD32:
1036         case R_390_TLS_GOTIE12:
1037         case R_390_TLS_GOTIE20:
1038         case R_390_TLS_GOTIE32:
1039         case R_390_TLS_IEENT:
1040         case R_390_TLS_IE32:
1041         case R_390_TLS_LDM32:
1042           if (h == NULL
1043               && local_got_refcounts == NULL)
1044             {
1045               bfd_size_type size;
1046
1047               size = symtab_hdr->sh_info;
1048               size *= (sizeof (bfd_signed_vma) + sizeof(char));
1049               local_got_refcounts = ((bfd_signed_vma *)
1050                                      bfd_zalloc (abfd, size));
1051               if (local_got_refcounts == NULL)
1052                 return FALSE;
1053               elf_local_got_refcounts (abfd) = local_got_refcounts;
1054               elf_s390_local_got_tls_type (abfd)
1055                 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
1056             }
1057           /* Fall through.  */
1058         case R_390_GOTOFF16:
1059         case R_390_GOTOFF32:
1060         case R_390_GOTPC:
1061         case R_390_GOTPCDBL:
1062           if (htab->sgot == NULL)
1063             {
1064               if (htab->elf.dynobj == NULL)
1065                 htab->elf.dynobj = abfd;
1066               if (!create_got_section (htab->elf.dynobj, info))
1067                 return FALSE;
1068             }
1069         }
1070
1071       switch (r_type)
1072         {
1073         case R_390_GOTOFF16:
1074         case R_390_GOTOFF32:
1075         case R_390_GOTPC:
1076         case R_390_GOTPCDBL:
1077           /* Got is created, nothing to be done.  */
1078           break;
1079
1080         case R_390_PLT16DBL:
1081         case R_390_PLT32DBL:
1082         case R_390_PLT32:
1083         case R_390_PLTOFF16:
1084         case R_390_PLTOFF32:
1085           /* This symbol requires a procedure linkage table entry.  We
1086              actually build the entry in adjust_dynamic_symbol,
1087              because this might be a case of linking PIC code which is
1088              never referenced by a dynamic object, in which case we
1089              don't need to generate a procedure linkage table entry
1090              after all.  */
1091
1092           /* If this is a local symbol, we resolve it directly without
1093              creating a procedure linkage table entry.  */
1094           if (h != NULL)
1095             {
1096               h->needs_plt = 1;
1097               h->plt.refcount += 1;
1098             }
1099           break;
1100
1101         case R_390_GOTPLT12:
1102         case R_390_GOTPLT16:
1103         case R_390_GOTPLT20:
1104         case R_390_GOTPLT32:
1105         case R_390_GOTPLTENT:
1106           /* This symbol requires either a procedure linkage table entry
1107              or an entry in the local got. We actually build the entry
1108              in adjust_dynamic_symbol because whether this is really a
1109              global reference can change and with it the fact if we have
1110              to create a plt entry or a local got entry. To be able to
1111              make a once global symbol a local one we have to keep track
1112              of the number of gotplt references that exist for this
1113              symbol.  */
1114           if (h != NULL)
1115             {
1116               ((struct elf_s390_link_hash_entry *) h)->gotplt_refcount++;
1117               h->needs_plt = 1;
1118               h->plt.refcount += 1;
1119             }
1120           else
1121             local_got_refcounts[r_symndx] += 1;
1122           break;
1123
1124         case R_390_TLS_LDM32:
1125           htab->tls_ldm_got.refcount += 1;
1126           break;
1127
1128         case R_390_TLS_IE32:
1129         case R_390_TLS_GOTIE12:
1130         case R_390_TLS_GOTIE20:
1131         case R_390_TLS_GOTIE32:
1132         case R_390_TLS_IEENT:
1133           if (info->shared)
1134             info->flags |= DF_STATIC_TLS;
1135           /* Fall through.  */
1136
1137         case R_390_GOT12:
1138         case R_390_GOT16:
1139         case R_390_GOT20:
1140         case R_390_GOT32:
1141         case R_390_GOTENT:
1142         case R_390_TLS_GD32:
1143           /* This symbol requires a global offset table entry.  */
1144           switch (r_type)
1145             {
1146             default:
1147             case R_390_GOT12:
1148             case R_390_GOT16:
1149             case R_390_GOT20:
1150             case R_390_GOT32:
1151             case R_390_GOTENT:
1152               tls_type = GOT_NORMAL;
1153               break;
1154             case R_390_TLS_GD32:
1155               tls_type = GOT_TLS_GD;
1156               break;
1157             case R_390_TLS_IE32:
1158             case R_390_TLS_GOTIE32:
1159               tls_type = GOT_TLS_IE;
1160               break;
1161             case R_390_TLS_GOTIE12:
1162             case R_390_TLS_GOTIE20:
1163             case R_390_TLS_IEENT:
1164               tls_type = GOT_TLS_IE_NLT;
1165               break;
1166             }
1167
1168           if (h != NULL)
1169             {
1170               h->got.refcount += 1;
1171               old_tls_type = elf_s390_hash_entry(h)->tls_type;
1172             }
1173           else
1174             {
1175               local_got_refcounts[r_symndx] += 1;
1176               old_tls_type = elf_s390_local_got_tls_type (abfd) [r_symndx];
1177             }
1178           /* If a TLS symbol is accessed using IE at least once,
1179              there is no point to use dynamic model for it.  */
1180           if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN)
1181             {
1182               if (old_tls_type == GOT_NORMAL || tls_type == GOT_NORMAL)
1183                 {
1184                   (*_bfd_error_handler)
1185                     (_("%B: `%s' accessed both as normal and thread local symbol"),
1186                      abfd, h->root.root.string);
1187                   return FALSE;
1188                 }
1189               if (old_tls_type > tls_type)
1190                 tls_type = old_tls_type;
1191             }
1192
1193           if (old_tls_type != tls_type)
1194             {
1195               if (h != NULL)
1196                 elf_s390_hash_entry (h)->tls_type = tls_type;
1197               else
1198                 elf_s390_local_got_tls_type (abfd) [r_symndx] = tls_type;
1199             }
1200
1201           if (r_type != R_390_TLS_IE32)
1202             break;
1203           /* Fall through.  */
1204
1205         case R_390_TLS_LE32:
1206           if (!info->shared)
1207             break;
1208           info->flags |= DF_STATIC_TLS;
1209           /* Fall through.  */
1210
1211         case R_390_8:
1212         case R_390_16:
1213         case R_390_32:
1214         case R_390_PC16:
1215         case R_390_PC16DBL:
1216         case R_390_PC32DBL:
1217         case R_390_PC32:
1218           if (h != NULL && !info->shared)
1219             {
1220               /* If this reloc is in a read-only section, we might
1221                  need a copy reloc.  We can't check reliably at this
1222                  stage whether the section is read-only, as input
1223                  sections have not yet been mapped to output sections.
1224                  Tentatively set the flag for now, and correct in
1225                  adjust_dynamic_symbol.  */
1226               h->non_got_ref = 1;
1227
1228               /* We may need a .plt entry if the function this reloc
1229                  refers to is in a shared lib.  */
1230               h->plt.refcount += 1;
1231             }
1232
1233           /* If we are creating a shared library, and this is a reloc
1234              against a global symbol, or a non PC relative reloc
1235              against a local symbol, then we need to copy the reloc
1236              into the shared library.  However, if we are linking with
1237              -Bsymbolic, we do not need to copy a reloc against a
1238              global symbol which is defined in an object we are
1239              including in the link (i.e., DEF_REGULAR is set).  At
1240              this point we have not seen all the input files, so it is
1241              possible that DEF_REGULAR is not set now but will be set
1242              later (it is never cleared).  In case of a weak definition,
1243              DEF_REGULAR may be cleared later by a strong definition in
1244              a shared library. We account for that possibility below by
1245              storing information in the relocs_copied field of the hash
1246              table entry.  A similar situation occurs when creating
1247              shared libraries and symbol visibility changes render the
1248              symbol local.
1249
1250              If on the other hand, we are creating an executable, we
1251              may need to keep relocations for symbols satisfied by a
1252              dynamic library if we manage to avoid copy relocs for the
1253              symbol.  */
1254           if ((info->shared
1255                && (sec->flags & SEC_ALLOC) != 0
1256                && ((ELF32_R_TYPE (rel->r_info) != R_390_PC16
1257                     && ELF32_R_TYPE (rel->r_info) != R_390_PC16DBL
1258                     && ELF32_R_TYPE (rel->r_info) != R_390_PC32DBL
1259                     && ELF32_R_TYPE (rel->r_info) != R_390_PC32)
1260                    || (h != NULL
1261                        && (! info->symbolic
1262                            || h->root.type == bfd_link_hash_defweak
1263                            || !h->def_regular))))
1264               || (ELIMINATE_COPY_RELOCS
1265                   && !info->shared
1266                   && (sec->flags & SEC_ALLOC) != 0
1267                   && h != NULL
1268                   && (h->root.type == bfd_link_hash_defweak
1269                       || !h->def_regular)))
1270             {
1271               struct elf_s390_dyn_relocs *p;
1272               struct elf_s390_dyn_relocs **head;
1273
1274               /* We must copy these reloc types into the output file.
1275                  Create a reloc section in dynobj and make room for
1276                  this reloc.  */
1277               if (sreloc == NULL)
1278                 {
1279                   const char *name;
1280                   bfd *dynobj;
1281
1282                   name = (bfd_elf_string_from_elf_section
1283                           (abfd,
1284                            elf_elfheader (abfd)->e_shstrndx,
1285                            elf_section_data (sec)->rel_hdr.sh_name));
1286                   if (name == NULL)
1287                     return FALSE;
1288
1289                   if (! CONST_STRNEQ (name, ".rela")
1290                       || strcmp (bfd_get_section_name (abfd, sec),
1291                                  name + 5) != 0)
1292                     {
1293                       (*_bfd_error_handler)
1294                         (_("%B: bad relocation section name `%s\'"),
1295                          abfd, name);
1296                     }
1297
1298                   if (htab->elf.dynobj == NULL)
1299                     htab->elf.dynobj = abfd;
1300
1301                   dynobj = htab->elf.dynobj;
1302                   sreloc = bfd_get_section_by_name (dynobj, name);
1303                   if (sreloc == NULL)
1304                     {
1305                       flagword flags;
1306
1307                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
1308                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1309                       if ((sec->flags & SEC_ALLOC) != 0)
1310                         flags |= SEC_ALLOC | SEC_LOAD;
1311                       sreloc = bfd_make_section_with_flags (dynobj,
1312                                                             name,
1313                                                             flags);
1314                       if (sreloc == NULL
1315                           || ! bfd_set_section_alignment (dynobj, sreloc, 2))
1316                         return FALSE;
1317                     }
1318                   elf_section_data (sec)->sreloc = sreloc;
1319                 }
1320
1321               /* If this is a global symbol, we count the number of
1322                  relocations we need for this symbol.  */
1323               if (h != NULL)
1324                 {
1325                   head = &((struct elf_s390_link_hash_entry *) h)->dyn_relocs;
1326                 }
1327               else
1328                 {
1329                   /* Track dynamic relocs needed for local syms too.
1330                      We really need local syms available to do this
1331                      easily.  Oh well.  */
1332                   asection *s;
1333                   void *vpp;
1334
1335                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1336                                                  sec, r_symndx);
1337                   if (s == NULL)
1338                     return FALSE;
1339
1340                   vpp = &elf_section_data (s)->local_dynrel;
1341                   head = (struct elf_s390_dyn_relocs **) vpp;
1342                 }
1343
1344               p = *head;
1345               if (p == NULL || p->sec != sec)
1346                 {
1347                   bfd_size_type amt = sizeof *p;
1348
1349                   p = ((struct elf_s390_dyn_relocs *)
1350                        bfd_alloc (htab->elf.dynobj, amt));
1351                   if (p == NULL)
1352                     return FALSE;
1353                   p->next = *head;
1354                   *head = p;
1355                   p->sec = sec;
1356                   p->count = 0;
1357                   p->pc_count = 0;
1358                 }
1359
1360               p->count += 1;
1361               if (ELF32_R_TYPE (rel->r_info) == R_390_PC16
1362                   || ELF32_R_TYPE (rel->r_info) == R_390_PC16DBL
1363                   || ELF32_R_TYPE (rel->r_info) == R_390_PC32DBL
1364                   || ELF32_R_TYPE (rel->r_info) == R_390_PC32)
1365                 p->pc_count += 1;
1366             }
1367           break;
1368
1369           /* This relocation describes the C++ object vtable hierarchy.
1370              Reconstruct it for later use during GC.  */
1371         case R_390_GNU_VTINHERIT:
1372           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1373             return FALSE;
1374           break;
1375
1376           /* This relocation describes which C++ vtable entries are actually
1377              used.  Record for later use during GC.  */
1378         case R_390_GNU_VTENTRY:
1379           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1380             return FALSE;
1381           break;
1382
1383         default:
1384           break;
1385         }
1386     }
1387
1388   return TRUE;
1389 }
1390
1391 /* Return the section that should be marked against GC for a given
1392    relocation.  */
1393
1394 static asection *
1395 elf_s390_gc_mark_hook (asection *sec,
1396                        struct bfd_link_info *info,
1397                        Elf_Internal_Rela *rel,
1398                        struct elf_link_hash_entry *h,
1399                        Elf_Internal_Sym *sym)
1400 {
1401   if (h != NULL)
1402     switch (ELF32_R_TYPE (rel->r_info))
1403       {
1404       case R_390_GNU_VTINHERIT:
1405       case R_390_GNU_VTENTRY:
1406         return NULL;
1407       }
1408   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1409
1410 }
1411
1412 /* Update the got entry reference counts for the section being removed.  */
1413
1414 static bfd_boolean
1415 elf_s390_gc_sweep_hook (bfd *abfd,
1416                         struct bfd_link_info *info,
1417                         asection *sec,
1418                         const Elf_Internal_Rela *relocs)
1419 {
1420   Elf_Internal_Shdr *symtab_hdr;
1421   struct elf_link_hash_entry **sym_hashes;
1422   bfd_signed_vma *local_got_refcounts;
1423   const Elf_Internal_Rela *rel, *relend;
1424
1425   elf_section_data (sec)->local_dynrel = NULL;
1426
1427   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1428   sym_hashes = elf_sym_hashes (abfd);
1429   local_got_refcounts = elf_local_got_refcounts (abfd);
1430
1431   relend = relocs + sec->reloc_count;
1432   for (rel = relocs; rel < relend; rel++)
1433     {
1434       unsigned long r_symndx;
1435       unsigned int r_type;
1436       struct elf_link_hash_entry *h = NULL;
1437
1438       r_symndx = ELF32_R_SYM (rel->r_info);
1439       if (r_symndx >= symtab_hdr->sh_info)
1440         {
1441           struct elf_s390_link_hash_entry *eh;
1442           struct elf_s390_dyn_relocs **pp;
1443           struct elf_s390_dyn_relocs *p;
1444
1445           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1446           while (h->root.type == bfd_link_hash_indirect
1447                  || h->root.type == bfd_link_hash_warning)
1448             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1449           eh = (struct elf_s390_link_hash_entry *) h;
1450
1451           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1452             if (p->sec == sec)
1453               {
1454                 /* Everything must go for SEC.  */
1455                 *pp = p->next;
1456                 break;
1457               }
1458         }
1459
1460       r_type = ELF32_R_TYPE (rel->r_info);
1461       r_type = elf_s390_tls_transition (info, r_type, h != NULL);
1462       switch (r_type)
1463         {
1464         case R_390_TLS_LDM32:
1465           if (elf_s390_hash_table (info)->tls_ldm_got.refcount > 0)
1466             elf_s390_hash_table (info)->tls_ldm_got.refcount -= 1;
1467           break;
1468
1469         case R_390_TLS_GD32:
1470         case R_390_TLS_IE32:
1471         case R_390_TLS_GOTIE12:
1472         case R_390_TLS_GOTIE20:
1473         case R_390_TLS_GOTIE32:
1474         case R_390_TLS_IEENT:
1475         case R_390_GOT12:
1476         case R_390_GOT16:
1477         case R_390_GOT20:
1478         case R_390_GOT32:
1479         case R_390_GOTOFF16:
1480         case R_390_GOTOFF32:
1481         case R_390_GOTPC:
1482         case R_390_GOTPCDBL:
1483         case R_390_GOTENT:
1484           if (h != NULL)
1485             {
1486               if (h->got.refcount > 0)
1487                 h->got.refcount -= 1;
1488             }
1489           else if (local_got_refcounts != NULL)
1490             {
1491               if (local_got_refcounts[r_symndx] > 0)
1492                 local_got_refcounts[r_symndx] -= 1;
1493             }
1494           break;
1495
1496         case R_390_8:
1497         case R_390_12:
1498         case R_390_16:
1499         case R_390_20:
1500         case R_390_32:
1501         case R_390_PC16:
1502         case R_390_PC16DBL:
1503         case R_390_PC32DBL:
1504         case R_390_PC32:
1505           if (info->shared)
1506             break;
1507           /* Fall through.  */
1508
1509         case R_390_PLT16DBL:
1510         case R_390_PLT32DBL:
1511         case R_390_PLT32:
1512         case R_390_PLTOFF16:
1513         case R_390_PLTOFF32:
1514           if (h != NULL)
1515             {
1516               if (h->plt.refcount > 0)
1517                 h->plt.refcount -= 1;
1518             }
1519           break;
1520
1521         case R_390_GOTPLT12:
1522         case R_390_GOTPLT16:
1523         case R_390_GOTPLT20:
1524         case R_390_GOTPLT32:
1525         case R_390_GOTPLTENT:
1526           if (h != NULL)
1527             {
1528               if (h->plt.refcount > 0)
1529                 {
1530                   ((struct elf_s390_link_hash_entry *) h)->gotplt_refcount--;
1531                   h->plt.refcount -= 1;
1532                 }
1533             }
1534           else if (local_got_refcounts != NULL)
1535             {
1536               if (local_got_refcounts[r_symndx] > 0)
1537                 local_got_refcounts[r_symndx] -= 1;
1538             }
1539           break;
1540
1541         default:
1542           break;
1543         }
1544     }
1545
1546   return TRUE;
1547 }
1548
1549 /* Make sure we emit a GOT entry if the symbol was supposed to have a PLT
1550    entry but we found we will not create any.  Called when we find we will
1551    not have any PLT for this symbol, by for example
1552    elf_s390_adjust_dynamic_symbol when we're doing a proper dynamic link,
1553    or elf_s390_size_dynamic_sections if no dynamic sections will be
1554    created (we're only linking static objects).  */
1555
1556 static void
1557 elf_s390_adjust_gotplt (h)
1558      struct elf_s390_link_hash_entry *h;
1559 {
1560   if (h->elf.root.type == bfd_link_hash_warning)
1561     h = (struct elf_s390_link_hash_entry *) h->elf.root.u.i.link;
1562
1563   if (h->gotplt_refcount <= 0)
1564     return;
1565
1566   /* We simply add the number of gotplt references to the number
1567    * of got references for this symbol.  */
1568   h->elf.got.refcount += h->gotplt_refcount;
1569   h->gotplt_refcount = -1;
1570 }
1571
1572 /* Adjust a symbol defined by a dynamic object and referenced by a
1573    regular object.  The current definition is in some section of the
1574    dynamic object, but we're not including those sections.  We have to
1575    change the definition to something the rest of the link can
1576    understand.  */
1577
1578 static bfd_boolean
1579 elf_s390_adjust_dynamic_symbol (info, h)
1580      struct bfd_link_info *info;
1581      struct elf_link_hash_entry *h;
1582 {
1583   struct elf_s390_link_hash_table *htab;
1584   asection *s;
1585   unsigned int power_of_two;
1586
1587   /* If this is a function, put it in the procedure linkage table.  We
1588      will fill in the contents of the procedure linkage table later
1589      (although we could actually do it here).  */
1590   if (h->type == STT_FUNC
1591       || h->needs_plt)
1592     {
1593       if (h->plt.refcount <= 0
1594           || (! info->shared
1595               && !h->def_dynamic
1596               && !h->ref_dynamic
1597               && h->root.type != bfd_link_hash_undefweak
1598               && h->root.type != bfd_link_hash_undefined))
1599         {
1600           /* This case can occur if we saw a PLT32 reloc in an input
1601              file, but the symbol was never referred to by a dynamic
1602              object, or if all references were garbage collected.  In
1603              such a case, we don't actually need to build a procedure
1604              linkage table, and we can just do a PC32 reloc instead.  */
1605           h->plt.offset = (bfd_vma) -1;
1606           h->needs_plt = 0;
1607           elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1608         }
1609
1610       return TRUE;
1611     }
1612   else
1613     /* It's possible that we incorrectly decided a .plt reloc was
1614        needed for an R_390_PC32 reloc to a non-function sym in
1615        check_relocs.  We can't decide accurately between function and
1616        non-function syms in check-relocs;  Objects loaded later in
1617        the link may change h->type.  So fix it now.  */
1618     h->plt.offset = (bfd_vma) -1;
1619
1620   /* If this is a weak symbol, and there is a real definition, the
1621      processor independent code will have arranged for us to see the
1622      real definition first, and we can just use the same value.  */
1623   if (h->u.weakdef != NULL)
1624     {
1625       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1626                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1627       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1628       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1629       if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1630         h->non_got_ref = h->u.weakdef->non_got_ref;
1631       return TRUE;
1632     }
1633
1634   /* This is a reference to a symbol defined by a dynamic object which
1635      is not a function.  */
1636
1637   /* If we are creating a shared library, we must presume that the
1638      only references to the symbol are via the global offset table.
1639      For such cases we need not do anything here; the relocations will
1640      be handled correctly by relocate_section.  */
1641   if (info->shared)
1642     return TRUE;
1643
1644   /* If there are no references to this symbol that do not use the
1645      GOT, we don't need to generate a copy reloc.  */
1646   if (!h->non_got_ref)
1647     return TRUE;
1648
1649   /* If -z nocopyreloc was given, we won't generate them either.  */
1650   if (info->nocopyreloc)
1651     {
1652       h->non_got_ref = 0;
1653       return TRUE;
1654     }
1655
1656   if (ELIMINATE_COPY_RELOCS)
1657     {
1658       struct elf_s390_link_hash_entry * eh;
1659       struct elf_s390_dyn_relocs *p;
1660
1661       eh = (struct elf_s390_link_hash_entry *) h;
1662       for (p = eh->dyn_relocs; p != NULL; p = p->next)
1663         {
1664           s = p->sec->output_section;
1665           if (s != NULL && (s->flags & SEC_READONLY) != 0)
1666             break;
1667         }
1668
1669       /* If we didn't find any dynamic relocs in read-only sections, then
1670          we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
1671       if (p == NULL)
1672         {
1673           h->non_got_ref = 0;
1674           return TRUE;
1675         }
1676     }
1677
1678   if (h->size == 0)
1679     {
1680       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1681                              h->root.root.string);
1682       return TRUE;
1683     }
1684
1685   /* We must allocate the symbol in our .dynbss section, which will
1686      become part of the .bss section of the executable.  There will be
1687      an entry for this symbol in the .dynsym section.  The dynamic
1688      object will contain position independent code, so all references
1689      from the dynamic object to this symbol will go through the global
1690      offset table.  The dynamic linker will use the .dynsym entry to
1691      determine the address it must put in the global offset table, so
1692      both the dynamic object and the regular object will refer to the
1693      same memory location for the variable.  */
1694
1695   htab = elf_s390_hash_table (info);
1696
1697   /* We must generate a R_390_COPY reloc to tell the dynamic linker to
1698      copy the initial value out of the dynamic object and into the
1699      runtime process image.  */
1700   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1701     {
1702       htab->srelbss->size += sizeof (Elf32_External_Rela);
1703       h->needs_copy = 1;
1704     }
1705
1706   /* We need to figure out the alignment required for this symbol.  I
1707      have no idea how ELF linkers handle this.  */
1708   power_of_two = bfd_log2 (h->size);
1709   if (power_of_two > 3)
1710     power_of_two = 3;
1711
1712   /* Apply the required alignment.  */
1713   s = htab->sdynbss;
1714   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
1715   if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
1716     {
1717       if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
1718         return FALSE;
1719     }
1720
1721   /* Define the symbol as being at this point in the section.  */
1722   h->root.u.def.section = s;
1723   h->root.u.def.value = s->size;
1724
1725   /* Increment the section size to make room for the symbol.  */
1726   s->size += h->size;
1727
1728   return TRUE;
1729 }
1730
1731 /* Allocate space in .plt, .got and associated reloc sections for
1732    dynamic relocs.  */
1733
1734 static bfd_boolean
1735 allocate_dynrelocs (h, inf)
1736      struct elf_link_hash_entry *h;
1737      PTR inf;
1738 {
1739   struct bfd_link_info *info;
1740   struct elf_s390_link_hash_table *htab;
1741   struct elf_s390_link_hash_entry *eh;
1742   struct elf_s390_dyn_relocs *p;
1743
1744   if (h->root.type == bfd_link_hash_indirect)
1745     return TRUE;
1746
1747   if (h->root.type == bfd_link_hash_warning)
1748     /* When warning symbols are created, they **replace** the "real"
1749        entry in the hash table, thus we never get to see the real
1750        symbol in a hash traversal.  So look at it now.  */
1751     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1752
1753   info = (struct bfd_link_info *) inf;
1754   htab = elf_s390_hash_table (info);
1755
1756   if (htab->elf.dynamic_sections_created
1757       && h->plt.refcount > 0
1758       && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1759           || h->root.type != bfd_link_hash_undefweak))
1760     {
1761       /* Make sure this symbol is output as a dynamic symbol.
1762          Undefined weak syms won't yet be marked as dynamic.  */
1763       if (h->dynindx == -1
1764           && !h->forced_local)
1765         {
1766           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1767             return FALSE;
1768         }
1769
1770       if (info->shared
1771           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1772         {
1773           asection *s = htab->splt;
1774
1775           /* If this is the first .plt entry, make room for the special
1776              first entry.  */
1777           if (s->size == 0)
1778             s->size += PLT_FIRST_ENTRY_SIZE;
1779
1780           h->plt.offset = s->size;
1781
1782           /* If this symbol is not defined in a regular file, and we are
1783              not generating a shared library, then set the symbol to this
1784              location in the .plt.  This is required to make function
1785              pointers compare as equal between the normal executable and
1786              the shared library.  */
1787           if (! info->shared
1788               && !h->def_regular)
1789             {
1790               h->root.u.def.section = s;
1791               h->root.u.def.value = h->plt.offset;
1792             }
1793
1794           /* Make room for this entry.  */
1795           s->size += PLT_ENTRY_SIZE;
1796
1797           /* We also need to make an entry in the .got.plt section, which
1798              will be placed in the .got section by the linker script.  */
1799           htab->sgotplt->size += GOT_ENTRY_SIZE;
1800
1801           /* We also need to make an entry in the .rela.plt section.  */
1802           htab->srelplt->size += sizeof (Elf32_External_Rela);
1803         }
1804       else
1805         {
1806           h->plt.offset = (bfd_vma) -1;
1807           h->needs_plt = 0;
1808           elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1809         }
1810     }
1811   else
1812     {
1813       h->plt.offset = (bfd_vma) -1;
1814       h->needs_plt = 0;
1815       elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1816     }
1817
1818   /* If R_390_TLS_{IE32,GOTIE32,GOTIE12,IEENT} symbol is now local to
1819      the binary, we can optimize a bit. IE32 and GOTIE32 get converted
1820      to R_390_TLS_LE32 requiring no TLS entry. For GOTIE12 and IEENT
1821      we can save the dynamic TLS relocation.  */
1822   if (h->got.refcount > 0
1823       && !info->shared
1824       && h->dynindx == -1
1825       && elf_s390_hash_entry(h)->tls_type >= GOT_TLS_IE)
1826     {
1827       if (elf_s390_hash_entry(h)->tls_type == GOT_TLS_IE_NLT)
1828         /* For the GOTIE access without a literal pool entry the offset has
1829            to be stored somewhere. The immediate value in the instruction
1830            is not bit enough so the value is stored in the got.  */
1831         {
1832           h->got.offset = htab->sgot->size;
1833           htab->sgot->size += GOT_ENTRY_SIZE;
1834         }
1835       else
1836         h->got.offset = (bfd_vma) -1;
1837     }
1838   else if (h->got.refcount > 0)
1839    {
1840       asection *s;
1841       bfd_boolean dyn;
1842       int tls_type = elf_s390_hash_entry(h)->tls_type;
1843
1844       /* Make sure this symbol is output as a dynamic symbol.
1845          Undefined weak syms won't yet be marked as dynamic.  */
1846       if (h->dynindx == -1
1847           && !h->forced_local)
1848         {
1849           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1850             return FALSE;
1851         }
1852
1853       s = htab->sgot;
1854       h->got.offset = s->size;
1855       s->size += GOT_ENTRY_SIZE;
1856       /* R_390_TLS_GD32 needs 2 consecutive GOT slots.  */
1857       if (tls_type == GOT_TLS_GD)
1858         s->size += GOT_ENTRY_SIZE;
1859       dyn = htab->elf.dynamic_sections_created;
1860       /* R_390_TLS_IE32 needs one dynamic relocation,
1861          R_390_TLS_GD32 needs one if local symbol and two if global.  */
1862       if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1863           || tls_type >= GOT_TLS_IE)
1864         htab->srelgot->size += sizeof (Elf32_External_Rela);
1865       else if (tls_type == GOT_TLS_GD)
1866         htab->srelgot->size += 2 * sizeof (Elf32_External_Rela);
1867       else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1868                 || h->root.type != bfd_link_hash_undefweak)
1869                && (info->shared
1870                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1871         htab->srelgot->size += sizeof (Elf32_External_Rela);
1872     }
1873   else
1874     h->got.offset = (bfd_vma) -1;
1875
1876   eh = (struct elf_s390_link_hash_entry *) h;
1877   if (eh->dyn_relocs == NULL)
1878     return TRUE;
1879
1880   /* In the shared -Bsymbolic case, discard space allocated for
1881      dynamic pc-relative relocs against symbols which turn out to be
1882      defined in regular objects.  For the normal shared case, discard
1883      space for pc-relative relocs that have become local due to symbol
1884      visibility changes.  */
1885
1886   if (info->shared)
1887     {
1888       if (SYMBOL_REFERENCES_LOCAL (info, h))
1889         {
1890           struct elf_s390_dyn_relocs **pp;
1891
1892           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1893             {
1894               p->count -= p->pc_count;
1895               p->pc_count = 0;
1896               if (p->count == 0)
1897                 *pp = p->next;
1898               else
1899                 pp = &p->next;
1900             }
1901         }
1902
1903       /* Also discard relocs on undefined weak syms with non-default
1904          visibility.  */
1905       if (eh->dyn_relocs != NULL
1906           && h->root.type == bfd_link_hash_undefweak)
1907         {
1908           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1909             eh->dyn_relocs = NULL;
1910
1911           /* Make sure undefined weak symbols are output as a dynamic
1912              symbol in PIEs.  */
1913           else if (h->dynindx == -1
1914                    && !h->forced_local)
1915             {
1916               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1917                 return FALSE;
1918             }
1919         }
1920     }
1921   else if (ELIMINATE_COPY_RELOCS)
1922     {
1923       /* For the non-shared case, discard space for relocs against
1924          symbols which turn out to need copy relocs or are not
1925          dynamic.  */
1926
1927       if (!h->non_got_ref
1928           && ((h->def_dynamic
1929                && !h->def_regular)
1930               || (htab->elf.dynamic_sections_created
1931                   && (h->root.type == bfd_link_hash_undefweak
1932                       || h->root.type == bfd_link_hash_undefined))))
1933         {
1934           /* Make sure this symbol is output as a dynamic symbol.
1935              Undefined weak syms won't yet be marked as dynamic.  */
1936           if (h->dynindx == -1
1937               && !h->forced_local)
1938             {
1939               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1940                 return FALSE;
1941             }
1942
1943           /* If that succeeded, we know we'll be keeping all the
1944              relocs.  */
1945           if (h->dynindx != -1)
1946             goto keep;
1947         }
1948
1949       eh->dyn_relocs = NULL;
1950
1951     keep: ;
1952     }
1953
1954   /* Finally, allocate space.  */
1955   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1956     {
1957       asection *sreloc = elf_section_data (p->sec)->sreloc;
1958
1959       sreloc->size += p->count * sizeof (Elf32_External_Rela);
1960     }
1961
1962   return TRUE;
1963 }
1964
1965 /* Find any dynamic relocs that apply to read-only sections.  */
1966
1967 static bfd_boolean
1968 readonly_dynrelocs (h, inf)
1969      struct elf_link_hash_entry *h;
1970      PTR inf;
1971 {
1972   struct elf_s390_link_hash_entry *eh;
1973   struct elf_s390_dyn_relocs *p;
1974
1975   if (h->root.type == bfd_link_hash_warning)
1976     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1977
1978   eh = (struct elf_s390_link_hash_entry *) h;
1979   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1980     {
1981       asection *s = p->sec->output_section;
1982
1983       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1984         {
1985           struct bfd_link_info *info = (struct bfd_link_info *) inf;
1986
1987           info->flags |= DF_TEXTREL;
1988
1989           /* Not an error, just cut short the traversal.  */
1990           return FALSE;
1991         }
1992     }
1993   return TRUE;
1994 }
1995
1996 /* Set the sizes of the dynamic sections.  */
1997
1998 static bfd_boolean
1999 elf_s390_size_dynamic_sections (output_bfd, info)
2000      bfd *output_bfd ATTRIBUTE_UNUSED;
2001      struct bfd_link_info *info;
2002 {
2003   struct elf_s390_link_hash_table *htab;
2004   bfd *dynobj;
2005   asection *s;
2006   bfd_boolean relocs;
2007   bfd *ibfd;
2008
2009   htab = elf_s390_hash_table (info);
2010   dynobj = htab->elf.dynobj;
2011   if (dynobj == NULL)
2012     abort ();
2013
2014   if (htab->elf.dynamic_sections_created)
2015     {
2016       /* Set the contents of the .interp section to the interpreter.  */
2017       if (info->executable)
2018         {
2019           s = bfd_get_section_by_name (dynobj, ".interp");
2020           if (s == NULL)
2021             abort ();
2022           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2023           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2024         }
2025     }
2026
2027   /* Set up .got offsets for local syms, and space for local dynamic
2028      relocs.  */
2029   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2030     {
2031       bfd_signed_vma *local_got;
2032       bfd_signed_vma *end_local_got;
2033       char *local_tls_type;
2034       bfd_size_type locsymcount;
2035       Elf_Internal_Shdr *symtab_hdr;
2036       asection *srela;
2037
2038       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2039         continue;
2040
2041       for (s = ibfd->sections; s != NULL; s = s->next)
2042         {
2043           struct elf_s390_dyn_relocs *p;
2044
2045           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
2046             {
2047               if (!bfd_is_abs_section (p->sec)
2048                   && bfd_is_abs_section (p->sec->output_section))
2049                 {
2050                   /* Input section has been discarded, either because
2051                      it is a copy of a linkonce section or due to
2052                      linker script /DISCARD/, so we'll be discarding
2053                      the relocs too.  */
2054                 }
2055               else if (p->count != 0)
2056                 {
2057                   srela = elf_section_data (p->sec)->sreloc;
2058                   srela->size += p->count * sizeof (Elf32_External_Rela);
2059                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2060                     info->flags |= DF_TEXTREL;
2061                 }
2062             }
2063         }
2064
2065       local_got = elf_local_got_refcounts (ibfd);
2066       if (!local_got)
2067         continue;
2068
2069       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2070       locsymcount = symtab_hdr->sh_info;
2071       end_local_got = local_got + locsymcount;
2072       local_tls_type = elf_s390_local_got_tls_type (ibfd);
2073       s = htab->sgot;
2074       srela = htab->srelgot;
2075       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2076         {
2077           if (*local_got > 0)
2078             {
2079               *local_got = s->size;
2080               s->size += GOT_ENTRY_SIZE;
2081               if (*local_tls_type == GOT_TLS_GD)
2082                 s->size += GOT_ENTRY_SIZE;
2083               if (info->shared)
2084                 srela->size += sizeof (Elf32_External_Rela);
2085             }
2086           else
2087             *local_got = (bfd_vma) -1;
2088         }
2089     }
2090
2091   if (htab->tls_ldm_got.refcount > 0)
2092     {
2093       /* Allocate 2 got entries and 1 dynamic reloc for R_390_TLS_LDM32
2094          relocs.  */
2095       htab->tls_ldm_got.offset = htab->sgot->size;
2096       htab->sgot->size += 2 * GOT_ENTRY_SIZE;
2097       htab->srelgot->size += sizeof (Elf32_External_Rela);
2098     }
2099   else
2100     htab->tls_ldm_got.offset = -1;
2101
2102   /* Allocate global sym .plt and .got entries, and space for global
2103      sym dynamic relocs.  */
2104   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
2105
2106   /* We now have determined the sizes of the various dynamic sections.
2107      Allocate memory for them.  */
2108   relocs = FALSE;
2109   for (s = dynobj->sections; s != NULL; s = s->next)
2110     {
2111       if ((s->flags & SEC_LINKER_CREATED) == 0)
2112         continue;
2113
2114       if (s == htab->splt
2115           || s == htab->sgot
2116           || s == htab->sgotplt
2117           || s == htab->sdynbss)
2118         {
2119           /* Strip this section if we don't need it; see the
2120              comment below.  */
2121         }
2122       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2123         {
2124           if (s->size != 0)
2125             relocs = TRUE;
2126
2127           /* We use the reloc_count field as a counter if we need
2128              to copy relocs into the output file.  */
2129           s->reloc_count = 0;
2130         }
2131       else
2132         {
2133           /* It's not one of our sections, so don't allocate space.  */
2134           continue;
2135         }
2136
2137       if (s->size == 0)
2138         {
2139           /* If we don't need this section, strip it from the
2140              output file.  This is to handle .rela.bss and
2141              .rela.plt.  We must create it in
2142              create_dynamic_sections, because it must be created
2143              before the linker maps input sections to output
2144              sections.  The linker does that before
2145              adjust_dynamic_symbol is called, and it is that
2146              function which decides whether anything needs to go
2147              into these sections.  */
2148
2149           s->flags |= SEC_EXCLUDE;
2150           continue;
2151         }
2152
2153       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2154         continue;
2155
2156       /* Allocate memory for the section contents.  We use bfd_zalloc
2157          here in case unused entries are not reclaimed before the
2158          section's contents are written out.  This should not happen,
2159          but this way if it does, we get a R_390_NONE reloc instead
2160          of garbage.  */
2161       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2162       if (s->contents == NULL)
2163         return FALSE;
2164     }
2165
2166   if (htab->elf.dynamic_sections_created)
2167     {
2168       /* Add some entries to the .dynamic section.  We fill in the
2169          values later, in elf_s390_finish_dynamic_sections, but we
2170          must add the entries now so that we get the correct size for
2171          the .dynamic section.  The DT_DEBUG entry is filled in by the
2172          dynamic linker and used by the debugger.  */
2173 #define add_dynamic_entry(TAG, VAL) \
2174   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2175
2176       if (info->executable)
2177         {
2178           if (!add_dynamic_entry (DT_DEBUG, 0))
2179             return FALSE;
2180         }
2181
2182       if (htab->splt->size != 0)
2183         {
2184           if (!add_dynamic_entry (DT_PLTGOT, 0)
2185               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2186               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2187               || !add_dynamic_entry (DT_JMPREL, 0))
2188             return FALSE;
2189         }
2190
2191       if (relocs)
2192         {
2193           if (!add_dynamic_entry (DT_RELA, 0)
2194               || !add_dynamic_entry (DT_RELASZ, 0)
2195               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
2196             return FALSE;
2197
2198           /* If any dynamic relocs apply to a read-only section,
2199              then we need a DT_TEXTREL entry.  */
2200           if ((info->flags & DF_TEXTREL) == 0)
2201             elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2202                                     (PTR) info);
2203
2204           if ((info->flags & DF_TEXTREL) != 0)
2205             {
2206               if (!add_dynamic_entry (DT_TEXTREL, 0))
2207                 return FALSE;
2208             }
2209         }
2210     }
2211 #undef add_dynamic_entry
2212
2213   return TRUE;
2214 }
2215
2216 /* Return the base VMA address which should be subtracted from real addresses
2217    when resolving @dtpoff relocation.
2218    This is PT_TLS segment p_vaddr.  */
2219
2220 static bfd_vma
2221 dtpoff_base (info)
2222      struct bfd_link_info *info;
2223 {
2224   /* If tls_sec is NULL, we should have signalled an error already.  */
2225   if (elf_hash_table (info)->tls_sec == NULL)
2226     return 0;
2227   return elf_hash_table (info)->tls_sec->vma;
2228 }
2229
2230 /* Return the relocation value for @tpoff relocation
2231    if STT_TLS virtual address is ADDRESS.  */
2232
2233 static bfd_vma
2234 tpoff (info, address)
2235      struct bfd_link_info *info;
2236      bfd_vma address;
2237 {
2238   struct elf_link_hash_table *htab = elf_hash_table (info);
2239
2240   /* If tls_sec is NULL, we should have signalled an error already.  */
2241   if (htab->tls_sec == NULL)
2242     return 0;
2243   return htab->tls_size + htab->tls_sec->vma - address;
2244 }
2245
2246 /* Complain if TLS instruction relocation is against an invalid
2247    instruction.  */
2248
2249 static void
2250 invalid_tls_insn (input_bfd, input_section, rel)
2251      bfd *input_bfd;
2252      asection *input_section;
2253      Elf_Internal_Rela *rel;
2254 {
2255   reloc_howto_type *howto;
2256
2257   howto = elf_howto_table + ELF32_R_TYPE (rel->r_info);
2258   (*_bfd_error_handler)
2259     (_("%B(%A+0x%lx): invalid instruction for TLS relocation %s"),
2260      input_bfd,
2261      input_section,
2262      (long) rel->r_offset,
2263      howto->name);
2264   bfd_set_error (bfd_error_bad_value);
2265 }
2266
2267 /* Relocate a 390 ELF section.  */
2268
2269 static bfd_boolean
2270 elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
2271                               contents, relocs, local_syms, local_sections)
2272      bfd *output_bfd;
2273      struct bfd_link_info *info;
2274      bfd *input_bfd;
2275      asection *input_section;
2276      bfd_byte *contents;
2277      Elf_Internal_Rela *relocs;
2278      Elf_Internal_Sym *local_syms;
2279      asection **local_sections;
2280 {
2281   struct elf_s390_link_hash_table *htab;
2282   Elf_Internal_Shdr *symtab_hdr;
2283   struct elf_link_hash_entry **sym_hashes;
2284   bfd_vma *local_got_offsets;
2285   Elf_Internal_Rela *rel;
2286   Elf_Internal_Rela *relend;
2287
2288   htab = elf_s390_hash_table (info);
2289   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2290   sym_hashes = elf_sym_hashes (input_bfd);
2291   local_got_offsets = elf_local_got_offsets (input_bfd);
2292
2293   rel = relocs;
2294   relend = relocs + input_section->reloc_count;
2295   for (; rel < relend; rel++)
2296     {
2297       unsigned int r_type;
2298       reloc_howto_type *howto;
2299       unsigned long r_symndx;
2300       struct elf_link_hash_entry *h;
2301       Elf_Internal_Sym *sym;
2302       asection *sec;
2303       bfd_vma off;
2304       bfd_vma relocation;
2305       bfd_boolean unresolved_reloc;
2306       bfd_reloc_status_type r;
2307       int tls_type;
2308
2309       r_type = ELF32_R_TYPE (rel->r_info);
2310       if (r_type == (int) R_390_GNU_VTINHERIT
2311           || r_type == (int) R_390_GNU_VTENTRY)
2312         continue;
2313       if (r_type >= (int) R_390_max)
2314         {
2315           bfd_set_error (bfd_error_bad_value);
2316           return FALSE;
2317         }
2318
2319       howto = elf_howto_table + r_type;
2320       r_symndx = ELF32_R_SYM (rel->r_info);
2321
2322       h = NULL;
2323       sym = NULL;
2324       sec = NULL;
2325       unresolved_reloc = FALSE;
2326       if (r_symndx < symtab_hdr->sh_info)
2327         {
2328           sym = local_syms + r_symndx;
2329           sec = local_sections[r_symndx];
2330           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2331         }
2332       else
2333         {
2334           bfd_boolean warned ATTRIBUTE_UNUSED;
2335
2336           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2337                                    r_symndx, symtab_hdr, sym_hashes,
2338                                    h, sec, relocation,
2339                                    unresolved_reloc, warned);
2340         }
2341
2342       if (sec != NULL && elf_discarded_section (sec))
2343         {
2344           /* For relocs against symbols from removed linkonce sections,
2345              or sections discarded by a linker script, we just want the
2346              section contents zeroed.  Avoid any special processing.  */
2347           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2348           rel->r_info = 0;
2349           rel->r_addend = 0;
2350           continue;
2351         }
2352
2353       if (info->relocatable)
2354         continue;
2355
2356       switch (r_type)
2357         {
2358         case R_390_GOTPLT12:
2359         case R_390_GOTPLT16:
2360         case R_390_GOTPLT20:
2361         case R_390_GOTPLT32:
2362         case R_390_GOTPLTENT:
2363           /* There are three cases for a GOTPLT relocation. 1) The
2364              relocation is against the jump slot entry of a plt that
2365              will get emitted to the output file. 2) The relocation
2366              is against the jump slot of a plt entry that has been
2367              removed. elf_s390_adjust_gotplt has created a GOT entry
2368              as replacement. 3) The relocation is against a local symbol.
2369              Cases 2) and 3) are the same as the GOT relocation code
2370              so we just have to test for case 1 and fall through for
2371              the other two.  */
2372           if (h != NULL && h->plt.offset != (bfd_vma) -1)
2373             {
2374               bfd_vma plt_index;
2375
2376               /* Calc. index no.
2377                  Current offset - size first entry / entry size.  */
2378               plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) /
2379                 PLT_ENTRY_SIZE;
2380
2381               /* Offset in GOT is PLT index plus GOT headers(3) times 4,
2382                  addr & GOT addr.  */
2383               relocation = (plt_index + 3) * GOT_ENTRY_SIZE;
2384               unresolved_reloc = FALSE;
2385
2386               if (r_type == R_390_GOTPLTENT)
2387                 relocation += htab->sgot->output_section->vma;
2388               break;
2389             }
2390           /* Fall through.  */
2391
2392         case R_390_GOT12:
2393         case R_390_GOT16:
2394         case R_390_GOT20:
2395         case R_390_GOT32:
2396         case R_390_GOTENT:
2397           /* Relocation is to the entry for this symbol in the global
2398              offset table.  */
2399           if (htab->sgot == NULL)
2400             abort ();
2401
2402           if (h != NULL)
2403             {
2404               bfd_boolean dyn;
2405
2406               off = h->got.offset;
2407               dyn = htab->elf.dynamic_sections_created;
2408               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2409                   || (info->shared
2410                       && (info->symbolic
2411                           || h->dynindx == -1
2412                           || h->forced_local)
2413                       && h->def_regular)
2414                   || (ELF_ST_VISIBILITY (h->other)
2415                       && h->root.type == bfd_link_hash_undefweak))
2416                 {
2417                   /* This is actually a static link, or it is a
2418                      -Bsymbolic link and the symbol is defined
2419                      locally, or the symbol was forced to be local
2420                      because of a version file.  We must initialize
2421                      this entry in the global offset table.  Since the
2422                      offset must always be a multiple of 2, we use the
2423                      least significant bit to record whether we have
2424                      initialized it already.
2425
2426                      When doing a dynamic link, we create a .rel.got
2427                      relocation entry to initialize the value.  This
2428                      is done in the finish_dynamic_symbol routine.  */
2429                   if ((off & 1) != 0)
2430                     off &= ~1;
2431                   else
2432                     {
2433                       bfd_put_32 (output_bfd, relocation,
2434                                   htab->sgot->contents + off);
2435                       h->got.offset |= 1;
2436                     }
2437                 }
2438               else
2439                 unresolved_reloc = FALSE;
2440             }
2441           else
2442             {
2443               if (local_got_offsets == NULL)
2444                 abort ();
2445
2446               off = local_got_offsets[r_symndx];
2447
2448               /* The offset must always be a multiple of 4.  We use
2449                  the least significant bit to record whether we have
2450                  already generated the necessary reloc.  */
2451               if ((off & 1) != 0)
2452                 off &= ~1;
2453               else
2454                 {
2455                   bfd_put_32 (output_bfd, relocation,
2456                               htab->sgot->contents + off);
2457
2458                   if (info->shared)
2459                     {
2460                       asection *srelgot;
2461                       Elf_Internal_Rela outrel;
2462                       bfd_byte *loc;
2463
2464                       srelgot = htab->srelgot;
2465                       if (srelgot == NULL)
2466                         abort ();
2467
2468                       outrel.r_offset = (htab->sgot->output_section->vma
2469                                          + htab->sgot->output_offset
2470                                          + off);
2471                       outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2472                       outrel.r_addend = relocation;
2473                       loc = srelgot->contents;
2474                       loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
2475                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2476                     }
2477
2478                   local_got_offsets[r_symndx] |= 1;
2479                 }
2480             }
2481
2482           if (off >= (bfd_vma) -2)
2483             abort ();
2484
2485           relocation = htab->sgot->output_offset + off;
2486
2487           /* For @GOTENT the relocation is against the offset between
2488              the instruction and the symbols entry in the GOT and not
2489              between the start of the GOT and the symbols entry. We
2490              add the vma of the GOT to get the correct value.  */
2491           if (   r_type == R_390_GOTENT
2492               || r_type == R_390_GOTPLTENT)
2493             relocation += htab->sgot->output_section->vma;
2494
2495           break;
2496
2497         case R_390_GOTOFF16:
2498         case R_390_GOTOFF32:
2499           /* Relocation is relative to the start of the global offset
2500              table.  */
2501
2502           /* Note that sgot->output_offset is not involved in this
2503              calculation.  We always want the start of .got.  If we
2504              defined _GLOBAL_OFFSET_TABLE in a different way, as is
2505              permitted by the ABI, we might have to change this
2506              calculation.  */
2507           relocation -= htab->sgot->output_section->vma;
2508           break;
2509
2510         case R_390_GOTPC:
2511         case R_390_GOTPCDBL:
2512           /* Use global offset table as symbol value.  */
2513           relocation = htab->sgot->output_section->vma;
2514           unresolved_reloc = FALSE;
2515           break;
2516
2517         case R_390_PLT16DBL:
2518         case R_390_PLT32DBL:
2519         case R_390_PLT32:
2520           /* Relocation is to the entry for this symbol in the
2521              procedure linkage table.  */
2522
2523           /* Resolve a PLT32 reloc against a local symbol directly,
2524              without using the procedure linkage table.  */
2525           if (h == NULL)
2526             break;
2527
2528           if (h->plt.offset == (bfd_vma) -1
2529               || htab->splt == NULL)
2530             {
2531               /* We didn't make a PLT entry for this symbol.  This
2532                  happens when statically linking PIC code, or when
2533                  using -Bsymbolic.  */
2534               break;
2535             }
2536
2537           relocation = (htab->splt->output_section->vma
2538                         + htab->splt->output_offset
2539                         + h->plt.offset);
2540           unresolved_reloc = FALSE;
2541           break;
2542
2543         case R_390_PLTOFF16:
2544         case R_390_PLTOFF32:
2545           /* Relocation is to the entry for this symbol in the
2546              procedure linkage table relative to the start of the GOT.  */
2547
2548           /* For local symbols or if we didn't make a PLT entry for
2549              this symbol resolve the symbol directly.  */
2550           if (   h == NULL
2551               || h->plt.offset == (bfd_vma) -1
2552               || htab->splt == NULL)
2553             {
2554               relocation -= htab->sgot->output_section->vma;
2555               break;
2556             }
2557
2558           relocation = (htab->splt->output_section->vma
2559                         + htab->splt->output_offset
2560                         + h->plt.offset
2561                         - htab->sgot->output_section->vma);
2562           unresolved_reloc = FALSE;
2563           break;
2564
2565         case R_390_8:
2566         case R_390_16:
2567         case R_390_32:
2568         case R_390_PC16:
2569         case R_390_PC16DBL:
2570         case R_390_PC32DBL:
2571         case R_390_PC32:
2572           if ((input_section->flags & SEC_ALLOC) == 0)
2573             break;
2574
2575           if ((info->shared
2576                && (h == NULL
2577                    || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2578                    || h->root.type != bfd_link_hash_undefweak)
2579                && ((r_type != R_390_PC16
2580                     && r_type != R_390_PC16DBL
2581                     && r_type != R_390_PC32DBL
2582                     && r_type != R_390_PC32)
2583                    || (h != NULL
2584                        && !SYMBOL_REFERENCES_LOCAL (info, h))))
2585               || (ELIMINATE_COPY_RELOCS
2586                   && !info->shared
2587                   && h != NULL
2588                   && h->dynindx != -1
2589                   && !h->non_got_ref
2590                   && ((h->def_dynamic
2591                        && !h->def_regular)
2592                       || h->root.type == bfd_link_hash_undefweak
2593                       || h->root.type == bfd_link_hash_undefined)))
2594             {
2595               Elf_Internal_Rela outrel;
2596               bfd_boolean skip, relocate;
2597               asection *sreloc;
2598               bfd_byte *loc;
2599
2600               /* When generating a shared object, these relocations
2601                  are copied into the output file to be resolved at run
2602                  time.  */
2603
2604               skip = FALSE;
2605               relocate = FALSE;
2606
2607               outrel.r_offset =
2608                 _bfd_elf_section_offset (output_bfd, info, input_section,
2609                                          rel->r_offset);
2610               if (outrel.r_offset == (bfd_vma) -1)
2611                 skip = TRUE;
2612               else if (outrel.r_offset == (bfd_vma) -2)
2613                 skip = TRUE, relocate = TRUE;
2614               outrel.r_offset += (input_section->output_section->vma
2615                                   + input_section->output_offset);
2616
2617               if (skip)
2618                 memset (&outrel, 0, sizeof outrel);
2619               else if (h != NULL
2620                        && h->dynindx != -1
2621                        && (r_type == R_390_PC16
2622                            || r_type == R_390_PC16DBL
2623                            || r_type == R_390_PC32DBL
2624                            || r_type == R_390_PC32
2625                            || !info->shared
2626                            || !info->symbolic
2627                            || !h->def_regular))
2628                 {
2629                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2630                   outrel.r_addend = rel->r_addend;
2631                 }
2632               else
2633                 {
2634                   /* This symbol is local, or marked to become local.  */
2635                   outrel.r_addend = relocation + rel->r_addend;
2636                   if (r_type == R_390_32)
2637                     {
2638                       relocate = TRUE;
2639                       outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2640                     }
2641                   else
2642                     {
2643                       long sindx;
2644
2645                       if (bfd_is_abs_section (sec))
2646                         sindx = 0;
2647                       else if (sec == NULL || sec->owner == NULL)
2648                         {
2649                           bfd_set_error(bfd_error_bad_value);
2650                           return FALSE;
2651                         }
2652                       else
2653                         {
2654                           asection *osec;
2655
2656                           osec = sec->output_section;
2657                           sindx = elf_section_data (osec)->dynindx;
2658                           if (sindx == 0)
2659                             {
2660                               osec = htab->elf.text_index_section;
2661                               sindx = elf_section_data (osec)->dynindx;
2662                             }
2663                           BFD_ASSERT (sindx != 0);
2664
2665                           /* We are turning this relocation into one
2666                              against a section symbol, so subtract out
2667                              the output section's address but not the
2668                              offset of the input section in the output
2669                              section.  */
2670                           outrel.r_addend -= osec->vma;
2671                         }
2672                       outrel.r_info = ELF32_R_INFO (sindx, r_type);
2673                     }
2674                 }
2675
2676               sreloc = elf_section_data (input_section)->sreloc;
2677               if (sreloc == NULL)
2678                 abort ();
2679
2680               loc = sreloc->contents;
2681               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2682               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2683
2684               /* If this reloc is against an external symbol, we do
2685                  not want to fiddle with the addend.  Otherwise, we
2686                  need to include the symbol value so that it becomes
2687                  an addend for the dynamic reloc.  */
2688               if (! relocate)
2689                 continue;
2690             }
2691           break;
2692
2693           /* Relocations for tls literal pool entries.  */
2694         case R_390_TLS_IE32:
2695           if (info->shared)
2696             {
2697               Elf_Internal_Rela outrel;
2698               asection *sreloc;
2699               bfd_byte *loc;
2700
2701               outrel.r_offset = rel->r_offset
2702                                 + input_section->output_section->vma
2703                                 + input_section->output_offset;
2704               outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2705               sreloc = elf_section_data (input_section)->sreloc;
2706               if (sreloc == NULL)
2707                 abort ();
2708               loc = sreloc->contents;
2709               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2710               bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2711             }
2712           /* Fall through.  */
2713
2714         case R_390_TLS_GD32:
2715         case R_390_TLS_GOTIE32:
2716           r_type = elf_s390_tls_transition (info, r_type, h == NULL);
2717           tls_type = GOT_UNKNOWN;
2718           if (h == NULL && local_got_offsets)
2719             tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
2720           else if (h != NULL)
2721             {
2722               tls_type = elf_s390_hash_entry(h)->tls_type;
2723               if (!info->shared && h->dynindx == -1 && tls_type >= GOT_TLS_IE)
2724                 r_type = R_390_TLS_LE32;
2725             }
2726           if (r_type == R_390_TLS_GD32 && tls_type >= GOT_TLS_IE)
2727             r_type = R_390_TLS_IE32;
2728
2729           if (r_type == R_390_TLS_LE32)
2730             {
2731               /* This relocation gets optimized away by the local exec
2732                  access optimization.  */
2733               BFD_ASSERT (! unresolved_reloc);
2734               bfd_put_32 (output_bfd, -tpoff (info, relocation),
2735                           contents + rel->r_offset);
2736               continue;
2737             }
2738
2739           if (htab->sgot == NULL)
2740             abort ();
2741
2742           if (h != NULL)
2743             off = h->got.offset;
2744           else
2745             {
2746               if (local_got_offsets == NULL)
2747                 abort ();
2748
2749               off = local_got_offsets[r_symndx];
2750             }
2751
2752         emit_tls_relocs:
2753
2754           if ((off & 1) != 0)
2755             off &= ~1;
2756           else
2757             {
2758               Elf_Internal_Rela outrel;
2759               bfd_byte *loc;
2760               int dr_type, indx;
2761
2762               if (htab->srelgot == NULL)
2763                 abort ();
2764
2765               outrel.r_offset = (htab->sgot->output_section->vma
2766                                  + htab->sgot->output_offset + off);
2767
2768               indx = h && h->dynindx != -1 ? h->dynindx : 0;
2769               if (r_type == R_390_TLS_GD32)
2770                 dr_type = R_390_TLS_DTPMOD;
2771               else
2772                 dr_type = R_390_TLS_TPOFF;
2773               if (dr_type == R_390_TLS_TPOFF && indx == 0)
2774                 outrel.r_addend = relocation - dtpoff_base (info);
2775               else
2776                 outrel.r_addend = 0;
2777               outrel.r_info = ELF32_R_INFO (indx, dr_type);
2778               loc = htab->srelgot->contents;
2779               loc += htab->srelgot->reloc_count++
2780                 * sizeof (Elf32_External_Rela);
2781               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2782
2783               if (r_type == R_390_TLS_GD32)
2784                 {
2785                   if (indx == 0)
2786                     {
2787                       BFD_ASSERT (! unresolved_reloc);
2788                       bfd_put_32 (output_bfd,
2789                                   relocation - dtpoff_base (info),
2790                                   htab->sgot->contents + off + GOT_ENTRY_SIZE);
2791                     }
2792                   else
2793                     {
2794                       outrel.r_info = ELF32_R_INFO (indx, R_390_TLS_DTPOFF);
2795                       outrel.r_offset += GOT_ENTRY_SIZE;
2796                       outrel.r_addend = 0;
2797                       htab->srelgot->reloc_count++;
2798                       loc += sizeof (Elf32_External_Rela);
2799                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2800                     }
2801                 }
2802
2803               if (h != NULL)
2804                 h->got.offset |= 1;
2805               else
2806                 local_got_offsets[r_symndx] |= 1;
2807             }
2808
2809           if (off >= (bfd_vma) -2)
2810             abort ();
2811           if (r_type == ELF32_R_TYPE (rel->r_info))
2812             {
2813               relocation = htab->sgot->output_offset + off;
2814               if (r_type == R_390_TLS_IE32 || r_type == R_390_TLS_IEENT)
2815                 relocation += htab->sgot->output_section->vma;
2816               unresolved_reloc = FALSE;
2817             }
2818           else
2819             {
2820               bfd_put_32 (output_bfd, htab->sgot->output_offset + off,
2821                           contents + rel->r_offset);
2822               continue;
2823             }
2824           break;
2825
2826         case R_390_TLS_GOTIE12:
2827         case R_390_TLS_GOTIE20:
2828         case R_390_TLS_IEENT:
2829           if (h == NULL)
2830             {
2831               if (local_got_offsets == NULL)
2832                 abort();
2833               off = local_got_offsets[r_symndx];
2834               if (info->shared)
2835                 goto emit_tls_relocs;
2836             }
2837           else
2838             {
2839               off = h->got.offset;
2840               tls_type = elf_s390_hash_entry(h)->tls_type;
2841               if (info->shared || h->dynindx != -1 || tls_type < GOT_TLS_IE)
2842                 goto emit_tls_relocs;
2843             }
2844
2845           if (htab->sgot == NULL)
2846             abort ();
2847
2848           BFD_ASSERT (! unresolved_reloc);
2849           bfd_put_32 (output_bfd, -tpoff (info, relocation),
2850                       htab->sgot->contents + off);
2851           relocation = htab->sgot->output_offset + off;
2852           if (r_type == R_390_TLS_IEENT)
2853             relocation += htab->sgot->output_section->vma;
2854           unresolved_reloc = FALSE;
2855           break;
2856
2857         case R_390_TLS_LDM32:
2858           if (! info->shared)
2859             /* The literal pool entry this relocation refers to gets ignored
2860                by the optimized code of the local exec model. Do nothing
2861                and the value will turn out zero.  */
2862             continue;
2863
2864           if (htab->sgot == NULL)
2865             abort ();
2866
2867           off = htab->tls_ldm_got.offset;
2868           if (off & 1)
2869             off &= ~1;
2870           else
2871             {
2872               Elf_Internal_Rela outrel;
2873               bfd_byte *loc;
2874
2875               if (htab->srelgot == NULL)
2876                 abort ();
2877
2878               outrel.r_offset = (htab->sgot->output_section->vma
2879                                  + htab->sgot->output_offset + off);
2880
2881               bfd_put_32 (output_bfd, 0,
2882                           htab->sgot->contents + off + GOT_ENTRY_SIZE);
2883               outrel.r_info = ELF32_R_INFO (0, R_390_TLS_DTPMOD);
2884               outrel.r_addend = 0;
2885               loc = htab->srelgot->contents;
2886               loc += htab->srelgot->reloc_count++
2887                 * sizeof (Elf32_External_Rela);
2888               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2889               htab->tls_ldm_got.offset |= 1;
2890             }
2891           relocation = htab->sgot->output_offset + off;
2892           unresolved_reloc = FALSE;
2893           break;
2894
2895         case R_390_TLS_LE32:
2896           if (info->shared)
2897             {
2898               /* Linking a shared library with non-fpic code requires
2899                  a R_390_TLS_TPOFF relocation.  */
2900               Elf_Internal_Rela outrel;
2901               asection *sreloc;
2902               bfd_byte *loc;
2903               int indx;
2904
2905               outrel.r_offset = rel->r_offset
2906                                 + input_section->output_section->vma
2907                                 + input_section->output_offset;
2908               if (h != NULL && h->dynindx != -1)
2909                 indx = h->dynindx;
2910               else
2911                 indx = 0;
2912               outrel.r_info = ELF32_R_INFO (indx, R_390_TLS_TPOFF);
2913               if (indx == 0)
2914                 outrel.r_addend = relocation - dtpoff_base (info);
2915               else
2916                 outrel.r_addend = 0;
2917               sreloc = elf_section_data (input_section)->sreloc;
2918               if (sreloc == NULL)
2919                 abort ();
2920               loc = sreloc->contents;
2921               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2922               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2923             }
2924           else
2925             {
2926               BFD_ASSERT (! unresolved_reloc);
2927               bfd_put_32 (output_bfd, -tpoff (info, relocation),
2928                           contents + rel->r_offset);
2929             }
2930           continue;
2931
2932         case R_390_TLS_LDO32:
2933           if (info->shared)
2934             relocation -= dtpoff_base (info);
2935           else
2936             /* When converting LDO to LE, we must negate.  */
2937             relocation = -tpoff (info, relocation);
2938           break;
2939
2940           /* Relocations for tls instructions.  */
2941         case R_390_TLS_LOAD:
2942         case R_390_TLS_GDCALL:
2943         case R_390_TLS_LDCALL:
2944           tls_type = GOT_UNKNOWN;
2945           if (h == NULL && local_got_offsets)
2946             tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
2947           else if (h != NULL)
2948             tls_type = elf_s390_hash_entry(h)->tls_type;
2949
2950           if (tls_type == GOT_TLS_GD)
2951             continue;
2952
2953           if (r_type == R_390_TLS_LOAD)
2954             {
2955               if (!info->shared && (h == NULL || h->dynindx == -1))
2956                 {
2957                   /* IE->LE transition. Four valid cases:
2958                      l %rx,0(0,%ry)    -> lr %rx,%ry + bcr 0,0
2959                      l %rx,0(%ry,0)    -> lr %rx,%ry + bcr 0,0
2960                      l %rx,0(%ry,%r12) -> lr %rx,%ry + bcr 0,0
2961                      l %rx,0(%r12,%ry) -> lr %rx,%ry + bcr 0,0 */
2962                   unsigned int insn, ry;
2963
2964                   insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2965                   ry = 0;
2966                   if ((insn & 0xff00f000) == 0x58000000)
2967                     /* l %rx,0(%ry,0) -> lr %rx,%ry + bcr 0,0  */
2968                     ry = (insn & 0x000f0000);
2969                   else if ((insn & 0xff0f0000) == 0x58000000)
2970                     /* l %rx,0(0,%ry) -> lr %rx,%ry + bcr 0,0  */
2971                     ry = (insn & 0x0000f000) << 4;
2972                   else if ((insn & 0xff00f000) == 0x5800c000)
2973                     /* l %rx,0(%ry,%r12) -> lr %rx,%ry + bcr 0,0  */
2974                     ry = (insn & 0x000f0000);
2975                   else if ((insn & 0xff0f0000) == 0x580c0000)
2976                     /* l %rx,0(%r12,%ry) -> lr %rx,%ry + bcr 0,0  */
2977                     ry = (insn & 0x0000f000) << 4;
2978                   else
2979                     invalid_tls_insn (input_bfd, input_section, rel);
2980                   insn = 0x18000700 | (insn & 0x00f00000) | ry;
2981                   bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
2982                 }
2983             }
2984           else if (r_type == R_390_TLS_GDCALL)
2985             {
2986               unsigned int insn;
2987
2988               insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2989               if ((insn & 0xff000fff) != 0x4d000000 &&
2990                   (insn & 0xffff0000) != 0xc0e50000)
2991                 invalid_tls_insn (input_bfd, input_section, rel);
2992               if (!info->shared && (h == NULL || h->dynindx == -1))
2993                 {
2994                   if ((insn & 0xff000000) == 0x4d000000)
2995                     {
2996                       /* GD->LE transition.
2997                          bas %r14,0(%rx,%r13) -> bc 0,0  */
2998                       insn = 0x47000000;
2999                     }
3000                   else
3001                     {
3002                       /* GD->LE transition.
3003                          brasl %r14,_tls_get_addr@plt -> brcl 0,.  */
3004                       insn = 0xc0040000;
3005                       bfd_put_16 (output_bfd, 0x0000,
3006                                   contents + rel->r_offset + 4);
3007                     }
3008                 }
3009               else
3010                 {
3011                   if ((insn & 0xff000000) == 0x4d000000)
3012                     {
3013                       /* GD->IE transition.
3014                          bas %r14,0(%rx,%r13) -> l %r2,0(%r2,%r12)  */
3015                       insn = 0x5822c000;
3016                     }
3017                   else
3018                     {
3019                       /* GD->IE transition.
3020                          brasl %r14,__tls_get_addr@plt ->
3021                                 l %r2,0(%r2,%r12) ; bcr 0,0 */
3022                       insn = 0x5822c000;
3023                       bfd_put_16 (output_bfd, 0x0700,
3024                                   contents + rel->r_offset + 4);
3025                     }
3026                 }
3027               bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3028             }
3029           else if (r_type == R_390_TLS_LDCALL)
3030             {
3031               if (!info->shared)
3032                 {
3033                   unsigned int insn;
3034
3035                   insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3036                   if ((insn & 0xff000fff) != 0x4d000000 &&
3037                       (insn & 0xffff0000) != 0xc0e50000)
3038                     invalid_tls_insn (input_bfd, input_section, rel);
3039                   if ((insn & 0xff000000) == 0x4d000000)
3040                     {
3041                       /* LD->LE transition.
3042                          bas %r14,0(%rx,%r13) -> bc 0,0  */
3043                       insn = 0x47000000;
3044                     }
3045                   else
3046                     {
3047                       /* LD->LE transition.
3048                          brasl %r14,__tls_get_addr@plt -> brcl 0,. */
3049                       insn = 0xc0040000;
3050                       bfd_put_16 (output_bfd, 0x0000,
3051                                   contents + rel->r_offset + 4);
3052                     }
3053                   bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3054                 }
3055             }
3056           continue;
3057
3058         default:
3059           break;
3060         }
3061
3062       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3063          because such sections are not SEC_ALLOC and thus ld.so will
3064          not process them.  */
3065       if (unresolved_reloc
3066           && !((input_section->flags & SEC_DEBUGGING) != 0
3067                && h->def_dynamic))
3068         (*_bfd_error_handler)
3069           (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3070            input_bfd,
3071            input_section,
3072            (long) rel->r_offset,
3073            howto->name,
3074            h->root.root.string);
3075
3076       if (r_type == R_390_20
3077           || r_type == R_390_GOT20
3078           || r_type == R_390_GOTPLT20
3079           || r_type == R_390_TLS_GOTIE20)
3080         {
3081           relocation += rel->r_addend;
3082           relocation = (relocation&0xfff) << 8 | (relocation&0xff000) >> 12;
3083           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3084                                         contents, rel->r_offset,
3085                                         relocation, 0);
3086         }
3087       else
3088         r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3089                                       contents, rel->r_offset,
3090                                       relocation, rel->r_addend);
3091
3092       if (r != bfd_reloc_ok)
3093         {
3094           const char *name;
3095
3096           if (h != NULL)
3097             name = h->root.root.string;
3098           else
3099             {
3100               name = bfd_elf_string_from_elf_section (input_bfd,
3101                                                       symtab_hdr->sh_link,
3102                                                       sym->st_name);
3103               if (name == NULL)
3104                 return FALSE;
3105               if (*name == '\0')
3106                 name = bfd_section_name (input_bfd, sec);
3107             }
3108
3109           if (r == bfd_reloc_overflow)
3110             {
3111
3112               if (! ((*info->callbacks->reloc_overflow)
3113                      (info, (h ? &h->root : NULL), name, howto->name,
3114                       (bfd_vma) 0, input_bfd, input_section,
3115                       rel->r_offset)))
3116                 return FALSE;
3117             }
3118           else
3119             {
3120               (*_bfd_error_handler)
3121                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3122                  input_bfd, input_section,
3123                  (long) rel->r_offset, name, (int) r);
3124               return FALSE;
3125             }
3126         }
3127     }
3128
3129   return TRUE;
3130 }
3131
3132 /* Finish up dynamic symbol handling.  We set the contents of various
3133    dynamic sections here.  */
3134
3135 static bfd_boolean
3136 elf_s390_finish_dynamic_symbol (output_bfd, info, h, sym)
3137      bfd *output_bfd;
3138      struct bfd_link_info *info;
3139      struct elf_link_hash_entry *h;
3140      Elf_Internal_Sym *sym;
3141 {
3142   struct elf_s390_link_hash_table *htab;
3143
3144   htab = elf_s390_hash_table (info);
3145
3146   if (h->plt.offset != (bfd_vma) -1)
3147     {
3148       bfd_vma plt_index;
3149       bfd_vma got_offset;
3150       Elf_Internal_Rela rela;
3151       bfd_byte *loc;
3152       bfd_vma relative_offset;
3153
3154       /* This symbol has an entry in the procedure linkage table.  Set
3155          it up.  */
3156       if (h->dynindx == -1
3157           || htab->splt == NULL
3158           || htab->sgotplt == NULL
3159           || htab->srelplt == NULL)
3160         abort ();
3161
3162       /* Calc. index no.
3163          Current offset - size first entry / entry size.  */
3164       plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3165
3166       /* Offset in GOT is PLT index plus GOT headers(3) times 4,
3167          addr & GOT addr.  */
3168       got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
3169
3170       /* S390 uses halfwords for relative branch calc!  */
3171       relative_offset = - ((PLT_FIRST_ENTRY_SIZE +
3172                             (PLT_ENTRY_SIZE * plt_index) + 18) / 2);
3173       /* If offset is > 32768, branch to a previous branch
3174          390 can only handle +-64 K jumps.  */
3175       if ( -32768 > (int) relative_offset )
3176         relative_offset
3177           = -(unsigned) (((65536 / PLT_ENTRY_SIZE - 1) * PLT_ENTRY_SIZE) / 2);
3178
3179       /* Fill in the entry in the procedure linkage table.  */
3180       if (!info->shared)
3181         {
3182           bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD0,
3183                       htab->splt->contents + h->plt.offset);
3184           bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD1,
3185                       htab->splt->contents + h->plt.offset + 4);
3186           bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD2,
3187                       htab->splt->contents + h->plt.offset + 8);
3188           bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD3,
3189                       htab->splt->contents + h->plt.offset + 12);
3190           bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD4,
3191                       htab->splt->contents + h->plt.offset + 16);
3192           bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3193                       htab->splt->contents + h->plt.offset + 20);
3194           bfd_put_32 (output_bfd,
3195                       (htab->sgotplt->output_section->vma
3196                        + htab->sgotplt->output_offset
3197                        + got_offset),
3198                       htab->splt->contents + h->plt.offset + 24);
3199         }
3200       else if (got_offset < 4096)
3201         {
3202           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC12_ENTRY_WORD0 + got_offset,
3203                       htab->splt->contents + h->plt.offset);
3204           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC12_ENTRY_WORD1,
3205                       htab->splt->contents + h->plt.offset + 4);
3206           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC12_ENTRY_WORD2,
3207                       htab->splt->contents + h->plt.offset + 8);
3208           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC12_ENTRY_WORD3,
3209                       htab->splt->contents + h->plt.offset + 12);
3210           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC12_ENTRY_WORD4,
3211                       htab->splt->contents + h->plt.offset + 16);
3212           bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3213                       htab->splt->contents + h->plt.offset + 20);
3214           bfd_put_32 (output_bfd, (bfd_vma) 0,
3215                       htab->splt->contents + h->plt.offset + 24);
3216         }
3217       else if (got_offset < 32768)
3218         {
3219           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC16_ENTRY_WORD0 + got_offset,
3220                       htab->splt->contents + h->plt.offset);
3221           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC16_ENTRY_WORD1,
3222                       htab->splt->contents + h->plt.offset + 4);
3223           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC16_ENTRY_WORD2,
3224                       htab->splt->contents + h->plt.offset + 8);
3225           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC16_ENTRY_WORD3,
3226                       htab->splt->contents + h->plt.offset + 12);
3227           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC16_ENTRY_WORD4,
3228                       htab->splt->contents + h->plt.offset + 16);
3229           bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3230                       htab->splt->contents + h->plt.offset + 20);
3231           bfd_put_32 (output_bfd, (bfd_vma) 0,
3232                       htab->splt->contents + h->plt.offset + 24);
3233         }
3234       else
3235         {
3236           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_ENTRY_WORD0,
3237                       htab->splt->contents + h->plt.offset);
3238           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_ENTRY_WORD1,
3239                       htab->splt->contents + h->plt.offset + 4);
3240           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_ENTRY_WORD2,
3241                       htab->splt->contents + h->plt.offset + 8);
3242           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_ENTRY_WORD3,
3243                       htab->splt->contents + h->plt.offset + 12);
3244           bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_ENTRY_WORD4,
3245                       htab->splt->contents + h->plt.offset + 16);
3246           bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3247                       htab->splt->contents + h->plt.offset + 20);
3248           bfd_put_32 (output_bfd, got_offset,
3249                       htab->splt->contents + h->plt.offset + 24);
3250         }
3251       /* Insert offset into  reloc. table here.  */
3252       bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
3253                   htab->splt->contents + h->plt.offset + 28);
3254
3255       /* Fill in the entry in the global offset table.
3256          Points to instruction after GOT offset.  */
3257       bfd_put_32 (output_bfd,
3258                   (htab->splt->output_section->vma
3259                    + htab->splt->output_offset
3260                    + h->plt.offset
3261                    + 12),
3262                   htab->sgotplt->contents + got_offset);
3263
3264       /* Fill in the entry in the .rela.plt section.  */
3265       rela.r_offset = (htab->sgotplt->output_section->vma
3266                        + htab->sgotplt->output_offset
3267                        + got_offset);
3268       rela.r_info = ELF32_R_INFO (h->dynindx, R_390_JMP_SLOT);
3269       rela.r_addend = 0;
3270       loc = htab->srelplt->contents + plt_index * sizeof (Elf32_External_Rela);
3271       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3272
3273       if (!h->def_regular)
3274         {
3275           /* Mark the symbol as undefined, rather than as defined in
3276              the .plt section.  Leave the value alone.  This is a clue
3277              for the dynamic linker, to make function pointer
3278              comparisons work between an application and shared
3279              library.  */
3280           sym->st_shndx = SHN_UNDEF;
3281         }
3282     }
3283
3284   if (h->got.offset != (bfd_vma) -1
3285       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_GD
3286       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE
3287       && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE_NLT)
3288     {
3289       Elf_Internal_Rela rela;
3290       bfd_byte *loc;
3291
3292       /* This symbol has an entry in the global offset table.  Set it
3293          up.  */
3294
3295       if (htab->sgot == NULL || htab->srelgot == NULL)
3296         abort ();
3297
3298       rela.r_offset = (htab->sgot->output_section->vma
3299                        + htab->sgot->output_offset
3300                        + (h->got.offset &~ (bfd_vma) 1));
3301
3302       /* If this is a static link, or it is a -Bsymbolic link and the
3303          symbol is defined locally or was forced to be local because
3304          of a version file, we just want to emit a RELATIVE reloc.
3305          The entry in the global offset table will already have been
3306          initialized in the relocate_section function.  */
3307       if (info->shared
3308           && (info->symbolic
3309               || h->dynindx == -1
3310               || h->forced_local)
3311           && h->def_regular)
3312         {
3313           BFD_ASSERT((h->got.offset & 1) != 0);
3314           rela.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
3315           rela.r_addend = (h->root.u.def.value
3316                            + h->root.u.def.section->output_section->vma
3317                            + h->root.u.def.section->output_offset);
3318         }
3319       else
3320         {
3321           BFD_ASSERT((h->got.offset & 1) == 0);
3322           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgot->contents + h->got.offset);
3323           rela.r_info = ELF32_R_INFO (h->dynindx, R_390_GLOB_DAT);
3324           rela.r_addend = 0;
3325         }
3326
3327       loc = htab->srelgot->contents;
3328       loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
3329       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3330     }
3331
3332   if (h->needs_copy)
3333     {
3334       Elf_Internal_Rela rela;
3335       bfd_byte *loc;
3336
3337       /* This symbols needs a copy reloc.  Set it up.  */
3338
3339       if (h->dynindx == -1
3340           || (h->root.type != bfd_link_hash_defined
3341               && h->root.type != bfd_link_hash_defweak)
3342           || htab->srelbss == NULL)
3343         abort ();
3344
3345       rela.r_offset = (h->root.u.def.value
3346                        + h->root.u.def.section->output_section->vma
3347                        + h->root.u.def.section->output_offset);
3348       rela.r_info = ELF32_R_INFO (h->dynindx, R_390_COPY);
3349       rela.r_addend = 0;
3350       loc = htab->srelbss->contents;
3351       loc += htab->srelbss->reloc_count++ * sizeof (Elf32_External_Rela);
3352       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3353     }
3354
3355   /* Mark some specially defined symbols as absolute.  */
3356   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3357       || h == htab->elf.hgot
3358       || h == htab->elf.hplt)
3359     sym->st_shndx = SHN_ABS;
3360
3361   return TRUE;
3362 }
3363
3364 /* Used to decide how to sort relocs in an optimal manner for the
3365    dynamic linker, before writing them out.  */
3366
3367 static enum elf_reloc_type_class
3368 elf_s390_reloc_type_class (rela)
3369      const Elf_Internal_Rela *rela;
3370 {
3371   switch ((int) ELF32_R_TYPE (rela->r_info))
3372     {
3373     case R_390_RELATIVE:
3374       return reloc_class_relative;
3375     case R_390_JMP_SLOT:
3376       return reloc_class_plt;
3377     case R_390_COPY:
3378       return reloc_class_copy;
3379     default:
3380       return reloc_class_normal;
3381     }
3382 }
3383
3384 /* Finish up the dynamic sections.  */
3385
3386 static bfd_boolean
3387 elf_s390_finish_dynamic_sections (output_bfd, info)
3388      bfd *output_bfd;
3389      struct bfd_link_info *info;
3390 {
3391   struct elf_s390_link_hash_table *htab;
3392   bfd *dynobj;
3393   asection *sdyn;
3394
3395   htab = elf_s390_hash_table (info);
3396   dynobj = htab->elf.dynobj;
3397   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3398
3399   if (htab->elf.dynamic_sections_created)
3400     {
3401       Elf32_External_Dyn *dyncon, *dynconend;
3402
3403       if (sdyn == NULL || htab->sgot == NULL)
3404         abort ();
3405
3406       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3407       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3408       for (; dyncon < dynconend; dyncon++)
3409         {
3410           Elf_Internal_Dyn dyn;
3411           asection *s;
3412
3413           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3414
3415           switch (dyn.d_tag)
3416             {
3417             default:
3418               continue;
3419
3420             case DT_PLTGOT:
3421               dyn.d_un.d_ptr = htab->sgot->output_section->vma;
3422               break;
3423
3424             case DT_JMPREL:
3425               dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
3426               break;
3427
3428             case DT_PLTRELSZ:
3429               s = htab->srelplt->output_section;
3430               dyn.d_un.d_val = s->size;
3431               break;
3432             }
3433
3434           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3435         }
3436
3437       /* Fill in the special first entry in the procedure linkage table.  */
3438       if (htab->splt && htab->splt->size > 0)
3439         {
3440           memset (htab->splt->contents, 0, PLT_FIRST_ENTRY_SIZE);
3441           if (info->shared)
3442             {
3443               bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_FIRST_ENTRY_WORD0,
3444                           htab->splt->contents );
3445               bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_FIRST_ENTRY_WORD1,
3446                           htab->splt->contents +4 );
3447               bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_FIRST_ENTRY_WORD2,
3448                           htab->splt->contents +8 );
3449               bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_FIRST_ENTRY_WORD3,
3450                           htab->splt->contents +12 );
3451               bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_FIRST_ENTRY_WORD4,
3452                           htab->splt->contents +16 );
3453            }
3454           else
3455            {
3456               bfd_put_32 (output_bfd, (bfd_vma)PLT_FIRST_ENTRY_WORD0,
3457                           htab->splt->contents );
3458               bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD1,
3459                           htab->splt->contents +4 );
3460               bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD2,
3461                           htab->splt->contents +8 );
3462               bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD3,
3463                           htab->splt->contents +12 );
3464               bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD4,
3465                           htab->splt->contents +16 );
3466               bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD5,
3467                           htab->splt->contents +20 );
3468               bfd_put_32 (output_bfd,
3469                           htab->sgotplt->output_section->vma
3470                           + htab->sgotplt->output_offset,
3471                           htab->splt->contents + 24);
3472            }
3473           elf_section_data (htab->splt->output_section)
3474             ->this_hdr.sh_entsize = 4;
3475         }
3476
3477     }
3478
3479   if (htab->sgotplt)
3480     {
3481       /* Fill in the first three entries in the global offset table.  */
3482       if (htab->sgotplt->size > 0)
3483         {
3484           bfd_put_32 (output_bfd,
3485                       (sdyn == NULL ? (bfd_vma) 0
3486                        : sdyn->output_section->vma + sdyn->output_offset),
3487                       htab->sgotplt->contents);
3488           /* One entry for shared object struct ptr.  */
3489           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 4);
3490           /* One entry for _dl_runtime_resolve.  */
3491           bfd_put_32 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
3492         }
3493
3494       elf_section_data (htab->sgotplt->output_section)
3495         ->this_hdr.sh_entsize = 4;
3496     }
3497   return TRUE;
3498 }
3499
3500 static bfd_boolean
3501 elf_s390_grok_prstatus (abfd, note)
3502      bfd * abfd;
3503      Elf_Internal_Note * note;
3504 {
3505   int offset;
3506   unsigned int size;
3507
3508   switch (note->descsz)
3509     {
3510       default:
3511         return FALSE;
3512
3513       case 224:         /* S/390 Linux.  */
3514         /* pr_cursig */
3515         elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
3516
3517         /* pr_pid */
3518         elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
3519
3520         /* pr_reg */
3521         offset = 72;
3522         size = 144;
3523         break;
3524     }
3525
3526   /* Make a ".reg/999" section.  */
3527   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3528                                           size, note->descpos + offset);
3529 }
3530
3531 /* Return address for Ith PLT stub in section PLT, for relocation REL
3532    or (bfd_vma) -1 if it should not be included.  */
3533
3534 static bfd_vma
3535 elf_s390_plt_sym_val (bfd_vma i, const asection *plt,
3536                       const arelent *rel ATTRIBUTE_UNUSED)
3537 {
3538   return plt->vma + PLT_FIRST_ENTRY_SIZE + i * PLT_ENTRY_SIZE;
3539 }
3540
3541
3542 #define TARGET_BIG_SYM  bfd_elf32_s390_vec
3543 #define TARGET_BIG_NAME "elf32-s390"
3544 #define ELF_ARCH        bfd_arch_s390
3545 #define ELF_MACHINE_CODE EM_S390
3546 #define ELF_MACHINE_ALT1 EM_S390_OLD
3547 #define ELF_MAXPAGESIZE 0x1000
3548
3549 #define elf_backend_can_gc_sections     1
3550 #define elf_backend_can_refcount        1
3551 #define elf_backend_want_got_plt        1
3552 #define elf_backend_plt_readonly        1
3553 #define elf_backend_want_plt_sym        0
3554 #define elf_backend_got_header_size     12
3555 #define elf_backend_rela_normal         1
3556
3557 #define elf_info_to_howto                     elf_s390_info_to_howto
3558
3559 #define bfd_elf32_bfd_is_local_label_name     elf_s390_is_local_label_name
3560 #define bfd_elf32_bfd_link_hash_table_create  elf_s390_link_hash_table_create
3561 #define bfd_elf32_bfd_reloc_type_lookup       elf_s390_reloc_type_lookup
3562 #define bfd_elf32_bfd_reloc_name_lookup elf_s390_reloc_name_lookup
3563
3564 #define elf_backend_adjust_dynamic_symbol     elf_s390_adjust_dynamic_symbol
3565 #define elf_backend_check_relocs              elf_s390_check_relocs
3566 #define elf_backend_copy_indirect_symbol      elf_s390_copy_indirect_symbol
3567 #define elf_backend_create_dynamic_sections   elf_s390_create_dynamic_sections
3568 #define elf_backend_finish_dynamic_sections   elf_s390_finish_dynamic_sections
3569 #define elf_backend_finish_dynamic_symbol     elf_s390_finish_dynamic_symbol
3570 #define elf_backend_gc_mark_hook              elf_s390_gc_mark_hook
3571 #define elf_backend_gc_sweep_hook             elf_s390_gc_sweep_hook
3572 #define elf_backend_reloc_type_class          elf_s390_reloc_type_class
3573 #define elf_backend_relocate_section          elf_s390_relocate_section
3574 #define elf_backend_size_dynamic_sections     elf_s390_size_dynamic_sections
3575 #define elf_backend_init_index_section        _bfd_elf_init_1_index_section
3576 #define elf_backend_reloc_type_class          elf_s390_reloc_type_class
3577 #define elf_backend_grok_prstatus             elf_s390_grok_prstatus
3578 #define elf_backend_plt_sym_val               elf_s390_plt_sym_val
3579
3580 #define bfd_elf32_mkobject              elf_s390_mkobject
3581 #define elf_backend_object_p            elf_s390_object_p
3582
3583 #include "elf32-target.h"