daily update
[binutils.git] / bfd / elf64-hppa.c
blobfbd64584d1db6b2cc532919ddab0531f96b1503a
1 /* Support for HPPA 64-bit ELF
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
21 #include "alloca-conf.h"
22 #include "bfd.h"
23 #include "sysdep.h"
24 #include "libbfd.h"
25 #include "elf-bfd.h"
26 #include "elf/hppa.h"
27 #include "libhppa.h"
28 #include "elf64-hppa.h"
29 #define ARCH_SIZE 64
31 #define PLT_ENTRY_SIZE 0x10
32 #define DLT_ENTRY_SIZE 0x8
33 #define OPD_ENTRY_SIZE 0x20
35 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/pa20_64/dld.sl"
37 /* The stub is supposed to load the target address and target's DP
38 value out of the PLT, then do an external branch to the target
39 address.
41 LDD PLTOFF(%r27),%r1
42 BVE (%r1)
43 LDD PLTOFF+8(%r27),%r27
45 Note that we must use the LDD with a 14 bit displacement, not the one
46 with a 5 bit displacement. */
47 static char plt_stub[] = {0x53, 0x61, 0x00, 0x00, 0xe8, 0x20, 0xd0, 0x00,
48 0x53, 0x7b, 0x00, 0x00 };
50 struct elf64_hppa_dyn_hash_entry
52 struct bfd_hash_entry root;
54 /* Offsets for this symbol in various linker sections. */
55 bfd_vma dlt_offset;
56 bfd_vma plt_offset;
57 bfd_vma opd_offset;
58 bfd_vma stub_offset;
60 /* The symbol table entry, if any, that this was derived from. */
61 struct elf_link_hash_entry *h;
63 /* The index of the (possibly local) symbol in the input bfd and its
64 associated BFD. Needed so that we can have relocs against local
65 symbols in shared libraries. */
66 long sym_indx;
67 bfd *owner;
69 /* Dynamic symbols may need to have two different values. One for
70 the dynamic symbol table, one for the normal symbol table.
72 In such cases we store the symbol's real value and section
73 index here so we can restore the real value before we write
74 the normal symbol table. */
75 bfd_vma st_value;
76 int st_shndx;
78 /* Used to count non-got, non-plt relocations for delayed sizing
79 of relocation sections. */
80 struct elf64_hppa_dyn_reloc_entry
82 /* Next relocation in the chain. */
83 struct elf64_hppa_dyn_reloc_entry *next;
85 /* The type of the relocation. */
86 int type;
88 /* The input section of the relocation. */
89 asection *sec;
91 /* The index of the section symbol for the input section of
92 the relocation. Only needed when building shared libraries. */
93 int sec_symndx;
95 /* The offset within the input section of the relocation. */
96 bfd_vma offset;
98 /* The addend for the relocation. */
99 bfd_vma addend;
101 } *reloc_entries;
103 /* Nonzero if this symbol needs an entry in one of the linker
104 sections. */
105 unsigned want_dlt;
106 unsigned want_plt;
107 unsigned want_opd;
108 unsigned want_stub;
111 struct elf64_hppa_dyn_hash_table
113 struct bfd_hash_table root;
116 struct elf64_hppa_link_hash_table
118 struct elf_link_hash_table root;
120 /* Shortcuts to get to the various linker defined sections. */
121 asection *dlt_sec;
122 asection *dlt_rel_sec;
123 asection *plt_sec;
124 asection *plt_rel_sec;
125 asection *opd_sec;
126 asection *opd_rel_sec;
127 asection *other_rel_sec;
129 /* Offset of __gp within .plt section. When the PLT gets large we want
130 to slide __gp into the PLT section so that we can continue to use
131 single DP relative instructions to load values out of the PLT. */
132 bfd_vma gp_offset;
134 /* Note this is not strictly correct. We should create a stub section for
135 each input section with calls. The stub section should be placed before
136 the section with the call. */
137 asection *stub_sec;
139 bfd_vma text_segment_base;
140 bfd_vma data_segment_base;
142 struct elf64_hppa_dyn_hash_table dyn_hash_table;
144 /* We build tables to map from an input section back to its
145 symbol index. This is the BFD for which we currently have
146 a map. */
147 bfd *section_syms_bfd;
149 /* Array of symbol numbers for each input section attached to the
150 current BFD. */
151 int *section_syms;
154 #define elf64_hppa_hash_table(p) \
155 ((struct elf64_hppa_link_hash_table *) ((p)->hash))
157 typedef struct bfd_hash_entry *(*new_hash_entry_func)
158 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
160 static bfd_boolean elf64_hppa_dyn_hash_table_init
161 PARAMS ((struct elf64_hppa_dyn_hash_table *ht, bfd *abfd,
162 new_hash_entry_func new));
163 static struct bfd_hash_entry *elf64_hppa_new_dyn_hash_entry
164 PARAMS ((struct bfd_hash_entry *entry, struct bfd_hash_table *table,
165 const char *string));
166 static struct bfd_link_hash_table *elf64_hppa_hash_table_create
167 PARAMS ((bfd *abfd));
168 static struct elf64_hppa_dyn_hash_entry *elf64_hppa_dyn_hash_lookup
169 PARAMS ((struct elf64_hppa_dyn_hash_table *table, const char *string,
170 bfd_boolean create, bfd_boolean copy));
171 static void elf64_hppa_dyn_hash_traverse
172 PARAMS ((struct elf64_hppa_dyn_hash_table *table,
173 bfd_boolean (*func) (struct elf64_hppa_dyn_hash_entry *, PTR),
174 PTR info));
176 static const char *get_dyn_name
177 PARAMS ((bfd *, struct elf_link_hash_entry *,
178 const Elf_Internal_Rela *, char **, size_t *));
180 /* This must follow the definitions of the various derived linker
181 hash tables and shared functions. */
182 #include "elf-hppa.h"
184 static bfd_boolean elf64_hppa_object_p
185 PARAMS ((bfd *));
187 static void elf64_hppa_post_process_headers
188 PARAMS ((bfd *, struct bfd_link_info *));
190 static bfd_boolean elf64_hppa_create_dynamic_sections
191 PARAMS ((bfd *, struct bfd_link_info *));
193 static bfd_boolean elf64_hppa_adjust_dynamic_symbol
194 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
196 static bfd_boolean elf64_hppa_mark_milli_and_exported_functions
197 PARAMS ((struct elf_link_hash_entry *, PTR));
199 static bfd_boolean elf64_hppa_size_dynamic_sections
200 PARAMS ((bfd *, struct bfd_link_info *));
202 static bfd_boolean elf64_hppa_link_output_symbol_hook
203 PARAMS ((struct bfd_link_info *, const char *, Elf_Internal_Sym *,
204 asection *, struct elf_link_hash_entry *));
206 static bfd_boolean elf64_hppa_finish_dynamic_symbol
207 PARAMS ((bfd *, struct bfd_link_info *,
208 struct elf_link_hash_entry *, Elf_Internal_Sym *));
210 static int elf64_hppa_additional_program_headers
211 PARAMS ((bfd *));
213 static bfd_boolean elf64_hppa_modify_segment_map
214 PARAMS ((bfd *, struct bfd_link_info *));
216 static enum elf_reloc_type_class elf64_hppa_reloc_type_class
217 PARAMS ((const Elf_Internal_Rela *));
219 static bfd_boolean elf64_hppa_finish_dynamic_sections
220 PARAMS ((bfd *, struct bfd_link_info *));
222 static bfd_boolean elf64_hppa_check_relocs
223 PARAMS ((bfd *, struct bfd_link_info *,
224 asection *, const Elf_Internal_Rela *));
226 static bfd_boolean elf64_hppa_dynamic_symbol_p
227 PARAMS ((struct elf_link_hash_entry *, struct bfd_link_info *));
229 static bfd_boolean elf64_hppa_mark_exported_functions
230 PARAMS ((struct elf_link_hash_entry *, PTR));
232 static bfd_boolean elf64_hppa_finalize_opd
233 PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
235 static bfd_boolean elf64_hppa_finalize_dlt
236 PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
238 static bfd_boolean allocate_global_data_dlt
239 PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
241 static bfd_boolean allocate_global_data_plt
242 PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
244 static bfd_boolean allocate_global_data_stub
245 PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
247 static bfd_boolean allocate_global_data_opd
248 PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
250 static bfd_boolean get_reloc_section
251 PARAMS ((bfd *, struct elf64_hppa_link_hash_table *, asection *));
253 static bfd_boolean count_dyn_reloc
254 PARAMS ((bfd *, struct elf64_hppa_dyn_hash_entry *,
255 int, asection *, int, bfd_vma, bfd_vma));
257 static bfd_boolean allocate_dynrel_entries
258 PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
260 static bfd_boolean elf64_hppa_finalize_dynreloc
261 PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
263 static bfd_boolean get_opd
264 PARAMS ((bfd *, struct bfd_link_info *, struct elf64_hppa_link_hash_table *));
266 static bfd_boolean get_plt
267 PARAMS ((bfd *, struct bfd_link_info *, struct elf64_hppa_link_hash_table *));
269 static bfd_boolean get_dlt
270 PARAMS ((bfd *, struct bfd_link_info *, struct elf64_hppa_link_hash_table *));
272 static bfd_boolean get_stub
273 PARAMS ((bfd *, struct bfd_link_info *, struct elf64_hppa_link_hash_table *));
275 static int elf64_hppa_elf_get_symbol_type
276 PARAMS ((Elf_Internal_Sym *, int));
278 static bfd_boolean
279 elf64_hppa_dyn_hash_table_init (ht, abfd, new)
280 struct elf64_hppa_dyn_hash_table *ht;
281 bfd *abfd ATTRIBUTE_UNUSED;
282 new_hash_entry_func new;
284 memset (ht, 0, sizeof (*ht));
285 return bfd_hash_table_init (&ht->root, new);
288 static struct bfd_hash_entry*
289 elf64_hppa_new_dyn_hash_entry (entry, table, string)
290 struct bfd_hash_entry *entry;
291 struct bfd_hash_table *table;
292 const char *string;
294 struct elf64_hppa_dyn_hash_entry *ret;
295 ret = (struct elf64_hppa_dyn_hash_entry *) entry;
297 /* Allocate the structure if it has not already been allocated by a
298 subclass. */
299 if (!ret)
300 ret = bfd_hash_allocate (table, sizeof (*ret));
302 if (!ret)
303 return 0;
305 /* Call the allocation method of the superclass. */
306 ret = ((struct elf64_hppa_dyn_hash_entry *)
307 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
309 /* Initialize our local data. All zeros. */
310 memset (&ret->dlt_offset, 0,
311 (sizeof (struct elf64_hppa_dyn_hash_entry)
312 - offsetof (struct elf64_hppa_dyn_hash_entry, dlt_offset)));
314 return &ret->root;
317 /* Create the derived linker hash table. The PA64 ELF port uses this
318 derived hash table to keep information specific to the PA ElF
319 linker (without using static variables). */
321 static struct bfd_link_hash_table*
322 elf64_hppa_hash_table_create (abfd)
323 bfd *abfd;
325 struct elf64_hppa_link_hash_table *ret;
327 ret = bfd_zalloc (abfd, (bfd_size_type) sizeof (*ret));
328 if (!ret)
329 return 0;
330 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
331 _bfd_elf_link_hash_newfunc))
333 bfd_release (abfd, ret);
334 return 0;
337 if (!elf64_hppa_dyn_hash_table_init (&ret->dyn_hash_table, abfd,
338 elf64_hppa_new_dyn_hash_entry))
339 return 0;
340 return &ret->root.root;
343 /* Look up an entry in a PA64 ELF linker hash table. */
345 static struct elf64_hppa_dyn_hash_entry *
346 elf64_hppa_dyn_hash_lookup(table, string, create, copy)
347 struct elf64_hppa_dyn_hash_table *table;
348 const char *string;
349 bfd_boolean create, copy;
351 return ((struct elf64_hppa_dyn_hash_entry *)
352 bfd_hash_lookup (&table->root, string, create, copy));
355 /* Traverse a PA64 ELF linker hash table. */
357 static void
358 elf64_hppa_dyn_hash_traverse (table, func, info)
359 struct elf64_hppa_dyn_hash_table *table;
360 bfd_boolean (*func) PARAMS ((struct elf64_hppa_dyn_hash_entry *, PTR));
361 PTR info;
363 (bfd_hash_traverse
364 (&table->root,
365 (bfd_boolean (*) PARAMS ((struct bfd_hash_entry *, PTR))) func,
366 info));
369 /* Return nonzero if ABFD represents a PA2.0 ELF64 file.
371 Additionally we set the default architecture and machine. */
372 static bfd_boolean
373 elf64_hppa_object_p (abfd)
374 bfd *abfd;
376 Elf_Internal_Ehdr * i_ehdrp;
377 unsigned int flags;
379 i_ehdrp = elf_elfheader (abfd);
380 if (strcmp (bfd_get_target (abfd), "elf64-hppa-linux") == 0)
382 /* GCC on hppa-linux produces binaries with OSABI=Linux,
383 but the kernel produces corefiles with OSABI=SysV. */
384 if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_LINUX
385 && i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */
386 return FALSE;
388 else
390 /* HPUX produces binaries with OSABI=HPUX,
391 but the kernel produces corefiles with OSABI=SysV. */
392 if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_HPUX
393 && i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */
394 return FALSE;
397 flags = i_ehdrp->e_flags;
398 switch (flags & (EF_PARISC_ARCH | EF_PARISC_WIDE))
400 case EFA_PARISC_1_0:
401 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 10);
402 case EFA_PARISC_1_1:
403 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 11);
404 case EFA_PARISC_2_0:
405 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
406 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25);
407 else
408 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 20);
409 case EFA_PARISC_2_0 | EF_PARISC_WIDE:
410 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25);
412 /* Don't be fussy. */
413 return TRUE;
416 /* Given section type (hdr->sh_type), return a boolean indicating
417 whether or not the section is an elf64-hppa specific section. */
418 static bfd_boolean
419 elf64_hppa_section_from_shdr (bfd *abfd,
420 Elf_Internal_Shdr *hdr,
421 const char *name,
422 int shindex)
424 asection *newsect;
426 switch (hdr->sh_type)
428 case SHT_PARISC_EXT:
429 if (strcmp (name, ".PARISC.archext") != 0)
430 return FALSE;
431 break;
432 case SHT_PARISC_UNWIND:
433 if (strcmp (name, ".PARISC.unwind") != 0)
434 return FALSE;
435 break;
436 case SHT_PARISC_DOC:
437 case SHT_PARISC_ANNOT:
438 default:
439 return FALSE;
442 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
443 return FALSE;
444 newsect = hdr->bfd_section;
446 return TRUE;
449 /* Construct a string for use in the elf64_hppa_dyn_hash_table. The
450 name describes what was once potentially anonymous memory. We
451 allocate memory as necessary, possibly reusing PBUF/PLEN. */
453 static const char *
454 get_dyn_name (abfd, h, rel, pbuf, plen)
455 bfd *abfd;
456 struct elf_link_hash_entry *h;
457 const Elf_Internal_Rela *rel;
458 char **pbuf;
459 size_t *plen;
461 asection *sec = abfd->sections;
462 size_t nlen, tlen;
463 char *buf;
464 size_t len;
466 if (h && rel->r_addend == 0)
467 return h->root.root.string;
469 if (h)
470 nlen = strlen (h->root.root.string);
471 else
472 nlen = 8 + 1 + sizeof (rel->r_info) * 2 - 8;
473 tlen = nlen + 1 + sizeof (rel->r_addend) * 2 + 1;
475 len = *plen;
476 buf = *pbuf;
477 if (len < tlen)
479 if (buf)
480 free (buf);
481 *pbuf = buf = malloc (tlen);
482 *plen = len = tlen;
483 if (!buf)
484 return NULL;
487 if (h)
489 memcpy (buf, h->root.root.string, nlen);
490 buf[nlen++] = '+';
491 sprintf_vma (buf + nlen, rel->r_addend);
493 else
495 nlen = sprintf (buf, "%x:%lx",
496 sec->id & 0xffffffff,
497 (long) ELF64_R_SYM (rel->r_info));
498 if (rel->r_addend)
500 buf[nlen++] = '+';
501 sprintf_vma (buf + nlen, rel->r_addend);
505 return buf;
508 /* SEC is a section containing relocs for an input BFD when linking; return
509 a suitable section for holding relocs in the output BFD for a link. */
511 static bfd_boolean
512 get_reloc_section (abfd, hppa_info, sec)
513 bfd *abfd;
514 struct elf64_hppa_link_hash_table *hppa_info;
515 asection *sec;
517 const char *srel_name;
518 asection *srel;
519 bfd *dynobj;
521 srel_name = (bfd_elf_string_from_elf_section
522 (abfd, elf_elfheader(abfd)->e_shstrndx,
523 elf_section_data(sec)->rel_hdr.sh_name));
524 if (srel_name == NULL)
525 return FALSE;
527 BFD_ASSERT ((strncmp (srel_name, ".rela", 5) == 0
528 && strcmp (bfd_get_section_name (abfd, sec),
529 srel_name+5) == 0)
530 || (strncmp (srel_name, ".rel", 4) == 0
531 && strcmp (bfd_get_section_name (abfd, sec),
532 srel_name+4) == 0));
534 dynobj = hppa_info->root.dynobj;
535 if (!dynobj)
536 hppa_info->root.dynobj = dynobj = abfd;
538 srel = bfd_get_section_by_name (dynobj, srel_name);
539 if (srel == NULL)
541 srel = bfd_make_section_with_flags (dynobj, srel_name,
542 (SEC_ALLOC
543 | SEC_LOAD
544 | SEC_HAS_CONTENTS
545 | SEC_IN_MEMORY
546 | SEC_LINKER_CREATED
547 | SEC_READONLY));
548 if (srel == NULL
549 || !bfd_set_section_alignment (dynobj, srel, 3))
550 return FALSE;
553 hppa_info->other_rel_sec = srel;
554 return TRUE;
557 /* Add a new entry to the list of dynamic relocations against DYN_H.
559 We use this to keep a record of all the FPTR relocations against a
560 particular symbol so that we can create FPTR relocations in the
561 output file. */
563 static bfd_boolean
564 count_dyn_reloc (abfd, dyn_h, type, sec, sec_symndx, offset, addend)
565 bfd *abfd;
566 struct elf64_hppa_dyn_hash_entry *dyn_h;
567 int type;
568 asection *sec;
569 int sec_symndx;
570 bfd_vma offset;
571 bfd_vma addend;
573 struct elf64_hppa_dyn_reloc_entry *rent;
575 rent = (struct elf64_hppa_dyn_reloc_entry *)
576 bfd_alloc (abfd, (bfd_size_type) sizeof (*rent));
577 if (!rent)
578 return FALSE;
580 rent->next = dyn_h->reloc_entries;
581 rent->type = type;
582 rent->sec = sec;
583 rent->sec_symndx = sec_symndx;
584 rent->offset = offset;
585 rent->addend = addend;
586 dyn_h->reloc_entries = rent;
588 return TRUE;
591 /* Scan the RELOCS and record the type of dynamic entries that each
592 referenced symbol needs. */
594 static bfd_boolean
595 elf64_hppa_check_relocs (abfd, info, sec, relocs)
596 bfd *abfd;
597 struct bfd_link_info *info;
598 asection *sec;
599 const Elf_Internal_Rela *relocs;
601 struct elf64_hppa_link_hash_table *hppa_info;
602 const Elf_Internal_Rela *relend;
603 Elf_Internal_Shdr *symtab_hdr;
604 const Elf_Internal_Rela *rel;
605 asection *dlt, *plt, *stubs;
606 char *buf;
607 size_t buf_len;
608 int sec_symndx;
610 if (info->relocatable)
611 return TRUE;
613 /* If this is the first dynamic object found in the link, create
614 the special sections required for dynamic linking. */
615 if (! elf_hash_table (info)->dynamic_sections_created)
617 if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
618 return FALSE;
621 hppa_info = elf64_hppa_hash_table (info);
622 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
624 /* If necessary, build a new table holding section symbols indices
625 for this BFD. */
627 if (info->shared && hppa_info->section_syms_bfd != abfd)
629 unsigned long i;
630 unsigned int highest_shndx;
631 Elf_Internal_Sym *local_syms = NULL;
632 Elf_Internal_Sym *isym, *isymend;
633 bfd_size_type amt;
635 /* We're done with the old cache of section index to section symbol
636 index information. Free it.
638 ?!? Note we leak the last section_syms array. Presumably we
639 could free it in one of the later routines in this file. */
640 if (hppa_info->section_syms)
641 free (hppa_info->section_syms);
643 /* Read this BFD's local symbols. */
644 if (symtab_hdr->sh_info != 0)
646 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
647 if (local_syms == NULL)
648 local_syms = bfd_elf_get_elf_syms (abfd, symtab_hdr,
649 symtab_hdr->sh_info, 0,
650 NULL, NULL, NULL);
651 if (local_syms == NULL)
652 return FALSE;
655 /* Record the highest section index referenced by the local symbols. */
656 highest_shndx = 0;
657 isymend = local_syms + symtab_hdr->sh_info;
658 for (isym = local_syms; isym < isymend; isym++)
660 if (isym->st_shndx > highest_shndx)
661 highest_shndx = isym->st_shndx;
664 /* Allocate an array to hold the section index to section symbol index
665 mapping. Bump by one since we start counting at zero. */
666 highest_shndx++;
667 amt = highest_shndx;
668 amt *= sizeof (int);
669 hppa_info->section_syms = (int *) bfd_malloc (amt);
671 /* Now walk the local symbols again. If we find a section symbol,
672 record the index of the symbol into the section_syms array. */
673 for (i = 0, isym = local_syms; isym < isymend; i++, isym++)
675 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
676 hppa_info->section_syms[isym->st_shndx] = i;
679 /* We are finished with the local symbols. */
680 if (local_syms != NULL
681 && symtab_hdr->contents != (unsigned char *) local_syms)
683 if (! info->keep_memory)
684 free (local_syms);
685 else
687 /* Cache the symbols for elf_link_input_bfd. */
688 symtab_hdr->contents = (unsigned char *) local_syms;
692 /* Record which BFD we built the section_syms mapping for. */
693 hppa_info->section_syms_bfd = abfd;
696 /* Record the symbol index for this input section. We may need it for
697 relocations when building shared libraries. When not building shared
698 libraries this value is never really used, but assign it to zero to
699 prevent out of bounds memory accesses in other routines. */
700 if (info->shared)
702 sec_symndx = _bfd_elf_section_from_bfd_section (abfd, sec);
704 /* If we did not find a section symbol for this section, then
705 something went terribly wrong above. */
706 if (sec_symndx == -1)
707 return FALSE;
709 sec_symndx = hppa_info->section_syms[sec_symndx];
711 else
712 sec_symndx = 0;
714 dlt = plt = stubs = NULL;
715 buf = NULL;
716 buf_len = 0;
718 relend = relocs + sec->reloc_count;
719 for (rel = relocs; rel < relend; ++rel)
721 enum
723 NEED_DLT = 1,
724 NEED_PLT = 2,
725 NEED_STUB = 4,
726 NEED_OPD = 8,
727 NEED_DYNREL = 16,
730 struct elf_link_hash_entry *h = NULL;
731 unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
732 struct elf64_hppa_dyn_hash_entry *dyn_h;
733 int need_entry;
734 const char *addr_name;
735 bfd_boolean maybe_dynamic;
736 int dynrel_type = R_PARISC_NONE;
737 static reloc_howto_type *howto;
739 if (r_symndx >= symtab_hdr->sh_info)
741 /* We're dealing with a global symbol -- find its hash entry
742 and mark it as being referenced. */
743 long indx = r_symndx - symtab_hdr->sh_info;
744 h = elf_sym_hashes (abfd)[indx];
745 while (h->root.type == bfd_link_hash_indirect
746 || h->root.type == bfd_link_hash_warning)
747 h = (struct elf_link_hash_entry *) h->root.u.i.link;
749 h->ref_regular = 1;
752 /* We can only get preliminary data on whether a symbol is
753 locally or externally defined, as not all of the input files
754 have yet been processed. Do something with what we know, as
755 this may help reduce memory usage and processing time later. */
756 maybe_dynamic = FALSE;
757 if (h && ((info->shared
758 && (!info->symbolic
759 || info->unresolved_syms_in_shared_libs == RM_IGNORE))
760 || !h->def_regular
761 || h->root.type == bfd_link_hash_defweak))
762 maybe_dynamic = TRUE;
764 howto = elf_hppa_howto_table + ELF64_R_TYPE (rel->r_info);
765 need_entry = 0;
766 switch (howto->type)
768 /* These are simple indirect references to symbols through the
769 DLT. We need to create a DLT entry for any symbols which
770 appears in a DLTIND relocation. */
771 case R_PARISC_DLTIND21L:
772 case R_PARISC_DLTIND14R:
773 case R_PARISC_DLTIND14F:
774 case R_PARISC_DLTIND14WR:
775 case R_PARISC_DLTIND14DR:
776 need_entry = NEED_DLT;
777 break;
779 /* ?!? These need a DLT entry. But I have no idea what to do with
780 the "link time TP value. */
781 case R_PARISC_LTOFF_TP21L:
782 case R_PARISC_LTOFF_TP14R:
783 case R_PARISC_LTOFF_TP14F:
784 case R_PARISC_LTOFF_TP64:
785 case R_PARISC_LTOFF_TP14WR:
786 case R_PARISC_LTOFF_TP14DR:
787 case R_PARISC_LTOFF_TP16F:
788 case R_PARISC_LTOFF_TP16WF:
789 case R_PARISC_LTOFF_TP16DF:
790 need_entry = NEED_DLT;
791 break;
793 /* These are function calls. Depending on their precise target we
794 may need to make a stub for them. The stub uses the PLT, so we
795 need to create PLT entries for these symbols too. */
796 case R_PARISC_PCREL12F:
797 case R_PARISC_PCREL17F:
798 case R_PARISC_PCREL22F:
799 case R_PARISC_PCREL32:
800 case R_PARISC_PCREL64:
801 case R_PARISC_PCREL21L:
802 case R_PARISC_PCREL17R:
803 case R_PARISC_PCREL17C:
804 case R_PARISC_PCREL14R:
805 case R_PARISC_PCREL14F:
806 case R_PARISC_PCREL22C:
807 case R_PARISC_PCREL14WR:
808 case R_PARISC_PCREL14DR:
809 case R_PARISC_PCREL16F:
810 case R_PARISC_PCREL16WF:
811 case R_PARISC_PCREL16DF:
812 need_entry = (NEED_PLT | NEED_STUB);
813 break;
815 case R_PARISC_PLTOFF21L:
816 case R_PARISC_PLTOFF14R:
817 case R_PARISC_PLTOFF14F:
818 case R_PARISC_PLTOFF14WR:
819 case R_PARISC_PLTOFF14DR:
820 case R_PARISC_PLTOFF16F:
821 case R_PARISC_PLTOFF16WF:
822 case R_PARISC_PLTOFF16DF:
823 need_entry = (NEED_PLT);
824 break;
826 case R_PARISC_DIR64:
827 if (info->shared || maybe_dynamic)
828 need_entry = (NEED_DYNREL);
829 dynrel_type = R_PARISC_DIR64;
830 break;
832 /* This is an indirect reference through the DLT to get the address
833 of a OPD descriptor. Thus we need to make a DLT entry that points
834 to an OPD entry. */
835 case R_PARISC_LTOFF_FPTR21L:
836 case R_PARISC_LTOFF_FPTR14R:
837 case R_PARISC_LTOFF_FPTR14WR:
838 case R_PARISC_LTOFF_FPTR14DR:
839 case R_PARISC_LTOFF_FPTR32:
840 case R_PARISC_LTOFF_FPTR64:
841 case R_PARISC_LTOFF_FPTR16F:
842 case R_PARISC_LTOFF_FPTR16WF:
843 case R_PARISC_LTOFF_FPTR16DF:
844 if (info->shared || maybe_dynamic)
845 need_entry = (NEED_DLT | NEED_OPD);
846 else
847 need_entry = (NEED_DLT | NEED_OPD);
848 dynrel_type = R_PARISC_FPTR64;
849 break;
851 /* This is a simple OPD entry. */
852 case R_PARISC_FPTR64:
853 if (info->shared || maybe_dynamic)
854 need_entry = (NEED_OPD | NEED_DYNREL);
855 else
856 need_entry = (NEED_OPD);
857 dynrel_type = R_PARISC_FPTR64;
858 break;
860 /* Add more cases as needed. */
863 if (!need_entry)
864 continue;
866 /* Collect a canonical name for this address. */
867 addr_name = get_dyn_name (abfd, h, rel, &buf, &buf_len);
869 /* Collect the canonical entry data for this address. */
870 dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
871 addr_name, TRUE, TRUE);
872 BFD_ASSERT (dyn_h);
874 /* Stash away enough information to be able to find this symbol
875 regardless of whether or not it is local or global. */
876 dyn_h->h = h;
877 dyn_h->owner = abfd;
878 dyn_h->sym_indx = r_symndx;
880 /* ?!? We may need to do some error checking in here. */
881 /* Create what's needed. */
882 if (need_entry & NEED_DLT)
884 if (! hppa_info->dlt_sec
885 && ! get_dlt (abfd, info, hppa_info))
886 goto err_out;
887 dyn_h->want_dlt = 1;
890 if (need_entry & NEED_PLT)
892 if (! hppa_info->plt_sec
893 && ! get_plt (abfd, info, hppa_info))
894 goto err_out;
895 dyn_h->want_plt = 1;
898 if (need_entry & NEED_STUB)
900 if (! hppa_info->stub_sec
901 && ! get_stub (abfd, info, hppa_info))
902 goto err_out;
903 dyn_h->want_stub = 1;
906 if (need_entry & NEED_OPD)
908 if (! hppa_info->opd_sec
909 && ! get_opd (abfd, info, hppa_info))
910 goto err_out;
912 dyn_h->want_opd = 1;
914 /* FPTRs are not allocated by the dynamic linker for PA64, though
915 it is possible that will change in the future. */
917 /* This could be a local function that had its address taken, in
918 which case H will be NULL. */
919 if (h)
920 h->needs_plt = 1;
923 /* Add a new dynamic relocation to the chain of dynamic
924 relocations for this symbol. */
925 if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC))
927 if (! hppa_info->other_rel_sec
928 && ! get_reloc_section (abfd, hppa_info, sec))
929 goto err_out;
931 if (!count_dyn_reloc (abfd, dyn_h, dynrel_type, sec,
932 sec_symndx, rel->r_offset, rel->r_addend))
933 goto err_out;
935 /* If we are building a shared library and we just recorded
936 a dynamic R_PARISC_FPTR64 relocation, then make sure the
937 section symbol for this section ends up in the dynamic
938 symbol table. */
939 if (info->shared && dynrel_type == R_PARISC_FPTR64
940 && ! (bfd_elf_link_record_local_dynamic_symbol
941 (info, abfd, sec_symndx)))
942 return FALSE;
946 if (buf)
947 free (buf);
948 return TRUE;
950 err_out:
951 if (buf)
952 free (buf);
953 return FALSE;
956 struct elf64_hppa_allocate_data
958 struct bfd_link_info *info;
959 bfd_size_type ofs;
962 /* Should we do dynamic things to this symbol? */
964 static bfd_boolean
965 elf64_hppa_dynamic_symbol_p (h, info)
966 struct elf_link_hash_entry *h;
967 struct bfd_link_info *info;
969 /* ??? What, if anything, needs to happen wrt STV_PROTECTED symbols
970 and relocations that retrieve a function descriptor? Assume the
971 worst for now. */
972 if (_bfd_elf_dynamic_symbol_p (h, info, 1))
974 /* ??? Why is this here and not elsewhere is_local_label_name. */
975 if (h->root.root.string[0] == '$' && h->root.root.string[1] == '$')
976 return FALSE;
978 return TRUE;
980 else
981 return FALSE;
984 /* Mark all functions exported by this file so that we can later allocate
985 entries in .opd for them. */
987 static bfd_boolean
988 elf64_hppa_mark_exported_functions (h, data)
989 struct elf_link_hash_entry *h;
990 PTR data;
992 struct bfd_link_info *info = (struct bfd_link_info *)data;
993 struct elf64_hppa_link_hash_table *hppa_info;
995 hppa_info = elf64_hppa_hash_table (info);
997 if (h->root.type == bfd_link_hash_warning)
998 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1000 if (h
1001 && (h->root.type == bfd_link_hash_defined
1002 || h->root.type == bfd_link_hash_defweak)
1003 && h->root.u.def.section->output_section != NULL
1004 && h->type == STT_FUNC)
1006 struct elf64_hppa_dyn_hash_entry *dyn_h;
1008 /* Add this symbol to the PA64 linker hash table. */
1009 dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
1010 h->root.root.string, TRUE, TRUE);
1011 BFD_ASSERT (dyn_h);
1012 dyn_h->h = h;
1014 if (! hppa_info->opd_sec
1015 && ! get_opd (hppa_info->root.dynobj, info, hppa_info))
1016 return FALSE;
1018 dyn_h->want_opd = 1;
1019 /* Put a flag here for output_symbol_hook. */
1020 dyn_h->st_shndx = -1;
1021 h->needs_plt = 1;
1024 return TRUE;
1027 /* Allocate space for a DLT entry. */
1029 static bfd_boolean
1030 allocate_global_data_dlt (dyn_h, data)
1031 struct elf64_hppa_dyn_hash_entry *dyn_h;
1032 PTR data;
1034 struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data;
1036 if (dyn_h->want_dlt)
1038 struct elf_link_hash_entry *h = dyn_h->h;
1040 if (x->info->shared)
1042 /* Possibly add the symbol to the local dynamic symbol
1043 table since we might need to create a dynamic relocation
1044 against it. */
1045 if (! h
1046 || (h->dynindx == -1 && h->type != STT_PARISC_MILLI))
1048 bfd *owner;
1049 owner = (h ? h->root.u.def.section->owner : dyn_h->owner);
1051 if (! (bfd_elf_link_record_local_dynamic_symbol
1052 (x->info, owner, dyn_h->sym_indx)))
1053 return FALSE;
1057 dyn_h->dlt_offset = x->ofs;
1058 x->ofs += DLT_ENTRY_SIZE;
1060 return TRUE;
1063 /* Allocate space for a DLT.PLT entry. */
1065 static bfd_boolean
1066 allocate_global_data_plt (dyn_h, data)
1067 struct elf64_hppa_dyn_hash_entry *dyn_h;
1068 PTR data;
1070 struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data;
1072 if (dyn_h->want_plt
1073 && elf64_hppa_dynamic_symbol_p (dyn_h->h, x->info)
1074 && !((dyn_h->h->root.type == bfd_link_hash_defined
1075 || dyn_h->h->root.type == bfd_link_hash_defweak)
1076 && dyn_h->h->root.u.def.section->output_section != NULL))
1078 dyn_h->plt_offset = x->ofs;
1079 x->ofs += PLT_ENTRY_SIZE;
1080 if (dyn_h->plt_offset < 0x2000)
1081 elf64_hppa_hash_table (x->info)->gp_offset = dyn_h->plt_offset;
1083 else
1084 dyn_h->want_plt = 0;
1086 return TRUE;
1089 /* Allocate space for a STUB entry. */
1091 static bfd_boolean
1092 allocate_global_data_stub (dyn_h, data)
1093 struct elf64_hppa_dyn_hash_entry *dyn_h;
1094 PTR data;
1096 struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data;
1098 if (dyn_h->want_stub
1099 && elf64_hppa_dynamic_symbol_p (dyn_h->h, x->info)
1100 && !((dyn_h->h->root.type == bfd_link_hash_defined
1101 || dyn_h->h->root.type == bfd_link_hash_defweak)
1102 && dyn_h->h->root.u.def.section->output_section != NULL))
1104 dyn_h->stub_offset = x->ofs;
1105 x->ofs += sizeof (plt_stub);
1107 else
1108 dyn_h->want_stub = 0;
1109 return TRUE;
1112 /* Allocate space for a FPTR entry. */
1114 static bfd_boolean
1115 allocate_global_data_opd (dyn_h, data)
1116 struct elf64_hppa_dyn_hash_entry *dyn_h;
1117 PTR data;
1119 struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data;
1121 if (dyn_h->want_opd)
1123 struct elf_link_hash_entry *h = dyn_h->h;
1125 if (h)
1126 while (h->root.type == bfd_link_hash_indirect
1127 || h->root.type == bfd_link_hash_warning)
1128 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1130 /* We never need an opd entry for a symbol which is not
1131 defined by this output file. */
1132 if (h && (h->root.type == bfd_link_hash_undefined
1133 || h->root.u.def.section->output_section == NULL))
1134 dyn_h->want_opd = 0;
1136 /* If we are creating a shared library, took the address of a local
1137 function or might export this function from this object file, then
1138 we have to create an opd descriptor. */
1139 else if (x->info->shared
1140 || h == NULL
1141 || (h->dynindx == -1 && h->type != STT_PARISC_MILLI)
1142 || (h->root.type == bfd_link_hash_defined
1143 || h->root.type == bfd_link_hash_defweak))
1145 /* If we are creating a shared library, then we will have to
1146 create a runtime relocation for the symbol to properly
1147 initialize the .opd entry. Make sure the symbol gets
1148 added to the dynamic symbol table. */
1149 if (x->info->shared
1150 && (h == NULL || (h->dynindx == -1)))
1152 bfd *owner;
1153 owner = (h ? h->root.u.def.section->owner : dyn_h->owner);
1155 if (!bfd_elf_link_record_local_dynamic_symbol
1156 (x->info, owner, dyn_h->sym_indx))
1157 return FALSE;
1160 /* This may not be necessary or desirable anymore now that
1161 we have some support for dealing with section symbols
1162 in dynamic relocs. But name munging does make the result
1163 much easier to debug. ie, the EPLT reloc will reference
1164 a symbol like .foobar, instead of .text + offset. */
1165 if (x->info->shared && h)
1167 char *new_name;
1168 struct elf_link_hash_entry *nh;
1170 new_name = alloca (strlen (h->root.root.string) + 2);
1171 new_name[0] = '.';
1172 strcpy (new_name + 1, h->root.root.string);
1174 nh = elf_link_hash_lookup (elf_hash_table (x->info),
1175 new_name, TRUE, TRUE, TRUE);
1177 nh->root.type = h->root.type;
1178 nh->root.u.def.value = h->root.u.def.value;
1179 nh->root.u.def.section = h->root.u.def.section;
1181 if (! bfd_elf_link_record_dynamic_symbol (x->info, nh))
1182 return FALSE;
1185 dyn_h->opd_offset = x->ofs;
1186 x->ofs += OPD_ENTRY_SIZE;
1189 /* Otherwise we do not need an opd entry. */
1190 else
1191 dyn_h->want_opd = 0;
1193 return TRUE;
1196 /* HP requires the EI_OSABI field to be filled in. The assignment to
1197 EI_ABIVERSION may not be strictly necessary. */
1199 static void
1200 elf64_hppa_post_process_headers (abfd, link_info)
1201 bfd * abfd;
1202 struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
1204 Elf_Internal_Ehdr * i_ehdrp;
1206 i_ehdrp = elf_elfheader (abfd);
1208 if (strcmp (bfd_get_target (abfd), "elf64-hppa-linux") == 0)
1210 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_LINUX;
1212 else
1214 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_HPUX;
1215 i_ehdrp->e_ident[EI_ABIVERSION] = 1;
1219 /* Create function descriptor section (.opd). This section is called .opd
1220 because it contains "official procedure descriptors". The "official"
1221 refers to the fact that these descriptors are used when taking the address
1222 of a procedure, thus ensuring a unique address for each procedure. */
1224 static bfd_boolean
1225 get_opd (abfd, info, hppa_info)
1226 bfd *abfd;
1227 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1228 struct elf64_hppa_link_hash_table *hppa_info;
1230 asection *opd;
1231 bfd *dynobj;
1233 opd = hppa_info->opd_sec;
1234 if (!opd)
1236 dynobj = hppa_info->root.dynobj;
1237 if (!dynobj)
1238 hppa_info->root.dynobj = dynobj = abfd;
1240 opd = bfd_make_section_with_flags (dynobj, ".opd",
1241 (SEC_ALLOC
1242 | SEC_LOAD
1243 | SEC_HAS_CONTENTS
1244 | SEC_IN_MEMORY
1245 | SEC_LINKER_CREATED));
1246 if (!opd
1247 || !bfd_set_section_alignment (abfd, opd, 3))
1249 BFD_ASSERT (0);
1250 return FALSE;
1253 hppa_info->opd_sec = opd;
1256 return TRUE;
1259 /* Create the PLT section. */
1261 static bfd_boolean
1262 get_plt (abfd, info, hppa_info)
1263 bfd *abfd;
1264 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1265 struct elf64_hppa_link_hash_table *hppa_info;
1267 asection *plt;
1268 bfd *dynobj;
1270 plt = hppa_info->plt_sec;
1271 if (!plt)
1273 dynobj = hppa_info->root.dynobj;
1274 if (!dynobj)
1275 hppa_info->root.dynobj = dynobj = abfd;
1277 plt = bfd_make_section_with_flags (dynobj, ".plt",
1278 (SEC_ALLOC
1279 | SEC_LOAD
1280 | SEC_HAS_CONTENTS
1281 | SEC_IN_MEMORY
1282 | SEC_LINKER_CREATED));
1283 if (!plt
1284 || !bfd_set_section_alignment (abfd, plt, 3))
1286 BFD_ASSERT (0);
1287 return FALSE;
1290 hppa_info->plt_sec = plt;
1293 return TRUE;
1296 /* Create the DLT section. */
1298 static bfd_boolean
1299 get_dlt (abfd, info, hppa_info)
1300 bfd *abfd;
1301 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1302 struct elf64_hppa_link_hash_table *hppa_info;
1304 asection *dlt;
1305 bfd *dynobj;
1307 dlt = hppa_info->dlt_sec;
1308 if (!dlt)
1310 dynobj = hppa_info->root.dynobj;
1311 if (!dynobj)
1312 hppa_info->root.dynobj = dynobj = abfd;
1314 dlt = bfd_make_section_with_flags (dynobj, ".dlt",
1315 (SEC_ALLOC
1316 | SEC_LOAD
1317 | SEC_HAS_CONTENTS
1318 | SEC_IN_MEMORY
1319 | SEC_LINKER_CREATED));
1320 if (!dlt
1321 || !bfd_set_section_alignment (abfd, dlt, 3))
1323 BFD_ASSERT (0);
1324 return FALSE;
1327 hppa_info->dlt_sec = dlt;
1330 return TRUE;
1333 /* Create the stubs section. */
1335 static bfd_boolean
1336 get_stub (abfd, info, hppa_info)
1337 bfd *abfd;
1338 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1339 struct elf64_hppa_link_hash_table *hppa_info;
1341 asection *stub;
1342 bfd *dynobj;
1344 stub = hppa_info->stub_sec;
1345 if (!stub)
1347 dynobj = hppa_info->root.dynobj;
1348 if (!dynobj)
1349 hppa_info->root.dynobj = dynobj = abfd;
1351 stub = bfd_make_section_with_flags (dynobj, ".stub",
1352 (SEC_ALLOC | SEC_LOAD
1353 | SEC_HAS_CONTENTS
1354 | SEC_IN_MEMORY
1355 | SEC_READONLY
1356 | SEC_LINKER_CREATED));
1357 if (!stub
1358 || !bfd_set_section_alignment (abfd, stub, 3))
1360 BFD_ASSERT (0);
1361 return FALSE;
1364 hppa_info->stub_sec = stub;
1367 return TRUE;
1370 /* Create sections necessary for dynamic linking. This is only a rough
1371 cut and will likely change as we learn more about the somewhat
1372 unusual dynamic linking scheme HP uses.
1374 .stub:
1375 Contains code to implement cross-space calls. The first time one
1376 of the stubs is used it will call into the dynamic linker, later
1377 calls will go straight to the target.
1379 The only stub we support right now looks like
1381 ldd OFFSET(%dp),%r1
1382 bve %r0(%r1)
1383 ldd OFFSET+8(%dp),%dp
1385 Other stubs may be needed in the future. We may want the remove
1386 the break/nop instruction. It is only used right now to keep the
1387 offset of a .plt entry and a .stub entry in sync.
1389 .dlt:
1390 This is what most people call the .got. HP used a different name.
1391 Losers.
1393 .rela.dlt:
1394 Relocations for the DLT.
1396 .plt:
1397 Function pointers as address,gp pairs.
1399 .rela.plt:
1400 Should contain dynamic IPLT (and EPLT?) relocations.
1402 .opd:
1403 FPTRS
1405 .rela.opd:
1406 EPLT relocations for symbols exported from shared libraries. */
1408 static bfd_boolean
1409 elf64_hppa_create_dynamic_sections (abfd, info)
1410 bfd *abfd;
1411 struct bfd_link_info *info;
1413 asection *s;
1415 if (! get_stub (abfd, info, elf64_hppa_hash_table (info)))
1416 return FALSE;
1418 if (! get_dlt (abfd, info, elf64_hppa_hash_table (info)))
1419 return FALSE;
1421 if (! get_plt (abfd, info, elf64_hppa_hash_table (info)))
1422 return FALSE;
1424 if (! get_opd (abfd, info, elf64_hppa_hash_table (info)))
1425 return FALSE;
1427 s = bfd_make_section_with_flags (abfd, ".rela.dlt",
1428 (SEC_ALLOC | SEC_LOAD
1429 | SEC_HAS_CONTENTS
1430 | SEC_IN_MEMORY
1431 | SEC_READONLY
1432 | SEC_LINKER_CREATED));
1433 if (s == NULL
1434 || !bfd_set_section_alignment (abfd, s, 3))
1435 return FALSE;
1436 elf64_hppa_hash_table (info)->dlt_rel_sec = s;
1438 s = bfd_make_section_with_flags (abfd, ".rela.plt",
1439 (SEC_ALLOC | SEC_LOAD
1440 | SEC_HAS_CONTENTS
1441 | SEC_IN_MEMORY
1442 | SEC_READONLY
1443 | SEC_LINKER_CREATED));
1444 if (s == NULL
1445 || !bfd_set_section_alignment (abfd, s, 3))
1446 return FALSE;
1447 elf64_hppa_hash_table (info)->plt_rel_sec = s;
1449 s = bfd_make_section_with_flags (abfd, ".rela.data",
1450 (SEC_ALLOC | SEC_LOAD
1451 | SEC_HAS_CONTENTS
1452 | SEC_IN_MEMORY
1453 | SEC_READONLY
1454 | SEC_LINKER_CREATED));
1455 if (s == NULL
1456 || !bfd_set_section_alignment (abfd, s, 3))
1457 return FALSE;
1458 elf64_hppa_hash_table (info)->other_rel_sec = s;
1460 s = bfd_make_section_with_flags (abfd, ".rela.opd",
1461 (SEC_ALLOC | SEC_LOAD
1462 | SEC_HAS_CONTENTS
1463 | SEC_IN_MEMORY
1464 | SEC_READONLY
1465 | SEC_LINKER_CREATED));
1466 if (s == NULL
1467 || !bfd_set_section_alignment (abfd, s, 3))
1468 return FALSE;
1469 elf64_hppa_hash_table (info)->opd_rel_sec = s;
1471 return TRUE;
1474 /* Allocate dynamic relocations for those symbols that turned out
1475 to be dynamic. */
1477 static bfd_boolean
1478 allocate_dynrel_entries (dyn_h, data)
1479 struct elf64_hppa_dyn_hash_entry *dyn_h;
1480 PTR data;
1482 struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data;
1483 struct elf64_hppa_link_hash_table *hppa_info;
1484 struct elf64_hppa_dyn_reloc_entry *rent;
1485 bfd_boolean dynamic_symbol, shared;
1487 hppa_info = elf64_hppa_hash_table (x->info);
1488 dynamic_symbol = elf64_hppa_dynamic_symbol_p (dyn_h->h, x->info);
1489 shared = x->info->shared;
1491 /* We may need to allocate relocations for a non-dynamic symbol
1492 when creating a shared library. */
1493 if (!dynamic_symbol && !shared)
1494 return TRUE;
1496 /* Take care of the normal data relocations. */
1498 for (rent = dyn_h->reloc_entries; rent; rent = rent->next)
1500 /* Allocate one iff we are building a shared library, the relocation
1501 isn't a R_PARISC_FPTR64, or we don't want an opd entry. */
1502 if (!shared && rent->type == R_PARISC_FPTR64 && dyn_h->want_opd)
1503 continue;
1505 hppa_info->other_rel_sec->size += sizeof (Elf64_External_Rela);
1507 /* Make sure this symbol gets into the dynamic symbol table if it is
1508 not already recorded. ?!? This should not be in the loop since
1509 the symbol need only be added once. */
1510 if (dyn_h->h == 0
1511 || (dyn_h->h->dynindx == -1 && dyn_h->h->type != STT_PARISC_MILLI))
1512 if (!bfd_elf_link_record_local_dynamic_symbol
1513 (x->info, rent->sec->owner, dyn_h->sym_indx))
1514 return FALSE;
1517 /* Take care of the GOT and PLT relocations. */
1519 if ((dynamic_symbol || shared) && dyn_h->want_dlt)
1520 hppa_info->dlt_rel_sec->size += sizeof (Elf64_External_Rela);
1522 /* If we are building a shared library, then every symbol that has an
1523 opd entry will need an EPLT relocation to relocate the symbol's address
1524 and __gp value based on the runtime load address. */
1525 if (shared && dyn_h->want_opd)
1526 hppa_info->opd_rel_sec->size += sizeof (Elf64_External_Rela);
1528 if (dyn_h->want_plt && dynamic_symbol)
1530 bfd_size_type t = 0;
1532 /* Dynamic symbols get one IPLT relocation. Local symbols in
1533 shared libraries get two REL relocations. Local symbols in
1534 main applications get nothing. */
1535 if (dynamic_symbol)
1536 t = sizeof (Elf64_External_Rela);
1537 else if (shared)
1538 t = 2 * sizeof (Elf64_External_Rela);
1540 hppa_info->plt_rel_sec->size += t;
1543 return TRUE;
1546 /* Adjust a symbol defined by a dynamic object and referenced by a
1547 regular object. */
1549 static bfd_boolean
1550 elf64_hppa_adjust_dynamic_symbol (info, h)
1551 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1552 struct elf_link_hash_entry *h;
1554 /* ??? Undefined symbols with PLT entries should be re-defined
1555 to be the PLT entry. */
1557 /* If this is a weak symbol, and there is a real definition, the
1558 processor independent code will have arranged for us to see the
1559 real definition first, and we can just use the same value. */
1560 if (h->u.weakdef != NULL)
1562 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1563 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1564 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1565 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1566 return TRUE;
1569 /* If this is a reference to a symbol defined by a dynamic object which
1570 is not a function, we might allocate the symbol in our .dynbss section
1571 and allocate a COPY dynamic relocation.
1573 But PA64 code is canonically PIC, so as a rule we can avoid this sort
1574 of hackery. */
1576 return TRUE;
1579 /* This function is called via elf_link_hash_traverse to mark millicode
1580 symbols with a dynindx of -1 and to remove the string table reference
1581 from the dynamic symbol table. If the symbol is not a millicode symbol,
1582 elf64_hppa_mark_exported_functions is called. */
1584 static bfd_boolean
1585 elf64_hppa_mark_milli_and_exported_functions (h, data)
1586 struct elf_link_hash_entry *h;
1587 PTR data;
1589 struct bfd_link_info *info = (struct bfd_link_info *)data;
1590 struct elf_link_hash_entry *elf = h;
1592 if (elf->root.type == bfd_link_hash_warning)
1593 elf = (struct elf_link_hash_entry *) elf->root.u.i.link;
1595 if (elf->type == STT_PARISC_MILLI)
1597 if (elf->dynindx != -1)
1599 elf->dynindx = -1;
1600 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1601 elf->dynstr_index);
1603 return TRUE;
1606 return elf64_hppa_mark_exported_functions (h, data);
1609 /* Set the final sizes of the dynamic sections and allocate memory for
1610 the contents of our special sections. */
1612 static bfd_boolean
1613 elf64_hppa_size_dynamic_sections (output_bfd, info)
1614 bfd *output_bfd;
1615 struct bfd_link_info *info;
1617 bfd *dynobj;
1618 asection *s;
1619 bfd_boolean plt;
1620 bfd_boolean relocs;
1621 bfd_boolean reltext;
1622 struct elf64_hppa_allocate_data data;
1623 struct elf64_hppa_link_hash_table *hppa_info;
1625 hppa_info = elf64_hppa_hash_table (info);
1627 dynobj = elf_hash_table (info)->dynobj;
1628 BFD_ASSERT (dynobj != NULL);
1630 /* Mark each function this program exports so that we will allocate
1631 space in the .opd section for each function's FPTR. If we are
1632 creating dynamic sections, change the dynamic index of millicode
1633 symbols to -1 and remove them from the string table for .dynstr.
1635 We have to traverse the main linker hash table since we have to
1636 find functions which may not have been mentioned in any relocs. */
1637 elf_link_hash_traverse (elf_hash_table (info),
1638 (elf_hash_table (info)->dynamic_sections_created
1639 ? elf64_hppa_mark_milli_and_exported_functions
1640 : elf64_hppa_mark_exported_functions),
1641 info);
1643 if (elf_hash_table (info)->dynamic_sections_created)
1645 /* Set the contents of the .interp section to the interpreter. */
1646 if (info->executable)
1648 s = bfd_get_section_by_name (dynobj, ".interp");
1649 BFD_ASSERT (s != NULL);
1650 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
1651 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1654 else
1656 /* We may have created entries in the .rela.got section.
1657 However, if we are not creating the dynamic sections, we will
1658 not actually use these entries. Reset the size of .rela.dlt,
1659 which will cause it to get stripped from the output file
1660 below. */
1661 s = bfd_get_section_by_name (dynobj, ".rela.dlt");
1662 if (s != NULL)
1663 s->size = 0;
1666 /* Allocate the GOT entries. */
1668 data.info = info;
1669 if (elf64_hppa_hash_table (info)->dlt_sec)
1671 data.ofs = 0x0;
1672 elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
1673 allocate_global_data_dlt, &data);
1674 hppa_info->dlt_sec->size = data.ofs;
1676 data.ofs = 0x0;
1677 elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
1678 allocate_global_data_plt, &data);
1679 hppa_info->plt_sec->size = data.ofs;
1681 data.ofs = 0x0;
1682 elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
1683 allocate_global_data_stub, &data);
1684 hppa_info->stub_sec->size = data.ofs;
1687 /* Allocate space for entries in the .opd section. */
1688 if (elf64_hppa_hash_table (info)->opd_sec)
1690 data.ofs = 0;
1691 elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
1692 allocate_global_data_opd, &data);
1693 hppa_info->opd_sec->size = data.ofs;
1696 /* Now allocate space for dynamic relocations, if necessary. */
1697 if (hppa_info->root.dynamic_sections_created)
1698 elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
1699 allocate_dynrel_entries, &data);
1701 /* The sizes of all the sections are set. Allocate memory for them. */
1702 plt = FALSE;
1703 relocs = FALSE;
1704 reltext = FALSE;
1705 for (s = dynobj->sections; s != NULL; s = s->next)
1707 const char *name;
1709 if ((s->flags & SEC_LINKER_CREATED) == 0)
1710 continue;
1712 /* It's OK to base decisions on the section name, because none
1713 of the dynobj section names depend upon the input files. */
1714 name = bfd_get_section_name (dynobj, s);
1716 if (strcmp (name, ".plt") == 0)
1718 /* Remember whether there is a PLT. */
1719 plt = s->size != 0;
1721 else if (strcmp (name, ".opd") == 0
1722 || strncmp (name, ".dlt", 4) == 0
1723 || strcmp (name, ".stub") == 0
1724 || strcmp (name, ".got") == 0)
1726 /* Strip this section if we don't need it; see the comment below. */
1728 else if (strncmp (name, ".rela", 5) == 0)
1730 if (s->size != 0)
1732 asection *target;
1734 /* Remember whether there are any reloc sections other
1735 than .rela.plt. */
1736 if (strcmp (name, ".rela.plt") != 0)
1738 const char *outname;
1740 relocs = TRUE;
1742 /* If this relocation section applies to a read only
1743 section, then we probably need a DT_TEXTREL
1744 entry. The entries in the .rela.plt section
1745 really apply to the .got section, which we
1746 created ourselves and so know is not readonly. */
1747 outname = bfd_get_section_name (output_bfd,
1748 s->output_section);
1749 target = bfd_get_section_by_name (output_bfd, outname + 4);
1750 if (target != NULL
1751 && (target->flags & SEC_READONLY) != 0
1752 && (target->flags & SEC_ALLOC) != 0)
1753 reltext = TRUE;
1756 /* We use the reloc_count field as a counter if we need
1757 to copy relocs into the output file. */
1758 s->reloc_count = 0;
1761 else
1763 /* It's not one of our sections, so don't allocate space. */
1764 continue;
1767 if (s->size == 0)
1769 /* If we don't need this section, strip it from the
1770 output file. This is mostly to handle .rela.bss and
1771 .rela.plt. We must create both sections in
1772 create_dynamic_sections, because they must be created
1773 before the linker maps input sections to output
1774 sections. The linker does that before
1775 adjust_dynamic_symbol is called, and it is that
1776 function which decides whether anything needs to go
1777 into these sections. */
1778 s->flags |= SEC_EXCLUDE;
1779 continue;
1782 if ((s->flags & SEC_HAS_CONTENTS) == 0)
1783 continue;
1785 /* Allocate memory for the section contents if it has not
1786 been allocated already. We use bfd_zalloc here in case
1787 unused entries are not reclaimed before the section's
1788 contents are written out. This should not happen, but this
1789 way if it does, we get a R_PARISC_NONE reloc instead of
1790 garbage. */
1791 if (s->contents == NULL)
1793 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1794 if (s->contents == NULL)
1795 return FALSE;
1799 if (elf_hash_table (info)->dynamic_sections_created)
1801 /* Always create a DT_PLTGOT. It actually has nothing to do with
1802 the PLT, it is how we communicate the __gp value of a load
1803 module to the dynamic linker. */
1804 #define add_dynamic_entry(TAG, VAL) \
1805 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1807 if (!add_dynamic_entry (DT_HP_DLD_FLAGS, 0)
1808 || !add_dynamic_entry (DT_PLTGOT, 0))
1809 return FALSE;
1811 /* Add some entries to the .dynamic section. We fill in the
1812 values later, in elf64_hppa_finish_dynamic_sections, but we
1813 must add the entries now so that we get the correct size for
1814 the .dynamic section. The DT_DEBUG entry is filled in by the
1815 dynamic linker and used by the debugger. */
1816 if (! info->shared)
1818 if (!add_dynamic_entry (DT_DEBUG, 0)
1819 || !add_dynamic_entry (DT_HP_DLD_HOOK, 0)
1820 || !add_dynamic_entry (DT_HP_LOAD_MAP, 0))
1821 return FALSE;
1824 /* Force DT_FLAGS to always be set.
1825 Required by HPUX 11.00 patch PHSS_26559. */
1826 if (!add_dynamic_entry (DT_FLAGS, (info)->flags))
1827 return FALSE;
1829 if (plt)
1831 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
1832 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1833 || !add_dynamic_entry (DT_JMPREL, 0))
1834 return FALSE;
1837 if (relocs)
1839 if (!add_dynamic_entry (DT_RELA, 0)
1840 || !add_dynamic_entry (DT_RELASZ, 0)
1841 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
1842 return FALSE;
1845 if (reltext)
1847 if (!add_dynamic_entry (DT_TEXTREL, 0))
1848 return FALSE;
1849 info->flags |= DF_TEXTREL;
1852 #undef add_dynamic_entry
1854 return TRUE;
1857 /* Called after we have output the symbol into the dynamic symbol
1858 table, but before we output the symbol into the normal symbol
1859 table.
1861 For some symbols we had to change their address when outputting
1862 the dynamic symbol table. We undo that change here so that
1863 the symbols have their expected value in the normal symbol
1864 table. Ick. */
1866 static bfd_boolean
1867 elf64_hppa_link_output_symbol_hook (info, name, sym, input_sec, h)
1868 struct bfd_link_info *info;
1869 const char *name;
1870 Elf_Internal_Sym *sym;
1871 asection *input_sec ATTRIBUTE_UNUSED;
1872 struct elf_link_hash_entry *h;
1874 struct elf64_hppa_link_hash_table *hppa_info;
1875 struct elf64_hppa_dyn_hash_entry *dyn_h;
1877 /* We may be called with the file symbol or section symbols.
1878 They never need munging, so it is safe to ignore them. */
1879 if (!name)
1880 return TRUE;
1882 /* Get the PA dyn_symbol (if any) associated with NAME. */
1883 hppa_info = elf64_hppa_hash_table (info);
1884 dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
1885 name, FALSE, FALSE);
1886 if (!dyn_h || dyn_h->h != h)
1887 return TRUE;
1889 /* Function symbols for which we created .opd entries *may* have been
1890 munged by finish_dynamic_symbol and have to be un-munged here.
1892 Note that finish_dynamic_symbol sometimes turns dynamic symbols
1893 into non-dynamic ones, so we initialize st_shndx to -1 in
1894 mark_exported_functions and check to see if it was overwritten
1895 here instead of just checking dyn_h->h->dynindx. */
1896 if (dyn_h->want_opd && dyn_h->st_shndx != -1)
1898 /* Restore the saved value and section index. */
1899 sym->st_value = dyn_h->st_value;
1900 sym->st_shndx = dyn_h->st_shndx;
1903 return TRUE;
1906 /* Finish up dynamic symbol handling. We set the contents of various
1907 dynamic sections here. */
1909 static bfd_boolean
1910 elf64_hppa_finish_dynamic_symbol (output_bfd, info, h, sym)
1911 bfd *output_bfd;
1912 struct bfd_link_info *info;
1913 struct elf_link_hash_entry *h;
1914 Elf_Internal_Sym *sym;
1916 asection *stub, *splt, *sdlt, *sopd, *spltrel, *sdltrel;
1917 struct elf64_hppa_link_hash_table *hppa_info;
1918 struct elf64_hppa_dyn_hash_entry *dyn_h;
1920 hppa_info = elf64_hppa_hash_table (info);
1921 dyn_h = elf64_hppa_dyn_hash_lookup (&hppa_info->dyn_hash_table,
1922 h->root.root.string, FALSE, FALSE);
1924 stub = hppa_info->stub_sec;
1925 splt = hppa_info->plt_sec;
1926 sdlt = hppa_info->dlt_sec;
1927 sopd = hppa_info->opd_sec;
1928 spltrel = hppa_info->plt_rel_sec;
1929 sdltrel = hppa_info->dlt_rel_sec;
1931 /* Incredible. It is actually necessary to NOT use the symbol's real
1932 value when building the dynamic symbol table for a shared library.
1933 At least for symbols that refer to functions.
1935 We will store a new value and section index into the symbol long
1936 enough to output it into the dynamic symbol table, then we restore
1937 the original values (in elf64_hppa_link_output_symbol_hook). */
1938 if (dyn_h && dyn_h->want_opd)
1940 BFD_ASSERT (sopd != NULL);
1942 /* Save away the original value and section index so that we
1943 can restore them later. */
1944 dyn_h->st_value = sym->st_value;
1945 dyn_h->st_shndx = sym->st_shndx;
1947 /* For the dynamic symbol table entry, we want the value to be
1948 address of this symbol's entry within the .opd section. */
1949 sym->st_value = (dyn_h->opd_offset
1950 + sopd->output_offset
1951 + sopd->output_section->vma);
1952 sym->st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
1953 sopd->output_section);
1956 /* Initialize a .plt entry if requested. */
1957 if (dyn_h && dyn_h->want_plt
1958 && elf64_hppa_dynamic_symbol_p (dyn_h->h, info))
1960 bfd_vma value;
1961 Elf_Internal_Rela rel;
1962 bfd_byte *loc;
1964 BFD_ASSERT (splt != NULL && spltrel != NULL);
1966 /* We do not actually care about the value in the PLT entry
1967 if we are creating a shared library and the symbol is
1968 still undefined, we create a dynamic relocation to fill
1969 in the correct value. */
1970 if (info->shared && h->root.type == bfd_link_hash_undefined)
1971 value = 0;
1972 else
1973 value = (h->root.u.def.value + h->root.u.def.section->vma);
1975 /* Fill in the entry in the procedure linkage table.
1977 The format of a plt entry is
1978 <funcaddr> <__gp>.
1980 plt_offset is the offset within the PLT section at which to
1981 install the PLT entry.
1983 We are modifying the in-memory PLT contents here, so we do not add
1984 in the output_offset of the PLT section. */
1986 bfd_put_64 (splt->owner, value, splt->contents + dyn_h->plt_offset);
1987 value = _bfd_get_gp_value (splt->output_section->owner);
1988 bfd_put_64 (splt->owner, value, splt->contents + dyn_h->plt_offset + 0x8);
1990 /* Create a dynamic IPLT relocation for this entry.
1992 We are creating a relocation in the output file's PLT section,
1993 which is included within the DLT secton. So we do need to include
1994 the PLT's output_offset in the computation of the relocation's
1995 address. */
1996 rel.r_offset = (dyn_h->plt_offset + splt->output_offset
1997 + splt->output_section->vma);
1998 rel.r_info = ELF64_R_INFO (h->dynindx, R_PARISC_IPLT);
1999 rel.r_addend = 0;
2001 loc = spltrel->contents;
2002 loc += spltrel->reloc_count++ * sizeof (Elf64_External_Rela);
2003 bfd_elf64_swap_reloca_out (splt->output_section->owner, &rel, loc);
2006 /* Initialize an external call stub entry if requested. */
2007 if (dyn_h && dyn_h->want_stub
2008 && elf64_hppa_dynamic_symbol_p (dyn_h->h, info))
2010 bfd_vma value;
2011 int insn;
2012 unsigned int max_offset;
2014 BFD_ASSERT (stub != NULL);
2016 /* Install the generic stub template.
2018 We are modifying the contents of the stub section, so we do not
2019 need to include the stub section's output_offset here. */
2020 memcpy (stub->contents + dyn_h->stub_offset, plt_stub, sizeof (plt_stub));
2022 /* Fix up the first ldd instruction.
2024 We are modifying the contents of the STUB section in memory,
2025 so we do not need to include its output offset in this computation.
2027 Note the plt_offset value is the value of the PLT entry relative to
2028 the start of the PLT section. These instructions will reference
2029 data relative to the value of __gp, which may not necessarily have
2030 the same address as the start of the PLT section.
2032 gp_offset contains the offset of __gp within the PLT section. */
2033 value = dyn_h->plt_offset - hppa_info->gp_offset;
2035 insn = bfd_get_32 (stub->owner, stub->contents + dyn_h->stub_offset);
2036 if (output_bfd->arch_info->mach >= 25)
2038 /* Wide mode allows 16 bit offsets. */
2039 max_offset = 32768;
2040 insn &= ~ 0xfff1;
2041 insn |= re_assemble_16 ((int) value);
2043 else
2045 max_offset = 8192;
2046 insn &= ~ 0x3ff1;
2047 insn |= re_assemble_14 ((int) value);
2050 if ((value & 7) || value + max_offset >= 2*max_offset - 8)
2052 (*_bfd_error_handler) (_("stub entry for %s cannot load .plt, dp offset = %ld"),
2053 dyn_h->root.string,
2054 (long) value);
2055 return FALSE;
2058 bfd_put_32 (stub->owner, (bfd_vma) insn,
2059 stub->contents + dyn_h->stub_offset);
2061 /* Fix up the second ldd instruction. */
2062 value += 8;
2063 insn = bfd_get_32 (stub->owner, stub->contents + dyn_h->stub_offset + 8);
2064 if (output_bfd->arch_info->mach >= 25)
2066 insn &= ~ 0xfff1;
2067 insn |= re_assemble_16 ((int) value);
2069 else
2071 insn &= ~ 0x3ff1;
2072 insn |= re_assemble_14 ((int) value);
2074 bfd_put_32 (stub->owner, (bfd_vma) insn,
2075 stub->contents + dyn_h->stub_offset + 8);
2078 return TRUE;
2081 /* The .opd section contains FPTRs for each function this file
2082 exports. Initialize the FPTR entries. */
2084 static bfd_boolean
2085 elf64_hppa_finalize_opd (dyn_h, data)
2086 struct elf64_hppa_dyn_hash_entry *dyn_h;
2087 PTR data;
2089 struct bfd_link_info *info = (struct bfd_link_info *)data;
2090 struct elf64_hppa_link_hash_table *hppa_info;
2091 struct elf_link_hash_entry *h = dyn_h ? dyn_h->h : NULL;
2092 asection *sopd;
2093 asection *sopdrel;
2095 hppa_info = elf64_hppa_hash_table (info);
2096 sopd = hppa_info->opd_sec;
2097 sopdrel = hppa_info->opd_rel_sec;
2099 if (h && dyn_h->want_opd)
2101 bfd_vma value;
2103 /* The first two words of an .opd entry are zero.
2105 We are modifying the contents of the OPD section in memory, so we
2106 do not need to include its output offset in this computation. */
2107 memset (sopd->contents + dyn_h->opd_offset, 0, 16);
2109 value = (h->root.u.def.value
2110 + h->root.u.def.section->output_section->vma
2111 + h->root.u.def.section->output_offset);
2113 /* The next word is the address of the function. */
2114 bfd_put_64 (sopd->owner, value, sopd->contents + dyn_h->opd_offset + 16);
2116 /* The last word is our local __gp value. */
2117 value = _bfd_get_gp_value (sopd->output_section->owner);
2118 bfd_put_64 (sopd->owner, value, sopd->contents + dyn_h->opd_offset + 24);
2121 /* If we are generating a shared library, we must generate EPLT relocations
2122 for each entry in the .opd, even for static functions (they may have
2123 had their address taken). */
2124 if (info->shared && dyn_h && dyn_h->want_opd)
2126 Elf_Internal_Rela rel;
2127 bfd_byte *loc;
2128 int dynindx;
2130 /* We may need to do a relocation against a local symbol, in
2131 which case we have to look up it's dynamic symbol index off
2132 the local symbol hash table. */
2133 if (h && h->dynindx != -1)
2134 dynindx = h->dynindx;
2135 else
2136 dynindx
2137 = _bfd_elf_link_lookup_local_dynindx (info, dyn_h->owner,
2138 dyn_h->sym_indx);
2140 /* The offset of this relocation is the absolute address of the
2141 .opd entry for this symbol. */
2142 rel.r_offset = (dyn_h->opd_offset + sopd->output_offset
2143 + sopd->output_section->vma);
2145 /* If H is non-null, then we have an external symbol.
2147 It is imperative that we use a different dynamic symbol for the
2148 EPLT relocation if the symbol has global scope.
2150 In the dynamic symbol table, the function symbol will have a value
2151 which is address of the function's .opd entry.
2153 Thus, we can not use that dynamic symbol for the EPLT relocation
2154 (if we did, the data in the .opd would reference itself rather
2155 than the actual address of the function). Instead we have to use
2156 a new dynamic symbol which has the same value as the original global
2157 function symbol.
2159 We prefix the original symbol with a "." and use the new symbol in
2160 the EPLT relocation. This new symbol has already been recorded in
2161 the symbol table, we just have to look it up and use it.
2163 We do not have such problems with static functions because we do
2164 not make their addresses in the dynamic symbol table point to
2165 the .opd entry. Ultimately this should be safe since a static
2166 function can not be directly referenced outside of its shared
2167 library.
2169 We do have to play similar games for FPTR relocations in shared
2170 libraries, including those for static symbols. See the FPTR
2171 handling in elf64_hppa_finalize_dynreloc. */
2172 if (h)
2174 char *new_name;
2175 struct elf_link_hash_entry *nh;
2177 new_name = alloca (strlen (h->root.root.string) + 2);
2178 new_name[0] = '.';
2179 strcpy (new_name + 1, h->root.root.string);
2181 nh = elf_link_hash_lookup (elf_hash_table (info),
2182 new_name, FALSE, FALSE, FALSE);
2184 /* All we really want from the new symbol is its dynamic
2185 symbol index. */
2186 dynindx = nh->dynindx;
2189 rel.r_addend = 0;
2190 rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_EPLT);
2192 loc = sopdrel->contents;
2193 loc += sopdrel->reloc_count++ * sizeof (Elf64_External_Rela);
2194 bfd_elf64_swap_reloca_out (sopd->output_section->owner, &rel, loc);
2196 return TRUE;
2199 /* The .dlt section contains addresses for items referenced through the
2200 dlt. Note that we can have a DLTIND relocation for a local symbol, thus
2201 we can not depend on finish_dynamic_symbol to initialize the .dlt. */
2203 static bfd_boolean
2204 elf64_hppa_finalize_dlt (dyn_h, data)
2205 struct elf64_hppa_dyn_hash_entry *dyn_h;
2206 PTR data;
2208 struct bfd_link_info *info = (struct bfd_link_info *)data;
2209 struct elf64_hppa_link_hash_table *hppa_info;
2210 asection *sdlt, *sdltrel;
2211 struct elf_link_hash_entry *h = dyn_h ? dyn_h->h : NULL;
2213 hppa_info = elf64_hppa_hash_table (info);
2215 sdlt = hppa_info->dlt_sec;
2216 sdltrel = hppa_info->dlt_rel_sec;
2218 /* H/DYN_H may refer to a local variable and we know it's
2219 address, so there is no need to create a relocation. Just install
2220 the proper value into the DLT, note this shortcut can not be
2221 skipped when building a shared library. */
2222 if (! info->shared && h && dyn_h->want_dlt)
2224 bfd_vma value;
2226 /* If we had an LTOFF_FPTR style relocation we want the DLT entry
2227 to point to the FPTR entry in the .opd section.
2229 We include the OPD's output offset in this computation as
2230 we are referring to an absolute address in the resulting
2231 object file. */
2232 if (dyn_h->want_opd)
2234 value = (dyn_h->opd_offset
2235 + hppa_info->opd_sec->output_offset
2236 + hppa_info->opd_sec->output_section->vma);
2238 else if ((h->root.type == bfd_link_hash_defined
2239 || h->root.type == bfd_link_hash_defweak)
2240 && h->root.u.def.section)
2242 value = h->root.u.def.value + h->root.u.def.section->output_offset;
2243 if (h->root.u.def.section->output_section)
2244 value += h->root.u.def.section->output_section->vma;
2245 else
2246 value += h->root.u.def.section->vma;
2248 else
2249 /* We have an undefined function reference. */
2250 value = 0;
2252 /* We do not need to include the output offset of the DLT section
2253 here because we are modifying the in-memory contents. */
2254 bfd_put_64 (sdlt->owner, value, sdlt->contents + dyn_h->dlt_offset);
2257 /* Create a relocation for the DLT entry associated with this symbol.
2258 When building a shared library the symbol does not have to be dynamic. */
2259 if (dyn_h->want_dlt
2260 && (elf64_hppa_dynamic_symbol_p (dyn_h->h, info) || info->shared))
2262 Elf_Internal_Rela rel;
2263 bfd_byte *loc;
2264 int dynindx;
2266 /* We may need to do a relocation against a local symbol, in
2267 which case we have to look up it's dynamic symbol index off
2268 the local symbol hash table. */
2269 if (h && h->dynindx != -1)
2270 dynindx = h->dynindx;
2271 else
2272 dynindx
2273 = _bfd_elf_link_lookup_local_dynindx (info, dyn_h->owner,
2274 dyn_h->sym_indx);
2276 /* Create a dynamic relocation for this entry. Do include the output
2277 offset of the DLT entry since we need an absolute address in the
2278 resulting object file. */
2279 rel.r_offset = (dyn_h->dlt_offset + sdlt->output_offset
2280 + sdlt->output_section->vma);
2281 if (h && h->type == STT_FUNC)
2282 rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_FPTR64);
2283 else
2284 rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_DIR64);
2285 rel.r_addend = 0;
2287 loc = sdltrel->contents;
2288 loc += sdltrel->reloc_count++ * sizeof (Elf64_External_Rela);
2289 bfd_elf64_swap_reloca_out (sdlt->output_section->owner, &rel, loc);
2291 return TRUE;
2294 /* Finalize the dynamic relocations. Specifically the FPTR relocations
2295 for dynamic functions used to initialize static data. */
2297 static bfd_boolean
2298 elf64_hppa_finalize_dynreloc (dyn_h, data)
2299 struct elf64_hppa_dyn_hash_entry *dyn_h;
2300 PTR data;
2302 struct bfd_link_info *info = (struct bfd_link_info *)data;
2303 struct elf64_hppa_link_hash_table *hppa_info;
2304 struct elf_link_hash_entry *h;
2305 int dynamic_symbol;
2307 dynamic_symbol = elf64_hppa_dynamic_symbol_p (dyn_h->h, info);
2309 if (!dynamic_symbol && !info->shared)
2310 return TRUE;
2312 if (dyn_h->reloc_entries)
2314 struct elf64_hppa_dyn_reloc_entry *rent;
2315 int dynindx;
2317 hppa_info = elf64_hppa_hash_table (info);
2318 h = dyn_h->h;
2320 /* We may need to do a relocation against a local symbol, in
2321 which case we have to look up it's dynamic symbol index off
2322 the local symbol hash table. */
2323 if (h && h->dynindx != -1)
2324 dynindx = h->dynindx;
2325 else
2326 dynindx
2327 = _bfd_elf_link_lookup_local_dynindx (info, dyn_h->owner,
2328 dyn_h->sym_indx);
2330 for (rent = dyn_h->reloc_entries; rent; rent = rent->next)
2332 Elf_Internal_Rela rel;
2333 bfd_byte *loc;
2335 /* Allocate one iff we are building a shared library, the relocation
2336 isn't a R_PARISC_FPTR64, or we don't want an opd entry. */
2337 if (!info->shared && rent->type == R_PARISC_FPTR64 && dyn_h->want_opd)
2338 continue;
2340 /* Create a dynamic relocation for this entry.
2342 We need the output offset for the reloc's section because
2343 we are creating an absolute address in the resulting object
2344 file. */
2345 rel.r_offset = (rent->offset + rent->sec->output_offset
2346 + rent->sec->output_section->vma);
2348 /* An FPTR64 relocation implies that we took the address of
2349 a function and that the function has an entry in the .opd
2350 section. We want the FPTR64 relocation to reference the
2351 entry in .opd.
2353 We could munge the symbol value in the dynamic symbol table
2354 (in fact we already do for functions with global scope) to point
2355 to the .opd entry. Then we could use that dynamic symbol in
2356 this relocation.
2358 Or we could do something sensible, not munge the symbol's
2359 address and instead just use a different symbol to reference
2360 the .opd entry. At least that seems sensible until you
2361 realize there's no local dynamic symbols we can use for that
2362 purpose. Thus the hair in the check_relocs routine.
2364 We use a section symbol recorded by check_relocs as the
2365 base symbol for the relocation. The addend is the difference
2366 between the section symbol and the address of the .opd entry. */
2367 if (info->shared && rent->type == R_PARISC_FPTR64 && dyn_h->want_opd)
2369 bfd_vma value, value2;
2371 /* First compute the address of the opd entry for this symbol. */
2372 value = (dyn_h->opd_offset
2373 + hppa_info->opd_sec->output_section->vma
2374 + hppa_info->opd_sec->output_offset);
2376 /* Compute the value of the start of the section with
2377 the relocation. */
2378 value2 = (rent->sec->output_section->vma
2379 + rent->sec->output_offset);
2381 /* Compute the difference between the start of the section
2382 with the relocation and the opd entry. */
2383 value -= value2;
2385 /* The result becomes the addend of the relocation. */
2386 rel.r_addend = value;
2388 /* The section symbol becomes the symbol for the dynamic
2389 relocation. */
2390 dynindx
2391 = _bfd_elf_link_lookup_local_dynindx (info,
2392 rent->sec->owner,
2393 rent->sec_symndx);
2395 else
2396 rel.r_addend = rent->addend;
2398 rel.r_info = ELF64_R_INFO (dynindx, rent->type);
2400 loc = hppa_info->other_rel_sec->contents;
2401 loc += (hppa_info->other_rel_sec->reloc_count++
2402 * sizeof (Elf64_External_Rela));
2403 bfd_elf64_swap_reloca_out (hppa_info->other_rel_sec->output_section->owner,
2404 &rel, loc);
2408 return TRUE;
2411 /* Used to decide how to sort relocs in an optimal manner for the
2412 dynamic linker, before writing them out. */
2414 static enum elf_reloc_type_class
2415 elf64_hppa_reloc_type_class (rela)
2416 const Elf_Internal_Rela *rela;
2418 if (ELF64_R_SYM (rela->r_info) == 0)
2419 return reloc_class_relative;
2421 switch ((int) ELF64_R_TYPE (rela->r_info))
2423 case R_PARISC_IPLT:
2424 return reloc_class_plt;
2425 case R_PARISC_COPY:
2426 return reloc_class_copy;
2427 default:
2428 return reloc_class_normal;
2432 /* Finish up the dynamic sections. */
2434 static bfd_boolean
2435 elf64_hppa_finish_dynamic_sections (output_bfd, info)
2436 bfd *output_bfd;
2437 struct bfd_link_info *info;
2439 bfd *dynobj;
2440 asection *sdyn;
2441 struct elf64_hppa_link_hash_table *hppa_info;
2443 hppa_info = elf64_hppa_hash_table (info);
2445 /* Finalize the contents of the .opd section. */
2446 elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
2447 elf64_hppa_finalize_opd,
2448 info);
2450 elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
2451 elf64_hppa_finalize_dynreloc,
2452 info);
2454 /* Finalize the contents of the .dlt section. */
2455 dynobj = elf_hash_table (info)->dynobj;
2456 /* Finalize the contents of the .dlt section. */
2457 elf64_hppa_dyn_hash_traverse (&hppa_info->dyn_hash_table,
2458 elf64_hppa_finalize_dlt,
2459 info);
2461 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2463 if (elf_hash_table (info)->dynamic_sections_created)
2465 Elf64_External_Dyn *dyncon, *dynconend;
2467 BFD_ASSERT (sdyn != NULL);
2469 dyncon = (Elf64_External_Dyn *) sdyn->contents;
2470 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
2471 for (; dyncon < dynconend; dyncon++)
2473 Elf_Internal_Dyn dyn;
2474 asection *s;
2476 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
2478 switch (dyn.d_tag)
2480 default:
2481 break;
2483 case DT_HP_LOAD_MAP:
2484 /* Compute the absolute address of 16byte scratchpad area
2485 for the dynamic linker.
2487 By convention the linker script will allocate the scratchpad
2488 area at the start of the .data section. So all we have to
2489 to is find the start of the .data section. */
2490 s = bfd_get_section_by_name (output_bfd, ".data");
2491 dyn.d_un.d_ptr = s->vma;
2492 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2493 break;
2495 case DT_PLTGOT:
2496 /* HP's use PLTGOT to set the GOT register. */
2497 dyn.d_un.d_ptr = _bfd_get_gp_value (output_bfd);
2498 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2499 break;
2501 case DT_JMPREL:
2502 s = hppa_info->plt_rel_sec;
2503 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2504 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2505 break;
2507 case DT_PLTRELSZ:
2508 s = hppa_info->plt_rel_sec;
2509 dyn.d_un.d_val = s->size;
2510 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2511 break;
2513 case DT_RELA:
2514 s = hppa_info->other_rel_sec;
2515 if (! s || ! s->size)
2516 s = hppa_info->dlt_rel_sec;
2517 if (! s || ! s->size)
2518 s = hppa_info->opd_rel_sec;
2519 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2520 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2521 break;
2523 case DT_RELASZ:
2524 s = hppa_info->other_rel_sec;
2525 dyn.d_un.d_val = s->size;
2526 s = hppa_info->dlt_rel_sec;
2527 dyn.d_un.d_val += s->size;
2528 s = hppa_info->opd_rel_sec;
2529 dyn.d_un.d_val += s->size;
2530 /* There is some question about whether or not the size of
2531 the PLT relocs should be included here. HP's tools do
2532 it, so we'll emulate them. */
2533 s = hppa_info->plt_rel_sec;
2534 dyn.d_un.d_val += s->size;
2535 bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2536 break;
2542 return TRUE;
2545 /* Return the number of additional phdrs we will need.
2547 The generic ELF code only creates PT_PHDRs for executables. The HP
2548 dynamic linker requires PT_PHDRs for dynamic libraries too.
2550 This routine indicates that the backend needs one additional program
2551 header for that case.
2553 Note we do not have access to the link info structure here, so we have
2554 to guess whether or not we are building a shared library based on the
2555 existence of a .interp section. */
2557 static int
2558 elf64_hppa_additional_program_headers (abfd)
2559 bfd *abfd;
2561 asection *s;
2563 /* If we are creating a shared library, then we have to create a
2564 PT_PHDR segment. HP's dynamic linker chokes without it. */
2565 s = bfd_get_section_by_name (abfd, ".interp");
2566 if (! s)
2567 return 1;
2568 return 0;
2571 /* Allocate and initialize any program headers required by this
2572 specific backend.
2574 The generic ELF code only creates PT_PHDRs for executables. The HP
2575 dynamic linker requires PT_PHDRs for dynamic libraries too.
2577 This allocates the PT_PHDR and initializes it in a manner suitable
2578 for the HP linker.
2580 Note we do not have access to the link info structure here, so we have
2581 to guess whether or not we are building a shared library based on the
2582 existence of a .interp section. */
2584 static bfd_boolean
2585 elf64_hppa_modify_segment_map (abfd, info)
2586 bfd *abfd;
2587 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2589 struct elf_segment_map *m;
2590 asection *s;
2592 s = bfd_get_section_by_name (abfd, ".interp");
2593 if (! s)
2595 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
2596 if (m->p_type == PT_PHDR)
2597 break;
2598 if (m == NULL)
2600 m = ((struct elf_segment_map *)
2601 bfd_zalloc (abfd, (bfd_size_type) sizeof *m));
2602 if (m == NULL)
2603 return FALSE;
2605 m->p_type = PT_PHDR;
2606 m->p_flags = PF_R | PF_X;
2607 m->p_flags_valid = 1;
2608 m->p_paddr_valid = 1;
2609 m->includes_phdrs = 1;
2611 m->next = elf_tdata (abfd)->segment_map;
2612 elf_tdata (abfd)->segment_map = m;
2616 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
2617 if (m->p_type == PT_LOAD)
2619 unsigned int i;
2621 for (i = 0; i < m->count; i++)
2623 /* The code "hint" is not really a hint. It is a requirement
2624 for certain versions of the HP dynamic linker. Worse yet,
2625 it must be set even if the shared library does not have
2626 any code in its "text" segment (thus the check for .hash
2627 to catch this situation). */
2628 if (m->sections[i]->flags & SEC_CODE
2629 || (strcmp (m->sections[i]->name, ".hash") == 0))
2630 m->p_flags |= (PF_X | PF_HP_CODE);
2634 return TRUE;
2637 /* Called when writing out an object file to decide the type of a
2638 symbol. */
2639 static int
2640 elf64_hppa_elf_get_symbol_type (elf_sym, type)
2641 Elf_Internal_Sym *elf_sym;
2642 int type;
2644 if (ELF_ST_TYPE (elf_sym->st_info) == STT_PARISC_MILLI)
2645 return STT_PARISC_MILLI;
2646 else
2647 return type;
2650 /* Support HP specific sections for core files. */
2651 static bfd_boolean
2652 elf64_hppa_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int index,
2653 const char *typename)
2655 if (hdr->p_type == PT_HP_CORE_KERNEL)
2657 asection *sect;
2659 if (!_bfd_elf_make_section_from_phdr (abfd, hdr, index, typename))
2660 return FALSE;
2662 sect = bfd_make_section_anyway (abfd, ".kernel");
2663 if (sect == NULL)
2664 return FALSE;
2665 sect->size = hdr->p_filesz;
2666 sect->filepos = hdr->p_offset;
2667 sect->flags = SEC_HAS_CONTENTS | SEC_READONLY;
2668 return TRUE;
2671 if (hdr->p_type == PT_HP_CORE_PROC)
2673 int sig;
2675 if (bfd_seek (abfd, hdr->p_offset, SEEK_SET) != 0)
2676 return FALSE;
2677 if (bfd_bread (&sig, 4, abfd) != 4)
2678 return FALSE;
2680 elf_tdata (abfd)->core_signal = sig;
2682 if (!_bfd_elf_make_section_from_phdr (abfd, hdr, index, typename))
2683 return FALSE;
2685 /* GDB uses the ".reg" section to read register contents. */
2686 return _bfd_elfcore_make_pseudosection (abfd, ".reg", hdr->p_filesz,
2687 hdr->p_offset);
2690 if (hdr->p_type == PT_HP_CORE_LOADABLE
2691 || hdr->p_type == PT_HP_CORE_STACK
2692 || hdr->p_type == PT_HP_CORE_MMF)
2693 hdr->p_type = PT_LOAD;
2695 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, typename);
2698 static const struct bfd_elf_special_section elf64_hppa_special_sections[] =
2700 { ".fini", 5, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2701 { ".init", 5, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2702 { ".plt", 4, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },
2703 { ".dlt", 4, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },
2704 { ".sdata", 6, 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },
2705 { ".sbss", 5, 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },
2706 { ".tbss", 5, 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_WEAKORDER },
2707 { NULL, 0, 0, 0, 0 }
2710 /* The hash bucket size is the standard one, namely 4. */
2712 const struct elf_size_info hppa64_elf_size_info =
2714 sizeof (Elf64_External_Ehdr),
2715 sizeof (Elf64_External_Phdr),
2716 sizeof (Elf64_External_Shdr),
2717 sizeof (Elf64_External_Rel),
2718 sizeof (Elf64_External_Rela),
2719 sizeof (Elf64_External_Sym),
2720 sizeof (Elf64_External_Dyn),
2721 sizeof (Elf_External_Note),
2724 64, 3,
2725 ELFCLASS64, EV_CURRENT,
2726 bfd_elf64_write_out_phdrs,
2727 bfd_elf64_write_shdrs_and_ehdr,
2728 bfd_elf64_write_relocs,
2729 bfd_elf64_swap_symbol_in,
2730 bfd_elf64_swap_symbol_out,
2731 bfd_elf64_slurp_reloc_table,
2732 bfd_elf64_slurp_symbol_table,
2733 bfd_elf64_swap_dyn_in,
2734 bfd_elf64_swap_dyn_out,
2735 bfd_elf64_swap_reloc_in,
2736 bfd_elf64_swap_reloc_out,
2737 bfd_elf64_swap_reloca_in,
2738 bfd_elf64_swap_reloca_out
2741 #define TARGET_BIG_SYM bfd_elf64_hppa_vec
2742 #define TARGET_BIG_NAME "elf64-hppa"
2743 #define ELF_ARCH bfd_arch_hppa
2744 #define ELF_MACHINE_CODE EM_PARISC
2745 /* This is not strictly correct. The maximum page size for PA2.0 is
2746 64M. But everything still uses 4k. */
2747 #define ELF_MAXPAGESIZE 0x1000
2748 #define bfd_elf64_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
2749 #define bfd_elf64_bfd_is_local_label_name elf_hppa_is_local_label_name
2750 #define elf_info_to_howto elf_hppa_info_to_howto
2751 #define elf_info_to_howto_rel elf_hppa_info_to_howto_rel
2753 #define elf_backend_section_from_shdr elf64_hppa_section_from_shdr
2754 #define elf_backend_object_p elf64_hppa_object_p
2755 #define elf_backend_final_write_processing \
2756 elf_hppa_final_write_processing
2757 #define elf_backend_fake_sections elf_hppa_fake_sections
2758 #define elf_backend_add_symbol_hook elf_hppa_add_symbol_hook
2760 #define elf_backend_relocate_section elf_hppa_relocate_section
2762 #define bfd_elf64_bfd_final_link elf_hppa_final_link
2764 #define elf_backend_create_dynamic_sections \
2765 elf64_hppa_create_dynamic_sections
2766 #define elf_backend_post_process_headers elf64_hppa_post_process_headers
2768 #define elf_backend_adjust_dynamic_symbol \
2769 elf64_hppa_adjust_dynamic_symbol
2771 #define elf_backend_size_dynamic_sections \
2772 elf64_hppa_size_dynamic_sections
2774 #define elf_backend_finish_dynamic_symbol \
2775 elf64_hppa_finish_dynamic_symbol
2776 #define elf_backend_finish_dynamic_sections \
2777 elf64_hppa_finish_dynamic_sections
2779 /* Stuff for the BFD linker: */
2780 #define bfd_elf64_bfd_link_hash_table_create \
2781 elf64_hppa_hash_table_create
2783 #define elf_backend_check_relocs \
2784 elf64_hppa_check_relocs
2786 #define elf_backend_size_info \
2787 hppa64_elf_size_info
2789 #define elf_backend_additional_program_headers \
2790 elf64_hppa_additional_program_headers
2792 #define elf_backend_modify_segment_map \
2793 elf64_hppa_modify_segment_map
2795 #define elf_backend_link_output_symbol_hook \
2796 elf64_hppa_link_output_symbol_hook
2798 #define elf_backend_want_got_plt 0
2799 #define elf_backend_plt_readonly 0
2800 #define elf_backend_want_plt_sym 0
2801 #define elf_backend_got_header_size 0
2802 #define elf_backend_type_change_ok TRUE
2803 #define elf_backend_get_symbol_type elf64_hppa_elf_get_symbol_type
2804 #define elf_backend_reloc_type_class elf64_hppa_reloc_type_class
2805 #define elf_backend_rela_normal 1
2806 #define elf_backend_special_sections elf64_hppa_special_sections
2807 #define elf_backend_action_discarded elf_hppa_action_discarded
2808 #define elf_backend_section_from_phdr elf64_hppa_section_from_phdr
2810 #include "elf64-target.h"
2812 #undef TARGET_BIG_SYM
2813 #define TARGET_BIG_SYM bfd_elf64_hppa_linux_vec
2814 #undef TARGET_BIG_NAME
2815 #define TARGET_BIG_NAME "elf64-hppa-linux"
2817 #undef elf_backend_special_sections
2819 #define INCLUDED_TARGET_FILE 1
2820 #include "elf64-target.h"