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