bfd/elf32-s390.c

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