projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Automatic date update in version.in
[deliverable/binutils-gdb.git] / bfd / elf32-i370.c
1 /* i370-specific support for 32-bit ELF
2 Copyright (C) 1994-2018 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Cygnus Support.
4 Hacked by Linas Vepstas for i370 linas@linas.org
5
6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
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.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
22
23 /* This file is based on a preliminary PowerPC ELF ABI.
24 But its been hacked on for the IBM 360/370 architectures.
25 Basically, the 31bit relocation works, and just about everything
26 else is a wild card. In particular, don't expect shared libs or
27 dynamic loading to work ... its never been tested. */
28
29 #include "sysdep.h"
30 #include "bfd.h"
31 #include "bfdlink.h"
32 #include "libbfd.h"
33 #include "elf-bfd.h"
34 #include "elf/i370.h"
35
36 static reloc_howto_type *i370_elf_howto_table[ (int)R_I370_max ];
37
38 static reloc_howto_type i370_elf_howto_raw[] =
39 {
40 /* This reloc does nothing. */
41 HOWTO (R_I370_NONE, /* type */
42 0, /* rightshift */
43 3, /* size (0 = byte, 1 = short, 2 = long) */
44 0, /* bitsize */
45 FALSE, /* pc_relative */
46 0, /* bitpos */
47 complain_overflow_dont, /* complain_on_overflow */
48 bfd_elf_generic_reloc, /* special_function */
49 "R_I370_NONE", /* name */
50 FALSE, /* partial_inplace */
51 0, /* src_mask */
52 0, /* dst_mask */
53 FALSE), /* pcrel_offset */
54
55 /* A standard 31 bit relocation. */
56 HOWTO (R_I370_ADDR31, /* type */
57 0, /* rightshift */
58 2, /* size (0 = byte, 1 = short, 2 = long) */
59 31, /* bitsize */
60 FALSE, /* pc_relative */
61 0, /* bitpos */
62 complain_overflow_bitfield, /* complain_on_overflow */
63 bfd_elf_generic_reloc, /* special_function */
64 "R_I370_ADDR31", /* name */
65 FALSE, /* partial_inplace */
66 0, /* src_mask */
67 0x7fffffff, /* dst_mask */
68 FALSE), /* pcrel_offset */
69
70 /* A standard 32 bit relocation. */
71 HOWTO (R_I370_ADDR32, /* 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_ADDR32", /* name */
80 FALSE, /* partial_inplace */
81 0, /* src_mask */
82 0xffffffff, /* dst_mask */
83 FALSE), /* pcrel_offset */
84
85 /* A standard 16 bit relocation. */
86 HOWTO (R_I370_ADDR16, /* type */
87 0, /* rightshift */
88 1, /* size (0 = byte, 1 = short, 2 = long) */
89 16, /* 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_ADDR16", /* name */
95 FALSE, /* partial_inplace */
96 0, /* src_mask */
97 0xffff, /* dst_mask */
98 FALSE), /* pcrel_offset */
99
100 /* 31-bit PC relative. */
101 HOWTO (R_I370_REL31, /* type */
102 0, /* rightshift */
103 2, /* size (0 = byte, 1 = short, 2 = long) */
104 31, /* bitsize */
105 TRUE, /* pc_relative */
106 0, /* bitpos */
107 complain_overflow_bitfield, /* complain_on_overflow */
108 bfd_elf_generic_reloc, /* special_function */
109 "R_I370_REL31", /* name */
110 FALSE, /* partial_inplace */
111 0, /* src_mask */
112 0x7fffffff, /* dst_mask */
113 TRUE), /* pcrel_offset */
114
115 /* 32-bit PC relative. */
116 HOWTO (R_I370_REL32, /* type */
117 0, /* rightshift */
118 2, /* size (0 = byte, 1 = short, 2 = long) */
119 32, /* bitsize */
120 TRUE, /* pc_relative */
121 0, /* bitpos */
122 complain_overflow_bitfield, /* complain_on_overflow */
123 bfd_elf_generic_reloc, /* special_function */
124 "R_I370_REL32", /* name */
125 FALSE, /* partial_inplace */
126 0, /* src_mask */
127 0xffffffff, /* dst_mask */
128 TRUE), /* pcrel_offset */
129
130 /* A standard 12 bit relocation. */
131 HOWTO (R_I370_ADDR12, /* type */
132 0, /* rightshift */
133 1, /* size (0 = byte, 1 = short, 2 = long) */
134 12, /* bitsize */
135 FALSE, /* pc_relative */
136 0, /* bitpos */
137 complain_overflow_bitfield, /* complain_on_overflow */
138 bfd_elf_generic_reloc, /* special_function */
139 "R_I370_ADDR12", /* name */
140 FALSE, /* partial_inplace */
141 0, /* src_mask */
142 0xfff, /* dst_mask */
143 FALSE), /* pcrel_offset */
144
145 /* 12-bit PC relative. */
146 HOWTO (R_I370_REL12, /* type */
147 0, /* rightshift */
148 1, /* size (0 = byte, 1 = short, 2 = long) */
149 12, /* 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_REL12", /* name */
155 FALSE, /* partial_inplace */
156 0, /* src_mask */
157 0xfff, /* dst_mask */
158 TRUE), /* pcrel_offset */
159
160 /* A standard 8 bit relocation. */
161 HOWTO (R_I370_ADDR8, /* type */
162 0, /* rightshift */
163 0, /* size (0 = byte, 1 = short, 2 = long) */
164 8, /* 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_ADDR8", /* name */
170 FALSE, /* partial_inplace */
171 0, /* src_mask */
172 0xff, /* dst_mask */
173 FALSE), /* pcrel_offset */
174
175 /* 8-bit PC relative. */
176 HOWTO (R_I370_REL8, /* type */
177 0, /* rightshift */
178 0, /* size (0 = byte, 1 = short, 2 = long) */
179 8, /* 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_REL8", /* name */
185 FALSE, /* partial_inplace */
186 0, /* src_mask */
187 0xff, /* dst_mask */
188 TRUE), /* pcrel_offset */
189
190 /* This is used only by the dynamic linker. The symbol should exist
191 both in the object being run and in some shared library. The
192 dynamic linker copies the data addressed by the symbol from the
193 shared library into the object, because the object being
194 run has to have the data at some particular address. */
195 HOWTO (R_I370_COPY, /* type */
196 0, /* rightshift */
197 2, /* size (0 = byte, 1 = short, 2 = long) */
198 32, /* bitsize */
199 FALSE, /* pc_relative */
200 0, /* bitpos */
201 complain_overflow_bitfield, /* complain_on_overflow */
202 bfd_elf_generic_reloc, /* special_function */
203 "R_I370_COPY", /* name */
204 FALSE, /* partial_inplace */
205 0, /* src_mask */
206 0, /* dst_mask */
207 FALSE), /* pcrel_offset */
208
209 /* Used only by the dynamic linker. When the object is run, this
210 longword is set to the load address of the object, plus the
211 addend. */
212 HOWTO (R_I370_RELATIVE, /* type */
213 0, /* rightshift */
214 2, /* size (0 = byte, 1 = short, 2 = long) */
215 32, /* bitsize */
216 FALSE, /* pc_relative */
217 0, /* bitpos */
218 complain_overflow_bitfield, /* complain_on_overflow */
219 bfd_elf_generic_reloc, /* special_function */
220 "R_I370_RELATIVE", /* name */
221 FALSE, /* partial_inplace */
222 0, /* src_mask */
223 0xffffffff, /* dst_mask */
224 FALSE), /* pcrel_offset */
225
226 };
227 \f
228 /* Initialize the i370_elf_howto_table, so that linear accesses can be done. */
229
230 static void
231 i370_elf_howto_init (void)
232 {
233 unsigned int i, type;
234
235 for (i = 0; i < sizeof (i370_elf_howto_raw) / sizeof (i370_elf_howto_raw[0]); i++)
236 {
237 type = i370_elf_howto_raw[i].type;
238 BFD_ASSERT (type < sizeof (i370_elf_howto_table) / sizeof (i370_elf_howto_table[0]));
239 i370_elf_howto_table[type] = &i370_elf_howto_raw[i];
240 }
241 }
242
243 static reloc_howto_type *
244 i370_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
245 bfd_reloc_code_real_type code)
246 {
247 enum i370_reloc_type i370_reloc = R_I370_NONE;
248
249 if (!i370_elf_howto_table[ R_I370_ADDR31 ])
250 /* Initialize howto table if needed. */
251 i370_elf_howto_init ();
252
253 switch ((int) code)
254 {
255 default:
256 return NULL;
257
258 case BFD_RELOC_NONE: i370_reloc = R_I370_NONE; break;
259 case BFD_RELOC_32: i370_reloc = R_I370_ADDR31; break;
260 case BFD_RELOC_16: i370_reloc = R_I370_ADDR16; break;
261 case BFD_RELOC_32_PCREL: i370_reloc = R_I370_REL31; break;
262 case BFD_RELOC_CTOR: i370_reloc = R_I370_ADDR31; break;
263 case BFD_RELOC_I370_D12: i370_reloc = R_I370_ADDR12; break;
264 }
265
266 return i370_elf_howto_table[ (int)i370_reloc ];
267 };
268
269 static reloc_howto_type *
270 i370_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
271 const char *r_name)
272 {
273 unsigned int i;
274
275 for (i = 0;
276 i < sizeof (i370_elf_howto_raw) / sizeof (i370_elf_howto_raw[0]);
277 i++)
278 if (i370_elf_howto_raw[i].name != NULL
279 && strcasecmp (i370_elf_howto_raw[i].name, r_name) == 0)
280 return &i370_elf_howto_raw[i];
281
282 return NULL;
283 }
284
285 /* The name of the dynamic interpreter. This is put in the .interp
286 section. */
287
288 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
289
290 /* Set the howto pointer for an i370 ELF reloc. */
291
292 static bfd_boolean
293 i370_elf_info_to_howto (bfd *abfd,
294 arelent *cache_ptr,
295 Elf_Internal_Rela *dst)
296 {
297 unsigned int r_type;
298
299 if (!i370_elf_howto_table[ R_I370_ADDR31 ])
300 /* Initialize howto table. */
301 i370_elf_howto_init ();
302
303 r_type = ELF32_R_TYPE (dst->r_info);
304 if (r_type >= R_I370_max)
305 {
306 /* xgettext:c-format */
307 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
308 abfd, r_type);
309 bfd_set_error (bfd_error_bad_value);
310 return FALSE;
311 }
312 cache_ptr->howto = i370_elf_howto_table[r_type];
313 return TRUE;
314 }
315
316 /* Hack alert -- the following several routines look generic to me ...
317 why are we bothering with them ? */
318 /* Function to set whether a module needs the -mrelocatable bit set. */
319
320 static bfd_boolean
321 i370_elf_set_private_flags (bfd *abfd, flagword flags)
322 {
323 BFD_ASSERT (!elf_flags_init (abfd)
324 || elf_elfheader (abfd)->e_flags == flags);
325
326 elf_elfheader (abfd)->e_flags = flags;
327 elf_flags_init (abfd) = TRUE;
328 return TRUE;
329 }
330
331 /* Merge backend specific data from an object file to the output
332 object file when linking. */
333
334 static bfd_boolean
335 i370_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
336 {
337 bfd *obfd = info->output_bfd;
338 flagword old_flags;
339 flagword new_flags;
340
341 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
342 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
343 return TRUE;
344
345 new_flags = elf_elfheader (ibfd)->e_flags;
346 old_flags = elf_elfheader (obfd)->e_flags;
347 if (!elf_flags_init (obfd)) /* First call, no flags set. */
348 {
349 elf_flags_init (obfd) = TRUE;
350 elf_elfheader (obfd)->e_flags = new_flags;
351 }
352
353 else if (new_flags == old_flags) /* Compatible flags are ok. */
354 ;
355
356 else /* Incompatible flags. */
357 {
358 _bfd_error_handler
359 /* xgettext:c-format */
360 (_("%pB: uses different e_flags (%#x) fields than previous modules (%#x)"),
361 ibfd, new_flags, old_flags);
362
363 bfd_set_error (bfd_error_bad_value);
364 return FALSE;
365 }
366
367 return TRUE;
368 }
369 \f
370 /* Handle an i370 specific section when reading an object file. This
371 is called when elfcode.h finds a section with an unknown type. */
372 /* XXX hack alert bogus This routine is mostly all junk and almost
373 certainly does the wrong thing. Its here simply because it does
374 just enough to allow glibc-2.1 ld.so to compile & link. */
375
376 static bfd_boolean
377 i370_elf_section_from_shdr (bfd *abfd,
378 Elf_Internal_Shdr *hdr,
379 const char *name,
380 int shindex)
381 {
382 asection *newsect;
383 flagword flags;
384
385 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
386 return FALSE;
387
388 newsect = hdr->bfd_section;
389 flags = bfd_get_section_flags (abfd, newsect);
390 if (hdr->sh_type == SHT_ORDERED)
391 flags |= SEC_SORT_ENTRIES;
392
393 bfd_set_section_flags (abfd, newsect, flags);
394 return TRUE;
395 }
396 \f
397 /* Set up any other section flags and such that may be necessary. */
398 /* XXX hack alert bogus This routine is mostly all junk and almost
399 certainly does the wrong thing. Its here simply because it does
400 just enough to allow glibc-2.1 ld.so to compile & link. */
401
402 static bfd_boolean
403 i370_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
404 Elf_Internal_Shdr *shdr,
405 asection *asect)
406 {
407 if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE)
408 shdr->sh_flags |= SHF_EXCLUDE;
409
410 if ((asect->flags & SEC_SORT_ENTRIES) != 0)
411 shdr->sh_type = SHT_ORDERED;
412
413 return TRUE;
414 }
415 \f
416 /* We have to create .dynsbss and .rela.sbss here so that they get mapped
417 to output sections (just like _bfd_elf_create_dynamic_sections has
418 to create .dynbss and .rela.bss). */
419 /* XXX hack alert bogus This routine is mostly all junk and almost
420 certainly does the wrong thing. Its here simply because it does
421 just enough to allow glibc-2.1 ld.so to compile & link. */
422
423 static bfd_boolean
424 i370_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
425 {
426 asection *s;
427 flagword flags;
428
429 if (!_bfd_elf_create_dynamic_sections(abfd, info))
430 return FALSE;
431
432 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
433 | SEC_LINKER_CREATED);
434
435 s = bfd_make_section_anyway_with_flags (abfd, ".dynsbss",
436 SEC_ALLOC | SEC_LINKER_CREATED);
437 if (s == NULL)
438 return FALSE;
439
440 if (! bfd_link_pic (info))
441 {
442 s = bfd_make_section_anyway_with_flags (abfd, ".rela.sbss",
443 flags | SEC_READONLY);
444 if (s == NULL
445 || ! bfd_set_section_alignment (abfd, s, 2))
446 return FALSE;
447 }
448
449 /* XXX beats me, seem to need a rela.text ... */
450 s = bfd_make_section_anyway_with_flags (abfd, ".rela.text",
451 flags | SEC_READONLY);
452 if (s == NULL
453 || ! bfd_set_section_alignment (abfd, s, 2))
454 return FALSE;
455 return TRUE;
456 }
457
458 /* Adjust a symbol defined by a dynamic object and referenced by a
459 regular object. The current definition is in some section of the
460 dynamic object, but we're not including those sections. We have to
461 change the definition to something the rest of the link can
462 understand. */
463 /* XXX hack alert bogus This routine is mostly all junk and almost
464 certainly does the wrong thing. Its here simply because it does
465 just enough to allow glibc-2.1 ld.so to compile & link. */
466
467 static bfd_boolean
468 i370_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
469 struct elf_link_hash_entry *h)
470 {
471 bfd *dynobj = elf_hash_table (info)->dynobj;
472 asection *s;
473
474 #ifdef DEBUG
475 fprintf (stderr, "i370_elf_adjust_dynamic_symbol called for %s\n",
476 h->root.root.string);
477 #endif
478
479 /* Make sure we know what is going on here. */
480 BFD_ASSERT (dynobj != NULL
481 && (h->needs_plt
482 || h->is_weakalias
483 || (h->def_dynamic
484 && h->ref_regular
485 && !h->def_regular)));
486
487 s = bfd_get_linker_section (dynobj, ".rela.text");
488 BFD_ASSERT (s != NULL);
489 s->size += sizeof (Elf32_External_Rela);
490
491 /* If this is a weak symbol, and there is a real definition, the
492 processor independent code will have arranged for us to see the
493 real definition first, and we can just use the same value. */
494 if (h->is_weakalias)
495 {
496 struct elf_link_hash_entry *def = weakdef (h);
497 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
498 h->root.u.def.section = def->root.u.def.section;
499 h->root.u.def.value = def->root.u.def.value;
500 return TRUE;
501 }
502
503 /* This is a reference to a symbol defined by a dynamic object which
504 is not a function. */
505
506 /* If we are creating a shared library, we must presume that the
507 only references to the symbol are via the global offset table.
508 For such cases we need not do anything here; the relocations will
509 be handled correctly by relocate_section. */
510 if (bfd_link_pic (info))
511 return TRUE;
512
513 /* We must allocate the symbol in our .dynbss section, which will
514 become part of the .bss section of the executable. There will be
515 an entry for this symbol in the .dynsym section. The dynamic
516 object will contain position independent code, so all references
517 from the dynamic object to this symbol will go through the global
518 offset table. The dynamic linker will use the .dynsym entry to
519 determine the address it must put in the global offset table, so
520 both the dynamic object and the regular object will refer to the
521 same memory location for the variable.
522
523 Of course, if the symbol is sufficiently small, we must instead
524 allocate it in .sbss. FIXME: It would be better to do this if and
525 only if there were actually SDAREL relocs for that symbol. */
526
527 if (h->size <= elf_gp_size (dynobj))
528 s = bfd_get_linker_section (dynobj, ".dynsbss");
529 else
530 s = bfd_get_linker_section (dynobj, ".dynbss");
531 BFD_ASSERT (s != NULL);
532
533 /* We must generate a R_I370_COPY reloc to tell the dynamic linker to
534 copy the initial value out of the dynamic object and into the
535 runtime process image. We need to remember the offset into the
536 .rela.bss section we are going to use. */
537 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
538 {
539 asection *srel;
540
541 if (h->size <= elf_gp_size (dynobj))
542 srel = bfd_get_linker_section (dynobj, ".rela.sbss");
543 else
544 srel = bfd_get_linker_section (dynobj, ".rela.bss");
545 BFD_ASSERT (srel != NULL);
546 srel->size += sizeof (Elf32_External_Rela);
547 h->needs_copy = 1;
548 }
549
550 return _bfd_elf_adjust_dynamic_copy (info, h, s);
551 }
552 \f
553 /* Increment the index of a dynamic symbol by a given amount. Called
554 via elf_link_hash_traverse. */
555 /* XXX hack alert bogus This routine is mostly all junk and almost
556 certainly does the wrong thing. Its here simply because it does
557 just enough to allow glibc-2.1 ld.so to compile & link. */
558
559 static bfd_boolean
560 i370_elf_adjust_dynindx (struct elf_link_hash_entry *h, void * cparg)
561 {
562 int *cp = (int *) cparg;
563
564 #ifdef DEBUG
565 fprintf (stderr,
566 "i370_elf_adjust_dynindx called, h->dynindx = %ld, *cp = %d\n",
567 h->dynindx, *cp);
568 #endif
569
570 if (h->dynindx != -1)
571 h->dynindx += *cp;
572
573 return TRUE;
574 }
575 \f
576 /* Set the sizes of the dynamic sections. */
577 /* XXX hack alert bogus This routine is mostly all junk and almost
578 certainly does the wrong thing. Its here simply because it does
579 just enough to allow glibc-2.1 ld.so to compile & link. */
580
581 static bfd_boolean
582 i370_elf_size_dynamic_sections (bfd *output_bfd,
583 struct bfd_link_info *info)
584 {
585 bfd *dynobj;
586 asection *s;
587 bfd_boolean plt;
588 bfd_boolean relocs;
589 bfd_boolean reltext;
590
591 #ifdef DEBUG
592 fprintf (stderr, "i370_elf_size_dynamic_sections called\n");
593 #endif
594
595 dynobj = elf_hash_table (info)->dynobj;
596 BFD_ASSERT (dynobj != NULL);
597
598 if (elf_hash_table (info)->dynamic_sections_created)
599 {
600 /* Set the contents of the .interp section to the interpreter. */
601 if (bfd_link_executable (info) && !info->nointerp)
602 {
603 s = bfd_get_linker_section (dynobj, ".interp");
604 BFD_ASSERT (s != NULL);
605 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
606 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
607 }
608 }
609 else
610 {
611 /* We may have created entries in the .rela.got, .rela.sdata, and
612 .rela.sdata2 sections. However, if we are not creating the
613 dynamic sections, we will not actually use these entries. Reset
614 the size of .rela.got, et al, which will cause it to get
615 stripped from the output file below. */
616 static char *rela_sections[] = { ".rela.got", ".rela.sdata",
617 ".rela.sdata2", ".rela.sbss",
618 NULL };
619 char **p;
620
621 for (p = rela_sections; *p != NULL; p++)
622 {
623 s = bfd_get_linker_section (dynobj, *p);
624 if (s != NULL)
625 s->size = 0;
626 }
627 }
628
629 /* The check_relocs and adjust_dynamic_symbol entry points have
630 determined the sizes of the various dynamic sections. Allocate
631 memory for them. */
632 plt = FALSE;
633 relocs = FALSE;
634 reltext = FALSE;
635 for (s = dynobj->sections; s != NULL; s = s->next)
636 {
637 const char *name;
638
639 if ((s->flags & SEC_LINKER_CREATED) == 0)
640 continue;
641
642 /* It's OK to base decisions on the section name, because none
643 of the dynobj section names depend upon the input files. */
644 name = bfd_get_section_name (dynobj, s);
645
646 if (strcmp (name, ".plt") == 0)
647 {
648 /* Remember whether there is a PLT. */
649 plt = s->size != 0;
650 }
651 else if (CONST_STRNEQ (name, ".rela"))
652 {
653 if (s->size != 0)
654 {
655 asection *target;
656 const char *outname;
657
658 /* Remember whether there are any relocation sections. */
659 relocs = TRUE;
660
661 /* If this relocation section applies to a read only
662 section, then we probably need a DT_TEXTREL entry. */
663 outname = bfd_get_section_name (output_bfd,
664 s->output_section);
665 target = bfd_get_section_by_name (output_bfd, outname + 5);
666 if (target != NULL
667 && (target->flags & SEC_READONLY) != 0
668 && (target->flags & SEC_ALLOC) != 0)
669 reltext = TRUE;
670
671 /* We use the reloc_count field as a counter if we need
672 to copy relocs into the output file. */
673 s->reloc_count = 0;
674 }
675 }
676 else if (strcmp (name, ".got") != 0
677 && strcmp (name, ".sdata") != 0
678 && strcmp (name, ".sdata2") != 0
679 && strcmp (name, ".dynbss") != 0
680 && strcmp (name, ".dynsbss") != 0)
681 {
682 /* It's not one of our sections, so don't allocate space. */
683 continue;
684 }
685
686 if (s->size == 0)
687 {
688 /* If we don't need this section, strip it from the
689 output file. This is mostly to handle .rela.bss and
690 .rela.plt. We must create both sections in
691 create_dynamic_sections, because they must be created
692 before the linker maps input sections to output
693 sections. The linker does that before
694 adjust_dynamic_symbol is called, and it is that
695 function which decides whether anything needs to go
696 into these sections. */
697 s->flags |= SEC_EXCLUDE;
698 continue;
699 }
700
701 if ((s->flags & SEC_HAS_CONTENTS) == 0)
702 continue;
703
704 /* Allocate memory for the section contents. */
705 s->contents = bfd_zalloc (dynobj, s->size);
706 if (s->contents == NULL)
707 return FALSE;
708 }
709
710 if (elf_hash_table (info)->dynamic_sections_created)
711 {
712 /* Add some entries to the .dynamic section. We fill in the
713 values later, in i370_elf_finish_dynamic_sections, but we
714 must add the entries now so that we get the correct size for
715 the .dynamic section. The DT_DEBUG entry is filled in by the
716 dynamic linker and used by the debugger. */
717 #define add_dynamic_entry(TAG, VAL) \
718 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
719
720 if (!bfd_link_pic (info))
721 {
722 if (!add_dynamic_entry (DT_DEBUG, 0))
723 return FALSE;
724 }
725
726 if (plt)
727 {
728 if (!add_dynamic_entry (DT_PLTGOT, 0)
729 || !add_dynamic_entry (DT_PLTRELSZ, 0)
730 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
731 || !add_dynamic_entry (DT_JMPREL, 0))
732 return FALSE;
733 }
734
735 if (relocs)
736 {
737 if (!add_dynamic_entry (DT_RELA, 0)
738 || !add_dynamic_entry (DT_RELASZ, 0)
739 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
740 return FALSE;
741 }
742
743 if (reltext)
744 {
745 if (!add_dynamic_entry (DT_TEXTREL, 0))
746 return FALSE;
747 info->flags |= DF_TEXTREL;
748 }
749 }
750 #undef add_dynamic_entry
751
752 /* If we are generating a shared library, we generate a section
753 symbol for each output section. These are local symbols, which
754 means that they must come first in the dynamic symbol table.
755 That means we must increment the dynamic symbol index of every
756 other dynamic symbol.
757
758 FIXME: We assume that there will never be relocations to
759 locations in linker-created sections that do not have
760 externally-visible names. Instead, we should work out precisely
761 which sections relocations are targeted at. */
762 if (bfd_link_pic (info))
763 {
764 int c;
765
766 for (c = 0, s = output_bfd->sections; s != NULL; s = s->next)
767 {
768 if ((s->flags & SEC_LINKER_CREATED) != 0
769 || (s->flags & SEC_ALLOC) == 0)
770 {
771 elf_section_data (s)->dynindx = -1;
772 continue;
773 }
774
775 /* These symbols will have no names, so we don't need to
776 fiddle with dynstr_index. */
777
778 elf_section_data (s)->dynindx = c + 1;
779
780 c++;
781 }
782
783 elf_link_hash_traverse (elf_hash_table (info),
784 i370_elf_adjust_dynindx, & c);
785 elf_hash_table (info)->dynsymcount += c;
786 }
787
788 return TRUE;
789 }
790 \f
791 /* Look through the relocs for a section during the first phase, and
792 allocate space in the global offset table or procedure linkage
793 table. */
794 /* XXX hack alert bogus This routine is mostly all junk and almost
795 certainly does the wrong thing. Its here simply because it does
796 just enough to allow glibc-2.1 ld.so to compile & link. */
797
798 static bfd_boolean
799 i370_elf_check_relocs (bfd *abfd,
800 struct bfd_link_info *info,
801 asection *sec,
802 const Elf_Internal_Rela *relocs)
803 {
804 bfd *dynobj;
805 Elf_Internal_Shdr *symtab_hdr;
806 struct elf_link_hash_entry **sym_hashes;
807 const Elf_Internal_Rela *rel;
808 const Elf_Internal_Rela *rel_end;
809 asection *sreloc;
810
811 if (bfd_link_relocatable (info))
812 return TRUE;
813
814 #ifdef DEBUG
815 _bfd_error_handler ("i370_elf_check_relocs called for section %pA in %pB",
816 sec, abfd);
817 #endif
818
819 dynobj = elf_hash_table (info)->dynobj;
820 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
821 sym_hashes = elf_sym_hashes (abfd);
822
823 sreloc = NULL;
824
825 rel_end = relocs + sec->reloc_count;
826 for (rel = relocs; rel < rel_end; rel++)
827 {
828 unsigned long r_symndx;
829 struct elf_link_hash_entry *h;
830
831 r_symndx = ELF32_R_SYM (rel->r_info);
832 if (r_symndx < symtab_hdr->sh_info)
833 h = NULL;
834 else
835 {
836 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
837 while (h->root.type == bfd_link_hash_indirect
838 || h->root.type == bfd_link_hash_warning)
839 h = (struct elf_link_hash_entry *) h->root.u.i.link;
840 }
841
842 if (bfd_link_pic (info))
843 {
844 #ifdef DEBUG
845 fprintf (stderr,
846 "i370_elf_check_relocs needs to create relocation for %s\n",
847 (h && h->root.root.string)
848 ? h->root.root.string : "<unknown>");
849 #endif
850 if (sreloc == NULL)
851 {
852 sreloc = _bfd_elf_make_dynamic_reloc_section
853 (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
854
855 if (sreloc == NULL)
856 return FALSE;
857 }
858
859 sreloc->size += sizeof (Elf32_External_Rela);
860
861 /* FIXME: We should here do what the m68k and i386
862 backends do: if the reloc is pc-relative, record it
863 in case it turns out that the reloc is unnecessary
864 because the symbol is forced local by versioning or
865 we are linking with -Bdynamic. Fortunately this
866 case is not frequent. */
867 }
868 }
869
870 return TRUE;
871 }
872 \f
873 /* Finish up the dynamic sections. */
874 /* XXX hack alert bogus This routine is mostly all junk and almost
875 certainly does the wrong thing. Its here simply because it does
876 just enough to allow glibc-2.1 ld.so to compile & link. */
877
878 static bfd_boolean
879 i370_elf_finish_dynamic_sections (bfd *output_bfd,
880 struct bfd_link_info *info)
881 {
882 asection *sdyn;
883 bfd *dynobj = elf_hash_table (info)->dynobj;
884 asection *sgot = elf_hash_table (info)->sgot;
885
886 #ifdef DEBUG
887 fprintf (stderr, "i370_elf_finish_dynamic_sections called\n");
888 #endif
889
890 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
891
892 if (elf_hash_table (info)->dynamic_sections_created)
893 {
894 asection *splt;
895 Elf32_External_Dyn *dyncon, *dynconend;
896
897 splt = elf_hash_table (info)->splt;
898 BFD_ASSERT (splt != NULL && sdyn != NULL);
899
900 dyncon = (Elf32_External_Dyn *) sdyn->contents;
901 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
902 for (; dyncon < dynconend; dyncon++)
903 {
904 Elf_Internal_Dyn dyn;
905 asection *s;
906 bfd_boolean size;
907
908 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
909
910 switch (dyn.d_tag)
911 {
912 case DT_PLTGOT:
913 s = elf_hash_table (info)->splt;
914 size = FALSE;
915 break;
916 case DT_PLTRELSZ:
917 s = elf_hash_table (info)->srelplt;
918 size = TRUE;
919 break;
920 case DT_JMPREL:
921 s = elf_hash_table (info)->srelplt;
922 size = FALSE;
923 break;
924 default:
925 continue;
926 }
927
928 if (s == NULL)
929 dyn.d_un.d_val = 0;
930 else
931 {
932 if (!size)
933 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
934 else
935 dyn.d_un.d_val = s->size;
936 }
937 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
938 }
939 }
940
941 if (sgot && sgot->size != 0)
942 {
943 unsigned char *contents = sgot->contents;
944
945 if (sdyn == NULL)
946 bfd_put_32 (output_bfd, (bfd_vma) 0, contents);
947 else
948 bfd_put_32 (output_bfd,
949 sdyn->output_section->vma + sdyn->output_offset,
950 contents);
951
952 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
953 }
954
955 if (bfd_link_pic (info))
956 {
957 asection *sdynsym;
958 asection *s;
959 Elf_Internal_Sym sym;
960 int maxdindx = 0;
961
962 /* Set up the section symbols for the output sections. */
963
964 sdynsym = bfd_get_linker_section (dynobj, ".dynsym");
965 BFD_ASSERT (sdynsym != NULL);
966
967 sym.st_size = 0;
968 sym.st_name = 0;
969 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
970 sym.st_other = 0;
971 sym.st_target_internal = 0;
972
973 for (s = output_bfd->sections; s != NULL; s = s->next)
974 {
975 int indx, dindx;
976 Elf32_External_Sym *esym;
977
978 sym.st_value = s->vma;
979
980 indx = elf_section_data (s)->this_idx;
981 dindx = elf_section_data (s)->dynindx;
982 if (dindx != -1)
983 {
984 BFD_ASSERT(indx > 0);
985 BFD_ASSERT(dindx > 0);
986
987 if (dindx > maxdindx)
988 maxdindx = dindx;
989
990 sym.st_shndx = indx;
991
992 esym = (Elf32_External_Sym *) sdynsym->contents + dindx;
993 bfd_elf32_swap_symbol_out (output_bfd, &sym, esym, NULL);
994 }
995 }
996
997 /* Set the sh_info field of the output .dynsym section to the
998 index of the first global symbol. */
999 elf_section_data (sdynsym->output_section)->this_hdr.sh_info =
1000 maxdindx + 1;
1001 }
1002
1003 return TRUE;
1004 }
1005 \f
1006 /* The RELOCATE_SECTION function is called by the ELF backend linker
1007 to handle the relocations for a section.
1008
1009 The relocs are always passed as Rela structures; if the section
1010 actually uses Rel structures, the r_addend field will always be
1011 zero.
1012
1013 This function is responsible for adjust the section contents as
1014 necessary, and (if using Rela relocs and generating a
1015 relocatable output file) adjusting the reloc addend as
1016 necessary.
1017
1018 This function does not have to worry about setting the reloc
1019 address or the reloc symbol index.
1020
1021 LOCAL_SYMS is a pointer to the swapped in local symbols.
1022
1023 LOCAL_SECTIONS is an array giving the section in the input file
1024 corresponding to the st_shndx field of each local symbol.
1025
1026 The global hash table entry for the global symbols can be found
1027 via elf_sym_hashes (input_bfd).
1028
1029 When generating relocatable output, this function must handle
1030 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1031 going to be the section symbol corresponding to the output
1032 section, which means that the addend must be adjusted
1033 accordingly. */
1034
1035 static bfd_boolean
1036 i370_elf_relocate_section (bfd *output_bfd,
1037 struct bfd_link_info *info,
1038 bfd *input_bfd,
1039 asection *input_section,
1040 bfd_byte *contents,
1041 Elf_Internal_Rela *relocs,
1042 Elf_Internal_Sym *local_syms,
1043 asection **local_sections)
1044 {
1045 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1046 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
1047 Elf_Internal_Rela *rel = relocs;
1048 Elf_Internal_Rela *relend = relocs + input_section->reloc_count;
1049 asection *sreloc = NULL;
1050 bfd_boolean ret = TRUE;
1051
1052 #ifdef DEBUG
1053 _bfd_error_handler ("i370_elf_relocate_section called for %pB section %pA, %u relocations%s",
1054 input_bfd, input_section,
1055 input_section->reloc_count,
1056 (bfd_link_relocatable (info)) ? " (relocatable)" : "");
1057 #endif
1058
1059 if (!i370_elf_howto_table[ R_I370_ADDR31 ])
1060 /* Initialize howto table if needed. */
1061 i370_elf_howto_init ();
1062
1063 for (; rel < relend; rel++)
1064 {
1065 enum i370_reloc_type r_type = (enum i370_reloc_type) ELF32_R_TYPE (rel->r_info);
1066 bfd_vma offset = rel->r_offset;
1067 bfd_vma addend = rel->r_addend;
1068 bfd_reloc_status_type r = bfd_reloc_other;
1069 Elf_Internal_Sym *sym = NULL;
1070 asection *sec = NULL;
1071 struct elf_link_hash_entry * h = NULL;
1072 reloc_howto_type *howto;
1073 unsigned long r_symndx;
1074 bfd_vma relocation;
1075
1076 /* Unknown relocation handling. */
1077 if ((unsigned) r_type >= (unsigned) R_I370_max
1078 || !i370_elf_howto_table[(int)r_type])
1079 {
1080 /* xgettext:c-format */
1081 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1082 input_bfd, (int) r_type);
1083
1084 bfd_set_error (bfd_error_bad_value);
1085 ret = FALSE;
1086 continue;
1087 }
1088
1089 howto = i370_elf_howto_table[(int) r_type];
1090 r_symndx = ELF32_R_SYM (rel->r_info);
1091 relocation = 0;
1092
1093 if (r_symndx < symtab_hdr->sh_info)
1094 {
1095 sym = local_syms + r_symndx;
1096 sec = local_sections[r_symndx];
1097
1098 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, & sec, rel);
1099 addend = rel->r_addend;
1100 }
1101 else
1102 {
1103 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1104
1105 if (info->wrap_hash != NULL
1106 && (input_section->flags & SEC_DEBUGGING) != 0)
1107 h = ((struct elf_link_hash_entry *)
1108 unwrap_hash_lookup (info, input_bfd, &h->root));
1109
1110 while (h->root.type == bfd_link_hash_indirect
1111 || h->root.type == bfd_link_hash_warning)
1112 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1113 if (h->root.type == bfd_link_hash_defined
1114 || h->root.type == bfd_link_hash_defweak)
1115 {
1116 sec = h->root.u.def.section;
1117 if (bfd_link_pic (info)
1118 && ((! info->symbolic && h->dynindx != -1)
1119 || !h->def_regular)
1120 && (input_section->flags & SEC_ALLOC) != 0
1121 && (r_type == R_I370_ADDR31
1122 || r_type == R_I370_COPY
1123 || r_type == R_I370_ADDR16
1124 || r_type == R_I370_RELATIVE))
1125 /* In these cases, we don't need the relocation
1126 value. We check specially because in some
1127 obscure cases sec->output_section will be NULL. */
1128 ;
1129 else
1130 relocation = (h->root.u.def.value
1131 + sec->output_section->vma
1132 + sec->output_offset);
1133 }
1134 else if (h->root.type == bfd_link_hash_undefweak)
1135 ;
1136 else if (info->unresolved_syms_in_objects == RM_IGNORE
1137 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1138 ;
1139 else if (!bfd_link_relocatable (info))
1140 {
1141 (*info->callbacks->undefined_symbol)
1142 (info, h->root.root.string, input_bfd,
1143 input_section, rel->r_offset,
1144 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
1145 || ELF_ST_VISIBILITY (h->other)));
1146 ret = FALSE;
1147 continue;
1148 }
1149 }
1150
1151 if (sec != NULL && discarded_section (sec))
1152 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1153 rel, 1, relend, howto, 0, contents);
1154
1155 if (bfd_link_relocatable (info))
1156 continue;
1157
1158 switch ((int) r_type)
1159 {
1160 default:
1161 _bfd_error_handler
1162 (_("%pB: unsupported relocation type %#x"),
1163 input_bfd, (int) r_type);
1164
1165 bfd_set_error (bfd_error_bad_value);
1166 ret = FALSE;
1167 continue;
1168
1169 case (int) R_I370_NONE:
1170 continue;
1171
1172 /* Relocations that may need to be propagated if this is a shared
1173 object. */
1174 case (int) R_I370_REL31:
1175 /* If these relocations are not to a named symbol, they can be
1176 handled right here, no need to bother the dynamic linker. */
1177 if (h == NULL
1178 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1179 break;
1180 /* Fall through. */
1181
1182 /* Relocations that always need to be propagated if this is a shared
1183 object. */
1184 case (int) R_I370_ADDR31:
1185 case (int) R_I370_ADDR16:
1186 if (bfd_link_pic (info)
1187 && r_symndx != STN_UNDEF)
1188 {
1189 Elf_Internal_Rela outrel;
1190 bfd_byte *loc;
1191 int skip;
1192
1193 #ifdef DEBUG
1194 fprintf (stderr,
1195 "i370_elf_relocate_section needs to create relocation for %s\n",
1196 (h && h->root.root.string) ? h->root.root.string : "<unknown>");
1197 #endif
1198
1199 /* When generating a shared object, these relocations
1200 are copied into the output file to be resolved at run
1201 time. */
1202
1203 if (sreloc == NULL)
1204 {
1205 sreloc = _bfd_elf_get_dynamic_reloc_section
1206 (input_bfd, input_section, /*rela?*/ TRUE);
1207 if (sreloc == NULL)
1208 return FALSE;
1209 }
1210
1211 skip = 0;
1212
1213 outrel.r_offset =
1214 _bfd_elf_section_offset (output_bfd, info, input_section,
1215 rel->r_offset);
1216 if (outrel.r_offset == (bfd_vma) -1
1217 || outrel.r_offset == (bfd_vma) -2)
1218 skip = (int) outrel.r_offset;
1219 outrel.r_offset += (input_section->output_section->vma
1220 + input_section->output_offset);
1221
1222 if (skip)
1223 memset (&outrel, 0, sizeof outrel);
1224 /* h->dynindx may be -1 if this symbol was marked to
1225 become local. */
1226 else if (h != NULL
1227 && ((! info->symbolic && h->dynindx != -1)
1228 || !h->def_regular))
1229 {
1230 BFD_ASSERT (h->dynindx != -1);
1231 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1232 outrel.r_addend = rel->r_addend;
1233 }
1234 else
1235 {
1236 if (r_type == R_I370_ADDR31)
1237 {
1238 outrel.r_info = ELF32_R_INFO (0, R_I370_RELATIVE);
1239 outrel.r_addend = relocation + rel->r_addend;
1240 }
1241 else
1242 {
1243 long indx;
1244
1245 if (bfd_is_abs_section (sec))
1246 indx = 0;
1247 else if (sec == NULL || sec->owner == NULL)
1248 {
1249 bfd_set_error (bfd_error_bad_value);
1250 return FALSE;
1251 }
1252 else
1253 {
1254 asection *osec;
1255
1256 /* We are turning this relocation into one
1257 against a section symbol. It would be
1258 proper to subtract the symbol's value,
1259 osec->vma, from the emitted reloc addend,
1260 but ld.so expects buggy relocs. */
1261 osec = sec->output_section;
1262 indx = elf_section_data (osec)->dynindx;
1263 if (indx == 0)
1264 {
1265 struct elf_link_hash_table *htab;
1266 htab = elf_hash_table (info);
1267 osec = htab->text_index_section;
1268 indx = elf_section_data (osec)->dynindx;
1269 }
1270 BFD_ASSERT (indx != 0);
1271 #ifdef DEBUG
1272 if (indx <= 0)
1273 {
1274 printf ("indx=%ld section=%s flags=%08x name=%s\n",
1275 indx, osec->name, osec->flags,
1276 h->root.root.string);
1277 }
1278 #endif
1279 }
1280
1281 outrel.r_info = ELF32_R_INFO (indx, r_type);
1282 outrel.r_addend = relocation + rel->r_addend;
1283 }
1284 }
1285
1286 loc = sreloc->contents;
1287 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1288 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1289
1290 /* This reloc will be computed at runtime, so there's no
1291 need to do anything now, unless this is a RELATIVE
1292 reloc in an unallocated section. */
1293 if (skip == -1
1294 || (input_section->flags & SEC_ALLOC) != 0
1295 || ELF32_R_TYPE (outrel.r_info) != R_I370_RELATIVE)
1296 continue;
1297 }
1298 break;
1299
1300 case (int) R_I370_COPY:
1301 case (int) R_I370_RELATIVE:
1302 /* xgettext:c-format */
1303 _bfd_error_handler (_("%pB: %s unsupported"),
1304 input_bfd,
1305 i370_elf_howto_table[(int) r_type]->name);
1306 bfd_set_error (bfd_error_invalid_operation);
1307 ret = FALSE;
1308 continue;
1309 }
1310
1311 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
1312 offset, relocation, addend);
1313
1314 if (r != bfd_reloc_ok)
1315 {
1316 ret = FALSE;
1317 switch (r)
1318 {
1319 default:
1320 break;
1321
1322 case bfd_reloc_overflow:
1323 {
1324 const char *name;
1325
1326 if (h != NULL)
1327 name = NULL;
1328 else
1329 {
1330 name = bfd_elf_string_from_elf_section (input_bfd,
1331 symtab_hdr->sh_link,
1332 sym->st_name);
1333 if (name == NULL)
1334 break;
1335
1336 if (*name == '\0')
1337 name = bfd_section_name (input_bfd, sec);
1338 }
1339
1340 (*info->callbacks->reloc_overflow) (info,
1341 (h ? &h->root : NULL),
1342 name,
1343 howto->name,
1344 (bfd_vma) 0,
1345 input_bfd,
1346 input_section,
1347 offset);
1348 }
1349 break;
1350 }
1351 }
1352 }
1353
1354 #ifdef DEBUG
1355 fprintf (stderr, "\n");
1356 #endif
1357
1358 return ret;
1359 }
1360 \f
1361 #define TARGET_BIG_SYM i370_elf32_vec
1362 #define TARGET_BIG_NAME "elf32-i370"
1363 #define ELF_ARCH bfd_arch_i370
1364 #define ELF_MACHINE_CODE EM_S370
1365 #ifdef EM_I370_OLD
1366 #define ELF_MACHINE_ALT1 EM_I370_OLD
1367 #endif
1368 #define ELF_MAXPAGESIZE 0x1000
1369 #define ELF_OSABI ELFOSABI_GNU
1370
1371 #define elf_info_to_howto i370_elf_info_to_howto
1372
1373 #define elf_backend_plt_not_loaded 1
1374 #define elf_backend_rela_normal 1
1375
1376 #define bfd_elf32_bfd_reloc_type_lookup i370_elf_reloc_type_lookup
1377 #define bfd_elf32_bfd_reloc_name_lookup i370_elf_reloc_name_lookup
1378 #define bfd_elf32_bfd_set_private_flags i370_elf_set_private_flags
1379 #define bfd_elf32_bfd_merge_private_bfd_data i370_elf_merge_private_bfd_data
1380 #define elf_backend_relocate_section i370_elf_relocate_section
1381
1382 /* Dynamic loader support is mostly broken; just enough here to be able to
1383 link glibc's ld.so without errors. */
1384 #define elf_backend_create_dynamic_sections i370_elf_create_dynamic_sections
1385 #define elf_backend_size_dynamic_sections i370_elf_size_dynamic_sections
1386 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
1387 #define elf_backend_finish_dynamic_sections i370_elf_finish_dynamic_sections
1388 #define elf_backend_fake_sections i370_elf_fake_sections
1389 #define elf_backend_section_from_shdr i370_elf_section_from_shdr
1390 #define elf_backend_adjust_dynamic_symbol i370_elf_adjust_dynamic_symbol
1391 #define elf_backend_check_relocs i370_elf_check_relocs
1392
1393 static bfd_boolean
1394 i370_noop (bfd * abfd ATTRIBUTE_UNUSED, ...)
1395 {
1396 return TRUE;
1397 }
1398
1399 #define elf_backend_finish_dynamic_symbol \
1400 (bfd_boolean (*) \
1401 (bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, \
1402 Elf_Internal_Sym *)) i370_noop
1403
1404 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.059222 seconds and 4 git commands to generate.