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