bfd/elf32-s390.c

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