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