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