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