1 /* IBM S/390-specific support for 64-bit ELF
2 Copyright 2000, 2001 Free Software Foundation, Inc.
3 Contributed Martin Schwidefsky (schwidefsky@de.ibm.com).
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
28 static reloc_howto_type
*elf_s390_reloc_type_lookup
29 PARAMS ((bfd
*, bfd_reloc_code_real_type
));
30 static void elf_s390_info_to_howto
31 PARAMS ((bfd
*, arelent
*, Elf_Internal_Rela
*));
32 static boolean elf_s390_is_local_label_name
33 PARAMS ((bfd
*, const char *));
34 static struct bfd_hash_entry
*link_hash_newfunc
35 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
36 static struct bfd_link_hash_table
*elf_s390_link_hash_table_create
38 static boolean create_got_section
39 PARAMS((bfd
*, struct bfd_link_info
*));
40 static boolean elf_s390_create_dynamic_sections
41 PARAMS((bfd
*, struct bfd_link_info
*));
42 static void elf_s390_copy_indirect_symbol
43 PARAMS ((struct elf_link_hash_entry
*, struct elf_link_hash_entry
*));
44 static boolean elf_s390_check_relocs
45 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
46 const Elf_Internal_Rela
*));
47 static asection
*elf_s390_gc_mark_hook
48 PARAMS ((bfd
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
49 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
50 static boolean elf_s390_gc_sweep_hook
51 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
52 const Elf_Internal_Rela
*));
53 static boolean elf_s390_adjust_dynamic_symbol
54 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
55 static boolean allocate_dynrelocs
56 PARAMS ((struct elf_link_hash_entry
*, PTR
));
57 static boolean readonly_dynrelocs
58 PARAMS ((struct elf_link_hash_entry
*, PTR
));
59 static boolean elf_s390_size_dynamic_sections
60 PARAMS ((bfd
*, struct bfd_link_info
*));
61 static boolean elf_s390_relocate_section
62 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
63 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
64 static boolean elf_s390_finish_dynamic_symbol
65 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
67 static enum elf_reloc_type_class elf_s390_reloc_type_class
68 PARAMS ((const Elf_Internal_Rela
*));
69 static boolean elf_s390_finish_dynamic_sections
70 PARAMS ((bfd
*, struct bfd_link_info
*));
71 static boolean elf_s390_object_p
PARAMS ((bfd
*));
73 #define USE_RELA 1 /* We want RELA relocations, not REL. */
77 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
78 from smaller values. Start with zero, widen, *then* decrement. */
79 #define MINUS_ONE (((bfd_vma)0) - 1)
81 /* The relocation "howto" table. */
82 static reloc_howto_type elf_howto_table
[] =
84 HOWTO (R_390_NONE
, /* type */
86 0, /* size (0 = byte, 1 = short, 2 = long) */
88 false, /* pc_relative */
90 complain_overflow_dont
, /* complain_on_overflow */
91 bfd_elf_generic_reloc
, /* special_function */
92 "R_390_NONE", /* name */
93 false, /* partial_inplace */
96 false), /* pcrel_offset */
98 HOWTO(R_390_8
, 0, 0, 8, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_8", false, 0,0x000000ff, false),
99 HOWTO(R_390_12
, 0, 1, 12, false, 0, complain_overflow_dont
, bfd_elf_generic_reloc
, "R_390_12", false, 0,0x00000fff, false),
100 HOWTO(R_390_16
, 0, 1, 16, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_16", false, 0,0x0000ffff, false),
101 HOWTO(R_390_32
, 0, 2, 32, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_32", false, 0,0xffffffff, false),
102 HOWTO(R_390_PC32
, 0, 2, 32, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PC32", false, 0,0xffffffff, true),
103 HOWTO(R_390_GOT12
, 0, 1, 12, false, 0, complain_overflow_dont
, bfd_elf_generic_reloc
, "R_390_GOT12", false, 0,0x00000fff, false),
104 HOWTO(R_390_GOT32
, 0, 2, 32, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_GOT32", false, 0,0xffffffff, false),
105 HOWTO(R_390_PLT32
, 0, 2, 32, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PLT32", false, 0,0xffffffff, true),
106 HOWTO(R_390_COPY
, 0, 4, 64, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_COPY", false, 0,MINUS_ONE
, false),
107 HOWTO(R_390_GLOB_DAT
, 0, 4, 64, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_GLOB_DAT",false, 0,MINUS_ONE
, false),
108 HOWTO(R_390_JMP_SLOT
, 0, 4, 64, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_JMP_SLOT",false, 0,MINUS_ONE
, false),
109 HOWTO(R_390_RELATIVE
, 0, 4, 64, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_RELATIVE",false, 0,MINUS_ONE
, false),
110 HOWTO(R_390_GOTOFF
, 0, 4, 64, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_GOTOFF", false, 0,MINUS_ONE
, false),
111 HOWTO(R_390_GOTPC
, 0, 4, 64, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_GOTPC", false, 0,MINUS_ONE
, true),
112 HOWTO(R_390_GOT16
, 0, 1, 16, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_GOT16", false, 0,0x0000ffff, false),
113 HOWTO(R_390_PC16
, 0, 1, 16, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PC16", false, 0,0x0000ffff, true),
114 HOWTO(R_390_PC16DBL
, 1, 1, 16, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PC16DBL", false, 0,0x0000ffff, true),
115 HOWTO(R_390_PLT16DBL
, 1, 1, 16, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PLT16DBL", false, 0,0x0000ffff, true),
116 HOWTO(R_390_PC32DBL
, 1, 2, 32, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PC32DBL", false, 0,0xffffffff, true),
117 HOWTO(R_390_PLT32DBL
, 1, 2, 32, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PLT32DBL", false, 0,0xffffffff, true),
118 HOWTO(R_390_GOTPCDBL
, 1, 2, 32, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_GOTPCDBL", false, 0,MINUS_ONE
, true),
119 HOWTO(R_390_64
, 0, 4, 64, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_64", false, 0,MINUS_ONE
, false),
120 HOWTO(R_390_PC64
, 0, 4, 64, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PC64", false, 0,MINUS_ONE
, true),
121 HOWTO(R_390_GOT64
, 0, 4, 64, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_GOT64", false, 0,MINUS_ONE
, false),
122 HOWTO(R_390_PLT64
, 0, 4, 64, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PLT64", false, 0,MINUS_ONE
, true),
123 HOWTO(R_390_GOTENT
, 1, 2, 32, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_GOTENT", false, 0,MINUS_ONE
, true),
126 /* GNU extension to record C++ vtable hierarchy. */
127 static reloc_howto_type elf64_s390_vtinherit_howto
=
128 HOWTO (R_390_GNU_VTINHERIT
, 0,4,0,false,0,complain_overflow_dont
, NULL
, "R_390_GNU_VTINHERIT", false,0, 0, false);
129 static reloc_howto_type elf64_s390_vtentry_howto
=
130 HOWTO (R_390_GNU_VTENTRY
, 0,4,0,false,0,complain_overflow_dont
, _bfd_elf_rel_vtable_reloc_fn
,"R_390_GNU_VTENTRY", false,0,0, false);
132 static reloc_howto_type
*
133 elf_s390_reloc_type_lookup (abfd
, code
)
134 bfd
*abfd ATTRIBUTE_UNUSED
;
135 bfd_reloc_code_real_type code
;
140 return &elf_howto_table
[(int) R_390_NONE
];
142 return &elf_howto_table
[(int) R_390_8
];
143 case BFD_RELOC_390_12
:
144 return &elf_howto_table
[(int) R_390_12
];
146 return &elf_howto_table
[(int) R_390_16
];
148 return &elf_howto_table
[(int) R_390_32
];
150 return &elf_howto_table
[(int) R_390_32
];
151 case BFD_RELOC_32_PCREL
:
152 return &elf_howto_table
[(int) R_390_PC32
];
153 case BFD_RELOC_390_GOT12
:
154 return &elf_howto_table
[(int) R_390_GOT12
];
155 case BFD_RELOC_32_GOT_PCREL
:
156 return &elf_howto_table
[(int) R_390_GOT32
];
157 case BFD_RELOC_390_PLT32
:
158 return &elf_howto_table
[(int) R_390_PLT32
];
159 case BFD_RELOC_390_COPY
:
160 return &elf_howto_table
[(int) R_390_COPY
];
161 case BFD_RELOC_390_GLOB_DAT
:
162 return &elf_howto_table
[(int) R_390_GLOB_DAT
];
163 case BFD_RELOC_390_JMP_SLOT
:
164 return &elf_howto_table
[(int) R_390_JMP_SLOT
];
165 case BFD_RELOC_390_RELATIVE
:
166 return &elf_howto_table
[(int) R_390_RELATIVE
];
167 case BFD_RELOC_32_GOTOFF
:
168 return &elf_howto_table
[(int) R_390_GOTOFF
];
169 case BFD_RELOC_390_GOTPC
:
170 return &elf_howto_table
[(int) R_390_GOTPC
];
171 case BFD_RELOC_390_GOT16
:
172 return &elf_howto_table
[(int) R_390_GOT16
];
173 case BFD_RELOC_16_PCREL
:
174 return &elf_howto_table
[(int) R_390_PC16
];
175 case BFD_RELOC_390_PC16DBL
:
176 return &elf_howto_table
[(int) R_390_PC16DBL
];
177 case BFD_RELOC_390_PLT16DBL
:
178 return &elf_howto_table
[(int) R_390_PLT16DBL
];
179 case BFD_RELOC_VTABLE_INHERIT
:
180 return &elf64_s390_vtinherit_howto
;
181 case BFD_RELOC_VTABLE_ENTRY
:
182 return &elf64_s390_vtentry_howto
;
183 case BFD_RELOC_390_PC32DBL
:
184 return &elf_howto_table
[(int) R_390_PC32DBL
];
185 case BFD_RELOC_390_PLT32DBL
:
186 return &elf_howto_table
[(int) R_390_PLT32DBL
];
187 case BFD_RELOC_390_GOTPCDBL
:
188 return &elf_howto_table
[(int) R_390_GOTPCDBL
];
190 return &elf_howto_table
[(int) R_390_64
];
191 case BFD_RELOC_64_PCREL
:
192 return &elf_howto_table
[(int) R_390_PC64
];
193 case BFD_RELOC_390_GOT64
:
194 return &elf_howto_table
[(int) R_390_GOT64
];
195 case BFD_RELOC_390_PLT64
:
196 return &elf_howto_table
[(int) R_390_PLT64
];
197 case BFD_RELOC_390_GOTENT
:
198 return &elf_howto_table
[(int) R_390_GOTENT
];
205 /* We need to use ELF64_R_TYPE so we have our own copy of this function,
206 and elf64-s390.c has its own copy. */
209 elf_s390_info_to_howto (abfd
, cache_ptr
, dst
)
210 bfd
*abfd ATTRIBUTE_UNUSED
;
212 Elf_Internal_Rela
*dst
;
214 switch (ELF64_R_TYPE(dst
->r_info
))
216 case R_390_GNU_VTINHERIT
:
217 cache_ptr
->howto
= &elf64_s390_vtinherit_howto
;
220 case R_390_GNU_VTENTRY
:
221 cache_ptr
->howto
= &elf64_s390_vtentry_howto
;
225 BFD_ASSERT (ELF64_R_TYPE(dst
->r_info
) < (unsigned int) R_390_max
);
226 cache_ptr
->howto
= &elf_howto_table
[ELF64_R_TYPE(dst
->r_info
)];
231 elf_s390_is_local_label_name (abfd
, name
)
235 if (name
[0] == '.' && (name
[1] == 'X' || name
[1] == 'L'))
238 return _bfd_elf_is_local_label_name (abfd
, name
);
241 /* Functions for the 390 ELF linker. */
243 /* The name of the dynamic interpreter. This is put in the .interp
246 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
248 /* The size in bytes of the first entry in the procedure linkage table. */
249 #define PLT_FIRST_ENTRY_SIZE 32
250 /* The size in bytes of an entry in the procedure linkage table. */
251 #define PLT_ENTRY_SIZE 32
253 #define GOT_ENTRY_SIZE 8
255 /* The first three entries in a procedure linkage table are reserved,
256 and the initial contents are unimportant (we zero them out).
257 Subsequent entries look like this. See the SVR4 ABI 386
258 supplement to see how this works. */
260 /* For the s390, simple addr offset can only be 0 - 4096.
261 To use the full 16777216 TB address space, several instructions
262 are needed to load an address in a register and execute
263 a branch( or just saving the address)
265 Furthermore, only r 0 and 1 are free to use!!! */
267 /* The first 3 words in the GOT are then reserved.
268 Word 0 is the address of the dynamic table.
269 Word 1 is a pointer to a structure describing the object
270 Word 2 is used to point to the loader entry address.
272 The code for PLT entries looks like this:
274 The GOT holds the address in the PLT to be executed.
275 The loader then gets:
276 24(15) = Pointer to the structure describing the object.
277 28(15) = Offset in symbol table
278 The loader must then find the module where the function is
279 and insert the address in the GOT.
281 PLT1: LARL 1,<fn>@GOTENT # 6 bytes Load address of GOT entry in r1
282 LG 1,0(1) # 6 bytes Load address from GOT in r1
283 BCR 15,1 # 2 bytes Jump to address
284 RET1: BASR 1,0 # 2 bytes Return from GOT 1st time
285 LGF 1,12(1) # 6 bytes Load offset in symbl table in r1
286 BRCL 15,-x # 6 bytes Jump to start of PLT
287 .long ? # 4 bytes offset into symbol table
289 Total = 32 bytes per PLT entry
290 Fixup at offset 2: relative address to GOT entry
291 Fixup at offset 22: relative branch to PLT0
292 Fixup at offset 28: 32 bit offset into symbol table
294 A 32 bit offset into the symbol table is enough. It allows for symbol
295 tables up to a size of 2 gigabyte. A single dynamic object (the main
296 program, any shared library) is limited to 4GB in size and I want to see
297 the program that manages to have a symbol table of more than 2 GB with a
298 total size of at max 4 GB. */
300 #define PLT_ENTRY_WORD0 (bfd_vma) 0xc0100000
301 #define PLT_ENTRY_WORD1 (bfd_vma) 0x0000e310
302 #define PLT_ENTRY_WORD2 (bfd_vma) 0x10000004
303 #define PLT_ENTRY_WORD3 (bfd_vma) 0x07f10d10
304 #define PLT_ENTRY_WORD4 (bfd_vma) 0xe310100c
305 #define PLT_ENTRY_WORD5 (bfd_vma) 0x0014c0f4
306 #define PLT_ENTRY_WORD6 (bfd_vma) 0x00000000
307 #define PLT_ENTRY_WORD7 (bfd_vma) 0x00000000
309 /* The first PLT entry pushes the offset into the symbol table
310 from R1 onto the stack at 8(15) and the loader object info
311 at 12(15), loads the loader address in R1 and jumps to it. */
313 /* The first entry in the PLT:
316 STG 1,56(15) # r1 contains the offset into the symbol table
317 LARL 1,_GLOBAL_OFFSET_TABLE # load address of global offset table
318 MVC 48(8,15),8(1) # move loader ino (object struct address) to stack
319 LG 1,16(1) # get entry address of loader
320 BCR 15,1 # jump to loader
322 Fixup at offset 8: relative address to start of GOT. */
324 #define PLT_FIRST_ENTRY_WORD0 (bfd_vma) 0xe310f038
325 #define PLT_FIRST_ENTRY_WORD1 (bfd_vma) 0x0024c010
326 #define PLT_FIRST_ENTRY_WORD2 (bfd_vma) 0x00000000
327 #define PLT_FIRST_ENTRY_WORD3 (bfd_vma) 0xd207f030
328 #define PLT_FIRST_ENTRY_WORD4 (bfd_vma) 0x1008e310
329 #define PLT_FIRST_ENTRY_WORD5 (bfd_vma) 0x10100004
330 #define PLT_FIRST_ENTRY_WORD6 (bfd_vma) 0x07f10700
331 #define PLT_FIRST_ENTRY_WORD7 (bfd_vma) 0x07000700
333 /* The s390 linker needs to keep track of the number of relocs that it
334 decides to copy as dynamic relocs in check_relocs for each symbol.
335 This is so that it can later discard them if they are found to be
336 unnecessary. We store the information in a field extending the
337 regular ELF linker hash table. */
339 struct elf_s390_dyn_relocs
341 struct elf_s390_dyn_relocs
*next
;
343 /* The input section of the reloc. */
346 /* Total number of relocs copied for the input section. */
349 /* Number of pc-relative relocs copied for the input section. */
350 bfd_size_type pc_count
;
353 /* s390 ELF linker hash entry. */
355 struct elf_s390_link_hash_entry
357 struct elf_link_hash_entry elf
;
359 /* Track dynamic relocs copied for this symbol. */
360 struct elf_s390_dyn_relocs
*dyn_relocs
;
363 /* s390 ELF linker hash table. */
365 struct elf_s390_link_hash_table
367 struct elf_link_hash_table elf
;
369 /* Short-cuts to get to dynamic linker sections. */
379 /* Get the s390 ELF linker hash table from a link_info structure. */
381 #define elf_s390_hash_table(p) \
382 ((struct elf_s390_link_hash_table *) ((p)->hash))
384 /* Create an entry in an s390 ELF linker hash table. */
386 static struct bfd_hash_entry
*
387 link_hash_newfunc (entry
, table
, string
)
388 struct bfd_hash_entry
*entry
;
389 struct bfd_hash_table
*table
;
392 /* Allocate the structure if it has not already been allocated by a
396 entry
= bfd_hash_allocate (table
,
397 sizeof (struct elf_s390_link_hash_entry
));
402 /* Call the allocation method of the superclass. */
403 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
406 struct elf_s390_link_hash_entry
*eh
;
408 eh
= (struct elf_s390_link_hash_entry
*) entry
;
409 eh
->dyn_relocs
= NULL
;
415 /* Create an s390 ELF linker hash table. */
417 static struct bfd_link_hash_table
*
418 elf_s390_link_hash_table_create (abfd
)
421 struct elf_s390_link_hash_table
*ret
;
422 bfd_size_type amt
= sizeof (struct elf_s390_link_hash_table
);
424 ret
= (struct elf_s390_link_hash_table
*) bfd_alloc (abfd
, amt
);
428 if (! _bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
))
430 bfd_release (abfd
, ret
);
442 return &ret
->elf
.root
;
445 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
446 shortcuts to them in our hash table. */
449 create_got_section (dynobj
, info
)
451 struct bfd_link_info
*info
;
453 struct elf_s390_link_hash_table
*htab
;
455 if (! _bfd_elf_create_got_section (dynobj
, info
))
458 htab
= elf_s390_hash_table (info
);
459 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
460 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
461 if (!htab
->sgot
|| !htab
->sgotplt
)
464 htab
->srelgot
= bfd_make_section (dynobj
, ".rela.got");
465 if (htab
->srelgot
== NULL
466 || ! bfd_set_section_flags (dynobj
, htab
->srelgot
,
467 (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
468 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
470 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
475 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
476 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
480 elf_s390_create_dynamic_sections (dynobj
, info
)
482 struct bfd_link_info
*info
;
484 struct elf_s390_link_hash_table
*htab
;
486 htab
= elf_s390_hash_table (info
);
487 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
490 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
493 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
494 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rela.plt");
495 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
497 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rela.bss");
499 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
500 || (!info
->shared
&& !htab
->srelbss
))
506 /* Copy the extra info we tack onto an elf_link_hash_entry. */
509 elf_s390_copy_indirect_symbol (dir
, ind
)
510 struct elf_link_hash_entry
*dir
, *ind
;
512 struct elf_s390_link_hash_entry
*edir
, *eind
;
514 edir
= (struct elf_s390_link_hash_entry
*) dir
;
515 eind
= (struct elf_s390_link_hash_entry
*) ind
;
517 if (eind
->dyn_relocs
!= NULL
)
519 if (edir
->dyn_relocs
!= NULL
)
521 struct elf_s390_dyn_relocs
**pp
;
522 struct elf_s390_dyn_relocs
*p
;
524 if (ind
->root
.type
== bfd_link_hash_indirect
)
527 /* Add reloc counts against the weak sym to the strong sym
528 list. Merge any entries against the same section. */
529 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
531 struct elf_s390_dyn_relocs
*q
;
533 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
534 if (q
->sec
== p
->sec
)
536 q
->pc_count
+= p
->pc_count
;
537 q
->count
+= p
->count
;
544 *pp
= edir
->dyn_relocs
;
547 edir
->dyn_relocs
= eind
->dyn_relocs
;
548 eind
->dyn_relocs
= NULL
;
551 _bfd_elf_link_hash_copy_indirect (dir
, ind
);
554 /* Look through the relocs for a section during the first phase, and
555 allocate space in the global offset table or procedure linkage
559 elf_s390_check_relocs (abfd
, info
, sec
, relocs
)
561 struct bfd_link_info
*info
;
563 const Elf_Internal_Rela
*relocs
;
565 struct elf_s390_link_hash_table
*htab
;
566 Elf_Internal_Shdr
*symtab_hdr
;
567 struct elf_link_hash_entry
**sym_hashes
;
568 const Elf_Internal_Rela
*rel
;
569 const Elf_Internal_Rela
*rel_end
;
572 if (info
->relocateable
)
575 htab
= elf_s390_hash_table (info
);
576 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
577 sym_hashes
= elf_sym_hashes (abfd
);
581 rel_end
= relocs
+ sec
->reloc_count
;
582 for (rel
= relocs
; rel
< rel_end
; rel
++)
584 unsigned long r_symndx
;
585 struct elf_link_hash_entry
*h
;
587 r_symndx
= ELF64_R_SYM (rel
->r_info
);
589 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
591 (*_bfd_error_handler
) (_("%s: bad symbol index: %d"),
592 bfd_archive_filename (abfd
),
597 if (r_symndx
< symtab_hdr
->sh_info
)
600 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
602 switch (ELF64_R_TYPE (rel
->r_info
))
609 /* This symbol requires a global offset table entry. */
612 h
->got
.refcount
+= 1;
616 bfd_signed_vma
*local_got_refcounts
;
618 /* This is a global offset table entry for a local symbol. */
619 local_got_refcounts
= elf_local_got_refcounts (abfd
);
620 if (local_got_refcounts
== NULL
)
624 size
= symtab_hdr
->sh_info
;
625 size
*= sizeof (bfd_signed_vma
);
626 local_got_refcounts
= ((bfd_signed_vma
*)
627 bfd_zalloc (abfd
, size
));
628 if (local_got_refcounts
== NULL
)
630 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
632 local_got_refcounts
[r_symndx
] += 1;
639 if (htab
->sgot
== NULL
)
641 if (htab
->elf
.dynobj
== NULL
)
642 htab
->elf
.dynobj
= abfd
;
643 if (!create_got_section (htab
->elf
.dynobj
, info
))
652 /* This symbol requires a procedure linkage table entry. We
653 actually build the entry in adjust_dynamic_symbol,
654 because this might be a case of linking PIC code which is
655 never referenced by a dynamic object, in which case we
656 don't need to generate a procedure linkage table entry
659 /* If this is a local symbol, we resolve it directly without
660 creating a procedure linkage table entry. */
664 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
665 h
->plt
.refcount
+= 1;
677 if (h
!= NULL
&& !info
->shared
)
679 /* If this reloc is in a read-only section, we might
680 need a copy reloc. We can't check reliably at this
681 stage whether the section is read-only, as input
682 sections have not yet been mapped to output sections.
683 Tentatively set the flag for now, and correct in
684 adjust_dynamic_symbol. */
685 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
687 /* We may need a .plt entry if the function this reloc
688 refers to is in a shared lib. */
689 h
->plt
.refcount
+= 1;
692 /* If we are creating a shared library, and this is a reloc
693 against a global symbol, or a non PC relative reloc
694 against a local symbol, then we need to copy the reloc
695 into the shared library. However, if we are linking with
696 -Bsymbolic, we do not need to copy a reloc against a
697 global symbol which is defined in an object we are
698 including in the link (i.e., DEF_REGULAR is set). At
699 this point we have not seen all the input files, so it is
700 possible that DEF_REGULAR is not set now but will be set
701 later (it is never cleared). In case of a weak definition,
702 DEF_REGULAR may be cleared later by a strong definition in
703 a shared library. We account for that possibility below by
704 storing information in the relocs_copied field of the hash
705 table entry. A similar situation occurs when creating
706 shared libraries and symbol visibility changes render the
709 If on the other hand, we are creating an executable, we
710 may need to keep relocations for symbols satisfied by a
711 dynamic library if we manage to avoid copy relocs for the
714 && (sec
->flags
& SEC_ALLOC
) != 0
715 && ((ELF64_R_TYPE (rel
->r_info
) != R_390_PC16
716 && ELF64_R_TYPE (rel
->r_info
) != R_390_PC16DBL
717 && ELF64_R_TYPE (rel
->r_info
) != R_390_PC32
718 && ELF64_R_TYPE (rel
->r_info
) != R_390_PC32DBL
719 && ELF64_R_TYPE (rel
->r_info
) != R_390_PC64
)
722 || h
->root
.type
== bfd_link_hash_defweak
723 || (h
->elf_link_hash_flags
724 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
726 && (sec
->flags
& SEC_ALLOC
) != 0
728 && (h
->root
.type
== bfd_link_hash_defweak
729 || (h
->elf_link_hash_flags
730 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
732 /* We must copy these reloc types into the output file.
733 Create a reloc section in dynobj and make room for
740 name
= (bfd_elf_string_from_elf_section
742 elf_elfheader (abfd
)->e_shstrndx
,
743 elf_section_data (sec
)->rel_hdr
.sh_name
));
747 if (strncmp (name
, ".rela", 5) != 0
748 || strcmp (bfd_get_section_name (abfd
, sec
),
751 (*_bfd_error_handler
)
752 (_("%s: bad relocation section name `%s\'"),
753 bfd_archive_filename (abfd
), name
);
756 if (htab
->elf
.dynobj
== NULL
)
757 htab
->elf
.dynobj
= abfd
;
759 dynobj
= htab
->elf
.dynobj
;
760 sreloc
= bfd_get_section_by_name (dynobj
, name
);
765 sreloc
= bfd_make_section (dynobj
, name
);
766 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
767 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
768 if ((sec
->flags
& SEC_ALLOC
) != 0)
769 flags
|= SEC_ALLOC
| SEC_LOAD
;
771 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
772 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
775 elf_section_data (sec
)->sreloc
= sreloc
;
778 /* If this is a global symbol, we count the number of
779 relocations we need for this symbol. */
782 struct elf_s390_link_hash_entry
*eh
;
783 struct elf_s390_dyn_relocs
*p
;
785 eh
= (struct elf_s390_link_hash_entry
*) h
;
788 if (p
== NULL
|| p
->sec
!= sec
)
790 bfd_size_type amt
= sizeof *p
;
791 p
= ((struct elf_s390_dyn_relocs
*)
792 bfd_alloc (htab
->elf
.dynobj
, amt
));
795 p
->next
= eh
->dyn_relocs
;
803 if (ELF64_R_TYPE (rel
->r_info
) == R_390_PC16
804 || ELF64_R_TYPE (rel
->r_info
) == R_390_PC16DBL
805 || ELF64_R_TYPE (rel
->r_info
) == R_390_PC32
806 || ELF64_R_TYPE (rel
->r_info
) == R_390_PC32DBL
807 || ELF64_R_TYPE (rel
->r_info
) == R_390_PC64
)
812 /* Track dynamic relocs needed for local syms too. */
813 elf_section_data (sec
)->local_dynrel
+= 1;
818 /* This relocation describes the C++ object vtable hierarchy.
819 Reconstruct it for later use during GC. */
820 case R_390_GNU_VTINHERIT
:
821 if (!_bfd_elf64_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
825 /* This relocation describes which C++ vtable entries are actually
826 used. Record for later use during GC. */
827 case R_390_GNU_VTENTRY
:
828 if (!_bfd_elf64_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
840 /* Return the section that should be marked against GC for a given
844 elf_s390_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
846 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
847 Elf_Internal_Rela
*rel
;
848 struct elf_link_hash_entry
*h
;
849 Elf_Internal_Sym
*sym
;
853 switch (ELF64_R_TYPE (rel
->r_info
))
855 case R_390_GNU_VTINHERIT
:
856 case R_390_GNU_VTENTRY
:
860 switch (h
->root
.type
)
862 case bfd_link_hash_defined
:
863 case bfd_link_hash_defweak
:
864 return h
->root
.u
.def
.section
;
866 case bfd_link_hash_common
:
867 return h
->root
.u
.c
.p
->section
;
876 if (!(elf_bad_symtab (abfd
)
877 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
878 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
879 && sym
->st_shndx
!= SHN_COMMON
))
881 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
888 /* Update the got entry reference counts for the section being removed. */
891 elf_s390_gc_sweep_hook (abfd
, info
, sec
, relocs
)
893 struct bfd_link_info
*info
;
895 const Elf_Internal_Rela
*relocs
;
897 Elf_Internal_Shdr
*symtab_hdr
;
898 struct elf_link_hash_entry
**sym_hashes
;
899 bfd_signed_vma
*local_got_refcounts
;
900 const Elf_Internal_Rela
*rel
, *relend
;
901 unsigned long r_symndx
;
902 struct elf_link_hash_entry
*h
;
905 elf_section_data (sec
)->local_dynrel
= 0;
907 dynobj
= elf_hash_table (info
)->dynobj
;
911 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
912 sym_hashes
= elf_sym_hashes (abfd
);
913 local_got_refcounts
= elf_local_got_refcounts (abfd
);
915 relend
= relocs
+ sec
->reloc_count
;
916 for (rel
= relocs
; rel
< relend
; rel
++)
917 switch (ELF64_R_TYPE (rel
->r_info
))
927 r_symndx
= ELF64_R_SYM (rel
->r_info
);
928 if (r_symndx
>= symtab_hdr
->sh_info
)
930 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
931 if (h
->got
.refcount
> 0)
932 h
->got
.refcount
-= 1;
934 else if (local_got_refcounts
!= NULL
)
936 if (local_got_refcounts
[r_symndx
] > 0)
937 local_got_refcounts
[r_symndx
] -= 1;
951 r_symndx
= ELF64_R_SYM (rel
->r_info
);
952 if (r_symndx
>= symtab_hdr
->sh_info
)
954 struct elf_s390_link_hash_entry
*eh
;
955 struct elf_s390_dyn_relocs
**pp
;
956 struct elf_s390_dyn_relocs
*p
;
958 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
960 if (!info
->shared
&& h
->plt
.refcount
> 0)
961 h
->plt
.refcount
-= 1;
963 eh
= (struct elf_s390_link_hash_entry
*) h
;
965 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
968 if (ELF64_R_TYPE (rel
->r_info
) == R_390_PC16
969 || ELF64_R_TYPE (rel
->r_info
) == R_390_PC16DBL
970 || ELF64_R_TYPE (rel
->r_info
) == R_390_PC32
)
984 r_symndx
= ELF64_R_SYM (rel
->r_info
);
985 if (r_symndx
>= symtab_hdr
->sh_info
)
987 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
988 if (h
->plt
.refcount
> 0)
989 h
->plt
.refcount
-= 1;
1000 /* Adjust a symbol defined by a dynamic object and referenced by a
1001 regular object. The current definition is in some section of the
1002 dynamic object, but we're not including those sections. We have to
1003 change the definition to something the rest of the link can
1007 elf_s390_adjust_dynamic_symbol (info
, h
)
1008 struct bfd_link_info
*info
;
1009 struct elf_link_hash_entry
*h
;
1011 struct elf_s390_link_hash_table
*htab
;
1012 struct elf_s390_link_hash_entry
* eh
;
1013 struct elf_s390_dyn_relocs
*p
;
1015 unsigned int power_of_two
;
1017 /* If this is a function, put it in the procedure linkage table. We
1018 will fill in the contents of the procedure linkage table later
1019 (although we could actually do it here). */
1020 if (h
->type
== STT_FUNC
1021 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
1023 if (h
->plt
.refcount
<= 0
1025 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1026 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0))
1028 /* This case can occur if we saw a PLT32 reloc in an input
1029 file, but the symbol was never referred to by a dynamic
1030 object, or if all references were garbage collected. In
1031 such a case, we don't actually need to build a procedure
1032 linkage table, and we can just do a PC32 reloc instead. */
1033 h
->plt
.offset
= (bfd_vma
) -1;
1034 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1040 /* It's possible that we incorrectly decided a .plt reloc was
1041 needed for an R_390_PC32 reloc to a non-function sym in
1042 check_relocs. We can't decide accurately between function and
1043 non-function syms in check-relocs; Objects loaded later in
1044 the link may change h->type. So fix it now. */
1045 h
->plt
.offset
= (bfd_vma
) -1;
1047 /* If this is a weak symbol, and there is a real definition, the
1048 processor independent code will have arranged for us to see the
1049 real definition first, and we can just use the same value. */
1050 if (h
->weakdef
!= NULL
)
1052 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
1053 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
1054 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
1055 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
1059 /* This is a reference to a symbol defined by a dynamic object which
1060 is not a function. */
1062 /* If we are creating a shared library, we must presume that the
1063 only references to the symbol are via the global offset table.
1064 For such cases we need not do anything here; the relocations will
1065 be handled correctly by relocate_section. */
1069 /* If there are no references to this symbol that do not use the
1070 GOT, we don't need to generate a copy reloc. */
1071 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
1074 /* If -z nocopyreloc was given, we won't generate them either. */
1075 if (info
->nocopyreloc
)
1077 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_GOT_REF
;
1081 eh
= (struct elf_s390_link_hash_entry
*) h
;
1082 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1084 s
= p
->sec
->output_section
;
1085 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1089 /* If we didn't find any dynamic relocs in read-only sections, then
1090 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1093 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_GOT_REF
;
1097 /* We must allocate the symbol in our .dynbss section, which will
1098 become part of the .bss section of the executable. There will be
1099 an entry for this symbol in the .dynsym section. The dynamic
1100 object will contain position independent code, so all references
1101 from the dynamic object to this symbol will go through the global
1102 offset table. The dynamic linker will use the .dynsym entry to
1103 determine the address it must put in the global offset table, so
1104 both the dynamic object and the regular object will refer to the
1105 same memory location for the variable. */
1107 htab
= elf_s390_hash_table (info
);
1109 /* We must generate a R_390_COPY reloc to tell the dynamic linker to
1110 copy the initial value out of the dynamic object and into the
1111 runtime process image. */
1112 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1114 htab
->srelbss
->_raw_size
+= sizeof (Elf64_External_Rela
);
1115 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
1118 /* We need to figure out the alignment required for this symbol. I
1119 have no idea how ELF linkers handle this. */
1120 power_of_two
= bfd_log2 (h
->size
);
1121 if (power_of_two
> 3)
1124 /* Apply the required alignment. */
1126 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
, (bfd_size_type
) (1 << power_of_two
));
1127 if (power_of_two
> bfd_get_section_alignment (htab
->elf
.dynobj
, s
))
1129 if (! bfd_set_section_alignment (htab
->elf
.dynobj
, s
, power_of_two
))
1133 /* Define the symbol as being at this point in the section. */
1134 h
->root
.u
.def
.section
= s
;
1135 h
->root
.u
.def
.value
= s
->_raw_size
;
1137 /* Increment the section size to make room for the symbol. */
1138 s
->_raw_size
+= h
->size
;
1143 /* This is the condition under which elf_s390_finish_dynamic_symbol
1144 will be called from elflink.h. If elflink.h doesn't call our
1145 finish_dynamic_symbol routine, we'll need to do something about
1146 initializing any .plt and .got entries in elf_s390_relocate_section. */
1147 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1149 && ((INFO)->shared \
1150 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1151 && ((H)->dynindx != -1 \
1152 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1154 /* Allocate space in .plt, .got and associated reloc sections for
1158 allocate_dynrelocs (h
, inf
)
1159 struct elf_link_hash_entry
*h
;
1162 struct bfd_link_info
*info
;
1163 struct elf_s390_link_hash_table
*htab
;
1164 struct elf_s390_link_hash_entry
*eh
;
1165 struct elf_s390_dyn_relocs
*p
;
1167 if (h
->root
.type
== bfd_link_hash_indirect
1168 || h
->root
.type
== bfd_link_hash_warning
)
1171 info
= (struct bfd_link_info
*) inf
;
1172 htab
= elf_s390_hash_table (info
);
1174 if (htab
->elf
.dynamic_sections_created
1175 && h
->plt
.refcount
> 0)
1177 /* Make sure this symbol is output as a dynamic symbol.
1178 Undefined weak syms won't yet be marked as dynamic. */
1179 if (h
->dynindx
== -1
1180 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1182 if (! bfd_elf64_link_record_dynamic_symbol (info
, h
))
1186 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
, h
))
1188 asection
*s
= htab
->splt
;
1190 /* If this is the first .plt entry, make room for the special
1192 if (s
->_raw_size
== 0)
1193 s
->_raw_size
+= PLT_FIRST_ENTRY_SIZE
;
1195 h
->plt
.offset
= s
->_raw_size
;
1197 /* If this symbol is not defined in a regular file, and we are
1198 not generating a shared library, then set the symbol to this
1199 location in the .plt. This is required to make function
1200 pointers compare as equal between the normal executable and
1201 the shared library. */
1203 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1205 h
->root
.u
.def
.section
= s
;
1206 h
->root
.u
.def
.value
= h
->plt
.offset
;
1209 /* Make room for this entry. */
1210 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1212 /* We also need to make an entry in the .got.plt section, which
1213 will be placed in the .got section by the linker script. */
1214 htab
->sgotplt
->_raw_size
+= GOT_ENTRY_SIZE
;
1216 /* We also need to make an entry in the .rela.plt section. */
1217 htab
->srelplt
->_raw_size
+= sizeof (Elf64_External_Rela
);
1221 h
->plt
.offset
= (bfd_vma
) -1;
1222 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1227 h
->plt
.offset
= (bfd_vma
) -1;
1228 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1231 if (h
->got
.refcount
> 0)
1236 /* Make sure this symbol is output as a dynamic symbol.
1237 Undefined weak syms won't yet be marked as dynamic. */
1238 if (h
->dynindx
== -1
1239 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1241 if (! bfd_elf64_link_record_dynamic_symbol (info
, h
))
1246 h
->got
.offset
= s
->_raw_size
;
1247 s
->_raw_size
+= GOT_ENTRY_SIZE
;
1248 dyn
= htab
->elf
.dynamic_sections_created
;
1249 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
))
1250 htab
->srelgot
->_raw_size
+= sizeof (Elf64_External_Rela
);
1253 h
->got
.offset
= (bfd_vma
) -1;
1255 eh
= (struct elf_s390_link_hash_entry
*) h
;
1256 if (eh
->dyn_relocs
== NULL
)
1259 /* In the shared -Bsymbolic case, discard space allocated for
1260 dynamic pc-relative relocs against symbols which turn out to be
1261 defined in regular objects. For the normal shared case, discard
1262 space for pc-relative relocs that have become local due to symbol
1263 visibility changes. */
1267 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1268 && ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0
1271 struct elf_s390_dyn_relocs
**pp
;
1273 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1275 p
->count
-= p
->pc_count
;
1286 /* For the non-shared case, discard space for relocs against
1287 symbols which turn out to need copy relocs or are not
1290 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1291 && (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1292 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1293 || (htab
->elf
.dynamic_sections_created
1294 && (h
->root
.type
== bfd_link_hash_undefweak
1295 || h
->root
.type
== bfd_link_hash_undefined
))))
1297 /* Make sure this symbol is output as a dynamic symbol.
1298 Undefined weak syms won't yet be marked as dynamic. */
1299 if (h
->dynindx
== -1
1300 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1302 if (! bfd_elf64_link_record_dynamic_symbol (info
, h
))
1306 /* If that succeeded, we know we'll be keeping all the
1308 if (h
->dynindx
!= -1)
1312 eh
->dyn_relocs
= NULL
;
1317 /* Finally, allocate space. */
1318 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1320 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1321 sreloc
->_raw_size
+= p
->count
* sizeof (Elf64_External_Rela
);
1327 /* Find any dynamic relocs that apply to read-only sections. */
1330 readonly_dynrelocs (h
, inf
)
1331 struct elf_link_hash_entry
*h
;
1334 struct elf_s390_link_hash_entry
*eh
;
1335 struct elf_s390_dyn_relocs
*p
;
1337 eh
= (struct elf_s390_link_hash_entry
*) h
;
1338 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1340 asection
*s
= p
->sec
->output_section
;
1342 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1344 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
1346 info
->flags
|= DF_TEXTREL
;
1348 /* Not an error, just cut short the traversal. */
1355 /* Set the sizes of the dynamic sections. */
1358 elf_s390_size_dynamic_sections (output_bfd
, info
)
1359 bfd
*output_bfd ATTRIBUTE_UNUSED
;
1360 struct bfd_link_info
*info
;
1362 struct elf_s390_link_hash_table
*htab
;
1368 htab
= elf_s390_hash_table (info
);
1369 dynobj
= htab
->elf
.dynobj
;
1373 if (htab
->elf
.dynamic_sections_created
)
1375 /* Set the contents of the .interp section to the interpreter. */
1378 s
= bfd_get_section_by_name (dynobj
, ".interp");
1381 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1382 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1386 /* Set up .got offsets for local syms, and space for local dynamic
1388 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
1390 bfd_signed_vma
*local_got
;
1391 bfd_signed_vma
*end_local_got
;
1392 bfd_size_type locsymcount
;
1393 Elf_Internal_Shdr
*symtab_hdr
;
1396 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
1399 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1401 bfd_size_type count
= elf_section_data (s
)->local_dynrel
;
1405 srela
= elf_section_data (s
)->sreloc
;
1406 srela
->_raw_size
+= count
* sizeof (Elf64_External_Rela
);
1410 local_got
= elf_local_got_refcounts (ibfd
);
1414 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1415 locsymcount
= symtab_hdr
->sh_info
;
1416 end_local_got
= local_got
+ locsymcount
;
1418 srela
= htab
->srelgot
;
1419 for (; local_got
< end_local_got
; ++local_got
)
1423 *local_got
= s
->_raw_size
;
1424 s
->_raw_size
+= GOT_ENTRY_SIZE
;
1426 srela
->_raw_size
+= sizeof (Elf64_External_Rela
);
1429 *local_got
= (bfd_vma
) -1;
1433 /* Allocate global sym .plt and .got entries, and space for global
1434 sym dynamic relocs. */
1435 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, (PTR
) info
);
1437 /* We now have determined the sizes of the various dynamic sections.
1438 Allocate memory for them. */
1440 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1442 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1447 || s
== htab
->sgotplt
)
1449 /* Strip this section if we don't need it; see the
1452 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rela", 5) == 0)
1454 if (s
->_raw_size
!= 0 && s
!= htab
->srelplt
)
1457 /* We use the reloc_count field as a counter if we need
1458 to copy relocs into the output file. */
1463 /* It's not one of our sections, so don't allocate space. */
1467 if (s
->_raw_size
== 0)
1469 /* If we don't need this section, strip it from the
1470 output file. This is to handle .rela.bss and
1471 .rela.plt. We must create it in
1472 create_dynamic_sections, because it must be created
1473 before the linker maps input sections to output
1474 sections. The linker does that before
1475 adjust_dynamic_symbol is called, and it is that
1476 function which decides whether anything needs to go
1477 into these sections. */
1479 _bfd_strip_section_from_output (info
, s
);
1483 /* Allocate memory for the section contents. We use bfd_zalloc
1484 here in case unused entries are not reclaimed before the
1485 section's contents are written out. This should not happen,
1486 but this way if it does, we get a R_390_NONE reloc instead
1488 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1489 if (s
->contents
== NULL
)
1493 if (htab
->elf
.dynamic_sections_created
)
1495 /* Add some entries to the .dynamic section. We fill in the
1496 values later, in elf_s390_finish_dynamic_sections, but we
1497 must add the entries now so that we get the correct size for
1498 the .dynamic section. The DT_DEBUG entry is filled in by the
1499 dynamic linker and used by the debugger. */
1500 #define add_dynamic_entry(TAG, VAL) \
1501 bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1505 if (!add_dynamic_entry (DT_DEBUG
, 0))
1509 if (htab
->splt
->_raw_size
!= 0)
1511 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1512 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1513 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1514 || !add_dynamic_entry (DT_JMPREL
, 0))
1520 if (!add_dynamic_entry (DT_RELA
, 0)
1521 || !add_dynamic_entry (DT_RELASZ
, 0)
1522 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf64_External_Rela
)))
1525 /* If any dynamic relocs apply to a read-only section,
1526 then we need a DT_TEXTREL entry. */
1527 elf_link_hash_traverse (&htab
->elf
, readonly_dynrelocs
, (PTR
) info
);
1529 if ((info
->flags
& DF_TEXTREL
) != 0)
1531 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1536 #undef add_dynamic_entry
1541 /* Relocate a 390 ELF section. */
1544 elf_s390_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1545 contents
, relocs
, local_syms
, local_sections
)
1547 struct bfd_link_info
*info
;
1549 asection
*input_section
;
1551 Elf_Internal_Rela
*relocs
;
1552 Elf_Internal_Sym
*local_syms
;
1553 asection
**local_sections
;
1555 struct elf_s390_link_hash_table
*htab
;
1556 Elf_Internal_Shdr
*symtab_hdr
;
1557 struct elf_link_hash_entry
**sym_hashes
;
1558 bfd_vma
*local_got_offsets
;
1559 Elf_Internal_Rela
*rel
;
1560 Elf_Internal_Rela
*relend
;
1562 htab
= elf_s390_hash_table (info
);
1563 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1564 sym_hashes
= elf_sym_hashes (input_bfd
);
1565 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1568 relend
= relocs
+ input_section
->reloc_count
;
1569 for (; rel
< relend
; rel
++)
1572 reloc_howto_type
*howto
;
1573 unsigned long r_symndx
;
1574 struct elf_link_hash_entry
*h
;
1575 Elf_Internal_Sym
*sym
;
1579 boolean unresolved_reloc
;
1580 bfd_reloc_status_type r
;
1582 r_type
= ELF64_R_TYPE (rel
->r_info
);
1583 if (r_type
== (int) R_390_GNU_VTINHERIT
1584 || r_type
== (int) R_390_GNU_VTENTRY
)
1586 if (r_type
< 0 || r_type
>= (int) R_390_max
)
1588 bfd_set_error (bfd_error_bad_value
);
1591 howto
= elf_howto_table
+ r_type
;
1593 r_symndx
= ELF64_R_SYM (rel
->r_info
);
1595 if (info
->relocateable
)
1597 /* This is a relocateable link. We don't have to change
1598 anything, unless the reloc is against a section symbol,
1599 in which case we have to adjust according to where the
1600 section symbol winds up in the output section. */
1601 if (r_symndx
< symtab_hdr
->sh_info
)
1603 sym
= local_syms
+ r_symndx
;
1604 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1606 sec
= local_sections
[r_symndx
];
1607 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1614 /* This is a final link. */
1618 unresolved_reloc
= false;
1619 if (r_symndx
< symtab_hdr
->sh_info
)
1621 sym
= local_syms
+ r_symndx
;
1622 sec
= local_sections
[r_symndx
];
1623 relocation
= (sec
->output_section
->vma
1624 + sec
->output_offset
1629 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1630 while (h
->root
.type
== bfd_link_hash_indirect
1631 || h
->root
.type
== bfd_link_hash_warning
)
1632 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1634 if (h
->root
.type
== bfd_link_hash_defined
1635 || h
->root
.type
== bfd_link_hash_defweak
)
1637 sec
= h
->root
.u
.def
.section
;
1638 if (r_type
== R_390_GOTPC
1639 || r_type
== R_390_GOTPCDBL
1640 || ((r_type
== R_390_PLT16DBL
1641 || r_type
== R_390_PLT32
1642 || r_type
== R_390_PLT32DBL
1643 || r_type
== R_390_PLT64
)
1644 && htab
->splt
!= NULL
1645 && h
->plt
.offset
!= (bfd_vma
) -1)
1646 || ((r_type
== R_390_GOT12
1647 || r_type
== R_390_GOT16
1648 || r_type
== R_390_GOT32
1649 || r_type
== R_390_GOT64
1650 || r_type
== R_390_GOTENT
)
1651 && elf_hash_table (info
)->dynamic_sections_created
1653 || (! info
->symbolic
&& h
->dynindx
!= -1)
1654 || (h
->elf_link_hash_flags
1655 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1657 && ((! info
->symbolic
&& h
->dynindx
!= -1)
1658 || (h
->elf_link_hash_flags
1659 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
1660 && (r_type
== R_390_8
1661 || r_type
== R_390_16
1662 || r_type
== R_390_32
1663 || r_type
== R_390_64
1664 || r_type
== R_390_PC16
1665 || r_type
== R_390_PC16DBL
1666 || r_type
== R_390_PC32
1667 || r_type
== R_390_PC32DBL
1668 || r_type
== R_390_PC64
)
1669 && ((input_section
->flags
& SEC_ALLOC
) != 0
1670 /* DWARF will emit R_390_32 relocations in its
1671 sections against symbols defined externally
1672 in shared libraries. We can't do anything
1674 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
1675 && (h
->elf_link_hash_flags
1676 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0))))
1678 /* In these cases, we don't need the relocation
1679 value. We check specially because in some
1680 obscure cases sec->output_section will be NULL. */
1683 else if (sec
->output_section
== NULL
)
1685 /* Set a flag that will be cleared later if we find a
1686 relocation value for this symbol. output_section
1687 is typically NULL for symbols satisfied by a shared
1689 unresolved_reloc
= true;
1693 relocation
= (h
->root
.u
.def
.value
1694 + sec
->output_section
->vma
1695 + sec
->output_offset
);
1697 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1699 else if (info
->shared
1700 && (!info
->symbolic
|| info
->allow_shlib_undefined
)
1701 && !info
->no_undefined
1702 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1706 if (! ((*info
->callbacks
->undefined_symbol
)
1707 (info
, h
->root
.root
.string
, input_bfd
,
1708 input_section
, rel
->r_offset
,
1709 (!info
->shared
|| info
->no_undefined
1710 || ELF_ST_VISIBILITY (h
->other
)))))
1723 /* Relocation is to the entry for this symbol in the global
1725 if (htab
->sgot
== NULL
)
1732 off
= h
->got
.offset
;
1733 dyn
= htab
->elf
.dynamic_sections_created
;
1734 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
)
1738 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
1739 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1741 /* This is actually a static link, or it is a
1742 -Bsymbolic link and the symbol is defined
1743 locally, or the symbol was forced to be local
1744 because of a version file. We must initialize
1745 this entry in the global offset table. Since the
1746 offset must always be a multiple of 2, we use the
1747 least significant bit to record whether we have
1748 initialized it already.
1750 When doing a dynamic link, we create a .rel.got
1751 relocation entry to initialize the value. This
1752 is done in the finish_dynamic_symbol routine. */
1757 bfd_put_64 (output_bfd
, relocation
,
1758 htab
->sgot
->contents
+ off
);
1763 unresolved_reloc
= false;
1767 if (local_got_offsets
== NULL
)
1770 off
= local_got_offsets
[r_symndx
];
1772 /* The offset must always be a multiple of 8. We use
1773 the least significant bit to record whether we have
1774 already generated the necessary reloc. */
1779 bfd_put_64 (output_bfd
, relocation
,
1780 htab
->sgot
->contents
+ off
);
1785 Elf_Internal_Rela outrel
;
1786 Elf64_External_Rela
*loc
;
1788 srelgot
= htab
->srelgot
;
1789 if (srelgot
== NULL
)
1792 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
1793 + htab
->sgot
->output_offset
1795 outrel
.r_info
= ELF64_R_INFO (0, R_390_RELATIVE
);
1796 outrel
.r_addend
= relocation
;
1797 loc
= (Elf64_External_Rela
*) srelgot
->contents
;
1798 loc
+= srelgot
->reloc_count
++;
1799 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
1802 local_got_offsets
[r_symndx
] |= 1;
1806 if (off
>= (bfd_vma
) -2)
1809 relocation
= htab
->sgot
->output_offset
+ off
;
1812 * For @GOTENT the relocation is against the offset between
1813 * the instruction and the symbols entry in the GOT and not
1814 * between the start of the GOT and the symbols entry. We
1815 * add the vma of the GOT to get the correct value.
1817 if (r_type
== R_390_GOTENT
)
1818 relocation
+= htab
->sgot
->output_section
->vma
;
1823 /* Relocation is relative to the start of the global offset
1826 /* Note that sgot->output_offset is not involved in this
1827 calculation. We always want the start of .got. If we
1828 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1829 permitted by the ABI, we might have to change this
1831 relocation
-= htab
->sgot
->output_section
->vma
;
1836 case R_390_GOTPCDBL
:
1837 /* Use global offset table as symbol value. */
1838 relocation
= htab
->sgot
->output_section
->vma
;
1839 unresolved_reloc
= false;
1842 case R_390_PLT16DBL
:
1844 case R_390_PLT32DBL
:
1846 /* Relocation is to the entry for this symbol in the
1847 procedure linkage table. */
1849 /* Resolve a PLT32 reloc against a local symbol directly,
1850 without using the procedure linkage table. */
1854 if (h
->plt
.offset
== (bfd_vma
) -1
1855 || htab
->splt
== NULL
)
1857 /* We didn't make a PLT entry for this symbol. This
1858 happens when statically linking PIC code, or when
1859 using -Bsymbolic. */
1863 relocation
= (htab
->splt
->output_section
->vma
1864 + htab
->splt
->output_offset
1866 unresolved_reloc
= false;
1879 && (input_section
->flags
& SEC_ALLOC
) != 0
1880 && ((r_type
!= R_390_PC16
1881 && r_type
!= R_390_PC16DBL
1882 && r_type
!= R_390_PC32
1883 && r_type
!= R_390_PC32DBL
1884 && r_type
!= R_390_PC64
)
1887 && (! info
->symbolic
1888 || (h
->elf_link_hash_flags
1889 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1891 && (input_section
->flags
& SEC_ALLOC
) != 0
1894 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1895 && (((h
->elf_link_hash_flags
1896 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1897 && (h
->elf_link_hash_flags
1898 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
1899 || h
->root
.type
== bfd_link_hash_undefweak
1900 || h
->root
.type
== bfd_link_hash_undefined
)))
1902 Elf_Internal_Rela outrel
;
1903 boolean skip
, relocate
;
1905 Elf64_External_Rela
*loc
;
1907 /* When generating a shared object, these relocations
1908 are copied into the output file to be resolved at run
1913 if (elf_section_data (input_section
)->stab_info
== NULL
)
1914 outrel
.r_offset
= rel
->r_offset
;
1917 off
= (_bfd_stab_section_offset
1918 (output_bfd
, htab
->elf
.stab_info
, input_section
,
1919 &elf_section_data (input_section
)->stab_info
,
1921 if (off
== (bfd_vma
) -1)
1923 outrel
.r_offset
= off
;
1926 outrel
.r_offset
+= (input_section
->output_section
->vma
1927 + input_section
->output_offset
);
1931 memset (&outrel
, 0, sizeof outrel
);
1936 && (r_type
== R_390_PC16
1937 || r_type
== R_390_PC16DBL
1938 || r_type
== R_390_PC32
1939 || r_type
== R_390_PC32DBL
1940 || r_type
== R_390_PC64
1943 || (h
->elf_link_hash_flags
1944 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1947 outrel
.r_info
= ELF64_R_INFO (h
->dynindx
, r_type
);
1948 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1952 /* This symbol is local, or marked to become local. */
1954 outrel
.r_info
= ELF64_R_INFO (0, R_390_RELATIVE
);
1955 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1958 sreloc
= elf_section_data (input_section
)->sreloc
;
1962 loc
= (Elf64_External_Rela
*) sreloc
->contents
;
1963 loc
+= sreloc
->reloc_count
++;
1964 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
1966 /* If this reloc is against an external symbol, we do
1967 not want to fiddle with the addend. Otherwise, we
1968 need to include the symbol value so that it becomes
1969 an addend for the dynamic reloc. */
1980 if (unresolved_reloc
1982 && (input_section
->flags
& SEC_DEBUGGING
) != 0
1983 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
1984 (*_bfd_error_handler
)
1985 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
1986 bfd_archive_filename (input_bfd
),
1987 bfd_get_section_name (input_bfd
, input_section
),
1988 (long) rel
->r_offset
,
1989 h
->root
.root
.string
);
1991 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1992 contents
, rel
->r_offset
,
1993 relocation
, rel
->r_addend
);
1995 if (r
!= bfd_reloc_ok
)
2000 name
= h
->root
.root
.string
;
2003 name
= bfd_elf_string_from_elf_section (input_bfd
,
2004 symtab_hdr
->sh_link
,
2009 name
= bfd_section_name (input_bfd
, sec
);
2012 if (r
== bfd_reloc_overflow
)
2015 if (! ((*info
->callbacks
->reloc_overflow
)
2016 (info
, name
, howto
->name
, (bfd_vma
) 0,
2017 input_bfd
, input_section
, rel
->r_offset
)))
2022 (*_bfd_error_handler
)
2023 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
2024 bfd_archive_filename (input_bfd
),
2025 bfd_get_section_name (input_bfd
, input_section
),
2026 (long) rel
->r_offset
, name
, (int) r
);
2035 /* Finish up dynamic symbol handling. We set the contents of various
2036 dynamic sections here. */
2039 elf_s390_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
2041 struct bfd_link_info
*info
;
2042 struct elf_link_hash_entry
*h
;
2043 Elf_Internal_Sym
*sym
;
2045 struct elf_s390_link_hash_table
*htab
;
2047 htab
= elf_s390_hash_table (info
);
2049 if (h
->plt
.offset
!= (bfd_vma
) -1)
2053 Elf_Internal_Rela rela
;
2054 Elf64_External_Rela
*loc
;
2056 /* This symbol has an entry in the procedure linkage table. Set
2059 if (h
->dynindx
== -1
2060 || htab
->splt
== NULL
2061 || htab
->sgotplt
== NULL
2062 || htab
->srelplt
== NULL
)
2066 Current offset - size first entry / entry size. */
2067 plt_index
= (h
->plt
.offset
- PLT_FIRST_ENTRY_SIZE
) / PLT_ENTRY_SIZE
;
2069 /* Offset in GOT is PLT index plus GOT headers(3) times 8,
2071 got_offset
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
2073 /* Fill in the blueprint of a PLT. */
2074 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD0
,
2075 htab
->splt
->contents
+ h
->plt
.offset
);
2076 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD1
,
2077 htab
->splt
->contents
+ h
->plt
.offset
+ 4);
2078 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD2
,
2079 htab
->splt
->contents
+ h
->plt
.offset
+ 8);
2080 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD3
,
2081 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
2082 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD4
,
2083 htab
->splt
->contents
+ h
->plt
.offset
+ 16);
2084 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD5
,
2085 htab
->splt
->contents
+ h
->plt
.offset
+ 20);
2086 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD6
,
2087 htab
->splt
->contents
+ h
->plt
.offset
+ 24);
2088 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD7
,
2089 htab
->splt
->contents
+ h
->plt
.offset
+ 28);
2090 /* Fixup the relative address to the GOT entry */
2091 bfd_put_32 (output_bfd
,
2092 (htab
->sgotplt
->output_section
->vma
+
2093 htab
->sgotplt
->output_offset
+ got_offset
2094 - (htab
->splt
->output_section
->vma
+ h
->plt
.offset
))/2,
2095 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
2096 /* Fixup the relative branch to PLT 0 */
2097 bfd_put_32 (output_bfd
, - (PLT_FIRST_ENTRY_SIZE
+
2098 (PLT_ENTRY_SIZE
* plt_index
) + 22)/2,
2099 htab
->splt
->contents
+ h
->plt
.offset
+ 24);
2100 /* Fixup offset into symbol table */
2101 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf64_External_Rela
),
2102 htab
->splt
->contents
+ h
->plt
.offset
+ 28);
2104 /* Fill in the entry in the global offset table.
2105 Points to instruction after GOT offset. */
2106 bfd_put_64 (output_bfd
,
2107 (htab
->splt
->output_section
->vma
2108 + htab
->splt
->output_offset
2111 htab
->sgotplt
->contents
+ got_offset
);
2113 /* Fill in the entry in the .rela.plt section. */
2114 rela
.r_offset
= (htab
->sgotplt
->output_section
->vma
2115 + htab
->sgotplt
->output_offset
2117 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_390_JMP_SLOT
);
2119 loc
= (Elf64_External_Rela
*) htab
->srelplt
->contents
+ plt_index
;
2120 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
2122 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2124 /* Mark the symbol as undefined, rather than as defined in
2125 the .plt section. Leave the value alone. This is a clue
2126 for the dynamic linker, to make function pointer
2127 comparisons work between an application and shared
2129 sym
->st_shndx
= SHN_UNDEF
;
2133 if (h
->got
.offset
!= (bfd_vma
) -1)
2135 Elf_Internal_Rela rela
;
2136 Elf64_External_Rela
*loc
;
2138 /* This symbol has an entry in the global offset table. Set it
2141 if (htab
->sgot
== NULL
|| htab
->srelgot
== NULL
)
2144 rela
.r_offset
= (htab
->sgot
->output_section
->vma
2145 + htab
->sgot
->output_offset
2146 + (h
->got
.offset
&~ (bfd_vma
) 1));
2148 /* If this is a static link, or it is a -Bsymbolic link and the
2149 symbol is defined locally or was forced to be local because
2150 of a version file, we just want to emit a RELATIVE reloc.
2151 The entry in the global offset table will already have been
2152 initialized in the relocate_section function. */
2156 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
2157 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
2159 BFD_ASSERT((h
->got
.offset
& 1) != 0);
2160 rela
.r_info
= ELF64_R_INFO (0, R_390_RELATIVE
);
2161 rela
.r_addend
= (h
->root
.u
.def
.value
2162 + h
->root
.u
.def
.section
->output_section
->vma
2163 + h
->root
.u
.def
.section
->output_offset
);
2167 BFD_ASSERT((h
->got
.offset
& 1) == 0);
2168 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->sgot
->contents
+ h
->got
.offset
);
2169 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_390_GLOB_DAT
);
2173 loc
= (Elf64_External_Rela
*) htab
->srelgot
->contents
;
2174 loc
+= htab
->srelgot
->reloc_count
++;
2175 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
2178 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
2180 Elf_Internal_Rela rela
;
2181 Elf64_External_Rela
*loc
;
2183 /* This symbols needs a copy reloc. Set it up. */
2185 if (h
->dynindx
== -1
2186 || (h
->root
.type
!= bfd_link_hash_defined
2187 && h
->root
.type
!= bfd_link_hash_defweak
)
2188 || htab
->srelbss
== NULL
)
2191 rela
.r_offset
= (h
->root
.u
.def
.value
2192 + h
->root
.u
.def
.section
->output_section
->vma
2193 + h
->root
.u
.def
.section
->output_offset
);
2194 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_390_COPY
);
2196 loc
= (Elf64_External_Rela
*) htab
->srelbss
->contents
;
2197 loc
+= htab
->srelbss
->reloc_count
++;
2198 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
2201 /* Mark some specially defined symbols as absolute. */
2202 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2203 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
2204 || strcmp (h
->root
.root
.string
, "_PROCEDURE_LINKAGE_TABLE_") == 0)
2205 sym
->st_shndx
= SHN_ABS
;
2210 /* Used to decide how to sort relocs in an optimal manner for the
2211 dynamic linker, before writing them out. */
2213 static enum elf_reloc_type_class
2214 elf_s390_reloc_type_class (rela
)
2215 const Elf_Internal_Rela
*rela
;
2217 switch ((int) ELF64_R_TYPE (rela
->r_info
))
2219 case R_390_RELATIVE
:
2220 return reloc_class_relative
;
2221 case R_390_JMP_SLOT
:
2222 return reloc_class_plt
;
2224 return reloc_class_copy
;
2226 return reloc_class_normal
;
2230 /* Finish up the dynamic sections. */
2233 elf_s390_finish_dynamic_sections (output_bfd
, info
)
2235 struct bfd_link_info
*info
;
2237 struct elf_s390_link_hash_table
*htab
;
2241 htab
= elf_s390_hash_table (info
);
2242 dynobj
= htab
->elf
.dynobj
;
2243 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2245 if (htab
->elf
.dynamic_sections_created
)
2247 Elf64_External_Dyn
*dyncon
, *dynconend
;
2249 if (sdyn
== NULL
|| htab
->sgot
== NULL
)
2252 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
2253 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
2254 for (; dyncon
< dynconend
; dyncon
++)
2256 Elf_Internal_Dyn dyn
;
2259 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2267 dyn
.d_un
.d_ptr
= htab
->sgot
->output_section
->vma
;
2271 dyn
.d_un
.d_ptr
= htab
->srelplt
->output_section
->vma
;
2275 s
= htab
->srelplt
->output_section
;
2276 if (s
->_cooked_size
!= 0)
2277 dyn
.d_un
.d_val
= s
->_cooked_size
;
2279 dyn
.d_un
.d_val
= s
->_raw_size
;
2283 /* The procedure linkage table relocs (DT_JMPREL) should
2284 not be included in the overall relocs (DT_RELA).
2285 Therefore, we override the DT_RELASZ entry here to
2286 make it not include the JMPREL relocs. Since the
2287 linker script arranges for .rela.plt to follow all
2288 other relocation sections, we don't have to worry
2289 about changing the DT_RELA entry. */
2290 s
= htab
->srelplt
->output_section
;
2291 if (s
->_cooked_size
!= 0)
2292 dyn
.d_un
.d_val
-= s
->_cooked_size
;
2294 dyn
.d_un
.d_val
-= s
->_raw_size
;
2298 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2301 /* Fill in the special first entry in the procedure linkage table. */
2302 if (htab
->splt
&& htab
->splt
->_raw_size
> 0)
2304 /* fill in blueprint for plt 0 entry */
2305 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD0
,
2306 htab
->splt
->contents
);
2307 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD1
,
2308 htab
->splt
->contents
+4 );
2309 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD3
,
2310 htab
->splt
->contents
+12 );
2311 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD4
,
2312 htab
->splt
->contents
+16 );
2313 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD5
,
2314 htab
->splt
->contents
+20 );
2315 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD6
,
2316 htab
->splt
->contents
+ 24);
2317 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD7
,
2318 htab
->splt
->contents
+ 28 );
2319 /* Fixup relative address to start of GOT */
2320 bfd_put_32 (output_bfd
,
2321 (htab
->sgotplt
->output_section
->vma
+
2322 htab
->sgotplt
->output_offset
2323 - htab
->splt
->output_section
->vma
- 6)/2,
2324 htab
->splt
->contents
+ 8);
2326 elf_section_data (htab
->splt
->output_section
)
2327 ->this_hdr
.sh_entsize
= PLT_ENTRY_SIZE
;
2332 /* Fill in the first three entries in the global offset table. */
2333 if (htab
->sgotplt
->_raw_size
> 0)
2335 bfd_put_64 (output_bfd
,
2336 (sdyn
== NULL
? (bfd_vma
) 0
2337 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
2338 htab
->sgotplt
->contents
);
2339 /* One entry for shared object struct ptr. */
2340 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 8);
2341 /* One entry for _dl_runtime_resolve. */
2342 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 12);
2345 elf_section_data (htab
->sgot
->output_section
)
2346 ->this_hdr
.sh_entsize
= 8;
2352 elf_s390_object_p (abfd
)
2355 return bfd_default_set_arch_mach (abfd
, bfd_arch_s390
, bfd_mach_s390_esame
);
2359 * Why was the hash table entry size definition changed from
2360 * ARCH_SIZE/8 to 4? This breaks the 64 bit dynamic linker and
2361 * this is the only reason for the s390_elf64_size_info structure.
2364 const struct elf_size_info s390_elf64_size_info
=
2366 sizeof (Elf64_External_Ehdr
),
2367 sizeof (Elf64_External_Phdr
),
2368 sizeof (Elf64_External_Shdr
),
2369 sizeof (Elf64_External_Rel
),
2370 sizeof (Elf64_External_Rela
),
2371 sizeof (Elf64_External_Sym
),
2372 sizeof (Elf64_External_Dyn
),
2373 sizeof (Elf_External_Note
),
2374 8, /* hash-table entry size */
2375 1, /* internal relocations per external relocations */
2378 ELFCLASS64
, EV_CURRENT
,
2379 bfd_elf64_write_out_phdrs
,
2380 bfd_elf64_write_shdrs_and_ehdr
,
2381 bfd_elf64_write_relocs
,
2382 bfd_elf64_swap_symbol_out
,
2383 bfd_elf64_slurp_reloc_table
,
2384 bfd_elf64_slurp_symbol_table
,
2385 bfd_elf64_swap_dyn_in
,
2386 bfd_elf64_swap_dyn_out
,
2393 #define TARGET_BIG_SYM bfd_elf64_s390_vec
2394 #define TARGET_BIG_NAME "elf64-s390"
2395 #define ELF_ARCH bfd_arch_s390
2396 #define ELF_MACHINE_CODE EM_S390
2397 #define ELF_MACHINE_ALT1 EM_S390_OLD
2398 #define ELF_MAXPAGESIZE 0x1000
2400 #define elf_backend_size_info s390_elf64_size_info
2402 #define elf_backend_can_gc_sections 1
2403 #define elf_backend_can_refcount 1
2404 #define elf_backend_want_got_plt 1
2405 #define elf_backend_plt_readonly 1
2406 #define elf_backend_want_plt_sym 0
2407 #define elf_backend_got_header_size 24
2408 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
2410 #define elf_info_to_howto elf_s390_info_to_howto
2412 #define bfd_elf64_bfd_is_local_label_name elf_s390_is_local_label_name
2413 #define bfd_elf64_bfd_link_hash_table_create elf_s390_link_hash_table_create
2414 #define bfd_elf64_bfd_reloc_type_lookup elf_s390_reloc_type_lookup
2416 #define elf_backend_adjust_dynamic_symbol elf_s390_adjust_dynamic_symbol
2417 #define elf_backend_check_relocs elf_s390_check_relocs
2418 #define elf_backend_copy_indirect_symbol elf_s390_copy_indirect_symbol
2419 #define elf_backend_create_dynamic_sections elf_s390_create_dynamic_sections
2420 #define elf_backend_finish_dynamic_sections elf_s390_finish_dynamic_sections
2421 #define elf_backend_finish_dynamic_symbol elf_s390_finish_dynamic_symbol
2422 #define elf_backend_gc_mark_hook elf_s390_gc_mark_hook
2423 #define elf_backend_gc_sweep_hook elf_s390_gc_sweep_hook
2424 #define elf_backend_reloc_type_class elf_s390_reloc_type_class
2425 #define elf_backend_relocate_section elf_s390_relocate_section
2426 #define elf_backend_size_dynamic_sections elf_s390_size_dynamic_sections
2427 #define elf_backend_reloc_type_class elf_s390_reloc_type_class
2429 #define elf_backend_object_p elf_s390_object_p
2431 #include "elf64-target.h"