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