bfd/elf32-i370.c

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