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