bfd/elf32-i370.c

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