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