bfd/elf32-i370.c

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