projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Remove trailing white spaces in bfd
[deliverable/binutils-gdb.git] / bfd / 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_malloc (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 ret->elf.sgot = NULL;
802 ret->elf.sgotplt = NULL;
803 ret->elf.srelgot = NULL;
804 ret->elf.splt = NULL;
805 ret->elf.srelplt = NULL;
806 ret->sdynbss = NULL;
807 ret->srelbss = NULL;
808 ret->tls_ldm_got.refcount = 0;
809 ret->sym_cache.abfd = NULL;
810
811 return &ret->elf.root;
812 }
813
814 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
815 shortcuts to them in our hash table. */
816
817 static bfd_boolean
818 create_got_section (bfd *dynobj, struct bfd_link_info *info)
819 {
820 struct elf_s390_link_hash_table *htab;
821
822 if (! _bfd_elf_create_got_section (dynobj, info))
823 return FALSE;
824
825 htab = elf_s390_hash_table (info);
826 htab->elf.sgot = bfd_get_linker_section (dynobj, ".got");
827 htab->elf.sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
828 htab->elf.srelgot = bfd_get_linker_section (dynobj, ".rela.got");
829 if (!htab->elf.sgot || !htab->elf.sgotplt || !htab->elf.srelgot)
830 abort ();
831
832 return TRUE;
833 }
834
835 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
836 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
837 hash table. */
838
839 static bfd_boolean
840 elf_s390_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
841 {
842 struct elf_s390_link_hash_table *htab;
843
844 htab = elf_s390_hash_table (info);
845 if (!htab->elf.sgot && !create_got_section (dynobj, info))
846 return FALSE;
847
848 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
849 return FALSE;
850
851 htab->elf.splt = bfd_get_linker_section (dynobj, ".plt");
852 htab->elf.srelplt = bfd_get_linker_section (dynobj, ".rela.plt");
853 htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
854 if (!info->shared)
855 htab->srelbss = bfd_get_linker_section (dynobj, ".rela.bss");
856
857 if (!htab->elf.splt || !htab->elf.srelplt || !htab->sdynbss
858 || (!info->shared && !htab->srelbss))
859 abort ();
860
861 return TRUE;
862 }
863
864 /* Copy the extra info we tack onto an elf_link_hash_entry. */
865
866 static void
867 elf_s390_copy_indirect_symbol (struct bfd_link_info *info,
868 struct elf_link_hash_entry *dir,
869 struct elf_link_hash_entry *ind)
870 {
871 struct elf_s390_link_hash_entry *edir, *eind;
872
873 edir = (struct elf_s390_link_hash_entry *) dir;
874 eind = (struct elf_s390_link_hash_entry *) ind;
875
876 if (eind->dyn_relocs != NULL)
877 {
878 if (edir->dyn_relocs != NULL)
879 {
880 struct elf_dyn_relocs **pp;
881 struct elf_dyn_relocs *p;
882
883 /* Add reloc counts against the indirect sym to the direct sym
884 list. Merge any entries against the same section. */
885 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
886 {
887 struct elf_dyn_relocs *q;
888
889 for (q = edir->dyn_relocs; q != NULL; q = q->next)
890 if (q->sec == p->sec)
891 {
892 q->pc_count += p->pc_count;
893 q->count += p->count;
894 *pp = p->next;
895 break;
896 }
897 if (q == NULL)
898 pp = &p->next;
899 }
900 *pp = edir->dyn_relocs;
901 }
902
903 edir->dyn_relocs = eind->dyn_relocs;
904 eind->dyn_relocs = NULL;
905 }
906
907 if (ind->root.type == bfd_link_hash_indirect
908 && dir->got.refcount <= 0)
909 {
910 edir->tls_type = eind->tls_type;
911 eind->tls_type = GOT_UNKNOWN;
912 }
913
914 if (ELIMINATE_COPY_RELOCS
915 && ind->root.type != bfd_link_hash_indirect
916 && dir->dynamic_adjusted)
917 {
918 /* If called to transfer flags for a weakdef during processing
919 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
920 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
921 dir->ref_dynamic |= ind->ref_dynamic;
922 dir->ref_regular |= ind->ref_regular;
923 dir->ref_regular_nonweak |= ind->ref_regular_nonweak;
924 dir->needs_plt |= ind->needs_plt;
925 }
926 else
927 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
928 }
929
930 static int
931 elf_s390_tls_transition (struct bfd_link_info *info,
932 int r_type,
933 int is_local)
934 {
935 if (info->shared)
936 return r_type;
937
938 switch (r_type)
939 {
940 case R_390_TLS_GD32:
941 case R_390_TLS_IE32:
942 if (is_local)
943 return R_390_TLS_LE32;
944 return R_390_TLS_IE32;
945 case R_390_TLS_GOTIE32:
946 if (is_local)
947 return R_390_TLS_LE32;
948 return R_390_TLS_GOTIE32;
949 case R_390_TLS_LDM32:
950 return R_390_TLS_LE32;
951 }
952
953 return r_type;
954 }
955
956 /* Look through the relocs for a section during the first phase, and
957 allocate space in the global offset table or procedure linkage
958 table. */
959
960 static bfd_boolean
961 elf_s390_check_relocs (bfd *abfd,
962 struct bfd_link_info *info,
963 asection *sec,
964 const Elf_Internal_Rela *relocs)
965 {
966 struct elf_s390_link_hash_table *htab;
967 Elf_Internal_Shdr *symtab_hdr;
968 struct elf_link_hash_entry **sym_hashes;
969 const Elf_Internal_Rela *rel;
970 const Elf_Internal_Rela *rel_end;
971 asection *sreloc;
972 bfd_signed_vma *local_got_refcounts;
973 int tls_type, old_tls_type;
974 Elf_Internal_Sym *isym;
975
976 if (info->relocatable)
977 return TRUE;
978
979 BFD_ASSERT (is_s390_elf (abfd));
980
981 htab = elf_s390_hash_table (info);
982 symtab_hdr = &elf_symtab_hdr (abfd);
983 sym_hashes = elf_sym_hashes (abfd);
984 local_got_refcounts = elf_local_got_refcounts (abfd);
985
986 sreloc = NULL;
987
988 rel_end = relocs + sec->reloc_count;
989 for (rel = relocs; rel < rel_end; rel++)
990 {
991 unsigned int r_type;
992 unsigned long r_symndx;
993 struct elf_link_hash_entry *h;
994
995 r_symndx = ELF32_R_SYM (rel->r_info);
996
997 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
998 {
999 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
1000 abfd, r_symndx);
1001 return FALSE;
1002 }
1003
1004 if (r_symndx < symtab_hdr->sh_info)
1005 {
1006 /* A local symbol. */
1007 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1008 abfd, r_symndx);
1009 if (isym == NULL)
1010 return FALSE;
1011
1012 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1013 {
1014 struct plt_entry *plt;
1015
1016 if (htab->elf.dynobj == NULL)
1017 htab->elf.dynobj = abfd;
1018
1019 if (!s390_elf_create_ifunc_sections (htab->elf.dynobj, info))
1020 return FALSE;
1021
1022 if (local_got_refcounts == NULL)
1023 {
1024 if (!elf_s390_allocate_local_syminfo (abfd, symtab_hdr))
1025 return FALSE;
1026 local_got_refcounts = elf_local_got_refcounts (abfd);
1027 }
1028 plt = elf_s390_local_plt (abfd);
1029 plt[r_symndx].plt.refcount++;
1030 }
1031 h = NULL;
1032 }
1033 else
1034 {
1035 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1036 while (h->root.type == bfd_link_hash_indirect
1037 || h->root.type == bfd_link_hash_warning)
1038 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1039 }
1040
1041 /* Create got section and local_got_refcounts array if they
1042 are needed. */
1043 r_type = elf_s390_tls_transition (info,
1044 ELF32_R_TYPE (rel->r_info),
1045 h == NULL);
1046 switch (r_type)
1047 {
1048 case R_390_GOT12:
1049 case R_390_GOT16:
1050 case R_390_GOT20:
1051 case R_390_GOT32:
1052 case R_390_GOTENT:
1053 case R_390_GOTPLT12:
1054 case R_390_GOTPLT16:
1055 case R_390_GOTPLT20:
1056 case R_390_GOTPLT32:
1057 case R_390_GOTPLTENT:
1058 case R_390_TLS_GD32:
1059 case R_390_TLS_GOTIE12:
1060 case R_390_TLS_GOTIE20:
1061 case R_390_TLS_GOTIE32:
1062 case R_390_TLS_IEENT:
1063 case R_390_TLS_IE32:
1064 case R_390_TLS_LDM32:
1065 if (h == NULL
1066 && local_got_refcounts == NULL)
1067 {
1068 if (!elf_s390_allocate_local_syminfo (abfd, symtab_hdr))
1069 return FALSE;
1070 local_got_refcounts = elf_local_got_refcounts (abfd);
1071 }
1072 /* Fall through. */
1073 case R_390_GOTOFF16:
1074 case R_390_GOTOFF32:
1075 case R_390_GOTPC:
1076 case R_390_GOTPCDBL:
1077 if (htab->elf.sgot == NULL)
1078 {
1079 if (htab->elf.dynobj == NULL)
1080 htab->elf.dynobj = abfd;
1081 if (!create_got_section (htab->elf.dynobj, info))
1082 return FALSE;
1083 }
1084 }
1085
1086 if (h != NULL)
1087 {
1088 if (htab->elf.dynobj == NULL)
1089 htab->elf.dynobj = abfd;
1090 if (!s390_elf_create_ifunc_sections (htab->elf.dynobj, info))
1091 return FALSE;
1092
1093 /* Make sure an IFUNC symbol defined in a non-shared object
1094 always gets a PLT slot. */
1095 if (s390_is_ifunc_symbol_p (h) && h->def_regular)
1096 {
1097 /* The symbol is called by the dynamic loader in order
1098 to resolve the relocation. So it is in fact also
1099 referenced. */
1100 h->ref_regular = 1;
1101 h->needs_plt = 1;
1102 }
1103 }
1104 switch (r_type)
1105 {
1106 case R_390_GOTOFF16:
1107 case R_390_GOTOFF32:
1108 case R_390_GOTPC:
1109 case R_390_GOTPCDBL:
1110 /* These relocs do not need a GOT slot. They just load the
1111 GOT pointer itself or address something else relative to
1112 the GOT. Since the GOT pointer has been set up above we
1113 are done. */
1114 break;
1115
1116 case R_390_PLT16DBL:
1117 case R_390_PLT32DBL:
1118 case R_390_PLT32:
1119 case R_390_PLTOFF16:
1120 case R_390_PLTOFF32:
1121 /* This symbol requires a procedure linkage table entry. We
1122 actually build the entry in adjust_dynamic_symbol,
1123 because this might be a case of linking PIC code which is
1124 never referenced by a dynamic object, in which case we
1125 don't need to generate a procedure linkage table entry
1126 after all. */
1127
1128 /* If this is a local symbol, we resolve it directly without
1129 creating a procedure linkage table entry. */
1130 if (h != NULL)
1131 {
1132 h->needs_plt = 1;
1133 h->plt.refcount += 1;
1134 }
1135 break;
1136
1137 case R_390_GOTPLT12:
1138 case R_390_GOTPLT16:
1139 case R_390_GOTPLT20:
1140 case R_390_GOTPLT32:
1141 case R_390_GOTPLTENT:
1142 /* This symbol requires either a procedure linkage table entry
1143 or an entry in the local got. We actually build the entry
1144 in adjust_dynamic_symbol because whether this is really a
1145 global reference can change and with it the fact if we have
1146 to create a plt entry or a local got entry. To be able to
1147 make a once global symbol a local one we have to keep track
1148 of the number of gotplt references that exist for this
1149 symbol. */
1150 if (h != NULL)
1151 {
1152 ((struct elf_s390_link_hash_entry *) h)->gotplt_refcount++;
1153 h->needs_plt = 1;
1154 h->plt.refcount += 1;
1155 }
1156 else
1157 local_got_refcounts[r_symndx] += 1;
1158 break;
1159
1160 case R_390_TLS_LDM32:
1161 htab->tls_ldm_got.refcount += 1;
1162 break;
1163
1164 case R_390_TLS_IE32:
1165 case R_390_TLS_GOTIE12:
1166 case R_390_TLS_GOTIE20:
1167 case R_390_TLS_GOTIE32:
1168 case R_390_TLS_IEENT:
1169 if (info->shared)
1170 info->flags |= DF_STATIC_TLS;
1171 /* Fall through. */
1172
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 case R_390_TLS_GD32:
1179 /* This symbol requires a global offset table entry. */
1180 switch (r_type)
1181 {
1182 default:
1183 case R_390_GOT12:
1184 case R_390_GOT16:
1185 case R_390_GOT20:
1186 case R_390_GOT32:
1187 case R_390_GOTENT:
1188 tls_type = GOT_NORMAL;
1189 break;
1190 case R_390_TLS_GD32:
1191 tls_type = GOT_TLS_GD;
1192 break;
1193 case R_390_TLS_IE32:
1194 case R_390_TLS_GOTIE32:
1195 tls_type = GOT_TLS_IE;
1196 break;
1197 case R_390_TLS_GOTIE12:
1198 case R_390_TLS_GOTIE20:
1199 case R_390_TLS_IEENT:
1200 tls_type = GOT_TLS_IE_NLT;
1201 break;
1202 }
1203
1204 if (h != NULL)
1205 {
1206 h->got.refcount += 1;
1207 old_tls_type = elf_s390_hash_entry(h)->tls_type;
1208 }
1209 else
1210 {
1211 local_got_refcounts[r_symndx] += 1;
1212 old_tls_type = elf_s390_local_got_tls_type (abfd) [r_symndx];
1213 }
1214 /* If a TLS symbol is accessed using IE at least once,
1215 there is no point to use dynamic model for it. */
1216 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN)
1217 {
1218 if (old_tls_type == GOT_NORMAL || tls_type == GOT_NORMAL)
1219 {
1220 (*_bfd_error_handler)
1221 (_("%B: `%s' accessed both as normal and thread local symbol"),
1222 abfd, h->root.root.string);
1223 return FALSE;
1224 }
1225 if (old_tls_type > tls_type)
1226 tls_type = old_tls_type;
1227 }
1228
1229 if (old_tls_type != tls_type)
1230 {
1231 if (h != NULL)
1232 elf_s390_hash_entry (h)->tls_type = tls_type;
1233 else
1234 elf_s390_local_got_tls_type (abfd) [r_symndx] = tls_type;
1235 }
1236
1237 if (r_type != R_390_TLS_IE32)
1238 break;
1239 /* Fall through. */
1240
1241 case R_390_TLS_LE32:
1242 if (!info->shared)
1243 break;
1244 info->flags |= DF_STATIC_TLS;
1245 /* Fall through. */
1246
1247 case R_390_8:
1248 case R_390_16:
1249 case R_390_32:
1250 case R_390_PC16:
1251 case R_390_PC16DBL:
1252 case R_390_PC32DBL:
1253 case R_390_PC32:
1254 if (h != NULL)
1255 {
1256 /* If this reloc is in a read-only section, we might
1257 need a copy reloc. We can't check reliably at this
1258 stage whether the section is read-only, as input
1259 sections have not yet been mapped to output sections.
1260 Tentatively set the flag for now, and correct in
1261 adjust_dynamic_symbol. */
1262 h->non_got_ref = 1;
1263
1264 if (!info->shared)
1265 {
1266 /* We may need a .plt entry if the function this reloc
1267 refers to is in a shared lib. */
1268 h->plt.refcount += 1;
1269 }
1270 }
1271
1272 /* If we are creating a shared library, and this is a reloc
1273 against a global symbol, or a non PC relative reloc
1274 against a local symbol, then we need to copy the reloc
1275 into the shared library. However, if we are linking with
1276 -Bsymbolic, we do not need to copy a reloc against a
1277 global symbol which is defined in an object we are
1278 including in the link (i.e., DEF_REGULAR is set). At
1279 this point we have not seen all the input files, so it is
1280 possible that DEF_REGULAR is not set now but will be set
1281 later (it is never cleared). In case of a weak definition,
1282 DEF_REGULAR may be cleared later by a strong definition in
1283 a shared library. We account for that possibility below by
1284 storing information in the relocs_copied field of the hash
1285 table entry. A similar situation occurs when creating
1286 shared libraries and symbol visibility changes render the
1287 symbol local.
1288
1289 If on the other hand, we are creating an executable, we
1290 may need to keep relocations for symbols satisfied by a
1291 dynamic library if we manage to avoid copy relocs for the
1292 symbol. */
1293 if ((info->shared
1294 && (sec->flags & SEC_ALLOC) != 0
1295 && ((ELF32_R_TYPE (rel->r_info) != R_390_PC16
1296 && ELF32_R_TYPE (rel->r_info) != R_390_PC16DBL
1297 && ELF32_R_TYPE (rel->r_info) != R_390_PC32DBL
1298 && ELF32_R_TYPE (rel->r_info) != R_390_PC32)
1299 || (h != NULL
1300 && (! SYMBOLIC_BIND (info, h)
1301 || h->root.type == bfd_link_hash_defweak
1302 || !h->def_regular))))
1303 || (ELIMINATE_COPY_RELOCS
1304 && !info->shared
1305 && (sec->flags & SEC_ALLOC) != 0
1306 && h != NULL
1307 && (h->root.type == bfd_link_hash_defweak
1308 || !h->def_regular)))
1309 {
1310 struct elf_dyn_relocs *p;
1311 struct elf_dyn_relocs **head;
1312
1313 /* We must copy these reloc types into the output file.
1314 Create a reloc section in dynobj and make room for
1315 this reloc. */
1316 if (sreloc == NULL)
1317 {
1318 if (htab->elf.dynobj == NULL)
1319 htab->elf.dynobj = abfd;
1320
1321 sreloc = _bfd_elf_make_dynamic_reloc_section
1322 (sec, htab->elf.dynobj, 2, abfd, /*rela?*/ TRUE);
1323
1324 if (sreloc == NULL)
1325 return FALSE;
1326 }
1327
1328 /* If this is a global symbol, we count the number of
1329 relocations we need for this symbol. */
1330 if (h != NULL)
1331 {
1332 head = &((struct elf_s390_link_hash_entry *) h)->dyn_relocs;
1333 }
1334 else
1335 {
1336 /* Track dynamic relocs needed for local syms too.
1337 We really need local syms available to do this
1338 easily. Oh well. */
1339 asection *s;
1340 void *vpp;
1341
1342 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1343 abfd, r_symndx);
1344 if (isym == NULL)
1345 return FALSE;
1346
1347 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
1348 if (s == NULL)
1349 s = sec;
1350
1351 vpp = &elf_section_data (s)->local_dynrel;
1352 head = (struct elf_dyn_relocs **) vpp;
1353 }
1354
1355 p = *head;
1356 if (p == NULL || p->sec != sec)
1357 {
1358 bfd_size_type amt = sizeof *p;
1359
1360 p = ((struct elf_dyn_relocs *)
1361 bfd_alloc (htab->elf.dynobj, amt));
1362 if (p == NULL)
1363 return FALSE;
1364 p->next = *head;
1365 *head = p;
1366 p->sec = sec;
1367 p->count = 0;
1368 p->pc_count = 0;
1369 }
1370
1371 p->count += 1;
1372 if (ELF32_R_TYPE (rel->r_info) == R_390_PC16
1373 || ELF32_R_TYPE (rel->r_info) == R_390_PC16DBL
1374 || ELF32_R_TYPE (rel->r_info) == R_390_PC32DBL
1375 || ELF32_R_TYPE (rel->r_info) == R_390_PC32)
1376 p->pc_count += 1;
1377 }
1378 break;
1379
1380 /* This relocation describes the C++ object vtable hierarchy.
1381 Reconstruct it for later use during GC. */
1382 case R_390_GNU_VTINHERIT:
1383 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1384 return FALSE;
1385 break;
1386
1387 /* This relocation describes which C++ vtable entries are actually
1388 used. Record for later use during GC. */
1389 case R_390_GNU_VTENTRY:
1390 BFD_ASSERT (h != NULL);
1391 if (h != NULL
1392 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1393 return FALSE;
1394 break;
1395
1396 default:
1397 break;
1398 }
1399 }
1400
1401 return TRUE;
1402 }
1403
1404 /* Return the section that should be marked against GC for a given
1405 relocation. */
1406
1407 static asection *
1408 elf_s390_gc_mark_hook (asection *sec,
1409 struct bfd_link_info *info,
1410 Elf_Internal_Rela *rel,
1411 struct elf_link_hash_entry *h,
1412 Elf_Internal_Sym *sym)
1413 {
1414 if (h != NULL)
1415 switch (ELF32_R_TYPE (rel->r_info))
1416 {
1417 case R_390_GNU_VTINHERIT:
1418 case R_390_GNU_VTENTRY:
1419 return NULL;
1420 }
1421 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1422
1423 }
1424
1425 /* Update the got entry reference counts for the section being removed. */
1426
1427 static bfd_boolean
1428 elf_s390_gc_sweep_hook (bfd *abfd,
1429 struct bfd_link_info *info,
1430 asection *sec,
1431 const Elf_Internal_Rela *relocs)
1432 {
1433 struct elf_s390_link_hash_table *htab;
1434 Elf_Internal_Shdr *symtab_hdr;
1435 struct elf_link_hash_entry **sym_hashes;
1436 bfd_signed_vma *local_got_refcounts;
1437 const Elf_Internal_Rela *rel, *relend;
1438
1439 if (info->relocatable)
1440 return TRUE;
1441
1442 htab = elf_s390_hash_table (info);
1443 if (htab == NULL)
1444 return FALSE;
1445
1446 elf_section_data (sec)->local_dynrel = NULL;
1447
1448 symtab_hdr = &elf_symtab_hdr (abfd);
1449 sym_hashes = elf_sym_hashes (abfd);
1450 local_got_refcounts = elf_local_got_refcounts (abfd);
1451
1452 relend = relocs + sec->reloc_count;
1453 for (rel = relocs; rel < relend; rel++)
1454 {
1455 unsigned long r_symndx;
1456 unsigned int r_type;
1457 struct elf_link_hash_entry *h = NULL;
1458
1459 r_symndx = ELF32_R_SYM (rel->r_info);
1460 if (r_symndx >= symtab_hdr->sh_info)
1461 {
1462 struct elf_s390_link_hash_entry *eh;
1463 struct elf_dyn_relocs **pp;
1464 struct elf_dyn_relocs *p;
1465
1466 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1467 while (h->root.type == bfd_link_hash_indirect
1468 || h->root.type == bfd_link_hash_warning)
1469 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1470 eh = (struct elf_s390_link_hash_entry *) h;
1471
1472 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1473 if (p->sec == sec)
1474 {
1475 /* Everything must go for SEC. */
1476 *pp = p->next;
1477 break;
1478 }
1479 }
1480 else
1481 {
1482 Elf_Internal_Sym *isym;
1483
1484 /* A local symbol. */
1485 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1486 abfd, r_symndx);
1487 if (isym == NULL)
1488 return FALSE;
1489
1490 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
1491 {
1492 struct plt_entry *plt = elf_s390_local_plt (abfd);
1493 if (plt[r_symndx].plt.refcount > 0)
1494 plt[r_symndx].plt.refcount--;
1495 }
1496 }
1497
1498 r_type = ELF32_R_TYPE (rel->r_info);
1499 r_type = elf_s390_tls_transition (info, r_type, h != NULL);
1500 switch (r_type)
1501 {
1502 case R_390_TLS_LDM32:
1503 if (elf_s390_hash_table (info)->tls_ldm_got.refcount > 0)
1504 elf_s390_hash_table (info)->tls_ldm_got.refcount -= 1;
1505 break;
1506
1507 case R_390_TLS_GD32:
1508 case R_390_TLS_IE32:
1509 case R_390_TLS_GOTIE12:
1510 case R_390_TLS_GOTIE20:
1511 case R_390_TLS_GOTIE32:
1512 case R_390_TLS_IEENT:
1513 case R_390_GOT12:
1514 case R_390_GOT16:
1515 case R_390_GOT20:
1516 case R_390_GOT32:
1517 case R_390_GOTOFF16:
1518 case R_390_GOTOFF32:
1519 case R_390_GOTPC:
1520 case R_390_GOTPCDBL:
1521 case R_390_GOTENT:
1522 if (h != NULL)
1523 {
1524 if (h->got.refcount > 0)
1525 h->got.refcount -= 1;
1526 }
1527 else if (local_got_refcounts != NULL)
1528 {
1529 if (local_got_refcounts[r_symndx] > 0)
1530 local_got_refcounts[r_symndx] -= 1;
1531 }
1532 break;
1533
1534 case R_390_8:
1535 case R_390_12:
1536 case R_390_16:
1537 case R_390_20:
1538 case R_390_32:
1539 case R_390_PC16:
1540 case R_390_PC16DBL:
1541 case R_390_PC32DBL:
1542 case R_390_PC32:
1543 if (info->shared)
1544 break;
1545 /* Fall through. */
1546
1547 case R_390_PLT16DBL:
1548 case R_390_PLT32DBL:
1549 case R_390_PLT32:
1550 case R_390_PLTOFF16:
1551 case R_390_PLTOFF32:
1552 if (h != NULL)
1553 {
1554 if (h->plt.refcount > 0)
1555 h->plt.refcount -= 1;
1556 }
1557 break;
1558
1559 case R_390_GOTPLT12:
1560 case R_390_GOTPLT16:
1561 case R_390_GOTPLT20:
1562 case R_390_GOTPLT32:
1563 case R_390_GOTPLTENT:
1564 if (h != NULL)
1565 {
1566 if (h->plt.refcount > 0)
1567 {
1568 ((struct elf_s390_link_hash_entry *) h)->gotplt_refcount--;
1569 h->plt.refcount -= 1;
1570 }
1571 }
1572 else if (local_got_refcounts != NULL)
1573 {
1574 if (local_got_refcounts[r_symndx] > 0)
1575 local_got_refcounts[r_symndx] -= 1;
1576 }
1577 break;
1578
1579 default:
1580 break;
1581 }
1582 }
1583
1584 return TRUE;
1585 }
1586
1587 /* Make sure we emit a GOT entry if the symbol was supposed to have a PLT
1588 entry but we found we will not create any. Called when we find we will
1589 not have any PLT for this symbol, by for example
1590 elf_s390_adjust_dynamic_symbol when we're doing a proper dynamic link,
1591 or elf_s390_size_dynamic_sections if no dynamic sections will be
1592 created (we're only linking static objects). */
1593
1594 static void
1595 elf_s390_adjust_gotplt (struct elf_s390_link_hash_entry *h)
1596 {
1597 if (h->elf.root.type == bfd_link_hash_warning)
1598 h = (struct elf_s390_link_hash_entry *) h->elf.root.u.i.link;
1599
1600 if (h->gotplt_refcount <= 0)
1601 return;
1602
1603 /* We simply add the number of gotplt references to the number
1604 * of got references for this symbol. */
1605 h->elf.got.refcount += h->gotplt_refcount;
1606 h->gotplt_refcount = -1;
1607 }
1608
1609 /* Adjust a symbol defined by a dynamic object and referenced by a
1610 regular object. The current definition is in some section of the
1611 dynamic object, but we're not including those sections. We have to
1612 change the definition to something the rest of the link can
1613 understand. */
1614
1615 static bfd_boolean
1616 elf_s390_adjust_dynamic_symbol (struct bfd_link_info *info,
1617 struct elf_link_hash_entry *h)
1618 {
1619 struct elf_s390_link_hash_table *htab;
1620 asection *s;
1621
1622 /* STT_GNU_IFUNC symbol must go through PLT. */
1623 if (s390_is_ifunc_symbol_p (h))
1624 return TRUE;
1625
1626 /* If this is a function, put it in the procedure linkage table. We
1627 will fill in the contents of the procedure linkage table later
1628 (although we could actually do it here). */
1629 if (h->type == STT_FUNC
1630 || h->needs_plt)
1631 {
1632 if (h->plt.refcount <= 0
1633 || SYMBOL_CALLS_LOCAL (info, h)
1634 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1635 && h->root.type != bfd_link_hash_undefweak))
1636 {
1637 /* This case can occur if we saw a PLT32 reloc in an input
1638 file, but the symbol was never referred to by a dynamic
1639 object, or if all references were garbage collected. In
1640 such a case, we don't actually need to build a procedure
1641 linkage table, and we can just do a PC32 reloc instead. */
1642 h->plt.offset = (bfd_vma) -1;
1643 h->needs_plt = 0;
1644 elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1645 }
1646
1647 return TRUE;
1648 }
1649 else
1650 /* It's possible that we incorrectly decided a .plt reloc was
1651 needed for an R_390_PC32 reloc to a non-function sym in
1652 check_relocs. We can't decide accurately between function and
1653 non-function syms in check-relocs; Objects loaded later in
1654 the link may change h->type. So fix it now. */
1655 h->plt.offset = (bfd_vma) -1;
1656
1657 /* If this is a weak symbol, and there is a real definition, the
1658 processor independent code will have arranged for us to see the
1659 real definition first, and we can just use the same value. */
1660 if (h->u.weakdef != NULL)
1661 {
1662 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1663 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1664 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1665 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1666 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
1667 h->non_got_ref = h->u.weakdef->non_got_ref;
1668 return TRUE;
1669 }
1670
1671 /* This is a reference to a symbol defined by a dynamic object which
1672 is not a function. */
1673
1674 /* If we are creating a shared library, we must presume that the
1675 only references to the symbol are via the global offset table.
1676 For such cases we need not do anything here; the relocations will
1677 be handled correctly by relocate_section. */
1678 if (info->shared)
1679 return TRUE;
1680
1681 /* If there are no references to this symbol that do not use the
1682 GOT, we don't need to generate a copy reloc. */
1683 if (!h->non_got_ref)
1684 return TRUE;
1685
1686 /* If -z nocopyreloc was given, we won't generate them either. */
1687 if (info->nocopyreloc)
1688 {
1689 h->non_got_ref = 0;
1690 return TRUE;
1691 }
1692
1693 if (ELIMINATE_COPY_RELOCS)
1694 {
1695 struct elf_s390_link_hash_entry * eh;
1696 struct elf_dyn_relocs *p;
1697
1698 eh = (struct elf_s390_link_hash_entry *) h;
1699 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1700 {
1701 s = p->sec->output_section;
1702 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1703 break;
1704 }
1705
1706 /* If we didn't find any dynamic relocs in read-only sections, then
1707 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1708 if (p == NULL)
1709 {
1710 h->non_got_ref = 0;
1711 return TRUE;
1712 }
1713 }
1714
1715 /* We must allocate the symbol in our .dynbss section, which will
1716 become part of the .bss section of the executable. There will be
1717 an entry for this symbol in the .dynsym section. The dynamic
1718 object will contain position independent code, so all references
1719 from the dynamic object to this symbol will go through the global
1720 offset table. The dynamic linker will use the .dynsym entry to
1721 determine the address it must put in the global offset table, so
1722 both the dynamic object and the regular object will refer to the
1723 same memory location for the variable. */
1724
1725 htab = elf_s390_hash_table (info);
1726
1727 /* We must generate a R_390_COPY reloc to tell the dynamic linker to
1728 copy the initial value out of the dynamic object and into the
1729 runtime process image. */
1730 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1731 {
1732 htab->srelbss->size += sizeof (Elf32_External_Rela);
1733 h->needs_copy = 1;
1734 }
1735
1736 s = htab->sdynbss;
1737
1738 return _bfd_elf_adjust_dynamic_copy (h, s);
1739 }
1740
1741 /* Allocate space in .plt, .got and associated reloc sections for
1742 dynamic relocs. */
1743
1744 static bfd_boolean
1745 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1746 {
1747 struct bfd_link_info *info;
1748 struct elf_s390_link_hash_table *htab;
1749 struct elf_s390_link_hash_entry *eh = (struct elf_s390_link_hash_entry *)h;
1750 struct elf_dyn_relocs *p;
1751
1752 if (h->root.type == bfd_link_hash_indirect)
1753 return TRUE;
1754
1755 info = (struct bfd_link_info *) inf;
1756 htab = elf_s390_hash_table (info);
1757
1758 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
1759 here if it is defined and referenced in a non-shared object. */
1760 if (s390_is_ifunc_symbol_p (h) && h->def_regular)
1761 return s390_elf_allocate_ifunc_dyn_relocs (info, h,
1762 &eh->dyn_relocs);
1763 else if (htab->elf.dynamic_sections_created
1764 && h->plt.refcount > 0)
1765 {
1766 /* Make sure this symbol is output as a dynamic symbol.
1767 Undefined weak syms won't yet be marked as dynamic. */
1768 if (h->dynindx == -1
1769 && !h->forced_local)
1770 {
1771 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1772 return FALSE;
1773 }
1774
1775 if (info->shared
1776 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
1777 {
1778 asection *s = htab->elf.splt;
1779
1780 /* If this is the first .plt entry, make room for the special
1781 first entry. */
1782 if (s->size == 0)
1783 s->size += PLT_FIRST_ENTRY_SIZE;
1784
1785 h->plt.offset = s->size;
1786
1787 /* If this symbol is not defined in a regular file, and we are
1788 not generating a shared library, then set the symbol to this
1789 location in the .plt. This is required to make function
1790 pointers compare as equal between the normal executable and
1791 the shared library. */
1792 if (! info->shared
1793 && !h->def_regular)
1794 {
1795 h->root.u.def.section = s;
1796 h->root.u.def.value = h->plt.offset;
1797 }
1798
1799 /* Make room for this entry. */
1800 s->size += PLT_ENTRY_SIZE;
1801
1802 /* We also need to make an entry in the .got.plt section, which
1803 will be placed in the .got section by the linker script. */
1804 htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
1805
1806 /* We also need to make an entry in the .rela.plt section. */
1807 htab->elf.srelplt->size += sizeof (Elf32_External_Rela);
1808 }
1809 else
1810 {
1811 h->plt.offset = (bfd_vma) -1;
1812 h->needs_plt = 0;
1813 elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1814 }
1815 }
1816 else
1817 {
1818 h->plt.offset = (bfd_vma) -1;
1819 h->needs_plt = 0;
1820 elf_s390_adjust_gotplt((struct elf_s390_link_hash_entry *) h);
1821 }
1822
1823 /* If R_390_TLS_{IE32,GOTIE32,GOTIE12,IEENT} symbol is now local to
1824 the binary, we can optimize a bit. IE32 and GOTIE32 get converted
1825 to R_390_TLS_LE32 requiring no TLS entry. For GOTIE12 and IEENT
1826 we can save the dynamic TLS relocation. */
1827 if (h->got.refcount > 0
1828 && !info->shared
1829 && h->dynindx == -1
1830 && elf_s390_hash_entry(h)->tls_type >= GOT_TLS_IE)
1831 {
1832 if (elf_s390_hash_entry(h)->tls_type == GOT_TLS_IE_NLT)
1833 /* For the GOTIE access without a literal pool entry the offset has
1834 to be stored somewhere. The immediate value in the instruction
1835 is not bit enough so the value is stored in the got. */
1836 {
1837 h->got.offset = htab->elf.sgot->size;
1838 htab->elf.sgot->size += GOT_ENTRY_SIZE;
1839 }
1840 else
1841 h->got.offset = (bfd_vma) -1;
1842 }
1843 else if (h->got.refcount > 0)
1844 {
1845 asection *s;
1846 bfd_boolean dyn;
1847 int tls_type = elf_s390_hash_entry(h)->tls_type;
1848
1849 /* Make sure this symbol is output as a dynamic symbol.
1850 Undefined weak syms won't yet be marked as dynamic. */
1851 if (h->dynindx == -1
1852 && !h->forced_local)
1853 {
1854 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1855 return FALSE;
1856 }
1857
1858 s = htab->elf.sgot;
1859 h->got.offset = s->size;
1860 s->size += GOT_ENTRY_SIZE;
1861 /* R_390_TLS_GD32 needs 2 consecutive GOT slots. */
1862 if (tls_type == GOT_TLS_GD)
1863 s->size += GOT_ENTRY_SIZE;
1864 dyn = htab->elf.dynamic_sections_created;
1865 /* R_390_TLS_IE32 needs one dynamic relocation,
1866 R_390_TLS_GD32 needs one if local symbol and two if global. */
1867 if ((tls_type == GOT_TLS_GD && h->dynindx == -1)
1868 || tls_type >= GOT_TLS_IE)
1869 htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
1870 else if (tls_type == GOT_TLS_GD)
1871 htab->elf.srelgot->size += 2 * sizeof (Elf32_External_Rela);
1872 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1873 || h->root.type != bfd_link_hash_undefweak)
1874 && (info->shared
1875 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
1876 htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
1877 }
1878 else
1879 h->got.offset = (bfd_vma) -1;
1880
1881 if (eh->dyn_relocs == NULL)
1882 return TRUE;
1883
1884 /* In the shared -Bsymbolic case, discard space allocated for
1885 dynamic pc-relative relocs against symbols which turn out to be
1886 defined in regular objects. For the normal shared case, discard
1887 space for pc-relative relocs that have become local due to symbol
1888 visibility changes. */
1889
1890 if (info->shared)
1891 {
1892 if (SYMBOL_CALLS_LOCAL (info, h))
1893 {
1894 struct elf_dyn_relocs **pp;
1895
1896 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1897 {
1898 p->count -= p->pc_count;
1899 p->pc_count = 0;
1900 if (p->count == 0)
1901 *pp = p->next;
1902 else
1903 pp = &p->next;
1904 }
1905 }
1906
1907 /* Also discard relocs on undefined weak syms with non-default
1908 visibility. */
1909 if (eh->dyn_relocs != NULL
1910 && h->root.type == bfd_link_hash_undefweak)
1911 {
1912 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1913 eh->dyn_relocs = NULL;
1914
1915 /* Make sure undefined weak symbols are output as a dynamic
1916 symbol in PIEs. */
1917 else if (h->dynindx == -1
1918 && !h->forced_local)
1919 {
1920 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1921 return FALSE;
1922 }
1923 }
1924 }
1925 else if (ELIMINATE_COPY_RELOCS)
1926 {
1927 /* For the non-shared case, discard space for relocs against
1928 symbols which turn out to need copy relocs or are not
1929 dynamic. */
1930
1931 if (!h->non_got_ref
1932 && ((h->def_dynamic
1933 && !h->def_regular)
1934 || (htab->elf.dynamic_sections_created
1935 && (h->root.type == bfd_link_hash_undefweak
1936 || h->root.type == bfd_link_hash_undefined))))
1937 {
1938 /* Make sure this symbol is output as a dynamic symbol.
1939 Undefined weak syms won't yet be marked as dynamic. */
1940 if (h->dynindx == -1
1941 && !h->forced_local)
1942 {
1943 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1944 return FALSE;
1945 }
1946
1947 /* If that succeeded, we know we'll be keeping all the
1948 relocs. */
1949 if (h->dynindx != -1)
1950 goto keep;
1951 }
1952
1953 eh->dyn_relocs = NULL;
1954
1955 keep: ;
1956 }
1957
1958 /* Finally, allocate space. */
1959 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1960 {
1961 asection *sreloc = elf_section_data (p->sec)->sreloc;
1962
1963 sreloc->size += p->count * sizeof (Elf32_External_Rela);
1964 }
1965
1966 return TRUE;
1967 }
1968
1969 /* Find any dynamic relocs that apply to read-only sections. */
1970
1971 static bfd_boolean
1972 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1973 {
1974 struct elf_s390_link_hash_entry *eh;
1975 struct elf_dyn_relocs *p;
1976
1977 eh = (struct elf_s390_link_hash_entry *) h;
1978 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1979 {
1980 asection *s = p->sec->output_section;
1981
1982 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1983 {
1984 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1985
1986 info->flags |= DF_TEXTREL;
1987
1988 /* Not an error, just cut short the traversal. */
1989 return FALSE;
1990 }
1991 }
1992 return TRUE;
1993 }
1994
1995 /* Set the sizes of the dynamic sections. */
1996
1997 static bfd_boolean
1998 elf_s390_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1999 struct bfd_link_info *info)
2000 {
2001 struct elf_s390_link_hash_table *htab;
2002 bfd *dynobj;
2003 asection *s;
2004 bfd_boolean relocs;
2005 bfd *ibfd;
2006
2007 htab = elf_s390_hash_table (info);
2008 dynobj = htab->elf.dynobj;
2009 if (dynobj == NULL)
2010 abort ();
2011
2012 if (htab->elf.dynamic_sections_created)
2013 {
2014 /* Set the contents of the .interp section to the interpreter. */
2015 if (info->executable)
2016 {
2017 s = bfd_get_linker_section (dynobj, ".interp");
2018 if (s == NULL)
2019 abort ();
2020 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2021 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2022 }
2023 }
2024
2025 /* Set up .got offsets for local syms, and space for local dynamic
2026 relocs. */
2027 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2028 {
2029 bfd_signed_vma *local_got;
2030 bfd_signed_vma *end_local_got;
2031 char *local_tls_type;
2032 bfd_size_type locsymcount;
2033 Elf_Internal_Shdr *symtab_hdr;
2034 asection *srela;
2035 struct plt_entry *local_plt;
2036 unsigned int i;
2037
2038 if (! is_s390_elf (ibfd))
2039 continue;
2040
2041 for (s = ibfd->sections; s != NULL; s = s->next)
2042 {
2043 struct elf_dyn_relocs *p;
2044
2045 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
2046 {
2047 if (!bfd_is_abs_section (p->sec)
2048 && bfd_is_abs_section (p->sec->output_section))
2049 {
2050 /* Input section has been discarded, either because
2051 it is a copy of a linkonce section or due to
2052 linker script /DISCARD/, so we'll be discarding
2053 the relocs too. */
2054 }
2055 else if (p->count != 0)
2056 {
2057 srela = elf_section_data (p->sec)->sreloc;
2058 srela->size += p->count * sizeof (Elf32_External_Rela);
2059 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2060 info->flags |= DF_TEXTREL;
2061 }
2062 }
2063 }
2064
2065 local_got = elf_local_got_refcounts (ibfd);
2066 if (!local_got)
2067 continue;
2068
2069 symtab_hdr = &elf_symtab_hdr (ibfd);
2070 locsymcount = symtab_hdr->sh_info;
2071 end_local_got = local_got + locsymcount;
2072 local_tls_type = elf_s390_local_got_tls_type (ibfd);
2073 s = htab->elf.sgot;
2074 srela = htab->elf.srelgot;
2075 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
2076 {
2077 if (*local_got > 0)
2078 {
2079 *local_got = s->size;
2080 s->size += GOT_ENTRY_SIZE;
2081 if (*local_tls_type == GOT_TLS_GD)
2082 s->size += GOT_ENTRY_SIZE;
2083 if (info->shared)
2084 srela->size += sizeof (Elf32_External_Rela);
2085 }
2086 else
2087 *local_got = (bfd_vma) -1;
2088 }
2089 local_plt = elf_s390_local_plt (ibfd);
2090 for (i = 0; i < symtab_hdr->sh_info; i++)
2091 {
2092 if (local_plt[i].plt.refcount > 0)
2093 {
2094 local_plt[i].plt.offset = htab->elf.iplt->size;
2095 htab->elf.iplt->size += PLT_ENTRY_SIZE;
2096 htab->elf.igotplt->size += GOT_ENTRY_SIZE;
2097 htab->elf.irelplt->size += RELA_ENTRY_SIZE;
2098 }
2099 else
2100 local_plt[i].plt.offset = (bfd_vma) -1;
2101 }
2102 }
2103
2104 if (htab->tls_ldm_got.refcount > 0)
2105 {
2106 /* Allocate 2 got entries and 1 dynamic reloc for R_390_TLS_LDM32
2107 relocs. */
2108 htab->tls_ldm_got.offset = htab->elf.sgot->size;
2109 htab->elf.sgot->size += 2 * GOT_ENTRY_SIZE;
2110 htab->elf.srelgot->size += sizeof (Elf32_External_Rela);
2111 }
2112 else
2113 htab->tls_ldm_got.offset = -1;
2114
2115 /* Allocate global sym .plt and .got entries, and space for global
2116 sym dynamic relocs. */
2117 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
2118
2119 /* We now have determined the sizes of the various dynamic sections.
2120 Allocate memory for them. */
2121 relocs = FALSE;
2122 for (s = dynobj->sections; s != NULL; s = s->next)
2123 {
2124 if ((s->flags & SEC_LINKER_CREATED) == 0)
2125 continue;
2126
2127 if (s == htab->elf.splt
2128 || s == htab->elf.sgot
2129 || s == htab->elf.sgotplt
2130 || s == htab->sdynbss
2131 || s == htab->elf.iplt
2132 || s == htab->elf.igotplt
2133 || s == htab->irelifunc)
2134 {
2135 /* Strip this section if we don't need it; see the
2136 comment below. */
2137 }
2138 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2139 {
2140 if (s->size != 0)
2141 relocs = TRUE;
2142
2143 /* We use the reloc_count field as a counter if we need
2144 to copy relocs into the output file. */
2145 s->reloc_count = 0;
2146 }
2147 else
2148 {
2149 /* It's not one of our sections, so don't allocate space. */
2150 continue;
2151 }
2152
2153 if (s->size == 0)
2154 {
2155 /* If we don't need this section, strip it from the
2156 output file. This is to handle .rela.bss and
2157 .rela.plt. We must create it in
2158 create_dynamic_sections, because it must be created
2159 before the linker maps input sections to output
2160 sections. The linker does that before
2161 adjust_dynamic_symbol is called, and it is that
2162 function which decides whether anything needs to go
2163 into these sections. */
2164
2165 s->flags |= SEC_EXCLUDE;
2166 continue;
2167 }
2168
2169 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2170 continue;
2171
2172 /* Allocate memory for the section contents. We use bfd_zalloc
2173 here in case unused entries are not reclaimed before the
2174 section's contents are written out. This should not happen,
2175 but this way if it does, we get a R_390_NONE reloc instead
2176 of garbage. */
2177 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2178 if (s->contents == NULL)
2179 return FALSE;
2180 }
2181
2182 if (htab->elf.dynamic_sections_created)
2183 {
2184 /* Add some entries to the .dynamic section. We fill in the
2185 values later, in elf_s390_finish_dynamic_sections, but we
2186 must add the entries now so that we get the correct size for
2187 the .dynamic section. The DT_DEBUG entry is filled in by the
2188 dynamic linker and used by the debugger. */
2189 #define add_dynamic_entry(TAG, VAL) \
2190 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2191
2192 if (info->executable)
2193 {
2194 if (!add_dynamic_entry (DT_DEBUG, 0))
2195 return FALSE;
2196 }
2197
2198 if (htab->elf.splt->size != 0)
2199 {
2200 if (!add_dynamic_entry (DT_PLTGOT, 0)
2201 || !add_dynamic_entry (DT_PLTRELSZ, 0)
2202 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2203 || !add_dynamic_entry (DT_JMPREL, 0))
2204 return FALSE;
2205 }
2206
2207 if (relocs)
2208 {
2209 if (!add_dynamic_entry (DT_RELA, 0)
2210 || !add_dynamic_entry (DT_RELASZ, 0)
2211 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
2212 return FALSE;
2213
2214 /* If any dynamic relocs apply to a read-only section,
2215 then we need a DT_TEXTREL entry. */
2216 if ((info->flags & DF_TEXTREL) == 0)
2217 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
2218
2219 if ((info->flags & DF_TEXTREL) != 0)
2220 {
2221 if (!add_dynamic_entry (DT_TEXTREL, 0))
2222 return FALSE;
2223 }
2224 }
2225 }
2226 #undef add_dynamic_entry
2227
2228 return TRUE;
2229 }
2230
2231 /* Return the base VMA address which should be subtracted from real addresses
2232 when resolving @dtpoff relocation.
2233 This is PT_TLS segment p_vaddr. */
2234
2235 static bfd_vma
2236 dtpoff_base (struct bfd_link_info *info)
2237 {
2238 /* If tls_sec is NULL, we should have signalled an error already. */
2239 if (elf_hash_table (info)->tls_sec == NULL)
2240 return 0;
2241 return elf_hash_table (info)->tls_sec->vma;
2242 }
2243
2244 /* Return the relocation value for @tpoff relocation
2245 if STT_TLS virtual address is ADDRESS. */
2246
2247 static bfd_vma
2248 tpoff (struct bfd_link_info *info, bfd_vma address)
2249 {
2250 struct elf_link_hash_table *htab = elf_hash_table (info);
2251
2252 /* If tls_sec is NULL, we should have signalled an error already. */
2253 if (htab->tls_sec == NULL)
2254 return 0;
2255 return htab->tls_size + htab->tls_sec->vma - address;
2256 }
2257
2258 /* Complain if TLS instruction relocation is against an invalid
2259 instruction. */
2260
2261 static void
2262 invalid_tls_insn (bfd *input_bfd,
2263 asection *input_section,
2264 Elf_Internal_Rela *rel)
2265 {
2266 reloc_howto_type *howto;
2267
2268 howto = elf_howto_table + ELF32_R_TYPE (rel->r_info);
2269 (*_bfd_error_handler)
2270 (_("%B(%A+0x%lx): invalid instruction for TLS relocation %s"),
2271 input_bfd,
2272 input_section,
2273 (long) rel->r_offset,
2274 howto->name);
2275 bfd_set_error (bfd_error_bad_value);
2276 }
2277
2278 /* Relocate a 390 ELF section. */
2279
2280 static bfd_boolean
2281 elf_s390_relocate_section (bfd *output_bfd,
2282 struct bfd_link_info *info,
2283 bfd *input_bfd,
2284 asection *input_section,
2285 bfd_byte *contents,
2286 Elf_Internal_Rela *relocs,
2287 Elf_Internal_Sym *local_syms,
2288 asection **local_sections)
2289 {
2290 struct elf_s390_link_hash_table *htab;
2291 Elf_Internal_Shdr *symtab_hdr;
2292 struct elf_link_hash_entry **sym_hashes;
2293 bfd_vma *local_got_offsets;
2294 Elf_Internal_Rela *rel;
2295 Elf_Internal_Rela *relend;
2296
2297 BFD_ASSERT (is_s390_elf (input_bfd));
2298
2299 htab = elf_s390_hash_table (info);
2300 symtab_hdr = &elf_symtab_hdr (input_bfd);
2301 sym_hashes = elf_sym_hashes (input_bfd);
2302 local_got_offsets = elf_local_got_offsets (input_bfd);
2303
2304 rel = relocs;
2305 relend = relocs + input_section->reloc_count;
2306 for (; rel < relend; rel++)
2307 {
2308 unsigned int r_type;
2309 reloc_howto_type *howto;
2310 unsigned long r_symndx;
2311 struct elf_link_hash_entry *h;
2312 Elf_Internal_Sym *sym;
2313 asection *sec;
2314 bfd_vma off;
2315 bfd_vma relocation;
2316 bfd_boolean unresolved_reloc;
2317 bfd_reloc_status_type r;
2318 int tls_type;
2319 asection *base_got = htab->elf.sgot;
2320
2321 r_type = ELF32_R_TYPE (rel->r_info);
2322 if (r_type == (int) R_390_GNU_VTINHERIT
2323 || r_type == (int) R_390_GNU_VTENTRY)
2324 continue;
2325 if (r_type >= (int) R_390_max)
2326 {
2327 bfd_set_error (bfd_error_bad_value);
2328 return FALSE;
2329 }
2330
2331 howto = elf_howto_table + r_type;
2332 r_symndx = ELF32_R_SYM (rel->r_info);
2333
2334 h = NULL;
2335 sym = NULL;
2336 sec = NULL;
2337 unresolved_reloc = FALSE;
2338 if (r_symndx < symtab_hdr->sh_info)
2339 {
2340 sym = local_syms + r_symndx;
2341 sec = local_sections[r_symndx];
2342 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
2343 {
2344 struct plt_entry *local_plt = elf_s390_local_plt (input_bfd);
2345 if (local_plt == NULL)
2346 return FALSE;
2347
2348 /* Address of the PLT slot. */
2349 relocation = (htab->elf.iplt->output_section->vma
2350 + htab->elf.iplt->output_offset
2351 + local_plt[r_symndx].plt.offset);
2352
2353 switch (r_type)
2354 {
2355 case R_390_PLTOFF16:
2356 case R_390_PLTOFF32:
2357 relocation -= htab->elf.sgot->output_section->vma;
2358 break;
2359 case R_390_GOTPLT12:
2360 case R_390_GOTPLT16:
2361 case R_390_GOTPLT20:
2362 case R_390_GOTPLT32:
2363 case R_390_GOTPLTENT:
2364 case R_390_GOT12:
2365 case R_390_GOT16:
2366 case R_390_GOT20:
2367 case R_390_GOT32:
2368 case R_390_GOTENT:
2369 {
2370 /* Write the PLT slot address into the GOT slot. */
2371 bfd_put_32 (output_bfd, relocation,
2372 htab->elf.sgot->contents +
2373 local_got_offsets[r_symndx]);
2374 relocation = (local_got_offsets[r_symndx] +
2375 htab->elf.sgot->output_offset);
2376
2377 if (r_type == R_390_GOTENT || r_type == R_390_GOTPLTENT)
2378 relocation += htab->elf.sgot->output_section->vma;
2379 break;
2380 }
2381 default:
2382 break;
2383 }
2384 /* The output section is needed later in
2385 finish_dynamic_section when creating the dynamic
2386 relocation. */
2387 local_plt[r_symndx].sec = sec;
2388 goto do_relocation;
2389 }
2390 else
2391 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2392 }
2393 else
2394 {
2395 bfd_boolean warned ATTRIBUTE_UNUSED;
2396
2397 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2398 r_symndx, symtab_hdr, sym_hashes,
2399 h, sec, relocation,
2400 unresolved_reloc, warned);
2401 }
2402
2403 if (sec != NULL && discarded_section (sec))
2404 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2405 rel, 1, relend, howto, 0, contents);
2406
2407 if (info->relocatable)
2408 continue;
2409
2410 switch (r_type)
2411 {
2412 case R_390_GOTPLT12:
2413 case R_390_GOTPLT16:
2414 case R_390_GOTPLT20:
2415 case R_390_GOTPLT32:
2416 case R_390_GOTPLTENT:
2417 /* There are three cases for a GOTPLT relocation. 1) The
2418 relocation is against the jump slot entry of a plt that
2419 will get emitted to the output file. 2) The relocation
2420 is against the jump slot of a plt entry that has been
2421 removed. elf_s390_adjust_gotplt has created a GOT entry
2422 as replacement. 3) The relocation is against a local symbol.
2423 Cases 2) and 3) are the same as the GOT relocation code
2424 so we just have to test for case 1 and fall through for
2425 the other two. */
2426 if (h != NULL && h->plt.offset != (bfd_vma) -1)
2427 {
2428 bfd_vma plt_index;
2429
2430 if (s390_is_ifunc_symbol_p (h))
2431 {
2432 plt_index = h->plt.offset / PLT_ENTRY_SIZE;
2433 relocation = (plt_index * GOT_ENTRY_SIZE +
2434 htab->elf.igotplt->output_offset);
2435 if (r_type == R_390_GOTPLTENT)
2436 relocation += htab->elf.igotplt->output_section->vma;
2437 }
2438 else
2439 {
2440 /* Calc. index no.
2441 Current offset - size first entry / entry size. */
2442 plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) /
2443 PLT_ENTRY_SIZE;
2444
2445 /* Offset in GOT is PLT index plus GOT headers(3)
2446 times 4, addr & GOT addr. */
2447 relocation = (plt_index + 3) * GOT_ENTRY_SIZE;
2448 if (r_type == R_390_GOTPLTENT)
2449 relocation += htab->elf.sgot->output_section->vma;
2450 }
2451 unresolved_reloc = FALSE;
2452
2453 }
2454 /* Fall through. */
2455
2456 case R_390_GOT12:
2457 case R_390_GOT16:
2458 case R_390_GOT20:
2459 case R_390_GOT32:
2460 case R_390_GOTENT:
2461 /* Relocation is to the entry for this symbol in the global
2462 offset table. */
2463 if (base_got == NULL)
2464 abort ();
2465
2466 if (h != NULL)
2467 {
2468 bfd_boolean dyn;
2469
2470 off = h->got.offset;
2471 dyn = htab->elf.dynamic_sections_created;
2472
2473 if (s390_is_ifunc_symbol_p (h))
2474 {
2475 BFD_ASSERT (h->plt.offset != (bfd_vma) -1);
2476 if (off == (bfd_vma)-1)
2477 {
2478 /* No explicit GOT usage so redirect to the
2479 got.iplt slot. */
2480 base_got = htab->elf.igotplt;
2481 off = h->plt.offset / PLT_ENTRY_SIZE * GOT_ENTRY_SIZE;
2482 }
2483 else
2484 {
2485 /* Explicit GOT slots must contain the address
2486 of the PLT slot. This will be handled in
2487 finish_dynamic_symbol. */
2488 }
2489 }
2490 else if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2491 || (info->shared
2492 && SYMBOL_REFERENCES_LOCAL (info, h))
2493 || (ELF_ST_VISIBILITY (h->other)
2494 && h->root.type == bfd_link_hash_undefweak))
2495
2496 {
2497 /* This is actually a static link, or it is a
2498 -Bsymbolic link and the symbol is defined
2499 locally, or the symbol was forced to be local
2500 because of a version file. We must initialize
2501 this entry in the global offset table. Since the
2502 offset must always be a multiple of 2, we use the
2503 least significant bit to record whether we have
2504 initialized it already.
2505
2506 When doing a dynamic link, we create a .rel.got
2507 relocation entry to initialize the value. This
2508 is done in the finish_dynamic_symbol routine. */
2509 if ((off & 1) != 0)
2510 off &= ~1;
2511 else
2512 {
2513 bfd_put_32 (output_bfd, relocation,
2514 base_got->contents + off);
2515 h->got.offset |= 1;
2516 }
2517 }
2518 else
2519 unresolved_reloc = FALSE;
2520 }
2521 else
2522 {
2523 if (local_got_offsets == NULL)
2524 abort ();
2525
2526 off = local_got_offsets[r_symndx];
2527
2528 /* The offset must always be a multiple of 4. We use
2529 the least significant bit to record whether we have
2530 already generated the necessary reloc. */
2531 if ((off & 1) != 0)
2532 off &= ~1;
2533 else
2534 {
2535 bfd_put_32 (output_bfd, relocation,
2536 htab->elf.sgot->contents + off);
2537
2538 if (info->shared)
2539 {
2540 asection *srelgot;
2541 Elf_Internal_Rela outrel;
2542 bfd_byte *loc;
2543
2544 srelgot = htab->elf.srelgot;
2545 if (srelgot == NULL)
2546 abort ();
2547
2548 outrel.r_offset = (htab->elf.sgot->output_section->vma
2549 + htab->elf.sgot->output_offset
2550 + off);
2551 outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2552 outrel.r_addend = relocation;
2553 loc = srelgot->contents;
2554 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
2555 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2556 }
2557
2558 local_got_offsets[r_symndx] |= 1;
2559 }
2560 }
2561
2562 if (off >= (bfd_vma) -2)
2563 abort ();
2564
2565 relocation = base_got->output_offset + off;
2566
2567 /* For @GOTENT the relocation is against the offset between
2568 the instruction and the symbols entry in the GOT and not
2569 between the start of the GOT and the symbols entry. We
2570 add the vma of the GOT to get the correct value. */
2571 if ( r_type == R_390_GOTENT
2572 || r_type == R_390_GOTPLTENT)
2573 relocation += base_got->output_section->vma;
2574
2575 break;
2576
2577 case R_390_GOTOFF16:
2578 case R_390_GOTOFF32:
2579 /* Relocation is relative to the start of the global offset
2580 table. */
2581
2582 /* Note that sgot->output_offset is not involved in this
2583 calculation. We always want the start of .got. If we
2584 defined _GLOBAL_OFFSET_TABLE in a different way, as is
2585 permitted by the ABI, we might have to change this
2586 calculation. */
2587 relocation -= htab->elf.sgot->output_section->vma;
2588 break;
2589
2590 case R_390_GOTPC:
2591 case R_390_GOTPCDBL:
2592 /* Use global offset table as symbol value. */
2593 relocation = htab->elf.sgot->output_section->vma;
2594 unresolved_reloc = FALSE;
2595 break;
2596
2597 case R_390_PLT16DBL:
2598 case R_390_PLT32DBL:
2599 case R_390_PLT32:
2600 /* Relocation is to the entry for this symbol in the
2601 procedure linkage table. */
2602
2603 /* Resolve a PLT32 reloc against a local symbol directly,
2604 without using the procedure linkage table. */
2605 if (h == NULL)
2606 break;
2607
2608 if (h->plt.offset == (bfd_vma) -1
2609 || (htab->elf.splt == NULL && htab->elf.iplt == NULL))
2610 {
2611 /* We didn't make a PLT entry for this symbol. This
2612 happens when statically linking PIC code, or when
2613 using -Bsymbolic. */
2614 break;
2615 }
2616
2617 if (s390_is_ifunc_symbol_p (h))
2618 relocation = (htab->elf.iplt->output_section->vma
2619 + htab->elf.iplt->output_offset
2620 + h->plt.offset);
2621 else
2622 relocation = (htab->elf.splt->output_section->vma
2623 + htab->elf.splt->output_offset
2624 + h->plt.offset);
2625 unresolved_reloc = FALSE;
2626 break;
2627
2628 case R_390_PLTOFF16:
2629 case R_390_PLTOFF32:
2630 /* Relocation is to the entry for this symbol in the
2631 procedure linkage table relative to the start of the GOT. */
2632
2633 /* For local symbols or if we didn't make a PLT entry for
2634 this symbol resolve the symbol directly. */
2635 if (h == NULL
2636 || h->plt.offset == (bfd_vma) -1
2637 || (htab->elf.splt == NULL && !s390_is_ifunc_symbol_p (h)))
2638 {
2639 relocation -= htab->elf.sgot->output_section->vma;
2640 break;
2641 }
2642
2643 if (s390_is_ifunc_symbol_p (h))
2644 relocation = (htab->elf.iplt->output_section->vma
2645 + htab->elf.iplt->output_offset
2646 + h->plt.offset
2647 - htab->elf.sgot->output_section->vma);
2648 else
2649 relocation = (htab->elf.splt->output_section->vma
2650 + htab->elf.splt->output_offset
2651 + h->plt.offset
2652 - htab->elf.sgot->output_section->vma);
2653 unresolved_reloc = FALSE;
2654 break;
2655
2656 case R_390_8:
2657 case R_390_16:
2658 case R_390_32:
2659 case R_390_PC16:
2660 case R_390_PC16DBL:
2661 case R_390_PC32DBL:
2662 case R_390_PC32:
2663 if (h != NULL
2664 && s390_is_ifunc_symbol_p (h)
2665 && h->def_regular)
2666 {
2667 if (!info->shared || !h->non_got_ref)
2668 {
2669 /* For a non-shared object STT_GNU_IFUNC symbol must
2670 go through PLT. */
2671 relocation = (htab->elf.iplt->output_section->vma
2672 + htab->elf.iplt->output_offset
2673 + h ->plt.offset);
2674 goto do_relocation;
2675 }
2676 else
2677 {
2678 /* For shared objects a runtime relocation is needed. */
2679
2680 Elf_Internal_Rela outrel;
2681 asection *sreloc;
2682
2683 /* Need a dynamic relocation to get the real function
2684 address. */
2685 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
2686 info,
2687 input_section,
2688 rel->r_offset);
2689 if (outrel.r_offset == (bfd_vma) -1
2690 || outrel.r_offset == (bfd_vma) -2)
2691 abort ();
2692
2693 outrel.r_offset += (input_section->output_section->vma
2694 + input_section->output_offset);
2695
2696 if (h->dynindx == -1
2697 || h->forced_local
2698 || info->executable)
2699 {
2700 /* This symbol is resolved locally. */
2701 outrel.r_info = ELF32_R_INFO (0, R_390_IRELATIVE);
2702 outrel.r_addend = (h->root.u.def.value
2703 + h->root.u.def.section->output_section->vma
2704 + h->root.u.def.section->output_offset);
2705 }
2706 else
2707 {
2708 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2709 outrel.r_addend = 0;
2710 }
2711
2712 sreloc = htab->elf.irelifunc;
2713 elf_append_rela (output_bfd, sreloc, &outrel);
2714
2715 /* If this reloc is against an external symbol, we
2716 do not want to fiddle with the addend. Otherwise,
2717 we need to include the symbol value so that it
2718 becomes an addend for the dynamic reloc. For an
2719 internal symbol, we have updated addend. */
2720 continue;
2721 }
2722 }
2723
2724 if ((input_section->flags & SEC_ALLOC) == 0)
2725 break;
2726
2727 if ((info->shared
2728 && (h == NULL
2729 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2730 || h->root.type != bfd_link_hash_undefweak)
2731 && ((r_type != R_390_PC16
2732 && r_type != R_390_PC16DBL
2733 && r_type != R_390_PC32DBL
2734 && r_type != R_390_PC32)
2735 || !SYMBOL_CALLS_LOCAL (info, h)))
2736 || (ELIMINATE_COPY_RELOCS
2737 && !info->shared
2738 && h != NULL
2739 && h->dynindx != -1
2740 && !h->non_got_ref
2741 && ((h->def_dynamic
2742 && !h->def_regular)
2743 || h->root.type == bfd_link_hash_undefweak
2744 || h->root.type == bfd_link_hash_undefined)))
2745 {
2746 Elf_Internal_Rela outrel;
2747 bfd_boolean skip, relocate;
2748 asection *sreloc;
2749 bfd_byte *loc;
2750
2751 /* When generating a shared object, these relocations
2752 are copied into the output file to be resolved at run
2753 time. */
2754
2755 skip = FALSE;
2756 relocate = FALSE;
2757
2758 outrel.r_offset =
2759 _bfd_elf_section_offset (output_bfd, info, input_section,
2760 rel->r_offset);
2761 if (outrel.r_offset == (bfd_vma) -1)
2762 skip = TRUE;
2763 else if (outrel.r_offset == (bfd_vma) -2)
2764 skip = TRUE, relocate = TRUE;
2765 outrel.r_offset += (input_section->output_section->vma
2766 + input_section->output_offset);
2767
2768 if (skip)
2769 memset (&outrel, 0, sizeof outrel);
2770 else if (h != NULL
2771 && h->dynindx != -1
2772 && (r_type == R_390_PC16
2773 || r_type == R_390_PC16DBL
2774 || r_type == R_390_PC32DBL
2775 || r_type == R_390_PC32
2776 || !info->shared
2777 || !SYMBOLIC_BIND (info, h)
2778 || !h->def_regular))
2779 {
2780 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2781 outrel.r_addend = rel->r_addend;
2782 }
2783 else
2784 {
2785 /* This symbol is local, or marked to become local. */
2786 outrel.r_addend = relocation + rel->r_addend;
2787 if (r_type == R_390_32)
2788 {
2789 relocate = TRUE;
2790 outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2791 }
2792 else
2793 {
2794 long sindx;
2795
2796 if (bfd_is_abs_section (sec))
2797 sindx = 0;
2798 else if (sec == NULL || sec->owner == NULL)
2799 {
2800 bfd_set_error(bfd_error_bad_value);
2801 return FALSE;
2802 }
2803 else
2804 {
2805 asection *osec;
2806
2807 osec = sec->output_section;
2808 sindx = elf_section_data (osec)->dynindx;
2809 if (sindx == 0)
2810 {
2811 osec = htab->elf.text_index_section;
2812 sindx = elf_section_data (osec)->dynindx;
2813 }
2814 BFD_ASSERT (sindx != 0);
2815
2816 /* We are turning this relocation into one
2817 against a section symbol, so subtract out
2818 the output section's address but not the
2819 offset of the input section in the output
2820 section. */
2821 outrel.r_addend -= osec->vma;
2822 }
2823 outrel.r_info = ELF32_R_INFO (sindx, r_type);
2824 }
2825 }
2826
2827 sreloc = elf_section_data (input_section)->sreloc;
2828 if (sreloc == NULL)
2829 abort ();
2830
2831 loc = sreloc->contents;
2832 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2833 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2834
2835 /* If this reloc is against an external symbol, we do
2836 not want to fiddle with the addend. Otherwise, we
2837 need to include the symbol value so that it becomes
2838 an addend for the dynamic reloc. */
2839 if (! relocate)
2840 continue;
2841 }
2842 break;
2843
2844 /* Relocations for tls literal pool entries. */
2845 case R_390_TLS_IE32:
2846 if (info->shared)
2847 {
2848 Elf_Internal_Rela outrel;
2849 asection *sreloc;
2850 bfd_byte *loc;
2851
2852 outrel.r_offset = rel->r_offset
2853 + input_section->output_section->vma
2854 + input_section->output_offset;
2855 outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
2856 sreloc = elf_section_data (input_section)->sreloc;
2857 if (sreloc == NULL)
2858 abort ();
2859 loc = sreloc->contents;
2860 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2861 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2862 }
2863 /* Fall through. */
2864
2865 case R_390_TLS_GD32:
2866 case R_390_TLS_GOTIE32:
2867 r_type = elf_s390_tls_transition (info, r_type, h == NULL);
2868 tls_type = GOT_UNKNOWN;
2869 if (h == NULL && local_got_offsets)
2870 tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
2871 else if (h != NULL)
2872 {
2873 tls_type = elf_s390_hash_entry(h)->tls_type;
2874 if (!info->shared && h->dynindx == -1 && tls_type >= GOT_TLS_IE)
2875 r_type = R_390_TLS_LE32;
2876 }
2877 if (r_type == R_390_TLS_GD32 && tls_type >= GOT_TLS_IE)
2878 r_type = R_390_TLS_IE32;
2879
2880 if (r_type == R_390_TLS_LE32)
2881 {
2882 /* This relocation gets optimized away by the local exec
2883 access optimization. */
2884 BFD_ASSERT (! unresolved_reloc);
2885 bfd_put_32 (output_bfd, -tpoff (info, relocation),
2886 contents + rel->r_offset);
2887 continue;
2888 }
2889
2890 if (htab->elf.sgot == NULL)
2891 abort ();
2892
2893 if (h != NULL)
2894 off = h->got.offset;
2895 else
2896 {
2897 if (local_got_offsets == NULL)
2898 abort ();
2899
2900 off = local_got_offsets[r_symndx];
2901 }
2902
2903 emit_tls_relocs:
2904
2905 if ((off & 1) != 0)
2906 off &= ~1;
2907 else
2908 {
2909 Elf_Internal_Rela outrel;
2910 bfd_byte *loc;
2911 int dr_type, indx;
2912
2913 if (htab->elf.srelgot == NULL)
2914 abort ();
2915
2916 outrel.r_offset = (htab->elf.sgot->output_section->vma
2917 + htab->elf.sgot->output_offset + off);
2918
2919 indx = h && h->dynindx != -1 ? h->dynindx : 0;
2920 if (r_type == R_390_TLS_GD32)
2921 dr_type = R_390_TLS_DTPMOD;
2922 else
2923 dr_type = R_390_TLS_TPOFF;
2924 if (dr_type == R_390_TLS_TPOFF && indx == 0)
2925 outrel.r_addend = relocation - dtpoff_base (info);
2926 else
2927 outrel.r_addend = 0;
2928 outrel.r_info = ELF32_R_INFO (indx, dr_type);
2929 loc = htab->elf.srelgot->contents;
2930 loc += htab->elf.srelgot->reloc_count++
2931 * sizeof (Elf32_External_Rela);
2932 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2933
2934 if (r_type == R_390_TLS_GD32)
2935 {
2936 if (indx == 0)
2937 {
2938 BFD_ASSERT (! unresolved_reloc);
2939 bfd_put_32 (output_bfd,
2940 relocation - dtpoff_base (info),
2941 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
2942 }
2943 else
2944 {
2945 outrel.r_info = ELF32_R_INFO (indx, R_390_TLS_DTPOFF);
2946 outrel.r_offset += GOT_ENTRY_SIZE;
2947 outrel.r_addend = 0;
2948 htab->elf.srelgot->reloc_count++;
2949 loc += sizeof (Elf32_External_Rela);
2950 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2951 }
2952 }
2953
2954 if (h != NULL)
2955 h->got.offset |= 1;
2956 else
2957 local_got_offsets[r_symndx] |= 1;
2958 }
2959
2960 if (off >= (bfd_vma) -2)
2961 abort ();
2962 if (r_type == ELF32_R_TYPE (rel->r_info))
2963 {
2964 relocation = htab->elf.sgot->output_offset + off;
2965 if (r_type == R_390_TLS_IE32 || r_type == R_390_TLS_IEENT)
2966 relocation += htab->elf.sgot->output_section->vma;
2967 unresolved_reloc = FALSE;
2968 }
2969 else
2970 {
2971 bfd_put_32 (output_bfd, htab->elf.sgot->output_offset + off,
2972 contents + rel->r_offset);
2973 continue;
2974 }
2975 break;
2976
2977 case R_390_TLS_GOTIE12:
2978 case R_390_TLS_GOTIE20:
2979 case R_390_TLS_IEENT:
2980 if (h == NULL)
2981 {
2982 if (local_got_offsets == NULL)
2983 abort();
2984 off = local_got_offsets[r_symndx];
2985 if (info->shared)
2986 goto emit_tls_relocs;
2987 }
2988 else
2989 {
2990 off = h->got.offset;
2991 tls_type = elf_s390_hash_entry(h)->tls_type;
2992 if (info->shared || h->dynindx != -1 || tls_type < GOT_TLS_IE)
2993 goto emit_tls_relocs;
2994 }
2995
2996 if (htab->elf.sgot == NULL)
2997 abort ();
2998
2999 BFD_ASSERT (! unresolved_reloc);
3000 bfd_put_32 (output_bfd, -tpoff (info, relocation),
3001 htab->elf.sgot->contents + off);
3002 relocation = htab->elf.sgot->output_offset + off;
3003 if (r_type == R_390_TLS_IEENT)
3004 relocation += htab->elf.sgot->output_section->vma;
3005 unresolved_reloc = FALSE;
3006 break;
3007
3008 case R_390_TLS_LDM32:
3009 if (! info->shared)
3010 /* The literal pool entry this relocation refers to gets ignored
3011 by the optimized code of the local exec model. Do nothing
3012 and the value will turn out zero. */
3013 continue;
3014
3015 if (htab->elf.sgot == NULL)
3016 abort ();
3017
3018 off = htab->tls_ldm_got.offset;
3019 if (off & 1)
3020 off &= ~1;
3021 else
3022 {
3023 Elf_Internal_Rela outrel;
3024 bfd_byte *loc;
3025
3026 if (htab->elf.srelgot == NULL)
3027 abort ();
3028
3029 outrel.r_offset = (htab->elf.sgot->output_section->vma
3030 + htab->elf.sgot->output_offset + off);
3031
3032 bfd_put_32 (output_bfd, 0,
3033 htab->elf.sgot->contents + off + GOT_ENTRY_SIZE);
3034 outrel.r_info = ELF32_R_INFO (0, R_390_TLS_DTPMOD);
3035 outrel.r_addend = 0;
3036 loc = htab->elf.srelgot->contents;
3037 loc += htab->elf.srelgot->reloc_count++
3038 * sizeof (Elf32_External_Rela);
3039 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3040 htab->tls_ldm_got.offset |= 1;
3041 }
3042 relocation = htab->elf.sgot->output_offset + off;
3043 unresolved_reloc = FALSE;
3044 break;
3045
3046 case R_390_TLS_LE32:
3047 if (info->shared)
3048 {
3049 /* Linking a shared library with non-fpic code requires
3050 a R_390_TLS_TPOFF relocation. */
3051 Elf_Internal_Rela outrel;
3052 asection *sreloc;
3053 bfd_byte *loc;
3054 int indx;
3055
3056 outrel.r_offset = rel->r_offset
3057 + input_section->output_section->vma
3058 + input_section->output_offset;
3059 if (h != NULL && h->dynindx != -1)
3060 indx = h->dynindx;
3061 else
3062 indx = 0;
3063 outrel.r_info = ELF32_R_INFO (indx, R_390_TLS_TPOFF);
3064 if (indx == 0)
3065 outrel.r_addend = relocation - dtpoff_base (info);
3066 else
3067 outrel.r_addend = 0;
3068 sreloc = elf_section_data (input_section)->sreloc;
3069 if (sreloc == NULL)
3070 abort ();
3071 loc = sreloc->contents;
3072 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
3073 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3074 }
3075 else
3076 {
3077 BFD_ASSERT (! unresolved_reloc);
3078 bfd_put_32 (output_bfd, -tpoff (info, relocation),
3079 contents + rel->r_offset);
3080 }
3081 continue;
3082
3083 case R_390_TLS_LDO32:
3084 if (info->shared || (input_section->flags & SEC_DEBUGGING))
3085 relocation -= dtpoff_base (info);
3086 else
3087 /* When converting LDO to LE, we must negate. */
3088 relocation = -tpoff (info, relocation);
3089 break;
3090
3091 /* Relocations for tls instructions. */
3092 case R_390_TLS_LOAD:
3093 case R_390_TLS_GDCALL:
3094 case R_390_TLS_LDCALL:
3095 tls_type = GOT_UNKNOWN;
3096 if (h == NULL && local_got_offsets)
3097 tls_type = elf_s390_local_got_tls_type (input_bfd) [r_symndx];
3098 else if (h != NULL)
3099 tls_type = elf_s390_hash_entry(h)->tls_type;
3100
3101 if (tls_type == GOT_TLS_GD)
3102 continue;
3103
3104 if (r_type == R_390_TLS_LOAD)
3105 {
3106 if (!info->shared && (h == NULL || h->dynindx == -1))
3107 {
3108 /* IE->LE transition. Four valid cases:
3109 l %rx,0(0,%ry) -> lr %rx,%ry + bcr 0,0
3110 l %rx,0(%ry,0) -> lr %rx,%ry + bcr 0,0
3111 l %rx,0(%ry,%r12) -> lr %rx,%ry + bcr 0,0
3112 l %rx,0(%r12,%ry) -> lr %rx,%ry + bcr 0,0 */
3113 unsigned int insn, ry;
3114
3115 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3116 ry = 0;
3117 if ((insn & 0xff00f000) == 0x58000000)
3118 /* l %rx,0(%ry,0) -> lr %rx,%ry + bcr 0,0 */
3119 ry = (insn & 0x000f0000);
3120 else if ((insn & 0xff0f0000) == 0x58000000)
3121 /* l %rx,0(0,%ry) -> lr %rx,%ry + bcr 0,0 */
3122 ry = (insn & 0x0000f000) << 4;
3123 else if ((insn & 0xff00f000) == 0x5800c000)
3124 /* l %rx,0(%ry,%r12) -> lr %rx,%ry + bcr 0,0 */
3125 ry = (insn & 0x000f0000);
3126 else if ((insn & 0xff0f0000) == 0x580c0000)
3127 /* l %rx,0(%r12,%ry) -> lr %rx,%ry + bcr 0,0 */
3128 ry = (insn & 0x0000f000) << 4;
3129 else
3130 invalid_tls_insn (input_bfd, input_section, rel);
3131 insn = 0x18000700 | (insn & 0x00f00000) | ry;
3132 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3133 }
3134 }
3135 else if (r_type == R_390_TLS_GDCALL)
3136 {
3137 unsigned int insn;
3138
3139 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3140 if ((insn & 0xff000fff) != 0x4d000000 &&
3141 (insn & 0xffff0000) != 0xc0e50000 &&
3142 (insn & 0xff000000) != 0x0d000000)
3143 invalid_tls_insn (input_bfd, input_section, rel);
3144 if (!info->shared && (h == NULL || h->dynindx == -1))
3145 {
3146 if ((insn & 0xff000000) == 0x0d000000)
3147 {
3148 /* GD->LE transition.
3149 basr rx, ry -> nopr r7 */
3150 insn = 0x07070000 | (insn & 0xffff);
3151 }
3152 else if ((insn & 0xff000000) == 0x4d000000)
3153 {
3154 /* GD->LE transition.
3155 bas %r14,0(%rx,%r13) -> bc 0,0 */
3156 insn = 0x47000000;
3157 }
3158 else
3159 {
3160 /* GD->LE transition.
3161 brasl %r14,_tls_get_offset@plt -> brcl 0,. */
3162 insn = 0xc0040000;
3163 bfd_put_16 (output_bfd, 0x0000,
3164 contents + rel->r_offset + 4);
3165 }
3166 }
3167 else
3168 {
3169 /* If basr is used in the pic case to invoke
3170 _tls_get_offset, something went wrong before. */
3171 if ((insn & 0xff000000) == 0x0d000000)
3172 invalid_tls_insn (input_bfd, input_section, rel);
3173
3174 if ((insn & 0xff000000) == 0x4d000000)
3175 {
3176 /* GD->IE transition.
3177 bas %r14,0(%rx,%r13) -> l %r2,0(%r2,%r12) */
3178 insn = 0x5822c000;
3179 }
3180 else
3181 {
3182 /* GD->IE transition.
3183 brasl %r14,__tls_get_addr@plt ->
3184 l %r2,0(%r2,%r12) ; bcr 0,0 */
3185 insn = 0x5822c000;
3186 bfd_put_16 (output_bfd, 0x0700,
3187 contents + rel->r_offset + 4);
3188 }
3189 }
3190 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3191 }
3192 else if (r_type == R_390_TLS_LDCALL)
3193 {
3194 if (!info->shared)
3195 {
3196 unsigned int insn;
3197
3198 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3199 if ((insn & 0xff000fff) != 0x4d000000 &&
3200 (insn & 0xffff0000) != 0xc0e50000 &&
3201 (insn & 0xff000000) != 0x0d000000)
3202 invalid_tls_insn (input_bfd, input_section, rel);
3203
3204 if ((insn & 0xff000000) == 0x0d000000)
3205 {
3206 /* LD->LE transition.
3207 basr rx, ry -> nopr r7 */
3208 insn = 0x07070000 | (insn & 0xffff);
3209 }
3210 else if ((insn & 0xff000000) == 0x4d000000)
3211 {
3212 /* LD->LE transition.
3213 bas %r14,0(%rx,%r13) -> bc 0,0 */
3214 insn = 0x47000000;
3215 }
3216 else
3217 {
3218 /* LD->LE transition.
3219 brasl %r14,__tls_get_offset@plt -> brcl 0,. */
3220 insn = 0xc0040000;
3221 bfd_put_16 (output_bfd, 0x0000,
3222 contents + rel->r_offset + 4);
3223 }
3224 bfd_put_32 (output_bfd, insn, contents + rel->r_offset);
3225 }
3226 }
3227 continue;
3228
3229 default:
3230 break;
3231 }
3232
3233 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3234 because such sections are not SEC_ALLOC and thus ld.so will
3235 not process them. */
3236 if (unresolved_reloc
3237 && !((input_section->flags & SEC_DEBUGGING) != 0
3238 && h->def_dynamic)
3239 && _bfd_elf_section_offset (output_bfd, info, input_section,
3240 rel->r_offset) != (bfd_vma) -1)
3241 (*_bfd_error_handler)
3242 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
3243 input_bfd,
3244 input_section,
3245 (long) rel->r_offset,
3246 howto->name,
3247 h->root.root.string);
3248
3249 do_relocation:
3250
3251 if (r_type == R_390_20
3252 || r_type == R_390_GOT20
3253 || r_type == R_390_GOTPLT20
3254 || r_type == R_390_TLS_GOTIE20)
3255 {
3256 relocation += rel->r_addend;
3257 relocation = (relocation&0xfff) << 8 | (relocation&0xff000) >> 12;
3258 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3259 contents, rel->r_offset,
3260 relocation, 0);
3261 }
3262 else
3263 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3264 contents, rel->r_offset,
3265 relocation, rel->r_addend);
3266
3267 if (r != bfd_reloc_ok)
3268 {
3269 const char *name;
3270
3271 if (h != NULL)
3272 name = h->root.root.string;
3273 else
3274 {
3275 name = bfd_elf_string_from_elf_section (input_bfd,
3276 symtab_hdr->sh_link,
3277 sym->st_name);
3278 if (name == NULL)
3279 return FALSE;
3280 if (*name == '\0')
3281 name = bfd_section_name (input_bfd, sec);
3282 }
3283
3284 if (r == bfd_reloc_overflow)
3285 {
3286
3287 if (! ((*info->callbacks->reloc_overflow)
3288 (info, (h ? &h->root : NULL), name, howto->name,
3289 (bfd_vma) 0, input_bfd, input_section,
3290 rel->r_offset)))
3291 return FALSE;
3292 }
3293 else
3294 {
3295 (*_bfd_error_handler)
3296 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3297 input_bfd, input_section,
3298 (long) rel->r_offset, name, (int) r);
3299 return FALSE;
3300 }
3301 }
3302 }
3303
3304 return TRUE;
3305 }
3306
3307 /* Generate the PLT slots together with the dynamic relocations needed
3308 for IFUNC symbols. */
3309
3310 static void
3311 elf_s390_finish_ifunc_symbol (bfd *output_bfd,
3312 struct bfd_link_info *info,
3313 struct elf_link_hash_entry *h,
3314 struct elf_s390_link_hash_table *htab,
3315 bfd_vma iplt_offset,
3316 bfd_vma resolver_address)
3317 {
3318 bfd_vma iplt_index;
3319 bfd_vma got_offset;
3320 bfd_vma igotiplt_offset;
3321 Elf_Internal_Rela rela;
3322 bfd_byte *loc;
3323 asection *plt, *gotplt, *relplt;
3324 bfd_vma relative_offset;
3325
3326 if (htab->elf.iplt == NULL
3327 || htab->elf.igotplt == NULL
3328 || htab->elf.irelplt == NULL)
3329 abort ();
3330
3331 gotplt = htab->elf.igotplt;
3332 relplt = htab->elf.irelplt;
3333
3334 /* Index of the PLT slot within iplt section. */
3335 iplt_index = iplt_offset / PLT_ENTRY_SIZE;
3336 plt = htab->elf.iplt;
3337 /* Offset into the igot.plt section. */
3338 igotiplt_offset = iplt_index * GOT_ENTRY_SIZE;
3339 /* Offset into the got section. */
3340 got_offset = igotiplt_offset + gotplt->output_offset;
3341
3342 /* S390 uses halfwords for relative branch calc! */
3343 relative_offset = - (plt->output_offset +
3344 (PLT_ENTRY_SIZE * iplt_index) + 18) / 2;
3345 /* If offset is > 32768, branch to a previous branch
3346 390 can only handle +-64 K jumps. */
3347 if ( -32768 > (int) relative_offset )
3348 relative_offset
3349 = -(unsigned) (((65536 / PLT_ENTRY_SIZE - 1) * PLT_ENTRY_SIZE) / 2);
3350
3351 /* Fill in the entry in the procedure linkage table. */
3352 if (!info->shared)
3353 {
3354 memcpy (plt->contents + iplt_offset, elf_s390_plt_entry,
3355 PLT_ENTRY_SIZE);
3356
3357 /* Adjust jump to the first plt entry. */
3358 bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3359 plt->contents + iplt_offset + 20);
3360
3361 /* Push the GOT offset field. */
3362 bfd_put_32 (output_bfd,
3363 (gotplt->output_section->vma
3364 + got_offset),
3365 plt->contents + iplt_offset + 24);
3366 }
3367 else if (got_offset < 4096)
3368 {
3369 /* The GOT offset is small enough to be used directly as
3370 displacement. */
3371 memcpy (plt->contents + iplt_offset,
3372 elf_s390_plt_pic12_entry,
3373 PLT_ENTRY_SIZE);
3374
3375 /* Put in the GOT offset as displacement value. The 0xc000
3376 value comes from the first word of the plt entry. Look
3377 at the elf_s390_plt_pic16_entry content. */
3378 bfd_put_16 (output_bfd, (bfd_vma)0xc000 | got_offset,
3379 plt->contents + iplt_offset + 2);
3380
3381 /* Adjust the jump to the first plt entry. */
3382 bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3383 plt->contents + iplt_offset + 20);
3384 }
3385 else if (got_offset < 32768)
3386 {
3387 /* The GOT offset is too big for a displacement but small
3388 enough to be a signed 16 bit immediate value as it can be
3389 used in an lhi instruction. */
3390 memcpy (plt->contents + iplt_offset,
3391 elf_s390_plt_pic16_entry,
3392 PLT_ENTRY_SIZE);
3393
3394 /* Put in the GOT offset for the lhi instruction. */
3395 bfd_put_16 (output_bfd, (bfd_vma)got_offset,
3396 plt->contents + iplt_offset + 2);
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 else
3403 {
3404 memcpy (plt->contents + iplt_offset,
3405 elf_s390_plt_pic_entry,
3406 PLT_ENTRY_SIZE);
3407
3408 /* Adjust the jump to the first plt entry. */
3409 bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3410 plt->contents + iplt_offset + 20);
3411
3412 /* Push the GOT offset field. */
3413 bfd_put_32 (output_bfd, got_offset,
3414 plt->contents + iplt_offset + 24);
3415 }
3416 /* Insert offset into reloc. table here. */
3417 bfd_put_32 (output_bfd, relplt->output_offset +
3418 iplt_index * RELA_ENTRY_SIZE,
3419 plt->contents + iplt_offset + 28);
3420
3421 /* Fill in the entry in the global offset table.
3422 Points to instruction after GOT offset. */
3423 bfd_put_32 (output_bfd,
3424 (plt->output_section->vma
3425 + plt->output_offset
3426 + iplt_offset
3427 + 12),
3428 gotplt->contents + igotiplt_offset);
3429
3430 /* Fill in the entry in the .rela.plt section. */
3431 rela.r_offset = gotplt->output_section->vma + got_offset;
3432
3433 if (!h
3434 || h->dynindx == -1
3435 || ((info->executable
3436 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
3437 && h->def_regular))
3438 {
3439 /* The symbol can be locally resolved. */
3440 rela.r_info = ELF32_R_INFO (0, R_390_IRELATIVE);
3441 rela.r_addend = resolver_address;
3442 }
3443 else
3444 {
3445 rela.r_info = ELF32_R_INFO (h->dynindx, R_390_JMP_SLOT);
3446 rela.r_addend = 0;
3447 }
3448
3449 loc = relplt->contents + iplt_index * RELA_ENTRY_SIZE;
3450 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3451 }
3452
3453 /* Finish up dynamic symbol handling. We set the contents of various
3454 dynamic sections here. */
3455
3456 static bfd_boolean
3457 elf_s390_finish_dynamic_symbol (bfd *output_bfd,
3458 struct bfd_link_info *info,
3459 struct elf_link_hash_entry *h,
3460 Elf_Internal_Sym *sym)
3461 {
3462 struct elf_s390_link_hash_table *htab;
3463 struct elf_s390_link_hash_entry *eh = (struct elf_s390_link_hash_entry*)h;
3464
3465 htab = elf_s390_hash_table (info);
3466
3467 if (h->plt.offset != (bfd_vma) -1)
3468 {
3469 bfd_vma plt_index;
3470 bfd_vma got_offset;
3471 Elf_Internal_Rela rela;
3472 bfd_byte *loc;
3473 bfd_vma relative_offset;
3474
3475 /* This symbol has an entry in the procedure linkage table. Set
3476 it up. */
3477 if (s390_is_ifunc_symbol_p (h))
3478 {
3479 /* If we can resolve the IFUNC symbol locally we generate an
3480 IRELATIVE reloc. */
3481 elf_s390_finish_ifunc_symbol (output_bfd, info, h, htab, h->plt.offset,
3482 eh->ifunc_resolver_address +
3483 eh->ifunc_resolver_section->output_offset +
3484 eh->ifunc_resolver_section->output_section->vma);
3485 /* Fallthrough. Handling of explicit GOT slots of IFUNC
3486 symbols is below. */
3487 }
3488 else
3489 {
3490 if (h->dynindx == -1
3491 || htab->elf.splt == NULL
3492 || htab->elf.sgotplt == NULL
3493 || htab->elf.srelplt == NULL)
3494 abort ();
3495
3496 /* Calc. index no.
3497 Current offset - size first entry / entry size. */
3498 plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) / PLT_ENTRY_SIZE;
3499
3500 /* Offset in GOT is PLT index plus GOT headers(3) times 4,
3501 addr & GOT addr. */
3502 got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
3503
3504 /* S390 uses halfwords for relative branch calc! */
3505 relative_offset = - ((PLT_FIRST_ENTRY_SIZE +
3506 (PLT_ENTRY_SIZE * plt_index) + 18) / 2);
3507 /* If offset is > 32768, branch to a previous branch
3508 390 can only handle +-64 K jumps. */
3509 if ( -32768 > (int) relative_offset )
3510 relative_offset
3511 = -(unsigned) (((65536 / PLT_ENTRY_SIZE - 1) * PLT_ENTRY_SIZE) / 2);
3512
3513 /* Fill in the entry in the procedure linkage table. */
3514 if (!info->shared)
3515 {
3516 memcpy (htab->elf.splt->contents + h->plt.offset, elf_s390_plt_entry,
3517 PLT_ENTRY_SIZE);
3518
3519 /* Adjust jump to the first plt entry. */
3520 bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3521 htab->elf.splt->contents + h->plt.offset + 20);
3522
3523 /* Push the GOT offset field. */
3524 bfd_put_32 (output_bfd,
3525 (htab->elf.sgotplt->output_section->vma
3526 + htab->elf.sgotplt->output_offset
3527 + got_offset),
3528 htab->elf.splt->contents + h->plt.offset + 24);
3529 }
3530 else if (got_offset < 4096)
3531 {
3532 /* The GOT offset is small enough to be used directly as
3533 displacement. */
3534 memcpy (htab->elf.splt->contents + h->plt.offset,
3535 elf_s390_plt_pic12_entry,
3536 PLT_ENTRY_SIZE);
3537
3538 /* Put in the GOT offset as displacement value. The 0xc000
3539 value comes from the first word of the plt entry. Look
3540 at the elf_s390_plt_pic16_entry content. */
3541 bfd_put_16 (output_bfd, (bfd_vma)0xc000 | got_offset,
3542 htab->elf.splt->contents + h->plt.offset + 2);
3543
3544 /* Adjust the jump to the first plt entry. */
3545 bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3546 htab->elf.splt->contents + h->plt.offset + 20);
3547 }
3548 else if (got_offset < 32768)
3549 {
3550 /* The GOT offset is too big for a displacement but small
3551 enough to be a signed 16 bit immediate value as it can be
3552 used in an lhi instruction. */
3553 memcpy (htab->elf.splt->contents + h->plt.offset,
3554 elf_s390_plt_pic16_entry,
3555 PLT_ENTRY_SIZE);
3556
3557 /* Put in the GOT offset for the lhi instruction. */
3558 bfd_put_16 (output_bfd, (bfd_vma)got_offset,
3559 htab->elf.splt->contents + h->plt.offset + 2);
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 else
3566 {
3567 memcpy (htab->elf.splt->contents + h->plt.offset,
3568 elf_s390_plt_pic_entry,
3569 PLT_ENTRY_SIZE);
3570
3571 /* Adjust the jump to the first plt entry. */
3572 bfd_put_32 (output_bfd, (bfd_vma) 0+(relative_offset << 16),
3573 htab->elf.splt->contents + h->plt.offset + 20);
3574
3575 /* Push the GOT offset field. */
3576 bfd_put_32 (output_bfd, got_offset,
3577 htab->elf.splt->contents + h->plt.offset + 24);
3578 }
3579 /* Insert offset into reloc. table here. */
3580 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
3581 htab->elf.splt->contents + h->plt.offset + 28);
3582
3583 /* Fill in the entry in the global offset table.
3584 Points to instruction after GOT offset. */
3585 bfd_put_32 (output_bfd,
3586 (htab->elf.splt->output_section->vma
3587 + htab->elf.splt->output_offset
3588 + h->plt.offset
3589 + 12),
3590 htab->elf.sgotplt->contents + got_offset);
3591
3592 /* Fill in the entry in the .rela.plt section. */
3593 rela.r_offset = (htab->elf.sgotplt->output_section->vma
3594 + htab->elf.sgotplt->output_offset
3595 + got_offset);
3596 rela.r_info = ELF32_R_INFO (h->dynindx, R_390_JMP_SLOT);
3597 rela.r_addend = 0;
3598 loc = htab->elf.srelplt->contents + plt_index * sizeof (Elf32_External_Rela);
3599 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3600
3601 if (!h->def_regular)
3602 {
3603 /* Mark the symbol as undefined, rather than as defined in
3604 the .plt section. Leave the value alone. This is a clue
3605 for the dynamic linker, to make function pointer
3606 comparisons work between an application and shared
3607 library. */
3608 sym->st_shndx = SHN_UNDEF;
3609 }
3610 }
3611 }
3612
3613 if (h->got.offset != (bfd_vma) -1
3614 && elf_s390_hash_entry(h)->tls_type != GOT_TLS_GD
3615 && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE
3616 && elf_s390_hash_entry(h)->tls_type != GOT_TLS_IE_NLT)
3617 {
3618 Elf_Internal_Rela rela;
3619 bfd_byte *loc;
3620
3621 /* This symbol has an entry in the global offset table. Set it
3622 up. */
3623
3624 if (htab->elf.sgot == NULL || htab->elf.srelgot == NULL)
3625 abort ();
3626
3627 rela.r_offset = (htab->elf.sgot->output_section->vma
3628 + htab->elf.sgot->output_offset
3629 + (h->got.offset &~ (bfd_vma) 1));
3630
3631 /* If this is a static link, or it is a -Bsymbolic link and the
3632 symbol is defined locally or was forced to be local because
3633 of a version file, we just want to emit a RELATIVE reloc.
3634 The entry in the global offset table will already have been
3635 initialized in the relocate_section function. */
3636 if (h->def_regular && s390_is_ifunc_symbol_p (h))
3637 {
3638 if (info->shared)
3639 {
3640 /* An explicit GOT slot usage needs GLOB_DAT. If the
3641 symbol references local the implicit got.iplt slot
3642 will be used and the IRELATIVE reloc has been created
3643 above. */
3644 goto do_glob_dat;
3645 }
3646 else
3647 {
3648 /* For non-shared objects explicit GOT slots must be
3649 filled with the PLT slot address for pointer
3650 equality reasons. */
3651 bfd_put_32 (output_bfd, (htab->elf.iplt->output_section->vma
3652 + htab->elf.iplt->output_offset
3653 + h->plt.offset),
3654 htab->elf.sgot->contents + h->got.offset);
3655 return TRUE;
3656 }
3657 }
3658 else if (info->shared
3659 && SYMBOL_REFERENCES_LOCAL (info, h))
3660 {
3661 /* If this is a static link, or it is a -Bsymbolic link and
3662 the symbol is defined locally or was forced to be local
3663 because of a version file, we just want to emit a
3664 RELATIVE reloc. The entry in the global offset table
3665 will already have been initialized in the
3666 relocate_section function. */
3667 if (!h->def_regular)
3668 return FALSE;
3669 BFD_ASSERT((h->got.offset & 1) != 0);
3670 rela.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
3671 rela.r_addend = (h->root.u.def.value
3672 + h->root.u.def.section->output_section->vma
3673 + h->root.u.def.section->output_offset);
3674 }
3675 else
3676 {
3677 BFD_ASSERT((h->got.offset & 1) == 0);
3678 do_glob_dat:
3679 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->elf.sgot->contents + h->got.offset);
3680 rela.r_info = ELF32_R_INFO (h->dynindx, R_390_GLOB_DAT);
3681 rela.r_addend = 0;
3682 }
3683
3684 loc = htab->elf.srelgot->contents;
3685 loc += htab->elf.srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
3686 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3687 }
3688
3689 if (h->needs_copy)
3690 {
3691 Elf_Internal_Rela rela;
3692 bfd_byte *loc;
3693
3694 /* This symbols needs a copy reloc. Set it up. */
3695
3696 if (h->dynindx == -1
3697 || (h->root.type != bfd_link_hash_defined
3698 && h->root.type != bfd_link_hash_defweak)
3699 || htab->srelbss == NULL)
3700 abort ();
3701
3702 rela.r_offset = (h->root.u.def.value
3703 + h->root.u.def.section->output_section->vma
3704 + h->root.u.def.section->output_offset);
3705 rela.r_info = ELF32_R_INFO (h->dynindx, R_390_COPY);
3706 rela.r_addend = 0;
3707 loc = htab->srelbss->contents;
3708 loc += htab->srelbss->reloc_count++ * sizeof (Elf32_External_Rela);
3709 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3710 }
3711
3712 /* Mark some specially defined symbols as absolute. */
3713 if (h == htab->elf.hdynamic
3714 || h == htab->elf.hgot
3715 || h == htab->elf.hplt)
3716 sym->st_shndx = SHN_ABS;
3717
3718 return TRUE;
3719 }
3720
3721 /* Used to decide how to sort relocs in an optimal manner for the
3722 dynamic linker, before writing them out. */
3723
3724 static enum elf_reloc_type_class
3725 elf_s390_reloc_type_class (const Elf_Internal_Rela *rela)
3726 {
3727 switch ((int) ELF32_R_TYPE (rela->r_info))
3728 {
3729 case R_390_RELATIVE:
3730 return reloc_class_relative;
3731 case R_390_JMP_SLOT:
3732 return reloc_class_plt;
3733 case R_390_COPY:
3734 return reloc_class_copy;
3735 default:
3736 return reloc_class_normal;
3737 }
3738 }
3739
3740 /* Finish up the dynamic sections. */
3741
3742 static bfd_boolean
3743 elf_s390_finish_dynamic_sections (bfd *output_bfd,
3744 struct bfd_link_info *info)
3745 {
3746 struct elf_s390_link_hash_table *htab;
3747 bfd *dynobj;
3748 asection *sdyn;
3749 bfd *ibfd;
3750 unsigned int i;
3751
3752 htab = elf_s390_hash_table (info);
3753 dynobj = htab->elf.dynobj;
3754 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3755
3756 if (htab->elf.dynamic_sections_created)
3757 {
3758 Elf32_External_Dyn *dyncon, *dynconend;
3759
3760 if (sdyn == NULL || htab->elf.sgot == NULL)
3761 abort ();
3762
3763 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3764 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3765 for (; dyncon < dynconend; dyncon++)
3766 {
3767 Elf_Internal_Dyn dyn;
3768 asection *s;
3769
3770 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3771
3772 switch (dyn.d_tag)
3773 {
3774 default:
3775 continue;
3776
3777 case DT_PLTGOT:
3778 dyn.d_un.d_ptr = htab->elf.sgot->output_section->vma;
3779 break;
3780
3781 case DT_JMPREL:
3782 dyn.d_un.d_ptr = htab->elf.srelplt->output_section->vma;
3783 break;
3784
3785 case DT_PLTRELSZ:
3786 s = htab->elf.srelplt->output_section;
3787 dyn.d_un.d_val = s->size;
3788 break;
3789 }
3790
3791 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3792 }
3793
3794 /* Fill in the special first entry in the procedure linkage table. */
3795 if (htab->elf.splt && htab->elf.splt->size > 0)
3796 {
3797 memset (htab->elf.splt->contents, 0, PLT_FIRST_ENTRY_SIZE);
3798 if (info->shared)
3799 {
3800 memcpy (htab->elf.splt->contents, elf_s390_plt_pic_first_entry,
3801 PLT_FIRST_ENTRY_SIZE);
3802 }
3803 else
3804 {
3805 memcpy (htab->elf.splt->contents, elf_s390_plt_first_entry,
3806 PLT_FIRST_ENTRY_SIZE);
3807 bfd_put_32 (output_bfd,
3808 htab->elf.sgotplt->output_section->vma
3809 + htab->elf.sgotplt->output_offset,
3810 htab->elf.splt->contents + 24);
3811 }
3812 elf_section_data (htab->elf.splt->output_section)
3813 ->this_hdr.sh_entsize = 4;
3814 }
3815
3816 }
3817
3818 if (htab->elf.sgotplt)
3819 {
3820 /* Fill in the first three entries in the global offset table. */
3821 if (htab->elf.sgotplt->size > 0)
3822 {
3823 bfd_put_32 (output_bfd,
3824 (sdyn == NULL ? (bfd_vma) 0
3825 : sdyn->output_section->vma + sdyn->output_offset),
3826 htab->elf.sgotplt->contents);
3827 /* One entry for shared object struct ptr. */
3828 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + 4);
3829 /* One entry for _dl_runtime_resolve. */
3830 bfd_put_32 (output_bfd, (bfd_vma) 0, htab->elf.sgotplt->contents + 8);
3831 }
3832
3833 elf_section_data (htab->elf.sgotplt->output_section)
3834 ->this_hdr.sh_entsize = 4;
3835 }
3836 /* Finish dynamic symbol for local IFUNC symbols. */
3837 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3838 {
3839 struct plt_entry *local_plt;
3840 Elf_Internal_Sym *isym;
3841 Elf_Internal_Shdr *symtab_hdr;
3842
3843 symtab_hdr = &elf_symtab_hdr (ibfd);
3844
3845 local_plt = elf_s390_local_plt (ibfd);
3846 if (local_plt != NULL)
3847 for (i = 0; i < symtab_hdr->sh_info; i++)
3848 {
3849 if (local_plt[i].plt.offset != (bfd_vma) -1)
3850 {
3851 asection *sec = local_plt[i].sec;
3852 isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, i);
3853 if (isym == NULL)
3854 return FALSE;
3855
3856 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
3857 elf_s390_finish_ifunc_symbol (output_bfd, info, NULL, htab,
3858 local_plt[i].plt.offset,
3859 isym->st_value
3860 + sec->output_section->vma
3861 + sec->output_offset);
3862
3863 }
3864 }
3865 }
3866 return TRUE;
3867 }
3868
3869 static bfd_boolean
3870 elf_s390_grok_prstatus (bfd * abfd, Elf_Internal_Note * note)
3871 {
3872 int offset;
3873 unsigned int size;
3874
3875 switch (note->descsz)
3876 {
3877 default:
3878 return FALSE;
3879
3880 case 224: /* S/390 Linux. */
3881 /* pr_cursig */
3882 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
3883
3884 /* pr_pid */
3885 elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24);
3886
3887 /* pr_reg */
3888 offset = 72;
3889 size = 144;
3890 break;
3891 }
3892
3893 /* Make a ".reg/999" section. */
3894 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
3895 size, note->descpos + offset);
3896 }
3897
3898 /* Return address for Ith PLT stub in section PLT, for relocation REL
3899 or (bfd_vma) -1 if it should not be included. */
3900
3901 static bfd_vma
3902 elf_s390_plt_sym_val (bfd_vma i, const asection *plt,
3903 const arelent *rel ATTRIBUTE_UNUSED)
3904 {
3905 return plt->vma + PLT_FIRST_ENTRY_SIZE + i * PLT_ENTRY_SIZE;
3906 }
3907
3908 static bfd_boolean
3909 elf32_s390_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
3910 {
3911 elf_elfheader (obfd)->e_flags |= elf_elfheader (ibfd)->e_flags;
3912 return TRUE;
3913 }
3914
3915
3916 #define TARGET_BIG_SYM bfd_elf32_s390_vec
3917 #define TARGET_BIG_NAME "elf32-s390"
3918 #define ELF_ARCH bfd_arch_s390
3919 #define ELF_TARGET_ID S390_ELF_DATA
3920 #define ELF_MACHINE_CODE EM_S390
3921 #define ELF_MACHINE_ALT1 EM_S390_OLD
3922 #define ELF_MAXPAGESIZE 0x1000
3923
3924 #define elf_backend_can_gc_sections 1
3925 #define elf_backend_can_refcount 1
3926 #define elf_backend_want_got_plt 1
3927 #define elf_backend_plt_readonly 1
3928 #define elf_backend_want_plt_sym 0
3929 #define elf_backend_got_header_size 12
3930 #define elf_backend_rela_normal 1
3931
3932 #define elf_info_to_howto elf_s390_info_to_howto
3933
3934 #define bfd_elf32_bfd_is_local_label_name elf_s390_is_local_label_name
3935 #define bfd_elf32_bfd_link_hash_table_create elf_s390_link_hash_table_create
3936 #define bfd_elf32_bfd_reloc_type_lookup elf_s390_reloc_type_lookup
3937 #define bfd_elf32_bfd_reloc_name_lookup elf_s390_reloc_name_lookup
3938
3939 #define bfd_elf32_bfd_merge_private_bfd_data elf32_s390_merge_private_bfd_data
3940
3941 #define elf_backend_adjust_dynamic_symbol elf_s390_adjust_dynamic_symbol
3942 #define elf_backend_check_relocs elf_s390_check_relocs
3943 #define elf_backend_copy_indirect_symbol elf_s390_copy_indirect_symbol
3944 #define elf_backend_create_dynamic_sections elf_s390_create_dynamic_sections
3945 #define elf_backend_finish_dynamic_sections elf_s390_finish_dynamic_sections
3946 #define elf_backend_finish_dynamic_symbol elf_s390_finish_dynamic_symbol
3947 #define elf_backend_gc_mark_hook elf_s390_gc_mark_hook
3948 #define elf_backend_gc_sweep_hook elf_s390_gc_sweep_hook
3949 #define elf_backend_reloc_type_class elf_s390_reloc_type_class
3950 #define elf_backend_relocate_section elf_s390_relocate_section
3951 #define elf_backend_size_dynamic_sections elf_s390_size_dynamic_sections
3952 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
3953 #define elf_backend_reloc_type_class elf_s390_reloc_type_class
3954 #define elf_backend_grok_prstatus elf_s390_grok_prstatus
3955 #define elf_backend_plt_sym_val elf_s390_plt_sym_val
3956 #define elf_backend_add_symbol_hook elf_s390_add_symbol_hook
3957
3958 #define bfd_elf32_mkobject elf_s390_mkobject
3959 #define elf_backend_object_p elf_s390_object_p
3960
3961 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.184378 seconds and 5 git commands to generate.