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