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