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