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