1 /* i370-specific support for 32-bit ELF
2 Copyright (C) 1994-2016 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Cygnus Support.
4 Hacked by Linas Vepstas for i370 linas@linas.org
6 This file is part of BFD, the Binary File Descriptor library.
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 3 of the License, or
11 (at your option) any later version.
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.
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., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
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. */
36 static reloc_howto_type *i370_elf_howto_table[ (int)R_I370_max ];
38 static reloc_howto_type i370_elf_howto_raw[] =
40 /* This reloc does nothing. */
41 HOWTO (R_I370_NONE, /* type */
43 3, /* size (0 = byte, 1 = short, 2 = long) */
45 FALSE, /* pc_relative */
47 complain_overflow_dont, /* complain_on_overflow */
48 bfd_elf_generic_reloc, /* special_function */
49 "R_I370_NONE", /* name */
50 FALSE, /* partial_inplace */
53 FALSE), /* pcrel_offset */
55 /* A standard 31 bit relocation. */
56 HOWTO (R_I370_ADDR31, /* type */
58 2, /* size (0 = byte, 1 = short, 2 = long) */
60 FALSE, /* pc_relative */
62 complain_overflow_bitfield, /* complain_on_overflow */
63 bfd_elf_generic_reloc, /* special_function */
64 "R_I370_ADDR31", /* name */
65 FALSE, /* partial_inplace */
67 0x7fffffff, /* dst_mask */
68 FALSE), /* pcrel_offset */
70 /* A standard 32 bit relocation. */
71 HOWTO (R_I370_ADDR32, /* type */
73 2, /* size (0 = byte, 1 = short, 2 = long) */
75 FALSE, /* pc_relative */
77 complain_overflow_bitfield, /* complain_on_overflow */
78 bfd_elf_generic_reloc, /* special_function */
79 "R_I370_ADDR32", /* name */
80 FALSE, /* partial_inplace */
82 0xffffffff, /* dst_mask */
83 FALSE), /* pcrel_offset */
85 /* A standard 16 bit relocation. */
86 HOWTO (R_I370_ADDR16, /* type */
88 1, /* size (0 = byte, 1 = short, 2 = long) */
90 FALSE, /* pc_relative */
92 complain_overflow_bitfield, /* complain_on_overflow */
93 bfd_elf_generic_reloc, /* special_function */
94 "R_I370_ADDR16", /* name */
95 FALSE, /* partial_inplace */
97 0xffff, /* dst_mask */
98 FALSE), /* pcrel_offset */
100 /* 31-bit PC relative. */
101 HOWTO (R_I370_REL31, /* type */
103 2, /* size (0 = byte, 1 = short, 2 = long) */
105 TRUE, /* pc_relative */
107 complain_overflow_bitfield, /* complain_on_overflow */
108 bfd_elf_generic_reloc, /* special_function */
109 "R_I370_REL31", /* name */
110 FALSE, /* partial_inplace */
112 0x7fffffff, /* dst_mask */
113 TRUE), /* pcrel_offset */
115 /* 32-bit PC relative. */
116 HOWTO (R_I370_REL32, /* type */
118 2, /* size (0 = byte, 1 = short, 2 = long) */
120 TRUE, /* pc_relative */
122 complain_overflow_bitfield, /* complain_on_overflow */
123 bfd_elf_generic_reloc, /* special_function */
124 "R_I370_REL32", /* name */
125 FALSE, /* partial_inplace */
127 0xffffffff, /* dst_mask */
128 TRUE), /* pcrel_offset */
130 /* A standard 12 bit relocation. */
131 HOWTO (R_I370_ADDR12, /* type */
133 1, /* size (0 = byte, 1 = short, 2 = long) */
135 FALSE, /* pc_relative */
137 complain_overflow_bitfield, /* complain_on_overflow */
138 bfd_elf_generic_reloc, /* special_function */
139 "R_I370_ADDR12", /* name */
140 FALSE, /* partial_inplace */
142 0xfff, /* dst_mask */
143 FALSE), /* pcrel_offset */
145 /* 12-bit PC relative. */
146 HOWTO (R_I370_REL12, /* type */
148 1, /* size (0 = byte, 1 = short, 2 = long) */
150 TRUE, /* pc_relative */
152 complain_overflow_bitfield, /* complain_on_overflow */
153 bfd_elf_generic_reloc, /* special_function */
154 "R_I370_REL12", /* name */
155 FALSE, /* partial_inplace */
157 0xfff, /* dst_mask */
158 TRUE), /* pcrel_offset */
160 /* A standard 8 bit relocation. */
161 HOWTO (R_I370_ADDR8, /* type */
163 0, /* size (0 = byte, 1 = short, 2 = long) */
165 FALSE, /* pc_relative */
167 complain_overflow_bitfield, /* complain_on_overflow */
168 bfd_elf_generic_reloc, /* special_function */
169 "R_I370_ADDR8", /* name */
170 FALSE, /* partial_inplace */
173 FALSE), /* pcrel_offset */
175 /* 8-bit PC relative. */
176 HOWTO (R_I370_REL8, /* type */
178 0, /* size (0 = byte, 1 = short, 2 = long) */
180 TRUE, /* pc_relative */
182 complain_overflow_bitfield, /* complain_on_overflow */
183 bfd_elf_generic_reloc, /* special_function */
184 "R_I370_REL8", /* name */
185 FALSE, /* partial_inplace */
188 TRUE), /* pcrel_offset */
190 /* This is used only by the dynamic linker. The symbol should exist
191 both in the object being run and in some shared library. The
192 dynamic linker copies the data addressed by the symbol from the
193 shared library into the object, because the object being
194 run has to have the data at some particular address. */
195 HOWTO (R_I370_COPY, /* type */
197 2, /* size (0 = byte, 1 = short, 2 = long) */
199 FALSE, /* pc_relative */
201 complain_overflow_bitfield, /* complain_on_overflow */
202 bfd_elf_generic_reloc, /* special_function */
203 "R_I370_COPY", /* name */
204 FALSE, /* partial_inplace */
207 FALSE), /* pcrel_offset */
209 /* Used only by the dynamic linker. When the object is run, this
210 longword is set to the load address of the object, plus the
212 HOWTO (R_I370_RELATIVE, /* type */
214 2, /* size (0 = byte, 1 = short, 2 = long) */
216 FALSE, /* pc_relative */
218 complain_overflow_bitfield, /* complain_on_overflow */
219 bfd_elf_generic_reloc, /* special_function */
220 "R_I370_RELATIVE", /* name */
221 FALSE, /* partial_inplace */
223 0xffffffff, /* dst_mask */
224 FALSE), /* pcrel_offset */
228 /* Initialize the i370_elf_howto_table, so that linear accesses can be done. */
231 i370_elf_howto_init (void)
233 unsigned int i, type;
235 for (i = 0; i < sizeof (i370_elf_howto_raw) / sizeof (i370_elf_howto_raw[0]); i++)
237 type = i370_elf_howto_raw[i].type;
238 BFD_ASSERT (type < sizeof (i370_elf_howto_table) / sizeof (i370_elf_howto_table[0]));
239 i370_elf_howto_table[type] = &i370_elf_howto_raw[i];
243 static reloc_howto_type *
244 i370_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
245 bfd_reloc_code_real_type code)
247 enum i370_reloc_type i370_reloc = R_I370_NONE;
249 if (!i370_elf_howto_table[ R_I370_ADDR31 ])
250 /* Initialize howto table if needed. */
251 i370_elf_howto_init ();
258 case BFD_RELOC_NONE: i370_reloc = R_I370_NONE; break;
259 case BFD_RELOC_32: i370_reloc = R_I370_ADDR31; break;
260 case BFD_RELOC_16: i370_reloc = R_I370_ADDR16; break;
261 case BFD_RELOC_32_PCREL: i370_reloc = R_I370_REL31; break;
262 case BFD_RELOC_CTOR: i370_reloc = R_I370_ADDR31; break;
263 case BFD_RELOC_I370_D12: i370_reloc = R_I370_ADDR12; break;
266 return i370_elf_howto_table[ (int)i370_reloc ];
269 static reloc_howto_type *
270 i370_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
276 i < sizeof (i370_elf_howto_raw) / sizeof (i370_elf_howto_raw[0]);
278 if (i370_elf_howto_raw[i].name != NULL
279 && strcasecmp (i370_elf_howto_raw[i].name, r_name) == 0)
280 return &i370_elf_howto_raw[i];
285 /* The name of the dynamic interpreter. This is put in the .interp
288 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
290 /* Set the howto pointer for an i370 ELF reloc. */
293 i370_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
295 Elf_Internal_Rela *dst)
299 if (!i370_elf_howto_table[ R_I370_ADDR31 ])
300 /* Initialize howto table. */
301 i370_elf_howto_init ();
303 r_type = ELF32_R_TYPE (dst->r_info);
304 if (r_type >= R_I370_max)
306 _bfd_error_handler (_("%B: unrecognised I370 reloc number: %d"),
308 bfd_set_error (bfd_error_bad_value);
309 r_type = R_I370_NONE;
311 cache_ptr->howto = i370_elf_howto_table[r_type];
314 /* Hack alert -- the following several routines look generic to me ...
315 why are we bothering with them ? */
316 /* Function to set whether a module needs the -mrelocatable bit set. */
319 i370_elf_set_private_flags (bfd *abfd, flagword flags)
321 BFD_ASSERT (!elf_flags_init (abfd)
322 || elf_elfheader (abfd)->e_flags == flags);
324 elf_elfheader (abfd)->e_flags = flags;
325 elf_flags_init (abfd) = TRUE;
329 /* Merge backend specific data from an object file to the output
330 object file when linking. */
333 i370_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
335 bfd *obfd = info->output_bfd;
339 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
340 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
343 new_flags = elf_elfheader (ibfd)->e_flags;
344 old_flags = elf_elfheader (obfd)->e_flags;
345 if (!elf_flags_init (obfd)) /* First call, no flags set. */
347 elf_flags_init (obfd) = TRUE;
348 elf_elfheader (obfd)->e_flags = new_flags;
351 else if (new_flags == old_flags) /* Compatible flags are ok. */
354 else /* Incompatible flags. */
357 ("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)",
358 ibfd, (long) new_flags, (long) old_flags);
360 bfd_set_error (bfd_error_bad_value);
367 /* Handle an i370 specific section when reading an object file. This
368 is called when elfcode.h finds a section with an unknown type. */
369 /* XXX hack alert bogus This routine is mostly all junk and almost
370 certainly does the wrong thing. Its here simply because it does
371 just enough to allow glibc-2.1 ld.so to compile & link. */
374 i370_elf_section_from_shdr (bfd *abfd,
375 Elf_Internal_Shdr *hdr,
382 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
385 newsect = hdr->bfd_section;
386 flags = bfd_get_section_flags (abfd, newsect);
387 if (hdr->sh_type == SHT_ORDERED)
388 flags |= SEC_SORT_ENTRIES;
390 bfd_set_section_flags (abfd, newsect, flags);
394 /* Set up any other section flags and such that may be necessary. */
395 /* XXX hack alert bogus This routine is mostly all junk and almost
396 certainly does the wrong thing. Its here simply because it does
397 just enough to allow glibc-2.1 ld.so to compile & link. */
400 i370_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
401 Elf_Internal_Shdr *shdr,
404 if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE)
405 shdr->sh_flags |= SHF_EXCLUDE;
407 if ((asect->flags & SEC_SORT_ENTRIES) != 0)
408 shdr->sh_type = SHT_ORDERED;
413 /* We have to create .dynsbss and .rela.sbss here so that they get mapped
414 to output sections (just like _bfd_elf_create_dynamic_sections has
415 to create .dynbss and .rela.bss). */
416 /* XXX hack alert bogus This routine is mostly all junk and almost
417 certainly does the wrong thing. Its here simply because it does
418 just enough to allow glibc-2.1 ld.so to compile & link. */
421 i370_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
426 if (!_bfd_elf_create_dynamic_sections(abfd, info))
429 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
430 | SEC_LINKER_CREATED);
432 s = bfd_make_section_anyway_with_flags (abfd, ".dynsbss",
433 SEC_ALLOC | SEC_LINKER_CREATED);
437 if (! bfd_link_pic (info))
439 s = bfd_make_section_anyway_with_flags (abfd, ".rela.sbss",
440 flags | SEC_READONLY);
442 || ! bfd_set_section_alignment (abfd, s, 2))
446 /* XXX beats me, seem to need a rela.text ... */
447 s = bfd_make_section_anyway_with_flags (abfd, ".rela.text",
448 flags | SEC_READONLY);
450 || ! bfd_set_section_alignment (abfd, s, 2))
455 /* Adjust a symbol defined by a dynamic object and referenced by a
456 regular object. The current definition is in some section of the
457 dynamic object, but we're not including those sections. We have to
458 change the definition to something the rest of the link can
460 /* XXX hack alert bogus This routine is mostly all junk and almost
461 certainly does the wrong thing. Its here simply because it does
462 just enough to allow glibc-2.1 ld.so to compile & link. */
465 i370_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
466 struct elf_link_hash_entry *h)
468 bfd *dynobj = elf_hash_table (info)->dynobj;
472 fprintf (stderr, "i370_elf_adjust_dynamic_symbol called for %s\n",
473 h->root.root.string);
476 /* Make sure we know what is going on here. */
477 BFD_ASSERT (dynobj != NULL
479 || h->u.weakdef != NULL
482 && !h->def_regular)));
484 s = bfd_get_linker_section (dynobj, ".rela.text");
485 BFD_ASSERT (s != NULL);
486 s->size += sizeof (Elf32_External_Rela);
488 /* If this is a weak symbol, and there is a real definition, the
489 processor independent code will have arranged for us to see the
490 real definition first, and we can just use the same value. */
491 if (h->u.weakdef != NULL)
493 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
494 || h->u.weakdef->root.type == bfd_link_hash_defweak);
495 h->root.u.def.section = h->u.weakdef->root.u.def.section;
496 h->root.u.def.value = h->u.weakdef->root.u.def.value;
500 /* This is a reference to a symbol defined by a dynamic object which
501 is not a function. */
503 /* If we are creating a shared library, we must presume that the
504 only references to the symbol are via the global offset table.
505 For such cases we need not do anything here; the relocations will
506 be handled correctly by relocate_section. */
507 if (bfd_link_pic (info))
510 /* We must allocate the symbol in our .dynbss section, which will
511 become part of the .bss section of the executable. There will be
512 an entry for this symbol in the .dynsym section. The dynamic
513 object will contain position independent code, so all references
514 from the dynamic object to this symbol will go through the global
515 offset table. The dynamic linker will use the .dynsym entry to
516 determine the address it must put in the global offset table, so
517 both the dynamic object and the regular object will refer to the
518 same memory location for the variable.
520 Of course, if the symbol is sufficiently small, we must instead
521 allocate it in .sbss. FIXME: It would be better to do this if and
522 only if there were actually SDAREL relocs for that symbol. */
524 if (h->size <= elf_gp_size (dynobj))
525 s = bfd_get_linker_section (dynobj, ".dynsbss");
527 s = bfd_get_linker_section (dynobj, ".dynbss");
528 BFD_ASSERT (s != NULL);
530 /* We must generate a R_I370_COPY reloc to tell the dynamic linker to
531 copy the initial value out of the dynamic object and into the
532 runtime process image. We need to remember the offset into the
533 .rela.bss section we are going to use. */
534 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
538 if (h->size <= elf_gp_size (dynobj))
539 srel = bfd_get_linker_section (dynobj, ".rela.sbss");
541 srel = bfd_get_linker_section (dynobj, ".rela.bss");
542 BFD_ASSERT (srel != NULL);
543 srel->size += sizeof (Elf32_External_Rela);
547 return _bfd_elf_adjust_dynamic_copy (info, h, s);
550 /* Increment the index of a dynamic symbol by a given amount. Called
551 via elf_link_hash_traverse. */
552 /* XXX hack alert bogus This routine is mostly all junk and almost
553 certainly does the wrong thing. Its here simply because it does
554 just enough to allow glibc-2.1 ld.so to compile & link. */
557 i370_elf_adjust_dynindx (struct elf_link_hash_entry *h, void * cparg)
559 int *cp = (int *) cparg;
563 "i370_elf_adjust_dynindx called, h->dynindx = %ld, *cp = %d\n",
567 if (h->dynindx != -1)
573 /* Set the sizes of the dynamic sections. */
574 /* XXX hack alert bogus This routine is mostly all junk and almost
575 certainly does the wrong thing. Its here simply because it does
576 just enough to allow glibc-2.1 ld.so to compile & link. */
579 i370_elf_size_dynamic_sections (bfd *output_bfd,
580 struct bfd_link_info *info)
589 fprintf (stderr, "i370_elf_size_dynamic_sections called\n");
592 dynobj = elf_hash_table (info)->dynobj;
593 BFD_ASSERT (dynobj != NULL);
595 if (elf_hash_table (info)->dynamic_sections_created)
597 /* Set the contents of the .interp section to the interpreter. */
598 if (bfd_link_executable (info) && !info->nointerp)
600 s = bfd_get_linker_section (dynobj, ".interp");
601 BFD_ASSERT (s != NULL);
602 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
603 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
608 /* We may have created entries in the .rela.got, .rela.sdata, and
609 .rela.sdata2 sections. However, if we are not creating the
610 dynamic sections, we will not actually use these entries. Reset
611 the size of .rela.got, et al, which will cause it to get
612 stripped from the output file below. */
613 static char *rela_sections[] = { ".rela.got", ".rela.sdata",
614 ".rela.sdata2", ".rela.sbss",
618 for (p = rela_sections; *p != NULL; p++)
620 s = bfd_get_linker_section (dynobj, *p);
626 /* The check_relocs and adjust_dynamic_symbol entry points have
627 determined the sizes of the various dynamic sections. Allocate
632 for (s = dynobj->sections; s != NULL; s = s->next)
636 if ((s->flags & SEC_LINKER_CREATED) == 0)
639 /* It's OK to base decisions on the section name, because none
640 of the dynobj section names depend upon the input files. */
641 name = bfd_get_section_name (dynobj, s);
643 if (strcmp (name, ".plt") == 0)
645 /* Remember whether there is a PLT. */
648 else if (CONST_STRNEQ (name, ".rela"))
655 /* Remember whether there are any relocation sections. */
658 /* If this relocation section applies to a read only
659 section, then we probably need a DT_TEXTREL entry. */
660 outname = bfd_get_section_name (output_bfd,
662 target = bfd_get_section_by_name (output_bfd, outname + 5);
664 && (target->flags & SEC_READONLY) != 0
665 && (target->flags & SEC_ALLOC) != 0)
668 /* We use the reloc_count field as a counter if we need
669 to copy relocs into the output file. */
673 else if (strcmp (name, ".got") != 0
674 && strcmp (name, ".sdata") != 0
675 && strcmp (name, ".sdata2") != 0
676 && strcmp (name, ".dynbss") != 0
677 && strcmp (name, ".dynsbss") != 0)
679 /* It's not one of our sections, so don't allocate space. */
685 /* If we don't need this section, strip it from the
686 output file. This is mostly to handle .rela.bss and
687 .rela.plt. We must create both sections in
688 create_dynamic_sections, because they must be created
689 before the linker maps input sections to output
690 sections. The linker does that before
691 adjust_dynamic_symbol is called, and it is that
692 function which decides whether anything needs to go
693 into these sections. */
694 s->flags |= SEC_EXCLUDE;
698 if ((s->flags & SEC_HAS_CONTENTS) == 0)
701 /* Allocate memory for the section contents. */
702 s->contents = bfd_zalloc (dynobj, s->size);
703 if (s->contents == NULL)
707 if (elf_hash_table (info)->dynamic_sections_created)
709 /* Add some entries to the .dynamic section. We fill in the
710 values later, in i370_elf_finish_dynamic_sections, but we
711 must add the entries now so that we get the correct size for
712 the .dynamic section. The DT_DEBUG entry is filled in by the
713 dynamic linker and used by the debugger. */
714 #define add_dynamic_entry(TAG, VAL) \
715 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
717 if (!bfd_link_pic (info))
719 if (!add_dynamic_entry (DT_DEBUG, 0))
725 if (!add_dynamic_entry (DT_PLTGOT, 0)
726 || !add_dynamic_entry (DT_PLTRELSZ, 0)
727 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
728 || !add_dynamic_entry (DT_JMPREL, 0))
734 if (!add_dynamic_entry (DT_RELA, 0)
735 || !add_dynamic_entry (DT_RELASZ, 0)
736 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
742 if (!add_dynamic_entry (DT_TEXTREL, 0))
744 info->flags |= DF_TEXTREL;
747 #undef add_dynamic_entry
749 /* If we are generating a shared library, we generate a section
750 symbol for each output section. These are local symbols, which
751 means that they must come first in the dynamic symbol table.
752 That means we must increment the dynamic symbol index of every
753 other dynamic symbol.
755 FIXME: We assume that there will never be relocations to
756 locations in linker-created sections that do not have
757 externally-visible names. Instead, we should work out precisely
758 which sections relocations are targeted at. */
759 if (bfd_link_pic (info))
763 for (c = 0, s = output_bfd->sections; s != NULL; s = s->next)
765 if ((s->flags & SEC_LINKER_CREATED) != 0
766 || (s->flags & SEC_ALLOC) == 0)
768 elf_section_data (s)->dynindx = -1;
772 /* These symbols will have no names, so we don't need to
773 fiddle with dynstr_index. */
775 elf_section_data (s)->dynindx = c + 1;
780 elf_link_hash_traverse (elf_hash_table (info),
781 i370_elf_adjust_dynindx, & c);
782 elf_hash_table (info)->dynsymcount += c;
788 /* Look through the relocs for a section during the first phase, and
789 allocate space in the global offset table or procedure linkage
791 /* XXX hack alert bogus This routine is mostly all junk and almost
792 certainly does the wrong thing. Its here simply because it does
793 just enough to allow glibc-2.1 ld.so to compile & link. */
796 i370_elf_check_relocs (bfd *abfd,
797 struct bfd_link_info *info,
799 const Elf_Internal_Rela *relocs)
802 Elf_Internal_Shdr *symtab_hdr;
803 struct elf_link_hash_entry **sym_hashes;
804 const Elf_Internal_Rela *rel;
805 const Elf_Internal_Rela *rel_end;
808 if (bfd_link_relocatable (info))
812 _bfd_error_handler ("i370_elf_check_relocs called for section %A in %B",
816 dynobj = elf_hash_table (info)->dynobj;
817 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
818 sym_hashes = elf_sym_hashes (abfd);
822 rel_end = relocs + sec->reloc_count;
823 for (rel = relocs; rel < rel_end; rel++)
825 unsigned long r_symndx;
826 struct elf_link_hash_entry *h;
828 r_symndx = ELF32_R_SYM (rel->r_info);
829 if (r_symndx < symtab_hdr->sh_info)
833 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
834 while (h->root.type == bfd_link_hash_indirect
835 || h->root.type == bfd_link_hash_warning)
836 h = (struct elf_link_hash_entry *) h->root.u.i.link;
838 /* PR15323, ref flags aren't set for references in the same
840 h->root.non_ir_ref = 1;
843 if (bfd_link_pic (info))
847 "i370_elf_check_relocs needs to create relocation for %s\n",
848 (h && h->root.root.string)
849 ? h->root.root.string : "<unknown>");
853 sreloc = _bfd_elf_make_dynamic_reloc_section
854 (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
860 sreloc->size += sizeof (Elf32_External_Rela);
862 /* FIXME: We should here do what the m68k and i386
863 backends do: if the reloc is pc-relative, record it
864 in case it turns out that the reloc is unnecessary
865 because the symbol is forced local by versioning or
866 we are linking with -Bdynamic. Fortunately this
867 case is not frequent. */
874 /* Finish up the dynamic sections. */
875 /* XXX hack alert bogus This routine is mostly all junk and almost
876 certainly does the wrong thing. Its here simply because it does
877 just enough to allow glibc-2.1 ld.so to compile & link. */
880 i370_elf_finish_dynamic_sections (bfd *output_bfd,
881 struct bfd_link_info *info)
884 bfd *dynobj = elf_hash_table (info)->dynobj;
885 asection *sgot = bfd_get_linker_section (dynobj, ".got");
888 fprintf (stderr, "i370_elf_finish_dynamic_sections called\n");
891 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
893 if (elf_hash_table (info)->dynamic_sections_created)
896 Elf32_External_Dyn *dyncon, *dynconend;
898 splt = bfd_get_linker_section (dynobj, ".plt");
899 BFD_ASSERT (splt != NULL && sdyn != NULL);
901 dyncon = (Elf32_External_Dyn *) sdyn->contents;
902 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
903 for (; dyncon < dynconend; dyncon++)
905 Elf_Internal_Dyn dyn;
909 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
913 case DT_PLTGOT: name = ".plt"; size = FALSE; break;
914 case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
915 case DT_JMPREL: name = ".rela.plt"; size = FALSE; break;
916 default: name = NULL; size = FALSE; break;
923 s = bfd_get_linker_section (dynobj, name);
929 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
931 dyn.d_un.d_val = s->size;
933 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
938 if (sgot && sgot->size != 0)
940 unsigned char *contents = sgot->contents;
943 bfd_put_32 (output_bfd, (bfd_vma) 0, contents);
945 bfd_put_32 (output_bfd,
946 sdyn->output_section->vma + sdyn->output_offset,
949 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
952 if (bfd_link_pic (info))
956 Elf_Internal_Sym sym;
959 /* Set up the section symbols for the output sections. */
961 sdynsym = bfd_get_linker_section (dynobj, ".dynsym");
962 BFD_ASSERT (sdynsym != NULL);
966 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
968 sym.st_target_internal = 0;
970 for (s = output_bfd->sections; s != NULL; s = s->next)
973 Elf32_External_Sym *esym;
975 sym.st_value = s->vma;
977 indx = elf_section_data (s)->this_idx;
978 dindx = elf_section_data (s)->dynindx;
981 BFD_ASSERT(indx > 0);
982 BFD_ASSERT(dindx > 0);
984 if (dindx > maxdindx)
989 esym = (Elf32_External_Sym *) sdynsym->contents + dindx;
990 bfd_elf32_swap_symbol_out (output_bfd, &sym, esym, NULL);
994 /* Set the sh_info field of the output .dynsym section to the
995 index of the first global symbol. */
996 elf_section_data (sdynsym->output_section)->this_hdr.sh_info =
1003 /* The RELOCATE_SECTION function is called by the ELF backend linker
1004 to handle the relocations for a section.
1006 The relocs are always passed as Rela structures; if the section
1007 actually uses Rel structures, the r_addend field will always be
1010 This function is responsible for adjust the section contents as
1011 necessary, and (if using Rela relocs and generating a
1012 relocatable output file) adjusting the reloc addend as
1015 This function does not have to worry about setting the reloc
1016 address or the reloc symbol index.
1018 LOCAL_SYMS is a pointer to the swapped in local symbols.
1020 LOCAL_SECTIONS is an array giving the section in the input file
1021 corresponding to the st_shndx field of each local symbol.
1023 The global hash table entry for the global symbols can be found
1024 via elf_sym_hashes (input_bfd).
1026 When generating relocatable output, this function must handle
1027 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1028 going to be the section symbol corresponding to the output
1029 section, which means that the addend must be adjusted
1033 i370_elf_relocate_section (bfd *output_bfd,
1034 struct bfd_link_info *info,
1036 asection *input_section,
1038 Elf_Internal_Rela *relocs,
1039 Elf_Internal_Sym *local_syms,
1040 asection **local_sections)
1042 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1043 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
1044 Elf_Internal_Rela *rel = relocs;
1045 Elf_Internal_Rela *relend = relocs + input_section->reloc_count;
1046 asection *sreloc = NULL;
1047 bfd_boolean ret = TRUE;
1050 _bfd_error_handler ("i370_elf_relocate_section called for %B section %A, %ld relocations%s",
1051 input_bfd, input_section,
1052 (long) input_section->reloc_count,
1053 (bfd_link_relocatable (info)) ? " (relocatable)" : "");
1056 if (!i370_elf_howto_table[ R_I370_ADDR31 ])
1057 /* Initialize howto table if needed. */
1058 i370_elf_howto_init ();
1060 for (; rel < relend; rel++)
1062 enum i370_reloc_type r_type = (enum i370_reloc_type) ELF32_R_TYPE (rel->r_info);
1063 bfd_vma offset = rel->r_offset;
1064 bfd_vma addend = rel->r_addend;
1065 bfd_reloc_status_type r = bfd_reloc_other;
1066 Elf_Internal_Sym *sym = NULL;
1067 asection *sec = NULL;
1068 struct elf_link_hash_entry * h = NULL;
1069 const char *sym_name = NULL;
1070 reloc_howto_type *howto;
1071 unsigned long r_symndx;
1074 /* Unknown relocation handling. */
1075 if ((unsigned) r_type >= (unsigned) R_I370_max
1076 || !i370_elf_howto_table[(int)r_type])
1078 _bfd_error_handler ("%B: unknown relocation type %d",
1079 input_bfd, (int) r_type);
1081 bfd_set_error (bfd_error_bad_value);
1086 howto = i370_elf_howto_table[(int) r_type];
1087 r_symndx = ELF32_R_SYM (rel->r_info);
1090 if (r_symndx < symtab_hdr->sh_info)
1092 sym = local_syms + r_symndx;
1093 sec = local_sections[r_symndx];
1094 sym_name = "<local symbol>";
1096 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, & sec, rel);
1097 addend = rel->r_addend;
1101 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1103 if (info->wrap_hash != NULL
1104 && (input_section->flags & SEC_DEBUGGING) != 0)
1105 h = ((struct elf_link_hash_entry *)
1106 unwrap_hash_lookup (info, input_bfd, &h->root));
1108 while (h->root.type == bfd_link_hash_indirect
1109 || h->root.type == bfd_link_hash_warning)
1110 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1111 sym_name = h->root.root.string;
1112 if (h->root.type == bfd_link_hash_defined
1113 || h->root.type == bfd_link_hash_defweak)
1115 sec = h->root.u.def.section;
1116 if (bfd_link_pic (info)
1117 && ((! info->symbolic && h->dynindx != -1)
1119 && (input_section->flags & SEC_ALLOC) != 0
1120 && (r_type == R_I370_ADDR31
1121 || r_type == R_I370_COPY
1122 || r_type == R_I370_ADDR16
1123 || r_type == R_I370_RELATIVE))
1124 /* In these cases, we don't need the relocation
1125 value. We check specially because in some
1126 obscure cases sec->output_section will be NULL. */
1129 relocation = (h->root.u.def.value
1130 + sec->output_section->vma
1131 + sec->output_offset);
1133 else if (h->root.type == bfd_link_hash_undefweak)
1135 else if (info->unresolved_syms_in_objects == RM_IGNORE
1136 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1138 else if (!bfd_link_relocatable (info))
1140 (*info->callbacks->undefined_symbol)
1141 (info, h->root.root.string, input_bfd,
1142 input_section, rel->r_offset,
1143 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
1144 || ELF_ST_VISIBILITY (h->other)));
1150 if (sec != NULL && discarded_section (sec))
1151 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1152 rel, 1, relend, howto, 0, contents);
1154 if (bfd_link_relocatable (info))
1157 switch ((int) r_type)
1161 ("%B: unknown relocation type %d for symbol %s",
1162 input_bfd, (int) r_type, sym_name);
1164 bfd_set_error (bfd_error_bad_value);
1168 case (int) R_I370_NONE:
1171 /* Relocations that may need to be propagated if this is a shared
1173 case (int) R_I370_REL31:
1174 /* If these relocations are not to a named symbol, they can be
1175 handled right here, no need to bother the dynamic linker. */
1177 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1181 /* Relocations that always need to be propagated if this is a shared
1183 case (int) R_I370_ADDR31:
1184 case (int) R_I370_ADDR16:
1185 if (bfd_link_pic (info)
1186 && r_symndx != STN_UNDEF)
1188 Elf_Internal_Rela outrel;
1194 "i370_elf_relocate_section needs to create relocation for %s\n",
1195 (h && h->root.root.string) ? h->root.root.string : "<unknown>");
1198 /* When generating a shared object, these relocations
1199 are copied into the output file to be resolved at run
1204 sreloc = _bfd_elf_get_dynamic_reloc_section
1205 (input_bfd, input_section, /*rela?*/ TRUE);
1213 _bfd_elf_section_offset (output_bfd, info, input_section,
1215 if (outrel.r_offset == (bfd_vma) -1
1216 || outrel.r_offset == (bfd_vma) -2)
1217 skip = (int) outrel.r_offset;
1218 outrel.r_offset += (input_section->output_section->vma
1219 + input_section->output_offset);
1222 memset (&outrel, 0, sizeof outrel);
1223 /* h->dynindx may be -1 if this symbol was marked to
1226 && ((! info->symbolic && h->dynindx != -1)
1227 || !h->def_regular))
1229 BFD_ASSERT (h->dynindx != -1);
1230 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1231 outrel.r_addend = rel->r_addend;
1235 if (r_type == R_I370_ADDR31)
1237 outrel.r_info = ELF32_R_INFO (0, R_I370_RELATIVE);
1238 outrel.r_addend = relocation + rel->r_addend;
1244 if (bfd_is_abs_section (sec))
1246 else if (sec == NULL || sec->owner == NULL)
1248 bfd_set_error (bfd_error_bad_value);
1255 /* We are turning this relocation into one
1256 against a section symbol. It would be
1257 proper to subtract the symbol's value,
1258 osec->vma, from the emitted reloc addend,
1259 but ld.so expects buggy relocs. */
1260 osec = sec->output_section;
1261 indx = elf_section_data (osec)->dynindx;
1264 struct elf_link_hash_table *htab;
1265 htab = elf_hash_table (info);
1266 osec = htab->text_index_section;
1267 indx = elf_section_data (osec)->dynindx;
1269 BFD_ASSERT (indx != 0);
1273 printf ("indx=%ld section=%s flags=%08x name=%s\n",
1274 indx, osec->name, osec->flags,
1275 h->root.root.string);
1280 outrel.r_info = ELF32_R_INFO (indx, r_type);
1281 outrel.r_addend = relocation + rel->r_addend;
1285 loc = sreloc->contents;
1286 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1287 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1289 /* This reloc will be computed at runtime, so there's no
1290 need to do anything now, unless this is a RELATIVE
1291 reloc in an unallocated section. */
1293 || (input_section->flags & SEC_ALLOC) != 0
1294 || ELF32_R_TYPE (outrel.r_info) != R_I370_RELATIVE)
1299 case (int) R_I370_COPY:
1300 case (int) R_I370_RELATIVE:
1302 ("%B: Relocation %s is not yet supported for symbol %s.",
1304 i370_elf_howto_table[(int) r_type]->name,
1307 bfd_set_error (bfd_error_invalid_operation);
1313 fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, offset = %ld, addend = %ld\n",
1322 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
1323 offset, relocation, addend);
1325 if (r != bfd_reloc_ok)
1333 case bfd_reloc_overflow:
1341 name = bfd_elf_string_from_elf_section (input_bfd,
1342 symtab_hdr->sh_link,
1348 name = bfd_section_name (input_bfd, sec);
1351 (*info->callbacks->reloc_overflow) (info,
1352 (h ? &h->root : NULL),
1366 fprintf (stderr, "\n");
1372 #define TARGET_BIG_SYM i370_elf32_vec
1373 #define TARGET_BIG_NAME "elf32-i370"
1374 #define ELF_ARCH bfd_arch_i370
1375 #define ELF_MACHINE_CODE EM_S370
1377 #define ELF_MACHINE_ALT1 EM_I370_OLD
1379 #define ELF_MAXPAGESIZE 0x1000
1380 #define ELF_OSABI ELFOSABI_GNU
1382 #define elf_info_to_howto i370_elf_info_to_howto
1384 #define elf_backend_plt_not_loaded 1
1385 #define elf_backend_rela_normal 1
1387 #define bfd_elf32_bfd_reloc_type_lookup i370_elf_reloc_type_lookup
1388 #define bfd_elf32_bfd_reloc_name_lookup i370_elf_reloc_name_lookup
1389 #define bfd_elf32_bfd_set_private_flags i370_elf_set_private_flags
1390 #define bfd_elf32_bfd_merge_private_bfd_data i370_elf_merge_private_bfd_data
1391 #define elf_backend_relocate_section i370_elf_relocate_section
1393 /* Dynamic loader support is mostly broken; just enough here to be able to
1394 link glibc's ld.so without errors. */
1395 #define elf_backend_create_dynamic_sections i370_elf_create_dynamic_sections
1396 #define elf_backend_size_dynamic_sections i370_elf_size_dynamic_sections
1397 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
1398 #define elf_backend_finish_dynamic_sections i370_elf_finish_dynamic_sections
1399 #define elf_backend_fake_sections i370_elf_fake_sections
1400 #define elf_backend_section_from_shdr i370_elf_section_from_shdr
1401 #define elf_backend_adjust_dynamic_symbol i370_elf_adjust_dynamic_symbol
1402 #define elf_backend_check_relocs i370_elf_check_relocs
1410 #define elf_backend_finish_dynamic_symbol \
1412 (bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, \
1413 Elf_Internal_Sym *)) i370_noop
1415 #include "elf32-target.h"