projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
2001-05-16 Jeff Johnston <jjohnstn@redhat.com>
[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
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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
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 #define USE_RELA /* we want RELA relocations, not REL */
38
39 /* i370 relocations */
40 /* Note that there is really just one relocation that we currently
41 * support (and only one that we seem to need, at the moment), and
42 * that is the 31-bit address relocation. Note that the 370/390
43 * only supports a 31-bit (2GB) address space.
44 */
45 enum i370_reloc_type
46 {
47 R_I370_NONE = 0,
48 R_I370_ADDR31 = 1,
49 R_I370_ADDR32 = 2,
50 R_I370_ADDR16 = 3,
51 R_I370_REL31 = 4,
52 R_I370_REL32 = 5,
53 R_I370_ADDR12 = 6,
54 R_I370_REL12 = 7,
55 R_I370_ADDR8 = 8,
56 R_I370_REL8 = 9,
57 R_I370_COPY = 10,
58 R_I370_RELATIVE = 11,
59
60 R_I370_max
61 };
62 \f
63 static reloc_howto_type *i370_elf_howto_table[ (int)R_I370_max ];
64
65 static reloc_howto_type i370_elf_howto_raw[] =
66 {
67 /* This reloc does nothing. */
68 HOWTO (R_I370_NONE, /* type */
69 0, /* rightshift */
70 2, /* size (0 = byte, 1 = short, 2 = long) */
71 32, /* bitsize */
72 false, /* pc_relative */
73 0, /* bitpos */
74 complain_overflow_bitfield, /* complain_on_overflow */
75 bfd_elf_generic_reloc, /* special_function */
76 "R_I370_NONE", /* name */
77 false, /* partial_inplace */
78 0, /* src_mask */
79 0, /* dst_mask */
80 false), /* pcrel_offset */
81
82 /* A standard 31 bit relocation. */
83 HOWTO (R_I370_ADDR31, /* type */
84 0, /* rightshift */
85 2, /* size (0 = byte, 1 = short, 2 = long) */
86 31, /* bitsize */
87 false, /* pc_relative */
88 0, /* bitpos */
89 complain_overflow_bitfield, /* complain_on_overflow */
90 bfd_elf_generic_reloc, /* special_function */
91 "R_I370_ADDR31", /* name */
92 false, /* partial_inplace */
93 0, /* src_mask */
94 0x7fffffff, /* dst_mask */
95 false), /* pcrel_offset */
96
97 /* A standard 32 bit relocation. */
98 HOWTO (R_I370_ADDR32, /* type */
99 0, /* rightshift */
100 2, /* size (0 = byte, 1 = short, 2 = long) */
101 32, /* bitsize */
102 false, /* pc_relative */
103 0, /* bitpos */
104 complain_overflow_bitfield, /* complain_on_overflow */
105 bfd_elf_generic_reloc, /* special_function */
106 "R_I370_ADDR32", /* name */
107 false, /* partial_inplace */
108 0, /* src_mask */
109 0xffffffff, /* dst_mask */
110 false), /* pcrel_offset */
111
112 /* A standard 16 bit relocation. */
113 HOWTO (R_I370_ADDR16, /* type */
114 0, /* rightshift */
115 1, /* size (0 = byte, 1 = short, 2 = long) */
116 16, /* bitsize */
117 false, /* pc_relative */
118 0, /* bitpos */
119 complain_overflow_bitfield, /* complain_on_overflow */
120 bfd_elf_generic_reloc, /* special_function */
121 "R_I370_ADDR16", /* name */
122 false, /* partial_inplace */
123 0, /* src_mask */
124 0xffff, /* dst_mask */
125 false), /* pcrel_offset */
126
127 /* 31-bit PC relative */
128 HOWTO (R_I370_REL31, /* type */
129 0, /* rightshift */
130 2, /* size (0 = byte, 1 = short, 2 = long) */
131 31, /* bitsize */
132 true, /* pc_relative */
133 0, /* bitpos */
134 complain_overflow_bitfield, /* complain_on_overflow */
135 bfd_elf_generic_reloc, /* special_function */
136 "R_I370_REL31", /* name */
137 false, /* partial_inplace */
138 0, /* src_mask */
139 0x7fffffff, /* dst_mask */
140 true), /* pcrel_offset */
141
142 /* 32-bit PC relative */
143 HOWTO (R_I370_REL32, /* type */
144 0, /* rightshift */
145 2, /* size (0 = byte, 1 = short, 2 = long) */
146 32, /* bitsize */
147 true, /* pc_relative */
148 0, /* bitpos */
149 complain_overflow_bitfield, /* complain_on_overflow */
150 bfd_elf_generic_reloc, /* special_function */
151 "R_I370_REL32", /* name */
152 false, /* partial_inplace */
153 0, /* src_mask */
154 0xffffffff, /* dst_mask */
155 true), /* pcrel_offset */
156
157 /* A standard 12 bit relocation. */
158 HOWTO (R_I370_ADDR12, /* type */
159 0, /* rightshift */
160 1, /* size (0 = byte, 1 = short, 2 = long) */
161 12, /* bitsize */
162 false, /* pc_relative */
163 0, /* bitpos */
164 complain_overflow_bitfield, /* complain_on_overflow */
165 bfd_elf_generic_reloc, /* special_function */
166 "R_I370_ADDR12", /* name */
167 false, /* partial_inplace */
168 0, /* src_mask */
169 0xfff, /* dst_mask */
170 false), /* pcrel_offset */
171
172 /* 12-bit PC relative */
173 HOWTO (R_I370_REL12, /* type */
174 0, /* rightshift */
175 1, /* size (0 = byte, 1 = short, 2 = long) */
176 12, /* bitsize */
177 true, /* pc_relative */
178 0, /* bitpos */
179 complain_overflow_bitfield, /* complain_on_overflow */
180 bfd_elf_generic_reloc, /* special_function */
181 "R_I370_REL12", /* name */
182 false, /* partial_inplace */
183 0, /* src_mask */
184 0xfff, /* dst_mask */
185 true), /* pcrel_offset */
186
187 /* A standard 8 bit relocation. */
188 HOWTO (R_I370_ADDR8, /* type */
189 0, /* rightshift */
190 0, /* size (0 = byte, 1 = short, 2 = long) */
191 8, /* bitsize */
192 false, /* pc_relative */
193 0, /* bitpos */
194 complain_overflow_bitfield, /* complain_on_overflow */
195 bfd_elf_generic_reloc, /* special_function */
196 "R_I370_ADDR8", /* name */
197 false, /* partial_inplace */
198 0, /* src_mask */
199 0xff, /* dst_mask */
200 false), /* pcrel_offset */
201
202 /* 8-bit PC relative */
203 HOWTO (R_I370_REL8, /* type */
204 0, /* rightshift */
205 0, /* size (0 = byte, 1 = short, 2 = long) */
206 8, /* bitsize */
207 true, /* pc_relative */
208 0, /* bitpos */
209 complain_overflow_bitfield, /* complain_on_overflow */
210 bfd_elf_generic_reloc, /* special_function */
211 "R_I370_REL8", /* name */
212 false, /* partial_inplace */
213 0, /* src_mask */
214 0xff, /* dst_mask */
215 true), /* pcrel_offset */
216
217 /* This is used only by the dynamic linker. The symbol should exist
218 both in the object being run and in some shared library. The
219 dynamic linker copies the data addressed by the symbol from the
220 shared library into the object, because the object being
221 run has to have the data at some particular address. */
222 HOWTO (R_I370_COPY, /* type */
223 0, /* rightshift */
224 2, /* size (0 = byte, 1 = short, 2 = long) */
225 32, /* bitsize */
226 false, /* pc_relative */
227 0, /* bitpos */
228 complain_overflow_bitfield, /* complain_on_overflow */
229 bfd_elf_generic_reloc, /* special_function */
230 "R_I370_COPY", /* name */
231 false, /* partial_inplace */
232 0, /* src_mask */
233 0, /* dst_mask */
234 false), /* pcrel_offset */
235
236 /* Used only by the dynamic linker. When the object is run, this
237 longword is set to the load address of the object, plus the
238 addend. */
239 HOWTO (R_I370_RELATIVE, /* type */
240 0, /* rightshift */
241 2, /* size (0 = byte, 1 = short, 2 = long) */
242 32, /* bitsize */
243 false, /* pc_relative */
244 0, /* bitpos */
245 complain_overflow_bitfield, /* complain_on_overflow */
246 bfd_elf_generic_reloc, /* special_function */
247 "R_I370_RELATIVE", /* name */
248 false, /* partial_inplace */
249 0, /* src_mask */
250 0xffffffff, /* dst_mask */
251 false), /* pcrel_offset */
252
253 };
254 \f
255 static void i370_elf_howto_init PARAMS ((void));
256 static void i370_elf_info_to_howto PARAMS ((bfd *abfd, arelent *cache_ptr,
257 Elf32_Internal_Rela *dst));
258 static boolean i370_elf_set_private_flags PARAMS ((bfd *, flagword));
259 \f
260 /* Initialize the i370_elf_howto_table, so that linear accesses can be done. */
261
262 static void
263 i370_elf_howto_init ()
264 {
265 unsigned int i, type;
266
267 for (i = 0; i < sizeof (i370_elf_howto_raw) / sizeof (i370_elf_howto_raw[0]); i++)
268 {
269 type = i370_elf_howto_raw[i].type;
270 BFD_ASSERT (type < sizeof (i370_elf_howto_table) / sizeof (i370_elf_howto_table[0]));
271 i370_elf_howto_table[type] = &i370_elf_howto_raw[i];
272 }
273 }
274 \f
275 static reloc_howto_type *
276 i370_elf_reloc_type_lookup (abfd, code)
277 bfd *abfd ATTRIBUTE_UNUSED;
278 bfd_reloc_code_real_type code;
279 {
280 enum i370_reloc_type i370_reloc = R_I370_NONE;
281
282 if (!i370_elf_howto_table[ R_I370_ADDR31 ]) /* Initialize howto table if needed */
283 i370_elf_howto_init ();
284
285 switch ((int)code)
286 {
287 default:
288 return (reloc_howto_type *)NULL;
289
290 case BFD_RELOC_NONE: i370_reloc = R_I370_NONE; break;
291 case BFD_RELOC_32: i370_reloc = R_I370_ADDR31; break;
292 case BFD_RELOC_16: i370_reloc = R_I370_ADDR16; break;
293 case BFD_RELOC_32_PCREL: i370_reloc = R_I370_REL31; break;
294 case BFD_RELOC_CTOR: i370_reloc = R_I370_ADDR31; break;
295 case BFD_RELOC_I370_D12: i370_reloc = R_I370_ADDR12; break;
296 }
297
298 return i370_elf_howto_table[ (int)i370_reloc ];
299 };
300
301 static boolean i370_elf_copy_private_bfd_data PARAMS ((bfd *, bfd *));
302 static boolean i370_elf_merge_private_bfd_data PARAMS ((bfd *, bfd *));
303
304 static boolean i370_elf_relocate_section PARAMS ((bfd *,
305 struct bfd_link_info *info,
306 bfd *,
307 asection *,
308 bfd_byte *,
309 Elf_Internal_Rela *relocs,
310 Elf_Internal_Sym *local_syms,
311 asection **));
312
313 static boolean i370_elf_create_dynamic_sections PARAMS ((bfd *,
314 struct bfd_link_info *));
315
316 static boolean i370_elf_section_from_shdr PARAMS ((bfd *,
317 Elf32_Internal_Shdr *,
318 char *));
319 static boolean i370_elf_fake_sections PARAMS ((bfd *,
320 Elf32_Internal_Shdr *,
321 asection *));
322 #if 0
323 static elf_linker_section_t *i370_elf_create_linker_section
324 PARAMS ((bfd *abfd,
325 struct bfd_link_info *info,
326 enum elf_linker_section_enum));
327 #endif
328 static boolean i370_elf_check_relocs PARAMS ((bfd *,
329 struct bfd_link_info *,
330 asection *,
331 const Elf_Internal_Rela *));
332
333 static boolean i370_elf_adjust_dynamic_symbol PARAMS ((struct bfd_link_info *,
334 struct elf_link_hash_entry *));
335
336 static boolean i370_elf_adjust_dynindx PARAMS ((struct elf_link_hash_entry *, PTR));
337
338 static boolean i370_elf_size_dynamic_sections PARAMS ((bfd *, struct bfd_link_info *));
339
340 static boolean i370_elf_finish_dynamic_sections PARAMS ((bfd *, struct bfd_link_info *));
341
342 /* The name of the dynamic interpreter. This is put in the .interp
343 section. */
344
345 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
346
347 /* Set the howto pointer for an i370 ELF reloc. */
348
349 static void
350 i370_elf_info_to_howto (abfd, cache_ptr, dst)
351 bfd *abfd ATTRIBUTE_UNUSED;
352 arelent *cache_ptr;
353 Elf32_Internal_Rela *dst;
354 {
355 if (!i370_elf_howto_table[ R_I370_ADDR31 ]) /* Initialize howto table */
356 i370_elf_howto_init ();
357
358 BFD_ASSERT (ELF32_R_TYPE (dst->r_info) < (unsigned int) R_I370_max);
359 cache_ptr->howto = i370_elf_howto_table[ELF32_R_TYPE (dst->r_info)];
360 }
361
362 /* hack alert -- the following several routines look generic to me ...
363 * why are we bothering with them ???
364 */
365 /* Function to set whether a module needs the -mrelocatable bit set. */
366 static boolean
367 i370_elf_set_private_flags (abfd, flags)
368 bfd *abfd;
369 flagword flags;
370 {
371 BFD_ASSERT (!elf_flags_init (abfd)
372 || elf_elfheader (abfd)->e_flags == flags);
373
374 elf_elfheader (abfd)->e_flags = flags;
375 elf_flags_init (abfd) = true;
376 return true;
377 }
378
379 /* Copy backend specific data from one object module to another */
380 static boolean
381 i370_elf_copy_private_bfd_data (ibfd, obfd)
382 bfd *ibfd;
383 bfd *obfd;
384 {
385 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
386 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
387 return true;
388
389 BFD_ASSERT (!elf_flags_init (obfd)
390 || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
391
392 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
393 elf_flags_init (obfd) = true;
394 return true;
395 }
396
397 /* Merge backend specific data from an object file to the output
398 object file when linking */
399 static boolean
400 i370_elf_merge_private_bfd_data (ibfd, obfd)
401 bfd *ibfd;
402 bfd *obfd;
403 {
404 flagword old_flags;
405 flagword new_flags;
406
407 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
408 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
409 return true;
410
411 new_flags = elf_elfheader (ibfd)->e_flags;
412 old_flags = elf_elfheader (obfd)->e_flags;
413 if (!elf_flags_init (obfd)) /* First call, no flags set */
414 {
415 elf_flags_init (obfd) = true;
416 elf_elfheader (obfd)->e_flags = new_flags;
417 }
418
419 else if (new_flags == old_flags) /* Compatible flags are ok */
420 ;
421
422 else /* Incompatible flags */
423 {
424 (*_bfd_error_handler)
425 ("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)",
426 bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
427
428 bfd_set_error (bfd_error_bad_value);
429 return false;
430 }
431
432 return true;
433 }
434 \f
435 /* Handle an i370 specific section when reading an object file. This
436 is called when elfcode.h finds a section with an unknown type. */
437 /* XXX hack alert bogus This routine is mostly all junk and almost
438 * certainly does the wrong thing. Its here simply because it does
439 * just enough to allow glibc-2.1 ld.so to compile & link.
440 */
441
442 static boolean
443 i370_elf_section_from_shdr (abfd, hdr, name)
444 bfd *abfd;
445 Elf32_Internal_Shdr *hdr;
446 char *name;
447 {
448 asection *newsect;
449 flagword flags;
450
451 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
452 return false;
453
454 newsect = hdr->bfd_section;
455 flags = bfd_get_section_flags (abfd, newsect);
456 if (hdr->sh_flags & SHF_EXCLUDE)
457 flags |= SEC_EXCLUDE;
458
459 if (hdr->sh_type == SHT_ORDERED)
460 flags |= SEC_SORT_ENTRIES;
461
462 bfd_set_section_flags (abfd, newsect, flags);
463 return true;
464 }
465 \f
466 /* Set up any other section flags and such that may be necessary. */
467 /* XXX hack alert bogus This routine is mostly all junk and almost
468 * certainly does the wrong thing. Its here simply because it does
469 * just enough to allow glibc-2.1 ld.so to compile & link.
470 */
471
472 static boolean
473 i370_elf_fake_sections (abfd, shdr, asect)
474 bfd *abfd ATTRIBUTE_UNUSED;
475 Elf32_Internal_Shdr *shdr;
476 asection *asect;
477 {
478 if ((asect->flags & SEC_EXCLUDE) != 0)
479 shdr->sh_flags |= SHF_EXCLUDE;
480
481 if ((asect->flags & SEC_SORT_ENTRIES) != 0)
482 shdr->sh_type = SHT_ORDERED;
483
484 return true;
485 }
486 \f
487 #if 0
488 /* Create a special linker section */
489 /* XXX hack alert bogus This routine is mostly all junk and almost
490 * certainly does the wrong thing. Its here simply because it does
491 * just enough to allow glibc-2.1 ld.so to compile & link.
492 */
493
494 static elf_linker_section_t *
495 i370_elf_create_linker_section (abfd, info, which)
496 bfd *abfd;
497 struct bfd_link_info *info;
498 enum elf_linker_section_enum which;
499 {
500 bfd *dynobj = elf_hash_table (info)->dynobj;
501 elf_linker_section_t *lsect;
502
503 /* Record the first bfd section that needs the special section */
504 if (!dynobj)
505 dynobj = elf_hash_table (info)->dynobj = abfd;
506
507 /* If this is the first time, create the section */
508 lsect = elf_linker_section (dynobj, which);
509 if (!lsect)
510 {
511 elf_linker_section_t defaults;
512 static elf_linker_section_t zero_section;
513
514 defaults = zero_section;
515 defaults.which = which;
516 defaults.hole_written_p = false;
517 defaults.alignment = 2;
518
519 /* Both of these sections are (technically) created by the user
520 putting data in them, so they shouldn't be marked
521 SEC_LINKER_CREATED.
522
523 The linker creates them so it has somewhere to attach their
524 respective symbols. In fact, if they were empty it would
525 be OK to leave the symbol set to 0 (or any random number), because
526 the appropriate register should never be used. */
527 defaults.flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
528 | SEC_IN_MEMORY);
529
530 switch (which)
531 {
532 default:
533 (*_bfd_error_handler) ("%s: Unknown special linker type %d",
534 bfd_get_filename (abfd),
535 (int)which);
536
537 bfd_set_error (bfd_error_bad_value);
538 return (elf_linker_section_t *)0;
539
540 case LINKER_SECTION_SDATA: /* .sdata/.sbss section */
541 defaults.name = ".sdata";
542 defaults.rel_name = ".rela.sdata";
543 defaults.bss_name = ".sbss";
544 defaults.sym_name = "_SDA_BASE_";
545 defaults.sym_offset = 32768;
546 break;
547
548 case LINKER_SECTION_SDATA2: /* .sdata2/.sbss2 section */
549 defaults.name = ".sdata2";
550 defaults.rel_name = ".rela.sdata2";
551 defaults.bss_name = ".sbss2";
552 defaults.sym_name = "_SDA2_BASE_";
553 defaults.sym_offset = 32768;
554 defaults.flags |= SEC_READONLY;
555 break;
556 }
557
558 lsect = _bfd_elf_create_linker_section (abfd, info, which, &defaults);
559 }
560
561 return lsect;
562 }
563 #endif
564 \f
565 /* We have to create .dynsbss and .rela.sbss here so that they get mapped
566 to output sections (just like _bfd_elf_create_dynamic_sections has
567 to create .dynbss and .rela.bss). */
568 /* XXX hack alert bogus This routine is mostly all junk and almost
569 * certainly does the wrong thing. Its here simply because it does
570 * just enough to allow glibc-2.1 ld.so to compile & link.
571 */
572
573 static boolean
574 i370_elf_create_dynamic_sections (abfd, info)
575 bfd *abfd;
576 struct bfd_link_info *info;
577 {
578 register asection *s;
579 flagword flags;
580
581 if (!_bfd_elf_create_dynamic_sections(abfd, info))
582 return false;
583
584 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
585 | SEC_LINKER_CREATED);
586
587 s = bfd_make_section (abfd, ".dynsbss");
588 if (s == NULL
589 || ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
590 return false;
591
592 if (! info->shared)
593 {
594 s = bfd_make_section (abfd, ".rela.sbss");
595 if (s == NULL
596 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
597 || ! bfd_set_section_alignment (abfd, s, 2))
598 return false;
599 }
600
601 /* xxx beats me, seem to need a rela.text ... */
602 s = bfd_make_section (abfd, ".rela.text");
603 if (s == NULL
604 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
605 || ! bfd_set_section_alignment (abfd, s, 2))
606 return false;
607 return true;
608 }
609
610 /* Adjust a symbol defined by a dynamic object and referenced by a
611 regular object. The current definition is in some section of the
612 dynamic object, but we're not including those sections. We have to
613 change the definition to something the rest of the link can
614 understand. */
615 /* XXX hack alert bogus This routine is mostly all junk and almost
616 * certainly does the wrong thing. Its here simply because it does
617 * just enough to allow glibc-2.1 ld.so to compile & link.
618 */
619
620 static boolean
621 i370_elf_adjust_dynamic_symbol (info, h)
622 struct bfd_link_info *info;
623 struct elf_link_hash_entry *h;
624 {
625 bfd *dynobj = elf_hash_table (info)->dynobj;
626 asection *s;
627 unsigned int power_of_two;
628
629 #ifdef DEBUG
630 fprintf (stderr, "i370_elf_adjust_dynamic_symbol called for %s\n",
631 h->root.root.string);
632 #endif
633
634 /* Make sure we know what is going on here. */
635 BFD_ASSERT (dynobj != NULL
636 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
637 || h->weakdef != NULL
638 || ((h->elf_link_hash_flags
639 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
640 && (h->elf_link_hash_flags
641 & ELF_LINK_HASH_REF_REGULAR) != 0
642 && (h->elf_link_hash_flags
643 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
644
645 s = bfd_get_section_by_name (dynobj, ".rela.text");
646 BFD_ASSERT (s != NULL);
647 s->_raw_size += sizeof (Elf32_External_Rela);
648
649 /* If this is a weak symbol, and there is a real definition, the
650 processor independent code will have arranged for us to see the
651 real definition first, and we can just use the same value. */
652 if (h->weakdef != NULL)
653 {
654 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
655 || h->weakdef->root.type == bfd_link_hash_defweak);
656 h->root.u.def.section = h->weakdef->root.u.def.section;
657 h->root.u.def.value = h->weakdef->root.u.def.value;
658 return true;
659 }
660
661 /* This is a reference to a symbol defined by a dynamic object which
662 is not a function. */
663
664 /* If we are creating a shared library, we must presume that the
665 only references to the symbol are via the global offset table.
666 For such cases we need not do anything here; the relocations will
667 be handled correctly by relocate_section. */
668 if (info->shared)
669 return true;
670
671 /* We must allocate the symbol in our .dynbss section, which will
672 become part of the .bss section of the executable. There will be
673 an entry for this symbol in the .dynsym section. The dynamic
674 object will contain position independent code, so all references
675 from the dynamic object to this symbol will go through the global
676 offset table. The dynamic linker will use the .dynsym entry to
677 determine the address it must put in the global offset table, so
678 both the dynamic object and the regular object will refer to the
679 same memory location for the variable.
680
681 Of course, if the symbol is sufficiently small, we must instead
682 allocate it in .sbss. FIXME: It would be better to do this if and
683 only if there were actually SDAREL relocs for that symbol. */
684
685 if (h->size <= elf_gp_size (dynobj))
686 s = bfd_get_section_by_name (dynobj, ".dynsbss");
687 else
688 s = bfd_get_section_by_name (dynobj, ".dynbss");
689 BFD_ASSERT (s != NULL);
690
691 /* We must generate a R_I370_COPY reloc to tell the dynamic linker to
692 copy the initial value out of the dynamic object and into the
693 runtime process image. We need to remember the offset into the
694 .rela.bss section we are going to use. */
695 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
696 {
697 asection *srel;
698
699 if (h->size <= elf_gp_size (dynobj))
700 srel = bfd_get_section_by_name (dynobj, ".rela.sbss");
701 else
702 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
703 BFD_ASSERT (srel != NULL);
704 srel->_raw_size += sizeof (Elf32_External_Rela);
705 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
706 }
707
708 /* We need to figure out the alignment required for this symbol. I
709 have no idea how ELF linkers handle this. */
710 power_of_two = bfd_log2 (h->size);
711 if (power_of_two > 4)
712 power_of_two = 4;
713
714 /* Apply the required alignment. */
715 s->_raw_size = BFD_ALIGN (s->_raw_size,
716 (bfd_size_type) (1 << power_of_two));
717 if (power_of_two > bfd_get_section_alignment (dynobj, s))
718 {
719 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
720 return false;
721 }
722
723 /* Define the symbol as being at this point in the section. */
724 h->root.u.def.section = s;
725 h->root.u.def.value = s->_raw_size;
726
727 /* Increment the section size to make room for the symbol. */
728 s->_raw_size += h->size;
729
730 return true;
731 }
732 \f
733 /* Increment the index of a dynamic symbol by a given amount. Called
734 via elf_link_hash_traverse. */
735 /* XXX hack alert bogus This routine is mostly all junk and almost
736 * certainly does the wrong thing. Its here simply because it does
737 * just enough to allow glibc-2.1 ld.so to compile & link.
738 */
739
740 static boolean
741 i370_elf_adjust_dynindx (h, cparg)
742 struct elf_link_hash_entry *h;
743 PTR cparg;
744 {
745 int *cp = (int *) cparg;
746
747 #ifdef DEBUG
748 fprintf (stderr,
749 "i370_elf_adjust_dynindx called, h->dynindx = %d, *cp = %d\n",
750 h->dynindx, *cp);
751 #endif
752
753 if (h->dynindx != -1)
754 h->dynindx += *cp;
755
756 return true;
757 }
758 \f
759 /* Set the sizes of the dynamic sections. */
760 /* XXX hack alert bogus This routine is mostly all junk and almost
761 * certainly does the wrong thing. Its here simply because it does
762 * just enough to allow glibc-2.1 ld.so to compile & link.
763 */
764
765 static boolean
766 i370_elf_size_dynamic_sections (output_bfd, info)
767 bfd *output_bfd;
768 struct bfd_link_info *info;
769 {
770 bfd *dynobj;
771 asection *s;
772 boolean plt;
773 boolean relocs;
774 boolean reltext;
775
776 #ifdef DEBUG
777 fprintf (stderr, "i370_elf_size_dynamic_sections called\n");
778 #endif
779
780 dynobj = elf_hash_table (info)->dynobj;
781 BFD_ASSERT (dynobj != NULL);
782
783 if (elf_hash_table (info)->dynamic_sections_created)
784 {
785 /* Set the contents of the .interp section to the interpreter. */
786 if (! info->shared)
787 {
788 s = bfd_get_section_by_name (dynobj, ".interp");
789 BFD_ASSERT (s != NULL);
790 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
791 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
792 }
793 }
794 else
795 {
796 /* We may have created entries in the .rela.got, .rela.sdata, and
797 .rela.sdata2 sections. However, if we are not creating the
798 dynamic sections, we will not actually use these entries. Reset
799 the size of .rela.got, et al, which will cause it to get
800 stripped from the output file below. */
801 static char *rela_sections[] = { ".rela.got", ".rela.sdata",
802 ".rela.sdata2", ".rela.sbss",
803 (char *)0 };
804 char **p;
805
806 for (p = rela_sections; *p != (char *)0; p++)
807 {
808 s = bfd_get_section_by_name (dynobj, *p);
809 if (s != NULL)
810 s->_raw_size = 0;
811 }
812 }
813
814 /* The check_relocs and adjust_dynamic_symbol entry points have
815 determined the sizes of the various dynamic sections. Allocate
816 memory for them. */
817 plt = false;
818 relocs = false;
819 reltext = false;
820 for (s = dynobj->sections; s != NULL; s = s->next)
821 {
822 const char *name;
823 boolean strip;
824
825 if ((s->flags & SEC_LINKER_CREATED) == 0)
826 continue;
827
828 /* It's OK to base decisions on the section name, because none
829 of the dynobj section names depend upon the input files. */
830 name = bfd_get_section_name (dynobj, s);
831 strip = false;
832
833 if (strcmp (name, ".plt") == 0)
834 {
835 if (s->_raw_size == 0)
836 {
837 /* Strip this section if we don't need it; see the
838 comment below. */
839 strip = true;
840 }
841 else
842 {
843 /* Remember whether there is a PLT. */
844 plt = true;
845 }
846 }
847 else if (strncmp (name, ".rela", 5) == 0)
848 {
849 if (s->_raw_size == 0)
850 {
851 /* If we don't need this section, strip it from the
852 output file. This is mostly to handle .rela.bss and
853 .rela.plt. We must create both sections in
854 create_dynamic_sections, because they must be created
855 before the linker maps input sections to output
856 sections. The linker does that before
857 adjust_dynamic_symbol is called, and it is that
858 function which decides whether anything needs to go
859 into these sections. */
860 strip = true;
861 }
862 else
863 {
864 asection *target;
865 const char *outname;
866
867 /* Remember whether there are any relocation sections. */
868 relocs = true;
869
870 /* If this relocation section applies to a read only
871 section, then we probably need a DT_TEXTREL entry. */
872 outname = bfd_get_section_name (output_bfd,
873 s->output_section);
874 target = bfd_get_section_by_name (output_bfd, outname + 5);
875 if (target != NULL
876 && (target->flags & SEC_READONLY) != 0
877 && (target->flags & SEC_ALLOC) != 0)
878 reltext = true;
879
880 /* We use the reloc_count field as a counter if we need
881 to copy relocs into the output file. */
882 s->reloc_count = 0;
883 }
884 }
885 else if (strcmp (name, ".got") != 0
886 && strcmp (name, ".sdata") != 0
887 && strcmp (name, ".sdata2") != 0)
888 {
889 /* It's not one of our sections, so don't allocate space. */
890 continue;
891 }
892
893 if (strip)
894 {
895 asection **spp;
896
897 for (spp = &s->output_section->owner->sections;
898 *spp != s->output_section;
899 spp = &(*spp)->next)
900 ;
901 *spp = s->output_section->next;
902 --s->output_section->owner->section_count;
903
904 continue;
905 }
906 /* Allocate memory for the section contents. */
907 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
908 if (s->contents == NULL && s->_raw_size != 0)
909 return false;
910 }
911
912 if (elf_hash_table (info)->dynamic_sections_created)
913 {
914 /* Add some entries to the .dynamic section. We fill in the
915 values later, in i370_elf_finish_dynamic_sections, but we
916 must add the entries now so that we get the correct size for
917 the .dynamic section. The DT_DEBUG entry is filled in by the
918 dynamic linker and used by the debugger. */
919 if (! info->shared)
920 {
921 if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
922 return false;
923 }
924
925 if (plt)
926 {
927 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
928 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
929 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
930 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
931 return false;
932 }
933
934 if (relocs)
935 {
936 if (! bfd_elf32_add_dynamic_entry (info, DT_RELA, 0)
937 || ! bfd_elf32_add_dynamic_entry (info, DT_RELASZ, 0)
938 || ! bfd_elf32_add_dynamic_entry (info, DT_RELAENT,
939 sizeof (Elf32_External_Rela)))
940 return false;
941 }
942
943 if (reltext)
944 {
945 if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
946 return false;
947 info->flags |= DF_TEXTREL;
948 }
949 }
950
951 /* If we are generating a shared library, we generate a section
952 symbol for each output section. These are local symbols, which
953 means that they must come first in the dynamic symbol table.
954 That means we must increment the dynamic symbol index of every
955 other dynamic symbol.
956
957 FIXME: We assume that there will never be relocations to
958 locations in linker-created sections that do not have
959 externally-visible names. Instead, we should work out precisely
960 which sections relocations are targetted at. */
961 if (info->shared)
962 {
963 int c;
964
965 for (c = 0, s = output_bfd->sections; s != NULL; s = s->next)
966 {
967 if ((s->flags & SEC_LINKER_CREATED) != 0
968 || (s->flags & SEC_ALLOC) == 0)
969 {
970 elf_section_data (s)->dynindx = -1;
971 continue;
972 }
973
974 /* These symbols will have no names, so we don't need to
975 fiddle with dynstr_index. */
976
977 elf_section_data (s)->dynindx = c + 1;
978
979 c++;
980 }
981
982 elf_link_hash_traverse (elf_hash_table (info),
983 i370_elf_adjust_dynindx,
984 (PTR) &c);
985 elf_hash_table (info)->dynsymcount += c;
986 }
987
988 return true;
989 }
990 \f
991 /* Look through the relocs for a section during the first phase, and
992 allocate space in the global offset table or procedure linkage
993 table. */
994 /* XXX hack alert bogus This routine is mostly all junk and almost
995 * certainly does the wrong thing. Its here simply because it does
996 * just enough to allow glibc-2.1 ld.so to compile & link.
997 */
998
999 static boolean
1000 i370_elf_check_relocs (abfd, info, sec, relocs)
1001 bfd *abfd;
1002 struct bfd_link_info *info;
1003 asection *sec;
1004 const Elf_Internal_Rela *relocs;
1005 {
1006 bfd *dynobj;
1007 Elf_Internal_Shdr *symtab_hdr;
1008 struct elf_link_hash_entry **sym_hashes;
1009 const Elf_Internal_Rela *rel;
1010 const Elf_Internal_Rela *rel_end;
1011 bfd_vma *local_got_offsets;
1012 asection *sreloc;
1013
1014 if (info->relocateable)
1015 return true;
1016
1017 #ifdef DEBUG
1018 fprintf (stderr, "i370_elf_check_relocs called for section %s in %s\n",
1019 bfd_get_section_name (abfd, sec),
1020 bfd_get_filename (abfd));
1021 #endif
1022
1023 dynobj = elf_hash_table (info)->dynobj;
1024 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1025 sym_hashes = elf_sym_hashes (abfd);
1026 local_got_offsets = elf_local_got_offsets (abfd);
1027
1028 sreloc = NULL;
1029
1030 rel_end = relocs + sec->reloc_count;
1031 for (rel = relocs; rel < rel_end; rel++)
1032 {
1033 unsigned long r_symndx;
1034 struct elf_link_hash_entry *h;
1035
1036 r_symndx = ELF32_R_SYM (rel->r_info);
1037 if (r_symndx < symtab_hdr->sh_info)
1038 h = NULL;
1039 else
1040 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1041
1042 if (info->shared)
1043 {
1044 #ifdef DEBUG
1045 fprintf (stderr,
1046 "i370_elf_check_relocs needs to create relocation for %s\n",
1047 (h && h->root.root.string)
1048 ? h->root.root.string : "<unknown>");
1049 #endif
1050 if (sreloc == NULL)
1051 {
1052 const char *name;
1053
1054 name = (bfd_elf_string_from_elf_section
1055 (abfd,
1056 elf_elfheader (abfd)->e_shstrndx,
1057 elf_section_data (sec)->rel_hdr.sh_name));
1058 if (name == NULL)
1059 return false;
1060
1061 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1062 && strcmp (bfd_get_section_name (abfd, sec), name + 5) == 0);
1063
1064 sreloc = bfd_get_section_by_name (dynobj, name);
1065 if (sreloc == NULL)
1066 {
1067 flagword flags;
1068
1069 sreloc = bfd_make_section (dynobj, name);
1070 flags = (SEC_HAS_CONTENTS | SEC_READONLY
1071 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1072 if ((sec->flags & SEC_ALLOC) != 0)
1073 flags |= SEC_ALLOC | SEC_LOAD;
1074 if (sreloc == NULL
1075 || ! bfd_set_section_flags (dynobj, sreloc, flags)
1076 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
1077 return false;
1078 }
1079 }
1080
1081 sreloc->_raw_size += sizeof (Elf32_External_Rela);
1082
1083 /* FIXME: We should here do what the m68k and i386
1084 backends do: if the reloc is pc-relative, record it
1085 in case it turns out that the reloc is unnecessary
1086 because the symbol is forced local by versioning or
1087 we are linking with -Bdynamic. Fortunately this
1088 case is not frequent. */
1089 }
1090 }
1091
1092 return true;
1093 }
1094 \f
1095 /* Finish up the dynamic sections. */
1096 /* XXX hack alert bogus This routine is mostly all junk and almost
1097 * certainly does the wrong thing. Its here simply because it does
1098 * just enough to allow glibc-2.1 ld.so to compile & link.
1099 */
1100
1101 static boolean
1102 i370_elf_finish_dynamic_sections (output_bfd, info)
1103 bfd *output_bfd;
1104 struct bfd_link_info *info;
1105 {
1106 asection *sdyn;
1107 bfd *dynobj = elf_hash_table (info)->dynobj;
1108 asection *sgot = bfd_get_section_by_name (dynobj, ".got");
1109
1110 #ifdef DEBUG
1111 fprintf (stderr, "i370_elf_finish_dynamic_sections called\n");
1112 #endif
1113
1114 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1115
1116 if (elf_hash_table (info)->dynamic_sections_created)
1117 {
1118 asection *splt;
1119 Elf32_External_Dyn *dyncon, *dynconend;
1120
1121 splt = bfd_get_section_by_name (dynobj, ".plt");
1122 BFD_ASSERT (splt != NULL && sdyn != NULL);
1123
1124 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1125 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1126 for (; dyncon < dynconend; dyncon++)
1127 {
1128 Elf_Internal_Dyn dyn;
1129 const char *name;
1130 boolean size;
1131
1132 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1133
1134 switch (dyn.d_tag)
1135 {
1136 case DT_PLTGOT: name = ".plt"; size = false; break;
1137 case DT_PLTRELSZ: name = ".rela.plt"; size = true; break;
1138 case DT_JMPREL: name = ".rela.plt"; size = false; break;
1139 default: name = NULL; size = false; break;
1140 }
1141
1142 if (name != NULL)
1143 {
1144 asection *s;
1145
1146 s = bfd_get_section_by_name (output_bfd, name);
1147 if (s == NULL)
1148 dyn.d_un.d_val = 0;
1149 else
1150 {
1151 if (! size)
1152 dyn.d_un.d_ptr = s->vma;
1153 else
1154 {
1155 if (s->_cooked_size != 0)
1156 dyn.d_un.d_val = s->_cooked_size;
1157 else
1158 dyn.d_un.d_val = s->_raw_size;
1159 }
1160 }
1161 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1162 }
1163 }
1164 }
1165
1166 /* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4 so that a function can
1167 easily find the address of the _GLOBAL_OFFSET_TABLE_. */
1168 /* XXX this is clearly very wrong for the 370 arch */
1169 if (sgot)
1170 {
1171 unsigned char *contents = sgot->contents;
1172 bfd_put_32 (output_bfd, 0x4e800021 /* blrl */, contents);
1173
1174 if (sdyn == NULL)
1175 bfd_put_32 (output_bfd, (bfd_vma) 0, contents+4);
1176 else
1177 bfd_put_32 (output_bfd,
1178 sdyn->output_section->vma + sdyn->output_offset,
1179 contents+4);
1180
1181 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1182 }
1183
1184 if (info->shared)
1185 {
1186 asection *sdynsym;
1187 asection *s;
1188 Elf_Internal_Sym sym;
1189 int maxdindx = 0;
1190
1191 /* Set up the section symbols for the output sections. */
1192
1193 sdynsym = bfd_get_section_by_name (dynobj, ".dynsym");
1194 BFD_ASSERT (sdynsym != NULL);
1195
1196 sym.st_size = 0;
1197 sym.st_name = 0;
1198 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
1199 sym.st_other = 0;
1200
1201 for (s = output_bfd->sections; s != NULL; s = s->next)
1202 {
1203 int indx, dindx;
1204
1205 sym.st_value = s->vma;
1206
1207 indx = elf_section_data (s)->this_idx;
1208 dindx = elf_section_data (s)->dynindx;
1209 if (dindx != -1)
1210 {
1211 BFD_ASSERT(indx > 0);
1212 BFD_ASSERT(dindx > 0);
1213
1214 if (dindx > maxdindx)
1215 maxdindx = dindx;
1216
1217 sym.st_shndx = indx;
1218
1219 bfd_elf32_swap_symbol_out (output_bfd, &sym,
1220 (PTR) (((Elf32_External_Sym *)
1221 sdynsym->contents)
1222 + dindx));
1223 }
1224 }
1225
1226 /* Set the sh_info field of the output .dynsym section to the
1227 index of the first global symbol. */
1228 elf_section_data (sdynsym->output_section)->this_hdr.sh_info =
1229 maxdindx + 1;
1230 }
1231
1232 return true;
1233 }
1234 \f
1235 /* The RELOCATE_SECTION function is called by the ELF backend linker
1236 to handle the relocations for a section.
1237
1238 The relocs are always passed as Rela structures; if the section
1239 actually uses Rel structures, the r_addend field will always be
1240 zero.
1241
1242 This function is responsible for adjust the section contents as
1243 necessary, and (if using Rela relocs and generating a
1244 relocateable output file) adjusting the reloc addend as
1245 necessary.
1246
1247 This function does not have to worry about setting the reloc
1248 address or the reloc symbol index.
1249
1250 LOCAL_SYMS is a pointer to the swapped in local symbols.
1251
1252 LOCAL_SECTIONS is an array giving the section in the input file
1253 corresponding to the st_shndx field of each local symbol.
1254
1255 The global hash table entry for the global symbols can be found
1256 via elf_sym_hashes (input_bfd).
1257
1258 When generating relocateable output, this function must handle
1259 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1260 going to be the section symbol corresponding to the output
1261 section, which means that the addend must be adjusted
1262 accordingly. */
1263
1264 static boolean
1265 i370_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1266 contents, relocs, local_syms, local_sections)
1267 bfd *output_bfd;
1268 struct bfd_link_info *info;
1269 bfd *input_bfd;
1270 asection *input_section;
1271 bfd_byte *contents;
1272 Elf_Internal_Rela *relocs;
1273 Elf_Internal_Sym *local_syms;
1274 asection **local_sections;
1275 {
1276 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1277 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
1278 bfd *dynobj = elf_hash_table (info)->dynobj;
1279 Elf_Internal_Rela *rel = relocs;
1280 Elf_Internal_Rela *relend = relocs + input_section->reloc_count;
1281 asection *sreloc = NULL;
1282 bfd_vma *local_got_offsets;
1283 boolean ret = true;
1284
1285 #ifdef DEBUG
1286 fprintf (stderr, "i370_elf_relocate_section called for %s section %s, %ld relocations%s\n",
1287 bfd_get_filename (input_bfd),
1288 bfd_section_name(input_bfd, input_section),
1289 (long)input_section->reloc_count,
1290 (info->relocateable) ? " (relocatable)" : "");
1291 #endif
1292
1293 if (!i370_elf_howto_table[ R_I370_ADDR31 ]) /* Initialize howto table if needed */
1294 i370_elf_howto_init ();
1295
1296 local_got_offsets = elf_local_got_offsets (input_bfd);
1297
1298 for (; rel < relend; rel++)
1299 {
1300 enum i370_reloc_type r_type = (enum i370_reloc_type)ELF32_R_TYPE (rel->r_info);
1301 bfd_vma offset = rel->r_offset;
1302 bfd_vma addend = rel->r_addend;
1303 bfd_reloc_status_type r = bfd_reloc_other;
1304 Elf_Internal_Sym *sym = (Elf_Internal_Sym *)0;
1305 asection *sec = (asection *)0;
1306 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *)0;
1307 const char *sym_name = (const char *)0;
1308 reloc_howto_type *howto;
1309 unsigned long r_symndx;
1310 bfd_vma relocation;
1311
1312 /* Unknown relocation handling */
1313 if ((unsigned)r_type >= (unsigned)R_I370_max
1314 || !i370_elf_howto_table[(int)r_type])
1315 {
1316 (*_bfd_error_handler) ("%s: unknown relocation type %d",
1317 bfd_get_filename (input_bfd),
1318 (int)r_type);
1319
1320 bfd_set_error (bfd_error_bad_value);
1321 ret = false;
1322 continue;
1323 }
1324
1325 howto = i370_elf_howto_table[(int)r_type];
1326 r_symndx = ELF32_R_SYM (rel->r_info);
1327
1328 if (info->relocateable)
1329 {
1330 /* This is a relocateable link. We don't have to change
1331 anything, unless the reloc is against a section symbol,
1332 in which case we have to adjust according to where the
1333 section symbol winds up in the output section. */
1334 if (r_symndx < symtab_hdr->sh_info)
1335 {
1336 sym = local_syms + r_symndx;
1337 if ((unsigned)ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1338 {
1339 sec = local_sections[r_symndx];
1340 addend = rel->r_addend += sec->output_offset + sym->st_value;
1341 }
1342 }
1343
1344 #ifdef DEBUG
1345 fprintf (stderr, "\ttype = %s (%d), symbol index = %ld, offset = %ld, addend = %ld\n",
1346 howto->name,
1347 (int)r_type,
1348 r_symndx,
1349 (long)offset,
1350 (long)addend);
1351 #endif
1352 continue;
1353 }
1354
1355 /* This is a final link. */
1356 if (r_symndx < symtab_hdr->sh_info)
1357 {
1358 sym = local_syms + r_symndx;
1359 sec = local_sections[r_symndx];
1360 sym_name = "<local symbol>";
1361
1362 relocation = (sec->output_section->vma
1363 + sec->output_offset
1364 + sym->st_value);
1365 }
1366 else
1367 {
1368 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1369 while (h->root.type == bfd_link_hash_indirect
1370 || h->root.type == bfd_link_hash_warning)
1371 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1372 sym_name = h->root.root.string;
1373 if (h->root.type == bfd_link_hash_defined
1374 || h->root.type == bfd_link_hash_defweak)
1375 {
1376 sec = h->root.u.def.section;
1377 if (info->shared
1378 && ((! info->symbolic && h->dynindx != -1)
1379 || (h->elf_link_hash_flags
1380 & ELF_LINK_HASH_DEF_REGULAR) == 0)
1381 && (input_section->flags & SEC_ALLOC) != 0
1382 && (r_type == R_I370_ADDR31
1383 || r_type == R_I370_COPY
1384 || r_type == R_I370_ADDR16
1385 || r_type == R_I370_RELATIVE))
1386 {
1387 /* In these cases, we don't need the relocation
1388 value. We check specially because in some
1389 obscure cases sec->output_section will be NULL. */
1390 relocation = 0;
1391 }
1392 else
1393 relocation = (h->root.u.def.value
1394 + sec->output_section->vma
1395 + sec->output_offset);
1396 }
1397 else if (h->root.type == bfd_link_hash_undefweak)
1398 relocation = 0;
1399 else if (info->shared
1400 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1401 relocation = 0;
1402 else
1403 {
1404 (*info->callbacks->undefined_symbol) (info,
1405 h->root.root.string,
1406 input_bfd,
1407 input_section,
1408 rel->r_offset,
1409 true);
1410 ret = false;
1411 continue;
1412 }
1413 }
1414
1415 switch ((int)r_type)
1416 {
1417 default:
1418 (*_bfd_error_handler) ("%s: unknown relocation type %d for symbol %s",
1419 bfd_get_filename (input_bfd),
1420 (int)r_type, sym_name);
1421
1422 bfd_set_error (bfd_error_bad_value);
1423 ret = false;
1424 continue;
1425
1426 /* Relocations that may need to be propagated if this is a shared
1427 object. */
1428 case (int)R_I370_REL31:
1429 /* If these relocations are not to a named symbol, they can be
1430 handled right here, no need to bother the dynamic linker. */
1431 if (h == NULL
1432 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1433 break;
1434 /* fall through */
1435
1436 /* Relocations that always need to be propagated if this is a shared
1437 object. */
1438 case (int)R_I370_NONE:
1439 case (int)R_I370_ADDR31:
1440 case (int)R_I370_ADDR16:
1441 if (info->shared)
1442 {
1443 Elf_Internal_Rela outrel;
1444 boolean skip;
1445
1446 #ifdef DEBUG
1447 fprintf (stderr,
1448 "i370_elf_relocate_section needs to create relocation for %s\n",
1449 (h && h->root.root.string) ? h->root.root.string : "<unknown>");
1450 #endif
1451
1452 /* When generating a shared object, these relocations
1453 are copied into the output file to be resolved at run
1454 time. */
1455
1456 if (sreloc == NULL)
1457 {
1458 const char *name;
1459
1460 name = (bfd_elf_string_from_elf_section
1461 (input_bfd,
1462 elf_elfheader (input_bfd)->e_shstrndx,
1463 elf_section_data (input_section)->rel_hdr.sh_name));
1464 if (name == NULL)
1465 return false;
1466
1467 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1468 && strcmp (bfd_get_section_name (input_bfd,
1469 input_section),
1470 name + 5) == 0);
1471
1472 sreloc = bfd_get_section_by_name (dynobj, name);
1473 BFD_ASSERT (sreloc != NULL);
1474 }
1475
1476 skip = false;
1477
1478 if (elf_section_data (input_section)->stab_info == NULL)
1479 outrel.r_offset = rel->r_offset;
1480 else
1481 {
1482 bfd_vma off;
1483
1484 off = (_bfd_stab_section_offset
1485 (output_bfd, &elf_hash_table (info)->stab_info,
1486 input_section,
1487 &elf_section_data (input_section)->stab_info,
1488 rel->r_offset));
1489 if (off == (bfd_vma) -1)
1490 skip = true;
1491 outrel.r_offset = off;
1492 }
1493
1494 outrel.r_offset += (input_section->output_section->vma
1495 + input_section->output_offset);
1496
1497 if (skip)
1498 memset (&outrel, 0, sizeof outrel);
1499 /* h->dynindx may be -1 if this symbol was marked to
1500 become local. */
1501 else if (h != NULL
1502 && ((! info->symbolic && h->dynindx != -1)
1503 || (h->elf_link_hash_flags
1504 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1505 {
1506 BFD_ASSERT (h->dynindx != -1);
1507 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1508 outrel.r_addend = rel->r_addend;
1509 }
1510 else
1511 {
1512 if (r_type == R_I370_ADDR31)
1513 {
1514 outrel.r_info = ELF32_R_INFO (0, R_I370_RELATIVE);
1515 outrel.r_addend = relocation + rel->r_addend;
1516 }
1517 else
1518 {
1519 long indx;
1520
1521 if (h == NULL)
1522 sec = local_sections[r_symndx];
1523 else
1524 {
1525 BFD_ASSERT (h->root.type == bfd_link_hash_defined
1526 || (h->root.type
1527 == bfd_link_hash_defweak));
1528 sec = h->root.u.def.section;
1529 }
1530 if (sec != NULL && bfd_is_abs_section (sec))
1531 indx = 0;
1532 else if (sec == NULL || sec->owner == NULL)
1533 {
1534 bfd_set_error (bfd_error_bad_value);
1535 return false;
1536 }
1537 else
1538 {
1539 asection *osec;
1540
1541 osec = sec->output_section;
1542 indx = elf_section_data (osec)->dynindx;
1543 BFD_ASSERT(indx > 0);
1544 #ifdef DEBUG
1545 if (indx <= 0)
1546 {
1547 printf ("indx=%d section=%s flags=%08x name=%s\n",
1548 indx, osec->name, osec->flags,
1549 h->root.root.string);
1550 }
1551 #endif
1552 }
1553
1554 outrel.r_info = ELF32_R_INFO (indx, r_type);
1555 outrel.r_addend = relocation + rel->r_addend;
1556 }
1557 }
1558
1559 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1560 (((Elf32_External_Rela *)
1561 sreloc->contents)
1562 + sreloc->reloc_count));
1563 ++sreloc->reloc_count;
1564
1565 /* This reloc will be computed at runtime, so there's no
1566 need to do anything now, unless this is a RELATIVE
1567 reloc in an unallocated section. */
1568 if (skip
1569 || (input_section->flags & SEC_ALLOC) != 0
1570 || ELF32_R_TYPE (outrel.r_info) != R_I370_RELATIVE)
1571 continue;
1572 }
1573 break;
1574
1575 case (int)R_I370_COPY:
1576 case (int)R_I370_RELATIVE:
1577 (*_bfd_error_handler) ("%s: Relocation %s is not yet supported for symbol %s.",
1578 bfd_get_filename (input_bfd),
1579 i370_elf_howto_table[ (int)r_type ]->name,
1580 sym_name);
1581
1582 bfd_set_error (bfd_error_invalid_operation);
1583 ret = false;
1584 continue;
1585 }
1586
1587 #ifdef DEBUG
1588 fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, offset = %ld, addend = %ld\n",
1589 howto->name,
1590 (int)r_type,
1591 sym_name,
1592 r_symndx,
1593 (long)offset,
1594 (long)addend);
1595 #endif
1596
1597 r = _bfd_final_link_relocate (howto,
1598 input_bfd,
1599 input_section,
1600 contents,
1601 offset,
1602 relocation,
1603 addend);
1604
1605 if (r != bfd_reloc_ok)
1606 {
1607 ret = false;
1608 switch (r)
1609 {
1610 default:
1611 break;
1612
1613 case bfd_reloc_overflow:
1614 {
1615 const char *name;
1616
1617 if (h != NULL)
1618 name = h->root.root.string;
1619 else
1620 {
1621 name = bfd_elf_string_from_elf_section (input_bfd,
1622 symtab_hdr->sh_link,
1623 sym->st_name);
1624 if (name == NULL)
1625 break;
1626
1627 if (*name == '\0')
1628 name = bfd_section_name (input_bfd, sec);
1629 }
1630
1631 (*info->callbacks->reloc_overflow) (info,
1632 name,
1633 howto->name,
1634 (bfd_vma) 0,
1635 input_bfd,
1636 input_section,
1637 offset);
1638 }
1639 break;
1640
1641 }
1642 }
1643 }
1644
1645 #ifdef DEBUG
1646 fprintf (stderr, "\n");
1647 #endif
1648
1649 return ret;
1650 }
1651
1652 static void
1653 i370_elf_post_process_headers (abfd, link_info)
1654 bfd * abfd;
1655 struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
1656 {
1657 Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form */
1658
1659 i_ehdrp = elf_elfheader (abfd);
1660 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_LINUX;
1661 }
1662 \f
1663 #define TARGET_BIG_SYM bfd_elf32_i370_vec
1664 #define TARGET_BIG_NAME "elf32-i370"
1665 #define ELF_ARCH bfd_arch_i370
1666 #define ELF_MACHINE_CODE EM_S370
1667 #ifdef EM_I370_OLD
1668 #define ELF_MACHINE_ALT1 EM_I370_OLD
1669 #endif
1670 #define ELF_MAXPAGESIZE 0x1000
1671 #define elf_info_to_howto i370_elf_info_to_howto
1672
1673 #define elf_backend_plt_not_loaded 1
1674 #define elf_backend_got_symbol_offset 4
1675
1676 #define bfd_elf32_bfd_reloc_type_lookup i370_elf_reloc_type_lookup
1677 #define bfd_elf32_bfd_set_private_flags i370_elf_set_private_flags
1678 #define bfd_elf32_bfd_copy_private_bfd_data i370_elf_copy_private_bfd_data
1679 #define bfd_elf32_bfd_merge_private_bfd_data i370_elf_merge_private_bfd_data
1680 #define elf_backend_relocate_section i370_elf_relocate_section
1681
1682 /* dynamic loader support is mostly broken; just enough here to be able to
1683 * link glibc's ld.so without errors.
1684 */
1685 #define elf_backend_create_dynamic_sections i370_elf_create_dynamic_sections
1686 #define elf_backend_size_dynamic_sections i370_elf_size_dynamic_sections
1687 #define elf_backend_finish_dynamic_sections i370_elf_finish_dynamic_sections
1688 #define elf_backend_fake_sections i370_elf_fake_sections
1689 #define elf_backend_section_from_shdr i370_elf_section_from_shdr
1690 #define elf_backend_adjust_dynamic_symbol i370_elf_adjust_dynamic_symbol
1691 #define elf_backend_check_relocs i370_elf_check_relocs
1692
1693 /*
1694 #define elf_backend_add_symbol_hook i370_elf_add_symbol_hook
1695 #define elf_backend_finish_dynamic_symbol i370_elf_finish_dynamic_symbol
1696 #define elf_backend_additional_program_headers i370_elf_additional_program_headers
1697 #define elf_backend_modify_segment_map i370_elf_modify_segment_map
1698 */
1699
1700 #define elf_backend_post_process_headers i370_elf_post_process_headers
1701
1702 int i370_noop()
1703 {
1704 return 1;
1705 }
1706
1707 /* we need to define these at least as no-ops to link glibc ld.so */
1708
1709 #define elf_backend_add_symbol_hook \
1710 (boolean (*) PARAMS ((bfd *, struct bfd_link_info *, \
1711 const Elf_Internal_Sym *, const char **, flagword *, \
1712 asection **, bfd_vma *))) i370_noop
1713 #define elf_backend_finish_dynamic_symbol \
1714 (boolean (*) PARAMS ((bfd *, struct bfd_link_info *, \
1715 struct elf_link_hash_entry *, \
1716 Elf_Internal_Sym *))) i370_noop
1717 #define elf_backend_additional_program_headers \
1718 (int (*) PARAMS ((bfd *))) i370_noop
1719 #define elf_backend_modify_segment_map \
1720 (boolean (*) PARAMS ((bfd *))) i370_noop
1721
1722 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.088233 seconds and 4 git commands to generate.