bfd/elf32-i370.c

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