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