bfd/elf32-s390.c

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