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