bfd/elf64-s390.c

   1 /* IBM S/390-specific support for 64-bit ELF
   2    Copyright 2000, 2001 Free Software Foundation, Inc.
   3    Contributed Martin Schwidefsky (schwidefsky@de.ibm.com).
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  20    02111-1307, USA.  */
  21
  22 #include "bfd.h"
  23 #include "sysdep.h"
  24 #include "bfdlink.h"
  25 #include "libbfd.h"
  26 #include "elf-bfd.h"
  27
  28 static reloc_howto_type *elf_s390_reloc_type_lookup
  29   PARAMS ((bfd *, bfd_reloc_code_real_type));
  30 static void elf_s390_info_to_howto
  31   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
  32 static boolean elf_s390_is_local_label_name
  33   PARAMS ((bfd *, const char *));
  34 static struct bfd_hash_entry *link_hash_newfunc
  35   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
  36 static struct bfd_link_hash_table *elf_s390_link_hash_table_create
  37   PARAMS ((bfd *));
  38 static boolean create_got_section
  39   PARAMS((bfd *, struct bfd_link_info *));
  40 static boolean elf_s390_create_dynamic_sections
  41   PARAMS((bfd *, struct bfd_link_info *));
  42 static void elf_s390_copy_indirect_symbol
  43   PARAMS ((struct elf_link_hash_entry *, struct elf_link_hash_entry *));
  44 static boolean elf_s390_check_relocs
  45   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  46            const Elf_Internal_Rela *));
  47 static asection *elf_s390_gc_mark_hook
  48   PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
  49            struct elf_link_hash_entry *, Elf_Internal_Sym *));
  50 static boolean elf_s390_gc_sweep_hook
  51   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  52            const Elf_Internal_Rela *));
  53 static boolean elf_s390_adjust_dynamic_symbol
  54   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
  55 static boolean allocate_dynrelocs
  56   PARAMS ((struct elf_link_hash_entry *, PTR));
  57 static boolean readonly_dynrelocs
  58   PARAMS ((struct elf_link_hash_entry *, PTR));
  59 static boolean elf_s390_size_dynamic_sections
  60   PARAMS ((bfd *, struct bfd_link_info *));
  61 static boolean elf_s390_relocate_section
  62   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  63            Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
  64 static boolean elf_s390_finish_dynamic_symbol
  65   PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
  66            Elf_Internal_Sym *));
  67 static enum elf_reloc_type_class elf_s390_reloc_type_class
  68   PARAMS ((const Elf_Internal_Rela *));
  69 static boolean elf_s390_finish_dynamic_sections
  70   PARAMS ((bfd *, struct bfd_link_info *));
  71 static boolean elf_s390_object_p PARAMS ((bfd *));
  72
  73 #define USE_RELA 1              /* We want RELA relocations, not REL.  */
  74
  75 #include "elf/s390.h"
  76
  77 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
  78    from smaller values.  Start with zero, widen, *then* decrement.  */
  79 #define MINUS_ONE      (((bfd_vma)0) - 1)
  80
  81 /* The relocation "howto" table.  */
  82 static reloc_howto_type elf_howto_table[] =
  83 {
  84   HOWTO (R_390_NONE,            /* type */
  85          0,                     /* rightshift */
  86          0,                     /* size (0 = byte, 1 = short, 2 = long) */
  87          0,                     /* bitsize */
  88          false,                 /* pc_relative */
  89          0,                     /* bitpos */
  90          complain_overflow_dont, /* complain_on_overflow */
  91          bfd_elf_generic_reloc, /* special_function */
  92          "R_390_NONE",          /* name */
  93          false,                 /* partial_inplace */
  94          0,                     /* src_mask */
  95          0,                     /* dst_mask */
  96          false),                /* pcrel_offset */
  97
  98   HOWTO(R_390_8,         0, 0,  8, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_8",       false, 0,0x000000ff, false),
  99   HOWTO(R_390_12,        0, 1, 12, false, 0, complain_overflow_dont, bfd_elf_generic_reloc, "R_390_12",      false, 0,0x00000fff, false),
 100   HOWTO(R_390_16,        0, 1, 16, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_16",      false, 0,0x0000ffff, false),
 101   HOWTO(R_390_32,        0, 2, 32, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_32",      false, 0,0xffffffff, false),
 102   HOWTO(R_390_PC32,      0, 2, 32,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PC32",    false, 0,0xffffffff,  true),
 103   HOWTO(R_390_GOT12,     0, 1, 12, false, 0, complain_overflow_dont, bfd_elf_generic_reloc, "R_390_GOT12",   false, 0,0x00000fff, false),
 104   HOWTO(R_390_GOT32,     0, 2, 32, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GOT32",   false, 0,0xffffffff, false),
 105   HOWTO(R_390_PLT32,     0, 2, 32,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PLT32",   false, 0,0xffffffff,  true),
 106   HOWTO(R_390_COPY,      0, 4, 64, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_COPY",    false, 0,MINUS_ONE, false),
 107   HOWTO(R_390_GLOB_DAT,  0, 4, 64, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GLOB_DAT",false, 0,MINUS_ONE, false),
 108   HOWTO(R_390_JMP_SLOT,  0, 4, 64, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_JMP_SLOT",false, 0,MINUS_ONE, false),
 109   HOWTO(R_390_RELATIVE,  0, 4, 64,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_RELATIVE",false, 0,MINUS_ONE, false),
 110   HOWTO(R_390_GOTOFF,    0, 4, 64, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GOTOFF",  false, 0,MINUS_ONE, false),
 111   HOWTO(R_390_GOTPC,     0, 4, 64,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GOTPC",   false, 0,MINUS_ONE,  true),
 112   HOWTO(R_390_GOT16,     0, 1, 16, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GOT16",   false, 0,0x0000ffff, false),
 113   HOWTO(R_390_PC16,      0, 1, 16,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PC16",    false, 0,0x0000ffff,  true),
 114   HOWTO(R_390_PC16DBL,   1, 1, 16,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PC16DBL", false, 0,0x0000ffff,  true),
 115   HOWTO(R_390_PLT16DBL,  1, 1, 16,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PLT16DBL", false, 0,0x0000ffff,  true),
 116   HOWTO(R_390_PC32DBL,   1, 2, 32,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PC32DBL", false, 0,0xffffffff,  true),
 117   HOWTO(R_390_PLT32DBL,  1, 2, 32,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PLT32DBL", false, 0,0xffffffff,  true),
 118   HOWTO(R_390_GOTPCDBL,  1, 2, 32,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GOTPCDBL", false, 0,MINUS_ONE,  true),
 119   HOWTO(R_390_64,        0, 4, 64, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_64",      false, 0,MINUS_ONE, false),
 120   HOWTO(R_390_PC64,      0, 4, 64,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PC64",    false, 0,MINUS_ONE,  true),
 121   HOWTO(R_390_GOT64,     0, 4, 64, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GOT64",   false, 0,MINUS_ONE, false),
 122   HOWTO(R_390_PLT64,     0, 4, 64,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PLT64",   false, 0,MINUS_ONE,  true),
 123   HOWTO(R_390_GOTENT,    1, 2, 32,  true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GOTENT",   false, 0,MINUS_ONE,  true),
 124 };
 125
 126 /* GNU extension to record C++ vtable hierarchy.  */
 127 static reloc_howto_type elf64_s390_vtinherit_howto =
 128   HOWTO (R_390_GNU_VTINHERIT, 0,4,0,false,0,complain_overflow_dont, NULL, "R_390_GNU_VTINHERIT", false,0, 0, false);
 129 static reloc_howto_type elf64_s390_vtentry_howto =
 130   HOWTO (R_390_GNU_VTENTRY, 0,4,0,false,0,complain_overflow_dont, _bfd_elf_rel_vtable_reloc_fn,"R_390_GNU_VTENTRY", false,0,0, false);
 131
 132 static reloc_howto_type *
 133 elf_s390_reloc_type_lookup (abfd, code)
 134      bfd *abfd ATTRIBUTE_UNUSED;
 135      bfd_reloc_code_real_type code;
 136 {
 137   switch (code)
 138     {
 139     case BFD_RELOC_NONE:
 140       return &elf_howto_table[(int) R_390_NONE];
 141     case BFD_RELOC_8:
 142       return &elf_howto_table[(int) R_390_8];
 143     case BFD_RELOC_390_12:
 144       return &elf_howto_table[(int) R_390_12];
 145     case BFD_RELOC_16:
 146       return &elf_howto_table[(int) R_390_16];
 147     case BFD_RELOC_32:
 148       return &elf_howto_table[(int) R_390_32];
 149     case BFD_RELOC_CTOR:
 150       return &elf_howto_table[(int) R_390_32];
 151     case BFD_RELOC_32_PCREL:
 152       return &elf_howto_table[(int) R_390_PC32];
 153     case BFD_RELOC_390_GOT12:
 154       return &elf_howto_table[(int) R_390_GOT12];
 155     case BFD_RELOC_32_GOT_PCREL:
 156       return &elf_howto_table[(int) R_390_GOT32];
 157     case BFD_RELOC_390_PLT32:
 158       return &elf_howto_table[(int) R_390_PLT32];
 159     case BFD_RELOC_390_COPY:
 160       return &elf_howto_table[(int) R_390_COPY];
 161     case BFD_RELOC_390_GLOB_DAT:
 162       return &elf_howto_table[(int) R_390_GLOB_DAT];
 163     case BFD_RELOC_390_JMP_SLOT:
 164       return &elf_howto_table[(int) R_390_JMP_SLOT];
 165     case BFD_RELOC_390_RELATIVE:
 166       return &elf_howto_table[(int) R_390_RELATIVE];
 167     case BFD_RELOC_32_GOTOFF:
 168       return &elf_howto_table[(int) R_390_GOTOFF];
 169     case BFD_RELOC_390_GOTPC:
 170       return &elf_howto_table[(int) R_390_GOTPC];
 171     case BFD_RELOC_390_GOT16:
 172       return &elf_howto_table[(int) R_390_GOT16];
 173     case BFD_RELOC_16_PCREL:
 174       return &elf_howto_table[(int) R_390_PC16];
 175     case BFD_RELOC_390_PC16DBL:
 176       return &elf_howto_table[(int) R_390_PC16DBL];
 177     case BFD_RELOC_390_PLT16DBL:
 178       return &elf_howto_table[(int) R_390_PLT16DBL];
 179     case BFD_RELOC_VTABLE_INHERIT:
 180       return &elf64_s390_vtinherit_howto;
 181     case BFD_RELOC_VTABLE_ENTRY:
 182       return &elf64_s390_vtentry_howto;
 183     case BFD_RELOC_390_PC32DBL:
 184       return &elf_howto_table[(int) R_390_PC32DBL];
 185     case BFD_RELOC_390_PLT32DBL:
 186       return &elf_howto_table[(int) R_390_PLT32DBL];
 187     case BFD_RELOC_390_GOTPCDBL:
 188       return &elf_howto_table[(int) R_390_GOTPCDBL];
 189     case BFD_RELOC_64:
 190       return &elf_howto_table[(int) R_390_64];
 191     case BFD_RELOC_64_PCREL:
 192       return &elf_howto_table[(int) R_390_PC64];
 193     case BFD_RELOC_390_GOT64:
 194       return &elf_howto_table[(int) R_390_GOT64];
 195     case BFD_RELOC_390_PLT64:
 196       return &elf_howto_table[(int) R_390_PLT64];
 197     case BFD_RELOC_390_GOTENT:
 198       return &elf_howto_table[(int) R_390_GOTENT];
 199     default:
 200       break;
 201     }
 202   return 0;
 203 }
 204
 205 /* We need to use ELF64_R_TYPE so we have our own copy of this function,
 206    and elf64-s390.c has its own copy.  */
 207
 208 static void
 209 elf_s390_info_to_howto (abfd, cache_ptr, dst)
 210      bfd *abfd ATTRIBUTE_UNUSED;
 211      arelent *cache_ptr;
 212      Elf_Internal_Rela *dst;
 213 {
 214   switch (ELF64_R_TYPE(dst->r_info))
 215     {
 216     case R_390_GNU_VTINHERIT:
 217       cache_ptr->howto = &elf64_s390_vtinherit_howto;
 218       break;
 219
 220     case R_390_GNU_VTENTRY:
 221       cache_ptr->howto = &elf64_s390_vtentry_howto;
 222       break;
 223
 224     default:
 225       BFD_ASSERT (ELF64_R_TYPE(dst->r_info) < (unsigned int) R_390_max);
 226       cache_ptr->howto = &elf_howto_table[ELF64_R_TYPE(dst->r_info)];
 227     }
 228 }
 229
 230 static boolean
 231 elf_s390_is_local_label_name (abfd, name)
 232      bfd *abfd;
 233      const char *name;
 234 {
 235   if (name[0] == '.' && (name[1] == 'X' || name[1] == 'L'))
 236     return true;
 237
 238   return _bfd_elf_is_local_label_name (abfd, name);
 239 }
 240
 241 /* Functions for the 390 ELF linker.  */
 242
 243 /* The name of the dynamic interpreter.  This is put in the .interp
 244    section.  */
 245
 246 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 247
 248 /* The size in bytes of the first entry in the procedure linkage table.  */
 249 #define PLT_FIRST_ENTRY_SIZE 32
 250 /* The size in bytes of an entry in the procedure linkage table.  */
 251 #define PLT_ENTRY_SIZE 32
 252
 253 #define GOT_ENTRY_SIZE 8
 254
 255 /* The first three entries in a procedure linkage table are reserved,
 256    and the initial contents are unimportant (we zero them out).
 257    Subsequent entries look like this.  See the SVR4 ABI 386
 258    supplement to see how this works.  */
 259
 260 /* For the s390, simple addr offset can only be 0 - 4096.
 261    To use the full 16777216 TB address space, several instructions
 262    are needed to load an address in a register and execute
 263    a branch( or just saving the address)
 264
 265    Furthermore, only r 0 and 1 are free to use!!!  */
 266
 267 /* The first 3 words in the GOT are then reserved.
 268    Word 0 is the address of the dynamic table.
 269    Word 1 is a pointer to a structure describing the object
 270    Word 2 is used to point to the loader entry address.
 271
 272    The code for PLT entries looks like this:
 273
 274    The GOT holds the address in the PLT to be executed.
 275    The loader then gets:
 276    24(15) =  Pointer to the structure describing the object.
 277    28(15) =  Offset in symbol table
 278    The loader  must  then find the module where the function is
 279    and insert the address in the GOT.
 280
 281    PLT1: LARL 1,<fn>@GOTENT # 6 bytes  Load address of GOT entry in r1
 282          LG   1,0(1)      # 6 bytes  Load address from GOT in r1
 283          BCR  15,1        # 2 bytes  Jump to address
 284    RET1: BASR 1,0         # 2 bytes  Return from GOT 1st time
 285          LGF  1,12(1)     # 6 bytes  Load offset in symbl table in r1
 286          BRCL 15,-x       # 6 bytes  Jump to start of PLT
 287          .long ?          # 4 bytes  offset into symbol table
 288
 289    Total = 32 bytes per PLT entry
 290    Fixup at offset 2: relative address to GOT entry
 291    Fixup at offset 22: relative branch to PLT0
 292    Fixup at offset 28: 32 bit offset into symbol table
 293
 294    A 32 bit offset into the symbol table is enough. It allows for symbol
 295    tables up to a size of 2 gigabyte. A single dynamic object (the main
 296    program, any shared library) is limited to 4GB in size and I want to see
 297    the program that manages to have a symbol table of more than 2 GB with a
 298    total size of at max 4 GB.  */
 299
 300 #define PLT_ENTRY_WORD0     (bfd_vma) 0xc0100000
 301 #define PLT_ENTRY_WORD1     (bfd_vma) 0x0000e310
 302 #define PLT_ENTRY_WORD2     (bfd_vma) 0x10000004
 303 #define PLT_ENTRY_WORD3     (bfd_vma) 0x07f10d10
 304 #define PLT_ENTRY_WORD4     (bfd_vma) 0xe310100c
 305 #define PLT_ENTRY_WORD5     (bfd_vma) 0x0014c0f4
 306 #define PLT_ENTRY_WORD6     (bfd_vma) 0x00000000
 307 #define PLT_ENTRY_WORD7     (bfd_vma) 0x00000000
 308
 309 /* The first PLT entry pushes the offset into the symbol table
 310    from R1 onto the stack at 8(15) and the loader object info
 311    at 12(15), loads the loader address in R1 and jumps to it.  */
 312
 313 /* The first entry in the PLT:
 314
 315   PLT0:
 316      STG  1,56(15)  # r1 contains the offset into the symbol table
 317      LARL 1,_GLOBAL_OFFSET_TABLE # load address of global offset table
 318      MVC  48(8,15),8(1) # move loader ino (object struct address) to stack
 319      LG   1,16(1)   # get entry address of loader
 320      BCR  15,1      # jump to loader
 321
 322      Fixup at offset 8: relative address to start of GOT.  */
 323
 324 #define PLT_FIRST_ENTRY_WORD0     (bfd_vma) 0xe310f038
 325 #define PLT_FIRST_ENTRY_WORD1     (bfd_vma) 0x0024c010
 326 #define PLT_FIRST_ENTRY_WORD2     (bfd_vma) 0x00000000
 327 #define PLT_FIRST_ENTRY_WORD3     (bfd_vma) 0xd207f030
 328 #define PLT_FIRST_ENTRY_WORD4     (bfd_vma) 0x1008e310
 329 #define PLT_FIRST_ENTRY_WORD5     (bfd_vma) 0x10100004
 330 #define PLT_FIRST_ENTRY_WORD6     (bfd_vma) 0x07f10700
 331 #define PLT_FIRST_ENTRY_WORD7     (bfd_vma) 0x07000700
 332
 333 /* The s390 linker needs to keep track of the number of relocs that it
 334    decides to copy as dynamic relocs in check_relocs for each symbol.
 335    This is so that it can later discard them if they are found to be
 336    unnecessary.  We store the information in a field extending the
 337    regular ELF linker hash table.  */
 338
 339 struct elf_s390_dyn_relocs
 340 {
 341   struct elf_s390_dyn_relocs *next;
 342
 343   /* The input section of the reloc.  */
 344   asection *sec;
 345
 346   /* Total number of relocs copied for the input section.  */
 347   bfd_size_type count;
 348
 349   /* Number of pc-relative relocs copied for the input section.  */
 350   bfd_size_type pc_count;
 351 };
 352
 353 /* s390 ELF linker hash entry.  */
 354
 355 struct elf_s390_link_hash_entry
 356 {
 357   struct elf_link_hash_entry elf;
 358
 359   /* Track dynamic relocs copied for this symbol.  */
 360   struct elf_s390_dyn_relocs *dyn_relocs;
 361 };
 362
 363 /* s390 ELF linker hash table.  */
 364
 365 struct elf_s390_link_hash_table
 366 {
 367   struct elf_link_hash_table elf;
 368
 369   /* Short-cuts to get to dynamic linker sections.  */
 370   asection *sgot;
 371   asection *sgotplt;
 372   asection *srelgot;
 373   asection *splt;
 374   asection *srelplt;
 375   asection *sdynbss;
 376   asection *srelbss;
 377
 378   /* Small local sym to section mapping cache.  */
 379   struct sym_sec_cache sym_sec;
 380 };
 381
 382 /* Get the s390 ELF linker hash table from a link_info structure.  */
 383
 384 #define elf_s390_hash_table(p) \
 385   ((struct elf_s390_link_hash_table *) ((p)->hash))
 386
 387 /* Create an entry in an s390 ELF linker hash table.  */
 388
 389 static struct bfd_hash_entry *
 390 link_hash_newfunc (entry, table, string)
 391      struct bfd_hash_entry *entry;
 392      struct bfd_hash_table *table;
 393      const char *string;
 394 {
 395   /* Allocate the structure if it has not already been allocated by a
 396      subclass.  */
 397   if (entry == NULL)
 398     {
 399       entry = bfd_hash_allocate (table,
 400                                  sizeof (struct elf_s390_link_hash_entry));
 401       if (entry == NULL)
 402         return entry;
 403     }
 404
 405   /* Call the allocation method of the superclass.  */
 406   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
 407   if (entry != NULL)
 408     {
 409       struct elf_s390_link_hash_entry *eh;
 410
 411       eh = (struct elf_s390_link_hash_entry *) entry;
 412       eh->dyn_relocs = NULL;
 413     }
 414
 415   return entry;
 416 }
 417
 418 /* Create an s390 ELF linker hash table.  */
 419
 420 static struct bfd_link_hash_table *
 421 elf_s390_link_hash_table_create (abfd)
 422      bfd *abfd;
 423 {
 424   struct elf_s390_link_hash_table *ret;
 425   bfd_size_type amt = sizeof (struct elf_s390_link_hash_table);
 426
 427   ret = (struct elf_s390_link_hash_table *) bfd_alloc (abfd, amt);
 428   if (ret == NULL)
 429     return NULL;
 430
 431   if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
 432     {
 433       bfd_release (abfd, ret);
 434       return NULL;
 435     }
 436
 437   ret->sgot = NULL;
 438   ret->sgotplt = NULL;
 439   ret->srelgot = NULL;
 440   ret->splt = NULL;
 441   ret->srelplt = NULL;
 442   ret->sdynbss = NULL;
 443   ret->srelbss = NULL;
 444   ret->sym_sec.abfd = NULL;
 445
 446   return &ret->elf.root;
 447 }
 448
 449 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
 450    shortcuts to them in our hash table.  */
 451
 452 static boolean
 453 create_got_section (dynobj, info)
 454      bfd *dynobj;
 455      struct bfd_link_info *info;
 456 {
 457   struct elf_s390_link_hash_table *htab;
 458
 459   if (! _bfd_elf_create_got_section (dynobj, info))
 460     return false;
 461
 462   htab = elf_s390_hash_table (info);
 463   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
 464   htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
 465   if (!htab->sgot || !htab->sgotplt)
 466     abort ();
 467
 468   htab->srelgot = bfd_make_section (dynobj, ".rela.got");
 469   if (htab->srelgot == NULL
 470       || ! bfd_set_section_flags (dynobj, htab->srelgot,
 471                                   (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
 472                                    | SEC_IN_MEMORY | SEC_LINKER_CREATED
 473                                    | SEC_READONLY))
 474       || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
 475     return false;
 476   return true;
 477 }
 478
 479 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
 480    .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
 481    hash table.  */
 482
 483 static boolean
 484 elf_s390_create_dynamic_sections (dynobj, info)
 485      bfd *dynobj;
 486      struct bfd_link_info *info;
 487 {
 488   struct elf_s390_link_hash_table *htab;
 489
 490   htab = elf_s390_hash_table (info);
 491   if (!htab->sgot && !create_got_section (dynobj, info))
 492     return false;
 493
 494   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
 495     return false;
 496
 497   htab->splt = bfd_get_section_by_name (dynobj, ".plt");
 498   htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
 499   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
 500   if (!info->shared)
 501     htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
 502
 503   if (!htab->splt || !htab->srelplt || !htab->sdynbss
 504       || (!info->shared && !htab->srelbss))
 505     abort ();
 506
 507   return true;
 508 }
 509
 510 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
 511
 512 static void
 513 elf_s390_copy_indirect_symbol (dir, ind)
 514      struct elf_link_hash_entry *dir, *ind;
 515 {
 516   struct elf_s390_link_hash_entry *edir, *eind;
 517
 518   edir = (struct elf_s390_link_hash_entry *) dir;
 519   eind = (struct elf_s390_link_hash_entry *) ind;
 520
 521   if (eind->dyn_relocs != NULL)
 522     {
 523       if (edir->dyn_relocs != NULL)
 524         {
 525           struct elf_s390_dyn_relocs **pp;
 526           struct elf_s390_dyn_relocs *p;
 527
 528           if (ind->root.type == bfd_link_hash_indirect)
 529             abort ();
 530
 531           /* Add reloc counts against the weak sym to the strong sym
 532              list.  Merge any entries against the same section.  */
 533           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
 534             {
 535               struct elf_s390_dyn_relocs *q;
 536
 537               for (q = edir->dyn_relocs; q != NULL; q = q->next)
 538                 if (q->sec == p->sec)
 539                   {
 540                     q->pc_count += p->pc_count;
 541                     q->count += p->count;
 542                     *pp = p->next;
 543                     break;
 544                   }
 545               if (q == NULL)
 546                 pp = &p->next;
 547             }
 548           *pp = edir->dyn_relocs;
 549         }
 550
 551       edir->dyn_relocs = eind->dyn_relocs;
 552       eind->dyn_relocs = NULL;
 553     }
 554
 555   _bfd_elf_link_hash_copy_indirect (dir, ind);
 556 }
 557
 558 /* Look through the relocs for a section during the first phase, and
 559    allocate space in the global offset table or procedure linkage
 560    table.  */
 561
 562 static boolean
 563 elf_s390_check_relocs (abfd, info, sec, relocs)
 564      bfd *abfd;
 565      struct bfd_link_info *info;
 566      asection *sec;
 567      const Elf_Internal_Rela *relocs;
 568 {
 569   struct elf_s390_link_hash_table *htab;
 570   Elf_Internal_Shdr *symtab_hdr;
 571   struct elf_link_hash_entry **sym_hashes;
 572   const Elf_Internal_Rela *rel;
 573   const Elf_Internal_Rela *rel_end;
 574   asection *sreloc;
 575
 576   if (info->relocateable)
 577     return true;
 578
 579   htab = elf_s390_hash_table (info);
 580   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 581   sym_hashes = elf_sym_hashes (abfd);
 582
 583   sreloc = NULL;
 584
 585   rel_end = relocs + sec->reloc_count;
 586   for (rel = relocs; rel < rel_end; rel++)
 587     {
 588       unsigned long r_symndx;
 589       struct elf_link_hash_entry *h;
 590
 591       r_symndx = ELF64_R_SYM (rel->r_info);
 592
 593       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
 594         {
 595           (*_bfd_error_handler) (_("%s: bad symbol index: %d"),
 596                                  bfd_archive_filename (abfd),
 597                                  r_symndx);
 598           return false;
 599         }
 600
 601       if (r_symndx < symtab_hdr->sh_info)
 602         h = NULL;
 603       else
 604         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 605
 606       switch (ELF64_R_TYPE (rel->r_info))
 607         {
 608         case R_390_GOT12:
 609         case R_390_GOT16:
 610         case R_390_GOT32:
 611         case R_390_GOT64:
 612         case R_390_GOTENT:
 613           /* This symbol requires a global offset table entry.  */
 614           if (h != NULL)
 615             {
 616               h->got.refcount += 1;
 617             }
 618           else
 619             {
 620               bfd_signed_vma *local_got_refcounts;
 621
 622               /* This is a global offset table entry for a local symbol.  */
 623               local_got_refcounts = elf_local_got_refcounts (abfd);
 624               if (local_got_refcounts == NULL)
 625                 {
 626                   bfd_size_type size;
 627
 628                   size = symtab_hdr->sh_info;
 629                   size *= sizeof (bfd_signed_vma);
 630                   local_got_refcounts = ((bfd_signed_vma *)
 631                                          bfd_zalloc (abfd, size));
 632                   if (local_got_refcounts == NULL)
 633                     return false;
 634                   elf_local_got_refcounts (abfd) = local_got_refcounts;
 635                 }
 636               local_got_refcounts[r_symndx] += 1;
 637             }
 638           /* Fall through */
 639
 640         case R_390_GOTOFF:
 641         case R_390_GOTPC:
 642         case R_390_GOTPCDBL:
 643           if (htab->sgot == NULL)
 644             {
 645               if (htab->elf.dynobj == NULL)
 646                 htab->elf.dynobj = abfd;
 647               if (!create_got_section (htab->elf.dynobj, info))
 648                 return false;
 649             }
 650           break;
 651
 652         case R_390_PLT16DBL:
 653         case R_390_PLT32:
 654         case R_390_PLT32DBL:
 655         case R_390_PLT64:
 656           /* This symbol requires a procedure linkage table entry.  We
 657              actually build the entry in adjust_dynamic_symbol,
 658              because this might be a case of linking PIC code which is
 659              never referenced by a dynamic object, in which case we
 660              don't need to generate a procedure linkage table entry
 661              after all.  */
 662
 663           /* If this is a local symbol, we resolve it directly without
 664              creating a procedure linkage table entry.  */
 665           if (h == NULL)
 666             continue;
 667
 668           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
 669           h->plt.refcount += 1;
 670           break;
 671
 672         case R_390_8:
 673         case R_390_16:
 674         case R_390_32:
 675         case R_390_64:
 676         case R_390_PC16:
 677         case R_390_PC16DBL:
 678         case R_390_PC32:
 679         case R_390_PC32DBL:
 680         case R_390_PC64:
 681           if (h != NULL && !info->shared)
 682             {
 683               /* If this reloc is in a read-only section, we might
 684                  need a copy reloc.  We can't check reliably at this
 685                  stage whether the section is read-only, as input
 686                  sections have not yet been mapped to output sections.
 687                  Tentatively set the flag for now, and correct in
 688                  adjust_dynamic_symbol.  */
 689               h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
 690
 691               /* We may need a .plt entry if the function this reloc
 692                  refers to is in a shared lib.  */
 693               h->plt.refcount += 1;
 694             }
 695
 696           /* If we are creating a shared library, and this is a reloc
 697              against a global symbol, or a non PC relative reloc
 698              against a local symbol, then we need to copy the reloc
 699              into the shared library.  However, if we are linking with
 700              -Bsymbolic, we do not need to copy a reloc against a
 701              global symbol which is defined in an object we are
 702              including in the link (i.e., DEF_REGULAR is set).  At
 703              this point we have not seen all the input files, so it is
 704              possible that DEF_REGULAR is not set now but will be set
 705              later (it is never cleared).  In case of a weak definition,
 706              DEF_REGULAR may be cleared later by a strong definition in
 707              a shared library. We account for that possibility below by
 708              storing information in the relocs_copied field of the hash
 709              table entry.  A similar situation occurs when creating
 710              shared libraries and symbol visibility changes render the
 711              symbol local.
 712
 713              If on the other hand, we are creating an executable, we
 714              may need to keep relocations for symbols satisfied by a
 715              dynamic library if we manage to avoid copy relocs for the
 716              symbol.  */
 717           if ((info->shared
 718                && (sec->flags & SEC_ALLOC) != 0
 719                && ((ELF64_R_TYPE (rel->r_info) != R_390_PC16
 720                     && ELF64_R_TYPE (rel->r_info) != R_390_PC16DBL
 721                     && ELF64_R_TYPE (rel->r_info) != R_390_PC32
 722                     && ELF64_R_TYPE (rel->r_info) != R_390_PC32DBL
 723                     && ELF64_R_TYPE (rel->r_info) != R_390_PC64)
 724                    || (h != NULL
 725                        && (! info->symbolic
 726                            || h->root.type == bfd_link_hash_defweak
 727                            || (h->elf_link_hash_flags
 728                                & ELF_LINK_HASH_DEF_REGULAR) == 0))))
 729               || (!info->shared
 730                   && (sec->flags & SEC_ALLOC) != 0
 731                   && h != NULL
 732                   && (h->root.type == bfd_link_hash_defweak
 733                       || (h->elf_link_hash_flags
 734                           & ELF_LINK_HASH_DEF_REGULAR) == 0)))
 735             {
 736               struct elf_s390_dyn_relocs *p;
 737               struct elf_s390_dyn_relocs **head;
 738
 739               /* We must copy these reloc types into the output file.
 740                  Create a reloc section in dynobj and make room for
 741                  this reloc.  */
 742               if (sreloc == NULL)
 743                 {
 744                   const char *name;
 745                   bfd *dynobj;
 746
 747                   name = (bfd_elf_string_from_elf_section
 748                           (abfd,
 749                            elf_elfheader (abfd)->e_shstrndx,
 750                            elf_section_data (sec)->rel_hdr.sh_name));
 751                   if (name == NULL)
 752                     return false;
 753
 754                   if (strncmp (name, ".rela", 5) != 0
 755                       || strcmp (bfd_get_section_name (abfd, sec),
 756                                  name + 5) != 0)
 757                     {
 758                       (*_bfd_error_handler)
 759                         (_("%s: bad relocation section name `%s\'"),
 760                          bfd_archive_filename (abfd), name);
 761                     }
 762
 763                   if (htab->elf.dynobj == NULL)
 764                     htab->elf.dynobj = abfd;
 765
 766                   dynobj = htab->elf.dynobj;
 767                   sreloc = bfd_get_section_by_name (dynobj, name);
 768                   if (sreloc == NULL)
 769                     {
 770                       flagword flags;
 771
 772                       sreloc = bfd_make_section (dynobj, name);
 773                       flags = (SEC_HAS_CONTENTS | SEC_READONLY
 774                                | SEC_IN_MEMORY | SEC_LINKER_CREATED);
 775                       if ((sec->flags & SEC_ALLOC) != 0)
 776                         flags |= SEC_ALLOC | SEC_LOAD;
 777                       if (sreloc == NULL
 778                           || ! bfd_set_section_flags (dynobj, sreloc, flags)
 779                           || ! bfd_set_section_alignment (dynobj, sreloc, 2))
 780                         return false;
 781                     }
 782                   elf_section_data (sec)->sreloc = sreloc;
 783                 }
 784
 785               /* If this is a global symbol, we count the number of
 786                  relocations we need for this symbol.  */
 787               if (h != NULL)
 788                 {
 789                   head = &((struct elf_s390_link_hash_entry *) h)->dyn_relocs;
 790                 }
 791               else
 792                 {
 793                   /* Track dynamic relocs needed for local syms too.
 794                      We really need local syms available to do this
 795                      easily.  Oh well.  */
 796
 797                   asection *s;
 798                   s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
 799                                                  sec, r_symndx);
 800                   if (s == NULL)
 801                     return false;
 802
 803                   head = ((struct elf_s390_dyn_relocs **)
 804                           &elf_section_data (s)->local_dynrel);
 805                 }
 806
 807               p = *head;
 808               if (p == NULL || p->sec != sec)
 809                 {
 810                   bfd_size_type amt = sizeof *p;
 811                   p = ((struct elf_s390_dyn_relocs *)
 812                        bfd_alloc (htab->elf.dynobj, amt));
 813                   if (p == NULL)
 814                     return false;
 815                   p->next = *head;
 816                   *head = p;
 817                   p->sec = sec;
 818                   p->count = 0;
 819                   p->pc_count = 0;
 820                 }
 821
 822               p->count += 1;
 823               if (ELF64_R_TYPE (rel->r_info) == R_390_PC16
 824                   || ELF64_R_TYPE (rel->r_info) == R_390_PC16DBL
 825                   || ELF64_R_TYPE (rel->r_info) == R_390_PC32
 826                   || ELF64_R_TYPE (rel->r_info) == R_390_PC32DBL
 827                   || ELF64_R_TYPE (rel->r_info) == R_390_PC64)
 828                 p->pc_count += 1;
 829             }
 830           break;
 831
 832           /* This relocation describes the C++ object vtable hierarchy.
 833              Reconstruct it for later use during GC.  */
 834         case R_390_GNU_VTINHERIT:
 835           if (!_bfd_elf64_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 836             return false;
 837           break;
 838
 839           /* This relocation describes which C++ vtable entries are actually
 840              used.  Record for later use during GC.  */
 841         case R_390_GNU_VTENTRY:
 842           if (!_bfd_elf64_gc_record_vtentry (abfd, sec, h, rel->r_offset))
 843             return false;
 844           break;
 845
 846         default:
 847           break;
 848         }
 849     }
 850
 851   return true;
 852 }
 853
 854 /* Return the section that should be marked against GC for a given
 855    relocation.  */
 856
 857 static asection *
 858 elf_s390_gc_mark_hook (abfd, info, rel, h, sym)
 859      bfd *abfd;
 860      struct bfd_link_info *info ATTRIBUTE_UNUSED;
 861      Elf_Internal_Rela *rel;
 862      struct elf_link_hash_entry *h;
 863      Elf_Internal_Sym *sym;
 864 {
 865   if (h != NULL)
 866     {
 867       switch (ELF64_R_TYPE (rel->r_info))
 868         {
 869         case R_390_GNU_VTINHERIT:
 870         case R_390_GNU_VTENTRY:
 871           break;
 872
 873         default:
 874           switch (h->root.type)
 875             {
 876             case bfd_link_hash_defined:
 877             case bfd_link_hash_defweak:
 878               return h->root.u.def.section;
 879
 880             case bfd_link_hash_common:
 881               return h->root.u.c.p->section;
 882
 883             default:
 884               break;
 885             }
 886         }
 887     }
 888   else
 889     {
 890       if (!(elf_bad_symtab (abfd)
 891             && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
 892           && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
 893                 && sym->st_shndx != SHN_COMMON))
 894         {
 895           return bfd_section_from_elf_index (abfd, sym->st_shndx);
 896         }
 897     }
 898
 899   return NULL;
 900 }
 901
 902 /* Update the got entry reference counts for the section being removed.  */
 903
 904 static boolean
 905 elf_s390_gc_sweep_hook (abfd, info, sec, relocs)
 906      bfd *abfd;
 907      struct bfd_link_info *info;
 908      asection *sec;
 909      const Elf_Internal_Rela *relocs;
 910 {
 911   Elf_Internal_Shdr *symtab_hdr;
 912   struct elf_link_hash_entry **sym_hashes;
 913   bfd_signed_vma *local_got_refcounts;
 914   const Elf_Internal_Rela *rel, *relend;
 915   unsigned long r_symndx;
 916   struct elf_link_hash_entry *h;
 917
 918   elf_section_data (sec)->local_dynrel = NULL;
 919
 920   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 921   sym_hashes = elf_sym_hashes (abfd);
 922   local_got_refcounts = elf_local_got_refcounts (abfd);
 923
 924   relend = relocs + sec->reloc_count;
 925   for (rel = relocs; rel < relend; rel++)
 926     switch (ELF64_R_TYPE (rel->r_info))
 927       {
 928       case R_390_GOT12:
 929       case R_390_GOT16:
 930       case R_390_GOT32:
 931       case R_390_GOT64:
 932       case R_390_GOTOFF:
 933       case R_390_GOTPC:
 934       case R_390_GOTPCDBL:
 935       case R_390_GOTENT:
 936         r_symndx = ELF64_R_SYM (rel->r_info);
 937         if (r_symndx >= symtab_hdr->sh_info)
 938           {
 939             h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 940             if (h->got.refcount > 0)
 941               h->got.refcount -= 1;
 942           }
 943         else if (local_got_refcounts != NULL)
 944           {
 945             if (local_got_refcounts[r_symndx] > 0)
 946               local_got_refcounts[r_symndx] -= 1;
 947           }
 948         break;
 949
 950       case R_390_8:
 951       case R_390_12:
 952       case R_390_16:
 953       case R_390_32:
 954       case R_390_64:
 955       case R_390_PC16:
 956       case R_390_PC16DBL:
 957       case R_390_PC32:
 958       case R_390_PC32DBL:
 959       case R_390_PC64:
 960         r_symndx = ELF64_R_SYM (rel->r_info);
 961         if (r_symndx >= symtab_hdr->sh_info)
 962           {
 963             struct elf_s390_link_hash_entry *eh;
 964             struct elf_s390_dyn_relocs **pp;
 965             struct elf_s390_dyn_relocs *p;
 966
 967             h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 968
 969             if (!info->shared && h->plt.refcount > 0)
 970               h->plt.refcount -= 1;
 971
 972             eh = (struct elf_s390_link_hash_entry *) h;
 973
 974             for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
 975               if (p->sec == sec)
 976                 {
 977                   if (ELF64_R_TYPE (rel->r_info) == R_390_PC16
 978                       || ELF64_R_TYPE (rel->r_info) == R_390_PC16DBL
 979                       || ELF64_R_TYPE (rel->r_info) == R_390_PC32)
 980                     p->pc_count -= 1;
 981                   p->count -= 1;
 982                   if (p->count == 0)
 983                     *pp = p->next;
 984                   break;
 985                 }
 986           }
 987         break;
 988
 989       case R_390_PLT16DBL:
 990       case R_390_PLT32:
 991       case R_390_PLT32DBL:
 992       case R_390_PLT64:
 993         r_symndx = ELF64_R_SYM (rel->r_info);
 994         if (r_symndx >= symtab_hdr->sh_info)
 995           {
 996             h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 997             if (h->plt.refcount > 0)
 998               h->plt.refcount -= 1;
 999           }
1000         break;
1001
1002       default:
1003         break;
1004       }
1005
1006   return true;
1007 }
1008
1009 /* Adjust a symbol defined by a dynamic object and referenced by a
1010    regular object.  The current definition is in some section of the
1011    dynamic object, but we're not including those sections.  We have to
1012    change the definition to something the rest of the link can
1013    understand.  */
1014
1015 static boolean
1016 elf_s390_adjust_dynamic_symbol (info, h)
1017      struct bfd_link_info *info;
1018      struct elf_link_hash_entry *h;
1019 {
1020   struct elf_s390_link_hash_table *htab;
1021   struct elf_s390_link_hash_entry * eh;
1022   struct elf_s390_dyn_relocs *p;
1023   asection *s;
1024   unsigned int power_of_two;
1025
1026   /* If this is a function, put it in the procedure linkage table.  We
1027      will fill in the contents of the procedure linkage table later
1028      (although we could actually do it here). */
1029   if (h->type == STT_FUNC
1030       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
1031     {
1032       if (h->plt.refcount <= 0
1033           || (! info->shared
1034               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
1035               && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0))
1036         {
1037           /* This case can occur if we saw a PLT32 reloc in an input
1038              file, but the symbol was never referred to by a dynamic
1039              object, or if all references were garbage collected.  In
1040              such a case, we don't actually need to build a procedure
1041              linkage table, and we can just do a PC32 reloc instead.  */
1042           h->plt.offset = (bfd_vma) -1;
1043           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1044         }
1045
1046       return true;
1047     }
1048   else
1049     /* It's possible that we incorrectly decided a .plt reloc was
1050        needed for an R_390_PC32 reloc to a non-function sym in
1051        check_relocs.  We can't decide accurately between function and
1052        non-function syms in check-relocs;  Objects loaded later in
1053        the link may change h->type.  So fix it now.  */
1054     h->plt.offset = (bfd_vma) -1;
1055
1056   /* If this is a weak symbol, and there is a real definition, the
1057      processor independent code will have arranged for us to see the
1058      real definition first, and we can just use the same value.  */
1059   if (h->weakdef != NULL)
1060     {
1061       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1062                   || h->weakdef->root.type == bfd_link_hash_defweak);
1063       h->root.u.def.section = h->weakdef->root.u.def.section;
1064       h->root.u.def.value = h->weakdef->root.u.def.value;
1065       return true;
1066     }
1067
1068   /* This is a reference to a symbol defined by a dynamic object which
1069      is not a function.  */
1070
1071   /* If we are creating a shared library, we must presume that the
1072      only references to the symbol are via the global offset table.
1073      For such cases we need not do anything here; the relocations will
1074      be handled correctly by relocate_section.  */
1075   if (info->shared)
1076     return true;
1077
1078   /* If there are no references to this symbol that do not use the
1079      GOT, we don't need to generate a copy reloc.  */
1080   if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1081     return true;
1082
1083   /* If -z nocopyreloc was given, we won't generate them either.  */
1084   if (info->nocopyreloc)
1085     {
1086       h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1087       return true;
1088     }
1089
1090   eh = (struct elf_s390_link_hash_entry *) h;
1091   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1092     {
1093       s = p->sec->output_section;
1094       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1095         break;
1096     }
1097
1098   /* If we didn't find any dynamic relocs in read-only sections, then
1099      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
1100   if (p == NULL)
1101     {
1102       h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1103       return true;
1104     }
1105
1106   /* We must allocate the symbol in our .dynbss section, which will
1107      become part of the .bss section of the executable.  There will be
1108      an entry for this symbol in the .dynsym section.  The dynamic
1109      object will contain position independent code, so all references
1110      from the dynamic object to this symbol will go through the global
1111      offset table.  The dynamic linker will use the .dynsym entry to
1112      determine the address it must put in the global offset table, so
1113      both the dynamic object and the regular object will refer to the
1114      same memory location for the variable.  */
1115
1116   htab = elf_s390_hash_table (info);
1117
1118   /* We must generate a R_390_COPY reloc to tell the dynamic linker to
1119      copy the initial value out of the dynamic object and into the
1120      runtime process image.  */
1121   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1122     {
1123       htab->srelbss->_raw_size += sizeof (Elf64_External_Rela);
1124       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1125     }
1126
1127   /* We need to figure out the alignment required for this symbol.  I
1128      have no idea how ELF linkers handle this.  */
1129   power_of_two = bfd_log2 (h->size);
1130   if (power_of_two > 3)
1131     power_of_two = 3;
1132
1133   /* Apply the required alignment.  */
1134   s = htab->sdynbss;
1135   s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
1136   if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
1137     {
1138       if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
1139         return false;
1140     }
1141
1142   /* Define the symbol as being at this point in the section.  */
1143   h->root.u.def.section = s;
1144   h->root.u.def.value = s->_raw_size;
1145
1146   /* Increment the section size to make room for the symbol.  */
1147   s->_raw_size += h->size;
1148
1149   return true;
1150 }
1151
1152 /* This is the condition under which elf_s390_finish_dynamic_symbol
1153    will be called from elflink.h.  If elflink.h doesn't call our
1154    finish_dynamic_symbol routine, we'll need to do something about
1155    initializing any .plt and .got entries in elf_s390_relocate_section.  */
1156 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1157   ((DYN)                                                                \
1158    && ((INFO)->shared                                                   \
1159        || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)      \
1160    && ((H)->dynindx != -1                                               \
1161        || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1162
1163 /* Allocate space in .plt, .got and associated reloc sections for
1164    dynamic relocs.  */
1165
1166 static boolean
1167 allocate_dynrelocs (h, inf)
1168      struct elf_link_hash_entry *h;
1169      PTR inf;
1170 {
1171   struct bfd_link_info *info;
1172   struct elf_s390_link_hash_table *htab;
1173   struct elf_s390_link_hash_entry *eh;
1174   struct elf_s390_dyn_relocs *p;
1175
1176   if (h->root.type == bfd_link_hash_indirect
1177       || h->root.type == bfd_link_hash_warning)
1178     return true;
1179
1180   info = (struct bfd_link_info *) inf;
1181   htab = elf_s390_hash_table (info);
1182
1183   if (htab->elf.dynamic_sections_created
1184       && h->plt.refcount > 0)
1185     {
1186       /* Make sure this symbol is output as a dynamic symbol.
1187          Undefined weak syms won't yet be marked as dynamic.  */
1188       if (h->dynindx == -1
1189           && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1190         {
1191           if (! bfd_elf64_link_record_dynamic_symbol (info, h))
1192             return false;
1193         }
1194
1195       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
1196         {
1197           asection *s = htab->splt;
1198
1199           /* If this is the first .plt entry, make room for the special
1200              first entry.  */
1201           if (s->_raw_size == 0)
1202             s->_raw_size += PLT_FIRST_ENTRY_SIZE;
1203
1204           h->plt.offset = s->_raw_size;
1205
1206           /* If this symbol is not defined in a regular file, and we are
1207              not generating a shared library, then set the symbol to this
1208              location in the .plt.  This is required to make function
1209              pointers compare as equal between the normal executable and
1210              the shared library.  */
1211           if (! info->shared
1212               && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1213             {
1214               h->root.u.def.section = s;
1215               h->root.u.def.value = h->plt.offset;
1216             }
1217
1218           /* Make room for this entry.  */
1219           s->_raw_size += PLT_ENTRY_SIZE;
1220
1221           /* We also need to make an entry in the .got.plt section, which
1222              will be placed in the .got section by the linker script.  */
1223           htab->sgotplt->_raw_size += GOT_ENTRY_SIZE;
1224
1225           /* We also need to make an entry in the .rela.plt section.  */
1226           htab->srelplt->_raw_size += sizeof (Elf64_External_Rela);
1227         }
1228       else
1229         {
1230           h->plt.offset = (bfd_vma) -1;
1231           h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1232         }
1233     }
1234   else
1235     {
1236       h->plt.offset = (bfd_vma) -1;
1237       h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1238     }
1239
1240   if (h->got.refcount > 0)
1241     {
1242       asection *s;
1243       boolean dyn;
1244
1245       /* Make sure this symbol is output as a dynamic symbol.
1246          Undefined weak syms won't yet be marked as dynamic.  */
1247       if (h->dynindx == -1
1248           && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1249         {
1250           if (! bfd_elf64_link_record_dynamic_symbol (info, h))
1251             return false;
1252         }
1253
1254       s = htab->sgot;
1255       h->got.offset = s->_raw_size;
1256       s->_raw_size += GOT_ENTRY_SIZE;
1257       dyn = htab->elf.dynamic_sections_created;
1258       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h))
1259         htab->srelgot->_raw_size += sizeof (Elf64_External_Rela);
1260     }
1261   else
1262     h->got.offset = (bfd_vma) -1;
1263
1264   eh = (struct elf_s390_link_hash_entry *) h;
1265   if (eh->dyn_relocs == NULL)
1266     return true;
1267
1268   /* In the shared -Bsymbolic case, discard space allocated for
1269      dynamic pc-relative relocs against symbols which turn out to be
1270      defined in regular objects.  For the normal shared case, discard
1271      space for pc-relative relocs that have become local due to symbol
1272      visibility changes.  */
1273
1274   if (info->shared)
1275     {
1276       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1277           && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1278               || info->symbolic))
1279         {
1280           struct elf_s390_dyn_relocs **pp;
1281
1282           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1283             {
1284               p->count -= p->pc_count;
1285               p->pc_count = 0;
1286               if (p->count == 0)
1287                 *pp = p->next;
1288               else
1289                 pp = &p->next;
1290             }
1291         }
1292     }
1293   else
1294     {
1295       /* For the non-shared case, discard space for relocs against
1296          symbols which turn out to need copy relocs or are not
1297          dynamic.  */
1298
1299       if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1300           && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1301                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1302               || (htab->elf.dynamic_sections_created
1303                   && (h->root.type == bfd_link_hash_undefweak
1304                       || h->root.type == bfd_link_hash_undefined))))
1305         {
1306           /* Make sure this symbol is output as a dynamic symbol.
1307              Undefined weak syms won't yet be marked as dynamic.  */
1308           if (h->dynindx == -1
1309               && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1310             {
1311               if (! bfd_elf64_link_record_dynamic_symbol (info, h))
1312                 return false;
1313             }
1314
1315           /* If that succeeded, we know we'll be keeping all the
1316              relocs.  */
1317           if (h->dynindx != -1)
1318             goto keep;
1319         }
1320
1321       eh->dyn_relocs = NULL;
1322
1323     keep: ;
1324     }
1325
1326   /* Finally, allocate space.  */
1327   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1328     {
1329       asection *sreloc = elf_section_data (p->sec)->sreloc;
1330       sreloc->_raw_size += p->count * sizeof (Elf64_External_Rela);
1331     }
1332
1333   return true;
1334 }
1335
1336 /* Find any dynamic relocs that apply to read-only sections.  */
1337
1338 static boolean
1339 readonly_dynrelocs (h, inf)
1340      struct elf_link_hash_entry *h;
1341      PTR inf;
1342 {
1343   struct elf_s390_link_hash_entry *eh;
1344   struct elf_s390_dyn_relocs *p;
1345
1346   eh = (struct elf_s390_link_hash_entry *) h;
1347   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1348     {
1349       asection *s = p->sec->output_section;
1350
1351       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1352         {
1353           struct bfd_link_info *info = (struct bfd_link_info *) inf;
1354
1355           info->flags |= DF_TEXTREL;
1356
1357           /* Not an error, just cut short the traversal.  */
1358           return false;
1359         }
1360     }
1361   return true;
1362 }
1363
1364 /* Set the sizes of the dynamic sections.  */
1365
1366 static boolean
1367 elf_s390_size_dynamic_sections (output_bfd, info)
1368      bfd *output_bfd ATTRIBUTE_UNUSED;
1369      struct bfd_link_info *info;
1370 {
1371   struct elf_s390_link_hash_table *htab;
1372   bfd *dynobj;
1373   asection *s;
1374   boolean relocs;
1375   bfd *ibfd;
1376
1377   htab = elf_s390_hash_table (info);
1378   dynobj = htab->elf.dynobj;
1379   if (dynobj == NULL)
1380     abort ();
1381
1382   if (htab->elf.dynamic_sections_created)
1383     {
1384       /* Set the contents of the .interp section to the interpreter.  */
1385       if (! info->shared)
1386         {
1387           s = bfd_get_section_by_name (dynobj, ".interp");
1388           if (s == NULL)
1389             abort ();
1390           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1391           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1392         }
1393     }
1394
1395   /* Set up .got offsets for local syms, and space for local dynamic
1396      relocs.  */
1397   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1398     {
1399       bfd_signed_vma *local_got;
1400       bfd_signed_vma *end_local_got;
1401       bfd_size_type locsymcount;
1402       Elf_Internal_Shdr *symtab_hdr;
1403       asection *srela;
1404
1405       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1406         continue;
1407
1408       for (s = ibfd->sections; s != NULL; s = s->next)
1409         {
1410           struct elf_s390_dyn_relocs *p;
1411
1412           for (p = *((struct elf_s390_dyn_relocs **)
1413                      &elf_section_data (s)->local_dynrel);
1414                p != NULL;
1415                p = p->next)
1416             {
1417               if (!bfd_is_abs_section (p->sec)
1418                   && bfd_is_abs_section (p->sec->output_section))
1419                 {
1420                   /* Input section has been discarded, either because
1421                      it is a copy of a linkonce section or due to
1422                      linker script /DISCARD/, so we'll be discarding
1423                      the relocs too.  */
1424                 }
1425               else
1426                 {
1427                   srela = elf_section_data (p->sec)->sreloc;
1428                   srela->_raw_size += p->count * sizeof (Elf64_External_Rela);
1429                 }
1430             }
1431         }
1432
1433       local_got = elf_local_got_refcounts (ibfd);
1434       if (!local_got)
1435         continue;
1436
1437       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1438       locsymcount = symtab_hdr->sh_info;
1439       end_local_got = local_got + locsymcount;
1440       s = htab->sgot;
1441       srela = htab->srelgot;
1442       for (; local_got < end_local_got; ++local_got)
1443         {
1444           if (*local_got > 0)
1445             {
1446               *local_got = s->_raw_size;
1447               s->_raw_size += GOT_ENTRY_SIZE;
1448               if (info->shared)
1449                 srela->_raw_size += sizeof (Elf64_External_Rela);
1450             }
1451           else
1452             *local_got = (bfd_vma) -1;
1453         }
1454     }
1455
1456   /* Allocate global sym .plt and .got entries, and space for global
1457      sym dynamic relocs.  */
1458   elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
1459
1460   /* We now have determined the sizes of the various dynamic sections.
1461      Allocate memory for them.  */
1462   relocs = false;
1463   for (s = dynobj->sections; s != NULL; s = s->next)
1464     {
1465       if ((s->flags & SEC_LINKER_CREATED) == 0)
1466         continue;
1467
1468       if (s == htab->splt
1469           || s == htab->sgot
1470           || s == htab->sgotplt)
1471         {
1472           /* Strip this section if we don't need it; see the
1473              comment below.  */
1474         }
1475       else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
1476         {
1477           if (s->_raw_size != 0 && s != htab->srelplt)
1478             relocs = true;
1479
1480           /* We use the reloc_count field as a counter if we need
1481              to copy relocs into the output file.  */
1482           s->reloc_count = 0;
1483         }
1484       else
1485         {
1486           /* It's not one of our sections, so don't allocate space.  */
1487           continue;
1488         }
1489
1490       if (s->_raw_size == 0)
1491         {
1492           /* If we don't need this section, strip it from the
1493              output file.  This is to handle .rela.bss and
1494              .rela.plt.  We must create it in
1495              create_dynamic_sections, because it must be created
1496              before the linker maps input sections to output
1497              sections.  The linker does that before
1498              adjust_dynamic_symbol is called, and it is that
1499              function which decides whether anything needs to go
1500              into these sections.  */
1501
1502           _bfd_strip_section_from_output (info, s);
1503           continue;
1504         }
1505
1506       /* Allocate memory for the section contents.  We use bfd_zalloc
1507          here in case unused entries are not reclaimed before the
1508          section's contents are written out.  This should not happen,
1509          but this way if it does, we get a R_390_NONE reloc instead
1510          of garbage.  */
1511       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
1512       if (s->contents == NULL)
1513         return false;
1514     }
1515
1516   if (htab->elf.dynamic_sections_created)
1517     {
1518       /* Add some entries to the .dynamic section.  We fill in the
1519          values later, in elf_s390_finish_dynamic_sections, but we
1520          must add the entries now so that we get the correct size for
1521          the .dynamic section.  The DT_DEBUG entry is filled in by the
1522          dynamic linker and used by the debugger.  */
1523 #define add_dynamic_entry(TAG, VAL) \
1524   bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1525
1526       if (! info->shared)
1527         {
1528           if (!add_dynamic_entry (DT_DEBUG, 0))
1529             return false;
1530         }
1531
1532       if (htab->splt->_raw_size != 0)
1533         {
1534           if (!add_dynamic_entry (DT_PLTGOT, 0)
1535               || !add_dynamic_entry (DT_PLTRELSZ, 0)
1536               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1537               || !add_dynamic_entry (DT_JMPREL, 0))
1538             return false;
1539         }
1540
1541       if (relocs)
1542         {
1543           if (!add_dynamic_entry (DT_RELA, 0)
1544               || !add_dynamic_entry (DT_RELASZ, 0)
1545               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
1546             return false;
1547
1548           /* If any dynamic relocs apply to a read-only section,
1549              then we need a DT_TEXTREL entry.  */
1550           elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, (PTR) info);
1551
1552           if ((info->flags & DF_TEXTREL) != 0)
1553             {
1554               if (!add_dynamic_entry (DT_TEXTREL, 0))
1555                 return false;
1556             }
1557         }
1558     }
1559 #undef add_dynamic_entry
1560
1561   return true;
1562 }
1563
1564 /* Relocate a 390 ELF section.  */
1565
1566 static boolean
1567 elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
1568                               contents, relocs, local_syms, local_sections)
1569      bfd *output_bfd;
1570      struct bfd_link_info *info;
1571      bfd *input_bfd;
1572      asection *input_section;
1573      bfd_byte *contents;
1574      Elf_Internal_Rela *relocs;
1575      Elf_Internal_Sym *local_syms;
1576      asection **local_sections;
1577 {
1578   struct elf_s390_link_hash_table *htab;
1579   Elf_Internal_Shdr *symtab_hdr;
1580   struct elf_link_hash_entry **sym_hashes;
1581   bfd_vma *local_got_offsets;
1582   Elf_Internal_Rela *rel;
1583   Elf_Internal_Rela *relend;
1584
1585   htab = elf_s390_hash_table (info);
1586   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1587   sym_hashes = elf_sym_hashes (input_bfd);
1588   local_got_offsets = elf_local_got_offsets (input_bfd);
1589
1590   rel = relocs;
1591   relend = relocs + input_section->reloc_count;
1592   for (; rel < relend; rel++)
1593     {
1594       int r_type;
1595       reloc_howto_type *howto;
1596       unsigned long r_symndx;
1597       struct elf_link_hash_entry *h;
1598       Elf_Internal_Sym *sym;
1599       asection *sec;
1600       bfd_vma off;
1601       bfd_vma relocation;
1602       boolean unresolved_reloc;
1603       bfd_reloc_status_type r;
1604
1605       r_type = ELF64_R_TYPE (rel->r_info);
1606       if (r_type == (int) R_390_GNU_VTINHERIT
1607           || r_type == (int) R_390_GNU_VTENTRY)
1608         continue;
1609       if (r_type < 0 || r_type >= (int) R_390_max)
1610         {
1611           bfd_set_error (bfd_error_bad_value);
1612           return false;
1613         }
1614       howto = elf_howto_table + r_type;
1615
1616       r_symndx = ELF64_R_SYM (rel->r_info);
1617
1618       if (info->relocateable)
1619         {
1620           /* This is a relocateable link.  We don't have to change
1621              anything, unless the reloc is against a section symbol,
1622              in which case we have to adjust according to where the
1623              section symbol winds up in the output section.  */
1624           if (r_symndx < symtab_hdr->sh_info)
1625             {
1626               sym = local_syms + r_symndx;
1627               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1628                 {
1629                   sec = local_sections[r_symndx];
1630                   rel->r_addend += sec->output_offset + sym->st_value;
1631                 }
1632             }
1633
1634           continue;
1635         }
1636
1637       /* This is a final link.  */
1638       h = NULL;
1639       sym = NULL;
1640       sec = NULL;
1641       unresolved_reloc = false;
1642       if (r_symndx < symtab_hdr->sh_info)
1643         {
1644           sym = local_syms + r_symndx;
1645           sec = local_sections[r_symndx];
1646           relocation = (sec->output_section->vma
1647                         + sec->output_offset
1648                         + sym->st_value);
1649         }
1650       else
1651         {
1652           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1653           while (h->root.type == bfd_link_hash_indirect
1654                  || h->root.type == bfd_link_hash_warning)
1655             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1656
1657           if (h->root.type == bfd_link_hash_defined
1658               || h->root.type == bfd_link_hash_defweak)
1659             {
1660               sec = h->root.u.def.section;
1661               if (r_type == R_390_GOTPC
1662                   || r_type == R_390_GOTPCDBL
1663                   || ((r_type == R_390_PLT16DBL
1664                        || r_type == R_390_PLT32
1665                        || r_type == R_390_PLT32DBL
1666                        || r_type == R_390_PLT64)
1667                       && htab->splt != NULL
1668                       && h->plt.offset != (bfd_vma) -1)
1669                   || ((r_type == R_390_GOT12
1670                        || r_type == R_390_GOT16
1671                        || r_type == R_390_GOT32
1672                        || r_type == R_390_GOT64
1673                        || r_type == R_390_GOTENT)
1674                       && elf_hash_table (info)->dynamic_sections_created
1675                       && (! info->shared
1676                           || (! info->symbolic && h->dynindx != -1)
1677                           || (h->elf_link_hash_flags
1678                               & ELF_LINK_HASH_DEF_REGULAR) == 0))
1679                   || (info->shared
1680                       && ((! info->symbolic && h->dynindx != -1)
1681                           || (h->elf_link_hash_flags
1682                               & ELF_LINK_HASH_DEF_REGULAR) == 0)
1683                       && (r_type == R_390_8
1684                           || r_type == R_390_16
1685                           || r_type == R_390_32
1686                           || r_type == R_390_64
1687                           || r_type == R_390_PC16
1688                           || r_type == R_390_PC16DBL
1689                           || r_type == R_390_PC32
1690                           || r_type == R_390_PC32DBL
1691                           || r_type == R_390_PC64)
1692                       && ((input_section->flags & SEC_ALLOC) != 0
1693                           /* DWARF will emit R_390_32 relocations in its
1694                              sections against symbols defined externally
1695                              in shared libraries.  We can't do anything
1696                              with them here.  */
1697                           || ((input_section->flags & SEC_DEBUGGING) != 0
1698                               && (h->elf_link_hash_flags
1699                                   & ELF_LINK_HASH_DEF_DYNAMIC) != 0))))
1700                 {
1701                   /* In these cases, we don't need the relocation
1702                      value.  We check specially because in some
1703                      obscure cases sec->output_section will be NULL.  */
1704                   relocation = 0;
1705                 }
1706               else if (sec->output_section == NULL)
1707                 {
1708                   /* Set a flag that will be cleared later if we find a
1709                      relocation value for this symbol.  output_section
1710                      is typically NULL for symbols satisfied by a shared
1711                      library.  */
1712                   unresolved_reloc = true;
1713                   relocation = 0;
1714                 }
1715               else
1716                 relocation = (h->root.u.def.value
1717                               + sec->output_section->vma
1718                               + sec->output_offset);
1719             }
1720           else if (h->root.type == bfd_link_hash_undefweak)
1721             relocation = 0;
1722           else if (info->shared
1723                    && (!info->symbolic || info->allow_shlib_undefined)
1724                    && !info->no_undefined
1725                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1726             relocation = 0;
1727           else
1728             {
1729               if (! ((*info->callbacks->undefined_symbol)
1730                      (info, h->root.root.string, input_bfd,
1731                       input_section, rel->r_offset,
1732                       (!info->shared || info->no_undefined
1733                        || ELF_ST_VISIBILITY (h->other)))))
1734                 return false;
1735               relocation = 0;
1736             }
1737         }
1738
1739       switch (r_type)
1740         {
1741         case R_390_GOT12:
1742         case R_390_GOT16:
1743         case R_390_GOT32:
1744         case R_390_GOT64:
1745         case R_390_GOTENT:
1746           /* Relocation is to the entry for this symbol in the global
1747              offset table.  */
1748           if (htab->sgot == NULL)
1749             abort ();
1750
1751           if (h != NULL)
1752             {
1753               boolean dyn;
1754
1755               off = h->got.offset;
1756               dyn = htab->elf.dynamic_sections_created;
1757               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
1758                   || (info->shared
1759                       && (info->symbolic
1760                           || h->dynindx == -1
1761                           || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
1762                       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1763                 {
1764                   /* This is actually a static link, or it is a
1765                      -Bsymbolic link and the symbol is defined
1766                      locally, or the symbol was forced to be local
1767                      because of a version file.  We must initialize
1768                      this entry in the global offset table.  Since the
1769                      offset must always be a multiple of 2, we use the
1770                      least significant bit to record whether we have
1771                      initialized it already.
1772
1773                      When doing a dynamic link, we create a .rel.got
1774                      relocation entry to initialize the value.  This
1775                      is done in the finish_dynamic_symbol routine.  */
1776                   if ((off & 1) != 0)
1777                     off &= ~1;
1778                   else
1779                     {
1780                       bfd_put_64 (output_bfd, relocation,
1781                                   htab->sgot->contents + off);
1782                       h->got.offset |= 1;
1783                     }
1784                 }
1785               else
1786                 unresolved_reloc = false;
1787             }
1788           else
1789             {
1790               if (local_got_offsets == NULL)
1791                 abort ();
1792
1793               off = local_got_offsets[r_symndx];
1794
1795               /* The offset must always be a multiple of 8.  We use
1796                  the least significant bit to record whether we have
1797                  already generated the necessary reloc.  */
1798               if ((off & 1) != 0)
1799                 off &= ~1;
1800               else
1801                 {
1802                   bfd_put_64 (output_bfd, relocation,
1803                               htab->sgot->contents + off);
1804
1805                   if (info->shared)
1806                     {
1807                       asection *srelgot;
1808                       Elf_Internal_Rela outrel;
1809                       Elf64_External_Rela *loc;
1810
1811                       srelgot = htab->srelgot;
1812                       if (srelgot == NULL)
1813                         abort ();
1814
1815                       outrel.r_offset = (htab->sgot->output_section->vma
1816                                          + htab->sgot->output_offset
1817                                          + off);
1818                       outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
1819                       outrel.r_addend = relocation;
1820                       loc = (Elf64_External_Rela *) srelgot->contents;
1821                       loc += srelgot->reloc_count++;
1822                       bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
1823                     }
1824
1825                   local_got_offsets[r_symndx] |= 1;
1826                 }
1827             }
1828
1829           if (off >= (bfd_vma) -2)
1830             abort ();
1831
1832           relocation = htab->sgot->output_offset + off;
1833
1834           /*
1835            * For @GOTENT the relocation is against the offset between
1836            * the instruction and the symbols entry in the GOT and not
1837            * between the start of the GOT and the symbols entry. We
1838            * add the vma of the GOT to get the correct value.
1839            */
1840           if (r_type == R_390_GOTENT)
1841             relocation += htab->sgot->output_section->vma;
1842
1843           break;
1844
1845         case R_390_GOTOFF:
1846           /* Relocation is relative to the start of the global offset
1847              table.  */
1848
1849           /* Note that sgot->output_offset is not involved in this
1850              calculation.  We always want the start of .got.  If we
1851              defined _GLOBAL_OFFSET_TABLE in a different way, as is
1852              permitted by the ABI, we might have to change this
1853              calculation.  */
1854           relocation -= htab->sgot->output_section->vma;
1855
1856           break;
1857
1858         case R_390_GOTPC:
1859         case R_390_GOTPCDBL:
1860           /* Use global offset table as symbol value.  */
1861           relocation = htab->sgot->output_section->vma;
1862           unresolved_reloc = false;
1863          break;
1864
1865         case R_390_PLT16DBL:
1866         case R_390_PLT32:
1867         case R_390_PLT32DBL:
1868         case R_390_PLT64:
1869           /* Relocation is to the entry for this symbol in the
1870              procedure linkage table.  */
1871
1872           /* Resolve a PLT32 reloc against a local symbol directly,
1873              without using the procedure linkage table.  */
1874           if (h == NULL)
1875             break;
1876
1877           if (h->plt.offset == (bfd_vma) -1
1878               || htab->splt == NULL)
1879             {
1880               /* We didn't make a PLT entry for this symbol.  This
1881                  happens when statically linking PIC code, or when
1882                  using -Bsymbolic.  */
1883               break;
1884             }
1885
1886           relocation = (htab->splt->output_section->vma
1887                         + htab->splt->output_offset
1888                         + h->plt.offset);
1889           unresolved_reloc = false;
1890           break;
1891
1892         case R_390_8:
1893         case R_390_16:
1894         case R_390_32:
1895         case R_390_64:
1896         case R_390_PC16:
1897         case R_390_PC16DBL:
1898         case R_390_PC32:
1899         case R_390_PC32DBL:
1900         case R_390_PC64:
1901           /* r_symndx will be zero only for relocs against symbols
1902              from removed linkonce sections, or sections discarded by
1903              a linker script.  */
1904           if (r_symndx == 0
1905               || (input_section->flags & SEC_ALLOC) == 0)
1906             break;
1907
1908           if ((info->shared
1909                && ((r_type != R_390_PC16
1910                     && r_type != R_390_PC16DBL
1911                     && r_type != R_390_PC32
1912                     && r_type != R_390_PC32DBL
1913                     && r_type != R_390_PC64)
1914                    || (h != NULL
1915                        && h->dynindx != -1
1916                        && (! info->symbolic
1917                            || (h->elf_link_hash_flags
1918                                & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1919               || (!info->shared
1920                   && h != NULL
1921                   && h->dynindx != -1
1922                   && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1923                   && (((h->elf_link_hash_flags
1924                         & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1925                        && (h->elf_link_hash_flags
1926                            & ELF_LINK_HASH_DEF_REGULAR) == 0)
1927                       || h->root.type == bfd_link_hash_undefweak
1928                       || h->root.type == bfd_link_hash_undefined)))
1929             {
1930               Elf_Internal_Rela outrel;
1931               boolean skip, relocate;
1932               asection *sreloc;
1933               Elf64_External_Rela *loc;
1934
1935               /* When generating a shared object, these relocations
1936                  are copied into the output file to be resolved at run
1937                  time.  */
1938
1939               skip = false;
1940
1941               if (elf_section_data (input_section)->stab_info == NULL)
1942                 outrel.r_offset = rel->r_offset;
1943               else
1944                 {
1945                   off = (_bfd_stab_section_offset
1946                          (output_bfd, htab->elf.stab_info, input_section,
1947                           &elf_section_data (input_section)->stab_info,
1948                           rel->r_offset));
1949                   if (off == (bfd_vma) -1)
1950                     skip = true;
1951                   outrel.r_offset = off;
1952                 }
1953
1954               outrel.r_offset += (input_section->output_section->vma
1955                                   + input_section->output_offset);
1956
1957               if (skip)
1958                 {
1959                   memset (&outrel, 0, sizeof outrel);
1960                   relocate = false;
1961                 }
1962               else if (h != NULL
1963                        && h->dynindx != -1
1964                        && (r_type == R_390_PC16
1965                            || r_type == R_390_PC16DBL
1966                            || r_type == R_390_PC32
1967                            || r_type == R_390_PC32DBL
1968                            || r_type == R_390_PC64
1969                            || !info->shared
1970                            || !info->symbolic
1971                            || (h->elf_link_hash_flags
1972                                & ELF_LINK_HASH_DEF_REGULAR) == 0))
1973                 {
1974                   relocate = false;
1975                   outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
1976                   outrel.r_addend = relocation + rel->r_addend;
1977                 }
1978               else
1979                 {
1980                   /* This symbol is local, or marked to become local.  */
1981                   relocate = true;
1982                   outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
1983                   outrel.r_addend = relocation + rel->r_addend;
1984                 }
1985
1986               sreloc = elf_section_data (input_section)->sreloc;
1987               if (sreloc == NULL)
1988                 abort ();
1989
1990               loc = (Elf64_External_Rela *) sreloc->contents;
1991               loc += sreloc->reloc_count++;
1992               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
1993
1994               /* If this reloc is against an external symbol, we do
1995                  not want to fiddle with the addend.  Otherwise, we
1996                  need to include the symbol value so that it becomes
1997                  an addend for the dynamic reloc.  */
1998               if (! relocate)
1999                 continue;
2000             }
2001
2002           break;
2003
2004         default:
2005           break;
2006         }
2007
2008       if (unresolved_reloc
2009           && !(info->shared
2010                && (input_section->flags & SEC_DEBUGGING) != 0
2011                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
2012         (*_bfd_error_handler)
2013           (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2014            bfd_archive_filename (input_bfd),
2015            bfd_get_section_name (input_bfd, input_section),
2016            (long) rel->r_offset,
2017            h->root.root.string);
2018
2019       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2020                                       contents, rel->r_offset,
2021                                       relocation, rel->r_addend);
2022
2023       if (r != bfd_reloc_ok)
2024         {
2025           const char *name;
2026
2027           if (h != NULL)
2028             name = h->root.root.string;
2029           else
2030             {
2031               name = bfd_elf_string_from_elf_section (input_bfd,
2032                                                       symtab_hdr->sh_link,
2033                                                       sym->st_name);
2034               if (name == NULL)
2035                 return false;
2036               if (*name == '\0')
2037                 name = bfd_section_name (input_bfd, sec);
2038             }
2039
2040           if (r == bfd_reloc_overflow)
2041             {
2042
2043               if (! ((*info->callbacks->reloc_overflow)
2044                      (info, name, howto->name, (bfd_vma) 0,
2045                       input_bfd, input_section, rel->r_offset)))
2046                 return false;
2047             }
2048           else
2049             {
2050               (*_bfd_error_handler)
2051                 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
2052                  bfd_archive_filename (input_bfd),
2053                  bfd_get_section_name (input_bfd, input_section),
2054                  (long) rel->r_offset, name, (int) r);
2055               return false;
2056             }
2057         }
2058     }
2059
2060   return true;
2061 }
2062
2063 /* Finish up dynamic symbol handling.  We set the contents of various
2064    dynamic sections here.  */
2065
2066 static boolean
2067 elf_s390_finish_dynamic_symbol (output_bfd, info, h, sym)
2068      bfd *output_bfd;
2069      struct bfd_link_info *info;
2070      struct elf_link_hash_entry *h;
2071      Elf_Internal_Sym *sym;
2072 {
2073   struct elf_s390_link_hash_table *htab;
2074
2075   htab = elf_s390_hash_table (info);
2076
2077   if (h->plt.offset != (bfd_vma) -1)
2078     {
2079       bfd_vma plt_index;
2080       bfd_vma got_offset;
2081       Elf_Internal_Rela rela;
2082       Elf64_External_Rela *loc;
2083
2084       /* This symbol has an entry in the procedure linkage table.  Set
2085          it up.  */
2086
2087       if (h->dynindx == -1
2088           || htab->splt == NULL
2089           || htab->sgotplt == NULL
2090           || htab->srelplt == NULL)
2091         abort ();
2092
2093       /* Calc. index no.
2094          Current offset - size first entry / entry size.  */
2095       plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) / PLT_ENTRY_SIZE;
2096
2097       /* Offset in GOT is PLT index plus GOT headers(3) times 8,
2098          addr & GOT addr.  */
2099       got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
2100
2101       /* Fill in the blueprint of a PLT.  */
2102       bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD0,
2103                   htab->splt->contents + h->plt.offset);
2104       bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD1,
2105                   htab->splt->contents + h->plt.offset + 4);
2106       bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD2,
2107                   htab->splt->contents + h->plt.offset + 8);
2108       bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD3,
2109                   htab->splt->contents + h->plt.offset + 12);
2110       bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD4,
2111                   htab->splt->contents + h->plt.offset + 16);
2112       bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD5,
2113                   htab->splt->contents + h->plt.offset + 20);
2114       bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD6,
2115                   htab->splt->contents + h->plt.offset + 24);
2116       bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD7,
2117                   htab->splt->contents + h->plt.offset + 28);
2118       /* Fixup the relative address to the GOT entry */
2119       bfd_put_32 (output_bfd,
2120                   (htab->sgotplt->output_section->vma +
2121                    htab->sgotplt->output_offset + got_offset
2122                    - (htab->splt->output_section->vma + h->plt.offset))/2,
2123                   htab->splt->contents + h->plt.offset + 2);
2124       /* Fixup the relative branch to PLT 0 */
2125       bfd_put_32 (output_bfd, - (PLT_FIRST_ENTRY_SIZE +
2126                                  (PLT_ENTRY_SIZE * plt_index) + 22)/2,
2127                   htab->splt->contents + h->plt.offset + 24);
2128       /* Fixup offset into symbol table */
2129       bfd_put_32 (output_bfd, plt_index * sizeof (Elf64_External_Rela),
2130                   htab->splt->contents + h->plt.offset + 28);
2131
2132       /* Fill in the entry in the global offset table.
2133          Points to instruction after GOT offset.  */
2134       bfd_put_64 (output_bfd,
2135                   (htab->splt->output_section->vma
2136                    + htab->splt->output_offset
2137                    + h->plt.offset
2138                    + 14),
2139                   htab->sgotplt->contents + got_offset);
2140
2141       /* Fill in the entry in the .rela.plt section.  */
2142       rela.r_offset = (htab->sgotplt->output_section->vma
2143                        + htab->sgotplt->output_offset
2144                        + got_offset);
2145       rela.r_info = ELF64_R_INFO (h->dynindx, R_390_JMP_SLOT);
2146       rela.r_addend = 0;
2147       loc = (Elf64_External_Rela *) htab->srelplt->contents + plt_index;
2148       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
2149
2150       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2151         {
2152           /* Mark the symbol as undefined, rather than as defined in
2153              the .plt section.  Leave the value alone.  This is a clue
2154              for the dynamic linker, to make function pointer
2155              comparisons work between an application and shared
2156              library.  */
2157           sym->st_shndx = SHN_UNDEF;
2158         }
2159     }
2160
2161   if (h->got.offset != (bfd_vma) -1)
2162     {
2163       Elf_Internal_Rela rela;
2164       Elf64_External_Rela *loc;
2165
2166       /* This symbol has an entry in the global offset table.  Set it
2167          up.  */
2168
2169       if (htab->sgot == NULL || htab->srelgot == NULL)
2170         abort ();
2171
2172       rela.r_offset = (htab->sgot->output_section->vma
2173                        + htab->sgot->output_offset
2174                        + (h->got.offset &~ (bfd_vma) 1));
2175
2176       /* If this is a static link, or it is a -Bsymbolic link and the
2177          symbol is defined locally or was forced to be local because
2178          of a version file, we just want to emit a RELATIVE reloc.
2179          The entry in the global offset table will already have been
2180          initialized in the relocate_section function.  */
2181       if (info->shared
2182           && (info->symbolic
2183               || h->dynindx == -1
2184               || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2185           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2186         {
2187           BFD_ASSERT((h->got.offset & 1) != 0);
2188           rela.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2189           rela.r_addend = (h->root.u.def.value
2190                            + h->root.u.def.section->output_section->vma
2191                            + h->root.u.def.section->output_offset);
2192         }
2193       else
2194         {
2195           BFD_ASSERT((h->got.offset & 1) == 0);
2196           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgot->contents + h->got.offset);
2197           rela.r_info = ELF64_R_INFO (h->dynindx, R_390_GLOB_DAT);
2198           rela.r_addend = 0;
2199         }
2200
2201       loc = (Elf64_External_Rela *) htab->srelgot->contents;
2202       loc += htab->srelgot->reloc_count++;
2203       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
2204     }
2205
2206   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2207     {
2208       Elf_Internal_Rela rela;
2209       Elf64_External_Rela *loc;
2210
2211       /* This symbols needs a copy reloc.  Set it up.  */
2212
2213       if (h->dynindx == -1
2214           || (h->root.type != bfd_link_hash_defined
2215               && h->root.type != bfd_link_hash_defweak)
2216           || htab->srelbss == NULL)
2217         abort ();
2218
2219       rela.r_offset = (h->root.u.def.value
2220                        + h->root.u.def.section->output_section->vma
2221                        + h->root.u.def.section->output_offset);
2222       rela.r_info = ELF64_R_INFO (h->dynindx, R_390_COPY);
2223       rela.r_addend = 0;
2224       loc = (Elf64_External_Rela *) htab->srelbss->contents;
2225       loc += htab->srelbss->reloc_count++;
2226       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
2227     }
2228
2229   /* Mark some specially defined symbols as absolute.  */
2230   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2231       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
2232       || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
2233     sym->st_shndx = SHN_ABS;
2234
2235   return true;
2236 }
2237
2238 /* Used to decide how to sort relocs in an optimal manner for the
2239    dynamic linker, before writing them out.  */
2240
2241 static enum elf_reloc_type_class
2242 elf_s390_reloc_type_class (rela)
2243      const Elf_Internal_Rela *rela;
2244 {
2245   switch ((int) ELF64_R_TYPE (rela->r_info))
2246     {
2247     case R_390_RELATIVE:
2248       return reloc_class_relative;
2249     case R_390_JMP_SLOT:
2250       return reloc_class_plt;
2251     case R_390_COPY:
2252       return reloc_class_copy;
2253     default:
2254       return reloc_class_normal;
2255     }
2256 }
2257
2258 /* Finish up the dynamic sections.  */
2259
2260 static boolean
2261 elf_s390_finish_dynamic_sections (output_bfd, info)
2262      bfd *output_bfd;
2263      struct bfd_link_info *info;
2264 {
2265   struct elf_s390_link_hash_table *htab;
2266   bfd *dynobj;
2267   asection *sdyn;
2268
2269   htab = elf_s390_hash_table (info);
2270   dynobj = htab->elf.dynobj;
2271   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2272
2273   if (htab->elf.dynamic_sections_created)
2274     {
2275       Elf64_External_Dyn *dyncon, *dynconend;
2276
2277       if (sdyn == NULL || htab->sgot == NULL)
2278         abort ();
2279
2280       dyncon = (Elf64_External_Dyn *) sdyn->contents;
2281       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2282       for (; dyncon < dynconend; dyncon++)
2283         {
2284           Elf_Internal_Dyn dyn;
2285           asection *s;
2286
2287           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
2288
2289           switch (dyn.d_tag)
2290             {
2291             default:
2292               continue;
2293
2294             case DT_PLTGOT:
2295               dyn.d_un.d_ptr = htab->sgot->output_section->vma;
2296               break;
2297
2298             case DT_JMPREL:
2299               dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
2300               break;
2301
2302             case DT_PLTRELSZ:
2303               s = htab->srelplt->output_section;
2304               if (s->_cooked_size != 0)
2305                 dyn.d_un.d_val = s->_cooked_size;
2306               else
2307                 dyn.d_un.d_val = s->_raw_size;
2308               break;
2309
2310             case DT_RELASZ:
2311               /* The procedure linkage table relocs (DT_JMPREL) should
2312                  not be included in the overall relocs (DT_RELA).
2313                  Therefore, we override the DT_RELASZ entry here to
2314                  make it not include the JMPREL relocs.  Since the
2315                  linker script arranges for .rela.plt to follow all
2316                  other relocation sections, we don't have to worry
2317                  about changing the DT_RELA entry.  */
2318               s = htab->srelplt->output_section;
2319               if (s->_cooked_size != 0)
2320                 dyn.d_un.d_val -= s->_cooked_size;
2321               else
2322                 dyn.d_un.d_val -= s->_raw_size;
2323               break;
2324             }
2325
2326           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2327         }
2328
2329       /* Fill in the special first entry in the procedure linkage table.  */
2330       if (htab->splt && htab->splt->_raw_size > 0)
2331         {
2332           /* fill in blueprint for plt 0 entry */
2333           bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD0,
2334                       htab->splt->contents );
2335           bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD1,
2336                       htab->splt->contents +4 );
2337           bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD3,
2338                       htab->splt->contents +12 );
2339           bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD4,
2340                       htab->splt->contents +16 );
2341           bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD5,
2342                       htab->splt->contents +20 );
2343           bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD6,
2344                       htab->splt->contents + 24);
2345           bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD7,
2346                       htab->splt->contents + 28 );
2347           /* Fixup relative address to start of GOT */
2348           bfd_put_32 (output_bfd,
2349                       (htab->sgotplt->output_section->vma +
2350                        htab->sgotplt->output_offset
2351                        - htab->splt->output_section->vma - 6)/2,
2352                       htab->splt->contents + 8);
2353         }
2354       elf_section_data (htab->splt->output_section)
2355         ->this_hdr.sh_entsize = PLT_ENTRY_SIZE;
2356     }
2357
2358   if (htab->sgotplt)
2359     {
2360       /* Fill in the first three entries in the global offset table.  */
2361       if (htab->sgotplt->_raw_size > 0)
2362         {
2363           bfd_put_64 (output_bfd,
2364                       (sdyn == NULL ? (bfd_vma) 0
2365                        : sdyn->output_section->vma + sdyn->output_offset),
2366                       htab->sgotplt->contents);
2367           /* One entry for shared object struct ptr.  */
2368           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
2369           /* One entry for _dl_runtime_resolve.  */
2370           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 12);
2371         }
2372
2373       elf_section_data (htab->sgot->output_section)
2374         ->this_hdr.sh_entsize = 8;
2375     }
2376   return true;
2377 }
2378
2379 static boolean
2380 elf_s390_object_p (abfd)
2381      bfd *abfd;
2382 {
2383   return bfd_default_set_arch_mach (abfd, bfd_arch_s390, bfd_mach_s390_esame);
2384 }
2385
2386 /*
2387  * Why was the hash table entry size definition changed from
2388  * ARCH_SIZE/8 to 4? This breaks the 64 bit dynamic linker and
2389  * this is the only reason for the s390_elf64_size_info structure.
2390  */
2391
2392 const struct elf_size_info s390_elf64_size_info =
2393 {
2394   sizeof (Elf64_External_Ehdr),
2395   sizeof (Elf64_External_Phdr),
2396   sizeof (Elf64_External_Shdr),
2397   sizeof (Elf64_External_Rel),
2398   sizeof (Elf64_External_Rela),
2399   sizeof (Elf64_External_Sym),
2400   sizeof (Elf64_External_Dyn),
2401   sizeof (Elf_External_Note),
2402   8,            /* hash-table entry size */
2403   1,            /* internal relocations per external relocations */
2404   64,           /* arch_size */
2405   8,            /* file_align */
2406   ELFCLASS64, EV_CURRENT,
2407   bfd_elf64_write_out_phdrs,
2408   bfd_elf64_write_shdrs_and_ehdr,
2409   bfd_elf64_write_relocs,
2410   bfd_elf64_swap_symbol_out,
2411   bfd_elf64_slurp_reloc_table,
2412   bfd_elf64_slurp_symbol_table,
2413   bfd_elf64_swap_dyn_in,
2414   bfd_elf64_swap_dyn_out,
2415   NULL,
2416   NULL,
2417   NULL,
2418   NULL
2419 };
2420
2421 #define TARGET_BIG_SYM  bfd_elf64_s390_vec
2422 #define TARGET_BIG_NAME "elf64-s390"
2423 #define ELF_ARCH        bfd_arch_s390
2424 #define ELF_MACHINE_CODE EM_S390
2425 #define ELF_MACHINE_ALT1 EM_S390_OLD
2426 #define ELF_MAXPAGESIZE 0x1000
2427
2428 #define elf_backend_size_info           s390_elf64_size_info
2429
2430 #define elf_backend_can_gc_sections     1
2431 #define elf_backend_can_refcount        1
2432 #define elf_backend_want_got_plt        1
2433 #define elf_backend_plt_readonly        1
2434 #define elf_backend_want_plt_sym        0
2435 #define elf_backend_got_header_size     24
2436 #define elf_backend_plt_header_size     PLT_ENTRY_SIZE
2437
2438 #define elf_info_to_howto               elf_s390_info_to_howto
2439
2440 #define bfd_elf64_bfd_is_local_label_name     elf_s390_is_local_label_name
2441 #define bfd_elf64_bfd_link_hash_table_create  elf_s390_link_hash_table_create
2442 #define bfd_elf64_bfd_reloc_type_lookup       elf_s390_reloc_type_lookup
2443
2444 #define elf_backend_adjust_dynamic_symbol     elf_s390_adjust_dynamic_symbol
2445 #define elf_backend_check_relocs              elf_s390_check_relocs
2446 #define elf_backend_copy_indirect_symbol      elf_s390_copy_indirect_symbol
2447 #define elf_backend_create_dynamic_sections   elf_s390_create_dynamic_sections
2448 #define elf_backend_finish_dynamic_sections   elf_s390_finish_dynamic_sections
2449 #define elf_backend_finish_dynamic_symbol     elf_s390_finish_dynamic_symbol
2450 #define elf_backend_gc_mark_hook              elf_s390_gc_mark_hook
2451 #define elf_backend_gc_sweep_hook             elf_s390_gc_sweep_hook
2452 #define elf_backend_reloc_type_class          elf_s390_reloc_type_class
2453 #define elf_backend_relocate_section          elf_s390_relocate_section
2454 #define elf_backend_size_dynamic_sections     elf_s390_size_dynamic_sections
2455 #define elf_backend_reloc_type_class          elf_s390_reloc_type_class
2456
2457 #define elf_backend_object_p                  elf_s390_object_p
2458
2459 #include "elf64-target.h"