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