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