1 /* Support for HPPA 64-bit ELF
2 Copyright (C) 1999-2019 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
*plt_rel_sec
;
123 asection
*opd_rel_sec
;
124 asection
*other_rel_sec
;
126 /* Offset of __gp within .plt section. When the PLT gets large we want
127 to slide __gp into the PLT section so that we can continue to use
128 single DP relative instructions to load values out of the PLT. */
131 /* Note this is not strictly correct. We should create a stub section for
132 each input section with calls. The stub section should be placed before
133 the section with the call. */
136 bfd_vma text_segment_base
;
137 bfd_vma data_segment_base
;
139 /* We build tables to map from an input section back to its
140 symbol index. This is the BFD for which we currently have
142 bfd
*section_syms_bfd
;
144 /* Array of symbol numbers for each input section attached to the
149 #define hppa_link_hash_table(p) \
150 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
151 == HPPA64_ELF_DATA ? ((struct elf64_hppa_link_hash_table *) ((p)->hash)) : NULL)
153 #define hppa_elf_hash_entry(ent) \
154 ((struct elf64_hppa_link_hash_entry *)(ent))
156 #define eh_name(eh) \
157 (eh ? eh->root.root.string : "<undef>")
159 typedef struct bfd_hash_entry
*(*new_hash_entry_func
)
160 (struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *);
162 static struct bfd_link_hash_table
*elf64_hppa_hash_table_create
165 /* This must follow the definitions of the various derived linker
166 hash tables and shared functions. */
167 #include "elf-hppa.h"
169 static bfd_boolean elf64_hppa_object_p
172 static void elf64_hppa_post_process_headers
173 (bfd
*, struct bfd_link_info
*);
175 static bfd_boolean elf64_hppa_create_dynamic_sections
176 (bfd
*, struct bfd_link_info
*);
178 static bfd_boolean elf64_hppa_adjust_dynamic_symbol
179 (struct bfd_link_info
*, struct elf_link_hash_entry
*);
181 static bfd_boolean elf64_hppa_mark_milli_and_exported_functions
182 (struct elf_link_hash_entry
*, void *);
184 static bfd_boolean elf64_hppa_size_dynamic_sections
185 (bfd
*, struct bfd_link_info
*);
187 static int elf64_hppa_link_output_symbol_hook
188 (struct bfd_link_info
*, const char *, Elf_Internal_Sym
*,
189 asection
*, struct elf_link_hash_entry
*);
191 static bfd_boolean elf64_hppa_finish_dynamic_symbol
192 (bfd
*, struct bfd_link_info
*,
193 struct elf_link_hash_entry
*, Elf_Internal_Sym
*);
195 static bfd_boolean elf64_hppa_finish_dynamic_sections
196 (bfd
*, struct bfd_link_info
*);
198 static bfd_boolean elf64_hppa_check_relocs
199 (bfd
*, struct bfd_link_info
*,
200 asection
*, const Elf_Internal_Rela
*);
202 static bfd_boolean elf64_hppa_dynamic_symbol_p
203 (struct elf_link_hash_entry
*, struct bfd_link_info
*);
205 static bfd_boolean elf64_hppa_mark_exported_functions
206 (struct elf_link_hash_entry
*, void *);
208 static bfd_boolean elf64_hppa_finalize_opd
209 (struct elf_link_hash_entry
*, void *);
211 static bfd_boolean elf64_hppa_finalize_dlt
212 (struct elf_link_hash_entry
*, void *);
214 static bfd_boolean allocate_global_data_dlt
215 (struct elf_link_hash_entry
*, void *);
217 static bfd_boolean allocate_global_data_plt
218 (struct elf_link_hash_entry
*, void *);
220 static bfd_boolean allocate_global_data_stub
221 (struct elf_link_hash_entry
*, void *);
223 static bfd_boolean allocate_global_data_opd
224 (struct elf_link_hash_entry
*, void *);
226 static bfd_boolean get_reloc_section
227 (bfd
*, struct elf64_hppa_link_hash_table
*, asection
*);
229 static bfd_boolean count_dyn_reloc
230 (bfd
*, struct elf64_hppa_link_hash_entry
*,
231 int, asection
*, int, bfd_vma
, bfd_vma
);
233 static bfd_boolean allocate_dynrel_entries
234 (struct elf_link_hash_entry
*, void *);
236 static bfd_boolean elf64_hppa_finalize_dynreloc
237 (struct elf_link_hash_entry
*, void *);
239 static bfd_boolean get_opd
240 (bfd
*, struct bfd_link_info
*, struct elf64_hppa_link_hash_table
*);
242 static bfd_boolean get_plt
243 (bfd
*, struct bfd_link_info
*, struct elf64_hppa_link_hash_table
*);
245 static bfd_boolean get_dlt
246 (bfd
*, struct bfd_link_info
*, struct elf64_hppa_link_hash_table
*);
248 static bfd_boolean get_stub
249 (bfd
*, struct bfd_link_info
*, struct elf64_hppa_link_hash_table
*);
251 static int elf64_hppa_elf_get_symbol_type
252 (Elf_Internal_Sym
*, int);
254 /* Initialize an entry in the link hash table. */
256 static struct bfd_hash_entry
*
257 hppa64_link_hash_newfunc (struct bfd_hash_entry
*entry
,
258 struct bfd_hash_table
*table
,
261 /* Allocate the structure if it has not already been allocated by a
265 entry
= bfd_hash_allocate (table
,
266 sizeof (struct elf64_hppa_link_hash_entry
));
271 /* Call the allocation method of the superclass. */
272 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
275 struct elf64_hppa_link_hash_entry
*hh
;
277 /* Initialize our local data. All zeros. */
278 hh
= hppa_elf_hash_entry (entry
);
279 memset (&hh
->dlt_offset
, 0,
280 (sizeof (struct elf64_hppa_link_hash_entry
)
281 - offsetof (struct elf64_hppa_link_hash_entry
, dlt_offset
)));
287 /* Create the derived linker hash table. The PA64 ELF port uses this
288 derived hash table to keep information specific to the PA ElF
289 linker (without using static variables). */
291 static struct bfd_link_hash_table
*
292 elf64_hppa_hash_table_create (bfd
*abfd
)
294 struct elf64_hppa_link_hash_table
*htab
;
295 bfd_size_type amt
= sizeof (*htab
);
297 htab
= bfd_zmalloc (amt
);
301 if (!_bfd_elf_link_hash_table_init (&htab
->root
, abfd
,
302 hppa64_link_hash_newfunc
,
303 sizeof (struct elf64_hppa_link_hash_entry
),
310 htab
->text_segment_base
= (bfd_vma
) -1;
311 htab
->data_segment_base
= (bfd_vma
) -1;
313 return &htab
->root
.root
;
316 /* Return nonzero if ABFD represents a PA2.0 ELF64 file.
318 Additionally we set the default architecture and machine. */
320 elf64_hppa_object_p (bfd
*abfd
)
322 Elf_Internal_Ehdr
* i_ehdrp
;
325 i_ehdrp
= elf_elfheader (abfd
);
326 if (strcmp (bfd_get_target (abfd
), "elf64-hppa-linux") == 0)
328 /* GCC on hppa-linux produces binaries with OSABI=GNU,
329 but the kernel produces corefiles with OSABI=SysV. */
330 if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_GNU
331 && i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_NONE
) /* aka SYSV */
336 /* HPUX produces binaries with OSABI=HPUX,
337 but the kernel produces corefiles with OSABI=SysV. */
338 if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_HPUX
339 && i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_NONE
) /* aka SYSV */
343 flags
= i_ehdrp
->e_flags
;
344 switch (flags
& (EF_PARISC_ARCH
| EF_PARISC_WIDE
))
347 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 10);
349 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 11);
351 if (i_ehdrp
->e_ident
[EI_CLASS
] == ELFCLASS64
)
352 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 25);
354 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 20);
355 case EFA_PARISC_2_0
| EF_PARISC_WIDE
:
356 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 25);
358 /* Don't be fussy. */
362 /* Given section type (hdr->sh_type), return a boolean indicating
363 whether or not the section is an elf64-hppa specific section. */
365 elf64_hppa_section_from_shdr (bfd
*abfd
,
366 Elf_Internal_Shdr
*hdr
,
370 switch (hdr
->sh_type
)
373 if (strcmp (name
, ".PARISC.archext") != 0)
376 case SHT_PARISC_UNWIND
:
377 if (strcmp (name
, ".PARISC.unwind") != 0)
381 case SHT_PARISC_ANNOT
:
386 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
392 /* SEC is a section containing relocs for an input BFD when linking; return
393 a suitable section for holding relocs in the output BFD for a link. */
396 get_reloc_section (bfd
*abfd
,
397 struct elf64_hppa_link_hash_table
*hppa_info
,
400 const char *srel_name
;
404 srel_name
= (bfd_elf_string_from_elf_section
405 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
406 _bfd_elf_single_rel_hdr(sec
)->sh_name
));
407 if (srel_name
== NULL
)
410 dynobj
= hppa_info
->root
.dynobj
;
412 hppa_info
->root
.dynobj
= dynobj
= abfd
;
414 srel
= bfd_get_linker_section (dynobj
, srel_name
);
417 srel
= bfd_make_section_anyway_with_flags (dynobj
, srel_name
,
425 || !bfd_set_section_alignment (srel
, 3))
429 hppa_info
->other_rel_sec
= srel
;
433 /* Add a new entry to the list of dynamic relocations against DYN_H.
435 We use this to keep a record of all the FPTR relocations against a
436 particular symbol so that we can create FPTR relocations in the
440 count_dyn_reloc (bfd
*abfd
,
441 struct elf64_hppa_link_hash_entry
*hh
,
448 struct elf64_hppa_dyn_reloc_entry
*rent
;
450 rent
= (struct elf64_hppa_dyn_reloc_entry
*)
451 bfd_alloc (abfd
, (bfd_size_type
) sizeof (*rent
));
455 rent
->next
= hh
->reloc_entries
;
458 rent
->sec_symndx
= sec_symndx
;
459 rent
->offset
= offset
;
460 rent
->addend
= addend
;
461 hh
->reloc_entries
= rent
;
466 /* Return a pointer to the local DLT, PLT and OPD reference counts
467 for ABFD. Returns NULL if the storage allocation fails. */
469 static bfd_signed_vma
*
470 hppa64_elf_local_refcounts (bfd
*abfd
)
472 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
473 bfd_signed_vma
*local_refcounts
;
475 local_refcounts
= elf_local_got_refcounts (abfd
);
476 if (local_refcounts
== NULL
)
480 /* Allocate space for local DLT, PLT and OPD reference
481 counts. Done this way to save polluting elf_obj_tdata
482 with another target specific pointer. */
483 size
= symtab_hdr
->sh_info
;
484 size
*= 3 * sizeof (bfd_signed_vma
);
485 local_refcounts
= bfd_zalloc (abfd
, size
);
486 elf_local_got_refcounts (abfd
) = local_refcounts
;
488 return local_refcounts
;
491 /* Scan the RELOCS and record the type of dynamic entries that each
492 referenced symbol needs. */
495 elf64_hppa_check_relocs (bfd
*abfd
,
496 struct bfd_link_info
*info
,
498 const Elf_Internal_Rela
*relocs
)
500 struct elf64_hppa_link_hash_table
*hppa_info
;
501 const Elf_Internal_Rela
*relend
;
502 Elf_Internal_Shdr
*symtab_hdr
;
503 const Elf_Internal_Rela
*rel
;
504 unsigned int sec_symndx
;
506 if (bfd_link_relocatable (info
))
509 /* If this is the first dynamic object found in the link, create
510 the special sections required for dynamic linking. */
511 if (! elf_hash_table (info
)->dynamic_sections_created
)
513 if (! _bfd_elf_link_create_dynamic_sections (abfd
, info
))
517 hppa_info
= hppa_link_hash_table (info
);
518 if (hppa_info
== NULL
)
520 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
522 /* If necessary, build a new table holding section symbols indices
525 if (bfd_link_pic (info
) && hppa_info
->section_syms_bfd
!= abfd
)
528 unsigned int highest_shndx
;
529 Elf_Internal_Sym
*local_syms
= NULL
;
530 Elf_Internal_Sym
*isym
, *isymend
;
533 /* We're done with the old cache of section index to section symbol
534 index information. Free it.
536 ?!? Note we leak the last section_syms array. Presumably we
537 could free it in one of the later routines in this file. */
538 if (hppa_info
->section_syms
)
539 free (hppa_info
->section_syms
);
541 /* Read this BFD's local symbols. */
542 if (symtab_hdr
->sh_info
!= 0)
544 local_syms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
545 if (local_syms
== NULL
)
546 local_syms
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
547 symtab_hdr
->sh_info
, 0,
549 if (local_syms
== NULL
)
553 /* Record the highest section index referenced by the local symbols. */
555 isymend
= local_syms
+ symtab_hdr
->sh_info
;
556 for (isym
= local_syms
; isym
< isymend
; isym
++)
558 if (isym
->st_shndx
> highest_shndx
559 && isym
->st_shndx
< SHN_LORESERVE
)
560 highest_shndx
= isym
->st_shndx
;
563 /* Allocate an array to hold the section index to section symbol index
564 mapping. Bump by one since we start counting at zero. */
568 hppa_info
->section_syms
= (int *) bfd_malloc (amt
);
570 /* Now walk the local symbols again. If we find a section symbol,
571 record the index of the symbol into the section_syms array. */
572 for (i
= 0, isym
= local_syms
; isym
< isymend
; i
++, isym
++)
574 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
575 hppa_info
->section_syms
[isym
->st_shndx
] = i
;
578 /* We are finished with the local symbols. */
579 if (local_syms
!= NULL
580 && symtab_hdr
->contents
!= (unsigned char *) local_syms
)
582 if (! info
->keep_memory
)
586 /* Cache the symbols for elf_link_input_bfd. */
587 symtab_hdr
->contents
= (unsigned char *) local_syms
;
591 /* Record which BFD we built the section_syms mapping for. */
592 hppa_info
->section_syms_bfd
= abfd
;
595 /* Record the symbol index for this input section. We may need it for
596 relocations when building shared libraries. When not building shared
597 libraries this value is never really used, but assign it to zero to
598 prevent out of bounds memory accesses in other routines. */
599 if (bfd_link_pic (info
))
601 sec_symndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
603 /* If we did not find a section symbol for this section, then
604 something went terribly wrong above. */
605 if (sec_symndx
== SHN_BAD
)
608 if (sec_symndx
< SHN_LORESERVE
)
609 sec_symndx
= hppa_info
->section_syms
[sec_symndx
];
616 relend
= relocs
+ sec
->reloc_count
;
617 for (rel
= relocs
; rel
< relend
; ++rel
)
628 unsigned long r_symndx
= ELF64_R_SYM (rel
->r_info
);
629 struct elf64_hppa_link_hash_entry
*hh
;
631 bfd_boolean maybe_dynamic
;
632 int dynrel_type
= R_PARISC_NONE
;
633 static reloc_howto_type
*howto
;
635 if (r_symndx
>= symtab_hdr
->sh_info
)
637 /* We're dealing with a global symbol -- find its hash entry
638 and mark it as being referenced. */
639 long indx
= r_symndx
- symtab_hdr
->sh_info
;
640 hh
= hppa_elf_hash_entry (elf_sym_hashes (abfd
)[indx
]);
641 while (hh
->eh
.root
.type
== bfd_link_hash_indirect
642 || hh
->eh
.root
.type
== bfd_link_hash_warning
)
643 hh
= hppa_elf_hash_entry (hh
->eh
.root
.u
.i
.link
);
645 /* PR15323, ref flags aren't set for references in the same
647 hh
->eh
.ref_regular
= 1;
652 /* We can only get preliminary data on whether a symbol is
653 locally or externally defined, as not all of the input files
654 have yet been processed. Do something with what we know, as
655 this may help reduce memory usage and processing time later. */
656 maybe_dynamic
= FALSE
;
657 if (hh
&& ((bfd_link_pic (info
)
659 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
660 || !hh
->eh
.def_regular
661 || hh
->eh
.root
.type
== bfd_link_hash_defweak
))
662 maybe_dynamic
= TRUE
;
664 howto
= elf_hppa_howto_table
+ ELF64_R_TYPE (rel
->r_info
);
668 /* These are simple indirect references to symbols through the
669 DLT. We need to create a DLT entry for any symbols which
670 appears in a DLTIND relocation. */
671 case R_PARISC_DLTIND21L
:
672 case R_PARISC_DLTIND14R
:
673 case R_PARISC_DLTIND14F
:
674 case R_PARISC_DLTIND14WR
:
675 case R_PARISC_DLTIND14DR
:
676 need_entry
= NEED_DLT
;
679 /* ?!? These need a DLT entry. But I have no idea what to do with
680 the "link time TP value. */
681 case R_PARISC_LTOFF_TP21L
:
682 case R_PARISC_LTOFF_TP14R
:
683 case R_PARISC_LTOFF_TP14F
:
684 case R_PARISC_LTOFF_TP64
:
685 case R_PARISC_LTOFF_TP14WR
:
686 case R_PARISC_LTOFF_TP14DR
:
687 case R_PARISC_LTOFF_TP16F
:
688 case R_PARISC_LTOFF_TP16WF
:
689 case R_PARISC_LTOFF_TP16DF
:
690 need_entry
= NEED_DLT
;
693 /* These are function calls. Depending on their precise target we
694 may need to make a stub for them. The stub uses the PLT, so we
695 need to create PLT entries for these symbols too. */
696 case R_PARISC_PCREL12F
:
697 case R_PARISC_PCREL17F
:
698 case R_PARISC_PCREL22F
:
699 case R_PARISC_PCREL32
:
700 case R_PARISC_PCREL64
:
701 case R_PARISC_PCREL21L
:
702 case R_PARISC_PCREL17R
:
703 case R_PARISC_PCREL17C
:
704 case R_PARISC_PCREL14R
:
705 case R_PARISC_PCREL14F
:
706 case R_PARISC_PCREL22C
:
707 case R_PARISC_PCREL14WR
:
708 case R_PARISC_PCREL14DR
:
709 case R_PARISC_PCREL16F
:
710 case R_PARISC_PCREL16WF
:
711 case R_PARISC_PCREL16DF
:
712 /* Function calls might need to go through the .plt, and
713 might need a long branch stub. */
714 if (hh
!= NULL
&& hh
->eh
.type
!= STT_PARISC_MILLI
)
715 need_entry
= (NEED_PLT
| NEED_STUB
);
720 case R_PARISC_PLTOFF21L
:
721 case R_PARISC_PLTOFF14R
:
722 case R_PARISC_PLTOFF14F
:
723 case R_PARISC_PLTOFF14WR
:
724 case R_PARISC_PLTOFF14DR
:
725 case R_PARISC_PLTOFF16F
:
726 case R_PARISC_PLTOFF16WF
:
727 case R_PARISC_PLTOFF16DF
:
728 need_entry
= (NEED_PLT
);
732 if (bfd_link_pic (info
) || maybe_dynamic
)
733 need_entry
= (NEED_DYNREL
);
734 dynrel_type
= R_PARISC_DIR64
;
737 /* This is an indirect reference through the DLT to get the address
738 of a OPD descriptor. Thus we need to make a DLT entry that points
740 case R_PARISC_LTOFF_FPTR21L
:
741 case R_PARISC_LTOFF_FPTR14R
:
742 case R_PARISC_LTOFF_FPTR14WR
:
743 case R_PARISC_LTOFF_FPTR14DR
:
744 case R_PARISC_LTOFF_FPTR32
:
745 case R_PARISC_LTOFF_FPTR64
:
746 case R_PARISC_LTOFF_FPTR16F
:
747 case R_PARISC_LTOFF_FPTR16WF
:
748 case R_PARISC_LTOFF_FPTR16DF
:
749 if (bfd_link_pic (info
) || maybe_dynamic
)
750 need_entry
= (NEED_DLT
| NEED_OPD
| NEED_PLT
);
752 need_entry
= (NEED_DLT
| NEED_OPD
| NEED_PLT
);
753 dynrel_type
= R_PARISC_FPTR64
;
756 /* This is a simple OPD entry. */
757 case R_PARISC_FPTR64
:
758 if (bfd_link_pic (info
) || maybe_dynamic
)
759 need_entry
= (NEED_OPD
| NEED_PLT
| NEED_DYNREL
);
761 need_entry
= (NEED_OPD
| NEED_PLT
);
762 dynrel_type
= R_PARISC_FPTR64
;
765 /* Add more cases as needed. */
773 /* Stash away enough information to be able to find this symbol
774 regardless of whether or not it is local or global. */
776 hh
->sym_indx
= r_symndx
;
779 /* Create what's needed. */
780 if (need_entry
& NEED_DLT
)
782 /* Allocate space for a DLT entry, as well as a dynamic
783 relocation for this entry. */
784 if (! hppa_info
->dlt_sec
785 && ! get_dlt (abfd
, info
, hppa_info
))
791 hh
->eh
.got
.refcount
+= 1;
795 bfd_signed_vma
*local_dlt_refcounts
;
797 /* This is a DLT entry for a local symbol. */
798 local_dlt_refcounts
= hppa64_elf_local_refcounts (abfd
);
799 if (local_dlt_refcounts
== NULL
)
801 local_dlt_refcounts
[r_symndx
] += 1;
805 if (need_entry
& NEED_PLT
)
807 if (! hppa_info
->plt_sec
808 && ! get_plt (abfd
, info
, hppa_info
))
814 hh
->eh
.needs_plt
= 1;
815 hh
->eh
.plt
.refcount
+= 1;
819 bfd_signed_vma
*local_dlt_refcounts
;
820 bfd_signed_vma
*local_plt_refcounts
;
822 /* This is a PLT entry for a local symbol. */
823 local_dlt_refcounts
= hppa64_elf_local_refcounts (abfd
);
824 if (local_dlt_refcounts
== NULL
)
826 local_plt_refcounts
= local_dlt_refcounts
+ symtab_hdr
->sh_info
;
827 local_plt_refcounts
[r_symndx
] += 1;
831 if (need_entry
& NEED_STUB
)
833 if (! hppa_info
->stub_sec
834 && ! get_stub (abfd
, info
, hppa_info
))
840 if (need_entry
& NEED_OPD
)
842 if (! hppa_info
->opd_sec
843 && ! get_opd (abfd
, info
, hppa_info
))
846 /* FPTRs are not allocated by the dynamic linker for PA64,
847 though it is possible that will change in the future. */
853 bfd_signed_vma
*local_dlt_refcounts
;
854 bfd_signed_vma
*local_opd_refcounts
;
856 /* This is a OPD for a local symbol. */
857 local_dlt_refcounts
= hppa64_elf_local_refcounts (abfd
);
858 if (local_dlt_refcounts
== NULL
)
860 local_opd_refcounts
= (local_dlt_refcounts
861 + 2 * symtab_hdr
->sh_info
);
862 local_opd_refcounts
[r_symndx
] += 1;
866 /* Add a new dynamic relocation to the chain of dynamic
867 relocations for this symbol. */
868 if ((need_entry
& NEED_DYNREL
) && (sec
->flags
& SEC_ALLOC
))
870 if (! hppa_info
->other_rel_sec
871 && ! get_reloc_section (abfd
, hppa_info
, sec
))
874 /* Count dynamic relocations against global symbols. */
876 && !count_dyn_reloc (abfd
, hh
, dynrel_type
, sec
,
877 sec_symndx
, rel
->r_offset
, rel
->r_addend
))
880 /* If we are building a shared library and we just recorded
881 a dynamic R_PARISC_FPTR64 relocation, then make sure the
882 section symbol for this section ends up in the dynamic
884 if (bfd_link_pic (info
) && dynrel_type
== R_PARISC_FPTR64
885 && ! (bfd_elf_link_record_local_dynamic_symbol
886 (info
, abfd
, sec_symndx
)))
897 struct elf64_hppa_allocate_data
899 struct bfd_link_info
*info
;
903 /* Should we do dynamic things to this symbol? */
906 elf64_hppa_dynamic_symbol_p (struct elf_link_hash_entry
*eh
,
907 struct bfd_link_info
*info
)
909 /* ??? What, if anything, needs to happen wrt STV_PROTECTED symbols
910 and relocations that retrieve a function descriptor? Assume the
912 if (_bfd_elf_dynamic_symbol_p (eh
, info
, 1))
914 /* ??? Why is this here and not elsewhere is_local_label_name. */
915 if (eh
->root
.root
.string
[0] == '$' && eh
->root
.root
.string
[1] == '$')
924 /* Mark all functions exported by this file so that we can later allocate
925 entries in .opd for them. */
928 elf64_hppa_mark_exported_functions (struct elf_link_hash_entry
*eh
, void *data
)
930 struct elf64_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
931 struct bfd_link_info
*info
= (struct bfd_link_info
*)data
;
932 struct elf64_hppa_link_hash_table
*hppa_info
;
934 hppa_info
= hppa_link_hash_table (info
);
935 if (hppa_info
== NULL
)
939 && (eh
->root
.type
== bfd_link_hash_defined
940 || eh
->root
.type
== bfd_link_hash_defweak
)
941 && eh
->root
.u
.def
.section
->output_section
!= NULL
942 && eh
->type
== STT_FUNC
)
944 if (! hppa_info
->opd_sec
945 && ! get_opd (hppa_info
->root
.dynobj
, info
, hppa_info
))
950 /* Put a flag here for output_symbol_hook. */
958 /* Allocate space for a DLT entry. */
961 allocate_global_data_dlt (struct elf_link_hash_entry
*eh
, void *data
)
963 struct elf64_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
964 struct elf64_hppa_allocate_data
*x
= (struct elf64_hppa_allocate_data
*)data
;
968 if (bfd_link_pic (x
->info
))
970 /* Possibly add the symbol to the local dynamic symbol
971 table since we might need to create a dynamic relocation
973 if (eh
->dynindx
== -1 && eh
->type
!= STT_PARISC_MILLI
)
975 bfd
*owner
= eh
->root
.u
.def
.section
->owner
;
977 if (! (bfd_elf_link_record_local_dynamic_symbol
978 (x
->info
, owner
, hh
->sym_indx
)))
983 hh
->dlt_offset
= x
->ofs
;
984 x
->ofs
+= DLT_ENTRY_SIZE
;
989 /* Allocate space for a DLT.PLT entry. */
992 allocate_global_data_plt (struct elf_link_hash_entry
*eh
, void *data
)
994 struct elf64_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
995 struct elf64_hppa_allocate_data
*x
= (struct elf64_hppa_allocate_data
*) data
;
998 && elf64_hppa_dynamic_symbol_p (eh
, x
->info
)
999 && !((eh
->root
.type
== bfd_link_hash_defined
1000 || eh
->root
.type
== bfd_link_hash_defweak
)
1001 && eh
->root
.u
.def
.section
->output_section
!= NULL
))
1003 hh
->plt_offset
= x
->ofs
;
1004 x
->ofs
+= PLT_ENTRY_SIZE
;
1005 if (hh
->plt_offset
< 0x2000)
1007 struct elf64_hppa_link_hash_table
*hppa_info
;
1009 hppa_info
= hppa_link_hash_table (x
->info
);
1010 if (hppa_info
== NULL
)
1013 hppa_info
->gp_offset
= hh
->plt_offset
;
1022 /* Allocate space for a STUB entry. */
1025 allocate_global_data_stub (struct elf_link_hash_entry
*eh
, void *data
)
1027 struct elf64_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
1028 struct elf64_hppa_allocate_data
*x
= (struct elf64_hppa_allocate_data
*)data
;
1031 && elf64_hppa_dynamic_symbol_p (eh
, x
->info
)
1032 && !((eh
->root
.type
== bfd_link_hash_defined
1033 || eh
->root
.type
== bfd_link_hash_defweak
)
1034 && eh
->root
.u
.def
.section
->output_section
!= NULL
))
1036 hh
->stub_offset
= x
->ofs
;
1037 x
->ofs
+= sizeof (plt_stub
);
1044 /* Allocate space for a FPTR entry. */
1047 allocate_global_data_opd (struct elf_link_hash_entry
*eh
, void *data
)
1049 struct elf64_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
1050 struct elf64_hppa_allocate_data
*x
= (struct elf64_hppa_allocate_data
*)data
;
1052 if (hh
&& hh
->want_opd
)
1054 /* We never need an opd entry for a symbol which is not
1055 defined by this output file. */
1056 if (hh
&& (hh
->eh
.root
.type
== bfd_link_hash_undefined
1057 || hh
->eh
.root
.type
== bfd_link_hash_undefweak
1058 || hh
->eh
.root
.u
.def
.section
->output_section
== NULL
))
1061 /* If we are creating a shared library, took the address of a local
1062 function or might export this function from this object file, then
1063 we have to create an opd descriptor. */
1064 else if (bfd_link_pic (x
->info
)
1066 || (hh
->eh
.dynindx
== -1 && hh
->eh
.type
!= STT_PARISC_MILLI
)
1067 || (hh
->eh
.root
.type
== bfd_link_hash_defined
1068 || hh
->eh
.root
.type
== bfd_link_hash_defweak
))
1070 /* If we are creating a shared library, then we will have to
1071 create a runtime relocation for the symbol to properly
1072 initialize the .opd entry. Make sure the symbol gets
1073 added to the dynamic symbol table. */
1074 if (bfd_link_pic (x
->info
)
1075 && (hh
== NULL
|| (hh
->eh
.dynindx
== -1)))
1078 /* PR 6511: Default to using the dynamic symbol table. */
1079 owner
= (hh
->owner
? hh
->owner
: eh
->root
.u
.def
.section
->owner
);
1081 if (!bfd_elf_link_record_local_dynamic_symbol
1082 (x
->info
, owner
, hh
->sym_indx
))
1086 /* This may not be necessary or desirable anymore now that
1087 we have some support for dealing with section symbols
1088 in dynamic relocs. But name munging does make the result
1089 much easier to debug. ie, the EPLT reloc will reference
1090 a symbol like .foobar, instead of .text + offset. */
1091 if (bfd_link_pic (x
->info
) && eh
)
1094 struct elf_link_hash_entry
*nh
;
1096 new_name
= concat (".", eh
->root
.root
.string
, NULL
);
1098 nh
= elf_link_hash_lookup (elf_hash_table (x
->info
),
1099 new_name
, TRUE
, TRUE
, TRUE
);
1102 nh
->root
.type
= eh
->root
.type
;
1103 nh
->root
.u
.def
.value
= eh
->root
.u
.def
.value
;
1104 nh
->root
.u
.def
.section
= eh
->root
.u
.def
.section
;
1106 if (! bfd_elf_link_record_dynamic_symbol (x
->info
, nh
))
1109 hh
->opd_offset
= x
->ofs
;
1110 x
->ofs
+= OPD_ENTRY_SIZE
;
1113 /* Otherwise we do not need an opd entry. */
1120 /* HP requires the EI_OSABI field to be filled in. The assignment to
1121 EI_ABIVERSION may not be strictly necessary. */
1124 elf64_hppa_post_process_headers (bfd
*abfd
,
1125 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
1127 Elf_Internal_Ehdr
* i_ehdrp
;
1129 i_ehdrp
= elf_elfheader (abfd
);
1131 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
1132 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 1;
1135 /* Create function descriptor section (.opd). This section is called .opd
1136 because it contains "official procedure descriptors". The "official"
1137 refers to the fact that these descriptors are used when taking the address
1138 of a procedure, thus ensuring a unique address for each procedure. */
1142 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1143 struct elf64_hppa_link_hash_table
*hppa_info
)
1148 opd
= hppa_info
->opd_sec
;
1151 dynobj
= hppa_info
->root
.dynobj
;
1153 hppa_info
->root
.dynobj
= dynobj
= abfd
;
1155 opd
= bfd_make_section_anyway_with_flags (dynobj
, ".opd",
1160 | SEC_LINKER_CREATED
));
1162 || !bfd_set_section_alignment (opd
, 3))
1168 hppa_info
->opd_sec
= opd
;
1174 /* Create the PLT section. */
1178 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1179 struct elf64_hppa_link_hash_table
*hppa_info
)
1184 plt
= hppa_info
->plt_sec
;
1187 dynobj
= hppa_info
->root
.dynobj
;
1189 hppa_info
->root
.dynobj
= dynobj
= abfd
;
1191 plt
= bfd_make_section_anyway_with_flags (dynobj
, ".plt",
1196 | SEC_LINKER_CREATED
));
1198 || !bfd_set_section_alignment (plt
, 3))
1204 hppa_info
->plt_sec
= plt
;
1210 /* Create the DLT section. */
1214 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1215 struct elf64_hppa_link_hash_table
*hppa_info
)
1220 dlt
= hppa_info
->dlt_sec
;
1223 dynobj
= hppa_info
->root
.dynobj
;
1225 hppa_info
->root
.dynobj
= dynobj
= abfd
;
1227 dlt
= bfd_make_section_anyway_with_flags (dynobj
, ".dlt",
1232 | SEC_LINKER_CREATED
));
1234 || !bfd_set_section_alignment (dlt
, 3))
1240 hppa_info
->dlt_sec
= dlt
;
1246 /* Create the stubs section. */
1249 get_stub (bfd
*abfd
,
1250 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1251 struct elf64_hppa_link_hash_table
*hppa_info
)
1256 stub
= hppa_info
->stub_sec
;
1259 dynobj
= hppa_info
->root
.dynobj
;
1261 hppa_info
->root
.dynobj
= dynobj
= abfd
;
1263 stub
= bfd_make_section_anyway_with_flags (dynobj
, ".stub",
1264 (SEC_ALLOC
| SEC_LOAD
1268 | SEC_LINKER_CREATED
));
1270 || !bfd_set_section_alignment (stub
, 3))
1276 hppa_info
->stub_sec
= stub
;
1282 /* Create sections necessary for dynamic linking. This is only a rough
1283 cut and will likely change as we learn more about the somewhat
1284 unusual dynamic linking scheme HP uses.
1287 Contains code to implement cross-space calls. The first time one
1288 of the stubs is used it will call into the dynamic linker, later
1289 calls will go straight to the target.
1291 The only stub we support right now looks like
1295 ldd OFFSET+8(%dp),%dp
1297 Other stubs may be needed in the future. We may want the remove
1298 the break/nop instruction. It is only used right now to keep the
1299 offset of a .plt entry and a .stub entry in sync.
1302 This is what most people call the .got. HP used a different name.
1306 Relocations for the DLT.
1309 Function pointers as address,gp pairs.
1312 Should contain dynamic IPLT (and EPLT?) relocations.
1318 EPLT relocations for symbols exported from shared libraries. */
1321 elf64_hppa_create_dynamic_sections (bfd
*abfd
,
1322 struct bfd_link_info
*info
)
1325 struct elf64_hppa_link_hash_table
*hppa_info
;
1327 hppa_info
= hppa_link_hash_table (info
);
1328 if (hppa_info
== NULL
)
1331 if (! get_stub (abfd
, info
, hppa_info
))
1334 if (! get_dlt (abfd
, info
, hppa_info
))
1337 if (! get_plt (abfd
, info
, hppa_info
))
1340 if (! get_opd (abfd
, info
, hppa_info
))
1343 s
= bfd_make_section_anyway_with_flags (abfd
, ".rela.dlt",
1344 (SEC_ALLOC
| SEC_LOAD
1348 | SEC_LINKER_CREATED
));
1350 || !bfd_set_section_alignment (s
, 3))
1352 hppa_info
->dlt_rel_sec
= s
;
1354 s
= bfd_make_section_anyway_with_flags (abfd
, ".rela.plt",
1355 (SEC_ALLOC
| SEC_LOAD
1359 | SEC_LINKER_CREATED
));
1361 || !bfd_set_section_alignment (s
, 3))
1363 hppa_info
->plt_rel_sec
= s
;
1365 s
= bfd_make_section_anyway_with_flags (abfd
, ".rela.data",
1366 (SEC_ALLOC
| SEC_LOAD
1370 | SEC_LINKER_CREATED
));
1372 || !bfd_set_section_alignment (s
, 3))
1374 hppa_info
->other_rel_sec
= s
;
1376 s
= bfd_make_section_anyway_with_flags (abfd
, ".rela.opd",
1377 (SEC_ALLOC
| SEC_LOAD
1381 | SEC_LINKER_CREATED
));
1383 || !bfd_set_section_alignment (s
, 3))
1385 hppa_info
->opd_rel_sec
= s
;
1390 /* Allocate dynamic relocations for those symbols that turned out
1394 allocate_dynrel_entries (struct elf_link_hash_entry
*eh
, void *data
)
1396 struct elf64_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
1397 struct elf64_hppa_allocate_data
*x
= (struct elf64_hppa_allocate_data
*)data
;
1398 struct elf64_hppa_link_hash_table
*hppa_info
;
1399 struct elf64_hppa_dyn_reloc_entry
*rent
;
1400 bfd_boolean dynamic_symbol
, shared
;
1402 hppa_info
= hppa_link_hash_table (x
->info
);
1403 if (hppa_info
== NULL
)
1406 dynamic_symbol
= elf64_hppa_dynamic_symbol_p (eh
, x
->info
);
1407 shared
= bfd_link_pic (x
->info
);
1409 /* We may need to allocate relocations for a non-dynamic symbol
1410 when creating a shared library. */
1411 if (!dynamic_symbol
&& !shared
)
1414 /* Take care of the normal data relocations. */
1416 for (rent
= hh
->reloc_entries
; rent
; rent
= rent
->next
)
1418 /* Allocate one iff we are building a shared library, the relocation
1419 isn't a R_PARISC_FPTR64, or we don't want an opd entry. */
1420 if (!shared
&& rent
->type
== R_PARISC_FPTR64
&& hh
->want_opd
)
1423 hppa_info
->other_rel_sec
->size
+= sizeof (Elf64_External_Rela
);
1425 /* Make sure this symbol gets into the dynamic symbol table if it is
1426 not already recorded. ?!? This should not be in the loop since
1427 the symbol need only be added once. */
1428 if (eh
->dynindx
== -1 && eh
->type
!= STT_PARISC_MILLI
)
1429 if (!bfd_elf_link_record_local_dynamic_symbol
1430 (x
->info
, rent
->sec
->owner
, hh
->sym_indx
))
1434 /* Take care of the GOT and PLT relocations. */
1436 if ((dynamic_symbol
|| shared
) && hh
->want_dlt
)
1437 hppa_info
->dlt_rel_sec
->size
+= sizeof (Elf64_External_Rela
);
1439 /* If we are building a shared library, then every symbol that has an
1440 opd entry will need an EPLT relocation to relocate the symbol's address
1441 and __gp value based on the runtime load address. */
1442 if (shared
&& hh
->want_opd
)
1443 hppa_info
->opd_rel_sec
->size
+= sizeof (Elf64_External_Rela
);
1445 if (hh
->want_plt
&& dynamic_symbol
)
1447 bfd_size_type t
= 0;
1449 /* Dynamic symbols get one IPLT relocation. Local symbols in
1450 shared libraries get two REL relocations. Local symbols in
1451 main applications get nothing. */
1453 t
= sizeof (Elf64_External_Rela
);
1455 t
= 2 * sizeof (Elf64_External_Rela
);
1457 hppa_info
->plt_rel_sec
->size
+= t
;
1463 /* Adjust a symbol defined by a dynamic object and referenced by a
1467 elf64_hppa_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1468 struct elf_link_hash_entry
*eh
)
1470 /* ??? Undefined symbols with PLT entries should be re-defined
1471 to be the PLT entry. */
1473 /* If this is a weak symbol, and there is a real definition, the
1474 processor independent code will have arranged for us to see the
1475 real definition first, and we can just use the same value. */
1476 if (eh
->is_weakalias
)
1478 struct elf_link_hash_entry
*def
= weakdef (eh
);
1479 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1480 eh
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1481 eh
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1485 /* If this is a reference to a symbol defined by a dynamic object which
1486 is not a function, we might allocate the symbol in our .dynbss section
1487 and allocate a COPY dynamic relocation.
1489 But PA64 code is canonically PIC, so as a rule we can avoid this sort
1495 /* This function is called via elf_link_hash_traverse to mark millicode
1496 symbols with a dynindx of -1 and to remove the string table reference
1497 from the dynamic symbol table. If the symbol is not a millicode symbol,
1498 elf64_hppa_mark_exported_functions is called. */
1501 elf64_hppa_mark_milli_and_exported_functions (struct elf_link_hash_entry
*eh
,
1504 struct bfd_link_info
*info
= (struct bfd_link_info
*) data
;
1506 if (eh
->type
== STT_PARISC_MILLI
)
1508 if (eh
->dynindx
!= -1)
1511 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1517 return elf64_hppa_mark_exported_functions (eh
, data
);
1520 /* Set the final sizes of the dynamic sections and allocate memory for
1521 the contents of our special sections. */
1524 elf64_hppa_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
1526 struct elf64_hppa_link_hash_table
*hppa_info
;
1527 struct elf64_hppa_allocate_data data
;
1533 bfd_boolean reltext
;
1535 hppa_info
= hppa_link_hash_table (info
);
1536 if (hppa_info
== NULL
)
1539 dynobj
= hppa_info
->root
.dynobj
;
1540 BFD_ASSERT (dynobj
!= NULL
);
1542 /* Mark each function this program exports so that we will allocate
1543 space in the .opd section for each function's FPTR. If we are
1544 creating dynamic sections, change the dynamic index of millicode
1545 symbols to -1 and remove them from the string table for .dynstr.
1547 We have to traverse the main linker hash table since we have to
1548 find functions which may not have been mentioned in any relocs. */
1549 elf_link_hash_traverse (&hppa_info
->root
,
1550 (hppa_info
->root
.dynamic_sections_created
1551 ? elf64_hppa_mark_milli_and_exported_functions
1552 : elf64_hppa_mark_exported_functions
),
1555 if (hppa_info
->root
.dynamic_sections_created
)
1557 /* Set the contents of the .interp section to the interpreter. */
1558 if (bfd_link_executable (info
) && !info
->nointerp
)
1560 sec
= bfd_get_linker_section (dynobj
, ".interp");
1561 BFD_ASSERT (sec
!= NULL
);
1562 sec
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1563 sec
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1568 /* We may have created entries in the .rela.got section.
1569 However, if we are not creating the dynamic sections, we will
1570 not actually use these entries. Reset the size of .rela.dlt,
1571 which will cause it to get stripped from the output file
1573 sec
= hppa_info
->dlt_rel_sec
;
1578 /* Set up DLT, PLT and OPD offsets for local syms, and space for local
1580 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
1582 bfd_signed_vma
*local_dlt
;
1583 bfd_signed_vma
*end_local_dlt
;
1584 bfd_signed_vma
*local_plt
;
1585 bfd_signed_vma
*end_local_plt
;
1586 bfd_signed_vma
*local_opd
;
1587 bfd_signed_vma
*end_local_opd
;
1588 bfd_size_type locsymcount
;
1589 Elf_Internal_Shdr
*symtab_hdr
;
1592 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
1595 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
1597 struct elf64_hppa_dyn_reloc_entry
*hdh_p
;
1599 for (hdh_p
= ((struct elf64_hppa_dyn_reloc_entry
*)
1600 elf_section_data (sec
)->local_dynrel
);
1602 hdh_p
= hdh_p
->next
)
1604 if (!bfd_is_abs_section (hdh_p
->sec
)
1605 && bfd_is_abs_section (hdh_p
->sec
->output_section
))
1607 /* Input section has been discarded, either because
1608 it is a copy of a linkonce section or due to
1609 linker script /DISCARD/, so we'll be discarding
1612 else if (hdh_p
->count
!= 0)
1614 srel
= elf_section_data (hdh_p
->sec
)->sreloc
;
1615 srel
->size
+= hdh_p
->count
* sizeof (Elf64_External_Rela
);
1616 if ((hdh_p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1617 info
->flags
|= DF_TEXTREL
;
1622 local_dlt
= elf_local_got_refcounts (ibfd
);
1626 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1627 locsymcount
= symtab_hdr
->sh_info
;
1628 end_local_dlt
= local_dlt
+ locsymcount
;
1629 sec
= hppa_info
->dlt_sec
;
1630 srel
= hppa_info
->dlt_rel_sec
;
1631 for (; local_dlt
< end_local_dlt
; ++local_dlt
)
1635 *local_dlt
= sec
->size
;
1636 sec
->size
+= DLT_ENTRY_SIZE
;
1637 if (bfd_link_pic (info
))
1639 srel
->size
+= sizeof (Elf64_External_Rela
);
1643 *local_dlt
= (bfd_vma
) -1;
1646 local_plt
= end_local_dlt
;
1647 end_local_plt
= local_plt
+ locsymcount
;
1648 if (! hppa_info
->root
.dynamic_sections_created
)
1650 /* Won't be used, but be safe. */
1651 for (; local_plt
< end_local_plt
; ++local_plt
)
1652 *local_plt
= (bfd_vma
) -1;
1656 sec
= hppa_info
->plt_sec
;
1657 srel
= hppa_info
->plt_rel_sec
;
1658 for (; local_plt
< end_local_plt
; ++local_plt
)
1662 *local_plt
= sec
->size
;
1663 sec
->size
+= PLT_ENTRY_SIZE
;
1664 if (bfd_link_pic (info
))
1665 srel
->size
+= sizeof (Elf64_External_Rela
);
1668 *local_plt
= (bfd_vma
) -1;
1672 local_opd
= end_local_plt
;
1673 end_local_opd
= local_opd
+ locsymcount
;
1674 if (! hppa_info
->root
.dynamic_sections_created
)
1676 /* Won't be used, but be safe. */
1677 for (; local_opd
< end_local_opd
; ++local_opd
)
1678 *local_opd
= (bfd_vma
) -1;
1682 sec
= hppa_info
->opd_sec
;
1683 srel
= hppa_info
->opd_rel_sec
;
1684 for (; local_opd
< end_local_opd
; ++local_opd
)
1688 *local_opd
= sec
->size
;
1689 sec
->size
+= OPD_ENTRY_SIZE
;
1690 if (bfd_link_pic (info
))
1691 srel
->size
+= sizeof (Elf64_External_Rela
);
1694 *local_opd
= (bfd_vma
) -1;
1699 /* Allocate the GOT entries. */
1702 if (hppa_info
->dlt_sec
)
1704 data
.ofs
= hppa_info
->dlt_sec
->size
;
1705 elf_link_hash_traverse (&hppa_info
->root
,
1706 allocate_global_data_dlt
, &data
);
1707 hppa_info
->dlt_sec
->size
= data
.ofs
;
1710 if (hppa_info
->plt_sec
)
1712 data
.ofs
= hppa_info
->plt_sec
->size
;
1713 elf_link_hash_traverse (&hppa_info
->root
,
1714 allocate_global_data_plt
, &data
);
1715 hppa_info
->plt_sec
->size
= data
.ofs
;
1718 if (hppa_info
->stub_sec
)
1721 elf_link_hash_traverse (&hppa_info
->root
,
1722 allocate_global_data_stub
, &data
);
1723 hppa_info
->stub_sec
->size
= data
.ofs
;
1726 /* Allocate space for entries in the .opd section. */
1727 if (hppa_info
->opd_sec
)
1729 data
.ofs
= hppa_info
->opd_sec
->size
;
1730 elf_link_hash_traverse (&hppa_info
->root
,
1731 allocate_global_data_opd
, &data
);
1732 hppa_info
->opd_sec
->size
= data
.ofs
;
1735 /* Now allocate space for dynamic relocations, if necessary. */
1736 if (hppa_info
->root
.dynamic_sections_created
)
1737 elf_link_hash_traverse (&hppa_info
->root
,
1738 allocate_dynrel_entries
, &data
);
1740 /* The sizes of all the sections are set. Allocate memory for them. */
1744 for (sec
= dynobj
->sections
; sec
!= NULL
; sec
= sec
->next
)
1748 if ((sec
->flags
& SEC_LINKER_CREATED
) == 0)
1751 /* It's OK to base decisions on the section name, because none
1752 of the dynobj section names depend upon the input files. */
1753 name
= bfd_section_name (sec
);
1755 if (strcmp (name
, ".plt") == 0)
1757 /* Remember whether there is a PLT. */
1758 plt
= sec
->size
!= 0;
1760 else if (strcmp (name
, ".opd") == 0
1761 || CONST_STRNEQ (name
, ".dlt")
1762 || strcmp (name
, ".stub") == 0
1763 || strcmp (name
, ".got") == 0)
1765 /* Strip this section if we don't need it; see the comment below. */
1767 else if (CONST_STRNEQ (name
, ".rela"))
1773 /* Remember whether there are any reloc sections other
1775 if (strcmp (name
, ".rela.plt") != 0)
1777 const char *outname
;
1781 /* If this relocation section applies to a read only
1782 section, then we probably need a DT_TEXTREL
1783 entry. The entries in the .rela.plt section
1784 really apply to the .got section, which we
1785 created ourselves and so know is not readonly. */
1786 outname
= bfd_section_name (sec
->output_section
);
1787 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
1789 && (target
->flags
& SEC_READONLY
) != 0
1790 && (target
->flags
& SEC_ALLOC
) != 0)
1794 /* We use the reloc_count field as a counter if we need
1795 to copy relocs into the output file. */
1796 sec
->reloc_count
= 0;
1801 /* It's not one of our sections, so don't allocate space. */
1807 /* If we don't need this section, strip it from the
1808 output file. This is mostly to handle .rela.bss and
1809 .rela.plt. We must create both sections in
1810 create_dynamic_sections, because they must be created
1811 before the linker maps input sections to output
1812 sections. The linker does that before
1813 adjust_dynamic_symbol is called, and it is that
1814 function which decides whether anything needs to go
1815 into these sections. */
1816 sec
->flags
|= SEC_EXCLUDE
;
1820 if ((sec
->flags
& SEC_HAS_CONTENTS
) == 0)
1823 /* Allocate memory for the section contents if it has not
1824 been allocated already. We use bfd_zalloc here in case
1825 unused entries are not reclaimed before the section's
1826 contents are written out. This should not happen, but this
1827 way if it does, we get a R_PARISC_NONE reloc instead of
1829 if (sec
->contents
== NULL
)
1831 sec
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, sec
->size
);
1832 if (sec
->contents
== NULL
)
1837 if (hppa_info
->root
.dynamic_sections_created
)
1839 /* Always create a DT_PLTGOT. It actually has nothing to do with
1840 the PLT, it is how we communicate the __gp value of a load
1841 module to the dynamic linker. */
1842 #define add_dynamic_entry(TAG, VAL) \
1843 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1845 if (!add_dynamic_entry (DT_HP_DLD_FLAGS
, 0)
1846 || !add_dynamic_entry (DT_PLTGOT
, 0))
1849 /* Add some entries to the .dynamic section. We fill in the
1850 values later, in elf64_hppa_finish_dynamic_sections, but we
1851 must add the entries now so that we get the correct size for
1852 the .dynamic section. The DT_DEBUG entry is filled in by the
1853 dynamic linker and used by the debugger. */
1854 if (! bfd_link_pic (info
))
1856 if (!add_dynamic_entry (DT_DEBUG
, 0)
1857 || !add_dynamic_entry (DT_HP_DLD_HOOK
, 0)
1858 || !add_dynamic_entry (DT_HP_LOAD_MAP
, 0))
1862 /* Force DT_FLAGS to always be set.
1863 Required by HPUX 11.00 patch PHSS_26559. */
1864 if (!add_dynamic_entry (DT_FLAGS
, (info
)->flags
))
1869 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
1870 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1871 || !add_dynamic_entry (DT_JMPREL
, 0))
1877 if (!add_dynamic_entry (DT_RELA
, 0)
1878 || !add_dynamic_entry (DT_RELASZ
, 0)
1879 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf64_External_Rela
)))
1885 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1887 info
->flags
|= DF_TEXTREL
;
1890 #undef add_dynamic_entry
1895 /* Called after we have output the symbol into the dynamic symbol
1896 table, but before we output the symbol into the normal symbol
1899 For some symbols we had to change their address when outputting
1900 the dynamic symbol table. We undo that change here so that
1901 the symbols have their expected value in the normal symbol
1905 elf64_hppa_link_output_symbol_hook (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1907 Elf_Internal_Sym
*sym
,
1908 asection
*input_sec ATTRIBUTE_UNUSED
,
1909 struct elf_link_hash_entry
*eh
)
1911 struct elf64_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
1913 /* We may be called with the file symbol or section symbols.
1914 They never need munging, so it is safe to ignore them. */
1918 /* Function symbols for which we created .opd entries *may* have been
1919 munged by finish_dynamic_symbol and have to be un-munged here.
1921 Note that finish_dynamic_symbol sometimes turns dynamic symbols
1922 into non-dynamic ones, so we initialize st_shndx to -1 in
1923 mark_exported_functions and check to see if it was overwritten
1924 here instead of just checking eh->dynindx. */
1925 if (hh
->want_opd
&& hh
->st_shndx
!= -1)
1927 /* Restore the saved value and section index. */
1928 sym
->st_value
= hh
->st_value
;
1929 sym
->st_shndx
= hh
->st_shndx
;
1935 /* Finish up dynamic symbol handling. We set the contents of various
1936 dynamic sections here. */
1939 elf64_hppa_finish_dynamic_symbol (bfd
*output_bfd
,
1940 struct bfd_link_info
*info
,
1941 struct elf_link_hash_entry
*eh
,
1942 Elf_Internal_Sym
*sym
)
1944 struct elf64_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
1945 asection
*stub
, *splt
, *sopd
, *spltrel
;
1946 struct elf64_hppa_link_hash_table
*hppa_info
;
1948 hppa_info
= hppa_link_hash_table (info
);
1949 if (hppa_info
== NULL
)
1952 stub
= hppa_info
->stub_sec
;
1953 splt
= hppa_info
->plt_sec
;
1954 sopd
= hppa_info
->opd_sec
;
1955 spltrel
= hppa_info
->plt_rel_sec
;
1957 /* Incredible. It is actually necessary to NOT use the symbol's real
1958 value when building the dynamic symbol table for a shared library.
1959 At least for symbols that refer to functions.
1961 We will store a new value and section index into the symbol long
1962 enough to output it into the dynamic symbol table, then we restore
1963 the original values (in elf64_hppa_link_output_symbol_hook). */
1966 BFD_ASSERT (sopd
!= NULL
);
1968 /* Save away the original value and section index so that we
1969 can restore them later. */
1970 hh
->st_value
= sym
->st_value
;
1971 hh
->st_shndx
= sym
->st_shndx
;
1973 /* For the dynamic symbol table entry, we want the value to be
1974 address of this symbol's entry within the .opd section. */
1975 sym
->st_value
= (hh
->opd_offset
1976 + sopd
->output_offset
1977 + sopd
->output_section
->vma
);
1978 sym
->st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
1979 sopd
->output_section
);
1982 /* Initialize a .plt entry if requested. */
1984 && elf64_hppa_dynamic_symbol_p (eh
, info
))
1987 Elf_Internal_Rela rel
;
1990 BFD_ASSERT (splt
!= NULL
&& spltrel
!= NULL
);
1992 /* We do not actually care about the value in the PLT entry
1993 if we are creating a shared library and the symbol is
1994 still undefined, we create a dynamic relocation to fill
1995 in the correct value. */
1996 if (bfd_link_pic (info
) && eh
->root
.type
== bfd_link_hash_undefined
)
1999 value
= (eh
->root
.u
.def
.value
+ eh
->root
.u
.def
.section
->vma
);
2001 /* Fill in the entry in the procedure linkage table.
2003 The format of a plt entry is
2006 plt_offset is the offset within the PLT section at which to
2007 install the PLT entry.
2009 We are modifying the in-memory PLT contents here, so we do not add
2010 in the output_offset of the PLT section. */
2012 bfd_put_64 (splt
->owner
, value
, splt
->contents
+ hh
->plt_offset
);
2013 value
= _bfd_get_gp_value (info
->output_bfd
);
2014 bfd_put_64 (splt
->owner
, value
, splt
->contents
+ hh
->plt_offset
+ 0x8);
2016 /* Create a dynamic IPLT relocation for this entry.
2018 We are creating a relocation in the output file's PLT section,
2019 which is included within the DLT secton. So we do need to include
2020 the PLT's output_offset in the computation of the relocation's
2022 rel
.r_offset
= (hh
->plt_offset
+ splt
->output_offset
2023 + splt
->output_section
->vma
);
2024 rel
.r_info
= ELF64_R_INFO (hh
->eh
.dynindx
, R_PARISC_IPLT
);
2027 loc
= spltrel
->contents
;
2028 loc
+= spltrel
->reloc_count
++ * sizeof (Elf64_External_Rela
);
2029 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rel
, loc
);
2032 /* Initialize an external call stub entry if requested. */
2034 && elf64_hppa_dynamic_symbol_p (eh
, info
))
2038 unsigned int max_offset
;
2040 BFD_ASSERT (stub
!= NULL
);
2042 /* Install the generic stub template.
2044 We are modifying the contents of the stub section, so we do not
2045 need to include the stub section's output_offset here. */
2046 memcpy (stub
->contents
+ hh
->stub_offset
, plt_stub
, sizeof (plt_stub
));
2048 /* Fix up the first ldd instruction.
2050 We are modifying the contents of the STUB section in memory,
2051 so we do not need to include its output offset in this computation.
2053 Note the plt_offset value is the value of the PLT entry relative to
2054 the start of the PLT section. These instructions will reference
2055 data relative to the value of __gp, which may not necessarily have
2056 the same address as the start of the PLT section.
2058 gp_offset contains the offset of __gp within the PLT section. */
2059 value
= hh
->plt_offset
- hppa_info
->gp_offset
;
2061 insn
= bfd_get_32 (stub
->owner
, stub
->contents
+ hh
->stub_offset
);
2062 if (output_bfd
->arch_info
->mach
>= 25)
2064 /* Wide mode allows 16 bit offsets. */
2067 insn
|= re_assemble_16 ((int) value
);
2073 insn
|= re_assemble_14 ((int) value
);
2076 if ((value
& 7) || value
+ max_offset
>= 2*max_offset
- 8)
2079 /* xgettext:c-format */
2080 (_("stub entry for %s cannot load .plt, dp offset = %" PRId64
),
2081 hh
->eh
.root
.root
.string
, (int64_t) value
);
2085 bfd_put_32 (stub
->owner
, (bfd_vma
) insn
,
2086 stub
->contents
+ hh
->stub_offset
);
2088 /* Fix up the second ldd instruction. */
2090 insn
= bfd_get_32 (stub
->owner
, stub
->contents
+ hh
->stub_offset
+ 8);
2091 if (output_bfd
->arch_info
->mach
>= 25)
2094 insn
|= re_assemble_16 ((int) value
);
2099 insn
|= re_assemble_14 ((int) value
);
2101 bfd_put_32 (stub
->owner
, (bfd_vma
) insn
,
2102 stub
->contents
+ hh
->stub_offset
+ 8);
2108 /* The .opd section contains FPTRs for each function this file
2109 exports. Initialize the FPTR entries. */
2112 elf64_hppa_finalize_opd (struct elf_link_hash_entry
*eh
, void *data
)
2114 struct elf64_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
2115 struct bfd_link_info
*info
= (struct bfd_link_info
*)data
;
2116 struct elf64_hppa_link_hash_table
*hppa_info
;
2120 hppa_info
= hppa_link_hash_table (info
);
2121 if (hppa_info
== NULL
)
2124 sopd
= hppa_info
->opd_sec
;
2125 sopdrel
= hppa_info
->opd_rel_sec
;
2131 /* The first two words of an .opd entry are zero.
2133 We are modifying the contents of the OPD section in memory, so we
2134 do not need to include its output offset in this computation. */
2135 memset (sopd
->contents
+ hh
->opd_offset
, 0, 16);
2137 value
= (eh
->root
.u
.def
.value
2138 + eh
->root
.u
.def
.section
->output_section
->vma
2139 + eh
->root
.u
.def
.section
->output_offset
);
2141 /* The next word is the address of the function. */
2142 bfd_put_64 (sopd
->owner
, value
, sopd
->contents
+ hh
->opd_offset
+ 16);
2144 /* The last word is our local __gp value. */
2145 value
= _bfd_get_gp_value (info
->output_bfd
);
2146 bfd_put_64 (sopd
->owner
, value
, sopd
->contents
+ hh
->opd_offset
+ 24);
2149 /* If we are generating a shared library, we must generate EPLT relocations
2150 for each entry in the .opd, even for static functions (they may have
2151 had their address taken). */
2152 if (bfd_link_pic (info
) && hh
->want_opd
)
2154 Elf_Internal_Rela rel
;
2158 /* We may need to do a relocation against a local symbol, in
2159 which case we have to look up it's dynamic symbol index off
2160 the local symbol hash table. */
2161 if (eh
->dynindx
!= -1)
2162 dynindx
= eh
->dynindx
;
2165 = _bfd_elf_link_lookup_local_dynindx (info
, hh
->owner
,
2168 /* The offset of this relocation is the absolute address of the
2169 .opd entry for this symbol. */
2170 rel
.r_offset
= (hh
->opd_offset
+ sopd
->output_offset
2171 + sopd
->output_section
->vma
);
2173 /* If H is non-null, then we have an external symbol.
2175 It is imperative that we use a different dynamic symbol for the
2176 EPLT relocation if the symbol has global scope.
2178 In the dynamic symbol table, the function symbol will have a value
2179 which is address of the function's .opd entry.
2181 Thus, we can not use that dynamic symbol for the EPLT relocation
2182 (if we did, the data in the .opd would reference itself rather
2183 than the actual address of the function). Instead we have to use
2184 a new dynamic symbol which has the same value as the original global
2187 We prefix the original symbol with a "." and use the new symbol in
2188 the EPLT relocation. This new symbol has already been recorded in
2189 the symbol table, we just have to look it up and use it.
2191 We do not have such problems with static functions because we do
2192 not make their addresses in the dynamic symbol table point to
2193 the .opd entry. Ultimately this should be safe since a static
2194 function can not be directly referenced outside of its shared
2197 We do have to play similar games for FPTR relocations in shared
2198 libraries, including those for static symbols. See the FPTR
2199 handling in elf64_hppa_finalize_dynreloc. */
2203 struct elf_link_hash_entry
*nh
;
2205 new_name
= concat (".", eh
->root
.root
.string
, NULL
);
2207 nh
= elf_link_hash_lookup (elf_hash_table (info
),
2208 new_name
, TRUE
, TRUE
, FALSE
);
2210 /* All we really want from the new symbol is its dynamic
2213 dynindx
= nh
->dynindx
;
2218 rel
.r_info
= ELF64_R_INFO (dynindx
, R_PARISC_EPLT
);
2220 loc
= sopdrel
->contents
;
2221 loc
+= sopdrel
->reloc_count
++ * sizeof (Elf64_External_Rela
);
2222 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rel
, loc
);
2227 /* The .dlt section contains addresses for items referenced through the
2228 dlt. Note that we can have a DLTIND relocation for a local symbol, thus
2229 we can not depend on finish_dynamic_symbol to initialize the .dlt. */
2232 elf64_hppa_finalize_dlt (struct elf_link_hash_entry
*eh
, void *data
)
2234 struct elf64_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
2235 struct bfd_link_info
*info
= (struct bfd_link_info
*)data
;
2236 struct elf64_hppa_link_hash_table
*hppa_info
;
2237 asection
*sdlt
, *sdltrel
;
2239 hppa_info
= hppa_link_hash_table (info
);
2240 if (hppa_info
== NULL
)
2243 sdlt
= hppa_info
->dlt_sec
;
2244 sdltrel
= hppa_info
->dlt_rel_sec
;
2246 /* H/DYN_H may refer to a local variable and we know it's
2247 address, so there is no need to create a relocation. Just install
2248 the proper value into the DLT, note this shortcut can not be
2249 skipped when building a shared library. */
2250 if (! bfd_link_pic (info
) && hh
&& hh
->want_dlt
)
2254 /* If we had an LTOFF_FPTR style relocation we want the DLT entry
2255 to point to the FPTR entry in the .opd section.
2257 We include the OPD's output offset in this computation as
2258 we are referring to an absolute address in the resulting
2262 value
= (hh
->opd_offset
2263 + hppa_info
->opd_sec
->output_offset
2264 + hppa_info
->opd_sec
->output_section
->vma
);
2266 else if ((eh
->root
.type
== bfd_link_hash_defined
2267 || eh
->root
.type
== bfd_link_hash_defweak
)
2268 && eh
->root
.u
.def
.section
)
2270 value
= eh
->root
.u
.def
.value
+ eh
->root
.u
.def
.section
->output_offset
;
2271 if (eh
->root
.u
.def
.section
->output_section
)
2272 value
+= eh
->root
.u
.def
.section
->output_section
->vma
;
2274 value
+= eh
->root
.u
.def
.section
->vma
;
2277 /* We have an undefined function reference. */
2280 /* We do not need to include the output offset of the DLT section
2281 here because we are modifying the in-memory contents. */
2282 bfd_put_64 (sdlt
->owner
, value
, sdlt
->contents
+ hh
->dlt_offset
);
2285 /* Create a relocation for the DLT entry associated with this symbol.
2286 When building a shared library the symbol does not have to be dynamic. */
2288 && (elf64_hppa_dynamic_symbol_p (eh
, info
) || bfd_link_pic (info
)))
2290 Elf_Internal_Rela rel
;
2294 /* We may need to do a relocation against a local symbol, in
2295 which case we have to look up it's dynamic symbol index off
2296 the local symbol hash table. */
2297 if (eh
&& eh
->dynindx
!= -1)
2298 dynindx
= eh
->dynindx
;
2301 = _bfd_elf_link_lookup_local_dynindx (info
, hh
->owner
,
2304 /* Create a dynamic relocation for this entry. Do include the output
2305 offset of the DLT entry since we need an absolute address in the
2306 resulting object file. */
2307 rel
.r_offset
= (hh
->dlt_offset
+ sdlt
->output_offset
2308 + sdlt
->output_section
->vma
);
2309 if (eh
&& eh
->type
== STT_FUNC
)
2310 rel
.r_info
= ELF64_R_INFO (dynindx
, R_PARISC_FPTR64
);
2312 rel
.r_info
= ELF64_R_INFO (dynindx
, R_PARISC_DIR64
);
2315 loc
= sdltrel
->contents
;
2316 loc
+= sdltrel
->reloc_count
++ * sizeof (Elf64_External_Rela
);
2317 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rel
, loc
);
2322 /* Finalize the dynamic relocations. Specifically the FPTR relocations
2323 for dynamic functions used to initialize static data. */
2326 elf64_hppa_finalize_dynreloc (struct elf_link_hash_entry
*eh
,
2329 struct elf64_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
2330 struct bfd_link_info
*info
= (struct bfd_link_info
*)data
;
2331 struct elf64_hppa_link_hash_table
*hppa_info
;
2334 dynamic_symbol
= elf64_hppa_dynamic_symbol_p (eh
, info
);
2336 if (!dynamic_symbol
&& !bfd_link_pic (info
))
2339 if (hh
->reloc_entries
)
2341 struct elf64_hppa_dyn_reloc_entry
*rent
;
2344 hppa_info
= hppa_link_hash_table (info
);
2345 if (hppa_info
== NULL
)
2348 /* We may need to do a relocation against a local symbol, in
2349 which case we have to look up it's dynamic symbol index off
2350 the local symbol hash table. */
2351 if (eh
->dynindx
!= -1)
2352 dynindx
= eh
->dynindx
;
2355 = _bfd_elf_link_lookup_local_dynindx (info
, hh
->owner
,
2358 for (rent
= hh
->reloc_entries
; rent
; rent
= rent
->next
)
2360 Elf_Internal_Rela rel
;
2363 /* Allocate one iff we are building a shared library, the relocation
2364 isn't a R_PARISC_FPTR64, or we don't want an opd entry. */
2365 if (!bfd_link_pic (info
)
2366 && rent
->type
== R_PARISC_FPTR64
&& hh
->want_opd
)
2369 /* Create a dynamic relocation for this entry.
2371 We need the output offset for the reloc's section because
2372 we are creating an absolute address in the resulting object
2374 rel
.r_offset
= (rent
->offset
+ rent
->sec
->output_offset
2375 + rent
->sec
->output_section
->vma
);
2377 /* An FPTR64 relocation implies that we took the address of
2378 a function and that the function has an entry in the .opd
2379 section. We want the FPTR64 relocation to reference the
2382 We could munge the symbol value in the dynamic symbol table
2383 (in fact we already do for functions with global scope) to point
2384 to the .opd entry. Then we could use that dynamic symbol in
2387 Or we could do something sensible, not munge the symbol's
2388 address and instead just use a different symbol to reference
2389 the .opd entry. At least that seems sensible until you
2390 realize there's no local dynamic symbols we can use for that
2391 purpose. Thus the hair in the check_relocs routine.
2393 We use a section symbol recorded by check_relocs as the
2394 base symbol for the relocation. The addend is the difference
2395 between the section symbol and the address of the .opd entry. */
2396 if (bfd_link_pic (info
)
2397 && rent
->type
== R_PARISC_FPTR64
&& hh
->want_opd
)
2399 bfd_vma value
, value2
;
2401 /* First compute the address of the opd entry for this symbol. */
2402 value
= (hh
->opd_offset
2403 + hppa_info
->opd_sec
->output_section
->vma
2404 + hppa_info
->opd_sec
->output_offset
);
2406 /* Compute the value of the start of the section with
2408 value2
= (rent
->sec
->output_section
->vma
2409 + rent
->sec
->output_offset
);
2411 /* Compute the difference between the start of the section
2412 with the relocation and the opd entry. */
2415 /* The result becomes the addend of the relocation. */
2416 rel
.r_addend
= value
;
2418 /* The section symbol becomes the symbol for the dynamic
2421 = _bfd_elf_link_lookup_local_dynindx (info
,
2426 rel
.r_addend
= rent
->addend
;
2428 rel
.r_info
= ELF64_R_INFO (dynindx
, rent
->type
);
2430 loc
= hppa_info
->other_rel_sec
->contents
;
2431 loc
+= (hppa_info
->other_rel_sec
->reloc_count
++
2432 * sizeof (Elf64_External_Rela
));
2433 bfd_elf64_swap_reloca_out (info
->output_bfd
, &rel
, loc
);
2440 /* Used to decide how to sort relocs in an optimal manner for the
2441 dynamic linker, before writing them out. */
2443 static enum elf_reloc_type_class
2444 elf64_hppa_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2445 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2446 const Elf_Internal_Rela
*rela
)
2448 if (ELF64_R_SYM (rela
->r_info
) == STN_UNDEF
)
2449 return reloc_class_relative
;
2451 switch ((int) ELF64_R_TYPE (rela
->r_info
))
2454 return reloc_class_plt
;
2456 return reloc_class_copy
;
2458 return reloc_class_normal
;
2462 /* Finish up the dynamic sections. */
2465 elf64_hppa_finish_dynamic_sections (bfd
*output_bfd
,
2466 struct bfd_link_info
*info
)
2470 struct elf64_hppa_link_hash_table
*hppa_info
;
2472 hppa_info
= hppa_link_hash_table (info
);
2473 if (hppa_info
== NULL
)
2476 /* Finalize the contents of the .opd section. */
2477 elf_link_hash_traverse (elf_hash_table (info
),
2478 elf64_hppa_finalize_opd
,
2481 elf_link_hash_traverse (elf_hash_table (info
),
2482 elf64_hppa_finalize_dynreloc
,
2485 /* Finalize the contents of the .dlt section. */
2486 dynobj
= elf_hash_table (info
)->dynobj
;
2487 /* Finalize the contents of the .dlt section. */
2488 elf_link_hash_traverse (elf_hash_table (info
),
2489 elf64_hppa_finalize_dlt
,
2492 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
2494 if (elf_hash_table (info
)->dynamic_sections_created
)
2496 Elf64_External_Dyn
*dyncon
, *dynconend
;
2498 BFD_ASSERT (sdyn
!= NULL
);
2500 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
2501 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
2502 for (; dyncon
< dynconend
; dyncon
++)
2504 Elf_Internal_Dyn dyn
;
2507 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2514 case DT_HP_LOAD_MAP
:
2515 /* Compute the absolute address of 16byte scratchpad area
2516 for the dynamic linker.
2518 By convention the linker script will allocate the scratchpad
2519 area at the start of the .data section. So all we have to
2520 to is find the start of the .data section. */
2521 s
= bfd_get_section_by_name (output_bfd
, ".data");
2524 dyn
.d_un
.d_ptr
= s
->vma
;
2525 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2529 /* HP's use PLTGOT to set the GOT register. */
2530 dyn
.d_un
.d_ptr
= _bfd_get_gp_value (output_bfd
);
2531 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2535 s
= hppa_info
->plt_rel_sec
;
2536 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2537 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2541 s
= hppa_info
->plt_rel_sec
;
2542 dyn
.d_un
.d_val
= s
->size
;
2543 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2547 s
= hppa_info
->other_rel_sec
;
2548 if (! s
|| ! s
->size
)
2549 s
= hppa_info
->dlt_rel_sec
;
2550 if (! s
|| ! s
->size
)
2551 s
= hppa_info
->opd_rel_sec
;
2552 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2553 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2557 s
= hppa_info
->other_rel_sec
;
2558 dyn
.d_un
.d_val
= s
->size
;
2559 s
= hppa_info
->dlt_rel_sec
;
2560 dyn
.d_un
.d_val
+= s
->size
;
2561 s
= hppa_info
->opd_rel_sec
;
2562 dyn
.d_un
.d_val
+= s
->size
;
2563 /* There is some question about whether or not the size of
2564 the PLT relocs should be included here. HP's tools do
2565 it, so we'll emulate them. */
2566 s
= hppa_info
->plt_rel_sec
;
2567 dyn
.d_un
.d_val
+= s
->size
;
2568 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2578 /* Support for core dump NOTE sections. */
2581 elf64_hppa_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
2586 switch (note
->descsz
)
2591 case 760: /* Linux/hppa */
2593 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
2596 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 32);
2605 /* Make a ".reg/999" section. */
2606 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
2607 size
, note
->descpos
+ offset
);
2611 elf64_hppa_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
2616 switch (note
->descsz
)
2621 case 136: /* Linux/hppa elf_prpsinfo. */
2622 elf_tdata (abfd
)->core
->program
2623 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 40, 16);
2624 elf_tdata (abfd
)->core
->command
2625 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 56, 80);
2628 /* Note that for some reason, a spurious space is tacked
2629 onto the end of the args in some (at least one anyway)
2630 implementations, so strip it off if it exists. */
2631 command
= elf_tdata (abfd
)->core
->command
;
2632 n
= strlen (command
);
2634 if (0 < n
&& command
[n
- 1] == ' ')
2635 command
[n
- 1] = '\0';
2640 /* Return the number of additional phdrs we will need.
2642 The generic ELF code only creates PT_PHDRs for executables. The HP
2643 dynamic linker requires PT_PHDRs for dynamic libraries too.
2645 This routine indicates that the backend needs one additional program
2646 header for that case.
2648 Note we do not have access to the link info structure here, so we have
2649 to guess whether or not we are building a shared library based on the
2650 existence of a .interp section. */
2653 elf64_hppa_additional_program_headers (bfd
*abfd
,
2654 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
2658 /* If we are creating a shared library, then we have to create a
2659 PT_PHDR segment. HP's dynamic linker chokes without it. */
2660 s
= bfd_get_section_by_name (abfd
, ".interp");
2667 elf64_hppa_allow_non_load_phdr (bfd
*abfd ATTRIBUTE_UNUSED
,
2668 const Elf_Internal_Phdr
*phdr ATTRIBUTE_UNUSED
,
2669 unsigned int count ATTRIBUTE_UNUSED
)
2674 /* Allocate and initialize any program headers required by this
2677 The generic ELF code only creates PT_PHDRs for executables. The HP
2678 dynamic linker requires PT_PHDRs for dynamic libraries too.
2680 This allocates the PT_PHDR and initializes it in a manner suitable
2683 Note we do not have access to the link info structure here, so we have
2684 to guess whether or not we are building a shared library based on the
2685 existence of a .interp section. */
2688 elf64_hppa_modify_segment_map (bfd
*abfd
, struct bfd_link_info
*info
)
2690 struct elf_segment_map
*m
;
2692 m
= elf_seg_map (abfd
);
2693 if (info
!= NULL
&& !info
->user_phdrs
&& m
!= NULL
&& m
->p_type
!= PT_PHDR
)
2695 m
= ((struct elf_segment_map
*)
2696 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *m
));
2700 m
->p_type
= PT_PHDR
;
2701 m
->p_flags
= PF_R
| PF_X
;
2702 m
->p_flags_valid
= 1;
2703 m
->p_paddr_valid
= 1;
2704 m
->includes_phdrs
= 1;
2706 m
->next
= elf_seg_map (abfd
);
2707 elf_seg_map (abfd
) = m
;
2710 for (m
= elf_seg_map (abfd
) ; m
!= NULL
; m
= m
->next
)
2711 if (m
->p_type
== PT_LOAD
)
2715 for (i
= 0; i
< m
->count
; i
++)
2717 /* The code "hint" is not really a hint. It is a requirement
2718 for certain versions of the HP dynamic linker. Worse yet,
2719 it must be set even if the shared library does not have
2720 any code in its "text" segment (thus the check for .hash
2721 to catch this situation). */
2722 if (m
->sections
[i
]->flags
& SEC_CODE
2723 || (strcmp (m
->sections
[i
]->name
, ".hash") == 0))
2724 m
->p_flags
|= (PF_X
| PF_HP_CODE
);
2731 /* Called when writing out an object file to decide the type of a
2734 elf64_hppa_elf_get_symbol_type (Elf_Internal_Sym
*elf_sym
,
2737 if (ELF_ST_TYPE (elf_sym
->st_info
) == STT_PARISC_MILLI
)
2738 return STT_PARISC_MILLI
;
2743 /* Support HP specific sections for core files. */
2746 elf64_hppa_section_from_phdr (bfd
*abfd
, Elf_Internal_Phdr
*hdr
, int sec_index
,
2747 const char *typename
)
2749 if (hdr
->p_type
== PT_HP_CORE_KERNEL
)
2753 if (!_bfd_elf_make_section_from_phdr (abfd
, hdr
, sec_index
, typename
))
2756 sect
= bfd_make_section_anyway (abfd
, ".kernel");
2759 sect
->size
= hdr
->p_filesz
;
2760 sect
->filepos
= hdr
->p_offset
;
2761 sect
->flags
= SEC_HAS_CONTENTS
| SEC_READONLY
;
2765 if (hdr
->p_type
== PT_HP_CORE_PROC
)
2769 if (bfd_seek (abfd
, hdr
->p_offset
, SEEK_SET
) != 0)
2771 if (bfd_bread (&sig
, 4, abfd
) != 4)
2774 elf_tdata (abfd
)->core
->signal
= sig
;
2776 if (!_bfd_elf_make_section_from_phdr (abfd
, hdr
, sec_index
, typename
))
2779 /* GDB uses the ".reg" section to read register contents. */
2780 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", hdr
->p_filesz
,
2784 if (hdr
->p_type
== PT_HP_CORE_LOADABLE
2785 || hdr
->p_type
== PT_HP_CORE_STACK
2786 || hdr
->p_type
== PT_HP_CORE_MMF
)
2787 hdr
->p_type
= PT_LOAD
;
2789 return _bfd_elf_make_section_from_phdr (abfd
, hdr
, sec_index
, typename
);
2792 /* Hook called by the linker routine which adds symbols from an object
2793 file. HP's libraries define symbols with HP specific section
2794 indices, which we have to handle. */
2797 elf_hppa_add_symbol_hook (bfd
*abfd
,
2798 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2799 Elf_Internal_Sym
*sym
,
2800 const char **namep ATTRIBUTE_UNUSED
,
2801 flagword
*flagsp ATTRIBUTE_UNUSED
,
2805 unsigned int sec_index
= sym
->st_shndx
;
2809 case SHN_PARISC_ANSI_COMMON
:
2810 *secp
= bfd_make_section_old_way (abfd
, ".PARISC.ansi.common");
2811 (*secp
)->flags
|= SEC_IS_COMMON
;
2812 *valp
= sym
->st_size
;
2815 case SHN_PARISC_HUGE_COMMON
:
2816 *secp
= bfd_make_section_old_way (abfd
, ".PARISC.huge.common");
2817 (*secp
)->flags
|= SEC_IS_COMMON
;
2818 *valp
= sym
->st_size
;
2826 elf_hppa_unmark_useless_dynamic_symbols (struct elf_link_hash_entry
*h
,
2829 struct bfd_link_info
*info
= data
;
2831 /* If we are not creating a shared library, and this symbol is
2832 referenced by a shared library but is not defined anywhere, then
2833 the generic code will warn that it is undefined.
2835 This behavior is undesirable on HPs since the standard shared
2836 libraries contain references to undefined symbols.
2838 So we twiddle the flags associated with such symbols so that they
2839 will not trigger the warning. ?!? FIXME. This is horribly fragile.
2841 Ultimately we should have better controls over the generic ELF BFD
2843 if (! bfd_link_relocatable (info
)
2844 && info
->unresolved_syms_in_shared_libs
!= RM_IGNORE
2845 && h
->root
.type
== bfd_link_hash_undefined
2850 h
->pointer_equality_needed
= 1;
2857 elf_hppa_remark_useless_dynamic_symbols (struct elf_link_hash_entry
*h
,
2860 struct bfd_link_info
*info
= data
;
2862 /* If we are not creating a shared library, and this symbol is
2863 referenced by a shared library but is not defined anywhere, then
2864 the generic code will warn that it is undefined.
2866 This behavior is undesirable on HPs since the standard shared
2867 libraries contain references to undefined symbols.
2869 So we twiddle the flags associated with such symbols so that they
2870 will not trigger the warning. ?!? FIXME. This is horribly fragile.
2872 Ultimately we should have better controls over the generic ELF BFD
2874 if (! bfd_link_relocatable (info
)
2875 && info
->unresolved_syms_in_shared_libs
!= RM_IGNORE
2876 && h
->root
.type
== bfd_link_hash_undefined
2879 && h
->pointer_equality_needed
)
2882 h
->pointer_equality_needed
= 0;
2889 elf_hppa_is_dynamic_loader_symbol (const char *name
)
2891 return (! strcmp (name
, "__CPU_REVISION")
2892 || ! strcmp (name
, "__CPU_KEYBITS_1")
2893 || ! strcmp (name
, "__SYSTEM_ID_D")
2894 || ! strcmp (name
, "__FPU_MODEL")
2895 || ! strcmp (name
, "__FPU_REVISION")
2896 || ! strcmp (name
, "__ARGC")
2897 || ! strcmp (name
, "__ARGV")
2898 || ! strcmp (name
, "__ENVP")
2899 || ! strcmp (name
, "__TLS_SIZE_D")
2900 || ! strcmp (name
, "__LOAD_INFO")
2901 || ! strcmp (name
, "__systab"));
2904 /* Record the lowest address for the data and text segments. */
2906 elf_hppa_record_segment_addrs (bfd
*abfd
,
2910 struct elf64_hppa_link_hash_table
*hppa_info
= data
;
2912 if ((section
->flags
& (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
2915 Elf_Internal_Phdr
*p
;
2917 p
= _bfd_elf_find_segment_containing_section (abfd
, section
->output_section
);
2918 BFD_ASSERT (p
!= NULL
);
2921 if (section
->flags
& SEC_READONLY
)
2923 if (value
< hppa_info
->text_segment_base
)
2924 hppa_info
->text_segment_base
= value
;
2928 if (value
< hppa_info
->data_segment_base
)
2929 hppa_info
->data_segment_base
= value
;
2934 /* Called after we have seen all the input files/sections, but before
2935 final symbol resolution and section placement has been determined.
2937 We use this hook to (possibly) provide a value for __gp, then we
2938 fall back to the generic ELF final link routine. */
2941 elf_hppa_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
2944 struct elf64_hppa_link_hash_table
*hppa_info
= hppa_link_hash_table (info
);
2946 if (hppa_info
== NULL
)
2949 if (! bfd_link_relocatable (info
))
2951 struct elf_link_hash_entry
*gp
;
2954 /* The linker script defines a value for __gp iff it was referenced
2955 by one of the objects being linked. First try to find the symbol
2956 in the hash table. If that fails, just compute the value __gp
2958 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
2964 /* Adjust the value of __gp as we may want to slide it into the
2965 .plt section so that the stubs can access PLT entries without
2966 using an addil sequence. */
2967 gp
->root
.u
.def
.value
+= hppa_info
->gp_offset
;
2969 gp_val
= (gp
->root
.u
.def
.section
->output_section
->vma
2970 + gp
->root
.u
.def
.section
->output_offset
2971 + gp
->root
.u
.def
.value
);
2977 /* First look for a .plt section. If found, then __gp is the
2978 address of the .plt + gp_offset.
2980 If no .plt is found, then look for .dlt, .opd and .data (in
2981 that order) and set __gp to the base address of whichever
2982 section is found first. */
2984 sec
= hppa_info
->plt_sec
;
2985 if (sec
&& ! (sec
->flags
& SEC_EXCLUDE
))
2986 gp_val
= (sec
->output_offset
2987 + sec
->output_section
->vma
2988 + hppa_info
->gp_offset
);
2991 sec
= hppa_info
->dlt_sec
;
2992 if (!sec
|| (sec
->flags
& SEC_EXCLUDE
))
2993 sec
= hppa_info
->opd_sec
;
2994 if (!sec
|| (sec
->flags
& SEC_EXCLUDE
))
2995 sec
= bfd_get_section_by_name (abfd
, ".data");
2996 if (!sec
|| (sec
->flags
& SEC_EXCLUDE
))
2999 gp_val
= sec
->output_offset
+ sec
->output_section
->vma
;
3003 /* Install whatever value we found/computed for __gp. */
3004 _bfd_set_gp_value (abfd
, gp_val
);
3007 /* We need to know the base of the text and data segments so that we
3008 can perform SEGREL relocations. We will record the base addresses
3009 when we encounter the first SEGREL relocation. */
3010 hppa_info
->text_segment_base
= (bfd_vma
)-1;
3011 hppa_info
->data_segment_base
= (bfd_vma
)-1;
3013 /* HP's shared libraries have references to symbols that are not
3014 defined anywhere. The generic ELF BFD linker code will complain
3017 So we detect the losing case and arrange for the flags on the symbol
3018 to indicate that it was never referenced. This keeps the generic
3019 ELF BFD link code happy and appears to not create any secondary
3020 problems. Ultimately we need a way to control the behavior of the
3021 generic ELF BFD link code better. */
3022 elf_link_hash_traverse (elf_hash_table (info
),
3023 elf_hppa_unmark_useless_dynamic_symbols
,
3026 /* Invoke the regular ELF backend linker to do all the work. */
3027 if (!bfd_elf_final_link (abfd
, info
))
3030 elf_link_hash_traverse (elf_hash_table (info
),
3031 elf_hppa_remark_useless_dynamic_symbols
,
3034 /* If we're producing a final executable, sort the contents of the
3036 if (bfd_link_relocatable (info
))
3039 /* Do not attempt to sort non-regular files. This is here
3040 especially for configure scripts and kernel builds which run
3041 tests with "ld [...] -o /dev/null". */
3042 if (stat (abfd
->filename
, &buf
) != 0
3043 || !S_ISREG(buf
.st_mode
))
3046 return elf_hppa_sort_unwind (abfd
);
3049 /* Relocate the given INSN. VALUE should be the actual value we want
3050 to insert into the instruction, ie by this point we should not be
3051 concerned with computing an offset relative to the DLT, PC, etc.
3052 Instead this routine is meant to handle the bit manipulations needed
3053 to insert the relocation into the given instruction. */
3056 elf_hppa_relocate_insn (int insn
, int sym_value
, unsigned int r_type
)
3060 /* This is any 22 bit branch. In PA2.0 syntax it corresponds to
3061 the "B" instruction. */
3062 case R_PARISC_PCREL22F
:
3063 case R_PARISC_PCREL22C
:
3064 return (insn
& ~0x3ff1ffd) | re_assemble_22 (sym_value
);
3066 /* This is any 12 bit branch. */
3067 case R_PARISC_PCREL12F
:
3068 return (insn
& ~0x1ffd) | re_assemble_12 (sym_value
);
3070 /* This is any 17 bit branch. In PA2.0 syntax it also corresponds
3071 to the "B" instruction as well as BE. */
3072 case R_PARISC_PCREL17F
:
3073 case R_PARISC_DIR17F
:
3074 case R_PARISC_DIR17R
:
3075 case R_PARISC_PCREL17C
:
3076 case R_PARISC_PCREL17R
:
3077 return (insn
& ~0x1f1ffd) | re_assemble_17 (sym_value
);
3079 /* ADDIL or LDIL instructions. */
3080 case R_PARISC_DLTREL21L
:
3081 case R_PARISC_DLTIND21L
:
3082 case R_PARISC_LTOFF_FPTR21L
:
3083 case R_PARISC_PCREL21L
:
3084 case R_PARISC_LTOFF_TP21L
:
3085 case R_PARISC_DPREL21L
:
3086 case R_PARISC_PLTOFF21L
:
3087 case R_PARISC_DIR21L
:
3088 return (insn
& ~0x1fffff) | re_assemble_21 (sym_value
);
3090 /* LDO and integer loads/stores with 14 bit displacements. */
3091 case R_PARISC_DLTREL14R
:
3092 case R_PARISC_DLTREL14F
:
3093 case R_PARISC_DLTIND14R
:
3094 case R_PARISC_DLTIND14F
:
3095 case R_PARISC_LTOFF_FPTR14R
:
3096 case R_PARISC_PCREL14R
:
3097 case R_PARISC_PCREL14F
:
3098 case R_PARISC_LTOFF_TP14R
:
3099 case R_PARISC_LTOFF_TP14F
:
3100 case R_PARISC_DPREL14R
:
3101 case R_PARISC_DPREL14F
:
3102 case R_PARISC_PLTOFF14R
:
3103 case R_PARISC_PLTOFF14F
:
3104 case R_PARISC_DIR14R
:
3105 case R_PARISC_DIR14F
:
3106 return (insn
& ~0x3fff) | low_sign_unext (sym_value
, 14);
3108 /* PA2.0W LDO and integer loads/stores with 16 bit displacements. */
3109 case R_PARISC_LTOFF_FPTR16F
:
3110 case R_PARISC_PCREL16F
:
3111 case R_PARISC_LTOFF_TP16F
:
3112 case R_PARISC_GPREL16F
:
3113 case R_PARISC_PLTOFF16F
:
3114 case R_PARISC_DIR16F
:
3115 case R_PARISC_LTOFF16F
:
3116 return (insn
& ~0xffff) | re_assemble_16 (sym_value
);
3118 /* Doubleword loads and stores with a 14 bit displacement. */
3119 case R_PARISC_DLTREL14DR
:
3120 case R_PARISC_DLTIND14DR
:
3121 case R_PARISC_LTOFF_FPTR14DR
:
3122 case R_PARISC_LTOFF_FPTR16DF
:
3123 case R_PARISC_PCREL14DR
:
3124 case R_PARISC_PCREL16DF
:
3125 case R_PARISC_LTOFF_TP14DR
:
3126 case R_PARISC_LTOFF_TP16DF
:
3127 case R_PARISC_DPREL14DR
:
3128 case R_PARISC_GPREL16DF
:
3129 case R_PARISC_PLTOFF14DR
:
3130 case R_PARISC_PLTOFF16DF
:
3131 case R_PARISC_DIR14DR
:
3132 case R_PARISC_DIR16DF
:
3133 case R_PARISC_LTOFF16DF
:
3134 return (insn
& ~0x3ff1) | (((sym_value
& 0x2000) >> 13)
3135 | ((sym_value
& 0x1ff8) << 1));
3137 /* Floating point single word load/store instructions. */
3138 case R_PARISC_DLTREL14WR
:
3139 case R_PARISC_DLTIND14WR
:
3140 case R_PARISC_LTOFF_FPTR14WR
:
3141 case R_PARISC_LTOFF_FPTR16WF
:
3142 case R_PARISC_PCREL14WR
:
3143 case R_PARISC_PCREL16WF
:
3144 case R_PARISC_LTOFF_TP14WR
:
3145 case R_PARISC_LTOFF_TP16WF
:
3146 case R_PARISC_DPREL14WR
:
3147 case R_PARISC_GPREL16WF
:
3148 case R_PARISC_PLTOFF14WR
:
3149 case R_PARISC_PLTOFF16WF
:
3150 case R_PARISC_DIR16WF
:
3151 case R_PARISC_DIR14WR
:
3152 case R_PARISC_LTOFF16WF
:
3153 return (insn
& ~0x3ff9) | (((sym_value
& 0x2000) >> 13)
3154 | ((sym_value
& 0x1ffc) << 1));
3161 /* Compute the value for a relocation (REL) during a final link stage,
3162 then insert the value into the proper location in CONTENTS.
3164 VALUE is a tentative value for the relocation and may be overridden
3165 and modified here based on the specific relocation to be performed.
3167 For example we do conversions for PC-relative branches in this routine
3168 or redirection of calls to external routines to stubs.
3170 The work of actually applying the relocation is left to a helper
3171 routine in an attempt to reduce the complexity and size of this
3174 static bfd_reloc_status_type
3175 elf_hppa_final_link_relocate (Elf_Internal_Rela
*rel
,
3178 asection
*input_section
,
3181 struct bfd_link_info
*info
,
3183 struct elf_link_hash_entry
*eh
)
3185 struct elf64_hppa_link_hash_table
*hppa_info
= hppa_link_hash_table (info
);
3186 struct elf64_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
3187 bfd_vma
*local_offsets
;
3188 Elf_Internal_Shdr
*symtab_hdr
;
3190 bfd_vma max_branch_offset
= 0;
3191 bfd_vma offset
= rel
->r_offset
;
3192 bfd_signed_vma addend
= rel
->r_addend
;
3193 reloc_howto_type
*howto
= elf_hppa_howto_table
+ ELF_R_TYPE (rel
->r_info
);
3194 unsigned int r_symndx
= ELF_R_SYM (rel
->r_info
);
3195 unsigned int r_type
= howto
->type
;
3196 bfd_byte
*hit_data
= contents
+ offset
;
3198 if (hppa_info
== NULL
)
3199 return bfd_reloc_notsupported
;
3201 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3202 local_offsets
= elf_local_got_offsets (input_bfd
);
3203 insn
= bfd_get_32 (input_bfd
, hit_data
);
3210 /* Basic function call support.
3212 Note for a call to a function defined in another dynamic library
3213 we want to redirect the call to a stub. */
3215 /* PC relative relocs without an implicit offset. */
3216 case R_PARISC_PCREL21L
:
3217 case R_PARISC_PCREL14R
:
3218 case R_PARISC_PCREL14F
:
3219 case R_PARISC_PCREL14WR
:
3220 case R_PARISC_PCREL14DR
:
3221 case R_PARISC_PCREL16F
:
3222 case R_PARISC_PCREL16WF
:
3223 case R_PARISC_PCREL16DF
:
3225 /* If this is a call to a function defined in another dynamic
3226 library, then redirect the call to the local stub for this
3228 if (sym_sec
== NULL
|| sym_sec
->output_section
== NULL
)
3229 value
= (hh
->stub_offset
+ hppa_info
->stub_sec
->output_offset
3230 + hppa_info
->stub_sec
->output_section
->vma
);
3232 /* Turn VALUE into a proper PC relative address. */
3233 value
-= (offset
+ input_section
->output_offset
3234 + input_section
->output_section
->vma
);
3236 /* Adjust for any field selectors. */
3237 if (r_type
== R_PARISC_PCREL21L
)
3238 value
= hppa_field_adjust (value
, -8 + addend
, e_lsel
);
3239 else if (r_type
== R_PARISC_PCREL14F
3240 || r_type
== R_PARISC_PCREL16F
3241 || r_type
== R_PARISC_PCREL16WF
3242 || r_type
== R_PARISC_PCREL16DF
)
3243 value
= hppa_field_adjust (value
, -8 + addend
, e_fsel
);
3245 value
= hppa_field_adjust (value
, -8 + addend
, e_rsel
);
3247 /* Apply the relocation to the given instruction. */
3248 insn
= elf_hppa_relocate_insn (insn
, (int) value
, r_type
);
3252 case R_PARISC_PCREL12F
:
3253 case R_PARISC_PCREL22F
:
3254 case R_PARISC_PCREL17F
:
3255 case R_PARISC_PCREL22C
:
3256 case R_PARISC_PCREL17C
:
3257 case R_PARISC_PCREL17R
:
3259 /* If this is a call to a function defined in another dynamic
3260 library, then redirect the call to the local stub for this
3262 if (sym_sec
== NULL
|| sym_sec
->output_section
== NULL
)
3263 value
= (hh
->stub_offset
+ hppa_info
->stub_sec
->output_offset
3264 + hppa_info
->stub_sec
->output_section
->vma
);
3266 /* Turn VALUE into a proper PC relative address. */
3267 value
-= (offset
+ input_section
->output_offset
3268 + input_section
->output_section
->vma
);
3271 if (r_type
== (unsigned int) R_PARISC_PCREL22F
)
3272 max_branch_offset
= (1 << (22-1)) << 2;
3273 else if (r_type
== (unsigned int) R_PARISC_PCREL17F
)
3274 max_branch_offset
= (1 << (17-1)) << 2;
3275 else if (r_type
== (unsigned int) R_PARISC_PCREL12F
)
3276 max_branch_offset
= (1 << (12-1)) << 2;
3278 /* Make sure we can reach the branch target. */
3279 if (max_branch_offset
!= 0
3280 && value
+ addend
+ max_branch_offset
>= 2*max_branch_offset
)
3283 /* xgettext:c-format */
3284 (_("%pB(%pA+%#" PRIx64
"): cannot reach %s"),
3288 eh
? eh
->root
.root
.string
: "unknown");
3289 bfd_set_error (bfd_error_bad_value
);
3290 return bfd_reloc_overflow
;
3293 /* Adjust for any field selectors. */
3294 if (r_type
== R_PARISC_PCREL17R
)
3295 value
= hppa_field_adjust (value
, addend
, e_rsel
);
3297 value
= hppa_field_adjust (value
, addend
, e_fsel
);
3299 /* All branches are implicitly shifted by 2 places. */
3302 /* Apply the relocation to the given instruction. */
3303 insn
= elf_hppa_relocate_insn (insn
, (int) value
, r_type
);
3307 /* Indirect references to data through the DLT. */
3308 case R_PARISC_DLTIND14R
:
3309 case R_PARISC_DLTIND14F
:
3310 case R_PARISC_DLTIND14DR
:
3311 case R_PARISC_DLTIND14WR
:
3312 case R_PARISC_DLTIND21L
:
3313 case R_PARISC_LTOFF_FPTR14R
:
3314 case R_PARISC_LTOFF_FPTR14DR
:
3315 case R_PARISC_LTOFF_FPTR14WR
:
3316 case R_PARISC_LTOFF_FPTR21L
:
3317 case R_PARISC_LTOFF_FPTR16F
:
3318 case R_PARISC_LTOFF_FPTR16WF
:
3319 case R_PARISC_LTOFF_FPTR16DF
:
3320 case R_PARISC_LTOFF_TP21L
:
3321 case R_PARISC_LTOFF_TP14R
:
3322 case R_PARISC_LTOFF_TP14F
:
3323 case R_PARISC_LTOFF_TP14WR
:
3324 case R_PARISC_LTOFF_TP14DR
:
3325 case R_PARISC_LTOFF_TP16F
:
3326 case R_PARISC_LTOFF_TP16WF
:
3327 case R_PARISC_LTOFF_TP16DF
:
3328 case R_PARISC_LTOFF16F
:
3329 case R_PARISC_LTOFF16WF
:
3330 case R_PARISC_LTOFF16DF
:
3334 /* If this relocation was against a local symbol, then we still
3335 have not set up the DLT entry (it's not convenient to do so
3336 in the "finalize_dlt" routine because it is difficult to get
3337 to the local symbol's value).
3339 So, if this is a local symbol (h == NULL), then we need to
3340 fill in its DLT entry.
3342 Similarly we may still need to set up an entry in .opd for
3343 a local function which had its address taken. */
3346 bfd_vma
*local_opd_offsets
, *local_dlt_offsets
;
3348 if (local_offsets
== NULL
)
3351 /* Now do .opd creation if needed. */
3352 if (r_type
== R_PARISC_LTOFF_FPTR14R
3353 || r_type
== R_PARISC_LTOFF_FPTR14DR
3354 || r_type
== R_PARISC_LTOFF_FPTR14WR
3355 || r_type
== R_PARISC_LTOFF_FPTR21L
3356 || r_type
== R_PARISC_LTOFF_FPTR16F
3357 || r_type
== R_PARISC_LTOFF_FPTR16WF
3358 || r_type
== R_PARISC_LTOFF_FPTR16DF
)
3360 local_opd_offsets
= local_offsets
+ 2 * symtab_hdr
->sh_info
;
3361 off
= local_opd_offsets
[r_symndx
];
3363 /* The last bit records whether we've already initialised
3364 this local .opd entry. */
3367 BFD_ASSERT (off
!= (bfd_vma
) -1);
3372 local_opd_offsets
[r_symndx
] |= 1;
3374 /* The first two words of an .opd entry are zero. */
3375 memset (hppa_info
->opd_sec
->contents
+ off
, 0, 16);
3377 /* The next word is the address of the function. */
3378 bfd_put_64 (hppa_info
->opd_sec
->owner
, value
+ addend
,
3379 (hppa_info
->opd_sec
->contents
+ off
+ 16));
3381 /* The last word is our local __gp value. */
3382 value
= _bfd_get_gp_value (info
->output_bfd
);
3383 bfd_put_64 (hppa_info
->opd_sec
->owner
, value
,
3384 (hppa_info
->opd_sec
->contents
+ off
+ 24));
3387 /* The DLT value is the address of the .opd entry. */
3389 + hppa_info
->opd_sec
->output_offset
3390 + hppa_info
->opd_sec
->output_section
->vma
);
3394 local_dlt_offsets
= local_offsets
;
3395 off
= local_dlt_offsets
[r_symndx
];
3399 BFD_ASSERT (off
!= (bfd_vma
) -1);
3404 local_dlt_offsets
[r_symndx
] |= 1;
3405 bfd_put_64 (hppa_info
->dlt_sec
->owner
,
3407 hppa_info
->dlt_sec
->contents
+ off
);
3411 off
= hh
->dlt_offset
;
3413 /* We want the value of the DLT offset for this symbol, not
3414 the symbol's actual address. Note that __gp may not point
3415 to the start of the DLT, so we have to compute the absolute
3416 address, then subtract out the value of __gp. */
3418 + hppa_info
->dlt_sec
->output_offset
3419 + hppa_info
->dlt_sec
->output_section
->vma
);
3420 value
-= _bfd_get_gp_value (output_bfd
);
3422 /* All DLTIND relocations are basically the same at this point,
3423 except that we need different field selectors for the 21bit
3424 version vs the 14bit versions. */
3425 if (r_type
== R_PARISC_DLTIND21L
3426 || r_type
== R_PARISC_LTOFF_FPTR21L
3427 || r_type
== R_PARISC_LTOFF_TP21L
)
3428 value
= hppa_field_adjust (value
, 0, e_lsel
);
3429 else if (r_type
== R_PARISC_DLTIND14F
3430 || r_type
== R_PARISC_LTOFF_FPTR16F
3431 || r_type
== R_PARISC_LTOFF_FPTR16WF
3432 || r_type
== R_PARISC_LTOFF_FPTR16DF
3433 || r_type
== R_PARISC_LTOFF16F
3434 || r_type
== R_PARISC_LTOFF16DF
3435 || r_type
== R_PARISC_LTOFF16WF
3436 || r_type
== R_PARISC_LTOFF_TP16F
3437 || r_type
== R_PARISC_LTOFF_TP16WF
3438 || r_type
== R_PARISC_LTOFF_TP16DF
)
3439 value
= hppa_field_adjust (value
, 0, e_fsel
);
3441 value
= hppa_field_adjust (value
, 0, e_rsel
);
3443 insn
= elf_hppa_relocate_insn (insn
, (int) value
, r_type
);
3447 case R_PARISC_DLTREL14R
:
3448 case R_PARISC_DLTREL14F
:
3449 case R_PARISC_DLTREL14DR
:
3450 case R_PARISC_DLTREL14WR
:
3451 case R_PARISC_DLTREL21L
:
3452 case R_PARISC_DPREL21L
:
3453 case R_PARISC_DPREL14WR
:
3454 case R_PARISC_DPREL14DR
:
3455 case R_PARISC_DPREL14R
:
3456 case R_PARISC_DPREL14F
:
3457 case R_PARISC_GPREL16F
:
3458 case R_PARISC_GPREL16WF
:
3459 case R_PARISC_GPREL16DF
:
3461 /* Subtract out the global pointer value to make value a DLT
3462 relative address. */
3463 value
-= _bfd_get_gp_value (output_bfd
);
3465 /* All DLTREL relocations are basically the same at this point,
3466 except that we need different field selectors for the 21bit
3467 version vs the 14bit versions. */
3468 if (r_type
== R_PARISC_DLTREL21L
3469 || r_type
== R_PARISC_DPREL21L
)
3470 value
= hppa_field_adjust (value
, addend
, e_lrsel
);
3471 else if (r_type
== R_PARISC_DLTREL14F
3472 || r_type
== R_PARISC_DPREL14F
3473 || r_type
== R_PARISC_GPREL16F
3474 || r_type
== R_PARISC_GPREL16WF
3475 || r_type
== R_PARISC_GPREL16DF
)
3476 value
= hppa_field_adjust (value
, addend
, e_fsel
);
3478 value
= hppa_field_adjust (value
, addend
, e_rrsel
);
3480 insn
= elf_hppa_relocate_insn (insn
, (int) value
, r_type
);
3484 case R_PARISC_DIR21L
:
3485 case R_PARISC_DIR17R
:
3486 case R_PARISC_DIR17F
:
3487 case R_PARISC_DIR14R
:
3488 case R_PARISC_DIR14F
:
3489 case R_PARISC_DIR14WR
:
3490 case R_PARISC_DIR14DR
:
3491 case R_PARISC_DIR16F
:
3492 case R_PARISC_DIR16WF
:
3493 case R_PARISC_DIR16DF
:
3495 /* All DIR relocations are basically the same at this point,
3496 except that branch offsets need to be divided by four, and
3497 we need different field selectors. Note that we don't
3498 redirect absolute calls to local stubs. */
3500 if (r_type
== R_PARISC_DIR21L
)
3501 value
= hppa_field_adjust (value
, addend
, e_lrsel
);
3502 else if (r_type
== R_PARISC_DIR17F
3503 || r_type
== R_PARISC_DIR16F
3504 || r_type
== R_PARISC_DIR16WF
3505 || r_type
== R_PARISC_DIR16DF
3506 || r_type
== R_PARISC_DIR14F
)
3507 value
= hppa_field_adjust (value
, addend
, e_fsel
);
3509 value
= hppa_field_adjust (value
, addend
, e_rrsel
);
3511 if (r_type
== R_PARISC_DIR17R
|| r_type
== R_PARISC_DIR17F
)
3512 /* All branches are implicitly shifted by 2 places. */
3515 insn
= elf_hppa_relocate_insn (insn
, (int) value
, r_type
);
3519 case R_PARISC_PLTOFF21L
:
3520 case R_PARISC_PLTOFF14R
:
3521 case R_PARISC_PLTOFF14F
:
3522 case R_PARISC_PLTOFF14WR
:
3523 case R_PARISC_PLTOFF14DR
:
3524 case R_PARISC_PLTOFF16F
:
3525 case R_PARISC_PLTOFF16WF
:
3526 case R_PARISC_PLTOFF16DF
:
3528 /* We want the value of the PLT offset for this symbol, not
3529 the symbol's actual address. Note that __gp may not point
3530 to the start of the DLT, so we have to compute the absolute
3531 address, then subtract out the value of __gp. */
3532 value
= (hh
->plt_offset
3533 + hppa_info
->plt_sec
->output_offset
3534 + hppa_info
->plt_sec
->output_section
->vma
);
3535 value
-= _bfd_get_gp_value (output_bfd
);
3537 /* All PLTOFF relocations are basically the same at this point,
3538 except that we need different field selectors for the 21bit
3539 version vs the 14bit versions. */
3540 if (r_type
== R_PARISC_PLTOFF21L
)
3541 value
= hppa_field_adjust (value
, addend
, e_lrsel
);
3542 else if (r_type
== R_PARISC_PLTOFF14F
3543 || r_type
== R_PARISC_PLTOFF16F
3544 || r_type
== R_PARISC_PLTOFF16WF
3545 || r_type
== R_PARISC_PLTOFF16DF
)
3546 value
= hppa_field_adjust (value
, addend
, e_fsel
);
3548 value
= hppa_field_adjust (value
, addend
, e_rrsel
);
3550 insn
= elf_hppa_relocate_insn (insn
, (int) value
, r_type
);
3554 case R_PARISC_LTOFF_FPTR32
:
3556 /* FIXME: There used to be code here to create the FPTR itself if
3557 the relocation was against a local symbol. But the code could
3558 never have worked. If the assert below is ever triggered then
3559 the code will need to be reinstated and fixed so that it does
3561 BFD_ASSERT (hh
!= NULL
);
3563 /* We want the value of the DLT offset for this symbol, not
3564 the symbol's actual address. Note that __gp may not point
3565 to the start of the DLT, so we have to compute the absolute
3566 address, then subtract out the value of __gp. */
3567 value
= (hh
->dlt_offset
3568 + hppa_info
->dlt_sec
->output_offset
3569 + hppa_info
->dlt_sec
->output_section
->vma
);
3570 value
-= _bfd_get_gp_value (output_bfd
);
3571 bfd_put_32 (input_bfd
, value
, hit_data
);
3572 return bfd_reloc_ok
;
3575 case R_PARISC_LTOFF_FPTR64
:
3576 case R_PARISC_LTOFF_TP64
:
3578 /* We may still need to create the FPTR itself if it was for
3580 if (eh
== NULL
&& r_type
== R_PARISC_LTOFF_FPTR64
)
3582 /* The first two words of an .opd entry are zero. */
3583 memset (hppa_info
->opd_sec
->contents
+ hh
->opd_offset
, 0, 16);
3585 /* The next word is the address of the function. */
3586 bfd_put_64 (hppa_info
->opd_sec
->owner
, value
+ addend
,
3587 (hppa_info
->opd_sec
->contents
3588 + hh
->opd_offset
+ 16));
3590 /* The last word is our local __gp value. */
3591 value
= _bfd_get_gp_value (info
->output_bfd
);
3592 bfd_put_64 (hppa_info
->opd_sec
->owner
, value
,
3593 hppa_info
->opd_sec
->contents
+ hh
->opd_offset
+ 24);
3595 /* The DLT value is the address of the .opd entry. */
3596 value
= (hh
->opd_offset
3597 + hppa_info
->opd_sec
->output_offset
3598 + hppa_info
->opd_sec
->output_section
->vma
);
3600 bfd_put_64 (hppa_info
->dlt_sec
->owner
,
3602 hppa_info
->dlt_sec
->contents
+ hh
->dlt_offset
);
3605 /* We want the value of the DLT offset for this symbol, not
3606 the symbol's actual address. Note that __gp may not point
3607 to the start of the DLT, so we have to compute the absolute
3608 address, then subtract out the value of __gp. */
3609 value
= (hh
->dlt_offset
3610 + hppa_info
->dlt_sec
->output_offset
3611 + hppa_info
->dlt_sec
->output_section
->vma
);
3612 value
-= _bfd_get_gp_value (output_bfd
);
3613 bfd_put_64 (input_bfd
, value
, hit_data
);
3614 return bfd_reloc_ok
;
3617 case R_PARISC_DIR32
:
3618 bfd_put_32 (input_bfd
, value
+ addend
, hit_data
);
3619 return bfd_reloc_ok
;
3621 case R_PARISC_DIR64
:
3622 bfd_put_64 (input_bfd
, value
+ addend
, hit_data
);
3623 return bfd_reloc_ok
;
3625 case R_PARISC_GPREL64
:
3626 /* Subtract out the global pointer value to make value a DLT
3627 relative address. */
3628 value
-= _bfd_get_gp_value (output_bfd
);
3630 bfd_put_64 (input_bfd
, value
+ addend
, hit_data
);
3631 return bfd_reloc_ok
;
3633 case R_PARISC_LTOFF64
:
3634 /* We want the value of the DLT offset for this symbol, not
3635 the symbol's actual address. Note that __gp may not point
3636 to the start of the DLT, so we have to compute the absolute
3637 address, then subtract out the value of __gp. */
3638 value
= (hh
->dlt_offset
3639 + hppa_info
->dlt_sec
->output_offset
3640 + hppa_info
->dlt_sec
->output_section
->vma
);
3641 value
-= _bfd_get_gp_value (output_bfd
);
3643 bfd_put_64 (input_bfd
, value
+ addend
, hit_data
);
3644 return bfd_reloc_ok
;
3646 case R_PARISC_PCREL32
:
3648 /* If this is a call to a function defined in another dynamic
3649 library, then redirect the call to the local stub for this
3651 if (sym_sec
== NULL
|| sym_sec
->output_section
== NULL
)
3652 value
= (hh
->stub_offset
+ hppa_info
->stub_sec
->output_offset
3653 + hppa_info
->stub_sec
->output_section
->vma
);
3655 /* Turn VALUE into a proper PC relative address. */
3656 value
-= (offset
+ input_section
->output_offset
3657 + input_section
->output_section
->vma
);
3661 bfd_put_32 (input_bfd
, value
, hit_data
);
3662 return bfd_reloc_ok
;
3665 case R_PARISC_PCREL64
:
3667 /* If this is a call to a function defined in another dynamic
3668 library, then redirect the call to the local stub for this
3670 if (sym_sec
== NULL
|| sym_sec
->output_section
== NULL
)
3671 value
= (hh
->stub_offset
+ hppa_info
->stub_sec
->output_offset
3672 + hppa_info
->stub_sec
->output_section
->vma
);
3674 /* Turn VALUE into a proper PC relative address. */
3675 value
-= (offset
+ input_section
->output_offset
3676 + input_section
->output_section
->vma
);
3680 bfd_put_64 (input_bfd
, value
, hit_data
);
3681 return bfd_reloc_ok
;
3684 case R_PARISC_FPTR64
:
3688 /* We may still need to create the FPTR itself if it was for
3692 bfd_vma
*local_opd_offsets
;
3694 if (local_offsets
== NULL
)
3697 local_opd_offsets
= local_offsets
+ 2 * symtab_hdr
->sh_info
;
3698 off
= local_opd_offsets
[r_symndx
];
3700 /* The last bit records whether we've already initialised
3701 this local .opd entry. */
3704 BFD_ASSERT (off
!= (bfd_vma
) -1);
3709 /* The first two words of an .opd entry are zero. */
3710 memset (hppa_info
->opd_sec
->contents
+ off
, 0, 16);
3712 /* The next word is the address of the function. */
3713 bfd_put_64 (hppa_info
->opd_sec
->owner
, value
+ addend
,
3714 (hppa_info
->opd_sec
->contents
+ off
+ 16));
3716 /* The last word is our local __gp value. */
3717 value
= _bfd_get_gp_value (info
->output_bfd
);
3718 bfd_put_64 (hppa_info
->opd_sec
->owner
, value
,
3719 hppa_info
->opd_sec
->contents
+ off
+ 24);
3723 off
= hh
->opd_offset
;
3725 if (hh
== NULL
|| hh
->want_opd
)
3726 /* We want the value of the OPD offset for this symbol. */
3728 + hppa_info
->opd_sec
->output_offset
3729 + hppa_info
->opd_sec
->output_section
->vma
);
3731 /* We want the address of the symbol. */
3734 bfd_put_64 (input_bfd
, value
, hit_data
);
3735 return bfd_reloc_ok
;
3738 case R_PARISC_SECREL32
:
3740 value
-= sym_sec
->output_section
->vma
;
3741 bfd_put_32 (input_bfd
, value
+ addend
, hit_data
);
3742 return bfd_reloc_ok
;
3744 case R_PARISC_SEGREL32
:
3745 case R_PARISC_SEGREL64
:
3747 /* If this is the first SEGREL relocation, then initialize
3748 the segment base values. */
3749 if (hppa_info
->text_segment_base
== (bfd_vma
) -1)
3750 bfd_map_over_sections (output_bfd
, elf_hppa_record_segment_addrs
,
3753 /* VALUE holds the absolute address. We want to include the
3754 addend, then turn it into a segment relative address.
3756 The segment is derived from SYM_SEC. We assume that there are
3757 only two segments of note in the resulting executable/shlib.
3758 A readonly segment (.text) and a readwrite segment (.data). */
3761 if (sym_sec
->flags
& SEC_CODE
)
3762 value
-= hppa_info
->text_segment_base
;
3764 value
-= hppa_info
->data_segment_base
;
3766 if (r_type
== R_PARISC_SEGREL32
)
3767 bfd_put_32 (input_bfd
, value
, hit_data
);
3769 bfd_put_64 (input_bfd
, value
, hit_data
);
3770 return bfd_reloc_ok
;
3773 /* Something we don't know how to handle. */
3775 return bfd_reloc_notsupported
;
3778 /* Update the instruction word. */
3779 bfd_put_32 (input_bfd
, (bfd_vma
) insn
, hit_data
);
3780 return bfd_reloc_ok
;
3783 /* Relocate an HPPA ELF section. */
3786 elf64_hppa_relocate_section (bfd
*output_bfd
,
3787 struct bfd_link_info
*info
,
3789 asection
*input_section
,
3791 Elf_Internal_Rela
*relocs
,
3792 Elf_Internal_Sym
*local_syms
,
3793 asection
**local_sections
)
3795 Elf_Internal_Shdr
*symtab_hdr
;
3796 Elf_Internal_Rela
*rel
;
3797 Elf_Internal_Rela
*relend
;
3798 struct elf64_hppa_link_hash_table
*hppa_info
;
3800 hppa_info
= hppa_link_hash_table (info
);
3801 if (hppa_info
== NULL
)
3804 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3807 relend
= relocs
+ input_section
->reloc_count
;
3808 for (; rel
< relend
; rel
++)
3811 reloc_howto_type
*howto
= elf_hppa_howto_table
+ ELF_R_TYPE (rel
->r_info
);
3812 unsigned long r_symndx
;
3813 struct elf_link_hash_entry
*eh
;
3814 Elf_Internal_Sym
*sym
;
3817 bfd_reloc_status_type r
;
3819 r_type
= ELF_R_TYPE (rel
->r_info
);
3820 if (r_type
< 0 || r_type
>= (int) R_PARISC_UNIMPLEMENTED
)
3822 bfd_set_error (bfd_error_bad_value
);
3825 if (r_type
== (unsigned int) R_PARISC_GNU_VTENTRY
3826 || r_type
== (unsigned int) R_PARISC_GNU_VTINHERIT
)
3829 /* This is a final link. */
3830 r_symndx
= ELF_R_SYM (rel
->r_info
);
3834 if (r_symndx
< symtab_hdr
->sh_info
)
3836 /* This is a local symbol, hh defaults to NULL. */
3837 sym
= local_syms
+ r_symndx
;
3838 sym_sec
= local_sections
[r_symndx
];
3839 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sym_sec
, rel
);
3843 /* This is not a local symbol. */
3844 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
3846 /* It seems this can happen with erroneous or unsupported
3847 input (mixing a.out and elf in an archive, for example.) */
3848 if (sym_hashes
== NULL
)
3851 eh
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
3853 if (info
->wrap_hash
!= NULL
3854 && (input_section
->flags
& SEC_DEBUGGING
) != 0)
3855 eh
= ((struct elf_link_hash_entry
*)
3856 unwrap_hash_lookup (info
, input_bfd
, &eh
->root
));
3858 while (eh
->root
.type
== bfd_link_hash_indirect
3859 || eh
->root
.type
== bfd_link_hash_warning
)
3860 eh
= (struct elf_link_hash_entry
*) eh
->root
.u
.i
.link
;
3863 if (eh
->root
.type
== bfd_link_hash_defined
3864 || eh
->root
.type
== bfd_link_hash_defweak
)
3866 sym_sec
= eh
->root
.u
.def
.section
;
3868 && sym_sec
->output_section
!= NULL
)
3869 relocation
= (eh
->root
.u
.def
.value
3870 + sym_sec
->output_section
->vma
3871 + sym_sec
->output_offset
);
3873 else if (eh
->root
.type
== bfd_link_hash_undefweak
)
3875 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
3876 && ELF_ST_VISIBILITY (eh
->other
) == STV_DEFAULT
)
3878 else if (!bfd_link_relocatable (info
)
3879 && elf_hppa_is_dynamic_loader_symbol (eh
->root
.root
.string
))
3881 else if (!bfd_link_relocatable (info
))
3884 err
= (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
3885 || ELF_ST_VISIBILITY (eh
->other
) != STV_DEFAULT
);
3886 (*info
->callbacks
->undefined_symbol
) (info
,
3887 eh
->root
.root
.string
,
3890 rel
->r_offset
, err
);
3893 if (!bfd_link_relocatable (info
)
3895 && eh
->root
.type
!= bfd_link_hash_defined
3896 && eh
->root
.type
!= bfd_link_hash_defweak
3897 && eh
->root
.type
!= bfd_link_hash_undefweak
)
3899 if (info
->unresolved_syms_in_objects
== RM_IGNORE
3900 && ELF_ST_VISIBILITY (eh
->other
) == STV_DEFAULT
3901 && eh
->type
== STT_PARISC_MILLI
)
3902 (*info
->callbacks
->undefined_symbol
)
3903 (info
, eh_name (eh
), input_bfd
,
3904 input_section
, rel
->r_offset
, FALSE
);
3908 if (sym_sec
!= NULL
&& discarded_section (sym_sec
))
3909 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3910 rel
, 1, relend
, howto
, 0, contents
);
3912 if (bfd_link_relocatable (info
))
3915 r
= elf_hppa_final_link_relocate (rel
, input_bfd
, output_bfd
,
3916 input_section
, contents
,
3917 relocation
, info
, sym_sec
,
3920 if (r
!= bfd_reloc_ok
)
3926 case bfd_reloc_overflow
:
3928 const char *sym_name
;
3934 sym_name
= bfd_elf_string_from_elf_section (input_bfd
,
3935 symtab_hdr
->sh_link
,
3937 if (sym_name
== NULL
)
3939 if (*sym_name
== '\0')
3940 sym_name
= bfd_section_name (sym_sec
);
3943 (*info
->callbacks
->reloc_overflow
)
3944 (info
, (eh
? &eh
->root
: NULL
), sym_name
, howto
->name
,
3945 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
3954 static const struct bfd_elf_special_section elf64_hppa_special_sections
[] =
3956 { STRING_COMMA_LEN (".tbss"), 0, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_HP_TLS
},
3957 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
3958 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
3959 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_PARISC_SHORT
},
3960 { STRING_COMMA_LEN (".dlt"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_PARISC_SHORT
},
3961 { STRING_COMMA_LEN (".sdata"), 0, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_PARISC_SHORT
},
3962 { STRING_COMMA_LEN (".sbss"), 0, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_PARISC_SHORT
},
3963 { NULL
, 0, 0, 0, 0 }
3966 /* The hash bucket size is the standard one, namely 4. */
3968 const struct elf_size_info hppa64_elf_size_info
=
3970 sizeof (Elf64_External_Ehdr
),
3971 sizeof (Elf64_External_Phdr
),
3972 sizeof (Elf64_External_Shdr
),
3973 sizeof (Elf64_External_Rel
),
3974 sizeof (Elf64_External_Rela
),
3975 sizeof (Elf64_External_Sym
),
3976 sizeof (Elf64_External_Dyn
),
3977 sizeof (Elf_External_Note
),
3981 ELFCLASS64
, EV_CURRENT
,
3982 bfd_elf64_write_out_phdrs
,
3983 bfd_elf64_write_shdrs_and_ehdr
,
3984 bfd_elf64_checksum_contents
,
3985 bfd_elf64_write_relocs
,
3986 bfd_elf64_swap_symbol_in
,
3987 bfd_elf64_swap_symbol_out
,
3988 bfd_elf64_slurp_reloc_table
,
3989 bfd_elf64_slurp_symbol_table
,
3990 bfd_elf64_swap_dyn_in
,
3991 bfd_elf64_swap_dyn_out
,
3992 bfd_elf64_swap_reloc_in
,
3993 bfd_elf64_swap_reloc_out
,
3994 bfd_elf64_swap_reloca_in
,
3995 bfd_elf64_swap_reloca_out
3998 #define TARGET_BIG_SYM hppa_elf64_vec
3999 #define TARGET_BIG_NAME "elf64-hppa"
4000 #define ELF_ARCH bfd_arch_hppa
4001 #define ELF_TARGET_ID HPPA64_ELF_DATA
4002 #define ELF_MACHINE_CODE EM_PARISC
4003 /* This is not strictly correct. The maximum page size for PA2.0 is
4004 64M. But everything still uses 4k. */
4005 #define ELF_MAXPAGESIZE 0x1000
4006 #define ELF_OSABI ELFOSABI_HPUX
4008 #define bfd_elf64_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
4009 #define bfd_elf64_bfd_reloc_name_lookup elf_hppa_reloc_name_lookup
4010 #define bfd_elf64_bfd_is_local_label_name elf_hppa_is_local_label_name
4011 #define elf_info_to_howto elf_hppa_info_to_howto
4012 #define elf_info_to_howto_rel elf_hppa_info_to_howto_rel
4014 #define elf_backend_section_from_shdr elf64_hppa_section_from_shdr
4015 #define elf_backend_object_p elf64_hppa_object_p
4016 #define elf_backend_final_write_processing \
4017 elf_hppa_final_write_processing
4018 #define elf_backend_fake_sections elf_hppa_fake_sections
4019 #define elf_backend_add_symbol_hook elf_hppa_add_symbol_hook
4021 #define elf_backend_relocate_section elf_hppa_relocate_section
4023 #define bfd_elf64_bfd_final_link elf_hppa_final_link
4025 #define elf_backend_create_dynamic_sections \
4026 elf64_hppa_create_dynamic_sections
4027 #define elf_backend_post_process_headers elf64_hppa_post_process_headers
4029 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
4031 #define elf_backend_adjust_dynamic_symbol \
4032 elf64_hppa_adjust_dynamic_symbol
4034 #define elf_backend_size_dynamic_sections \
4035 elf64_hppa_size_dynamic_sections
4037 #define elf_backend_finish_dynamic_symbol \
4038 elf64_hppa_finish_dynamic_symbol
4039 #define elf_backend_finish_dynamic_sections \
4040 elf64_hppa_finish_dynamic_sections
4041 #define elf_backend_grok_prstatus elf64_hppa_grok_prstatus
4042 #define elf_backend_grok_psinfo elf64_hppa_grok_psinfo
4044 /* Stuff for the BFD linker: */
4045 #define bfd_elf64_bfd_link_hash_table_create \
4046 elf64_hppa_hash_table_create
4048 #define elf_backend_check_relocs \
4049 elf64_hppa_check_relocs
4051 #define elf_backend_size_info \
4052 hppa64_elf_size_info
4054 #define elf_backend_additional_program_headers \
4055 elf64_hppa_additional_program_headers
4057 #define elf_backend_modify_segment_map \
4058 elf64_hppa_modify_segment_map
4060 #define elf_backend_allow_non_load_phdr \
4061 elf64_hppa_allow_non_load_phdr
4063 #define elf_backend_link_output_symbol_hook \
4064 elf64_hppa_link_output_symbol_hook
4066 #define elf_backend_want_got_plt 0
4067 #define elf_backend_plt_readonly 0
4068 #define elf_backend_want_plt_sym 0
4069 #define elf_backend_got_header_size 0
4070 #define elf_backend_type_change_ok TRUE
4071 #define elf_backend_get_symbol_type elf64_hppa_elf_get_symbol_type
4072 #define elf_backend_reloc_type_class elf64_hppa_reloc_type_class
4073 #define elf_backend_rela_normal 1
4074 #define elf_backend_special_sections elf64_hppa_special_sections
4075 #define elf_backend_action_discarded elf_hppa_action_discarded
4076 #define elf_backend_section_from_phdr elf64_hppa_section_from_phdr
4078 #define elf64_bed elf64_hppa_hpux_bed
4080 #include "elf64-target.h"
4082 #undef TARGET_BIG_SYM
4083 #define TARGET_BIG_SYM hppa_elf64_linux_vec
4084 #undef TARGET_BIG_NAME
4085 #define TARGET_BIG_NAME "elf64-hppa-linux"
4087 #define ELF_OSABI ELFOSABI_GNU
4089 #define elf64_bed elf64_hppa_linux_bed
4090 #undef elf_backend_special_sections
4091 #define elf_backend_special_sections (elf64_hppa_special_sections + 1)
4093 #include "elf64-target.h"