1 /* Support for HPPA 64-bit ELF
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
3 Free Software Foundation, Inc.
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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
21 #include "alloca-conf.h"
28 #include "elf64-hppa.h"
31 #define PLT_ENTRY_SIZE 0x10
32 #define DLT_ENTRY_SIZE 0x8
33 #define OPD_ENTRY_SIZE 0x20
35 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/pa20_64/dld.sl"
37 /* The stub is supposed to load the target address and target's DP
38 value out of the PLT, then do an external branch to the target
43 LDD PLTOFF+8(%r27),%r27
45 Note that we must use the LDD with a 14 bit displacement, not the one
46 with a 5 bit displacement. */
47 static char plt_stub
[] = {0x53, 0x61, 0x00, 0x00, 0xe8, 0x20, 0xd0, 0x00,
48 0x53, 0x7b, 0x00, 0x00 };
50 struct elf64_hppa_dyn_hash_entry
52 struct bfd_hash_entry root
;
54 /* Offsets for this symbol in various linker sections. */
60 /* The symbol table entry, if any, that this was derived from. */
61 struct elf_link_hash_entry
*h
;
63 /* The index of the (possibly local) symbol in the input bfd and its
64 associated BFD. Needed so that we can have relocs against local
65 symbols in shared libraries. */
69 /* Dynamic symbols may need to have two different values. One for
70 the dynamic symbol table, one for the normal symbol table.
72 In such cases we store the symbol's real value and section
73 index here so we can restore the real value before we write
74 the normal symbol table. */
78 /* Used to count non-got, non-plt relocations for delayed sizing
79 of relocation sections. */
80 struct elf64_hppa_dyn_reloc_entry
82 /* Next relocation in the chain. */
83 struct elf64_hppa_dyn_reloc_entry
*next
;
85 /* The type of the relocation. */
88 /* The input section of the relocation. */
91 /* The index of the section symbol for the input section of
92 the relocation. Only needed when building shared libraries. */
95 /* The offset within the input section of the relocation. */
98 /* The addend for the relocation. */
103 /* Nonzero if this symbol needs an entry in one of the linker
111 struct elf64_hppa_dyn_hash_table
113 struct bfd_hash_table root
;
116 struct elf64_hppa_link_hash_table
118 struct elf_link_hash_table root
;
120 /* Shortcuts to get to the various linker defined sections. */
122 asection
*dlt_rel_sec
;
124 asection
*plt_rel_sec
;
126 asection
*opd_rel_sec
;
127 asection
*other_rel_sec
;
129 /* Offset of __gp within .plt section. When the PLT gets large we want
130 to slide __gp into the PLT section so that we can continue to use
131 single DP relative instructions to load values out of the PLT. */
134 /* Note this is not strictly correct. We should create a stub section for
135 each input section with calls. The stub section should be placed before
136 the section with the call. */
139 bfd_vma text_segment_base
;
140 bfd_vma data_segment_base
;
142 struct elf64_hppa_dyn_hash_table dyn_hash_table
;
144 /* We build tables to map from an input section back to its
145 symbol index. This is the BFD for which we currently have
147 bfd
*section_syms_bfd
;
149 /* Array of symbol numbers for each input section attached to the
154 #define elf64_hppa_hash_table(p) \
155 ((struct elf64_hppa_link_hash_table *) ((p)->hash))
157 typedef struct bfd_hash_entry
*(*new_hash_entry_func
)
158 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
160 static struct bfd_hash_entry
*elf64_hppa_new_dyn_hash_entry
161 PARAMS ((struct bfd_hash_entry
*entry
, struct bfd_hash_table
*table
,
162 const char *string
));
163 static struct bfd_link_hash_table
*elf64_hppa_hash_table_create
164 PARAMS ((bfd
*abfd
));
165 static struct elf64_hppa_dyn_hash_entry
*elf64_hppa_dyn_hash_lookup
166 PARAMS ((struct elf64_hppa_dyn_hash_table
*table
, const char *string
,
167 bfd_boolean create
, bfd_boolean copy
));
168 static void elf64_hppa_dyn_hash_traverse
169 PARAMS ((struct elf64_hppa_dyn_hash_table
*table
,
170 bfd_boolean (*func
) (struct elf64_hppa_dyn_hash_entry
*, PTR
),
173 static const char *get_dyn_name
174 PARAMS ((bfd
*, struct elf_link_hash_entry
*,
175 const Elf_Internal_Rela
*, char **, size_t *));
177 /* This must follow the definitions of the various derived linker
178 hash tables and shared functions. */
179 #include "elf-hppa.h"
181 static bfd_boolean elf64_hppa_object_p
184 static void elf64_hppa_post_process_headers
185 PARAMS ((bfd
*, struct bfd_link_info
*));
187 static bfd_boolean elf64_hppa_create_dynamic_sections
188 PARAMS ((bfd
*, struct bfd_link_info
*));
190 static bfd_boolean elf64_hppa_adjust_dynamic_symbol
191 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
193 static bfd_boolean elf64_hppa_mark_milli_and_exported_functions
194 PARAMS ((struct elf_link_hash_entry
*, PTR
));
196 static bfd_boolean elf64_hppa_size_dynamic_sections
197 PARAMS ((bfd
*, struct bfd_link_info
*));
199 static bfd_boolean elf64_hppa_link_output_symbol_hook
200 PARAMS ((struct bfd_link_info
*, const char *, Elf_Internal_Sym
*,
201 asection
*, struct elf_link_hash_entry
*));
203 static bfd_boolean elf64_hppa_finish_dynamic_symbol
204 PARAMS ((bfd
*, struct bfd_link_info
*,
205 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
207 static int elf64_hppa_additional_program_headers
210 static bfd_boolean elf64_hppa_modify_segment_map
211 PARAMS ((bfd
*, struct bfd_link_info
*));
213 static enum elf_reloc_type_class elf64_hppa_reloc_type_class
214 PARAMS ((const Elf_Internal_Rela
*));
216 static bfd_boolean elf64_hppa_finish_dynamic_sections
217 PARAMS ((bfd
*, struct bfd_link_info
*));
219 static bfd_boolean elf64_hppa_check_relocs
220 PARAMS ((bfd
*, struct bfd_link_info
*,
221 asection
*, const Elf_Internal_Rela
*));
223 static bfd_boolean elf64_hppa_dynamic_symbol_p
224 PARAMS ((struct elf_link_hash_entry
*, struct bfd_link_info
*));
226 static bfd_boolean elf64_hppa_mark_exported_functions
227 PARAMS ((struct elf_link_hash_entry
*, PTR
));
229 static bfd_boolean elf64_hppa_finalize_opd
230 PARAMS ((struct elf64_hppa_dyn_hash_entry
*, PTR
));
232 static bfd_boolean elf64_hppa_finalize_dlt
233 PARAMS ((struct elf64_hppa_dyn_hash_entry
*, PTR
));
235 static bfd_boolean allocate_global_data_dlt
236 PARAMS ((struct elf64_hppa_dyn_hash_entry
*, PTR
));
238 static bfd_boolean allocate_global_data_plt
239 PARAMS ((struct elf64_hppa_dyn_hash_entry
*, PTR
));
241 static bfd_boolean allocate_global_data_stub
242 PARAMS ((struct elf64_hppa_dyn_hash_entry
*, PTR
));
244 static bfd_boolean allocate_global_data_opd
245 PARAMS ((struct elf64_hppa_dyn_hash_entry
*, PTR
));
247 static bfd_boolean get_reloc_section
248 PARAMS ((bfd
*, struct elf64_hppa_link_hash_table
*, asection
*));
250 static bfd_boolean count_dyn_reloc
251 PARAMS ((bfd
*, struct elf64_hppa_dyn_hash_entry
*,
252 int, asection
*, int, bfd_vma
, bfd_vma
));
254 static bfd_boolean allocate_dynrel_entries
255 PARAMS ((struct elf64_hppa_dyn_hash_entry
*, PTR
));
257 static bfd_boolean elf64_hppa_finalize_dynreloc
258 PARAMS ((struct elf64_hppa_dyn_hash_entry
*, PTR
));
260 static bfd_boolean get_opd
261 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf64_hppa_link_hash_table
*));
263 static bfd_boolean get_plt
264 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf64_hppa_link_hash_table
*));
266 static bfd_boolean get_dlt
267 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf64_hppa_link_hash_table
*));
269 static bfd_boolean get_stub
270 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf64_hppa_link_hash_table
*));
272 static int elf64_hppa_elf_get_symbol_type
273 PARAMS ((Elf_Internal_Sym
*, int));
276 elf64_hppa_dyn_hash_table_init (struct elf64_hppa_dyn_hash_table
*ht
,
277 bfd
*abfd ATTRIBUTE_UNUSED
,
278 new_hash_entry_func
new,
279 unsigned int entsize
)
281 memset (ht
, 0, sizeof (*ht
));
282 return bfd_hash_table_init (&ht
->root
, new, entsize
);
285 static struct bfd_hash_entry
*
286 elf64_hppa_new_dyn_hash_entry (entry
, table
, string
)
287 struct bfd_hash_entry
*entry
;
288 struct bfd_hash_table
*table
;
291 struct elf64_hppa_dyn_hash_entry
*ret
;
292 ret
= (struct elf64_hppa_dyn_hash_entry
*) entry
;
294 /* Allocate the structure if it has not already been allocated by a
297 ret
= bfd_hash_allocate (table
, sizeof (*ret
));
302 /* Call the allocation method of the superclass. */
303 ret
= ((struct elf64_hppa_dyn_hash_entry
*)
304 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
306 /* Initialize our local data. All zeros. */
307 memset (&ret
->dlt_offset
, 0,
308 (sizeof (struct elf64_hppa_dyn_hash_entry
)
309 - offsetof (struct elf64_hppa_dyn_hash_entry
, dlt_offset
)));
314 /* Create the derived linker hash table. The PA64 ELF port uses this
315 derived hash table to keep information specific to the PA ElF
316 linker (without using static variables). */
318 static struct bfd_link_hash_table
*
319 elf64_hppa_hash_table_create (abfd
)
322 struct elf64_hppa_link_hash_table
*ret
;
324 ret
= bfd_zalloc (abfd
, (bfd_size_type
) sizeof (*ret
));
327 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
328 _bfd_elf_link_hash_newfunc
,
329 sizeof (struct elf_link_hash_entry
)))
331 bfd_release (abfd
, ret
);
335 if (!elf64_hppa_dyn_hash_table_init (&ret
->dyn_hash_table
, abfd
,
336 elf64_hppa_new_dyn_hash_entry
,
337 sizeof (struct elf64_hppa_dyn_hash_entry
)))
339 return &ret
->root
.root
;
342 /* Look up an entry in a PA64 ELF linker hash table. */
344 static struct elf64_hppa_dyn_hash_entry
*
345 elf64_hppa_dyn_hash_lookup(table
, string
, create
, copy
)
346 struct elf64_hppa_dyn_hash_table
*table
;
348 bfd_boolean create
, copy
;
350 return ((struct elf64_hppa_dyn_hash_entry
*)
351 bfd_hash_lookup (&table
->root
, string
, create
, copy
));
354 /* Traverse a PA64 ELF linker hash table. */
357 elf64_hppa_dyn_hash_traverse (table
, func
, info
)
358 struct elf64_hppa_dyn_hash_table
*table
;
359 bfd_boolean (*func
) PARAMS ((struct elf64_hppa_dyn_hash_entry
*, PTR
));
364 (bfd_boolean (*) PARAMS ((struct bfd_hash_entry
*, PTR
))) func
,
368 /* Return nonzero if ABFD represents a PA2.0 ELF64 file.
370 Additionally we set the default architecture and machine. */
372 elf64_hppa_object_p (abfd
)
375 Elf_Internal_Ehdr
* i_ehdrp
;
378 i_ehdrp
= elf_elfheader (abfd
);
379 if (strcmp (bfd_get_target (abfd
), "elf64-hppa-linux") == 0)
381 /* GCC on hppa-linux produces binaries with OSABI=Linux,
382 but the kernel produces corefiles with OSABI=SysV. */
383 if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_LINUX
384 && i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_NONE
) /* aka SYSV */
389 /* HPUX produces binaries with OSABI=HPUX,
390 but the kernel produces corefiles with OSABI=SysV. */
391 if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_HPUX
392 && i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_NONE
) /* aka SYSV */
396 flags
= i_ehdrp
->e_flags
;
397 switch (flags
& (EF_PARISC_ARCH
| EF_PARISC_WIDE
))
400 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 10);
402 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 11);
404 if (i_ehdrp
->e_ident
[EI_CLASS
] == ELFCLASS64
)
405 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 25);
407 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 20);
408 case EFA_PARISC_2_0
| EF_PARISC_WIDE
:
409 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 25);
411 /* Don't be fussy. */
415 /* Given section type (hdr->sh_type), return a boolean indicating
416 whether or not the section is an elf64-hppa specific section. */
418 elf64_hppa_section_from_shdr (bfd
*abfd
,
419 Elf_Internal_Shdr
*hdr
,
425 switch (hdr
->sh_type
)
428 if (strcmp (name
, ".PARISC.archext") != 0)
431 case SHT_PARISC_UNWIND
:
432 if (strcmp (name
, ".PARISC.unwind") != 0)
436 case SHT_PARISC_ANNOT
:
441 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
443 newsect
= hdr
->bfd_section
;
448 /* Construct a string for use in the elf64_hppa_dyn_hash_table. The
449 name describes what was once potentially anonymous memory. We
450 allocate memory as necessary, possibly reusing PBUF/PLEN. */
453 get_dyn_name (abfd
, h
, rel
, pbuf
, plen
)
455 struct elf_link_hash_entry
*h
;
456 const Elf_Internal_Rela
*rel
;
460 asection
*sec
= abfd
->sections
;
465 if (h
&& rel
->r_addend
== 0)
466 return h
->root
.root
.string
;
469 nlen
= strlen (h
->root
.root
.string
);
471 nlen
= 8 + 1 + sizeof (rel
->r_info
) * 2 - 8;
472 tlen
= nlen
+ 1 + sizeof (rel
->r_addend
) * 2 + 1;
480 *pbuf
= buf
= malloc (tlen
);
488 memcpy (buf
, h
->root
.root
.string
, nlen
);
490 sprintf_vma (buf
+ nlen
, rel
->r_addend
);
494 nlen
= sprintf (buf
, "%x:%lx",
495 sec
->id
& 0xffffffff,
496 (long) ELF64_R_SYM (rel
->r_info
));
500 sprintf_vma (buf
+ nlen
, rel
->r_addend
);
507 /* SEC is a section containing relocs for an input BFD when linking; return
508 a suitable section for holding relocs in the output BFD for a link. */
511 get_reloc_section (abfd
, hppa_info
, sec
)
513 struct elf64_hppa_link_hash_table
*hppa_info
;
516 const char *srel_name
;
520 srel_name
= (bfd_elf_string_from_elf_section
521 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
522 elf_section_data(sec
)->rel_hdr
.sh_name
));
523 if (srel_name
== NULL
)
526 BFD_ASSERT ((strncmp (srel_name
, ".rela", 5) == 0
527 && strcmp (bfd_get_section_name (abfd
, sec
),
529 || (strncmp (srel_name
, ".rel", 4) == 0
530 && strcmp (bfd_get_section_name (abfd
, sec
),
533 dynobj
= hppa_info
->root
.dynobj
;
535 hppa_info
->root
.dynobj
= dynobj
= abfd
;
537 srel
= bfd_get_section_by_name (dynobj
, srel_name
);
540 srel
= bfd_make_section_with_flags (dynobj
, srel_name
,
548 || !bfd_set_section_alignment (dynobj
, srel
, 3))
552 hppa_info
->other_rel_sec
= srel
;
556 /* Add a new entry to the list of dynamic relocations against DYN_H.
558 We use this to keep a record of all the FPTR relocations against a
559 particular symbol so that we can create FPTR relocations in the
563 count_dyn_reloc (abfd
, dyn_h
, type
, sec
, sec_symndx
, offset
, addend
)
565 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
572 struct elf64_hppa_dyn_reloc_entry
*rent
;
574 rent
= (struct elf64_hppa_dyn_reloc_entry
*)
575 bfd_alloc (abfd
, (bfd_size_type
) sizeof (*rent
));
579 rent
->next
= dyn_h
->reloc_entries
;
582 rent
->sec_symndx
= sec_symndx
;
583 rent
->offset
= offset
;
584 rent
->addend
= addend
;
585 dyn_h
->reloc_entries
= rent
;
590 /* Scan the RELOCS and record the type of dynamic entries that each
591 referenced symbol needs. */
594 elf64_hppa_check_relocs (abfd
, info
, sec
, relocs
)
596 struct bfd_link_info
*info
;
598 const Elf_Internal_Rela
*relocs
;
600 struct elf64_hppa_link_hash_table
*hppa_info
;
601 const Elf_Internal_Rela
*relend
;
602 Elf_Internal_Shdr
*symtab_hdr
;
603 const Elf_Internal_Rela
*rel
;
604 asection
*dlt
, *plt
, *stubs
;
609 if (info
->relocatable
)
612 /* If this is the first dynamic object found in the link, create
613 the special sections required for dynamic linking. */
614 if (! elf_hash_table (info
)->dynamic_sections_created
)
616 if (! _bfd_elf_link_create_dynamic_sections (abfd
, info
))
620 hppa_info
= elf64_hppa_hash_table (info
);
621 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
623 /* If necessary, build a new table holding section symbols indices
626 if (info
->shared
&& hppa_info
->section_syms_bfd
!= abfd
)
629 unsigned int highest_shndx
;
630 Elf_Internal_Sym
*local_syms
= NULL
;
631 Elf_Internal_Sym
*isym
, *isymend
;
634 /* We're done with the old cache of section index to section symbol
635 index information. Free it.
637 ?!? Note we leak the last section_syms array. Presumably we
638 could free it in one of the later routines in this file. */
639 if (hppa_info
->section_syms
)
640 free (hppa_info
->section_syms
);
642 /* Read this BFD's local symbols. */
643 if (symtab_hdr
->sh_info
!= 0)
645 local_syms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
646 if (local_syms
== NULL
)
647 local_syms
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
648 symtab_hdr
->sh_info
, 0,
650 if (local_syms
== NULL
)
654 /* Record the highest section index referenced by the local symbols. */
656 isymend
= local_syms
+ symtab_hdr
->sh_info
;
657 for (isym
= local_syms
; isym
< isymend
; isym
++)
659 if (isym
->st_shndx
> highest_shndx
)
660 highest_shndx
= isym
->st_shndx
;
663 /* Allocate an array to hold the section index to section symbol index
664 mapping. Bump by one since we start counting at zero. */
668 hppa_info
->section_syms
= (int *) bfd_malloc (amt
);
670 /* Now walk the local symbols again. If we find a section symbol,
671 record the index of the symbol into the section_syms array. */
672 for (i
= 0, isym
= local_syms
; isym
< isymend
; i
++, isym
++)
674 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
675 hppa_info
->section_syms
[isym
->st_shndx
] = i
;
678 /* We are finished with the local symbols. */
679 if (local_syms
!= NULL
680 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
682 if (! info
->keep_memory
)
686 /* Cache the symbols for elf_link_input_bfd. */
687 symtab_hdr
->contents
= (unsigned char *) local_syms
;
691 /* Record which BFD we built the section_syms mapping for. */
692 hppa_info
->section_syms_bfd
= abfd
;
695 /* Record the symbol index for this input section. We may need it for
696 relocations when building shared libraries. When not building shared
697 libraries this value is never really used, but assign it to zero to
698 prevent out of bounds memory accesses in other routines. */
701 sec_symndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
703 /* If we did not find a section symbol for this section, then
704 something went terribly wrong above. */
705 if (sec_symndx
== -1)
708 sec_symndx
= hppa_info
->section_syms
[sec_symndx
];
713 dlt
= plt
= stubs
= NULL
;
717 relend
= relocs
+ sec
->reloc_count
;
718 for (rel
= relocs
; rel
< relend
; ++rel
)
729 struct elf_link_hash_entry
*h
= NULL
;
730 unsigned long r_symndx
= ELF64_R_SYM (rel
->r_info
);
731 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
733 const char *addr_name
;
734 bfd_boolean maybe_dynamic
;
735 int dynrel_type
= R_PARISC_NONE
;
736 static reloc_howto_type
*howto
;
738 if (r_symndx
>= symtab_hdr
->sh_info
)
740 /* We're dealing with a global symbol -- find its hash entry
741 and mark it as being referenced. */
742 long indx
= r_symndx
- symtab_hdr
->sh_info
;
743 h
= elf_sym_hashes (abfd
)[indx
];
744 while (h
->root
.type
== bfd_link_hash_indirect
745 || h
->root
.type
== bfd_link_hash_warning
)
746 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
751 /* We can only get preliminary data on whether a symbol is
752 locally or externally defined, as not all of the input files
753 have yet been processed. Do something with what we know, as
754 this may help reduce memory usage and processing time later. */
755 maybe_dynamic
= FALSE
;
756 if (h
&& ((info
->shared
758 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
760 || h
->root
.type
== bfd_link_hash_defweak
))
761 maybe_dynamic
= TRUE
;
763 howto
= elf_hppa_howto_table
+ ELF64_R_TYPE (rel
->r_info
);
767 /* These are simple indirect references to symbols through the
768 DLT. We need to create a DLT entry for any symbols which
769 appears in a DLTIND relocation. */
770 case R_PARISC_DLTIND21L
:
771 case R_PARISC_DLTIND14R
:
772 case R_PARISC_DLTIND14F
:
773 case R_PARISC_DLTIND14WR
:
774 case R_PARISC_DLTIND14DR
:
775 need_entry
= NEED_DLT
;
778 /* ?!? These need a DLT entry. But I have no idea what to do with
779 the "link time TP value. */
780 case R_PARISC_LTOFF_TP21L
:
781 case R_PARISC_LTOFF_TP14R
:
782 case R_PARISC_LTOFF_TP14F
:
783 case R_PARISC_LTOFF_TP64
:
784 case R_PARISC_LTOFF_TP14WR
:
785 case R_PARISC_LTOFF_TP14DR
:
786 case R_PARISC_LTOFF_TP16F
:
787 case R_PARISC_LTOFF_TP16WF
:
788 case R_PARISC_LTOFF_TP16DF
:
789 need_entry
= NEED_DLT
;
792 /* These are function calls. Depending on their precise target we
793 may need to make a stub for them. The stub uses the PLT, so we
794 need to create PLT entries for these symbols too. */
795 case R_PARISC_PCREL12F
:
796 case R_PARISC_PCREL17F
:
797 case R_PARISC_PCREL22F
:
798 case R_PARISC_PCREL32
:
799 case R_PARISC_PCREL64
:
800 case R_PARISC_PCREL21L
:
801 case R_PARISC_PCREL17R
:
802 case R_PARISC_PCREL17C
:
803 case R_PARISC_PCREL14R
:
804 case R_PARISC_PCREL14F
:
805 case R_PARISC_PCREL22C
:
806 case R_PARISC_PCREL14WR
:
807 case R_PARISC_PCREL14DR
:
808 case R_PARISC_PCREL16F
:
809 case R_PARISC_PCREL16WF
:
810 case R_PARISC_PCREL16DF
:
811 need_entry
= (NEED_PLT
| NEED_STUB
);
814 case R_PARISC_PLTOFF21L
:
815 case R_PARISC_PLTOFF14R
:
816 case R_PARISC_PLTOFF14F
:
817 case R_PARISC_PLTOFF14WR
:
818 case R_PARISC_PLTOFF14DR
:
819 case R_PARISC_PLTOFF16F
:
820 case R_PARISC_PLTOFF16WF
:
821 case R_PARISC_PLTOFF16DF
:
822 need_entry
= (NEED_PLT
);
826 if (info
->shared
|| maybe_dynamic
)
827 need_entry
= (NEED_DYNREL
);
828 dynrel_type
= R_PARISC_DIR64
;
831 /* This is an indirect reference through the DLT to get the address
832 of a OPD descriptor. Thus we need to make a DLT entry that points
834 case R_PARISC_LTOFF_FPTR21L
:
835 case R_PARISC_LTOFF_FPTR14R
:
836 case R_PARISC_LTOFF_FPTR14WR
:
837 case R_PARISC_LTOFF_FPTR14DR
:
838 case R_PARISC_LTOFF_FPTR32
:
839 case R_PARISC_LTOFF_FPTR64
:
840 case R_PARISC_LTOFF_FPTR16F
:
841 case R_PARISC_LTOFF_FPTR16WF
:
842 case R_PARISC_LTOFF_FPTR16DF
:
843 if (info
->shared
|| maybe_dynamic
)
844 need_entry
= (NEED_DLT
| NEED_OPD
);
846 need_entry
= (NEED_DLT
| NEED_OPD
);
847 dynrel_type
= R_PARISC_FPTR64
;
850 /* This is a simple OPD entry. */
851 case R_PARISC_FPTR64
:
852 if (info
->shared
|| maybe_dynamic
)
853 need_entry
= (NEED_OPD
| NEED_DYNREL
);
855 need_entry
= (NEED_OPD
);
856 dynrel_type
= R_PARISC_FPTR64
;
859 /* Add more cases as needed. */
865 /* Collect a canonical name for this address. */
866 addr_name
= get_dyn_name (abfd
, h
, rel
, &buf
, &buf_len
);
868 /* Collect the canonical entry data for this address. */
869 dyn_h
= elf64_hppa_dyn_hash_lookup (&hppa_info
->dyn_hash_table
,
870 addr_name
, TRUE
, TRUE
);
873 /* Stash away enough information to be able to find this symbol
874 regardless of whether or not it is local or global. */
877 dyn_h
->sym_indx
= r_symndx
;
879 /* ?!? We may need to do some error checking in here. */
880 /* Create what's needed. */
881 if (need_entry
& NEED_DLT
)
883 if (! hppa_info
->dlt_sec
884 && ! get_dlt (abfd
, info
, hppa_info
))
889 if (need_entry
& NEED_PLT
)
891 if (! hppa_info
->plt_sec
892 && ! get_plt (abfd
, info
, hppa_info
))
897 if (need_entry
& NEED_STUB
)
899 if (! hppa_info
->stub_sec
900 && ! get_stub (abfd
, info
, hppa_info
))
902 dyn_h
->want_stub
= 1;
905 if (need_entry
& NEED_OPD
)
907 if (! hppa_info
->opd_sec
908 && ! get_opd (abfd
, info
, hppa_info
))
913 /* FPTRs are not allocated by the dynamic linker for PA64, though
914 it is possible that will change in the future. */
916 /* This could be a local function that had its address taken, in
917 which case H will be NULL. */
922 /* Add a new dynamic relocation to the chain of dynamic
923 relocations for this symbol. */
924 if ((need_entry
& NEED_DYNREL
) && (sec
->flags
& SEC_ALLOC
))
926 if (! hppa_info
->other_rel_sec
927 && ! get_reloc_section (abfd
, hppa_info
, sec
))
930 if (!count_dyn_reloc (abfd
, dyn_h
, dynrel_type
, sec
,
931 sec_symndx
, rel
->r_offset
, rel
->r_addend
))
934 /* If we are building a shared library and we just recorded
935 a dynamic R_PARISC_FPTR64 relocation, then make sure the
936 section symbol for this section ends up in the dynamic
938 if (info
->shared
&& dynrel_type
== R_PARISC_FPTR64
939 && ! (bfd_elf_link_record_local_dynamic_symbol
940 (info
, abfd
, sec_symndx
)))
955 struct elf64_hppa_allocate_data
957 struct bfd_link_info
*info
;
961 /* Should we do dynamic things to this symbol? */
964 elf64_hppa_dynamic_symbol_p (h
, info
)
965 struct elf_link_hash_entry
*h
;
966 struct bfd_link_info
*info
;
968 /* ??? What, if anything, needs to happen wrt STV_PROTECTED symbols
969 and relocations that retrieve a function descriptor? Assume the
971 if (_bfd_elf_dynamic_symbol_p (h
, info
, 1))
973 /* ??? Why is this here and not elsewhere is_local_label_name. */
974 if (h
->root
.root
.string
[0] == '$' && h
->root
.root
.string
[1] == '$')
983 /* Mark all functions exported by this file so that we can later allocate
984 entries in .opd for them. */
987 elf64_hppa_mark_exported_functions (h
, data
)
988 struct elf_link_hash_entry
*h
;
991 struct bfd_link_info
*info
= (struct bfd_link_info
*)data
;
992 struct elf64_hppa_link_hash_table
*hppa_info
;
994 hppa_info
= elf64_hppa_hash_table (info
);
996 if (h
->root
.type
== bfd_link_hash_warning
)
997 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1000 && (h
->root
.type
== bfd_link_hash_defined
1001 || h
->root
.type
== bfd_link_hash_defweak
)
1002 && h
->root
.u
.def
.section
->output_section
!= NULL
1003 && h
->type
== STT_FUNC
)
1005 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
1007 /* Add this symbol to the PA64 linker hash table. */
1008 dyn_h
= elf64_hppa_dyn_hash_lookup (&hppa_info
->dyn_hash_table
,
1009 h
->root
.root
.string
, TRUE
, TRUE
);
1013 if (! hppa_info
->opd_sec
1014 && ! get_opd (hppa_info
->root
.dynobj
, info
, hppa_info
))
1017 dyn_h
->want_opd
= 1;
1018 /* Put a flag here for output_symbol_hook. */
1019 dyn_h
->st_shndx
= -1;
1026 /* Allocate space for a DLT entry. */
1029 allocate_global_data_dlt (dyn_h
, data
)
1030 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
1033 struct elf64_hppa_allocate_data
*x
= (struct elf64_hppa_allocate_data
*)data
;
1035 if (dyn_h
->want_dlt
)
1037 struct elf_link_hash_entry
*h
= dyn_h
->h
;
1039 if (x
->info
->shared
)
1041 /* Possibly add the symbol to the local dynamic symbol
1042 table since we might need to create a dynamic relocation
1045 || (h
->dynindx
== -1 && h
->type
!= STT_PARISC_MILLI
))
1048 owner
= (h
? h
->root
.u
.def
.section
->owner
: dyn_h
->owner
);
1050 if (! (bfd_elf_link_record_local_dynamic_symbol
1051 (x
->info
, owner
, dyn_h
->sym_indx
)))
1056 dyn_h
->dlt_offset
= x
->ofs
;
1057 x
->ofs
+= DLT_ENTRY_SIZE
;
1062 /* Allocate space for a DLT.PLT entry. */
1065 allocate_global_data_plt (dyn_h
, data
)
1066 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
1069 struct elf64_hppa_allocate_data
*x
= (struct elf64_hppa_allocate_data
*)data
;
1072 && elf64_hppa_dynamic_symbol_p (dyn_h
->h
, x
->info
)
1073 && !((dyn_h
->h
->root
.type
== bfd_link_hash_defined
1074 || dyn_h
->h
->root
.type
== bfd_link_hash_defweak
)
1075 && dyn_h
->h
->root
.u
.def
.section
->output_section
!= NULL
))
1077 dyn_h
->plt_offset
= x
->ofs
;
1078 x
->ofs
+= PLT_ENTRY_SIZE
;
1079 if (dyn_h
->plt_offset
< 0x2000)
1080 elf64_hppa_hash_table (x
->info
)->gp_offset
= dyn_h
->plt_offset
;
1083 dyn_h
->want_plt
= 0;
1088 /* Allocate space for a STUB entry. */
1091 allocate_global_data_stub (dyn_h
, data
)
1092 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
1095 struct elf64_hppa_allocate_data
*x
= (struct elf64_hppa_allocate_data
*)data
;
1097 if (dyn_h
->want_stub
1098 && elf64_hppa_dynamic_symbol_p (dyn_h
->h
, x
->info
)
1099 && !((dyn_h
->h
->root
.type
== bfd_link_hash_defined
1100 || dyn_h
->h
->root
.type
== bfd_link_hash_defweak
)
1101 && dyn_h
->h
->root
.u
.def
.section
->output_section
!= NULL
))
1103 dyn_h
->stub_offset
= x
->ofs
;
1104 x
->ofs
+= sizeof (plt_stub
);
1107 dyn_h
->want_stub
= 0;
1111 /* Allocate space for a FPTR entry. */
1114 allocate_global_data_opd (dyn_h
, data
)
1115 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
1118 struct elf64_hppa_allocate_data
*x
= (struct elf64_hppa_allocate_data
*)data
;
1120 if (dyn_h
->want_opd
)
1122 struct elf_link_hash_entry
*h
= dyn_h
->h
;
1125 while (h
->root
.type
== bfd_link_hash_indirect
1126 || h
->root
.type
== bfd_link_hash_warning
)
1127 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1129 /* We never need an opd entry for a symbol which is not
1130 defined by this output file. */
1131 if (h
&& (h
->root
.type
== bfd_link_hash_undefined
1132 || h
->root
.u
.def
.section
->output_section
== NULL
))
1133 dyn_h
->want_opd
= 0;
1135 /* If we are creating a shared library, took the address of a local
1136 function or might export this function from this object file, then
1137 we have to create an opd descriptor. */
1138 else if (x
->info
->shared
1140 || (h
->dynindx
== -1 && h
->type
!= STT_PARISC_MILLI
)
1141 || (h
->root
.type
== bfd_link_hash_defined
1142 || h
->root
.type
== bfd_link_hash_defweak
))
1144 /* If we are creating a shared library, then we will have to
1145 create a runtime relocation for the symbol to properly
1146 initialize the .opd entry. Make sure the symbol gets
1147 added to the dynamic symbol table. */
1149 && (h
== NULL
|| (h
->dynindx
== -1)))
1152 owner
= (h
? h
->root
.u
.def
.section
->owner
: dyn_h
->owner
);
1154 if (!bfd_elf_link_record_local_dynamic_symbol
1155 (x
->info
, owner
, dyn_h
->sym_indx
))
1159 /* This may not be necessary or desirable anymore now that
1160 we have some support for dealing with section symbols
1161 in dynamic relocs. But name munging does make the result
1162 much easier to debug. ie, the EPLT reloc will reference
1163 a symbol like .foobar, instead of .text + offset. */
1164 if (x
->info
->shared
&& h
)
1167 struct elf_link_hash_entry
*nh
;
1169 new_name
= alloca (strlen (h
->root
.root
.string
) + 2);
1171 strcpy (new_name
+ 1, h
->root
.root
.string
);
1173 nh
= elf_link_hash_lookup (elf_hash_table (x
->info
),
1174 new_name
, TRUE
, TRUE
, TRUE
);
1176 nh
->root
.type
= h
->root
.type
;
1177 nh
->root
.u
.def
.value
= h
->root
.u
.def
.value
;
1178 nh
->root
.u
.def
.section
= h
->root
.u
.def
.section
;
1180 if (! bfd_elf_link_record_dynamic_symbol (x
->info
, nh
))
1184 dyn_h
->opd_offset
= x
->ofs
;
1185 x
->ofs
+= OPD_ENTRY_SIZE
;
1188 /* Otherwise we do not need an opd entry. */
1190 dyn_h
->want_opd
= 0;
1195 /* HP requires the EI_OSABI field to be filled in. The assignment to
1196 EI_ABIVERSION may not be strictly necessary. */
1199 elf64_hppa_post_process_headers (abfd
, link_info
)
1201 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
;
1203 Elf_Internal_Ehdr
* i_ehdrp
;
1205 i_ehdrp
= elf_elfheader (abfd
);
1207 if (strcmp (bfd_get_target (abfd
), "elf64-hppa-linux") == 0)
1209 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_LINUX
;
1213 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_HPUX
;
1214 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 1;
1218 /* Create function descriptor section (.opd). This section is called .opd
1219 because it contains "official procedure descriptors". The "official"
1220 refers to the fact that these descriptors are used when taking the address
1221 of a procedure, thus ensuring a unique address for each procedure. */
1224 get_opd (abfd
, info
, hppa_info
)
1226 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1227 struct elf64_hppa_link_hash_table
*hppa_info
;
1232 opd
= hppa_info
->opd_sec
;
1235 dynobj
= hppa_info
->root
.dynobj
;
1237 hppa_info
->root
.dynobj
= dynobj
= abfd
;
1239 opd
= bfd_make_section_with_flags (dynobj
, ".opd",
1244 | SEC_LINKER_CREATED
));
1246 || !bfd_set_section_alignment (abfd
, opd
, 3))
1252 hppa_info
->opd_sec
= opd
;
1258 /* Create the PLT section. */
1261 get_plt (abfd
, info
, hppa_info
)
1263 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1264 struct elf64_hppa_link_hash_table
*hppa_info
;
1269 plt
= hppa_info
->plt_sec
;
1272 dynobj
= hppa_info
->root
.dynobj
;
1274 hppa_info
->root
.dynobj
= dynobj
= abfd
;
1276 plt
= bfd_make_section_with_flags (dynobj
, ".plt",
1281 | SEC_LINKER_CREATED
));
1283 || !bfd_set_section_alignment (abfd
, plt
, 3))
1289 hppa_info
->plt_sec
= plt
;
1295 /* Create the DLT section. */
1298 get_dlt (abfd
, info
, hppa_info
)
1300 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1301 struct elf64_hppa_link_hash_table
*hppa_info
;
1306 dlt
= hppa_info
->dlt_sec
;
1309 dynobj
= hppa_info
->root
.dynobj
;
1311 hppa_info
->root
.dynobj
= dynobj
= abfd
;
1313 dlt
= bfd_make_section_with_flags (dynobj
, ".dlt",
1318 | SEC_LINKER_CREATED
));
1320 || !bfd_set_section_alignment (abfd
, dlt
, 3))
1326 hppa_info
->dlt_sec
= dlt
;
1332 /* Create the stubs section. */
1335 get_stub (abfd
, info
, hppa_info
)
1337 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1338 struct elf64_hppa_link_hash_table
*hppa_info
;
1343 stub
= hppa_info
->stub_sec
;
1346 dynobj
= hppa_info
->root
.dynobj
;
1348 hppa_info
->root
.dynobj
= dynobj
= abfd
;
1350 stub
= bfd_make_section_with_flags (dynobj
, ".stub",
1351 (SEC_ALLOC
| SEC_LOAD
1355 | SEC_LINKER_CREATED
));
1357 || !bfd_set_section_alignment (abfd
, stub
, 3))
1363 hppa_info
->stub_sec
= stub
;
1369 /* Create sections necessary for dynamic linking. This is only a rough
1370 cut and will likely change as we learn more about the somewhat
1371 unusual dynamic linking scheme HP uses.
1374 Contains code to implement cross-space calls. The first time one
1375 of the stubs is used it will call into the dynamic linker, later
1376 calls will go straight to the target.
1378 The only stub we support right now looks like
1382 ldd OFFSET+8(%dp),%dp
1384 Other stubs may be needed in the future. We may want the remove
1385 the break/nop instruction. It is only used right now to keep the
1386 offset of a .plt entry and a .stub entry in sync.
1389 This is what most people call the .got. HP used a different name.
1393 Relocations for the DLT.
1396 Function pointers as address,gp pairs.
1399 Should contain dynamic IPLT (and EPLT?) relocations.
1405 EPLT relocations for symbols exported from shared libraries. */
1408 elf64_hppa_create_dynamic_sections (abfd
, info
)
1410 struct bfd_link_info
*info
;
1414 if (! get_stub (abfd
, info
, elf64_hppa_hash_table (info
)))
1417 if (! get_dlt (abfd
, info
, elf64_hppa_hash_table (info
)))
1420 if (! get_plt (abfd
, info
, elf64_hppa_hash_table (info
)))
1423 if (! get_opd (abfd
, info
, elf64_hppa_hash_table (info
)))
1426 s
= bfd_make_section_with_flags (abfd
, ".rela.dlt",
1427 (SEC_ALLOC
| SEC_LOAD
1431 | SEC_LINKER_CREATED
));
1433 || !bfd_set_section_alignment (abfd
, s
, 3))
1435 elf64_hppa_hash_table (info
)->dlt_rel_sec
= s
;
1437 s
= bfd_make_section_with_flags (abfd
, ".rela.plt",
1438 (SEC_ALLOC
| SEC_LOAD
1442 | SEC_LINKER_CREATED
));
1444 || !bfd_set_section_alignment (abfd
, s
, 3))
1446 elf64_hppa_hash_table (info
)->plt_rel_sec
= s
;
1448 s
= bfd_make_section_with_flags (abfd
, ".rela.data",
1449 (SEC_ALLOC
| SEC_LOAD
1453 | SEC_LINKER_CREATED
));
1455 || !bfd_set_section_alignment (abfd
, s
, 3))
1457 elf64_hppa_hash_table (info
)->other_rel_sec
= s
;
1459 s
= bfd_make_section_with_flags (abfd
, ".rela.opd",
1460 (SEC_ALLOC
| SEC_LOAD
1464 | SEC_LINKER_CREATED
));
1466 || !bfd_set_section_alignment (abfd
, s
, 3))
1468 elf64_hppa_hash_table (info
)->opd_rel_sec
= s
;
1473 /* Allocate dynamic relocations for those symbols that turned out
1477 allocate_dynrel_entries (dyn_h
, data
)
1478 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
1481 struct elf64_hppa_allocate_data
*x
= (struct elf64_hppa_allocate_data
*)data
;
1482 struct elf64_hppa_link_hash_table
*hppa_info
;
1483 struct elf64_hppa_dyn_reloc_entry
*rent
;
1484 bfd_boolean dynamic_symbol
, shared
;
1486 hppa_info
= elf64_hppa_hash_table (x
->info
);
1487 dynamic_symbol
= elf64_hppa_dynamic_symbol_p (dyn_h
->h
, x
->info
);
1488 shared
= x
->info
->shared
;
1490 /* We may need to allocate relocations for a non-dynamic symbol
1491 when creating a shared library. */
1492 if (!dynamic_symbol
&& !shared
)
1495 /* Take care of the normal data relocations. */
1497 for (rent
= dyn_h
->reloc_entries
; rent
; rent
= rent
->next
)
1499 /* Allocate one iff we are building a shared library, the relocation
1500 isn't a R_PARISC_FPTR64, or we don't want an opd entry. */
1501 if (!shared
&& rent
->type
== R_PARISC_FPTR64
&& dyn_h
->want_opd
)
1504 hppa_info
->other_rel_sec
->size
+= sizeof (Elf64_External_Rela
);
1506 /* Make sure this symbol gets into the dynamic symbol table if it is
1507 not already recorded. ?!? This should not be in the loop since
1508 the symbol need only be added once. */
1510 || (dyn_h
->h
->dynindx
== -1 && dyn_h
->h
->type
!= STT_PARISC_MILLI
))
1511 if (!bfd_elf_link_record_local_dynamic_symbol
1512 (x
->info
, rent
->sec
->owner
, dyn_h
->sym_indx
))
1516 /* Take care of the GOT and PLT relocations. */
1518 if ((dynamic_symbol
|| shared
) && dyn_h
->want_dlt
)
1519 hppa_info
->dlt_rel_sec
->size
+= sizeof (Elf64_External_Rela
);
1521 /* If we are building a shared library, then every symbol that has an
1522 opd entry will need an EPLT relocation to relocate the symbol's address
1523 and __gp value based on the runtime load address. */
1524 if (shared
&& dyn_h
->want_opd
)
1525 hppa_info
->opd_rel_sec
->size
+= sizeof (Elf64_External_Rela
);
1527 if (dyn_h
->want_plt
&& dynamic_symbol
)
1529 bfd_size_type t
= 0;
1531 /* Dynamic symbols get one IPLT relocation. Local symbols in
1532 shared libraries get two REL relocations. Local symbols in
1533 main applications get nothing. */
1535 t
= sizeof (Elf64_External_Rela
);
1537 t
= 2 * sizeof (Elf64_External_Rela
);
1539 hppa_info
->plt_rel_sec
->size
+= t
;
1545 /* Adjust a symbol defined by a dynamic object and referenced by a
1549 elf64_hppa_adjust_dynamic_symbol (info
, h
)
1550 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1551 struct elf_link_hash_entry
*h
;
1553 /* ??? Undefined symbols with PLT entries should be re-defined
1554 to be the PLT entry. */
1556 /* If this is a weak symbol, and there is a real definition, the
1557 processor independent code will have arranged for us to see the
1558 real definition first, and we can just use the same value. */
1559 if (h
->u
.weakdef
!= NULL
)
1561 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
1562 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
1563 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
1564 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
1568 /* If this is a reference to a symbol defined by a dynamic object which
1569 is not a function, we might allocate the symbol in our .dynbss section
1570 and allocate a COPY dynamic relocation.
1572 But PA64 code is canonically PIC, so as a rule we can avoid this sort
1578 /* This function is called via elf_link_hash_traverse to mark millicode
1579 symbols with a dynindx of -1 and to remove the string table reference
1580 from the dynamic symbol table. If the symbol is not a millicode symbol,
1581 elf64_hppa_mark_exported_functions is called. */
1584 elf64_hppa_mark_milli_and_exported_functions (h
, data
)
1585 struct elf_link_hash_entry
*h
;
1588 struct bfd_link_info
*info
= (struct bfd_link_info
*)data
;
1589 struct elf_link_hash_entry
*elf
= h
;
1591 if (elf
->root
.type
== bfd_link_hash_warning
)
1592 elf
= (struct elf_link_hash_entry
*) elf
->root
.u
.i
.link
;
1594 if (elf
->type
== STT_PARISC_MILLI
)
1596 if (elf
->dynindx
!= -1)
1599 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1605 return elf64_hppa_mark_exported_functions (h
, data
);
1608 /* Set the final sizes of the dynamic sections and allocate memory for
1609 the contents of our special sections. */
1612 elf64_hppa_size_dynamic_sections (output_bfd
, info
)
1614 struct bfd_link_info
*info
;
1620 bfd_boolean reltext
;
1621 struct elf64_hppa_allocate_data data
;
1622 struct elf64_hppa_link_hash_table
*hppa_info
;
1624 hppa_info
= elf64_hppa_hash_table (info
);
1626 dynobj
= elf_hash_table (info
)->dynobj
;
1627 BFD_ASSERT (dynobj
!= NULL
);
1629 /* Mark each function this program exports so that we will allocate
1630 space in the .opd section for each function's FPTR. If we are
1631 creating dynamic sections, change the dynamic index of millicode
1632 symbols to -1 and remove them from the string table for .dynstr.
1634 We have to traverse the main linker hash table since we have to
1635 find functions which may not have been mentioned in any relocs. */
1636 elf_link_hash_traverse (elf_hash_table (info
),
1637 (elf_hash_table (info
)->dynamic_sections_created
1638 ? elf64_hppa_mark_milli_and_exported_functions
1639 : elf64_hppa_mark_exported_functions
),
1642 if (elf_hash_table (info
)->dynamic_sections_created
)
1644 /* Set the contents of the .interp section to the interpreter. */
1645 if (info
->executable
)
1647 s
= bfd_get_section_by_name (dynobj
, ".interp");
1648 BFD_ASSERT (s
!= NULL
);
1649 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1650 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1655 /* We may have created entries in the .rela.got section.
1656 However, if we are not creating the dynamic sections, we will
1657 not actually use these entries. Reset the size of .rela.dlt,
1658 which will cause it to get stripped from the output file
1660 s
= bfd_get_section_by_name (dynobj
, ".rela.dlt");
1665 /* Allocate the GOT entries. */
1668 if (elf64_hppa_hash_table (info
)->dlt_sec
)
1671 elf64_hppa_dyn_hash_traverse (&hppa_info
->dyn_hash_table
,
1672 allocate_global_data_dlt
, &data
);
1673 hppa_info
->dlt_sec
->size
= data
.ofs
;
1676 elf64_hppa_dyn_hash_traverse (&hppa_info
->dyn_hash_table
,
1677 allocate_global_data_plt
, &data
);
1678 hppa_info
->plt_sec
->size
= data
.ofs
;
1681 elf64_hppa_dyn_hash_traverse (&hppa_info
->dyn_hash_table
,
1682 allocate_global_data_stub
, &data
);
1683 hppa_info
->stub_sec
->size
= data
.ofs
;
1686 /* Allocate space for entries in the .opd section. */
1687 if (elf64_hppa_hash_table (info
)->opd_sec
)
1690 elf64_hppa_dyn_hash_traverse (&hppa_info
->dyn_hash_table
,
1691 allocate_global_data_opd
, &data
);
1692 hppa_info
->opd_sec
->size
= data
.ofs
;
1695 /* Now allocate space for dynamic relocations, if necessary. */
1696 if (hppa_info
->root
.dynamic_sections_created
)
1697 elf64_hppa_dyn_hash_traverse (&hppa_info
->dyn_hash_table
,
1698 allocate_dynrel_entries
, &data
);
1700 /* The sizes of all the sections are set. Allocate memory for them. */
1704 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1708 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1711 /* It's OK to base decisions on the section name, because none
1712 of the dynobj section names depend upon the input files. */
1713 name
= bfd_get_section_name (dynobj
, s
);
1715 if (strcmp (name
, ".plt") == 0)
1717 /* Remember whether there is a PLT. */
1720 else if (strcmp (name
, ".opd") == 0
1721 || strncmp (name
, ".dlt", 4) == 0
1722 || strcmp (name
, ".stub") == 0
1723 || strcmp (name
, ".got") == 0)
1725 /* Strip this section if we don't need it; see the comment below. */
1727 else if (strncmp (name
, ".rela", 5) == 0)
1733 /* Remember whether there are any reloc sections other
1735 if (strcmp (name
, ".rela.plt") != 0)
1737 const char *outname
;
1741 /* If this relocation section applies to a read only
1742 section, then we probably need a DT_TEXTREL
1743 entry. The entries in the .rela.plt section
1744 really apply to the .got section, which we
1745 created ourselves and so know is not readonly. */
1746 outname
= bfd_get_section_name (output_bfd
,
1748 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
1750 && (target
->flags
& SEC_READONLY
) != 0
1751 && (target
->flags
& SEC_ALLOC
) != 0)
1755 /* We use the reloc_count field as a counter if we need
1756 to copy relocs into the output file. */
1762 /* It's not one of our sections, so don't allocate space. */
1768 /* If we don't need this section, strip it from the
1769 output file. This is mostly to handle .rela.bss and
1770 .rela.plt. We must create both sections in
1771 create_dynamic_sections, because they must be created
1772 before the linker maps input sections to output
1773 sections. The linker does that before
1774 adjust_dynamic_symbol is called, and it is that
1775 function which decides whether anything needs to go
1776 into these sections. */
1777 s
->flags
|= SEC_EXCLUDE
;
1781 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
1784 /* Allocate memory for the section contents if it has not
1785 been allocated already. We use bfd_zalloc here in case
1786 unused entries are not reclaimed before the section's
1787 contents are written out. This should not happen, but this
1788 way if it does, we get a R_PARISC_NONE reloc instead of
1790 if (s
->contents
== NULL
)
1792 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1793 if (s
->contents
== NULL
)
1798 if (elf_hash_table (info
)->dynamic_sections_created
)
1800 /* Always create a DT_PLTGOT. It actually has nothing to do with
1801 the PLT, it is how we communicate the __gp value of a load
1802 module to the dynamic linker. */
1803 #define add_dynamic_entry(TAG, VAL) \
1804 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1806 if (!add_dynamic_entry (DT_HP_DLD_FLAGS
, 0)
1807 || !add_dynamic_entry (DT_PLTGOT
, 0))
1810 /* Add some entries to the .dynamic section. We fill in the
1811 values later, in elf64_hppa_finish_dynamic_sections, but we
1812 must add the entries now so that we get the correct size for
1813 the .dynamic section. The DT_DEBUG entry is filled in by the
1814 dynamic linker and used by the debugger. */
1817 if (!add_dynamic_entry (DT_DEBUG
, 0)
1818 || !add_dynamic_entry (DT_HP_DLD_HOOK
, 0)
1819 || !add_dynamic_entry (DT_HP_LOAD_MAP
, 0))
1823 /* Force DT_FLAGS to always be set.
1824 Required by HPUX 11.00 patch PHSS_26559. */
1825 if (!add_dynamic_entry (DT_FLAGS
, (info
)->flags
))
1830 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
1831 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1832 || !add_dynamic_entry (DT_JMPREL
, 0))
1838 if (!add_dynamic_entry (DT_RELA
, 0)
1839 || !add_dynamic_entry (DT_RELASZ
, 0)
1840 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf64_External_Rela
)))
1846 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1848 info
->flags
|= DF_TEXTREL
;
1851 #undef add_dynamic_entry
1856 /* Called after we have output the symbol into the dynamic symbol
1857 table, but before we output the symbol into the normal symbol
1860 For some symbols we had to change their address when outputting
1861 the dynamic symbol table. We undo that change here so that
1862 the symbols have their expected value in the normal symbol
1866 elf64_hppa_link_output_symbol_hook (info
, name
, sym
, input_sec
, h
)
1867 struct bfd_link_info
*info
;
1869 Elf_Internal_Sym
*sym
;
1870 asection
*input_sec ATTRIBUTE_UNUSED
;
1871 struct elf_link_hash_entry
*h
;
1873 struct elf64_hppa_link_hash_table
*hppa_info
;
1874 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
1876 /* We may be called with the file symbol or section symbols.
1877 They never need munging, so it is safe to ignore them. */
1881 /* Get the PA dyn_symbol (if any) associated with NAME. */
1882 hppa_info
= elf64_hppa_hash_table (info
);
1883 dyn_h
= elf64_hppa_dyn_hash_lookup (&hppa_info
->dyn_hash_table
,
1884 name
, FALSE
, FALSE
);
1885 if (!dyn_h
|| dyn_h
->h
!= h
)
1888 /* Function symbols for which we created .opd entries *may* have been
1889 munged by finish_dynamic_symbol and have to be un-munged here.
1891 Note that finish_dynamic_symbol sometimes turns dynamic symbols
1892 into non-dynamic ones, so we initialize st_shndx to -1 in
1893 mark_exported_functions and check to see if it was overwritten
1894 here instead of just checking dyn_h->h->dynindx. */
1895 if (dyn_h
->want_opd
&& dyn_h
->st_shndx
!= -1)
1897 /* Restore the saved value and section index. */
1898 sym
->st_value
= dyn_h
->st_value
;
1899 sym
->st_shndx
= dyn_h
->st_shndx
;
1905 /* Finish up dynamic symbol handling. We set the contents of various
1906 dynamic sections here. */
1909 elf64_hppa_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
1911 struct bfd_link_info
*info
;
1912 struct elf_link_hash_entry
*h
;
1913 Elf_Internal_Sym
*sym
;
1915 asection
*stub
, *splt
, *sdlt
, *sopd
, *spltrel
, *sdltrel
;
1916 struct elf64_hppa_link_hash_table
*hppa_info
;
1917 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
1919 hppa_info
= elf64_hppa_hash_table (info
);
1920 dyn_h
= elf64_hppa_dyn_hash_lookup (&hppa_info
->dyn_hash_table
,
1921 h
->root
.root
.string
, FALSE
, FALSE
);
1923 stub
= hppa_info
->stub_sec
;
1924 splt
= hppa_info
->plt_sec
;
1925 sdlt
= hppa_info
->dlt_sec
;
1926 sopd
= hppa_info
->opd_sec
;
1927 spltrel
= hppa_info
->plt_rel_sec
;
1928 sdltrel
= hppa_info
->dlt_rel_sec
;
1930 /* Incredible. It is actually necessary to NOT use the symbol's real
1931 value when building the dynamic symbol table for a shared library.
1932 At least for symbols that refer to functions.
1934 We will store a new value and section index into the symbol long
1935 enough to output it into the dynamic symbol table, then we restore
1936 the original values (in elf64_hppa_link_output_symbol_hook). */
1937 if (dyn_h
&& dyn_h
->want_opd
)
1939 BFD_ASSERT (sopd
!= NULL
);
1941 /* Save away the original value and section index so that we
1942 can restore them later. */
1943 dyn_h
->st_value
= sym
->st_value
;
1944 dyn_h
->st_shndx
= sym
->st_shndx
;
1946 /* For the dynamic symbol table entry, we want the value to be
1947 address of this symbol's entry within the .opd section. */
1948 sym
->st_value
= (dyn_h
->opd_offset
1949 + sopd
->output_offset
1950 + sopd
->output_section
->vma
);
1951 sym
->st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
1952 sopd
->output_section
);
1955 /* Initialize a .plt entry if requested. */
1956 if (dyn_h
&& dyn_h
->want_plt
1957 && elf64_hppa_dynamic_symbol_p (dyn_h
->h
, info
))
1960 Elf_Internal_Rela rel
;
1963 BFD_ASSERT (splt
!= NULL
&& spltrel
!= NULL
);
1965 /* We do not actually care about the value in the PLT entry
1966 if we are creating a shared library and the symbol is
1967 still undefined, we create a dynamic relocation to fill
1968 in the correct value. */
1969 if (info
->shared
&& h
->root
.type
== bfd_link_hash_undefined
)
1972 value
= (h
->root
.u
.def
.value
+ h
->root
.u
.def
.section
->vma
);
1974 /* Fill in the entry in the procedure linkage table.
1976 The format of a plt entry is
1979 plt_offset is the offset within the PLT section at which to
1980 install the PLT entry.
1982 We are modifying the in-memory PLT contents here, so we do not add
1983 in the output_offset of the PLT section. */
1985 bfd_put_64 (splt
->owner
, value
, splt
->contents
+ dyn_h
->plt_offset
);
1986 value
= _bfd_get_gp_value (splt
->output_section
->owner
);
1987 bfd_put_64 (splt
->owner
, value
, splt
->contents
+ dyn_h
->plt_offset
+ 0x8);
1989 /* Create a dynamic IPLT relocation for this entry.
1991 We are creating a relocation in the output file's PLT section,
1992 which is included within the DLT secton. So we do need to include
1993 the PLT's output_offset in the computation of the relocation's
1995 rel
.r_offset
= (dyn_h
->plt_offset
+ splt
->output_offset
1996 + splt
->output_section
->vma
);
1997 rel
.r_info
= ELF64_R_INFO (h
->dynindx
, R_PARISC_IPLT
);
2000 loc
= spltrel
->contents
;
2001 loc
+= spltrel
->reloc_count
++ * sizeof (Elf64_External_Rela
);
2002 bfd_elf64_swap_reloca_out (splt
->output_section
->owner
, &rel
, loc
);
2005 /* Initialize an external call stub entry if requested. */
2006 if (dyn_h
&& dyn_h
->want_stub
2007 && elf64_hppa_dynamic_symbol_p (dyn_h
->h
, info
))
2011 unsigned int max_offset
;
2013 BFD_ASSERT (stub
!= NULL
);
2015 /* Install the generic stub template.
2017 We are modifying the contents of the stub section, so we do not
2018 need to include the stub section's output_offset here. */
2019 memcpy (stub
->contents
+ dyn_h
->stub_offset
, plt_stub
, sizeof (plt_stub
));
2021 /* Fix up the first ldd instruction.
2023 We are modifying the contents of the STUB section in memory,
2024 so we do not need to include its output offset in this computation.
2026 Note the plt_offset value is the value of the PLT entry relative to
2027 the start of the PLT section. These instructions will reference
2028 data relative to the value of __gp, which may not necessarily have
2029 the same address as the start of the PLT section.
2031 gp_offset contains the offset of __gp within the PLT section. */
2032 value
= dyn_h
->plt_offset
- hppa_info
->gp_offset
;
2034 insn
= bfd_get_32 (stub
->owner
, stub
->contents
+ dyn_h
->stub_offset
);
2035 if (output_bfd
->arch_info
->mach
>= 25)
2037 /* Wide mode allows 16 bit offsets. */
2040 insn
|= re_assemble_16 ((int) value
);
2046 insn
|= re_assemble_14 ((int) value
);
2049 if ((value
& 7) || value
+ max_offset
>= 2*max_offset
- 8)
2051 (*_bfd_error_handler
) (_("stub entry for %s cannot load .plt, dp offset = %ld"),
2057 bfd_put_32 (stub
->owner
, (bfd_vma
) insn
,
2058 stub
->contents
+ dyn_h
->stub_offset
);
2060 /* Fix up the second ldd instruction. */
2062 insn
= bfd_get_32 (stub
->owner
, stub
->contents
+ dyn_h
->stub_offset
+ 8);
2063 if (output_bfd
->arch_info
->mach
>= 25)
2066 insn
|= re_assemble_16 ((int) value
);
2071 insn
|= re_assemble_14 ((int) value
);
2073 bfd_put_32 (stub
->owner
, (bfd_vma
) insn
,
2074 stub
->contents
+ dyn_h
->stub_offset
+ 8);
2080 /* The .opd section contains FPTRs for each function this file
2081 exports. Initialize the FPTR entries. */
2084 elf64_hppa_finalize_opd (dyn_h
, data
)
2085 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
2088 struct bfd_link_info
*info
= (struct bfd_link_info
*)data
;
2089 struct elf64_hppa_link_hash_table
*hppa_info
;
2090 struct elf_link_hash_entry
*h
= dyn_h
? dyn_h
->h
: NULL
;
2094 hppa_info
= elf64_hppa_hash_table (info
);
2095 sopd
= hppa_info
->opd_sec
;
2096 sopdrel
= hppa_info
->opd_rel_sec
;
2098 if (h
&& dyn_h
->want_opd
)
2102 /* The first two words of an .opd entry are zero.
2104 We are modifying the contents of the OPD section in memory, so we
2105 do not need to include its output offset in this computation. */
2106 memset (sopd
->contents
+ dyn_h
->opd_offset
, 0, 16);
2108 value
= (h
->root
.u
.def
.value
2109 + h
->root
.u
.def
.section
->output_section
->vma
2110 + h
->root
.u
.def
.section
->output_offset
);
2112 /* The next word is the address of the function. */
2113 bfd_put_64 (sopd
->owner
, value
, sopd
->contents
+ dyn_h
->opd_offset
+ 16);
2115 /* The last word is our local __gp value. */
2116 value
= _bfd_get_gp_value (sopd
->output_section
->owner
);
2117 bfd_put_64 (sopd
->owner
, value
, sopd
->contents
+ dyn_h
->opd_offset
+ 24);
2120 /* If we are generating a shared library, we must generate EPLT relocations
2121 for each entry in the .opd, even for static functions (they may have
2122 had their address taken). */
2123 if (info
->shared
&& dyn_h
&& dyn_h
->want_opd
)
2125 Elf_Internal_Rela rel
;
2129 /* We may need to do a relocation against a local symbol, in
2130 which case we have to look up it's dynamic symbol index off
2131 the local symbol hash table. */
2132 if (h
&& h
->dynindx
!= -1)
2133 dynindx
= h
->dynindx
;
2136 = _bfd_elf_link_lookup_local_dynindx (info
, dyn_h
->owner
,
2139 /* The offset of this relocation is the absolute address of the
2140 .opd entry for this symbol. */
2141 rel
.r_offset
= (dyn_h
->opd_offset
+ sopd
->output_offset
2142 + sopd
->output_section
->vma
);
2144 /* If H is non-null, then we have an external symbol.
2146 It is imperative that we use a different dynamic symbol for the
2147 EPLT relocation if the symbol has global scope.
2149 In the dynamic symbol table, the function symbol will have a value
2150 which is address of the function's .opd entry.
2152 Thus, we can not use that dynamic symbol for the EPLT relocation
2153 (if we did, the data in the .opd would reference itself rather
2154 than the actual address of the function). Instead we have to use
2155 a new dynamic symbol which has the same value as the original global
2158 We prefix the original symbol with a "." and use the new symbol in
2159 the EPLT relocation. This new symbol has already been recorded in
2160 the symbol table, we just have to look it up and use it.
2162 We do not have such problems with static functions because we do
2163 not make their addresses in the dynamic symbol table point to
2164 the .opd entry. Ultimately this should be safe since a static
2165 function can not be directly referenced outside of its shared
2168 We do have to play similar games for FPTR relocations in shared
2169 libraries, including those for static symbols. See the FPTR
2170 handling in elf64_hppa_finalize_dynreloc. */
2174 struct elf_link_hash_entry
*nh
;
2176 new_name
= alloca (strlen (h
->root
.root
.string
) + 2);
2178 strcpy (new_name
+ 1, h
->root
.root
.string
);
2180 nh
= elf_link_hash_lookup (elf_hash_table (info
),
2181 new_name
, FALSE
, FALSE
, FALSE
);
2183 /* All we really want from the new symbol is its dynamic
2185 dynindx
= nh
->dynindx
;
2189 rel
.r_info
= ELF64_R_INFO (dynindx
, R_PARISC_EPLT
);
2191 loc
= sopdrel
->contents
;
2192 loc
+= sopdrel
->reloc_count
++ * sizeof (Elf64_External_Rela
);
2193 bfd_elf64_swap_reloca_out (sopd
->output_section
->owner
, &rel
, loc
);
2198 /* The .dlt section contains addresses for items referenced through the
2199 dlt. Note that we can have a DLTIND relocation for a local symbol, thus
2200 we can not depend on finish_dynamic_symbol to initialize the .dlt. */
2203 elf64_hppa_finalize_dlt (dyn_h
, data
)
2204 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
2207 struct bfd_link_info
*info
= (struct bfd_link_info
*)data
;
2208 struct elf64_hppa_link_hash_table
*hppa_info
;
2209 asection
*sdlt
, *sdltrel
;
2210 struct elf_link_hash_entry
*h
= dyn_h
? dyn_h
->h
: NULL
;
2212 hppa_info
= elf64_hppa_hash_table (info
);
2214 sdlt
= hppa_info
->dlt_sec
;
2215 sdltrel
= hppa_info
->dlt_rel_sec
;
2217 /* H/DYN_H may refer to a local variable and we know it's
2218 address, so there is no need to create a relocation. Just install
2219 the proper value into the DLT, note this shortcut can not be
2220 skipped when building a shared library. */
2221 if (! info
->shared
&& h
&& dyn_h
->want_dlt
)
2225 /* If we had an LTOFF_FPTR style relocation we want the DLT entry
2226 to point to the FPTR entry in the .opd section.
2228 We include the OPD's output offset in this computation as
2229 we are referring to an absolute address in the resulting
2231 if (dyn_h
->want_opd
)
2233 value
= (dyn_h
->opd_offset
2234 + hppa_info
->opd_sec
->output_offset
2235 + hppa_info
->opd_sec
->output_section
->vma
);
2237 else if ((h
->root
.type
== bfd_link_hash_defined
2238 || h
->root
.type
== bfd_link_hash_defweak
)
2239 && h
->root
.u
.def
.section
)
2241 value
= h
->root
.u
.def
.value
+ h
->root
.u
.def
.section
->output_offset
;
2242 if (h
->root
.u
.def
.section
->output_section
)
2243 value
+= h
->root
.u
.def
.section
->output_section
->vma
;
2245 value
+= h
->root
.u
.def
.section
->vma
;
2248 /* We have an undefined function reference. */
2251 /* We do not need to include the output offset of the DLT section
2252 here because we are modifying the in-memory contents. */
2253 bfd_put_64 (sdlt
->owner
, value
, sdlt
->contents
+ dyn_h
->dlt_offset
);
2256 /* Create a relocation for the DLT entry associated with this symbol.
2257 When building a shared library the symbol does not have to be dynamic. */
2259 && (elf64_hppa_dynamic_symbol_p (dyn_h
->h
, info
) || info
->shared
))
2261 Elf_Internal_Rela rel
;
2265 /* We may need to do a relocation against a local symbol, in
2266 which case we have to look up it's dynamic symbol index off
2267 the local symbol hash table. */
2268 if (h
&& h
->dynindx
!= -1)
2269 dynindx
= h
->dynindx
;
2272 = _bfd_elf_link_lookup_local_dynindx (info
, dyn_h
->owner
,
2275 /* Create a dynamic relocation for this entry. Do include the output
2276 offset of the DLT entry since we need an absolute address in the
2277 resulting object file. */
2278 rel
.r_offset
= (dyn_h
->dlt_offset
+ sdlt
->output_offset
2279 + sdlt
->output_section
->vma
);
2280 if (h
&& h
->type
== STT_FUNC
)
2281 rel
.r_info
= ELF64_R_INFO (dynindx
, R_PARISC_FPTR64
);
2283 rel
.r_info
= ELF64_R_INFO (dynindx
, R_PARISC_DIR64
);
2286 loc
= sdltrel
->contents
;
2287 loc
+= sdltrel
->reloc_count
++ * sizeof (Elf64_External_Rela
);
2288 bfd_elf64_swap_reloca_out (sdlt
->output_section
->owner
, &rel
, loc
);
2293 /* Finalize the dynamic relocations. Specifically the FPTR relocations
2294 for dynamic functions used to initialize static data. */
2297 elf64_hppa_finalize_dynreloc (dyn_h
, data
)
2298 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
2301 struct bfd_link_info
*info
= (struct bfd_link_info
*)data
;
2302 struct elf64_hppa_link_hash_table
*hppa_info
;
2303 struct elf_link_hash_entry
*h
;
2306 dynamic_symbol
= elf64_hppa_dynamic_symbol_p (dyn_h
->h
, info
);
2308 if (!dynamic_symbol
&& !info
->shared
)
2311 if (dyn_h
->reloc_entries
)
2313 struct elf64_hppa_dyn_reloc_entry
*rent
;
2316 hppa_info
= elf64_hppa_hash_table (info
);
2319 /* We may need to do a relocation against a local symbol, in
2320 which case we have to look up it's dynamic symbol index off
2321 the local symbol hash table. */
2322 if (h
&& h
->dynindx
!= -1)
2323 dynindx
= h
->dynindx
;
2326 = _bfd_elf_link_lookup_local_dynindx (info
, dyn_h
->owner
,
2329 for (rent
= dyn_h
->reloc_entries
; rent
; rent
= rent
->next
)
2331 Elf_Internal_Rela rel
;
2334 /* Allocate one iff we are building a shared library, the relocation
2335 isn't a R_PARISC_FPTR64, or we don't want an opd entry. */
2336 if (!info
->shared
&& rent
->type
== R_PARISC_FPTR64
&& dyn_h
->want_opd
)
2339 /* Create a dynamic relocation for this entry.
2341 We need the output offset for the reloc's section because
2342 we are creating an absolute address in the resulting object
2344 rel
.r_offset
= (rent
->offset
+ rent
->sec
->output_offset
2345 + rent
->sec
->output_section
->vma
);
2347 /* An FPTR64 relocation implies that we took the address of
2348 a function and that the function has an entry in the .opd
2349 section. We want the FPTR64 relocation to reference the
2352 We could munge the symbol value in the dynamic symbol table
2353 (in fact we already do for functions with global scope) to point
2354 to the .opd entry. Then we could use that dynamic symbol in
2357 Or we could do something sensible, not munge the symbol's
2358 address and instead just use a different symbol to reference
2359 the .opd entry. At least that seems sensible until you
2360 realize there's no local dynamic symbols we can use for that
2361 purpose. Thus the hair in the check_relocs routine.
2363 We use a section symbol recorded by check_relocs as the
2364 base symbol for the relocation. The addend is the difference
2365 between the section symbol and the address of the .opd entry. */
2366 if (info
->shared
&& rent
->type
== R_PARISC_FPTR64
&& dyn_h
->want_opd
)
2368 bfd_vma value
, value2
;
2370 /* First compute the address of the opd entry for this symbol. */
2371 value
= (dyn_h
->opd_offset
2372 + hppa_info
->opd_sec
->output_section
->vma
2373 + hppa_info
->opd_sec
->output_offset
);
2375 /* Compute the value of the start of the section with
2377 value2
= (rent
->sec
->output_section
->vma
2378 + rent
->sec
->output_offset
);
2380 /* Compute the difference between the start of the section
2381 with the relocation and the opd entry. */
2384 /* The result becomes the addend of the relocation. */
2385 rel
.r_addend
= value
;
2387 /* The section symbol becomes the symbol for the dynamic
2390 = _bfd_elf_link_lookup_local_dynindx (info
,
2395 rel
.r_addend
= rent
->addend
;
2397 rel
.r_info
= ELF64_R_INFO (dynindx
, rent
->type
);
2399 loc
= hppa_info
->other_rel_sec
->contents
;
2400 loc
+= (hppa_info
->other_rel_sec
->reloc_count
++
2401 * sizeof (Elf64_External_Rela
));
2402 bfd_elf64_swap_reloca_out (hppa_info
->other_rel_sec
->output_section
->owner
,
2410 /* Used to decide how to sort relocs in an optimal manner for the
2411 dynamic linker, before writing them out. */
2413 static enum elf_reloc_type_class
2414 elf64_hppa_reloc_type_class (rela
)
2415 const Elf_Internal_Rela
*rela
;
2417 if (ELF64_R_SYM (rela
->r_info
) == 0)
2418 return reloc_class_relative
;
2420 switch ((int) ELF64_R_TYPE (rela
->r_info
))
2423 return reloc_class_plt
;
2425 return reloc_class_copy
;
2427 return reloc_class_normal
;
2431 /* Finish up the dynamic sections. */
2434 elf64_hppa_finish_dynamic_sections (output_bfd
, info
)
2436 struct bfd_link_info
*info
;
2440 struct elf64_hppa_link_hash_table
*hppa_info
;
2442 hppa_info
= elf64_hppa_hash_table (info
);
2444 /* Finalize the contents of the .opd section. */
2445 elf64_hppa_dyn_hash_traverse (&hppa_info
->dyn_hash_table
,
2446 elf64_hppa_finalize_opd
,
2449 elf64_hppa_dyn_hash_traverse (&hppa_info
->dyn_hash_table
,
2450 elf64_hppa_finalize_dynreloc
,
2453 /* Finalize the contents of the .dlt section. */
2454 dynobj
= elf_hash_table (info
)->dynobj
;
2455 /* Finalize the contents of the .dlt section. */
2456 elf64_hppa_dyn_hash_traverse (&hppa_info
->dyn_hash_table
,
2457 elf64_hppa_finalize_dlt
,
2460 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2462 if (elf_hash_table (info
)->dynamic_sections_created
)
2464 Elf64_External_Dyn
*dyncon
, *dynconend
;
2466 BFD_ASSERT (sdyn
!= NULL
);
2468 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
2469 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
2470 for (; dyncon
< dynconend
; dyncon
++)
2472 Elf_Internal_Dyn dyn
;
2475 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2482 case DT_HP_LOAD_MAP
:
2483 /* Compute the absolute address of 16byte scratchpad area
2484 for the dynamic linker.
2486 By convention the linker script will allocate the scratchpad
2487 area at the start of the .data section. So all we have to
2488 to is find the start of the .data section. */
2489 s
= bfd_get_section_by_name (output_bfd
, ".data");
2490 dyn
.d_un
.d_ptr
= s
->vma
;
2491 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2495 /* HP's use PLTGOT to set the GOT register. */
2496 dyn
.d_un
.d_ptr
= _bfd_get_gp_value (output_bfd
);
2497 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2501 s
= hppa_info
->plt_rel_sec
;
2502 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2503 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2507 s
= hppa_info
->plt_rel_sec
;
2508 dyn
.d_un
.d_val
= s
->size
;
2509 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2513 s
= hppa_info
->other_rel_sec
;
2514 if (! s
|| ! s
->size
)
2515 s
= hppa_info
->dlt_rel_sec
;
2516 if (! s
|| ! s
->size
)
2517 s
= hppa_info
->opd_rel_sec
;
2518 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2519 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2523 s
= hppa_info
->other_rel_sec
;
2524 dyn
.d_un
.d_val
= s
->size
;
2525 s
= hppa_info
->dlt_rel_sec
;
2526 dyn
.d_un
.d_val
+= s
->size
;
2527 s
= hppa_info
->opd_rel_sec
;
2528 dyn
.d_un
.d_val
+= s
->size
;
2529 /* There is some question about whether or not the size of
2530 the PLT relocs should be included here. HP's tools do
2531 it, so we'll emulate them. */
2532 s
= hppa_info
->plt_rel_sec
;
2533 dyn
.d_un
.d_val
+= s
->size
;
2534 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2544 /* Return the number of additional phdrs we will need.
2546 The generic ELF code only creates PT_PHDRs for executables. The HP
2547 dynamic linker requires PT_PHDRs for dynamic libraries too.
2549 This routine indicates that the backend needs one additional program
2550 header for that case.
2552 Note we do not have access to the link info structure here, so we have
2553 to guess whether or not we are building a shared library based on the
2554 existence of a .interp section. */
2557 elf64_hppa_additional_program_headers (abfd
)
2562 /* If we are creating a shared library, then we have to create a
2563 PT_PHDR segment. HP's dynamic linker chokes without it. */
2564 s
= bfd_get_section_by_name (abfd
, ".interp");
2570 /* Allocate and initialize any program headers required by this
2573 The generic ELF code only creates PT_PHDRs for executables. The HP
2574 dynamic linker requires PT_PHDRs for dynamic libraries too.
2576 This allocates the PT_PHDR and initializes it in a manner suitable
2579 Note we do not have access to the link info structure here, so we have
2580 to guess whether or not we are building a shared library based on the
2581 existence of a .interp section. */
2584 elf64_hppa_modify_segment_map (abfd
, info
)
2586 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2588 struct elf_segment_map
*m
;
2591 s
= bfd_get_section_by_name (abfd
, ".interp");
2594 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2595 if (m
->p_type
== PT_PHDR
)
2599 m
= ((struct elf_segment_map
*)
2600 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *m
));
2604 m
->p_type
= PT_PHDR
;
2605 m
->p_flags
= PF_R
| PF_X
;
2606 m
->p_flags_valid
= 1;
2607 m
->p_paddr_valid
= 1;
2608 m
->includes_phdrs
= 1;
2610 m
->next
= elf_tdata (abfd
)->segment_map
;
2611 elf_tdata (abfd
)->segment_map
= m
;
2615 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2616 if (m
->p_type
== PT_LOAD
)
2620 for (i
= 0; i
< m
->count
; i
++)
2622 /* The code "hint" is not really a hint. It is a requirement
2623 for certain versions of the HP dynamic linker. Worse yet,
2624 it must be set even if the shared library does not have
2625 any code in its "text" segment (thus the check for .hash
2626 to catch this situation). */
2627 if (m
->sections
[i
]->flags
& SEC_CODE
2628 || (strcmp (m
->sections
[i
]->name
, ".hash") == 0))
2629 m
->p_flags
|= (PF_X
| PF_HP_CODE
);
2636 /* Called when writing out an object file to decide the type of a
2639 elf64_hppa_elf_get_symbol_type (elf_sym
, type
)
2640 Elf_Internal_Sym
*elf_sym
;
2643 if (ELF_ST_TYPE (elf_sym
->st_info
) == STT_PARISC_MILLI
)
2644 return STT_PARISC_MILLI
;
2649 /* Support HP specific sections for core files. */
2651 elf64_hppa_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int index
,
2652 const char *typename
)
2654 if (hdr
->p_type
== PT_HP_CORE_KERNEL
)
2658 if (!_bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, typename
))
2661 sect
= bfd_make_section_anyway (abfd
, ".kernel");
2664 sect
->size
= hdr
->p_filesz
;
2665 sect
->filepos
= hdr
->p_offset
;
2666 sect
->flags
= SEC_HAS_CONTENTS
| SEC_READONLY
;
2670 if (hdr
->p_type
== PT_HP_CORE_PROC
)
2674 if (bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != 0)
2676 if (bfd_bread (&sig
, 4, abfd
) != 4)
2679 elf_tdata (abfd
)->core_signal
= sig
;
2681 if (!_bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, typename
))
2684 /* GDB uses the ".reg" section to read register contents. */
2685 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", hdr
->p_filesz
,
2689 if (hdr
->p_type
== PT_HP_CORE_LOADABLE
2690 || hdr
->p_type
== PT_HP_CORE_STACK
2691 || hdr
->p_type
== PT_HP_CORE_MMF
)
2692 hdr
->p_type
= PT_LOAD
;
2694 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, index
, typename
);
2697 static const struct bfd_elf_special_section elf64_hppa_special_sections
[] =
2699 { ".fini", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2700 { ".init", 5, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2701 { ".plt", 4, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_PARISC_SHORT
},
2702 { ".dlt", 4, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_PARISC_SHORT
},
2703 { ".sdata", 6, 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_PARISC_SHORT
},
2704 { ".sbss", 5, 0, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_PARISC_SHORT
},
2705 { ".tbss", 5, 0, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_PARISC_WEAKORDER
},
2706 { NULL
, 0, 0, 0, 0 }
2709 /* The hash bucket size is the standard one, namely 4. */
2711 const struct elf_size_info hppa64_elf_size_info
=
2713 sizeof (Elf64_External_Ehdr
),
2714 sizeof (Elf64_External_Phdr
),
2715 sizeof (Elf64_External_Shdr
),
2716 sizeof (Elf64_External_Rel
),
2717 sizeof (Elf64_External_Rela
),
2718 sizeof (Elf64_External_Sym
),
2719 sizeof (Elf64_External_Dyn
),
2720 sizeof (Elf_External_Note
),
2724 ELFCLASS64
, EV_CURRENT
,
2725 bfd_elf64_write_out_phdrs
,
2726 bfd_elf64_write_shdrs_and_ehdr
,
2727 bfd_elf64_write_relocs
,
2728 bfd_elf64_swap_symbol_in
,
2729 bfd_elf64_swap_symbol_out
,
2730 bfd_elf64_slurp_reloc_table
,
2731 bfd_elf64_slurp_symbol_table
,
2732 bfd_elf64_swap_dyn_in
,
2733 bfd_elf64_swap_dyn_out
,
2734 bfd_elf64_swap_reloc_in
,
2735 bfd_elf64_swap_reloc_out
,
2736 bfd_elf64_swap_reloca_in
,
2737 bfd_elf64_swap_reloca_out
2740 #define TARGET_BIG_SYM bfd_elf64_hppa_vec
2741 #define TARGET_BIG_NAME "elf64-hppa"
2742 #define ELF_ARCH bfd_arch_hppa
2743 #define ELF_MACHINE_CODE EM_PARISC
2744 /* This is not strictly correct. The maximum page size for PA2.0 is
2745 64M. But everything still uses 4k. */
2746 #define ELF_MAXPAGESIZE 0x1000
2747 #define bfd_elf64_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
2748 #define bfd_elf64_bfd_is_local_label_name elf_hppa_is_local_label_name
2749 #define elf_info_to_howto elf_hppa_info_to_howto
2750 #define elf_info_to_howto_rel elf_hppa_info_to_howto_rel
2752 #define elf_backend_section_from_shdr elf64_hppa_section_from_shdr
2753 #define elf_backend_object_p elf64_hppa_object_p
2754 #define elf_backend_final_write_processing \
2755 elf_hppa_final_write_processing
2756 #define elf_backend_fake_sections elf_hppa_fake_sections
2757 #define elf_backend_add_symbol_hook elf_hppa_add_symbol_hook
2759 #define elf_backend_relocate_section elf_hppa_relocate_section
2761 #define bfd_elf64_bfd_final_link elf_hppa_final_link
2763 #define elf_backend_create_dynamic_sections \
2764 elf64_hppa_create_dynamic_sections
2765 #define elf_backend_post_process_headers elf64_hppa_post_process_headers
2767 #define elf_backend_adjust_dynamic_symbol \
2768 elf64_hppa_adjust_dynamic_symbol
2770 #define elf_backend_size_dynamic_sections \
2771 elf64_hppa_size_dynamic_sections
2773 #define elf_backend_finish_dynamic_symbol \
2774 elf64_hppa_finish_dynamic_symbol
2775 #define elf_backend_finish_dynamic_sections \
2776 elf64_hppa_finish_dynamic_sections
2778 /* Stuff for the BFD linker: */
2779 #define bfd_elf64_bfd_link_hash_table_create \
2780 elf64_hppa_hash_table_create
2782 #define elf_backend_check_relocs \
2783 elf64_hppa_check_relocs
2785 #define elf_backend_size_info \
2786 hppa64_elf_size_info
2788 #define elf_backend_additional_program_headers \
2789 elf64_hppa_additional_program_headers
2791 #define elf_backend_modify_segment_map \
2792 elf64_hppa_modify_segment_map
2794 #define elf_backend_link_output_symbol_hook \
2795 elf64_hppa_link_output_symbol_hook
2797 #define elf_backend_want_got_plt 0
2798 #define elf_backend_plt_readonly 0
2799 #define elf_backend_want_plt_sym 0
2800 #define elf_backend_got_header_size 0
2801 #define elf_backend_type_change_ok TRUE
2802 #define elf_backend_get_symbol_type elf64_hppa_elf_get_symbol_type
2803 #define elf_backend_reloc_type_class elf64_hppa_reloc_type_class
2804 #define elf_backend_rela_normal 1
2805 #define elf_backend_special_sections elf64_hppa_special_sections
2806 #define elf_backend_action_discarded elf_hppa_action_discarded
2807 #define elf_backend_section_from_phdr elf64_hppa_section_from_phdr
2809 #include "elf64-target.h"
2811 #undef TARGET_BIG_SYM
2812 #define TARGET_BIG_SYM bfd_elf64_hppa_linux_vec
2813 #undef TARGET_BIG_NAME
2814 #define TARGET_BIG_NAME "elf64-hppa-linux"
2816 #undef elf_backend_special_sections
2818 #define INCLUDED_TARGET_FILE 1
2819 #include "elf64-target.h"