Automatic date update in version.in
[external/binutils.git] / bfd / elf32-hppa.c
1 /* BFD back-end for HP PA-RISC ELF files.
2    Copyright (C) 1990-2018 Free Software Foundation, Inc.
3
4    Original code by
5         Center for Software Science
6         Department of Computer Science
7         University of Utah
8    Largely rewritten by Alan Modra <alan@linuxcare.com.au>
9    Naming cleanup by Carlos O'Donell <carlos@systemhalted.org>
10    TLS support written by Randolph Chung <tausq@debian.org>
11
12    This file is part of BFD, the Binary File Descriptor library.
13
14    This program is free software; you can redistribute it and/or modify
15    it under the terms of the GNU General Public License as published by
16    the Free Software Foundation; either version 3 of the License, or
17    (at your option) any later version.
18
19    This program is distributed in the hope that it will be useful,
20    but WITHOUT ANY WARRANTY; without even the implied warranty of
21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22    GNU General Public License for more details.
23
24    You should have received a copy of the GNU General Public License
25    along with this program; if not, write to the Free Software
26    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
27    MA 02110-1301, USA.  */
28
29 #include "sysdep.h"
30 #include "bfd.h"
31 #include "libbfd.h"
32 #include "elf-bfd.h"
33 #include "elf/hppa.h"
34 #include "libhppa.h"
35 #include "elf32-hppa.h"
36 #define ARCH_SIZE               32
37 #include "elf32-hppa.h"
38 #include "elf-hppa.h"
39
40 /* In order to gain some understanding of code in this file without
41    knowing all the intricate details of the linker, note the
42    following:
43
44    Functions named elf32_hppa_* are called by external routines, other
45    functions are only called locally.  elf32_hppa_* functions appear
46    in this file more or less in the order in which they are called
47    from external routines.  eg. elf32_hppa_check_relocs is called
48    early in the link process, elf32_hppa_finish_dynamic_sections is
49    one of the last functions.  */
50
51 /* We use two hash tables to hold information for linking PA ELF objects.
52
53    The first is the elf32_hppa_link_hash_table which is derived
54    from the standard ELF linker hash table.  We use this as a place to
55    attach other hash tables and static information.
56
57    The second is the stub hash table which is derived from the
58    base BFD hash table.  The stub hash table holds the information
59    necessary to build the linker stubs during a link.
60
61    There are a number of different stubs generated by the linker.
62
63    Long branch stub:
64    :            ldil LR'X,%r1
65    :            be,n RR'X(%sr4,%r1)
66
67    PIC long branch stub:
68    :            b,l .+8,%r1
69    :            addil LR'X - ($PIC_pcrel$0 - 4),%r1
70    :            be,n RR'X - ($PIC_pcrel$0 - 8)(%sr4,%r1)
71
72    Import stub to call shared library routine from normal object file
73    (single sub-space version)
74    :            addil LR'lt_ptr+ltoff,%dp       ; get procedure entry point
75    :            ldw RR'lt_ptr+ltoff(%r1),%r21
76    :            bv %r0(%r21)
77    :            ldw RR'lt_ptr+ltoff+4(%r1),%r19 ; get new dlt value.
78
79    Import stub to call shared library routine from shared library
80    (single sub-space version)
81    :            addil LR'ltoff,%r19             ; get procedure entry point
82    :            ldw RR'ltoff(%r1),%r21
83    :            bv %r0(%r21)
84    :            ldw RR'ltoff+4(%r1),%r19        ; get new dlt value.
85
86    Import stub to call shared library routine from normal object file
87    (multiple sub-space support)
88    :            addil LR'lt_ptr+ltoff,%dp       ; get procedure entry point
89    :            ldw RR'lt_ptr+ltoff(%r1),%r21
90    :            ldw RR'lt_ptr+ltoff+4(%r1),%r19 ; get new dlt value.
91    :            ldsid (%r21),%r1
92    :            mtsp %r1,%sr0
93    :            be 0(%sr0,%r21)                 ; branch to target
94    :            stw %rp,-24(%sp)                ; save rp
95
96    Import stub to call shared library routine from shared library
97    (multiple sub-space support)
98    :            addil LR'ltoff,%r19             ; get procedure entry point
99    :            ldw RR'ltoff(%r1),%r21
100    :            ldw RR'ltoff+4(%r1),%r19        ; get new dlt value.
101    :            ldsid (%r21),%r1
102    :            mtsp %r1,%sr0
103    :            be 0(%sr0,%r21)                 ; branch to target
104    :            stw %rp,-24(%sp)                ; save rp
105
106    Export stub to return from shared lib routine (multiple sub-space support)
107    One of these is created for each exported procedure in a shared
108    library (and stored in the shared lib).  Shared lib routines are
109    called via the first instruction in the export stub so that we can
110    do an inter-space return.  Not required for single sub-space.
111    :            bl,n X,%rp                      ; trap the return
112    :            nop
113    :            ldw -24(%sp),%rp                ; restore the original rp
114    :            ldsid (%rp),%r1
115    :            mtsp %r1,%sr0
116    :            be,n 0(%sr0,%rp)                ; inter-space return.  */
117
118
119 /* Variable names follow a coding style.
120    Please follow this (Apps Hungarian) style:
121
122    Structure/Variable                   Prefix
123    elf_link_hash_table                  "etab"
124    elf_link_hash_entry                  "eh"
125
126    elf32_hppa_link_hash_table           "htab"
127    elf32_hppa_link_hash_entry           "hh"
128
129    bfd_hash_table                       "btab"
130    bfd_hash_entry                       "bh"
131
132    bfd_hash_table containing stubs      "bstab"
133    elf32_hppa_stub_hash_entry           "hsh"
134
135    Always remember to use GNU Coding Style. */
136
137 #define PLT_ENTRY_SIZE 8
138 #define GOT_ENTRY_SIZE 4
139 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
140
141 static const bfd_byte plt_stub[] =
142 {
143   0x0e, 0x80, 0x10, 0x96,  /* 1: ldw    0(%r20),%r22            */
144   0xea, 0xc0, 0xc0, 0x00,  /*    bv     %r0(%r22)               */
145   0x0e, 0x88, 0x10, 0x95,  /*    ldw    4(%r20),%r21            */
146 #define PLT_STUB_ENTRY (3*4)
147   0xea, 0x9f, 0x1f, 0xdd,  /*    b,l    1b,%r20                 */
148   0xd6, 0x80, 0x1c, 0x1e,  /*    depi   0,31,2,%r20             */
149   0x00, 0xc0, 0xff, 0xee,  /* 9: .word  fixup_func              */
150   0xde, 0xad, 0xbe, 0xef   /*    .word  fixup_ltp               */
151 };
152
153 /* Section name for stubs is the associated section name plus this
154    string.  */
155 #define STUB_SUFFIX ".stub"
156
157 /* We don't need to copy certain PC- or GP-relative dynamic relocs
158    into a shared object's dynamic section.  All the relocs of the
159    limited class we are interested in, are absolute.  */
160 #ifndef RELATIVE_DYNRELOCS
161 #define RELATIVE_DYNRELOCS 0
162 #define IS_ABSOLUTE_RELOC(r_type) 1
163 #define pc_dynrelocs(hh) 0
164 #endif
165
166 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
167    copying dynamic variables from a shared lib into an app's dynbss
168    section, and instead use a dynamic relocation to point into the
169    shared lib.  */
170 #define ELIMINATE_COPY_RELOCS 1
171
172 enum elf32_hppa_stub_type
173 {
174   hppa_stub_long_branch,
175   hppa_stub_long_branch_shared,
176   hppa_stub_import,
177   hppa_stub_import_shared,
178   hppa_stub_export,
179   hppa_stub_none
180 };
181
182 struct elf32_hppa_stub_hash_entry
183 {
184   /* Base hash table entry structure.  */
185   struct bfd_hash_entry bh_root;
186
187   /* The stub section.  */
188   asection *stub_sec;
189
190   /* Offset within stub_sec of the beginning of this stub.  */
191   bfd_vma stub_offset;
192
193   /* Given the symbol's value and its section we can determine its final
194      value when building the stubs (so the stub knows where to jump.  */
195   bfd_vma target_value;
196   asection *target_section;
197
198   enum elf32_hppa_stub_type stub_type;
199
200   /* The symbol table entry, if any, that this was derived from.  */
201   struct elf32_hppa_link_hash_entry *hh;
202
203   /* Where this stub is being called from, or, in the case of combined
204      stub sections, the first input section in the group.  */
205   asection *id_sec;
206 };
207
208 enum _tls_type
209   {
210     GOT_UNKNOWN = 0,
211     GOT_NORMAL = 1,
212     GOT_TLS_GD = 2,
213     GOT_TLS_LDM = 4,
214     GOT_TLS_IE = 8
215   };
216
217 struct elf32_hppa_link_hash_entry
218 {
219   struct elf_link_hash_entry eh;
220
221   /* A pointer to the most recently used stub hash entry against this
222      symbol.  */
223   struct elf32_hppa_stub_hash_entry *hsh_cache;
224
225   /* Used to count relocations for delayed sizing of relocation
226      sections.  */
227   struct elf_dyn_relocs *dyn_relocs;
228
229   ENUM_BITFIELD (_tls_type) tls_type : 8;
230
231   /* Set if this symbol is used by a plabel reloc.  */
232   unsigned int plabel:1;
233 };
234
235 struct elf32_hppa_link_hash_table
236 {
237   /* The main hash table.  */
238   struct elf_link_hash_table etab;
239
240   /* The stub hash table.  */
241   struct bfd_hash_table bstab;
242
243   /* Linker stub bfd.  */
244   bfd *stub_bfd;
245
246   /* Linker call-backs.  */
247   asection * (*add_stub_section) (const char *, asection *);
248   void (*layout_sections_again) (void);
249
250   /* Array to keep track of which stub sections have been created, and
251      information on stub grouping.  */
252   struct map_stub
253   {
254     /* This is the section to which stubs in the group will be
255        attached.  */
256     asection *link_sec;
257     /* The stub section.  */
258     asection *stub_sec;
259   } *stub_group;
260
261   /* Assorted information used by elf32_hppa_size_stubs.  */
262   unsigned int bfd_count;
263   unsigned int top_index;
264   asection **input_list;
265   Elf_Internal_Sym **all_local_syms;
266
267   /* Used during a final link to store the base of the text and data
268      segments so that we can perform SEGREL relocations.  */
269   bfd_vma text_segment_base;
270   bfd_vma data_segment_base;
271
272   /* Whether we support multiple sub-spaces for shared libs.  */
273   unsigned int multi_subspace:1;
274
275   /* Flags set when various size branches are detected.  Used to
276      select suitable defaults for the stub group size.  */
277   unsigned int has_12bit_branch:1;
278   unsigned int has_17bit_branch:1;
279   unsigned int has_22bit_branch:1;
280
281   /* Set if we need a .plt stub to support lazy dynamic linking.  */
282   unsigned int need_plt_stub:1;
283
284   /* Small local sym cache.  */
285   struct sym_cache sym_cache;
286
287   /* Data for LDM relocations.  */
288   union
289   {
290     bfd_signed_vma refcount;
291     bfd_vma offset;
292   } tls_ldm_got;
293 };
294
295 /* Various hash macros and functions.  */
296 #define hppa_link_hash_table(p) \
297   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
298   == HPPA32_ELF_DATA ? ((struct elf32_hppa_link_hash_table *) ((p)->hash)) : NULL)
299
300 #define hppa_elf_hash_entry(ent) \
301   ((struct elf32_hppa_link_hash_entry *)(ent))
302
303 #define hppa_stub_hash_entry(ent) \
304   ((struct elf32_hppa_stub_hash_entry *)(ent))
305
306 #define hppa_stub_hash_lookup(table, string, create, copy) \
307   ((struct elf32_hppa_stub_hash_entry *) \
308    bfd_hash_lookup ((table), (string), (create), (copy)))
309
310 #define hppa_elf_local_got_tls_type(abfd) \
311   ((char *)(elf_local_got_offsets (abfd) + (elf_tdata (abfd)->symtab_hdr.sh_info * 2)))
312
313 #define hh_name(hh) \
314   (hh ? hh->eh.root.root.string : "<undef>")
315
316 #define eh_name(eh) \
317   (eh ? eh->root.root.string : "<undef>")
318
319 /* Assorted hash table functions.  */
320
321 /* Initialize an entry in the stub hash table.  */
322
323 static struct bfd_hash_entry *
324 stub_hash_newfunc (struct bfd_hash_entry *entry,
325                    struct bfd_hash_table *table,
326                    const char *string)
327 {
328   /* Allocate the structure if it has not already been allocated by a
329      subclass.  */
330   if (entry == NULL)
331     {
332       entry = bfd_hash_allocate (table,
333                                  sizeof (struct elf32_hppa_stub_hash_entry));
334       if (entry == NULL)
335         return entry;
336     }
337
338   /* Call the allocation method of the superclass.  */
339   entry = bfd_hash_newfunc (entry, table, string);
340   if (entry != NULL)
341     {
342       struct elf32_hppa_stub_hash_entry *hsh;
343
344       /* Initialize the local fields.  */
345       hsh = hppa_stub_hash_entry (entry);
346       hsh->stub_sec = NULL;
347       hsh->stub_offset = 0;
348       hsh->target_value = 0;
349       hsh->target_section = NULL;
350       hsh->stub_type = hppa_stub_long_branch;
351       hsh->hh = NULL;
352       hsh->id_sec = NULL;
353     }
354
355   return entry;
356 }
357
358 /* Initialize an entry in the link hash table.  */
359
360 static struct bfd_hash_entry *
361 hppa_link_hash_newfunc (struct bfd_hash_entry *entry,
362                         struct bfd_hash_table *table,
363                         const char *string)
364 {
365   /* Allocate the structure if it has not already been allocated by a
366      subclass.  */
367   if (entry == NULL)
368     {
369       entry = bfd_hash_allocate (table,
370                                  sizeof (struct elf32_hppa_link_hash_entry));
371       if (entry == NULL)
372         return entry;
373     }
374
375   /* Call the allocation method of the superclass.  */
376   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
377   if (entry != NULL)
378     {
379       struct elf32_hppa_link_hash_entry *hh;
380
381       /* Initialize the local fields.  */
382       hh = hppa_elf_hash_entry (entry);
383       hh->hsh_cache = NULL;
384       hh->dyn_relocs = NULL;
385       hh->plabel = 0;
386       hh->tls_type = GOT_UNKNOWN;
387     }
388
389   return entry;
390 }
391
392 /* Free the derived linker hash table.  */
393
394 static void
395 elf32_hppa_link_hash_table_free (bfd *obfd)
396 {
397   struct elf32_hppa_link_hash_table *htab
398     = (struct elf32_hppa_link_hash_table *) obfd->link.hash;
399
400   bfd_hash_table_free (&htab->bstab);
401   _bfd_elf_link_hash_table_free (obfd);
402 }
403
404 /* Create the derived linker hash table.  The PA ELF port uses the derived
405    hash table to keep information specific to the PA ELF linker (without
406    using static variables).  */
407
408 static struct bfd_link_hash_table *
409 elf32_hppa_link_hash_table_create (bfd *abfd)
410 {
411   struct elf32_hppa_link_hash_table *htab;
412   bfd_size_type amt = sizeof (*htab);
413
414   htab = bfd_zmalloc (amt);
415   if (htab == NULL)
416     return NULL;
417
418   if (!_bfd_elf_link_hash_table_init (&htab->etab, abfd, hppa_link_hash_newfunc,
419                                       sizeof (struct elf32_hppa_link_hash_entry),
420                                       HPPA32_ELF_DATA))
421     {
422       free (htab);
423       return NULL;
424     }
425
426   /* Init the stub hash table too.  */
427   if (!bfd_hash_table_init (&htab->bstab, stub_hash_newfunc,
428                             sizeof (struct elf32_hppa_stub_hash_entry)))
429     {
430       _bfd_elf_link_hash_table_free (abfd);
431       return NULL;
432     }
433   htab->etab.root.hash_table_free = elf32_hppa_link_hash_table_free;
434
435   htab->text_segment_base = (bfd_vma) -1;
436   htab->data_segment_base = (bfd_vma) -1;
437   return &htab->etab.root;
438 }
439
440 /* Initialize the linker stubs BFD so that we can use it for linker
441    created dynamic sections.  */
442
443 void
444 elf32_hppa_init_stub_bfd (bfd *abfd, struct bfd_link_info *info)
445 {
446   struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
447
448   elf_elfheader (abfd)->e_ident[EI_CLASS] = ELFCLASS32;
449   htab->etab.dynobj = abfd;
450 }
451
452 /* Build a name for an entry in the stub hash table.  */
453
454 static char *
455 hppa_stub_name (const asection *input_section,
456                 const asection *sym_sec,
457                 const struct elf32_hppa_link_hash_entry *hh,
458                 const Elf_Internal_Rela *rela)
459 {
460   char *stub_name;
461   bfd_size_type len;
462
463   if (hh)
464     {
465       len = 8 + 1 + strlen (hh_name (hh)) + 1 + 8 + 1;
466       stub_name = bfd_malloc (len);
467       if (stub_name != NULL)
468         sprintf (stub_name, "%08x_%s+%x",
469                  input_section->id & 0xffffffff,
470                  hh_name (hh),
471                  (int) rela->r_addend & 0xffffffff);
472     }
473   else
474     {
475       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
476       stub_name = bfd_malloc (len);
477       if (stub_name != NULL)
478         sprintf (stub_name, "%08x_%x:%x+%x",
479                  input_section->id & 0xffffffff,
480                  sym_sec->id & 0xffffffff,
481                  (int) ELF32_R_SYM (rela->r_info) & 0xffffffff,
482                  (int) rela->r_addend & 0xffffffff);
483     }
484   return stub_name;
485 }
486
487 /* Look up an entry in the stub hash.  Stub entries are cached because
488    creating the stub name takes a bit of time.  */
489
490 static struct elf32_hppa_stub_hash_entry *
491 hppa_get_stub_entry (const asection *input_section,
492                      const asection *sym_sec,
493                      struct elf32_hppa_link_hash_entry *hh,
494                      const Elf_Internal_Rela *rela,
495                      struct elf32_hppa_link_hash_table *htab)
496 {
497   struct elf32_hppa_stub_hash_entry *hsh_entry;
498   const asection *id_sec;
499
500   /* If this input section is part of a group of sections sharing one
501      stub section, then use the id of the first section in the group.
502      Stub names need to include a section id, as there may well be
503      more than one stub used to reach say, printf, and we need to
504      distinguish between them.  */
505   id_sec = htab->stub_group[input_section->id].link_sec;
506   if (id_sec == NULL)
507     return NULL;
508
509   if (hh != NULL && hh->hsh_cache != NULL
510       && hh->hsh_cache->hh == hh
511       && hh->hsh_cache->id_sec == id_sec)
512     {
513       hsh_entry = hh->hsh_cache;
514     }
515   else
516     {
517       char *stub_name;
518
519       stub_name = hppa_stub_name (id_sec, sym_sec, hh, rela);
520       if (stub_name == NULL)
521         return NULL;
522
523       hsh_entry = hppa_stub_hash_lookup (&htab->bstab,
524                                           stub_name, FALSE, FALSE);
525       if (hh != NULL)
526         hh->hsh_cache = hsh_entry;
527
528       free (stub_name);
529     }
530
531   return hsh_entry;
532 }
533
534 /* Add a new stub entry to the stub hash.  Not all fields of the new
535    stub entry are initialised.  */
536
537 static struct elf32_hppa_stub_hash_entry *
538 hppa_add_stub (const char *stub_name,
539                asection *section,
540                struct elf32_hppa_link_hash_table *htab)
541 {
542   asection *link_sec;
543   asection *stub_sec;
544   struct elf32_hppa_stub_hash_entry *hsh;
545
546   link_sec = htab->stub_group[section->id].link_sec;
547   stub_sec = htab->stub_group[section->id].stub_sec;
548   if (stub_sec == NULL)
549     {
550       stub_sec = htab->stub_group[link_sec->id].stub_sec;
551       if (stub_sec == NULL)
552         {
553           size_t namelen;
554           bfd_size_type len;
555           char *s_name;
556
557           namelen = strlen (link_sec->name);
558           len = namelen + sizeof (STUB_SUFFIX);
559           s_name = bfd_alloc (htab->stub_bfd, len);
560           if (s_name == NULL)
561             return NULL;
562
563           memcpy (s_name, link_sec->name, namelen);
564           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
565           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
566           if (stub_sec == NULL)
567             return NULL;
568           htab->stub_group[link_sec->id].stub_sec = stub_sec;
569         }
570       htab->stub_group[section->id].stub_sec = stub_sec;
571     }
572
573   /* Enter this entry into the linker stub hash table.  */
574   hsh = hppa_stub_hash_lookup (&htab->bstab, stub_name,
575                                       TRUE, FALSE);
576   if (hsh == NULL)
577     {
578       /* xgettext:c-format */
579       _bfd_error_handler (_("%pB: cannot create stub entry %s"),
580                           section->owner, stub_name);
581       return NULL;
582     }
583
584   hsh->stub_sec = stub_sec;
585   hsh->stub_offset = 0;
586   hsh->id_sec = link_sec;
587   return hsh;
588 }
589
590 /* Determine the type of stub needed, if any, for a call.  */
591
592 static enum elf32_hppa_stub_type
593 hppa_type_of_stub (asection *input_sec,
594                    const Elf_Internal_Rela *rela,
595                    struct elf32_hppa_link_hash_entry *hh,
596                    bfd_vma destination,
597                    struct bfd_link_info *info)
598 {
599   bfd_vma location;
600   bfd_vma branch_offset;
601   bfd_vma max_branch_offset;
602   unsigned int r_type;
603
604   if (hh != NULL
605       && hh->eh.plt.offset != (bfd_vma) -1
606       && hh->eh.dynindx != -1
607       && !hh->plabel
608       && (bfd_link_pic (info)
609           || !hh->eh.def_regular
610           || hh->eh.root.type == bfd_link_hash_defweak))
611     {
612       /* We need an import stub.  Decide between hppa_stub_import
613          and hppa_stub_import_shared later.  */
614       return hppa_stub_import;
615     }
616
617   if (destination == (bfd_vma) -1)
618     return hppa_stub_none;
619
620   /* Determine where the call point is.  */
621   location = (input_sec->output_offset
622               + input_sec->output_section->vma
623               + rela->r_offset);
624
625   branch_offset = destination - location - 8;
626   r_type = ELF32_R_TYPE (rela->r_info);
627
628   /* Determine if a long branch stub is needed.  parisc branch offsets
629      are relative to the second instruction past the branch, ie. +8
630      bytes on from the branch instruction location.  The offset is
631      signed and counts in units of 4 bytes.  */
632   if (r_type == (unsigned int) R_PARISC_PCREL17F)
633     max_branch_offset = (1 << (17 - 1)) << 2;
634
635   else if (r_type == (unsigned int) R_PARISC_PCREL12F)
636     max_branch_offset = (1 << (12 - 1)) << 2;
637
638   else /* R_PARISC_PCREL22F.  */
639     max_branch_offset = (1 << (22 - 1)) << 2;
640
641   if (branch_offset + max_branch_offset >= 2*max_branch_offset)
642     return hppa_stub_long_branch;
643
644   return hppa_stub_none;
645 }
646
647 /* Build one linker stub as defined by the stub hash table entry GEN_ENTRY.
648    IN_ARG contains the link info pointer.  */
649
650 #define LDIL_R1         0x20200000      /* ldil  LR'XXX,%r1             */
651 #define BE_SR4_R1       0xe0202002      /* be,n  RR'XXX(%sr4,%r1)       */
652
653 #define BL_R1           0xe8200000      /* b,l   .+8,%r1                */
654 #define ADDIL_R1        0x28200000      /* addil LR'XXX,%r1,%r1         */
655 #define DEPI_R1         0xd4201c1e      /* depi  0,31,2,%r1             */
656
657 #define ADDIL_DP        0x2b600000      /* addil LR'XXX,%dp,%r1         */
658 #define LDW_R1_R21      0x48350000      /* ldw   RR'XXX(%sr0,%r1),%r21  */
659 #define BV_R0_R21       0xeaa0c000      /* bv    %r0(%r21)              */
660 #define LDW_R1_R19      0x48330000      /* ldw   RR'XXX(%sr0,%r1),%r19  */
661
662 #define ADDIL_R19       0x2a600000      /* addil LR'XXX,%r19,%r1        */
663 #define LDW_R1_DP       0x483b0000      /* ldw   RR'XXX(%sr0,%r1),%dp   */
664
665 #define LDSID_R21_R1    0x02a010a1      /* ldsid (%sr0,%r21),%r1        */
666 #define MTSP_R1         0x00011820      /* mtsp  %r1,%sr0               */
667 #define BE_SR0_R21      0xe2a00000      /* be    0(%sr0,%r21)           */
668 #define STW_RP          0x6bc23fd1      /* stw   %rp,-24(%sr0,%sp)      */
669
670 #define BL22_RP         0xe800a002      /* b,l,n XXX,%rp                */
671 #define BL_RP           0xe8400002      /* b,l,n XXX,%rp                */
672 #define NOP             0x08000240      /* nop                          */
673 #define LDW_RP          0x4bc23fd1      /* ldw   -24(%sr0,%sp),%rp      */
674 #define LDSID_RP_R1     0x004010a1      /* ldsid (%sr0,%rp),%r1         */
675 #define BE_SR0_RP       0xe0400002      /* be,n  0(%sr0,%rp)            */
676
677 #ifndef R19_STUBS
678 #define R19_STUBS 1
679 #endif
680
681 #if R19_STUBS
682 #define LDW_R1_DLT      LDW_R1_R19
683 #else
684 #define LDW_R1_DLT      LDW_R1_DP
685 #endif
686
687 static bfd_boolean
688 hppa_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
689 {
690   struct elf32_hppa_stub_hash_entry *hsh;
691   struct bfd_link_info *info;
692   struct elf32_hppa_link_hash_table *htab;
693   asection *stub_sec;
694   bfd *stub_bfd;
695   bfd_byte *loc;
696   bfd_vma sym_value;
697   bfd_vma insn;
698   bfd_vma off;
699   int val;
700   int size;
701
702   /* Massage our args to the form they really have.  */
703   hsh = hppa_stub_hash_entry (bh);
704   info = (struct bfd_link_info *)in_arg;
705
706   htab = hppa_link_hash_table (info);
707   if (htab == NULL)
708     return FALSE;
709
710   stub_sec = hsh->stub_sec;
711
712   /* Make a note of the offset within the stubs for this entry.  */
713   hsh->stub_offset = stub_sec->size;
714   loc = stub_sec->contents + hsh->stub_offset;
715
716   stub_bfd = stub_sec->owner;
717
718   switch (hsh->stub_type)
719     {
720     case hppa_stub_long_branch:
721       /* Create the long branch.  A long branch is formed with "ldil"
722          loading the upper bits of the target address into a register,
723          then branching with "be" which adds in the lower bits.
724          The "be" has its delay slot nullified.  */
725       sym_value = (hsh->target_value
726                    + hsh->target_section->output_offset
727                    + hsh->target_section->output_section->vma);
728
729       val = hppa_field_adjust (sym_value, 0, e_lrsel);
730       insn = hppa_rebuild_insn ((int) LDIL_R1, val, 21);
731       bfd_put_32 (stub_bfd, insn, loc);
732
733       val = hppa_field_adjust (sym_value, 0, e_rrsel) >> 2;
734       insn = hppa_rebuild_insn ((int) BE_SR4_R1, val, 17);
735       bfd_put_32 (stub_bfd, insn, loc + 4);
736
737       size = 8;
738       break;
739
740     case hppa_stub_long_branch_shared:
741       /* Branches are relative.  This is where we are going to.  */
742       sym_value = (hsh->target_value
743                    + hsh->target_section->output_offset
744                    + hsh->target_section->output_section->vma);
745
746       /* And this is where we are coming from, more or less.  */
747       sym_value -= (hsh->stub_offset
748                     + stub_sec->output_offset
749                     + stub_sec->output_section->vma);
750
751       bfd_put_32 (stub_bfd, (bfd_vma) BL_R1, loc);
752       val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_lrsel);
753       insn = hppa_rebuild_insn ((int) ADDIL_R1, val, 21);
754       bfd_put_32 (stub_bfd, insn, loc + 4);
755
756       val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_rrsel) >> 2;
757       insn = hppa_rebuild_insn ((int) BE_SR4_R1, val, 17);
758       bfd_put_32 (stub_bfd, insn, loc + 8);
759       size = 12;
760       break;
761
762     case hppa_stub_import:
763     case hppa_stub_import_shared:
764       off = hsh->hh->eh.plt.offset;
765       if (off >= (bfd_vma) -2)
766         abort ();
767
768       off &= ~ (bfd_vma) 1;
769       sym_value = (off
770                    + htab->etab.splt->output_offset
771                    + htab->etab.splt->output_section->vma
772                    - elf_gp (htab->etab.splt->output_section->owner));
773
774       insn = ADDIL_DP;
775 #if R19_STUBS
776       if (hsh->stub_type == hppa_stub_import_shared)
777         insn = ADDIL_R19;
778 #endif
779       val = hppa_field_adjust (sym_value, 0, e_lrsel),
780       insn = hppa_rebuild_insn ((int) insn, val, 21);
781       bfd_put_32 (stub_bfd, insn, loc);
782
783       /* It is critical to use lrsel/rrsel here because we are using
784          two different offsets (+0 and +4) from sym_value.  If we use
785          lsel/rsel then with unfortunate sym_values we will round
786          sym_value+4 up to the next 2k block leading to a mis-match
787          between the lsel and rsel value.  */
788       val = hppa_field_adjust (sym_value, 0, e_rrsel);
789       insn = hppa_rebuild_insn ((int) LDW_R1_R21, val, 14);
790       bfd_put_32 (stub_bfd, insn, loc + 4);
791
792       if (htab->multi_subspace)
793         {
794           val = hppa_field_adjust (sym_value, (bfd_signed_vma) 4, e_rrsel);
795           insn = hppa_rebuild_insn ((int) LDW_R1_DLT, val, 14);
796           bfd_put_32 (stub_bfd, insn, loc + 8);
797
798           bfd_put_32 (stub_bfd, (bfd_vma) LDSID_R21_R1, loc + 12);
799           bfd_put_32 (stub_bfd, (bfd_vma) MTSP_R1,      loc + 16);
800           bfd_put_32 (stub_bfd, (bfd_vma) BE_SR0_R21,   loc + 20);
801           bfd_put_32 (stub_bfd, (bfd_vma) STW_RP,       loc + 24);
802
803           size = 28;
804         }
805       else
806         {
807           bfd_put_32 (stub_bfd, (bfd_vma) BV_R0_R21, loc + 8);
808           val = hppa_field_adjust (sym_value, (bfd_signed_vma) 4, e_rrsel);
809           insn = hppa_rebuild_insn ((int) LDW_R1_DLT, val, 14);
810           bfd_put_32 (stub_bfd, insn, loc + 12);
811
812           size = 16;
813         }
814
815       break;
816
817     case hppa_stub_export:
818       /* Branches are relative.  This is where we are going to.  */
819       sym_value = (hsh->target_value
820                    + hsh->target_section->output_offset
821                    + hsh->target_section->output_section->vma);
822
823       /* And this is where we are coming from.  */
824       sym_value -= (hsh->stub_offset
825                     + stub_sec->output_offset
826                     + stub_sec->output_section->vma);
827
828       if (sym_value - 8 + (1 << (17 + 1)) >= (1 << (17 + 2))
829           && (!htab->has_22bit_branch
830               || sym_value - 8 + (1 << (22 + 1)) >= (1 << (22 + 2))))
831         {
832           _bfd_error_handler
833             /* xgettext:c-format */
834             (_("%pB(%pA+%#" PRIx64 "): "
835                "cannot reach %s, recompile with -ffunction-sections"),
836              hsh->target_section->owner,
837              stub_sec,
838              (uint64_t) hsh->stub_offset,
839              hsh->bh_root.string);
840           bfd_set_error (bfd_error_bad_value);
841           return FALSE;
842         }
843
844       val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_fsel) >> 2;
845       if (!htab->has_22bit_branch)
846         insn = hppa_rebuild_insn ((int) BL_RP, val, 17);
847       else
848         insn = hppa_rebuild_insn ((int) BL22_RP, val, 22);
849       bfd_put_32 (stub_bfd, insn, loc);
850
851       bfd_put_32 (stub_bfd, (bfd_vma) NOP,         loc + 4);
852       bfd_put_32 (stub_bfd, (bfd_vma) LDW_RP,      loc + 8);
853       bfd_put_32 (stub_bfd, (bfd_vma) LDSID_RP_R1, loc + 12);
854       bfd_put_32 (stub_bfd, (bfd_vma) MTSP_R1,     loc + 16);
855       bfd_put_32 (stub_bfd, (bfd_vma) BE_SR0_RP,   loc + 20);
856
857       /* Point the function symbol at the stub.  */
858       hsh->hh->eh.root.u.def.section = stub_sec;
859       hsh->hh->eh.root.u.def.value = stub_sec->size;
860
861       size = 24;
862       break;
863
864     default:
865       BFD_FAIL ();
866       return FALSE;
867     }
868
869   stub_sec->size += size;
870   return TRUE;
871 }
872
873 #undef LDIL_R1
874 #undef BE_SR4_R1
875 #undef BL_R1
876 #undef ADDIL_R1
877 #undef DEPI_R1
878 #undef LDW_R1_R21
879 #undef LDW_R1_DLT
880 #undef LDW_R1_R19
881 #undef ADDIL_R19
882 #undef LDW_R1_DP
883 #undef LDSID_R21_R1
884 #undef MTSP_R1
885 #undef BE_SR0_R21
886 #undef STW_RP
887 #undef BV_R0_R21
888 #undef BL_RP
889 #undef NOP
890 #undef LDW_RP
891 #undef LDSID_RP_R1
892 #undef BE_SR0_RP
893
894 /* As above, but don't actually build the stub.  Just bump offset so
895    we know stub section sizes.  */
896
897 static bfd_boolean
898 hppa_size_one_stub (struct bfd_hash_entry *bh, void *in_arg)
899 {
900   struct elf32_hppa_stub_hash_entry *hsh;
901   struct elf32_hppa_link_hash_table *htab;
902   int size;
903
904   /* Massage our args to the form they really have.  */
905   hsh = hppa_stub_hash_entry (bh);
906   htab = in_arg;
907
908   if (hsh->stub_type == hppa_stub_long_branch)
909     size = 8;
910   else if (hsh->stub_type == hppa_stub_long_branch_shared)
911     size = 12;
912   else if (hsh->stub_type == hppa_stub_export)
913     size = 24;
914   else /* hppa_stub_import or hppa_stub_import_shared.  */
915     {
916       if (htab->multi_subspace)
917         size = 28;
918       else
919         size = 16;
920     }
921
922   hsh->stub_sec->size += size;
923   return TRUE;
924 }
925
926 /* Return nonzero if ABFD represents an HPPA ELF32 file.
927    Additionally we set the default architecture and machine.  */
928
929 static bfd_boolean
930 elf32_hppa_object_p (bfd *abfd)
931 {
932   Elf_Internal_Ehdr * i_ehdrp;
933   unsigned int flags;
934
935   i_ehdrp = elf_elfheader (abfd);
936   if (strcmp (bfd_get_target (abfd), "elf32-hppa-linux") == 0)
937     {
938       /* GCC on hppa-linux produces binaries with OSABI=GNU,
939          but the kernel produces corefiles with OSABI=SysV.  */
940       if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_GNU &&
941           i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */
942         return FALSE;
943     }
944   else if (strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") == 0)
945     {
946       /* GCC on hppa-netbsd produces binaries with OSABI=NetBSD,
947          but the kernel produces corefiles with OSABI=SysV.  */
948       if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NETBSD &&
949           i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */
950         return FALSE;
951     }
952   else
953     {
954       if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_HPUX)
955         return FALSE;
956     }
957
958   flags = i_ehdrp->e_flags;
959   switch (flags & (EF_PARISC_ARCH | EF_PARISC_WIDE))
960     {
961     case EFA_PARISC_1_0:
962       return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 10);
963     case EFA_PARISC_1_1:
964       return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 11);
965     case EFA_PARISC_2_0:
966       return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 20);
967     case EFA_PARISC_2_0 | EF_PARISC_WIDE:
968       return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25);
969     }
970   return TRUE;
971 }
972
973 /* Create the .plt and .got sections, and set up our hash table
974    short-cuts to various dynamic sections.  */
975
976 static bfd_boolean
977 elf32_hppa_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
978 {
979   struct elf32_hppa_link_hash_table *htab;
980   struct elf_link_hash_entry *eh;
981
982   /* Don't try to create the .plt and .got twice.  */
983   htab = hppa_link_hash_table (info);
984   if (htab == NULL)
985     return FALSE;
986   if (htab->etab.splt != NULL)
987     return TRUE;
988
989   /* Call the generic code to do most of the work.  */
990   if (! _bfd_elf_create_dynamic_sections (abfd, info))
991     return FALSE;
992
993   /* hppa-linux needs _GLOBAL_OFFSET_TABLE_ to be visible from the main
994      application, because __canonicalize_funcptr_for_compare needs it.  */
995   eh = elf_hash_table (info)->hgot;
996   eh->forced_local = 0;
997   eh->other = STV_DEFAULT;
998   return bfd_elf_link_record_dynamic_symbol (info, eh);
999 }
1000
1001 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
1002
1003 static void
1004 elf32_hppa_copy_indirect_symbol (struct bfd_link_info *info,
1005                                  struct elf_link_hash_entry *eh_dir,
1006                                  struct elf_link_hash_entry *eh_ind)
1007 {
1008   struct elf32_hppa_link_hash_entry *hh_dir, *hh_ind;
1009
1010   hh_dir = hppa_elf_hash_entry (eh_dir);
1011   hh_ind = hppa_elf_hash_entry (eh_ind);
1012
1013   if (hh_ind->dyn_relocs != NULL
1014       && eh_ind->root.type == bfd_link_hash_indirect)
1015     {
1016       if (hh_dir->dyn_relocs != NULL)
1017         {
1018           struct elf_dyn_relocs **hdh_pp;
1019           struct elf_dyn_relocs *hdh_p;
1020
1021           /* Add reloc counts against the indirect sym to the direct sym
1022              list.  Merge any entries against the same section.  */
1023           for (hdh_pp = &hh_ind->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
1024             {
1025               struct elf_dyn_relocs *hdh_q;
1026
1027               for (hdh_q = hh_dir->dyn_relocs;
1028                    hdh_q != NULL;
1029                    hdh_q = hdh_q->next)
1030                 if (hdh_q->sec == hdh_p->sec)
1031                   {
1032 #if RELATIVE_DYNRELOCS
1033                     hdh_q->pc_count += hdh_p->pc_count;
1034 #endif
1035                     hdh_q->count += hdh_p->count;
1036                     *hdh_pp = hdh_p->next;
1037                     break;
1038                   }
1039               if (hdh_q == NULL)
1040                 hdh_pp = &hdh_p->next;
1041             }
1042           *hdh_pp = hh_dir->dyn_relocs;
1043         }
1044
1045       hh_dir->dyn_relocs = hh_ind->dyn_relocs;
1046       hh_ind->dyn_relocs = NULL;
1047     }
1048
1049   if (eh_ind->root.type == bfd_link_hash_indirect)
1050     {
1051       hh_dir->plabel |= hh_ind->plabel;
1052       hh_dir->tls_type |= hh_ind->tls_type;
1053       hh_ind->tls_type = GOT_UNKNOWN;
1054     }
1055
1056   _bfd_elf_link_hash_copy_indirect (info, eh_dir, eh_ind);
1057 }
1058
1059 static int
1060 elf32_hppa_optimized_tls_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1061                                 int r_type, int is_local ATTRIBUTE_UNUSED)
1062 {
1063   /* For now we don't support linker optimizations.  */
1064   return r_type;
1065 }
1066
1067 /* Return a pointer to the local GOT, PLT and TLS reference counts
1068    for ABFD.  Returns NULL if the storage allocation fails.  */
1069
1070 static bfd_signed_vma *
1071 hppa32_elf_local_refcounts (bfd *abfd)
1072 {
1073   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1074   bfd_signed_vma *local_refcounts;
1075
1076   local_refcounts = elf_local_got_refcounts (abfd);
1077   if (local_refcounts == NULL)
1078     {
1079       bfd_size_type size;
1080
1081       /* Allocate space for local GOT and PLT reference
1082          counts.  Done this way to save polluting elf_obj_tdata
1083          with another target specific pointer.  */
1084       size = symtab_hdr->sh_info;
1085       size *= 2 * sizeof (bfd_signed_vma);
1086       /* Add in space to store the local GOT TLS types.  */
1087       size += symtab_hdr->sh_info;
1088       local_refcounts = bfd_zalloc (abfd, size);
1089       if (local_refcounts == NULL)
1090         return NULL;
1091       elf_local_got_refcounts (abfd) = local_refcounts;
1092       memset (hppa_elf_local_got_tls_type (abfd), GOT_UNKNOWN,
1093               symtab_hdr->sh_info);
1094     }
1095   return local_refcounts;
1096 }
1097
1098
1099 /* Look through the relocs for a section during the first phase, and
1100    calculate needed space in the global offset table, procedure linkage
1101    table, and dynamic reloc sections.  At this point we haven't
1102    necessarily read all the input files.  */
1103
1104 static bfd_boolean
1105 elf32_hppa_check_relocs (bfd *abfd,
1106                          struct bfd_link_info *info,
1107                          asection *sec,
1108                          const Elf_Internal_Rela *relocs)
1109 {
1110   Elf_Internal_Shdr *symtab_hdr;
1111   struct elf_link_hash_entry **eh_syms;
1112   const Elf_Internal_Rela *rela;
1113   const Elf_Internal_Rela *rela_end;
1114   struct elf32_hppa_link_hash_table *htab;
1115   asection *sreloc;
1116
1117   if (bfd_link_relocatable (info))
1118     return TRUE;
1119
1120   htab = hppa_link_hash_table (info);
1121   if (htab == NULL)
1122     return FALSE;
1123   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1124   eh_syms = elf_sym_hashes (abfd);
1125   sreloc = NULL;
1126
1127   rela_end = relocs + sec->reloc_count;
1128   for (rela = relocs; rela < rela_end; rela++)
1129     {
1130       enum {
1131         NEED_GOT = 1,
1132         NEED_PLT = 2,
1133         NEED_DYNREL = 4,
1134         PLT_PLABEL = 8
1135       };
1136
1137       unsigned int r_symndx, r_type;
1138       struct elf32_hppa_link_hash_entry *hh;
1139       int need_entry = 0;
1140
1141       r_symndx = ELF32_R_SYM (rela->r_info);
1142
1143       if (r_symndx < symtab_hdr->sh_info)
1144         hh = NULL;
1145       else
1146         {
1147           hh =  hppa_elf_hash_entry (eh_syms[r_symndx - symtab_hdr->sh_info]);
1148           while (hh->eh.root.type == bfd_link_hash_indirect
1149                  || hh->eh.root.type == bfd_link_hash_warning)
1150             hh = hppa_elf_hash_entry (hh->eh.root.u.i.link);
1151         }
1152
1153       r_type = ELF32_R_TYPE (rela->r_info);
1154       r_type = elf32_hppa_optimized_tls_reloc (info, r_type, hh == NULL);
1155
1156       switch (r_type)
1157         {
1158         case R_PARISC_DLTIND14F:
1159         case R_PARISC_DLTIND14R:
1160         case R_PARISC_DLTIND21L:
1161           /* This symbol requires a global offset table entry.  */
1162           need_entry = NEED_GOT;
1163           break;
1164
1165         case R_PARISC_PLABEL14R: /* "Official" procedure labels.  */
1166         case R_PARISC_PLABEL21L:
1167         case R_PARISC_PLABEL32:
1168           /* If the addend is non-zero, we break badly.  */
1169           if (rela->r_addend != 0)
1170             abort ();
1171
1172           /* If we are creating a shared library, then we need to
1173              create a PLT entry for all PLABELs, because PLABELs with
1174              local symbols may be passed via a pointer to another
1175              object.  Additionally, output a dynamic relocation
1176              pointing to the PLT entry.
1177
1178              For executables, the original 32-bit ABI allowed two
1179              different styles of PLABELs (function pointers):  For
1180              global functions, the PLABEL word points into the .plt
1181              two bytes past a (function address, gp) pair, and for
1182              local functions the PLABEL points directly at the
1183              function.  The magic +2 for the first type allows us to
1184              differentiate between the two.  As you can imagine, this
1185              is a real pain when it comes to generating code to call
1186              functions indirectly or to compare function pointers.
1187              We avoid the mess by always pointing a PLABEL into the
1188              .plt, even for local functions.  */
1189           need_entry = PLT_PLABEL | NEED_PLT;
1190           if (bfd_link_pic (info))
1191             need_entry |= NEED_DYNREL;
1192           break;
1193
1194         case R_PARISC_PCREL12F:
1195           htab->has_12bit_branch = 1;
1196           goto branch_common;
1197
1198         case R_PARISC_PCREL17C:
1199         case R_PARISC_PCREL17F:
1200           htab->has_17bit_branch = 1;
1201           goto branch_common;
1202
1203         case R_PARISC_PCREL22F:
1204           htab->has_22bit_branch = 1;
1205         branch_common:
1206           /* Function calls might need to go through the .plt, and
1207              might require long branch stubs.  */
1208           if (hh == NULL)
1209             {
1210               /* We know local syms won't need a .plt entry, and if
1211                  they need a long branch stub we can't guarantee that
1212                  we can reach the stub.  So just flag an error later
1213                  if we're doing a shared link and find we need a long
1214                  branch stub.  */
1215               continue;
1216             }
1217           else
1218             {
1219               /* Global symbols will need a .plt entry if they remain
1220                  global, and in most cases won't need a long branch
1221                  stub.  Unfortunately, we have to cater for the case
1222                  where a symbol is forced local by versioning, or due
1223                  to symbolic linking, and we lose the .plt entry.  */
1224               need_entry = NEED_PLT;
1225               if (hh->eh.type == STT_PARISC_MILLI)
1226                 need_entry = 0;
1227             }
1228           break;
1229
1230         case R_PARISC_SEGBASE:  /* Used to set segment base.  */
1231         case R_PARISC_SEGREL32: /* Relative reloc, used for unwind.  */
1232         case R_PARISC_PCREL14F: /* PC relative load/store.  */
1233         case R_PARISC_PCREL14R:
1234         case R_PARISC_PCREL17R: /* External branches.  */
1235         case R_PARISC_PCREL21L: /* As above, and for load/store too.  */
1236         case R_PARISC_PCREL32:
1237           /* We don't need to propagate the relocation if linking a
1238              shared object since these are section relative.  */
1239           continue;
1240
1241         case R_PARISC_DPREL14F: /* Used for gp rel data load/store.  */
1242         case R_PARISC_DPREL14R:
1243         case R_PARISC_DPREL21L:
1244           if (bfd_link_pic (info))
1245             {
1246               _bfd_error_handler
1247                 /* xgettext:c-format */
1248                 (_("%pB: relocation %s can not be used when making a shared object; recompile with -fPIC"),
1249                  abfd,
1250                  elf_hppa_howto_table[r_type].name);
1251               bfd_set_error (bfd_error_bad_value);
1252               return FALSE;
1253             }
1254           /* Fall through.  */
1255
1256         case R_PARISC_DIR17F: /* Used for external branches.  */
1257         case R_PARISC_DIR17R:
1258         case R_PARISC_DIR14F: /* Used for load/store from absolute locn.  */
1259         case R_PARISC_DIR14R:
1260         case R_PARISC_DIR21L: /* As above, and for ext branches too.  */
1261         case R_PARISC_DIR32: /* .word relocs.  */
1262           /* We may want to output a dynamic relocation later.  */
1263           need_entry = NEED_DYNREL;
1264           break;
1265
1266           /* This relocation describes the C++ object vtable hierarchy.
1267              Reconstruct it for later use during GC.  */
1268         case R_PARISC_GNU_VTINHERIT:
1269           if (!bfd_elf_gc_record_vtinherit (abfd, sec, &hh->eh, rela->r_offset))
1270             return FALSE;
1271           continue;
1272
1273           /* This relocation describes which C++ vtable entries are actually
1274              used.  Record for later use during GC.  */
1275         case R_PARISC_GNU_VTENTRY:
1276           BFD_ASSERT (hh != NULL);
1277           if (hh != NULL
1278               && !bfd_elf_gc_record_vtentry (abfd, sec, &hh->eh, rela->r_addend))
1279             return FALSE;
1280           continue;
1281
1282         case R_PARISC_TLS_GD21L:
1283         case R_PARISC_TLS_GD14R:
1284         case R_PARISC_TLS_LDM21L:
1285         case R_PARISC_TLS_LDM14R:
1286           need_entry = NEED_GOT;
1287           break;
1288
1289         case R_PARISC_TLS_IE21L:
1290         case R_PARISC_TLS_IE14R:
1291           if (bfd_link_dll (info))
1292             info->flags |= DF_STATIC_TLS;
1293           need_entry = NEED_GOT;
1294           break;
1295
1296         default:
1297           continue;
1298         }
1299
1300       /* Now carry out our orders.  */
1301       if (need_entry & NEED_GOT)
1302         {
1303           int tls_type = GOT_NORMAL;
1304
1305           switch (r_type)
1306             {
1307             default:
1308               break;
1309             case R_PARISC_TLS_GD21L:
1310             case R_PARISC_TLS_GD14R:
1311               tls_type = GOT_TLS_GD;
1312               break;
1313             case R_PARISC_TLS_LDM21L:
1314             case R_PARISC_TLS_LDM14R:
1315               tls_type = GOT_TLS_LDM;
1316               break;
1317             case R_PARISC_TLS_IE21L:
1318             case R_PARISC_TLS_IE14R:
1319               tls_type = GOT_TLS_IE;
1320               break;
1321             }
1322
1323           /* Allocate space for a GOT entry, as well as a dynamic
1324              relocation for this entry.  */
1325           if (htab->etab.sgot == NULL)
1326             {
1327               if (!elf32_hppa_create_dynamic_sections (htab->etab.dynobj, info))
1328                 return FALSE;
1329             }
1330
1331           if (hh != NULL)
1332             {
1333               if (tls_type == GOT_TLS_LDM)
1334                 htab->tls_ldm_got.refcount += 1;
1335               else
1336                 hh->eh.got.refcount += 1;
1337               hh->tls_type |= tls_type;
1338             }
1339           else
1340             {
1341               bfd_signed_vma *local_got_refcounts;
1342
1343               /* This is a global offset table entry for a local symbol.  */
1344               local_got_refcounts = hppa32_elf_local_refcounts (abfd);
1345               if (local_got_refcounts == NULL)
1346                 return FALSE;
1347               if (tls_type == GOT_TLS_LDM)
1348                 htab->tls_ldm_got.refcount += 1;
1349               else
1350                 local_got_refcounts[r_symndx] += 1;
1351
1352               hppa_elf_local_got_tls_type (abfd) [r_symndx] |= tls_type;
1353             }
1354         }
1355
1356       if (need_entry & NEED_PLT)
1357         {
1358           /* If we are creating a shared library, and this is a reloc
1359              against a weak symbol or a global symbol in a dynamic
1360              object, then we will be creating an import stub and a
1361              .plt entry for the symbol.  Similarly, on a normal link
1362              to symbols defined in a dynamic object we'll need the
1363              import stub and a .plt entry.  We don't know yet whether
1364              the symbol is defined or not, so make an entry anyway and
1365              clean up later in adjust_dynamic_symbol.  */
1366           if ((sec->flags & SEC_ALLOC) != 0)
1367             {
1368               if (hh != NULL)
1369                 {
1370                   hh->eh.needs_plt = 1;
1371                   hh->eh.plt.refcount += 1;
1372
1373                   /* If this .plt entry is for a plabel, mark it so
1374                      that adjust_dynamic_symbol will keep the entry
1375                      even if it appears to be local.  */
1376                   if (need_entry & PLT_PLABEL)
1377                     hh->plabel = 1;
1378                 }
1379               else if (need_entry & PLT_PLABEL)
1380                 {
1381                   bfd_signed_vma *local_got_refcounts;
1382                   bfd_signed_vma *local_plt_refcounts;
1383
1384                   local_got_refcounts = hppa32_elf_local_refcounts (abfd);
1385                   if (local_got_refcounts == NULL)
1386                     return FALSE;
1387                   local_plt_refcounts = (local_got_refcounts
1388                                          + symtab_hdr->sh_info);
1389                   local_plt_refcounts[r_symndx] += 1;
1390                 }
1391             }
1392         }
1393
1394       if ((need_entry & NEED_DYNREL) != 0
1395           && (sec->flags & SEC_ALLOC) != 0)
1396         {
1397           /* Flag this symbol as having a non-got, non-plt reference
1398              so that we generate copy relocs if it turns out to be
1399              dynamic.  */
1400           if (hh != NULL)
1401             hh->eh.non_got_ref = 1;
1402
1403           /* If we are creating a shared library then we need to copy
1404              the reloc into the shared library.  However, if we are
1405              linking with -Bsymbolic, we need only copy absolute
1406              relocs or relocs against symbols that are not defined in
1407              an object we are including in the link.  PC- or DP- or
1408              DLT-relative relocs against any local sym or global sym
1409              with DEF_REGULAR set, can be discarded.  At this point we
1410              have not seen all the input files, so it is possible that
1411              DEF_REGULAR is not set now but will be set later (it is
1412              never cleared).  We account for that possibility below by
1413              storing information in the dyn_relocs field of the
1414              hash table entry.
1415
1416              A similar situation to the -Bsymbolic case occurs when
1417              creating shared libraries and symbol visibility changes
1418              render the symbol local.
1419
1420              As it turns out, all the relocs we will be creating here
1421              are absolute, so we cannot remove them on -Bsymbolic
1422              links or visibility changes anyway.  A STUB_REL reloc
1423              is absolute too, as in that case it is the reloc in the
1424              stub we will be creating, rather than copying the PCREL
1425              reloc in the branch.
1426
1427              If on the other hand, we are creating an executable, we
1428              may need to keep relocations for symbols satisfied by a
1429              dynamic library if we manage to avoid copy relocs for the
1430              symbol.  */
1431           if ((bfd_link_pic (info)
1432                && (IS_ABSOLUTE_RELOC (r_type)
1433                    || (hh != NULL
1434                        && (!SYMBOLIC_BIND (info, &hh->eh)
1435                            || hh->eh.root.type == bfd_link_hash_defweak
1436                            || !hh->eh.def_regular))))
1437               || (ELIMINATE_COPY_RELOCS
1438                   && !bfd_link_pic (info)
1439                   && hh != NULL
1440                   && (hh->eh.root.type == bfd_link_hash_defweak
1441                       || !hh->eh.def_regular)))
1442             {
1443               struct elf_dyn_relocs *hdh_p;
1444               struct elf_dyn_relocs **hdh_head;
1445
1446               /* Create a reloc section in dynobj and make room for
1447                  this reloc.  */
1448               if (sreloc == NULL)
1449                 {
1450                   sreloc = _bfd_elf_make_dynamic_reloc_section
1451                     (sec, htab->etab.dynobj, 2, abfd, /*rela?*/ TRUE);
1452
1453                   if (sreloc == NULL)
1454                     {
1455                       bfd_set_error (bfd_error_bad_value);
1456                       return FALSE;
1457                     }
1458                 }
1459
1460               /* If this is a global symbol, we count the number of
1461                  relocations we need for this symbol.  */
1462               if (hh != NULL)
1463                 {
1464                   hdh_head = &hh->dyn_relocs;
1465                 }
1466               else
1467                 {
1468                   /* Track dynamic relocs needed for local syms too.
1469                      We really need local syms available to do this
1470                      easily.  Oh well.  */
1471                   asection *sr;
1472                   void *vpp;
1473                   Elf_Internal_Sym *isym;
1474
1475                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
1476                                                 abfd, r_symndx);
1477                   if (isym == NULL)
1478                     return FALSE;
1479
1480                   sr = bfd_section_from_elf_index (abfd, isym->st_shndx);
1481                   if (sr == NULL)
1482                     sr = sec;
1483
1484                   vpp = &elf_section_data (sr)->local_dynrel;
1485                   hdh_head = (struct elf_dyn_relocs **) vpp;
1486                 }
1487
1488               hdh_p = *hdh_head;
1489               if (hdh_p == NULL || hdh_p->sec != sec)
1490                 {
1491                   hdh_p = bfd_alloc (htab->etab.dynobj, sizeof *hdh_p);
1492                   if (hdh_p == NULL)
1493                     return FALSE;
1494                   hdh_p->next = *hdh_head;
1495                   *hdh_head = hdh_p;
1496                   hdh_p->sec = sec;
1497                   hdh_p->count = 0;
1498 #if RELATIVE_DYNRELOCS
1499                   hdh_p->pc_count = 0;
1500 #endif
1501                 }
1502
1503               hdh_p->count += 1;
1504 #if RELATIVE_DYNRELOCS
1505               if (!IS_ABSOLUTE_RELOC (rtype))
1506                 hdh_p->pc_count += 1;
1507 #endif
1508             }
1509         }
1510     }
1511
1512   return TRUE;
1513 }
1514
1515 /* Return the section that should be marked against garbage collection
1516    for a given relocation.  */
1517
1518 static asection *
1519 elf32_hppa_gc_mark_hook (asection *sec,
1520                          struct bfd_link_info *info,
1521                          Elf_Internal_Rela *rela,
1522                          struct elf_link_hash_entry *hh,
1523                          Elf_Internal_Sym *sym)
1524 {
1525   if (hh != NULL)
1526     switch ((unsigned int) ELF32_R_TYPE (rela->r_info))
1527       {
1528       case R_PARISC_GNU_VTINHERIT:
1529       case R_PARISC_GNU_VTENTRY:
1530         return NULL;
1531       }
1532
1533   return _bfd_elf_gc_mark_hook (sec, info, rela, hh, sym);
1534 }
1535
1536 /* Support for core dump NOTE sections.  */
1537
1538 static bfd_boolean
1539 elf32_hppa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1540 {
1541   int offset;
1542   size_t size;
1543
1544   switch (note->descsz)
1545     {
1546       default:
1547         return FALSE;
1548
1549       case 396:         /* Linux/hppa */
1550         /* pr_cursig */
1551         elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
1552
1553         /* pr_pid */
1554         elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
1555
1556         /* pr_reg */
1557         offset = 72;
1558         size = 320;
1559
1560         break;
1561     }
1562
1563   /* Make a ".reg/999" section.  */
1564   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1565                                           size, note->descpos + offset);
1566 }
1567
1568 static bfd_boolean
1569 elf32_hppa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
1570 {
1571   switch (note->descsz)
1572     {
1573       default:
1574         return FALSE;
1575
1576       case 124:         /* Linux/hppa elf_prpsinfo.  */
1577         elf_tdata (abfd)->core->program
1578           = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
1579         elf_tdata (abfd)->core->command
1580           = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
1581     }
1582
1583   /* Note that for some reason, a spurious space is tacked
1584      onto the end of the args in some (at least one anyway)
1585      implementations, so strip it off if it exists.  */
1586   {
1587     char *command = elf_tdata (abfd)->core->command;
1588     int n = strlen (command);
1589
1590     if (0 < n && command[n - 1] == ' ')
1591       command[n - 1] = '\0';
1592   }
1593
1594   return TRUE;
1595 }
1596
1597 /* Our own version of hide_symbol, so that we can keep plt entries for
1598    plabels.  */
1599
1600 static void
1601 elf32_hppa_hide_symbol (struct bfd_link_info *info,
1602                         struct elf_link_hash_entry *eh,
1603                         bfd_boolean force_local)
1604 {
1605   if (force_local)
1606     {
1607       eh->forced_local = 1;
1608       if (eh->dynindx != -1)
1609         {
1610           eh->dynindx = -1;
1611           _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1612                                   eh->dynstr_index);
1613         }
1614
1615       /* PR 16082: Remove version information from hidden symbol.  */
1616       eh->verinfo.verdef = NULL;
1617       eh->verinfo.vertree = NULL;
1618     }
1619
1620   /* STT_GNU_IFUNC symbol must go through PLT.  */
1621   if (! hppa_elf_hash_entry (eh)->plabel
1622       && eh->type != STT_GNU_IFUNC)
1623     {
1624       eh->needs_plt = 0;
1625       eh->plt = elf_hash_table (info)->init_plt_offset;
1626     }
1627 }
1628
1629 /* Find any dynamic relocs that apply to read-only sections.  */
1630
1631 static asection *
1632 readonly_dynrelocs (struct elf_link_hash_entry *eh)
1633 {
1634   struct elf32_hppa_link_hash_entry *hh;
1635   struct elf_dyn_relocs *hdh_p;
1636
1637   hh = hppa_elf_hash_entry (eh);
1638   for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->next)
1639     {
1640       asection *sec = hdh_p->sec->output_section;
1641
1642       if (sec != NULL && (sec->flags & SEC_READONLY) != 0)
1643         return hdh_p->sec;
1644     }
1645   return NULL;
1646 }
1647
1648 /* Return true if we have dynamic relocs against H or any of its weak
1649    aliases, that apply to read-only sections.  Cannot be used after
1650    size_dynamic_sections.  */
1651
1652 static bfd_boolean
1653 alias_readonly_dynrelocs (struct elf_link_hash_entry *eh)
1654 {
1655   struct elf32_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
1656   do
1657     {
1658       if (readonly_dynrelocs (&hh->eh))
1659         return TRUE;
1660       hh = hppa_elf_hash_entry (hh->eh.u.alias);
1661     } while (hh != NULL && &hh->eh != eh);
1662
1663   return FALSE;
1664 }
1665
1666 /* Adjust a symbol defined by a dynamic object and referenced by a
1667    regular object.  The current definition is in some section of the
1668    dynamic object, but we're not including those sections.  We have to
1669    change the definition to something the rest of the link can
1670    understand.  */
1671
1672 static bfd_boolean
1673 elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info *info,
1674                                   struct elf_link_hash_entry *eh)
1675 {
1676   struct elf32_hppa_link_hash_table *htab;
1677   asection *sec, *srel;
1678
1679   /* If this is a function, put it in the procedure linkage table.  We
1680      will fill in the contents of the procedure linkage table later.  */
1681   if (eh->type == STT_FUNC
1682       || eh->needs_plt)
1683     {
1684       bfd_boolean local = (SYMBOL_CALLS_LOCAL (info, eh)
1685                            || UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh));
1686       /* Discard dyn_relocs when non-pic if we've decided that a
1687          function symbol is local.  */
1688       if (!bfd_link_pic (info) && local)
1689         hppa_elf_hash_entry (eh)->dyn_relocs = NULL;
1690
1691       /* If the symbol is used by a plabel, we must allocate a PLT slot.
1692          The refcounts are not reliable when it has been hidden since
1693          hide_symbol can be called before the plabel flag is set.  */
1694       if (hppa_elf_hash_entry (eh)->plabel)
1695         eh->plt.refcount = 1;
1696
1697       /* Note that unlike some other backends, the refcount is not
1698          incremented for a non-call (and non-plabel) function reference.  */
1699       else if (eh->plt.refcount <= 0
1700                || local)
1701         {
1702           /* The .plt entry is not needed when:
1703              a) Garbage collection has removed all references to the
1704              symbol, or
1705              b) We know for certain the symbol is defined in this
1706              object, and it's not a weak definition, nor is the symbol
1707              used by a plabel relocation.  Either this object is the
1708              application or we are doing a shared symbolic link.  */
1709           eh->plt.offset = (bfd_vma) -1;
1710           eh->needs_plt = 0;
1711         }
1712
1713       /* Unlike other targets, elf32-hppa.c does not define a function
1714          symbol in a non-pic executable on PLT stub code, so we don't
1715          have a local definition in that case.  ie. dyn_relocs can't
1716          be discarded.  */
1717
1718       /* Function symbols can't have copy relocs.  */
1719       return TRUE;
1720     }
1721   else
1722     eh->plt.offset = (bfd_vma) -1;
1723
1724   htab = hppa_link_hash_table (info);
1725   if (htab == NULL)
1726     return FALSE;
1727
1728   /* If this is a weak symbol, and there is a real definition, the
1729      processor independent code will have arranged for us to see the
1730      real definition first, and we can just use the same value.  */
1731   if (eh->is_weakalias)
1732     {
1733       struct elf_link_hash_entry *def = weakdef (eh);
1734       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
1735       eh->root.u.def.section = def->root.u.def.section;
1736       eh->root.u.def.value = def->root.u.def.value;
1737       if (def->root.u.def.section == htab->etab.sdynbss
1738           || def->root.u.def.section == htab->etab.sdynrelro)
1739         hppa_elf_hash_entry (eh)->dyn_relocs = NULL;
1740       return TRUE;
1741     }
1742
1743   /* This is a reference to a symbol defined by a dynamic object which
1744      is not a function.  */
1745
1746   /* If we are creating a shared library, we must presume that the
1747      only references to the symbol are via the global offset table.
1748      For such cases we need not do anything here; the relocations will
1749      be handled correctly by relocate_section.  */
1750   if (bfd_link_pic (info))
1751     return TRUE;
1752
1753   /* If there are no references to this symbol that do not use the
1754      GOT, we don't need to generate a copy reloc.  */
1755   if (!eh->non_got_ref)
1756     return TRUE;
1757
1758   /* If -z nocopyreloc was given, we won't generate them either.  */
1759   if (info->nocopyreloc)
1760     return TRUE;
1761
1762   /* If we don't find any dynamic relocs in read-only sections, then
1763      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
1764   if (ELIMINATE_COPY_RELOCS
1765       && !alias_readonly_dynrelocs (eh))
1766     return TRUE;
1767
1768   /* We must allocate the symbol in our .dynbss section, which will
1769      become part of the .bss section of the executable.  There will be
1770      an entry for this symbol in the .dynsym section.  The dynamic
1771      object will contain position independent code, so all references
1772      from the dynamic object to this symbol will go through the global
1773      offset table.  The dynamic linker will use the .dynsym entry to
1774      determine the address it must put in the global offset table, so
1775      both the dynamic object and the regular object will refer to the
1776      same memory location for the variable.  */
1777   if ((eh->root.u.def.section->flags & SEC_READONLY) != 0)
1778     {
1779       sec = htab->etab.sdynrelro;
1780       srel = htab->etab.sreldynrelro;
1781     }
1782   else
1783     {
1784       sec = htab->etab.sdynbss;
1785       srel = htab->etab.srelbss;
1786     }
1787   if ((eh->root.u.def.section->flags & SEC_ALLOC) != 0 && eh->size != 0)
1788     {
1789       /* We must generate a COPY reloc to tell the dynamic linker to
1790          copy the initial value out of the dynamic object and into the
1791          runtime process image.  */
1792       srel->size += sizeof (Elf32_External_Rela);
1793       eh->needs_copy = 1;
1794     }
1795
1796   /* We no longer want dyn_relocs.  */
1797   hppa_elf_hash_entry (eh)->dyn_relocs = NULL;
1798   return _bfd_elf_adjust_dynamic_copy (info, eh, sec);
1799 }
1800
1801 /* If EH is undefined, make it dynamic if that makes sense.  */
1802
1803 static bfd_boolean
1804 ensure_undef_dynamic (struct bfd_link_info *info,
1805                       struct elf_link_hash_entry *eh)
1806 {
1807   struct elf_link_hash_table *htab = elf_hash_table (info);
1808
1809   if (htab->dynamic_sections_created
1810       && (eh->root.type == bfd_link_hash_undefweak
1811           || eh->root.type == bfd_link_hash_undefined)
1812       && eh->dynindx == -1
1813       && !eh->forced_local
1814       && eh->type != STT_PARISC_MILLI
1815       && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh)
1816       && ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT)
1817     return bfd_elf_link_record_dynamic_symbol (info, eh);
1818   return TRUE;
1819 }
1820
1821 /* Allocate space in the .plt for entries that won't have relocations.
1822    ie. plabel entries.  */
1823
1824 static bfd_boolean
1825 allocate_plt_static (struct elf_link_hash_entry *eh, void *inf)
1826 {
1827   struct bfd_link_info *info;
1828   struct elf32_hppa_link_hash_table *htab;
1829   struct elf32_hppa_link_hash_entry *hh;
1830   asection *sec;
1831
1832   if (eh->root.type == bfd_link_hash_indirect)
1833     return TRUE;
1834
1835   info = (struct bfd_link_info *) inf;
1836   hh = hppa_elf_hash_entry (eh);
1837   htab = hppa_link_hash_table (info);
1838   if (htab == NULL)
1839     return FALSE;
1840
1841   if (htab->etab.dynamic_sections_created
1842       && eh->plt.refcount > 0)
1843     {
1844       if (!ensure_undef_dynamic (info, eh))
1845         return FALSE;
1846
1847       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), eh))
1848         {
1849           /* Allocate these later.  From this point on, h->plabel
1850              means that the plt entry is only used by a plabel.
1851              We'll be using a normal plt entry for this symbol, so
1852              clear the plabel indicator.  */
1853
1854           hh->plabel = 0;
1855         }
1856       else if (hh->plabel)
1857         {
1858           /* Make an entry in the .plt section for plabel references
1859              that won't have a .plt entry for other reasons.  */
1860           sec = htab->etab.splt;
1861           eh->plt.offset = sec->size;
1862           sec->size += PLT_ENTRY_SIZE;
1863           if (bfd_link_pic (info))
1864             htab->etab.srelplt->size += sizeof (Elf32_External_Rela);
1865         }
1866       else
1867         {
1868           /* No .plt entry needed.  */
1869           eh->plt.offset = (bfd_vma) -1;
1870           eh->needs_plt = 0;
1871         }
1872     }
1873   else
1874     {
1875       eh->plt.offset = (bfd_vma) -1;
1876       eh->needs_plt = 0;
1877     }
1878
1879   return TRUE;
1880 }
1881
1882 /* Calculate size of GOT entries for symbol given its TLS_TYPE.  */
1883
1884 static inline unsigned int
1885 got_entries_needed (int tls_type)
1886 {
1887   unsigned int need = 0;
1888
1889   if ((tls_type & GOT_NORMAL) != 0)
1890     need += GOT_ENTRY_SIZE;
1891   if ((tls_type & GOT_TLS_GD) != 0)
1892     need += GOT_ENTRY_SIZE * 2;
1893   if ((tls_type & GOT_TLS_IE) != 0)
1894     need += GOT_ENTRY_SIZE;
1895   return need;
1896 }
1897
1898 /* Calculate size of relocs needed for symbol given its TLS_TYPE and
1899    NEEDed GOT entries.  TPREL_KNOWN says a TPREL offset can be
1900    calculated at link time.  DTPREL_KNOWN says the same for a DTPREL
1901    offset.  */
1902
1903 static inline unsigned int
1904 got_relocs_needed (int tls_type, unsigned int need,
1905                    bfd_boolean dtprel_known, bfd_boolean tprel_known)
1906 {
1907   /* All the entries we allocated need relocs.
1908      Except for GD and IE with local symbols.  */
1909   if ((tls_type & GOT_TLS_GD) != 0 && dtprel_known)
1910     need -= GOT_ENTRY_SIZE;
1911   if ((tls_type & GOT_TLS_IE) != 0 && tprel_known)
1912     need -= GOT_ENTRY_SIZE;
1913   return need * sizeof (Elf32_External_Rela) / GOT_ENTRY_SIZE;
1914 }
1915
1916 /* Allocate space in .plt, .got and associated reloc sections for
1917    global syms.  */
1918
1919 static bfd_boolean
1920 allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
1921 {
1922   struct bfd_link_info *info;
1923   struct elf32_hppa_link_hash_table *htab;
1924   asection *sec;
1925   struct elf32_hppa_link_hash_entry *hh;
1926   struct elf_dyn_relocs *hdh_p;
1927
1928   if (eh->root.type == bfd_link_hash_indirect)
1929     return TRUE;
1930
1931   info = inf;
1932   htab = hppa_link_hash_table (info);
1933   if (htab == NULL)
1934     return FALSE;
1935
1936   hh = hppa_elf_hash_entry (eh);
1937
1938   if (htab->etab.dynamic_sections_created
1939       && eh->plt.offset != (bfd_vma) -1
1940       && !hh->plabel
1941       && eh->plt.refcount > 0)
1942     {
1943       /* Make an entry in the .plt section.  */
1944       sec = htab->etab.splt;
1945       eh->plt.offset = sec->size;
1946       sec->size += PLT_ENTRY_SIZE;
1947
1948       /* We also need to make an entry in the .rela.plt section.  */
1949       htab->etab.srelplt->size += sizeof (Elf32_External_Rela);
1950       htab->need_plt_stub = 1;
1951     }
1952
1953   if (eh->got.refcount > 0)
1954     {
1955       unsigned int need;
1956
1957       if (!ensure_undef_dynamic (info, eh))
1958         return FALSE;
1959
1960       sec = htab->etab.sgot;
1961       eh->got.offset = sec->size;
1962       need = got_entries_needed (hh->tls_type);
1963       sec->size += need;
1964       if (htab->etab.dynamic_sections_created
1965           && (bfd_link_dll (info)
1966               || (bfd_link_pic (info) && (hh->tls_type & GOT_NORMAL) != 0)
1967               || (eh->dynindx != -1
1968                   && !SYMBOL_REFERENCES_LOCAL (info, eh)))
1969           && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh))
1970         {
1971           bfd_boolean local = SYMBOL_REFERENCES_LOCAL (info, eh);
1972           htab->etab.srelgot->size
1973             += got_relocs_needed (hh->tls_type, need, local,
1974                                   local && bfd_link_executable (info));
1975         }
1976     }
1977   else
1978     eh->got.offset = (bfd_vma) -1;
1979
1980   /* If no dynamic sections we can't have dynamic relocs.  */
1981   if (!htab->etab.dynamic_sections_created)
1982     hh->dyn_relocs = NULL;
1983
1984   /* Discard relocs on undefined syms with non-default visibility.  */
1985   else if ((eh->root.type == bfd_link_hash_undefined
1986             && ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT)
1987            || UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh))
1988     hh->dyn_relocs = NULL;
1989
1990   if (hh->dyn_relocs == NULL)
1991     return TRUE;
1992
1993   /* If this is a -Bsymbolic shared link, then we need to discard all
1994      space allocated for dynamic pc-relative relocs against symbols
1995      defined in a regular object.  For the normal shared case, discard
1996      space for relocs that have become local due to symbol visibility
1997      changes.  */
1998   if (bfd_link_pic (info))
1999     {
2000 #if RELATIVE_DYNRELOCS
2001       if (SYMBOL_CALLS_LOCAL (info, eh))
2002         {
2003           struct elf_dyn_relocs **hdh_pp;
2004
2005           for (hdh_pp = &hh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
2006             {
2007               hdh_p->count -= hdh_p->pc_count;
2008               hdh_p->pc_count = 0;
2009               if (hdh_p->count == 0)
2010                 *hdh_pp = hdh_p->next;
2011               else
2012                 hdh_pp = &hdh_p->next;
2013             }
2014         }
2015 #endif
2016
2017       if (hh->dyn_relocs != NULL)
2018         {
2019           if (!ensure_undef_dynamic (info, eh))
2020             return FALSE;
2021         }
2022     }
2023   else if (ELIMINATE_COPY_RELOCS)
2024     {
2025       /* For the non-shared case, discard space for relocs against
2026          symbols which turn out to need copy relocs or are not
2027          dynamic.  */
2028
2029       if (eh->dynamic_adjusted
2030           && !eh->def_regular
2031           && !ELF_COMMON_DEF_P (eh))
2032         {
2033           if (!ensure_undef_dynamic (info, eh))
2034             return FALSE;
2035
2036           if (eh->dynindx == -1)
2037             hh->dyn_relocs = NULL;
2038         }
2039       else
2040         hh->dyn_relocs = NULL;
2041     }
2042
2043   /* Finally, allocate space.  */
2044   for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->next)
2045     {
2046       asection *sreloc = elf_section_data (hdh_p->sec)->sreloc;
2047       sreloc->size += hdh_p->count * sizeof (Elf32_External_Rela);
2048     }
2049
2050   return TRUE;
2051 }
2052
2053 /* This function is called via elf_link_hash_traverse to force
2054    millicode symbols local so they do not end up as globals in the
2055    dynamic symbol table.  We ought to be able to do this in
2056    adjust_dynamic_symbol, but our adjust_dynamic_symbol is not called
2057    for all dynamic symbols.  Arguably, this is a bug in
2058    elf_adjust_dynamic_symbol.  */
2059
2060 static bfd_boolean
2061 clobber_millicode_symbols (struct elf_link_hash_entry *eh,
2062                            struct bfd_link_info *info)
2063 {
2064   if (eh->type == STT_PARISC_MILLI
2065       && !eh->forced_local)
2066     {
2067       elf32_hppa_hide_symbol (info, eh, TRUE);
2068     }
2069   return TRUE;
2070 }
2071
2072 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
2073    read-only sections.  */
2074
2075 static bfd_boolean
2076 maybe_set_textrel (struct elf_link_hash_entry *eh, void *inf)
2077 {
2078   asection *sec;
2079
2080   if (eh->root.type == bfd_link_hash_indirect)
2081     return TRUE;
2082
2083   sec = readonly_dynrelocs (eh);
2084   if (sec != NULL)
2085     {
2086       struct bfd_link_info *info = (struct bfd_link_info *) inf;
2087
2088       info->flags |= DF_TEXTREL;
2089       info->callbacks->minfo
2090         (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
2091          sec->owner, eh->root.root.string, sec);
2092
2093       /* Not an error, just cut short the traversal.  */
2094       return FALSE;
2095     }
2096   return TRUE;
2097 }
2098
2099 /* Set the sizes of the dynamic sections.  */
2100
2101 static bfd_boolean
2102 elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2103                                   struct bfd_link_info *info)
2104 {
2105   struct elf32_hppa_link_hash_table *htab;
2106   bfd *dynobj;
2107   bfd *ibfd;
2108   asection *sec;
2109   bfd_boolean relocs;
2110
2111   htab = hppa_link_hash_table (info);
2112   if (htab == NULL)
2113     return FALSE;
2114
2115   dynobj = htab->etab.dynobj;
2116   if (dynobj == NULL)
2117     abort ();
2118
2119   if (htab->etab.dynamic_sections_created)
2120     {
2121       /* Set the contents of the .interp section to the interpreter.  */
2122       if (bfd_link_executable (info) && !info->nointerp)
2123         {
2124           sec = bfd_get_linker_section (dynobj, ".interp");
2125           if (sec == NULL)
2126             abort ();
2127           sec->size = sizeof ELF_DYNAMIC_INTERPRETER;
2128           sec->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2129         }
2130
2131       /* Force millicode symbols local.  */
2132       elf_link_hash_traverse (&htab->etab,
2133                               clobber_millicode_symbols,
2134                               info);
2135     }
2136
2137   /* Set up .got and .plt offsets for local syms, and space for local
2138      dynamic relocs.  */
2139   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2140     {
2141       bfd_signed_vma *local_got;
2142       bfd_signed_vma *end_local_got;
2143       bfd_signed_vma *local_plt;
2144       bfd_signed_vma *end_local_plt;
2145       bfd_size_type locsymcount;
2146       Elf_Internal_Shdr *symtab_hdr;
2147       asection *srel;
2148       char *local_tls_type;
2149
2150       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2151         continue;
2152
2153       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
2154         {
2155           struct elf_dyn_relocs *hdh_p;
2156
2157           for (hdh_p = ((struct elf_dyn_relocs *)
2158                     elf_section_data (sec)->local_dynrel);
2159                hdh_p != NULL;
2160                hdh_p = hdh_p->next)
2161             {
2162               if (!bfd_is_abs_section (hdh_p->sec)
2163                   && bfd_is_abs_section (hdh_p->sec->output_section))
2164                 {
2165                   /* Input section has been discarded, either because
2166                      it is a copy of a linkonce section or due to
2167                      linker script /DISCARD/, so we'll be discarding
2168                      the relocs too.  */
2169                 }
2170               else if (hdh_p->count != 0)
2171                 {
2172                   srel = elf_section_data (hdh_p->sec)->sreloc;
2173                   srel->size += hdh_p->count * sizeof (Elf32_External_Rela);
2174                   if ((hdh_p->sec->output_section->flags & SEC_READONLY) != 0)
2175                     info->flags |= DF_TEXTREL;
2176                 }
2177             }
2178         }
2179
2180       local_got = elf_local_got_refcounts (ibfd);
2181       if (!local_got)
2182         continue;
2183
2184       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2185       locsymcount = symtab_hdr->sh_info;
2186       end_local_got = local_got + locsymcount;
2187       local_tls_type = hppa_elf_local_got_tls_type (ibfd);
2188       sec = htab->etab.sgot;
2189       srel = htab->etab.srelgot;
2190       for (; local_got < end_local_got; ++local_got)
2191         {
2192           if (*local_got > 0)
2193             {
2194               unsigned int need;
2195
2196               *local_got = sec->size;
2197               need = got_entries_needed (*local_tls_type);
2198               sec->size += need;
2199               if (bfd_link_dll (info)
2200                   || (bfd_link_pic (info)
2201                       && (*local_tls_type & GOT_NORMAL) != 0))
2202                 htab->etab.srelgot->size
2203                   += got_relocs_needed (*local_tls_type, need, TRUE,
2204                                         bfd_link_executable (info));
2205             }
2206           else
2207             *local_got = (bfd_vma) -1;
2208
2209           ++local_tls_type;
2210         }
2211
2212       local_plt = end_local_got;
2213       end_local_plt = local_plt + locsymcount;
2214       if (! htab->etab.dynamic_sections_created)
2215         {
2216           /* Won't be used, but be safe.  */
2217           for (; local_plt < end_local_plt; ++local_plt)
2218             *local_plt = (bfd_vma) -1;
2219         }
2220       else
2221         {
2222           sec = htab->etab.splt;
2223           srel = htab->etab.srelplt;
2224           for (; local_plt < end_local_plt; ++local_plt)
2225             {
2226               if (*local_plt > 0)
2227                 {
2228                   *local_plt = sec->size;
2229                   sec->size += PLT_ENTRY_SIZE;
2230                   if (bfd_link_pic (info))
2231                     srel->size += sizeof (Elf32_External_Rela);
2232                 }
2233               else
2234                 *local_plt = (bfd_vma) -1;
2235             }
2236         }
2237     }
2238
2239   if (htab->tls_ldm_got.refcount > 0)
2240     {
2241       /* Allocate 2 got entries and 1 dynamic reloc for
2242          R_PARISC_TLS_DTPMOD32 relocs.  */
2243       htab->tls_ldm_got.offset = htab->etab.sgot->size;
2244       htab->etab.sgot->size += (GOT_ENTRY_SIZE * 2);
2245       htab->etab.srelgot->size += sizeof (Elf32_External_Rela);
2246     }
2247   else
2248     htab->tls_ldm_got.offset = -1;
2249
2250   /* Do all the .plt entries without relocs first.  The dynamic linker
2251      uses the last .plt reloc to find the end of the .plt (and hence
2252      the start of the .got) for lazy linking.  */
2253   elf_link_hash_traverse (&htab->etab, allocate_plt_static, info);
2254
2255   /* Allocate global sym .plt and .got entries, and space for global
2256      sym dynamic relocs.  */
2257   elf_link_hash_traverse (&htab->etab, allocate_dynrelocs, info);
2258
2259   /* The check_relocs and adjust_dynamic_symbol entry points have
2260      determined the sizes of the various dynamic sections.  Allocate
2261      memory for them.  */
2262   relocs = FALSE;
2263   for (sec = dynobj->sections; sec != NULL; sec = sec->next)
2264     {
2265       if ((sec->flags & SEC_LINKER_CREATED) == 0)
2266         continue;
2267
2268       if (sec == htab->etab.splt)
2269         {
2270           if (htab->need_plt_stub)
2271             {
2272               /* Make space for the plt stub at the end of the .plt
2273                  section.  We want this stub right at the end, up
2274                  against the .got section.  */
2275               int gotalign = bfd_section_alignment (dynobj, htab->etab.sgot);
2276               int pltalign = bfd_section_alignment (dynobj, sec);
2277               bfd_size_type mask;
2278
2279               if (gotalign > pltalign)
2280                 (void) bfd_set_section_alignment (dynobj, sec, gotalign);
2281               mask = ((bfd_size_type) 1 << gotalign) - 1;
2282               sec->size = (sec->size + sizeof (plt_stub) + mask) & ~mask;
2283             }
2284         }
2285       else if (sec == htab->etab.sgot
2286                || sec == htab->etab.sdynbss
2287                || sec == htab->etab.sdynrelro)
2288         ;
2289       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, sec), ".rela"))
2290         {
2291           if (sec->size != 0)
2292             {
2293               /* Remember whether there are any reloc sections other
2294                  than .rela.plt.  */
2295               if (sec != htab->etab.srelplt)
2296                 relocs = TRUE;
2297
2298               /* We use the reloc_count field as a counter if we need
2299                  to copy relocs into the output file.  */
2300               sec->reloc_count = 0;
2301             }
2302         }
2303       else
2304         {
2305           /* It's not one of our sections, so don't allocate space.  */
2306           continue;
2307         }
2308
2309       if (sec->size == 0)
2310         {
2311           /* If we don't need this section, strip it from the
2312              output file.  This is mostly to handle .rela.bss and
2313              .rela.plt.  We must create both sections in
2314              create_dynamic_sections, because they must be created
2315              before the linker maps input sections to output
2316              sections.  The linker does that before
2317              adjust_dynamic_symbol is called, and it is that
2318              function which decides whether anything needs to go
2319              into these sections.  */
2320           sec->flags |= SEC_EXCLUDE;
2321           continue;
2322         }
2323
2324       if ((sec->flags & SEC_HAS_CONTENTS) == 0)
2325         continue;
2326
2327       /* Allocate memory for the section contents.  Zero it, because
2328          we may not fill in all the reloc sections.  */
2329       sec->contents = bfd_zalloc (dynobj, sec->size);
2330       if (sec->contents == NULL)
2331         return FALSE;
2332     }
2333
2334   if (htab->etab.dynamic_sections_created)
2335     {
2336       /* Like IA-64 and HPPA64, always create a DT_PLTGOT.  It
2337          actually has nothing to do with the PLT, it is how we
2338          communicate the LTP value of a load module to the dynamic
2339          linker.  */
2340 #define add_dynamic_entry(TAG, VAL) \
2341   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2342
2343       if (!add_dynamic_entry (DT_PLTGOT, 0))
2344         return FALSE;
2345
2346       /* Add some entries to the .dynamic section.  We fill in the
2347          values later, in elf32_hppa_finish_dynamic_sections, but we
2348          must add the entries now so that we get the correct size for
2349          the .dynamic section.  The DT_DEBUG entry is filled in by the
2350          dynamic linker and used by the debugger.  */
2351       if (bfd_link_executable (info))
2352         {
2353           if (!add_dynamic_entry (DT_DEBUG, 0))
2354             return FALSE;
2355         }
2356
2357       if (htab->etab.srelplt->size != 0)
2358         {
2359           if (!add_dynamic_entry (DT_PLTRELSZ, 0)
2360               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2361               || !add_dynamic_entry (DT_JMPREL, 0))
2362             return FALSE;
2363         }
2364
2365       if (relocs)
2366         {
2367           if (!add_dynamic_entry (DT_RELA, 0)
2368               || !add_dynamic_entry (DT_RELASZ, 0)
2369               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
2370             return FALSE;
2371
2372           /* If any dynamic relocs apply to a read-only section,
2373              then we need a DT_TEXTREL entry.  */
2374           if ((info->flags & DF_TEXTREL) == 0)
2375             elf_link_hash_traverse (&htab->etab, maybe_set_textrel, info);
2376
2377           if ((info->flags & DF_TEXTREL) != 0)
2378             {
2379               if (!add_dynamic_entry (DT_TEXTREL, 0))
2380                 return FALSE;
2381             }
2382         }
2383     }
2384 #undef add_dynamic_entry
2385
2386   return TRUE;
2387 }
2388
2389 /* External entry points for sizing and building linker stubs.  */
2390
2391 /* Set up various things so that we can make a list of input sections
2392    for each output section included in the link.  Returns -1 on error,
2393    0 when no stubs will be needed, and 1 on success.  */
2394
2395 int
2396 elf32_hppa_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info)
2397 {
2398   bfd *input_bfd;
2399   unsigned int bfd_count;
2400   unsigned int top_id, top_index;
2401   asection *section;
2402   asection **input_list, **list;
2403   bfd_size_type amt;
2404   struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
2405
2406   if (htab == NULL)
2407     return -1;
2408
2409   /* Count the number of input BFDs and find the top input section id.  */
2410   for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
2411        input_bfd != NULL;
2412        input_bfd = input_bfd->link.next)
2413     {
2414       bfd_count += 1;
2415       for (section = input_bfd->sections;
2416            section != NULL;
2417            section = section->next)
2418         {
2419           if (top_id < section->id)
2420             top_id = section->id;
2421         }
2422     }
2423   htab->bfd_count = bfd_count;
2424
2425   amt = sizeof (struct map_stub) * (top_id + 1);
2426   htab->stub_group = bfd_zmalloc (amt);
2427   if (htab->stub_group == NULL)
2428     return -1;
2429
2430   /* We can't use output_bfd->section_count here to find the top output
2431      section index as some sections may have been removed, and
2432      strip_excluded_output_sections doesn't renumber the indices.  */
2433   for (section = output_bfd->sections, top_index = 0;
2434        section != NULL;
2435        section = section->next)
2436     {
2437       if (top_index < section->index)
2438         top_index = section->index;
2439     }
2440
2441   htab->top_index = top_index;
2442   amt = sizeof (asection *) * (top_index + 1);
2443   input_list = bfd_malloc (amt);
2444   htab->input_list = input_list;
2445   if (input_list == NULL)
2446     return -1;
2447
2448   /* For sections we aren't interested in, mark their entries with a
2449      value we can check later.  */
2450   list = input_list + top_index;
2451   do
2452     *list = bfd_abs_section_ptr;
2453   while (list-- != input_list);
2454
2455   for (section = output_bfd->sections;
2456        section != NULL;
2457        section = section->next)
2458     {
2459       if ((section->flags & SEC_CODE) != 0)
2460         input_list[section->index] = NULL;
2461     }
2462
2463   return 1;
2464 }
2465
2466 /* The linker repeatedly calls this function for each input section,
2467    in the order that input sections are linked into output sections.
2468    Build lists of input sections to determine groupings between which
2469    we may insert linker stubs.  */
2470
2471 void
2472 elf32_hppa_next_input_section (struct bfd_link_info *info, asection *isec)
2473 {
2474   struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
2475
2476   if (htab == NULL)
2477     return;
2478
2479   if (isec->output_section->index <= htab->top_index)
2480     {
2481       asection **list = htab->input_list + isec->output_section->index;
2482       if (*list != bfd_abs_section_ptr)
2483         {
2484           /* Steal the link_sec pointer for our list.  */
2485 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
2486           /* This happens to make the list in reverse order,
2487              which is what we want.  */
2488           PREV_SEC (isec) = *list;
2489           *list = isec;
2490         }
2491     }
2492 }
2493
2494 /* See whether we can group stub sections together.  Grouping stub
2495    sections may result in fewer stubs.  More importantly, we need to
2496    put all .init* and .fini* stubs at the beginning of the .init or
2497    .fini output sections respectively, because glibc splits the
2498    _init and _fini functions into multiple parts.  Putting a stub in
2499    the middle of a function is not a good idea.  */
2500
2501 static void
2502 group_sections (struct elf32_hppa_link_hash_table *htab,
2503                 bfd_size_type stub_group_size,
2504                 bfd_boolean stubs_always_before_branch)
2505 {
2506   asection **list = htab->input_list + htab->top_index;
2507   do
2508     {
2509       asection *tail = *list;
2510       if (tail == bfd_abs_section_ptr)
2511         continue;
2512       while (tail != NULL)
2513         {
2514           asection *curr;
2515           asection *prev;
2516           bfd_size_type total;
2517           bfd_boolean big_sec;
2518
2519           curr = tail;
2520           total = tail->size;
2521           big_sec = total >= stub_group_size;
2522
2523           while ((prev = PREV_SEC (curr)) != NULL
2524                  && ((total += curr->output_offset - prev->output_offset)
2525                      < stub_group_size))
2526             curr = prev;
2527
2528           /* OK, the size from the start of CURR to the end is less
2529              than 240000 bytes and thus can be handled by one stub
2530              section.  (or the tail section is itself larger than
2531              240000 bytes, in which case we may be toast.)
2532              We should really be keeping track of the total size of
2533              stubs added here, as stubs contribute to the final output
2534              section size.  That's a little tricky, and this way will
2535              only break if stubs added total more than 22144 bytes, or
2536              2768 long branch stubs.  It seems unlikely for more than
2537              2768 different functions to be called, especially from
2538              code only 240000 bytes long.  This limit used to be
2539              250000, but c++ code tends to generate lots of little
2540              functions, and sometimes violated the assumption.  */
2541           do
2542             {
2543               prev = PREV_SEC (tail);
2544               /* Set up this stub group.  */
2545               htab->stub_group[tail->id].link_sec = curr;
2546             }
2547           while (tail != curr && (tail = prev) != NULL);
2548
2549           /* But wait, there's more!  Input sections up to 240000
2550              bytes before the stub section can be handled by it too.
2551              Don't do this if we have a really large section after the
2552              stubs, as adding more stubs increases the chance that
2553              branches may not reach into the stub section.  */
2554           if (!stubs_always_before_branch && !big_sec)
2555             {
2556               total = 0;
2557               while (prev != NULL
2558                      && ((total += tail->output_offset - prev->output_offset)
2559                          < stub_group_size))
2560                 {
2561                   tail = prev;
2562                   prev = PREV_SEC (tail);
2563                   htab->stub_group[tail->id].link_sec = curr;
2564                 }
2565             }
2566           tail = prev;
2567         }
2568     }
2569   while (list-- != htab->input_list);
2570   free (htab->input_list);
2571 #undef PREV_SEC
2572 }
2573
2574 /* Read in all local syms for all input bfds, and create hash entries
2575    for export stubs if we are building a multi-subspace shared lib.
2576    Returns -1 on error, 1 if export stubs created, 0 otherwise.  */
2577
2578 static int
2579 get_local_syms (bfd *output_bfd, bfd *input_bfd, struct bfd_link_info *info)
2580 {
2581   unsigned int bfd_indx;
2582   Elf_Internal_Sym *local_syms, **all_local_syms;
2583   int stub_changed = 0;
2584   struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
2585
2586   if (htab == NULL)
2587     return -1;
2588
2589   /* We want to read in symbol extension records only once.  To do this
2590      we need to read in the local symbols in parallel and save them for
2591      later use; so hold pointers to the local symbols in an array.  */
2592   bfd_size_type amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
2593   all_local_syms = bfd_zmalloc (amt);
2594   htab->all_local_syms = all_local_syms;
2595   if (all_local_syms == NULL)
2596     return -1;
2597
2598   /* Walk over all the input BFDs, swapping in local symbols.
2599      If we are creating a shared library, create hash entries for the
2600      export stubs.  */
2601   for (bfd_indx = 0;
2602        input_bfd != NULL;
2603        input_bfd = input_bfd->link.next, bfd_indx++)
2604     {
2605       Elf_Internal_Shdr *symtab_hdr;
2606
2607       /* We'll need the symbol table in a second.  */
2608       symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2609       if (symtab_hdr->sh_info == 0)
2610         continue;
2611
2612       /* We need an array of the local symbols attached to the input bfd.  */
2613       local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
2614       if (local_syms == NULL)
2615         {
2616           local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2617                                              symtab_hdr->sh_info, 0,
2618                                              NULL, NULL, NULL);
2619           /* Cache them for elf_link_input_bfd.  */
2620           symtab_hdr->contents = (unsigned char *) local_syms;
2621         }
2622       if (local_syms == NULL)
2623         return -1;
2624
2625       all_local_syms[bfd_indx] = local_syms;
2626
2627       if (bfd_link_pic (info) && htab->multi_subspace)
2628         {
2629           struct elf_link_hash_entry **eh_syms;
2630           struct elf_link_hash_entry **eh_symend;
2631           unsigned int symcount;
2632
2633           symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2634                       - symtab_hdr->sh_info);
2635           eh_syms = (struct elf_link_hash_entry **) elf_sym_hashes (input_bfd);
2636           eh_symend = (struct elf_link_hash_entry **) (eh_syms + symcount);
2637
2638           /* Look through the global syms for functions;  We need to
2639              build export stubs for all globally visible functions.  */
2640           for (; eh_syms < eh_symend; eh_syms++)
2641             {
2642               struct elf32_hppa_link_hash_entry *hh;
2643
2644               hh = hppa_elf_hash_entry (*eh_syms);
2645
2646               while (hh->eh.root.type == bfd_link_hash_indirect
2647                      || hh->eh.root.type == bfd_link_hash_warning)
2648                    hh = hppa_elf_hash_entry (hh->eh.root.u.i.link);
2649
2650               /* At this point in the link, undefined syms have been
2651                  resolved, so we need to check that the symbol was
2652                  defined in this BFD.  */
2653               if ((hh->eh.root.type == bfd_link_hash_defined
2654                    || hh->eh.root.type == bfd_link_hash_defweak)
2655                   && hh->eh.type == STT_FUNC
2656                   && hh->eh.root.u.def.section->output_section != NULL
2657                   && (hh->eh.root.u.def.section->output_section->owner
2658                       == output_bfd)
2659                   && hh->eh.root.u.def.section->owner == input_bfd
2660                   && hh->eh.def_regular
2661                   && !hh->eh.forced_local
2662                   && ELF_ST_VISIBILITY (hh->eh.other) == STV_DEFAULT)
2663                 {
2664                   asection *sec;
2665                   const char *stub_name;
2666                   struct elf32_hppa_stub_hash_entry *hsh;
2667
2668                   sec = hh->eh.root.u.def.section;
2669                   stub_name = hh_name (hh);
2670                   hsh = hppa_stub_hash_lookup (&htab->bstab,
2671                                                       stub_name,
2672                                                       FALSE, FALSE);
2673                   if (hsh == NULL)
2674                     {
2675                       hsh = hppa_add_stub (stub_name, sec, htab);
2676                       if (!hsh)
2677                         return -1;
2678
2679                       hsh->target_value = hh->eh.root.u.def.value;
2680                       hsh->target_section = hh->eh.root.u.def.section;
2681                       hsh->stub_type = hppa_stub_export;
2682                       hsh->hh = hh;
2683                       stub_changed = 1;
2684                     }
2685                   else
2686                     {
2687                       /* xgettext:c-format */
2688                       _bfd_error_handler (_("%pB: duplicate export stub %s"),
2689                                           input_bfd, stub_name);
2690                     }
2691                 }
2692             }
2693         }
2694     }
2695
2696   return stub_changed;
2697 }
2698
2699 /* Determine and set the size of the stub section for a final link.
2700
2701    The basic idea here is to examine all the relocations looking for
2702    PC-relative calls to a target that is unreachable with a "bl"
2703    instruction.  */
2704
2705 bfd_boolean
2706 elf32_hppa_size_stubs
2707   (bfd *output_bfd, bfd *stub_bfd, struct bfd_link_info *info,
2708    bfd_boolean multi_subspace, bfd_signed_vma group_size,
2709    asection * (*add_stub_section) (const char *, asection *),
2710    void (*layout_sections_again) (void))
2711 {
2712   bfd_size_type stub_group_size;
2713   bfd_boolean stubs_always_before_branch;
2714   bfd_boolean stub_changed;
2715   struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
2716
2717   if (htab == NULL)
2718     return FALSE;
2719
2720   /* Stash our params away.  */
2721   htab->stub_bfd = stub_bfd;
2722   htab->multi_subspace = multi_subspace;
2723   htab->add_stub_section = add_stub_section;
2724   htab->layout_sections_again = layout_sections_again;
2725   stubs_always_before_branch = group_size < 0;
2726   if (group_size < 0)
2727     stub_group_size = -group_size;
2728   else
2729     stub_group_size = group_size;
2730   if (stub_group_size == 1)
2731     {
2732       /* Default values.  */
2733       if (stubs_always_before_branch)
2734         {
2735           stub_group_size = 7680000;
2736           if (htab->has_17bit_branch || htab->multi_subspace)
2737             stub_group_size = 240000;
2738           if (htab->has_12bit_branch)
2739             stub_group_size = 7500;
2740         }
2741       else
2742         {
2743           stub_group_size = 6971392;
2744           if (htab->has_17bit_branch || htab->multi_subspace)
2745             stub_group_size = 217856;
2746           if (htab->has_12bit_branch)
2747             stub_group_size = 6808;
2748         }
2749     }
2750
2751   group_sections (htab, stub_group_size, stubs_always_before_branch);
2752
2753   switch (get_local_syms (output_bfd, info->input_bfds, info))
2754     {
2755     default:
2756       if (htab->all_local_syms)
2757         goto error_ret_free_local;
2758       return FALSE;
2759
2760     case 0:
2761       stub_changed = FALSE;
2762       break;
2763
2764     case 1:
2765       stub_changed = TRUE;
2766       break;
2767     }
2768
2769   while (1)
2770     {
2771       bfd *input_bfd;
2772       unsigned int bfd_indx;
2773       asection *stub_sec;
2774
2775       for (input_bfd = info->input_bfds, bfd_indx = 0;
2776            input_bfd != NULL;
2777            input_bfd = input_bfd->link.next, bfd_indx++)
2778         {
2779           Elf_Internal_Shdr *symtab_hdr;
2780           asection *section;
2781           Elf_Internal_Sym *local_syms;
2782
2783           /* We'll need the symbol table in a second.  */
2784           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2785           if (symtab_hdr->sh_info == 0)
2786             continue;
2787
2788           local_syms = htab->all_local_syms[bfd_indx];
2789
2790           /* Walk over each section attached to the input bfd.  */
2791           for (section = input_bfd->sections;
2792                section != NULL;
2793                section = section->next)
2794             {
2795               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
2796
2797               /* If there aren't any relocs, then there's nothing more
2798                  to do.  */
2799               if ((section->flags & SEC_RELOC) == 0
2800                   || (section->flags & SEC_ALLOC) == 0
2801                   || (section->flags & SEC_LOAD) == 0
2802                   || (section->flags & SEC_CODE) == 0
2803                   || section->reloc_count == 0)
2804                 continue;
2805
2806               /* If this section is a link-once section that will be
2807                  discarded, then don't create any stubs.  */
2808               if (section->output_section == NULL
2809                   || section->output_section->owner != output_bfd)
2810                 continue;
2811
2812               /* Get the relocs.  */
2813               internal_relocs
2814                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
2815                                              info->keep_memory);
2816               if (internal_relocs == NULL)
2817                 goto error_ret_free_local;
2818
2819               /* Now examine each relocation.  */
2820               irela = internal_relocs;
2821               irelaend = irela + section->reloc_count;
2822               for (; irela < irelaend; irela++)
2823                 {
2824                   unsigned int r_type, r_indx;
2825                   enum elf32_hppa_stub_type stub_type;
2826                   struct elf32_hppa_stub_hash_entry *hsh;
2827                   asection *sym_sec;
2828                   bfd_vma sym_value;
2829                   bfd_vma destination;
2830                   struct elf32_hppa_link_hash_entry *hh;
2831                   char *stub_name;
2832                   const asection *id_sec;
2833
2834                   r_type = ELF32_R_TYPE (irela->r_info);
2835                   r_indx = ELF32_R_SYM (irela->r_info);
2836
2837                   if (r_type >= (unsigned int) R_PARISC_UNIMPLEMENTED)
2838                     {
2839                       bfd_set_error (bfd_error_bad_value);
2840                     error_ret_free_internal:
2841                       if (elf_section_data (section)->relocs == NULL)
2842                         free (internal_relocs);
2843                       goto error_ret_free_local;
2844                     }
2845
2846                   /* Only look for stubs on call instructions.  */
2847                   if (r_type != (unsigned int) R_PARISC_PCREL12F
2848                       && r_type != (unsigned int) R_PARISC_PCREL17F
2849                       && r_type != (unsigned int) R_PARISC_PCREL22F)
2850                     continue;
2851
2852                   /* Now determine the call target, its name, value,
2853                      section.  */
2854                   sym_sec = NULL;
2855                   sym_value = 0;
2856                   destination = -1;
2857                   hh = NULL;
2858                   if (r_indx < symtab_hdr->sh_info)
2859                     {
2860                       /* It's a local symbol.  */
2861                       Elf_Internal_Sym *sym;
2862                       Elf_Internal_Shdr *hdr;
2863                       unsigned int shndx;
2864
2865                       sym = local_syms + r_indx;
2866                       if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2867                         sym_value = sym->st_value;
2868                       shndx = sym->st_shndx;
2869                       if (shndx < elf_numsections (input_bfd))
2870                         {
2871                           hdr = elf_elfsections (input_bfd)[shndx];
2872                           sym_sec = hdr->bfd_section;
2873                           destination = (sym_value + irela->r_addend
2874                                          + sym_sec->output_offset
2875                                          + sym_sec->output_section->vma);
2876                         }
2877                     }
2878                   else
2879                     {
2880                       /* It's an external symbol.  */
2881                       int e_indx;
2882
2883                       e_indx = r_indx - symtab_hdr->sh_info;
2884                       hh = hppa_elf_hash_entry (elf_sym_hashes (input_bfd)[e_indx]);
2885
2886                       while (hh->eh.root.type == bfd_link_hash_indirect
2887                              || hh->eh.root.type == bfd_link_hash_warning)
2888                         hh = hppa_elf_hash_entry (hh->eh.root.u.i.link);
2889
2890                       if (hh->eh.root.type == bfd_link_hash_defined
2891                           || hh->eh.root.type == bfd_link_hash_defweak)
2892                         {
2893                           sym_sec = hh->eh.root.u.def.section;
2894                           sym_value = hh->eh.root.u.def.value;
2895                           if (sym_sec->output_section != NULL)
2896                             destination = (sym_value + irela->r_addend
2897                                            + sym_sec->output_offset
2898                                            + sym_sec->output_section->vma);
2899                         }
2900                       else if (hh->eh.root.type == bfd_link_hash_undefweak)
2901                         {
2902                           if (! bfd_link_pic (info))
2903                             continue;
2904                         }
2905                       else if (hh->eh.root.type == bfd_link_hash_undefined)
2906                         {
2907                           if (! (info->unresolved_syms_in_objects == RM_IGNORE
2908                                  && (ELF_ST_VISIBILITY (hh->eh.other)
2909                                      == STV_DEFAULT)
2910                                  && hh->eh.type != STT_PARISC_MILLI))
2911                             continue;
2912                         }
2913                       else
2914                         {
2915                           bfd_set_error (bfd_error_bad_value);
2916                           goto error_ret_free_internal;
2917                         }
2918                     }
2919
2920                   /* Determine what (if any) linker stub is needed.  */
2921                   stub_type = hppa_type_of_stub (section, irela, hh,
2922                                                  destination, info);
2923                   if (stub_type == hppa_stub_none)
2924                     continue;
2925
2926                   /* Support for grouping stub sections.  */
2927                   id_sec = htab->stub_group[section->id].link_sec;
2928
2929                   /* Get the name of this stub.  */
2930                   stub_name = hppa_stub_name (id_sec, sym_sec, hh, irela);
2931                   if (!stub_name)
2932                     goto error_ret_free_internal;
2933
2934                   hsh = hppa_stub_hash_lookup (&htab->bstab,
2935                                                       stub_name,
2936                                                       FALSE, FALSE);
2937                   if (hsh != NULL)
2938                     {
2939                       /* The proper stub has already been created.  */
2940                       free (stub_name);
2941                       continue;
2942                     }
2943
2944                   hsh = hppa_add_stub (stub_name, section, htab);
2945                   if (hsh == NULL)
2946                     {
2947                       free (stub_name);
2948                       goto error_ret_free_internal;
2949                     }
2950
2951                   hsh->target_value = sym_value;
2952                   hsh->target_section = sym_sec;
2953                   hsh->stub_type = stub_type;
2954                   if (bfd_link_pic (info))
2955                     {
2956                       if (stub_type == hppa_stub_import)
2957                         hsh->stub_type = hppa_stub_import_shared;
2958                       else if (stub_type == hppa_stub_long_branch)
2959                         hsh->stub_type = hppa_stub_long_branch_shared;
2960                     }
2961                   hsh->hh = hh;
2962                   stub_changed = TRUE;
2963                 }
2964
2965               /* We're done with the internal relocs, free them.  */
2966               if (elf_section_data (section)->relocs == NULL)
2967                 free (internal_relocs);
2968             }
2969         }
2970
2971       if (!stub_changed)
2972         break;
2973
2974       /* OK, we've added some stubs.  Find out the new size of the
2975          stub sections.  */
2976       for (stub_sec = htab->stub_bfd->sections;
2977            stub_sec != NULL;
2978            stub_sec = stub_sec->next)
2979         if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
2980           stub_sec->size = 0;
2981
2982       bfd_hash_traverse (&htab->bstab, hppa_size_one_stub, htab);
2983
2984       /* Ask the linker to do its stuff.  */
2985       (*htab->layout_sections_again) ();
2986       stub_changed = FALSE;
2987     }
2988
2989   free (htab->all_local_syms);
2990   return TRUE;
2991
2992  error_ret_free_local:
2993   free (htab->all_local_syms);
2994   return FALSE;
2995 }
2996
2997 /* For a final link, this function is called after we have sized the
2998    stubs to provide a value for __gp.  */
2999
3000 bfd_boolean
3001 elf32_hppa_set_gp (bfd *abfd, struct bfd_link_info *info)
3002 {
3003   struct bfd_link_hash_entry *h;
3004   asection *sec = NULL;
3005   bfd_vma gp_val = 0;
3006
3007   h = bfd_link_hash_lookup (info->hash, "$global$", FALSE, FALSE, FALSE);
3008
3009   if (h != NULL
3010       && (h->type == bfd_link_hash_defined
3011           || h->type == bfd_link_hash_defweak))
3012     {
3013       gp_val = h->u.def.value;
3014       sec = h->u.def.section;
3015     }
3016   else
3017     {
3018       asection *splt = bfd_get_section_by_name (abfd, ".plt");
3019       asection *sgot = bfd_get_section_by_name (abfd, ".got");
3020
3021       /* Choose to point our LTP at, in this order, one of .plt, .got,
3022          or .data, if these sections exist.  In the case of choosing
3023          .plt try to make the LTP ideal for addressing anywhere in the
3024          .plt or .got with a 14 bit signed offset.  Typically, the end
3025          of the .plt is the start of the .got, so choose .plt + 0x2000
3026          if either the .plt or .got is larger than 0x2000.  If both
3027          the .plt and .got are smaller than 0x2000, choose the end of
3028          the .plt section.  */
3029       sec = strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") == 0
3030           ? NULL : splt;
3031       if (sec != NULL)
3032         {
3033           gp_val = sec->size;
3034           if (gp_val > 0x2000 || (sgot && sgot->size > 0x2000))
3035             {
3036               gp_val = 0x2000;
3037             }
3038         }
3039       else
3040         {
3041           sec = sgot;
3042           if (sec != NULL)
3043             {
3044               if (strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") != 0)
3045                 {
3046                   /* We know we don't have a .plt.  If .got is large,
3047                      offset our LTP.  */
3048                   if (sec->size > 0x2000)
3049                     gp_val = 0x2000;
3050                 }
3051             }
3052           else
3053             {
3054               /* No .plt or .got.  Who cares what the LTP is?  */
3055               sec = bfd_get_section_by_name (abfd, ".data");
3056             }
3057         }
3058
3059       if (h != NULL)
3060         {
3061           h->type = bfd_link_hash_defined;
3062           h->u.def.value = gp_val;
3063           if (sec != NULL)
3064             h->u.def.section = sec;
3065           else
3066             h->u.def.section = bfd_abs_section_ptr;
3067         }
3068     }
3069
3070   if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
3071     {
3072       if (sec != NULL && sec->output_section != NULL)
3073         gp_val += sec->output_section->vma + sec->output_offset;
3074
3075       elf_gp (abfd) = gp_val;
3076     }
3077   return TRUE;
3078 }
3079
3080 /* Build all the stubs associated with the current output file.  The
3081    stubs are kept in a hash table attached to the main linker hash
3082    table.  We also set up the .plt entries for statically linked PIC
3083    functions here.  This function is called via hppaelf_finish in the
3084    linker.  */
3085
3086 bfd_boolean
3087 elf32_hppa_build_stubs (struct bfd_link_info *info)
3088 {
3089   asection *stub_sec;
3090   struct bfd_hash_table *table;
3091   struct elf32_hppa_link_hash_table *htab;
3092
3093   htab = hppa_link_hash_table (info);
3094   if (htab == NULL)
3095     return FALSE;
3096
3097   for (stub_sec = htab->stub_bfd->sections;
3098        stub_sec != NULL;
3099        stub_sec = stub_sec->next)
3100     if ((stub_sec->flags & SEC_LINKER_CREATED) == 0
3101         && stub_sec->size != 0)
3102       {
3103         /* Allocate memory to hold the linker stubs.  */
3104         stub_sec->contents = bfd_zalloc (htab->stub_bfd, stub_sec->size);
3105         if (stub_sec->contents == NULL)
3106           return FALSE;
3107         stub_sec->size = 0;
3108       }
3109
3110   /* Build the stubs as directed by the stub hash table.  */
3111   table = &htab->bstab;
3112   bfd_hash_traverse (table, hppa_build_one_stub, info);
3113
3114   return TRUE;
3115 }
3116
3117 /* Return the base vma address which should be subtracted from the real
3118    address when resolving a dtpoff relocation.
3119    This is PT_TLS segment p_vaddr.  */
3120
3121 static bfd_vma
3122 dtpoff_base (struct bfd_link_info *info)
3123 {
3124   /* If tls_sec is NULL, we should have signalled an error already.  */
3125   if (elf_hash_table (info)->tls_sec == NULL)
3126     return 0;
3127   return elf_hash_table (info)->tls_sec->vma;
3128 }
3129
3130 /* Return the relocation value for R_PARISC_TLS_TPOFF*..  */
3131
3132 static bfd_vma
3133 tpoff (struct bfd_link_info *info, bfd_vma address)
3134 {
3135   struct elf_link_hash_table *htab = elf_hash_table (info);
3136
3137   /* If tls_sec is NULL, we should have signalled an error already.  */
3138   if (htab->tls_sec == NULL)
3139     return 0;
3140   /* hppa TLS ABI is variant I and static TLS block start just after
3141      tcbhead structure which has 2 pointer fields.  */
3142   return (address - htab->tls_sec->vma
3143           + align_power ((bfd_vma) 8, htab->tls_sec->alignment_power));
3144 }
3145
3146 /* Perform a final link.  */
3147
3148 static bfd_boolean
3149 elf32_hppa_final_link (bfd *abfd, struct bfd_link_info *info)
3150 {
3151   struct stat buf;
3152
3153   /* Invoke the regular ELF linker to do all the work.  */
3154   if (!bfd_elf_final_link (abfd, info))
3155     return FALSE;
3156
3157   /* If we're producing a final executable, sort the contents of the
3158      unwind section.  */
3159   if (bfd_link_relocatable (info))
3160     return TRUE;
3161
3162   /* Do not attempt to sort non-regular files.  This is here
3163      especially for configure scripts and kernel builds which run
3164      tests with "ld [...] -o /dev/null".  */
3165   if (stat (abfd->filename, &buf) != 0
3166       || !S_ISREG(buf.st_mode))
3167     return TRUE;
3168
3169   return elf_hppa_sort_unwind (abfd);
3170 }
3171
3172 /* Record the lowest address for the data and text segments.  */
3173
3174 static void
3175 hppa_record_segment_addr (bfd *abfd, asection *section, void *data)
3176 {
3177   struct elf32_hppa_link_hash_table *htab;
3178
3179   htab = (struct elf32_hppa_link_hash_table*) data;
3180   if (htab == NULL)
3181     return;
3182
3183   if ((section->flags & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3184     {
3185       bfd_vma value;
3186       Elf_Internal_Phdr *p;
3187
3188       p = _bfd_elf_find_segment_containing_section (abfd, section->output_section);
3189       BFD_ASSERT (p != NULL);
3190       value = p->p_vaddr;
3191
3192       if ((section->flags & SEC_READONLY) != 0)
3193         {
3194           if (value < htab->text_segment_base)
3195             htab->text_segment_base = value;
3196         }
3197       else
3198         {
3199           if (value < htab->data_segment_base)
3200             htab->data_segment_base = value;
3201         }
3202     }
3203 }
3204
3205 /* Perform a relocation as part of a final link.  */
3206
3207 static bfd_reloc_status_type
3208 final_link_relocate (asection *input_section,
3209                      bfd_byte *contents,
3210                      const Elf_Internal_Rela *rela,
3211                      bfd_vma value,
3212                      struct elf32_hppa_link_hash_table *htab,
3213                      asection *sym_sec,
3214                      struct elf32_hppa_link_hash_entry *hh,
3215                      struct bfd_link_info *info)
3216 {
3217   int insn;
3218   unsigned int r_type = ELF32_R_TYPE (rela->r_info);
3219   unsigned int orig_r_type = r_type;
3220   reloc_howto_type *howto = elf_hppa_howto_table + r_type;
3221   int r_format = howto->bitsize;
3222   enum hppa_reloc_field_selector_type_alt r_field;
3223   bfd *input_bfd = input_section->owner;
3224   bfd_vma offset = rela->r_offset;
3225   bfd_vma max_branch_offset = 0;
3226   bfd_byte *hit_data = contents + offset;
3227   bfd_signed_vma addend = rela->r_addend;
3228   bfd_vma location;
3229   struct elf32_hppa_stub_hash_entry *hsh = NULL;
3230   int val;
3231
3232   if (r_type == R_PARISC_NONE)
3233     return bfd_reloc_ok;
3234
3235   insn = bfd_get_32 (input_bfd, hit_data);
3236
3237   /* Find out where we are and where we're going.  */
3238   location = (offset +
3239               input_section->output_offset +
3240               input_section->output_section->vma);
3241
3242   /* If we are not building a shared library, convert DLTIND relocs to
3243      DPREL relocs.  */
3244   if (!bfd_link_pic (info))
3245     {
3246       switch (r_type)
3247         {
3248           case R_PARISC_DLTIND21L:
3249           case R_PARISC_TLS_GD21L:
3250           case R_PARISC_TLS_LDM21L:
3251           case R_PARISC_TLS_IE21L:
3252             r_type = R_PARISC_DPREL21L;
3253             break;
3254
3255           case R_PARISC_DLTIND14R:
3256           case R_PARISC_TLS_GD14R:
3257           case R_PARISC_TLS_LDM14R:
3258           case R_PARISC_TLS_IE14R:
3259             r_type = R_PARISC_DPREL14R;
3260             break;
3261
3262           case R_PARISC_DLTIND14F:
3263             r_type = R_PARISC_DPREL14F;
3264             break;
3265         }
3266     }
3267
3268   switch (r_type)
3269     {
3270     case R_PARISC_PCREL12F:
3271     case R_PARISC_PCREL17F:
3272     case R_PARISC_PCREL22F:
3273       /* If this call should go via the plt, find the import stub in
3274          the stub hash.  */
3275       if (sym_sec == NULL
3276           || sym_sec->output_section == NULL
3277           || (hh != NULL
3278               && hh->eh.plt.offset != (bfd_vma) -1
3279               && hh->eh.dynindx != -1
3280               && !hh->plabel
3281               && (bfd_link_pic (info)
3282                   || !hh->eh.def_regular
3283                   || hh->eh.root.type == bfd_link_hash_defweak)))
3284         {
3285           hsh = hppa_get_stub_entry (input_section, sym_sec,
3286                                      hh, rela, htab);
3287           if (hsh != NULL)
3288             {
3289               value = (hsh->stub_offset
3290                        + hsh->stub_sec->output_offset
3291                        + hsh->stub_sec->output_section->vma);
3292               addend = 0;
3293             }
3294           else if (sym_sec == NULL && hh != NULL
3295                    && hh->eh.root.type == bfd_link_hash_undefweak)
3296             {
3297               /* It's OK if undefined weak.  Calls to undefined weak
3298                  symbols behave as if the "called" function
3299                  immediately returns.  We can thus call to a weak
3300                  function without first checking whether the function
3301                  is defined.  */
3302               value = location;
3303               addend = 8;
3304             }
3305           else
3306             return bfd_reloc_undefined;
3307         }
3308       /* Fall thru.  */
3309
3310     case R_PARISC_PCREL21L:
3311     case R_PARISC_PCREL17C:
3312     case R_PARISC_PCREL17R:
3313     case R_PARISC_PCREL14R:
3314     case R_PARISC_PCREL14F:
3315     case R_PARISC_PCREL32:
3316       /* Make it a pc relative offset.  */
3317       value -= location;
3318       addend -= 8;
3319       break;
3320
3321     case R_PARISC_DPREL21L:
3322     case R_PARISC_DPREL14R:
3323     case R_PARISC_DPREL14F:
3324       /* Convert instructions that use the linkage table pointer (r19) to
3325          instructions that use the global data pointer (dp).  This is the
3326          most efficient way of using PIC code in an incomplete executable,
3327          but the user must follow the standard runtime conventions for
3328          accessing data for this to work.  */
3329       if (orig_r_type != r_type)
3330         {
3331           if (r_type == R_PARISC_DPREL21L)
3332             {
3333               /* GCC sometimes uses a register other than r19 for the
3334                  operation, so we must convert any addil instruction
3335                  that uses this relocation.  */
3336               if ((insn & 0xfc000000) == ((int) OP_ADDIL << 26))
3337                 insn = ADDIL_DP;
3338               else
3339                 /* We must have a ldil instruction.  It's too hard to find
3340                    and convert the associated add instruction, so issue an
3341                    error.  */
3342                 _bfd_error_handler
3343                   /* xgettext:c-format */
3344                   (_("%pB(%pA+%#" PRIx64 "): %s fixup for insn %#x "
3345                      "is not supported in a non-shared link"),
3346                    input_bfd,
3347                    input_section,
3348                    (uint64_t) offset,
3349                    howto->name,
3350                    insn);
3351             }
3352           else if (r_type == R_PARISC_DPREL14F)
3353             {
3354               /* This must be a format 1 load/store.  Change the base
3355                  register to dp.  */
3356               insn = (insn & 0xfc1ffff) | (27 << 21);
3357             }
3358         }
3359
3360       /* For all the DP relative relocations, we need to examine the symbol's
3361          section.  If it has no section or if it's a code section, then
3362          "data pointer relative" makes no sense.  In that case we don't
3363          adjust the "value", and for 21 bit addil instructions, we change the
3364          source addend register from %dp to %r0.  This situation commonly
3365          arises for undefined weak symbols and when a variable's "constness"
3366          is declared differently from the way the variable is defined.  For
3367          instance: "extern int foo" with foo defined as "const int foo".  */
3368       if (sym_sec == NULL || (sym_sec->flags & SEC_CODE) != 0)
3369         {
3370           if ((insn & ((0x3f << 26) | (0x1f << 21)))
3371               == (((int) OP_ADDIL << 26) | (27 << 21)))
3372             {
3373               insn &= ~ (0x1f << 21);
3374             }
3375           /* Now try to make things easy for the dynamic linker.  */
3376
3377           break;
3378         }
3379       /* Fall thru.  */
3380
3381     case R_PARISC_DLTIND21L:
3382     case R_PARISC_DLTIND14R:
3383     case R_PARISC_DLTIND14F:
3384     case R_PARISC_TLS_GD21L:
3385     case R_PARISC_TLS_LDM21L:
3386     case R_PARISC_TLS_IE21L:
3387     case R_PARISC_TLS_GD14R:
3388     case R_PARISC_TLS_LDM14R:
3389     case R_PARISC_TLS_IE14R:
3390       value -= elf_gp (input_section->output_section->owner);
3391       break;
3392
3393     case R_PARISC_SEGREL32:
3394       if ((sym_sec->flags & SEC_CODE) != 0)
3395         value -= htab->text_segment_base;
3396       else
3397         value -= htab->data_segment_base;
3398       break;
3399
3400     default:
3401       break;
3402     }
3403
3404   switch (r_type)
3405     {
3406     case R_PARISC_DIR32:
3407     case R_PARISC_DIR14F:
3408     case R_PARISC_DIR17F:
3409     case R_PARISC_PCREL17C:
3410     case R_PARISC_PCREL14F:
3411     case R_PARISC_PCREL32:
3412     case R_PARISC_DPREL14F:
3413     case R_PARISC_PLABEL32:
3414     case R_PARISC_DLTIND14F:
3415     case R_PARISC_SEGBASE:
3416     case R_PARISC_SEGREL32:
3417     case R_PARISC_TLS_DTPMOD32:
3418     case R_PARISC_TLS_DTPOFF32:
3419     case R_PARISC_TLS_TPREL32:
3420       r_field = e_fsel;
3421       break;
3422
3423     case R_PARISC_DLTIND21L:
3424     case R_PARISC_PCREL21L:
3425     case R_PARISC_PLABEL21L:
3426       r_field = e_lsel;
3427       break;
3428
3429     case R_PARISC_DIR21L:
3430     case R_PARISC_DPREL21L:
3431     case R_PARISC_TLS_GD21L:
3432     case R_PARISC_TLS_LDM21L:
3433     case R_PARISC_TLS_LDO21L:
3434     case R_PARISC_TLS_IE21L:
3435     case R_PARISC_TLS_LE21L:
3436       r_field = e_lrsel;
3437       break;
3438
3439     case R_PARISC_PCREL17R:
3440     case R_PARISC_PCREL14R:
3441     case R_PARISC_PLABEL14R:
3442     case R_PARISC_DLTIND14R:
3443       r_field = e_rsel;
3444       break;
3445
3446     case R_PARISC_DIR17R:
3447     case R_PARISC_DIR14R:
3448     case R_PARISC_DPREL14R:
3449     case R_PARISC_TLS_GD14R:
3450     case R_PARISC_TLS_LDM14R:
3451     case R_PARISC_TLS_LDO14R:
3452     case R_PARISC_TLS_IE14R:
3453     case R_PARISC_TLS_LE14R:
3454       r_field = e_rrsel;
3455       break;
3456
3457     case R_PARISC_PCREL12F:
3458     case R_PARISC_PCREL17F:
3459     case R_PARISC_PCREL22F:
3460       r_field = e_fsel;
3461
3462       if (r_type == (unsigned int) R_PARISC_PCREL17F)
3463         {
3464           max_branch_offset = (1 << (17-1)) << 2;
3465         }
3466       else if (r_type == (unsigned int) R_PARISC_PCREL12F)
3467         {
3468           max_branch_offset = (1 << (12-1)) << 2;
3469         }
3470       else
3471         {
3472           max_branch_offset = (1 << (22-1)) << 2;
3473         }
3474
3475       /* sym_sec is NULL on undefined weak syms or when shared on
3476          undefined syms.  We've already checked for a stub for the
3477          shared undefined case.  */
3478       if (sym_sec == NULL)
3479         break;
3480
3481       /* If the branch is out of reach, then redirect the
3482          call to the local stub for this function.  */
3483       if (value + addend + max_branch_offset >= 2*max_branch_offset)
3484         {
3485           hsh = hppa_get_stub_entry (input_section, sym_sec,
3486                                      hh, rela, htab);
3487           if (hsh == NULL)
3488             return bfd_reloc_undefined;
3489
3490           /* Munge up the value and addend so that we call the stub
3491              rather than the procedure directly.  */
3492           value = (hsh->stub_offset
3493                    + hsh->stub_sec->output_offset
3494                    + hsh->stub_sec->output_section->vma
3495                    - location);
3496           addend = -8;
3497         }
3498       break;
3499
3500     /* Something we don't know how to handle.  */
3501     default:
3502       return bfd_reloc_notsupported;
3503     }
3504
3505   /* Make sure we can reach the stub.  */
3506   if (max_branch_offset != 0
3507       && value + addend + max_branch_offset >= 2*max_branch_offset)
3508     {
3509       _bfd_error_handler
3510         /* xgettext:c-format */
3511         (_("%pB(%pA+%#" PRIx64 "): cannot reach %s, "
3512            "recompile with -ffunction-sections"),
3513          input_bfd,
3514          input_section,
3515          (uint64_t) offset,
3516          hsh->bh_root.string);
3517       bfd_set_error (bfd_error_bad_value);
3518       return bfd_reloc_notsupported;
3519     }
3520
3521   val = hppa_field_adjust (value, addend, r_field);
3522
3523   switch (r_type)
3524     {
3525     case R_PARISC_PCREL12F:
3526     case R_PARISC_PCREL17C:
3527     case R_PARISC_PCREL17F:
3528     case R_PARISC_PCREL17R:
3529     case R_PARISC_PCREL22F:
3530     case R_PARISC_DIR17F:
3531     case R_PARISC_DIR17R:
3532       /* This is a branch.  Divide the offset by four.
3533          Note that we need to decide whether it's a branch or
3534          otherwise by inspecting the reloc.  Inspecting insn won't
3535          work as insn might be from a .word directive.  */
3536       val >>= 2;
3537       break;
3538
3539     default:
3540       break;
3541     }
3542
3543   insn = hppa_rebuild_insn (insn, val, r_format);
3544
3545   /* Update the instruction word.  */
3546   bfd_put_32 (input_bfd, (bfd_vma) insn, hit_data);
3547   return bfd_reloc_ok;
3548 }
3549
3550 /* Relocate an HPPA ELF section.  */
3551
3552 static bfd_boolean
3553 elf32_hppa_relocate_section (bfd *output_bfd,
3554                              struct bfd_link_info *info,
3555                              bfd *input_bfd,
3556                              asection *input_section,
3557                              bfd_byte *contents,
3558                              Elf_Internal_Rela *relocs,
3559                              Elf_Internal_Sym *local_syms,
3560                              asection **local_sections)
3561 {
3562   bfd_vma *local_got_offsets;
3563   struct elf32_hppa_link_hash_table *htab;
3564   Elf_Internal_Shdr *symtab_hdr;
3565   Elf_Internal_Rela *rela;
3566   Elf_Internal_Rela *relend;
3567
3568   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3569
3570   htab = hppa_link_hash_table (info);
3571   if (htab == NULL)
3572     return FALSE;
3573
3574   local_got_offsets = elf_local_got_offsets (input_bfd);
3575
3576   rela = relocs;
3577   relend = relocs + input_section->reloc_count;
3578   for (; rela < relend; rela++)
3579     {
3580       unsigned int r_type;
3581       reloc_howto_type *howto;
3582       unsigned int r_symndx;
3583       struct elf32_hppa_link_hash_entry *hh;
3584       Elf_Internal_Sym *sym;
3585       asection *sym_sec;
3586       bfd_vma relocation;
3587       bfd_reloc_status_type rstatus;
3588       const char *sym_name;
3589       bfd_boolean plabel;
3590       bfd_boolean warned_undef;
3591
3592       r_type = ELF32_R_TYPE (rela->r_info);
3593       if (r_type >= (unsigned int) R_PARISC_UNIMPLEMENTED)
3594         {
3595           bfd_set_error (bfd_error_bad_value);
3596           return FALSE;
3597         }
3598       if (r_type == (unsigned int) R_PARISC_GNU_VTENTRY
3599           || r_type == (unsigned int) R_PARISC_GNU_VTINHERIT)
3600         continue;
3601
3602       r_symndx = ELF32_R_SYM (rela->r_info);
3603       hh = NULL;
3604       sym = NULL;
3605       sym_sec = NULL;
3606       warned_undef = FALSE;
3607       if (r_symndx < symtab_hdr->sh_info)
3608         {
3609           /* This is a local symbol, h defaults to NULL.  */
3610           sym = local_syms + r_symndx;
3611           sym_sec = local_sections[r_symndx];
3612           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sym_sec, rela);
3613         }
3614       else
3615         {
3616           struct elf_link_hash_entry *eh;
3617           bfd_boolean unresolved_reloc, ignored;
3618           struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
3619
3620           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rela,
3621                                    r_symndx, symtab_hdr, sym_hashes,
3622                                    eh, sym_sec, relocation,
3623                                    unresolved_reloc, warned_undef,
3624                                    ignored);
3625
3626           if (!bfd_link_relocatable (info)
3627               && relocation == 0
3628               && eh->root.type != bfd_link_hash_defined
3629               && eh->root.type != bfd_link_hash_defweak
3630               && eh->root.type != bfd_link_hash_undefweak)
3631             {
3632               if (info->unresolved_syms_in_objects == RM_IGNORE
3633                   && ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT
3634                   && eh->type == STT_PARISC_MILLI)
3635                 {
3636                   (*info->callbacks->undefined_symbol)
3637                     (info, eh_name (eh), input_bfd,
3638                      input_section, rela->r_offset, FALSE);
3639                   warned_undef = TRUE;
3640                 }
3641             }
3642           hh = hppa_elf_hash_entry (eh);
3643         }
3644
3645       if (sym_sec != NULL && discarded_section (sym_sec))
3646         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3647                                          rela, 1, relend,
3648                                          elf_hppa_howto_table + r_type, 0,
3649                                          contents);
3650
3651       if (bfd_link_relocatable (info))
3652         continue;
3653
3654       /* Do any required modifications to the relocation value, and
3655          determine what types of dynamic info we need to output, if
3656          any.  */
3657       plabel = 0;
3658       switch (r_type)
3659         {
3660         case R_PARISC_DLTIND14F:
3661         case R_PARISC_DLTIND14R:
3662         case R_PARISC_DLTIND21L:
3663           {
3664             bfd_vma off;
3665             bfd_boolean do_got = FALSE;
3666             bfd_boolean reloc = bfd_link_pic (info);
3667
3668             /* Relocation is to the entry for this symbol in the
3669                global offset table.  */
3670             if (hh != NULL)
3671               {
3672                 bfd_boolean dyn;
3673
3674                 off = hh->eh.got.offset;
3675                 dyn = htab->etab.dynamic_sections_created;
3676                 reloc = (!UNDEFWEAK_NO_DYNAMIC_RELOC (info, &hh->eh)
3677                          && (reloc
3678                              || (hh->eh.dynindx != -1
3679                                  && !SYMBOL_REFERENCES_LOCAL (info, &hh->eh))));
3680                 if (!reloc
3681                     || !WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
3682                                                          bfd_link_pic (info),
3683                                                          &hh->eh))
3684                   {
3685                     /* If we aren't going to call finish_dynamic_symbol,
3686                        then we need to handle initialisation of the .got
3687                        entry and create needed relocs here.  Since the
3688                        offset must always be a multiple of 4, we use the
3689                        least significant bit to record whether we have
3690                        initialised it already.  */
3691                     if ((off & 1) != 0)
3692                       off &= ~1;
3693                     else
3694                       {
3695                         hh->eh.got.offset |= 1;
3696                         do_got = TRUE;
3697                       }
3698                   }
3699               }
3700             else
3701               {
3702                 /* Local symbol case.  */
3703                 if (local_got_offsets == NULL)
3704                   abort ();
3705
3706                 off = local_got_offsets[r_symndx];
3707
3708                 /* The offset must always be a multiple of 4.  We use
3709                    the least significant bit to record whether we have
3710                    already generated the necessary reloc.  */
3711                 if ((off & 1) != 0)
3712                   off &= ~1;
3713                 else
3714                   {
3715                     local_got_offsets[r_symndx] |= 1;
3716                     do_got = TRUE;
3717                   }
3718               }
3719
3720             if (do_got)
3721               {
3722                 if (reloc)
3723                   {
3724                     /* Output a dynamic relocation for this GOT entry.
3725                        In this case it is relative to the base of the
3726                        object because the symbol index is zero.  */
3727                     Elf_Internal_Rela outrel;
3728                     bfd_byte *loc;
3729                     asection *sec = htab->etab.srelgot;
3730
3731                     outrel.r_offset = (off
3732                                        + htab->etab.sgot->output_offset
3733                                        + htab->etab.sgot->output_section->vma);
3734                     outrel.r_info = ELF32_R_INFO (0, R_PARISC_DIR32);
3735                     outrel.r_addend = relocation;
3736                     loc = sec->contents;
3737                     loc += sec->reloc_count++ * sizeof (Elf32_External_Rela);
3738                     bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3739                   }
3740                 else
3741                   bfd_put_32 (output_bfd, relocation,
3742                               htab->etab.sgot->contents + off);
3743               }
3744
3745             if (off >= (bfd_vma) -2)
3746               abort ();
3747
3748             /* Add the base of the GOT to the relocation value.  */
3749             relocation = (off
3750                           + htab->etab.sgot->output_offset
3751                           + htab->etab.sgot->output_section->vma);
3752           }
3753           break;
3754
3755         case R_PARISC_SEGREL32:
3756           /* If this is the first SEGREL relocation, then initialize
3757              the segment base values.  */
3758           if (htab->text_segment_base == (bfd_vma) -1)
3759             bfd_map_over_sections (output_bfd, hppa_record_segment_addr, htab);
3760           break;
3761
3762         case R_PARISC_PLABEL14R:
3763         case R_PARISC_PLABEL21L:
3764         case R_PARISC_PLABEL32:
3765           if (htab->etab.dynamic_sections_created)
3766             {
3767               bfd_vma off;
3768               bfd_boolean do_plt = 0;
3769               /* If we have a global symbol with a PLT slot, then
3770                  redirect this relocation to it.  */
3771               if (hh != NULL)
3772                 {
3773                   off = hh->eh.plt.offset;
3774                   if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (1,
3775                                                          bfd_link_pic (info),
3776                                                          &hh->eh))
3777                     {
3778                       /* In a non-shared link, adjust_dynamic_symbol
3779                          isn't called for symbols forced local.  We
3780                          need to write out the plt entry here.  */
3781                       if ((off & 1) != 0)
3782                         off &= ~1;
3783                       else
3784                         {
3785                           hh->eh.plt.offset |= 1;
3786                           do_plt = 1;
3787                         }
3788                     }
3789                 }
3790               else
3791                 {
3792                   bfd_vma *local_plt_offsets;
3793
3794                   if (local_got_offsets == NULL)
3795                     abort ();
3796
3797                   local_plt_offsets = local_got_offsets + symtab_hdr->sh_info;
3798                   off = local_plt_offsets[r_symndx];
3799
3800                   /* As for the local .got entry case, we use the last
3801                      bit to record whether we've already initialised
3802                      this local .plt entry.  */
3803                   if ((off & 1) != 0)
3804                     off &= ~1;
3805                   else
3806                     {
3807                       local_plt_offsets[r_symndx] |= 1;
3808                       do_plt = 1;
3809                     }
3810                 }
3811
3812               if (do_plt)
3813                 {
3814                   if (bfd_link_pic (info))
3815                     {
3816                       /* Output a dynamic IPLT relocation for this
3817                          PLT entry.  */
3818                       Elf_Internal_Rela outrel;
3819                       bfd_byte *loc;
3820                       asection *s = htab->etab.srelplt;
3821
3822                       outrel.r_offset = (off
3823                                          + htab->etab.splt->output_offset
3824                                          + htab->etab.splt->output_section->vma);
3825                       outrel.r_info = ELF32_R_INFO (0, R_PARISC_IPLT);
3826                       outrel.r_addend = relocation;
3827                       loc = s->contents;
3828                       loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
3829                       bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3830                     }
3831                   else
3832                     {
3833                       bfd_put_32 (output_bfd,
3834                                   relocation,
3835                                   htab->etab.splt->contents + off);
3836                       bfd_put_32 (output_bfd,
3837                                   elf_gp (htab->etab.splt->output_section->owner),
3838                                   htab->etab.splt->contents + off + 4);
3839                     }
3840                 }
3841
3842               if (off >= (bfd_vma) -2)
3843                 abort ();
3844
3845               /* PLABELs contain function pointers.  Relocation is to
3846                  the entry for the function in the .plt.  The magic +2
3847                  offset signals to $$dyncall that the function pointer
3848                  is in the .plt and thus has a gp pointer too.
3849                  Exception:  Undefined PLABELs should have a value of
3850                  zero.  */
3851               if (hh == NULL
3852                   || (hh->eh.root.type != bfd_link_hash_undefweak
3853                       && hh->eh.root.type != bfd_link_hash_undefined))
3854                 {
3855                   relocation = (off
3856                                 + htab->etab.splt->output_offset
3857                                 + htab->etab.splt->output_section->vma
3858                                 + 2);
3859                 }
3860               plabel = 1;
3861             }
3862           /* Fall through.  */
3863
3864         case R_PARISC_DIR17F:
3865         case R_PARISC_DIR17R:
3866         case R_PARISC_DIR14F:
3867         case R_PARISC_DIR14R:
3868         case R_PARISC_DIR21L:
3869         case R_PARISC_DPREL14F:
3870         case R_PARISC_DPREL14R:
3871         case R_PARISC_DPREL21L:
3872         case R_PARISC_DIR32:
3873           if ((input_section->flags & SEC_ALLOC) == 0)
3874             break;
3875
3876           if (bfd_link_pic (info)
3877               ? ((hh == NULL
3878                   || hh->dyn_relocs != NULL)
3879                  && ((hh != NULL && pc_dynrelocs (hh))
3880                      || IS_ABSOLUTE_RELOC (r_type)))
3881               : (hh != NULL
3882                  && hh->dyn_relocs != NULL))
3883             {
3884               Elf_Internal_Rela outrel;
3885               bfd_boolean skip;
3886               asection *sreloc;
3887               bfd_byte *loc;
3888
3889               /* When generating a shared object, these relocations
3890                  are copied into the output file to be resolved at run
3891                  time.  */
3892
3893               outrel.r_addend = rela->r_addend;
3894               outrel.r_offset =
3895                 _bfd_elf_section_offset (output_bfd, info, input_section,
3896                                          rela->r_offset);
3897               skip = (outrel.r_offset == (bfd_vma) -1
3898                       || outrel.r_offset == (bfd_vma) -2);
3899               outrel.r_offset += (input_section->output_offset
3900                                   + input_section->output_section->vma);
3901
3902               if (skip)
3903                 {
3904                   memset (&outrel, 0, sizeof (outrel));
3905                 }
3906               else if (hh != NULL
3907                        && hh->eh.dynindx != -1
3908                        && (plabel
3909                            || !IS_ABSOLUTE_RELOC (r_type)
3910                            || !bfd_link_pic (info)
3911                            || !SYMBOLIC_BIND (info, &hh->eh)
3912                            || !hh->eh.def_regular))
3913                 {
3914                   outrel.r_info = ELF32_R_INFO (hh->eh.dynindx, r_type);
3915                 }
3916               else /* It's a local symbol, or one marked to become local.  */
3917                 {
3918                   int indx = 0;
3919
3920                   /* Add the absolute offset of the symbol.  */
3921                   outrel.r_addend += relocation;
3922
3923                   /* Global plabels need to be processed by the
3924                      dynamic linker so that functions have at most one
3925                      fptr.  For this reason, we need to differentiate
3926                      between global and local plabels, which we do by
3927                      providing the function symbol for a global plabel
3928                      reloc, and no symbol for local plabels.  */
3929                   if (! plabel
3930                       && sym_sec != NULL
3931                       && sym_sec->output_section != NULL
3932                       && ! bfd_is_abs_section (sym_sec))
3933                     {
3934                       asection *osec;
3935
3936                       osec = sym_sec->output_section;
3937                       indx = elf_section_data (osec)->dynindx;
3938                       if (indx == 0)
3939                         {
3940                           osec = htab->etab.text_index_section;
3941                           indx = elf_section_data (osec)->dynindx;
3942                         }
3943                       BFD_ASSERT (indx != 0);
3944
3945                       /* We are turning this relocation into one
3946                          against a section symbol, so subtract out the
3947                          output section's address but not the offset
3948                          of the input section in the output section.  */
3949                       outrel.r_addend -= osec->vma;
3950                     }
3951
3952                   outrel.r_info = ELF32_R_INFO (indx, r_type);
3953                 }
3954               sreloc = elf_section_data (input_section)->sreloc;
3955               if (sreloc == NULL)
3956                 abort ();
3957
3958               loc = sreloc->contents;
3959               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
3960               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3961             }
3962           break;
3963
3964         case R_PARISC_TLS_LDM21L:
3965         case R_PARISC_TLS_LDM14R:
3966           {
3967             bfd_vma off;
3968
3969             off = htab->tls_ldm_got.offset;
3970             if (off & 1)
3971               off &= ~1;
3972             else
3973               {
3974                 Elf_Internal_Rela outrel;
3975                 bfd_byte *loc;
3976
3977                 outrel.r_offset = (off
3978                                    + htab->etab.sgot->output_section->vma
3979                                    + htab->etab.sgot->output_offset);
3980                 outrel.r_addend = 0;
3981                 outrel.r_info = ELF32_R_INFO (0, R_PARISC_TLS_DTPMOD32);
3982                 loc = htab->etab.srelgot->contents;
3983                 loc += htab->etab.srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
3984
3985                 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3986                 htab->tls_ldm_got.offset |= 1;
3987               }
3988
3989             /* Add the base of the GOT to the relocation value.  */
3990             relocation = (off
3991                           + htab->etab.sgot->output_offset
3992                           + htab->etab.sgot->output_section->vma);
3993
3994             break;
3995           }
3996
3997         case R_PARISC_TLS_LDO21L:
3998         case R_PARISC_TLS_LDO14R:
3999           relocation -= dtpoff_base (info);
4000           break;
4001
4002         case R_PARISC_TLS_GD21L:
4003         case R_PARISC_TLS_GD14R:
4004         case R_PARISC_TLS_IE21L:
4005         case R_PARISC_TLS_IE14R:
4006           {
4007             bfd_vma off;
4008             int indx;
4009             char tls_type;
4010
4011             indx = 0;
4012             if (hh != NULL)
4013               {
4014                 if (!htab->etab.dynamic_sections_created
4015                     || hh->eh.dynindx == -1
4016                     || SYMBOL_REFERENCES_LOCAL (info, &hh->eh)
4017                     || UNDEFWEAK_NO_DYNAMIC_RELOC (info, &hh->eh))
4018                   /* This is actually a static link, or it is a
4019                      -Bsymbolic link and the symbol is defined
4020                      locally, or the symbol was forced to be local
4021                      because of a version file.  */
4022                   ;
4023                 else
4024                   indx = hh->eh.dynindx;
4025                 off = hh->eh.got.offset;
4026                 tls_type = hh->tls_type;
4027               }
4028             else
4029               {
4030                 off = local_got_offsets[r_symndx];
4031                 tls_type = hppa_elf_local_got_tls_type (input_bfd)[r_symndx];
4032               }
4033
4034             if (tls_type == GOT_UNKNOWN)
4035               abort ();
4036
4037             if ((off & 1) != 0)
4038               off &= ~1;
4039             else
4040               {
4041                 bfd_boolean need_relocs = FALSE;
4042                 Elf_Internal_Rela outrel;
4043                 bfd_byte *loc = NULL;
4044                 int cur_off = off;
4045
4046                 /* The GOT entries have not been initialized yet.  Do it
4047                    now, and emit any relocations.  If both an IE GOT and a
4048                    GD GOT are necessary, we emit the GD first.  */
4049
4050                 if (indx != 0
4051                     || (bfd_link_dll (info)
4052                         && (hh == NULL
4053                             || !UNDEFWEAK_NO_DYNAMIC_RELOC (info, &hh->eh))))
4054                   {
4055                     need_relocs = TRUE;
4056                     loc = htab->etab.srelgot->contents;
4057                     loc += (htab->etab.srelgot->reloc_count
4058                             * sizeof (Elf32_External_Rela));
4059                   }
4060
4061                 if (tls_type & GOT_TLS_GD)
4062                   {
4063                     if (need_relocs)
4064                       {
4065                         outrel.r_offset
4066                           = (cur_off
4067                              + htab->etab.sgot->output_section->vma
4068                              + htab->etab.sgot->output_offset);
4069                         outrel.r_info
4070                           = ELF32_R_INFO (indx, R_PARISC_TLS_DTPMOD32);
4071                         outrel.r_addend = 0;
4072                         bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4073                         htab->etab.srelgot->reloc_count++;
4074                         loc += sizeof (Elf32_External_Rela);
4075                         bfd_put_32 (output_bfd, 0,
4076                                     htab->etab.sgot->contents + cur_off);
4077                       }
4078                     else
4079                       /* If we are not emitting relocations for a
4080                          general dynamic reference, then we must be in a
4081                          static link or an executable link with the
4082                          symbol binding locally.  Mark it as belonging
4083                          to module 1, the executable.  */
4084                       bfd_put_32 (output_bfd, 1,
4085                                   htab->etab.sgot->contents + cur_off);
4086
4087                     if (indx != 0)
4088                       {
4089                         outrel.r_info
4090                           = ELF32_R_INFO (indx, R_PARISC_TLS_DTPOFF32);
4091                         outrel.r_offset += 4;
4092                         bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4093                         htab->etab.srelgot->reloc_count++;
4094                         loc += sizeof (Elf32_External_Rela);
4095                         bfd_put_32 (output_bfd, 0,
4096                                     htab->etab.sgot->contents + cur_off + 4);
4097                       }
4098                     else
4099                       bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
4100                                   htab->etab.sgot->contents + cur_off + 4);
4101                     cur_off += 8;
4102                   }
4103
4104                 if (tls_type & GOT_TLS_IE)
4105                   {
4106                     if (need_relocs
4107                         && !(bfd_link_executable (info)
4108                              && SYMBOL_REFERENCES_LOCAL (info, &hh->eh)))
4109                       {
4110                         outrel.r_offset
4111                           = (cur_off
4112                              + htab->etab.sgot->output_section->vma
4113                              + htab->etab.sgot->output_offset);
4114                         outrel.r_info = ELF32_R_INFO (indx,
4115                                                       R_PARISC_TLS_TPREL32);
4116                         if (indx == 0)
4117                           outrel.r_addend = relocation - dtpoff_base (info);
4118                         else
4119                           outrel.r_addend = 0;
4120                         bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4121                         htab->etab.srelgot->reloc_count++;
4122                         loc += sizeof (Elf32_External_Rela);
4123                       }
4124                     else
4125                       bfd_put_32 (output_bfd, tpoff (info, relocation),
4126                                   htab->etab.sgot->contents + cur_off);
4127                     cur_off += 4;
4128                   }
4129
4130                 if (hh != NULL)
4131                   hh->eh.got.offset |= 1;
4132                 else
4133                   local_got_offsets[r_symndx] |= 1;
4134               }
4135
4136             if ((tls_type & GOT_NORMAL) != 0
4137                 && (tls_type & (GOT_TLS_GD | GOT_TLS_LDM | GOT_TLS_IE)) != 0)
4138               {
4139                 if (hh != NULL)
4140                   _bfd_error_handler (_("%s has both normal and TLS relocs"),
4141                                       hh_name (hh));
4142                 else
4143                   {
4144                     Elf_Internal_Sym *isym
4145                       = bfd_sym_from_r_symndx (&htab->sym_cache,
4146                                                input_bfd, r_symndx);
4147                     if (isym == NULL)
4148                       return FALSE;
4149                     sym_name
4150                       = bfd_elf_string_from_elf_section (input_bfd,
4151                                                          symtab_hdr->sh_link,
4152                                                          isym->st_name);
4153                     if (sym_name == NULL)
4154                       return FALSE;
4155                     if (*sym_name == '\0')
4156                       sym_name = bfd_section_name (input_bfd, sym_sec);
4157                     _bfd_error_handler
4158                       (_("%pB:%s has both normal and TLS relocs"),
4159                        input_bfd, sym_name);
4160                   }
4161                 bfd_set_error (bfd_error_bad_value);
4162                 return FALSE;
4163               }
4164
4165             if ((tls_type & GOT_TLS_GD)
4166                 && r_type != R_PARISC_TLS_GD21L
4167                 && r_type != R_PARISC_TLS_GD14R)
4168               off += 2 * GOT_ENTRY_SIZE;
4169
4170             /* Add the base of the GOT to the relocation value.  */
4171             relocation = (off
4172                           + htab->etab.sgot->output_offset
4173                           + htab->etab.sgot->output_section->vma);
4174
4175             break;
4176           }
4177
4178         case R_PARISC_TLS_LE21L:
4179         case R_PARISC_TLS_LE14R:
4180           {
4181             relocation = tpoff (info, relocation);
4182             break;
4183           }
4184           break;
4185
4186         default:
4187           break;
4188         }
4189
4190       rstatus = final_link_relocate (input_section, contents, rela, relocation,
4191                                htab, sym_sec, hh, info);
4192
4193       if (rstatus == bfd_reloc_ok)
4194         continue;
4195
4196       if (hh != NULL)
4197         sym_name = hh_name (hh);
4198       else
4199         {
4200           sym_name = bfd_elf_string_from_elf_section (input_bfd,
4201                                                       symtab_hdr->sh_link,
4202                                                       sym->st_name);
4203           if (sym_name == NULL)
4204             return FALSE;
4205           if (*sym_name == '\0')
4206             sym_name = bfd_section_name (input_bfd, sym_sec);
4207         }
4208
4209       howto = elf_hppa_howto_table + r_type;
4210
4211       if (rstatus == bfd_reloc_undefined || rstatus == bfd_reloc_notsupported)
4212         {
4213           if (rstatus == bfd_reloc_notsupported || !warned_undef)
4214             {
4215               _bfd_error_handler
4216                 /* xgettext:c-format */
4217                 (_("%pB(%pA+%#" PRIx64 "): cannot handle %s for %s"),
4218                  input_bfd,
4219                  input_section,
4220                  (uint64_t) rela->r_offset,
4221                  howto->name,
4222                  sym_name);
4223               bfd_set_error (bfd_error_bad_value);
4224               return FALSE;
4225             }
4226         }
4227       else
4228         (*info->callbacks->reloc_overflow)
4229           (info, (hh ? &hh->eh.root : NULL), sym_name, howto->name,
4230            (bfd_vma) 0, input_bfd, input_section, rela->r_offset);
4231     }
4232
4233   return TRUE;
4234 }
4235
4236 /* Finish up dynamic symbol handling.  We set the contents of various
4237    dynamic sections here.  */
4238
4239 static bfd_boolean
4240 elf32_hppa_finish_dynamic_symbol (bfd *output_bfd,
4241                                   struct bfd_link_info *info,
4242                                   struct elf_link_hash_entry *eh,
4243                                   Elf_Internal_Sym *sym)
4244 {
4245   struct elf32_hppa_link_hash_table *htab;
4246   Elf_Internal_Rela rela;
4247   bfd_byte *loc;
4248
4249   htab = hppa_link_hash_table (info);
4250   if (htab == NULL)
4251     return FALSE;
4252
4253   if (eh->plt.offset != (bfd_vma) -1)
4254     {
4255       bfd_vma value;
4256
4257       if (eh->plt.offset & 1)
4258         abort ();
4259
4260       /* This symbol has an entry in the procedure linkage table.  Set
4261          it up.
4262
4263          The format of a plt entry is
4264          <funcaddr>
4265          <__gp>
4266       */
4267       value = 0;
4268       if (eh->root.type == bfd_link_hash_defined
4269           || eh->root.type == bfd_link_hash_defweak)
4270         {
4271           value = eh->root.u.def.value;
4272           if (eh->root.u.def.section->output_section != NULL)
4273             value += (eh->root.u.def.section->output_offset
4274                       + eh->root.u.def.section->output_section->vma);
4275         }
4276
4277       /* Create a dynamic IPLT relocation for this entry.  */
4278       rela.r_offset = (eh->plt.offset
4279                       + htab->etab.splt->output_offset
4280                       + htab->etab.splt->output_section->vma);
4281       if (eh->dynindx != -1)
4282         {
4283           rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_IPLT);
4284           rela.r_addend = 0;
4285         }
4286       else
4287         {
4288           /* This symbol has been marked to become local, and is
4289              used by a plabel so must be kept in the .plt.  */
4290           rela.r_info = ELF32_R_INFO (0, R_PARISC_IPLT);
4291           rela.r_addend = value;
4292         }
4293
4294       loc = htab->etab.srelplt->contents;
4295       loc += htab->etab.srelplt->reloc_count++ * sizeof (Elf32_External_Rela);
4296       bfd_elf32_swap_reloca_out (htab->etab.splt->output_section->owner, &rela, loc);
4297
4298       if (!eh->def_regular)
4299         {
4300           /* Mark the symbol as undefined, rather than as defined in
4301              the .plt section.  Leave the value alone.  */
4302           sym->st_shndx = SHN_UNDEF;
4303         }
4304     }
4305
4306   if (eh->got.offset != (bfd_vma) -1
4307       && (hppa_elf_hash_entry (eh)->tls_type & GOT_NORMAL) != 0
4308       && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, eh))
4309     {
4310       bfd_boolean is_dyn = (eh->dynindx != -1
4311                             && !SYMBOL_REFERENCES_LOCAL (info, eh));
4312
4313       if (is_dyn || bfd_link_pic (info))
4314         {
4315           /* This symbol has an entry in the global offset table.  Set
4316              it up.  */
4317
4318           rela.r_offset = ((eh->got.offset &~ (bfd_vma) 1)
4319                            + htab->etab.sgot->output_offset
4320                            + htab->etab.sgot->output_section->vma);
4321
4322           /* If this is a -Bsymbolic link and the symbol is defined
4323              locally or was forced to be local because of a version
4324              file, we just want to emit a RELATIVE reloc.  The entry
4325              in the global offset table will already have been
4326              initialized in the relocate_section function.  */
4327           if (!is_dyn)
4328             {
4329               rela.r_info = ELF32_R_INFO (0, R_PARISC_DIR32);
4330               rela.r_addend = (eh->root.u.def.value
4331                                + eh->root.u.def.section->output_offset
4332                                + eh->root.u.def.section->output_section->vma);
4333             }
4334           else
4335             {
4336               if ((eh->got.offset & 1) != 0)
4337                 abort ();
4338
4339               bfd_put_32 (output_bfd, 0,
4340                           htab->etab.sgot->contents + (eh->got.offset & ~1));
4341               rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_DIR32);
4342               rela.r_addend = 0;
4343             }
4344
4345           loc = htab->etab.srelgot->contents;
4346           loc += (htab->etab.srelgot->reloc_count++
4347                   * sizeof (Elf32_External_Rela));
4348           bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4349         }
4350     }
4351
4352   if (eh->needs_copy)
4353     {
4354       asection *sec;
4355
4356       /* This symbol needs a copy reloc.  Set it up.  */
4357
4358       if (! (eh->dynindx != -1
4359              && (eh->root.type == bfd_link_hash_defined
4360                  || eh->root.type == bfd_link_hash_defweak)))
4361         abort ();
4362
4363       rela.r_offset = (eh->root.u.def.value
4364                       + eh->root.u.def.section->output_offset
4365                       + eh->root.u.def.section->output_section->vma);
4366       rela.r_addend = 0;
4367       rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_COPY);
4368       if (eh->root.u.def.section == htab->etab.sdynrelro)
4369         sec = htab->etab.sreldynrelro;
4370       else
4371         sec = htab->etab.srelbss;
4372       loc = sec->contents + sec->reloc_count++ * sizeof (Elf32_External_Rela);
4373       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4374     }
4375
4376   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
4377   if (eh == htab->etab.hdynamic || eh == htab->etab.hgot)
4378     {
4379       sym->st_shndx = SHN_ABS;
4380     }
4381
4382   return TRUE;
4383 }
4384
4385 /* Used to decide how to sort relocs in an optimal manner for the
4386    dynamic linker, before writing them out.  */
4387
4388 static enum elf_reloc_type_class
4389 elf32_hppa_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
4390                              const asection *rel_sec ATTRIBUTE_UNUSED,
4391                              const Elf_Internal_Rela *rela)
4392 {
4393   /* Handle TLS relocs first; we don't want them to be marked
4394      relative by the "if (ELF32_R_SYM (rela->r_info) == STN_UNDEF)"
4395      check below.  */
4396   switch ((int) ELF32_R_TYPE (rela->r_info))
4397     {
4398       case R_PARISC_TLS_DTPMOD32:
4399       case R_PARISC_TLS_DTPOFF32:
4400       case R_PARISC_TLS_TPREL32:
4401         return reloc_class_normal;
4402     }
4403
4404   if (ELF32_R_SYM (rela->r_info) == STN_UNDEF)
4405     return reloc_class_relative;
4406
4407   switch ((int) ELF32_R_TYPE (rela->r_info))
4408     {
4409     case R_PARISC_IPLT:
4410       return reloc_class_plt;
4411     case R_PARISC_COPY:
4412       return reloc_class_copy;
4413     default:
4414       return reloc_class_normal;
4415     }
4416 }
4417
4418 /* Finish up the dynamic sections.  */
4419
4420 static bfd_boolean
4421 elf32_hppa_finish_dynamic_sections (bfd *output_bfd,
4422                                     struct bfd_link_info *info)
4423 {
4424   bfd *dynobj;
4425   struct elf32_hppa_link_hash_table *htab;
4426   asection *sdyn;
4427   asection * sgot;
4428
4429   htab = hppa_link_hash_table (info);
4430   if (htab == NULL)
4431     return FALSE;
4432
4433   dynobj = htab->etab.dynobj;
4434
4435   sgot = htab->etab.sgot;
4436   /* A broken linker script might have discarded the dynamic sections.
4437      Catch this here so that we do not seg-fault later on.  */
4438   if (sgot != NULL && bfd_is_abs_section (sgot->output_section))
4439     return FALSE;
4440
4441   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4442
4443   if (htab->etab.dynamic_sections_created)
4444     {
4445       Elf32_External_Dyn *dyncon, *dynconend;
4446
4447       if (sdyn == NULL)
4448         abort ();
4449
4450       dyncon = (Elf32_External_Dyn *) sdyn->contents;
4451       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4452       for (; dyncon < dynconend; dyncon++)
4453         {
4454           Elf_Internal_Dyn dyn;
4455           asection *s;
4456
4457           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4458
4459           switch (dyn.d_tag)
4460             {
4461             default:
4462               continue;
4463
4464             case DT_PLTGOT:
4465               /* Use PLTGOT to set the GOT register.  */
4466               dyn.d_un.d_ptr = elf_gp (output_bfd);
4467               break;
4468
4469             case DT_JMPREL:
4470               s = htab->etab.srelplt;
4471               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4472               break;
4473
4474             case DT_PLTRELSZ:
4475               s = htab->etab.srelplt;
4476               dyn.d_un.d_val = s->size;
4477               break;
4478             }
4479
4480           bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4481         }
4482     }
4483
4484   if (sgot != NULL && sgot->size != 0)
4485     {
4486       /* Fill in the first entry in the global offset table.
4487          We use it to point to our dynamic section, if we have one.  */
4488       bfd_put_32 (output_bfd,
4489                   sdyn ? sdyn->output_section->vma + sdyn->output_offset : 0,
4490                   sgot->contents);
4491
4492       /* The second entry is reserved for use by the dynamic linker.  */
4493       memset (sgot->contents + GOT_ENTRY_SIZE, 0, GOT_ENTRY_SIZE);
4494
4495       /* Set .got entry size.  */
4496       elf_section_data (sgot->output_section)
4497         ->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
4498     }
4499
4500   if (htab->etab.splt != NULL && htab->etab.splt->size != 0)
4501     {
4502       /* Set plt entry size to 0 instead of PLT_ENTRY_SIZE, since we add the
4503          plt stubs and as such the section does not hold a table of fixed-size
4504          entries.  */
4505       elf_section_data (htab->etab.splt->output_section)->this_hdr.sh_entsize = 0;
4506
4507       if (htab->need_plt_stub)
4508         {
4509           /* Set up the .plt stub.  */
4510           memcpy (htab->etab.splt->contents
4511                   + htab->etab.splt->size - sizeof (plt_stub),
4512                   plt_stub, sizeof (plt_stub));
4513
4514           if ((htab->etab.splt->output_offset
4515                + htab->etab.splt->output_section->vma
4516                + htab->etab.splt->size)
4517               != (sgot->output_offset
4518                   + sgot->output_section->vma))
4519             {
4520               _bfd_error_handler
4521                 (_(".got section not immediately after .plt section"));
4522               return FALSE;
4523             }
4524         }
4525     }
4526
4527   return TRUE;
4528 }
4529
4530 /* Called when writing out an object file to decide the type of a
4531    symbol.  */
4532 static int
4533 elf32_hppa_elf_get_symbol_type (Elf_Internal_Sym *elf_sym, int type)
4534 {
4535   if (ELF_ST_TYPE (elf_sym->st_info) == STT_PARISC_MILLI)
4536     return STT_PARISC_MILLI;
4537   else
4538     return type;
4539 }
4540
4541 /* Misc BFD support code.  */
4542 #define bfd_elf32_bfd_is_local_label_name    elf_hppa_is_local_label_name
4543 #define bfd_elf32_bfd_reloc_type_lookup      elf_hppa_reloc_type_lookup
4544 #define bfd_elf32_bfd_reloc_name_lookup      elf_hppa_reloc_name_lookup
4545 #define elf_info_to_howto                    elf_hppa_info_to_howto
4546 #define elf_info_to_howto_rel                elf_hppa_info_to_howto_rel
4547
4548 /* Stuff for the BFD linker.  */
4549 #define bfd_elf32_bfd_final_link             elf32_hppa_final_link
4550 #define bfd_elf32_bfd_link_hash_table_create elf32_hppa_link_hash_table_create
4551 #define elf_backend_adjust_dynamic_symbol    elf32_hppa_adjust_dynamic_symbol
4552 #define elf_backend_copy_indirect_symbol     elf32_hppa_copy_indirect_symbol
4553 #define elf_backend_check_relocs             elf32_hppa_check_relocs
4554 #define elf_backend_relocs_compatible        _bfd_elf_relocs_compatible
4555 #define elf_backend_create_dynamic_sections  elf32_hppa_create_dynamic_sections
4556 #define elf_backend_fake_sections            elf_hppa_fake_sections
4557 #define elf_backend_relocate_section         elf32_hppa_relocate_section
4558 #define elf_backend_hide_symbol              elf32_hppa_hide_symbol
4559 #define elf_backend_finish_dynamic_symbol    elf32_hppa_finish_dynamic_symbol
4560 #define elf_backend_finish_dynamic_sections  elf32_hppa_finish_dynamic_sections
4561 #define elf_backend_size_dynamic_sections    elf32_hppa_size_dynamic_sections
4562 #define elf_backend_init_index_section       _bfd_elf_init_1_index_section
4563 #define elf_backend_gc_mark_hook             elf32_hppa_gc_mark_hook
4564 #define elf_backend_grok_prstatus            elf32_hppa_grok_prstatus
4565 #define elf_backend_grok_psinfo              elf32_hppa_grok_psinfo
4566 #define elf_backend_object_p                 elf32_hppa_object_p
4567 #define elf_backend_final_write_processing   elf_hppa_final_write_processing
4568 #define elf_backend_get_symbol_type          elf32_hppa_elf_get_symbol_type
4569 #define elf_backend_reloc_type_class         elf32_hppa_reloc_type_class
4570 #define elf_backend_action_discarded         elf_hppa_action_discarded
4571
4572 #define elf_backend_can_gc_sections          1
4573 #define elf_backend_can_refcount             1
4574 #define elf_backend_plt_alignment            2
4575 #define elf_backend_want_got_plt             0
4576 #define elf_backend_plt_readonly             0
4577 #define elf_backend_want_plt_sym             0
4578 #define elf_backend_got_header_size          8
4579 #define elf_backend_want_dynrelro            1
4580 #define elf_backend_rela_normal              1
4581 #define elf_backend_dtrel_excludes_plt       1
4582 #define elf_backend_no_page_alias            1
4583
4584 #define TARGET_BIG_SYM          hppa_elf32_vec
4585 #define TARGET_BIG_NAME         "elf32-hppa"
4586 #define ELF_ARCH                bfd_arch_hppa
4587 #define ELF_TARGET_ID           HPPA32_ELF_DATA
4588 #define ELF_MACHINE_CODE        EM_PARISC
4589 #define ELF_MAXPAGESIZE         0x1000
4590 #define ELF_OSABI               ELFOSABI_HPUX
4591 #define elf32_bed               elf32_hppa_hpux_bed
4592
4593 #include "elf32-target.h"
4594
4595 #undef TARGET_BIG_SYM
4596 #define TARGET_BIG_SYM          hppa_elf32_linux_vec
4597 #undef TARGET_BIG_NAME
4598 #define TARGET_BIG_NAME         "elf32-hppa-linux"
4599 #undef ELF_OSABI
4600 #define ELF_OSABI               ELFOSABI_GNU
4601 #undef elf32_bed
4602 #define elf32_bed               elf32_hppa_linux_bed
4603
4604 #include "elf32-target.h"
4605
4606 #undef TARGET_BIG_SYM
4607 #define TARGET_BIG_SYM          hppa_elf32_nbsd_vec
4608 #undef TARGET_BIG_NAME
4609 #define TARGET_BIG_NAME         "elf32-hppa-netbsd"
4610 #undef ELF_OSABI
4611 #define ELF_OSABI               ELFOSABI_NETBSD
4612 #undef elf32_bed
4613 #define elf32_bed               elf32_hppa_netbsd_bed
4614
4615 #include "elf32-target.h"