bfd/elf32-i370.c

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