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