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