bfd/elf32-i370.c

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