1 /* i370-specific support for 32-bit ELF
2 Copyright 1994, 1995, 1996, 1997, 1998, 2000, 2001
3 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 ...
37 #define USE_RELA /* we want RELA relocations, not REL */
39 /* i370 relocations */
40 /* Note that there is really just one relocation that we currently
41 * support (and only one that we seem to need, at the moment), and
42 * that is the 31-bit address relocation. Note that the 370/390
43 * only supports a 31-bit (2GB) address space.
63 static reloc_howto_type
*i370_elf_howto_table
[ (int)R_I370_max
];
65 static reloc_howto_type i370_elf_howto_raw
[] =
67 /* This reloc does nothing. */
68 HOWTO (R_I370_NONE
, /* type */
70 2, /* size (0 = byte, 1 = short, 2 = long) */
72 false, /* pc_relative */
74 complain_overflow_bitfield
, /* complain_on_overflow */
75 bfd_elf_generic_reloc
, /* special_function */
76 "R_I370_NONE", /* name */
77 false, /* partial_inplace */
80 false), /* pcrel_offset */
82 /* A standard 31 bit relocation. */
83 HOWTO (R_I370_ADDR31
, /* type */
85 2, /* size (0 = byte, 1 = short, 2 = long) */
87 false, /* pc_relative */
89 complain_overflow_bitfield
, /* complain_on_overflow */
90 bfd_elf_generic_reloc
, /* special_function */
91 "R_I370_ADDR31", /* name */
92 false, /* partial_inplace */
94 0x7fffffff, /* dst_mask */
95 false), /* pcrel_offset */
97 /* A standard 32 bit relocation. */
98 HOWTO (R_I370_ADDR32
, /* type */
100 2, /* size (0 = byte, 1 = short, 2 = long) */
102 false, /* pc_relative */
104 complain_overflow_bitfield
, /* complain_on_overflow */
105 bfd_elf_generic_reloc
, /* special_function */
106 "R_I370_ADDR32", /* name */
107 false, /* partial_inplace */
109 0xffffffff, /* dst_mask */
110 false), /* pcrel_offset */
112 /* A standard 16 bit relocation. */
113 HOWTO (R_I370_ADDR16
, /* type */
115 1, /* size (0 = byte, 1 = short, 2 = long) */
117 false, /* pc_relative */
119 complain_overflow_bitfield
, /* complain_on_overflow */
120 bfd_elf_generic_reloc
, /* special_function */
121 "R_I370_ADDR16", /* name */
122 false, /* partial_inplace */
124 0xffff, /* dst_mask */
125 false), /* pcrel_offset */
127 /* 31-bit PC relative */
128 HOWTO (R_I370_REL31
, /* type */
130 2, /* size (0 = byte, 1 = short, 2 = long) */
132 true, /* pc_relative */
134 complain_overflow_bitfield
, /* complain_on_overflow */
135 bfd_elf_generic_reloc
, /* special_function */
136 "R_I370_REL31", /* name */
137 false, /* partial_inplace */
139 0x7fffffff, /* dst_mask */
140 true), /* pcrel_offset */
142 /* 32-bit PC relative */
143 HOWTO (R_I370_REL32
, /* type */
145 2, /* size (0 = byte, 1 = short, 2 = long) */
147 true, /* pc_relative */
149 complain_overflow_bitfield
, /* complain_on_overflow */
150 bfd_elf_generic_reloc
, /* special_function */
151 "R_I370_REL32", /* name */
152 false, /* partial_inplace */
154 0xffffffff, /* dst_mask */
155 true), /* pcrel_offset */
157 /* A standard 12 bit relocation. */
158 HOWTO (R_I370_ADDR12
, /* type */
160 1, /* size (0 = byte, 1 = short, 2 = long) */
162 false, /* pc_relative */
164 complain_overflow_bitfield
, /* complain_on_overflow */
165 bfd_elf_generic_reloc
, /* special_function */
166 "R_I370_ADDR12", /* name */
167 false, /* partial_inplace */
169 0xfff, /* dst_mask */
170 false), /* pcrel_offset */
172 /* 12-bit PC relative */
173 HOWTO (R_I370_REL12
, /* type */
175 1, /* size (0 = byte, 1 = short, 2 = long) */
177 true, /* pc_relative */
179 complain_overflow_bitfield
, /* complain_on_overflow */
180 bfd_elf_generic_reloc
, /* special_function */
181 "R_I370_REL12", /* name */
182 false, /* partial_inplace */
184 0xfff, /* dst_mask */
185 true), /* pcrel_offset */
187 /* A standard 8 bit relocation. */
188 HOWTO (R_I370_ADDR8
, /* type */
190 0, /* size (0 = byte, 1 = short, 2 = long) */
192 false, /* pc_relative */
194 complain_overflow_bitfield
, /* complain_on_overflow */
195 bfd_elf_generic_reloc
, /* special_function */
196 "R_I370_ADDR8", /* name */
197 false, /* partial_inplace */
200 false), /* pcrel_offset */
202 /* 8-bit PC relative */
203 HOWTO (R_I370_REL8
, /* type */
205 0, /* size (0 = byte, 1 = short, 2 = long) */
207 true, /* pc_relative */
209 complain_overflow_bitfield
, /* complain_on_overflow */
210 bfd_elf_generic_reloc
, /* special_function */
211 "R_I370_REL8", /* name */
212 false, /* partial_inplace */
215 true), /* pcrel_offset */
217 /* This is used only by the dynamic linker. The symbol should exist
218 both in the object being run and in some shared library. The
219 dynamic linker copies the data addressed by the symbol from the
220 shared library into the object, because the object being
221 run has to have the data at some particular address. */
222 HOWTO (R_I370_COPY
, /* type */
224 2, /* size (0 = byte, 1 = short, 2 = long) */
226 false, /* pc_relative */
228 complain_overflow_bitfield
, /* complain_on_overflow */
229 bfd_elf_generic_reloc
, /* special_function */
230 "R_I370_COPY", /* name */
231 false, /* partial_inplace */
234 false), /* pcrel_offset */
236 /* Used only by the dynamic linker. When the object is run, this
237 longword is set to the load address of the object, plus the
239 HOWTO (R_I370_RELATIVE
, /* type */
241 2, /* size (0 = byte, 1 = short, 2 = long) */
243 false, /* pc_relative */
245 complain_overflow_bitfield
, /* complain_on_overflow */
246 bfd_elf_generic_reloc
, /* special_function */
247 "R_I370_RELATIVE", /* name */
248 false, /* partial_inplace */
250 0xffffffff, /* dst_mask */
251 false), /* pcrel_offset */
255 static void i370_elf_howto_init
PARAMS ((void));
256 static reloc_howto_type
*i370_elf_reloc_type_lookup
257 PARAMS ((bfd
*, bfd_reloc_code_real_type
));
259 static void i370_elf_info_to_howto
PARAMS ((bfd
*abfd
, arelent
*cache_ptr
,
260 Elf32_Internal_Rela
*dst
));
261 static boolean i370_elf_set_private_flags
PARAMS ((bfd
*, flagword
));
263 /* Initialize the i370_elf_howto_table, so that linear accesses can be done. */
266 i370_elf_howto_init ()
268 unsigned int i
, type
;
270 for (i
= 0; i
< sizeof (i370_elf_howto_raw
) / sizeof (i370_elf_howto_raw
[0]); i
++)
272 type
= i370_elf_howto_raw
[i
].type
;
273 BFD_ASSERT (type
< sizeof (i370_elf_howto_table
) / sizeof (i370_elf_howto_table
[0]));
274 i370_elf_howto_table
[type
] = &i370_elf_howto_raw
[i
];
278 static reloc_howto_type
*
279 i370_elf_reloc_type_lookup (abfd
, code
)
280 bfd
*abfd ATTRIBUTE_UNUSED
;
281 bfd_reloc_code_real_type code
;
283 enum i370_reloc_type i370_reloc
= R_I370_NONE
;
285 if (!i370_elf_howto_table
[ R_I370_ADDR31
]) /* Initialize howto table if needed */
286 i370_elf_howto_init ();
291 return (reloc_howto_type
*)NULL
;
293 case BFD_RELOC_NONE
: i370_reloc
= R_I370_NONE
; break;
294 case BFD_RELOC_32
: i370_reloc
= R_I370_ADDR31
; break;
295 case BFD_RELOC_16
: i370_reloc
= R_I370_ADDR16
; break;
296 case BFD_RELOC_32_PCREL
: i370_reloc
= R_I370_REL31
; break;
297 case BFD_RELOC_CTOR
: i370_reloc
= R_I370_ADDR31
; break;
298 case BFD_RELOC_I370_D12
: i370_reloc
= R_I370_ADDR12
; break;
301 return i370_elf_howto_table
[ (int)i370_reloc
];
304 static boolean i370_elf_merge_private_bfd_data
PARAMS ((bfd
*, bfd
*));
306 static boolean i370_elf_relocate_section
PARAMS ((bfd
*,
307 struct bfd_link_info
*info
,
311 Elf_Internal_Rela
*relocs
,
312 Elf_Internal_Sym
*local_syms
,
314 static void i370_elf_post_process_headers
315 PARAMS ((bfd
*, struct bfd_link_info
*));
317 static boolean i370_elf_create_dynamic_sections
PARAMS ((bfd
*,
318 struct bfd_link_info
*));
320 static boolean i370_elf_section_from_shdr
PARAMS ((bfd
*,
321 Elf32_Internal_Shdr
*,
323 static boolean i370_elf_fake_sections
PARAMS ((bfd
*,
324 Elf32_Internal_Shdr
*,
327 static elf_linker_section_t
*i370_elf_create_linker_section
329 struct bfd_link_info
*info
,
330 enum elf_linker_section_enum
));
332 static boolean i370_elf_check_relocs
PARAMS ((bfd
*,
333 struct bfd_link_info
*,
335 const Elf_Internal_Rela
*));
337 static boolean i370_elf_adjust_dynamic_symbol
PARAMS ((struct bfd_link_info
*,
338 struct elf_link_hash_entry
*));
340 static boolean i370_elf_adjust_dynindx
PARAMS ((struct elf_link_hash_entry
*, PTR
));
342 static boolean i370_elf_size_dynamic_sections
PARAMS ((bfd
*, struct bfd_link_info
*));
344 static boolean i370_elf_finish_dynamic_sections
PARAMS ((bfd
*, struct bfd_link_info
*));
346 /* The name of the dynamic interpreter. This is put in the .interp
349 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
351 /* Set the howto pointer for an i370 ELF reloc. */
354 i370_elf_info_to_howto (abfd
, cache_ptr
, dst
)
355 bfd
*abfd ATTRIBUTE_UNUSED
;
357 Elf32_Internal_Rela
*dst
;
359 if (!i370_elf_howto_table
[ R_I370_ADDR31
]) /* Initialize howto table */
360 i370_elf_howto_init ();
362 BFD_ASSERT (ELF32_R_TYPE (dst
->r_info
) < (unsigned int) R_I370_max
);
363 cache_ptr
->howto
= i370_elf_howto_table
[ELF32_R_TYPE (dst
->r_info
)];
366 /* hack alert -- the following several routines look generic to me ...
367 * why are we bothering with them ???
369 /* Function to set whether a module needs the -mrelocatable bit set. */
371 i370_elf_set_private_flags (abfd
, flags
)
375 BFD_ASSERT (!elf_flags_init (abfd
)
376 || elf_elfheader (abfd
)->e_flags
== flags
);
378 elf_elfheader (abfd
)->e_flags
= flags
;
379 elf_flags_init (abfd
) = true;
383 /* Merge backend specific data from an object file to the output
384 object file when linking */
386 i370_elf_merge_private_bfd_data (ibfd
, obfd
)
393 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
394 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
397 new_flags
= elf_elfheader (ibfd
)->e_flags
;
398 old_flags
= elf_elfheader (obfd
)->e_flags
;
399 if (!elf_flags_init (obfd
)) /* First call, no flags set */
401 elf_flags_init (obfd
) = true;
402 elf_elfheader (obfd
)->e_flags
= new_flags
;
405 else if (new_flags
== old_flags
) /* Compatible flags are ok */
408 else /* Incompatible flags */
410 (*_bfd_error_handler
)
411 ("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)",
412 bfd_archive_filename (ibfd
), (long) new_flags
, (long) old_flags
);
414 bfd_set_error (bfd_error_bad_value
);
421 /* Handle an i370 specific section when reading an object file. This
422 is called when elfcode.h finds a section with an unknown type. */
423 /* XXX hack alert bogus This routine is mostly all junk and almost
424 * certainly does the wrong thing. Its here simply because it does
425 * just enough to allow glibc-2.1 ld.so to compile & link.
429 i370_elf_section_from_shdr (abfd
, hdr
, name
)
431 Elf32_Internal_Shdr
*hdr
;
437 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
440 newsect
= hdr
->bfd_section
;
441 flags
= bfd_get_section_flags (abfd
, newsect
);
442 if (hdr
->sh_flags
& SHF_EXCLUDE
)
443 flags
|= SEC_EXCLUDE
;
445 if (hdr
->sh_type
== SHT_ORDERED
)
446 flags
|= SEC_SORT_ENTRIES
;
448 bfd_set_section_flags (abfd
, newsect
, flags
);
452 /* Set up any other section flags and such that may be necessary. */
453 /* XXX hack alert bogus This routine is mostly all junk and almost
454 * certainly does the wrong thing. Its here simply because it does
455 * just enough to allow glibc-2.1 ld.so to compile & link.
459 i370_elf_fake_sections (abfd
, shdr
, asect
)
460 bfd
*abfd ATTRIBUTE_UNUSED
;
461 Elf32_Internal_Shdr
*shdr
;
464 if ((asect
->flags
& SEC_EXCLUDE
) != 0)
465 shdr
->sh_flags
|= SHF_EXCLUDE
;
467 if ((asect
->flags
& SEC_SORT_ENTRIES
) != 0)
468 shdr
->sh_type
= SHT_ORDERED
;
474 /* Create a special linker section */
475 /* XXX hack alert bogus This routine is mostly all junk and almost
476 * certainly does the wrong thing. Its here simply because it does
477 * just enough to allow glibc-2.1 ld.so to compile & link.
480 static elf_linker_section_t
*
481 i370_elf_create_linker_section (abfd
, info
, which
)
483 struct bfd_link_info
*info
;
484 enum elf_linker_section_enum which
;
486 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
487 elf_linker_section_t
*lsect
;
489 /* Record the first bfd section that needs the special section */
491 dynobj
= elf_hash_table (info
)->dynobj
= abfd
;
493 /* If this is the first time, create the section */
494 lsect
= elf_linker_section (dynobj
, which
);
497 elf_linker_section_t defaults
;
498 static elf_linker_section_t zero_section
;
500 defaults
= zero_section
;
501 defaults
.which
= which
;
502 defaults
.hole_written_p
= false;
503 defaults
.alignment
= 2;
505 /* Both of these sections are (technically) created by the user
506 putting data in them, so they shouldn't be marked
509 The linker creates them so it has somewhere to attach their
510 respective symbols. In fact, if they were empty it would
511 be OK to leave the symbol set to 0 (or any random number), because
512 the appropriate register should never be used. */
513 defaults
.flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
519 (*_bfd_error_handler
) ("%s: Unknown special linker type %d",
520 bfd_archive_filename (abfd
),
523 bfd_set_error (bfd_error_bad_value
);
524 return (elf_linker_section_t
*)0;
526 case LINKER_SECTION_SDATA
: /* .sdata/.sbss section */
527 defaults
.name
= ".sdata";
528 defaults
.rel_name
= ".rela.sdata";
529 defaults
.bss_name
= ".sbss";
530 defaults
.sym_name
= "_SDA_BASE_";
531 defaults
.sym_offset
= 32768;
534 case LINKER_SECTION_SDATA2
: /* .sdata2/.sbss2 section */
535 defaults
.name
= ".sdata2";
536 defaults
.rel_name
= ".rela.sdata2";
537 defaults
.bss_name
= ".sbss2";
538 defaults
.sym_name
= "_SDA2_BASE_";
539 defaults
.sym_offset
= 32768;
540 defaults
.flags
|= SEC_READONLY
;
544 lsect
= _bfd_elf_create_linker_section (abfd
, info
, which
, &defaults
);
551 /* We have to create .dynsbss and .rela.sbss here so that they get mapped
552 to output sections (just like _bfd_elf_create_dynamic_sections has
553 to create .dynbss and .rela.bss). */
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.
560 i370_elf_create_dynamic_sections (abfd
, info
)
562 struct bfd_link_info
*info
;
564 register asection
*s
;
567 if (!_bfd_elf_create_dynamic_sections(abfd
, info
))
570 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
571 | SEC_LINKER_CREATED
);
573 s
= bfd_make_section (abfd
, ".dynsbss");
575 || ! bfd_set_section_flags (abfd
, s
, SEC_ALLOC
))
580 s
= bfd_make_section (abfd
, ".rela.sbss");
582 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
583 || ! bfd_set_section_alignment (abfd
, s
, 2))
587 /* xxx beats me, seem to need a rela.text ... */
588 s
= bfd_make_section (abfd
, ".rela.text");
590 || ! bfd_set_section_flags (abfd
, s
, flags
| SEC_READONLY
)
591 || ! bfd_set_section_alignment (abfd
, s
, 2))
596 /* Adjust a symbol defined by a dynamic object and referenced by a
597 regular object. The current definition is in some section of the
598 dynamic object, but we're not including those sections. We have to
599 change the definition to something the rest of the link can
601 /* XXX hack alert bogus This routine is mostly all junk and almost
602 * certainly does the wrong thing. Its here simply because it does
603 * just enough to allow glibc-2.1 ld.so to compile & link.
607 i370_elf_adjust_dynamic_symbol (info
, h
)
608 struct bfd_link_info
*info
;
609 struct elf_link_hash_entry
*h
;
611 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
613 unsigned int power_of_two
;
616 fprintf (stderr
, "i370_elf_adjust_dynamic_symbol called for %s\n",
617 h
->root
.root
.string
);
620 /* Make sure we know what is going on here. */
621 BFD_ASSERT (dynobj
!= NULL
622 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
623 || h
->weakdef
!= NULL
624 || ((h
->elf_link_hash_flags
625 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
626 && (h
->elf_link_hash_flags
627 & ELF_LINK_HASH_REF_REGULAR
) != 0
628 && (h
->elf_link_hash_flags
629 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
631 s
= bfd_get_section_by_name (dynobj
, ".rela.text");
632 BFD_ASSERT (s
!= NULL
);
633 s
->_raw_size
+= sizeof (Elf32_External_Rela
);
635 /* If this is a weak symbol, and there is a real definition, the
636 processor independent code will have arranged for us to see the
637 real definition first, and we can just use the same value. */
638 if (h
->weakdef
!= NULL
)
640 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
641 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
642 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
643 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
647 /* This is a reference to a symbol defined by a dynamic object which
648 is not a function. */
650 /* If we are creating a shared library, we must presume that the
651 only references to the symbol are via the global offset table.
652 For such cases we need not do anything here; the relocations will
653 be handled correctly by relocate_section. */
657 /* We must allocate the symbol in our .dynbss section, which will
658 become part of the .bss section of the executable. There will be
659 an entry for this symbol in the .dynsym section. The dynamic
660 object will contain position independent code, so all references
661 from the dynamic object to this symbol will go through the global
662 offset table. The dynamic linker will use the .dynsym entry to
663 determine the address it must put in the global offset table, so
664 both the dynamic object and the regular object will refer to the
665 same memory location for the variable.
667 Of course, if the symbol is sufficiently small, we must instead
668 allocate it in .sbss. FIXME: It would be better to do this if and
669 only if there were actually SDAREL relocs for that symbol. */
671 if (h
->size
<= elf_gp_size (dynobj
))
672 s
= bfd_get_section_by_name (dynobj
, ".dynsbss");
674 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
675 BFD_ASSERT (s
!= NULL
);
677 /* We must generate a R_I370_COPY reloc to tell the dynamic linker to
678 copy the initial value out of the dynamic object and into the
679 runtime process image. We need to remember the offset into the
680 .rela.bss section we are going to use. */
681 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
685 if (h
->size
<= elf_gp_size (dynobj
))
686 srel
= bfd_get_section_by_name (dynobj
, ".rela.sbss");
688 srel
= bfd_get_section_by_name (dynobj
, ".rela.bss");
689 BFD_ASSERT (srel
!= NULL
);
690 srel
->_raw_size
+= sizeof (Elf32_External_Rela
);
691 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
694 /* We need to figure out the alignment required for this symbol. I
695 have no idea how ELF linkers handle this. */
696 power_of_two
= bfd_log2 (h
->size
);
697 if (power_of_two
> 4)
700 /* Apply the required alignment. */
701 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
702 (bfd_size_type
) (1 << power_of_two
));
703 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
705 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
709 /* Define the symbol as being at this point in the section. */
710 h
->root
.u
.def
.section
= s
;
711 h
->root
.u
.def
.value
= s
->_raw_size
;
713 /* Increment the section size to make room for the symbol. */
714 s
->_raw_size
+= h
->size
;
719 /* Increment the index of a dynamic symbol by a given amount. Called
720 via elf_link_hash_traverse. */
721 /* XXX hack alert bogus This routine is mostly all junk and almost
722 * certainly does the wrong thing. Its here simply because it does
723 * just enough to allow glibc-2.1 ld.so to compile & link.
727 i370_elf_adjust_dynindx (h
, cparg
)
728 struct elf_link_hash_entry
*h
;
731 int *cp
= (int *) cparg
;
735 "i370_elf_adjust_dynindx called, h->dynindx = %d, *cp = %d\n",
739 if (h
->dynindx
!= -1)
745 /* Set the sizes of the dynamic sections. */
746 /* XXX hack alert bogus This routine is mostly all junk and almost
747 * certainly does the wrong thing. Its here simply because it does
748 * just enough to allow glibc-2.1 ld.so to compile & link.
752 i370_elf_size_dynamic_sections (output_bfd
, info
)
754 struct bfd_link_info
*info
;
763 fprintf (stderr
, "i370_elf_size_dynamic_sections called\n");
766 dynobj
= elf_hash_table (info
)->dynobj
;
767 BFD_ASSERT (dynobj
!= NULL
);
769 if (elf_hash_table (info
)->dynamic_sections_created
)
771 /* Set the contents of the .interp section to the interpreter. */
774 s
= bfd_get_section_by_name (dynobj
, ".interp");
775 BFD_ASSERT (s
!= NULL
);
776 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
777 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
782 /* We may have created entries in the .rela.got, .rela.sdata, and
783 .rela.sdata2 sections. However, if we are not creating the
784 dynamic sections, we will not actually use these entries. Reset
785 the size of .rela.got, et al, which will cause it to get
786 stripped from the output file below. */
787 static char *rela_sections
[] = { ".rela.got", ".rela.sdata",
788 ".rela.sdata2", ".rela.sbss",
792 for (p
= rela_sections
; *p
!= (char *)0; p
++)
794 s
= bfd_get_section_by_name (dynobj
, *p
);
800 /* The check_relocs and adjust_dynamic_symbol entry points have
801 determined the sizes of the various dynamic sections. Allocate
806 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
811 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
814 /* It's OK to base decisions on the section name, because none
815 of the dynobj section names depend upon the input files. */
816 name
= bfd_get_section_name (dynobj
, s
);
819 if (strcmp (name
, ".plt") == 0)
821 if (s
->_raw_size
== 0)
823 /* Strip this section if we don't need it; see the
829 /* Remember whether there is a PLT. */
833 else if (strncmp (name
, ".rela", 5) == 0)
835 if (s
->_raw_size
== 0)
837 /* If we don't need this section, strip it from the
838 output file. This is mostly to handle .rela.bss and
839 .rela.plt. We must create both sections in
840 create_dynamic_sections, because they must be created
841 before the linker maps input sections to output
842 sections. The linker does that before
843 adjust_dynamic_symbol is called, and it is that
844 function which decides whether anything needs to go
845 into these sections. */
853 /* Remember whether there are any relocation sections. */
856 /* If this relocation section applies to a read only
857 section, then we probably need a DT_TEXTREL entry. */
858 outname
= bfd_get_section_name (output_bfd
,
860 target
= bfd_get_section_by_name (output_bfd
, outname
+ 5);
862 && (target
->flags
& SEC_READONLY
) != 0
863 && (target
->flags
& SEC_ALLOC
) != 0)
866 /* We use the reloc_count field as a counter if we need
867 to copy relocs into the output file. */
871 else if (strcmp (name
, ".got") != 0
872 && strcmp (name
, ".sdata") != 0
873 && strcmp (name
, ".sdata2") != 0)
875 /* It's not one of our sections, so don't allocate space. */
883 for (spp
= &s
->output_section
->owner
->sections
;
884 *spp
!= s
->output_section
;
887 *spp
= s
->output_section
->next
;
888 --s
->output_section
->owner
->section_count
;
892 /* Allocate memory for the section contents. */
893 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
894 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
898 if (elf_hash_table (info
)->dynamic_sections_created
)
900 /* Add some entries to the .dynamic section. We fill in the
901 values later, in i370_elf_finish_dynamic_sections, but we
902 must add the entries now so that we get the correct size for
903 the .dynamic section. The DT_DEBUG entry is filled in by the
904 dynamic linker and used by the debugger. */
905 #define add_dynamic_entry(TAG, VAL) \
906 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
910 if (!add_dynamic_entry (DT_DEBUG
, 0))
916 if (!add_dynamic_entry (DT_PLTGOT
, 0)
917 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
918 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
919 || !add_dynamic_entry (DT_JMPREL
, 0))
925 if (!add_dynamic_entry (DT_RELA
, 0)
926 || !add_dynamic_entry (DT_RELASZ
, 0)
927 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
933 if (!add_dynamic_entry (DT_TEXTREL
, 0))
935 info
->flags
|= DF_TEXTREL
;
938 #undef add_dynamic_entry
940 /* If we are generating a shared library, we generate a section
941 symbol for each output section. These are local symbols, which
942 means that they must come first in the dynamic symbol table.
943 That means we must increment the dynamic symbol index of every
944 other dynamic symbol.
946 FIXME: We assume that there will never be relocations to
947 locations in linker-created sections that do not have
948 externally-visible names. Instead, we should work out precisely
949 which sections relocations are targetted at. */
954 for (c
= 0, s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
956 if ((s
->flags
& SEC_LINKER_CREATED
) != 0
957 || (s
->flags
& SEC_ALLOC
) == 0)
959 elf_section_data (s
)->dynindx
= -1;
963 /* These symbols will have no names, so we don't need to
964 fiddle with dynstr_index. */
966 elf_section_data (s
)->dynindx
= c
+ 1;
971 elf_link_hash_traverse (elf_hash_table (info
),
972 i370_elf_adjust_dynindx
,
974 elf_hash_table (info
)->dynsymcount
+= c
;
980 /* Look through the relocs for a section during the first phase, and
981 allocate space in the global offset table or procedure linkage
983 /* XXX hack alert bogus This routine is mostly all junk and almost
984 * certainly does the wrong thing. Its here simply because it does
985 * just enough to allow glibc-2.1 ld.so to compile & link.
989 i370_elf_check_relocs (abfd
, info
, sec
, relocs
)
991 struct bfd_link_info
*info
;
993 const Elf_Internal_Rela
*relocs
;
996 Elf_Internal_Shdr
*symtab_hdr
;
997 struct elf_link_hash_entry
**sym_hashes
;
998 const Elf_Internal_Rela
*rel
;
999 const Elf_Internal_Rela
*rel_end
;
1000 bfd_vma
*local_got_offsets
;
1003 if (info
->relocateable
)
1007 fprintf (stderr
, "i370_elf_check_relocs called for section %s in %s\n",
1008 bfd_get_section_name (abfd
, sec
),
1009 bfd_archive_filename (abfd
));
1012 dynobj
= elf_hash_table (info
)->dynobj
;
1013 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1014 sym_hashes
= elf_sym_hashes (abfd
);
1015 local_got_offsets
= elf_local_got_offsets (abfd
);
1019 rel_end
= relocs
+ sec
->reloc_count
;
1020 for (rel
= relocs
; rel
< rel_end
; rel
++)
1022 unsigned long r_symndx
;
1023 struct elf_link_hash_entry
*h
;
1025 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1026 if (r_symndx
< symtab_hdr
->sh_info
)
1029 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1035 "i370_elf_check_relocs needs to create relocation for %s\n",
1036 (h
&& h
->root
.root
.string
)
1037 ? h
->root
.root
.string
: "<unknown>");
1043 name
= (bfd_elf_string_from_elf_section
1045 elf_elfheader (abfd
)->e_shstrndx
,
1046 elf_section_data (sec
)->rel_hdr
.sh_name
));
1050 BFD_ASSERT (strncmp (name
, ".rela", 5) == 0
1051 && strcmp (bfd_get_section_name (abfd
, sec
), name
+ 5) == 0);
1053 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1058 sreloc
= bfd_make_section (dynobj
, name
);
1059 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
1060 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
1061 if ((sec
->flags
& SEC_ALLOC
) != 0)
1062 flags
|= SEC_ALLOC
| SEC_LOAD
;
1064 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
1065 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
1070 sreloc
->_raw_size
+= sizeof (Elf32_External_Rela
);
1072 /* FIXME: We should here do what the m68k and i386
1073 backends do: if the reloc is pc-relative, record it
1074 in case it turns out that the reloc is unnecessary
1075 because the symbol is forced local by versioning or
1076 we are linking with -Bdynamic. Fortunately this
1077 case is not frequent. */
1084 /* Finish up the dynamic sections. */
1085 /* XXX hack alert bogus This routine is mostly all junk and almost
1086 * certainly does the wrong thing. Its here simply because it does
1087 * just enough to allow glibc-2.1 ld.so to compile & link.
1091 i370_elf_finish_dynamic_sections (output_bfd
, info
)
1093 struct bfd_link_info
*info
;
1096 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
1097 asection
*sgot
= bfd_get_section_by_name (dynobj
, ".got");
1100 fprintf (stderr
, "i370_elf_finish_dynamic_sections called\n");
1103 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
1105 if (elf_hash_table (info
)->dynamic_sections_created
)
1108 Elf32_External_Dyn
*dyncon
, *dynconend
;
1110 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1111 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
1113 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
1114 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
1115 for (; dyncon
< dynconend
; dyncon
++)
1117 Elf_Internal_Dyn dyn
;
1121 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
1125 case DT_PLTGOT
: name
= ".plt"; size
= false; break;
1126 case DT_PLTRELSZ
: name
= ".rela.plt"; size
= true; break;
1127 case DT_JMPREL
: name
= ".rela.plt"; size
= false; break;
1128 default: name
= NULL
; size
= false; break;
1135 s
= bfd_get_section_by_name (output_bfd
, name
);
1141 dyn
.d_un
.d_ptr
= s
->vma
;
1144 if (s
->_cooked_size
!= 0)
1145 dyn
.d_un
.d_val
= s
->_cooked_size
;
1147 dyn
.d_un
.d_val
= s
->_raw_size
;
1150 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
1155 /* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4 so that a function can
1156 easily find the address of the _GLOBAL_OFFSET_TABLE_. */
1157 /* XXX this is clearly very wrong for the 370 arch */
1160 unsigned char *contents
= sgot
->contents
;
1161 bfd_put_32 (output_bfd
, (bfd_vma
) 0x4e800021 /* blrl */, contents
);
1164 bfd_put_32 (output_bfd
, (bfd_vma
) 0, contents
+4);
1166 bfd_put_32 (output_bfd
,
1167 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
1170 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
1177 Elf_Internal_Sym sym
;
1180 /* Set up the section symbols for the output sections. */
1182 sdynsym
= bfd_get_section_by_name (dynobj
, ".dynsym");
1183 BFD_ASSERT (sdynsym
!= NULL
);
1187 sym
.st_info
= ELF_ST_INFO (STB_LOCAL
, STT_SECTION
);
1190 for (s
= output_bfd
->sections
; s
!= NULL
; s
= s
->next
)
1193 Elf32_External_Sym
*esym
;
1195 sym
.st_value
= s
->vma
;
1197 indx
= elf_section_data (s
)->this_idx
;
1198 dindx
= elf_section_data (s
)->dynindx
;
1201 BFD_ASSERT(indx
> 0);
1202 BFD_ASSERT(dindx
> 0);
1204 if (dindx
> maxdindx
)
1207 sym
.st_shndx
= indx
;
1209 esym
= (Elf32_External_Sym
*) sdynsym
->contents
+ dindx
;
1210 bfd_elf32_swap_symbol_out (output_bfd
, &sym
, (PTR
) esym
, (PTR
) 0);
1214 /* Set the sh_info field of the output .dynsym section to the
1215 index of the first global symbol. */
1216 elf_section_data (sdynsym
->output_section
)->this_hdr
.sh_info
=
1223 /* The RELOCATE_SECTION function is called by the ELF backend linker
1224 to handle the relocations for a section.
1226 The relocs are always passed as Rela structures; if the section
1227 actually uses Rel structures, the r_addend field will always be
1230 This function is responsible for adjust the section contents as
1231 necessary, and (if using Rela relocs and generating a
1232 relocateable output file) adjusting the reloc addend as
1235 This function does not have to worry about setting the reloc
1236 address or the reloc symbol index.
1238 LOCAL_SYMS is a pointer to the swapped in local symbols.
1240 LOCAL_SECTIONS is an array giving the section in the input file
1241 corresponding to the st_shndx field of each local symbol.
1243 The global hash table entry for the global symbols can be found
1244 via elf_sym_hashes (input_bfd).
1246 When generating relocateable output, this function must handle
1247 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1248 going to be the section symbol corresponding to the output
1249 section, which means that the addend must be adjusted
1253 i370_elf_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1254 contents
, relocs
, local_syms
, local_sections
)
1256 struct bfd_link_info
*info
;
1258 asection
*input_section
;
1260 Elf_Internal_Rela
*relocs
;
1261 Elf_Internal_Sym
*local_syms
;
1262 asection
**local_sections
;
1264 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1265 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
1266 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
1267 Elf_Internal_Rela
*rel
= relocs
;
1268 Elf_Internal_Rela
*relend
= relocs
+ input_section
->reloc_count
;
1269 asection
*sreloc
= NULL
;
1270 bfd_vma
*local_got_offsets
;
1274 fprintf (stderr
, "i370_elf_relocate_section called for %s section %s, %ld relocations%s\n",
1275 bfd_archive_filename (input_bfd
),
1276 bfd_section_name(input_bfd
, input_section
),
1277 (long) input_section
->reloc_count
,
1278 (info
->relocateable
) ? " (relocatable)" : "");
1281 if (!i370_elf_howto_table
[ R_I370_ADDR31
]) /* Initialize howto table if needed */
1282 i370_elf_howto_init ();
1284 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1286 for (; rel
< relend
; rel
++)
1288 enum i370_reloc_type r_type
= (enum i370_reloc_type
)ELF32_R_TYPE (rel
->r_info
);
1289 bfd_vma offset
= rel
->r_offset
;
1290 bfd_vma addend
= rel
->r_addend
;
1291 bfd_reloc_status_type r
= bfd_reloc_other
;
1292 Elf_Internal_Sym
*sym
= (Elf_Internal_Sym
*)0;
1293 asection
*sec
= (asection
*)0;
1294 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*)0;
1295 const char *sym_name
= (const char *)0;
1296 reloc_howto_type
*howto
;
1297 unsigned long r_symndx
;
1300 /* Unknown relocation handling */
1301 if ((unsigned)r_type
>= (unsigned)R_I370_max
1302 || !i370_elf_howto_table
[(int)r_type
])
1304 (*_bfd_error_handler
) ("%s: unknown relocation type %d",
1305 bfd_archive_filename (input_bfd
),
1308 bfd_set_error (bfd_error_bad_value
);
1313 howto
= i370_elf_howto_table
[(int)r_type
];
1314 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1316 if (info
->relocateable
)
1318 /* This is a relocateable link. We don't have to change
1319 anything, unless the reloc is against a section symbol,
1320 in which case we have to adjust according to where the
1321 section symbol winds up in the output section. */
1322 if (r_symndx
< symtab_hdr
->sh_info
)
1324 sym
= local_syms
+ r_symndx
;
1325 if ((unsigned)ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1327 sec
= local_sections
[r_symndx
];
1328 addend
= rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1333 fprintf (stderr
, "\ttype = %s (%d), symbol index = %ld, offset = %ld, addend = %ld\n",
1343 /* This is a final link. */
1344 if (r_symndx
< symtab_hdr
->sh_info
)
1346 sym
= local_syms
+ r_symndx
;
1347 sec
= local_sections
[r_symndx
];
1348 sym_name
= "<local symbol>";
1350 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, sec
, rel
);
1351 addend
= rel
->r_addend
;
1355 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1356 while (h
->root
.type
== bfd_link_hash_indirect
1357 || h
->root
.type
== bfd_link_hash_warning
)
1358 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1359 sym_name
= h
->root
.root
.string
;
1360 if (h
->root
.type
== bfd_link_hash_defined
1361 || h
->root
.type
== bfd_link_hash_defweak
)
1363 sec
= h
->root
.u
.def
.section
;
1365 && ((! info
->symbolic
&& h
->dynindx
!= -1)
1366 || (h
->elf_link_hash_flags
1367 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
1368 && (input_section
->flags
& SEC_ALLOC
) != 0
1369 && (r_type
== R_I370_ADDR31
1370 || r_type
== R_I370_COPY
1371 || r_type
== R_I370_ADDR16
1372 || r_type
== R_I370_RELATIVE
))
1374 /* In these cases, we don't need the relocation
1375 value. We check specially because in some
1376 obscure cases sec->output_section will be NULL. */
1380 relocation
= (h
->root
.u
.def
.value
1381 + sec
->output_section
->vma
1382 + sec
->output_offset
);
1384 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1386 else if (info
->shared
1387 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1391 (*info
->callbacks
->undefined_symbol
) (info
,
1392 h
->root
.root
.string
,
1402 switch ((int) r_type
)
1405 (*_bfd_error_handler
)
1406 ("%s: unknown relocation type %d for symbol %s",
1407 bfd_archive_filename (input_bfd
),
1408 (int) r_type
, sym_name
);
1410 bfd_set_error (bfd_error_bad_value
);
1414 case (int)R_I370_NONE
:
1417 /* Relocations that may need to be propagated if this is a shared
1419 case (int)R_I370_REL31
:
1420 /* If these relocations are not to a named symbol, they can be
1421 handled right here, no need to bother the dynamic linker. */
1423 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
1427 /* Relocations that always need to be propagated if this is a shared
1429 case (int)R_I370_ADDR31
:
1430 case (int)R_I370_ADDR16
:
1434 Elf_Internal_Rela outrel
;
1439 "i370_elf_relocate_section needs to create relocation for %s\n",
1440 (h
&& h
->root
.root
.string
) ? h
->root
.root
.string
: "<unknown>");
1443 /* When generating a shared object, these relocations
1444 are copied into the output file to be resolved at run
1451 name
= (bfd_elf_string_from_elf_section
1453 elf_elfheader (input_bfd
)->e_shstrndx
,
1454 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1458 BFD_ASSERT (strncmp (name
, ".rela", 5) == 0
1459 && strcmp (bfd_get_section_name (input_bfd
,
1463 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1464 BFD_ASSERT (sreloc
!= NULL
);
1470 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1472 if (outrel
.r_offset
== (bfd_vma
) -1)
1474 outrel
.r_offset
+= (input_section
->output_section
->vma
1475 + input_section
->output_offset
);
1478 memset (&outrel
, 0, sizeof outrel
);
1479 /* h->dynindx may be -1 if this symbol was marked to
1482 && ((! info
->symbolic
&& h
->dynindx
!= -1)
1483 || (h
->elf_link_hash_flags
1484 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1486 BFD_ASSERT (h
->dynindx
!= -1);
1487 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1488 outrel
.r_addend
= rel
->r_addend
;
1492 if (r_type
== R_I370_ADDR31
)
1494 outrel
.r_info
= ELF32_R_INFO (0, R_I370_RELATIVE
);
1495 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1502 sec
= local_sections
[r_symndx
];
1505 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
1507 == bfd_link_hash_defweak
));
1508 sec
= h
->root
.u
.def
.section
;
1510 if (sec
!= NULL
&& bfd_is_abs_section (sec
))
1512 else if (sec
== NULL
|| sec
->owner
== NULL
)
1514 bfd_set_error (bfd_error_bad_value
);
1521 osec
= sec
->output_section
;
1522 indx
= elf_section_data (osec
)->dynindx
;
1523 BFD_ASSERT(indx
> 0);
1527 printf ("indx=%d section=%s flags=%08x name=%s\n",
1528 indx
, osec
->name
, osec
->flags
,
1529 h
->root
.root
.string
);
1534 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
1535 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1539 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
1540 (((Elf32_External_Rela
*)
1542 + sreloc
->reloc_count
));
1543 ++sreloc
->reloc_count
;
1545 /* This reloc will be computed at runtime, so there's no
1546 need to do anything now, unless this is a RELATIVE
1547 reloc in an unallocated section. */
1549 || (input_section
->flags
& SEC_ALLOC
) != 0
1550 || ELF32_R_TYPE (outrel
.r_info
) != R_I370_RELATIVE
)
1555 case (int)R_I370_COPY
:
1556 case (int)R_I370_RELATIVE
:
1557 (*_bfd_error_handler
)
1558 ("%s: Relocation %s is not yet supported for symbol %s.",
1559 bfd_archive_filename (input_bfd
),
1560 i370_elf_howto_table
[(int) r_type
]->name
,
1563 bfd_set_error (bfd_error_invalid_operation
);
1569 fprintf (stderr
, "\ttype = %s (%d), name = %s, symbol index = %ld, offset = %ld, addend = %ld\n",
1578 r
= _bfd_final_link_relocate (howto
,
1586 if (r
!= bfd_reloc_ok
)
1594 case bfd_reloc_overflow
:
1599 name
= h
->root
.root
.string
;
1602 name
= bfd_elf_string_from_elf_section (input_bfd
,
1603 symtab_hdr
->sh_link
,
1609 name
= bfd_section_name (input_bfd
, sec
);
1612 (*info
->callbacks
->reloc_overflow
) (info
,
1627 fprintf (stderr
, "\n");
1634 i370_elf_post_process_headers (abfd
, link_info
)
1636 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
;
1638 Elf_Internal_Ehdr
* i_ehdrp
; /* Elf file header, internal form */
1640 i_ehdrp
= elf_elfheader (abfd
);
1641 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_LINUX
;
1644 #define TARGET_BIG_SYM bfd_elf32_i370_vec
1645 #define TARGET_BIG_NAME "elf32-i370"
1646 #define ELF_ARCH bfd_arch_i370
1647 #define ELF_MACHINE_CODE EM_S370
1649 #define ELF_MACHINE_ALT1 EM_I370_OLD
1651 #define ELF_MAXPAGESIZE 0x1000
1652 #define elf_info_to_howto i370_elf_info_to_howto
1654 #define elf_backend_plt_not_loaded 1
1655 #define elf_backend_got_symbol_offset 4
1657 #define bfd_elf32_bfd_reloc_type_lookup i370_elf_reloc_type_lookup
1658 #define bfd_elf32_bfd_set_private_flags i370_elf_set_private_flags
1659 #define bfd_elf32_bfd_merge_private_bfd_data i370_elf_merge_private_bfd_data
1660 #define elf_backend_relocate_section i370_elf_relocate_section
1662 /* dynamic loader support is mostly broken; just enough here to be able to
1663 * link glibc's ld.so without errors.
1665 #define elf_backend_create_dynamic_sections i370_elf_create_dynamic_sections
1666 #define elf_backend_size_dynamic_sections i370_elf_size_dynamic_sections
1667 #define elf_backend_finish_dynamic_sections i370_elf_finish_dynamic_sections
1668 #define elf_backend_fake_sections i370_elf_fake_sections
1669 #define elf_backend_section_from_shdr i370_elf_section_from_shdr
1670 #define elf_backend_adjust_dynamic_symbol i370_elf_adjust_dynamic_symbol
1671 #define elf_backend_check_relocs i370_elf_check_relocs
1674 #define elf_backend_add_symbol_hook i370_elf_add_symbol_hook
1675 #define elf_backend_finish_dynamic_symbol i370_elf_finish_dynamic_symbol
1676 #define elf_backend_additional_program_headers i370_elf_additional_program_headers
1677 #define elf_backend_modify_segment_map i370_elf_modify_segment_map
1680 #define elf_backend_post_process_headers i370_elf_post_process_headers
1682 static int i370_noop
PARAMS ((void));
1684 static int i370_noop ()
1689 /* we need to define these at least as no-ops to link glibc ld.so */
1691 #define elf_backend_add_symbol_hook \
1692 (boolean (*) PARAMS ((bfd *, struct bfd_link_info *, \
1693 const Elf_Internal_Sym *, const char **, flagword *, \
1694 asection **, bfd_vma *))) i370_noop
1695 #define elf_backend_finish_dynamic_symbol \
1696 (boolean (*) PARAMS ((bfd *, struct bfd_link_info *, \
1697 struct elf_link_hash_entry *, \
1698 Elf_Internal_Sym *))) i370_noop
1699 #define elf_backend_additional_program_headers \
1700 (int (*) PARAMS ((bfd *))) i370_noop
1701 #define elf_backend_modify_segment_map \
1702 (boolean (*) PARAMS ((bfd *))) i370_noop
1704 #include "elf32-target.h"