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