1 /* i370-specific support for 32-bit ELF
2 Copyright (C) 1994-2018 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
,
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 /* xgettext:c-format */
307 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
309 bfd_set_error (bfd_error_bad_value
);
312 cache_ptr
->howto
= i370_elf_howto_table
[r_type
];
316 /* Hack alert -- the following several routines look generic to me ...
317 why are we bothering with them ? */
318 /* Function to set whether a module needs the -mrelocatable bit set. */
321 i370_elf_set_private_flags (bfd
*abfd
, flagword flags
)
323 BFD_ASSERT (!elf_flags_init (abfd
)
324 || elf_elfheader (abfd
)->e_flags
== flags
);
326 elf_elfheader (abfd
)->e_flags
= flags
;
327 elf_flags_init (abfd
) = TRUE
;
331 /* Merge backend specific data from an object file to the output
332 object file when linking. */
335 i370_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
337 bfd
*obfd
= info
->output_bfd
;
341 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
342 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
345 new_flags
= elf_elfheader (ibfd
)->e_flags
;
346 old_flags
= elf_elfheader (obfd
)->e_flags
;
347 if (!elf_flags_init (obfd
)) /* First call, no flags set. */
349 elf_flags_init (obfd
) = TRUE
;
350 elf_elfheader (obfd
)->e_flags
= new_flags
;
353 else if (new_flags
== old_flags
) /* Compatible flags are ok. */
356 else /* Incompatible flags. */
359 /* xgettext:c-format */
360 (_("%pB: uses different e_flags (%#x) fields than previous modules (%#x)"),
361 ibfd
, new_flags
, old_flags
);
363 bfd_set_error (bfd_error_bad_value
);
370 /* Handle an i370 specific section when reading an object file. This
371 is called when elfcode.h finds a section with an unknown type. */
372 /* XXX hack alert bogus This routine is mostly all junk and almost
373 certainly does the wrong thing. Its here simply because it does
374 just enough to allow glibc-2.1 ld.so to compile & link. */
377 i370_elf_section_from_shdr (bfd
*abfd
,
378 Elf_Internal_Shdr
*hdr
,
385 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
388 newsect
= hdr
->bfd_section
;
389 flags
= bfd_get_section_flags (abfd
, newsect
);
390 if (hdr
->sh_type
== SHT_ORDERED
)
391 flags
|= SEC_SORT_ENTRIES
;
393 bfd_set_section_flags (abfd
, newsect
, flags
);
397 /* Set up any other section flags and such that may be necessary. */
398 /* XXX hack alert bogus This routine is mostly all junk and almost
399 certainly does the wrong thing. Its here simply because it does
400 just enough to allow glibc-2.1 ld.so to compile & link. */
403 i370_elf_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
404 Elf_Internal_Shdr
*shdr
,
407 if ((asect
->flags
& (SEC_GROUP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
408 shdr
->sh_flags
|= SHF_EXCLUDE
;
410 if ((asect
->flags
& SEC_SORT_ENTRIES
) != 0)
411 shdr
->sh_type
= SHT_ORDERED
;
416 /* We have to create .dynsbss and .rela.sbss here so that they get mapped
417 to output sections (just like _bfd_elf_create_dynamic_sections has
418 to create .dynbss and .rela.bss). */
419 /* XXX hack alert bogus This routine is mostly all junk and almost
420 certainly does the wrong thing. Its here simply because it does
421 just enough to allow glibc-2.1 ld.so to compile & link. */
424 i370_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
429 if (!_bfd_elf_create_dynamic_sections(abfd
, info
))
432 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
433 | SEC_LINKER_CREATED
);
435 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynsbss",
436 SEC_ALLOC
| SEC_LINKER_CREATED
);
440 if (! bfd_link_pic (info
))
442 s
= bfd_make_section_anyway_with_flags (abfd
, ".rela.sbss",
443 flags
| SEC_READONLY
);
445 || ! bfd_set_section_alignment (abfd
, s
, 2))
449 /* XXX beats me, seem to need a rela.text ... */
450 s
= bfd_make_section_anyway_with_flags (abfd
, ".rela.text",
451 flags
| SEC_READONLY
);
453 || ! bfd_set_section_alignment (abfd
, s
, 2))
458 /* Adjust a symbol defined by a dynamic object and referenced by a
459 regular object. The current definition is in some section of the
460 dynamic object, but we're not including those sections. We have to
461 change the definition to something the rest of the link can
463 /* XXX hack alert bogus This routine is mostly all junk and almost
464 certainly does the wrong thing. Its here simply because it does
465 just enough to allow glibc-2.1 ld.so to compile & link. */
468 i370_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
469 struct elf_link_hash_entry
*h
)
471 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
475 fprintf (stderr
, "i370_elf_adjust_dynamic_symbol called for %s\n",
476 h
->root
.root
.string
);
479 /* Make sure we know what is going on here. */
480 BFD_ASSERT (dynobj
!= NULL
485 && !h
->def_regular
)));
487 s
= bfd_get_linker_section (dynobj
, ".rela.text");
488 BFD_ASSERT (s
!= NULL
);
489 s
->size
+= sizeof (Elf32_External_Rela
);
491 /* If this is a weak symbol, and there is a real definition, the
492 processor independent code will have arranged for us to see the
493 real definition first, and we can just use the same value. */
496 struct elf_link_hash_entry
*def
= weakdef (h
);
497 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
498 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
499 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
503 /* This is a reference to a symbol defined by a dynamic object which
504 is not a function. */
506 /* If we are creating a shared library, we must presume that the
507 only references to the symbol are via the global offset table.
508 For such cases we need not do anything here; the relocations will
509 be handled correctly by relocate_section. */
510 if (bfd_link_pic (info
))
513 /* We must allocate the symbol in our .dynbss section, which will
514 become part of the .bss section of the executable. There will be
515 an entry for this symbol in the .dynsym section. The dynamic
516 object will contain position independent code, so all references
517 from the dynamic object to this symbol will go through the global
518 offset table. The dynamic linker will use the .dynsym entry to
519 determine the address it must put in the global offset table, so
520 both the dynamic object and the regular object will refer to the
521 same memory location for the variable.
523 Of course, if the symbol is sufficiently small, we must instead
524 allocate it in .sbss. FIXME: It would be better to do this if and
525 only if there were actually SDAREL relocs for that symbol. */
527 if (h
->size
<= elf_gp_size (dynobj
))
528 s
= bfd_get_linker_section (dynobj
, ".dynsbss");
530 s
= bfd_get_linker_section (dynobj
, ".dynbss");
531 BFD_ASSERT (s
!= NULL
);
533 /* We must generate a R_I370_COPY reloc to tell the dynamic linker to
534 copy the initial value out of the dynamic object and into the
535 runtime process image. We need to remember the offset into the
536 .rela.bss section we are going to use. */
537 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
541 if (h
->size
<= elf_gp_size (dynobj
))
542 srel
= bfd_get_linker_section (dynobj
, ".rela.sbss");
544 srel
= bfd_get_linker_section (dynobj
, ".rela.bss");
545 BFD_ASSERT (srel
!= NULL
);
546 srel
->size
+= sizeof (Elf32_External_Rela
);
550 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
553 /* Increment the index of a dynamic symbol by a given amount. Called
554 via elf_link_hash_traverse. */
555 /* XXX hack alert bogus This routine is mostly all junk and almost
556 certainly does the wrong thing. Its here simply because it does
557 just enough to allow glibc-2.1 ld.so to compile & link. */
560 i370_elf_adjust_dynindx (struct elf_link_hash_entry
*h
, void * cparg
)
562 int *cp
= (int *) cparg
;
566 "i370_elf_adjust_dynindx called, h->dynindx = %ld, *cp = %d\n",
570 if (h
->dynindx
!= -1)
576 /* Set the sizes of the dynamic sections. */
577 /* XXX hack alert bogus This routine is mostly all junk and almost
578 certainly does the wrong thing. Its here simply because it does
579 just enough to allow glibc-2.1 ld.so to compile & link. */
582 i370_elf_size_dynamic_sections (bfd
*output_bfd
,
583 struct bfd_link_info
*info
)
592 fprintf (stderr
, "i370_elf_size_dynamic_sections called\n");
595 dynobj
= elf_hash_table (info
)->dynobj
;
596 BFD_ASSERT (dynobj
!= NULL
);
598 if (elf_hash_table (info
)->dynamic_sections_created
)
600 /* Set the contents of the .interp section to the interpreter. */
601 if (bfd_link_executable (info
) && !info
->nointerp
)
603 s
= bfd_get_linker_section (dynobj
, ".interp");
604 BFD_ASSERT (s
!= NULL
);
605 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
606 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
611 /* We may have created entries in the .rela.got, .rela.sdata, and
612 .rela.sdata2 sections. However, if we are not creating the
613 dynamic sections, we will not actually use these entries. Reset
614 the size of .rela.got, et al, which will cause it to get
615 stripped from the output file below. */
616 static char *rela_sections
[] = { ".rela.got", ".rela.sdata",
617 ".rela.sdata2", ".rela.sbss",
621 for (p
= rela_sections
; *p
!= NULL
; p
++)
623 s
= bfd_get_linker_section (dynobj
, *p
);
629 /* The check_relocs and adjust_dynamic_symbol entry points have
630 determined the sizes of the various dynamic sections. Allocate
635 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
639 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
642 /* It's OK to base decisions on the section name, because none
643 of the dynobj section names depend upon the input files. */
644 name
= bfd_get_section_name (dynobj
, s
);
646 if (strcmp (name
, ".plt") == 0)
648 /* Remember whether there is a PLT. */
651 else if (CONST_STRNEQ (name
, ".rela"))
658 /* Remember whether there are any relocation sections. */
661 /* If this relocation section applies to a read only
662 section, then we probably need a DT_TEXTREL entry. */
663 outname
= bfd_get_section_name (output_bfd
,
665 target
= bfd_get_section_by_name (output_bfd
, outname
+ 5);
667 && (target
->flags
& SEC_READONLY
) != 0
668 && (target
->flags
& SEC_ALLOC
) != 0)
671 /* We use the reloc_count field as a counter if we need
672 to copy relocs into the output file. */
676 else if (strcmp (name
, ".got") != 0
677 && strcmp (name
, ".sdata") != 0
678 && strcmp (name
, ".sdata2") != 0
679 && strcmp (name
, ".dynbss") != 0
680 && strcmp (name
, ".dynsbss") != 0)
682 /* It's not one of our sections, so don't allocate space. */
688 /* If we don't need this section, strip it from the
689 output file. This is mostly to handle .rela.bss and
690 .rela.plt. We must create both sections in
691 create_dynamic_sections, because they must be created
692 before the linker maps input sections to output
693 sections. The linker does that before
694 adjust_dynamic_symbol is called, and it is that
695 function which decides whether anything needs to go
696 into these sections. */
697 s
->flags
|= SEC_EXCLUDE
;
701 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
704 /* Allocate memory for the section contents. */
705 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
706 if (s
->contents
== NULL
)
710 if (elf_hash_table (info
)->dynamic_sections_created
)
712 /* Add some entries to the .dynamic section. We fill in the
713 values later, in i370_elf_finish_dynamic_sections, but we
714 must add the entries now so that we get the correct size for
715 the .dynamic section. The DT_DEBUG entry is filled in by the
716 dynamic linker and used by the debugger. */
717 #define add_dynamic_entry(TAG, VAL) \
718 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
720 if (!bfd_link_pic (info
))
722 if (!add_dynamic_entry (DT_DEBUG
, 0))
728 if (!add_dynamic_entry (DT_PLTGOT
, 0)
729 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
730 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
731 || !add_dynamic_entry (DT_JMPREL
, 0))
737 if (!add_dynamic_entry (DT_RELA
, 0)
738 || !add_dynamic_entry (DT_RELASZ
, 0)
739 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
745 if (!add_dynamic_entry (DT_TEXTREL
, 0))
747 info
->flags
|= DF_TEXTREL
;
750 #undef add_dynamic_entry
752 /* If we are generating a shared library, we generate a section
753 symbol for each output section. These are local symbols, which
754 means that they must come first in the dynamic symbol table.
755 That means we must increment the dynamic symbol index of every
756 other dynamic symbol.
758 FIXME: We assume that there will never be relocations to
759 locations in linker-created sections that do not have
760 externally-visible names. Instead, we should work out precisely
761 which sections relocations are targeted at. */
762 if (bfd_link_pic (info
))
766 for (c
= 0, s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
768 if ((s
->flags
& SEC_LINKER_CREATED
) != 0
769 || (s
->flags
& SEC_ALLOC
) == 0)
771 elf_section_data (s
)->dynindx
= -1;
775 /* These symbols will have no names, so we don't need to
776 fiddle with dynstr_index. */
778 elf_section_data (s
)->dynindx
= c
+ 1;
783 elf_link_hash_traverse (elf_hash_table (info
),
784 i370_elf_adjust_dynindx
, & c
);
785 elf_hash_table (info
)->dynsymcount
+= c
;
791 /* Look through the relocs for a section during the first phase, and
792 allocate space in the global offset table or procedure linkage
794 /* XXX hack alert bogus This routine is mostly all junk and almost
795 certainly does the wrong thing. Its here simply because it does
796 just enough to allow glibc-2.1 ld.so to compile & link. */
799 i370_elf_check_relocs (bfd
*abfd
,
800 struct bfd_link_info
*info
,
802 const Elf_Internal_Rela
*relocs
)
805 Elf_Internal_Shdr
*symtab_hdr
;
806 struct elf_link_hash_entry
**sym_hashes
;
807 const Elf_Internal_Rela
*rel
;
808 const Elf_Internal_Rela
*rel_end
;
811 if (bfd_link_relocatable (info
))
815 _bfd_error_handler ("i370_elf_check_relocs called for section %pA in %pB",
819 dynobj
= elf_hash_table (info
)->dynobj
;
820 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
821 sym_hashes
= elf_sym_hashes (abfd
);
825 rel_end
= relocs
+ sec
->reloc_count
;
826 for (rel
= relocs
; rel
< rel_end
; rel
++)
828 unsigned long r_symndx
;
829 struct elf_link_hash_entry
*h
;
831 r_symndx
= ELF32_R_SYM (rel
->r_info
);
832 if (r_symndx
< symtab_hdr
->sh_info
)
836 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
837 while (h
->root
.type
== bfd_link_hash_indirect
838 || h
->root
.type
== bfd_link_hash_warning
)
839 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
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
= elf_hash_table (info
)->sgot
;
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
= elf_hash_table (info
)->splt
;
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
);
913 s
= elf_hash_table (info
)->splt
;
917 s
= elf_hash_table (info
)->srelplt
;
921 s
= elf_hash_table (info
)->srelplt
;
933 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
935 dyn
.d_un
.d_val
= s
->size
;
937 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
941 if (sgot
&& sgot
->size
!= 0)
943 unsigned char *contents
= sgot
->contents
;
946 bfd_put_32 (output_bfd
, (bfd_vma
) 0, contents
);
948 bfd_put_32 (output_bfd
,
949 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
952 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
955 if (bfd_link_pic (info
))
959 Elf_Internal_Sym sym
;
962 /* Set up the section symbols for the output sections. */
964 sdynsym
= bfd_get_linker_section (dynobj
, ".dynsym");
965 BFD_ASSERT (sdynsym
!= NULL
);
969 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
971 sym
.st_target_internal
= 0;
973 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
976 Elf32_External_Sym
*esym
;
978 sym
.st_value
= s
->vma
;
980 indx
= elf_section_data (s
)->this_idx
;
981 dindx
= elf_section_data (s
)->dynindx
;
984 BFD_ASSERT(indx
> 0);
985 BFD_ASSERT(dindx
> 0);
987 if (dindx
> maxdindx
)
992 esym
= (Elf32_External_Sym
*) sdynsym
->contents
+ dindx
;
993 bfd_elf32_swap_symbol_out (output_bfd
, &sym
, esym
, NULL
);
997 /* Set the sh_info field of the output .dynsym section to the
998 index of the first global symbol. */
999 elf_section_data (sdynsym
->output_section
)->this_hdr
.sh_info
=
1006 /* The RELOCATE_SECTION function is called by the ELF backend linker
1007 to handle the relocations for a section.
1009 The relocs are always passed as Rela structures; if the section
1010 actually uses Rel structures, the r_addend field will always be
1013 This function is responsible for adjust the section contents as
1014 necessary, and (if using Rela relocs and generating a
1015 relocatable output file) adjusting the reloc addend as
1018 This function does not have to worry about setting the reloc
1019 address or the reloc symbol index.
1021 LOCAL_SYMS is a pointer to the swapped in local symbols.
1023 LOCAL_SECTIONS is an array giving the section in the input file
1024 corresponding to the st_shndx field of each local symbol.
1026 The global hash table entry for the global symbols can be found
1027 via elf_sym_hashes (input_bfd).
1029 When generating relocatable output, this function must handle
1030 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1031 going to be the section symbol corresponding to the output
1032 section, which means that the addend must be adjusted
1036 i370_elf_relocate_section (bfd
*output_bfd
,
1037 struct bfd_link_info
*info
,
1039 asection
*input_section
,
1041 Elf_Internal_Rela
*relocs
,
1042 Elf_Internal_Sym
*local_syms
,
1043 asection
**local_sections
)
1045 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1046 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
1047 Elf_Internal_Rela
*rel
= relocs
;
1048 Elf_Internal_Rela
*relend
= relocs
+ input_section
->reloc_count
;
1049 asection
*sreloc
= NULL
;
1050 bfd_boolean ret
= TRUE
;
1053 _bfd_error_handler ("i370_elf_relocate_section called for %pB section %pA, %u relocations%s",
1054 input_bfd
, input_section
,
1055 input_section
->reloc_count
,
1056 (bfd_link_relocatable (info
)) ? " (relocatable)" : "");
1059 if (!i370_elf_howto_table
[ R_I370_ADDR31
])
1060 /* Initialize howto table if needed. */
1061 i370_elf_howto_init ();
1063 for (; rel
< relend
; rel
++)
1065 enum i370_reloc_type r_type
= (enum i370_reloc_type
) ELF32_R_TYPE (rel
->r_info
);
1066 bfd_vma offset
= rel
->r_offset
;
1067 bfd_vma addend
= rel
->r_addend
;
1068 bfd_reloc_status_type r
= bfd_reloc_other
;
1069 Elf_Internal_Sym
*sym
= NULL
;
1070 asection
*sec
= NULL
;
1071 struct elf_link_hash_entry
* h
= NULL
;
1072 reloc_howto_type
*howto
;
1073 unsigned long r_symndx
;
1076 /* Unknown relocation handling. */
1077 if ((unsigned) r_type
>= (unsigned) R_I370_max
1078 || !i370_elf_howto_table
[(int)r_type
])
1080 /* xgettext:c-format */
1081 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1082 input_bfd
, (int) r_type
);
1084 bfd_set_error (bfd_error_bad_value
);
1089 howto
= i370_elf_howto_table
[(int) r_type
];
1090 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1093 if (r_symndx
< symtab_hdr
->sh_info
)
1095 sym
= local_syms
+ r_symndx
;
1096 sec
= local_sections
[r_symndx
];
1098 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, & sec
, rel
);
1099 addend
= rel
->r_addend
;
1103 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1105 if (info
->wrap_hash
!= NULL
1106 && (input_section
->flags
& SEC_DEBUGGING
) != 0)
1107 h
= ((struct elf_link_hash_entry
*)
1108 unwrap_hash_lookup (info
, input_bfd
, &h
->root
));
1110 while (h
->root
.type
== bfd_link_hash_indirect
1111 || h
->root
.type
== bfd_link_hash_warning
)
1112 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1113 if (h
->root
.type
== bfd_link_hash_defined
1114 || h
->root
.type
== bfd_link_hash_defweak
)
1116 sec
= h
->root
.u
.def
.section
;
1117 if (bfd_link_pic (info
)
1118 && ((! info
->symbolic
&& h
->dynindx
!= -1)
1120 && (input_section
->flags
& SEC_ALLOC
) != 0
1121 && (r_type
== R_I370_ADDR31
1122 || r_type
== R_I370_COPY
1123 || r_type
== R_I370_ADDR16
1124 || r_type
== R_I370_RELATIVE
))
1125 /* In these cases, we don't need the relocation
1126 value. We check specially because in some
1127 obscure cases sec->output_section will be NULL. */
1130 relocation
= (h
->root
.u
.def
.value
1131 + sec
->output_section
->vma
1132 + sec
->output_offset
);
1134 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1136 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
1137 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1139 else if (!bfd_link_relocatable (info
))
1141 (*info
->callbacks
->undefined_symbol
)
1142 (info
, h
->root
.root
.string
, input_bfd
,
1143 input_section
, rel
->r_offset
,
1144 (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
1145 || ELF_ST_VISIBILITY (h
->other
)));
1151 if (sec
!= NULL
&& discarded_section (sec
))
1152 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
1153 rel
, 1, relend
, howto
, 0, contents
);
1155 if (bfd_link_relocatable (info
))
1158 switch ((int) r_type
)
1162 (_("%pB: unsupported relocation type %#x"),
1163 input_bfd
, (int) r_type
);
1165 bfd_set_error (bfd_error_bad_value
);
1169 case (int) R_I370_NONE
:
1172 /* Relocations that may need to be propagated if this is a shared
1174 case (int) R_I370_REL31
:
1175 /* If these relocations are not to a named symbol, they can be
1176 handled right here, no need to bother the dynamic linker. */
1178 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1182 /* Relocations that always need to be propagated if this is a shared
1184 case (int) R_I370_ADDR31
:
1185 case (int) R_I370_ADDR16
:
1186 if (bfd_link_pic (info
)
1187 && r_symndx
!= STN_UNDEF
)
1189 Elf_Internal_Rela outrel
;
1195 "i370_elf_relocate_section needs to create relocation for %s\n",
1196 (h
&& h
->root
.root
.string
) ? h
->root
.root
.string
: "<unknown>");
1199 /* When generating a shared object, these relocations
1200 are copied into the output file to be resolved at run
1205 sreloc
= _bfd_elf_get_dynamic_reloc_section
1206 (input_bfd
, input_section
, /*rela?*/ TRUE
);
1214 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1216 if (outrel
.r_offset
== (bfd_vma
) -1
1217 || outrel
.r_offset
== (bfd_vma
) -2)
1218 skip
= (int) outrel
.r_offset
;
1219 outrel
.r_offset
+= (input_section
->output_section
->vma
1220 + input_section
->output_offset
);
1223 memset (&outrel
, 0, sizeof outrel
);
1224 /* h->dynindx may be -1 if this symbol was marked to
1227 && ((! info
->symbolic
&& h
->dynindx
!= -1)
1228 || !h
->def_regular
))
1230 BFD_ASSERT (h
->dynindx
!= -1);
1231 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1232 outrel
.r_addend
= rel
->r_addend
;
1236 if (r_type
== R_I370_ADDR31
)
1238 outrel
.r_info
= ELF32_R_INFO (0, R_I370_RELATIVE
);
1239 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1245 if (bfd_is_abs_section (sec
))
1247 else if (sec
== NULL
|| sec
->owner
== NULL
)
1249 bfd_set_error (bfd_error_bad_value
);
1256 /* We are turning this relocation into one
1257 against a section symbol. It would be
1258 proper to subtract the symbol's value,
1259 osec->vma, from the emitted reloc addend,
1260 but ld.so expects buggy relocs. */
1261 osec
= sec
->output_section
;
1262 indx
= elf_section_data (osec
)->dynindx
;
1265 struct elf_link_hash_table
*htab
;
1266 htab
= elf_hash_table (info
);
1267 osec
= htab
->text_index_section
;
1268 indx
= elf_section_data (osec
)->dynindx
;
1270 BFD_ASSERT (indx
!= 0);
1274 printf ("indx=%ld section=%s flags=%08x name=%s\n",
1275 indx
, osec
->name
, osec
->flags
,
1276 h
->root
.root
.string
);
1281 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
1282 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1286 loc
= sreloc
->contents
;
1287 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
1288 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1290 /* This reloc will be computed at runtime, so there's no
1291 need to do anything now, unless this is a RELATIVE
1292 reloc in an unallocated section. */
1294 || (input_section
->flags
& SEC_ALLOC
) != 0
1295 || ELF32_R_TYPE (outrel
.r_info
) != R_I370_RELATIVE
)
1300 case (int) R_I370_COPY
:
1301 case (int) R_I370_RELATIVE
:
1302 /* xgettext:c-format */
1303 _bfd_error_handler (_("%pB: %s unsupported"),
1305 i370_elf_howto_table
[(int) r_type
]->name
);
1306 bfd_set_error (bfd_error_invalid_operation
);
1311 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
, contents
,
1312 offset
, relocation
, addend
);
1314 if (r
!= bfd_reloc_ok
)
1322 case bfd_reloc_overflow
:
1330 name
= bfd_elf_string_from_elf_section (input_bfd
,
1331 symtab_hdr
->sh_link
,
1337 name
= bfd_section_name (input_bfd
, sec
);
1340 (*info
->callbacks
->reloc_overflow
) (info
,
1341 (h
? &h
->root
: NULL
),
1355 fprintf (stderr
, "\n");
1361 #define TARGET_BIG_SYM i370_elf32_vec
1362 #define TARGET_BIG_NAME "elf32-i370"
1363 #define ELF_ARCH bfd_arch_i370
1364 #define ELF_MACHINE_CODE EM_S370
1366 #define ELF_MACHINE_ALT1 EM_I370_OLD
1368 #define ELF_MAXPAGESIZE 0x1000
1369 #define ELF_OSABI ELFOSABI_GNU
1371 #define elf_info_to_howto i370_elf_info_to_howto
1373 #define elf_backend_plt_not_loaded 1
1374 #define elf_backend_rela_normal 1
1376 #define bfd_elf32_bfd_reloc_type_lookup i370_elf_reloc_type_lookup
1377 #define bfd_elf32_bfd_reloc_name_lookup i370_elf_reloc_name_lookup
1378 #define bfd_elf32_bfd_set_private_flags i370_elf_set_private_flags
1379 #define bfd_elf32_bfd_merge_private_bfd_data i370_elf_merge_private_bfd_data
1380 #define elf_backend_relocate_section i370_elf_relocate_section
1382 /* Dynamic loader support is mostly broken; just enough here to be able to
1383 link glibc's ld.so without errors. */
1384 #define elf_backend_create_dynamic_sections i370_elf_create_dynamic_sections
1385 #define elf_backend_size_dynamic_sections i370_elf_size_dynamic_sections
1386 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
1387 #define elf_backend_finish_dynamic_sections i370_elf_finish_dynamic_sections
1388 #define elf_backend_fake_sections i370_elf_fake_sections
1389 #define elf_backend_section_from_shdr i370_elf_section_from_shdr
1390 #define elf_backend_adjust_dynamic_symbol i370_elf_adjust_dynamic_symbol
1391 #define elf_backend_check_relocs i370_elf_check_relocs
1394 i370_noop (bfd
* abfd ATTRIBUTE_UNUSED
, ...)
1399 #define elf_backend_finish_dynamic_symbol \
1401 (bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, \
1402 Elf_Internal_Sym *)) i370_noop
1404 #include "elf32-target.h"