1 /* Generic support for 64-bit ELF
2 Copyright 1999, 2000 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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26 #include "elf64-hppa.h"
29 #define PLT_ENTRY_SIZE 0x10
30 #define DLT_ENTRY_SIZE 0x8
31 #define OPD_ENTRY_SIZE 0x20
33 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/pa20_64/dld.sl"
35 /* The stub is supposed to load the target address and target's DP
36 value out of the PLT, then do an external branch to the target
41 LDD PLTOFF+8(%r27),%r27
43 Note that we must use the LDD with a 14 bit displacement, not the one
44 with a 5 bit displacement. */
45 static char plt_stub
[] = {0x53, 0x61, 0x00, 0x00, 0xe8, 0x20, 0xd0, 0x00,
46 0x53, 0x7b, 0x00, 0x00 };
48 struct elf64_hppa_dyn_hash_entry
50 struct bfd_hash_entry root
;
52 /* Offsets for this symbol in various linker sections. */
58 /* The symbol table entry, if any, that this was derived from. */
59 struct elf_link_hash_entry
*h
;
61 /* The index of the (possibly local) symbol in the input bfd and its
62 associated BFD. Needed so that we can have relocs against local
63 symbols in shared libraries. */
64 unsigned long sym_indx
;
67 /* Dynamic symbols may need to have two different values. One for
68 the dynamic symbol table, one for the normal symbol table.
70 In such cases we store the symbol's real value and section
71 index here so we can restore the real value before we write
72 the normal symbol table. */
76 /* Used to count non-got, non-plt relocations for delayed sizing
77 of relocation sections. */
78 struct elf64_hppa_dyn_reloc_entry
80 /* Next relocation in the chain. */
81 struct elf64_hppa_dyn_reloc_entry
*next
;
83 /* The type of the relocation. */
86 /* The input section of the relocation. */
89 /* The index of the section symbol for the input section of
90 the relocation. Only needed when building shared libraries. */
93 /* The offset within the input section of the relocation. */
96 /* The addend for the relocation. */
101 /* Nonzero if this symbol needs an entry in one of the linker
109 struct elf64_hppa_dyn_hash_table
111 struct bfd_hash_table root
;
114 struct elf64_hppa_link_hash_table
116 struct elf_link_hash_table root
;
118 /* Shortcuts to get to the various linker defined sections. */
120 asection
*dlt_rel_sec
;
122 asection
*plt_rel_sec
;
124 asection
*opd_rel_sec
;
125 asection
*other_rel_sec
;
127 /* Offset of __gp within .plt section. When the PLT gets large we want
128 to slide __gp into the PLT section so that we can continue to use
129 single DP relative instructions to load values out of the PLT. */
132 /* Note this is not strictly correct. We should create a stub section for
133 each input section with calls. The stub section should be placed before
134 the section with the call. */
137 bfd_vma text_segment_base
;
138 bfd_vma data_segment_base
;
140 struct elf64_hppa_dyn_hash_table dyn_hash_table
;
142 /* We build tables to map from an input section back to its
143 symbol index. This is the BFD for which we currently have
145 bfd
*section_syms_bfd
;
147 /* Array of symbol numbers for each input section attached to the
152 #define elf64_hppa_hash_table(p) \
153 ((struct elf64_hppa_link_hash_table *) ((p)->hash))
155 typedef struct bfd_hash_entry
*(*new_hash_entry_func
)
156 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
158 static boolean elf64_hppa_dyn_hash_table_init
159 PARAMS ((struct elf64_hppa_dyn_hash_table
*ht
, bfd
*abfd
,
160 new_hash_entry_func
new));
161 static struct bfd_hash_entry
*elf64_hppa_new_dyn_hash_entry
162 PARAMS ((struct bfd_hash_entry
*entry
, struct bfd_hash_table
*table
,
163 const char *string
));
164 static struct bfd_link_hash_table
*elf64_hppa_hash_table_create
165 PARAMS ((bfd
*abfd
));
166 static struct elf64_hppa_dyn_hash_entry
*elf64_hppa_dyn_hash_lookup
167 PARAMS ((struct elf64_hppa_dyn_hash_table
*table
, const char *string
,
168 boolean create
, boolean copy
));
169 static void elf64_hppa_dyn_hash_traverse
170 PARAMS ((struct elf64_hppa_dyn_hash_table
*table
,
171 boolean (*func
)(struct elf64_hppa_dyn_hash_entry
*, PTR
),
174 static const char *get_dyn_name
175 PARAMS ((asection
*, struct elf_link_hash_entry
*,
176 const Elf_Internal_Rela
*, char **, size_t *));
179 /* This must follow the definitions of the various derived linker
180 hash tables and shared functions. */
181 #include "elf-hppa.h"
184 static boolean elf64_hppa_object_p
187 static boolean elf64_hppa_section_from_shdr
188 PARAMS ((bfd
*, Elf64_Internal_Shdr
*, char *));
190 static void elf64_hppa_post_process_headers
191 PARAMS ((bfd
*, struct bfd_link_info
*));
193 static boolean elf64_hppa_create_dynamic_sections
194 PARAMS ((bfd
*, struct bfd_link_info
*));
196 static boolean elf64_hppa_adjust_dynamic_symbol
197 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
199 static boolean elf64_hppa_size_dynamic_sections
200 PARAMS ((bfd
*, struct bfd_link_info
*));
202 static boolean elf64_hppa_finish_dynamic_symbol
203 PARAMS ((bfd
*, struct bfd_link_info
*,
204 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
206 static boolean elf64_hppa_finish_dynamic_sections
207 PARAMS ((bfd
*, struct bfd_link_info
*));
209 static boolean elf64_hppa_check_relocs
210 PARAMS ((bfd
*, struct bfd_link_info
*,
211 asection
*, const Elf_Internal_Rela
*));
213 static boolean elf64_hppa_dynamic_symbol_p
214 PARAMS ((struct elf_link_hash_entry
*, struct bfd_link_info
*));
216 static boolean elf64_hppa_mark_exported_functions
217 PARAMS ((struct elf_link_hash_entry
*, PTR
));
219 static boolean elf64_hppa_finalize_opd
220 PARAMS ((struct elf64_hppa_dyn_hash_entry
*, PTR
));
222 static boolean elf64_hppa_finalize_dlt
223 PARAMS ((struct elf64_hppa_dyn_hash_entry
*, PTR
));
225 static boolean allocate_global_data_dlt
226 PARAMS ((struct elf64_hppa_dyn_hash_entry
*, PTR
));
228 static boolean allocate_global_data_plt
229 PARAMS ((struct elf64_hppa_dyn_hash_entry
*, PTR
));
231 static boolean allocate_global_data_stub
232 PARAMS ((struct elf64_hppa_dyn_hash_entry
*, PTR
));
234 static boolean allocate_global_data_opd
235 PARAMS ((struct elf64_hppa_dyn_hash_entry
*, PTR
));
237 static boolean get_reloc_section
238 PARAMS ((bfd
*, struct elf64_hppa_link_hash_table
*, asection
*));
240 static boolean count_dyn_reloc
241 PARAMS ((bfd
*, struct elf64_hppa_dyn_hash_entry
*,
242 int, asection
*, int, bfd_vma
, bfd_vma
));
244 static boolean allocate_dynrel_entries
245 PARAMS ((struct elf64_hppa_dyn_hash_entry
*, PTR
));
247 static boolean elf64_hppa_finalize_dynreloc
248 PARAMS ((struct elf64_hppa_dyn_hash_entry
*, PTR
));
250 static boolean get_opd
251 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf64_hppa_link_hash_table
*));
253 static boolean get_plt
254 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf64_hppa_link_hash_table
*));
256 static boolean get_dlt
257 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf64_hppa_link_hash_table
*));
259 static boolean get_stub
260 PARAMS ((bfd
*, struct bfd_link_info
*, struct elf64_hppa_link_hash_table
*));
263 elf64_hppa_dyn_hash_table_init (ht
, abfd
, new)
264 struct elf64_hppa_dyn_hash_table
*ht
;
265 bfd
*abfd ATTRIBUTE_UNUSED
;
266 new_hash_entry_func
new;
268 memset (ht
, 0, sizeof(*ht
));
269 return bfd_hash_table_init (&ht
->root
, new);
272 static struct bfd_hash_entry
*
273 elf64_hppa_new_dyn_hash_entry (entry
, table
, string
)
274 struct bfd_hash_entry
*entry
;
275 struct bfd_hash_table
*table
;
278 struct elf64_hppa_dyn_hash_entry
*ret
;
279 ret
= (struct elf64_hppa_dyn_hash_entry
*) entry
;
281 /* Allocate the structure if it has not already been allocated by a
284 ret
= bfd_hash_allocate (table
, sizeof (*ret
));
289 /* Initialize our local data. All zeros, and definitely easier
290 than setting 8 bit fields. */
291 memset (ret
, 0, sizeof(*ret
));
293 /* Call the allocation method of the superclass. */
294 ret
= ((struct elf64_hppa_dyn_hash_entry
*)
295 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
300 /* Create the derived linker hash table. The PA64 ELF port uses this
301 derived hash table to keep information specific to the PA ElF
302 linker (without using static variables). */
304 static struct bfd_link_hash_table
*
305 elf64_hppa_hash_table_create (abfd
)
308 struct elf64_hppa_link_hash_table
*ret
;
310 ret
= bfd_zalloc (abfd
, sizeof (*ret
));
313 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
314 _bfd_elf_link_hash_newfunc
))
316 bfd_release (abfd
, ret
);
320 if (!elf64_hppa_dyn_hash_table_init (&ret
->dyn_hash_table
, abfd
,
321 elf64_hppa_new_dyn_hash_entry
))
323 return &ret
->root
.root
;
326 /* Look up an entry in a PA64 ELF linker hash table. */
328 static struct elf64_hppa_dyn_hash_entry
*
329 elf64_hppa_dyn_hash_lookup(table
, string
, create
, copy
)
330 struct elf64_hppa_dyn_hash_table
*table
;
332 boolean create
, copy
;
334 return ((struct elf64_hppa_dyn_hash_entry
*)
335 bfd_hash_lookup (&table
->root
, string
, create
, copy
));
338 /* Traverse a PA64 ELF linker hash table. */
341 elf64_hppa_dyn_hash_traverse (table
, func
, info
)
342 struct elf64_hppa_dyn_hash_table
*table
;
343 boolean (*func
) PARAMS ((struct elf64_hppa_dyn_hash_entry
*, PTR
));
348 (boolean (*) PARAMS ((struct bfd_hash_entry
*, PTR
))) func
,
352 /* Return nonzero if ABFD represents a PA2.0 ELF64 file.
354 Additionally we set the default architecture and machine. */
356 elf64_hppa_object_p (abfd
)
359 /* Set the right machine number for an HPPA ELF file. */
360 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 25);
363 /* Given section type (hdr->sh_type), return a boolean indicating
364 whether or not the section is an elf64-hppa specific section. */
366 elf64_hppa_section_from_shdr (abfd
, hdr
, name
)
368 Elf64_Internal_Shdr
*hdr
;
373 switch (hdr
->sh_type
)
376 if (strcmp (name
, ".PARISC.archext") != 0)
379 case SHT_PARISC_UNWIND
:
380 if (strcmp (name
, ".PARISC.unwind") != 0)
384 case SHT_PARISC_ANNOT
:
389 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
391 newsect
= hdr
->bfd_section
;
397 /* Construct a string for use in the elf64_hppa_dyn_hash_table. The
398 name describes what was once potentially anonymous memory. We
399 allocate memory as necessary, possibly reusing PBUF/PLEN. */
402 get_dyn_name (sec
, h
, rel
, pbuf
, plen
)
404 struct elf_link_hash_entry
*h
;
405 const Elf_Internal_Rela
*rel
;
413 if (h
&& rel
->r_addend
== 0)
414 return h
->root
.root
.string
;
417 nlen
= strlen (h
->root
.root
.string
);
419 nlen
= 8 + 1 + sizeof (rel
->r_info
) * 2 - 8;
420 tlen
= nlen
+ 1 + sizeof (rel
->r_addend
) * 2 + 1;
428 *pbuf
= buf
= malloc (tlen
);
436 memcpy (buf
, h
->root
.root
.string
, nlen
);
438 sprintf_vma (buf
+ nlen
, rel
->r_addend
);
442 nlen
= sprintf (buf
, "%x:%lx",
443 sec
->id
& 0xffffffff,
444 (long) ELF64_R_SYM (rel
->r_info
));
448 sprintf_vma (buf
+ nlen
, rel
->r_addend
);
455 /* SEC is a section containing relocs for an input BFD when linking; return
456 a suitable section for holding relocs in the output BFD for a link. */
459 get_reloc_section (abfd
, hppa_info
, sec
)
461 struct elf64_hppa_link_hash_table
*hppa_info
;
464 const char *srel_name
;
468 srel_name
= (bfd_elf_string_from_elf_section
469 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
470 elf_section_data(sec
)->rel_hdr
.sh_name
));
471 if (srel_name
== NULL
)
474 BFD_ASSERT ((strncmp (srel_name
, ".rela", 5) == 0
475 && strcmp (bfd_get_section_name (abfd
, sec
),
477 || (strncmp (srel_name
, ".rel", 4) == 0
478 && strcmp (bfd_get_section_name (abfd
, sec
),
481 dynobj
= hppa_info
->root
.dynobj
;
483 hppa_info
->root
.dynobj
= dynobj
= abfd
;
485 srel
= bfd_get_section_by_name (dynobj
, srel_name
);
488 srel
= bfd_make_section (dynobj
, srel_name
);
490 || !bfd_set_section_flags (dynobj
, srel
,
497 || !bfd_set_section_alignment (dynobj
, srel
, 3))
501 hppa_info
->other_rel_sec
= srel
;
505 /* Add a new entry to the list of dynamic relocations against DYN_H.
507 We use this to keep a record of all the FPTR relocations against a
508 particular symbol so that we can create FPTR relocations in the
512 count_dyn_reloc (abfd
, dyn_h
, type
, sec
, sec_symndx
, offset
, addend
)
514 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
521 struct elf64_hppa_dyn_reloc_entry
*rent
;
523 rent
= (struct elf64_hppa_dyn_reloc_entry
*)
524 bfd_alloc (abfd
, sizeof (*rent
));
528 rent
->next
= dyn_h
->reloc_entries
;
531 rent
->sec_symndx
= sec_symndx
;
532 rent
->offset
= offset
;
533 rent
->addend
= addend
;
534 dyn_h
->reloc_entries
= rent
;
539 /* Scan the RELOCS and record the type of dynamic entries that each
540 referenced symbol needs. */
543 elf64_hppa_check_relocs (abfd
, info
, sec
, relocs
)
545 struct bfd_link_info
*info
;
547 const Elf_Internal_Rela
*relocs
;
549 struct elf64_hppa_link_hash_table
*hppa_info
;
550 const Elf_Internal_Rela
*relend
;
551 Elf_Internal_Shdr
*symtab_hdr
;
552 const Elf_Internal_Rela
*rel
;
553 asection
*dlt
, *plt
, *stubs
;
558 if (info
->relocateable
)
561 /* If this is the first dynamic object found in the link, create
562 the special sections required for dynamic linking. */
563 if (! elf_hash_table (info
)->dynamic_sections_created
)
565 if (! bfd_elf64_link_create_dynamic_sections (abfd
, info
))
569 hppa_info
= elf64_hppa_hash_table (info
);
570 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
572 /* If necessary, build a new table holding section symbols indices
573 for this BFD. This is disgusting. */
575 if (info
->shared
&& hppa_info
->section_syms_bfd
!= abfd
)
579 Elf_Internal_Sym
*local_syms
, *isym
;
580 Elf64_External_Sym
*ext_syms
, *esym
;
582 /* We're done with the old cache of section index to section symbol
583 index information. Free it.
585 ?!? Note we leak the last section_syms array. Presumably we
586 could free it in one of the later routines in this file. */
587 if (hppa_info
->section_syms
)
588 free (hppa_info
->section_syms
);
590 /* Allocate memory for the internal and external symbols. */
592 = (Elf_Internal_Sym
*) bfd_malloc (symtab_hdr
->sh_info
593 * sizeof (Elf_Internal_Sym
));
594 if (local_syms
== NULL
)
598 = (Elf64_External_Sym
*) bfd_malloc (symtab_hdr
->sh_info
599 * sizeof (Elf64_External_Sym
));
600 if (ext_syms
== NULL
)
606 /* Read in the local symbols. */
607 if (bfd_seek (abfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
608 || bfd_read (ext_syms
, 1,
610 * sizeof (Elf64_External_Sym
)), abfd
)
611 != (symtab_hdr
->sh_info
* sizeof (Elf64_External_Sym
)))
618 /* Swap in the local symbols, also record the highest section index
619 referenced by the local symbols. */
623 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++, esym
++, isym
++)
625 bfd_elf64_swap_symbol_in (abfd
, esym
, isym
);
626 if (isym
->st_shndx
> highest_shndx
)
627 highest_shndx
= isym
->st_shndx
;
630 /* Now we can free the external symbols. */
633 /* Allocate an array to hold the section index to section symbol index
634 mapping. Bump by one since we start counting at zero. */
636 hppa_info
->section_syms
= (int *) bfd_malloc (highest_shndx
639 /* Now walk the local symbols again. If we find a section symbol,
640 record the index of the symbol into the section_syms array. */
641 for (isym
= local_syms
, i
= 0; i
< symtab_hdr
->sh_info
; i
++, isym
++)
643 if (ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
)
644 hppa_info
->section_syms
[isym
->st_shndx
] = i
;
647 /* We are finished with the local symbols. Get rid of them. */
650 /* Record which BFD we built the section_syms mapping for. */
651 hppa_info
->section_syms_bfd
= abfd
;
654 /* Record the symbol index for this input section. We may need it for
655 relocations when building shared libraries. When not building shared
656 libraries this value is never really used, but assign it to zero to
657 prevent out of bounds memory accesses in other routines. */
660 sec_symndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
662 /* If we did not find a section symbol for this section, then
663 something went terribly wrong above. */
664 if (sec_symndx
== -1)
667 sec_symndx
= hppa_info
->section_syms
[sec_symndx
];
672 dlt
= plt
= stubs
= NULL
;
676 relend
= relocs
+ sec
->reloc_count
;
677 for (rel
= relocs
; rel
< relend
; ++rel
)
687 struct elf_link_hash_entry
*h
= NULL
;
688 unsigned long r_symndx
= ELF64_R_SYM (rel
->r_info
);
689 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
691 const char *addr_name
;
692 boolean maybe_dynamic
;
693 int dynrel_type
= R_PARISC_NONE
;
694 static reloc_howto_type
*howto
;
696 if (r_symndx
>= symtab_hdr
->sh_info
)
698 /* We're dealing with a global symbol -- find its hash entry
699 and mark it as being referenced. */
700 long indx
= r_symndx
- symtab_hdr
->sh_info
;
701 h
= elf_sym_hashes (abfd
)[indx
];
702 while (h
->root
.type
== bfd_link_hash_indirect
703 || h
->root
.type
== bfd_link_hash_warning
)
704 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
706 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
709 /* We can only get preliminary data on whether a symbol is
710 locally or externally defined, as not all of the input files
711 have yet been processed. Do something with what we know, as
712 this may help reduce memory usage and processing time later. */
713 maybe_dynamic
= false;
714 if (h
&& ((info
->shared
&& ! info
->symbolic
)
715 || ! (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)
716 || h
->root
.type
== bfd_link_hash_defweak
))
717 maybe_dynamic
= true;
719 howto
= elf_hppa_howto_table
+ ELF64_R_TYPE (rel
->r_info
);
723 /* These are simple indirect references to symbols through the
724 DLT. We need to create a DLT entry for any symbols which
725 appears in a DLTIND relocation. */
726 case R_PARISC_DLTIND21L
:
727 case R_PARISC_DLTIND14R
:
728 case R_PARISC_DLTIND14F
:
729 case R_PARISC_DLTIND14WR
:
730 case R_PARISC_DLTIND14DR
:
731 need_entry
= NEED_DLT
;
734 /* ?!? These need a DLT entry. But I have no idea what to do with
735 the "link time TP value. */
736 case R_PARISC_LTOFF_TP21L
:
737 case R_PARISC_LTOFF_TP14R
:
738 case R_PARISC_LTOFF_TP14F
:
739 case R_PARISC_LTOFF_TP64
:
740 case R_PARISC_LTOFF_TP14WR
:
741 case R_PARISC_LTOFF_TP14DR
:
742 case R_PARISC_LTOFF_TP16F
:
743 case R_PARISC_LTOFF_TP16WF
:
744 case R_PARISC_LTOFF_TP16DF
:
745 need_entry
= NEED_DLT
;
748 /* These are function calls. Depending on their precise target we
749 may need to make a stub for them. The stub uses the PLT, so we
750 need to create PLT entries for these symbols too. */
751 case R_PARISC_PCREL12F
:
752 case R_PARISC_PCREL17F
:
753 case R_PARISC_PCREL22F
:
754 case R_PARISC_PCREL32
:
755 case R_PARISC_PCREL64
:
756 case R_PARISC_PCREL21L
:
757 case R_PARISC_PCREL17R
:
758 case R_PARISC_PCREL17C
:
759 case R_PARISC_PCREL14R
:
760 case R_PARISC_PCREL14F
:
761 case R_PARISC_PCREL22C
:
762 case R_PARISC_PCREL14WR
:
763 case R_PARISC_PCREL14DR
:
764 case R_PARISC_PCREL16F
:
765 case R_PARISC_PCREL16WF
:
766 case R_PARISC_PCREL16DF
:
767 need_entry
= (NEED_PLT
| NEED_STUB
);
770 case R_PARISC_PLTOFF21L
:
771 case R_PARISC_PLTOFF14R
:
772 case R_PARISC_PLTOFF14F
:
773 case R_PARISC_PLTOFF14WR
:
774 case R_PARISC_PLTOFF14DR
:
775 case R_PARISC_PLTOFF16F
:
776 case R_PARISC_PLTOFF16WF
:
777 case R_PARISC_PLTOFF16DF
:
778 need_entry
= (NEED_PLT
);
782 if (info
->shared
|| maybe_dynamic
)
783 need_entry
= (NEED_DYNREL
);
784 dynrel_type
= R_PARISC_DIR64
;
787 /* This is an indirect reference through the DLT to get the address
788 of a OPD descriptor. Thus we need to make a DLT entry that points
790 case R_PARISC_LTOFF_FPTR21L
:
791 case R_PARISC_LTOFF_FPTR14R
:
792 case R_PARISC_LTOFF_FPTR14WR
:
793 case R_PARISC_LTOFF_FPTR14DR
:
794 case R_PARISC_LTOFF_FPTR32
:
795 case R_PARISC_LTOFF_FPTR64
:
796 case R_PARISC_LTOFF_FPTR16F
:
797 case R_PARISC_LTOFF_FPTR16WF
:
798 case R_PARISC_LTOFF_FPTR16DF
:
799 if (info
->shared
|| maybe_dynamic
)
800 need_entry
= (NEED_DLT
| NEED_OPD
);
802 need_entry
= (NEED_DLT
| NEED_OPD
);
803 dynrel_type
= R_PARISC_FPTR64
;
806 /* This is a simple OPD entry. */
807 case R_PARISC_FPTR64
:
808 if (info
->shared
|| maybe_dynamic
)
809 need_entry
= (NEED_OPD
| NEED_DYNREL
);
811 need_entry
= (NEED_OPD
);
812 dynrel_type
= R_PARISC_FPTR64
;
815 /* Add more cases as needed. */
821 /* Collect a canonical name for this address. */
822 addr_name
= get_dyn_name (sec
, h
, rel
, &buf
, &buf_len
);
824 /* Collect the canonical entry data for this address. */
825 dyn_h
= elf64_hppa_dyn_hash_lookup (&hppa_info
->dyn_hash_table
,
826 addr_name
, true, true);
829 /* Stash away enough information to be able to find this symbol
830 regardless of whether or not it is local or global. */
833 dyn_h
->sym_indx
= r_symndx
;
835 /* ?!? We may need to do some error checking in here. */
836 /* Create what's needed. */
837 if (need_entry
& NEED_DLT
)
839 if (! hppa_info
->dlt_sec
840 && ! get_dlt (abfd
, info
, hppa_info
))
845 if (need_entry
& NEED_PLT
)
847 if (! hppa_info
->plt_sec
848 && ! get_plt (abfd
, info
, hppa_info
))
853 if (need_entry
& NEED_STUB
)
855 if (! hppa_info
->stub_sec
856 && ! get_stub (abfd
, info
, hppa_info
))
858 dyn_h
->want_stub
= 1;
861 if (need_entry
& NEED_OPD
)
863 if (! hppa_info
->opd_sec
864 && ! get_opd (abfd
, info
, hppa_info
))
869 /* FPTRs are not allocated by the dynamic linker for PA64, though
870 it is possible that will change in the future. */
872 /* This could be a local function that had its address taken, in
873 which case H will be NULL. */
875 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
878 /* Add a new dynamic relocation to the chain of dynamic
879 relocations for this symbol. */
880 if ((need_entry
& NEED_DYNREL
) && (sec
->flags
& SEC_ALLOC
))
882 if (! hppa_info
->other_rel_sec
883 && ! get_reloc_section (abfd
, hppa_info
, sec
))
886 if (!count_dyn_reloc (abfd
, dyn_h
, dynrel_type
, sec
,
887 sec_symndx
, rel
->r_offset
, rel
->r_addend
))
890 /* If we are building a shared library and we just recorded
891 a dynamic R_PARISC_FPTR64 relocation, then make sure the
892 section symbol for this section ends up in the dynamic
894 if (info
->shared
&& dynrel_type
== R_PARISC_FPTR64
895 && ! (_bfd_elf64_link_record_local_dynamic_symbol
896 (info
, abfd
, sec_symndx
)))
911 struct elf64_hppa_allocate_data
913 struct bfd_link_info
*info
;
917 /* Should we do dynamic things to this symbol? */
920 elf64_hppa_dynamic_symbol_p (h
, info
)
921 struct elf_link_hash_entry
*h
;
922 struct bfd_link_info
*info
;
927 while (h
->root
.type
== bfd_link_hash_indirect
928 || h
->root
.type
== bfd_link_hash_warning
)
929 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
931 if (h
->dynindx
== -1)
934 if (h
->root
.type
== bfd_link_hash_undefweak
935 || h
->root
.type
== bfd_link_hash_defweak
)
938 if (h
->root
.root
.string
[0] == '$' && h
->root
.root
.string
[1] == '$')
941 if ((info
->shared
&& !info
->symbolic
)
942 || ((h
->elf_link_hash_flags
943 & (ELF_LINK_HASH_DEF_DYNAMIC
| ELF_LINK_HASH_REF_REGULAR
))
944 == (ELF_LINK_HASH_DEF_DYNAMIC
| ELF_LINK_HASH_REF_REGULAR
)))
950 /* Mark all funtions exported by this file so that we can later allocate
951 entries in .opd for them. */
954 elf64_hppa_mark_exported_functions (h
, data
)
955 struct elf_link_hash_entry
*h
;
958 struct bfd_link_info
*info
= (struct bfd_link_info
*)data
;
959 struct elf64_hppa_link_hash_table
*hppa_info
;
961 hppa_info
= elf64_hppa_hash_table (info
);
964 && (h
->root
.type
== bfd_link_hash_defined
965 || h
->root
.type
== bfd_link_hash_defweak
)
966 && h
->root
.u
.def
.section
->output_section
!= NULL
967 && h
->type
== STT_FUNC
)
969 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
971 /* Add this symbol to the PA64 linker hash table. */
972 dyn_h
= elf64_hppa_dyn_hash_lookup (&hppa_info
->dyn_hash_table
,
973 h
->root
.root
.string
, true, true);
977 if (! hppa_info
->opd_sec
978 && ! get_opd (hppa_info
->root
.dynobj
, info
, hppa_info
))
982 /* Put a flag here for output_symbol_hook. */
983 dyn_h
->st_shndx
= -1;
984 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
990 /* Allocate space for a DLT entry. */
993 allocate_global_data_dlt (dyn_h
, data
)
994 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
997 struct elf64_hppa_allocate_data
*x
= (struct elf64_hppa_allocate_data
*)data
;
1001 struct elf_link_hash_entry
*h
= dyn_h
->h
;
1003 if (x
->info
->shared
)
1005 /* Possibly add the symbol to the local dynamic symbol
1006 table since we might need to create a dynamic relocation
1009 || (h
&& h
->dynindx
== -1))
1012 owner
= (h
? h
->root
.u
.def
.section
->owner
: dyn_h
->owner
);
1014 if (!_bfd_elf64_link_record_local_dynamic_symbol
1015 (x
->info
, owner
, dyn_h
->sym_indx
))
1020 dyn_h
->dlt_offset
= x
->ofs
;
1021 x
->ofs
+= DLT_ENTRY_SIZE
;
1026 /* Allocate space for a DLT.PLT entry. */
1029 allocate_global_data_plt (dyn_h
, data
)
1030 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
1033 struct elf64_hppa_allocate_data
*x
= (struct elf64_hppa_allocate_data
*)data
;
1036 && elf64_hppa_dynamic_symbol_p (dyn_h
->h
, x
->info
)
1037 && !((dyn_h
->h
->root
.type
== bfd_link_hash_defined
1038 || dyn_h
->h
->root
.type
== bfd_link_hash_defweak
)
1039 && dyn_h
->h
->root
.u
.def
.section
->output_section
!= NULL
))
1041 dyn_h
->plt_offset
= x
->ofs
;
1042 x
->ofs
+= PLT_ENTRY_SIZE
;
1043 if (dyn_h
->plt_offset
< 0x2000)
1044 elf64_hppa_hash_table (x
->info
)->gp_offset
= dyn_h
->plt_offset
;
1047 dyn_h
->want_plt
= 0;
1052 /* Allocate space for a STUB entry. */
1055 allocate_global_data_stub (dyn_h
, data
)
1056 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
1059 struct elf64_hppa_allocate_data
*x
= (struct elf64_hppa_allocate_data
*)data
;
1061 if (dyn_h
->want_stub
1062 && elf64_hppa_dynamic_symbol_p (dyn_h
->h
, x
->info
)
1063 && !((dyn_h
->h
->root
.type
== bfd_link_hash_defined
1064 || dyn_h
->h
->root
.type
== bfd_link_hash_defweak
)
1065 && dyn_h
->h
->root
.u
.def
.section
->output_section
!= NULL
))
1067 dyn_h
->stub_offset
= x
->ofs
;
1068 x
->ofs
+= sizeof (plt_stub
);
1071 dyn_h
->want_stub
= 0;
1075 /* Allocate space for a FPTR entry. */
1078 allocate_global_data_opd (dyn_h
, data
)
1079 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
1082 struct elf64_hppa_allocate_data
*x
= (struct elf64_hppa_allocate_data
*)data
;
1084 if (dyn_h
->want_opd
)
1086 struct elf_link_hash_entry
*h
= dyn_h
->h
;
1089 while (h
->root
.type
== bfd_link_hash_indirect
1090 || h
->root
.type
== bfd_link_hash_warning
)
1091 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1093 /* We never need an opd entry for a symbol which is not
1094 defined by this output file. */
1095 if (h
&& h
->root
.type
== bfd_link_hash_undefined
)
1096 dyn_h
->want_opd
= 0;
1098 /* If we are creating a shared library, took the address of a local
1099 function or might export this function from this object file, then
1100 we have to create an opd descriptor. */
1101 else if (x
->info
->shared
1104 || ((h
->root
.type
== bfd_link_hash_defined
1105 || h
->root
.type
== bfd_link_hash_defweak
)
1106 && h
->root
.u
.def
.section
->output_section
!= NULL
))
1108 /* If we are creating a shared library, then we will have to
1109 create a runtime relocation for the symbol to properly
1110 initialize the .opd entry. Make sure the symbol gets
1111 added to the dynamic symbol table. */
1113 && (h
== NULL
|| (h
->dynindx
== -1)))
1116 owner
= (h
? h
->root
.u
.def
.section
->owner
: dyn_h
->owner
);
1118 if (!_bfd_elf64_link_record_local_dynamic_symbol
1119 (x
->info
, owner
, dyn_h
->sym_indx
))
1123 /* This may not be necessary or desirable anymore now that
1124 we have some support for dealing with section symbols
1125 in dynamic relocs. But name munging does make the result
1126 much easier to debug. ie, the EPLT reloc will reference
1127 a symbol like .foobar, instead of .text + offset. */
1128 if (x
->info
->shared
&& h
)
1131 struct elf_link_hash_entry
*nh
;
1133 new_name
= alloca (strlen (h
->root
.root
.string
) + 2);
1135 strcpy (new_name
+ 1, h
->root
.root
.string
);
1137 nh
= elf_link_hash_lookup (elf_hash_table (x
->info
),
1138 new_name
, true, true, true);
1140 nh
->root
.type
= h
->root
.type
;
1141 nh
->root
.u
.def
.value
= h
->root
.u
.def
.value
;
1142 nh
->root
.u
.def
.section
= h
->root
.u
.def
.section
;
1144 if (! bfd_elf64_link_record_dynamic_symbol (x
->info
, nh
))
1148 dyn_h
->opd_offset
= x
->ofs
;
1149 x
->ofs
+= OPD_ENTRY_SIZE
;
1152 /* Otherwise we do not need an opd entry. */
1154 dyn_h
->want_opd
= 0;
1159 /* HP requires the EI_OSABI field to be filled in. The assignment to
1160 EI_ABIVERSION may not be strictly necessary. */
1163 elf64_hppa_post_process_headers (abfd
, link_info
)
1165 struct bfd_link_info
* link_info ATTRIBUTE_UNUSED
;
1167 Elf_Internal_Ehdr
* i_ehdrp
;
1169 i_ehdrp
= elf_elfheader (abfd
);
1171 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_HPUX
;
1172 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 1;
1175 /* Create function descriptor section (.opd). This section is called .opd
1176 because it contains "official prodecure descriptors". The "official"
1177 refers to the fact that these descriptors are used when taking the address
1178 of a procedure, thus ensuring a unique address for each procedure. */
1181 get_opd (abfd
, info
, hppa_info
)
1183 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1184 struct elf64_hppa_link_hash_table
*hppa_info
;
1189 opd
= hppa_info
->opd_sec
;
1192 dynobj
= hppa_info
->root
.dynobj
;
1194 hppa_info
->root
.dynobj
= dynobj
= abfd
;
1196 opd
= bfd_make_section (dynobj
, ".opd");
1198 || !bfd_set_section_flags (dynobj
, opd
,
1203 | SEC_LINKER_CREATED
))
1204 || !bfd_set_section_alignment (abfd
, opd
, 3))
1210 hppa_info
->opd_sec
= opd
;
1216 /* Create the PLT section. */
1219 get_plt (abfd
, info
, hppa_info
)
1221 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1222 struct elf64_hppa_link_hash_table
*hppa_info
;
1227 plt
= hppa_info
->plt_sec
;
1230 dynobj
= hppa_info
->root
.dynobj
;
1232 hppa_info
->root
.dynobj
= dynobj
= abfd
;
1234 plt
= bfd_make_section (dynobj
, ".plt");
1236 || !bfd_set_section_flags (dynobj
, plt
,
1241 | SEC_LINKER_CREATED
))
1242 || !bfd_set_section_alignment (abfd
, plt
, 3))
1248 hppa_info
->plt_sec
= plt
;
1254 /* Create the DLT section. */
1257 get_dlt (abfd
, info
, hppa_info
)
1259 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1260 struct elf64_hppa_link_hash_table
*hppa_info
;
1265 dlt
= hppa_info
->dlt_sec
;
1268 dynobj
= hppa_info
->root
.dynobj
;
1270 hppa_info
->root
.dynobj
= dynobj
= abfd
;
1272 dlt
= bfd_make_section (dynobj
, ".dlt");
1274 || !bfd_set_section_flags (dynobj
, dlt
,
1279 | SEC_LINKER_CREATED
))
1280 || !bfd_set_section_alignment (abfd
, dlt
, 3))
1286 hppa_info
->dlt_sec
= dlt
;
1292 /* Create the stubs section. */
1295 get_stub (abfd
, info
, hppa_info
)
1297 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1298 struct elf64_hppa_link_hash_table
*hppa_info
;
1303 stub
= hppa_info
->stub_sec
;
1306 dynobj
= hppa_info
->root
.dynobj
;
1308 hppa_info
->root
.dynobj
= dynobj
= abfd
;
1310 stub
= bfd_make_section (dynobj
, ".stub");
1312 || !bfd_set_section_flags (dynobj
, stub
,
1318 | SEC_LINKER_CREATED
))
1319 || !bfd_set_section_alignment (abfd
, stub
, 3))
1325 hppa_info
->stub_sec
= stub
;
1331 /* Create sections necessary for dynamic linking. This is only a rough
1332 cut and will likely change as we learn more about the somewhat
1333 unusual dynamic linking scheme HP uses.
1336 Contains code to implement cross-space calls. The first time one
1337 of the stubs is used it will call into the dynamic linker, later
1338 calls will go straight to the target.
1340 The only stub we support right now looks like
1344 ldd OFFSET+8(%dp),%dp
1346 Other stubs may be needed in the future. We may want the remove
1347 the break/nop instruction. It is only used right now to keep the
1348 offset of a .plt entry and a .stub entry in sync.
1351 This is what most people call the .got. HP used a different name.
1355 Relocations for the DLT.
1358 Function pointers as address,gp pairs.
1361 Should contain dynamic IPLT (and EPLT?) relocations.
1367 EPLT relocations for symbols exported from shared libraries. */
1370 elf64_hppa_create_dynamic_sections (abfd
, info
)
1372 struct bfd_link_info
*info
;
1376 if (! get_stub (abfd
, info
, elf64_hppa_hash_table (info
)))
1379 if (! get_dlt (abfd
, info
, elf64_hppa_hash_table (info
)))
1382 if (! get_plt (abfd
, info
, elf64_hppa_hash_table (info
)))
1385 if (! get_opd (abfd
, info
, elf64_hppa_hash_table (info
)))
1388 s
= bfd_make_section(abfd
, ".rela.dlt");
1390 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
1394 | SEC_LINKER_CREATED
))
1395 || !bfd_set_section_alignment (abfd
, s
, 3))
1397 elf64_hppa_hash_table (info
)->dlt_rel_sec
= s
;
1399 s
= bfd_make_section(abfd
, ".rela.plt");
1401 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
1405 | SEC_LINKER_CREATED
))
1406 || !bfd_set_section_alignment (abfd
, s
, 3))
1408 elf64_hppa_hash_table (info
)->plt_rel_sec
= s
;
1410 s
= bfd_make_section(abfd
, ".rela.data");
1412 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
1416 | SEC_LINKER_CREATED
))
1417 || !bfd_set_section_alignment (abfd
, s
, 3))
1419 elf64_hppa_hash_table (info
)->other_rel_sec
= s
;
1421 s
= bfd_make_section(abfd
, ".rela.opd");
1423 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
1427 | SEC_LINKER_CREATED
))
1428 || !bfd_set_section_alignment (abfd
, s
, 3))
1430 elf64_hppa_hash_table (info
)->opd_rel_sec
= s
;
1435 /* Allocate dynamic relocations for those symbols that turned out
1439 allocate_dynrel_entries (dyn_h
, data
)
1440 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
1443 struct elf64_hppa_allocate_data
*x
= (struct elf64_hppa_allocate_data
*)data
;
1444 struct elf64_hppa_link_hash_table
*hppa_info
;
1445 struct elf64_hppa_dyn_reloc_entry
*rent
;
1446 boolean dynamic_symbol
, shared
;
1448 hppa_info
= elf64_hppa_hash_table (x
->info
);
1449 dynamic_symbol
= elf64_hppa_dynamic_symbol_p (dyn_h
->h
, x
->info
);
1450 shared
= x
->info
->shared
;
1452 /* We may need to allocate relocations for a non-dynamic symbol
1453 when creating a shared library. */
1454 if (!dynamic_symbol
&& !shared
)
1457 /* Take care of the normal data relocations. */
1459 for (rent
= dyn_h
->reloc_entries
; rent
; rent
= rent
->next
)
1463 case R_PARISC_FPTR64
:
1464 /* Allocate one iff we are not building a shared library and
1465 !want_opd, which by this point will be true only if we're
1466 actually allocating one statically in the main executable. */
1467 if (!x
->info
->shared
&& dyn_h
->want_opd
)
1471 hppa_info
->other_rel_sec
->_raw_size
+= sizeof (Elf64_External_Rela
);
1473 /* Make sure this symbol gets into the dynamic symbol table if it is
1474 not already recorded. ?!? This should not be in the loop since
1475 the symbol need only be added once. */
1476 if (dyn_h
->h
== 0 || dyn_h
->h
->dynindx
== -1)
1477 if (!_bfd_elf64_link_record_local_dynamic_symbol
1478 (x
->info
, rent
->sec
->owner
, dyn_h
->sym_indx
))
1482 /* Take care of the GOT and PLT relocations. */
1484 if ((dynamic_symbol
|| shared
) && dyn_h
->want_dlt
)
1485 hppa_info
->dlt_rel_sec
->_raw_size
+= sizeof (Elf64_External_Rela
);
1487 /* If we are building a shared library, then every symbol that has an
1488 opd entry will need an EPLT relocation to relocate the symbol's address
1489 and __gp value based on the runtime load address. */
1490 if (shared
&& dyn_h
->want_opd
)
1491 hppa_info
->opd_rel_sec
->_raw_size
+= sizeof (Elf64_External_Rela
);
1493 if (dyn_h
->want_plt
&& dynamic_symbol
)
1495 bfd_size_type t
= 0;
1497 /* Dynamic symbols get one IPLT relocation. Local symbols in
1498 shared libraries get two REL relocations. Local symbols in
1499 main applications get nothing. */
1501 t
= sizeof (Elf64_External_Rela
);
1503 t
= 2 * sizeof (Elf64_External_Rela
);
1505 hppa_info
->plt_rel_sec
->_raw_size
+= t
;
1511 /* Adjust a symbol defined by a dynamic object and referenced by a
1515 elf64_hppa_adjust_dynamic_symbol (info
, h
)
1516 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1517 struct elf_link_hash_entry
*h
;
1519 /* ??? Undefined symbols with PLT entries should be re-defined
1520 to be the PLT entry. */
1522 /* If this is a weak symbol, and there is a real definition, the
1523 processor independent code will have arranged for us to see the
1524 real definition first, and we can just use the same value. */
1525 if (h
->weakdef
!= NULL
)
1527 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
1528 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
1529 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
1530 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
1534 /* If this is a reference to a symbol defined by a dynamic object which
1535 is not a function, we might allocate the symbol in our .dynbss section
1536 and allocate a COPY dynamic relocation.
1538 But PA64 code is canonically PIC, so as a rule we can avoid this sort
1544 /* Set the final sizes of the dynamic sections and allocate memory for
1545 the contents of our special sections. */
1548 elf64_hppa_size_dynamic_sections (output_bfd
, info
)
1550 struct bfd_link_info
*info
;
1557 struct elf64_hppa_allocate_data data
;
1558 struct elf64_hppa_link_hash_table
*hppa_info
;
1560 hppa_info
= elf64_hppa_hash_table (info
);
1562 dynobj
= elf_hash_table (info
)->dynobj
;
1563 BFD_ASSERT (dynobj
!= NULL
);
1565 if (elf_hash_table (info
)->dynamic_sections_created
)
1567 /* Set the contents of the .interp section to the interpreter. */
1570 s
= bfd_get_section_by_name (dynobj
, ".interp");
1571 BFD_ASSERT (s
!= NULL
);
1572 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1573 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1578 /* We may have created entries in the .rela.got section.
1579 However, if we are not creating the dynamic sections, we will
1580 not actually use these entries. Reset the size of .rela.dlt,
1581 which will cause it to get stripped from the output file
1583 s
= bfd_get_section_by_name (dynobj
, ".rela.dlt");
1588 /* Allocate the GOT entries. */
1591 if (elf64_hppa_hash_table (info
)->dlt_sec
)
1594 elf64_hppa_dyn_hash_traverse (&hppa_info
->dyn_hash_table
,
1595 allocate_global_data_dlt
, &data
);
1596 hppa_info
->dlt_sec
->_raw_size
= data
.ofs
;
1599 elf64_hppa_dyn_hash_traverse (&hppa_info
->dyn_hash_table
,
1600 allocate_global_data_plt
, &data
);
1601 hppa_info
->plt_sec
->_raw_size
= data
.ofs
;
1604 elf64_hppa_dyn_hash_traverse (&hppa_info
->dyn_hash_table
,
1605 allocate_global_data_stub
, &data
);
1606 hppa_info
->stub_sec
->_raw_size
= data
.ofs
;
1609 /* Mark each function this program exports so that we will allocate
1610 space in the .opd section for each function's FPTR.
1612 We have to traverse the main linker hash table since we have to
1613 find functions which may not have been mentioned in any relocs. */
1614 elf_link_hash_traverse (elf_hash_table (info
),
1615 elf64_hppa_mark_exported_functions
,
1618 /* Allocate space for entries in the .opd section. */
1619 if (elf64_hppa_hash_table (info
)->opd_sec
)
1622 elf64_hppa_dyn_hash_traverse (&hppa_info
->dyn_hash_table
,
1623 allocate_global_data_opd
, &data
);
1624 hppa_info
->opd_sec
->_raw_size
= data
.ofs
;
1627 /* Now allocate space for dynamic relocations, if necessary. */
1628 if (hppa_info
->root
.dynamic_sections_created
)
1629 elf64_hppa_dyn_hash_traverse (&hppa_info
->dyn_hash_table
,
1630 allocate_dynrel_entries
, &data
);
1632 /* The sizes of all the sections are set. Allocate memory for them. */
1636 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1641 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1644 /* It's OK to base decisions on the section name, because none
1645 of the dynobj section names depend upon the input files. */
1646 name
= bfd_get_section_name (dynobj
, s
);
1650 if (strcmp (name
, ".plt") == 0)
1652 if (s
->_raw_size
== 0)
1654 /* Strip this section if we don't need it; see the
1660 /* Remember whether there is a PLT. */
1664 else if (strcmp (name
, ".dlt") == 0)
1666 if (s
->_raw_size
== 0)
1668 /* Strip this section if we don't need it; see the
1673 else if (strcmp (name
, ".opd") == 0)
1675 if (s
->_raw_size
== 0)
1677 /* Strip this section if we don't need it; see the
1682 else if (strncmp (name
, ".rela", 4) == 0)
1684 if (s
->_raw_size
== 0)
1686 /* If we don't need this section, strip it from the
1687 output file. This is mostly to handle .rela.bss and
1688 .rela.plt. We must create both sections in
1689 create_dynamic_sections, because they must be created
1690 before the linker maps input sections to output
1691 sections. The linker does that before
1692 adjust_dynamic_symbol is called, and it is that
1693 function which decides whether anything needs to go
1694 into these sections. */
1701 /* Remember whether there are any reloc sections other
1703 if (strcmp (name
, ".rela.plt") != 0)
1705 const char *outname
;
1709 /* If this relocation section applies to a read only
1710 section, then we probably need a DT_TEXTREL
1711 entry. The entries in the .rela.plt section
1712 really apply to the .got section, which we
1713 created ourselves and so know is not readonly. */
1714 outname
= bfd_get_section_name (output_bfd
,
1716 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
1718 && (target
->flags
& SEC_READONLY
) != 0
1719 && (target
->flags
& SEC_ALLOC
) != 0)
1723 /* We use the reloc_count field as a counter if we need
1724 to copy relocs into the output file. */
1728 else if (strncmp (name
, ".dlt", 4) != 0
1729 && strcmp (name
, ".stub") != 0
1730 && strcmp (name
, ".got") != 0)
1732 /* It's not one of our sections, so don't allocate space. */
1738 _bfd_strip_section_from_output (info
, s
);
1742 /* Allocate memory for the section contents if it has not
1743 been allocated already. We use bfd_zalloc here in case
1744 unused entries are not reclaimed before the section's
1745 contents are written out. This should not happen, but this
1746 way if it does, we get a R_PARISC_NONE reloc instead of
1748 if (s
->contents
== NULL
)
1750 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
1751 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
1756 if (elf_hash_table (info
)->dynamic_sections_created
)
1758 /* Always create a DT_PLTGOT. It actually has nothing to do with
1759 the PLT, it is how we communicate the __gp value of a load
1760 module to the dynamic linker. */
1761 if (! bfd_elf64_add_dynamic_entry (info
, DT_HP_DLD_FLAGS
, 0)
1762 || ! bfd_elf64_add_dynamic_entry (info
, DT_PLTGOT
, 0))
1765 /* Add some entries to the .dynamic section. We fill in the
1766 values later, in elf64_hppa_finish_dynamic_sections, but we
1767 must add the entries now so that we get the correct size for
1768 the .dynamic section. The DT_DEBUG entry is filled in by the
1769 dynamic linker and used by the debugger. */
1772 if (! bfd_elf64_add_dynamic_entry (info
, DT_DEBUG
, 0)
1773 || ! bfd_elf64_add_dynamic_entry (info
, DT_HP_DLD_HOOK
, 0)
1774 || ! bfd_elf64_add_dynamic_entry (info
, DT_HP_LOAD_MAP
, 0))
1780 if (! bfd_elf64_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
1781 || ! bfd_elf64_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
1782 || ! bfd_elf64_add_dynamic_entry (info
, DT_JMPREL
, 0))
1788 if (! bfd_elf64_add_dynamic_entry (info
, DT_RELA
, 0)
1789 || ! bfd_elf64_add_dynamic_entry (info
, DT_RELASZ
, 0)
1790 || ! bfd_elf64_add_dynamic_entry (info
, DT_RELAENT
,
1791 sizeof (Elf64_External_Rela
)))
1797 if (! bfd_elf64_add_dynamic_entry (info
, DT_TEXTREL
, 0))
1799 info
->flags
|= DF_TEXTREL
;
1806 /* Called after we have output the symbol into the dynamic symbol
1807 table, but before we output the symbol into the normal symbol
1810 For some symbols we had to change their address when outputting
1811 the dynamic symbol table. We undo that change here so that
1812 the symbols have their expected value in the normal symbol
1816 elf64_hppa_link_output_symbol_hook (abfd
, info
, name
, sym
, input_sec
)
1817 bfd
*abfd ATTRIBUTE_UNUSED
;
1818 struct bfd_link_info
*info
;
1820 Elf_Internal_Sym
*sym
;
1821 asection
*input_sec ATTRIBUTE_UNUSED
;
1823 struct elf64_hppa_link_hash_table
*hppa_info
;
1824 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
1826 /* We may be called with the file symbol or section symbols.
1827 They never need munging, so it is safe to ignore them. */
1831 /* Get the PA dyn_symbol (if any) associated with NAME. */
1832 hppa_info
= elf64_hppa_hash_table (info
);
1833 dyn_h
= elf64_hppa_dyn_hash_lookup (&hppa_info
->dyn_hash_table
,
1834 name
, false, false);
1836 /* Function symbols for which we created .opd entries *may* have been
1837 munged by finish_dynamic_symbol and have to be un-munged here.
1839 Note that finish_dynamic_symbol sometimes turns dynamic symbols
1840 into non-dynamic ones, so we initialize st_shndx to -1 in
1841 mark_exported_functions and check to see if it was overwritten
1842 here instead of just checking dyn_h->h->dynindx. */
1843 if (dyn_h
&& dyn_h
->want_opd
&& dyn_h
->st_shndx
!= -1)
1845 /* Restore the saved value and section index. */
1846 sym
->st_value
= dyn_h
->st_value
;
1847 sym
->st_shndx
= dyn_h
->st_shndx
;
1853 /* Finish up dynamic symbol handling. We set the contents of various
1854 dynamic sections here. */
1857 elf64_hppa_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
1859 struct bfd_link_info
*info
;
1860 struct elf_link_hash_entry
*h
;
1861 Elf_Internal_Sym
*sym
;
1863 asection
*stub
, *splt
, *sdlt
, *sopd
, *spltrel
, *sdltrel
;
1864 struct elf64_hppa_link_hash_table
*hppa_info
;
1865 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
1867 hppa_info
= elf64_hppa_hash_table (info
);
1868 dyn_h
= elf64_hppa_dyn_hash_lookup (&hppa_info
->dyn_hash_table
,
1869 h
->root
.root
.string
, false, false);
1871 stub
= hppa_info
->stub_sec
;
1872 splt
= hppa_info
->plt_sec
;
1873 sdlt
= hppa_info
->dlt_sec
;
1874 sopd
= hppa_info
->opd_sec
;
1875 spltrel
= hppa_info
->plt_rel_sec
;
1876 sdltrel
= hppa_info
->dlt_rel_sec
;
1878 BFD_ASSERT (stub
!= NULL
&& splt
!= NULL
1879 && sopd
!= NULL
&& sdlt
!= NULL
)
1881 /* Incredible. It is actually necessary to NOT use the symbol's real
1882 value when building the dynamic symbol table for a shared library.
1883 At least for symbols that refer to functions.
1885 We will store a new value and section index into the symbol long
1886 enough to output it into the dynamic symbol table, then we restore
1887 the original values (in elf64_hppa_link_output_symbol_hook). */
1888 if (dyn_h
&& dyn_h
->want_opd
)
1890 /* Save away the original value and section index so that we
1891 can restore them later. */
1892 dyn_h
->st_value
= sym
->st_value
;
1893 dyn_h
->st_shndx
= sym
->st_shndx
;
1895 /* For the dynamic symbol table entry, we want the value to be
1896 address of this symbol's entry within the .opd section. */
1897 sym
->st_value
= (dyn_h
->opd_offset
1898 + sopd
->output_offset
1899 + sopd
->output_section
->vma
);
1900 sym
->st_shndx
= _bfd_elf_section_from_bfd_section (output_bfd
,
1901 sopd
->output_section
);
1904 /* Initialize a .plt entry if requested. */
1905 if (dyn_h
&& dyn_h
->want_plt
1906 && elf64_hppa_dynamic_symbol_p (dyn_h
->h
, info
))
1909 Elf_Internal_Rela rel
;
1911 /* We do not actually care about the value in the PLT entry
1912 if we are creating a shared library and the symbol is
1913 still undefined, we create a dynamic relocation to fill
1914 in the correct value. */
1915 if (info
->shared
&& h
->root
.type
== bfd_link_hash_undefined
)
1918 value
= (h
->root
.u
.def
.value
+ h
->root
.u
.def
.section
->vma
);
1920 /* Fill in the entry in the procedure linkage table.
1922 The format of a plt entry is
1925 plt_offset is the offset within the PLT section at which to
1926 install the PLT entry.
1928 We are modifying the in-memory PLT contents here, so we do not add
1929 in the output_offset of the PLT section. */
1931 bfd_put_64 (splt
->owner
, value
, splt
->contents
+ dyn_h
->plt_offset
);
1932 value
= _bfd_get_gp_value (splt
->output_section
->owner
);
1933 bfd_put_64 (splt
->owner
, value
, splt
->contents
+ dyn_h
->plt_offset
+ 0x8);
1935 /* Create a dynamic IPLT relocation for this entry.
1937 We are creating a relocation in the output file's PLT section,
1938 which is included within the DLT secton. So we do need to include
1939 the PLT's output_offset in the computation of the relocation's
1941 rel
.r_offset
= (dyn_h
->plt_offset
+ splt
->output_offset
1942 + splt
->output_section
->vma
);
1943 rel
.r_info
= ELF64_R_INFO (h
->dynindx
, R_PARISC_IPLT
);
1946 bfd_elf64_swap_reloca_out (splt
->output_section
->owner
, &rel
,
1947 (((Elf64_External_Rela
*)
1949 + spltrel
->reloc_count
));
1950 spltrel
->reloc_count
++;
1953 /* Initialize an external call stub entry if requested. */
1954 if (dyn_h
&& dyn_h
->want_stub
1955 && elf64_hppa_dynamic_symbol_p (dyn_h
->h
, info
))
1960 /* Install the generic stub template.
1962 We are modifying the contents of the stub section, so we do not
1963 need to include the stub section's output_offset here. */
1964 memcpy (stub
->contents
+ dyn_h
->stub_offset
, plt_stub
, sizeof (plt_stub
));
1966 /* Fix up the first ldd instruction.
1968 We are modifying the contents of the STUB section in memory,
1969 so we do not need to include its output offset in this computation.
1971 Note the plt_offset value is the value of the PLT entry relative to
1972 the start of the PLT section. These instructions will reference
1973 data relative to the value of __gp, which may not necessarily have
1974 the same address as the start of the PLT section.
1976 gp_offset contains the offset of __gp within the PLT section. */
1977 value
= dyn_h
->plt_offset
- hppa_info
->gp_offset
;
1979 insn
= bfd_get_32 (stub
->owner
, stub
->contents
+ dyn_h
->stub_offset
);
1981 insn
|= ((value
& 0x2000) >> 13);
1984 bfd_put_32 (stub
->owner
, (insn
| value
),
1985 stub
->contents
+ dyn_h
->stub_offset
);
1987 /* Fix up the second ldd instruction. */
1988 value
= dyn_h
->plt_offset
- hppa_info
->gp_offset
+ 8;
1990 insn
= bfd_get_32 (stub
->owner
, stub
->contents
+ dyn_h
->stub_offset
+ 8);
1992 insn
|= ((value
& 0x2000) >> 13);
1995 bfd_put_32 (stub
->owner
, (insn
| value
),
1996 stub
->contents
+ dyn_h
->stub_offset
+ 8);
1999 /* Millicode symbols should not be put in the dynamic
2000 symbol table under any circumstances. */
2001 if (ELF_ST_TYPE (sym
->st_info
) == STT_PARISC_MILLI
)
2007 /* The .opd section contains FPTRs for each function this file
2008 exports. Initialize the FPTR entries. */
2011 elf64_hppa_finalize_opd (dyn_h
, data
)
2012 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
2015 struct bfd_link_info
*info
= (struct bfd_link_info
*)data
;
2016 struct elf64_hppa_link_hash_table
*hppa_info
;
2017 struct elf_link_hash_entry
*h
= dyn_h
->h
;
2021 hppa_info
= elf64_hppa_hash_table (info
);
2022 sopd
= hppa_info
->opd_sec
;
2023 sopdrel
= hppa_info
->opd_rel_sec
;
2025 if (h
&& dyn_h
&& dyn_h
->want_opd
)
2029 /* The first two words of an .opd entry are zero.
2031 We are modifying the contents of the OPD section in memory, so we
2032 do not need to include its output offset in this computation. */
2033 memset (sopd
->contents
+ dyn_h
->opd_offset
, 0, 16);
2035 value
= (h
->root
.u
.def
.value
2036 + h
->root
.u
.def
.section
->output_section
->vma
2037 + h
->root
.u
.def
.section
->output_offset
);
2039 /* The next word is the address of the function. */
2040 bfd_put_64 (sopd
->owner
, value
, sopd
->contents
+ dyn_h
->opd_offset
+ 16);
2042 /* The last word is our local __gp value. */
2043 value
= _bfd_get_gp_value (sopd
->output_section
->owner
);
2044 bfd_put_64 (sopd
->owner
, value
, sopd
->contents
+ dyn_h
->opd_offset
+ 24);
2047 /* If we are generating a shared library, we must generate EPLT relocations
2048 for each entry in the .opd, even for static functions (they may have
2049 had their address taken). */
2050 if (info
->shared
&& dyn_h
&& dyn_h
->want_opd
)
2052 Elf64_Internal_Rela rel
;
2055 /* We may need to do a relocation against a local symbol, in
2056 which case we have to look up it's dynamic symbol index off
2057 the local symbol hash table. */
2058 if (h
&& h
->dynindx
!= -1)
2059 dynindx
= h
->dynindx
;
2062 = _bfd_elf_link_lookup_local_dynindx (info
, dyn_h
->owner
,
2065 /* The offset of this relocation is the absolute address of the
2066 .opd entry for this symbol. */
2067 rel
.r_offset
= (dyn_h
->opd_offset
+ sopd
->output_offset
2068 + sopd
->output_section
->vma
);
2070 /* If H is non-null, then we have an external symbol.
2072 It is imperative that we use a different dynamic symbol for the
2073 EPLT relocation if the symbol has global scope.
2075 In the dynamic symbol table, the function symbol will have a value
2076 which is address of the function's .opd entry.
2078 Thus, we can not use that dynamic symbol for the EPLT relocation
2079 (if we did, the data in the .opd would reference itself rather
2080 than the actual address of the function). Instead we have to use
2081 a new dynamic symbol which has the same value as the original global
2084 We prefix the original symbol with a "." and use the new symbol in
2085 the EPLT relocation. This new symbol has already been recorded in
2086 the symbol table, we just have to look it up and use it.
2088 We do not have such problems with static functions because we do
2089 not make their addresses in the dynamic symbol table point to
2090 the .opd entry. Ultimately this should be safe since a static
2091 function can not be directly referenced outside of its shared
2094 We do have to play similar games for FPTR relocations in shared
2095 libraries, including those for static symbols. See the FPTR
2096 handling in elf64_hppa_finalize_dynreloc. */
2100 struct elf_link_hash_entry
*nh
;
2102 new_name
= alloca (strlen (h
->root
.root
.string
) + 2);
2104 strcpy (new_name
+ 1, h
->root
.root
.string
);
2106 nh
= elf_link_hash_lookup (elf_hash_table (info
),
2107 new_name
, false, false, false);
2109 /* All we really want from the new symbol is its dynamic
2111 dynindx
= nh
->dynindx
;
2115 rel
.r_info
= ELF64_R_INFO (dynindx
, R_PARISC_EPLT
);
2117 bfd_elf64_swap_reloca_out (sopd
->output_section
->owner
, &rel
,
2118 (((Elf64_External_Rela
*)
2120 + sopdrel
->reloc_count
));
2121 sopdrel
->reloc_count
++;
2126 /* The .dlt section contains addresses for items referenced through the
2127 dlt. Note that we can have a DLTIND relocation for a local symbol, thus
2128 we can not depend on finish_dynamic_symbol to initialize the .dlt. */
2131 elf64_hppa_finalize_dlt (dyn_h
, data
)
2132 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
2135 struct bfd_link_info
*info
= (struct bfd_link_info
*)data
;
2136 struct elf64_hppa_link_hash_table
*hppa_info
;
2137 asection
*sdlt
, *sdltrel
;
2138 struct elf_link_hash_entry
*h
= dyn_h
->h
;
2140 hppa_info
= elf64_hppa_hash_table (info
);
2142 sdlt
= hppa_info
->dlt_sec
;
2143 sdltrel
= hppa_info
->dlt_rel_sec
;
2145 /* H/DYN_H may refer to a local variable and we know it's
2146 address, so there is no need to create a relocation. Just install
2147 the proper value into the DLT, note this shortcut can not be
2148 skipped when building a shared library. */
2149 if (! info
->shared
&& h
&& dyn_h
&& dyn_h
->want_dlt
)
2153 /* If we had an LTOFF_FPTR style relocation we want the DLT entry
2154 to point to the FPTR entry in the .opd section.
2156 We include the OPD's output offset in this computation as
2157 we are referring to an absolute address in the resulting
2159 if (dyn_h
->want_opd
)
2161 value
= (dyn_h
->opd_offset
2162 + hppa_info
->opd_sec
->output_offset
2163 + hppa_info
->opd_sec
->output_section
->vma
);
2167 value
= (h
->root
.u
.def
.value
2168 + h
->root
.u
.def
.section
->output_offset
);
2170 if (h
->root
.u
.def
.section
->output_section
)
2171 value
+= h
->root
.u
.def
.section
->output_section
->vma
;
2173 value
+= h
->root
.u
.def
.section
->vma
;
2176 /* We do not need to include the output offset of the DLT section
2177 here because we are modifying the in-memory contents. */
2178 bfd_put_64 (sdlt
->owner
, value
, sdlt
->contents
+ dyn_h
->dlt_offset
);
2181 /* Create a relocation for the DLT entry assocated with this symbol.
2182 When building a shared library the symbol does not have to be dynamic. */
2184 && (elf64_hppa_dynamic_symbol_p (dyn_h
->h
, info
) || info
->shared
))
2186 Elf64_Internal_Rela rel
;
2189 /* We may need to do a relocation against a local symbol, in
2190 which case we have to look up it's dynamic symbol index off
2191 the local symbol hash table. */
2192 if (h
&& h
->dynindx
!= -1)
2193 dynindx
= h
->dynindx
;
2196 = _bfd_elf_link_lookup_local_dynindx (info
, dyn_h
->owner
,
2200 /* Create a dynamic relocation for this entry. Do include the output
2201 offset of the DLT entry since we need an absolute address in the
2202 resulting object file. */
2203 rel
.r_offset
= (dyn_h
->dlt_offset
+ sdlt
->output_offset
2204 + sdlt
->output_section
->vma
);
2205 if (h
&& h
->type
== STT_FUNC
)
2206 rel
.r_info
= ELF64_R_INFO (dynindx
, R_PARISC_FPTR64
);
2208 rel
.r_info
= ELF64_R_INFO (dynindx
, R_PARISC_DIR64
);
2211 bfd_elf64_swap_reloca_out (sdlt
->output_section
->owner
, &rel
,
2212 (((Elf64_External_Rela
*)
2214 + sdltrel
->reloc_count
));
2215 sdltrel
->reloc_count
++;
2220 /* Finalize the dynamic relocations. Specifically the FPTR relocations
2221 for dynamic functions used to initialize static data. */
2224 elf64_hppa_finalize_dynreloc (dyn_h
, data
)
2225 struct elf64_hppa_dyn_hash_entry
*dyn_h
;
2228 struct bfd_link_info
*info
= (struct bfd_link_info
*)data
;
2229 struct elf64_hppa_link_hash_table
*hppa_info
;
2230 struct elf_link_hash_entry
*h
;
2233 dynamic_symbol
= elf64_hppa_dynamic_symbol_p (dyn_h
->h
, info
);
2235 if (!dynamic_symbol
&& !info
->shared
)
2238 if (dyn_h
->reloc_entries
)
2240 struct elf64_hppa_dyn_reloc_entry
*rent
;
2243 hppa_info
= elf64_hppa_hash_table (info
);
2246 /* We may need to do a relocation against a local symbol, in
2247 which case we have to look up it's dynamic symbol index off
2248 the local symbol hash table. */
2249 if (h
&& h
->dynindx
!= -1)
2250 dynindx
= h
->dynindx
;
2253 = _bfd_elf_link_lookup_local_dynindx (info
, dyn_h
->owner
,
2256 for (rent
= dyn_h
->reloc_entries
; rent
; rent
= rent
->next
)
2258 Elf64_Internal_Rela rel
;
2262 case R_PARISC_FPTR64
:
2263 /* Allocate one iff we are not building a shared library and
2264 !want_opd, which by this point will be true only if we're
2265 actually allocating one statically in the main executable. */
2266 if (!info
->shared
&& dyn_h
->want_opd
)
2271 /* Create a dynamic relocation for this entry.
2273 We need the output offset for the reloc's section because
2274 we are creating an absolute address in the resulting object
2276 rel
.r_offset
= (rent
->offset
+ rent
->sec
->output_offset
2277 + rent
->sec
->output_section
->vma
);
2279 /* An FPTR64 relocation implies that we took the address of
2280 a function and that the function has an entry in the .opd
2281 section. We want the FPTR64 relocation to reference the
2284 We could munge the symbol value in the dynamic symbol table
2285 (in fact we already do for functions with global scope) to point
2286 to the .opd entry. Then we could use that dynamic symbol in
2289 Or we could do something sensible, not munge the symbol's
2290 address and instead just use a different symbol to reference
2291 the .opd entry. At least that seems sensible until you
2292 realize there's no local dynamic symbols we can use for that
2293 purpose. Thus the hair in the check_relocs routine.
2295 We use a section symbol recorded by check_relocs as the
2296 base symbol for the relocation. The addend is the difference
2297 between the section symbol and the address of the .opd entry. */
2298 if (info
->shared
&& rent
->type
== R_PARISC_FPTR64
)
2300 bfd_vma value
, value2
;
2302 /* First compute the address of the opd entry for this symbol. */
2303 value
= (dyn_h
->opd_offset
2304 + hppa_info
->opd_sec
->output_section
->vma
2305 + hppa_info
->opd_sec
->output_offset
);
2307 /* Compute the value of the start of the section with
2309 value2
= (rent
->sec
->output_section
->vma
2310 + rent
->sec
->output_offset
);
2312 /* Compute the difference between the start of the section
2313 with the relocation and the opd entry. */
2316 /* The result becomes the addend of the relocation. */
2317 rel
.r_addend
= value
;
2319 /* The section symbol becomes the symbol for the dynamic
2322 = _bfd_elf_link_lookup_local_dynindx (info
,
2327 rel
.r_addend
= rent
->addend
;
2329 rel
.r_info
= ELF64_R_INFO (dynindx
, rent
->type
);
2331 bfd_elf64_swap_reloca_out (hppa_info
->other_rel_sec
->output_section
->owner
,
2333 (((Elf64_External_Rela
*)
2334 hppa_info
->other_rel_sec
->contents
)
2335 + hppa_info
->other_rel_sec
->reloc_count
));
2336 hppa_info
->other_rel_sec
->reloc_count
++;
2343 /* Finish up the dynamic sections. */
2346 elf64_hppa_finish_dynamic_sections (output_bfd
, info
)
2348 struct bfd_link_info
*info
;
2352 struct elf64_hppa_link_hash_table
*hppa_info
;
2354 hppa_info
= elf64_hppa_hash_table (info
);
2356 /* Finalize the contents of the .opd section. */
2357 elf64_hppa_dyn_hash_traverse (&hppa_info
->dyn_hash_table
,
2358 elf64_hppa_finalize_opd
,
2361 elf64_hppa_dyn_hash_traverse (&hppa_info
->dyn_hash_table
,
2362 elf64_hppa_finalize_dynreloc
,
2365 /* Finalize the contents of the .dlt section. */
2366 dynobj
= elf_hash_table (info
)->dynobj
;
2367 /* Finalize the contents of the .dlt section. */
2368 elf64_hppa_dyn_hash_traverse (&hppa_info
->dyn_hash_table
,
2369 elf64_hppa_finalize_dlt
,
2373 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2375 if (elf_hash_table (info
)->dynamic_sections_created
)
2377 Elf64_External_Dyn
*dyncon
, *dynconend
;
2379 BFD_ASSERT (sdyn
!= NULL
);
2381 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
2382 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
2383 for (; dyncon
< dynconend
; dyncon
++)
2385 Elf_Internal_Dyn dyn
;
2388 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2395 case DT_HP_LOAD_MAP
:
2396 /* Compute the absolute address of 16byte scratchpad area
2397 for the dynamic linker.
2399 By convention the linker script will allocate the scratchpad
2400 area at the start of the .data section. So all we have to
2401 to is find the start of the .data section. */
2402 s
= bfd_get_section_by_name (output_bfd
, ".data");
2403 dyn
.d_un
.d_ptr
= s
->vma
;
2404 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2408 /* HP's use PLTGOT to set the GOT register. */
2409 dyn
.d_un
.d_ptr
= _bfd_get_gp_value (output_bfd
);
2410 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2414 s
= hppa_info
->plt_rel_sec
;
2415 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2416 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2420 s
= hppa_info
->plt_rel_sec
;
2421 dyn
.d_un
.d_val
= s
->_raw_size
;
2422 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2426 s
= hppa_info
->other_rel_sec
;
2428 s
= hppa_info
->dlt_rel_sec
;
2429 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2430 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2434 s
= hppa_info
->other_rel_sec
;
2435 dyn
.d_un
.d_val
= s
->_raw_size
;
2436 s
= hppa_info
->dlt_rel_sec
;
2437 dyn
.d_un
.d_val
+= s
->_raw_size
;
2438 s
= hppa_info
->opd_rel_sec
;
2439 dyn
.d_un
.d_val
+= s
->_raw_size
;
2440 /* There is some question about whether or not the size of
2441 the PLT relocs should be included here. HP's tools do
2442 it, so we'll emulate them. */
2443 s
= hppa_info
->plt_rel_sec
;
2444 dyn
.d_un
.d_val
+= s
->_raw_size
;
2445 bfd_elf64_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2456 /* Return the number of additional phdrs we will need.
2458 The generic ELF code only creates PT_PHDRs for executables. The HP
2459 dynamic linker requires PT_PHDRs for dynamic libraries too.
2461 This routine indicates that the backend needs one additional program
2462 header for that case.
2464 Note we do not have access to the link info structure here, so we have
2465 to guess whether or not we are building a shared library based on the
2466 existence of a .interp section. */
2469 elf64_hppa_additional_program_headers (abfd
)
2474 /* If we are creating a shared library, then we have to create a
2475 PT_PHDR segment. HP's dynamic linker chokes without it. */
2476 s
= bfd_get_section_by_name (abfd
, ".interp");
2482 /* Allocate and initialize any program headers required by this
2485 The generic ELF code only creates PT_PHDRs for executables. The HP
2486 dynamic linker requires PT_PHDRs for dynamic libraries too.
2488 This allocates the PT_PHDR and initializes it in a manner suitable
2491 Note we do not have access to the link info structure here, so we have
2492 to guess whether or not we are building a shared library based on the
2493 existence of a .interp section. */
2496 elf64_hppa_modify_segment_map (abfd
)
2499 struct elf_segment_map
*m
;
2502 s
= bfd_get_section_by_name (abfd
, ".interp");
2505 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2506 if (m
->p_type
== PT_PHDR
)
2510 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, sizeof *m
);
2514 m
->p_type
= PT_PHDR
;
2515 m
->p_flags
= PF_R
| PF_X
;
2516 m
->p_flags_valid
= 1;
2517 m
->p_paddr_valid
= 1;
2518 m
->includes_phdrs
= 1;
2520 m
->next
= elf_tdata (abfd
)->segment_map
;
2521 elf_tdata (abfd
)->segment_map
= m
;
2525 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
2526 if (m
->p_type
== PT_LOAD
)
2530 for (i
= 0; i
< m
->count
; i
++)
2532 /* The code "hint" is not really a hint. It is a requirement
2533 for certain versions of the HP dynamic linker. Worse yet,
2534 it must be set even if the shared library does not have
2535 any code in its "text" segment (thus the check for .hash
2536 to catch this situation). */
2537 if (m
->sections
[i
]->flags
& SEC_CODE
2538 || (strcmp (m
->sections
[i
]->name
, ".hash") == 0))
2539 m
->p_flags
|= (PF_X
| PF_HP_CODE
);
2546 /* The hash bucket size is the standard one, namely 4. */
2548 const struct elf_size_info hppa64_elf_size_info
=
2550 sizeof (Elf64_External_Ehdr
),
2551 sizeof (Elf64_External_Phdr
),
2552 sizeof (Elf64_External_Shdr
),
2553 sizeof (Elf64_External_Rel
),
2554 sizeof (Elf64_External_Rela
),
2555 sizeof (Elf64_External_Sym
),
2556 sizeof (Elf64_External_Dyn
),
2557 sizeof (Elf_External_Note
),
2561 ELFCLASS64
, EV_CURRENT
,
2562 bfd_elf64_write_out_phdrs
,
2563 bfd_elf64_write_shdrs_and_ehdr
,
2564 bfd_elf64_write_relocs
,
2565 bfd_elf64_swap_symbol_out
,
2566 bfd_elf64_slurp_reloc_table
,
2567 bfd_elf64_slurp_symbol_table
,
2568 bfd_elf64_swap_dyn_in
,
2569 bfd_elf64_swap_dyn_out
,
2576 #define TARGET_BIG_SYM bfd_elf64_hppa_vec
2577 #define TARGET_BIG_NAME "elf64-hppa"
2578 #define ELF_ARCH bfd_arch_hppa
2579 #define ELF_MACHINE_CODE EM_PARISC
2580 /* This is not strictly correct. The maximum page size for PA2.0 is
2581 64M. But everything still uses 4k. */
2582 #define ELF_MAXPAGESIZE 0x1000
2583 #define bfd_elf64_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
2584 #define bfd_elf64_bfd_is_local_label_name elf_hppa_is_local_label_name
2585 #define elf_info_to_howto elf_hppa_info_to_howto
2586 #define elf_info_to_howto_rel elf_hppa_info_to_howto_rel
2588 #define elf_backend_section_from_shdr elf64_hppa_section_from_shdr
2589 #define elf_backend_object_p elf64_hppa_object_p
2590 #define elf_backend_final_write_processing \
2591 elf_hppa_final_write_processing
2592 #define elf_backend_fake_sections elf_hppa_fake_sections
2593 #define elf_backend_add_symbol_hook elf_hppa_add_symbol_hook
2595 #define elf_backend_relocate_section elf_hppa_relocate_section
2597 #define bfd_elf64_bfd_final_link elf_hppa_final_link
2599 #define elf_backend_create_dynamic_sections \
2600 elf64_hppa_create_dynamic_sections
2601 #define elf_backend_post_process_headers elf64_hppa_post_process_headers
2603 #define elf_backend_adjust_dynamic_symbol \
2604 elf64_hppa_adjust_dynamic_symbol
2606 #define elf_backend_size_dynamic_sections \
2607 elf64_hppa_size_dynamic_sections
2609 #define elf_backend_finish_dynamic_symbol \
2610 elf64_hppa_finish_dynamic_symbol
2611 #define elf_backend_finish_dynamic_sections \
2612 elf64_hppa_finish_dynamic_sections
2614 /* Stuff for the BFD linker: */
2615 #define bfd_elf64_bfd_link_hash_table_create \
2616 elf64_hppa_hash_table_create
2618 #define elf_backend_check_relocs \
2619 elf64_hppa_check_relocs
2621 #define elf_backend_size_info \
2622 hppa64_elf_size_info
2624 #define elf_backend_additional_program_headers \
2625 elf64_hppa_additional_program_headers
2627 #define elf_backend_modify_segment_map \
2628 elf64_hppa_modify_segment_map
2630 #define elf_backend_link_output_symbol_hook \
2631 elf64_hppa_link_output_symbol_hook
2634 #define elf_backend_want_got_plt 0
2635 #define elf_backend_plt_readonly 0
2636 #define elf_backend_want_plt_sym 0
2637 #define elf_backend_got_header_size 0
2638 #define elf_backend_plt_header_size 0
2639 #define elf_backend_type_change_ok true
2641 #include "elf64-target.h"