bfd/elf32-i370.c

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