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
PARAMS ((bfd
*, const char *));
33 static struct bfd_hash_entry
*elf_s390_link_hash_newfunc
34 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
35 static struct bfd_link_hash_table
*elf_s390_link_hash_table_create
37 static boolean elf_s390_check_relocs
38 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
39 const Elf_Internal_Rela
*));
40 static asection
*elf_s390_gc_mark_hook
41 PARAMS ((bfd
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
42 struct elf_link_hash_entry
*, Elf_Internal_Sym
*sym
));
43 static boolean elf_s390_gc_sweep_hook
44 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
45 const Elf_Internal_Rela
*));
46 static boolean elf_s390_adjust_dynamic_symbol
47 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
48 static boolean elf_s390_size_dynamic_sections
49 PARAMS ((bfd
*, struct bfd_link_info
*));
50 static boolean elf_s390_relocate_section
51 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
52 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
53 static boolean elf_s390_finish_dynamic_symbol
54 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf_link_hash_entry
*,
56 static boolean elf_s390_finish_dynamic_sections
57 PARAMS ((bfd
*, struct bfd_link_info
*));
58 static boolean elf_s390_object_p
PARAMS ((bfd
*));
59 static enum elf_reloc_type_class elf_s390_reloc_type_class
PARAMS ((int));
61 #define USE_RELA 1 /* We want RELA relocations, not REL. */
65 /* The relocation "howto" table. */
67 static reloc_howto_type elf_howto_table
[] =
69 HOWTO (R_390_NONE
, /* type */
71 0, /* size (0 = byte, 1 = short, 2 = long) */
73 false, /* pc_relative */
75 complain_overflow_dont
, /* complain_on_overflow */
76 bfd_elf_generic_reloc
, /* special_function */
77 "R_390_NONE", /* name */
78 false, /* partial_inplace */
81 false), /* pcrel_offset */
83 HOWTO(R_390_8
, 0, 0, 8, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_8", false, 0,0x000000ff, false),
84 HOWTO(R_390_12
, 0, 1, 12, false, 0, complain_overflow_dont
, bfd_elf_generic_reloc
, "R_390_12", false, 0,0x00000fff, false),
85 HOWTO(R_390_16
, 0, 1, 16, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_16", false, 0,0x0000ffff, false),
86 HOWTO(R_390_32
, 0, 2, 32, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_32", false, 0,0xffffffff, false),
87 HOWTO(R_390_PC32
, 0, 2, 32, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PC32", false, 0,0xffffffff, true),
88 HOWTO(R_390_GOT12
, 0, 1, 12, false, 0, complain_overflow_dont
, bfd_elf_generic_reloc
, "R_390_GOT12", false, 0,0x00000fff, false),
89 HOWTO(R_390_GOT32
, 0, 2, 32, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_GOT32", false, 0,0xffffffff, false),
90 HOWTO(R_390_PLT32
, 0, 2, 32, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PLT32", false, 0,0xffffffff, true),
91 HOWTO(R_390_COPY
, 0, 2, 32, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_COPY", false, 0,0xffffffff, false),
92 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),
93 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),
94 HOWTO(R_390_RELATIVE
, 0, 2, 32, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_RELATIVE",false, 0,0xffffffff, false),
95 HOWTO(R_390_GOTOFF
, 0, 2, 32, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_GOTOFF", false, 0,0xffffffff, false),
96 HOWTO(R_390_GOTPC
, 0, 2, 32, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_GOTPC", false, 0,0xffffffff, true),
97 HOWTO(R_390_GOT16
, 0, 1, 16, false, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_GOT16", false, 0,0x0000ffff, false),
98 HOWTO(R_390_PC16
, 0, 1, 16, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PC16", false, 0,0x0000ffff, true),
99 HOWTO(R_390_PC16DBL
, 1, 1, 16, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PC16DBL", false, 0,0x0000ffff, true),
100 HOWTO(R_390_PLT16DBL
, 1, 1, 16, true, 0, complain_overflow_bitfield
, bfd_elf_generic_reloc
, "R_390_PLT16DBL", false, 0,0x0000ffff, true),
103 /* GNU extension to record C++ vtable hierarchy. */
104 static reloc_howto_type elf32_s390_vtinherit_howto
=
105 HOWTO (R_390_GNU_VTINHERIT
, 0,2,0,false,0,complain_overflow_dont
, NULL
, "R_390_GNU_VTINHERIT", false,0, 0, false);
106 static reloc_howto_type elf32_s390_vtentry_howto
=
107 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);
109 static reloc_howto_type
*
110 elf_s390_reloc_type_lookup (abfd
, code
)
111 bfd
*abfd ATTRIBUTE_UNUSED
;
112 bfd_reloc_code_real_type code
;
116 return &elf_howto_table
[(int) R_390_NONE
];
118 return &elf_howto_table
[(int) R_390_8
];
119 case BFD_RELOC_390_12
:
120 return &elf_howto_table
[(int) R_390_12
];
122 return &elf_howto_table
[(int) R_390_16
];
124 return &elf_howto_table
[(int) R_390_32
];
126 return &elf_howto_table
[(int) R_390_32
];
127 case BFD_RELOC_32_PCREL
:
128 return &elf_howto_table
[(int) R_390_PC32
];
129 case BFD_RELOC_390_GOT12
:
130 return &elf_howto_table
[(int) R_390_GOT12
];
131 case BFD_RELOC_32_GOT_PCREL
:
132 return &elf_howto_table
[(int) R_390_GOT32
];
133 case BFD_RELOC_390_PLT32
:
134 return &elf_howto_table
[(int) R_390_PLT32
];
135 case BFD_RELOC_390_COPY
:
136 return &elf_howto_table
[(int) R_390_COPY
];
137 case BFD_RELOC_390_GLOB_DAT
:
138 return &elf_howto_table
[(int) R_390_GLOB_DAT
];
139 case BFD_RELOC_390_JMP_SLOT
:
140 return &elf_howto_table
[(int) R_390_JMP_SLOT
];
141 case BFD_RELOC_390_RELATIVE
:
142 return &elf_howto_table
[(int) R_390_RELATIVE
];
143 case BFD_RELOC_32_GOTOFF
:
144 return &elf_howto_table
[(int) R_390_GOTOFF
];
145 case BFD_RELOC_390_GOTPC
:
146 return &elf_howto_table
[(int) R_390_GOTPC
];
147 case BFD_RELOC_390_GOT16
:
148 return &elf_howto_table
[(int) R_390_GOT16
];
149 case BFD_RELOC_16_PCREL
:
150 return &elf_howto_table
[(int) R_390_PC16
];
151 case BFD_RELOC_390_PC16DBL
:
152 return &elf_howto_table
[(int) R_390_PC16DBL
];
153 case BFD_RELOC_390_PLT16DBL
:
154 return &elf_howto_table
[(int) R_390_PLT16DBL
];
155 case BFD_RELOC_VTABLE_INHERIT
:
156 return &elf32_s390_vtinherit_howto
;
157 case BFD_RELOC_VTABLE_ENTRY
:
158 return &elf32_s390_vtentry_howto
;
165 /* We need to use ELF32_R_TYPE so we have our own copy of this function,
166 and elf32-s390.c has its own copy. */
169 elf_s390_info_to_howto (abfd
, cache_ptr
, dst
)
170 bfd
*abfd ATTRIBUTE_UNUSED
;
172 Elf_Internal_Rela
*dst
;
174 switch (ELF32_R_TYPE(dst
->r_info
))
176 case R_390_GNU_VTINHERIT
:
177 cache_ptr
->howto
= &elf32_s390_vtinherit_howto
;
180 case R_390_GNU_VTENTRY
:
181 cache_ptr
->howto
= &elf32_s390_vtentry_howto
;
185 BFD_ASSERT (ELF32_R_TYPE(dst
->r_info
) < (unsigned int) R_390_max
);
186 cache_ptr
->howto
= &elf_howto_table
[ELF32_R_TYPE(dst
->r_info
)];
191 elf_s390_is_local_label_name (abfd
, name
)
195 if (name
[0] == '.' && (name
[1] == 'X' || name
[1] == 'L'))
198 return _bfd_elf_is_local_label_name (abfd
, name
);
201 /* Functions for the 390 ELF linker. */
203 /* The name of the dynamic interpreter. This is put in the .interp
206 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
208 /* The nop opcode we use. */
210 #define s390_NOP 0x07070707
213 /* The size in bytes of the first entry in the procedure linkage table. */
214 #define PLT_FIRST_ENTRY_SIZE 32
215 /* The size in bytes of an entry in the procedure linkage table. */
216 #define PLT_ENTRY_SIZE 32
218 #define GOT_ENTRY_SIZE 4
220 /* The first three entries in a procedure linkage table are reserved,
221 and the initial contents are unimportant (we zero them out).
222 Subsequent entries look like this. See the SVR4 ABI 386
223 supplement to see how this works. */
225 /* For the s390, simple addr offset can only be 0 - 4096.
226 To use the full 2 GB address space, several instructions
227 are needed to load an address in a register and execute
228 a branch( or just saving the address)
230 Furthermore, only r 0 and 1 are free to use!!! */
232 /* The first 3 words in the GOT are then reserved.
233 Word 0 is the address of the dynamic table.
234 Word 1 is a pointer to a structure describing the object
235 Word 2 is used to point to the loader entry address.
237 The code for position independand PLT entries looks like this:
239 r12 holds addr of the current GOT at entry to the PLT
241 The GOT holds the address in the PLT to be executed.
242 The loader then gets:
243 24(15) = Pointer to the structure describing the object.
244 28(15) = Offset in symbol table
246 The loader must then find the module where the function is
247 and insert the address in the GOT.
249 Note: 390 can only address +- 64 K relative.
250 We check if offset > 65536, then make a relative branch -64xxx
251 back to a previous defined branch
253 PLT1: BASR 1,0 # 2 bytes
254 L 1,22(1) # 4 bytes Load offset in GOT in r 1
255 L 1,(1,12) # 4 bytes Load address from GOT in r1
256 BCR 15,1 # 2 bytes Jump to address
257 RET1: BASR 1,0 # 2 bytes Return from GOT 1st time
258 L 1,14(1) # 4 bytes Load offset in symol table in r1
259 BRC 15,-x # 4 bytes Jump to start of PLT
260 .word 0 # 2 bytes filler
261 .long ? # 4 bytes offset in GOT
262 .long ? # 4 bytes offset into symbol table
264 This was the general case. There are two additional, optimizes PLT
265 definitions. One for GOT offsets < 4096 and one for GOT offsets < 32768.
266 First the one for GOT offsets < 4096:
268 PLT1: L 1,<offset>(12) # 4 bytes Load address from GOT in R1
269 BCR 15,1 # 2 bytes Jump to address
270 .word 0,0,0 # 6 bytes filler
271 RET1: BASR 1,0 # 2 bytes Return from GOT 1st time
272 L 1,14(1) # 4 bytes Load offset in symbol table in r1
273 BRC 15,-x # 4 bytes Jump to start of PLT
274 .word 0,0,0 # 6 bytes filler
275 .long ? # 4 bytes offset into symbol table
277 Second the one for GOT offsets < 32768:
279 PLT1: LHI 1,<offset> # 4 bytes Load offset in GOT to r1
280 L 1,(1,12) # 4 bytes Load address from GOT to r1
281 BCR 15,1 # 2 bytes Jump to address
282 .word 0 # 2 bytes filler
283 RET1: BASR 1,0 # 2 bytes Return from GOT 1st time
284 L 1,14(1) # 4 bytes Load offset in symbol table in r1
285 BRC 15,-x # 4 bytes Jump to start of PLT
286 .word 0,0,0 # 6 bytes filler
287 .long ? # 4 bytes offset into symbol table
289 Total = 32 bytes per PLT entry
291 The code for static build PLT entries looks like this:
293 PLT1: BASR 1,0 # 2 bytes
294 L 1,22(1) # 4 bytes Load address of GOT entry
295 L 1,0(0,1) # 4 bytes Load address from GOT in r1
296 BCR 15,1 # 2 bytes Jump to address
297 RET1: BASR 1,0 # 2 bytes Return from GOT 1st time
298 L 1,14(1) # 4 bytes Load offset in symbol table in r1
299 BRC 15,-x # 4 bytes Jump to start of PLT
300 .word 0 # 2 bytes filler
301 .long ? # 4 bytes address of GOT entry
302 .long ? # 4 bytes offset into symbol table */
304 #define PLT_PIC_ENTRY_WORD0 0x0d105810
305 #define PLT_PIC_ENTRY_WORD1 0x10165811
306 #define PLT_PIC_ENTRY_WORD2 0xc00007f1
307 #define PLT_PIC_ENTRY_WORD3 0x0d105810
308 #define PLT_PIC_ENTRY_WORD4 0x100ea7f4
310 #define PLT_PIC12_ENTRY_WORD0 0x5810c000
311 #define PLT_PIC12_ENTRY_WORD1 0x07f10000
312 #define PLT_PIC12_ENTRY_WORD2 0x00000000
313 #define PLT_PIC12_ENTRY_WORD3 0x0d105810
314 #define PLT_PIC12_ENTRY_WORD4 0x100ea7f4
316 #define PLT_PIC16_ENTRY_WORD0 0xa7180000
317 #define PLT_PIC16_ENTRY_WORD1 0x5811c000
318 #define PLT_PIC16_ENTRY_WORD2 0x07f10000
319 #define PLT_PIC16_ENTRY_WORD3 0x0d105810
320 #define PLT_PIC16_ENTRY_WORD4 0x100ea7f4
322 #define PLT_ENTRY_WORD0 0x0d105810
323 #define PLT_ENTRY_WORD1 0x10165810
324 #define PLT_ENTRY_WORD2 0x100007f1
325 #define PLT_ENTRY_WORD3 0x0d105810
326 #define PLT_ENTRY_WORD4 0x100ea7f4
328 /* The first PLT entry pushes the offset into the symbol table
329 from R1 onto the stack at 8(15) and the loader object info
330 at 12(15), loads the loader address in R1 and jumps to it. */
332 /* The first entry in the PLT for PIC code:
335 ST 1,28(15) # R1 has offset into symbol table
336 L 1,4(12) # Get loader ino(object struct address)
337 ST 1,24(15) # Store address
338 L 1,8(12) # Entry address of loader in R1
339 BR 1 # Jump to loader
341 The first entry in the PLT for static code:
344 ST 1,28(15) # R1 has offset into symbol table
346 L 1,18(0,1) # Get address of GOT
347 MVC 24(4,15),4(1) # Move loader ino to stack
348 L 1,8(1) # Get address of loader
349 BR 1 # Jump to loader
351 .long got # address of GOT */
353 #define PLT_PIC_FIRST_ENTRY_WORD0 0x5010f01c
354 #define PLT_PIC_FIRST_ENTRY_WORD1 0x5810c004
355 #define PLT_PIC_FIRST_ENTRY_WORD2 0x5010f018
356 #define PLT_PIC_FIRST_ENTRY_WORD3 0x5810c008
357 #define PLT_PIC_FIRST_ENTRY_WORD4 0x07f10000
359 #define PLT_FIRST_ENTRY_WORD0 0x5010f01c
360 #define PLT_FIRST_ENTRY_WORD1 0x0d105810
361 #define PLT_FIRST_ENTRY_WORD2 0x1012D203
362 #define PLT_FIRST_ENTRY_WORD3 0xf0181004
363 #define PLT_FIRST_ENTRY_WORD4 0x58101008
364 #define PLT_FIRST_ENTRY_WORD5 0x07f10000
366 /* The s390 linker needs to keep track of the number of relocs that it
367 decides to copy in check_relocs for each symbol. This is so that
368 it can discard PC relative relocs if it doesn't need them when
369 linking with -Bsymbolic. We store the information in a field
370 extending the regular ELF linker hash table. */
372 /* This structure keeps track of the number of PC relative relocs we
373 have copied for a given symbol. */
375 struct elf_s390_pcrel_relocs_copied
378 struct elf_s390_pcrel_relocs_copied
*next
;
379 /* A section in dynobj. */
381 /* Number of relocs copied in this section. */
385 /* s390 ELF linker hash entry. */
387 struct elf_s390_link_hash_entry
389 struct elf_link_hash_entry root
;
391 /* Number of PC relative relocs copied for this symbol. */
392 struct elf_s390_pcrel_relocs_copied
*pcrel_relocs_copied
;
395 /* s390 ELF linker hash table. */
397 struct elf_s390_link_hash_table
399 struct elf_link_hash_table root
;
402 /* Declare this now that the above structures are defined. */
404 static boolean elf_s390_discard_copies
405 PARAMS ((struct elf_s390_link_hash_entry
*, PTR
));
407 /* Traverse an s390 ELF linker hash table. */
409 #define elf_s390_link_hash_traverse(table, func, info) \
410 (elf_link_hash_traverse \
412 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
415 /* Get the s390 ELF linker hash table from a link_info structure. */
417 #define elf_s390_hash_table(p) \
418 ((struct elf_s390_link_hash_table *) ((p)->hash))
420 /* Create an entry in an s390 ELF linker hash table. */
422 static struct bfd_hash_entry
*
423 elf_s390_link_hash_newfunc (entry
, table
, string
)
424 struct bfd_hash_entry
*entry
;
425 struct bfd_hash_table
*table
;
428 struct elf_s390_link_hash_entry
*ret
=
429 (struct elf_s390_link_hash_entry
*) entry
;
431 /* Allocate the structure if it has not already been allocated by a
433 if (ret
== (struct elf_s390_link_hash_entry
*) NULL
)
434 ret
= ((struct elf_s390_link_hash_entry
*)
435 bfd_hash_allocate (table
,
436 sizeof (struct elf_s390_link_hash_entry
)));
437 if (ret
== (struct elf_s390_link_hash_entry
*) NULL
)
438 return (struct bfd_hash_entry
*) ret
;
440 /* Call the allocation method of the superclass. */
441 ret
= ((struct elf_s390_link_hash_entry
*)
442 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
444 if (ret
!= (struct elf_s390_link_hash_entry
*) NULL
)
446 ret
->pcrel_relocs_copied
= NULL
;
449 return (struct bfd_hash_entry
*) ret
;
452 /* Create an s390 ELF linker hash table. */
454 static struct bfd_link_hash_table
*
455 elf_s390_link_hash_table_create (abfd
)
458 struct elf_s390_link_hash_table
*ret
;
459 bfd_size_type amt
= sizeof (struct elf_s390_link_hash_table
);
461 ret
= (struct elf_s390_link_hash_table
*) bfd_alloc (abfd
, amt
);
462 if (ret
== (struct elf_s390_link_hash_table
*) NULL
)
465 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
466 elf_s390_link_hash_newfunc
))
468 bfd_release (abfd
, ret
);
472 return &ret
->root
.root
;
476 /* Look through the relocs for a section during the first phase, and
477 allocate space in the global offset table or procedure linkage
481 elf_s390_check_relocs (abfd
, info
, sec
, relocs
)
483 struct bfd_link_info
*info
;
485 const Elf_Internal_Rela
*relocs
;
488 Elf_Internal_Shdr
*symtab_hdr
;
489 struct elf_link_hash_entry
**sym_hashes
;
490 bfd_signed_vma
*local_got_refcounts
;
491 const Elf_Internal_Rela
*rel
;
492 const Elf_Internal_Rela
*rel_end
;
497 if (info
->relocateable
)
500 dynobj
= elf_hash_table (info
)->dynobj
;
501 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
502 sym_hashes
= elf_sym_hashes (abfd
);
503 local_got_refcounts
= elf_local_got_offsets (abfd
);
509 rel_end
= relocs
+ sec
->reloc_count
;
510 for (rel
= relocs
; rel
< rel_end
; rel
++)
512 unsigned long r_symndx
;
513 struct elf_link_hash_entry
*h
;
515 r_symndx
= ELF32_R_SYM (rel
->r_info
);
517 if (r_symndx
< symtab_hdr
->sh_info
)
520 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
522 /* Some relocs require a global offset table. */
525 switch (ELF32_R_TYPE (rel
->r_info
))
532 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
533 if (! _bfd_elf_create_got_section (dynobj
, info
))
543 switch (ELF32_R_TYPE (rel
->r_info
))
548 /* This symbol requires a global offset table entry. */
552 sgot
= bfd_get_section_by_name (dynobj
, ".got");
553 BFD_ASSERT (sgot
!= NULL
);
558 && (h
!= NULL
|| info
->shared
))
560 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
563 srelgot
= bfd_make_section (dynobj
, ".rela.got");
565 || ! bfd_set_section_flags (dynobj
, srelgot
,
572 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
579 if (h
->got
.refcount
== -1)
583 /* Make sure this symbol is output as a dynamic symbol. */
584 if (h
->dynindx
== -1)
586 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
590 sgot
->_raw_size
+= 4;
591 srelgot
->_raw_size
+= sizeof (Elf32_External_Rela
);
594 h
->got
.refcount
+= 1;
598 /* This is a global offset table entry for a local symbol. */
599 if (local_got_refcounts
== NULL
)
603 size
= symtab_hdr
->sh_info
;
604 size
*= sizeof (bfd_signed_vma
);
605 local_got_refcounts
= (bfd_signed_vma
*)
606 bfd_alloc (abfd
, size
);
607 if (local_got_refcounts
== NULL
)
609 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
610 memset (local_got_refcounts
, -1, (size_t) size
);
612 if (local_got_refcounts
[r_symndx
] == -1)
614 local_got_refcounts
[r_symndx
] = 1;
616 sgot
->_raw_size
+= 4;
619 /* If we are generating a shared object, we need to
620 output a R_390_RELATIVE reloc so that the dynamic
621 linker can adjust this GOT entry. */
622 srelgot
->_raw_size
+= sizeof (Elf32_External_Rela
);
626 local_got_refcounts
[r_symndx
] += 1;
632 /* This symbol requires a procedure linkage table entry. We
633 actually build the entry in adjust_dynamic_symbol,
634 because this might be a case of linking PIC code which is
635 never referenced by a dynamic object, in which case we
636 don't need to generate a procedure linkage table entry
639 /* If this is a local symbol, we resolve it directly without
640 creating a procedure linkage table entry. */
644 if (h
->plt
.refcount
== -1)
647 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
650 h
->plt
.refcount
+= 1;
660 h
->elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
662 /* If we are creating a shared library, and this is a reloc
663 against a global symbol, or a non PC relative reloc
664 against a local symbol, then we need to copy the reloc
665 into the shared library. However, if we are linking with
666 -Bsymbolic, we do not need to copy a reloc against a
667 global symbol which is defined in an object we are
668 including in the link (i.e., DEF_REGULAR is set). At
669 this point we have not seen all the input files, so it is
670 possible that DEF_REGULAR is not set now but will be set
671 later (it is never cleared). We account for that
672 possibility below by storing information in the
673 pcrel_relocs_copied field of the hash table entry. */
675 && (sec
->flags
& SEC_ALLOC
) != 0
676 && ((ELF32_R_TYPE (rel
->r_info
) != R_390_PC16
&&
677 ELF32_R_TYPE (rel
->r_info
) != R_390_PC16DBL
&&
678 ELF32_R_TYPE (rel
->r_info
) != R_390_PC32
)
681 || (h
->elf_link_hash_flags
682 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
684 /* When creating a shared object, we must copy these
685 reloc types into the output file. We create a reloc
686 section in dynobj and make room for this reloc. */
691 name
= (bfd_elf_string_from_elf_section
693 elf_elfheader (abfd
)->e_shstrndx
,
694 elf_section_data (sec
)->rel_hdr
.sh_name
));
698 BFD_ASSERT (strncmp (name
, ".rela", 5) == 0
699 && strcmp (bfd_get_section_name (abfd
, sec
),
702 sreloc
= bfd_get_section_by_name (dynobj
, name
);
707 sreloc
= bfd_make_section (dynobj
, name
);
708 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
709 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
710 if ((sec
->flags
& SEC_ALLOC
) != 0)
711 flags
|= SEC_ALLOC
| SEC_LOAD
;
713 || ! bfd_set_section_flags (dynobj
, sreloc
, flags
)
714 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
717 if (sec
->flags
& SEC_READONLY
)
718 info
->flags
|= DF_TEXTREL
;
721 sreloc
->_raw_size
+= sizeof (Elf32_External_Rela
);
723 /* If we are linking with -Bsymbolic, and this is a
724 global symbol, we count the number of PC relative
725 relocations we have entered for this symbol, so that
726 we can discard them again if the symbol is later
727 defined by a regular object. Note that this function
728 is only called if we are using an elf_s390 linker
729 hash table, which means that h is really a pointer to
730 an elf_s390_link_hash_entry. */
732 && (ELF32_R_TYPE (rel
->r_info
) == R_390_PC16
||
733 ELF32_R_TYPE (rel
->r_info
) == R_390_PC16DBL
||
734 ELF32_R_TYPE (rel
->r_info
) == R_390_PC32
))
736 struct elf_s390_link_hash_entry
*eh
;
737 struct elf_s390_pcrel_relocs_copied
*p
;
739 eh
= (struct elf_s390_link_hash_entry
*) h
;
741 for (p
= eh
->pcrel_relocs_copied
; p
!= NULL
; p
= p
->next
)
742 if (p
->section
== sreloc
)
747 p
= ((struct elf_s390_pcrel_relocs_copied
*)
748 bfd_alloc (dynobj
, (bfd_size_type
) sizeof *p
));
751 p
->next
= eh
->pcrel_relocs_copied
;
752 eh
->pcrel_relocs_copied
= p
;
763 /* This relocation describes the C++ object vtable hierarchy.
764 Reconstruct it for later use during GC. */
765 case R_390_GNU_VTINHERIT
:
766 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
770 /* This relocation describes which C++ vtable entries are actually
771 used. Record for later use during GC. */
772 case R_390_GNU_VTENTRY
:
773 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
785 /* Return the section that should be marked against GC for a given
789 elf_s390_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
791 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
792 Elf_Internal_Rela
*rel
;
793 struct elf_link_hash_entry
*h
;
794 Elf_Internal_Sym
*sym
;
798 switch (ELF32_R_TYPE (rel
->r_info
))
800 case R_390_GNU_VTINHERIT
:
801 case R_390_GNU_VTENTRY
:
805 switch (h
->root
.type
)
807 case bfd_link_hash_defined
:
808 case bfd_link_hash_defweak
:
809 return h
->root
.u
.def
.section
;
811 case bfd_link_hash_common
:
812 return h
->root
.u
.c
.p
->section
;
821 if (!(elf_bad_symtab (abfd
)
822 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
823 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
824 && sym
->st_shndx
!= SHN_COMMON
))
826 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
833 /* Update the got entry reference counts for the section being removed. */
836 elf_s390_gc_sweep_hook (abfd
, info
, sec
, relocs
)
837 bfd
*abfd ATTRIBUTE_UNUSED
;
838 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
839 asection
*sec ATTRIBUTE_UNUSED
;
840 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
;
842 Elf_Internal_Shdr
*symtab_hdr
;
843 struct elf_link_hash_entry
**sym_hashes
;
844 bfd_signed_vma
*local_got_refcounts
;
845 const Elf_Internal_Rela
*rel
, *relend
;
846 unsigned long r_symndx
;
847 struct elf_link_hash_entry
*h
;
852 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
853 sym_hashes
= elf_sym_hashes (abfd
);
854 local_got_refcounts
= elf_local_got_refcounts (abfd
);
856 dynobj
= elf_hash_table (info
)->dynobj
;
860 sgot
= bfd_get_section_by_name (dynobj
, ".got");
861 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
863 relend
= relocs
+ sec
->reloc_count
;
864 for (rel
= relocs
; rel
< relend
; rel
++)
865 switch (ELF32_R_TYPE (rel
->r_info
))
872 r_symndx
= ELF32_R_SYM (rel
->r_info
);
873 if (r_symndx
>= symtab_hdr
->sh_info
)
875 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
876 if (h
->got
.refcount
> 0)
878 h
->got
.refcount
-= 1;
879 if (h
->got
.refcount
== 0)
881 sgot
->_raw_size
-= 4;
882 srelgot
->_raw_size
-= sizeof (Elf32_External_Rela
);
886 else if (local_got_refcounts
!= NULL
)
888 if (local_got_refcounts
[r_symndx
] > 0)
890 local_got_refcounts
[r_symndx
] -= 1;
891 if (local_got_refcounts
[r_symndx
] == 0)
893 sgot
->_raw_size
-= 4;
895 srelgot
->_raw_size
-= sizeof (Elf32_External_Rela
);
903 r_symndx
= ELF32_R_SYM (rel
->r_info
);
904 if (r_symndx
>= symtab_hdr
->sh_info
)
906 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
907 if (h
->plt
.refcount
> 0)
908 h
->plt
.refcount
-= 1;
919 /* Adjust a symbol defined by a dynamic object and referenced by a
920 regular object. The current definition is in some section of the
921 dynamic object, but we're not including those sections. We have to
922 change the definition to something the rest of the link can
926 elf_s390_adjust_dynamic_symbol (info
, h
)
927 struct bfd_link_info
*info
;
928 struct elf_link_hash_entry
*h
;
932 unsigned int power_of_two
;
934 dynobj
= elf_hash_table (info
)->dynobj
;
936 /* Make sure we know what is going on here. */
937 BFD_ASSERT (dynobj
!= NULL
938 && ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
)
939 || h
->weakdef
!= NULL
940 || ((h
->elf_link_hash_flags
941 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
942 && (h
->elf_link_hash_flags
943 & ELF_LINK_HASH_REF_REGULAR
) != 0
944 && (h
->elf_link_hash_flags
945 & ELF_LINK_HASH_DEF_REGULAR
) == 0)));
947 /* If this is a function, put it in the procedure linkage table. We
948 will fill in the contents of the procedure linkage table later
949 (although we could actually do it here). */
950 if (h
->type
== STT_FUNC
951 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
954 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) == 0
955 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_REF_DYNAMIC
) == 0)
956 || (info
->shared
&& h
->plt
.refcount
<= 0))
958 /* This case can occur if we saw a PLT32 reloc in an input
959 file, but the symbol was never referred to by a dynamic
960 object, or if all references were garbage collected. In
961 such a case, we don't actually need to build a procedure
962 linkage table, and we can just do a PC32 reloc instead. */
963 h
->plt
.offset
= (bfd_vma
) -1;
964 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
968 /* Make sure this symbol is output as a dynamic symbol. */
969 if (h
->dynindx
== -1)
971 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
975 s
= bfd_get_section_by_name (dynobj
, ".plt");
976 BFD_ASSERT (s
!= NULL
);
978 /* The first entry in .plt is reserved. */
979 if (s
->_raw_size
== 0)
980 s
->_raw_size
= PLT_FIRST_ENTRY_SIZE
;
982 /* If this symbol is not defined in a regular file, and we are
983 not generating a shared library, then set the symbol to this
984 location in the .plt. This is required to make function
985 pointers compare as equal between the normal executable and
986 the shared library. */
988 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
990 h
->root
.u
.def
.section
= s
;
991 h
->root
.u
.def
.value
= s
->_raw_size
;
994 h
->plt
.offset
= s
->_raw_size
;
996 /* Make room for this entry. */
997 s
->_raw_size
+= PLT_ENTRY_SIZE
;
999 /* We also need to make an entry in the .got.plt section, which
1000 will be placed in the .got section by the linker script. */
1001 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
1002 BFD_ASSERT (s
!= NULL
);
1003 s
->_raw_size
+= GOT_ENTRY_SIZE
;
1005 /* We also need to make an entry in the .rela.plt section. */
1006 s
= bfd_get_section_by_name (dynobj
, ".rela.plt");
1007 BFD_ASSERT (s
!= NULL
);
1008 s
->_raw_size
+= sizeof (Elf32_External_Rela
);
1013 /* If this is a weak symbol, and there is a real definition, the
1014 processor independent code will have arranged for us to see the
1015 real definition first, and we can just use the same value. */
1016 if (h
->weakdef
!= NULL
)
1018 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
1019 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
1020 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
1021 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
1025 /* This is a reference to a symbol defined by a dynamic object which
1026 is not a function. */
1028 /* If we are creating a shared library, we must presume that the
1029 only references to the symbol are via the global offset table.
1030 For such cases we need not do anything here; the relocations will
1031 be handled correctly by relocate_section. */
1035 /* If there are no references to this symbol that do not use the
1036 GOT, we don't need to generate a copy reloc. */
1037 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
1040 /* We must allocate the symbol in our .dynbss section, which will
1041 become part of the .bss section of the executable. There will be
1042 an entry for this symbol in the .dynsym section. The dynamic
1043 object will contain position independent code, so all references
1044 from the dynamic object to this symbol will go through the global
1045 offset table. The dynamic linker will use the .dynsym entry to
1046 determine the address it must put in the global offset table, so
1047 both the dynamic object and the regular object will refer to the
1048 same memory location for the variable. */
1050 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
1051 BFD_ASSERT (s
!= NULL
);
1053 /* We must generate a R_390_COPY reloc to tell the dynamic linker
1054 to copy the initial value out of the dynamic object and into the
1055 runtime process image. We need to remember the offset into the
1056 .rel.bss section we are going to use. */
1057 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1061 srel
= bfd_get_section_by_name (dynobj
, ".rela.bss");
1062 BFD_ASSERT (srel
!= NULL
);
1063 srel
->_raw_size
+= sizeof (Elf32_External_Rela
);
1064 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
1067 /* We need to figure out the alignment required for this symbol. I
1068 have no idea how ELF linkers handle this. */
1069 power_of_two
= bfd_log2 (h
->size
);
1070 if (power_of_two
> 3)
1073 /* Apply the required alignment. */
1074 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
1075 (bfd_size_type
) (1 << power_of_two
));
1076 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
1078 if (! bfd_set_section_alignment (dynobj
, s
, power_of_two
))
1082 /* Define the symbol as being at this point in the section. */
1083 h
->root
.u
.def
.section
= s
;
1084 h
->root
.u
.def
.value
= s
->_raw_size
;
1086 /* Increment the section size to make room for the symbol. */
1087 s
->_raw_size
+= h
->size
;
1092 /* Set the sizes of the dynamic sections. */
1095 elf_s390_size_dynamic_sections (output_bfd
, info
)
1096 bfd
*output_bfd ATTRIBUTE_UNUSED
;
1097 struct bfd_link_info
*info
;
1104 dynobj
= elf_hash_table (info
)->dynobj
;
1105 BFD_ASSERT (dynobj
!= NULL
);
1107 if (elf_hash_table (info
)->dynamic_sections_created
)
1109 /* Set the contents of the .interp section to the interpreter. */
1112 s
= bfd_get_section_by_name (dynobj
, ".interp");
1113 BFD_ASSERT (s
!= NULL
);
1114 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1115 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1120 /* We may have created entries in the .rela.got section.
1121 However, if we are not creating the dynamic sections, we will
1122 not actually use these entries. Reset the size of .rela.got,
1123 which will cause it to get stripped from the output file
1125 s
= bfd_get_section_by_name (dynobj
, ".rela.got");
1130 /* If this is a -Bsymbolic shared link, then we need to discard all
1131 PC relative relocs against symbols defined in a regular object.
1132 We allocated space for them in the check_relocs routine, but we
1133 will not fill them in in the relocate_section routine. */
1135 elf_s390_link_hash_traverse (elf_s390_hash_table (info
),
1136 elf_s390_discard_copies
,
1139 /* The check_relocs and adjust_dynamic_symbol entry points have
1140 determined the sizes of the various dynamic sections. Allocate
1144 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1149 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1152 /* It's OK to base decisions on the section name, because none
1153 of the dynobj section names depend upon the input files. */
1154 name
= bfd_get_section_name (dynobj
, s
);
1158 if (strcmp (name
, ".plt") == 0)
1160 if (s
->_raw_size
== 0)
1162 /* Strip this section if we don't need it; see the
1168 /* Remember whether there is a PLT. */
1172 else if (strncmp (name
, ".rela", 5) == 0)
1174 if (s
->_raw_size
== 0)
1176 /* If we don't need this section, strip it from the
1177 output file. This is to handle .rela.bss and
1178 .rel.plt. We must create it in
1179 create_dynamic_sections, because it must be created
1180 before the linker maps input sections to output
1181 sections. The linker does that before
1182 adjust_dynamic_symbol is called, and it is that
1183 function which decides whether anything needs to go
1184 into these sections. */
1189 /* Remember whether there are any reloc sections other
1191 if (strcmp (name
, ".rela.plt") != 0)
1194 /* We use the reloc_count field as a counter if we need
1195 to copy relocs into the output file. */
1199 else if (strncmp (name
, ".got", 4) != 0)
1201 /* It's not one of our sections, so don't allocate space. */
1207 _bfd_strip_section_from_output (info
, s
);
1211 /* Allocate memory for the section contents. */
1212 s
->contents
= (bfd_byte
*) bfd_alloc (dynobj
, s
->_raw_size
);
1213 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1217 if (elf_hash_table (info
)->dynamic_sections_created
)
1219 /* Add some entries to the .dynamic section. We fill in the
1220 values later, in elf_s390_finish_dynamic_sections, but we
1221 must add the entries now so that we get the correct size for
1222 the .dynamic section. The DT_DEBUG entry is filled in by the
1223 dynamic linker and used by the debugger. */
1224 #define add_dynamic_entry(TAG, VAL) \
1225 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
1229 if (!add_dynamic_entry (DT_DEBUG
, 0))
1235 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1236 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1237 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1238 || !add_dynamic_entry (DT_JMPREL
, 0))
1244 if (!add_dynamic_entry (DT_RELA
, 0)
1245 || !add_dynamic_entry (DT_RELASZ
, 0)
1246 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
1250 if ((info
->flags
& DF_TEXTREL
) != 0)
1252 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1254 info
->flags
|= DF_TEXTREL
;
1257 #undef add_dynamic_entry
1262 /* This function is called via elf_s390_link_hash_traverse if we are
1263 creating a shared object with -Bsymbolic. It discards the space
1264 allocated to copy PC relative relocs against symbols which are
1265 defined in regular objects. We allocated space for them in the
1266 check_relocs routine, but we won't fill them in in the
1267 relocate_section routine. */
1271 elf_s390_discard_copies (h
, inf
)
1272 struct elf_s390_link_hash_entry
*h
;
1275 struct elf_s390_pcrel_relocs_copied
*s
;
1276 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
1278 /* If a symbol has been forced local or we have found a regular
1279 definition for the symbolic link case, then we won't be needing
1281 if ((h
->root
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1282 && ((h
->root
.elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0
1285 for (s
= h
->pcrel_relocs_copied
; s
!= NULL
; s
= s
->next
)
1286 s
->section
->_raw_size
-= s
->count
* sizeof (Elf32_External_Rela
);
1290 /* Relocate a 390 ELF section. */
1293 elf_s390_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
1294 contents
, relocs
, local_syms
, local_sections
)
1296 struct bfd_link_info
*info
;
1298 asection
*input_section
;
1300 Elf_Internal_Rela
*relocs
;
1301 Elf_Internal_Sym
*local_syms
;
1302 asection
**local_sections
;
1305 Elf_Internal_Shdr
*symtab_hdr
;
1306 struct elf_link_hash_entry
**sym_hashes
;
1307 bfd_vma
*local_got_offsets
;
1311 Elf_Internal_Rela
*rel
;
1312 Elf_Internal_Rela
*relend
;
1314 dynobj
= elf_hash_table (info
)->dynobj
;
1315 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1316 sym_hashes
= elf_sym_hashes (input_bfd
);
1317 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1324 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1325 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1329 relend
= relocs
+ input_section
->reloc_count
;
1330 for (; rel
< relend
; rel
++)
1333 reloc_howto_type
*howto
;
1334 unsigned long r_symndx
;
1335 struct elf_link_hash_entry
*h
;
1336 Elf_Internal_Sym
*sym
;
1339 bfd_reloc_status_type r
;
1341 r_type
= ELF32_R_TYPE (rel
->r_info
);
1342 if (r_type
== (int) R_390_GNU_VTINHERIT
1343 || r_type
== (int) R_390_GNU_VTENTRY
)
1345 if (r_type
< 0 || r_type
>= (int) R_390_max
)
1347 bfd_set_error (bfd_error_bad_value
);
1350 howto
= elf_howto_table
+ r_type
;
1352 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1354 if (info
->relocateable
)
1356 /* This is a relocateable link. We don't have to change
1357 anything, unless the reloc is against a section symbol,
1358 in which case we have to adjust according to where the
1359 section symbol winds up in the output section. */
1360 if (r_symndx
< symtab_hdr
->sh_info
)
1362 sym
= local_syms
+ r_symndx
;
1363 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1365 sec
= local_sections
[r_symndx
];
1366 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
1373 /* This is a final link. */
1377 if (r_symndx
< symtab_hdr
->sh_info
)
1379 sym
= local_syms
+ r_symndx
;
1380 sec
= local_sections
[r_symndx
];
1381 relocation
= (sec
->output_section
->vma
1382 + sec
->output_offset
1387 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1388 while (h
->root
.type
== bfd_link_hash_indirect
1389 || h
->root
.type
== bfd_link_hash_warning
)
1390 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1391 if (h
->root
.type
== bfd_link_hash_defined
1392 || h
->root
.type
== bfd_link_hash_defweak
)
1394 sec
= h
->root
.u
.def
.section
;
1395 if (r_type
== R_390_GOTPC
1396 || ((r_type
== R_390_PLT16DBL
||
1397 r_type
== R_390_PLT32
)
1399 && h
->plt
.offset
!= (bfd_vma
) -1)
1400 || ((r_type
== R_390_GOT12
||
1401 r_type
== R_390_GOT16
||
1402 r_type
== R_390_GOT32
)
1403 && elf_hash_table (info
)->dynamic_sections_created
1405 || (! info
->symbolic
&& h
->dynindx
!= -1)
1406 || (h
->elf_link_hash_flags
1407 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
1409 && ((! info
->symbolic
&& h
->dynindx
!= -1)
1410 || (h
->elf_link_hash_flags
1411 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
1412 && ( r_type
== R_390_8
||
1413 r_type
== R_390_16
||
1414 r_type
== R_390_32
||
1415 r_type
== R_390_PC16
||
1416 r_type
== R_390_PC16DBL
||
1417 r_type
== R_390_PC32
)
1418 && ((input_section
->flags
& SEC_ALLOC
) != 0
1419 /* DWARF will emit R_386_32 relocations in its
1420 sections against symbols defined externally
1421 in shared libraries. We can't do anything
1423 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
1424 && (h
->elf_link_hash_flags
1425 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0))))
1427 /* In these cases, we don't need the relocation
1428 value. We check specially because in some
1429 obscure cases sec->output_section will be NULL. */
1432 else if (sec
->output_section
== NULL
)
1434 (*_bfd_error_handler
)
1435 (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1436 bfd_get_filename (input_bfd
), h
->root
.root
.string
,
1437 bfd_get_section_name (input_bfd
, input_section
));
1441 relocation
= (h
->root
.u
.def
.value
1442 + sec
->output_section
->vma
1443 + sec
->output_offset
);
1445 else if (h
->root
.type
== bfd_link_hash_undefweak
)
1447 else if (info
->shared
1448 && (!info
->symbolic
|| info
->allow_shlib_undefined
)
1449 && !info
->no_undefined
1450 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
1454 if (! ((*info
->callbacks
->undefined_symbol
)
1455 (info
, h
->root
.root
.string
, input_bfd
,
1456 input_section
, rel
->r_offset
,
1457 (!info
->shared
|| info
->no_undefined
1458 || ELF_ST_VISIBILITY (h
->other
)))))
1469 /* Relocation is to the entry for this symbol in the global
1471 BFD_ASSERT (sgot
!= NULL
);
1477 off
= h
->got
.offset
;
1478 BFD_ASSERT (off
!= (bfd_vma
) -1);
1480 if (! elf_hash_table (info
)->dynamic_sections_created
1482 && (info
->symbolic
|| h
->dynindx
== -1)
1483 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1485 /* This is actually a static link, or it is a
1486 -Bsymbolic link and the symbol is defined
1487 locally, or the symbol was forced to be local
1488 because of a version file. We must initialize
1489 this entry in the global offset table. Since the
1490 offset must always be a multiple of 2, we use the
1491 least significant bit to record whether we have
1492 initialized it already.
1494 When doing a dynamic link, we create a .rel.got
1495 relocation entry to initialize the value. This
1496 is done in the finish_dynamic_symbol routine. */
1501 bfd_put_32 (output_bfd
, relocation
,
1502 sgot
->contents
+ off
);
1506 relocation
= sgot
->output_offset
+ off
;
1512 BFD_ASSERT (local_got_offsets
!= NULL
1513 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1515 off
= local_got_offsets
[r_symndx
];
1517 /* The offset must always be a multiple of 4. We use
1518 the least significant bit to record whether we have
1519 already generated the necessary reloc. */
1524 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
1529 Elf_Internal_Rela outrel
;
1531 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
1532 BFD_ASSERT (srelgot
!= NULL
);
1534 outrel
.r_offset
= (sgot
->output_section
->vma
1535 + sgot
->output_offset
1537 outrel
.r_info
= ELF32_R_INFO (0, R_390_RELATIVE
);
1538 outrel
.r_addend
= relocation
;
1539 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
1540 (((Elf32_External_Rela
*)
1542 + srelgot
->reloc_count
));
1543 ++srelgot
->reloc_count
;
1546 local_got_offsets
[r_symndx
] |= 1;
1549 relocation
= sgot
->output_offset
+ off
;
1556 /* Relocation is relative to the start of the global offset
1561 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1562 BFD_ASSERT (sgot
!= NULL
);
1565 /* Note that sgot->output_offset is not involved in this
1566 calculation. We always want the start of .got. If we
1567 defined _GLOBAL_OFFSET_TABLE in a different way, as is
1568 permitted by the ABI, we might have to change this
1570 relocation
-= sgot
->output_section
->vma
;
1575 /* Use global offset table as symbol value. */
1579 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1580 BFD_ASSERT (sgot
!= NULL
);
1583 relocation
= sgot
->output_section
->vma
;
1587 case R_390_PLT16DBL
:
1589 /* Relocation is to the entry for this symbol in the
1590 procedure linkage table. */
1592 /* Resolve a PLT32 reloc against a local symbol directly,
1593 without using the procedure linkage table. */
1597 if (h
->plt
.offset
== (bfd_vma
) -1 || splt
== NULL
)
1599 /* We didn't make a PLT entry for this symbol. This
1600 happens when statically linking PIC code, or when
1601 using -Bsymbolic. */
1605 relocation
= (splt
->output_section
->vma
1606 + splt
->output_offset
1618 && (input_section
->flags
& SEC_ALLOC
) != 0
1619 && ((r_type
!= R_390_PC16
&&
1620 r_type
!= R_390_PC16DBL
&&
1621 r_type
!= R_390_PC32
)
1624 && (! info
->symbolic
1625 || (h
->elf_link_hash_flags
1626 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1628 Elf_Internal_Rela outrel
;
1629 boolean skip
, relocate
;
1631 /* When generating a shared object, these relocations
1632 are copied into the output file to be resolved at run
1639 name
= (bfd_elf_string_from_elf_section
1641 elf_elfheader (input_bfd
)->e_shstrndx
,
1642 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1646 BFD_ASSERT (strncmp (name
, ".rela", 5) == 0
1647 && strcmp (bfd_get_section_name (input_bfd
,
1651 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1652 BFD_ASSERT (sreloc
!= NULL
);
1657 if (elf_section_data (input_section
)->stab_info
== NULL
)
1658 outrel
.r_offset
= rel
->r_offset
;
1663 off
= (_bfd_stab_section_offset
1664 (output_bfd
, &elf_hash_table (info
)->stab_info
,
1666 &elf_section_data (input_section
)->stab_info
,
1668 if (off
== (bfd_vma
) -1)
1670 outrel
.r_offset
= off
;
1673 outrel
.r_offset
+= (input_section
->output_section
->vma
1674 + input_section
->output_offset
);
1678 memset (&outrel
, 0, sizeof outrel
);
1681 else if (r_type
== R_390_PC16
||
1682 r_type
== R_390_PC16DBL
||
1683 r_type
== R_390_PC32
)
1685 BFD_ASSERT (h
!= NULL
&& h
->dynindx
!= -1);
1687 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
1688 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1692 /* h->dynindx may be -1 if this symbol was marked to
1695 || ((info
->symbolic
|| h
->dynindx
== -1)
1696 && (h
->elf_link_hash_flags
1697 & ELF_LINK_HASH_DEF_REGULAR
) != 0))
1700 outrel
.r_info
= ELF32_R_INFO (0, R_390_RELATIVE
);
1701 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1705 BFD_ASSERT (h
->dynindx
!= -1);
1707 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_390_32
);
1708 outrel
.r_addend
= relocation
+ rel
->r_addend
;
1712 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
1713 (((Elf32_External_Rela
*)
1715 + sreloc
->reloc_count
));
1716 ++sreloc
->reloc_count
;
1718 /* If this reloc is against an external symbol, we do
1719 not want to fiddle with the addend. Otherwise, we
1720 need to include the symbol value so that it becomes
1721 an addend for the dynamic reloc. */
1732 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1733 contents
, rel
->r_offset
,
1734 relocation
, rel
->r_addend
);
1736 if (r
!= bfd_reloc_ok
)
1741 case bfd_reloc_outofrange
:
1743 case bfd_reloc_overflow
:
1748 name
= h
->root
.root
.string
;
1751 name
= bfd_elf_string_from_elf_section (input_bfd
,
1752 symtab_hdr
->sh_link
,
1757 name
= bfd_section_name (input_bfd
, sec
);
1759 if (! ((*info
->callbacks
->reloc_overflow
)
1760 (info
, name
, howto
->name
, (bfd_vma
) 0,
1761 input_bfd
, input_section
, rel
->r_offset
)))
1772 /* Finish up dynamic symbol handling. We set the contents of various
1773 dynamic sections here. */
1776 elf_s390_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
1778 struct bfd_link_info
*info
;
1779 struct elf_link_hash_entry
*h
;
1780 Elf_Internal_Sym
*sym
;
1784 dynobj
= elf_hash_table (info
)->dynobj
;
1786 if (h
->plt
.offset
!= (bfd_vma
) -1)
1790 Elf_Internal_Rela rela
;
1791 bfd_vma relative_offset
;
1796 /* This symbol has an entry in the procedure linkage table. Set
1799 BFD_ASSERT (h
->dynindx
!= -1);
1801 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1802 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
1803 srela
= bfd_get_section_by_name (dynobj
, ".rela.plt");
1804 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srela
!= NULL
);
1807 Current offset - size first entry / entry size. */
1808 plt_index
= (h
->plt
.offset
- PLT_FIRST_ENTRY_SIZE
) / PLT_ENTRY_SIZE
;
1810 /* Offset in GOT is PLT index plus GOT headers(3) times 4,
1812 got_offset
= (plt_index
+ 3) * GOT_ENTRY_SIZE
;
1814 /* S390 uses halfwords for relative branch calc! */
1815 relative_offset
= - ((PLT_FIRST_ENTRY_SIZE
+
1816 (PLT_ENTRY_SIZE
* plt_index
) + 18) / 2);
1817 /* If offset is > 32768, branch to a previous branch
1818 390 can only handle +-64 K jumps. */
1819 if ( -32768 > (int) relative_offset
)
1821 -(unsigned) (((65536 / PLT_ENTRY_SIZE
- 1) * PLT_ENTRY_SIZE
) / 2);
1823 /* Fill in the entry in the procedure linkage table. */
1826 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD0
,
1827 splt
->contents
+ h
->plt
.offset
);
1828 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD1
,
1829 splt
->contents
+ h
->plt
.offset
+ 4);
1830 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD2
,
1831 splt
->contents
+ h
->plt
.offset
+ 8);
1832 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD3
,
1833 splt
->contents
+ h
->plt
.offset
+ 12);
1834 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_ENTRY_WORD4
,
1835 splt
->contents
+ h
->plt
.offset
+ 16);
1836 bfd_put_32 (output_bfd
, (bfd_vma
) 0 + (relative_offset
<< 16),
1837 splt
->contents
+ h
->plt
.offset
+ 20);
1838 bfd_put_32 (output_bfd
,
1839 (sgot
->output_section
->vma
1840 + sgot
->output_offset
1842 splt
->contents
+ h
->plt
.offset
+ 24);
1844 else if (got_offset
< 4096)
1846 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC12_ENTRY_WORD0
+ got_offset
,
1847 splt
->contents
+ h
->plt
.offset
);
1848 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC12_ENTRY_WORD1
,
1849 splt
->contents
+ h
->plt
.offset
+ 4);
1850 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC12_ENTRY_WORD2
,
1851 splt
->contents
+ h
->plt
.offset
+ 8);
1852 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC12_ENTRY_WORD3
,
1853 splt
->contents
+ h
->plt
.offset
+ 12);
1854 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC12_ENTRY_WORD4
,
1855 splt
->contents
+ h
->plt
.offset
+ 16);
1856 bfd_put_32 (output_bfd
, (bfd_vma
) 0 + (relative_offset
<< 16),
1857 splt
->contents
+ h
->plt
.offset
+ 20);
1858 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
1859 splt
->contents
+ h
->plt
.offset
+ 24);
1861 else if (got_offset
< 32768)
1863 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC16_ENTRY_WORD0
+ got_offset
,
1864 splt
->contents
+ h
->plt
.offset
);
1865 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC16_ENTRY_WORD1
,
1866 splt
->contents
+ h
->plt
.offset
+ 4);
1867 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC16_ENTRY_WORD2
,
1868 splt
->contents
+ h
->plt
.offset
+ 8);
1869 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC16_ENTRY_WORD3
,
1870 splt
->contents
+ h
->plt
.offset
+ 12);
1871 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC16_ENTRY_WORD4
,
1872 splt
->contents
+ h
->plt
.offset
+ 16);
1873 bfd_put_32 (output_bfd
, (bfd_vma
) 0 + (relative_offset
<< 16),
1874 splt
->contents
+ h
->plt
.offset
+ 20);
1875 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
1876 splt
->contents
+ h
->plt
.offset
+ 24);
1880 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_ENTRY_WORD0
,
1881 splt
->contents
+ h
->plt
.offset
);
1882 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_ENTRY_WORD1
,
1883 splt
->contents
+ h
->plt
.offset
+ 4);
1884 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_ENTRY_WORD2
,
1885 splt
->contents
+ h
->plt
.offset
+ 8);
1886 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_ENTRY_WORD3
,
1887 splt
->contents
+ h
->plt
.offset
+ 12);
1888 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_ENTRY_WORD4
,
1889 splt
->contents
+ h
->plt
.offset
+ 16);
1890 bfd_put_32 (output_bfd
, (bfd_vma
) 0 + (relative_offset
<< 16),
1891 splt
->contents
+ h
->plt
.offset
+ 20);
1892 bfd_put_32 (output_bfd
, got_offset
,
1893 splt
->contents
+ h
->plt
.offset
+ 24);
1895 /* Insert offset into reloc. table here. */
1896 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rela
),
1897 splt
->contents
+ h
->plt
.offset
+ 28);
1898 /* Fill in the entry in the .rela.plt section. */
1899 rela
.r_offset
= (sgot
->output_section
->vma
1900 + sgot
->output_offset
1902 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_390_JMP_SLOT
);
1904 bfd_elf32_swap_reloca_out (output_bfd
, &rela
,
1905 ((Elf32_External_Rela
*) srela
->contents
1908 /* Fill in the entry in the global offset table.
1909 Points to instruction after GOT offset. */
1910 bfd_put_32 (output_bfd
,
1911 (splt
->output_section
->vma
1912 + splt
->output_offset
1915 sgot
->contents
+ got_offset
);
1918 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
1920 /* Mark the symbol as undefined, rather than as defined in
1921 the .plt section. Leave the value alone. */
1922 sym
->st_shndx
= SHN_UNDEF
;
1926 if (h
->got
.offset
!= (bfd_vma
) -1)
1930 Elf_Internal_Rela rela
;
1932 /* This symbol has an entry in the global offset table. Set it
1935 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1936 srela
= bfd_get_section_by_name (dynobj
, ".rela.got");
1937 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
1939 rela
.r_offset
= (sgot
->output_section
->vma
1940 + sgot
->output_offset
1941 + (h
->got
.offset
&~ (bfd_vma
) 1));
1943 /* If this is a static link, or it is a -Bsymbolic link and the
1944 symbol is defined locally or was forced to be local because
1945 of a version file, we just want to emit a RELATIVE reloc.
1946 The entry in the global offset table will already have been
1947 initialized in the relocate_section function. */
1948 if (! elf_hash_table (info
)->dynamic_sections_created
1950 && (info
->symbolic
|| h
->dynindx
== -1)
1951 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)))
1953 rela
.r_info
= ELF32_R_INFO (0, R_390_RELATIVE
);
1954 rela
.r_addend
= (h
->root
.u
.def
.value
1955 + h
->root
.u
.def
.section
->output_section
->vma
1956 + h
->root
.u
.def
.section
->output_offset
);
1960 BFD_ASSERT((h
->got
.offset
& 1) == 0);
1961 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
1962 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_390_GLOB_DAT
);
1966 bfd_elf32_swap_reloca_out (output_bfd
, &rela
,
1967 ((Elf32_External_Rela
*) srela
->contents
1968 + srela
->reloc_count
));
1969 ++srela
->reloc_count
;
1972 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
1975 Elf_Internal_Rela rela
;
1977 /* This symbols needs a copy reloc. Set it up. */
1979 BFD_ASSERT (h
->dynindx
!= -1
1980 && (h
->root
.type
== bfd_link_hash_defined
1981 || h
->root
.type
== bfd_link_hash_defweak
));
1984 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
1986 BFD_ASSERT (s
!= NULL
);
1988 rela
.r_offset
= (h
->root
.u
.def
.value
1989 + h
->root
.u
.def
.section
->output_section
->vma
1990 + h
->root
.u
.def
.section
->output_offset
);
1991 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_390_COPY
);
1993 bfd_elf32_swap_reloca_out (output_bfd
, &rela
,
1994 ((Elf32_External_Rela
*) s
->contents
1999 /* Mark some specially defined symbols as absolute. */
2000 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2001 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
2002 || strcmp (h
->root
.root
.string
, "_PROCEDURE_LINKAGE_TABLE_") == 0)
2003 sym
->st_shndx
= SHN_ABS
;
2008 /* Finish up the dynamic sections. */
2011 elf_s390_finish_dynamic_sections (output_bfd
, info
)
2013 struct bfd_link_info
*info
;
2019 dynobj
= elf_hash_table (info
)->dynobj
;
2021 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
2022 BFD_ASSERT (sgot
!= NULL
);
2023 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2025 if (elf_hash_table (info
)->dynamic_sections_created
)
2028 Elf32_External_Dyn
*dyncon
, *dynconend
;
2030 BFD_ASSERT (sdyn
!= NULL
);
2032 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2033 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
2034 for (; dyncon
< dynconend
; dyncon
++)
2036 Elf_Internal_Dyn dyn
;
2040 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2053 s
= bfd_get_section_by_name(output_bfd
, name
);
2054 BFD_ASSERT (s
!= NULL
);
2055 dyn
.d_un
.d_ptr
= s
->vma
;
2056 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2060 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
2061 BFD_ASSERT (s
!= NULL
);
2062 if (s
->_cooked_size
!= 0)
2063 dyn
.d_un
.d_val
= s
->_cooked_size
;
2065 dyn
.d_un
.d_val
= s
->_raw_size
;
2066 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2071 /* Fill in the special first entry in the procedure linkage table. */
2072 splt
= bfd_get_section_by_name (dynobj
, ".plt");
2073 if (splt
&& splt
->_raw_size
> 0)
2075 memset (splt
->contents
, 0, PLT_FIRST_ENTRY_SIZE
);
2078 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_FIRST_ENTRY_WORD0
,
2080 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_FIRST_ENTRY_WORD1
,
2081 splt
->contents
+ 4 );
2082 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_FIRST_ENTRY_WORD2
,
2083 splt
->contents
+ 8 );
2084 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_FIRST_ENTRY_WORD3
,
2085 splt
->contents
+ 12 );
2086 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_PIC_FIRST_ENTRY_WORD4
,
2087 splt
->contents
+ 16 );
2091 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD0
,
2093 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD1
,
2094 splt
->contents
+ 4 );
2095 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD2
,
2096 splt
->contents
+ 8 );
2097 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD3
,
2098 splt
->contents
+ 12 );
2099 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD4
,
2100 splt
->contents
+ 16 );
2101 bfd_put_32 (output_bfd
, (bfd_vma
) PLT_FIRST_ENTRY_WORD5
,
2102 splt
->contents
+ 20 );
2103 bfd_put_32 (output_bfd
,
2104 sgot
->output_section
->vma
+ sgot
->output_offset
,
2105 splt
->contents
+ 24);
2107 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
2112 /* Set the first entry in the global offset table to the address of
2113 the dynamic section. */
2114 if (sgot
->_raw_size
> 0)
2117 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
2119 bfd_put_32 (output_bfd
,
2120 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2123 /* One entry for shared object struct ptr. */
2124 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
2125 /* One entry for _dl_runtime_resolve. */
2126 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
2129 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
2135 elf_s390_object_p (abfd
)
2138 return bfd_default_set_arch_mach (abfd
, bfd_arch_s390
, bfd_mach_s390_esa
);
2141 static enum elf_reloc_type_class
2142 elf_s390_reloc_type_class (type
)
2147 case R_390_RELATIVE
:
2148 return reloc_class_relative
;
2149 case R_390_JMP_SLOT
:
2150 return reloc_class_plt
;
2152 return reloc_class_copy
;
2154 return reloc_class_normal
;
2158 #define TARGET_BIG_SYM bfd_elf32_s390_vec
2159 #define TARGET_BIG_NAME "elf32-s390"
2160 #define ELF_ARCH bfd_arch_s390
2161 #define ELF_MACHINE_CODE EM_S390
2162 #define ELF_MACHINE_ALT1 EM_S390_OLD
2163 #define ELF_MAXPAGESIZE 0x1000
2165 #define elf_backend_can_gc_sections 1
2166 #define elf_backend_want_got_plt 1
2167 #define elf_backend_plt_readonly 1
2168 #define elf_backend_want_plt_sym 0
2169 #define elf_backend_got_header_size 12
2170 #define elf_backend_plt_header_size PLT_ENTRY_SIZE
2172 #define elf_info_to_howto elf_s390_info_to_howto
2174 #define bfd_elf32_bfd_final_link _bfd_elf32_gc_common_final_link
2175 #define bfd_elf32_bfd_is_local_label_name elf_s390_is_local_label_name
2176 #define bfd_elf32_bfd_link_hash_table_create elf_s390_link_hash_table_create
2177 #define bfd_elf32_bfd_reloc_type_lookup elf_s390_reloc_type_lookup
2179 #define elf_backend_adjust_dynamic_symbol elf_s390_adjust_dynamic_symbol
2180 #define elf_backend_check_relocs elf_s390_check_relocs
2181 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
2182 #define elf_backend_finish_dynamic_sections elf_s390_finish_dynamic_sections
2183 #define elf_backend_finish_dynamic_symbol elf_s390_finish_dynamic_symbol
2184 #define elf_backend_gc_mark_hook elf_s390_gc_mark_hook
2185 #define elf_backend_gc_sweep_hook elf_s390_gc_sweep_hook
2186 #define elf_backend_relocate_section elf_s390_relocate_section
2187 #define elf_backend_size_dynamic_sections elf_s390_size_dynamic_sections
2188 #define elf_backend_reloc_type_class elf_s390_reloc_type_class
2190 #define elf_backend_object_p elf_s390_object_p
2192 #include "elf32-target.h"