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-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
1094 if (info->wrap_hash != NULL
1095 && (input_section->flags & SEC_DEBUGGING) != 0)
1096 h = ((struct elf_link_hash_entry *)
1097 unwrap_hash_lookup (info, input_bfd, &h->root));
1098
1099 while (h->root.type == bfd_link_hash_indirect
1100 || h->root.type == bfd_link_hash_warning)
1101 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1102 sym_name = h->root.root.string;
1103 if (h->root.type == bfd_link_hash_defined
1104 || h->root.type == bfd_link_hash_defweak)
1105 {
1106 sec = h->root.u.def.section;
1107 if (info->shared
1108 && ((! info->symbolic && h->dynindx != -1)
1109 || !h->def_regular)
1110 && (input_section->flags & SEC_ALLOC) != 0
1111 && (r_type == R_I370_ADDR31
1112 || r_type == R_I370_COPY
1113 || r_type == R_I370_ADDR16
1114 || r_type == R_I370_RELATIVE))
1115 /* In these cases, we don't need the relocation
1116 value. We check specially because in some
1117 obscure cases sec->output_section will be NULL. */
1118 ;
1119 else
1120 relocation = (h->root.u.def.value
1121 + sec->output_section->vma
1122 + sec->output_offset);
1123 }
1124 else if (h->root.type == bfd_link_hash_undefweak)
1125 ;
1126 else if (info->unresolved_syms_in_objects == RM_IGNORE
1127 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1128 ;
1129 else if (!info->relocatable)
1130 {
1131 if ((*info->callbacks->undefined_symbol)
1132 (info, h->root.root.string, input_bfd,
1133 input_section, rel->r_offset,
1134 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
1135 || ELF_ST_VISIBILITY (h->other))))
1136 {
1137 ret = FALSE;
1138 continue;
1139 }
1140 }
1141 }
1142
1143 if (sec != NULL && discarded_section (sec))
1144 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1145 rel, 1, relend, howto, 0, contents);
1146
1147 if (info->relocatable)
1148 continue;
1149
1150 switch ((int) r_type)
1151 {
1152 default:
1153 (*_bfd_error_handler)
1154 ("%B: unknown relocation type %d for symbol %s",
1155 input_bfd, (int) r_type, sym_name);
1156
1157 bfd_set_error (bfd_error_bad_value);
1158 ret = FALSE;
1159 continue;
1160
1161 case (int) R_I370_NONE:
1162 continue;
1163
1164 /* Relocations that may need to be propagated if this is a shared
1165 object. */
1166 case (int) R_I370_REL31:
1167 /* If these relocations are not to a named symbol, they can be
1168 handled right here, no need to bother the dynamic linker. */
1169 if (h == NULL
1170 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1171 break;
1172 /* Fall through. */
1173
1174 /* Relocations that always need to be propagated if this is a shared
1175 object. */
1176 case (int) R_I370_ADDR31:
1177 case (int) R_I370_ADDR16:
1178 if (info->shared
1179 && r_symndx != STN_UNDEF)
1180 {
1181 Elf_Internal_Rela outrel;
1182 bfd_byte *loc;
1183 int skip;
1184
1185 #ifdef DEBUG
1186 fprintf (stderr,
1187 "i370_elf_relocate_section needs to create relocation for %s\n",
1188 (h && h->root.root.string) ? h->root.root.string : "<unknown>");
1189 #endif
1190
1191 /* When generating a shared object, these relocations
1192 are copied into the output file to be resolved at run
1193 time. */
1194
1195 if (sreloc == NULL)
1196 {
1197 sreloc = _bfd_elf_get_dynamic_reloc_section
1198 (input_bfd, input_section, /*rela?*/ TRUE);
1199 if (sreloc == NULL)
1200 return FALSE;
1201 }
1202
1203 skip = 0;
1204
1205 outrel.r_offset =
1206 _bfd_elf_section_offset (output_bfd, info, input_section,
1207 rel->r_offset);
1208 if (outrel.r_offset == (bfd_vma) -1
1209 || outrel.r_offset == (bfd_vma) -2)
1210 skip = (int) outrel.r_offset;
1211 outrel.r_offset += (input_section->output_section->vma
1212 + input_section->output_offset);
1213
1214 if (skip)
1215 memset (&outrel, 0, sizeof outrel);
1216 /* h->dynindx may be -1 if this symbol was marked to
1217 become local. */
1218 else if (h != NULL
1219 && ((! info->symbolic && h->dynindx != -1)
1220 || !h->def_regular))
1221 {
1222 BFD_ASSERT (h->dynindx != -1);
1223 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1224 outrel.r_addend = rel->r_addend;
1225 }
1226 else
1227 {
1228 if (r_type == R_I370_ADDR31)
1229 {
1230 outrel.r_info = ELF32_R_INFO (0, R_I370_RELATIVE);
1231 outrel.r_addend = relocation + rel->r_addend;
1232 }
1233 else
1234 {
1235 long indx;
1236
1237 if (bfd_is_abs_section (sec))
1238 indx = 0;
1239 else if (sec == NULL || sec->owner == NULL)
1240 {
1241 bfd_set_error (bfd_error_bad_value);
1242 return FALSE;
1243 }
1244 else
1245 {
1246 asection *osec;
1247
1248 /* We are turning this relocation into one
1249 against a section symbol. It would be
1250 proper to subtract the symbol's value,
1251 osec->vma, from the emitted reloc addend,
1252 but ld.so expects buggy relocs. */
1253 osec = sec->output_section;
1254 indx = elf_section_data (osec)->dynindx;
1255 if (indx == 0)
1256 {
1257 struct elf_link_hash_table *htab;
1258 htab = elf_hash_table (info);
1259 osec = htab->text_index_section;
1260 indx = elf_section_data (osec)->dynindx;
1261 }
1262 BFD_ASSERT (indx != 0);
1263 #ifdef DEBUG
1264 if (indx <= 0)
1265 {
1266 printf ("indx=%ld section=%s flags=%08x name=%s\n",
1267 indx, osec->name, osec->flags,
1268 h->root.root.string);
1269 }
1270 #endif
1271 }
1272
1273 outrel.r_info = ELF32_R_INFO (indx, r_type);
1274 outrel.r_addend = relocation + rel->r_addend;
1275 }
1276 }
1277
1278 loc = sreloc->contents;
1279 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1280 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1281
1282 /* This reloc will be computed at runtime, so there's no
1283 need to do anything now, unless this is a RELATIVE
1284 reloc in an unallocated section. */
1285 if (skip == -1
1286 || (input_section->flags & SEC_ALLOC) != 0
1287 || ELF32_R_TYPE (outrel.r_info) != R_I370_RELATIVE)
1288 continue;
1289 }
1290 break;
1291
1292 case (int) R_I370_COPY:
1293 case (int) R_I370_RELATIVE:
1294 (*_bfd_error_handler)
1295 ("%B: Relocation %s is not yet supported for symbol %s.",
1296 input_bfd,
1297 i370_elf_howto_table[(int) r_type]->name,
1298 sym_name);
1299
1300 bfd_set_error (bfd_error_invalid_operation);
1301 ret = FALSE;
1302 continue;
1303 }
1304
1305 #ifdef DEBUG
1306 fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, offset = %ld, addend = %ld\n",
1307 howto->name,
1308 (int)r_type,
1309 sym_name,
1310 r_symndx,
1311 (long) offset,
1312 (long) addend);
1313 #endif
1314
1315 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
1316 offset, relocation, addend);
1317
1318 if (r != bfd_reloc_ok)
1319 {
1320 ret = FALSE;
1321 switch (r)
1322 {
1323 default:
1324 break;
1325
1326 case bfd_reloc_overflow:
1327 {
1328 const char *name;
1329
1330 if (h != NULL)
1331 name = NULL;
1332 else
1333 {
1334 name = bfd_elf_string_from_elf_section (input_bfd,
1335 symtab_hdr->sh_link,
1336 sym->st_name);
1337 if (name == NULL)
1338 break;
1339
1340 if (*name == '\0')
1341 name = bfd_section_name (input_bfd, sec);
1342 }
1343
1344 (*info->callbacks->reloc_overflow) (info,
1345 (h ? &h->root : NULL),
1346 name,
1347 howto->name,
1348 (bfd_vma) 0,
1349 input_bfd,
1350 input_section,
1351 offset);
1352 }
1353 break;
1354 }
1355 }
1356 }
1357
1358 #ifdef DEBUG
1359 fprintf (stderr, "\n");
1360 #endif
1361
1362 return ret;
1363 }
1364 \f
1365 #define TARGET_BIG_SYM i370_elf32_vec
1366 #define TARGET_BIG_NAME "elf32-i370"
1367 #define ELF_ARCH bfd_arch_i370
1368 #define ELF_MACHINE_CODE EM_S370
1369 #ifdef EM_I370_OLD
1370 #define ELF_MACHINE_ALT1 EM_I370_OLD
1371 #endif
1372 #define ELF_MAXPAGESIZE 0x1000
1373 #define ELF_OSABI ELFOSABI_GNU
1374
1375 #define elf_info_to_howto i370_elf_info_to_howto
1376
1377 #define elf_backend_plt_not_loaded 1
1378 #define elf_backend_rela_normal 1
1379
1380 #define bfd_elf32_bfd_reloc_type_lookup i370_elf_reloc_type_lookup
1381 #define bfd_elf32_bfd_reloc_name_lookup i370_elf_reloc_name_lookup
1382 #define bfd_elf32_bfd_set_private_flags i370_elf_set_private_flags
1383 #define bfd_elf32_bfd_merge_private_bfd_data i370_elf_merge_private_bfd_data
1384 #define elf_backend_relocate_section i370_elf_relocate_section
1385
1386 /* Dynamic loader support is mostly broken; just enough here to be able to
1387 link glibc's ld.so without errors. */
1388 #define elf_backend_create_dynamic_sections i370_elf_create_dynamic_sections
1389 #define elf_backend_size_dynamic_sections i370_elf_size_dynamic_sections
1390 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
1391 #define elf_backend_finish_dynamic_sections i370_elf_finish_dynamic_sections
1392 #define elf_backend_fake_sections i370_elf_fake_sections
1393 #define elf_backend_section_from_shdr i370_elf_section_from_shdr
1394 #define elf_backend_adjust_dynamic_symbol i370_elf_adjust_dynamic_symbol
1395 #define elf_backend_check_relocs i370_elf_check_relocs
1396
1397 static int
1398 i370_noop (void)
1399 {
1400 return 1;
1401 }
1402
1403 #define elf_backend_finish_dynamic_symbol \
1404 (bfd_boolean (*) \
1405 (bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, \
1406 Elf_Internal_Sym *)) i370_noop
1407
1408 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.079496 seconds and 4 git commands to generate.