bfd/elf32-s390.c

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