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