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