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