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