Automatic date update in version.in
[external/binutils.git] / bfd / elf64-hppa.c
1 /* Support for HPPA 64-bit ELF
2    Copyright (C) 1999-2018 Free Software Foundation, Inc.
3
4    This file is part of BFD, the Binary File Descriptor library.
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
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.
15
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19    MA 02110-1301, USA.  */
20
21 #include "sysdep.h"
22 #include "alloca-conf.h"
23 #include "bfd.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 #include "libiberty.h"
30
31 #define ARCH_SIZE              64
32
33 #define PLT_ENTRY_SIZE 0x10
34 #define DLT_ENTRY_SIZE 0x8
35 #define OPD_ENTRY_SIZE 0x20
36
37 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/pa20_64/dld.sl"
38
39 /* The stub is supposed to load the target address and target's DP
40    value out of the PLT, then do an external branch to the target
41    address.
42
43    LDD PLTOFF(%r27),%r1
44    BVE (%r1)
45    LDD PLTOFF+8(%r27),%r27
46
47    Note that we must use the LDD with a 14 bit displacement, not the one
48    with a 5 bit displacement.  */
49 static char plt_stub[] = {0x53, 0x61, 0x00, 0x00, 0xe8, 0x20, 0xd0, 0x00,
50                           0x53, 0x7b, 0x00, 0x00 };
51
52 struct elf64_hppa_link_hash_entry
53 {
54   struct elf_link_hash_entry eh;
55
56   /* Offsets for this symbol in various linker sections.  */
57   bfd_vma dlt_offset;
58   bfd_vma plt_offset;
59   bfd_vma opd_offset;
60   bfd_vma stub_offset;
61
62   /* The index of the (possibly local) symbol in the input bfd and its
63      associated BFD.  Needed so that we can have relocs against local
64      symbols in shared libraries.  */
65   long sym_indx;
66   bfd *owner;
67
68   /* Dynamic symbols may need to have two different values.  One for
69      the dynamic symbol table, one for the normal symbol table.
70
71      In such cases we store the symbol's real value and section
72      index here so we can restore the real value before we write
73      the normal symbol table.  */
74   bfd_vma st_value;
75   int st_shndx;
76
77   /* Used to count non-got, non-plt relocations for delayed sizing
78      of relocation sections.  */
79   struct elf64_hppa_dyn_reloc_entry
80   {
81     /* Next relocation in the chain.  */
82     struct elf64_hppa_dyn_reloc_entry *next;
83
84     /* The type of the relocation.  */
85     int type;
86
87     /* The input section of the relocation.  */
88     asection *sec;
89
90     /* Number of relocs copied in this section.  */
91     bfd_size_type count;
92
93     /* The index of the section symbol for the input section of
94        the relocation.  Only needed when building shared libraries.  */
95     int sec_symndx;
96
97     /* The offset within the input section of the relocation.  */
98     bfd_vma offset;
99
100     /* The addend for the relocation.  */
101     bfd_vma addend;
102
103   } *reloc_entries;
104
105   /* Nonzero if this symbol needs an entry in one of the linker
106      sections.  */
107   unsigned want_dlt;
108   unsigned want_plt;
109   unsigned want_opd;
110   unsigned want_stub;
111 };
112
113 struct elf64_hppa_link_hash_table
114 {
115   struct elf_link_hash_table root;
116
117   /* Shortcuts to get to the various linker defined sections.  */
118   asection *dlt_sec;
119   asection *dlt_rel_sec;
120   asection *plt_sec;
121   asection *plt_rel_sec;
122   asection *opd_sec;
123   asection *opd_rel_sec;
124   asection *other_rel_sec;
125
126   /* Offset of __gp within .plt section.  When the PLT gets large we want
127      to slide __gp into the PLT section so that we can continue to use
128      single DP relative instructions to load values out of the PLT.  */
129   bfd_vma gp_offset;
130
131   /* Note this is not strictly correct.  We should create a stub section for
132      each input section with calls.  The stub section should be placed before
133      the section with the call.  */
134   asection *stub_sec;
135
136   bfd_vma text_segment_base;
137   bfd_vma data_segment_base;
138
139   /* We build tables to map from an input section back to its
140      symbol index.  This is the BFD for which we currently have
141      a map.  */
142   bfd *section_syms_bfd;
143
144   /* Array of symbol numbers for each input section attached to the
145      current BFD.  */
146   int *section_syms;
147 };
148
149 #define hppa_link_hash_table(p) \
150   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
151   == HPPA64_ELF_DATA ? ((struct elf64_hppa_link_hash_table *) ((p)->hash)) : NULL)
152
153 #define hppa_elf_hash_entry(ent) \
154   ((struct elf64_hppa_link_hash_entry *)(ent))
155
156 #define eh_name(eh) \
157   (eh ? eh->root.root.string : "<undef>")
158
159 typedef struct bfd_hash_entry *(*new_hash_entry_func)
160   (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
161
162 static struct bfd_link_hash_table *elf64_hppa_hash_table_create
163   (bfd *abfd);
164
165 /* This must follow the definitions of the various derived linker
166    hash tables and shared functions.  */
167 #include "elf-hppa.h"
168
169 static bfd_boolean elf64_hppa_object_p
170   (bfd *);
171
172 static void elf64_hppa_post_process_headers
173   (bfd *, struct bfd_link_info *);
174
175 static bfd_boolean elf64_hppa_create_dynamic_sections
176   (bfd *, struct bfd_link_info *);
177
178 static bfd_boolean elf64_hppa_adjust_dynamic_symbol
179   (struct bfd_link_info *, struct elf_link_hash_entry *);
180
181 static bfd_boolean elf64_hppa_mark_milli_and_exported_functions
182   (struct elf_link_hash_entry *, void *);
183
184 static bfd_boolean elf64_hppa_size_dynamic_sections
185   (bfd *, struct bfd_link_info *);
186
187 static int elf64_hppa_link_output_symbol_hook
188   (struct bfd_link_info *, const char *, Elf_Internal_Sym *,
189    asection *, struct elf_link_hash_entry *);
190
191 static bfd_boolean elf64_hppa_finish_dynamic_symbol
192   (bfd *, struct bfd_link_info *,
193    struct elf_link_hash_entry *, Elf_Internal_Sym *);
194
195 static bfd_boolean elf64_hppa_finish_dynamic_sections
196   (bfd *, struct bfd_link_info *);
197
198 static bfd_boolean elf64_hppa_check_relocs
199   (bfd *, struct bfd_link_info *,
200    asection *, const Elf_Internal_Rela *);
201
202 static bfd_boolean elf64_hppa_dynamic_symbol_p
203   (struct elf_link_hash_entry *, struct bfd_link_info *);
204
205 static bfd_boolean elf64_hppa_mark_exported_functions
206   (struct elf_link_hash_entry *, void *);
207
208 static bfd_boolean elf64_hppa_finalize_opd
209   (struct elf_link_hash_entry *, void *);
210
211 static bfd_boolean elf64_hppa_finalize_dlt
212   (struct elf_link_hash_entry *, void *);
213
214 static bfd_boolean allocate_global_data_dlt
215   (struct elf_link_hash_entry *, void *);
216
217 static bfd_boolean allocate_global_data_plt
218   (struct elf_link_hash_entry *, void *);
219
220 static bfd_boolean allocate_global_data_stub
221   (struct elf_link_hash_entry *, void *);
222
223 static bfd_boolean allocate_global_data_opd
224   (struct elf_link_hash_entry *, void *);
225
226 static bfd_boolean get_reloc_section
227   (bfd *, struct elf64_hppa_link_hash_table *, asection *);
228
229 static bfd_boolean count_dyn_reloc
230   (bfd *, struct elf64_hppa_link_hash_entry *,
231    int, asection *, int, bfd_vma, bfd_vma);
232
233 static bfd_boolean allocate_dynrel_entries
234   (struct elf_link_hash_entry *, void *);
235
236 static bfd_boolean elf64_hppa_finalize_dynreloc
237   (struct elf_link_hash_entry *, void *);
238
239 static bfd_boolean get_opd
240   (bfd *, struct bfd_link_info *, struct elf64_hppa_link_hash_table *);
241
242 static bfd_boolean get_plt
243   (bfd *, struct bfd_link_info *, struct elf64_hppa_link_hash_table *);
244
245 static bfd_boolean get_dlt
246   (bfd *, struct bfd_link_info *, struct elf64_hppa_link_hash_table *);
247
248 static bfd_boolean get_stub
249   (bfd *, struct bfd_link_info *, struct elf64_hppa_link_hash_table *);
250
251 static int elf64_hppa_elf_get_symbol_type
252   (Elf_Internal_Sym *, int);
253
254 /* Initialize an entry in the link hash table.  */
255
256 static struct bfd_hash_entry *
257 hppa64_link_hash_newfunc (struct bfd_hash_entry *entry,
258                           struct bfd_hash_table *table,
259                           const char *string)
260 {
261   /* Allocate the structure if it has not already been allocated by a
262      subclass.  */
263   if (entry == NULL)
264     {
265       entry = bfd_hash_allocate (table,
266                                  sizeof (struct elf64_hppa_link_hash_entry));
267       if (entry == NULL)
268         return entry;
269     }
270
271   /* Call the allocation method of the superclass.  */
272   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
273   if (entry != NULL)
274     {
275       struct elf64_hppa_link_hash_entry *hh;
276
277       /* Initialize our local data.  All zeros.  */
278       hh = hppa_elf_hash_entry (entry);
279       memset (&hh->dlt_offset, 0,
280               (sizeof (struct elf64_hppa_link_hash_entry)
281                - offsetof (struct elf64_hppa_link_hash_entry, dlt_offset)));
282     }
283
284   return entry;
285 }
286
287 /* Create the derived linker hash table.  The PA64 ELF port uses this
288    derived hash table to keep information specific to the PA ElF
289    linker (without using static variables).  */
290
291 static struct bfd_link_hash_table*
292 elf64_hppa_hash_table_create (bfd *abfd)
293 {
294   struct elf64_hppa_link_hash_table *htab;
295   bfd_size_type amt = sizeof (*htab);
296
297   htab = bfd_zmalloc (amt);
298   if (htab == NULL)
299     return NULL;
300
301   if (!_bfd_elf_link_hash_table_init (&htab->root, abfd,
302                                       hppa64_link_hash_newfunc,
303                                       sizeof (struct elf64_hppa_link_hash_entry),
304                                       HPPA64_ELF_DATA))
305     {
306       free (htab);
307       return NULL;
308     }
309
310   htab->text_segment_base = (bfd_vma) -1;
311   htab->data_segment_base = (bfd_vma) -1;
312
313   return &htab->root.root;
314 }
315 \f
316 /* Return nonzero if ABFD represents a PA2.0 ELF64 file.
317
318    Additionally we set the default architecture and machine.  */
319 static bfd_boolean
320 elf64_hppa_object_p (bfd *abfd)
321 {
322   Elf_Internal_Ehdr * i_ehdrp;
323   unsigned int flags;
324
325   i_ehdrp = elf_elfheader (abfd);
326   if (strcmp (bfd_get_target (abfd), "elf64-hppa-linux") == 0)
327     {
328       /* GCC on hppa-linux produces binaries with OSABI=GNU,
329          but the kernel produces corefiles with OSABI=SysV.  */
330       if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_GNU
331           && i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */
332         return FALSE;
333     }
334   else
335     {
336       /* HPUX produces binaries with OSABI=HPUX,
337          but the kernel produces corefiles with OSABI=SysV.  */
338       if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_HPUX
339           && i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */
340         return FALSE;
341     }
342
343   flags = i_ehdrp->e_flags;
344   switch (flags & (EF_PARISC_ARCH | EF_PARISC_WIDE))
345     {
346     case EFA_PARISC_1_0:
347       return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 10);
348     case EFA_PARISC_1_1:
349       return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 11);
350     case EFA_PARISC_2_0:
351       if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
352         return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25);
353       else
354         return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 20);
355     case EFA_PARISC_2_0 | EF_PARISC_WIDE:
356       return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25);
357     }
358   /* Don't be fussy.  */
359   return TRUE;
360 }
361
362 /* Given section type (hdr->sh_type), return a boolean indicating
363    whether or not the section is an elf64-hppa specific section.  */
364 static bfd_boolean
365 elf64_hppa_section_from_shdr (bfd *abfd,
366                               Elf_Internal_Shdr *hdr,
367                               const char *name,
368                               int shindex)
369 {
370   switch (hdr->sh_type)
371     {
372     case SHT_PARISC_EXT:
373       if (strcmp (name, ".PARISC.archext") != 0)
374         return FALSE;
375       break;
376     case SHT_PARISC_UNWIND:
377       if (strcmp (name, ".PARISC.unwind") != 0)
378         return FALSE;
379       break;
380     case SHT_PARISC_DOC:
381     case SHT_PARISC_ANNOT:
382     default:
383       return FALSE;
384     }
385
386   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
387     return FALSE;
388
389   return TRUE;
390 }
391
392 /* SEC is a section containing relocs for an input BFD when linking; return
393    a suitable section for holding relocs in the output BFD for a link.  */
394
395 static bfd_boolean
396 get_reloc_section (bfd *abfd,
397                    struct elf64_hppa_link_hash_table *hppa_info,
398                    asection *sec)
399 {
400   const char *srel_name;
401   asection *srel;
402   bfd *dynobj;
403
404   srel_name = (bfd_elf_string_from_elf_section
405                (abfd, elf_elfheader(abfd)->e_shstrndx,
406                 _bfd_elf_single_rel_hdr(sec)->sh_name));
407   if (srel_name == NULL)
408     return FALSE;
409
410   dynobj = hppa_info->root.dynobj;
411   if (!dynobj)
412     hppa_info->root.dynobj = dynobj = abfd;
413
414   srel = bfd_get_linker_section (dynobj, srel_name);
415   if (srel == NULL)
416     {
417       srel = bfd_make_section_anyway_with_flags (dynobj, srel_name,
418                                                  (SEC_ALLOC
419                                                   | SEC_LOAD
420                                                   | SEC_HAS_CONTENTS
421                                                   | SEC_IN_MEMORY
422                                                   | SEC_LINKER_CREATED
423                                                   | SEC_READONLY));
424       if (srel == NULL
425           || !bfd_set_section_alignment (dynobj, srel, 3))
426         return FALSE;
427     }
428
429   hppa_info->other_rel_sec = srel;
430   return TRUE;
431 }
432
433 /* Add a new entry to the list of dynamic relocations against DYN_H.
434
435    We use this to keep a record of all the FPTR relocations against a
436    particular symbol so that we can create FPTR relocations in the
437    output file.  */
438
439 static bfd_boolean
440 count_dyn_reloc (bfd *abfd,
441                  struct elf64_hppa_link_hash_entry *hh,
442                  int type,
443                  asection *sec,
444                  int sec_symndx,
445                  bfd_vma offset,
446                  bfd_vma addend)
447 {
448   struct elf64_hppa_dyn_reloc_entry *rent;
449
450   rent = (struct elf64_hppa_dyn_reloc_entry *)
451   bfd_alloc (abfd, (bfd_size_type) sizeof (*rent));
452   if (!rent)
453     return FALSE;
454
455   rent->next = hh->reloc_entries;
456   rent->type = type;
457   rent->sec = sec;
458   rent->sec_symndx = sec_symndx;
459   rent->offset = offset;
460   rent->addend = addend;
461   hh->reloc_entries = rent;
462
463   return TRUE;
464 }
465
466 /* Return a pointer to the local DLT, PLT and OPD reference counts
467    for ABFD.  Returns NULL if the storage allocation fails.  */
468
469 static bfd_signed_vma *
470 hppa64_elf_local_refcounts (bfd *abfd)
471 {
472   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
473   bfd_signed_vma *local_refcounts;
474
475   local_refcounts = elf_local_got_refcounts (abfd);
476   if (local_refcounts == NULL)
477     {
478       bfd_size_type size;
479
480       /* Allocate space for local DLT, PLT and OPD reference
481          counts.  Done this way to save polluting elf_obj_tdata
482          with another target specific pointer.  */
483       size = symtab_hdr->sh_info;
484       size *= 3 * sizeof (bfd_signed_vma);
485       local_refcounts = bfd_zalloc (abfd, size);
486       elf_local_got_refcounts (abfd) = local_refcounts;
487     }
488   return local_refcounts;
489 }
490
491 /* Scan the RELOCS and record the type of dynamic entries that each
492    referenced symbol needs.  */
493
494 static bfd_boolean
495 elf64_hppa_check_relocs (bfd *abfd,
496                          struct bfd_link_info *info,
497                          asection *sec,
498                          const Elf_Internal_Rela *relocs)
499 {
500   struct elf64_hppa_link_hash_table *hppa_info;
501   const Elf_Internal_Rela *relend;
502   Elf_Internal_Shdr *symtab_hdr;
503   const Elf_Internal_Rela *rel;
504   unsigned int sec_symndx;
505
506   if (bfd_link_relocatable (info))
507     return TRUE;
508
509   /* If this is the first dynamic object found in the link, create
510      the special sections required for dynamic linking.  */
511   if (! elf_hash_table (info)->dynamic_sections_created)
512     {
513       if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
514         return FALSE;
515     }
516
517   hppa_info = hppa_link_hash_table (info);
518   if (hppa_info == NULL)
519     return FALSE;
520   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
521
522   /* If necessary, build a new table holding section symbols indices
523      for this BFD.  */
524
525   if (bfd_link_pic (info) && hppa_info->section_syms_bfd != abfd)
526     {
527       unsigned long i;
528       unsigned int highest_shndx;
529       Elf_Internal_Sym *local_syms = NULL;
530       Elf_Internal_Sym *isym, *isymend;
531       bfd_size_type amt;
532
533       /* We're done with the old cache of section index to section symbol
534          index information.  Free it.
535
536          ?!? Note we leak the last section_syms array.  Presumably we
537          could free it in one of the later routines in this file.  */
538       if (hppa_info->section_syms)
539         free (hppa_info->section_syms);
540
541       /* Read this BFD's local symbols.  */
542       if (symtab_hdr->sh_info != 0)
543         {
544           local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
545           if (local_syms == NULL)
546             local_syms = bfd_elf_get_elf_syms (abfd, symtab_hdr,
547                                                symtab_hdr->sh_info, 0,
548                                                NULL, NULL, NULL);
549           if (local_syms == NULL)
550             return FALSE;
551         }
552
553       /* Record the highest section index referenced by the local symbols.  */
554       highest_shndx = 0;
555       isymend = local_syms + symtab_hdr->sh_info;
556       for (isym = local_syms; isym < isymend; isym++)
557         {
558           if (isym->st_shndx > highest_shndx
559               && isym->st_shndx < SHN_LORESERVE)
560             highest_shndx = isym->st_shndx;
561         }
562
563       /* Allocate an array to hold the section index to section symbol index
564          mapping.  Bump by one since we start counting at zero.  */
565       highest_shndx++;
566       amt = highest_shndx;
567       amt *= sizeof (int);
568       hppa_info->section_syms = (int *) bfd_malloc (amt);
569
570       /* Now walk the local symbols again.  If we find a section symbol,
571          record the index of the symbol into the section_syms array.  */
572       for (i = 0, isym = local_syms; isym < isymend; i++, isym++)
573         {
574           if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
575             hppa_info->section_syms[isym->st_shndx] = i;
576         }
577
578       /* We are finished with the local symbols.  */
579       if (local_syms != NULL
580           && symtab_hdr->contents != (unsigned char *) local_syms)
581         {
582           if (! info->keep_memory)
583             free (local_syms);
584           else
585             {
586               /* Cache the symbols for elf_link_input_bfd.  */
587               symtab_hdr->contents = (unsigned char *) local_syms;
588             }
589         }
590
591       /* Record which BFD we built the section_syms mapping for.  */
592       hppa_info->section_syms_bfd = abfd;
593     }
594
595   /* Record the symbol index for this input section.  We may need it for
596      relocations when building shared libraries.  When not building shared
597      libraries this value is never really used, but assign it to zero to
598      prevent out of bounds memory accesses in other routines.  */
599   if (bfd_link_pic (info))
600     {
601       sec_symndx = _bfd_elf_section_from_bfd_section (abfd, sec);
602
603       /* If we did not find a section symbol for this section, then
604          something went terribly wrong above.  */
605       if (sec_symndx == SHN_BAD)
606         return FALSE;
607
608       if (sec_symndx < SHN_LORESERVE)
609         sec_symndx = hppa_info->section_syms[sec_symndx];
610       else
611         sec_symndx = 0;
612     }
613   else
614     sec_symndx = 0;
615
616   relend = relocs + sec->reloc_count;
617   for (rel = relocs; rel < relend; ++rel)
618     {
619       enum
620         {
621           NEED_DLT = 1,
622           NEED_PLT = 2,
623           NEED_STUB = 4,
624           NEED_OPD = 8,
625           NEED_DYNREL = 16,
626         };
627
628       unsigned long r_symndx = ELF64_R_SYM (rel->r_info);
629       struct elf64_hppa_link_hash_entry *hh;
630       int need_entry;
631       bfd_boolean maybe_dynamic;
632       int dynrel_type = R_PARISC_NONE;
633       static reloc_howto_type *howto;
634
635       if (r_symndx >= symtab_hdr->sh_info)
636         {
637           /* We're dealing with a global symbol -- find its hash entry
638              and mark it as being referenced.  */
639           long indx = r_symndx - symtab_hdr->sh_info;
640           hh = hppa_elf_hash_entry (elf_sym_hashes (abfd)[indx]);
641           while (hh->eh.root.type == bfd_link_hash_indirect
642                  || hh->eh.root.type == bfd_link_hash_warning)
643             hh = hppa_elf_hash_entry (hh->eh.root.u.i.link);
644
645           /* PR15323, ref flags aren't set for references in the same
646              object.  */
647           hh->eh.ref_regular = 1;
648         }
649       else
650         hh = NULL;
651
652       /* We can only get preliminary data on whether a symbol is
653          locally or externally defined, as not all of the input files
654          have yet been processed.  Do something with what we know, as
655          this may help reduce memory usage and processing time later.  */
656       maybe_dynamic = FALSE;
657       if (hh && ((bfd_link_pic (info)
658                  && (!info->symbolic
659                      || info->unresolved_syms_in_shared_libs == RM_IGNORE))
660                 || !hh->eh.def_regular
661                 || hh->eh.root.type == bfd_link_hash_defweak))
662         maybe_dynamic = TRUE;
663
664       howto = elf_hppa_howto_table + ELF64_R_TYPE (rel->r_info);
665       need_entry = 0;
666       switch (howto->type)
667         {
668         /* These are simple indirect references to symbols through the
669            DLT.  We need to create a DLT entry for any symbols which
670            appears in a DLTIND relocation.  */
671         case R_PARISC_DLTIND21L:
672         case R_PARISC_DLTIND14R:
673         case R_PARISC_DLTIND14F:
674         case R_PARISC_DLTIND14WR:
675         case R_PARISC_DLTIND14DR:
676           need_entry = NEED_DLT;
677           break;
678
679         /* ?!?  These need a DLT entry.  But I have no idea what to do with
680            the "link time TP value.  */
681         case R_PARISC_LTOFF_TP21L:
682         case R_PARISC_LTOFF_TP14R:
683         case R_PARISC_LTOFF_TP14F:
684         case R_PARISC_LTOFF_TP64:
685         case R_PARISC_LTOFF_TP14WR:
686         case R_PARISC_LTOFF_TP14DR:
687         case R_PARISC_LTOFF_TP16F:
688         case R_PARISC_LTOFF_TP16WF:
689         case R_PARISC_LTOFF_TP16DF:
690           need_entry = NEED_DLT;
691           break;
692
693         /* These are function calls.  Depending on their precise target we
694            may need to make a stub for them.  The stub uses the PLT, so we
695            need to create PLT entries for these symbols too.  */
696         case R_PARISC_PCREL12F:
697         case R_PARISC_PCREL17F:
698         case R_PARISC_PCREL22F:
699         case R_PARISC_PCREL32:
700         case R_PARISC_PCREL64:
701         case R_PARISC_PCREL21L:
702         case R_PARISC_PCREL17R:
703         case R_PARISC_PCREL17C:
704         case R_PARISC_PCREL14R:
705         case R_PARISC_PCREL14F:
706         case R_PARISC_PCREL22C:
707         case R_PARISC_PCREL14WR:
708         case R_PARISC_PCREL14DR:
709         case R_PARISC_PCREL16F:
710         case R_PARISC_PCREL16WF:
711         case R_PARISC_PCREL16DF:
712           /* Function calls might need to go through the .plt, and
713              might need a long branch stub.  */
714           if (hh != NULL && hh->eh.type != STT_PARISC_MILLI)
715             need_entry = (NEED_PLT | NEED_STUB);
716           else
717             need_entry = 0;
718           break;
719
720         case R_PARISC_PLTOFF21L:
721         case R_PARISC_PLTOFF14R:
722         case R_PARISC_PLTOFF14F:
723         case R_PARISC_PLTOFF14WR:
724         case R_PARISC_PLTOFF14DR:
725         case R_PARISC_PLTOFF16F:
726         case R_PARISC_PLTOFF16WF:
727         case R_PARISC_PLTOFF16DF:
728           need_entry = (NEED_PLT);
729           break;
730
731         case R_PARISC_DIR64:
732           if (bfd_link_pic (info) || maybe_dynamic)
733             need_entry = (NEED_DYNREL);
734           dynrel_type = R_PARISC_DIR64;
735           break;
736
737         /* This is an indirect reference through the DLT to get the address
738            of a OPD descriptor.  Thus we need to make a DLT entry that points
739            to an OPD entry.  */
740         case R_PARISC_LTOFF_FPTR21L:
741         case R_PARISC_LTOFF_FPTR14R:
742         case R_PARISC_LTOFF_FPTR14WR:
743         case R_PARISC_LTOFF_FPTR14DR:
744         case R_PARISC_LTOFF_FPTR32:
745         case R_PARISC_LTOFF_FPTR64:
746         case R_PARISC_LTOFF_FPTR16F:
747         case R_PARISC_LTOFF_FPTR16WF:
748         case R_PARISC_LTOFF_FPTR16DF:
749           if (bfd_link_pic (info) || maybe_dynamic)
750             need_entry = (NEED_DLT | NEED_OPD | NEED_PLT);
751           else
752             need_entry = (NEED_DLT | NEED_OPD | NEED_PLT);
753           dynrel_type = R_PARISC_FPTR64;
754           break;
755
756         /* This is a simple OPD entry.  */
757         case R_PARISC_FPTR64:
758           if (bfd_link_pic (info) || maybe_dynamic)
759             need_entry = (NEED_OPD | NEED_PLT | NEED_DYNREL);
760           else
761             need_entry = (NEED_OPD | NEED_PLT);
762           dynrel_type = R_PARISC_FPTR64;
763           break;
764
765         /* Add more cases as needed.  */
766         }
767
768       if (!need_entry)
769         continue;
770
771       if (hh)
772         {
773           /* Stash away enough information to be able to find this symbol
774              regardless of whether or not it is local or global.  */
775           hh->owner = abfd;
776           hh->sym_indx = r_symndx;
777         }
778
779       /* Create what's needed.  */
780       if (need_entry & NEED_DLT)
781         {
782           /* Allocate space for a DLT entry, as well as a dynamic
783              relocation for this entry.  */
784           if (! hppa_info->dlt_sec
785               && ! get_dlt (abfd, info, hppa_info))
786             goto err_out;
787
788           if (hh != NULL)
789             {
790               hh->want_dlt = 1;
791               hh->eh.got.refcount += 1;
792             }
793           else
794             {
795               bfd_signed_vma *local_dlt_refcounts;
796
797               /* This is a DLT entry for a local symbol.  */
798               local_dlt_refcounts = hppa64_elf_local_refcounts (abfd);
799               if (local_dlt_refcounts == NULL)
800                 return FALSE;
801               local_dlt_refcounts[r_symndx] += 1;
802             }
803         }
804
805       if (need_entry & NEED_PLT)
806         {
807           if (! hppa_info->plt_sec
808               && ! get_plt (abfd, info, hppa_info))
809             goto err_out;
810
811           if (hh != NULL)
812             {
813               hh->want_plt = 1;
814               hh->eh.needs_plt = 1;
815               hh->eh.plt.refcount += 1;
816             }
817           else
818             {
819               bfd_signed_vma *local_dlt_refcounts;
820               bfd_signed_vma *local_plt_refcounts;
821
822               /* This is a PLT entry for a local symbol.  */
823               local_dlt_refcounts = hppa64_elf_local_refcounts (abfd);
824               if (local_dlt_refcounts == NULL)
825                 return FALSE;
826               local_plt_refcounts = local_dlt_refcounts + symtab_hdr->sh_info;
827               local_plt_refcounts[r_symndx] += 1;
828             }
829         }
830
831       if (need_entry & NEED_STUB)
832         {
833           if (! hppa_info->stub_sec
834               && ! get_stub (abfd, info, hppa_info))
835             goto err_out;
836           if (hh)
837             hh->want_stub = 1;
838         }
839
840       if (need_entry & NEED_OPD)
841         {
842           if (! hppa_info->opd_sec
843               && ! get_opd (abfd, info, hppa_info))
844             goto err_out;
845
846           /* FPTRs are not allocated by the dynamic linker for PA64,
847              though it is possible that will change in the future.  */
848
849           if (hh != NULL)
850             hh->want_opd = 1;
851           else
852             {
853               bfd_signed_vma *local_dlt_refcounts;
854               bfd_signed_vma *local_opd_refcounts;
855
856               /* This is a OPD for a local symbol.  */
857               local_dlt_refcounts = hppa64_elf_local_refcounts (abfd);
858               if (local_dlt_refcounts == NULL)
859                 return FALSE;
860               local_opd_refcounts = (local_dlt_refcounts
861                                      + 2 * symtab_hdr->sh_info);
862               local_opd_refcounts[r_symndx] += 1;
863             }
864         }
865
866       /* Add a new dynamic relocation to the chain of dynamic
867          relocations for this symbol.  */
868       if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC))
869         {
870           if (! hppa_info->other_rel_sec
871               && ! get_reloc_section (abfd, hppa_info, sec))
872             goto err_out;
873
874           /* Count dynamic relocations against global symbols.  */
875           if (hh != NULL
876               && !count_dyn_reloc (abfd, hh, dynrel_type, sec,
877                                    sec_symndx, rel->r_offset, rel->r_addend))
878             goto err_out;
879
880           /* If we are building a shared library and we just recorded
881              a dynamic R_PARISC_FPTR64 relocation, then make sure the
882              section symbol for this section ends up in the dynamic
883              symbol table.  */
884           if (bfd_link_pic (info) && dynrel_type == R_PARISC_FPTR64
885               && ! (bfd_elf_link_record_local_dynamic_symbol
886                     (info, abfd, sec_symndx)))
887             return FALSE;
888         }
889     }
890
891   return TRUE;
892
893  err_out:
894   return FALSE;
895 }
896
897 struct elf64_hppa_allocate_data
898 {
899   struct bfd_link_info *info;
900   bfd_size_type ofs;
901 };
902
903 /* Should we do dynamic things to this symbol?  */
904
905 static bfd_boolean
906 elf64_hppa_dynamic_symbol_p (struct elf_link_hash_entry *eh,
907                              struct bfd_link_info *info)
908 {
909   /* ??? What, if anything, needs to happen wrt STV_PROTECTED symbols
910      and relocations that retrieve a function descriptor?  Assume the
911      worst for now.  */
912   if (_bfd_elf_dynamic_symbol_p (eh, info, 1))
913     {
914       /* ??? Why is this here and not elsewhere is_local_label_name.  */
915       if (eh->root.root.string[0] == '$' && eh->root.root.string[1] == '$')
916         return FALSE;
917
918       return TRUE;
919     }
920   else
921     return FALSE;
922 }
923
924 /* Mark all functions exported by this file so that we can later allocate
925    entries in .opd for them.  */
926
927 static bfd_boolean
928 elf64_hppa_mark_exported_functions (struct elf_link_hash_entry *eh, void *data)
929 {
930   struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
931   struct bfd_link_info *info = (struct bfd_link_info *)data;
932   struct elf64_hppa_link_hash_table *hppa_info;
933
934   hppa_info = hppa_link_hash_table (info);
935   if (hppa_info == NULL)
936     return FALSE;
937
938   if (eh
939       && (eh->root.type == bfd_link_hash_defined
940           || eh->root.type == bfd_link_hash_defweak)
941       && eh->root.u.def.section->output_section != NULL
942       && eh->type == STT_FUNC)
943     {
944       if (! hppa_info->opd_sec
945           && ! get_opd (hppa_info->root.dynobj, info, hppa_info))
946         return FALSE;
947
948       hh->want_opd = 1;
949
950       /* Put a flag here for output_symbol_hook.  */
951       hh->st_shndx = -1;
952       eh->needs_plt = 1;
953     }
954
955   return TRUE;
956 }
957
958 /* Allocate space for a DLT entry.  */
959
960 static bfd_boolean
961 allocate_global_data_dlt (struct elf_link_hash_entry *eh, void *data)
962 {
963   struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
964   struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data;
965
966   if (hh->want_dlt)
967     {
968       if (bfd_link_pic (x->info))
969         {
970           /* Possibly add the symbol to the local dynamic symbol
971              table since we might need to create a dynamic relocation
972              against it.  */
973           if (eh->dynindx == -1 && eh->type != STT_PARISC_MILLI)
974             {
975               bfd *owner = eh->root.u.def.section->owner;
976
977               if (! (bfd_elf_link_record_local_dynamic_symbol
978                      (x->info, owner, hh->sym_indx)))
979                 return FALSE;
980             }
981         }
982
983       hh->dlt_offset = x->ofs;
984       x->ofs += DLT_ENTRY_SIZE;
985     }
986   return TRUE;
987 }
988
989 /* Allocate space for a DLT.PLT entry.  */
990
991 static bfd_boolean
992 allocate_global_data_plt (struct elf_link_hash_entry *eh, void *data)
993 {
994   struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
995   struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *) data;
996
997   if (hh->want_plt
998       && elf64_hppa_dynamic_symbol_p (eh, x->info)
999       && !((eh->root.type == bfd_link_hash_defined
1000             || eh->root.type == bfd_link_hash_defweak)
1001            && eh->root.u.def.section->output_section != NULL))
1002     {
1003       hh->plt_offset = x->ofs;
1004       x->ofs += PLT_ENTRY_SIZE;
1005       if (hh->plt_offset < 0x2000)
1006         {
1007           struct elf64_hppa_link_hash_table *hppa_info;
1008
1009           hppa_info = hppa_link_hash_table (x->info);
1010           if (hppa_info == NULL)
1011             return FALSE;
1012
1013           hppa_info->gp_offset = hh->plt_offset;
1014         }
1015     }
1016   else
1017     hh->want_plt = 0;
1018
1019   return TRUE;
1020 }
1021
1022 /* Allocate space for a STUB entry.  */
1023
1024 static bfd_boolean
1025 allocate_global_data_stub (struct elf_link_hash_entry *eh, void *data)
1026 {
1027   struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
1028   struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data;
1029
1030   if (hh->want_stub
1031       && elf64_hppa_dynamic_symbol_p (eh, x->info)
1032       && !((eh->root.type == bfd_link_hash_defined
1033             || eh->root.type == bfd_link_hash_defweak)
1034            && eh->root.u.def.section->output_section != NULL))
1035     {
1036       hh->stub_offset = x->ofs;
1037       x->ofs += sizeof (plt_stub);
1038     }
1039   else
1040     hh->want_stub = 0;
1041   return TRUE;
1042 }
1043
1044 /* Allocate space for a FPTR entry.  */
1045
1046 static bfd_boolean
1047 allocate_global_data_opd (struct elf_link_hash_entry *eh, void *data)
1048 {
1049   struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
1050   struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data;
1051
1052   if (hh && hh->want_opd)
1053     {
1054       /* We never need an opd entry for a symbol which is not
1055          defined by this output file.  */
1056       if (hh && (hh->eh.root.type == bfd_link_hash_undefined
1057                  || hh->eh.root.type == bfd_link_hash_undefweak
1058                  || hh->eh.root.u.def.section->output_section == NULL))
1059         hh->want_opd = 0;
1060
1061       /* If we are creating a shared library, took the address of a local
1062          function or might export this function from this object file, then
1063          we have to create an opd descriptor.  */
1064       else if (bfd_link_pic (x->info)
1065                || hh == NULL
1066                || (hh->eh.dynindx == -1 && hh->eh.type != STT_PARISC_MILLI)
1067                || (hh->eh.root.type == bfd_link_hash_defined
1068                    || hh->eh.root.type == bfd_link_hash_defweak))
1069         {
1070           /* If we are creating a shared library, then we will have to
1071              create a runtime relocation for the symbol to properly
1072              initialize the .opd entry.  Make sure the symbol gets
1073              added to the dynamic symbol table.  */
1074           if (bfd_link_pic (x->info)
1075               && (hh == NULL || (hh->eh.dynindx == -1)))
1076             {
1077               bfd *owner;
1078               /* PR 6511: Default to using the dynamic symbol table.  */
1079               owner = (hh->owner ? hh->owner: eh->root.u.def.section->owner);
1080
1081               if (!bfd_elf_link_record_local_dynamic_symbol
1082                     (x->info, owner, hh->sym_indx))
1083                 return FALSE;
1084             }
1085
1086           /* This may not be necessary or desirable anymore now that
1087              we have some support for dealing with section symbols
1088              in dynamic relocs.  But name munging does make the result
1089              much easier to debug.  ie, the EPLT reloc will reference
1090              a symbol like .foobar, instead of .text + offset.  */
1091           if (bfd_link_pic (x->info) && eh)
1092             {
1093               char *new_name;
1094               struct elf_link_hash_entry *nh;
1095
1096               new_name = concat (".", eh->root.root.string, NULL);
1097
1098               nh = elf_link_hash_lookup (elf_hash_table (x->info),
1099                                          new_name, TRUE, TRUE, TRUE);
1100
1101               free (new_name);
1102               nh->root.type = eh->root.type;
1103               nh->root.u.def.value = eh->root.u.def.value;
1104               nh->root.u.def.section = eh->root.u.def.section;
1105
1106               if (! bfd_elf_link_record_dynamic_symbol (x->info, nh))
1107                 return FALSE;
1108              }
1109           hh->opd_offset = x->ofs;
1110           x->ofs += OPD_ENTRY_SIZE;
1111         }
1112
1113       /* Otherwise we do not need an opd entry.  */
1114       else
1115         hh->want_opd = 0;
1116     }
1117   return TRUE;
1118 }
1119
1120 /* HP requires the EI_OSABI field to be filled in.  The assignment to
1121    EI_ABIVERSION may not be strictly necessary.  */
1122
1123 static void
1124 elf64_hppa_post_process_headers (bfd *abfd,
1125                          struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
1126 {
1127   Elf_Internal_Ehdr * i_ehdrp;
1128
1129   i_ehdrp = elf_elfheader (abfd);
1130
1131   i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
1132   i_ehdrp->e_ident[EI_ABIVERSION] = 1;
1133 }
1134
1135 /* Create function descriptor section (.opd).  This section is called .opd
1136    because it contains "official procedure descriptors".  The "official"
1137    refers to the fact that these descriptors are used when taking the address
1138    of a procedure, thus ensuring a unique address for each procedure.  */
1139
1140 static bfd_boolean
1141 get_opd (bfd *abfd,
1142          struct bfd_link_info *info ATTRIBUTE_UNUSED,
1143          struct elf64_hppa_link_hash_table *hppa_info)
1144 {
1145   asection *opd;
1146   bfd *dynobj;
1147
1148   opd = hppa_info->opd_sec;
1149   if (!opd)
1150     {
1151       dynobj = hppa_info->root.dynobj;
1152       if (!dynobj)
1153         hppa_info->root.dynobj = dynobj = abfd;
1154
1155       opd = bfd_make_section_anyway_with_flags (dynobj, ".opd",
1156                                                 (SEC_ALLOC
1157                                                  | SEC_LOAD
1158                                                  | SEC_HAS_CONTENTS
1159                                                  | SEC_IN_MEMORY
1160                                                  | SEC_LINKER_CREATED));
1161       if (!opd
1162           || !bfd_set_section_alignment (abfd, opd, 3))
1163         {
1164           BFD_ASSERT (0);
1165           return FALSE;
1166         }
1167
1168       hppa_info->opd_sec = opd;
1169     }
1170
1171   return TRUE;
1172 }
1173
1174 /* Create the PLT section.  */
1175
1176 static bfd_boolean
1177 get_plt (bfd *abfd,
1178          struct bfd_link_info *info ATTRIBUTE_UNUSED,
1179          struct elf64_hppa_link_hash_table *hppa_info)
1180 {
1181   asection *plt;
1182   bfd *dynobj;
1183
1184   plt = hppa_info->plt_sec;
1185   if (!plt)
1186     {
1187       dynobj = hppa_info->root.dynobj;
1188       if (!dynobj)
1189         hppa_info->root.dynobj = dynobj = abfd;
1190
1191       plt = bfd_make_section_anyway_with_flags (dynobj, ".plt",
1192                                                 (SEC_ALLOC
1193                                                  | SEC_LOAD
1194                                                  | SEC_HAS_CONTENTS
1195                                                  | SEC_IN_MEMORY
1196                                                  | SEC_LINKER_CREATED));
1197       if (!plt
1198           || !bfd_set_section_alignment (abfd, plt, 3))
1199         {
1200           BFD_ASSERT (0);
1201           return FALSE;
1202         }
1203
1204       hppa_info->plt_sec = plt;
1205     }
1206
1207   return TRUE;
1208 }
1209
1210 /* Create the DLT section.  */
1211
1212 static bfd_boolean
1213 get_dlt (bfd *abfd,
1214          struct bfd_link_info *info ATTRIBUTE_UNUSED,
1215          struct elf64_hppa_link_hash_table *hppa_info)
1216 {
1217   asection *dlt;
1218   bfd *dynobj;
1219
1220   dlt = hppa_info->dlt_sec;
1221   if (!dlt)
1222     {
1223       dynobj = hppa_info->root.dynobj;
1224       if (!dynobj)
1225         hppa_info->root.dynobj = dynobj = abfd;
1226
1227       dlt = bfd_make_section_anyway_with_flags (dynobj, ".dlt",
1228                                                 (SEC_ALLOC
1229                                                  | SEC_LOAD
1230                                                  | SEC_HAS_CONTENTS
1231                                                  | SEC_IN_MEMORY
1232                                                  | SEC_LINKER_CREATED));
1233       if (!dlt
1234           || !bfd_set_section_alignment (abfd, dlt, 3))
1235         {
1236           BFD_ASSERT (0);
1237           return FALSE;
1238         }
1239
1240       hppa_info->dlt_sec = dlt;
1241     }
1242
1243   return TRUE;
1244 }
1245
1246 /* Create the stubs section.  */
1247
1248 static bfd_boolean
1249 get_stub (bfd *abfd,
1250           struct bfd_link_info *info ATTRIBUTE_UNUSED,
1251           struct elf64_hppa_link_hash_table *hppa_info)
1252 {
1253   asection *stub;
1254   bfd *dynobj;
1255
1256   stub = hppa_info->stub_sec;
1257   if (!stub)
1258     {
1259       dynobj = hppa_info->root.dynobj;
1260       if (!dynobj)
1261         hppa_info->root.dynobj = dynobj = abfd;
1262
1263       stub = bfd_make_section_anyway_with_flags (dynobj, ".stub",
1264                                                  (SEC_ALLOC | SEC_LOAD
1265                                                   | SEC_HAS_CONTENTS
1266                                                   | SEC_IN_MEMORY
1267                                                   | SEC_READONLY
1268                                                   | SEC_LINKER_CREATED));
1269       if (!stub
1270           || !bfd_set_section_alignment (abfd, stub, 3))
1271         {
1272           BFD_ASSERT (0);
1273           return FALSE;
1274         }
1275
1276       hppa_info->stub_sec = stub;
1277     }
1278
1279   return TRUE;
1280 }
1281
1282 /* Create sections necessary for dynamic linking.  This is only a rough
1283    cut and will likely change as we learn more about the somewhat
1284    unusual dynamic linking scheme HP uses.
1285
1286    .stub:
1287         Contains code to implement cross-space calls.  The first time one
1288         of the stubs is used it will call into the dynamic linker, later
1289         calls will go straight to the target.
1290
1291         The only stub we support right now looks like
1292
1293         ldd OFFSET(%dp),%r1
1294         bve %r0(%r1)
1295         ldd OFFSET+8(%dp),%dp
1296
1297         Other stubs may be needed in the future.  We may want the remove
1298         the break/nop instruction.  It is only used right now to keep the
1299         offset of a .plt entry and a .stub entry in sync.
1300
1301    .dlt:
1302         This is what most people call the .got.  HP used a different name.
1303         Losers.
1304
1305    .rela.dlt:
1306         Relocations for the DLT.
1307
1308    .plt:
1309         Function pointers as address,gp pairs.
1310
1311    .rela.plt:
1312         Should contain dynamic IPLT (and EPLT?) relocations.
1313
1314    .opd:
1315         FPTRS
1316
1317    .rela.opd:
1318         EPLT relocations for symbols exported from shared libraries.  */
1319
1320 static bfd_boolean
1321 elf64_hppa_create_dynamic_sections (bfd *abfd,
1322                                     struct bfd_link_info *info)
1323 {
1324   asection *s;
1325   struct elf64_hppa_link_hash_table *hppa_info;
1326
1327   hppa_info = hppa_link_hash_table (info);
1328   if (hppa_info == NULL)
1329     return FALSE;
1330
1331   if (! get_stub (abfd, info, hppa_info))
1332     return FALSE;
1333
1334   if (! get_dlt (abfd, info, hppa_info))
1335     return FALSE;
1336
1337   if (! get_plt (abfd, info, hppa_info))
1338     return FALSE;
1339
1340   if (! get_opd (abfd, info, hppa_info))
1341     return FALSE;
1342
1343   s = bfd_make_section_anyway_with_flags (abfd, ".rela.dlt",
1344                                           (SEC_ALLOC | SEC_LOAD
1345                                            | SEC_HAS_CONTENTS
1346                                            | SEC_IN_MEMORY
1347                                            | SEC_READONLY
1348                                            | SEC_LINKER_CREATED));
1349   if (s == NULL
1350       || !bfd_set_section_alignment (abfd, s, 3))
1351     return FALSE;
1352   hppa_info->dlt_rel_sec = s;
1353
1354   s = bfd_make_section_anyway_with_flags (abfd, ".rela.plt",
1355                                           (SEC_ALLOC | SEC_LOAD
1356                                            | SEC_HAS_CONTENTS
1357                                            | SEC_IN_MEMORY
1358                                            | SEC_READONLY
1359                                            | SEC_LINKER_CREATED));
1360   if (s == NULL
1361       || !bfd_set_section_alignment (abfd, s, 3))
1362     return FALSE;
1363   hppa_info->plt_rel_sec = s;
1364
1365   s = bfd_make_section_anyway_with_flags (abfd, ".rela.data",
1366                                           (SEC_ALLOC | SEC_LOAD
1367                                            | SEC_HAS_CONTENTS
1368                                            | SEC_IN_MEMORY
1369                                            | SEC_READONLY
1370                                            | SEC_LINKER_CREATED));
1371   if (s == NULL
1372       || !bfd_set_section_alignment (abfd, s, 3))
1373     return FALSE;
1374   hppa_info->other_rel_sec = s;
1375
1376   s = bfd_make_section_anyway_with_flags (abfd, ".rela.opd",
1377                                           (SEC_ALLOC | SEC_LOAD
1378                                            | SEC_HAS_CONTENTS
1379                                            | SEC_IN_MEMORY
1380                                            | SEC_READONLY
1381                                            | SEC_LINKER_CREATED));
1382   if (s == NULL
1383       || !bfd_set_section_alignment (abfd, s, 3))
1384     return FALSE;
1385   hppa_info->opd_rel_sec = s;
1386
1387   return TRUE;
1388 }
1389
1390 /* Allocate dynamic relocations for those symbols that turned out
1391    to be dynamic.  */
1392
1393 static bfd_boolean
1394 allocate_dynrel_entries (struct elf_link_hash_entry *eh, void *data)
1395 {
1396   struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
1397   struct elf64_hppa_allocate_data *x = (struct elf64_hppa_allocate_data *)data;
1398   struct elf64_hppa_link_hash_table *hppa_info;
1399   struct elf64_hppa_dyn_reloc_entry *rent;
1400   bfd_boolean dynamic_symbol, shared;
1401
1402   hppa_info = hppa_link_hash_table (x->info);
1403   if (hppa_info == NULL)
1404     return FALSE;
1405
1406   dynamic_symbol = elf64_hppa_dynamic_symbol_p (eh, x->info);
1407   shared = bfd_link_pic (x->info);
1408
1409   /* We may need to allocate relocations for a non-dynamic symbol
1410      when creating a shared library.  */
1411   if (!dynamic_symbol && !shared)
1412     return TRUE;
1413
1414   /* Take care of the normal data relocations.  */
1415
1416   for (rent = hh->reloc_entries; rent; rent = rent->next)
1417     {
1418       /* Allocate one iff we are building a shared library, the relocation
1419          isn't a R_PARISC_FPTR64, or we don't want an opd entry.  */
1420       if (!shared && rent->type == R_PARISC_FPTR64 && hh->want_opd)
1421         continue;
1422
1423       hppa_info->other_rel_sec->size += sizeof (Elf64_External_Rela);
1424
1425       /* Make sure this symbol gets into the dynamic symbol table if it is
1426          not already recorded.  ?!? This should not be in the loop since
1427          the symbol need only be added once.  */
1428       if (eh->dynindx == -1 && eh->type != STT_PARISC_MILLI)
1429         if (!bfd_elf_link_record_local_dynamic_symbol
1430             (x->info, rent->sec->owner, hh->sym_indx))
1431           return FALSE;
1432     }
1433
1434   /* Take care of the GOT and PLT relocations.  */
1435
1436   if ((dynamic_symbol || shared) && hh->want_dlt)
1437     hppa_info->dlt_rel_sec->size += sizeof (Elf64_External_Rela);
1438
1439   /* If we are building a shared library, then every symbol that has an
1440      opd entry will need an EPLT relocation to relocate the symbol's address
1441      and __gp value based on the runtime load address.  */
1442   if (shared && hh->want_opd)
1443     hppa_info->opd_rel_sec->size += sizeof (Elf64_External_Rela);
1444
1445   if (hh->want_plt && dynamic_symbol)
1446     {
1447       bfd_size_type t = 0;
1448
1449       /* Dynamic symbols get one IPLT relocation.  Local symbols in
1450          shared libraries get two REL relocations.  Local symbols in
1451          main applications get nothing.  */
1452       if (dynamic_symbol)
1453         t = sizeof (Elf64_External_Rela);
1454       else if (shared)
1455         t = 2 * sizeof (Elf64_External_Rela);
1456
1457       hppa_info->plt_rel_sec->size += t;
1458     }
1459
1460   return TRUE;
1461 }
1462
1463 /* Adjust a symbol defined by a dynamic object and referenced by a
1464    regular object.  */
1465
1466 static bfd_boolean
1467 elf64_hppa_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1468                                   struct elf_link_hash_entry *eh)
1469 {
1470   /* ??? Undefined symbols with PLT entries should be re-defined
1471      to be the PLT entry.  */
1472
1473   /* If this is a weak symbol, and there is a real definition, the
1474      processor independent code will have arranged for us to see the
1475      real definition first, and we can just use the same value.  */
1476   if (eh->is_weakalias)
1477     {
1478       struct elf_link_hash_entry *def = weakdef (eh);
1479       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
1480       eh->root.u.def.section = def->root.u.def.section;
1481       eh->root.u.def.value = def->root.u.def.value;
1482       return TRUE;
1483     }
1484
1485   /* If this is a reference to a symbol defined by a dynamic object which
1486      is not a function, we might allocate the symbol in our .dynbss section
1487      and allocate a COPY dynamic relocation.
1488
1489      But PA64 code is canonically PIC, so as a rule we can avoid this sort
1490      of hackery.  */
1491
1492   return TRUE;
1493 }
1494
1495 /* This function is called via elf_link_hash_traverse to mark millicode
1496    symbols with a dynindx of -1 and to remove the string table reference
1497    from the dynamic symbol table.  If the symbol is not a millicode symbol,
1498    elf64_hppa_mark_exported_functions is called.  */
1499
1500 static bfd_boolean
1501 elf64_hppa_mark_milli_and_exported_functions (struct elf_link_hash_entry *eh,
1502                                               void *data)
1503 {
1504   struct bfd_link_info *info = (struct bfd_link_info *) data;
1505
1506   if (eh->type == STT_PARISC_MILLI)
1507     {
1508       if (eh->dynindx != -1)
1509         {
1510           eh->dynindx = -1;
1511           _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1512                                   eh->dynstr_index);
1513         }
1514       return TRUE;
1515     }
1516
1517   return elf64_hppa_mark_exported_functions (eh, data);
1518 }
1519
1520 /* Set the final sizes of the dynamic sections and allocate memory for
1521    the contents of our special sections.  */
1522
1523 static bfd_boolean
1524 elf64_hppa_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
1525 {
1526   struct elf64_hppa_link_hash_table *hppa_info;
1527   struct elf64_hppa_allocate_data data;
1528   bfd *dynobj;
1529   bfd *ibfd;
1530   asection *sec;
1531   bfd_boolean plt;
1532   bfd_boolean relocs;
1533   bfd_boolean reltext;
1534
1535   hppa_info = hppa_link_hash_table (info);
1536   if (hppa_info == NULL)
1537     return FALSE;
1538
1539   dynobj = hppa_info->root.dynobj;
1540   BFD_ASSERT (dynobj != NULL);
1541
1542   /* Mark each function this program exports so that we will allocate
1543      space in the .opd section for each function's FPTR.  If we are
1544      creating dynamic sections, change the dynamic index of millicode
1545      symbols to -1 and remove them from the string table for .dynstr.
1546
1547      We have to traverse the main linker hash table since we have to
1548      find functions which may not have been mentioned in any relocs.  */
1549   elf_link_hash_traverse (&hppa_info->root,
1550                           (hppa_info->root.dynamic_sections_created
1551                            ? elf64_hppa_mark_milli_and_exported_functions
1552                            : elf64_hppa_mark_exported_functions),
1553                           info);
1554
1555   if (hppa_info->root.dynamic_sections_created)
1556     {
1557       /* Set the contents of the .interp section to the interpreter.  */
1558       if (bfd_link_executable (info) && !info->nointerp)
1559         {
1560           sec = bfd_get_linker_section (dynobj, ".interp");
1561           BFD_ASSERT (sec != NULL);
1562           sec->size = sizeof ELF_DYNAMIC_INTERPRETER;
1563           sec->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
1564         }
1565     }
1566   else
1567     {
1568       /* We may have created entries in the .rela.got section.
1569          However, if we are not creating the dynamic sections, we will
1570          not actually use these entries.  Reset the size of .rela.dlt,
1571          which will cause it to get stripped from the output file
1572          below.  */
1573       sec = hppa_info->dlt_rel_sec;
1574       if (sec != NULL)
1575         sec->size = 0;
1576     }
1577
1578   /* Set up DLT, PLT and OPD offsets for local syms, and space for local
1579      dynamic relocs.  */
1580   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
1581     {
1582       bfd_signed_vma *local_dlt;
1583       bfd_signed_vma *end_local_dlt;
1584       bfd_signed_vma *local_plt;
1585       bfd_signed_vma *end_local_plt;
1586       bfd_signed_vma *local_opd;
1587       bfd_signed_vma *end_local_opd;
1588       bfd_size_type locsymcount;
1589       Elf_Internal_Shdr *symtab_hdr;
1590       asection *srel;
1591
1592       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
1593         continue;
1594
1595       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
1596         {
1597           struct elf64_hppa_dyn_reloc_entry *hdh_p;
1598
1599           for (hdh_p = ((struct elf64_hppa_dyn_reloc_entry *)
1600                     elf_section_data (sec)->local_dynrel);
1601                hdh_p != NULL;
1602                hdh_p = hdh_p->next)
1603             {
1604               if (!bfd_is_abs_section (hdh_p->sec)
1605                   && bfd_is_abs_section (hdh_p->sec->output_section))
1606                 {
1607                   /* Input section has been discarded, either because
1608                      it is a copy of a linkonce section or due to
1609                      linker script /DISCARD/, so we'll be discarding
1610                      the relocs too.  */
1611                 }
1612               else if (hdh_p->count != 0)
1613                 {
1614                   srel = elf_section_data (hdh_p->sec)->sreloc;
1615                   srel->size += hdh_p->count * sizeof (Elf64_External_Rela);
1616                   if ((hdh_p->sec->output_section->flags & SEC_READONLY) != 0)
1617                     info->flags |= DF_TEXTREL;
1618                 }
1619             }
1620         }
1621
1622       local_dlt = elf_local_got_refcounts (ibfd);
1623       if (!local_dlt)
1624         continue;
1625
1626       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1627       locsymcount = symtab_hdr->sh_info;
1628       end_local_dlt = local_dlt + locsymcount;
1629       sec = hppa_info->dlt_sec;
1630       srel = hppa_info->dlt_rel_sec;
1631       for (; local_dlt < end_local_dlt; ++local_dlt)
1632         {
1633           if (*local_dlt > 0)
1634             {
1635               *local_dlt = sec->size;
1636               sec->size += DLT_ENTRY_SIZE;
1637               if (bfd_link_pic (info))
1638                 {
1639                   srel->size += sizeof (Elf64_External_Rela);
1640                 }
1641             }
1642           else
1643             *local_dlt = (bfd_vma) -1;
1644         }
1645
1646       local_plt = end_local_dlt;
1647       end_local_plt = local_plt + locsymcount;
1648       if (! hppa_info->root.dynamic_sections_created)
1649         {
1650           /* Won't be used, but be safe.  */
1651           for (; local_plt < end_local_plt; ++local_plt)
1652             *local_plt = (bfd_vma) -1;
1653         }
1654       else
1655         {
1656           sec = hppa_info->plt_sec;
1657           srel = hppa_info->plt_rel_sec;
1658           for (; local_plt < end_local_plt; ++local_plt)
1659             {
1660               if (*local_plt > 0)
1661                 {
1662                   *local_plt = sec->size;
1663                   sec->size += PLT_ENTRY_SIZE;
1664                   if (bfd_link_pic (info))
1665                     srel->size += sizeof (Elf64_External_Rela);
1666                 }
1667               else
1668                 *local_plt = (bfd_vma) -1;
1669             }
1670         }
1671
1672       local_opd = end_local_plt;
1673       end_local_opd = local_opd + locsymcount;
1674       if (! hppa_info->root.dynamic_sections_created)
1675         {
1676           /* Won't be used, but be safe.  */
1677           for (; local_opd < end_local_opd; ++local_opd)
1678             *local_opd = (bfd_vma) -1;
1679         }
1680       else
1681         {
1682           sec = hppa_info->opd_sec;
1683           srel = hppa_info->opd_rel_sec;
1684           for (; local_opd < end_local_opd; ++local_opd)
1685             {
1686               if (*local_opd > 0)
1687                 {
1688                   *local_opd = sec->size;
1689                   sec->size += OPD_ENTRY_SIZE;
1690                   if (bfd_link_pic (info))
1691                     srel->size += sizeof (Elf64_External_Rela);
1692                 }
1693               else
1694                 *local_opd = (bfd_vma) -1;
1695             }
1696         }
1697     }
1698
1699   /* Allocate the GOT entries.  */
1700
1701   data.info = info;
1702   if (hppa_info->dlt_sec)
1703     {
1704       data.ofs = hppa_info->dlt_sec->size;
1705       elf_link_hash_traverse (&hppa_info->root,
1706                               allocate_global_data_dlt, &data);
1707       hppa_info->dlt_sec->size = data.ofs;
1708     }
1709
1710   if (hppa_info->plt_sec)
1711     {
1712       data.ofs = hppa_info->plt_sec->size;
1713       elf_link_hash_traverse (&hppa_info->root,
1714                               allocate_global_data_plt, &data);
1715       hppa_info->plt_sec->size = data.ofs;
1716     }
1717
1718   if (hppa_info->stub_sec)
1719     {
1720       data.ofs = 0x0;
1721       elf_link_hash_traverse (&hppa_info->root,
1722                               allocate_global_data_stub, &data);
1723       hppa_info->stub_sec->size = data.ofs;
1724     }
1725
1726   /* Allocate space for entries in the .opd section.  */
1727   if (hppa_info->opd_sec)
1728     {
1729       data.ofs = hppa_info->opd_sec->size;
1730       elf_link_hash_traverse (&hppa_info->root,
1731                               allocate_global_data_opd, &data);
1732       hppa_info->opd_sec->size = data.ofs;
1733     }
1734
1735   /* Now allocate space for dynamic relocations, if necessary.  */
1736   if (hppa_info->root.dynamic_sections_created)
1737     elf_link_hash_traverse (&hppa_info->root,
1738                             allocate_dynrel_entries, &data);
1739
1740   /* The sizes of all the sections are set.  Allocate memory for them.  */
1741   plt = FALSE;
1742   relocs = FALSE;
1743   reltext = FALSE;
1744   for (sec = dynobj->sections; sec != NULL; sec = sec->next)
1745     {
1746       const char *name;
1747
1748       if ((sec->flags & SEC_LINKER_CREATED) == 0)
1749         continue;
1750
1751       /* It's OK to base decisions on the section name, because none
1752          of the dynobj section names depend upon the input files.  */
1753       name = bfd_get_section_name (dynobj, sec);
1754
1755       if (strcmp (name, ".plt") == 0)
1756         {
1757           /* Remember whether there is a PLT.  */
1758           plt = sec->size != 0;
1759         }
1760       else if (strcmp (name, ".opd") == 0
1761                || CONST_STRNEQ (name, ".dlt")
1762                || strcmp (name, ".stub") == 0
1763                || strcmp (name, ".got") == 0)
1764         {
1765           /* Strip this section if we don't need it; see the comment below.  */
1766         }
1767       else if (CONST_STRNEQ (name, ".rela"))
1768         {
1769           if (sec->size != 0)
1770             {
1771               asection *target;
1772
1773               /* Remember whether there are any reloc sections other
1774                  than .rela.plt.  */
1775               if (strcmp (name, ".rela.plt") != 0)
1776                 {
1777                   const char *outname;
1778
1779                   relocs = TRUE;
1780
1781                   /* If this relocation section applies to a read only
1782                      section, then we probably need a DT_TEXTREL
1783                      entry.  The entries in the .rela.plt section
1784                      really apply to the .got section, which we
1785                      created ourselves and so know is not readonly.  */
1786                   outname = bfd_get_section_name (output_bfd,
1787                                                   sec->output_section);
1788                   target = bfd_get_section_by_name (output_bfd, outname + 4);
1789                   if (target != NULL
1790                       && (target->flags & SEC_READONLY) != 0
1791                       && (target->flags & SEC_ALLOC) != 0)
1792                     reltext = TRUE;
1793                 }
1794
1795               /* We use the reloc_count field as a counter if we need
1796                  to copy relocs into the output file.  */
1797               sec->reloc_count = 0;
1798             }
1799         }
1800       else
1801         {
1802           /* It's not one of our sections, so don't allocate space.  */
1803           continue;
1804         }
1805
1806       if (sec->size == 0)
1807         {
1808           /* If we don't need this section, strip it from the
1809              output file.  This is mostly to handle .rela.bss and
1810              .rela.plt.  We must create both sections in
1811              create_dynamic_sections, because they must be created
1812              before the linker maps input sections to output
1813              sections.  The linker does that before
1814              adjust_dynamic_symbol is called, and it is that
1815              function which decides whether anything needs to go
1816              into these sections.  */
1817           sec->flags |= SEC_EXCLUDE;
1818           continue;
1819         }
1820
1821       if ((sec->flags & SEC_HAS_CONTENTS) == 0)
1822         continue;
1823
1824       /* Allocate memory for the section contents if it has not
1825          been allocated already.  We use bfd_zalloc here in case
1826          unused entries are not reclaimed before the section's
1827          contents are written out.  This should not happen, but this
1828          way if it does, we get a R_PARISC_NONE reloc instead of
1829          garbage.  */
1830       if (sec->contents == NULL)
1831         {
1832           sec->contents = (bfd_byte *) bfd_zalloc (dynobj, sec->size);
1833           if (sec->contents == NULL)
1834             return FALSE;
1835         }
1836     }
1837
1838   if (hppa_info->root.dynamic_sections_created)
1839     {
1840       /* Always create a DT_PLTGOT.  It actually has nothing to do with
1841          the PLT, it is how we communicate the __gp value of a load
1842          module to the dynamic linker.  */
1843 #define add_dynamic_entry(TAG, VAL) \
1844   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1845
1846       if (!add_dynamic_entry (DT_HP_DLD_FLAGS, 0)
1847           || !add_dynamic_entry (DT_PLTGOT, 0))
1848         return FALSE;
1849
1850       /* Add some entries to the .dynamic section.  We fill in the
1851          values later, in elf64_hppa_finish_dynamic_sections, but we
1852          must add the entries now so that we get the correct size for
1853          the .dynamic section.  The DT_DEBUG entry is filled in by the
1854          dynamic linker and used by the debugger.  */
1855       if (! bfd_link_pic (info))
1856         {
1857           if (!add_dynamic_entry (DT_DEBUG, 0)
1858               || !add_dynamic_entry (DT_HP_DLD_HOOK, 0)
1859               || !add_dynamic_entry (DT_HP_LOAD_MAP, 0))
1860             return FALSE;
1861         }
1862
1863       /* Force DT_FLAGS to always be set.
1864          Required by HPUX 11.00 patch PHSS_26559.  */
1865       if (!add_dynamic_entry (DT_FLAGS, (info)->flags))
1866         return FALSE;
1867
1868       if (plt)
1869         {
1870           if (!add_dynamic_entry (DT_PLTRELSZ, 0)
1871               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1872               || !add_dynamic_entry (DT_JMPREL, 0))
1873             return FALSE;
1874         }
1875
1876       if (relocs)
1877         {
1878           if (!add_dynamic_entry (DT_RELA, 0)
1879               || !add_dynamic_entry (DT_RELASZ, 0)
1880               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
1881             return FALSE;
1882         }
1883
1884       if (reltext)
1885         {
1886           if (!add_dynamic_entry (DT_TEXTREL, 0))
1887             return FALSE;
1888           info->flags |= DF_TEXTREL;
1889         }
1890     }
1891 #undef add_dynamic_entry
1892
1893   return TRUE;
1894 }
1895
1896 /* Called after we have output the symbol into the dynamic symbol
1897    table, but before we output the symbol into the normal symbol
1898    table.
1899
1900    For some symbols we had to change their address when outputting
1901    the dynamic symbol table.  We undo that change here so that
1902    the symbols have their expected value in the normal symbol
1903    table.  Ick.  */
1904
1905 static int
1906 elf64_hppa_link_output_symbol_hook (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1907                                     const char *name,
1908                                     Elf_Internal_Sym *sym,
1909                                     asection *input_sec ATTRIBUTE_UNUSED,
1910                                     struct elf_link_hash_entry *eh)
1911 {
1912   struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
1913
1914   /* We may be called with the file symbol or section symbols.
1915      They never need munging, so it is safe to ignore them.  */
1916   if (!name || !eh)
1917     return 1;
1918
1919   /* Function symbols for which we created .opd entries *may* have been
1920      munged by finish_dynamic_symbol and have to be un-munged here.
1921
1922      Note that finish_dynamic_symbol sometimes turns dynamic symbols
1923      into non-dynamic ones, so we initialize st_shndx to -1 in
1924      mark_exported_functions and check to see if it was overwritten
1925      here instead of just checking eh->dynindx.  */
1926   if (hh->want_opd && hh->st_shndx != -1)
1927     {
1928       /* Restore the saved value and section index.  */
1929       sym->st_value = hh->st_value;
1930       sym->st_shndx = hh->st_shndx;
1931     }
1932
1933   return 1;
1934 }
1935
1936 /* Finish up dynamic symbol handling.  We set the contents of various
1937    dynamic sections here.  */
1938
1939 static bfd_boolean
1940 elf64_hppa_finish_dynamic_symbol (bfd *output_bfd,
1941                                   struct bfd_link_info *info,
1942                                   struct elf_link_hash_entry *eh,
1943                                   Elf_Internal_Sym *sym)
1944 {
1945   struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
1946   asection *stub, *splt, *sopd, *spltrel;
1947   struct elf64_hppa_link_hash_table *hppa_info;
1948
1949   hppa_info = hppa_link_hash_table (info);
1950   if (hppa_info == NULL)
1951     return FALSE;
1952
1953   stub = hppa_info->stub_sec;
1954   splt = hppa_info->plt_sec;
1955   sopd = hppa_info->opd_sec;
1956   spltrel = hppa_info->plt_rel_sec;
1957
1958   /* Incredible.  It is actually necessary to NOT use the symbol's real
1959      value when building the dynamic symbol table for a shared library.
1960      At least for symbols that refer to functions.
1961
1962      We will store a new value and section index into the symbol long
1963      enough to output it into the dynamic symbol table, then we restore
1964      the original values (in elf64_hppa_link_output_symbol_hook).  */
1965   if (hh->want_opd)
1966     {
1967       BFD_ASSERT (sopd != NULL);
1968
1969       /* Save away the original value and section index so that we
1970          can restore them later.  */
1971       hh->st_value = sym->st_value;
1972       hh->st_shndx = sym->st_shndx;
1973
1974       /* For the dynamic symbol table entry, we want the value to be
1975          address of this symbol's entry within the .opd section.  */
1976       sym->st_value = (hh->opd_offset
1977                        + sopd->output_offset
1978                        + sopd->output_section->vma);
1979       sym->st_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
1980                                                          sopd->output_section);
1981     }
1982
1983   /* Initialize a .plt entry if requested.  */
1984   if (hh->want_plt
1985       && elf64_hppa_dynamic_symbol_p (eh, info))
1986     {
1987       bfd_vma value;
1988       Elf_Internal_Rela rel;
1989       bfd_byte *loc;
1990
1991       BFD_ASSERT (splt != NULL && spltrel != NULL);
1992
1993       /* We do not actually care about the value in the PLT entry
1994          if we are creating a shared library and the symbol is
1995          still undefined, we create a dynamic relocation to fill
1996          in the correct value.  */
1997       if (bfd_link_pic (info) && eh->root.type == bfd_link_hash_undefined)
1998         value = 0;
1999       else
2000         value = (eh->root.u.def.value + eh->root.u.def.section->vma);
2001
2002       /* Fill in the entry in the procedure linkage table.
2003
2004          The format of a plt entry is
2005          <funcaddr> <__gp>.
2006
2007          plt_offset is the offset within the PLT section at which to
2008          install the PLT entry.
2009
2010          We are modifying the in-memory PLT contents here, so we do not add
2011          in the output_offset of the PLT section.  */
2012
2013       bfd_put_64 (splt->owner, value, splt->contents + hh->plt_offset);
2014       value = _bfd_get_gp_value (splt->output_section->owner);
2015       bfd_put_64 (splt->owner, value, splt->contents + hh->plt_offset + 0x8);
2016
2017       /* Create a dynamic IPLT relocation for this entry.
2018
2019          We are creating a relocation in the output file's PLT section,
2020          which is included within the DLT secton.  So we do need to include
2021          the PLT's output_offset in the computation of the relocation's
2022          address.  */
2023       rel.r_offset = (hh->plt_offset + splt->output_offset
2024                       + splt->output_section->vma);
2025       rel.r_info = ELF64_R_INFO (hh->eh.dynindx, R_PARISC_IPLT);
2026       rel.r_addend = 0;
2027
2028       loc = spltrel->contents;
2029       loc += spltrel->reloc_count++ * sizeof (Elf64_External_Rela);
2030       bfd_elf64_swap_reloca_out (splt->output_section->owner, &rel, loc);
2031     }
2032
2033   /* Initialize an external call stub entry if requested.  */
2034   if (hh->want_stub
2035       && elf64_hppa_dynamic_symbol_p (eh, info))
2036     {
2037       bfd_vma value;
2038       int insn;
2039       unsigned int max_offset;
2040
2041       BFD_ASSERT (stub != NULL);
2042
2043       /* Install the generic stub template.
2044
2045          We are modifying the contents of the stub section, so we do not
2046          need to include the stub section's output_offset here.  */
2047       memcpy (stub->contents + hh->stub_offset, plt_stub, sizeof (plt_stub));
2048
2049       /* Fix up the first ldd instruction.
2050
2051          We are modifying the contents of the STUB section in memory,
2052          so we do not need to include its output offset in this computation.
2053
2054          Note the plt_offset value is the value of the PLT entry relative to
2055          the start of the PLT section.  These instructions will reference
2056          data relative to the value of __gp, which may not necessarily have
2057          the same address as the start of the PLT section.
2058
2059          gp_offset contains the offset of __gp within the PLT section.  */
2060       value = hh->plt_offset - hppa_info->gp_offset;
2061
2062       insn = bfd_get_32 (stub->owner, stub->contents + hh->stub_offset);
2063       if (output_bfd->arch_info->mach >= 25)
2064         {
2065           /* Wide mode allows 16 bit offsets.  */
2066           max_offset = 32768;
2067           insn &= ~ 0xfff1;
2068           insn |= re_assemble_16 ((int) value);
2069         }
2070       else
2071         {
2072           max_offset = 8192;
2073           insn &= ~ 0x3ff1;
2074           insn |= re_assemble_14 ((int) value);
2075         }
2076
2077       if ((value & 7) || value + max_offset >= 2*max_offset - 8)
2078         {
2079           _bfd_error_handler
2080             /* xgettext:c-format */
2081             (_("stub entry for %s cannot load .plt, dp offset = %" PRId64),
2082              hh->eh.root.root.string, (int64_t) value);
2083           return FALSE;
2084         }
2085
2086       bfd_put_32 (stub->owner, (bfd_vma) insn,
2087                   stub->contents + hh->stub_offset);
2088
2089       /* Fix up the second ldd instruction.  */
2090       value += 8;
2091       insn = bfd_get_32 (stub->owner, stub->contents + hh->stub_offset + 8);
2092       if (output_bfd->arch_info->mach >= 25)
2093         {
2094           insn &= ~ 0xfff1;
2095           insn |= re_assemble_16 ((int) value);
2096         }
2097       else
2098         {
2099           insn &= ~ 0x3ff1;
2100           insn |= re_assemble_14 ((int) value);
2101         }
2102       bfd_put_32 (stub->owner, (bfd_vma) insn,
2103                   stub->contents + hh->stub_offset + 8);
2104     }
2105
2106   return TRUE;
2107 }
2108
2109 /* The .opd section contains FPTRs for each function this file
2110    exports.  Initialize the FPTR entries.  */
2111
2112 static bfd_boolean
2113 elf64_hppa_finalize_opd (struct elf_link_hash_entry *eh, void *data)
2114 {
2115   struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
2116   struct bfd_link_info *info = (struct bfd_link_info *)data;
2117   struct elf64_hppa_link_hash_table *hppa_info;
2118   asection *sopd;
2119   asection *sopdrel;
2120
2121   hppa_info = hppa_link_hash_table (info);
2122   if (hppa_info == NULL)
2123     return FALSE;
2124
2125   sopd = hppa_info->opd_sec;
2126   sopdrel = hppa_info->opd_rel_sec;
2127
2128   if (hh->want_opd)
2129     {
2130       bfd_vma value;
2131
2132       /* The first two words of an .opd entry are zero.
2133
2134          We are modifying the contents of the OPD section in memory, so we
2135          do not need to include its output offset in this computation.  */
2136       memset (sopd->contents + hh->opd_offset, 0, 16);
2137
2138       value = (eh->root.u.def.value
2139                + eh->root.u.def.section->output_section->vma
2140                + eh->root.u.def.section->output_offset);
2141
2142       /* The next word is the address of the function.  */
2143       bfd_put_64 (sopd->owner, value, sopd->contents + hh->opd_offset + 16);
2144
2145       /* The last word is our local __gp value.  */
2146       value = _bfd_get_gp_value (sopd->output_section->owner);
2147       bfd_put_64 (sopd->owner, value, sopd->contents + hh->opd_offset + 24);
2148     }
2149
2150   /* If we are generating a shared library, we must generate EPLT relocations
2151      for each entry in the .opd, even for static functions (they may have
2152      had their address taken).  */
2153   if (bfd_link_pic (info) && hh->want_opd)
2154     {
2155       Elf_Internal_Rela rel;
2156       bfd_byte *loc;
2157       int dynindx;
2158
2159       /* We may need to do a relocation against a local symbol, in
2160          which case we have to look up it's dynamic symbol index off
2161          the local symbol hash table.  */
2162       if (eh->dynindx != -1)
2163         dynindx = eh->dynindx;
2164       else
2165         dynindx
2166           = _bfd_elf_link_lookup_local_dynindx (info, hh->owner,
2167                                                 hh->sym_indx);
2168
2169       /* The offset of this relocation is the absolute address of the
2170          .opd entry for this symbol.  */
2171       rel.r_offset = (hh->opd_offset + sopd->output_offset
2172                       + sopd->output_section->vma);
2173
2174       /* If H is non-null, then we have an external symbol.
2175
2176          It is imperative that we use a different dynamic symbol for the
2177          EPLT relocation if the symbol has global scope.
2178
2179          In the dynamic symbol table, the function symbol will have a value
2180          which is address of the function's .opd entry.
2181
2182          Thus, we can not use that dynamic symbol for the EPLT relocation
2183          (if we did, the data in the .opd would reference itself rather
2184          than the actual address of the function).  Instead we have to use
2185          a new dynamic symbol which has the same value as the original global
2186          function symbol.
2187
2188          We prefix the original symbol with a "." and use the new symbol in
2189          the EPLT relocation.  This new symbol has already been recorded in
2190          the symbol table, we just have to look it up and use it.
2191
2192          We do not have such problems with static functions because we do
2193          not make their addresses in the dynamic symbol table point to
2194          the .opd entry.  Ultimately this should be safe since a static
2195          function can not be directly referenced outside of its shared
2196          library.
2197
2198          We do have to play similar games for FPTR relocations in shared
2199          libraries, including those for static symbols.  See the FPTR
2200          handling in elf64_hppa_finalize_dynreloc.  */
2201       if (eh)
2202         {
2203           char *new_name;
2204           struct elf_link_hash_entry *nh;
2205
2206           new_name = concat (".", eh->root.root.string, NULL);
2207
2208           nh = elf_link_hash_lookup (elf_hash_table (info),
2209                                      new_name, TRUE, TRUE, FALSE);
2210
2211           /* All we really want from the new symbol is its dynamic
2212              symbol index.  */
2213           if (nh)
2214             dynindx = nh->dynindx;
2215           free (new_name);
2216         }
2217
2218       rel.r_addend = 0;
2219       rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_EPLT);
2220
2221       loc = sopdrel->contents;
2222       loc += sopdrel->reloc_count++ * sizeof (Elf64_External_Rela);
2223       bfd_elf64_swap_reloca_out (sopd->output_section->owner, &rel, loc);
2224     }
2225   return TRUE;
2226 }
2227
2228 /* The .dlt section contains addresses for items referenced through the
2229    dlt.  Note that we can have a DLTIND relocation for a local symbol, thus
2230    we can not depend on finish_dynamic_symbol to initialize the .dlt.  */
2231
2232 static bfd_boolean
2233 elf64_hppa_finalize_dlt (struct elf_link_hash_entry *eh, void *data)
2234 {
2235   struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
2236   struct bfd_link_info *info = (struct bfd_link_info *)data;
2237   struct elf64_hppa_link_hash_table *hppa_info;
2238   asection *sdlt, *sdltrel;
2239
2240   hppa_info = hppa_link_hash_table (info);
2241   if (hppa_info == NULL)
2242     return FALSE;
2243
2244   sdlt = hppa_info->dlt_sec;
2245   sdltrel = hppa_info->dlt_rel_sec;
2246
2247   /* H/DYN_H may refer to a local variable and we know it's
2248      address, so there is no need to create a relocation.  Just install
2249      the proper value into the DLT, note this shortcut can not be
2250      skipped when building a shared library.  */
2251   if (! bfd_link_pic (info) && hh && hh->want_dlt)
2252     {
2253       bfd_vma value;
2254
2255       /* If we had an LTOFF_FPTR style relocation we want the DLT entry
2256          to point to the FPTR entry in the .opd section.
2257
2258          We include the OPD's output offset in this computation as
2259          we are referring to an absolute address in the resulting
2260          object file.  */
2261       if (hh->want_opd)
2262         {
2263           value = (hh->opd_offset
2264                    + hppa_info->opd_sec->output_offset
2265                    + hppa_info->opd_sec->output_section->vma);
2266         }
2267       else if ((eh->root.type == bfd_link_hash_defined
2268                 || eh->root.type == bfd_link_hash_defweak)
2269                && eh->root.u.def.section)
2270         {
2271           value = eh->root.u.def.value + eh->root.u.def.section->output_offset;
2272           if (eh->root.u.def.section->output_section)
2273             value += eh->root.u.def.section->output_section->vma;
2274           else
2275             value += eh->root.u.def.section->vma;
2276         }
2277       else
2278         /* We have an undefined function reference.  */
2279         value = 0;
2280
2281       /* We do not need to include the output offset of the DLT section
2282          here because we are modifying the in-memory contents.  */
2283       bfd_put_64 (sdlt->owner, value, sdlt->contents + hh->dlt_offset);
2284     }
2285
2286   /* Create a relocation for the DLT entry associated with this symbol.
2287      When building a shared library the symbol does not have to be dynamic.  */
2288   if (hh->want_dlt
2289       && (elf64_hppa_dynamic_symbol_p (eh, info) || bfd_link_pic (info)))
2290     {
2291       Elf_Internal_Rela rel;
2292       bfd_byte *loc;
2293       int dynindx;
2294
2295       /* We may need to do a relocation against a local symbol, in
2296          which case we have to look up it's dynamic symbol index off
2297          the local symbol hash table.  */
2298       if (eh && eh->dynindx != -1)
2299         dynindx = eh->dynindx;
2300       else
2301         dynindx
2302           = _bfd_elf_link_lookup_local_dynindx (info, hh->owner,
2303                                                 hh->sym_indx);
2304
2305       /* Create a dynamic relocation for this entry.  Do include the output
2306          offset of the DLT entry since we need an absolute address in the
2307          resulting object file.  */
2308       rel.r_offset = (hh->dlt_offset + sdlt->output_offset
2309                       + sdlt->output_section->vma);
2310       if (eh && eh->type == STT_FUNC)
2311           rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_FPTR64);
2312       else
2313           rel.r_info = ELF64_R_INFO (dynindx, R_PARISC_DIR64);
2314       rel.r_addend = 0;
2315
2316       loc = sdltrel->contents;
2317       loc += sdltrel->reloc_count++ * sizeof (Elf64_External_Rela);
2318       bfd_elf64_swap_reloca_out (sdlt->output_section->owner, &rel, loc);
2319     }
2320   return TRUE;
2321 }
2322
2323 /* Finalize the dynamic relocations.  Specifically the FPTR relocations
2324    for dynamic functions used to initialize static data.  */
2325
2326 static bfd_boolean
2327 elf64_hppa_finalize_dynreloc (struct elf_link_hash_entry *eh,
2328                               void *data)
2329 {
2330   struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
2331   struct bfd_link_info *info = (struct bfd_link_info *)data;
2332   struct elf64_hppa_link_hash_table *hppa_info;
2333   int dynamic_symbol;
2334
2335   dynamic_symbol = elf64_hppa_dynamic_symbol_p (eh, info);
2336
2337   if (!dynamic_symbol && !bfd_link_pic (info))
2338     return TRUE;
2339
2340   if (hh->reloc_entries)
2341     {
2342       struct elf64_hppa_dyn_reloc_entry *rent;
2343       int dynindx;
2344
2345       hppa_info = hppa_link_hash_table (info);
2346       if (hppa_info == NULL)
2347         return FALSE;
2348
2349       /* We may need to do a relocation against a local symbol, in
2350          which case we have to look up it's dynamic symbol index off
2351          the local symbol hash table.  */
2352       if (eh->dynindx != -1)
2353         dynindx = eh->dynindx;
2354       else
2355         dynindx
2356           = _bfd_elf_link_lookup_local_dynindx (info, hh->owner,
2357                                                 hh->sym_indx);
2358
2359       for (rent = hh->reloc_entries; rent; rent = rent->next)
2360         {
2361           Elf_Internal_Rela rel;
2362           bfd_byte *loc;
2363
2364           /* Allocate one iff we are building a shared library, the relocation
2365              isn't a R_PARISC_FPTR64, or we don't want an opd entry.  */
2366           if (!bfd_link_pic (info)
2367               && rent->type == R_PARISC_FPTR64 && hh->want_opd)
2368             continue;
2369
2370           /* Create a dynamic relocation for this entry.
2371
2372              We need the output offset for the reloc's section because
2373              we are creating an absolute address in the resulting object
2374              file.  */
2375           rel.r_offset = (rent->offset + rent->sec->output_offset
2376                           + rent->sec->output_section->vma);
2377
2378           /* An FPTR64 relocation implies that we took the address of
2379              a function and that the function has an entry in the .opd
2380              section.  We want the FPTR64 relocation to reference the
2381              entry in .opd.
2382
2383              We could munge the symbol value in the dynamic symbol table
2384              (in fact we already do for functions with global scope) to point
2385              to the .opd entry.  Then we could use that dynamic symbol in
2386              this relocation.
2387
2388              Or we could do something sensible, not munge the symbol's
2389              address and instead just use a different symbol to reference
2390              the .opd entry.  At least that seems sensible until you
2391              realize there's no local dynamic symbols we can use for that
2392              purpose.  Thus the hair in the check_relocs routine.
2393
2394              We use a section symbol recorded by check_relocs as the
2395              base symbol for the relocation.  The addend is the difference
2396              between the section symbol and the address of the .opd entry.  */
2397           if (bfd_link_pic (info)
2398               && rent->type == R_PARISC_FPTR64 && hh->want_opd)
2399             {
2400               bfd_vma value, value2;
2401
2402               /* First compute the address of the opd entry for this symbol.  */
2403               value = (hh->opd_offset
2404                        + hppa_info->opd_sec->output_section->vma
2405                        + hppa_info->opd_sec->output_offset);
2406
2407               /* Compute the value of the start of the section with
2408                  the relocation.  */
2409               value2 = (rent->sec->output_section->vma
2410                         + rent->sec->output_offset);
2411
2412               /* Compute the difference between the start of the section
2413                  with the relocation and the opd entry.  */
2414               value -= value2;
2415
2416               /* The result becomes the addend of the relocation.  */
2417               rel.r_addend = value;
2418
2419               /* The section symbol becomes the symbol for the dynamic
2420                  relocation.  */
2421               dynindx
2422                 = _bfd_elf_link_lookup_local_dynindx (info,
2423                                                       rent->sec->owner,
2424                                                       rent->sec_symndx);
2425             }
2426           else
2427             rel.r_addend = rent->addend;
2428
2429           rel.r_info = ELF64_R_INFO (dynindx, rent->type);
2430
2431           loc = hppa_info->other_rel_sec->contents;
2432           loc += (hppa_info->other_rel_sec->reloc_count++
2433                   * sizeof (Elf64_External_Rela));
2434           bfd_elf64_swap_reloca_out (hppa_info->other_rel_sec->output_section->owner,
2435                                      &rel, loc);
2436         }
2437     }
2438
2439   return TRUE;
2440 }
2441
2442 /* Used to decide how to sort relocs in an optimal manner for the
2443    dynamic linker, before writing them out.  */
2444
2445 static enum elf_reloc_type_class
2446 elf64_hppa_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
2447                              const asection *rel_sec ATTRIBUTE_UNUSED,
2448                              const Elf_Internal_Rela *rela)
2449 {
2450   if (ELF64_R_SYM (rela->r_info) == STN_UNDEF)
2451     return reloc_class_relative;
2452
2453   switch ((int) ELF64_R_TYPE (rela->r_info))
2454     {
2455     case R_PARISC_IPLT:
2456       return reloc_class_plt;
2457     case R_PARISC_COPY:
2458       return reloc_class_copy;
2459     default:
2460       return reloc_class_normal;
2461     }
2462 }
2463
2464 /* Finish up the dynamic sections.  */
2465
2466 static bfd_boolean
2467 elf64_hppa_finish_dynamic_sections (bfd *output_bfd,
2468                                     struct bfd_link_info *info)
2469 {
2470   bfd *dynobj;
2471   asection *sdyn;
2472   struct elf64_hppa_link_hash_table *hppa_info;
2473
2474   hppa_info = hppa_link_hash_table (info);
2475   if (hppa_info == NULL)
2476     return FALSE;
2477
2478   /* Finalize the contents of the .opd section.  */
2479   elf_link_hash_traverse (elf_hash_table (info),
2480                           elf64_hppa_finalize_opd,
2481                           info);
2482
2483   elf_link_hash_traverse (elf_hash_table (info),
2484                           elf64_hppa_finalize_dynreloc,
2485                           info);
2486
2487   /* Finalize the contents of the .dlt section.  */
2488   dynobj = elf_hash_table (info)->dynobj;
2489   /* Finalize the contents of the .dlt section.  */
2490   elf_link_hash_traverse (elf_hash_table (info),
2491                           elf64_hppa_finalize_dlt,
2492                           info);
2493
2494   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
2495
2496   if (elf_hash_table (info)->dynamic_sections_created)
2497     {
2498       Elf64_External_Dyn *dyncon, *dynconend;
2499
2500       BFD_ASSERT (sdyn != NULL);
2501
2502       dyncon = (Elf64_External_Dyn *) sdyn->contents;
2503       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
2504       for (; dyncon < dynconend; dyncon++)
2505         {
2506           Elf_Internal_Dyn dyn;
2507           asection *s;
2508
2509           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
2510
2511           switch (dyn.d_tag)
2512             {
2513             default:
2514               break;
2515
2516             case DT_HP_LOAD_MAP:
2517               /* Compute the absolute address of 16byte scratchpad area
2518                  for the dynamic linker.
2519
2520                  By convention the linker script will allocate the scratchpad
2521                  area at the start of the .data section.  So all we have to
2522                  to is find the start of the .data section.  */
2523               s = bfd_get_section_by_name (output_bfd, ".data");
2524               if (!s)
2525                 return FALSE;
2526               dyn.d_un.d_ptr = s->vma;
2527               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2528               break;
2529
2530             case DT_PLTGOT:
2531               /* HP's use PLTGOT to set the GOT register.  */
2532               dyn.d_un.d_ptr = _bfd_get_gp_value (output_bfd);
2533               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2534               break;
2535
2536             case DT_JMPREL:
2537               s = hppa_info->plt_rel_sec;
2538               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2539               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2540               break;
2541
2542             case DT_PLTRELSZ:
2543               s = hppa_info->plt_rel_sec;
2544               dyn.d_un.d_val = s->size;
2545               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2546               break;
2547
2548             case DT_RELA:
2549               s = hppa_info->other_rel_sec;
2550               if (! s || ! s->size)
2551                 s = hppa_info->dlt_rel_sec;
2552               if (! s || ! s->size)
2553                 s = hppa_info->opd_rel_sec;
2554               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2555               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2556               break;
2557
2558             case DT_RELASZ:
2559               s = hppa_info->other_rel_sec;
2560               dyn.d_un.d_val = s->size;
2561               s = hppa_info->dlt_rel_sec;
2562               dyn.d_un.d_val += s->size;
2563               s = hppa_info->opd_rel_sec;
2564               dyn.d_un.d_val += s->size;
2565               /* There is some question about whether or not the size of
2566                  the PLT relocs should be included here.  HP's tools do
2567                  it, so we'll emulate them.  */
2568               s = hppa_info->plt_rel_sec;
2569               dyn.d_un.d_val += s->size;
2570               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2571               break;
2572
2573             }
2574         }
2575     }
2576
2577   return TRUE;
2578 }
2579
2580 /* Support for core dump NOTE sections.  */
2581
2582 static bfd_boolean
2583 elf64_hppa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2584 {
2585   int offset;
2586   size_t size;
2587
2588   switch (note->descsz)
2589     {
2590       default:
2591         return FALSE;
2592
2593       case 760:         /* Linux/hppa */
2594         /* pr_cursig */
2595         elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2596
2597         /* pr_pid */
2598         elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2599
2600         /* pr_reg */
2601         offset = 112;
2602         size = 640;
2603
2604         break;
2605     }
2606
2607   /* Make a ".reg/999" section.  */
2608   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2609                                           size, note->descpos + offset);
2610 }
2611
2612 static bfd_boolean
2613 elf64_hppa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2614 {
2615   char * command;
2616   int n;
2617
2618   switch (note->descsz)
2619     {
2620     default:
2621       return FALSE;
2622
2623     case 136:           /* Linux/hppa elf_prpsinfo.  */
2624       elf_tdata (abfd)->core->program
2625         = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2626       elf_tdata (abfd)->core->command
2627         = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2628     }
2629
2630   /* Note that for some reason, a spurious space is tacked
2631      onto the end of the args in some (at least one anyway)
2632      implementations, so strip it off if it exists.  */
2633   command = elf_tdata (abfd)->core->command;
2634   n = strlen (command);
2635
2636   if (0 < n && command[n - 1] == ' ')
2637     command[n - 1] = '\0';
2638
2639   return TRUE;
2640 }
2641
2642 /* Return the number of additional phdrs we will need.
2643
2644    The generic ELF code only creates PT_PHDRs for executables.  The HP
2645    dynamic linker requires PT_PHDRs for dynamic libraries too.
2646
2647    This routine indicates that the backend needs one additional program
2648    header for that case.
2649
2650    Note we do not have access to the link info structure here, so we have
2651    to guess whether or not we are building a shared library based on the
2652    existence of a .interp section.  */
2653
2654 static int
2655 elf64_hppa_additional_program_headers (bfd *abfd,
2656                                 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2657 {
2658   asection *s;
2659
2660   /* If we are creating a shared library, then we have to create a
2661      PT_PHDR segment.  HP's dynamic linker chokes without it.  */
2662   s = bfd_get_section_by_name (abfd, ".interp");
2663   if (! s)
2664     return 1;
2665   return 0;
2666 }
2667
2668 static bfd_boolean
2669 elf64_hppa_allow_non_load_phdr (bfd *abfd ATTRIBUTE_UNUSED,
2670                                 const Elf_Internal_Phdr *phdr ATTRIBUTE_UNUSED,
2671                                 unsigned int count ATTRIBUTE_UNUSED)
2672 {
2673   return TRUE;
2674 }
2675
2676 /* Allocate and initialize any program headers required by this
2677    specific backend.
2678
2679    The generic ELF code only creates PT_PHDRs for executables.  The HP
2680    dynamic linker requires PT_PHDRs for dynamic libraries too.
2681
2682    This allocates the PT_PHDR and initializes it in a manner suitable
2683    for the HP linker.
2684
2685    Note we do not have access to the link info structure here, so we have
2686    to guess whether or not we are building a shared library based on the
2687    existence of a .interp section.  */
2688
2689 static bfd_boolean
2690 elf64_hppa_modify_segment_map (bfd *abfd, struct bfd_link_info *info)
2691 {
2692   struct elf_segment_map *m;
2693
2694   m = elf_seg_map (abfd);
2695   if (info != NULL && !info->user_phdrs && m != NULL && m->p_type != PT_PHDR)
2696     {
2697       m = ((struct elf_segment_map *)
2698            bfd_zalloc (abfd, (bfd_size_type) sizeof *m));
2699       if (m == NULL)
2700         return FALSE;
2701
2702       m->p_type = PT_PHDR;
2703       m->p_flags = PF_R | PF_X;
2704       m->p_flags_valid = 1;
2705       m->p_paddr_valid = 1;
2706       m->includes_phdrs = 1;
2707
2708       m->next = elf_seg_map (abfd);
2709       elf_seg_map (abfd) = m;
2710     }
2711
2712   for (m = elf_seg_map (abfd) ; m != NULL; m = m->next)
2713     if (m->p_type == PT_LOAD)
2714       {
2715         unsigned int i;
2716
2717         for (i = 0; i < m->count; i++)
2718           {
2719             /* The code "hint" is not really a hint.  It is a requirement
2720                for certain versions of the HP dynamic linker.  Worse yet,
2721                it must be set even if the shared library does not have
2722                any code in its "text" segment (thus the check for .hash
2723                to catch this situation).  */
2724             if (m->sections[i]->flags & SEC_CODE
2725                 || (strcmp (m->sections[i]->name, ".hash") == 0))
2726               m->p_flags |= (PF_X | PF_HP_CODE);
2727           }
2728       }
2729
2730   return TRUE;
2731 }
2732
2733 /* Called when writing out an object file to decide the type of a
2734    symbol.  */
2735 static int
2736 elf64_hppa_elf_get_symbol_type (Elf_Internal_Sym *elf_sym,
2737                                 int type)
2738 {
2739   if (ELF_ST_TYPE (elf_sym->st_info) == STT_PARISC_MILLI)
2740     return STT_PARISC_MILLI;
2741   else
2742     return type;
2743 }
2744
2745 /* Support HP specific sections for core files.  */
2746
2747 static bfd_boolean
2748 elf64_hppa_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int sec_index,
2749                               const char *typename)
2750 {
2751   if (hdr->p_type == PT_HP_CORE_KERNEL)
2752     {
2753       asection *sect;
2754
2755       if (!_bfd_elf_make_section_from_phdr (abfd, hdr, sec_index, typename))
2756         return FALSE;
2757
2758       sect = bfd_make_section_anyway (abfd, ".kernel");
2759       if (sect == NULL)
2760         return FALSE;
2761       sect->size = hdr->p_filesz;
2762       sect->filepos = hdr->p_offset;
2763       sect->flags = SEC_HAS_CONTENTS | SEC_READONLY;
2764       return TRUE;
2765     }
2766
2767   if (hdr->p_type == PT_HP_CORE_PROC)
2768     {
2769       int sig;
2770
2771       if (bfd_seek (abfd, hdr->p_offset, SEEK_SET) != 0)
2772         return FALSE;
2773       if (bfd_bread (&sig, 4, abfd) != 4)
2774         return FALSE;
2775
2776       elf_tdata (abfd)->core->signal = sig;
2777
2778       if (!_bfd_elf_make_section_from_phdr (abfd, hdr, sec_index, typename))
2779         return FALSE;
2780
2781       /* GDB uses the ".reg" section to read register contents.  */
2782       return _bfd_elfcore_make_pseudosection (abfd, ".reg", hdr->p_filesz,
2783                                               hdr->p_offset);
2784     }
2785
2786   if (hdr->p_type == PT_HP_CORE_LOADABLE
2787       || hdr->p_type == PT_HP_CORE_STACK
2788       || hdr->p_type == PT_HP_CORE_MMF)
2789     hdr->p_type = PT_LOAD;
2790
2791   return _bfd_elf_make_section_from_phdr (abfd, hdr, sec_index, typename);
2792 }
2793
2794 /* Hook called by the linker routine which adds symbols from an object
2795    file.  HP's libraries define symbols with HP specific section
2796    indices, which we have to handle.  */
2797
2798 static bfd_boolean
2799 elf_hppa_add_symbol_hook (bfd *abfd,
2800                           struct bfd_link_info *info ATTRIBUTE_UNUSED,
2801                           Elf_Internal_Sym *sym,
2802                           const char **namep ATTRIBUTE_UNUSED,
2803                           flagword *flagsp ATTRIBUTE_UNUSED,
2804                           asection **secp,
2805                           bfd_vma *valp)
2806 {
2807   unsigned int sec_index = sym->st_shndx;
2808
2809   switch (sec_index)
2810     {
2811     case SHN_PARISC_ANSI_COMMON:
2812       *secp = bfd_make_section_old_way (abfd, ".PARISC.ansi.common");
2813       (*secp)->flags |= SEC_IS_COMMON;
2814       *valp = sym->st_size;
2815       break;
2816
2817     case SHN_PARISC_HUGE_COMMON:
2818       *secp = bfd_make_section_old_way (abfd, ".PARISC.huge.common");
2819       (*secp)->flags |= SEC_IS_COMMON;
2820       *valp = sym->st_size;
2821       break;
2822     }
2823
2824   return TRUE;
2825 }
2826
2827 static bfd_boolean
2828 elf_hppa_unmark_useless_dynamic_symbols (struct elf_link_hash_entry *h,
2829                                          void *data)
2830 {
2831   struct bfd_link_info *info = data;
2832
2833   /* If we are not creating a shared library, and this symbol is
2834      referenced by a shared library but is not defined anywhere, then
2835      the generic code will warn that it is undefined.
2836
2837      This behavior is undesirable on HPs since the standard shared
2838      libraries contain references to undefined symbols.
2839
2840      So we twiddle the flags associated with such symbols so that they
2841      will not trigger the warning.  ?!? FIXME.  This is horribly fragile.
2842
2843      Ultimately we should have better controls over the generic ELF BFD
2844      linker code.  */
2845   if (! bfd_link_relocatable (info)
2846       && info->unresolved_syms_in_shared_libs != RM_IGNORE
2847       && h->root.type == bfd_link_hash_undefined
2848       && h->ref_dynamic
2849       && !h->ref_regular)
2850     {
2851       h->ref_dynamic = 0;
2852       h->pointer_equality_needed = 1;
2853     }
2854
2855   return TRUE;
2856 }
2857
2858 static bfd_boolean
2859 elf_hppa_remark_useless_dynamic_symbols (struct elf_link_hash_entry *h,
2860                                          void *data)
2861 {
2862   struct bfd_link_info *info = data;
2863
2864   /* If we are not creating a shared library, and this symbol is
2865      referenced by a shared library but is not defined anywhere, then
2866      the generic code will warn that it is undefined.
2867
2868      This behavior is undesirable on HPs since the standard shared
2869      libraries contain references to undefined symbols.
2870
2871      So we twiddle the flags associated with such symbols so that they
2872      will not trigger the warning.  ?!? FIXME.  This is horribly fragile.
2873
2874      Ultimately we should have better controls over the generic ELF BFD
2875      linker code.  */
2876   if (! bfd_link_relocatable (info)
2877       && info->unresolved_syms_in_shared_libs != RM_IGNORE
2878       && h->root.type == bfd_link_hash_undefined
2879       && !h->ref_dynamic
2880       && !h->ref_regular
2881       && h->pointer_equality_needed)
2882     {
2883       h->ref_dynamic = 1;
2884       h->pointer_equality_needed = 0;
2885     }
2886
2887   return TRUE;
2888 }
2889
2890 static bfd_boolean
2891 elf_hppa_is_dynamic_loader_symbol (const char *name)
2892 {
2893   return (! strcmp (name, "__CPU_REVISION")
2894           || ! strcmp (name, "__CPU_KEYBITS_1")
2895           || ! strcmp (name, "__SYSTEM_ID_D")
2896           || ! strcmp (name, "__FPU_MODEL")
2897           || ! strcmp (name, "__FPU_REVISION")
2898           || ! strcmp (name, "__ARGC")
2899           || ! strcmp (name, "__ARGV")
2900           || ! strcmp (name, "__ENVP")
2901           || ! strcmp (name, "__TLS_SIZE_D")
2902           || ! strcmp (name, "__LOAD_INFO")
2903           || ! strcmp (name, "__systab"));
2904 }
2905
2906 /* Record the lowest address for the data and text segments.  */
2907 static void
2908 elf_hppa_record_segment_addrs (bfd *abfd,
2909                                asection *section,
2910                                void *data)
2911 {
2912   struct elf64_hppa_link_hash_table *hppa_info = data;
2913
2914   if ((section->flags & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2915     {
2916       bfd_vma value;
2917       Elf_Internal_Phdr *p;
2918
2919       p = _bfd_elf_find_segment_containing_section (abfd, section->output_section);
2920       BFD_ASSERT (p != NULL);
2921       value = p->p_vaddr;
2922
2923       if (section->flags & SEC_READONLY)
2924         {
2925           if (value < hppa_info->text_segment_base)
2926             hppa_info->text_segment_base = value;
2927         }
2928       else
2929         {
2930           if (value < hppa_info->data_segment_base)
2931             hppa_info->data_segment_base = value;
2932         }
2933     }
2934 }
2935
2936 /* Called after we have seen all the input files/sections, but before
2937    final symbol resolution and section placement has been determined.
2938
2939    We use this hook to (possibly) provide a value for __gp, then we
2940    fall back to the generic ELF final link routine.  */
2941
2942 static bfd_boolean
2943 elf_hppa_final_link (bfd *abfd, struct bfd_link_info *info)
2944 {
2945   struct stat buf;
2946   struct elf64_hppa_link_hash_table *hppa_info = hppa_link_hash_table (info);
2947
2948   if (hppa_info == NULL)
2949     return FALSE;
2950
2951   if (! bfd_link_relocatable (info))
2952     {
2953       struct elf_link_hash_entry *gp;
2954       bfd_vma gp_val;
2955
2956       /* The linker script defines a value for __gp iff it was referenced
2957          by one of the objects being linked.  First try to find the symbol
2958          in the hash table.  If that fails, just compute the value __gp
2959          should have had.  */
2960       gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
2961                                  FALSE, FALSE);
2962
2963       if (gp)
2964         {
2965
2966           /* Adjust the value of __gp as we may want to slide it into the
2967              .plt section so that the stubs can access PLT entries without
2968              using an addil sequence.  */
2969           gp->root.u.def.value += hppa_info->gp_offset;
2970
2971           gp_val = (gp->root.u.def.section->output_section->vma
2972                     + gp->root.u.def.section->output_offset
2973                     + gp->root.u.def.value);
2974         }
2975       else
2976         {
2977           asection *sec;
2978
2979           /* First look for a .plt section.  If found, then __gp is the
2980              address of the .plt + gp_offset.
2981
2982              If no .plt is found, then look for .dlt, .opd and .data (in
2983              that order) and set __gp to the base address of whichever
2984              section is found first.  */
2985
2986           sec = hppa_info->plt_sec;
2987           if (sec && ! (sec->flags & SEC_EXCLUDE))
2988             gp_val = (sec->output_offset
2989                       + sec->output_section->vma
2990                       + hppa_info->gp_offset);
2991           else
2992             {
2993               sec = hppa_info->dlt_sec;
2994               if (!sec || (sec->flags & SEC_EXCLUDE))
2995                 sec = hppa_info->opd_sec;
2996               if (!sec || (sec->flags & SEC_EXCLUDE))
2997                 sec = bfd_get_section_by_name (abfd, ".data");
2998               if (!sec || (sec->flags & SEC_EXCLUDE))
2999                 gp_val = 0;
3000               else
3001                 gp_val = sec->output_offset + sec->output_section->vma;
3002             }
3003         }
3004
3005       /* Install whatever value we found/computed for __gp.  */
3006       _bfd_set_gp_value (abfd, gp_val);
3007     }
3008
3009   /* We need to know the base of the text and data segments so that we
3010      can perform SEGREL relocations.  We will record the base addresses
3011      when we encounter the first SEGREL relocation.  */
3012   hppa_info->text_segment_base = (bfd_vma)-1;
3013   hppa_info->data_segment_base = (bfd_vma)-1;
3014
3015   /* HP's shared libraries have references to symbols that are not
3016      defined anywhere.  The generic ELF BFD linker code will complain
3017      about such symbols.
3018
3019      So we detect the losing case and arrange for the flags on the symbol
3020      to indicate that it was never referenced.  This keeps the generic
3021      ELF BFD link code happy and appears to not create any secondary
3022      problems.  Ultimately we need a way to control the behavior of the
3023      generic ELF BFD link code better.  */
3024   elf_link_hash_traverse (elf_hash_table (info),
3025                           elf_hppa_unmark_useless_dynamic_symbols,
3026                           info);
3027
3028   /* Invoke the regular ELF backend linker to do all the work.  */
3029   if (!bfd_elf_final_link (abfd, info))
3030     return FALSE;
3031
3032   elf_link_hash_traverse (elf_hash_table (info),
3033                           elf_hppa_remark_useless_dynamic_symbols,
3034                           info);
3035
3036   /* If we're producing a final executable, sort the contents of the
3037      unwind section. */
3038   if (bfd_link_relocatable (info))
3039     return TRUE;
3040
3041   /* Do not attempt to sort non-regular files.  This is here
3042      especially for configure scripts and kernel builds which run
3043      tests with "ld [...] -o /dev/null".  */
3044   if (stat (abfd->filename, &buf) != 0
3045       || !S_ISREG(buf.st_mode))
3046     return TRUE;
3047
3048   return elf_hppa_sort_unwind (abfd);
3049 }
3050
3051 /* Relocate the given INSN.  VALUE should be the actual value we want
3052    to insert into the instruction, ie by this point we should not be
3053    concerned with computing an offset relative to the DLT, PC, etc.
3054    Instead this routine is meant to handle the bit manipulations needed
3055    to insert the relocation into the given instruction.  */
3056
3057 static int
3058 elf_hppa_relocate_insn (int insn, int sym_value, unsigned int r_type)
3059 {
3060   switch (r_type)
3061     {
3062     /* This is any 22 bit branch.  In PA2.0 syntax it corresponds to
3063        the "B" instruction.  */
3064     case R_PARISC_PCREL22F:
3065     case R_PARISC_PCREL22C:
3066       return (insn & ~0x3ff1ffd) | re_assemble_22 (sym_value);
3067
3068       /* This is any 12 bit branch.  */
3069     case R_PARISC_PCREL12F:
3070       return (insn & ~0x1ffd) | re_assemble_12 (sym_value);
3071
3072     /* This is any 17 bit branch.  In PA2.0 syntax it also corresponds
3073        to the "B" instruction as well as BE.  */
3074     case R_PARISC_PCREL17F:
3075     case R_PARISC_DIR17F:
3076     case R_PARISC_DIR17R:
3077     case R_PARISC_PCREL17C:
3078     case R_PARISC_PCREL17R:
3079       return (insn & ~0x1f1ffd) | re_assemble_17 (sym_value);
3080
3081     /* ADDIL or LDIL instructions.  */
3082     case R_PARISC_DLTREL21L:
3083     case R_PARISC_DLTIND21L:
3084     case R_PARISC_LTOFF_FPTR21L:
3085     case R_PARISC_PCREL21L:
3086     case R_PARISC_LTOFF_TP21L:
3087     case R_PARISC_DPREL21L:
3088     case R_PARISC_PLTOFF21L:
3089     case R_PARISC_DIR21L:
3090       return (insn & ~0x1fffff) | re_assemble_21 (sym_value);
3091
3092     /* LDO and integer loads/stores with 14 bit displacements.  */
3093     case R_PARISC_DLTREL14R:
3094     case R_PARISC_DLTREL14F:
3095     case R_PARISC_DLTIND14R:
3096     case R_PARISC_DLTIND14F:
3097     case R_PARISC_LTOFF_FPTR14R:
3098     case R_PARISC_PCREL14R:
3099     case R_PARISC_PCREL14F:
3100     case R_PARISC_LTOFF_TP14R:
3101     case R_PARISC_LTOFF_TP14F:
3102     case R_PARISC_DPREL14R:
3103     case R_PARISC_DPREL14F:
3104     case R_PARISC_PLTOFF14R:
3105     case R_PARISC_PLTOFF14F:
3106     case R_PARISC_DIR14R:
3107     case R_PARISC_DIR14F:
3108       return (insn & ~0x3fff) | low_sign_unext (sym_value, 14);
3109
3110     /* PA2.0W LDO and integer loads/stores with 16 bit displacements.  */
3111     case R_PARISC_LTOFF_FPTR16F:
3112     case R_PARISC_PCREL16F:
3113     case R_PARISC_LTOFF_TP16F:
3114     case R_PARISC_GPREL16F:
3115     case R_PARISC_PLTOFF16F:
3116     case R_PARISC_DIR16F:
3117     case R_PARISC_LTOFF16F:
3118       return (insn & ~0xffff) | re_assemble_16 (sym_value);
3119
3120     /* Doubleword loads and stores with a 14 bit displacement.  */
3121     case R_PARISC_DLTREL14DR:
3122     case R_PARISC_DLTIND14DR:
3123     case R_PARISC_LTOFF_FPTR14DR:
3124     case R_PARISC_LTOFF_FPTR16DF:
3125     case R_PARISC_PCREL14DR:
3126     case R_PARISC_PCREL16DF:
3127     case R_PARISC_LTOFF_TP14DR:
3128     case R_PARISC_LTOFF_TP16DF:
3129     case R_PARISC_DPREL14DR:
3130     case R_PARISC_GPREL16DF:
3131     case R_PARISC_PLTOFF14DR:
3132     case R_PARISC_PLTOFF16DF:
3133     case R_PARISC_DIR14DR:
3134     case R_PARISC_DIR16DF:
3135     case R_PARISC_LTOFF16DF:
3136       return (insn & ~0x3ff1) | (((sym_value & 0x2000) >> 13)
3137                                  | ((sym_value & 0x1ff8) << 1));
3138
3139     /* Floating point single word load/store instructions.  */
3140     case R_PARISC_DLTREL14WR:
3141     case R_PARISC_DLTIND14WR:
3142     case R_PARISC_LTOFF_FPTR14WR:
3143     case R_PARISC_LTOFF_FPTR16WF:
3144     case R_PARISC_PCREL14WR:
3145     case R_PARISC_PCREL16WF:
3146     case R_PARISC_LTOFF_TP14WR:
3147     case R_PARISC_LTOFF_TP16WF:
3148     case R_PARISC_DPREL14WR:
3149     case R_PARISC_GPREL16WF:
3150     case R_PARISC_PLTOFF14WR:
3151     case R_PARISC_PLTOFF16WF:
3152     case R_PARISC_DIR16WF:
3153     case R_PARISC_DIR14WR:
3154     case R_PARISC_LTOFF16WF:
3155       return (insn & ~0x3ff9) | (((sym_value & 0x2000) >> 13)
3156                                  | ((sym_value & 0x1ffc) << 1));
3157
3158     default:
3159       return insn;
3160     }
3161 }
3162
3163 /* Compute the value for a relocation (REL) during a final link stage,
3164    then insert the value into the proper location in CONTENTS.
3165
3166    VALUE is a tentative value for the relocation and may be overridden
3167    and modified here based on the specific relocation to be performed.
3168
3169    For example we do conversions for PC-relative branches in this routine
3170    or redirection of calls to external routines to stubs.
3171
3172    The work of actually applying the relocation is left to a helper
3173    routine in an attempt to reduce the complexity and size of this
3174    function.  */
3175
3176 static bfd_reloc_status_type
3177 elf_hppa_final_link_relocate (Elf_Internal_Rela *rel,
3178                               bfd *input_bfd,
3179                               bfd *output_bfd,
3180                               asection *input_section,
3181                               bfd_byte *contents,
3182                               bfd_vma value,
3183                               struct bfd_link_info *info,
3184                               asection *sym_sec,
3185                               struct elf_link_hash_entry *eh)
3186 {
3187   struct elf64_hppa_link_hash_table *hppa_info = hppa_link_hash_table (info);
3188   struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
3189   bfd_vma *local_offsets;
3190   Elf_Internal_Shdr *symtab_hdr;
3191   int insn;
3192   bfd_vma max_branch_offset = 0;
3193   bfd_vma offset = rel->r_offset;
3194   bfd_signed_vma addend = rel->r_addend;
3195   reloc_howto_type *howto = elf_hppa_howto_table + ELF_R_TYPE (rel->r_info);
3196   unsigned int r_symndx = ELF_R_SYM (rel->r_info);
3197   unsigned int r_type = howto->type;
3198   bfd_byte *hit_data = contents + offset;
3199
3200   if (hppa_info == NULL)
3201     return bfd_reloc_notsupported;
3202
3203   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3204   local_offsets = elf_local_got_offsets (input_bfd);
3205   insn = bfd_get_32 (input_bfd, hit_data);
3206
3207   switch (r_type)
3208     {
3209     case R_PARISC_NONE:
3210       break;
3211
3212     /* Basic function call support.
3213
3214        Note for a call to a function defined in another dynamic library
3215        we want to redirect the call to a stub.  */
3216
3217     /* PC relative relocs without an implicit offset.  */
3218     case R_PARISC_PCREL21L:
3219     case R_PARISC_PCREL14R:
3220     case R_PARISC_PCREL14F:
3221     case R_PARISC_PCREL14WR:
3222     case R_PARISC_PCREL14DR:
3223     case R_PARISC_PCREL16F:
3224     case R_PARISC_PCREL16WF:
3225     case R_PARISC_PCREL16DF:
3226       {
3227         /* If this is a call to a function defined in another dynamic
3228            library, then redirect the call to the local stub for this
3229            function.  */
3230         if (sym_sec == NULL || sym_sec->output_section == NULL)
3231           value = (hh->stub_offset + hppa_info->stub_sec->output_offset
3232                    + hppa_info->stub_sec->output_section->vma);
3233
3234         /* Turn VALUE into a proper PC relative address.  */
3235         value -= (offset + input_section->output_offset
3236                   + input_section->output_section->vma);
3237
3238         /* Adjust for any field selectors.  */
3239         if (r_type == R_PARISC_PCREL21L)
3240           value = hppa_field_adjust (value, -8 + addend, e_lsel);
3241         else if (r_type == R_PARISC_PCREL14F
3242                  || r_type == R_PARISC_PCREL16F
3243                  || r_type == R_PARISC_PCREL16WF
3244                  || r_type == R_PARISC_PCREL16DF)
3245           value = hppa_field_adjust (value, -8 + addend, e_fsel);
3246         else
3247           value = hppa_field_adjust (value, -8 + addend, e_rsel);
3248
3249         /* Apply the relocation to the given instruction.  */
3250         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
3251         break;
3252       }
3253
3254     case R_PARISC_PCREL12F:
3255     case R_PARISC_PCREL22F:
3256     case R_PARISC_PCREL17F:
3257     case R_PARISC_PCREL22C:
3258     case R_PARISC_PCREL17C:
3259     case R_PARISC_PCREL17R:
3260       {
3261         /* If this is a call to a function defined in another dynamic
3262            library, then redirect the call to the local stub for this
3263            function.  */
3264         if (sym_sec == NULL || sym_sec->output_section == NULL)
3265           value = (hh->stub_offset + hppa_info->stub_sec->output_offset
3266                    + hppa_info->stub_sec->output_section->vma);
3267
3268         /* Turn VALUE into a proper PC relative address.  */
3269         value -= (offset + input_section->output_offset
3270                   + input_section->output_section->vma);
3271         addend -= 8;
3272
3273         if (r_type == (unsigned int) R_PARISC_PCREL22F)
3274           max_branch_offset = (1 << (22-1)) << 2;
3275         else if (r_type == (unsigned int) R_PARISC_PCREL17F)
3276           max_branch_offset = (1 << (17-1)) << 2;
3277         else if (r_type == (unsigned int) R_PARISC_PCREL12F)
3278           max_branch_offset = (1 << (12-1)) << 2;
3279
3280         /* Make sure we can reach the branch target.  */
3281         if (max_branch_offset != 0
3282             && value + addend + max_branch_offset >= 2*max_branch_offset)
3283           {
3284             _bfd_error_handler
3285               /* xgettext:c-format */
3286               (_("%pB(%pA+%#" PRIx64 "): cannot reach %s"),
3287               input_bfd,
3288               input_section,
3289               (uint64_t) offset,
3290               eh ? eh->root.root.string : "unknown");
3291             bfd_set_error (bfd_error_bad_value);
3292             return bfd_reloc_overflow;
3293           }
3294
3295         /* Adjust for any field selectors.  */
3296         if (r_type == R_PARISC_PCREL17R)
3297           value = hppa_field_adjust (value, addend, e_rsel);
3298         else
3299           value = hppa_field_adjust (value, addend, e_fsel);
3300
3301         /* All branches are implicitly shifted by 2 places.  */
3302         value >>= 2;
3303
3304         /* Apply the relocation to the given instruction.  */
3305         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
3306         break;
3307       }
3308
3309     /* Indirect references to data through the DLT.  */
3310     case R_PARISC_DLTIND14R:
3311     case R_PARISC_DLTIND14F:
3312     case R_PARISC_DLTIND14DR:
3313     case R_PARISC_DLTIND14WR:
3314     case R_PARISC_DLTIND21L:
3315     case R_PARISC_LTOFF_FPTR14R:
3316     case R_PARISC_LTOFF_FPTR14DR:
3317     case R_PARISC_LTOFF_FPTR14WR:
3318     case R_PARISC_LTOFF_FPTR21L:
3319     case R_PARISC_LTOFF_FPTR16F:
3320     case R_PARISC_LTOFF_FPTR16WF:
3321     case R_PARISC_LTOFF_FPTR16DF:
3322     case R_PARISC_LTOFF_TP21L:
3323     case R_PARISC_LTOFF_TP14R:
3324     case R_PARISC_LTOFF_TP14F:
3325     case R_PARISC_LTOFF_TP14WR:
3326     case R_PARISC_LTOFF_TP14DR:
3327     case R_PARISC_LTOFF_TP16F:
3328     case R_PARISC_LTOFF_TP16WF:
3329     case R_PARISC_LTOFF_TP16DF:
3330     case R_PARISC_LTOFF16F:
3331     case R_PARISC_LTOFF16WF:
3332     case R_PARISC_LTOFF16DF:
3333       {
3334         bfd_vma off;
3335
3336         /* If this relocation was against a local symbol, then we still
3337            have not set up the DLT entry (it's not convenient to do so
3338            in the "finalize_dlt" routine because it is difficult to get
3339            to the local symbol's value).
3340
3341            So, if this is a local symbol (h == NULL), then we need to
3342            fill in its DLT entry.
3343
3344            Similarly we may still need to set up an entry in .opd for
3345            a local function which had its address taken.  */
3346         if (hh == NULL)
3347           {
3348             bfd_vma *local_opd_offsets, *local_dlt_offsets;
3349
3350             if (local_offsets == NULL)
3351               abort ();
3352
3353             /* Now do .opd creation if needed.  */
3354             if (r_type == R_PARISC_LTOFF_FPTR14R
3355                 || r_type == R_PARISC_LTOFF_FPTR14DR
3356                 || r_type == R_PARISC_LTOFF_FPTR14WR
3357                 || r_type == R_PARISC_LTOFF_FPTR21L
3358                 || r_type == R_PARISC_LTOFF_FPTR16F
3359                 || r_type == R_PARISC_LTOFF_FPTR16WF
3360                 || r_type == R_PARISC_LTOFF_FPTR16DF)
3361               {
3362                 local_opd_offsets = local_offsets + 2 * symtab_hdr->sh_info;
3363                 off = local_opd_offsets[r_symndx];
3364
3365                 /* The last bit records whether we've already initialised
3366                    this local .opd entry.  */
3367                 if ((off & 1) != 0)
3368                   {
3369                     BFD_ASSERT (off != (bfd_vma) -1);
3370                     off &= ~1;
3371                   }
3372                 else
3373                   {
3374                     local_opd_offsets[r_symndx] |= 1;
3375
3376                     /* The first two words of an .opd entry are zero.  */
3377                     memset (hppa_info->opd_sec->contents + off, 0, 16);
3378
3379                     /* The next word is the address of the function.  */
3380                     bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
3381                                 (hppa_info->opd_sec->contents + off + 16));
3382
3383                     /* The last word is our local __gp value.  */
3384                     value = _bfd_get_gp_value
3385                               (hppa_info->opd_sec->output_section->owner);
3386                     bfd_put_64 (hppa_info->opd_sec->owner, value,
3387                                 (hppa_info->opd_sec->contents + off + 24));
3388                   }
3389
3390                 /* The DLT value is the address of the .opd entry.  */
3391                 value = (off
3392                          + hppa_info->opd_sec->output_offset
3393                          + hppa_info->opd_sec->output_section->vma);
3394                 addend = 0;
3395               }
3396
3397             local_dlt_offsets = local_offsets;
3398             off = local_dlt_offsets[r_symndx];
3399
3400             if ((off & 1) != 0)
3401               {
3402                 BFD_ASSERT (off != (bfd_vma) -1);
3403                 off &= ~1;
3404               }
3405             else
3406               {
3407                 local_dlt_offsets[r_symndx] |= 1;
3408                 bfd_put_64 (hppa_info->dlt_sec->owner,
3409                             value + addend,
3410                             hppa_info->dlt_sec->contents + off);
3411               }
3412           }
3413         else
3414           off = hh->dlt_offset;
3415
3416         /* We want the value of the DLT offset for this symbol, not
3417            the symbol's actual address.  Note that __gp may not point
3418            to the start of the DLT, so we have to compute the absolute
3419            address, then subtract out the value of __gp.  */
3420         value = (off
3421                  + hppa_info->dlt_sec->output_offset
3422                  + hppa_info->dlt_sec->output_section->vma);
3423         value -= _bfd_get_gp_value (output_bfd);
3424
3425         /* All DLTIND relocations are basically the same at this point,
3426            except that we need different field selectors for the 21bit
3427            version vs the 14bit versions.  */
3428         if (r_type == R_PARISC_DLTIND21L
3429             || r_type == R_PARISC_LTOFF_FPTR21L
3430             || r_type == R_PARISC_LTOFF_TP21L)
3431           value = hppa_field_adjust (value, 0, e_lsel);
3432         else if (r_type == R_PARISC_DLTIND14F
3433                  || r_type == R_PARISC_LTOFF_FPTR16F
3434                  || r_type == R_PARISC_LTOFF_FPTR16WF
3435                  || r_type == R_PARISC_LTOFF_FPTR16DF
3436                  || r_type == R_PARISC_LTOFF16F
3437                  || r_type == R_PARISC_LTOFF16DF
3438                  || r_type == R_PARISC_LTOFF16WF
3439                  || r_type == R_PARISC_LTOFF_TP16F
3440                  || r_type == R_PARISC_LTOFF_TP16WF
3441                  || r_type == R_PARISC_LTOFF_TP16DF)
3442           value = hppa_field_adjust (value, 0, e_fsel);
3443         else
3444           value = hppa_field_adjust (value, 0, e_rsel);
3445
3446         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
3447         break;
3448       }
3449
3450     case R_PARISC_DLTREL14R:
3451     case R_PARISC_DLTREL14F:
3452     case R_PARISC_DLTREL14DR:
3453     case R_PARISC_DLTREL14WR:
3454     case R_PARISC_DLTREL21L:
3455     case R_PARISC_DPREL21L:
3456     case R_PARISC_DPREL14WR:
3457     case R_PARISC_DPREL14DR:
3458     case R_PARISC_DPREL14R:
3459     case R_PARISC_DPREL14F:
3460     case R_PARISC_GPREL16F:
3461     case R_PARISC_GPREL16WF:
3462     case R_PARISC_GPREL16DF:
3463       {
3464         /* Subtract out the global pointer value to make value a DLT
3465            relative address.  */
3466         value -= _bfd_get_gp_value (output_bfd);
3467
3468         /* All DLTREL relocations are basically the same at this point,
3469            except that we need different field selectors for the 21bit
3470            version vs the 14bit versions.  */
3471         if (r_type == R_PARISC_DLTREL21L
3472             || r_type == R_PARISC_DPREL21L)
3473           value = hppa_field_adjust (value, addend, e_lrsel);
3474         else if (r_type == R_PARISC_DLTREL14F
3475                  || r_type == R_PARISC_DPREL14F
3476                  || r_type == R_PARISC_GPREL16F
3477                  || r_type == R_PARISC_GPREL16WF
3478                  || r_type == R_PARISC_GPREL16DF)
3479           value = hppa_field_adjust (value, addend, e_fsel);
3480         else
3481           value = hppa_field_adjust (value, addend, e_rrsel);
3482
3483         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
3484         break;
3485       }
3486
3487     case R_PARISC_DIR21L:
3488     case R_PARISC_DIR17R:
3489     case R_PARISC_DIR17F:
3490     case R_PARISC_DIR14R:
3491     case R_PARISC_DIR14F:
3492     case R_PARISC_DIR14WR:
3493     case R_PARISC_DIR14DR:
3494     case R_PARISC_DIR16F:
3495     case R_PARISC_DIR16WF:
3496     case R_PARISC_DIR16DF:
3497       {
3498         /* All DIR relocations are basically the same at this point,
3499            except that branch offsets need to be divided by four, and
3500            we need different field selectors.  Note that we don't
3501            redirect absolute calls to local stubs.  */
3502
3503         if (r_type == R_PARISC_DIR21L)
3504           value = hppa_field_adjust (value, addend, e_lrsel);
3505         else if (r_type == R_PARISC_DIR17F
3506                  || r_type == R_PARISC_DIR16F
3507                  || r_type == R_PARISC_DIR16WF
3508                  || r_type == R_PARISC_DIR16DF
3509                  || r_type == R_PARISC_DIR14F)
3510           value = hppa_field_adjust (value, addend, e_fsel);
3511         else
3512           value = hppa_field_adjust (value, addend, e_rrsel);
3513
3514         if (r_type == R_PARISC_DIR17R || r_type == R_PARISC_DIR17F)
3515           /* All branches are implicitly shifted by 2 places.  */
3516           value >>= 2;
3517
3518         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
3519         break;
3520       }
3521
3522     case R_PARISC_PLTOFF21L:
3523     case R_PARISC_PLTOFF14R:
3524     case R_PARISC_PLTOFF14F:
3525     case R_PARISC_PLTOFF14WR:
3526     case R_PARISC_PLTOFF14DR:
3527     case R_PARISC_PLTOFF16F:
3528     case R_PARISC_PLTOFF16WF:
3529     case R_PARISC_PLTOFF16DF:
3530       {
3531         /* We want the value of the PLT offset for this symbol, not
3532            the symbol's actual address.  Note that __gp may not point
3533            to the start of the DLT, so we have to compute the absolute
3534            address, then subtract out the value of __gp.  */
3535         value = (hh->plt_offset
3536                  + hppa_info->plt_sec->output_offset
3537                  + hppa_info->plt_sec->output_section->vma);
3538         value -= _bfd_get_gp_value (output_bfd);
3539
3540         /* All PLTOFF relocations are basically the same at this point,
3541            except that we need different field selectors for the 21bit
3542            version vs the 14bit versions.  */
3543         if (r_type == R_PARISC_PLTOFF21L)
3544           value = hppa_field_adjust (value, addend, e_lrsel);
3545         else if (r_type == R_PARISC_PLTOFF14F
3546                  || r_type == R_PARISC_PLTOFF16F
3547                  || r_type == R_PARISC_PLTOFF16WF
3548                  || r_type == R_PARISC_PLTOFF16DF)
3549           value = hppa_field_adjust (value, addend, e_fsel);
3550         else
3551           value = hppa_field_adjust (value, addend, e_rrsel);
3552
3553         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
3554         break;
3555       }
3556
3557     case R_PARISC_LTOFF_FPTR32:
3558       {
3559         /* We may still need to create the FPTR itself if it was for
3560            a local symbol.  */
3561         if (hh == NULL)
3562           {
3563             /* The first two words of an .opd entry are zero.  */
3564             memset (hppa_info->opd_sec->contents + hh->opd_offset, 0, 16);
3565
3566             /* The next word is the address of the function.  */
3567             bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
3568                         (hppa_info->opd_sec->contents
3569                          + hh->opd_offset + 16));
3570
3571             /* The last word is our local __gp value.  */
3572             value = _bfd_get_gp_value
3573                       (hppa_info->opd_sec->output_section->owner);
3574             bfd_put_64 (hppa_info->opd_sec->owner, value,
3575                         hppa_info->opd_sec->contents + hh->opd_offset + 24);
3576
3577             /* The DLT value is the address of the .opd entry.  */
3578             value = (hh->opd_offset
3579                      + hppa_info->opd_sec->output_offset
3580                      + hppa_info->opd_sec->output_section->vma);
3581
3582             bfd_put_64 (hppa_info->dlt_sec->owner,
3583                         value,
3584                         hppa_info->dlt_sec->contents + hh->dlt_offset);
3585           }
3586
3587         /* We want the value of the DLT offset for this symbol, not
3588            the symbol's actual address.  Note that __gp may not point
3589            to the start of the DLT, so we have to compute the absolute
3590            address, then subtract out the value of __gp.  */
3591         value = (hh->dlt_offset
3592                  + hppa_info->dlt_sec->output_offset
3593                  + hppa_info->dlt_sec->output_section->vma);
3594         value -= _bfd_get_gp_value (output_bfd);
3595         bfd_put_32 (input_bfd, value, hit_data);
3596         return bfd_reloc_ok;
3597       }
3598
3599     case R_PARISC_LTOFF_FPTR64:
3600     case R_PARISC_LTOFF_TP64:
3601       {
3602         /* We may still need to create the FPTR itself if it was for
3603            a local symbol.  */
3604         if (eh == NULL && r_type == R_PARISC_LTOFF_FPTR64)
3605           {
3606             /* The first two words of an .opd entry are zero.  */
3607             memset (hppa_info->opd_sec->contents + hh->opd_offset, 0, 16);
3608
3609             /* The next word is the address of the function.  */
3610             bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
3611                         (hppa_info->opd_sec->contents
3612                          + hh->opd_offset + 16));
3613
3614             /* The last word is our local __gp value.  */
3615             value = _bfd_get_gp_value
3616                       (hppa_info->opd_sec->output_section->owner);
3617             bfd_put_64 (hppa_info->opd_sec->owner, value,
3618                         hppa_info->opd_sec->contents + hh->opd_offset + 24);
3619
3620             /* The DLT value is the address of the .opd entry.  */
3621             value = (hh->opd_offset
3622                      + hppa_info->opd_sec->output_offset
3623                      + hppa_info->opd_sec->output_section->vma);
3624
3625             bfd_put_64 (hppa_info->dlt_sec->owner,
3626                         value,
3627                         hppa_info->dlt_sec->contents + hh->dlt_offset);
3628           }
3629
3630         /* We want the value of the DLT offset for this symbol, not
3631            the symbol's actual address.  Note that __gp may not point
3632            to the start of the DLT, so we have to compute the absolute
3633            address, then subtract out the value of __gp.  */
3634         value = (hh->dlt_offset
3635                  + hppa_info->dlt_sec->output_offset
3636                  + hppa_info->dlt_sec->output_section->vma);
3637         value -= _bfd_get_gp_value (output_bfd);
3638         bfd_put_64 (input_bfd, value, hit_data);
3639         return bfd_reloc_ok;
3640       }
3641
3642     case R_PARISC_DIR32:
3643       bfd_put_32 (input_bfd, value + addend, hit_data);
3644       return bfd_reloc_ok;
3645
3646     case R_PARISC_DIR64:
3647       bfd_put_64 (input_bfd, value + addend, hit_data);
3648       return bfd_reloc_ok;
3649
3650     case R_PARISC_GPREL64:
3651       /* Subtract out the global pointer value to make value a DLT
3652          relative address.  */
3653       value -= _bfd_get_gp_value (output_bfd);
3654
3655       bfd_put_64 (input_bfd, value + addend, hit_data);
3656       return bfd_reloc_ok;
3657
3658     case R_PARISC_LTOFF64:
3659         /* We want the value of the DLT offset for this symbol, not
3660            the symbol's actual address.  Note that __gp may not point
3661            to the start of the DLT, so we have to compute the absolute
3662            address, then subtract out the value of __gp.  */
3663       value = (hh->dlt_offset
3664                + hppa_info->dlt_sec->output_offset
3665                + hppa_info->dlt_sec->output_section->vma);
3666       value -= _bfd_get_gp_value (output_bfd);
3667
3668       bfd_put_64 (input_bfd, value + addend, hit_data);
3669       return bfd_reloc_ok;
3670
3671     case R_PARISC_PCREL32:
3672       {
3673         /* If this is a call to a function defined in another dynamic
3674            library, then redirect the call to the local stub for this
3675            function.  */
3676         if (sym_sec == NULL || sym_sec->output_section == NULL)
3677           value = (hh->stub_offset + hppa_info->stub_sec->output_offset
3678                    + hppa_info->stub_sec->output_section->vma);
3679
3680         /* Turn VALUE into a proper PC relative address.  */
3681         value -= (offset + input_section->output_offset
3682                   + input_section->output_section->vma);
3683
3684         value += addend;
3685         value -= 8;
3686         bfd_put_32 (input_bfd, value, hit_data);
3687         return bfd_reloc_ok;
3688       }
3689
3690     case R_PARISC_PCREL64:
3691       {
3692         /* If this is a call to a function defined in another dynamic
3693            library, then redirect the call to the local stub for this
3694            function.  */
3695         if (sym_sec == NULL || sym_sec->output_section == NULL)
3696           value = (hh->stub_offset + hppa_info->stub_sec->output_offset
3697                    + hppa_info->stub_sec->output_section->vma);
3698
3699         /* Turn VALUE into a proper PC relative address.  */
3700         value -= (offset + input_section->output_offset
3701                   + input_section->output_section->vma);
3702
3703         value += addend;
3704         value -= 8;
3705         bfd_put_64 (input_bfd, value, hit_data);
3706         return bfd_reloc_ok;
3707       }
3708
3709     case R_PARISC_FPTR64:
3710       {
3711         bfd_vma off;
3712
3713         /* We may still need to create the FPTR itself if it was for
3714            a local symbol.  */
3715         if (hh == NULL)
3716           {
3717             bfd_vma *local_opd_offsets;
3718
3719             if (local_offsets == NULL)
3720               abort ();
3721
3722             local_opd_offsets = local_offsets + 2 * symtab_hdr->sh_info;
3723             off = local_opd_offsets[r_symndx];
3724
3725             /* The last bit records whether we've already initialised
3726                this local .opd entry.  */
3727             if ((off & 1) != 0)
3728               {
3729                 BFD_ASSERT (off != (bfd_vma) -1);
3730                 off &= ~1;
3731               }
3732             else
3733               {
3734                 /* The first two words of an .opd entry are zero.  */
3735                 memset (hppa_info->opd_sec->contents + off, 0, 16);
3736
3737                 /* The next word is the address of the function.  */
3738                 bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
3739                             (hppa_info->opd_sec->contents + off + 16));
3740
3741                 /* The last word is our local __gp value.  */
3742                 value = _bfd_get_gp_value
3743                           (hppa_info->opd_sec->output_section->owner);
3744                 bfd_put_64 (hppa_info->opd_sec->owner, value,
3745                             hppa_info->opd_sec->contents + off + 24);
3746               }
3747           }
3748         else
3749           off = hh->opd_offset;
3750
3751         if (hh == NULL || hh->want_opd)
3752           /* We want the value of the OPD offset for this symbol.  */
3753           value = (off
3754                    + hppa_info->opd_sec->output_offset
3755                    + hppa_info->opd_sec->output_section->vma);
3756         else
3757           /* We want the address of the symbol.  */
3758           value += addend;
3759
3760         bfd_put_64 (input_bfd, value, hit_data);
3761         return bfd_reloc_ok;
3762       }
3763
3764     case R_PARISC_SECREL32:
3765       if (sym_sec)
3766         value -= sym_sec->output_section->vma;
3767       bfd_put_32 (input_bfd, value + addend, hit_data);
3768       return bfd_reloc_ok;
3769
3770     case R_PARISC_SEGREL32:
3771     case R_PARISC_SEGREL64:
3772       {
3773         /* If this is the first SEGREL relocation, then initialize
3774            the segment base values.  */
3775         if (hppa_info->text_segment_base == (bfd_vma) -1)
3776           bfd_map_over_sections (output_bfd, elf_hppa_record_segment_addrs,
3777                                  hppa_info);
3778
3779         /* VALUE holds the absolute address.  We want to include the
3780            addend, then turn it into a segment relative address.
3781
3782            The segment is derived from SYM_SEC.  We assume that there are
3783            only two segments of note in the resulting executable/shlib.
3784            A readonly segment (.text) and a readwrite segment (.data).  */
3785         value += addend;
3786
3787         if (sym_sec->flags & SEC_CODE)
3788           value -= hppa_info->text_segment_base;
3789         else
3790           value -= hppa_info->data_segment_base;
3791
3792         if (r_type == R_PARISC_SEGREL32)
3793           bfd_put_32 (input_bfd, value, hit_data);
3794         else
3795           bfd_put_64 (input_bfd, value, hit_data);
3796         return bfd_reloc_ok;
3797       }
3798
3799     /* Something we don't know how to handle.  */
3800     default:
3801       return bfd_reloc_notsupported;
3802     }
3803
3804   /* Update the instruction word.  */
3805   bfd_put_32 (input_bfd, (bfd_vma) insn, hit_data);
3806   return bfd_reloc_ok;
3807 }
3808
3809 /* Relocate an HPPA ELF section.  */
3810
3811 static bfd_boolean
3812 elf64_hppa_relocate_section (bfd *output_bfd,
3813                            struct bfd_link_info *info,
3814                            bfd *input_bfd,
3815                            asection *input_section,
3816                            bfd_byte *contents,
3817                            Elf_Internal_Rela *relocs,
3818                            Elf_Internal_Sym *local_syms,
3819                            asection **local_sections)
3820 {
3821   Elf_Internal_Shdr *symtab_hdr;
3822   Elf_Internal_Rela *rel;
3823   Elf_Internal_Rela *relend;
3824   struct elf64_hppa_link_hash_table *hppa_info;
3825
3826   hppa_info = hppa_link_hash_table (info);
3827   if (hppa_info == NULL)
3828     return FALSE;
3829
3830   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3831
3832   rel = relocs;
3833   relend = relocs + input_section->reloc_count;
3834   for (; rel < relend; rel++)
3835     {
3836       int r_type;
3837       reloc_howto_type *howto = elf_hppa_howto_table + ELF_R_TYPE (rel->r_info);
3838       unsigned long r_symndx;
3839       struct elf_link_hash_entry *eh;
3840       Elf_Internal_Sym *sym;
3841       asection *sym_sec;
3842       bfd_vma relocation;
3843       bfd_reloc_status_type r;
3844
3845       r_type = ELF_R_TYPE (rel->r_info);
3846       if (r_type < 0 || r_type >= (int) R_PARISC_UNIMPLEMENTED)
3847         {
3848           bfd_set_error (bfd_error_bad_value);
3849           return FALSE;
3850         }
3851       if (r_type == (unsigned int) R_PARISC_GNU_VTENTRY
3852           || r_type == (unsigned int) R_PARISC_GNU_VTINHERIT)
3853         continue;
3854
3855       /* This is a final link.  */
3856       r_symndx = ELF_R_SYM (rel->r_info);
3857       eh = NULL;
3858       sym = NULL;
3859       sym_sec = NULL;
3860       if (r_symndx < symtab_hdr->sh_info)
3861         {
3862           /* This is a local symbol, hh defaults to NULL.  */
3863           sym = local_syms + r_symndx;
3864           sym_sec = local_sections[r_symndx];
3865           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sym_sec, rel);
3866         }
3867       else
3868         {
3869           /* This is not a local symbol.  */
3870           struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
3871
3872           /* It seems this can happen with erroneous or unsupported
3873              input (mixing a.out and elf in an archive, for example.)  */
3874           if (sym_hashes == NULL)
3875             return FALSE;
3876
3877           eh = sym_hashes[r_symndx - symtab_hdr->sh_info];
3878
3879           if (info->wrap_hash != NULL
3880               && (input_section->flags & SEC_DEBUGGING) != 0)
3881             eh = ((struct elf_link_hash_entry *)
3882                   unwrap_hash_lookup (info, input_bfd, &eh->root));
3883
3884           while (eh->root.type == bfd_link_hash_indirect
3885                  || eh->root.type == bfd_link_hash_warning)
3886             eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
3887
3888           relocation = 0;
3889           if (eh->root.type == bfd_link_hash_defined
3890               || eh->root.type == bfd_link_hash_defweak)
3891             {
3892               sym_sec = eh->root.u.def.section;
3893               if (sym_sec != NULL
3894                   && sym_sec->output_section != NULL)
3895                 relocation = (eh->root.u.def.value
3896                               + sym_sec->output_section->vma
3897                               + sym_sec->output_offset);
3898             }
3899           else if (eh->root.type == bfd_link_hash_undefweak)
3900             ;
3901           else if (info->unresolved_syms_in_objects == RM_IGNORE
3902                    && ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT)
3903             ;
3904           else if (!bfd_link_relocatable (info)
3905                    && elf_hppa_is_dynamic_loader_symbol (eh->root.root.string))
3906             continue;
3907           else if (!bfd_link_relocatable (info))
3908             {
3909               bfd_boolean err;
3910               err = (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
3911                      || ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT);
3912               (*info->callbacks->undefined_symbol) (info,
3913                                                     eh->root.root.string,
3914                                                     input_bfd,
3915                                                     input_section,
3916                                                     rel->r_offset, err);
3917             }
3918
3919           if (!bfd_link_relocatable (info)
3920               && relocation == 0
3921               && eh->root.type != bfd_link_hash_defined
3922               && eh->root.type != bfd_link_hash_defweak
3923               && eh->root.type != bfd_link_hash_undefweak)
3924             {
3925               if (info->unresolved_syms_in_objects == RM_IGNORE
3926                   && ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT
3927                   && eh->type == STT_PARISC_MILLI)
3928                 (*info->callbacks->undefined_symbol)
3929                   (info, eh_name (eh), input_bfd,
3930                    input_section, rel->r_offset, FALSE);
3931             }
3932         }
3933
3934       if (sym_sec != NULL && discarded_section (sym_sec))
3935         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3936                                          rel, 1, relend, howto, 0, contents);
3937
3938       if (bfd_link_relocatable (info))
3939         continue;
3940
3941       r = elf_hppa_final_link_relocate (rel, input_bfd, output_bfd,
3942                                         input_section, contents,
3943                                         relocation, info, sym_sec,
3944                                         eh);
3945
3946       if (r != bfd_reloc_ok)
3947         {
3948           switch (r)
3949             {
3950             default:
3951               abort ();
3952             case bfd_reloc_overflow:
3953               {
3954                 const char *sym_name;
3955
3956                 if (eh != NULL)
3957                   sym_name = NULL;
3958                 else
3959                   {
3960                     sym_name = bfd_elf_string_from_elf_section (input_bfd,
3961                                                                 symtab_hdr->sh_link,
3962                                                                 sym->st_name);
3963                     if (sym_name == NULL)
3964                       return FALSE;
3965                     if (*sym_name == '\0')
3966                       sym_name = bfd_section_name (input_bfd, sym_sec);
3967                   }
3968
3969                 (*info->callbacks->reloc_overflow)
3970                   (info, (eh ? &eh->root : NULL), sym_name, howto->name,
3971                    (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
3972               }
3973               break;
3974             }
3975         }
3976     }
3977   return TRUE;
3978 }
3979
3980 static const struct bfd_elf_special_section elf64_hppa_special_sections[] =
3981 {
3982   { STRING_COMMA_LEN (".fini"),  0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3983   { STRING_COMMA_LEN (".init"),  0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3984   { STRING_COMMA_LEN (".plt"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },
3985   { STRING_COMMA_LEN (".dlt"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },
3986   { STRING_COMMA_LEN (".sdata"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },
3987   { STRING_COMMA_LEN (".sbss"),  0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },
3988   { STRING_COMMA_LEN (".tbss"),  0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_HP_TLS },
3989   { NULL,                    0,  0, 0,            0 }
3990 };
3991
3992 /* The hash bucket size is the standard one, namely 4.  */
3993
3994 const struct elf_size_info hppa64_elf_size_info =
3995 {
3996   sizeof (Elf64_External_Ehdr),
3997   sizeof (Elf64_External_Phdr),
3998   sizeof (Elf64_External_Shdr),
3999   sizeof (Elf64_External_Rel),
4000   sizeof (Elf64_External_Rela),
4001   sizeof (Elf64_External_Sym),
4002   sizeof (Elf64_External_Dyn),
4003   sizeof (Elf_External_Note),
4004   4,
4005   1,
4006   64, 3,
4007   ELFCLASS64, EV_CURRENT,
4008   bfd_elf64_write_out_phdrs,
4009   bfd_elf64_write_shdrs_and_ehdr,
4010   bfd_elf64_checksum_contents,
4011   bfd_elf64_write_relocs,
4012   bfd_elf64_swap_symbol_in,
4013   bfd_elf64_swap_symbol_out,
4014   bfd_elf64_slurp_reloc_table,
4015   bfd_elf64_slurp_symbol_table,
4016   bfd_elf64_swap_dyn_in,
4017   bfd_elf64_swap_dyn_out,
4018   bfd_elf64_swap_reloc_in,
4019   bfd_elf64_swap_reloc_out,
4020   bfd_elf64_swap_reloca_in,
4021   bfd_elf64_swap_reloca_out
4022 };
4023
4024 #define TARGET_BIG_SYM                  hppa_elf64_vec
4025 #define TARGET_BIG_NAME                 "elf64-hppa"
4026 #define ELF_ARCH                        bfd_arch_hppa
4027 #define ELF_TARGET_ID                   HPPA64_ELF_DATA
4028 #define ELF_MACHINE_CODE                EM_PARISC
4029 /* This is not strictly correct.  The maximum page size for PA2.0 is
4030    64M.  But everything still uses 4k.  */
4031 #define ELF_MAXPAGESIZE                 0x1000
4032 #define ELF_OSABI                       ELFOSABI_HPUX
4033
4034 #define bfd_elf64_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
4035 #define bfd_elf64_bfd_reloc_name_lookup elf_hppa_reloc_name_lookup
4036 #define bfd_elf64_bfd_is_local_label_name       elf_hppa_is_local_label_name
4037 #define elf_info_to_howto               elf_hppa_info_to_howto
4038 #define elf_info_to_howto_rel           elf_hppa_info_to_howto_rel
4039
4040 #define elf_backend_section_from_shdr   elf64_hppa_section_from_shdr
4041 #define elf_backend_object_p            elf64_hppa_object_p
4042 #define elf_backend_final_write_processing \
4043                                         elf_hppa_final_write_processing
4044 #define elf_backend_fake_sections       elf_hppa_fake_sections
4045 #define elf_backend_add_symbol_hook     elf_hppa_add_symbol_hook
4046
4047 #define elf_backend_relocate_section    elf_hppa_relocate_section
4048
4049 #define bfd_elf64_bfd_final_link        elf_hppa_final_link
4050
4051 #define elf_backend_create_dynamic_sections \
4052                                         elf64_hppa_create_dynamic_sections
4053 #define elf_backend_post_process_headers        elf64_hppa_post_process_headers
4054
4055 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
4056
4057 #define elf_backend_adjust_dynamic_symbol \
4058                                         elf64_hppa_adjust_dynamic_symbol
4059
4060 #define elf_backend_size_dynamic_sections \
4061                                         elf64_hppa_size_dynamic_sections
4062
4063 #define elf_backend_finish_dynamic_symbol \
4064                                         elf64_hppa_finish_dynamic_symbol
4065 #define elf_backend_finish_dynamic_sections \
4066                                         elf64_hppa_finish_dynamic_sections
4067 #define elf_backend_grok_prstatus       elf64_hppa_grok_prstatus
4068 #define elf_backend_grok_psinfo         elf64_hppa_grok_psinfo
4069
4070 /* Stuff for the BFD linker: */
4071 #define bfd_elf64_bfd_link_hash_table_create \
4072         elf64_hppa_hash_table_create
4073
4074 #define elf_backend_check_relocs \
4075         elf64_hppa_check_relocs
4076
4077 #define elf_backend_size_info \
4078   hppa64_elf_size_info
4079
4080 #define elf_backend_additional_program_headers \
4081         elf64_hppa_additional_program_headers
4082
4083 #define elf_backend_modify_segment_map \
4084         elf64_hppa_modify_segment_map
4085
4086 #define elf_backend_allow_non_load_phdr \
4087         elf64_hppa_allow_non_load_phdr
4088
4089 #define elf_backend_link_output_symbol_hook \
4090         elf64_hppa_link_output_symbol_hook
4091
4092 #define elf_backend_want_got_plt        0
4093 #define elf_backend_plt_readonly        0
4094 #define elf_backend_want_plt_sym        0
4095 #define elf_backend_got_header_size     0
4096 #define elf_backend_type_change_ok      TRUE
4097 #define elf_backend_get_symbol_type     elf64_hppa_elf_get_symbol_type
4098 #define elf_backend_reloc_type_class    elf64_hppa_reloc_type_class
4099 #define elf_backend_rela_normal         1
4100 #define elf_backend_special_sections    elf64_hppa_special_sections
4101 #define elf_backend_action_discarded    elf_hppa_action_discarded
4102 #define elf_backend_section_from_phdr   elf64_hppa_section_from_phdr
4103
4104 #define elf64_bed                       elf64_hppa_hpux_bed
4105
4106 #include "elf64-target.h"
4107
4108 #undef TARGET_BIG_SYM
4109 #define TARGET_BIG_SYM                  hppa_elf64_linux_vec
4110 #undef TARGET_BIG_NAME
4111 #define TARGET_BIG_NAME                 "elf64-hppa-linux"
4112 #undef ELF_OSABI
4113 #define ELF_OSABI                       ELFOSABI_GNU
4114 #undef elf64_bed
4115 #define elf64_bed                       elf64_hppa_linux_bed
4116
4117 #include "elf64-target.h"