projects / deliverable / binutils-gdb.git / blob
? search:


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