* Makefile.am (ALL_EMULATIONS): Remove ehppaelf.o.
[binutils.git] / bfd / elf32-i370.c
blob6dc993d26e5e300132421125ba7e5cdadfe21de9
1 /* i370-specific support for 32-bit ELF
2 Copyright 1994, 95, 96, 97, 98, 2000 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 ...
32 #include "bfd.h"
33 #include "sysdep.h"
34 #include "bfdlink.h"
35 #include "libbfd.h"
36 #include "elf-bfd.h"
37 #include "elf/i370.h"
39 #define USE_RELA /* we want RELA relocations, not REL */
41 /* i370 relocations */
42 /* Note that there is really just one relocation that we currently
43 * support (and only one that we seem to need, at the moment), and
44 * that is the 31-bit address relocation. Note that the 370/390
45 * only supports a 31-bit (2GB) address space.
47 enum i370_reloc_type
49 R_I370_NONE = 0,
50 R_I370_ADDR31 = 1,
51 R_I370_ADDR32 = 2,
52 R_I370_ADDR16 = 3,
53 R_I370_REL31 = 4,
54 R_I370_REL32 = 5,
55 R_I370_ADDR12 = 6,
56 R_I370_REL12 = 7,
57 R_I370_ADDR8 = 8,
58 R_I370_REL8 = 9,
59 R_I370_COPY = 10,
60 R_I370_RELATIVE = 11,
62 R_I370_max
66 static reloc_howto_type *i370_elf_howto_table[ (int)R_I370_max ];
68 static reloc_howto_type i370_elf_howto_raw[] =
70 /* This reloc does nothing. */
71 HOWTO (R_I370_NONE, /* type */
72 0, /* rightshift */
73 2, /* size (0 = byte, 1 = short, 2 = long) */
74 32, /* bitsize */
75 false, /* pc_relative */
76 0, /* bitpos */
77 complain_overflow_bitfield, /* complain_on_overflow */
78 bfd_elf_generic_reloc, /* special_function */
79 "R_I370_NONE", /* name */
80 false, /* partial_inplace */
81 0, /* src_mask */
82 0, /* dst_mask */
83 false), /* pcrel_offset */
85 /* A standard 31 bit relocation. */
86 HOWTO (R_I370_ADDR31, /* type */
87 0, /* rightshift */
88 2, /* size (0 = byte, 1 = short, 2 = long) */
89 31, /* bitsize */
90 false, /* pc_relative */
91 0, /* bitpos */
92 complain_overflow_bitfield, /* complain_on_overflow */
93 bfd_elf_generic_reloc, /* special_function */
94 "R_I370_ADDR31", /* name */
95 false, /* partial_inplace */
96 0, /* src_mask */
97 0x7fffffff, /* dst_mask */
98 false), /* pcrel_offset */
100 /* A standard 32 bit relocation. */
101 HOWTO (R_I370_ADDR32, /* type */
102 0, /* rightshift */
103 2, /* size (0 = byte, 1 = short, 2 = long) */
104 32, /* bitsize */
105 false, /* pc_relative */
106 0, /* bitpos */
107 complain_overflow_bitfield, /* complain_on_overflow */
108 bfd_elf_generic_reloc, /* special_function */
109 "R_I370_ADDR32", /* name */
110 false, /* partial_inplace */
111 0, /* src_mask */
112 0xffffffff, /* dst_mask */
113 false), /* pcrel_offset */
115 /* A standard 16 bit relocation. */
116 HOWTO (R_I370_ADDR16, /* type */
117 0, /* rightshift */
118 1, /* size (0 = byte, 1 = short, 2 = long) */
119 16, /* bitsize */
120 false, /* pc_relative */
121 0, /* bitpos */
122 complain_overflow_bitfield, /* complain_on_overflow */
123 bfd_elf_generic_reloc, /* special_function */
124 "R_I370_ADDR16", /* name */
125 false, /* partial_inplace */
126 0, /* src_mask */
127 0xffff, /* dst_mask */
128 false), /* pcrel_offset */
130 /* 31-bit PC relative */
131 HOWTO (R_I370_REL31, /* type */
132 0, /* rightshift */
133 2, /* size (0 = byte, 1 = short, 2 = long) */
134 31, /* bitsize */
135 true, /* pc_relative */
136 0, /* bitpos */
137 complain_overflow_bitfield, /* complain_on_overflow */
138 bfd_elf_generic_reloc, /* special_function */
139 "R_I370_REL31", /* name */
140 false, /* partial_inplace */
141 0, /* src_mask */
142 0x7fffffff, /* dst_mask */
143 true), /* pcrel_offset */
145 /* 32-bit PC relative */
146 HOWTO (R_I370_REL32, /* type */
147 0, /* rightshift */
148 2, /* size (0 = byte, 1 = short, 2 = long) */
149 32, /* bitsize */
150 true, /* pc_relative */
151 0, /* bitpos */
152 complain_overflow_bitfield, /* complain_on_overflow */
153 bfd_elf_generic_reloc, /* special_function */
154 "R_I370_REL32", /* name */
155 false, /* partial_inplace */
156 0, /* src_mask */
157 0xffffffff, /* dst_mask */
158 true), /* pcrel_offset */
160 /* A standard 12 bit relocation. */
161 HOWTO (R_I370_ADDR12, /* type */
162 0, /* rightshift */
163 1, /* size (0 = byte, 1 = short, 2 = long) */
164 12, /* bitsize */
165 false, /* pc_relative */
166 0, /* bitpos */
167 complain_overflow_bitfield, /* complain_on_overflow */
168 bfd_elf_generic_reloc, /* special_function */
169 "R_I370_ADDR12", /* name */
170 false, /* partial_inplace */
171 0, /* src_mask */
172 0xfff, /* dst_mask */
173 false), /* pcrel_offset */
175 /* 12-bit PC relative */
176 HOWTO (R_I370_REL12, /* type */
177 0, /* rightshift */
178 1, /* size (0 = byte, 1 = short, 2 = long) */
179 12, /* bitsize */
180 true, /* pc_relative */
181 0, /* bitpos */
182 complain_overflow_bitfield, /* complain_on_overflow */
183 bfd_elf_generic_reloc, /* special_function */
184 "R_I370_REL12", /* name */
185 false, /* partial_inplace */
186 0, /* src_mask */
187 0xfff, /* dst_mask */
188 true), /* pcrel_offset */
190 /* A standard 8 bit relocation. */
191 HOWTO (R_I370_ADDR8, /* type */
192 0, /* rightshift */
193 0, /* size (0 = byte, 1 = short, 2 = long) */
194 8, /* bitsize */
195 false, /* pc_relative */
196 0, /* bitpos */
197 complain_overflow_bitfield, /* complain_on_overflow */
198 bfd_elf_generic_reloc, /* special_function */
199 "R_I370_ADDR8", /* name */
200 false, /* partial_inplace */
201 0, /* src_mask */
202 0xff, /* dst_mask */
203 false), /* pcrel_offset */
205 /* 8-bit PC relative */
206 HOWTO (R_I370_REL8, /* type */
207 0, /* rightshift */
208 0, /* size (0 = byte, 1 = short, 2 = long) */
209 8, /* bitsize */
210 true, /* pc_relative */
211 0, /* bitpos */
212 complain_overflow_bitfield, /* complain_on_overflow */
213 bfd_elf_generic_reloc, /* special_function */
214 "R_I370_REL8", /* name */
215 false, /* partial_inplace */
216 0, /* src_mask */
217 0xff, /* dst_mask */
218 true), /* pcrel_offset */
220 /* This is used only by the dynamic linker. The symbol should exist
221 both in the object being run and in some shared library. The
222 dynamic linker copies the data addressed by the symbol from the
223 shared library into the object, because the object being
224 run has to have the data at some particular address. */
225 HOWTO (R_I370_COPY, /* type */
226 0, /* rightshift */
227 2, /* size (0 = byte, 1 = short, 2 = long) */
228 32, /* bitsize */
229 false, /* pc_relative */
230 0, /* bitpos */
231 complain_overflow_bitfield, /* complain_on_overflow */
232 bfd_elf_generic_reloc, /* special_function */
233 "R_I370_COPY", /* name */
234 false, /* partial_inplace */
235 0, /* src_mask */
236 0, /* dst_mask */
237 false), /* pcrel_offset */
239 /* Used only by the dynamic linker. When the object is run, this
240 longword is set to the load address of the object, plus the
241 addend. */
242 HOWTO (R_I370_RELATIVE, /* type */
243 0, /* rightshift */
244 2, /* size (0 = byte, 1 = short, 2 = long) */
245 32, /* bitsize */
246 false, /* pc_relative */
247 0, /* bitpos */
248 complain_overflow_bitfield, /* complain_on_overflow */
249 bfd_elf_generic_reloc, /* special_function */
250 "R_I370_RELATIVE", /* name */
251 false, /* partial_inplace */
252 0, /* src_mask */
253 0xffffffff, /* dst_mask */
254 false), /* pcrel_offset */
259 static void i370_elf_howto_init PARAMS ((void));
260 static void i370_elf_info_to_howto PARAMS ((bfd *abfd, arelent *cache_ptr,
261 Elf32_Internal_Rela *dst));
262 static boolean i370_elf_set_private_flags PARAMS ((bfd *, flagword));
265 /* Initialize the i370_elf_howto_table, so that linear accesses can be done. */
267 static void
268 i370_elf_howto_init ()
270 unsigned int i, type;
272 for (i = 0; i < sizeof (i370_elf_howto_raw) / sizeof (i370_elf_howto_raw[0]); i++)
274 type = i370_elf_howto_raw[i].type;
275 BFD_ASSERT (type < sizeof(i370_elf_howto_table) / sizeof(i370_elf_howto_table[0]));
276 i370_elf_howto_table[type] = &i370_elf_howto_raw[i];
281 static reloc_howto_type *
282 i370_elf_reloc_type_lookup (abfd, code)
283 bfd *abfd;
284 bfd_reloc_code_real_type code;
286 enum i370_reloc_type i370_reloc = R_I370_NONE;
288 if (!i370_elf_howto_table[ R_I370_ADDR31 ]) /* Initialize howto table if needed */
289 i370_elf_howto_init ();
291 switch ((int)code)
293 default:
294 return (reloc_howto_type *)NULL;
296 case BFD_RELOC_NONE: i370_reloc = R_I370_NONE; break;
297 case BFD_RELOC_32: i370_reloc = R_I370_ADDR31; break;
298 case BFD_RELOC_16: i370_reloc = R_I370_ADDR16; break;
299 case BFD_RELOC_32_PCREL: i370_reloc = R_I370_REL31; break;
300 case BFD_RELOC_CTOR: i370_reloc = R_I370_ADDR31; break;
301 case BFD_RELOC_I370_D12: i370_reloc = R_I370_ADDR12; break;
304 return i370_elf_howto_table[ (int)i370_reloc ];
307 static boolean i370_elf_copy_private_bfd_data PARAMS ((bfd *, bfd *));
308 static boolean i370_elf_merge_private_bfd_data PARAMS ((bfd *, bfd *));
310 static boolean i370_elf_relocate_section PARAMS ((bfd *,
311 struct bfd_link_info *info,
312 bfd *,
313 asection *,
314 bfd_byte *,
315 Elf_Internal_Rela *relocs,
316 Elf_Internal_Sym *local_syms,
317 asection **));
319 static boolean i370_elf_create_dynamic_sections PARAMS ((bfd *,
320 struct bfd_link_info *));
322 static boolean i370_elf_section_from_shdr PARAMS ((bfd *,
323 Elf32_Internal_Shdr *,
324 char *));
325 static boolean i370_elf_fake_sections PARAMS ((bfd *,
326 Elf32_Internal_Shdr *,
327 asection *));
329 static elf_linker_section_t *i370_elf_create_linker_section
330 PARAMS ((bfd *abfd,
331 struct bfd_link_info *info,
332 enum elf_linker_section_enum));
334 static boolean i370_elf_check_relocs PARAMS ((bfd *,
335 struct bfd_link_info *,
336 asection *,
337 const Elf_Internal_Rela *));
339 static boolean i370_elf_adjust_dynamic_symbol PARAMS ((struct bfd_link_info *,
340 struct elf_link_hash_entry *));
342 static boolean i370_elf_adjust_dynindx PARAMS ((struct elf_link_hash_entry *, PTR));
344 static boolean i370_elf_size_dynamic_sections PARAMS ((bfd *, struct bfd_link_info *));
346 static boolean i370_elf_finish_dynamic_sections PARAMS ((bfd *, struct bfd_link_info *));
348 /* The name of the dynamic interpreter. This is put in the .interp
349 section. */
351 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
354 /* Set the howto pointer for an i370 ELF reloc. */
356 static void
357 i370_elf_info_to_howto (abfd, cache_ptr, dst)
358 bfd *abfd;
359 arelent *cache_ptr;
360 Elf32_Internal_Rela *dst;
362 if (!i370_elf_howto_table[ R_I370_ADDR31 ]) /* Initialize howto table */
363 i370_elf_howto_init ();
365 BFD_ASSERT (ELF32_R_TYPE (dst->r_info) < (unsigned int) R_I370_max);
366 cache_ptr->howto = i370_elf_howto_table[ELF32_R_TYPE (dst->r_info)];
369 /* hack alert -- the following several routines look generic to me ...
370 * why are we bothering with them ???
372 /* Function to set whether a module needs the -mrelocatable bit set. */
373 static boolean
374 i370_elf_set_private_flags (abfd, flags)
375 bfd *abfd;
376 flagword flags;
378 BFD_ASSERT (!elf_flags_init (abfd)
379 || elf_elfheader (abfd)->e_flags == flags);
381 elf_elfheader (abfd)->e_flags = flags;
382 elf_flags_init (abfd) = true;
383 return true;
386 /* Copy backend specific data from one object module to another */
387 static boolean
388 i370_elf_copy_private_bfd_data (ibfd, obfd)
389 bfd *ibfd;
390 bfd *obfd;
392 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
393 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
394 return true;
396 BFD_ASSERT (!elf_flags_init (obfd)
397 || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
399 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
400 elf_flags_init (obfd) = true;
401 return true;
404 /* Merge backend specific data from an object file to the output
405 object file when linking */
406 static boolean
407 i370_elf_merge_private_bfd_data (ibfd, obfd)
408 bfd *ibfd;
409 bfd *obfd;
411 flagword old_flags;
412 flagword new_flags;
414 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
415 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
416 return true;
418 new_flags = elf_elfheader (ibfd)->e_flags;
419 old_flags = elf_elfheader (obfd)->e_flags;
420 if (!elf_flags_init (obfd)) /* First call, no flags set */
422 elf_flags_init (obfd) = true;
423 elf_elfheader (obfd)->e_flags = new_flags;
426 else if (new_flags == old_flags) /* Compatible flags are ok */
429 else /* Incompatible flags */
431 (*_bfd_error_handler)
432 ("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)",
433 bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
435 bfd_set_error (bfd_error_bad_value);
436 return false;
439 return true;
443 /* Handle an i370 specific section when reading an object file. This
444 is called when elfcode.h finds a section with an unknown type. */
445 /* XXX hack alert bogus This routine is mostly all junk and almost
446 * certainly does the wrong thing. Its here simply because it does
447 * just enough to allow glibc-2.1 ld.so to compile & link.
450 static boolean
451 i370_elf_section_from_shdr (abfd, hdr, name)
452 bfd *abfd;
453 Elf32_Internal_Shdr *hdr;
454 char *name;
456 asection *newsect;
457 flagword flags;
459 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
460 return false;
462 newsect = hdr->bfd_section;
463 flags = bfd_get_section_flags (abfd, newsect);
464 if (hdr->sh_flags & SHF_EXCLUDE)
465 flags |= SEC_EXCLUDE;
467 if (hdr->sh_type == SHT_ORDERED)
468 flags |= SEC_SORT_ENTRIES;
470 bfd_set_section_flags (abfd, newsect, flags);
471 return true;
476 /* Set up any other section flags and such that may be necessary. */
477 /* XXX hack alert bogus This routine is mostly all junk and almost
478 * certainly does the wrong thing. Its here simply because it does
479 * just enough to allow glibc-2.1 ld.so to compile & link.
483 static boolean
484 i370_elf_fake_sections (abfd, shdr, asect)
485 bfd *abfd;
486 Elf32_Internal_Shdr *shdr;
487 asection *asect;
489 if ((asect->flags & SEC_EXCLUDE) != 0)
490 shdr->sh_flags |= SHF_EXCLUDE;
492 if ((asect->flags & SEC_SORT_ENTRIES) != 0)
493 shdr->sh_type = SHT_ORDERED;
495 return true;
499 /* Create a special linker section */
500 /* XXX hack alert bogus This routine is mostly all junk and almost
501 * certainly does the wrong thing. Its here simply because it does
502 * just enough to allow glibc-2.1 ld.so to compile & link.
505 static elf_linker_section_t *
506 i370_elf_create_linker_section (abfd, info, which)
507 bfd *abfd;
508 struct bfd_link_info *info;
509 enum elf_linker_section_enum which;
511 bfd *dynobj = elf_hash_table (info)->dynobj;
512 elf_linker_section_t *lsect;
514 /* Record the first bfd section that needs the special section */
515 if (!dynobj)
516 dynobj = elf_hash_table (info)->dynobj = abfd;
518 /* If this is the first time, create the section */
519 lsect = elf_linker_section (dynobj, which);
520 if (!lsect)
522 elf_linker_section_t defaults;
523 static elf_linker_section_t zero_section;
525 defaults = zero_section;
526 defaults.which = which;
527 defaults.hole_written_p = false;
528 defaults.alignment = 2;
530 /* Both of these sections are (technically) created by the user
531 putting data in them, so they shouldn't be marked
532 SEC_LINKER_CREATED.
534 The linker creates them so it has somewhere to attach their
535 respective symbols. In fact, if they were empty it would
536 be OK to leave the symbol set to 0 (or any random number), because
537 the appropriate register should never be used. */
538 defaults.flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
539 | SEC_IN_MEMORY);
541 switch (which)
543 default:
544 (*_bfd_error_handler) ("%s: Unknown special linker type %d",
545 bfd_get_filename (abfd),
546 (int)which);
548 bfd_set_error (bfd_error_bad_value);
549 return (elf_linker_section_t *)0;
551 case LINKER_SECTION_SDATA: /* .sdata/.sbss section */
552 defaults.name = ".sdata";
553 defaults.rel_name = ".rela.sdata";
554 defaults.bss_name = ".sbss";
555 defaults.sym_name = "_SDA_BASE_";
556 defaults.sym_offset = 32768;
557 break;
559 case LINKER_SECTION_SDATA2: /* .sdata2/.sbss2 section */
560 defaults.name = ".sdata2";
561 defaults.rel_name = ".rela.sdata2";
562 defaults.bss_name = ".sbss2";
563 defaults.sym_name = "_SDA2_BASE_";
564 defaults.sym_offset = 32768;
565 defaults.flags |= SEC_READONLY;
566 break;
569 lsect = _bfd_elf_create_linker_section (abfd, info, which, &defaults);
572 return lsect;
576 /* We have to create .dynsbss and .rela.sbss here so that they get mapped
577 to output sections (just like _bfd_elf_create_dynamic_sections has
578 to create .dynbss and .rela.bss). */
579 /* XXX hack alert bogus This routine is mostly all junk and almost
580 * certainly does the wrong thing. Its here simply because it does
581 * just enough to allow glibc-2.1 ld.so to compile & link.
584 static boolean
585 i370_elf_create_dynamic_sections (abfd, info)
586 bfd *abfd;
587 struct bfd_link_info *info;
589 register asection *s;
590 flagword flags;
592 if (!_bfd_elf_create_dynamic_sections(abfd, info))
593 return false;
595 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
596 | SEC_LINKER_CREATED);
598 s = bfd_make_section (abfd, ".dynsbss");
599 if (s == NULL
600 || ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
601 return false;
603 if (! info->shared)
605 s = bfd_make_section (abfd, ".rela.sbss");
606 if (s == NULL
607 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
608 || ! bfd_set_section_alignment (abfd, s, 2))
609 return false;
612 /* xxx beats me, seem to need a rela.text ... */
613 s = bfd_make_section (abfd, ".rela.text");
614 if (s == NULL
615 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
616 || ! bfd_set_section_alignment (abfd, s, 2))
617 return false;
618 return true;
621 /* Adjust a symbol defined by a dynamic object and referenced by a
622 regular object. The current definition is in some section of the
623 dynamic object, but we're not including those sections. We have to
624 change the definition to something the rest of the link can
625 understand. */
626 /* XXX hack alert bogus This routine is mostly all junk and almost
627 * certainly does the wrong thing. Its here simply because it does
628 * just enough to allow glibc-2.1 ld.so to compile & link.
631 static boolean
632 i370_elf_adjust_dynamic_symbol (info, h)
633 struct bfd_link_info *info;
634 struct elf_link_hash_entry *h;
636 bfd *dynobj = elf_hash_table (info)->dynobj;
637 asection *s;
638 unsigned int power_of_two;
639 bfd_vma plt_offset;
641 #ifdef DEBUG
642 fprintf (stderr, "i370_elf_adjust_dynamic_symbol called for %s\n",
643 h->root.root.string);
644 #endif
646 /* Make sure we know what is going on here. */
647 BFD_ASSERT (dynobj != NULL
648 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
649 || h->weakdef != NULL
650 || ((h->elf_link_hash_flags
651 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
652 && (h->elf_link_hash_flags
653 & ELF_LINK_HASH_REF_REGULAR) != 0
654 && (h->elf_link_hash_flags
655 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
658 s = bfd_get_section_by_name (dynobj, ".rela.text");
659 BFD_ASSERT (s != NULL);
660 s->_raw_size += sizeof (Elf32_External_Rela);
662 /* If this is a weak symbol, and there is a real definition, the
663 processor independent code will have arranged for us to see the
664 real definition first, and we can just use the same value. */
665 if (h->weakdef != NULL)
667 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
668 || h->weakdef->root.type == bfd_link_hash_defweak);
669 h->root.u.def.section = h->weakdef->root.u.def.section;
670 h->root.u.def.value = h->weakdef->root.u.def.value;
671 return true;
674 /* This is a reference to a symbol defined by a dynamic object which
675 is not a function. */
677 /* If we are creating a shared library, we must presume that the
678 only references to the symbol are via the global offset table.
679 For such cases we need not do anything here; the relocations will
680 be handled correctly by relocate_section. */
681 if (info->shared)
682 return true;
684 /* We must allocate the symbol in our .dynbss section, which will
685 become part of the .bss section of the executable. There will be
686 an entry for this symbol in the .dynsym section. The dynamic
687 object will contain position independent code, so all references
688 from the dynamic object to this symbol will go through the global
689 offset table. The dynamic linker will use the .dynsym entry to
690 determine the address it must put in the global offset table, so
691 both the dynamic object and the regular object will refer to the
692 same memory location for the variable.
694 Of course, if the symbol is sufficiently small, we must instead
695 allocate it in .sbss. FIXME: It would be better to do this if and
696 only if there were actually SDAREL relocs for that symbol. */
698 if (h->size <= elf_gp_size (dynobj))
699 s = bfd_get_section_by_name (dynobj, ".dynsbss");
700 else
701 s = bfd_get_section_by_name (dynobj, ".dynbss");
702 BFD_ASSERT (s != NULL);
704 /* We must generate a R_I370_COPY reloc to tell the dynamic linker to
705 copy the initial value out of the dynamic object and into the
706 runtime process image. We need to remember the offset into the
707 .rela.bss section we are going to use. */
708 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
710 asection *srel;
712 if (h->size <= elf_gp_size (dynobj))
713 srel = bfd_get_section_by_name (dynobj, ".rela.sbss");
714 else
715 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
716 BFD_ASSERT (srel != NULL);
717 srel->_raw_size += sizeof (Elf32_External_Rela);
718 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
721 /* We need to figure out the alignment required for this symbol. I
722 have no idea how ELF linkers handle this. */
723 power_of_two = bfd_log2 (h->size);
724 if (power_of_two > 4)
725 power_of_two = 4;
727 /* Apply the required alignment. */
728 s->_raw_size = BFD_ALIGN (s->_raw_size,
729 (bfd_size_type) (1 << power_of_two));
730 if (power_of_two > bfd_get_section_alignment (dynobj, s))
732 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
733 return false;
736 /* Define the symbol as being at this point in the section. */
737 h->root.u.def.section = s;
738 h->root.u.def.value = s->_raw_size;
740 /* Increment the section size to make room for the symbol. */
741 s->_raw_size += h->size;
743 return true;
747 /* Increment the index of a dynamic symbol by a given amount. Called
748 via elf_link_hash_traverse. */
749 /* XXX hack alert bogus This routine is mostly all junk and almost
750 * certainly does the wrong thing. Its here simply because it does
751 * just enough to allow glibc-2.1 ld.so to compile & link.
754 static boolean
755 i370_elf_adjust_dynindx (h, cparg)
756 struct elf_link_hash_entry *h;
757 PTR cparg;
759 int *cp = (int *) cparg;
761 #ifdef DEBUG
762 fprintf (stderr,
763 "i370_elf_adjust_dynindx called, h->dynindx = %d, *cp = %d\n",
764 h->dynindx, *cp);
765 #endif
767 if (h->dynindx != -1)
768 h->dynindx += *cp;
770 return true;
774 /* Set the sizes of the dynamic sections. */
775 /* XXX hack alert bogus This routine is mostly all junk and almost
776 * certainly does the wrong thing. Its here simply because it does
777 * just enough to allow glibc-2.1 ld.so to compile & link.
780 static boolean
781 i370_elf_size_dynamic_sections (output_bfd, info)
782 bfd *output_bfd;
783 struct bfd_link_info *info;
785 bfd *dynobj;
786 asection *s;
787 boolean plt;
788 boolean relocs;
789 boolean reltext;
791 #ifdef DEBUG
792 fprintf (stderr, "i370_elf_size_dynamic_sections called\n");
793 #endif
795 dynobj = elf_hash_table (info)->dynobj;
796 BFD_ASSERT (dynobj != NULL);
798 if (elf_hash_table (info)->dynamic_sections_created)
800 /* Set the contents of the .interp section to the interpreter. */
801 if (! info->shared)
803 s = bfd_get_section_by_name (dynobj, ".interp");
804 BFD_ASSERT (s != NULL);
805 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
806 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
809 else
811 /* We may have created entries in the .rela.got, .rela.sdata, and
812 .rela.sdata2 sections. However, if we are not creating the
813 dynamic sections, we will not actually use these entries. Reset
814 the size of .rela.got, et al, which will cause it to get
815 stripped from the output file below. */
816 static char *rela_sections[] = { ".rela.got", ".rela.sdata",
817 ".rela.sdata2", ".rela.sbss",
818 (char *)0 };
819 char **p;
821 for (p = rela_sections; *p != (char *)0; p++)
823 s = bfd_get_section_by_name (dynobj, *p);
824 if (s != NULL)
825 s->_raw_size = 0;
829 /* The check_relocs and adjust_dynamic_symbol entry points have
830 determined the sizes of the various dynamic sections. Allocate
831 memory for them. */
832 plt = false;
833 relocs = false;
834 reltext = false;
835 for (s = dynobj->sections; s != NULL; s = s->next)
837 const char *name;
838 boolean strip;
840 if ((s->flags & SEC_LINKER_CREATED) == 0)
841 continue;
843 /* It's OK to base decisions on the section name, because none
844 of the dynobj section names depend upon the input files. */
845 name = bfd_get_section_name (dynobj, s);
846 strip = false;
848 if (strcmp (name, ".plt") == 0)
850 if (s->_raw_size == 0)
852 /* Strip this section if we don't need it; see the
853 comment below. */
854 strip = true;
856 else
858 /* Remember whether there is a PLT. */
859 plt = true;
862 else if (strncmp (name, ".rela", 5) == 0)
864 if (s->_raw_size == 0)
866 /* If we don't need this section, strip it from the
867 output file. This is mostly to handle .rela.bss and
868 .rela.plt. We must create both sections in
869 create_dynamic_sections, because they must be created
870 before the linker maps input sections to output
871 sections. The linker does that before
872 adjust_dynamic_symbol is called, and it is that
873 function which decides whether anything needs to go
874 into these sections. */
875 strip = true;
877 else
879 asection *target;
880 const char *outname;
882 /* Remember whether there are any relocation sections. */
883 relocs = true;
885 /* If this relocation section applies to a read only
886 section, then we probably need a DT_TEXTREL entry. */
887 outname = bfd_get_section_name (output_bfd,
888 s->output_section);
889 target = bfd_get_section_by_name (output_bfd, outname + 5);
890 if (target != NULL
891 && (target->flags & SEC_READONLY) != 0
892 && (target->flags & SEC_ALLOC) != 0)
893 reltext = true;
895 /* We use the reloc_count field as a counter if we need
896 to copy relocs into the output file. */
897 s->reloc_count = 0;
900 else if (strcmp (name, ".got") != 0
901 && strcmp (name, ".sdata") != 0
902 && strcmp (name, ".sdata2") != 0)
904 /* It's not one of our sections, so don't allocate space. */
905 continue;
908 if (strip)
910 asection **spp;
912 for (spp = &s->output_section->owner->sections;
913 *spp != s->output_section;
914 spp = &(*spp)->next)
916 *spp = s->output_section->next;
917 --s->output_section->owner->section_count;
919 continue;
921 /* Allocate memory for the section contents. */
922 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
923 if (s->contents == NULL && s->_raw_size != 0)
924 return false;
927 if (elf_hash_table (info)->dynamic_sections_created)
929 /* Add some entries to the .dynamic section. We fill in the
930 values later, in i370_elf_finish_dynamic_sections, but we
931 must add the entries now so that we get the correct size for
932 the .dynamic section. The DT_DEBUG entry is filled in by the
933 dynamic linker and used by the debugger. */
934 if (! info->shared)
936 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
937 return false;
940 if (plt)
942 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
943 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
944 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
945 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
946 return false;
949 if (relocs)
951 if (! bfd_elf32_add_dynamic_entry (info, DT_RELA, 0)
952 || ! bfd_elf32_add_dynamic_entry (info, DT_RELASZ, 0)
953 || ! bfd_elf32_add_dynamic_entry (info, DT_RELAENT,
954 sizeof (Elf32_External_Rela)))
955 return false;
958 if (reltext)
960 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
961 return false;
965 /* If we are generating a shared library, we generate a section
966 symbol for each output section. These are local symbols, which
967 means that they must come first in the dynamic symbol table.
968 That means we must increment the dynamic symbol index of every
969 other dynamic symbol.
971 FIXME: We assume that there will never be relocations to
972 locations in linker-created sections that do not have
973 externally-visible names. Instead, we should work out precisely
974 which sections relocations are targetted at. */
975 if (info->shared)
977 int c;
979 for (c = 0, s = output_bfd->sections; s != NULL; s = s->next)
981 if ((s->flags & SEC_LINKER_CREATED) != 0
982 || (s->flags & SEC_ALLOC) == 0)
984 elf_section_data (s)->dynindx = -1;
985 continue;
988 /* These symbols will have no names, so we don't need to
989 fiddle with dynstr_index. */
991 elf_section_data (s)->dynindx = c + 1;
993 c++;
996 elf_link_hash_traverse (elf_hash_table (info),
997 i370_elf_adjust_dynindx,
998 (PTR) &c);
999 elf_hash_table (info)->dynsymcount += c;
1002 return true;
1006 /* Look through the relocs for a section during the first phase, and
1007 allocate space in the global offset table or procedure linkage
1008 table. */
1009 /* XXX hack alert bogus This routine is mostly all junk and almost
1010 * certainly does the wrong thing. Its here simply because it does
1011 * just enough to allow glibc-2.1 ld.so to compile & link.
1014 static boolean
1015 i370_elf_check_relocs (abfd, info, sec, relocs)
1016 bfd *abfd;
1017 struct bfd_link_info *info;
1018 asection *sec;
1019 const Elf_Internal_Rela *relocs;
1021 bfd *dynobj;
1022 Elf_Internal_Shdr *symtab_hdr;
1023 struct elf_link_hash_entry **sym_hashes;
1024 const Elf_Internal_Rela *rel;
1025 const Elf_Internal_Rela *rel_end;
1026 bfd_vma *local_got_offsets;
1027 elf_linker_section_t *sdata;
1028 elf_linker_section_t *sdata2;
1029 asection *sreloc;
1030 asection *sgot;
1031 asection *srelgot = NULL;
1033 if (info->relocateable)
1034 return true;
1036 #ifdef DEBUG
1037 fprintf (stderr, "i370_elf_check_relocs called for section %s in %s\n",
1038 bfd_get_section_name (abfd, sec),
1039 bfd_get_filename (abfd));
1040 #endif
1042 dynobj = elf_hash_table (info)->dynobj;
1043 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1044 sym_hashes = elf_sym_hashes (abfd);
1045 local_got_offsets = elf_local_got_offsets (abfd);
1047 sreloc = NULL;
1049 rel_end = relocs + sec->reloc_count;
1050 for (rel = relocs; rel < rel_end; rel++)
1052 unsigned long r_symndx;
1053 struct elf_link_hash_entry *h;
1055 r_symndx = ELF32_R_SYM (rel->r_info);
1056 if (r_symndx < symtab_hdr->sh_info)
1057 h = NULL;
1058 else
1059 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1061 if (info->shared)
1063 #ifdef DEBUG
1064 fprintf (stderr,
1065 "i370_elf_check_relocs needs to create relocation for %s\n",
1066 (h && h->root.root.string)
1067 ? h->root.root.string : "<unknown>");
1068 #endif
1069 if (sreloc == NULL)
1071 const char *name;
1073 name = (bfd_elf_string_from_elf_section
1074 (abfd,
1075 elf_elfheader (abfd)->e_shstrndx,
1076 elf_section_data (sec)->rel_hdr.sh_name));
1077 if (name == NULL)
1078 return false;
1080 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1081 && strcmp (bfd_get_section_name (abfd, sec), name + 5) == 0);
1083 sreloc = bfd_get_section_by_name (dynobj, name);
1084 if (sreloc == NULL)
1086 flagword flags;
1088 sreloc = bfd_make_section (dynobj, name);
1089 flags = (SEC_HAS_CONTENTS | SEC_READONLY
1090 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1091 if ((sec->flags & SEC_ALLOC) != 0)
1092 flags |= SEC_ALLOC | SEC_LOAD;
1093 if (sreloc == NULL
1094 || ! bfd_set_section_flags (dynobj, sreloc, flags)
1095 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
1096 return false;
1100 sreloc->_raw_size += sizeof (Elf32_External_Rela);
1102 /* FIXME: We should here do what the m68k and i386
1103 backends do: if the reloc is pc-relative, record it
1104 in case it turns out that the reloc is unnecessary
1105 because the symbol is forced local by versioning or
1106 we are linking with -Bdynamic. Fortunately this
1107 case is not frequent. */
1111 return true;
1115 /* Finish up the dynamic sections. */
1116 /* XXX hack alert bogus This routine is mostly all junk and almost
1117 * certainly does the wrong thing. Its here simply because it does
1118 * just enough to allow glibc-2.1 ld.so to compile & link.
1121 static boolean
1122 i370_elf_finish_dynamic_sections (output_bfd, info)
1123 bfd *output_bfd;
1124 struct bfd_link_info *info;
1126 asection *sdyn;
1127 bfd *dynobj = elf_hash_table (info)->dynobj;
1128 asection *sgot = bfd_get_section_by_name (dynobj, ".got");
1130 #ifdef DEBUG
1131 fprintf (stderr, "i370_elf_finish_dynamic_sections called\n");
1132 #endif
1134 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1136 if (elf_hash_table (info)->dynamic_sections_created)
1138 asection *splt;
1139 Elf32_External_Dyn *dyncon, *dynconend;
1141 splt = bfd_get_section_by_name (dynobj, ".plt");
1142 BFD_ASSERT (splt != NULL && sdyn != NULL);
1144 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1145 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1146 for (; dyncon < dynconend; dyncon++)
1148 Elf_Internal_Dyn dyn;
1149 const char *name;
1150 boolean size;
1152 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1154 switch (dyn.d_tag)
1156 case DT_PLTGOT: name = ".plt"; size = false; break;
1157 case DT_PLTRELSZ: name = ".rela.plt"; size = true; break;
1158 case DT_JMPREL: name = ".rela.plt"; size = false; break;
1159 default: name = NULL; size = false; break;
1162 if (name != NULL)
1164 asection *s;
1166 s = bfd_get_section_by_name (output_bfd, name);
1167 if (s == NULL)
1168 dyn.d_un.d_val = 0;
1169 else
1171 if (! size)
1172 dyn.d_un.d_ptr = s->vma;
1173 else
1175 if (s->_cooked_size != 0)
1176 dyn.d_un.d_val = s->_cooked_size;
1177 else
1178 dyn.d_un.d_val = s->_raw_size;
1181 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1186 /* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4 so that a function can
1187 easily find the address of the _GLOBAL_OFFSET_TABLE_. */
1188 /* XXX this is clearly very wrong for the 370 arch */
1189 if (sgot)
1191 unsigned char *contents = sgot->contents;
1192 bfd_put_32 (output_bfd, 0x4e800021 /* blrl */, contents);
1194 if (sdyn == NULL)
1195 bfd_put_32 (output_bfd, (bfd_vma) 0, contents+4);
1196 else
1197 bfd_put_32 (output_bfd,
1198 sdyn->output_section->vma + sdyn->output_offset,
1199 contents+4);
1201 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1204 if (info->shared)
1206 asection *sdynsym;
1207 asection *s;
1208 Elf_Internal_Sym sym;
1209 int maxdindx = 0;
1211 /* Set up the section symbols for the output sections. */
1213 sdynsym = bfd_get_section_by_name (dynobj, ".dynsym");
1214 BFD_ASSERT (sdynsym != NULL);
1216 sym.st_size = 0;
1217 sym.st_name = 0;
1218 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
1219 sym.st_other = 0;
1221 for (s = output_bfd->sections; s != NULL; s = s->next)
1223 int indx, dindx;
1225 sym.st_value = s->vma;
1227 indx = elf_section_data (s)->this_idx;
1228 dindx = elf_section_data (s)->dynindx;
1229 if (dindx != -1)
1231 BFD_ASSERT(indx > 0);
1232 BFD_ASSERT(dindx > 0);
1234 if (dindx > maxdindx)
1235 maxdindx = dindx;
1237 sym.st_shndx = indx;
1239 bfd_elf32_swap_symbol_out (output_bfd, &sym,
1240 (PTR) (((Elf32_External_Sym *)
1241 sdynsym->contents)
1242 + dindx));
1246 /* Set the sh_info field of the output .dynsym section to the
1247 index of the first global symbol. */
1248 elf_section_data (sdynsym->output_section)->this_hdr.sh_info =
1249 maxdindx + 1;
1252 return true;
1256 /* The RELOCATE_SECTION function is called by the ELF backend linker
1257 to handle the relocations for a section.
1259 The relocs are always passed as Rela structures; if the section
1260 actually uses Rel structures, the r_addend field will always be
1261 zero.
1263 This function is responsible for adjust the section contents as
1264 necessary, and (if using Rela relocs and generating a
1265 relocateable output file) adjusting the reloc addend as
1266 necessary.
1268 This function does not have to worry about setting the reloc
1269 address or the reloc symbol index.
1271 LOCAL_SYMS is a pointer to the swapped in local symbols.
1273 LOCAL_SECTIONS is an array giving the section in the input file
1274 corresponding to the st_shndx field of each local symbol.
1276 The global hash table entry for the global symbols can be found
1277 via elf_sym_hashes (input_bfd).
1279 When generating relocateable output, this function must handle
1280 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1281 going to be the section symbol corresponding to the output
1282 section, which means that the addend must be adjusted
1283 accordingly. */
1285 static boolean
1286 i370_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1287 contents, relocs, local_syms, local_sections)
1288 bfd *output_bfd;
1289 struct bfd_link_info *info;
1290 bfd *input_bfd;
1291 asection *input_section;
1292 bfd_byte *contents;
1293 Elf_Internal_Rela *relocs;
1294 Elf_Internal_Sym *local_syms;
1295 asection **local_sections;
1297 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1298 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
1299 bfd *dynobj = elf_hash_table (info)->dynobj;
1300 Elf_Internal_Rela *rel = relocs;
1301 Elf_Internal_Rela *relend = relocs + input_section->reloc_count;
1302 asection *sreloc = NULL;
1303 bfd_vma *local_got_offsets;
1304 boolean ret = true;
1306 #ifdef DEBUG
1307 fprintf (stderr, "i370_elf_relocate_section called for %s section %s, %ld relocations%s\n",
1308 bfd_get_filename (input_bfd),
1309 bfd_section_name(input_bfd, input_section),
1310 (long)input_section->reloc_count,
1311 (info->relocateable) ? " (relocatable)" : "");
1312 #endif
1314 if (!i370_elf_howto_table[ R_I370_ADDR31 ]) /* Initialize howto table if needed */
1315 i370_elf_howto_init ();
1317 local_got_offsets = elf_local_got_offsets (input_bfd);
1319 for (; rel < relend; rel++)
1321 enum i370_reloc_type r_type = (enum i370_reloc_type)ELF32_R_TYPE (rel->r_info);
1322 bfd_vma offset = rel->r_offset;
1323 bfd_vma addend = rel->r_addend;
1324 bfd_reloc_status_type r = bfd_reloc_other;
1325 Elf_Internal_Sym *sym = (Elf_Internal_Sym *)0;
1326 asection *sec = (asection *)0;
1327 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *)0;
1328 const char *sym_name = (const char *)0;
1329 reloc_howto_type *howto;
1330 unsigned long r_symndx;
1331 bfd_vma relocation;
1333 /* Unknown relocation handling */
1334 if ((unsigned)r_type >= (unsigned)R_I370_max
1335 || !i370_elf_howto_table[(int)r_type])
1337 (*_bfd_error_handler) ("%s: unknown relocation type %d",
1338 bfd_get_filename (input_bfd),
1339 (int)r_type);
1341 bfd_set_error (bfd_error_bad_value);
1342 ret = false;
1343 continue;
1346 howto = i370_elf_howto_table[(int)r_type];
1347 r_symndx = ELF32_R_SYM (rel->r_info);
1349 if (info->relocateable)
1351 /* This is a relocateable link. We don't have to change
1352 anything, unless the reloc is against a section symbol,
1353 in which case we have to adjust according to where the
1354 section symbol winds up in the output section. */
1355 if (r_symndx < symtab_hdr->sh_info)
1357 sym = local_syms + r_symndx;
1358 if ((unsigned)ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1360 sec = local_sections[r_symndx];
1361 addend = rel->r_addend += sec->output_offset + sym->st_value;
1365 #ifdef DEBUG
1366 fprintf (stderr, "\ttype = %s (%d), symbol index = %ld, offset = %ld, addend = %ld\n",
1367 howto->name,
1368 (int)r_type,
1369 r_symndx,
1370 (long)offset,
1371 (long)addend);
1372 #endif
1373 continue;
1376 /* This is a final link. */
1377 if (r_symndx < symtab_hdr->sh_info)
1379 sym = local_syms + r_symndx;
1380 sec = local_sections[r_symndx];
1381 sym_name = "<local symbol>";
1383 relocation = (sec->output_section->vma
1384 + sec->output_offset
1385 + sym->st_value);
1387 else
1389 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1390 while (h->root.type == bfd_link_hash_indirect
1391 || h->root.type == bfd_link_hash_warning)
1392 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1393 sym_name = h->root.root.string;
1394 if (h->root.type == bfd_link_hash_defined
1395 || h->root.type == bfd_link_hash_defweak)
1397 sec = h->root.u.def.section;
1398 if (info->shared
1399 && ((! info->symbolic && h->dynindx != -1)
1400 || (h->elf_link_hash_flags
1401 & ELF_LINK_HASH_DEF_REGULAR) == 0)
1402 && (input_section->flags & SEC_ALLOC) != 0
1403 && (r_type == R_I370_ADDR31
1404 || r_type == R_I370_COPY
1405 || r_type == R_I370_ADDR16
1406 || r_type == R_I370_RELATIVE))
1408 /* In these cases, we don't need the relocation
1409 value. We check specially because in some
1410 obscure cases sec->output_section will be NULL. */
1411 relocation = 0;
1413 else
1414 relocation = (h->root.u.def.value
1415 + sec->output_section->vma
1416 + sec->output_offset);
1418 else if (h->root.type == bfd_link_hash_undefweak)
1419 relocation = 0;
1420 else if (info->shared)
1421 relocation = 0;
1422 else
1424 (*info->callbacks->undefined_symbol)(info,
1425 h->root.root.string,
1426 input_bfd,
1427 input_section,
1428 rel->r_offset);
1429 ret = false;
1430 continue;
1434 switch ((int)r_type)
1436 default:
1437 (*_bfd_error_handler) ("%s: unknown relocation type %d for symbol %s",
1438 bfd_get_filename (input_bfd),
1439 (int)r_type, sym_name);
1441 bfd_set_error (bfd_error_bad_value);
1442 ret = false;
1443 continue;
1445 /* Relocations that may need to be propagated if this is a shared
1446 object. */
1447 case (int)R_I370_REL31:
1448 /* If these relocations are not to a named symbol, they can be
1449 handled right here, no need to bother the dynamic linker. */
1450 if (h == NULL
1451 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1452 break;
1453 /* fall through */
1455 /* Relocations that always need to be propagated if this is a shared
1456 object. */
1457 case (int)R_I370_NONE:
1458 case (int)R_I370_ADDR31:
1459 case (int)R_I370_ADDR16:
1460 if (info->shared)
1462 Elf_Internal_Rela outrel;
1463 boolean skip;
1465 #ifdef DEBUG
1466 fprintf (stderr,
1467 "i370_elf_relocate_section needs to create relocation for %s\n",
1468 (h && h->root.root.string) ? h->root.root.string : "<unknown>");
1469 #endif
1471 /* When generating a shared object, these relocations
1472 are copied into the output file to be resolved at run
1473 time. */
1475 if (sreloc == NULL)
1477 const char *name;
1479 name = (bfd_elf_string_from_elf_section
1480 (input_bfd,
1481 elf_elfheader (input_bfd)->e_shstrndx,
1482 elf_section_data (input_section)->rel_hdr.sh_name));
1483 if (name == NULL)
1484 return false;
1486 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1487 && strcmp (bfd_get_section_name (input_bfd,
1488 input_section),
1489 name + 5) == 0);
1491 sreloc = bfd_get_section_by_name (dynobj, name);
1492 BFD_ASSERT (sreloc != NULL);
1495 skip = false;
1497 if (elf_section_data (input_section)->stab_info == NULL)
1498 outrel.r_offset = rel->r_offset;
1499 else
1501 bfd_vma off;
1503 off = (_bfd_stab_section_offset
1504 (output_bfd, &elf_hash_table (info)->stab_info,
1505 input_section,
1506 &elf_section_data (input_section)->stab_info,
1507 rel->r_offset));
1508 if (off == (bfd_vma) -1)
1509 skip = true;
1510 outrel.r_offset = off;
1513 outrel.r_offset += (input_section->output_section->vma
1514 + input_section->output_offset);
1516 if (skip)
1517 memset (&outrel, 0, sizeof outrel);
1518 /* h->dynindx may be -1 if this symbol was marked to
1519 become local. */
1520 else if (h != NULL
1521 && ((! info->symbolic && h->dynindx != -1)
1522 || (h->elf_link_hash_flags
1523 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1525 BFD_ASSERT (h->dynindx != -1);
1526 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1527 outrel.r_addend = rel->r_addend;
1529 else
1531 if (r_type == R_I370_ADDR31)
1533 outrel.r_info = ELF32_R_INFO (0, R_I370_RELATIVE);
1534 outrel.r_addend = relocation + rel->r_addend;
1536 else
1538 long indx;
1540 if (h == NULL)
1541 sec = local_sections[r_symndx];
1542 else
1544 BFD_ASSERT (h->root.type == bfd_link_hash_defined
1545 || (h->root.type
1546 == bfd_link_hash_defweak));
1547 sec = h->root.u.def.section;
1549 if (sec != NULL && bfd_is_abs_section (sec))
1550 indx = 0;
1551 else if (sec == NULL || sec->owner == NULL)
1553 bfd_set_error (bfd_error_bad_value);
1554 return false;
1556 else
1558 asection *osec;
1560 osec = sec->output_section;
1561 indx = elf_section_data (osec)->dynindx;
1562 BFD_ASSERT(indx > 0);
1563 #ifdef DEBUG
1564 if (indx <= 0)
1566 printf("indx=%d section=%s flags=%08x name=%s\n",
1567 indx, osec->name, osec->flags,
1568 h->root.root.string);
1570 #endif
1573 outrel.r_info = ELF32_R_INFO (indx, r_type);
1574 outrel.r_addend = relocation + rel->r_addend;
1578 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1579 (((Elf32_External_Rela *)
1580 sreloc->contents)
1581 + sreloc->reloc_count));
1582 ++sreloc->reloc_count;
1584 /* This reloc will be computed at runtime, so there's no
1585 need to do anything now, unless this is a RELATIVE
1586 reloc in an unallocated section. */
1587 if (skip
1588 || (input_section->flags & SEC_ALLOC) != 0
1589 || ELF32_R_TYPE (outrel.r_info) != R_I370_RELATIVE)
1590 continue;
1592 break;
1594 case (int)R_I370_COPY:
1595 case (int)R_I370_RELATIVE:
1596 (*_bfd_error_handler) ("%s: Relocation %s is not yet supported for symbol %s.",
1597 bfd_get_filename (input_bfd),
1598 i370_elf_howto_table[ (int)r_type ]->name,
1599 sym_name);
1601 bfd_set_error (bfd_error_invalid_operation);
1602 ret = false;
1603 continue;
1607 #ifdef DEBUG
1608 fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, offset = %ld, addend = %ld\n",
1609 howto->name,
1610 (int)r_type,
1611 sym_name,
1612 r_symndx,
1613 (long)offset,
1614 (long)addend);
1615 #endif
1617 r = _bfd_final_link_relocate (howto,
1618 input_bfd,
1619 input_section,
1620 contents,
1621 offset,
1622 relocation,
1623 addend);
1625 if (r != bfd_reloc_ok)
1627 ret = false;
1628 switch (r)
1630 default:
1631 break;
1633 case bfd_reloc_overflow:
1635 const char *name;
1637 if (h != NULL)
1638 name = h->root.root.string;
1639 else
1641 name = bfd_elf_string_from_elf_section (input_bfd,
1642 symtab_hdr->sh_link,
1643 sym->st_name);
1644 if (name == NULL)
1645 break;
1647 if (*name == '\0')
1648 name = bfd_section_name (input_bfd, sec);
1651 (*info->callbacks->reloc_overflow)(info,
1652 name,
1653 howto->name,
1654 (bfd_vma) 0,
1655 input_bfd,
1656 input_section,
1657 offset);
1659 break;
1666 #ifdef DEBUG
1667 fprintf (stderr, "\n");
1668 #endif
1670 return ret;
1673 static void
1674 i370_elf_post_process_headers (abfd, link_info)
1675 bfd * abfd;
1676 struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
1678 Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form */
1680 i_ehdrp = elf_elfheader (abfd);
1681 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_LINUX;
1684 #define TARGET_BIG_SYM bfd_elf32_i370_vec
1685 #define TARGET_BIG_NAME "elf32-i370"
1686 #define ELF_ARCH bfd_arch_i370
1687 #define ELF_MACHINE_CODE EM_S370
1688 #ifdef EM_I370_OLD
1689 #define ELF_MACHINE_ALT1 EM_I370_OLD
1690 #endif
1691 #define ELF_MAXPAGESIZE 0x1000
1692 #define elf_info_to_howto i370_elf_info_to_howto
1696 #define elf_backend_plt_not_loaded 1
1697 #define elf_backend_got_symbol_offset 4
1699 #define bfd_elf32_bfd_reloc_type_lookup i370_elf_reloc_type_lookup
1700 #define bfd_elf32_bfd_set_private_flags i370_elf_set_private_flags
1701 #define bfd_elf32_bfd_copy_private_bfd_data i370_elf_copy_private_bfd_data
1702 #define bfd_elf32_bfd_merge_private_bfd_data i370_elf_merge_private_bfd_data
1703 #define elf_backend_relocate_section i370_elf_relocate_section
1705 /* dynamic loader support is mostly broken; just enough here to be able to
1706 * link glibc's ld.so without errors.
1708 #define elf_backend_create_dynamic_sections i370_elf_create_dynamic_sections
1709 #define elf_backend_size_dynamic_sections i370_elf_size_dynamic_sections
1710 #define elf_backend_finish_dynamic_sections i370_elf_finish_dynamic_sections
1711 #define elf_backend_fake_sections i370_elf_fake_sections
1712 #define elf_backend_section_from_shdr i370_elf_section_from_shdr
1713 #define elf_backend_adjust_dynamic_symbol i370_elf_adjust_dynamic_symbol
1714 #define elf_backend_check_relocs i370_elf_check_relocs
1717 #define elf_backend_add_symbol_hook i370_elf_add_symbol_hook
1718 #define elf_backend_finish_dynamic_symbol i370_elf_finish_dynamic_symbol
1719 #define elf_backend_additional_program_headers i370_elf_additional_program_headers
1720 #define elf_backend_modify_segment_map i370_elf_modify_segment_map
1723 #define elf_backend_post_process_headers i370_elf_post_process_headers
1725 int i370_noop()
1727 return 1;
1730 /* we need to define these at least as no-ops to link glibc ld.so */
1732 #define elf_backend_add_symbol_hook \
1733 (boolean (*) PARAMS ((bfd *, struct bfd_link_info *, \
1734 const char *, Elf_Internal_Sym *, \
1735 asection *))) i370_noop
1736 #define elf_backend_finish_dynamic_symbol \
1737 (boolean (*) PARAMS ((bfd *, struct bfd_link_info *, \
1738 struct elf_link_hash_entry *, \
1739 Elf_Internal_Sym *))) i370_noop
1740 #define elf_backend_additional_program_headers \
1741 (int (*) PARAMS ((bfd *))) i370_noop
1742 #define elf_backend_modify_segment_map \
1743 (boolean (*) PARAMS ((bfd *))) i370_noop
1745 #include "elf32-target.h"