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