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