bfd/elf64-s390.c

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