projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
PR ld/15323
[deliverable/binutils-gdb.git] / bfd / elf32-i370.c
1 /* i370-specific support for 32-bit ELF
2 Copyright 1994, 1995, 1996, 1997, 1998, 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007, 2008, 2010, 2011, 2012 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 \f
229 /* Initialize the i370_elf_howto_table, so that linear accesses can be done. */
230
231 static 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 *
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 *
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
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
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
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 \f
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
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 \f
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
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 \f
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
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_anyway_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_anyway_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_anyway_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
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_linker_section (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 /* We must allocate the symbol in our .dynbss section, which will
502 become part of the .bss section of the executable. There will be
503 an entry for this symbol in the .dynsym section. The dynamic
504 object will contain position independent code, so all references
505 from the dynamic object to this symbol will go through the global
506 offset table. The dynamic linker will use the .dynsym entry to
507 determine the address it must put in the global offset table, so
508 both the dynamic object and the regular object will refer to the
509 same memory location for the variable.
510
511 Of course, if the symbol is sufficiently small, we must instead
512 allocate it in .sbss. FIXME: It would be better to do this if and
513 only if there were actually SDAREL relocs for that symbol. */
514
515 if (h->size <= elf_gp_size (dynobj))
516 s = bfd_get_linker_section (dynobj, ".dynsbss");
517 else
518 s = bfd_get_linker_section (dynobj, ".dynbss");
519 BFD_ASSERT (s != NULL);
520
521 /* We must generate a R_I370_COPY reloc to tell the dynamic linker to
522 copy the initial value out of the dynamic object and into the
523 runtime process image. We need to remember the offset into the
524 .rela.bss section we are going to use. */
525 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
526 {
527 asection *srel;
528
529 if (h->size <= elf_gp_size (dynobj))
530 srel = bfd_get_linker_section (dynobj, ".rela.sbss");
531 else
532 srel = bfd_get_linker_section (dynobj, ".rela.bss");
533 BFD_ASSERT (srel != NULL);
534 srel->size += sizeof (Elf32_External_Rela);
535 h->needs_copy = 1;
536 }
537
538 return _bfd_elf_adjust_dynamic_copy (h, s);
539 }
540 \f
541 /* Increment the index of a dynamic symbol by a given amount. Called
542 via elf_link_hash_traverse. */
543 /* XXX hack alert bogus This routine is mostly all junk and almost
544 certainly does the wrong thing. Its here simply because it does
545 just enough to allow glibc-2.1 ld.so to compile & link. */
546
547 static bfd_boolean
548 i370_elf_adjust_dynindx (struct elf_link_hash_entry *h, void * cparg)
549 {
550 int *cp = (int *) cparg;
551
552 #ifdef DEBUG
553 fprintf (stderr,
554 "i370_elf_adjust_dynindx called, h->dynindx = %ld, *cp = %d\n",
555 h->dynindx, *cp);
556 #endif
557
558 if (h->dynindx != -1)
559 h->dynindx += *cp;
560
561 return TRUE;
562 }
563 \f
564 /* Set the sizes of the dynamic sections. */
565 /* XXX hack alert bogus This routine is mostly all junk and almost
566 certainly does the wrong thing. Its here simply because it does
567 just enough to allow glibc-2.1 ld.so to compile & link. */
568
569 static bfd_boolean
570 i370_elf_size_dynamic_sections (bfd *output_bfd,
571 struct bfd_link_info *info)
572 {
573 bfd *dynobj;
574 asection *s;
575 bfd_boolean plt;
576 bfd_boolean relocs;
577 bfd_boolean reltext;
578
579 #ifdef DEBUG
580 fprintf (stderr, "i370_elf_size_dynamic_sections called\n");
581 #endif
582
583 dynobj = elf_hash_table (info)->dynobj;
584 BFD_ASSERT (dynobj != NULL);
585
586 if (elf_hash_table (info)->dynamic_sections_created)
587 {
588 /* Set the contents of the .interp section to the interpreter. */
589 if (info->executable)
590 {
591 s = bfd_get_linker_section (dynobj, ".interp");
592 BFD_ASSERT (s != NULL);
593 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
594 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
595 }
596 }
597 else
598 {
599 /* We may have created entries in the .rela.got, .rela.sdata, and
600 .rela.sdata2 sections. However, if we are not creating the
601 dynamic sections, we will not actually use these entries. Reset
602 the size of .rela.got, et al, which will cause it to get
603 stripped from the output file below. */
604 static char *rela_sections[] = { ".rela.got", ".rela.sdata",
605 ".rela.sdata2", ".rela.sbss",
606 NULL };
607 char **p;
608
609 for (p = rela_sections; *p != NULL; p++)
610 {
611 s = bfd_get_linker_section (dynobj, *p);
612 if (s != NULL)
613 s->size = 0;
614 }
615 }
616
617 /* The check_relocs and adjust_dynamic_symbol entry points have
618 determined the sizes of the various dynamic sections. Allocate
619 memory for them. */
620 plt = FALSE;
621 relocs = FALSE;
622 reltext = FALSE;
623 for (s = dynobj->sections; s != NULL; s = s->next)
624 {
625 const char *name;
626
627 if ((s->flags & SEC_LINKER_CREATED) == 0)
628 continue;
629
630 /* It's OK to base decisions on the section name, because none
631 of the dynobj section names depend upon the input files. */
632 name = bfd_get_section_name (dynobj, s);
633
634 if (strcmp (name, ".plt") == 0)
635 {
636 /* Remember whether there is a PLT. */
637 plt = s->size != 0;
638 }
639 else if (CONST_STRNEQ (name, ".rela"))
640 {
641 if (s->size != 0)
642 {
643 asection *target;
644 const char *outname;
645
646 /* Remember whether there are any relocation sections. */
647 relocs = TRUE;
648
649 /* If this relocation section applies to a read only
650 section, then we probably need a DT_TEXTREL entry. */
651 outname = bfd_get_section_name (output_bfd,
652 s->output_section);
653 target = bfd_get_section_by_name (output_bfd, outname + 5);
654 if (target != NULL
655 && (target->flags & SEC_READONLY) != 0
656 && (target->flags & SEC_ALLOC) != 0)
657 reltext = TRUE;
658
659 /* We use the reloc_count field as a counter if we need
660 to copy relocs into the output file. */
661 s->reloc_count = 0;
662 }
663 }
664 else if (strcmp (name, ".got") != 0
665 && strcmp (name, ".sdata") != 0
666 && strcmp (name, ".sdata2") != 0
667 && strcmp (name, ".dynbss") != 0
668 && strcmp (name, ".dynsbss") != 0)
669 {
670 /* It's not one of our sections, so don't allocate space. */
671 continue;
672 }
673
674 if (s->size == 0)
675 {
676 /* If we don't need this section, strip it from the
677 output file. This is mostly to handle .rela.bss and
678 .rela.plt. We must create both sections in
679 create_dynamic_sections, because they must be created
680 before the linker maps input sections to output
681 sections. The linker does that before
682 adjust_dynamic_symbol is called, and it is that
683 function which decides whether anything needs to go
684 into these sections. */
685 s->flags |= SEC_EXCLUDE;
686 continue;
687 }
688
689 if ((s->flags & SEC_HAS_CONTENTS) == 0)
690 continue;
691
692 /* Allocate memory for the section contents. */
693 s->contents = bfd_zalloc (dynobj, s->size);
694 if (s->contents == NULL)
695 return FALSE;
696 }
697
698 if (elf_hash_table (info)->dynamic_sections_created)
699 {
700 /* Add some entries to the .dynamic section. We fill in the
701 values later, in i370_elf_finish_dynamic_sections, but we
702 must add the entries now so that we get the correct size for
703 the .dynamic section. The DT_DEBUG entry is filled in by the
704 dynamic linker and used by the debugger. */
705 #define add_dynamic_entry(TAG, VAL) \
706 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
707
708 if (!info->shared)
709 {
710 if (!add_dynamic_entry (DT_DEBUG, 0))
711 return FALSE;
712 }
713
714 if (plt)
715 {
716 if (!add_dynamic_entry (DT_PLTGOT, 0)
717 || !add_dynamic_entry (DT_PLTRELSZ, 0)
718 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
719 || !add_dynamic_entry (DT_JMPREL, 0))
720 return FALSE;
721 }
722
723 if (relocs)
724 {
725 if (!add_dynamic_entry (DT_RELA, 0)
726 || !add_dynamic_entry (DT_RELASZ, 0)
727 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
728 return FALSE;
729 }
730
731 if (reltext)
732 {
733 if (!add_dynamic_entry (DT_TEXTREL, 0))
734 return FALSE;
735 info->flags |= DF_TEXTREL;
736 }
737 }
738 #undef add_dynamic_entry
739
740 /* If we are generating a shared library, we generate a section
741 symbol for each output section. These are local symbols, which
742 means that they must come first in the dynamic symbol table.
743 That means we must increment the dynamic symbol index of every
744 other dynamic symbol.
745
746 FIXME: We assume that there will never be relocations to
747 locations in linker-created sections that do not have
748 externally-visible names. Instead, we should work out precisely
749 which sections relocations are targeted at. */
750 if (info->shared)
751 {
752 int c;
753
754 for (c = 0, s = output_bfd->sections; s != NULL; s = s->next)
755 {
756 if ((s->flags & SEC_LINKER_CREATED) != 0
757 || (s->flags & SEC_ALLOC) == 0)
758 {
759 elf_section_data (s)->dynindx = -1;
760 continue;
761 }
762
763 /* These symbols will have no names, so we don't need to
764 fiddle with dynstr_index. */
765
766 elf_section_data (s)->dynindx = c + 1;
767
768 c++;
769 }
770
771 elf_link_hash_traverse (elf_hash_table (info),
772 i370_elf_adjust_dynindx, & c);
773 elf_hash_table (info)->dynsymcount += c;
774 }
775
776 return TRUE;
777 }
778 \f
779 /* Look through the relocs for a section during the first phase, and
780 allocate space in the global offset table or procedure linkage
781 table. */
782 /* XXX hack alert bogus This routine is mostly all junk and almost
783 certainly does the wrong thing. Its here simply because it does
784 just enough to allow glibc-2.1 ld.so to compile & link. */
785
786 static bfd_boolean
787 i370_elf_check_relocs (bfd *abfd,
788 struct bfd_link_info *info,
789 asection *sec,
790 const Elf_Internal_Rela *relocs)
791 {
792 bfd *dynobj;
793 Elf_Internal_Shdr *symtab_hdr;
794 struct elf_link_hash_entry **sym_hashes;
795 const Elf_Internal_Rela *rel;
796 const Elf_Internal_Rela *rel_end;
797 asection *sreloc;
798
799 if (info->relocatable)
800 return TRUE;
801
802 #ifdef DEBUG
803 _bfd_error_handler ("i370_elf_check_relocs called for section %A in %B",
804 sec, abfd);
805 #endif
806
807 dynobj = elf_hash_table (info)->dynobj;
808 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
809 sym_hashes = elf_sym_hashes (abfd);
810
811 sreloc = NULL;
812
813 rel_end = relocs + sec->reloc_count;
814 for (rel = relocs; rel < rel_end; rel++)
815 {
816 unsigned long r_symndx;
817 struct elf_link_hash_entry *h;
818
819 r_symndx = ELF32_R_SYM (rel->r_info);
820 if (r_symndx < symtab_hdr->sh_info)
821 h = NULL;
822 else
823 {
824 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
825 while (h->root.type == bfd_link_hash_indirect
826 || h->root.type == bfd_link_hash_warning)
827 h = (struct elf_link_hash_entry *) h->root.u.i.link;
828
829 /* PR15323, ref flags aren't set for references in the same
830 object. */
831 h->root.non_ir_ref = 1;
832 }
833
834 if (info->shared)
835 {
836 #ifdef DEBUG
837 fprintf (stderr,
838 "i370_elf_check_relocs needs to create relocation for %s\n",
839 (h && h->root.root.string)
840 ? h->root.root.string : "<unknown>");
841 #endif
842 if (sreloc == NULL)
843 {
844 sreloc = _bfd_elf_make_dynamic_reloc_section
845 (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
846
847 if (sreloc == NULL)
848 return FALSE;
849 }
850
851 sreloc->size += sizeof (Elf32_External_Rela);
852
853 /* FIXME: We should here do what the m68k and i386
854 backends do: if the reloc is pc-relative, record it
855 in case it turns out that the reloc is unnecessary
856 because the symbol is forced local by versioning or
857 we are linking with -Bdynamic. Fortunately this
858 case is not frequent. */
859 }
860 }
861
862 return TRUE;
863 }
864 \f
865 /* Finish up the dynamic sections. */
866 /* XXX hack alert bogus This routine is mostly all junk and almost
867 certainly does the wrong thing. Its here simply because it does
868 just enough to allow glibc-2.1 ld.so to compile & link. */
869
870 static bfd_boolean
871 i370_elf_finish_dynamic_sections (bfd *output_bfd,
872 struct bfd_link_info *info)
873 {
874 asection *sdyn;
875 bfd *dynobj = elf_hash_table (info)->dynobj;
876 asection *sgot = bfd_get_linker_section (dynobj, ".got");
877
878 #ifdef DEBUG
879 fprintf (stderr, "i370_elf_finish_dynamic_sections called\n");
880 #endif
881
882 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
883
884 if (elf_hash_table (info)->dynamic_sections_created)
885 {
886 asection *splt;
887 Elf32_External_Dyn *dyncon, *dynconend;
888
889 splt = bfd_get_linker_section (dynobj, ".plt");
890 BFD_ASSERT (splt != NULL && sdyn != NULL);
891
892 dyncon = (Elf32_External_Dyn *) sdyn->contents;
893 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
894 for (; dyncon < dynconend; dyncon++)
895 {
896 Elf_Internal_Dyn dyn;
897 const char *name;
898 bfd_boolean size;
899
900 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
901
902 switch (dyn.d_tag)
903 {
904 case DT_PLTGOT: name = ".plt"; size = FALSE; break;
905 case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE; break;
906 case DT_JMPREL: name = ".rela.plt"; size = FALSE; break;
907 default: name = NULL; size = FALSE; break;
908 }
909
910 if (name != NULL)
911 {
912 asection *s;
913
914 s = bfd_get_section_by_name (output_bfd, name);
915 if (s == NULL)
916 dyn.d_un.d_val = 0;
917 else
918 {
919 if (! size)
920 dyn.d_un.d_ptr = s->vma;
921 else
922 dyn.d_un.d_val = s->size;
923 }
924 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
925 }
926 }
927 }
928
929 if (sgot && sgot->size != 0)
930 {
931 unsigned char *contents = sgot->contents;
932
933 if (sdyn == NULL)
934 bfd_put_32 (output_bfd, (bfd_vma) 0, contents);
935 else
936 bfd_put_32 (output_bfd,
937 sdyn->output_section->vma + sdyn->output_offset,
938 contents);
939
940 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
941 }
942
943 if (info->shared)
944 {
945 asection *sdynsym;
946 asection *s;
947 Elf_Internal_Sym sym;
948 int maxdindx = 0;
949
950 /* Set up the section symbols for the output sections. */
951
952 sdynsym = bfd_get_linker_section (dynobj, ".dynsym");
953 BFD_ASSERT (sdynsym != NULL);
954
955 sym.st_size = 0;
956 sym.st_name = 0;
957 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
958 sym.st_other = 0;
959 sym.st_target_internal = 0;
960
961 for (s = output_bfd->sections; s != NULL; s = s->next)
962 {
963 int indx, dindx;
964 Elf32_External_Sym *esym;
965
966 sym.st_value = s->vma;
967
968 indx = elf_section_data (s)->this_idx;
969 dindx = elf_section_data (s)->dynindx;
970 if (dindx != -1)
971 {
972 BFD_ASSERT(indx > 0);
973 BFD_ASSERT(dindx > 0);
974
975 if (dindx > maxdindx)
976 maxdindx = dindx;
977
978 sym.st_shndx = indx;
979
980 esym = (Elf32_External_Sym *) sdynsym->contents + dindx;
981 bfd_elf32_swap_symbol_out (output_bfd, &sym, esym, NULL);
982 }
983 }
984
985 /* Set the sh_info field of the output .dynsym section to the
986 index of the first global symbol. */
987 elf_section_data (sdynsym->output_section)->this_hdr.sh_info =
988 maxdindx + 1;
989 }
990
991 return TRUE;
992 }
993 \f
994 /* The RELOCATE_SECTION function is called by the ELF backend linker
995 to handle the relocations for a section.
996
997 The relocs are always passed as Rela structures; if the section
998 actually uses Rel structures, the r_addend field will always be
999 zero.
1000
1001 This function is responsible for adjust the section contents as
1002 necessary, and (if using Rela relocs and generating a
1003 relocatable output file) adjusting the reloc addend as
1004 necessary.
1005
1006 This function does not have to worry about setting the reloc
1007 address or the reloc symbol index.
1008
1009 LOCAL_SYMS is a pointer to the swapped in local symbols.
1010
1011 LOCAL_SECTIONS is an array giving the section in the input file
1012 corresponding to the st_shndx field of each local symbol.
1013
1014 The global hash table entry for the global symbols can be found
1015 via elf_sym_hashes (input_bfd).
1016
1017 When generating relocatable output, this function must handle
1018 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1019 going to be the section symbol corresponding to the output
1020 section, which means that the addend must be adjusted
1021 accordingly. */
1022
1023 static bfd_boolean
1024 i370_elf_relocate_section (bfd *output_bfd,
1025 struct bfd_link_info *info,
1026 bfd *input_bfd,
1027 asection *input_section,
1028 bfd_byte *contents,
1029 Elf_Internal_Rela *relocs,
1030 Elf_Internal_Sym *local_syms,
1031 asection **local_sections)
1032 {
1033 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1034 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
1035 Elf_Internal_Rela *rel = relocs;
1036 Elf_Internal_Rela *relend = relocs + input_section->reloc_count;
1037 asection *sreloc = NULL;
1038 bfd_boolean ret = TRUE;
1039
1040 #ifdef DEBUG
1041 _bfd_error_handler ("i370_elf_relocate_section called for %B section %A, %ld relocations%s",
1042 input_bfd, input_section,
1043 (long) input_section->reloc_count,
1044 (info->relocatable) ? " (relocatable)" : "");
1045 #endif
1046
1047 if (!i370_elf_howto_table[ R_I370_ADDR31 ])
1048 /* Initialize howto table if needed. */
1049 i370_elf_howto_init ();
1050
1051 for (; rel < relend; rel++)
1052 {
1053 enum i370_reloc_type r_type = (enum i370_reloc_type) ELF32_R_TYPE (rel->r_info);
1054 bfd_vma offset = rel->r_offset;
1055 bfd_vma addend = rel->r_addend;
1056 bfd_reloc_status_type r = bfd_reloc_other;
1057 Elf_Internal_Sym *sym = NULL;
1058 asection *sec = NULL;
1059 struct elf_link_hash_entry * h = NULL;
1060 const char *sym_name = NULL;
1061 reloc_howto_type *howto;
1062 unsigned long r_symndx;
1063 bfd_vma relocation;
1064
1065 /* Unknown relocation handling. */
1066 if ((unsigned) r_type >= (unsigned) R_I370_max
1067 || !i370_elf_howto_table[(int)r_type])
1068 {
1069 (*_bfd_error_handler) ("%B: unknown relocation type %d",
1070 input_bfd,
1071 (int) r_type);
1072
1073 bfd_set_error (bfd_error_bad_value);
1074 ret = FALSE;
1075 continue;
1076 }
1077
1078 howto = i370_elf_howto_table[(int) r_type];
1079 r_symndx = ELF32_R_SYM (rel->r_info);
1080 relocation = 0;
1081
1082 if (r_symndx < symtab_hdr->sh_info)
1083 {
1084 sym = local_syms + r_symndx;
1085 sec = local_sections[r_symndx];
1086 sym_name = "<local symbol>";
1087
1088 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, & sec, rel);
1089 addend = rel->r_addend;
1090 }
1091 else
1092 {
1093 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1094 while (h->root.type == bfd_link_hash_indirect
1095 || h->root.type == bfd_link_hash_warning)
1096 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1097 sym_name = h->root.root.string;
1098 if (h->root.type == bfd_link_hash_defined
1099 || h->root.type == bfd_link_hash_defweak)
1100 {
1101 sec = h->root.u.def.section;
1102 if (info->shared
1103 && ((! info->symbolic && h->dynindx != -1)
1104 || !h->def_regular)
1105 && (input_section->flags & SEC_ALLOC) != 0
1106 && (r_type == R_I370_ADDR31
1107 || r_type == R_I370_COPY
1108 || r_type == R_I370_ADDR16
1109 || r_type == R_I370_RELATIVE))
1110 /* In these cases, we don't need the relocation
1111 value. We check specially because in some
1112 obscure cases sec->output_section will be NULL. */
1113 ;
1114 else
1115 relocation = (h->root.u.def.value
1116 + sec->output_section->vma
1117 + sec->output_offset);
1118 }
1119 else if (h->root.type == bfd_link_hash_undefweak)
1120 ;
1121 else if (info->unresolved_syms_in_objects == RM_IGNORE
1122 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1123 ;
1124 else if (!info->relocatable)
1125 {
1126 if ((*info->callbacks->undefined_symbol)
1127 (info, h->root.root.string, input_bfd,
1128 input_section, rel->r_offset,
1129 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
1130 || ELF_ST_VISIBILITY (h->other))))
1131 {
1132 ret = FALSE;
1133 continue;
1134 }
1135 }
1136 }
1137
1138 if (sec != NULL && discarded_section (sec))
1139 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1140 rel, 1, relend, howto, 0, contents);
1141
1142 if (info->relocatable)
1143 continue;
1144
1145 switch ((int) r_type)
1146 {
1147 default:
1148 (*_bfd_error_handler)
1149 ("%B: unknown relocation type %d for symbol %s",
1150 input_bfd, (int) r_type, sym_name);
1151
1152 bfd_set_error (bfd_error_bad_value);
1153 ret = FALSE;
1154 continue;
1155
1156 case (int) R_I370_NONE:
1157 continue;
1158
1159 /* Relocations that may need to be propagated if this is a shared
1160 object. */
1161 case (int) R_I370_REL31:
1162 /* If these relocations are not to a named symbol, they can be
1163 handled right here, no need to bother the dynamic linker. */
1164 if (h == NULL
1165 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1166 break;
1167 /* Fall through. */
1168
1169 /* Relocations that always need to be propagated if this is a shared
1170 object. */
1171 case (int) R_I370_ADDR31:
1172 case (int) R_I370_ADDR16:
1173 if (info->shared
1174 && r_symndx != STN_UNDEF)
1175 {
1176 Elf_Internal_Rela outrel;
1177 bfd_byte *loc;
1178 int skip;
1179
1180 #ifdef DEBUG
1181 fprintf (stderr,
1182 "i370_elf_relocate_section needs to create relocation for %s\n",
1183 (h && h->root.root.string) ? h->root.root.string : "<unknown>");
1184 #endif
1185
1186 /* When generating a shared object, these relocations
1187 are copied into the output file to be resolved at run
1188 time. */
1189
1190 if (sreloc == NULL)
1191 {
1192 sreloc = _bfd_elf_get_dynamic_reloc_section
1193 (input_bfd, input_section, /*rela?*/ TRUE);
1194 if (sreloc == NULL)
1195 return FALSE;
1196 }
1197
1198 skip = 0;
1199
1200 outrel.r_offset =
1201 _bfd_elf_section_offset (output_bfd, info, input_section,
1202 rel->r_offset);
1203 if (outrel.r_offset == (bfd_vma) -1
1204 || outrel.r_offset == (bfd_vma) -2)
1205 skip = (int) outrel.r_offset;
1206 outrel.r_offset += (input_section->output_section->vma
1207 + input_section->output_offset);
1208
1209 if (skip)
1210 memset (&outrel, 0, sizeof outrel);
1211 /* h->dynindx may be -1 if this symbol was marked to
1212 become local. */
1213 else if (h != NULL
1214 && ((! info->symbolic && h->dynindx != -1)
1215 || !h->def_regular))
1216 {
1217 BFD_ASSERT (h->dynindx != -1);
1218 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1219 outrel.r_addend = rel->r_addend;
1220 }
1221 else
1222 {
1223 if (r_type == R_I370_ADDR31)
1224 {
1225 outrel.r_info = ELF32_R_INFO (0, R_I370_RELATIVE);
1226 outrel.r_addend = relocation + rel->r_addend;
1227 }
1228 else
1229 {
1230 long indx;
1231
1232 if (bfd_is_abs_section (sec))
1233 indx = 0;
1234 else if (sec == NULL || sec->owner == NULL)
1235 {
1236 bfd_set_error (bfd_error_bad_value);
1237 return FALSE;
1238 }
1239 else
1240 {
1241 asection *osec;
1242
1243 /* We are turning this relocation into one
1244 against a section symbol. It would be
1245 proper to subtract the symbol's value,
1246 osec->vma, from the emitted reloc addend,
1247 but ld.so expects buggy relocs. */
1248 osec = sec->output_section;
1249 indx = elf_section_data (osec)->dynindx;
1250 if (indx == 0)
1251 {
1252 struct elf_link_hash_table *htab;
1253 htab = elf_hash_table (info);
1254 osec = htab->text_index_section;
1255 indx = elf_section_data (osec)->dynindx;
1256 }
1257 BFD_ASSERT (indx != 0);
1258 #ifdef DEBUG
1259 if (indx <= 0)
1260 {
1261 printf ("indx=%ld section=%s flags=%08x name=%s\n",
1262 indx, osec->name, osec->flags,
1263 h->root.root.string);
1264 }
1265 #endif
1266 }
1267
1268 outrel.r_info = ELF32_R_INFO (indx, r_type);
1269 outrel.r_addend = relocation + rel->r_addend;
1270 }
1271 }
1272
1273 loc = sreloc->contents;
1274 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1275 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1276
1277 /* This reloc will be computed at runtime, so there's no
1278 need to do anything now, unless this is a RELATIVE
1279 reloc in an unallocated section. */
1280 if (skip == -1
1281 || (input_section->flags & SEC_ALLOC) != 0
1282 || ELF32_R_TYPE (outrel.r_info) != R_I370_RELATIVE)
1283 continue;
1284 }
1285 break;
1286
1287 case (int) R_I370_COPY:
1288 case (int) R_I370_RELATIVE:
1289 (*_bfd_error_handler)
1290 ("%B: Relocation %s is not yet supported for symbol %s.",
1291 input_bfd,
1292 i370_elf_howto_table[(int) r_type]->name,
1293 sym_name);
1294
1295 bfd_set_error (bfd_error_invalid_operation);
1296 ret = FALSE;
1297 continue;
1298 }
1299
1300 #ifdef DEBUG
1301 fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, offset = %ld, addend = %ld\n",
1302 howto->name,
1303 (int)r_type,
1304 sym_name,
1305 r_symndx,
1306 (long) offset,
1307 (long) addend);
1308 #endif
1309
1310 r = _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
1311 offset, relocation, addend);
1312
1313 if (r != bfd_reloc_ok)
1314 {
1315 ret = FALSE;
1316 switch (r)
1317 {
1318 default:
1319 break;
1320
1321 case bfd_reloc_overflow:
1322 {
1323 const char *name;
1324
1325 if (h != NULL)
1326 name = NULL;
1327 else
1328 {
1329 name = bfd_elf_string_from_elf_section (input_bfd,
1330 symtab_hdr->sh_link,
1331 sym->st_name);
1332 if (name == NULL)
1333 break;
1334
1335 if (*name == '\0')
1336 name = bfd_section_name (input_bfd, sec);
1337 }
1338
1339 (*info->callbacks->reloc_overflow) (info,
1340 (h ? &h->root : NULL),
1341 name,
1342 howto->name,
1343 (bfd_vma) 0,
1344 input_bfd,
1345 input_section,
1346 offset);
1347 }
1348 break;
1349 }
1350 }
1351 }
1352
1353 #ifdef DEBUG
1354 fprintf (stderr, "\n");
1355 #endif
1356
1357 return ret;
1358 }
1359 \f
1360 #define TARGET_BIG_SYM bfd_elf32_i370_vec
1361 #define TARGET_BIG_NAME "elf32-i370"
1362 #define ELF_ARCH bfd_arch_i370
1363 #define ELF_MACHINE_CODE EM_S370
1364 #ifdef EM_I370_OLD
1365 #define ELF_MACHINE_ALT1 EM_I370_OLD
1366 #endif
1367 #define ELF_MAXPAGESIZE 0x1000
1368 #define ELF_OSABI ELFOSABI_GNU
1369
1370 #define elf_info_to_howto i370_elf_info_to_howto
1371
1372 #define elf_backend_plt_not_loaded 1
1373 #define elf_backend_rela_normal 1
1374
1375 #define bfd_elf32_bfd_reloc_type_lookup i370_elf_reloc_type_lookup
1376 #define bfd_elf32_bfd_reloc_name_lookup i370_elf_reloc_name_lookup
1377 #define bfd_elf32_bfd_set_private_flags i370_elf_set_private_flags
1378 #define bfd_elf32_bfd_merge_private_bfd_data i370_elf_merge_private_bfd_data
1379 #define elf_backend_relocate_section i370_elf_relocate_section
1380
1381 /* Dynamic loader support is mostly broken; just enough here to be able to
1382 link glibc's ld.so without errors. */
1383 #define elf_backend_create_dynamic_sections i370_elf_create_dynamic_sections
1384 #define elf_backend_size_dynamic_sections i370_elf_size_dynamic_sections
1385 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
1386 #define elf_backend_finish_dynamic_sections i370_elf_finish_dynamic_sections
1387 #define elf_backend_fake_sections i370_elf_fake_sections
1388 #define elf_backend_section_from_shdr i370_elf_section_from_shdr
1389 #define elf_backend_adjust_dynamic_symbol i370_elf_adjust_dynamic_symbol
1390 #define elf_backend_check_relocs i370_elf_check_relocs
1391 #define elf_backend_post_process_headers _bfd_elf_set_osabi
1392
1393 static int
1394 i370_noop (void)
1395 {
1396 return 1;
1397 }
1398
1399 #define elf_backend_finish_dynamic_symbol \
1400 (bfd_boolean (*) \
1401 (bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, \
1402 Elf_Internal_Sym *)) i370_noop
1403
1404 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.06011 seconds and 4 git commands to generate.