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