1 /* Support for HPPA 64-bit ELF
2 Copyright (C) 1999-2020 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
22 #include "alloca-conf.h"
28 #include "elf64-hppa.h"
29 #include "libiberty.h"
33 #define PLT_ENTRY_SIZE 0x10
34 #define DLT_ENTRY_SIZE 0x8
35 #define OPD_ENTRY_SIZE 0x20
37 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/pa20_64/dld.sl"
39 /* The stub is supposed to load the target address and target's DP
40 value out of the PLT, then do an external branch to the target
45 LDD PLTOFF+8(%r27),%r27
47 Note that we must use the LDD with a 14 bit displacement, not the one
48 with a 5 bit displacement. */
49 static char plt_stub
[] = {0x53, 0x61, 0x00, 0x00, 0xe8, 0x20, 0xd0, 0x00,
50 0x53, 0x7b, 0x00, 0x00 };
52 struct elf64_hppa_link_hash_entry
54 struct elf_link_hash_entry eh
;
56 /* Offsets for this symbol in various linker sections. */
62 /* The index of the (possibly local) symbol in the input bfd and its
63 associated BFD. Needed so that we can have relocs against local
64 symbols in shared libraries. */
68 /* Dynamic symbols may need to have two different values. One for
69 the dynamic symbol table, one for the normal symbol table.
71 In such cases we store the symbol's real value and section
72 index here so we can restore the real value before we write
73 the normal symbol table. */
77 /* Used to count non-got, non-plt relocations for delayed sizing
78 of relocation sections. */
79 struct elf64_hppa_dyn_reloc_entry
81 /* Next relocation in the chain. */
82 struct elf64_hppa_dyn_reloc_entry
*next
;
84 /* The type of the relocation. */
87 /* The input section of the relocation. */
90 /* Number of relocs copied in this section. */
93 /* The index of the section symbol for the input section of
94 the relocation. Only needed when building shared libraries. */
97 /* The offset within the input section of the relocation. */
100 /* The addend for the relocation. */
105 /* Nonzero if this symbol needs an entry in one of the linker
113 struct elf64_hppa_link_hash_table
115 struct elf_link_hash_table root
;
117 /* Shortcuts to get to the various linker defined sections. */
119 asection
*dlt_rel_sec
;
121 asection
*opd_rel_sec
;
122 asection
*other_rel_sec
;
124 /* Offset of __gp within .plt section. When the PLT gets large we want
125 to slide __gp into the PLT section so that we can continue to use
126 single DP relative instructions to load values out of the PLT. */
129 /* Note this is not strictly correct. We should create a stub section for
130 each input section with calls. The stub section should be placed before
131 the section with the call. */
134 bfd_vma text_segment_base
;
135 bfd_vma data_segment_base
;
137 /* We build tables to map from an input section back to its
138 symbol index. This is the BFD for which we currently have
140 bfd
*section_syms_bfd
;
142 /* Array of symbol numbers for each input section attached to the
147 #define hppa_link_hash_table(p) \
148 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
149 == HPPA64_ELF_DATA ? ((struct elf64_hppa_link_hash_table *) ((p)->hash)) : NULL)
151 #define hppa_elf_hash_entry(ent) \
152 ((struct elf64_hppa_link_hash_entry *)(ent))
154 #define eh_name(eh) \
155 (eh ? eh->root.root.string : "<undef>")
157 typedef struct bfd_hash_entry
*(*new_hash_entry_func
)
158 (struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *);
160 static struct bfd_link_hash_table
*elf64_hppa_hash_table_create
163 /* This must follow the definitions of the various derived linker
164 hash tables and shared functions. */
165 #include "elf-hppa.h"
167 static bfd_boolean elf64_hppa_object_p
170 static bfd_boolean elf64_hppa_create_dynamic_sections
171 (bfd
*, struct bfd_link_info
*);
173 static bfd_boolean elf64_hppa_adjust_dynamic_symbol
174 (struct bfd_link_info
*, struct elf_link_hash_entry
*);
176 static bfd_boolean elf64_hppa_mark_milli_and_exported_functions
177 (struct elf_link_hash_entry
*, void *);
179 static bfd_boolean elf64_hppa_size_dynamic_sections
180 (bfd
*, struct bfd_link_info
*);
182 static int elf64_hppa_link_output_symbol_hook
183 (struct bfd_link_info
*, const char *, Elf_Internal_Sym
*,
184 asection
*, struct elf_link_hash_entry
*);
186 static bfd_boolean elf64_hppa_finish_dynamic_symbol
187 (bfd
*, struct bfd_link_info
*,
188 struct elf_link_hash_entry
*, Elf_Internal_Sym
*);
190 static bfd_boolean elf64_hppa_finish_dynamic_sections
191 (bfd
*, struct bfd_link_info
*);
193 static bfd_boolean elf64_hppa_check_relocs
194 (bfd
*, struct bfd_link_info
*,
195 asection
*, const Elf_Internal_Rela
*);
197 static bfd_boolean elf64_hppa_dynamic_symbol_p
198 (struct elf_link_hash_entry
*, struct bfd_link_info
*);
200 static bfd_boolean elf64_hppa_mark_exported_functions
201 (struct elf_link_hash_entry
*, void *);
203 static bfd_boolean elf64_hppa_finalize_opd
204 (struct elf_link_hash_entry
*, void *);
206 static bfd_boolean elf64_hppa_finalize_dlt
207 (struct elf_link_hash_entry
*, void *);
209 static bfd_boolean allocate_global_data_dlt
210 (struct elf_link_hash_entry
*, void *);
212 static bfd_boolean allocate_global_data_plt
213 (struct elf_link_hash_entry
*, void *);
215 static bfd_boolean allocate_global_data_stub
216 (struct elf_link_hash_entry
*, void *);
218 static bfd_boolean allocate_global_data_opd
219 (struct elf_link_hash_entry
*, void *);
221 static bfd_boolean get_reloc_section
222 (bfd
*, struct elf64_hppa_link_hash_table
*, asection
*);
224 static bfd_boolean count_dyn_reloc
225 (bfd
*, struct elf64_hppa_link_hash_entry
*,
226 int, asection
*, int, bfd_vma
, bfd_vma
);
228 static bfd_boolean allocate_dynrel_entries
229 (struct elf_link_hash_entry
*, void *);
231 static bfd_boolean elf64_hppa_finalize_dynreloc
232 (struct elf_link_hash_entry
*, void *);
234 static bfd_boolean get_opd
235 (bfd
*, struct bfd_link_info
*, struct elf64_hppa_link_hash_table
*);
237 static bfd_boolean get_plt
238 (bfd
*, struct bfd_link_info
*, struct elf64_hppa_link_hash_table
*);
240 static bfd_boolean get_dlt
241 (bfd
*, struct bfd_link_info
*, struct elf64_hppa_link_hash_table
*);
243 static bfd_boolean get_stub
244 (bfd
*, struct bfd_link_info
*, struct elf64_hppa_link_hash_table
*);
246 static int elf64_hppa_elf_get_symbol_type
247 (Elf_Internal_Sym
*, int);
249 /* Initialize an entry in the link hash table. */
251 static struct bfd_hash_entry
*
252 hppa64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
253 struct bfd_hash_table
*table
,
256 /* Allocate the structure if it has not already been allocated by a
260 entry
= bfd_hash_allocate (table
,
261 sizeof (struct elf64_hppa_link_hash_entry
));
266 /* Call the allocation method of the superclass. */
267 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
270 struct elf64_hppa_link_hash_entry
*hh
;
272 /* Initialize our local data. All zeros. */
273 hh
= hppa_elf_hash_entry (entry
);
274 memset (&hh
->dlt_offset
, 0,
275 (sizeof (struct elf64_hppa_link_hash_entry
)
276 - offsetof (struct elf64_hppa_link_hash_entry
, dlt_offset
)));
282 /* Create the derived linker hash table. The PA64 ELF port uses this
283 derived hash table to keep information specific to the PA ElF
284 linker (without using static variables). */
286 static struct bfd_link_hash_table
*
287 elf64_hppa_hash_table_create (bfd
*abfd
)
289 struct elf64_hppa_link_hash_table
*htab
;
290 size_t amt
= sizeof (*htab
);
292 htab
= bfd_zmalloc (amt
);
296 if (!_bfd_elf_link_hash_table_init (&htab
->root
, abfd
,
297 hppa64_link_hash_newfunc
,
298 sizeof (struct elf64_hppa_link_hash_entry
),
305 htab
->text_segment_base
= (bfd_vma
) -1;
306 htab
->data_segment_base
= (bfd_vma
) -1;
308 return &htab
->root
.root
;
311 /* Return nonzero if ABFD represents a PA2.0 ELF64 file.
313 Additionally we set the default architecture and machine. */
315 elf64_hppa_object_p (bfd
*abfd
)
317 Elf_Internal_Ehdr
* i_ehdrp
;
320 i_ehdrp
= elf_elfheader (abfd
);
321 if (strcmp (bfd_get_target (abfd
), "elf64-hppa-linux") == 0)
323 /* GCC on hppa-linux produces binaries with OSABI=GNU,
324 but the kernel produces corefiles with OSABI=SysV. */
325 if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_GNU
326 && i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_NONE
) /* aka SYSV */
331 /* HPUX produces binaries with OSABI=HPUX,
332 but the kernel produces corefiles with OSABI=SysV. */
333 if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_HPUX
334 && i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_NONE
) /* aka SYSV */
338 flags
= i_ehdrp
->e_flags
;
339 switch (flags
& (EF_PARISC_ARCH
| EF_PARISC_WIDE
))
342 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 10);
344 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 11);
346 if (i_ehdrp
->e_ident
[EI_CLASS
] == ELFCLASS64
)
347 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 25);
349 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 20);
350 case EFA_PARISC_2_0
| EF_PARISC_WIDE
:
351 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 25);
353 /* Don't be fussy. */
357 /* Given section type (hdr->sh_type), return a boolean indicating
358 whether or not the section is an elf64-hppa specific section. */
360 elf64_hppa_section_from_shdr (bfd
*abfd
,
361 Elf_Internal_Shdr
*hdr
,
365 switch (hdr
->sh_type
)
368 if (strcmp (name
, ".PARISC.archext") != 0)
371 case SHT_PARISC_UNWIND
:
372 if (strcmp (name
, ".PARISC.unwind") != 0)
376 case SHT_PARISC_ANNOT
:
381 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
384 return ((hdr
->sh_flags
& SHF_PARISC_SHORT
) == 0
385 || bfd_set_section_flags (hdr
->bfd_section
,
386 hdr
->bfd_section
->flags
| SEC_SMALL_DATA
));
389 /* SEC is a section containing relocs for an input BFD when linking; return
390 a suitable section for holding relocs in the output BFD for a link. */
393 get_reloc_section (bfd
*abfd
,
394 struct elf64_hppa_link_hash_table
*hppa_info
,
397 const char *srel_name
;
401 srel_name
= (bfd_elf_string_from_elf_section
402 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
403 _bfd_elf_single_rel_hdr(sec
)->sh_name
));
404 if (srel_name
== NULL
)
407 dynobj
= hppa_info
->root
.dynobj
;
409 hppa_info
->root
.dynobj
= dynobj
= abfd
;
411 srel
= bfd_get_linker_section (dynobj
, srel_name
);
414 srel
= bfd_make_section_anyway_with_flags (dynobj
, srel_name
,
422 || !bfd_set_section_alignment (srel
, 3))
426 hppa_info
->other_rel_sec
= srel
;
430 /* Add a new entry to the list of dynamic relocations against DYN_H.
432 We use this to keep a record of all the FPTR relocations against a
433 particular symbol so that we can create FPTR relocations in the
437 count_dyn_reloc (bfd
*abfd
,
438 struct elf64_hppa_link_hash_entry
*hh
,
445 struct elf64_hppa_dyn_reloc_entry
*rent
;
447 rent
= (struct elf64_hppa_dyn_reloc_entry
*)
448 bfd_alloc (abfd
, (bfd_size_type
) sizeof (*rent
));
452 rent
->next
= hh
->reloc_entries
;
455 rent
->sec_symndx
= sec_symndx
;
456 rent
->offset
= offset
;
457 rent
->addend
= addend
;
458 hh
->reloc_entries
= rent
;
463 /* Return a pointer to the local DLT, PLT and OPD reference counts
464 for ABFD. Returns NULL if the storage allocation fails. */
466 static bfd_signed_vma
*
467 hppa64_elf_local_refcounts (bfd
*abfd
)
469 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
470 bfd_signed_vma
*local_refcounts
;
472 local_refcounts
= elf_local_got_refcounts (abfd
);
473 if (local_refcounts
== NULL
)
477 /* Allocate space for local DLT, PLT and OPD reference
478 counts. Done this way to save polluting elf_obj_tdata
479 with another target specific pointer. */
480 size
= symtab_hdr
->sh_info
;
481 size
*= 3 * sizeof (bfd_signed_vma
);
482 local_refcounts
= bfd_zalloc (abfd
, size
);
483 elf_local_got_refcounts (abfd
) = local_refcounts
;
485 return local_refcounts
;
488 /* Scan the RELOCS and record the type of dynamic entries that each
489 referenced symbol needs. */
492 elf64_hppa_check_relocs (bfd
*abfd
,
493 struct bfd_link_info
*info
,
495 const Elf_Internal_Rela
*relocs
)
497 struct elf64_hppa_link_hash_table
*hppa_info
;
498 const Elf_Internal_Rela
*relend
;
499 Elf_Internal_Shdr
*symtab_hdr
;
500 const Elf_Internal_Rela
*rel
;
501 unsigned int sec_symndx
;
503 if (bfd_link_relocatable (info
))
506 /* If this is the first dynamic object found in the link, create
507 the special sections required for dynamic linking. */
508 if (! elf_hash_table (info
)->dynamic_sections_created
)
510 if (! _bfd_elf_link_create_dynamic_sections (abfd
, info
))
514 hppa_info
= hppa_link_hash_table (info
);
515 if (hppa_info
== NULL
)
517 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
519 /* If necessary, build a new table holding section symbols indices
522 if (bfd_link_pic (info
) && hppa_info
->section_syms_bfd
!= abfd
)
525 unsigned int highest_shndx
;
526 Elf_Internal_Sym
*local_syms
= NULL
;
527 Elf_Internal_Sym
*isym
, *isymend
;
530 /* We're done with the old cache of section index to section symbol
531 index information. Free it.
533 ?!? Note we leak the last section_syms array. Presumably we
534 could free it in one of the later routines in this file. */
535 free (hppa_info
->section_syms
);
537 /* Read this BFD's local symbols. */
538 if (symtab_hdr
->sh_info
!= 0)
540 local_syms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
541 if (local_syms
== NULL
)
542 local_syms
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
543 symtab_hdr
->sh_info
, 0,
545 if (local_syms
== NULL
)
549 /* Record the highest section index referenced by the local symbols. */
551 isymend
= local_syms
+ symtab_hdr
->sh_info
;
552 for (isym
= local_syms
; isym
< isymend
; isym
++)
554 if (isym
->st_shndx
> highest_shndx
555 && isym
->st_shndx
< SHN_LORESERVE
)
556 highest_shndx
= isym
->st_shndx
;
559 /* Allocate an array to hold the section index to section symbol index
560 mapping. Bump by one since we start counting at zero. */
564 hppa_info
->section_syms
= (int *) bfd_malloc (amt
);
566 /* Now walk the local symbols again. If we find a section symbol,
567 record the index of the symbol into the section_syms array. */
568 for (i
= 0, isym
= local_syms
; isym
< isymend
; i
++, isym
++)
570 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
571 hppa_info
->section_syms
[isym
->st_shndx
] = i
;
574 /* We are finished with the local symbols. */
575 if (local_syms
!= NULL
576 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
578 if (! info
->keep_memory
)
582 /* Cache the symbols for elf_link_input_bfd. */
583 symtab_hdr
->contents
= (unsigned char *) local_syms
;
587 /* Record which BFD we built the section_syms mapping for. */
588 hppa_info
->section_syms_bfd
= abfd
;
591 /* Record the symbol index for this input section. We may need it for
592 relocations when building shared libraries. When not building shared
593 libraries this value is never really used, but assign it to zero to
594 prevent out of bounds memory accesses in other routines. */
595 if (bfd_link_pic (info
))
597 sec_symndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
599 /* If we did not find a section symbol for this section, then
600 something went terribly wrong above. */
601 if (sec_symndx
== SHN_BAD
)
604 if (sec_symndx
< SHN_LORESERVE
)
605 sec_symndx
= hppa_info
->section_syms
[sec_symndx
];
612 relend
= relocs
+ sec
->reloc_count
;
613 for (rel
= relocs
; rel
< relend
; ++rel
)
624 unsigned long r_symndx
= ELF64_R_SYM (rel
->r_info
);
625 struct elf64_hppa_link_hash_entry
*hh
;
627 bfd_boolean maybe_dynamic
;
628 int dynrel_type
= R_PARISC_NONE
;
629 static reloc_howto_type
*howto
;
631 if (r_symndx
>= symtab_hdr
->sh_info
)
633 /* We're dealing with a global symbol -- find its hash entry
634 and mark it as being referenced. */
635 long indx
= r_symndx
- symtab_hdr
->sh_info
;
636 hh
= hppa_elf_hash_entry (elf_sym_hashes (abfd
)[indx
]);
637 while (hh
->eh
.root
.type
== bfd_link_hash_indirect
638 || hh
->eh
.root
.type
== bfd_link_hash_warning
)
639 hh
= hppa_elf_hash_entry (hh
->eh
.root
.u
.i
.link
);
641 /* PR15323, ref flags aren't set for references in the same
643 hh
->eh
.ref_regular
= 1;
648 /* We can only get preliminary data on whether a symbol is
649 locally or externally defined, as not all of the input files
650 have yet been processed. Do something with what we know, as
651 this may help reduce memory usage and processing time later. */
652 maybe_dynamic
= FALSE
;
653 if (hh
&& ((bfd_link_pic (info
)
655 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
656 || !hh
->eh
.def_regular
657 || hh
->eh
.root
.type
== bfd_link_hash_defweak
))
658 maybe_dynamic
= TRUE
;
660 howto
= elf_hppa_howto_table
+ ELF64_R_TYPE (rel
->r_info
);
664 /* These are simple indirect references to symbols through the
665 DLT. We need to create a DLT entry for any symbols which
666 appears in a DLTIND relocation. */
667 case R_PARISC_DLTIND21L
:
668 case R_PARISC_DLTIND14R
:
669 case R_PARISC_DLTIND14F
:
670 case R_PARISC_DLTIND14WR
:
671 case R_PARISC_DLTIND14DR
:
672 need_entry
= NEED_DLT
;
675 /* ?!? These need a DLT entry. But I have no idea what to do with
676 the "link time TP value. */
677 case R_PARISC_LTOFF_TP21L
:
678 case R_PARISC_LTOFF_TP14R
:
679 case R_PARISC_LTOFF_TP14F
:
680 case R_PARISC_LTOFF_TP64
:
681 case R_PARISC_LTOFF_TP14WR
:
682 case R_PARISC_LTOFF_TP14DR
:
683 case R_PARISC_LTOFF_TP16F
:
684 case R_PARISC_LTOFF_TP16WF
:
685 case R_PARISC_LTOFF_TP16DF
:
686 need_entry
= NEED_DLT
;
689 /* These are function calls. Depending on their precise target we
690 may need to make a stub for them. The stub uses the PLT, so we
691 need to create PLT entries for these symbols too. */
692 case R_PARISC_PCREL12F
:
693 case R_PARISC_PCREL17F
:
694 case R_PARISC_PCREL22F
:
695 case R_PARISC_PCREL32
:
696 case R_PARISC_PCREL64
:
697 case R_PARISC_PCREL21L
:
698 case R_PARISC_PCREL17R
:
699 case R_PARISC_PCREL17C
:
700 case R_PARISC_PCREL14R
:
701 case R_PARISC_PCREL14F
:
702 case R_PARISC_PCREL22C
:
703 case R_PARISC_PCREL14WR
:
704 case R_PARISC_PCREL14DR
:
705 case R_PARISC_PCREL16F
:
706 case R_PARISC_PCREL16WF
:
707 case R_PARISC_PCREL16DF
:
708 /* Function calls might need to go through the .plt, and
709 might need a long branch stub. */
710 if (hh
!= NULL
&& hh
->eh
.type
!= STT_PARISC_MILLI
)
711 need_entry
= (NEED_PLT
| NEED_STUB
);
716 case R_PARISC_PLTOFF21L
:
717 case R_PARISC_PLTOFF14R
:
718 case R_PARISC_PLTOFF14F
:
719 case R_PARISC_PLTOFF14WR
:
720 case R_PARISC_PLTOFF14DR
:
721 case R_PARISC_PLTOFF16F
:
722 case R_PARISC_PLTOFF16WF
:
723 case R_PARISC_PLTOFF16DF
:
724 need_entry
= (NEED_PLT
);
728 if (bfd_link_pic (info
) || maybe_dynamic
)
729 need_entry
= (NEED_DYNREL
);
730 dynrel_type
= R_PARISC_DIR64
;
733 /* This is an indirect reference through the DLT to get the address
734 of a OPD descriptor. Thus we need to make a DLT entry that points
736 case R_PARISC_LTOFF_FPTR21L
:
737 case R_PARISC_LTOFF_FPTR14R
:
738 case R_PARISC_LTOFF_FPTR14WR
:
739 case R_PARISC_LTOFF_FPTR14DR
:
740 case R_PARISC_LTOFF_FPTR32
:
741 case R_PARISC_LTOFF_FPTR64
:
742 case R_PARISC_LTOFF_FPTR16F
:
743 case R_PARISC_LTOFF_FPTR16WF
:
744 case R_PARISC_LTOFF_FPTR16DF
:
745 if (bfd_link_pic (info
) || maybe_dynamic
)
746 need_entry
= (NEED_DLT
| NEED_OPD
| NEED_PLT
);
748 need_entry
= (NEED_DLT
| NEED_OPD
| NEED_PLT
);
749 dynrel_type
= R_PARISC_FPTR64
;
752 /* This is a simple OPD entry. */
753 case R_PARISC_FPTR64
:
754 if (bfd_link_pic (info
) || maybe_dynamic
)
755 need_entry
= (NEED_OPD
| NEED_PLT
| NEED_DYNREL
);
757 need_entry
= (NEED_OPD
| NEED_PLT
);
758 dynrel_type
= R_PARISC_FPTR64
;
761 /* Add more cases as needed. */
769 /* Stash away enough information to be able to find this symbol
770 regardless of whether or not it is local or global. */
772 hh
->sym_indx
= r_symndx
;
775 /* Create what's needed. */
776 if (need_entry
& NEED_DLT
)
778 /* Allocate space for a DLT entry, as well as a dynamic
779 relocation for this entry. */
780 if (! hppa_info
->dlt_sec
781 && ! get_dlt (abfd
, info
, hppa_info
))
787 hh
->eh
.got
.refcount
+= 1;
791 bfd_signed_vma
*local_dlt_refcounts
;
793 /* This is a DLT entry for a local symbol. */
794 local_dlt_refcounts
= hppa64_elf_local_refcounts (abfd
);
795 if (local_dlt_refcounts
== NULL
)
797 local_dlt_refcounts
[r_symndx
] += 1;
801 if (need_entry
& NEED_PLT
)
803 if (! hppa_info
->root
.splt
804 && ! get_plt (abfd
, info
, hppa_info
))
810 hh
->eh
.needs_plt
= 1;
811 hh
->eh
.plt
.refcount
+= 1;
815 bfd_signed_vma
*local_dlt_refcounts
;
816 bfd_signed_vma
*local_plt_refcounts
;
818 /* This is a PLT entry for a local symbol. */
819 local_dlt_refcounts
= hppa64_elf_local_refcounts (abfd
);
820 if (local_dlt_refcounts
== NULL
)
822 local_plt_refcounts
= local_dlt_refcounts
+ symtab_hdr
->sh_info
;
823 local_plt_refcounts
[r_symndx
] += 1;
827 if (need_entry
& NEED_STUB
)
829 if (! hppa_info
->stub_sec
830 && ! get_stub (abfd
, info
, hppa_info
))
836 if (need_entry
& NEED_OPD
)
838 if (! hppa_info
->opd_sec
839 && ! get_opd (abfd
, info
, hppa_info
))
842 /* FPTRs are not allocated by the dynamic linker for PA64,
843 though it is possible that will change in the future. */
849 bfd_signed_vma
*local_dlt_refcounts
;
850 bfd_signed_vma
*local_opd_refcounts
;
852 /* This is a OPD for a local symbol. */
853 local_dlt_refcounts
= hppa64_elf_local_refcounts (abfd
);
854 if (local_dlt_refcounts
== NULL
)
856 local_opd_refcounts
= (local_dlt_refcounts
857 + 2 * symtab_hdr
->sh_info
);
858 local_opd_refcounts
[r_symndx
] += 1;
862 /* Add a new dynamic relocation to the chain of dynamic
863 relocations for this symbol. */
864 if ((need_entry
& NEED_DYNREL
) && (sec
->flags
& SEC_ALLOC
))
866 if (! hppa_info
->other_rel_sec
867 && ! get_reloc_section (abfd
, hppa_info
, sec
))
870 /* Count dynamic relocations against global symbols. */
872 && !count_dyn_reloc (abfd
, hh
, dynrel_type
, sec
,
873 sec_symndx
, rel
->r_offset
, rel
->r_addend
))
876 /* If we are building a shared library and we just recorded
877 a dynamic R_PARISC_FPTR64 relocation, then make sure the
878 section symbol for this section ends up in the dynamic
880 if (bfd_link_pic (info
) && dynrel_type
== R_PARISC_FPTR64
881 && ! (bfd_elf_link_record_local_dynamic_symbol
882 (info
, abfd
, sec_symndx
)))
893 struct elf64_hppa_allocate_data
895 struct bfd_link_info
*info
;
899 /* Should we do dynamic things to this symbol? */
902 elf64_hppa_dynamic_symbol_p (struct elf_link_hash_entry
*eh
,
903 struct bfd_link_info
*info
)
905 /* ??? What, if anything, needs to happen wrt STV_PROTECTED symbols
906 and relocations that retrieve a function descriptor? Assume the
908 if (_bfd_elf_dynamic_symbol_p (eh
, info
, 1))
910 /* ??? Why is this here and not elsewhere is_local_label_name. */
911 if (eh
->root
.root
.string
[0] == '$' && eh
->root
.root
.string
[1] == '$')
920 /* Mark all functions exported by this file so that we can later allocate
921 entries in .opd for them. */
924 elf64_hppa_mark_exported_functions (struct elf_link_hash_entry
*eh
, void *data
)
926 struct elf64_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
927 struct bfd_link_info
*info
= (struct bfd_link_info
*)data
;
928 struct elf64_hppa_link_hash_table
*hppa_info
;
930 hppa_info
= hppa_link_hash_table (info
);
931 if (hppa_info
== NULL
)
935 && (eh
->root
.type
== bfd_link_hash_defined
936 || eh
->root
.type
== bfd_link_hash_defweak
)
937 && eh
->root
.u
.def
.section
->output_section
!= NULL
938 && eh
->type
== STT_FUNC
)
940 if (! hppa_info
->opd_sec
941 && ! get_opd (hppa_info
->root
.dynobj
, info
, hppa_info
))
946 /* Put a flag here for output_symbol_hook. */
954 /* Allocate space for a DLT entry. */
957 allocate_global_data_dlt (struct elf_link_hash_entry
*eh
, void *data
)
959 struct elf64_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
960 struct elf64_hppa_allocate_data
*x
= (struct elf64_hppa_allocate_data
*)data
;
964 if (bfd_link_pic (x
->info
))
966 /* Possibly add the symbol to the local dynamic symbol
967 table since we might need to create a dynamic relocation
969 if (eh
->dynindx
== -1 && eh
->type
!= STT_PARISC_MILLI
)
971 bfd
*owner
= eh
->root
.u
.def
.section
->owner
;
973 if (! (bfd_elf_link_record_local_dynamic_symbol
974 (x
->info
, owner
, hh
->sym_indx
)))
979 hh
->dlt_offset
= x
->ofs
;
980 x
->ofs
+= DLT_ENTRY_SIZE
;
985 /* Allocate space for a DLT.PLT entry. */
988 allocate_global_data_plt (struct elf_link_hash_entry
*eh
, void *data
)
990 struct elf64_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
991 struct elf64_hppa_allocate_data
*x
= (struct elf64_hppa_allocate_data
*) data
;
994 && elf64_hppa_dynamic_symbol_p (eh
, x
->info
)
995 && !((eh
->root
.type
== bfd_link_hash_defined
996 || eh
->root
.type
== bfd_link_hash_defweak
)
997 && eh
->root
.u
.def
.section
->output_section
!= NULL
))
999 hh
->plt_offset
= x
->ofs
;
1000 x
->ofs
+= PLT_ENTRY_SIZE
;
1001 if (hh
->plt_offset
< 0x2000)
1003 struct elf64_hppa_link_hash_table
*hppa_info
;
1005 hppa_info
= hppa_link_hash_table (x
->info
);
1006 if (hppa_info
== NULL
)
1009 hppa_info
->gp_offset
= hh
->plt_offset
;
1018 /* Allocate space for a STUB entry. */
1021 allocate_global_data_stub (struct elf_link_hash_entry
*eh
, void *data
)
1023 struct elf64_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
1024 struct elf64_hppa_allocate_data
*x
= (struct elf64_hppa_allocate_data
*)data
;
1027 && elf64_hppa_dynamic_symbol_p (eh
, x
->info
)
1028 && !((eh
->root
.type
== bfd_link_hash_defined
1029 || eh
->root
.type
== bfd_link_hash_defweak
)
1030 && eh
->root
.u
.def
.section
->output_section
!= NULL
))
1032 hh
->stub_offset
= x
->ofs
;
1033 x
->ofs
+= sizeof (plt_stub
);
1040 /* Allocate space for a FPTR entry. */
1043 allocate_global_data_opd (struct elf_link_hash_entry
*eh
, void *data
)
1045 struct elf64_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
1046 struct elf64_hppa_allocate_data
*x
= (struct elf64_hppa_allocate_data
*)data
;
1048 if (hh
&& hh
->want_opd
)
1050 /* We never need an opd entry for a symbol which is not
1051 defined by this output file. */
1052 if (hh
&& (hh
->eh
.root
.type
== bfd_link_hash_undefined
1053 || hh
->eh
.root
.type
== bfd_link_hash_undefweak
1054 || hh
->eh
.root
.u
.def
.section
->output_section
== NULL
))
1057 /* If we are creating a shared library, took the address of a local
1058 function or might export this function from this object file, then
1059 we have to create an opd descriptor. */
1060 else if (bfd_link_pic (x
->info
)
1062 || (hh
->eh
.dynindx
== -1 && hh
->eh
.type
!= STT_PARISC_MILLI
)
1063 || (hh
->eh
.root
.type
== bfd_link_hash_defined
1064 || hh
->eh
.root
.type
== bfd_link_hash_defweak
))
1066 /* If we are creating a shared library, then we will have to
1067 create a runtime relocation for the symbol to properly
1068 initialize the .opd entry. Make sure the symbol gets
1069 added to the dynamic symbol table. */
1070 if (bfd_link_pic (x
->info
)
1071 && (hh
== NULL
|| (hh
->eh
.dynindx
== -1)))
1074 /* PR 6511: Default to using the dynamic symbol table. */
1075 owner
= (hh
->owner
? hh
->owner
: eh
->root
.u
.def
.section
->owner
);
1077 if (!bfd_elf_link_record_local_dynamic_symbol
1078 (x
->info
, owner
, hh
->sym_indx
))
1082 /* This may not be necessary or desirable anymore now that
1083 we have some support for dealing with section symbols
1084 in dynamic relocs. But name munging does make the result
1085 much easier to debug. ie, the EPLT reloc will reference
1086 a symbol like .foobar, instead of .text + offset. */
1087 if (bfd_link_pic (x
->info
) && eh
)
1090 struct elf_link_hash_entry
*nh
;
1092 new_name
= concat (".", eh
->root
.root
.string
, NULL
);
1094 nh
= elf_link_hash_lookup (elf_hash_table (x
->info
),
1095 new_name
, TRUE
, TRUE
, TRUE
);
1098 nh
->root
.type
= eh
->root
.type
;
1099 nh
->root
.u
.def
.value
= eh
->root
.u
.def
.value
;
1100 nh
->root
.u
.def
.section
= eh
->root
.u
.def
.section
;
1102 if (! bfd_elf_link_record_dynamic_symbol (x
->info
, nh
))
1105 hh
->opd_offset
= x
->ofs
;
1106 x
->ofs
+= OPD_ENTRY_SIZE
;
1109 /* Otherwise we do not need an opd entry. */
1116 /* HP requires the EI_OSABI field to be filled in. The assignment to
1117 EI_ABIVERSION may not be strictly necessary. */
1120 elf64_hppa_init_file_header (bfd
*abfd
, struct bfd_link_info
*info
)
1122 Elf_Internal_Ehdr
*i_ehdrp
;
1124 if (!_bfd_elf_init_file_header (abfd
, info
))
1127 i_ehdrp
= elf_elfheader (abfd
);
1128 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
1129 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 1;
1133 /* Create function descriptor section (.opd). This section is called .opd
1134 because it contains "official procedure descriptors". The "official"
1135 refers to the fact that these descriptors are used when taking the address
1136 of a procedure, thus ensuring a unique address for each procedure. */
1140 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1141 struct elf64_hppa_link_hash_table
*hppa_info
)
1146 opd
= hppa_info
->opd_sec
;
1149 dynobj
= hppa_info
->root
.dynobj
;
1151 hppa_info
->root
.dynobj
= dynobj
= abfd
;
1153 opd
= bfd_make_section_anyway_with_flags (dynobj
, ".opd",
1158 | SEC_LINKER_CREATED
));
1160 || !bfd_set_section_alignment (opd
, 3))
1166 hppa_info
->opd_sec
= opd
;
1172 /* Create the PLT section. */
1176 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1177 struct elf64_hppa_link_hash_table
*hppa_info
)
1182 plt
= hppa_info
->root
.splt
;
1185 dynobj
= hppa_info
->root
.dynobj
;
1187 hppa_info
->root
.dynobj
= dynobj
= abfd
;
1189 plt
= bfd_make_section_anyway_with_flags (dynobj
, ".plt",
1194 | SEC_LINKER_CREATED
));
1196 || !bfd_set_section_alignment (plt
, 3))
1202 hppa_info
->root
.splt
= plt
;
1208 /* Create the DLT section. */
1212 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1213 struct elf64_hppa_link_hash_table
*hppa_info
)
1218 dlt
= hppa_info
->dlt_sec
;
1221 dynobj
= hppa_info
->root
.dynobj
;
1223 hppa_info
->root
.dynobj
= dynobj
= abfd
;
1225 dlt
= bfd_make_section_anyway_with_flags (dynobj
, ".dlt",
1230 | SEC_LINKER_CREATED
));
1232 || !bfd_set_section_alignment (dlt
, 3))
1238 hppa_info
->dlt_sec
= dlt
;
1244 /* Create the stubs section. */
1247 get_stub (bfd
*abfd
,
1248 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1249 struct elf64_hppa_link_hash_table
*hppa_info
)
1254 stub
= hppa_info
->stub_sec
;
1257 dynobj
= hppa_info
->root
.dynobj
;
1259 hppa_info
->root
.dynobj
= dynobj
= abfd
;
1261 stub
= bfd_make_section_anyway_with_flags (dynobj
, ".stub",
1262 (SEC_ALLOC
| SEC_LOAD
1266 | SEC_LINKER_CREATED
));
1268 || !bfd_set_section_alignment (stub
, 3))
1274 hppa_info
->stub_sec
= stub
;
1280 /* Create sections necessary for dynamic linking. This is only a rough
1281 cut and will likely change as we learn more about the somewhat
1282 unusual dynamic linking scheme HP uses.
1285 Contains code to implement cross-space calls. The first time one
1286 of the stubs is used it will call into the dynamic linker, later
1287 calls will go straight to the target.
1289 The only stub we support right now looks like
1293 ldd OFFSET+8(%dp),%dp
1295 Other stubs may be needed in the future. We may want the remove
1296 the break/nop instruction. It is only used right now to keep the
1297 offset of a .plt entry and a .stub entry in sync.
1300 This is what most people call the .got. HP used a different name.
1304 Relocations for the DLT.
1307 Function pointers as address,gp pairs.
1310 Should contain dynamic IPLT (and EPLT?) relocations.
1316 EPLT relocations for symbols exported from shared libraries. */
1319 elf64_hppa_create_dynamic_sections (bfd
*abfd
,
1320 struct bfd_link_info
*info
)
1323 struct elf64_hppa_link_hash_table
*hppa_info
;
1325 hppa_info
= hppa_link_hash_table (info
);
1326 if (hppa_info
== NULL
)
1329 if (! get_stub (abfd
, info
, hppa_info
))
1332 if (! get_dlt (abfd
, info
, hppa_info
))
1335 if (! get_plt (abfd
, info
, hppa_info
))
1338 if (! get_opd (abfd
, info
, hppa_info
))
1341 s
= bfd_make_section_anyway_with_flags (abfd
, ".rela.dlt",
1342 (SEC_ALLOC
| SEC_LOAD
1346 | SEC_LINKER_CREATED
));
1348 || !bfd_set_section_alignment (s
, 3))
1350 hppa_info
->dlt_rel_sec
= s
;
1352 s
= bfd_make_section_anyway_with_flags (abfd
, ".rela.plt",
1353 (SEC_ALLOC
| SEC_LOAD
1357 | SEC_LINKER_CREATED
));
1359 || !bfd_set_section_alignment (s
, 3))
1361 hppa_info
->root
.srelplt
= s
;
1363 s
= bfd_make_section_anyway_with_flags (abfd
, ".rela.data",
1364 (SEC_ALLOC
| SEC_LOAD
1368 | SEC_LINKER_CREATED
));
1370 || !bfd_set_section_alignment (s
, 3))
1372 hppa_info
->other_rel_sec
= s
;
1374 s
= bfd_make_section_anyway_with_flags (abfd
, ".rela.opd",
1375 (SEC_ALLOC
| SEC_LOAD
1379 | SEC_LINKER_CREATED
));
1381 || !bfd_set_section_alignment (s
, 3))
1383 hppa_info
->opd_rel_sec
= s
;
1388 /* Allocate dynamic relocations for those symbols that turned out
1392 allocate_dynrel_entries (struct elf_link_hash_entry
*eh
, void *data
)
1394 struct elf64_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
1395 struct elf64_hppa_allocate_data
*x
= (struct elf64_hppa_allocate_data
*)data
;
1396 struct elf64_hppa_link_hash_table
*hppa_info
;
1397 struct elf64_hppa_dyn_reloc_entry
*rent
;
1398 bfd_boolean dynamic_symbol
, shared
;
1400 hppa_info
= hppa_link_hash_table (x
->info
);
1401 if (hppa_info
== NULL
)
1404 dynamic_symbol
= elf64_hppa_dynamic_symbol_p (eh
, x
->info
);
1405 shared
= bfd_link_pic (x
->info
);
1407 /* We may need to allocate relocations for a non-dynamic symbol
1408 when creating a shared library. */
1409 if (!dynamic_symbol
&& !shared
)
1412 /* Take care of the normal data relocations. */
1414 for (rent
= hh
->reloc_entries
; rent
; rent
= rent
->next
)
1416 /* Allocate one iff we are building a shared library, the relocation
1417 isn't a R_PARISC_FPTR64, or we don't want an opd entry. */
1418 if (!shared
&& rent
->type
== R_PARISC_FPTR64
&& hh
->want_opd
)
1421 hppa_info
->other_rel_sec
->size
+= sizeof (Elf64_External_Rela
);
1423 /* Make sure this symbol gets into the dynamic symbol table if it is
1424 not already recorded. ?!? This should not be in the loop since
1425 the symbol need only be added once. */
1426 if (eh
->dynindx
== -1 && eh
->type
!= STT_PARISC_MILLI
)
1427 if (!bfd_elf_link_record_local_dynamic_symbol
1428 (x
->info
, rent
->sec
->owner
, hh
->sym_indx
))
1432 /* Take care of the GOT and PLT relocations. */
1434 if ((dynamic_symbol
|| shared
) && hh
->want_dlt
)
1435 hppa_info
->dlt_rel_sec
->size
+= sizeof (Elf64_External_Rela
);
1437 /* If we are building a shared library, then every symbol that has an
1438 opd entry will need an EPLT relocation to relocate the symbol's address
1439 and __gp value based on the runtime load address. */
1440 if (shared
&& hh
->want_opd
)
1441 hppa_info
->opd_rel_sec
->size
+= sizeof (Elf64_External_Rela
);
1443 if (hh
->want_plt
&& dynamic_symbol
)
1445 bfd_size_type t
= 0;
1447 /* Dynamic symbols get one IPLT relocation. Local symbols in
1448 shared libraries get two REL relocations. Local symbols in
1449 main applications get nothing. */
1451 t
= sizeof (Elf64_External_Rela
);
1453 t
= 2 * sizeof (Elf64_External_Rela
);
1455 hppa_info
->root
.srelplt
->size
+= t
;
1461 /* Adjust a symbol defined by a dynamic object and referenced by a
1465 elf64_hppa_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1466 struct elf_link_hash_entry
*eh
)
1468 /* ??? Undefined symbols with PLT entries should be re-defined
1469 to be the PLT entry. */
1471 /* If this is a weak symbol, and there is a real definition, the
1472 processor independent code will have arranged for us to see the
1473 real definition first, and we can just use the same value. */
1474 if (eh
->is_weakalias
)
1476 struct elf_link_hash_entry
*def
= weakdef (eh
);
1477 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1478 eh
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1479 eh
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1483 /* If this is a reference to a symbol defined by a dynamic object which
1484 is not a function, we might allocate the symbol in our .dynbss section
1485 and allocate a COPY dynamic relocation.
1487 But PA64 code is canonically PIC, so as a rule we can avoid this sort
1493 /* This function is called via elf_link_hash_traverse to mark millicode
1494 symbols with a dynindx of -1 and to remove the string table reference
1495 from the dynamic symbol table. If the symbol is not a millicode symbol,
1496 elf64_hppa_mark_exported_functions is called. */
1499 elf64_hppa_mark_milli_and_exported_functions (struct elf_link_hash_entry
*eh
,
1502 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
1504 if (eh
->type
== STT_PARISC_MILLI
)
1506 if (eh
->dynindx
!= -1)
1509 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1515 return elf64_hppa_mark_exported_functions (eh
, data
);
1518 /* Set the final sizes of the dynamic sections and allocate memory for
1519 the contents of our special sections. */
1522 elf64_hppa_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
1524 struct elf64_hppa_link_hash_table
*hppa_info
;
1525 struct elf64_hppa_allocate_data data
;
1531 bfd_boolean reltext
;
1533 hppa_info
= hppa_link_hash_table (info
);
1534 if (hppa_info
== NULL
)
1537 dynobj
= hppa_info
->root
.dynobj
;
1538 BFD_ASSERT (dynobj
!= NULL
);
1540 /* Mark each function this program exports so that we will allocate
1541 space in the .opd section for each function's FPTR. If we are
1542 creating dynamic sections, change the dynamic index of millicode
1543 symbols to -1 and remove them from the string table for .dynstr.
1545 We have to traverse the main linker hash table since we have to
1546 find functions which may not have been mentioned in any relocs. */
1547 elf_link_hash_traverse (&hppa_info
->root
,
1548 (hppa_info
->root
.dynamic_sections_created
1549 ? elf64_hppa_mark_milli_and_exported_functions
1550 : elf64_hppa_mark_exported_functions
),
1553 if (hppa_info
->root
.dynamic_sections_created
)
1555 /* Set the contents of the .interp section to the interpreter. */
1556 if (bfd_link_executable (info
) && !info
->nointerp
)
1558 sec
= bfd_get_linker_section (dynobj
, ".interp");
1559 BFD_ASSERT (sec
!= NULL
);
1560 sec
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1561 sec
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1566 /* We may have created entries in the .rela.got section.
1567 However, if we are not creating the dynamic sections, we will
1568 not actually use these entries. Reset the size of .rela.dlt,
1569 which will cause it to get stripped from the output file
1571 sec
= hppa_info
->dlt_rel_sec
;
1576 /* Set up DLT, PLT and OPD offsets for local syms, and space for local
1578 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
1580 bfd_signed_vma
*local_dlt
;
1581 bfd_signed_vma
*end_local_dlt
;
1582 bfd_signed_vma
*local_plt
;
1583 bfd_signed_vma
*end_local_plt
;
1584 bfd_signed_vma
*local_opd
;
1585 bfd_signed_vma
*end_local_opd
;
1586 bfd_size_type locsymcount
;
1587 Elf_Internal_Shdr
*symtab_hdr
;
1590 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
1593 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
1595 struct elf64_hppa_dyn_reloc_entry
*hdh_p
;
1597 for (hdh_p
= ((struct elf64_hppa_dyn_reloc_entry
*)
1598 elf_section_data (sec
)->local_dynrel
);
1600 hdh_p
= hdh_p
->next
)
1602 if (!bfd_is_abs_section (hdh_p
->sec
)
1603 && bfd_is_abs_section (hdh_p
->sec
->output_section
))
1605 /* Input section has been discarded, either because
1606 it is a copy of a linkonce section or due to
1607 linker script /DISCARD/, so we'll be discarding
1610 else if (hdh_p
->count
!= 0)
1612 srel
= elf_section_data (hdh_p
->sec
)->sreloc
;
1613 srel
->size
+= hdh_p
->count
* sizeof (Elf64_External_Rela
);
1614 if ((hdh_p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1615 info
->flags
|= DF_TEXTREL
;
1620 local_dlt
= elf_local_got_refcounts (ibfd
);
1624 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1625 locsymcount
= symtab_hdr
->sh_info
;
1626 end_local_dlt
= local_dlt
+ locsymcount
;
1627 sec
= hppa_info
->dlt_sec
;
1628 srel
= hppa_info
->dlt_rel_sec
;
1629 for (; local_dlt
< end_local_dlt
; ++local_dlt
)
1633 *local_dlt
= sec
->size
;
1634 sec
->size
+= DLT_ENTRY_SIZE
;
1635 if (bfd_link_pic (info
))
1637 srel
->size
+= sizeof (Elf64_External_Rela
);
1641 *local_dlt
= (bfd_vma
) -1;
1644 local_plt
= end_local_dlt
;
1645 end_local_plt
= local_plt
+ locsymcount
;
1646 if (! hppa_info
->root
.dynamic_sections_created
)
1648 /* Won't be used, but be safe. */
1649 for (; local_plt
< end_local_plt
; ++local_plt
)
1650 *local_plt
= (bfd_vma
) -1;
1654 sec
= hppa_info
->root
.splt
;
1655 srel
= hppa_info
->root
.srelplt
;
1656 for (; local_plt
< end_local_plt
; ++local_plt
)
1660 *local_plt
= sec
->size
;
1661 sec
->size
+= PLT_ENTRY_SIZE
;
1662 if (bfd_link_pic (info
))
1663 srel
->size
+= sizeof (Elf64_External_Rela
);
1666 *local_plt
= (bfd_vma
) -1;
1670 local_opd
= end_local_plt
;
1671 end_local_opd
= local_opd
+ locsymcount
;
1672 if (! hppa_info
->root
.dynamic_sections_created
)
1674 /* Won't be used, but be safe. */
1675 for (; local_opd
< end_local_opd
; ++local_opd
)
1676 *local_opd
= (bfd_vma
) -1;
1680 sec
= hppa_info
->opd_sec
;
1681 srel
= hppa_info
->opd_rel_sec
;
1682 for (; local_opd
< end_local_opd
; ++local_opd
)
1686 *local_opd
= sec
->size
;
1687 sec
->size
+= OPD_ENTRY_SIZE
;
1688 if (bfd_link_pic (info
))
1689 srel
->size
+= sizeof (Elf64_External_Rela
);
1692 *local_opd
= (bfd_vma
) -1;
1697 /* Allocate the GOT entries. */
1700 if (hppa_info
->dlt_sec
)
1702 data
.ofs
= hppa_info
->dlt_sec
->size
;
1703 elf_link_hash_traverse (&hppa_info
->root
,
1704 allocate_global_data_dlt
, &data
);
1705 hppa_info
->dlt_sec
->size
= data
.ofs
;
1708 if (hppa_info
->root
.splt
)
1710 data
.ofs
= hppa_info
->root
.splt
->size
;
1711 elf_link_hash_traverse (&hppa_info
->root
,
1712 allocate_global_data_plt
, &data
);
1713 hppa_info
->root
.splt
->size
= data
.ofs
;
1716 if (hppa_info
->stub_sec
)
1719 elf_link_hash_traverse (&hppa_info
->root
,
1720 allocate_global_data_stub
, &data
);
1721 hppa_info
->stub_sec
->size
= data
.ofs
;
1724 /* Allocate space for entries in the .opd section. */
1725 if (hppa_info
->opd_sec
)
1727 data
.ofs
= hppa_info
->opd_sec
->size
;
1728 elf_link_hash_traverse (&hppa_info
->root
,
1729 allocate_global_data_opd
, &data
);
1730 hppa_info
->opd_sec
->size
= data
.ofs
;
1733 /* Now allocate space for dynamic relocations, if necessary. */
1734 if (hppa_info
->root
.dynamic_sections_created
)
1735 elf_link_hash_traverse (&hppa_info
->root
,
1736 allocate_dynrel_entries
, &data
);
1738 /* The sizes of all the sections are set. Allocate memory for them. */
1742 for (sec
= dynobj
->sections
; sec
!= NULL
; sec
= sec
->next
)
1746 if ((sec
->flags
& SEC_LINKER_CREATED
) == 0)
1749 /* It's OK to base decisions on the section name, because none
1750 of the dynobj section names depend upon the input files. */
1751 name
= bfd_section_name (sec
);
1753 if (strcmp (name
, ".plt") == 0)
1755 /* Remember whether there is a PLT. */
1756 plt
= sec
->size
!= 0;
1758 else if (strcmp (name
, ".opd") == 0
1759 || CONST_STRNEQ (name
, ".dlt")
1760 || strcmp (name
, ".stub") == 0
1761 || strcmp (name
, ".got") == 0)
1763 /* Strip this section if we don't need it; see the comment below. */
1765 else if (CONST_STRNEQ (name
, ".rela"))
1771 /* Remember whether there are any reloc sections other
1773 if (strcmp (name
, ".rela.plt") != 0)
1775 const char *outname
;
1779 /* If this relocation section applies to a read only
1780 section, then we probably need a DT_TEXTREL
1781 entry. The entries in the .rela.plt section
1782 really apply to the .got section, which we
1783 created ourselves and so know is not readonly. */
1784 outname
= bfd_section_name (sec
->output_section
);
1785 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
1787 && (target
->flags
& SEC_READONLY
) != 0
1788 && (target
->flags
& SEC_ALLOC
) != 0)
1792 /* We use the reloc_count field as a counter if we need
1793 to copy relocs into the output file. */
1794 sec
->reloc_count
= 0;
1799 /* It's not one of our sections, so don't allocate space. */
1805 /* If we don't need this section, strip it from the
1806 output file. This is mostly to handle .rela.bss and
1807 .rela.plt. We must create both sections in
1808 create_dynamic_sections, because they must be created
1809 before the linker maps input sections to output
1810 sections. The linker does that before
1811 adjust_dynamic_symbol is called, and it is that
1812 function which decides whether anything needs to go
1813 into these sections. */
1814 sec
->flags
|= SEC_EXCLUDE
;
1818 if ((sec
->flags
& SEC_HAS_CONTENTS
) == 0)
1821 /* Allocate memory for the section contents if it has not
1822 been allocated already. We use bfd_zalloc here in case
1823 unused entries are not reclaimed before the section's
1824 contents are written out. This should not happen, but this
1825 way if it does, we get a R_PARISC_NONE reloc instead of
1827 if (sec
->contents
== NULL
)
1829 sec
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, sec
->size
);
1830 if (sec
->contents
== NULL
)
1835 if (hppa_info
->root
.dynamic_sections_created
)
1837 /* Always create a DT_PLTGOT. It actually has nothing to do with
1838 the PLT, it is how we communicate the __gp value of a load
1839 module to the dynamic linker. */
1840 #define add_dynamic_entry(TAG, VAL) \
1841 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1843 if (!add_dynamic_entry (DT_HP_DLD_FLAGS
, 0)
1844 || !add_dynamic_entry (DT_PLTGOT
, 0))
1847 /* Add some entries to the .dynamic section. We fill in the
1848 values later, in elf64_hppa_finish_dynamic_sections, but we
1849 must add the entries now so that we get the correct size for
1850 the .dynamic section. The DT_DEBUG entry is filled in by the
1851 dynamic linker and used by the debugger. */
1852 if (! bfd_link_pic (info
))
1854 if (!add_dynamic_entry (DT_DEBUG
, 0)
1855 || !add_dynamic_entry (DT_HP_DLD_HOOK
, 0)
1856 || !add_dynamic_entry (DT_HP_LOAD_MAP
, 0))
1860 /* Force DT_FLAGS to always be set.
1861 Required by HPUX 11.00 patch PHSS_26559. */
1862 if (!add_dynamic_entry (DT_FLAGS
, (info
)->flags
))
1867 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
1868 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1869 || !add_dynamic_entry (DT_JMPREL
, 0))
1875 if (!add_dynamic_entry (DT_RELA
, 0)
1876 || !add_dynamic_entry (DT_RELASZ
, 0)
1877 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf64_External_Rela
)))
1883 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1885 info
->flags
|= DF_TEXTREL
;
1888 #undef add_dynamic_entry
1893 /* Called after we have output the symbol into the dynamic symbol
1894 table, but before we output the symbol into the normal symbol
1897 For some symbols we had to change their address when outputting
1898 the dynamic symbol table. We undo that change here so that
1899 the symbols have their expected value in the normal symbol
1903 elf64_hppa_link_output_symbol_hook (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1905 Elf_Internal_Sym
*sym
,
1906 asection
*input_sec ATTRIBUTE_UNUSED
,
1907 struct elf_link_hash_entry
*eh
)
1909 struct elf64_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
1911 /* We may be called with the file symbol or section symbols.
1912 They never need munging, so it is safe to ignore them. */
1916 /* Function symbols for which we created .opd entries *may* have been
1917 munged by finish_dynamic_symbol and have to be un-munged here.
1919 Note that finish_dynamic_symbol sometimes turns dynamic symbols
1920 into non-dynamic ones, so we initialize st_shndx to -1 in
1921 mark_exported_functions and check to see if it was overwritten
1922 here instead of just checking eh->dynindx. */
1923 if (hh
->want_opd
&& hh
->st_shndx
!= -1)
1925 /* Restore the saved value and section index. */
1926 sym
->st_value
= hh
->st_value
;
1927 sym
->st_shndx
= hh
->st_shndx
;
1933 /* Finish up dynamic symbol handling. We set the contents of various
1934 dynamic sections here. */
1937 elf64_hppa_finish_dynamic_symbol (bfd
*output_bfd
,
1938 struct bfd_link_info
*info
,
1939 struct elf_link_hash_entry
*eh
,
1940 Elf_Internal_Sym
*sym
)
1942 struct elf64_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
1943 asection
*stub
, *splt
, *sopd
, *spltrel
;
1944 struct elf64_hppa_link_hash_table
*hppa_info
;
1946 hppa_info
= hppa_link_hash_table (info
);
1947 if (hppa_info
== NULL
)
1950 stub
= hppa_info
->stub_sec
;
1951 splt
= hppa_info
->root
.splt
;
1952 sopd
= hppa_info
->opd_sec
;
1953 spltrel
= hppa_info
->root
.srelplt
;
1955 /* Incredible. It is actually necessary to NOT use the symbol's real
1956 value when building the dynamic symbol table for a shared library.
1957 At least for symbols that refer to functions.
1959 We will store a new value and section index into the symbol long
1960 enough to output it into the dynamic symbol table, then we restore
1961 the original values (in elf64_hppa_link_output_symbol_hook). */
1964 BFD_ASSERT (sopd
!= NULL
);
1966 /* Save away the original value and section index so that we
1967 can restore them later. */
1968 hh
->st_value
= sym
->st_value
;
1969 hh
->st_shndx
= sym
->st_shndx
;
1971 /* For the dynamic symbol table entry, we want the value to be
1972 address of this symbol's entry within the .opd section. */
1973 sym
->st_value
= (hh
->opd_offset
1974 + sopd
->output_offset
1975 + sopd
->output_section
->vma
);
1976 sym
->st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
1977 sopd
->output_section
);
1980 /* Initialize a .plt entry if requested. */
1982 && elf64_hppa_dynamic_symbol_p (eh
, info
))
1985 Elf_Internal_Rela rel
;
1988 BFD_ASSERT (splt
!= NULL
&& spltrel
!= NULL
);
1990 /* We do not actually care about the value in the PLT entry
1991 if we are creating a shared library and the symbol is
1992 still undefined, we create a dynamic relocation to fill
1993 in the correct value. */
1994 if (bfd_link_pic (info
) && eh
->root
.type
== bfd_link_hash_undefined
)
1997 value
= (eh
->root
.u
.def
.value
+ eh
->root
.u
.def
.section
->vma
);
1999 /* Fill in the entry in the procedure linkage table.
2001 The format of a plt entry is
2004 plt_offset is the offset within the PLT section at which to
2005 install the PLT entry.
2007 We are modifying the in-memory PLT contents here, so we do not add
2008 in the output_offset of the PLT section. */
2010 bfd_put_64 (splt
->owner
, value
, splt
->contents
+ hh
->plt_offset
);
2011 value
= _bfd_get_gp_value (info
->output_bfd
);
2012 bfd_put_64 (splt
->owner
, value
, splt
->contents
+ hh
->plt_offset
+ 0x8);
2014 /* Create a dynamic IPLT relocation for this entry.
2016 We are creating a relocation in the output file's PLT section,
2017 which is included within the DLT secton. So we do need to include
2018 the PLT's output_offset in the computation of the relocation's
2020 rel
.r_offset
= (hh
->plt_offset
+ splt
->output_offset
2021 + splt
->output_section
->vma
);
2022 rel
.r_info
= ELF64_R_INFO (hh
->eh
.dynindx
, R_PARISC_IPLT
);
2025 loc
= spltrel
->contents
;
2026 loc
+= spltrel
->reloc_count
++ * sizeof (Elf64_External_Rela
);
2027 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rel
, loc
);
2030 /* Initialize an external call stub entry if requested. */
2032 && elf64_hppa_dynamic_symbol_p (eh
, info
))
2036 unsigned int max_offset
;
2038 BFD_ASSERT (stub
!= NULL
);
2040 /* Install the generic stub template.
2042 We are modifying the contents of the stub section, so we do not
2043 need to include the stub section's output_offset here. */
2044 memcpy (stub
->contents
+ hh
->stub_offset
, plt_stub
, sizeof (plt_stub
));
2046 /* Fix up the first ldd instruction.
2048 We are modifying the contents of the STUB section in memory,
2049 so we do not need to include its output offset in this computation.
2051 Note the plt_offset value is the value of the PLT entry relative to
2052 the start of the PLT section. These instructions will reference
2053 data relative to the value of __gp, which may not necessarily have
2054 the same address as the start of the PLT section.
2056 gp_offset contains the offset of __gp within the PLT section. */
2057 value
= hh
->plt_offset
- hppa_info
->gp_offset
;
2059 insn
= bfd_get_32 (stub
->owner
, stub
->contents
+ hh
->stub_offset
);
2060 if (output_bfd
->arch_info
->mach
>= 25)
2062 /* Wide mode allows 16 bit offsets. */
2065 insn
|= re_assemble_16 ((int) value
);
2071 insn
|= re_assemble_14 ((int) value
);
2074 if ((value
& 7) || value
+ max_offset
>= 2*max_offset
- 8)
2077 /* xgettext:c-format */
2078 (_("stub entry for %s cannot load .plt, dp offset = %" PRId64
),
2079 hh
->eh
.root
.root
.string
, (int64_t) value
);
2083 bfd_put_32 (stub
->owner
, (bfd_vma
) insn
,
2084 stub
->contents
+ hh
->stub_offset
);
2086 /* Fix up the second ldd instruction. */
2088 insn
= bfd_get_32 (stub
->owner
, stub
->contents
+ hh
->stub_offset
+ 8);
2089 if (output_bfd
->arch_info
->mach
>= 25)
2092 insn
|= re_assemble_16 ((int) value
);
2097 insn
|= re_assemble_14 ((int) value
);
2099 bfd_put_32 (stub
->owner
, (bfd_vma
) insn
,
2100 stub
->contents
+ hh
->stub_offset
+ 8);
2106 /* The .opd section contains FPTRs for each function this file
2107 exports. Initialize the FPTR entries. */
2110 elf64_hppa_finalize_opd (struct elf_link_hash_entry
*eh
, void *data
)
2112 struct elf64_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
2113 struct bfd_link_info
*info
= (struct bfd_link_info
*)data
;
2114 struct elf64_hppa_link_hash_table
*hppa_info
;
2118 hppa_info
= hppa_link_hash_table (info
);
2119 if (hppa_info
== NULL
)
2122 sopd
= hppa_info
->opd_sec
;
2123 sopdrel
= hppa_info
->opd_rel_sec
;
2129 /* The first two words of an .opd entry are zero.
2131 We are modifying the contents of the OPD section in memory, so we
2132 do not need to include its output offset in this computation. */
2133 memset (sopd
->contents
+ hh
->opd_offset
, 0, 16);
2135 value
= (eh
->root
.u
.def
.value
2136 + eh
->root
.u
.def
.section
->output_section
->vma
2137 + eh
->root
.u
.def
.section
->output_offset
);
2139 /* The next word is the address of the function. */
2140 bfd_put_64 (sopd
->owner
, value
, sopd
->contents
+ hh
->opd_offset
+ 16);
2142 /* The last word is our local __gp value. */
2143 value
= _bfd_get_gp_value (info
->output_bfd
);
2144 bfd_put_64 (sopd
->owner
, value
, sopd
->contents
+ hh
->opd_offset
+ 24);
2147 /* If we are generating a shared library, we must generate EPLT relocations
2148 for each entry in the .opd, even for static functions (they may have
2149 had their address taken). */
2150 if (bfd_link_pic (info
) && hh
->want_opd
)
2152 Elf_Internal_Rela rel
;
2156 /* We may need to do a relocation against a local symbol, in
2157 which case we have to look up it's dynamic symbol index off
2158 the local symbol hash table. */
2159 if (eh
->dynindx
!= -1)
2160 dynindx
= eh
->dynindx
;
2163 = _bfd_elf_link_lookup_local_dynindx (info
, hh
->owner
,
2166 /* The offset of this relocation is the absolute address of the
2167 .opd entry for this symbol. */
2168 rel
.r_offset
= (hh
->opd_offset
+ sopd
->output_offset
2169 + sopd
->output_section
->vma
);
2171 /* If H is non-null, then we have an external symbol.
2173 It is imperative that we use a different dynamic symbol for the
2174 EPLT relocation if the symbol has global scope.
2176 In the dynamic symbol table, the function symbol will have a value
2177 which is address of the function's .opd entry.
2179 Thus, we can not use that dynamic symbol for the EPLT relocation
2180 (if we did, the data in the .opd would reference itself rather
2181 than the actual address of the function). Instead we have to use
2182 a new dynamic symbol which has the same value as the original global
2185 We prefix the original symbol with a "." and use the new symbol in
2186 the EPLT relocation. This new symbol has already been recorded in
2187 the symbol table, we just have to look it up and use it.
2189 We do not have such problems with static functions because we do
2190 not make their addresses in the dynamic symbol table point to
2191 the .opd entry. Ultimately this should be safe since a static
2192 function can not be directly referenced outside of its shared
2195 We do have to play similar games for FPTR relocations in shared
2196 libraries, including those for static symbols. See the FPTR
2197 handling in elf64_hppa_finalize_dynreloc. */
2201 struct elf_link_hash_entry
*nh
;
2203 new_name
= concat (".", eh
->root
.root
.string
, NULL
);
2205 nh
= elf_link_hash_lookup (elf_hash_table (info
),
2206 new_name
, TRUE
, TRUE
, FALSE
);
2208 /* All we really want from the new symbol is its dynamic
2211 dynindx
= nh
->dynindx
;
2216 rel
.r_info
= ELF64_R_INFO (dynindx
, R_PARISC_EPLT
);
2218 loc
= sopdrel
->contents
;
2219 loc
+= sopdrel
->reloc_count
++ * sizeof (Elf64_External_Rela
);
2220 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rel
, loc
);
2225 /* The .dlt section contains addresses for items referenced through the
2226 dlt. Note that we can have a DLTIND relocation for a local symbol, thus
2227 we can not depend on finish_dynamic_symbol to initialize the .dlt. */
2230 elf64_hppa_finalize_dlt (struct elf_link_hash_entry
*eh
, void *data
)
2232 struct elf64_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
2233 struct bfd_link_info
*info
= (struct bfd_link_info
*)data
;
2234 struct elf64_hppa_link_hash_table
*hppa_info
;
2235 asection
*sdlt
, *sdltrel
;
2237 hppa_info
= hppa_link_hash_table (info
);
2238 if (hppa_info
== NULL
)
2241 sdlt
= hppa_info
->dlt_sec
;
2242 sdltrel
= hppa_info
->dlt_rel_sec
;
2244 /* H/DYN_H may refer to a local variable and we know it's
2245 address, so there is no need to create a relocation. Just install
2246 the proper value into the DLT, note this shortcut can not be
2247 skipped when building a shared library. */
2248 if (! bfd_link_pic (info
) && hh
&& hh
->want_dlt
)
2252 /* If we had an LTOFF_FPTR style relocation we want the DLT entry
2253 to point to the FPTR entry in the .opd section.
2255 We include the OPD's output offset in this computation as
2256 we are referring to an absolute address in the resulting
2260 value
= (hh
->opd_offset
2261 + hppa_info
->opd_sec
->output_offset
2262 + hppa_info
->opd_sec
->output_section
->vma
);
2264 else if ((eh
->root
.type
== bfd_link_hash_defined
2265 || eh
->root
.type
== bfd_link_hash_defweak
)
2266 && eh
->root
.u
.def
.section
)
2268 value
= eh
->root
.u
.def
.value
+ eh
->root
.u
.def
.section
->output_offset
;
2269 if (eh
->root
.u
.def
.section
->output_section
)
2270 value
+= eh
->root
.u
.def
.section
->output_section
->vma
;
2272 value
+= eh
->root
.u
.def
.section
->vma
;
2275 /* We have an undefined function reference. */
2278 /* We do not need to include the output offset of the DLT section
2279 here because we are modifying the in-memory contents. */
2280 bfd_put_64 (sdlt
->owner
, value
, sdlt
->contents
+ hh
->dlt_offset
);
2283 /* Create a relocation for the DLT entry associated with this symbol.
2284 When building a shared library the symbol does not have to be dynamic. */
2286 && (elf64_hppa_dynamic_symbol_p (eh
, info
) || bfd_link_pic (info
)))
2288 Elf_Internal_Rela rel
;
2292 /* We may need to do a relocation against a local symbol, in
2293 which case we have to look up it's dynamic symbol index off
2294 the local symbol hash table. */
2295 if (eh
&& eh
->dynindx
!= -1)
2296 dynindx
= eh
->dynindx
;
2299 = _bfd_elf_link_lookup_local_dynindx (info
, hh
->owner
,
2302 /* Create a dynamic relocation for this entry. Do include the output
2303 offset of the DLT entry since we need an absolute address in the
2304 resulting object file. */
2305 rel
.r_offset
= (hh
->dlt_offset
+ sdlt
->output_offset
2306 + sdlt
->output_section
->vma
);
2307 if (eh
&& eh
->type
== STT_FUNC
)
2308 rel
.r_info
= ELF64_R_INFO (dynindx
, R_PARISC_FPTR64
);
2310 rel
.r_info
= ELF64_R_INFO (dynindx
, R_PARISC_DIR64
);
2313 loc
= sdltrel
->contents
;
2314 loc
+= sdltrel
->reloc_count
++ * sizeof (Elf64_External_Rela
);
2315 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rel
, loc
);
2320 /* Finalize the dynamic relocations. Specifically the FPTR relocations
2321 for dynamic functions used to initialize static data. */
2324 elf64_hppa_finalize_dynreloc (struct elf_link_hash_entry
*eh
,
2327 struct elf64_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
2328 struct bfd_link_info
*info
= (struct bfd_link_info
*)data
;
2329 struct elf64_hppa_link_hash_table
*hppa_info
;
2332 dynamic_symbol
= elf64_hppa_dynamic_symbol_p (eh
, info
);
2334 if (!dynamic_symbol
&& !bfd_link_pic (info
))
2337 if (hh
->reloc_entries
)
2339 struct elf64_hppa_dyn_reloc_entry
*rent
;
2342 hppa_info
= hppa_link_hash_table (info
);
2343 if (hppa_info
== NULL
)
2346 /* We may need to do a relocation against a local symbol, in
2347 which case we have to look up it's dynamic symbol index off
2348 the local symbol hash table. */
2349 if (eh
->dynindx
!= -1)
2350 dynindx
= eh
->dynindx
;
2353 = _bfd_elf_link_lookup_local_dynindx (info
, hh
->owner
,
2356 for (rent
= hh
->reloc_entries
; rent
; rent
= rent
->next
)
2358 Elf_Internal_Rela rel
;
2361 /* Allocate one iff we are building a shared library, the relocation
2362 isn't a R_PARISC_FPTR64, or we don't want an opd entry. */
2363 if (!bfd_link_pic (info
)
2364 && rent
->type
== R_PARISC_FPTR64
&& hh
->want_opd
)
2367 /* Create a dynamic relocation for this entry.
2369 We need the output offset for the reloc's section because
2370 we are creating an absolute address in the resulting object
2372 rel
.r_offset
= (rent
->offset
+ rent
->sec
->output_offset
2373 + rent
->sec
->output_section
->vma
);
2375 /* An FPTR64 relocation implies that we took the address of
2376 a function and that the function has an entry in the .opd
2377 section. We want the FPTR64 relocation to reference the
2380 We could munge the symbol value in the dynamic symbol table
2381 (in fact we already do for functions with global scope) to point
2382 to the .opd entry. Then we could use that dynamic symbol in
2385 Or we could do something sensible, not munge the symbol's
2386 address and instead just use a different symbol to reference
2387 the .opd entry. At least that seems sensible until you
2388 realize there's no local dynamic symbols we can use for that
2389 purpose. Thus the hair in the check_relocs routine.
2391 We use a section symbol recorded by check_relocs as the
2392 base symbol for the relocation. The addend is the difference
2393 between the section symbol and the address of the .opd entry. */
2394 if (bfd_link_pic (info
)
2395 && rent
->type
== R_PARISC_FPTR64
&& hh
->want_opd
)
2397 bfd_vma value
, value2
;
2399 /* First compute the address of the opd entry for this symbol. */
2400 value
= (hh
->opd_offset
2401 + hppa_info
->opd_sec
->output_section
->vma
2402 + hppa_info
->opd_sec
->output_offset
);
2404 /* Compute the value of the start of the section with
2406 value2
= (rent
->sec
->output_section
->vma
2407 + rent
->sec
->output_offset
);
2409 /* Compute the difference between the start of the section
2410 with the relocation and the opd entry. */
2413 /* The result becomes the addend of the relocation. */
2414 rel
.r_addend
= value
;
2416 /* The section symbol becomes the symbol for the dynamic
2419 = _bfd_elf_link_lookup_local_dynindx (info
,
2424 rel
.r_addend
= rent
->addend
;
2426 rel
.r_info
= ELF64_R_INFO (dynindx
, rent
->type
);
2428 loc
= hppa_info
->other_rel_sec
->contents
;
2429 loc
+= (hppa_info
->other_rel_sec
->reloc_count
++
2430 * sizeof (Elf64_External_Rela
));
2431 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rel
, loc
);
2438 /* Used to decide how to sort relocs in an optimal manner for the
2439 dynamic linker, before writing them out. */
2441 static enum elf_reloc_type_class
2442 elf64_hppa_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2443 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2444 const Elf_Internal_Rela
*rela
)
2446 if (ELF64_R_SYM (rela
->r_info
) == STN_UNDEF
)
2447 return reloc_class_relative
;
2449 switch ((int) ELF64_R_TYPE (rela
->r_info
))
2452 return reloc_class_plt
;
2454 return reloc_class_copy
;
2456 return reloc_class_normal
;
2460 /* Finish up the dynamic sections. */
2463 elf64_hppa_finish_dynamic_sections (bfd
*output_bfd
,
2464 struct bfd_link_info
*info
)
2468 struct elf64_hppa_link_hash_table
*hppa_info
;
2470 hppa_info
= hppa_link_hash_table (info
);
2471 if (hppa_info
== NULL
)
2474 /* Finalize the contents of the .opd section. */
2475 elf_link_hash_traverse (elf_hash_table (info
),
2476 elf64_hppa_finalize_opd
,
2479 elf_link_hash_traverse (elf_hash_table (info
),
2480 elf64_hppa_finalize_dynreloc
,
2483 /* Finalize the contents of the .dlt section. */
2484 dynobj
= elf_hash_table (info
)->dynobj
;
2485 /* Finalize the contents of the .dlt section. */
2486 elf_link_hash_traverse (elf_hash_table (info
),
2487 elf64_hppa_finalize_dlt
,
2490 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
2492 if (elf_hash_table (info
)->dynamic_sections_created
)
2494 Elf64_External_Dyn
*dyncon
, *dynconend
;
2496 BFD_ASSERT (sdyn
!= NULL
);
2498 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
2499 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
2500 for (; dyncon
< dynconend
; dyncon
++)
2502 Elf_Internal_Dyn dyn
;
2505 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2512 case DT_HP_LOAD_MAP
:
2513 /* Compute the absolute address of 16byte scratchpad area
2514 for the dynamic linker.
2516 By convention the linker script will allocate the scratchpad
2517 area at the start of the .data section. So all we have to
2518 to is find the start of the .data section. */
2519 s
= bfd_get_section_by_name (output_bfd
, ".data");
2522 dyn
.d_un
.d_ptr
= s
->vma
;
2523 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2527 /* HP's use PLTGOT to set the GOT register. */
2528 dyn
.d_un
.d_ptr
= _bfd_get_gp_value (output_bfd
);
2529 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2533 s
= hppa_info
->root
.srelplt
;
2534 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2535 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2539 s
= hppa_info
->root
.srelplt
;
2540 dyn
.d_un
.d_val
= s
->size
;
2541 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2545 s
= hppa_info
->other_rel_sec
;
2546 if (! s
|| ! s
->size
)
2547 s
= hppa_info
->dlt_rel_sec
;
2548 if (! s
|| ! s
->size
)
2549 s
= hppa_info
->opd_rel_sec
;
2550 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2551 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2555 s
= hppa_info
->other_rel_sec
;
2556 dyn
.d_un
.d_val
= s
->size
;
2557 s
= hppa_info
->dlt_rel_sec
;
2558 dyn
.d_un
.d_val
+= s
->size
;
2559 s
= hppa_info
->opd_rel_sec
;
2560 dyn
.d_un
.d_val
+= s
->size
;
2561 /* There is some question about whether or not the size of
2562 the PLT relocs should be included here. HP's tools do
2563 it, so we'll emulate them. */
2564 s
= hppa_info
->root
.srelplt
;
2565 dyn
.d_un
.d_val
+= s
->size
;
2566 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2576 /* Support for core dump NOTE sections. */
2579 elf64_hppa_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
2584 switch (note
->descsz
)
2589 case 760: /* Linux/hppa */
2591 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
2594 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 32);
2603 /* Make a ".reg/999" section. */
2604 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
2605 size
, note
->descpos
+ offset
);
2609 elf64_hppa_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
2614 switch (note
->descsz
)
2619 case 136: /* Linux/hppa elf_prpsinfo. */
2620 elf_tdata (abfd
)->core
->program
2621 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
2622 elf_tdata (abfd
)->core
->command
2623 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
2626 /* Note that for some reason, a spurious space is tacked
2627 onto the end of the args in some (at least one anyway)
2628 implementations, so strip it off if it exists. */
2629 command
= elf_tdata (abfd
)->core
->command
;
2630 n
= strlen (command
);
2632 if (0 < n
&& command
[n
- 1] == ' ')
2633 command
[n
- 1] = '\0';
2638 /* Return the number of additional phdrs we will need.
2640 The generic ELF code only creates PT_PHDRs for executables. The HP
2641 dynamic linker requires PT_PHDRs for dynamic libraries too.
2643 This routine indicates that the backend needs one additional program
2644 header for that case.
2646 Note we do not have access to the link info structure here, so we have
2647 to guess whether or not we are building a shared library based on the
2648 existence of a .interp section. */
2651 elf64_hppa_additional_program_headers (bfd
*abfd
,
2652 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2656 /* If we are creating a shared library, then we have to create a
2657 PT_PHDR segment. HP's dynamic linker chokes without it. */
2658 s
= bfd_get_section_by_name (abfd
, ".interp");
2665 elf64_hppa_allow_non_load_phdr (bfd
*abfd ATTRIBUTE_UNUSED
,
2666 const Elf_Internal_Phdr
*phdr ATTRIBUTE_UNUSED
,
2667 unsigned int count ATTRIBUTE_UNUSED
)
2672 /* Allocate and initialize any program headers required by this
2675 The generic ELF code only creates PT_PHDRs for executables. The HP
2676 dynamic linker requires PT_PHDRs for dynamic libraries too.
2678 This allocates the PT_PHDR and initializes it in a manner suitable
2681 Note we do not have access to the link info structure here, so we have
2682 to guess whether or not we are building a shared library based on the
2683 existence of a .interp section. */
2686 elf64_hppa_modify_segment_map (bfd
*abfd
, struct bfd_link_info
*info
)
2688 struct elf_segment_map
*m
;
2690 m
= elf_seg_map (abfd
);
2691 if (info
!= NULL
&& !info
->user_phdrs
&& m
!= NULL
&& m
->p_type
!= PT_PHDR
)
2693 m
= ((struct elf_segment_map
*)
2694 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *m
));
2698 m
->p_type
= PT_PHDR
;
2699 m
->p_flags
= PF_R
| PF_X
;
2700 m
->p_flags_valid
= 1;
2701 m
->p_paddr_valid
= 1;
2702 m
->includes_phdrs
= 1;
2704 m
->next
= elf_seg_map (abfd
);
2705 elf_seg_map (abfd
) = m
;
2708 for (m
= elf_seg_map (abfd
) ; m
!= NULL
; m
= m
->next
)
2709 if (m
->p_type
== PT_LOAD
)
2713 for (i
= 0; i
< m
->count
; i
++)
2715 /* The code "hint" is not really a hint. It is a requirement
2716 for certain versions of the HP dynamic linker. Worse yet,
2717 it must be set even if the shared library does not have
2718 any code in its "text" segment (thus the check for .hash
2719 to catch this situation). */
2720 if (m
->sections
[i
]->flags
& SEC_CODE
2721 || (strcmp (m
->sections
[i
]->name
, ".hash") == 0))
2722 m
->p_flags
|= (PF_X
| PF_HP_CODE
);
2729 /* Called when writing out an object file to decide the type of a
2732 elf64_hppa_elf_get_symbol_type (Elf_Internal_Sym
*elf_sym
,
2735 if (ELF_ST_TYPE (elf_sym
->st_info
) == STT_PARISC_MILLI
)
2736 return STT_PARISC_MILLI
;
2741 /* Support HP specific sections for core files. */
2744 elf64_hppa_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int sec_index
,
2745 const char *typename
)
2747 if (hdr
->p_type
== PT_HP_CORE_KERNEL
)
2751 if (!_bfd_elf_make_section_from_phdr (abfd
, hdr
, sec_index
, typename
))
2754 sect
= bfd_make_section_anyway (abfd
, ".kernel");
2757 sect
->size
= hdr
->p_filesz
;
2758 sect
->filepos
= hdr
->p_offset
;
2759 sect
->flags
= SEC_HAS_CONTENTS
| SEC_READONLY
;
2763 if (hdr
->p_type
== PT_HP_CORE_PROC
)
2767 if (bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != 0)
2769 if (bfd_bread (&sig
, 4, abfd
) != 4)
2772 elf_tdata (abfd
)->core
->signal
= sig
;
2774 if (!_bfd_elf_make_section_from_phdr (abfd
, hdr
, sec_index
, typename
))
2777 /* GDB uses the ".reg" section to read register contents. */
2778 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", hdr
->p_filesz
,
2782 if (hdr
->p_type
== PT_HP_CORE_LOADABLE
2783 || hdr
->p_type
== PT_HP_CORE_STACK
2784 || hdr
->p_type
== PT_HP_CORE_MMF
)
2785 hdr
->p_type
= PT_LOAD
;
2787 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, sec_index
, typename
);
2790 /* Hook called by the linker routine which adds symbols from an object
2791 file. HP's libraries define symbols with HP specific section
2792 indices, which we have to handle. */
2795 elf_hppa_add_symbol_hook (bfd
*abfd
,
2796 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2797 Elf_Internal_Sym
*sym
,
2798 const char **namep ATTRIBUTE_UNUSED
,
2799 flagword
*flagsp ATTRIBUTE_UNUSED
,
2803 unsigned int sec_index
= sym
->st_shndx
;
2807 case SHN_PARISC_ANSI_COMMON
:
2808 *secp
= bfd_make_section_old_way (abfd
, ".PARISC.ansi.common");
2809 (*secp
)->flags
|= SEC_IS_COMMON
;
2810 *valp
= sym
->st_size
;
2813 case SHN_PARISC_HUGE_COMMON
:
2814 *secp
= bfd_make_section_old_way (abfd
, ".PARISC.huge.common");
2815 (*secp
)->flags
|= SEC_IS_COMMON
;
2816 *valp
= sym
->st_size
;
2824 elf_hppa_unmark_useless_dynamic_symbols (struct elf_link_hash_entry
*h
,
2827 struct bfd_link_info
*info
= data
;
2829 /* If we are not creating a shared library, and this symbol is
2830 referenced by a shared library but is not defined anywhere, then
2831 the generic code will warn that it is undefined.
2833 This behavior is undesirable on HPs since the standard shared
2834 libraries contain references to undefined symbols.
2836 So we twiddle the flags associated with such symbols so that they
2837 will not trigger the warning. ?!? FIXME. This is horribly fragile.
2839 Ultimately we should have better controls over the generic ELF BFD
2841 if (! bfd_link_relocatable (info
)
2842 && info
->unresolved_syms_in_shared_libs
!= RM_IGNORE
2843 && h
->root
.type
== bfd_link_hash_undefined
2848 h
->pointer_equality_needed
= 1;
2855 elf_hppa_remark_useless_dynamic_symbols (struct elf_link_hash_entry
*h
,
2858 struct bfd_link_info
*info
= data
;
2860 /* If we are not creating a shared library, and this symbol is
2861 referenced by a shared library but is not defined anywhere, then
2862 the generic code will warn that it is undefined.
2864 This behavior is undesirable on HPs since the standard shared
2865 libraries contain references to undefined symbols.
2867 So we twiddle the flags associated with such symbols so that they
2868 will not trigger the warning. ?!? FIXME. This is horribly fragile.
2870 Ultimately we should have better controls over the generic ELF BFD
2872 if (! bfd_link_relocatable (info
)
2873 && info
->unresolved_syms_in_shared_libs
!= RM_IGNORE
2874 && h
->root
.type
== bfd_link_hash_undefined
2877 && h
->pointer_equality_needed
)
2880 h
->pointer_equality_needed
= 0;
2887 elf_hppa_is_dynamic_loader_symbol (const char *name
)
2889 return (! strcmp (name
, "__CPU_REVISION")
2890 || ! strcmp (name
, "__CPU_KEYBITS_1")
2891 || ! strcmp (name
, "__SYSTEM_ID_D")
2892 || ! strcmp (name
, "__FPU_MODEL")
2893 || ! strcmp (name
, "__FPU_REVISION")
2894 || ! strcmp (name
, "__ARGC")
2895 || ! strcmp (name
, "__ARGV")
2896 || ! strcmp (name
, "__ENVP")
2897 || ! strcmp (name
, "__TLS_SIZE_D")
2898 || ! strcmp (name
, "__LOAD_INFO")
2899 || ! strcmp (name
, "__systab"));
2902 /* Record the lowest address for the data and text segments. */
2904 elf_hppa_record_segment_addrs (bfd
*abfd
,
2908 struct elf64_hppa_link_hash_table
*hppa_info
= data
;
2910 if ((section
->flags
& (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
2913 Elf_Internal_Phdr
*p
;
2915 p
= _bfd_elf_find_segment_containing_section (abfd
, section
->output_section
);
2916 BFD_ASSERT (p
!= NULL
);
2919 if (section
->flags
& SEC_READONLY
)
2921 if (value
< hppa_info
->text_segment_base
)
2922 hppa_info
->text_segment_base
= value
;
2926 if (value
< hppa_info
->data_segment_base
)
2927 hppa_info
->data_segment_base
= value
;
2932 /* Called after we have seen all the input files/sections, but before
2933 final symbol resolution and section placement has been determined.
2935 We use this hook to (possibly) provide a value for __gp, then we
2936 fall back to the generic ELF final link routine. */
2939 elf_hppa_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
2942 struct elf64_hppa_link_hash_table
*hppa_info
= hppa_link_hash_table (info
);
2944 if (hppa_info
== NULL
)
2947 if (! bfd_link_relocatable (info
))
2949 struct elf_link_hash_entry
*gp
;
2952 /* The linker script defines a value for __gp iff it was referenced
2953 by one of the objects being linked. First try to find the symbol
2954 in the hash table. If that fails, just compute the value __gp
2956 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
2962 /* Adjust the value of __gp as we may want to slide it into the
2963 .plt section so that the stubs can access PLT entries without
2964 using an addil sequence. */
2965 gp
->root
.u
.def
.value
+= hppa_info
->gp_offset
;
2967 gp_val
= (gp
->root
.u
.def
.section
->output_section
->vma
2968 + gp
->root
.u
.def
.section
->output_offset
2969 + gp
->root
.u
.def
.value
);
2975 /* First look for a .plt section. If found, then __gp is the
2976 address of the .plt + gp_offset.
2978 If no .plt is found, then look for .dlt, .opd and .data (in
2979 that order) and set __gp to the base address of whichever
2980 section is found first. */
2982 sec
= hppa_info
->root
.splt
;
2983 if (sec
&& ! (sec
->flags
& SEC_EXCLUDE
))
2984 gp_val
= (sec
->output_offset
2985 + sec
->output_section
->vma
2986 + hppa_info
->gp_offset
);
2989 sec
= hppa_info
->dlt_sec
;
2990 if (!sec
|| (sec
->flags
& SEC_EXCLUDE
))
2991 sec
= hppa_info
->opd_sec
;
2992 if (!sec
|| (sec
->flags
& SEC_EXCLUDE
))
2993 sec
= bfd_get_section_by_name (abfd
, ".data");
2994 if (!sec
|| (sec
->flags
& SEC_EXCLUDE
))
2997 gp_val
= sec
->output_offset
+ sec
->output_section
->vma
;
3001 /* Install whatever value we found/computed for __gp. */
3002 _bfd_set_gp_value (abfd
, gp_val
);
3005 /* We need to know the base of the text and data segments so that we
3006 can perform SEGREL relocations. We will record the base addresses
3007 when we encounter the first SEGREL relocation. */
3008 hppa_info
->text_segment_base
= (bfd_vma
)-1;
3009 hppa_info
->data_segment_base
= (bfd_vma
)-1;
3011 /* HP's shared libraries have references to symbols that are not
3012 defined anywhere. The generic ELF BFD linker code will complain
3015 So we detect the losing case and arrange for the flags on the symbol
3016 to indicate that it was never referenced. This keeps the generic
3017 ELF BFD link code happy and appears to not create any secondary
3018 problems. Ultimately we need a way to control the behavior of the
3019 generic ELF BFD link code better. */
3020 elf_link_hash_traverse (elf_hash_table (info
),
3021 elf_hppa_unmark_useless_dynamic_symbols
,
3024 /* Invoke the regular ELF backend linker to do all the work. */
3025 if (!bfd_elf_final_link (abfd
, info
))
3028 elf_link_hash_traverse (elf_hash_table (info
),
3029 elf_hppa_remark_useless_dynamic_symbols
,
3032 /* If we're producing a final executable, sort the contents of the
3034 if (bfd_link_relocatable (info
))
3037 /* Do not attempt to sort non-regular files. This is here
3038 especially for configure scripts and kernel builds which run
3039 tests with "ld [...] -o /dev/null". */
3040 if (stat (bfd_get_filename (abfd
), &buf
) != 0
3041 || !S_ISREG(buf
.st_mode
))
3044 return elf_hppa_sort_unwind (abfd
);
3047 /* Relocate the given INSN. VALUE should be the actual value we want
3048 to insert into the instruction, ie by this point we should not be
3049 concerned with computing an offset relative to the DLT, PC, etc.
3050 Instead this routine is meant to handle the bit manipulations needed
3051 to insert the relocation into the given instruction. */
3054 elf_hppa_relocate_insn (int insn
, int sym_value
, unsigned int r_type
)
3058 /* This is any 22 bit branch. In PA2.0 syntax it corresponds to
3059 the "B" instruction. */
3060 case R_PARISC_PCREL22F
:
3061 case R_PARISC_PCREL22C
:
3062 return (insn
& ~0x3ff1ffd) | re_assemble_22 (sym_value
);
3064 /* This is any 12 bit branch. */
3065 case R_PARISC_PCREL12F
:
3066 return (insn
& ~0x1ffd) | re_assemble_12 (sym_value
);
3068 /* This is any 17 bit branch. In PA2.0 syntax it also corresponds
3069 to the "B" instruction as well as BE. */
3070 case R_PARISC_PCREL17F
:
3071 case R_PARISC_DIR17F
:
3072 case R_PARISC_DIR17R
:
3073 case R_PARISC_PCREL17C
:
3074 case R_PARISC_PCREL17R
:
3075 return (insn
& ~0x1f1ffd) | re_assemble_17 (sym_value
);
3077 /* ADDIL or LDIL instructions. */
3078 case R_PARISC_DLTREL21L
:
3079 case R_PARISC_DLTIND21L
:
3080 case R_PARISC_LTOFF_FPTR21L
:
3081 case R_PARISC_PCREL21L
:
3082 case R_PARISC_LTOFF_TP21L
:
3083 case R_PARISC_DPREL21L
:
3084 case R_PARISC_PLTOFF21L
:
3085 case R_PARISC_DIR21L
:
3086 return (insn
& ~0x1fffff) | re_assemble_21 (sym_value
);
3088 /* LDO and integer loads/stores with 14 bit displacements. */
3089 case R_PARISC_DLTREL14R
:
3090 case R_PARISC_DLTREL14F
:
3091 case R_PARISC_DLTIND14R
:
3092 case R_PARISC_DLTIND14F
:
3093 case R_PARISC_LTOFF_FPTR14R
:
3094 case R_PARISC_PCREL14R
:
3095 case R_PARISC_PCREL14F
:
3096 case R_PARISC_LTOFF_TP14R
:
3097 case R_PARISC_LTOFF_TP14F
:
3098 case R_PARISC_DPREL14R
:
3099 case R_PARISC_DPREL14F
:
3100 case R_PARISC_PLTOFF14R
:
3101 case R_PARISC_PLTOFF14F
:
3102 case R_PARISC_DIR14R
:
3103 case R_PARISC_DIR14F
:
3104 return (insn
& ~0x3fff) | low_sign_unext (sym_value
, 14);
3106 /* PA2.0W LDO and integer loads/stores with 16 bit displacements. */
3107 case R_PARISC_LTOFF_FPTR16F
:
3108 case R_PARISC_PCREL16F
:
3109 case R_PARISC_LTOFF_TP16F
:
3110 case R_PARISC_GPREL16F
:
3111 case R_PARISC_PLTOFF16F
:
3112 case R_PARISC_DIR16F
:
3113 case R_PARISC_LTOFF16F
:
3114 return (insn
& ~0xffff) | re_assemble_16 (sym_value
);
3116 /* Doubleword loads and stores with a 14 bit displacement. */
3117 case R_PARISC_DLTREL14DR
:
3118 case R_PARISC_DLTIND14DR
:
3119 case R_PARISC_LTOFF_FPTR14DR
:
3120 case R_PARISC_LTOFF_FPTR16DF
:
3121 case R_PARISC_PCREL14DR
:
3122 case R_PARISC_PCREL16DF
:
3123 case R_PARISC_LTOFF_TP14DR
:
3124 case R_PARISC_LTOFF_TP16DF
:
3125 case R_PARISC_DPREL14DR
:
3126 case R_PARISC_GPREL16DF
:
3127 case R_PARISC_PLTOFF14DR
:
3128 case R_PARISC_PLTOFF16DF
:
3129 case R_PARISC_DIR14DR
:
3130 case R_PARISC_DIR16DF
:
3131 case R_PARISC_LTOFF16DF
:
3132 return (insn
& ~0x3ff1) | (((sym_value
& 0x2000) >> 13)
3133 | ((sym_value
& 0x1ff8) << 1));
3135 /* Floating point single word load/store instructions. */
3136 case R_PARISC_DLTREL14WR
:
3137 case R_PARISC_DLTIND14WR
:
3138 case R_PARISC_LTOFF_FPTR14WR
:
3139 case R_PARISC_LTOFF_FPTR16WF
:
3140 case R_PARISC_PCREL14WR
:
3141 case R_PARISC_PCREL16WF
:
3142 case R_PARISC_LTOFF_TP14WR
:
3143 case R_PARISC_LTOFF_TP16WF
:
3144 case R_PARISC_DPREL14WR
:
3145 case R_PARISC_GPREL16WF
:
3146 case R_PARISC_PLTOFF14WR
:
3147 case R_PARISC_PLTOFF16WF
:
3148 case R_PARISC_DIR16WF
:
3149 case R_PARISC_DIR14WR
:
3150 case R_PARISC_LTOFF16WF
:
3151 return (insn
& ~0x3ff9) | (((sym_value
& 0x2000) >> 13)
3152 | ((sym_value
& 0x1ffc) << 1));
3159 /* Compute the value for a relocation (REL) during a final link stage,
3160 then insert the value into the proper location in CONTENTS.
3162 VALUE is a tentative value for the relocation and may be overridden
3163 and modified here based on the specific relocation to be performed.
3165 For example we do conversions for PC-relative branches in this routine
3166 or redirection of calls to external routines to stubs.
3168 The work of actually applying the relocation is left to a helper
3169 routine in an attempt to reduce the complexity and size of this
3172 static bfd_reloc_status_type
3173 elf_hppa_final_link_relocate (Elf_Internal_Rela
*rel
,
3176 asection
*input_section
,
3179 struct bfd_link_info
*info
,
3181 struct elf_link_hash_entry
*eh
)
3183 struct elf64_hppa_link_hash_table
*hppa_info
= hppa_link_hash_table (info
);
3184 struct elf64_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
3185 bfd_vma
*local_offsets
;
3186 Elf_Internal_Shdr
*symtab_hdr
;
3188 bfd_vma max_branch_offset
= 0;
3189 bfd_vma offset
= rel
->r_offset
;
3190 bfd_signed_vma addend
= rel
->r_addend
;
3191 reloc_howto_type
*howto
= elf_hppa_howto_table
+ ELF_R_TYPE (rel
->r_info
);
3192 unsigned int r_symndx
= ELF_R_SYM (rel
->r_info
);
3193 unsigned int r_type
= howto
->type
;
3194 bfd_byte
*hit_data
= contents
+ offset
;
3196 if (hppa_info
== NULL
)
3197 return bfd_reloc_notsupported
;
3199 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3200 local_offsets
= elf_local_got_offsets (input_bfd
);
3201 insn
= bfd_get_32 (input_bfd
, hit_data
);
3208 /* Basic function call support.
3210 Note for a call to a function defined in another dynamic library
3211 we want to redirect the call to a stub. */
3213 /* PC relative relocs without an implicit offset. */
3214 case R_PARISC_PCREL21L
:
3215 case R_PARISC_PCREL14R
:
3216 case R_PARISC_PCREL14F
:
3217 case R_PARISC_PCREL14WR
:
3218 case R_PARISC_PCREL14DR
:
3219 case R_PARISC_PCREL16F
:
3220 case R_PARISC_PCREL16WF
:
3221 case R_PARISC_PCREL16DF
:
3223 /* If this is a call to a function defined in another dynamic
3224 library, then redirect the call to the local stub for this
3226 if (sym_sec
== NULL
|| sym_sec
->output_section
== NULL
)
3227 value
= (hh
->stub_offset
+ hppa_info
->stub_sec
->output_offset
3228 + hppa_info
->stub_sec
->output_section
->vma
);
3230 /* Turn VALUE into a proper PC relative address. */
3231 value
-= (offset
+ input_section
->output_offset
3232 + input_section
->output_section
->vma
);
3234 /* Adjust for any field selectors. */
3235 if (r_type
== R_PARISC_PCREL21L
)
3236 value
= hppa_field_adjust (value
, -8 + addend
, e_lsel
);
3237 else if (r_type
== R_PARISC_PCREL14F
3238 || r_type
== R_PARISC_PCREL16F
3239 || r_type
== R_PARISC_PCREL16WF
3240 || r_type
== R_PARISC_PCREL16DF
)
3241 value
= hppa_field_adjust (value
, -8 + addend
, e_fsel
);
3243 value
= hppa_field_adjust (value
, -8 + addend
, e_rsel
);
3245 /* Apply the relocation to the given instruction. */
3246 insn
= elf_hppa_relocate_insn (insn
, (int) value
, r_type
);
3250 case R_PARISC_PCREL12F
:
3251 case R_PARISC_PCREL22F
:
3252 case R_PARISC_PCREL17F
:
3253 case R_PARISC_PCREL22C
:
3254 case R_PARISC_PCREL17C
:
3255 case R_PARISC_PCREL17R
:
3257 /* If this is a call to a function defined in another dynamic
3258 library, then redirect the call to the local stub for this
3260 if (sym_sec
== NULL
|| sym_sec
->output_section
== NULL
)
3261 value
= (hh
->stub_offset
+ hppa_info
->stub_sec
->output_offset
3262 + hppa_info
->stub_sec
->output_section
->vma
);
3264 /* Turn VALUE into a proper PC relative address. */
3265 value
-= (offset
+ input_section
->output_offset
3266 + input_section
->output_section
->vma
);
3269 if (r_type
== (unsigned int) R_PARISC_PCREL22F
)
3270 max_branch_offset
= (1 << (22-1)) << 2;
3271 else if (r_type
== (unsigned int) R_PARISC_PCREL17F
)
3272 max_branch_offset
= (1 << (17-1)) << 2;
3273 else if (r_type
== (unsigned int) R_PARISC_PCREL12F
)
3274 max_branch_offset
= (1 << (12-1)) << 2;
3276 /* Make sure we can reach the branch target. */
3277 if (max_branch_offset
!= 0
3278 && value
+ addend
+ max_branch_offset
>= 2*max_branch_offset
)
3281 /* xgettext:c-format */
3282 (_("%pB(%pA+%#" PRIx64
"): cannot reach %s"),
3286 eh
? eh
->root
.root
.string
: "unknown");
3287 bfd_set_error (bfd_error_bad_value
);
3288 return bfd_reloc_overflow
;
3291 /* Adjust for any field selectors. */
3292 if (r_type
== R_PARISC_PCREL17R
)
3293 value
= hppa_field_adjust (value
, addend
, e_rsel
);
3295 value
= hppa_field_adjust (value
, addend
, e_fsel
);
3297 /* All branches are implicitly shifted by 2 places. */
3300 /* Apply the relocation to the given instruction. */
3301 insn
= elf_hppa_relocate_insn (insn
, (int) value
, r_type
);
3305 /* Indirect references to data through the DLT. */
3306 case R_PARISC_DLTIND14R
:
3307 case R_PARISC_DLTIND14F
:
3308 case R_PARISC_DLTIND14DR
:
3309 case R_PARISC_DLTIND14WR
:
3310 case R_PARISC_DLTIND21L
:
3311 case R_PARISC_LTOFF_FPTR14R
:
3312 case R_PARISC_LTOFF_FPTR14DR
:
3313 case R_PARISC_LTOFF_FPTR14WR
:
3314 case R_PARISC_LTOFF_FPTR21L
:
3315 case R_PARISC_LTOFF_FPTR16F
:
3316 case R_PARISC_LTOFF_FPTR16WF
:
3317 case R_PARISC_LTOFF_FPTR16DF
:
3318 case R_PARISC_LTOFF_TP21L
:
3319 case R_PARISC_LTOFF_TP14R
:
3320 case R_PARISC_LTOFF_TP14F
:
3321 case R_PARISC_LTOFF_TP14WR
:
3322 case R_PARISC_LTOFF_TP14DR
:
3323 case R_PARISC_LTOFF_TP16F
:
3324 case R_PARISC_LTOFF_TP16WF
:
3325 case R_PARISC_LTOFF_TP16DF
:
3326 case R_PARISC_LTOFF16F
:
3327 case R_PARISC_LTOFF16WF
:
3328 case R_PARISC_LTOFF16DF
:
3332 /* If this relocation was against a local symbol, then we still
3333 have not set up the DLT entry (it's not convenient to do so
3334 in the "finalize_dlt" routine because it is difficult to get
3335 to the local symbol's value).
3337 So, if this is a local symbol (h == NULL), then we need to
3338 fill in its DLT entry.
3340 Similarly we may still need to set up an entry in .opd for
3341 a local function which had its address taken. */
3344 bfd_vma
*local_opd_offsets
, *local_dlt_offsets
;
3346 if (local_offsets
== NULL
)
3349 /* Now do .opd creation if needed. */
3350 if (r_type
== R_PARISC_LTOFF_FPTR14R
3351 || r_type
== R_PARISC_LTOFF_FPTR14DR
3352 || r_type
== R_PARISC_LTOFF_FPTR14WR
3353 || r_type
== R_PARISC_LTOFF_FPTR21L
3354 || r_type
== R_PARISC_LTOFF_FPTR16F
3355 || r_type
== R_PARISC_LTOFF_FPTR16WF
3356 || r_type
== R_PARISC_LTOFF_FPTR16DF
)
3358 local_opd_offsets
= local_offsets
+ 2 * symtab_hdr
->sh_info
;
3359 off
= local_opd_offsets
[r_symndx
];
3361 /* The last bit records whether we've already initialised
3362 this local .opd entry. */
3365 BFD_ASSERT (off
!= (bfd_vma
) -1);
3370 local_opd_offsets
[r_symndx
] |= 1;
3372 /* The first two words of an .opd entry are zero. */
3373 memset (hppa_info
->opd_sec
->contents
+ off
, 0, 16);
3375 /* The next word is the address of the function. */
3376 bfd_put_64 (hppa_info
->opd_sec
->owner
, value
+ addend
,
3377 (hppa_info
->opd_sec
->contents
+ off
+ 16));
3379 /* The last word is our local __gp value. */
3380 value
= _bfd_get_gp_value (info
->output_bfd
);
3381 bfd_put_64 (hppa_info
->opd_sec
->owner
, value
,
3382 (hppa_info
->opd_sec
->contents
+ off
+ 24));
3385 /* The DLT value is the address of the .opd entry. */
3387 + hppa_info
->opd_sec
->output_offset
3388 + hppa_info
->opd_sec
->output_section
->vma
);
3392 local_dlt_offsets
= local_offsets
;
3393 off
= local_dlt_offsets
[r_symndx
];
3397 BFD_ASSERT (off
!= (bfd_vma
) -1);
3402 local_dlt_offsets
[r_symndx
] |= 1;
3403 bfd_put_64 (hppa_info
->dlt_sec
->owner
,
3405 hppa_info
->dlt_sec
->contents
+ off
);
3409 off
= hh
->dlt_offset
;
3411 /* We want the value of the DLT offset for this symbol, not
3412 the symbol's actual address. Note that __gp may not point
3413 to the start of the DLT, so we have to compute the absolute
3414 address, then subtract out the value of __gp. */
3416 + hppa_info
->dlt_sec
->output_offset
3417 + hppa_info
->dlt_sec
->output_section
->vma
);
3418 value
-= _bfd_get_gp_value (output_bfd
);
3420 /* All DLTIND relocations are basically the same at this point,
3421 except that we need different field selectors for the 21bit
3422 version vs the 14bit versions. */
3423 if (r_type
== R_PARISC_DLTIND21L
3424 || r_type
== R_PARISC_LTOFF_FPTR21L
3425 || r_type
== R_PARISC_LTOFF_TP21L
)
3426 value
= hppa_field_adjust (value
, 0, e_lsel
);
3427 else if (r_type
== R_PARISC_DLTIND14F
3428 || r_type
== R_PARISC_LTOFF_FPTR16F
3429 || r_type
== R_PARISC_LTOFF_FPTR16WF
3430 || r_type
== R_PARISC_LTOFF_FPTR16DF
3431 || r_type
== R_PARISC_LTOFF16F
3432 || r_type
== R_PARISC_LTOFF16DF
3433 || r_type
== R_PARISC_LTOFF16WF
3434 || r_type
== R_PARISC_LTOFF_TP16F
3435 || r_type
== R_PARISC_LTOFF_TP16WF
3436 || r_type
== R_PARISC_LTOFF_TP16DF
)
3437 value
= hppa_field_adjust (value
, 0, e_fsel
);
3439 value
= hppa_field_adjust (value
, 0, e_rsel
);
3441 insn
= elf_hppa_relocate_insn (insn
, (int) value
, r_type
);
3445 case R_PARISC_DLTREL14R
:
3446 case R_PARISC_DLTREL14F
:
3447 case R_PARISC_DLTREL14DR
:
3448 case R_PARISC_DLTREL14WR
:
3449 case R_PARISC_DLTREL21L
:
3450 case R_PARISC_DPREL21L
:
3451 case R_PARISC_DPREL14WR
:
3452 case R_PARISC_DPREL14DR
:
3453 case R_PARISC_DPREL14R
:
3454 case R_PARISC_DPREL14F
:
3455 case R_PARISC_GPREL16F
:
3456 case R_PARISC_GPREL16WF
:
3457 case R_PARISC_GPREL16DF
:
3459 /* Subtract out the global pointer value to make value a DLT
3460 relative address. */
3461 value
-= _bfd_get_gp_value (output_bfd
);
3463 /* All DLTREL relocations are basically the same at this point,
3464 except that we need different field selectors for the 21bit
3465 version vs the 14bit versions. */
3466 if (r_type
== R_PARISC_DLTREL21L
3467 || r_type
== R_PARISC_DPREL21L
)
3468 value
= hppa_field_adjust (value
, addend
, e_lrsel
);
3469 else if (r_type
== R_PARISC_DLTREL14F
3470 || r_type
== R_PARISC_DPREL14F
3471 || r_type
== R_PARISC_GPREL16F
3472 || r_type
== R_PARISC_GPREL16WF
3473 || r_type
== R_PARISC_GPREL16DF
)
3474 value
= hppa_field_adjust (value
, addend
, e_fsel
);
3476 value
= hppa_field_adjust (value
, addend
, e_rrsel
);
3478 insn
= elf_hppa_relocate_insn (insn
, (int) value
, r_type
);
3482 case R_PARISC_DIR21L
:
3483 case R_PARISC_DIR17R
:
3484 case R_PARISC_DIR17F
:
3485 case R_PARISC_DIR14R
:
3486 case R_PARISC_DIR14F
:
3487 case R_PARISC_DIR14WR
:
3488 case R_PARISC_DIR14DR
:
3489 case R_PARISC_DIR16F
:
3490 case R_PARISC_DIR16WF
:
3491 case R_PARISC_DIR16DF
:
3493 /* All DIR relocations are basically the same at this point,
3494 except that branch offsets need to be divided by four, and
3495 we need different field selectors. Note that we don't
3496 redirect absolute calls to local stubs. */
3498 if (r_type
== R_PARISC_DIR21L
)
3499 value
= hppa_field_adjust (value
, addend
, e_lrsel
);
3500 else if (r_type
== R_PARISC_DIR17F
3501 || r_type
== R_PARISC_DIR16F
3502 || r_type
== R_PARISC_DIR16WF
3503 || r_type
== R_PARISC_DIR16DF
3504 || r_type
== R_PARISC_DIR14F
)
3505 value
= hppa_field_adjust (value
, addend
, e_fsel
);
3507 value
= hppa_field_adjust (value
, addend
, e_rrsel
);
3509 if (r_type
== R_PARISC_DIR17R
|| r_type
== R_PARISC_DIR17F
)
3510 /* All branches are implicitly shifted by 2 places. */
3513 insn
= elf_hppa_relocate_insn (insn
, (int) value
, r_type
);
3517 case R_PARISC_PLTOFF21L
:
3518 case R_PARISC_PLTOFF14R
:
3519 case R_PARISC_PLTOFF14F
:
3520 case R_PARISC_PLTOFF14WR
:
3521 case R_PARISC_PLTOFF14DR
:
3522 case R_PARISC_PLTOFF16F
:
3523 case R_PARISC_PLTOFF16WF
:
3524 case R_PARISC_PLTOFF16DF
:
3526 /* We want the value of the PLT offset for this symbol, not
3527 the symbol's actual address. Note that __gp may not point
3528 to the start of the DLT, so we have to compute the absolute
3529 address, then subtract out the value of __gp. */
3530 value
= (hh
->plt_offset
3531 + hppa_info
->root
.splt
->output_offset
3532 + hppa_info
->root
.splt
->output_section
->vma
);
3533 value
-= _bfd_get_gp_value (output_bfd
);
3535 /* All PLTOFF relocations are basically the same at this point,
3536 except that we need different field selectors for the 21bit
3537 version vs the 14bit versions. */
3538 if (r_type
== R_PARISC_PLTOFF21L
)
3539 value
= hppa_field_adjust (value
, addend
, e_lrsel
);
3540 else if (r_type
== R_PARISC_PLTOFF14F
3541 || r_type
== R_PARISC_PLTOFF16F
3542 || r_type
== R_PARISC_PLTOFF16WF
3543 || r_type
== R_PARISC_PLTOFF16DF
)
3544 value
= hppa_field_adjust (value
, addend
, e_fsel
);
3546 value
= hppa_field_adjust (value
, addend
, e_rrsel
);
3548 insn
= elf_hppa_relocate_insn (insn
, (int) value
, r_type
);
3552 case R_PARISC_LTOFF_FPTR32
:
3554 /* FIXME: There used to be code here to create the FPTR itself if
3555 the relocation was against a local symbol. But the code could
3556 never have worked. If the assert below is ever triggered then
3557 the code will need to be reinstated and fixed so that it does
3559 BFD_ASSERT (hh
!= NULL
);
3561 /* We want the value of the DLT offset for this symbol, not
3562 the symbol's actual address. Note that __gp may not point
3563 to the start of the DLT, so we have to compute the absolute
3564 address, then subtract out the value of __gp. */
3565 value
= (hh
->dlt_offset
3566 + hppa_info
->dlt_sec
->output_offset
3567 + hppa_info
->dlt_sec
->output_section
->vma
);
3568 value
-= _bfd_get_gp_value (output_bfd
);
3569 bfd_put_32 (input_bfd
, value
, hit_data
);
3570 return bfd_reloc_ok
;
3573 case R_PARISC_LTOFF_FPTR64
:
3574 case R_PARISC_LTOFF_TP64
:
3576 /* We may still need to create the FPTR itself if it was for
3578 if (eh
== NULL
&& r_type
== R_PARISC_LTOFF_FPTR64
)
3580 /* The first two words of an .opd entry are zero. */
3581 memset (hppa_info
->opd_sec
->contents
+ hh
->opd_offset
, 0, 16);
3583 /* The next word is the address of the function. */
3584 bfd_put_64 (hppa_info
->opd_sec
->owner
, value
+ addend
,
3585 (hppa_info
->opd_sec
->contents
3586 + hh
->opd_offset
+ 16));
3588 /* The last word is our local __gp value. */
3589 value
= _bfd_get_gp_value (info
->output_bfd
);
3590 bfd_put_64 (hppa_info
->opd_sec
->owner
, value
,
3591 hppa_info
->opd_sec
->contents
+ hh
->opd_offset
+ 24);
3593 /* The DLT value is the address of the .opd entry. */
3594 value
= (hh
->opd_offset
3595 + hppa_info
->opd_sec
->output_offset
3596 + hppa_info
->opd_sec
->output_section
->vma
);
3598 bfd_put_64 (hppa_info
->dlt_sec
->owner
,
3600 hppa_info
->dlt_sec
->contents
+ hh
->dlt_offset
);
3603 /* We want the value of the DLT offset for this symbol, not
3604 the symbol's actual address. Note that __gp may not point
3605 to the start of the DLT, so we have to compute the absolute
3606 address, then subtract out the value of __gp. */
3607 value
= (hh
->dlt_offset
3608 + hppa_info
->dlt_sec
->output_offset
3609 + hppa_info
->dlt_sec
->output_section
->vma
);
3610 value
-= _bfd_get_gp_value (output_bfd
);
3611 bfd_put_64 (input_bfd
, value
, hit_data
);
3612 return bfd_reloc_ok
;
3615 case R_PARISC_DIR32
:
3616 bfd_put_32 (input_bfd
, value
+ addend
, hit_data
);
3617 return bfd_reloc_ok
;
3619 case R_PARISC_DIR64
:
3620 bfd_put_64 (input_bfd
, value
+ addend
, hit_data
);
3621 return bfd_reloc_ok
;
3623 case R_PARISC_GPREL64
:
3624 /* Subtract out the global pointer value to make value a DLT
3625 relative address. */
3626 value
-= _bfd_get_gp_value (output_bfd
);
3628 bfd_put_64 (input_bfd
, value
+ addend
, hit_data
);
3629 return bfd_reloc_ok
;
3631 case R_PARISC_LTOFF64
:
3632 /* We want the value of the DLT offset for this symbol, not
3633 the symbol's actual address. Note that __gp may not point
3634 to the start of the DLT, so we have to compute the absolute
3635 address, then subtract out the value of __gp. */
3636 value
= (hh
->dlt_offset
3637 + hppa_info
->dlt_sec
->output_offset
3638 + hppa_info
->dlt_sec
->output_section
->vma
);
3639 value
-= _bfd_get_gp_value (output_bfd
);
3641 bfd_put_64 (input_bfd
, value
+ addend
, hit_data
);
3642 return bfd_reloc_ok
;
3644 case R_PARISC_PCREL32
:
3646 /* If this is a call to a function defined in another dynamic
3647 library, then redirect the call to the local stub for this
3649 if (sym_sec
== NULL
|| sym_sec
->output_section
== NULL
)
3650 value
= (hh
->stub_offset
+ hppa_info
->stub_sec
->output_offset
3651 + hppa_info
->stub_sec
->output_section
->vma
);
3653 /* Turn VALUE into a proper PC relative address. */
3654 value
-= (offset
+ input_section
->output_offset
3655 + input_section
->output_section
->vma
);
3659 bfd_put_32 (input_bfd
, value
, hit_data
);
3660 return bfd_reloc_ok
;
3663 case R_PARISC_PCREL64
:
3665 /* If this is a call to a function defined in another dynamic
3666 library, then redirect the call to the local stub for this
3668 if (sym_sec
== NULL
|| sym_sec
->output_section
== NULL
)
3669 value
= (hh
->stub_offset
+ hppa_info
->stub_sec
->output_offset
3670 + hppa_info
->stub_sec
->output_section
->vma
);
3672 /* Turn VALUE into a proper PC relative address. */
3673 value
-= (offset
+ input_section
->output_offset
3674 + input_section
->output_section
->vma
);
3678 bfd_put_64 (input_bfd
, value
, hit_data
);
3679 return bfd_reloc_ok
;
3682 case R_PARISC_FPTR64
:
3686 /* We may still need to create the FPTR itself if it was for
3690 bfd_vma
*local_opd_offsets
;
3692 if (local_offsets
== NULL
)
3695 local_opd_offsets
= local_offsets
+ 2 * symtab_hdr
->sh_info
;
3696 off
= local_opd_offsets
[r_symndx
];
3698 /* The last bit records whether we've already initialised
3699 this local .opd entry. */
3702 BFD_ASSERT (off
!= (bfd_vma
) -1);
3707 /* The first two words of an .opd entry are zero. */
3708 memset (hppa_info
->opd_sec
->contents
+ off
, 0, 16);
3710 /* The next word is the address of the function. */
3711 bfd_put_64 (hppa_info
->opd_sec
->owner
, value
+ addend
,
3712 (hppa_info
->opd_sec
->contents
+ off
+ 16));
3714 /* The last word is our local __gp value. */
3715 value
= _bfd_get_gp_value (info
->output_bfd
);
3716 bfd_put_64 (hppa_info
->opd_sec
->owner
, value
,
3717 hppa_info
->opd_sec
->contents
+ off
+ 24);
3721 off
= hh
->opd_offset
;
3723 if (hh
== NULL
|| hh
->want_opd
)
3724 /* We want the value of the OPD offset for this symbol. */
3726 + hppa_info
->opd_sec
->output_offset
3727 + hppa_info
->opd_sec
->output_section
->vma
);
3729 /* We want the address of the symbol. */
3732 bfd_put_64 (input_bfd
, value
, hit_data
);
3733 return bfd_reloc_ok
;
3736 case R_PARISC_SECREL32
:
3738 value
-= sym_sec
->output_section
->vma
;
3739 bfd_put_32 (input_bfd
, value
+ addend
, hit_data
);
3740 return bfd_reloc_ok
;
3742 case R_PARISC_SEGREL32
:
3743 case R_PARISC_SEGREL64
:
3745 /* If this is the first SEGREL relocation, then initialize
3746 the segment base values. */
3747 if (hppa_info
->text_segment_base
== (bfd_vma
) -1)
3748 bfd_map_over_sections (output_bfd
, elf_hppa_record_segment_addrs
,
3751 /* VALUE holds the absolute address. We want to include the
3752 addend, then turn it into a segment relative address.
3754 The segment is derived from SYM_SEC. We assume that there are
3755 only two segments of note in the resulting executable/shlib.
3756 A readonly segment (.text) and a readwrite segment (.data). */
3759 if (sym_sec
->flags
& SEC_CODE
)
3760 value
-= hppa_info
->text_segment_base
;
3762 value
-= hppa_info
->data_segment_base
;
3764 if (r_type
== R_PARISC_SEGREL32
)
3765 bfd_put_32 (input_bfd
, value
, hit_data
);
3767 bfd_put_64 (input_bfd
, value
, hit_data
);
3768 return bfd_reloc_ok
;
3771 /* Something we don't know how to handle. */
3773 return bfd_reloc_notsupported
;
3776 /* Update the instruction word. */
3777 bfd_put_32 (input_bfd
, (bfd_vma
) insn
, hit_data
);
3778 return bfd_reloc_ok
;
3781 /* Relocate an HPPA ELF section. */
3784 elf64_hppa_relocate_section (bfd
*output_bfd
,
3785 struct bfd_link_info
*info
,
3787 asection
*input_section
,
3789 Elf_Internal_Rela
*relocs
,
3790 Elf_Internal_Sym
*local_syms
,
3791 asection
**local_sections
)
3793 Elf_Internal_Shdr
*symtab_hdr
;
3794 Elf_Internal_Rela
*rel
;
3795 Elf_Internal_Rela
*relend
;
3796 struct elf64_hppa_link_hash_table
*hppa_info
;
3798 hppa_info
= hppa_link_hash_table (info
);
3799 if (hppa_info
== NULL
)
3802 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3805 relend
= relocs
+ input_section
->reloc_count
;
3806 for (; rel
< relend
; rel
++)
3809 reloc_howto_type
*howto
= elf_hppa_howto_table
+ ELF_R_TYPE (rel
->r_info
);
3810 unsigned long r_symndx
;
3811 struct elf_link_hash_entry
*eh
;
3812 Elf_Internal_Sym
*sym
;
3815 bfd_reloc_status_type r
;
3817 r_type
= ELF_R_TYPE (rel
->r_info
);
3818 if (r_type
< 0 || r_type
>= (int) R_PARISC_UNIMPLEMENTED
)
3820 bfd_set_error (bfd_error_bad_value
);
3823 if (r_type
== (unsigned int) R_PARISC_GNU_VTENTRY
3824 || r_type
== (unsigned int) R_PARISC_GNU_VTINHERIT
)
3827 /* This is a final link. */
3828 r_symndx
= ELF_R_SYM (rel
->r_info
);
3832 if (r_symndx
< symtab_hdr
->sh_info
)
3834 /* This is a local symbol, hh defaults to NULL. */
3835 sym
= local_syms
+ r_symndx
;
3836 sym_sec
= local_sections
[r_symndx
];
3837 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sym_sec
, rel
);
3841 /* This is not a local symbol. */
3842 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
3844 /* It seems this can happen with erroneous or unsupported
3845 input (mixing a.out and elf in an archive, for example.) */
3846 if (sym_hashes
== NULL
)
3849 eh
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
3851 if (info
->wrap_hash
!= NULL
3852 && (input_section
->flags
& SEC_DEBUGGING
) != 0)
3853 eh
= ((struct elf_link_hash_entry
*)
3854 unwrap_hash_lookup (info
, input_bfd
, &eh
->root
));
3856 while (eh
->root
.type
== bfd_link_hash_indirect
3857 || eh
->root
.type
== bfd_link_hash_warning
)
3858 eh
= (struct elf_link_hash_entry
*) eh
->root
.u
.i
.link
;
3861 if (eh
->root
.type
== bfd_link_hash_defined
3862 || eh
->root
.type
== bfd_link_hash_defweak
)
3864 sym_sec
= eh
->root
.u
.def
.section
;
3866 && sym_sec
->output_section
!= NULL
)
3867 relocation
= (eh
->root
.u
.def
.value
3868 + sym_sec
->output_section
->vma
3869 + sym_sec
->output_offset
);
3871 else if (eh
->root
.type
== bfd_link_hash_undefweak
)
3873 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
3874 && ELF_ST_VISIBILITY (eh
->other
) == STV_DEFAULT
)
3876 else if (!bfd_link_relocatable (info
)
3877 && elf_hppa_is_dynamic_loader_symbol (eh
->root
.root
.string
))
3879 else if (!bfd_link_relocatable (info
))
3883 err
= (info
->unresolved_syms_in_objects
== RM_DIAGNOSE
3884 && !info
->warn_unresolved_syms
)
3885 || ELF_ST_VISIBILITY (eh
->other
) != STV_DEFAULT
;
3887 info
->callbacks
->undefined_symbol
3888 (info
, eh
->root
.root
.string
, input_bfd
,
3889 input_section
, rel
->r_offset
, err
);
3892 if (!bfd_link_relocatable (info
)
3894 && eh
->root
.type
!= bfd_link_hash_defined
3895 && eh
->root
.type
!= bfd_link_hash_defweak
3896 && eh
->root
.type
!= bfd_link_hash_undefweak
)
3898 if (info
->unresolved_syms_in_objects
== RM_IGNORE
3899 && ELF_ST_VISIBILITY (eh
->other
) == STV_DEFAULT
3900 && eh
->type
== STT_PARISC_MILLI
)
3901 info
->callbacks
->undefined_symbol
3902 (info
, eh_name (eh
), input_bfd
,
3903 input_section
, rel
->r_offset
, FALSE
);
3907 if (sym_sec
!= NULL
&& discarded_section (sym_sec
))
3908 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3909 rel
, 1, relend
, howto
, 0, contents
);
3911 if (bfd_link_relocatable (info
))
3914 r
= elf_hppa_final_link_relocate (rel
, input_bfd
, output_bfd
,
3915 input_section
, contents
,
3916 relocation
, info
, sym_sec
,
3919 if (r
!= bfd_reloc_ok
)
3925 case bfd_reloc_overflow
:
3927 const char *sym_name
;
3933 sym_name
= bfd_elf_string_from_elf_section (input_bfd
,
3934 symtab_hdr
->sh_link
,
3936 if (sym_name
== NULL
)
3938 if (*sym_name
== '\0')
3939 sym_name
= bfd_section_name (sym_sec
);
3942 (*info
->callbacks
->reloc_overflow
)
3943 (info
, (eh
? &eh
->root
: NULL
), sym_name
, howto
->name
,
3944 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
3953 static const struct bfd_elf_special_section elf64_hppa_special_sections
[] =
3955 { STRING_COMMA_LEN (".tbss"), 0, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_HP_TLS
},
3956 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
3957 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
3958 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_PARISC_SHORT
},
3959 { STRING_COMMA_LEN (".dlt"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_PARISC_SHORT
},
3960 { STRING_COMMA_LEN (".sdata"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_PARISC_SHORT
},
3961 { STRING_COMMA_LEN (".sbss"), 0, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_PARISC_SHORT
},
3962 { NULL
, 0, 0, 0, 0 }
3965 /* The hash bucket size is the standard one, namely 4. */
3967 const struct elf_size_info hppa64_elf_size_info
=
3969 sizeof (Elf64_External_Ehdr
),
3970 sizeof (Elf64_External_Phdr
),
3971 sizeof (Elf64_External_Shdr
),
3972 sizeof (Elf64_External_Rel
),
3973 sizeof (Elf64_External_Rela
),
3974 sizeof (Elf64_External_Sym
),
3975 sizeof (Elf64_External_Dyn
),
3976 sizeof (Elf_External_Note
),
3980 ELFCLASS64
, EV_CURRENT
,
3981 bfd_elf64_write_out_phdrs
,
3982 bfd_elf64_write_shdrs_and_ehdr
,
3983 bfd_elf64_checksum_contents
,
3984 bfd_elf64_write_relocs
,
3985 bfd_elf64_swap_symbol_in
,
3986 bfd_elf64_swap_symbol_out
,
3987 bfd_elf64_slurp_reloc_table
,
3988 bfd_elf64_slurp_symbol_table
,
3989 bfd_elf64_swap_dyn_in
,
3990 bfd_elf64_swap_dyn_out
,
3991 bfd_elf64_swap_reloc_in
,
3992 bfd_elf64_swap_reloc_out
,
3993 bfd_elf64_swap_reloca_in
,
3994 bfd_elf64_swap_reloca_out
3997 #define TARGET_BIG_SYM hppa_elf64_vec
3998 #define TARGET_BIG_NAME "elf64-hppa"
3999 #define ELF_ARCH bfd_arch_hppa
4000 #define ELF_TARGET_ID HPPA64_ELF_DATA
4001 #define ELF_MACHINE_CODE EM_PARISC
4002 /* This is not strictly correct. The maximum page size for PA2.0 is
4003 64M. But everything still uses 4k. */
4004 #define ELF_MAXPAGESIZE 0x1000
4005 #define ELF_OSABI ELFOSABI_HPUX
4007 #define bfd_elf64_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
4008 #define bfd_elf64_bfd_reloc_name_lookup elf_hppa_reloc_name_lookup
4009 #define bfd_elf64_bfd_is_local_label_name elf_hppa_is_local_label_name
4010 #define elf_info_to_howto elf_hppa_info_to_howto
4011 #define elf_info_to_howto_rel elf_hppa_info_to_howto_rel
4013 #define elf_backend_section_from_shdr elf64_hppa_section_from_shdr
4014 #define elf_backend_object_p elf64_hppa_object_p
4015 #define elf_backend_final_write_processing \
4016 elf_hppa_final_write_processing
4017 #define elf_backend_fake_sections elf_hppa_fake_sections
4018 #define elf_backend_add_symbol_hook elf_hppa_add_symbol_hook
4020 #define elf_backend_relocate_section elf_hppa_relocate_section
4022 #define bfd_elf64_bfd_final_link elf_hppa_final_link
4024 #define elf_backend_create_dynamic_sections \
4025 elf64_hppa_create_dynamic_sections
4026 #define elf_backend_init_file_header elf64_hppa_init_file_header
4028 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
4030 #define elf_backend_adjust_dynamic_symbol \
4031 elf64_hppa_adjust_dynamic_symbol
4033 #define elf_backend_size_dynamic_sections \
4034 elf64_hppa_size_dynamic_sections
4036 #define elf_backend_finish_dynamic_symbol \
4037 elf64_hppa_finish_dynamic_symbol
4038 #define elf_backend_finish_dynamic_sections \
4039 elf64_hppa_finish_dynamic_sections
4040 #define elf_backend_grok_prstatus elf64_hppa_grok_prstatus
4041 #define elf_backend_grok_psinfo elf64_hppa_grok_psinfo
4043 /* Stuff for the BFD linker: */
4044 #define bfd_elf64_bfd_link_hash_table_create \
4045 elf64_hppa_hash_table_create
4047 #define elf_backend_check_relocs \
4048 elf64_hppa_check_relocs
4050 #define elf_backend_size_info \
4051 hppa64_elf_size_info
4053 #define elf_backend_additional_program_headers \
4054 elf64_hppa_additional_program_headers
4056 #define elf_backend_modify_segment_map \
4057 elf64_hppa_modify_segment_map
4059 #define elf_backend_allow_non_load_phdr \
4060 elf64_hppa_allow_non_load_phdr
4062 #define elf_backend_link_output_symbol_hook \
4063 elf64_hppa_link_output_symbol_hook
4065 #define elf_backend_want_got_plt 0
4066 #define elf_backend_plt_readonly 0
4067 #define elf_backend_want_plt_sym 0
4068 #define elf_backend_got_header_size 0
4069 #define elf_backend_type_change_ok TRUE
4070 #define elf_backend_get_symbol_type elf64_hppa_elf_get_symbol_type
4071 #define elf_backend_reloc_type_class elf64_hppa_reloc_type_class
4072 #define elf_backend_rela_normal 1
4073 #define elf_backend_special_sections elf64_hppa_special_sections
4074 #define elf_backend_action_discarded elf_hppa_action_discarded
4075 #define elf_backend_section_from_phdr elf64_hppa_section_from_phdr
4077 #define elf64_bed elf64_hppa_hpux_bed
4079 #include "elf64-target.h"
4081 #undef TARGET_BIG_SYM
4082 #define TARGET_BIG_SYM hppa_elf64_linux_vec
4083 #undef TARGET_BIG_NAME
4084 #define TARGET_BIG_NAME "elf64-hppa-linux"
4086 #define ELF_OSABI ELFOSABI_GNU
4088 #define elf64_bed elf64_hppa_linux_bed
4089 #undef elf_backend_special_sections
4090 #define elf_backend_special_sections (elf64_hppa_special_sections + 1)
4092 #include "elf64-target.h"