bfd/elf64-s390.c

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