projects / deliverable / binutils-gdb.git / blob
? search:


42f230d9b14c0d8029fc2d54426765d4792687a4
[deliverable/binutils-gdb.git] / bfd / elf32-s390.c
1 /* IBM S/390-specific support for 32-bit ELF
2 Copyright (C) 2000-2020 Free Software Foundation, Inc.
3 Contributed by Carl B. Pedersen and Martin Schwidefsky.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
20 02110-1301, USA. */
21
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "bfdlink.h"
25 #include "libbfd.h"
26 #include "elf-bfd.h"
27 #include "elf/s390.h"
28 #include <stdarg.h>
29
30 static bfd_reloc_status_type
31 s390_tls_reloc (bfd *, arelent *, asymbol *, void *,
32 asection *, bfd *, char **);
33 static bfd_reloc_status_type
34 s390_elf_ldisp_reloc (bfd *, arelent *, asymbol *, void *,
35 asection *, bfd *, char **);
36
37 /* The relocation "howto" table. */
38
39 static reloc_howto_type elf_howto_table[] =
40 {
41 HOWTO (R_390_NONE, /* type */
42 0, /* rightshift */
43 3, /* size (0 = byte, 1 = 2 byte, 2 = 4 byte) */
44 0, /* bitsize */
45 FALSE, /* pc_relative */
46 0, /* bitpos */
47 complain_overflow_dont, /* complain_on_overflow */
48 bfd_elf_generic_reloc, /* special_function */
49 "R_390_NONE", /* name */
50 FALSE, /* partial_inplace */
51 0, /* src_mask */
52 0, /* dst_mask */
53 FALSE), /* pcrel_offset */
54
55 HOWTO(R_390_8, 0, 0, 8, FALSE, 0, complain_overflow_bitfield,
56 bfd_elf_generic_reloc, "R_390_8", FALSE, 0,0x000000ff, FALSE),
57 HOWTO(R_390_12, 0, 1, 12, FALSE, 0, complain_overflow_dont,
58 bfd_elf_generic_reloc, "R_390_12", FALSE, 0,0x00000fff, FALSE),
59 HOWTO(R_390_16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
60 bfd_elf_generic_reloc, "R_390_16", FALSE, 0,0x0000ffff, FALSE),
61 HOWTO(R_390_32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
62 bfd_elf_generic_reloc, "R_390_32", FALSE, 0,0xffffffff, FALSE),
63 HOWTO(R_390_PC32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
64 bfd_elf_generic_reloc, "R_390_PC32", FALSE, 0,0xffffffff, TRUE),
65 HOWTO(R_390_GOT12, 0, 1, 12, FALSE, 0, complain_overflow_bitfield,
66 bfd_elf_generic_reloc, "R_390_GOT12", FALSE, 0,0x00000fff, FALSE),
67 HOWTO(R_390_GOT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
68 bfd_elf_generic_reloc, "R_390_GOT32", FALSE, 0,0xffffffff, FALSE),
69 HOWTO(R_390_PLT32, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
70 bfd_elf_generic_reloc, "R_390_PLT32", FALSE, 0,0xffffffff, TRUE),
71 HOWTO(R_390_COPY, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
72 bfd_elf_generic_reloc, "R_390_COPY", FALSE, 0,0xffffffff, FALSE),
73 HOWTO(R_390_GLOB_DAT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
74 bfd_elf_generic_reloc, "R_390_GLOB_DAT", FALSE, 0,0xffffffff, FALSE),
75 HOWTO(R_390_JMP_SLOT, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
76 bfd_elf_generic_reloc, "R_390_JMP_SLOT", FALSE, 0,0xffffffff, FALSE),
77 HOWTO(R_390_RELATIVE, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
78 bfd_elf_generic_reloc, "R_390_RELATIVE", FALSE, 0,0xffffffff, FALSE),
79 HOWTO(R_390_GOTOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
80 bfd_elf_generic_reloc, "R_390_GOTOFF32", FALSE, 0,0xffffffff, FALSE),
81 HOWTO(R_390_GOTPC, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
82 bfd_elf_generic_reloc, "R_390_GOTPC", FALSE, 0,0xffffffff, TRUE),
83 HOWTO(R_390_GOT16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
84 bfd_elf_generic_reloc, "R_390_GOT16", FALSE, 0,0x0000ffff, FALSE),
85 HOWTO(R_390_PC16, 0, 1, 16, TRUE, 0, complain_overflow_bitfield,
86 bfd_elf_generic_reloc, "R_390_PC16", FALSE, 0,0x0000ffff, TRUE),
87 HOWTO(R_390_PC16DBL, 1, 1, 16, TRUE, 0, complain_overflow_bitfield,
88 bfd_elf_generic_reloc, "R_390_PC16DBL", FALSE, 0,0x0000ffff, TRUE),
89 HOWTO(R_390_PLT16DBL, 1, 1, 16, TRUE, 0, complain_overflow_bitfield,
90 bfd_elf_generic_reloc, "R_390_PLT16DBL", FALSE, 0,0x0000ffff, TRUE),
91 HOWTO(R_390_PC32DBL, 1, 2, 32, TRUE, 0, complain_overflow_bitfield,
92 bfd_elf_generic_reloc, "R_390_PC32DBL", FALSE, 0,0xffffffff, TRUE),
93 HOWTO(R_390_PLT32DBL, 1, 2, 32, TRUE, 0, complain_overflow_bitfield,
94 bfd_elf_generic_reloc, "R_390_PLT32DBL", FALSE, 0,0xffffffff, TRUE),
95 HOWTO(R_390_GOTPCDBL, 1, 2, 32, TRUE, 0, complain_overflow_bitfield,
96 bfd_elf_generic_reloc, "R_390_GOTPCDBL", FALSE, 0,0xffffffff, TRUE),
97 EMPTY_HOWTO (R_390_64), /* Empty entry for R_390_64. */
98 EMPTY_HOWTO (R_390_PC64), /* Empty entry for R_390_PC64. */
99 EMPTY_HOWTO (R_390_GOT64), /* Empty entry for R_390_GOT64. */
100 EMPTY_HOWTO (R_390_PLT64), /* Empty entry for R_390_PLT64. */
101 HOWTO(R_390_GOTENT, 1, 2, 32, TRUE, 0, complain_overflow_bitfield,
102 bfd_elf_generic_reloc, "R_390_GOTENT", FALSE, 0,0xffffffff, TRUE),
103 HOWTO(R_390_GOTOFF16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
104 bfd_elf_generic_reloc, "R_390_GOTOFF16", FALSE, 0,0x0000ffff, FALSE),
105 EMPTY_HOWTO (R_390_GOTOFF64), /* Empty entry for R_390_GOTOFF64. */
106 HOWTO(R_390_GOTPLT12, 0, 1, 12, FALSE, 0, complain_overflow_dont,
107 bfd_elf_generic_reloc, "R_390_GOTPLT12", FALSE, 0,0x00000fff, FALSE),
108 HOWTO(R_390_GOTPLT16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
109 bfd_elf_generic_reloc, "R_390_GOTPLT16", FALSE, 0,0x0000ffff, FALSE),
110 HOWTO(R_390_GOTPLT32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
111 bfd_elf_generic_reloc, "R_390_GOTPLT32", FALSE, 0,0xffffffff, FALSE),
112 EMPTY_HOWTO (R_390_GOTPLT64), /* Empty entry for R_390_GOTPLT64. */
113 HOWTO(R_390_GOTPLTENT, 1, 2, 32, TRUE, 0, complain_overflow_bitfield,
114 bfd_elf_generic_reloc, "R_390_GOTPLTENT",FALSE, 0,0xffffffff, TRUE),
115 HOWTO(R_390_PLTOFF16, 0, 1, 16, FALSE, 0, complain_overflow_bitfield,
116 bfd_elf_generic_reloc, "R_390_PLTOFF16", FALSE, 0,0x0000ffff, FALSE),
117 HOWTO(R_390_PLTOFF32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
118 bfd_elf_generic_reloc, "R_390_PLTOFF32", FALSE, 0,0xffffffff, FALSE),
119 EMPTY_HOWTO (R_390_PLTOFF64), /* Empty entry for R_390_PLTOFF64. */
120 HOWTO(R_390_TLS_LOAD, 0, 0, 0, FALSE, 0, complain_overflow_dont,
121 s390_tls_reloc, "R_390_TLS_LOAD", FALSE, 0, 0, FALSE),
122 HOWTO(R_390_TLS_GDCALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
123 s390_tls_reloc, "R_390_TLS_GDCALL", FALSE, 0, 0, FALSE),
124 HOWTO(R_390_TLS_LDCALL, 0, 0, 0, FALSE, 0, complain_overflow_dont,
125 s390_tls_reloc, "R_390_TLS_LDCALL", FALSE, 0, 0, FALSE),
126 HOWTO(R_390_TLS_GD32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
127 bfd_elf_generic_reloc, "R_390_TLS_GD32", FALSE, 0, 0xffffffff, FALSE),
128 EMPTY_HOWTO (R_390_TLS_GD64), /* Empty entry for R_390_TLS_GD64. */
129 HOWTO(R_390_TLS_GOTIE12, 0, 1, 12, FALSE, 0, complain_overflow_dont,
130 bfd_elf_generic_reloc, "R_390_TLS_GOTIE12", FALSE, 0, 0x00000fff, FALSE),
131 HOWTO(R_390_TLS_GOTIE32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
132 bfd_elf_generic_reloc, "R_390_TLS_GOTIE32", FALSE, 0, 0xffffffff, FALSE),
133 EMPTY_HOWTO (R_390_TLS_GOTIE64), /* Empty entry for R_390_TLS_GOTIE64. */
134 HOWTO(R_390_TLS_LDM32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
135 bfd_elf_generic_reloc, "R_390_TLS_LDM32", FALSE, 0, 0xffffffff, FALSE),
136 EMPTY_HOWTO (R_390_TLS_LDM64), /* Empty entry for R_390_TLS_LDM64. */
137 HOWTO(R_390_TLS_IE32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
138 bfd_elf_generic_reloc, "R_390_TLS_IE32", FALSE, 0, 0xffffffff, FALSE),
139 EMPTY_HOWTO (R_390_TLS_IE64), /* Empty entry for R_390_TLS_IE64. */
140 HOWTO(R_390_TLS_IEENT, 1, 2, 32, TRUE, 0, complain_overflow_bitfield,
141 bfd_elf_generic_reloc, "R_390_TLS_IEENT", FALSE, 0, 0xffffffff, TRUE),
142 HOWTO(R_390_TLS_LE32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
143 bfd_elf_generic_reloc, "R_390_TLS_LE32", FALSE, 0, 0xffffffff, FALSE),
144 EMPTY_HOWTO (R_390_TLS_LE64), /* Empty entry for R_390_TLS_LE64. */
145 HOWTO(R_390_TLS_LDO32, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
146 bfd_elf_generic_reloc, "R_390_TLS_LDO32", FALSE, 0, 0xffffffff, FALSE),
147 EMPTY_HOWTO (R_390_TLS_LDO64), /* Empty entry for R_390_TLS_LDO64. */
148 HOWTO(R_390_TLS_DTPMOD, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
149 bfd_elf_generic_reloc, "R_390_TLS_DTPMOD", FALSE, 0, 0xffffffff, FALSE),
150 HOWTO(R_390_TLS_DTPOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
151 bfd_elf_generic_reloc, "R_390_TLS_DTPOFF", FALSE, 0, 0xffffffff, FALSE),
152 HOWTO(R_390_TLS_TPOFF, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,
153 bfd_elf_generic_reloc, "R_390_TLS_TPOFF", FALSE, 0, 0xffffffff, FALSE),
154 HOWTO(R_390_20, 0, 2, 20, FALSE, 8, complain_overflow_dont,
155 s390_elf_ldisp_reloc, "R_390_20", FALSE, 0,0x0fffff00, FALSE),
156 HOWTO(R_390_GOT20, 0, 2, 20, FALSE, 8, complain_overflow_dont,
157 s390_elf_ldisp_reloc, "R_390_GOT20", FALSE, 0,0x0fffff00, FALSE),
158 HOWTO(R_390_GOTPLT20, 0, 2, 20, FALSE, 8, complain_overflow_dont,
159 s390_elf_ldisp_reloc, "R_390_GOTPLT20", FALSE, 0,0x0fffff00, FALSE),
160 HOWTO(R_390_TLS_GOTIE20, 0, 2, 20, FALSE, 8, complain_overflow_dont,
161 s390_elf_ldisp_reloc, "R_390_TLS_GOTIE20", FALSE, 0,0x0fffff00, FALSE),
162 HOWTO(R_390_IRELATIVE, 0, 2, 32, TRUE, 0, complain_overflow_bitfield,
163 bfd_elf_generic_reloc, "R_390_IRELATIVE", FALSE, 0, 0xffffffff, FALSE),
164 HOWTO(R_390_PC12DBL, 1, 1, 12, TRUE, 0, complain_overflow_bitfield,
165 bfd_elf_generic_reloc, "R_390_PC12DBL", FALSE, 0,0x00000fff, TRUE),
166 HOWTO(R_390_PLT12DBL, 1, 1, 12, TRUE, 0, complain_overflow_bitfield,
167 bfd_elf_generic_reloc, "R_390_PLT12DBL", FALSE, 0,0x00000fff, TRUE),
168 HOWTO(R_390_PC24DBL, 1, 2, 24, TRUE, 0, complain_overflow_bitfield,
169 bfd_elf_generic_reloc, "R_390_PC24DBL", FALSE, 0,0x00ffffff, TRUE),
170 HOWTO(R_390_PLT24DBL, 1, 2, 24, TRUE, 0, complain_overflow_bitfield,
171 bfd_elf_generic_reloc, "R_390_PLT24DBL", FALSE, 0,0x00ffffff, TRUE),
172 };
173
174 /* GNU extension to record C++ vtable hierarchy. */
175 static reloc_howto_type elf32_s390_vtinherit_howto =
176 HOWTO (R_390_GNU_VTINHERIT, 0,2,0,FALSE,0,complain_overflow_dont, NULL, "R_390_GNU_VTINHERIT", FALSE,0, 0, FALSE);
177 static reloc_howto_type elf32_s390_vtentry_howto =
178 HOWTO (R_390_GNU_VTENTRY, 0,2,0,FALSE,0,complain_overflow_dont, _bfd_elf_rel_vtable_reloc_fn,"R_390_GNU_VTENTRY", FALSE,0,0, FALSE);
179
180 static reloc_howto_type *
181 elf_s390_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
182 bfd_reloc_code_real_type code)
183 {
184 switch (code)
185 {
186 case BFD_RELOC_NONE:
187 return &elf_howto_table[(int) R_390_NONE];
188 case BFD_RELOC_8:
189 return &elf_howto_table[(int) R_390_8];
190 case BFD_RELOC_390_12:
191 return &elf_howto_table[(int) R_390_12];
192 case BFD_RELOC_16:
193 return &elf_howto_table[(int) R_390_16];
194 case BFD_RELOC_32:
195 return &elf_howto_table[(int) R_390_32];
196 case BFD_RELOC_CTOR:
197 return &elf_howto_table[(int) R_390_32];
198 case BFD_RELOC_32_PCREL:
199 return &elf_howto_table[(int) R_390_PC32];
200 case BFD_RELOC_390_GOT12:
201 return &elf_howto_table[(int) R_390_GOT12];
202 case BFD_RELOC_32_GOT_PCREL:
203 return &elf_howto_table[(int) R_390_GOT32];
204 case BFD_RELOC_390_PLT32:
205 return &elf_howto_table[(int) R_390_PLT32];
206 case BFD_RELOC_390_COPY:
207 return &elf_howto_table[(int) R_390_COPY];
208 case BFD_RELOC_390_GLOB_DAT:
209 return &elf_howto_table[(int) R_390_GLOB_DAT];
210 case BFD_RELOC_390_JMP_SLOT:
211 return &elf_howto_table[(int) R_390_JMP_SLOT];
212 case BFD_RELOC_390_RELATIVE:
213 return &elf_howto_table[(int) R_390_RELATIVE];
214 case BFD_RELOC_32_GOTOFF:
215 return &elf_howto_table[(int) R_390_GOTOFF32];
216 case BFD_RELOC_390_GOTPC:
217 return &elf_howto_table[(int) R_390_GOTPC];
218 case BFD_RELOC_390_GOT16:
219 return &elf_howto_table[(int) R_390_GOT16];
220 case BFD_RELOC_16_PCREL:
221 return &elf_howto_table[(int) R_390_PC16];
222 case BFD_RELOC_390_PC12DBL:
223 return &elf_howto_table[(int) R_390_PC12DBL];
224 case BFD_RELOC_390_PLT12DBL:
225 return &elf_howto_table[(int) R_390_PLT12DBL];
226 case BFD_RELOC_390_PC16DBL:
227 return &elf_howto_table[(int) R_390_PC16DBL];
228 case BFD_RELOC_390_PLT16DBL:
229 return &elf_howto_table[(int) R_390_PLT16DBL];
230 case BFD_RELOC_390_PC24DBL:
231 return &elf_howto_table[(int) R_390_PC24DBL];
232 case BFD_RELOC_390_PLT24DBL:
233 return &elf_howto_table[(int) R_390_PLT24DBL];
234 case BFD_RELOC_390_PC32DBL:
235 return &elf_howto_table[(int) R_390_PC32DBL];
236 case BFD_RELOC_390_PLT32DBL:
237 return &elf_howto_table[(int) R_390_PLT32DBL];
238 case BFD_RELOC_390_GOTPCDBL:
239 return &elf_howto_table[(int) R_390_GOTPCDBL];
240 case BFD_RELOC_390_GOTENT:
241 return &elf_howto_table[(int) R_390_GOTENT];
242 case BFD_RELOC_16_GOTOFF:
243 return &elf_howto_table[(int) R_390_GOTOFF16];
244 case BFD_RELOC_390_GOTPLT12:
245 return &elf_howto_table[(int) R_390_GOTPLT12];
246 case BFD_RELOC_390_GOTPLT16:
247 return &elf_howto_table[(int) R_390_GOTPLT16];
248 case BFD_RELOC_390_GOTPLT32:
249 return &elf_howto_table[(int) R_390_GOTPLT32];
250 case BFD_RELOC_390_GOTPLTENT:
251 return &elf_howto_table[(int) R_390_GOTPLTENT];
252 case BFD_RELOC_390_PLTOFF16:
253 return &elf_howto_table[(int) R_390_PLTOFF16];
254 case BFD_RELOC_390_PLTOFF32:
255 return &elf_howto_table[(int) R_390_PLTOFF32];
256 case BFD_RELOC_390_TLS_LOAD:
257 return &elf_howto_table[(int) R_390_TLS_LOAD];
258 case BFD_RELOC_390_TLS_GDCALL:
259 return &elf_howto_table[(int) R_390_TLS_GDCALL];
260 case BFD_RELOC_390_TLS_LDCALL:
261 return &elf_howto_table[(int) R_390_TLS_LDCALL];
262 case BFD_RELOC_390_TLS_GD32:
263 return &elf_howto_table[(int) R_390_TLS_GD32];
264 case BFD_RELOC_390_TLS_GOTIE12:
265 return &elf_howto_table[(int) R_390_TLS_GOTIE12];
266 case BFD_RELOC_390_TLS_GOTIE32:
267 return &elf_howto_table[(int) R_390_TLS_GOTIE32];
268 case BFD_RELOC_390_TLS_LDM32:
269 return &elf_howto_table[(int) R_390_TLS_LDM32];
270 case BFD_RELOC_390_TLS_IE32:
271 return &elf_howto_table[(int) R_390_TLS_IE32];
272 case BFD_RELOC_390_TLS_IEENT:
273 return &elf_howto_table[(int) R_390_TLS_IEENT];
274 case BFD_RELOC_390_TLS_LE32:
275 return &elf_howto_table[(int) R_390_TLS_LE32];
276 case BFD_RELOC_390_TLS_LDO32:
277 return &elf_howto_table[(int) R_390_TLS_LDO32];
278 case BFD_RELOC_390_TLS_DTPMOD:
279 return &elf_howto_table[(int) R_390_TLS_DTPMOD];
280 case BFD_RELOC_390_TLS_DTPOFF:
281 return &elf_howto_table[(int) R_390_TLS_DTPOFF];
282 case BFD_RELOC_390_TLS_TPOFF:
283 return &elf_howto_table[(int) R_390_TLS_TPOFF];
284 case BFD_RELOC_390_20:
285 return &elf_howto_table[(int) R_390_20];
286 case BFD_RELOC_390_GOT20:
287 return &elf_howto_table[(int) R_390_GOT20];
288 case BFD_RELOC_390_GOTPLT20:
289 return &elf_howto_table[(int) R_390_GOTPLT20];
290 case BFD_RELOC_390_TLS_GOTIE20:
291 return &elf_howto_table[(int) R_390_TLS_GOTIE20];
292 case BFD_RELOC_390_IRELATIVE:
293 return &elf_howto_table[(int) R_390_IRELATIVE];
294 case BFD_RELOC_VTABLE_INHERIT:
295 return &elf32_s390_vtinherit_howto;
296 case BFD_RELOC_VTABLE_ENTRY:
297 return &elf32_s390_vtentry_howto;
298 default:
299 break;
300 }
301 return 0;
302 }
303
304 static reloc_howto_type *
305 elf_s390_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
306 const char *r_name)
307 {
308 unsigned int i;
309
310 for (i = 0; i < sizeof (elf_howto_table) / sizeof (elf_howto_table[0]); i++)
311 if (elf_howto_table[i].name != NULL
312 && strcasecmp (elf_howto_table[i].name, r_name) == 0)
313 return &elf_howto_table[i];
314
315 if (strcasecmp (elf32_s390_vtinherit_howto.name, r_name) == 0)
316 return &elf32_s390_vtinherit_howto;
317 if (strcasecmp (elf32_s390_vtentry_howto.name, r_name) == 0)
318 return &elf32_s390_vtentry_howto;
319
320 return NULL;
321 }
322
323 /* We need to use ELF32_R_TYPE so we have our own copy of this function,
324 and elf32-s390.c has its own copy. */
325
326 static bfd_boolean
327 elf_s390_info_to_howto (bfd *abfd,
328 arelent *cache_ptr,
329 Elf_Internal_Rela *dst)
330 {
331 unsigned int r_type = ELF32_R_TYPE(dst->r_info);
332
333 switch (r_type)
334 {
335 case R_390_GNU_VTINHERIT:
336 cache_ptr->howto = &elf32_s390_vtinherit_howto;
337 break;
338
339 case R_390_GNU_VTENTRY:
340 cache_ptr->howto = &elf32_s390_vtentry_howto;
341 break;
342
343 default:
344 if (r_type >= sizeof (elf_howto_table) / sizeof (elf_howto_table[0]))
345 {
346 /* xgettext:c-format */
347 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
348 abfd, r_type);
349 bfd_set_error (bfd_error_bad_value);
350 return FALSE;
351 }
352 cache_ptr->howto = &elf_howto_table[r_type];
353 }
354
355 return TRUE;
356 }
357
358 /* A relocation function which doesn't do anything. */
359 static bfd_reloc_status_type
360 s390_tls_reloc (bfd *abfd ATTRIBUTE_UNUSED,
361 arelent *reloc_entry,
362 asymbol *symbol ATTRIBUTE_UNUSED,
363 void * data ATTRIBUTE_UNUSED,
364 asection *input_section,
365 bfd *output_bfd,
366 char **error_message ATTRIBUTE_UNUSED)
367 {
368 if (output_bfd)
369 reloc_entry->address += input_section->output_offset;
370 return bfd_reloc_ok;
371 }
372
373 /* Handle the large displacement relocs. */
374 static bfd_reloc_status_type
375 s390_elf_ldisp_reloc (bfd *abfd ATTRIBUTE_UNUSED,
376 arelent *reloc_entry,
377 asymbol *symbol,
378 void * data ATTRIBUTE_UNUSED,
379 asection *input_section,
380 bfd *output_bfd,
381 char **error_message ATTRIBUTE_UNUSED)
382 {
383 reloc_howto_type *howto = reloc_entry->howto;
384 bfd_vma relocation;
385 bfd_vma insn;
386
387 if (output_bfd != (bfd *) NULL
388 && (symbol->flags & BSF_SECTION_SYM) == 0
389 && (! howto->partial_inplace
390 || reloc_entry->addend == 0))
391 {
392 reloc_entry->address += input_section->output_offset;
393 return bfd_reloc_ok;
394 }
395
396 if (output_bfd != NULL)
397 return bfd_reloc_continue;
398
399 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
400 return bfd_reloc_outofrange;
401
402 relocation = (symbol->value
403 + symbol->section->output_section->vma
404 + symbol->section->output_offset);
405 relocation += reloc_entry->addend;
406 if (howto->pc_relative)
407 {
408 relocation -= (input_section->output_section->vma
409 + input_section->output_offset);
410 relocation -= reloc_entry->address;
411 }
412
413 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
414 insn |= (relocation & 0xfff) << 16 | (relocation & 0xff000) >> 4;
415 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
416
417 if ((bfd_signed_vma) relocation < - 0x80000
418 || (bfd_signed_vma) relocation > 0x7ffff)
419 return bfd_reloc_overflow;
420 else
421 return bfd_reloc_ok;
422 }
423
424 static bfd_boolean
425 elf_s390_is_local_label_name (bfd *abfd, const char *name)
426 {
427 if (name[0] == '.' && (name[1] == 'X' || name[1] == 'L'))
428 return TRUE;
429
430 return _bfd_elf_is_local_label_name (abfd, name);
431 }
432
433 /* Functions for the 390 ELF linker. */
434
435 /* The name of the dynamic interpreter. This is put in the .interp
436 section. */
437
438 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
439
440 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
441 copying dynamic variables from a shared lib into an app's dynbss
442 section, and instead use a dynamic relocation to point into the
443 shared lib. */
444 #define ELIMINATE_COPY_RELOCS 1
445
446 /* The size in bytes of the first entry in the procedure linkage table. */
447 #define PLT_FIRST_ENTRY_SIZE 32
448 /* The size in bytes of an entry in the procedure linkage table. */
449 #define PLT_ENTRY_SIZE 32
450
451 #define GOT_ENTRY_SIZE 4
452
453 #define RELA_ENTRY_SIZE sizeof (Elf32_External_Rela)
454
455 /* The first three entries in a procedure linkage table are reserved,
456 and the initial contents are unimportant (we zero them out).
457 Subsequent entries look like this. See the SVR4 ABI 386
458 supplement to see how this works. */
459
460 /* For the s390, simple addr offset can only be 0 - 4096.
461 To use the full 2 GB address space, several instructions
462 are needed to load an address in a register and execute
463 a branch( or just saving the address)
464
465 Furthermore, only r 0 and 1 are free to use!!! */
466
467 /* The first 3 words in the GOT are then reserved.
468 Word 0 is the address of the dynamic table.
469 Word 1 is a pointer to a structure describing the object
470 Word 2 is used to point to the loader entry address.
471
472 The code for position independent PLT entries looks like this:
473
474 r12 holds addr of the current GOT at entry to the PLT
475
476 The GOT holds the address in the PLT to be executed.
477 The loader then gets:
478 24(15) = Pointer to the structure describing the object.
479 28(15) = Offset into rela.plt
480
481 The loader must then find the module where the function is
482 and insert the address in the GOT.
483
484 Note: 390 can only address +- 64 K relative.
485 We check if offset > 65536, then make a relative branch -64xxx
486 back to a previous defined branch
487
488 PLT1: BASR 1,0 # 2 bytes
489 L 1,22(1) # 4 bytes Load offset in GOT in r 1
490 L 1,(1,12) # 4 bytes Load address from GOT in r1
491 BCR 15,1 # 2 bytes Jump to address
492 RET1: BASR 1,0 # 2 bytes Return from GOT 1st time
493 L 1,14(1) # 4 bytes Load offset in symol table in r1
494 BRC 15,-x # 4 bytes Jump to start of PLT
495 .word 0 # 2 bytes filler
496 .long ? # 4 bytes offset in GOT
497 .long ? # 4 bytes offset into rela.plt
498
499 This was the general case. There are two additional, optimizes PLT
500 definitions. One for GOT offsets < 4096 and one for GOT offsets < 32768.
501 First the one for GOT offsets < 4096:
502
503 PLT1: L 1,<offset>(12) # 4 bytes Load address from GOT in R1
504 BCR 15,1 # 2 bytes Jump to address
505 .word 0,0,0 # 6 bytes filler
506 RET1: BASR 1,0 # 2 bytes Return from GOT 1st time
507 L 1,14(1) # 4 bytes Load offset in rela.plt in r1
508 BRC 15,-x # 4 bytes Jump to start of PLT
509 .word 0,0,0 # 6 bytes filler
510 .long ? # 4 bytes offset into rela.plt
511
512 Second the one for GOT offsets < 32768:
513
514 PLT1: LHI 1,<offset> # 4 bytes Load offset in GOT to r1
515 L 1,(1,12) # 4 bytes Load address from GOT to r1
516 BCR 15,1 # 2 bytes Jump to address
517 .word 0 # 2 bytes filler
518 RET1: BASR 1,0 # 2 bytes Return from GOT 1st time
519 L 1,14(1) # 4 bytes Load offset in rela.plt in r1
520 BRC 15,-x # 4 bytes Jump to start of PLT
521 .word 0,0,0 # 6 bytes filler
522 .long ? # 4 bytes offset into rela.plt
523
524 Total = 32 bytes per PLT entry
525
526 The code for static build PLT entries looks like this:
527
528 PLT1: BASR 1,0 # 2 bytes
529 L 1,22(1) # 4 bytes Load address of GOT entry
530 L 1,0(0,1) # 4 bytes Load address from GOT in r1
531 BCR 15,1 # 2 bytes Jump to address
532 RET1: BASR 1,0 # 2 bytes Return from GOT 1st time
533 L 1,14(1) # 4 bytes Load offset in symbol table in r1
534 BRC 15,-x # 4 bytes Jump to start of PLT
535 .word 0 # 2 bytes filler
536 .long ? # 4 bytes address of GOT entry
537 .long ? # 4 bytes offset into rela.plt */
538
539 static const bfd_byte elf_s390_plt_entry[PLT_ENTRY_SIZE] =
540 {
541 0x0d, 0x10, /* basr %r1,%r0 */
542 0x58, 0x10, 0x10, 0x16, /* l %r1,22(%r1) */
543 0x58, 0x10, 0x10, 0x00, /* l %r1,0(%r1) */
544 0x07, 0xf1, /* br %r1 */
545 0x0d, 0x10, /* basr %r1,%r0 */
546 0x58, 0x10, 0x10, 0x0e, /* l %r1,14(%r1) */
547 0xa7, 0xf4, 0x00, 0x00, /* j first plt */
548 0x00, 0x00, /* padding */
549 0x00, 0x00, 0x00, 0x00, /* GOT offset */
550 0x00, 0x00, 0x00, 0x00 /* rela.plt offset */
551 };
552
553 /* Generic PLT pic entry. */
554 static const bfd_byte elf_s390_plt_pic_entry[PLT_ENTRY_SIZE] =
555 {
556 0x0d, 0x10, /* basr %r1,%r0 */
557 0x58, 0x10, 0x10, 0x16, /* l %r1,22(%r1) */
558 0x58, 0x11, 0xc0, 0x00, /* l %r1,0(%r1,%r12) */
559 0x07, 0xf1, /* br %r1 */
560 0x0d, 0x10, /* basr %r1,%r0 */
561 0x58, 0x10, 0x10, 0x0e, /* l %r1,14(%r1) */
562 0xa7, 0xf4, 0x00, 0x00, /* j first plt */
563 0x00, 0x00, /* padding */
564 0x00, 0x00, 0x00, 0x00, /* GOT offset */
565 0x00, 0x00, 0x00, 0x00 /* rela.plt offset */
566 };
567
568 /* Optimized PLT pic entry for GOT offset < 4k. xx will be replaced
569 when generating the PLT slot with the GOT offset. */
570 static const bfd_byte elf_s390_plt_pic12_entry[PLT_ENTRY_SIZE] =
571 {
572 0x58, 0x10, 0xc0, 0x00, /* l %r1,xx(%r12) */
573 0x07, 0xf1, /* br %r1 */
574 0x00, 0x00, 0x00, 0x00, /* padding */
575 0x00, 0x00,
576 0x0d, 0x10, /* basr %r1,%r0 */
577 0x58, 0x10, 0x10, 0x0e, /* l %r1,14(%r1) */
578 0xa7, 0xf4, 0x00, 0x00, /* j first plt */
579 0x00, 0x00, 0x00, 0x00,
580 0x00, 0x00, 0x00, 0x00
581 };
582
583 /* Optimized PLT pic entry for GOT offset < 32k. xx will be replaced
584 when generating the PLT slot with the GOT offset. */
585 static const bfd_byte elf_s390_plt_pic16_entry[PLT_ENTRY_SIZE] =
586 {
587 0xa7, 0x18, 0x00, 0x00, /* lhi %r1,xx */
588 0x58, 0x11, 0xc0, 0x00, /* l %r1,0(%r1,%r12) */
589 0x07, 0xf1, /* br %r1 */
590 0x00, 0x00,
591 0x0d, 0x10, /* basr %r1,%r0 */
592 0x58, 0x10, 0x10, 0x0e, /* l %r1,14(%r1) */
593 0xa7, 0xf4, 0x00, 0x00, /* j first plt */
594 0x00, 0x00, 0x00, 0x00,
595 0x00, 0x00, 0x00, 0x00,
596 0x00, 0x00
597 };
598
599 /* The first PLT entry pushes the offset into the rela.plt
600 from R1 onto the stack at 8(15) and the loader object info
601 at 12(15), loads the loader address in R1 and jumps to it. */
602
603 /* The first entry in the PLT for PIC code:
604
605 PLT0:
606 ST 1,28(15) # R1 has offset into rela.plt
607 L 1,4(12) # Get loader ino(object struct address)
608 ST 1,24(15) # Store address
609 L 1,8(12) # Entry address of loader in R1
610 BR 1 # Jump to loader
611
612 The first entry in the PLT for static code:
613
614 PLT0:
615 ST 1,28(15) # R1 has offset into rela.plt
616 BASR 1,0
617 L 1,18(0,1) # Get address of GOT
618 MVC 24(4,15),4(1) # Move loader ino to stack
619 L 1,8(1) # Get address of loader
620 BR 1 # Jump to loader
621 .word 0 # filler
622 .long got # address of GOT */
623
624 static const bfd_byte elf_s390_plt_first_entry[PLT_FIRST_ENTRY_SIZE] =
625 {
626 0x50, 0x10, 0xf0, 0x1c, /* st %r1,28(%r15) */
627 0x0d, 0x10, /* basr %r1,%r0 */
628 0x58, 0x10, 0x10, 0x12, /* l %r1,18(%r1) */
629 0xd2, 0x03, 0xf0, 0x18, 0x10, 0x04, /* mvc 24(4,%r15),4(%r1) */
630 0x58, 0x10, 0x10, 0x08, /* l %r1,8(%r1) */
631 0x07, 0xf1, /* br %r1 */
632 0x00, 0x00, 0x00, 0x00,
633 0x00, 0x00, 0x00, 0x00,
634 0x00, 0x00
635 };
636
637 static const bfd_byte elf_s390_plt_pic_first_entry[PLT_FIRST_ENTRY_SIZE] =
638 {
639 0x50, 0x10, 0xf0, 0x1c, /* st %r1,28(%r15) */
640 0x58, 0x10, 0xc0, 0x04, /* l %r1,4(%r12) */
641 0x50, 0x10, 0xf0, 0x18, /* st %r1,24(%r15) */
642 0x58, 0x10, 0xc0, 0x08, /* l %r1,8(%r12) */
643 0x07, 0xf1, /* br %r1 */
644 0x00, 0x00, 0x00, 0x00,
645 0x00, 0x00, 0x00, 0x00,
646 0x00, 0x00, 0x00, 0x00,
647 0x00, 0x00
648 };
649
650
651 /* s390 ELF linker hash entry. */
652
653 struct elf_s390_link_hash_entry
654 {
655 struct elf_link_hash_entry elf;
656
657 /* Number of GOTPLT references for a function. */
658 bfd_signed_vma gotplt_refcount;
659
660 #define GOT_UNKNOWN 0
661 #define GOT_NORMAL 1
662 #define GOT_TLS_GD 2
663 #define GOT_TLS_IE 3
664 #define GOT_TLS_IE_NLT 4
665 unsigned char tls_type;
666
667 /* For pointer equality reasons we might need to change the symbol
668 type from STT_GNU_IFUNC to STT_FUNC together with its value and
669 section entry. So after alloc_dynrelocs only these values should
670 be used. In order to check whether a symbol is IFUNC use
671 s390_is_ifunc_symbol_p. */
672 bfd_vma ifunc_resolver_address;
673 asection *ifunc_resolver_section;
674 };
675
676 #define elf_s390_hash_entry(ent) \
677 ((struct elf_s390_link_hash_entry *)(ent))
678
679 /* This structure represents an entry in the local PLT list needed for
680 local IFUNC symbols. */
681 struct plt_entry
682 {
683 /* The section of the local symbol.
684 Set in relocate_section and used in finish_dynamic_sections. */
685 asection *sec;
686
687 union
688 {
689 bfd_signed_vma refcount;
690 bfd_vma offset;
691 } plt;
692 };
693
694 /* NOTE: Keep this structure in sync with
695 the one declared in elf64-s390.c. */
696 struct elf_s390_obj_tdata
697 {
698 struct elf_obj_tdata root;
699
700 /* A local PLT is needed for ifunc symbols. */
701 struct plt_entry *local_plt;
702
703 /* TLS type for each local got entry. */
704 char *local_got_tls_type;
705 };
706
707 #define elf_s390_tdata(abfd) \
708 ((struct elf_s390_obj_tdata *) (abfd)->tdata.any)
709
710 #define elf_s390_local_plt(abfd) \
711 (elf_s390_tdata (abfd)->local_plt)
712
713 #define elf_s390_local_got_tls_type(abfd) \
714 (elf_s390_tdata (abfd)->local_got_tls_type)
715
716 #define is_s390_elf(bfd) \
717 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
718 && elf_tdata (bfd) != NULL \
719 && elf_object_id (bfd) == S390_ELF_DATA)
720
721 static bfd_boolean
722 elf_s390_mkobject (bfd *abfd)
723 {
724 return bfd_elf_allocate_object (abfd, sizeof (struct elf_s390_obj_tdata),
725 S390_ELF_DATA);
726 }
727
728 static bfd_boolean
729 elf_s390_object_p (bfd *abfd)
730 {
731 /* Set the right machine number for an s390 elf32 file. */
732 return bfd_default_set_arch_mach (abfd, bfd_arch_s390, bfd_mach_s390_31);
733 }
734
735 /* s390 ELF linker hash table. */
736
737 struct elf_s390_link_hash_table
738 {
739 struct elf_link_hash_table elf;
740
741 /* Short-cuts to get to dynamic linker sections. */
742 asection *irelifunc;
743
744 union
745 {
746 bfd_signed_vma refcount;
747 bfd_vma offset;
748 } tls_ldm_got;
749
750 /* Small local sym cache. */
751 struct sym_cache sym_cache;
752 };
753
754 /* Get the s390 ELF linker hash table from a link_info structure. */
755
756 #define elf_s390_hash_table(p) \
757 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
758 == S390_ELF_DATA ? ((struct elf_s390_link_hash_table *) ((p)->hash)) : NULL)
759
760 #undef ELF64
761 #include "elf-s390-common.c"
762
763 /* Create an entry in an s390 ELF linker hash table. */
764
765 static struct bfd_hash_entry *
766 link_hash_newfunc (struct bfd_hash_entry *entry,
767 struct bfd_hash_table *table,
768 const char *string)
769 {
770 /* Allocate the structure if it has not already been allocated by a
771 subclass. */
772 if (entry == NULL)
773 {
774 entry = bfd_hash_allocate (table,
775 sizeof (struct elf_s390_link_hash_entry));
776 if (entry == NULL)
777 return entry;
778 }
779
780 /* Call the allocation method of the superclass. */
781 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
782 if (entry != NULL)
783 {
784 struct elf_s390_link_hash_entry *eh;
785
786 eh = (struct elf_s390_link_hash_entry *) entry;
787 eh->gotplt_refcount = 0;
788 eh->tls_type = GOT_UNKNOWN;
789 eh->ifunc_resolver_address = 0;
790 eh->ifunc_resolver_section = NULL;
791 }
792
793 return entry;
794 }
795
796 /* Create an s390 ELF linker hash table. */
797
798 static struct bfd_link_hash_table *
799 elf_s390_link_hash_table_create (bfd *abfd)
800 {
801 struct elf_s390_link_hash_table *ret;
802 size_t amt = sizeof (struct elf_s390_link_hash_table);
803
804 ret = (struct elf_s390_link_hash_table *) bfd_zmalloc (amt);
805 if (ret == NULL)
806 return NULL;
807
808 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
809 sizeof (struct elf_s390_link_hash_entry),
810 S390_ELF_DATA))
811 {
812 free (ret);
813 return NULL;
814 }
815
816 return &ret->elf.root;
817 }
818
819 /* Copy the extra info we tack onto an elf_link_hash_entry. */
820
821 static void
822 elf_s390_copy_indirect_symbol (struct bfd_link_info *info,
823 struct elf_link_hash_entry *dir,
824 struct elf_link_hash_entry *ind)
825 {
826 struct elf_s390_link_hash_entry *edir, *eind;
827
828 edir = (struct elf_s390_link_hash_entry *) dir;
829 eind = (struct elf_s390_link_hash_entry *) ind;
830
831 if (ind->root.type == bfd_link_hash_indirect
832 && dir->got.refcount <= 0)
833 {
834 edir->tls_type = eind->tls_type;
835 eind->tls_type = GOT_UNKNOWN;
836 }
837
838 if (ELIMINATE_COPY_RELOCS
839 && ind->root.type != bfd_link_hash_indirect
840 && dir->dynamic_adjusted)
841 {
842 /* If called to transfer flags for a weakdef during processing
843 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
844 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
845 if (dir->versioned != versioned_hidden)
846 dir->ref_dynamic |= ind->ref_dynamic;
847 dir->ref_regular |= ind->ref_regular;
848 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
849 dir->needs_plt |= ind->needs_plt;
850 }
851 else
852 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
853 }
854
855 static int
856 elf_s390_tls_transition (struct bfd_link_info *info,
857 int r_type,
858 int is_local)
859 {
860 if (bfd_link_pic (info))
861 return r_type;
862
863 switch (r_type)
864 {
865 case R_390_TLS_GD32:
866 case R_390_TLS_IE32:
867 if (is_local)
868 return R_390_TLS_LE32;
869 return R_390_TLS_IE32;
870 case R_390_TLS_GOTIE32:
871 if (is_local)
872 return R_390_TLS_LE32;
873 return R_390_TLS_GOTIE32;
874 case R_390_TLS_LDM32:
875 return R_390_TLS_LE32;
876 }
877
878 return r_type;
879 }
880
881 /* Look through the relocs for a section during the first phase, and
882 allocate space in the global offset table or procedure linkage
883 table. */
884
885 static bfd_boolean
886 elf_s390_check_relocs (bfd *abfd,
887 struct bfd_link_info *info,
888 asection *sec,
889 const Elf_Internal_Rela *relocs)
890 {
891 struct elf_s390_link_hash_table *htab;
892 Elf_Internal_Shdr *symtab_hdr;
893 struct elf_link_hash_entry **sym_hashes;
894 const Elf_Internal_Rela *rel;
895 const Elf_Internal_Rela *rel_end;
896 asection *sreloc;
897 bfd_signed_vma *local_got_refcounts;
898 int tls_type, old_tls_type;
899 Elf_Internal_Sym *isym;
900
901 if (bfd_link_relocatable (info))
902 return TRUE;
903
904 BFD_ASSERT (is_s390_elf (abfd));
905
906 htab = elf_s390_hash_table (info);
907 symtab_hdr = &elf_symtab_hdr (abfd);
908 sym_hashes = elf_sym_hashes (abfd);
909 local_got_refcounts = elf_local_got_refcounts (abfd);
910
911 sreloc = NULL;
912
913 rel_end = relocs + sec->reloc_count;
914 for (rel = relocs; rel < rel_end; rel++)
915 {
916 unsigned int r_type;
917 unsigned int r_symndx;
918 struct elf_link_hash_entry *h;
919
920 r_symndx = ELF32_R_SYM (rel->r_info);
921
922 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
923 {
924 /* xgettext:c-format */
925 _bfd_error_handler (_("%pB: bad symbol index: %d"),
926 abfd, r_symndx);
927 return FALSE;
928 }
929
930 if (r_symndx < symtab_hdr->sh_info)
931 {
932 /* A local symbol. */
933 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
934 abfd, r_symndx);
935 if (isym == NULL)
936 return FALSE;
937
938 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
939 {
940 struct plt_entry *plt;
941
942 if (htab->elf.dynobj == NULL)
943 htab->elf.dynobj = abfd;
944
945 if (!s390_elf_create_ifunc_sections (htab->elf.dynobj, info))
946 return FALSE;
947
948 if (local_got_refcounts == NULL)
949 {
950 if (!elf_s390_allocate_local_syminfo (abfd, symtab_hdr))
951 return FALSE;
952 local_got_refcounts = elf_local_got_refcounts (abfd);
953 }
954 plt = elf_s390_local_plt (abfd);
955 plt[r_symndx].plt.refcount++;
956 }
957 h = NULL;
958 }
959 else
960 {
961 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
962 while (h->root.type == bfd_link_hash_indirect
963 || h->root.type == bfd_link_hash_warning)
964 h = (struct elf_link_hash_entry *) h->root.u.i.link;
965 }
966
967 /* Create got section and local_got_refcounts array if they
968 are needed. */
969 r_type = elf_s390_tls_transition (info,
970 ELF32_R_TYPE (rel->r_info),
971 h == NULL);
972 switch (r_type)
973 {
974 case R_390_GOT12:
975 case R_390_GOT16:
976 case R_390_GOT20:
977 case R_390_GOT32:
978 case R_390_GOTENT:
979 case R_390_GOTPLT12:
980 case R_390_GOTPLT16:
981 case R_390_GOTPLT20:
982 case R_390_GOTPLT32:
983 case R_390_GOTPLTENT:
984 case R_390_TLS_GD32:
985 case R_390_TLS_GOTIE12:
986 case R_390_TLS_GOTIE20:
987 case R_390_TLS_GOTIE32:
988 case R_390_TLS_IEENT:
989 case R_390_TLS_IE32:
990 case R_390_TLS_LDM32:
991 if (h == NULL
992 && local_got_refcounts == NULL)
993 {
994 if (!elf_s390_allocate_local_syminfo (abfd, symtab_hdr))
995 return FALSE;
996 local_got_refcounts = elf_local_got_refcounts (abfd);
997 }
998 /* Fall through. */
999 case R_390_GOTOFF16:
1000 case R_390_GOTOFF32:
1001 case R_390_GOTPC:
1002 case R_390_GOTPCDBL:
1003 if (htab->elf.sgot == NULL)
1004 {
1005 if (htab->elf.dynobj == NULL)
1006 htab->elf.dynobj = abfd;
1007 if (!_bfd_elf_create_got_section (htab->elf.dynobj, info))
1008 return FALSE;
1009 }
1010 }
1011
1012 if (h != NULL)
1013 {
1014 if (htab->elf.dynobj == NULL)
1015 htab->elf.dynobj = abfd;
1016 if (!s390_elf_create_ifunc_sections (htab->elf.dynobj, info))
1017 return FALSE;
1018
1019 /* Make sure an IFUNC symbol defined in a non-shared object
1020 always gets a PLT slot. */
1021 if (s390_is_ifunc_symbol_p (h) && h->def_regular)
1022 {
1023 /* The symbol is called by the dynamic loader in order
1024 to resolve the relocation. So it is in fact also
1025 referenced. */
1026 h->ref_regular = 1;
1027 h->needs_plt = 1;
1028 }
1029 }
1030 switch (r_type)
1031 {
1032 case R_390_GOTPC:
1033 case R_390_GOTPCDBL:
1034 /* These relocs do not need a GOT slot. They just load the
1035 GOT pointer itself or address something else relative to
1036 the GOT. Since the GOT pointer has been set up above we
1037 are done. */
1038 break;
1039 case R_390_GOTOFF16:
1040 case R_390_GOTOFF32:
1041 if (h == NULL || !s390_is_ifunc_symbol_p (h) || !h->def_regular)
1042 break;
1043 /* Fall through. */
1044
1045 case R_390_PLT12DBL:
1046 case R_390_PLT16DBL:
1047 case R_390_PLT24DBL:
1048 case R_390_PLT32DBL:
1049 case R_390_PLT32:
1050 case R_390_PLTOFF16:
1051 case R_390_PLTOFF32:
1052 /* This symbol requires a procedure linkage table entry. We
1053 actually build the entry in adjust_dynamic_symbol,
1054 because this might be a case of linking PIC code which is
1055 never referenced by a dynamic object, in which case we
1056 don't need to generate a procedure linkage table entry
1057 after all. */
1058
1059 /* If this is a local symbol, we resolve it directly without
1060 creating a procedure linkage table entry. */
1061 if (h != NULL)
1062 {
1063 h->needs_plt = 1;
1064 h->plt.refcount += 1;
1065 }
1066 break;
1067
1068 case R_390_GOTPLT12:
1069 case R_390_GOTPLT16:
1070 case R_390_GOTPLT20:
1071 case R_390_GOTPLT32:
1072 case R_390_GOTPLTENT:
1073 /* This symbol requires either a procedure linkage table entry
1074 or an entry in the local got. We actually build the entry
1075 in adjust_dynamic_symbol because whether this is really a
1076 global reference can change and with it the fact if we have
1077 to create a plt entry or a local got entry. To be able to
1078 make a once global symbol a local one we have to keep track
1079 of the number of gotplt references that exist for this
1080 symbol. */
1081 if (h != NULL)
1082 {
1083 ((struct elf_s390_link_hash_entry *) h)->gotplt_refcount++;
1084 h->needs_plt = 1;
1085 h->plt.refcount += 1;
1086 }
1087 else
1088 local_got_refcounts[r_symndx] += 1;
1089 break;
1090
1091 case R_390_TLS_LDM32:
1092 htab->tls_ldm_got.refcount += 1;
1093 break;
1094
1095 case R_390_TLS_IE32:
1096 case R_390_TLS_GOTIE12:
1097 case R_390_TLS_GOTIE20:
1098 case R_390_TLS_GOTIE32:
1099 case R_390_TLS_IEENT:
1100 if (bfd_link_pic (info))
1101 info->flags |= DF_STATIC_TLS;
1102 /* Fall through. */
1103
1104 case R_390_GOT12:
1105 case R_390_GOT16:
1106 case R_390_GOT20:
1107 case R_390_GOT32:
1108 case R_390_GOTENT:
1109 case R_390_TLS_GD32:
1110 /* This symbol requires a global offset table entry. */
1111 switch (r_type)
1112 {
1113 default:
1114 case R_390_GOT12:
1115 case R_390_GOT16:
1116 case R_390_GOT20:
1117 case R_390_GOT32:
1118 case R_390_GOTENT:
1119 tls_type = GOT_NORMAL;
1120 break;
1121 case R_390_TLS_GD32:
1122 tls_type = GOT_TLS_GD;
1123 break;
1124 case R_390_TLS_IE32:
1125 case R_390_TLS_GOTIE32:
1126 tls_type = GOT_TLS_IE;
1127 break;
1128 case R_390_TLS_GOTIE12:
1129 case R_390_TLS_GOTIE20:
1130 case R_390_TLS_IEENT:
1131 tls_type = GOT_TLS_IE_NLT;
1132 break;
1133 }
1134
1135 if (h != NULL)
1136 {
1137 h->got.refcount += 1;
1138 old_tls_type = elf_s390_hash_entry(h)->tls_type;
1139 }
1140 else
1141 {
1142 local_got_refcounts[r_symndx] += 1;
1143 old_tls_type = elf_s390_local_got_tls_type (abfd) [r_symndx];
1144 }
1145 /* If a TLS symbol is accessed using IE at least once,
1146 there is no point to use dynamic model for it. */
1147 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN)
1148 {
1149 if (old_tls_type == GOT_NORMAL || tls_type == GOT_NORMAL)
1150 {
1151 _bfd_error_handler
1152 /* xgettext:c-format */
1153 (_("%pB: `%s' accessed both as normal and thread local symbol"),
1154 abfd, h->root.root.string);
1155 return FALSE;
1156 }
1157 if (old_tls_type > tls_type)
1158 tls_type = old_tls_type;
1159 }
1160
1161 if (old_tls_type != tls_type)
1162 {
1163 if (h != NULL)
1164 elf_s390_hash_entry (h)->tls_type = tls_type;
1165 else
1166 elf_s390_local_got_tls_type (abfd) [r_symndx] = tls_type;
1167 }
1168
1169 if (r_type != R_390_TLS_IE32)
1170 break;
1171 /* Fall through. */
1172
1173 case R_390_TLS_LE32:
1174 /* For static linking and executables this reloc will be
1175 calculated at linktime otherwise a TLS_TPOFF runtime
1176 reloc will be generated. */
1177 if (r_type == R_390_TLS_LE32 && bfd_link_pie (info))
1178 break;
1179
1180 if (!bfd_link_pic (info))
1181 break;
1182 info->flags |= DF_STATIC_TLS;
1183 /* Fall through. */
1184
1185 case R_390_8:
1186 case R_390_16:
1187 case R_390_32:
1188 case R_390_PC16:
1189 case R_390_PC12DBL:
1190 case R_390_PC16DBL:
1191 case R_390_PC24DBL:
1192 case R_390_PC32DBL:
1193 case R_390_PC32:
1194 if (h != NULL && bfd_link_executable (info))
1195 {
1196 /* If this reloc is in a read-only section, we might
1197 need a copy reloc. We can't check reliably at this
1198 stage whether the section is read-only, as input
1199 sections have not yet been mapped to output sections.
1200 Tentatively set the flag for now, and correct in
1201 adjust_dynamic_symbol. */
1202 h->non_got_ref = 1;
1203
1204 if (!bfd_link_pic (info))
1205 {
1206 /* We may need a .plt entry if the function this reloc
1207 refers to is in a shared lib. */
1208 h->plt.refcount += 1;
1209 }
1210 }
1211
1212 /* If we are creating a shared library, and this is a reloc
1213 against a global symbol, or a non PC relative reloc
1214 against a local symbol, then we need to copy the reloc
1215 into the shared library. However, if we are linking with
1216 -Bsymbolic, we do not need to copy a reloc against a
1217 global symbol which is defined in an object we are
1218 including in the link (i.e., DEF_REGULAR is set). At
1219 this point we have not seen all the input files, so it is
1220 possible that DEF_REGULAR is not set now but will be set
1221 later (it is never cleared). In case of a weak definition,
1222 DEF_REGULAR may be cleared later by a strong definition in
1223 a shared library. We account for that possibility below by
1224 storing information in the relocs_copied field of the hash
1225 table entry. A similar situation occurs when creating
1226 shared libraries and symbol visibility changes render the
1227 symbol local.
1228
1229 If on the other hand, we are creating an executable, we
1230 may need to keep relocations for symbols satisfied by a
1231 dynamic library if we manage to avoid copy relocs for the
1232 symbol. */
1233 if ((bfd_link_pic (info)
1234 && (sec->flags & SEC_ALLOC) != 0
1235 && ((ELF32_R_TYPE (rel->r_info) != R_390_PC16
1236 && ELF32_R_TYPE (rel->r_info) != R_390_PC12DBL
1237 && ELF32_R_TYPE (rel->r_info) != R_390_PC16DBL
1238 && ELF32_R_TYPE (rel->r_info) != R_390_PC24DBL
1239 && ELF32_R_TYPE (rel->r_info) != R_390_PC32DBL
1240 && ELF32_R_TYPE (rel->r_info) != R_390_PC32)
1241 || (h != NULL
1242 && (! SYMBOLIC_BIND (info, h)
1243 || h->root.type == bfd_link_hash_defweak
1244 || !h->def_regular))))
1245 || (ELIMINATE_COPY_RELOCS
1246 && !bfd_link_pic (info)
1247 && (sec->flags & SEC_ALLOC) != 0
1248 && h != NULL
1249 && (h->root.type == bfd_link_hash_defweak
1250 || !h->def_regular)))
1251 {
1252 struct elf_dyn_relocs *p;
1253 struct elf_dyn_relocs **head;
1254
1255 /* We must copy these reloc types into the output file.
1256 Create a reloc section in dynobj and make room for
1257 this reloc. */
1258 if (sreloc == NULL)
1259 {
1260 if (htab->elf.dynobj == NULL)
1261 htab->elf.dynobj = abfd;
1262
1263 sreloc = _bfd_elf_make_dynamic_reloc_section
1264 (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ TRUE);
1265
1266 if (sreloc == NULL)
1267 return FALSE;
1268 }
1269
1270 /* If this is a global symbol, we count the number of
1271 relocations we need for this symbol. */
1272 if (h != NULL)
1273 {
1274 head = &h->dyn_relocs;
1275 }
1276 else
1277 {
1278 /* Track dynamic relocs needed for local syms too.
1279 We really need local syms available to do this
1280 easily. Oh well. */
1281 asection *s;
1282 void *vpp;
1283
1284 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1285 abfd, r_symndx);
1286 if (isym == NULL)
1287 return FALSE;
1288
1289 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1290 if (s == NULL)
1291 s = sec;
1292
1293 vpp = &elf_section_data (s)->local_dynrel;
1294 head = (struct elf_dyn_relocs **) vpp;
1295 }
1296
1297 p = *head;
1298 if (p == NULL || p->sec != sec)
1299 {
1300 size_t amt = sizeof *p;
1301
1302 p = ((struct elf_dyn_relocs *)
1303 bfd_alloc (htab->elf.dynobj, amt));
1304 if (p == NULL)
1305 return FALSE;
1306 p->next = *head;
1307 *head = p;
1308 p->sec = sec;
1309 p->count = 0;
1310 p->pc_count = 0;
1311 }
1312
1313 p->count += 1;
1314 if (ELF32_R_TYPE (rel->r_info) == R_390_PC16
1315 || ELF32_R_TYPE (rel->r_info) == R_390_PC12DBL
1316 || ELF32_R_TYPE (rel->r_info) == R_390_PC16DBL
1317 || ELF32_R_TYPE (rel->r_info) == R_390_PC24DBL
1318 || ELF32_R_TYPE (rel->r_info) == R_390_PC32DBL
1319 || ELF32_R_TYPE (rel->r_info) == R_390_PC32)
1320 p->pc_count += 1;
1321 }
1322 break;
1323
1324 /* This relocation describes the C++ object vtable hierarchy.
1325 Reconstruct it for later use during GC. */
1326 case R_390_GNU_VTINHERIT:
1327 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1328 return FALSE;
1329 break;
1330
1331 /* This relocation describes which C++ vtable entries are actually
1332 used. Record for later use during GC. */
1333 case R_390_GNU_VTENTRY:
1334 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1335 return FALSE;
1336 break;
1337
1338 default:
1339 break;
1340 }
1341 }
1342
1343 return TRUE;
1344 }
1345
1346 /* Return the section that should be marked against GC for a given
1347 relocation. */
1348
1349 static asection *
1350 elf_s390_gc_mark_hook (asection *sec,
1351 struct bfd_link_info *info,
1352 Elf_Internal_Rela *rel,
1353 struct elf_link_hash_entry *h,
1354 Elf_Internal_Sym *sym)
1355 {
1356 if (h != NULL)
1357 switch (ELF32_R_TYPE (rel->r_info))
1358 {
1359 case R_390_GNU_VTINHERIT:
1360 case R_390_GNU_VTENTRY:
1361 return NULL;
1362 }
1363 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1364
1365 }
1366
1367 /* Make sure we emit a GOT entry if the symbol was supposed to have a PLT
1368 entry but we found we will not create any. Called when we find we will
1369 not have any PLT for this symbol, by for example
1370 elf_s390_adjust_dynamic_symbol when we're doing a proper dynamic link,
1371 or elf_s390_size_dynamic_sections if no dynamic sections will be
1372 created (we're only linking static objects). */
1373
1374 static void
1375 elf_s390_adjust_gotplt (struct elf_s390_link_hash_entry *h)
1376 {
1377 if (h->elf.root.type == bfd_link_hash_warning)
1378 h = (struct elf_s390_link_hash_entry *) h->elf.root.u.i.link;
1379
1380 if (h->gotplt_refcount <= 0)
1381 return;
1382
1383 /* We simply add the number of gotplt references to the number
1384 * of got references for this symbol. */
1385 h->elf.got.refcount += h->gotplt_refcount;
1386 h->gotplt_refcount = -1;
1387 }
1388
1389 /* Adjust a symbol defined by a dynamic object and referenced by a
1390 regular object. The current definition is in some section of the
1391 dynamic object, but we're not including those sections. We have to
1392 change the definition to something the rest of the link can
1393 understand. */
1394
1395 static bfd_boolean
1396 elf_s390_adjust_dynamic_symbol (struct bfd_link_info *info,
1397 struct elf_link_hash_entry *h)
1398 {
1399 struct elf_s390_link_hash_table *htab;
1400 asection *s, *srel;
1401
1402 /* STT_GNU_IFUNC symbol must go through PLT. */
1403 if (s390_is_ifunc_symbol_p (h))
1404 {
1405 /* All local STT_GNU_IFUNC references must be treated as local
1406 calls via local PLT. */
1407 if (h->ref_regular && SYMBOL_CALLS_LOCAL (info, h))
1408 {
1409 bfd_size_type pc_count = 0, count = 0;
1410 struct elf_dyn_relocs **pp;
1411 struct elf_dyn_relocs *p;
1412
1413 for (pp = &h->dyn_relocs; (p = *pp) != NULL; )
1414 {
1415 pc_count += p->pc_count;
1416 p->count -= p->pc_count;
1417 p->pc_count = 0;
1418 count += p->count;
1419 if (p->count == 0)
1420 *pp = p->next;
1421 else
1422 pp = &p->next;
1423 }
1424
1425 if (pc_count || count)
1426 {
1427 h->needs_plt = 1;
1428 h->non_got_ref = 1;
1429 if (h->plt.refcount <= 0)
1430 h->plt.refcount = 1;
1431 else
1432 h->plt.refcount += 1;
1433 }
1434 }
1435
1436 if (h->plt.refcount <= 0)
1437 {
1438 h->plt.offset = (bfd_vma) -1;
1439 h->needs_plt = 0;
1440 }
1441 return TRUE;
1442 }
1443
1444 /* If this is a function, put it in the procedure linkage table. We
1445 will fill in the contents of the procedure linkage table later
1446 (although we could actually do it here). */
1447 if (h->type == STT_FUNC
1448 || h->needs_plt)
1449 {
1450 if (h->plt.refcount <= 0
1451 || SYMBOL_CALLS_LOCAL (info, h)
1452 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1453 && h->root.type != bfd_link_hash_undefweak))
1454 {
1455 /* This case can occur if we saw a PLT32 reloc in an input
1456 file, but the symbol was never referred to by a dynamic
1457 object, or if all references were garbage collected. In
1458 such a case, we don't actually need to build a procedure
1459 linkage table, and we can just do a PC32 reloc instead. */
1460 h->plt.offset = (bfd_vma) -1;
1461 h->needs_plt = 0;
1462 elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1463 }
1464
1465 return TRUE;
1466 }
1467 else
1468 /* It's possible that we incorrectly decided a .plt reloc was
1469 needed for an R_390_PC32 reloc to a non-function sym in
1470 check_relocs. We can't decide accurately between function and
1471 non-function syms in check-relocs; Objects loaded later in
1472 the link may change h->type. So fix it now. */
1473 h->plt.offset = (bfd_vma) -1;
1474
1475 /* If this is a weak symbol, and there is a real definition, the
1476 processor independent code will have arranged for us to see the
1477 real definition first, and we can just use the same value. */
1478 if (h->is_weakalias)
1479 {
1480 struct elf_link_hash_entry *def = weakdef (h);
1481 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
1482 h->root.u.def.section = def->root.u.def.section;
1483 h->root.u.def.value = def->root.u.def.value;
1484 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1485 h->non_got_ref = def->non_got_ref;
1486 return TRUE;
1487 }
1488
1489 /* This is a reference to a symbol defined by a dynamic object which
1490 is not a function. */
1491
1492 /* If we are creating a shared library, we must presume that the
1493 only references to the symbol are via the global offset table.
1494 For such cases we need not do anything here; the relocations will
1495 be handled correctly by relocate_section. */
1496 if (bfd_link_pic (info))
1497 return TRUE;
1498
1499 /* If there are no references to this symbol that do not use the
1500 GOT, we don't need to generate a copy reloc. */
1501 if (!h->non_got_ref)
1502 return TRUE;
1503
1504 /* If -z nocopyreloc was given, we won't generate them either. */
1505 if (info->nocopyreloc)
1506 {
1507 h->non_got_ref = 0;
1508 return TRUE;
1509 }
1510
1511 /* If we don't find any dynamic relocs in read-only sections, then
1512 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1513 if (ELIMINATE_COPY_RELOCS && !_bfd_elf_readonly_dynrelocs (h))
1514 {
1515 h->non_got_ref = 0;
1516 return TRUE;
1517 }
1518
1519 /* We must allocate the symbol in our .dynbss section, which will
1520 become part of the .bss section of the executable. There will be
1521 an entry for this symbol in the .dynsym section. The dynamic
1522 object will contain position independent code, so all references
1523 from the dynamic object to this symbol will go through the global
1524 offset table. The dynamic linker will use the .dynsym entry to
1525 determine the address it must put in the global offset table, so
1526 both the dynamic object and the regular object will refer to the
1527 same memory location for the variable. */
1528
1529 htab = elf_s390_hash_table (info);
1530
1531 /* We must generate a R_390_COPY reloc to tell the dynamic linker to
1532 copy the initial value out of the dynamic object and into the
1533 runtime process image. */
1534 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
1535 {
1536 s = htab->elf.sdynrelro;
1537 srel = htab->elf.sreldynrelro;
1538 }
1539 else
1540 {
1541 s = htab->elf.sdynbss;
1542 srel = htab->elf.srelbss;
1543 }
1544 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1545 {
1546 srel->size += sizeof (Elf32_External_Rela);
1547 h->needs_copy = 1;
1548 }
1549
1550 return _bfd_elf_adjust_dynamic_copy (info, h, s);
1551 }
1552
1553 /* Allocate space in .plt, .got and associated reloc sections for
1554 dynamic relocs. */
1555
1556 static bfd_boolean
1557 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1558 {
1559 struct bfd_link_info *info;
1560 struct elf_s390_link_hash_table *htab;
1561 struct elf_dyn_relocs *p;
1562
1563 if (h->root.type == bfd_link_hash_indirect)
1564 return TRUE;
1565
1566 info = (struct bfd_link_info *) inf;
1567 htab = elf_s390_hash_table (info);
1568
1569 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
1570 here if it is defined and referenced in a non-shared object. */
1571 if (s390_is_ifunc_symbol_p (h) && h->def_regular)
1572 return s390_elf_allocate_ifunc_dyn_relocs (info, h);
1573 else if (htab->elf.dynamic_sections_created
1574 && h->plt.refcount > 0)
1575 {
1576 /* Make sure this symbol is output as a dynamic symbol.
1577 Undefined weak syms won't yet be marked as dynamic. */
1578 if (h->dynindx == -1
1579 && !h->forced_local)
1580 {
1581 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1582 return FALSE;
1583 }
1584
1585 if (bfd_link_pic (info)
1586 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1587 {
1588 asection *s = htab->elf.splt;
1589
1590 /* If this is the first .plt entry, make room for the special
1591 first entry. */
1592 if (s->size == 0)
1593 s->size += PLT_FIRST_ENTRY_SIZE;
1594
1595 h->plt.offset = s->size;
1596
1597 /* If this symbol is not defined in a regular file, and we are
1598 not generating a shared library, then set the symbol to this
1599 location in the .plt. This is required to make function
1600 pointers compare as equal between the normal executable and
1601 the shared library. */
1602 if (! bfd_link_pic (info)
1603 && !h->def_regular)
1604 {
1605 h->root.u.def.section = s;
1606 h->root.u.def.value = h->plt.offset;
1607 }
1608
1609 /* Make room for this entry. */
1610 s->size += PLT_ENTRY_SIZE;
1611
1612 /* We also need to make an entry in the .got.plt section, which
1613 will be placed in the .got section by the linker script. */
1614 htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
1615
1616 /* We also need to make an entry in the .rela.plt section. */
1617 htab->elf.srelplt->size += sizeof (Elf32_External_Rela);
1618 }
1619 else
1620 {
1621 h->plt.offset = (bfd_vma) -1;
1622 h->needs_plt = 0;
1623 elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1624 }
1625 }
1626 else
1627 {
1628 h->plt.offset = (bfd_vma) -1;
1629 h->needs_plt = 0;
1630 elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1631 }
1632
1633 /* If R_390_TLS_{IE32,GOTIE32,GOTIE12,IEENT} symbol is now local to
1634 the binary, we can optimize a bit. IE32 and GOTIE32 get converted
1635 to R_390_TLS_LE32 requiring no TLS entry. For GOTIE12 and IEENT
1636 we can save the dynamic TLS relocation. */
1637 if (h->got.refcount > 0
1638 && !bfd_link_pic (info)
1639 && h->dynindx == -1
1640 && elf_s390_hash_entry(h)->tls_type >= GOT_TLS_IE)
1641 {
1642 if (elf_s390_hash_entry(h)->tls_type == GOT_TLS_IE_NLT)
1643 /* For the GOTIE access without a literal pool entry the offset has
1644 to be stored somewhere. The immediate value in the instruction
1645 is not bit enough so the value is stored in the got. */
1646 {
1647 h->got.offset = htab->elf.sgot->size;
1648 htab->elf.sgot->size += GOT_ENTRY_SIZE;
1649 }
1650 else
1651 h->got.offset = (bfd_vma) -1;
1652 }
1653 else if (h->got.refcount > 0)
1654 {
1655 asection *s;
1656 bfd_boolean dyn;
1657 int tls_type = elf_s390_hash_entry(h)->tls_type;
1658
1659 /* Make sure this symbol is output as a dynamic symbol.
1660 Undefined weak syms won't yet be marked as dynamic. */
1661 if (h->dynindx == -1
1662 && !h->forced_local)
1663 {
1664 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1665 return FALSE;
1666 }
1667
1668 s = htab->elf.sgot;
1669 h->got.offset = s->size;
1670 s->size += GOT_ENTRY_SIZE;
1671 /* R_390_TLS_GD32 needs 2 consecutive GOT slots. */
1672 if (tls_type == GOT_TLS_GD)
1673 s->size += GOT_ENTRY_SIZE;
1674 dyn = htab->elf.dynamic_sections_created;
1675 /* R_390_TLS_IE32 needs one dynamic relocation,
1676 R_390_TLS_GD32 needs one if local symbol and two if global. */
1677 if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1678 || tls_type >= GOT_TLS_IE)
1679 htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
1680 else if (tls_type == GOT_TLS_GD)
1681 htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rela);
1682 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1683 || h->root.type != bfd_link_hash_undefweak)
1684 && (bfd_link_pic (info)
1685 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1686 htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
1687 }
1688 else
1689 h->got.offset = (bfd_vma) -1;
1690
1691 if (h->dyn_relocs == NULL)
1692 return TRUE;
1693
1694 /* In the shared -Bsymbolic case, discard space allocated for
1695 dynamic pc-relative relocs against symbols which turn out to be
1696 defined in regular objects. For the normal shared case, discard
1697 space for pc-relative relocs that have become local due to symbol
1698 visibility changes. */
1699
1700 if (bfd_link_pic (info))
1701 {
1702 if (SYMBOL_CALLS_LOCAL (info, h))
1703 {
1704 struct elf_dyn_relocs **pp;
1705
1706 for (pp = &h->dyn_relocs; (p = *pp) != NULL; )
1707 {
1708 p->count -= p->pc_count;
1709 p->pc_count = 0;
1710 if (p->count == 0)
1711 *pp = p->next;
1712 else
1713 pp = &p->next;
1714 }
1715 }
1716
1717 /* Also discard relocs on undefined weak syms with non-default
1718 visibility. */
1719 if (h->dyn_relocs != NULL
1720 && h->root.type == bfd_link_hash_undefweak)
1721 {
1722 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1723 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
1724 h->dyn_relocs = NULL;
1725
1726 /* Make sure undefined weak symbols are output as a dynamic
1727 symbol in PIEs. */
1728 else if (h->dynindx == -1
1729 && !h->forced_local)
1730 {
1731 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1732 return FALSE;
1733 }
1734 }
1735 }
1736 else if (ELIMINATE_COPY_RELOCS)
1737 {
1738 /* For the non-shared case, discard space for relocs against
1739 symbols which turn out to need copy relocs or are not
1740 dynamic. */
1741
1742 if (!h->non_got_ref
1743 && ((h->def_dynamic
1744 && !h->def_regular)
1745 || (htab->elf.dynamic_sections_created
1746 && (h->root.type == bfd_link_hash_undefweak
1747 || h->root.type == bfd_link_hash_undefined))))
1748 {
1749 /* Make sure this symbol is output as a dynamic symbol.
1750 Undefined weak syms won't yet be marked as dynamic. */
1751 if (h->dynindx == -1
1752 && !h->forced_local)
1753 {
1754 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1755 return FALSE;
1756 }
1757
1758 /* If that succeeded, we know we'll be keeping all the
1759 relocs. */
1760 if (h->dynindx != -1)
1761 goto keep;
1762 }
1763
1764 h->dyn_relocs = NULL;
1765
1766 keep: ;
1767 }
1768
1769 /* Finally, allocate space. */
1770 for (p = h->dyn_relocs; p != NULL; p = p->next)
1771 {
1772 asection *sreloc = elf_section_data (p->sec)->sreloc;
1773
1774 sreloc->size += p->count * sizeof (Elf32_External_Rela);
1775 }
1776
1777 return TRUE;
1778 }
1779
1780 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
1781 read-only sections. */
1782
1783 static bfd_boolean
1784 maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
1785 {
1786 asection *sec;
1787
1788 if (h->root.type == bfd_link_hash_indirect)
1789 return TRUE;
1790
1791 sec = _bfd_elf_readonly_dynrelocs (h);
1792 if (sec != NULL)
1793 {
1794 struct bfd_link_info *info = (struct bfd_link_info *) info_p;
1795
1796 info->flags |= DF_TEXTREL;
1797 info->callbacks->minfo
1798 (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
1799 sec->owner, h->root.root.string, sec);
1800
1801 /* Not an error, just cut short the traversal. */
1802 return FALSE;
1803 }
1804 return TRUE;
1805 }
1806
1807 /* Set the sizes of the dynamic sections. */
1808
1809 static bfd_boolean
1810 elf_s390_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1811 struct bfd_link_info *info)
1812 {
1813 struct elf_s390_link_hash_table *htab;
1814 bfd *dynobj;
1815 asection *s;
1816 bfd_boolean relocs;
1817 bfd *ibfd;
1818
1819 htab = elf_s390_hash_table (info);
1820 dynobj = htab->elf.dynobj;
1821 if (dynobj == NULL)
1822 abort ();
1823
1824 if (htab->elf.dynamic_sections_created)
1825 {
1826 /* Set the contents of the .interp section to the interpreter. */
1827 if (bfd_link_executable (info) && !info->nointerp)
1828 {
1829 s = bfd_get_linker_section (dynobj, ".interp");
1830 if (s == NULL)
1831 abort ();
1832 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1833 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1834 }
1835 }
1836
1837 /* Set up .got offsets for local syms, and space for local dynamic
1838 relocs. */
1839 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
1840 {
1841 bfd_signed_vma *local_got;
1842 bfd_signed_vma *end_local_got;
1843 char *local_tls_type;
1844 bfd_size_type locsymcount;
1845 Elf_Internal_Shdr *symtab_hdr;
1846 asection *srela;
1847 struct plt_entry *local_plt;
1848 unsigned int i;
1849
1850 if (! is_s390_elf (ibfd))
1851 continue;
1852
1853 for (s = ibfd->sections; s != NULL; s = s->next)
1854 {
1855 struct elf_dyn_relocs *p;
1856
1857 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
1858 {
1859 if (!bfd_is_abs_section (p->sec)
1860 && bfd_is_abs_section (p->sec->output_section))
1861 {
1862 /* Input section has been discarded, either because
1863 it is a copy of a linkonce section or due to
1864 linker script /DISCARD/, so we'll be discarding
1865 the relocs too. */
1866 }
1867 else if (p->count != 0)
1868 {
1869 srela = elf_section_data (p->sec)->sreloc;
1870 srela->size += p->count * sizeof (Elf32_External_Rela);
1871 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1872 info->flags |= DF_TEXTREL;
1873 }
1874 }
1875 }
1876
1877 local_got = elf_local_got_refcounts (ibfd);
1878 if (!local_got)
1879 continue;
1880
1881 symtab_hdr = &elf_symtab_hdr (ibfd);
1882 locsymcount = symtab_hdr->sh_info;
1883 end_local_got = local_got + locsymcount;
1884 local_tls_type = elf_s390_local_got_tls_type (ibfd);
1885 s = htab->elf.sgot;
1886 srela = htab->elf.srelgot;
1887 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1888 {
1889 if (*local_got > 0)
1890 {
1891 *local_got = s->size;
1892 s->size += GOT_ENTRY_SIZE;
1893 if (*local_tls_type == GOT_TLS_GD)
1894 s->size += GOT_ENTRY_SIZE;
1895 if (bfd_link_pic (info))
1896 srela->size += sizeof (Elf32_External_Rela);
1897 }
1898 else
1899 *local_got = (bfd_vma) -1;
1900 }
1901 local_plt = elf_s390_local_plt (ibfd);
1902 for (i = 0; i < symtab_hdr->sh_info; i++)
1903 {
1904 if (local_plt[i].plt.refcount > 0)
1905 {
1906 local_plt[i].plt.offset = htab->elf.iplt->size;
1907 htab->elf.iplt->size += PLT_ENTRY_SIZE;
1908 htab->elf.igotplt->size += GOT_ENTRY_SIZE;
1909 htab->elf.irelplt->size += RELA_ENTRY_SIZE;
1910 }
1911 else
1912 local_plt[i].plt.offset = (bfd_vma) -1;
1913 }
1914 }
1915
1916 if (htab->tls_ldm_got.refcount > 0)
1917 {
1918 /* Allocate 2 got entries and 1 dynamic reloc for R_390_TLS_LDM32
1919 relocs. */
1920 htab->tls_ldm_got.offset = htab->elf.sgot->size;
1921 htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
1922 htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
1923 }
1924 else
1925 htab->tls_ldm_got.offset = -1;
1926
1927 /* Allocate global sym .plt and .got entries, and space for global
1928 sym dynamic relocs. */
1929 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
1930
1931 /* We now have determined the sizes of the various dynamic sections.
1932 Allocate memory for them. */
1933 relocs = FALSE;
1934 for (s = dynobj->sections; s != NULL; s = s->next)
1935 {
1936 if ((s->flags & SEC_LINKER_CREATED) == 0)
1937 continue;
1938
1939 if (s == htab->elf.splt
1940 || s == htab->elf.sgot
1941 || s == htab->elf.sgotplt
1942 || s == htab->elf.sdynbss
1943 || s == htab->elf.sdynrelro
1944 || s == htab->elf.iplt
1945 || s == htab->elf.igotplt
1946 || s == htab->irelifunc)
1947 {
1948 /* Strip this section if we don't need it; see the
1949 comment below. */
1950 }
1951 else if (CONST_STRNEQ (bfd_section_name (s), ".rela"))
1952 {
1953 if (s->size != 0)
1954 relocs = TRUE;
1955
1956 /* We use the reloc_count field as a counter if we need
1957 to copy relocs into the output file. */
1958 s->reloc_count = 0;
1959 }
1960 else
1961 {
1962 /* It's not one of our sections, so don't allocate space. */
1963 continue;
1964 }
1965
1966 if (s->size == 0)
1967 {
1968 /* If we don't need this section, strip it from the
1969 output file. This is to handle .rela.bss and
1970 .rela.plt. We must create it in
1971 create_dynamic_sections, because it must be created
1972 before the linker maps input sections to output
1973 sections. The linker does that before
1974 adjust_dynamic_symbol is called, and it is that
1975 function which decides whether anything needs to go
1976 into these sections. */
1977
1978 s->flags |= SEC_EXCLUDE;
1979 continue;
1980 }
1981
1982 if ((s->flags & SEC_HAS_CONTENTS) == 0)
1983 continue;
1984
1985 /* Allocate memory for the section contents. We use bfd_zalloc
1986 here in case unused entries are not reclaimed before the
1987 section's contents are written out. This should not happen,
1988 but this way if it does, we get a R_390_NONE reloc instead
1989 of garbage. */
1990 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1991 if (s->contents == NULL)
1992 return FALSE;
1993 }
1994
1995 if (htab->elf.dynamic_sections_created)
1996 {
1997 /* Add some entries to the .dynamic section. We fill in the
1998 values later, in elf_s390_finish_dynamic_sections, but we
1999 must add the entries now so that we get the correct size for
2000 the .dynamic section. The DT_DEBUG entry is filled in by the
2001 dynamic linker and used by the debugger. */
2002 #define add_dynamic_entry(TAG, VAL) \
2003 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2004
2005 if (bfd_link_executable (info))
2006 {
2007 if (!add_dynamic_entry (DT_DEBUG, 0))
2008 return FALSE;
2009 }
2010
2011 if (htab->elf.splt->size != 0)
2012 {
2013 if (!add_dynamic_entry (DT_PLTGOT, 0)
2014 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2015 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2016 || !add_dynamic_entry (DT_JMPREL, 0))
2017 return FALSE;
2018 }
2019
2020 if (relocs)
2021 {
2022 if (!add_dynamic_entry (DT_RELA, 0)
2023 || !add_dynamic_entry (DT_RELASZ, 0)
2024 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
2025 return FALSE;
2026
2027 /* If any dynamic relocs apply to a read-only section,
2028 then we need a DT_TEXTREL entry. */
2029 if ((info->flags & DF_TEXTREL) == 0)
2030 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
2031
2032 if ((info->flags & DF_TEXTREL) != 0)
2033 {
2034 if (!add_dynamic_entry (DT_TEXTREL, 0))
2035 return FALSE;
2036 }
2037 }
2038 }
2039 #undef add_dynamic_entry
2040
2041 return TRUE;
2042 }
2043
2044 /* Return the base VMA address which should be subtracted from real addresses
2045 when resolving @dtpoff relocation.
2046 This is PT_TLS segment p_vaddr. */
2047
2048 static bfd_vma
2049 dtpoff_base (struct bfd_link_info *info)
2050 {
2051 /* If tls_sec is NULL, we should have signalled an error already. */
2052 if (elf_hash_table (info)->tls_sec == NULL)
2053 return 0;
2054 return elf_hash_table (info)->tls_sec->vma;
2055 }
2056
2057 /* Return the relocation value for @tpoff relocation
2058 if STT_TLS virtual address is ADDRESS. */
2059
2060 static bfd_vma
2061 tpoff (struct bfd_link_info *info, bfd_vma address)
2062 {
2063 struct elf_link_hash_table *htab = elf_hash_table (info);
2064
2065 /* If tls_sec is NULL, we should have signalled an error already. */
2066 if (htab->tls_sec == NULL)
2067 return 0;
2068 return htab->tls_size + htab->tls_sec->vma - address;
2069 }
2070
2071 /* Complain if TLS instruction relocation is against an invalid
2072 instruction. */
2073
2074 static void
2075 invalid_tls_insn (bfd *input_bfd,
2076 asection *input_section,
2077 Elf_Internal_Rela *rel)
2078 {
2079 reloc_howto_type *howto;
2080
2081 howto = elf_howto_table + ELF32_R_TYPE (rel->r_info);
2082 _bfd_error_handler
2083 /* xgettext:c-format */
2084 (_("%pB(%pA+%#" PRIx64 "): invalid instruction for TLS relocation %s"),
2085 input_bfd,
2086 input_section,
2087 (uint64_t) rel->r_offset,
2088 howto->name);
2089 bfd_set_error (bfd_error_bad_value);
2090 }
2091
2092 /* Relocate a 390 ELF section. */
2093
2094 static bfd_boolean
2095 elf_s390_relocate_section (bfd *output_bfd,
2096 struct bfd_link_info *info,
2097 bfd *input_bfd,
2098 asection *input_section,
2099 bfd_byte *contents,
2100 Elf_Internal_Rela *relocs,
2101 Elf_Internal_Sym *local_syms,
2102 asection **local_sections)
2103 {
2104 struct elf_s390_link_hash_table *htab;
2105 Elf_Internal_Shdr *symtab_hdr;
2106 struct elf_link_hash_entry **sym_hashes;
2107 bfd_vma *local_got_offsets;
2108 Elf_Internal_Rela *rel;
2109 Elf_Internal_Rela *relend;
2110
2111 if (!is_s390_elf (input_bfd))
2112 {
2113 bfd_set_error (bfd_error_wrong_format);
2114 return FALSE;
2115 }
2116
2117 htab = elf_s390_hash_table (info);
2118 symtab_hdr = &elf_symtab_hdr (input_bfd);
2119 sym_hashes = elf_sym_hashes (input_bfd);
2120 local_got_offsets = elf_local_got_offsets (input_bfd);
2121
2122 rel = relocs;
2123 relend = relocs + input_section->reloc_count;
2124 for (; rel < relend; rel++)
2125 {
2126 unsigned int r_type;
2127 reloc_howto_type *howto;
2128 unsigned long r_symndx;
2129 struct elf_link_hash_entry *h;
2130 Elf_Internal_Sym *sym;
2131 asection *sec;
2132 bfd_vma off;
2133 bfd_vma relocation;
2134 bfd_boolean unresolved_reloc;
2135 bfd_reloc_status_type r;
2136 int tls_type;
2137 asection *base_got = htab->elf.sgot;
2138 bfd_boolean resolved_to_zero;
2139
2140 r_type = ELF32_R_TYPE (rel->r_info);
2141 if (r_type == (int) R_390_GNU_VTINHERIT
2142 || r_type == (int) R_390_GNU_VTENTRY)
2143 continue;
2144 if (r_type >= (int) R_390_max)
2145 {
2146 bfd_set_error (bfd_error_bad_value);
2147 return FALSE;
2148 }
2149
2150 howto = elf_howto_table + r_type;
2151 r_symndx = ELF32_R_SYM (rel->r_info);
2152
2153 h = NULL;
2154 sym = NULL;
2155 sec = NULL;
2156 unresolved_reloc = FALSE;
2157 if (r_symndx < symtab_hdr->sh_info)
2158 {
2159 sym = local_syms + r_symndx;
2160 sec = local_sections[r_symndx];
2161 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
2162 {
2163 struct plt_entry *local_plt = elf_s390_local_plt (input_bfd);
2164 if (local_plt == NULL)
2165 return FALSE;
2166
2167 /* Address of the PLT slot. */
2168 relocation = (htab->elf.iplt->output_section->vma
2169 + htab->elf.iplt->output_offset
2170 + local_plt[r_symndx].plt.offset);
2171
2172 switch (r_type)
2173 {
2174 case R_390_PLTOFF16:
2175 case R_390_PLTOFF32:
2176 relocation -= htab->elf.sgot->output_section->vma;
2177 break;
2178 case R_390_GOTPLT12:
2179 case R_390_GOTPLT16:
2180 case R_390_GOTPLT20:
2181 case R_390_GOTPLT32:
2182 case R_390_GOTPLTENT:
2183 case R_390_GOT12:
2184 case R_390_GOT16:
2185 case R_390_GOT20:
2186 case R_390_GOT32:
2187 case R_390_GOTENT:
2188 {
2189 /* Write the PLT slot address into the GOT slot. */
2190 bfd_put_32 (output_bfd, relocation,
2191 htab->elf.sgot->contents +
2192 local_got_offsets[r_symndx]);
2193 relocation = (local_got_offsets[r_symndx] +
2194 htab->elf.sgot->output_offset);
2195
2196 if (r_type == R_390_GOTENT || r_type == R_390_GOTPLTENT)
2197 relocation += htab->elf.sgot->output_section->vma;
2198 break;
2199 }
2200 default:
2201 break;
2202 }
2203 /* The output section is needed later in
2204 finish_dynamic_section when creating the dynamic
2205 relocation. */
2206 local_plt[r_symndx].sec = sec;
2207 goto do_relocation;
2208 }
2209 else
2210 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2211 }
2212 else
2213 {
2214 bfd_boolean warned ATTRIBUTE_UNUSED;
2215 bfd_boolean ignored ATTRIBUTE_UNUSED;
2216
2217 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2218 r_symndx, symtab_hdr, sym_hashes,
2219 h, sec, relocation,
2220 unresolved_reloc, warned, ignored);
2221 }
2222
2223 if (sec != NULL && discarded_section (sec))
2224 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2225 rel, 1, relend, howto, 0, contents);
2226
2227 if (bfd_link_relocatable (info))
2228 continue;
2229
2230 resolved_to_zero = (h != NULL
2231 && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
2232
2233 switch (r_type)
2234 {
2235 case R_390_GOTPLT12:
2236 case R_390_GOTPLT16:
2237 case R_390_GOTPLT20:
2238 case R_390_GOTPLT32:
2239 case R_390_GOTPLTENT:
2240 /* There are three cases for a GOTPLT relocation. 1) The
2241 relocation is against the jump slot entry of a plt that
2242 will get emitted to the output file. 2) The relocation
2243 is against the jump slot of a plt entry that has been
2244 removed. elf_s390_adjust_gotplt has created a GOT entry
2245 as replacement. 3) The relocation is against a local symbol.
2246 Cases 2) and 3) are the same as the GOT relocation code
2247 so we just have to test for case 1 and fall through for
2248 the other two. */
2249 if (h != NULL && h->plt.offset != (bfd_vma) -1)
2250 {
2251 bfd_vma plt_index;
2252
2253 if (s390_is_ifunc_symbol_p (h))
2254 {
2255 plt_index = h->plt.offset / PLT_ENTRY_SIZE;
2256 relocation = (plt_index * GOT_ENTRY_SIZE +
2257 htab->elf.igotplt->output_offset);
2258 if (r_type == R_390_GOTPLTENT)
2259 relocation += htab->elf.igotplt->output_section->vma;
2260 }
2261 else
2262 {
2263 /* Calc. index no.
2264 Current offset - size first entry / entry size. */
2265 plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) /
2266 PLT_ENTRY_SIZE;
2267
2268 /* Offset in GOT is PLT index plus GOT headers(3)
2269 times 4, addr & GOT addr. */
2270 relocation = (plt_index + 3) * GOT_ENTRY_SIZE;
2271 if (r_type == R_390_GOTPLTENT)
2272 relocation += htab->elf.sgot->output_section->vma;
2273 }
2274 unresolved_reloc = FALSE;
2275
2276 }
2277 /* Fall through. */
2278
2279 case R_390_GOT12:
2280 case R_390_GOT16:
2281 case R_390_GOT20:
2282 case R_390_GOT32:
2283 case R_390_GOTENT:
2284 /* Relocation is to the entry for this symbol in the global
2285 offset table. */
2286 if (base_got == NULL)
2287 abort ();
2288
2289 if (h != NULL)
2290 {
2291 bfd_boolean dyn;
2292
2293 off = h->got.offset;
2294 dyn = htab->elf.dynamic_sections_created;
2295
2296 if (s390_is_ifunc_symbol_p (h))
2297 {
2298 BFD_ASSERT (h->plt.offset != (bfd_vma) -1);
2299 if (off == (bfd_vma)-1)
2300 {
2301 /* No explicit GOT usage so redirect to the
2302 got.iplt slot. */
2303 base_got = htab->elf.igotplt;
2304 off = h->plt.offset / PLT_ENTRY_SIZE * GOT_ENTRY_SIZE;
2305 }
2306 else
2307 {
2308 /* Explicit GOT slots must contain the address
2309 of the PLT slot. This will be handled in
2310 finish_dynamic_symbol. */
2311 }
2312 }
2313 else if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
2314 bfd_link_pic (info),
2315 h)
2316 || (bfd_link_pic (info)
2317 && SYMBOL_REFERENCES_LOCAL (info, h))
2318 || (ELF_ST_VISIBILITY (h->other)
2319 && h->root.type == bfd_link_hash_undefweak))
2320
2321 {
2322 /* This is actually a static link, or it is a
2323 -Bsymbolic link and the symbol is defined
2324 locally, or the symbol was forced to be local
2325 because of a version file. We must initialize
2326 this entry in the global offset table. Since the
2327 offset must always be a multiple of 2, we use the
2328 least significant bit to record whether we have
2329 initialized it already.
2330
2331 When doing a dynamic link, we create a .rel.got
2332 relocation entry to initialize the value. This
2333 is done in the finish_dynamic_symbol routine. */
2334 if ((off & 1) != 0)
2335 off &= ~1;
2336 else
2337 {
2338 bfd_put_32 (output_bfd, relocation,
2339 base_got->contents + off);
2340 h->got.offset |= 1;
2341 }
2342
2343 if ((h->def_regular
2344 && bfd_link_pic (info)
2345 && SYMBOL_REFERENCES_LOCAL (info, h))
2346 /* lrl rx,sym@GOTENT -> larl rx, sym */
2347 && ((r_type == R_390_GOTENT
2348 && (bfd_get_16 (input_bfd,
2349 contents + rel->r_offset - 2)
2350 & 0xff0f) == 0xc40d)
2351 /* ly rx, sym@GOT(r12) -> larl rx, sym */
2352 || (r_type == R_390_GOT20
2353 && (bfd_get_32 (input_bfd,
2354 contents + rel->r_offset - 2)
2355 & 0xff00f000) == 0xe300c000
2356 && bfd_get_8 (input_bfd,
2357 contents + rel->r_offset + 3) == 0x58)))
2358 {
2359 unsigned short new_insn =
2360 (0xc000 | (bfd_get_8 (input_bfd,
2361 contents + rel->r_offset - 1) & 0xf0));
2362 bfd_put_16 (output_bfd, new_insn,
2363 contents + rel->r_offset - 2);
2364 r_type = R_390_PC32DBL;
2365 rel->r_addend = 2;
2366 howto = elf_howto_table + r_type;
2367 relocation = h->root.u.def.value
2368 + h->root.u.def.section->output_section->vma
2369 + h->root.u.def.section->output_offset;
2370 goto do_relocation;
2371 }
2372 }
2373 else
2374 unresolved_reloc = FALSE;
2375 }
2376 else
2377 {
2378 if (local_got_offsets == NULL)
2379 abort ();
2380
2381 off = local_got_offsets[r_symndx];
2382
2383 /* The offset must always be a multiple of 4. We use
2384 the least significant bit to record whether we have
2385 already generated the necessary reloc. */
2386 if ((off & 1) != 0)
2387 off &= ~1;
2388 else
2389 {
2390 bfd_put_32 (output_bfd, relocation,
2391 htab->elf.sgot->contents + off);
2392
2393 if (bfd_link_pic (info))
2394 {
2395 asection *srelgot;
2396 Elf_Internal_Rela outrel;
2397 bfd_byte *loc;
2398
2399 srelgot = htab->elf.srelgot;
2400 if (srelgot == NULL)
2401 abort ();
2402
2403 outrel.r_offset = (htab->elf.sgot->output_section->vma
2404 + htab->elf.sgot->output_offset
2405 + off);
2406 outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2407 outrel.r_addend = relocation;
2408 loc = srelgot->contents;
2409 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
2410 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2411 }
2412
2413 local_got_offsets[r_symndx] |= 1;
2414 }
2415 }
2416
2417 if (off >= (bfd_vma) -2)
2418 abort ();
2419
2420 relocation = base_got->output_offset + off;
2421
2422 /* For @GOTENT the relocation is against the offset between
2423 the instruction and the symbols entry in the GOT and not
2424 between the start of the GOT and the symbols entry. We
2425 add the vma of the GOT to get the correct value. */
2426 if ( r_type == R_390_GOTENT
2427 || r_type == R_390_GOTPLTENT)
2428 relocation += base_got->output_section->vma;
2429
2430 break;
2431
2432 case R_390_GOTOFF16:
2433 case R_390_GOTOFF32:
2434 /* Relocation is relative to the start of the global offset
2435 table. */
2436
2437 if (h != NULL
2438 && s390_is_ifunc_symbol_p (h)
2439 && h->def_regular
2440 && !bfd_link_executable (info))
2441 {
2442 relocation = (htab->elf.iplt->output_section->vma
2443 + htab->elf.iplt->output_offset
2444 + h->plt.offset
2445 - htab->elf.sgot->output_section->vma);
2446 goto do_relocation;
2447 }
2448
2449 /* Note that sgot->output_offset is not involved in this
2450 calculation. We always want the start of .got. If we
2451 defined _GLOBAL_OFFSET_TABLE in a different way, as is
2452 permitted by the ABI, we might have to change this
2453 calculation. */
2454 relocation -= htab->elf.sgot->output_section->vma;
2455 break;
2456
2457 case R_390_GOTPC:
2458 case R_390_GOTPCDBL:
2459 /* Use global offset table as symbol value. */
2460 relocation = htab->elf.sgot->output_section->vma;
2461 unresolved_reloc = FALSE;
2462 break;
2463
2464 case R_390_PLT12DBL:
2465 case R_390_PLT16DBL:
2466 case R_390_PLT24DBL:
2467 case R_390_PLT32DBL:
2468 case R_390_PLT32:
2469 /* Relocation is to the entry for this symbol in the
2470 procedure linkage table. */
2471
2472 /* Resolve a PLT32 reloc against a local symbol directly,
2473 without using the procedure linkage table. */
2474 if (h == NULL)
2475 break;
2476
2477 if (h->plt.offset == (bfd_vma) -1
2478 || (htab->elf.splt == NULL && htab->elf.iplt == NULL))
2479 {
2480 /* We didn't make a PLT entry for this symbol. This
2481 happens when statically linking PIC code, or when
2482 using -Bsymbolic. */
2483 break;
2484 }
2485
2486 if (s390_is_ifunc_symbol_p (h))
2487 relocation = (htab->elf.iplt->output_section->vma
2488 + htab->elf.iplt->output_offset
2489 + h->plt.offset);
2490 else
2491 relocation = (htab->elf.splt->output_section->vma
2492 + htab->elf.splt->output_offset
2493 + h->plt.offset);
2494 unresolved_reloc = FALSE;
2495 break;
2496
2497 case R_390_PLTOFF16:
2498 case R_390_PLTOFF32:
2499 /* Relocation is to the entry for this symbol in the
2500 procedure linkage table relative to the start of the GOT. */
2501
2502 /* For local symbols or if we didn't make a PLT entry for
2503 this symbol resolve the symbol directly. */
2504 if (h == NULL
2505 || h->plt.offset == (bfd_vma) -1
2506 || (htab->elf.splt == NULL && !s390_is_ifunc_symbol_p (h)))
2507 {
2508 relocation -= htab->elf.sgot->output_section->vma;
2509 break;
2510 }
2511
2512 if (s390_is_ifunc_symbol_p (h))
2513 relocation = (htab->elf.iplt->output_section->vma
2514 + htab->elf.iplt->output_offset
2515 + h->plt.offset
2516 - htab->elf.sgot->output_section->vma);
2517 else
2518 relocation = (htab->elf.splt->output_section->vma
2519 + htab->elf.splt->output_offset
2520 + h->plt.offset
2521 - htab->elf.sgot->output_section->vma);
2522 unresolved_reloc = FALSE;
2523 break;
2524
2525 case R_390_PC16:
2526 case R_390_PC12DBL:
2527 case R_390_PC16DBL:
2528 case R_390_PC24DBL:
2529 case R_390_PC32DBL:
2530 case R_390_PC32:
2531 if (h != NULL
2532 && s390_is_ifunc_symbol_p (h)
2533 && h->def_regular
2534 && !bfd_link_executable (info))
2535 {
2536 /* This will not work our if the function does not
2537 happen to set up the GOT pointer for some other
2538 reason. 31 bit PLT entries require r12 to hold the
2539 GOT pointer.
2540 FIXME: Implement an errorcheck.
2541 NOTE: It will work when brasl is not available
2542 (e.g. with -m31 -march=g5) since a local function
2543 call then does use GOTOFF which implies r12 being set
2544 up. */
2545 relocation = (htab->elf.iplt->output_section->vma
2546 + htab->elf.iplt->output_offset
2547 + h ->plt.offset);
2548 goto do_relocation;
2549 }
2550 /* Fall through. */
2551
2552 case R_390_8:
2553 case R_390_16:
2554 case R_390_32:
2555 if ((input_section->flags & SEC_ALLOC) == 0)
2556 break;
2557
2558 if (h != NULL
2559 && s390_is_ifunc_symbol_p (h)
2560 && h->def_regular)
2561 {
2562 if (!bfd_link_pic (info))
2563 {
2564 /* For a non-shared object STT_GNU_IFUNC symbol must
2565 go through PLT. */
2566 relocation = (htab->elf.iplt->output_section->vma
2567 + htab->elf.iplt->output_offset
2568 + h ->plt.offset);
2569 goto do_relocation;
2570 }
2571 else
2572 {
2573 /* For shared objects a runtime relocation is needed. */
2574
2575 Elf_Internal_Rela outrel;
2576 asection *sreloc;
2577
2578 /* Need a dynamic relocation to get the real function
2579 address. */
2580 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
2581 info,
2582 input_section,
2583 rel->r_offset);
2584 if (outrel.r_offset == (bfd_vma) -1
2585 || outrel.r_offset == (bfd_vma) -2)
2586 abort ();
2587
2588 outrel.r_offset += (input_section->output_section->vma
2589 + input_section->output_offset);
2590
2591 if (h->dynindx == -1
2592 || h->forced_local
2593 || bfd_link_executable (info))
2594 {
2595 /* This symbol is resolved locally. */
2596 outrel.r_info = ELF32_R_INFO (0, R_390_IRELATIVE);
2597 outrel.r_addend = (h->root.u.def.value
2598 + h->root.u.def.section->output_section->vma
2599 + h->root.u.def.section->output_offset);
2600 }
2601 else
2602 {
2603 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2604 outrel.r_addend = 0;
2605 }
2606
2607 sreloc = htab->elf.irelifunc;
2608 elf_append_rela (output_bfd, sreloc, &outrel);
2609
2610 /* If this reloc is against an external symbol, we
2611 do not want to fiddle with the addend. Otherwise,
2612 we need to include the symbol value so that it
2613 becomes an addend for the dynamic reloc. For an
2614 internal symbol, we have updated addend. */
2615 continue;
2616 }
2617 }
2618
2619 if ((bfd_link_pic (info)
2620 && (h == NULL
2621 || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2622 && !resolved_to_zero)
2623 || h->root.type != bfd_link_hash_undefweak)
2624 && ((r_type != R_390_PC16
2625 && r_type != R_390_PC12DBL
2626 && r_type != R_390_PC16DBL
2627 && r_type != R_390_PC24DBL
2628 && r_type != R_390_PC32DBL
2629 && r_type != R_390_PC32)
2630 || !SYMBOL_CALLS_LOCAL (info, h)))
2631 || (ELIMINATE_COPY_RELOCS
2632 && !bfd_link_pic (info)
2633 && h != NULL
2634 && h->dynindx != -1
2635 && !h->non_got_ref
2636 && ((h->def_dynamic
2637 && !h->def_regular)
2638 || h->root.type == bfd_link_hash_undefweak
2639 || h->root.type == bfd_link_hash_undefined)))
2640 {
2641 Elf_Internal_Rela outrel;
2642 bfd_boolean skip, relocate;
2643 asection *sreloc;
2644 bfd_byte *loc;
2645
2646 /* When generating a shared object, these relocations
2647 are copied into the output file to be resolved at run
2648 time. */
2649
2650 skip = FALSE;
2651 relocate = FALSE;
2652
2653 outrel.r_offset =
2654 _bfd_elf_section_offset (output_bfd, info, input_section,
2655 rel->r_offset);
2656 if (outrel.r_offset == (bfd_vma) -1)
2657 skip = TRUE;
2658 else if (outrel.r_offset == (bfd_vma) -2)
2659 skip = TRUE, relocate = TRUE;
2660 outrel.r_offset += (input_section->output_section->vma
2661 + input_section->output_offset);
2662
2663 if (skip)
2664 memset (&outrel, 0, sizeof outrel);
2665 else if (h != NULL
2666 && h->dynindx != -1
2667 && (r_type == R_390_PC16
2668 || r_type == R_390_PC12DBL
2669 || r_type == R_390_PC16DBL
2670 || r_type == R_390_PC24DBL
2671 || r_type == R_390_PC32DBL
2672 || r_type == R_390_PC32
2673 || !bfd_link_pic (info)
2674 || !SYMBOLIC_BIND (info, h)
2675 || !h->def_regular))
2676 {
2677 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2678 outrel.r_addend = rel->r_addend;
2679 }
2680 else
2681 {
2682 /* This symbol is local, or marked to become local. */
2683 outrel.r_addend = relocation + rel->r_addend;
2684 if (r_type == R_390_32)
2685 {
2686 relocate = TRUE;
2687 outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2688 }
2689 else
2690 {
2691 long sindx;
2692
2693 if (bfd_is_abs_section (sec))
2694 sindx = 0;
2695 else if (sec == NULL || sec->owner == NULL)
2696 {
2697 bfd_set_error(bfd_error_bad_value);
2698 return FALSE;
2699 }
2700 else
2701 {
2702 asection *osec;
2703
2704 osec = sec->output_section;
2705 sindx = elf_section_data (osec)->dynindx;
2706 if (sindx == 0)
2707 {
2708 osec = htab->elf.text_index_section;
2709 sindx = elf_section_data (osec)->dynindx;
2710 }
2711 BFD_ASSERT (sindx != 0);
2712
2713 /* We are turning this relocation into one
2714 against a section symbol, so subtract out
2715 the output section's address but not the
2716 offset of the input section in the output
2717 section. */
2718 outrel.r_addend -= osec->vma;
2719 }
2720 outrel.r_info = ELF32_R_INFO (sindx, r_type);
2721 }
2722 }
2723
2724 sreloc = elf_section_data (input_section)->sreloc;
2725 if (sreloc == NULL)
2726 abort ();
2727
2728 loc = sreloc->contents;
2729 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2730 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2731
2732 /* If this reloc is against an external symbol, we do
2733 not want to fiddle with the addend. Otherwise, we
2734 need to include the symbol value so that it becomes
2735 an addend for the dynamic reloc. */
2736 if (! relocate)
2737 continue;
2738 }
2739 break;
2740
2741 /* Relocations for tls literal pool entries. */
2742 case R_390_TLS_IE32:
2743 if (bfd_link_pic (info))
2744 {
2745 Elf_Internal_Rela outrel;
2746 asection *sreloc;
2747 bfd_byte *loc;
2748
2749 outrel.r_offset = rel->r_offset
2750 + input_section->output_section->vma
2751 + input_section->output_offset;
2752 outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2753 sreloc = elf_section_data (input_section)->sreloc;
2754 if (sreloc == NULL)
2755 abort ();
2756 loc = sreloc->contents;
2757 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2758 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2759 }
2760 /* Fall through. */
2761
2762 case R_390_TLS_GD32:
2763 case R_390_TLS_GOTIE32:
2764 r_type = elf_s390_tls_transition (info, r_type, h == NULL);
2765 tls_type = GOT_UNKNOWN;
2766 if (h == NULL && local_got_offsets)
2767 tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
2768 else if (h != NULL)
2769 {
2770 tls_type = elf_s390_hash_entry(h)->tls_type;
2771 if (!bfd_link_pic (info)
2772 && h->dynindx == -1
2773 && tls_type >= GOT_TLS_IE)
2774 r_type = R_390_TLS_LE32;
2775 }
2776 if (r_type == R_390_TLS_GD32 && tls_type >= GOT_TLS_IE)
2777 r_type = R_390_TLS_IE32;
2778
2779 if (r_type == R_390_TLS_LE32)
2780 {
2781 /* This relocation gets optimized away by the local exec
2782 access optimization. */
2783 BFD_ASSERT (! unresolved_reloc);
2784 bfd_put_32 (output_bfd, -tpoff (info, relocation),
2785 contents + rel->r_offset);
2786 continue;
2787 }
2788
2789 if (htab->elf.sgot == NULL)
2790 abort ();
2791
2792 if (h != NULL)
2793 off = h->got.offset;
2794 else
2795 {
2796 if (local_got_offsets == NULL)
2797 abort ();
2798
2799 off = local_got_offsets[r_symndx];
2800 }
2801
2802 emit_tls_relocs:
2803
2804 if ((off & 1) != 0)
2805 off &= ~1;
2806 else
2807 {
2808 Elf_Internal_Rela outrel;
2809 bfd_byte *loc;
2810 int dr_type, indx;
2811
2812 if (htab->elf.srelgot == NULL)
2813 abort ();
2814
2815 outrel.r_offset = (htab->elf.sgot->output_section->vma
2816 + htab->elf.sgot->output_offset + off);
2817
2818 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2819 if (r_type == R_390_TLS_GD32)
2820 dr_type = R_390_TLS_DTPMOD;
2821 else
2822 dr_type = R_390_TLS_TPOFF;
2823 if (dr_type == R_390_TLS_TPOFF && indx == 0)
2824 outrel.r_addend = relocation - dtpoff_base (info);
2825 else
2826 outrel.r_addend = 0;
2827 outrel.r_info = ELF32_R_INFO (indx, dr_type);
2828 loc = htab->elf.srelgot->contents;
2829 loc += htab->elf.srelgot->reloc_count++
2830 * sizeof (Elf32_External_Rela);
2831 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2832
2833 if (r_type == R_390_TLS_GD32)
2834 {
2835 if (indx == 0)
2836 {
2837 BFD_ASSERT (! unresolved_reloc);
2838 bfd_put_32 (output_bfd,
2839 relocation - dtpoff_base (info),
2840 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
2841 }
2842 else
2843 {
2844 outrel.r_info = ELF32_R_INFO (indx, R_390_TLS_DTPOFF);
2845 outrel.r_offset += GOT_ENTRY_SIZE;
2846 outrel.r_addend = 0;
2847 htab->elf.srelgot->reloc_count++;
2848 loc += sizeof (Elf32_External_Rela);
2849 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2850 }
2851 }
2852
2853 if (h != NULL)
2854 h->got.offset |= 1;
2855 else
2856 local_got_offsets[r_symndx] |= 1;
2857 }
2858
2859 if (off >= (bfd_vma) -2)
2860 abort ();
2861 if (r_type == ELF32_R_TYPE (rel->r_info))
2862 {
2863 relocation = htab->elf.sgot->output_offset + off;
2864 if (r_type == R_390_TLS_IE32 || r_type == R_390_TLS_IEENT)
2865 relocation += htab->elf.sgot->output_section->vma;
2866 unresolved_reloc = FALSE;
2867 }
2868 else
2869 {
2870 bfd_put_32 (output_bfd, htab->elf.sgot->output_offset + off,
2871 contents + rel->r_offset);
2872 continue;
2873 }
2874 break;
2875
2876 case R_390_TLS_GOTIE12:
2877 case R_390_TLS_GOTIE20:
2878 case R_390_TLS_IEENT:
2879 if (h == NULL)
2880 {
2881 if (local_got_offsets == NULL)
2882 abort();
2883 off = local_got_offsets[r_symndx];
2884 if (bfd_link_pic (info))
2885 goto emit_tls_relocs;
2886 }
2887 else
2888 {
2889 off = h->got.offset;
2890 tls_type = elf_s390_hash_entry(h)->tls_type;
2891 if (bfd_link_pic (info)
2892 || h->dynindx != -1
2893 || tls_type < GOT_TLS_IE)
2894 goto emit_tls_relocs;
2895 }
2896
2897 if (htab->elf.sgot == NULL)
2898 abort ();
2899
2900 BFD_ASSERT (! unresolved_reloc);
2901 bfd_put_32 (output_bfd, -tpoff (info, relocation),
2902 htab->elf.sgot->contents + off);
2903 relocation = htab->elf.sgot->output_offset + off;
2904 if (r_type == R_390_TLS_IEENT)
2905 relocation += htab->elf.sgot->output_section->vma;
2906 unresolved_reloc = FALSE;
2907 break;
2908
2909 case R_390_TLS_LDM32:
2910 if (! bfd_link_pic (info))
2911 /* The literal pool entry this relocation refers to gets ignored
2912 by the optimized code of the local exec model. Do nothing
2913 and the value will turn out zero. */
2914 continue;
2915
2916 if (htab->elf.sgot == NULL)
2917 abort ();
2918
2919 off = htab->tls_ldm_got.offset;
2920 if (off & 1)
2921 off &= ~1;
2922 else
2923 {
2924 Elf_Internal_Rela outrel;
2925 bfd_byte *loc;
2926
2927 if (htab->elf.srelgot == NULL)
2928 abort ();
2929
2930 outrel.r_offset = (htab->elf.sgot->output_section->vma
2931 + htab->elf.sgot->output_offset + off);
2932
2933 bfd_put_32 (output_bfd, 0,
2934 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
2935 outrel.r_info = ELF32_R_INFO (0, R_390_TLS_DTPMOD);
2936 outrel.r_addend = 0;
2937 loc = htab->elf.srelgot->contents;
2938 loc += htab->elf.srelgot->reloc_count++
2939 * sizeof (Elf32_External_Rela);
2940 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2941 htab->tls_ldm_got.offset |= 1;
2942 }
2943 relocation = htab->elf.sgot->output_offset + off;
2944 unresolved_reloc = FALSE;
2945 break;
2946
2947 case R_390_TLS_LE32:
2948 if (bfd_link_dll (info))
2949 {
2950 /* Linking a shared library with non-fpic code requires
2951 a R_390_TLS_TPOFF relocation. */
2952 Elf_Internal_Rela outrel;
2953 asection *sreloc;
2954 bfd_byte *loc;
2955 int indx;
2956
2957 outrel.r_offset = rel->r_offset
2958 + input_section->output_section->vma
2959 + input_section->output_offset;
2960 if (h != NULL && h->dynindx != -1)
2961 indx = h->dynindx;
2962 else
2963 indx = 0;
2964 outrel.r_info = ELF32_R_INFO (indx, R_390_TLS_TPOFF);
2965 if (indx == 0)
2966 outrel.r_addend = relocation - dtpoff_base (info);
2967 else
2968 outrel.r_addend = 0;
2969 sreloc = elf_section_data (input_section)->sreloc;
2970 if (sreloc == NULL)
2971 abort ();
2972 loc = sreloc->contents;
2973 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2974 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2975 }
2976 else
2977 {
2978 BFD_ASSERT (! unresolved_reloc);
2979 bfd_put_32 (output_bfd, -tpoff (info, relocation),
2980 contents + rel->r_offset);
2981 }
2982 continue;
2983
2984 case R_390_TLS_LDO32:
2985 if (bfd_link_pic (info) || (input_section->flags & SEC_DEBUGGING))
2986 relocation -= dtpoff_base (info);
2987 else
2988 /* When converting LDO to LE, we must negate. */
2989 relocation = -tpoff (info, relocation);
2990 break;
2991
2992 /* Relocations for tls instructions. */
2993 case R_390_TLS_LOAD:
2994 case R_390_TLS_GDCALL:
2995 case R_390_TLS_LDCALL:
2996 tls_type = GOT_UNKNOWN;
2997 if (h == NULL && local_got_offsets)
2998 tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
2999 else if (h != NULL)
3000 tls_type = elf_s390_hash_entry(h)->tls_type;
3001
3002 if (tls_type == GOT_TLS_GD)
3003 continue;
3004
3005 if (r_type == R_390_TLS_LOAD)
3006 {
3007 if (!bfd_link_pic (info) && (h == NULL || h->dynindx == -1))
3008 {
3009 /* IE->LE transition. Four valid cases:
3010 l %rx,0(0,%ry) -> lr %rx,%ry + bcr 0,0
3011 l %rx,0(%ry,0) -> lr %rx,%ry + bcr 0,0
3012 l %rx,0(%ry,%r12) -> lr %rx,%ry + bcr 0,0
3013 l %rx,0(%r12,%ry) -> lr %rx,%ry + bcr 0,0 */
3014 unsigned int insn, ry;
3015
3016 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3017 if ((insn & 0xff00f000) == 0x58000000)
3018 /* l %rx,0(%ry,0) -> lr %rx,%ry + bcr 0,0 */
3019 ry = (insn & 0x000f0000);
3020 else if ((insn & 0xff0f0000) == 0x58000000)
3021 /* l %rx,0(0,%ry) -> lr %rx,%ry + bcr 0,0 */
3022 ry = (insn & 0x0000f000) << 4;
3023 else if ((insn & 0xff00f000) == 0x5800c000)
3024 /* l %rx,0(%ry,%r12) -> lr %rx,%ry + bcr 0,0 */
3025 ry = (insn & 0x000f0000);
3026 else if ((insn & 0xff0f0000) == 0x580c0000)
3027 /* l %rx,0(%r12,%ry) -> lr %rx,%ry + bcr 0,0 */
3028 ry = (insn & 0x0000f000) << 4;
3029 else
3030 {
3031 invalid_tls_insn (input_bfd, input_section, rel);
3032 return FALSE;
3033 }
3034 insn = 0x18000700 | (insn & 0x00f00000) | ry;
3035 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3036 }
3037 }
3038 else if (r_type == R_390_TLS_GDCALL)
3039 {
3040 unsigned int insn;
3041
3042 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3043 if ((insn & 0xff000fff) != 0x4d000000 &&
3044 (insn & 0xffff0000) != 0xc0e50000 &&
3045 (insn & 0xff000000) != 0x0d000000)
3046 {
3047 invalid_tls_insn (input_bfd, input_section, rel);
3048 return FALSE;
3049 }
3050 if (!bfd_link_pic (info) && (h == NULL || h->dynindx == -1))
3051 {
3052 if ((insn & 0xff000000) == 0x0d000000)
3053 {
3054 /* GD->LE transition.
3055 basr rx, ry -> nopr r7 */
3056 insn = 0x07070000 | (insn & 0xffff);
3057 }
3058 else if ((insn & 0xff000000) == 0x4d000000)
3059 {
3060 /* GD->LE transition.
3061 bas %r14,0(%rx,%r13) -> bc 0,0 */
3062 insn = 0x47000000;
3063 }
3064 else
3065 {
3066 /* GD->LE transition.
3067 brasl %r14,_tls_get_offset@plt -> brcl 0,. */
3068 insn = 0xc0040000;
3069 bfd_put_16 (output_bfd, 0x0000,
3070 contents + rel->r_offset + 4);
3071 }
3072 }
3073 else
3074 {
3075 /* If basr is used in the pic case to invoke
3076 _tls_get_offset, something went wrong before. */
3077 if ((insn & 0xff000000) == 0x0d000000)
3078 {
3079 invalid_tls_insn (input_bfd, input_section, rel);
3080 return FALSE;
3081 }
3082
3083 if ((insn & 0xff000000) == 0x4d000000)
3084 {
3085 /* GD->IE transition.
3086 bas %r14,0(%rx,%r13) -> l %r2,0(%r2,%r12) */
3087 insn = 0x5822c000;
3088 }
3089 else
3090 {
3091 /* GD->IE transition.
3092 brasl %r14,__tls_get_addr@plt ->
3093 l %r2,0(%r2,%r12) ; bcr 0,0 */
3094 insn = 0x5822c000;
3095 bfd_put_16 (output_bfd, 0x0700,
3096 contents + rel->r_offset + 4);
3097 }
3098 }
3099 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3100 }
3101 else if (r_type == R_390_TLS_LDCALL)
3102 {
3103 if (!bfd_link_pic (info))
3104 {
3105 unsigned int insn;
3106
3107 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3108 if ((insn & 0xff000fff) != 0x4d000000 &&
3109 (insn & 0xffff0000) != 0xc0e50000 &&
3110 (insn & 0xff000000) != 0x0d000000)
3111 {
3112 invalid_tls_insn (input_bfd, input_section, rel);
3113 return FALSE;
3114 }
3115
3116 if ((insn & 0xff000000) == 0x0d000000)
3117 {
3118 /* LD->LE transition.
3119 basr rx, ry -> nopr r7 */
3120 insn = 0x07070000 | (insn & 0xffff);
3121 }
3122 else if ((insn & 0xff000000) == 0x4d000000)
3123 {
3124 /* LD->LE transition.
3125 bas %r14,0(%rx,%r13) -> bc 0,0 */
3126 insn = 0x47000000;
3127 }
3128 else
3129 {
3130 /* LD->LE transition.
3131 brasl %r14,__tls_get_offset@plt -> brcl 0,. */
3132 insn = 0xc0040000;
3133 bfd_put_16 (output_bfd, 0x0000,
3134 contents + rel->r_offset + 4);
3135 }
3136 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3137 }
3138 }
3139 continue;
3140
3141 default:
3142 break;
3143 }
3144
3145 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3146 because such sections are not SEC_ALLOC and thus ld.so will
3147 not process them. */
3148 if (unresolved_reloc
3149 && !((input_section->flags & SEC_DEBUGGING) != 0
3150 && h->def_dynamic)
3151 && _bfd_elf_section_offset (output_bfd, info, input_section,
3152 rel->r_offset) != (bfd_vma) -1)
3153 _bfd_error_handler
3154 /* xgettext:c-format */
3155 (_("%pB(%pA+%#" PRIx64 "): "
3156 "unresolvable %s relocation against symbol `%s'"),
3157 input_bfd,
3158 input_section,
3159 (uint64_t) rel->r_offset,
3160 howto->name,
3161 h->root.root.string);
3162
3163 do_relocation:
3164
3165 /* When applying a 24 bit reloc we need to start one byte
3166 earlier. Otherwise the 32 bit get/put bfd operations might
3167 access a byte after the actual section. */
3168 if (r_type == R_390_PC24DBL
3169 || r_type == R_390_PLT24DBL)
3170 rel->r_offset--;
3171
3172 if (r_type == R_390_20
3173 || r_type == R_390_GOT20
3174 || r_type == R_390_GOTPLT20
3175 || r_type == R_390_TLS_GOTIE20)
3176 {
3177 relocation += rel->r_addend;
3178 relocation = (relocation&0xfff) << 8 | (relocation&0xff000) >> 12;
3179 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3180 contents, rel->r_offset,
3181 relocation, 0);
3182 }
3183 else
3184 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3185 contents, rel->r_offset,
3186 relocation, rel->r_addend);
3187
3188 if (r != bfd_reloc_ok)
3189 {
3190 const char *name;
3191
3192 if (h != NULL)
3193 name = h->root.root.string;
3194 else
3195 {
3196 name = bfd_elf_string_from_elf_section (input_bfd,
3197 symtab_hdr->sh_link,
3198 sym->st_name);
3199 if (name == NULL)
3200 return FALSE;
3201 if (*name == '\0')
3202 name = bfd_section_name (sec);
3203 }
3204
3205 if (r == bfd_reloc_overflow)
3206 (*info->callbacks->reloc_overflow)
3207 (info, (h ? &h->root : NULL), name, howto->name,
3208 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
3209 else
3210 {
3211 _bfd_error_handler
3212 /* xgettext:c-format */
3213 (_("%pB(%pA+%#" PRIx64 "): reloc against `%s': error %d"),
3214 input_bfd, input_section,
3215 (uint64_t) rel->r_offset, name, (int) r);
3216 return FALSE;
3217 }
3218 }
3219 }
3220
3221 return TRUE;
3222 }
3223
3224 /* Generate the PLT slots together with the dynamic relocations needed
3225 for IFUNC symbols. */
3226
3227 static void
3228 elf_s390_finish_ifunc_symbol (bfd *output_bfd,
3229 struct bfd_link_info *info,
3230 struct elf_link_hash_entry *h,
3231 struct elf_s390_link_hash_table *htab,
3232 bfd_vma iplt_offset,
3233 bfd_vma resolver_address)
3234 {
3235 bfd_vma iplt_index;
3236 bfd_vma got_offset;
3237 bfd_vma igotiplt_offset;
3238 Elf_Internal_Rela rela;
3239 bfd_byte *loc;
3240 asection *plt, *gotplt, *relplt;
3241 bfd_vma relative_offset;
3242
3243 if (htab->elf.iplt == NULL
3244 || htab->elf.igotplt == NULL
3245 || htab->elf.irelplt == NULL)
3246 abort ();
3247
3248 gotplt = htab->elf.igotplt;
3249 relplt = htab->elf.irelplt;
3250
3251 /* Index of the PLT slot within iplt section. */
3252 iplt_index = iplt_offset / PLT_ENTRY_SIZE;
3253 plt = htab->elf.iplt;
3254 /* Offset into the igot.plt section. */
3255 igotiplt_offset = iplt_index * GOT_ENTRY_SIZE;
3256 /* Offset into the got section. */
3257 got_offset = igotiplt_offset + gotplt->output_offset;
3258
3259 /* S390 uses halfwords for relative branch calc! */
3260 relative_offset = - (plt->output_offset +
3261 (PLT_ENTRY_SIZE * iplt_index) + 18) / 2;
3262 /* If offset is > 32768, branch to a previous branch
3263 390 can only handle +-64 K jumps. */
3264 if ( -32768 > (int) relative_offset )
3265 relative_offset
3266 = -(unsigned) (((65536 / PLT_ENTRY_SIZE - 1) * PLT_ENTRY_SIZE) / 2);
3267
3268 /* Fill in the entry in the procedure linkage table. */
3269 if (!bfd_link_pic (info))
3270 {
3271 memcpy (plt->contents + iplt_offset, elf_s390_plt_entry,
3272 PLT_ENTRY_SIZE);
3273
3274 /* Adjust jump to the first plt entry. */
3275 bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3276 plt->contents + iplt_offset + 20);
3277
3278 /* Push the GOT offset field. */
3279 bfd_put_32 (output_bfd,
3280 (gotplt->output_section->vma
3281 + got_offset),
3282 plt->contents + iplt_offset + 24);
3283 }
3284 else if (got_offset < 4096)
3285 {
3286 /* The GOT offset is small enough to be used directly as
3287 displacement. */
3288 memcpy (plt->contents + iplt_offset,
3289 elf_s390_plt_pic12_entry,
3290 PLT_ENTRY_SIZE);
3291
3292 /* Put in the GOT offset as displacement value. The 0xc000
3293 value comes from the first word of the plt entry. Look
3294 at the elf_s390_plt_pic16_entry content. */
3295 bfd_put_16 (output_bfd, (bfd_vma)0xc000 | got_offset,
3296 plt->contents + iplt_offset + 2);
3297
3298 /* Adjust the jump to the first plt entry. */
3299 bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3300 plt->contents + iplt_offset + 20);
3301 }
3302 else if (got_offset < 32768)
3303 {
3304 /* The GOT offset is too big for a displacement but small
3305 enough to be a signed 16 bit immediate value as it can be
3306 used in an lhi instruction. */
3307 memcpy (plt->contents + iplt_offset,
3308 elf_s390_plt_pic16_entry,
3309 PLT_ENTRY_SIZE);
3310
3311 /* Put in the GOT offset for the lhi instruction. */
3312 bfd_put_16 (output_bfd, (bfd_vma)got_offset,
3313 plt->contents + iplt_offset + 2);
3314
3315 /* Adjust the jump to the first plt entry. */
3316 bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3317 plt->contents + iplt_offset + 20);
3318 }
3319 else
3320 {
3321 memcpy (plt->contents + iplt_offset,
3322 elf_s390_plt_pic_entry,
3323 PLT_ENTRY_SIZE);
3324
3325 /* Adjust the jump to the first plt entry. */
3326 bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3327 plt->contents + iplt_offset + 20);
3328
3329 /* Push the GOT offset field. */
3330 bfd_put_32 (output_bfd, got_offset,
3331 plt->contents + iplt_offset + 24);
3332 }
3333 /* Insert offset into reloc. table here. */
3334 bfd_put_32 (output_bfd, relplt->output_offset +
3335 iplt_index * RELA_ENTRY_SIZE,
3336 plt->contents + iplt_offset + 28);
3337
3338 /* Fill in the entry in the global offset table.
3339 Points to instruction after GOT offset. */
3340 bfd_put_32 (output_bfd,
3341 (plt->output_section->vma
3342 + plt->output_offset
3343 + iplt_offset
3344 + 12),
3345 gotplt->contents + igotiplt_offset);
3346
3347 /* Fill in the entry in the .rela.plt section. */
3348 rela.r_offset = gotplt->output_section->vma + got_offset;
3349
3350 if (!h
3351 || h->dynindx == -1
3352 || ((bfd_link_executable (info)
3353 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
3354 && h->def_regular))
3355 {
3356 /* The symbol can be locally resolved. */
3357 rela.r_info = ELF32_R_INFO (0, R_390_IRELATIVE);
3358 rela.r_addend = resolver_address;
3359 }
3360 else
3361 {
3362 rela.r_info = ELF32_R_INFO (h->dynindx, R_390_JMP_SLOT);
3363 rela.r_addend = 0;
3364 }
3365
3366 loc = relplt->contents + iplt_index * RELA_ENTRY_SIZE;
3367 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3368 }
3369
3370 /* Finish up dynamic symbol handling. We set the contents of various
3371 dynamic sections here. */
3372
3373 static bfd_boolean
3374 elf_s390_finish_dynamic_symbol (bfd *output_bfd,
3375 struct bfd_link_info *info,
3376 struct elf_link_hash_entry *h,
3377 Elf_Internal_Sym *sym)
3378 {
3379 struct elf_s390_link_hash_table *htab;
3380 struct elf_s390_link_hash_entry *eh = (struct elf_s390_link_hash_entry*)h;
3381
3382 htab = elf_s390_hash_table (info);
3383
3384 if (h->plt.offset != (bfd_vma) -1)
3385 {
3386 bfd_vma plt_index;
3387 bfd_vma got_offset;
3388 Elf_Internal_Rela rela;
3389 bfd_byte *loc;
3390 bfd_vma relative_offset;
3391
3392 /* This symbol has an entry in the procedure linkage table. Set
3393 it up. */
3394 if (s390_is_ifunc_symbol_p (h) && h->def_regular)
3395 {
3396 elf_s390_finish_ifunc_symbol (output_bfd, info, h,
3397 htab, h->plt.offset,
3398 eh->ifunc_resolver_address +
3399 eh->ifunc_resolver_section->output_offset +
3400 eh->ifunc_resolver_section->output_section->vma);
3401 /* Do not return yet. Handling of explicit GOT slots of
3402 IFUNC symbols is below. */
3403 }
3404 else
3405 {
3406 if (h->dynindx == -1
3407 || htab->elf.splt == NULL
3408 || htab->elf.sgotplt == NULL
3409 || htab->elf.srelplt == NULL)
3410 abort ();
3411
3412 /* Calc. index no.
3413 Current offset - size first entry / entry size. */
3414 plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3415
3416 /* Offset in GOT is PLT index plus GOT headers(3) times 4,
3417 addr & GOT addr. */
3418 got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
3419
3420 /* S390 uses halfwords for relative branch calc! */
3421 relative_offset = - ((PLT_FIRST_ENTRY_SIZE +
3422 (PLT_ENTRY_SIZE * plt_index) + 18) / 2);
3423 /* If offset is > 32768, branch to a previous branch
3424 390 can only handle +-64 K jumps. */
3425 if ( -32768 > (int) relative_offset )
3426 relative_offset
3427 = -(unsigned) (((65536 / PLT_ENTRY_SIZE - 1) * PLT_ENTRY_SIZE) / 2);
3428
3429 /* Fill in the entry in the procedure linkage table. */
3430 if (!bfd_link_pic (info))
3431 {
3432 memcpy (htab->elf.splt->contents + h->plt.offset, elf_s390_plt_entry,
3433 PLT_ENTRY_SIZE);
3434
3435 /* Adjust jump to the first plt entry. */
3436 bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3437 htab->elf.splt->contents + h->plt.offset + 20);
3438
3439 /* Push the GOT offset field. */
3440 bfd_put_32 (output_bfd,
3441 (htab->elf.sgotplt->output_section->vma
3442 + htab->elf.sgotplt->output_offset
3443 + got_offset),
3444 htab->elf.splt->contents + h->plt.offset + 24);
3445 }
3446 else if (got_offset < 4096)
3447 {
3448 /* The GOT offset is small enough to be used directly as
3449 displacement. */
3450 memcpy (htab->elf.splt->contents + h->plt.offset,
3451 elf_s390_plt_pic12_entry,
3452 PLT_ENTRY_SIZE);
3453
3454 /* Put in the GOT offset as displacement value. The 0xc000
3455 value comes from the first word of the plt entry. Look
3456 at the elf_s390_plt_pic12_entry content. */
3457 bfd_put_16 (output_bfd, (bfd_vma)0xc000 | got_offset,
3458 htab->elf.splt->contents + h->plt.offset + 2);
3459
3460 /* Adjust the jump to the first plt entry. */
3461 bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3462 htab->elf.splt->contents + h->plt.offset + 20);
3463 }
3464 else if (got_offset < 32768)
3465 {
3466 /* The GOT offset is too big for a displacement but small
3467 enough to be a signed 16 bit immediate value as it can be
3468 used in an lhi instruction. */
3469 memcpy (htab->elf.splt->contents + h->plt.offset,
3470 elf_s390_plt_pic16_entry,
3471 PLT_ENTRY_SIZE);
3472
3473 /* Put in the GOT offset for the lhi instruction. */
3474 bfd_put_16 (output_bfd, (bfd_vma)got_offset,
3475 htab->elf.splt->contents + h->plt.offset + 2);
3476
3477 /* Adjust the jump to the first plt entry. */
3478 bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3479 htab->elf.splt->contents + h->plt.offset + 20);
3480 }
3481 else
3482 {
3483 memcpy (htab->elf.splt->contents + h->plt.offset,
3484 elf_s390_plt_pic_entry,
3485 PLT_ENTRY_SIZE);
3486
3487 /* Adjust the jump to the first plt entry. */
3488 bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3489 htab->elf.splt->contents + h->plt.offset + 20);
3490
3491 /* Push the GOT offset field. */
3492 bfd_put_32 (output_bfd, got_offset,
3493 htab->elf.splt->contents + h->plt.offset + 24);
3494 }
3495 /* Insert offset into reloc. table here. */
3496 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
3497 htab->elf.splt->contents + h->plt.offset + 28);
3498
3499 /* Fill in the entry in the global offset table.
3500 Points to instruction after GOT offset. */
3501 bfd_put_32 (output_bfd,
3502 (htab->elf.splt->output_section->vma
3503 + htab->elf.splt->output_offset
3504 + h->plt.offset
3505 + 12),
3506 htab->elf.sgotplt->contents + got_offset);
3507
3508 /* Fill in the entry in the .rela.plt section. */
3509 rela.r_offset = (htab->elf.sgotplt->output_section->vma
3510 + htab->elf.sgotplt->output_offset
3511 + got_offset);
3512 rela.r_info = ELF32_R_INFO (h->dynindx, R_390_JMP_SLOT);
3513 rela.r_addend = 0;
3514 loc = htab->elf.srelplt->contents + plt_index * sizeof (Elf32_External_Rela);
3515 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3516
3517 if (!h->def_regular)
3518 {
3519 /* Mark the symbol as undefined, rather than as defined in
3520 the .plt section. Leave the value alone. This is a clue
3521 for the dynamic linker, to make function pointer
3522 comparisons work between an application and shared
3523 library. */
3524 sym->st_shndx = SHN_UNDEF;
3525 }
3526 }
3527 }
3528
3529 if (h->got.offset != (bfd_vma) -1
3530 && elf_s390_hash_entry(h)->tls_type != GOT_TLS_GD
3531 && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE
3532 && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE_NLT)
3533 {
3534 Elf_Internal_Rela rela;
3535 bfd_byte *loc;
3536
3537 /* This symbol has an entry in the global offset table. Set it
3538 up. */
3539
3540 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
3541 abort ();
3542
3543 rela.r_offset = (htab->elf.sgot->output_section->vma
3544 + htab->elf.sgot->output_offset
3545 + (h->got.offset &~ (bfd_vma) 1));
3546
3547 /* If this is a static link, or it is a -Bsymbolic link and the
3548 symbol is defined locally or was forced to be local because
3549 of a version file, we just want to emit a RELATIVE reloc.
3550 The entry in the global offset table will already have been
3551 initialized in the relocate_section function. */
3552 if (h->def_regular && s390_is_ifunc_symbol_p (h))
3553 {
3554 if (bfd_link_pic (info))
3555 {
3556 /* An explicit GOT slot usage needs GLOB_DAT. If the
3557 symbol references local the implicit got.iplt slot
3558 will be used and the IRELATIVE reloc has been created
3559 above. */
3560 goto do_glob_dat;
3561 }
3562 else
3563 {
3564 /* For non-shared objects explicit GOT slots must be
3565 filled with the PLT slot address for pointer
3566 equality reasons. */
3567 bfd_put_32 (output_bfd, (htab->elf.iplt->output_section->vma
3568 + htab->elf.iplt->output_offset
3569 + h->plt.offset),
3570 htab->elf.sgot->contents + h->got.offset);
3571 return TRUE;
3572 }
3573 }
3574 else if (bfd_link_pic (info)
3575 && SYMBOL_REFERENCES_LOCAL (info, h))
3576 {
3577 /* If this is a static link, or it is a -Bsymbolic link and
3578 the symbol is defined locally or was forced to be local
3579 because of a version file, we just want to emit a
3580 RELATIVE reloc. The entry in the global offset table
3581 will already have been initialized in the
3582 relocate_section function. */
3583 if (!(h->def_regular || ELF_COMMON_DEF_P (h)))
3584 return FALSE;
3585 BFD_ASSERT((h->got.offset & 1) != 0);
3586 rela.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
3587 rela.r_addend = (h->root.u.def.value
3588 + h->root.u.def.section->output_section->vma
3589 + h->root.u.def.section->output_offset);
3590 }
3591 else
3592 {
3593 BFD_ASSERT((h->got.offset & 1) == 0);
3594 do_glob_dat:
3595 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->elf.sgot->contents + h->got.offset);
3596 rela.r_info = ELF32_R_INFO (h->dynindx, R_390_GLOB_DAT);
3597 rela.r_addend = 0;
3598 }
3599
3600 loc = htab->elf.srelgot->contents;
3601 loc += htab->elf.srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
3602 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3603 }
3604
3605 if (h->needs_copy)
3606 {
3607 Elf_Internal_Rela rela;
3608 asection *s;
3609 bfd_byte *loc;
3610
3611 /* This symbols needs a copy reloc. Set it up. */
3612
3613 if (h->dynindx == -1
3614 || (h->root.type != bfd_link_hash_defined
3615 && h->root.type != bfd_link_hash_defweak)
3616 || htab->elf.srelbss == NULL
3617 || htab->elf.sreldynrelro == NULL)
3618 abort ();
3619
3620 rela.r_offset = (h->root.u.def.value
3621 + h->root.u.def.section->output_section->vma
3622 + h->root.u.def.section->output_offset);
3623 rela.r_info = ELF32_R_INFO (h->dynindx, R_390_COPY);
3624 rela.r_addend = 0;
3625 if (h->root.u.def.section == htab->elf.sdynrelro)
3626 s = htab->elf.sreldynrelro;
3627 else
3628 s = htab->elf.srelbss;
3629 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
3630 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3631 }
3632
3633 /* Mark some specially defined symbols as absolute. */
3634 if (h == htab->elf.hdynamic
3635 || h == htab->elf.hgot
3636 || h == htab->elf.hplt)
3637 sym->st_shndx = SHN_ABS;
3638
3639 return TRUE;
3640 }
3641
3642 /* Used to decide how to sort relocs in an optimal manner for the
3643 dynamic linker, before writing them out. */
3644
3645 static enum elf_reloc_type_class
3646 elf_s390_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
3647 const asection *rel_sec ATTRIBUTE_UNUSED,
3648 const Elf_Internal_Rela *rela)
3649 {
3650 bfd *abfd = info->output_bfd;
3651 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3652 struct elf_s390_link_hash_table *htab = elf_s390_hash_table (info);
3653 unsigned long r_symndx = ELF32_R_SYM (rela->r_info);
3654 Elf_Internal_Sym sym;
3655
3656 if (htab->elf.dynsym == NULL
3657 || !bed->s->swap_symbol_in (abfd,
3658 (htab->elf.dynsym->contents
3659 + r_symndx * bed->s->sizeof_sym),
3660 0, &sym))
3661 abort ();
3662
3663 /* Check relocation against STT_GNU_IFUNC symbol. */
3664 if (ELF_ST_TYPE (sym.st_info) == STT_GNU_IFUNC)
3665 return reloc_class_ifunc;
3666
3667 switch ((int) ELF32_R_TYPE (rela->r_info))
3668 {
3669 case R_390_RELATIVE:
3670 return reloc_class_relative;
3671 case R_390_JMP_SLOT:
3672 return reloc_class_plt;
3673 case R_390_COPY:
3674 return reloc_class_copy;
3675 default:
3676 return reloc_class_normal;
3677 }
3678 }
3679
3680 /* Finish up the dynamic sections. */
3681
3682 static bfd_boolean
3683 elf_s390_finish_dynamic_sections (bfd *output_bfd,
3684 struct bfd_link_info *info)
3685 {
3686 struct elf_s390_link_hash_table *htab;
3687 bfd *dynobj;
3688 asection *sdyn;
3689 bfd *ibfd;
3690 unsigned int i;
3691
3692 htab = elf_s390_hash_table (info);
3693 dynobj = htab->elf.dynobj;
3694 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3695
3696 if (htab->elf.dynamic_sections_created)
3697 {
3698 Elf32_External_Dyn *dyncon, *dynconend;
3699
3700 if (sdyn == NULL || htab->elf.sgot == NULL)
3701 abort ();
3702
3703 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3704 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3705 for (; dyncon < dynconend; dyncon++)
3706 {
3707 Elf_Internal_Dyn dyn;
3708 asection *s;
3709
3710 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3711
3712 switch (dyn.d_tag)
3713 {
3714 default:
3715 continue;
3716
3717 case DT_PLTGOT:
3718 s = htab->elf.sgotplt;
3719 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3720 break;
3721
3722 case DT_JMPREL:
3723 s = htab->elf.srelplt;
3724 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3725 break;
3726
3727 case DT_PLTRELSZ:
3728 dyn.d_un.d_val = htab->elf.srelplt->size;
3729 if (htab->elf.irelplt)
3730 dyn.d_un.d_val += htab->elf.irelplt->size;
3731 break;
3732 }
3733
3734 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3735 }
3736
3737 /* Fill in the special first entry in the procedure linkage table. */
3738 if (htab->elf.splt && htab->elf.splt->size > 0)
3739 {
3740 memset (htab->elf.splt->contents, 0, PLT_FIRST_ENTRY_SIZE);
3741 if (bfd_link_pic (info))
3742 {
3743 memcpy (htab->elf.splt->contents, elf_s390_plt_pic_first_entry,
3744 PLT_FIRST_ENTRY_SIZE);
3745 }
3746 else
3747 {
3748 memcpy (htab->elf.splt->contents, elf_s390_plt_first_entry,
3749 PLT_FIRST_ENTRY_SIZE);
3750 bfd_put_32 (output_bfd,
3751 htab->elf.sgotplt->output_section->vma
3752 + htab->elf.sgotplt->output_offset,
3753 htab->elf.splt->contents + 24);
3754 }
3755 elf_section_data (htab->elf.splt->output_section)
3756 ->this_hdr.sh_entsize = 4;
3757 }
3758
3759 }
3760
3761 if (htab->elf.sgotplt)
3762 {
3763 /* Fill in the first three entries in the global offset table. */
3764 if (htab->elf.sgotplt->size > 0)
3765 {
3766 bfd_put_32 (output_bfd,
3767 (sdyn == NULL ? (bfd_vma) 0
3768 : sdyn->output_section->vma + sdyn->output_offset),
3769 htab->elf.sgotplt->contents);
3770 /* One entry for shared object struct ptr. */
3771 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + 4);
3772 /* One entry for _dl_runtime_resolve. */
3773 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + 8);
3774 }
3775
3776 elf_section_data (htab->elf.sgotplt->output_section)
3777 ->this_hdr.sh_entsize = 4;
3778 }
3779 /* Finish dynamic symbol for local IFUNC symbols. */
3780 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3781 {
3782 struct plt_entry *local_plt;
3783 Elf_Internal_Sym *isym;
3784 Elf_Internal_Shdr *symtab_hdr;
3785
3786 symtab_hdr = &elf_symtab_hdr (ibfd);
3787
3788 if (!is_s390_elf (ibfd))
3789 continue;
3790
3791 local_plt = elf_s390_local_plt (ibfd);
3792 if (local_plt != NULL)
3793 for (i = 0; i < symtab_hdr->sh_info; i++)
3794 {
3795 if (local_plt[i].plt.offset != (bfd_vma) -1)
3796 {
3797 asection *sec = local_plt[i].sec;
3798 isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, i);
3799 if (isym == NULL)
3800 return FALSE;
3801
3802 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
3803 elf_s390_finish_ifunc_symbol (output_bfd, info, NULL, htab,
3804 local_plt[i].plt.offset,
3805 isym->st_value
3806 + sec->output_section->vma
3807 + sec->output_offset);
3808
3809 }
3810 }
3811 }
3812 return TRUE;
3813 }
3814 \f
3815 /* Support for core dump NOTE sections. */
3816
3817 static bfd_boolean
3818 elf_s390_grok_prstatus (bfd * abfd, Elf_Internal_Note * note)
3819 {
3820 int offset;
3821 unsigned int size;
3822
3823 switch (note->descsz)
3824 {
3825 default:
3826 return FALSE;
3827
3828 case 224: /* S/390 Linux. */
3829 /* pr_cursig */
3830 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
3831
3832 /* pr_pid */
3833 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
3834
3835 /* pr_reg */
3836 offset = 72;
3837 size = 144;
3838 break;
3839 }
3840
3841 /* Make a ".reg/999" section. */
3842 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3843 size, note->descpos + offset);
3844 }
3845
3846 static bfd_boolean
3847 elf_s390_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3848 {
3849 switch (note->descsz)
3850 {
3851 default:
3852 return FALSE;
3853
3854 case 124: /* sizeof(struct elf_prpsinfo) on s390 */
3855 elf_tdata (abfd)->core->pid
3856 = bfd_get_32 (abfd, note->descdata + 12);
3857 elf_tdata (abfd)->core->program
3858 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
3859 elf_tdata (abfd)->core->command
3860 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
3861 break;
3862 }
3863
3864 /* Note that for some reason, a spurious space is tacked
3865 onto the end of the args in some (at least one anyway)
3866 implementations, so strip it off if it exists. */
3867
3868 {
3869 char *command = elf_tdata (abfd)->core->command;
3870 int n = strlen (command);
3871
3872 if (0 < n && command[n - 1] == ' ')
3873 command[n - 1] = '\0';
3874 }
3875
3876 return TRUE;
3877 }
3878
3879 static char *
3880 elf_s390_write_core_note (bfd *abfd, char *buf, int *bufsiz,
3881 int note_type, ...)
3882 {
3883 va_list ap;
3884
3885 switch (note_type)
3886 {
3887 default:
3888 return NULL;
3889
3890 case NT_PRPSINFO:
3891 {
3892 char data[124] ATTRIBUTE_NONSTRING = { 0 };
3893 const char *fname, *psargs;
3894
3895 va_start (ap, note_type);
3896 fname = va_arg (ap, const char *);
3897 psargs = va_arg (ap, const char *);
3898 va_end (ap);
3899
3900 strncpy (data + 28, fname, 16);
3901 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
3902 DIAGNOSTIC_PUSH;
3903 /* GCC 8.0 and 8.1 warn about 80 equals destination size with
3904 -Wstringop-truncation:
3905 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643
3906 */
3907 DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION;
3908 #endif
3909 strncpy (data + 44, psargs, 80);
3910 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
3911 DIAGNOSTIC_POP;
3912 #endif
3913 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
3914 &data, sizeof (data));
3915 }
3916
3917 case NT_PRSTATUS:
3918 {
3919 char data[224] = { 0 };
3920 long pid;
3921 int cursig;
3922 const void *gregs;
3923
3924 va_start (ap, note_type);
3925 pid = va_arg (ap, long);
3926 cursig = va_arg (ap, int);
3927 gregs = va_arg (ap, const void *);
3928 va_end (ap);
3929
3930 bfd_put_16 (abfd, cursig, data + 12);
3931 bfd_put_32 (abfd, pid, data + 24);
3932 memcpy (data + 72, gregs, 144);
3933 return elfcore_write_note (abfd, buf, bufsiz, "CORE", note_type,
3934 &data, sizeof (data));
3935 }
3936 }
3937 /* NOTREACHED */
3938 }
3939 \f
3940 /* Return address for Ith PLT stub in section PLT, for relocation REL
3941 or (bfd_vma) -1 if it should not be included. */
3942
3943 static bfd_vma
3944 elf_s390_plt_sym_val (bfd_vma i, const asection *plt,
3945 const arelent *rel ATTRIBUTE_UNUSED)
3946 {
3947 return plt->vma + PLT_FIRST_ENTRY_SIZE + i * PLT_ENTRY_SIZE;
3948 }
3949
3950 /* Merge backend specific data from an object file to the output
3951 object file when linking. */
3952
3953 static bfd_boolean
3954 elf32_s390_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
3955 {
3956 bfd *obfd = info->output_bfd;
3957
3958 if (!is_s390_elf (ibfd) || !is_s390_elf (obfd))
3959 return TRUE;
3960
3961 if (!elf_s390_merge_obj_attributes (ibfd, info))
3962 return FALSE;
3963
3964 elf_elfheader (obfd)->e_flags |= elf_elfheader (ibfd)->e_flags;
3965 return TRUE;
3966 }
3967
3968
3969 #define TARGET_BIG_SYM s390_elf32_vec
3970 #define TARGET_BIG_NAME "elf32-s390"
3971 #define ELF_ARCH bfd_arch_s390
3972 #define ELF_TARGET_ID S390_ELF_DATA
3973 #define ELF_MACHINE_CODE EM_S390
3974 #define ELF_MACHINE_ALT1 EM_S390_OLD
3975 #define ELF_MAXPAGESIZE 0x1000
3976
3977 #define elf_backend_can_gc_sections 1
3978 #define elf_backend_can_refcount 1
3979 #define elf_backend_want_got_plt 1
3980 #define elf_backend_plt_readonly 1
3981 #define elf_backend_want_plt_sym 0
3982 #define elf_backend_got_header_size 12
3983 #define elf_backend_want_dynrelro 1
3984 #define elf_backend_rela_normal 1
3985
3986 #define elf_info_to_howto elf_s390_info_to_howto
3987
3988 #define bfd_elf32_bfd_is_local_label_name elf_s390_is_local_label_name
3989 #define bfd_elf32_bfd_link_hash_table_create elf_s390_link_hash_table_create
3990 #define bfd_elf32_bfd_reloc_type_lookup elf_s390_reloc_type_lookup
3991 #define bfd_elf32_bfd_reloc_name_lookup elf_s390_reloc_name_lookup
3992
3993 #define bfd_elf32_bfd_merge_private_bfd_data elf32_s390_merge_private_bfd_data
3994
3995 #define elf_backend_adjust_dynamic_symbol elf_s390_adjust_dynamic_symbol
3996 #define elf_backend_check_relocs elf_s390_check_relocs
3997 #define elf_backend_copy_indirect_symbol elf_s390_copy_indirect_symbol
3998 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
3999 #define elf_backend_finish_dynamic_sections elf_s390_finish_dynamic_sections
4000 #define elf_backend_finish_dynamic_symbol elf_s390_finish_dynamic_symbol
4001 #define elf_backend_gc_mark_hook elf_s390_gc_mark_hook
4002 #define elf_backend_reloc_type_class elf_s390_reloc_type_class
4003 #define elf_backend_relocate_section elf_s390_relocate_section
4004 #define elf_backend_size_dynamic_sections elf_s390_size_dynamic_sections
4005 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
4006 #define elf_backend_grok_prstatus elf_s390_grok_prstatus
4007 #define elf_backend_grok_psinfo elf_s390_grok_psinfo
4008 #define elf_backend_write_core_note elf_s390_write_core_note
4009 #define elf_backend_plt_sym_val elf_s390_plt_sym_val
4010 #define elf_backend_sort_relocs_p elf_s390_elf_sort_relocs_p
4011
4012 #define bfd_elf32_mkobject elf_s390_mkobject
4013 #define elf_backend_object_p elf_s390_object_p
4014
4015 #define elf_backend_linux_prpsinfo32_ugid16 TRUE
4016
4017 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.112082 seconds and 3 git commands to generate.