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