1 /* i370-specific support for 32-bit ELF
2 Copyright (C) 1994-2017 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 /* xgettext:c-format */
307 _bfd_error_handler (_("%B: unrecognised I370 reloc number: %d"),
309 bfd_set_error (bfd_error_bad_value
);
310 r_type
= R_I370_NONE
;
312 cache_ptr
->howto
= i370_elf_howto_table
[r_type
];
315 /* Hack alert -- the following several routines look generic to me ...
316 why are we bothering with them ? */
317 /* Function to set whether a module needs the -mrelocatable bit set. */
320 i370_elf_set_private_flags (bfd
*abfd
, flagword flags
)
322 BFD_ASSERT (!elf_flags_init (abfd
)
323 || elf_elfheader (abfd
)->e_flags
== flags
);
325 elf_elfheader (abfd
)->e_flags
= flags
;
326 elf_flags_init (abfd
) = TRUE
;
330 /* Merge backend specific data from an object file to the output
331 object file when linking. */
334 i370_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
336 bfd
*obfd
= info
->output_bfd
;
340 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
341 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
344 new_flags
= elf_elfheader (ibfd
)->e_flags
;
345 old_flags
= elf_elfheader (obfd
)->e_flags
;
346 if (!elf_flags_init (obfd
)) /* First call, no flags set. */
348 elf_flags_init (obfd
) = TRUE
;
349 elf_elfheader (obfd
)->e_flags
= new_flags
;
352 else if (new_flags
== old_flags
) /* Compatible flags are ok. */
355 else /* Incompatible flags. */
358 /* xgettext:c-format */
359 (_("%B: uses different e_flags (%#x) fields than previous modules (%#x)"),
360 ibfd
, new_flags
, old_flags
);
362 bfd_set_error (bfd_error_bad_value
);
369 /* Handle an i370 specific section when reading an object file. This
370 is called when elfcode.h finds a section with an unknown type. */
371 /* XXX hack alert bogus This routine is mostly all junk and almost
372 certainly does the wrong thing. Its here simply because it does
373 just enough to allow glibc-2.1 ld.so to compile & link. */
376 i370_elf_section_from_shdr (bfd
*abfd
,
377 Elf_Internal_Shdr
*hdr
,
384 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
387 newsect
= hdr
->bfd_section
;
388 flags
= bfd_get_section_flags (abfd
, newsect
);
389 if (hdr
->sh_type
== SHT_ORDERED
)
390 flags
|= SEC_SORT_ENTRIES
;
392 bfd_set_section_flags (abfd
, newsect
, flags
);
396 /* Set up any other section flags and such that may be necessary. */
397 /* XXX hack alert bogus This routine is mostly all junk and almost
398 certainly does the wrong thing. Its here simply because it does
399 just enough to allow glibc-2.1 ld.so to compile & link. */
402 i370_elf_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
403 Elf_Internal_Shdr
*shdr
,
406 if ((asect
->flags
& (SEC_GROUP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
407 shdr
->sh_flags
|= SHF_EXCLUDE
;
409 if ((asect
->flags
& SEC_SORT_ENTRIES
) != 0)
410 shdr
->sh_type
= SHT_ORDERED
;
415 /* We have to create .dynsbss and .rela.sbss here so that they get mapped
416 to output sections (just like _bfd_elf_create_dynamic_sections has
417 to create .dynbss and .rela.bss). */
418 /* XXX hack alert bogus This routine is mostly all junk and almost
419 certainly does the wrong thing. Its here simply because it does
420 just enough to allow glibc-2.1 ld.so to compile & link. */
423 i370_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
428 if (!_bfd_elf_create_dynamic_sections(abfd
, info
))
431 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
432 | SEC_LINKER_CREATED
);
434 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynsbss",
435 SEC_ALLOC
| SEC_LINKER_CREATED
);
439 if (! bfd_link_pic (info
))
441 s
= bfd_make_section_anyway_with_flags (abfd
, ".rela.sbss",
442 flags
| SEC_READONLY
);
444 || ! bfd_set_section_alignment (abfd
, s
, 2))
448 /* XXX beats me, seem to need a rela.text ... */
449 s
= bfd_make_section_anyway_with_flags (abfd
, ".rela.text",
450 flags
| SEC_READONLY
);
452 || ! bfd_set_section_alignment (abfd
, s
, 2))
457 /* Adjust a symbol defined by a dynamic object and referenced by a
458 regular object. The current definition is in some section of the
459 dynamic object, but we're not including those sections. We have to
460 change the definition to something the rest of the link can
462 /* XXX hack alert bogus This routine is mostly all junk and almost
463 certainly does the wrong thing. Its here simply because it does
464 just enough to allow glibc-2.1 ld.so to compile & link. */
467 i370_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
468 struct elf_link_hash_entry
*h
)
470 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
474 fprintf (stderr
, "i370_elf_adjust_dynamic_symbol called for %s\n",
475 h
->root
.root
.string
);
478 /* Make sure we know what is going on here. */
479 BFD_ASSERT (dynobj
!= NULL
481 || h
->u
.weakdef
!= NULL
484 && !h
->def_regular
)));
486 s
= bfd_get_linker_section (dynobj
, ".rela.text");
487 BFD_ASSERT (s
!= NULL
);
488 s
->size
+= sizeof (Elf32_External_Rela
);
490 /* If this is a weak symbol, and there is a real definition, the
491 processor independent code will have arranged for us to see the
492 real definition first, and we can just use the same value. */
493 if (h
->u
.weakdef
!= NULL
)
495 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
496 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
497 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
498 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
502 /* This is a reference to a symbol defined by a dynamic object which
503 is not a function. */
505 /* If we are creating a shared library, we must presume that the
506 only references to the symbol are via the global offset table.
507 For such cases we need not do anything here; the relocations will
508 be handled correctly by relocate_section. */
509 if (bfd_link_pic (info
))
512 /* We must allocate the symbol in our .dynbss section, which will
513 become part of the .bss section of the executable. There will be
514 an entry for this symbol in the .dynsym section. The dynamic
515 object will contain position independent code, so all references
516 from the dynamic object to this symbol will go through the global
517 offset table. The dynamic linker will use the .dynsym entry to
518 determine the address it must put in the global offset table, so
519 both the dynamic object and the regular object will refer to the
520 same memory location for the variable.
522 Of course, if the symbol is sufficiently small, we must instead
523 allocate it in .sbss. FIXME: It would be better to do this if and
524 only if there were actually SDAREL relocs for that symbol. */
526 if (h
->size
<= elf_gp_size (dynobj
))
527 s
= bfd_get_linker_section (dynobj
, ".dynsbss");
529 s
= bfd_get_linker_section (dynobj
, ".dynbss");
530 BFD_ASSERT (s
!= NULL
);
532 /* We must generate a R_I370_COPY reloc to tell the dynamic linker to
533 copy the initial value out of the dynamic object and into the
534 runtime process image. We need to remember the offset into the
535 .rela.bss section we are going to use. */
536 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
540 if (h
->size
<= elf_gp_size (dynobj
))
541 srel
= bfd_get_linker_section (dynobj
, ".rela.sbss");
543 srel
= bfd_get_linker_section (dynobj
, ".rela.bss");
544 BFD_ASSERT (srel
!= NULL
);
545 srel
->size
+= sizeof (Elf32_External_Rela
);
549 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
552 /* Increment the index of a dynamic symbol by a given amount. Called
553 via elf_link_hash_traverse. */
554 /* XXX hack alert bogus This routine is mostly all junk and almost
555 certainly does the wrong thing. Its here simply because it does
556 just enough to allow glibc-2.1 ld.so to compile & link. */
559 i370_elf_adjust_dynindx (struct elf_link_hash_entry
*h
, void * cparg
)
561 int *cp
= (int *) cparg
;
565 "i370_elf_adjust_dynindx called, h->dynindx = %ld, *cp = %d\n",
569 if (h
->dynindx
!= -1)
575 /* Set the sizes of the dynamic sections. */
576 /* XXX hack alert bogus This routine is mostly all junk and almost
577 certainly does the wrong thing. Its here simply because it does
578 just enough to allow glibc-2.1 ld.so to compile & link. */
581 i370_elf_size_dynamic_sections (bfd
*output_bfd
,
582 struct bfd_link_info
*info
)
591 fprintf (stderr
, "i370_elf_size_dynamic_sections called\n");
594 dynobj
= elf_hash_table (info
)->dynobj
;
595 BFD_ASSERT (dynobj
!= NULL
);
597 if (elf_hash_table (info
)->dynamic_sections_created
)
599 /* Set the contents of the .interp section to the interpreter. */
600 if (bfd_link_executable (info
) && !info
->nointerp
)
602 s
= bfd_get_linker_section (dynobj
, ".interp");
603 BFD_ASSERT (s
!= NULL
);
604 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
605 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
610 /* We may have created entries in the .rela.got, .rela.sdata, and
611 .rela.sdata2 sections. However, if we are not creating the
612 dynamic sections, we will not actually use these entries. Reset
613 the size of .rela.got, et al, which will cause it to get
614 stripped from the output file below. */
615 static char *rela_sections
[] = { ".rela.got", ".rela.sdata",
616 ".rela.sdata2", ".rela.sbss",
620 for (p
= rela_sections
; *p
!= NULL
; p
++)
622 s
= bfd_get_linker_section (dynobj
, *p
);
628 /* The check_relocs and adjust_dynamic_symbol entry points have
629 determined the sizes of the various dynamic sections. Allocate
634 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
638 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
641 /* It's OK to base decisions on the section name, because none
642 of the dynobj section names depend upon the input files. */
643 name
= bfd_get_section_name (dynobj
, s
);
645 if (strcmp (name
, ".plt") == 0)
647 /* Remember whether there is a PLT. */
650 else if (CONST_STRNEQ (name
, ".rela"))
657 /* Remember whether there are any relocation sections. */
660 /* If this relocation section applies to a read only
661 section, then we probably need a DT_TEXTREL entry. */
662 outname
= bfd_get_section_name (output_bfd
,
664 target
= bfd_get_section_by_name (output_bfd
, outname
+ 5);
666 && (target
->flags
& SEC_READONLY
) != 0
667 && (target
->flags
& SEC_ALLOC
) != 0)
670 /* We use the reloc_count field as a counter if we need
671 to copy relocs into the output file. */
675 else if (strcmp (name
, ".got") != 0
676 && strcmp (name
, ".sdata") != 0
677 && strcmp (name
, ".sdata2") != 0
678 && strcmp (name
, ".dynbss") != 0
679 && strcmp (name
, ".dynsbss") != 0)
681 /* It's not one of our sections, so don't allocate space. */
687 /* If we don't need this section, strip it from the
688 output file. This is mostly to handle .rela.bss and
689 .rela.plt. We must create both sections in
690 create_dynamic_sections, because they must be created
691 before the linker maps input sections to output
692 sections. The linker does that before
693 adjust_dynamic_symbol is called, and it is that
694 function which decides whether anything needs to go
695 into these sections. */
696 s
->flags
|= SEC_EXCLUDE
;
700 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
703 /* Allocate memory for the section contents. */
704 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
705 if (s
->contents
== NULL
)
709 if (elf_hash_table (info
)->dynamic_sections_created
)
711 /* Add some entries to the .dynamic section. We fill in the
712 values later, in i370_elf_finish_dynamic_sections, but we
713 must add the entries now so that we get the correct size for
714 the .dynamic section. The DT_DEBUG entry is filled in by the
715 dynamic linker and used by the debugger. */
716 #define add_dynamic_entry(TAG, VAL) \
717 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
719 if (!bfd_link_pic (info
))
721 if (!add_dynamic_entry (DT_DEBUG
, 0))
727 if (!add_dynamic_entry (DT_PLTGOT
, 0)
728 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
729 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
730 || !add_dynamic_entry (DT_JMPREL
, 0))
736 if (!add_dynamic_entry (DT_RELA
, 0)
737 || !add_dynamic_entry (DT_RELASZ
, 0)
738 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
744 if (!add_dynamic_entry (DT_TEXTREL
, 0))
746 info
->flags
|= DF_TEXTREL
;
749 #undef add_dynamic_entry
751 /* If we are generating a shared library, we generate a section
752 symbol for each output section. These are local symbols, which
753 means that they must come first in the dynamic symbol table.
754 That means we must increment the dynamic symbol index of every
755 other dynamic symbol.
757 FIXME: We assume that there will never be relocations to
758 locations in linker-created sections that do not have
759 externally-visible names. Instead, we should work out precisely
760 which sections relocations are targeted at. */
761 if (bfd_link_pic (info
))
765 for (c
= 0, s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
767 if ((s
->flags
& SEC_LINKER_CREATED
) != 0
768 || (s
->flags
& SEC_ALLOC
) == 0)
770 elf_section_data (s
)->dynindx
= -1;
774 /* These symbols will have no names, so we don't need to
775 fiddle with dynstr_index. */
777 elf_section_data (s
)->dynindx
= c
+ 1;
782 elf_link_hash_traverse (elf_hash_table (info
),
783 i370_elf_adjust_dynindx
, & c
);
784 elf_hash_table (info
)->dynsymcount
+= c
;
790 /* Look through the relocs for a section during the first phase, and
791 allocate space in the global offset table or procedure linkage
793 /* XXX hack alert bogus This routine is mostly all junk and almost
794 certainly does the wrong thing. Its here simply because it does
795 just enough to allow glibc-2.1 ld.so to compile & link. */
798 i370_elf_check_relocs (bfd
*abfd
,
799 struct bfd_link_info
*info
,
801 const Elf_Internal_Rela
*relocs
)
804 Elf_Internal_Shdr
*symtab_hdr
;
805 struct elf_link_hash_entry
**sym_hashes
;
806 const Elf_Internal_Rela
*rel
;
807 const Elf_Internal_Rela
*rel_end
;
810 if (bfd_link_relocatable (info
))
814 _bfd_error_handler ("i370_elf_check_relocs called for section %A in %B",
818 dynobj
= elf_hash_table (info
)->dynobj
;
819 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
820 sym_hashes
= elf_sym_hashes (abfd
);
824 rel_end
= relocs
+ sec
->reloc_count
;
825 for (rel
= relocs
; rel
< rel_end
; rel
++)
827 unsigned long r_symndx
;
828 struct elf_link_hash_entry
*h
;
830 r_symndx
= ELF32_R_SYM (rel
->r_info
);
831 if (r_symndx
< symtab_hdr
->sh_info
)
835 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
836 while (h
->root
.type
== bfd_link_hash_indirect
837 || h
->root
.type
== bfd_link_hash_warning
)
838 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
840 /* PR15323, ref flags aren't set for references in the same
842 h
->root
.non_ir_ref_regular
= 1;
845 if (bfd_link_pic (info
))
849 "i370_elf_check_relocs needs to create relocation for %s\n",
850 (h
&& h
->root
.root
.string
)
851 ? h
->root
.root
.string
: "<unknown>");
855 sreloc
= _bfd_elf_make_dynamic_reloc_section
856 (sec
, dynobj
, 2, abfd
, /*rela?*/ TRUE
);
862 sreloc
->size
+= sizeof (Elf32_External_Rela
);
864 /* FIXME: We should here do what the m68k and i386
865 backends do: if the reloc is pc-relative, record it
866 in case it turns out that the reloc is unnecessary
867 because the symbol is forced local by versioning or
868 we are linking with -Bdynamic. Fortunately this
869 case is not frequent. */
876 /* Finish up the dynamic sections. */
877 /* XXX hack alert bogus This routine is mostly all junk and almost
878 certainly does the wrong thing. Its here simply because it does
879 just enough to allow glibc-2.1 ld.so to compile & link. */
882 i370_elf_finish_dynamic_sections (bfd
*output_bfd
,
883 struct bfd_link_info
*info
)
886 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
887 asection
*sgot
= elf_hash_table (info
)->sgot
;
890 fprintf (stderr
, "i370_elf_finish_dynamic_sections called\n");
893 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
895 if (elf_hash_table (info
)->dynamic_sections_created
)
898 Elf32_External_Dyn
*dyncon
, *dynconend
;
900 splt
= elf_hash_table (info
)->splt
;
901 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
903 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
904 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
905 for (; dyncon
< dynconend
; dyncon
++)
907 Elf_Internal_Dyn dyn
;
911 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
916 s
= elf_hash_table (info
)->splt
;
920 s
= elf_hash_table (info
)->srelplt
;
924 s
= elf_hash_table (info
)->srelplt
;
936 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
938 dyn
.d_un
.d_val
= s
->size
;
940 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
944 if (sgot
&& sgot
->size
!= 0)
946 unsigned char *contents
= sgot
->contents
;
949 bfd_put_32 (output_bfd
, (bfd_vma
) 0, contents
);
951 bfd_put_32 (output_bfd
,
952 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
955 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
958 if (bfd_link_pic (info
))
962 Elf_Internal_Sym sym
;
965 /* Set up the section symbols for the output sections. */
967 sdynsym
= bfd_get_linker_section (dynobj
, ".dynsym");
968 BFD_ASSERT (sdynsym
!= NULL
);
972 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
974 sym
.st_target_internal
= 0;
976 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
979 Elf32_External_Sym
*esym
;
981 sym
.st_value
= s
->vma
;
983 indx
= elf_section_data (s
)->this_idx
;
984 dindx
= elf_section_data (s
)->dynindx
;
987 BFD_ASSERT(indx
> 0);
988 BFD_ASSERT(dindx
> 0);
990 if (dindx
> maxdindx
)
995 esym
= (Elf32_External_Sym
*) sdynsym
->contents
+ dindx
;
996 bfd_elf32_swap_symbol_out (output_bfd
, &sym
, esym
, NULL
);
1000 /* Set the sh_info field of the output .dynsym section to the
1001 index of the first global symbol. */
1002 elf_section_data (sdynsym
->output_section
)->this_hdr
.sh_info
=
1009 /* The RELOCATE_SECTION function is called by the ELF backend linker
1010 to handle the relocations for a section.
1012 The relocs are always passed as Rela structures; if the section
1013 actually uses Rel structures, the r_addend field will always be
1016 This function is responsible for adjust the section contents as
1017 necessary, and (if using Rela relocs and generating a
1018 relocatable output file) adjusting the reloc addend as
1021 This function does not have to worry about setting the reloc
1022 address or the reloc symbol index.
1024 LOCAL_SYMS is a pointer to the swapped in local symbols.
1026 LOCAL_SECTIONS is an array giving the section in the input file
1027 corresponding to the st_shndx field of each local symbol.
1029 The global hash table entry for the global symbols can be found
1030 via elf_sym_hashes (input_bfd).
1032 When generating relocatable output, this function must handle
1033 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1034 going to be the section symbol corresponding to the output
1035 section, which means that the addend must be adjusted
1039 i370_elf_relocate_section (bfd
*output_bfd
,
1040 struct bfd_link_info
*info
,
1042 asection
*input_section
,
1044 Elf_Internal_Rela
*relocs
,
1045 Elf_Internal_Sym
*local_syms
,
1046 asection
**local_sections
)
1048 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1049 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
1050 Elf_Internal_Rela
*rel
= relocs
;
1051 Elf_Internal_Rela
*relend
= relocs
+ input_section
->reloc_count
;
1052 asection
*sreloc
= NULL
;
1053 bfd_boolean ret
= TRUE
;
1056 _bfd_error_handler ("i370_elf_relocate_section called for %B section %A, %u relocations%s",
1057 input_bfd
, input_section
,
1058 input_section
->reloc_count
,
1059 (bfd_link_relocatable (info
)) ? " (relocatable)" : "");
1062 if (!i370_elf_howto_table
[ R_I370_ADDR31
])
1063 /* Initialize howto table if needed. */
1064 i370_elf_howto_init ();
1066 for (; rel
< relend
; rel
++)
1068 enum i370_reloc_type r_type
= (enum i370_reloc_type
) ELF32_R_TYPE (rel
->r_info
);
1069 bfd_vma offset
= rel
->r_offset
;
1070 bfd_vma addend
= rel
->r_addend
;
1071 bfd_reloc_status_type r
= bfd_reloc_other
;
1072 Elf_Internal_Sym
*sym
= NULL
;
1073 asection
*sec
= NULL
;
1074 struct elf_link_hash_entry
* h
= NULL
;
1075 const char *sym_name
= NULL
;
1076 reloc_howto_type
*howto
;
1077 unsigned long r_symndx
;
1080 /* Unknown relocation handling. */
1081 if ((unsigned) r_type
>= (unsigned) R_I370_max
1082 || !i370_elf_howto_table
[(int)r_type
])
1084 /* xgettext:c-format */
1085 _bfd_error_handler (_("%B: unknown relocation type %d"),
1086 input_bfd
, (int) r_type
);
1088 bfd_set_error (bfd_error_bad_value
);
1093 howto
= i370_elf_howto_table
[(int) r_type
];
1094 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1097 if (r_symndx
< symtab_hdr
->sh_info
)
1099 sym
= local_syms
+ r_symndx
;
1100 sec
= local_sections
[r_symndx
];
1101 sym_name
= "<local symbol>";
1103 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, & sec
, rel
);
1104 addend
= rel
->r_addend
;
1108 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1110 if (info
->wrap_hash
!= NULL
1111 && (input_section
->flags
& SEC_DEBUGGING
) != 0)
1112 h
= ((struct elf_link_hash_entry
*)
1113 unwrap_hash_lookup (info
, input_bfd
, &h
->root
));
1115 while (h
->root
.type
== bfd_link_hash_indirect
1116 || h
->root
.type
== bfd_link_hash_warning
)
1117 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1118 sym_name
= h
->root
.root
.string
;
1119 if (h
->root
.type
== bfd_link_hash_defined
1120 || h
->root
.type
== bfd_link_hash_defweak
)
1122 sec
= h
->root
.u
.def
.section
;
1123 if (bfd_link_pic (info
)
1124 && ((! info
->symbolic
&& h
->dynindx
!= -1)
1126 && (input_section
->flags
& SEC_ALLOC
) != 0
1127 && (r_type
== R_I370_ADDR31
1128 || r_type
== R_I370_COPY
1129 || r_type
== R_I370_ADDR16
1130 || r_type
== R_I370_RELATIVE
))
1131 /* In these cases, we don't need the relocation
1132 value. We check specially because in some
1133 obscure cases sec->output_section will be NULL. */
1136 relocation
= (h
->root
.u
.def
.value
1137 + sec
->output_section
->vma
1138 + sec
->output_offset
);
1140 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1142 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
1143 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1145 else if (!bfd_link_relocatable (info
))
1147 (*info
->callbacks
->undefined_symbol
)
1148 (info
, h
->root
.root
.string
, input_bfd
,
1149 input_section
, rel
->r_offset
,
1150 (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
1151 || ELF_ST_VISIBILITY (h
->other
)));
1157 if (sec
!= NULL
&& discarded_section (sec
))
1158 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
1159 rel
, 1, relend
, howto
, 0, contents
);
1161 if (bfd_link_relocatable (info
))
1164 switch ((int) r_type
)
1168 (_("%B: unknown relocation type %d for symbol %s"),
1169 input_bfd
, (int) r_type
, sym_name
);
1171 bfd_set_error (bfd_error_bad_value
);
1175 case (int) R_I370_NONE
:
1178 /* Relocations that may need to be propagated if this is a shared
1180 case (int) R_I370_REL31
:
1181 /* If these relocations are not to a named symbol, they can be
1182 handled right here, no need to bother the dynamic linker. */
1184 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1188 /* Relocations that always need to be propagated if this is a shared
1190 case (int) R_I370_ADDR31
:
1191 case (int) R_I370_ADDR16
:
1192 if (bfd_link_pic (info
)
1193 && r_symndx
!= STN_UNDEF
)
1195 Elf_Internal_Rela outrel
;
1201 "i370_elf_relocate_section needs to create relocation for %s\n",
1202 (h
&& h
->root
.root
.string
) ? h
->root
.root
.string
: "<unknown>");
1205 /* When generating a shared object, these relocations
1206 are copied into the output file to be resolved at run
1211 sreloc
= _bfd_elf_get_dynamic_reloc_section
1212 (input_bfd
, input_section
, /*rela?*/ TRUE
);
1220 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1222 if (outrel
.r_offset
== (bfd_vma
) -1
1223 || outrel
.r_offset
== (bfd_vma
) -2)
1224 skip
= (int) outrel
.r_offset
;
1225 outrel
.r_offset
+= (input_section
->output_section
->vma
1226 + input_section
->output_offset
);
1229 memset (&outrel
, 0, sizeof outrel
);
1230 /* h->dynindx may be -1 if this symbol was marked to
1233 && ((! info
->symbolic
&& h
->dynindx
!= -1)
1234 || !h
->def_regular
))
1236 BFD_ASSERT (h
->dynindx
!= -1);
1237 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1238 outrel
.r_addend
= rel
->r_addend
;
1242 if (r_type
== R_I370_ADDR31
)
1244 outrel
.r_info
= ELF32_R_INFO (0, R_I370_RELATIVE
);
1245 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1251 if (bfd_is_abs_section (sec
))
1253 else if (sec
== NULL
|| sec
->owner
== NULL
)
1255 bfd_set_error (bfd_error_bad_value
);
1262 /* We are turning this relocation into one
1263 against a section symbol. It would be
1264 proper to subtract the symbol's value,
1265 osec->vma, from the emitted reloc addend,
1266 but ld.so expects buggy relocs. */
1267 osec
= sec
->output_section
;
1268 indx
= elf_section_data (osec
)->dynindx
;
1271 struct elf_link_hash_table
*htab
;
1272 htab
= elf_hash_table (info
);
1273 osec
= htab
->text_index_section
;
1274 indx
= elf_section_data (osec
)->dynindx
;
1276 BFD_ASSERT (indx
!= 0);
1280 printf ("indx=%ld section=%s flags=%08x name=%s\n",
1281 indx
, osec
->name
, osec
->flags
,
1282 h
->root
.root
.string
);
1287 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
1288 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1292 loc
= sreloc
->contents
;
1293 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
1294 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1296 /* This reloc will be computed at runtime, so there's no
1297 need to do anything now, unless this is a RELATIVE
1298 reloc in an unallocated section. */
1300 || (input_section
->flags
& SEC_ALLOC
) != 0
1301 || ELF32_R_TYPE (outrel
.r_info
) != R_I370_RELATIVE
)
1306 case (int) R_I370_COPY
:
1307 case (int) R_I370_RELATIVE
:
1309 /* xgettext:c-format */
1310 (_("%B: Relocation %s is not yet supported for symbol %s."),
1312 i370_elf_howto_table
[(int) r_type
]->name
,
1315 bfd_set_error (bfd_error_invalid_operation
);
1321 fprintf (stderr
, "\ttype = %s (%d), name = %s, symbol index = %ld, offset = %ld, addend = %ld\n",
1330 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
, contents
,
1331 offset
, relocation
, addend
);
1333 if (r
!= bfd_reloc_ok
)
1341 case bfd_reloc_overflow
:
1349 name
= bfd_elf_string_from_elf_section (input_bfd
,
1350 symtab_hdr
->sh_link
,
1356 name
= bfd_section_name (input_bfd
, sec
);
1359 (*info
->callbacks
->reloc_overflow
) (info
,
1360 (h
? &h
->root
: NULL
),
1374 fprintf (stderr
, "\n");
1380 #define TARGET_BIG_SYM i370_elf32_vec
1381 #define TARGET_BIG_NAME "elf32-i370"
1382 #define ELF_ARCH bfd_arch_i370
1383 #define ELF_MACHINE_CODE EM_S370
1385 #define ELF_MACHINE_ALT1 EM_I370_OLD
1387 #define ELF_MAXPAGESIZE 0x1000
1388 #define ELF_OSABI ELFOSABI_GNU
1390 #define elf_info_to_howto i370_elf_info_to_howto
1392 #define elf_backend_plt_not_loaded 1
1393 #define elf_backend_rela_normal 1
1395 #define bfd_elf32_bfd_reloc_type_lookup i370_elf_reloc_type_lookup
1396 #define bfd_elf32_bfd_reloc_name_lookup i370_elf_reloc_name_lookup
1397 #define bfd_elf32_bfd_set_private_flags i370_elf_set_private_flags
1398 #define bfd_elf32_bfd_merge_private_bfd_data i370_elf_merge_private_bfd_data
1399 #define elf_backend_relocate_section i370_elf_relocate_section
1401 /* Dynamic loader support is mostly broken; just enough here to be able to
1402 link glibc's ld.so without errors. */
1403 #define elf_backend_create_dynamic_sections i370_elf_create_dynamic_sections
1404 #define elf_backend_size_dynamic_sections i370_elf_size_dynamic_sections
1405 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
1406 #define elf_backend_finish_dynamic_sections i370_elf_finish_dynamic_sections
1407 #define elf_backend_fake_sections i370_elf_fake_sections
1408 #define elf_backend_section_from_shdr i370_elf_section_from_shdr
1409 #define elf_backend_adjust_dynamic_symbol i370_elf_adjust_dynamic_symbol
1410 #define elf_backend_check_relocs i370_elf_check_relocs
1418 #define elf_backend_finish_dynamic_symbol \
1420 (bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, \
1421 Elf_Internal_Sym *)) i370_noop
1423 #include "elf32-target.h"