projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* som.c (som_write_symbol_strings): Cast current_offset in
[deliverable/binutils-gdb.git] / bfd / elf32-s390.c
CommitLineData
a85d7ed0 1/* IBM S/390-specific support for 32-bit ELF
7898deda 2 Copyright 2000, 2001 Free Software Foundation, Inc.
a85d7ed0
NC		 3 Contributed by Carl B. Pedersen and Martin Schwidefsky.
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 *));
32static boolean elf_s390_is_local_label_name PARAMS ((bfd *, const char *));
33static struct bfd_hash_entry *elf_s390_link_hash_newfunc
34 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
35static struct bfd_link_hash_table *elf_s390_link_hash_table_create
36 PARAMS ((bfd *));
37static boolean elf_s390_check_relocs
38 PARAMS ((bfd *, struct bfd_link_info *, asection *,
39 const Elf_Internal_Rela *));
5a65713f
AJ		 40static asection *elf_s390_gc_mark_hook
41 PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
42 struct elf_link_hash_entry *, Elf_Internal_Sym *sym));
43static boolean elf_s390_gc_sweep_hook
44 PARAMS ((bfd *, struct bfd_link_info *, asection *,
45 const Elf_Internal_Rela *));
a85d7ed0
NC		 46static boolean elf_s390_adjust_dynamic_symbol
47 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
48static boolean elf_s390_size_dynamic_sections
49 PARAMS ((bfd *, struct bfd_link_info *));
50static boolean elf_s390_relocate_section
51 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
52 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
53static boolean elf_s390_finish_dynamic_symbol
54 PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
55 Elf_Internal_Sym *));
56static boolean elf_s390_finish_dynamic_sections
57 PARAMS ((bfd *, struct bfd_link_info *));
5a65713f 58static boolean elf_s390_object_p PARAMS ((bfd *));
f51e552e
AM		 59static enum elf_reloc_type_class elf_s390_reloc_type_class
60 PARAMS ((const Elf_Internal_Rela *));
a85d7ed0
NC		 61
62#define USE_RELA 1 /* We want RELA relocations, not REL. */
63
64#include "elf/s390.h"
65
66/* The relocation "howto" table. */
67
68static reloc_howto_type elf_howto_table[] =
69{
70 HOWTO (R_390_NONE, /* type */
71 0, /* rightshift */
72 0, /* size (0 = byte, 1 = short, 2 = long) */
73 0, /* bitsize */
74 false, /* pc_relative */
75 0, /* bitpos */
76 complain_overflow_dont, /* complain_on_overflow */
77 bfd_elf_generic_reloc, /* special_function */
78 "R_390_NONE", /* name */
79 false, /* partial_inplace */
80 0, /* src_mask */
81 0, /* dst_mask */
82 false), /* pcrel_offset */
83
84 HOWTO(R_390_8, 0, 0, 8, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_8", false, 0,0x000000ff, false),
85 HOWTO(R_390_12, 0, 1, 12, false, 0, complain_overflow_dont, bfd_elf_generic_reloc, "R_390_12", false, 0,0x00000fff, false),
86 HOWTO(R_390_16, 0, 1, 16, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_16", false, 0,0x0000ffff, false),
87 HOWTO(R_390_32, 0, 2, 32, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_32", false, 0,0xffffffff, false),
88 HOWTO(R_390_PC32, 0, 2, 32, true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PC32", false, 0,0xffffffff, true),
89 HOWTO(R_390_GOT12, 0, 1, 12, false, 0, complain_overflow_dont, bfd_elf_generic_reloc, "R_390_GOT12", false, 0,0x00000fff, false),
90 HOWTO(R_390_GOT32, 0, 2, 32, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GOT32", false, 0,0xffffffff, false),
91 HOWTO(R_390_PLT32, 0, 2, 32, true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PLT32", false, 0,0xffffffff, true),
92 HOWTO(R_390_COPY, 0, 2, 32, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_COPY", false, 0,0xffffffff, false),
93 HOWTO(R_390_GLOB_DAT, 0, 2, 32, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GLOB_DAT",false, 0,0xffffffff, false),
94 HOWTO(R_390_JMP_SLOT, 0, 2, 32, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_JMP_SLOT",false, 0,0xffffffff, false),
95 HOWTO(R_390_RELATIVE, 0, 2, 32, true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_RELATIVE",false, 0,0xffffffff, false),
96 HOWTO(R_390_GOTOFF, 0, 2, 32, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GOTOFF", false, 0,0xffffffff, false),
97 HOWTO(R_390_GOTPC, 0, 2, 32, true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GOTPC", false, 0,0xffffffff, true),
98 HOWTO(R_390_GOT16, 0, 1, 16, false, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_GOT16", false, 0,0x0000ffff, false),
99 HOWTO(R_390_PC16, 0, 1, 16, true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PC16", false, 0,0x0000ffff, true),
100 HOWTO(R_390_PC16DBL, 1, 1, 16, true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PC16DBL", false, 0,0x0000ffff, true),
101 HOWTO(R_390_PLT16DBL, 1, 1, 16, true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_390_PLT16DBL", false, 0,0x0000ffff, true),
102};
103
104/* GNU extension to record C++ vtable hierarchy. */
105static reloc_howto_type elf32_s390_vtinherit_howto =
106 HOWTO (R_390_GNU_VTINHERIT, 0,2,0,false,0,complain_overflow_dont, NULL, "R_390_GNU_VTINHERIT", false,0, 0, false);
107static reloc_howto_type elf32_s390_vtentry_howto =
dc810e39 108 HOWTO (R_390_GNU_VTENTRY, 0,2,0,false,0,complain_overflow_dont, _bfd_elf_rel_vtable_reloc_fn,"R_390_GNU_VTENTRY", false,0,0, false);
a85d7ed0
NC		 109
110static reloc_howto_type *
111elf_s390_reloc_type_lookup (abfd, code)
112 bfd *abfd ATTRIBUTE_UNUSED;
113 bfd_reloc_code_real_type code;
114{
115 switch (code) {
116 case BFD_RELOC_NONE:
117 return &elf_howto_table[(int) R_390_NONE];
118 case BFD_RELOC_8:
119 return &elf_howto_table[(int) R_390_8];
120 case BFD_RELOC_390_12:
121 return &elf_howto_table[(int) R_390_12];
122 case BFD_RELOC_16:
123 return &elf_howto_table[(int) R_390_16];
124 case BFD_RELOC_32:
125 return &elf_howto_table[(int) R_390_32];
126 case BFD_RELOC_CTOR:
127 return &elf_howto_table[(int) R_390_32];
128 case BFD_RELOC_32_PCREL:
129 return &elf_howto_table[(int) R_390_PC32];
130 case BFD_RELOC_390_GOT12:
131 return &elf_howto_table[(int) R_390_GOT12];
132 case BFD_RELOC_32_GOT_PCREL:
133 return &elf_howto_table[(int) R_390_GOT32];
134 case BFD_RELOC_390_PLT32:
135 return &elf_howto_table[(int) R_390_PLT32];
136 case BFD_RELOC_390_COPY:
137 return &elf_howto_table[(int) R_390_COPY];
138 case BFD_RELOC_390_GLOB_DAT:
139 return &elf_howto_table[(int) R_390_GLOB_DAT];
140 case BFD_RELOC_390_JMP_SLOT:
141 return &elf_howto_table[(int) R_390_JMP_SLOT];
142 case BFD_RELOC_390_RELATIVE:
143 return &elf_howto_table[(int) R_390_RELATIVE];
144 case BFD_RELOC_32_GOTOFF:
145 return &elf_howto_table[(int) R_390_GOTOFF];
146 case BFD_RELOC_390_GOTPC:
147 return &elf_howto_table[(int) R_390_GOTPC];
148 case BFD_RELOC_390_GOT16:
149 return &elf_howto_table[(int) R_390_GOT16];
150 case BFD_RELOC_16_PCREL:
151 return &elf_howto_table[(int) R_390_PC16];
152 case BFD_RELOC_390_PC16DBL:
153 return &elf_howto_table[(int) R_390_PC16DBL];
154 case BFD_RELOC_390_PLT16DBL:
155 return &elf_howto_table[(int) R_390_PLT16DBL];
156 case BFD_RELOC_VTABLE_INHERIT:
157 return &elf32_s390_vtinherit_howto;
158 case BFD_RELOC_VTABLE_ENTRY:
159 return &elf32_s390_vtentry_howto;
160 default:
dc810e39 161 break;
a85d7ed0
NC		 162 }
163 return 0;
164}
165
166/* We need to use ELF32_R_TYPE so we have our own copy of this function,
167 and elf32-s390.c has its own copy. */
168
169static void
170elf_s390_info_to_howto (abfd, cache_ptr, dst)
171 bfd *abfd ATTRIBUTE_UNUSED;
172 arelent *cache_ptr;
173 Elf_Internal_Rela *dst;
174{
175 switch (ELF32_R_TYPE(dst->r_info))
176 {
177 case R_390_GNU_VTINHERIT:
178 cache_ptr->howto = &elf32_s390_vtinherit_howto;
179 break;
180
181 case R_390_GNU_VTENTRY:
182 cache_ptr->howto = &elf32_s390_vtentry_howto;
183 break;
184
185 default:
186 BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_390_max);
187 cache_ptr->howto = &elf_howto_table[ELF32_R_TYPE(dst->r_info)];
dc810e39 188 }
a85d7ed0
NC		 189}
190
191static boolean
192elf_s390_is_local_label_name (abfd, name)
193 bfd *abfd;
194 const char *name;
195{
196 if (name[0] == '.' && (name[1] == 'X' || name[1] == 'L'))
197 return true;
198
199 return _bfd_elf_is_local_label_name (abfd, name);
200}
201
202/* Functions for the 390 ELF linker. */
203
204/* The name of the dynamic interpreter. This is put in the .interp
205 section. */
206
207#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
208
209/* The nop opcode we use. */
210
211#define s390_NOP 0x07070707
212
213
214/* The size in bytes of the first entry in the procedure linkage table. */
215#define PLT_FIRST_ENTRY_SIZE 32
216/* The size in bytes of an entry in the procedure linkage table. */
dc810e39 217#define PLT_ENTRY_SIZE 32
a85d7ed0
NC		 218
219#define GOT_ENTRY_SIZE 4
220
221/* The first three entries in a procedure linkage table are reserved,
222 and the initial contents are unimportant (we zero them out).
223 Subsequent entries look like this. See the SVR4 ABI 386
224 supplement to see how this works. */
225
226/* For the s390, simple addr offset can only be 0 - 4096.
227 To use the full 2 GB address space, several instructions
228 are needed to load an address in a register and execute
229 a branch( or just saving the address)
230
dc810e39 231 Furthermore, only r 0 and 1 are free to use!!! */
a85d7ed0
NC		 232
233/* The first 3 words in the GOT are then reserved.
234 Word 0 is the address of the dynamic table.
235 Word 1 is a pointer to a structure describing the object
236 Word 2 is used to point to the loader entry address.
237
238 The code for position independand PLT entries looks like this:
239
240 r12 holds addr of the current GOT at entry to the PLT
241
242 The GOT holds the address in the PLT to be executed.
243 The loader then gets:
244 24(15) = Pointer to the structure describing the object.
dc810e39 245 28(15) = Offset in symbol table
a85d7ed0
NC		 246
247 The loader must then find the module where the function is
248 and insert the address in the GOT.
249
250 Note: 390 can only address +- 64 K relative.
251 We check if offset > 65536, then make a relative branch -64xxx
252 back to a previous defined branch
253
254PLT1: BASR 1,0 # 2 bytes
255 L 1,22(1) # 4 bytes Load offset in GOT in r 1
256 L 1,(1,12) # 4 bytes Load address from GOT in r1
257 BCR 15,1 # 2 bytes Jump to address
258RET1: BASR 1,0 # 2 bytes Return from GOT 1st time
259 L 1,14(1) # 4 bytes Load offset in symol table in r1
260 BRC 15,-x # 4 bytes Jump to start of PLT
261 .word 0 # 2 bytes filler
262 .long ? # 4 bytes offset in GOT
263 .long ? # 4 bytes offset into symbol table
264
265 This was the general case. There are two additional, optimizes PLT
266 definitions. One for GOT offsets < 4096 and one for GOT offsets < 32768.
267 First the one for GOT offsets < 4096:
268
269PLT1: L 1,<offset>(12) # 4 bytes Load address from GOT in R1
270 BCR 15,1 # 2 bytes Jump to address
271 .word 0,0,0 # 6 bytes filler
272RET1: BASR 1,0 # 2 bytes Return from GOT 1st time
273 L 1,14(1) # 4 bytes Load offset in symbol table in r1
274 BRC 15,-x # 4 bytes Jump to start of PLT
275 .word 0,0,0 # 6 bytes filler
276 .long ? # 4 bytes offset into symbol table
277
278 Second the one for GOT offsets < 32768:
279
280PLT1: LHI 1,<offset> # 4 bytes Load offset in GOT to r1
281 L 1,(1,12) # 4 bytes Load address from GOT to r1
282 BCR 15,1 # 2 bytes Jump to address
283 .word 0 # 2 bytes filler
284RET1: BASR 1,0 # 2 bytes Return from GOT 1st time
285 L 1,14(1) # 4 bytes Load offset in symbol table in r1
286 BRC 15,-x # 4 bytes Jump to start of PLT
287 .word 0,0,0 # 6 bytes filler
288 .long ? # 4 bytes offset into symbol table
289
290Total = 32 bytes per PLT entry
291
292 The code for static build PLT entries looks like this:
293
294PLT1: BASR 1,0 # 2 bytes
295 L 1,22(1) # 4 bytes Load address of GOT entry
296 L 1,0(0,1) # 4 bytes Load address from GOT in r1
297 BCR 15,1 # 2 bytes Jump to address
298RET1: BASR 1,0 # 2 bytes Return from GOT 1st time
299 L 1,14(1) # 4 bytes Load offset in symbol table in r1
300 BRC 15,-x # 4 bytes Jump to start of PLT
301 .word 0 # 2 bytes filler
302 .long ? # 4 bytes address of GOT entry
303 .long ? # 4 bytes offset into symbol table */
304
305#define PLT_PIC_ENTRY_WORD0 0x0d105810
306#define PLT_PIC_ENTRY_WORD1 0x10165811
307#define PLT_PIC_ENTRY_WORD2 0xc00007f1
308#define PLT_PIC_ENTRY_WORD3 0x0d105810
309#define PLT_PIC_ENTRY_WORD4 0x100ea7f4
310
311#define PLT_PIC12_ENTRY_WORD0 0x5810c000
312#define PLT_PIC12_ENTRY_WORD1 0x07f10000
313#define PLT_PIC12_ENTRY_WORD2 0x00000000
314#define PLT_PIC12_ENTRY_WORD3 0x0d105810
315#define PLT_PIC12_ENTRY_WORD4 0x100ea7f4
316
317#define PLT_PIC16_ENTRY_WORD0 0xa7180000
318#define PLT_PIC16_ENTRY_WORD1 0x5811c000
319#define PLT_PIC16_ENTRY_WORD2 0x07f10000
320#define PLT_PIC16_ENTRY_WORD3 0x0d105810
321#define PLT_PIC16_ENTRY_WORD4 0x100ea7f4
322
323#define PLT_ENTRY_WORD0 0x0d105810
324#define PLT_ENTRY_WORD1 0x10165810
325#define PLT_ENTRY_WORD2 0x100007f1
326#define PLT_ENTRY_WORD3 0x0d105810
327#define PLT_ENTRY_WORD4 0x100ea7f4
328
329/* The first PLT entry pushes the offset into the symbol table
330 from R1 onto the stack at 8(15) and the loader object info
331 at 12(15), loads the loader address in R1 and jumps to it. */
332
333/* The first entry in the PLT for PIC code:
334
335PLT0:
336 ST 1,28(15) # R1 has offset into symbol table
337 L 1,4(12) # Get loader ino(object struct address)
dc810e39 338 ST 1,24(15) # Store address
a85d7ed0
NC		 339 L 1,8(12) # Entry address of loader in R1
340 BR 1 # Jump to loader
341
342 The first entry in the PLT for static code:
343
344PLT0:
345 ST 1,28(15) # R1 has offset into symbol table
346 BASR 1,0
347 L 1,18(0,1) # Get address of GOT
348 MVC 24(4,15),4(1) # Move loader ino to stack
349 L 1,8(1) # Get address of loader
350 BR 1 # Jump to loader
351 .word 0 # filler
352 .long got # address of GOT */
353
354#define PLT_PIC_FIRST_ENTRY_WORD0 0x5010f01c
355#define PLT_PIC_FIRST_ENTRY_WORD1 0x5810c004
356#define PLT_PIC_FIRST_ENTRY_WORD2 0x5010f018
357#define PLT_PIC_FIRST_ENTRY_WORD3 0x5810c008
358#define PLT_PIC_FIRST_ENTRY_WORD4 0x07f10000
359
360#define PLT_FIRST_ENTRY_WORD0 0x5010f01c
361#define PLT_FIRST_ENTRY_WORD1 0x0d105810
362#define PLT_FIRST_ENTRY_WORD2 0x1012D203
363#define PLT_FIRST_ENTRY_WORD3 0xf0181004
364#define PLT_FIRST_ENTRY_WORD4 0x58101008
365#define PLT_FIRST_ENTRY_WORD5 0x07f10000
366
367/* The s390 linker needs to keep track of the number of relocs that it
368 decides to copy in check_relocs for each symbol. This is so that
369 it can discard PC relative relocs if it doesn't need them when
370 linking with -Bsymbolic. We store the information in a field
371 extending the regular ELF linker hash table. */
372
373/* This structure keeps track of the number of PC relative relocs we
374 have copied for a given symbol. */
375
376struct elf_s390_pcrel_relocs_copied
377{
378 /* Next section. */
379 struct elf_s390_pcrel_relocs_copied *next;
380 /* A section in dynobj. */
381 asection *section;
382 /* Number of relocs copied in this section. */
383 bfd_size_type count;
384};
385
386/* s390 ELF linker hash entry. */
387
388struct elf_s390_link_hash_entry
389{
390 struct elf_link_hash_entry root;
391
392 /* Number of PC relative relocs copied for this symbol. */
393 struct elf_s390_pcrel_relocs_copied *pcrel_relocs_copied;
394};
395
396/* s390 ELF linker hash table. */
397
398struct elf_s390_link_hash_table
399{
400 struct elf_link_hash_table root;
401};
402
403/* Declare this now that the above structures are defined. */
404
405static boolean elf_s390_discard_copies
406 PARAMS ((struct elf_s390_link_hash_entry *, PTR));
407
408/* Traverse an s390 ELF linker hash table. */
409
410#define elf_s390_link_hash_traverse(table, func, info) \
411 (elf_link_hash_traverse \
412 (&(table)->root, \
413 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
414 (info)))
415
416/* Get the s390 ELF linker hash table from a link_info structure. */
417
418#define elf_s390_hash_table(p) \
419 ((struct elf_s390_link_hash_table *) ((p)->hash))
420
421/* Create an entry in an s390 ELF linker hash table. */
422
423static struct bfd_hash_entry *
424elf_s390_link_hash_newfunc (entry, table, string)
425 struct bfd_hash_entry *entry;
426 struct bfd_hash_table *table;
427 const char *string;
428{
429 struct elf_s390_link_hash_entry *ret =
430 (struct elf_s390_link_hash_entry *) entry;
431
432 /* Allocate the structure if it has not already been allocated by a
433 subclass. */
434 if (ret == (struct elf_s390_link_hash_entry *) NULL)
435 ret = ((struct elf_s390_link_hash_entry *)
436 bfd_hash_allocate (table,
437 sizeof (struct elf_s390_link_hash_entry)));
438 if (ret == (struct elf_s390_link_hash_entry *) NULL)
439 return (struct bfd_hash_entry *) ret;
440
441 /* Call the allocation method of the superclass. */
442 ret = ((struct elf_s390_link_hash_entry *)
443 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
444 table, string));
445 if (ret != (struct elf_s390_link_hash_entry *) NULL)
446 {
447 ret->pcrel_relocs_copied = NULL;
448 }
449
450 return (struct bfd_hash_entry *) ret;
451}
452
453/* Create an s390 ELF linker hash table. */
454
455static struct bfd_link_hash_table *
456elf_s390_link_hash_table_create (abfd)
457 bfd *abfd;
458{
459 struct elf_s390_link_hash_table *ret;
dc810e39 460 bfd_size_type amt = sizeof (struct elf_s390_link_hash_table);
a85d7ed0 461
dc810e39 462 ret = (struct elf_s390_link_hash_table *) bfd_alloc (abfd, amt);
a85d7ed0
NC		 463 if (ret == (struct elf_s390_link_hash_table *) NULL)
464 return NULL;
465
466 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
467 elf_s390_link_hash_newfunc))
468 {
469 bfd_release (abfd, ret);
470 return NULL;
471 }
472
473 return &ret->root.root;
474}
475
476
477/* Look through the relocs for a section during the first phase, and
478 allocate space in the global offset table or procedure linkage
479 table. */
480
481static boolean
482elf_s390_check_relocs (abfd, info, sec, relocs)
483 bfd *abfd;
484 struct bfd_link_info *info;
485 asection *sec;
486 const Elf_Internal_Rela *relocs;
487{
488 bfd *dynobj;
489 Elf_Internal_Shdr *symtab_hdr;
490 struct elf_link_hash_entry **sym_hashes;
491 bfd_signed_vma *local_got_refcounts;
492 const Elf_Internal_Rela *rel;
493 const Elf_Internal_Rela *rel_end;
494 asection *sgot;
495 asection *srelgot;
496 asection *sreloc;
497
498 if (info->relocateable)
499 return true;
500
501 dynobj = elf_hash_table (info)->dynobj;
502 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
503 sym_hashes = elf_sym_hashes (abfd);
504 local_got_refcounts = elf_local_got_offsets (abfd);
505
506 sgot = NULL;
507 srelgot = NULL;
508 sreloc = NULL;
509
510 rel_end = relocs + sec->reloc_count;
511 for (rel = relocs; rel < rel_end; rel++)
512 {
513 unsigned long r_symndx;
514 struct elf_link_hash_entry *h;
515
516 r_symndx = ELF32_R_SYM (rel->r_info);
517
518 if (r_symndx < symtab_hdr->sh_info)
519 h = NULL;
520 else
dc810e39 521 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
a85d7ed0
NC		 522
523 /* Some relocs require a global offset table. */
524 if (dynobj == NULL)
525 {
526 switch (ELF32_R_TYPE (rel->r_info))
527 {
528 case R_390_GOT12:
529 case R_390_GOT16:
530 case R_390_GOT32:
531 case R_390_GOTOFF:
532 case R_390_GOTPC:
533 elf_hash_table (info)->dynobj = dynobj = abfd;
534 if (! _bfd_elf_create_got_section (dynobj, info))
535 return false;
536 break;
537
538 default:
539 break;
540 }
541 }
542
543
544 switch (ELF32_R_TYPE (rel->r_info))
545 {
546 case R_390_GOT12:
547 case R_390_GOT16:
548 case R_390_GOT32:
549 /* This symbol requires a global offset table entry. */
550
551 if (sgot == NULL)
552 {
553 sgot = bfd_get_section_by_name (dynobj, ".got");
554 BFD_ASSERT (sgot != NULL);
555 }
556
557
558 if (srelgot == NULL
559 && (h != NULL || info->shared))
560 {
561 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
562 if (srelgot == NULL)
563 {
564 srelgot = bfd_make_section (dynobj, ".rela.got");
565 if (srelgot == NULL
566 || ! bfd_set_section_flags (dynobj, srelgot,
567 (SEC_ALLOC
568 | SEC_LOAD
569 | SEC_HAS_CONTENTS
570 | SEC_IN_MEMORY
571 | SEC_LINKER_CREATED
572 | SEC_READONLY))
573 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
574 return false;
575 }
576 }
577
578 if (h != NULL)
579 {
580 if (h->got.refcount == -1)
581 {
582 h->got.refcount = 1;
583
584 /* Make sure this symbol is output as a dynamic symbol. */
585 if (h->dynindx == -1)
586 {
587 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
588 return false;
589 }
590
591 sgot->_raw_size += 4;
592 srelgot->_raw_size += sizeof (Elf32_External_Rela);
593 }
594 else
595 h->got.refcount += 1;
596 }
597 else
598 {
599 /* This is a global offset table entry for a local symbol. */
600 if (local_got_refcounts == NULL)
601 {
dc810e39 602 bfd_size_type size;
a85d7ed0 603
dc810e39
AM		 604 size = symtab_hdr->sh_info;
605 size *= sizeof (bfd_signed_vma);
a85d7ed0
NC		 606 local_got_refcounts = (bfd_signed_vma *)
607 bfd_alloc (abfd, size);
608 if (local_got_refcounts == NULL)
609 return false;
610 elf_local_got_refcounts (abfd) = local_got_refcounts;
dc810e39 611 memset (local_got_refcounts, -1, (size_t) size);
a85d7ed0
NC		 612 }
613 if (local_got_refcounts[r_symndx] == -1)
614 {
615 local_got_refcounts[r_symndx] = 1;
616
617 sgot->_raw_size += 4;
618 if (info->shared)
619 {
620 /* If we are generating a shared object, we need to
621 output a R_390_RELATIVE reloc so that the dynamic
622 linker can adjust this GOT entry. */
623 srelgot->_raw_size += sizeof (Elf32_External_Rela);
624 }
625 }
626 else
627 local_got_refcounts[r_symndx] += 1;
628 }
629 break;
630
631 case R_390_PLT16DBL:
632 case R_390_PLT32:
633 /* This symbol requires a procedure linkage table entry. We
634 actually build the entry in adjust_dynamic_symbol,
635 because this might be a case of linking PIC code which is
636 never referenced by a dynamic object, in which case we
637 don't need to generate a procedure linkage table entry
638 after all. */
639
640 /* If this is a local symbol, we resolve it directly without
641 creating a procedure linkage table entry. */
642 if (h == NULL)
643 continue;
644
645 if (h->plt.refcount == -1)
646 {
647 h->plt.refcount = 1;
648 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
649 }
650 else
651 h->plt.refcount += 1;
652 break;
653
654 case R_390_8:
655 case R_390_16:
656 case R_390_32:
657 case R_390_PC16:
658 case R_390_PC16DBL:
659 case R_390_PC32:
660 if (h != NULL)
661 h->elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
662
663 /* If we are creating a shared library, and this is a reloc
664 against a global symbol, or a non PC relative reloc
665 against a local symbol, then we need to copy the reloc
666 into the shared library. However, if we are linking with
667 -Bsymbolic, we do not need to copy a reloc against a
668 global symbol which is defined in an object we are
669 including in the link (i.e., DEF_REGULAR is set). At
670 this point we have not seen all the input files, so it is
671 possible that DEF_REGULAR is not set now but will be set
672 later (it is never cleared). We account for that
673 possibility below by storing information in the
674 pcrel_relocs_copied field of the hash table entry. */
675 if (info->shared
676 && (sec->flags & SEC_ALLOC) != 0
677 && ((ELF32_R_TYPE (rel->r_info) != R_390_PC16 &&
678 ELF32_R_TYPE (rel->r_info) != R_390_PC16DBL &&
679 ELF32_R_TYPE (rel->r_info) != R_390_PC32)
680 || (h != NULL
681 && (! info->symbolic
682 || (h->elf_link_hash_flags
683 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
684 {
685 /* When creating a shared object, we must copy these
686 reloc types into the output file. We create a reloc
687 section in dynobj and make room for this reloc. */
688 if (sreloc == NULL)
689 {
690 const char *name;
691
692 name = (bfd_elf_string_from_elf_section
693 (abfd,
694 elf_elfheader (abfd)->e_shstrndx,
695 elf_section_data (sec)->rel_hdr.sh_name));
696 if (name == NULL)
697 return false;
698
699 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
700 && strcmp (bfd_get_section_name (abfd, sec),
701 name + 5) == 0);
702
703 sreloc = bfd_get_section_by_name (dynobj, name);
704 if (sreloc == NULL)
705 {
706 flagword flags;
707
708 sreloc = bfd_make_section (dynobj, name);
709 flags = (SEC_HAS_CONTENTS | SEC_READONLY
710 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
711 if ((sec->flags & SEC_ALLOC) != 0)
712 flags |= SEC_ALLOC | SEC_LOAD;
713 if (sreloc == NULL
714 || ! bfd_set_section_flags (dynobj, sreloc, flags)
715 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
716 return false;
717 }
29c2fb7c
AJ		 718 if (sec->flags & SEC_READONLY)
719 info->flags |= DF_TEXTREL;
a85d7ed0
NC		 720 }
721
722 sreloc->_raw_size += sizeof (Elf32_External_Rela);
723
724 /* If we are linking with -Bsymbolic, and this is a
725 global symbol, we count the number of PC relative
726 relocations we have entered for this symbol, so that
727 we can discard them again if the symbol is later
728 defined by a regular object. Note that this function
729 is only called if we are using an elf_s390 linker
730 hash table, which means that h is really a pointer to
731 an elf_s390_link_hash_entry. */
732 if (h != NULL
733 && (ELF32_R_TYPE (rel->r_info) == R_390_PC16 ||
734 ELF32_R_TYPE (rel->r_info) == R_390_PC16DBL ||
735 ELF32_R_TYPE (rel->r_info) == R_390_PC32))
736 {
737 struct elf_s390_link_hash_entry *eh;
738 struct elf_s390_pcrel_relocs_copied *p;
739
740 eh = (struct elf_s390_link_hash_entry *) h;
741
742 for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
743 if (p->section == sreloc)
744 break;
745
746 if (p == NULL)
747 {
748 p = ((struct elf_s390_pcrel_relocs_copied *)
dc810e39 749 bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
a85d7ed0
NC		 750 if (p == NULL)
751 return false;
752 p->next = eh->pcrel_relocs_copied;
753 eh->pcrel_relocs_copied = p;
754 p->section = sreloc;
755 p->count = 0;
756 }
757
758 ++p->count;
759 }
760 }
761
762 break;
763
764 /* This relocation describes the C++ object vtable hierarchy.
765 Reconstruct it for later use during GC. */
766 case R_390_GNU_VTINHERIT:
767 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
768 return false;
769 break;
770
771 /* This relocation describes which C++ vtable entries are actually
772 used. Record for later use during GC. */
773 case R_390_GNU_VTENTRY:
774 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
775 return false;
776 break;
dc810e39 777
a85d7ed0
NC		 778 default:
779 break;
780 }
781 }
782
783 return true;
784}
785
786/* Return the section that should be marked against GC for a given
787 relocation. */
788
789static asection *
790elf_s390_gc_mark_hook (abfd, info, rel, h, sym)
791 bfd *abfd;
792 struct bfd_link_info *info ATTRIBUTE_UNUSED;
793 Elf_Internal_Rela *rel;
794 struct elf_link_hash_entry *h;
795 Elf_Internal_Sym *sym;
796{
797 if (h != NULL)
798 {
799 switch (ELF32_R_TYPE (rel->r_info))
800 {
801 case R_390_GNU_VTINHERIT:
802 case R_390_GNU_VTENTRY:
803 break;
804
805 default:
806 switch (h->root.type)
807 {
808 case bfd_link_hash_defined:
809 case bfd_link_hash_defweak:
810 return h->root.u.def.section;
811
812 case bfd_link_hash_common:
813 return h->root.u.c.p->section;
814
815 default:
816 break;
817 }
818 }
819 }
820 else
821 {
822 if (!(elf_bad_symtab (abfd)
823 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
824 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
825 && sym->st_shndx != SHN_COMMON))
826 {
827 return bfd_section_from_elf_index (abfd, sym->st_shndx);
828 }
829 }
830
831 return NULL;
832}
833
834/* Update the got entry reference counts for the section being removed. */
835
836static boolean
837elf_s390_gc_sweep_hook (abfd, info, sec, relocs)
838 bfd *abfd ATTRIBUTE_UNUSED;
839 struct bfd_link_info *info ATTRIBUTE_UNUSED;
840 asection *sec ATTRIBUTE_UNUSED;
841 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
842{
843 Elf_Internal_Shdr *symtab_hdr;
844 struct elf_link_hash_entry **sym_hashes;
845 bfd_signed_vma *local_got_refcounts;
846 const Elf_Internal_Rela *rel, *relend;
847 unsigned long r_symndx;
848 struct elf_link_hash_entry *h;
849 bfd *dynobj;
850 asection *sgot;
851 asection *srelgot;
852
853 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
854 sym_hashes = elf_sym_hashes (abfd);
855 local_got_refcounts = elf_local_got_refcounts (abfd);
856
857 dynobj = elf_hash_table (info)->dynobj;
858 if (dynobj == NULL)
859 return true;
860
861 sgot = bfd_get_section_by_name (dynobj, ".got");
862 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
863
864 relend = relocs + sec->reloc_count;
865 for (rel = relocs; rel < relend; rel++)
866 switch (ELF32_R_TYPE (rel->r_info))
867 {
868 case R_390_GOT12:
869 case R_390_GOT16:
870 case R_390_GOT32:
871 case R_390_GOTOFF:
872 case R_390_GOTPC:
873 r_symndx = ELF32_R_SYM (rel->r_info);
874 if (r_symndx >= symtab_hdr->sh_info)
875 {
876 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
877 if (h->got.refcount > 0)
878 {
879 h->got.refcount -= 1;
880 if (h->got.refcount == 0)
881 {
882 sgot->_raw_size -= 4;
883 srelgot->_raw_size -= sizeof (Elf32_External_Rela);
884 }
885 }
886 }
887 else if (local_got_refcounts != NULL)
888 {
889 if (local_got_refcounts[r_symndx] > 0)
890 {
891 local_got_refcounts[r_symndx] -= 1;
892 if (local_got_refcounts[r_symndx] == 0)
893 {
894 sgot->_raw_size -= 4;
895 if (info->shared)
896 srelgot->_raw_size -= sizeof (Elf32_External_Rela);
897 }
898 }
899 }
900 break;
901
902 case R_390_PLT16DBL:
903 case R_390_PLT32:
904 r_symndx = ELF32_R_SYM (rel->r_info);
905 if (r_symndx >= symtab_hdr->sh_info)
906 {
907 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
908 if (h->plt.refcount > 0)
909 h->plt.refcount -= 1;
910 }
911 break;
912
913 default:
914 break;
915 }
916
917 return true;
918}
919
920/* Adjust a symbol defined by a dynamic object and referenced by a
921 regular object. The current definition is in some section of the
922 dynamic object, but we're not including those sections. We have to
923 change the definition to something the rest of the link can
924 understand. */
925
926static boolean
927elf_s390_adjust_dynamic_symbol (info, h)
928 struct bfd_link_info *info;
929 struct elf_link_hash_entry *h;
930{
931 bfd *dynobj;
932 asection *s;
933 unsigned int power_of_two;
934
935 dynobj = elf_hash_table (info)->dynobj;
936
937 /* Make sure we know what is going on here. */
938 BFD_ASSERT (dynobj != NULL
939 && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
940 || h->weakdef != NULL
941 || ((h->elf_link_hash_flags
942 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
943 && (h->elf_link_hash_flags
944 & ELF_LINK_HASH_REF_REGULAR) != 0
945 && (h->elf_link_hash_flags
946 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
947
948 /* If this is a function, put it in the procedure linkage table. We
949 will fill in the contents of the procedure linkage table later
950 (although we could actually do it here). */
951 if (h->type == STT_FUNC
952 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
953 {
954 if ((! info->shared
955 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
956 && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
957 || (info->shared && h->plt.refcount <= 0))
958 {
959 /* This case can occur if we saw a PLT32 reloc in an input
960 file, but the symbol was never referred to by a dynamic
961 object, or if all references were garbage collected. In
962 such a case, we don't actually need to build a procedure
963 linkage table, and we can just do a PC32 reloc instead. */
964 h->plt.offset = (bfd_vma) -1;
965 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
966 return true;
967 }
968
969 /* Make sure this symbol is output as a dynamic symbol. */
970 if (h->dynindx == -1)
971 {
972 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
973 return false;
974 }
975
976 s = bfd_get_section_by_name (dynobj, ".plt");
977 BFD_ASSERT (s != NULL);
978
979 /* The first entry in .plt is reserved. */
980 if (s->_raw_size == 0)
981 s->_raw_size = PLT_FIRST_ENTRY_SIZE;
982
983 /* If this symbol is not defined in a regular file, and we are
984 not generating a shared library, then set the symbol to this
985 location in the .plt. This is required to make function
986 pointers compare as equal between the normal executable and
987 the shared library. */
988 if (! info->shared
989 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
990 {
991 h->root.u.def.section = s;
992 h->root.u.def.value = s->_raw_size;
993 }
994
995 h->plt.offset = s->_raw_size;
996
997 /* Make room for this entry. */
998 s->_raw_size += PLT_ENTRY_SIZE;
999
1000 /* We also need to make an entry in the .got.plt section, which
1001 will be placed in the .got section by the linker script. */
1002 s = bfd_get_section_by_name (dynobj, ".got.plt");
1003 BFD_ASSERT (s != NULL);
1004 s->_raw_size += GOT_ENTRY_SIZE;
1005
1006 /* We also need to make an entry in the .rela.plt section. */
1007 s = bfd_get_section_by_name (dynobj, ".rela.plt");
1008 BFD_ASSERT (s != NULL);
1009 s->_raw_size += sizeof (Elf32_External_Rela);
1010
1011 return true;
1012 }
1013
1014 /* If this is a weak symbol, and there is a real definition, the
1015 processor independent code will have arranged for us to see the
1016 real definition first, and we can just use the same value. */
1017 if (h->weakdef != NULL)
1018 {
1019 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
1020 || h->weakdef->root.type == bfd_link_hash_defweak);
1021 h->root.u.def.section = h->weakdef->root.u.def.section;
1022 h->root.u.def.value = h->weakdef->root.u.def.value;
1023 return true;
1024 }
1025
1026 /* This is a reference to a symbol defined by a dynamic object which
1027 is not a function. */
1028
1029 /* If we are creating a shared library, we must presume that the
1030 only references to the symbol are via the global offset table.
1031 For such cases we need not do anything here; the relocations will
1032 be handled correctly by relocate_section. */
1033 if (info->shared)
1034 return true;
1035
1036 /* If there are no references to this symbol that do not use the
1037 GOT, we don't need to generate a copy reloc. */
1038 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1039 return true;
1040
1041 /* We must allocate the symbol in our .dynbss section, which will
1042 become part of the .bss section of the executable. There will be
1043 an entry for this symbol in the .dynsym section. The dynamic
1044 object will contain position independent code, so all references
1045 from the dynamic object to this symbol will go through the global
1046 offset table. The dynamic linker will use the .dynsym entry to
1047 determine the address it must put in the global offset table, so
1048 both the dynamic object and the regular object will refer to the
1049 same memory location for the variable. */
1050
1051 s = bfd_get_section_by_name (dynobj, ".dynbss");
1052 BFD_ASSERT (s != NULL);
1053
1054 /* We must generate a R_390_COPY reloc to tell the dynamic linker
1055 to copy the initial value out of the dynamic object and into the
1056 runtime process image. We need to remember the offset into the
1057 .rel.bss section we are going to use. */
1058 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1059 {
1060 asection *srel;
1061
1062 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
1063 BFD_ASSERT (srel != NULL);
1064 srel->_raw_size += sizeof (Elf32_External_Rela);
1065 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1066 }
1067
1068 /* We need to figure out the alignment required for this symbol. I
1069 have no idea how ELF linkers handle this. */
1070 power_of_two = bfd_log2 (h->size);
1071 if (power_of_two > 3)
1072 power_of_two = 3;
1073
1074 /* Apply the required alignment. */
1075 s->_raw_size = BFD_ALIGN (s->_raw_size,
1076 (bfd_size_type) (1 << power_of_two));
1077 if (power_of_two > bfd_get_section_alignment (dynobj, s))
1078 {
1079 if (! bfd_set_section_alignment (dynobj, s, power_of_two))
1080 return false;
1081 }
1082
1083 /* Define the symbol as being at this point in the section. */
1084 h->root.u.def.section = s;
1085 h->root.u.def.value = s->_raw_size;
1086
1087 /* Increment the section size to make room for the symbol. */
1088 s->_raw_size += h->size;
1089
1090 return true;
1091}
1092
1093/* Set the sizes of the dynamic sections. */
1094
1095static boolean
1096elf_s390_size_dynamic_sections (output_bfd, info)
29c2fb7c 1097 bfd *output_bfd ATTRIBUTE_UNUSED;
a85d7ed0
NC		 1098 struct bfd_link_info *info;
1099{
1100 bfd *dynobj;
1101 asection *s;
a85d7ed0
NC		 1102 boolean relocs;
1103 boolean plt;
1104
1105 dynobj = elf_hash_table (info)->dynobj;
1106 BFD_ASSERT (dynobj != NULL);
1107
1108 if (elf_hash_table (info)->dynamic_sections_created)
1109 {
1110 /* Set the contents of the .interp section to the interpreter. */
1111 if (! info->shared)
1112 {
1113 s = bfd_get_section_by_name (dynobj, ".interp");
1114 BFD_ASSERT (s != NULL);
1115 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
1116 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1117 }
1118 }
1119 else
1120 {
1121 /* We may have created entries in the .rela.got section.
1122 However, if we are not creating the dynamic sections, we will
1123 not actually use these entries. Reset the size of .rela.got,
1124 which will cause it to get stripped from the output file
1125 below. */
1126 s = bfd_get_section_by_name (dynobj, ".rela.got");
1127 if (s != NULL)
1128 s->_raw_size = 0;
1129 }
1130
1131 /* If this is a -Bsymbolic shared link, then we need to discard all
1132 PC relative relocs against symbols defined in a regular object.
1133 We allocated space for them in the check_relocs routine, but we
1134 will not fill them in in the relocate_section routine. */
1135 if (info->shared)
1136 elf_s390_link_hash_traverse (elf_s390_hash_table (info),
1137 elf_s390_discard_copies,
1138 (PTR) info);
1139
1140 /* The check_relocs and adjust_dynamic_symbol entry points have
1141 determined the sizes of the various dynamic sections. Allocate
1142 memory for them. */
1143 plt = false;
a85d7ed0
NC		 1144 relocs = false;
1145 for (s = dynobj->sections; s != NULL; s = s->next)
1146 {
1147 const char *name;
1148 boolean strip;
1149
1150 if ((s->flags & SEC_LINKER_CREATED) == 0)
1151 continue;
1152
1153 /* It's OK to base decisions on the section name, because none
1154 of the dynobj section names depend upon the input files. */
1155 name = bfd_get_section_name (dynobj, s);
1156
1157 strip = false;
1158
1159 if (strcmp (name, ".plt") == 0)
1160 {
1161 if (s->_raw_size == 0)
1162 {
1163 /* Strip this section if we don't need it; see the
1164 comment below. */
1165 strip = true;
1166 }
1167 else
1168 {
1169 /* Remember whether there is a PLT. */
1170 plt = true;
1171 }
1172 }
1173 else if (strncmp (name, ".rela", 5) == 0)
1174 {
1175 if (s->_raw_size == 0)
1176 {
1177 /* If we don't need this section, strip it from the
1178 output file. This is to handle .rela.bss and
1179 .rel.plt. We must create it in
1180 create_dynamic_sections, because it must be created
1181 before the linker maps input sections to output
1182 sections. The linker does that before
1183 adjust_dynamic_symbol is called, and it is that
1184 function which decides whether anything needs to go
1185 into these sections. */
1186 strip = true;
1187 }
1188 else
1189 {
a85d7ed0
NC		 1190 /* Remember whether there are any reloc sections other
1191 than .rela.plt. */
1192 if (strcmp (name, ".rela.plt") != 0)
29c2fb7c 1193 relocs = true;
a85d7ed0
NC		 1194
1195 /* We use the reloc_count field as a counter if we need
1196 to copy relocs into the output file. */
1197 s->reloc_count = 0;
1198 }
1199 }
1200 else if (strncmp (name, ".got", 4) != 0)
1201 {
1202 /* It's not one of our sections, so don't allocate space. */
1203 continue;
1204 }
1205
1206 if (strip)
1207 {
1208 _bfd_strip_section_from_output (info, s);
1209 continue;
1210 }
1211
1212 /* Allocate memory for the section contents. */
1213 s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
1214 if (s->contents == NULL && s->_raw_size != 0)
1215 return false;
1216 }
1217
1218 if (elf_hash_table (info)->dynamic_sections_created)
1219 {
1220 /* Add some entries to the .dynamic section. We fill in the
1221 values later, in elf_s390_finish_dynamic_sections, but we
1222 must add the entries now so that we get the correct size for
1223 the .dynamic section. The DT_DEBUG entry is filled in by the
1224 dynamic linker and used by the debugger. */
dc810e39
AM		 1225#define add_dynamic_entry(TAG, VAL) \
1226 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1227
a85d7ed0
NC		 1228 if (! info->shared)
1229 {
dc810e39 1230 if (!add_dynamic_entry (DT_DEBUG, 0))
a85d7ed0
NC		 1231 return false;
1232 }
1233
1234 if (plt)
1235 {
dc810e39
AM		 1236 if (!add_dynamic_entry (DT_PLTGOT, 0)
1237 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1238 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1239 || !add_dynamic_entry (DT_JMPREL, 0))
a85d7ed0
NC		 1240 return false;
1241 }
1242
1243 if (relocs)
1244 {
dc810e39
AM		 1245 if (!add_dynamic_entry (DT_RELA, 0)
1246 || !add_dynamic_entry (DT_RELASZ, 0)
1247 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
a85d7ed0
NC		 1248 return false;
1249 }
1250
29c2fb7c 1251 if ((info->flags & DF_TEXTREL) != 0)
a85d7ed0 1252 {
dc810e39 1253 if (!add_dynamic_entry (DT_TEXTREL, 0))
a85d7ed0
NC		 1254 return false;
1255 info->flags |= DF_TEXTREL;
1256 }
1257 }
dc810e39 1258#undef add_dynamic_entry
a85d7ed0
NC		 1259
1260 return true;
1261}
1262
1263/* This function is called via elf_s390_link_hash_traverse if we are
1264 creating a shared object with -Bsymbolic. It discards the space
1265 allocated to copy PC relative relocs against symbols which are
1266 defined in regular objects. We allocated space for them in the
1267 check_relocs routine, but we won't fill them in in the
1268 relocate_section routine. */
1269
1270/*ARGSUSED*/
1271static boolean
1272elf_s390_discard_copies (h, inf)
1273 struct elf_s390_link_hash_entry *h;
1274 PTR inf;
1275{
1276 struct elf_s390_pcrel_relocs_copied *s;
1277 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1278
1279 /* If a symbol has been forced local or we have found a regular
1280 definition for the symbolic link case, then we won't be needing
1281 any relocs. */
1282 if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1283 && ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
1284 || info->symbolic))
1285 {
1286 for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
1287 s->section->_raw_size -= s->count * sizeof (Elf32_External_Rela);
1288 }
1289 return true;
1290}
1291/* Relocate a 390 ELF section. */
1292
1293static boolean
1294elf_s390_relocate_section (output_bfd, info, input_bfd, input_section,
1295 contents, relocs, local_syms, local_sections)
1296 bfd *output_bfd;
1297 struct bfd_link_info *info;
1298 bfd *input_bfd;
1299 asection *input_section;
1300 bfd_byte *contents;
1301 Elf_Internal_Rela *relocs;
1302 Elf_Internal_Sym *local_syms;
1303 asection **local_sections;
1304{
1305 bfd *dynobj;
1306 Elf_Internal_Shdr *symtab_hdr;
1307 struct elf_link_hash_entry **sym_hashes;
1308 bfd_vma *local_got_offsets;
1309 asection *sgot;
1310 asection *splt;
1311 asection *sreloc;
1312 Elf_Internal_Rela *rel;
1313 Elf_Internal_Rela *relend;
1314
1315 dynobj = elf_hash_table (info)->dynobj;
1316 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1317 sym_hashes = elf_sym_hashes (input_bfd);
1318 local_got_offsets = elf_local_got_offsets (input_bfd);
1319
1320 sgot = NULL;
1321 splt = NULL;
1322 sreloc = NULL;
1323 if (dynobj != NULL)
1324 {
1325 splt = bfd_get_section_by_name (dynobj, ".plt");
1326 sgot = bfd_get_section_by_name (dynobj, ".got");
1327 }
1328
1329 rel = relocs;
1330 relend = relocs + input_section->reloc_count;
1331 for (; rel < relend; rel++)
1332 {
1333 int r_type;
1334 reloc_howto_type *howto;
1335 unsigned long r_symndx;
1336 struct elf_link_hash_entry *h;
1337 Elf_Internal_Sym *sym;
1338 asection *sec;
1339 bfd_vma relocation;
1340 bfd_reloc_status_type r;
1341
1342 r_type = ELF32_R_TYPE (rel->r_info);
1343 if (r_type == (int) R_390_GNU_VTINHERIT
1344 || r_type == (int) R_390_GNU_VTENTRY)
1345 continue;
1346 if (r_type < 0 || r_type >= (int) R_390_max)
1347 {
1348 bfd_set_error (bfd_error_bad_value);
1349 return false;
1350 }
1351 howto = elf_howto_table + r_type;
1352
1353 r_symndx = ELF32_R_SYM (rel->r_info);
1354
1355 if (info->relocateable)
1356 {
1357 /* This is a relocateable link. We don't have to change
1358 anything, unless the reloc is against a section symbol,
1359 in which case we have to adjust according to where the
1360 section symbol winds up in the output section. */
1361 if (r_symndx < symtab_hdr->sh_info)
1362 {
1363 sym = local_syms + r_symndx;
1364 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1365 {
1366 sec = local_sections[r_symndx];
1367 rel->r_addend += sec->output_offset + sym->st_value;
1368 }
1369 }
1370
1371 continue;
1372 }
1373
1374 /* This is a final link. */
1375 h = NULL;
1376 sym = NULL;
1377 sec = NULL;
1378 if (r_symndx < symtab_hdr->sh_info)
1379 {
1380 sym = local_syms + r_symndx;
1381 sec = local_sections[r_symndx];
1382 relocation = (sec->output_section->vma
1383 + sec->output_offset
1384 + sym->st_value);
1385 }
1386 else
1387 {
1388 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1389 while (h->root.type == bfd_link_hash_indirect
1390 || h->root.type == bfd_link_hash_warning)
1391 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1392 if (h->root.type == bfd_link_hash_defined
1393 || h->root.type == bfd_link_hash_defweak)
1394 {
1395 sec = h->root.u.def.section;
1396 if (r_type == R_390_GOTPC
1397 || ((r_type == R_390_PLT16DBL ||
1398 r_type == R_390_PLT32)
1399 && splt != NULL
1400 && h->plt.offset != (bfd_vma) -1)
1401 || ((r_type == R_390_GOT12 ||
1402 r_type == R_390_GOT16 ||
1403 r_type == R_390_GOT32)
1404 && elf_hash_table (info)->dynamic_sections_created
1405 && (! info->shared
1406 || (! info->symbolic && h->dynindx != -1)
1407 || (h->elf_link_hash_flags
1408 & ELF_LINK_HASH_DEF_REGULAR) == 0))
1409 || (info->shared
1410 && ((! info->symbolic && h->dynindx != -1)
1411 || (h->elf_link_hash_flags
1412 & ELF_LINK_HASH_DEF_REGULAR) == 0)
1413 && ( r_type == R_390_8 ||
1414 r_type == R_390_16 ||
1415 r_type == R_390_32 ||
1416 r_type == R_390_PC16 ||
1417 r_type == R_390_PC16DBL ||
1418 r_type == R_390_PC32)
1419 && ((input_section->flags & SEC_ALLOC) != 0
1420 /* DWARF will emit R_386_32 relocations in its
1421 sections against symbols defined externally
1422 in shared libraries. We can't do anything
1423 with them here. */
1424 || ((input_section->flags & SEC_DEBUGGING) != 0
1425 && (h->elf_link_hash_flags
1426 & ELF_LINK_HASH_DEF_DYNAMIC) != 0))))
1427 {
1428 /* In these cases, we don't need the relocation
1429 value. We check specially because in some
1430 obscure cases sec->output_section will be NULL. */
1431 relocation = 0;
1432 }
1433 else if (sec->output_section == NULL)
1434 {
1435 (*_bfd_error_handler)
1436 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
8f615d07 1437 bfd_archive_filename (input_bfd), h->root.root.string,
a85d7ed0
NC		 1438 bfd_get_section_name (input_bfd, input_section));
1439 relocation = 0;
1440 }
1441 else
1442 relocation = (h->root.u.def.value
1443 + sec->output_section->vma
1444 + sec->output_offset);
1445 }
1446 else if (h->root.type == bfd_link_hash_undefweak)
1447 relocation = 0;
671bae9c
NC		 1448 else if (info->shared
1449 && (!info->symbolic || info->allow_shlib_undefined)
a85d7ed0
NC		 1450 && !info->no_undefined
1451 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1452 relocation = 0;
1453 else
1454 {
1455 if (! ((*info->callbacks->undefined_symbol)
1456 (info, h->root.root.string, input_bfd,
1457 input_section, rel->r_offset,
1458 (!info->shared || info->no_undefined
1459 || ELF_ST_VISIBILITY (h->other)))))
1460 return false;
1461 relocation = 0;
1462 }
1463 }
1464
1465 switch (r_type)
1466 {
1467 case R_390_GOT12:
1468 case R_390_GOT16:
1469 case R_390_GOT32:
1470 /* Relocation is to the entry for this symbol in the global
1471 offset table. */
1472 BFD_ASSERT (sgot != NULL);
1473
1474 if (h != NULL)
1475 {
1476 bfd_vma off;
1477
1478 off = h->got.offset;
1479 BFD_ASSERT (off != (bfd_vma) -1);
1480
1481 if (! elf_hash_table (info)->dynamic_sections_created
1482 || (info->shared
1483 && (info->symbolic || h->dynindx == -1)
1484 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1485 {
1486 /* This is actually a static link, or it is a
1487 -Bsymbolic link and the symbol is defined
1488 locally, or the symbol was forced to be local
1489 because of a version file. We must initialize
1490 this entry in the global offset table. Since the
1491 offset must always be a multiple of 2, we use the
1492 least significant bit to record whether we have
1493 initialized it already.
1494
1495 When doing a dynamic link, we create a .rel.got
1496 relocation entry to initialize the value. This
1497 is done in the finish_dynamic_symbol routine. */
1498 if ((off & 1) != 0)
1499 off &= ~1;
1500 else
1501 {
1502 bfd_put_32 (output_bfd, relocation,
1503 sgot->contents + off);
1504 h->got.offset |= 1;
1505 }
1506 }
1507 relocation = sgot->output_offset + off;
1508 }
1509 else
1510 {
1511 bfd_vma off;
1512
1513 BFD_ASSERT (local_got_offsets != NULL
1514 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1515
1516 off = local_got_offsets[r_symndx];
1517
1518 /* The offset must always be a multiple of 4. We use
1519 the least significant bit to record whether we have
1520 already generated the necessary reloc. */
1521 if ((off & 1) != 0)
1522 off &= ~1;
1523 else
1524 {
1525 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1526
1527 if (info->shared)
1528 {
1529 asection *srelgot;
1530 Elf_Internal_Rela outrel;
1531
1532 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1533 BFD_ASSERT (srelgot != NULL);
1534
1535 outrel.r_offset = (sgot->output_section->vma
1536 + sgot->output_offset
1537 + off);
1538 outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
1539 outrel.r_addend = relocation;
1540 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1541 (((Elf32_External_Rela *)
1542 srelgot->contents)
1543 + srelgot->reloc_count));
1544 ++srelgot->reloc_count;
1545 }
1546
1547 local_got_offsets[r_symndx] |= 1;
1548 }
1549
1550 relocation = sgot->output_offset + off;
1551 }
1552
1553
1554 break;
dc810e39 1555
a85d7ed0
NC		 1556 case R_390_GOTOFF:
1557 /* Relocation is relative to the start of the global offset
1558 table. */
1559
1560 if (sgot == NULL)
1561 {
1562 sgot = bfd_get_section_by_name (dynobj, ".got");
1563 BFD_ASSERT (sgot != NULL);
1564 }
1565
1566 /* Note that sgot->output_offset is not involved in this
1567 calculation. We always want the start of .got. If we
1568 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1569 permitted by the ABI, we might have to change this
1570 calculation. */
1571 relocation -= sgot->output_section->vma;
1572
1573 break;
1574
1575 case R_390_GOTPC:
1576 /* Use global offset table as symbol value. */
1577
1578 if (sgot == NULL)
1579 {
1580 sgot = bfd_get_section_by_name (dynobj, ".got");
1581 BFD_ASSERT (sgot != NULL);
1582 }
1583
1584 relocation = sgot->output_section->vma;
1585
1586 break;
1587
1588 case R_390_PLT16DBL:
1589 case R_390_PLT32:
1590 /* Relocation is to the entry for this symbol in the
1591 procedure linkage table. */
1592
1593 /* Resolve a PLT32 reloc against a local symbol directly,
1594 without using the procedure linkage table. */
1595 if (h == NULL)
1596 break;
1597
1598 if (h->plt.offset == (bfd_vma) -1 || splt == NULL)
1599 {
1600 /* We didn't make a PLT entry for this symbol. This
1601 happens when statically linking PIC code, or when
1602 using -Bsymbolic. */
1603 break;
1604 }
1605
1606 relocation = (splt->output_section->vma
1607 + splt->output_offset
1608 + h->plt.offset);
1609
1610 break;
1611
1612 case R_390_8:
1613 case R_390_16:
1614 case R_390_32:
1615 case R_390_PC16:
1616 case R_390_PC16DBL:
1617 case R_390_PC32:
1618 if (info->shared
1619 && (input_section->flags & SEC_ALLOC) != 0
1620 && ((r_type != R_390_PC16 &&
1621 r_type != R_390_PC16DBL &&
1622 r_type != R_390_PC32)
1623 || (h != NULL
1624 && h->dynindx != -1
1625 && (! info->symbolic
1626 || (h->elf_link_hash_flags
1627 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1628 {
1629 Elf_Internal_Rela outrel;
1630 boolean skip, relocate;
1631
1632 /* When generating a shared object, these relocations
1633 are copied into the output file to be resolved at run
1634 time. */
1635
1636 if (sreloc == NULL)
1637 {
1638 const char *name;
1639
1640 name = (bfd_elf_string_from_elf_section
1641 (input_bfd,
1642 elf_elfheader (input_bfd)->e_shstrndx,
1643 elf_section_data (input_section)->rel_hdr.sh_name));
1644 if (name == NULL)
1645 return false;
1646
1647 BFD_ASSERT (strncmp (name, ".rela", 5) == 0
1648 && strcmp (bfd_get_section_name (input_bfd,
1649 input_section),
1650 name + 5) == 0);
1651
1652 sreloc = bfd_get_section_by_name (dynobj, name);
1653 BFD_ASSERT (sreloc != NULL);
1654 }
1655
1656 skip = false;
1657
1658 if (elf_section_data (input_section)->stab_info == NULL)
1659 outrel.r_offset = rel->r_offset;
1660 else
1661 {
1662 bfd_vma off;
1663
1664 off = (_bfd_stab_section_offset
1665 (output_bfd, &elf_hash_table (info)->stab_info,
1666 input_section,
1667 &elf_section_data (input_section)->stab_info,
1668 rel->r_offset));
1669 if (off == (bfd_vma) -1)
1670 skip = true;
1671 outrel.r_offset = off;
1672 }
1673
1674 outrel.r_offset += (input_section->output_section->vma
1675 + input_section->output_offset);
1676
1677 if (skip)
1678 {
1679 memset (&outrel, 0, sizeof outrel);
1680 relocate = false;
1681 }
1682 else if (r_type == R_390_PC16 ||
1683 r_type == R_390_PC16DBL ||
1684 r_type == R_390_PC32)
1685 {
1686 BFD_ASSERT (h != NULL && h->dynindx != -1);
1687 relocate = false;
1688 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1689 outrel.r_addend = relocation + rel->r_addend;
1690 }
1691 else
1692 {
1693 /* h->dynindx may be -1 if this symbol was marked to
1694 become local. */
1695 if (h == NULL
1696 || ((info->symbolic || h->dynindx == -1)
1697 && (h->elf_link_hash_flags
1698 & ELF_LINK_HASH_DEF_REGULAR) != 0))
1699 {
1700 relocate = true;
1701 outrel.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
1702 outrel.r_addend = relocation + rel->r_addend;
1703 }
1704 else
1705 {
1706 BFD_ASSERT (h->dynindx != -1);
1707 relocate = false;
1708 outrel.r_info = ELF32_R_INFO (h->dynindx, R_390_32);
1709 outrel.r_addend = relocation + rel->r_addend;
1710 }
1711 }
1712
1713 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1714 (((Elf32_External_Rela *)
1715 sreloc->contents)
1716 + sreloc->reloc_count));
1717 ++sreloc->reloc_count;
1718
1719 /* If this reloc is against an external symbol, we do
1720 not want to fiddle with the addend. Otherwise, we
1721 need to include the symbol value so that it becomes
1722 an addend for the dynamic reloc. */
1723 if (! relocate)
1724 continue;
1725 }
1726
1727 break;
1728
1729 default:
1730 break;
1731 }
1732
1733 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1734 contents, rel->r_offset,
1735 relocation, rel->r_addend);
1736
1737 if (r != bfd_reloc_ok)
1738 {
1739 switch (r)
1740 {
1741 default:
1742 case bfd_reloc_outofrange:
1743 abort ();
1744 case bfd_reloc_overflow:
1745 {
1746 const char *name;
1747
1748 if (h != NULL)
1749 name = h->root.root.string;
1750 else
1751 {
1752 name = bfd_elf_string_from_elf_section (input_bfd,
1753 symtab_hdr->sh_link,
1754 sym->st_name);
1755 if (name == NULL)
1756 return false;
1757 if (*name == '\0')
1758 name = bfd_section_name (input_bfd, sec);
1759 }
1760 if (! ((*info->callbacks->reloc_overflow)
1761 (info, name, howto->name, (bfd_vma) 0,
1762 input_bfd, input_section, rel->r_offset)))
1763 return false;
1764 }
1765 break;
1766 }
1767 }
1768 }
1769
1770 return true;
1771}
1772
1773/* Finish up dynamic symbol handling. We set the contents of various
1774 dynamic sections here. */
1775
1776static boolean
1777elf_s390_finish_dynamic_symbol (output_bfd, info, h, sym)
1778 bfd *output_bfd;
1779 struct bfd_link_info *info;
1780 struct elf_link_hash_entry *h;
1781 Elf_Internal_Sym *sym;
1782{
1783 bfd *dynobj;
1784
1785 dynobj = elf_hash_table (info)->dynobj;
1786
1787 if (h->plt.offset != (bfd_vma) -1)
1788 {
1789 asection *splt;
1790 asection *srela;
1791 Elf_Internal_Rela rela;
1792 bfd_vma relative_offset;
1793 bfd_vma got_offset;
1794 bfd_vma plt_index;
1795 asection *sgot;
1796
1797 /* This symbol has an entry in the procedure linkage table. Set
1798 it up. */
1799
1800 BFD_ASSERT (h->dynindx != -1);
1801
1802 splt = bfd_get_section_by_name (dynobj, ".plt");
1803 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
1804 srela = bfd_get_section_by_name (dynobj, ".rela.plt");
1805 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1806
dc810e39 1807 /* Calc. index no.
a85d7ed0
NC		 1808 Current offset - size first entry / entry size. */
1809 plt_index = (h->plt.offset - PLT_FIRST_ENTRY_SIZE) / PLT_ENTRY_SIZE;
1810
1811 /* Offset in GOT is PLT index plus GOT headers(3) times 4,
1812 addr & GOT addr. */
1813 got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
1814
1815 /* S390 uses halfwords for relative branch calc! */
dc810e39
AM		 1816 relative_offset = - ((PLT_FIRST_ENTRY_SIZE +
1817 (PLT_ENTRY_SIZE * plt_index) + 18) / 2);
a85d7ed0
NC		 1818 /* If offset is > 32768, branch to a previous branch
1819 390 can only handle +-64 K jumps. */
dc810e39
AM		 1820 if ( -32768 > (int) relative_offset )
1821 relative_offset =
1822 -(unsigned) (((65536 / PLT_ENTRY_SIZE - 1) * PLT_ENTRY_SIZE) / 2);
a85d7ed0
NC		 1823
1824 /* Fill in the entry in the procedure linkage table. */
1825 if (!info->shared)
1826 {
dc810e39 1827 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD0,
a85d7ed0 1828 splt->contents + h->plt.offset);
dc810e39 1829 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD1,
a85d7ed0 1830 splt->contents + h->plt.offset + 4);
dc810e39 1831 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD2,
a85d7ed0 1832 splt->contents + h->plt.offset + 8);
dc810e39 1833 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD3,
a85d7ed0 1834 splt->contents + h->plt.offset + 12);
dc810e39 1835 bfd_put_32 (output_bfd, (bfd_vma) PLT_ENTRY_WORD4,
a85d7ed0 1836 splt->contents + h->plt.offset + 16);
dc810e39 1837 bfd_put_32 (output_bfd, (bfd_vma) 0 + (relative_offset << 16),
a85d7ed0
NC		 1838 splt->contents + h->plt.offset + 20);
1839 bfd_put_32 (output_bfd,
dc810e39
AM		 1840 (sgot->output_section->vma
1841 + sgot->output_offset
1842 + got_offset),
a85d7ed0
NC		 1843 splt->contents + h->plt.offset + 24);
1844 }
1845 else if (got_offset < 4096)
1846 {
dc810e39 1847 bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC12_ENTRY_WORD0 + got_offset,
a85d7ed0 1848 splt->contents + h->plt.offset);
dc810e39 1849 bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC12_ENTRY_WORD1,
a85d7ed0 1850 splt->contents + h->plt.offset + 4);
dc810e39 1851 bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC12_ENTRY_WORD2,
a85d7ed0 1852 splt->contents + h->plt.offset + 8);
dc810e39 1853 bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC12_ENTRY_WORD3,
a85d7ed0 1854 splt->contents + h->plt.offset + 12);
dc810e39 1855 bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC12_ENTRY_WORD4,
a85d7ed0 1856 splt->contents + h->plt.offset + 16);
dc810e39 1857 bfd_put_32 (output_bfd, (bfd_vma) 0 + (relative_offset << 16),
a85d7ed0 1858 splt->contents + h->plt.offset + 20);
dc810e39 1859 bfd_put_32 (output_bfd, (bfd_vma) 0,
a85d7ed0
NC		 1860 splt->contents + h->plt.offset + 24);
1861 }
1862 else if (got_offset < 32768)
1863 {
dc810e39 1864 bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC16_ENTRY_WORD0 + got_offset,
a85d7ed0 1865 splt->contents + h->plt.offset);
dc810e39 1866 bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC16_ENTRY_WORD1,
a85d7ed0 1867 splt->contents + h->plt.offset + 4);
dc810e39 1868 bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC16_ENTRY_WORD2,
a85d7ed0 1869 splt->contents + h->plt.offset + 8);
dc810e39 1870 bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC16_ENTRY_WORD3,
a85d7ed0 1871 splt->contents + h->plt.offset + 12);
dc810e39 1872 bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC16_ENTRY_WORD4,
a85d7ed0 1873 splt->contents + h->plt.offset + 16);
dc810e39 1874 bfd_put_32 (output_bfd, (bfd_vma) 0 + (relative_offset << 16),
a85d7ed0 1875 splt->contents + h->plt.offset + 20);
dc810e39 1876 bfd_put_32 (output_bfd, (bfd_vma) 0,
a85d7ed0
NC		 1877 splt->contents + h->plt.offset + 24);
1878 }
1879 else
1880 {
dc810e39 1881 bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_ENTRY_WORD0,
a85d7ed0 1882 splt->contents + h->plt.offset);
dc810e39 1883 bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_ENTRY_WORD1,
a85d7ed0 1884 splt->contents + h->plt.offset + 4);
dc810e39 1885 bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_ENTRY_WORD2,
a85d7ed0 1886 splt->contents + h->plt.offset + 8);
dc810e39 1887 bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_ENTRY_WORD3,
a85d7ed0 1888 splt->contents + h->plt.offset + 12);
dc810e39 1889 bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_ENTRY_WORD4,
a85d7ed0 1890 splt->contents + h->plt.offset + 16);
dc810e39 1891 bfd_put_32 (output_bfd, (bfd_vma) 0 + (relative_offset << 16),
a85d7ed0
NC		 1892 splt->contents + h->plt.offset + 20);
1893 bfd_put_32 (output_bfd, got_offset,
1894 splt->contents + h->plt.offset + 24);
1895 }
1896 /* Insert offset into reloc. table here. */
1897 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
1898 splt->contents + h->plt.offset + 28);
1899 /* Fill in the entry in the .rela.plt section. */
1900 rela.r_offset = (sgot->output_section->vma
1901 + sgot->output_offset
1902 + got_offset);
1903 rela.r_info = ELF32_R_INFO (h->dynindx, R_390_JMP_SLOT);
1904 rela.r_addend = 0;
1905 bfd_elf32_swap_reloca_out (output_bfd, &rela,
1906 ((Elf32_External_Rela *) srela->contents
1907 + plt_index ));
1908
1909 /* Fill in the entry in the global offset table.
1910 Points to instruction after GOT offset. */
1911 bfd_put_32 (output_bfd,
1912 (splt->output_section->vma
1913 + splt->output_offset
1914 + h->plt.offset
1915 + 12),
1916 sgot->contents + got_offset);
1917
1918
1919 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
1920 {
1921 /* Mark the symbol as undefined, rather than as defined in
1922 the .plt section. Leave the value alone. */
1923 sym->st_shndx = SHN_UNDEF;
1924 }
1925 }
1926
1927 if (h->got.offset != (bfd_vma) -1)
1928 {
1929 asection *sgot;
1930 asection *srela;
1931 Elf_Internal_Rela rela;
1932
1933 /* This symbol has an entry in the global offset table. Set it
1934 up. */
1935
1936 sgot = bfd_get_section_by_name (dynobj, ".got");
1937 srela = bfd_get_section_by_name (dynobj, ".rela.got");
1938 BFD_ASSERT (sgot != NULL && srela != NULL);
1939
1940 rela.r_offset = (sgot->output_section->vma
1941 + sgot->output_offset
dc810e39 1942 + (h->got.offset &~ (bfd_vma) 1));
a85d7ed0
NC		 1943
1944 /* If this is a static link, or it is a -Bsymbolic link and the
1945 symbol is defined locally or was forced to be local because
1946 of a version file, we just want to emit a RELATIVE reloc.
1947 The entry in the global offset table will already have been
1948 initialized in the relocate_section function. */
1949 if (! elf_hash_table (info)->dynamic_sections_created
1950 || (info->shared
1951 && (info->symbolic || h->dynindx == -1)
1952 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1953 {
1954 rela.r_info = ELF32_R_INFO (0, R_390_RELATIVE);
1955 rela.r_addend = (h->root.u.def.value
1956 + h->root.u.def.section->output_section->vma
1957 + h->root.u.def.section->output_offset);
1958 }
1959 else
1960 {
1961 BFD_ASSERT((h->got.offset & 1) == 0);
1962 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1963 rela.r_info = ELF32_R_INFO (h->dynindx, R_390_GLOB_DAT);
1964 rela.r_addend = 0;
1965 }
1966
1967 bfd_elf32_swap_reloca_out (output_bfd, &rela,
1968 ((Elf32_External_Rela *) srela->contents
1969 + srela->reloc_count));
1970 ++srela->reloc_count;
1971 }
1972
1973 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
1974 {
1975 asection *s;
1976 Elf_Internal_Rela rela;
1977
1978 /* This symbols needs a copy reloc. Set it up. */
1979
1980 BFD_ASSERT (h->dynindx != -1
1981 && (h->root.type == bfd_link_hash_defined
1982 || h->root.type == bfd_link_hash_defweak));
1983
1984
1985 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1986 ".rela.bss");
1987 BFD_ASSERT (s != NULL);
1988
1989 rela.r_offset = (h->root.u.def.value
1990 + h->root.u.def.section->output_section->vma
1991 + h->root.u.def.section->output_offset);
1992 rela.r_info = ELF32_R_INFO (h->dynindx, R_390_COPY);
1993 rela.r_addend = 0;
1994 bfd_elf32_swap_reloca_out (output_bfd, &rela,
1995 ((Elf32_External_Rela *) s->contents
1996 + s->reloc_count));
1997 ++s->reloc_count;
1998 }
1999
2000 /* Mark some specially defined symbols as absolute. */
2001 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2002 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
2003 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
2004 sym->st_shndx = SHN_ABS;
2005
2006 return true;
2007}
2008
2009/* Finish up the dynamic sections. */
2010
2011static boolean
2012elf_s390_finish_dynamic_sections (output_bfd, info)
2013 bfd *output_bfd;
2014 struct bfd_link_info *info;
2015{
2016 bfd *dynobj;
2017 asection *sdyn;
2018 asection *sgot;
2019
2020 dynobj = elf_hash_table (info)->dynobj;
2021
2022 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
2023 BFD_ASSERT (sgot != NULL);
2024 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2025
2026 if (elf_hash_table (info)->dynamic_sections_created)
2027 {
2028 asection *splt;
2029 Elf32_External_Dyn *dyncon, *dynconend;
2030
2031 BFD_ASSERT (sdyn != NULL);
2032
2033 dyncon = (Elf32_External_Dyn *) sdyn->contents;
2034 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
2035 for (; dyncon < dynconend; dyncon++)
2036 {
2037 Elf_Internal_Dyn dyn;
2038 const char *name;
2039 asection *s;
2040
2041 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2042
2043 switch (dyn.d_tag)
2044 {
2045 default:
2046 break;
2047
2048 case DT_PLTGOT:
2049 name = ".got";
2050 goto get_vma;
2051 case DT_JMPREL:
2052 name = ".rela.plt";
2053 get_vma:
2054 s = bfd_get_section_by_name(output_bfd, name);
2055 BFD_ASSERT (s != NULL);
2056 dyn.d_un.d_ptr = s->vma;
2057 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2058 break;
2059
2060 case DT_PLTRELSZ:
2061 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2062 BFD_ASSERT (s != NULL);
2063 if (s->_cooked_size != 0)
2064 dyn.d_un.d_val = s->_cooked_size;
2065 else
2066 dyn.d_un.d_val = s->_raw_size;
2067 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2068 break;
2069 }
2070 }
2071
2072 /* Fill in the special first entry in the procedure linkage table. */
2073 splt = bfd_get_section_by_name (dynobj, ".plt");
2074 if (splt && splt->_raw_size > 0)
2075 {
2076 memset (splt->contents, 0, PLT_FIRST_ENTRY_SIZE);
2077 if (info->shared)
2078 {
dc810e39 2079 bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_FIRST_ENTRY_WORD0,
a85d7ed0 2080 splt->contents );
dc810e39
AM		 2081 bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_FIRST_ENTRY_WORD1,
2082 splt->contents + 4 );
2083 bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_FIRST_ENTRY_WORD2,
2084 splt->contents + 8 );
2085 bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_FIRST_ENTRY_WORD3,
2086 splt->contents + 12 );
2087 bfd_put_32 (output_bfd, (bfd_vma) PLT_PIC_FIRST_ENTRY_WORD4,
2088 splt->contents + 16 );
a85d7ed0
NC		 2089 }
2090 else
2091 {
dc810e39 2092 bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD0,
a85d7ed0 2093 splt->contents );
dc810e39
AM		 2094 bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD1,
2095 splt->contents + 4 );
2096 bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD2,
2097 splt->contents + 8 );
2098 bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD3,
2099 splt->contents + 12 );
2100 bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD4,
2101 splt->contents + 16 );
2102 bfd_put_32 (output_bfd, (bfd_vma) PLT_FIRST_ENTRY_WORD5,
2103 splt->contents + 20 );
a85d7ed0
NC		 2104 bfd_put_32 (output_bfd,
2105 sgot->output_section->vma + sgot->output_offset,
2106 splt->contents + 24);
2107 }
2108 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
2109 }
2110
2111 }
2112
2113 /* Set the first entry in the global offset table to the address of
2114 the dynamic section. */
2115 if (sgot->_raw_size > 0)
2116 {
2117 if (sdyn == NULL)
2118 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2119 else
2120 bfd_put_32 (output_bfd,
2121 sdyn->output_section->vma + sdyn->output_offset,
2122 sgot->contents);
2123
2124 /* One entry for shared object struct ptr. */
2125 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
2126 /* One entry for _dl_runtime_resolve. */
2127 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
2128 }
2129
2130 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2131
2132 return true;
2133}
2134
2135static boolean
2136elf_s390_object_p (abfd)
2137 bfd *abfd;
2138{
2139 return bfd_default_set_arch_mach (abfd, bfd_arch_s390, bfd_mach_s390_esa);
2140}
2141
29c2fb7c 2142static enum elf_reloc_type_class
f51e552e
AM		 2143elf_s390_reloc_type_class (rela)
2144 const Elf_Internal_Rela *rela;
29c2fb7c 2145{
f51e552e 2146 switch ((int) ELF32_R_TYPE (rela->r_info))
29c2fb7c
AJ		 2147 {
2148 case R_390_RELATIVE:
2149 return reloc_class_relative;
2150 case R_390_JMP_SLOT:
2151 return reloc_class_plt;
2152 case R_390_COPY:
2153 return reloc_class_copy;
2154 default:
2155 return reloc_class_normal;
2156 }
2157}
2158
a85d7ed0
NC		 2159#define TARGET_BIG_SYM bfd_elf32_s390_vec
2160#define TARGET_BIG_NAME "elf32-s390"
2161#define ELF_ARCH bfd_arch_s390
2162#define ELF_MACHINE_CODE EM_S390
2163#define ELF_MACHINE_ALT1 EM_S390_OLD
2164#define ELF_MAXPAGESIZE 0x1000
2165
2166#define elf_backend_can_gc_sections 1
2167#define elf_backend_want_got_plt 1
2168#define elf_backend_plt_readonly 1
2169#define elf_backend_want_plt_sym 0
2170#define elf_backend_got_header_size 12
2171#define elf_backend_plt_header_size PLT_ENTRY_SIZE
2172
2173#define elf_info_to_howto elf_s390_info_to_howto
2174
2175#define bfd_elf32_bfd_final_link _bfd_elf32_gc_common_final_link
2176#define bfd_elf32_bfd_is_local_label_name elf_s390_is_local_label_name
2177#define bfd_elf32_bfd_link_hash_table_create elf_s390_link_hash_table_create
2178#define bfd_elf32_bfd_reloc_type_lookup elf_s390_reloc_type_lookup
2179
2180#define elf_backend_adjust_dynamic_symbol elf_s390_adjust_dynamic_symbol
2181#define elf_backend_check_relocs elf_s390_check_relocs
2182#define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
2183#define elf_backend_finish_dynamic_sections elf_s390_finish_dynamic_sections
2184#define elf_backend_finish_dynamic_symbol elf_s390_finish_dynamic_symbol
2185#define elf_backend_gc_mark_hook elf_s390_gc_mark_hook
2186#define elf_backend_gc_sweep_hook elf_s390_gc_sweep_hook
2187#define elf_backend_relocate_section elf_s390_relocate_section
2188#define elf_backend_size_dynamic_sections elf_s390_size_dynamic_sections
29c2fb7c 2189#define elf_backend_reloc_type_class elf_s390_reloc_type_class
a85d7ed0
NC		 2190
2191#define elf_backend_object_p elf_s390_object_p
2192
2193#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.129778 seconds and 4 git commands to generate.