bfd/elf32-i370.c

   1 /* i370-specific support for 32-bit ELF
   2    Copyright 1994, 95, 96, 97, 98, 2000 Free Software Foundation, Inc.
   3    Written by Ian Lance Taylor, Cygnus Support.
   4    Hacked by Linas Vepstas for i370 [email protected]
   5
   6 This file is part of BFD, the Binary File Descriptor library.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 /* This file is based on a preliminary PowerPC ELF ABI.
  23    But its been hacked on for the IBM 360/370 architectures.
  24    Basically, the 31bit relocation works, and just about everything
  25    else is a wild card.  In particular, don't expect shared libs or
  26    dynamic loading to work ...  its never been tested ...
  27 */
  28
  29 #include "bfd.h"
  30 #include "sysdep.h"
  31 #include "bfdlink.h"
  32 #include "libbfd.h"
  33 #include "elf-bfd.h"
  34 #include "elf/i370.h"
  35
  36 #define USE_RELA                /* we want RELA relocations, not REL */
  37
  38 /* i370 relocations */
  39 /* Note that there is really just one relocation that we currently
  40  * support (and only one that we seem to need, at the moment), and
  41  * that is the 31-bit address relocation.  Note that the 370/390
  42  * only supports a 31-bit (2GB) address space.
  43  */
  44 enum i370_reloc_type
  45 {
  46   R_I370_NONE           =   0,
  47   R_I370_ADDR31         =   1,
  48   R_I370_ADDR32         =   2,
  49   R_I370_ADDR16         =   3,
  50   R_I370_REL31          =   4,
  51   R_I370_REL32          =   5,
  52   R_I370_ADDR12         =   6,
  53   R_I370_REL12          =   7,
  54   R_I370_ADDR8          =   8,
  55   R_I370_REL8           =   9,
  56   R_I370_COPY           =  10,
  57   R_I370_RELATIVE       =  11,
  58
  59   R_I370_max
  60 };
  61 \f
  62 static reloc_howto_type *i370_elf_howto_table[ (int)R_I370_max ];
  63
  64 static reloc_howto_type i370_elf_howto_raw[] =
  65 {
  66   /* This reloc does nothing.  */
  67   HOWTO (R_I370_NONE,           /* type */
  68          0,                     /* rightshift */
  69          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  70          32,                    /* bitsize */
  71          false,                 /* pc_relative */
  72          0,                     /* bitpos */
  73          complain_overflow_bitfield, /* complain_on_overflow */
  74          bfd_elf_generic_reloc, /* special_function */
  75          "R_I370_NONE",         /* name */
  76          false,                 /* partial_inplace */
  77          0,                     /* src_mask */
  78          0,                     /* dst_mask */
  79          false),                /* pcrel_offset */
  80
  81   /* A standard 31 bit relocation.  */
  82   HOWTO (R_I370_ADDR31,         /* type */
  83          0,                     /* rightshift */
  84          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  85          31,                    /* bitsize */
  86          false,                 /* pc_relative */
  87          0,                     /* bitpos */
  88          complain_overflow_bitfield, /* complain_on_overflow */
  89          bfd_elf_generic_reloc, /* special_function */
  90          "R_I370_ADDR31",       /* name */
  91          false,                 /* partial_inplace */
  92          0,                     /* src_mask */
  93          0x7fffffff,            /* dst_mask */
  94          false),                /* pcrel_offset */
  95
  96   /* A standard 32 bit relocation.  */
  97   HOWTO (R_I370_ADDR32,         /* type */
  98          0,                     /* rightshift */
  99          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 100          32,                    /* bitsize */
 101          false,                 /* pc_relative */
 102          0,                     /* bitpos */
 103          complain_overflow_bitfield, /* complain_on_overflow */
 104          bfd_elf_generic_reloc, /* special_function */
 105          "R_I370_ADDR32",       /* name */
 106          false,                 /* partial_inplace */
 107          0,                     /* src_mask */
 108          0xffffffff,            /* dst_mask */
 109          false),                /* pcrel_offset */
 110
 111   /* A standard 16 bit relocation.  */
 112   HOWTO (R_I370_ADDR16,         /* type */
 113          0,                     /* rightshift */
 114          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 115          16,                    /* bitsize */
 116          false,                 /* pc_relative */
 117          0,                     /* bitpos */
 118          complain_overflow_bitfield, /* complain_on_overflow */
 119          bfd_elf_generic_reloc, /* special_function */
 120          "R_I370_ADDR16",       /* name */
 121          false,                 /* partial_inplace */
 122          0,                     /* src_mask */
 123          0xffff,                /* dst_mask */
 124          false),                /* pcrel_offset */
 125
 126   /* 31-bit PC relative */
 127   HOWTO (R_I370_REL31,          /* type */
 128          0,                     /* rightshift */
 129          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 130          31,                    /* bitsize */
 131          true,                  /* pc_relative */
 132          0,                     /* bitpos */
 133          complain_overflow_bitfield, /* complain_on_overflow */
 134          bfd_elf_generic_reloc, /* special_function */
 135          "R_I370_REL31",        /* name */
 136          false,                 /* partial_inplace */
 137          0,                     /* src_mask */
 138          0x7fffffff,            /* dst_mask */
 139          true),                 /* pcrel_offset */
 140
 141   /* 32-bit PC relative */
 142   HOWTO (R_I370_REL32,          /* type */
 143          0,                     /* rightshift */
 144          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 145          32,                    /* bitsize */
 146          true,                  /* pc_relative */
 147          0,                     /* bitpos */
 148          complain_overflow_bitfield, /* complain_on_overflow */
 149          bfd_elf_generic_reloc, /* special_function */
 150          "R_I370_REL32",        /* name */
 151          false,                 /* partial_inplace */
 152          0,                     /* src_mask */
 153          0xffffffff,            /* dst_mask */
 154          true),                 /* pcrel_offset */
 155
 156   /* A standard 12 bit relocation.  */
 157   HOWTO (R_I370_ADDR12,         /* type */
 158          0,                     /* rightshift */
 159          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 160          12,                    /* bitsize */
 161          false,                 /* pc_relative */
 162          0,                     /* bitpos */
 163          complain_overflow_bitfield, /* complain_on_overflow */
 164          bfd_elf_generic_reloc, /* special_function */
 165          "R_I370_ADDR12",       /* name */
 166          false,                 /* partial_inplace */
 167          0,                     /* src_mask */
 168          0xfff,                 /* dst_mask */
 169          false),                /* pcrel_offset */
 170
 171   /* 12-bit PC relative */
 172   HOWTO (R_I370_REL12,          /* type */
 173          0,                     /* rightshift */
 174          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 175          12,                    /* bitsize */
 176          true,                  /* pc_relative */
 177          0,                     /* bitpos */
 178          complain_overflow_bitfield, /* complain_on_overflow */
 179          bfd_elf_generic_reloc, /* special_function */
 180          "R_I370_REL12",        /* name */
 181          false,                 /* partial_inplace */
 182          0,                     /* src_mask */
 183          0xfff,                 /* dst_mask */
 184          true),                 /* pcrel_offset */
 185
 186   /* A standard 8 bit relocation.  */
 187   HOWTO (R_I370_ADDR8,          /* type */
 188          0,                     /* rightshift */
 189          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 190          8,                     /* bitsize */
 191          false,                 /* pc_relative */
 192          0,                     /* bitpos */
 193          complain_overflow_bitfield, /* complain_on_overflow */
 194          bfd_elf_generic_reloc, /* special_function */
 195          "R_I370_ADDR8",        /* name */
 196          false,                 /* partial_inplace */
 197          0,                     /* src_mask */
 198          0xff,                  /* dst_mask */
 199          false),                /* pcrel_offset */
 200
 201   /* 8-bit PC relative */
 202   HOWTO (R_I370_REL8,           /* type */
 203          0,                     /* rightshift */
 204          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 205          8,                     /* bitsize */
 206          true,                  /* pc_relative */
 207          0,                     /* bitpos */
 208          complain_overflow_bitfield, /* complain_on_overflow */
 209          bfd_elf_generic_reloc, /* special_function */
 210          "R_I370_REL8",         /* name */
 211          false,                 /* partial_inplace */
 212          0,                     /* src_mask */
 213          0xff,                  /* dst_mask */
 214          true),                 /* pcrel_offset */
 215
 216   /* This is used only by the dynamic linker.  The symbol should exist
 217      both in the object being run and in some shared library.  The
 218      dynamic linker copies the data addressed by the symbol from the
 219      shared library into the object, because the object being
 220      run has to have the data at some particular address.  */
 221   HOWTO (R_I370_COPY,           /* type */
 222          0,                     /* rightshift */
 223          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 224          32,                    /* bitsize */
 225          false,                 /* pc_relative */
 226          0,                     /* bitpos */
 227          complain_overflow_bitfield, /* complain_on_overflow */
 228          bfd_elf_generic_reloc,  /* special_function */
 229          "R_I370_COPY",         /* name */
 230          false,                 /* partial_inplace */
 231          0,                     /* src_mask */
 232          0,                     /* dst_mask */
 233          false),                /* pcrel_offset */
 234
 235   /* Used only by the dynamic linker.  When the object is run, this
 236      longword is set to the load address of the object, plus the
 237      addend.  */
 238   HOWTO (R_I370_RELATIVE,       /* type */
 239          0,                     /* rightshift */
 240          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 241          32,                    /* bitsize */
 242          false,                 /* pc_relative */
 243          0,                     /* bitpos */
 244          complain_overflow_bitfield, /* complain_on_overflow */
 245          bfd_elf_generic_reloc,  /* special_function */
 246          "R_I370_RELATIVE",     /* name */
 247          false,                 /* partial_inplace */
 248          0,                     /* src_mask */
 249          0xffffffff,            /* dst_mask */
 250          false),                /* pcrel_offset */
 251
 252 };
 253 \f
 254 static void i370_elf_howto_init PARAMS ((void));
 255 static void i370_elf_info_to_howto PARAMS ((bfd *abfd, arelent *cache_ptr,
 256                                             Elf32_Internal_Rela *dst));
 257 static boolean i370_elf_set_private_flags PARAMS ((bfd *, flagword));
 258 \f
 259 /* Initialize the i370_elf_howto_table, so that linear accesses can be done.  */
 260
 261 static void
 262 i370_elf_howto_init ()
 263 {
 264   unsigned int i, type;
 265
 266   for (i = 0; i < sizeof (i370_elf_howto_raw) / sizeof (i370_elf_howto_raw[0]); i++)
 267     {
 268       type = i370_elf_howto_raw[i].type;
 269       BFD_ASSERT (type < sizeof (i370_elf_howto_table) / sizeof (i370_elf_howto_table[0]));
 270       i370_elf_howto_table[type] = &i370_elf_howto_raw[i];
 271     }
 272 }
 273 \f
 274 static reloc_howto_type *
 275 i370_elf_reloc_type_lookup (abfd, code)
 276      bfd *abfd ATTRIBUTE_UNUSED;
 277      bfd_reloc_code_real_type code;
 278 {
 279   enum i370_reloc_type i370_reloc = R_I370_NONE;
 280
 281   if (!i370_elf_howto_table[ R_I370_ADDR31 ])   /* Initialize howto table if needed */
 282     i370_elf_howto_init ();
 283
 284   switch ((int)code)
 285     {
 286     default:
 287       return (reloc_howto_type *)NULL;
 288
 289     case BFD_RELOC_NONE:        i370_reloc = R_I370_NONE;       break;
 290     case BFD_RELOC_32:          i370_reloc = R_I370_ADDR31;     break;
 291     case BFD_RELOC_16:          i370_reloc = R_I370_ADDR16;     break;
 292     case BFD_RELOC_32_PCREL:    i370_reloc = R_I370_REL31;      break;
 293     case BFD_RELOC_CTOR:        i370_reloc = R_I370_ADDR31;     break;
 294     case BFD_RELOC_I370_D12:    i370_reloc = R_I370_ADDR12;     break;
 295     }
 296
 297   return i370_elf_howto_table[ (int)i370_reloc ];
 298 };
 299
 300 static boolean i370_elf_copy_private_bfd_data PARAMS ((bfd *, bfd *));
 301 static boolean i370_elf_merge_private_bfd_data PARAMS ((bfd *, bfd *));
 302
 303 static boolean i370_elf_relocate_section PARAMS ((bfd *,
 304                                                   struct bfd_link_info *info,
 305                                                   bfd *,
 306                                                   asection *,
 307                                                   bfd_byte *,
 308                                                   Elf_Internal_Rela *relocs,
 309                                                   Elf_Internal_Sym *local_syms,
 310                                                   asection **));
 311
 312 static boolean i370_elf_create_dynamic_sections PARAMS ((bfd *,
 313                                                          struct bfd_link_info *));
 314
 315 static boolean i370_elf_section_from_shdr PARAMS ((bfd *,
 316                                                    Elf32_Internal_Shdr *,
 317                                                    char *));
 318 static boolean i370_elf_fake_sections PARAMS ((bfd *,
 319                                                Elf32_Internal_Shdr *,
 320                                                asection *));
 321 #if 0
 322 static elf_linker_section_t *i370_elf_create_linker_section
 323   PARAMS ((bfd *abfd,
 324            struct bfd_link_info *info,
 325            enum elf_linker_section_enum));
 326 #endif
 327 static boolean i370_elf_check_relocs PARAMS ((bfd *,
 328                                              struct bfd_link_info *,
 329                                              asection *,
 330                                              const Elf_Internal_Rela *));
 331
 332 static boolean i370_elf_adjust_dynamic_symbol PARAMS ((struct bfd_link_info *,
 333                                                       struct elf_link_hash_entry *));
 334
 335 static boolean i370_elf_adjust_dynindx PARAMS ((struct elf_link_hash_entry *, PTR));
 336
 337 static boolean i370_elf_size_dynamic_sections PARAMS ((bfd *, struct bfd_link_info *));
 338
 339 static boolean i370_elf_finish_dynamic_sections PARAMS ((bfd *, struct bfd_link_info *));
 340
 341 /* The name of the dynamic interpreter.  This is put in the .interp
 342     section.  */
 343
 344 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
 345
 346 /* Set the howto pointer for an i370 ELF reloc.  */
 347
 348 static void
 349 i370_elf_info_to_howto (abfd, cache_ptr, dst)
 350      bfd *abfd ATTRIBUTE_UNUSED;
 351      arelent *cache_ptr;
 352      Elf32_Internal_Rela *dst;
 353 {
 354   if (!i370_elf_howto_table[ R_I370_ADDR31 ])   /* Initialize howto table */
 355     i370_elf_howto_init ();
 356
 357   BFD_ASSERT (ELF32_R_TYPE (dst->r_info) < (unsigned int) R_I370_max);
 358   cache_ptr->howto = i370_elf_howto_table[ELF32_R_TYPE (dst->r_info)];
 359 }
 360
 361 /* hack alert --  the following several routines look generic to me ...
 362  * why are we bothering with them ???
 363  */
 364 /* Function to set whether a module needs the -mrelocatable bit set.  */
 365 static boolean
 366 i370_elf_set_private_flags (abfd, flags)
 367      bfd *abfd;
 368      flagword flags;
 369 {
 370   BFD_ASSERT (!elf_flags_init (abfd)
 371               || elf_elfheader (abfd)->e_flags == flags);
 372
 373   elf_elfheader (abfd)->e_flags = flags;
 374   elf_flags_init (abfd) = true;
 375   return true;
 376 }
 377
 378 /* Copy backend specific data from one object module to another */
 379 static boolean
 380 i370_elf_copy_private_bfd_data (ibfd, obfd)
 381      bfd *ibfd;
 382      bfd *obfd;
 383 {
 384   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
 385       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
 386     return true;
 387
 388   BFD_ASSERT (!elf_flags_init (obfd)
 389               || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
 390
 391   elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
 392   elf_flags_init (obfd) = true;
 393   return true;
 394 }
 395
 396 /* Merge backend specific data from an object file to the output
 397    object file when linking */
 398 static boolean
 399 i370_elf_merge_private_bfd_data (ibfd, obfd)
 400      bfd *ibfd;
 401      bfd *obfd;
 402 {
 403   flagword old_flags;
 404   flagword new_flags;
 405
 406   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
 407       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
 408     return true;
 409
 410   new_flags = elf_elfheader (ibfd)->e_flags;
 411   old_flags = elf_elfheader (obfd)->e_flags;
 412   if (!elf_flags_init (obfd))   /* First call, no flags set */
 413     {
 414       elf_flags_init (obfd) = true;
 415       elf_elfheader (obfd)->e_flags = new_flags;
 416     }
 417
 418   else if (new_flags == old_flags)      /* Compatible flags are ok */
 419     ;
 420
 421   else                                  /* Incompatible flags */
 422     {
 423       (*_bfd_error_handler)
 424         ("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)",
 425          bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
 426
 427       bfd_set_error (bfd_error_bad_value);
 428       return false;
 429     }
 430
 431   return true;
 432 }
 433 \f
 434 /* Handle an i370 specific section when reading an object file.  This
 435    is called when elfcode.h finds a section with an unknown type.  */
 436 /* XXX hack alert bogus This routine is mostly all junk and almost
 437  * certainly does the wrong thing.  Its here simply because it does
 438  * just enough to allow glibc-2.1 ld.so to compile & link.
 439  */
 440
 441 static boolean
 442 i370_elf_section_from_shdr (abfd, hdr, name)
 443      bfd *abfd;
 444      Elf32_Internal_Shdr *hdr;
 445      char *name;
 446 {
 447   asection *newsect;
 448   flagword flags;
 449
 450   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
 451     return false;
 452
 453   newsect = hdr->bfd_section;
 454   flags = bfd_get_section_flags (abfd, newsect);
 455   if (hdr->sh_flags & SHF_EXCLUDE)
 456     flags |= SEC_EXCLUDE;
 457
 458   if (hdr->sh_type == SHT_ORDERED)
 459     flags |= SEC_SORT_ENTRIES;
 460
 461   bfd_set_section_flags (abfd, newsect, flags);
 462   return true;
 463 }
 464 \f
 465 /* Set up any other section flags and such that may be necessary.  */
 466 /* XXX hack alert bogus This routine is mostly all junk and almost
 467  * certainly does the wrong thing.  Its here simply because it does
 468  * just enough to allow glibc-2.1 ld.so to compile & link.
 469  */
 470
 471 static boolean
 472 i370_elf_fake_sections (abfd, shdr, asect)
 473      bfd *abfd ATTRIBUTE_UNUSED;
 474      Elf32_Internal_Shdr *shdr;
 475      asection *asect;
 476 {
 477   if ((asect->flags & SEC_EXCLUDE) != 0)
 478     shdr->sh_flags |= SHF_EXCLUDE;
 479
 480   if ((asect->flags & SEC_SORT_ENTRIES) != 0)
 481     shdr->sh_type = SHT_ORDERED;
 482
 483   return true;
 484 }
 485 \f
 486 #if 0
 487 /* Create a special linker section */
 488 /* XXX hack alert bogus This routine is mostly all junk and almost
 489  * certainly does the wrong thing.  Its here simply because it does
 490  * just enough to allow glibc-2.1 ld.so to compile & link.
 491  */
 492
 493 static elf_linker_section_t *
 494 i370_elf_create_linker_section (abfd, info, which)
 495      bfd *abfd;
 496      struct bfd_link_info *info;
 497      enum elf_linker_section_enum which;
 498 {
 499   bfd *dynobj = elf_hash_table (info)->dynobj;
 500   elf_linker_section_t *lsect;
 501
 502   /* Record the first bfd section that needs the special section */
 503   if (!dynobj)
 504     dynobj = elf_hash_table (info)->dynobj = abfd;
 505
 506   /* If this is the first time, create the section */
 507   lsect = elf_linker_section (dynobj, which);
 508   if (!lsect)
 509     {
 510       elf_linker_section_t defaults;
 511       static elf_linker_section_t zero_section;
 512
 513       defaults = zero_section;
 514       defaults.which = which;
 515       defaults.hole_written_p = false;
 516       defaults.alignment = 2;
 517
 518       /* Both of these sections are (technically) created by the user
 519          putting data in them, so they shouldn't be marked
 520          SEC_LINKER_CREATED.
 521
 522          The linker creates them so it has somewhere to attach their
 523          respective symbols. In fact, if they were empty it would
 524          be OK to leave the symbol set to 0 (or any random number), because
 525          the appropriate register should never be used.  */
 526       defaults.flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
 527                         | SEC_IN_MEMORY);
 528
 529       switch (which)
 530         {
 531         default:
 532           (*_bfd_error_handler) ("%s: Unknown special linker type %d",
 533                                  bfd_get_filename (abfd),
 534                                  (int)which);
 535
 536           bfd_set_error (bfd_error_bad_value);
 537           return (elf_linker_section_t *)0;
 538
 539         case LINKER_SECTION_SDATA:      /* .sdata/.sbss section */
 540           defaults.name           = ".sdata";
 541           defaults.rel_name       = ".rela.sdata";
 542           defaults.bss_name       = ".sbss";
 543           defaults.sym_name       = "_SDA_BASE_";
 544           defaults.sym_offset     = 32768;
 545           break;
 546
 547         case LINKER_SECTION_SDATA2:     /* .sdata2/.sbss2 section */
 548           defaults.name           = ".sdata2";
 549           defaults.rel_name       = ".rela.sdata2";
 550           defaults.bss_name       = ".sbss2";
 551           defaults.sym_name       = "_SDA2_BASE_";
 552           defaults.sym_offset     = 32768;
 553           defaults.flags         |= SEC_READONLY;
 554           break;
 555         }
 556
 557       lsect = _bfd_elf_create_linker_section (abfd, info, which, &defaults);
 558     }
 559
 560   return lsect;
 561 }
 562 #endif
 563 \f
 564 /* We have to create .dynsbss and .rela.sbss here so that they get mapped
 565    to output sections (just like _bfd_elf_create_dynamic_sections has
 566    to create .dynbss and .rela.bss).  */
 567 /* XXX hack alert bogus This routine is mostly all junk and almost
 568  * certainly does the wrong thing.  Its here simply because it does
 569  * just enough to allow glibc-2.1 ld.so to compile & link.
 570  */
 571
 572 static boolean
 573 i370_elf_create_dynamic_sections (abfd, info)
 574      bfd *abfd;
 575      struct bfd_link_info *info;
 576 {
 577   register asection *s;
 578   flagword flags;
 579
 580   if (!_bfd_elf_create_dynamic_sections(abfd, info))
 581     return false;
 582
 583   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
 584            | SEC_LINKER_CREATED);
 585
 586   s = bfd_make_section (abfd, ".dynsbss");
 587   if (s == NULL
 588       || ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
 589     return false;
 590
 591   if (! info->shared)
 592     {
 593       s = bfd_make_section (abfd, ".rela.sbss");
 594       if (s == NULL
 595           || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
 596           || ! bfd_set_section_alignment (abfd, s, 2))
 597         return false;
 598     }
 599
 600    /* xxx beats me, seem to need a rela.text ...  */
 601    s = bfd_make_section (abfd, ".rela.text");
 602    if (s == NULL
 603       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
 604       || ! bfd_set_section_alignment (abfd, s, 2))
 605     return false;
 606   return true;
 607 }
 608
 609 /* Adjust a symbol defined by a dynamic object and referenced by a
 610    regular object.  The current definition is in some section of the
 611    dynamic object, but we're not including those sections.  We have to
 612    change the definition to something the rest of the link can
 613    understand.  */
 614 /* XXX hack alert bogus This routine is mostly all junk and almost
 615  * certainly does the wrong thing.  Its here simply because it does
 616  * just enough to allow glibc-2.1 ld.so to compile & link.
 617  */
 618
 619 static boolean
 620 i370_elf_adjust_dynamic_symbol (info, h)
 621      struct bfd_link_info *info;
 622      struct elf_link_hash_entry *h;
 623 {
 624   bfd *dynobj = elf_hash_table (info)->dynobj;
 625   asection *s;
 626   unsigned int power_of_two;
 627
 628 #ifdef DEBUG
 629   fprintf (stderr, "i370_elf_adjust_dynamic_symbol called for %s\n",
 630            h->root.root.string);
 631 #endif
 632
 633   /* Make sure we know what is going on here.  */
 634   BFD_ASSERT (dynobj != NULL
 635               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
 636                   || h->weakdef != NULL
 637                   || ((h->elf_link_hash_flags
 638                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
 639                       && (h->elf_link_hash_flags
 640                           & ELF_LINK_HASH_REF_REGULAR) != 0
 641                       && (h->elf_link_hash_flags
 642                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
 643
 644   s = bfd_get_section_by_name (dynobj, ".rela.text");
 645   BFD_ASSERT (s != NULL);
 646   s->_raw_size += sizeof (Elf32_External_Rela);
 647
 648   /* If this is a weak symbol, and there is a real definition, the
 649      processor independent code will have arranged for us to see the
 650      real definition first, and we can just use the same value.  */
 651   if (h->weakdef != NULL)
 652     {
 653       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
 654                   || h->weakdef->root.type == bfd_link_hash_defweak);
 655       h->root.u.def.section = h->weakdef->root.u.def.section;
 656       h->root.u.def.value = h->weakdef->root.u.def.value;
 657       return true;
 658     }
 659
 660   /* This is a reference to a symbol defined by a dynamic object which
 661      is not a function.  */
 662
 663   /* If we are creating a shared library, we must presume that the
 664      only references to the symbol are via the global offset table.
 665      For such cases we need not do anything here; the relocations will
 666      be handled correctly by relocate_section.  */
 667   if (info->shared)
 668     return true;
 669
 670   /* We must allocate the symbol in our .dynbss section, which will
 671      become part of the .bss section of the executable.  There will be
 672      an entry for this symbol in the .dynsym section.  The dynamic
 673      object will contain position independent code, so all references
 674      from the dynamic object to this symbol will go through the global
 675      offset table.  The dynamic linker will use the .dynsym entry to
 676      determine the address it must put in the global offset table, so
 677      both the dynamic object and the regular object will refer to the
 678      same memory location for the variable.
 679
 680      Of course, if the symbol is sufficiently small, we must instead
 681      allocate it in .sbss.  FIXME: It would be better to do this if and
 682      only if there were actually SDAREL relocs for that symbol.  */
 683
 684   if (h->size <= elf_gp_size (dynobj))
 685     s = bfd_get_section_by_name (dynobj, ".dynsbss");
 686   else
 687     s = bfd_get_section_by_name (dynobj, ".dynbss");
 688   BFD_ASSERT (s != NULL);
 689
 690   /* We must generate a R_I370_COPY reloc to tell the dynamic linker to
 691      copy the initial value out of the dynamic object and into the
 692      runtime process image.  We need to remember the offset into the
 693      .rela.bss section we are going to use.  */
 694   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
 695     {
 696       asection *srel;
 697
 698       if (h->size <= elf_gp_size (dynobj))
 699         srel = bfd_get_section_by_name (dynobj, ".rela.sbss");
 700       else
 701         srel = bfd_get_section_by_name (dynobj, ".rela.bss");
 702       BFD_ASSERT (srel != NULL);
 703       srel->_raw_size += sizeof (Elf32_External_Rela);
 704       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
 705     }
 706
 707   /* We need to figure out the alignment required for this symbol.  I
 708      have no idea how ELF linkers handle this.  */
 709   power_of_two = bfd_log2 (h->size);
 710   if (power_of_two > 4)
 711     power_of_two = 4;
 712
 713   /* Apply the required alignment.  */
 714   s->_raw_size = BFD_ALIGN (s->_raw_size,
 715                             (bfd_size_type) (1 << power_of_two));
 716   if (power_of_two > bfd_get_section_alignment (dynobj, s))
 717     {
 718       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
 719         return false;
 720     }
 721
 722   /* Define the symbol as being at this point in the section.  */
 723   h->root.u.def.section = s;
 724   h->root.u.def.value = s->_raw_size;
 725
 726   /* Increment the section size to make room for the symbol.  */
 727   s->_raw_size += h->size;
 728
 729   return true;
 730 }
 731 \f
 732 /* Increment the index of a dynamic symbol by a given amount.  Called
 733    via elf_link_hash_traverse.  */
 734 /* XXX hack alert bogus This routine is mostly all junk and almost
 735  * certainly does the wrong thing.  Its here simply because it does
 736  * just enough to allow glibc-2.1 ld.so to compile & link.
 737  */
 738
 739 static boolean
 740 i370_elf_adjust_dynindx (h, cparg)
 741      struct elf_link_hash_entry *h;
 742      PTR cparg;
 743 {
 744   int *cp = (int *) cparg;
 745
 746 #ifdef DEBUG
 747   fprintf (stderr,
 748            "i370_elf_adjust_dynindx called, h->dynindx = %d, *cp = %d\n",
 749            h->dynindx, *cp);
 750 #endif
 751
 752   if (h->dynindx != -1)
 753     h->dynindx += *cp;
 754
 755   return true;
 756 }
 757 \f
 758 /* Set the sizes of the dynamic sections.  */
 759 /* XXX hack alert bogus This routine is mostly all junk and almost
 760  * certainly does the wrong thing.  Its here simply because it does
 761  * just enough to allow glibc-2.1 ld.so to compile & link.
 762  */
 763
 764 static boolean
 765 i370_elf_size_dynamic_sections (output_bfd, info)
 766      bfd *output_bfd;
 767      struct bfd_link_info *info;
 768 {
 769   bfd *dynobj;
 770   asection *s;
 771   boolean plt;
 772   boolean relocs;
 773   boolean reltext;
 774
 775 #ifdef DEBUG
 776   fprintf (stderr, "i370_elf_size_dynamic_sections called\n");
 777 #endif
 778
 779   dynobj = elf_hash_table (info)->dynobj;
 780   BFD_ASSERT (dynobj != NULL);
 781
 782   if (elf_hash_table (info)->dynamic_sections_created)
 783     {
 784       /* Set the contents of the .interp section to the interpreter.  */
 785       if (! info->shared)
 786         {
 787           s = bfd_get_section_by_name (dynobj, ".interp");
 788           BFD_ASSERT (s != NULL);
 789           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
 790           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
 791         }
 792     }
 793   else
 794     {
 795       /* We may have created entries in the .rela.got, .rela.sdata, and
 796          .rela.sdata2 sections.  However, if we are not creating the
 797          dynamic sections, we will not actually use these entries.  Reset
 798          the size of .rela.got, et al, which will cause it to get
 799          stripped from the output file below.  */
 800       static char *rela_sections[] = { ".rela.got", ".rela.sdata",
 801                                        ".rela.sdata2", ".rela.sbss",
 802                                        (char *)0 };
 803       char **p;
 804
 805       for (p = rela_sections; *p != (char *)0; p++)
 806         {
 807           s = bfd_get_section_by_name (dynobj, *p);
 808           if (s != NULL)
 809             s->_raw_size = 0;
 810         }
 811     }
 812
 813   /* The check_relocs and adjust_dynamic_symbol entry points have
 814      determined the sizes of the various dynamic sections.  Allocate
 815      memory for them.  */
 816   plt = false;
 817   relocs = false;
 818   reltext = false;
 819   for (s = dynobj->sections; s != NULL; s = s->next)
 820     {
 821       const char *name;
 822       boolean strip;
 823
 824       if ((s->flags & SEC_LINKER_CREATED) == 0)
 825         continue;
 826
 827       /* It's OK to base decisions on the section name, because none
 828          of the dynobj section names depend upon the input files.  */
 829       name = bfd_get_section_name (dynobj, s);
 830       strip = false;
 831
 832       if (strcmp (name, ".plt") == 0)
 833         {
 834           if (s->_raw_size == 0)
 835             {
 836               /* Strip this section if we don't need it; see the
 837                  comment below.  */
 838               strip = true;
 839             }
 840           else
 841             {
 842               /* Remember whether there is a PLT.  */
 843               plt = true;
 844             }
 845         }
 846       else if (strncmp (name, ".rela", 5) == 0)
 847         {
 848           if (s->_raw_size == 0)
 849             {
 850               /* If we don't need this section, strip it from the
 851                  output file.  This is mostly to handle .rela.bss and
 852                  .rela.plt.  We must create both sections in
 853                  create_dynamic_sections, because they must be created
 854                  before the linker maps input sections to output
 855                  sections.  The linker does that before
 856                  adjust_dynamic_symbol is called, and it is that
 857                  function which decides whether anything needs to go
 858                  into these sections.  */
 859               strip = true;
 860             }
 861           else
 862             {
 863               asection *target;
 864               const char *outname;
 865
 866               /* Remember whether there are any relocation sections.  */
 867               relocs = true;
 868
 869               /* If this relocation section applies to a read only
 870                  section, then we probably need a DT_TEXTREL entry.  */
 871               outname = bfd_get_section_name (output_bfd,
 872                                               s->output_section);
 873               target = bfd_get_section_by_name (output_bfd, outname + 5);
 874               if (target != NULL
 875                   && (target->flags & SEC_READONLY) != 0
 876                   && (target->flags & SEC_ALLOC) != 0)
 877                 reltext = true;
 878
 879               /* We use the reloc_count field as a counter if we need
 880                  to copy relocs into the output file.  */
 881               s->reloc_count = 0;
 882             }
 883         }
 884       else if (strcmp (name, ".got") != 0
 885                && strcmp (name, ".sdata") != 0
 886                && strcmp (name, ".sdata2") != 0)
 887         {
 888           /* It's not one of our sections, so don't allocate space.  */
 889           continue;
 890         }
 891
 892       if (strip)
 893         {
 894           asection **spp;
 895
 896           for (spp = &s->output_section->owner->sections;
 897                *spp != s->output_section;
 898                spp = &(*spp)->next)
 899             ;
 900           *spp = s->output_section->next;
 901           --s->output_section->owner->section_count;
 902
 903           continue;
 904         }
 905       /* Allocate memory for the section contents.  */
 906       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
 907       if (s->contents == NULL && s->_raw_size != 0)
 908         return false;
 909     }
 910
 911   if (elf_hash_table (info)->dynamic_sections_created)
 912     {
 913       /* Add some entries to the .dynamic section.  We fill in the
 914          values later, in i370_elf_finish_dynamic_sections, but we
 915          must add the entries now so that we get the correct size for
 916          the .dynamic section.  The DT_DEBUG entry is filled in by the
 917          dynamic linker and used by the debugger.  */
 918       if (! info->shared)
 919         {
 920           if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
 921             return false;
 922         }
 923
 924       if (plt)
 925         {
 926           if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
 927               || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
 928               || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
 929               || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
 930             return false;
 931         }
 932
 933       if (relocs)
 934         {
 935           if (! bfd_elf32_add_dynamic_entry (info, DT_RELA, 0)
 936               || ! bfd_elf32_add_dynamic_entry (info, DT_RELASZ, 0)
 937               || ! bfd_elf32_add_dynamic_entry (info, DT_RELAENT,
 938                                                 sizeof (Elf32_External_Rela)))
 939             return false;
 940         }
 941
 942       if (reltext)
 943         {
 944           if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
 945             return false;
 946           info->flags |= DF_TEXTREL;
 947         }
 948     }
 949
 950   /* If we are generating a shared library, we generate a section
 951      symbol for each output section.  These are local symbols, which
 952      means that they must come first in the dynamic symbol table.
 953      That means we must increment the dynamic symbol index of every
 954      other dynamic symbol.
 955
 956      FIXME: We assume that there will never be relocations to
 957      locations in linker-created sections that do not have
 958      externally-visible names. Instead, we should work out precisely
 959      which sections relocations are targetted at.  */
 960   if (info->shared)
 961     {
 962       int c;
 963
 964       for (c = 0, s = output_bfd->sections; s != NULL; s = s->next)
 965         {
 966           if ((s->flags & SEC_LINKER_CREATED) != 0
 967               || (s->flags & SEC_ALLOC) == 0)
 968             {
 969               elf_section_data (s)->dynindx = -1;
 970               continue;
 971             }
 972
 973           /* These symbols will have no names, so we don't need to
 974              fiddle with dynstr_index.  */
 975
 976           elf_section_data (s)->dynindx = c + 1;
 977
 978           c++;
 979         }
 980
 981       elf_link_hash_traverse (elf_hash_table (info),
 982                               i370_elf_adjust_dynindx,
 983                               (PTR) &c);
 984       elf_hash_table (info)->dynsymcount += c;
 985     }
 986
 987   return true;
 988 }
 989 \f
 990 /* Look through the relocs for a section during the first phase, and
 991    allocate space in the global offset table or procedure linkage
 992    table.  */
 993 /* XXX hack alert bogus This routine is mostly all junk and almost
 994  * certainly does the wrong thing.  Its here simply because it does
 995  * just enough to allow glibc-2.1 ld.so to compile & link.
 996  */
 997
 998 static boolean
 999 i370_elf_check_relocs (abfd, info, sec, relocs)
1000      bfd *abfd;
1001      struct bfd_link_info *info;
1002      asection *sec;
1003      const Elf_Internal_Rela *relocs;
1004 {
1005   bfd *dynobj;
1006   Elf_Internal_Shdr *symtab_hdr;
1007   struct elf_link_hash_entry **sym_hashes;
1008   const Elf_Internal_Rela *rel;
1009   const Elf_Internal_Rela *rel_end;
1010   bfd_vma *local_got_offsets;
1011   asection *sreloc;
1012
1013   if (info->relocateable)
1014     return true;
1015
1016 #ifdef DEBUG
1017   fprintf (stderr, "i370_elf_check_relocs called for section %s in %s\n",
1018            bfd_get_section_name (abfd, sec),
1019            bfd_get_filename (abfd));
1020 #endif
1021
1022   dynobj = elf_hash_table (info)->dynobj;
1023   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1024   sym_hashes = elf_sym_hashes (abfd);
1025   local_got_offsets = elf_local_got_offsets (abfd);
1026
1027   sreloc = NULL;
1028
1029   rel_end = relocs + sec->reloc_count;
1030   for (rel = relocs; rel < rel_end; rel++)
1031     {
1032       unsigned long r_symndx;
1033       struct elf_link_hash_entry *h;
1034
1035       r_symndx = ELF32_R_SYM (rel->r_info);
1036       if (r_symndx < symtab_hdr->sh_info)
1037         h = NULL;
1038       else
1039         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1040
1041       if (info->shared)
1042         {
1043 #ifdef DEBUG
1044           fprintf (stderr,
1045                    "i370_elf_check_relocs needs to create relocation for %s\n",
1046                    (h && h->root.root.string)
1047                    ? h->root.root.string : "<unknown>");
1048 #endif
1049           if (sreloc == NULL)
1050             {
1051               const char *name;
1052
1053               name = (bfd_elf_string_from_elf_section
1054                       (abfd,
1055                        elf_elfheader (abfd)->e_shstrndx,
1056                        elf_section_data (sec)->rel_hdr.sh_name));
1057               if (name == NULL)
1058                 return false;
1059
1060               BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1061                           && strcmp (bfd_get_section_name (abfd, sec), name + 5) == 0);
1062
1063               sreloc = bfd_get_section_by_name (dynobj, name);
1064               if (sreloc == NULL)
1065                 {
1066                   flagword flags;
1067
1068                   sreloc = bfd_make_section (dynobj, name);
1069                   flags = (SEC_HAS_CONTENTS | SEC_READONLY
1070                            | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1071                   if ((sec->flags & SEC_ALLOC) != 0)
1072                     flags |= SEC_ALLOC | SEC_LOAD;
1073                   if (sreloc == NULL
1074                       || ! bfd_set_section_flags (dynobj, sreloc, flags)
1075                       || ! bfd_set_section_alignment (dynobj, sreloc, 2))
1076                     return false;
1077                 }
1078             }
1079
1080           sreloc->_raw_size += sizeof (Elf32_External_Rela);
1081
1082           /* FIXME: We should here do what the m68k and i386
1083              backends do: if the reloc is pc-relative, record it
1084              in case it turns out that the reloc is unnecessary
1085              because the symbol is forced local by versioning or
1086              we are linking with -Bdynamic.  Fortunately this
1087              case is not frequent.  */
1088         }
1089     }
1090
1091   return true;
1092 }
1093 \f
1094 /* Finish up the dynamic sections.  */
1095 /* XXX hack alert bogus This routine is mostly all junk and almost
1096  * certainly does the wrong thing.  Its here simply because it does
1097  * just enough to allow glibc-2.1 ld.so to compile & link.
1098  */
1099
1100 static boolean
1101 i370_elf_finish_dynamic_sections (output_bfd, info)
1102      bfd *output_bfd;
1103      struct bfd_link_info *info;
1104 {
1105   asection *sdyn;
1106   bfd *dynobj = elf_hash_table (info)->dynobj;
1107   asection *sgot = bfd_get_section_by_name (dynobj, ".got");
1108
1109 #ifdef DEBUG
1110   fprintf (stderr, "i370_elf_finish_dynamic_sections called\n");
1111 #endif
1112
1113   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1114
1115   if (elf_hash_table (info)->dynamic_sections_created)
1116     {
1117       asection *splt;
1118       Elf32_External_Dyn *dyncon, *dynconend;
1119
1120       splt = bfd_get_section_by_name (dynobj, ".plt");
1121       BFD_ASSERT (splt != NULL && sdyn != NULL);
1122
1123       dyncon = (Elf32_External_Dyn *) sdyn->contents;
1124       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1125       for (; dyncon < dynconend; dyncon++)
1126         {
1127           Elf_Internal_Dyn dyn;
1128           const char *name;
1129           boolean size;
1130
1131           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1132
1133           switch (dyn.d_tag)
1134             {
1135             case DT_PLTGOT:   name = ".plt";      size = false; break;
1136             case DT_PLTRELSZ: name = ".rela.plt"; size = true;  break;
1137             case DT_JMPREL:   name = ".rela.plt"; size = false; break;
1138             default:          name = NULL;        size = false; break;
1139             }
1140
1141           if (name != NULL)
1142             {
1143               asection *s;
1144
1145               s = bfd_get_section_by_name (output_bfd, name);
1146               if (s == NULL)
1147                 dyn.d_un.d_val = 0;
1148               else
1149                 {
1150                   if (! size)
1151                     dyn.d_un.d_ptr = s->vma;
1152                   else
1153                     {
1154                       if (s->_cooked_size != 0)
1155                         dyn.d_un.d_val = s->_cooked_size;
1156                       else
1157                         dyn.d_un.d_val = s->_raw_size;
1158                     }
1159                 }
1160               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1161             }
1162         }
1163     }
1164
1165   /* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4 so that a function can
1166      easily find the address of the _GLOBAL_OFFSET_TABLE_.  */
1167 /* XXX this is clearly very wrong for the 370 arch */
1168   if (sgot)
1169     {
1170       unsigned char *contents = sgot->contents;
1171       bfd_put_32 (output_bfd, 0x4e800021 /* blrl */, contents);
1172
1173       if (sdyn == NULL)
1174         bfd_put_32 (output_bfd, (bfd_vma) 0, contents+4);
1175       else
1176         bfd_put_32 (output_bfd,
1177                     sdyn->output_section->vma + sdyn->output_offset,
1178                     contents+4);
1179
1180       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1181     }
1182
1183   if (info->shared)
1184     {
1185       asection *sdynsym;
1186       asection *s;
1187       Elf_Internal_Sym sym;
1188       int maxdindx = 0;
1189
1190       /* Set up the section symbols for the output sections.  */
1191
1192       sdynsym = bfd_get_section_by_name (dynobj, ".dynsym");
1193       BFD_ASSERT (sdynsym != NULL);
1194
1195       sym.st_size = 0;
1196       sym.st_name = 0;
1197       sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
1198       sym.st_other = 0;
1199
1200       for (s = output_bfd->sections; s != NULL; s = s->next)
1201         {
1202           int indx, dindx;
1203
1204           sym.st_value = s->vma;
1205
1206           indx = elf_section_data (s)->this_idx;
1207           dindx = elf_section_data (s)->dynindx;
1208           if (dindx != -1)
1209             {
1210               BFD_ASSERT(indx > 0);
1211               BFD_ASSERT(dindx > 0);
1212
1213               if (dindx > maxdindx)
1214                 maxdindx = dindx;
1215
1216               sym.st_shndx = indx;
1217
1218               bfd_elf32_swap_symbol_out (output_bfd, &sym,
1219                                          (PTR) (((Elf32_External_Sym *)
1220                                                  sdynsym->contents)
1221                                                 + dindx));
1222             }
1223         }
1224
1225       /* Set the sh_info field of the output .dynsym section to the
1226          index of the first global symbol.  */
1227       elf_section_data (sdynsym->output_section)->this_hdr.sh_info =
1228         maxdindx + 1;
1229     }
1230
1231   return true;
1232 }
1233 \f
1234 /* The RELOCATE_SECTION function is called by the ELF backend linker
1235    to handle the relocations for a section.
1236
1237    The relocs are always passed as Rela structures; if the section
1238    actually uses Rel structures, the r_addend field will always be
1239    zero.
1240
1241    This function is responsible for adjust the section contents as
1242    necessary, and (if using Rela relocs and generating a
1243    relocateable output file) adjusting the reloc addend as
1244    necessary.
1245
1246    This function does not have to worry about setting the reloc
1247    address or the reloc symbol index.
1248
1249    LOCAL_SYMS is a pointer to the swapped in local symbols.
1250
1251    LOCAL_SECTIONS is an array giving the section in the input file
1252    corresponding to the st_shndx field of each local symbol.
1253
1254    The global hash table entry for the global symbols can be found
1255    via elf_sym_hashes (input_bfd).
1256
1257    When generating relocateable output, this function must handle
1258    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
1259    going to be the section symbol corresponding to the output
1260    section, which means that the addend must be adjusted
1261    accordingly.  */
1262
1263 static boolean
1264 i370_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1265                           contents, relocs, local_syms, local_sections)
1266      bfd *output_bfd;
1267      struct bfd_link_info *info;
1268      bfd *input_bfd;
1269      asection *input_section;
1270      bfd_byte *contents;
1271      Elf_Internal_Rela *relocs;
1272      Elf_Internal_Sym *local_syms;
1273      asection **local_sections;
1274 {
1275   Elf_Internal_Shdr *symtab_hdr           = &elf_tdata (input_bfd)->symtab_hdr;
1276   struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
1277   bfd *dynobj                             = elf_hash_table (info)->dynobj;
1278   Elf_Internal_Rela *rel                  = relocs;
1279   Elf_Internal_Rela *relend               = relocs + input_section->reloc_count;
1280   asection *sreloc                        = NULL;
1281   bfd_vma *local_got_offsets;
1282   boolean ret                             = true;
1283
1284 #ifdef DEBUG
1285   fprintf (stderr, "i370_elf_relocate_section called for %s section %s, %ld relocations%s\n",
1286            bfd_get_filename (input_bfd),
1287            bfd_section_name(input_bfd, input_section),
1288            (long)input_section->reloc_count,
1289            (info->relocateable) ? " (relocatable)" : "");
1290 #endif
1291
1292   if (!i370_elf_howto_table[ R_I370_ADDR31 ])   /* Initialize howto table if needed */
1293     i370_elf_howto_init ();
1294
1295   local_got_offsets = elf_local_got_offsets (input_bfd);
1296
1297   for (; rel < relend; rel++)
1298     {
1299       enum i370_reloc_type r_type       = (enum i370_reloc_type)ELF32_R_TYPE (rel->r_info);
1300       bfd_vma offset                    = rel->r_offset;
1301       bfd_vma addend                    = rel->r_addend;
1302       bfd_reloc_status_type r           = bfd_reloc_other;
1303       Elf_Internal_Sym *sym             = (Elf_Internal_Sym *)0;
1304       asection *sec                     = (asection *)0;
1305       struct elf_link_hash_entry *h     = (struct elf_link_hash_entry *)0;
1306       const char *sym_name              = (const char *)0;
1307       reloc_howto_type *howto;
1308       unsigned long r_symndx;
1309       bfd_vma relocation;
1310
1311       /* Unknown relocation handling */
1312       if ((unsigned)r_type >= (unsigned)R_I370_max
1313           || !i370_elf_howto_table[(int)r_type])
1314         {
1315           (*_bfd_error_handler) ("%s: unknown relocation type %d",
1316                                  bfd_get_filename (input_bfd),
1317                                  (int)r_type);
1318
1319           bfd_set_error (bfd_error_bad_value);
1320           ret = false;
1321           continue;
1322         }
1323
1324       howto = i370_elf_howto_table[(int)r_type];
1325       r_symndx = ELF32_R_SYM (rel->r_info);
1326
1327       if (info->relocateable)
1328         {
1329           /* This is a relocateable link.  We don't have to change
1330              anything, unless the reloc is against a section symbol,
1331              in which case we have to adjust according to where the
1332              section symbol winds up in the output section.  */
1333           if (r_symndx < symtab_hdr->sh_info)
1334             {
1335               sym = local_syms + r_symndx;
1336               if ((unsigned)ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1337                 {
1338                   sec = local_sections[r_symndx];
1339                   addend = rel->r_addend += sec->output_offset + sym->st_value;
1340                 }
1341             }
1342
1343 #ifdef DEBUG
1344           fprintf (stderr, "\ttype = %s (%d), symbol index = %ld, offset = %ld, addend = %ld\n",
1345                    howto->name,
1346                    (int)r_type,
1347                    r_symndx,
1348                    (long)offset,
1349                    (long)addend);
1350 #endif
1351           continue;
1352         }
1353
1354       /* This is a final link.  */
1355       if (r_symndx < symtab_hdr->sh_info)
1356         {
1357           sym = local_syms + r_symndx;
1358           sec = local_sections[r_symndx];
1359           sym_name = "<local symbol>";
1360
1361           relocation = (sec->output_section->vma
1362                         + sec->output_offset
1363                         + sym->st_value);
1364         }
1365       else
1366         {
1367           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1368           while (h->root.type == bfd_link_hash_indirect
1369                  || h->root.type == bfd_link_hash_warning)
1370             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1371           sym_name = h->root.root.string;
1372           if (h->root.type == bfd_link_hash_defined
1373               || h->root.type == bfd_link_hash_defweak)
1374             {
1375               sec = h->root.u.def.section;
1376               if (info->shared
1377                   && ((! info->symbolic && h->dynindx != -1)
1378                       || (h->elf_link_hash_flags
1379                           & ELF_LINK_HASH_DEF_REGULAR) == 0)
1380                   && (input_section->flags & SEC_ALLOC) != 0
1381                   && (r_type == R_I370_ADDR31
1382                       || r_type == R_I370_COPY
1383                       || r_type == R_I370_ADDR16
1384                       || r_type == R_I370_RELATIVE))
1385                 {
1386                   /* In these cases, we don't need the relocation
1387                      value.  We check specially because in some
1388                      obscure cases sec->output_section will be NULL.  */
1389                   relocation = 0;
1390                 }
1391               else
1392                 relocation = (h->root.u.def.value
1393                               + sec->output_section->vma
1394                               + sec->output_offset);
1395             }
1396           else if (h->root.type == bfd_link_hash_undefweak)
1397             relocation = 0;
1398           else if (info->shared
1399                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1400             relocation = 0;
1401           else
1402             {
1403               (*info->callbacks->undefined_symbol) (info,
1404                                                     h->root.root.string,
1405                                                     input_bfd,
1406                                                     input_section,
1407                                                     rel->r_offset,
1408                                                     true);
1409               ret = false;
1410               continue;
1411             }
1412         }
1413
1414       switch ((int)r_type)
1415         {
1416         default:
1417           (*_bfd_error_handler) ("%s: unknown relocation type %d for symbol %s",
1418                                  bfd_get_filename (input_bfd),
1419                                  (int)r_type, sym_name);
1420
1421           bfd_set_error (bfd_error_bad_value);
1422           ret = false;
1423           continue;
1424
1425         /* Relocations that may need to be propagated if this is a shared
1426            object.  */
1427         case (int)R_I370_REL31:
1428           /* If these relocations are not to a named symbol, they can be
1429              handled right here, no need to bother the dynamic linker.  */
1430           if (h == NULL
1431               || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1432             break;
1433         /* fall through */
1434
1435         /* Relocations that always need to be propagated if this is a shared
1436            object.  */
1437         case (int)R_I370_NONE:
1438         case (int)R_I370_ADDR31:
1439         case (int)R_I370_ADDR16:
1440           if (info->shared)
1441             {
1442               Elf_Internal_Rela outrel;
1443               boolean skip;
1444
1445 #ifdef DEBUG
1446               fprintf (stderr,
1447                        "i370_elf_relocate_section needs to create relocation for %s\n",
1448                        (h && h->root.root.string) ? h->root.root.string : "<unknown>");
1449 #endif
1450
1451               /* When generating a shared object, these relocations
1452                  are copied into the output file to be resolved at run
1453                  time.  */
1454
1455               if (sreloc == NULL)
1456                 {
1457                   const char *name;
1458
1459                   name = (bfd_elf_string_from_elf_section
1460                           (input_bfd,
1461                            elf_elfheader (input_bfd)->e_shstrndx,
1462                            elf_section_data (input_section)->rel_hdr.sh_name));
1463                   if (name == NULL)
1464                     return false;
1465
1466                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1467                               && strcmp (bfd_get_section_name (input_bfd,
1468                                                                input_section),
1469                                          name + 5) == 0);
1470
1471                   sreloc = bfd_get_section_by_name (dynobj, name);
1472                   BFD_ASSERT (sreloc != NULL);
1473                 }
1474
1475               skip = false;
1476
1477               if (elf_section_data (input_section)->stab_info == NULL)
1478                 outrel.r_offset = rel->r_offset;
1479               else
1480                 {
1481                   bfd_vma off;
1482
1483                   off = (_bfd_stab_section_offset
1484                          (output_bfd, &elf_hash_table (info)->stab_info,
1485                           input_section,
1486                           &elf_section_data (input_section)->stab_info,
1487                           rel->r_offset));
1488                   if (off == (bfd_vma) -1)
1489                     skip = true;
1490                   outrel.r_offset = off;
1491                 }
1492
1493               outrel.r_offset += (input_section->output_section->vma
1494                                   + input_section->output_offset);
1495
1496               if (skip)
1497                 memset (&outrel, 0, sizeof outrel);
1498               /* h->dynindx may be -1 if this symbol was marked to
1499                  become local.  */
1500               else if (h != NULL
1501                        && ((! info->symbolic && h->dynindx != -1)
1502                            || (h->elf_link_hash_flags
1503                                & ELF_LINK_HASH_DEF_REGULAR) == 0))
1504                 {
1505                   BFD_ASSERT (h->dynindx != -1);
1506                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1507                   outrel.r_addend = rel->r_addend;
1508                 }
1509               else
1510                 {
1511                   if (r_type == R_I370_ADDR31)
1512                     {
1513                       outrel.r_info = ELF32_R_INFO (0, R_I370_RELATIVE);
1514                       outrel.r_addend = relocation + rel->r_addend;
1515                     }
1516                   else
1517                     {
1518                       long indx;
1519
1520                       if (h == NULL)
1521                         sec = local_sections[r_symndx];
1522                       else
1523                         {
1524                           BFD_ASSERT (h->root.type == bfd_link_hash_defined
1525                                       || (h->root.type
1526                                           == bfd_link_hash_defweak));
1527                           sec = h->root.u.def.section;
1528                         }
1529                       if (sec != NULL && bfd_is_abs_section (sec))
1530                         indx = 0;
1531                       else if (sec == NULL || sec->owner == NULL)
1532                         {
1533                           bfd_set_error (bfd_error_bad_value);
1534                           return false;
1535                         }
1536                       else
1537                         {
1538                           asection *osec;
1539
1540                           osec = sec->output_section;
1541                           indx = elf_section_data (osec)->dynindx;
1542                           BFD_ASSERT(indx > 0);
1543 #ifdef DEBUG
1544                           if (indx <= 0)
1545                             {
1546                               printf ("indx=%d section=%s flags=%08x name=%s\n",
1547                                       indx, osec->name, osec->flags,
1548                                       h->root.root.string);
1549                             }
1550 #endif
1551                         }
1552
1553                       outrel.r_info = ELF32_R_INFO (indx, r_type);
1554                       outrel.r_addend = relocation + rel->r_addend;
1555                     }
1556                 }
1557
1558               bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1559                                          (((Elf32_External_Rela *)
1560                                            sreloc->contents)
1561                                           + sreloc->reloc_count));
1562               ++sreloc->reloc_count;
1563
1564               /* This reloc will be computed at runtime, so there's no
1565                  need to do anything now, unless this is a RELATIVE
1566                  reloc in an unallocated section.  */
1567               if (skip
1568                   || (input_section->flags & SEC_ALLOC) != 0
1569                   || ELF32_R_TYPE (outrel.r_info) != R_I370_RELATIVE)
1570                 continue;
1571             }
1572           break;
1573
1574         case (int)R_I370_COPY:
1575         case (int)R_I370_RELATIVE:
1576           (*_bfd_error_handler) ("%s: Relocation %s is not yet supported for symbol %s.",
1577                                  bfd_get_filename (input_bfd),
1578                                  i370_elf_howto_table[ (int)r_type ]->name,
1579                                  sym_name);
1580
1581           bfd_set_error (bfd_error_invalid_operation);
1582           ret = false;
1583           continue;
1584         }
1585
1586 #ifdef DEBUG
1587       fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, offset = %ld, addend = %ld\n",
1588                howto->name,
1589                (int)r_type,
1590                sym_name,
1591                r_symndx,
1592                (long)offset,
1593                (long)addend);
1594 #endif
1595
1596       r = _bfd_final_link_relocate (howto,
1597                                     input_bfd,
1598                                     input_section,
1599                                     contents,
1600                                     offset,
1601                                     relocation,
1602                                     addend);
1603
1604       if (r != bfd_reloc_ok)
1605         {
1606           ret = false;
1607           switch (r)
1608             {
1609             default:
1610               break;
1611
1612             case bfd_reloc_overflow:
1613               {
1614                 const char *name;
1615
1616                 if (h != NULL)
1617                   name = h->root.root.string;
1618                 else
1619                   {
1620                     name = bfd_elf_string_from_elf_section (input_bfd,
1621                                                             symtab_hdr->sh_link,
1622                                                             sym->st_name);
1623                     if (name == NULL)
1624                       break;
1625
1626                     if (*name == '\0')
1627                       name = bfd_section_name (input_bfd, sec);
1628                   }
1629
1630                 (*info->callbacks->reloc_overflow) (info,
1631                                                     name,
1632                                                     howto->name,
1633                                                     (bfd_vma) 0,
1634                                                     input_bfd,
1635                                                     input_section,
1636                                                     offset);
1637               }
1638               break;
1639
1640             }
1641         }
1642     }
1643
1644 #ifdef DEBUG
1645   fprintf (stderr, "\n");
1646 #endif
1647
1648   return ret;
1649 }
1650
1651 static void
1652 i370_elf_post_process_headers (abfd, link_info)
1653     bfd * abfd;
1654     struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
1655 {
1656   Elf_Internal_Ehdr * i_ehdrp;  /* Elf file header, internal form */
1657
1658   i_ehdrp = elf_elfheader (abfd);
1659   i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_LINUX;
1660 }
1661 \f
1662 #define TARGET_BIG_SYM          bfd_elf32_i370_vec
1663 #define TARGET_BIG_NAME         "elf32-i370"
1664 #define ELF_ARCH                bfd_arch_i370
1665 #define ELF_MACHINE_CODE        EM_S370
1666 #ifdef EM_I370_OLD
1667 #define ELF_MACHINE_ALT1        EM_I370_OLD
1668 #endif
1669 #define ELF_MAXPAGESIZE         0x1000
1670 #define elf_info_to_howto       i370_elf_info_to_howto
1671
1672 #define elf_backend_plt_not_loaded 1
1673 #define elf_backend_got_symbol_offset 4
1674
1675 #define bfd_elf32_bfd_reloc_type_lookup         i370_elf_reloc_type_lookup
1676 #define bfd_elf32_bfd_set_private_flags         i370_elf_set_private_flags
1677 #define bfd_elf32_bfd_copy_private_bfd_data     i370_elf_copy_private_bfd_data
1678 #define bfd_elf32_bfd_merge_private_bfd_data    i370_elf_merge_private_bfd_data
1679 #define elf_backend_relocate_section            i370_elf_relocate_section
1680
1681 /* dynamic loader support is mostly broken; just enough here to be able to
1682  * link glibc's ld.so without errors.
1683  */
1684 #define elf_backend_create_dynamic_sections     i370_elf_create_dynamic_sections
1685 #define elf_backend_size_dynamic_sections       i370_elf_size_dynamic_sections
1686 #define elf_backend_finish_dynamic_sections     i370_elf_finish_dynamic_sections
1687 #define elf_backend_fake_sections               i370_elf_fake_sections
1688 #define elf_backend_section_from_shdr           i370_elf_section_from_shdr
1689 #define elf_backend_adjust_dynamic_symbol       i370_elf_adjust_dynamic_symbol
1690 #define elf_backend_check_relocs                i370_elf_check_relocs
1691
1692 /*
1693 #define elf_backend_add_symbol_hook             i370_elf_add_symbol_hook
1694 #define elf_backend_finish_dynamic_symbol       i370_elf_finish_dynamic_symbol
1695 #define elf_backend_additional_program_headers  i370_elf_additional_program_headers
1696 #define elf_backend_modify_segment_map          i370_elf_modify_segment_map
1697 */
1698
1699 #define elf_backend_post_process_headers        i370_elf_post_process_headers
1700
1701 int i370_noop()
1702 {
1703   return 1;
1704 }
1705
1706 /* we need to define these at least as no-ops to link glibc ld.so */
1707
1708 #define elf_backend_add_symbol_hook \
1709   (boolean (*) PARAMS ((bfd *, struct bfd_link_info *, \
1710                         const Elf_Internal_Sym *, const char **, flagword *, \
1711                         asection **, bfd_vma *)))               i370_noop
1712 #define elf_backend_finish_dynamic_symbol \
1713   (boolean (*) PARAMS ((bfd *, struct bfd_link_info *, \
1714                         struct elf_link_hash_entry *, \
1715                         Elf_Internal_Sym *)))                   i370_noop
1716 #define elf_backend_additional_program_headers \
1717   (int (*) PARAMS ((bfd *)))                                    i370_noop
1718 #define elf_backend_modify_segment_map \
1719   (boolean (*) PARAMS ((bfd *)))                                i370_noop
1720
1721 #include "elf32-target.h"