1 /* IBM S/390-specific support for 64-bit ELF
2 Copyright 2000, 2001, 2002, 2003 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 bfd_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 bfd_boolean create_got_section
39 PARAMS((bfd *, struct bfd_link_info *));
40 static bfd_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_backend_data *, struct elf_link_hash_entry *,
44 struct elf_link_hash_entry *));
45 static bfd_boolean elf_s390_check_relocs
46 PARAMS ((bfd *, struct bfd_link_info *, asection *,
47 const Elf_Internal_Rela *));
48 static asection *elf_s390_gc_mark_hook
49 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
50 struct elf_link_hash_entry *, Elf_Internal_Sym *));
51 static bfd_boolean elf_s390_gc_sweep_hook
52 PARAMS ((bfd *, struct bfd_link_info *, asection *,
53 const Elf_Internal_Rela *));
54 struct elf_s390_link_hash_entry;
55 static void elf_s390_adjust_gotplt
56 PARAMS ((struct elf_s390_link_hash_entry *));
57 static bfd_boolean elf_s390_adjust_dynamic_symbol
58 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
59 static bfd_boolean allocate_dynrelocs
60 PARAMS ((struct elf_link_hash_entry *, PTR));
61 static bfd_boolean readonly_dynrelocs
62 PARAMS ((struct elf_link_hash_entry *, PTR));
63 static bfd_boolean elf_s390_size_dynamic_sections
64 PARAMS ((bfd *, struct bfd_link_info *));
65 static bfd_boolean elf_s390_relocate_section
66 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
67 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
68 static bfd_boolean elf_s390_finish_dynamic_symbol
69 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
71 static enum elf_reloc_type_class elf_s390_reloc_type_class
72 PARAMS ((const Elf_Internal_Rela *));
73 static bfd_boolean elf_s390_finish_dynamic_sections
74 PARAMS ((bfd *, struct bfd_link_info *));
75 static bfd_boolean elf_s390_mkobject
77 static bfd_boolean elf_s390_object_p
79 static int elf_s390_tls_transition
80 PARAMS ((struct bfd_link_info *, int, int));
81 static bfd_reloc_status_type s390_tls_reloc
82 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
83 static bfd_vma dtpoff_base
84 PARAMS ((struct bfd_link_info *));
86 PARAMS ((struct bfd_link_info *, bfd_vma));
87 static void invalid_tls_insn
88 PARAMS ((bfd *, asection *, Elf_Internal_Rela *));
92 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
93 from smaller values. Start with zero, widen, *then* decrement. */
94 #define MINUS_ONE (((bfd_vma)0) - 1)
96 /* The relocation "howto" table. */
97 static reloc_howto_type elf_howto_table[] =
99 HOWTO (R_390_NONE, /* type */
101 0, /* size (0 = byte, 1 = short, 2 = long) */
103 FALSE, /* pc_relative */
105 complain_overflow_dont, /* complain_on_overflow */
106 bfd_elf_generic_reloc, /* special_function */
107 "R_390_NONE", /* name */
108 FALSE, /* partial_inplace */
111 FALSE), /* pcrel_offset */
113 HOWTO(R_390_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
114 bfd_elf_generic_reloc, "R_390_8", FALSE, 0,0x000000ff, FALSE),
115 HOWTO(R_390_12, 0, 1, 12, FALSE, 0, complain_overflow_dont,
116 bfd_elf_generic_reloc, "R_390_12", FALSE, 0,0x00000fff, FALSE),
117 HOWTO(R_390_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
118 bfd_elf_generic_reloc, "R_390_16", FALSE, 0,0x0000ffff, FALSE),
119 HOWTO(R_390_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
120 bfd_elf_generic_reloc, "R_390_32", FALSE, 0,0xffffffff, FALSE),
121 HOWTO(R_390_PC32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
122 bfd_elf_generic_reloc, "R_390_PC32", FALSE, 0,0xffffffff, TRUE),
123 HOWTO(R_390_GOT12, 0, 1, 12, FALSE, 0, complain_overflow_dont,
124 bfd_elf_generic_reloc, "R_390_GOT12", FALSE, 0,0x00000fff, FALSE),
125 HOWTO(R_390_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
126 bfd_elf_generic_reloc, "R_390_GOT32", FALSE, 0,0xffffffff, FALSE),
127 HOWTO(R_390_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
128 bfd_elf_generic_reloc, "R_390_PLT32", FALSE, 0,0xffffffff, TRUE),
129 HOWTO(R_390_COPY, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
130 bfd_elf_generic_reloc, "R_390_COPY", FALSE, 0,MINUS_ONE, FALSE),
131 HOWTO(R_390_GLOB_DAT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
132 bfd_elf_generic_reloc, "R_390_GLOB_DAT", FALSE, 0,MINUS_ONE, FALSE),
133 HOWTO(R_390_JMP_SLOT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
134 bfd_elf_generic_reloc, "R_390_JMP_SLOT", FALSE, 0,MINUS_ONE, FALSE),
135 HOWTO(R_390_RELATIVE, 0, 4, 64, TRUE, 0, complain_overflow_bitfield,
136 bfd_elf_generic_reloc, "R_390_RELATIVE", FALSE, 0,MINUS_ONE, FALSE),
137 HOWTO(R_390_GOTOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
138 bfd_elf_generic_reloc, "R_390_GOTOFF32", FALSE, 0,MINUS_ONE, FALSE),
139 HOWTO(R_390_GOTPC, 0, 4, 64, TRUE, 0, complain_overflow_bitfield,
140 bfd_elf_generic_reloc, "R_390_GOTPC", FALSE, 0,MINUS_ONE, TRUE),
141 HOWTO(R_390_GOT16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
142 bfd_elf_generic_reloc, "R_390_GOT16", FALSE, 0,0x0000ffff, FALSE),
143 HOWTO(R_390_PC16, 0, 1, 16, TRUE, 0, complain_overflow_bitfield,
144 bfd_elf_generic_reloc, "R_390_PC16", FALSE, 0,0x0000ffff, TRUE),
145 HOWTO(R_390_PC16DBL, 1, 1, 16, TRUE, 0, complain_overflow_bitfield,
146 bfd_elf_generic_reloc, "R_390_PC16DBL", FALSE, 0,0x0000ffff, TRUE),
147 HOWTO(R_390_PLT16DBL, 1, 1, 16, TRUE, 0, complain_overflow_bitfield,
148 bfd_elf_generic_reloc, "R_390_PLT16DBL", FALSE, 0,0x0000ffff, TRUE),
149 HOWTO(R_390_PC32DBL, 1, 2, 32, TRUE, 0, complain_overflow_bitfield,
150 bfd_elf_generic_reloc, "R_390_PC32DBL", FALSE, 0,0xffffffff, TRUE),
151 HOWTO(R_390_PLT32DBL, 1, 2, 32, TRUE, 0, complain_overflow_bitfield,
152 bfd_elf_generic_reloc, "R_390_PLT32DBL", FALSE, 0,0xffffffff, TRUE),
153 HOWTO(R_390_GOTPCDBL, 1, 2, 32, TRUE, 0, complain_overflow_bitfield,
154 bfd_elf_generic_reloc, "R_390_GOTPCDBL", FALSE, 0,MINUS_ONE, TRUE),
155 HOWTO(R_390_64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
156 bfd_elf_generic_reloc, "R_390_64", FALSE, 0,MINUS_ONE, FALSE),
157 HOWTO(R_390_PC64, 0, 4, 64, TRUE, 0, complain_overflow_bitfield,
158 bfd_elf_generic_reloc, "R_390_PC64", FALSE, 0,MINUS_ONE, TRUE),
159 HOWTO(R_390_GOT64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
160 bfd_elf_generic_reloc, "R_390_GOT64", FALSE, 0,MINUS_ONE, FALSE),
161 HOWTO(R_390_PLT64, 0, 4, 64, TRUE, 0, complain_overflow_bitfield,
162 bfd_elf_generic_reloc, "R_390_PLT64", FALSE, 0,MINUS_ONE, TRUE),
163 HOWTO(R_390_GOTENT, 1, 2, 32, TRUE, 0, complain_overflow_bitfield,
164 bfd_elf_generic_reloc, "R_390_GOTENT", FALSE, 0,MINUS_ONE, TRUE),
165 HOWTO(R_390_GOTOFF16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
166 bfd_elf_generic_reloc, "R_390_GOTOFF16", FALSE, 0,0x0000ffff, FALSE),
167 HOWTO(R_390_GOTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
168 bfd_elf_generic_reloc, "R_390_GOTOFF64", FALSE, 0,MINUS_ONE, FALSE),
169 HOWTO(R_390_GOTPLT12, 0, 1, 12, FALSE, 0, complain_overflow_dont,
170 bfd_elf_generic_reloc, "R_390_GOTPLT12", FALSE, 0,0x00000fff, FALSE),
171 HOWTO(R_390_GOTPLT16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
172 bfd_elf_generic_reloc, "R_390_GOTPLT16", FALSE, 0,0x0000ffff, FALSE),
173 HOWTO(R_390_GOTPLT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
174 bfd_elf_generic_reloc, "R_390_GOTPLT32", FALSE, 0,0xffffffff, FALSE),
175 HOWTO(R_390_GOTPLT64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
176 bfd_elf_generic_reloc, "R_390_GOTPLT64", FALSE, 0,MINUS_ONE, FALSE),
177 HOWTO(R_390_GOTPLTENT, 1, 2, 32, TRUE, 0, complain_overflow_bitfield,
178 bfd_elf_generic_reloc, "R_390_GOTPLTENT",FALSE, 0,MINUS_ONE, TRUE),
179 HOWTO(R_390_PLTOFF16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
180 bfd_elf_generic_reloc, "R_390_PLTOFF16", FALSE, 0,0x0000ffff, FALSE),
181 HOWTO(R_390_PLTOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
182 bfd_elf_generic_reloc, "R_390_PLTOFF32", FALSE, 0,0xffffffff, FALSE),
183 HOWTO(R_390_PLTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
184 bfd_elf_generic_reloc, "R_390_PLTOFF64", FALSE, 0,MINUS_ONE, FALSE),
185 HOWTO(R_390_TLS_LOAD, 0, 0, 0, FALSE, 0, complain_overflow_dont,
186 s390_tls_reloc, "R_390_TLS_LOAD", FALSE, 0, 0, FALSE),
187 HOWTO(R_390_TLS_GDCALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
188 s390_tls_reloc, "R_390_TLS_GDCALL", FALSE, 0, 0, FALSE),
189 HOWTO(R_390_TLS_LDCALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
190 s390_tls_reloc, "R_390_TLS_LDCALL", FALSE, 0, 0, FALSE),
191 EMPTY_HOWTO (R_390_TLS_GD32), /* Empty entry for R_390_TLS_GD32. */
192 HOWTO(R_390_TLS_GD64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
193 bfd_elf_generic_reloc, "R_390_TLS_GD64", FALSE, 0, MINUS_ONE, FALSE),
194 HOWTO(R_390_TLS_GOTIE12, 0, 1, 12, FALSE, 0, complain_overflow_dont,
195 bfd_elf_generic_reloc, "R_390_TLS_GOTIE12", FALSE, 0, 0x00000fff, FALSE),
196 EMPTY_HOWTO (R_390_TLS_GOTIE32), /* Empty entry for R_390_TLS_GOTIE32. */
197 HOWTO(R_390_TLS_GOTIE64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
198 bfd_elf_generic_reloc, "R_390_TLS_GOTIE64", FALSE, 0, MINUS_ONE, FALSE),
199 EMPTY_HOWTO (R_390_TLS_LDM32), /* Empty entry for R_390_TLS_LDM32. */
200 HOWTO(R_390_TLS_LDM64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
201 bfd_elf_generic_reloc, "R_390_TLS_LDM64", FALSE, 0, MINUS_ONE, FALSE),
202 EMPTY_HOWTO (R_390_TLS_IE32), /* Empty entry for R_390_TLS_IE32. */
203 HOWTO(R_390_TLS_IE64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
204 bfd_elf_generic_reloc, "R_390_TLS_IE64", FALSE, 0, MINUS_ONE, FALSE),
205 HOWTO(R_390_TLS_IEENT, 1, 2, 32, TRUE, 0, complain_overflow_bitfield,
206 bfd_elf_generic_reloc, "R_390_TLS_IEENT", FALSE, 0, MINUS_ONE, TRUE),
207 EMPTY_HOWTO (R_390_TLS_LE32), /* Empty entry for R_390_TLS_LE32. */
208 HOWTO(R_390_TLS_LE64, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
209 bfd_elf_generic_reloc, "R_390_TLS_LE64", FALSE, 0, MINUS_ONE, FALSE),
210 EMPTY_HOWTO (R_390_TLS_LDO32), /* Empty entry for R_390_TLS_LDO32. */
211 HOWTO(R_390_TLS_LDO64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
212 bfd_elf_generic_reloc, "R_390_TLS_LDO64", FALSE, 0, MINUS_ONE, FALSE),
213 HOWTO(R_390_TLS_DTPMOD, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
214 bfd_elf_generic_reloc, "R_390_TLS_DTPMOD", FALSE, 0, MINUS_ONE, FALSE),
215 HOWTO(R_390_TLS_DTPOFF, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
216 bfd_elf_generic_reloc, "R_390_TLS_DTPOFF", FALSE, 0, MINUS_ONE, FALSE),
217 HOWTO(R_390_TLS_TPOFF, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
218 bfd_elf_generic_reloc, "R_390_TLS_TPOFF", FALSE, 0, MINUS_ONE, FALSE),
221 /* GNU extension to record C++ vtable hierarchy. */
222 static reloc_howto_type elf64_s390_vtinherit_howto =
223 HOWTO (R_390_GNU_VTINHERIT, 0,4,0,FALSE,0,complain_overflow_dont, NULL, "R_390_GNU_VTINHERIT", FALSE,0, 0, FALSE);
224 static reloc_howto_type elf64_s390_vtentry_howto =
225 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);
227 static reloc_howto_type *
228 elf_s390_reloc_type_lookup (abfd, code)
229 bfd *abfd ATTRIBUTE_UNUSED;
230 bfd_reloc_code_real_type code;
235 return &elf_howto_table[(int) R_390_NONE];
237 return &elf_howto_table[(int) R_390_8];
238 case BFD_RELOC_390_12:
239 return &elf_howto_table[(int) R_390_12];
241 return &elf_howto_table[(int) R_390_16];
243 return &elf_howto_table[(int) R_390_32];
245 return &elf_howto_table[(int) R_390_32];
246 case BFD_RELOC_32_PCREL:
247 return &elf_howto_table[(int) R_390_PC32];
248 case BFD_RELOC_390_GOT12:
249 return &elf_howto_table[(int) R_390_GOT12];
250 case BFD_RELOC_32_GOT_PCREL:
251 return &elf_howto_table[(int) R_390_GOT32];
252 case BFD_RELOC_390_PLT32:
253 return &elf_howto_table[(int) R_390_PLT32];
254 case BFD_RELOC_390_COPY:
255 return &elf_howto_table[(int) R_390_COPY];
256 case BFD_RELOC_390_GLOB_DAT:
257 return &elf_howto_table[(int) R_390_GLOB_DAT];
258 case BFD_RELOC_390_JMP_SLOT:
259 return &elf_howto_table[(int) R_390_JMP_SLOT];
260 case BFD_RELOC_390_RELATIVE:
261 return &elf_howto_table[(int) R_390_RELATIVE];
262 case BFD_RELOC_32_GOTOFF:
263 return &elf_howto_table[(int) R_390_GOTOFF32];
264 case BFD_RELOC_390_GOTPC:
265 return &elf_howto_table[(int) R_390_GOTPC];
266 case BFD_RELOC_390_GOT16:
267 return &elf_howto_table[(int) R_390_GOT16];
268 case BFD_RELOC_16_PCREL:
269 return &elf_howto_table[(int) R_390_PC16];
270 case BFD_RELOC_390_PC16DBL:
271 return &elf_howto_table[(int) R_390_PC16DBL];
272 case BFD_RELOC_390_PLT16DBL:
273 return &elf_howto_table[(int) R_390_PLT16DBL];
274 case BFD_RELOC_390_PC32DBL:
275 return &elf_howto_table[(int) R_390_PC32DBL];
276 case BFD_RELOC_390_PLT32DBL:
277 return &elf_howto_table[(int) R_390_PLT32DBL];
278 case BFD_RELOC_390_GOTPCDBL:
279 return &elf_howto_table[(int) R_390_GOTPCDBL];
281 return &elf_howto_table[(int) R_390_64];
282 case BFD_RELOC_64_PCREL:
283 return &elf_howto_table[(int) R_390_PC64];
284 case BFD_RELOC_390_GOT64:
285 return &elf_howto_table[(int) R_390_GOT64];
286 case BFD_RELOC_390_PLT64:
287 return &elf_howto_table[(int) R_390_PLT64];
288 case BFD_RELOC_390_GOTENT:
289 return &elf_howto_table[(int) R_390_GOTENT];
290 case BFD_RELOC_16_GOTOFF:
291 return &elf_howto_table[(int) R_390_GOTOFF16];
292 case BFD_RELOC_390_GOTOFF64:
293 return &elf_howto_table[(int) R_390_GOTOFF64];
294 case BFD_RELOC_390_GOTPLT12:
295 return &elf_howto_table[(int) R_390_GOTPLT12];
296 case BFD_RELOC_390_GOTPLT16:
297 return &elf_howto_table[(int) R_390_GOTPLT16];
298 case BFD_RELOC_390_GOTPLT32:
299 return &elf_howto_table[(int) R_390_GOTPLT32];
300 case BFD_RELOC_390_GOTPLT64:
301 return &elf_howto_table[(int) R_390_GOTPLT64];
302 case BFD_RELOC_390_GOTPLTENT:
303 return &elf_howto_table[(int) R_390_GOTPLTENT];
304 case BFD_RELOC_390_PLTOFF16:
305 return &elf_howto_table[(int) R_390_PLTOFF16];
306 case BFD_RELOC_390_PLTOFF32:
307 return &elf_howto_table[(int) R_390_PLTOFF32];
308 case BFD_RELOC_390_PLTOFF64:
309 return &elf_howto_table[(int) R_390_PLTOFF64];
310 case BFD_RELOC_390_TLS_LOAD:
311 return &elf_howto_table[(int) R_390_TLS_LOAD];
312 case BFD_RELOC_390_TLS_GDCALL:
313 return &elf_howto_table[(int) R_390_TLS_GDCALL];
314 case BFD_RELOC_390_TLS_LDCALL:
315 return &elf_howto_table[(int) R_390_TLS_LDCALL];
316 case BFD_RELOC_390_TLS_GD64:
317 return &elf_howto_table[(int) R_390_TLS_GD64];
318 case BFD_RELOC_390_TLS_GOTIE12:
319 return &elf_howto_table[(int) R_390_TLS_GOTIE12];
320 case BFD_RELOC_390_TLS_GOTIE64:
321 return &elf_howto_table[(int) R_390_TLS_GOTIE64];
322 case BFD_RELOC_390_TLS_LDM64:
323 return &elf_howto_table[(int) R_390_TLS_LDM64];
324 case BFD_RELOC_390_TLS_IE64:
325 return &elf_howto_table[(int) R_390_TLS_IE64];
326 case BFD_RELOC_390_TLS_IEENT:
327 return &elf_howto_table[(int) R_390_TLS_IEENT];
328 case BFD_RELOC_390_TLS_LE64:
329 return &elf_howto_table[(int) R_390_TLS_LE64];
330 case BFD_RELOC_390_TLS_LDO64:
331 return &elf_howto_table[(int) R_390_TLS_LDO64];
332 case BFD_RELOC_390_TLS_DTPMOD:
333 return &elf_howto_table[(int) R_390_TLS_DTPMOD];
334 case BFD_RELOC_390_TLS_DTPOFF:
335 return &elf_howto_table[(int) R_390_TLS_DTPOFF];
336 case BFD_RELOC_390_TLS_TPOFF:
337 return &elf_howto_table[(int) R_390_TLS_TPOFF];
338 case BFD_RELOC_VTABLE_INHERIT:
339 return &elf64_s390_vtinherit_howto;
340 case BFD_RELOC_VTABLE_ENTRY:
341 return &elf64_s390_vtentry_howto;
348 /* We need to use ELF64_R_TYPE so we have our own copy of this function,
349 and elf64-s390.c has its own copy. */
352 elf_s390_info_to_howto (abfd, cache_ptr, dst)
353 bfd *abfd ATTRIBUTE_UNUSED;
355 Elf_Internal_Rela *dst;
357 switch (ELF64_R_TYPE(dst->r_info))
359 case R_390_GNU_VTINHERIT:
360 cache_ptr->howto = &elf64_s390_vtinherit_howto;
363 case R_390_GNU_VTENTRY:
364 cache_ptr->howto = &elf64_s390_vtentry_howto;
368 BFD_ASSERT (ELF64_R_TYPE(dst->r_info) < (unsigned int) R_390_max);
369 cache_ptr->howto = &elf_howto_table[ELF64_R_TYPE(dst->r_info)];
373 /* A relocation function which doesn't do anything. */
374 static bfd_reloc_status_type
375 s390_tls_reloc (abfd, reloc_entry, symbol, data, input_section,
376 output_bfd, error_message)
377 bfd *abfd ATTRIBUTE_UNUSED;
378 arelent *reloc_entry;
379 asymbol *symbol ATTRIBUTE_UNUSED;
380 PTR data ATTRIBUTE_UNUSED;
381 asection *input_section;
383 char **error_message ATTRIBUTE_UNUSED;
386 reloc_entry->address += input_section->output_offset;
391 elf_s390_is_local_label_name (abfd, name)
395 if (name[0] == '.' && (name[1] == 'X' || name[1] == 'L'))
398 return _bfd_elf_is_local_label_name (abfd, name);
401 /* Functions for the 390 ELF linker. */
403 /* The name of the dynamic interpreter. This is put in the .interp
406 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
408 /* The size in bytes of the first entry in the procedure linkage table. */
409 #define PLT_FIRST_ENTRY_SIZE 32
410 /* The size in bytes of an entry in the procedure linkage table. */
411 #define PLT_ENTRY_SIZE 32
413 #define GOT_ENTRY_SIZE 8
415 /* The first three entries in a procedure linkage table are reserved,
416 and the initial contents are unimportant (we zero them out).
417 Subsequent entries look like this. See the SVR4 ABI 386
418 supplement to see how this works. */
420 /* For the s390, simple addr offset can only be 0 - 4096.
421 To use the full 16777216 TB address space, several instructions
422 are needed to load an address in a register and execute
423 a branch( or just saving the address)
425 Furthermore, only r 0 and 1 are free to use!!! */
427 /* The first 3 words in the GOT are then reserved.
428 Word 0 is the address of the dynamic table.
429 Word 1 is a pointer to a structure describing the object
430 Word 2 is used to point to the loader entry address.
432 The code for PLT entries looks like this:
434 The GOT holds the address in the PLT to be executed.
435 The loader then gets:
436 24(15) = Pointer to the structure describing the object.
437 28(15) = Offset in symbol table
438 The loader must then find the module where the function is
439 and insert the address in the GOT.
441 PLT1: LARL 1,<fn>@GOTENT # 6 bytes Load address of GOT entry in r1
442 LG 1,0(1) # 6 bytes Load address from GOT in r1
443 BCR 15,1 # 2 bytes Jump to address
444 RET1: BASR 1,0 # 2 bytes Return from GOT 1st time
445 LGF 1,12(1) # 6 bytes Load offset in symbl table in r1
446 BRCL 15,-x # 6 bytes Jump to start of PLT
447 .long ? # 4 bytes offset into symbol table
449 Total = 32 bytes per PLT entry
450 Fixup at offset 2: relative address to GOT entry
451 Fixup at offset 22: relative branch to PLT0
452 Fixup at offset 28: 32 bit offset into symbol table
454 A 32 bit offset into the symbol table is enough. It allows for symbol
455 tables up to a size of 2 gigabyte. A single dynamic object (the main
456 program, any shared library) is limited to 4GB in size and I want to see
457 the program that manages to have a symbol table of more than 2 GB with a
458 total size of at max 4 GB. */
460 #define PLT_ENTRY_WORD0 (bfd_vma) 0xc0100000
461 #define PLT_ENTRY_WORD1 (bfd_vma) 0x0000e310
462 #define PLT_ENTRY_WORD2 (bfd_vma) 0x10000004
463 #define PLT_ENTRY_WORD3 (bfd_vma) 0x07f10d10
464 #define PLT_ENTRY_WORD4 (bfd_vma) 0xe310100c
465 #define PLT_ENTRY_WORD5 (bfd_vma) 0x0014c0f4
466 #define PLT_ENTRY_WORD6 (bfd_vma) 0x00000000
467 #define PLT_ENTRY_WORD7 (bfd_vma) 0x00000000
469 /* The first PLT entry pushes the offset into the symbol table
470 from R1 onto the stack at 8(15) and the loader object info
471 at 12(15), loads the loader address in R1 and jumps to it. */
473 /* The first entry in the PLT:
476 STG 1,56(15) # r1 contains the offset into the symbol table
477 LARL 1,_GLOBAL_OFFSET_TABLE # load address of global offset table
478 MVC 48(8,15),8(1) # move loader ino (object struct address) to stack
479 LG 1,16(1) # get entry address of loader
480 BCR 15,1 # jump to loader
482 Fixup at offset 8: relative address to start of GOT. */
484 #define PLT_FIRST_ENTRY_WORD0 (bfd_vma) 0xe310f038
485 #define PLT_FIRST_ENTRY_WORD1 (bfd_vma) 0x0024c010
486 #define PLT_FIRST_ENTRY_WORD2 (bfd_vma) 0x00000000
487 #define PLT_FIRST_ENTRY_WORD3 (bfd_vma) 0xd207f030
488 #define PLT_FIRST_ENTRY_WORD4 (bfd_vma) 0x1008e310
489 #define PLT_FIRST_ENTRY_WORD5 (bfd_vma) 0x10100004
490 #define PLT_FIRST_ENTRY_WORD6 (bfd_vma) 0x07f10700
491 #define PLT_FIRST_ENTRY_WORD7 (bfd_vma) 0x07000700
493 /* The s390 linker needs to keep track of the number of relocs that it
494 decides to copy as dynamic relocs in check_relocs for each symbol.
495 This is so that it can later discard them if they are found to be
496 unnecessary. We store the information in a field extending the
497 regular ELF linker hash table. */
499 struct elf_s390_dyn_relocs
501 struct elf_s390_dyn_relocs *next;
503 /* The input section of the reloc. */
506 /* Total number of relocs copied for the input section. */
509 /* Number of pc-relative relocs copied for the input section. */
510 bfd_size_type pc_count;
513 /* s390 ELF linker hash entry. */
515 struct elf_s390_link_hash_entry
517 struct elf_link_hash_entry elf;
519 /* Track dynamic relocs copied for this symbol. */
520 struct elf_s390_dyn_relocs *dyn_relocs;
522 /* Number of GOTPLT references for a function. */
523 bfd_signed_vma gotplt_refcount;
525 #define GOT_UNKNOWN 0
529 #define GOT_TLS_IE_NLT 3
530 unsigned char tls_type;
533 #define elf_s390_hash_entry(ent) \
534 ((struct elf_s390_link_hash_entry *)(ent))
536 struct elf_s390_obj_tdata
538 struct elf_obj_tdata root;
540 /* tls_type for each local got entry. */
541 char *local_got_tls_type;
544 #define elf_s390_tdata(abfd) \
545 ((struct elf_s390_obj_tdata *) (abfd)->tdata.any)
547 #define elf_s390_local_got_tls_type(abfd) \
548 (elf_s390_tdata (abfd)->local_got_tls_type)
551 elf_s390_mkobject (abfd)
554 bfd_size_type amt = sizeof (struct elf_s390_obj_tdata);
555 abfd->tdata.any = bfd_zalloc (abfd, amt);
556 if (abfd->tdata.any == NULL)
562 elf_s390_object_p (abfd)
565 /* Allocate our special target data. */
566 struct elf_s390_obj_tdata *new_tdata;
567 bfd_size_type amt = sizeof (struct elf_s390_obj_tdata);
568 new_tdata = bfd_zalloc (abfd, amt);
569 if (new_tdata == NULL)
571 new_tdata->root = *abfd->tdata.elf_obj_data;
572 abfd->tdata.any = new_tdata;
573 /* Set the right machine number for an s390 elf32 file. */
574 return bfd_default_set_arch_mach (abfd, bfd_arch_s390, bfd_mach_s390_64);
577 /* s390 ELF linker hash table. */
579 struct elf_s390_link_hash_table
581 struct elf_link_hash_table elf;
583 /* Short-cuts to get to dynamic linker sections. */
593 bfd_signed_vma refcount;
597 /* Small local sym to section mapping cache. */
598 struct sym_sec_cache sym_sec;
601 /* Get the s390 ELF linker hash table from a link_info structure. */
603 #define elf_s390_hash_table(p) \
604 ((struct elf_s390_link_hash_table *) ((p)->hash))
606 /* Create an entry in an s390 ELF linker hash table. */
608 static struct bfd_hash_entry *
609 link_hash_newfunc (entry, table, string)
610 struct bfd_hash_entry *entry;
611 struct bfd_hash_table *table;
614 /* Allocate the structure if it has not already been allocated by a
618 entry = bfd_hash_allocate (table,
619 sizeof (struct elf_s390_link_hash_entry));
624 /* Call the allocation method of the superclass. */
625 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
628 struct elf_s390_link_hash_entry *eh;
630 eh = (struct elf_s390_link_hash_entry *) entry;
631 eh->dyn_relocs = NULL;
632 eh->gotplt_refcount = 0;
633 eh->tls_type = GOT_UNKNOWN;
639 /* Create an s390 ELF linker hash table. */
641 static struct bfd_link_hash_table *
642 elf_s390_link_hash_table_create (abfd)
645 struct elf_s390_link_hash_table *ret;
646 bfd_size_type amt = sizeof (struct elf_s390_link_hash_table);
648 ret = (struct elf_s390_link_hash_table *) bfd_malloc (amt);
652 if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc))
665 ret->tls_ldm_got.refcount = 0;
666 ret->sym_sec.abfd = NULL;
668 return &ret->elf.root;
671 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
672 shortcuts to them in our hash table. */
675 create_got_section (dynobj, info)
677 struct bfd_link_info *info;
679 struct elf_s390_link_hash_table *htab;
681 if (! _bfd_elf_create_got_section (dynobj, info))
684 htab = elf_s390_hash_table (info);
685 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
686 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
687 if (!htab->sgot || !htab->sgotplt)
690 htab->srelgot = bfd_make_section (dynobj, ".rela.got");
691 if (htab->srelgot == NULL
692 || ! bfd_set_section_flags (dynobj, htab->srelgot,
693 (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
694 | SEC_IN_MEMORY | SEC_LINKER_CREATED
696 || ! bfd_set_section_alignment (dynobj, htab->srelgot, 3))
701 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
702 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
706 elf_s390_create_dynamic_sections (dynobj, info)
708 struct bfd_link_info *info;
710 struct elf_s390_link_hash_table *htab;
712 htab = elf_s390_hash_table (info);
713 if (!htab->sgot && !create_got_section (dynobj, info))
716 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
719 htab->splt = bfd_get_section_by_name (dynobj, ".plt");
720 htab->srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
721 htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
723 htab->srelbss = bfd_get_section_by_name (dynobj, ".rela.bss");
725 if (!htab->splt || !htab->srelplt || !htab->sdynbss
726 || (!info->shared && !htab->srelbss))
732 /* Copy the extra info we tack onto an elf_link_hash_entry. */
735 elf_s390_copy_indirect_symbol (bed, dir, ind)
736 struct elf_backend_data *bed;
737 struct elf_link_hash_entry *dir, *ind;
739 struct elf_s390_link_hash_entry *edir, *eind;
741 edir = (struct elf_s390_link_hash_entry *) dir;
742 eind = (struct elf_s390_link_hash_entry *) ind;
744 if (eind->dyn_relocs != NULL)
746 if (edir->dyn_relocs != NULL)
748 struct elf_s390_dyn_relocs **pp;
749 struct elf_s390_dyn_relocs *p;
751 if (ind->root.type == bfd_link_hash_indirect)
754 /* Add reloc counts against the weak sym to the strong sym
755 list. Merge any entries against the same section. */
756 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
758 struct elf_s390_dyn_relocs *q;
760 for (q = edir->dyn_relocs; q != NULL; q = q->next)
761 if (q->sec == p->sec)
763 q->pc_count += p->pc_count;
764 q->count += p->count;
771 *pp = edir->dyn_relocs;
774 edir->dyn_relocs = eind->dyn_relocs;
775 eind->dyn_relocs = NULL;
778 if (ind->root.type == bfd_link_hash_indirect
779 && dir->got.refcount <= 0)
781 edir->tls_type = eind->tls_type;
782 eind->tls_type = GOT_UNKNOWN;
785 _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
789 elf_s390_tls_transition (info, r_type, is_local)
790 struct bfd_link_info *info;
802 return R_390_TLS_LE64;
803 return R_390_TLS_IE64;
804 case R_390_TLS_GOTIE64:
806 return R_390_TLS_LE64;
807 return R_390_TLS_GOTIE64;
808 case R_390_TLS_LDM64:
809 return R_390_TLS_LE64;
815 /* Look through the relocs for a section during the first phase, and
816 allocate space in the global offset table or procedure linkage
820 elf_s390_check_relocs (abfd, info, sec, relocs)
822 struct bfd_link_info *info;
824 const Elf_Internal_Rela *relocs;
826 struct elf_s390_link_hash_table *htab;
827 Elf_Internal_Shdr *symtab_hdr;
828 struct elf_link_hash_entry **sym_hashes;
829 const Elf_Internal_Rela *rel;
830 const Elf_Internal_Rela *rel_end;
832 bfd_signed_vma *local_got_refcounts;
833 int tls_type, old_tls_type;
835 if (info->relocateable)
838 htab = elf_s390_hash_table (info);
839 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
840 sym_hashes = elf_sym_hashes (abfd);
841 local_got_refcounts = elf_local_got_refcounts (abfd);
845 rel_end = relocs + sec->reloc_count;
846 for (rel = relocs; rel < rel_end; rel++)
849 unsigned long r_symndx;
850 struct elf_link_hash_entry *h;
852 r_symndx = ELF64_R_SYM (rel->r_info);
854 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
856 (*_bfd_error_handler) (_("%s: bad symbol index: %d"),
857 bfd_archive_filename (abfd),
862 if (r_symndx < symtab_hdr->sh_info)
865 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
867 /* Create got section and local_got_refcounts array if they
869 r_type = elf_s390_tls_transition (info,
870 ELF64_R_TYPE (rel->r_info),
883 case R_390_GOTPLTENT:
885 case R_390_TLS_GOTIE12:
886 case R_390_TLS_GOTIE64:
887 case R_390_TLS_IEENT:
889 case R_390_TLS_LDM64:
891 && local_got_refcounts == NULL)
895 size = symtab_hdr->sh_info;
896 size *= (sizeof (bfd_signed_vma) + sizeof(char));
897 local_got_refcounts = ((bfd_signed_vma *)
898 bfd_zalloc (abfd, size));
899 if (local_got_refcounts == NULL)
901 elf_local_got_refcounts (abfd) = local_got_refcounts;
902 elf_s390_local_got_tls_type (abfd)
903 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
911 if (htab->sgot == NULL)
913 if (htab->elf.dynobj == NULL)
914 htab->elf.dynobj = abfd;
915 if (!create_got_section (htab->elf.dynobj, info))
927 /* Got is created, nothing to be done. */
937 /* This symbol requires a procedure linkage table entry. We
938 actually build the entry in adjust_dynamic_symbol,
939 because this might be a case of linking PIC code which is
940 never referenced by a dynamic object, in which case we
941 don't need to generate a procedure linkage table entry
944 /* If this is a local symbol, we resolve it directly without
945 creating a procedure linkage table entry. */
948 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
949 h->plt.refcount += 1;
957 case R_390_GOTPLTENT:
958 /* This symbol requires either a procedure linkage table entry
959 or an entry in the local got. We actually build the entry
960 in adjust_dynamic_symbol because whether this is really a
961 global reference can change and with it the fact if we have
962 to create a plt entry or a local got entry. To be able to
963 make a once global symbol a local one we have to keep track
964 of the number of gotplt references that exist for this
968 ((struct elf_s390_link_hash_entry *) h)->gotplt_refcount++;
969 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
970 h->plt.refcount += 1;
973 local_got_refcounts[r_symndx] += 1;
976 case R_390_TLS_LDM64:
977 htab->tls_ldm_got.refcount += 1;
981 case R_390_TLS_GOTIE12:
982 case R_390_TLS_GOTIE64:
983 case R_390_TLS_IEENT:
985 info->flags |= DF_STATIC_TLS;
994 /* This symbol requires a global offset table entry. */
1002 tls_type = GOT_NORMAL;
1004 case R_390_TLS_GD64:
1005 tls_type = GOT_TLS_GD;
1007 case R_390_TLS_IE64:
1008 case R_390_TLS_GOTIE64:
1009 tls_type = GOT_TLS_IE;
1011 case R_390_TLS_GOTIE12:
1012 case R_390_TLS_IEENT:
1013 tls_type = GOT_TLS_IE_NLT;
1019 h->got.refcount += 1;
1020 old_tls_type = elf_s390_hash_entry(h)->tls_type;
1024 local_got_refcounts[r_symndx] += 1;
1025 old_tls_type = elf_s390_local_got_tls_type (abfd) [r_symndx];
1027 /* If a TLS symbol is accessed using IE at least once,
1028 there is no point to use dynamic model for it. */
1029 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN)
1031 if (old_tls_type == GOT_NORMAL || tls_type == GOT_NORMAL)
1033 (*_bfd_error_handler)
1034 (_("%s: `%s' accessed both as normal and thread local symbol"),
1035 bfd_archive_filename (abfd), h->root.root.string);
1038 if (old_tls_type > tls_type)
1039 tls_type = old_tls_type;
1042 if (old_tls_type != tls_type)
1045 elf_s390_hash_entry (h)->tls_type = tls_type;
1047 elf_s390_local_got_tls_type (abfd) [r_symndx] = tls_type;
1050 if (r_type != R_390_TLS_IE64)
1054 case R_390_TLS_LE64:
1057 info->flags |= DF_STATIC_TLS;
1069 if (h != NULL && !info->shared)
1071 /* If this reloc is in a read-only section, we might
1072 need a copy reloc. We can't check reliably at this
1073 stage whether the section is read-only, as input
1074 sections have not yet been mapped to output sections.
1075 Tentatively set the flag for now, and correct in
1076 adjust_dynamic_symbol. */
1077 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
1079 /* We may need a .plt entry if the function this reloc
1080 refers to is in a shared lib. */
1081 h->plt.refcount += 1;
1084 /* If we are creating a shared library, and this is a reloc
1085 against a global symbol, or a non PC relative reloc
1086 against a local symbol, then we need to copy the reloc
1087 into the shared library. However, if we are linking with
1088 -Bsymbolic, we do not need to copy a reloc against a
1089 global symbol which is defined in an object we are
1090 including in the link (i.e., DEF_REGULAR is set). At
1091 this point we have not seen all the input files, so it is
1092 possible that DEF_REGULAR is not set now but will be set
1093 later (it is never cleared). In case of a weak definition,
1094 DEF_REGULAR may be cleared later by a strong definition in
1095 a shared library. We account for that possibility below by
1096 storing information in the relocs_copied field of the hash
1097 table entry. A similar situation occurs when creating
1098 shared libraries and symbol visibility changes render the
1101 If on the other hand, we are creating an executable, we
1102 may need to keep relocations for symbols satisfied by a
1103 dynamic library if we manage to avoid copy relocs for the
1106 && (sec->flags & SEC_ALLOC) != 0
1107 && ((ELF64_R_TYPE (rel->r_info) != R_390_PC16
1108 && ELF64_R_TYPE (rel->r_info) != R_390_PC16DBL
1109 && ELF64_R_TYPE (rel->r_info) != R_390_PC32
1110 && ELF64_R_TYPE (rel->r_info) != R_390_PC32DBL
1111 && ELF64_R_TYPE (rel->r_info) != R_390_PC64)
1113 && (! info->symbolic
1114 || h->root.type == bfd_link_hash_defweak
1115 || (h->elf_link_hash_flags
1116 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1118 && (sec->flags & SEC_ALLOC) != 0
1120 && (h->root.type == bfd_link_hash_defweak
1121 || (h->elf_link_hash_flags
1122 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
1124 struct elf_s390_dyn_relocs *p;
1125 struct elf_s390_dyn_relocs **head;
1127 /* We must copy these reloc types into the output file.
1128 Create a reloc section in dynobj and make room for
1135 name = (bfd_elf_string_from_elf_section
1137 elf_elfheader (abfd)->e_shstrndx,
1138 elf_section_data (sec)->rel_hdr.sh_name));
1142 if (strncmp (name, ".rela", 5) != 0
1143 || strcmp (bfd_get_section_name (abfd, sec),
1146 (*_bfd_error_handler)
1147 (_("%s: bad relocation section name `%s\'"),
1148 bfd_archive_filename (abfd), name);
1151 if (htab->elf.dynobj == NULL)
1152 htab->elf.dynobj = abfd;
1154 dynobj = htab->elf.dynobj;
1155 sreloc = bfd_get_section_by_name (dynobj, name);
1160 sreloc = bfd_make_section (dynobj, name);
1161 flags = (SEC_HAS_CONTENTS | SEC_READONLY
1162 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1163 if ((sec->flags & SEC_ALLOC) != 0)
1164 flags |= SEC_ALLOC | SEC_LOAD;
1166 || ! bfd_set_section_flags (dynobj, sreloc, flags)
1167 || ! bfd_set_section_alignment (dynobj, sreloc, 3))
1170 elf_section_data (sec)->sreloc = sreloc;
1173 /* If this is a global symbol, we count the number of
1174 relocations we need for this symbol. */
1177 head = &((struct elf_s390_link_hash_entry *) h)->dyn_relocs;
1181 /* Track dynamic relocs needed for local syms too.
1182 We really need local syms available to do this
1186 s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1191 head = ((struct elf_s390_dyn_relocs **)
1192 &elf_section_data (s)->local_dynrel);
1196 if (p == NULL || p->sec != sec)
1198 bfd_size_type amt = sizeof *p;
1199 p = ((struct elf_s390_dyn_relocs *)
1200 bfd_alloc (htab->elf.dynobj, amt));
1211 if (ELF64_R_TYPE (rel->r_info) == R_390_PC16
1212 || ELF64_R_TYPE (rel->r_info) == R_390_PC16DBL
1213 || ELF64_R_TYPE (rel->r_info) == R_390_PC32
1214 || ELF64_R_TYPE (rel->r_info) == R_390_PC32DBL
1215 || ELF64_R_TYPE (rel->r_info) == R_390_PC64)
1220 /* This relocation describes the C++ object vtable hierarchy.
1221 Reconstruct it for later use during GC. */
1222 case R_390_GNU_VTINHERIT:
1223 if (!_bfd_elf64_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1227 /* This relocation describes which C++ vtable entries are actually
1228 used. Record for later use during GC. */
1229 case R_390_GNU_VTENTRY:
1230 if (!_bfd_elf64_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1242 /* Return the section that should be marked against GC for a given
1246 elf_s390_gc_mark_hook (sec, info, rel, h, sym)
1248 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1249 Elf_Internal_Rela *rel;
1250 struct elf_link_hash_entry *h;
1251 Elf_Internal_Sym *sym;
1255 switch (ELF64_R_TYPE (rel->r_info))
1257 case R_390_GNU_VTINHERIT:
1258 case R_390_GNU_VTENTRY:
1262 switch (h->root.type)
1264 case bfd_link_hash_defined:
1265 case bfd_link_hash_defweak:
1266 return h->root.u.def.section;
1268 case bfd_link_hash_common:
1269 return h->root.u.c.p->section;
1277 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1282 /* Update the got entry reference counts for the section being removed. */
1285 elf_s390_gc_sweep_hook (abfd, info, sec, relocs)
1287 struct bfd_link_info *info;
1289 const Elf_Internal_Rela *relocs;
1291 Elf_Internal_Shdr *symtab_hdr;
1292 struct elf_link_hash_entry **sym_hashes;
1293 bfd_signed_vma *local_got_refcounts;
1294 const Elf_Internal_Rela *rel, *relend;
1296 elf_section_data (sec)->local_dynrel = NULL;
1298 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1299 sym_hashes = elf_sym_hashes (abfd);
1300 local_got_refcounts = elf_local_got_refcounts (abfd);
1302 relend = relocs + sec->reloc_count;
1303 for (rel = relocs; rel < relend; rel++)
1305 unsigned long r_symndx;
1306 unsigned int r_type;
1307 struct elf_link_hash_entry *h = NULL;
1309 r_symndx = ELF64_R_SYM (rel->r_info);
1310 if (r_symndx >= symtab_hdr->sh_info)
1312 struct elf_s390_link_hash_entry *eh;
1313 struct elf_s390_dyn_relocs **pp;
1314 struct elf_s390_dyn_relocs *p;
1316 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1317 eh = (struct elf_s390_link_hash_entry *) h;
1319 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1322 /* Everything must go for SEC. */
1328 r_type = ELF64_R_TYPE (rel->r_info);
1329 r_type = elf_s390_tls_transition (info, r_type, h != NULL);
1332 case R_390_TLS_LDM64:
1333 if (elf_s390_hash_table (info)->tls_ldm_got.refcount > 0)
1334 elf_s390_hash_table (info)->tls_ldm_got.refcount -= 1;
1337 case R_390_TLS_GD64:
1338 case R_390_TLS_IE64:
1339 case R_390_TLS_GOTIE12:
1340 case R_390_TLS_GOTIE64:
1341 case R_390_TLS_IEENT:
1346 case R_390_GOTOFF16:
1347 case R_390_GOTOFF32:
1348 case R_390_GOTOFF64:
1350 case R_390_GOTPCDBL:
1354 if (h->got.refcount > 0)
1355 h->got.refcount -= 1;
1357 else if (local_got_refcounts != NULL)
1359 if (local_got_refcounts[r_symndx] > 0)
1360 local_got_refcounts[r_symndx] -= 1;
1378 case R_390_PLT16DBL:
1380 case R_390_PLT32DBL:
1382 case R_390_PLTOFF16:
1383 case R_390_PLTOFF32:
1384 case R_390_PLTOFF64:
1387 if (h->plt.refcount > 0)
1388 h->plt.refcount -= 1;
1392 case R_390_GOTPLT12:
1393 case R_390_GOTPLT16:
1394 case R_390_GOTPLT32:
1395 case R_390_GOTPLT64:
1396 case R_390_GOTPLTENT:
1399 if (h->plt.refcount > 0)
1401 ((struct elf_s390_link_hash_entry *) h)->gotplt_refcount--;
1402 h->plt.refcount -= 1;
1405 else if (local_got_refcounts != NULL)
1407 if (local_got_refcounts[r_symndx] > 0)
1408 local_got_refcounts[r_symndx] -= 1;
1420 /* Make sure we emit a GOT entry if the symbol was supposed to have a PLT
1421 entry but we found we will not create any. Called when we find we will
1422 not have any PLT for this symbol, by for example
1423 elf_s390_adjust_dynamic_symbol when we're doing a proper dynamic link,
1424 or elf_s390_size_dynamic_sections if no dynamic sections will be
1425 created (we're only linking static objects). */
1428 elf_s390_adjust_gotplt (h)
1429 struct elf_s390_link_hash_entry *h;
1431 if (h->elf.root.type == bfd_link_hash_warning)
1432 h = (struct elf_s390_link_hash_entry *) h->elf.root.u.i.link;
1434 if (h->gotplt_refcount <= 0)
1437 /* We simply add the number of gotplt references to the number
1438 * of got references for this symbol. */
1439 h->elf.got.refcount += h->gotplt_refcount;
1440 h->gotplt_refcount = -1;
1443 /* Adjust a symbol defined by a dynamic object and referenced by a
1444 regular object. The current definition is in some section of the
1445 dynamic object, but we're not including those sections. We have to
1446 change the definition to something the rest of the link can
1450 elf_s390_adjust_dynamic_symbol (info, h)
1451 struct bfd_link_info *info;
1452 struct elf_link_hash_entry *h;
1454 struct elf_s390_link_hash_table *htab;
1455 struct elf_s390_link_hash_entry * eh;
1456 struct elf_s390_dyn_relocs *p;
1458 unsigned int power_of_two;
1460 /* If this is a function, put it in the procedure linkage table. We
1461 will fill in the contents of the procedure linkage table later
1462 (although we could actually do it here). */
1463 if (h->type == STT_FUNC
1464 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
1466 if (h->plt.refcount <= 0
1468 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
1469 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0
1470 && h->root.type != bfd_link_hash_undefweak
1471 && h->root.type != bfd_link_hash_undefined))
1473 /* This case can occur if we saw a PLT32 reloc in an input
1474 file, but the symbol was never referred to by a dynamic
1475 object, or if all references were garbage collected. In
1476 such a case, we don't actually need to build a procedure
1477 linkage table, and we can just do a PC32 reloc instead. */
1478 h->plt.offset = (bfd_vma) -1;
1479 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1480 elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1486 /* It's possible that we incorrectly decided a .plt reloc was
1487 needed for an R_390_PC32 reloc to a non-function sym in
1488 check_relocs. We can't decide accurately between function and
1489 non-function syms in check-relocs; Objects loaded later in
1490 the link may change h->type. So fix it now. */
1491 h->plt.offset = (bfd_vma) -1;
1493 /* If this is a weak symbol, and there is a real definition, the
1494 processor independent code will have arranged for us to see the
1495 real definition first, and we can just use the same value. */
1496 if (h->weakdef != NULL)
1498 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1499 || h->weakdef->root.type == bfd_link_hash_defweak);
1500 h->root.u.def.section = h->weakdef->root.u.def.section;
1501 h->root.u.def.value = h->weakdef->root.u.def.value;
1505 /* This is a reference to a symbol defined by a dynamic object which
1506 is not a function. */
1508 /* If we are creating a shared library, we must presume that the
1509 only references to the symbol are via the global offset table.
1510 For such cases we need not do anything here; the relocations will
1511 be handled correctly by relocate_section. */
1515 /* If there are no references to this symbol that do not use the
1516 GOT, we don't need to generate a copy reloc. */
1517 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1520 /* If -z nocopyreloc was given, we won't generate them either. */
1521 if (info->nocopyreloc)
1523 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1527 eh = (struct elf_s390_link_hash_entry *) h;
1528 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1530 s = p->sec->output_section;
1531 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1535 /* If we didn't find any dynamic relocs in read-only sections, then
1536 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1539 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1543 /* We must allocate the symbol in our .dynbss section, which will
1544 become part of the .bss section of the executable. There will be
1545 an entry for this symbol in the .dynsym section. The dynamic
1546 object will contain position independent code, so all references
1547 from the dynamic object to this symbol will go through the global
1548 offset table. The dynamic linker will use the .dynsym entry to
1549 determine the address it must put in the global offset table, so
1550 both the dynamic object and the regular object will refer to the
1551 same memory location for the variable. */
1553 htab = elf_s390_hash_table (info);
1555 /* We must generate a R_390_COPY reloc to tell the dynamic linker to
1556 copy the initial value out of the dynamic object and into the
1557 runtime process image. */
1558 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1560 htab->srelbss->_raw_size += sizeof (Elf64_External_Rela);
1561 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1564 /* We need to figure out the alignment required for this symbol. I
1565 have no idea how ELF linkers handle this. */
1566 power_of_two = bfd_log2 (h->size);
1567 if (power_of_two > 3)
1570 /* Apply the required alignment. */
1572 s->_raw_size = BFD_ALIGN (s->_raw_size, (bfd_size_type) (1 << power_of_two));
1573 if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
1575 if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
1579 /* Define the symbol as being at this point in the section. */
1580 h->root.u.def.section = s;
1581 h->root.u.def.value = s->_raw_size;
1583 /* Increment the section size to make room for the symbol. */
1584 s->_raw_size += h->size;
1589 /* This is the condition under which elf_s390_finish_dynamic_symbol
1590 will be called from elflink.h. If elflink.h doesn't call our
1591 finish_dynamic_symbol routine, we'll need to do something about
1592 initializing any .plt and .got entries in elf_s390_relocate_section. */
1593 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1595 && ((INFO)->shared \
1596 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1597 && ((H)->dynindx != -1 \
1598 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1600 /* Allocate space in .plt, .got and associated reloc sections for
1604 allocate_dynrelocs (h, inf)
1605 struct elf_link_hash_entry *h;
1608 struct bfd_link_info *info;
1609 struct elf_s390_link_hash_table *htab;
1610 struct elf_s390_link_hash_entry *eh;
1611 struct elf_s390_dyn_relocs *p;
1613 if (h->root.type == bfd_link_hash_indirect)
1616 if (h->root.type == bfd_link_hash_warning)
1617 /* When warning symbols are created, they **replace** the "real"
1618 entry in the hash table, thus we never get to see the real
1619 symbol in a hash traversal. So look at it now. */
1620 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1622 info = (struct bfd_link_info *) inf;
1623 htab = elf_s390_hash_table (info);
1625 if (htab->elf.dynamic_sections_created
1626 && h->plt.refcount > 0
1627 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1628 || h->root.type != bfd_link_hash_undefweak))
1630 /* Make sure this symbol is output as a dynamic symbol.
1631 Undefined weak syms won't yet be marked as dynamic. */
1632 if (h->dynindx == -1
1633 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1635 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
1640 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
1642 asection *s = htab->splt;
1644 /* If this is the first .plt entry, make room for the special
1646 if (s->_raw_size == 0)
1647 s->_raw_size += PLT_FIRST_ENTRY_SIZE;
1649 h->plt.offset = s->_raw_size;
1651 /* If this symbol is not defined in a regular file, and we are
1652 not generating a shared library, then set the symbol to this
1653 location in the .plt. This is required to make function
1654 pointers compare as equal between the normal executable and
1655 the shared library. */
1657 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1659 h->root.u.def.section = s;
1660 h->root.u.def.value = h->plt.offset;
1663 /* Make room for this entry. */
1664 s->_raw_size += PLT_ENTRY_SIZE;
1666 /* We also need to make an entry in the .got.plt section, which
1667 will be placed in the .got section by the linker script. */
1668 htab->sgotplt->_raw_size += GOT_ENTRY_SIZE;
1670 /* We also need to make an entry in the .rela.plt section. */
1671 htab->srelplt->_raw_size += sizeof (Elf64_External_Rela);
1675 h->plt.offset = (bfd_vma) -1;
1676 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1677 elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1682 h->plt.offset = (bfd_vma) -1;
1683 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1684 elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1687 /* If R_390_TLS_{IE64,GOTIE64,GOTIE12,IEENT} symbol is now local to
1688 the binary, we can optimize a bit. IE64 and GOTIE64 get converted
1689 to R_390_TLS_LE64 requiring no TLS entry. For GOTIE12 and IEENT
1690 we can save the dynamic TLS relocation. */
1691 if (h->got.refcount > 0
1694 && elf_s390_hash_entry(h)->tls_type >= GOT_TLS_IE)
1696 if (elf_s390_hash_entry(h)->tls_type == GOT_TLS_IE_NLT)
1697 /* For the GOTIE access without a literal pool entry the offset has
1698 to be stored somewhere. The immediate value in the instruction
1699 is not bit enough so the value is stored in the got. */
1701 h->got.offset = htab->sgot->_raw_size;
1702 htab->sgot->_raw_size += GOT_ENTRY_SIZE;
1705 h->got.offset = (bfd_vma) -1;
1707 else if (h->got.refcount > 0)
1711 int tls_type = elf_s390_hash_entry(h)->tls_type;
1713 /* Make sure this symbol is output as a dynamic symbol.
1714 Undefined weak syms won't yet be marked as dynamic. */
1715 if (h->dynindx == -1
1716 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1718 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
1723 h->got.offset = s->_raw_size;
1724 s->_raw_size += GOT_ENTRY_SIZE;
1725 /* R_390_TLS_GD64 needs 2 consecutive GOT slots. */
1726 if (tls_type == GOT_TLS_GD)
1727 s->_raw_size += GOT_ENTRY_SIZE;
1728 dyn = htab->elf.dynamic_sections_created;
1729 /* R_390_TLS_IE64 needs one dynamic relocation,
1730 R_390_TLS_GD64 needs one if local symbol and two if global. */
1731 if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1732 || tls_type >= GOT_TLS_IE)
1733 htab->srelgot->_raw_size += sizeof (Elf64_External_Rela);
1734 else if (tls_type == GOT_TLS_GD)
1735 htab->srelgot->_raw_size += 2 * sizeof (Elf64_External_Rela);
1736 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1737 || h->root.type != bfd_link_hash_undefweak)
1739 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1740 htab->srelgot->_raw_size += sizeof (Elf64_External_Rela);
1743 h->got.offset = (bfd_vma) -1;
1745 eh = (struct elf_s390_link_hash_entry *) h;
1746 if (eh->dyn_relocs == NULL)
1749 /* In the shared -Bsymbolic case, discard space allocated for
1750 dynamic pc-relative relocs against symbols which turn out to be
1751 defined in regular objects. For the normal shared case, discard
1752 space for pc-relative relocs that have become local due to symbol
1753 visibility changes. */
1757 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1758 && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1761 struct elf_s390_dyn_relocs **pp;
1763 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1765 p->count -= p->pc_count;
1774 /* Also discard relocs on undefined weak syms with non-default
1776 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1777 && h->root.type == bfd_link_hash_undefweak)
1778 eh->dyn_relocs = NULL;
1782 /* For the non-shared case, discard space for relocs against
1783 symbols which turn out to need copy relocs or are not
1786 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
1787 && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
1788 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1789 || (htab->elf.dynamic_sections_created
1790 && (h->root.type == bfd_link_hash_undefweak
1791 || h->root.type == bfd_link_hash_undefined))))
1793 /* Make sure this symbol is output as a dynamic symbol.
1794 Undefined weak syms won't yet be marked as dynamic. */
1795 if (h->dynindx == -1
1796 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
1798 if (! bfd_elf64_link_record_dynamic_symbol (info, h))
1802 /* If that succeeded, we know we'll be keeping all the
1804 if (h->dynindx != -1)
1808 eh->dyn_relocs = NULL;
1813 /* Finally, allocate space. */
1814 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1816 asection *sreloc = elf_section_data (p->sec)->sreloc;
1817 sreloc->_raw_size += p->count * sizeof (Elf64_External_Rela);
1823 /* Find any dynamic relocs that apply to read-only sections. */
1826 readonly_dynrelocs (h, inf)
1827 struct elf_link_hash_entry *h;
1830 struct elf_s390_link_hash_entry *eh;
1831 struct elf_s390_dyn_relocs *p;
1833 if (h->root.type == bfd_link_hash_warning)
1834 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1836 eh = (struct elf_s390_link_hash_entry *) h;
1837 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1839 asection *s = p->sec->output_section;
1841 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1843 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1845 info->flags |= DF_TEXTREL;
1847 /* Not an error, just cut short the traversal. */
1854 /* Set the sizes of the dynamic sections. */
1857 elf_s390_size_dynamic_sections (output_bfd, info)
1858 bfd *output_bfd ATTRIBUTE_UNUSED;
1859 struct bfd_link_info *info;
1861 struct elf_s390_link_hash_table *htab;
1867 htab = elf_s390_hash_table (info);
1868 dynobj = htab->elf.dynobj;
1872 if (htab->elf.dynamic_sections_created)
1874 /* Set the contents of the .interp section to the interpreter. */
1877 s = bfd_get_section_by_name (dynobj, ".interp");
1880 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1881 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1885 /* Set up .got offsets for local syms, and space for local dynamic
1887 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1889 bfd_signed_vma *local_got;
1890 bfd_signed_vma *end_local_got;
1891 char *local_tls_type;
1892 bfd_size_type locsymcount;
1893 Elf_Internal_Shdr *symtab_hdr;
1896 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1899 for (s = ibfd->sections; s != NULL; s = s->next)
1901 struct elf_s390_dyn_relocs *p;
1903 for (p = *((struct elf_s390_dyn_relocs **)
1904 &elf_section_data (s)->local_dynrel);
1908 if (!bfd_is_abs_section (p->sec)
1909 && bfd_is_abs_section (p->sec->output_section))
1911 /* Input section has been discarded, either because
1912 it is a copy of a linkonce section or due to
1913 linker script /DISCARD/, so we'll be discarding
1916 else if (p->count != 0)
1918 srela = elf_section_data (p->sec)->sreloc;
1919 srela->_raw_size += p->count * sizeof (Elf64_External_Rela);
1920 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1921 info->flags |= DF_TEXTREL;
1926 local_got = elf_local_got_refcounts (ibfd);
1930 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1931 locsymcount = symtab_hdr->sh_info;
1932 end_local_got = local_got + locsymcount;
1933 local_tls_type = elf_s390_local_got_tls_type (ibfd);
1935 srela = htab->srelgot;
1936 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1940 *local_got = s->_raw_size;
1941 s->_raw_size += GOT_ENTRY_SIZE;
1942 if (*local_tls_type == GOT_TLS_GD)
1943 s->_raw_size += GOT_ENTRY_SIZE;
1945 srela->_raw_size += sizeof (Elf64_External_Rela);
1948 *local_got = (bfd_vma) -1;
1952 if (htab->tls_ldm_got.refcount > 0)
1954 /* Allocate 2 got entries and 1 dynamic reloc for R_390_TLS_LDM64
1956 htab->tls_ldm_got.offset = htab->sgot->_raw_size;
1957 htab->sgot->_raw_size += 2 * GOT_ENTRY_SIZE;
1958 htab->srelgot->_raw_size += sizeof (Elf64_External_Rela);
1961 htab->tls_ldm_got.offset = -1;
1963 /* Allocate global sym .plt and .got entries, and space for global
1964 sym dynamic relocs. */
1965 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
1967 /* We now have determined the sizes of the various dynamic sections.
1968 Allocate memory for them. */
1970 for (s = dynobj->sections; s != NULL; s = s->next)
1972 if ((s->flags & SEC_LINKER_CREATED) == 0)
1977 || s == htab->sgotplt)
1979 /* Strip this section if we don't need it; see the
1982 else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
1984 if (s->_raw_size != 0 && s != htab->srelplt)
1987 /* We use the reloc_count field as a counter if we need
1988 to copy relocs into the output file. */
1993 /* It's not one of our sections, so don't allocate space. */
1997 if (s->_raw_size == 0)
1999 /* If we don't need this section, strip it from the
2000 output file. This is to handle .rela.bss and
2001 .rela.plt. We must create it in
2002 create_dynamic_sections, because it must be created
2003 before the linker maps input sections to output
2004 sections. The linker does that before
2005 adjust_dynamic_symbol is called, and it is that
2006 function which decides whether anything needs to go
2007 into these sections. */
2009 _bfd_strip_section_from_output (info, s);
2013 /* Allocate memory for the section contents. We use bfd_zalloc
2014 here in case unused entries are not reclaimed before the
2015 section's contents are written out. This should not happen,
2016 but this way if it does, we get a R_390_NONE reloc instead
2018 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
2019 if (s->contents == NULL)
2023 if (htab->elf.dynamic_sections_created)
2025 /* Add some entries to the .dynamic section. We fill in the
2026 values later, in elf_s390_finish_dynamic_sections, but we
2027 must add the entries now so that we get the correct size for
2028 the .dynamic section. The DT_DEBUG entry is filled in by the
2029 dynamic linker and used by the debugger. */
2030 #define add_dynamic_entry(TAG, VAL) \
2031 bfd_elf64_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
2035 if (!add_dynamic_entry (DT_DEBUG, 0))
2039 if (htab->splt->_raw_size != 0)
2041 if (!add_dynamic_entry (DT_PLTGOT, 0)
2042 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2043 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2044 || !add_dynamic_entry (DT_JMPREL, 0))
2050 if (!add_dynamic_entry (DT_RELA, 0)
2051 || !add_dynamic_entry (DT_RELASZ, 0)
2052 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
2055 /* If any dynamic relocs apply to a read-only section,
2056 then we need a DT_TEXTREL entry. */
2057 if ((info->flags & DF_TEXTREL) == 0)
2058 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2061 if ((info->flags & DF_TEXTREL) != 0)
2063 if (!add_dynamic_entry (DT_TEXTREL, 0))
2068 #undef add_dynamic_entry
2073 /* Return the base VMA address which should be subtracted from real addresses
2074 when resolving @dtpoff relocation.
2075 This is PT_TLS segment p_vaddr. */
2079 struct bfd_link_info *info;
2081 /* If tls_segment is NULL, we should have signalled an error already. */
2082 if (elf_hash_table (info)->tls_segment == NULL)
2084 return elf_hash_table (info)->tls_segment->start;
2087 /* Return the relocation value for @tpoff relocation
2088 if STT_TLS virtual address is ADDRESS. */
2091 tpoff (info, address)
2092 struct bfd_link_info *info;
2095 struct elf_link_tls_segment *tls_segment
2096 = elf_hash_table (info)->tls_segment;
2098 /* If tls_segment is NULL, we should have signalled an error already. */
2099 if (tls_segment == NULL)
2101 return (align_power (tls_segment->size, tls_segment->align)
2102 + tls_segment->start - address);
2105 /* Complain if TLS instruction relocation is against an invalid
2109 invalid_tls_insn (input_bfd, input_section, rel)
2111 asection *input_section;
2112 Elf_Internal_Rela *rel;
2114 reloc_howto_type *howto;
2116 howto = elf_howto_table + ELF64_R_TYPE (rel->r_info);
2117 (*_bfd_error_handler)
2118 (_("%s(%s+0x%lx): invalid instruction for TLS relocation %s"),
2119 bfd_archive_filename (input_bfd),
2120 bfd_get_section_name (input_bfd, input_section),
2121 (long) rel->r_offset,
2125 /* Relocate a 390 ELF section. */
2128 elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
2129 contents, relocs, local_syms, local_sections)
2131 struct bfd_link_info *info;
2133 asection *input_section;
2135 Elf_Internal_Rela *relocs;
2136 Elf_Internal_Sym *local_syms;
2137 asection **local_sections;
2139 struct elf_s390_link_hash_table *htab;
2140 Elf_Internal_Shdr *symtab_hdr;
2141 struct elf_link_hash_entry **sym_hashes;
2142 bfd_vma *local_got_offsets;
2143 Elf_Internal_Rela *rel;
2144 Elf_Internal_Rela *relend;
2146 if (info->relocateable)
2149 htab = elf_s390_hash_table (info);
2150 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2151 sym_hashes = elf_sym_hashes (input_bfd);
2152 local_got_offsets = elf_local_got_offsets (input_bfd);
2155 relend = relocs + input_section->reloc_count;
2156 for (; rel < relend; rel++)
2158 unsigned int r_type;
2159 reloc_howto_type *howto;
2160 unsigned long r_symndx;
2161 struct elf_link_hash_entry *h;
2162 Elf_Internal_Sym *sym;
2166 bfd_boolean unresolved_reloc;
2167 bfd_reloc_status_type r;
2170 r_type = ELF64_R_TYPE (rel->r_info);
2171 if (r_type == (int) R_390_GNU_VTINHERIT
2172 || r_type == (int) R_390_GNU_VTENTRY)
2174 if (r_type >= (int) R_390_max)
2176 bfd_set_error (bfd_error_bad_value);
2180 howto = elf_howto_table + r_type;
2181 r_symndx = ELF64_R_SYM (rel->r_info);
2183 /* This is a final link. */
2187 unresolved_reloc = FALSE;
2188 if (r_symndx < symtab_hdr->sh_info)
2190 sym = local_syms + r_symndx;
2191 sec = local_sections[r_symndx];
2192 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
2196 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2197 while (h->root.type == bfd_link_hash_indirect
2198 || h->root.type == bfd_link_hash_warning)
2199 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2201 if (h->root.type == bfd_link_hash_defined
2202 || h->root.type == bfd_link_hash_defweak)
2204 sec = h->root.u.def.section;
2205 if (sec->output_section == NULL)
2207 /* Set a flag that will be cleared later if we find a
2208 relocation value for this symbol. output_section
2209 is typically NULL for symbols satisfied by a shared
2211 unresolved_reloc = TRUE;
2215 relocation = (h->root.u.def.value
2216 + sec->output_section->vma
2217 + sec->output_offset);
2219 else if (h->root.type == bfd_link_hash_undefweak)
2221 else if (info->shared
2222 && !info->no_undefined
2223 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2227 if (! ((*info->callbacks->undefined_symbol)
2228 (info, h->root.root.string, input_bfd,
2229 input_section, rel->r_offset,
2230 (!info->shared || info->no_undefined
2231 || ELF_ST_VISIBILITY (h->other)))))
2239 case R_390_GOTPLT12:
2240 case R_390_GOTPLT16:
2241 case R_390_GOTPLT32:
2242 case R_390_GOTPLT64:
2243 case R_390_GOTPLTENT:
2244 /* There are three cases for a GOTPLT relocation. 1) The
2245 relocation is against the jump slot entry of a plt that
2246 will get emitted to the output file. 2) The relocation
2247 is against the jump slot of a plt entry that has been
2248 removed. elf_s390_adjust_gotplt has created a GOT entry
2249 as replacement. 3) The relocation is against a local symbol.
2250 Cases 2) and 3) are the same as the GOT relocation code
2251 so we just have to test for case 1 and fall through for
2253 if (h != NULL && h->plt.offset != (bfd_vma) -1)
2258 Current offset - size first entry / entry size. */
2259 plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) /
2262 /* Offset in GOT is PLT index plus GOT headers(3) times 4,
2264 relocation = (plt_index + 3) * GOT_ENTRY_SIZE;
2265 unresolved_reloc = FALSE;
2267 if (r_type == R_390_GOTPLTENT)
2268 relocation += htab->sgot->output_section->vma;
2278 /* Relocation is to the entry for this symbol in the global
2280 if (htab->sgot == NULL)
2287 off = h->got.offset;
2288 dyn = htab->elf.dynamic_sections_created;
2289 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, h)
2293 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
2294 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
2295 || (ELF_ST_VISIBILITY (h->other)
2296 && h->root.type == bfd_link_hash_undefweak))
2298 /* This is actually a static link, or it is a
2299 -Bsymbolic link and the symbol is defined
2300 locally, or the symbol was forced to be local
2301 because of a version file. We must initialize
2302 this entry in the global offset table. Since the
2303 offset must always be a multiple of 2, we use the
2304 least significant bit to record whether we have
2305 initialized it already.
2307 When doing a dynamic link, we create a .rel.got
2308 relocation entry to initialize the value. This
2309 is done in the finish_dynamic_symbol routine. */
2314 bfd_put_64 (output_bfd, relocation,
2315 htab->sgot->contents + off);
2320 unresolved_reloc = FALSE;
2324 if (local_got_offsets == NULL)
2327 off = local_got_offsets[r_symndx];
2329 /* The offset must always be a multiple of 8. We use
2330 the least significant bit to record whether we have
2331 already generated the necessary reloc. */
2336 bfd_put_64 (output_bfd, relocation,
2337 htab->sgot->contents + off);
2342 Elf_Internal_Rela outrel;
2349 outrel.r_offset = (htab->sgot->output_section->vma
2350 + htab->sgot->output_offset
2352 outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2353 outrel.r_addend = relocation;
2355 loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
2356 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2359 local_got_offsets[r_symndx] |= 1;
2363 if (off >= (bfd_vma) -2)
2366 relocation = htab->sgot->output_offset + off;
2368 /* For @GOTENT the relocation is against the offset between
2369 the instruction and the symbols entry in the GOT and not
2370 between the start of the GOT and the symbols entry. We
2371 add the vma of the GOT to get the correct value. */
2372 if ( r_type == R_390_GOTENT
2373 || r_type == R_390_GOTPLTENT)
2374 relocation += htab->sgot->output_section->vma;
2378 case R_390_GOTOFF16:
2379 case R_390_GOTOFF32:
2380 case R_390_GOTOFF64:
2381 /* Relocation is relative to the start of the global offset
2384 /* Note that sgot->output_offset is not involved in this
2385 calculation. We always want the start of .got. If we
2386 defined _GLOBAL_OFFSET_TABLE in a different way, as is
2387 permitted by the ABI, we might have to change this
2389 relocation -= htab->sgot->output_section->vma;
2393 case R_390_GOTPCDBL:
2394 /* Use global offset table as symbol value. */
2395 relocation = htab->sgot->output_section->vma;
2396 unresolved_reloc = FALSE;
2399 case R_390_PLT16DBL:
2401 case R_390_PLT32DBL:
2403 /* Relocation is to the entry for this symbol in the
2404 procedure linkage table. */
2406 /* Resolve a PLT32 reloc against a local symbol directly,
2407 without using the procedure linkage table. */
2411 if (h->plt.offset == (bfd_vma) -1
2412 || htab->splt == NULL)
2414 /* We didn't make a PLT entry for this symbol. This
2415 happens when statically linking PIC code, or when
2416 using -Bsymbolic. */
2420 relocation = (htab->splt->output_section->vma
2421 + htab->splt->output_offset
2423 unresolved_reloc = FALSE;
2426 case R_390_PLTOFF16:
2427 case R_390_PLTOFF32:
2428 case R_390_PLTOFF64:
2429 /* Relocation is to the entry for this symbol in the
2430 procedure linkage table relative to the start of the GOT. */
2432 /* For local symbols or if we didn't make a PLT entry for
2433 this symbol resolve the symbol directly. */
2435 || h->plt.offset == (bfd_vma) -1
2436 || htab->splt == NULL)
2438 relocation -= htab->sgot->output_section->vma;
2442 relocation = (htab->splt->output_section->vma
2443 + htab->splt->output_offset
2445 - htab->sgot->output_section->vma);
2446 unresolved_reloc = FALSE;
2458 /* r_symndx will be zero only for relocs against symbols
2459 from removed linkonce sections, or sections discarded by
2462 || (input_section->flags & SEC_ALLOC) == 0)
2467 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2468 || h->root.type != bfd_link_hash_undefweak)
2469 && ((r_type != R_390_PC16
2470 && r_type != R_390_PC16DBL
2471 && r_type != R_390_PC32
2472 && r_type != R_390_PC32DBL
2473 && r_type != R_390_PC64)
2476 && (! info->symbolic
2477 || (h->elf_link_hash_flags
2478 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2482 && (h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
2483 && (((h->elf_link_hash_flags
2484 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2485 && (h->elf_link_hash_flags
2486 & ELF_LINK_HASH_DEF_REGULAR) == 0)
2487 || h->root.type == bfd_link_hash_undefweak
2488 || h->root.type == bfd_link_hash_undefined)))
2490 Elf_Internal_Rela outrel;
2491 bfd_boolean skip, relocate;
2495 /* When generating a shared object, these relocations
2496 are copied into the output file to be resolved at run
2502 _bfd_elf_section_offset (output_bfd, info, input_section,
2504 if (outrel.r_offset == (bfd_vma) -1)
2506 else if (outrel.r_offset == (bfd_vma) -2)
2507 skip = TRUE, relocate = TRUE;
2509 outrel.r_offset += (input_section->output_section->vma
2510 + input_section->output_offset);
2513 memset (&outrel, 0, sizeof outrel);
2516 && (r_type == R_390_PC16
2517 || r_type == R_390_PC16DBL
2518 || r_type == R_390_PC32
2519 || r_type == R_390_PC32DBL
2520 || r_type == R_390_PC64
2523 || (h->elf_link_hash_flags
2524 & ELF_LINK_HASH_DEF_REGULAR) == 0))
2526 outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
2527 outrel.r_addend = rel->r_addend;
2531 /* This symbol is local, or marked to become local. */
2533 outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2534 outrel.r_addend = relocation + rel->r_addend;
2537 sreloc = elf_section_data (input_section)->sreloc;
2541 loc = sreloc->contents;
2542 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2543 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2545 /* If this reloc is against an external symbol, we do
2546 not want to fiddle with the addend. Otherwise, we
2547 need to include the symbol value so that it becomes
2548 an addend for the dynamic reloc. */
2555 /* Relocations for tls literal pool entries. */
2556 case R_390_TLS_IE64:
2559 Elf_Internal_Rela outrel;
2563 outrel.r_offset = rel->r_offset
2564 + input_section->output_section->vma
2565 + input_section->output_offset;
2566 outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2567 sreloc = elf_section_data (input_section)->sreloc;
2570 loc = sreloc->contents;
2571 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2572 bfd_elf64_swap_reloc_out (output_bfd, &outrel, loc);
2576 case R_390_TLS_GD64:
2577 case R_390_TLS_GOTIE64:
2578 r_type = elf_s390_tls_transition (info, r_type, h == NULL);
2579 tls_type = GOT_UNKNOWN;
2580 if (h == NULL && local_got_offsets)
2581 tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
2584 tls_type = elf_s390_hash_entry(h)->tls_type;
2585 if (!info->shared && h->dynindx == -1 && tls_type >= GOT_TLS_IE)
2586 r_type = R_390_TLS_LE64;
2588 if (r_type == R_390_TLS_GD64 && tls_type >= GOT_TLS_IE)
2589 r_type = R_390_TLS_IE64;
2591 if (r_type == R_390_TLS_LE64)
2593 /* This relocation gets optimized away by the local exec
2594 access optimization. */
2595 BFD_ASSERT (! unresolved_reloc);
2596 bfd_put_64 (output_bfd, -tpoff (info, relocation),
2597 contents + rel->r_offset);
2601 if (htab->sgot == NULL)
2605 off = h->got.offset;
2608 if (local_got_offsets == NULL)
2611 off = local_got_offsets[r_symndx];
2620 Elf_Internal_Rela outrel;
2624 if (htab->srelgot == NULL)
2627 outrel.r_offset = (htab->sgot->output_section->vma
2628 + htab->sgot->output_offset + off);
2630 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2631 if (r_type == R_390_TLS_GD64)
2632 dr_type = R_390_TLS_DTPMOD;
2634 dr_type = R_390_TLS_TPOFF;
2635 if (dr_type == R_390_TLS_TPOFF && indx == 0)
2636 outrel.r_addend = relocation - dtpoff_base (info);
2638 outrel.r_addend = 0;
2639 outrel.r_info = ELF64_R_INFO (indx, dr_type);
2640 loc = htab->srelgot->contents;
2641 loc += htab->srelgot->reloc_count++
2642 * sizeof (Elf64_External_Rela);
2643 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2645 if (r_type == R_390_TLS_GD64)
2649 BFD_ASSERT (! unresolved_reloc);
2650 bfd_put_64 (output_bfd,
2651 relocation - dtpoff_base (info),
2652 htab->sgot->contents + off + GOT_ENTRY_SIZE);
2656 outrel.r_info = ELF64_R_INFO (indx, R_390_TLS_DTPOFF);
2657 outrel.r_offset += GOT_ENTRY_SIZE;
2658 outrel.r_addend = 0;
2659 htab->srelgot->reloc_count++;
2660 loc += sizeof (Elf64_External_Rela);
2661 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2668 local_got_offsets[r_symndx] |= 1;
2671 if (off >= (bfd_vma) -2)
2673 if (r_type == ELF64_R_TYPE (rel->r_info))
2675 relocation = htab->sgot->output_offset + off;
2676 if (r_type == R_390_TLS_IE64 || r_type == R_390_TLS_IEENT)
2677 relocation += htab->sgot->output_section->vma;
2678 unresolved_reloc = FALSE;
2682 bfd_put_64 (output_bfd, htab->sgot->output_offset + off,
2683 contents + rel->r_offset);
2688 case R_390_TLS_GOTIE12:
2689 case R_390_TLS_IEENT:
2692 if (local_got_offsets == NULL)
2694 off = local_got_offsets[r_symndx];
2696 goto emit_tls_relocs;
2700 off = h->got.offset;
2701 tls_type = elf_s390_hash_entry(h)->tls_type;
2702 if (info->shared || h->dynindx != -1 || tls_type < GOT_TLS_IE)
2703 goto emit_tls_relocs;
2706 if (htab->sgot == NULL)
2709 BFD_ASSERT (! unresolved_reloc);
2710 bfd_put_64 (output_bfd, -tpoff (info, relocation),
2711 htab->sgot->contents + off);
2712 relocation = htab->sgot->output_offset + off;
2713 if (r_type == R_390_TLS_IEENT)
2714 relocation += htab->sgot->output_section->vma;
2715 unresolved_reloc = FALSE;
2718 case R_390_TLS_LDM64:
2720 /* The literal pool entry this relocation refers to gets ignored
2721 by the optimized code of the local exec model. Do nothing
2722 and the value will turn out zero. */
2725 if (htab->sgot == NULL)
2728 off = htab->tls_ldm_got.offset;
2733 Elf_Internal_Rela outrel;
2736 if (htab->srelgot == NULL)
2739 outrel.r_offset = (htab->sgot->output_section->vma
2740 + htab->sgot->output_offset + off);
2742 bfd_put_64 (output_bfd, 0,
2743 htab->sgot->contents + off + GOT_ENTRY_SIZE);
2744 outrel.r_info = ELF64_R_INFO (0, R_390_TLS_DTPMOD);
2745 outrel.r_addend = 0;
2746 loc = htab->srelgot->contents;
2747 loc += htab->srelgot->reloc_count++
2748 * sizeof (Elf64_External_Rela);
2749 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2750 htab->tls_ldm_got.offset |= 1;
2752 relocation = htab->sgot->output_offset + off;
2753 unresolved_reloc = FALSE;
2756 case R_390_TLS_LE64:
2759 /* Linking a shared library with non-fpic code requires
2760 a R_390_TLS_TPOFF relocation. */
2761 Elf_Internal_Rela outrel;
2766 outrel.r_offset = rel->r_offset
2767 + input_section->output_section->vma
2768 + input_section->output_offset;
2769 if (h != NULL && h->dynindx != -1)
2773 outrel.r_info = ELF64_R_INFO (indx, R_390_TLS_TPOFF);
2775 outrel.r_addend = relocation - dtpoff_base (info);
2777 outrel.r_addend = 0;
2778 sreloc = elf_section_data (input_section)->sreloc;
2781 loc = sreloc->contents;
2782 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2783 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2787 BFD_ASSERT (! unresolved_reloc);
2788 bfd_put_64 (output_bfd, -tpoff (info, relocation),
2789 contents + rel->r_offset);
2793 case R_390_TLS_LDO64:
2794 if (info->shared || (input_section->flags & SEC_CODE) == 0)
2795 relocation -= dtpoff_base (info);
2797 /* When converting LDO to LE, we must negate. */
2798 relocation = -tpoff (info, relocation);
2801 /* Relocations for tls instructions. */
2802 case R_390_TLS_LOAD:
2803 case R_390_TLS_GDCALL:
2804 case R_390_TLS_LDCALL:
2805 tls_type = GOT_UNKNOWN;
2806 if (h == NULL && local_got_offsets)
2807 tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
2809 tls_type = elf_s390_hash_entry(h)->tls_type;
2811 if (tls_type == GOT_TLS_GD)
2814 if (r_type == R_390_TLS_LOAD)
2816 if (!info->shared && (h == NULL || h->dynindx == -1))
2818 /* IE->LE transition. Four valid cases:
2819 lg %rx,(0,%ry) -> sllg %rx,%ry,0
2820 lg %rx,(%ry,0) -> sllg %rx,%ry,0
2821 lg %rx,(%ry,%r12) -> sllg %rx,%ry,0
2822 lg %rx,(%r12,%ry) -> sllg %rx,%ry,0 */
2823 unsigned int insn0, insn1, ry;
2825 insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset);
2826 insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4);
2827 if (insn1 != 0x0004)
2828 invalid_tls_insn (input_bfd, input_section, rel);
2830 if ((insn0 & 0xff00f000) == 0xe3000000)
2831 /* lg %rx,0(%ry,0) -> sllg %rx,%ry,0 */
2832 ry = (insn0 & 0x000f0000);
2833 else if ((insn0 & 0xff0f0000) == 0xe3000000)
2834 /* lg %rx,0(0,%ry) -> sllg %rx,%ry,0 */
2835 ry = (insn0 & 0x0000f000) << 4;
2836 else if ((insn0 & 0xff00f000) == 0xe300c000)
2837 /* lg %rx,0(%ry,%r12) -> sllg %rx,%ry,0 */
2838 ry = (insn0 & 0x000f0000);
2839 else if ((insn0 & 0xff0f0000) == 0xe30c0000)
2840 /* lg %rx,0(%r12,%ry) -> sllg %rx,%ry,0 */
2841 ry = (insn0 & 0x0000f000) << 4;
2843 invalid_tls_insn (input_bfd, input_section, rel);
2844 insn0 = 0xeb000000 | (insn0 & 0x00f00000) | ry;
2846 bfd_put_32 (output_bfd, insn0, contents + rel->r_offset);
2847 bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4);
2850 else if (r_type == R_390_TLS_GDCALL)
2852 unsigned int insn0, insn1;
2854 insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset);
2855 insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4);
2856 if ((insn0 & 0xffff0000) != 0xc0e50000)
2857 invalid_tls_insn (input_bfd, input_section, rel);
2858 if (!info->shared && (h == NULL || h->dynindx == -1))
2860 /* GD->LE transition.
2861 brasl %r14,__tls_get_addr@plt -> brcl 0,. */
2867 /* GD->IE transition.
2868 brasl %r14,__tls_get_addr@plt -> lg %r2,0(%r2,%r12) */
2872 bfd_put_32 (output_bfd, insn0, contents + rel->r_offset);
2873 bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4);
2875 else if (r_type == R_390_TLS_LDCALL)
2879 unsigned int insn0, insn1;
2881 insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset);
2882 insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4);
2883 if ((insn0 & 0xffff0000) != 0xc0e50000)
2884 invalid_tls_insn (input_bfd, input_section, rel);
2885 /* LD->LE transition.
2886 brasl %r14,__tls_get_addr@plt -> brcl 0,. */
2889 bfd_put_32 (output_bfd, insn0, contents + rel->r_offset);
2890 bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4);
2899 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2900 because such sections are not SEC_ALLOC and thus ld.so will
2901 not process them. */
2902 if (unresolved_reloc
2903 && !((input_section->flags & SEC_DEBUGGING) != 0
2904 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
2905 (*_bfd_error_handler)
2906 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
2907 bfd_archive_filename (input_bfd),
2908 bfd_get_section_name (input_bfd, input_section),
2909 (long) rel->r_offset,
2910 h->root.root.string);
2912 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2913 contents, rel->r_offset,
2914 relocation, rel->r_addend);
2916 if (r != bfd_reloc_ok)
2921 name = h->root.root.string;
2924 name = bfd_elf_string_from_elf_section (input_bfd,
2925 symtab_hdr->sh_link,
2930 name = bfd_section_name (input_bfd, sec);
2933 if (r == bfd_reloc_overflow)
2936 if (! ((*info->callbacks->reloc_overflow)
2937 (info, name, howto->name, (bfd_vma) 0,
2938 input_bfd, input_section, rel->r_offset)))
2943 (*_bfd_error_handler)
2944 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
2945 bfd_archive_filename (input_bfd),
2946 bfd_get_section_name (input_bfd, input_section),
2947 (long) rel->r_offset, name, (int) r);
2956 /* Finish up dynamic symbol handling. We set the contents of various
2957 dynamic sections here. */
2960 elf_s390_finish_dynamic_symbol (output_bfd, info, h, sym)
2962 struct bfd_link_info *info;
2963 struct elf_link_hash_entry *h;
2964 Elf_Internal_Sym *sym;
2966 struct elf_s390_link_hash_table *htab;
2968 htab = elf_s390_hash_table (info);
2970 if (h->plt.offset != (bfd_vma) -1)
2974 Elf_Internal_Rela rela;
2977 /* This symbol has an entry in the procedure linkage table. Set
2980 if (h->dynindx == -1
2981 || htab->splt == NULL
2982 || htab->sgotplt == NULL
2983 || htab->srelplt == NULL)
2987 Current offset - size first entry / entry size. */
2988 plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) / PLT_ENTRY_SIZE;
2990 /* Offset in GOT is PLT index plus GOT headers(3) times 8,
2992 got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
2994 /* Fill in the blueprint of a PLT. */
2995 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD0,
2996 htab->splt->contents + h->plt.offset);
2997 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD1,
2998 htab->splt->contents + h->plt.offset + 4);
2999 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD2,
3000 htab->splt->contents + h->plt.offset + 8);
3001 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD3,
3002 htab->splt->contents + h->plt.offset + 12);
3003 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD4,
3004 htab->splt->contents + h->plt.offset + 16);
3005 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD5,
3006 htab->splt->contents + h->plt.offset + 20);
3007 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD6,
3008 htab->splt->contents + h->plt.offset + 24);
3009 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD7,
3010 htab->splt->contents + h->plt.offset + 28);
3011 /* Fixup the relative address to the GOT entry */
3012 bfd_put_32 (output_bfd,
3013 (htab->sgotplt->output_section->vma +
3014 htab->sgotplt->output_offset + got_offset
3015 - (htab->splt->output_section->vma + h->plt.offset))/2,
3016 htab->splt->contents + h->plt.offset + 2);
3017 /* Fixup the relative branch to PLT 0 */
3018 bfd_put_32 (output_bfd, - (PLT_FIRST_ENTRY_SIZE +
3019 (PLT_ENTRY_SIZE * plt_index) + 22)/2,
3020 htab->splt->contents + h->plt.offset + 24);
3021 /* Fixup offset into symbol table */
3022 bfd_put_32 (output_bfd, plt_index * sizeof (Elf64_External_Rela),
3023 htab->splt->contents + h->plt.offset + 28);
3025 /* Fill in the entry in the global offset table.
3026 Points to instruction after GOT offset. */
3027 bfd_put_64 (output_bfd,
3028 (htab->splt->output_section->vma
3029 + htab->splt->output_offset
3032 htab->sgotplt->contents + got_offset);
3034 /* Fill in the entry in the .rela.plt section. */
3035 rela.r_offset = (htab->sgotplt->output_section->vma
3036 + htab->sgotplt->output_offset
3038 rela.r_info = ELF64_R_INFO (h->dynindx, R_390_JMP_SLOT);
3040 loc = htab->srelplt->contents + plt_index * sizeof (Elf64_External_Rela);
3041 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3043 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3045 /* Mark the symbol as undefined, rather than as defined in
3046 the .plt section. Leave the value alone. This is a clue
3047 for the dynamic linker, to make function pointer
3048 comparisons work between an application and shared
3050 sym->st_shndx = SHN_UNDEF;
3054 if (h->got.offset != (bfd_vma) -1
3055 && elf_s390_hash_entry(h)->tls_type != GOT_TLS_GD
3056 && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE
3057 && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE_NLT)
3059 Elf_Internal_Rela rela;
3062 /* This symbol has an entry in the global offset table. Set it
3064 if (htab->sgot == NULL || htab->srelgot == NULL)
3067 rela.r_offset = (htab->sgot->output_section->vma
3068 + htab->sgot->output_offset
3069 + (h->got.offset &~ (bfd_vma) 1));
3071 /* If this is a static link, or it is a -Bsymbolic link and the
3072 symbol is defined locally or was forced to be local because
3073 of a version file, we just want to emit a RELATIVE reloc.
3074 The entry in the global offset table will already have been
3075 initialized in the relocate_section function. */
3079 || (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL))
3080 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3082 BFD_ASSERT((h->got.offset & 1) != 0);
3083 rela.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
3084 rela.r_addend = (h->root.u.def.value
3085 + h->root.u.def.section->output_section->vma
3086 + h->root.u.def.section->output_offset);
3090 BFD_ASSERT((h->got.offset & 1) == 0);
3091 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgot->contents + h->got.offset);
3092 rela.r_info = ELF64_R_INFO (h->dynindx, R_390_GLOB_DAT);
3096 loc = htab->srelgot->contents;
3097 loc += htab->srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
3098 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3101 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
3103 Elf_Internal_Rela rela;
3106 /* This symbols needs a copy reloc. Set it up. */
3108 if (h->dynindx == -1
3109 || (h->root.type != bfd_link_hash_defined
3110 && h->root.type != bfd_link_hash_defweak)
3111 || htab->srelbss == NULL)
3114 rela.r_offset = (h->root.u.def.value
3115 + h->root.u.def.section->output_section->vma
3116 + h->root.u.def.section->output_offset);
3117 rela.r_info = ELF64_R_INFO (h->dynindx, R_390_COPY);
3119 loc = htab->srelbss->contents;
3120 loc += htab->srelbss->reloc_count++ * sizeof (Elf64_External_Rela);
3121 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3124 /* Mark some specially defined symbols as absolute. */
3125 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3126 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
3127 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3128 sym->st_shndx = SHN_ABS;
3133 /* Used to decide how to sort relocs in an optimal manner for the
3134 dynamic linker, before writing them out. */
3136 static enum elf_reloc_type_class
3137 elf_s390_reloc_type_class (rela)
3138 const Elf_Internal_Rela *rela;
3140 switch ((int) ELF64_R_TYPE (rela->r_info))
3142 case R_390_RELATIVE:
3143 return reloc_class_relative;
3144 case R_390_JMP_SLOT:
3145 return reloc_class_plt;
3147 return reloc_class_copy;
3149 return reloc_class_normal;
3153 /* Finish up the dynamic sections. */
3156 elf_s390_finish_dynamic_sections (output_bfd, info)
3158 struct bfd_link_info *info;
3160 struct elf_s390_link_hash_table *htab;
3164 htab = elf_s390_hash_table (info);
3165 dynobj = htab->elf.dynobj;
3166 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3168 if (htab->elf.dynamic_sections_created)
3170 Elf64_External_Dyn *dyncon, *dynconend;
3172 if (sdyn == NULL || htab->sgot == NULL)
3175 dyncon = (Elf64_External_Dyn *) sdyn->contents;
3176 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3177 for (; dyncon < dynconend; dyncon++)
3179 Elf_Internal_Dyn dyn;
3182 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3190 dyn.d_un.d_ptr = htab->sgot->output_section->vma;
3194 dyn.d_un.d_ptr = htab->srelplt->output_section->vma;
3198 s = htab->srelplt->output_section;
3199 if (s->_cooked_size != 0)
3200 dyn.d_un.d_val = s->_cooked_size;
3202 dyn.d_un.d_val = s->_raw_size;
3206 /* The procedure linkage table relocs (DT_JMPREL) should
3207 not be included in the overall relocs (DT_RELA).
3208 Therefore, we override the DT_RELASZ entry here to
3209 make it not include the JMPREL relocs. Since the
3210 linker script arranges for .rela.plt to follow all
3211 other relocation sections, we don't have to worry
3212 about changing the DT_RELA entry. */
3213 s = htab->srelplt->output_section;
3214 if (s->_cooked_size != 0)
3215 dyn.d_un.d_val -= s->_cooked_size;
3217 dyn.d_un.d_val -= s->_raw_size;
3221 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3224 /* Fill in the special first entry in the procedure linkage table. */
3225 if (htab->splt && htab->splt->_raw_size > 0)
3227 /* fill in blueprint for plt 0 entry */
3228 bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD0,
3229 htab->splt->contents );
3230 bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD1,
3231 htab->splt->contents +4 );
3232 bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD3,
3233 htab->splt->contents +12 );
3234 bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD4,
3235 htab->splt->contents +16 );
3236 bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD5,
3237 htab->splt->contents +20 );
3238 bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD6,
3239 htab->splt->contents + 24);
3240 bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD7,
3241 htab->splt->contents + 28 );
3242 /* Fixup relative address to start of GOT */
3243 bfd_put_32 (output_bfd,
3244 (htab->sgotplt->output_section->vma +
3245 htab->sgotplt->output_offset
3246 - htab->splt->output_section->vma - 6)/2,
3247 htab->splt->contents + 8);
3249 elf_section_data (htab->splt->output_section)
3250 ->this_hdr.sh_entsize = PLT_ENTRY_SIZE;
3255 /* Fill in the first three entries in the global offset table. */
3256 if (htab->sgotplt->_raw_size > 0)
3258 bfd_put_64 (output_bfd,
3259 (sdyn == NULL ? (bfd_vma) 0
3260 : sdyn->output_section->vma + sdyn->output_offset),
3261 htab->sgotplt->contents);
3262 /* One entry for shared object struct ptr. */
3263 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 8);
3264 /* One entry for _dl_runtime_resolve. */
3265 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->sgotplt->contents + 12);
3268 elf_section_data (htab->sgot->output_section)
3269 ->this_hdr.sh_entsize = 8;
3274 /* Why was the hash table entry size definition changed from
3275 ARCH_SIZE/8 to 4? This breaks the 64 bit dynamic linker and
3276 this is the only reason for the s390_elf64_size_info structure. */
3278 const struct elf_size_info s390_elf64_size_info =
3280 sizeof (Elf64_External_Ehdr),
3281 sizeof (Elf64_External_Phdr),
3282 sizeof (Elf64_External_Shdr),
3283 sizeof (Elf64_External_Rel),
3284 sizeof (Elf64_External_Rela),
3285 sizeof (Elf64_External_Sym),
3286 sizeof (Elf64_External_Dyn),
3287 sizeof (Elf_External_Note),
3288 8, /* hash-table entry size. */
3289 1, /* internal relocations per external relocations. */
3290 64, /* arch_size. */
3291 3, /* log_file_align. */
3292 ELFCLASS64, EV_CURRENT,
3293 bfd_elf64_write_out_phdrs,
3294 bfd_elf64_write_shdrs_and_ehdr,
3295 bfd_elf64_write_relocs,
3296 bfd_elf64_swap_symbol_in,
3297 bfd_elf64_swap_symbol_out,
3298 bfd_elf64_slurp_reloc_table,
3299 bfd_elf64_slurp_symbol_table,
3300 bfd_elf64_swap_dyn_in,
3301 bfd_elf64_swap_dyn_out,
3302 bfd_elf64_swap_reloc_in,
3303 bfd_elf64_swap_reloc_out,
3304 bfd_elf64_swap_reloca_in,
3305 bfd_elf64_swap_reloca_out
3308 #define TARGET_BIG_SYM bfd_elf64_s390_vec
3309 #define TARGET_BIG_NAME "elf64-s390"
3310 #define ELF_ARCH bfd_arch_s390
3311 #define ELF_MACHINE_CODE EM_S390
3312 #define ELF_MACHINE_ALT1 EM_S390_OLD
3313 #define ELF_MAXPAGESIZE 0x1000
3315 #define elf_backend_size_info s390_elf64_size_info
3317 #define elf_backend_can_gc_sections 1
3318 #define elf_backend_can_refcount 1
3319 #define elf_backend_want_got_plt 1
3320 #define elf_backend_plt_readonly 1
3321 #define elf_backend_want_plt_sym 0
3322 #define elf_backend_got_header_size 24
3323 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
3324 #define elf_backend_rela_normal 1
3326 #define elf_info_to_howto elf_s390_info_to_howto
3328 #define bfd_elf64_bfd_is_local_label_name elf_s390_is_local_label_name
3329 #define bfd_elf64_bfd_link_hash_table_create elf_s390_link_hash_table_create
3330 #define bfd_elf64_bfd_reloc_type_lookup elf_s390_reloc_type_lookup
3332 #define elf_backend_adjust_dynamic_symbol elf_s390_adjust_dynamic_symbol
3333 #define elf_backend_check_relocs elf_s390_check_relocs
3334 #define elf_backend_copy_indirect_symbol elf_s390_copy_indirect_symbol
3335 #define elf_backend_create_dynamic_sections elf_s390_create_dynamic_sections
3336 #define elf_backend_finish_dynamic_sections elf_s390_finish_dynamic_sections
3337 #define elf_backend_finish_dynamic_symbol elf_s390_finish_dynamic_symbol
3338 #define elf_backend_gc_mark_hook elf_s390_gc_mark_hook
3339 #define elf_backend_gc_sweep_hook elf_s390_gc_sweep_hook
3340 #define elf_backend_reloc_type_class elf_s390_reloc_type_class
3341 #define elf_backend_relocate_section elf_s390_relocate_section
3342 #define elf_backend_size_dynamic_sections elf_s390_size_dynamic_sections
3343 #define elf_backend_reloc_type_class elf_s390_reloc_type_class
3345 #define bfd_elf64_mkobject elf_s390_mkobject
3346 #define elf_backend_object_p elf_s390_object_p
3348 #include "elf64-target.h"