* remote-utils.c (remote_open): Print a status notice after
[platform/upstream/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
3    Free Software Foundation, Inc.
4    Written by Ian Lance Taylor, Cygnus Support.
5    Hacked by Linas Vepstas for i370 linas@linas.org
6
7 This file is part of BFD, the Binary File Descriptor library.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
22
23 /* This file is based on a preliminary PowerPC ELF ABI.
24    But its been hacked on for the IBM 360/370 architectures.
25    Basically, the 31bit relocation works, and just about everything
26    else is a wild card.  In particular, don't expect shared libs or
27    dynamic loading to work ...  its never been tested ...
28 */
29
30 #include "bfd.h"
31 #include "sysdep.h"
32 #include "bfdlink.h"
33 #include "libbfd.h"
34 #include "elf-bfd.h"
35 #include "elf/i370.h"
36
37 static reloc_howto_type *i370_elf_howto_table[ (int)R_I370_max ];
38
39 static reloc_howto_type i370_elf_howto_raw[] =
40 {
41   /* This reloc does nothing.  */
42   HOWTO (R_I370_NONE,           /* type */
43          0,                     /* rightshift */
44          2,                     /* size (0 = byte, 1 = short, 2 = long) */
45          32,                    /* bitsize */
46          FALSE,                 /* pc_relative */
47          0,                     /* bitpos */
48          complain_overflow_bitfield, /* complain_on_overflow */
49          bfd_elf_generic_reloc, /* special_function */
50          "R_I370_NONE",         /* name */
51          FALSE,                 /* partial_inplace */
52          0,                     /* src_mask */
53          0,                     /* dst_mask */
54          FALSE),                /* pcrel_offset */
55
56   /* A standard 31 bit relocation.  */
57   HOWTO (R_I370_ADDR31,         /* type */
58          0,                     /* rightshift */
59          2,                     /* size (0 = byte, 1 = short, 2 = long) */
60          31,                    /* bitsize */
61          FALSE,                 /* pc_relative */
62          0,                     /* bitpos */
63          complain_overflow_bitfield, /* complain_on_overflow */
64          bfd_elf_generic_reloc, /* special_function */
65          "R_I370_ADDR31",       /* name */
66          FALSE,                 /* partial_inplace */
67          0,                     /* src_mask */
68          0x7fffffff,            /* dst_mask */
69          FALSE),                /* pcrel_offset */
70
71   /* A standard 32 bit relocation.  */
72   HOWTO (R_I370_ADDR32,         /* type */
73          0,                     /* rightshift */
74          2,                     /* size (0 = byte, 1 = short, 2 = long) */
75          32,                    /* bitsize */
76          FALSE,                 /* pc_relative */
77          0,                     /* bitpos */
78          complain_overflow_bitfield, /* complain_on_overflow */
79          bfd_elf_generic_reloc, /* special_function */
80          "R_I370_ADDR32",       /* name */
81          FALSE,                 /* partial_inplace */
82          0,                     /* src_mask */
83          0xffffffff,            /* dst_mask */
84          FALSE),                /* pcrel_offset */
85
86   /* A standard 16 bit relocation.  */
87   HOWTO (R_I370_ADDR16,         /* type */
88          0,                     /* rightshift */
89          1,                     /* size (0 = byte, 1 = short, 2 = long) */
90          16,                    /* bitsize */
91          FALSE,                 /* pc_relative */
92          0,                     /* bitpos */
93          complain_overflow_bitfield, /* complain_on_overflow */
94          bfd_elf_generic_reloc, /* special_function */
95          "R_I370_ADDR16",       /* name */
96          FALSE,                 /* partial_inplace */
97          0,                     /* src_mask */
98          0xffff,                /* dst_mask */
99          FALSE),                /* pcrel_offset */
100
101   /* 31-bit PC relative */
102   HOWTO (R_I370_REL31,          /* type */
103          0,                     /* rightshift */
104          2,                     /* size (0 = byte, 1 = short, 2 = long) */
105          31,                    /* bitsize */
106          TRUE,                  /* pc_relative */
107          0,                     /* bitpos */
108          complain_overflow_bitfield, /* complain_on_overflow */
109          bfd_elf_generic_reloc, /* special_function */
110          "R_I370_REL31",        /* name */
111          FALSE,                 /* partial_inplace */
112          0,                     /* src_mask */
113          0x7fffffff,            /* dst_mask */
114          TRUE),                 /* pcrel_offset */
115
116   /* 32-bit PC relative */
117   HOWTO (R_I370_REL32,          /* type */
118          0,                     /* rightshift */
119          2,                     /* size (0 = byte, 1 = short, 2 = long) */
120          32,                    /* bitsize */
121          TRUE,                  /* pc_relative */
122          0,                     /* bitpos */
123          complain_overflow_bitfield, /* complain_on_overflow */
124          bfd_elf_generic_reloc, /* special_function */
125          "R_I370_REL32",        /* name */
126          FALSE,                 /* partial_inplace */
127          0,                     /* src_mask */
128          0xffffffff,            /* dst_mask */
129          TRUE),                 /* pcrel_offset */
130
131   /* A standard 12 bit relocation.  */
132   HOWTO (R_I370_ADDR12,         /* type */
133          0,                     /* rightshift */
134          1,                     /* size (0 = byte, 1 = short, 2 = long) */
135          12,                    /* bitsize */
136          FALSE,                 /* pc_relative */
137          0,                     /* bitpos */
138          complain_overflow_bitfield, /* complain_on_overflow */
139          bfd_elf_generic_reloc, /* special_function */
140          "R_I370_ADDR12",       /* name */
141          FALSE,                 /* partial_inplace */
142          0,                     /* src_mask */
143          0xfff,                 /* dst_mask */
144          FALSE),                /* pcrel_offset */
145
146   /* 12-bit PC relative */
147   HOWTO (R_I370_REL12,          /* type */
148          0,                     /* rightshift */
149          1,                     /* size (0 = byte, 1 = short, 2 = long) */
150          12,                    /* bitsize */
151          TRUE,                  /* pc_relative */
152          0,                     /* bitpos */
153          complain_overflow_bitfield, /* complain_on_overflow */
154          bfd_elf_generic_reloc, /* special_function */
155          "R_I370_REL12",        /* name */
156          FALSE,                 /* partial_inplace */
157          0,                     /* src_mask */
158          0xfff,                 /* dst_mask */
159          TRUE),                 /* pcrel_offset */
160
161   /* A standard 8 bit relocation.  */
162   HOWTO (R_I370_ADDR8,          /* type */
163          0,                     /* rightshift */
164          0,                     /* size (0 = byte, 1 = short, 2 = long) */
165          8,                     /* bitsize */
166          FALSE,                 /* pc_relative */
167          0,                     /* bitpos */
168          complain_overflow_bitfield, /* complain_on_overflow */
169          bfd_elf_generic_reloc, /* special_function */
170          "R_I370_ADDR8",        /* name */
171          FALSE,                 /* partial_inplace */
172          0,                     /* src_mask */
173          0xff,                  /* dst_mask */
174          FALSE),                /* pcrel_offset */
175
176   /* 8-bit PC relative */
177   HOWTO (R_I370_REL8,           /* type */
178          0,                     /* rightshift */
179          0,                     /* size (0 = byte, 1 = short, 2 = long) */
180          8,                     /* bitsize */
181          TRUE,                  /* pc_relative */
182          0,                     /* bitpos */
183          complain_overflow_bitfield, /* complain_on_overflow */
184          bfd_elf_generic_reloc, /* special_function */
185          "R_I370_REL8",         /* name */
186          FALSE,                 /* partial_inplace */
187          0,                     /* src_mask */
188          0xff,                  /* dst_mask */
189          TRUE),                 /* pcrel_offset */
190
191   /* This is used only by the dynamic linker.  The symbol should exist
192      both in the object being run and in some shared library.  The
193      dynamic linker copies the data addressed by the symbol from the
194      shared library into the object, because the object being
195      run has to have the data at some particular address.  */
196   HOWTO (R_I370_COPY,           /* type */
197          0,                     /* rightshift */
198          2,                     /* size (0 = byte, 1 = short, 2 = long) */
199          32,                    /* bitsize */
200          FALSE,                 /* pc_relative */
201          0,                     /* bitpos */
202          complain_overflow_bitfield, /* complain_on_overflow */
203          bfd_elf_generic_reloc,  /* special_function */
204          "R_I370_COPY",         /* name */
205          FALSE,                 /* partial_inplace */
206          0,                     /* src_mask */
207          0,                     /* dst_mask */
208          FALSE),                /* pcrel_offset */
209
210   /* Used only by the dynamic linker.  When the object is run, this
211      longword is set to the load address of the object, plus the
212      addend.  */
213   HOWTO (R_I370_RELATIVE,       /* type */
214          0,                     /* rightshift */
215          2,                     /* size (0 = byte, 1 = short, 2 = long) */
216          32,                    /* bitsize */
217          FALSE,                 /* pc_relative */
218          0,                     /* bitpos */
219          complain_overflow_bitfield, /* complain_on_overflow */
220          bfd_elf_generic_reloc,  /* special_function */
221          "R_I370_RELATIVE",     /* name */
222          FALSE,                 /* partial_inplace */
223          0,                     /* src_mask */
224          0xffffffff,            /* dst_mask */
225          FALSE),                /* pcrel_offset */
226
227 };
228 \f
229 static void i370_elf_howto_init
230   PARAMS ((void));
231 static reloc_howto_type *i370_elf_reloc_type_lookup
232   PARAMS ((bfd *, bfd_reloc_code_real_type));
233 static void i370_elf_info_to_howto
234   PARAMS ((bfd *abfd, arelent *cache_ptr, Elf_Internal_Rela *dst));
235 static bfd_boolean i370_elf_set_private_flags
236   PARAMS ((bfd *, flagword));
237 \f
238 /* Initialize the i370_elf_howto_table, so that linear accesses can be done.  */
239
240 static void
241 i370_elf_howto_init ()
242 {
243   unsigned int i, type;
244
245   for (i = 0; i < sizeof (i370_elf_howto_raw) / sizeof (i370_elf_howto_raw[0]); i++)
246     {
247       type = i370_elf_howto_raw[i].type;
248       BFD_ASSERT (type < sizeof (i370_elf_howto_table) / sizeof (i370_elf_howto_table[0]));
249       i370_elf_howto_table[type] = &i370_elf_howto_raw[i];
250     }
251 }
252 \f
253 static reloc_howto_type *
254 i370_elf_reloc_type_lookup (abfd, code)
255      bfd *abfd ATTRIBUTE_UNUSED;
256      bfd_reloc_code_real_type code;
257 {
258   enum i370_reloc_type i370_reloc = R_I370_NONE;
259
260   if (!i370_elf_howto_table[ R_I370_ADDR31 ])   /* Initialize howto table if needed */
261     i370_elf_howto_init ();
262
263   switch ((int)code)
264     {
265     default:
266       return (reloc_howto_type *)NULL;
267
268     case BFD_RELOC_NONE:        i370_reloc = R_I370_NONE;       break;
269     case BFD_RELOC_32:          i370_reloc = R_I370_ADDR31;     break;
270     case BFD_RELOC_16:          i370_reloc = R_I370_ADDR16;     break;
271     case BFD_RELOC_32_PCREL:    i370_reloc = R_I370_REL31;      break;
272     case BFD_RELOC_CTOR:        i370_reloc = R_I370_ADDR31;     break;
273     case BFD_RELOC_I370_D12:    i370_reloc = R_I370_ADDR12;     break;
274     }
275
276   return i370_elf_howto_table[ (int)i370_reloc ];
277 };
278
279 static bfd_boolean i370_elf_merge_private_bfd_data
280   PARAMS ((bfd *, bfd *));
281 static bfd_boolean i370_elf_relocate_section
282   PARAMS ((bfd *, struct bfd_link_info *info, bfd *, asection *, bfd_byte *,
283            Elf_Internal_Rela *relocs, Elf_Internal_Sym *local_syms,
284            asection **));
285 static void i370_elf_post_process_headers
286   PARAMS ((bfd *, struct bfd_link_info *));
287 static bfd_boolean i370_elf_create_dynamic_sections
288   PARAMS ((bfd *, struct bfd_link_info *));
289 static bfd_boolean i370_elf_section_from_shdr
290   PARAMS ((bfd *, Elf_Internal_Shdr *, const char *));
291 static bfd_boolean i370_elf_fake_sections
292   PARAMS ((bfd *, Elf_Internal_Shdr *, asection *));
293 static bfd_boolean i370_elf_check_relocs
294   PARAMS ((bfd *, struct bfd_link_info *, asection *,
295            const Elf_Internal_Rela *));
296 static bfd_boolean i370_elf_adjust_dynamic_symbol
297   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
298 static bfd_boolean i370_elf_adjust_dynindx
299   PARAMS ((struct elf_link_hash_entry *, PTR));
300 static bfd_boolean i370_elf_size_dynamic_sections
301   PARAMS ((bfd *, struct bfd_link_info *));
302 static bfd_boolean i370_elf_finish_dynamic_sections
303   PARAMS ((bfd *, struct bfd_link_info *));
304
305 /* The name of the dynamic interpreter.  This is put in the .interp
306     section.  */
307
308 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so"
309
310 /* Set the howto pointer for an i370 ELF reloc.  */
311
312 static void
313 i370_elf_info_to_howto (abfd, cache_ptr, dst)
314      bfd *abfd ATTRIBUTE_UNUSED;
315      arelent *cache_ptr;
316      Elf_Internal_Rela *dst;
317 {
318   if (!i370_elf_howto_table[ R_I370_ADDR31 ])   /* Initialize howto table */
319     i370_elf_howto_init ();
320
321   BFD_ASSERT (ELF32_R_TYPE (dst->r_info) < (unsigned int) R_I370_max);
322   cache_ptr->howto = i370_elf_howto_table[ELF32_R_TYPE (dst->r_info)];
323 }
324
325 /* hack alert --  the following several routines look generic to me ...
326  * why are we bothering with them ???
327  */
328 /* Function to set whether a module needs the -mrelocatable bit set.  */
329 static bfd_boolean
330 i370_elf_set_private_flags (abfd, flags)
331      bfd *abfd;
332      flagword flags;
333 {
334   BFD_ASSERT (!elf_flags_init (abfd)
335               || elf_elfheader (abfd)->e_flags == flags);
336
337   elf_elfheader (abfd)->e_flags = flags;
338   elf_flags_init (abfd) = TRUE;
339   return TRUE;
340 }
341
342 /* Merge backend specific data from an object file to the output
343    object file when linking */
344 static bfd_boolean
345 i370_elf_merge_private_bfd_data (ibfd, obfd)
346      bfd *ibfd;
347      bfd *obfd;
348 {
349   flagword old_flags;
350   flagword new_flags;
351
352   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
353       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
354     return TRUE;
355
356   new_flags = elf_elfheader (ibfd)->e_flags;
357   old_flags = elf_elfheader (obfd)->e_flags;
358   if (!elf_flags_init (obfd))   /* First call, no flags set */
359     {
360       elf_flags_init (obfd) = TRUE;
361       elf_elfheader (obfd)->e_flags = new_flags;
362     }
363
364   else if (new_flags == old_flags)      /* Compatible flags are ok */
365     ;
366
367   else                                  /* Incompatible flags */
368     {
369       (*_bfd_error_handler)
370         ("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)",
371          bfd_archive_filename (ibfd), (long) new_flags, (long) old_flags);
372
373       bfd_set_error (bfd_error_bad_value);
374       return FALSE;
375     }
376
377   return TRUE;
378 }
379 \f
380 /* Handle an i370 specific section when reading an object file.  This
381    is called when elfcode.h finds a section with an unknown type.  */
382 /* XXX hack alert bogus This routine is mostly all junk and almost
383  * certainly does the wrong thing.  Its here simply because it does
384  * just enough to allow glibc-2.1 ld.so to compile & link.
385  */
386
387 static bfd_boolean
388 i370_elf_section_from_shdr (abfd, hdr, name)
389      bfd *abfd;
390      Elf_Internal_Shdr *hdr;
391      const char *name;
392 {
393   asection *newsect;
394   flagword flags;
395
396   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
397     return FALSE;
398
399   newsect = hdr->bfd_section;
400   flags = bfd_get_section_flags (abfd, newsect);
401   if (hdr->sh_flags & SHF_EXCLUDE)
402     flags |= SEC_EXCLUDE;
403
404   if (hdr->sh_type == SHT_ORDERED)
405     flags |= SEC_SORT_ENTRIES;
406
407   bfd_set_section_flags (abfd, newsect, flags);
408   return TRUE;
409 }
410 \f
411 /* Set up any other section flags and such that may be necessary.  */
412 /* XXX hack alert bogus This routine is mostly all junk and almost
413  * certainly does the wrong thing.  Its here simply because it does
414  * just enough to allow glibc-2.1 ld.so to compile & link.
415  */
416
417 static bfd_boolean
418 i370_elf_fake_sections (abfd, shdr, asect)
419      bfd *abfd ATTRIBUTE_UNUSED;
420      Elf_Internal_Shdr *shdr;
421      asection *asect;
422 {
423   if ((asect->flags & SEC_EXCLUDE) != 0)
424     shdr->sh_flags |= SHF_EXCLUDE;
425
426   if ((asect->flags & SEC_SORT_ENTRIES) != 0)
427     shdr->sh_type = SHT_ORDERED;
428
429   return TRUE;
430 }
431 \f
432 /* We have to create .dynsbss and .rela.sbss here so that they get mapped
433    to output sections (just like _bfd_elf_create_dynamic_sections has
434    to create .dynbss and .rela.bss).  */
435 /* XXX hack alert bogus This routine is mostly all junk and almost
436  * certainly does the wrong thing.  Its here simply because it does
437  * just enough to allow glibc-2.1 ld.so to compile & link.
438  */
439
440 static bfd_boolean
441 i370_elf_create_dynamic_sections (abfd, info)
442      bfd *abfd;
443      struct bfd_link_info *info;
444 {
445   register asection *s;
446   flagword flags;
447
448   if (!_bfd_elf_create_dynamic_sections(abfd, info))
449     return FALSE;
450
451   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
452            | SEC_LINKER_CREATED);
453
454   s = bfd_make_section (abfd, ".dynsbss");
455   if (s == NULL
456       || ! bfd_set_section_flags (abfd, s, SEC_ALLOC))
457     return FALSE;
458
459   if (! info->shared)
460     {
461       s = bfd_make_section (abfd, ".rela.sbss");
462       if (s == NULL
463           || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
464           || ! bfd_set_section_alignment (abfd, s, 2))
465         return FALSE;
466     }
467
468    /* xxx beats me, seem to need a rela.text ...  */
469    s = bfd_make_section (abfd, ".rela.text");
470    if (s == NULL
471       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
472       || ! bfd_set_section_alignment (abfd, s, 2))
473     return FALSE;
474   return TRUE;
475 }
476
477 /* Adjust a symbol defined by a dynamic object and referenced by a
478    regular object.  The current definition is in some section of the
479    dynamic object, but we're not including those sections.  We have to
480    change the definition to something the rest of the link can
481    understand.  */
482 /* XXX hack alert bogus This routine is mostly all junk and almost
483  * certainly does the wrong thing.  Its here simply because it does
484  * just enough to allow glibc-2.1 ld.so to compile & link.
485  */
486
487 static bfd_boolean
488 i370_elf_adjust_dynamic_symbol (info, h)
489      struct bfd_link_info *info;
490      struct elf_link_hash_entry *h;
491 {
492   bfd *dynobj = elf_hash_table (info)->dynobj;
493   asection *s;
494   unsigned int power_of_two;
495
496 #ifdef DEBUG
497   fprintf (stderr, "i370_elf_adjust_dynamic_symbol called for %s\n",
498            h->root.root.string);
499 #endif
500
501   /* Make sure we know what is going on here.  */
502   BFD_ASSERT (dynobj != NULL
503               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
504                   || h->weakdef != NULL
505                   || ((h->elf_link_hash_flags
506                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
507                       && (h->elf_link_hash_flags
508                           & ELF_LINK_HASH_REF_REGULAR) != 0
509                       && (h->elf_link_hash_flags
510                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
511
512   s = bfd_get_section_by_name (dynobj, ".rela.text");
513   BFD_ASSERT (s != NULL);
514   s->_raw_size += sizeof (Elf32_External_Rela);
515
516   /* If this is a weak symbol, and there is a real definition, the
517      processor independent code will have arranged for us to see the
518      real definition first, and we can just use the same value.  */
519   if (h->weakdef != NULL)
520     {
521       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
522                   || h->weakdef->root.type == bfd_link_hash_defweak);
523       h->root.u.def.section = h->weakdef->root.u.def.section;
524       h->root.u.def.value = h->weakdef->root.u.def.value;
525       return TRUE;
526     }
527
528   /* This is a reference to a symbol defined by a dynamic object which
529      is not a function.  */
530
531   /* If we are creating a shared library, we must presume that the
532      only references to the symbol are via the global offset table.
533      For such cases we need not do anything here; the relocations will
534      be handled correctly by relocate_section.  */
535   if (info->shared)
536     return TRUE;
537
538   /* We must allocate the symbol in our .dynbss section, which will
539      become part of the .bss section of the executable.  There will be
540      an entry for this symbol in the .dynsym section.  The dynamic
541      object will contain position independent code, so all references
542      from the dynamic object to this symbol will go through the global
543      offset table.  The dynamic linker will use the .dynsym entry to
544      determine the address it must put in the global offset table, so
545      both the dynamic object and the regular object will refer to the
546      same memory location for the variable.
547
548      Of course, if the symbol is sufficiently small, we must instead
549      allocate it in .sbss.  FIXME: It would be better to do this if and
550      only if there were actually SDAREL relocs for that symbol.  */
551
552   if (h->size <= elf_gp_size (dynobj))
553     s = bfd_get_section_by_name (dynobj, ".dynsbss");
554   else
555     s = bfd_get_section_by_name (dynobj, ".dynbss");
556   BFD_ASSERT (s != NULL);
557
558   /* We must generate a R_I370_COPY reloc to tell the dynamic linker to
559      copy the initial value out of the dynamic object and into the
560      runtime process image.  We need to remember the offset into the
561      .rela.bss section we are going to use.  */
562   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
563     {
564       asection *srel;
565
566       if (h->size <= elf_gp_size (dynobj))
567         srel = bfd_get_section_by_name (dynobj, ".rela.sbss");
568       else
569         srel = bfd_get_section_by_name (dynobj, ".rela.bss");
570       BFD_ASSERT (srel != NULL);
571       srel->_raw_size += sizeof (Elf32_External_Rela);
572       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
573     }
574
575   /* We need to figure out the alignment required for this symbol.  I
576      have no idea how ELF linkers handle this.  */
577   power_of_two = bfd_log2 (h->size);
578   if (power_of_two > 4)
579     power_of_two = 4;
580
581   /* Apply the required alignment.  */
582   s->_raw_size = BFD_ALIGN (s->_raw_size,
583                             (bfd_size_type) (1 << power_of_two));
584   if (power_of_two > bfd_get_section_alignment (dynobj, s))
585     {
586       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
587         return FALSE;
588     }
589
590   /* Define the symbol as being at this point in the section.  */
591   h->root.u.def.section = s;
592   h->root.u.def.value = s->_raw_size;
593
594   /* Increment the section size to make room for the symbol.  */
595   s->_raw_size += h->size;
596
597   return TRUE;
598 }
599 \f
600 /* Increment the index of a dynamic symbol by a given amount.  Called
601    via elf_link_hash_traverse.  */
602 /* XXX hack alert bogus This routine is mostly all junk and almost
603  * certainly does the wrong thing.  Its here simply because it does
604  * just enough to allow glibc-2.1 ld.so to compile & link.
605  */
606
607 static bfd_boolean
608 i370_elf_adjust_dynindx (h, cparg)
609      struct elf_link_hash_entry *h;
610      PTR cparg;
611 {
612   int *cp = (int *) cparg;
613
614 #ifdef DEBUG
615   fprintf (stderr,
616            "i370_elf_adjust_dynindx called, h->dynindx = %d, *cp = %d\n",
617            h->dynindx, *cp);
618 #endif
619
620   if (h->root.type == bfd_link_hash_warning)
621     h = (struct elf_link_hash_entry *) h->root.u.i.link;
622
623   if (h->dynindx != -1)
624     h->dynindx += *cp;
625
626   return TRUE;
627 }
628 \f
629 /* Set the sizes of the dynamic sections.  */
630 /* XXX hack alert bogus This routine is mostly all junk and almost
631  * certainly does the wrong thing.  Its here simply because it does
632  * just enough to allow glibc-2.1 ld.so to compile & link.
633  */
634
635 static bfd_boolean
636 i370_elf_size_dynamic_sections (output_bfd, info)
637      bfd *output_bfd;
638      struct bfd_link_info *info;
639 {
640   bfd *dynobj;
641   asection *s;
642   bfd_boolean plt;
643   bfd_boolean relocs;
644   bfd_boolean reltext;
645
646 #ifdef DEBUG
647   fprintf (stderr, "i370_elf_size_dynamic_sections called\n");
648 #endif
649
650   dynobj = elf_hash_table (info)->dynobj;
651   BFD_ASSERT (dynobj != NULL);
652
653   if (elf_hash_table (info)->dynamic_sections_created)
654     {
655       /* Set the contents of the .interp section to the interpreter.  */
656       if (info->executable)
657         {
658           s = bfd_get_section_by_name (dynobj, ".interp");
659           BFD_ASSERT (s != NULL);
660           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
661           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
662         }
663     }
664   else
665     {
666       /* We may have created entries in the .rela.got, .rela.sdata, and
667          .rela.sdata2 sections.  However, if we are not creating the
668          dynamic sections, we will not actually use these entries.  Reset
669          the size of .rela.got, et al, which will cause it to get
670          stripped from the output file below.  */
671       static char *rela_sections[] = { ".rela.got", ".rela.sdata",
672                                        ".rela.sdata2", ".rela.sbss",
673                                        (char *)0 };
674       char **p;
675
676       for (p = rela_sections; *p != (char *)0; p++)
677         {
678           s = bfd_get_section_by_name (dynobj, *p);
679           if (s != NULL)
680             s->_raw_size = 0;
681         }
682     }
683
684   /* The check_relocs and adjust_dynamic_symbol entry points have
685      determined the sizes of the various dynamic sections.  Allocate
686      memory for them.  */
687   plt = FALSE;
688   relocs = FALSE;
689   reltext = FALSE;
690   for (s = dynobj->sections; s != NULL; s = s->next)
691     {
692       const char *name;
693       bfd_boolean strip;
694
695       if ((s->flags & SEC_LINKER_CREATED) == 0)
696         continue;
697
698       /* It's OK to base decisions on the section name, because none
699          of the dynobj section names depend upon the input files.  */
700       name = bfd_get_section_name (dynobj, s);
701       strip = FALSE;
702
703       if (strcmp (name, ".plt") == 0)
704         {
705           if (s->_raw_size == 0)
706             {
707               /* Strip this section if we don't need it; see the
708                  comment below.  */
709               strip = TRUE;
710             }
711           else
712             {
713               /* Remember whether there is a PLT.  */
714               plt = TRUE;
715             }
716         }
717       else if (strncmp (name, ".rela", 5) == 0)
718         {
719           if (s->_raw_size == 0)
720             {
721               /* If we don't need this section, strip it from the
722                  output file.  This is mostly to handle .rela.bss and
723                  .rela.plt.  We must create both sections in
724                  create_dynamic_sections, because they must be created
725                  before the linker maps input sections to output
726                  sections.  The linker does that before
727                  adjust_dynamic_symbol is called, and it is that
728                  function which decides whether anything needs to go
729                  into these sections.  */
730               strip = TRUE;
731             }
732           else
733             {
734               asection *target;
735               const char *outname;
736
737               /* Remember whether there are any relocation sections.  */
738               relocs = TRUE;
739
740               /* If this relocation section applies to a read only
741                  section, then we probably need a DT_TEXTREL entry.  */
742               outname = bfd_get_section_name (output_bfd,
743                                               s->output_section);
744               target = bfd_get_section_by_name (output_bfd, outname + 5);
745               if (target != NULL
746                   && (target->flags & SEC_READONLY) != 0
747                   && (target->flags & SEC_ALLOC) != 0)
748                 reltext = TRUE;
749
750               /* We use the reloc_count field as a counter if we need
751                  to copy relocs into the output file.  */
752               s->reloc_count = 0;
753             }
754         }
755       else if (strcmp (name, ".got") != 0
756                && strcmp (name, ".sdata") != 0
757                && strcmp (name, ".sdata2") != 0)
758         {
759           /* It's not one of our sections, so don't allocate space.  */
760           continue;
761         }
762
763       if (strip)
764         {
765           asection **spp;
766
767           for (spp = &s->output_section->owner->sections;
768                *spp != NULL;
769                spp = &(*spp)->next)
770             {
771               if (*spp == s->output_section)
772                 {
773                   bfd_section_list_remove (s->output_section->owner, spp);
774                   --s->output_section->owner->section_count;
775                   break;
776                 }
777             }
778           continue;
779         }
780       /* Allocate memory for the section contents.  */
781       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
782       if (s->contents == NULL && s->_raw_size != 0)
783         return FALSE;
784     }
785
786   if (elf_hash_table (info)->dynamic_sections_created)
787     {
788       /* Add some entries to the .dynamic section.  We fill in the
789          values later, in i370_elf_finish_dynamic_sections, but we
790          must add the entries now so that we get the correct size for
791          the .dynamic section.  The DT_DEBUG entry is filled in by the
792          dynamic linker and used by the debugger.  */
793 #define add_dynamic_entry(TAG, VAL) \
794   bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
795
796       if (!info->shared)
797         {
798           if (!add_dynamic_entry (DT_DEBUG, 0))
799             return FALSE;
800         }
801
802       if (plt)
803         {
804           if (!add_dynamic_entry (DT_PLTGOT, 0)
805               || !add_dynamic_entry (DT_PLTRELSZ, 0)
806               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
807               || !add_dynamic_entry (DT_JMPREL, 0))
808             return FALSE;
809         }
810
811       if (relocs)
812         {
813           if (!add_dynamic_entry (DT_RELA, 0)
814               || !add_dynamic_entry (DT_RELASZ, 0)
815               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
816             return FALSE;
817         }
818
819       if (reltext)
820         {
821           if (!add_dynamic_entry (DT_TEXTREL, 0))
822             return FALSE;
823           info->flags |= DF_TEXTREL;
824         }
825     }
826 #undef add_dynamic_entry
827
828   /* If we are generating a shared library, we generate a section
829      symbol for each output section.  These are local symbols, which
830      means that they must come first in the dynamic symbol table.
831      That means we must increment the dynamic symbol index of every
832      other dynamic symbol.
833
834      FIXME: We assume that there will never be relocations to
835      locations in linker-created sections that do not have
836      externally-visible names. Instead, we should work out precisely
837      which sections relocations are targeted at.  */
838   if (info->shared)
839     {
840       int c;
841
842       for (c = 0, s = output_bfd->sections; s != NULL; s = s->next)
843         {
844           if ((s->flags & SEC_LINKER_CREATED) != 0
845               || (s->flags & SEC_ALLOC) == 0)
846             {
847               elf_section_data (s)->dynindx = -1;
848               continue;
849             }
850
851           /* These symbols will have no names, so we don't need to
852              fiddle with dynstr_index.  */
853
854           elf_section_data (s)->dynindx = c + 1;
855
856           c++;
857         }
858
859       elf_link_hash_traverse (elf_hash_table (info),
860                               i370_elf_adjust_dynindx,
861                               (PTR) &c);
862       elf_hash_table (info)->dynsymcount += c;
863     }
864
865   return TRUE;
866 }
867 \f
868 /* Look through the relocs for a section during the first phase, and
869    allocate space in the global offset table or procedure linkage
870    table.  */
871 /* XXX hack alert bogus This routine is mostly all junk and almost
872  * certainly does the wrong thing.  Its here simply because it does
873  * just enough to allow glibc-2.1 ld.so to compile & link.
874  */
875
876 static bfd_boolean
877 i370_elf_check_relocs (abfd, info, sec, relocs)
878      bfd *abfd;
879      struct bfd_link_info *info;
880      asection *sec;
881      const Elf_Internal_Rela *relocs;
882 {
883   bfd *dynobj;
884   Elf_Internal_Shdr *symtab_hdr;
885   struct elf_link_hash_entry **sym_hashes;
886   const Elf_Internal_Rela *rel;
887   const Elf_Internal_Rela *rel_end;
888   bfd_vma *local_got_offsets;
889   asection *sreloc;
890
891   if (info->relocatable)
892     return TRUE;
893
894 #ifdef DEBUG
895   fprintf (stderr, "i370_elf_check_relocs called for section %s in %s\n",
896            bfd_get_section_name (abfd, sec),
897            bfd_archive_filename (abfd));
898 #endif
899
900   dynobj = elf_hash_table (info)->dynobj;
901   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
902   sym_hashes = elf_sym_hashes (abfd);
903   local_got_offsets = elf_local_got_offsets (abfd);
904
905   sreloc = NULL;
906
907   rel_end = relocs + sec->reloc_count;
908   for (rel = relocs; rel < rel_end; rel++)
909     {
910       unsigned long r_symndx;
911       struct elf_link_hash_entry *h;
912
913       r_symndx = ELF32_R_SYM (rel->r_info);
914       if (r_symndx < symtab_hdr->sh_info)
915         h = NULL;
916       else
917         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
918
919       if (info->shared)
920         {
921 #ifdef DEBUG
922           fprintf (stderr,
923                    "i370_elf_check_relocs needs to create relocation for %s\n",
924                    (h && h->root.root.string)
925                    ? h->root.root.string : "<unknown>");
926 #endif
927           if (sreloc == NULL)
928             {
929               const char *name;
930
931               name = (bfd_elf_string_from_elf_section
932                       (abfd,
933                        elf_elfheader (abfd)->e_shstrndx,
934                        elf_section_data (sec)->rel_hdr.sh_name));
935               if (name == NULL)
936                 return FALSE;
937
938               BFD_ASSERT (strncmp (name, ".rela", 5) == 0
939                           && strcmp (bfd_get_section_name (abfd, sec), name + 5) == 0);
940
941               sreloc = bfd_get_section_by_name (dynobj, name);
942               if (sreloc == NULL)
943                 {
944                   flagword flags;
945
946                   sreloc = bfd_make_section (dynobj, name);
947                   flags = (SEC_HAS_CONTENTS | SEC_READONLY
948                            | SEC_IN_MEMORY | SEC_LINKER_CREATED);
949                   if ((sec->flags & SEC_ALLOC) != 0)
950                     flags |= SEC_ALLOC | SEC_LOAD;
951                   if (sreloc == NULL
952                       || ! bfd_set_section_flags (dynobj, sreloc, flags)
953                       || ! bfd_set_section_alignment (dynobj, sreloc, 2))
954                     return FALSE;
955                 }
956             }
957
958           sreloc->_raw_size += sizeof (Elf32_External_Rela);
959
960           /* FIXME: We should here do what the m68k and i386
961              backends do: if the reloc is pc-relative, record it
962              in case it turns out that the reloc is unnecessary
963              because the symbol is forced local by versioning or
964              we are linking with -Bdynamic.  Fortunately this
965              case is not frequent.  */
966         }
967     }
968
969   return TRUE;
970 }
971 \f
972 /* Finish up the dynamic sections.  */
973 /* XXX hack alert bogus This routine is mostly all junk and almost
974  * certainly does the wrong thing.  Its here simply because it does
975  * just enough to allow glibc-2.1 ld.so to compile & link.
976  */
977
978 static bfd_boolean
979 i370_elf_finish_dynamic_sections (output_bfd, info)
980      bfd *output_bfd;
981      struct bfd_link_info *info;
982 {
983   asection *sdyn;
984   bfd *dynobj = elf_hash_table (info)->dynobj;
985   asection *sgot = bfd_get_section_by_name (dynobj, ".got");
986
987 #ifdef DEBUG
988   fprintf (stderr, "i370_elf_finish_dynamic_sections called\n");
989 #endif
990
991   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
992
993   if (elf_hash_table (info)->dynamic_sections_created)
994     {
995       asection *splt;
996       Elf32_External_Dyn *dyncon, *dynconend;
997
998       splt = bfd_get_section_by_name (dynobj, ".plt");
999       BFD_ASSERT (splt != NULL && sdyn != NULL);
1000
1001       dyncon = (Elf32_External_Dyn *) sdyn->contents;
1002       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
1003       for (; dyncon < dynconend; dyncon++)
1004         {
1005           Elf_Internal_Dyn dyn;
1006           const char *name;
1007           bfd_boolean size;
1008
1009           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1010
1011           switch (dyn.d_tag)
1012             {
1013             case DT_PLTGOT:   name = ".plt";      size = FALSE; break;
1014             case DT_PLTRELSZ: name = ".rela.plt"; size = TRUE;  break;
1015             case DT_JMPREL:   name = ".rela.plt"; size = FALSE; break;
1016             default:          name = NULL;        size = FALSE; break;
1017             }
1018
1019           if (name != NULL)
1020             {
1021               asection *s;
1022
1023               s = bfd_get_section_by_name (output_bfd, name);
1024               if (s == NULL)
1025                 dyn.d_un.d_val = 0;
1026               else
1027                 {
1028                   if (! size)
1029                     dyn.d_un.d_ptr = s->vma;
1030                   else
1031                     {
1032                       if (s->_cooked_size != 0)
1033                         dyn.d_un.d_val = s->_cooked_size;
1034                       else
1035                         dyn.d_un.d_val = s->_raw_size;
1036                     }
1037                 }
1038               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1039             }
1040         }
1041     }
1042
1043   /* Add a blrl instruction at _GLOBAL_OFFSET_TABLE_-4 so that a function can
1044      easily find the address of the _GLOBAL_OFFSET_TABLE_.  */
1045 /* XXX this is clearly very wrong for the 370 arch */
1046   if (sgot)
1047     {
1048       unsigned char *contents = sgot->contents;
1049       bfd_put_32 (output_bfd, (bfd_vma) 0x4e800021 /* blrl */, contents);
1050
1051       if (sdyn == NULL)
1052         bfd_put_32 (output_bfd, (bfd_vma) 0, contents+4);
1053       else
1054         bfd_put_32 (output_bfd,
1055                     sdyn->output_section->vma + sdyn->output_offset,
1056                     contents+4);
1057
1058       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1059     }
1060
1061   if (info->shared)
1062     {
1063       asection *sdynsym;
1064       asection *s;
1065       Elf_Internal_Sym sym;
1066       int maxdindx = 0;
1067
1068       /* Set up the section symbols for the output sections.  */
1069
1070       sdynsym = bfd_get_section_by_name (dynobj, ".dynsym");
1071       BFD_ASSERT (sdynsym != NULL);
1072
1073       sym.st_size = 0;
1074       sym.st_name = 0;
1075       sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
1076       sym.st_other = 0;
1077
1078       for (s = output_bfd->sections; s != NULL; s = s->next)
1079         {
1080           int indx, dindx;
1081           Elf32_External_Sym *esym;
1082
1083           sym.st_value = s->vma;
1084
1085           indx = elf_section_data (s)->this_idx;
1086           dindx = elf_section_data (s)->dynindx;
1087           if (dindx != -1)
1088             {
1089               BFD_ASSERT(indx > 0);
1090               BFD_ASSERT(dindx > 0);
1091
1092               if (dindx > maxdindx)
1093                 maxdindx = dindx;
1094
1095               sym.st_shndx = indx;
1096
1097               esym = (Elf32_External_Sym *) sdynsym->contents + dindx;
1098               bfd_elf32_swap_symbol_out (output_bfd, &sym, (PTR) esym, (PTR) 0);
1099             }
1100         }
1101
1102       /* Set the sh_info field of the output .dynsym section to the
1103          index of the first global symbol.  */
1104       elf_section_data (sdynsym->output_section)->this_hdr.sh_info =
1105         maxdindx + 1;
1106     }
1107
1108   return TRUE;
1109 }
1110 \f
1111 /* The RELOCATE_SECTION function is called by the ELF backend linker
1112    to handle the relocations for a section.
1113
1114    The relocs are always passed as Rela structures; if the section
1115    actually uses Rel structures, the r_addend field will always be
1116    zero.
1117
1118    This function is responsible for adjust the section contents as
1119    necessary, and (if using Rela relocs and generating a
1120    relocatable output file) adjusting the reloc addend as
1121    necessary.
1122
1123    This function does not have to worry about setting the reloc
1124    address or the reloc symbol index.
1125
1126    LOCAL_SYMS is a pointer to the swapped in local symbols.
1127
1128    LOCAL_SECTIONS is an array giving the section in the input file
1129    corresponding to the st_shndx field of each local symbol.
1130
1131    The global hash table entry for the global symbols can be found
1132    via elf_sym_hashes (input_bfd).
1133
1134    When generating relocatable output, this function must handle
1135    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
1136    going to be the section symbol corresponding to the output
1137    section, which means that the addend must be adjusted
1138    accordingly.  */
1139
1140 static bfd_boolean
1141 i370_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1142                            contents, relocs, local_syms, local_sections)
1143      bfd *output_bfd;
1144      struct bfd_link_info *info;
1145      bfd *input_bfd;
1146      asection *input_section;
1147      bfd_byte *contents;
1148      Elf_Internal_Rela *relocs;
1149      Elf_Internal_Sym *local_syms;
1150      asection **local_sections;
1151 {
1152   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1153   struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
1154   bfd *dynobj = elf_hash_table (info)->dynobj;
1155   Elf_Internal_Rela *rel = relocs;
1156   Elf_Internal_Rela *relend = relocs + input_section->reloc_count;
1157   asection *sreloc = NULL;
1158   bfd_vma *local_got_offsets;
1159   bfd_boolean ret = TRUE;
1160
1161   if (info->relocatable)
1162     return TRUE;
1163
1164 #ifdef DEBUG
1165   fprintf (stderr, "i370_elf_relocate_section called for %s section %s, %ld relocations%s\n",
1166            bfd_archive_filename (input_bfd),
1167            bfd_section_name(input_bfd, input_section),
1168            (long) input_section->reloc_count,
1169            (info->relocatable) ? " (relocatable)" : "");
1170 #endif
1171
1172   if (!i370_elf_howto_table[ R_I370_ADDR31 ])   /* Initialize howto table if needed */
1173     i370_elf_howto_init ();
1174
1175   local_got_offsets = elf_local_got_offsets (input_bfd);
1176
1177   for (; rel < relend; rel++)
1178     {
1179       enum i370_reloc_type r_type       = (enum i370_reloc_type)ELF32_R_TYPE (rel->r_info);
1180       bfd_vma offset                    = rel->r_offset;
1181       bfd_vma addend                    = rel->r_addend;
1182       bfd_reloc_status_type r           = bfd_reloc_other;
1183       Elf_Internal_Sym *sym             = (Elf_Internal_Sym *)0;
1184       asection *sec                     = (asection *)0;
1185       struct elf_link_hash_entry *h     = (struct elf_link_hash_entry *)0;
1186       const char *sym_name              = (const char *)0;
1187       reloc_howto_type *howto;
1188       unsigned long r_symndx;
1189       bfd_vma relocation;
1190
1191       /* Unknown relocation handling */
1192       if ((unsigned)r_type >= (unsigned)R_I370_max
1193           || !i370_elf_howto_table[(int)r_type])
1194         {
1195           (*_bfd_error_handler) ("%s: unknown relocation type %d",
1196                                  bfd_archive_filename (input_bfd),
1197                                  (int) r_type);
1198
1199           bfd_set_error (bfd_error_bad_value);
1200           ret = FALSE;
1201           continue;
1202         }
1203
1204       howto = i370_elf_howto_table[(int)r_type];
1205       r_symndx = ELF32_R_SYM (rel->r_info);
1206
1207       if (r_symndx < symtab_hdr->sh_info)
1208         {
1209           sym = local_syms + r_symndx;
1210           sec = local_sections[r_symndx];
1211           sym_name = "<local symbol>";
1212
1213           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1214           addend = rel->r_addend;
1215         }
1216       else
1217         {
1218           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1219           while (h->root.type == bfd_link_hash_indirect
1220                  || h->root.type == bfd_link_hash_warning)
1221             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1222           sym_name = h->root.root.string;
1223           if (h->root.type == bfd_link_hash_defined
1224               || h->root.type == bfd_link_hash_defweak)
1225             {
1226               sec = h->root.u.def.section;
1227               if (info->shared
1228                   && ((! info->symbolic && h->dynindx != -1)
1229                       || (h->elf_link_hash_flags
1230                           & ELF_LINK_HASH_DEF_REGULAR) == 0)
1231                   && (input_section->flags & SEC_ALLOC) != 0
1232                   && (r_type == R_I370_ADDR31
1233                       || r_type == R_I370_COPY
1234                       || r_type == R_I370_ADDR16
1235                       || r_type == R_I370_RELATIVE))
1236                 {
1237                   /* In these cases, we don't need the relocation
1238                      value.  We check specially because in some
1239                      obscure cases sec->output_section will be NULL.  */
1240                   relocation = 0;
1241                 }
1242               else
1243                 relocation = (h->root.u.def.value
1244                               + sec->output_section->vma
1245                               + sec->output_offset);
1246             }
1247           else if (h->root.type == bfd_link_hash_undefweak)
1248             relocation = 0;
1249           else if (info->shared
1250                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1251             relocation = 0;
1252           else
1253             {
1254               (*info->callbacks->undefined_symbol) (info,
1255                                                     h->root.root.string,
1256                                                     input_bfd,
1257                                                     input_section,
1258                                                     rel->r_offset,
1259                                                     TRUE);
1260               ret = FALSE;
1261               continue;
1262             }
1263         }
1264
1265       switch ((int) r_type)
1266         {
1267         default:
1268           (*_bfd_error_handler)
1269             ("%s: unknown relocation type %d for symbol %s",
1270              bfd_archive_filename (input_bfd),
1271              (int) r_type, sym_name);
1272
1273           bfd_set_error (bfd_error_bad_value);
1274           ret = FALSE;
1275           continue;
1276
1277         case (int)R_I370_NONE:
1278           continue;
1279
1280         /* Relocations that may need to be propagated if this is a shared
1281            object.  */
1282         case (int)R_I370_REL31:
1283           /* If these relocations are not to a named symbol, they can be
1284              handled right here, no need to bother the dynamic linker.  */
1285           if (h == NULL
1286               || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
1287             break;
1288         /* fall through */
1289
1290         /* Relocations that always need to be propagated if this is a shared
1291            object.  */
1292         case (int)R_I370_ADDR31:
1293         case (int)R_I370_ADDR16:
1294           if (info->shared
1295               && r_symndx != 0)
1296             {
1297               Elf_Internal_Rela outrel;
1298               bfd_byte *loc;
1299               int skip;
1300
1301 #ifdef DEBUG
1302               fprintf (stderr,
1303                        "i370_elf_relocate_section needs to create relocation for %s\n",
1304                        (h && h->root.root.string) ? h->root.root.string : "<unknown>");
1305 #endif
1306
1307               /* When generating a shared object, these relocations
1308                  are copied into the output file to be resolved at run
1309                  time.  */
1310
1311               if (sreloc == NULL)
1312                 {
1313                   const char *name;
1314
1315                   name = (bfd_elf_string_from_elf_section
1316                           (input_bfd,
1317                            elf_elfheader (input_bfd)->e_shstrndx,
1318                            elf_section_data (input_section)->rel_hdr.sh_name));
1319                   if (name == NULL)
1320                     return FALSE;
1321
1322                   BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1323                               && strcmp (bfd_get_section_name (input_bfd,
1324                                                                input_section),
1325                                          name + 5) == 0);
1326
1327                   sreloc = bfd_get_section_by_name (dynobj, name);
1328                   BFD_ASSERT (sreloc != NULL);
1329                 }
1330
1331               skip = 0;
1332
1333               outrel.r_offset =
1334                 _bfd_elf_section_offset (output_bfd, info, input_section,
1335                                          rel->r_offset);
1336               if (outrel.r_offset == (bfd_vma) -1
1337                   || outrel.r_offset == (bfd_vma) -2)
1338                 skip = (int) outrel.r_offset;
1339               outrel.r_offset += (input_section->output_section->vma
1340                                   + input_section->output_offset);
1341
1342               if (skip)
1343                 memset (&outrel, 0, sizeof outrel);
1344               /* h->dynindx may be -1 if this symbol was marked to
1345                  become local.  */
1346               else if (h != NULL
1347                        && ((! info->symbolic && h->dynindx != -1)
1348                            || (h->elf_link_hash_flags
1349                                & ELF_LINK_HASH_DEF_REGULAR) == 0))
1350                 {
1351                   BFD_ASSERT (h->dynindx != -1);
1352                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1353                   outrel.r_addend = rel->r_addend;
1354                 }
1355               else
1356                 {
1357                   if (r_type == R_I370_ADDR31)
1358                     {
1359                       outrel.r_info = ELF32_R_INFO (0, R_I370_RELATIVE);
1360                       outrel.r_addend = relocation + rel->r_addend;
1361                     }
1362                   else
1363                     {
1364                       long indx;
1365
1366                       if (bfd_is_abs_section (sec))
1367                         indx = 0;
1368                       else if (sec == NULL || sec->owner == NULL)
1369                         {
1370                           bfd_set_error (bfd_error_bad_value);
1371                           return FALSE;
1372                         }
1373                       else
1374                         {
1375                           asection *osec;
1376
1377                           osec = sec->output_section;
1378                           indx = elf_section_data (osec)->dynindx;
1379                           BFD_ASSERT(indx > 0);
1380 #ifdef DEBUG
1381                           if (indx <= 0)
1382                             {
1383                               printf ("indx=%d section=%s flags=%08x name=%s\n",
1384                                       indx, osec->name, osec->flags,
1385                                       h->root.root.string);
1386                             }
1387 #endif
1388                         }
1389
1390                       outrel.r_info = ELF32_R_INFO (indx, r_type);
1391                       outrel.r_addend = relocation + rel->r_addend;
1392                     }
1393                 }
1394
1395               loc = sreloc->contents;
1396               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1397               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1398
1399               /* This reloc will be computed at runtime, so there's no
1400                  need to do anything now, unless this is a RELATIVE
1401                  reloc in an unallocated section.  */
1402               if (skip == -1
1403                   || (input_section->flags & SEC_ALLOC) != 0
1404                   || ELF32_R_TYPE (outrel.r_info) != R_I370_RELATIVE)
1405                 continue;
1406             }
1407           break;
1408
1409         case (int)R_I370_COPY:
1410         case (int)R_I370_RELATIVE:
1411           (*_bfd_error_handler)
1412             ("%s: Relocation %s is not yet supported for symbol %s.",
1413              bfd_archive_filename (input_bfd),
1414              i370_elf_howto_table[(int) r_type]->name,
1415              sym_name);
1416
1417           bfd_set_error (bfd_error_invalid_operation);
1418           ret = FALSE;
1419           continue;
1420         }
1421
1422 #ifdef DEBUG
1423       fprintf (stderr, "\ttype = %s (%d), name = %s, symbol index = %ld, offset = %ld, addend = %ld\n",
1424                howto->name,
1425                (int)r_type,
1426                sym_name,
1427                r_symndx,
1428                (long)offset,
1429                (long)addend);
1430 #endif
1431
1432       r = _bfd_final_link_relocate (howto,
1433                                     input_bfd,
1434                                     input_section,
1435                                     contents,
1436                                     offset,
1437                                     relocation,
1438                                     addend);
1439
1440       if (r != bfd_reloc_ok)
1441         {
1442           ret = FALSE;
1443           switch (r)
1444             {
1445             default:
1446               break;
1447
1448             case bfd_reloc_overflow:
1449               {
1450                 const char *name;
1451
1452                 if (h != NULL)
1453                   name = h->root.root.string;
1454                 else
1455                   {
1456                     name = bfd_elf_string_from_elf_section (input_bfd,
1457                                                             symtab_hdr->sh_link,
1458                                                             sym->st_name);
1459                     if (name == NULL)
1460                       break;
1461
1462                     if (*name == '\0')
1463                       name = bfd_section_name (input_bfd, sec);
1464                   }
1465
1466                 (*info->callbacks->reloc_overflow) (info,
1467                                                     name,
1468                                                     howto->name,
1469                                                     (bfd_vma) 0,
1470                                                     input_bfd,
1471                                                     input_section,
1472                                                     offset);
1473               }
1474               break;
1475
1476             }
1477         }
1478     }
1479
1480 #ifdef DEBUG
1481   fprintf (stderr, "\n");
1482 #endif
1483
1484   return ret;
1485 }
1486
1487 static void
1488 i370_elf_post_process_headers (abfd, link_info)
1489     bfd * abfd;
1490     struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
1491 {
1492   Elf_Internal_Ehdr * i_ehdrp;  /* Elf file header, internal form */
1493
1494   i_ehdrp = elf_elfheader (abfd);
1495   i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_LINUX;
1496 }
1497 \f
1498 #define TARGET_BIG_SYM          bfd_elf32_i370_vec
1499 #define TARGET_BIG_NAME         "elf32-i370"
1500 #define ELF_ARCH                bfd_arch_i370
1501 #define ELF_MACHINE_CODE        EM_S370
1502 #ifdef EM_I370_OLD
1503 #define ELF_MACHINE_ALT1        EM_I370_OLD
1504 #endif
1505 #define ELF_MAXPAGESIZE         0x1000
1506 #define elf_info_to_howto       i370_elf_info_to_howto
1507
1508 #define elf_backend_plt_not_loaded 1
1509 #define elf_backend_got_symbol_offset 4
1510 #define elf_backend_rela_normal 1
1511
1512 #define bfd_elf32_bfd_reloc_type_lookup         i370_elf_reloc_type_lookup
1513 #define bfd_elf32_bfd_set_private_flags         i370_elf_set_private_flags
1514 #define bfd_elf32_bfd_merge_private_bfd_data    i370_elf_merge_private_bfd_data
1515 #define elf_backend_relocate_section            i370_elf_relocate_section
1516
1517 /* dynamic loader support is mostly broken; just enough here to be able to
1518  * link glibc's ld.so without errors.
1519  */
1520 #define elf_backend_create_dynamic_sections     i370_elf_create_dynamic_sections
1521 #define elf_backend_size_dynamic_sections       i370_elf_size_dynamic_sections
1522 #define elf_backend_finish_dynamic_sections     i370_elf_finish_dynamic_sections
1523 #define elf_backend_fake_sections               i370_elf_fake_sections
1524 #define elf_backend_section_from_shdr           i370_elf_section_from_shdr
1525 #define elf_backend_adjust_dynamic_symbol       i370_elf_adjust_dynamic_symbol
1526 #define elf_backend_check_relocs                i370_elf_check_relocs
1527
1528 /*
1529 #define elf_backend_add_symbol_hook             i370_elf_add_symbol_hook
1530 #define elf_backend_finish_dynamic_symbol       i370_elf_finish_dynamic_symbol
1531 #define elf_backend_additional_program_headers  i370_elf_additional_program_headers
1532 #define elf_backend_modify_segment_map          i370_elf_modify_segment_map
1533 */
1534
1535 #define elf_backend_post_process_headers        i370_elf_post_process_headers
1536
1537 static int i370_noop
1538   PARAMS ((void));
1539
1540 static int i370_noop ()
1541 {
1542   return 1;
1543 }
1544
1545 /* we need to define these at least as no-ops to link glibc ld.so */
1546
1547 #define elf_backend_add_symbol_hook \
1548   (bfd_boolean (*) \
1549      PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *, \
1550               const char **, flagword *, asection **, bfd_vma *))) i370_noop
1551 #define elf_backend_finish_dynamic_symbol \
1552   (bfd_boolean (*) \
1553      PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *, \
1554               Elf_Internal_Sym *))) i370_noop
1555 #define elf_backend_additional_program_headers \
1556   (int (*) PARAMS ((bfd *))) i370_noop
1557 #define elf_backend_modify_segment_map \
1558   (bfd_boolean (*) PARAMS ((bfd *, struct bfd_link_info *))) i370_noop
1559
1560 #include "elf32-target.h"