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