1 /* IBM S/390-specific support for 64-bit ELF
2 Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
3 2010, 2011, 2012 Free Software Foundation, Inc.
4 Contributed Martin Schwidefsky (schwidefsky@de.ibm.com).
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
30 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
31 from smaller values. Start with zero, widen, *then* decrement. */
32 #define MINUS_ONE (((bfd_vma)0) - 1)
34 static bfd_reloc_status_type
35 s390_tls_reloc (bfd *, arelent *, asymbol *, void *,
36 asection *, bfd *, char **);
37 static bfd_reloc_status_type
38 s390_elf_ldisp_reloc (bfd *, arelent *, asymbol *, void *,
39 asection *, bfd *, char **);
41 /* The relocation "howto" table. */
42 static reloc_howto_type elf_howto_table[] =
44 HOWTO (R_390_NONE, /* type */
46 0, /* size (0 = byte, 1 = short, 2 = long) */
48 FALSE, /* pc_relative */
50 complain_overflow_dont, /* complain_on_overflow */
51 bfd_elf_generic_reloc, /* special_function */
52 "R_390_NONE", /* name */
53 FALSE, /* partial_inplace */
56 FALSE), /* pcrel_offset */
58 HOWTO(R_390_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
59 bfd_elf_generic_reloc, "R_390_8", FALSE, 0,0x000000ff, FALSE),
60 HOWTO(R_390_12, 0, 1, 12, FALSE, 0, complain_overflow_dont,
61 bfd_elf_generic_reloc, "R_390_12", FALSE, 0,0x00000fff, FALSE),
62 HOWTO(R_390_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
63 bfd_elf_generic_reloc, "R_390_16", FALSE, 0,0x0000ffff, FALSE),
64 HOWTO(R_390_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
65 bfd_elf_generic_reloc, "R_390_32", FALSE, 0,0xffffffff, FALSE),
66 HOWTO(R_390_PC32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
67 bfd_elf_generic_reloc, "R_390_PC32", FALSE, 0,0xffffffff, TRUE),
68 HOWTO(R_390_GOT12, 0, 1, 12, FALSE, 0, complain_overflow_bitfield,
69 bfd_elf_generic_reloc, "R_390_GOT12", FALSE, 0,0x00000fff, FALSE),
70 HOWTO(R_390_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
71 bfd_elf_generic_reloc, "R_390_GOT32", FALSE, 0,0xffffffff, FALSE),
72 HOWTO(R_390_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
73 bfd_elf_generic_reloc, "R_390_PLT32", FALSE, 0,0xffffffff, TRUE),
74 HOWTO(R_390_COPY, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
75 bfd_elf_generic_reloc, "R_390_COPY", FALSE, 0,MINUS_ONE, FALSE),
76 HOWTO(R_390_GLOB_DAT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
77 bfd_elf_generic_reloc, "R_390_GLOB_DAT", FALSE, 0,MINUS_ONE, FALSE),
78 HOWTO(R_390_JMP_SLOT, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
79 bfd_elf_generic_reloc, "R_390_JMP_SLOT", FALSE, 0,MINUS_ONE, FALSE),
80 HOWTO(R_390_RELATIVE, 0, 4, 64, TRUE, 0, complain_overflow_bitfield,
81 bfd_elf_generic_reloc, "R_390_RELATIVE", FALSE, 0,MINUS_ONE, FALSE),
82 HOWTO(R_390_GOTOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
83 bfd_elf_generic_reloc, "R_390_GOTOFF32", FALSE, 0,MINUS_ONE, FALSE),
84 HOWTO(R_390_GOTPC, 0, 4, 64, TRUE, 0, complain_overflow_bitfield,
85 bfd_elf_generic_reloc, "R_390_GOTPC", FALSE, 0,MINUS_ONE, TRUE),
86 HOWTO(R_390_GOT16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
87 bfd_elf_generic_reloc, "R_390_GOT16", FALSE, 0,0x0000ffff, FALSE),
88 HOWTO(R_390_PC16, 0, 1, 16, TRUE, 0, complain_overflow_bitfield,
89 bfd_elf_generic_reloc, "R_390_PC16", FALSE, 0,0x0000ffff, TRUE),
90 HOWTO(R_390_PC16DBL, 1, 1, 16, TRUE, 0, complain_overflow_bitfield,
91 bfd_elf_generic_reloc, "R_390_PC16DBL", FALSE, 0,0x0000ffff, TRUE),
92 HOWTO(R_390_PLT16DBL, 1, 1, 16, TRUE, 0, complain_overflow_bitfield,
93 bfd_elf_generic_reloc, "R_390_PLT16DBL", FALSE, 0,0x0000ffff, TRUE),
94 HOWTO(R_390_PC32DBL, 1, 2, 32, TRUE, 0, complain_overflow_bitfield,
95 bfd_elf_generic_reloc, "R_390_PC32DBL", FALSE, 0,0xffffffff, TRUE),
96 HOWTO(R_390_PLT32DBL, 1, 2, 32, TRUE, 0, complain_overflow_bitfield,
97 bfd_elf_generic_reloc, "R_390_PLT32DBL", FALSE, 0,0xffffffff, TRUE),
98 HOWTO(R_390_GOTPCDBL, 1, 2, 32, TRUE, 0, complain_overflow_bitfield,
99 bfd_elf_generic_reloc, "R_390_GOTPCDBL", FALSE, 0,MINUS_ONE, TRUE),
100 HOWTO(R_390_64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
101 bfd_elf_generic_reloc, "R_390_64", FALSE, 0,MINUS_ONE, FALSE),
102 HOWTO(R_390_PC64, 0, 4, 64, TRUE, 0, complain_overflow_bitfield,
103 bfd_elf_generic_reloc, "R_390_PC64", FALSE, 0,MINUS_ONE, TRUE),
104 HOWTO(R_390_GOT64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
105 bfd_elf_generic_reloc, "R_390_GOT64", FALSE, 0,MINUS_ONE, FALSE),
106 HOWTO(R_390_PLT64, 0, 4, 64, TRUE, 0, complain_overflow_bitfield,
107 bfd_elf_generic_reloc, "R_390_PLT64", FALSE, 0,MINUS_ONE, TRUE),
108 HOWTO(R_390_GOTENT, 1, 2, 32, TRUE, 0, complain_overflow_bitfield,
109 bfd_elf_generic_reloc, "R_390_GOTENT", FALSE, 0,MINUS_ONE, TRUE),
110 HOWTO(R_390_GOTOFF16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
111 bfd_elf_generic_reloc, "R_390_GOTOFF16", FALSE, 0,0x0000ffff, FALSE),
112 HOWTO(R_390_GOTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
113 bfd_elf_generic_reloc, "R_390_GOTOFF64", FALSE, 0,MINUS_ONE, FALSE),
114 HOWTO(R_390_GOTPLT12, 0, 1, 12, FALSE, 0, complain_overflow_dont,
115 bfd_elf_generic_reloc, "R_390_GOTPLT12", FALSE, 0,0x00000fff, FALSE),
116 HOWTO(R_390_GOTPLT16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
117 bfd_elf_generic_reloc, "R_390_GOTPLT16", FALSE, 0,0x0000ffff, FALSE),
118 HOWTO(R_390_GOTPLT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
119 bfd_elf_generic_reloc, "R_390_GOTPLT32", FALSE, 0,0xffffffff, FALSE),
120 HOWTO(R_390_GOTPLT64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
121 bfd_elf_generic_reloc, "R_390_GOTPLT64", FALSE, 0,MINUS_ONE, FALSE),
122 HOWTO(R_390_GOTPLTENT, 1, 2, 32, TRUE, 0, complain_overflow_bitfield,
123 bfd_elf_generic_reloc, "R_390_GOTPLTENT",FALSE, 0,MINUS_ONE, TRUE),
124 HOWTO(R_390_PLTOFF16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
125 bfd_elf_generic_reloc, "R_390_PLTOFF16", FALSE, 0,0x0000ffff, FALSE),
126 HOWTO(R_390_PLTOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
127 bfd_elf_generic_reloc, "R_390_PLTOFF32", FALSE, 0,0xffffffff, FALSE),
128 HOWTO(R_390_PLTOFF64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
129 bfd_elf_generic_reloc, "R_390_PLTOFF64", FALSE, 0,MINUS_ONE, FALSE),
130 HOWTO(R_390_TLS_LOAD, 0, 0, 0, FALSE, 0, complain_overflow_dont,
131 s390_tls_reloc, "R_390_TLS_LOAD", FALSE, 0, 0, FALSE),
132 HOWTO(R_390_TLS_GDCALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
133 s390_tls_reloc, "R_390_TLS_GDCALL", FALSE, 0, 0, FALSE),
134 HOWTO(R_390_TLS_LDCALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
135 s390_tls_reloc, "R_390_TLS_LDCALL", FALSE, 0, 0, FALSE),
136 EMPTY_HOWTO (R_390_TLS_GD32), /* Empty entry for R_390_TLS_GD32. */
137 HOWTO(R_390_TLS_GD64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
138 bfd_elf_generic_reloc, "R_390_TLS_GD64", FALSE, 0, MINUS_ONE, FALSE),
139 HOWTO(R_390_TLS_GOTIE12, 0, 1, 12, FALSE, 0, complain_overflow_dont,
140 bfd_elf_generic_reloc, "R_390_TLS_GOTIE12", FALSE, 0, 0x00000fff, FALSE),
141 EMPTY_HOWTO (R_390_TLS_GOTIE32), /* Empty entry for R_390_TLS_GOTIE32. */
142 HOWTO(R_390_TLS_GOTIE64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
143 bfd_elf_generic_reloc, "R_390_TLS_GOTIE64", FALSE, 0, MINUS_ONE, FALSE),
144 EMPTY_HOWTO (R_390_TLS_LDM32), /* Empty entry for R_390_TLS_LDM32. */
145 HOWTO(R_390_TLS_LDM64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
146 bfd_elf_generic_reloc, "R_390_TLS_LDM64", FALSE, 0, MINUS_ONE, FALSE),
147 EMPTY_HOWTO (R_390_TLS_IE32), /* Empty entry for R_390_TLS_IE32. */
148 HOWTO(R_390_TLS_IE64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
149 bfd_elf_generic_reloc, "R_390_TLS_IE64", FALSE, 0, MINUS_ONE, FALSE),
150 HOWTO(R_390_TLS_IEENT, 1, 2, 32, TRUE, 0, complain_overflow_bitfield,
151 bfd_elf_generic_reloc, "R_390_TLS_IEENT", FALSE, 0, MINUS_ONE, TRUE),
152 EMPTY_HOWTO (R_390_TLS_LE32), /* Empty entry for R_390_TLS_LE32. */
153 HOWTO(R_390_TLS_LE64, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
154 bfd_elf_generic_reloc, "R_390_TLS_LE64", FALSE, 0, MINUS_ONE, FALSE),
155 EMPTY_HOWTO (R_390_TLS_LDO32), /* Empty entry for R_390_TLS_LDO32. */
156 HOWTO(R_390_TLS_LDO64, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
157 bfd_elf_generic_reloc, "R_390_TLS_LDO64", FALSE, 0, MINUS_ONE, FALSE),
158 HOWTO(R_390_TLS_DTPMOD, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
159 bfd_elf_generic_reloc, "R_390_TLS_DTPMOD", FALSE, 0, MINUS_ONE, FALSE),
160 HOWTO(R_390_TLS_DTPOFF, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
161 bfd_elf_generic_reloc, "R_390_TLS_DTPOFF", FALSE, 0, MINUS_ONE, FALSE),
162 HOWTO(R_390_TLS_TPOFF, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
163 bfd_elf_generic_reloc, "R_390_TLS_TPOFF", FALSE, 0, MINUS_ONE, FALSE),
164 HOWTO(R_390_20, 0, 2, 20, FALSE, 8, complain_overflow_dont,
165 s390_elf_ldisp_reloc, "R_390_20", FALSE, 0,0x0fffff00, FALSE),
166 HOWTO(R_390_GOT20, 0, 2, 20, FALSE, 8, complain_overflow_dont,
167 s390_elf_ldisp_reloc, "R_390_GOT20", FALSE, 0,0x0fffff00, FALSE),
168 HOWTO(R_390_GOTPLT20, 0, 2, 20, FALSE, 8, complain_overflow_dont,
169 s390_elf_ldisp_reloc, "R_390_GOTPLT20", FALSE, 0,0x0fffff00, FALSE),
170 HOWTO(R_390_TLS_GOTIE20, 0, 2, 20, FALSE, 8, complain_overflow_dont,
171 s390_elf_ldisp_reloc, "R_390_TLS_GOTIE20", FALSE, 0,0x0fffff00, FALSE),
172 HOWTO(R_390_IRELATIVE, 0, 4, 64, FALSE, 0, complain_overflow_bitfield,
173 bfd_elf_generic_reloc, "R_390_IRELATIVE", FALSE, 0, MINUS_ONE, FALSE),
177 /* GNU extension to record C++ vtable hierarchy. */
178 static reloc_howto_type elf64_s390_vtinherit_howto =
179 HOWTO (R_390_GNU_VTINHERIT, 0,4,0,FALSE,0,complain_overflow_dont, NULL, "R_390_GNU_VTINHERIT", FALSE,0, 0, FALSE);
180 static reloc_howto_type elf64_s390_vtentry_howto =
181 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);
183 static reloc_howto_type *
184 elf_s390_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
185 bfd_reloc_code_real_type code)
190 return &elf_howto_table[(int) R_390_NONE];
192 return &elf_howto_table[(int) R_390_8];
193 case BFD_RELOC_390_12:
194 return &elf_howto_table[(int) R_390_12];
196 return &elf_howto_table[(int) R_390_16];
198 return &elf_howto_table[(int) R_390_32];
200 return &elf_howto_table[(int) R_390_32];
201 case BFD_RELOC_32_PCREL:
202 return &elf_howto_table[(int) R_390_PC32];
203 case BFD_RELOC_390_GOT12:
204 return &elf_howto_table[(int) R_390_GOT12];
205 case BFD_RELOC_32_GOT_PCREL:
206 return &elf_howto_table[(int) R_390_GOT32];
207 case BFD_RELOC_390_PLT32:
208 return &elf_howto_table[(int) R_390_PLT32];
209 case BFD_RELOC_390_COPY:
210 return &elf_howto_table[(int) R_390_COPY];
211 case BFD_RELOC_390_GLOB_DAT:
212 return &elf_howto_table[(int) R_390_GLOB_DAT];
213 case BFD_RELOC_390_JMP_SLOT:
214 return &elf_howto_table[(int) R_390_JMP_SLOT];
215 case BFD_RELOC_390_RELATIVE:
216 return &elf_howto_table[(int) R_390_RELATIVE];
217 case BFD_RELOC_32_GOTOFF:
218 return &elf_howto_table[(int) R_390_GOTOFF32];
219 case BFD_RELOC_390_GOTPC:
220 return &elf_howto_table[(int) R_390_GOTPC];
221 case BFD_RELOC_390_GOT16:
222 return &elf_howto_table[(int) R_390_GOT16];
223 case BFD_RELOC_16_PCREL:
224 return &elf_howto_table[(int) R_390_PC16];
225 case BFD_RELOC_390_PC16DBL:
226 return &elf_howto_table[(int) R_390_PC16DBL];
227 case BFD_RELOC_390_PLT16DBL:
228 return &elf_howto_table[(int) R_390_PLT16DBL];
229 case BFD_RELOC_390_PC32DBL:
230 return &elf_howto_table[(int) R_390_PC32DBL];
231 case BFD_RELOC_390_PLT32DBL:
232 return &elf_howto_table[(int) R_390_PLT32DBL];
233 case BFD_RELOC_390_GOTPCDBL:
234 return &elf_howto_table[(int) R_390_GOTPCDBL];
236 return &elf_howto_table[(int) R_390_64];
237 case BFD_RELOC_64_PCREL:
238 return &elf_howto_table[(int) R_390_PC64];
239 case BFD_RELOC_390_GOT64:
240 return &elf_howto_table[(int) R_390_GOT64];
241 case BFD_RELOC_390_PLT64:
242 return &elf_howto_table[(int) R_390_PLT64];
243 case BFD_RELOC_390_GOTENT:
244 return &elf_howto_table[(int) R_390_GOTENT];
245 case BFD_RELOC_16_GOTOFF:
246 return &elf_howto_table[(int) R_390_GOTOFF16];
247 case BFD_RELOC_390_GOTOFF64:
248 return &elf_howto_table[(int) R_390_GOTOFF64];
249 case BFD_RELOC_390_GOTPLT12:
250 return &elf_howto_table[(int) R_390_GOTPLT12];
251 case BFD_RELOC_390_GOTPLT16:
252 return &elf_howto_table[(int) R_390_GOTPLT16];
253 case BFD_RELOC_390_GOTPLT32:
254 return &elf_howto_table[(int) R_390_GOTPLT32];
255 case BFD_RELOC_390_GOTPLT64:
256 return &elf_howto_table[(int) R_390_GOTPLT64];
257 case BFD_RELOC_390_GOTPLTENT:
258 return &elf_howto_table[(int) R_390_GOTPLTENT];
259 case BFD_RELOC_390_PLTOFF16:
260 return &elf_howto_table[(int) R_390_PLTOFF16];
261 case BFD_RELOC_390_PLTOFF32:
262 return &elf_howto_table[(int) R_390_PLTOFF32];
263 case BFD_RELOC_390_PLTOFF64:
264 return &elf_howto_table[(int) R_390_PLTOFF64];
265 case BFD_RELOC_390_TLS_LOAD:
266 return &elf_howto_table[(int) R_390_TLS_LOAD];
267 case BFD_RELOC_390_TLS_GDCALL:
268 return &elf_howto_table[(int) R_390_TLS_GDCALL];
269 case BFD_RELOC_390_TLS_LDCALL:
270 return &elf_howto_table[(int) R_390_TLS_LDCALL];
271 case BFD_RELOC_390_TLS_GD64:
272 return &elf_howto_table[(int) R_390_TLS_GD64];
273 case BFD_RELOC_390_TLS_GOTIE12:
274 return &elf_howto_table[(int) R_390_TLS_GOTIE12];
275 case BFD_RELOC_390_TLS_GOTIE64:
276 return &elf_howto_table[(int) R_390_TLS_GOTIE64];
277 case BFD_RELOC_390_TLS_LDM64:
278 return &elf_howto_table[(int) R_390_TLS_LDM64];
279 case BFD_RELOC_390_TLS_IE64:
280 return &elf_howto_table[(int) R_390_TLS_IE64];
281 case BFD_RELOC_390_TLS_IEENT:
282 return &elf_howto_table[(int) R_390_TLS_IEENT];
283 case BFD_RELOC_390_TLS_LE64:
284 return &elf_howto_table[(int) R_390_TLS_LE64];
285 case BFD_RELOC_390_TLS_LDO64:
286 return &elf_howto_table[(int) R_390_TLS_LDO64];
287 case BFD_RELOC_390_TLS_DTPMOD:
288 return &elf_howto_table[(int) R_390_TLS_DTPMOD];
289 case BFD_RELOC_390_TLS_DTPOFF:
290 return &elf_howto_table[(int) R_390_TLS_DTPOFF];
291 case BFD_RELOC_390_TLS_TPOFF:
292 return &elf_howto_table[(int) R_390_TLS_TPOFF];
293 case BFD_RELOC_390_20:
294 return &elf_howto_table[(int) R_390_20];
295 case BFD_RELOC_390_GOT20:
296 return &elf_howto_table[(int) R_390_GOT20];
297 case BFD_RELOC_390_GOTPLT20:
298 return &elf_howto_table[(int) R_390_GOTPLT20];
299 case BFD_RELOC_390_TLS_GOTIE20:
300 return &elf_howto_table[(int) R_390_TLS_GOTIE20];
301 case BFD_RELOC_390_IRELATIVE:
302 return &elf_howto_table[(int) R_390_IRELATIVE];
303 case BFD_RELOC_VTABLE_INHERIT:
304 return &elf64_s390_vtinherit_howto;
305 case BFD_RELOC_VTABLE_ENTRY:
306 return &elf64_s390_vtentry_howto;
313 static reloc_howto_type *
314 elf_s390_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
320 i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]);
322 if (elf_howto_table[i].name != NULL
323 && strcasecmp (elf_howto_table[i].name, r_name) == 0)
324 return &elf_howto_table[i];
326 if (strcasecmp (elf64_s390_vtinherit_howto.name, r_name) == 0)
327 return &elf64_s390_vtinherit_howto;
328 if (strcasecmp (elf64_s390_vtentry_howto.name, r_name) == 0)
329 return &elf64_s390_vtentry_howto;
334 /* We need to use ELF64_R_TYPE so we have our own copy of this function,
335 and elf64-s390.c has its own copy. */
338 elf_s390_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
340 Elf_Internal_Rela *dst)
342 unsigned int r_type = ELF64_R_TYPE(dst->r_info);
345 case R_390_GNU_VTINHERIT:
346 cache_ptr->howto = &elf64_s390_vtinherit_howto;
349 case R_390_GNU_VTENTRY:
350 cache_ptr->howto = &elf64_s390_vtentry_howto;
354 if (r_type >= sizeof (elf_howto_table) / sizeof (elf_howto_table[0]))
356 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
360 cache_ptr->howto = &elf_howto_table[r_type];
364 /* A relocation function which doesn't do anything. */
365 static bfd_reloc_status_type
366 s390_tls_reloc (bfd *abfd ATTRIBUTE_UNUSED,
367 arelent *reloc_entry,
368 asymbol *symbol ATTRIBUTE_UNUSED,
369 void * data ATTRIBUTE_UNUSED,
370 asection *input_section,
372 char **error_message ATTRIBUTE_UNUSED)
375 reloc_entry->address += input_section->output_offset;
379 /* Handle the large displacement relocs. */
380 static bfd_reloc_status_type
381 s390_elf_ldisp_reloc (bfd *abfd,
382 arelent *reloc_entry,
385 asection *input_section,
387 char **error_message ATTRIBUTE_UNUSED)
389 reloc_howto_type *howto = reloc_entry->howto;
393 if (output_bfd != (bfd *) NULL
394 && (symbol->flags & BSF_SECTION_SYM) == 0
395 && (! howto->partial_inplace
396 || reloc_entry->addend == 0))
398 reloc_entry->address += input_section->output_offset;
401 if (output_bfd != NULL)
402 return bfd_reloc_continue;
404 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
405 return bfd_reloc_outofrange;
407 relocation = (symbol->value
408 + symbol->section->output_section->vma
409 + symbol->section->output_offset);
410 relocation += reloc_entry->addend;
411 if (howto->pc_relative)
413 relocation -= (input_section->output_section->vma
414 + input_section->output_offset);
415 relocation -= reloc_entry->address;
418 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
419 insn |= (relocation & 0xfff) << 16 | (relocation & 0xff000) >> 4;
420 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
422 if ((bfd_signed_vma) relocation < - 0x80000
423 || (bfd_signed_vma) relocation > 0x7ffff)
424 return bfd_reloc_overflow;
430 elf_s390_is_local_label_name (bfd *abfd, const char *name)
432 if (name[0] == '.' && (name[1] == 'X' || name[1] == 'L'))
435 return _bfd_elf_is_local_label_name (abfd, name);
438 /* Functions for the 390 ELF linker. */
440 /* The name of the dynamic interpreter. This is put in the .interp
443 #define ELF_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
445 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
446 copying dynamic variables from a shared lib into an app's dynbss
447 section, and instead use a dynamic relocation to point into the
449 #define ELIMINATE_COPY_RELOCS 1
451 /* The size in bytes of the first entry in the procedure linkage table. */
452 #define PLT_FIRST_ENTRY_SIZE 32
453 /* The size in bytes of an entry in the procedure linkage table. */
454 #define PLT_ENTRY_SIZE 32
456 #define GOT_ENTRY_SIZE 8
458 #define RELA_ENTRY_SIZE sizeof (Elf64_External_Rela)
460 /* The first three entries in a procedure linkage table are reserved,
461 and the initial contents are unimportant (we zero them out).
462 Subsequent entries look like this. See the SVR4 ABI 386
463 supplement to see how this works. */
465 /* For the s390, simple addr offset can only be 0 - 4096.
466 To use the full 16777216 TB address space, several instructions
467 are needed to load an address in a register and execute
468 a branch( or just saving the address)
470 Furthermore, only r 0 and 1 are free to use!!! */
472 /* The first 3 words in the GOT are then reserved.
473 Word 0 is the address of the dynamic table.
474 Word 1 is a pointer to a structure describing the object
475 Word 2 is used to point to the loader entry address.
477 The code for PLT entries looks like this:
479 The GOT holds the address in the PLT to be executed.
480 The loader then gets:
481 24(15) = Pointer to the structure describing the object.
482 28(15) = Offset in symbol table
483 The loader must then find the module where the function is
484 and insert the address in the GOT.
486 PLT1: LARL 1,<fn>@GOTENT # 6 bytes Load address of GOT entry in r1
487 LG 1,0(1) # 6 bytes Load address from GOT in r1
488 BCR 15,1 # 2 bytes Jump to address
489 RET1: BASR 1,0 # 2 bytes Return from GOT 1st time
490 LGF 1,12(1) # 6 bytes Load offset in symbl table in r1
491 BRCL 15,-x # 6 bytes Jump to start of PLT
492 .long ? # 4 bytes offset into .rela.plt
494 Total = 32 bytes per PLT entry
495 Fixup at offset 2: relative address to GOT entry
496 Fixup at offset 22: relative branch to PLT0
497 Fixup at offset 28: 32 bit offset into .rela.plt
499 A 32 bit offset into the symbol table is enough. It allows for
500 .rela.plt sections up to a size of 2 gigabyte. A single dynamic
501 object (the main program, any shared library) is limited to 4GB in
502 size. Having a .rela.plt of 2GB would already make the .plt
503 section bigger than 8GB. */
505 static const bfd_byte elf_s390x_plt_entry[PLT_ENTRY_SIZE] =
507 0xc0, 0x10, 0x00, 0x00, 0x00, 0x00, /* larl %r1,. */
508 0xe3, 0x10, 0x10, 0x00, 0x00, 0x04, /* lg %r1,0(%r1) */
509 0x07, 0xf1, /* br %r1 */
510 0x0d, 0x10, /* basr %r1,%r0 */
511 0xe3, 0x10, 0x10, 0x0c, 0x00, 0x14, /* lgf %r1,12(%r1) */
512 0xc0, 0xf4, 0x00, 0x00, 0x00, 0x00, /* jg first plt */
513 0x00, 0x00, 0x00, 0x00 /* .long 0x00000000 */
516 /* The first PLT entry pushes the offset into the symbol table
517 from R1 onto the stack at 56(15) and the loader object info
518 at 48(15), loads the loader address in R1 and jumps to it. */
520 /* The first entry in the PLT:
523 STG 1,56(15) # r1 contains the offset into the symbol table
524 LARL 1,_GLOBAL_OFFSET_TABLE # load address of global offset table
525 MVC 48(8,15),8(1) # move loader ino (object struct address) to stack
526 LG 1,16(1) # get entry address of loader
527 BCR 15,1 # jump to loader
529 Fixup at offset 8: relative address to start of GOT. */
531 static const bfd_byte elf_s390x_first_plt_entry[PLT_FIRST_ENTRY_SIZE] =
533 0xe3, 0x10, 0xf0, 0x38, 0x00, 0x24, /* stg %r1,56(%r15) */
534 0xc0, 0x10, 0x00, 0x00, 0x00, 0x00, /* larl %r1,. */
535 0xd2, 0x07, 0xf0, 0x30, 0x10, 0x08, /* mvc 48(8,%r15),8(%r1) */
536 0xe3, 0x10, 0x10, 0x10, 0x00, 0x04, /* lg %r1,16(%r1) */
537 0x07, 0xf1, /* br %r1 */
538 0x07, 0x00, /* nopr %r0 */
539 0x07, 0x00, /* nopr %r0 */
540 0x07, 0x00 /* nopr %r0 */
544 /* s390 ELF linker hash entry. */
546 struct elf_s390_link_hash_entry
548 struct elf_link_hash_entry elf;
550 /* Track dynamic relocs copied for this symbol. */
551 struct elf_dyn_relocs *dyn_relocs;
553 /* Number of GOTPLT references for a function. */
554 bfd_signed_vma gotplt_refcount;
556 #define GOT_UNKNOWN 0
560 #define GOT_TLS_IE_NLT 3
561 unsigned char tls_type;
563 /* For pointer equality reasons we might need to change the symbol
564 type from STT_GNU_IFUNC to STT_FUNC together with its value and
565 section entry. So after alloc_dynrelocs only these values should
566 be used. In order to check whether a symbol is IFUNC use
567 s390_is_ifunc_symbol_p. */
568 bfd_vma ifunc_resolver_address;
569 asection *ifunc_resolver_section;
572 #define elf_s390_hash_entry(ent) \
573 ((struct elf_s390_link_hash_entry *)(ent))
575 /* This structure represents an entry in the local PLT list needed for
576 local IFUNC symbols. */
579 /* The section of the local symbol.
580 Set in relocate_section and used in finish_dynamic_sections. */
585 bfd_signed_vma refcount;
590 /* NOTE: Keep this structure in sync with
591 the one declared in elf32-s390.c. */
592 struct elf_s390_obj_tdata
594 struct elf_obj_tdata root;
596 /* A local PLT is needed for ifunc symbols. */
597 struct plt_entry *local_plt;
599 /* TLS type for each local got entry. */
600 char *local_got_tls_type;
603 #define elf_s390_tdata(abfd) \
604 ((struct elf_s390_obj_tdata *) (abfd)->tdata.any)
606 #define elf_s390_local_plt(abfd) \
607 (elf_s390_tdata (abfd)->local_plt)
609 #define elf_s390_local_got_tls_type(abfd) \
610 (elf_s390_tdata (abfd)->local_got_tls_type)
612 #define is_s390_elf(bfd) \
613 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
614 && elf_tdata (bfd) != NULL \
615 && elf_object_id (bfd) == S390_ELF_DATA)
618 elf_s390_mkobject (bfd *abfd)
620 return bfd_elf_allocate_object (abfd, sizeof (struct elf_s390_obj_tdata),
625 elf_s390_object_p (bfd *abfd)
627 /* Set the right machine number for an s390 elf32 file. */
628 return bfd_default_set_arch_mach (abfd, bfd_arch_s390, bfd_mach_s390_64);
631 /* s390 ELF linker hash table. */
633 struct elf_s390_link_hash_table
635 struct elf_link_hash_table elf;
637 /* Short-cuts to get to dynamic linker sections. */
643 bfd_signed_vma refcount;
647 /* Small local sym cache. */
648 struct sym_cache sym_cache;
651 /* Get the s390 ELF linker hash table from a link_info structure. */
653 #define elf_s390_hash_table(p) \
654 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
655 == S390_ELF_DATA ? ((struct elf_s390_link_hash_table *) ((p)->hash)) : NULL)
658 #include "elf-s390-common.c"
660 /* Create an entry in an s390 ELF linker hash table. */
662 static struct bfd_hash_entry *
663 link_hash_newfunc (struct bfd_hash_entry *entry,
664 struct bfd_hash_table *table,
667 /* Allocate the structure if it has not already been allocated by a
671 entry = bfd_hash_allocate (table,
672 sizeof (struct elf_s390_link_hash_entry));
677 /* Call the allocation method of the superclass. */
678 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
681 struct elf_s390_link_hash_entry *eh;
683 eh = (struct elf_s390_link_hash_entry *) entry;
684 eh->dyn_relocs = NULL;
685 eh->gotplt_refcount = 0;
686 eh->tls_type = GOT_UNKNOWN;
687 eh->ifunc_resolver_address = 0;
688 eh->ifunc_resolver_section = NULL;
694 /* Create an s390 ELF linker hash table. */
696 static struct bfd_link_hash_table *
697 elf_s390_link_hash_table_create (bfd *abfd)
699 struct elf_s390_link_hash_table *ret;
700 bfd_size_type amt = sizeof (struct elf_s390_link_hash_table);
702 ret = (struct elf_s390_link_hash_table *) bfd_malloc (amt);
706 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
707 sizeof (struct elf_s390_link_hash_entry),
714 ret->elf.sgot = NULL;
715 ret->elf.sgotplt = NULL;
716 ret->elf.srelgot = NULL;
717 ret->elf.splt = NULL;
718 ret->elf.srelplt = NULL;
721 ret->tls_ldm_got.refcount = 0;
722 ret->sym_cache.abfd = NULL;
724 return &ret->elf.root;
727 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
728 shortcuts to them in our hash table. */
731 create_got_section (bfd *dynobj,
732 struct bfd_link_info *info)
734 struct elf_s390_link_hash_table *htab;
736 if (! _bfd_elf_create_got_section (dynobj, info))
739 htab = elf_s390_hash_table (info);
743 htab->elf.sgot = bfd_get_linker_section (dynobj, ".got");
744 htab->elf.sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
745 htab->elf.srelgot = bfd_get_linker_section (dynobj, ".rela.got");
746 if (!htab->elf.sgot || !htab->elf.sgotplt || !htab->elf.srelgot)
751 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
752 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
756 elf_s390_create_dynamic_sections (bfd *dynobj,
757 struct bfd_link_info *info)
759 struct elf_s390_link_hash_table *htab;
761 htab = elf_s390_hash_table (info);
765 if (!htab->elf.sgot && !create_got_section (dynobj, info))
768 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
771 htab->elf.splt = bfd_get_linker_section (dynobj, ".plt");
772 htab->elf.srelplt = bfd_get_linker_section (dynobj, ".rela.plt");
773 htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
775 htab->srelbss = bfd_get_linker_section (dynobj, ".rela.bss");
777 if (!htab->elf.splt || !htab->elf.srelplt || !htab->sdynbss
778 || (!info->shared && !htab->srelbss))
784 /* Copy the extra info we tack onto an elf_link_hash_entry. */
787 elf_s390_copy_indirect_symbol (struct bfd_link_info *info,
788 struct elf_link_hash_entry *dir,
789 struct elf_link_hash_entry *ind)
791 struct elf_s390_link_hash_entry *edir, *eind;
793 edir = (struct elf_s390_link_hash_entry *) dir;
794 eind = (struct elf_s390_link_hash_entry *) ind;
796 if (eind->dyn_relocs != NULL)
798 if (edir->dyn_relocs != NULL)
800 struct elf_dyn_relocs **pp;
801 struct elf_dyn_relocs *p;
803 /* Add reloc counts against the indirect sym to the direct sym
804 list. Merge any entries against the same section. */
805 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
807 struct elf_dyn_relocs *q;
809 for (q = edir->dyn_relocs; q != NULL; q = q->next)
810 if (q->sec == p->sec)
812 q->pc_count += p->pc_count;
813 q->count += p->count;
820 *pp = edir->dyn_relocs;
823 edir->dyn_relocs = eind->dyn_relocs;
824 eind->dyn_relocs = NULL;
827 if (ind->root.type == bfd_link_hash_indirect
828 && dir->got.refcount <= 0)
830 edir->tls_type = eind->tls_type;
831 eind->tls_type = GOT_UNKNOWN;
834 if (ELIMINATE_COPY_RELOCS
835 && ind->root.type != bfd_link_hash_indirect
836 && dir->dynamic_adjusted)
838 /* If called to transfer flags for a weakdef during processing
839 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
840 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
841 dir->ref_dynamic |= ind->ref_dynamic;
842 dir->ref_regular |= ind->ref_regular;
843 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
844 dir->needs_plt |= ind->needs_plt;
847 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
851 elf_s390_tls_transition (struct bfd_link_info *info,
863 return R_390_TLS_LE64;
864 return R_390_TLS_IE64;
865 case R_390_TLS_GOTIE64:
867 return R_390_TLS_LE64;
868 return R_390_TLS_GOTIE64;
869 case R_390_TLS_LDM64:
870 return R_390_TLS_LE64;
876 /* Look through the relocs for a section during the first phase, and
877 allocate space in the global offset table or procedure linkage
881 elf_s390_check_relocs (bfd *abfd,
882 struct bfd_link_info *info,
884 const Elf_Internal_Rela *relocs)
886 struct elf_s390_link_hash_table *htab;
887 Elf_Internal_Shdr *symtab_hdr;
888 struct elf_link_hash_entry **sym_hashes;
889 const Elf_Internal_Rela *rel;
890 const Elf_Internal_Rela *rel_end;
892 bfd_signed_vma *local_got_refcounts;
893 int tls_type, old_tls_type;
895 if (info->relocatable)
898 BFD_ASSERT (is_s390_elf (abfd));
900 htab = elf_s390_hash_table (info);
904 symtab_hdr = &elf_symtab_hdr (abfd);
905 sym_hashes = elf_sym_hashes (abfd);
906 local_got_refcounts = elf_local_got_refcounts (abfd);
910 rel_end = relocs + sec->reloc_count;
911 for (rel = relocs; rel < rel_end; rel++)
914 unsigned long r_symndx;
915 struct elf_link_hash_entry *h;
916 Elf_Internal_Sym *isym;
918 r_symndx = ELF64_R_SYM (rel->r_info);
920 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
922 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
928 if (r_symndx < symtab_hdr->sh_info)
930 /* A local symbol. */
931 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
936 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
938 struct plt_entry *plt;
940 if (htab->elf.dynobj == NULL)
941 htab->elf.dynobj = abfd;
943 if (!s390_elf_create_ifunc_sections (htab->elf.dynobj, info))
946 if (local_got_refcounts == NULL)
948 if (!elf_s390_allocate_local_syminfo (abfd, symtab_hdr))
950 local_got_refcounts = elf_local_got_refcounts (abfd);
952 plt = elf_s390_local_plt (abfd);
953 plt[r_symndx].plt.refcount++;
959 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
960 while (h->root.type == bfd_link_hash_indirect
961 || h->root.type == bfd_link_hash_warning)
962 h = (struct elf_link_hash_entry *) h->root.u.i.link;
965 /* Create got section and local_got_refcounts array if they
967 r_type = elf_s390_tls_transition (info,
968 ELF64_R_TYPE (rel->r_info),
983 case R_390_GOTPLTENT:
985 case R_390_TLS_GOTIE12:
986 case R_390_TLS_GOTIE20:
987 case R_390_TLS_GOTIE64:
988 case R_390_TLS_IEENT:
990 case R_390_TLS_LDM64:
992 && local_got_refcounts == NULL)
994 if (!elf_s390_allocate_local_syminfo (abfd, symtab_hdr))
996 local_got_refcounts = elf_local_got_refcounts (abfd);
1000 case R_390_GOTOFF16:
1001 case R_390_GOTOFF32:
1002 case R_390_GOTOFF64:
1004 case R_390_GOTPCDBL:
1005 if (htab->elf.sgot == NULL)
1007 if (htab->elf.dynobj == NULL)
1008 htab->elf.dynobj = abfd;
1009 if (!create_got_section (htab->elf.dynobj, info))
1016 if (htab->elf.dynobj == NULL)
1017 htab->elf.dynobj = abfd;
1018 if (!s390_elf_create_ifunc_sections (htab->elf.dynobj, info))
1021 /* Make sure an IFUNC symbol defined in a non-shared object
1022 always gets a PLT slot. */
1023 if (s390_is_ifunc_symbol_p (h) && h->def_regular)
1025 /* The symbol is called by the dynamic loader in order
1026 to resolve the relocation. So it is in fact also
1035 case R_390_GOTOFF16:
1036 case R_390_GOTOFF32:
1037 case R_390_GOTOFF64:
1039 case R_390_GOTPCDBL:
1040 /* These relocs do not need a GOT slot. They just load the
1041 GOT pointer itself or address something else relative to
1042 the GOT. Since the GOT pointer has been set up above we
1046 case R_390_PLT16DBL:
1048 case R_390_PLT32DBL:
1050 case R_390_PLTOFF16:
1051 case R_390_PLTOFF32:
1052 case R_390_PLTOFF64:
1053 /* This symbol requires a procedure linkage table entry. We
1054 actually build the entry in adjust_dynamic_symbol,
1055 because this might be a case of linking PIC code which is
1056 never referenced by a dynamic object, in which case we
1057 don't need to generate a procedure linkage table entry
1060 /* If this is a local symbol, we resolve it directly without
1061 creating a procedure linkage table entry. */
1065 h->plt.refcount += 1;
1069 case R_390_GOTPLT12:
1070 case R_390_GOTPLT16:
1071 case R_390_GOTPLT20:
1072 case R_390_GOTPLT32:
1073 case R_390_GOTPLT64:
1074 case R_390_GOTPLTENT:
1075 /* This symbol requires either a procedure linkage table entry
1076 or an entry in the local got. We actually build the entry
1077 in adjust_dynamic_symbol because whether this is really a
1078 global reference can change and with it the fact if we have
1079 to create a plt entry or a local got entry. To be able to
1080 make a once global symbol a local one we have to keep track
1081 of the number of gotplt references that exist for this
1085 ((struct elf_s390_link_hash_entry *) h)->gotplt_refcount++;
1087 h->plt.refcount += 1;
1090 local_got_refcounts[r_symndx] += 1;
1093 case R_390_TLS_LDM64:
1094 htab->tls_ldm_got.refcount += 1;
1097 case R_390_TLS_IE64:
1098 case R_390_TLS_GOTIE12:
1099 case R_390_TLS_GOTIE20:
1100 case R_390_TLS_GOTIE64:
1101 case R_390_TLS_IEENT:
1103 info->flags |= DF_STATIC_TLS;
1112 case R_390_TLS_GD64:
1113 /* This symbol requires a global offset table entry. */
1122 tls_type = GOT_NORMAL;
1124 case R_390_TLS_GD64:
1125 tls_type = GOT_TLS_GD;
1127 case R_390_TLS_IE64:
1128 case R_390_TLS_GOTIE64:
1129 tls_type = GOT_TLS_IE;
1131 case R_390_TLS_GOTIE12:
1132 case R_390_TLS_GOTIE20:
1133 case R_390_TLS_IEENT:
1134 tls_type = GOT_TLS_IE_NLT;
1140 h->got.refcount += 1;
1141 old_tls_type = elf_s390_hash_entry(h)->tls_type;
1145 local_got_refcounts[r_symndx] += 1;
1146 old_tls_type = elf_s390_local_got_tls_type (abfd) [r_symndx];
1148 /* If a TLS symbol is accessed using IE at least once,
1149 there is no point to use dynamic model for it. */
1150 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN)
1152 if (old_tls_type == GOT_NORMAL || tls_type == GOT_NORMAL)
1154 (*_bfd_error_handler)
1155 (_("%B: `%s' accessed both as normal and thread local symbol"),
1156 abfd, h->root.root.string);
1159 if (old_tls_type > tls_type)
1160 tls_type = old_tls_type;
1163 if (old_tls_type != tls_type)
1166 elf_s390_hash_entry (h)->tls_type = tls_type;
1168 elf_s390_local_got_tls_type (abfd) [r_symndx] = tls_type;
1171 if (r_type != R_390_TLS_IE64)
1175 case R_390_TLS_LE64:
1178 info->flags |= DF_STATIC_TLS;
1192 /* If this reloc is in a read-only section, we might
1193 need a copy reloc. We can't check reliably at this
1194 stage whether the section is read-only, as input
1195 sections have not yet been mapped to output sections.
1196 Tentatively set the flag for now, and correct in
1197 adjust_dynamic_symbol. */
1202 /* We may need a .plt entry if the function this reloc
1203 refers to is in a shared lib. */
1204 h->plt.refcount += 1;
1208 /* If we are creating a shared library, and this is a reloc
1209 against a global symbol, or a non PC relative reloc
1210 against a local symbol, then we need to copy the reloc
1211 into the shared library. However, if we are linking with
1212 -Bsymbolic, we do not need to copy a reloc against a
1213 global symbol which is defined in an object we are
1214 including in the link (i.e., DEF_REGULAR is set). At
1215 this point we have not seen all the input files, so it is
1216 possible that DEF_REGULAR is not set now but will be set
1217 later (it is never cleared). In case of a weak definition,
1218 DEF_REGULAR may be cleared later by a strong definition in
1219 a shared library. We account for that possibility below by
1220 storing information in the relocs_copied field of the hash
1221 table entry. A similar situation occurs when creating
1222 shared libraries and symbol visibility changes render the
1225 If on the other hand, we are creating an executable, we
1226 may need to keep relocations for symbols satisfied by a
1227 dynamic library if we manage to avoid copy relocs for the
1230 && (sec->flags & SEC_ALLOC) != 0
1231 && ((ELF64_R_TYPE (rel->r_info) != R_390_PC16
1232 && ELF64_R_TYPE (rel->r_info) != R_390_PC16DBL
1233 && ELF64_R_TYPE (rel->r_info) != R_390_PC32
1234 && ELF64_R_TYPE (rel->r_info) != R_390_PC32DBL
1235 && ELF64_R_TYPE (rel->r_info) != R_390_PC64)
1237 && (! SYMBOLIC_BIND (info, h)
1238 || h->root.type == bfd_link_hash_defweak
1239 || !h->def_regular))))
1240 || (ELIMINATE_COPY_RELOCS
1242 && (sec->flags & SEC_ALLOC) != 0
1244 && (h->root.type == bfd_link_hash_defweak
1245 || !h->def_regular)))
1247 struct elf_dyn_relocs *p;
1248 struct elf_dyn_relocs **head;
1250 /* We must copy these reloc types into the output file.
1251 Create a reloc section in dynobj and make room for
1255 if (htab->elf.dynobj == NULL)
1256 htab->elf.dynobj = abfd;
1258 sreloc = _bfd_elf_make_dynamic_reloc_section
1259 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
1265 /* If this is a global symbol, we count the number of
1266 relocations we need for this symbol. */
1269 head = &((struct elf_s390_link_hash_entry *) h)->dyn_relocs;
1273 /* Track dynamic relocs needed for local syms too.
1274 We really need local syms available to do this
1279 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1284 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1288 vpp = &elf_section_data (s)->local_dynrel;
1289 head = (struct elf_dyn_relocs **) vpp;
1293 if (p == NULL || p->sec != sec)
1295 bfd_size_type amt = sizeof *p;
1296 p = ((struct elf_dyn_relocs *)
1297 bfd_alloc (htab->elf.dynobj, amt));
1308 if (ELF64_R_TYPE (rel->r_info) == R_390_PC16
1309 || ELF64_R_TYPE (rel->r_info) == R_390_PC16DBL
1310 || ELF64_R_TYPE (rel->r_info) == R_390_PC32
1311 || ELF64_R_TYPE (rel->r_info) == R_390_PC32DBL
1312 || ELF64_R_TYPE (rel->r_info) == R_390_PC64)
1317 /* This relocation describes the C++ object vtable hierarchy.
1318 Reconstruct it for later use during GC. */
1319 case R_390_GNU_VTINHERIT:
1320 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1324 /* This relocation describes which C++ vtable entries are actually
1325 used. Record for later use during GC. */
1326 case R_390_GNU_VTENTRY:
1327 BFD_ASSERT (h != NULL);
1329 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1341 /* Return the section that should be marked against GC for a given
1345 elf_s390_gc_mark_hook (asection *sec,
1346 struct bfd_link_info *info,
1347 Elf_Internal_Rela *rel,
1348 struct elf_link_hash_entry *h,
1349 Elf_Internal_Sym *sym)
1352 switch (ELF64_R_TYPE (rel->r_info))
1354 case R_390_GNU_VTINHERIT:
1355 case R_390_GNU_VTENTRY:
1359 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1362 /* Update the got entry reference counts for the section being removed. */
1365 elf_s390_gc_sweep_hook (bfd *abfd,
1366 struct bfd_link_info *info,
1368 const Elf_Internal_Rela *relocs)
1370 struct elf_s390_link_hash_table *htab;
1371 Elf_Internal_Shdr *symtab_hdr;
1372 struct elf_link_hash_entry **sym_hashes;
1373 bfd_signed_vma *local_got_refcounts;
1374 const Elf_Internal_Rela *rel, *relend;
1376 if (info->relocatable)
1379 htab = elf_s390_hash_table (info);
1383 elf_section_data (sec)->local_dynrel = NULL;
1385 symtab_hdr = &elf_symtab_hdr (abfd);
1386 sym_hashes = elf_sym_hashes (abfd);
1387 local_got_refcounts = elf_local_got_refcounts (abfd);
1389 relend = relocs + sec->reloc_count;
1390 for (rel = relocs; rel < relend; rel++)
1392 unsigned long r_symndx;
1393 unsigned int r_type;
1394 struct elf_link_hash_entry *h = NULL;
1396 r_symndx = ELF64_R_SYM (rel->r_info);
1397 if (r_symndx >= symtab_hdr->sh_info)
1399 struct elf_s390_link_hash_entry *eh;
1400 struct elf_dyn_relocs **pp;
1401 struct elf_dyn_relocs *p;
1403 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1404 while (h->root.type == bfd_link_hash_indirect
1405 || h->root.type == bfd_link_hash_warning)
1406 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1407 eh = (struct elf_s390_link_hash_entry *) h;
1409 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1412 /* Everything must go for SEC. */
1419 Elf_Internal_Sym *isym;
1421 /* A local symbol. */
1422 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1427 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1429 struct plt_entry *plt = elf_s390_local_plt (abfd);
1430 if (plt[r_symndx].plt.refcount > 0)
1431 plt[r_symndx].plt.refcount--;
1435 r_type = ELF64_R_TYPE (rel->r_info);
1436 r_type = elf_s390_tls_transition (info, r_type, h != NULL);
1439 case R_390_TLS_LDM64:
1440 if (htab->tls_ldm_got.refcount > 0)
1441 htab->tls_ldm_got.refcount -= 1;
1444 case R_390_TLS_GD64:
1445 case R_390_TLS_IE64:
1446 case R_390_TLS_GOTIE12:
1447 case R_390_TLS_GOTIE20:
1448 case R_390_TLS_GOTIE64:
1449 case R_390_TLS_IEENT:
1455 case R_390_GOTOFF16:
1456 case R_390_GOTOFF32:
1457 case R_390_GOTOFF64:
1459 case R_390_GOTPCDBL:
1463 if (h->got.refcount > 0)
1464 h->got.refcount -= 1;
1466 else if (local_got_refcounts != NULL)
1468 if (local_got_refcounts[r_symndx] > 0)
1469 local_got_refcounts[r_symndx] -= 1;
1488 case R_390_PLT16DBL:
1490 case R_390_PLT32DBL:
1492 case R_390_PLTOFF16:
1493 case R_390_PLTOFF32:
1494 case R_390_PLTOFF64:
1497 if (h->plt.refcount > 0)
1498 h->plt.refcount -= 1;
1502 case R_390_GOTPLT12:
1503 case R_390_GOTPLT16:
1504 case R_390_GOTPLT20:
1505 case R_390_GOTPLT32:
1506 case R_390_GOTPLT64:
1507 case R_390_GOTPLTENT:
1510 if (h->plt.refcount > 0)
1512 ((struct elf_s390_link_hash_entry *) h)->gotplt_refcount--;
1513 h->plt.refcount -= 1;
1516 else if (local_got_refcounts != NULL)
1518 if (local_got_refcounts[r_symndx] > 0)
1519 local_got_refcounts[r_symndx] -= 1;
1531 /* Make sure we emit a GOT entry if the symbol was supposed to have a PLT
1532 entry but we found we will not create any. Called when we find we will
1533 not have any PLT for this symbol, by for example
1534 elf_s390_adjust_dynamic_symbol when we're doing a proper dynamic link,
1535 or elf_s390_size_dynamic_sections if no dynamic sections will be
1536 created (we're only linking static objects). */
1539 elf_s390_adjust_gotplt (struct elf_s390_link_hash_entry *h)
1541 if (h->elf.root.type == bfd_link_hash_warning)
1542 h = (struct elf_s390_link_hash_entry *) h->elf.root.u.i.link;
1544 if (h->gotplt_refcount <= 0)
1547 /* We simply add the number of gotplt references to the number
1548 * of got references for this symbol. */
1549 h->elf.got.refcount += h->gotplt_refcount;
1550 h->gotplt_refcount = -1;
1553 /* Adjust a symbol defined by a dynamic object and referenced by a
1554 regular object. The current definition is in some section of the
1555 dynamic object, but we're not including those sections. We have to
1556 change the definition to something the rest of the link can
1560 elf_s390_adjust_dynamic_symbol (struct bfd_link_info *info,
1561 struct elf_link_hash_entry *h)
1563 struct elf_s390_link_hash_table *htab;
1566 /* STT_GNU_IFUNC symbol must go through PLT. */
1567 if (s390_is_ifunc_symbol_p (h))
1570 /* If this is a function, put it in the procedure linkage table. We
1571 will fill in the contents of the procedure linkage table later
1572 (although we could actually do it here). */
1573 if (h->type == STT_FUNC
1576 if (h->plt.refcount <= 0
1577 || SYMBOL_CALLS_LOCAL (info, h)
1578 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1579 && h->root.type == bfd_link_hash_undefweak))
1581 /* This case can occur if we saw a PLT32 reloc in an input
1582 file, but the symbol was never referred to by a dynamic
1583 object, or if all references were garbage collected. In
1584 such a case, we don't actually need to build a procedure
1585 linkage table, and we can just do a PC32 reloc instead. */
1586 h->plt.offset = (bfd_vma) -1;
1588 elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1594 /* It's possible that we incorrectly decided a .plt reloc was
1595 needed for an R_390_PC32 reloc to a non-function sym in
1596 check_relocs. We can't decide accurately between function and
1597 non-function syms in check-relocs; Objects loaded later in
1598 the link may change h->type. So fix it now. */
1599 h->plt.offset = (bfd_vma) -1;
1601 /* If this is a weak symbol, and there is a real definition, the
1602 processor independent code will have arranged for us to see the
1603 real definition first, and we can just use the same value. */
1604 if (h->u.weakdef != NULL)
1606 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1607 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1608 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1609 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1610 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1611 h->non_got_ref = h->u.weakdef->non_got_ref;
1615 /* This is a reference to a symbol defined by a dynamic object which
1616 is not a function. */
1618 /* If we are creating a shared library, we must presume that the
1619 only references to the symbol are via the global offset table.
1620 For such cases we need not do anything here; the relocations will
1621 be handled correctly by relocate_section. */
1625 /* If there are no references to this symbol that do not use the
1626 GOT, we don't need to generate a copy reloc. */
1627 if (!h->non_got_ref)
1630 /* If -z nocopyreloc was given, we won't generate them either. */
1631 if (info->nocopyreloc)
1637 if (ELIMINATE_COPY_RELOCS)
1639 struct elf_s390_link_hash_entry * eh;
1640 struct elf_dyn_relocs *p;
1642 eh = (struct elf_s390_link_hash_entry *) h;
1643 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1645 s = p->sec->output_section;
1646 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1650 /* If we didn't find any dynamic relocs in read-only sections, then
1651 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1659 /* We must allocate the symbol in our .dynbss section, which will
1660 become part of the .bss section of the executable. There will be
1661 an entry for this symbol in the .dynsym section. The dynamic
1662 object will contain position independent code, so all references
1663 from the dynamic object to this symbol will go through the global
1664 offset table. The dynamic linker will use the .dynsym entry to
1665 determine the address it must put in the global offset table, so
1666 both the dynamic object and the regular object will refer to the
1667 same memory location for the variable. */
1669 htab = elf_s390_hash_table (info);
1673 /* We must generate a R_390_COPY reloc to tell the dynamic linker to
1674 copy the initial value out of the dynamic object and into the
1675 runtime process image. */
1676 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1678 htab->srelbss->size += sizeof (Elf64_External_Rela);
1684 return _bfd_elf_adjust_dynamic_copy (h, s);
1687 /* Allocate space in .plt, .got and associated reloc sections for
1691 allocate_dynrelocs (struct elf_link_hash_entry *h,
1694 struct bfd_link_info *info;
1695 struct elf_s390_link_hash_table *htab;
1696 struct elf_s390_link_hash_entry *eh = (struct elf_s390_link_hash_entry *)h;
1697 struct elf_dyn_relocs *p;
1699 if (h->root.type == bfd_link_hash_indirect)
1702 info = (struct bfd_link_info *) inf;
1703 htab = elf_s390_hash_table (info);
1707 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
1708 here if it is defined and referenced in a non-shared object. */
1709 if (s390_is_ifunc_symbol_p (h) && h->def_regular)
1710 return s390_elf_allocate_ifunc_dyn_relocs (info, h,
1712 else if (htab->elf.dynamic_sections_created
1713 && h->plt.refcount > 0)
1715 /* Make sure this symbol is output as a dynamic symbol.
1716 Undefined weak syms won't yet be marked as dynamic. */
1717 if (h->dynindx == -1
1718 && !h->forced_local)
1720 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1725 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1727 asection *s = htab->elf.splt;
1729 /* If this is the first .plt entry, make room for the special
1732 s->size += PLT_FIRST_ENTRY_SIZE;
1734 h->plt.offset = s->size;
1736 /* If this symbol is not defined in a regular file, and we are
1737 not generating a shared library, then set the symbol to this
1738 location in the .plt. This is required to make function
1739 pointers compare as equal between the normal executable and
1740 the shared library. */
1744 h->root.u.def.section = s;
1745 h->root.u.def.value = h->plt.offset;
1748 /* Make room for this entry. */
1749 s->size += PLT_ENTRY_SIZE;
1751 /* We also need to make an entry in the .got.plt section, which
1752 will be placed in the .got section by the linker script. */
1753 htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
1755 /* We also need to make an entry in the .rela.plt section. */
1756 htab->elf.srelplt->size += sizeof (Elf64_External_Rela);
1760 h->plt.offset = (bfd_vma) -1;
1762 elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1767 h->plt.offset = (bfd_vma) -1;
1769 elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1772 /* If R_390_TLS_{IE64,GOTIE64,GOTIE12,IEENT} symbol is now local to
1773 the binary, we can optimize a bit. IE64 and GOTIE64 get converted
1774 to R_390_TLS_LE64 requiring no TLS entry. For GOTIE12 and IEENT
1775 we can save the dynamic TLS relocation. */
1776 if (h->got.refcount > 0
1779 && elf_s390_hash_entry(h)->tls_type >= GOT_TLS_IE)
1781 if (elf_s390_hash_entry(h)->tls_type == GOT_TLS_IE_NLT)
1782 /* For the GOTIE access without a literal pool entry the offset has
1783 to be stored somewhere. The immediate value in the instruction
1784 is not bit enough so the value is stored in the got. */
1786 h->got.offset = htab->elf.sgot->size;
1787 htab->elf.sgot->size += GOT_ENTRY_SIZE;
1790 h->got.offset = (bfd_vma) -1;
1792 else if (h->got.refcount > 0)
1796 int tls_type = elf_s390_hash_entry(h)->tls_type;
1798 /* Make sure this symbol is output as a dynamic symbol.
1799 Undefined weak syms won't yet be marked as dynamic. */
1800 if (h->dynindx == -1
1801 && !h->forced_local)
1803 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1808 h->got.offset = s->size;
1809 s->size += GOT_ENTRY_SIZE;
1810 /* R_390_TLS_GD64 needs 2 consecutive GOT slots. */
1811 if (tls_type == GOT_TLS_GD)
1812 s->size += GOT_ENTRY_SIZE;
1813 dyn = htab->elf.dynamic_sections_created;
1814 /* R_390_TLS_IE64 needs one dynamic relocation,
1815 R_390_TLS_GD64 needs one if local symbol and two if global. */
1816 if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1817 || tls_type >= GOT_TLS_IE)
1818 htab->elf.srelgot->size += sizeof (Elf64_External_Rela);
1819 else if (tls_type == GOT_TLS_GD)
1820 htab->elf.srelgot->size += 2 * sizeof (Elf64_External_Rela);
1821 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1822 || h->root.type != bfd_link_hash_undefweak)
1824 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1825 htab->elf.srelgot->size += sizeof (Elf64_External_Rela);
1828 h->got.offset = (bfd_vma) -1;
1830 if (eh->dyn_relocs == NULL)
1833 /* In the shared -Bsymbolic case, discard space allocated for
1834 dynamic pc-relative relocs against symbols which turn out to be
1835 defined in regular objects. For the normal shared case, discard
1836 space for pc-relative relocs that have become local due to symbol
1837 visibility changes. */
1841 if (SYMBOL_CALLS_LOCAL (info, h))
1843 struct elf_dyn_relocs **pp;
1845 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1847 p->count -= p->pc_count;
1856 /* Also discard relocs on undefined weak syms with non-default
1858 if (eh->dyn_relocs != NULL
1859 && h->root.type == bfd_link_hash_undefweak)
1861 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1862 eh->dyn_relocs = NULL;
1864 /* Make sure undefined weak symbols are output as a dynamic
1866 else if (h->dynindx == -1
1867 && !h->forced_local)
1869 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1874 else if (ELIMINATE_COPY_RELOCS)
1876 /* For the non-shared case, discard space for relocs against
1877 symbols which turn out to need copy relocs or are not
1883 || (htab->elf.dynamic_sections_created
1884 && (h->root.type == bfd_link_hash_undefweak
1885 || h->root.type == bfd_link_hash_undefined))))
1887 /* Make sure this symbol is output as a dynamic symbol.
1888 Undefined weak syms won't yet be marked as dynamic. */
1889 if (h->dynindx == -1
1890 && !h->forced_local)
1892 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1896 /* If that succeeded, we know we'll be keeping all the
1898 if (h->dynindx != -1)
1902 eh->dyn_relocs = NULL;
1907 /* Finally, allocate space. */
1908 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1910 asection *sreloc = elf_section_data (p->sec)->sreloc;
1911 sreloc->size += p->count * sizeof (Elf64_External_Rela);
1917 /* Find any dynamic relocs that apply to read-only sections. */
1920 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1922 struct elf_s390_link_hash_entry *eh;
1923 struct elf_dyn_relocs *p;
1925 eh = (struct elf_s390_link_hash_entry *) h;
1926 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1928 asection *s = p->sec->output_section;
1930 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1932 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1934 info->flags |= DF_TEXTREL;
1936 /* Not an error, just cut short the traversal. */
1943 /* Set the sizes of the dynamic sections. */
1946 elf_s390_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1947 struct bfd_link_info *info)
1949 struct elf_s390_link_hash_table *htab;
1955 htab = elf_s390_hash_table (info);
1959 dynobj = htab->elf.dynobj;
1963 if (htab->elf.dynamic_sections_created)
1965 /* Set the contents of the .interp section to the interpreter. */
1966 if (info->executable)
1968 s = bfd_get_linker_section (dynobj, ".interp");
1971 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1972 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1976 /* Set up .got offsets for local syms, and space for local dynamic
1978 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1980 bfd_signed_vma *local_got;
1981 bfd_signed_vma *end_local_got;
1982 char *local_tls_type;
1983 bfd_size_type locsymcount;
1984 Elf_Internal_Shdr *symtab_hdr;
1986 struct plt_entry *local_plt;
1989 if (! is_s390_elf (ibfd))
1992 for (s = ibfd->sections; s != NULL; s = s->next)
1994 struct elf_dyn_relocs *p;
1996 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
1998 if (!bfd_is_abs_section (p->sec)
1999 && bfd_is_abs_section (p->sec->output_section))
2001 /* Input section has been discarded, either because
2002 it is a copy of a linkonce section or due to
2003 linker script /DISCARD/, so we'll be discarding
2006 else if (p->count != 0)
2008 srela = elf_section_data (p->sec)->sreloc;
2009 srela->size += p->count * sizeof (Elf64_External_Rela);
2010 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2011 info->flags |= DF_TEXTREL;
2016 local_got = elf_local_got_refcounts (ibfd);
2020 symtab_hdr = &elf_symtab_hdr (ibfd);
2021 locsymcount = symtab_hdr->sh_info;
2022 end_local_got = local_got + locsymcount;
2023 local_tls_type = elf_s390_local_got_tls_type (ibfd);
2025 srela = htab->elf.srelgot;
2026 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2030 *local_got = s->size;
2031 s->size += GOT_ENTRY_SIZE;
2032 if (*local_tls_type == GOT_TLS_GD)
2033 s->size += GOT_ENTRY_SIZE;
2035 srela->size += sizeof (Elf64_External_Rela);
2038 *local_got = (bfd_vma) -1;
2041 local_plt = elf_s390_local_plt (ibfd);
2042 for (i = 0; i < symtab_hdr->sh_info; i++)
2044 if (local_plt[i].plt.refcount > 0)
2046 local_plt[i].plt.offset = htab->elf.iplt->size;
2047 htab->elf.iplt->size += PLT_ENTRY_SIZE;
2048 htab->elf.igotplt->size += GOT_ENTRY_SIZE;
2049 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
2052 local_plt[i].plt.offset = (bfd_vma) -1;
2056 if (htab->tls_ldm_got.refcount > 0)
2058 /* Allocate 2 got entries and 1 dynamic reloc for R_390_TLS_LDM64
2060 htab->tls_ldm_got.offset = htab->elf.sgot->size;
2061 htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
2062 htab->elf.srelgot->size += sizeof (Elf64_External_Rela);
2065 htab->tls_ldm_got.offset = -1;
2067 /* Allocate global sym .plt and .got entries, and space for global
2068 sym dynamic relocs. */
2069 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
2071 /* We now have determined the sizes of the various dynamic sections.
2072 Allocate memory for them. */
2074 for (s = dynobj->sections; s != NULL; s = s->next)
2076 if ((s->flags & SEC_LINKER_CREATED) == 0)
2079 if (s == htab->elf.splt
2080 || s == htab->elf.sgot
2081 || s == htab->elf.sgotplt
2082 || s == htab->sdynbss
2083 || s == htab->elf.iplt
2084 || s == htab->elf.igotplt
2085 || s == htab->irelifunc)
2087 /* Strip this section if we don't need it; see the
2090 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2092 if (s->size != 0 && s != htab->elf.srelplt)
2095 /* We use the reloc_count field as a counter if we need
2096 to copy relocs into the output file. */
2101 /* It's not one of our sections, so don't allocate space. */
2107 /* If we don't need this section, strip it from the
2108 output file. This is to handle .rela.bss and
2109 .rela.plt. We must create it in
2110 create_dynamic_sections, because it must be created
2111 before the linker maps input sections to output
2112 sections. The linker does that before
2113 adjust_dynamic_symbol is called, and it is that
2114 function which decides whether anything needs to go
2115 into these sections. */
2117 s->flags |= SEC_EXCLUDE;
2121 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2124 /* Allocate memory for the section contents. We use bfd_zalloc
2125 here in case unused entries are not reclaimed before the
2126 section's contents are written out. This should not happen,
2127 but this way if it does, we get a R_390_NONE reloc instead
2129 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2130 if (s->contents == NULL)
2134 if (htab->elf.dynamic_sections_created)
2136 /* Add some entries to the .dynamic section. We fill in the
2137 values later, in elf_s390_finish_dynamic_sections, but we
2138 must add the entries now so that we get the correct size for
2139 the .dynamic section. The DT_DEBUG entry is filled in by the
2140 dynamic linker and used by the debugger. */
2141 #define add_dynamic_entry(TAG, VAL) \
2142 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2144 if (info->executable)
2146 if (!add_dynamic_entry (DT_DEBUG, 0))
2150 if (htab->elf.splt->size != 0)
2152 if (!add_dynamic_entry (DT_PLTGOT, 0)
2153 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2154 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2155 || !add_dynamic_entry (DT_JMPREL, 0))
2161 if (!add_dynamic_entry (DT_RELA, 0)
2162 || !add_dynamic_entry (DT_RELASZ, 0)
2163 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
2166 /* If any dynamic relocs apply to a read-only section,
2167 then we need a DT_TEXTREL entry. */
2168 if ((info->flags & DF_TEXTREL) == 0)
2169 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2172 if ((info->flags & DF_TEXTREL) != 0)
2174 if (!add_dynamic_entry (DT_TEXTREL, 0))
2179 #undef add_dynamic_entry
2184 /* Return the base VMA address which should be subtracted from real addresses
2185 when resolving @dtpoff relocation.
2186 This is PT_TLS segment p_vaddr. */
2189 dtpoff_base (struct bfd_link_info *info)
2191 /* If tls_sec is NULL, we should have signalled an error already. */
2192 if (elf_hash_table (info)->tls_sec == NULL)
2194 return elf_hash_table (info)->tls_sec->vma;
2197 /* Return the relocation value for @tpoff relocation
2198 if STT_TLS virtual address is ADDRESS. */
2201 tpoff (struct bfd_link_info *info, bfd_vma address)
2203 struct elf_link_hash_table *htab = elf_hash_table (info);
2205 /* If tls_sec is NULL, we should have signalled an error already. */
2206 if (htab->tls_sec == NULL)
2208 return htab->tls_size + htab->tls_sec->vma - address;
2211 /* Complain if TLS instruction relocation is against an invalid
2215 invalid_tls_insn (bfd *input_bfd,
2216 asection *input_section,
2217 Elf_Internal_Rela *rel)
2219 reloc_howto_type *howto;
2221 howto = elf_howto_table + ELF64_R_TYPE (rel->r_info);
2222 (*_bfd_error_handler)
2223 (_("%B(%A+0x%lx): invalid instruction for TLS relocation %s"),
2226 (long) rel->r_offset,
2228 bfd_set_error (bfd_error_bad_value);
2231 /* Relocate a 390 ELF section. */
2234 elf_s390_relocate_section (bfd *output_bfd,
2235 struct bfd_link_info *info,
2237 asection *input_section,
2239 Elf_Internal_Rela *relocs,
2240 Elf_Internal_Sym *local_syms,
2241 asection **local_sections)
2243 struct elf_s390_link_hash_table *htab;
2244 Elf_Internal_Shdr *symtab_hdr;
2245 struct elf_link_hash_entry **sym_hashes;
2246 bfd_vma *local_got_offsets;
2247 Elf_Internal_Rela *rel;
2248 Elf_Internal_Rela *relend;
2250 BFD_ASSERT (is_s390_elf (input_bfd));
2252 htab = elf_s390_hash_table (info);
2256 symtab_hdr = &elf_symtab_hdr (input_bfd);
2257 sym_hashes = elf_sym_hashes (input_bfd);
2258 local_got_offsets = elf_local_got_offsets (input_bfd);
2261 relend = relocs + input_section->reloc_count;
2262 for (; rel < relend; rel++)
2264 unsigned int r_type;
2265 reloc_howto_type *howto;
2266 unsigned long r_symndx;
2267 struct elf_link_hash_entry *h;
2268 Elf_Internal_Sym *sym;
2272 bfd_boolean unresolved_reloc;
2273 bfd_reloc_status_type r;
2275 asection *base_got = htab->elf.sgot;
2277 r_type = ELF64_R_TYPE (rel->r_info);
2278 if (r_type == (int) R_390_GNU_VTINHERIT
2279 || r_type == (int) R_390_GNU_VTENTRY)
2281 if (r_type >= (int) R_390_max)
2283 bfd_set_error (bfd_error_bad_value);
2287 howto = elf_howto_table + r_type;
2288 r_symndx = ELF64_R_SYM (rel->r_info);
2293 unresolved_reloc = FALSE;
2294 if (r_symndx < symtab_hdr->sh_info)
2296 sym = local_syms + r_symndx;
2297 sec = local_sections[r_symndx];
2299 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
2301 struct plt_entry *local_plt = elf_s390_local_plt (input_bfd);
2302 if (local_plt == NULL)
2305 /* Address of the PLT slot. */
2306 relocation = (htab->elf.iplt->output_section->vma
2307 + htab->elf.iplt->output_offset
2308 + local_plt[r_symndx].plt.offset);
2312 case R_390_PLTOFF16:
2313 case R_390_PLTOFF32:
2314 case R_390_PLTOFF64:
2315 relocation -= htab->elf.sgot->output_section->vma;
2317 case R_390_GOTPLT12:
2318 case R_390_GOTPLT16:
2319 case R_390_GOTPLT20:
2320 case R_390_GOTPLT32:
2321 case R_390_GOTPLT64:
2322 case R_390_GOTPLTENT:
2330 /* Write the PLT slot address into the GOT slot. */
2331 bfd_put_64 (output_bfd, relocation,
2332 htab->elf.sgot->contents +
2333 local_got_offsets[r_symndx]);
2334 relocation = (local_got_offsets[r_symndx] +
2335 htab->elf.sgot->output_offset);
2337 if (r_type == R_390_GOTENT || r_type == R_390_GOTPLTENT)
2338 relocation += htab->elf.sgot->output_section->vma;
2344 /* The output section is needed later in
2345 finish_dynamic_section when creating the dynamic
2347 local_plt[r_symndx].sec = sec;
2351 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2355 bfd_boolean warned ATTRIBUTE_UNUSED;
2357 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2358 r_symndx, symtab_hdr, sym_hashes,
2360 unresolved_reloc, warned);
2363 if (sec != NULL && discarded_section (sec))
2364 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2365 rel, 1, relend, howto, 0, contents);
2367 if (info->relocatable)
2372 case R_390_GOTPLT12:
2373 case R_390_GOTPLT16:
2374 case R_390_GOTPLT20:
2375 case R_390_GOTPLT32:
2376 case R_390_GOTPLT64:
2377 case R_390_GOTPLTENT:
2378 /* There are three cases for a GOTPLT relocation. 1) The
2379 relocation is against the jump slot entry of a plt that
2380 will get emitted to the output file. 2) The relocation
2381 is against the jump slot of a plt entry that has been
2382 removed. elf_s390_adjust_gotplt has created a GOT entry
2383 as replacement. 3) The relocation is against a local symbol.
2384 Cases 2) and 3) are the same as the GOT relocation code
2385 so we just have to test for case 1 and fall through for
2387 if (h != NULL && h->plt.offset != (bfd_vma) -1)
2391 if (s390_is_ifunc_symbol_p (h))
2393 plt_index = h->plt.offset / PLT_ENTRY_SIZE;
2394 relocation = (plt_index * GOT_ENTRY_SIZE +
2395 htab->elf.igotplt->output_offset);
2396 if (r_type == R_390_GOTPLTENT)
2397 relocation += htab->elf.igotplt->output_section->vma;
2402 Current offset - size first entry / entry size. */
2403 plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) /
2406 /* Offset in GOT is PLT index plus GOT headers(3)
2407 times 4, addr & GOT addr. */
2408 relocation = (plt_index + 3) * GOT_ENTRY_SIZE;
2409 if (r_type == R_390_GOTPLTENT)
2410 relocation += htab->elf.sgot->output_section->vma;
2412 unresolved_reloc = FALSE;
2423 /* Relocation is to the entry for this symbol in the global
2425 if (base_got == NULL)
2432 off = h->got.offset;
2433 dyn = htab->elf.dynamic_sections_created;
2435 if (s390_is_ifunc_symbol_p (h))
2437 BFD_ASSERT (h->plt.offset != (bfd_vma) -1);
2438 if (off == (bfd_vma)-1)
2440 /* No explicit GOT usage so redirect to the
2442 base_got = htab->elf.igotplt;
2443 off = h->plt.offset / PLT_ENTRY_SIZE * GOT_ENTRY_SIZE;
2447 /* Explicit GOT slots must contain the address
2448 of the PLT slot. This will be handled in
2449 finish_dynamic_symbol. */
2452 else if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2454 && SYMBOL_REFERENCES_LOCAL (info, h))
2455 || (ELF_ST_VISIBILITY (h->other)
2456 && h->root.type == bfd_link_hash_undefweak))
2458 /* This is actually a static link, or it is a
2459 -Bsymbolic link and the symbol is defined
2460 locally, or the symbol was forced to be local
2461 because of a version file. We must initialize
2462 this entry in the global offset table. Since the
2463 offset must always be a multiple of 2, we use the
2464 least significant bit to record whether we have
2465 initialized it already.
2467 When doing a dynamic link, we create a .rel.got
2468 relocation entry to initialize the value. This
2469 is done in the finish_dynamic_symbol routine. */
2474 bfd_put_64 (output_bfd, relocation,
2475 base_got->contents + off);
2480 unresolved_reloc = FALSE;
2484 if (local_got_offsets == NULL)
2487 off = local_got_offsets[r_symndx];
2489 /* The offset must always be a multiple of 8. We use
2490 the least significant bit to record whether we have
2491 already generated the necessary reloc. */
2496 bfd_put_64 (output_bfd, relocation,
2497 htab->elf.sgot->contents + off);
2502 Elf_Internal_Rela outrel;
2505 s = htab->elf.srelgot;
2509 outrel.r_offset = (htab->elf.sgot->output_section->vma
2510 + htab->elf.sgot->output_offset
2512 outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2513 outrel.r_addend = relocation;
2515 loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
2516 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2519 local_got_offsets[r_symndx] |= 1;
2523 if (off >= (bfd_vma) -2)
2526 relocation = base_got->output_offset + off;
2528 /* For @GOTENT the relocation is against the offset between
2529 the instruction and the symbols entry in the GOT and not
2530 between the start of the GOT and the symbols entry. We
2531 add the vma of the GOT to get the correct value. */
2532 if ( r_type == R_390_GOTENT
2533 || r_type == R_390_GOTPLTENT)
2534 relocation += base_got->output_section->vma;
2538 case R_390_GOTOFF16:
2539 case R_390_GOTOFF32:
2540 case R_390_GOTOFF64:
2541 /* Relocation is relative to the start of the global offset
2544 /* Note that sgot->output_offset is not involved in this
2545 calculation. We always want the start of .got. If we
2546 defined _GLOBAL_OFFSET_TABLE in a different way, as is
2547 permitted by the ABI, we might have to change this
2549 relocation -= htab->elf.sgot->output_section->vma;
2553 case R_390_GOTPCDBL:
2554 /* Use global offset table as symbol value. */
2555 relocation = htab->elf.sgot->output_section->vma;
2556 unresolved_reloc = FALSE;
2559 case R_390_PLT16DBL:
2561 case R_390_PLT32DBL:
2563 /* Relocation is to the entry for this symbol in the
2564 procedure linkage table. */
2566 /* Resolve a PLT32 reloc against a local symbol directly,
2567 without using the procedure linkage table. */
2571 if (h->plt.offset == (bfd_vma) -1
2572 || (htab->elf.splt == NULL && !s390_is_ifunc_symbol_p (h)))
2574 /* We didn't make a PLT entry for this symbol. This
2575 happens when statically linking PIC code, or when
2576 using -Bsymbolic. */
2579 if (s390_is_ifunc_symbol_p (h))
2580 relocation = (htab->elf.iplt->output_section->vma
2581 + htab->elf.iplt->output_offset
2584 relocation = (htab->elf.splt->output_section->vma
2585 + htab->elf.splt->output_offset
2587 unresolved_reloc = FALSE;
2590 case R_390_PLTOFF16:
2591 case R_390_PLTOFF32:
2592 case R_390_PLTOFF64:
2593 /* Relocation is to the entry for this symbol in the
2594 procedure linkage table relative to the start of the GOT. */
2596 /* For local symbols or if we didn't make a PLT entry for
2597 this symbol resolve the symbol directly. */
2599 || h->plt.offset == (bfd_vma) -1
2600 || (htab->elf.splt == NULL && !s390_is_ifunc_symbol_p (h)))
2602 relocation -= htab->elf.sgot->output_section->vma;
2606 if (s390_is_ifunc_symbol_p (h))
2607 relocation = (htab->elf.iplt->output_section->vma
2608 + htab->elf.iplt->output_offset
2610 - htab->elf.sgot->output_section->vma);
2612 relocation = (htab->elf.splt->output_section->vma
2613 + htab->elf.splt->output_offset
2615 - htab->elf.sgot->output_section->vma);
2616 unresolved_reloc = FALSE;
2630 && s390_is_ifunc_symbol_p (h)
2633 if (!info->shared || !h->non_got_ref)
2635 /* For a non-shared object STT_GNU_IFUNC symbol must
2637 relocation = (htab->elf.iplt->output_section->vma
2638 + htab->elf.iplt->output_offset
2644 /* For shared objects a runtime relocation is needed. */
2646 Elf_Internal_Rela outrel;
2649 /* Need a dynamic relocation to get the real function
2651 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
2655 if (outrel.r_offset == (bfd_vma) -1
2656 || outrel.r_offset == (bfd_vma) -2)
2659 outrel.r_offset += (input_section->output_section->vma
2660 + input_section->output_offset);
2662 if (h->dynindx == -1
2664 || info->executable)
2666 /* This symbol is resolved locally. */
2667 outrel.r_info = ELF64_R_INFO (0, R_390_IRELATIVE);
2668 outrel.r_addend = (h->root.u.def.value
2669 + h->root.u.def.section->output_section->vma
2670 + h->root.u.def.section->output_offset);
2674 outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
2675 outrel.r_addend = 0;
2678 sreloc = htab->elf.irelifunc;
2679 elf_append_rela (output_bfd, sreloc, &outrel);
2681 /* If this reloc is against an external symbol, we
2682 do not want to fiddle with the addend. Otherwise,
2683 we need to include the symbol value so that it
2684 becomes an addend for the dynamic reloc. For an
2685 internal symbol, we have updated addend. */
2690 if ((input_section->flags & SEC_ALLOC) == 0)
2695 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2696 || h->root.type != bfd_link_hash_undefweak)
2697 && ((r_type != R_390_PC16
2698 && r_type != R_390_PC16DBL
2699 && r_type != R_390_PC32
2700 && r_type != R_390_PC32DBL
2701 && r_type != R_390_PC64)
2702 || !SYMBOL_CALLS_LOCAL (info, h)))
2703 || (ELIMINATE_COPY_RELOCS
2710 || h->root.type == bfd_link_hash_undefweak
2711 || h->root.type == bfd_link_hash_undefined)))
2713 Elf_Internal_Rela outrel;
2714 bfd_boolean skip, relocate;
2718 /* When generating a shared object, these relocations
2719 are copied into the output file to be resolved at run
2725 _bfd_elf_section_offset (output_bfd, info, input_section,
2727 if (outrel.r_offset == (bfd_vma) -1)
2729 else if (outrel.r_offset == (bfd_vma) -2)
2730 skip = TRUE, relocate = TRUE;
2732 outrel.r_offset += (input_section->output_section->vma
2733 + input_section->output_offset);
2736 memset (&outrel, 0, sizeof outrel);
2739 && (r_type == R_390_PC16
2740 || r_type == R_390_PC16DBL
2741 || r_type == R_390_PC32
2742 || r_type == R_390_PC32DBL
2743 || r_type == R_390_PC64
2745 || !SYMBOLIC_BIND (info, h)
2746 || !h->def_regular))
2748 outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
2749 outrel.r_addend = rel->r_addend;
2753 /* This symbol is local, or marked to become local. */
2754 outrel.r_addend = relocation + rel->r_addend;
2755 if (r_type == R_390_64)
2758 outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2764 if (bfd_is_abs_section (sec))
2766 else if (sec == NULL || sec->owner == NULL)
2768 bfd_set_error(bfd_error_bad_value);
2775 osec = sec->output_section;
2776 sindx = elf_section_data (osec)->dynindx;
2780 osec = htab->elf.text_index_section;
2781 sindx = elf_section_data (osec)->dynindx;
2783 BFD_ASSERT (sindx != 0);
2785 /* We are turning this relocation into one
2786 against a section symbol, so subtract out
2787 the output section's address but not the
2788 offset of the input section in the output
2790 outrel.r_addend -= osec->vma;
2792 outrel.r_info = ELF64_R_INFO (sindx, r_type);
2796 sreloc = elf_section_data (input_section)->sreloc;
2800 loc = sreloc->contents;
2801 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2802 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2804 /* If this reloc is against an external symbol, we do
2805 not want to fiddle with the addend. Otherwise, we
2806 need to include the symbol value so that it becomes
2807 an addend for the dynamic reloc. */
2814 /* Relocations for tls literal pool entries. */
2815 case R_390_TLS_IE64:
2818 Elf_Internal_Rela outrel;
2822 outrel.r_offset = rel->r_offset
2823 + input_section->output_section->vma
2824 + input_section->output_offset;
2825 outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2826 sreloc = elf_section_data (input_section)->sreloc;
2829 loc = sreloc->contents;
2830 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2831 bfd_elf64_swap_reloc_out (output_bfd, &outrel, loc);
2835 case R_390_TLS_GD64:
2836 case R_390_TLS_GOTIE64:
2837 r_type = elf_s390_tls_transition (info, r_type, h == NULL);
2838 tls_type = GOT_UNKNOWN;
2839 if (h == NULL && local_got_offsets)
2840 tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
2843 tls_type = elf_s390_hash_entry(h)->tls_type;
2844 if (!info->shared && h->dynindx == -1 && tls_type >= GOT_TLS_IE)
2845 r_type = R_390_TLS_LE64;
2847 if (r_type == R_390_TLS_GD64 && tls_type >= GOT_TLS_IE)
2848 r_type = R_390_TLS_IE64;
2850 if (r_type == R_390_TLS_LE64)
2852 /* This relocation gets optimized away by the local exec
2853 access optimization. */
2854 BFD_ASSERT (! unresolved_reloc);
2855 bfd_put_64 (output_bfd, -tpoff (info, relocation),
2856 contents + rel->r_offset);
2860 if (htab->elf.sgot == NULL)
2864 off = h->got.offset;
2867 if (local_got_offsets == NULL)
2870 off = local_got_offsets[r_symndx];
2879 Elf_Internal_Rela outrel;
2883 if (htab->elf.srelgot == NULL)
2886 outrel.r_offset = (htab->elf.sgot->output_section->vma
2887 + htab->elf.sgot->output_offset + off);
2889 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2890 if (r_type == R_390_TLS_GD64)
2891 dr_type = R_390_TLS_DTPMOD;
2893 dr_type = R_390_TLS_TPOFF;
2894 if (dr_type == R_390_TLS_TPOFF && indx == 0)
2895 outrel.r_addend = relocation - dtpoff_base (info);
2897 outrel.r_addend = 0;
2898 outrel.r_info = ELF64_R_INFO (indx, dr_type);
2899 loc = htab->elf.srelgot->contents;
2900 loc += htab->elf.srelgot->reloc_count++
2901 * sizeof (Elf64_External_Rela);
2902 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2904 if (r_type == R_390_TLS_GD64)
2908 BFD_ASSERT (! unresolved_reloc);
2909 bfd_put_64 (output_bfd,
2910 relocation - dtpoff_base (info),
2911 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
2915 outrel.r_info = ELF64_R_INFO (indx, R_390_TLS_DTPOFF);
2916 outrel.r_offset += GOT_ENTRY_SIZE;
2917 outrel.r_addend = 0;
2918 htab->elf.srelgot->reloc_count++;
2919 loc += sizeof (Elf64_External_Rela);
2920 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2927 local_got_offsets[r_symndx] |= 1;
2930 if (off >= (bfd_vma) -2)
2932 if (r_type == ELF64_R_TYPE (rel->r_info))
2934 relocation = htab->elf.sgot->output_offset + off;
2935 if (r_type == R_390_TLS_IE64 || r_type == R_390_TLS_IEENT)
2936 relocation += htab->elf.sgot->output_section->vma;
2937 unresolved_reloc = FALSE;
2941 bfd_put_64 (output_bfd, htab->elf.sgot->output_offset + off,
2942 contents + rel->r_offset);
2947 case R_390_TLS_GOTIE12:
2948 case R_390_TLS_GOTIE20:
2949 case R_390_TLS_IEENT:
2952 if (local_got_offsets == NULL)
2954 off = local_got_offsets[r_symndx];
2956 goto emit_tls_relocs;
2960 off = h->got.offset;
2961 tls_type = elf_s390_hash_entry(h)->tls_type;
2962 if (info->shared || h->dynindx != -1 || tls_type < GOT_TLS_IE)
2963 goto emit_tls_relocs;
2966 if (htab->elf.sgot == NULL)
2969 BFD_ASSERT (! unresolved_reloc);
2970 bfd_put_64 (output_bfd, -tpoff (info, relocation),
2971 htab->elf.sgot->contents + off);
2972 relocation = htab->elf.sgot->output_offset + off;
2973 if (r_type == R_390_TLS_IEENT)
2974 relocation += htab->elf.sgot->output_section->vma;
2975 unresolved_reloc = FALSE;
2978 case R_390_TLS_LDM64:
2980 /* The literal pool entry this relocation refers to gets ignored
2981 by the optimized code of the local exec model. Do nothing
2982 and the value will turn out zero. */
2985 if (htab->elf.sgot == NULL)
2988 off = htab->tls_ldm_got.offset;
2993 Elf_Internal_Rela outrel;
2996 if (htab->elf.srelgot == NULL)
2999 outrel.r_offset = (htab->elf.sgot->output_section->vma
3000 + htab->elf.sgot->output_offset + off);
3002 bfd_put_64 (output_bfd, 0,
3003 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3004 outrel.r_info = ELF64_R_INFO (0, R_390_TLS_DTPMOD);
3005 outrel.r_addend = 0;
3006 loc = htab->elf.srelgot->contents;
3007 loc += htab->elf.srelgot->reloc_count++
3008 * sizeof (Elf64_External_Rela);
3009 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
3010 htab->tls_ldm_got.offset |= 1;
3012 relocation = htab->elf.sgot->output_offset + off;
3013 unresolved_reloc = FALSE;
3016 case R_390_TLS_LE64:
3019 /* Linking a shared library with non-fpic code requires
3020 a R_390_TLS_TPOFF relocation. */
3021 Elf_Internal_Rela outrel;
3026 outrel.r_offset = rel->r_offset
3027 + input_section->output_section->vma
3028 + input_section->output_offset;
3029 if (h != NULL && h->dynindx != -1)
3033 outrel.r_info = ELF64_R_INFO (indx, R_390_TLS_TPOFF);
3035 outrel.r_addend = relocation - dtpoff_base (info);
3037 outrel.r_addend = 0;
3038 sreloc = elf_section_data (input_section)->sreloc;
3041 loc = sreloc->contents;
3042 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
3043 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
3047 BFD_ASSERT (! unresolved_reloc);
3048 bfd_put_64 (output_bfd, -tpoff (info, relocation),
3049 contents + rel->r_offset);
3053 case R_390_TLS_LDO64:
3054 if (info->shared || (input_section->flags & SEC_DEBUGGING))
3055 relocation -= dtpoff_base (info);
3057 /* When converting LDO to LE, we must negate. */
3058 relocation = -tpoff (info, relocation);
3061 /* Relocations for tls instructions. */
3062 case R_390_TLS_LOAD:
3063 case R_390_TLS_GDCALL:
3064 case R_390_TLS_LDCALL:
3065 tls_type = GOT_UNKNOWN;
3066 if (h == NULL && local_got_offsets)
3067 tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
3069 tls_type = elf_s390_hash_entry(h)->tls_type;
3071 if (tls_type == GOT_TLS_GD)
3074 if (r_type == R_390_TLS_LOAD)
3076 if (!info->shared && (h == NULL || h->dynindx == -1))
3078 /* IE->LE transition. Four valid cases:
3079 lg %rx,(0,%ry) -> sllg %rx,%ry,0
3080 lg %rx,(%ry,0) -> sllg %rx,%ry,0
3081 lg %rx,(%ry,%r12) -> sllg %rx,%ry,0
3082 lg %rx,(%r12,%ry) -> sllg %rx,%ry,0 */
3083 unsigned int insn0, insn1, ry;
3085 insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset);
3086 insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4);
3087 if (insn1 != 0x0004)
3088 invalid_tls_insn (input_bfd, input_section, rel);
3090 if ((insn0 & 0xff00f000) == 0xe3000000)
3091 /* lg %rx,0(%ry,0) -> sllg %rx,%ry,0 */
3092 ry = (insn0 & 0x000f0000);
3093 else if ((insn0 & 0xff0f0000) == 0xe3000000)
3094 /* lg %rx,0(0,%ry) -> sllg %rx,%ry,0 */
3095 ry = (insn0 & 0x0000f000) << 4;
3096 else if ((insn0 & 0xff00f000) == 0xe300c000)
3097 /* lg %rx,0(%ry,%r12) -> sllg %rx,%ry,0 */
3098 ry = (insn0 & 0x000f0000);
3099 else if ((insn0 & 0xff0f0000) == 0xe30c0000)
3100 /* lg %rx,0(%r12,%ry) -> sllg %rx,%ry,0 */
3101 ry = (insn0 & 0x0000f000) << 4;
3103 invalid_tls_insn (input_bfd, input_section, rel);
3104 insn0 = 0xeb000000 | (insn0 & 0x00f00000) | ry;
3106 bfd_put_32 (output_bfd, insn0, contents + rel->r_offset);
3107 bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4);
3110 else if (r_type == R_390_TLS_GDCALL)
3112 unsigned int insn0, insn1;
3114 insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset);
3115 insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4);
3116 if ((insn0 & 0xffff0000) != 0xc0e50000)
3117 invalid_tls_insn (input_bfd, input_section, rel);
3118 if (!info->shared && (h == NULL || h->dynindx == -1))
3120 /* GD->LE transition.
3121 brasl %r14,__tls_get_addr@plt -> brcl 0,. */
3127 /* GD->IE transition.
3128 brasl %r14,__tls_get_addr@plt -> lg %r2,0(%r2,%r12) */
3132 bfd_put_32 (output_bfd, insn0, contents + rel->r_offset);
3133 bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4);
3135 else if (r_type == R_390_TLS_LDCALL)
3139 unsigned int insn0, insn1;
3141 insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset);
3142 insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4);
3143 if ((insn0 & 0xffff0000) != 0xc0e50000)
3144 invalid_tls_insn (input_bfd, input_section, rel);
3145 /* LD->LE transition.
3146 brasl %r14,__tls_get_addr@plt -> brcl 0,. */
3149 bfd_put_32 (output_bfd, insn0, contents + rel->r_offset);
3150 bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4);
3159 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3160 because such sections are not SEC_ALLOC and thus ld.so will
3161 not process them. */
3162 if (unresolved_reloc
3163 && !((input_section->flags & SEC_DEBUGGING) != 0
3165 && _bfd_elf_section_offset (output_bfd, info, input_section,
3166 rel->r_offset) != (bfd_vma) -1)
3167 (*_bfd_error_handler)
3168 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3171 (long) rel->r_offset,
3173 h->root.root.string);
3177 if (r_type == R_390_20
3178 || r_type == R_390_GOT20
3179 || r_type == R_390_GOTPLT20
3180 || r_type == R_390_TLS_GOTIE20)
3182 relocation += rel->r_addend;
3183 relocation = (relocation&0xfff) << 8 | (relocation&0xff000) >> 12;
3184 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3185 contents, rel->r_offset,
3189 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3190 contents, rel->r_offset,
3191 relocation, rel->r_addend);
3193 if (r != bfd_reloc_ok)
3198 name = h->root.root.string;
3201 name = bfd_elf_string_from_elf_section (input_bfd,
3202 symtab_hdr->sh_link,
3207 name = bfd_section_name (input_bfd, sec);
3210 if (r == bfd_reloc_overflow)
3213 if (! ((*info->callbacks->reloc_overflow)
3214 (info, (h ? &h->root : NULL), name, howto->name,
3215 (bfd_vma) 0, input_bfd, input_section,
3221 (*_bfd_error_handler)
3222 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3223 input_bfd, input_section,
3224 (long) rel->r_offset, name, (int) r);
3233 /* Generate the PLT slots together with the dynamic relocations needed
3234 for IFUNC symbols. */
3237 elf_s390_finish_ifunc_symbol (bfd *output_bfd,
3238 struct bfd_link_info *info,
3239 struct elf_link_hash_entry *h,
3240 struct elf_s390_link_hash_table *htab,
3242 bfd_vma resolver_address)
3246 Elf_Internal_Rela rela;
3248 asection *plt, *gotplt, *relplt;
3250 if (htab->elf.iplt == NULL
3251 || htab->elf.igotplt == NULL
3252 || htab->elf.irelplt == NULL)
3255 /* Index of the PLT slot within iplt section. */
3256 plt_index = plt_offset / PLT_ENTRY_SIZE;
3257 plt = htab->elf.iplt;
3258 /* Offset into the igot.plt section. */
3259 got_offset = plt_index * GOT_ENTRY_SIZE;
3260 gotplt = htab->elf.igotplt;
3261 relplt = htab->elf.irelplt;
3263 /* Fill in the blueprint of a PLT. */
3264 memcpy (plt->contents + plt_offset, elf_s390x_plt_entry,
3267 /* Fixup the relative address to the GOT entry */
3268 bfd_put_32 (output_bfd,
3269 (gotplt->output_section->vma +
3270 gotplt->output_offset + got_offset
3271 - (plt->output_section->vma +
3272 plt->output_offset +
3274 plt->contents + plt_offset + 2);
3275 /* Fixup the relative branch to PLT 0 */
3276 bfd_put_32 (output_bfd, - (plt->output_offset +
3277 (PLT_ENTRY_SIZE * plt_index) + 22)/2,
3278 plt->contents + plt_offset + 24);
3279 /* Fixup offset into .rela.plt section. */
3280 bfd_put_32 (output_bfd, relplt->output_offset +
3281 plt_index * sizeof (Elf64_External_Rela),
3282 plt->contents + plt_offset + 28);
3284 /* Fill in the entry in the global offset table.
3285 Points to instruction after GOT offset. */
3286 bfd_put_64 (output_bfd,
3287 (plt->output_section->vma
3288 + plt->output_offset
3291 gotplt->contents + got_offset);
3293 /* Fill in the entry in the .rela.plt section. */
3294 rela.r_offset = (gotplt->output_section->vma
3295 + gotplt->output_offset
3300 || ((info->executable
3301 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
3304 /* The symbol can be locally resolved. */
3305 rela.r_info = ELF64_R_INFO (0, R_390_IRELATIVE);
3306 rela.r_addend = resolver_address;
3310 rela.r_info = ELF64_R_INFO (h->dynindx, R_390_JMP_SLOT);
3314 loc = relplt->contents + plt_index * sizeof (Elf64_External_Rela);
3315 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3319 /* Finish up dynamic symbol handling. We set the contents of various
3320 dynamic sections here. */
3323 elf_s390_finish_dynamic_symbol (bfd *output_bfd,
3324 struct bfd_link_info *info,
3325 struct elf_link_hash_entry *h,
3326 Elf_Internal_Sym *sym)
3328 struct elf_s390_link_hash_table *htab;
3329 struct elf_s390_link_hash_entry *eh = (struct elf_s390_link_hash_entry*)h;
3331 htab = elf_s390_hash_table (info);
3335 if (h->plt.offset != (bfd_vma) -1)
3339 Elf_Internal_Rela rela;
3342 /* This symbol has an entry in the procedure linkage table. Set
3344 if (s390_is_ifunc_symbol_p (h))
3346 /* If we can resolve the IFUNC symbol locally we generate an
3348 elf_s390_finish_ifunc_symbol (output_bfd, info, h, htab, h->plt.offset,
3349 eh->ifunc_resolver_address +
3350 eh->ifunc_resolver_section->output_offset +
3351 eh->ifunc_resolver_section->output_section->vma);
3353 /* Fallthrough. Handling of explicit GOT slots of IFUNC
3354 symbols is below. */
3358 if (h->dynindx == -1
3359 || htab->elf.splt == NULL
3360 || htab->elf.sgotplt == NULL
3361 || htab->elf.srelplt == NULL)
3365 Current offset - size first entry / entry size. */
3366 plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3368 /* Offset in GOT is PLT index plus GOT headers(3) times 8,
3370 got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
3372 /* Fill in the blueprint of a PLT. */
3373 memcpy (htab->elf.splt->contents + h->plt.offset, elf_s390x_plt_entry,
3376 /* Fixup the relative address to the GOT entry */
3377 bfd_put_32 (output_bfd,
3378 (htab->elf.sgotplt->output_section->vma +
3379 htab->elf.sgotplt->output_offset + got_offset
3380 - (htab->elf.splt->output_section->vma +
3381 htab->elf.splt->output_offset +
3383 htab->elf.splt->contents + h->plt.offset + 2);
3384 /* Fixup the relative branch to PLT 0 */
3385 bfd_put_32 (output_bfd, - (PLT_FIRST_ENTRY_SIZE +
3386 (PLT_ENTRY_SIZE * plt_index) + 22)/2,
3387 htab->elf.splt->contents + h->plt.offset + 24);
3388 /* Fixup offset into .rela.plt section. */
3389 bfd_put_32 (output_bfd, plt_index * sizeof (Elf64_External_Rela),
3390 htab->elf.splt->contents + h->plt.offset + 28);
3392 /* Fill in the entry in the global offset table.
3393 Points to instruction after GOT offset. */
3394 bfd_put_64 (output_bfd,
3395 (htab->elf.splt->output_section->vma
3396 + htab->elf.splt->output_offset
3399 htab->elf.sgotplt->contents + got_offset);
3401 /* Fill in the entry in the .rela.plt section. */
3402 rela.r_offset = (htab->elf.sgotplt->output_section->vma
3403 + htab->elf.sgotplt->output_offset
3405 rela.r_info = ELF64_R_INFO (h->dynindx, R_390_JMP_SLOT);
3407 loc = htab->elf.srelplt->contents + plt_index *
3408 sizeof (Elf64_External_Rela);
3409 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3411 if (!h->def_regular)
3413 /* Mark the symbol as undefined, rather than as defined in
3414 the .plt section. Leave the value alone. This is a clue
3415 for the dynamic linker, to make function pointer
3416 comparisons work between an application and shared
3418 sym->st_shndx = SHN_UNDEF;
3423 if (h->got.offset != (bfd_vma) -1
3424 && elf_s390_hash_entry(h)->tls_type != GOT_TLS_GD
3425 && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE
3426 && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE_NLT)
3428 Elf_Internal_Rela rela;
3431 /* This symbol has an entry in the global offset table. Set it
3433 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
3436 rela.r_offset = (htab->elf.sgot->output_section->vma
3437 + htab->elf.sgot->output_offset
3438 + (h->got.offset &~ (bfd_vma) 1));
3440 if (h->def_regular && s390_is_ifunc_symbol_p (h))
3444 /* An explicit GOT slot usage needs GLOB_DAT. If the
3445 symbol references local the implicit got.iplt slot
3446 will be used and the IRELATIVE reloc has been created
3452 /* For non-shared objects explicit GOT slots must be
3453 filled with the PLT slot address for pointer
3454 equality reasons. */
3455 bfd_put_64 (output_bfd, (htab->elf.iplt->output_section->vma
3456 + htab->elf.iplt->output_offset
3458 htab->elf.sgot->contents + h->got.offset);
3462 else if (info->shared
3463 && SYMBOL_REFERENCES_LOCAL (info, h))
3465 /* If this is a static link, or it is a -Bsymbolic link and
3466 the symbol is defined locally or was forced to be local
3467 because of a version file, we just want to emit a
3468 RELATIVE reloc. The entry in the global offset table
3469 will already have been initialized in the
3470 relocate_section function. */
3471 if (!h->def_regular)
3473 BFD_ASSERT((h->got.offset & 1) != 0);
3474 rela.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
3475 rela.r_addend = (h->root.u.def.value
3476 + h->root.u.def.section->output_section->vma
3477 + h->root.u.def.section->output_offset);
3481 BFD_ASSERT((h->got.offset & 1) == 0);
3483 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgot->contents + h->got.offset);
3484 rela.r_info = ELF64_R_INFO (h->dynindx, R_390_GLOB_DAT);
3488 loc = htab->elf.srelgot->contents;
3489 loc += htab->elf.srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
3490 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3495 Elf_Internal_Rela rela;
3498 /* This symbols needs a copy reloc. Set it up. */
3500 if (h->dynindx == -1
3501 || (h->root.type != bfd_link_hash_defined
3502 && h->root.type != bfd_link_hash_defweak)
3503 || htab->srelbss == NULL)
3506 rela.r_offset = (h->root.u.def.value
3507 + h->root.u.def.section->output_section->vma
3508 + h->root.u.def.section->output_offset);
3509 rela.r_info = ELF64_R_INFO (h->dynindx, R_390_COPY);
3511 loc = htab->srelbss->contents;
3512 loc += htab->srelbss->reloc_count++ * sizeof (Elf64_External_Rela);
3513 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3516 /* Mark some specially defined symbols as absolute. */
3517 if (h == htab->elf.hdynamic
3518 || h == htab->elf.hgot
3519 || h == htab->elf.hplt)
3520 sym->st_shndx = SHN_ABS;
3525 /* Used to decide how to sort relocs in an optimal manner for the
3526 dynamic linker, before writing them out. */
3528 static enum elf_reloc_type_class
3529 elf_s390_reloc_type_class (const Elf_Internal_Rela *rela)
3531 switch ((int) ELF64_R_TYPE (rela->r_info))
3533 case R_390_RELATIVE:
3534 return reloc_class_relative;
3535 case R_390_JMP_SLOT:
3536 return reloc_class_plt;
3538 return reloc_class_copy;
3540 return reloc_class_normal;
3544 /* Finish up the dynamic sections. */
3547 elf_s390_finish_dynamic_sections (bfd *output_bfd,
3548 struct bfd_link_info *info)
3550 struct elf_s390_link_hash_table *htab;
3556 htab = elf_s390_hash_table (info);
3560 dynobj = htab->elf.dynobj;
3561 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3563 if (htab->elf.dynamic_sections_created)
3565 Elf64_External_Dyn *dyncon, *dynconend;
3567 if (sdyn == NULL || htab->elf.sgot == NULL)
3570 dyncon = (Elf64_External_Dyn *) sdyn->contents;
3571 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
3572 for (; dyncon < dynconend; dyncon++)
3574 Elf_Internal_Dyn dyn;
3577 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3585 dyn.d_un.d_ptr = htab->elf.sgot->output_section->vma;
3589 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
3593 s = htab->elf.srelplt->output_section;
3594 dyn.d_un.d_val = s->size;
3598 /* The procedure linkage table relocs (DT_JMPREL) should
3599 not be included in the overall relocs (DT_RELA).
3600 Therefore, we override the DT_RELASZ entry here to
3601 make it not include the JMPREL relocs. Since the
3602 linker script arranges for .rela.plt to follow all
3603 other relocation sections, we don't have to worry
3604 about changing the DT_RELA entry. */
3605 s = htab->elf.srelplt->output_section;
3606 dyn.d_un.d_val -= s->size;
3610 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3613 /* Fill in the special first entry in the procedure linkage table. */
3614 if (htab->elf.splt && htab->elf.splt->size > 0)
3616 /* fill in blueprint for plt 0 entry */
3617 memcpy (htab->elf.splt->contents, elf_s390x_first_plt_entry,
3618 PLT_FIRST_ENTRY_SIZE);
3619 /* Fixup relative address to start of GOT */
3620 bfd_put_32 (output_bfd,
3621 (htab->elf.sgotplt->output_section->vma +
3622 htab->elf.sgotplt->output_offset
3623 - htab->elf.splt->output_section->vma - 6)/2,
3624 htab->elf.splt->contents + 8);
3626 elf_section_data (htab->elf.splt->output_section)
3627 ->this_hdr.sh_entsize = PLT_ENTRY_SIZE;
3630 if (htab->elf.sgotplt)
3632 /* Fill in the first three entries in the global offset table. */
3633 if (htab->elf.sgotplt->size > 0)
3635 bfd_put_64 (output_bfd,
3636 (sdyn == NULL ? (bfd_vma) 0
3637 : sdyn->output_section->vma + sdyn->output_offset),
3638 htab->elf.sgotplt->contents);
3639 /* One entry for shared object struct ptr. */
3640 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + 8);
3641 /* One entry for _dl_runtime_resolve. */
3642 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + 12);
3645 elf_section_data (htab->elf.sgot->output_section)
3646 ->this_hdr.sh_entsize = 8;
3649 /* Finish dynamic symbol for local IFUNC symbols. */
3650 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3652 struct plt_entry *local_plt;
3653 Elf_Internal_Sym *isym;
3654 Elf_Internal_Shdr *symtab_hdr;
3656 symtab_hdr = &elf_symtab_hdr (ibfd);
3658 local_plt = elf_s390_local_plt (ibfd);
3659 if (local_plt != NULL)
3660 for (i = 0; i < symtab_hdr->sh_info; i++)
3662 if (local_plt[i].plt.offset != (bfd_vma) -1)
3664 asection *sec = local_plt[i].sec;
3665 isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, i);
3669 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
3670 elf_s390_finish_ifunc_symbol (output_bfd, info, NULL, htab,
3671 local_plt[i].plt.offset,
3673 + sec->output_section->vma
3674 + sec->output_offset);
3683 /* Return address for Ith PLT stub in section PLT, for relocation REL
3684 or (bfd_vma) -1 if it should not be included. */
3687 elf_s390_plt_sym_val (bfd_vma i, const asection *plt,
3688 const arelent *rel ATTRIBUTE_UNUSED)
3690 return plt->vma + PLT_FIRST_ENTRY_SIZE + i * PLT_ENTRY_SIZE;
3693 /* Why was the hash table entry size definition changed from
3694 ARCH_SIZE/8 to 4? This breaks the 64 bit dynamic linker and
3695 this is the only reason for the s390_elf64_size_info structure. */
3697 const struct elf_size_info s390_elf64_size_info =
3699 sizeof (Elf64_External_Ehdr),
3700 sizeof (Elf64_External_Phdr),
3701 sizeof (Elf64_External_Shdr),
3702 sizeof (Elf64_External_Rel),
3703 sizeof (Elf64_External_Rela),
3704 sizeof (Elf64_External_Sym),
3705 sizeof (Elf64_External_Dyn),
3706 sizeof (Elf_External_Note),
3707 8, /* hash-table entry size. */
3708 1, /* internal relocations per external relocations. */
3709 64, /* arch_size. */
3710 3, /* log_file_align. */
3711 ELFCLASS64, EV_CURRENT,
3712 bfd_elf64_write_out_phdrs,
3713 bfd_elf64_write_shdrs_and_ehdr,
3714 bfd_elf64_checksum_contents,
3715 bfd_elf64_write_relocs,
3716 bfd_elf64_swap_symbol_in,
3717 bfd_elf64_swap_symbol_out,
3718 bfd_elf64_slurp_reloc_table,
3719 bfd_elf64_slurp_symbol_table,
3720 bfd_elf64_swap_dyn_in,
3721 bfd_elf64_swap_dyn_out,
3722 bfd_elf64_swap_reloc_in,
3723 bfd_elf64_swap_reloc_out,
3724 bfd_elf64_swap_reloca_in,
3725 bfd_elf64_swap_reloca_out
3728 #define TARGET_BIG_SYM bfd_elf64_s390_vec
3729 #define TARGET_BIG_NAME "elf64-s390"
3730 #define ELF_ARCH bfd_arch_s390
3731 #define ELF_TARGET_ID S390_ELF_DATA
3732 #define ELF_MACHINE_CODE EM_S390
3733 #define ELF_MACHINE_ALT1 EM_S390_OLD
3734 #define ELF_MAXPAGESIZE 0x1000
3736 #define elf_backend_size_info s390_elf64_size_info
3738 #define elf_backend_can_gc_sections 1
3739 #define elf_backend_can_refcount 1
3740 #define elf_backend_want_got_plt 1
3741 #define elf_backend_plt_readonly 1
3742 #define elf_backend_want_plt_sym 0
3743 #define elf_backend_got_header_size 24
3744 #define elf_backend_rela_normal 1
3746 #define elf_info_to_howto elf_s390_info_to_howto
3748 #define bfd_elf64_bfd_is_local_label_name elf_s390_is_local_label_name
3749 #define bfd_elf64_bfd_link_hash_table_create elf_s390_link_hash_table_create
3750 #define bfd_elf64_bfd_reloc_type_lookup elf_s390_reloc_type_lookup
3751 #define bfd_elf64_bfd_reloc_name_lookup elf_s390_reloc_name_lookup
3753 #define elf_backend_adjust_dynamic_symbol elf_s390_adjust_dynamic_symbol
3754 #define elf_backend_check_relocs elf_s390_check_relocs
3755 #define elf_backend_copy_indirect_symbol elf_s390_copy_indirect_symbol
3756 #define elf_backend_create_dynamic_sections elf_s390_create_dynamic_sections
3757 #define elf_backend_finish_dynamic_sections elf_s390_finish_dynamic_sections
3758 #define elf_backend_finish_dynamic_symbol elf_s390_finish_dynamic_symbol
3759 #define elf_backend_gc_mark_hook elf_s390_gc_mark_hook
3760 #define elf_backend_gc_sweep_hook elf_s390_gc_sweep_hook
3761 #define elf_backend_reloc_type_class elf_s390_reloc_type_class
3762 #define elf_backend_relocate_section elf_s390_relocate_section
3763 #define elf_backend_size_dynamic_sections elf_s390_size_dynamic_sections
3764 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
3765 #define elf_backend_reloc_type_class elf_s390_reloc_type_class
3766 #define elf_backend_plt_sym_val elf_s390_plt_sym_val
3767 #define elf_backend_add_symbol_hook elf_s390_add_symbol_hook
3769 #define bfd_elf64_mkobject elf_s390_mkobject
3770 #define elf_backend_object_p elf_s390_object_p
3772 /* Enable ELF64 archive functions. */
3773 #define bfd_elf64_archive_functions
3774 extern bfd_boolean bfd_elf64_archive_slurp_armap (bfd *);
3775 extern bfd_boolean bfd_elf64_archive_write_armap (bfd *, unsigned int, struct orl *, unsigned int, int);
3777 #define bfd_elf64_archive_slurp_extended_name_table _bfd_archive_coff_slurp_extended_name_table
3778 #define bfd_elf64_archive_construct_extended_name_table _bfd_archive_coff_construct_extended_name_table
3779 #define bfd_elf64_archive_truncate_arname _bfd_archive_coff_truncate_arname
3780 #define bfd_elf64_archive_read_ar_hdr _bfd_archive_coff_read_ar_hdr
3781 #define bfd_elf64_archive_write_ar_hdr _bfd_archive_coff_write_ar_hdr
3782 #define bfd_elf64_archive_openr_next_archived_file _bfd_archive_coff_openr_next_archived_file
3783 #define bfd_elf64_archive_get_elt_at_index _bfd_archive_coff_get_elt_at_index
3784 #define bfd_elf64_archive_generic_stat_arch_elt _bfd_archive_coff_generic_stat_arch_elt
3785 #define bfd_elf64_archive_update_armap_timestamp _bfd_archive_coff_update_armap_timestamp
3787 #include "elf64-target.h"