1 /* IBM S/390-specific support for 32-bit ELF
2 Copyright 2000, 2001, 2002 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 bfd_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 bfd_boolean create_got_section
39 PARAMS((bfd
*, struct bfd_link_info
*));
40 static bfd_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_backend_data
*, struct elf_link_hash_entry
*,
44 struct elf_link_hash_entry
*));
45 static bfd_boolean elf_s390_check_relocs
46 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
47 const Elf_Internal_Rela
*));
48 static asection
*elf_s390_gc_mark_hook
49 PARAMS ((asection
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
50 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
51 static bfd_boolean elf_s390_gc_sweep_hook
52 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
53 const Elf_Internal_Rela
*));
54 static bfd_boolean elf_s390_adjust_dynamic_symbol
55 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
56 static bfd_boolean allocate_dynrelocs
57 PARAMS ((struct elf_link_hash_entry
*, PTR
));
58 static bfd_boolean readonly_dynrelocs
59 PARAMS ((struct elf_link_hash_entry
*, PTR
));
60 static bfd_boolean elf_s390_size_dynamic_sections
61 PARAMS ((bfd
*, struct bfd_link_info
*));
62 static bfd_boolean elf_s390_relocate_section
63 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
64 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
65 static bfd_boolean elf_s390_finish_dynamic_symbol
66 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
68 static enum elf_reloc_type_class elf_s390_reloc_type_class
69 PARAMS ((const Elf_Internal_Rela
*));
70 static bfd_boolean elf_s390_finish_dynamic_sections
71 PARAMS ((bfd
*, struct bfd_link_info
*));
72 static bfd_boolean elf_s390_object_p
74 static bfd_boolean elf_s390_grok_prstatus
75 PARAMS ((bfd
*, Elf_Internal_Note
*));
79 /* The relocation "howto" table. */
81 static reloc_howto_type elf_howto_table
[] =
83 HOWTO (R_390_NONE
, /* type */
85 0, /* size (0 = byte, 1 = short, 2 = long) */
87 FALSE
, /* pc_relative */
89 complain_overflow_dont
, /* complain_on_overflow */
90 bfd_elf_generic_reloc
, /* special_function */
91 "R_390_NONE", /* name */
92 FALSE
, /* partial_inplace */
95 FALSE
), /* pcrel_offset */
97 HOWTO(R_390_8
, 0, 0, 8, FALSE
, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_8", FALSE
, 0,0x000000ff, FALSE
),
98 HOWTO(R_390_12
, 0, 1, 12, FALSE
, 0, complain_overflow_dont
, bfd_elf_generic_reloc
, "R_390_12", FALSE
, 0,0x00000fff, FALSE
),
99 HOWTO(R_390_16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_16", FALSE
, 0,0x0000ffff, FALSE
),
100 HOWTO(R_390_32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_32", FALSE
, 0,0xffffffff, FALSE
),
101 HOWTO(R_390_PC32
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PC32", FALSE
, 0,0xffffffff, TRUE
),
102 HOWTO(R_390_GOT12
, 0, 1, 12, FALSE
, 0, complain_overflow_dont
, bfd_elf_generic_reloc
, "R_390_GOT12", FALSE
, 0,0x00000fff, FALSE
),
103 HOWTO(R_390_GOT32
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_GOT32", FALSE
, 0,0xffffffff, FALSE
),
104 HOWTO(R_390_PLT32
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PLT32", FALSE
, 0,0xffffffff, TRUE
),
105 HOWTO(R_390_COPY
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_COPY", FALSE
, 0,0xffffffff, FALSE
),
106 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
),
107 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
),
108 HOWTO(R_390_RELATIVE
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_RELATIVE",FALSE
, 0,0xffffffff, FALSE
),
109 HOWTO(R_390_GOTOFF
, 0, 2, 32, FALSE
, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_GOTOFF", FALSE
, 0,0xffffffff, FALSE
),
110 HOWTO(R_390_GOTPC
, 0, 2, 32, TRUE
, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_GOTPC", FALSE
, 0,0xffffffff, TRUE
),
111 HOWTO(R_390_GOT16
, 0, 1, 16, FALSE
, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_GOT16", FALSE
, 0,0x0000ffff, FALSE
),
112 HOWTO(R_390_PC16
, 0, 1, 16, TRUE
, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PC16", FALSE
, 0,0x0000ffff, TRUE
),
113 HOWTO(R_390_PC16DBL
, 1, 1, 16, TRUE
, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PC16DBL", FALSE
, 0,0x0000ffff, TRUE
),
114 HOWTO(R_390_PLT16DBL
, 1, 1, 16, TRUE
, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PLT16DBL", FALSE
, 0,0x0000ffff, TRUE
),
115 HOWTO(R_390_PC32DBL
, 1, 2, 32, TRUE
, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PC32DBL", FALSE
, 0,0xffffffff, TRUE
),
116 HOWTO(R_390_PLT32DBL
, 1, 2, 32, TRUE
, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PLT32DBL", FALSE
, 0,0xffffffff, TRUE
),
117 HOWTO(R_390_GOTPCDBL
, 1, 2, 32, TRUE
, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_GOTPCDBL", FALSE
, 0,0xffffffff, TRUE
),
118 HOWTO(R_390_GOTENT
, 1, 2, 32, TRUE
, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_GOTENT", FALSE
, 0,0xffffffff, TRUE
),
121 /* GNU extension to record C++ vtable hierarchy. */
122 static reloc_howto_type elf32_s390_vtinherit_howto
=
123 HOWTO (R_390_GNU_VTINHERIT
, 0,2,0,FALSE
,0,complain_overflow_dont
, NULL
, "R_390_GNU_VTINHERIT", FALSE
,0, 0, FALSE
);
124 static reloc_howto_type elf32_s390_vtentry_howto
=
125 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
);
127 static reloc_howto_type
*
128 elf_s390_reloc_type_lookup (abfd
, code
)
129 bfd
*abfd ATTRIBUTE_UNUSED
;
130 bfd_reloc_code_real_type code
;
135 return &elf_howto_table
[(int) R_390_NONE
];
137 return &elf_howto_table
[(int) R_390_8
];
138 case BFD_RELOC_390_12
:
139 return &elf_howto_table
[(int) R_390_12
];
141 return &elf_howto_table
[(int) R_390_16
];
143 return &elf_howto_table
[(int) R_390_32
];
145 return &elf_howto_table
[(int) R_390_32
];
146 case BFD_RELOC_32_PCREL
:
147 return &elf_howto_table
[(int) R_390_PC32
];
148 case BFD_RELOC_390_GOT12
:
149 return &elf_howto_table
[(int) R_390_GOT12
];
150 case BFD_RELOC_32_GOT_PCREL
:
151 return &elf_howto_table
[(int) R_390_GOT32
];
152 case BFD_RELOC_390_PLT32
:
153 return &elf_howto_table
[(int) R_390_PLT32
];
154 case BFD_RELOC_390_COPY
:
155 return &elf_howto_table
[(int) R_390_COPY
];
156 case BFD_RELOC_390_GLOB_DAT
:
157 return &elf_howto_table
[(int) R_390_GLOB_DAT
];
158 case BFD_RELOC_390_JMP_SLOT
:
159 return &elf_howto_table
[(int) R_390_JMP_SLOT
];
160 case BFD_RELOC_390_RELATIVE
:
161 return &elf_howto_table
[(int) R_390_RELATIVE
];
162 case BFD_RELOC_32_GOTOFF
:
163 return &elf_howto_table
[(int) R_390_GOTOFF
];
164 case BFD_RELOC_390_GOTPC
:
165 return &elf_howto_table
[(int) R_390_GOTPC
];
166 case BFD_RELOC_390_GOT16
:
167 return &elf_howto_table
[(int) R_390_GOT16
];
168 case BFD_RELOC_16_PCREL
:
169 return &elf_howto_table
[(int) R_390_PC16
];
170 case BFD_RELOC_390_PC16DBL
:
171 return &elf_howto_table
[(int) R_390_PC16DBL
];
172 case BFD_RELOC_390_PLT16DBL
:
173 return &elf_howto_table
[(int) R_390_PLT16DBL
];
174 case BFD_RELOC_390_PC32DBL
:
175 return &elf_howto_table
[(int) R_390_PC32DBL
];
176 case BFD_RELOC_390_PLT32DBL
:
177 return &elf_howto_table
[(int) R_390_PLT32DBL
];
178 case BFD_RELOC_390_GOTPCDBL
:
179 return &elf_howto_table
[(int) R_390_GOTPCDBL
];
180 case BFD_RELOC_390_GOTENT
:
181 return &elf_howto_table
[(int) R_390_GOTENT
];
182 case BFD_RELOC_VTABLE_INHERIT
:
183 return &elf32_s390_vtinherit_howto
;
184 case BFD_RELOC_VTABLE_ENTRY
:
185 return &elf32_s390_vtentry_howto
;
192 /* We need to use ELF32_R_TYPE so we have our own copy of this function,
193 and elf32-s390.c has its own copy. */
196 elf_s390_info_to_howto (abfd
, cache_ptr
, dst
)
197 bfd
*abfd ATTRIBUTE_UNUSED
;
199 Elf_Internal_Rela
*dst
;
201 switch (ELF32_R_TYPE(dst
->r_info
))
203 case R_390_GNU_VTINHERIT
:
204 cache_ptr
->howto
= &elf32_s390_vtinherit_howto
;
207 case R_390_GNU_VTENTRY
:
208 cache_ptr
->howto
= &elf32_s390_vtentry_howto
;
212 BFD_ASSERT (ELF32_R_TYPE(dst
->r_info
) < (unsigned int) R_390_max
);
213 cache_ptr
->howto
= &elf_howto_table
[ELF32_R_TYPE(dst
->r_info
)];
218 elf_s390_is_local_label_name (abfd
, name
)
222 if (name
[0] == '.' && (name
[1] == 'X' || name
[1] == 'L'))
225 return _bfd_elf_is_local_label_name (abfd
, name
);
228 /* Functions for the 390 ELF linker. */
230 /* The name of the dynamic interpreter. This is put in the .interp
233 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
235 /* The size in bytes of the first entry in the procedure linkage table. */
236 #define PLT_FIRST_ENTRY_SIZE 32
237 /* The size in bytes of an entry in the procedure linkage table. */
238 #define PLT_ENTRY_SIZE 32
240 #define GOT_ENTRY_SIZE 4
242 /* The first three entries in a procedure linkage table are reserved,
243 and the initial contents are unimportant (we zero them out).
244 Subsequent entries look like this. See the SVR4 ABI 386
245 supplement to see how this works. */
247 /* For the s390, simple addr offset can only be 0 - 4096.
248 To use the full 2 GB address space, several instructions
249 are needed to load an address in a register and execute
250 a branch( or just saving the address)
252 Furthermore, only r 0 and 1 are free to use!!! */
254 /* The first 3 words in the GOT are then reserved.
255 Word 0 is the address of the dynamic table.
256 Word 1 is a pointer to a structure describing the object
257 Word 2 is used to point to the loader entry address.
259 The code for position independand PLT entries looks like this:
261 r12 holds addr of the current GOT at entry to the PLT
263 The GOT holds the address in the PLT to be executed.
264 The loader then gets:
265 24(15) = Pointer to the structure describing the object.
266 28(15) = Offset in symbol table
268 The loader must then find the module where the function is
269 and insert the address in the GOT.
271 Note: 390 can only address +- 64 K relative.
272 We check if offset > 65536, then make a relative branch -64xxx
273 back to a previous defined branch
275 PLT1: BASR 1,0 # 2 bytes
276 L 1,22(1) # 4 bytes Load offset in GOT in r 1
277 L 1,(1,12) # 4 bytes Load address from GOT in r1
278 BCR 15,1 # 2 bytes Jump to address
279 RET1: BASR 1,0 # 2 bytes Return from GOT 1st time
280 L 1,14(1) # 4 bytes Load offset in symol table in r1
281 BRC 15,-x # 4 bytes Jump to start of PLT
282 .word 0 # 2 bytes filler
283 .long ? # 4 bytes offset in GOT
284 .long ? # 4 bytes offset into symbol table
286 This was the general case. There are two additional, optimizes PLT
287 definitions. One for GOT offsets < 4096 and one for GOT offsets < 32768.
288 First the one for GOT offsets < 4096:
290 PLT1: L 1,<offset>(12) # 4 bytes Load address from GOT in R1
291 BCR 15,1 # 2 bytes Jump to address
292 .word 0,0,0 # 6 bytes filler
293 RET1: BASR 1,0 # 2 bytes Return from GOT 1st time
294 L 1,14(1) # 4 bytes Load offset in symbol table in r1
295 BRC 15,-x # 4 bytes Jump to start of PLT
296 .word 0,0,0 # 6 bytes filler
297 .long ? # 4 bytes offset into symbol table
299 Second the one for GOT offsets < 32768:
301 PLT1: LHI 1,<offset> # 4 bytes Load offset in GOT to r1
302 L 1,(1,12) # 4 bytes Load address from GOT to r1
303 BCR 15,1 # 2 bytes Jump to address
304 .word 0 # 2 bytes filler
305 RET1: BASR 1,0 # 2 bytes Return from GOT 1st time
306 L 1,14(1) # 4 bytes Load offset in symbol table in r1
307 BRC 15,-x # 4 bytes Jump to start of PLT
308 .word 0,0,0 # 6 bytes filler
309 .long ? # 4 bytes offset into symbol table
311 Total = 32 bytes per PLT entry
313 The code for static build PLT entries looks like this:
315 PLT1: BASR 1,0 # 2 bytes
316 L 1,22(1) # 4 bytes Load address of GOT entry
317 L 1,0(0,1) # 4 bytes Load address from GOT in r1
318 BCR 15,1 # 2 bytes Jump to address
319 RET1: BASR 1,0 # 2 bytes Return from GOT 1st time
320 L 1,14(1) # 4 bytes Load offset in symbol table in r1
321 BRC 15,-x # 4 bytes Jump to start of PLT
322 .word 0 # 2 bytes filler
323 .long ? # 4 bytes address of GOT entry
324 .long ? # 4 bytes offset into symbol table */
326 #define PLT_PIC_ENTRY_WORD0 0x0d105810
327 #define PLT_PIC_ENTRY_WORD1 0x10165811
328 #define PLT_PIC_ENTRY_WORD2 0xc00007f1
329 #define PLT_PIC_ENTRY_WORD3 0x0d105810
330 #define PLT_PIC_ENTRY_WORD4 0x100ea7f4
332 #define PLT_PIC12_ENTRY_WORD0 0x5810c000
333 #define PLT_PIC12_ENTRY_WORD1 0x07f10000
334 #define PLT_PIC12_ENTRY_WORD2 0x00000000
335 #define PLT_PIC12_ENTRY_WORD3 0x0d105810
336 #define PLT_PIC12_ENTRY_WORD4 0x100ea7f4
338 #define PLT_PIC16_ENTRY_WORD0 0xa7180000
339 #define PLT_PIC16_ENTRY_WORD1 0x5811c000
340 #define PLT_PIC16_ENTRY_WORD2 0x07f10000
341 #define PLT_PIC16_ENTRY_WORD3 0x0d105810
342 #define PLT_PIC16_ENTRY_WORD4 0x100ea7f4
344 #define PLT_ENTRY_WORD0 0x0d105810
345 #define PLT_ENTRY_WORD1 0x10165810
346 #define PLT_ENTRY_WORD2 0x100007f1
347 #define PLT_ENTRY_WORD3 0x0d105810
348 #define PLT_ENTRY_WORD4 0x100ea7f4
350 /* The first PLT entry pushes the offset into the symbol table
351 from R1 onto the stack at 8(15) and the loader object info
352 at 12(15), loads the loader address in R1 and jumps to it. */
354 /* The first entry in the PLT for PIC code:
357 ST 1,28(15) # R1 has offset into symbol table
358 L 1,4(12) # Get loader ino(object struct address)
359 ST 1,24(15) # Store address
360 L 1,8(12) # Entry address of loader in R1
361 BR 1 # Jump to loader
363 The first entry in the PLT for static code:
366 ST 1,28(15) # R1 has offset into symbol table
368 L 1,18(0,1) # Get address of GOT
369 MVC 24(4,15),4(1) # Move loader ino to stack
370 L 1,8(1) # Get address of loader
371 BR 1 # Jump to loader
373 .long got # address of GOT */
375 #define PLT_PIC_FIRST_ENTRY_WORD0 0x5010f01c
376 #define PLT_PIC_FIRST_ENTRY_WORD1 0x5810c004
377 #define PLT_PIC_FIRST_ENTRY_WORD2 0x5010f018
378 #define PLT_PIC_FIRST_ENTRY_WORD3 0x5810c008
379 #define PLT_PIC_FIRST_ENTRY_WORD4 0x07f10000
381 #define PLT_FIRST_ENTRY_WORD0 0x5010f01c
382 #define PLT_FIRST_ENTRY_WORD1 0x0d105810
383 #define PLT_FIRST_ENTRY_WORD2 0x1012D203
384 #define PLT_FIRST_ENTRY_WORD3 0xf0181004
385 #define PLT_FIRST_ENTRY_WORD4 0x58101008
386 #define PLT_FIRST_ENTRY_WORD5 0x07f10000
388 /* The s390 linker needs to keep track of the number of relocs that it
389 decides to copy as dynamic relocs in check_relocs for each symbol.
390 This is so that it can later discard them if they are found to be
391 unnecessary. We store the information in a field extending the
392 regular ELF linker hash table. */
394 struct elf_s390_dyn_relocs
396 struct elf_s390_dyn_relocs
*next
;
398 /* The input section of the reloc. */
401 /* Total number of relocs copied for the input section. */
404 /* Number of pc-relative relocs copied for the input section. */
405 bfd_size_type pc_count
;
408 /* s390 ELF linker hash entry. */
410 struct elf_s390_link_hash_entry
412 struct elf_link_hash_entry elf
;
414 /* Track dynamic relocs copied for this symbol. */
415 struct elf_s390_dyn_relocs
*dyn_relocs
;
418 /* s390 ELF linker hash table. */
420 struct elf_s390_link_hash_table
422 struct elf_link_hash_table elf
;
424 /* Short-cuts to get to dynamic linker sections. */
433 /* Small local sym to section mapping cache. */
434 struct sym_sec_cache sym_sec
;
437 /* Get the s390 ELF linker hash table from a link_info structure. */
439 #define elf_s390_hash_table(p) \
440 ((struct elf_s390_link_hash_table *) ((p)->hash))
442 /* Create an entry in an s390 ELF linker hash table. */
444 static struct bfd_hash_entry
*
445 link_hash_newfunc (entry
, table
, string
)
446 struct bfd_hash_entry
*entry
;
447 struct bfd_hash_table
*table
;
450 /* Allocate the structure if it has not already been allocated by a
454 entry
= bfd_hash_allocate (table
,
455 sizeof (struct elf_s390_link_hash_entry
));
460 /* Call the allocation method of the superclass. */
461 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
464 struct elf_s390_link_hash_entry
*eh
;
466 eh
= (struct elf_s390_link_hash_entry
*) entry
;
467 eh
->dyn_relocs
= NULL
;
473 /* Create an s390 ELF linker hash table. */
475 static struct bfd_link_hash_table
*
476 elf_s390_link_hash_table_create (abfd
)
479 struct elf_s390_link_hash_table
*ret
;
480 bfd_size_type amt
= sizeof (struct elf_s390_link_hash_table
);
482 ret
= (struct elf_s390_link_hash_table
*) bfd_malloc (amt
);
486 if (! _bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
))
499 ret
->sym_sec
.abfd
= NULL
;
501 return &ret
->elf
.root
;
504 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
505 shortcuts to them in our hash table. */
508 create_got_section (dynobj
, info
)
510 struct bfd_link_info
*info
;
512 struct elf_s390_link_hash_table
*htab
;
514 if (! _bfd_elf_create_got_section (dynobj
, info
))
517 htab
= elf_s390_hash_table (info
);
518 htab
->sgot
= bfd_get_section_by_name (dynobj
, ".got");
519 htab
->sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
520 if (!htab
->sgot
|| !htab
->sgotplt
)
523 htab
->srelgot
= bfd_make_section (dynobj
, ".rela.got");
524 if (htab
->srelgot
== NULL
525 || ! bfd_set_section_flags (dynobj
, htab
->srelgot
,
526 (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
527 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
529 || ! bfd_set_section_alignment (dynobj
, htab
->srelgot
, 2))
534 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
535 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
539 elf_s390_create_dynamic_sections (dynobj
, info
)
541 struct bfd_link_info
*info
;
543 struct elf_s390_link_hash_table
*htab
;
545 htab
= elf_s390_hash_table (info
);
546 if (!htab
->sgot
&& !create_got_section (dynobj
, info
))
549 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
552 htab
->splt
= bfd_get_section_by_name (dynobj
, ".plt");
553 htab
->srelplt
= bfd_get_section_by_name (dynobj
, ".rela.plt");
554 htab
->sdynbss
= bfd_get_section_by_name (dynobj
, ".dynbss");
556 htab
->srelbss
= bfd_get_section_by_name (dynobj
, ".rela.bss");
558 if (!htab
->splt
|| !htab
->srelplt
|| !htab
->sdynbss
559 || (!info
->shared
&& !htab
->srelbss
))
565 /* Copy the extra info we tack onto an elf_link_hash_entry. */
568 elf_s390_copy_indirect_symbol (bed
, dir
, ind
)
569 struct elf_backend_data
*bed
;
570 struct elf_link_hash_entry
*dir
, *ind
;
572 struct elf_s390_link_hash_entry
*edir
, *eind
;
574 edir
= (struct elf_s390_link_hash_entry
*) dir
;
575 eind
= (struct elf_s390_link_hash_entry
*) ind
;
577 if (eind
->dyn_relocs
!= NULL
)
579 if (edir
->dyn_relocs
!= NULL
)
581 struct elf_s390_dyn_relocs
**pp
;
582 struct elf_s390_dyn_relocs
*p
;
584 if (ind
->root
.type
== bfd_link_hash_indirect
)
587 /* Add reloc counts against the weak sym to the strong sym
588 list. Merge any entries against the same section. */
589 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
591 struct elf_s390_dyn_relocs
*q
;
593 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
594 if (q
->sec
== p
->sec
)
596 q
->pc_count
+= p
->pc_count
;
597 q
->count
+= p
->count
;
604 *pp
= edir
->dyn_relocs
;
607 edir
->dyn_relocs
= eind
->dyn_relocs
;
608 eind
->dyn_relocs
= NULL
;
611 _bfd_elf_link_hash_copy_indirect (bed
, dir
, ind
);
614 /* Look through the relocs for a section during the first phase, and
615 allocate space in the global offset table or procedure linkage
619 elf_s390_check_relocs (abfd
, info
, sec
, relocs
)
621 struct bfd_link_info
*info
;
623 const Elf_Internal_Rela
*relocs
;
625 struct elf_s390_link_hash_table
*htab
;
626 Elf_Internal_Shdr
*symtab_hdr
;
627 struct elf_link_hash_entry
**sym_hashes
;
628 const Elf_Internal_Rela
*rel
;
629 const Elf_Internal_Rela
*rel_end
;
632 if (info
->relocateable
)
635 htab
= elf_s390_hash_table (info
);
636 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
637 sym_hashes
= elf_sym_hashes (abfd
);
641 rel_end
= relocs
+ sec
->reloc_count
;
642 for (rel
= relocs
; rel
< rel_end
; rel
++)
644 unsigned long r_symndx
;
645 struct elf_link_hash_entry
*h
;
647 r_symndx
= ELF32_R_SYM (rel
->r_info
);
649 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
651 (*_bfd_error_handler
) (_("%s: bad symbol index: %d"),
652 bfd_archive_filename (abfd
),
657 if (r_symndx
< symtab_hdr
->sh_info
)
660 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
662 switch (ELF32_R_TYPE (rel
->r_info
))
668 /* This symbol requires a global offset table entry. */
671 h
->got
.refcount
+= 1;
675 bfd_signed_vma
*local_got_refcounts
;
677 /* This is a global offset table entry for a local symbol. */
678 local_got_refcounts
= elf_local_got_refcounts (abfd
);
679 if (local_got_refcounts
== NULL
)
683 size
= symtab_hdr
->sh_info
;
684 size
*= sizeof (bfd_signed_vma
);
685 local_got_refcounts
= ((bfd_signed_vma
*)
686 bfd_zalloc (abfd
, size
));
687 if (local_got_refcounts
== NULL
)
689 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
691 local_got_refcounts
[r_symndx
] += 1;
698 if (htab
->sgot
== NULL
)
700 if (htab
->elf
.dynobj
== NULL
)
701 htab
->elf
.dynobj
= abfd
;
702 if (!create_got_section (htab
->elf
.dynobj
, info
))
710 /* This symbol requires a procedure linkage table entry. We
711 actually build the entry in adjust_dynamic_symbol,
712 because this might be a case of linking PIC code which is
713 never referenced by a dynamic object, in which case we
714 don't need to generate a procedure linkage table entry
717 /* If this is a local symbol, we resolve it directly without
718 creating a procedure linkage table entry. */
722 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
723 h
->plt
.refcount
+= 1;
733 if (h
!= NULL
&& !info
->shared
)
735 /* If this reloc is in a read-only section, we might
736 need a copy reloc. We can't check reliably at this
737 stage whether the section is read-only, as input
738 sections have not yet been mapped to output sections.
739 Tentatively set the flag for now, and correct in
740 adjust_dynamic_symbol. */
741 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
743 /* We may need a .plt entry if the function this reloc
744 refers to is in a shared lib. */
745 h
->plt
.refcount
+= 1;
748 /* If we are creating a shared library, and this is a reloc
749 against a global symbol, or a non PC relative reloc
750 against a local symbol, then we need to copy the reloc
751 into the shared library. However, if we are linking with
752 -Bsymbolic, we do not need to copy a reloc against a
753 global symbol which is defined in an object we are
754 including in the link (i.e., DEF_REGULAR is set). At
755 this point we have not seen all the input files, so it is
756 possible that DEF_REGULAR is not set now but will be set
757 later (it is never cleared). In case of a weak definition,
758 DEF_REGULAR may be cleared later by a strong definition in
759 a shared library. We account for that possibility below by
760 storing information in the relocs_copied field of the hash
761 table entry. A similar situation occurs when creating
762 shared libraries and symbol visibility changes render the
765 If on the other hand, we are creating an executable, we
766 may need to keep relocations for symbols satisfied by a
767 dynamic library if we manage to avoid copy relocs for the
770 && (sec
->flags
& SEC_ALLOC
) != 0
771 && ((ELF32_R_TYPE (rel
->r_info
) != R_390_PC16
772 && ELF32_R_TYPE (rel
->r_info
) != R_390_PC16DBL
773 && ELF32_R_TYPE (rel
->r_info
) != R_390_PC32DBL
774 && ELF32_R_TYPE (rel
->r_info
) != R_390_PC32
)
777 || h
->root
.type
== bfd_link_hash_defweak
778 || (h
->elf_link_hash_flags
779 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
781 && (sec
->flags
& SEC_ALLOC
) != 0
783 && (h
->root
.type
== bfd_link_hash_defweak
784 || (h
->elf_link_hash_flags
785 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
787 struct elf_s390_dyn_relocs
*p
;
788 struct elf_s390_dyn_relocs
**head
;
790 /* We must copy these reloc types into the output file.
791 Create a reloc section in dynobj and make room for
798 name
= (bfd_elf_string_from_elf_section
800 elf_elfheader (abfd
)->e_shstrndx
,
801 elf_section_data (sec
)->rel_hdr
.sh_name
));
805 if (strncmp (name
, ".rela", 5) != 0
806 || strcmp (bfd_get_section_name (abfd
, sec
),
809 (*_bfd_error_handler
)
810 (_("%s: bad relocation section name `%s\'"),
811 bfd_archive_filename (abfd
), name
);
814 if (htab
->elf
.dynobj
== NULL
)
815 htab
->elf
.dynobj
= abfd
;
817 dynobj
= htab
->elf
.dynobj
;
818 sreloc
= bfd_get_section_by_name (dynobj
, name
);
823 sreloc
= bfd_make_section (dynobj
, name
);
824 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
825 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
826 if ((sec
->flags
& SEC_ALLOC
) != 0)
827 flags
|= SEC_ALLOC
| SEC_LOAD
;
829 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
830 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
833 elf_section_data (sec
)->sreloc
= sreloc
;
836 /* If this is a global symbol, we count the number of
837 relocations we need for this symbol. */
840 head
= &((struct elf_s390_link_hash_entry
*) h
)->dyn_relocs
;
844 /* Track dynamic relocs needed for local syms too.
845 We really need local syms available to do this
849 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
854 head
= ((struct elf_s390_dyn_relocs
**)
855 &elf_section_data (s
)->local_dynrel
);
859 if (p
== NULL
|| p
->sec
!= sec
)
861 bfd_size_type amt
= sizeof *p
;
862 p
= ((struct elf_s390_dyn_relocs
*)
863 bfd_alloc (htab
->elf
.dynobj
, amt
));
874 if (ELF32_R_TYPE (rel
->r_info
) == R_390_PC16
875 || ELF32_R_TYPE (rel
->r_info
) == R_390_PC16DBL
876 || ELF32_R_TYPE (rel
->r_info
) == R_390_PC32DBL
877 || ELF32_R_TYPE (rel
->r_info
) == R_390_PC32
)
882 /* This relocation describes the C++ object vtable hierarchy.
883 Reconstruct it for later use during GC. */
884 case R_390_GNU_VTINHERIT
:
885 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
889 /* This relocation describes which C++ vtable entries are actually
890 used. Record for later use during GC. */
891 case R_390_GNU_VTENTRY
:
892 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
904 /* Return the section that should be marked against GC for a given
908 elf_s390_gc_mark_hook (sec
, info
, rel
, h
, sym
)
910 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
911 Elf_Internal_Rela
*rel
;
912 struct elf_link_hash_entry
*h
;
913 Elf_Internal_Sym
*sym
;
917 switch (ELF32_R_TYPE (rel
->r_info
))
919 case R_390_GNU_VTINHERIT
:
920 case R_390_GNU_VTENTRY
:
924 switch (h
->root
.type
)
926 case bfd_link_hash_defined
:
927 case bfd_link_hash_defweak
:
928 return h
->root
.u
.def
.section
;
930 case bfd_link_hash_common
:
931 return h
->root
.u
.c
.p
->section
;
939 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
944 /* Update the got entry reference counts for the section being removed. */
947 elf_s390_gc_sweep_hook (abfd
, info
, sec
, relocs
)
949 struct bfd_link_info
*info
;
951 const Elf_Internal_Rela
*relocs
;
953 Elf_Internal_Shdr
*symtab_hdr
;
954 struct elf_link_hash_entry
**sym_hashes
;
955 bfd_signed_vma
*local_got_refcounts
;
956 const Elf_Internal_Rela
*rel
, *relend
;
957 unsigned long r_symndx
;
958 struct elf_link_hash_entry
*h
;
960 elf_section_data (sec
)->local_dynrel
= NULL
;
962 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
963 sym_hashes
= elf_sym_hashes (abfd
);
964 local_got_refcounts
= elf_local_got_refcounts (abfd
);
966 relend
= relocs
+ sec
->reloc_count
;
967 for (rel
= relocs
; rel
< relend
; rel
++)
968 switch (ELF32_R_TYPE (rel
->r_info
))
977 r_symndx
= ELF32_R_SYM (rel
->r_info
);
978 if (r_symndx
>= symtab_hdr
->sh_info
)
980 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
981 if (h
->got
.refcount
> 0)
982 h
->got
.refcount
-= 1;
984 else if (local_got_refcounts
!= NULL
)
986 if (local_got_refcounts
[r_symndx
] > 0)
987 local_got_refcounts
[r_symndx
] -= 1;
999 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1000 if (r_symndx
>= symtab_hdr
->sh_info
)
1002 struct elf_s390_link_hash_entry
*eh
;
1003 struct elf_s390_dyn_relocs
**pp
;
1004 struct elf_s390_dyn_relocs
*p
;
1006 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1008 if (!info
->shared
&& h
->plt
.refcount
> 0)
1009 h
->plt
.refcount
-= 1;
1011 eh
= (struct elf_s390_link_hash_entry
*) h
;
1013 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1016 if (ELF32_R_TYPE (rel
->r_info
) == R_390_PC16
1017 || ELF32_R_TYPE (rel
->r_info
) == R_390_PC16DBL
1018 || ELF32_R_TYPE (rel
->r_info
) == R_390_PC32DBL
1019 || ELF32_R_TYPE (rel
->r_info
) == R_390_PC32
)
1029 case R_390_PLT16DBL
:
1030 case R_390_PLT32DBL
:
1032 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1033 if (r_symndx
>= symtab_hdr
->sh_info
)
1035 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1036 if (h
->plt
.refcount
> 0)
1037 h
->plt
.refcount
-= 1;
1048 /* Adjust a symbol defined by a dynamic object and referenced by a
1049 regular object. The current definition is in some section of the
1050 dynamic object, but we're not including those sections. We have to
1051 change the definition to something the rest of the link can
1055 elf_s390_adjust_dynamic_symbol (info
, h
)
1056 struct bfd_link_info
*info
;
1057 struct elf_link_hash_entry
*h
;
1059 struct elf_s390_link_hash_table
*htab
;
1060 struct elf_s390_link_hash_entry
* eh
;
1061 struct elf_s390_dyn_relocs
*p
;
1063 unsigned int power_of_two
;
1065 /* If this is a function, put it in the procedure linkage table. We
1066 will fill in the contents of the procedure linkage table later
1067 (although we could actually do it here). */
1068 if (h
->type
== STT_FUNC
1069 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
1071 if (h
->plt
.refcount
<= 0
1073 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
1074 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0
1075 && h
->root
.type
!= bfd_link_hash_undefweak
1076 && h
->root
.type
!= bfd_link_hash_undefined
))
1078 /* This case can occur if we saw a PLT32 reloc in an input
1079 file, but the symbol was never referred to by a dynamic
1080 object, or if all references were garbage collected. In
1081 such a case, we don't actually need to build a procedure
1082 linkage table, and we can just do a PC32 reloc instead. */
1083 h
->plt
.offset
= (bfd_vma
) -1;
1084 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1090 /* It's possible that we incorrectly decided a .plt reloc was
1091 needed for an R_390_PC32 reloc to a non-function sym in
1092 check_relocs. We can't decide accurately between function and
1093 non-function syms in check-relocs; Objects loaded later in
1094 the link may change h->type. So fix it now. */
1095 h
->plt
.offset
= (bfd_vma
) -1;
1097 /* If this is a weak symbol, and there is a real definition, the
1098 processor independent code will have arranged for us to see the
1099 real definition first, and we can just use the same value. */
1100 if (h
->weakdef
!= NULL
)
1102 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
1103 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
1104 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
1105 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
1109 /* This is a reference to a symbol defined by a dynamic object which
1110 is not a function. */
1112 /* If we are creating a shared library, we must presume that the
1113 only references to the symbol are via the global offset table.
1114 For such cases we need not do anything here; the relocations will
1115 be handled correctly by relocate_section. */
1119 /* If there are no references to this symbol that do not use the
1120 GOT, we don't need to generate a copy reloc. */
1121 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
1124 /* If -z nocopyreloc was given, we won't generate them either. */
1125 if (info
->nocopyreloc
)
1127 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_GOT_REF
;
1131 eh
= (struct elf_s390_link_hash_entry
*) h
;
1132 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1134 s
= p
->sec
->output_section
;
1135 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1139 /* If we didn't find any dynamic relocs in read-only sections, then
1140 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1143 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_GOT_REF
;
1147 /* We must allocate the symbol in our .dynbss section, which will
1148 become part of the .bss section of the executable. There will be
1149 an entry for this symbol in the .dynsym section. The dynamic
1150 object will contain position independent code, so all references
1151 from the dynamic object to this symbol will go through the global
1152 offset table. The dynamic linker will use the .dynsym entry to
1153 determine the address it must put in the global offset table, so
1154 both the dynamic object and the regular object will refer to the
1155 same memory location for the variable. */
1157 htab
= elf_s390_hash_table (info
);
1159 /* We must generate a R_390_COPY reloc to tell the dynamic linker to
1160 copy the initial value out of the dynamic object and into the
1161 runtime process image. */
1162 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1164 htab
->srelbss
->_raw_size
+= sizeof (Elf32_External_Rela
);
1165 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
1168 /* We need to figure out the alignment required for this symbol. I
1169 have no idea how ELF linkers handle this. */
1170 power_of_two
= bfd_log2 (h
->size
);
1171 if (power_of_two
> 3)
1174 /* Apply the required alignment. */
1176 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
, (bfd_size_type
) (1 << power_of_two
));
1177 if (power_of_two
> bfd_get_section_alignment (htab
->elf
.dynobj
, s
))
1179 if (! bfd_set_section_alignment (htab
->elf
.dynobj
, s
, power_of_two
))
1183 /* Define the symbol as being at this point in the section. */
1184 h
->root
.u
.def
.section
= s
;
1185 h
->root
.u
.def
.value
= s
->_raw_size
;
1187 /* Increment the section size to make room for the symbol. */
1188 s
->_raw_size
+= h
->size
;
1193 /* This is the condition under which elf_s390_finish_dynamic_symbol
1194 will be called from elflink.h. If elflink.h doesn't call our
1195 finish_dynamic_symbol routine, we'll need to do something about
1196 initializing any .plt and .got entries in elf_s390_relocate_section. */
1197 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1199 && ((INFO)->shared \
1200 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1201 && ((H)->dynindx != -1 \
1202 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1204 /* Allocate space in .plt, .got and associated reloc sections for
1208 allocate_dynrelocs (h
, inf
)
1209 struct elf_link_hash_entry
*h
;
1212 struct bfd_link_info
*info
;
1213 struct elf_s390_link_hash_table
*htab
;
1214 struct elf_s390_link_hash_entry
*eh
;
1215 struct elf_s390_dyn_relocs
*p
;
1217 if (h
->root
.type
== bfd_link_hash_indirect
)
1220 if (h
->root
.type
== bfd_link_hash_warning
)
1221 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1223 info
= (struct bfd_link_info
*) inf
;
1224 htab
= elf_s390_hash_table (info
);
1226 if (htab
->elf
.dynamic_sections_created
1227 && h
->plt
.refcount
> 0)
1229 /* Make sure this symbol is output as a dynamic symbol.
1230 Undefined weak syms won't yet be marked as dynamic. */
1231 if (h
->dynindx
== -1
1232 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1234 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1238 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
, h
))
1240 asection
*s
= htab
->splt
;
1242 /* If this is the first .plt entry, make room for the special
1244 if (s
->_raw_size
== 0)
1245 s
->_raw_size
+= PLT_FIRST_ENTRY_SIZE
;
1247 h
->plt
.offset
= s
->_raw_size
;
1249 /* If this symbol is not defined in a regular file, and we are
1250 not generating a shared library, then set the symbol to this
1251 location in the .plt. This is required to make function
1252 pointers compare as equal between the normal executable and
1253 the shared library. */
1255 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1257 h
->root
.u
.def
.section
= s
;
1258 h
->root
.u
.def
.value
= h
->plt
.offset
;
1261 /* Make room for this entry. */
1262 s
->_raw_size
+= PLT_ENTRY_SIZE
;
1264 /* We also need to make an entry in the .got.plt section, which
1265 will be placed in the .got section by the linker script. */
1266 htab
->sgotplt
->_raw_size
+= GOT_ENTRY_SIZE
;
1268 /* We also need to make an entry in the .rela.plt section. */
1269 htab
->srelplt
->_raw_size
+= sizeof (Elf32_External_Rela
);
1273 h
->plt
.offset
= (bfd_vma
) -1;
1274 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1279 h
->plt
.offset
= (bfd_vma
) -1;
1280 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1283 if (h
->got
.refcount
> 0)
1288 /* Make sure this symbol is output as a dynamic symbol.
1289 Undefined weak syms won't yet be marked as dynamic. */
1290 if (h
->dynindx
== -1
1291 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1293 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1298 h
->got
.offset
= s
->_raw_size
;
1299 s
->_raw_size
+= GOT_ENTRY_SIZE
;
1300 dyn
= htab
->elf
.dynamic_sections_created
;
1301 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
))
1302 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rela
);
1305 h
->got
.offset
= (bfd_vma
) -1;
1307 eh
= (struct elf_s390_link_hash_entry
*) h
;
1308 if (eh
->dyn_relocs
== NULL
)
1311 /* In the shared -Bsymbolic case, discard space allocated for
1312 dynamic pc-relative relocs against symbols which turn out to be
1313 defined in regular objects. For the normal shared case, discard
1314 space for pc-relative relocs that have become local due to symbol
1315 visibility changes. */
1319 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1320 && ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0
1323 struct elf_s390_dyn_relocs
**pp
;
1325 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1327 p
->count
-= p
->pc_count
;
1338 /* For the non-shared case, discard space for relocs against
1339 symbols which turn out to need copy relocs or are not
1342 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1343 && (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1344 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1345 || (htab
->elf
.dynamic_sections_created
1346 && (h
->root
.type
== bfd_link_hash_undefweak
1347 || h
->root
.type
== bfd_link_hash_undefined
))))
1349 /* Make sure this symbol is output as a dynamic symbol.
1350 Undefined weak syms won't yet be marked as dynamic. */
1351 if (h
->dynindx
== -1
1352 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0)
1354 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
1358 /* If that succeeded, we know we'll be keeping all the
1360 if (h
->dynindx
!= -1)
1364 eh
->dyn_relocs
= NULL
;
1369 /* Finally, allocate space. */
1370 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1372 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1373 sreloc
->_raw_size
+= p
->count
* sizeof (Elf32_External_Rela
);
1379 /* Find any dynamic relocs that apply to read-only sections. */
1382 readonly_dynrelocs (h
, inf
)
1383 struct elf_link_hash_entry
*h
;
1386 struct elf_s390_link_hash_entry
*eh
;
1387 struct elf_s390_dyn_relocs
*p
;
1389 if (h
->root
.type
== bfd_link_hash_warning
)
1390 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1392 eh
= (struct elf_s390_link_hash_entry
*) h
;
1393 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1395 asection
*s
= p
->sec
->output_section
;
1397 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1399 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
1401 info
->flags
|= DF_TEXTREL
;
1403 /* Not an error, just cut short the traversal. */
1410 /* Set the sizes of the dynamic sections. */
1413 elf_s390_size_dynamic_sections (output_bfd
, info
)
1414 bfd
*output_bfd ATTRIBUTE_UNUSED
;
1415 struct bfd_link_info
*info
;
1417 struct elf_s390_link_hash_table
*htab
;
1423 htab
= elf_s390_hash_table (info
);
1424 dynobj
= htab
->elf
.dynobj
;
1428 if (htab
->elf
.dynamic_sections_created
)
1430 /* Set the contents of the .interp section to the interpreter. */
1433 s
= bfd_get_section_by_name (dynobj
, ".interp");
1436 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1437 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1441 /* Set up .got offsets for local syms, and space for local dynamic
1443 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
1445 bfd_signed_vma
*local_got
;
1446 bfd_signed_vma
*end_local_got
;
1447 bfd_size_type locsymcount
;
1448 Elf_Internal_Shdr
*symtab_hdr
;
1451 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
1454 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1456 struct elf_s390_dyn_relocs
*p
;
1458 for (p
= *((struct elf_s390_dyn_relocs
**)
1459 &elf_section_data (s
)->local_dynrel
);
1463 if (!bfd_is_abs_section (p
->sec
)
1464 && bfd_is_abs_section (p
->sec
->output_section
))
1466 /* Input section has been discarded, either because
1467 it is a copy of a linkonce section or due to
1468 linker script /DISCARD/, so we'll be discarding
1471 else if (p
->count
!= 0)
1473 srela
= elf_section_data (p
->sec
)->sreloc
;
1474 srela
->_raw_size
+= p
->count
* sizeof (Elf32_External_Rela
);
1475 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1476 info
->flags
|= DF_TEXTREL
;
1481 local_got
= elf_local_got_refcounts (ibfd
);
1485 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1486 locsymcount
= symtab_hdr
->sh_info
;
1487 end_local_got
= local_got
+ locsymcount
;
1489 srela
= htab
->srelgot
;
1490 for (; local_got
< end_local_got
; ++local_got
)
1494 *local_got
= s
->_raw_size
;
1495 s
->_raw_size
+= GOT_ENTRY_SIZE
;
1497 srela
->_raw_size
+= sizeof (Elf32_External_Rela
);
1500 *local_got
= (bfd_vma
) -1;
1504 /* Allocate global sym .plt and .got entries, and space for global
1505 sym dynamic relocs. */
1506 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, (PTR
) info
);
1508 /* We now have determined the sizes of the various dynamic sections.
1509 Allocate memory for them. */
1511 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1513 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1518 || s
== htab
->sgotplt
)
1520 /* Strip this section if we don't need it; see the
1523 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rela", 5) == 0)
1525 if (s
->_raw_size
!= 0 && s
!= htab
->srelplt
)
1528 /* We use the reloc_count field as a counter if we need
1529 to copy relocs into the output file. */
1534 /* It's not one of our sections, so don't allocate space. */
1538 if (s
->_raw_size
== 0)
1540 /* If we don't need this section, strip it from the
1541 output file. This is to handle .rela.bss and
1542 .rela.plt. We must create it in
1543 create_dynamic_sections, because it must be created
1544 before the linker maps input sections to output
1545 sections. The linker does that before
1546 adjust_dynamic_symbol is called, and it is that
1547 function which decides whether anything needs to go
1548 into these sections. */
1550 _bfd_strip_section_from_output (info
, s
);
1554 /* Allocate memory for the section contents. We use bfd_zalloc
1555 here in case unused entries are not reclaimed before the
1556 section's contents are written out. This should not happen,
1557 but this way if it does, we get a R_390_NONE reloc instead
1559 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1560 if (s
->contents
== NULL
)
1564 if (htab
->elf
.dynamic_sections_created
)
1566 /* Add some entries to the .dynamic section. We fill in the
1567 values later, in elf_s390_finish_dynamic_sections, but we
1568 must add the entries now so that we get the correct size for
1569 the .dynamic section. The DT_DEBUG entry is filled in by the
1570 dynamic linker and used by the debugger. */
1571 #define add_dynamic_entry(TAG, VAL) \
1572 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1576 if (!add_dynamic_entry (DT_DEBUG
, 0))
1580 if (htab
->splt
->_raw_size
!= 0)
1582 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1583 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1584 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1585 || !add_dynamic_entry (DT_JMPREL
, 0))
1591 if (!add_dynamic_entry (DT_RELA
, 0)
1592 || !add_dynamic_entry (DT_RELASZ
, 0)
1593 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
1596 /* If any dynamic relocs apply to a read-only section,
1597 then we need a DT_TEXTREL entry. */
1598 if ((info
->flags
& DF_TEXTREL
) == 0)
1599 elf_link_hash_traverse (&htab
->elf
, readonly_dynrelocs
,
1602 if ((info
->flags
& DF_TEXTREL
) != 0)
1604 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1609 #undef add_dynamic_entry
1614 /* Relocate a 390 ELF section. */
1617 elf_s390_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1618 contents
, relocs
, local_syms
, local_sections
)
1620 struct bfd_link_info
*info
;
1622 asection
*input_section
;
1624 Elf_Internal_Rela
*relocs
;
1625 Elf_Internal_Sym
*local_syms
;
1626 asection
**local_sections
;
1628 struct elf_s390_link_hash_table
*htab
;
1629 Elf_Internal_Shdr
*symtab_hdr
;
1630 struct elf_link_hash_entry
**sym_hashes
;
1631 bfd_vma
*local_got_offsets
;
1632 Elf_Internal_Rela
*rel
;
1633 Elf_Internal_Rela
*relend
;
1635 if (info
->relocateable
)
1638 htab
= elf_s390_hash_table (info
);
1639 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1640 sym_hashes
= elf_sym_hashes (input_bfd
);
1641 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1644 relend
= relocs
+ input_section
->reloc_count
;
1645 for (; rel
< relend
; rel
++)
1648 reloc_howto_type
*howto
;
1649 unsigned long r_symndx
;
1650 struct elf_link_hash_entry
*h
;
1651 Elf_Internal_Sym
*sym
;
1655 bfd_boolean unresolved_reloc
;
1656 bfd_reloc_status_type r
;
1658 r_type
= ELF32_R_TYPE (rel
->r_info
);
1659 if (r_type
== (int) R_390_GNU_VTINHERIT
1660 || r_type
== (int) R_390_GNU_VTENTRY
)
1662 if (r_type
< 0 || r_type
>= (int) R_390_max
)
1664 bfd_set_error (bfd_error_bad_value
);
1668 howto
= elf_howto_table
+ r_type
;
1669 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1673 unresolved_reloc
= FALSE
;
1674 if (r_symndx
< symtab_hdr
->sh_info
)
1676 sym
= local_syms
+ r_symndx
;
1677 sec
= local_sections
[r_symndx
];
1678 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, sec
, rel
);
1682 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1683 while (h
->root
.type
== bfd_link_hash_indirect
1684 || h
->root
.type
== bfd_link_hash_warning
)
1685 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1687 if (h
->root
.type
== bfd_link_hash_defined
1688 || h
->root
.type
== bfd_link_hash_defweak
)
1690 sec
= h
->root
.u
.def
.section
;
1691 if (sec
->output_section
== NULL
)
1693 /* Set a flag that will be cleared later if we find a
1694 relocation value for this symbol. output_section
1695 is typically NULL for symbols satisfied by a shared
1697 unresolved_reloc
= TRUE
;
1701 relocation
= (h
->root
.u
.def
.value
1702 + sec
->output_section
->vma
1703 + sec
->output_offset
);
1705 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1707 else if (info
->shared
1708 && (!info
->symbolic
|| info
->allow_shlib_undefined
)
1709 && !info
->no_undefined
1710 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1714 if (! ((*info
->callbacks
->undefined_symbol
)
1715 (info
, h
->root
.root
.string
, input_bfd
,
1716 input_section
, rel
->r_offset
,
1717 (!info
->shared
|| info
->no_undefined
1718 || ELF_ST_VISIBILITY (h
->other
)))))
1730 /* Relocation is to the entry for this symbol in the global
1732 if (htab
->sgot
== NULL
)
1739 off
= h
->got
.offset
;
1740 dyn
= htab
->elf
.dynamic_sections_created
;
1741 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, h
)
1745 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
1746 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1748 /* This is actually a static link, or it is a
1749 -Bsymbolic link and the symbol is defined
1750 locally, or the symbol was forced to be local
1751 because of a version file. We must initialize
1752 this entry in the global offset table. Since the
1753 offset must always be a multiple of 2, we use the
1754 least significant bit to record whether we have
1755 initialized it already.
1757 When doing a dynamic link, we create a .rel.got
1758 relocation entry to initialize the value. This
1759 is done in the finish_dynamic_symbol routine. */
1764 bfd_put_32 (output_bfd
, relocation
,
1765 htab
->sgot
->contents
+ off
);
1770 unresolved_reloc
= FALSE
;
1774 if (local_got_offsets
== NULL
)
1777 off
= local_got_offsets
[r_symndx
];
1779 /* The offset must always be a multiple of 4. We use
1780 the least significant bit to record whether we have
1781 already generated the necessary reloc. */
1786 bfd_put_32 (output_bfd
, relocation
,
1787 htab
->sgot
->contents
+ off
);
1792 Elf_Internal_Rela outrel
;
1795 srelgot
= htab
->srelgot
;
1796 if (srelgot
== NULL
)
1799 outrel
.r_offset
= (htab
->sgot
->output_section
->vma
1800 + htab
->sgot
->output_offset
1802 outrel
.r_info
= ELF32_R_INFO (0, R_390_RELATIVE
);
1803 outrel
.r_addend
= relocation
;
1804 loc
= srelgot
->contents
;
1805 loc
+= srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
1806 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1809 local_got_offsets
[r_symndx
] |= 1;
1813 if (off
>= (bfd_vma
) -2)
1816 relocation
= htab
->sgot
->output_offset
+ off
;
1819 * For @GOTENT the relocation is against the offset between
1820 * the instruction and the symbols entry in the GOT and not
1821 * between the start of the GOT and the symbols entry. We
1822 * add the vma of the GOT to get the correct value.
1824 if (r_type
== R_390_GOTENT
)
1825 relocation
+= htab
->sgot
->output_section
->vma
;
1830 /* Relocation is relative to the start of the global offset
1833 /* Note that sgot->output_offset is not involved in this
1834 calculation. We always want the start of .got. If we
1835 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1836 permitted by the ABI, we might have to change this
1838 relocation
-= htab
->sgot
->output_section
->vma
;
1842 case R_390_GOTPCDBL
:
1843 /* Use global offset table as symbol value. */
1844 relocation
= htab
->sgot
->output_section
->vma
;
1845 unresolved_reloc
= FALSE
;
1848 case R_390_PLT16DBL
:
1849 case R_390_PLT32DBL
:
1851 /* Relocation is to the entry for this symbol in the
1852 procedure linkage table. */
1854 /* Resolve a PLT32 reloc against a local symbol directly,
1855 without using the procedure linkage table. */
1859 if (h
->plt
.offset
== (bfd_vma
) -1
1860 || htab
->splt
== NULL
)
1862 /* We didn't make a PLT entry for this symbol. This
1863 happens when statically linking PIC code, or when
1864 using -Bsymbolic. */
1868 relocation
= (htab
->splt
->output_section
->vma
1869 + htab
->splt
->output_offset
1871 unresolved_reloc
= FALSE
;
1881 /* r_symndx will be zero only for relocs against symbols
1882 from removed linkonce sections, or sections discarded by
1885 || (input_section
->flags
& SEC_ALLOC
) == 0)
1889 && ((r_type
!= R_390_PC16
1890 && r_type
!= R_390_PC16DBL
1891 && r_type
!= R_390_PC32DBL
1892 && r_type
!= R_390_PC32
)
1895 && (! info
->symbolic
1896 || (h
->elf_link_hash_flags
1897 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1901 && (h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
1902 && (((h
->elf_link_hash_flags
1903 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
1904 && (h
->elf_link_hash_flags
1905 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
1906 || h
->root
.type
== bfd_link_hash_undefweak
1907 || h
->root
.type
== bfd_link_hash_undefined
)))
1909 Elf_Internal_Rela outrel
;
1910 bfd_boolean skip
, relocate
;
1914 /* When generating a shared object, these relocations
1915 are copied into the output file to be resolved at run
1922 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1924 if (outrel
.r_offset
== (bfd_vma
) -1)
1926 else if (outrel
.r_offset
== (bfd_vma
) -2)
1927 skip
= TRUE
, relocate
= TRUE
;
1928 outrel
.r_offset
+= (input_section
->output_section
->vma
1929 + input_section
->output_offset
);
1932 memset (&outrel
, 0, sizeof outrel
);
1935 && (r_type
== R_390_PC16
1936 || r_type
== R_390_PC16DBL
1937 || r_type
== R_390_PC32DBL
1938 || r_type
== R_390_PC32
1941 || (h
->elf_link_hash_flags
1942 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1944 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1945 outrel
.r_addend
= rel
->r_addend
;
1949 /* This symbol is local, or marked to become local. */
1951 outrel
.r_info
= ELF32_R_INFO (0, R_390_RELATIVE
);
1952 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1955 sreloc
= elf_section_data (input_section
)->sreloc
;
1959 loc
= sreloc
->contents
;
1960 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
1961 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1963 /* If this reloc is against an external symbol, we do
1964 not want to fiddle with the addend. Otherwise, we
1965 need to include the symbol value so that it becomes
1966 an addend for the dynamic reloc. */
1976 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
1977 because such sections are not SEC_ALLOC and thus ld.so will
1978 not process them. */
1979 if (unresolved_reloc
1980 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
1981 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0))
1982 (*_bfd_error_handler
)
1983 (_("%s(%s+0x%lx): unresolvable relocation against symbol `%s'"),
1984 bfd_archive_filename (input_bfd
),
1985 bfd_get_section_name (input_bfd
, input_section
),
1986 (long) rel
->r_offset
,
1987 h
->root
.root
.string
);
1989 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1990 contents
, rel
->r_offset
,
1991 relocation
, rel
->r_addend
);
1993 if (r
!= bfd_reloc_ok
)
1998 name
= h
->root
.root
.string
;
2001 name
= bfd_elf_string_from_elf_section (input_bfd
,
2002 symtab_hdr
->sh_link
,
2007 name
= bfd_section_name (input_bfd
, sec
);
2010 if (r
== bfd_reloc_overflow
)
2013 if (! ((*info
->callbacks
->reloc_overflow
)
2014 (info
, name
, howto
->name
, (bfd_vma
) 0,
2015 input_bfd
, input_section
, rel
->r_offset
)))
2020 (*_bfd_error_handler
)
2021 (_("%s(%s+0x%lx): reloc against `%s': error %d"),
2022 bfd_archive_filename (input_bfd
),
2023 bfd_get_section_name (input_bfd
, input_section
),
2024 (long) rel
->r_offset
, name
, (int) r
);
2033 /* Finish up dynamic symbol handling. We set the contents of various
2034 dynamic sections here. */
2037 elf_s390_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
2039 struct bfd_link_info
*info
;
2040 struct elf_link_hash_entry
*h
;
2041 Elf_Internal_Sym
*sym
;
2043 struct elf_s390_link_hash_table
*htab
;
2045 htab
= elf_s390_hash_table (info
);
2047 if (h
->plt
.offset
!= (bfd_vma
) -1)
2051 Elf_Internal_Rela rela
;
2053 bfd_vma relative_offset
;
2055 /* This symbol has an entry in the procedure linkage table. Set
2058 if (h
->dynindx
== -1
2059 || htab
->splt
== NULL
2060 || htab
->sgotplt
== NULL
2061 || htab
->srelplt
== NULL
)
2065 Current offset - size first entry / entry size. */
2066 plt_index
= (h
->plt
.offset
- PLT_FIRST_ENTRY_SIZE
) / PLT_ENTRY_SIZE
;
2068 /* Offset in GOT is PLT index plus GOT headers(3) times 4,
2070 got_offset
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
2072 /* S390 uses halfwords for relative branch calc! */
2073 relative_offset
= - ((PLT_FIRST_ENTRY_SIZE
+
2074 (PLT_ENTRY_SIZE
* plt_index
) + 18) / 2);
2075 /* If offset is > 32768, branch to a previous branch
2076 390 can only handle +-64 K jumps. */
2077 if ( -32768 > (int) relative_offset
)
2079 -(unsigned) (((65536 / PLT_ENTRY_SIZE
- 1) * PLT_ENTRY_SIZE
) / 2);
2081 /* Fill in the entry in the procedure linkage table. */
2084 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD0
,
2085 htab
->splt
->contents
+ h
->plt
.offset
);
2086 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD1
,
2087 htab
->splt
->contents
+ h
->plt
.offset
+ 4);
2088 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD2
,
2089 htab
->splt
->contents
+ h
->plt
.offset
+ 8);
2090 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD3
,
2091 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
2092 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD4
,
2093 htab
->splt
->contents
+ h
->plt
.offset
+ 16);
2094 bfd_put_32 (output_bfd
, (bfd_vma
) 0+(relative_offset
<< 16),
2095 htab
->splt
->contents
+ h
->plt
.offset
+ 20);
2096 bfd_put_32 (output_bfd
,
2097 (htab
->sgotplt
->output_section
->vma
2098 + htab
->sgotplt
->output_offset
2100 htab
->splt
->contents
+ h
->plt
.offset
+ 24);
2102 else if (got_offset
< 4096)
2104 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC12_ENTRY_WORD0
+ got_offset
,
2105 htab
->splt
->contents
+ h
->plt
.offset
);
2106 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC12_ENTRY_WORD1
,
2107 htab
->splt
->contents
+ h
->plt
.offset
+ 4);
2108 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC12_ENTRY_WORD2
,
2109 htab
->splt
->contents
+ h
->plt
.offset
+ 8);
2110 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC12_ENTRY_WORD3
,
2111 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
2112 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC12_ENTRY_WORD4
,
2113 htab
->splt
->contents
+ h
->plt
.offset
+ 16);
2114 bfd_put_32 (output_bfd
, (bfd_vma
) 0+(relative_offset
<< 16),
2115 htab
->splt
->contents
+ h
->plt
.offset
+ 20);
2116 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2117 htab
->splt
->contents
+ h
->plt
.offset
+ 24);
2119 else if (got_offset
< 32768)
2121 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC16_ENTRY_WORD0
+ got_offset
,
2122 htab
->splt
->contents
+ h
->plt
.offset
);
2123 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC16_ENTRY_WORD1
,
2124 htab
->splt
->contents
+ h
->plt
.offset
+ 4);
2125 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC16_ENTRY_WORD2
,
2126 htab
->splt
->contents
+ h
->plt
.offset
+ 8);
2127 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC16_ENTRY_WORD3
,
2128 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
2129 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC16_ENTRY_WORD4
,
2130 htab
->splt
->contents
+ h
->plt
.offset
+ 16);
2131 bfd_put_32 (output_bfd
, (bfd_vma
) 0+(relative_offset
<< 16),
2132 htab
->splt
->contents
+ h
->plt
.offset
+ 20);
2133 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2134 htab
->splt
->contents
+ h
->plt
.offset
+ 24);
2138 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_ENTRY_WORD0
,
2139 htab
->splt
->contents
+ h
->plt
.offset
);
2140 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_ENTRY_WORD1
,
2141 htab
->splt
->contents
+ h
->plt
.offset
+ 4);
2142 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_ENTRY_WORD2
,
2143 htab
->splt
->contents
+ h
->plt
.offset
+ 8);
2144 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_ENTRY_WORD3
,
2145 htab
->splt
->contents
+ h
->plt
.offset
+ 12);
2146 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_ENTRY_WORD4
,
2147 htab
->splt
->contents
+ h
->plt
.offset
+ 16);
2148 bfd_put_32 (output_bfd
, (bfd_vma
) 0+(relative_offset
<< 16),
2149 htab
->splt
->contents
+ h
->plt
.offset
+ 20);
2150 bfd_put_32 (output_bfd
, got_offset
,
2151 htab
->splt
->contents
+ h
->plt
.offset
+ 24);
2153 /* Insert offset into reloc. table here. */
2154 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rela
),
2155 htab
->splt
->contents
+ h
->plt
.offset
+ 28);
2157 /* Fill in the entry in the global offset table.
2158 Points to instruction after GOT offset. */
2159 bfd_put_32 (output_bfd
,
2160 (htab
->splt
->output_section
->vma
2161 + htab
->splt
->output_offset
2164 htab
->sgotplt
->contents
+ got_offset
);
2166 /* Fill in the entry in the .rela.plt section. */
2167 rela
.r_offset
= (htab
->sgotplt
->output_section
->vma
2168 + htab
->sgotplt
->output_offset
2170 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_390_JMP_SLOT
);
2172 loc
= htab
->srelplt
->contents
+ plt_index
* sizeof (Elf32_External_Rela
);
2173 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
2175 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2177 /* Mark the symbol as undefined, rather than as defined in
2178 the .plt section. Leave the value alone. This is a clue
2179 for the dynamic linker, to make function pointer
2180 comparisons work between an application and shared
2182 sym
->st_shndx
= SHN_UNDEF
;
2186 if (h
->got
.offset
!= (bfd_vma
) -1)
2188 Elf_Internal_Rela rela
;
2191 /* This symbol has an entry in the global offset table. Set it
2194 if (htab
->sgot
== NULL
|| htab
->srelgot
== NULL
)
2197 rela
.r_offset
= (htab
->sgot
->output_section
->vma
2198 + htab
->sgot
->output_offset
2199 + (h
->got
.offset
&~ (bfd_vma
) 1));
2201 /* If this is a static link, or it is a -Bsymbolic link and the
2202 symbol is defined locally or was forced to be local because
2203 of a version file, we just want to emit a RELATIVE reloc.
2204 The entry in the global offset table will already have been
2205 initialized in the relocate_section function. */
2209 || (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
))
2210 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
2212 BFD_ASSERT((h
->got
.offset
& 1) != 0);
2213 rela
.r_info
= ELF32_R_INFO (0, R_390_RELATIVE
);
2214 rela
.r_addend
= (h
->root
.u
.def
.value
2215 + h
->root
.u
.def
.section
->output_section
->vma
2216 + h
->root
.u
.def
.section
->output_offset
);
2220 BFD_ASSERT((h
->got
.offset
& 1) == 0);
2221 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgot
->contents
+ h
->got
.offset
);
2222 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_390_GLOB_DAT
);
2226 loc
= htab
->srelgot
->contents
;
2227 loc
+= htab
->srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
2228 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
2231 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
2233 Elf_Internal_Rela rela
;
2236 /* This symbols needs a copy reloc. Set it up. */
2238 if (h
->dynindx
== -1
2239 || (h
->root
.type
!= bfd_link_hash_defined
2240 && h
->root
.type
!= bfd_link_hash_defweak
)
2241 || htab
->srelbss
== NULL
)
2244 rela
.r_offset
= (h
->root
.u
.def
.value
2245 + h
->root
.u
.def
.section
->output_section
->vma
2246 + h
->root
.u
.def
.section
->output_offset
);
2247 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_390_COPY
);
2249 loc
= htab
->srelbss
->contents
;
2250 loc
+= htab
->srelbss
->reloc_count
++ * sizeof (Elf32_External_Rela
);
2251 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
2254 /* Mark some specially defined symbols as absolute. */
2255 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2256 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
2257 || strcmp (h
->root
.root
.string
, "_PROCEDURE_LINKAGE_TABLE_") == 0)
2258 sym
->st_shndx
= SHN_ABS
;
2263 /* Used to decide how to sort relocs in an optimal manner for the
2264 dynamic linker, before writing them out. */
2266 static enum elf_reloc_type_class
2267 elf_s390_reloc_type_class (rela
)
2268 const Elf_Internal_Rela
*rela
;
2270 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2272 case R_390_RELATIVE
:
2273 return reloc_class_relative
;
2274 case R_390_JMP_SLOT
:
2275 return reloc_class_plt
;
2277 return reloc_class_copy
;
2279 return reloc_class_normal
;
2283 /* Finish up the dynamic sections. */
2286 elf_s390_finish_dynamic_sections (output_bfd
, info
)
2288 struct bfd_link_info
*info
;
2290 struct elf_s390_link_hash_table
*htab
;
2294 htab
= elf_s390_hash_table (info
);
2295 dynobj
= htab
->elf
.dynobj
;
2296 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2298 if (htab
->elf
.dynamic_sections_created
)
2300 Elf32_External_Dyn
*dyncon
, *dynconend
;
2302 if (sdyn
== NULL
|| htab
->sgot
== NULL
)
2305 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2306 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
2307 for (; dyncon
< dynconend
; dyncon
++)
2309 Elf_Internal_Dyn dyn
;
2312 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2320 dyn
.d_un
.d_ptr
= htab
->sgot
->output_section
->vma
;
2324 dyn
.d_un
.d_ptr
= htab
->srelplt
->output_section
->vma
;
2328 s
= htab
->srelplt
->output_section
;
2329 if (s
->_cooked_size
!= 0)
2330 dyn
.d_un
.d_val
= s
->_cooked_size
;
2332 dyn
.d_un
.d_val
= s
->_raw_size
;
2336 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2339 /* Fill in the special first entry in the procedure linkage table. */
2340 if (htab
->splt
&& htab
->splt
->_raw_size
> 0)
2342 memset (htab
->splt
->contents
, 0, PLT_FIRST_ENTRY_SIZE
);
2345 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_FIRST_ENTRY_WORD0
,
2346 htab
->splt
->contents
);
2347 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_FIRST_ENTRY_WORD1
,
2348 htab
->splt
->contents
+4 );
2349 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_FIRST_ENTRY_WORD2
,
2350 htab
->splt
->contents
+8 );
2351 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_FIRST_ENTRY_WORD3
,
2352 htab
->splt
->contents
+12 );
2353 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_FIRST_ENTRY_WORD4
,
2354 htab
->splt
->contents
+16 );
2358 bfd_put_32 (output_bfd
, (bfd_vma
)PLT_FIRST_ENTRY_WORD0
,
2359 htab
->splt
->contents
);
2360 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD1
,
2361 htab
->splt
->contents
+4 );
2362 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD2
,
2363 htab
->splt
->contents
+8 );
2364 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD3
,
2365 htab
->splt
->contents
+12 );
2366 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD4
,
2367 htab
->splt
->contents
+16 );
2368 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD5
,
2369 htab
->splt
->contents
+20 );
2370 bfd_put_32 (output_bfd
,
2371 htab
->sgotplt
->output_section
->vma
2372 + htab
->sgotplt
->output_offset
,
2373 htab
->splt
->contents
+ 24);
2375 elf_section_data (htab
->splt
->output_section
)
2376 ->this_hdr
.sh_entsize
= 4;
2383 /* Fill in the first three entries in the global offset table. */
2384 if (htab
->sgotplt
->_raw_size
> 0)
2386 bfd_put_32 (output_bfd
,
2387 (sdyn
== NULL
? (bfd_vma
) 0
2388 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
2389 htab
->sgotplt
->contents
);
2390 /* One entry for shared object struct ptr. */
2391 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 4);
2392 /* One entry for _dl_runtime_resolve. */
2393 bfd_put_32 (output_bfd
, (bfd_vma
) 0, htab
->sgotplt
->contents
+ 8);
2396 elf_section_data (htab
->sgotplt
->output_section
)
2397 ->this_hdr
.sh_entsize
= 4;
2403 elf_s390_object_p (abfd
)
2406 return bfd_default_set_arch_mach (abfd
, bfd_arch_s390
, bfd_mach_s390_31
);
2410 elf_s390_grok_prstatus (abfd
, note
)
2412 Elf_Internal_Note
* note
;
2415 unsigned int raw_size
;
2417 switch (note
->descsz
)
2422 case 224: /* S/390 Linux. */
2424 elf_tdata (abfd
)->core_signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
2427 elf_tdata (abfd
)->core_pid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
2435 /* Make a ".reg/999" section. */
2436 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
2437 raw_size
, note
->descpos
+ offset
);
2440 #define TARGET_BIG_SYM bfd_elf32_s390_vec
2441 #define TARGET_BIG_NAME "elf32-s390"
2442 #define ELF_ARCH bfd_arch_s390
2443 #define ELF_MACHINE_CODE EM_S390
2444 #define ELF_MACHINE_ALT1 EM_S390_OLD
2445 #define ELF_MAXPAGESIZE 0x1000
2447 #define elf_backend_can_gc_sections 1
2448 #define elf_backend_can_refcount 1
2449 #define elf_backend_want_got_plt 1
2450 #define elf_backend_plt_readonly 1
2451 #define elf_backend_want_plt_sym 0
2452 #define elf_backend_got_header_size 12
2453 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
2454 #define elf_backend_rela_normal 1
2456 #define elf_info_to_howto elf_s390_info_to_howto
2458 #define bfd_elf32_bfd_is_local_label_name elf_s390_is_local_label_name
2459 #define bfd_elf32_bfd_link_hash_table_create elf_s390_link_hash_table_create
2460 #define bfd_elf32_bfd_reloc_type_lookup elf_s390_reloc_type_lookup
2462 #define elf_backend_adjust_dynamic_symbol elf_s390_adjust_dynamic_symbol
2463 #define elf_backend_check_relocs elf_s390_check_relocs
2464 #define elf_backend_copy_indirect_symbol elf_s390_copy_indirect_symbol
2465 #define elf_backend_create_dynamic_sections elf_s390_create_dynamic_sections
2466 #define elf_backend_finish_dynamic_sections elf_s390_finish_dynamic_sections
2467 #define elf_backend_finish_dynamic_symbol elf_s390_finish_dynamic_symbol
2468 #define elf_backend_gc_mark_hook elf_s390_gc_mark_hook
2469 #define elf_backend_gc_sweep_hook elf_s390_gc_sweep_hook
2470 #define elf_backend_reloc_type_class elf_s390_reloc_type_class
2471 #define elf_backend_relocate_section elf_s390_relocate_section
2472 #define elf_backend_size_dynamic_sections elf_s390_size_dynamic_sections
2473 #define elf_backend_reloc_type_class elf_s390_reloc_type_class
2474 #define elf_backend_grok_prstatus elf_s390_grok_prstatus
2476 #define elf_backend_object_p elf_s390_object_p
2478 #include "elf32-target.h"