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