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