1 /* Support for HPPA 64-bit ELF
2 Copyright (C) 1999-2014 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"
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 (dynobj, 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 (info->relocatable)
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 (info->shared && 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. */
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.root.non_ir_ref = 1;
648 hh->eh.ref_regular = 1;
653 /* We can only get preliminary data on whether a symbol is
654 locally or externally defined, as not all of the input files
655 have yet been processed. Do something with what we know, as
656 this may help reduce memory usage and processing time later. */
657 maybe_dynamic = FALSE;
658 if (hh && ((info->shared
660 || info->unresolved_syms_in_shared_libs == RM_IGNORE))
661 || !hh->eh.def_regular
662 || hh->eh.root.type == bfd_link_hash_defweak))
663 maybe_dynamic = TRUE;
665 howto = elf_hppa_howto_table + ELF64_R_TYPE (rel->r_info);
669 /* These are simple indirect references to symbols through the
670 DLT. We need to create a DLT entry for any symbols which
671 appears in a DLTIND relocation. */
672 case R_PARISC_DLTIND21L:
673 case R_PARISC_DLTIND14R:
674 case R_PARISC_DLTIND14F:
675 case R_PARISC_DLTIND14WR:
676 case R_PARISC_DLTIND14DR:
677 need_entry = NEED_DLT;
680 /* ?!? These need a DLT entry. But I have no idea what to do with
681 the "link time TP value. */
682 case R_PARISC_LTOFF_TP21L:
683 case R_PARISC_LTOFF_TP14R:
684 case R_PARISC_LTOFF_TP14F:
685 case R_PARISC_LTOFF_TP64:
686 case R_PARISC_LTOFF_TP14WR:
687 case R_PARISC_LTOFF_TP14DR:
688 case R_PARISC_LTOFF_TP16F:
689 case R_PARISC_LTOFF_TP16WF:
690 case R_PARISC_LTOFF_TP16DF:
691 need_entry = NEED_DLT;
694 /* These are function calls. Depending on their precise target we
695 may need to make a stub for them. The stub uses the PLT, so we
696 need to create PLT entries for these symbols too. */
697 case R_PARISC_PCREL12F:
698 case R_PARISC_PCREL17F:
699 case R_PARISC_PCREL22F:
700 case R_PARISC_PCREL32:
701 case R_PARISC_PCREL64:
702 case R_PARISC_PCREL21L:
703 case R_PARISC_PCREL17R:
704 case R_PARISC_PCREL17C:
705 case R_PARISC_PCREL14R:
706 case R_PARISC_PCREL14F:
707 case R_PARISC_PCREL22C:
708 case R_PARISC_PCREL14WR:
709 case R_PARISC_PCREL14DR:
710 case R_PARISC_PCREL16F:
711 case R_PARISC_PCREL16WF:
712 case R_PARISC_PCREL16DF:
713 /* Function calls might need to go through the .plt, and
714 might need a long branch stub. */
715 if (hh != NULL && hh->eh.type != STT_PARISC_MILLI)
716 need_entry = (NEED_PLT | NEED_STUB);
721 case R_PARISC_PLTOFF21L:
722 case R_PARISC_PLTOFF14R:
723 case R_PARISC_PLTOFF14F:
724 case R_PARISC_PLTOFF14WR:
725 case R_PARISC_PLTOFF14DR:
726 case R_PARISC_PLTOFF16F:
727 case R_PARISC_PLTOFF16WF:
728 case R_PARISC_PLTOFF16DF:
729 need_entry = (NEED_PLT);
733 if (info->shared || maybe_dynamic)
734 need_entry = (NEED_DYNREL);
735 dynrel_type = R_PARISC_DIR64;
738 /* This is an indirect reference through the DLT to get the address
739 of a OPD descriptor. Thus we need to make a DLT entry that points
741 case R_PARISC_LTOFF_FPTR21L:
742 case R_PARISC_LTOFF_FPTR14R:
743 case R_PARISC_LTOFF_FPTR14WR:
744 case R_PARISC_LTOFF_FPTR14DR:
745 case R_PARISC_LTOFF_FPTR32:
746 case R_PARISC_LTOFF_FPTR64:
747 case R_PARISC_LTOFF_FPTR16F:
748 case R_PARISC_LTOFF_FPTR16WF:
749 case R_PARISC_LTOFF_FPTR16DF:
750 if (info->shared || maybe_dynamic)
751 need_entry = (NEED_DLT | NEED_OPD | NEED_PLT);
753 need_entry = (NEED_DLT | NEED_OPD | NEED_PLT);
754 dynrel_type = R_PARISC_FPTR64;
757 /* This is a simple OPD entry. */
758 case R_PARISC_FPTR64:
759 if (info->shared || maybe_dynamic)
760 need_entry = (NEED_OPD | NEED_PLT | NEED_DYNREL);
762 need_entry = (NEED_OPD | NEED_PLT);
763 dynrel_type = R_PARISC_FPTR64;
766 /* Add more cases as needed. */
774 /* Stash away enough information to be able to find this symbol
775 regardless of whether or not it is local or global. */
777 hh->sym_indx = r_symndx;
780 /* Create what's needed. */
781 if (need_entry & NEED_DLT)
783 /* Allocate space for a DLT entry, as well as a dynamic
784 relocation for this entry. */
785 if (! hppa_info->dlt_sec
786 && ! get_dlt (abfd, info, hppa_info))
792 hh->eh.got.refcount += 1;
796 bfd_signed_vma *local_dlt_refcounts;
798 /* This is a DLT entry for a local symbol. */
799 local_dlt_refcounts = hppa64_elf_local_refcounts (abfd);
800 if (local_dlt_refcounts == NULL)
802 local_dlt_refcounts[r_symndx] += 1;
806 if (need_entry & NEED_PLT)
808 if (! hppa_info->plt_sec
809 && ! get_plt (abfd, info, hppa_info))
815 hh->eh.needs_plt = 1;
816 hh->eh.plt.refcount += 1;
820 bfd_signed_vma *local_dlt_refcounts;
821 bfd_signed_vma *local_plt_refcounts;
823 /* This is a PLT entry for a local symbol. */
824 local_dlt_refcounts = hppa64_elf_local_refcounts (abfd);
825 if (local_dlt_refcounts == NULL)
827 local_plt_refcounts = local_dlt_refcounts + symtab_hdr->sh_info;
828 local_plt_refcounts[r_symndx] += 1;
832 if (need_entry & NEED_STUB)
834 if (! hppa_info->stub_sec
835 && ! get_stub (abfd, info, hppa_info))
841 if (need_entry & NEED_OPD)
843 if (! hppa_info->opd_sec
844 && ! get_opd (abfd, info, hppa_info))
847 /* FPTRs are not allocated by the dynamic linker for PA64,
848 though it is possible that will change in the future. */
854 bfd_signed_vma *local_dlt_refcounts;
855 bfd_signed_vma *local_opd_refcounts;
857 /* This is a OPD for a local symbol. */
858 local_dlt_refcounts = hppa64_elf_local_refcounts (abfd);
859 if (local_dlt_refcounts == NULL)
861 local_opd_refcounts = (local_dlt_refcounts
862 + 2 * symtab_hdr->sh_info);
863 local_opd_refcounts[r_symndx] += 1;
867 /* Add a new dynamic relocation to the chain of dynamic
868 relocations for this symbol. */
869 if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC))
871 if (! hppa_info->other_rel_sec
872 && ! get_reloc_section (abfd, hppa_info, sec))
875 /* Count dynamic relocations against global symbols. */
877 && !count_dyn_reloc (abfd, hh, dynrel_type, sec,
878 sec_symndx, rel->r_offset, rel->r_addend))
881 /* If we are building a shared library and we just recorded
882 a dynamic R_PARISC_FPTR64 relocation, then make sure the
883 section symbol for this section ends up in the dynamic
885 if (info->shared && dynrel_type == R_PARISC_FPTR64
886 && ! (bfd_elf_link_record_local_dynamic_symbol
887 (info, abfd, sec_symndx)))
898 struct elf64_hppa_allocate_data
900 struct bfd_link_info *info;
904 /* Should we do dynamic things to this symbol? */
907 elf64_hppa_dynamic_symbol_p (struct elf_link_hash_entry *eh,
908 struct bfd_link_info *info)
910 /* ??? What, if anything, needs to happen wrt STV_PROTECTED symbols
911 and relocations that retrieve a function descriptor? Assume the
913 if (_bfd_elf_dynamic_symbol_p (eh, info, 1))
915 /* ??? Why is this here and not elsewhere is_local_label_name. */
916 if (eh->root.root.string[0] == '$' && eh->root.root.string[1] == '$')
925 /* Mark all functions exported by this file so that we can later allocate
926 entries in .opd for them. */
929 elf64_hppa_mark_exported_functions (struct elf_link_hash_entry *eh, void *data)
931 struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
932 struct bfd_link_info *info = (struct bfd_link_info *)data;
933 struct elf64_hppa_link_hash_table *hppa_info;
935 hppa_info = hppa_link_hash_table (info);
936 if (hppa_info == NULL)
940 && (eh->root.type == bfd_link_hash_defined
941 || eh->root.type == bfd_link_hash_defweak)
942 && eh->root.u.def.section->output_section != NULL
943 && eh->type == STT_FUNC)
945 if (! hppa_info->opd_sec
946 && ! get_opd (hppa_info->root.dynobj, info, hppa_info))
951 /* Put a flag here for output_symbol_hook. */
959 /* Allocate space for a DLT entry. */
962 allocate_global_data_dlt (struct elf_link_hash_entry *eh, void *data)
964 struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
965 struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data;
971 /* Possibly add the symbol to the local dynamic symbol
972 table since we might need to create a dynamic relocation
974 if (eh->dynindx == -1 && eh->type != STT_PARISC_MILLI)
976 bfd *owner = eh->root.u.def.section->owner;
978 if (! (bfd_elf_link_record_local_dynamic_symbol
979 (x->info, owner, hh->sym_indx)))
984 hh->dlt_offset = x->ofs;
985 x->ofs += DLT_ENTRY_SIZE;
990 /* Allocate space for a DLT.PLT entry. */
993 allocate_global_data_plt (struct elf_link_hash_entry *eh, void *data)
995 struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
996 struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *) data;
999 && elf64_hppa_dynamic_symbol_p (eh, x->info)
1000 && !((eh->root.type == bfd_link_hash_defined
1001 || eh->root.type == bfd_link_hash_defweak)
1002 && eh->root.u.def.section->output_section != NULL))
1004 hh->plt_offset = x->ofs;
1005 x->ofs += PLT_ENTRY_SIZE;
1006 if (hh->plt_offset < 0x2000)
1008 struct elf64_hppa_link_hash_table *hppa_info;
1010 hppa_info = hppa_link_hash_table (x->info);
1011 if (hppa_info == NULL)
1014 hppa_info->gp_offset = hh->plt_offset;
1023 /* Allocate space for a STUB entry. */
1026 allocate_global_data_stub (struct elf_link_hash_entry *eh, void *data)
1028 struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
1029 struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data;
1032 && elf64_hppa_dynamic_symbol_p (eh, x->info)
1033 && !((eh->root.type == bfd_link_hash_defined
1034 || eh->root.type == bfd_link_hash_defweak)
1035 && eh->root.u.def.section->output_section != NULL))
1037 hh->stub_offset = x->ofs;
1038 x->ofs += sizeof (plt_stub);
1045 /* Allocate space for a FPTR entry. */
1048 allocate_global_data_opd (struct elf_link_hash_entry *eh, void *data)
1050 struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
1051 struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data;
1053 if (hh && hh->want_opd)
1055 /* We never need an opd entry for a symbol which is not
1056 defined by this output file. */
1057 if (hh && (hh->eh.root.type == bfd_link_hash_undefined
1058 || hh->eh.root.type == bfd_link_hash_undefweak
1059 || hh->eh.root.u.def.section->output_section == NULL))
1062 /* If we are creating a shared library, took the address of a local
1063 function or might export this function from this object file, then
1064 we have to create an opd descriptor. */
1065 else if (x->info->shared
1067 || (hh->eh.dynindx == -1 && hh->eh.type != STT_PARISC_MILLI)
1068 || (hh->eh.root.type == bfd_link_hash_defined
1069 || hh->eh.root.type == bfd_link_hash_defweak))
1071 /* If we are creating a shared library, then we will have to
1072 create a runtime relocation for the symbol to properly
1073 initialize the .opd entry. Make sure the symbol gets
1074 added to the dynamic symbol table. */
1076 && (hh == NULL || (hh->eh.dynindx == -1)))
1079 /* PR 6511: Default to using the dynamic symbol table. */
1080 owner = (hh->owner ? hh->owner: eh->root.u.def.section->owner);
1082 if (!bfd_elf_link_record_local_dynamic_symbol
1083 (x->info, owner, hh->sym_indx))
1087 /* This may not be necessary or desirable anymore now that
1088 we have some support for dealing with section symbols
1089 in dynamic relocs. But name munging does make the result
1090 much easier to debug. ie, the EPLT reloc will reference
1091 a symbol like .foobar, instead of .text + offset. */
1092 if (x->info->shared && eh)
1095 struct elf_link_hash_entry *nh;
1097 new_name = alloca (strlen (eh->root.root.string) + 2);
1099 strcpy (new_name + 1, eh->root.root.string);
1101 nh = elf_link_hash_lookup (elf_hash_table (x->info),
1102 new_name, TRUE, TRUE, TRUE);
1104 nh->root.type = eh->root.type;
1105 nh->root.u.def.value = eh->root.u.def.value;
1106 nh->root.u.def.section = eh->root.u.def.section;
1108 if (! bfd_elf_link_record_dynamic_symbol (x->info, nh))
1112 hh->opd_offset = x->ofs;
1113 x->ofs += OPD_ENTRY_SIZE;
1116 /* Otherwise we do not need an opd entry. */
1123 /* HP requires the EI_OSABI field to be filled in. The assignment to
1124 EI_ABIVERSION may not be strictly necessary. */
1127 elf64_hppa_post_process_headers (bfd *abfd,
1128 struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
1130 Elf_Internal_Ehdr * i_ehdrp;
1132 i_ehdrp = elf_elfheader (abfd);
1134 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
1135 i_ehdrp->e_ident[EI_ABIVERSION] = 1;
1138 /* Create function descriptor section (.opd). This section is called .opd
1139 because it contains "official procedure descriptors". The "official"
1140 refers to the fact that these descriptors are used when taking the address
1141 of a procedure, thus ensuring a unique address for each procedure. */
1145 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1146 struct elf64_hppa_link_hash_table *hppa_info)
1151 opd = hppa_info->opd_sec;
1154 dynobj = hppa_info->root.dynobj;
1156 hppa_info->root.dynobj = dynobj = abfd;
1158 opd = bfd_make_section_anyway_with_flags (dynobj, ".opd",
1163 | SEC_LINKER_CREATED));
1165 || !bfd_set_section_alignment (abfd, opd, 3))
1171 hppa_info->opd_sec = opd;
1177 /* Create the PLT section. */
1181 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1182 struct elf64_hppa_link_hash_table *hppa_info)
1187 plt = hppa_info->plt_sec;
1190 dynobj = hppa_info->root.dynobj;
1192 hppa_info->root.dynobj = dynobj = abfd;
1194 plt = bfd_make_section_anyway_with_flags (dynobj, ".plt",
1199 | SEC_LINKER_CREATED));
1201 || !bfd_set_section_alignment (abfd, plt, 3))
1207 hppa_info->plt_sec = plt;
1213 /* Create the DLT section. */
1217 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1218 struct elf64_hppa_link_hash_table *hppa_info)
1223 dlt = hppa_info->dlt_sec;
1226 dynobj = hppa_info->root.dynobj;
1228 hppa_info->root.dynobj = dynobj = abfd;
1230 dlt = bfd_make_section_anyway_with_flags (dynobj, ".dlt",
1235 | SEC_LINKER_CREATED));
1237 || !bfd_set_section_alignment (abfd, dlt, 3))
1243 hppa_info->dlt_sec = dlt;
1249 /* Create the stubs section. */
1252 get_stub (bfd *abfd,
1253 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1254 struct elf64_hppa_link_hash_table *hppa_info)
1259 stub = hppa_info->stub_sec;
1262 dynobj = hppa_info->root.dynobj;
1264 hppa_info->root.dynobj = dynobj = abfd;
1266 stub = bfd_make_section_anyway_with_flags (dynobj, ".stub",
1267 (SEC_ALLOC | SEC_LOAD
1271 | SEC_LINKER_CREATED));
1273 || !bfd_set_section_alignment (abfd, stub, 3))
1279 hppa_info->stub_sec = stub;
1285 /* Create sections necessary for dynamic linking. This is only a rough
1286 cut and will likely change as we learn more about the somewhat
1287 unusual dynamic linking scheme HP uses.
1290 Contains code to implement cross-space calls. The first time one
1291 of the stubs is used it will call into the dynamic linker, later
1292 calls will go straight to the target.
1294 The only stub we support right now looks like
1298 ldd OFFSET+8(%dp),%dp
1300 Other stubs may be needed in the future. We may want the remove
1301 the break/nop instruction. It is only used right now to keep the
1302 offset of a .plt entry and a .stub entry in sync.
1305 This is what most people call the .got. HP used a different name.
1309 Relocations for the DLT.
1312 Function pointers as address,gp pairs.
1315 Should contain dynamic IPLT (and EPLT?) relocations.
1321 EPLT relocations for symbols exported from shared libraries. */
1324 elf64_hppa_create_dynamic_sections (bfd *abfd,
1325 struct bfd_link_info *info)
1328 struct elf64_hppa_link_hash_table *hppa_info;
1330 hppa_info = hppa_link_hash_table (info);
1331 if (hppa_info == NULL)
1334 if (! get_stub (abfd, info, hppa_info))
1337 if (! get_dlt (abfd, info, hppa_info))
1340 if (! get_plt (abfd, info, hppa_info))
1343 if (! get_opd (abfd, info, hppa_info))
1346 s = bfd_make_section_anyway_with_flags (abfd, ".rela.dlt",
1347 (SEC_ALLOC | SEC_LOAD
1351 | SEC_LINKER_CREATED));
1353 || !bfd_set_section_alignment (abfd, s, 3))
1355 hppa_info->dlt_rel_sec = s;
1357 s = bfd_make_section_anyway_with_flags (abfd, ".rela.plt",
1358 (SEC_ALLOC | SEC_LOAD
1362 | SEC_LINKER_CREATED));
1364 || !bfd_set_section_alignment (abfd, s, 3))
1366 hppa_info->plt_rel_sec = s;
1368 s = bfd_make_section_anyway_with_flags (abfd, ".rela.data",
1369 (SEC_ALLOC | SEC_LOAD
1373 | SEC_LINKER_CREATED));
1375 || !bfd_set_section_alignment (abfd, s, 3))
1377 hppa_info->other_rel_sec = s;
1379 s = bfd_make_section_anyway_with_flags (abfd, ".rela.opd",
1380 (SEC_ALLOC | SEC_LOAD
1384 | SEC_LINKER_CREATED));
1386 || !bfd_set_section_alignment (abfd, s, 3))
1388 hppa_info->opd_rel_sec = s;
1393 /* Allocate dynamic relocations for those symbols that turned out
1397 allocate_dynrel_entries (struct elf_link_hash_entry *eh, void *data)
1399 struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
1400 struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data;
1401 struct elf64_hppa_link_hash_table *hppa_info;
1402 struct elf64_hppa_dyn_reloc_entry *rent;
1403 bfd_boolean dynamic_symbol, shared;
1405 hppa_info = hppa_link_hash_table (x->info);
1406 if (hppa_info == NULL)
1409 dynamic_symbol = elf64_hppa_dynamic_symbol_p (eh, x->info);
1410 shared = x->info->shared;
1412 /* We may need to allocate relocations for a non-dynamic symbol
1413 when creating a shared library. */
1414 if (!dynamic_symbol && !shared)
1417 /* Take care of the normal data relocations. */
1419 for (rent = hh->reloc_entries; rent; rent = rent->next)
1421 /* Allocate one iff we are building a shared library, the relocation
1422 isn't a R_PARISC_FPTR64, or we don't want an opd entry. */
1423 if (!shared && rent->type == R_PARISC_FPTR64 && hh->want_opd)
1426 hppa_info->other_rel_sec->size += sizeof (Elf64_External_Rela);
1428 /* Make sure this symbol gets into the dynamic symbol table if it is
1429 not already recorded. ?!? This should not be in the loop since
1430 the symbol need only be added once. */
1431 if (eh->dynindx == -1 && eh->type != STT_PARISC_MILLI)
1432 if (!bfd_elf_link_record_local_dynamic_symbol
1433 (x->info, rent->sec->owner, hh->sym_indx))
1437 /* Take care of the GOT and PLT relocations. */
1439 if ((dynamic_symbol || shared) && hh->want_dlt)
1440 hppa_info->dlt_rel_sec->size += sizeof (Elf64_External_Rela);
1442 /* If we are building a shared library, then every symbol that has an
1443 opd entry will need an EPLT relocation to relocate the symbol's address
1444 and __gp value based on the runtime load address. */
1445 if (shared && hh->want_opd)
1446 hppa_info->opd_rel_sec->size += sizeof (Elf64_External_Rela);
1448 if (hh->want_plt && dynamic_symbol)
1450 bfd_size_type t = 0;
1452 /* Dynamic symbols get one IPLT relocation. Local symbols in
1453 shared libraries get two REL relocations. Local symbols in
1454 main applications get nothing. */
1456 t = sizeof (Elf64_External_Rela);
1458 t = 2 * sizeof (Elf64_External_Rela);
1460 hppa_info->plt_rel_sec->size += t;
1466 /* Adjust a symbol defined by a dynamic object and referenced by a
1470 elf64_hppa_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1471 struct elf_link_hash_entry *eh)
1473 /* ??? Undefined symbols with PLT entries should be re-defined
1474 to be the PLT entry. */
1476 /* If this is a weak symbol, and there is a real definition, the
1477 processor independent code will have arranged for us to see the
1478 real definition first, and we can just use the same value. */
1479 if (eh->u.weakdef != NULL)
1481 BFD_ASSERT (eh->u.weakdef->root.type == bfd_link_hash_defined
1482 || eh->u.weakdef->root.type == bfd_link_hash_defweak);
1483 eh->root.u.def.section = eh->u.weakdef->root.u.def.section;
1484 eh->root.u.def.value = eh->u.weakdef->root.u.def.value;
1488 /* If this is a reference to a symbol defined by a dynamic object which
1489 is not a function, we might allocate the symbol in our .dynbss section
1490 and allocate a COPY dynamic relocation.
1492 But PA64 code is canonically PIC, so as a rule we can avoid this sort
1498 /* This function is called via elf_link_hash_traverse to mark millicode
1499 symbols with a dynindx of -1 and to remove the string table reference
1500 from the dynamic symbol table. If the symbol is not a millicode symbol,
1501 elf64_hppa_mark_exported_functions is called. */
1504 elf64_hppa_mark_milli_and_exported_functions (struct elf_link_hash_entry *eh,
1507 struct bfd_link_info *info = (struct bfd_link_info *) data;
1509 if (eh->type == STT_PARISC_MILLI)
1511 if (eh->dynindx != -1)
1514 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1520 return elf64_hppa_mark_exported_functions (eh, data);
1523 /* Set the final sizes of the dynamic sections and allocate memory for
1524 the contents of our special sections. */
1527 elf64_hppa_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
1529 struct elf64_hppa_link_hash_table *hppa_info;
1530 struct elf64_hppa_allocate_data data;
1536 bfd_boolean reltext;
1538 hppa_info = hppa_link_hash_table (info);
1539 if (hppa_info == NULL)
1542 dynobj = elf_hash_table (info)->dynobj;
1543 BFD_ASSERT (dynobj != NULL);
1545 /* Mark each function this program exports so that we will allocate
1546 space in the .opd section for each function's FPTR. If we are
1547 creating dynamic sections, change the dynamic index of millicode
1548 symbols to -1 and remove them from the string table for .dynstr.
1550 We have to traverse the main linker hash table since we have to
1551 find functions which may not have been mentioned in any relocs. */
1552 elf_link_hash_traverse (elf_hash_table (info),
1553 (elf_hash_table (info)->dynamic_sections_created
1554 ? elf64_hppa_mark_milli_and_exported_functions
1555 : elf64_hppa_mark_exported_functions),
1558 if (elf_hash_table (info)->dynamic_sections_created)
1560 /* Set the contents of the .interp section to the interpreter. */
1561 if (info->executable)
1563 sec = bfd_get_linker_section (dynobj, ".interp");
1564 BFD_ASSERT (sec != NULL);
1565 sec->size = sizeof ELF_DYNAMIC_INTERPRETER;
1566 sec->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1571 /* We may have created entries in the .rela.got section.
1572 However, if we are not creating the dynamic sections, we will
1573 not actually use these entries. Reset the size of .rela.dlt,
1574 which will cause it to get stripped from the output file
1576 sec = bfd_get_linker_section (dynobj, ".rela.dlt");
1581 /* Set up DLT, PLT and OPD offsets for local syms, and space for local
1583 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1585 bfd_signed_vma *local_dlt;
1586 bfd_signed_vma *end_local_dlt;
1587 bfd_signed_vma *local_plt;
1588 bfd_signed_vma *end_local_plt;
1589 bfd_signed_vma *local_opd;
1590 bfd_signed_vma *end_local_opd;
1591 bfd_size_type locsymcount;
1592 Elf_Internal_Shdr *symtab_hdr;
1595 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1598 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
1600 struct elf64_hppa_dyn_reloc_entry *hdh_p;
1602 for (hdh_p = ((struct elf64_hppa_dyn_reloc_entry *)
1603 elf_section_data (sec)->local_dynrel);
1605 hdh_p = hdh_p->next)
1607 if (!bfd_is_abs_section (hdh_p->sec)
1608 && bfd_is_abs_section (hdh_p->sec->output_section))
1610 /* Input section has been discarded, either because
1611 it is a copy of a linkonce section or due to
1612 linker script /DISCARD/, so we'll be discarding
1615 else if (hdh_p->count != 0)
1617 srel = elf_section_data (hdh_p->sec)->sreloc;
1618 srel->size += hdh_p->count * sizeof (Elf64_External_Rela);
1619 if ((hdh_p->sec->output_section->flags & SEC_READONLY) != 0)
1620 info->flags |= DF_TEXTREL;
1625 local_dlt = elf_local_got_refcounts (ibfd);
1629 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1630 locsymcount = symtab_hdr->sh_info;
1631 end_local_dlt = local_dlt + locsymcount;
1632 sec = hppa_info->dlt_sec;
1633 srel = hppa_info->dlt_rel_sec;
1634 for (; local_dlt < end_local_dlt; ++local_dlt)
1638 *local_dlt = sec->size;
1639 sec->size += DLT_ENTRY_SIZE;
1642 srel->size += sizeof (Elf64_External_Rela);
1646 *local_dlt = (bfd_vma) -1;
1649 local_plt = end_local_dlt;
1650 end_local_plt = local_plt + locsymcount;
1651 if (! hppa_info->root.dynamic_sections_created)
1653 /* Won't be used, but be safe. */
1654 for (; local_plt < end_local_plt; ++local_plt)
1655 *local_plt = (bfd_vma) -1;
1659 sec = hppa_info->plt_sec;
1660 srel = hppa_info->plt_rel_sec;
1661 for (; local_plt < end_local_plt; ++local_plt)
1665 *local_plt = sec->size;
1666 sec->size += PLT_ENTRY_SIZE;
1668 srel->size += sizeof (Elf64_External_Rela);
1671 *local_plt = (bfd_vma) -1;
1675 local_opd = end_local_plt;
1676 end_local_opd = local_opd + locsymcount;
1677 if (! hppa_info->root.dynamic_sections_created)
1679 /* Won't be used, but be safe. */
1680 for (; local_opd < end_local_opd; ++local_opd)
1681 *local_opd = (bfd_vma) -1;
1685 sec = hppa_info->opd_sec;
1686 srel = hppa_info->opd_rel_sec;
1687 for (; local_opd < end_local_opd; ++local_opd)
1691 *local_opd = sec->size;
1692 sec->size += OPD_ENTRY_SIZE;
1694 srel->size += sizeof (Elf64_External_Rela);
1697 *local_opd = (bfd_vma) -1;
1702 /* Allocate the GOT entries. */
1705 if (hppa_info->dlt_sec)
1707 data.ofs = hppa_info->dlt_sec->size;
1708 elf_link_hash_traverse (elf_hash_table (info),
1709 allocate_global_data_dlt, &data);
1710 hppa_info->dlt_sec->size = data.ofs;
1713 if (hppa_info->plt_sec)
1715 data.ofs = hppa_info->plt_sec->size;
1716 elf_link_hash_traverse (elf_hash_table (info),
1717 allocate_global_data_plt, &data);
1718 hppa_info->plt_sec->size = data.ofs;
1721 if (hppa_info->stub_sec)
1724 elf_link_hash_traverse (elf_hash_table (info),
1725 allocate_global_data_stub, &data);
1726 hppa_info->stub_sec->size = data.ofs;
1729 /* Allocate space for entries in the .opd section. */
1730 if (hppa_info->opd_sec)
1732 data.ofs = hppa_info->opd_sec->size;
1733 elf_link_hash_traverse (elf_hash_table (info),
1734 allocate_global_data_opd, &data);
1735 hppa_info->opd_sec->size = data.ofs;
1738 /* Now allocate space for dynamic relocations, if necessary. */
1739 if (hppa_info->root.dynamic_sections_created)
1740 elf_link_hash_traverse (elf_hash_table (info),
1741 allocate_dynrel_entries, &data);
1743 /* The sizes of all the sections are set. Allocate memory for them. */
1747 for (sec = dynobj->sections; sec != NULL; sec = sec->next)
1751 if ((sec->flags & SEC_LINKER_CREATED) == 0)
1754 /* It's OK to base decisions on the section name, because none
1755 of the dynobj section names depend upon the input files. */
1756 name = bfd_get_section_name (dynobj, sec);
1758 if (strcmp (name, ".plt") == 0)
1760 /* Remember whether there is a PLT. */
1761 plt = sec->size != 0;
1763 else if (strcmp (name, ".opd") == 0
1764 || CONST_STRNEQ (name, ".dlt")
1765 || strcmp (name, ".stub") == 0
1766 || strcmp (name, ".got") == 0)
1768 /* Strip this section if we don't need it; see the comment below. */
1770 else if (CONST_STRNEQ (name, ".rela"))
1776 /* Remember whether there are any reloc sections other
1778 if (strcmp (name, ".rela.plt") != 0)
1780 const char *outname;
1784 /* If this relocation section applies to a read only
1785 section, then we probably need a DT_TEXTREL
1786 entry. The entries in the .rela.plt section
1787 really apply to the .got section, which we
1788 created ourselves and so know is not readonly. */
1789 outname = bfd_get_section_name (output_bfd,
1790 sec->output_section);
1791 target = bfd_get_section_by_name (output_bfd, outname + 4);
1793 && (target->flags & SEC_READONLY) != 0
1794 && (target->flags & SEC_ALLOC) != 0)
1798 /* We use the reloc_count field as a counter if we need
1799 to copy relocs into the output file. */
1800 sec->reloc_count = 0;
1805 /* It's not one of our sections, so don't allocate space. */
1811 /* If we don't need this section, strip it from the
1812 output file. This is mostly to handle .rela.bss and
1813 .rela.plt. We must create both sections in
1814 create_dynamic_sections, because they must be created
1815 before the linker maps input sections to output
1816 sections. The linker does that before
1817 adjust_dynamic_symbol is called, and it is that
1818 function which decides whether anything needs to go
1819 into these sections. */
1820 sec->flags |= SEC_EXCLUDE;
1824 if ((sec->flags & SEC_HAS_CONTENTS) == 0)
1827 /* Allocate memory for the section contents if it has not
1828 been allocated already. We use bfd_zalloc here in case
1829 unused entries are not reclaimed before the section's
1830 contents are written out. This should not happen, but this
1831 way if it does, we get a R_PARISC_NONE reloc instead of
1833 if (sec->contents == NULL)
1835 sec->contents = (bfd_byte *) bfd_zalloc (dynobj, sec->size);
1836 if (sec->contents == NULL)
1841 if (elf_hash_table (info)->dynamic_sections_created)
1843 /* Always create a DT_PLTGOT. It actually has nothing to do with
1844 the PLT, it is how we communicate the __gp value of a load
1845 module to the dynamic linker. */
1846 #define add_dynamic_entry(TAG, VAL) \
1847 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1849 if (!add_dynamic_entry (DT_HP_DLD_FLAGS, 0)
1850 || !add_dynamic_entry (DT_PLTGOT, 0))
1853 /* Add some entries to the .dynamic section. We fill in the
1854 values later, in elf64_hppa_finish_dynamic_sections, but we
1855 must add the entries now so that we get the correct size for
1856 the .dynamic section. The DT_DEBUG entry is filled in by the
1857 dynamic linker and used by the debugger. */
1860 if (!add_dynamic_entry (DT_DEBUG, 0)
1861 || !add_dynamic_entry (DT_HP_DLD_HOOK, 0)
1862 || !add_dynamic_entry (DT_HP_LOAD_MAP, 0))
1866 /* Force DT_FLAGS to always be set.
1867 Required by HPUX 11.00 patch PHSS_26559. */
1868 if (!add_dynamic_entry (DT_FLAGS, (info)->flags))
1873 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
1874 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1875 || !add_dynamic_entry (DT_JMPREL, 0))
1881 if (!add_dynamic_entry (DT_RELA, 0)
1882 || !add_dynamic_entry (DT_RELASZ, 0)
1883 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
1889 if (!add_dynamic_entry (DT_TEXTREL, 0))
1891 info->flags |= DF_TEXTREL;
1894 #undef add_dynamic_entry
1899 /* Called after we have output the symbol into the dynamic symbol
1900 table, but before we output the symbol into the normal symbol
1903 For some symbols we had to change their address when outputting
1904 the dynamic symbol table. We undo that change here so that
1905 the symbols have their expected value in the normal symbol
1909 elf64_hppa_link_output_symbol_hook (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1911 Elf_Internal_Sym *sym,
1912 asection *input_sec ATTRIBUTE_UNUSED,
1913 struct elf_link_hash_entry *eh)
1915 struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
1917 /* We may be called with the file symbol or section symbols.
1918 They never need munging, so it is safe to ignore them. */
1922 /* Function symbols for which we created .opd entries *may* have been
1923 munged by finish_dynamic_symbol and have to be un-munged here.
1925 Note that finish_dynamic_symbol sometimes turns dynamic symbols
1926 into non-dynamic ones, so we initialize st_shndx to -1 in
1927 mark_exported_functions and check to see if it was overwritten
1928 here instead of just checking eh->dynindx. */
1929 if (hh->want_opd && hh->st_shndx != -1)
1931 /* Restore the saved value and section index. */
1932 sym->st_value = hh->st_value;
1933 sym->st_shndx = hh->st_shndx;
1939 /* Finish up dynamic symbol handling. We set the contents of various
1940 dynamic sections here. */
1943 elf64_hppa_finish_dynamic_symbol (bfd *output_bfd,
1944 struct bfd_link_info *info,
1945 struct elf_link_hash_entry *eh,
1946 Elf_Internal_Sym *sym)
1948 struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
1949 asection *stub, *splt, *sopd, *spltrel;
1950 struct elf64_hppa_link_hash_table *hppa_info;
1952 hppa_info = hppa_link_hash_table (info);
1953 if (hppa_info == NULL)
1956 stub = hppa_info->stub_sec;
1957 splt = hppa_info->plt_sec;
1958 sopd = hppa_info->opd_sec;
1959 spltrel = hppa_info->plt_rel_sec;
1961 /* Incredible. It is actually necessary to NOT use the symbol's real
1962 value when building the dynamic symbol table for a shared library.
1963 At least for symbols that refer to functions.
1965 We will store a new value and section index into the symbol long
1966 enough to output it into the dynamic symbol table, then we restore
1967 the original values (in elf64_hppa_link_output_symbol_hook). */
1970 BFD_ASSERT (sopd != NULL);
1972 /* Save away the original value and section index so that we
1973 can restore them later. */
1974 hh->st_value = sym->st_value;
1975 hh->st_shndx = sym->st_shndx;
1977 /* For the dynamic symbol table entry, we want the value to be
1978 address of this symbol's entry within the .opd section. */
1979 sym->st_value = (hh->opd_offset
1980 + sopd->output_offset
1981 + sopd->output_section->vma);
1982 sym->st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
1983 sopd->output_section);
1986 /* Initialize a .plt entry if requested. */
1988 && elf64_hppa_dynamic_symbol_p (eh, info))
1991 Elf_Internal_Rela rel;
1994 BFD_ASSERT (splt != NULL && spltrel != NULL);
1996 /* We do not actually care about the value in the PLT entry
1997 if we are creating a shared library and the symbol is
1998 still undefined, we create a dynamic relocation to fill
1999 in the correct value. */
2000 if (info->shared && eh->root.type == bfd_link_hash_undefined)
2003 value = (eh->root.u.def.value + eh->root.u.def.section->vma);
2005 /* Fill in the entry in the procedure linkage table.
2007 The format of a plt entry is
2010 plt_offset is the offset within the PLT section at which to
2011 install the PLT entry.
2013 We are modifying the in-memory PLT contents here, so we do not add
2014 in the output_offset of the PLT section. */
2016 bfd_put_64 (splt->owner, value, splt->contents + hh->plt_offset);
2017 value = _bfd_get_gp_value (splt->output_section->owner);
2018 bfd_put_64 (splt->owner, value, splt->contents + hh->plt_offset + 0x8);
2020 /* Create a dynamic IPLT relocation for this entry.
2022 We are creating a relocation in the output file's PLT section,
2023 which is included within the DLT secton. So we do need to include
2024 the PLT's output_offset in the computation of the relocation's
2026 rel.r_offset = (hh->plt_offset + splt->output_offset
2027 + splt->output_section->vma);
2028 rel.r_info = ELF64_R_INFO (hh->eh.dynindx, R_PARISC_IPLT);
2031 loc = spltrel->contents;
2032 loc += spltrel->reloc_count++ * sizeof (Elf64_External_Rela);
2033 bfd_elf64_swap_reloca_out (splt->output_section->owner, &rel, loc);
2036 /* Initialize an external call stub entry if requested. */
2038 && elf64_hppa_dynamic_symbol_p (eh, info))
2042 unsigned int max_offset;
2044 BFD_ASSERT (stub != NULL);
2046 /* Install the generic stub template.
2048 We are modifying the contents of the stub section, so we do not
2049 need to include the stub section's output_offset here. */
2050 memcpy (stub->contents + hh->stub_offset, plt_stub, sizeof (plt_stub));
2052 /* Fix up the first ldd instruction.
2054 We are modifying the contents of the STUB section in memory,
2055 so we do not need to include its output offset in this computation.
2057 Note the plt_offset value is the value of the PLT entry relative to
2058 the start of the PLT section. These instructions will reference
2059 data relative to the value of __gp, which may not necessarily have
2060 the same address as the start of the PLT section.
2062 gp_offset contains the offset of __gp within the PLT section. */
2063 value = hh->plt_offset - hppa_info->gp_offset;
2065 insn = bfd_get_32 (stub->owner, stub->contents + hh->stub_offset);
2066 if (output_bfd->arch_info->mach >= 25)
2068 /* Wide mode allows 16 bit offsets. */
2071 insn |= re_assemble_16 ((int) value);
2077 insn |= re_assemble_14 ((int) value);
2080 if ((value & 7) || value + max_offset >= 2*max_offset - 8)
2082 (*_bfd_error_handler) (_("stub entry for %s cannot load .plt, dp offset = %ld"),
2083 hh->eh.root.root.string,
2088 bfd_put_32 (stub->owner, (bfd_vma) insn,
2089 stub->contents + hh->stub_offset);
2091 /* Fix up the second ldd instruction. */
2093 insn = bfd_get_32 (stub->owner, stub->contents + hh->stub_offset + 8);
2094 if (output_bfd->arch_info->mach >= 25)
2097 insn |= re_assemble_16 ((int) value);
2102 insn |= re_assemble_14 ((int) value);
2104 bfd_put_32 (stub->owner, (bfd_vma) insn,
2105 stub->contents + hh->stub_offset + 8);
2111 /* The .opd section contains FPTRs for each function this file
2112 exports. Initialize the FPTR entries. */
2115 elf64_hppa_finalize_opd (struct elf_link_hash_entry *eh, void *data)
2117 struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
2118 struct bfd_link_info *info = (struct bfd_link_info *)data;
2119 struct elf64_hppa_link_hash_table *hppa_info;
2123 hppa_info = hppa_link_hash_table (info);
2124 if (hppa_info == NULL)
2127 sopd = hppa_info->opd_sec;
2128 sopdrel = hppa_info->opd_rel_sec;
2134 /* The first two words of an .opd entry are zero.
2136 We are modifying the contents of the OPD section in memory, so we
2137 do not need to include its output offset in this computation. */
2138 memset (sopd->contents + hh->opd_offset, 0, 16);
2140 value = (eh->root.u.def.value
2141 + eh->root.u.def.section->output_section->vma
2142 + eh->root.u.def.section->output_offset);
2144 /* The next word is the address of the function. */
2145 bfd_put_64 (sopd->owner, value, sopd->contents + hh->opd_offset + 16);
2147 /* The last word is our local __gp value. */
2148 value = _bfd_get_gp_value (sopd->output_section->owner);
2149 bfd_put_64 (sopd->owner, value, sopd->contents + hh->opd_offset + 24);
2152 /* If we are generating a shared library, we must generate EPLT relocations
2153 for each entry in the .opd, even for static functions (they may have
2154 had their address taken). */
2155 if (info->shared && hh->want_opd)
2157 Elf_Internal_Rela rel;
2161 /* We may need to do a relocation against a local symbol, in
2162 which case we have to look up it's dynamic symbol index off
2163 the local symbol hash table. */
2164 if (eh->dynindx != -1)
2165 dynindx = eh->dynindx;
2168 = _bfd_elf_link_lookup_local_dynindx (info, hh->owner,
2171 /* The offset of this relocation is the absolute address of the
2172 .opd entry for this symbol. */
2173 rel.r_offset = (hh->opd_offset + sopd->output_offset
2174 + sopd->output_section->vma);
2176 /* If H is non-null, then we have an external symbol.
2178 It is imperative that we use a different dynamic symbol for the
2179 EPLT relocation if the symbol has global scope.
2181 In the dynamic symbol table, the function symbol will have a value
2182 which is address of the function's .opd entry.
2184 Thus, we can not use that dynamic symbol for the EPLT relocation
2185 (if we did, the data in the .opd would reference itself rather
2186 than the actual address of the function). Instead we have to use
2187 a new dynamic symbol which has the same value as the original global
2190 We prefix the original symbol with a "." and use the new symbol in
2191 the EPLT relocation. This new symbol has already been recorded in
2192 the symbol table, we just have to look it up and use it.
2194 We do not have such problems with static functions because we do
2195 not make their addresses in the dynamic symbol table point to
2196 the .opd entry. Ultimately this should be safe since a static
2197 function can not be directly referenced outside of its shared
2200 We do have to play similar games for FPTR relocations in shared
2201 libraries, including those for static symbols. See the FPTR
2202 handling in elf64_hppa_finalize_dynreloc. */
2206 struct elf_link_hash_entry *nh;
2208 new_name = alloca (strlen (eh->root.root.string) + 2);
2210 strcpy (new_name + 1, eh->root.root.string);
2212 nh = elf_link_hash_lookup (elf_hash_table (info),
2213 new_name, TRUE, TRUE, FALSE);
2215 /* All we really want from the new symbol is its dynamic
2218 dynindx = nh->dynindx;
2222 rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_EPLT);
2224 loc = sopdrel->contents;
2225 loc += sopdrel->reloc_count++ * sizeof (Elf64_External_Rela);
2226 bfd_elf64_swap_reloca_out (sopd->output_section->owner, &rel, loc);
2231 /* The .dlt section contains addresses for items referenced through the
2232 dlt. Note that we can have a DLTIND relocation for a local symbol, thus
2233 we can not depend on finish_dynamic_symbol to initialize the .dlt. */
2236 elf64_hppa_finalize_dlt (struct elf_link_hash_entry *eh, void *data)
2238 struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
2239 struct bfd_link_info *info = (struct bfd_link_info *)data;
2240 struct elf64_hppa_link_hash_table *hppa_info;
2241 asection *sdlt, *sdltrel;
2243 hppa_info = hppa_link_hash_table (info);
2244 if (hppa_info == NULL)
2247 sdlt = hppa_info->dlt_sec;
2248 sdltrel = hppa_info->dlt_rel_sec;
2250 /* H/DYN_H may refer to a local variable and we know it's
2251 address, so there is no need to create a relocation. Just install
2252 the proper value into the DLT, note this shortcut can not be
2253 skipped when building a shared library. */
2254 if (! info->shared && hh && hh->want_dlt)
2258 /* If we had an LTOFF_FPTR style relocation we want the DLT entry
2259 to point to the FPTR entry in the .opd section.
2261 We include the OPD's output offset in this computation as
2262 we are referring to an absolute address in the resulting
2266 value = (hh->opd_offset
2267 + hppa_info->opd_sec->output_offset
2268 + hppa_info->opd_sec->output_section->vma);
2270 else if ((eh->root.type == bfd_link_hash_defined
2271 || eh->root.type == bfd_link_hash_defweak)
2272 && eh->root.u.def.section)
2274 value = eh->root.u.def.value + eh->root.u.def.section->output_offset;
2275 if (eh->root.u.def.section->output_section)
2276 value += eh->root.u.def.section->output_section->vma;
2278 value += eh->root.u.def.section->vma;
2281 /* We have an undefined function reference. */
2284 /* We do not need to include the output offset of the DLT section
2285 here because we are modifying the in-memory contents. */
2286 bfd_put_64 (sdlt->owner, value, sdlt->contents + hh->dlt_offset);
2289 /* Create a relocation for the DLT entry associated with this symbol.
2290 When building a shared library the symbol does not have to be dynamic. */
2292 && (elf64_hppa_dynamic_symbol_p (eh, info) || info->shared))
2294 Elf_Internal_Rela rel;
2298 /* We may need to do a relocation against a local symbol, in
2299 which case we have to look up it's dynamic symbol index off
2300 the local symbol hash table. */
2301 if (eh && eh->dynindx != -1)
2302 dynindx = eh->dynindx;
2305 = _bfd_elf_link_lookup_local_dynindx (info, hh->owner,
2308 /* Create a dynamic relocation for this entry. Do include the output
2309 offset of the DLT entry since we need an absolute address in the
2310 resulting object file. */
2311 rel.r_offset = (hh->dlt_offset + sdlt->output_offset
2312 + sdlt->output_section->vma);
2313 if (eh && eh->type == STT_FUNC)
2314 rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_FPTR64);
2316 rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_DIR64);
2319 loc = sdltrel->contents;
2320 loc += sdltrel->reloc_count++ * sizeof (Elf64_External_Rela);
2321 bfd_elf64_swap_reloca_out (sdlt->output_section->owner, &rel, loc);
2326 /* Finalize the dynamic relocations. Specifically the FPTR relocations
2327 for dynamic functions used to initialize static data. */
2330 elf64_hppa_finalize_dynreloc (struct elf_link_hash_entry *eh,
2333 struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
2334 struct bfd_link_info *info = (struct bfd_link_info *)data;
2335 struct elf64_hppa_link_hash_table *hppa_info;
2338 dynamic_symbol = elf64_hppa_dynamic_symbol_p (eh, info);
2340 if (!dynamic_symbol && !info->shared)
2343 if (hh->reloc_entries)
2345 struct elf64_hppa_dyn_reloc_entry *rent;
2348 hppa_info = hppa_link_hash_table (info);
2349 if (hppa_info == NULL)
2352 /* We may need to do a relocation against a local symbol, in
2353 which case we have to look up it's dynamic symbol index off
2354 the local symbol hash table. */
2355 if (eh->dynindx != -1)
2356 dynindx = eh->dynindx;
2359 = _bfd_elf_link_lookup_local_dynindx (info, hh->owner,
2362 for (rent = hh->reloc_entries; rent; rent = rent->next)
2364 Elf_Internal_Rela rel;
2367 /* Allocate one iff we are building a shared library, the relocation
2368 isn't a R_PARISC_FPTR64, or we don't want an opd entry. */
2369 if (!info->shared && rent->type == R_PARISC_FPTR64 && hh->want_opd)
2372 /* Create a dynamic relocation for this entry.
2374 We need the output offset for the reloc's section because
2375 we are creating an absolute address in the resulting object
2377 rel.r_offset = (rent->offset + rent->sec->output_offset
2378 + rent->sec->output_section->vma);
2380 /* An FPTR64 relocation implies that we took the address of
2381 a function and that the function has an entry in the .opd
2382 section. We want the FPTR64 relocation to reference the
2385 We could munge the symbol value in the dynamic symbol table
2386 (in fact we already do for functions with global scope) to point
2387 to the .opd entry. Then we could use that dynamic symbol in
2390 Or we could do something sensible, not munge the symbol's
2391 address and instead just use a different symbol to reference
2392 the .opd entry. At least that seems sensible until you
2393 realize there's no local dynamic symbols we can use for that
2394 purpose. Thus the hair in the check_relocs routine.
2396 We use a section symbol recorded by check_relocs as the
2397 base symbol for the relocation. The addend is the difference
2398 between the section symbol and the address of the .opd entry. */
2399 if (info->shared && rent->type == R_PARISC_FPTR64 && hh->want_opd)
2401 bfd_vma value, value2;
2403 /* First compute the address of the opd entry for this symbol. */
2404 value = (hh->opd_offset
2405 + hppa_info->opd_sec->output_section->vma
2406 + hppa_info->opd_sec->output_offset);
2408 /* Compute the value of the start of the section with
2410 value2 = (rent->sec->output_section->vma
2411 + rent->sec->output_offset);
2413 /* Compute the difference between the start of the section
2414 with the relocation and the opd entry. */
2417 /* The result becomes the addend of the relocation. */
2418 rel.r_addend = value;
2420 /* The section symbol becomes the symbol for the dynamic
2423 = _bfd_elf_link_lookup_local_dynindx (info,
2428 rel.r_addend = rent->addend;
2430 rel.r_info = ELF64_R_INFO (dynindx, rent->type);
2432 loc = hppa_info->other_rel_sec->contents;
2433 loc += (hppa_info->other_rel_sec->reloc_count++
2434 * sizeof (Elf64_External_Rela));
2435 bfd_elf64_swap_reloca_out (hppa_info->other_rel_sec->output_section->owner,
2443 /* Used to decide how to sort relocs in an optimal manner for the
2444 dynamic linker, before writing them out. */
2446 static enum elf_reloc_type_class
2447 elf64_hppa_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
2448 const asection *rel_sec ATTRIBUTE_UNUSED,
2449 const Elf_Internal_Rela *rela)
2451 if (ELF64_R_SYM (rela->r_info) == STN_UNDEF)
2452 return reloc_class_relative;
2454 switch ((int) ELF64_R_TYPE (rela->r_info))
2457 return reloc_class_plt;
2459 return reloc_class_copy;
2461 return reloc_class_normal;
2465 /* Finish up the dynamic sections. */
2468 elf64_hppa_finish_dynamic_sections (bfd *output_bfd,
2469 struct bfd_link_info *info)
2473 struct elf64_hppa_link_hash_table *hppa_info;
2475 hppa_info = hppa_link_hash_table (info);
2476 if (hppa_info == NULL)
2479 /* Finalize the contents of the .opd section. */
2480 elf_link_hash_traverse (elf_hash_table (info),
2481 elf64_hppa_finalize_opd,
2484 elf_link_hash_traverse (elf_hash_table (info),
2485 elf64_hppa_finalize_dynreloc,
2488 /* Finalize the contents of the .dlt section. */
2489 dynobj = elf_hash_table (info)->dynobj;
2490 /* Finalize the contents of the .dlt section. */
2491 elf_link_hash_traverse (elf_hash_table (info),
2492 elf64_hppa_finalize_dlt,
2495 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
2497 if (elf_hash_table (info)->dynamic_sections_created)
2499 Elf64_External_Dyn *dyncon, *dynconend;
2501 BFD_ASSERT (sdyn != NULL);
2503 dyncon = (Elf64_External_Dyn *) sdyn->contents;
2504 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
2505 for (; dyncon < dynconend; dyncon++)
2507 Elf_Internal_Dyn dyn;
2510 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
2517 case DT_HP_LOAD_MAP:
2518 /* Compute the absolute address of 16byte scratchpad area
2519 for the dynamic linker.
2521 By convention the linker script will allocate the scratchpad
2522 area at the start of the .data section. So all we have to
2523 to is find the start of the .data section. */
2524 s = bfd_get_section_by_name (output_bfd, ".data");
2527 dyn.d_un.d_ptr = s->vma;
2528 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2532 /* HP's use PLTGOT to set the GOT register. */
2533 dyn.d_un.d_ptr = _bfd_get_gp_value (output_bfd);
2534 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2538 s = hppa_info->plt_rel_sec;
2539 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2540 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2544 s = hppa_info->plt_rel_sec;
2545 dyn.d_un.d_val = s->size;
2546 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2550 s = hppa_info->other_rel_sec;
2551 if (! s || ! s->size)
2552 s = hppa_info->dlt_rel_sec;
2553 if (! s || ! s->size)
2554 s = hppa_info->opd_rel_sec;
2555 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2556 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2560 s = hppa_info->other_rel_sec;
2561 dyn.d_un.d_val = s->size;
2562 s = hppa_info->dlt_rel_sec;
2563 dyn.d_un.d_val += s->size;
2564 s = hppa_info->opd_rel_sec;
2565 dyn.d_un.d_val += s->size;
2566 /* There is some question about whether or not the size of
2567 the PLT relocs should be included here. HP's tools do
2568 it, so we'll emulate them. */
2569 s = hppa_info->plt_rel_sec;
2570 dyn.d_un.d_val += s->size;
2571 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2581 /* Support for core dump NOTE sections. */
2584 elf64_hppa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2589 switch (note->descsz)
2594 case 760: /* Linux/hppa */
2596 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2599 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2608 /* Make a ".reg/999" section. */
2609 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2610 size, note->descpos + offset);
2614 elf64_hppa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2619 switch (note->descsz)
2624 case 136: /* Linux/hppa elf_prpsinfo. */
2625 elf_tdata (abfd)->core->program
2626 = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2627 elf_tdata (abfd)->core->command
2628 = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2631 /* Note that for some reason, a spurious space is tacked
2632 onto the end of the args in some (at least one anyway)
2633 implementations, so strip it off if it exists. */
2634 command = elf_tdata (abfd)->core->command;
2635 n = strlen (command);
2637 if (0 < n && command[n - 1] == ' ')
2638 command[n - 1] = '\0';
2643 /* Return the number of additional phdrs we will need.
2645 The generic ELF code only creates PT_PHDRs for executables. The HP
2646 dynamic linker requires PT_PHDRs for dynamic libraries too.
2648 This routine indicates that the backend needs one additional program
2649 header for that case.
2651 Note we do not have access to the link info structure here, so we have
2652 to guess whether or not we are building a shared library based on the
2653 existence of a .interp section. */
2656 elf64_hppa_additional_program_headers (bfd *abfd,
2657 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2661 /* If we are creating a shared library, then we have to create a
2662 PT_PHDR segment. HP's dynamic linker chokes without it. */
2663 s = bfd_get_section_by_name (abfd, ".interp");
2669 /* Allocate and initialize any program headers required by this
2672 The generic ELF code only creates PT_PHDRs for executables. The HP
2673 dynamic linker requires PT_PHDRs for dynamic libraries too.
2675 This allocates the PT_PHDR and initializes it in a manner suitable
2678 Note we do not have access to the link info structure here, so we have
2679 to guess whether or not we are building a shared library based on the
2680 existence of a .interp section. */
2683 elf64_hppa_modify_segment_map (bfd *abfd,
2684 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2686 struct elf_segment_map *m;
2689 s = bfd_get_section_by_name (abfd, ".interp");
2692 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
2693 if (m->p_type == PT_PHDR)
2697 m = ((struct elf_segment_map *)
2698 bfd_zalloc (abfd, (bfd_size_type) sizeof *m));
2702 m->p_type = PT_PHDR;
2703 m->p_flags = PF_R | PF_X;
2704 m->p_flags_valid = 1;
2705 m->p_paddr_valid = 1;
2706 m->includes_phdrs = 1;
2708 m->next = elf_seg_map (abfd);
2709 elf_seg_map (abfd) = m;
2713 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
2714 if (m->p_type == PT_LOAD)
2718 for (i = 0; i < m->count; i++)
2720 /* The code "hint" is not really a hint. It is a requirement
2721 for certain versions of the HP dynamic linker. Worse yet,
2722 it must be set even if the shared library does not have
2723 any code in its "text" segment (thus the check for .hash
2724 to catch this situation). */
2725 if (m->sections[i]->flags & SEC_CODE
2726 || (strcmp (m->sections[i]->name, ".hash") == 0))
2727 m->p_flags |= (PF_X | PF_HP_CODE);
2734 /* Called when writing out an object file to decide the type of a
2737 elf64_hppa_elf_get_symbol_type (Elf_Internal_Sym *elf_sym,
2740 if (ELF_ST_TYPE (elf_sym->st_info) == STT_PARISC_MILLI)
2741 return STT_PARISC_MILLI;
2746 /* Support HP specific sections for core files. */
2749 elf64_hppa_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int sec_index,
2750 const char *typename)
2752 if (hdr->p_type == PT_HP_CORE_KERNEL)
2756 if (!_bfd_elf_make_section_from_phdr (abfd, hdr, sec_index, typename))
2759 sect = bfd_make_section_anyway (abfd, ".kernel");
2762 sect->size = hdr->p_filesz;
2763 sect->filepos = hdr->p_offset;
2764 sect->flags = SEC_HAS_CONTENTS | SEC_READONLY;
2768 if (hdr->p_type == PT_HP_CORE_PROC)
2772 if (bfd_seek (abfd, hdr->p_offset, SEEK_SET) != 0)
2774 if (bfd_bread (&sig, 4, abfd) != 4)
2777 elf_tdata (abfd)->core->signal = sig;
2779 if (!_bfd_elf_make_section_from_phdr (abfd, hdr, sec_index, typename))
2782 /* GDB uses the ".reg" section to read register contents. */
2783 return _bfd_elfcore_make_pseudosection (abfd, ".reg", hdr->p_filesz,
2787 if (hdr->p_type == PT_HP_CORE_LOADABLE
2788 || hdr->p_type == PT_HP_CORE_STACK
2789 || hdr->p_type == PT_HP_CORE_MMF)
2790 hdr->p_type = PT_LOAD;
2792 return _bfd_elf_make_section_from_phdr (abfd, hdr, sec_index, typename);
2795 /* Hook called by the linker routine which adds symbols from an object
2796 file. HP's libraries define symbols with HP specific section
2797 indices, which we have to handle. */
2800 elf_hppa_add_symbol_hook (bfd *abfd,
2801 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2802 Elf_Internal_Sym *sym,
2803 const char **namep ATTRIBUTE_UNUSED,
2804 flagword *flagsp ATTRIBUTE_UNUSED,
2808 unsigned int sec_index = sym->st_shndx;
2812 case SHN_PARISC_ANSI_COMMON:
2813 *secp = bfd_make_section_old_way (abfd, ".PARISC.ansi.common");
2814 (*secp)->flags |= SEC_IS_COMMON;
2815 *valp = sym->st_size;
2818 case SHN_PARISC_HUGE_COMMON:
2819 *secp = bfd_make_section_old_way (abfd, ".PARISC.huge.common");
2820 (*secp)->flags |= SEC_IS_COMMON;
2821 *valp = sym->st_size;
2829 elf_hppa_unmark_useless_dynamic_symbols (struct elf_link_hash_entry *h,
2832 struct bfd_link_info *info = data;
2834 /* If we are not creating a shared library, and this symbol is
2835 referenced by a shared library but is not defined anywhere, then
2836 the generic code will warn that it is undefined.
2838 This behavior is undesirable on HPs since the standard shared
2839 libraries contain references to undefined symbols.
2841 So we twiddle the flags associated with such symbols so that they
2842 will not trigger the warning. ?!? FIXME. This is horribly fragile.
2844 Ultimately we should have better controls over the generic ELF BFD
2846 if (! info->relocatable
2847 && info->unresolved_syms_in_shared_libs != RM_IGNORE
2848 && h->root.type == bfd_link_hash_undefined
2853 h->pointer_equality_needed = 1;
2860 elf_hppa_remark_useless_dynamic_symbols (struct elf_link_hash_entry *h,
2863 struct bfd_link_info *info = data;
2865 /* If we are not creating a shared library, and this symbol is
2866 referenced by a shared library but is not defined anywhere, then
2867 the generic code will warn that it is undefined.
2869 This behavior is undesirable on HPs since the standard shared
2870 libraries contain references to undefined symbols.
2872 So we twiddle the flags associated with such symbols so that they
2873 will not trigger the warning. ?!? FIXME. This is horribly fragile.
2875 Ultimately we should have better controls over the generic ELF BFD
2877 if (! info->relocatable
2878 && info->unresolved_syms_in_shared_libs != RM_IGNORE
2879 && h->root.type == bfd_link_hash_undefined
2882 && h->pointer_equality_needed)
2885 h->pointer_equality_needed = 0;
2892 elf_hppa_is_dynamic_loader_symbol (const char *name)
2894 return (! strcmp (name, "__CPU_REVISION")
2895 || ! strcmp (name, "__CPU_KEYBITS_1")
2896 || ! strcmp (name, "__SYSTEM_ID_D")
2897 || ! strcmp (name, "__FPU_MODEL")
2898 || ! strcmp (name, "__FPU_REVISION")
2899 || ! strcmp (name, "__ARGC")
2900 || ! strcmp (name, "__ARGV")
2901 || ! strcmp (name, "__ENVP")
2902 || ! strcmp (name, "__TLS_SIZE_D")
2903 || ! strcmp (name, "__LOAD_INFO")
2904 || ! strcmp (name, "__systab"));
2907 /* Record the lowest address for the data and text segments. */
2909 elf_hppa_record_segment_addrs (bfd *abfd,
2913 struct elf64_hppa_link_hash_table *hppa_info = data;
2915 if ((section->flags & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2918 Elf_Internal_Phdr *p;
2920 p = _bfd_elf_find_segment_containing_section (abfd, section->output_section);
2921 BFD_ASSERT (p != NULL);
2924 if (section->flags & SEC_READONLY)
2926 if (value < hppa_info->text_segment_base)
2927 hppa_info->text_segment_base = value;
2931 if (value < hppa_info->data_segment_base)
2932 hppa_info->data_segment_base = value;
2937 /* Called after we have seen all the input files/sections, but before
2938 final symbol resolution and section placement has been determined.
2940 We use this hook to (possibly) provide a value for __gp, then we
2941 fall back to the generic ELF final link routine. */
2944 elf_hppa_final_link (bfd *abfd, struct bfd_link_info *info)
2947 struct elf64_hppa_link_hash_table *hppa_info = hppa_link_hash_table (info);
2949 if (hppa_info == NULL)
2952 if (! info->relocatable)
2954 struct elf_link_hash_entry *gp;
2957 /* The linker script defines a value for __gp iff it was referenced
2958 by one of the objects being linked. First try to find the symbol
2959 in the hash table. If that fails, just compute the value __gp
2961 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
2967 /* Adjust the value of __gp as we may want to slide it into the
2968 .plt section so that the stubs can access PLT entries without
2969 using an addil sequence. */
2970 gp->root.u.def.value += hppa_info->gp_offset;
2972 gp_val = (gp->root.u.def.section->output_section->vma
2973 + gp->root.u.def.section->output_offset
2974 + gp->root.u.def.value);
2980 /* First look for a .plt section. If found, then __gp is the
2981 address of the .plt + gp_offset.
2983 If no .plt is found, then look for .dlt, .opd and .data (in
2984 that order) and set __gp to the base address of whichever
2985 section is found first. */
2987 sec = hppa_info->plt_sec;
2988 if (sec && ! (sec->flags & SEC_EXCLUDE))
2989 gp_val = (sec->output_offset
2990 + sec->output_section->vma
2991 + hppa_info->gp_offset);
2994 sec = hppa_info->dlt_sec;
2995 if (!sec || (sec->flags & SEC_EXCLUDE))
2996 sec = hppa_info->opd_sec;
2997 if (!sec || (sec->flags & SEC_EXCLUDE))
2998 sec = bfd_get_section_by_name (abfd, ".data");
2999 if (!sec || (sec->flags & SEC_EXCLUDE))
3002 gp_val = sec->output_offset + sec->output_section->vma;
3006 /* Install whatever value we found/computed for __gp. */
3007 _bfd_set_gp_value (abfd, gp_val);
3010 /* We need to know the base of the text and data segments so that we
3011 can perform SEGREL relocations. We will record the base addresses
3012 when we encounter the first SEGREL relocation. */
3013 hppa_info->text_segment_base = (bfd_vma)-1;
3014 hppa_info->data_segment_base = (bfd_vma)-1;
3016 /* HP's shared libraries have references to symbols that are not
3017 defined anywhere. The generic ELF BFD linker code will complain
3020 So we detect the losing case and arrange for the flags on the symbol
3021 to indicate that it was never referenced. This keeps the generic
3022 ELF BFD link code happy and appears to not create any secondary
3023 problems. Ultimately we need a way to control the behavior of the
3024 generic ELF BFD link code better. */
3025 elf_link_hash_traverse (elf_hash_table (info),
3026 elf_hppa_unmark_useless_dynamic_symbols,
3029 /* Invoke the regular ELF backend linker to do all the work. */
3030 retval = bfd_elf_final_link (abfd, info);
3032 elf_link_hash_traverse (elf_hash_table (info),
3033 elf_hppa_remark_useless_dynamic_symbols,
3036 /* If we're producing a final executable, sort the contents of the
3038 if (retval && !info->relocatable)
3039 retval = elf_hppa_sort_unwind (abfd);
3044 /* Relocate the given INSN. VALUE should be the actual value we want
3045 to insert into the instruction, ie by this point we should not be
3046 concerned with computing an offset relative to the DLT, PC, etc.
3047 Instead this routine is meant to handle the bit manipulations needed
3048 to insert the relocation into the given instruction. */
3051 elf_hppa_relocate_insn (int insn, int sym_value, unsigned int r_type)
3055 /* This is any 22 bit branch. In PA2.0 syntax it corresponds to
3056 the "B" instruction. */
3057 case R_PARISC_PCREL22F:
3058 case R_PARISC_PCREL22C:
3059 return (insn & ~0x3ff1ffd) | re_assemble_22 (sym_value);
3061 /* This is any 12 bit branch. */
3062 case R_PARISC_PCREL12F:
3063 return (insn & ~0x1ffd) | re_assemble_12 (sym_value);
3065 /* This is any 17 bit branch. In PA2.0 syntax it also corresponds
3066 to the "B" instruction as well as BE. */
3067 case R_PARISC_PCREL17F:
3068 case R_PARISC_DIR17F:
3069 case R_PARISC_DIR17R:
3070 case R_PARISC_PCREL17C:
3071 case R_PARISC_PCREL17R:
3072 return (insn & ~0x1f1ffd) | re_assemble_17 (sym_value);
3074 /* ADDIL or LDIL instructions. */
3075 case R_PARISC_DLTREL21L:
3076 case R_PARISC_DLTIND21L:
3077 case R_PARISC_LTOFF_FPTR21L:
3078 case R_PARISC_PCREL21L:
3079 case R_PARISC_LTOFF_TP21L:
3080 case R_PARISC_DPREL21L:
3081 case R_PARISC_PLTOFF21L:
3082 case R_PARISC_DIR21L:
3083 return (insn & ~0x1fffff) | re_assemble_21 (sym_value);
3085 /* LDO and integer loads/stores with 14 bit displacements. */
3086 case R_PARISC_DLTREL14R:
3087 case R_PARISC_DLTREL14F:
3088 case R_PARISC_DLTIND14R:
3089 case R_PARISC_DLTIND14F:
3090 case R_PARISC_LTOFF_FPTR14R:
3091 case R_PARISC_PCREL14R:
3092 case R_PARISC_PCREL14F:
3093 case R_PARISC_LTOFF_TP14R:
3094 case R_PARISC_LTOFF_TP14F:
3095 case R_PARISC_DPREL14R:
3096 case R_PARISC_DPREL14F:
3097 case R_PARISC_PLTOFF14R:
3098 case R_PARISC_PLTOFF14F:
3099 case R_PARISC_DIR14R:
3100 case R_PARISC_DIR14F:
3101 return (insn & ~0x3fff) | low_sign_unext (sym_value, 14);
3103 /* PA2.0W LDO and integer loads/stores with 16 bit displacements. */
3104 case R_PARISC_LTOFF_FPTR16F:
3105 case R_PARISC_PCREL16F:
3106 case R_PARISC_LTOFF_TP16F:
3107 case R_PARISC_GPREL16F:
3108 case R_PARISC_PLTOFF16F:
3109 case R_PARISC_DIR16F:
3110 case R_PARISC_LTOFF16F:
3111 return (insn & ~0xffff) | re_assemble_16 (sym_value);
3113 /* Doubleword loads and stores with a 14 bit displacement. */
3114 case R_PARISC_DLTREL14DR:
3115 case R_PARISC_DLTIND14DR:
3116 case R_PARISC_LTOFF_FPTR14DR:
3117 case R_PARISC_LTOFF_FPTR16DF:
3118 case R_PARISC_PCREL14DR:
3119 case R_PARISC_PCREL16DF:
3120 case R_PARISC_LTOFF_TP14DR:
3121 case R_PARISC_LTOFF_TP16DF:
3122 case R_PARISC_DPREL14DR:
3123 case R_PARISC_GPREL16DF:
3124 case R_PARISC_PLTOFF14DR:
3125 case R_PARISC_PLTOFF16DF:
3126 case R_PARISC_DIR14DR:
3127 case R_PARISC_DIR16DF:
3128 case R_PARISC_LTOFF16DF:
3129 return (insn & ~0x3ff1) | (((sym_value & 0x2000) >> 13)
3130 | ((sym_value & 0x1ff8) << 1));
3132 /* Floating point single word load/store instructions. */
3133 case R_PARISC_DLTREL14WR:
3134 case R_PARISC_DLTIND14WR:
3135 case R_PARISC_LTOFF_FPTR14WR:
3136 case R_PARISC_LTOFF_FPTR16WF:
3137 case R_PARISC_PCREL14WR:
3138 case R_PARISC_PCREL16WF:
3139 case R_PARISC_LTOFF_TP14WR:
3140 case R_PARISC_LTOFF_TP16WF:
3141 case R_PARISC_DPREL14WR:
3142 case R_PARISC_GPREL16WF:
3143 case R_PARISC_PLTOFF14WR:
3144 case R_PARISC_PLTOFF16WF:
3145 case R_PARISC_DIR16WF:
3146 case R_PARISC_DIR14WR:
3147 case R_PARISC_LTOFF16WF:
3148 return (insn & ~0x3ff9) | (((sym_value & 0x2000) >> 13)
3149 | ((sym_value & 0x1ffc) << 1));
3156 /* Compute the value for a relocation (REL) during a final link stage,
3157 then insert the value into the proper location in CONTENTS.
3159 VALUE is a tentative value for the relocation and may be overridden
3160 and modified here based on the specific relocation to be performed.
3162 For example we do conversions for PC-relative branches in this routine
3163 or redirection of calls to external routines to stubs.
3165 The work of actually applying the relocation is left to a helper
3166 routine in an attempt to reduce the complexity and size of this
3169 static bfd_reloc_status_type
3170 elf_hppa_final_link_relocate (Elf_Internal_Rela *rel,
3173 asection *input_section,
3176 struct bfd_link_info *info,
3178 struct elf_link_hash_entry *eh)
3180 struct elf64_hppa_link_hash_table *hppa_info = hppa_link_hash_table (info);
3181 struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
3182 bfd_vma *local_offsets;
3183 Elf_Internal_Shdr *symtab_hdr;
3185 bfd_vma max_branch_offset = 0;
3186 bfd_vma offset = rel->r_offset;
3187 bfd_signed_vma addend = rel->r_addend;
3188 reloc_howto_type *howto = elf_hppa_howto_table + ELF_R_TYPE (rel->r_info);
3189 unsigned int r_symndx = ELF_R_SYM (rel->r_info);
3190 unsigned int r_type = howto->type;
3191 bfd_byte *hit_data = contents + offset;
3193 if (hppa_info == NULL)
3194 return bfd_reloc_notsupported;
3196 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3197 local_offsets = elf_local_got_offsets (input_bfd);
3198 insn = bfd_get_32 (input_bfd, hit_data);
3205 /* Basic function call support.
3207 Note for a call to a function defined in another dynamic library
3208 we want to redirect the call to a stub. */
3210 /* PC relative relocs without an implicit offset. */
3211 case R_PARISC_PCREL21L:
3212 case R_PARISC_PCREL14R:
3213 case R_PARISC_PCREL14F:
3214 case R_PARISC_PCREL14WR:
3215 case R_PARISC_PCREL14DR:
3216 case R_PARISC_PCREL16F:
3217 case R_PARISC_PCREL16WF:
3218 case R_PARISC_PCREL16DF:
3220 /* If this is a call to a function defined in another dynamic
3221 library, then redirect the call to the local stub for this
3223 if (sym_sec == NULL || sym_sec->output_section == NULL)
3224 value = (hh->stub_offset + hppa_info->stub_sec->output_offset
3225 + hppa_info->stub_sec->output_section->vma);
3227 /* Turn VALUE into a proper PC relative address. */
3228 value -= (offset + input_section->output_offset
3229 + input_section->output_section->vma);
3231 /* Adjust for any field selectors. */
3232 if (r_type == R_PARISC_PCREL21L)
3233 value = hppa_field_adjust (value, -8 + addend, e_lsel);
3234 else if (r_type == R_PARISC_PCREL14F
3235 || r_type == R_PARISC_PCREL16F
3236 || r_type == R_PARISC_PCREL16WF
3237 || r_type == R_PARISC_PCREL16DF)
3238 value = hppa_field_adjust (value, -8 + addend, e_fsel);
3240 value = hppa_field_adjust (value, -8 + addend, e_rsel);
3242 /* Apply the relocation to the given instruction. */
3243 insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
3247 case R_PARISC_PCREL12F:
3248 case R_PARISC_PCREL22F:
3249 case R_PARISC_PCREL17F:
3250 case R_PARISC_PCREL22C:
3251 case R_PARISC_PCREL17C:
3252 case R_PARISC_PCREL17R:
3254 /* If this is a call to a function defined in another dynamic
3255 library, then redirect the call to the local stub for this
3257 if (sym_sec == NULL || sym_sec->output_section == NULL)
3258 value = (hh->stub_offset + hppa_info->stub_sec->output_offset
3259 + hppa_info->stub_sec->output_section->vma);
3261 /* Turn VALUE into a proper PC relative address. */
3262 value -= (offset + input_section->output_offset
3263 + input_section->output_section->vma);
3266 if (r_type == (unsigned int) R_PARISC_PCREL22F)
3267 max_branch_offset = (1 << (22-1)) << 2;
3268 else if (r_type == (unsigned int) R_PARISC_PCREL17F)
3269 max_branch_offset = (1 << (17-1)) << 2;
3270 else if (r_type == (unsigned int) R_PARISC_PCREL12F)
3271 max_branch_offset = (1 << (12-1)) << 2;
3273 /* Make sure we can reach the branch target. */
3274 if (max_branch_offset != 0
3275 && value + addend + max_branch_offset >= 2*max_branch_offset)
3277 (*_bfd_error_handler)
3278 (_("%B(%A+0x%" BFD_VMA_FMT "x): cannot reach %s"),
3282 eh ? eh->root.root.string : "unknown");
3283 bfd_set_error (bfd_error_bad_value);
3284 return bfd_reloc_overflow;
3287 /* Adjust for any field selectors. */
3288 if (r_type == R_PARISC_PCREL17R)
3289 value = hppa_field_adjust (value, addend, e_rsel);
3291 value = hppa_field_adjust (value, addend, e_fsel);
3293 /* All branches are implicitly shifted by 2 places. */
3296 /* Apply the relocation to the given instruction. */
3297 insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
3301 /* Indirect references to data through the DLT. */
3302 case R_PARISC_DLTIND14R:
3303 case R_PARISC_DLTIND14F:
3304 case R_PARISC_DLTIND14DR:
3305 case R_PARISC_DLTIND14WR:
3306 case R_PARISC_DLTIND21L:
3307 case R_PARISC_LTOFF_FPTR14R:
3308 case R_PARISC_LTOFF_FPTR14DR:
3309 case R_PARISC_LTOFF_FPTR14WR:
3310 case R_PARISC_LTOFF_FPTR21L:
3311 case R_PARISC_LTOFF_FPTR16F:
3312 case R_PARISC_LTOFF_FPTR16WF:
3313 case R_PARISC_LTOFF_FPTR16DF:
3314 case R_PARISC_LTOFF_TP21L:
3315 case R_PARISC_LTOFF_TP14R:
3316 case R_PARISC_LTOFF_TP14F:
3317 case R_PARISC_LTOFF_TP14WR:
3318 case R_PARISC_LTOFF_TP14DR:
3319 case R_PARISC_LTOFF_TP16F:
3320 case R_PARISC_LTOFF_TP16WF:
3321 case R_PARISC_LTOFF_TP16DF:
3322 case R_PARISC_LTOFF16F:
3323 case R_PARISC_LTOFF16WF:
3324 case R_PARISC_LTOFF16DF:
3328 /* If this relocation was against a local symbol, then we still
3329 have not set up the DLT entry (it's not convenient to do so
3330 in the "finalize_dlt" routine because it is difficult to get
3331 to the local symbol's value).
3333 So, if this is a local symbol (h == NULL), then we need to
3334 fill in its DLT entry.
3336 Similarly we may still need to set up an entry in .opd for
3337 a local function which had its address taken. */
3340 bfd_vma *local_opd_offsets, *local_dlt_offsets;
3342 if (local_offsets == NULL)
3345 /* Now do .opd creation if needed. */
3346 if (r_type == R_PARISC_LTOFF_FPTR14R
3347 || r_type == R_PARISC_LTOFF_FPTR14DR
3348 || r_type == R_PARISC_LTOFF_FPTR14WR
3349 || r_type == R_PARISC_LTOFF_FPTR21L
3350 || r_type == R_PARISC_LTOFF_FPTR16F
3351 || r_type == R_PARISC_LTOFF_FPTR16WF
3352 || r_type == R_PARISC_LTOFF_FPTR16DF)
3354 local_opd_offsets = local_offsets + 2 * symtab_hdr->sh_info;
3355 off = local_opd_offsets[r_symndx];
3357 /* The last bit records whether we've already initialised
3358 this local .opd entry. */
3361 BFD_ASSERT (off != (bfd_vma) -1);
3366 local_opd_offsets[r_symndx] |= 1;
3368 /* The first two words of an .opd entry are zero. */
3369 memset (hppa_info->opd_sec->contents + off, 0, 16);
3371 /* The next word is the address of the function. */
3372 bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
3373 (hppa_info->opd_sec->contents + off + 16));
3375 /* The last word is our local __gp value. */
3376 value = _bfd_get_gp_value
3377 (hppa_info->opd_sec->output_section->owner);
3378 bfd_put_64 (hppa_info->opd_sec->owner, value,
3379 (hppa_info->opd_sec->contents + off + 24));
3382 /* The DLT value is the address of the .opd entry. */
3384 + hppa_info->opd_sec->output_offset
3385 + hppa_info->opd_sec->output_section->vma);
3389 local_dlt_offsets = local_offsets;
3390 off = local_dlt_offsets[r_symndx];
3394 BFD_ASSERT (off != (bfd_vma) -1);
3399 local_dlt_offsets[r_symndx] |= 1;
3400 bfd_put_64 (hppa_info->dlt_sec->owner,
3402 hppa_info->dlt_sec->contents + off);
3406 off = hh->dlt_offset;
3408 /* We want the value of the DLT offset for this symbol, not
3409 the symbol's actual address. Note that __gp may not point
3410 to the start of the DLT, so we have to compute the absolute
3411 address, then subtract out the value of __gp. */
3413 + hppa_info->dlt_sec->output_offset
3414 + hppa_info->dlt_sec->output_section->vma);
3415 value -= _bfd_get_gp_value (output_bfd);
3417 /* All DLTIND relocations are basically the same at this point,
3418 except that we need different field selectors for the 21bit
3419 version vs the 14bit versions. */
3420 if (r_type == R_PARISC_DLTIND21L
3421 || r_type == R_PARISC_LTOFF_FPTR21L
3422 || r_type == R_PARISC_LTOFF_TP21L)
3423 value = hppa_field_adjust (value, 0, e_lsel);
3424 else if (r_type == R_PARISC_DLTIND14F
3425 || r_type == R_PARISC_LTOFF_FPTR16F
3426 || r_type == R_PARISC_LTOFF_FPTR16WF
3427 || r_type == R_PARISC_LTOFF_FPTR16DF
3428 || r_type == R_PARISC_LTOFF16F
3429 || r_type == R_PARISC_LTOFF16DF
3430 || r_type == R_PARISC_LTOFF16WF
3431 || r_type == R_PARISC_LTOFF_TP16F
3432 || r_type == R_PARISC_LTOFF_TP16WF
3433 || r_type == R_PARISC_LTOFF_TP16DF)
3434 value = hppa_field_adjust (value, 0, e_fsel);
3436 value = hppa_field_adjust (value, 0, e_rsel);
3438 insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
3442 case R_PARISC_DLTREL14R:
3443 case R_PARISC_DLTREL14F:
3444 case R_PARISC_DLTREL14DR:
3445 case R_PARISC_DLTREL14WR:
3446 case R_PARISC_DLTREL21L:
3447 case R_PARISC_DPREL21L:
3448 case R_PARISC_DPREL14WR:
3449 case R_PARISC_DPREL14DR:
3450 case R_PARISC_DPREL14R:
3451 case R_PARISC_DPREL14F:
3452 case R_PARISC_GPREL16F:
3453 case R_PARISC_GPREL16WF:
3454 case R_PARISC_GPREL16DF:
3456 /* Subtract out the global pointer value to make value a DLT
3457 relative address. */
3458 value -= _bfd_get_gp_value (output_bfd);
3460 /* All DLTREL relocations are basically the same at this point,
3461 except that we need different field selectors for the 21bit
3462 version vs the 14bit versions. */
3463 if (r_type == R_PARISC_DLTREL21L
3464 || r_type == R_PARISC_DPREL21L)
3465 value = hppa_field_adjust (value, addend, e_lrsel);
3466 else if (r_type == R_PARISC_DLTREL14F
3467 || r_type == R_PARISC_DPREL14F
3468 || r_type == R_PARISC_GPREL16F
3469 || r_type == R_PARISC_GPREL16WF
3470 || r_type == R_PARISC_GPREL16DF)
3471 value = hppa_field_adjust (value, addend, e_fsel);
3473 value = hppa_field_adjust (value, addend, e_rrsel);
3475 insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
3479 case R_PARISC_DIR21L:
3480 case R_PARISC_DIR17R:
3481 case R_PARISC_DIR17F:
3482 case R_PARISC_DIR14R:
3483 case R_PARISC_DIR14F:
3484 case R_PARISC_DIR14WR:
3485 case R_PARISC_DIR14DR:
3486 case R_PARISC_DIR16F:
3487 case R_PARISC_DIR16WF:
3488 case R_PARISC_DIR16DF:
3490 /* All DIR relocations are basically the same at this point,
3491 except that branch offsets need to be divided by four, and
3492 we need different field selectors. Note that we don't
3493 redirect absolute calls to local stubs. */
3495 if (r_type == R_PARISC_DIR21L)
3496 value = hppa_field_adjust (value, addend, e_lrsel);
3497 else if (r_type == R_PARISC_DIR17F
3498 || r_type == R_PARISC_DIR16F
3499 || r_type == R_PARISC_DIR16WF
3500 || r_type == R_PARISC_DIR16DF
3501 || r_type == R_PARISC_DIR14F)
3502 value = hppa_field_adjust (value, addend, e_fsel);
3504 value = hppa_field_adjust (value, addend, e_rrsel);
3506 if (r_type == R_PARISC_DIR17R || r_type == R_PARISC_DIR17F)
3507 /* All branches are implicitly shifted by 2 places. */
3510 insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
3514 case R_PARISC_PLTOFF21L:
3515 case R_PARISC_PLTOFF14R:
3516 case R_PARISC_PLTOFF14F:
3517 case R_PARISC_PLTOFF14WR:
3518 case R_PARISC_PLTOFF14DR:
3519 case R_PARISC_PLTOFF16F:
3520 case R_PARISC_PLTOFF16WF:
3521 case R_PARISC_PLTOFF16DF:
3523 /* We want the value of the PLT offset for this symbol, not
3524 the symbol's actual address. Note that __gp may not point
3525 to the start of the DLT, so we have to compute the absolute
3526 address, then subtract out the value of __gp. */
3527 value = (hh->plt_offset
3528 + hppa_info->plt_sec->output_offset
3529 + hppa_info->plt_sec->output_section->vma);
3530 value -= _bfd_get_gp_value (output_bfd);
3532 /* All PLTOFF relocations are basically the same at this point,
3533 except that we need different field selectors for the 21bit
3534 version vs the 14bit versions. */
3535 if (r_type == R_PARISC_PLTOFF21L)
3536 value = hppa_field_adjust (value, addend, e_lrsel);
3537 else if (r_type == R_PARISC_PLTOFF14F
3538 || r_type == R_PARISC_PLTOFF16F
3539 || r_type == R_PARISC_PLTOFF16WF
3540 || r_type == R_PARISC_PLTOFF16DF)
3541 value = hppa_field_adjust (value, addend, e_fsel);
3543 value = hppa_field_adjust (value, addend, e_rrsel);
3545 insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
3549 case R_PARISC_LTOFF_FPTR32:
3551 /* We may still need to create the FPTR itself if it was for
3555 /* The first two words of an .opd entry are zero. */
3556 memset (hppa_info->opd_sec->contents + hh->opd_offset, 0, 16);
3558 /* The next word is the address of the function. */
3559 bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
3560 (hppa_info->opd_sec->contents
3561 + hh->opd_offset + 16));
3563 /* The last word is our local __gp value. */
3564 value = _bfd_get_gp_value
3565 (hppa_info->opd_sec->output_section->owner);
3566 bfd_put_64 (hppa_info->opd_sec->owner, value,
3567 hppa_info->opd_sec->contents + hh->opd_offset + 24);
3569 /* The DLT value is the address of the .opd entry. */
3570 value = (hh->opd_offset
3571 + hppa_info->opd_sec->output_offset
3572 + hppa_info->opd_sec->output_section->vma);
3574 bfd_put_64 (hppa_info->dlt_sec->owner,
3576 hppa_info->dlt_sec->contents + hh->dlt_offset);
3579 /* We want the value of the DLT offset for this symbol, not
3580 the symbol's actual address. Note that __gp may not point
3581 to the start of the DLT, so we have to compute the absolute
3582 address, then subtract out the value of __gp. */
3583 value = (hh->dlt_offset
3584 + hppa_info->dlt_sec->output_offset
3585 + hppa_info->dlt_sec->output_section->vma);
3586 value -= _bfd_get_gp_value (output_bfd);
3587 bfd_put_32 (input_bfd, value, hit_data);
3588 return bfd_reloc_ok;
3591 case R_PARISC_LTOFF_FPTR64:
3592 case R_PARISC_LTOFF_TP64:
3594 /* We may still need to create the FPTR itself if it was for
3596 if (eh == NULL && r_type == R_PARISC_LTOFF_FPTR64)
3598 /* The first two words of an .opd entry are zero. */
3599 memset (hppa_info->opd_sec->contents + hh->opd_offset, 0, 16);
3601 /* The next word is the address of the function. */
3602 bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
3603 (hppa_info->opd_sec->contents
3604 + hh->opd_offset + 16));
3606 /* The last word is our local __gp value. */
3607 value = _bfd_get_gp_value
3608 (hppa_info->opd_sec->output_section->owner);
3609 bfd_put_64 (hppa_info->opd_sec->owner, value,
3610 hppa_info->opd_sec->contents + hh->opd_offset + 24);
3612 /* The DLT value is the address of the .opd entry. */
3613 value = (hh->opd_offset
3614 + hppa_info->opd_sec->output_offset
3615 + hppa_info->opd_sec->output_section->vma);
3617 bfd_put_64 (hppa_info->dlt_sec->owner,
3619 hppa_info->dlt_sec->contents + hh->dlt_offset);
3622 /* We want the value of the DLT offset for this symbol, not
3623 the symbol's actual address. Note that __gp may not point
3624 to the start of the DLT, so we have to compute the absolute
3625 address, then subtract out the value of __gp. */
3626 value = (hh->dlt_offset
3627 + hppa_info->dlt_sec->output_offset
3628 + hppa_info->dlt_sec->output_section->vma);
3629 value -= _bfd_get_gp_value (output_bfd);
3630 bfd_put_64 (input_bfd, value, hit_data);
3631 return bfd_reloc_ok;
3634 case R_PARISC_DIR32:
3635 bfd_put_32 (input_bfd, value + addend, hit_data);
3636 return bfd_reloc_ok;
3638 case R_PARISC_DIR64:
3639 bfd_put_64 (input_bfd, value + addend, hit_data);
3640 return bfd_reloc_ok;
3642 case R_PARISC_GPREL64:
3643 /* Subtract out the global pointer value to make value a DLT
3644 relative address. */
3645 value -= _bfd_get_gp_value (output_bfd);
3647 bfd_put_64 (input_bfd, value + addend, hit_data);
3648 return bfd_reloc_ok;
3650 case R_PARISC_LTOFF64:
3651 /* We want the value of the DLT offset for this symbol, not
3652 the symbol's actual address. Note that __gp may not point
3653 to the start of the DLT, so we have to compute the absolute
3654 address, then subtract out the value of __gp. */
3655 value = (hh->dlt_offset
3656 + hppa_info->dlt_sec->output_offset
3657 + hppa_info->dlt_sec->output_section->vma);
3658 value -= _bfd_get_gp_value (output_bfd);
3660 bfd_put_64 (input_bfd, value + addend, hit_data);
3661 return bfd_reloc_ok;
3663 case R_PARISC_PCREL32:
3665 /* If this is a call to a function defined in another dynamic
3666 library, then redirect the call to the local stub for this
3668 if (sym_sec == NULL || sym_sec->output_section == NULL)
3669 value = (hh->stub_offset + hppa_info->stub_sec->output_offset
3670 + hppa_info->stub_sec->output_section->vma);
3672 /* Turn VALUE into a proper PC relative address. */
3673 value -= (offset + input_section->output_offset
3674 + input_section->output_section->vma);
3678 bfd_put_32 (input_bfd, value, hit_data);
3679 return bfd_reloc_ok;
3682 case R_PARISC_PCREL64:
3684 /* If this is a call to a function defined in another dynamic
3685 library, then redirect the call to the local stub for this
3687 if (sym_sec == NULL || sym_sec->output_section == NULL)
3688 value = (hh->stub_offset + hppa_info->stub_sec->output_offset
3689 + hppa_info->stub_sec->output_section->vma);
3691 /* Turn VALUE into a proper PC relative address. */
3692 value -= (offset + input_section->output_offset
3693 + input_section->output_section->vma);
3697 bfd_put_64 (input_bfd, value, hit_data);
3698 return bfd_reloc_ok;
3701 case R_PARISC_FPTR64:
3705 /* We may still need to create the FPTR itself if it was for
3709 bfd_vma *local_opd_offsets;
3711 if (local_offsets == NULL)
3714 local_opd_offsets = local_offsets + 2 * symtab_hdr->sh_info;
3715 off = local_opd_offsets[r_symndx];
3717 /* The last bit records whether we've already initialised
3718 this local .opd entry. */
3721 BFD_ASSERT (off != (bfd_vma) -1);
3726 /* The first two words of an .opd entry are zero. */
3727 memset (hppa_info->opd_sec->contents + off, 0, 16);
3729 /* The next word is the address of the function. */
3730 bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
3731 (hppa_info->opd_sec->contents + off + 16));
3733 /* The last word is our local __gp value. */
3734 value = _bfd_get_gp_value
3735 (hppa_info->opd_sec->output_section->owner);
3736 bfd_put_64 (hppa_info->opd_sec->owner, value,
3737 hppa_info->opd_sec->contents + off + 24);
3741 off = hh->opd_offset;
3743 if (hh == NULL || hh->want_opd)
3744 /* We want the value of the OPD offset for this symbol. */
3746 + hppa_info->opd_sec->output_offset
3747 + hppa_info->opd_sec->output_section->vma);
3749 /* We want the address of the symbol. */
3752 bfd_put_64 (input_bfd, value, hit_data);
3753 return bfd_reloc_ok;
3756 case R_PARISC_SECREL32:
3758 value -= sym_sec->output_section->vma;
3759 bfd_put_32 (input_bfd, value + addend, hit_data);
3760 return bfd_reloc_ok;
3762 case R_PARISC_SEGREL32:
3763 case R_PARISC_SEGREL64:
3765 /* If this is the first SEGREL relocation, then initialize
3766 the segment base values. */
3767 if (hppa_info->text_segment_base == (bfd_vma) -1)
3768 bfd_map_over_sections (output_bfd, elf_hppa_record_segment_addrs,
3771 /* VALUE holds the absolute address. We want to include the
3772 addend, then turn it into a segment relative address.
3774 The segment is derived from SYM_SEC. We assume that there are
3775 only two segments of note in the resulting executable/shlib.
3776 A readonly segment (.text) and a readwrite segment (.data). */
3779 if (sym_sec->flags & SEC_CODE)
3780 value -= hppa_info->text_segment_base;
3782 value -= hppa_info->data_segment_base;
3784 if (r_type == R_PARISC_SEGREL32)
3785 bfd_put_32 (input_bfd, value, hit_data);
3787 bfd_put_64 (input_bfd, value, hit_data);
3788 return bfd_reloc_ok;
3791 /* Something we don't know how to handle. */
3793 return bfd_reloc_notsupported;
3796 /* Update the instruction word. */
3797 bfd_put_32 (input_bfd, (bfd_vma) insn, hit_data);
3798 return bfd_reloc_ok;
3801 /* Relocate an HPPA ELF section. */
3804 elf64_hppa_relocate_section (bfd *output_bfd,
3805 struct bfd_link_info *info,
3807 asection *input_section,
3809 Elf_Internal_Rela *relocs,
3810 Elf_Internal_Sym *local_syms,
3811 asection **local_sections)
3813 Elf_Internal_Shdr *symtab_hdr;
3814 Elf_Internal_Rela *rel;
3815 Elf_Internal_Rela *relend;
3816 struct elf64_hppa_link_hash_table *hppa_info;
3818 hppa_info = hppa_link_hash_table (info);
3819 if (hppa_info == NULL)
3822 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3825 relend = relocs + input_section->reloc_count;
3826 for (; rel < relend; rel++)
3829 reloc_howto_type *howto = elf_hppa_howto_table + ELF_R_TYPE (rel->r_info);
3830 unsigned long r_symndx;
3831 struct elf_link_hash_entry *eh;
3832 Elf_Internal_Sym *sym;
3835 bfd_reloc_status_type r;
3837 r_type = ELF_R_TYPE (rel->r_info);
3838 if (r_type < 0 || r_type >= (int) R_PARISC_UNIMPLEMENTED)
3840 bfd_set_error (bfd_error_bad_value);
3843 if (r_type == (unsigned int) R_PARISC_GNU_VTENTRY
3844 || r_type == (unsigned int) R_PARISC_GNU_VTINHERIT)
3847 /* This is a final link. */
3848 r_symndx = ELF_R_SYM (rel->r_info);
3852 if (r_symndx < symtab_hdr->sh_info)
3854 /* This is a local symbol, hh defaults to NULL. */
3855 sym = local_syms + r_symndx;
3856 sym_sec = local_sections[r_symndx];
3857 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sym_sec, rel);
3861 /* This is not a local symbol. */
3862 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
3864 /* It seems this can happen with erroneous or unsupported
3865 input (mixing a.out and elf in an archive, for example.) */
3866 if (sym_hashes == NULL)
3869 eh = sym_hashes[r_symndx - symtab_hdr->sh_info];
3871 while (eh->root.type == bfd_link_hash_indirect
3872 || eh->root.type == bfd_link_hash_warning)
3873 eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
3876 if (eh->root.type == bfd_link_hash_defined
3877 || eh->root.type == bfd_link_hash_defweak)
3879 sym_sec = eh->root.u.def.section;
3881 && sym_sec->output_section != NULL)
3882 relocation = (eh->root.u.def.value
3883 + sym_sec->output_section->vma
3884 + sym_sec->output_offset);
3886 else if (eh->root.type == bfd_link_hash_undefweak)
3888 else if (info->unresolved_syms_in_objects == RM_IGNORE
3889 && ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT)
3891 else if (!info->relocatable
3892 && elf_hppa_is_dynamic_loader_symbol (eh->root.root.string))
3894 else if (!info->relocatable)
3897 err = (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
3898 || ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT);
3899 if (!info->callbacks->undefined_symbol (info,
3900 eh->root.root.string,
3903 rel->r_offset, err))
3907 if (!info->relocatable
3909 && eh->root.type != bfd_link_hash_defined
3910 && eh->root.type != bfd_link_hash_defweak
3911 && eh->root.type != bfd_link_hash_undefweak)
3913 if (info->unresolved_syms_in_objects == RM_IGNORE
3914 && ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT
3915 && eh->type == STT_PARISC_MILLI)
3917 if (! info->callbacks->undefined_symbol
3918 (info, eh_name (eh), input_bfd,
3919 input_section, rel->r_offset, FALSE))
3925 if (sym_sec != NULL && discarded_section (sym_sec))
3926 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3927 rel, 1, relend, howto, 0, contents);
3929 if (info->relocatable)
3932 r = elf_hppa_final_link_relocate (rel, input_bfd, output_bfd,
3933 input_section, contents,
3934 relocation, info, sym_sec,
3937 if (r != bfd_reloc_ok)
3943 case bfd_reloc_overflow:
3945 const char *sym_name;
3951 sym_name = bfd_elf_string_from_elf_section (input_bfd,
3952 symtab_hdr->sh_link,
3954 if (sym_name == NULL)
3956 if (*sym_name == '\0')
3957 sym_name = bfd_section_name (input_bfd, sym_sec);
3960 if (!((*info->callbacks->reloc_overflow)
3961 (info, (eh ? &eh->root : NULL), sym_name,
3962 howto->name, (bfd_vma) 0, input_bfd,
3963 input_section, rel->r_offset)))
3973 static const struct bfd_elf_special_section elf64_hppa_special_sections[] =
3975 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3976 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3977 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },
3978 { STRING_COMMA_LEN (".dlt"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },
3979 { STRING_COMMA_LEN (".sdata"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },
3980 { STRING_COMMA_LEN (".sbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },
3981 { STRING_COMMA_LEN (".tbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_HP_TLS },
3982 { NULL, 0, 0, 0, 0 }
3985 /* The hash bucket size is the standard one, namely 4. */
3987 const struct elf_size_info hppa64_elf_size_info =
3989 sizeof (Elf64_External_Ehdr),
3990 sizeof (Elf64_External_Phdr),
3991 sizeof (Elf64_External_Shdr),
3992 sizeof (Elf64_External_Rel),
3993 sizeof (Elf64_External_Rela),
3994 sizeof (Elf64_External_Sym),
3995 sizeof (Elf64_External_Dyn),
3996 sizeof (Elf_External_Note),
4000 ELFCLASS64, EV_CURRENT,
4001 bfd_elf64_write_out_phdrs,
4002 bfd_elf64_write_shdrs_and_ehdr,
4003 bfd_elf64_checksum_contents,
4004 bfd_elf64_write_relocs,
4005 bfd_elf64_swap_symbol_in,
4006 bfd_elf64_swap_symbol_out,
4007 bfd_elf64_slurp_reloc_table,
4008 bfd_elf64_slurp_symbol_table,
4009 bfd_elf64_swap_dyn_in,
4010 bfd_elf64_swap_dyn_out,
4011 bfd_elf64_swap_reloc_in,
4012 bfd_elf64_swap_reloc_out,
4013 bfd_elf64_swap_reloca_in,
4014 bfd_elf64_swap_reloca_out
4017 #define TARGET_BIG_SYM bfd_elf64_hppa_vec
4018 #define TARGET_BIG_NAME "elf64-hppa"
4019 #define ELF_ARCH bfd_arch_hppa
4020 #define ELF_TARGET_ID HPPA64_ELF_DATA
4021 #define ELF_MACHINE_CODE EM_PARISC
4022 /* This is not strictly correct. The maximum page size for PA2.0 is
4023 64M. But everything still uses 4k. */
4024 #define ELF_MAXPAGESIZE 0x1000
4025 #define ELF_OSABI ELFOSABI_HPUX
4027 #define bfd_elf64_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
4028 #define bfd_elf64_bfd_reloc_name_lookup elf_hppa_reloc_name_lookup
4029 #define bfd_elf64_bfd_is_local_label_name elf_hppa_is_local_label_name
4030 #define elf_info_to_howto elf_hppa_info_to_howto
4031 #define elf_info_to_howto_rel elf_hppa_info_to_howto_rel
4033 #define elf_backend_section_from_shdr elf64_hppa_section_from_shdr
4034 #define elf_backend_object_p elf64_hppa_object_p
4035 #define elf_backend_final_write_processing \
4036 elf_hppa_final_write_processing
4037 #define elf_backend_fake_sections elf_hppa_fake_sections
4038 #define elf_backend_add_symbol_hook elf_hppa_add_symbol_hook
4040 #define elf_backend_relocate_section elf_hppa_relocate_section
4042 #define bfd_elf64_bfd_final_link elf_hppa_final_link
4044 #define elf_backend_create_dynamic_sections \
4045 elf64_hppa_create_dynamic_sections
4046 #define elf_backend_post_process_headers elf64_hppa_post_process_headers
4048 #define elf_backend_omit_section_dynsym \
4049 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4050 #define elf_backend_adjust_dynamic_symbol \
4051 elf64_hppa_adjust_dynamic_symbol
4053 #define elf_backend_size_dynamic_sections \
4054 elf64_hppa_size_dynamic_sections
4056 #define elf_backend_finish_dynamic_symbol \
4057 elf64_hppa_finish_dynamic_symbol
4058 #define elf_backend_finish_dynamic_sections \
4059 elf64_hppa_finish_dynamic_sections
4060 #define elf_backend_grok_prstatus elf64_hppa_grok_prstatus
4061 #define elf_backend_grok_psinfo elf64_hppa_grok_psinfo
4063 /* Stuff for the BFD linker: */
4064 #define bfd_elf64_bfd_link_hash_table_create \
4065 elf64_hppa_hash_table_create
4067 #define elf_backend_check_relocs \
4068 elf64_hppa_check_relocs
4070 #define elf_backend_size_info \
4071 hppa64_elf_size_info
4073 #define elf_backend_additional_program_headers \
4074 elf64_hppa_additional_program_headers
4076 #define elf_backend_modify_segment_map \
4077 elf64_hppa_modify_segment_map
4079 #define elf_backend_link_output_symbol_hook \
4080 elf64_hppa_link_output_symbol_hook
4082 #define elf_backend_want_got_plt 0
4083 #define elf_backend_plt_readonly 0
4084 #define elf_backend_want_plt_sym 0
4085 #define elf_backend_got_header_size 0
4086 #define elf_backend_type_change_ok TRUE
4087 #define elf_backend_get_symbol_type elf64_hppa_elf_get_symbol_type
4088 #define elf_backend_reloc_type_class elf64_hppa_reloc_type_class
4089 #define elf_backend_rela_normal 1
4090 #define elf_backend_special_sections elf64_hppa_special_sections
4091 #define elf_backend_action_discarded elf_hppa_action_discarded
4092 #define elf_backend_section_from_phdr elf64_hppa_section_from_phdr
4094 #define elf64_bed elf64_hppa_hpux_bed
4096 #include "elf64-target.h"
4098 #undef TARGET_BIG_SYM
4099 #define TARGET_BIG_SYM bfd_elf64_hppa_linux_vec
4100 #undef TARGET_BIG_NAME
4101 #define TARGET_BIG_NAME "elf64-hppa-linux"
4103 #define ELF_OSABI ELFOSABI_GNU
4105 #define elf64_bed elf64_hppa_linux_bed
4107 #include "elf64-target.h"