bfd/elf64-s390.c

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