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