projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
2005-03-20 H.J. Lu <hongjiu.lu@intel.com>
[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_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 (abfd, ".dynsbss");
453 if (s == NULL
454 || ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
455 return FALSE;
456
457 if (! info->shared)
458 {
459 s = bfd_make_section (abfd, ".rela.sbss");
460 if (s == NULL
461 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
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 (abfd, ".rela.text");
468 if (s == NULL
469 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
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 asection **spp;
760
761 for (spp = &s->output_section->owner->sections;
762 *spp != NULL;
763 spp = &(*spp)->next)
764 {
765 if (*spp == s->output_section)
766 {
767 bfd_section_list_remove (s->output_section->owner, spp);
768 --s->output_section->owner->section_count;
769 break;
770 }
771 }
772 continue;
773 }
774 /* Allocate memory for the section contents. */
775 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
776 if (s->contents == NULL && s->size != 0)
777 return FALSE;
778 }
779
780 if (elf_hash_table (info)->dynamic_sections_created)
781 {
782 /* Add some entries to the .dynamic section. We fill in the
783 values later, in i370_elf_finish_dynamic_sections, but we
784 must add the entries now so that we get the correct size for
785 the .dynamic section. The DT_DEBUG entry is filled in by the
786 dynamic linker and used by the debugger. */
787 #define add_dynamic_entry(TAG, VAL) \
788 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
789
790 if (!info->shared)
791 {
792 if (!add_dynamic_entry (DT_DEBUG, 0))
793 return FALSE;
794 }
795
796 if (plt)
797 {
798 if (!add_dynamic_entry (DT_PLTGOT, 0)
799 || !add_dynamic_entry (DT_PLTRELSZ, 0)
800 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
801 || !add_dynamic_entry (DT_JMPREL, 0))
802 return FALSE;
803 }
804
805 if (relocs)
806 {
807 if (!add_dynamic_entry (DT_RELA, 0)
808 || !add_dynamic_entry (DT_RELASZ, 0)
809 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
810 return FALSE;
811 }
812
813 if (reltext)
814 {
815 if (!add_dynamic_entry (DT_TEXTREL, 0))
816 return FALSE;
817 info->flags |= DF_TEXTREL;
818 }
819 }
820 #undef add_dynamic_entry
821
822 /* If we are generating a shared library, we generate a section
823 symbol for each output section. These are local symbols, which
824 means that they must come first in the dynamic symbol table.
825 That means we must increment the dynamic symbol index of every
826 other dynamic symbol.
827
828 FIXME: We assume that there will never be relocations to
829 locations in linker-created sections that do not have
830 externally-visible names. Instead, we should work out precisely
831 which sections relocations are targeted at. */
832 if (info->shared)
833 {
834 int c;
835
836 for (c = 0, s = output_bfd->sections; s != NULL; s = s->next)
837 {
838 if ((s->flags & SEC_LINKER_CREATED) != 0
839 || (s->flags & SEC_ALLOC) == 0)
840 {
841 elf_section_data (s)->dynindx = -1;
842 continue;
843 }
844
845 /* These symbols will have no names, so we don't need to
846 fiddle with dynstr_index. */
847
848 elf_section_data (s)->dynindx = c + 1;
849
850 c++;
851 }
852
853 elf_link_hash_traverse (elf_hash_table (info),
854 i370_elf_adjust_dynindx,
855 (PTR) &c);
856 elf_hash_table (info)->dynsymcount += c;
857 }
858
859 return TRUE;
860 }
861 \f
862 /* Look through the relocs for a section during the first phase, and
863 allocate space in the global offset table or procedure linkage
864 table. */
865 /* XXX hack alert bogus This routine is mostly all junk and almost
866 * certainly does the wrong thing. Its here simply because it does
867 * just enough to allow glibc-2.1 ld.so to compile & link.
868 */
869
870 static bfd_boolean
871 i370_elf_check_relocs (abfd, info, sec, relocs)
872 bfd *abfd;
873 struct bfd_link_info *info;
874 asection *sec;
875 const Elf_Internal_Rela *relocs;
876 {
877 bfd *dynobj;
878 Elf_Internal_Shdr *symtab_hdr;
879 struct elf_link_hash_entry **sym_hashes;
880 const Elf_Internal_Rela *rel;
881 const Elf_Internal_Rela *rel_end;
882 bfd_vma *local_got_offsets;
883 asection *sreloc;
884
885 if (info->relocatable)
886 return TRUE;
887
888 #ifdef DEBUG
889 _bfd_error_handler ("i370_elf_check_relocs called for section %A in %B",
890 sec, abfd);
891 #endif
892
893 dynobj = elf_hash_table (info)->dynobj;
894 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
895 sym_hashes = elf_sym_hashes (abfd);
896 local_got_offsets = elf_local_got_offsets (abfd);
897
898 sreloc = NULL;
899
900 rel_end = relocs + sec->reloc_count;
901 for (rel = relocs; rel < rel_end; rel++)
902 {
903 unsigned long r_symndx;
904 struct elf_link_hash_entry *h;
905
906 r_symndx = ELF32_R_SYM (rel->r_info);
907 if (r_symndx < symtab_hdr->sh_info)
908 h = NULL;
909 else
910 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
911
912 if (info->shared)
913 {
914 #ifdef DEBUG
915 fprintf (stderr,
916 "i370_elf_check_relocs needs to create relocation for %s\n",
917 (h && h->root.root.string)
918 ? h->root.root.string : "<unknown>");
919 #endif
920 if (sreloc == NULL)
921 {
922 const char *name;
923
924 name = (bfd_elf_string_from_elf_section
925 (abfd,
926 elf_elfheader (abfd)->e_shstrndx,
927 elf_section_data (sec)->rel_hdr.sh_name));
928 if (name == NULL)
929 return FALSE;
930
931 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
932 && strcmp (bfd_get_section_name (abfd, sec), name + 5) == 0);
933
934 sreloc = bfd_get_section_by_name (dynobj, name);
935 if (sreloc == NULL)
936 {
937 flagword flags;
938
939 sreloc = bfd_make_section (dynobj, name);
940 flags = (SEC_HAS_CONTENTS | SEC_READONLY
941 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
942 if ((sec->flags & SEC_ALLOC) != 0)
943 flags |= SEC_ALLOC | SEC_LOAD;
944 if (sreloc == NULL
945 || ! bfd_set_section_flags (dynobj, sreloc, flags)
946 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
947 return FALSE;
948 }
949 }
950
951 sreloc->size += sizeof (Elf32_External_Rela);
952
953 /* FIXME: We should here do what the m68k and i386
954 backends do: if the reloc is pc-relative, record it
955 in case it turns out that the reloc is unnecessary
956 because the symbol is forced local by versioning or
957 we are linking with -Bdynamic. Fortunately this
958 case is not frequent. */
959 }
960 }
961
962 return TRUE;
963 }
964 \f
965 /* Finish up the dynamic sections. */
966 /* XXX hack alert bogus This routine is mostly all junk and almost
967 * certainly does the wrong thing. Its here simply because it does
968 * just enough to allow glibc-2.1 ld.so to compile & link.
969 */
970
971 static bfd_boolean
972 i370_elf_finish_dynamic_sections (output_bfd, info)
973 bfd *output_bfd;
974 struct bfd_link_info *info;
975 {
976 asection *sdyn;
977 bfd *dynobj = elf_hash_table (info)->dynobj;
978 asection *sgot = bfd_get_section_by_name (dynobj, ".got");
979
980 #ifdef DEBUG
981 fprintf (stderr, "i370_elf_finish_dynamic_sections called\n");
982 #endif
983
984 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
985
986 if (elf_hash_table (info)->dynamic_sections_created)
987 {
988 asection *splt;
989 Elf32_External_Dyn *dyncon, *dynconend;
990
991 splt = bfd_get_section_by_name (dynobj, ".plt");
992 BFD_ASSERT (splt != NULL && sdyn != NULL);
993
994 dyncon = (Elf32_External_Dyn *) sdyn->contents;
995 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
996 for (; dyncon < dynconend; dyncon++)
997 {
998 Elf_Internal_Dyn dyn;
999 const char *name;
1000 bfd_boolean size;
1001
1002 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1003
1004 switch (dyn.d_tag)
1005 {
1006 case DT_PLTGOT: name = ".plt"; size = FALSE; break;
1007 case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
1008 case DT_JMPREL: name = ".rela.plt"; size = FALSE; break;
1009 default: name = NULL; size = FALSE; break;
1010 }
1011
1012 if (name != NULL)
1013 {
1014 asection *s;
1015
1016 s = bfd_get_section_by_name (output_bfd, name);
1017 if (s == NULL)
1018 dyn.d_un.d_val = 0;
1019 else
1020 {
1021 if (! size)
1022 dyn.d_un.d_ptr = s->vma;
1023 else
1024 dyn.d_un.d_val = s->size;
1025 }
1026 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1027 }
1028 }
1029 }
1030
1031 /* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4 so that a function can
1032 easily find the address of the _GLOBAL_OFFSET_TABLE_. */
1033 /* XXX this is clearly very wrong for the 370 arch */
1034 if (sgot)
1035 {
1036 unsigned char *contents = sgot->contents;
1037 bfd_put_32 (output_bfd, (bfd_vma) 0x4e800021 /* blrl */, contents);
1038
1039 if (sdyn == NULL)
1040 bfd_put_32 (output_bfd, (bfd_vma) 0, contents+4);
1041 else
1042 bfd_put_32 (output_bfd,
1043 sdyn->output_section->vma + sdyn->output_offset,
1044 contents+4);
1045
1046 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1047 }
1048
1049 if (info->shared)
1050 {
1051 asection *sdynsym;
1052 asection *s;
1053 Elf_Internal_Sym sym;
1054 int maxdindx = 0;
1055
1056 /* Set up the section symbols for the output sections. */
1057
1058 sdynsym = bfd_get_section_by_name (dynobj, ".dynsym");
1059 BFD_ASSERT (sdynsym != NULL);
1060
1061 sym.st_size = 0;
1062 sym.st_name = 0;
1063 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
1064 sym.st_other = 0;
1065
1066 for (s = output_bfd->sections; s != NULL; s = s->next)
1067 {
1068 int indx, dindx;
1069 Elf32_External_Sym *esym;
1070
1071 sym.st_value = s->vma;
1072
1073 indx = elf_section_data (s)->this_idx;
1074 dindx = elf_section_data (s)->dynindx;
1075 if (dindx != -1)
1076 {
1077 BFD_ASSERT(indx > 0);
1078 BFD_ASSERT(dindx > 0);
1079
1080 if (dindx > maxdindx)
1081 maxdindx = dindx;
1082
1083 sym.st_shndx = indx;
1084
1085 esym = (Elf32_External_Sym *) sdynsym->contents + dindx;
1086 bfd_elf32_swap_symbol_out (output_bfd, &sym, (PTR) esym, (PTR) 0);
1087 }
1088 }
1089
1090 /* Set the sh_info field of the output .dynsym section to the
1091 index of the first global symbol. */
1092 elf_section_data (sdynsym->output_section)->this_hdr.sh_info =
1093 maxdindx + 1;
1094 }
1095
1096 return TRUE;
1097 }
1098 \f
1099 /* The RELOCATE_SECTION function is called by the ELF backend linker
1100 to handle the relocations for a section.
1101
1102 The relocs are always passed as Rela structures; if the section
1103 actually uses Rel structures, the r_addend field will always be
1104 zero.
1105
1106 This function is responsible for adjust the section contents as
1107 necessary, and (if using Rela relocs and generating a
1108 relocatable output file) adjusting the reloc addend as
1109 necessary.
1110
1111 This function does not have to worry about setting the reloc
1112 address or the reloc symbol index.
1113
1114 LOCAL_SYMS is a pointer to the swapped in local symbols.
1115
1116 LOCAL_SECTIONS is an array giving the section in the input file
1117 corresponding to the st_shndx field of each local symbol.
1118
1119 The global hash table entry for the global symbols can be found
1120 via elf_sym_hashes (input_bfd).
1121
1122 When generating relocatable output, this function must handle
1123 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1124 going to be the section symbol corresponding to the output
1125 section, which means that the addend must be adjusted
1126 accordingly. */
1127
1128 static bfd_boolean
1129 i370_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1130 contents, relocs, local_syms, local_sections)
1131 bfd *output_bfd;
1132 struct bfd_link_info *info;
1133 bfd *input_bfd;
1134 asection *input_section;
1135 bfd_byte *contents;
1136 Elf_Internal_Rela *relocs;
1137 Elf_Internal_Sym *local_syms;
1138 asection **local_sections;
1139 {
1140 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1141 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
1142 bfd *dynobj = elf_hash_table (info)->dynobj;
1143 Elf_Internal_Rela *rel = relocs;
1144 Elf_Internal_Rela *relend = relocs + input_section->reloc_count;
1145 asection *sreloc = NULL;
1146 bfd_vma *local_got_offsets;
1147 bfd_boolean ret = TRUE;
1148
1149 if (info->relocatable)
1150 return TRUE;
1151
1152 #ifdef DEBUG
1153 _bfd_error_handler ("i370_elf_relocate_section called for %B section %A, %ld relocations%s",
1154 input_bfd, input_section,
1155 (long) input_section->reloc_count,
1156 (info->relocatable) ? " (relocatable)" : "");
1157 #endif
1158
1159 if (!i370_elf_howto_table[ R_I370_ADDR31 ]) /* Initialize howto table if needed */
1160 i370_elf_howto_init ();
1161
1162 local_got_offsets = elf_local_got_offsets (input_bfd);
1163
1164 for (; rel < relend; rel++)
1165 {
1166 enum i370_reloc_type r_type = (enum i370_reloc_type)ELF32_R_TYPE (rel->r_info);
1167 bfd_vma offset = rel->r_offset;
1168 bfd_vma addend = rel->r_addend;
1169 bfd_reloc_status_type r = bfd_reloc_other;
1170 Elf_Internal_Sym *sym = (Elf_Internal_Sym *)0;
1171 asection *sec = (asection *)0;
1172 struct elf_link_hash_entry *h = (struct elf_link_hash_entry *)0;
1173 const char *sym_name = (const char *)0;
1174 reloc_howto_type *howto;
1175 unsigned long r_symndx;
1176 bfd_vma relocation;
1177
1178 /* Unknown relocation handling */
1179 if ((unsigned)r_type >= (unsigned)R_I370_max
1180 || !i370_elf_howto_table[(int)r_type])
1181 {
1182 (*_bfd_error_handler) ("%B: unknown relocation type %d",
1183 input_bfd,
1184 (int) r_type);
1185
1186 bfd_set_error (bfd_error_bad_value);
1187 ret = FALSE;
1188 continue;
1189 }
1190
1191 howto = i370_elf_howto_table[(int)r_type];
1192 r_symndx = ELF32_R_SYM (rel->r_info);
1193
1194 if (r_symndx < symtab_hdr->sh_info)
1195 {
1196 sym = local_syms + r_symndx;
1197 sec = local_sections[r_symndx];
1198 sym_name = "<local symbol>";
1199
1200 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1201 addend = rel->r_addend;
1202 }
1203 else
1204 {
1205 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1206 while (h->root.type == bfd_link_hash_indirect
1207 || h->root.type == bfd_link_hash_warning)
1208 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1209 sym_name = h->root.root.string;
1210 if (h->root.type == bfd_link_hash_defined
1211 || h->root.type == bfd_link_hash_defweak)
1212 {
1213 sec = h->root.u.def.section;
1214 if (info->shared
1215 && ((! info->symbolic && h->dynindx != -1)
1216 || !h->def_regular)
1217 && (input_section->flags & SEC_ALLOC) != 0
1218 && (r_type == R_I370_ADDR31
1219 || r_type == R_I370_COPY
1220 || r_type == R_I370_ADDR16
1221 || r_type == R_I370_RELATIVE))
1222 {
1223 /* In these cases, we don't need the relocation
1224 value. We check specially because in some
1225 obscure cases sec->output_section will be NULL. */
1226 relocation = 0;
1227 }
1228 else
1229 relocation = (h->root.u.def.value
1230 + sec->output_section->vma
1231 + sec->output_offset);
1232 }
1233 else if (h->root.type == bfd_link_hash_undefweak)
1234 relocation = 0;
1235 else if (info->unresolved_syms_in_objects == RM_IGNORE
1236 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1237 relocation = 0;
1238 else
1239 {
1240 if ((*info->callbacks->undefined_symbol)
1241 (info, h->root.root.string, input_bfd,
1242 input_section, rel->r_offset,
1243 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
1244 || ELF_ST_VISIBILITY (h->other))))
1245 {
1246 ret = FALSE;
1247 continue;
1248 }
1249 relocation = 0;
1250 }
1251 }
1252
1253 switch ((int) r_type)
1254 {
1255 default:
1256 (*_bfd_error_handler)
1257 ("%B: unknown relocation type %d for symbol %s",
1258 input_bfd, (int) r_type, sym_name);
1259
1260 bfd_set_error (bfd_error_bad_value);
1261 ret = FALSE;
1262 continue;
1263
1264 case (int)R_I370_NONE:
1265 continue;
1266
1267 /* Relocations that may need to be propagated if this is a shared
1268 object. */
1269 case (int)R_I370_REL31:
1270 /* If these relocations are not to a named symbol, they can be
1271 handled right here, no need to bother the dynamic linker. */
1272 if (h == NULL
1273 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1274 break;
1275 /* fall through */
1276
1277 /* Relocations that always need to be propagated if this is a shared
1278 object. */
1279 case (int)R_I370_ADDR31:
1280 case (int)R_I370_ADDR16:
1281 if (info->shared
1282 && r_symndx != 0)
1283 {
1284 Elf_Internal_Rela outrel;
1285 bfd_byte *loc;
1286 int skip;
1287
1288 #ifdef DEBUG
1289 fprintf (stderr,
1290 "i370_elf_relocate_section needs to create relocation for %s\n",
1291 (h && h->root.root.string) ? h->root.root.string : "<unknown>");
1292 #endif
1293
1294 /* When generating a shared object, these relocations
1295 are copied into the output file to be resolved at run
1296 time. */
1297
1298 if (sreloc == NULL)
1299 {
1300 const char *name;
1301
1302 name = (bfd_elf_string_from_elf_section
1303 (input_bfd,
1304 elf_elfheader (input_bfd)->e_shstrndx,
1305 elf_section_data (input_section)->rel_hdr.sh_name));
1306 if (name == NULL)
1307 return FALSE;
1308
1309 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1310 && strcmp (bfd_get_section_name (input_bfd,
1311 input_section),
1312 name + 5) == 0);
1313
1314 sreloc = bfd_get_section_by_name (dynobj, name);
1315 BFD_ASSERT (sreloc != NULL);
1316 }
1317
1318 skip = 0;
1319
1320 outrel.r_offset =
1321 _bfd_elf_section_offset (output_bfd, info, input_section,
1322 rel->r_offset);
1323 if (outrel.r_offset == (bfd_vma) -1
1324 || outrel.r_offset == (bfd_vma) -2)
1325 skip = (int) outrel.r_offset;
1326 outrel.r_offset += (input_section->output_section->vma
1327 + input_section->output_offset);
1328
1329 if (skip)
1330 memset (&outrel, 0, sizeof outrel);
1331 /* h->dynindx may be -1 if this symbol was marked to
1332 become local. */
1333 else if (h != NULL
1334 && ((! info->symbolic && h->dynindx != -1)
1335 || !h->def_regular))
1336 {
1337 BFD_ASSERT (h->dynindx != -1);
1338 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1339 outrel.r_addend = rel->r_addend;
1340 }
1341 else
1342 {
1343 if (r_type == R_I370_ADDR31)
1344 {
1345 outrel.r_info = ELF32_R_INFO (0, R_I370_RELATIVE);
1346 outrel.r_addend = relocation + rel->r_addend;
1347 }
1348 else
1349 {
1350 long indx;
1351
1352 if (bfd_is_abs_section (sec))
1353 indx = 0;
1354 else if (sec == NULL || sec->owner == NULL)
1355 {
1356 bfd_set_error (bfd_error_bad_value);
1357 return FALSE;
1358 }
1359 else
1360 {
1361 asection *osec;
1362
1363 osec = sec->output_section;
1364 indx = elf_section_data (osec)->dynindx;
1365 BFD_ASSERT(indx > 0);
1366 #ifdef DEBUG
1367 if (indx <= 0)
1368 {
1369 printf ("indx=%d section=%s flags=%08x name=%s\n",
1370 indx, osec->name, osec->flags,
1371 h->root.root.string);
1372 }
1373 #endif
1374 }
1375
1376 outrel.r_info = ELF32_R_INFO (indx, r_type);
1377 outrel.r_addend = relocation + rel->r_addend;
1378 }
1379 }
1380
1381 loc = sreloc->contents;
1382 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1383 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1384
1385 /* This reloc will be computed at runtime, so there's no
1386 need to do anything now, unless this is a RELATIVE
1387 reloc in an unallocated section. */
1388 if (skip == -1
1389 || (input_section->flags & SEC_ALLOC) != 0
1390 || ELF32_R_TYPE (outrel.r_info) != R_I370_RELATIVE)
1391 continue;
1392 }
1393 break;
1394
1395 case (int)R_I370_COPY:
1396 case (int)R_I370_RELATIVE:
1397 (*_bfd_error_handler)
1398 ("%B: Relocation %s is not yet supported for symbol %s.",
1399 input_bfd,
1400 i370_elf_howto_table[(int) r_type]->name,
1401 sym_name);
1402
1403 bfd_set_error (bfd_error_invalid_operation);
1404 ret = FALSE;
1405 continue;
1406 }
1407
1408 #ifdef DEBUG
1409 fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, offset = %ld, addend = %ld\n",
1410 howto->name,
1411 (int)r_type,
1412 sym_name,
1413 r_symndx,
1414 (long)offset,
1415 (long)addend);
1416 #endif
1417
1418 r = _bfd_final_link_relocate (howto,
1419 input_bfd,
1420 input_section,
1421 contents,
1422 offset,
1423 relocation,
1424 addend);
1425
1426 if (r != bfd_reloc_ok)
1427 {
1428 ret = FALSE;
1429 switch (r)
1430 {
1431 default:
1432 break;
1433
1434 case bfd_reloc_overflow:
1435 {
1436 const char *name;
1437
1438 if (h != NULL)
1439 name = NULL;
1440 else
1441 {
1442 name = bfd_elf_string_from_elf_section (input_bfd,
1443 symtab_hdr->sh_link,
1444 sym->st_name);
1445 if (name == NULL)
1446 break;
1447
1448 if (*name == '\0')
1449 name = bfd_section_name (input_bfd, sec);
1450 }
1451
1452 (*info->callbacks->reloc_overflow) (info,
1453 (h ? &h->root : NULL),
1454 name,
1455 howto->name,
1456 (bfd_vma) 0,
1457 input_bfd,
1458 input_section,
1459 offset);
1460 }
1461 break;
1462
1463 }
1464 }
1465 }
1466
1467 #ifdef DEBUG
1468 fprintf (stderr, "\n");
1469 #endif
1470
1471 return ret;
1472 }
1473
1474 static void
1475 i370_elf_post_process_headers (abfd, link_info)
1476 bfd * abfd;
1477 struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
1478 {
1479 Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form */
1480
1481 i_ehdrp = elf_elfheader (abfd);
1482 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_LINUX;
1483 }
1484 \f
1485 #define TARGET_BIG_SYM bfd_elf32_i370_vec
1486 #define TARGET_BIG_NAME "elf32-i370"
1487 #define ELF_ARCH bfd_arch_i370
1488 #define ELF_MACHINE_CODE EM_S370
1489 #ifdef EM_I370_OLD
1490 #define ELF_MACHINE_ALT1 EM_I370_OLD
1491 #endif
1492 #define ELF_MAXPAGESIZE 0x1000
1493 #define elf_info_to_howto i370_elf_info_to_howto
1494
1495 #define elf_backend_plt_not_loaded 1
1496 #define elf_backend_got_symbol_offset 4
1497 #define elf_backend_rela_normal 1
1498
1499 #define bfd_elf32_bfd_reloc_type_lookup i370_elf_reloc_type_lookup
1500 #define bfd_elf32_bfd_set_private_flags i370_elf_set_private_flags
1501 #define bfd_elf32_bfd_merge_private_bfd_data i370_elf_merge_private_bfd_data
1502 #define elf_backend_relocate_section i370_elf_relocate_section
1503
1504 /* dynamic loader support is mostly broken; just enough here to be able to
1505 * link glibc's ld.so without errors.
1506 */
1507 #define elf_backend_create_dynamic_sections i370_elf_create_dynamic_sections
1508 #define elf_backend_size_dynamic_sections i370_elf_size_dynamic_sections
1509 #define elf_backend_finish_dynamic_sections i370_elf_finish_dynamic_sections
1510 #define elf_backend_fake_sections i370_elf_fake_sections
1511 #define elf_backend_section_from_shdr i370_elf_section_from_shdr
1512 #define elf_backend_adjust_dynamic_symbol i370_elf_adjust_dynamic_symbol
1513 #define elf_backend_check_relocs i370_elf_check_relocs
1514
1515 /*
1516 #define elf_backend_add_symbol_hook i370_elf_add_symbol_hook
1517 #define elf_backend_finish_dynamic_symbol i370_elf_finish_dynamic_symbol
1518 #define elf_backend_additional_program_headers i370_elf_additional_program_headers
1519 #define elf_backend_modify_segment_map i370_elf_modify_segment_map
1520 */
1521
1522 #define elf_backend_post_process_headers i370_elf_post_process_headers
1523
1524 static int i370_noop
1525 PARAMS ((void));
1526
1527 static int i370_noop ()
1528 {
1529 return 1;
1530 }
1531
1532 /* we need to define these at least as no-ops to link glibc ld.so */
1533
1534 #define elf_backend_add_symbol_hook \
1535 (bfd_boolean (*) \
1536 PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Sym *, \
1537 const char **, flagword *, asection **, bfd_vma *))) i370_noop
1538 #define elf_backend_finish_dynamic_symbol \
1539 (bfd_boolean (*) \
1540 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, \
1541 Elf_Internal_Sym *))) i370_noop
1542 #define elf_backend_additional_program_headers \
1543 (int (*) PARAMS ((bfd *))) i370_noop
1544 #define elf_backend_modify_segment_map \
1545 (bfd_boolean (*) PARAMS ((bfd *, struct bfd_link_info *))) i370_noop
1546
1547 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.099645 seconds and 4 git commands to generate.