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 (sec->output_section == NULL)
1662                 {
1663                   /* Set a flag that will be cleared later if we find a
1664                      relocation value for this symbol.  output_section
1665                      is typically NULL for symbols satisfied by a shared
1666                      library.  */
1667                   unresolved_reloc = true;
1668                   relocation = 0;
1669                 }
1670               else
1671                 relocation = (h->root.u.def.value
1672                               + sec->output_section->vma
1673                               + sec->output_offset);
1674             }
1675           else if (h->root.type == bfd_link_hash_undefweak)
1676             relocation = 0;
1677           else if (info->shared
1678                    && (!info->symbolic || info->allow_shlib_undefined)
1679                    && !info->no_undefined
1680                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1681             relocation = 0;
1682           else
1683             {
1684               if (! ((*info->callbacks->undefined_symbol)
1685                      (info, h->root.root.string, input_bfd,
1686                       input_section, rel->r_offset,
1687                       (!info->shared || info->no_undefined
1688                        || ELF_ST_VISIBILITY (h->other)))))
1689                 return false;
1690               relocation = 0;
1691             }
1692         }
1693
1694       switch (r_type)
1695         {
1696         case R_390_GOT12:
1697         case R_390_GOT16:
1698         case R_390_GOT32:
1699         case R_390_GOT64:
1700         case R_390_GOTENT:
1701           /* Relocation is to the entry for this symbol in the global
1702              offset table.  */
1703           if (htab->sgot == NULL)
1704             abort ();
1705
1706           if (h != NULL)
1707             {
1708               boolean dyn;
1709
1710               off = h->got.offset;
1711               dyn = htab->elf.dynamic_sections_created;
1712               if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
1713                   || (info->shared
1714                       && (info->symbolic
1715                           || h->dynindx == -1
1716                           || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
1717                       && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1718                 {
1719                   /* This is actually a static link, or it is a
1720                      -Bsymbolic link and the symbol is defined
1721                      locally, or the symbol was forced to be local
1722                      because of a version file.  We must initialize
1723                      this entry in the global offset table.  Since the
1724                      offset must always be a multiple of 2, we use the
1725                      least significant bit to record whether we have
1726                      initialized it already.
1727
1728                      When doing a dynamic link, we create a .rel.got
1729                      relocation entry to initialize the value.  This
1730                      is done in the finish_dynamic_symbol routine.  */
1731                   if ((off & 1) != 0)
1732                     off &= ~1;
1733                   else
1734                     {
1735                       bfd_put_64 (output_bfd, relocation,
1736                                   htab->sgot->contents + off);
1737                       h->got.offset |= 1;
1738                     }
1739                 }
1740               else
1741                 unresolved_reloc = false;
1742             }
1743           else
1744             {
1745               if (local_got_offsets == NULL)
1746                 abort ();
1747
1748               off = local_got_offsets[r_symndx];
1749
1750               /* The offset must always be a multiple of 8.  We use
1751                  the least significant bit to record whether we have
1752                  already generated the necessary reloc.  */
1753               if ((off & 1) != 0)
1754                 off &= ~1;
1755               else
1756                 {
1757                   bfd_put_64 (output_bfd, relocation,
1758                               htab->sgot->contents + off);
1759
1760                   if (info->shared)
1761                     {
1762                       asection *srelgot;
1763                       Elf_Internal_Rela outrel;
1764                       Elf64_External_Rela *loc;
1765
1766                       srelgot = htab->srelgot;
1767                       if (srelgot == NULL)
1768                         abort ();
1769
1770                       outrel.r_offset = (htab->sgot->output_section->vma
1771                                          + htab->sgot->output_offset
1772                                          + off);
1773                       outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
1774                       outrel.r_addend = relocation;
1775                       loc = (Elf64_External_Rela *) srelgot->contents;
1776                       loc += srelgot->reloc_count++;
1777                       bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
1778                     }
1779
1780                   local_got_offsets[r_symndx] |= 1;
1781                 }
1782             }
1783
1784           if (off >= (bfd_vma) -2)
1785             abort ();
1786
1787           relocation = htab->sgot->output_offset + off;
1788
1789           /*
1790            * For @GOTENT the relocation is against the offset between
1791            * the instruction and the symbols entry in the GOT and not
1792            * between the start of the GOT and the symbols entry. We
1793            * add the vma of the GOT to get the correct value.
1794            */
1795           if (r_type == R_390_GOTENT)
1796             relocation += htab->sgot->output_section->vma;
1797
1798           break;
1799
1800         case R_390_GOTOFF:
1801           /* Relocation is relative to the start of the global offset
1802              table.  */
1803
1804           /* Note that sgot->output_offset is not involved in this
1805              calculation.  We always want the start of .got.  If we
1806              defined _GLOBAL_OFFSET_TABLE in a different way, as is
1807              permitted by the ABI, we might have to change this
1808              calculation.  */
1809           relocation -= htab->sgot->output_section->vma;
1810
1811           break;
1812
1813         case R_390_GOTPC:
1814         case R_390_GOTPCDBL:
1815           /* Use global offset table as symbol value.  */
1816           relocation = htab->sgot->output_section->vma;
1817           unresolved_reloc = false;
1818          break;
1819
1820         case R_390_PLT16DBL:
1821         case R_390_PLT32:
1822         case R_390_PLT32DBL:
1823         case R_390_PLT64:
1824           /* Relocation is to the entry for this symbol in the
1825              procedure linkage table.  */
1826
1827           /* Resolve a PLT32 reloc against a local symbol directly,
1828              without using the procedure linkage table.  */
1829           if (h == NULL)
1830             break;
1831
1832           if (h->plt.offset == (bfd_vma) -1
1833               || htab->splt == NULL)
1834             {
1835               /* We didn't make a PLT entry for this symbol.  This
1836                  happens when statically linking PIC code, or when
1837                  using -Bsymbolic.  */
1838               break;
1839             }
1840
1841           relocation = (htab->splt->output_section->vma
1842                         + htab->splt->output_offset
1843                         + h->plt.offset);
1844           unresolved_reloc = false;
1845           break;
1846
1847         case R_390_8:
1848         case R_390_16:
1849         case R_390_32:
1850         case R_390_64:
1851         case R_390_PC16:
1852         case R_390_PC16DBL:
1853         case R_390_PC32:
1854         case R_390_PC32DBL:
1855         case R_390_PC64:
1856           /* r_symndx will be zero only for relocs against symbols
1857              from removed linkonce sections, or sections discarded by
1858              a linker script.  */
1859           if (r_symndx == 0
1860               || (input_section->flags & SEC_ALLOC) == 0)
1861             break;
1862
1863           if ((info->shared
1864                && ((r_type != R_390_PC16
1865                     && r_type != R_390_PC16DBL
1866                     && r_type != R_390_PC32
1867                     && r_type != R_390_PC32DBL
1868                     && r_type != R_390_PC64)
1869                    || (h != NULL
1870                        && h->dynindx != -1
1871                        && (! info->symbolic
1872                            || (h->elf_link_hash_flags
1873                                & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1874               || (!info->shared
1875                   && h != NULL
1876                   && h->dynindx != -1
1877                   && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1878                   && (((h->elf_link_hash_flags
1879                         & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1880                        && (h->elf_link_hash_flags
1881                            & ELF_LINK_HASH_DEF_REGULAR) == 0)
1882                       || h->root.type == bfd_link_hash_undefweak
1883                       || h->root.type == bfd_link_hash_undefined)))
1884             {
1885               Elf_Internal_Rela outrel;
1886               boolean skip, relocate;
1887               asection *sreloc;
1888               Elf64_External_Rela *loc;
1889
1890               /* When generating a shared object, these relocations
1891                  are copied into the output file to be resolved at run
1892                  time.  */
1893
1894               skip = false;
1895
1896               if (elf_section_data (input_section)->stab_info == NULL)
1897                 outrel.r_offset = rel->r_offset;
1898               else
1899                 {
1900                   off = (_bfd_stab_section_offset
1901                          (output_bfd, htab->elf.stab_info, input_section,
1902                           &elf_section_data (input_section)->stab_info,
1903                           rel->r_offset));
1904                   if (off == (bfd_vma) -1)
1905                     skip = true;
1906                   outrel.r_offset = off;
1907                 }
1908
1909               outrel.r_offset += (input_section->output_section->vma
1910                                   + input_section->output_offset);
1911
1912               if (skip)
1913                 {
1914                   memset (&outrel, 0, sizeof outrel);
1915                   relocate = false;
1916                 }
1917               else if (h != NULL
1918                        && h->dynindx != -1
1919                        && (r_type == R_390_PC16
1920                            || r_type == R_390_PC16DBL
1921                            || r_type == R_390_PC32
1922                            || r_type == R_390_PC32DBL
1923                            || r_type == R_390_PC64
1924                            || !info->shared
1925                            || !info->symbolic
1926                            || (h->elf_link_hash_flags
1927                                & ELF_LINK_HASH_DEF_REGULAR) == 0))
1928                 {
1929                   relocate = false;
1930                   outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
1931                   outrel.r_addend = rel->r_addend;
1932                 }
1933               else
1934                 {
1935                   /* This symbol is local, or marked to become local.  */
1936                   relocate = true;
1937                   outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
1938                   outrel.r_addend = relocation + rel->r_addend;
1939                 }
1940
1941               sreloc = elf_section_data (input_section)->sreloc;
1942               if (sreloc == NULL)
1943                 abort ();
1944
1945               loc = (Elf64_External_Rela *) sreloc->contents;
1946               loc += sreloc->reloc_count++;
1947               bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
1948
1949               /* If this reloc is against an external symbol, we do
1950                  not want to fiddle with the addend.  Otherwise, we
1951                  need to include the symbol value so that it becomes
1952                  an addend for the dynamic reloc.  */
1953               if (! relocate)
1954                 continue;
1955             }
1956
1957           break;
1958
1959         default:
1960           break;
1961         }
1962
1963       if (unresolved_reloc
1964           && !(info->shared
1965                && (input_section->flags & SEC_DEBUGGING) != 0
1966                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
1967         (*_bfd_error_handler)
1968           (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
1969            bfd_archive_filename (input_bfd),
1970            bfd_get_section_name (input_bfd, input_section),
1971            (long) rel->r_offset,
1972            h->root.root.string);
1973
1974       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1975                                       contents, rel->r_offset,
1976                                       relocation, rel->r_addend);
1977
1978       if (r != bfd_reloc_ok)
1979         {
1980           const char *name;
1981
1982           if (h != NULL)
1983             name = h->root.root.string;
1984           else
1985             {
1986               name = bfd_elf_string_from_elf_section (input_bfd,
1987                                                       symtab_hdr->sh_link,
1988                                                       sym->st_name);
1989               if (name == NULL)
1990                 return false;
1991               if (*name == '\0')
1992                 name = bfd_section_name (input_bfd, sec);
1993             }
1994
1995           if (r == bfd_reloc_overflow)
1996             {
1997
1998               if (! ((*info->callbacks->reloc_overflow)
1999                      (info, name, howto->name, (bfd_vma) 0,
2000                       input_bfd, input_section, rel->r_offset)))
2001                 return false;
2002             }
2003           else
2004             {
2005               (*_bfd_error_handler)
2006                 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
2007                  bfd_archive_filename (input_bfd),
2008                  bfd_get_section_name (input_bfd, input_section),
2009                  (long) rel->r_offset, name, (int) r);
2010               return false;
2011             }
2012         }
2013     }
2014
2015   return true;
2016 }
2017
2018 /* Finish up dynamic symbol handling.  We set the contents of various
2019    dynamic sections here.  */
2020
2021 static boolean
2022 elf_s390_finish_dynamic_symbol (output_bfd, info, h, sym)
2023      bfd *output_bfd;
2024      struct bfd_link_info *info;
2025      struct elf_link_hash_entry *h;
2026      Elf_Internal_Sym *sym;
2027 {
2028   struct elf_s390_link_hash_table *htab;
2029
2030   htab = elf_s390_hash_table (info);
2031
2032   if (h->plt.offset != (bfd_vma) -1)
2033     {
2034       bfd_vma plt_index;
2035       bfd_vma got_offset;
2036       Elf_Internal_Rela rela;
2037       Elf64_External_Rela *loc;
2038
2039       /* This symbol has an entry in the procedure linkage table.  Set
2040          it up.  */
2041
2042       if (h->dynindx == -1
2043           || htab->splt == NULL
2044           || htab->sgotplt == NULL
2045           || htab->srelplt == NULL)
2046         abort ();
2047
2048       /* Calc. index no.
2049          Current offset - size first entry / entry size.  */
2050       plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) / PLT_ENTRY_SIZE;
2051
2052       /* Offset in GOT is PLT index plus GOT headers(3) times 8,
2053          addr & GOT addr.  */
2054       got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
2055
2056       /* Fill in the blueprint of a PLT.  */
2057       bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD0,
2058                   htab->splt->contents + h->plt.offset);
2059       bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD1,
2060                   htab->splt->contents + h->plt.offset + 4);
2061       bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD2,
2062                   htab->splt->contents + h->plt.offset + 8);
2063       bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD3,
2064                   htab->splt->contents + h->plt.offset + 12);
2065       bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD4,
2066                   htab->splt->contents + h->plt.offset + 16);
2067       bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD5,
2068                   htab->splt->contents + h->plt.offset + 20);
2069       bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD6,
2070                   htab->splt->contents + h->plt.offset + 24);
2071       bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD7,
2072                   htab->splt->contents + h->plt.offset + 28);
2073       /* Fixup the relative address to the GOT entry */
2074       bfd_put_32 (output_bfd,
2075                   (htab->sgotplt->output_section->vma +
2076                    htab->sgotplt->output_offset + got_offset
2077                    - (htab->splt->output_section->vma + h->plt.offset))/2,
2078                   htab->splt->contents + h->plt.offset + 2);
2079       /* Fixup the relative branch to PLT 0 */
2080       bfd_put_32 (output_bfd, - (PLT_FIRST_ENTRY_SIZE +
2081                                  (PLT_ENTRY_SIZE * plt_index) + 22)/2,
2082                   htab->splt->contents + h->plt.offset + 24);
2083       /* Fixup offset into symbol table */
2084       bfd_put_32 (output_bfd, plt_index * sizeof (Elf64_External_Rela),
2085                   htab->splt->contents + h->plt.offset + 28);
2086
2087       /* Fill in the entry in the global offset table.
2088          Points to instruction after GOT offset.  */
2089       bfd_put_64 (output_bfd,
2090                   (htab->splt->output_section->vma
2091                    + htab->splt->output_offset
2092                    + h->plt.offset
2093                    + 14),
2094                   htab->sgotplt->contents + got_offset);
2095
2096       /* Fill in the entry in the .rela.plt section.  */
2097       rela.r_offset = (htab->sgotplt->output_section->vma
2098                        + htab->sgotplt->output_offset
2099                        + got_offset);
2100       rela.r_info = ELF64_R_INFO (h->dynindx, R_390_JMP_SLOT);
2101       rela.r_addend = 0;
2102       loc = (Elf64_External_Rela *) htab->srelplt->contents + plt_index;
2103       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
2104
2105       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2106         {
2107           /* Mark the symbol as undefined, rather than as defined in
2108              the .plt section.  Leave the value alone.  This is a clue
2109              for the dynamic linker, to make function pointer
2110              comparisons work between an application and shared
2111              library.  */
2112           sym->st_shndx = SHN_UNDEF;
2113         }
2114     }
2115
2116   if (h->got.offset != (bfd_vma) -1)
2117     {
2118       Elf_Internal_Rela rela;
2119       Elf64_External_Rela *loc;
2120
2121       /* This symbol has an entry in the global offset table.  Set it
2122          up.  */
2123
2124       if (htab->sgot == NULL || htab->srelgot == NULL)
2125         abort ();
2126
2127       rela.r_offset = (htab->sgot->output_section->vma
2128                        + htab->sgot->output_offset
2129                        + (h->got.offset &~ (bfd_vma) 1));
2130
2131       /* If this is a static link, or it is a -Bsymbolic link and the
2132          symbol is defined locally or was forced to be local because
2133          of a version file, we just want to emit a RELATIVE reloc.
2134          The entry in the global offset table will already have been
2135          initialized in the relocate_section function.  */
2136       if (info->shared
2137           && (info->symbolic
2138               || h->dynindx == -1
2139               || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2140           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2141         {
2142           BFD_ASSERT((h->got.offset & 1) != 0);
2143           rela.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2144           rela.r_addend = (h->root.u.def.value
2145                            + h->root.u.def.section->output_section->vma
2146                            + h->root.u.def.section->output_offset);
2147         }
2148       else
2149         {
2150           BFD_ASSERT((h->got.offset & 1) == 0);
2151           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgot->contents + h->got.offset);
2152           rela.r_info = ELF64_R_INFO (h->dynindx, R_390_GLOB_DAT);
2153           rela.r_addend = 0;
2154         }
2155
2156       loc = (Elf64_External_Rela *) htab->srelgot->contents;
2157       loc += htab->srelgot->reloc_count++;
2158       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
2159     }
2160
2161   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
2162     {
2163       Elf_Internal_Rela rela;
2164       Elf64_External_Rela *loc;
2165
2166       /* This symbols needs a copy reloc.  Set it up.  */
2167
2168       if (h->dynindx == -1
2169           || (h->root.type != bfd_link_hash_defined
2170               && h->root.type != bfd_link_hash_defweak)
2171           || htab->srelbss == NULL)
2172         abort ();
2173
2174       rela.r_offset = (h->root.u.def.value
2175                        + h->root.u.def.section->output_section->vma
2176                        + h->root.u.def.section->output_offset);
2177       rela.r_info = ELF64_R_INFO (h->dynindx, R_390_COPY);
2178       rela.r_addend = 0;
2179       loc = (Elf64_External_Rela *) htab->srelbss->contents;
2180       loc += htab->srelbss->reloc_count++;
2181       bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
2182     }
2183
2184   /* Mark some specially defined symbols as absolute.  */
2185   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2186       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
2187       || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
2188     sym->st_shndx = SHN_ABS;
2189
2190   return true;
2191 }
2192
2193 /* Used to decide how to sort relocs in an optimal manner for the
2194    dynamic linker, before writing them out.  */
2195
2196 static enum elf_reloc_type_class
2197 elf_s390_reloc_type_class (rela)
2198      const Elf_Internal_Rela *rela;
2199 {
2200   switch ((int) ELF64_R_TYPE (rela->r_info))
2201     {
2202     case R_390_RELATIVE:
2203       return reloc_class_relative;
2204     case R_390_JMP_SLOT:
2205       return reloc_class_plt;
2206     case R_390_COPY:
2207       return reloc_class_copy;
2208     default:
2209       return reloc_class_normal;
2210     }
2211 }
2212
2213 /* Finish up the dynamic sections.  */
2214
2215 static boolean
2216 elf_s390_finish_dynamic_sections (output_bfd, info)
2217      bfd *output_bfd;
2218      struct bfd_link_info *info;
2219 {
2220   struct elf_s390_link_hash_table *htab;
2221   bfd *dynobj;
2222   asection *sdyn;
2223
2224   htab = elf_s390_hash_table (info);
2225   dynobj = htab->elf.dynobj;
2226   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2227
2228   if (htab->elf.dynamic_sections_created)
2229     {
2230       Elf64_External_Dyn *dyncon, *dynconend;
2231
2232       if (sdyn == NULL || htab->sgot == NULL)
2233         abort ();
2234
2235       dyncon = (Elf64_External_Dyn *) sdyn->contents;
2236       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2237       for (; dyncon < dynconend; dyncon++)
2238         {
2239           Elf_Internal_Dyn dyn;
2240           asection *s;
2241
2242           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
2243
2244           switch (dyn.d_tag)
2245             {
2246             default:
2247               continue;
2248
2249             case DT_PLTGOT:
2250               dyn.d_un.d_ptr = htab->sgot->output_section->vma;
2251               break;
2252
2253             case DT_JMPREL:
2254               dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
2255               break;
2256
2257             case DT_PLTRELSZ:
2258               s = htab->srelplt->output_section;
2259               if (s->_cooked_size != 0)
2260                 dyn.d_un.d_val = s->_cooked_size;
2261               else
2262                 dyn.d_un.d_val = s->_raw_size;
2263               break;
2264
2265             case DT_RELASZ:
2266               /* The procedure linkage table relocs (DT_JMPREL) should
2267                  not be included in the overall relocs (DT_RELA).
2268                  Therefore, we override the DT_RELASZ entry here to
2269                  make it not include the JMPREL relocs.  Since the
2270                  linker script arranges for .rela.plt to follow all
2271                  other relocation sections, we don't have to worry
2272                  about changing the DT_RELA entry.  */
2273               s = htab->srelplt->output_section;
2274               if (s->_cooked_size != 0)
2275                 dyn.d_un.d_val -= s->_cooked_size;
2276               else
2277                 dyn.d_un.d_val -= s->_raw_size;
2278               break;
2279             }
2280
2281           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2282         }
2283
2284       /* Fill in the special first entry in the procedure linkage table.  */
2285       if (htab->splt && htab->splt->_raw_size > 0)
2286         {
2287           /* fill in blueprint for plt 0 entry */
2288           bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD0,
2289                       htab->splt->contents );
2290           bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD1,
2291                       htab->splt->contents +4 );
2292           bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD3,
2293                       htab->splt->contents +12 );
2294           bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD4,
2295                       htab->splt->contents +16 );
2296           bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD5,
2297                       htab->splt->contents +20 );
2298           bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD6,
2299                       htab->splt->contents + 24);
2300           bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD7,
2301                       htab->splt->contents + 28 );
2302           /* Fixup relative address to start of GOT */
2303           bfd_put_32 (output_bfd,
2304                       (htab->sgotplt->output_section->vma +
2305                        htab->sgotplt->output_offset
2306                        - htab->splt->output_section->vma - 6)/2,
2307                       htab->splt->contents + 8);
2308         }
2309       elf_section_data (htab->splt->output_section)
2310         ->this_hdr.sh_entsize = PLT_ENTRY_SIZE;
2311     }
2312
2313   if (htab->sgotplt)
2314     {
2315       /* Fill in the first three entries in the global offset table.  */
2316       if (htab->sgotplt->_raw_size > 0)
2317         {
2318           bfd_put_64 (output_bfd,
2319                       (sdyn == NULL ? (bfd_vma) 0
2320                        : sdyn->output_section->vma + sdyn->output_offset),
2321                       htab->sgotplt->contents);
2322           /* One entry for shared object struct ptr.  */
2323           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
2324           /* One entry for _dl_runtime_resolve.  */
2325           bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 12);
2326         }
2327
2328       elf_section_data (htab->sgot->output_section)
2329         ->this_hdr.sh_entsize = 8;
2330     }
2331   return true;
2332 }
2333
2334 static boolean
2335 elf_s390_object_p (abfd)
2336      bfd *abfd;
2337 {
2338   return bfd_default_set_arch_mach (abfd, bfd_arch_s390, bfd_mach_s390_esame);
2339 }
2340
2341 /*
2342  * Why was the hash table entry size definition changed from
2343  * ARCH_SIZE/8 to 4? This breaks the 64 bit dynamic linker and
2344  * this is the only reason for the s390_elf64_size_info structure.
2345  */
2346
2347 const struct elf_size_info s390_elf64_size_info =
2348 {
2349   sizeof (Elf64_External_Ehdr),
2350   sizeof (Elf64_External_Phdr),
2351   sizeof (Elf64_External_Shdr),
2352   sizeof (Elf64_External_Rel),
2353   sizeof (Elf64_External_Rela),
2354   sizeof (Elf64_External_Sym),
2355   sizeof (Elf64_External_Dyn),
2356   sizeof (Elf_External_Note),
2357   8,            /* hash-table entry size */
2358   1,            /* internal relocations per external relocations */
2359   64,           /* arch_size */
2360   8,            /* file_align */
2361   ELFCLASS64, EV_CURRENT,
2362   bfd_elf64_write_out_phdrs,
2363   bfd_elf64_write_shdrs_and_ehdr,
2364   bfd_elf64_write_relocs,
2365   bfd_elf64_swap_symbol_out,
2366   bfd_elf64_slurp_reloc_table,
2367   bfd_elf64_slurp_symbol_table,
2368   bfd_elf64_swap_dyn_in,
2369   bfd_elf64_swap_dyn_out,
2370   NULL,
2371   NULL,
2372   NULL,
2373   NULL
2374 };
2375
2376 #define TARGET_BIG_SYM  bfd_elf64_s390_vec
2377 #define TARGET_BIG_NAME "elf64-s390"
2378 #define ELF_ARCH        bfd_arch_s390
2379 #define ELF_MACHINE_CODE EM_S390
2380 #define ELF_MACHINE_ALT1 EM_S390_OLD
2381 #define ELF_MAXPAGESIZE 0x1000
2382
2383 #define elf_backend_size_info           s390_elf64_size_info
2384
2385 #define elf_backend_can_gc_sections     1
2386 #define elf_backend_can_refcount        1
2387 #define elf_backend_want_got_plt        1
2388 #define elf_backend_plt_readonly        1
2389 #define elf_backend_want_plt_sym        0
2390 #define elf_backend_got_header_size     24
2391 #define elf_backend_plt_header_size     PLT_ENTRY_SIZE
2392
2393 #define elf_info_to_howto               elf_s390_info_to_howto
2394
2395 #define bfd_elf64_bfd_is_local_label_name     elf_s390_is_local_label_name
2396 #define bfd_elf64_bfd_link_hash_table_create  elf_s390_link_hash_table_create
2397 #define bfd_elf64_bfd_reloc_type_lookup       elf_s390_reloc_type_lookup
2398
2399 #define elf_backend_adjust_dynamic_symbol     elf_s390_adjust_dynamic_symbol
2400 #define elf_backend_check_relocs              elf_s390_check_relocs
2401 #define elf_backend_copy_indirect_symbol      elf_s390_copy_indirect_symbol
2402 #define elf_backend_create_dynamic_sections   elf_s390_create_dynamic_sections
2403 #define elf_backend_finish_dynamic_sections   elf_s390_finish_dynamic_sections
2404 #define elf_backend_finish_dynamic_symbol     elf_s390_finish_dynamic_symbol
2405 #define elf_backend_gc_mark_hook              elf_s390_gc_mark_hook
2406 #define elf_backend_gc_sweep_hook             elf_s390_gc_sweep_hook
2407 #define elf_backend_reloc_type_class          elf_s390_reloc_type_class
2408 #define elf_backend_relocate_section          elf_s390_relocate_section
2409 #define elf_backend_size_dynamic_sections     elf_s390_size_dynamic_sections
2410 #define elf_backend_reloc_type_class          elf_s390_reloc_type_class
2411
2412 #define elf_backend_object_p                  elf_s390_object_p
2413
2414 #include "elf64-target.h"