?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2013-03-12 Sebastian Huber <sebastian.huber@embedded-brains.de>
[binutils-gdb.git] / bfd / elf64-s390.c
blobeece2c26f973225eb6d234ee81cd25885c2a843e
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).
5
6 This file is part of BFD, the Binary File Descriptor library.
7
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.
12
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.
17
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
21 02110-1301, USA. */
22
23 #include "sysdep.h"
24 #include "bfd.h"
25 #include "bfdlink.h"
26 #include "libbfd.h"
27 #include "elf-bfd.h"
28 #include "elf/s390.h"
29
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)
33
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 **);
40
41 /* The relocation "howto" table. */
42 static reloc_howto_type elf_howto_table[] =
43 {
44 HOWTO (R_390_NONE, /* type */
45 0, /* rightshift */
46 0, /* size (0 = byte, 1 = short, 2 = long) */
47 0, /* bitsize */
48 FALSE, /* pc_relative */
49 0, /* bitpos */
50 complain_overflow_dont, /* complain_on_overflow */
51 bfd_elf_generic_reloc, /* special_function */
52 "R_390_NONE", /* name */
53 FALSE, /* partial_inplace */
54 0, /* src_mask */
55 0, /* dst_mask */
56 FALSE), /* pcrel_offset */
57
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),
174
175 };
176
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);
182
183 static reloc_howto_type *
184 elf_s390_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
185 bfd_reloc_code_real_type code)
186 {
187 switch (code)
188 {
189 case BFD_RELOC_NONE:
190 return &elf_howto_table[(int) R_390_NONE];
191 case BFD_RELOC_8:
192 return &elf_howto_table[(int) R_390_8];
193 case BFD_RELOC_390_12:
194 return &elf_howto_table[(int) R_390_12];
195 case BFD_RELOC_16:
196 return &elf_howto_table[(int) R_390_16];
197 case BFD_RELOC_32:
198 return &elf_howto_table[(int) R_390_32];
199 case BFD_RELOC_CTOR:
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];
235 case BFD_RELOC_64:
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;
307 default:
308 break;
309 }
310 return 0;
311 }
312
313 static reloc_howto_type *
314 elf_s390_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
315 const char *r_name)
316 {
317 unsigned int i;
318
319 for (i = 0;
320 i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]);
321 i++)
322 if (elf_howto_table[i].name != NULL
323 && strcasecmp (elf_howto_table[i].name, r_name) == 0)
324 return &elf_howto_table[i];
325
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;
330
331 return NULL;
332 }
333
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. */
336
337 static void
338 elf_s390_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
339 arelent *cache_ptr,
340 Elf_Internal_Rela *dst)
341 {
342 unsigned int r_type = ELF64_R_TYPE(dst->r_info);
343 switch (r_type)
344 {
345 case R_390_GNU_VTINHERIT:
346 cache_ptr->howto = &elf64_s390_vtinherit_howto;
347 break;
348
349 case R_390_GNU_VTENTRY:
350 cache_ptr->howto = &elf64_s390_vtentry_howto;
351 break;
352
353 default:
354 if (r_type >= sizeof (elf_howto_table) / sizeof (elf_howto_table[0]))
355 {
356 (*_bfd_error_handler) (_("%B: invalid relocation type %d"),
357 abfd, (int) r_type);
358 r_type = R_390_NONE;
359 }
360 cache_ptr->howto = &elf_howto_table[r_type];
361 }
362 }
363
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,
371 bfd *output_bfd,
372 char **error_message ATTRIBUTE_UNUSED)
373 {
374 if (output_bfd)
375 reloc_entry->address += input_section->output_offset;
376 return bfd_reloc_ok;
377 }
378
379 /* Handle the large displacement relocs. */
380 static bfd_reloc_status_type
381 s390_elf_ldisp_reloc (bfd *abfd,
382 arelent *reloc_entry,
383 asymbol *symbol,
384 void * data,
385 asection *input_section,
386 bfd *output_bfd,
387 char **error_message ATTRIBUTE_UNUSED)
388 {
389 reloc_howto_type *howto = reloc_entry->howto;
390 bfd_vma relocation;
391 bfd_vma insn;
392
393 if (output_bfd != (bfd *) NULL
394 && (symbol->flags & BSF_SECTION_SYM) == 0
395 && (! howto->partial_inplace
396 || reloc_entry->addend == 0))
397 {
398 reloc_entry->address += input_section->output_offset;
399 return bfd_reloc_ok;
400 }
401 if (output_bfd != NULL)
402 return bfd_reloc_continue;
403
404 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
405 return bfd_reloc_outofrange;
406
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)
412 {
413 relocation -= (input_section->output_section->vma
414 + input_section->output_offset);
415 relocation -= reloc_entry->address;
416 }
417
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);
421
422 if ((bfd_signed_vma) relocation < - 0x80000
423 || (bfd_signed_vma) relocation > 0x7ffff)
424 return bfd_reloc_overflow;
425 else
426 return bfd_reloc_ok;
427 }
428
429 static bfd_boolean
430 elf_s390_is_local_label_name (bfd *abfd, const char *name)
431 {
432 if (name[0] == '.' && (name[1] == 'X' || name[1] == 'L'))
433 return TRUE;
434
435 return _bfd_elf_is_local_label_name (abfd, name);
436 }
437
438 /* Functions for the 390 ELF linker. */
439
440 /* The name of the dynamic interpreter. This is put in the .interp
441 section. */
442
443 #define ELF_DYNAMIC_INTERPRETER "/lib/ld64.so.1"
444
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
448 shared lib. */
449 #define ELIMINATE_COPY_RELOCS 1
450
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
455
456 #define GOT_ENTRY_SIZE 8
457
458 #define RELA_ENTRY_SIZE sizeof (Elf64_External_Rela)
459
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. */
464
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)
469
470 Furthermore, only r 0 and 1 are free to use!!! */
471
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.
476
477 The code for PLT entries looks like this:
478
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.
485
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
493
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
498
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. */
504
505 static const bfd_byte elf_s390x_plt_entry[PLT_ENTRY_SIZE] =
506 {
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 */
514 };
515
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. */
519
520 /* The first entry in the PLT:
521
522 PLT0:
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
528
529 Fixup at offset 8: relative address to start of GOT. */
530
531 static const bfd_byte elf_s390x_first_plt_entry[PLT_FIRST_ENTRY_SIZE] =
532 {
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 */
541 };
542
543
544 /* s390 ELF linker hash entry. */
545
546 struct elf_s390_link_hash_entry
547 {
548 struct elf_link_hash_entry elf;
549
550 /* Track dynamic relocs copied for this symbol. */
551 struct elf_dyn_relocs *dyn_relocs;
552
553 /* Number of GOTPLT references for a function. */
554 bfd_signed_vma gotplt_refcount;
555
556 #define GOT_UNKNOWN 0
557 #define GOT_NORMAL 1
558 #define GOT_TLS_GD 2
559 #define GOT_TLS_IE 3
560 #define GOT_TLS_IE_NLT 3
561 unsigned char tls_type;
562
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;
570 };
571
572 #define elf_s390_hash_entry(ent) \
573 ((struct elf_s390_link_hash_entry *)(ent))
574
575 /* This structure represents an entry in the local PLT list needed for
576 local IFUNC symbols. */
577 struct plt_entry
578 {
579 /* The section of the local symbol.
580 Set in relocate_section and used in finish_dynamic_sections. */
581 asection *sec;
582
583 union
584 {
585 bfd_signed_vma refcount;
586 bfd_vma offset;
587 } plt;
588 };
589
590 /* NOTE: Keep this structure in sync with
591 the one declared in elf32-s390.c. */
592 struct elf_s390_obj_tdata
593 {
594 struct elf_obj_tdata root;
595
596 /* A local PLT is needed for ifunc symbols. */
597 struct plt_entry *local_plt;
598
599 /* TLS type for each local got entry. */
600 char *local_got_tls_type;
601 };
602
603 #define elf_s390_tdata(abfd) \
604 ((struct elf_s390_obj_tdata *) (abfd)->tdata.any)
605
606 #define elf_s390_local_plt(abfd) \
607 (elf_s390_tdata (abfd)->local_plt)
608
609 #define elf_s390_local_got_tls_type(abfd) \
610 (elf_s390_tdata (abfd)->local_got_tls_type)
611
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)
616
617 static bfd_boolean
618 elf_s390_mkobject (bfd *abfd)
619 {
620 return bfd_elf_allocate_object (abfd, sizeof (struct elf_s390_obj_tdata),
621 S390_ELF_DATA);
622 }
623
624 static bfd_boolean
625 elf_s390_object_p (bfd *abfd)
626 {
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);
629 }
630
631 /* s390 ELF linker hash table. */
632
633 struct elf_s390_link_hash_table
634 {
635 struct elf_link_hash_table elf;
636
637 /* Short-cuts to get to dynamic linker sections. */
638 asection *sdynbss;
639 asection *srelbss;
640 asection *irelifunc;
641
642 union {
643 bfd_signed_vma refcount;
644 bfd_vma offset;
645 } tls_ldm_got;
646
647 /* Small local sym cache. */
648 struct sym_cache sym_cache;
649 };
650
651 /* Get the s390 ELF linker hash table from a link_info structure. */
652
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)
656
657 #define ELF64 1
658 #include "elf-s390-common.c"
659
660 /* Create an entry in an s390 ELF linker hash table. */
661
662 static struct bfd_hash_entry *
663 link_hash_newfunc (struct bfd_hash_entry *entry,
664 struct bfd_hash_table *table,
665 const char *string)
666 {
667 /* Allocate the structure if it has not already been allocated by a
668 subclass. */
669 if (entry == NULL)
670 {
671 entry = bfd_hash_allocate (table,
672 sizeof (struct elf_s390_link_hash_entry));
673 if (entry == NULL)
674 return entry;
675 }
676
677 /* Call the allocation method of the superclass. */
678 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
679 if (entry != NULL)
680 {
681 struct elf_s390_link_hash_entry *eh;
682
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;
689 }
690
691 return entry;
692 }
693
694 /* Create an s390 ELF linker hash table. */
695
696 static struct bfd_link_hash_table *
697 elf_s390_link_hash_table_create (bfd *abfd)
698 {
699 struct elf_s390_link_hash_table *ret;
700 bfd_size_type amt = sizeof (struct elf_s390_link_hash_table);
701
702 ret = (struct elf_s390_link_hash_table *) bfd_zmalloc (amt);
703 if (ret == NULL)
704 return NULL;
705
706 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
707 sizeof (struct elf_s390_link_hash_entry),
708 S390_ELF_DATA))
709 {
710 free (ret);
711 return NULL;
712 }
713
714 return &ret->elf.root;
715 }
716
717 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
718 shortcuts to them in our hash table. */
719
720 static bfd_boolean
721 create_got_section (bfd *dynobj,
722 struct bfd_link_info *info)
723 {
724 struct elf_s390_link_hash_table *htab;
725
726 if (! _bfd_elf_create_got_section (dynobj, info))
727 return FALSE;
728
729 htab = elf_s390_hash_table (info);
730 if (htab == NULL)
731 return FALSE;
732
733 htab->elf.sgot = bfd_get_linker_section (dynobj, ".got");
734 htab->elf.sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
735 htab->elf.srelgot = bfd_get_linker_section (dynobj, ".rela.got");
736 if (!htab->elf.sgot || !htab->elf.sgotplt || !htab->elf.srelgot)
737 abort ();
738 return TRUE;
739 }
740
741 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
742 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
743 hash table. */
744
745 static bfd_boolean
746 elf_s390_create_dynamic_sections (bfd *dynobj,
747 struct bfd_link_info *info)
748 {
749 struct elf_s390_link_hash_table *htab;
750
751 htab = elf_s390_hash_table (info);
752 if (htab == NULL)
753 return FALSE;
754
755 if (!htab->elf.sgot && !create_got_section (dynobj, info))
756 return FALSE;
757
758 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
759 return FALSE;
760
761 htab->elf.splt = bfd_get_linker_section (dynobj, ".plt");
762 htab->elf.srelplt = bfd_get_linker_section (dynobj, ".rela.plt");
763 htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
764 if (!info->shared)
765 htab->srelbss = bfd_get_linker_section (dynobj, ".rela.bss");
766
767 if (!htab->elf.splt || !htab->elf.srelplt || !htab->sdynbss
768 || (!info->shared && !htab->srelbss))
769 abort ();
770
771 return TRUE;
772 }
773
774 /* Copy the extra info we tack onto an elf_link_hash_entry. */
775
776 static void
777 elf_s390_copy_indirect_symbol (struct bfd_link_info *info,
778 struct elf_link_hash_entry *dir,
779 struct elf_link_hash_entry *ind)
780 {
781 struct elf_s390_link_hash_entry *edir, *eind;
782
783 edir = (struct elf_s390_link_hash_entry *) dir;
784 eind = (struct elf_s390_link_hash_entry *) ind;
785
786 if (eind->dyn_relocs != NULL)
787 {
788 if (edir->dyn_relocs != NULL)
789 {
790 struct elf_dyn_relocs **pp;
791 struct elf_dyn_relocs *p;
792
793 /* Add reloc counts against the indirect sym to the direct sym
794 list. Merge any entries against the same section. */
795 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
796 {
797 struct elf_dyn_relocs *q;
798
799 for (q = edir->dyn_relocs; q != NULL; q = q->next)
800 if (q->sec == p->sec)
801 {
802 q->pc_count += p->pc_count;
803 q->count += p->count;
804 *pp = p->next;
805 break;
806 }
807 if (q == NULL)
808 pp = &p->next;
809 }
810 *pp = edir->dyn_relocs;
811 }
812
813 edir->dyn_relocs = eind->dyn_relocs;
814 eind->dyn_relocs = NULL;
815 }
816
817 if (ind->root.type == bfd_link_hash_indirect
818 && dir->got.refcount <= 0)
819 {
820 edir->tls_type = eind->tls_type;
821 eind->tls_type = GOT_UNKNOWN;
822 }
823
824 if (ELIMINATE_COPY_RELOCS
825 && ind->root.type != bfd_link_hash_indirect
826 && dir->dynamic_adjusted)
827 {
828 /* If called to transfer flags for a weakdef during processing
829 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
830 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
831 dir->ref_dynamic |= ind->ref_dynamic;
832 dir->ref_regular |= ind->ref_regular;
833 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
834 dir->needs_plt |= ind->needs_plt;
835 }
836 else
837 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
838 }
839
840 static int
841 elf_s390_tls_transition (struct bfd_link_info *info,
842 int r_type,
843 int is_local)
844 {
845 if (info->shared)
846 return r_type;
847
848 switch (r_type)
849 {
850 case R_390_TLS_GD64:
851 case R_390_TLS_IE64:
852 if (is_local)
853 return R_390_TLS_LE64;
854 return R_390_TLS_IE64;
855 case R_390_TLS_GOTIE64:
856 if (is_local)
857 return R_390_TLS_LE64;
858 return R_390_TLS_GOTIE64;
859 case R_390_TLS_LDM64:
860 return R_390_TLS_LE64;
861 }
862
863 return r_type;
864 }
865
866 /* Look through the relocs for a section during the first phase, and
867 allocate space in the global offset table or procedure linkage
868 table. */
869
870 static bfd_boolean
871 elf_s390_check_relocs (bfd *abfd,
872 struct bfd_link_info *info,
873 asection *sec,
874 const Elf_Internal_Rela *relocs)
875 {
876 struct elf_s390_link_hash_table *htab;
877 Elf_Internal_Shdr *symtab_hdr;
878 struct elf_link_hash_entry **sym_hashes;
879 const Elf_Internal_Rela *rel;
880 const Elf_Internal_Rela *rel_end;
881 asection *sreloc;
882 bfd_signed_vma *local_got_refcounts;
883 int tls_type, old_tls_type;
884
885 if (info->relocatable)
886 return TRUE;
887
888 BFD_ASSERT (is_s390_elf (abfd));
889
890 htab = elf_s390_hash_table (info);
891 if (htab == NULL)
892 return FALSE;
893
894 symtab_hdr = &elf_symtab_hdr (abfd);
895 sym_hashes = elf_sym_hashes (abfd);
896 local_got_refcounts = elf_local_got_refcounts (abfd);
897
898 sreloc = NULL;
899
900 rel_end = relocs + sec->reloc_count;
901 for (rel = relocs; rel < rel_end; rel++)
902 {
903 unsigned int r_type;
904 unsigned long r_symndx;
905 struct elf_link_hash_entry *h;
906 Elf_Internal_Sym *isym;
907
908 r_symndx = ELF64_R_SYM (rel->r_info);
909
910 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
911 {
912 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
913 abfd,
914 r_symndx);
915 return FALSE;
916 }
917
918 if (r_symndx < symtab_hdr->sh_info)
919 {
920 /* A local symbol. */
921 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
922 abfd, r_symndx);
923 if (isym == NULL)
924 return FALSE;
925
926 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
927 {
928 struct plt_entry *plt;
929
930 if (htab->elf.dynobj == NULL)
931 htab->elf.dynobj = abfd;
932
933 if (!s390_elf_create_ifunc_sections (htab->elf.dynobj, info))
934 return FALSE;
935
936 if (local_got_refcounts == NULL)
937 {
938 if (!elf_s390_allocate_local_syminfo (abfd, symtab_hdr))
939 return FALSE;
940 local_got_refcounts = elf_local_got_refcounts (abfd);
941 }
942 plt = elf_s390_local_plt (abfd);
943 plt[r_symndx].plt.refcount++;
944 }
945 h = NULL;
946 }
947 else
948 {
949 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
950 while (h->root.type == bfd_link_hash_indirect
951 || h->root.type == bfd_link_hash_warning)
952 h = (struct elf_link_hash_entry *) h->root.u.i.link;
953 }
954
955 /* Create got section and local_got_refcounts array if they
956 are needed. */
957 r_type = elf_s390_tls_transition (info,
958 ELF64_R_TYPE (rel->r_info),
959 h == NULL);
960 switch (r_type)
961 {
962 case R_390_GOT12:
963 case R_390_GOT16:
964 case R_390_GOT20:
965 case R_390_GOT32:
966 case R_390_GOT64:
967 case R_390_GOTENT:
968 case R_390_GOTPLT12:
969 case R_390_GOTPLT16:
970 case R_390_GOTPLT20:
971 case R_390_GOTPLT32:
972 case R_390_GOTPLT64:
973 case R_390_GOTPLTENT:
974 case R_390_TLS_GD64:
975 case R_390_TLS_GOTIE12:
976 case R_390_TLS_GOTIE20:
977 case R_390_TLS_GOTIE64:
978 case R_390_TLS_IEENT:
979 case R_390_TLS_IE64:
980 case R_390_TLS_LDM64:
981 if (h == NULL
982 && local_got_refcounts == NULL)
983 {
984 if (!elf_s390_allocate_local_syminfo (abfd, symtab_hdr))
985 return FALSE;
986 local_got_refcounts = elf_local_got_refcounts (abfd);
987 }
988
989 /* Fall through. */
990 case R_390_GOTOFF16:
991 case R_390_GOTOFF32:
992 case R_390_GOTOFF64:
993 case R_390_GOTPC:
994 case R_390_GOTPCDBL:
995 if (htab->elf.sgot == NULL)
996 {
997 if (htab->elf.dynobj == NULL)
998 htab->elf.dynobj = abfd;
999 if (!create_got_section (htab->elf.dynobj, info))
1000 return FALSE;
1001 }
1002 }
1003
1004 if (h != NULL)
1005 {
1006 if (htab->elf.dynobj == NULL)
1007 htab->elf.dynobj = abfd;
1008 if (!s390_elf_create_ifunc_sections (htab->elf.dynobj, info))
1009 return FALSE;
1010
1011 /* Make sure an IFUNC symbol defined in a non-shared object
1012 always gets a PLT slot. */
1013 if (s390_is_ifunc_symbol_p (h) && h->def_regular)
1014 {
1015 /* The symbol is called by the dynamic loader in order
1016 to resolve the relocation. So it is in fact also
1017 referenced. */
1018 h->ref_regular = 1;
1019 h->needs_plt = 1;
1020 }
1021 }
1022
1023 switch (r_type)
1024 {
1025 case R_390_GOTOFF16:
1026 case R_390_GOTOFF32:
1027 case R_390_GOTOFF64:
1028 case R_390_GOTPC:
1029 case R_390_GOTPCDBL:
1030 /* These relocs do not need a GOT slot. They just load the
1031 GOT pointer itself or address something else relative to
1032 the GOT. Since the GOT pointer has been set up above we
1033 are done. */
1034 break;
1035
1036 case R_390_PLT16DBL:
1037 case R_390_PLT32:
1038 case R_390_PLT32DBL:
1039 case R_390_PLT64:
1040 case R_390_PLTOFF16:
1041 case R_390_PLTOFF32:
1042 case R_390_PLTOFF64:
1043 /* This symbol requires a procedure linkage table entry. We
1044 actually build the entry in adjust_dynamic_symbol,
1045 because this might be a case of linking PIC code which is
1046 never referenced by a dynamic object, in which case we
1047 don't need to generate a procedure linkage table entry
1048 after all. */
1049
1050 /* If this is a local symbol, we resolve it directly without
1051 creating a procedure linkage table entry. */
1052 if (h != NULL)
1053 {
1054 h->needs_plt = 1;
1055 h->plt.refcount += 1;
1056 }
1057 break;
1058
1059 case R_390_GOTPLT12:
1060 case R_390_GOTPLT16:
1061 case R_390_GOTPLT20:
1062 case R_390_GOTPLT32:
1063 case R_390_GOTPLT64:
1064 case R_390_GOTPLTENT:
1065 /* This symbol requires either a procedure linkage table entry
1066 or an entry in the local got. We actually build the entry
1067 in adjust_dynamic_symbol because whether this is really a
1068 global reference can change and with it the fact if we have
1069 to create a plt entry or a local got entry. To be able to
1070 make a once global symbol a local one we have to keep track
1071 of the number of gotplt references that exist for this
1072 symbol. */
1073 if (h != NULL)
1074 {
1075 ((struct elf_s390_link_hash_entry *) h)->gotplt_refcount++;
1076 h->needs_plt = 1;
1077 h->plt.refcount += 1;
1078 }
1079 else
1080 local_got_refcounts[r_symndx] += 1;
1081 break;
1082
1083 case R_390_TLS_LDM64:
1084 htab->tls_ldm_got.refcount += 1;
1085 break;
1086
1087 case R_390_TLS_IE64:
1088 case R_390_TLS_GOTIE12:
1089 case R_390_TLS_GOTIE20:
1090 case R_390_TLS_GOTIE64:
1091 case R_390_TLS_IEENT:
1092 if (info->shared)
1093 info->flags |= DF_STATIC_TLS;
1094 /* Fall through */
1095
1096 case R_390_GOT12:
1097 case R_390_GOT16:
1098 case R_390_GOT20:
1099 case R_390_GOT32:
1100 case R_390_GOT64:
1101 case R_390_GOTENT:
1102 case R_390_TLS_GD64:
1103 /* This symbol requires a global offset table entry. */
1104 switch (r_type)
1105 {
1106 default:
1107 case R_390_GOT12:
1108 case R_390_GOT16:
1109 case R_390_GOT20:
1110 case R_390_GOT32:
1111 case R_390_GOTENT:
1112 tls_type = GOT_NORMAL;
1113 break;
1114 case R_390_TLS_GD64:
1115 tls_type = GOT_TLS_GD;
1116 break;
1117 case R_390_TLS_IE64:
1118 case R_390_TLS_GOTIE64:
1119 tls_type = GOT_TLS_IE;
1120 break;
1121 case R_390_TLS_GOTIE12:
1122 case R_390_TLS_GOTIE20:
1123 case R_390_TLS_IEENT:
1124 tls_type = GOT_TLS_IE_NLT;
1125 break;
1126 }
1127
1128 if (h != NULL)
1129 {
1130 h->got.refcount += 1;
1131 old_tls_type = elf_s390_hash_entry(h)->tls_type;
1132 }
1133 else
1134 {
1135 local_got_refcounts[r_symndx] += 1;
1136 old_tls_type = elf_s390_local_got_tls_type (abfd) [r_symndx];
1137 }
1138 /* If a TLS symbol is accessed using IE at least once,
1139 there is no point to use dynamic model for it. */
1140 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN)
1141 {
1142 if (old_tls_type == GOT_NORMAL || tls_type == GOT_NORMAL)
1143 {
1144 (*_bfd_error_handler)
1145 (_("%B: `%s' accessed both as normal and thread local symbol"),
1146 abfd, h->root.root.string);
1147 return FALSE;
1148 }
1149 if (old_tls_type > tls_type)
1150 tls_type = old_tls_type;
1151 }
1152
1153 if (old_tls_type != tls_type)
1154 {
1155 if (h != NULL)
1156 elf_s390_hash_entry (h)->tls_type = tls_type;
1157 else
1158 elf_s390_local_got_tls_type (abfd) [r_symndx] = tls_type;
1159 }
1160
1161 if (r_type != R_390_TLS_IE64)
1162 break;
1163 /* Fall through */
1164
1165 case R_390_TLS_LE64:
1166 if (!info->shared)
1167 break;
1168 info->flags |= DF_STATIC_TLS;
1169 /* Fall through */
1170
1171 case R_390_8:
1172 case R_390_16:
1173 case R_390_32:
1174 case R_390_64:
1175 case R_390_PC16:
1176 case R_390_PC16DBL:
1177 case R_390_PC32:
1178 case R_390_PC32DBL:
1179 case R_390_PC64:
1180 if (h != NULL)
1181 {
1182 /* If this reloc is in a read-only section, we might
1183 need a copy reloc. We can't check reliably at this
1184 stage whether the section is read-only, as input
1185 sections have not yet been mapped to output sections.
1186 Tentatively set the flag for now, and correct in
1187 adjust_dynamic_symbol. */
1188 h->non_got_ref = 1;
1189
1190 if (!info->shared)
1191 {
1192 /* We may need a .plt entry if the function this reloc
1193 refers to is in a shared lib. */
1194 h->plt.refcount += 1;
1195 }
1196 }
1197
1198 /* If we are creating a shared library, and this is a reloc
1199 against a global symbol, or a non PC relative reloc
1200 against a local symbol, then we need to copy the reloc
1201 into the shared library. However, if we are linking with
1202 -Bsymbolic, we do not need to copy a reloc against a
1203 global symbol which is defined in an object we are
1204 including in the link (i.e., DEF_REGULAR is set). At
1205 this point we have not seen all the input files, so it is
1206 possible that DEF_REGULAR is not set now but will be set
1207 later (it is never cleared). In case of a weak definition,
1208 DEF_REGULAR may be cleared later by a strong definition in
1209 a shared library. We account for that possibility below by
1210 storing information in the relocs_copied field of the hash
1211 table entry. A similar situation occurs when creating
1212 shared libraries and symbol visibility changes render the
1213 symbol local.
1214
1215 If on the other hand, we are creating an executable, we
1216 may need to keep relocations for symbols satisfied by a
1217 dynamic library if we manage to avoid copy relocs for the
1218 symbol. */
1219 if ((info->shared
1220 && (sec->flags & SEC_ALLOC) != 0
1221 && ((ELF64_R_TYPE (rel->r_info) != R_390_PC16
1222 && ELF64_R_TYPE (rel->r_info) != R_390_PC16DBL
1223 && ELF64_R_TYPE (rel->r_info) != R_390_PC32
1224 && ELF64_R_TYPE (rel->r_info) != R_390_PC32DBL
1225 && ELF64_R_TYPE (rel->r_info) != R_390_PC64)
1226 || (h != NULL
1227 && (! SYMBOLIC_BIND (info, h)
1228 || h->root.type == bfd_link_hash_defweak
1229 || !h->def_regular))))
1230 || (ELIMINATE_COPY_RELOCS
1231 && !info->shared
1232 && (sec->flags & SEC_ALLOC) != 0
1233 && h != NULL
1234 && (h->root.type == bfd_link_hash_defweak
1235 || !h->def_regular)))
1236 {
1237 struct elf_dyn_relocs *p;
1238 struct elf_dyn_relocs **head;
1239
1240 /* We must copy these reloc types into the output file.
1241 Create a reloc section in dynobj and make room for
1242 this reloc. */
1243 if (sreloc == NULL)
1244 {
1245 if (htab->elf.dynobj == NULL)
1246 htab->elf.dynobj = abfd;
1247
1248 sreloc = _bfd_elf_make_dynamic_reloc_section
1249 (sec, htab->elf.dynobj, 3, abfd, /*rela?*/ TRUE);
1250
1251 if (sreloc == NULL)
1252 return FALSE;
1253 }
1254
1255 /* If this is a global symbol, we count the number of
1256 relocations we need for this symbol. */
1257 if (h != NULL)
1258 {
1259 head = &((struct elf_s390_link_hash_entry *) h)->dyn_relocs;
1260 }
1261 else
1262 {
1263 /* Track dynamic relocs needed for local syms too.
1264 We really need local syms available to do this
1265 easily. Oh well. */
1266 asection *s;
1267 void *vpp;
1268
1269 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1270 abfd, r_symndx);
1271 if (isym == NULL)
1272 return FALSE;
1273
1274 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1275 if (s == NULL)
1276 s = sec;
1277
1278 vpp = &elf_section_data (s)->local_dynrel;
1279 head = (struct elf_dyn_relocs **) vpp;
1280 }
1281
1282 p = *head;
1283 if (p == NULL || p->sec != sec)
1284 {
1285 bfd_size_type amt = sizeof *p;
1286 p = ((struct elf_dyn_relocs *)
1287 bfd_alloc (htab->elf.dynobj, amt));
1288 if (p == NULL)
1289 return FALSE;
1290 p->next = *head;
1291 *head = p;
1292 p->sec = sec;
1293 p->count = 0;
1294 p->pc_count = 0;
1295 }
1296
1297 p->count += 1;
1298 if (ELF64_R_TYPE (rel->r_info) == R_390_PC16
1299 || ELF64_R_TYPE (rel->r_info) == R_390_PC16DBL
1300 || ELF64_R_TYPE (rel->r_info) == R_390_PC32
1301 || ELF64_R_TYPE (rel->r_info) == R_390_PC32DBL
1302 || ELF64_R_TYPE (rel->r_info) == R_390_PC64)
1303 p->pc_count += 1;
1304 }
1305 break;
1306
1307 /* This relocation describes the C++ object vtable hierarchy.
1308 Reconstruct it for later use during GC. */
1309 case R_390_GNU_VTINHERIT:
1310 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1311 return FALSE;
1312 break;
1313
1314 /* This relocation describes which C++ vtable entries are actually
1315 used. Record for later use during GC. */
1316 case R_390_GNU_VTENTRY:
1317 BFD_ASSERT (h != NULL);
1318 if (h != NULL
1319 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1320 return FALSE;
1321 break;
1322
1323 default:
1324 break;
1325 }
1326 }
1327
1328 return TRUE;
1329 }
1330
1331 /* Return the section that should be marked against GC for a given
1332 relocation. */
1333
1334 static asection *
1335 elf_s390_gc_mark_hook (asection *sec,
1336 struct bfd_link_info *info,
1337 Elf_Internal_Rela *rel,
1338 struct elf_link_hash_entry *h,
1339 Elf_Internal_Sym *sym)
1340 {
1341 if (h != NULL)
1342 switch (ELF64_R_TYPE (rel->r_info))
1343 {
1344 case R_390_GNU_VTINHERIT:
1345 case R_390_GNU_VTENTRY:
1346 return NULL;
1347 }
1348
1349 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1350 }
1351
1352 /* Update the got entry reference counts for the section being removed. */
1353
1354 static bfd_boolean
1355 elf_s390_gc_sweep_hook (bfd *abfd,
1356 struct bfd_link_info *info,
1357 asection *sec,
1358 const Elf_Internal_Rela *relocs)
1359 {
1360 struct elf_s390_link_hash_table *htab;
1361 Elf_Internal_Shdr *symtab_hdr;
1362 struct elf_link_hash_entry **sym_hashes;
1363 bfd_signed_vma *local_got_refcounts;
1364 const Elf_Internal_Rela *rel, *relend;
1365
1366 if (info->relocatable)
1367 return TRUE;
1368
1369 htab = elf_s390_hash_table (info);
1370 if (htab == NULL)
1371 return FALSE;
1372
1373 elf_section_data (sec)->local_dynrel = NULL;
1374
1375 symtab_hdr = &elf_symtab_hdr (abfd);
1376 sym_hashes = elf_sym_hashes (abfd);
1377 local_got_refcounts = elf_local_got_refcounts (abfd);
1378
1379 relend = relocs + sec->reloc_count;
1380 for (rel = relocs; rel < relend; rel++)
1381 {
1382 unsigned long r_symndx;
1383 unsigned int r_type;
1384 struct elf_link_hash_entry *h = NULL;
1385
1386 r_symndx = ELF64_R_SYM (rel->r_info);
1387 if (r_symndx >= symtab_hdr->sh_info)
1388 {
1389 struct elf_s390_link_hash_entry *eh;
1390 struct elf_dyn_relocs **pp;
1391 struct elf_dyn_relocs *p;
1392
1393 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1394 while (h->root.type == bfd_link_hash_indirect
1395 || h->root.type == bfd_link_hash_warning)
1396 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1397 eh = (struct elf_s390_link_hash_entry *) h;
1398
1399 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1400 if (p->sec == sec)
1401 {
1402 /* Everything must go for SEC. */
1403 *pp = p->next;
1404 break;
1405 }
1406 }
1407 else
1408 {
1409 Elf_Internal_Sym *isym;
1410
1411 /* A local symbol. */
1412 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1413 abfd, r_symndx);
1414 if (isym == NULL)
1415 return FALSE;
1416
1417 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1418 {
1419 struct plt_entry *plt = elf_s390_local_plt (abfd);
1420 if (plt[r_symndx].plt.refcount > 0)
1421 plt[r_symndx].plt.refcount--;
1422 }
1423 }
1424
1425 r_type = ELF64_R_TYPE (rel->r_info);
1426 r_type = elf_s390_tls_transition (info, r_type, h != NULL);
1427 switch (r_type)
1428 {
1429 case R_390_TLS_LDM64:
1430 if (htab->tls_ldm_got.refcount > 0)
1431 htab->tls_ldm_got.refcount -= 1;
1432 break;
1433
1434 case R_390_TLS_GD64:
1435 case R_390_TLS_IE64:
1436 case R_390_TLS_GOTIE12:
1437 case R_390_TLS_GOTIE20:
1438 case R_390_TLS_GOTIE64:
1439 case R_390_TLS_IEENT:
1440 case R_390_GOT12:
1441 case R_390_GOT16:
1442 case R_390_GOT20:
1443 case R_390_GOT32:
1444 case R_390_GOT64:
1445 case R_390_GOTOFF16:
1446 case R_390_GOTOFF32:
1447 case R_390_GOTOFF64:
1448 case R_390_GOTPC:
1449 case R_390_GOTPCDBL:
1450 case R_390_GOTENT:
1451 if (h != NULL)
1452 {
1453 if (h->got.refcount > 0)
1454 h->got.refcount -= 1;
1455 }
1456 else if (local_got_refcounts != NULL)
1457 {
1458 if (local_got_refcounts[r_symndx] > 0)
1459 local_got_refcounts[r_symndx] -= 1;
1460 }
1461 break;
1462
1463 case R_390_8:
1464 case R_390_12:
1465 case R_390_16:
1466 case R_390_20:
1467 case R_390_32:
1468 case R_390_64:
1469 case R_390_PC16:
1470 case R_390_PC16DBL:
1471 case R_390_PC32:
1472 case R_390_PC32DBL:
1473 case R_390_PC64:
1474 if (info->shared)
1475 break;
1476 /* Fall through */
1477
1478 case R_390_PLT16DBL:
1479 case R_390_PLT32:
1480 case R_390_PLT32DBL:
1481 case R_390_PLT64:
1482 case R_390_PLTOFF16:
1483 case R_390_PLTOFF32:
1484 case R_390_PLTOFF64:
1485 if (h != NULL)
1486 {
1487 if (h->plt.refcount > 0)
1488 h->plt.refcount -= 1;
1489 }
1490 break;
1491
1492 case R_390_GOTPLT12:
1493 case R_390_GOTPLT16:
1494 case R_390_GOTPLT20:
1495 case R_390_GOTPLT32:
1496 case R_390_GOTPLT64:
1497 case R_390_GOTPLTENT:
1498 if (h != NULL)
1499 {
1500 if (h->plt.refcount > 0)
1501 {
1502 ((struct elf_s390_link_hash_entry *) h)->gotplt_refcount--;
1503 h->plt.refcount -= 1;
1504 }
1505 }
1506 else if (local_got_refcounts != NULL)
1507 {
1508 if (local_got_refcounts[r_symndx] > 0)
1509 local_got_refcounts[r_symndx] -= 1;
1510 }
1511 break;
1512
1513 default:
1514 break;
1515 }
1516 }
1517
1518 return TRUE;
1519 }
1520
1521 /* Make sure we emit a GOT entry if the symbol was supposed to have a PLT
1522 entry but we found we will not create any. Called when we find we will
1523 not have any PLT for this symbol, by for example
1524 elf_s390_adjust_dynamic_symbol when we're doing a proper dynamic link,
1525 or elf_s390_size_dynamic_sections if no dynamic sections will be
1526 created (we're only linking static objects). */
1527
1528 static void
1529 elf_s390_adjust_gotplt (struct elf_s390_link_hash_entry *h)
1530 {
1531 if (h->elf.root.type == bfd_link_hash_warning)
1532 h = (struct elf_s390_link_hash_entry *) h->elf.root.u.i.link;
1533
1534 if (h->gotplt_refcount <= 0)
1535 return;
1536
1537 /* We simply add the number of gotplt references to the number
1538 * of got references for this symbol. */
1539 h->elf.got.refcount += h->gotplt_refcount;
1540 h->gotplt_refcount = -1;
1541 }
1542
1543 /* Adjust a symbol defined by a dynamic object and referenced by a
1544 regular object. The current definition is in some section of the
1545 dynamic object, but we're not including those sections. We have to
1546 change the definition to something the rest of the link can
1547 understand. */
1548
1549 static bfd_boolean
1550 elf_s390_adjust_dynamic_symbol (struct bfd_link_info *info,
1551 struct elf_link_hash_entry *h)
1552 {
1553 struct elf_s390_link_hash_table *htab;
1554 asection *s;
1555
1556 /* STT_GNU_IFUNC symbol must go through PLT. */
1557 if (s390_is_ifunc_symbol_p (h))
1558 return TRUE;
1559
1560 /* If this is a function, put it in the procedure linkage table. We
1561 will fill in the contents of the procedure linkage table later
1562 (although we could actually do it here). */
1563 if (h->type == STT_FUNC
1564 || h->needs_plt)
1565 {
1566 if (h->plt.refcount <= 0
1567 || SYMBOL_CALLS_LOCAL (info, h)
1568 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1569 && h->root.type == bfd_link_hash_undefweak))
1570 {
1571 /* This case can occur if we saw a PLT32 reloc in an input
1572 file, but the symbol was never referred to by a dynamic
1573 object, or if all references were garbage collected. In
1574 such a case, we don't actually need to build a procedure
1575 linkage table, and we can just do a PC32 reloc instead. */
1576 h->plt.offset = (bfd_vma) -1;
1577 h->needs_plt = 0;
1578 elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1579 }
1580
1581 return TRUE;
1582 }
1583 else
1584 /* It's possible that we incorrectly decided a .plt reloc was
1585 needed for an R_390_PC32 reloc to a non-function sym in
1586 check_relocs. We can't decide accurately between function and
1587 non-function syms in check-relocs; Objects loaded later in
1588 the link may change h->type. So fix it now. */
1589 h->plt.offset = (bfd_vma) -1;
1590
1591 /* If this is a weak symbol, and there is a real definition, the
1592 processor independent code will have arranged for us to see the
1593 real definition first, and we can just use the same value. */
1594 if (h->u.weakdef != NULL)
1595 {
1596 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1597 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1598 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1599 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1600 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1601 h->non_got_ref = h->u.weakdef->non_got_ref;
1602 return TRUE;
1603 }
1604
1605 /* This is a reference to a symbol defined by a dynamic object which
1606 is not a function. */
1607
1608 /* If we are creating a shared library, we must presume that the
1609 only references to the symbol are via the global offset table.
1610 For such cases we need not do anything here; the relocations will
1611 be handled correctly by relocate_section. */
1612 if (info->shared)
1613 return TRUE;
1614
1615 /* If there are no references to this symbol that do not use the
1616 GOT, we don't need to generate a copy reloc. */
1617 if (!h->non_got_ref)
1618 return TRUE;
1619
1620 /* If -z nocopyreloc was given, we won't generate them either. */
1621 if (info->nocopyreloc)
1622 {
1623 h->non_got_ref = 0;
1624 return TRUE;
1625 }
1626
1627 if (ELIMINATE_COPY_RELOCS)
1628 {
1629 struct elf_s390_link_hash_entry * eh;
1630 struct elf_dyn_relocs *p;
1631
1632 eh = (struct elf_s390_link_hash_entry *) h;
1633 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1634 {
1635 s = p->sec->output_section;
1636 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1637 break;
1638 }
1639
1640 /* If we didn't find any dynamic relocs in read-only sections, then
1641 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1642 if (p == NULL)
1643 {
1644 h->non_got_ref = 0;
1645 return TRUE;
1646 }
1647 }
1648
1649 /* We must allocate the symbol in our .dynbss section, which will
1650 become part of the .bss section of the executable. There will be
1651 an entry for this symbol in the .dynsym section. The dynamic
1652 object will contain position independent code, so all references
1653 from the dynamic object to this symbol will go through the global
1654 offset table. The dynamic linker will use the .dynsym entry to
1655 determine the address it must put in the global offset table, so
1656 both the dynamic object and the regular object will refer to the
1657 same memory location for the variable. */
1658
1659 htab = elf_s390_hash_table (info);
1660 if (htab == NULL)
1661 return FALSE;
1662
1663 /* We must generate a R_390_COPY reloc to tell the dynamic linker to
1664 copy the initial value out of the dynamic object and into the
1665 runtime process image. */
1666 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1667 {
1668 htab->srelbss->size += sizeof (Elf64_External_Rela);
1669 h->needs_copy = 1;
1670 }
1671
1672 s = htab->sdynbss;
1673
1674 return _bfd_elf_adjust_dynamic_copy (h, s);
1675 }
1676
1677 /* Allocate space in .plt, .got and associated reloc sections for
1678 dynamic relocs. */
1679
1680 static bfd_boolean
1681 allocate_dynrelocs (struct elf_link_hash_entry *h,
1682 void * inf)
1683 {
1684 struct bfd_link_info *info;
1685 struct elf_s390_link_hash_table *htab;
1686 struct elf_s390_link_hash_entry *eh = (struct elf_s390_link_hash_entry *)h;
1687 struct elf_dyn_relocs *p;
1688
1689 if (h->root.type == bfd_link_hash_indirect)
1690 return TRUE;
1691
1692 info = (struct bfd_link_info *) inf;
1693 htab = elf_s390_hash_table (info);
1694 if (htab == NULL)
1695 return FALSE;
1696
1697 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
1698 here if it is defined and referenced in a non-shared object. */
1699 if (s390_is_ifunc_symbol_p (h) && h->def_regular)
1700 return s390_elf_allocate_ifunc_dyn_relocs (info, h,
1701 &eh->dyn_relocs);
1702 else if (htab->elf.dynamic_sections_created
1703 && h->plt.refcount > 0)
1704 {
1705 /* Make sure this symbol is output as a dynamic symbol.
1706 Undefined weak syms won't yet be marked as dynamic. */
1707 if (h->dynindx == -1
1708 && !h->forced_local)
1709 {
1710 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1711 return FALSE;
1712 }
1713
1714 if (info->shared
1715 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1716 {
1717 asection *s = htab->elf.splt;
1718
1719 /* If this is the first .plt entry, make room for the special
1720 first entry. */
1721 if (s->size == 0)
1722 s->size += PLT_FIRST_ENTRY_SIZE;
1723
1724 h->plt.offset = s->size;
1725
1726 /* If this symbol is not defined in a regular file, and we are
1727 not generating a shared library, then set the symbol to this
1728 location in the .plt. This is required to make function
1729 pointers compare as equal between the normal executable and
1730 the shared library. */
1731 if (! info->shared
1732 && !h->def_regular)
1733 {
1734 h->root.u.def.section = s;
1735 h->root.u.def.value = h->plt.offset;
1736 }
1737
1738 /* Make room for this entry. */
1739 s->size += PLT_ENTRY_SIZE;
1740
1741 /* We also need to make an entry in the .got.plt section, which
1742 will be placed in the .got section by the linker script. */
1743 htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
1744
1745 /* We also need to make an entry in the .rela.plt section. */
1746 htab->elf.srelplt->size += sizeof (Elf64_External_Rela);
1747 }
1748 else
1749 {
1750 h->plt.offset = (bfd_vma) -1;
1751 h->needs_plt = 0;
1752 elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1753 }
1754 }
1755 else
1756 {
1757 h->plt.offset = (bfd_vma) -1;
1758 h->needs_plt = 0;
1759 elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1760 }
1761
1762 /* If R_390_TLS_{IE64,GOTIE64,GOTIE12,IEENT} symbol is now local to
1763 the binary, we can optimize a bit. IE64 and GOTIE64 get converted
1764 to R_390_TLS_LE64 requiring no TLS entry. For GOTIE12 and IEENT
1765 we can save the dynamic TLS relocation. */
1766 if (h->got.refcount > 0
1767 && !info->shared
1768 && h->dynindx == -1
1769 && elf_s390_hash_entry(h)->tls_type >= GOT_TLS_IE)
1770 {
1771 if (elf_s390_hash_entry(h)->tls_type == GOT_TLS_IE_NLT)
1772 /* For the GOTIE access without a literal pool entry the offset has
1773 to be stored somewhere. The immediate value in the instruction
1774 is not bit enough so the value is stored in the got. */
1775 {
1776 h->got.offset = htab->elf.sgot->size;
1777 htab->elf.sgot->size += GOT_ENTRY_SIZE;
1778 }
1779 else
1780 h->got.offset = (bfd_vma) -1;
1781 }
1782 else if (h->got.refcount > 0)
1783 {
1784 asection *s;
1785 bfd_boolean dyn;
1786 int tls_type = elf_s390_hash_entry(h)->tls_type;
1787
1788 /* Make sure this symbol is output as a dynamic symbol.
1789 Undefined weak syms won't yet be marked as dynamic. */
1790 if (h->dynindx == -1
1791 && !h->forced_local)
1792 {
1793 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1794 return FALSE;
1795 }
1796
1797 s = htab->elf.sgot;
1798 h->got.offset = s->size;
1799 s->size += GOT_ENTRY_SIZE;
1800 /* R_390_TLS_GD64 needs 2 consecutive GOT slots. */
1801 if (tls_type == GOT_TLS_GD)
1802 s->size += GOT_ENTRY_SIZE;
1803 dyn = htab->elf.dynamic_sections_created;
1804 /* R_390_TLS_IE64 needs one dynamic relocation,
1805 R_390_TLS_GD64 needs one if local symbol and two if global. */
1806 if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1807 || tls_type >= GOT_TLS_IE)
1808 htab->elf.srelgot->size += sizeof (Elf64_External_Rela);
1809 else if (tls_type == GOT_TLS_GD)
1810 htab->elf.srelgot->size += 2 * sizeof (Elf64_External_Rela);
1811 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1812 || h->root.type != bfd_link_hash_undefweak)
1813 && (info->shared
1814 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1815 htab->elf.srelgot->size += sizeof (Elf64_External_Rela);
1816 }
1817 else
1818 h->got.offset = (bfd_vma) -1;
1819
1820 if (eh->dyn_relocs == NULL)
1821 return TRUE;
1822
1823 /* In the shared -Bsymbolic case, discard space allocated for
1824 dynamic pc-relative relocs against symbols which turn out to be
1825 defined in regular objects. For the normal shared case, discard
1826 space for pc-relative relocs that have become local due to symbol
1827 visibility changes. */
1828
1829 if (info->shared)
1830 {
1831 if (SYMBOL_CALLS_LOCAL (info, h))
1832 {
1833 struct elf_dyn_relocs **pp;
1834
1835 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1836 {
1837 p->count -= p->pc_count;
1838 p->pc_count = 0;
1839 if (p->count == 0)
1840 *pp = p->next;
1841 else
1842 pp = &p->next;
1843 }
1844 }
1845
1846 /* Also discard relocs on undefined weak syms with non-default
1847 visibility. */
1848 if (eh->dyn_relocs != NULL
1849 && h->root.type == bfd_link_hash_undefweak)
1850 {
1851 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1852 eh->dyn_relocs = NULL;
1853
1854 /* Make sure undefined weak symbols are output as a dynamic
1855 symbol in PIEs. */
1856 else if (h->dynindx == -1
1857 && !h->forced_local)
1858 {
1859 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1860 return FALSE;
1861 }
1862 }
1863 }
1864 else if (ELIMINATE_COPY_RELOCS)
1865 {
1866 /* For the non-shared case, discard space for relocs against
1867 symbols which turn out to need copy relocs or are not
1868 dynamic. */
1869
1870 if (!h->non_got_ref
1871 && ((h->def_dynamic
1872 && !h->def_regular)
1873 || (htab->elf.dynamic_sections_created
1874 && (h->root.type == bfd_link_hash_undefweak
1875 || h->root.type == bfd_link_hash_undefined))))
1876 {
1877 /* Make sure this symbol is output as a dynamic symbol.
1878 Undefined weak syms won't yet be marked as dynamic. */
1879 if (h->dynindx == -1
1880 && !h->forced_local)
1881 {
1882 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1883 return FALSE;
1884 }
1885
1886 /* If that succeeded, we know we'll be keeping all the
1887 relocs. */
1888 if (h->dynindx != -1)
1889 goto keep;
1890 }
1891
1892 eh->dyn_relocs = NULL;
1893
1894 keep: ;
1895 }
1896
1897 /* Finally, allocate space. */
1898 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1899 {
1900 asection *sreloc = elf_section_data (p->sec)->sreloc;
1901 sreloc->size += p->count * sizeof (Elf64_External_Rela);
1902 }
1903
1904 return TRUE;
1905 }
1906
1907 /* Find any dynamic relocs that apply to read-only sections. */
1908
1909 static bfd_boolean
1910 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1911 {
1912 struct elf_s390_link_hash_entry *eh;
1913 struct elf_dyn_relocs *p;
1914
1915 eh = (struct elf_s390_link_hash_entry *) h;
1916 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1917 {
1918 asection *s = p->sec->output_section;
1919
1920 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1921 {
1922 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1923
1924 info->flags |= DF_TEXTREL;
1925
1926 /* Not an error, just cut short the traversal. */
1927 return FALSE;
1928 }
1929 }
1930 return TRUE;
1931 }
1932
1933 /* Set the sizes of the dynamic sections. */
1934
1935 static bfd_boolean
1936 elf_s390_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1937 struct bfd_link_info *info)
1938 {
1939 struct elf_s390_link_hash_table *htab;
1940 bfd *dynobj;
1941 asection *s;
1942 bfd_boolean relocs;
1943 bfd *ibfd;
1944
1945 htab = elf_s390_hash_table (info);
1946 if (htab == NULL)
1947 return FALSE;
1948
1949 dynobj = htab->elf.dynobj;
1950 if (dynobj == NULL)
1951 abort ();
1952
1953 if (htab->elf.dynamic_sections_created)
1954 {
1955 /* Set the contents of the .interp section to the interpreter. */
1956 if (info->executable)
1957 {
1958 s = bfd_get_linker_section (dynobj, ".interp");
1959 if (s == NULL)
1960 abort ();
1961 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1962 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1963 }
1964 }
1965
1966 /* Set up .got offsets for local syms, and space for local dynamic
1967 relocs. */
1968 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1969 {
1970 bfd_signed_vma *local_got;
1971 bfd_signed_vma *end_local_got;
1972 char *local_tls_type;
1973 bfd_size_type locsymcount;
1974 Elf_Internal_Shdr *symtab_hdr;
1975 asection *srela;
1976 struct plt_entry *local_plt;
1977 unsigned int i;
1978
1979 if (! is_s390_elf (ibfd))
1980 continue;
1981
1982 for (s = ibfd->sections; s != NULL; s = s->next)
1983 {
1984 struct elf_dyn_relocs *p;
1985
1986 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
1987 {
1988 if (!bfd_is_abs_section (p->sec)
1989 && bfd_is_abs_section (p->sec->output_section))
1990 {
1991 /* Input section has been discarded, either because
1992 it is a copy of a linkonce section or due to
1993 linker script /DISCARD/, so we'll be discarding
1994 the relocs too. */
1995 }
1996 else if (p->count != 0)
1997 {
1998 srela = elf_section_data (p->sec)->sreloc;
1999 srela->size += p->count * sizeof (Elf64_External_Rela);
2000 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2001 info->flags |= DF_TEXTREL;
2002 }
2003 }
2004 }
2005
2006 local_got = elf_local_got_refcounts (ibfd);
2007 if (!local_got)
2008 continue;
2009
2010 symtab_hdr = &elf_symtab_hdr (ibfd);
2011 locsymcount = symtab_hdr->sh_info;
2012 end_local_got = local_got + locsymcount;
2013 local_tls_type = elf_s390_local_got_tls_type (ibfd);
2014 s = htab->elf.sgot;
2015 srela = htab->elf.srelgot;
2016 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2017 {
2018 if (*local_got > 0)
2019 {
2020 *local_got = s->size;
2021 s->size += GOT_ENTRY_SIZE;
2022 if (*local_tls_type == GOT_TLS_GD)
2023 s->size += GOT_ENTRY_SIZE;
2024 if (info->shared)
2025 srela->size += sizeof (Elf64_External_Rela);
2026 }
2027 else
2028 *local_got = (bfd_vma) -1;
2029 }
2030
2031 local_plt = elf_s390_local_plt (ibfd);
2032 for (i = 0; i < symtab_hdr->sh_info; i++)
2033 {
2034 if (local_plt[i].plt.refcount > 0)
2035 {
2036 local_plt[i].plt.offset = htab->elf.iplt->size;
2037 htab->elf.iplt->size += PLT_ENTRY_SIZE;
2038 htab->elf.igotplt->size += GOT_ENTRY_SIZE;
2039 htab->elf.irelplt->size += sizeof (Elf64_External_Rela);
2040 }
2041 else
2042 local_plt[i].plt.offset = (bfd_vma) -1;
2043 }
2044 }
2045
2046 if (htab->tls_ldm_got.refcount > 0)
2047 {
2048 /* Allocate 2 got entries and 1 dynamic reloc for R_390_TLS_LDM64
2049 relocs. */
2050 htab->tls_ldm_got.offset = htab->elf.sgot->size;
2051 htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
2052 htab->elf.srelgot->size += sizeof (Elf64_External_Rela);
2053 }
2054 else
2055 htab->tls_ldm_got.offset = -1;
2056
2057 /* Allocate global sym .plt and .got entries, and space for global
2058 sym dynamic relocs. */
2059 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
2060
2061 /* We now have determined the sizes of the various dynamic sections.
2062 Allocate memory for them. */
2063 relocs = FALSE;
2064 for (s = dynobj->sections; s != NULL; s = s->next)
2065 {
2066 if ((s->flags & SEC_LINKER_CREATED) == 0)
2067 continue;
2068
2069 if (s == htab->elf.splt
2070 || s == htab->elf.sgot
2071 || s == htab->elf.sgotplt
2072 || s == htab->sdynbss
2073 || s == htab->elf.iplt
2074 || s == htab->elf.igotplt
2075 || s == htab->irelifunc)
2076 {
2077 /* Strip this section if we don't need it; see the
2078 comment below. */
2079 }
2080 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2081 {
2082 if (s->size != 0 && s != htab->elf.srelplt)
2083 relocs = TRUE;
2084
2085 /* We use the reloc_count field as a counter if we need
2086 to copy relocs into the output file. */
2087 s->reloc_count = 0;
2088 }
2089 else
2090 {
2091 /* It's not one of our sections, so don't allocate space. */
2092 continue;
2093 }
2094
2095 if (s->size == 0)
2096 {
2097 /* If we don't need this section, strip it from the
2098 output file. This is to handle .rela.bss and
2099 .rela.plt. We must create it in
2100 create_dynamic_sections, because it must be created
2101 before the linker maps input sections to output
2102 sections. The linker does that before
2103 adjust_dynamic_symbol is called, and it is that
2104 function which decides whether anything needs to go
2105 into these sections. */
2106
2107 s->flags |= SEC_EXCLUDE;
2108 continue;
2109 }
2110
2111 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2112 continue;
2113
2114 /* Allocate memory for the section contents. We use bfd_zalloc
2115 here in case unused entries are not reclaimed before the
2116 section's contents are written out. This should not happen,
2117 but this way if it does, we get a R_390_NONE reloc instead
2118 of garbage. */
2119 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2120 if (s->contents == NULL)
2121 return FALSE;
2122 }
2123
2124 if (htab->elf.dynamic_sections_created)
2125 {
2126 /* Add some entries to the .dynamic section. We fill in the
2127 values later, in elf_s390_finish_dynamic_sections, but we
2128 must add the entries now so that we get the correct size for
2129 the .dynamic section. The DT_DEBUG entry is filled in by the
2130 dynamic linker and used by the debugger. */
2131 #define add_dynamic_entry(TAG, VAL) \
2132 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2133
2134 if (info->executable)
2135 {
2136 if (!add_dynamic_entry (DT_DEBUG, 0))
2137 return FALSE;
2138 }
2139
2140 if (htab->elf.splt->size != 0)
2141 {
2142 if (!add_dynamic_entry (DT_PLTGOT, 0)
2143 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2144 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2145 || !add_dynamic_entry (DT_JMPREL, 0))
2146 return FALSE;
2147 }
2148
2149 if (relocs)
2150 {
2151 if (!add_dynamic_entry (DT_RELA, 0)
2152 || !add_dynamic_entry (DT_RELASZ, 0)
2153 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
2154 return FALSE;
2155
2156 /* If any dynamic relocs apply to a read-only section,
2157 then we need a DT_TEXTREL entry. */
2158 if ((info->flags & DF_TEXTREL) == 0)
2159 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2160 info);
2161
2162 if ((info->flags & DF_TEXTREL) != 0)
2163 {
2164 if (!add_dynamic_entry (DT_TEXTREL, 0))
2165 return FALSE;
2166 }
2167 }
2168 }
2169 #undef add_dynamic_entry
2170
2171 return TRUE;
2172 }
2173
2174 /* Return the base VMA address which should be subtracted from real addresses
2175 when resolving @dtpoff relocation.
2176 This is PT_TLS segment p_vaddr. */
2177
2178 static bfd_vma
2179 dtpoff_base (struct bfd_link_info *info)
2180 {
2181 /* If tls_sec is NULL, we should have signalled an error already. */
2182 if (elf_hash_table (info)->tls_sec == NULL)
2183 return 0;
2184 return elf_hash_table (info)->tls_sec->vma;
2185 }
2186
2187 /* Return the relocation value for @tpoff relocation
2188 if STT_TLS virtual address is ADDRESS. */
2189
2190 static bfd_vma
2191 tpoff (struct bfd_link_info *info, bfd_vma address)
2192 {
2193 struct elf_link_hash_table *htab = elf_hash_table (info);
2194
2195 /* If tls_sec is NULL, we should have signalled an error already. */
2196 if (htab->tls_sec == NULL)
2197 return 0;
2198 return htab->tls_size + htab->tls_sec->vma - address;
2199 }
2200
2201 /* Complain if TLS instruction relocation is against an invalid
2202 instruction. */
2203
2204 static void
2205 invalid_tls_insn (bfd *input_bfd,
2206 asection *input_section,
2207 Elf_Internal_Rela *rel)
2208 {
2209 reloc_howto_type *howto;
2210
2211 howto = elf_howto_table + ELF64_R_TYPE (rel->r_info);
2212 (*_bfd_error_handler)
2213 (_("%B(%A+0x%lx): invalid instruction for TLS relocation %s"),
2214 input_bfd,
2215 input_section,
2216 (long) rel->r_offset,
2217 howto->name);
2218 bfd_set_error (bfd_error_bad_value);
2219 }
2220
2221 /* Relocate a 390 ELF section. */
2222
2223 static bfd_boolean
2224 elf_s390_relocate_section (bfd *output_bfd,
2225 struct bfd_link_info *info,
2226 bfd *input_bfd,
2227 asection *input_section,
2228 bfd_byte *contents,
2229 Elf_Internal_Rela *relocs,
2230 Elf_Internal_Sym *local_syms,
2231 asection **local_sections)
2232 {
2233 struct elf_s390_link_hash_table *htab;
2234 Elf_Internal_Shdr *symtab_hdr;
2235 struct elf_link_hash_entry **sym_hashes;
2236 bfd_vma *local_got_offsets;
2237 Elf_Internal_Rela *rel;
2238 Elf_Internal_Rela *relend;
2239
2240 BFD_ASSERT (is_s390_elf (input_bfd));
2241
2242 htab = elf_s390_hash_table (info);
2243 if (htab == NULL)
2244 return FALSE;
2245
2246 symtab_hdr = &elf_symtab_hdr (input_bfd);
2247 sym_hashes = elf_sym_hashes (input_bfd);
2248 local_got_offsets = elf_local_got_offsets (input_bfd);
2249
2250 rel = relocs;
2251 relend = relocs + input_section->reloc_count;
2252 for (; rel < relend; rel++)
2253 {
2254 unsigned int r_type;
2255 reloc_howto_type *howto;
2256 unsigned long r_symndx;
2257 struct elf_link_hash_entry *h;
2258 Elf_Internal_Sym *sym;
2259 asection *sec;
2260 bfd_vma off;
2261 bfd_vma relocation;
2262 bfd_boolean unresolved_reloc;
2263 bfd_reloc_status_type r;
2264 int tls_type;
2265 asection *base_got = htab->elf.sgot;
2266
2267 r_type = ELF64_R_TYPE (rel->r_info);
2268 if (r_type == (int) R_390_GNU_VTINHERIT
2269 || r_type == (int) R_390_GNU_VTENTRY)
2270 continue;
2271 if (r_type >= (int) R_390_max)
2272 {
2273 bfd_set_error (bfd_error_bad_value);
2274 return FALSE;
2275 }
2276
2277 howto = elf_howto_table + r_type;
2278 r_symndx = ELF64_R_SYM (rel->r_info);
2279
2280 h = NULL;
2281 sym = NULL;
2282 sec = NULL;
2283 unresolved_reloc = FALSE;
2284 if (r_symndx < symtab_hdr->sh_info)
2285 {
2286 sym = local_syms + r_symndx;
2287 sec = local_sections[r_symndx];
2288
2289 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
2290 {
2291 struct plt_entry *local_plt = elf_s390_local_plt (input_bfd);
2292 if (local_plt == NULL)
2293 return FALSE;
2294
2295 /* Address of the PLT slot. */
2296 relocation = (htab->elf.iplt->output_section->vma
2297 + htab->elf.iplt->output_offset
2298 + local_plt[r_symndx].plt.offset);
2299
2300 switch (r_type)
2301 {
2302 case R_390_PLTOFF16:
2303 case R_390_PLTOFF32:
2304 case R_390_PLTOFF64:
2305 relocation -= htab->elf.sgot->output_section->vma;
2306 break;
2307 case R_390_GOTPLT12:
2308 case R_390_GOTPLT16:
2309 case R_390_GOTPLT20:
2310 case R_390_GOTPLT32:
2311 case R_390_GOTPLT64:
2312 case R_390_GOTPLTENT:
2313 case R_390_GOT12:
2314 case R_390_GOT16:
2315 case R_390_GOT20:
2316 case R_390_GOT32:
2317 case R_390_GOT64:
2318 case R_390_GOTENT:
2319 {
2320 /* Write the PLT slot address into the GOT slot. */
2321 bfd_put_64 (output_bfd, relocation,
2322 htab->elf.sgot->contents +
2323 local_got_offsets[r_symndx]);
2324 relocation = (local_got_offsets[r_symndx] +
2325 htab->elf.sgot->output_offset);
2326
2327 if (r_type == R_390_GOTENT || r_type == R_390_GOTPLTENT)
2328 relocation += htab->elf.sgot->output_section->vma;
2329 break;
2330 }
2331 default:
2332 break;
2333 }
2334 /* The output section is needed later in
2335 finish_dynamic_section when creating the dynamic
2336 relocation. */
2337 local_plt[r_symndx].sec = sec;
2338 goto do_relocation;
2339 }
2340 else
2341 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2342 }
2343 else
2344 {
2345 bfd_boolean warned ATTRIBUTE_UNUSED;
2346
2347 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2348 r_symndx, symtab_hdr, sym_hashes,
2349 h, sec, relocation,
2350 unresolved_reloc, warned);
2351 }
2352
2353 if (sec != NULL && discarded_section (sec))
2354 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2355 rel, 1, relend, howto, 0, contents);
2356
2357 if (info->relocatable)
2358 continue;
2359
2360 switch (r_type)
2361 {
2362 case R_390_GOTPLT12:
2363 case R_390_GOTPLT16:
2364 case R_390_GOTPLT20:
2365 case R_390_GOTPLT32:
2366 case R_390_GOTPLT64:
2367 case R_390_GOTPLTENT:
2368 /* There are three cases for a GOTPLT relocation. 1) The
2369 relocation is against the jump slot entry of a plt that
2370 will get emitted to the output file. 2) The relocation
2371 is against the jump slot of a plt entry that has been
2372 removed. elf_s390_adjust_gotplt has created a GOT entry
2373 as replacement. 3) The relocation is against a local symbol.
2374 Cases 2) and 3) are the same as the GOT relocation code
2375 so we just have to test for case 1 and fall through for
2376 the other two. */
2377 if (h != NULL && h->plt.offset != (bfd_vma) -1)
2378 {
2379 bfd_vma plt_index;
2380
2381 if (s390_is_ifunc_symbol_p (h))
2382 {
2383 plt_index = h->plt.offset / PLT_ENTRY_SIZE;
2384 relocation = (plt_index * GOT_ENTRY_SIZE +
2385 htab->elf.igotplt->output_offset);
2386 if (r_type == R_390_GOTPLTENT)
2387 relocation += htab->elf.igotplt->output_section->vma;
2388 }
2389 else
2390 {
2391 /* Calc. index no.
2392 Current offset - size first entry / entry size. */
2393 plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) /
2394 PLT_ENTRY_SIZE;
2395
2396 /* Offset in GOT is PLT index plus GOT headers(3)
2397 times 4, addr & GOT addr. */
2398 relocation = (plt_index + 3) * GOT_ENTRY_SIZE;
2399 if (r_type == R_390_GOTPLTENT)
2400 relocation += htab->elf.sgot->output_section->vma;
2401 }
2402 unresolved_reloc = FALSE;
2403 break;
2404 }
2405 /* Fall through. */
2406
2407 case R_390_GOT12:
2408 case R_390_GOT16:
2409 case R_390_GOT20:
2410 case R_390_GOT32:
2411 case R_390_GOT64:
2412 case R_390_GOTENT:
2413 /* Relocation is to the entry for this symbol in the global
2414 offset table. */
2415 if (base_got == NULL)
2416 abort ();
2417
2418 if (h != NULL)
2419 {
2420 bfd_boolean dyn;
2421
2422 off = h->got.offset;
2423 dyn = htab->elf.dynamic_sections_created;
2424
2425 if (s390_is_ifunc_symbol_p (h))
2426 {
2427 BFD_ASSERT (h->plt.offset != (bfd_vma) -1);
2428 if (off == (bfd_vma)-1)
2429 {
2430 /* No explicit GOT usage so redirect to the
2431 got.iplt slot. */
2432 base_got = htab->elf.igotplt;
2433 off = h->plt.offset / PLT_ENTRY_SIZE * GOT_ENTRY_SIZE;
2434 }
2435 else
2436 {
2437 /* Explicit GOT slots must contain the address
2438 of the PLT slot. This will be handled in
2439 finish_dynamic_symbol. */
2440 }
2441 }
2442 else if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2443 || (info->shared
2444 && SYMBOL_REFERENCES_LOCAL (info, h))
2445 || (ELF_ST_VISIBILITY (h->other)
2446 && h->root.type == bfd_link_hash_undefweak))
2447 {
2448 /* This is actually a static link, or it is a
2449 -Bsymbolic link and the symbol is defined
2450 locally, or the symbol was forced to be local
2451 because of a version file. We must initialize
2452 this entry in the global offset table. Since the
2453 offset must always be a multiple of 2, we use the
2454 least significant bit to record whether we have
2455 initialized it already.
2456
2457 When doing a dynamic link, we create a .rel.got
2458 relocation entry to initialize the value. This
2459 is done in the finish_dynamic_symbol routine. */
2460 if ((off & 1) != 0)
2461 off &= ~1;
2462 else
2463 {
2464 bfd_put_64 (output_bfd, relocation,
2465 base_got->contents + off);
2466 h->got.offset |= 1;
2467 }
2468 }
2469 else
2470 unresolved_reloc = FALSE;
2471 }
2472 else
2473 {
2474 if (local_got_offsets == NULL)
2475 abort ();
2476
2477 off = local_got_offsets[r_symndx];
2478
2479 /* The offset must always be a multiple of 8. We use
2480 the least significant bit to record whether we have
2481 already generated the necessary reloc. */
2482 if ((off & 1) != 0)
2483 off &= ~1;
2484 else
2485 {
2486 bfd_put_64 (output_bfd, relocation,
2487 htab->elf.sgot->contents + off);
2488
2489 if (info->shared)
2490 {
2491 asection *s;
2492 Elf_Internal_Rela outrel;
2493 bfd_byte *loc;
2494
2495 s = htab->elf.srelgot;
2496 if (s == NULL)
2497 abort ();
2498
2499 outrel.r_offset = (htab->elf.sgot->output_section->vma
2500 + htab->elf.sgot->output_offset
2501 + off);
2502 outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2503 outrel.r_addend = relocation;
2504 loc = s->contents;
2505 loc += s->reloc_count++ * sizeof (Elf64_External_Rela);
2506 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2507 }
2508
2509 local_got_offsets[r_symndx] |= 1;
2510 }
2511 }
2512
2513 if (off >= (bfd_vma) -2)
2514 abort ();
2515
2516 relocation = base_got->output_offset + off;
2517
2518 /* For @GOTENT the relocation is against the offset between
2519 the instruction and the symbols entry in the GOT and not
2520 between the start of the GOT and the symbols entry. We
2521 add the vma of the GOT to get the correct value. */
2522 if ( r_type == R_390_GOTENT
2523 || r_type == R_390_GOTPLTENT)
2524 relocation += base_got->output_section->vma;
2525
2526 break;
2527
2528 case R_390_GOTOFF16:
2529 case R_390_GOTOFF32:
2530 case R_390_GOTOFF64:
2531 /* Relocation is relative to the start of the global offset
2532 table. */
2533
2534 /* Note that sgot->output_offset is not involved in this
2535 calculation. We always want the start of .got. If we
2536 defined _GLOBAL_OFFSET_TABLE in a different way, as is
2537 permitted by the ABI, we might have to change this
2538 calculation. */
2539 relocation -= htab->elf.sgot->output_section->vma;
2540 break;
2541
2542 case R_390_GOTPC:
2543 case R_390_GOTPCDBL:
2544 /* Use global offset table as symbol value. */
2545 relocation = htab->elf.sgot->output_section->vma;
2546 unresolved_reloc = FALSE;
2547 break;
2548
2549 case R_390_PLT16DBL:
2550 case R_390_PLT32:
2551 case R_390_PLT32DBL:
2552 case R_390_PLT64:
2553 /* Relocation is to the entry for this symbol in the
2554 procedure linkage table. */
2555
2556 /* Resolve a PLT32 reloc against a local symbol directly,
2557 without using the procedure linkage table. */
2558 if (h == NULL)
2559 break;
2560
2561 if (h->plt.offset == (bfd_vma) -1
2562 || (htab->elf.splt == NULL && !s390_is_ifunc_symbol_p (h)))
2563 {
2564 /* We didn't make a PLT entry for this symbol. This
2565 happens when statically linking PIC code, or when
2566 using -Bsymbolic. */
2567 break;
2568 }
2569 if (s390_is_ifunc_symbol_p (h))
2570 relocation = (htab->elf.iplt->output_section->vma
2571 + htab->elf.iplt->output_offset
2572 + h->plt.offset);
2573 else
2574 relocation = (htab->elf.splt->output_section->vma
2575 + htab->elf.splt->output_offset
2576 + h->plt.offset);
2577 unresolved_reloc = FALSE;
2578 break;
2579
2580 case R_390_PLTOFF16:
2581 case R_390_PLTOFF32:
2582 case R_390_PLTOFF64:
2583 /* Relocation is to the entry for this symbol in the
2584 procedure linkage table relative to the start of the GOT. */
2585
2586 /* For local symbols or if we didn't make a PLT entry for
2587 this symbol resolve the symbol directly. */
2588 if (h == NULL
2589 || h->plt.offset == (bfd_vma) -1
2590 || (htab->elf.splt == NULL && !s390_is_ifunc_symbol_p (h)))
2591 {
2592 relocation -= htab->elf.sgot->output_section->vma;
2593 break;
2594 }
2595
2596 if (s390_is_ifunc_symbol_p (h))
2597 relocation = (htab->elf.iplt->output_section->vma
2598 + htab->elf.iplt->output_offset
2599 + h->plt.offset
2600 - htab->elf.sgot->output_section->vma);
2601 else
2602 relocation = (htab->elf.splt->output_section->vma
2603 + htab->elf.splt->output_offset
2604 + h->plt.offset
2605 - htab->elf.sgot->output_section->vma);
2606 unresolved_reloc = FALSE;
2607 break;
2608
2609 case R_390_8:
2610 case R_390_16:
2611 case R_390_32:
2612 case R_390_64:
2613 case R_390_PC16:
2614 case R_390_PC16DBL:
2615 case R_390_PC32:
2616 case R_390_PC32DBL:
2617 case R_390_PC64:
2618
2619 if (h != NULL
2620 && s390_is_ifunc_symbol_p (h)
2621 && h->def_regular)
2622 {
2623 if (!info->shared || !h->non_got_ref)
2624 {
2625 /* For a non-shared object STT_GNU_IFUNC symbol must
2626 go through PLT. */
2627 relocation = (htab->elf.iplt->output_section->vma
2628 + htab->elf.iplt->output_offset
2629 + h ->plt.offset);
2630 goto do_relocation;
2631 }
2632 else
2633 {
2634 /* For shared objects a runtime relocation is needed. */
2635
2636 Elf_Internal_Rela outrel;
2637 asection *sreloc;
2638
2639 /* Need a dynamic relocation to get the real function
2640 address. */
2641 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
2642 info,
2643 input_section,
2644 rel->r_offset);
2645 if (outrel.r_offset == (bfd_vma) -1
2646 || outrel.r_offset == (bfd_vma) -2)
2647 abort ();
2648
2649 outrel.r_offset += (input_section->output_section->vma
2650 + input_section->output_offset);
2651
2652 if (h->dynindx == -1
2653 || h->forced_local
2654 || info->executable)
2655 {
2656 /* This symbol is resolved locally. */
2657 outrel.r_info = ELF64_R_INFO (0, R_390_IRELATIVE);
2658 outrel.r_addend = (h->root.u.def.value
2659 + h->root.u.def.section->output_section->vma
2660 + h->root.u.def.section->output_offset);
2661 }
2662 else
2663 {
2664 outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
2665 outrel.r_addend = 0;
2666 }
2667
2668 sreloc = htab->elf.irelifunc;
2669 elf_append_rela (output_bfd, sreloc, &outrel);
2670
2671 /* If this reloc is against an external symbol, we
2672 do not want to fiddle with the addend. Otherwise,
2673 we need to include the symbol value so that it
2674 becomes an addend for the dynamic reloc. For an
2675 internal symbol, we have updated addend. */
2676 continue;
2677 }
2678 }
2679
2680 if ((input_section->flags & SEC_ALLOC) == 0)
2681 break;
2682
2683 if ((info->shared
2684 && (h == NULL
2685 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2686 || h->root.type != bfd_link_hash_undefweak)
2687 && ((r_type != R_390_PC16
2688 && r_type != R_390_PC16DBL
2689 && r_type != R_390_PC32
2690 && r_type != R_390_PC32DBL
2691 && r_type != R_390_PC64)
2692 || !SYMBOL_CALLS_LOCAL (info, h)))
2693 || (ELIMINATE_COPY_RELOCS
2694 && !info->shared
2695 && h != NULL
2696 && h->dynindx != -1
2697 && !h->non_got_ref
2698 && ((h->def_dynamic
2699 && !h->def_regular)
2700 || h->root.type == bfd_link_hash_undefweak
2701 || h->root.type == bfd_link_hash_undefined)))
2702 {
2703 Elf_Internal_Rela outrel;
2704 bfd_boolean skip, relocate;
2705 asection *sreloc;
2706 bfd_byte *loc;
2707
2708 /* When generating a shared object, these relocations
2709 are copied into the output file to be resolved at run
2710 time. */
2711 skip = FALSE;
2712 relocate = FALSE;
2713
2714 outrel.r_offset =
2715 _bfd_elf_section_offset (output_bfd, info, input_section,
2716 rel->r_offset);
2717 if (outrel.r_offset == (bfd_vma) -1)
2718 skip = TRUE;
2719 else if (outrel.r_offset == (bfd_vma) -2)
2720 skip = TRUE, relocate = TRUE;
2721
2722 outrel.r_offset += (input_section->output_section->vma
2723 + input_section->output_offset);
2724
2725 if (skip)
2726 memset (&outrel, 0, sizeof outrel);
2727 else if (h != NULL
2728 && h->dynindx != -1
2729 && (r_type == R_390_PC16
2730 || r_type == R_390_PC16DBL
2731 || r_type == R_390_PC32
2732 || r_type == R_390_PC32DBL
2733 || r_type == R_390_PC64
2734 || !info->shared
2735 || !SYMBOLIC_BIND (info, h)
2736 || !h->def_regular))
2737 {
2738 outrel.r_info = ELF64_R_INFO (h->dynindx, r_type);
2739 outrel.r_addend = rel->r_addend;
2740 }
2741 else
2742 {
2743 /* This symbol is local, or marked to become local. */
2744 outrel.r_addend = relocation + rel->r_addend;
2745 if (r_type == R_390_64)
2746 {
2747 relocate = TRUE;
2748 outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2749 }
2750 else
2751 {
2752 long sindx;
2753
2754 if (bfd_is_abs_section (sec))
2755 sindx = 0;
2756 else if (sec == NULL || sec->owner == NULL)
2757 {
2758 bfd_set_error(bfd_error_bad_value);
2759 return FALSE;
2760 }
2761 else
2762 {
2763 asection *osec;
2764
2765 osec = sec->output_section;
2766 sindx = elf_section_data (osec)->dynindx;
2767
2768 if (sindx == 0)
2769 {
2770 osec = htab->elf.text_index_section;
2771 sindx = elf_section_data (osec)->dynindx;
2772 }
2773 BFD_ASSERT (sindx != 0);
2774
2775 /* We are turning this relocation into one
2776 against a section symbol, so subtract out
2777 the output section's address but not the
2778 offset of the input section in the output
2779 section. */
2780 outrel.r_addend -= osec->vma;
2781 }
2782 outrel.r_info = ELF64_R_INFO (sindx, r_type);
2783 }
2784 }
2785
2786 sreloc = elf_section_data (input_section)->sreloc;
2787 if (sreloc == NULL)
2788 abort ();
2789
2790 loc = sreloc->contents;
2791 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2792 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2793
2794 /* If this reloc is against an external symbol, we do
2795 not want to fiddle with the addend. Otherwise, we
2796 need to include the symbol value so that it becomes
2797 an addend for the dynamic reloc. */
2798 if (! relocate)
2799 continue;
2800 }
2801
2802 break;
2803
2804 /* Relocations for tls literal pool entries. */
2805 case R_390_TLS_IE64:
2806 if (info->shared)
2807 {
2808 Elf_Internal_Rela outrel;
2809 asection *sreloc;
2810 bfd_byte *loc;
2811
2812 outrel.r_offset = rel->r_offset
2813 + input_section->output_section->vma
2814 + input_section->output_offset;
2815 outrel.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
2816 sreloc = elf_section_data (input_section)->sreloc;
2817 if (sreloc == NULL)
2818 abort ();
2819 loc = sreloc->contents;
2820 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
2821 bfd_elf64_swap_reloc_out (output_bfd, &outrel, loc);
2822 }
2823 /* Fall through. */
2824
2825 case R_390_TLS_GD64:
2826 case R_390_TLS_GOTIE64:
2827 r_type = elf_s390_tls_transition (info, r_type, h == NULL);
2828 tls_type = GOT_UNKNOWN;
2829 if (h == NULL && local_got_offsets)
2830 tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
2831 else if (h != NULL)
2832 {
2833 tls_type = elf_s390_hash_entry(h)->tls_type;
2834 if (!info->shared && h->dynindx == -1 && tls_type >= GOT_TLS_IE)
2835 r_type = R_390_TLS_LE64;
2836 }
2837 if (r_type == R_390_TLS_GD64 && tls_type >= GOT_TLS_IE)
2838 r_type = R_390_TLS_IE64;
2839
2840 if (r_type == R_390_TLS_LE64)
2841 {
2842 /* This relocation gets optimized away by the local exec
2843 access optimization. */
2844 BFD_ASSERT (! unresolved_reloc);
2845 bfd_put_64 (output_bfd, -tpoff (info, relocation),
2846 contents + rel->r_offset);
2847 continue;
2848 }
2849
2850 if (htab->elf.sgot == NULL)
2851 abort ();
2852
2853 if (h != NULL)
2854 off = h->got.offset;
2855 else
2856 {
2857 if (local_got_offsets == NULL)
2858 abort ();
2859
2860 off = local_got_offsets[r_symndx];
2861 }
2862
2863 emit_tls_relocs:
2864
2865 if ((off & 1) != 0)
2866 off &= ~1;
2867 else
2868 {
2869 Elf_Internal_Rela outrel;
2870 bfd_byte *loc;
2871 int dr_type, indx;
2872
2873 if (htab->elf.srelgot == NULL)
2874 abort ();
2875
2876 outrel.r_offset = (htab->elf.sgot->output_section->vma
2877 + htab->elf.sgot->output_offset + off);
2878
2879 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2880 if (r_type == R_390_TLS_GD64)
2881 dr_type = R_390_TLS_DTPMOD;
2882 else
2883 dr_type = R_390_TLS_TPOFF;
2884 if (dr_type == R_390_TLS_TPOFF && indx == 0)
2885 outrel.r_addend = relocation - dtpoff_base (info);
2886 else
2887 outrel.r_addend = 0;
2888 outrel.r_info = ELF64_R_INFO (indx, dr_type);
2889 loc = htab->elf.srelgot->contents;
2890 loc += htab->elf.srelgot->reloc_count++
2891 * sizeof (Elf64_External_Rela);
2892 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2893
2894 if (r_type == R_390_TLS_GD64)
2895 {
2896 if (indx == 0)
2897 {
2898 BFD_ASSERT (! unresolved_reloc);
2899 bfd_put_64 (output_bfd,
2900 relocation - dtpoff_base (info),
2901 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
2902 }
2903 else
2904 {
2905 outrel.r_info = ELF64_R_INFO (indx, R_390_TLS_DTPOFF);
2906 outrel.r_offset += GOT_ENTRY_SIZE;
2907 outrel.r_addend = 0;
2908 htab->elf.srelgot->reloc_count++;
2909 loc += sizeof (Elf64_External_Rela);
2910 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
2911 }
2912 }
2913
2914 if (h != NULL)
2915 h->got.offset |= 1;
2916 else
2917 local_got_offsets[r_symndx] |= 1;
2918 }
2919
2920 if (off >= (bfd_vma) -2)
2921 abort ();
2922 if (r_type == ELF64_R_TYPE (rel->r_info))
2923 {
2924 relocation = htab->elf.sgot->output_offset + off;
2925 if (r_type == R_390_TLS_IE64 || r_type == R_390_TLS_IEENT)
2926 relocation += htab->elf.sgot->output_section->vma;
2927 unresolved_reloc = FALSE;
2928 }
2929 else
2930 {
2931 bfd_put_64 (output_bfd, htab->elf.sgot->output_offset + off,
2932 contents + rel->r_offset);
2933 continue;
2934 }
2935 break;
2936
2937 case R_390_TLS_GOTIE12:
2938 case R_390_TLS_GOTIE20:
2939 case R_390_TLS_IEENT:
2940 if (h == NULL)
2941 {
2942 if (local_got_offsets == NULL)
2943 abort();
2944 off = local_got_offsets[r_symndx];
2945 if (info->shared)
2946 goto emit_tls_relocs;
2947 }
2948 else
2949 {
2950 off = h->got.offset;
2951 tls_type = elf_s390_hash_entry(h)->tls_type;
2952 if (info->shared || h->dynindx != -1 || tls_type < GOT_TLS_IE)
2953 goto emit_tls_relocs;
2954 }
2955
2956 if (htab->elf.sgot == NULL)
2957 abort ();
2958
2959 BFD_ASSERT (! unresolved_reloc);
2960 bfd_put_64 (output_bfd, -tpoff (info, relocation),
2961 htab->elf.sgot->contents + off);
2962 relocation = htab->elf.sgot->output_offset + off;
2963 if (r_type == R_390_TLS_IEENT)
2964 relocation += htab->elf.sgot->output_section->vma;
2965 unresolved_reloc = FALSE;
2966 break;
2967
2968 case R_390_TLS_LDM64:
2969 if (! info->shared)
2970 /* The literal pool entry this relocation refers to gets ignored
2971 by the optimized code of the local exec model. Do nothing
2972 and the value will turn out zero. */
2973 continue;
2974
2975 if (htab->elf.sgot == NULL)
2976 abort ();
2977
2978 off = htab->tls_ldm_got.offset;
2979 if (off & 1)
2980 off &= ~1;
2981 else
2982 {
2983 Elf_Internal_Rela outrel;
2984 bfd_byte *loc;
2985
2986 if (htab->elf.srelgot == NULL)
2987 abort ();
2988
2989 outrel.r_offset = (htab->elf.sgot->output_section->vma
2990 + htab->elf.sgot->output_offset + off);
2991
2992 bfd_put_64 (output_bfd, 0,
2993 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
2994 outrel.r_info = ELF64_R_INFO (0, R_390_TLS_DTPMOD);
2995 outrel.r_addend = 0;
2996 loc = htab->elf.srelgot->contents;
2997 loc += htab->elf.srelgot->reloc_count++
2998 * sizeof (Elf64_External_Rela);
2999 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
3000 htab->tls_ldm_got.offset |= 1;
3001 }
3002 relocation = htab->elf.sgot->output_offset + off;
3003 unresolved_reloc = FALSE;
3004 break;
3005
3006 case R_390_TLS_LE64:
3007 if (info->shared)
3008 {
3009 /* Linking a shared library with non-fpic code requires
3010 a R_390_TLS_TPOFF relocation. */
3011 Elf_Internal_Rela outrel;
3012 asection *sreloc;
3013 bfd_byte *loc;
3014 int indx;
3015
3016 outrel.r_offset = rel->r_offset
3017 + input_section->output_section->vma
3018 + input_section->output_offset;
3019 if (h != NULL && h->dynindx != -1)
3020 indx = h->dynindx;
3021 else
3022 indx = 0;
3023 outrel.r_info = ELF64_R_INFO (indx, R_390_TLS_TPOFF);
3024 if (indx == 0)
3025 outrel.r_addend = relocation - dtpoff_base (info);
3026 else
3027 outrel.r_addend = 0;
3028 sreloc = elf_section_data (input_section)->sreloc;
3029 if (sreloc == NULL)
3030 abort ();
3031 loc = sreloc->contents;
3032 loc += sreloc->reloc_count++ * sizeof (Elf64_External_Rela);
3033 bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
3034 }
3035 else
3036 {
3037 BFD_ASSERT (! unresolved_reloc);
3038 bfd_put_64 (output_bfd, -tpoff (info, relocation),
3039 contents + rel->r_offset);
3040 }
3041 continue;
3042
3043 case R_390_TLS_LDO64:
3044 if (info->shared || (input_section->flags & SEC_DEBUGGING))
3045 relocation -= dtpoff_base (info);
3046 else
3047 /* When converting LDO to LE, we must negate. */
3048 relocation = -tpoff (info, relocation);
3049 break;
3050
3051 /* Relocations for tls instructions. */
3052 case R_390_TLS_LOAD:
3053 case R_390_TLS_GDCALL:
3054 case R_390_TLS_LDCALL:
3055 tls_type = GOT_UNKNOWN;
3056 if (h == NULL && local_got_offsets)
3057 tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
3058 else if (h != NULL)
3059 tls_type = elf_s390_hash_entry(h)->tls_type;
3060
3061 if (tls_type == GOT_TLS_GD)
3062 continue;
3063
3064 if (r_type == R_390_TLS_LOAD)
3065 {
3066 if (!info->shared && (h == NULL || h->dynindx == -1))
3067 {
3068 /* IE->LE transition. Four valid cases:
3069 lg %rx,(0,%ry) -> sllg %rx,%ry,0
3070 lg %rx,(%ry,0) -> sllg %rx,%ry,0
3071 lg %rx,(%ry,%r12) -> sllg %rx,%ry,0
3072 lg %rx,(%r12,%ry) -> sllg %rx,%ry,0 */
3073 unsigned int insn0, insn1, ry;
3074
3075 insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset);
3076 insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4);
3077 if (insn1 != 0x0004)
3078 invalid_tls_insn (input_bfd, input_section, rel);
3079 ry = 0;
3080 if ((insn0 & 0xff00f000) == 0xe3000000)
3081 /* lg %rx,0(%ry,0) -> sllg %rx,%ry,0 */
3082 ry = (insn0 & 0x000f0000);
3083 else if ((insn0 & 0xff0f0000) == 0xe3000000)
3084 /* lg %rx,0(0,%ry) -> sllg %rx,%ry,0 */
3085 ry = (insn0 & 0x0000f000) << 4;
3086 else if ((insn0 & 0xff00f000) == 0xe300c000)
3087 /* lg %rx,0(%ry,%r12) -> sllg %rx,%ry,0 */
3088 ry = (insn0 & 0x000f0000);
3089 else if ((insn0 & 0xff0f0000) == 0xe30c0000)
3090 /* lg %rx,0(%r12,%ry) -> sllg %rx,%ry,0 */
3091 ry = (insn0 & 0x0000f000) << 4;
3092 else
3093 invalid_tls_insn (input_bfd, input_section, rel);
3094 insn0 = 0xeb000000 | (insn0 & 0x00f00000) | ry;
3095 insn1 = 0x000d;
3096 bfd_put_32 (output_bfd, insn0, contents + rel->r_offset);
3097 bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4);
3098 }
3099 }
3100 else if (r_type == R_390_TLS_GDCALL)
3101 {
3102 unsigned int insn0, insn1;
3103
3104 insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset);
3105 insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4);
3106 if ((insn0 & 0xffff0000) != 0xc0e50000)
3107 invalid_tls_insn (input_bfd, input_section, rel);
3108 if (!info->shared && (h == NULL || h->dynindx == -1))
3109 {
3110 /* GD->LE transition.
3111 brasl %r14,__tls_get_addr@plt -> brcl 0,. */
3112 insn0 = 0xc0040000;
3113 insn1 = 0x0000;
3114 }
3115 else
3116 {
3117 /* GD->IE transition.
3118 brasl %r14,__tls_get_addr@plt -> lg %r2,0(%r2,%r12) */
3119 insn0 = 0xe322c000;
3120 insn1 = 0x0004;
3121 }
3122 bfd_put_32 (output_bfd, insn0, contents + rel->r_offset);
3123 bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4);
3124 }
3125 else if (r_type == R_390_TLS_LDCALL)
3126 {
3127 if (!info->shared)
3128 {
3129 unsigned int insn0, insn1;
3130
3131 insn0 = bfd_get_32 (input_bfd, contents + rel->r_offset);
3132 insn1 = bfd_get_16 (input_bfd, contents + rel->r_offset + 4);
3133 if ((insn0 & 0xffff0000) != 0xc0e50000)
3134 invalid_tls_insn (input_bfd, input_section, rel);
3135 /* LD->LE transition.
3136 brasl %r14,__tls_get_addr@plt -> brcl 0,. */
3137 insn0 = 0xc0040000;
3138 insn1 = 0x0000;
3139 bfd_put_32 (output_bfd, insn0, contents + rel->r_offset);
3140 bfd_put_16 (output_bfd, insn1, contents + rel->r_offset + 4);
3141 }
3142 }
3143 continue;
3144
3145 default:
3146 break;
3147 }
3148
3149 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3150 because such sections are not SEC_ALLOC and thus ld.so will
3151 not process them. */
3152 if (unresolved_reloc
3153 && !((input_section->flags & SEC_DEBUGGING) != 0
3154 && h->def_dynamic)
3155 && _bfd_elf_section_offset (output_bfd, info, input_section,
3156 rel->r_offset) != (bfd_vma) -1)
3157 (*_bfd_error_handler)
3158 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3159 input_bfd,
3160 input_section,
3161 (long) rel->r_offset,
3162 howto->name,
3163 h->root.root.string);
3164
3165 do_relocation:
3166
3167 if (r_type == R_390_20
3168 || r_type == R_390_GOT20
3169 || r_type == R_390_GOTPLT20
3170 || r_type == R_390_TLS_GOTIE20)
3171 {
3172 relocation += rel->r_addend;
3173 relocation = (relocation&0xfff) << 8 | (relocation&0xff000) >> 12;
3174 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3175 contents, rel->r_offset,
3176 relocation, 0);
3177 }
3178 else
3179 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3180 contents, rel->r_offset,
3181 relocation, rel->r_addend);
3182
3183 if (r != bfd_reloc_ok)
3184 {
3185 const char *name;
3186
3187 if (h != NULL)
3188 name = h->root.root.string;
3189 else
3190 {
3191 name = bfd_elf_string_from_elf_section (input_bfd,
3192 symtab_hdr->sh_link,
3193 sym->st_name);
3194 if (name == NULL)
3195 return FALSE;
3196 if (*name == '\0')
3197 name = bfd_section_name (input_bfd, sec);
3198 }
3199
3200 if (r == bfd_reloc_overflow)
3201 {
3202
3203 if (! ((*info->callbacks->reloc_overflow)
3204 (info, (h ? &h->root : NULL), name, howto->name,
3205 (bfd_vma) 0, input_bfd, input_section,
3206 rel->r_offset)))
3207 return FALSE;
3208 }
3209 else
3210 {
3211 (*_bfd_error_handler)
3212 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3213 input_bfd, input_section,
3214 (long) rel->r_offset, name, (int) r);
3215 return FALSE;
3216 }
3217 }
3218 }
3219
3220 return TRUE;
3221 }
3222
3223 /* Generate the PLT slots together with the dynamic relocations needed
3224 for IFUNC symbols. */
3225
3226 static void
3227 elf_s390_finish_ifunc_symbol (bfd *output_bfd,
3228 struct bfd_link_info *info,
3229 struct elf_link_hash_entry *h,
3230 struct elf_s390_link_hash_table *htab,
3231 bfd_vma plt_offset,
3232 bfd_vma resolver_address)
3233 {
3234 bfd_vma plt_index;
3235 bfd_vma got_offset;
3236 Elf_Internal_Rela rela;
3237 bfd_byte *loc;
3238 asection *plt, *gotplt, *relplt;
3239
3240 if (htab->elf.iplt == NULL
3241 || htab->elf.igotplt == NULL
3242 || htab->elf.irelplt == NULL)
3243 abort ();
3244
3245 /* Index of the PLT slot within iplt section. */
3246 plt_index = plt_offset / PLT_ENTRY_SIZE;
3247 plt = htab->elf.iplt;
3248 /* Offset into the igot.plt section. */
3249 got_offset = plt_index * GOT_ENTRY_SIZE;
3250 gotplt = htab->elf.igotplt;
3251 relplt = htab->elf.irelplt;
3252
3253 /* Fill in the blueprint of a PLT. */
3254 memcpy (plt->contents + plt_offset, elf_s390x_plt_entry,
3255 PLT_ENTRY_SIZE);
3256
3257 /* Fixup the relative address to the GOT entry */
3258 bfd_put_32 (output_bfd,
3259 (gotplt->output_section->vma +
3260 gotplt->output_offset + got_offset
3261 - (plt->output_section->vma +
3262 plt->output_offset +
3263 plt_offset))/2,
3264 plt->contents + plt_offset + 2);
3265 /* Fixup the relative branch to PLT 0 */
3266 bfd_put_32 (output_bfd, - (plt->output_offset +
3267 (PLT_ENTRY_SIZE * plt_index) + 22)/2,
3268 plt->contents + plt_offset + 24);
3269 /* Fixup offset into .rela.plt section. */
3270 bfd_put_32 (output_bfd, relplt->output_offset +
3271 plt_index * sizeof (Elf64_External_Rela),
3272 plt->contents + plt_offset + 28);
3273
3274 /* Fill in the entry in the global offset table.
3275 Points to instruction after GOT offset. */
3276 bfd_put_64 (output_bfd,
3277 (plt->output_section->vma
3278 + plt->output_offset
3279 + plt_offset
3280 + 14),
3281 gotplt->contents + got_offset);
3282
3283 /* Fill in the entry in the .rela.plt section. */
3284 rela.r_offset = (gotplt->output_section->vma
3285 + gotplt->output_offset
3286 + got_offset);
3287
3288 if (!h
3289 || h->dynindx == -1
3290 || ((info->executable
3291 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
3292 && h->def_regular))
3293 {
3294 /* The symbol can be locally resolved. */
3295 rela.r_info = ELF64_R_INFO (0, R_390_IRELATIVE);
3296 rela.r_addend = resolver_address;
3297 }
3298 else
3299 {
3300 rela.r_info = ELF64_R_INFO (h->dynindx, R_390_JMP_SLOT);
3301 rela.r_addend = 0;
3302 }
3303
3304 loc = relplt->contents + plt_index * sizeof (Elf64_External_Rela);
3305 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3306 }
3307
3308
3309 /* Finish up dynamic symbol handling. We set the contents of various
3310 dynamic sections here. */
3311
3312 static bfd_boolean
3313 elf_s390_finish_dynamic_symbol (bfd *output_bfd,
3314 struct bfd_link_info *info,
3315 struct elf_link_hash_entry *h,
3316 Elf_Internal_Sym *sym)
3317 {
3318 struct elf_s390_link_hash_table *htab;
3319 struct elf_s390_link_hash_entry *eh = (struct elf_s390_link_hash_entry*)h;
3320
3321 htab = elf_s390_hash_table (info);
3322 if (htab == NULL)
3323 return FALSE;
3324
3325 if (h->plt.offset != (bfd_vma) -1)
3326 {
3327 bfd_vma plt_index;
3328 bfd_vma got_offset;
3329 Elf_Internal_Rela rela;
3330 bfd_byte *loc;
3331
3332 /* This symbol has an entry in the procedure linkage table. Set
3333 it up. */
3334 if (s390_is_ifunc_symbol_p (h))
3335 {
3336 /* If we can resolve the IFUNC symbol locally we generate an
3337 IRELATIVE reloc. */
3338 elf_s390_finish_ifunc_symbol (output_bfd, info, h, htab, h->plt.offset,
3339 eh->ifunc_resolver_address +
3340 eh->ifunc_resolver_section->output_offset +
3341 eh->ifunc_resolver_section->output_section->vma);
3342 ;
3343 /* Fallthrough. Handling of explicit GOT slots of IFUNC
3344 symbols is below. */
3345 }
3346 else
3347 {
3348 if (h->dynindx == -1
3349 || htab->elf.splt == NULL
3350 || htab->elf.sgotplt == NULL
3351 || htab->elf.srelplt == NULL)
3352 abort ();
3353
3354 /* Calc. index no.
3355 Current offset - size first entry / entry size. */
3356 plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3357
3358 /* Offset in GOT is PLT index plus GOT headers(3) times 8,
3359 addr & GOT addr. */
3360 got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
3361
3362 /* Fill in the blueprint of a PLT. */
3363 memcpy (htab->elf.splt->contents + h->plt.offset, elf_s390x_plt_entry,
3364 PLT_ENTRY_SIZE);
3365
3366 /* Fixup the relative address to the GOT entry */
3367 bfd_put_32 (output_bfd,
3368 (htab->elf.sgotplt->output_section->vma +
3369 htab->elf.sgotplt->output_offset + got_offset
3370 - (htab->elf.splt->output_section->vma +
3371 htab->elf.splt->output_offset +
3372 h->plt.offset))/2,
3373 htab->elf.splt->contents + h->plt.offset + 2);
3374 /* Fixup the relative branch to PLT 0 */
3375 bfd_put_32 (output_bfd, - (PLT_FIRST_ENTRY_SIZE +
3376 (PLT_ENTRY_SIZE * plt_index) + 22)/2,
3377 htab->elf.splt->contents + h->plt.offset + 24);
3378 /* Fixup offset into .rela.plt section. */
3379 bfd_put_32 (output_bfd, plt_index * sizeof (Elf64_External_Rela),
3380 htab->elf.splt->contents + h->plt.offset + 28);
3381
3382 /* Fill in the entry in the global offset table.
3383 Points to instruction after GOT offset. */
3384 bfd_put_64 (output_bfd,
3385 (htab->elf.splt->output_section->vma
3386 + htab->elf.splt->output_offset
3387 + h->plt.offset
3388 + 14),
3389 htab->elf.sgotplt->contents + got_offset);
3390
3391 /* Fill in the entry in the .rela.plt section. */
3392 rela.r_offset = (htab->elf.sgotplt->output_section->vma
3393 + htab->elf.sgotplt->output_offset
3394 + got_offset);
3395 rela.r_info = ELF64_R_INFO (h->dynindx, R_390_JMP_SLOT);
3396 rela.r_addend = 0;
3397 loc = htab->elf.srelplt->contents + plt_index *
3398 sizeof (Elf64_External_Rela);
3399 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3400
3401 if (!h->def_regular)
3402 {
3403 /* Mark the symbol as undefined, rather than as defined in
3404 the .plt section. Leave the value alone. This is a clue
3405 for the dynamic linker, to make function pointer
3406 comparisons work between an application and shared
3407 library. */
3408 sym->st_shndx = SHN_UNDEF;
3409 }
3410 }
3411 }
3412
3413 if (h->got.offset != (bfd_vma) -1
3414 && elf_s390_hash_entry(h)->tls_type != GOT_TLS_GD
3415 && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE
3416 && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE_NLT)
3417 {
3418 Elf_Internal_Rela rela;
3419 bfd_byte *loc;
3420
3421 /* This symbol has an entry in the global offset table. Set it
3422 up. */
3423 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
3424 abort ();
3425
3426 rela.r_offset = (htab->elf.sgot->output_section->vma
3427 + htab->elf.sgot->output_offset
3428 + (h->got.offset &~ (bfd_vma) 1));
3429
3430 if (h->def_regular && s390_is_ifunc_symbol_p (h))
3431 {
3432 if (info->shared)
3433 {
3434 /* An explicit GOT slot usage needs GLOB_DAT. If the
3435 symbol references local the implicit got.iplt slot
3436 will be used and the IRELATIVE reloc has been created
3437 above. */
3438 goto do_glob_dat;
3439 }
3440 else
3441 {
3442 /* For non-shared objects explicit GOT slots must be
3443 filled with the PLT slot address for pointer
3444 equality reasons. */
3445 bfd_put_64 (output_bfd, (htab->elf.iplt->output_section->vma
3446 + htab->elf.iplt->output_offset
3447 + h->plt.offset),
3448 htab->elf.sgot->contents + h->got.offset);
3449 return TRUE;
3450 }
3451 }
3452 else if (info->shared
3453 && SYMBOL_REFERENCES_LOCAL (info, h))
3454 {
3455 /* If this is a static link, or it is a -Bsymbolic link and
3456 the symbol is defined locally or was forced to be local
3457 because of a version file, we just want to emit a
3458 RELATIVE reloc. The entry in the global offset table
3459 will already have been initialized in the
3460 relocate_section function. */
3461 if (!h->def_regular)
3462 return FALSE;
3463 BFD_ASSERT((h->got.offset & 1) != 0);
3464 rela.r_info = ELF64_R_INFO (0, R_390_RELATIVE);
3465 rela.r_addend = (h->root.u.def.value
3466 + h->root.u.def.section->output_section->vma
3467 + h->root.u.def.section->output_offset);
3468 }
3469 else
3470 {
3471 BFD_ASSERT((h->got.offset & 1) == 0);
3472 do_glob_dat:
3473 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgot->contents + h->got.offset);
3474 rela.r_info = ELF64_R_INFO (h->dynindx, R_390_GLOB_DAT);
3475 rela.r_addend = 0;
3476 }
3477
3478 loc = htab->elf.srelgot->contents;
3479 loc += htab->elf.srelgot->reloc_count++ * sizeof (Elf64_External_Rela);
3480 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3481 }
3482
3483 if (h->needs_copy)
3484 {
3485 Elf_Internal_Rela rela;
3486 bfd_byte *loc;
3487
3488 /* This symbols needs a copy reloc. Set it up. */
3489
3490 if (h->dynindx == -1
3491 || (h->root.type != bfd_link_hash_defined
3492 && h->root.type != bfd_link_hash_defweak)
3493 || htab->srelbss == NULL)
3494 abort ();
3495
3496 rela.r_offset = (h->root.u.def.value
3497 + h->root.u.def.section->output_section->vma
3498 + h->root.u.def.section->output_offset);
3499 rela.r_info = ELF64_R_INFO (h->dynindx, R_390_COPY);
3500 rela.r_addend = 0;
3501 loc = htab->srelbss->contents;
3502 loc += htab->srelbss->reloc_count++ * sizeof (Elf64_External_Rela);
3503 bfd_elf64_swap_reloca_out (output_bfd, &rela, loc);
3504 }
3505
3506 /* Mark some specially defined symbols as absolute. */
3507 if (h == htab->elf.hdynamic
3508 || h == htab->elf.hgot
3509 || h == htab->elf.hplt)
3510 sym->st_shndx = SHN_ABS;
3511
3512 return TRUE;
3513 }
3514
3515 /* Used to decide how to sort relocs in an optimal manner for the
3516 dynamic linker, before writing them out. */
3517
3518 static enum elf_reloc_type_class
3519 elf_s390_reloc_type_class (const Elf_Internal_Rela *rela)
3520 {
3521 switch ((int) ELF64_R_TYPE (rela->r_info))
3522 {
3523 case R_390_RELATIVE:
3524 return reloc_class_relative;
3525 case R_390_JMP_SLOT:
3526 return reloc_class_plt;
3527 case R_390_COPY:
3528 return reloc_class_copy;
3529 default:
3530 return reloc_class_normal;
3531 }
3532 }
3533
3534 /* Finish up the dynamic sections. */
3535
3536 static bfd_boolean
3537 elf_s390_finish_dynamic_sections (bfd *output_bfd,
3538 struct bfd_link_info *info)
3539 {
3540 struct elf_s390_link_hash_table *htab;
3541 bfd *dynobj;
3542 asection *sdyn;
3543 bfd *ibfd;
3544 unsigned int i;
3545
3546 htab = elf_s390_hash_table (info);
3547 if (htab == NULL)
3548 return FALSE;
3549
3550 dynobj = htab->elf.dynobj;
3551 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3552
3553 if (htab->elf.dynamic_sections_created)
3554 {
3555 Elf64_External_Dyn *dyncon, *dynconend;
3556
3557 if (sdyn == NULL || htab->elf.sgot == NULL)
3558 abort ();
3559
3560 dyncon = (Elf64_External_Dyn *) sdyn->contents;
3561 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
3562 for (; dyncon < dynconend; dyncon++)
3563 {
3564 Elf_Internal_Dyn dyn;
3565 asection *s;
3566
3567 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
3568
3569 switch (dyn.d_tag)
3570 {
3571 default:
3572 continue;
3573
3574 case DT_PLTGOT:
3575 dyn.d_un.d_ptr = htab->elf.sgot->output_section->vma;
3576 break;
3577
3578 case DT_JMPREL:
3579 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
3580 break;
3581
3582 case DT_PLTRELSZ:
3583 s = htab->elf.srelplt->output_section;
3584 dyn.d_un.d_val = s->size;
3585 break;
3586
3587 case DT_RELASZ:
3588 /* The procedure linkage table relocs (DT_JMPREL) should
3589 not be included in the overall relocs (DT_RELA).
3590 Therefore, we override the DT_RELASZ entry here to
3591 make it not include the JMPREL relocs. Since the
3592 linker script arranges for .rela.plt to follow all
3593 other relocation sections, we don't have to worry
3594 about changing the DT_RELA entry. */
3595 s = htab->elf.srelplt->output_section;
3596 dyn.d_un.d_val -= s->size;
3597 break;
3598 }
3599
3600 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
3601 }
3602
3603 /* Fill in the special first entry in the procedure linkage table. */
3604 if (htab->elf.splt && htab->elf.splt->size > 0)
3605 {
3606 /* fill in blueprint for plt 0 entry */
3607 memcpy (htab->elf.splt->contents, elf_s390x_first_plt_entry,
3608 PLT_FIRST_ENTRY_SIZE);
3609 /* Fixup relative address to start of GOT */
3610 bfd_put_32 (output_bfd,
3611 (htab->elf.sgotplt->output_section->vma +
3612 htab->elf.sgotplt->output_offset
3613 - htab->elf.splt->output_section->vma - 6)/2,
3614 htab->elf.splt->contents + 8);
3615 }
3616 elf_section_data (htab->elf.splt->output_section)
3617 ->this_hdr.sh_entsize = PLT_ENTRY_SIZE;
3618 }
3619
3620 if (htab->elf.sgotplt)
3621 {
3622 /* Fill in the first three entries in the global offset table. */
3623 if (htab->elf.sgotplt->size > 0)
3624 {
3625 bfd_put_64 (output_bfd,
3626 (sdyn == NULL ? (bfd_vma) 0
3627 : sdyn->output_section->vma + sdyn->output_offset),
3628 htab->elf.sgotplt->contents);
3629 /* One entry for shared object struct ptr. */
3630 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + 8);
3631 /* One entry for _dl_runtime_resolve. */
3632 bfd_put_64 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + 12);
3633 }
3634
3635 elf_section_data (htab->elf.sgot->output_section)
3636 ->this_hdr.sh_entsize = 8;
3637 }
3638
3639 /* Finish dynamic symbol for local IFUNC symbols. */
3640 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3641 {
3642 struct plt_entry *local_plt;
3643 Elf_Internal_Sym *isym;
3644 Elf_Internal_Shdr *symtab_hdr;
3645
3646 symtab_hdr = &elf_symtab_hdr (ibfd);
3647
3648 local_plt = elf_s390_local_plt (ibfd);
3649 if (local_plt != NULL)
3650 for (i = 0; i < symtab_hdr->sh_info; i++)
3651 {
3652 if (local_plt[i].plt.offset != (bfd_vma) -1)
3653 {
3654 asection *sec = local_plt[i].sec;
3655 isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, i);
3656 if (isym == NULL)
3657 return FALSE;
3658
3659 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
3660 elf_s390_finish_ifunc_symbol (output_bfd, info, NULL, htab,
3661 local_plt[i].plt.offset,
3662 isym->st_value
3663 + sec->output_section->vma
3664 + sec->output_offset);
3665
3666 }
3667 }
3668 }
3669
3670 return TRUE;
3671 }
3672
3673 /* Return address for Ith PLT stub in section PLT, for relocation REL
3674 or (bfd_vma) -1 if it should not be included. */
3675
3676 static bfd_vma
3677 elf_s390_plt_sym_val (bfd_vma i, const asection *plt,
3678 const arelent *rel ATTRIBUTE_UNUSED)
3679 {
3680 return plt->vma + PLT_FIRST_ENTRY_SIZE + i * PLT_ENTRY_SIZE;
3681 }
3682
3683 /* Why was the hash table entry size definition changed from
3684 ARCH_SIZE/8 to 4? This breaks the 64 bit dynamic linker and
3685 this is the only reason for the s390_elf64_size_info structure. */
3686
3687 const struct elf_size_info s390_elf64_size_info =
3688 {
3689 sizeof (Elf64_External_Ehdr),
3690 sizeof (Elf64_External_Phdr),
3691 sizeof (Elf64_External_Shdr),
3692 sizeof (Elf64_External_Rel),
3693 sizeof (Elf64_External_Rela),
3694 sizeof (Elf64_External_Sym),
3695 sizeof (Elf64_External_Dyn),
3696 sizeof (Elf_External_Note),
3697 8, /* hash-table entry size. */
3698 1, /* internal relocations per external relocations. */
3699 64, /* arch_size. */
3700 3, /* log_file_align. */
3701 ELFCLASS64, EV_CURRENT,
3702 bfd_elf64_write_out_phdrs,
3703 bfd_elf64_write_shdrs_and_ehdr,
3704 bfd_elf64_checksum_contents,
3705 bfd_elf64_write_relocs,
3706 bfd_elf64_swap_symbol_in,
3707 bfd_elf64_swap_symbol_out,
3708 bfd_elf64_slurp_reloc_table,
3709 bfd_elf64_slurp_symbol_table,
3710 bfd_elf64_swap_dyn_in,
3711 bfd_elf64_swap_dyn_out,
3712 bfd_elf64_swap_reloc_in,
3713 bfd_elf64_swap_reloc_out,
3714 bfd_elf64_swap_reloca_in,
3715 bfd_elf64_swap_reloca_out
3716 };
3717
3718 #define TARGET_BIG_SYM bfd_elf64_s390_vec
3719 #define TARGET_BIG_NAME "elf64-s390"
3720 #define ELF_ARCH bfd_arch_s390
3721 #define ELF_TARGET_ID S390_ELF_DATA
3722 #define ELF_MACHINE_CODE EM_S390
3723 #define ELF_MACHINE_ALT1 EM_S390_OLD
3724 #define ELF_MAXPAGESIZE 0x1000
3725
3726 #define elf_backend_size_info s390_elf64_size_info
3727
3728 #define elf_backend_can_gc_sections 1
3729 #define elf_backend_can_refcount 1
3730 #define elf_backend_want_got_plt 1
3731 #define elf_backend_plt_readonly 1
3732 #define elf_backend_want_plt_sym 0
3733 #define elf_backend_got_header_size 24
3734 #define elf_backend_rela_normal 1
3735
3736 #define elf_info_to_howto elf_s390_info_to_howto
3737
3738 #define bfd_elf64_bfd_is_local_label_name elf_s390_is_local_label_name
3739 #define bfd_elf64_bfd_link_hash_table_create elf_s390_link_hash_table_create
3740 #define bfd_elf64_bfd_reloc_type_lookup elf_s390_reloc_type_lookup
3741 #define bfd_elf64_bfd_reloc_name_lookup elf_s390_reloc_name_lookup
3742
3743 #define elf_backend_adjust_dynamic_symbol elf_s390_adjust_dynamic_symbol
3744 #define elf_backend_check_relocs elf_s390_check_relocs
3745 #define elf_backend_copy_indirect_symbol elf_s390_copy_indirect_symbol
3746 #define elf_backend_create_dynamic_sections elf_s390_create_dynamic_sections
3747 #define elf_backend_finish_dynamic_sections elf_s390_finish_dynamic_sections
3748 #define elf_backend_finish_dynamic_symbol elf_s390_finish_dynamic_symbol
3749 #define elf_backend_gc_mark_hook elf_s390_gc_mark_hook
3750 #define elf_backend_gc_sweep_hook elf_s390_gc_sweep_hook
3751 #define elf_backend_reloc_type_class elf_s390_reloc_type_class
3752 #define elf_backend_relocate_section elf_s390_relocate_section
3753 #define elf_backend_size_dynamic_sections elf_s390_size_dynamic_sections
3754 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
3755 #define elf_backend_reloc_type_class elf_s390_reloc_type_class
3756 #define elf_backend_plt_sym_val elf_s390_plt_sym_val
3757 #define elf_backend_add_symbol_hook elf_s390_add_symbol_hook
3758
3759 #define bfd_elf64_mkobject elf_s390_mkobject
3760 #define elf_backend_object_p elf_s390_object_p
3761
3762 /* Enable ELF64 archive functions. */
3763 #define bfd_elf64_archive_functions
3764 extern bfd_boolean bfd_elf64_archive_slurp_armap (bfd *);
3765 extern bfd_boolean bfd_elf64_archive_write_armap (bfd *, unsigned int, struct orl *, unsigned int, int);
3766
3767 #define bfd_elf64_archive_slurp_extended_name_table _bfd_archive_coff_slurp_extended_name_table
3768 #define bfd_elf64_archive_construct_extended_name_table _bfd_archive_coff_construct_extended_name_table
3769 #define bfd_elf64_archive_truncate_arname _bfd_archive_coff_truncate_arname
3770 #define bfd_elf64_archive_read_ar_hdr _bfd_archive_coff_read_ar_hdr
3771 #define bfd_elf64_archive_write_ar_hdr _bfd_archive_coff_write_ar_hdr
3772 #define bfd_elf64_archive_openr_next_archived_file _bfd_archive_coff_openr_next_archived_file
3773 #define bfd_elf64_archive_get_elt_at_index _bfd_archive_coff_get_elt_at_index
3774 #define bfd_elf64_archive_generic_stat_arch_elt _bfd_archive_coff_generic_stat_arch_elt
3775 #define bfd_elf64_archive_update_armap_timestamp _bfd_archive_coff_update_armap_timestamp
3776
3777 #include "elf64-target.h"
The GNU Binutils are a collection of binary tools.