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