bfd/elf32-i370.c

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