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