2007-03-13 H.J. Lu <hongjiu.lu@intel.com>
[binutils.git] / bfd / elf32-i370.c
blob69393d97fc9efa9840abb269a8145e0d018f71ea
1 /* i370-specific support for 32-bit ELF
2 Copyright 1994, 1995, 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor, Cygnus Support.
5 Hacked by Linas Vepstas for i370 linas@linas.org
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
24 /* This file is based on a preliminary PowerPC ELF ABI.
25 But its been hacked on for the IBM 360/370 architectures.
26 Basically, the 31bit relocation works, and just about everything
27 else is a wild card. In particular, don't expect shared libs or
28 dynamic loading to work ... its never been tested. */
30 #include "bfd.h"
31 #include "sysdep.h"
32 #include "bfdlink.h"
33 #include "libbfd.h"
34 #include "elf-bfd.h"
35 #include "elf/i370.h"
37 static reloc_howto_type *i370_elf_howto_table[ (int)R_I370_max ];
39 static reloc_howto_type i370_elf_howto_raw[] =
41 /* This reloc does nothing. */
42 HOWTO (R_I370_NONE, /* type */
43 0, /* rightshift */
44 2, /* size (0 = byte, 1 = short, 2 = long) */
45 32, /* bitsize */
46 FALSE, /* pc_relative */
47 0, /* bitpos */
48 complain_overflow_bitfield, /* complain_on_overflow */
49 bfd_elf_generic_reloc, /* special_function */
50 "R_I370_NONE", /* name */
51 FALSE, /* partial_inplace */
52 0, /* src_mask */
53 0, /* dst_mask */
54 FALSE), /* pcrel_offset */
56 /* A standard 31 bit relocation. */
57 HOWTO (R_I370_ADDR31, /* type */
58 0, /* rightshift */
59 2, /* size (0 = byte, 1 = short, 2 = long) */
60 31, /* bitsize */
61 FALSE, /* pc_relative */
62 0, /* bitpos */
63 complain_overflow_bitfield, /* complain_on_overflow */
64 bfd_elf_generic_reloc, /* special_function */
65 "R_I370_ADDR31", /* name */
66 FALSE, /* partial_inplace */
67 0, /* src_mask */
68 0x7fffffff, /* dst_mask */
69 FALSE), /* pcrel_offset */
71 /* A standard 32 bit relocation. */
72 HOWTO (R_I370_ADDR32, /* type */
73 0, /* rightshift */
74 2, /* size (0 = byte, 1 = short, 2 = long) */
75 32, /* bitsize */
76 FALSE, /* pc_relative */
77 0, /* bitpos */
78 complain_overflow_bitfield, /* complain_on_overflow */
79 bfd_elf_generic_reloc, /* special_function */
80 "R_I370_ADDR32", /* name */
81 FALSE, /* partial_inplace */
82 0, /* src_mask */
83 0xffffffff, /* dst_mask */
84 FALSE), /* pcrel_offset */
86 /* A standard 16 bit relocation. */
87 HOWTO (R_I370_ADDR16, /* type */
88 0, /* rightshift */
89 1, /* size (0 = byte, 1 = short, 2 = long) */
90 16, /* bitsize */
91 FALSE, /* pc_relative */
92 0, /* bitpos */
93 complain_overflow_bitfield, /* complain_on_overflow */
94 bfd_elf_generic_reloc, /* special_function */
95 "R_I370_ADDR16", /* name */
96 FALSE, /* partial_inplace */
97 0, /* src_mask */
98 0xffff, /* dst_mask */
99 FALSE), /* pcrel_offset */
101 /* 31-bit PC relative. */
102 HOWTO (R_I370_REL31, /* type */
103 0, /* rightshift */
104 2, /* size (0 = byte, 1 = short, 2 = long) */
105 31, /* bitsize */
106 TRUE, /* pc_relative */
107 0, /* bitpos */
108 complain_overflow_bitfield, /* complain_on_overflow */
109 bfd_elf_generic_reloc, /* special_function */
110 "R_I370_REL31", /* name */
111 FALSE, /* partial_inplace */
112 0, /* src_mask */
113 0x7fffffff, /* dst_mask */
114 TRUE), /* pcrel_offset */
116 /* 32-bit PC relative. */
117 HOWTO (R_I370_REL32, /* type */
118 0, /* rightshift */
119 2, /* size (0 = byte, 1 = short, 2 = long) */
120 32, /* bitsize */
121 TRUE, /* pc_relative */
122 0, /* bitpos */
123 complain_overflow_bitfield, /* complain_on_overflow */
124 bfd_elf_generic_reloc, /* special_function */
125 "R_I370_REL32", /* name */
126 FALSE, /* partial_inplace */
127 0, /* src_mask */
128 0xffffffff, /* dst_mask */
129 TRUE), /* pcrel_offset */
131 /* A standard 12 bit relocation. */
132 HOWTO (R_I370_ADDR12, /* type */
133 0, /* rightshift */
134 1, /* size (0 = byte, 1 = short, 2 = long) */
135 12, /* bitsize */
136 FALSE, /* pc_relative */
137 0, /* bitpos */
138 complain_overflow_bitfield, /* complain_on_overflow */
139 bfd_elf_generic_reloc, /* special_function */
140 "R_I370_ADDR12", /* name */
141 FALSE, /* partial_inplace */
142 0, /* src_mask */
143 0xfff, /* dst_mask */
144 FALSE), /* pcrel_offset */
146 /* 12-bit PC relative. */
147 HOWTO (R_I370_REL12, /* type */
148 0, /* rightshift */
149 1, /* size (0 = byte, 1 = short, 2 = long) */
150 12, /* bitsize */
151 TRUE, /* pc_relative */
152 0, /* bitpos */
153 complain_overflow_bitfield, /* complain_on_overflow */
154 bfd_elf_generic_reloc, /* special_function */
155 "R_I370_REL12", /* name */
156 FALSE, /* partial_inplace */
157 0, /* src_mask */
158 0xfff, /* dst_mask */
159 TRUE), /* pcrel_offset */
161 /* A standard 8 bit relocation. */
162 HOWTO (R_I370_ADDR8, /* type */
163 0, /* rightshift */
164 0, /* size (0 = byte, 1 = short, 2 = long) */
165 8, /* bitsize */
166 FALSE, /* pc_relative */
167 0, /* bitpos */
168 complain_overflow_bitfield, /* complain_on_overflow */
169 bfd_elf_generic_reloc, /* special_function */
170 "R_I370_ADDR8", /* name */
171 FALSE, /* partial_inplace */
172 0, /* src_mask */
173 0xff, /* dst_mask */
174 FALSE), /* pcrel_offset */
176 /* 8-bit PC relative. */
177 HOWTO (R_I370_REL8, /* type */
178 0, /* rightshift */
179 0, /* size (0 = byte, 1 = short, 2 = long) */
180 8, /* bitsize */
181 TRUE, /* pc_relative */
182 0, /* bitpos */
183 complain_overflow_bitfield, /* complain_on_overflow */
184 bfd_elf_generic_reloc, /* special_function */
185 "R_I370_REL8", /* name */
186 FALSE, /* partial_inplace */
187 0, /* src_mask */
188 0xff, /* dst_mask */
189 TRUE), /* pcrel_offset */
191 /* This is used only by the dynamic linker. The symbol should exist
192 both in the object being run and in some shared library. The
193 dynamic linker copies the data addressed by the symbol from the
194 shared library into the object, because the object being
195 run has to have the data at some particular address. */
196 HOWTO (R_I370_COPY, /* type */
197 0, /* rightshift */
198 2, /* size (0 = byte, 1 = short, 2 = long) */
199 32, /* bitsize */
200 FALSE, /* pc_relative */
201 0, /* bitpos */
202 complain_overflow_bitfield, /* complain_on_overflow */
203 bfd_elf_generic_reloc, /* special_function */
204 "R_I370_COPY", /* name */
205 FALSE, /* partial_inplace */
206 0, /* src_mask */
207 0, /* dst_mask */
208 FALSE), /* pcrel_offset */
210 /* Used only by the dynamic linker. When the object is run, this
211 longword is set to the load address of the object, plus the
212 addend. */
213 HOWTO (R_I370_RELATIVE, /* type */
214 0, /* rightshift */
215 2, /* size (0 = byte, 1 = short, 2 = long) */
216 32, /* bitsize */
217 FALSE, /* pc_relative */
218 0, /* bitpos */
219 complain_overflow_bitfield, /* complain_on_overflow */
220 bfd_elf_generic_reloc, /* special_function */
221 "R_I370_RELATIVE", /* name */
222 FALSE, /* partial_inplace */
223 0, /* src_mask */
224 0xffffffff, /* dst_mask */
225 FALSE), /* pcrel_offset */
229 /* Initialize the i370_elf_howto_table, so that linear accesses can be done. */
231 static void
232 i370_elf_howto_init (void)
234 unsigned int i, type;
236 for (i = 0; i < sizeof (i370_elf_howto_raw) / sizeof (i370_elf_howto_raw[0]); i++)
238 type = i370_elf_howto_raw[i].type;
239 BFD_ASSERT (type < sizeof (i370_elf_howto_table) / sizeof (i370_elf_howto_table[0]));
240 i370_elf_howto_table[type] = &i370_elf_howto_raw[i];
244 static reloc_howto_type *
245 i370_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
246 bfd_reloc_code_real_type code)
248 enum i370_reloc_type i370_reloc = R_I370_NONE;
250 if (!i370_elf_howto_table[ R_I370_ADDR31 ])
251 /* Initialize howto table if needed. */
252 i370_elf_howto_init ();
254 switch ((int) code)
256 default:
257 return NULL;
259 case BFD_RELOC_NONE: i370_reloc = R_I370_NONE; break;
260 case BFD_RELOC_32: i370_reloc = R_I370_ADDR31; break;
261 case BFD_RELOC_16: i370_reloc = R_I370_ADDR16; break;
262 case BFD_RELOC_32_PCREL: i370_reloc = R_I370_REL31; break;
263 case BFD_RELOC_CTOR: i370_reloc = R_I370_ADDR31; break;
264 case BFD_RELOC_I370_D12: i370_reloc = R_I370_ADDR12; break;
267 return i370_elf_howto_table[ (int)i370_reloc ];
270 /* The name of the dynamic interpreter. This is put in the .interp
271 section. */
273 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
275 /* Set the howto pointer for an i370 ELF reloc. */
277 static void
278 i370_elf_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
279 arelent *cache_ptr,
280 Elf_Internal_Rela *dst)
282 if (!i370_elf_howto_table[ R_I370_ADDR31 ])
283 /* Initialize howto table. */
284 i370_elf_howto_init ();
286 BFD_ASSERT (ELF32_R_TYPE (dst->r_info) < (unsigned int) R_I370_max);
287 cache_ptr->howto = i370_elf_howto_table[ELF32_R_TYPE (dst->r_info)];
290 /* Hack alert -- the following several routines look generic to me ...
291 why are we bothering with them ? */
292 /* Function to set whether a module needs the -mrelocatable bit set. */
294 static bfd_boolean
295 i370_elf_set_private_flags (bfd *abfd, flagword flags)
297 BFD_ASSERT (!elf_flags_init (abfd)
298 || elf_elfheader (abfd)->e_flags == flags);
300 elf_elfheader (abfd)->e_flags = flags;
301 elf_flags_init (abfd) = TRUE;
302 return TRUE;
305 /* Merge backend specific data from an object file to the output
306 object file when linking. */
308 static bfd_boolean
309 i370_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
311 flagword old_flags;
312 flagword new_flags;
314 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
315 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
316 return TRUE;
318 new_flags = elf_elfheader (ibfd)->e_flags;
319 old_flags = elf_elfheader (obfd)->e_flags;
320 if (!elf_flags_init (obfd)) /* First call, no flags set. */
322 elf_flags_init (obfd) = TRUE;
323 elf_elfheader (obfd)->e_flags = new_flags;
326 else if (new_flags == old_flags) /* Compatible flags are ok. */
329 else /* Incompatible flags. */
331 (*_bfd_error_handler)
332 ("%B: uses different e_flags (0x%lx) fields than previous modules (0x%lx)",
333 ibfd, (long) new_flags, (long) old_flags);
335 bfd_set_error (bfd_error_bad_value);
336 return FALSE;
339 return TRUE;
342 /* Handle an i370 specific section when reading an object file. This
343 is called when elfcode.h finds a section with an unknown type. */
344 /* XXX hack alert bogus This routine is mostly all junk and almost
345 certainly does the wrong thing. Its here simply because it does
346 just enough to allow glibc-2.1 ld.so to compile & link. */
348 static bfd_boolean
349 i370_elf_section_from_shdr (bfd *abfd,
350 Elf_Internal_Shdr *hdr,
351 const char *name,
352 int shindex)
354 asection *newsect;
355 flagword flags;
357 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
358 return FALSE;
360 newsect = hdr->bfd_section;
361 flags = bfd_get_section_flags (abfd, newsect);
362 if (hdr->sh_flags & SHF_EXCLUDE)
363 flags |= SEC_EXCLUDE;
365 if (hdr->sh_type == SHT_ORDERED)
366 flags |= SEC_SORT_ENTRIES;
368 bfd_set_section_flags (abfd, newsect, flags);
369 return TRUE;
372 /* Set up any other section flags and such that may be necessary. */
373 /* XXX hack alert bogus This routine is mostly all junk and almost
374 certainly does the wrong thing. Its here simply because it does
375 just enough to allow glibc-2.1 ld.so to compile & link. */
377 static bfd_boolean
378 i370_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
379 Elf_Internal_Shdr *shdr,
380 asection *asect)
382 if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE)
383 shdr->sh_flags |= SHF_EXCLUDE;
385 if ((asect->flags & SEC_SORT_ENTRIES) != 0)
386 shdr->sh_type = SHT_ORDERED;
388 return TRUE;
391 /* We have to create .dynsbss and .rela.sbss here so that they get mapped
392 to output sections (just like _bfd_elf_create_dynamic_sections has
393 to create .dynbss and .rela.bss). */
394 /* XXX hack alert bogus This routine is mostly all junk and almost
395 certainly does the wrong thing. Its here simply because it does
396 just enough to allow glibc-2.1 ld.so to compile & link. */
398 static bfd_boolean
399 i370_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
401 asection *s;
402 flagword flags;
404 if (!_bfd_elf_create_dynamic_sections(abfd, info))
405 return FALSE;
407 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
408 | SEC_LINKER_CREATED);
410 s = bfd_make_section_with_flags (abfd, ".dynsbss",
411 SEC_ALLOC | SEC_LINKER_CREATED);
412 if (s == NULL)
413 return FALSE;
415 if (! info->shared)
417 s = bfd_make_section_with_flags (abfd, ".rela.sbss",
418 flags | SEC_READONLY);
419 if (s == NULL
420 || ! bfd_set_section_alignment (abfd, s, 2))
421 return FALSE;
424 /* XXX beats me, seem to need a rela.text ... */
425 s = bfd_make_section_with_flags (abfd, ".rela.text",
426 flags | SEC_READONLY);
427 if (s == NULL
428 || ! bfd_set_section_alignment (abfd, s, 2))
429 return FALSE;
430 return TRUE;
433 /* Adjust a symbol defined by a dynamic object and referenced by a
434 regular object. The current definition is in some section of the
435 dynamic object, but we're not including those sections. We have to
436 change the definition to something the rest of the link can
437 understand. */
438 /* XXX hack alert bogus This routine is mostly all junk and almost
439 certainly does the wrong thing. Its here simply because it does
440 just enough to allow glibc-2.1 ld.so to compile & link. */
442 static bfd_boolean
443 i370_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
444 struct elf_link_hash_entry *h)
446 bfd *dynobj = elf_hash_table (info)->dynobj;
447 asection *s;
448 unsigned int power_of_two;
450 #ifdef DEBUG
451 fprintf (stderr, "i370_elf_adjust_dynamic_symbol called for %s\n",
452 h->root.root.string);
453 #endif
455 /* Make sure we know what is going on here. */
456 BFD_ASSERT (dynobj != NULL
457 && (h->needs_plt
458 || h->u.weakdef != NULL
459 || (h->def_dynamic
460 && h->ref_regular
461 && !h->def_regular)));
463 s = bfd_get_section_by_name (dynobj, ".rela.text");
464 BFD_ASSERT (s != NULL);
465 s->size += sizeof (Elf32_External_Rela);
467 /* If this is a weak symbol, and there is a real definition, the
468 processor independent code will have arranged for us to see the
469 real definition first, and we can just use the same value. */
470 if (h->u.weakdef != NULL)
472 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
473 || h->u.weakdef->root.type == bfd_link_hash_defweak);
474 h->root.u.def.section = h->u.weakdef->root.u.def.section;
475 h->root.u.def.value = h->u.weakdef->root.u.def.value;
476 return TRUE;
479 /* This is a reference to a symbol defined by a dynamic object which
480 is not a function. */
482 /* If we are creating a shared library, we must presume that the
483 only references to the symbol are via the global offset table.
484 For such cases we need not do anything here; the relocations will
485 be handled correctly by relocate_section. */
486 if (info->shared)
487 return TRUE;
489 if (h->size == 0)
491 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
492 h->root.root.string);
493 return TRUE;
496 /* We must allocate the symbol in our .dynbss section, which will
497 become part of the .bss section of the executable. There will be
498 an entry for this symbol in the .dynsym section. The dynamic
499 object will contain position independent code, so all references
500 from the dynamic object to this symbol will go through the global
501 offset table. The dynamic linker will use the .dynsym entry to
502 determine the address it must put in the global offset table, so
503 both the dynamic object and the regular object will refer to the
504 same memory location for the variable.
506 Of course, if the symbol is sufficiently small, we must instead
507 allocate it in .sbss. FIXME: It would be better to do this if and
508 only if there were actually SDAREL relocs for that symbol. */
510 if (h->size <= elf_gp_size (dynobj))
511 s = bfd_get_section_by_name (dynobj, ".dynsbss");
512 else
513 s = bfd_get_section_by_name (dynobj, ".dynbss");
514 BFD_ASSERT (s != NULL);
516 /* We must generate a R_I370_COPY reloc to tell the dynamic linker to
517 copy the initial value out of the dynamic object and into the
518 runtime process image. We need to remember the offset into the
519 .rela.bss section we are going to use. */
520 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
522 asection *srel;
524 if (h->size <= elf_gp_size (dynobj))
525 srel = bfd_get_section_by_name (dynobj, ".rela.sbss");
526 else
527 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
528 BFD_ASSERT (srel != NULL);
529 srel->size += sizeof (Elf32_External_Rela);
530 h->needs_copy = 1;
533 /* We need to figure out the alignment required for this symbol. I
534 have no idea how ELF linkers handle this. */
535 power_of_two = bfd_log2 (h->size);
536 if (power_of_two > 4)
537 power_of_two = 4;
539 /* Apply the required alignment. */
540 s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
541 if (power_of_two > bfd_get_section_alignment (dynobj, s))
543 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
544 return FALSE;
547 /* Define the symbol as being at this point in the section. */
548 h->root.u.def.section = s;
549 h->root.u.def.value = s->size;
551 /* Increment the section size to make room for the symbol. */
552 s->size += h->size;
554 return TRUE;
557 /* Increment the index of a dynamic symbol by a given amount. Called
558 via elf_link_hash_traverse. */
559 /* XXX hack alert bogus This routine is mostly all junk and almost
560 certainly does the wrong thing. Its here simply because it does
561 just enough to allow glibc-2.1 ld.so to compile & link. */
563 static bfd_boolean
564 i370_elf_adjust_dynindx (struct elf_link_hash_entry *h, void * cparg)
566 int *cp = (int *) cparg;
568 #ifdef DEBUG
569 fprintf (stderr,
570 "i370_elf_adjust_dynindx called, h->dynindx = %ld, *cp = %d\n",
571 h->dynindx, *cp);
572 #endif
574 if (h->root.type == bfd_link_hash_warning)
575 h = (struct elf_link_hash_entry *) h->root.u.i.link;
577 if (h->dynindx != -1)
578 h->dynindx += *cp;
580 return TRUE;
583 /* Set the sizes of the dynamic sections. */
584 /* XXX hack alert bogus This routine is mostly all junk and almost
585 certainly does the wrong thing. Its here simply because it does
586 just enough to allow glibc-2.1 ld.so to compile & link. */
588 static bfd_boolean
589 i370_elf_size_dynamic_sections (bfd *output_bfd,
590 struct bfd_link_info *info)
592 bfd *dynobj;
593 asection *s;
594 bfd_boolean plt;
595 bfd_boolean relocs;
596 bfd_boolean reltext;
598 #ifdef DEBUG
599 fprintf (stderr, "i370_elf_size_dynamic_sections called\n");
600 #endif
602 dynobj = elf_hash_table (info)->dynobj;
603 BFD_ASSERT (dynobj != NULL);
605 if (elf_hash_table (info)->dynamic_sections_created)
607 /* Set the contents of the .interp section to the interpreter. */
608 if (info->executable)
610 s = bfd_get_section_by_name (dynobj, ".interp");
611 BFD_ASSERT (s != NULL);
612 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
613 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
616 else
618 /* We may have created entries in the .rela.got, .rela.sdata, and
619 .rela.sdata2 sections. However, if we are not creating the
620 dynamic sections, we will not actually use these entries. Reset
621 the size of .rela.got, et al, which will cause it to get
622 stripped from the output file below. */
623 static char *rela_sections[] = { ".rela.got", ".rela.sdata",
624 ".rela.sdata2", ".rela.sbss",
625 NULL };
626 char **p;
628 for (p = rela_sections; *p != NULL; p++)
630 s = bfd_get_section_by_name (dynobj, *p);
631 if (s != NULL)
632 s->size = 0;
636 /* The check_relocs and adjust_dynamic_symbol entry points have
637 determined the sizes of the various dynamic sections. Allocate
638 memory for them. */
639 plt = FALSE;
640 relocs = FALSE;
641 reltext = FALSE;
642 for (s = dynobj->sections; s != NULL; s = s->next)
644 const char *name;
646 if ((s->flags & SEC_LINKER_CREATED) == 0)
647 continue;
649 /* It's OK to base decisions on the section name, because none
650 of the dynobj section names depend upon the input files. */
651 name = bfd_get_section_name (dynobj, s);
653 if (strcmp (name, ".plt") == 0)
655 /* Remember whether there is a PLT. */
656 plt = s->size != 0;
658 else if (CONST_STRNEQ (name, ".rela"))
660 if (s->size != 0)
662 asection *target;
663 const char *outname;
665 /* Remember whether there are any relocation sections. */
666 relocs = TRUE;
668 /* If this relocation section applies to a read only
669 section, then we probably need a DT_TEXTREL entry. */
670 outname = bfd_get_section_name (output_bfd,
671 s->output_section);
672 target = bfd_get_section_by_name (output_bfd, outname + 5);
673 if (target != NULL
674 && (target->flags & SEC_READONLY) != 0
675 && (target->flags & SEC_ALLOC) != 0)
676 reltext = TRUE;
678 /* We use the reloc_count field as a counter if we need
679 to copy relocs into the output file. */
680 s->reloc_count = 0;
683 else if (strcmp (name, ".got") != 0
684 && strcmp (name, ".sdata") != 0
685 && strcmp (name, ".sdata2") != 0
686 && strcmp (name, ".dynbss") != 0
687 && strcmp (name, ".dynsbss") != 0)
689 /* It's not one of our sections, so don't allocate space. */
690 continue;
693 if (s->size == 0)
695 /* If we don't need this section, strip it from the
696 output file. This is mostly to handle .rela.bss and
697 .rela.plt. We must create both sections in
698 create_dynamic_sections, because they must be created
699 before the linker maps input sections to output
700 sections. The linker does that before
701 adjust_dynamic_symbol is called, and it is that
702 function which decides whether anything needs to go
703 into these sections. */
704 s->flags |= SEC_EXCLUDE;
705 continue;
708 if ((s->flags & SEC_HAS_CONTENTS) == 0)
709 continue;
711 /* Allocate memory for the section contents. */
712 s->contents = bfd_zalloc (dynobj, s->size);
713 if (s->contents == NULL)
714 return FALSE;
717 if (elf_hash_table (info)->dynamic_sections_created)
719 /* Add some entries to the .dynamic section. We fill in the
720 values later, in i370_elf_finish_dynamic_sections, but we
721 must add the entries now so that we get the correct size for
722 the .dynamic section. The DT_DEBUG entry is filled in by the
723 dynamic linker and used by the debugger. */
724 #define add_dynamic_entry(TAG, VAL) \
725 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
727 if (!info->shared)
729 if (!add_dynamic_entry (DT_DEBUG, 0))
730 return FALSE;
733 if (plt)
735 if (!add_dynamic_entry (DT_PLTGOT, 0)
736 || !add_dynamic_entry (DT_PLTRELSZ, 0)
737 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
738 || !add_dynamic_entry (DT_JMPREL, 0))
739 return FALSE;
742 if (relocs)
744 if (!add_dynamic_entry (DT_RELA, 0)
745 || !add_dynamic_entry (DT_RELASZ, 0)
746 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
747 return FALSE;
750 if (reltext)
752 if (!add_dynamic_entry (DT_TEXTREL, 0))
753 return FALSE;
754 info->flags |= DF_TEXTREL;
757 #undef add_dynamic_entry
759 /* If we are generating a shared library, we generate a section
760 symbol for each output section. These are local symbols, which
761 means that they must come first in the dynamic symbol table.
762 That means we must increment the dynamic symbol index of every
763 other dynamic symbol.
765 FIXME: We assume that there will never be relocations to
766 locations in linker-created sections that do not have
767 externally-visible names. Instead, we should work out precisely
768 which sections relocations are targeted at. */
769 if (info->shared)
771 int c;
773 for (c = 0, s = output_bfd->sections; s != NULL; s = s->next)
775 if ((s->flags & SEC_LINKER_CREATED) != 0
776 || (s->flags & SEC_ALLOC) == 0)
778 elf_section_data (s)->dynindx = -1;
779 continue;
782 /* These symbols will have no names, so we don't need to
783 fiddle with dynstr_index. */
785 elf_section_data (s)->dynindx = c + 1;
787 c++;
790 elf_link_hash_traverse (elf_hash_table (info),
791 i370_elf_adjust_dynindx, & c);
792 elf_hash_table (info)->dynsymcount += c;
795 return TRUE;
798 /* Look through the relocs for a section during the first phase, and
799 allocate space in the global offset table or procedure linkage
800 table. */
801 /* XXX hack alert bogus This routine is mostly all junk and almost
802 certainly does the wrong thing. Its here simply because it does
803 just enough to allow glibc-2.1 ld.so to compile & link. */
805 static bfd_boolean
806 i370_elf_check_relocs (bfd *abfd,
807 struct bfd_link_info *info,
808 asection *sec,
809 const Elf_Internal_Rela *relocs)
811 bfd *dynobj;
812 Elf_Internal_Shdr *symtab_hdr;
813 struct elf_link_hash_entry **sym_hashes;
814 const Elf_Internal_Rela *rel;
815 const Elf_Internal_Rela *rel_end;
816 bfd_vma *local_got_offsets;
817 asection *sreloc;
819 if (info->relocatable)
820 return TRUE;
822 #ifdef DEBUG
823 _bfd_error_handler ("i370_elf_check_relocs called for section %A in %B",
824 sec, abfd);
825 #endif
827 dynobj = elf_hash_table (info)->dynobj;
828 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
829 sym_hashes = elf_sym_hashes (abfd);
830 local_got_offsets = elf_local_got_offsets (abfd);
832 sreloc = NULL;
834 rel_end = relocs + sec->reloc_count;
835 for (rel = relocs; rel < rel_end; rel++)
837 unsigned long r_symndx;
838 struct elf_link_hash_entry *h;
840 r_symndx = ELF32_R_SYM (rel->r_info);
841 if (r_symndx < symtab_hdr->sh_info)
842 h = NULL;
843 else
845 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
846 while (h->root.type == bfd_link_hash_indirect
847 || h->root.type == bfd_link_hash_warning)
848 h = (struct elf_link_hash_entry *) h->root.u.i.link;
851 if (info->shared)
853 #ifdef DEBUG
854 fprintf (stderr,
855 "i370_elf_check_relocs needs to create relocation for %s\n",
856 (h && h->root.root.string)
857 ? h->root.root.string : "<unknown>");
858 #endif
859 if (sreloc == NULL)
861 const char *name;
863 name = (bfd_elf_string_from_elf_section
864 (abfd,
865 elf_elfheader (abfd)->e_shstrndx,
866 elf_section_data (sec)->rel_hdr.sh_name));
867 if (name == NULL)
868 return FALSE;
870 BFD_ASSERT (CONST_STRNEQ (name, ".rela")
871 && strcmp (bfd_get_section_name (abfd, sec), name + 5) == 0);
873 sreloc = bfd_get_section_by_name (dynobj, name);
874 if (sreloc == NULL)
876 flagword flags;
878 flags = (SEC_HAS_CONTENTS | SEC_READONLY
879 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
880 if ((sec->flags & SEC_ALLOC) != 0)
881 flags |= SEC_ALLOC | SEC_LOAD;
882 sreloc = bfd_make_section_with_flags (dynobj, name,
883 flags);
884 if (sreloc == NULL
885 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
886 return FALSE;
890 sreloc->size += sizeof (Elf32_External_Rela);
892 /* FIXME: We should here do what the m68k and i386
893 backends do: if the reloc is pc-relative, record it
894 in case it turns out that the reloc is unnecessary
895 because the symbol is forced local by versioning or
896 we are linking with -Bdynamic. Fortunately this
897 case is not frequent. */
901 return TRUE;
904 /* Finish up the dynamic sections. */
905 /* XXX hack alert bogus This routine is mostly all junk and almost
906 certainly does the wrong thing. Its here simply because it does
907 just enough to allow glibc-2.1 ld.so to compile & link. */
909 static bfd_boolean
910 i370_elf_finish_dynamic_sections (bfd *output_bfd,
911 struct bfd_link_info *info)
913 asection *sdyn;
914 bfd *dynobj = elf_hash_table (info)->dynobj;
915 asection *sgot = bfd_get_section_by_name (dynobj, ".got");
917 #ifdef DEBUG
918 fprintf (stderr, "i370_elf_finish_dynamic_sections called\n");
919 #endif
921 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
923 if (elf_hash_table (info)->dynamic_sections_created)
925 asection *splt;
926 Elf32_External_Dyn *dyncon, *dynconend;
928 splt = bfd_get_section_by_name (dynobj, ".plt");
929 BFD_ASSERT (splt != NULL && sdyn != NULL);
931 dyncon = (Elf32_External_Dyn *) sdyn->contents;
932 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
933 for (; dyncon < dynconend; dyncon++)
935 Elf_Internal_Dyn dyn;
936 const char *name;
937 bfd_boolean size;
939 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
941 switch (dyn.d_tag)
943 case DT_PLTGOT: name = ".plt"; size = FALSE; break;
944 case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
945 case DT_JMPREL: name = ".rela.plt"; size = FALSE; break;
946 default: name = NULL; size = FALSE; break;
949 if (name != NULL)
951 asection *s;
953 s = bfd_get_section_by_name (output_bfd, name);
954 if (s == NULL)
955 dyn.d_un.d_val = 0;
956 else
958 if (! size)
959 dyn.d_un.d_ptr = s->vma;
960 else
961 dyn.d_un.d_val = s->size;
963 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
968 if (sgot && sgot->size != 0)
970 unsigned char *contents = sgot->contents;
972 if (sdyn == NULL)
973 bfd_put_32 (output_bfd, (bfd_vma) 0, contents);
974 else
975 bfd_put_32 (output_bfd,
976 sdyn->output_section->vma + sdyn->output_offset,
977 contents);
979 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
982 if (info->shared)
984 asection *sdynsym;
985 asection *s;
986 Elf_Internal_Sym sym;
987 int maxdindx = 0;
989 /* Set up the section symbols for the output sections. */
991 sdynsym = bfd_get_section_by_name (dynobj, ".dynsym");
992 BFD_ASSERT (sdynsym != NULL);
994 sym.st_size = 0;
995 sym.st_name = 0;
996 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
997 sym.st_other = 0;
999 for (s = output_bfd->sections; s != NULL; s = s->next)
1001 int indx, dindx;
1002 Elf32_External_Sym *esym;
1004 sym.st_value = s->vma;
1006 indx = elf_section_data (s)->this_idx;
1007 dindx = elf_section_data (s)->dynindx;
1008 if (dindx != -1)
1010 BFD_ASSERT(indx > 0);
1011 BFD_ASSERT(dindx > 0);
1013 if (dindx > maxdindx)
1014 maxdindx = dindx;
1016 sym.st_shndx = indx;
1018 esym = (Elf32_External_Sym *) sdynsym->contents + dindx;
1019 bfd_elf32_swap_symbol_out (output_bfd, &sym, esym, NULL);
1023 /* Set the sh_info field of the output .dynsym section to the
1024 index of the first global symbol. */
1025 elf_section_data (sdynsym->output_section)->this_hdr.sh_info =
1026 maxdindx + 1;
1029 return TRUE;
1032 /* The RELOCATE_SECTION function is called by the ELF backend linker
1033 to handle the relocations for a section.
1035 The relocs are always passed as Rela structures; if the section
1036 actually uses Rel structures, the r_addend field will always be
1037 zero.
1039 This function is responsible for adjust the section contents as
1040 necessary, and (if using Rela relocs and generating a
1041 relocatable output file) adjusting the reloc addend as
1042 necessary.
1044 This function does not have to worry about setting the reloc
1045 address or the reloc symbol index.
1047 LOCAL_SYMS is a pointer to the swapped in local symbols.
1049 LOCAL_SECTIONS is an array giving the section in the input file
1050 corresponding to the st_shndx field of each local symbol.
1052 The global hash table entry for the global symbols can be found
1053 via elf_sym_hashes (input_bfd).
1055 When generating relocatable output, this function must handle
1056 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1057 going to be the section symbol corresponding to the output
1058 section, which means that the addend must be adjusted
1059 accordingly. */
1061 static bfd_boolean
1062 i370_elf_relocate_section (bfd *output_bfd,
1063 struct bfd_link_info *info,
1064 bfd *input_bfd,
1065 asection *input_section,
1066 bfd_byte *contents,
1067 Elf_Internal_Rela *relocs,
1068 Elf_Internal_Sym *local_syms,
1069 asection **local_sections)
1071 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1072 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
1073 bfd *dynobj = elf_hash_table (info)->dynobj;
1074 Elf_Internal_Rela *rel = relocs;
1075 Elf_Internal_Rela *relend = relocs + input_section->reloc_count;
1076 asection *sreloc = NULL;
1077 bfd_vma *local_got_offsets;
1078 bfd_boolean ret = TRUE;
1080 #ifdef DEBUG
1081 _bfd_error_handler ("i370_elf_relocate_section called for %B section %A, %ld relocations%s",
1082 input_bfd, input_section,
1083 (long) input_section->reloc_count,
1084 (info->relocatable) ? " (relocatable)" : "");
1085 #endif
1087 if (!i370_elf_howto_table[ R_I370_ADDR31 ])
1088 /* Initialize howto table if needed. */
1089 i370_elf_howto_init ();
1091 local_got_offsets = elf_local_got_offsets (input_bfd);
1093 for (; rel < relend; rel++)
1095 enum i370_reloc_type r_type = (enum i370_reloc_type) ELF32_R_TYPE (rel->r_info);
1096 bfd_vma offset = rel->r_offset;
1097 bfd_vma addend = rel->r_addend;
1098 bfd_reloc_status_type r = bfd_reloc_other;
1099 Elf_Internal_Sym *sym = NULL;
1100 asection *sec = NULL;
1101 struct elf_link_hash_entry * h = NULL;
1102 const char *sym_name = NULL;
1103 reloc_howto_type *howto;
1104 unsigned long r_symndx;
1105 bfd_vma relocation;
1107 /* Unknown relocation handling. */
1108 if ((unsigned) r_type >= (unsigned) R_I370_max
1109 || !i370_elf_howto_table[(int)r_type])
1111 (*_bfd_error_handler) ("%B: unknown relocation type %d",
1112 input_bfd,
1113 (int) r_type);
1115 bfd_set_error (bfd_error_bad_value);
1116 ret = FALSE;
1117 continue;
1120 howto = i370_elf_howto_table[(int) r_type];
1121 r_symndx = ELF32_R_SYM (rel->r_info);
1122 relocation = 0;
1124 if (r_symndx < symtab_hdr->sh_info)
1126 sym = local_syms + r_symndx;
1127 sec = local_sections[r_symndx];
1128 sym_name = "<local symbol>";
1130 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, & sec, rel);
1131 addend = rel->r_addend;
1133 else
1135 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1136 while (h->root.type == bfd_link_hash_indirect
1137 || h->root.type == bfd_link_hash_warning)
1138 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1139 sym_name = h->root.root.string;
1140 if (h->root.type == bfd_link_hash_defined
1141 || h->root.type == bfd_link_hash_defweak)
1143 sec = h->root.u.def.section;
1144 if (info->shared
1145 && ((! info->symbolic && h->dynindx != -1)
1146 || !h->def_regular)
1147 && (input_section->flags & SEC_ALLOC) != 0
1148 && (r_type == R_I370_ADDR31
1149 || r_type == R_I370_COPY
1150 || r_type == R_I370_ADDR16
1151 || r_type == R_I370_RELATIVE))
1152 /* In these cases, we don't need the relocation
1153 value. We check specially because in some
1154 obscure cases sec->output_section will be NULL. */
1156 else
1157 relocation = (h->root.u.def.value
1158 + sec->output_section->vma
1159 + sec->output_offset);
1161 else if (h->root.type == bfd_link_hash_undefweak)
1163 else if (info->unresolved_syms_in_objects == RM_IGNORE
1164 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1166 else if (!info->relocatable)
1168 if ((*info->callbacks->undefined_symbol)
1169 (info, h->root.root.string, input_bfd,
1170 input_section, rel->r_offset,
1171 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
1172 || ELF_ST_VISIBILITY (h->other))))
1174 ret = FALSE;
1175 continue;
1180 if (sec != NULL && elf_discarded_section (sec))
1182 /* For relocs against symbols from removed linkonce sections,
1183 or sections discarded by a linker script, we just want the
1184 section contents zeroed. Avoid any special processing. */
1185 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
1186 rel->r_info = 0;
1187 rel->r_addend = 0;
1188 continue;
1191 if (info->relocatable)
1192 continue;
1194 switch ((int) r_type)
1196 default:
1197 (*_bfd_error_handler)
1198 ("%B: unknown relocation type %d for symbol %s",
1199 input_bfd, (int) r_type, sym_name);
1201 bfd_set_error (bfd_error_bad_value);
1202 ret = FALSE;
1203 continue;
1205 case (int) R_I370_NONE:
1206 continue;
1208 /* Relocations that may need to be propagated if this is a shared
1209 object. */
1210 case (int) R_I370_REL31:
1211 /* If these relocations are not to a named symbol, they can be
1212 handled right here, no need to bother the dynamic linker. */
1213 if (h == NULL
1214 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1215 break;
1216 /* Fall through. */
1218 /* Relocations that always need to be propagated if this is a shared
1219 object. */
1220 case (int) R_I370_ADDR31:
1221 case (int) R_I370_ADDR16:
1222 if (info->shared
1223 && r_symndx != 0)
1225 Elf_Internal_Rela outrel;
1226 bfd_byte *loc;
1227 int skip;
1229 #ifdef DEBUG
1230 fprintf (stderr,
1231 "i370_elf_relocate_section needs to create relocation for %s\n",
1232 (h && h->root.root.string) ? h->root.root.string : "<unknown>");
1233 #endif
1235 /* When generating a shared object, these relocations
1236 are copied into the output file to be resolved at run
1237 time. */
1239 if (sreloc == NULL)
1241 const char *name;
1243 name = (bfd_elf_string_from_elf_section
1244 (input_bfd,
1245 elf_elfheader (input_bfd)->e_shstrndx,
1246 elf_section_data (input_section)->rel_hdr.sh_name));
1247 if (name == NULL)
1248 return FALSE;
1250 BFD_ASSERT (CONST_STRNEQ (name, ".rela")
1251 && strcmp (bfd_get_section_name (input_bfd,
1252 input_section),
1253 name + 5) == 0);
1255 sreloc = bfd_get_section_by_name (dynobj, name);
1256 BFD_ASSERT (sreloc != NULL);
1259 skip = 0;
1261 outrel.r_offset =
1262 _bfd_elf_section_offset (output_bfd, info, input_section,
1263 rel->r_offset);
1264 if (outrel.r_offset == (bfd_vma) -1
1265 || outrel.r_offset == (bfd_vma) -2)
1266 skip = (int) outrel.r_offset;
1267 outrel.r_offset += (input_section->output_section->vma
1268 + input_section->output_offset);
1270 if (skip)
1271 memset (&outrel, 0, sizeof outrel);
1272 /* h->dynindx may be -1 if this symbol was marked to
1273 become local. */
1274 else if (h != NULL
1275 && ((! info->symbolic && h->dynindx != -1)
1276 || !h->def_regular))
1278 BFD_ASSERT (h->dynindx != -1);
1279 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1280 outrel.r_addend = rel->r_addend;
1282 else
1284 if (r_type == R_I370_ADDR31)
1286 outrel.r_info = ELF32_R_INFO (0, R_I370_RELATIVE);
1287 outrel.r_addend = relocation + rel->r_addend;
1289 else
1291 long indx;
1293 if (bfd_is_abs_section (sec))
1294 indx = 0;
1295 else if (sec == NULL || sec->owner == NULL)
1297 bfd_set_error (bfd_error_bad_value);
1298 return FALSE;
1300 else
1302 asection *osec;
1304 /* We are turning this relocation into one
1305 against a section symbol. It would be
1306 proper to subtract the symbol's value,
1307 osec->vma, from the emitted reloc addend,
1308 but ld.so expects buggy relocs. */
1309 osec = sec->output_section;
1310 indx = elf_section_data (osec)->dynindx;
1311 if (indx == 0)
1313 struct elf_link_hash_table *htab;
1314 htab = elf_hash_table (info);
1315 osec = htab->text_index_section;
1316 indx = elf_section_data (osec)->dynindx;
1318 BFD_ASSERT (indx != 0);
1319 #ifdef DEBUG
1320 if (indx <= 0)
1322 printf ("indx=%ld section=%s flags=%08x name=%s\n",
1323 indx, osec->name, osec->flags,
1324 h->root.root.string);
1326 #endif
1329 outrel.r_info = ELF32_R_INFO (indx, r_type);
1330 outrel.r_addend = relocation + rel->r_addend;
1334 loc = sreloc->contents;
1335 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1336 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1338 /* This reloc will be computed at runtime, so there's no
1339 need to do anything now, unless this is a RELATIVE
1340 reloc in an unallocated section. */
1341 if (skip == -1
1342 || (input_section->flags & SEC_ALLOC) != 0
1343 || ELF32_R_TYPE (outrel.r_info) != R_I370_RELATIVE)
1344 continue;
1346 break;
1348 case (int) R_I370_COPY:
1349 case (int) R_I370_RELATIVE:
1350 (*_bfd_error_handler)
1351 ("%B: Relocation %s is not yet supported for symbol %s.",
1352 input_bfd,
1353 i370_elf_howto_table[(int) r_type]->name,
1354 sym_name);
1356 bfd_set_error (bfd_error_invalid_operation);
1357 ret = FALSE;
1358 continue;
1361 #ifdef DEBUG
1362 fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, offset = %ld, addend = %ld\n",
1363 howto->name,
1364 (int)r_type,
1365 sym_name,
1366 r_symndx,
1367 (long) offset,
1368 (long) addend);
1369 #endif
1371 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
1372 offset, relocation, addend);
1374 if (r != bfd_reloc_ok)
1376 ret = FALSE;
1377 switch (r)
1379 default:
1380 break;
1382 case bfd_reloc_overflow:
1384 const char *name;
1386 if (h != NULL)
1387 name = NULL;
1388 else
1390 name = bfd_elf_string_from_elf_section (input_bfd,
1391 symtab_hdr->sh_link,
1392 sym->st_name);
1393 if (name == NULL)
1394 break;
1396 if (*name == '\0')
1397 name = bfd_section_name (input_bfd, sec);
1400 (*info->callbacks->reloc_overflow) (info,
1401 (h ? &h->root : NULL),
1402 name,
1403 howto->name,
1404 (bfd_vma) 0,
1405 input_bfd,
1406 input_section,
1407 offset);
1409 break;
1414 #ifdef DEBUG
1415 fprintf (stderr, "\n");
1416 #endif
1418 return ret;
1421 #define TARGET_BIG_SYM bfd_elf32_i370_vec
1422 #define TARGET_BIG_NAME "elf32-i370"
1423 #define ELF_ARCH bfd_arch_i370
1424 #define ELF_MACHINE_CODE EM_S370
1425 #ifdef EM_I370_OLD
1426 #define ELF_MACHINE_ALT1 EM_I370_OLD
1427 #endif
1428 #define ELF_MAXPAGESIZE 0x1000
1429 #define ELF_OSABI ELFOSABI_LINUX
1431 #define elf_info_to_howto i370_elf_info_to_howto
1433 #define elf_backend_plt_not_loaded 1
1434 #define elf_backend_rela_normal 1
1436 #define bfd_elf32_bfd_reloc_type_lookup i370_elf_reloc_type_lookup
1437 #define bfd_elf32_bfd_set_private_flags i370_elf_set_private_flags
1438 #define bfd_elf32_bfd_merge_private_bfd_data i370_elf_merge_private_bfd_data
1439 #define elf_backend_relocate_section i370_elf_relocate_section
1441 /* Dynamic loader support is mostly broken; just enough here to be able to
1442 link glibc's ld.so without errors. */
1443 #define elf_backend_create_dynamic_sections i370_elf_create_dynamic_sections
1444 #define elf_backend_size_dynamic_sections i370_elf_size_dynamic_sections
1445 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
1446 #define elf_backend_finish_dynamic_sections i370_elf_finish_dynamic_sections
1447 #define elf_backend_fake_sections i370_elf_fake_sections
1448 #define elf_backend_section_from_shdr i370_elf_section_from_shdr
1449 #define elf_backend_adjust_dynamic_symbol i370_elf_adjust_dynamic_symbol
1450 #define elf_backend_check_relocs i370_elf_check_relocs
1451 #define elf_backend_post_process_headers _bfd_elf_set_osabi
1453 static int
1454 i370_noop (void)
1456 return 1;
1459 #define elf_backend_finish_dynamic_symbol \
1460 (bfd_boolean (*) \
1461 (bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, \
1462 Elf_Internal_Sym *)) i370_noop
1464 #include "elf32-target.h"