bfd/elf32-i370.c

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