1 /* i370-specific support for 32-bit ELF
2 Copyright (C) 1994-2015 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, bfd *obfd)
338 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
339 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
342 new_flags = elf_elfheader (ibfd)->e_flags;
343 old_flags = elf_elfheader (obfd)->e_flags;
344 if (!elf_flags_init (obfd)) /* First call, no flags set. */
346 elf_flags_init (obfd) = TRUE;
347 elf_elfheader (obfd)->e_flags = new_flags;
350 else if (new_flags == old_flags) /* Compatible flags are ok. */
353 else /* Incompatible flags. */
355 (*_bfd_error_handler)
356 ("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)",
357 ibfd, (long) new_flags, (long) old_flags);
359 bfd_set_error (bfd_error_bad_value);
366 /* Handle an i370 specific section when reading an object file. This
367 is called when elfcode.h finds a section with an unknown type. */
368 /* XXX hack alert bogus This routine is mostly all junk and almost
369 certainly does the wrong thing. Its here simply because it does
370 just enough to allow glibc-2.1 ld.so to compile & link. */
373 i370_elf_section_from_shdr (bfd *abfd,
374 Elf_Internal_Shdr *hdr,
381 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
384 newsect = hdr->bfd_section;
385 flags = bfd_get_section_flags (abfd, newsect);
386 if (hdr->sh_type == SHT_ORDERED)
387 flags |= SEC_SORT_ENTRIES;
389 bfd_set_section_flags (abfd, newsect, flags);
393 /* Set up any other section flags and such that may be necessary. */
394 /* XXX hack alert bogus This routine is mostly all junk and almost
395 certainly does the wrong thing. Its here simply because it does
396 just enough to allow glibc-2.1 ld.so to compile & link. */
399 i370_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
400 Elf_Internal_Shdr *shdr,
403 if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE)
404 shdr->sh_flags |= SHF_EXCLUDE;
406 if ((asect->flags & SEC_SORT_ENTRIES) != 0)
407 shdr->sh_type = SHT_ORDERED;
412 /* We have to create .dynsbss and .rela.sbss here so that they get mapped
413 to output sections (just like _bfd_elf_create_dynamic_sections has
414 to create .dynbss and .rela.bss). */
415 /* XXX hack alert bogus This routine is mostly all junk and almost
416 certainly does the wrong thing. Its here simply because it does
417 just enough to allow glibc-2.1 ld.so to compile & link. */
420 i370_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
425 if (!_bfd_elf_create_dynamic_sections(abfd, info))
428 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
429 | SEC_LINKER_CREATED);
431 s = bfd_make_section_anyway_with_flags (abfd, ".dynsbss",
432 SEC_ALLOC | SEC_LINKER_CREATED);
436 if (! bfd_link_pic (info))
438 s = bfd_make_section_anyway_with_flags (abfd, ".rela.sbss",
439 flags | SEC_READONLY);
441 || ! bfd_set_section_alignment (abfd, s, 2))
445 /* XXX beats me, seem to need a rela.text ... */
446 s = bfd_make_section_anyway_with_flags (abfd, ".rela.text",
447 flags | SEC_READONLY);
449 || ! bfd_set_section_alignment (abfd, s, 2))
454 /* Adjust a symbol defined by a dynamic object and referenced by a
455 regular object. The current definition is in some section of the
456 dynamic object, but we're not including those sections. We have to
457 change the definition to something the rest of the link can
459 /* XXX hack alert bogus This routine is mostly all junk and almost
460 certainly does the wrong thing. Its here simply because it does
461 just enough to allow glibc-2.1 ld.so to compile & link. */
464 i370_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
465 struct elf_link_hash_entry *h)
467 bfd *dynobj = elf_hash_table (info)->dynobj;
471 fprintf (stderr, "i370_elf_adjust_dynamic_symbol called for %s\n",
472 h->root.root.string);
475 /* Make sure we know what is going on here. */
476 BFD_ASSERT (dynobj != NULL
478 || h->u.weakdef != NULL
481 && !h->def_regular)));
483 s = bfd_get_linker_section (dynobj, ".rela.text");
484 BFD_ASSERT (s != NULL);
485 s->size += sizeof (Elf32_External_Rela);
487 /* If this is a weak symbol, and there is a real definition, the
488 processor independent code will have arranged for us to see the
489 real definition first, and we can just use the same value. */
490 if (h->u.weakdef != NULL)
492 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
493 || h->u.weakdef->root.type == bfd_link_hash_defweak);
494 h->root.u.def.section = h->u.weakdef->root.u.def.section;
495 h->root.u.def.value = h->u.weakdef->root.u.def.value;
499 /* This is a reference to a symbol defined by a dynamic object which
500 is not a function. */
502 /* If we are creating a shared library, we must presume that the
503 only references to the symbol are via the global offset table.
504 For such cases we need not do anything here; the relocations will
505 be handled correctly by relocate_section. */
506 if (bfd_link_pic (info))
509 /* We must allocate the symbol in our .dynbss section, which will
510 become part of the .bss section of the executable. There will be
511 an entry for this symbol in the .dynsym section. The dynamic
512 object will contain position independent code, so all references
513 from the dynamic object to this symbol will go through the global
514 offset table. The dynamic linker will use the .dynsym entry to
515 determine the address it must put in the global offset table, so
516 both the dynamic object and the regular object will refer to the
517 same memory location for the variable.
519 Of course, if the symbol is sufficiently small, we must instead
520 allocate it in .sbss. FIXME: It would be better to do this if and
521 only if there were actually SDAREL relocs for that symbol. */
523 if (h->size <= elf_gp_size (dynobj))
524 s = bfd_get_linker_section (dynobj, ".dynsbss");
526 s = bfd_get_linker_section (dynobj, ".dynbss");
527 BFD_ASSERT (s != NULL);
529 /* We must generate a R_I370_COPY reloc to tell the dynamic linker to
530 copy the initial value out of the dynamic object and into the
531 runtime process image. We need to remember the offset into the
532 .rela.bss section we are going to use. */
533 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
537 if (h->size <= elf_gp_size (dynobj))
538 srel = bfd_get_linker_section (dynobj, ".rela.sbss");
540 srel = bfd_get_linker_section (dynobj, ".rela.bss");
541 BFD_ASSERT (srel != NULL);
542 srel->size += sizeof (Elf32_External_Rela);
546 return _bfd_elf_adjust_dynamic_copy (info, h, s);
549 /* Increment the index of a dynamic symbol by a given amount. Called
550 via elf_link_hash_traverse. */
551 /* XXX hack alert bogus This routine is mostly all junk and almost
552 certainly does the wrong thing. Its here simply because it does
553 just enough to allow glibc-2.1 ld.so to compile & link. */
556 i370_elf_adjust_dynindx (struct elf_link_hash_entry *h, void * cparg)
558 int *cp = (int *) cparg;
562 "i370_elf_adjust_dynindx called, h->dynindx = %ld, *cp = %d\n",
566 if (h->dynindx != -1)
572 /* Set the sizes of the dynamic sections. */
573 /* XXX hack alert bogus This routine is mostly all junk and almost
574 certainly does the wrong thing. Its here simply because it does
575 just enough to allow glibc-2.1 ld.so to compile & link. */
578 i370_elf_size_dynamic_sections (bfd *output_bfd,
579 struct bfd_link_info *info)
588 fprintf (stderr, "i370_elf_size_dynamic_sections called\n");
591 dynobj = elf_hash_table (info)->dynobj;
592 BFD_ASSERT (dynobj != NULL);
594 if (elf_hash_table (info)->dynamic_sections_created)
596 /* Set the contents of the .interp section to the interpreter. */
597 if (bfd_link_executable (info))
599 s = bfd_get_linker_section (dynobj, ".interp");
600 BFD_ASSERT (s != NULL);
601 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
602 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
607 /* We may have created entries in the .rela.got, .rela.sdata, and
608 .rela.sdata2 sections. However, if we are not creating the
609 dynamic sections, we will not actually use these entries. Reset
610 the size of .rela.got, et al, which will cause it to get
611 stripped from the output file below. */
612 static char *rela_sections[] = { ".rela.got", ".rela.sdata",
613 ".rela.sdata2", ".rela.sbss",
617 for (p = rela_sections; *p != NULL; p++)
619 s = bfd_get_linker_section (dynobj, *p);
625 /* The check_relocs and adjust_dynamic_symbol entry points have
626 determined the sizes of the various dynamic sections. Allocate
631 for (s = dynobj->sections; s != NULL; s = s->next)
635 if ((s->flags & SEC_LINKER_CREATED) == 0)
638 /* It's OK to base decisions on the section name, because none
639 of the dynobj section names depend upon the input files. */
640 name = bfd_get_section_name (dynobj, s);
642 if (strcmp (name, ".plt") == 0)
644 /* Remember whether there is a PLT. */
647 else if (CONST_STRNEQ (name, ".rela"))
654 /* Remember whether there are any relocation sections. */
657 /* If this relocation section applies to a read only
658 section, then we probably need a DT_TEXTREL entry. */
659 outname = bfd_get_section_name (output_bfd,
661 target = bfd_get_section_by_name (output_bfd, outname + 5);
663 && (target->flags & SEC_READONLY) != 0
664 && (target->flags & SEC_ALLOC) != 0)
667 /* We use the reloc_count field as a counter if we need
668 to copy relocs into the output file. */
672 else if (strcmp (name, ".got") != 0
673 && strcmp (name, ".sdata") != 0
674 && strcmp (name, ".sdata2") != 0
675 && strcmp (name, ".dynbss") != 0
676 && strcmp (name, ".dynsbss") != 0)
678 /* It's not one of our sections, so don't allocate space. */
684 /* If we don't need this section, strip it from the
685 output file. This is mostly to handle .rela.bss and
686 .rela.plt. We must create both sections in
687 create_dynamic_sections, because they must be created
688 before the linker maps input sections to output
689 sections. The linker does that before
690 adjust_dynamic_symbol is called, and it is that
691 function which decides whether anything needs to go
692 into these sections. */
693 s->flags |= SEC_EXCLUDE;
697 if ((s->flags & SEC_HAS_CONTENTS) == 0)
700 /* Allocate memory for the section contents. */
701 s->contents = bfd_zalloc (dynobj, s->size);
702 if (s->contents == NULL)
706 if (elf_hash_table (info)->dynamic_sections_created)
708 /* Add some entries to the .dynamic section. We fill in the
709 values later, in i370_elf_finish_dynamic_sections, but we
710 must add the entries now so that we get the correct size for
711 the .dynamic section. The DT_DEBUG entry is filled in by the
712 dynamic linker and used by the debugger. */
713 #define add_dynamic_entry(TAG, VAL) \
714 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
716 if (!bfd_link_pic (info))
718 if (!add_dynamic_entry (DT_DEBUG, 0))
724 if (!add_dynamic_entry (DT_PLTGOT, 0)
725 || !add_dynamic_entry (DT_PLTRELSZ, 0)
726 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
727 || !add_dynamic_entry (DT_JMPREL, 0))
733 if (!add_dynamic_entry (DT_RELA, 0)
734 || !add_dynamic_entry (DT_RELASZ, 0)
735 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
741 if (!add_dynamic_entry (DT_TEXTREL, 0))
743 info->flags |= DF_TEXTREL;
746 #undef add_dynamic_entry
748 /* If we are generating a shared library, we generate a section
749 symbol for each output section. These are local symbols, which
750 means that they must come first in the dynamic symbol table.
751 That means we must increment the dynamic symbol index of every
752 other dynamic symbol.
754 FIXME: We assume that there will never be relocations to
755 locations in linker-created sections that do not have
756 externally-visible names. Instead, we should work out precisely
757 which sections relocations are targeted at. */
758 if (bfd_link_pic (info))
762 for (c = 0, s = output_bfd->sections; s != NULL; s = s->next)
764 if ((s->flags & SEC_LINKER_CREATED) != 0
765 || (s->flags & SEC_ALLOC) == 0)
767 elf_section_data (s)->dynindx = -1;
771 /* These symbols will have no names, so we don't need to
772 fiddle with dynstr_index. */
774 elf_section_data (s)->dynindx = c + 1;
779 elf_link_hash_traverse (elf_hash_table (info),
780 i370_elf_adjust_dynindx, & c);
781 elf_hash_table (info)->dynsymcount += c;
787 /* Look through the relocs for a section during the first phase, and
788 allocate space in the global offset table or procedure linkage
790 /* XXX hack alert bogus This routine is mostly all junk and almost
791 certainly does the wrong thing. Its here simply because it does
792 just enough to allow glibc-2.1 ld.so to compile & link. */
795 i370_elf_check_relocs (bfd *abfd,
796 struct bfd_link_info *info,
798 const Elf_Internal_Rela *relocs)
801 Elf_Internal_Shdr *symtab_hdr;
802 struct elf_link_hash_entry **sym_hashes;
803 const Elf_Internal_Rela *rel;
804 const Elf_Internal_Rela *rel_end;
807 if (bfd_link_relocatable (info))
811 _bfd_error_handler ("i370_elf_check_relocs called for section %A in %B",
815 dynobj = elf_hash_table (info)->dynobj;
816 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
817 sym_hashes = elf_sym_hashes (abfd);
821 rel_end = relocs + sec->reloc_count;
822 for (rel = relocs; rel < rel_end; rel++)
824 unsigned long r_symndx;
825 struct elf_link_hash_entry *h;
827 r_symndx = ELF32_R_SYM (rel->r_info);
828 if (r_symndx < symtab_hdr->sh_info)
832 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
833 while (h->root.type == bfd_link_hash_indirect
834 || h->root.type == bfd_link_hash_warning)
835 h = (struct elf_link_hash_entry *) h->root.u.i.link;
837 /* PR15323, ref flags aren't set for references in the same
839 h->root.non_ir_ref = 1;
842 if (bfd_link_pic (info))
846 "i370_elf_check_relocs needs to create relocation for %s\n",
847 (h && h->root.root.string)
848 ? h->root.root.string : "<unknown>");
852 sreloc = _bfd_elf_make_dynamic_reloc_section
853 (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
859 sreloc->size += sizeof (Elf32_External_Rela);
861 /* FIXME: We should here do what the m68k and i386
862 backends do: if the reloc is pc-relative, record it
863 in case it turns out that the reloc is unnecessary
864 because the symbol is forced local by versioning or
865 we are linking with -Bdynamic. Fortunately this
866 case is not frequent. */
873 /* Finish up the dynamic sections. */
874 /* XXX hack alert bogus This routine is mostly all junk and almost
875 certainly does the wrong thing. Its here simply because it does
876 just enough to allow glibc-2.1 ld.so to compile & link. */
879 i370_elf_finish_dynamic_sections (bfd *output_bfd,
880 struct bfd_link_info *info)
883 bfd *dynobj = elf_hash_table (info)->dynobj;
884 asection *sgot = bfd_get_linker_section (dynobj, ".got");
887 fprintf (stderr, "i370_elf_finish_dynamic_sections called\n");
890 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
892 if (elf_hash_table (info)->dynamic_sections_created)
895 Elf32_External_Dyn *dyncon, *dynconend;
897 splt = bfd_get_linker_section (dynobj, ".plt");
898 BFD_ASSERT (splt != NULL && sdyn != NULL);
900 dyncon = (Elf32_External_Dyn *) sdyn->contents;
901 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
902 for (; dyncon < dynconend; dyncon++)
904 Elf_Internal_Dyn dyn;
908 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
912 case DT_PLTGOT: name = ".plt"; size = FALSE; break;
913 case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
914 case DT_JMPREL: name = ".rela.plt"; size = FALSE; break;
915 default: name = NULL; size = FALSE; break;
922 s = bfd_get_section_by_name (output_bfd, name);
928 dyn.d_un.d_ptr = s->vma;
930 dyn.d_un.d_val = s->size;
932 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
937 if (sgot && sgot->size != 0)
939 unsigned char *contents = sgot->contents;
942 bfd_put_32 (output_bfd, (bfd_vma) 0, contents);
944 bfd_put_32 (output_bfd,
945 sdyn->output_section->vma + sdyn->output_offset,
948 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
951 if (bfd_link_pic (info))
955 Elf_Internal_Sym sym;
958 /* Set up the section symbols for the output sections. */
960 sdynsym = bfd_get_linker_section (dynobj, ".dynsym");
961 BFD_ASSERT (sdynsym != NULL);
965 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
967 sym.st_target_internal = 0;
969 for (s = output_bfd->sections; s != NULL; s = s->next)
972 Elf32_External_Sym *esym;
974 sym.st_value = s->vma;
976 indx = elf_section_data (s)->this_idx;
977 dindx = elf_section_data (s)->dynindx;
980 BFD_ASSERT(indx > 0);
981 BFD_ASSERT(dindx > 0);
983 if (dindx > maxdindx)
988 esym = (Elf32_External_Sym *) sdynsym->contents + dindx;
989 bfd_elf32_swap_symbol_out (output_bfd, &sym, esym, NULL);
993 /* Set the sh_info field of the output .dynsym section to the
994 index of the first global symbol. */
995 elf_section_data (sdynsym->output_section)->this_hdr.sh_info =
1002 /* The RELOCATE_SECTION function is called by the ELF backend linker
1003 to handle the relocations for a section.
1005 The relocs are always passed as Rela structures; if the section
1006 actually uses Rel structures, the r_addend field will always be
1009 This function is responsible for adjust the section contents as
1010 necessary, and (if using Rela relocs and generating a
1011 relocatable output file) adjusting the reloc addend as
1014 This function does not have to worry about setting the reloc
1015 address or the reloc symbol index.
1017 LOCAL_SYMS is a pointer to the swapped in local symbols.
1019 LOCAL_SECTIONS is an array giving the section in the input file
1020 corresponding to the st_shndx field of each local symbol.
1022 The global hash table entry for the global symbols can be found
1023 via elf_sym_hashes (input_bfd).
1025 When generating relocatable output, this function must handle
1026 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1027 going to be the section symbol corresponding to the output
1028 section, which means that the addend must be adjusted
1032 i370_elf_relocate_section (bfd *output_bfd,
1033 struct bfd_link_info *info,
1035 asection *input_section,
1037 Elf_Internal_Rela *relocs,
1038 Elf_Internal_Sym *local_syms,
1039 asection **local_sections)
1041 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1042 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
1043 Elf_Internal_Rela *rel = relocs;
1044 Elf_Internal_Rela *relend = relocs + input_section->reloc_count;
1045 asection *sreloc = NULL;
1046 bfd_boolean ret = TRUE;
1049 _bfd_error_handler ("i370_elf_relocate_section called for %B section %A, %ld relocations%s",
1050 input_bfd, input_section,
1051 (long) input_section->reloc_count,
1052 (bfd_link_relocatable (info)) ? " (relocatable)" : "");
1055 if (!i370_elf_howto_table[ R_I370_ADDR31 ])
1056 /* Initialize howto table if needed. */
1057 i370_elf_howto_init ();
1059 for (; rel < relend; rel++)
1061 enum i370_reloc_type r_type = (enum i370_reloc_type) ELF32_R_TYPE (rel->r_info);
1062 bfd_vma offset = rel->r_offset;
1063 bfd_vma addend = rel->r_addend;
1064 bfd_reloc_status_type r = bfd_reloc_other;
1065 Elf_Internal_Sym *sym = NULL;
1066 asection *sec = NULL;
1067 struct elf_link_hash_entry * h = NULL;
1068 const char *sym_name = NULL;
1069 reloc_howto_type *howto;
1070 unsigned long r_symndx;
1073 /* Unknown relocation handling. */
1074 if ((unsigned) r_type >= (unsigned) R_I370_max
1075 || !i370_elf_howto_table[(int)r_type])
1077 (*_bfd_error_handler) ("%B: unknown relocation type %d",
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 if ((*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))))
1152 if (sec != NULL && discarded_section (sec))
1153 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1154 rel, 1, relend, howto, 0, contents);
1156 if (bfd_link_relocatable (info))
1159 switch ((int) r_type)
1162 (*_bfd_error_handler)
1163 ("%B: unknown relocation type %d for symbol %s",
1164 input_bfd, (int) r_type, sym_name);
1166 bfd_set_error (bfd_error_bad_value);
1170 case (int) R_I370_NONE:
1173 /* Relocations that may need to be propagated if this is a shared
1175 case (int) R_I370_REL31:
1176 /* If these relocations are not to a named symbol, they can be
1177 handled right here, no need to bother the dynamic linker. */
1179 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1183 /* Relocations that always need to be propagated if this is a shared
1185 case (int) R_I370_ADDR31:
1186 case (int) R_I370_ADDR16:
1187 if (bfd_link_pic (info)
1188 && r_symndx != STN_UNDEF)
1190 Elf_Internal_Rela outrel;
1196 "i370_elf_relocate_section needs to create relocation for %s\n",
1197 (h && h->root.root.string) ? h->root.root.string : "<unknown>");
1200 /* When generating a shared object, these relocations
1201 are copied into the output file to be resolved at run
1206 sreloc = _bfd_elf_get_dynamic_reloc_section
1207 (input_bfd, input_section, /*rela?*/ TRUE);
1215 _bfd_elf_section_offset (output_bfd, info, input_section,
1217 if (outrel.r_offset == (bfd_vma) -1
1218 || outrel.r_offset == (bfd_vma) -2)
1219 skip = (int) outrel.r_offset;
1220 outrel.r_offset += (input_section->output_section->vma
1221 + input_section->output_offset);
1224 memset (&outrel, 0, sizeof outrel);
1225 /* h->dynindx may be -1 if this symbol was marked to
1228 && ((! info->symbolic && h->dynindx != -1)
1229 || !h->def_regular))
1231 BFD_ASSERT (h->dynindx != -1);
1232 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1233 outrel.r_addend = rel->r_addend;
1237 if (r_type == R_I370_ADDR31)
1239 outrel.r_info = ELF32_R_INFO (0, R_I370_RELATIVE);
1240 outrel.r_addend = relocation + rel->r_addend;
1246 if (bfd_is_abs_section (sec))
1248 else if (sec == NULL || sec->owner == NULL)
1250 bfd_set_error (bfd_error_bad_value);
1257 /* We are turning this relocation into one
1258 against a section symbol. It would be
1259 proper to subtract the symbol's value,
1260 osec->vma, from the emitted reloc addend,
1261 but ld.so expects buggy relocs. */
1262 osec = sec->output_section;
1263 indx = elf_section_data (osec)->dynindx;
1266 struct elf_link_hash_table *htab;
1267 htab = elf_hash_table (info);
1268 osec = htab->text_index_section;
1269 indx = elf_section_data (osec)->dynindx;
1271 BFD_ASSERT (indx != 0);
1275 printf ("indx=%ld section=%s flags=%08x name=%s\n",
1276 indx, osec->name, osec->flags,
1277 h->root.root.string);
1282 outrel.r_info = ELF32_R_INFO (indx, r_type);
1283 outrel.r_addend = relocation + rel->r_addend;
1287 loc = sreloc->contents;
1288 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1289 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1291 /* This reloc will be computed at runtime, so there's no
1292 need to do anything now, unless this is a RELATIVE
1293 reloc in an unallocated section. */
1295 || (input_section->flags & SEC_ALLOC) != 0
1296 || ELF32_R_TYPE (outrel.r_info) != R_I370_RELATIVE)
1301 case (int) R_I370_COPY:
1302 case (int) R_I370_RELATIVE:
1303 (*_bfd_error_handler)
1304 ("%B: Relocation %s is not yet supported for symbol %s.",
1306 i370_elf_howto_table[(int) r_type]->name,
1309 bfd_set_error (bfd_error_invalid_operation);
1315 fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, offset = %ld, addend = %ld\n",
1324 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
1325 offset, relocation, addend);
1327 if (r != bfd_reloc_ok)
1335 case bfd_reloc_overflow:
1343 name = bfd_elf_string_from_elf_section (input_bfd,
1344 symtab_hdr->sh_link,
1350 name = bfd_section_name (input_bfd, sec);
1353 (*info->callbacks->reloc_overflow) (info,
1354 (h ? &h->root : NULL),
1368 fprintf (stderr, "\n");
1374 #define TARGET_BIG_SYM i370_elf32_vec
1375 #define TARGET_BIG_NAME "elf32-i370"
1376 #define ELF_ARCH bfd_arch_i370
1377 #define ELF_MACHINE_CODE EM_S370
1379 #define ELF_MACHINE_ALT1 EM_I370_OLD
1381 #define ELF_MAXPAGESIZE 0x1000
1382 #define ELF_OSABI ELFOSABI_GNU
1384 #define elf_info_to_howto i370_elf_info_to_howto
1386 #define elf_backend_plt_not_loaded 1
1387 #define elf_backend_rela_normal 1
1389 #define bfd_elf32_bfd_reloc_type_lookup i370_elf_reloc_type_lookup
1390 #define bfd_elf32_bfd_reloc_name_lookup i370_elf_reloc_name_lookup
1391 #define bfd_elf32_bfd_set_private_flags i370_elf_set_private_flags
1392 #define bfd_elf32_bfd_merge_private_bfd_data i370_elf_merge_private_bfd_data
1393 #define elf_backend_relocate_section i370_elf_relocate_section
1395 /* Dynamic loader support is mostly broken; just enough here to be able to
1396 link glibc's ld.so without errors. */
1397 #define elf_backend_create_dynamic_sections i370_elf_create_dynamic_sections
1398 #define elf_backend_size_dynamic_sections i370_elf_size_dynamic_sections
1399 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
1400 #define elf_backend_finish_dynamic_sections i370_elf_finish_dynamic_sections
1401 #define elf_backend_fake_sections i370_elf_fake_sections
1402 #define elf_backend_section_from_shdr i370_elf_section_from_shdr
1403 #define elf_backend_adjust_dynamic_symbol i370_elf_adjust_dynamic_symbol
1404 #define elf_backend_check_relocs i370_elf_check_relocs
1412 #define elf_backend_finish_dynamic_symbol \
1414 (bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, \
1415 Elf_Internal_Sym *)) i370_noop
1417 #include "elf32-target.h"