bfd/elf32-i370.c

   1 /* i370-specific support for 32-bit ELF
   2    Copyright 1994, 1995, 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2004,
   3    2005, 2006, 2007, 2008, 2010  Free Software Foundation, Inc.
   4    Written by Ian Lance Taylor, Cygnus Support.
   5    Hacked by Linas Vepstas for i370 linas@linas.org
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  22    MA 02110-1301, USA.  */
  23
  24 /* This file is based on a preliminary PowerPC ELF ABI.
  25    But its been hacked on for the IBM 360/370 architectures.
  26    Basically, the 31bit relocation works, and just about everything
  27    else is a wild card.  In particular, don't expect shared libs or
  28    dynamic loading to work ...  its never been tested.  */
  29
  30 #include "sysdep.h"
  31 #include "bfd.h"
  32 #include "bfdlink.h"
  33 #include "libbfd.h"
  34 #include "elf-bfd.h"
  35 #include "elf/i370.h"
  36
  37 static reloc_howto_type *i370_elf_howto_table[ (int)R_I370_max ];
  38
  39 static reloc_howto_type i370_elf_howto_raw[] =
  40 {
  41   /* This reloc does nothing.  */
  42   HOWTO (R_I370_NONE,           /* type */
  43          0,                     /* rightshift */
  44          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  45          32,                    /* bitsize */
  46          FALSE,                 /* pc_relative */
  47          0,                     /* bitpos */
  48          complain_overflow_bitfield, /* complain_on_overflow */
  49          bfd_elf_generic_reloc, /* special_function */
  50          "R_I370_NONE",         /* name */
  51          FALSE,                 /* partial_inplace */
  52          0,                     /* src_mask */
  53          0,                     /* dst_mask */
  54          FALSE),                /* pcrel_offset */
  55
  56   /* A standard 31 bit relocation.  */
  57   HOWTO (R_I370_ADDR31,         /* type */
  58          0,                     /* rightshift */
  59          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  60          31,                    /* bitsize */
  61          FALSE,                 /* pc_relative */
  62          0,                     /* bitpos */
  63          complain_overflow_bitfield, /* complain_on_overflow */
  64          bfd_elf_generic_reloc, /* special_function */
  65          "R_I370_ADDR31",       /* name */
  66          FALSE,                 /* partial_inplace */
  67          0,                     /* src_mask */
  68          0x7fffffff,            /* dst_mask */
  69          FALSE),                /* pcrel_offset */
  70
  71   /* A standard 32 bit relocation.  */
  72   HOWTO (R_I370_ADDR32,         /* type */
  73          0,                     /* rightshift */
  74          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  75          32,                    /* bitsize */
  76          FALSE,                 /* pc_relative */
  77          0,                     /* bitpos */
  78          complain_overflow_bitfield, /* complain_on_overflow */
  79          bfd_elf_generic_reloc, /* special_function */
  80          "R_I370_ADDR32",       /* name */
  81          FALSE,                 /* partial_inplace */
  82          0,                     /* src_mask */
  83          0xffffffff,            /* dst_mask */
  84          FALSE),                /* pcrel_offset */
  85
  86   /* A standard 16 bit relocation.  */
  87   HOWTO (R_I370_ADDR16,         /* type */
  88          0,                     /* rightshift */
  89          1,                     /* size (0 = byte, 1 = short, 2 = long) */
  90          16,                    /* bitsize */
  91          FALSE,                 /* pc_relative */
  92          0,                     /* bitpos */
  93          complain_overflow_bitfield, /* complain_on_overflow */
  94          bfd_elf_generic_reloc, /* special_function */
  95          "R_I370_ADDR16",       /* name */
  96          FALSE,                 /* partial_inplace */
  97          0,                     /* src_mask */
  98          0xffff,                /* dst_mask */
  99          FALSE),                /* pcrel_offset */
 100
 101   /* 31-bit PC relative.  */
 102   HOWTO (R_I370_REL31,          /* type */
 103          0,                     /* rightshift */
 104          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 105          31,                    /* bitsize */
 106          TRUE,                  /* pc_relative */
 107          0,                     /* bitpos */
 108          complain_overflow_bitfield, /* complain_on_overflow */
 109          bfd_elf_generic_reloc, /* special_function */
 110          "R_I370_REL31",        /* name */
 111          FALSE,                 /* partial_inplace */
 112          0,                     /* src_mask */
 113          0x7fffffff,            /* dst_mask */
 114          TRUE),                 /* pcrel_offset */
 115
 116   /* 32-bit PC relative.  */
 117   HOWTO (R_I370_REL32,          /* type */
 118          0,                     /* rightshift */
 119          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 120          32,                    /* bitsize */
 121          TRUE,                  /* pc_relative */
 122          0,                     /* bitpos */
 123          complain_overflow_bitfield, /* complain_on_overflow */
 124          bfd_elf_generic_reloc, /* special_function */
 125          "R_I370_REL32",        /* name */
 126          FALSE,                 /* partial_inplace */
 127          0,                     /* src_mask */
 128          0xffffffff,            /* dst_mask */
 129          TRUE),                 /* pcrel_offset */
 130
 131   /* A standard 12 bit relocation.  */
 132   HOWTO (R_I370_ADDR12,         /* type */
 133          0,                     /* rightshift */
 134          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 135          12,                    /* bitsize */
 136          FALSE,                 /* pc_relative */
 137          0,                     /* bitpos */
 138          complain_overflow_bitfield, /* complain_on_overflow */
 139          bfd_elf_generic_reloc, /* special_function */
 140          "R_I370_ADDR12",       /* name */
 141          FALSE,                 /* partial_inplace */
 142          0,                     /* src_mask */
 143          0xfff,                 /* dst_mask */
 144          FALSE),                /* pcrel_offset */
 145
 146   /* 12-bit PC relative.  */
 147   HOWTO (R_I370_REL12,          /* type */
 148          0,                     /* rightshift */
 149          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 150          12,                    /* bitsize */
 151          TRUE,                  /* pc_relative */
 152          0,                     /* bitpos */
 153          complain_overflow_bitfield, /* complain_on_overflow */
 154          bfd_elf_generic_reloc, /* special_function */
 155          "R_I370_REL12",        /* name */
 156          FALSE,                 /* partial_inplace */
 157          0,                     /* src_mask */
 158          0xfff,                 /* dst_mask */
 159          TRUE),                 /* pcrel_offset */
 160
 161   /* A standard 8 bit relocation.  */
 162   HOWTO (R_I370_ADDR8,          /* type */
 163          0,                     /* rightshift */
 164          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 165          8,                     /* bitsize */
 166          FALSE,                 /* pc_relative */
 167          0,                     /* bitpos */
 168          complain_overflow_bitfield, /* complain_on_overflow */
 169          bfd_elf_generic_reloc, /* special_function */
 170          "R_I370_ADDR8",        /* name */
 171          FALSE,                 /* partial_inplace */
 172          0,                     /* src_mask */
 173          0xff,                  /* dst_mask */
 174          FALSE),                /* pcrel_offset */
 175
 176   /* 8-bit PC relative.  */
 177   HOWTO (R_I370_REL8,           /* type */
 178          0,                     /* rightshift */
 179          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 180          8,                     /* bitsize */
 181          TRUE,                  /* pc_relative */
 182          0,                     /* bitpos */
 183          complain_overflow_bitfield, /* complain_on_overflow */
 184          bfd_elf_generic_reloc, /* special_function */
 185          "R_I370_REL8",         /* name */
 186          FALSE,                 /* partial_inplace */
 187          0,                     /* src_mask */
 188          0xff,                  /* dst_mask */
 189          TRUE),                 /* pcrel_offset */
 190
 191   /* This is used only by the dynamic linker.  The symbol should exist
 192      both in the object being run and in some shared library.  The
 193      dynamic linker copies the data addressed by the symbol from the
 194      shared library into the object, because the object being
 195      run has to have the data at some particular address.  */
 196   HOWTO (R_I370_COPY,           /* type */
 197          0,                     /* rightshift */
 198          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 199          32,                    /* bitsize */
 200          FALSE,                 /* pc_relative */
 201          0,                     /* bitpos */
 202          complain_overflow_bitfield, /* complain_on_overflow */
 203          bfd_elf_generic_reloc,  /* special_function */
 204          "R_I370_COPY",         /* name */
 205          FALSE,                 /* partial_inplace */
 206          0,                     /* src_mask */
 207          0,                     /* dst_mask */
 208          FALSE),                /* pcrel_offset */
 209
 210   /* Used only by the dynamic linker.  When the object is run, this
 211      longword is set to the load address of the object, plus the
 212      addend.  */
 213   HOWTO (R_I370_RELATIVE,       /* type */
 214          0,                     /* rightshift */
 215          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 216          32,                    /* bitsize */
 217          FALSE,                 /* pc_relative */
 218          0,                     /* bitpos */
 219          complain_overflow_bitfield, /* complain_on_overflow */
 220          bfd_elf_generic_reloc,  /* special_function */
 221          "R_I370_RELATIVE",     /* name */
 222          FALSE,                 /* partial_inplace */
 223          0,                     /* src_mask */
 224          0xffffffff,            /* dst_mask */
 225          FALSE),                /* pcrel_offset */
 226
 227 };
 228 \f
 229 /* Initialize the i370_elf_howto_table, so that linear accesses can be done.  */
 230
 231 static void
 232 i370_elf_howto_init (void)
 233 {
 234   unsigned int i, type;
 235
 236   for (i = 0; i < sizeof (i370_elf_howto_raw) / sizeof (i370_elf_howto_raw[0]); i++)
 237     {
 238       type = i370_elf_howto_raw[i].type;
 239       BFD_ASSERT (type < sizeof (i370_elf_howto_table) / sizeof (i370_elf_howto_table[0]));
 240       i370_elf_howto_table[type] = &i370_elf_howto_raw[i];
 241     }
 242 }
 243
 244 static reloc_howto_type *
 245 i370_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 246                             bfd_reloc_code_real_type code)
 247 {
 248   enum i370_reloc_type i370_reloc = R_I370_NONE;
 249
 250   if (!i370_elf_howto_table[ R_I370_ADDR31 ])
 251     /* Initialize howto table if needed.  */
 252     i370_elf_howto_init ();
 253
 254   switch ((int) code)
 255     {
 256     default:
 257       return NULL;
 258
 259     case BFD_RELOC_NONE:        i370_reloc = R_I370_NONE;       break;
 260     case BFD_RELOC_32:          i370_reloc = R_I370_ADDR31;     break;
 261     case BFD_RELOC_16:          i370_reloc = R_I370_ADDR16;     break;
 262     case BFD_RELOC_32_PCREL:    i370_reloc = R_I370_REL31;      break;
 263     case BFD_RELOC_CTOR:        i370_reloc = R_I370_ADDR31;     break;
 264     case BFD_RELOC_I370_D12:    i370_reloc = R_I370_ADDR12;     break;
 265     }
 266
 267   return i370_elf_howto_table[ (int)i370_reloc ];
 268 };
 269
 270 static reloc_howto_type *
 271 i370_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 272                             const char *r_name)
 273 {
 274   unsigned int i;
 275
 276   for (i = 0;
 277        i < sizeof (i370_elf_howto_raw) / sizeof (i370_elf_howto_raw[0]);
 278        i++)
 279     if (i370_elf_howto_raw[i].name != NULL
 280         && strcasecmp (i370_elf_howto_raw[i].name, r_name) == 0)
 281       return &i370_elf_howto_raw[i];
 282
 283   return NULL;
 284 }
 285
 286 /* The name of the dynamic interpreter.  This is put in the .interp
 287     section.  */
 288
 289 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
 290
 291 /* Set the howto pointer for an i370 ELF reloc.  */
 292
 293 static void
 294 i370_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
 295                         arelent *cache_ptr,
 296                         Elf_Internal_Rela *dst)
 297 {
 298   if (!i370_elf_howto_table[ R_I370_ADDR31 ])
 299     /* Initialize howto table.  */
 300     i370_elf_howto_init ();
 301
 302   BFD_ASSERT (ELF32_R_TYPE (dst->r_info) < (unsigned int) R_I370_max);
 303   cache_ptr->howto = i370_elf_howto_table[ELF32_R_TYPE (dst->r_info)];
 304 }
 305
 306 /* Hack alert --  the following several routines look generic to me ...
 307    why are we bothering with them ?  */
 308 /* Function to set whether a module needs the -mrelocatable bit set.  */
 309
 310 static bfd_boolean
 311 i370_elf_set_private_flags (bfd *abfd, flagword flags)
 312 {
 313   BFD_ASSERT (!elf_flags_init (abfd)
 314               || elf_elfheader (abfd)->e_flags == flags);
 315
 316   elf_elfheader (abfd)->e_flags = flags;
 317   elf_flags_init (abfd) = TRUE;
 318   return TRUE;
 319 }
 320
 321 /* Merge backend specific data from an object file to the output
 322    object file when linking.  */
 323
 324 static bfd_boolean
 325 i370_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
 326 {
 327   flagword old_flags;
 328   flagword new_flags;
 329
 330   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
 331       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
 332     return TRUE;
 333
 334   new_flags = elf_elfheader (ibfd)->e_flags;
 335   old_flags = elf_elfheader (obfd)->e_flags;
 336   if (!elf_flags_init (obfd))   /* First call, no flags set.  */
 337     {
 338       elf_flags_init (obfd) = TRUE;
 339       elf_elfheader (obfd)->e_flags = new_flags;
 340     }
 341
 342   else if (new_flags == old_flags)      /* Compatible flags are ok.  */
 343     ;
 344
 345   else                                  /* Incompatible flags.  */
 346     {
 347       (*_bfd_error_handler)
 348         ("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)",
 349          ibfd, (long) new_flags, (long) old_flags);
 350
 351       bfd_set_error (bfd_error_bad_value);
 352       return FALSE;
 353     }
 354
 355   return TRUE;
 356 }
 357 \f
 358 /* Handle an i370 specific section when reading an object file.  This
 359    is called when elfcode.h finds a section with an unknown type.  */
 360 /* XXX hack alert bogus This routine is mostly all junk and almost
 361    certainly does the wrong thing.  Its here simply because it does
 362    just enough to allow glibc-2.1 ld.so to compile & link.  */
 363
 364 static bfd_boolean
 365 i370_elf_section_from_shdr (bfd *abfd,
 366                             Elf_Internal_Shdr *hdr,
 367                             const char *name,
 368                             int shindex)
 369 {
 370   asection *newsect;
 371   flagword flags;
 372
 373   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
 374     return FALSE;
 375
 376   newsect = hdr->bfd_section;
 377   flags = bfd_get_section_flags (abfd, newsect);
 378   if (hdr->sh_type == SHT_ORDERED)
 379     flags |= SEC_SORT_ENTRIES;
 380
 381   bfd_set_section_flags (abfd, newsect, flags);
 382   return TRUE;
 383 }
 384 \f
 385 /* Set up any other section flags and such that may be necessary.  */
 386 /* XXX hack alert bogus This routine is mostly all junk and almost
 387    certainly does the wrong thing.  Its here simply because it does
 388    just enough to allow glibc-2.1 ld.so to compile & link.  */
 389
 390 static bfd_boolean
 391 i370_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
 392                         Elf_Internal_Shdr *shdr,
 393                         asection *asect)
 394 {
 395   if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE)
 396     shdr->sh_flags |= SHF_EXCLUDE;
 397
 398   if ((asect->flags & SEC_SORT_ENTRIES) != 0)
 399     shdr->sh_type = SHT_ORDERED;
 400
 401   return TRUE;
 402 }
 403 \f
 404 /* We have to create .dynsbss and .rela.sbss here so that they get mapped
 405    to output sections (just like _bfd_elf_create_dynamic_sections has
 406    to create .dynbss and .rela.bss).  */
 407 /* XXX hack alert bogus This routine is mostly all junk and almost
 408    certainly does the wrong thing.  Its here simply because it does
 409    just enough to allow glibc-2.1 ld.so to compile & link.  */
 410
 411 static bfd_boolean
 412 i370_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
 413 {
 414   asection *s;
 415   flagword flags;
 416
 417   if (!_bfd_elf_create_dynamic_sections(abfd, info))
 418     return FALSE;
 419
 420   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
 421            | SEC_LINKER_CREATED);
 422
 423   s = bfd_make_section_with_flags (abfd, ".dynsbss",
 424                                    SEC_ALLOC | SEC_LINKER_CREATED);
 425   if (s == NULL)
 426     return FALSE;
 427
 428   if (! info->shared)
 429     {
 430       s = bfd_make_section_with_flags (abfd, ".rela.sbss",
 431                                        flags | SEC_READONLY);
 432       if (s == NULL
 433           || ! bfd_set_section_alignment (abfd, s, 2))
 434         return FALSE;
 435     }
 436
 437    /* XXX beats me, seem to need a rela.text ...  */
 438    s = bfd_make_section_with_flags (abfd, ".rela.text",
 439                                     flags | SEC_READONLY);
 440    if (s == NULL
 441       || ! bfd_set_section_alignment (abfd, s, 2))
 442     return FALSE;
 443   return TRUE;
 444 }
 445
 446 /* Adjust a symbol defined by a dynamic object and referenced by a
 447    regular object.  The current definition is in some section of the
 448    dynamic object, but we're not including those sections.  We have to
 449    change the definition to something the rest of the link can
 450    understand.  */
 451 /* XXX hack alert bogus This routine is mostly all junk and almost
 452    certainly does the wrong thing.  Its here simply because it does
 453    just enough to allow glibc-2.1 ld.so to compile & link.  */
 454
 455 static bfd_boolean
 456 i370_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
 457                                 struct elf_link_hash_entry *h)
 458 {
 459   bfd *dynobj = elf_hash_table (info)->dynobj;
 460   asection *s;
 461
 462 #ifdef DEBUG
 463   fprintf (stderr, "i370_elf_adjust_dynamic_symbol called for %s\n",
 464            h->root.root.string);
 465 #endif
 466
 467   /* Make sure we know what is going on here.  */
 468   BFD_ASSERT (dynobj != NULL
 469               && (h->needs_plt
 470                   || h->u.weakdef != NULL
 471                   || (h->def_dynamic
 472                       && h->ref_regular
 473                       && !h->def_regular)));
 474
 475   s = bfd_get_section_by_name (dynobj, ".rela.text");
 476   BFD_ASSERT (s != NULL);
 477   s->size += sizeof (Elf32_External_Rela);
 478
 479   /* If this is a weak symbol, and there is a real definition, the
 480      processor independent code will have arranged for us to see the
 481      real definition first, and we can just use the same value.  */
 482   if (h->u.weakdef != NULL)
 483     {
 484       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
 485                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
 486       h->root.u.def.section = h->u.weakdef->root.u.def.section;
 487       h->root.u.def.value = h->u.weakdef->root.u.def.value;
 488       return TRUE;
 489     }
 490
 491   /* This is a reference to a symbol defined by a dynamic object which
 492      is not a function.  */
 493
 494   /* If we are creating a shared library, we must presume that the
 495      only references to the symbol are via the global offset table.
 496      For such cases we need not do anything here; the relocations will
 497      be handled correctly by relocate_section.  */
 498   if (info->shared)
 499     return TRUE;
 500
 501   if (h->size == 0)
 502     {
 503       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
 504                              h->root.root.string);
 505       return TRUE;
 506     }
 507
 508   /* We must allocate the symbol in our .dynbss section, which will
 509      become part of the .bss section of the executable.  There will be
 510      an entry for this symbol in the .dynsym section.  The dynamic
 511      object will contain position independent code, so all references
 512      from the dynamic object to this symbol will go through the global
 513      offset table.  The dynamic linker will use the .dynsym entry to
 514      determine the address it must put in the global offset table, so
 515      both the dynamic object and the regular object will refer to the
 516      same memory location for the variable.
 517
 518      Of course, if the symbol is sufficiently small, we must instead
 519      allocate it in .sbss.  FIXME: It would be better to do this if and
 520      only if there were actually SDAREL relocs for that symbol.  */
 521
 522   if (h->size <= elf_gp_size (dynobj))
 523     s = bfd_get_section_by_name (dynobj, ".dynsbss");
 524   else
 525     s = bfd_get_section_by_name (dynobj, ".dynbss");
 526   BFD_ASSERT (s != NULL);
 527
 528   /* We must generate a R_I370_COPY reloc to tell the dynamic linker to
 529      copy the initial value out of the dynamic object and into the
 530      runtime process image.  We need to remember the offset into the
 531      .rela.bss section we are going to use.  */
 532   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
 533     {
 534       asection *srel;
 535
 536       if (h->size <= elf_gp_size (dynobj))
 537         srel = bfd_get_section_by_name (dynobj, ".rela.sbss");
 538       else
 539         srel = bfd_get_section_by_name (dynobj, ".rela.bss");
 540       BFD_ASSERT (srel != NULL);
 541       srel->size += sizeof (Elf32_External_Rela);
 542       h->needs_copy = 1;
 543     }
 544
 545   return _bfd_elf_adjust_dynamic_copy (h, s);
 546 }
 547 \f
 548 /* Increment the index of a dynamic symbol by a given amount.  Called
 549    via elf_link_hash_traverse.  */
 550 /* XXX hack alert bogus This routine is mostly all junk and almost
 551    certainly does the wrong thing.  Its here simply because it does
 552    just enough to allow glibc-2.1 ld.so to compile & link.  */
 553
 554 static bfd_boolean
 555 i370_elf_adjust_dynindx (struct elf_link_hash_entry *h, void * cparg)
 556 {
 557   int *cp = (int *) cparg;
 558
 559 #ifdef DEBUG
 560   fprintf (stderr,
 561            "i370_elf_adjust_dynindx called, h->dynindx = %ld, *cp = %d\n",
 562            h->dynindx, *cp);
 563 #endif
 564
 565   if (h->root.type == bfd_link_hash_warning)
 566     h = (struct elf_link_hash_entry *) h->root.u.i.link;
 567
 568   if (h->dynindx != -1)
 569     h->dynindx += *cp;
 570
 571   return TRUE;
 572 }
 573 \f
 574 /* Set the sizes of the dynamic sections.  */
 575 /* XXX hack alert bogus This routine is mostly all junk and almost
 576    certainly does the wrong thing.  Its here simply because it does
 577    just enough to allow glibc-2.1 ld.so to compile & link.  */
 578
 579 static bfd_boolean
 580 i370_elf_size_dynamic_sections (bfd *output_bfd,
 581                                 struct bfd_link_info *info)
 582 {
 583   bfd *dynobj;
 584   asection *s;
 585   bfd_boolean plt;
 586   bfd_boolean relocs;
 587   bfd_boolean reltext;
 588
 589 #ifdef DEBUG
 590   fprintf (stderr, "i370_elf_size_dynamic_sections called\n");
 591 #endif
 592
 593   dynobj = elf_hash_table (info)->dynobj;
 594   BFD_ASSERT (dynobj != NULL);
 595
 596   if (elf_hash_table (info)->dynamic_sections_created)
 597     {
 598       /* Set the contents of the .interp section to the interpreter.  */
 599       if (info->executable)
 600         {
 601           s = bfd_get_section_by_name (dynobj, ".interp");
 602           BFD_ASSERT (s != NULL);
 603           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
 604           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
 605         }
 606     }
 607   else
 608     {
 609       /* We may have created entries in the .rela.got, .rela.sdata, and
 610          .rela.sdata2 sections.  However, if we are not creating the
 611          dynamic sections, we will not actually use these entries.  Reset
 612          the size of .rela.got, et al, which will cause it to get
 613          stripped from the output file below.  */
 614       static char *rela_sections[] = { ".rela.got", ".rela.sdata",
 615                                        ".rela.sdata2", ".rela.sbss",
 616                                        NULL };
 617       char **p;
 618
 619       for (p = rela_sections; *p != NULL; p++)
 620         {
 621           s = bfd_get_section_by_name (dynobj, *p);
 622           if (s != NULL)
 623             s->size = 0;
 624         }
 625     }
 626
 627   /* The check_relocs and adjust_dynamic_symbol entry points have
 628      determined the sizes of the various dynamic sections.  Allocate
 629      memory for them.  */
 630   plt = FALSE;
 631   relocs = FALSE;
 632   reltext = FALSE;
 633   for (s = dynobj->sections; s != NULL; s = s->next)
 634     {
 635       const char *name;
 636
 637       if ((s->flags & SEC_LINKER_CREATED) == 0)
 638         continue;
 639
 640       /* It's OK to base decisions on the section name, because none
 641          of the dynobj section names depend upon the input files.  */
 642       name = bfd_get_section_name (dynobj, s);
 643
 644       if (strcmp (name, ".plt") == 0)
 645         {
 646           /* Remember whether there is a PLT.  */
 647           plt = s->size != 0;
 648         }
 649       else if (CONST_STRNEQ (name, ".rela"))
 650         {
 651           if (s->size != 0)
 652             {
 653               asection *target;
 654               const char *outname;
 655
 656               /* Remember whether there are any relocation sections.  */
 657               relocs = TRUE;
 658
 659               /* If this relocation section applies to a read only
 660                  section, then we probably need a DT_TEXTREL entry.  */
 661               outname = bfd_get_section_name (output_bfd,
 662                                               s->output_section);
 663               target = bfd_get_section_by_name (output_bfd, outname + 5);
 664               if (target != NULL
 665                   && (target->flags & SEC_READONLY) != 0
 666                   && (target->flags & SEC_ALLOC) != 0)
 667                 reltext = TRUE;
 668
 669               /* We use the reloc_count field as a counter if we need
 670                  to copy relocs into the output file.  */
 671               s->reloc_count = 0;
 672             }
 673         }
 674       else if (strcmp (name, ".got") != 0
 675                && strcmp (name, ".sdata") != 0
 676                && strcmp (name, ".sdata2") != 0
 677                && strcmp (name, ".dynbss") != 0
 678                && strcmp (name, ".dynsbss") != 0)
 679         {
 680           /* It's not one of our sections, so don't allocate space.  */
 681           continue;
 682         }
 683
 684       if (s->size == 0)
 685         {
 686           /* If we don't need this section, strip it from the
 687              output file.  This is mostly to handle .rela.bss and
 688              .rela.plt.  We must create both sections in
 689              create_dynamic_sections, because they must be created
 690              before the linker maps input sections to output
 691              sections.  The linker does that before
 692              adjust_dynamic_symbol is called, and it is that
 693              function which decides whether anything needs to go
 694              into these sections.  */
 695           s->flags |= SEC_EXCLUDE;
 696           continue;
 697         }
 698
 699       if ((s->flags & SEC_HAS_CONTENTS) == 0)
 700         continue;
 701
 702       /* Allocate memory for the section contents.  */
 703       s->contents = bfd_zalloc (dynobj, s->size);
 704       if (s->contents == NULL)
 705         return FALSE;
 706     }
 707
 708   if (elf_hash_table (info)->dynamic_sections_created)
 709     {
 710       /* Add some entries to the .dynamic section.  We fill in the
 711          values later, in i370_elf_finish_dynamic_sections, but we
 712          must add the entries now so that we get the correct size for
 713          the .dynamic section.  The DT_DEBUG entry is filled in by the
 714          dynamic linker and used by the debugger.  */
 715 #define add_dynamic_entry(TAG, VAL) \
 716   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
 717
 718       if (!info->shared)
 719         {
 720           if (!add_dynamic_entry (DT_DEBUG, 0))
 721             return FALSE;
 722         }
 723
 724       if (plt)
 725         {
 726           if (!add_dynamic_entry (DT_PLTGOT, 0)
 727               || !add_dynamic_entry (DT_PLTRELSZ, 0)
 728               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
 729               || !add_dynamic_entry (DT_JMPREL, 0))
 730             return FALSE;
 731         }
 732
 733       if (relocs)
 734         {
 735           if (!add_dynamic_entry (DT_RELA, 0)
 736               || !add_dynamic_entry (DT_RELASZ, 0)
 737               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
 738             return FALSE;
 739         }
 740
 741       if (reltext)
 742         {
 743           if (!add_dynamic_entry (DT_TEXTREL, 0))
 744             return FALSE;
 745           info->flags |= DF_TEXTREL;
 746         }
 747     }
 748 #undef add_dynamic_entry
 749
 750   /* If we are generating a shared library, we generate a section
 751      symbol for each output section.  These are local symbols, which
 752      means that they must come first in the dynamic symbol table.
 753      That means we must increment the dynamic symbol index of every
 754      other dynamic symbol.
 755
 756      FIXME: We assume that there will never be relocations to
 757      locations in linker-created sections that do not have
 758      externally-visible names. Instead, we should work out precisely
 759      which sections relocations are targeted at.  */
 760   if (info->shared)
 761     {
 762       int c;
 763
 764       for (c = 0, s = output_bfd->sections; s != NULL; s = s->next)
 765         {
 766           if ((s->flags & SEC_LINKER_CREATED) != 0
 767               || (s->flags & SEC_ALLOC) == 0)
 768             {
 769               elf_section_data (s)->dynindx = -1;
 770               continue;
 771             }
 772
 773           /* These symbols will have no names, so we don't need to
 774              fiddle with dynstr_index.  */
 775
 776           elf_section_data (s)->dynindx = c + 1;
 777
 778           c++;
 779         }
 780
 781       elf_link_hash_traverse (elf_hash_table (info),
 782                               i370_elf_adjust_dynindx, & c);
 783       elf_hash_table (info)->dynsymcount += c;
 784     }
 785
 786   return TRUE;
 787 }
 788 \f
 789 /* Look through the relocs for a section during the first phase, and
 790    allocate space in the global offset table or procedure linkage
 791    table.  */
 792 /* XXX hack alert bogus This routine is mostly all junk and almost
 793    certainly does the wrong thing.  Its here simply because it does
 794    just enough to allow glibc-2.1 ld.so to compile & link.  */
 795
 796 static bfd_boolean
 797 i370_elf_check_relocs (bfd *abfd,
 798                        struct bfd_link_info *info,
 799                        asection *sec,
 800                        const Elf_Internal_Rela *relocs)
 801 {
 802   bfd *dynobj;
 803   Elf_Internal_Shdr *symtab_hdr;
 804   struct elf_link_hash_entry **sym_hashes;
 805   const Elf_Internal_Rela *rel;
 806   const Elf_Internal_Rela *rel_end;
 807   asection *sreloc;
 808
 809   if (info->relocatable)
 810     return TRUE;
 811
 812 #ifdef DEBUG
 813   _bfd_error_handler ("i370_elf_check_relocs called for section %A in %B",
 814                       sec, abfd);
 815 #endif
 816
 817   dynobj = elf_hash_table (info)->dynobj;
 818   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 819   sym_hashes = elf_sym_hashes (abfd);
 820
 821   sreloc = NULL;
 822
 823   rel_end = relocs + sec->reloc_count;
 824   for (rel = relocs; rel < rel_end; rel++)
 825     {
 826       unsigned long r_symndx;
 827       struct elf_link_hash_entry *h;
 828
 829       r_symndx = ELF32_R_SYM (rel->r_info);
 830       if (r_symndx < symtab_hdr->sh_info)
 831         h = NULL;
 832       else
 833         {
 834           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 835           while (h->root.type == bfd_link_hash_indirect
 836                  || h->root.type == bfd_link_hash_warning)
 837             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 838         }
 839
 840       if (info->shared)
 841         {
 842 #ifdef DEBUG
 843           fprintf (stderr,
 844                    "i370_elf_check_relocs needs to create relocation for %s\n",
 845                    (h && h->root.root.string)
 846                    ? h->root.root.string : "<unknown>");
 847 #endif
 848           if (sreloc == NULL)
 849             {
 850               sreloc = _bfd_elf_make_dynamic_reloc_section
 851                 (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
 852
 853               if (sreloc == NULL)
 854                 return FALSE;
 855             }
 856
 857           sreloc->size += sizeof (Elf32_External_Rela);
 858
 859           /* FIXME: We should here do what the m68k and i386
 860              backends do: if the reloc is pc-relative, record it
 861              in case it turns out that the reloc is unnecessary
 862              because the symbol is forced local by versioning or
 863              we are linking with -Bdynamic.  Fortunately this
 864              case is not frequent.  */
 865         }
 866     }
 867
 868   return TRUE;
 869 }
 870 \f
 871 /* Finish up the dynamic sections.  */
 872 /* XXX hack alert bogus This routine is mostly all junk and almost
 873    certainly does the wrong thing.  Its here simply because it does
 874    just enough to allow glibc-2.1 ld.so to compile & link.  */
 875
 876 static bfd_boolean
 877 i370_elf_finish_dynamic_sections (bfd *output_bfd,
 878                                   struct bfd_link_info *info)
 879 {
 880   asection *sdyn;
 881   bfd *dynobj = elf_hash_table (info)->dynobj;
 882   asection *sgot = bfd_get_section_by_name (dynobj, ".got");
 883
 884 #ifdef DEBUG
 885   fprintf (stderr, "i370_elf_finish_dynamic_sections called\n");
 886 #endif
 887
 888   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
 889
 890   if (elf_hash_table (info)->dynamic_sections_created)
 891     {
 892       asection *splt;
 893       Elf32_External_Dyn *dyncon, *dynconend;
 894
 895       splt = bfd_get_section_by_name (dynobj, ".plt");
 896       BFD_ASSERT (splt != NULL && sdyn != NULL);
 897
 898       dyncon = (Elf32_External_Dyn *) sdyn->contents;
 899       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
 900       for (; dyncon < dynconend; dyncon++)
 901         {
 902           Elf_Internal_Dyn dyn;
 903           const char *name;
 904           bfd_boolean size;
 905
 906           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
 907
 908           switch (dyn.d_tag)
 909             {
 910             case DT_PLTGOT:   name = ".plt";      size = FALSE; break;
 911             case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE;  break;
 912             case DT_JMPREL:   name = ".rela.plt"; size = FALSE; break;
 913             default:          name = NULL;        size = FALSE; break;
 914             }
 915
 916           if (name != NULL)
 917             {
 918               asection *s;
 919
 920               s = bfd_get_section_by_name (output_bfd, name);
 921               if (s == NULL)
 922                 dyn.d_un.d_val = 0;
 923               else
 924                 {
 925                   if (! size)
 926                     dyn.d_un.d_ptr = s->vma;
 927                   else
 928                     dyn.d_un.d_val = s->size;
 929                 }
 930               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
 931             }
 932         }
 933     }
 934
 935   if (sgot && sgot->size != 0)
 936     {
 937       unsigned char *contents = sgot->contents;
 938
 939       if (sdyn == NULL)
 940         bfd_put_32 (output_bfd, (bfd_vma) 0, contents);
 941       else
 942         bfd_put_32 (output_bfd,
 943                     sdyn->output_section->vma + sdyn->output_offset,
 944                     contents);
 945
 946       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
 947     }
 948
 949   if (info->shared)
 950     {
 951       asection *sdynsym;
 952       asection *s;
 953       Elf_Internal_Sym sym;
 954       int maxdindx = 0;
 955
 956       /* Set up the section symbols for the output sections.  */
 957
 958       sdynsym = bfd_get_section_by_name (dynobj, ".dynsym");
 959       BFD_ASSERT (sdynsym != NULL);
 960
 961       sym.st_size = 0;
 962       sym.st_name = 0;
 963       sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
 964       sym.st_other = 0;
 965       sym.st_target_internal = 0;
 966
 967       for (s = output_bfd->sections; s != NULL; s = s->next)
 968         {
 969           int indx, dindx;
 970           Elf32_External_Sym *esym;
 971
 972           sym.st_value = s->vma;
 973
 974           indx = elf_section_data (s)->this_idx;
 975           dindx = elf_section_data (s)->dynindx;
 976           if (dindx != -1)
 977             {
 978               BFD_ASSERT(indx > 0);
 979               BFD_ASSERT(dindx > 0);
 980
 981               if (dindx > maxdindx)
 982                 maxdindx = dindx;
 983
 984               sym.st_shndx = indx;
 985
 986               esym = (Elf32_External_Sym *) sdynsym->contents + dindx;
 987               bfd_elf32_swap_symbol_out (output_bfd, &sym, esym, NULL);
 988             }
 989         }
 990
 991       /* Set the sh_info field of the output .dynsym section to the
 992          index of the first global symbol.  */
 993       elf_section_data (sdynsym->output_section)->this_hdr.sh_info =
 994         maxdindx + 1;
 995     }
 996
 997   return TRUE;
 998 }
 999 \f
1000 /* The RELOCATE_SECTION function is called by the ELF backend linker
1001    to handle the relocations for a section.
1002
1003    The relocs are always passed as Rela structures; if the section
1004    actually uses Rel structures, the r_addend field will always be
1005    zero.
1006
1007    This function is responsible for adjust the section contents as
1008    necessary, and (if using Rela relocs and generating a
1009    relocatable output file) adjusting the reloc addend as
1010    necessary.
1011
1012    This function does not have to worry about setting the reloc
1013    address or the reloc symbol index.
1014
1015    LOCAL_SYMS is a pointer to the swapped in local symbols.
1016
1017    LOCAL_SECTIONS is an array giving the section in the input file
1018    corresponding to the st_shndx field of each local symbol.
1019
1020    The global hash table entry for the global symbols can be found
1021    via elf_sym_hashes (input_bfd).
1022
1023    When generating relocatable output, this function must handle
1024    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
1025    going to be the section symbol corresponding to the output
1026    section, which means that the addend must be adjusted
1027    accordingly.  */
1028
1029 static bfd_boolean
1030 i370_elf_relocate_section (bfd *output_bfd,
1031                            struct bfd_link_info *info,
1032                            bfd *input_bfd,
1033                            asection *input_section,
1034                            bfd_byte *contents,
1035                            Elf_Internal_Rela *relocs,
1036                            Elf_Internal_Sym *local_syms,
1037                            asection **local_sections)
1038 {
1039   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1040   struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
1041   Elf_Internal_Rela *rel = relocs;
1042   Elf_Internal_Rela *relend = relocs + input_section->reloc_count;
1043   asection *sreloc = NULL;
1044   bfd_boolean ret = TRUE;
1045
1046 #ifdef DEBUG
1047   _bfd_error_handler ("i370_elf_relocate_section called for %B section %A, %ld relocations%s",
1048                       input_bfd, input_section,
1049                       (long) input_section->reloc_count,
1050                       (info->relocatable) ? " (relocatable)" : "");
1051 #endif
1052
1053   if (!i370_elf_howto_table[ R_I370_ADDR31 ])
1054     /* Initialize howto table if needed.  */
1055     i370_elf_howto_init ();
1056
1057   for (; rel < relend; rel++)
1058     {
1059       enum i370_reloc_type r_type    = (enum i370_reloc_type) ELF32_R_TYPE (rel->r_info);
1060       bfd_vma offset                 = rel->r_offset;
1061       bfd_vma addend                 = rel->r_addend;
1062       bfd_reloc_status_type r        = bfd_reloc_other;
1063       Elf_Internal_Sym *sym          = NULL;
1064       asection *sec                  = NULL;
1065       struct elf_link_hash_entry * h = NULL;
1066       const char *sym_name           = NULL;
1067       reloc_howto_type *howto;
1068       unsigned long r_symndx;
1069       bfd_vma relocation;
1070
1071       /* Unknown relocation handling.  */
1072       if ((unsigned) r_type >= (unsigned) R_I370_max
1073           || !i370_elf_howto_table[(int)r_type])
1074         {
1075           (*_bfd_error_handler) ("%B: unknown relocation type %d",
1076                                  input_bfd,
1077                                  (int) r_type);
1078
1079           bfd_set_error (bfd_error_bad_value);
1080           ret = FALSE;
1081           continue;
1082         }
1083
1084       howto = i370_elf_howto_table[(int) r_type];
1085       r_symndx = ELF32_R_SYM (rel->r_info);
1086       relocation = 0;
1087
1088       if (r_symndx < symtab_hdr->sh_info)
1089         {
1090           sym = local_syms + r_symndx;
1091           sec = local_sections[r_symndx];
1092           sym_name = "<local symbol>";
1093
1094           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, & sec, rel);
1095           addend = rel->r_addend;
1096         }
1097       else
1098         {
1099           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1100           while (h->root.type == bfd_link_hash_indirect
1101                  || h->root.type == bfd_link_hash_warning)
1102             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1103           sym_name = h->root.root.string;
1104           if (h->root.type == bfd_link_hash_defined
1105               || h->root.type == bfd_link_hash_defweak)
1106             {
1107               sec = h->root.u.def.section;
1108               if (info->shared
1109                   && ((! info->symbolic && h->dynindx != -1)
1110                       || !h->def_regular)
1111                   && (input_section->flags & SEC_ALLOC) != 0
1112                   && (r_type == R_I370_ADDR31
1113                       || r_type == R_I370_COPY
1114                       || r_type == R_I370_ADDR16
1115                       || r_type == R_I370_RELATIVE))
1116                 /* In these cases, we don't need the relocation
1117                    value.  We check specially because in some
1118                    obscure cases sec->output_section will be NULL.  */
1119                 ;
1120               else
1121                 relocation = (h->root.u.def.value
1122                               + sec->output_section->vma
1123                               + sec->output_offset);
1124             }
1125           else if (h->root.type == bfd_link_hash_undefweak)
1126             ;
1127           else if (info->unresolved_syms_in_objects == RM_IGNORE
1128                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1129             ;
1130           else if (!info->relocatable)
1131             {
1132               if ((*info->callbacks->undefined_symbol)
1133                   (info, h->root.root.string, input_bfd,
1134                    input_section, rel->r_offset,
1135                    (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
1136                     || ELF_ST_VISIBILITY (h->other))))
1137                 {
1138                   ret = FALSE;
1139                   continue;
1140                 }
1141             }
1142         }
1143
1144       if (sec != NULL && elf_discarded_section (sec))
1145         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1146                                          rel, relend, howto, contents);
1147
1148       if (info->relocatable)
1149         continue;
1150
1151       switch ((int) r_type)
1152         {
1153         default:
1154           (*_bfd_error_handler)
1155             ("%B: unknown relocation type %d for symbol %s",
1156              input_bfd, (int) r_type, sym_name);
1157
1158           bfd_set_error (bfd_error_bad_value);
1159           ret = FALSE;
1160           continue;
1161
1162         case (int) R_I370_NONE:
1163           continue;
1164
1165         /* Relocations that may need to be propagated if this is a shared
1166            object.  */
1167         case (int) R_I370_REL31:
1168           /* If these relocations are not to a named symbol, they can be
1169              handled right here, no need to bother the dynamic linker.  */
1170           if (h == NULL
1171               || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1172             break;
1173         /* Fall through.  */
1174
1175         /* Relocations that always need to be propagated if this is a shared
1176            object.  */
1177         case (int) R_I370_ADDR31:
1178         case (int) R_I370_ADDR16:
1179           if (info->shared
1180               && r_symndx != STN_UNDEF)
1181             {
1182               Elf_Internal_Rela outrel;
1183               bfd_byte *loc;
1184               int skip;
1185
1186 #ifdef DEBUG
1187               fprintf (stderr,
1188                        "i370_elf_relocate_section needs to create relocation for %s\n",
1189                        (h && h->root.root.string) ? h->root.root.string : "<unknown>");
1190 #endif
1191
1192               /* When generating a shared object, these relocations
1193                  are copied into the output file to be resolved at run
1194                  time.  */
1195
1196               if (sreloc == NULL)
1197                 {
1198                   sreloc = _bfd_elf_get_dynamic_reloc_section
1199                     (input_bfd, input_section, /*rela?*/ TRUE);
1200                   if (sreloc == NULL)
1201                     return FALSE;
1202                 }
1203
1204               skip = 0;
1205
1206               outrel.r_offset =
1207                 _bfd_elf_section_offset (output_bfd, info, input_section,
1208                                          rel->r_offset);
1209               if (outrel.r_offset == (bfd_vma) -1
1210                   || outrel.r_offset == (bfd_vma) -2)
1211                 skip = (int) outrel.r_offset;
1212               outrel.r_offset += (input_section->output_section->vma
1213                                   + input_section->output_offset);
1214
1215               if (skip)
1216                 memset (&outrel, 0, sizeof outrel);
1217               /* h->dynindx may be -1 if this symbol was marked to
1218                  become local.  */
1219               else if (h != NULL
1220                        && ((! info->symbolic && h->dynindx != -1)
1221                            || !h->def_regular))
1222                 {
1223                   BFD_ASSERT (h->dynindx != -1);
1224                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1225                   outrel.r_addend = rel->r_addend;
1226                 }
1227               else
1228                 {
1229                   if (r_type == R_I370_ADDR31)
1230                     {
1231                       outrel.r_info = ELF32_R_INFO (0, R_I370_RELATIVE);
1232                       outrel.r_addend = relocation + rel->r_addend;
1233                     }
1234                   else
1235                     {
1236                       long indx;
1237
1238                       if (bfd_is_abs_section (sec))
1239                         indx = 0;
1240                       else if (sec == NULL || sec->owner == NULL)
1241                         {
1242                           bfd_set_error (bfd_error_bad_value);
1243                           return FALSE;
1244                         }
1245                       else
1246                         {
1247                           asection *osec;
1248
1249                           /* We are turning this relocation into one
1250                              against a section symbol.  It would be
1251                              proper to subtract the symbol's value,
1252                              osec->vma, from the emitted reloc addend,
1253                              but ld.so expects buggy relocs.  */
1254                           osec = sec->output_section;
1255                           indx = elf_section_data (osec)->dynindx;
1256                           if (indx == 0)
1257                             {
1258                               struct elf_link_hash_table *htab;
1259                               htab = elf_hash_table (info);
1260                               osec = htab->text_index_section;
1261                               indx = elf_section_data (osec)->dynindx;
1262                             }
1263                           BFD_ASSERT (indx != 0);
1264 #ifdef DEBUG
1265                           if (indx <= 0)
1266                             {
1267                               printf ("indx=%ld section=%s flags=%08x name=%s\n",
1268                                       indx, osec->name, osec->flags,
1269                                       h->root.root.string);
1270                             }
1271 #endif
1272                         }
1273
1274                       outrel.r_info = ELF32_R_INFO (indx, r_type);
1275                       outrel.r_addend = relocation + rel->r_addend;
1276                     }
1277                 }
1278
1279               loc = sreloc->contents;
1280               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1281               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1282
1283               /* This reloc will be computed at runtime, so there's no
1284                  need to do anything now, unless this is a RELATIVE
1285                  reloc in an unallocated section.  */
1286               if (skip == -1
1287                   || (input_section->flags & SEC_ALLOC) != 0
1288                   || ELF32_R_TYPE (outrel.r_info) != R_I370_RELATIVE)
1289                 continue;
1290             }
1291           break;
1292
1293         case (int) R_I370_COPY:
1294         case (int) R_I370_RELATIVE:
1295           (*_bfd_error_handler)
1296             ("%B: Relocation %s is not yet supported for symbol %s.",
1297              input_bfd,
1298              i370_elf_howto_table[(int) r_type]->name,
1299              sym_name);
1300
1301           bfd_set_error (bfd_error_invalid_operation);
1302           ret = FALSE;
1303           continue;
1304         }
1305
1306 #ifdef DEBUG
1307       fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, offset = %ld, addend = %ld\n",
1308                howto->name,
1309                (int)r_type,
1310                sym_name,
1311                r_symndx,
1312                (long) offset,
1313                (long) addend);
1314 #endif
1315
1316       r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
1317                                     offset, relocation, addend);
1318
1319       if (r != bfd_reloc_ok)
1320         {
1321           ret = FALSE;
1322           switch (r)
1323             {
1324             default:
1325               break;
1326
1327             case bfd_reloc_overflow:
1328               {
1329                 const char *name;
1330
1331                 if (h != NULL)
1332                   name = NULL;
1333                 else
1334                   {
1335                     name = bfd_elf_string_from_elf_section (input_bfd,
1336                                                             symtab_hdr->sh_link,
1337                                                             sym->st_name);
1338                     if (name == NULL)
1339                       break;
1340
1341                     if (*name == '\0')
1342                       name = bfd_section_name (input_bfd, sec);
1343                   }
1344
1345                 (*info->callbacks->reloc_overflow) (info,
1346                                                     (h ? &h->root : NULL),
1347                                                     name,
1348                                                     howto->name,
1349                                                     (bfd_vma) 0,
1350                                                     input_bfd,
1351                                                     input_section,
1352                                                     offset);
1353               }
1354               break;
1355             }
1356         }
1357     }
1358
1359 #ifdef DEBUG
1360   fprintf (stderr, "\n");
1361 #endif
1362
1363   return ret;
1364 }
1365 \f
1366 #define TARGET_BIG_SYM          bfd_elf32_i370_vec
1367 #define TARGET_BIG_NAME         "elf32-i370"
1368 #define ELF_ARCH                bfd_arch_i370
1369 #define ELF_MACHINE_CODE        EM_S370
1370 #ifdef EM_I370_OLD
1371 #define ELF_MACHINE_ALT1        EM_I370_OLD
1372 #endif
1373 #define ELF_MAXPAGESIZE         0x1000
1374 #define ELF_OSABI               ELFOSABI_LINUX
1375
1376 #define elf_info_to_howto       i370_elf_info_to_howto
1377
1378 #define elf_backend_plt_not_loaded 1
1379 #define elf_backend_rela_normal    1
1380
1381 #define bfd_elf32_bfd_reloc_type_lookup         i370_elf_reloc_type_lookup
1382 #define bfd_elf32_bfd_reloc_name_lookup i370_elf_reloc_name_lookup
1383 #define bfd_elf32_bfd_set_private_flags         i370_elf_set_private_flags
1384 #define bfd_elf32_bfd_merge_private_bfd_data    i370_elf_merge_private_bfd_data
1385 #define elf_backend_relocate_section            i370_elf_relocate_section
1386
1387 /* Dynamic loader support is mostly broken; just enough here to be able to
1388    link glibc's ld.so without errors.  */
1389 #define elf_backend_create_dynamic_sections     i370_elf_create_dynamic_sections
1390 #define elf_backend_size_dynamic_sections       i370_elf_size_dynamic_sections
1391 #define elf_backend_init_index_section          _bfd_elf_init_1_index_section
1392 #define elf_backend_finish_dynamic_sections     i370_elf_finish_dynamic_sections
1393 #define elf_backend_fake_sections               i370_elf_fake_sections
1394 #define elf_backend_section_from_shdr           i370_elf_section_from_shdr
1395 #define elf_backend_adjust_dynamic_symbol       i370_elf_adjust_dynamic_symbol
1396 #define elf_backend_check_relocs                i370_elf_check_relocs
1397 #define elf_backend_post_process_headers        _bfd_elf_set_osabi
1398
1399 static int
1400 i370_noop (void)
1401 {
1402   return 1;
1403 }
1404
1405 #define elf_backend_finish_dynamic_symbol \
1406   (bfd_boolean (*) \
1407      (bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, \
1408       Elf_Internal_Sym *)) i370_noop
1409
1410 #include "elf32-target.h"