1 /* IBM S/390-specific support for 32-bit ELF
2 Copyright 2000, 2001 Free Software Foundation, Inc.
3 Contributed by Carl B. Pedersen and Martin Schwidefsky.
5 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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
28 static reloc_howto_type
*elf_s390_reloc_type_lookup
29 PARAMS ((bfd
*, bfd_reloc_code_real_type
));
30 static void elf_s390_info_to_howto
31 PARAMS ((bfd
*, arelent
*, Elf_Internal_Rela
*));
32 static boolean elf_s390_is_local_label_name
33 PARAMS ((bfd
*, const char *));
34 static struct bfd_hash_entry
*link_hash_newfunc
35 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
36 static struct bfd_link_hash_table
*elf_s390_link_hash_table_create
38 static boolean create_got_section
39 PARAMS((bfd
*, struct bfd_link_info
*));
40 static boolean elf_s390_create_dynamic_sections
41 PARAMS((bfd
*, struct bfd_link_info
*));
42 static void elf_s390_copy_indirect_symbol
43 PARAMS ((struct elf_link_hash_entry
*, struct elf_link_hash_entry
*));
44 static boolean elf_s390_check_relocs
45 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
46 const Elf_Internal_Rela
*));
47 static asection
*elf_s390_gc_mark_hook
48 PARAMS ((bfd
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
49 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
50 static boolean elf_s390_gc_sweep_hook
51 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
52 const Elf_Internal_Rela
*));
53 static boolean elf_s390_adjust_dynamic_symbol
54 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
55 static boolean allocate_dynrelocs
56 PARAMS ((struct elf_link_hash_entry
*, PTR
));
57 static boolean readonly_dynrelocs
58 PARAMS ((struct elf_link_hash_entry
*, PTR
));
59 static boolean elf_s390_size_dynamic_sections
60 PARAMS ((bfd
*, struct bfd_link_info
*));
61 static boolean elf_s390_relocate_section
62 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
63 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
64 static boolean elf_s390_finish_dynamic_symbol
65 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
67 static enum elf_reloc_type_class elf_s390_reloc_type_class
68 PARAMS ((const Elf_Internal_Rela
*));
69 static boolean elf_s390_finish_dynamic_sections
70 PARAMS ((bfd
*, struct bfd_link_info
*));
71 static boolean elf_s390_object_p
PARAMS ((bfd
*));
72 static boolean elf_s390_grok_prstatus
PARAMS ((bfd
*, Elf_Internal_Note
*));
74 #define USE_RELA 1 /* We want RELA relocations, not REL. */
78 /* The relocation "howto" table. */
80 static reloc_howto_type elf_howto_table
[] =
82 HOWTO (R_390_NONE
, /* type */
84 0, /* size (0 = byte, 1 = short, 2 = long) */
86 false, /* pc_relative */
88 complain_overflow_dont
, /* complain_on_overflow */
89 bfd_elf_generic_reloc
, /* special_function */
90 "R_390_NONE", /* name */
91 false, /* partial_inplace */
94 false), /* pcrel_offset */
96 HOWTO(R_390_8
, 0, 0, 8, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_8", false, 0,0x000000ff, false),
97 HOWTO(R_390_12
, 0, 1, 12, false, 0, complain_overflow_dont
, bfd_elf_generic_reloc
, "R_390_12", false, 0,0x00000fff, false),
98 HOWTO(R_390_16
, 0, 1, 16, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_16", false, 0,0x0000ffff, false),
99 HOWTO(R_390_32
, 0, 2, 32, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_32", false, 0,0xffffffff, false),
100 HOWTO(R_390_PC32
, 0, 2, 32, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PC32", false, 0,0xffffffff, true),
101 HOWTO(R_390_GOT12
, 0, 1, 12, false, 0, complain_overflow_dont
, bfd_elf_generic_reloc
, "R_390_GOT12", false, 0,0x00000fff, false),
102 HOWTO(R_390_GOT32
, 0, 2, 32, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_GOT32", false, 0,0xffffffff, false),
103 HOWTO(R_390_PLT32
, 0, 2, 32, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PLT32", false, 0,0xffffffff, true),
104 HOWTO(R_390_COPY
, 0, 2, 32, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_COPY", false, 0,0xffffffff, false),
105 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),
106 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),
107 HOWTO(R_390_RELATIVE
, 0, 2, 32, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_RELATIVE",false, 0,0xffffffff, false),
108 HOWTO(R_390_GOTOFF
, 0, 2, 32, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_GOTOFF", false, 0,0xffffffff, false),
109 HOWTO(R_390_GOTPC
, 0, 2, 32, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_GOTPC", false, 0,0xffffffff, true),
110 HOWTO(R_390_GOT16
, 0, 1, 16, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_GOT16", false, 0,0x0000ffff, false),
111 HOWTO(R_390_PC16
, 0, 1, 16, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PC16", false, 0,0x0000ffff, true),
112 HOWTO(R_390_PC16DBL
, 1, 1, 16, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PC16DBL", false, 0,0x0000ffff, true),
113 HOWTO(R_390_PLT16DBL
, 1, 1, 16, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PLT16DBL", false, 0,0x0000ffff, true),
116 /* GNU extension to record C++ vtable hierarchy. */
117 static reloc_howto_type elf32_s390_vtinherit_howto
=
118 HOWTO (R_390_GNU_VTINHERIT
, 0,2,0,false,0,complain_overflow_dont
, NULL
, "R_390_GNU_VTINHERIT", false,0, 0, false);
119 static reloc_howto_type elf32_s390_vtentry_howto
=
120 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);
122 static reloc_howto_type
*
123 elf_s390_reloc_type_lookup (abfd
, code
)
124 bfd
*abfd ATTRIBUTE_UNUSED
;
125 bfd_reloc_code_real_type code
;
130 return &elf_howto_table
[(int) R_390_NONE
];
132 return &elf_howto_table
[(int) R_390_8
];
133 case BFD_RELOC_390_12
:
134 return &elf_howto_table
[(int) R_390_12
];
136 return &elf_howto_table
[(int) R_390_16
];
138 return &elf_howto_table
[(int) R_390_32
];
140 return &elf_howto_table
[(int) R_390_32
];
141 case BFD_RELOC_32_PCREL
:
142 return &elf_howto_table
[(int) R_390_PC32
];
143 case BFD_RELOC_390_GOT12
:
144 return &elf_howto_table
[(int) R_390_GOT12
];
145 case BFD_RELOC_32_GOT_PCREL
:
146 return &elf_howto_table
[(int) R_390_GOT32
];
147 case BFD_RELOC_390_PLT32
:
148 return &elf_howto_table
[(int) R_390_PLT32
];
149 case BFD_RELOC_390_COPY
:
150 return &elf_howto_table
[(int) R_390_COPY
];
151 case BFD_RELOC_390_GLOB_DAT
:
152 return &elf_howto_table
[(int) R_390_GLOB_DAT
];
153 case BFD_RELOC_390_JMP_SLOT
:
154 return &elf_howto_table
[(int) R_390_JMP_SLOT
];
155 case BFD_RELOC_390_RELATIVE
:
156 return &elf_howto_table
[(int) R_390_RELATIVE
];
157 case BFD_RELOC_32_GOTOFF
:
158 return &elf_howto_table
[(int) R_390_GOTOFF
];
159 case BFD_RELOC_390_GOTPC
:
160 return &elf_howto_table
[(int) R_390_GOTPC
];
161 case BFD_RELOC_390_GOT16
:
162 return &elf_howto_table
[(int) R_390_GOT16
];
163 case BFD_RELOC_16_PCREL
:
164 return &elf_howto_table
[(int) R_390_PC16
];
165 case BFD_RELOC_390_PC16DBL
:
166 return &elf_howto_table
[(int) R_390_PC16DBL
];
167 case BFD_RELOC_390_PLT16DBL
:
168 return &elf_howto_table
[(int) R_390_PLT16DBL
];
169 case BFD_RELOC_VTABLE_INHERIT
:
170 return &elf32_s390_vtinherit_howto
;
171 case BFD_RELOC_VTABLE_ENTRY
:
172 return &elf32_s390_vtentry_howto
;
179 /* We need to use ELF32_R_TYPE so we have our own copy of this function,
180 and elf32-s390.c has its own copy. */
183 elf_s390_info_to_howto (abfd
, cache_ptr
, dst
)
184 bfd
*abfd ATTRIBUTE_UNUSED
;
186 Elf_Internal_Rela
*dst
;
188 switch (ELF32_R_TYPE(dst
->r_info
))
190 case R_390_GNU_VTINHERIT
:
191 cache_ptr
->howto
= &elf32_s390_vtinherit_howto
;
194 case R_390_GNU_VTENTRY
:
195 cache_ptr
->howto
= &elf32_s390_vtentry_howto
;
199 BFD_ASSERT (ELF32_R_TYPE(dst
->r_info
) < (unsigned int) R_390_max
);
200 cache_ptr
->howto
= &elf_howto_table
[ELF32_R_TYPE(dst
->r_info
)];
205 elf_s390_is_local_label_name (abfd
, name
)
209 if (name
[0] == '.' && (name
[1] == 'X' || name
[1] == 'L'))
212 return _bfd_elf_is_local_label_name (abfd
, name
);
215 /* Functions for the 390 ELF linker. */
217 /* The name of the dynamic interpreter. This is put in the .interp
220 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
222 /* The size in bytes of the first entry in the procedure linkage table. */
223 #define PLT_FIRST_ENTRY_SIZE 32
224 /* The size in bytes of an entry in the procedure linkage table. */
225 #define PLT_ENTRY_SIZE 32
227 #define GOT_ENTRY_SIZE 4
229 /* The first three entries in a procedure linkage table are reserved,
230 and the initial contents are unimportant (we zero them out).
231 Subsequent entries look like this. See the SVR4 ABI 386
232 supplement to see how this works. */
234 /* For the s390, simple addr offset can only be 0 - 4096.
235 To use the full 2 GB address space, several instructions
236 are needed to load an address in a register and execute
237 a branch( or just saving the address)
239 Furthermore, only r 0 and 1 are free to use!!! */
241 /* The first 3 words in the GOT are then reserved.
242 Word 0 is the address of the dynamic table.
243 Word 1 is a pointer to a structure describing the object
244 Word 2 is used to point to the loader entry address.
246 The code for position independand PLT entries looks like this:
248 r12 holds addr of the current GOT at entry to the PLT
250 The GOT holds the address in the PLT to be executed.
251 The loader then gets:
252 24(15) = Pointer to the structure describing the object.
253 28(15) = Offset in symbol table
255 The loader must then find the module where the function is
256 and insert the address in the GOT.
258 Note: 390 can only address +- 64 K relative.
259 We check if offset > 65536, then make a relative branch -64xxx
260 back to a previous defined branch
262 PLT1: BASR 1,0 # 2 bytes
263 L 1,22(1) # 4 bytes Load offset in GOT in r 1
264 L 1,(1,12) # 4 bytes Load address from GOT in r1
265 BCR 15,1 # 2 bytes Jump to address
266 RET1: BASR 1,0 # 2 bytes Return from GOT 1st time
267 L 1,14(1) # 4 bytes Load offset in symol table in r1
268 BRC 15,-x # 4 bytes Jump to start of PLT
269 .word 0 # 2 bytes filler
270 .long ? # 4 bytes offset in GOT
271 .long ? # 4 bytes offset into symbol table
273 This was the general case. There are two additional, optimizes PLT
274 definitions. One for GOT offsets < 4096 and one for GOT offsets < 32768.
275 First the one for GOT offsets < 4096:
277 PLT1: L 1,<offset>(12) # 4 bytes Load address from GOT in R1
278 BCR 15,1 # 2 bytes Jump to address
279 .word 0,0,0 # 6 bytes filler
280 RET1: BASR 1,0 # 2 bytes Return from GOT 1st time
281 L 1,14(1) # 4 bytes Load offset in symbol table in r1
282 BRC 15,-x # 4 bytes Jump to start of PLT
283 .word 0,0,0 # 6 bytes filler
284 .long ? # 4 bytes offset into symbol table
286 Second the one for GOT offsets < 32768:
288 PLT1: LHI 1,<offset> # 4 bytes Load offset in GOT to r1
289 L 1,(1,12) # 4 bytes Load address from GOT to r1
290 BCR 15,1 # 2 bytes Jump to address
291 .word 0 # 2 bytes filler
292 RET1: BASR 1,0 # 2 bytes Return from GOT 1st time
293 L 1,14(1) # 4 bytes Load offset in symbol table in r1
294 BRC 15,-x # 4 bytes Jump to start of PLT
295 .word 0,0,0 # 6 bytes filler
296 .long ? # 4 bytes offset into symbol table
298 Total = 32 bytes per PLT entry
300 The code for static build PLT entries looks like this:
302 PLT1: BASR 1,0 # 2 bytes
303 L 1,22(1) # 4 bytes Load address of GOT entry
304 L 1,0(0,1) # 4 bytes Load address from GOT in r1
305 BCR 15,1 # 2 bytes Jump to address
306 RET1: BASR 1,0 # 2 bytes Return from GOT 1st time
307 L 1,14(1) # 4 bytes Load offset in symbol table in r1
308 BRC 15,-x # 4 bytes Jump to start of PLT
309 .word 0 # 2 bytes filler
310 .long ? # 4 bytes address of GOT entry
311 .long ? # 4 bytes offset into symbol table */
313 #define PLT_PIC_ENTRY_WORD0 0x0d105810
314 #define PLT_PIC_ENTRY_WORD1 0x10165811
315 #define PLT_PIC_ENTRY_WORD2 0xc00007f1
316 #define PLT_PIC_ENTRY_WORD3 0x0d105810
317 #define PLT_PIC_ENTRY_WORD4 0x100ea7f4
319 #define PLT_PIC12_ENTRY_WORD0 0x5810c000
320 #define PLT_PIC12_ENTRY_WORD1 0x07f10000
321 #define PLT_PIC12_ENTRY_WORD2 0x00000000
322 #define PLT_PIC12_ENTRY_WORD3 0x0d105810
323 #define PLT_PIC12_ENTRY_WORD4 0x100ea7f4
325 #define PLT_PIC16_ENTRY_WORD0 0xa7180000
326 #define PLT_PIC16_ENTRY_WORD1 0x5811c000
327 #define PLT_PIC16_ENTRY_WORD2 0x07f10000
328 #define PLT_PIC16_ENTRY_WORD3 0x0d105810
329 #define PLT_PIC16_ENTRY_WORD4 0x100ea7f4
331 #define PLT_ENTRY_WORD0 0x0d105810
332 #define PLT_ENTRY_WORD1 0x10165810
333 #define PLT_ENTRY_WORD2 0x100007f1
334 #define PLT_ENTRY_WORD3 0x0d105810
335 #define PLT_ENTRY_WORD4 0x100ea7f4
337 /* The first PLT entry pushes the offset into the symbol table
338 from R1 onto the stack at 8(15) and the loader object info
339 at 12(15), loads the loader address in R1 and jumps to it. */
341 /* The first entry in the PLT for PIC code:
344 ST 1,28(15) # R1 has offset into symbol table
345 L 1,4(12) # Get loader ino(object struct address)
346 ST 1,24(15) # Store address
347 L 1,8(12) # Entry address of loader in R1
348 BR 1 # Jump to loader
350 The first entry in the PLT for static code:
353 ST 1,28(15) # R1 has offset into symbol table
355 L 1,18(0,1) # Get address of GOT
356 MVC 24(4,15),4(1) # Move loader ino to stack
357 L 1,8(1) # Get address of loader
358 BR 1 # Jump to loader
360 .long got # address of GOT */
362 #define PLT_PIC_FIRST_ENTRY_WORD0 0x5010f01c
363 #define PLT_PIC_FIRST_ENTRY_WORD1 0x5810c004
364 #define PLT_PIC_FIRST_ENTRY_WORD2 0x5010f018
365 #define PLT_PIC_FIRST_ENTRY_WORD3 0x5810c008
366 #define PLT_PIC_FIRST_ENTRY_WORD4 0x07f10000
368 #define PLT_FIRST_ENTRY_WORD0 0x5010f01c
369 #define PLT_FIRST_ENTRY_WORD1 0x0d105810
370 #define PLT_FIRST_ENTRY_WORD2 0x1012D203
371 #define PLT_FIRST_ENTRY_WORD3 0xf0181004
372 #define PLT_FIRST_ENTRY_WORD4 0x58101008
373 #define PLT_FIRST_ENTRY_WORD5 0x07f10000
375 /* The s390 linker needs to keep track of the number of relocs that it
376 decides to copy as dynamic relocs in check_relocs for each symbol.
377 This is so that it can later discard them if they are found to be
378 unnecessary. We store the information in a field extending the
379 regular ELF linker hash table. */
381 struct elf_s390_dyn_relocs
383 struct elf_s390_dyn_relocs
*next
;
385 /* The input section of the reloc. */
388 /* Total number of relocs copied for the input section. */
391 /* Number of pc-relative relocs copied for the input section. */
392 bfd_size_type pc_count
;
395 /* s390 ELF linker hash entry. */
397 struct elf_s390_link_hash_entry
399 struct elf_link_hash_entry elf
;
401 /* Track dynamic relocs copied for this symbol. */
402 struct elf_s390_dyn_relocs
*dyn_relocs
;
405 /* s390 ELF linker hash table. */
407 struct elf_s390_link_hash_table
409 struct elf_link_hash_table elf
;
411 /* Short-cuts to get to dynamic linker sections. */
420 /* Small local sym to section mapping cache. */
421 struct sym_sec_cache sym_sec
;
424 /* Get the s390 ELF linker hash table from a link_info structure. */
426 #define elf_s390_hash_table(p) \
427 ((struct elf_s390_link_hash_table *) ((p)->hash))
429 /* Create an entry in an s390 ELF linker hash table. */
431 static struct bfd_hash_entry
*
432 link_hash_newfunc (entry
, table
, string
)
433 struct bfd_hash_entry
*entry
;
434 struct bfd_hash_table
*table
;
437 /* Allocate the structure if it has not already been allocated by a
441 entry
= bfd_hash_allocate (table
,
442 sizeof (struct elf_s390_link_hash_entry
));
447 /* Call the allocation method of the superclass. */
448 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
451 struct elf_s390_link_hash_entry
*eh
;
453 eh
= (struct elf_s390_link_hash_entry
*) entry
;
454 eh
->dyn_relocs
= NULL
;
460 /* Create an s390 ELF linker hash table. */
462 static struct bfd_link_hash_table
*
463 elf_s390_link_hash_table_create (abfd
)
466 struct elf_s390_link_hash_table
*ret
;
467 bfd_size_type amt
= sizeof (struct elf_s390_link_hash_table
);
469 ret
= (struct elf_s390_link_hash_table
*) bfd_alloc (abfd
, amt
);
473 if (! _bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
))
475 bfd_release (abfd
, ret
);
486 ret
->sym_sec
.abfd
= NULL
;
488 return &ret
->elf
.root
;
491 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
492 shortcuts to them in our hash table. */
495 create_got_section (dynobj
, info
)
497 struct bfd_link_info
*info
;
499 struct elf_s390_link_hash_table
*htab
;
501 if (! _bfd_elf_create_got_section (dynobj
, info
))
504 htab
= elf_s390_hash_table (info
);
505 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
506 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
507 if (!htab
->sgot
|| !htab
->sgotplt
)
510 htab
->srelgot
= bfd_make_section (dynobj
, ".rela.got");
511 if (htab
->srelgot
== NULL
512 || ! bfd_set_section_flags (dynobj
, htab
->srelgot
,
513 (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
514 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
516 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
521 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
522 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
526 elf_s390_create_dynamic_sections (dynobj
, info
)
528 struct bfd_link_info
*info
;
530 struct elf_s390_link_hash_table
*htab
;
532 htab
= elf_s390_hash_table (info
);
533 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
536 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
539 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
540 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rela.plt");
541 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
543 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rela.bss");
545 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
546 || (!info
->shared
&& !htab
->srelbss
))
552 /* Copy the extra info we tack onto an elf_link_hash_entry. */
555 elf_s390_copy_indirect_symbol (dir
, ind
)
556 struct elf_link_hash_entry
*dir
, *ind
;
558 struct elf_s390_link_hash_entry
*edir
, *eind
;
560 edir
= (struct elf_s390_link_hash_entry
*) dir
;
561 eind
= (struct elf_s390_link_hash_entry
*) ind
;
563 if (eind
->dyn_relocs
!= NULL
)
565 if (edir
->dyn_relocs
!= NULL
)
567 struct elf_s390_dyn_relocs
**pp
;
568 struct elf_s390_dyn_relocs
*p
;
570 if (ind
->root
.type
== bfd_link_hash_indirect
)
573 /* Add reloc counts against the weak sym to the strong sym
574 list. Merge any entries against the same section. */
575 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
577 struct elf_s390_dyn_relocs
*q
;
579 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
580 if (q
->sec
== p
->sec
)
582 q
->pc_count
+= p
->pc_count
;
583 q
->count
+= p
->count
;
590 *pp
= edir
->dyn_relocs
;
593 edir
->dyn_relocs
= eind
->dyn_relocs
;
594 eind
->dyn_relocs
= NULL
;
597 _bfd_elf_link_hash_copy_indirect (dir
, ind
);
600 /* Look through the relocs for a section during the first phase, and
601 allocate space in the global offset table or procedure linkage
605 elf_s390_check_relocs (abfd
, info
, sec
, relocs
)
607 struct bfd_link_info
*info
;
609 const Elf_Internal_Rela
*relocs
;
611 struct elf_s390_link_hash_table
*htab
;
612 Elf_Internal_Shdr
*symtab_hdr
;
613 struct elf_link_hash_entry
**sym_hashes
;
614 const Elf_Internal_Rela
*rel
;
615 const Elf_Internal_Rela
*rel_end
;
618 if (info
->relocateable
)
621 htab
= elf_s390_hash_table (info
);
622 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
623 sym_hashes
= elf_sym_hashes (abfd
);
627 rel_end
= relocs
+ sec
->reloc_count
;
628 for (rel
= relocs
; rel
< rel_end
; rel
++)
630 unsigned long r_symndx
;
631 struct elf_link_hash_entry
*h
;
633 r_symndx
= ELF32_R_SYM (rel
->r_info
);
635 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
637 (*_bfd_error_handler
) (_("%s: bad symbol index: %d"),
638 bfd_archive_filename (abfd
),
643 if (r_symndx
< symtab_hdr
->sh_info
)
646 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
648 switch (ELF32_R_TYPE (rel
->r_info
))
653 /* This symbol requires a global offset table entry. */
656 h
->got
.refcount
+= 1;
660 bfd_signed_vma
*local_got_refcounts
;
662 /* This is a global offset table entry for a local symbol. */
663 local_got_refcounts
= elf_local_got_refcounts (abfd
);
664 if (local_got_refcounts
== NULL
)
668 size
= symtab_hdr
->sh_info
;
669 size
*= sizeof (bfd_signed_vma
);
670 local_got_refcounts
= ((bfd_signed_vma
*)
671 bfd_zalloc (abfd
, size
));
672 if (local_got_refcounts
== NULL
)
674 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
676 local_got_refcounts
[r_symndx
] += 1;
682 if (htab
->sgot
== NULL
)
684 if (htab
->elf
.dynobj
== NULL
)
685 htab
->elf
.dynobj
= abfd
;
686 if (!create_got_section (htab
->elf
.dynobj
, info
))
693 /* This symbol requires a procedure linkage table entry. We
694 actually build the entry in adjust_dynamic_symbol,
695 because this might be a case of linking PIC code which is
696 never referenced by a dynamic object, in which case we
697 don't need to generate a procedure linkage table entry
700 /* If this is a local symbol, we resolve it directly without
701 creating a procedure linkage table entry. */
705 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
706 h
->plt
.refcount
+= 1;
715 if (h
!= NULL
&& !info
->shared
)
717 /* If this reloc is in a read-only section, we might
718 need a copy reloc. We can't check reliably at this
719 stage whether the section is read-only, as input
720 sections have not yet been mapped to output sections.
721 Tentatively set the flag for now, and correct in
722 adjust_dynamic_symbol. */
723 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
725 /* We may need a .plt entry if the function this reloc
726 refers to is in a shared lib. */
727 h
->plt
.refcount
+= 1;
730 /* If we are creating a shared library, and this is a reloc
731 against a global symbol, or a non PC relative reloc
732 against a local symbol, then we need to copy the reloc
733 into the shared library. However, if we are linking with
734 -Bsymbolic, we do not need to copy a reloc against a
735 global symbol which is defined in an object we are
736 including in the link (i.e., DEF_REGULAR is set). At
737 this point we have not seen all the input files, so it is
738 possible that DEF_REGULAR is not set now but will be set
739 later (it is never cleared). In case of a weak definition,
740 DEF_REGULAR may be cleared later by a strong definition in
741 a shared library. We account for that possibility below by
742 storing information in the relocs_copied field of the hash
743 table entry. A similar situation occurs when creating
744 shared libraries and symbol visibility changes render the
747 If on the other hand, we are creating an executable, we
748 may need to keep relocations for symbols satisfied by a
749 dynamic library if we manage to avoid copy relocs for the
752 && (sec
->flags
& SEC_ALLOC
) != 0
753 && ((ELF32_R_TYPE (rel
->r_info
) != R_390_PC16
754 && ELF32_R_TYPE (rel
->r_info
) != R_390_PC16DBL
755 && ELF32_R_TYPE (rel
->r_info
) != R_390_PC32
)
758 || h
->root
.type
== bfd_link_hash_defweak
759 || (h
->elf_link_hash_flags
760 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
762 && (sec
->flags
& SEC_ALLOC
) != 0
764 && (h
->root
.type
== bfd_link_hash_defweak
765 || (h
->elf_link_hash_flags
766 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
768 struct elf_s390_dyn_relocs
*p
;
769 struct elf_s390_dyn_relocs
**head
;
771 /* We must copy these reloc types into the output file.
772 Create a reloc section in dynobj and make room for
779 name
= (bfd_elf_string_from_elf_section
781 elf_elfheader (abfd
)->e_shstrndx
,
782 elf_section_data (sec
)->rel_hdr
.sh_name
));
786 if (strncmp (name
, ".rela", 5) != 0
787 || strcmp (bfd_get_section_name (abfd
, sec
),
790 (*_bfd_error_handler
)
791 (_("%s: bad relocation section name `%s\'"),
792 bfd_archive_filename (abfd
), name
);
795 if (htab
->elf
.dynobj
== NULL
)
796 htab
->elf
.dynobj
= abfd
;
798 dynobj
= htab
->elf
.dynobj
;
799 sreloc
= bfd_get_section_by_name (dynobj
, name
);
804 sreloc
= bfd_make_section (dynobj
, name
);
805 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
806 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
807 if ((sec
->flags
& SEC_ALLOC
) != 0)
808 flags
|= SEC_ALLOC
| SEC_LOAD
;
810 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
811 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
814 elf_section_data (sec
)->sreloc
= sreloc
;
817 /* If this is a global symbol, we count the number of
818 relocations we need for this symbol. */
821 head
= &((struct elf_s390_link_hash_entry
*) h
)->dyn_relocs
;
825 /* Track dynamic relocs needed for local syms too.
826 We really need local syms available to do this
830 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
835 head
= ((struct elf_s390_dyn_relocs
**)
836 &elf_section_data (s
)->local_dynrel
);
840 if (p
== NULL
|| p
->sec
!= sec
)
842 bfd_size_type amt
= sizeof *p
;
843 p
= ((struct elf_s390_dyn_relocs
*)
844 bfd_alloc (htab
->elf
.dynobj
, amt
));
855 if (ELF32_R_TYPE (rel
->r_info
) == R_390_PC16
856 || ELF32_R_TYPE (rel
->r_info
) == R_390_PC16DBL
857 || ELF32_R_TYPE (rel
->r_info
) == R_390_PC32
)
862 /* This relocation describes the C++ object vtable hierarchy.
863 Reconstruct it for later use during GC. */
864 case R_390_GNU_VTINHERIT
:
865 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
869 /* This relocation describes which C++ vtable entries are actually
870 used. Record for later use during GC. */
871 case R_390_GNU_VTENTRY
:
872 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
884 /* Return the section that should be marked against GC for a given
888 elf_s390_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
890 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
891 Elf_Internal_Rela
*rel
;
892 struct elf_link_hash_entry
*h
;
893 Elf_Internal_Sym
*sym
;
897 switch (ELF32_R_TYPE (rel
->r_info
))
899 case R_390_GNU_VTINHERIT
:
900 case R_390_GNU_VTENTRY
:
904 switch (h
->root
.type
)
906 case bfd_link_hash_defined
:
907 case bfd_link_hash_defweak
:
908 return h
->root
.u
.def
.section
;
910 case bfd_link_hash_common
:
911 return h
->root
.u
.c
.p
->section
;
920 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
926 /* Update the got entry reference counts for the section being removed. */
929 elf_s390_gc_sweep_hook (abfd
, info
, sec
, relocs
)
931 struct bfd_link_info
*info
;
933 const Elf_Internal_Rela
*relocs
;
935 Elf_Internal_Shdr
*symtab_hdr
;
936 struct elf_link_hash_entry
**sym_hashes
;
937 bfd_signed_vma
*local_got_refcounts
;
938 const Elf_Internal_Rela
*rel
, *relend
;
939 unsigned long r_symndx
;
940 struct elf_link_hash_entry
*h
;
942 elf_section_data (sec
)->local_dynrel
= NULL
;
944 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
945 sym_hashes
= elf_sym_hashes (abfd
);
946 local_got_refcounts
= elf_local_got_refcounts (abfd
);
948 relend
= relocs
+ sec
->reloc_count
;
949 for (rel
= relocs
; rel
< relend
; rel
++)
950 switch (ELF32_R_TYPE (rel
->r_info
))
957 r_symndx
= ELF32_R_SYM (rel
->r_info
);
958 if (r_symndx
>= symtab_hdr
->sh_info
)
960 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
961 if (h
->got
.refcount
> 0)
962 h
->got
.refcount
-= 1;
964 else if (local_got_refcounts
!= NULL
)
966 if (local_got_refcounts
[r_symndx
] > 0)
967 local_got_refcounts
[r_symndx
] -= 1;
978 r_symndx
= ELF32_R_SYM (rel
->r_info
);
979 if (r_symndx
>= symtab_hdr
->sh_info
)
981 struct elf_s390_link_hash_entry
*eh
;
982 struct elf_s390_dyn_relocs
**pp
;
983 struct elf_s390_dyn_relocs
*p
;
985 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
987 if (!info
->shared
&& h
->plt
.refcount
> 0)
988 h
->plt
.refcount
-= 1;
990 eh
= (struct elf_s390_link_hash_entry
*) h
;
992 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
995 if (ELF32_R_TYPE (rel
->r_info
) == R_390_PC16
996 || ELF32_R_TYPE (rel
->r_info
) == R_390_PC16DBL
997 || ELF32_R_TYPE (rel
->r_info
) == R_390_PC32
)
1007 case R_390_PLT16DBL
:
1009 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1010 if (r_symndx
>= symtab_hdr
->sh_info
)
1012 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1013 if (h
->plt
.refcount
> 0)
1014 h
->plt
.refcount
-= 1;
1025 /* Adjust a symbol defined by a dynamic object and referenced by a
1026 regular object. The current definition is in some section of the
1027 dynamic object, but we're not including those sections. We have to
1028 change the definition to something the rest of the link can
1032 elf_s390_adjust_dynamic_symbol (info
, h
)
1033 struct bfd_link_info
*info
;
1034 struct elf_link_hash_entry
*h
;
1036 struct elf_s390_link_hash_table
*htab
;
1037 struct elf_s390_link_hash_entry
* eh
;
1038 struct elf_s390_dyn_relocs
*p
;
1040 unsigned int power_of_two
;
1042 /* If this is a function, put it in the procedure linkage table. We
1043 will fill in the contents of the procedure linkage table later
1044 (although we could actually do it here). */
1045 if (h
->type
== STT_FUNC
1046 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
1048 if (h
->plt
.refcount
<= 0
1050 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1051 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0
1052 && h
->root
.type
!= bfd_link_hash_undefweak
1053 && h
->root
.type
!= bfd_link_hash_undefined
))
1055 /* This case can occur if we saw a PLT32 reloc in an input
1056 file, but the symbol was never referred to by a dynamic
1057 object, or if all references were garbage collected. In
1058 such a case, we don't actually need to build a procedure
1059 linkage table, and we can just do a PC32 reloc instead. */
1060 h
->plt
.offset
= (bfd_vma
) -1;
1061 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1067 /* It's possible that we incorrectly decided a .plt reloc was
1068 needed for an R_390_PC32 reloc to a non-function sym in
1069 check_relocs. We can't decide accurately between function and
1070 non-function syms in check-relocs; Objects loaded later in
1071 the link may change h->type. So fix it now. */
1072 h
->plt
.offset
= (bfd_vma
) -1;
1074 /* If this is a weak symbol, and there is a real definition, the
1075 processor independent code will have arranged for us to see the
1076 real definition first, and we can just use the same value. */
1077 if (h
->weakdef
!= NULL
)
1079 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
1080 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
1081 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
1082 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
1086 /* This is a reference to a symbol defined by a dynamic object which
1087 is not a function. */
1089 /* If we are creating a shared library, we must presume that the
1090 only references to the symbol are via the global offset table.
1091 For such cases we need not do anything here; the relocations will
1092 be handled correctly by relocate_section. */
1096 /* If there are no references to this symbol that do not use the
1097 GOT, we don't need to generate a copy reloc. */
1098 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
1101 /* If -z nocopyreloc was given, we won't generate them either. */
1102 if (info
->nocopyreloc
)
1104 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_GOT_REF
;
1108 eh
= (struct elf_s390_link_hash_entry
*) h
;
1109 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1111 s
= p
->sec
->output_section
;
1112 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1116 /* If we didn't find any dynamic relocs in read-only sections, then
1117 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1120 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_GOT_REF
;
1124 /* We must allocate the symbol in our .dynbss section, which will
1125 become part of the .bss section of the executable. There will be
1126 an entry for this symbol in the .dynsym section. The dynamic
1127 object will contain position independent code, so all references
1128 from the dynamic object to this symbol will go through the global
1129 offset table. The dynamic linker will use the .dynsym entry to
1130 determine the address it must put in the global offset table, so
1131 both the dynamic object and the regular object will refer to the
1132 same memory location for the variable. */
1134 htab
= elf_s390_hash_table (info
);
1136 /* We must generate a R_390_COPY reloc to tell the dynamic linker to
1137 copy the initial value out of the dynamic object and into the
1138 runtime process image. */
1139 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1141 htab
->srelbss
->_raw_size
+= sizeof (Elf32_External_Rela
);
1142 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
1145 /* We need to figure out the alignment required for this symbol. I
1146 have no idea how ELF linkers handle this. */
1147 power_of_two
= bfd_log2 (h
->size
);
1148 if (power_of_two
> 3)
1151 /* Apply the required alignment. */
1153 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
, (bfd_size_type
) (1 << power_of_two
));
1154 if (power_of_two
> bfd_get_section_alignment (htab
->elf
.dynobj
, s
))
1156 if (! bfd_set_section_alignment (htab
->elf
.dynobj
, s
, power_of_two
))
1160 /* Define the symbol as being at this point in the section. */
1161 h
->root
.u
.def
.section
= s
;
1162 h
->root
.u
.def
.value
= s
->_raw_size
;
1164 /* Increment the section size to make room for the symbol. */
1165 s
->_raw_size
+= h
->size
;
1170 /* This is the condition under which elf_s390_finish_dynamic_symbol
1171 will be called from elflink.h. If elflink.h doesn't call our
1172 finish_dynamic_symbol routine, we'll need to do something about
1173 initializing any .plt and .got entries in elf_s390_relocate_section. */
1174 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1176 && ((INFO)->shared \
1177 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1178 && ((H)->dynindx != -1 \
1179 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1181 /* Allocate space in .plt, .got and associated reloc sections for
1185 allocate_dynrelocs (h
, inf
)
1186 struct elf_link_hash_entry
*h
;
1189 struct bfd_link_info
*info
;
1190 struct elf_s390_link_hash_table
*htab
;
1191 struct elf_s390_link_hash_entry
*eh
;
1192 struct elf_s390_dyn_relocs
*p
;
1194 if (h
->root
.type
== bfd_link_hash_indirect
1195 || h
->root
.type
== bfd_link_hash_warning
)
1198 info
= (struct bfd_link_info
*) inf
;
1199 htab
= elf_s390_hash_table (info
);
1201 if (htab
->elf
.dynamic_sections_created
1202 && h
->plt
.refcount
> 0)
1204 /* Make sure this symbol is output as a dynamic symbol.
1205 Undefined weak syms won't yet be marked as dynamic. */
1206 if (h
->dynindx
== -1
1207 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1209 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1213 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
, h
))
1215 asection
*s
= htab
->splt
;
1217 /* If this is the first .plt entry, make room for the special
1219 if (s
->_raw_size
== 0)
1220 s
->_raw_size
+= PLT_FIRST_ENTRY_SIZE
;
1222 h
->plt
.offset
= s
->_raw_size
;
1224 /* If this symbol is not defined in a regular file, and we are
1225 not generating a shared library, then set the symbol to this
1226 location in the .plt. This is required to make function
1227 pointers compare as equal between the normal executable and
1228 the shared library. */
1230 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1232 h
->root
.u
.def
.section
= s
;
1233 h
->root
.u
.def
.value
= h
->plt
.offset
;
1236 /* Make room for this entry. */
1237 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1239 /* We also need to make an entry in the .got.plt section, which
1240 will be placed in the .got section by the linker script. */
1241 htab
->sgotplt
->_raw_size
+= GOT_ENTRY_SIZE
;
1243 /* We also need to make an entry in the .rela.plt section. */
1244 htab
->srelplt
->_raw_size
+= sizeof (Elf32_External_Rela
);
1248 h
->plt
.offset
= (bfd_vma
) -1;
1249 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1254 h
->plt
.offset
= (bfd_vma
) -1;
1255 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1258 if (h
->got
.refcount
> 0)
1263 /* Make sure this symbol is output as a dynamic symbol.
1264 Undefined weak syms won't yet be marked as dynamic. */
1265 if (h
->dynindx
== -1
1266 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1268 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1273 h
->got
.offset
= s
->_raw_size
;
1274 s
->_raw_size
+= GOT_ENTRY_SIZE
;
1275 dyn
= htab
->elf
.dynamic_sections_created
;
1276 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
))
1277 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rela
);
1280 h
->got
.offset
= (bfd_vma
) -1;
1282 eh
= (struct elf_s390_link_hash_entry
*) h
;
1283 if (eh
->dyn_relocs
== NULL
)
1286 /* In the shared -Bsymbolic case, discard space allocated for
1287 dynamic pc-relative relocs against symbols which turn out to be
1288 defined in regular objects. For the normal shared case, discard
1289 space for pc-relative relocs that have become local due to symbol
1290 visibility changes. */
1294 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1295 && ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0
1298 struct elf_s390_dyn_relocs
**pp
;
1300 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1302 p
->count
-= p
->pc_count
;
1313 /* For the non-shared case, discard space for relocs against
1314 symbols which turn out to need copy relocs or are not
1317 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1318 && (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1319 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1320 || (htab
->elf
.dynamic_sections_created
1321 && (h
->root
.type
== bfd_link_hash_undefweak
1322 || h
->root
.type
== bfd_link_hash_undefined
))))
1324 /* Make sure this symbol is output as a dynamic symbol.
1325 Undefined weak syms won't yet be marked as dynamic. */
1326 if (h
->dynindx
== -1
1327 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1329 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1333 /* If that succeeded, we know we'll be keeping all the
1335 if (h
->dynindx
!= -1)
1339 eh
->dyn_relocs
= NULL
;
1344 /* Finally, allocate space. */
1345 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1347 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1348 sreloc
->_raw_size
+= p
->count
* sizeof (Elf32_External_Rela
);
1354 /* Find any dynamic relocs that apply to read-only sections. */
1357 readonly_dynrelocs (h
, inf
)
1358 struct elf_link_hash_entry
*h
;
1361 struct elf_s390_link_hash_entry
*eh
;
1362 struct elf_s390_dyn_relocs
*p
;
1364 eh
= (struct elf_s390_link_hash_entry
*) h
;
1365 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1367 asection
*s
= p
->sec
->output_section
;
1369 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1371 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
1373 info
->flags
|= DF_TEXTREL
;
1375 /* Not an error, just cut short the traversal. */
1382 /* Set the sizes of the dynamic sections. */
1385 elf_s390_size_dynamic_sections (output_bfd
, info
)
1386 bfd
*output_bfd ATTRIBUTE_UNUSED
;
1387 struct bfd_link_info
*info
;
1389 struct elf_s390_link_hash_table
*htab
;
1395 htab
= elf_s390_hash_table (info
);
1396 dynobj
= htab
->elf
.dynobj
;
1400 if (htab
->elf
.dynamic_sections_created
)
1402 /* Set the contents of the .interp section to the interpreter. */
1405 s
= bfd_get_section_by_name (dynobj
, ".interp");
1408 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1409 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1413 /* Set up .got offsets for local syms, and space for local dynamic
1415 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
1417 bfd_signed_vma
*local_got
;
1418 bfd_signed_vma
*end_local_got
;
1419 bfd_size_type locsymcount
;
1420 Elf_Internal_Shdr
*symtab_hdr
;
1423 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
1426 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1428 struct elf_s390_dyn_relocs
*p
;
1430 for (p
= *((struct elf_s390_dyn_relocs
**)
1431 &elf_section_data (s
)->local_dynrel
);
1435 if (!bfd_is_abs_section (p
->sec
)
1436 && bfd_is_abs_section (p
->sec
->output_section
))
1438 /* Input section has been discarded, either because
1439 it is a copy of a linkonce section or due to
1440 linker script /DISCARD/, so we'll be discarding
1443 else if (p
->count
!= 0)
1445 srela
= elf_section_data (p
->sec
)->sreloc
;
1446 srela
->_raw_size
+= p
->count
* sizeof (Elf32_External_Rela
);
1447 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1448 info
->flags
|= DF_TEXTREL
;
1453 local_got
= elf_local_got_refcounts (ibfd
);
1457 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1458 locsymcount
= symtab_hdr
->sh_info
;
1459 end_local_got
= local_got
+ locsymcount
;
1461 srela
= htab
->srelgot
;
1462 for (; local_got
< end_local_got
; ++local_got
)
1466 *local_got
= s
->_raw_size
;
1467 s
->_raw_size
+= GOT_ENTRY_SIZE
;
1469 srela
->_raw_size
+= sizeof (Elf32_External_Rela
);
1472 *local_got
= (bfd_vma
) -1;
1476 /* Allocate global sym .plt and .got entries, and space for global
1477 sym dynamic relocs. */
1478 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, (PTR
) info
);
1480 /* We now have determined the sizes of the various dynamic sections.
1481 Allocate memory for them. */
1483 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1485 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1490 || s
== htab
->sgotplt
)
1492 /* Strip this section if we don't need it; see the
1495 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rela", 5) == 0)
1497 if (s
->_raw_size
!= 0 && s
!= htab
->srelplt
)
1500 /* We use the reloc_count field as a counter if we need
1501 to copy relocs into the output file. */
1506 /* It's not one of our sections, so don't allocate space. */
1510 if (s
->_raw_size
== 0)
1512 /* If we don't need this section, strip it from the
1513 output file. This is to handle .rela.bss and
1514 .rela.plt. We must create it in
1515 create_dynamic_sections, because it must be created
1516 before the linker maps input sections to output
1517 sections. The linker does that before
1518 adjust_dynamic_symbol is called, and it is that
1519 function which decides whether anything needs to go
1520 into these sections. */
1522 _bfd_strip_section_from_output (info
, s
);
1526 /* Allocate memory for the section contents. We use bfd_zalloc
1527 here in case unused entries are not reclaimed before the
1528 section's contents are written out. This should not happen,
1529 but this way if it does, we get a R_390_NONE reloc instead
1531 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1532 if (s
->contents
== NULL
)
1536 if (htab
->elf
.dynamic_sections_created
)
1538 /* Add some entries to the .dynamic section. We fill in the
1539 values later, in elf_s390_finish_dynamic_sections, but we
1540 must add the entries now so that we get the correct size for
1541 the .dynamic section. The DT_DEBUG entry is filled in by the
1542 dynamic linker and used by the debugger. */
1543 #define add_dynamic_entry(TAG, VAL) \
1544 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1548 if (!add_dynamic_entry (DT_DEBUG
, 0))
1552 if (htab
->splt
->_raw_size
!= 0)
1554 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1555 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1556 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1557 || !add_dynamic_entry (DT_JMPREL
, 0))
1563 if (!add_dynamic_entry (DT_RELA
, 0)
1564 || !add_dynamic_entry (DT_RELASZ
, 0)
1565 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
1568 /* If any dynamic relocs apply to a read-only section,
1569 then we need a DT_TEXTREL entry. */
1570 if ((info
->flags
& DF_TEXTREL
) == 0)
1571 elf_link_hash_traverse (&htab
->elf
, readonly_dynrelocs
,
1574 if ((info
->flags
& DF_TEXTREL
) != 0)
1576 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1581 #undef add_dynamic_entry
1586 /* Relocate a 390 ELF section. */
1589 elf_s390_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1590 contents
, relocs
, local_syms
, local_sections
)
1592 struct bfd_link_info
*info
;
1594 asection
*input_section
;
1596 Elf_Internal_Rela
*relocs
;
1597 Elf_Internal_Sym
*local_syms
;
1598 asection
**local_sections
;
1600 struct elf_s390_link_hash_table
*htab
;
1601 Elf_Internal_Shdr
*symtab_hdr
;
1602 struct elf_link_hash_entry
**sym_hashes
;
1603 bfd_vma
*local_got_offsets
;
1604 Elf_Internal_Rela
*rel
;
1605 Elf_Internal_Rela
*relend
;
1607 htab
= elf_s390_hash_table (info
);
1608 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1609 sym_hashes
= elf_sym_hashes (input_bfd
);
1610 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1613 relend
= relocs
+ input_section
->reloc_count
;
1614 for (; rel
< relend
; rel
++)
1617 reloc_howto_type
*howto
;
1618 unsigned long r_symndx
;
1619 struct elf_link_hash_entry
*h
;
1620 Elf_Internal_Sym
*sym
;
1624 boolean unresolved_reloc
;
1625 bfd_reloc_status_type r
;
1627 r_type
= ELF32_R_TYPE (rel
->r_info
);
1628 if (r_type
== (int) R_390_GNU_VTINHERIT
1629 || r_type
== (int) R_390_GNU_VTENTRY
)
1631 if (r_type
< 0 || r_type
>= (int) R_390_max
)
1633 bfd_set_error (bfd_error_bad_value
);
1636 howto
= elf_howto_table
+ r_type
;
1638 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1640 if (info
->relocateable
)
1642 /* This is a relocateable link. We don't have to change
1643 anything, unless the reloc is against a section symbol,
1644 in which case we have to adjust according to where the
1645 section symbol winds up in the output section. */
1646 if (r_symndx
< symtab_hdr
->sh_info
)
1648 sym
= local_syms
+ r_symndx
;
1649 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1651 sec
= local_sections
[r_symndx
];
1652 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1659 /* This is a final link. */
1663 unresolved_reloc
= false;
1664 if (r_symndx
< symtab_hdr
->sh_info
)
1666 sym
= local_syms
+ r_symndx
;
1667 sec
= local_sections
[r_symndx
];
1668 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, sec
, rel
);
1672 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1673 while (h
->root
.type
== bfd_link_hash_indirect
1674 || h
->root
.type
== bfd_link_hash_warning
)
1675 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1677 if (h
->root
.type
== bfd_link_hash_defined
1678 || h
->root
.type
== bfd_link_hash_defweak
)
1680 sec
= h
->root
.u
.def
.section
;
1681 if (sec
->output_section
== NULL
)
1683 /* Set a flag that will be cleared later if we find a
1684 relocation value for this symbol. output_section
1685 is typically NULL for symbols satisfied by a shared
1687 unresolved_reloc
= true;
1691 relocation
= (h
->root
.u
.def
.value
1692 + sec
->output_section
->vma
1693 + sec
->output_offset
);
1695 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1697 else if (info
->shared
1698 && (!info
->symbolic
|| info
->allow_shlib_undefined
)
1699 && !info
->no_undefined
1700 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1704 if (! ((*info
->callbacks
->undefined_symbol
)
1705 (info
, h
->root
.root
.string
, input_bfd
,
1706 input_section
, rel
->r_offset
,
1707 (!info
->shared
|| info
->no_undefined
1708 || ELF_ST_VISIBILITY (h
->other
)))))
1719 /* Relocation is to the entry for this symbol in the global
1721 if (htab
->sgot
== NULL
)
1728 off
= h
->got
.offset
;
1729 dyn
= htab
->elf
.dynamic_sections_created
;
1730 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
)
1734 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
1735 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1737 /* This is actually a static link, or it is a
1738 -Bsymbolic link and the symbol is defined
1739 locally, or the symbol was forced to be local
1740 because of a version file. We must initialize
1741 this entry in the global offset table. Since the
1742 offset must always be a multiple of 2, we use the
1743 least significant bit to record whether we have
1744 initialized it already.
1746 When doing a dynamic link, we create a .rel.got
1747 relocation entry to initialize the value. This
1748 is done in the finish_dynamic_symbol routine. */
1753 bfd_put_32 (output_bfd
, relocation
,
1754 htab
->sgot
->contents
+ off
);
1759 unresolved_reloc
= false;
1763 if (local_got_offsets
== NULL
)
1766 off
= local_got_offsets
[r_symndx
];
1768 /* The offset must always be a multiple of 4. We use
1769 the least significant bit to record whether we have
1770 already generated the necessary reloc. */
1775 bfd_put_32 (output_bfd
, relocation
,
1776 htab
->sgot
->contents
+ off
);
1781 Elf_Internal_Rela outrel
;
1782 Elf32_External_Rela
*loc
;
1784 srelgot
= htab
->srelgot
;
1785 if (srelgot
== NULL
)
1788 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
1789 + htab
->sgot
->output_offset
1791 outrel
.r_info
= ELF32_R_INFO (0, R_390_RELATIVE
);
1792 outrel
.r_addend
= relocation
;
1793 loc
= (Elf32_External_Rela
*) srelgot
->contents
;
1794 loc
+= srelgot
->reloc_count
++;
1795 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1798 local_got_offsets
[r_symndx
] |= 1;
1802 if (off
>= (bfd_vma
) -2)
1805 relocation
= htab
->sgot
->output_offset
+ off
;
1809 /* Relocation is relative to the start of the global offset
1812 /* Note that sgot->output_offset is not involved in this
1813 calculation. We always want the start of .got. If we
1814 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1815 permitted by the ABI, we might have to change this
1817 relocation
-= htab
->sgot
->output_section
->vma
;
1821 /* Use global offset table as symbol value. */
1822 relocation
= htab
->sgot
->output_section
->vma
;
1823 unresolved_reloc
= false;
1826 case R_390_PLT16DBL
:
1828 /* Relocation is to the entry for this symbol in the
1829 procedure linkage table. */
1831 /* Resolve a PLT32 reloc against a local symbol directly,
1832 without using the procedure linkage table. */
1836 if (h
->plt
.offset
== (bfd_vma
) -1
1837 || htab
->splt
== NULL
)
1839 /* We didn't make a PLT entry for this symbol. This
1840 happens when statically linking PIC code, or when
1841 using -Bsymbolic. */
1845 relocation
= (htab
->splt
->output_section
->vma
1846 + htab
->splt
->output_offset
1848 unresolved_reloc
= false;
1857 /* r_symndx will be zero only for relocs against symbols
1858 from removed linkonce sections, or sections discarded by
1861 || (input_section
->flags
& SEC_ALLOC
) == 0)
1865 && ((r_type
!= R_390_PC16
1866 && r_type
!= R_390_PC16DBL
1867 && r_type
!= R_390_PC32
)
1870 && (! info
->symbolic
1871 || (h
->elf_link_hash_flags
1872 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1876 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1877 && (((h
->elf_link_hash_flags
1878 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1879 && (h
->elf_link_hash_flags
1880 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
1881 || h
->root
.type
== bfd_link_hash_undefweak
1882 || h
->root
.type
== bfd_link_hash_undefined
)))
1884 Elf_Internal_Rela outrel
;
1885 boolean skip
, relocate
;
1887 Elf32_External_Rela
*loc
;
1889 /* When generating a shared object, these relocations
1890 are copied into the output file to be resolved at run
1897 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1899 if (outrel
.r_offset
== (bfd_vma
) -1)
1901 else if (outrel
.r_offset
== (bfd_vma
) -2)
1902 skip
= true, relocate
= true;
1903 outrel
.r_offset
+= (input_section
->output_section
->vma
1904 + input_section
->output_offset
);
1907 memset (&outrel
, 0, sizeof outrel
);
1910 && (r_type
== R_390_PC16
1911 || r_type
== R_390_PC16DBL
1912 || r_type
== R_390_PC32
1915 || (h
->elf_link_hash_flags
1916 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1918 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1919 outrel
.r_addend
= rel
->r_addend
;
1923 /* This symbol is local, or marked to become local. */
1925 outrel
.r_info
= ELF32_R_INFO (0, R_390_RELATIVE
);
1926 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1929 sreloc
= elf_section_data (input_section
)->sreloc
;
1933 loc
= (Elf32_External_Rela
*) sreloc
->contents
;
1934 loc
+= sreloc
->reloc_count
++;
1935 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1937 /* If this reloc is against an external symbol, we do
1938 not want to fiddle with the addend. Otherwise, we
1939 need to include the symbol value so that it becomes
1940 an addend for the dynamic reloc. */
1950 if (unresolved_reloc
1952 && (input_section
->flags
& SEC_DEBUGGING
) != 0
1953 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
1954 (*_bfd_error_handler
)
1955 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
1956 bfd_archive_filename (input_bfd
),
1957 bfd_get_section_name (input_bfd
, input_section
),
1958 (long) rel
->r_offset
,
1959 h
->root
.root
.string
);
1961 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1962 contents
, rel
->r_offset
,
1963 relocation
, rel
->r_addend
);
1965 if (r
!= bfd_reloc_ok
)
1970 name
= h
->root
.root
.string
;
1973 name
= bfd_elf_string_from_elf_section (input_bfd
,
1974 symtab_hdr
->sh_link
,
1979 name
= bfd_section_name (input_bfd
, sec
);
1982 if (r
== bfd_reloc_overflow
)
1985 if (! ((*info
->callbacks
->reloc_overflow
)
1986 (info
, name
, howto
->name
, (bfd_vma
) 0,
1987 input_bfd
, input_section
, rel
->r_offset
)))
1992 (*_bfd_error_handler
)
1993 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
1994 bfd_archive_filename (input_bfd
),
1995 bfd_get_section_name (input_bfd
, input_section
),
1996 (long) rel
->r_offset
, name
, (int) r
);
2005 /* Finish up dynamic symbol handling. We set the contents of various
2006 dynamic sections here. */
2009 elf_s390_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
2011 struct bfd_link_info
*info
;
2012 struct elf_link_hash_entry
*h
;
2013 Elf_Internal_Sym
*sym
;
2015 struct elf_s390_link_hash_table
*htab
;
2017 htab
= elf_s390_hash_table (info
);
2019 if (h
->plt
.offset
!= (bfd_vma
) -1)
2023 Elf_Internal_Rela rela
;
2024 Elf32_External_Rela
*loc
;
2025 bfd_vma relative_offset
;
2027 /* This symbol has an entry in the procedure linkage table. Set
2030 if (h
->dynindx
== -1
2031 || htab
->splt
== NULL
2032 || htab
->sgotplt
== NULL
2033 || htab
->srelplt
== NULL
)
2037 Current offset - size first entry / entry size. */
2038 plt_index
= (h
->plt
.offset
- PLT_FIRST_ENTRY_SIZE
) / PLT_ENTRY_SIZE
;
2040 /* Offset in GOT is PLT index plus GOT headers(3) times 4,
2042 got_offset
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
2044 /* S390 uses halfwords for relative branch calc! */
2045 relative_offset
= - ((PLT_FIRST_ENTRY_SIZE
+
2046 (PLT_ENTRY_SIZE
* plt_index
) + 18) / 2);
2047 /* If offset is > 32768, branch to a previous branch
2048 390 can only handle +-64 K jumps. */
2049 if ( -32768 > (int) relative_offset
)
2051 -(unsigned) (((65536 / PLT_ENTRY_SIZE
- 1) * PLT_ENTRY_SIZE
) / 2);
2053 /* Fill in the entry in the procedure linkage table. */
2056 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD0
,
2057 htab
->splt
->contents
+ h
->plt
.offset
);
2058 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD1
,
2059 htab
->splt
->contents
+ h
->plt
.offset
+ 4);
2060 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD2
,
2061 htab
->splt
->contents
+ h
->plt
.offset
+ 8);
2062 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD3
,
2063 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
2064 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD4
,
2065 htab
->splt
->contents
+ h
->plt
.offset
+ 16);
2066 bfd_put_32 (output_bfd
, (bfd_vma
) 0+(relative_offset
<< 16),
2067 htab
->splt
->contents
+ h
->plt
.offset
+ 20);
2068 bfd_put_32 (output_bfd
,
2069 (htab
->sgotplt
->output_section
->vma
2070 + htab
->sgotplt
->output_offset
2072 htab
->splt
->contents
+ h
->plt
.offset
+ 24);
2074 else if (got_offset
< 4096)
2076 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC12_ENTRY_WORD0
+ got_offset
,
2077 htab
->splt
->contents
+ h
->plt
.offset
);
2078 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC12_ENTRY_WORD1
,
2079 htab
->splt
->contents
+ h
->plt
.offset
+ 4);
2080 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC12_ENTRY_WORD2
,
2081 htab
->splt
->contents
+ h
->plt
.offset
+ 8);
2082 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC12_ENTRY_WORD3
,
2083 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
2084 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC12_ENTRY_WORD4
,
2085 htab
->splt
->contents
+ h
->plt
.offset
+ 16);
2086 bfd_put_32 (output_bfd
, (bfd_vma
) 0+(relative_offset
<< 16),
2087 htab
->splt
->contents
+ h
->plt
.offset
+ 20);
2088 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2089 htab
->splt
->contents
+ h
->plt
.offset
+ 24);
2091 else if (got_offset
< 32768)
2093 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC16_ENTRY_WORD0
+ got_offset
,
2094 htab
->splt
->contents
+ h
->plt
.offset
);
2095 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC16_ENTRY_WORD1
,
2096 htab
->splt
->contents
+ h
->plt
.offset
+ 4);
2097 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC16_ENTRY_WORD2
,
2098 htab
->splt
->contents
+ h
->plt
.offset
+ 8);
2099 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC16_ENTRY_WORD3
,
2100 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
2101 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC16_ENTRY_WORD4
,
2102 htab
->splt
->contents
+ h
->plt
.offset
+ 16);
2103 bfd_put_32 (output_bfd
, (bfd_vma
) 0+(relative_offset
<< 16),
2104 htab
->splt
->contents
+ h
->plt
.offset
+ 20);
2105 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2106 htab
->splt
->contents
+ h
->plt
.offset
+ 24);
2110 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_ENTRY_WORD0
,
2111 htab
->splt
->contents
+ h
->plt
.offset
);
2112 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_ENTRY_WORD1
,
2113 htab
->splt
->contents
+ h
->plt
.offset
+ 4);
2114 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_ENTRY_WORD2
,
2115 htab
->splt
->contents
+ h
->plt
.offset
+ 8);
2116 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_ENTRY_WORD3
,
2117 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
2118 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_ENTRY_WORD4
,
2119 htab
->splt
->contents
+ h
->plt
.offset
+ 16);
2120 bfd_put_32 (output_bfd
, (bfd_vma
) 0+(relative_offset
<< 16),
2121 htab
->splt
->contents
+ h
->plt
.offset
+ 20);
2122 bfd_put_32 (output_bfd
, got_offset
,
2123 htab
->splt
->contents
+ h
->plt
.offset
+ 24);
2125 /* Insert offset into reloc. table here. */
2126 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rela
),
2127 htab
->splt
->contents
+ h
->plt
.offset
+ 28);
2129 /* Fill in the entry in the global offset table.
2130 Points to instruction after GOT offset. */
2131 bfd_put_32 (output_bfd
,
2132 (htab
->splt
->output_section
->vma
2133 + htab
->splt
->output_offset
2136 htab
->sgotplt
->contents
+ got_offset
);
2138 /* Fill in the entry in the .rela.plt section. */
2139 rela
.r_offset
= (htab
->sgotplt
->output_section
->vma
2140 + htab
->sgotplt
->output_offset
2142 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_390_JMP_SLOT
);
2144 loc
= (Elf32_External_Rela
*) htab
->srelplt
->contents
+ plt_index
;
2145 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
2147 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2149 /* Mark the symbol as undefined, rather than as defined in
2150 the .plt section. Leave the value alone. This is a clue
2151 for the dynamic linker, to make function pointer
2152 comparisons work between an application and shared
2154 sym
->st_shndx
= SHN_UNDEF
;
2158 if (h
->got
.offset
!= (bfd_vma
) -1)
2160 Elf_Internal_Rela rela
;
2161 Elf32_External_Rela
*loc
;
2163 /* This symbol has an entry in the global offset table. Set it
2166 if (htab
->sgot
== NULL
|| htab
->srelgot
== NULL
)
2169 rela
.r_offset
= (htab
->sgot
->output_section
->vma
2170 + htab
->sgot
->output_offset
2171 + (h
->got
.offset
&~ (bfd_vma
) 1));
2173 /* If this is a static link, or it is a -Bsymbolic link and the
2174 symbol is defined locally or was forced to be local because
2175 of a version file, we just want to emit a RELATIVE reloc.
2176 The entry in the global offset table will already have been
2177 initialized in the relocate_section function. */
2181 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
2182 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
2184 BFD_ASSERT((h
->got
.offset
& 1) != 0);
2185 rela
.r_info
= ELF32_R_INFO (0, R_390_RELATIVE
);
2186 rela
.r_addend
= (h
->root
.u
.def
.value
2187 + h
->root
.u
.def
.section
->output_section
->vma
2188 + h
->root
.u
.def
.section
->output_offset
);
2192 BFD_ASSERT((h
->got
.offset
& 1) == 0);
2193 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgot
->contents
+ h
->got
.offset
);
2194 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_390_GLOB_DAT
);
2198 loc
= (Elf32_External_Rela
*) htab
->srelgot
->contents
;
2199 loc
+= htab
->srelgot
->reloc_count
++;
2200 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
2203 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
2205 Elf_Internal_Rela rela
;
2206 Elf32_External_Rela
*loc
;
2208 /* This symbols needs a copy reloc. Set it up. */
2210 if (h
->dynindx
== -1
2211 || (h
->root
.type
!= bfd_link_hash_defined
2212 && h
->root
.type
!= bfd_link_hash_defweak
)
2213 || htab
->srelbss
== NULL
)
2216 rela
.r_offset
= (h
->root
.u
.def
.value
2217 + h
->root
.u
.def
.section
->output_section
->vma
2218 + h
->root
.u
.def
.section
->output_offset
);
2219 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_390_COPY
);
2221 loc
= (Elf32_External_Rela
*) htab
->srelbss
->contents
;
2222 loc
+= htab
->srelbss
->reloc_count
++;
2223 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
2226 /* Mark some specially defined symbols as absolute. */
2227 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2228 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
2229 || strcmp (h
->root
.root
.string
, "_PROCEDURE_LINKAGE_TABLE_") == 0)
2230 sym
->st_shndx
= SHN_ABS
;
2235 /* Used to decide how to sort relocs in an optimal manner for the
2236 dynamic linker, before writing them out. */
2238 static enum elf_reloc_type_class
2239 elf_s390_reloc_type_class (rela
)
2240 const Elf_Internal_Rela
*rela
;
2242 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2244 case R_390_RELATIVE
:
2245 return reloc_class_relative
;
2246 case R_390_JMP_SLOT
:
2247 return reloc_class_plt
;
2249 return reloc_class_copy
;
2251 return reloc_class_normal
;
2255 /* Finish up the dynamic sections. */
2258 elf_s390_finish_dynamic_sections (output_bfd
, info
)
2260 struct bfd_link_info
*info
;
2262 struct elf_s390_link_hash_table
*htab
;
2266 htab
= elf_s390_hash_table (info
);
2267 dynobj
= htab
->elf
.dynobj
;
2268 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2270 if (htab
->elf
.dynamic_sections_created
)
2272 Elf32_External_Dyn
*dyncon
, *dynconend
;
2274 if (sdyn
== NULL
|| htab
->sgot
== NULL
)
2277 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2278 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
2279 for (; dyncon
< dynconend
; dyncon
++)
2281 Elf_Internal_Dyn dyn
;
2284 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2292 dyn
.d_un
.d_ptr
= htab
->sgot
->output_section
->vma
;
2296 dyn
.d_un
.d_ptr
= htab
->srelplt
->output_section
->vma
;
2300 s
= htab
->srelplt
->output_section
;
2301 if (s
->_cooked_size
!= 0)
2302 dyn
.d_un
.d_val
= s
->_cooked_size
;
2304 dyn
.d_un
.d_val
= s
->_raw_size
;
2308 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2311 /* Fill in the special first entry in the procedure linkage table. */
2312 if (htab
->splt
&& htab
->splt
->_raw_size
> 0)
2314 memset (htab
->splt
->contents
, 0, PLT_FIRST_ENTRY_SIZE
);
2317 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_FIRST_ENTRY_WORD0
,
2318 htab
->splt
->contents
);
2319 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_FIRST_ENTRY_WORD1
,
2320 htab
->splt
->contents
+4 );
2321 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_FIRST_ENTRY_WORD2
,
2322 htab
->splt
->contents
+8 );
2323 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_FIRST_ENTRY_WORD3
,
2324 htab
->splt
->contents
+12 );
2325 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_FIRST_ENTRY_WORD4
,
2326 htab
->splt
->contents
+16 );
2330 bfd_put_32 (output_bfd
, (bfd_vma
)PLT_FIRST_ENTRY_WORD0
,
2331 htab
->splt
->contents
);
2332 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD1
,
2333 htab
->splt
->contents
+4 );
2334 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD2
,
2335 htab
->splt
->contents
+8 );
2336 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD3
,
2337 htab
->splt
->contents
+12 );
2338 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD4
,
2339 htab
->splt
->contents
+16 );
2340 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD5
,
2341 htab
->splt
->contents
+20 );
2342 bfd_put_32 (output_bfd
,
2343 htab
->sgotplt
->output_section
->vma
2344 + htab
->sgotplt
->output_offset
,
2345 htab
->splt
->contents
+ 24);
2347 elf_section_data (htab
->splt
->output_section
)
2348 ->this_hdr
.sh_entsize
= 4;
2355 /* Fill in the first three entries in the global offset table. */
2356 if (htab
->sgotplt
->_raw_size
> 0)
2358 bfd_put_32 (output_bfd
,
2359 (sdyn
== NULL
? (bfd_vma
) 0
2360 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
2361 htab
->sgotplt
->contents
);
2362 /* One entry for shared object struct ptr. */
2363 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 4);
2364 /* One entry for _dl_runtime_resolve. */
2365 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 8);
2368 elf_section_data (htab
->sgotplt
->output_section
)
2369 ->this_hdr
.sh_entsize
= 4;
2375 elf_s390_object_p (abfd
)
2378 return bfd_default_set_arch_mach (abfd
, bfd_arch_s390
, bfd_mach_s390_esa
);
2382 elf_s390_grok_prstatus (abfd
, note
)
2384 Elf_Internal_Note
* note
;
2387 unsigned int raw_size
;
2389 switch (note
->descsz
)
2394 case 224: /* S/390 Linux. */
2396 elf_tdata (abfd
)->core_signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
2399 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
2407 /* Make a ".reg/999" section. */
2408 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
2409 raw_size
, note
->descpos
+ offset
);
2412 #define TARGET_BIG_SYM bfd_elf32_s390_vec
2413 #define TARGET_BIG_NAME "elf32-s390"
2414 #define ELF_ARCH bfd_arch_s390
2415 #define ELF_MACHINE_CODE EM_S390
2416 #define ELF_MACHINE_ALT1 EM_S390_OLD
2417 #define ELF_MAXPAGESIZE 0x1000
2419 #define elf_backend_can_gc_sections 1
2420 #define elf_backend_can_refcount 1
2421 #define elf_backend_want_got_plt 1
2422 #define elf_backend_plt_readonly 1
2423 #define elf_backend_want_plt_sym 0
2424 #define elf_backend_got_header_size 12
2425 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
2427 #define elf_info_to_howto elf_s390_info_to_howto
2429 #define bfd_elf32_bfd_is_local_label_name elf_s390_is_local_label_name
2430 #define bfd_elf32_bfd_link_hash_table_create elf_s390_link_hash_table_create
2431 #define bfd_elf32_bfd_reloc_type_lookup elf_s390_reloc_type_lookup
2433 #define elf_backend_adjust_dynamic_symbol elf_s390_adjust_dynamic_symbol
2434 #define elf_backend_check_relocs elf_s390_check_relocs
2435 #define elf_backend_copy_indirect_symbol elf_s390_copy_indirect_symbol
2436 #define elf_backend_create_dynamic_sections elf_s390_create_dynamic_sections
2437 #define elf_backend_finish_dynamic_sections elf_s390_finish_dynamic_sections
2438 #define elf_backend_finish_dynamic_symbol elf_s390_finish_dynamic_symbol
2439 #define elf_backend_gc_mark_hook elf_s390_gc_mark_hook
2440 #define elf_backend_gc_sweep_hook elf_s390_gc_sweep_hook
2441 #define elf_backend_reloc_type_class elf_s390_reloc_type_class
2442 #define elf_backend_relocate_section elf_s390_relocate_section
2443 #define elf_backend_size_dynamic_sections elf_s390_size_dynamic_sections
2444 #define elf_backend_reloc_type_class elf_s390_reloc_type_class
2445 #define elf_backend_grok_prstatus elf_s390_grok_prstatus
2447 #define elf_backend_object_p elf_s390_object_p
2449 #include "elf32-target.h"