bfd/elf32-s390.c

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