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