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