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