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