1 /* IBM S/390-specific support for 64-bit ELF
2 Copyright 2000, 2001, 2002 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. */
378 /* Small local sym to section mapping cache. */
379 struct sym_sec_cache sym_sec
;
382 /* Get the s390 ELF linker hash table from a link_info structure. */
384 #define elf_s390_hash_table(p) \
385 ((struct elf_s390_link_hash_table *) ((p)->hash))
387 /* Create an entry in an s390 ELF linker hash table. */
389 static struct bfd_hash_entry
*
390 link_hash_newfunc (entry
, table
, string
)
391 struct bfd_hash_entry
*entry
;
392 struct bfd_hash_table
*table
;
395 /* Allocate the structure if it has not already been allocated by a
399 entry
= bfd_hash_allocate (table
,
400 sizeof (struct elf_s390_link_hash_entry
));
405 /* Call the allocation method of the superclass. */
406 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
409 struct elf_s390_link_hash_entry
*eh
;
411 eh
= (struct elf_s390_link_hash_entry
*) entry
;
412 eh
->dyn_relocs
= NULL
;
418 /* Create an s390 ELF linker hash table. */
420 static struct bfd_link_hash_table
*
421 elf_s390_link_hash_table_create (abfd
)
424 struct elf_s390_link_hash_table
*ret
;
425 bfd_size_type amt
= sizeof (struct elf_s390_link_hash_table
);
427 ret
= (struct elf_s390_link_hash_table
*) bfd_alloc (abfd
, amt
);
431 if (! _bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
))
433 bfd_release (abfd
, ret
);
444 ret
->sym_sec
.abfd
= NULL
;
446 return &ret
->elf
.root
;
449 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
450 shortcuts to them in our hash table. */
453 create_got_section (dynobj
, info
)
455 struct bfd_link_info
*info
;
457 struct elf_s390_link_hash_table
*htab
;
459 if (! _bfd_elf_create_got_section (dynobj
, info
))
462 htab
= elf_s390_hash_table (info
);
463 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
464 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
465 if (!htab
->sgot
|| !htab
->sgotplt
)
468 htab
->srelgot
= bfd_make_section (dynobj
, ".rela.got");
469 if (htab
->srelgot
== NULL
470 || ! bfd_set_section_flags (dynobj
, htab
->srelgot
,
471 (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
472 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
474 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
479 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
480 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
484 elf_s390_create_dynamic_sections (dynobj
, info
)
486 struct bfd_link_info
*info
;
488 struct elf_s390_link_hash_table
*htab
;
490 htab
= elf_s390_hash_table (info
);
491 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
494 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
497 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
498 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rela.plt");
499 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
501 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rela.bss");
503 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
504 || (!info
->shared
&& !htab
->srelbss
))
510 /* Copy the extra info we tack onto an elf_link_hash_entry. */
513 elf_s390_copy_indirect_symbol (dir
, ind
)
514 struct elf_link_hash_entry
*dir
, *ind
;
516 struct elf_s390_link_hash_entry
*edir
, *eind
;
518 edir
= (struct elf_s390_link_hash_entry
*) dir
;
519 eind
= (struct elf_s390_link_hash_entry
*) ind
;
521 if (eind
->dyn_relocs
!= NULL
)
523 if (edir
->dyn_relocs
!= NULL
)
525 struct elf_s390_dyn_relocs
**pp
;
526 struct elf_s390_dyn_relocs
*p
;
528 if (ind
->root
.type
== bfd_link_hash_indirect
)
531 /* Add reloc counts against the weak sym to the strong sym
532 list. Merge any entries against the same section. */
533 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
535 struct elf_s390_dyn_relocs
*q
;
537 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
538 if (q
->sec
== p
->sec
)
540 q
->pc_count
+= p
->pc_count
;
541 q
->count
+= p
->count
;
548 *pp
= edir
->dyn_relocs
;
551 edir
->dyn_relocs
= eind
->dyn_relocs
;
552 eind
->dyn_relocs
= NULL
;
555 _bfd_elf_link_hash_copy_indirect (dir
, ind
);
558 /* Look through the relocs for a section during the first phase, and
559 allocate space in the global offset table or procedure linkage
563 elf_s390_check_relocs (abfd
, info
, sec
, relocs
)
565 struct bfd_link_info
*info
;
567 const Elf_Internal_Rela
*relocs
;
569 struct elf_s390_link_hash_table
*htab
;
570 Elf_Internal_Shdr
*symtab_hdr
;
571 struct elf_link_hash_entry
**sym_hashes
;
572 const Elf_Internal_Rela
*rel
;
573 const Elf_Internal_Rela
*rel_end
;
576 if (info
->relocateable
)
579 htab
= elf_s390_hash_table (info
);
580 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
581 sym_hashes
= elf_sym_hashes (abfd
);
585 rel_end
= relocs
+ sec
->reloc_count
;
586 for (rel
= relocs
; rel
< rel_end
; rel
++)
588 unsigned long r_symndx
;
589 struct elf_link_hash_entry
*h
;
591 r_symndx
= ELF64_R_SYM (rel
->r_info
);
593 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
595 (*_bfd_error_handler
) (_("%s: bad symbol index: %d"),
596 bfd_archive_filename (abfd
),
601 if (r_symndx
< symtab_hdr
->sh_info
)
604 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
606 switch (ELF64_R_TYPE (rel
->r_info
))
613 /* This symbol requires a global offset table entry. */
616 h
->got
.refcount
+= 1;
620 bfd_signed_vma
*local_got_refcounts
;
622 /* This is a global offset table entry for a local symbol. */
623 local_got_refcounts
= elf_local_got_refcounts (abfd
);
624 if (local_got_refcounts
== NULL
)
628 size
= symtab_hdr
->sh_info
;
629 size
*= sizeof (bfd_signed_vma
);
630 local_got_refcounts
= ((bfd_signed_vma
*)
631 bfd_zalloc (abfd
, size
));
632 if (local_got_refcounts
== NULL
)
634 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
636 local_got_refcounts
[r_symndx
] += 1;
643 if (htab
->sgot
== NULL
)
645 if (htab
->elf
.dynobj
== NULL
)
646 htab
->elf
.dynobj
= abfd
;
647 if (!create_got_section (htab
->elf
.dynobj
, info
))
656 /* This symbol requires a procedure linkage table entry. We
657 actually build the entry in adjust_dynamic_symbol,
658 because this might be a case of linking PIC code which is
659 never referenced by a dynamic object, in which case we
660 don't need to generate a procedure linkage table entry
663 /* If this is a local symbol, we resolve it directly without
664 creating a procedure linkage table entry. */
668 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
669 h
->plt
.refcount
+= 1;
681 if (h
!= NULL
&& !info
->shared
)
683 /* If this reloc is in a read-only section, we might
684 need a copy reloc. We can't check reliably at this
685 stage whether the section is read-only, as input
686 sections have not yet been mapped to output sections.
687 Tentatively set the flag for now, and correct in
688 adjust_dynamic_symbol. */
689 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
691 /* We may need a .plt entry if the function this reloc
692 refers to is in a shared lib. */
693 h
->plt
.refcount
+= 1;
696 /* If we are creating a shared library, and this is a reloc
697 against a global symbol, or a non PC relative reloc
698 against a local symbol, then we need to copy the reloc
699 into the shared library. However, if we are linking with
700 -Bsymbolic, we do not need to copy a reloc against a
701 global symbol which is defined in an object we are
702 including in the link (i.e., DEF_REGULAR is set). At
703 this point we have not seen all the input files, so it is
704 possible that DEF_REGULAR is not set now but will be set
705 later (it is never cleared). In case of a weak definition,
706 DEF_REGULAR may be cleared later by a strong definition in
707 a shared library. We account for that possibility below by
708 storing information in the relocs_copied field of the hash
709 table entry. A similar situation occurs when creating
710 shared libraries and symbol visibility changes render the
713 If on the other hand, we are creating an executable, we
714 may need to keep relocations for symbols satisfied by a
715 dynamic library if we manage to avoid copy relocs for the
718 && (sec
->flags
& SEC_ALLOC
) != 0
719 && ((ELF64_R_TYPE (rel
->r_info
) != R_390_PC16
720 && ELF64_R_TYPE (rel
->r_info
) != R_390_PC16DBL
721 && ELF64_R_TYPE (rel
->r_info
) != R_390_PC32
722 && ELF64_R_TYPE (rel
->r_info
) != R_390_PC32DBL
723 && ELF64_R_TYPE (rel
->r_info
) != R_390_PC64
)
726 || h
->root
.type
== bfd_link_hash_defweak
727 || (h
->elf_link_hash_flags
728 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
730 && (sec
->flags
& SEC_ALLOC
) != 0
732 && (h
->root
.type
== bfd_link_hash_defweak
733 || (h
->elf_link_hash_flags
734 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
736 struct elf_s390_dyn_relocs
*p
;
737 struct elf_s390_dyn_relocs
**head
;
739 /* We must copy these reloc types into the output file.
740 Create a reloc section in dynobj and make room for
747 name
= (bfd_elf_string_from_elf_section
749 elf_elfheader (abfd
)->e_shstrndx
,
750 elf_section_data (sec
)->rel_hdr
.sh_name
));
754 if (strncmp (name
, ".rela", 5) != 0
755 || strcmp (bfd_get_section_name (abfd
, sec
),
758 (*_bfd_error_handler
)
759 (_("%s: bad relocation section name `%s\'"),
760 bfd_archive_filename (abfd
), name
);
763 if (htab
->elf
.dynobj
== NULL
)
764 htab
->elf
.dynobj
= abfd
;
766 dynobj
= htab
->elf
.dynobj
;
767 sreloc
= bfd_get_section_by_name (dynobj
, name
);
772 sreloc
= bfd_make_section (dynobj
, name
);
773 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
774 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
775 if ((sec
->flags
& SEC_ALLOC
) != 0)
776 flags
|= SEC_ALLOC
| SEC_LOAD
;
778 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
779 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
782 elf_section_data (sec
)->sreloc
= sreloc
;
785 /* If this is a global symbol, we count the number of
786 relocations we need for this symbol. */
789 head
= &((struct elf_s390_link_hash_entry
*) h
)->dyn_relocs
;
793 /* Track dynamic relocs needed for local syms too.
794 We really need local syms available to do this
798 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
803 head
= ((struct elf_s390_dyn_relocs
**)
804 &elf_section_data (s
)->local_dynrel
);
808 if (p
== NULL
|| p
->sec
!= sec
)
810 bfd_size_type amt
= sizeof *p
;
811 p
= ((struct elf_s390_dyn_relocs
*)
812 bfd_alloc (htab
->elf
.dynobj
, amt
));
823 if (ELF64_R_TYPE (rel
->r_info
) == R_390_PC16
824 || ELF64_R_TYPE (rel
->r_info
) == R_390_PC16DBL
825 || ELF64_R_TYPE (rel
->r_info
) == R_390_PC32
826 || ELF64_R_TYPE (rel
->r_info
) == R_390_PC32DBL
827 || ELF64_R_TYPE (rel
->r_info
) == R_390_PC64
)
832 /* This relocation describes the C++ object vtable hierarchy.
833 Reconstruct it for later use during GC. */
834 case R_390_GNU_VTINHERIT
:
835 if (!_bfd_elf64_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
839 /* This relocation describes which C++ vtable entries are actually
840 used. Record for later use during GC. */
841 case R_390_GNU_VTENTRY
:
842 if (!_bfd_elf64_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
854 /* Return the section that should be marked against GC for a given
858 elf_s390_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
860 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
861 Elf_Internal_Rela
*rel
;
862 struct elf_link_hash_entry
*h
;
863 Elf_Internal_Sym
*sym
;
867 switch (ELF64_R_TYPE (rel
->r_info
))
869 case R_390_GNU_VTINHERIT
:
870 case R_390_GNU_VTENTRY
:
874 switch (h
->root
.type
)
876 case bfd_link_hash_defined
:
877 case bfd_link_hash_defweak
:
878 return h
->root
.u
.def
.section
;
880 case bfd_link_hash_common
:
881 return h
->root
.u
.c
.p
->section
;
890 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
896 /* Update the got entry reference counts for the section being removed. */
899 elf_s390_gc_sweep_hook (abfd
, info
, sec
, relocs
)
901 struct bfd_link_info
*info
;
903 const Elf_Internal_Rela
*relocs
;
905 Elf_Internal_Shdr
*symtab_hdr
;
906 struct elf_link_hash_entry
**sym_hashes
;
907 bfd_signed_vma
*local_got_refcounts
;
908 const Elf_Internal_Rela
*rel
, *relend
;
909 unsigned long r_symndx
;
910 struct elf_link_hash_entry
*h
;
912 elf_section_data (sec
)->local_dynrel
= NULL
;
914 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
915 sym_hashes
= elf_sym_hashes (abfd
);
916 local_got_refcounts
= elf_local_got_refcounts (abfd
);
918 relend
= relocs
+ sec
->reloc_count
;
919 for (rel
= relocs
; rel
< relend
; rel
++)
920 switch (ELF64_R_TYPE (rel
->r_info
))
930 r_symndx
= ELF64_R_SYM (rel
->r_info
);
931 if (r_symndx
>= symtab_hdr
->sh_info
)
933 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
934 if (h
->got
.refcount
> 0)
935 h
->got
.refcount
-= 1;
937 else if (local_got_refcounts
!= NULL
)
939 if (local_got_refcounts
[r_symndx
] > 0)
940 local_got_refcounts
[r_symndx
] -= 1;
954 r_symndx
= ELF64_R_SYM (rel
->r_info
);
955 if (r_symndx
>= symtab_hdr
->sh_info
)
957 struct elf_s390_link_hash_entry
*eh
;
958 struct elf_s390_dyn_relocs
**pp
;
959 struct elf_s390_dyn_relocs
*p
;
961 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
963 if (!info
->shared
&& h
->plt
.refcount
> 0)
964 h
->plt
.refcount
-= 1;
966 eh
= (struct elf_s390_link_hash_entry
*) h
;
968 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
971 if (ELF64_R_TYPE (rel
->r_info
) == R_390_PC16
972 || ELF64_R_TYPE (rel
->r_info
) == R_390_PC16DBL
973 || ELF64_R_TYPE (rel
->r_info
) == R_390_PC32
)
987 r_symndx
= ELF64_R_SYM (rel
->r_info
);
988 if (r_symndx
>= symtab_hdr
->sh_info
)
990 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
991 if (h
->plt
.refcount
> 0)
992 h
->plt
.refcount
-= 1;
1003 /* Adjust a symbol defined by a dynamic object and referenced by a
1004 regular object. The current definition is in some section of the
1005 dynamic object, but we're not including those sections. We have to
1006 change the definition to something the rest of the link can
1010 elf_s390_adjust_dynamic_symbol (info
, h
)
1011 struct bfd_link_info
*info
;
1012 struct elf_link_hash_entry
*h
;
1014 struct elf_s390_link_hash_table
*htab
;
1015 struct elf_s390_link_hash_entry
* eh
;
1016 struct elf_s390_dyn_relocs
*p
;
1018 unsigned int power_of_two
;
1020 /* If this is a function, put it in the procedure linkage table. We
1021 will fill in the contents of the procedure linkage table later
1022 (although we could actually do it here). */
1023 if (h
->type
== STT_FUNC
1024 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
1026 if (h
->plt
.refcount
<= 0
1028 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1029 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0
1030 && h
->root
.type
!= bfd_link_hash_undefweak
1031 && h
->root
.type
!= bfd_link_hash_undefined
))
1033 /* This case can occur if we saw a PLT32 reloc in an input
1034 file, but the symbol was never referred to by a dynamic
1035 object, or if all references were garbage collected. In
1036 such a case, we don't actually need to build a procedure
1037 linkage table, and we can just do a PC32 reloc instead. */
1038 h
->plt
.offset
= (bfd_vma
) -1;
1039 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1045 /* It's possible that we incorrectly decided a .plt reloc was
1046 needed for an R_390_PC32 reloc to a non-function sym in
1047 check_relocs. We can't decide accurately between function and
1048 non-function syms in check-relocs; Objects loaded later in
1049 the link may change h->type. So fix it now. */
1050 h
->plt
.offset
= (bfd_vma
) -1;
1052 /* If this is a weak symbol, and there is a real definition, the
1053 processor independent code will have arranged for us to see the
1054 real definition first, and we can just use the same value. */
1055 if (h
->weakdef
!= NULL
)
1057 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
1058 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
1059 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
1060 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
1064 /* This is a reference to a symbol defined by a dynamic object which
1065 is not a function. */
1067 /* If we are creating a shared library, we must presume that the
1068 only references to the symbol are via the global offset table.
1069 For such cases we need not do anything here; the relocations will
1070 be handled correctly by relocate_section. */
1074 /* If there are no references to this symbol that do not use the
1075 GOT, we don't need to generate a copy reloc. */
1076 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
1079 /* If -z nocopyreloc was given, we won't generate them either. */
1080 if (info
->nocopyreloc
)
1082 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_GOT_REF
;
1086 eh
= (struct elf_s390_link_hash_entry
*) h
;
1087 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1089 s
= p
->sec
->output_section
;
1090 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1094 /* If we didn't find any dynamic relocs in read-only sections, then
1095 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1098 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_GOT_REF
;
1102 /* We must allocate the symbol in our .dynbss section, which will
1103 become part of the .bss section of the executable. There will be
1104 an entry for this symbol in the .dynsym section. The dynamic
1105 object will contain position independent code, so all references
1106 from the dynamic object to this symbol will go through the global
1107 offset table. The dynamic linker will use the .dynsym entry to
1108 determine the address it must put in the global offset table, so
1109 both the dynamic object and the regular object will refer to the
1110 same memory location for the variable. */
1112 htab
= elf_s390_hash_table (info
);
1114 /* We must generate a R_390_COPY reloc to tell the dynamic linker to
1115 copy the initial value out of the dynamic object and into the
1116 runtime process image. */
1117 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1119 htab
->srelbss
->_raw_size
+= sizeof (Elf64_External_Rela
);
1120 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
1123 /* We need to figure out the alignment required for this symbol. I
1124 have no idea how ELF linkers handle this. */
1125 power_of_two
= bfd_log2 (h
->size
);
1126 if (power_of_two
> 3)
1129 /* Apply the required alignment. */
1131 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
, (bfd_size_type
) (1 << power_of_two
));
1132 if (power_of_two
> bfd_get_section_alignment (htab
->elf
.dynobj
, s
))
1134 if (! bfd_set_section_alignment (htab
->elf
.dynobj
, s
, power_of_two
))
1138 /* Define the symbol as being at this point in the section. */
1139 h
->root
.u
.def
.section
= s
;
1140 h
->root
.u
.def
.value
= s
->_raw_size
;
1142 /* Increment the section size to make room for the symbol. */
1143 s
->_raw_size
+= h
->size
;
1148 /* This is the condition under which elf_s390_finish_dynamic_symbol
1149 will be called from elflink.h. If elflink.h doesn't call our
1150 finish_dynamic_symbol routine, we'll need to do something about
1151 initializing any .plt and .got entries in elf_s390_relocate_section. */
1152 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1154 && ((INFO)->shared \
1155 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1156 && ((H)->dynindx != -1 \
1157 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1159 /* Allocate space in .plt, .got and associated reloc sections for
1163 allocate_dynrelocs (h
, inf
)
1164 struct elf_link_hash_entry
*h
;
1167 struct bfd_link_info
*info
;
1168 struct elf_s390_link_hash_table
*htab
;
1169 struct elf_s390_link_hash_entry
*eh
;
1170 struct elf_s390_dyn_relocs
*p
;
1172 if (h
->root
.type
== bfd_link_hash_indirect
)
1175 if (h
->root
.type
== bfd_link_hash_warning
)
1176 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1178 info
= (struct bfd_link_info
*) inf
;
1179 htab
= elf_s390_hash_table (info
);
1181 if (htab
->elf
.dynamic_sections_created
1182 && h
->plt
.refcount
> 0)
1184 /* Make sure this symbol is output as a dynamic symbol.
1185 Undefined weak syms won't yet be marked as dynamic. */
1186 if (h
->dynindx
== -1
1187 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1189 if (! bfd_elf64_link_record_dynamic_symbol (info
, h
))
1193 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
, h
))
1195 asection
*s
= htab
->splt
;
1197 /* If this is the first .plt entry, make room for the special
1199 if (s
->_raw_size
== 0)
1200 s
->_raw_size
+= PLT_FIRST_ENTRY_SIZE
;
1202 h
->plt
.offset
= s
->_raw_size
;
1204 /* If this symbol is not defined in a regular file, and we are
1205 not generating a shared library, then set the symbol to this
1206 location in the .plt. This is required to make function
1207 pointers compare as equal between the normal executable and
1208 the shared library. */
1210 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1212 h
->root
.u
.def
.section
= s
;
1213 h
->root
.u
.def
.value
= h
->plt
.offset
;
1216 /* Make room for this entry. */
1217 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1219 /* We also need to make an entry in the .got.plt section, which
1220 will be placed in the .got section by the linker script. */
1221 htab
->sgotplt
->_raw_size
+= GOT_ENTRY_SIZE
;
1223 /* We also need to make an entry in the .rela.plt section. */
1224 htab
->srelplt
->_raw_size
+= sizeof (Elf64_External_Rela
);
1228 h
->plt
.offset
= (bfd_vma
) -1;
1229 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1234 h
->plt
.offset
= (bfd_vma
) -1;
1235 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1238 if (h
->got
.refcount
> 0)
1243 /* Make sure this symbol is output as a dynamic symbol.
1244 Undefined weak syms won't yet be marked as dynamic. */
1245 if (h
->dynindx
== -1
1246 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1248 if (! bfd_elf64_link_record_dynamic_symbol (info
, h
))
1253 h
->got
.offset
= s
->_raw_size
;
1254 s
->_raw_size
+= GOT_ENTRY_SIZE
;
1255 dyn
= htab
->elf
.dynamic_sections_created
;
1256 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
))
1257 htab
->srelgot
->_raw_size
+= sizeof (Elf64_External_Rela
);
1260 h
->got
.offset
= (bfd_vma
) -1;
1262 eh
= (struct elf_s390_link_hash_entry
*) h
;
1263 if (eh
->dyn_relocs
== NULL
)
1266 /* In the shared -Bsymbolic case, discard space allocated for
1267 dynamic pc-relative relocs against symbols which turn out to be
1268 defined in regular objects. For the normal shared case, discard
1269 space for pc-relative relocs that have become local due to symbol
1270 visibility changes. */
1274 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1275 && ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0
1278 struct elf_s390_dyn_relocs
**pp
;
1280 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1282 p
->count
-= p
->pc_count
;
1293 /* For the non-shared case, discard space for relocs against
1294 symbols which turn out to need copy relocs or are not
1297 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1298 && (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1299 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1300 || (htab
->elf
.dynamic_sections_created
1301 && (h
->root
.type
== bfd_link_hash_undefweak
1302 || h
->root
.type
== bfd_link_hash_undefined
))))
1304 /* Make sure this symbol is output as a dynamic symbol.
1305 Undefined weak syms won't yet be marked as dynamic. */
1306 if (h
->dynindx
== -1
1307 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1309 if (! bfd_elf64_link_record_dynamic_symbol (info
, h
))
1313 /* If that succeeded, we know we'll be keeping all the
1315 if (h
->dynindx
!= -1)
1319 eh
->dyn_relocs
= NULL
;
1324 /* Finally, allocate space. */
1325 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1327 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1328 sreloc
->_raw_size
+= p
->count
* sizeof (Elf64_External_Rela
);
1334 /* Find any dynamic relocs that apply to read-only sections. */
1337 readonly_dynrelocs (h
, inf
)
1338 struct elf_link_hash_entry
*h
;
1341 struct elf_s390_link_hash_entry
*eh
;
1342 struct elf_s390_dyn_relocs
*p
;
1344 if (h
->root
.type
== bfd_link_hash_warning
)
1345 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1347 eh
= (struct elf_s390_link_hash_entry
*) h
;
1348 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1350 asection
*s
= p
->sec
->output_section
;
1352 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1354 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
1356 info
->flags
|= DF_TEXTREL
;
1358 /* Not an error, just cut short the traversal. */
1365 /* Set the sizes of the dynamic sections. */
1368 elf_s390_size_dynamic_sections (output_bfd
, info
)
1369 bfd
*output_bfd ATTRIBUTE_UNUSED
;
1370 struct bfd_link_info
*info
;
1372 struct elf_s390_link_hash_table
*htab
;
1378 htab
= elf_s390_hash_table (info
);
1379 dynobj
= htab
->elf
.dynobj
;
1383 if (htab
->elf
.dynamic_sections_created
)
1385 /* Set the contents of the .interp section to the interpreter. */
1388 s
= bfd_get_section_by_name (dynobj
, ".interp");
1391 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1392 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1396 /* Set up .got offsets for local syms, and space for local dynamic
1398 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
1400 bfd_signed_vma
*local_got
;
1401 bfd_signed_vma
*end_local_got
;
1402 bfd_size_type locsymcount
;
1403 Elf_Internal_Shdr
*symtab_hdr
;
1406 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
1409 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1411 struct elf_s390_dyn_relocs
*p
;
1413 for (p
= *((struct elf_s390_dyn_relocs
**)
1414 &elf_section_data (s
)->local_dynrel
);
1418 if (!bfd_is_abs_section (p
->sec
)
1419 && bfd_is_abs_section (p
->sec
->output_section
))
1421 /* Input section has been discarded, either because
1422 it is a copy of a linkonce section or due to
1423 linker script /DISCARD/, so we'll be discarding
1426 else if (p
->count
!= 0)
1428 srela
= elf_section_data (p
->sec
)->sreloc
;
1429 srela
->_raw_size
+= p
->count
* sizeof (Elf64_External_Rela
);
1430 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1431 info
->flags
|= DF_TEXTREL
;
1436 local_got
= elf_local_got_refcounts (ibfd
);
1440 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1441 locsymcount
= symtab_hdr
->sh_info
;
1442 end_local_got
= local_got
+ locsymcount
;
1444 srela
= htab
->srelgot
;
1445 for (; local_got
< end_local_got
; ++local_got
)
1449 *local_got
= s
->_raw_size
;
1450 s
->_raw_size
+= GOT_ENTRY_SIZE
;
1452 srela
->_raw_size
+= sizeof (Elf64_External_Rela
);
1455 *local_got
= (bfd_vma
) -1;
1459 /* Allocate global sym .plt and .got entries, and space for global
1460 sym dynamic relocs. */
1461 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, (PTR
) info
);
1463 /* We now have determined the sizes of the various dynamic sections.
1464 Allocate memory for them. */
1466 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1468 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1473 || s
== htab
->sgotplt
)
1475 /* Strip this section if we don't need it; see the
1478 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rela", 5) == 0)
1480 if (s
->_raw_size
!= 0 && s
!= htab
->srelplt
)
1483 /* We use the reloc_count field as a counter if we need
1484 to copy relocs into the output file. */
1489 /* It's not one of our sections, so don't allocate space. */
1493 if (s
->_raw_size
== 0)
1495 /* If we don't need this section, strip it from the
1496 output file. This is to handle .rela.bss and
1497 .rela.plt. We must create it in
1498 create_dynamic_sections, because it must be created
1499 before the linker maps input sections to output
1500 sections. The linker does that before
1501 adjust_dynamic_symbol is called, and it is that
1502 function which decides whether anything needs to go
1503 into these sections. */
1505 _bfd_strip_section_from_output (info
, s
);
1509 /* Allocate memory for the section contents. We use bfd_zalloc
1510 here in case unused entries are not reclaimed before the
1511 section's contents are written out. This should not happen,
1512 but this way if it does, we get a R_390_NONE reloc instead
1514 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1515 if (s
->contents
== NULL
)
1519 if (htab
->elf
.dynamic_sections_created
)
1521 /* Add some entries to the .dynamic section. We fill in the
1522 values later, in elf_s390_finish_dynamic_sections, but we
1523 must add the entries now so that we get the correct size for
1524 the .dynamic section. The DT_DEBUG entry is filled in by the
1525 dynamic linker and used by the debugger. */
1526 #define add_dynamic_entry(TAG, VAL) \
1527 bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1531 if (!add_dynamic_entry (DT_DEBUG
, 0))
1535 if (htab
->splt
->_raw_size
!= 0)
1537 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1538 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1539 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1540 || !add_dynamic_entry (DT_JMPREL
, 0))
1546 if (!add_dynamic_entry (DT_RELA
, 0)
1547 || !add_dynamic_entry (DT_RELASZ
, 0)
1548 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf64_External_Rela
)))
1551 /* If any dynamic relocs apply to a read-only section,
1552 then we need a DT_TEXTREL entry. */
1553 if ((info
->flags
& DF_TEXTREL
) == 0)
1554 elf_link_hash_traverse (&htab
->elf
, readonly_dynrelocs
,
1557 if ((info
->flags
& DF_TEXTREL
) != 0)
1559 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1564 #undef add_dynamic_entry
1569 /* Relocate a 390 ELF section. */
1572 elf_s390_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1573 contents
, relocs
, local_syms
, local_sections
)
1575 struct bfd_link_info
*info
;
1577 asection
*input_section
;
1579 Elf_Internal_Rela
*relocs
;
1580 Elf_Internal_Sym
*local_syms
;
1581 asection
**local_sections
;
1583 struct elf_s390_link_hash_table
*htab
;
1584 Elf_Internal_Shdr
*symtab_hdr
;
1585 struct elf_link_hash_entry
**sym_hashes
;
1586 bfd_vma
*local_got_offsets
;
1587 Elf_Internal_Rela
*rel
;
1588 Elf_Internal_Rela
*relend
;
1590 htab
= elf_s390_hash_table (info
);
1591 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1592 sym_hashes
= elf_sym_hashes (input_bfd
);
1593 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1596 relend
= relocs
+ input_section
->reloc_count
;
1597 for (; rel
< relend
; rel
++)
1600 reloc_howto_type
*howto
;
1601 unsigned long r_symndx
;
1602 struct elf_link_hash_entry
*h
;
1603 Elf_Internal_Sym
*sym
;
1607 boolean unresolved_reloc
;
1608 bfd_reloc_status_type r
;
1610 r_type
= ELF64_R_TYPE (rel
->r_info
);
1611 if (r_type
== (int) R_390_GNU_VTINHERIT
1612 || r_type
== (int) R_390_GNU_VTENTRY
)
1614 if (r_type
< 0 || r_type
>= (int) R_390_max
)
1616 bfd_set_error (bfd_error_bad_value
);
1619 howto
= elf_howto_table
+ r_type
;
1621 r_symndx
= ELF64_R_SYM (rel
->r_info
);
1623 if (info
->relocateable
)
1625 /* This is a relocateable link. We don't have to change
1626 anything, unless the reloc is against a section symbol,
1627 in which case we have to adjust according to where the
1628 section symbol winds up in the output section. */
1629 if (r_symndx
< symtab_hdr
->sh_info
)
1631 sym
= local_syms
+ r_symndx
;
1632 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1634 sec
= local_sections
[r_symndx
];
1635 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1642 /* This is a final link. */
1646 unresolved_reloc
= false;
1647 if (r_symndx
< symtab_hdr
->sh_info
)
1649 sym
= local_syms
+ r_symndx
;
1650 sec
= local_sections
[r_symndx
];
1651 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, sec
, rel
);
1655 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1656 while (h
->root
.type
== bfd_link_hash_indirect
1657 || h
->root
.type
== bfd_link_hash_warning
)
1658 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1660 if (h
->root
.type
== bfd_link_hash_defined
1661 || h
->root
.type
== bfd_link_hash_defweak
)
1663 sec
= h
->root
.u
.def
.section
;
1664 if (sec
->output_section
== NULL
)
1666 /* Set a flag that will be cleared later if we find a
1667 relocation value for this symbol. output_section
1668 is typically NULL for symbols satisfied by a shared
1670 unresolved_reloc
= true;
1674 relocation
= (h
->root
.u
.def
.value
1675 + sec
->output_section
->vma
1676 + sec
->output_offset
);
1678 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1680 else if (info
->shared
1681 && (!info
->symbolic
|| info
->allow_shlib_undefined
)
1682 && !info
->no_undefined
1683 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1687 if (! ((*info
->callbacks
->undefined_symbol
)
1688 (info
, h
->root
.root
.string
, input_bfd
,
1689 input_section
, rel
->r_offset
,
1690 (!info
->shared
|| info
->no_undefined
1691 || ELF_ST_VISIBILITY (h
->other
)))))
1704 /* Relocation is to the entry for this symbol in the global
1706 if (htab
->sgot
== NULL
)
1713 off
= h
->got
.offset
;
1714 dyn
= htab
->elf
.dynamic_sections_created
;
1715 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
)
1719 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
1720 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1722 /* This is actually a static link, or it is a
1723 -Bsymbolic link and the symbol is defined
1724 locally, or the symbol was forced to be local
1725 because of a version file. We must initialize
1726 this entry in the global offset table. Since the
1727 offset must always be a multiple of 2, we use the
1728 least significant bit to record whether we have
1729 initialized it already.
1731 When doing a dynamic link, we create a .rel.got
1732 relocation entry to initialize the value. This
1733 is done in the finish_dynamic_symbol routine. */
1738 bfd_put_64 (output_bfd
, relocation
,
1739 htab
->sgot
->contents
+ off
);
1744 unresolved_reloc
= false;
1748 if (local_got_offsets
== NULL
)
1751 off
= local_got_offsets
[r_symndx
];
1753 /* The offset must always be a multiple of 8. We use
1754 the least significant bit to record whether we have
1755 already generated the necessary reloc. */
1760 bfd_put_64 (output_bfd
, relocation
,
1761 htab
->sgot
->contents
+ off
);
1766 Elf_Internal_Rela outrel
;
1767 Elf64_External_Rela
*loc
;
1769 srelgot
= htab
->srelgot
;
1770 if (srelgot
== NULL
)
1773 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
1774 + htab
->sgot
->output_offset
1776 outrel
.r_info
= ELF64_R_INFO (0, R_390_RELATIVE
);
1777 outrel
.r_addend
= relocation
;
1778 loc
= (Elf64_External_Rela
*) srelgot
->contents
;
1779 loc
+= srelgot
->reloc_count
++;
1780 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
1783 local_got_offsets
[r_symndx
] |= 1;
1787 if (off
>= (bfd_vma
) -2)
1790 relocation
= htab
->sgot
->output_offset
+ off
;
1793 * For @GOTENT the relocation is against the offset between
1794 * the instruction and the symbols entry in the GOT and not
1795 * between the start of the GOT and the symbols entry. We
1796 * add the vma of the GOT to get the correct value.
1798 if (r_type
== R_390_GOTENT
)
1799 relocation
+= htab
->sgot
->output_section
->vma
;
1804 /* Relocation is relative to the start of the global offset
1807 /* Note that sgot->output_offset is not involved in this
1808 calculation. We always want the start of .got. If we
1809 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1810 permitted by the ABI, we might have to change this
1812 relocation
-= htab
->sgot
->output_section
->vma
;
1817 case R_390_GOTPCDBL
:
1818 /* Use global offset table as symbol value. */
1819 relocation
= htab
->sgot
->output_section
->vma
;
1820 unresolved_reloc
= false;
1823 case R_390_PLT16DBL
:
1825 case R_390_PLT32DBL
:
1827 /* Relocation is to the entry for this symbol in the
1828 procedure linkage table. */
1830 /* Resolve a PLT32 reloc against a local symbol directly,
1831 without using the procedure linkage table. */
1835 if (h
->plt
.offset
== (bfd_vma
) -1
1836 || htab
->splt
== NULL
)
1838 /* We didn't make a PLT entry for this symbol. This
1839 happens when statically linking PIC code, or when
1840 using -Bsymbolic. */
1844 relocation
= (htab
->splt
->output_section
->vma
1845 + htab
->splt
->output_offset
1847 unresolved_reloc
= false;
1859 /* r_symndx will be zero only for relocs against symbols
1860 from removed linkonce sections, or sections discarded by
1863 || (input_section
->flags
& SEC_ALLOC
) == 0)
1867 && ((r_type
!= R_390_PC16
1868 && r_type
!= R_390_PC16DBL
1869 && r_type
!= R_390_PC32
1870 && r_type
!= R_390_PC32DBL
1871 && r_type
!= R_390_PC64
)
1874 && (! info
->symbolic
1875 || (h
->elf_link_hash_flags
1876 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1880 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1881 && (((h
->elf_link_hash_flags
1882 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1883 && (h
->elf_link_hash_flags
1884 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
1885 || h
->root
.type
== bfd_link_hash_undefweak
1886 || h
->root
.type
== bfd_link_hash_undefined
)))
1888 Elf_Internal_Rela outrel
;
1889 boolean skip
, relocate
;
1891 Elf64_External_Rela
*loc
;
1893 /* When generating a shared object, these relocations
1894 are copied into the output file to be resolved at run
1901 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1903 if (outrel
.r_offset
== (bfd_vma
) -1)
1905 else if (outrel
.r_offset
== (bfd_vma
) -2)
1906 skip
= true, relocate
= true;
1908 outrel
.r_offset
+= (input_section
->output_section
->vma
1909 + input_section
->output_offset
);
1912 memset (&outrel
, 0, sizeof outrel
);
1915 && (r_type
== R_390_PC16
1916 || r_type
== R_390_PC16DBL
1917 || r_type
== R_390_PC32
1918 || r_type
== R_390_PC32DBL
1919 || r_type
== R_390_PC64
1922 || (h
->elf_link_hash_flags
1923 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1925 outrel
.r_info
= ELF64_R_INFO (h
->dynindx
, r_type
);
1926 outrel
.r_addend
= rel
->r_addend
;
1930 /* This symbol is local, or marked to become local. */
1932 outrel
.r_info
= ELF64_R_INFO (0, R_390_RELATIVE
);
1933 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1936 sreloc
= elf_section_data (input_section
)->sreloc
;
1940 loc
= (Elf64_External_Rela
*) sreloc
->contents
;
1941 loc
+= sreloc
->reloc_count
++;
1942 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, loc
);
1944 /* If this reloc is against an external symbol, we do
1945 not want to fiddle with the addend. Otherwise, we
1946 need to include the symbol value so that it becomes
1947 an addend for the dynamic reloc. */
1958 if (unresolved_reloc
1960 && (input_section
->flags
& SEC_DEBUGGING
) != 0
1961 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
1962 (*_bfd_error_handler
)
1963 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
1964 bfd_archive_filename (input_bfd
),
1965 bfd_get_section_name (input_bfd
, input_section
),
1966 (long) rel
->r_offset
,
1967 h
->root
.root
.string
);
1969 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1970 contents
, rel
->r_offset
,
1971 relocation
, rel
->r_addend
);
1973 if (r
!= bfd_reloc_ok
)
1978 name
= h
->root
.root
.string
;
1981 name
= bfd_elf_string_from_elf_section (input_bfd
,
1982 symtab_hdr
->sh_link
,
1987 name
= bfd_section_name (input_bfd
, sec
);
1990 if (r
== bfd_reloc_overflow
)
1993 if (! ((*info
->callbacks
->reloc_overflow
)
1994 (info
, name
, howto
->name
, (bfd_vma
) 0,
1995 input_bfd
, input_section
, rel
->r_offset
)))
2000 (*_bfd_error_handler
)
2001 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
2002 bfd_archive_filename (input_bfd
),
2003 bfd_get_section_name (input_bfd
, input_section
),
2004 (long) rel
->r_offset
, name
, (int) r
);
2013 /* Finish up dynamic symbol handling. We set the contents of various
2014 dynamic sections here. */
2017 elf_s390_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
2019 struct bfd_link_info
*info
;
2020 struct elf_link_hash_entry
*h
;
2021 Elf_Internal_Sym
*sym
;
2023 struct elf_s390_link_hash_table
*htab
;
2025 htab
= elf_s390_hash_table (info
);
2027 if (h
->plt
.offset
!= (bfd_vma
) -1)
2031 Elf_Internal_Rela rela
;
2032 Elf64_External_Rela
*loc
;
2034 /* This symbol has an entry in the procedure linkage table. Set
2037 if (h
->dynindx
== -1
2038 || htab
->splt
== NULL
2039 || htab
->sgotplt
== NULL
2040 || htab
->srelplt
== NULL
)
2044 Current offset - size first entry / entry size. */
2045 plt_index
= (h
->plt
.offset
- PLT_FIRST_ENTRY_SIZE
) / PLT_ENTRY_SIZE
;
2047 /* Offset in GOT is PLT index plus GOT headers(3) times 8,
2049 got_offset
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
2051 /* Fill in the blueprint of a PLT. */
2052 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD0
,
2053 htab
->splt
->contents
+ h
->plt
.offset
);
2054 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD1
,
2055 htab
->splt
->contents
+ h
->plt
.offset
+ 4);
2056 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD2
,
2057 htab
->splt
->contents
+ h
->plt
.offset
+ 8);
2058 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD3
,
2059 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
2060 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD4
,
2061 htab
->splt
->contents
+ h
->plt
.offset
+ 16);
2062 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD5
,
2063 htab
->splt
->contents
+ h
->plt
.offset
+ 20);
2064 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD6
,
2065 htab
->splt
->contents
+ h
->plt
.offset
+ 24);
2066 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD7
,
2067 htab
->splt
->contents
+ h
->plt
.offset
+ 28);
2068 /* Fixup the relative address to the GOT entry */
2069 bfd_put_32 (output_bfd
,
2070 (htab
->sgotplt
->output_section
->vma
+
2071 htab
->sgotplt
->output_offset
+ got_offset
2072 - (htab
->splt
->output_section
->vma
+ h
->plt
.offset
))/2,
2073 htab
->splt
->contents
+ h
->plt
.offset
+ 2);
2074 /* Fixup the relative branch to PLT 0 */
2075 bfd_put_32 (output_bfd
, - (PLT_FIRST_ENTRY_SIZE
+
2076 (PLT_ENTRY_SIZE
* plt_index
) + 22)/2,
2077 htab
->splt
->contents
+ h
->plt
.offset
+ 24);
2078 /* Fixup offset into symbol table */
2079 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf64_External_Rela
),
2080 htab
->splt
->contents
+ h
->plt
.offset
+ 28);
2082 /* Fill in the entry in the global offset table.
2083 Points to instruction after GOT offset. */
2084 bfd_put_64 (output_bfd
,
2085 (htab
->splt
->output_section
->vma
2086 + htab
->splt
->output_offset
2089 htab
->sgotplt
->contents
+ got_offset
);
2091 /* Fill in the entry in the .rela.plt section. */
2092 rela
.r_offset
= (htab
->sgotplt
->output_section
->vma
2093 + htab
->sgotplt
->output_offset
2095 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_390_JMP_SLOT
);
2097 loc
= (Elf64_External_Rela
*) htab
->srelplt
->contents
+ plt_index
;
2098 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
2100 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2102 /* Mark the symbol as undefined, rather than as defined in
2103 the .plt section. Leave the value alone. This is a clue
2104 for the dynamic linker, to make function pointer
2105 comparisons work between an application and shared
2107 sym
->st_shndx
= SHN_UNDEF
;
2111 if (h
->got
.offset
!= (bfd_vma
) -1)
2113 Elf_Internal_Rela rela
;
2114 Elf64_External_Rela
*loc
;
2116 /* This symbol has an entry in the global offset table. Set it
2119 if (htab
->sgot
== NULL
|| htab
->srelgot
== NULL
)
2122 rela
.r_offset
= (htab
->sgot
->output_section
->vma
2123 + htab
->sgot
->output_offset
2124 + (h
->got
.offset
&~ (bfd_vma
) 1));
2126 /* If this is a static link, or it is a -Bsymbolic link and the
2127 symbol is defined locally or was forced to be local because
2128 of a version file, we just want to emit a RELATIVE reloc.
2129 The entry in the global offset table will already have been
2130 initialized in the relocate_section function. */
2134 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
2135 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
2137 BFD_ASSERT((h
->got
.offset
& 1) != 0);
2138 rela
.r_info
= ELF64_R_INFO (0, R_390_RELATIVE
);
2139 rela
.r_addend
= (h
->root
.u
.def
.value
2140 + h
->root
.u
.def
.section
->output_section
->vma
2141 + h
->root
.u
.def
.section
->output_offset
);
2145 BFD_ASSERT((h
->got
.offset
& 1) == 0);
2146 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->sgot
->contents
+ h
->got
.offset
);
2147 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_390_GLOB_DAT
);
2151 loc
= (Elf64_External_Rela
*) htab
->srelgot
->contents
;
2152 loc
+= htab
->srelgot
->reloc_count
++;
2153 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
2156 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
2158 Elf_Internal_Rela rela
;
2159 Elf64_External_Rela
*loc
;
2161 /* This symbols needs a copy reloc. Set it up. */
2163 if (h
->dynindx
== -1
2164 || (h
->root
.type
!= bfd_link_hash_defined
2165 && h
->root
.type
!= bfd_link_hash_defweak
)
2166 || htab
->srelbss
== NULL
)
2169 rela
.r_offset
= (h
->root
.u
.def
.value
2170 + h
->root
.u
.def
.section
->output_section
->vma
2171 + h
->root
.u
.def
.section
->output_offset
);
2172 rela
.r_info
= ELF64_R_INFO (h
->dynindx
, R_390_COPY
);
2174 loc
= (Elf64_External_Rela
*) htab
->srelbss
->contents
;
2175 loc
+= htab
->srelbss
->reloc_count
++;
2176 bfd_elf64_swap_reloca_out (output_bfd
, &rela
, loc
);
2179 /* Mark some specially defined symbols as absolute. */
2180 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2181 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
2182 || strcmp (h
->root
.root
.string
, "_PROCEDURE_LINKAGE_TABLE_") == 0)
2183 sym
->st_shndx
= SHN_ABS
;
2188 /* Used to decide how to sort relocs in an optimal manner for the
2189 dynamic linker, before writing them out. */
2191 static enum elf_reloc_type_class
2192 elf_s390_reloc_type_class (rela
)
2193 const Elf_Internal_Rela
*rela
;
2195 switch ((int) ELF64_R_TYPE (rela
->r_info
))
2197 case R_390_RELATIVE
:
2198 return reloc_class_relative
;
2199 case R_390_JMP_SLOT
:
2200 return reloc_class_plt
;
2202 return reloc_class_copy
;
2204 return reloc_class_normal
;
2208 /* Finish up the dynamic sections. */
2211 elf_s390_finish_dynamic_sections (output_bfd
, info
)
2213 struct bfd_link_info
*info
;
2215 struct elf_s390_link_hash_table
*htab
;
2219 htab
= elf_s390_hash_table (info
);
2220 dynobj
= htab
->elf
.dynobj
;
2221 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2223 if (htab
->elf
.dynamic_sections_created
)
2225 Elf64_External_Dyn
*dyncon
, *dynconend
;
2227 if (sdyn
== NULL
|| htab
->sgot
== NULL
)
2230 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
2231 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
2232 for (; dyncon
< dynconend
; dyncon
++)
2234 Elf_Internal_Dyn dyn
;
2237 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2245 dyn
.d_un
.d_ptr
= htab
->sgot
->output_section
->vma
;
2249 dyn
.d_un
.d_ptr
= htab
->srelplt
->output_section
->vma
;
2253 s
= htab
->srelplt
->output_section
;
2254 if (s
->_cooked_size
!= 0)
2255 dyn
.d_un
.d_val
= s
->_cooked_size
;
2257 dyn
.d_un
.d_val
= s
->_raw_size
;
2261 /* The procedure linkage table relocs (DT_JMPREL) should
2262 not be included in the overall relocs (DT_RELA).
2263 Therefore, we override the DT_RELASZ entry here to
2264 make it not include the JMPREL relocs. Since the
2265 linker script arranges for .rela.plt to follow all
2266 other relocation sections, we don't have to worry
2267 about changing the DT_RELA entry. */
2268 s
= htab
->srelplt
->output_section
;
2269 if (s
->_cooked_size
!= 0)
2270 dyn
.d_un
.d_val
-= s
->_cooked_size
;
2272 dyn
.d_un
.d_val
-= s
->_raw_size
;
2276 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2279 /* Fill in the special first entry in the procedure linkage table. */
2280 if (htab
->splt
&& htab
->splt
->_raw_size
> 0)
2282 /* fill in blueprint for plt 0 entry */
2283 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD0
,
2284 htab
->splt
->contents
);
2285 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD1
,
2286 htab
->splt
->contents
+4 );
2287 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD3
,
2288 htab
->splt
->contents
+12 );
2289 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD4
,
2290 htab
->splt
->contents
+16 );
2291 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD5
,
2292 htab
->splt
->contents
+20 );
2293 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD6
,
2294 htab
->splt
->contents
+ 24);
2295 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD7
,
2296 htab
->splt
->contents
+ 28 );
2297 /* Fixup relative address to start of GOT */
2298 bfd_put_32 (output_bfd
,
2299 (htab
->sgotplt
->output_section
->vma
+
2300 htab
->sgotplt
->output_offset
2301 - htab
->splt
->output_section
->vma
- 6)/2,
2302 htab
->splt
->contents
+ 8);
2304 elf_section_data (htab
->splt
->output_section
)
2305 ->this_hdr
.sh_entsize
= PLT_ENTRY_SIZE
;
2310 /* Fill in the first three entries in the global offset table. */
2311 if (htab
->sgotplt
->_raw_size
> 0)
2313 bfd_put_64 (output_bfd
,
2314 (sdyn
== NULL
? (bfd_vma
) 0
2315 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
2316 htab
->sgotplt
->contents
);
2317 /* One entry for shared object struct ptr. */
2318 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 8);
2319 /* One entry for _dl_runtime_resolve. */
2320 bfd_put_64 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 12);
2323 elf_section_data (htab
->sgot
->output_section
)
2324 ->this_hdr
.sh_entsize
= 8;
2330 elf_s390_object_p (abfd
)
2333 return bfd_default_set_arch_mach (abfd
, bfd_arch_s390
, bfd_mach_s390_64
);
2337 * Why was the hash table entry size definition changed from
2338 * ARCH_SIZE/8 to 4? This breaks the 64 bit dynamic linker and
2339 * this is the only reason for the s390_elf64_size_info structure.
2342 const struct elf_size_info s390_elf64_size_info
=
2344 sizeof (Elf64_External_Ehdr
),
2345 sizeof (Elf64_External_Phdr
),
2346 sizeof (Elf64_External_Shdr
),
2347 sizeof (Elf64_External_Rel
),
2348 sizeof (Elf64_External_Rela
),
2349 sizeof (Elf64_External_Sym
),
2350 sizeof (Elf64_External_Dyn
),
2351 sizeof (Elf_External_Note
),
2352 8, /* hash-table entry size */
2353 1, /* internal relocations per external relocations */
2356 ELFCLASS64
, EV_CURRENT
,
2357 bfd_elf64_write_out_phdrs
,
2358 bfd_elf64_write_shdrs_and_ehdr
,
2359 bfd_elf64_write_relocs
,
2360 bfd_elf64_swap_symbol_out
,
2361 bfd_elf64_slurp_reloc_table
,
2362 bfd_elf64_slurp_symbol_table
,
2363 bfd_elf64_swap_dyn_in
,
2364 bfd_elf64_swap_dyn_out
,
2371 #define TARGET_BIG_SYM bfd_elf64_s390_vec
2372 #define TARGET_BIG_NAME "elf64-s390"
2373 #define ELF_ARCH bfd_arch_s390
2374 #define ELF_MACHINE_CODE EM_S390
2375 #define ELF_MACHINE_ALT1 EM_S390_OLD
2376 #define ELF_MAXPAGESIZE 0x1000
2378 #define elf_backend_size_info s390_elf64_size_info
2380 #define elf_backend_can_gc_sections 1
2381 #define elf_backend_can_refcount 1
2382 #define elf_backend_want_got_plt 1
2383 #define elf_backend_plt_readonly 1
2384 #define elf_backend_want_plt_sym 0
2385 #define elf_backend_got_header_size 24
2386 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
2388 #define elf_info_to_howto elf_s390_info_to_howto
2390 #define bfd_elf64_bfd_is_local_label_name elf_s390_is_local_label_name
2391 #define bfd_elf64_bfd_link_hash_table_create elf_s390_link_hash_table_create
2392 #define bfd_elf64_bfd_reloc_type_lookup elf_s390_reloc_type_lookup
2394 #define elf_backend_adjust_dynamic_symbol elf_s390_adjust_dynamic_symbol
2395 #define elf_backend_check_relocs elf_s390_check_relocs
2396 #define elf_backend_copy_indirect_symbol elf_s390_copy_indirect_symbol
2397 #define elf_backend_create_dynamic_sections elf_s390_create_dynamic_sections
2398 #define elf_backend_finish_dynamic_sections elf_s390_finish_dynamic_sections
2399 #define elf_backend_finish_dynamic_symbol elf_s390_finish_dynamic_symbol
2400 #define elf_backend_gc_mark_hook elf_s390_gc_mark_hook
2401 #define elf_backend_gc_sweep_hook elf_s390_gc_sweep_hook
2402 #define elf_backend_reloc_type_class elf_s390_reloc_type_class
2403 #define elf_backend_relocate_section elf_s390_relocate_section
2404 #define elf_backend_size_dynamic_sections elf_s390_size_dynamic_sections
2405 #define elf_backend_reloc_type_class elf_s390_reloc_type_class
2407 #define elf_backend_object_p elf_s390_object_p
2409 #include "elf64-target.h"