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