bfd/elf32-i370.c

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