bfd/elf32-i370.c

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