1 /* i370-specific support for 32-bit ELF
2 Copyright 1994, 1995, 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor, Cygnus Support.
5 Hacked by Linas Vepstas for i370 linas@linas.org
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
24 /* This file is based on a preliminary PowerPC ELF ABI.
25 But its been hacked on for the IBM 360/370 architectures.
26 Basically, the 31bit relocation works, and just about everything
27 else is a wild card. In particular, don't expect shared libs or
28 dynamic loading to work ... its never been tested. */
37 static reloc_howto_type
*i370_elf_howto_table
[ (int)R_I370_max
];
39 static reloc_howto_type i370_elf_howto_raw
[] =
41 /* This reloc does nothing. */
42 HOWTO (R_I370_NONE
, /* type */
44 2, /* size (0 = byte, 1 = short, 2 = long) */
46 FALSE
, /* pc_relative */
48 complain_overflow_bitfield
, /* complain_on_overflow */
49 bfd_elf_generic_reloc
, /* special_function */
50 "R_I370_NONE", /* name */
51 FALSE
, /* partial_inplace */
54 FALSE
), /* pcrel_offset */
56 /* A standard 31 bit relocation. */
57 HOWTO (R_I370_ADDR31
, /* type */
59 2, /* size (0 = byte, 1 = short, 2 = long) */
61 FALSE
, /* pc_relative */
63 complain_overflow_bitfield
, /* complain_on_overflow */
64 bfd_elf_generic_reloc
, /* special_function */
65 "R_I370_ADDR31", /* name */
66 FALSE
, /* partial_inplace */
68 0x7fffffff, /* dst_mask */
69 FALSE
), /* pcrel_offset */
71 /* A standard 32 bit relocation. */
72 HOWTO (R_I370_ADDR32
, /* type */
74 2, /* size (0 = byte, 1 = short, 2 = long) */
76 FALSE
, /* pc_relative */
78 complain_overflow_bitfield
, /* complain_on_overflow */
79 bfd_elf_generic_reloc
, /* special_function */
80 "R_I370_ADDR32", /* name */
81 FALSE
, /* partial_inplace */
83 0xffffffff, /* dst_mask */
84 FALSE
), /* pcrel_offset */
86 /* A standard 16 bit relocation. */
87 HOWTO (R_I370_ADDR16
, /* type */
89 1, /* size (0 = byte, 1 = short, 2 = long) */
91 FALSE
, /* pc_relative */
93 complain_overflow_bitfield
, /* complain_on_overflow */
94 bfd_elf_generic_reloc
, /* special_function */
95 "R_I370_ADDR16", /* name */
96 FALSE
, /* partial_inplace */
98 0xffff, /* dst_mask */
99 FALSE
), /* pcrel_offset */
101 /* 31-bit PC relative. */
102 HOWTO (R_I370_REL31
, /* type */
104 2, /* size (0 = byte, 1 = short, 2 = long) */
106 TRUE
, /* pc_relative */
108 complain_overflow_bitfield
, /* complain_on_overflow */
109 bfd_elf_generic_reloc
, /* special_function */
110 "R_I370_REL31", /* name */
111 FALSE
, /* partial_inplace */
113 0x7fffffff, /* dst_mask */
114 TRUE
), /* pcrel_offset */
116 /* 32-bit PC relative. */
117 HOWTO (R_I370_REL32
, /* type */
119 2, /* size (0 = byte, 1 = short, 2 = long) */
121 TRUE
, /* pc_relative */
123 complain_overflow_bitfield
, /* complain_on_overflow */
124 bfd_elf_generic_reloc
, /* special_function */
125 "R_I370_REL32", /* name */
126 FALSE
, /* partial_inplace */
128 0xffffffff, /* dst_mask */
129 TRUE
), /* pcrel_offset */
131 /* A standard 12 bit relocation. */
132 HOWTO (R_I370_ADDR12
, /* type */
134 1, /* size (0 = byte, 1 = short, 2 = long) */
136 FALSE
, /* pc_relative */
138 complain_overflow_bitfield
, /* complain_on_overflow */
139 bfd_elf_generic_reloc
, /* special_function */
140 "R_I370_ADDR12", /* name */
141 FALSE
, /* partial_inplace */
143 0xfff, /* dst_mask */
144 FALSE
), /* pcrel_offset */
146 /* 12-bit PC relative. */
147 HOWTO (R_I370_REL12
, /* type */
149 1, /* size (0 = byte, 1 = short, 2 = long) */
151 TRUE
, /* pc_relative */
153 complain_overflow_bitfield
, /* complain_on_overflow */
154 bfd_elf_generic_reloc
, /* special_function */
155 "R_I370_REL12", /* name */
156 FALSE
, /* partial_inplace */
158 0xfff, /* dst_mask */
159 TRUE
), /* pcrel_offset */
161 /* A standard 8 bit relocation. */
162 HOWTO (R_I370_ADDR8
, /* type */
164 0, /* size (0 = byte, 1 = short, 2 = long) */
166 FALSE
, /* pc_relative */
168 complain_overflow_bitfield
, /* complain_on_overflow */
169 bfd_elf_generic_reloc
, /* special_function */
170 "R_I370_ADDR8", /* name */
171 FALSE
, /* partial_inplace */
174 FALSE
), /* pcrel_offset */
176 /* 8-bit PC relative. */
177 HOWTO (R_I370_REL8
, /* type */
179 0, /* size (0 = byte, 1 = short, 2 = long) */
181 TRUE
, /* pc_relative */
183 complain_overflow_bitfield
, /* complain_on_overflow */
184 bfd_elf_generic_reloc
, /* special_function */
185 "R_I370_REL8", /* name */
186 FALSE
, /* partial_inplace */
189 TRUE
), /* pcrel_offset */
191 /* This is used only by the dynamic linker. The symbol should exist
192 both in the object being run and in some shared library. The
193 dynamic linker copies the data addressed by the symbol from the
194 shared library into the object, because the object being
195 run has to have the data at some particular address. */
196 HOWTO (R_I370_COPY
, /* type */
198 2, /* size (0 = byte, 1 = short, 2 = long) */
200 FALSE
, /* pc_relative */
202 complain_overflow_bitfield
, /* complain_on_overflow */
203 bfd_elf_generic_reloc
, /* special_function */
204 "R_I370_COPY", /* name */
205 FALSE
, /* partial_inplace */
208 FALSE
), /* pcrel_offset */
210 /* Used only by the dynamic linker. When the object is run, this
211 longword is set to the load address of the object, plus the
213 HOWTO (R_I370_RELATIVE
, /* type */
215 2, /* size (0 = byte, 1 = short, 2 = long) */
217 FALSE
, /* pc_relative */
219 complain_overflow_bitfield
, /* complain_on_overflow */
220 bfd_elf_generic_reloc
, /* special_function */
221 "R_I370_RELATIVE", /* name */
222 FALSE
, /* partial_inplace */
224 0xffffffff, /* dst_mask */
225 FALSE
), /* pcrel_offset */
229 /* Initialize the i370_elf_howto_table, so that linear accesses can be done. */
232 i370_elf_howto_init (void)
234 unsigned int i
, type
;
236 for (i
= 0; i
< sizeof (i370_elf_howto_raw
) / sizeof (i370_elf_howto_raw
[0]); i
++)
238 type
= i370_elf_howto_raw
[i
].type
;
239 BFD_ASSERT (type
< sizeof (i370_elf_howto_table
) / sizeof (i370_elf_howto_table
[0]));
240 i370_elf_howto_table
[type
] = &i370_elf_howto_raw
[i
];
244 static reloc_howto_type
*
245 i370_elf_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
246 bfd_reloc_code_real_type code
)
248 enum i370_reloc_type i370_reloc
= R_I370_NONE
;
250 if (!i370_elf_howto_table
[ R_I370_ADDR31
])
251 /* Initialize howto table if needed. */
252 i370_elf_howto_init ();
259 case BFD_RELOC_NONE
: i370_reloc
= R_I370_NONE
; break;
260 case BFD_RELOC_32
: i370_reloc
= R_I370_ADDR31
; break;
261 case BFD_RELOC_16
: i370_reloc
= R_I370_ADDR16
; break;
262 case BFD_RELOC_32_PCREL
: i370_reloc
= R_I370_REL31
; break;
263 case BFD_RELOC_CTOR
: i370_reloc
= R_I370_ADDR31
; break;
264 case BFD_RELOC_I370_D12
: i370_reloc
= R_I370_ADDR12
; break;
267 return i370_elf_howto_table
[ (int)i370_reloc
];
270 static reloc_howto_type
*
271 i370_elf_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
277 i
< sizeof (i370_elf_howto_raw
) / sizeof (i370_elf_howto_raw
[0]);
279 if (i370_elf_howto_raw
[i
].name
!= NULL
280 && strcasecmp (i370_elf_howto_raw
[i
].name
, r_name
) == 0)
281 return &i370_elf_howto_raw
[i
];
286 /* The name of the dynamic interpreter. This is put in the .interp
289 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
291 /* Set the howto pointer for an i370 ELF reloc. */
294 i370_elf_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
296 Elf_Internal_Rela
*dst
)
298 if (!i370_elf_howto_table
[ R_I370_ADDR31
])
299 /* Initialize howto table. */
300 i370_elf_howto_init ();
302 BFD_ASSERT (ELF32_R_TYPE (dst
->r_info
) < (unsigned int) R_I370_max
);
303 cache_ptr
->howto
= i370_elf_howto_table
[ELF32_R_TYPE (dst
->r_info
)];
306 /* Hack alert -- the following several routines look generic to me ...
307 why are we bothering with them ? */
308 /* Function to set whether a module needs the -mrelocatable bit set. */
311 i370_elf_set_private_flags (bfd
*abfd
, flagword flags
)
313 BFD_ASSERT (!elf_flags_init (abfd
)
314 || elf_elfheader (abfd
)->e_flags
== flags
);
316 elf_elfheader (abfd
)->e_flags
= flags
;
317 elf_flags_init (abfd
) = TRUE
;
321 /* Merge backend specific data from an object file to the output
322 object file when linking. */
325 i370_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
330 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
331 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
334 new_flags
= elf_elfheader (ibfd
)->e_flags
;
335 old_flags
= elf_elfheader (obfd
)->e_flags
;
336 if (!elf_flags_init (obfd
)) /* First call, no flags set. */
338 elf_flags_init (obfd
) = TRUE
;
339 elf_elfheader (obfd
)->e_flags
= new_flags
;
342 else if (new_flags
== old_flags
) /* Compatible flags are ok. */
345 else /* Incompatible flags. */
347 (*_bfd_error_handler
)
348 ("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)",
349 ibfd
, (long) new_flags
, (long) old_flags
);
351 bfd_set_error (bfd_error_bad_value
);
358 /* Handle an i370 specific section when reading an object file. This
359 is called when elfcode.h finds a section with an unknown type. */
360 /* XXX hack alert bogus This routine is mostly all junk and almost
361 certainly does the wrong thing. Its here simply because it does
362 just enough to allow glibc-2.1 ld.so to compile & link. */
365 i370_elf_section_from_shdr (bfd
*abfd
,
366 Elf_Internal_Shdr
*hdr
,
373 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
376 newsect
= hdr
->bfd_section
;
377 flags
= bfd_get_section_flags (abfd
, newsect
);
378 if (hdr
->sh_flags
& SHF_EXCLUDE
)
379 flags
|= SEC_EXCLUDE
;
381 if (hdr
->sh_type
== SHT_ORDERED
)
382 flags
|= SEC_SORT_ENTRIES
;
384 bfd_set_section_flags (abfd
, newsect
, flags
);
388 /* Set up any other section flags and such that may be necessary. */
389 /* XXX hack alert bogus This routine is mostly all junk and almost
390 certainly does the wrong thing. Its here simply because it does
391 just enough to allow glibc-2.1 ld.so to compile & link. */
394 i370_elf_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
395 Elf_Internal_Shdr
*shdr
,
398 if ((asect
->flags
& (SEC_GROUP
| SEC_EXCLUDE
)) == SEC_EXCLUDE
)
399 shdr
->sh_flags
|= SHF_EXCLUDE
;
401 if ((asect
->flags
& SEC_SORT_ENTRIES
) != 0)
402 shdr
->sh_type
= SHT_ORDERED
;
407 /* We have to create .dynsbss and .rela.sbss here so that they get mapped
408 to output sections (just like _bfd_elf_create_dynamic_sections has
409 to create .dynbss and .rela.bss). */
410 /* XXX hack alert bogus This routine is mostly all junk and almost
411 certainly does the wrong thing. Its here simply because it does
412 just enough to allow glibc-2.1 ld.so to compile & link. */
415 i370_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
420 if (!_bfd_elf_create_dynamic_sections(abfd
, info
))
423 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
424 | SEC_LINKER_CREATED
);
426 s
= bfd_make_section_with_flags (abfd
, ".dynsbss",
427 SEC_ALLOC
| SEC_LINKER_CREATED
);
433 s
= bfd_make_section_with_flags (abfd
, ".rela.sbss",
434 flags
| SEC_READONLY
);
436 || ! bfd_set_section_alignment (abfd
, s
, 2))
440 /* XXX beats me, seem to need a rela.text ... */
441 s
= bfd_make_section_with_flags (abfd
, ".rela.text",
442 flags
| SEC_READONLY
);
444 || ! bfd_set_section_alignment (abfd
, s
, 2))
449 /* Adjust a symbol defined by a dynamic object and referenced by a
450 regular object. The current definition is in some section of the
451 dynamic object, but we're not including those sections. We have to
452 change the definition to something the rest of the link can
454 /* XXX hack alert bogus This routine is mostly all junk and almost
455 certainly does the wrong thing. Its here simply because it does
456 just enough to allow glibc-2.1 ld.so to compile & link. */
459 i370_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
460 struct elf_link_hash_entry
*h
)
462 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
464 unsigned int power_of_two
;
467 fprintf (stderr
, "i370_elf_adjust_dynamic_symbol called for %s\n",
468 h
->root
.root
.string
);
471 /* Make sure we know what is going on here. */
472 BFD_ASSERT (dynobj
!= NULL
474 || h
->u
.weakdef
!= NULL
477 && !h
->def_regular
)));
479 s
= bfd_get_section_by_name (dynobj
, ".rela.text");
480 BFD_ASSERT (s
!= NULL
);
481 s
->size
+= sizeof (Elf32_External_Rela
);
483 /* If this is a weak symbol, and there is a real definition, the
484 processor independent code will have arranged for us to see the
485 real definition first, and we can just use the same value. */
486 if (h
->u
.weakdef
!= NULL
)
488 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
489 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
490 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
491 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
495 /* This is a reference to a symbol defined by a dynamic object which
496 is not a function. */
498 /* If we are creating a shared library, we must presume that the
499 only references to the symbol are via the global offset table.
500 For such cases we need not do anything here; the relocations will
501 be handled correctly by relocate_section. */
507 (*_bfd_error_handler
) (_("dynamic variable `%s' is zero size"),
508 h
->root
.root
.string
);
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_section_by_name (dynobj
, ".dynsbss");
529 s
= bfd_get_section_by_name (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)
540 if (h
->size
<= elf_gp_size (dynobj
))
541 srel
= bfd_get_section_by_name (dynobj
, ".rela.sbss");
543 srel
= bfd_get_section_by_name (dynobj
, ".rela.bss");
544 BFD_ASSERT (srel
!= NULL
);
545 srel
->size
+= sizeof (Elf32_External_Rela
);
549 /* We need to figure out the alignment required for this symbol. I
550 have no idea how ELF linkers handle this. */
551 power_of_two
= bfd_log2 (h
->size
);
552 if (power_of_two
> 4)
555 /* Apply the required alignment. */
556 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
) (1 << power_of_two
));
557 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
559 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
563 /* Define the symbol as being at this point in the section. */
564 h
->root
.u
.def
.section
= s
;
565 h
->root
.u
.def
.value
= s
->size
;
567 /* Increment the section size to make room for the symbol. */
573 /* Increment the index of a dynamic symbol by a given amount. Called
574 via elf_link_hash_traverse. */
575 /* XXX hack alert bogus This routine is mostly all junk and almost
576 certainly does the wrong thing. Its here simply because it does
577 just enough to allow glibc-2.1 ld.so to compile & link. */
580 i370_elf_adjust_dynindx (struct elf_link_hash_entry
*h
, void * cparg
)
582 int *cp
= (int *) cparg
;
586 "i370_elf_adjust_dynindx called, h->dynindx = %ld, *cp = %d\n",
590 if (h
->root
.type
== bfd_link_hash_warning
)
591 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
593 if (h
->dynindx
!= -1)
599 /* Set the sizes of the dynamic sections. */
600 /* XXX hack alert bogus This routine is mostly all junk and almost
601 certainly does the wrong thing. Its here simply because it does
602 just enough to allow glibc-2.1 ld.so to compile & link. */
605 i370_elf_size_dynamic_sections (bfd
*output_bfd
,
606 struct bfd_link_info
*info
)
615 fprintf (stderr
, "i370_elf_size_dynamic_sections called\n");
618 dynobj
= elf_hash_table (info
)->dynobj
;
619 BFD_ASSERT (dynobj
!= NULL
);
621 if (elf_hash_table (info
)->dynamic_sections_created
)
623 /* Set the contents of the .interp section to the interpreter. */
624 if (info
->executable
)
626 s
= bfd_get_section_by_name (dynobj
, ".interp");
627 BFD_ASSERT (s
!= NULL
);
628 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
629 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
634 /* We may have created entries in the .rela.got, .rela.sdata, and
635 .rela.sdata2 sections. However, if we are not creating the
636 dynamic sections, we will not actually use these entries. Reset
637 the size of .rela.got, et al, which will cause it to get
638 stripped from the output file below. */
639 static char *rela_sections
[] = { ".rela.got", ".rela.sdata",
640 ".rela.sdata2", ".rela.sbss",
644 for (p
= rela_sections
; *p
!= NULL
; p
++)
646 s
= bfd_get_section_by_name (dynobj
, *p
);
652 /* The check_relocs and adjust_dynamic_symbol entry points have
653 determined the sizes of the various dynamic sections. Allocate
658 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
662 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
665 /* It's OK to base decisions on the section name, because none
666 of the dynobj section names depend upon the input files. */
667 name
= bfd_get_section_name (dynobj
, s
);
669 if (strcmp (name
, ".plt") == 0)
671 /* Remember whether there is a PLT. */
674 else if (CONST_STRNEQ (name
, ".rela"))
681 /* Remember whether there are any relocation sections. */
684 /* If this relocation section applies to a read only
685 section, then we probably need a DT_TEXTREL entry. */
686 outname
= bfd_get_section_name (output_bfd
,
688 target
= bfd_get_section_by_name (output_bfd
, outname
+ 5);
690 && (target
->flags
& SEC_READONLY
) != 0
691 && (target
->flags
& SEC_ALLOC
) != 0)
694 /* We use the reloc_count field as a counter if we need
695 to copy relocs into the output file. */
699 else if (strcmp (name
, ".got") != 0
700 && strcmp (name
, ".sdata") != 0
701 && strcmp (name
, ".sdata2") != 0
702 && strcmp (name
, ".dynbss") != 0
703 && strcmp (name
, ".dynsbss") != 0)
705 /* It's not one of our sections, so don't allocate space. */
711 /* If we don't need this section, strip it from the
712 output file. This is mostly to handle .rela.bss and
713 .rela.plt. We must create both sections in
714 create_dynamic_sections, because they must be created
715 before the linker maps input sections to output
716 sections. The linker does that before
717 adjust_dynamic_symbol is called, and it is that
718 function which decides whether anything needs to go
719 into these sections. */
720 s
->flags
|= SEC_EXCLUDE
;
724 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
727 /* Allocate memory for the section contents. */
728 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
729 if (s
->contents
== NULL
)
733 if (elf_hash_table (info
)->dynamic_sections_created
)
735 /* Add some entries to the .dynamic section. We fill in the
736 values later, in i370_elf_finish_dynamic_sections, but we
737 must add the entries now so that we get the correct size for
738 the .dynamic section. The DT_DEBUG entry is filled in by the
739 dynamic linker and used by the debugger. */
740 #define add_dynamic_entry(TAG, VAL) \
741 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
745 if (!add_dynamic_entry (DT_DEBUG
, 0))
751 if (!add_dynamic_entry (DT_PLTGOT
, 0)
752 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
753 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
754 || !add_dynamic_entry (DT_JMPREL
, 0))
760 if (!add_dynamic_entry (DT_RELA
, 0)
761 || !add_dynamic_entry (DT_RELASZ
, 0)
762 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
768 if (!add_dynamic_entry (DT_TEXTREL
, 0))
770 info
->flags
|= DF_TEXTREL
;
773 #undef add_dynamic_entry
775 /* If we are generating a shared library, we generate a section
776 symbol for each output section. These are local symbols, which
777 means that they must come first in the dynamic symbol table.
778 That means we must increment the dynamic symbol index of every
779 other dynamic symbol.
781 FIXME: We assume that there will never be relocations to
782 locations in linker-created sections that do not have
783 externally-visible names. Instead, we should work out precisely
784 which sections relocations are targeted at. */
789 for (c
= 0, s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
791 if ((s
->flags
& SEC_LINKER_CREATED
) != 0
792 || (s
->flags
& SEC_ALLOC
) == 0)
794 elf_section_data (s
)->dynindx
= -1;
798 /* These symbols will have no names, so we don't need to
799 fiddle with dynstr_index. */
801 elf_section_data (s
)->dynindx
= c
+ 1;
806 elf_link_hash_traverse (elf_hash_table (info
),
807 i370_elf_adjust_dynindx
, & c
);
808 elf_hash_table (info
)->dynsymcount
+= c
;
814 /* Look through the relocs for a section during the first phase, and
815 allocate space in the global offset table or procedure linkage
817 /* XXX hack alert bogus This routine is mostly all junk and almost
818 certainly does the wrong thing. Its here simply because it does
819 just enough to allow glibc-2.1 ld.so to compile & link. */
822 i370_elf_check_relocs (bfd
*abfd
,
823 struct bfd_link_info
*info
,
825 const Elf_Internal_Rela
*relocs
)
828 Elf_Internal_Shdr
*symtab_hdr
;
829 struct elf_link_hash_entry
**sym_hashes
;
830 const Elf_Internal_Rela
*rel
;
831 const Elf_Internal_Rela
*rel_end
;
832 bfd_vma
*local_got_offsets
;
835 if (info
->relocatable
)
839 _bfd_error_handler ("i370_elf_check_relocs called for section %A in %B",
843 dynobj
= elf_hash_table (info
)->dynobj
;
844 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
845 sym_hashes
= elf_sym_hashes (abfd
);
846 local_got_offsets
= elf_local_got_offsets (abfd
);
850 rel_end
= relocs
+ sec
->reloc_count
;
851 for (rel
= relocs
; rel
< rel_end
; rel
++)
853 unsigned long r_symndx
;
854 struct elf_link_hash_entry
*h
;
856 r_symndx
= ELF32_R_SYM (rel
->r_info
);
857 if (r_symndx
< symtab_hdr
->sh_info
)
861 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
862 while (h
->root
.type
== bfd_link_hash_indirect
863 || h
->root
.type
== bfd_link_hash_warning
)
864 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
871 "i370_elf_check_relocs needs to create relocation for %s\n",
872 (h
&& h
->root
.root
.string
)
873 ? h
->root
.root
.string
: "<unknown>");
879 name
= (bfd_elf_string_from_elf_section
881 elf_elfheader (abfd
)->e_shstrndx
,
882 elf_section_data (sec
)->rel_hdr
.sh_name
));
886 BFD_ASSERT (CONST_STRNEQ (name
, ".rela")
887 && strcmp (bfd_get_section_name (abfd
, sec
), name
+ 5) == 0);
889 sreloc
= bfd_get_section_by_name (dynobj
, name
);
894 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
895 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
896 if ((sec
->flags
& SEC_ALLOC
) != 0)
897 flags
|= SEC_ALLOC
| SEC_LOAD
;
898 sreloc
= bfd_make_section_with_flags (dynobj
, name
,
901 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
906 sreloc
->size
+= sizeof (Elf32_External_Rela
);
908 /* FIXME: We should here do what the m68k and i386
909 backends do: if the reloc is pc-relative, record it
910 in case it turns out that the reloc is unnecessary
911 because the symbol is forced local by versioning or
912 we are linking with -Bdynamic. Fortunately this
913 case is not frequent. */
920 /* Finish up the dynamic sections. */
921 /* XXX hack alert bogus This routine is mostly all junk and almost
922 certainly does the wrong thing. Its here simply because it does
923 just enough to allow glibc-2.1 ld.so to compile & link. */
926 i370_elf_finish_dynamic_sections (bfd
*output_bfd
,
927 struct bfd_link_info
*info
)
930 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
931 asection
*sgot
= bfd_get_section_by_name (dynobj
, ".got");
934 fprintf (stderr
, "i370_elf_finish_dynamic_sections called\n");
937 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
939 if (elf_hash_table (info
)->dynamic_sections_created
)
942 Elf32_External_Dyn
*dyncon
, *dynconend
;
944 splt
= bfd_get_section_by_name (dynobj
, ".plt");
945 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
947 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
948 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
949 for (; dyncon
< dynconend
; dyncon
++)
951 Elf_Internal_Dyn dyn
;
955 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
959 case DT_PLTGOT
: name
= ".plt"; size
= FALSE
; break;
960 case DT_PLTRELSZ
: name
= ".rela.plt"; size
= TRUE
; break;
961 case DT_JMPREL
: name
= ".rela.plt"; size
= FALSE
; break;
962 default: name
= NULL
; size
= FALSE
; break;
969 s
= bfd_get_section_by_name (output_bfd
, name
);
975 dyn
.d_un
.d_ptr
= s
->vma
;
977 dyn
.d_un
.d_val
= s
->size
;
979 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
984 if (sgot
&& sgot
->size
!= 0)
986 unsigned char *contents
= sgot
->contents
;
989 bfd_put_32 (output_bfd
, (bfd_vma
) 0, contents
);
991 bfd_put_32 (output_bfd
,
992 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
995 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
1002 Elf_Internal_Sym sym
;
1005 /* Set up the section symbols for the output sections. */
1007 sdynsym
= bfd_get_section_by_name (dynobj
, ".dynsym");
1008 BFD_ASSERT (sdynsym
!= NULL
);
1012 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
1015 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
1018 Elf32_External_Sym
*esym
;
1020 sym
.st_value
= s
->vma
;
1022 indx
= elf_section_data (s
)->this_idx
;
1023 dindx
= elf_section_data (s
)->dynindx
;
1026 BFD_ASSERT(indx
> 0);
1027 BFD_ASSERT(dindx
> 0);
1029 if (dindx
> maxdindx
)
1032 sym
.st_shndx
= indx
;
1034 esym
= (Elf32_External_Sym
*) sdynsym
->contents
+ dindx
;
1035 bfd_elf32_swap_symbol_out (output_bfd
, &sym
, esym
, NULL
);
1039 /* Set the sh_info field of the output .dynsym section to the
1040 index of the first global symbol. */
1041 elf_section_data (sdynsym
->output_section
)->this_hdr
.sh_info
=
1048 /* The RELOCATE_SECTION function is called by the ELF backend linker
1049 to handle the relocations for a section.
1051 The relocs are always passed as Rela structures; if the section
1052 actually uses Rel structures, the r_addend field will always be
1055 This function is responsible for adjust the section contents as
1056 necessary, and (if using Rela relocs and generating a
1057 relocatable output file) adjusting the reloc addend as
1060 This function does not have to worry about setting the reloc
1061 address or the reloc symbol index.
1063 LOCAL_SYMS is a pointer to the swapped in local symbols.
1065 LOCAL_SECTIONS is an array giving the section in the input file
1066 corresponding to the st_shndx field of each local symbol.
1068 The global hash table entry for the global symbols can be found
1069 via elf_sym_hashes (input_bfd).
1071 When generating relocatable output, this function must handle
1072 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1073 going to be the section symbol corresponding to the output
1074 section, which means that the addend must be adjusted
1078 i370_elf_relocate_section (bfd
*output_bfd
,
1079 struct bfd_link_info
*info
,
1081 asection
*input_section
,
1083 Elf_Internal_Rela
*relocs
,
1084 Elf_Internal_Sym
*local_syms
,
1085 asection
**local_sections
)
1087 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1088 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
1089 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
1090 Elf_Internal_Rela
*rel
= relocs
;
1091 Elf_Internal_Rela
*relend
= relocs
+ input_section
->reloc_count
;
1092 asection
*sreloc
= NULL
;
1093 bfd_vma
*local_got_offsets
;
1094 bfd_boolean ret
= TRUE
;
1097 _bfd_error_handler ("i370_elf_relocate_section called for %B section %A, %ld relocations%s",
1098 input_bfd
, input_section
,
1099 (long) input_section
->reloc_count
,
1100 (info
->relocatable
) ? " (relocatable)" : "");
1103 if (!i370_elf_howto_table
[ R_I370_ADDR31
])
1104 /* Initialize howto table if needed. */
1105 i370_elf_howto_init ();
1107 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1109 for (; rel
< relend
; rel
++)
1111 enum i370_reloc_type r_type
= (enum i370_reloc_type
) ELF32_R_TYPE (rel
->r_info
);
1112 bfd_vma offset
= rel
->r_offset
;
1113 bfd_vma addend
= rel
->r_addend
;
1114 bfd_reloc_status_type r
= bfd_reloc_other
;
1115 Elf_Internal_Sym
*sym
= NULL
;
1116 asection
*sec
= NULL
;
1117 struct elf_link_hash_entry
* h
= NULL
;
1118 const char *sym_name
= NULL
;
1119 reloc_howto_type
*howto
;
1120 unsigned long r_symndx
;
1123 /* Unknown relocation handling. */
1124 if ((unsigned) r_type
>= (unsigned) R_I370_max
1125 || !i370_elf_howto_table
[(int)r_type
])
1127 (*_bfd_error_handler
) ("%B: unknown relocation type %d",
1131 bfd_set_error (bfd_error_bad_value
);
1136 howto
= i370_elf_howto_table
[(int) r_type
];
1137 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1140 if (r_symndx
< symtab_hdr
->sh_info
)
1142 sym
= local_syms
+ r_symndx
;
1143 sec
= local_sections
[r_symndx
];
1144 sym_name
= "<local symbol>";
1146 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, & sec
, rel
);
1147 addend
= rel
->r_addend
;
1151 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1152 while (h
->root
.type
== bfd_link_hash_indirect
1153 || h
->root
.type
== bfd_link_hash_warning
)
1154 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1155 sym_name
= h
->root
.root
.string
;
1156 if (h
->root
.type
== bfd_link_hash_defined
1157 || h
->root
.type
== bfd_link_hash_defweak
)
1159 sec
= h
->root
.u
.def
.section
;
1161 && ((! info
->symbolic
&& h
->dynindx
!= -1)
1163 && (input_section
->flags
& SEC_ALLOC
) != 0
1164 && (r_type
== R_I370_ADDR31
1165 || r_type
== R_I370_COPY
1166 || r_type
== R_I370_ADDR16
1167 || r_type
== R_I370_RELATIVE
))
1168 /* In these cases, we don't need the relocation
1169 value. We check specially because in some
1170 obscure cases sec->output_section will be NULL. */
1173 relocation
= (h
->root
.u
.def
.value
1174 + sec
->output_section
->vma
1175 + sec
->output_offset
);
1177 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1179 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
1180 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1182 else if (!info
->relocatable
)
1184 if ((*info
->callbacks
->undefined_symbol
)
1185 (info
, h
->root
.root
.string
, input_bfd
,
1186 input_section
, rel
->r_offset
,
1187 (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
1188 || ELF_ST_VISIBILITY (h
->other
))))
1196 if (sec
!= NULL
&& elf_discarded_section (sec
))
1198 /* For relocs against symbols from removed linkonce sections,
1199 or sections discarded by a linker script, we just want the
1200 section contents zeroed. Avoid any special processing. */
1201 _bfd_clear_contents (howto
, input_bfd
, contents
+ rel
->r_offset
);
1207 if (info
->relocatable
)
1210 switch ((int) r_type
)
1213 (*_bfd_error_handler
)
1214 ("%B: unknown relocation type %d for symbol %s",
1215 input_bfd
, (int) r_type
, sym_name
);
1217 bfd_set_error (bfd_error_bad_value
);
1221 case (int) R_I370_NONE
:
1224 /* Relocations that may need to be propagated if this is a shared
1226 case (int) R_I370_REL31
:
1227 /* If these relocations are not to a named symbol, they can be
1228 handled right here, no need to bother the dynamic linker. */
1230 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1234 /* Relocations that always need to be propagated if this is a shared
1236 case (int) R_I370_ADDR31
:
1237 case (int) R_I370_ADDR16
:
1241 Elf_Internal_Rela outrel
;
1247 "i370_elf_relocate_section needs to create relocation for %s\n",
1248 (h
&& h
->root
.root
.string
) ? h
->root
.root
.string
: "<unknown>");
1251 /* When generating a shared object, these relocations
1252 are copied into the output file to be resolved at run
1259 name
= (bfd_elf_string_from_elf_section
1261 elf_elfheader (input_bfd
)->e_shstrndx
,
1262 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1266 BFD_ASSERT (CONST_STRNEQ (name
, ".rela")
1267 && strcmp (bfd_get_section_name (input_bfd
,
1271 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1272 BFD_ASSERT (sreloc
!= NULL
);
1278 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1280 if (outrel
.r_offset
== (bfd_vma
) -1
1281 || outrel
.r_offset
== (bfd_vma
) -2)
1282 skip
= (int) outrel
.r_offset
;
1283 outrel
.r_offset
+= (input_section
->output_section
->vma
1284 + input_section
->output_offset
);
1287 memset (&outrel
, 0, sizeof outrel
);
1288 /* h->dynindx may be -1 if this symbol was marked to
1291 && ((! info
->symbolic
&& h
->dynindx
!= -1)
1292 || !h
->def_regular
))
1294 BFD_ASSERT (h
->dynindx
!= -1);
1295 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1296 outrel
.r_addend
= rel
->r_addend
;
1300 if (r_type
== R_I370_ADDR31
)
1302 outrel
.r_info
= ELF32_R_INFO (0, R_I370_RELATIVE
);
1303 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1309 if (bfd_is_abs_section (sec
))
1311 else if (sec
== NULL
|| sec
->owner
== NULL
)
1313 bfd_set_error (bfd_error_bad_value
);
1320 /* We are turning this relocation into one
1321 against a section symbol. It would be
1322 proper to subtract the symbol's value,
1323 osec->vma, from the emitted reloc addend,
1324 but ld.so expects buggy relocs. */
1325 osec
= sec
->output_section
;
1326 indx
= elf_section_data (osec
)->dynindx
;
1329 struct elf_link_hash_table
*htab
;
1330 htab
= elf_hash_table (info
);
1331 osec
= htab
->text_index_section
;
1332 indx
= elf_section_data (osec
)->dynindx
;
1334 BFD_ASSERT (indx
!= 0);
1338 printf ("indx=%ld section=%s flags=%08x name=%s\n",
1339 indx
, osec
->name
, osec
->flags
,
1340 h
->root
.root
.string
);
1345 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
1346 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1350 loc
= sreloc
->contents
;
1351 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
1352 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1354 /* This reloc will be computed at runtime, so there's no
1355 need to do anything now, unless this is a RELATIVE
1356 reloc in an unallocated section. */
1358 || (input_section
->flags
& SEC_ALLOC
) != 0
1359 || ELF32_R_TYPE (outrel
.r_info
) != R_I370_RELATIVE
)
1364 case (int) R_I370_COPY
:
1365 case (int) R_I370_RELATIVE
:
1366 (*_bfd_error_handler
)
1367 ("%B: Relocation %s is not yet supported for symbol %s.",
1369 i370_elf_howto_table
[(int) r_type
]->name
,
1372 bfd_set_error (bfd_error_invalid_operation
);
1378 fprintf (stderr
, "\ttype = %s (%d), name = %s, symbol index = %ld, offset = %ld, addend = %ld\n",
1387 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
, contents
,
1388 offset
, relocation
, addend
);
1390 if (r
!= bfd_reloc_ok
)
1398 case bfd_reloc_overflow
:
1406 name
= bfd_elf_string_from_elf_section (input_bfd
,
1407 symtab_hdr
->sh_link
,
1413 name
= bfd_section_name (input_bfd
, sec
);
1416 (*info
->callbacks
->reloc_overflow
) (info
,
1417 (h
? &h
->root
: NULL
),
1431 fprintf (stderr
, "\n");
1437 #define TARGET_BIG_SYM bfd_elf32_i370_vec
1438 #define TARGET_BIG_NAME "elf32-i370"
1439 #define ELF_ARCH bfd_arch_i370
1440 #define ELF_MACHINE_CODE EM_S370
1442 #define ELF_MACHINE_ALT1 EM_I370_OLD
1444 #define ELF_MAXPAGESIZE 0x1000
1445 #define ELF_OSABI ELFOSABI_LINUX
1447 #define elf_info_to_howto i370_elf_info_to_howto
1449 #define elf_backend_plt_not_loaded 1
1450 #define elf_backend_rela_normal 1
1452 #define bfd_elf32_bfd_reloc_type_lookup i370_elf_reloc_type_lookup
1453 #define bfd_elf32_bfd_reloc_name_lookup i370_elf_reloc_name_lookup
1454 #define bfd_elf32_bfd_set_private_flags i370_elf_set_private_flags
1455 #define bfd_elf32_bfd_merge_private_bfd_data i370_elf_merge_private_bfd_data
1456 #define elf_backend_relocate_section i370_elf_relocate_section
1458 /* Dynamic loader support is mostly broken; just enough here to be able to
1459 link glibc's ld.so without errors. */
1460 #define elf_backend_create_dynamic_sections i370_elf_create_dynamic_sections
1461 #define elf_backend_size_dynamic_sections i370_elf_size_dynamic_sections
1462 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
1463 #define elf_backend_finish_dynamic_sections i370_elf_finish_dynamic_sections
1464 #define elf_backend_fake_sections i370_elf_fake_sections
1465 #define elf_backend_section_from_shdr i370_elf_section_from_shdr
1466 #define elf_backend_adjust_dynamic_symbol i370_elf_adjust_dynamic_symbol
1467 #define elf_backend_check_relocs i370_elf_check_relocs
1468 #define elf_backend_post_process_headers _bfd_elf_set_osabi
1476 #define elf_backend_finish_dynamic_symbol \
1478 (bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, \
1479 Elf_Internal_Sym *)) i370_noop
1481 #include "elf32-target.h"