or1k: Fix incorrect value in PLT GOT entries, causing infinite loop
[external/binutils.git] / bfd / elf64-hppa.c
1 /* Support for HPPA 64-bit ELF
2    Copyright (C) 1999-2019 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 (info->output_bfd);
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 (info->output_bfd, &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 (info->output_bfd);
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 (info->output_bfd, &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 (info->output_bfd, &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 (info->output_bfd, &rel, loc);
2435         }
2436     }
2437
2438   return TRUE;
2439 }
2440
2441 /* Used to decide how to sort relocs in an optimal manner for the
2442    dynamic linker, before writing them out.  */
2443
2444 static enum elf_reloc_type_class
2445 elf64_hppa_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
2446                              const asection *rel_sec ATTRIBUTE_UNUSED,
2447                              const Elf_Internal_Rela *rela)
2448 {
2449   if (ELF64_R_SYM (rela->r_info) == STN_UNDEF)
2450     return reloc_class_relative;
2451
2452   switch ((int) ELF64_R_TYPE (rela->r_info))
2453     {
2454     case R_PARISC_IPLT:
2455       return reloc_class_plt;
2456     case R_PARISC_COPY:
2457       return reloc_class_copy;
2458     default:
2459       return reloc_class_normal;
2460     }
2461 }
2462
2463 /* Finish up the dynamic sections.  */
2464
2465 static bfd_boolean
2466 elf64_hppa_finish_dynamic_sections (bfd *output_bfd,
2467                                     struct bfd_link_info *info)
2468 {
2469   bfd *dynobj;
2470   asection *sdyn;
2471   struct elf64_hppa_link_hash_table *hppa_info;
2472
2473   hppa_info = hppa_link_hash_table (info);
2474   if (hppa_info == NULL)
2475     return FALSE;
2476
2477   /* Finalize the contents of the .opd section.  */
2478   elf_link_hash_traverse (elf_hash_table (info),
2479                           elf64_hppa_finalize_opd,
2480                           info);
2481
2482   elf_link_hash_traverse (elf_hash_table (info),
2483                           elf64_hppa_finalize_dynreloc,
2484                           info);
2485
2486   /* Finalize the contents of the .dlt section.  */
2487   dynobj = elf_hash_table (info)->dynobj;
2488   /* Finalize the contents of the .dlt section.  */
2489   elf_link_hash_traverse (elf_hash_table (info),
2490                           elf64_hppa_finalize_dlt,
2491                           info);
2492
2493   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
2494
2495   if (elf_hash_table (info)->dynamic_sections_created)
2496     {
2497       Elf64_External_Dyn *dyncon, *dynconend;
2498
2499       BFD_ASSERT (sdyn != NULL);
2500
2501       dyncon = (Elf64_External_Dyn *) sdyn->contents;
2502       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
2503       for (; dyncon < dynconend; dyncon++)
2504         {
2505           Elf_Internal_Dyn dyn;
2506           asection *s;
2507
2508           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
2509
2510           switch (dyn.d_tag)
2511             {
2512             default:
2513               break;
2514
2515             case DT_HP_LOAD_MAP:
2516               /* Compute the absolute address of 16byte scratchpad area
2517                  for the dynamic linker.
2518
2519                  By convention the linker script will allocate the scratchpad
2520                  area at the start of the .data section.  So all we have to
2521                  to is find the start of the .data section.  */
2522               s = bfd_get_section_by_name (output_bfd, ".data");
2523               if (!s)
2524                 return FALSE;
2525               dyn.d_un.d_ptr = s->vma;
2526               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2527               break;
2528
2529             case DT_PLTGOT:
2530               /* HP's use PLTGOT to set the GOT register.  */
2531               dyn.d_un.d_ptr = _bfd_get_gp_value (output_bfd);
2532               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2533               break;
2534
2535             case DT_JMPREL:
2536               s = hppa_info->plt_rel_sec;
2537               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2538               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2539               break;
2540
2541             case DT_PLTRELSZ:
2542               s = hppa_info->plt_rel_sec;
2543               dyn.d_un.d_val = s->size;
2544               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2545               break;
2546
2547             case DT_RELA:
2548               s = hppa_info->other_rel_sec;
2549               if (! s || ! s->size)
2550                 s = hppa_info->dlt_rel_sec;
2551               if (! s || ! s->size)
2552                 s = hppa_info->opd_rel_sec;
2553               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2554               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2555               break;
2556
2557             case DT_RELASZ:
2558               s = hppa_info->other_rel_sec;
2559               dyn.d_un.d_val = s->size;
2560               s = hppa_info->dlt_rel_sec;
2561               dyn.d_un.d_val += s->size;
2562               s = hppa_info->opd_rel_sec;
2563               dyn.d_un.d_val += s->size;
2564               /* There is some question about whether or not the size of
2565                  the PLT relocs should be included here.  HP's tools do
2566                  it, so we'll emulate them.  */
2567               s = hppa_info->plt_rel_sec;
2568               dyn.d_un.d_val += s->size;
2569               bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
2570               break;
2571
2572             }
2573         }
2574     }
2575
2576   return TRUE;
2577 }
2578
2579 /* Support for core dump NOTE sections.  */
2580
2581 static bfd_boolean
2582 elf64_hppa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
2583 {
2584   int offset;
2585   size_t size;
2586
2587   switch (note->descsz)
2588     {
2589       default:
2590         return FALSE;
2591
2592       case 760:         /* Linux/hppa */
2593         /* pr_cursig */
2594         elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2595
2596         /* pr_pid */
2597         elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 32);
2598
2599         /* pr_reg */
2600         offset = 112;
2601         size = 640;
2602
2603         break;
2604     }
2605
2606   /* Make a ".reg/999" section.  */
2607   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2608                                           size, note->descpos + offset);
2609 }
2610
2611 static bfd_boolean
2612 elf64_hppa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2613 {
2614   char * command;
2615   int n;
2616
2617   switch (note->descsz)
2618     {
2619     default:
2620       return FALSE;
2621
2622     case 136:           /* Linux/hppa elf_prpsinfo.  */
2623       elf_tdata (abfd)->core->program
2624         = _bfd_elfcore_strndup (abfd, note->descdata + 40, 16);
2625       elf_tdata (abfd)->core->command
2626         = _bfd_elfcore_strndup (abfd, note->descdata + 56, 80);
2627     }
2628
2629   /* Note that for some reason, a spurious space is tacked
2630      onto the end of the args in some (at least one anyway)
2631      implementations, so strip it off if it exists.  */
2632   command = elf_tdata (abfd)->core->command;
2633   n = strlen (command);
2634
2635   if (0 < n && command[n - 1] == ' ')
2636     command[n - 1] = '\0';
2637
2638   return TRUE;
2639 }
2640
2641 /* Return the number of additional phdrs we will need.
2642
2643    The generic ELF code only creates PT_PHDRs for executables.  The HP
2644    dynamic linker requires PT_PHDRs for dynamic libraries too.
2645
2646    This routine indicates that the backend needs one additional program
2647    header for that case.
2648
2649    Note we do not have access to the link info structure here, so we have
2650    to guess whether or not we are building a shared library based on the
2651    existence of a .interp section.  */
2652
2653 static int
2654 elf64_hppa_additional_program_headers (bfd *abfd,
2655                                 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2656 {
2657   asection *s;
2658
2659   /* If we are creating a shared library, then we have to create a
2660      PT_PHDR segment.  HP's dynamic linker chokes without it.  */
2661   s = bfd_get_section_by_name (abfd, ".interp");
2662   if (! s)
2663     return 1;
2664   return 0;
2665 }
2666
2667 static bfd_boolean
2668 elf64_hppa_allow_non_load_phdr (bfd *abfd ATTRIBUTE_UNUSED,
2669                                 const Elf_Internal_Phdr *phdr ATTRIBUTE_UNUSED,
2670                                 unsigned int count ATTRIBUTE_UNUSED)
2671 {
2672   return TRUE;
2673 }
2674
2675 /* Allocate and initialize any program headers required by this
2676    specific backend.
2677
2678    The generic ELF code only creates PT_PHDRs for executables.  The HP
2679    dynamic linker requires PT_PHDRs for dynamic libraries too.
2680
2681    This allocates the PT_PHDR and initializes it in a manner suitable
2682    for the HP linker.
2683
2684    Note we do not have access to the link info structure here, so we have
2685    to guess whether or not we are building a shared library based on the
2686    existence of a .interp section.  */
2687
2688 static bfd_boolean
2689 elf64_hppa_modify_segment_map (bfd *abfd, struct bfd_link_info *info)
2690 {
2691   struct elf_segment_map *m;
2692
2693   m = elf_seg_map (abfd);
2694   if (info != NULL && !info->user_phdrs && m != NULL && m->p_type != PT_PHDR)
2695     {
2696       m = ((struct elf_segment_map *)
2697            bfd_zalloc (abfd, (bfd_size_type) sizeof *m));
2698       if (m == NULL)
2699         return FALSE;
2700
2701       m->p_type = PT_PHDR;
2702       m->p_flags = PF_R | PF_X;
2703       m->p_flags_valid = 1;
2704       m->p_paddr_valid = 1;
2705       m->includes_phdrs = 1;
2706
2707       m->next = elf_seg_map (abfd);
2708       elf_seg_map (abfd) = m;
2709     }
2710
2711   for (m = elf_seg_map (abfd) ; m != NULL; m = m->next)
2712     if (m->p_type == PT_LOAD)
2713       {
2714         unsigned int i;
2715
2716         for (i = 0; i < m->count; i++)
2717           {
2718             /* The code "hint" is not really a hint.  It is a requirement
2719                for certain versions of the HP dynamic linker.  Worse yet,
2720                it must be set even if the shared library does not have
2721                any code in its "text" segment (thus the check for .hash
2722                to catch this situation).  */
2723             if (m->sections[i]->flags & SEC_CODE
2724                 || (strcmp (m->sections[i]->name, ".hash") == 0))
2725               m->p_flags |= (PF_X | PF_HP_CODE);
2726           }
2727       }
2728
2729   return TRUE;
2730 }
2731
2732 /* Called when writing out an object file to decide the type of a
2733    symbol.  */
2734 static int
2735 elf64_hppa_elf_get_symbol_type (Elf_Internal_Sym *elf_sym,
2736                                 int type)
2737 {
2738   if (ELF_ST_TYPE (elf_sym->st_info) == STT_PARISC_MILLI)
2739     return STT_PARISC_MILLI;
2740   else
2741     return type;
2742 }
2743
2744 /* Support HP specific sections for core files.  */
2745
2746 static bfd_boolean
2747 elf64_hppa_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int sec_index,
2748                               const char *typename)
2749 {
2750   if (hdr->p_type == PT_HP_CORE_KERNEL)
2751     {
2752       asection *sect;
2753
2754       if (!_bfd_elf_make_section_from_phdr (abfd, hdr, sec_index, typename))
2755         return FALSE;
2756
2757       sect = bfd_make_section_anyway (abfd, ".kernel");
2758       if (sect == NULL)
2759         return FALSE;
2760       sect->size = hdr->p_filesz;
2761       sect->filepos = hdr->p_offset;
2762       sect->flags = SEC_HAS_CONTENTS | SEC_READONLY;
2763       return TRUE;
2764     }
2765
2766   if (hdr->p_type == PT_HP_CORE_PROC)
2767     {
2768       int sig;
2769
2770       if (bfd_seek (abfd, hdr->p_offset, SEEK_SET) != 0)
2771         return FALSE;
2772       if (bfd_bread (&sig, 4, abfd) != 4)
2773         return FALSE;
2774
2775       elf_tdata (abfd)->core->signal = sig;
2776
2777       if (!_bfd_elf_make_section_from_phdr (abfd, hdr, sec_index, typename))
2778         return FALSE;
2779
2780       /* GDB uses the ".reg" section to read register contents.  */
2781       return _bfd_elfcore_make_pseudosection (abfd, ".reg", hdr->p_filesz,
2782                                               hdr->p_offset);
2783     }
2784
2785   if (hdr->p_type == PT_HP_CORE_LOADABLE
2786       || hdr->p_type == PT_HP_CORE_STACK
2787       || hdr->p_type == PT_HP_CORE_MMF)
2788     hdr->p_type = PT_LOAD;
2789
2790   return _bfd_elf_make_section_from_phdr (abfd, hdr, sec_index, typename);
2791 }
2792
2793 /* Hook called by the linker routine which adds symbols from an object
2794    file.  HP's libraries define symbols with HP specific section
2795    indices, which we have to handle.  */
2796
2797 static bfd_boolean
2798 elf_hppa_add_symbol_hook (bfd *abfd,
2799                           struct bfd_link_info *info ATTRIBUTE_UNUSED,
2800                           Elf_Internal_Sym *sym,
2801                           const char **namep ATTRIBUTE_UNUSED,
2802                           flagword *flagsp ATTRIBUTE_UNUSED,
2803                           asection **secp,
2804                           bfd_vma *valp)
2805 {
2806   unsigned int sec_index = sym->st_shndx;
2807
2808   switch (sec_index)
2809     {
2810     case SHN_PARISC_ANSI_COMMON:
2811       *secp = bfd_make_section_old_way (abfd, ".PARISC.ansi.common");
2812       (*secp)->flags |= SEC_IS_COMMON;
2813       *valp = sym->st_size;
2814       break;
2815
2816     case SHN_PARISC_HUGE_COMMON:
2817       *secp = bfd_make_section_old_way (abfd, ".PARISC.huge.common");
2818       (*secp)->flags |= SEC_IS_COMMON;
2819       *valp = sym->st_size;
2820       break;
2821     }
2822
2823   return TRUE;
2824 }
2825
2826 static bfd_boolean
2827 elf_hppa_unmark_useless_dynamic_symbols (struct elf_link_hash_entry *h,
2828                                          void *data)
2829 {
2830   struct bfd_link_info *info = data;
2831
2832   /* If we are not creating a shared library, and this symbol is
2833      referenced by a shared library but is not defined anywhere, then
2834      the generic code will warn that it is undefined.
2835
2836      This behavior is undesirable on HPs since the standard shared
2837      libraries contain references to undefined symbols.
2838
2839      So we twiddle the flags associated with such symbols so that they
2840      will not trigger the warning.  ?!? FIXME.  This is horribly fragile.
2841
2842      Ultimately we should have better controls over the generic ELF BFD
2843      linker code.  */
2844   if (! bfd_link_relocatable (info)
2845       && info->unresolved_syms_in_shared_libs != RM_IGNORE
2846       && h->root.type == bfd_link_hash_undefined
2847       && h->ref_dynamic
2848       && !h->ref_regular)
2849     {
2850       h->ref_dynamic = 0;
2851       h->pointer_equality_needed = 1;
2852     }
2853
2854   return TRUE;
2855 }
2856
2857 static bfd_boolean
2858 elf_hppa_remark_useless_dynamic_symbols (struct elf_link_hash_entry *h,
2859                                          void *data)
2860 {
2861   struct bfd_link_info *info = data;
2862
2863   /* If we are not creating a shared library, and this symbol is
2864      referenced by a shared library but is not defined anywhere, then
2865      the generic code will warn that it is undefined.
2866
2867      This behavior is undesirable on HPs since the standard shared
2868      libraries contain references to undefined symbols.
2869
2870      So we twiddle the flags associated with such symbols so that they
2871      will not trigger the warning.  ?!? FIXME.  This is horribly fragile.
2872
2873      Ultimately we should have better controls over the generic ELF BFD
2874      linker code.  */
2875   if (! bfd_link_relocatable (info)
2876       && info->unresolved_syms_in_shared_libs != RM_IGNORE
2877       && h->root.type == bfd_link_hash_undefined
2878       && !h->ref_dynamic
2879       && !h->ref_regular
2880       && h->pointer_equality_needed)
2881     {
2882       h->ref_dynamic = 1;
2883       h->pointer_equality_needed = 0;
2884     }
2885
2886   return TRUE;
2887 }
2888
2889 static bfd_boolean
2890 elf_hppa_is_dynamic_loader_symbol (const char *name)
2891 {
2892   return (! strcmp (name, "__CPU_REVISION")
2893           || ! strcmp (name, "__CPU_KEYBITS_1")
2894           || ! strcmp (name, "__SYSTEM_ID_D")
2895           || ! strcmp (name, "__FPU_MODEL")
2896           || ! strcmp (name, "__FPU_REVISION")
2897           || ! strcmp (name, "__ARGC")
2898           || ! strcmp (name, "__ARGV")
2899           || ! strcmp (name, "__ENVP")
2900           || ! strcmp (name, "__TLS_SIZE_D")
2901           || ! strcmp (name, "__LOAD_INFO")
2902           || ! strcmp (name, "__systab"));
2903 }
2904
2905 /* Record the lowest address for the data and text segments.  */
2906 static void
2907 elf_hppa_record_segment_addrs (bfd *abfd,
2908                                asection *section,
2909                                void *data)
2910 {
2911   struct elf64_hppa_link_hash_table *hppa_info = data;
2912
2913   if ((section->flags & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2914     {
2915       bfd_vma value;
2916       Elf_Internal_Phdr *p;
2917
2918       p = _bfd_elf_find_segment_containing_section (abfd, section->output_section);
2919       BFD_ASSERT (p != NULL);
2920       value = p->p_vaddr;
2921
2922       if (section->flags & SEC_READONLY)
2923         {
2924           if (value < hppa_info->text_segment_base)
2925             hppa_info->text_segment_base = value;
2926         }
2927       else
2928         {
2929           if (value < hppa_info->data_segment_base)
2930             hppa_info->data_segment_base = value;
2931         }
2932     }
2933 }
2934
2935 /* Called after we have seen all the input files/sections, but before
2936    final symbol resolution and section placement has been determined.
2937
2938    We use this hook to (possibly) provide a value for __gp, then we
2939    fall back to the generic ELF final link routine.  */
2940
2941 static bfd_boolean
2942 elf_hppa_final_link (bfd *abfd, struct bfd_link_info *info)
2943 {
2944   struct stat buf;
2945   struct elf64_hppa_link_hash_table *hppa_info = hppa_link_hash_table (info);
2946
2947   if (hppa_info == NULL)
2948     return FALSE;
2949
2950   if (! bfd_link_relocatable (info))
2951     {
2952       struct elf_link_hash_entry *gp;
2953       bfd_vma gp_val;
2954
2955       /* The linker script defines a value for __gp iff it was referenced
2956          by one of the objects being linked.  First try to find the symbol
2957          in the hash table.  If that fails, just compute the value __gp
2958          should have had.  */
2959       gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
2960                                  FALSE, FALSE);
2961
2962       if (gp)
2963         {
2964
2965           /* Adjust the value of __gp as we may want to slide it into the
2966              .plt section so that the stubs can access PLT entries without
2967              using an addil sequence.  */
2968           gp->root.u.def.value += hppa_info->gp_offset;
2969
2970           gp_val = (gp->root.u.def.section->output_section->vma
2971                     + gp->root.u.def.section->output_offset
2972                     + gp->root.u.def.value);
2973         }
2974       else
2975         {
2976           asection *sec;
2977
2978           /* First look for a .plt section.  If found, then __gp is the
2979              address of the .plt + gp_offset.
2980
2981              If no .plt is found, then look for .dlt, .opd and .data (in
2982              that order) and set __gp to the base address of whichever
2983              section is found first.  */
2984
2985           sec = hppa_info->plt_sec;
2986           if (sec && ! (sec->flags & SEC_EXCLUDE))
2987             gp_val = (sec->output_offset
2988                       + sec->output_section->vma
2989                       + hppa_info->gp_offset);
2990           else
2991             {
2992               sec = hppa_info->dlt_sec;
2993               if (!sec || (sec->flags & SEC_EXCLUDE))
2994                 sec = hppa_info->opd_sec;
2995               if (!sec || (sec->flags & SEC_EXCLUDE))
2996                 sec = bfd_get_section_by_name (abfd, ".data");
2997               if (!sec || (sec->flags & SEC_EXCLUDE))
2998                 gp_val = 0;
2999               else
3000                 gp_val = sec->output_offset + sec->output_section->vma;
3001             }
3002         }
3003
3004       /* Install whatever value we found/computed for __gp.  */
3005       _bfd_set_gp_value (abfd, gp_val);
3006     }
3007
3008   /* We need to know the base of the text and data segments so that we
3009      can perform SEGREL relocations.  We will record the base addresses
3010      when we encounter the first SEGREL relocation.  */
3011   hppa_info->text_segment_base = (bfd_vma)-1;
3012   hppa_info->data_segment_base = (bfd_vma)-1;
3013
3014   /* HP's shared libraries have references to symbols that are not
3015      defined anywhere.  The generic ELF BFD linker code will complain
3016      about such symbols.
3017
3018      So we detect the losing case and arrange for the flags on the symbol
3019      to indicate that it was never referenced.  This keeps the generic
3020      ELF BFD link code happy and appears to not create any secondary
3021      problems.  Ultimately we need a way to control the behavior of the
3022      generic ELF BFD link code better.  */
3023   elf_link_hash_traverse (elf_hash_table (info),
3024                           elf_hppa_unmark_useless_dynamic_symbols,
3025                           info);
3026
3027   /* Invoke the regular ELF backend linker to do all the work.  */
3028   if (!bfd_elf_final_link (abfd, info))
3029     return FALSE;
3030
3031   elf_link_hash_traverse (elf_hash_table (info),
3032                           elf_hppa_remark_useless_dynamic_symbols,
3033                           info);
3034
3035   /* If we're producing a final executable, sort the contents of the
3036      unwind section. */
3037   if (bfd_link_relocatable (info))
3038     return TRUE;
3039
3040   /* Do not attempt to sort non-regular files.  This is here
3041      especially for configure scripts and kernel builds which run
3042      tests with "ld [...] -o /dev/null".  */
3043   if (stat (abfd->filename, &buf) != 0
3044       || !S_ISREG(buf.st_mode))
3045     return TRUE;
3046
3047   return elf_hppa_sort_unwind (abfd);
3048 }
3049
3050 /* Relocate the given INSN.  VALUE should be the actual value we want
3051    to insert into the instruction, ie by this point we should not be
3052    concerned with computing an offset relative to the DLT, PC, etc.
3053    Instead this routine is meant to handle the bit manipulations needed
3054    to insert the relocation into the given instruction.  */
3055
3056 static int
3057 elf_hppa_relocate_insn (int insn, int sym_value, unsigned int r_type)
3058 {
3059   switch (r_type)
3060     {
3061     /* This is any 22 bit branch.  In PA2.0 syntax it corresponds to
3062        the "B" instruction.  */
3063     case R_PARISC_PCREL22F:
3064     case R_PARISC_PCREL22C:
3065       return (insn & ~0x3ff1ffd) | re_assemble_22 (sym_value);
3066
3067       /* This is any 12 bit branch.  */
3068     case R_PARISC_PCREL12F:
3069       return (insn & ~0x1ffd) | re_assemble_12 (sym_value);
3070
3071     /* This is any 17 bit branch.  In PA2.0 syntax it also corresponds
3072        to the "B" instruction as well as BE.  */
3073     case R_PARISC_PCREL17F:
3074     case R_PARISC_DIR17F:
3075     case R_PARISC_DIR17R:
3076     case R_PARISC_PCREL17C:
3077     case R_PARISC_PCREL17R:
3078       return (insn & ~0x1f1ffd) | re_assemble_17 (sym_value);
3079
3080     /* ADDIL or LDIL instructions.  */
3081     case R_PARISC_DLTREL21L:
3082     case R_PARISC_DLTIND21L:
3083     case R_PARISC_LTOFF_FPTR21L:
3084     case R_PARISC_PCREL21L:
3085     case R_PARISC_LTOFF_TP21L:
3086     case R_PARISC_DPREL21L:
3087     case R_PARISC_PLTOFF21L:
3088     case R_PARISC_DIR21L:
3089       return (insn & ~0x1fffff) | re_assemble_21 (sym_value);
3090
3091     /* LDO and integer loads/stores with 14 bit displacements.  */
3092     case R_PARISC_DLTREL14R:
3093     case R_PARISC_DLTREL14F:
3094     case R_PARISC_DLTIND14R:
3095     case R_PARISC_DLTIND14F:
3096     case R_PARISC_LTOFF_FPTR14R:
3097     case R_PARISC_PCREL14R:
3098     case R_PARISC_PCREL14F:
3099     case R_PARISC_LTOFF_TP14R:
3100     case R_PARISC_LTOFF_TP14F:
3101     case R_PARISC_DPREL14R:
3102     case R_PARISC_DPREL14F:
3103     case R_PARISC_PLTOFF14R:
3104     case R_PARISC_PLTOFF14F:
3105     case R_PARISC_DIR14R:
3106     case R_PARISC_DIR14F:
3107       return (insn & ~0x3fff) | low_sign_unext (sym_value, 14);
3108
3109     /* PA2.0W LDO and integer loads/stores with 16 bit displacements.  */
3110     case R_PARISC_LTOFF_FPTR16F:
3111     case R_PARISC_PCREL16F:
3112     case R_PARISC_LTOFF_TP16F:
3113     case R_PARISC_GPREL16F:
3114     case R_PARISC_PLTOFF16F:
3115     case R_PARISC_DIR16F:
3116     case R_PARISC_LTOFF16F:
3117       return (insn & ~0xffff) | re_assemble_16 (sym_value);
3118
3119     /* Doubleword loads and stores with a 14 bit displacement.  */
3120     case R_PARISC_DLTREL14DR:
3121     case R_PARISC_DLTIND14DR:
3122     case R_PARISC_LTOFF_FPTR14DR:
3123     case R_PARISC_LTOFF_FPTR16DF:
3124     case R_PARISC_PCREL14DR:
3125     case R_PARISC_PCREL16DF:
3126     case R_PARISC_LTOFF_TP14DR:
3127     case R_PARISC_LTOFF_TP16DF:
3128     case R_PARISC_DPREL14DR:
3129     case R_PARISC_GPREL16DF:
3130     case R_PARISC_PLTOFF14DR:
3131     case R_PARISC_PLTOFF16DF:
3132     case R_PARISC_DIR14DR:
3133     case R_PARISC_DIR16DF:
3134     case R_PARISC_LTOFF16DF:
3135       return (insn & ~0x3ff1) | (((sym_value & 0x2000) >> 13)
3136                                  | ((sym_value & 0x1ff8) << 1));
3137
3138     /* Floating point single word load/store instructions.  */
3139     case R_PARISC_DLTREL14WR:
3140     case R_PARISC_DLTIND14WR:
3141     case R_PARISC_LTOFF_FPTR14WR:
3142     case R_PARISC_LTOFF_FPTR16WF:
3143     case R_PARISC_PCREL14WR:
3144     case R_PARISC_PCREL16WF:
3145     case R_PARISC_LTOFF_TP14WR:
3146     case R_PARISC_LTOFF_TP16WF:
3147     case R_PARISC_DPREL14WR:
3148     case R_PARISC_GPREL16WF:
3149     case R_PARISC_PLTOFF14WR:
3150     case R_PARISC_PLTOFF16WF:
3151     case R_PARISC_DIR16WF:
3152     case R_PARISC_DIR14WR:
3153     case R_PARISC_LTOFF16WF:
3154       return (insn & ~0x3ff9) | (((sym_value & 0x2000) >> 13)
3155                                  | ((sym_value & 0x1ffc) << 1));
3156
3157     default:
3158       return insn;
3159     }
3160 }
3161
3162 /* Compute the value for a relocation (REL) during a final link stage,
3163    then insert the value into the proper location in CONTENTS.
3164
3165    VALUE is a tentative value for the relocation and may be overridden
3166    and modified here based on the specific relocation to be performed.
3167
3168    For example we do conversions for PC-relative branches in this routine
3169    or redirection of calls to external routines to stubs.
3170
3171    The work of actually applying the relocation is left to a helper
3172    routine in an attempt to reduce the complexity and size of this
3173    function.  */
3174
3175 static bfd_reloc_status_type
3176 elf_hppa_final_link_relocate (Elf_Internal_Rela *rel,
3177                               bfd *input_bfd,
3178                               bfd *output_bfd,
3179                               asection *input_section,
3180                               bfd_byte *contents,
3181                               bfd_vma value,
3182                               struct bfd_link_info *info,
3183                               asection *sym_sec,
3184                               struct elf_link_hash_entry *eh)
3185 {
3186   struct elf64_hppa_link_hash_table *hppa_info = hppa_link_hash_table (info);
3187   struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
3188   bfd_vma *local_offsets;
3189   Elf_Internal_Shdr *symtab_hdr;
3190   int insn;
3191   bfd_vma max_branch_offset = 0;
3192   bfd_vma offset = rel->r_offset;
3193   bfd_signed_vma addend = rel->r_addend;
3194   reloc_howto_type *howto = elf_hppa_howto_table + ELF_R_TYPE (rel->r_info);
3195   unsigned int r_symndx = ELF_R_SYM (rel->r_info);
3196   unsigned int r_type = howto->type;
3197   bfd_byte *hit_data = contents + offset;
3198
3199   if (hppa_info == NULL)
3200     return bfd_reloc_notsupported;
3201
3202   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3203   local_offsets = elf_local_got_offsets (input_bfd);
3204   insn = bfd_get_32 (input_bfd, hit_data);
3205
3206   switch (r_type)
3207     {
3208     case R_PARISC_NONE:
3209       break;
3210
3211     /* Basic function call support.
3212
3213        Note for a call to a function defined in another dynamic library
3214        we want to redirect the call to a stub.  */
3215
3216     /* PC relative relocs without an implicit offset.  */
3217     case R_PARISC_PCREL21L:
3218     case R_PARISC_PCREL14R:
3219     case R_PARISC_PCREL14F:
3220     case R_PARISC_PCREL14WR:
3221     case R_PARISC_PCREL14DR:
3222     case R_PARISC_PCREL16F:
3223     case R_PARISC_PCREL16WF:
3224     case R_PARISC_PCREL16DF:
3225       {
3226         /* If this is a call to a function defined in another dynamic
3227            library, then redirect the call to the local stub for this
3228            function.  */
3229         if (sym_sec == NULL || sym_sec->output_section == NULL)
3230           value = (hh->stub_offset + hppa_info->stub_sec->output_offset
3231                    + hppa_info->stub_sec->output_section->vma);
3232
3233         /* Turn VALUE into a proper PC relative address.  */
3234         value -= (offset + input_section->output_offset
3235                   + input_section->output_section->vma);
3236
3237         /* Adjust for any field selectors.  */
3238         if (r_type == R_PARISC_PCREL21L)
3239           value = hppa_field_adjust (value, -8 + addend, e_lsel);
3240         else if (r_type == R_PARISC_PCREL14F
3241                  || r_type == R_PARISC_PCREL16F
3242                  || r_type == R_PARISC_PCREL16WF
3243                  || r_type == R_PARISC_PCREL16DF)
3244           value = hppa_field_adjust (value, -8 + addend, e_fsel);
3245         else
3246           value = hppa_field_adjust (value, -8 + addend, e_rsel);
3247
3248         /* Apply the relocation to the given instruction.  */
3249         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
3250         break;
3251       }
3252
3253     case R_PARISC_PCREL12F:
3254     case R_PARISC_PCREL22F:
3255     case R_PARISC_PCREL17F:
3256     case R_PARISC_PCREL22C:
3257     case R_PARISC_PCREL17C:
3258     case R_PARISC_PCREL17R:
3259       {
3260         /* If this is a call to a function defined in another dynamic
3261            library, then redirect the call to the local stub for this
3262            function.  */
3263         if (sym_sec == NULL || sym_sec->output_section == NULL)
3264           value = (hh->stub_offset + hppa_info->stub_sec->output_offset
3265                    + hppa_info->stub_sec->output_section->vma);
3266
3267         /* Turn VALUE into a proper PC relative address.  */
3268         value -= (offset + input_section->output_offset
3269                   + input_section->output_section->vma);
3270         addend -= 8;
3271
3272         if (r_type == (unsigned int) R_PARISC_PCREL22F)
3273           max_branch_offset = (1 << (22-1)) << 2;
3274         else if (r_type == (unsigned int) R_PARISC_PCREL17F)
3275           max_branch_offset = (1 << (17-1)) << 2;
3276         else if (r_type == (unsigned int) R_PARISC_PCREL12F)
3277           max_branch_offset = (1 << (12-1)) << 2;
3278
3279         /* Make sure we can reach the branch target.  */
3280         if (max_branch_offset != 0
3281             && value + addend + max_branch_offset >= 2*max_branch_offset)
3282           {
3283             _bfd_error_handler
3284               /* xgettext:c-format */
3285               (_("%pB(%pA+%#" PRIx64 "): cannot reach %s"),
3286               input_bfd,
3287               input_section,
3288               (uint64_t) offset,
3289               eh ? eh->root.root.string : "unknown");
3290             bfd_set_error (bfd_error_bad_value);
3291             return bfd_reloc_overflow;
3292           }
3293
3294         /* Adjust for any field selectors.  */
3295         if (r_type == R_PARISC_PCREL17R)
3296           value = hppa_field_adjust (value, addend, e_rsel);
3297         else
3298           value = hppa_field_adjust (value, addend, e_fsel);
3299
3300         /* All branches are implicitly shifted by 2 places.  */
3301         value >>= 2;
3302
3303         /* Apply the relocation to the given instruction.  */
3304         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
3305         break;
3306       }
3307
3308     /* Indirect references to data through the DLT.  */
3309     case R_PARISC_DLTIND14R:
3310     case R_PARISC_DLTIND14F:
3311     case R_PARISC_DLTIND14DR:
3312     case R_PARISC_DLTIND14WR:
3313     case R_PARISC_DLTIND21L:
3314     case R_PARISC_LTOFF_FPTR14R:
3315     case R_PARISC_LTOFF_FPTR14DR:
3316     case R_PARISC_LTOFF_FPTR14WR:
3317     case R_PARISC_LTOFF_FPTR21L:
3318     case R_PARISC_LTOFF_FPTR16F:
3319     case R_PARISC_LTOFF_FPTR16WF:
3320     case R_PARISC_LTOFF_FPTR16DF:
3321     case R_PARISC_LTOFF_TP21L:
3322     case R_PARISC_LTOFF_TP14R:
3323     case R_PARISC_LTOFF_TP14F:
3324     case R_PARISC_LTOFF_TP14WR:
3325     case R_PARISC_LTOFF_TP14DR:
3326     case R_PARISC_LTOFF_TP16F:
3327     case R_PARISC_LTOFF_TP16WF:
3328     case R_PARISC_LTOFF_TP16DF:
3329     case R_PARISC_LTOFF16F:
3330     case R_PARISC_LTOFF16WF:
3331     case R_PARISC_LTOFF16DF:
3332       {
3333         bfd_vma off;
3334
3335         /* If this relocation was against a local symbol, then we still
3336            have not set up the DLT entry (it's not convenient to do so
3337            in the "finalize_dlt" routine because it is difficult to get
3338            to the local symbol's value).
3339
3340            So, if this is a local symbol (h == NULL), then we need to
3341            fill in its DLT entry.
3342
3343            Similarly we may still need to set up an entry in .opd for
3344            a local function which had its address taken.  */
3345         if (hh == NULL)
3346           {
3347             bfd_vma *local_opd_offsets, *local_dlt_offsets;
3348
3349             if (local_offsets == NULL)
3350               abort ();
3351
3352             /* Now do .opd creation if needed.  */
3353             if (r_type == R_PARISC_LTOFF_FPTR14R
3354                 || r_type == R_PARISC_LTOFF_FPTR14DR
3355                 || r_type == R_PARISC_LTOFF_FPTR14WR
3356                 || r_type == R_PARISC_LTOFF_FPTR21L
3357                 || r_type == R_PARISC_LTOFF_FPTR16F
3358                 || r_type == R_PARISC_LTOFF_FPTR16WF
3359                 || r_type == R_PARISC_LTOFF_FPTR16DF)
3360               {
3361                 local_opd_offsets = local_offsets + 2 * symtab_hdr->sh_info;
3362                 off = local_opd_offsets[r_symndx];
3363
3364                 /* The last bit records whether we've already initialised
3365                    this local .opd entry.  */
3366                 if ((off & 1) != 0)
3367                   {
3368                     BFD_ASSERT (off != (bfd_vma) -1);
3369                     off &= ~1;
3370                   }
3371                 else
3372                   {
3373                     local_opd_offsets[r_symndx] |= 1;
3374
3375                     /* The first two words of an .opd entry are zero.  */
3376                     memset (hppa_info->opd_sec->contents + off, 0, 16);
3377
3378                     /* The next word is the address of the function.  */
3379                     bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
3380                                 (hppa_info->opd_sec->contents + off + 16));
3381
3382                     /* The last word is our local __gp value.  */
3383                     value = _bfd_get_gp_value (info->output_bfd);
3384                     bfd_put_64 (hppa_info->opd_sec->owner, value,
3385                                 (hppa_info->opd_sec->contents + off + 24));
3386                   }
3387
3388                 /* The DLT value is the address of the .opd entry.  */
3389                 value = (off
3390                          + hppa_info->opd_sec->output_offset
3391                          + hppa_info->opd_sec->output_section->vma);
3392                 addend = 0;
3393               }
3394
3395             local_dlt_offsets = local_offsets;
3396             off = local_dlt_offsets[r_symndx];
3397
3398             if ((off & 1) != 0)
3399               {
3400                 BFD_ASSERT (off != (bfd_vma) -1);
3401                 off &= ~1;
3402               }
3403             else
3404               {
3405                 local_dlt_offsets[r_symndx] |= 1;
3406                 bfd_put_64 (hppa_info->dlt_sec->owner,
3407                             value + addend,
3408                             hppa_info->dlt_sec->contents + off);
3409               }
3410           }
3411         else
3412           off = hh->dlt_offset;
3413
3414         /* We want the value of the DLT offset for this symbol, not
3415            the symbol's actual address.  Note that __gp may not point
3416            to the start of the DLT, so we have to compute the absolute
3417            address, then subtract out the value of __gp.  */
3418         value = (off
3419                  + hppa_info->dlt_sec->output_offset
3420                  + hppa_info->dlt_sec->output_section->vma);
3421         value -= _bfd_get_gp_value (output_bfd);
3422
3423         /* All DLTIND relocations are basically the same at this point,
3424            except that we need different field selectors for the 21bit
3425            version vs the 14bit versions.  */
3426         if (r_type == R_PARISC_DLTIND21L
3427             || r_type == R_PARISC_LTOFF_FPTR21L
3428             || r_type == R_PARISC_LTOFF_TP21L)
3429           value = hppa_field_adjust (value, 0, e_lsel);
3430         else if (r_type == R_PARISC_DLTIND14F
3431                  || r_type == R_PARISC_LTOFF_FPTR16F
3432                  || r_type == R_PARISC_LTOFF_FPTR16WF
3433                  || r_type == R_PARISC_LTOFF_FPTR16DF
3434                  || r_type == R_PARISC_LTOFF16F
3435                  || r_type == R_PARISC_LTOFF16DF
3436                  || r_type == R_PARISC_LTOFF16WF
3437                  || r_type == R_PARISC_LTOFF_TP16F
3438                  || r_type == R_PARISC_LTOFF_TP16WF
3439                  || r_type == R_PARISC_LTOFF_TP16DF)
3440           value = hppa_field_adjust (value, 0, e_fsel);
3441         else
3442           value = hppa_field_adjust (value, 0, e_rsel);
3443
3444         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
3445         break;
3446       }
3447
3448     case R_PARISC_DLTREL14R:
3449     case R_PARISC_DLTREL14F:
3450     case R_PARISC_DLTREL14DR:
3451     case R_PARISC_DLTREL14WR:
3452     case R_PARISC_DLTREL21L:
3453     case R_PARISC_DPREL21L:
3454     case R_PARISC_DPREL14WR:
3455     case R_PARISC_DPREL14DR:
3456     case R_PARISC_DPREL14R:
3457     case R_PARISC_DPREL14F:
3458     case R_PARISC_GPREL16F:
3459     case R_PARISC_GPREL16WF:
3460     case R_PARISC_GPREL16DF:
3461       {
3462         /* Subtract out the global pointer value to make value a DLT
3463            relative address.  */
3464         value -= _bfd_get_gp_value (output_bfd);
3465
3466         /* All DLTREL relocations are basically the same at this point,
3467            except that we need different field selectors for the 21bit
3468            version vs the 14bit versions.  */
3469         if (r_type == R_PARISC_DLTREL21L
3470             || r_type == R_PARISC_DPREL21L)
3471           value = hppa_field_adjust (value, addend, e_lrsel);
3472         else if (r_type == R_PARISC_DLTREL14F
3473                  || r_type == R_PARISC_DPREL14F
3474                  || r_type == R_PARISC_GPREL16F
3475                  || r_type == R_PARISC_GPREL16WF
3476                  || r_type == R_PARISC_GPREL16DF)
3477           value = hppa_field_adjust (value, addend, e_fsel);
3478         else
3479           value = hppa_field_adjust (value, addend, e_rrsel);
3480
3481         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
3482         break;
3483       }
3484
3485     case R_PARISC_DIR21L:
3486     case R_PARISC_DIR17R:
3487     case R_PARISC_DIR17F:
3488     case R_PARISC_DIR14R:
3489     case R_PARISC_DIR14F:
3490     case R_PARISC_DIR14WR:
3491     case R_PARISC_DIR14DR:
3492     case R_PARISC_DIR16F:
3493     case R_PARISC_DIR16WF:
3494     case R_PARISC_DIR16DF:
3495       {
3496         /* All DIR relocations are basically the same at this point,
3497            except that branch offsets need to be divided by four, and
3498            we need different field selectors.  Note that we don't
3499            redirect absolute calls to local stubs.  */
3500
3501         if (r_type == R_PARISC_DIR21L)
3502           value = hppa_field_adjust (value, addend, e_lrsel);
3503         else if (r_type == R_PARISC_DIR17F
3504                  || r_type == R_PARISC_DIR16F
3505                  || r_type == R_PARISC_DIR16WF
3506                  || r_type == R_PARISC_DIR16DF
3507                  || r_type == R_PARISC_DIR14F)
3508           value = hppa_field_adjust (value, addend, e_fsel);
3509         else
3510           value = hppa_field_adjust (value, addend, e_rrsel);
3511
3512         if (r_type == R_PARISC_DIR17R || r_type == R_PARISC_DIR17F)
3513           /* All branches are implicitly shifted by 2 places.  */
3514           value >>= 2;
3515
3516         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
3517         break;
3518       }
3519
3520     case R_PARISC_PLTOFF21L:
3521     case R_PARISC_PLTOFF14R:
3522     case R_PARISC_PLTOFF14F:
3523     case R_PARISC_PLTOFF14WR:
3524     case R_PARISC_PLTOFF14DR:
3525     case R_PARISC_PLTOFF16F:
3526     case R_PARISC_PLTOFF16WF:
3527     case R_PARISC_PLTOFF16DF:
3528       {
3529         /* We want the value of the PLT offset for this symbol, not
3530            the symbol's actual address.  Note that __gp may not point
3531            to the start of the DLT, so we have to compute the absolute
3532            address, then subtract out the value of __gp.  */
3533         value = (hh->plt_offset
3534                  + hppa_info->plt_sec->output_offset
3535                  + hppa_info->plt_sec->output_section->vma);
3536         value -= _bfd_get_gp_value (output_bfd);
3537
3538         /* All PLTOFF relocations are basically the same at this point,
3539            except that we need different field selectors for the 21bit
3540            version vs the 14bit versions.  */
3541         if (r_type == R_PARISC_PLTOFF21L)
3542           value = hppa_field_adjust (value, addend, e_lrsel);
3543         else if (r_type == R_PARISC_PLTOFF14F
3544                  || r_type == R_PARISC_PLTOFF16F
3545                  || r_type == R_PARISC_PLTOFF16WF
3546                  || r_type == R_PARISC_PLTOFF16DF)
3547           value = hppa_field_adjust (value, addend, e_fsel);
3548         else
3549           value = hppa_field_adjust (value, addend, e_rrsel);
3550
3551         insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
3552         break;
3553       }
3554
3555     case R_PARISC_LTOFF_FPTR32:
3556       {
3557         /* FIXME: There used to be code here to create the FPTR itself if
3558            the relocation was against a local symbol.  But the code could
3559            never have worked.  If the assert below is ever triggered then
3560            the code will need to be reinstated and fixed so that it does
3561            what is needed.  */
3562         BFD_ASSERT (hh != NULL);
3563
3564         /* We want the value of the DLT offset for this symbol, not
3565            the symbol's actual address.  Note that __gp may not point
3566            to the start of the DLT, so we have to compute the absolute
3567            address, then subtract out the value of __gp.  */
3568         value = (hh->dlt_offset
3569                  + hppa_info->dlt_sec->output_offset
3570                  + hppa_info->dlt_sec->output_section->vma);
3571         value -= _bfd_get_gp_value (output_bfd);
3572         bfd_put_32 (input_bfd, value, hit_data);
3573         return bfd_reloc_ok;
3574       }
3575
3576     case R_PARISC_LTOFF_FPTR64:
3577     case R_PARISC_LTOFF_TP64:
3578       {
3579         /* We may still need to create the FPTR itself if it was for
3580            a local symbol.  */
3581         if (eh == NULL && r_type == R_PARISC_LTOFF_FPTR64)
3582           {
3583             /* The first two words of an .opd entry are zero.  */
3584             memset (hppa_info->opd_sec->contents + hh->opd_offset, 0, 16);
3585
3586             /* The next word is the address of the function.  */
3587             bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
3588                         (hppa_info->opd_sec->contents
3589                          + hh->opd_offset + 16));
3590
3591             /* The last word is our local __gp value.  */
3592             value = _bfd_get_gp_value (info->output_bfd);
3593             bfd_put_64 (hppa_info->opd_sec->owner, value,
3594                         hppa_info->opd_sec->contents + hh->opd_offset + 24);
3595
3596             /* The DLT value is the address of the .opd entry.  */
3597             value = (hh->opd_offset
3598                      + hppa_info->opd_sec->output_offset
3599                      + hppa_info->opd_sec->output_section->vma);
3600
3601             bfd_put_64 (hppa_info->dlt_sec->owner,
3602                         value,
3603                         hppa_info->dlt_sec->contents + hh->dlt_offset);
3604           }
3605
3606         /* We want the value of the DLT offset for this symbol, not
3607            the symbol's actual address.  Note that __gp may not point
3608            to the start of the DLT, so we have to compute the absolute
3609            address, then subtract out the value of __gp.  */
3610         value = (hh->dlt_offset
3611                  + hppa_info->dlt_sec->output_offset
3612                  + hppa_info->dlt_sec->output_section->vma);
3613         value -= _bfd_get_gp_value (output_bfd);
3614         bfd_put_64 (input_bfd, value, hit_data);
3615         return bfd_reloc_ok;
3616       }
3617
3618     case R_PARISC_DIR32:
3619       bfd_put_32 (input_bfd, value + addend, hit_data);
3620       return bfd_reloc_ok;
3621
3622     case R_PARISC_DIR64:
3623       bfd_put_64 (input_bfd, value + addend, hit_data);
3624       return bfd_reloc_ok;
3625
3626     case R_PARISC_GPREL64:
3627       /* Subtract out the global pointer value to make value a DLT
3628          relative address.  */
3629       value -= _bfd_get_gp_value (output_bfd);
3630
3631       bfd_put_64 (input_bfd, value + addend, hit_data);
3632       return bfd_reloc_ok;
3633
3634     case R_PARISC_LTOFF64:
3635         /* We want the value of the DLT offset for this symbol, not
3636            the symbol's actual address.  Note that __gp may not point
3637            to the start of the DLT, so we have to compute the absolute
3638            address, then subtract out the value of __gp.  */
3639       value = (hh->dlt_offset
3640                + hppa_info->dlt_sec->output_offset
3641                + hppa_info->dlt_sec->output_section->vma);
3642       value -= _bfd_get_gp_value (output_bfd);
3643
3644       bfd_put_64 (input_bfd, value + addend, hit_data);
3645       return bfd_reloc_ok;
3646
3647     case R_PARISC_PCREL32:
3648       {
3649         /* If this is a call to a function defined in another dynamic
3650            library, then redirect the call to the local stub for this
3651            function.  */
3652         if (sym_sec == NULL || sym_sec->output_section == NULL)
3653           value = (hh->stub_offset + hppa_info->stub_sec->output_offset
3654                    + hppa_info->stub_sec->output_section->vma);
3655
3656         /* Turn VALUE into a proper PC relative address.  */
3657         value -= (offset + input_section->output_offset
3658                   + input_section->output_section->vma);
3659
3660         value += addend;
3661         value -= 8;
3662         bfd_put_32 (input_bfd, value, hit_data);
3663         return bfd_reloc_ok;
3664       }
3665
3666     case R_PARISC_PCREL64:
3667       {
3668         /* If this is a call to a function defined in another dynamic
3669            library, then redirect the call to the local stub for this
3670            function.  */
3671         if (sym_sec == NULL || sym_sec->output_section == NULL)
3672           value = (hh->stub_offset + hppa_info->stub_sec->output_offset
3673                    + hppa_info->stub_sec->output_section->vma);
3674
3675         /* Turn VALUE into a proper PC relative address.  */
3676         value -= (offset + input_section->output_offset
3677                   + input_section->output_section->vma);
3678
3679         value += addend;
3680         value -= 8;
3681         bfd_put_64 (input_bfd, value, hit_data);
3682         return bfd_reloc_ok;
3683       }
3684
3685     case R_PARISC_FPTR64:
3686       {
3687         bfd_vma off;
3688
3689         /* We may still need to create the FPTR itself if it was for
3690            a local symbol.  */
3691         if (hh == NULL)
3692           {
3693             bfd_vma *local_opd_offsets;
3694
3695             if (local_offsets == NULL)
3696               abort ();
3697
3698             local_opd_offsets = local_offsets + 2 * symtab_hdr->sh_info;
3699             off = local_opd_offsets[r_symndx];
3700
3701             /* The last bit records whether we've already initialised
3702                this local .opd entry.  */
3703             if ((off & 1) != 0)
3704               {
3705                 BFD_ASSERT (off != (bfd_vma) -1);
3706                 off &= ~1;
3707               }
3708             else
3709               {
3710                 /* The first two words of an .opd entry are zero.  */
3711                 memset (hppa_info->opd_sec->contents + off, 0, 16);
3712
3713                 /* The next word is the address of the function.  */
3714                 bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
3715                             (hppa_info->opd_sec->contents + off + 16));
3716
3717                 /* The last word is our local __gp value.  */
3718                 value = _bfd_get_gp_value (info->output_bfd);
3719                 bfd_put_64 (hppa_info->opd_sec->owner, value,
3720                             hppa_info->opd_sec->contents + off + 24);
3721               }
3722           }
3723         else
3724           off = hh->opd_offset;
3725
3726         if (hh == NULL || hh->want_opd)
3727           /* We want the value of the OPD offset for this symbol.  */
3728           value = (off
3729                    + hppa_info->opd_sec->output_offset
3730                    + hppa_info->opd_sec->output_section->vma);
3731         else
3732           /* We want the address of the symbol.  */
3733           value += addend;
3734
3735         bfd_put_64 (input_bfd, value, hit_data);
3736         return bfd_reloc_ok;
3737       }
3738
3739     case R_PARISC_SECREL32:
3740       if (sym_sec)
3741         value -= sym_sec->output_section->vma;
3742       bfd_put_32 (input_bfd, value + addend, hit_data);
3743       return bfd_reloc_ok;
3744
3745     case R_PARISC_SEGREL32:
3746     case R_PARISC_SEGREL64:
3747       {
3748         /* If this is the first SEGREL relocation, then initialize
3749            the segment base values.  */
3750         if (hppa_info->text_segment_base == (bfd_vma) -1)
3751           bfd_map_over_sections (output_bfd, elf_hppa_record_segment_addrs,
3752                                  hppa_info);
3753
3754         /* VALUE holds the absolute address.  We want to include the
3755            addend, then turn it into a segment relative address.
3756
3757            The segment is derived from SYM_SEC.  We assume that there are
3758            only two segments of note in the resulting executable/shlib.
3759            A readonly segment (.text) and a readwrite segment (.data).  */
3760         value += addend;
3761
3762         if (sym_sec->flags & SEC_CODE)
3763           value -= hppa_info->text_segment_base;
3764         else
3765           value -= hppa_info->data_segment_base;
3766
3767         if (r_type == R_PARISC_SEGREL32)
3768           bfd_put_32 (input_bfd, value, hit_data);
3769         else
3770           bfd_put_64 (input_bfd, value, hit_data);
3771         return bfd_reloc_ok;
3772       }
3773
3774     /* Something we don't know how to handle.  */
3775     default:
3776       return bfd_reloc_notsupported;
3777     }
3778
3779   /* Update the instruction word.  */
3780   bfd_put_32 (input_bfd, (bfd_vma) insn, hit_data);
3781   return bfd_reloc_ok;
3782 }
3783
3784 /* Relocate an HPPA ELF section.  */
3785
3786 static bfd_boolean
3787 elf64_hppa_relocate_section (bfd *output_bfd,
3788                            struct bfd_link_info *info,
3789                            bfd *input_bfd,
3790                            asection *input_section,
3791                            bfd_byte *contents,
3792                            Elf_Internal_Rela *relocs,
3793                            Elf_Internal_Sym *local_syms,
3794                            asection **local_sections)
3795 {
3796   Elf_Internal_Shdr *symtab_hdr;
3797   Elf_Internal_Rela *rel;
3798   Elf_Internal_Rela *relend;
3799   struct elf64_hppa_link_hash_table *hppa_info;
3800
3801   hppa_info = hppa_link_hash_table (info);
3802   if (hppa_info == NULL)
3803     return FALSE;
3804
3805   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3806
3807   rel = relocs;
3808   relend = relocs + input_section->reloc_count;
3809   for (; rel < relend; rel++)
3810     {
3811       int r_type;
3812       reloc_howto_type *howto = elf_hppa_howto_table + ELF_R_TYPE (rel->r_info);
3813       unsigned long r_symndx;
3814       struct elf_link_hash_entry *eh;
3815       Elf_Internal_Sym *sym;
3816       asection *sym_sec;
3817       bfd_vma relocation;
3818       bfd_reloc_status_type r;
3819
3820       r_type = ELF_R_TYPE (rel->r_info);
3821       if (r_type < 0 || r_type >= (int) R_PARISC_UNIMPLEMENTED)
3822         {
3823           bfd_set_error (bfd_error_bad_value);
3824           return FALSE;
3825         }
3826       if (r_type == (unsigned int) R_PARISC_GNU_VTENTRY
3827           || r_type == (unsigned int) R_PARISC_GNU_VTINHERIT)
3828         continue;
3829
3830       /* This is a final link.  */
3831       r_symndx = ELF_R_SYM (rel->r_info);
3832       eh = NULL;
3833       sym = NULL;
3834       sym_sec = NULL;
3835       if (r_symndx < symtab_hdr->sh_info)
3836         {
3837           /* This is a local symbol, hh defaults to NULL.  */
3838           sym = local_syms + r_symndx;
3839           sym_sec = local_sections[r_symndx];
3840           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sym_sec, rel);
3841         }
3842       else
3843         {
3844           /* This is not a local symbol.  */
3845           struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
3846
3847           /* It seems this can happen with erroneous or unsupported
3848              input (mixing a.out and elf in an archive, for example.)  */
3849           if (sym_hashes == NULL)
3850             return FALSE;
3851
3852           eh = sym_hashes[r_symndx - symtab_hdr->sh_info];
3853
3854           if (info->wrap_hash != NULL
3855               && (input_section->flags & SEC_DEBUGGING) != 0)
3856             eh = ((struct elf_link_hash_entry *)
3857                   unwrap_hash_lookup (info, input_bfd, &eh->root));
3858
3859           while (eh->root.type == bfd_link_hash_indirect
3860                  || eh->root.type == bfd_link_hash_warning)
3861             eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
3862
3863           relocation = 0;
3864           if (eh->root.type == bfd_link_hash_defined
3865               || eh->root.type == bfd_link_hash_defweak)
3866             {
3867               sym_sec = eh->root.u.def.section;
3868               if (sym_sec != NULL
3869                   && sym_sec->output_section != NULL)
3870                 relocation = (eh->root.u.def.value
3871                               + sym_sec->output_section->vma
3872                               + sym_sec->output_offset);
3873             }
3874           else if (eh->root.type == bfd_link_hash_undefweak)
3875             ;
3876           else if (info->unresolved_syms_in_objects == RM_IGNORE
3877                    && ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT)
3878             ;
3879           else if (!bfd_link_relocatable (info)
3880                    && elf_hppa_is_dynamic_loader_symbol (eh->root.root.string))
3881             continue;
3882           else if (!bfd_link_relocatable (info))
3883             {
3884               bfd_boolean err;
3885               err = (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
3886                      || ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT);
3887               (*info->callbacks->undefined_symbol) (info,
3888                                                     eh->root.root.string,
3889                                                     input_bfd,
3890                                                     input_section,
3891                                                     rel->r_offset, err);
3892             }
3893
3894           if (!bfd_link_relocatable (info)
3895               && relocation == 0
3896               && eh->root.type != bfd_link_hash_defined
3897               && eh->root.type != bfd_link_hash_defweak
3898               && eh->root.type != bfd_link_hash_undefweak)
3899             {
3900               if (info->unresolved_syms_in_objects == RM_IGNORE
3901                   && ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT
3902                   && eh->type == STT_PARISC_MILLI)
3903                 (*info->callbacks->undefined_symbol)
3904                   (info, eh_name (eh), input_bfd,
3905                    input_section, rel->r_offset, FALSE);
3906             }
3907         }
3908
3909       if (sym_sec != NULL && discarded_section (sym_sec))
3910         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3911                                          rel, 1, relend, howto, 0, contents);
3912
3913       if (bfd_link_relocatable (info))
3914         continue;
3915
3916       r = elf_hppa_final_link_relocate (rel, input_bfd, output_bfd,
3917                                         input_section, contents,
3918                                         relocation, info, sym_sec,
3919                                         eh);
3920
3921       if (r != bfd_reloc_ok)
3922         {
3923           switch (r)
3924             {
3925             default:
3926               abort ();
3927             case bfd_reloc_overflow:
3928               {
3929                 const char *sym_name;
3930
3931                 if (eh != NULL)
3932                   sym_name = NULL;
3933                 else
3934                   {
3935                     sym_name = bfd_elf_string_from_elf_section (input_bfd,
3936                                                                 symtab_hdr->sh_link,
3937                                                                 sym->st_name);
3938                     if (sym_name == NULL)
3939                       return FALSE;
3940                     if (*sym_name == '\0')
3941                       sym_name = bfd_section_name (input_bfd, sym_sec);
3942                   }
3943
3944                 (*info->callbacks->reloc_overflow)
3945                   (info, (eh ? &eh->root : NULL), sym_name, howto->name,
3946                    (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
3947               }
3948               break;
3949             }
3950         }
3951     }
3952   return TRUE;
3953 }
3954
3955 static const struct bfd_elf_special_section elf64_hppa_special_sections[] =
3956 {
3957   { STRING_COMMA_LEN (".tbss"),  0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_HP_TLS },
3958   { STRING_COMMA_LEN (".fini"),  0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3959   { STRING_COMMA_LEN (".init"),  0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3960   { STRING_COMMA_LEN (".plt"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },
3961   { STRING_COMMA_LEN (".dlt"),   0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },
3962   { STRING_COMMA_LEN (".sdata"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },
3963   { STRING_COMMA_LEN (".sbss"),  0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },
3964   { NULL,                    0,  0, 0,            0 }
3965 };
3966
3967 /* The hash bucket size is the standard one, namely 4.  */
3968
3969 const struct elf_size_info hppa64_elf_size_info =
3970 {
3971   sizeof (Elf64_External_Ehdr),
3972   sizeof (Elf64_External_Phdr),
3973   sizeof (Elf64_External_Shdr),
3974   sizeof (Elf64_External_Rel),
3975   sizeof (Elf64_External_Rela),
3976   sizeof (Elf64_External_Sym),
3977   sizeof (Elf64_External_Dyn),
3978   sizeof (Elf_External_Note),
3979   4,
3980   1,
3981   64, 3,
3982   ELFCLASS64, EV_CURRENT,
3983   bfd_elf64_write_out_phdrs,
3984   bfd_elf64_write_shdrs_and_ehdr,
3985   bfd_elf64_checksum_contents,
3986   bfd_elf64_write_relocs,
3987   bfd_elf64_swap_symbol_in,
3988   bfd_elf64_swap_symbol_out,
3989   bfd_elf64_slurp_reloc_table,
3990   bfd_elf64_slurp_symbol_table,
3991   bfd_elf64_swap_dyn_in,
3992   bfd_elf64_swap_dyn_out,
3993   bfd_elf64_swap_reloc_in,
3994   bfd_elf64_swap_reloc_out,
3995   bfd_elf64_swap_reloca_in,
3996   bfd_elf64_swap_reloca_out
3997 };
3998
3999 #define TARGET_BIG_SYM                  hppa_elf64_vec
4000 #define TARGET_BIG_NAME                 "elf64-hppa"
4001 #define ELF_ARCH                        bfd_arch_hppa
4002 #define ELF_TARGET_ID                   HPPA64_ELF_DATA
4003 #define ELF_MACHINE_CODE                EM_PARISC
4004 /* This is not strictly correct.  The maximum page size for PA2.0 is
4005    64M.  But everything still uses 4k.  */
4006 #define ELF_MAXPAGESIZE                 0x1000
4007 #define ELF_OSABI                       ELFOSABI_HPUX
4008
4009 #define bfd_elf64_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
4010 #define bfd_elf64_bfd_reloc_name_lookup elf_hppa_reloc_name_lookup
4011 #define bfd_elf64_bfd_is_local_label_name       elf_hppa_is_local_label_name
4012 #define elf_info_to_howto               elf_hppa_info_to_howto
4013 #define elf_info_to_howto_rel           elf_hppa_info_to_howto_rel
4014
4015 #define elf_backend_section_from_shdr   elf64_hppa_section_from_shdr
4016 #define elf_backend_object_p            elf64_hppa_object_p
4017 #define elf_backend_final_write_processing \
4018                                         elf_hppa_final_write_processing
4019 #define elf_backend_fake_sections       elf_hppa_fake_sections
4020 #define elf_backend_add_symbol_hook     elf_hppa_add_symbol_hook
4021
4022 #define elf_backend_relocate_section    elf_hppa_relocate_section
4023
4024 #define bfd_elf64_bfd_final_link        elf_hppa_final_link
4025
4026 #define elf_backend_create_dynamic_sections \
4027                                         elf64_hppa_create_dynamic_sections
4028 #define elf_backend_post_process_headers        elf64_hppa_post_process_headers
4029
4030 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
4031
4032 #define elf_backend_adjust_dynamic_symbol \
4033                                         elf64_hppa_adjust_dynamic_symbol
4034
4035 #define elf_backend_size_dynamic_sections \
4036                                         elf64_hppa_size_dynamic_sections
4037
4038 #define elf_backend_finish_dynamic_symbol \
4039                                         elf64_hppa_finish_dynamic_symbol
4040 #define elf_backend_finish_dynamic_sections \
4041                                         elf64_hppa_finish_dynamic_sections
4042 #define elf_backend_grok_prstatus       elf64_hppa_grok_prstatus
4043 #define elf_backend_grok_psinfo         elf64_hppa_grok_psinfo
4044
4045 /* Stuff for the BFD linker: */
4046 #define bfd_elf64_bfd_link_hash_table_create \
4047         elf64_hppa_hash_table_create
4048
4049 #define elf_backend_check_relocs \
4050         elf64_hppa_check_relocs
4051
4052 #define elf_backend_size_info \
4053   hppa64_elf_size_info
4054
4055 #define elf_backend_additional_program_headers \
4056         elf64_hppa_additional_program_headers
4057
4058 #define elf_backend_modify_segment_map \
4059         elf64_hppa_modify_segment_map
4060
4061 #define elf_backend_allow_non_load_phdr \
4062         elf64_hppa_allow_non_load_phdr
4063
4064 #define elf_backend_link_output_symbol_hook \
4065         elf64_hppa_link_output_symbol_hook
4066
4067 #define elf_backend_want_got_plt        0
4068 #define elf_backend_plt_readonly        0
4069 #define elf_backend_want_plt_sym        0
4070 #define elf_backend_got_header_size     0
4071 #define elf_backend_type_change_ok      TRUE
4072 #define elf_backend_get_symbol_type     elf64_hppa_elf_get_symbol_type
4073 #define elf_backend_reloc_type_class    elf64_hppa_reloc_type_class
4074 #define elf_backend_rela_normal         1
4075 #define elf_backend_special_sections    elf64_hppa_special_sections
4076 #define elf_backend_action_discarded    elf_hppa_action_discarded
4077 #define elf_backend_section_from_phdr   elf64_hppa_section_from_phdr
4078
4079 #define elf64_bed                       elf64_hppa_hpux_bed
4080
4081 #include "elf64-target.h"
4082
4083 #undef TARGET_BIG_SYM
4084 #define TARGET_BIG_SYM                  hppa_elf64_linux_vec
4085 #undef TARGET_BIG_NAME
4086 #define TARGET_BIG_NAME                 "elf64-hppa-linux"
4087 #undef ELF_OSABI
4088 #define ELF_OSABI                       ELFOSABI_GNU
4089 #undef elf64_bed
4090 #define elf64_bed                       elf64_hppa_linux_bed
4091 #undef elf_backend_special_sections
4092 #define elf_backend_special_sections    (elf64_hppa_special_sections + 1)
4093
4094 #include "elf64-target.h"