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