1 /* BFD back-end for HP PA-RISC ELF files.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000, 2001
3 Free Software Foundation, Inc.
6 Center for Software Science
7 Department of Computer Science
9 Largely rewritten by Alan Modra <alan@linuxcare.com.au>
11 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
33 #include "elf32-hppa.h"
36 #include "elf32-hppa.h"
38 /* In order to gain some understanding of code in this file without
39 knowing all the intricate details of the linker, note the
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. */
49 /* We use two hash tables to hold information for linking PA ELF objects.
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.
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.
59 There are a number of different stubs generated by the linker.
67 : addil LR'X - ($PIC_pcrel$0 - 4),%r1
68 : be,n RR'X - ($PIC_pcrel$0 - 8)(%sr4,%r1)
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
75 : ldw RR'lt_ptr+ltoff+4(%r1),%r19 ; get new dlt value.
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
82 : ldw RR'ltoff+4(%r1),%r19 ; get new dlt value.
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.
91 : be 0(%sr0,%r21) ; branch to target
92 : stw %rp,-24(%sp) ; save rp
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.
101 : be 0(%sr0,%r21) ; branch to target
102 : stw %rp,-24(%sp) ; save rp
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
111 : ldw -24(%sp),%rp ; restore the original rp
114 : be,n 0(%sr0,%rp) ; inter-space return */
116 #define PLT_ENTRY_SIZE 8
117 #define GOT_ENTRY_SIZE 4
118 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
120 static const bfd_byte plt_stub
[] =
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 */
132 /* Section name for stubs is the associated section name plus this
134 #define STUB_SUFFIX ".stub"
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
144 enum elf32_hppa_stub_type
{
145 hppa_stub_long_branch
,
146 hppa_stub_long_branch_shared
,
148 hppa_stub_import_shared
,
153 struct elf32_hppa_stub_hash_entry
{
155 /* Base hash table entry structure. */
156 struct bfd_hash_entry root
;
158 /* The stub section. */
161 /* Offset within stub_sec of the beginning of this stub. */
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
;
169 enum elf32_hppa_stub_type stub_type
;
171 /* The symbol table entry, if any, that this was derived from. */
172 struct elf32_hppa_link_hash_entry
*h
;
174 /* Where this stub is being called from, or, in the case of combined
175 stub sections, the first input section in the group. */
179 struct elf32_hppa_link_hash_entry
{
181 struct elf_link_hash_entry elf
;
183 /* A pointer to the most recently used stub hash entry against this
185 struct elf32_hppa_stub_hash_entry
*stub_cache
;
187 /* Used to count relocations for delayed sizing of relocation
189 struct elf32_hppa_dyn_reloc_entry
{
191 /* Next relocation in the chain. */
192 struct elf32_hppa_dyn_reloc_entry
*next
;
194 /* The input section of the reloc. */
197 /* Number of relocs copied in this section. */
200 #if RELATIVE_DYNRELOCS
201 /* Number of relative relocs copied for the input section. */
202 bfd_size_type relative_count
;
206 /* Set during a static link if we detect a function is PIC. */
207 unsigned int maybe_pic_call
:1;
209 /* Set if the only reason we need a .plt entry is for a non-PIC to
210 PIC function call. */
211 unsigned int pic_call
:1;
213 /* Set if this symbol is used by a plabel reloc. */
214 unsigned int plabel
:1;
217 struct elf32_hppa_link_hash_table
{
219 /* The main hash table. */
220 struct elf_link_hash_table elf
;
222 /* The stub hash table. */
223 struct bfd_hash_table stub_hash_table
;
225 /* Linker stub bfd. */
228 /* Linker call-backs. */
229 asection
* (*add_stub_section
) PARAMS ((const char *, asection
*));
230 void (*layout_sections_again
) PARAMS ((void));
232 /* Array to keep track of which stub sections have been created, and
233 information on stub grouping. */
235 /* This is the section to which stubs in the group will be
238 /* The stub section. */
242 /* Short-cuts to get to dynamic linker sections. */
250 /* Used during a final link to store the base of the text and data
251 segments so that we can perform SEGREL relocations. */
252 bfd_vma text_segment_base
;
253 bfd_vma data_segment_base
;
255 /* Whether we support multiple sub-spaces for shared libs. */
256 unsigned int multi_subspace
:1;
258 /* Flags set when PCREL12F and PCREL17F branches detected. Used to
259 select suitable defaults for the stub group size. */
260 unsigned int has_12bit_branch
:1;
261 unsigned int has_17bit_branch
:1;
263 /* Set if we need a .plt stub to support lazy dynamic linking. */
264 unsigned int need_plt_stub
:1;
266 /* Small local sym to section mapping cache. */
267 struct sym_sec_cache sym_sec
;
270 /* Various hash macros and functions. */
271 #define hppa_link_hash_table(p) \
272 ((struct elf32_hppa_link_hash_table *) ((p)->hash))
274 #define hppa_stub_hash_lookup(table, string, create, copy) \
275 ((struct elf32_hppa_stub_hash_entry *) \
276 bfd_hash_lookup ((table), (string), (create), (copy)))
278 static struct bfd_hash_entry
*stub_hash_newfunc
279 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
281 static struct bfd_hash_entry
*hppa_link_hash_newfunc
282 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
284 static struct bfd_link_hash_table
*elf32_hppa_link_hash_table_create
287 /* Stub handling functions. */
288 static char *hppa_stub_name
289 PARAMS ((const asection
*, const asection
*,
290 const struct elf32_hppa_link_hash_entry
*,
291 const Elf_Internal_Rela
*));
293 static struct elf32_hppa_stub_hash_entry
*hppa_get_stub_entry
294 PARAMS ((const asection
*, const asection
*,
295 struct elf32_hppa_link_hash_entry
*,
296 const Elf_Internal_Rela
*,
297 struct elf32_hppa_link_hash_table
*));
299 static struct elf32_hppa_stub_hash_entry
*hppa_add_stub
300 PARAMS ((const char *, asection
*, struct elf32_hppa_link_hash_table
*));
302 static enum elf32_hppa_stub_type hppa_type_of_stub
303 PARAMS ((asection
*, const Elf_Internal_Rela
*,
304 struct elf32_hppa_link_hash_entry
*, bfd_vma
));
306 static boolean hppa_build_one_stub
307 PARAMS ((struct bfd_hash_entry
*, PTR
));
309 static boolean hppa_size_one_stub
310 PARAMS ((struct bfd_hash_entry
*, PTR
));
312 /* BFD and elf backend functions. */
313 static boolean elf32_hppa_object_p
PARAMS ((bfd
*));
315 static boolean elf32_hppa_add_symbol_hook
316 PARAMS ((bfd
*, struct bfd_link_info
*, const Elf_Internal_Sym
*,
317 const char **, flagword
*, asection
**, bfd_vma
*));
319 static boolean elf32_hppa_create_dynamic_sections
320 PARAMS ((bfd
*, struct bfd_link_info
*));
322 static void elf32_hppa_copy_indirect_symbol
323 PARAMS ((struct elf_link_hash_entry
*, struct elf_link_hash_entry
*));
325 static boolean elf32_hppa_check_relocs
326 PARAMS ((bfd
*, struct bfd_link_info
*,
327 asection
*, const Elf_Internal_Rela
*));
329 static asection
*elf32_hppa_gc_mark_hook
330 PARAMS ((bfd
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
331 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
333 static boolean elf32_hppa_gc_sweep_hook
334 PARAMS ((bfd
*, struct bfd_link_info
*,
335 asection
*, const Elf_Internal_Rela
*));
337 static void elf32_hppa_hide_symbol
338 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
340 static boolean elf32_hppa_adjust_dynamic_symbol
341 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
343 static boolean mark_PIC_calls
344 PARAMS ((struct elf_link_hash_entry
*, PTR
));
346 static boolean allocate_plt_static
347 PARAMS ((struct elf_link_hash_entry
*, PTR
));
349 static boolean allocate_dynrelocs
350 PARAMS ((struct elf_link_hash_entry
*, PTR
));
352 static boolean readonly_dynrelocs
353 PARAMS ((struct elf_link_hash_entry
*, PTR
));
355 static boolean clobber_millicode_symbols
356 PARAMS ((struct elf_link_hash_entry
*, struct bfd_link_info
*));
358 static boolean elf32_hppa_size_dynamic_sections
359 PARAMS ((bfd
*, struct bfd_link_info
*));
361 static boolean elf32_hppa_final_link
362 PARAMS ((bfd
*, struct bfd_link_info
*));
364 static void hppa_record_segment_addr
365 PARAMS ((bfd
*, asection
*, PTR
));
367 static bfd_reloc_status_type final_link_relocate
368 PARAMS ((asection
*, bfd_byte
*, const Elf_Internal_Rela
*,
369 bfd_vma
, struct elf32_hppa_link_hash_table
*, asection
*,
370 struct elf32_hppa_link_hash_entry
*));
372 static boolean elf32_hppa_relocate_section
373 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*,
374 bfd_byte
*, Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
376 static int hppa_unwind_entry_compare
377 PARAMS ((const PTR
, const PTR
));
379 static boolean elf32_hppa_finish_dynamic_symbol
380 PARAMS ((bfd
*, struct bfd_link_info
*,
381 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
383 static enum elf_reloc_type_class elf32_hppa_reloc_type_class
384 PARAMS ((const Elf_Internal_Rela
*));
386 static boolean elf32_hppa_finish_dynamic_sections
387 PARAMS ((bfd
*, struct bfd_link_info
*));
389 static void elf32_hppa_post_process_headers
390 PARAMS ((bfd
*, struct bfd_link_info
*));
392 static int elf32_hppa_elf_get_symbol_type
393 PARAMS ((Elf_Internal_Sym
*, int));
395 /* Assorted hash table functions. */
397 /* Initialize an entry in the stub hash table. */
399 static struct bfd_hash_entry
*
400 stub_hash_newfunc (entry
, table
, string
)
401 struct bfd_hash_entry
*entry
;
402 struct bfd_hash_table
*table
;
405 /* Allocate the structure if it has not already been allocated by a
409 entry
= bfd_hash_allocate (table
,
410 sizeof (struct elf32_hppa_stub_hash_entry
));
415 /* Call the allocation method of the superclass. */
416 entry
= bfd_hash_newfunc (entry
, table
, string
);
419 struct elf32_hppa_stub_hash_entry
*eh
;
421 /* Initialize the local fields. */
422 eh
= (struct elf32_hppa_stub_hash_entry
*) entry
;
425 eh
->target_value
= 0;
426 eh
->target_section
= NULL
;
427 eh
->stub_type
= hppa_stub_long_branch
;
435 /* Initialize an entry in the link hash table. */
437 static struct bfd_hash_entry
*
438 hppa_link_hash_newfunc (entry
, table
, string
)
439 struct bfd_hash_entry
*entry
;
440 struct bfd_hash_table
*table
;
443 /* Allocate the structure if it has not already been allocated by a
447 entry
= bfd_hash_allocate (table
,
448 sizeof (struct elf32_hppa_link_hash_entry
));
453 /* Call the allocation method of the superclass. */
454 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
457 struct elf32_hppa_link_hash_entry
*eh
;
459 /* Initialize the local fields. */
460 eh
= (struct elf32_hppa_link_hash_entry
*) entry
;
461 eh
->stub_cache
= NULL
;
462 eh
->dyn_relocs
= NULL
;
463 eh
->maybe_pic_call
= 0;
471 /* Create the derived linker hash table. The PA ELF port uses the derived
472 hash table to keep information specific to the PA ELF linker (without
473 using static variables). */
475 static struct bfd_link_hash_table
*
476 elf32_hppa_link_hash_table_create (abfd
)
479 struct elf32_hppa_link_hash_table
*ret
;
480 bfd_size_type amt
= sizeof (*ret
);
482 ret
= (struct elf32_hppa_link_hash_table
*) bfd_alloc (abfd
, amt
);
486 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, hppa_link_hash_newfunc
))
488 bfd_release (abfd
, ret
);
492 /* Init the stub hash table too. */
493 if (!bfd_hash_table_init (&ret
->stub_hash_table
, stub_hash_newfunc
))
496 ret
->stub_bfd
= NULL
;
497 ret
->add_stub_section
= NULL
;
498 ret
->layout_sections_again
= NULL
;
499 ret
->stub_group
= NULL
;
506 ret
->text_segment_base
= (bfd_vma
) -1;
507 ret
->data_segment_base
= (bfd_vma
) -1;
508 ret
->multi_subspace
= 0;
509 ret
->has_12bit_branch
= 0;
510 ret
->has_17bit_branch
= 0;
511 ret
->need_plt_stub
= 0;
512 ret
->sym_sec
.abfd
= NULL
;
514 return &ret
->elf
.root
;
517 /* Build a name for an entry in the stub hash table. */
520 hppa_stub_name (input_section
, sym_sec
, hash
, rel
)
521 const asection
*input_section
;
522 const asection
*sym_sec
;
523 const struct elf32_hppa_link_hash_entry
*hash
;
524 const Elf_Internal_Rela
*rel
;
531 len
= 8 + 1 + strlen (hash
->elf
.root
.root
.string
) + 1 + 8 + 1;
532 stub_name
= bfd_malloc (len
);
533 if (stub_name
!= NULL
)
535 sprintf (stub_name
, "%08x_%s+%x",
536 input_section
->id
& 0xffffffff,
537 hash
->elf
.root
.root
.string
,
538 (int) rel
->r_addend
& 0xffffffff);
543 len
= 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
544 stub_name
= bfd_malloc (len
);
545 if (stub_name
!= NULL
)
547 sprintf (stub_name
, "%08x_%x:%x+%x",
548 input_section
->id
& 0xffffffff,
549 sym_sec
->id
& 0xffffffff,
550 (int) ELF32_R_SYM (rel
->r_info
) & 0xffffffff,
551 (int) rel
->r_addend
& 0xffffffff);
557 /* Look up an entry in the stub hash. Stub entries are cached because
558 creating the stub name takes a bit of time. */
560 static struct elf32_hppa_stub_hash_entry
*
561 hppa_get_stub_entry (input_section
, sym_sec
, hash
, rel
, htab
)
562 const asection
*input_section
;
563 const asection
*sym_sec
;
564 struct elf32_hppa_link_hash_entry
*hash
;
565 const Elf_Internal_Rela
*rel
;
566 struct elf32_hppa_link_hash_table
*htab
;
568 struct elf32_hppa_stub_hash_entry
*stub_entry
;
569 const asection
*id_sec
;
571 /* If this input section is part of a group of sections sharing one
572 stub section, then use the id of the first section in the group.
573 Stub names need to include a section id, as there may well be
574 more than one stub used to reach say, printf, and we need to
575 distinguish between them. */
576 id_sec
= htab
->stub_group
[input_section
->id
].link_sec
;
578 if (hash
!= NULL
&& hash
->stub_cache
!= NULL
579 && hash
->stub_cache
->h
== hash
580 && hash
->stub_cache
->id_sec
== id_sec
)
582 stub_entry
= hash
->stub_cache
;
588 stub_name
= hppa_stub_name (id_sec
, sym_sec
, hash
, rel
);
589 if (stub_name
== NULL
)
592 stub_entry
= hppa_stub_hash_lookup (&htab
->stub_hash_table
,
593 stub_name
, false, false);
595 hash
->stub_cache
= stub_entry
;
603 /* Add a new stub entry to the stub hash. Not all fields of the new
604 stub entry are initialised. */
606 static struct elf32_hppa_stub_hash_entry
*
607 hppa_add_stub (stub_name
, section
, htab
)
608 const char *stub_name
;
610 struct elf32_hppa_link_hash_table
*htab
;
614 struct elf32_hppa_stub_hash_entry
*stub_entry
;
616 link_sec
= htab
->stub_group
[section
->id
].link_sec
;
617 stub_sec
= htab
->stub_group
[section
->id
].stub_sec
;
618 if (stub_sec
== NULL
)
620 stub_sec
= htab
->stub_group
[link_sec
->id
].stub_sec
;
621 if (stub_sec
== NULL
)
626 len
= strlen (link_sec
->name
) + sizeof (STUB_SUFFIX
);
627 s_name
= bfd_alloc (htab
->stub_bfd
, len
);
631 strcpy (s_name
, link_sec
->name
);
632 strcpy (s_name
+ len
- sizeof (STUB_SUFFIX
), STUB_SUFFIX
);
633 stub_sec
= (*htab
->add_stub_section
) (s_name
, link_sec
);
634 if (stub_sec
== NULL
)
636 htab
->stub_group
[link_sec
->id
].stub_sec
= stub_sec
;
638 htab
->stub_group
[section
->id
].stub_sec
= stub_sec
;
641 /* Enter this entry into the linker stub hash table. */
642 stub_entry
= hppa_stub_hash_lookup (&htab
->stub_hash_table
, stub_name
,
644 if (stub_entry
== NULL
)
646 (*_bfd_error_handler
) (_("%s: cannot create stub entry %s"),
647 bfd_archive_filename (section
->owner
),
652 stub_entry
->stub_sec
= stub_sec
;
653 stub_entry
->stub_offset
= 0;
654 stub_entry
->id_sec
= link_sec
;
658 /* Determine the type of stub needed, if any, for a call. */
660 static enum elf32_hppa_stub_type
661 hppa_type_of_stub (input_sec
, rel
, hash
, destination
)
663 const Elf_Internal_Rela
*rel
;
664 struct elf32_hppa_link_hash_entry
*hash
;
668 bfd_vma branch_offset
;
669 bfd_vma max_branch_offset
;
673 && (((hash
->elf
.root
.type
== bfd_link_hash_defined
674 || hash
->elf
.root
.type
== bfd_link_hash_defweak
)
675 && hash
->elf
.root
.u
.def
.section
->output_section
== NULL
)
676 || (hash
->elf
.root
.type
== bfd_link_hash_defweak
677 && hash
->elf
.dynindx
!= -1
678 && hash
->elf
.plt
.offset
!= (bfd_vma
) -1)
679 || hash
->elf
.root
.type
== bfd_link_hash_undefweak
680 || hash
->elf
.root
.type
== bfd_link_hash_undefined
681 || (hash
->maybe_pic_call
&& !(input_sec
->flags
& SEC_HAS_GOT_REF
))))
683 /* If output_section is NULL, then it's a symbol defined in a
684 shared library. We will need an import stub. Decide between
685 hppa_stub_import and hppa_stub_import_shared later. For
686 shared links we need stubs for undefined or weak syms too;
687 They will presumably be resolved by the dynamic linker. */
688 return hppa_stub_import
;
691 /* Determine where the call point is. */
692 location
= (input_sec
->output_offset
693 + input_sec
->output_section
->vma
696 branch_offset
= destination
- location
- 8;
697 r_type
= ELF32_R_TYPE (rel
->r_info
);
699 /* Determine if a long branch stub is needed. parisc branch offsets
700 are relative to the second instruction past the branch, ie. +8
701 bytes on from the branch instruction location. The offset is
702 signed and counts in units of 4 bytes. */
703 if (r_type
== (unsigned int) R_PARISC_PCREL17F
)
705 max_branch_offset
= (1 << (17-1)) << 2;
707 else if (r_type
== (unsigned int) R_PARISC_PCREL12F
)
709 max_branch_offset
= (1 << (12-1)) << 2;
711 else /* R_PARISC_PCREL22F. */
713 max_branch_offset
= (1 << (22-1)) << 2;
716 if (branch_offset
+ max_branch_offset
>= 2*max_branch_offset
)
717 return hppa_stub_long_branch
;
719 return hppa_stub_none
;
722 /* Build one linker stub as defined by the stub hash table entry GEN_ENTRY.
723 IN_ARG contains the link info pointer. */
725 #define LDIL_R1 0x20200000 /* ldil LR'XXX,%r1 */
726 #define BE_SR4_R1 0xe0202002 /* be,n RR'XXX(%sr4,%r1) */
728 #define BL_R1 0xe8200000 /* b,l .+8,%r1 */
729 #define ADDIL_R1 0x28200000 /* addil LR'XXX,%r1,%r1 */
730 #define DEPI_R1 0xd4201c1e /* depi 0,31,2,%r1 */
732 #define ADDIL_DP 0x2b600000 /* addil LR'XXX,%dp,%r1 */
733 #define LDW_R1_R21 0x48350000 /* ldw RR'XXX(%sr0,%r1),%r21 */
734 #define BV_R0_R21 0xeaa0c000 /* bv %r0(%r21) */
735 #define LDW_R1_R19 0x48330000 /* ldw RR'XXX(%sr0,%r1),%r19 */
737 #define ADDIL_R19 0x2a600000 /* addil LR'XXX,%r19,%r1 */
738 #define LDW_R1_DP 0x483b0000 /* ldw RR'XXX(%sr0,%r1),%dp */
740 #define LDSID_R21_R1 0x02a010a1 /* ldsid (%sr0,%r21),%r1 */
741 #define MTSP_R1 0x00011820 /* mtsp %r1,%sr0 */
742 #define BE_SR0_R21 0xe2a00000 /* be 0(%sr0,%r21) */
743 #define STW_RP 0x6bc23fd1 /* stw %rp,-24(%sr0,%sp) */
745 #define BL_RP 0xe8400002 /* b,l,n XXX,%rp */
746 #define NOP 0x08000240 /* nop */
747 #define LDW_RP 0x4bc23fd1 /* ldw -24(%sr0,%sp),%rp */
748 #define LDSID_RP_R1 0x004010a1 /* ldsid (%sr0,%rp),%r1 */
749 #define BE_SR0_RP 0xe0400002 /* be,n 0(%sr0,%rp) */
756 #define LDW_R1_DLT LDW_R1_R19
758 #define LDW_R1_DLT LDW_R1_DP
762 hppa_build_one_stub (gen_entry
, in_arg
)
763 struct bfd_hash_entry
*gen_entry
;
766 struct elf32_hppa_stub_hash_entry
*stub_entry
;
767 struct bfd_link_info
*info
;
768 struct elf32_hppa_link_hash_table
*htab
;
778 /* Massage our args to the form they really have. */
779 stub_entry
= (struct elf32_hppa_stub_hash_entry
*) gen_entry
;
780 info
= (struct bfd_link_info
*) in_arg
;
782 htab
= hppa_link_hash_table (info
);
783 stub_sec
= stub_entry
->stub_sec
;
785 /* Make a note of the offset within the stubs for this entry. */
786 stub_entry
->stub_offset
= stub_sec
->_raw_size
;
787 loc
= stub_sec
->contents
+ stub_entry
->stub_offset
;
789 stub_bfd
= stub_sec
->owner
;
791 switch (stub_entry
->stub_type
)
793 case hppa_stub_long_branch
:
794 /* Create the long branch. A long branch is formed with "ldil"
795 loading the upper bits of the target address into a register,
796 then branching with "be" which adds in the lower bits.
797 The "be" has its delay slot nullified. */
798 sym_value
= (stub_entry
->target_value
799 + stub_entry
->target_section
->output_offset
800 + stub_entry
->target_section
->output_section
->vma
);
802 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) 0, e_lrsel
);
803 insn
= hppa_rebuild_insn ((int) LDIL_R1
, val
, 21);
804 bfd_put_32 (stub_bfd
, insn
, loc
);
806 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) 0, e_rrsel
) >> 2;
807 insn
= hppa_rebuild_insn ((int) BE_SR4_R1
, val
, 17);
808 bfd_put_32 (stub_bfd
, insn
, loc
+ 4);
813 case hppa_stub_long_branch_shared
:
814 /* Branches are relative. This is where we are going to. */
815 sym_value
= (stub_entry
->target_value
816 + stub_entry
->target_section
->output_offset
817 + stub_entry
->target_section
->output_section
->vma
);
819 /* And this is where we are coming from, more or less. */
820 sym_value
-= (stub_entry
->stub_offset
821 + stub_sec
->output_offset
822 + stub_sec
->output_section
->vma
);
824 bfd_put_32 (stub_bfd
, (bfd_vma
) BL_R1
, loc
);
825 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) -8, e_lrsel
);
826 insn
= hppa_rebuild_insn ((int) ADDIL_R1
, val
, 21);
827 bfd_put_32 (stub_bfd
, insn
, loc
+ 4);
829 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) -8, e_rrsel
) >> 2;
830 insn
= hppa_rebuild_insn ((int) BE_SR4_R1
, val
, 17);
831 bfd_put_32 (stub_bfd
, insn
, loc
+ 8);
835 case hppa_stub_import
:
836 case hppa_stub_import_shared
:
837 off
= stub_entry
->h
->elf
.plt
.offset
;
838 if (off
>= (bfd_vma
) -2)
841 off
&= ~ (bfd_vma
) 1;
843 + htab
->splt
->output_offset
844 + htab
->splt
->output_section
->vma
845 - elf_gp (htab
->splt
->output_section
->owner
));
849 if (stub_entry
->stub_type
== hppa_stub_import_shared
)
852 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) 0, e_lrsel
),
853 insn
= hppa_rebuild_insn ((int) insn
, val
, 21);
854 bfd_put_32 (stub_bfd
, insn
, loc
);
856 /* It is critical to use lrsel/rrsel here because we are using
857 two different offsets (+0 and +4) from sym_value. If we use
858 lsel/rsel then with unfortunate sym_values we will round
859 sym_value+4 up to the next 2k block leading to a mis-match
860 between the lsel and rsel value. */
861 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) 0, e_rrsel
);
862 insn
= hppa_rebuild_insn ((int) LDW_R1_R21
, val
, 14);
863 bfd_put_32 (stub_bfd
, insn
, loc
+ 4);
865 if (htab
->multi_subspace
)
867 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) 4, e_rrsel
);
868 insn
= hppa_rebuild_insn ((int) LDW_R1_DLT
, val
, 14);
869 bfd_put_32 (stub_bfd
, insn
, loc
+ 8);
871 bfd_put_32 (stub_bfd
, (bfd_vma
) LDSID_R21_R1
, loc
+ 12);
872 bfd_put_32 (stub_bfd
, (bfd_vma
) MTSP_R1
, loc
+ 16);
873 bfd_put_32 (stub_bfd
, (bfd_vma
) BE_SR0_R21
, loc
+ 20);
874 bfd_put_32 (stub_bfd
, (bfd_vma
) STW_RP
, loc
+ 24);
880 bfd_put_32 (stub_bfd
, (bfd_vma
) BV_R0_R21
, loc
+ 8);
881 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) 4, e_rrsel
);
882 insn
= hppa_rebuild_insn ((int) LDW_R1_DLT
, val
, 14);
883 bfd_put_32 (stub_bfd
, insn
, loc
+ 12);
889 && stub_entry
->h
!= NULL
890 && stub_entry
->h
->pic_call
)
892 /* Build the .plt entry needed to call a PIC function from
893 statically linked code. We don't need any relocs. */
895 struct elf32_hppa_link_hash_entry
*eh
;
898 dynobj
= htab
->elf
.dynobj
;
899 eh
= (struct elf32_hppa_link_hash_entry
*) stub_entry
->h
;
901 if (eh
->elf
.root
.type
!= bfd_link_hash_defined
902 && eh
->elf
.root
.type
!= bfd_link_hash_defweak
)
905 value
= (eh
->elf
.root
.u
.def
.value
906 + eh
->elf
.root
.u
.def
.section
->output_offset
907 + eh
->elf
.root
.u
.def
.section
->output_section
->vma
);
909 /* Fill in the entry in the procedure linkage table.
911 The format of a plt entry is
915 bfd_put_32 (htab
->splt
->owner
, value
,
916 htab
->splt
->contents
+ off
);
917 value
= elf_gp (htab
->splt
->output_section
->owner
);
918 bfd_put_32 (htab
->splt
->owner
, value
,
919 htab
->splt
->contents
+ off
+ 4);
923 case hppa_stub_export
:
924 /* Branches are relative. This is where we are going to. */
925 sym_value
= (stub_entry
->target_value
926 + stub_entry
->target_section
->output_offset
927 + stub_entry
->target_section
->output_section
->vma
);
929 /* And this is where we are coming from. */
930 sym_value
-= (stub_entry
->stub_offset
931 + stub_sec
->output_offset
932 + stub_sec
->output_section
->vma
);
934 if (sym_value
- 8 + 0x40000 >= 0x80000)
936 (*_bfd_error_handler
)
937 (_("%s(%s+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
938 bfd_archive_filename (stub_entry
->target_section
->owner
),
940 (long) stub_entry
->stub_offset
,
941 stub_entry
->root
.string
);
942 bfd_set_error (bfd_error_bad_value
);
946 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) -8, e_fsel
) >> 2;
947 insn
= hppa_rebuild_insn ((int) BL_RP
, val
, 17);
948 bfd_put_32 (stub_bfd
, insn
, loc
);
950 bfd_put_32 (stub_bfd
, (bfd_vma
) NOP
, loc
+ 4);
951 bfd_put_32 (stub_bfd
, (bfd_vma
) LDW_RP
, loc
+ 8);
952 bfd_put_32 (stub_bfd
, (bfd_vma
) LDSID_RP_R1
, loc
+ 12);
953 bfd_put_32 (stub_bfd
, (bfd_vma
) MTSP_R1
, loc
+ 16);
954 bfd_put_32 (stub_bfd
, (bfd_vma
) BE_SR0_RP
, loc
+ 20);
956 /* Point the function symbol at the stub. */
957 stub_entry
->h
->elf
.root
.u
.def
.section
= stub_sec
;
958 stub_entry
->h
->elf
.root
.u
.def
.value
= stub_sec
->_raw_size
;
968 stub_sec
->_raw_size
+= size
;
994 /* As above, but don't actually build the stub. Just bump offset so
995 we know stub section sizes. */
998 hppa_size_one_stub (gen_entry
, in_arg
)
999 struct bfd_hash_entry
*gen_entry
;
1002 struct elf32_hppa_stub_hash_entry
*stub_entry
;
1003 struct elf32_hppa_link_hash_table
*htab
;
1006 /* Massage our args to the form they really have. */
1007 stub_entry
= (struct elf32_hppa_stub_hash_entry
*) gen_entry
;
1008 htab
= (struct elf32_hppa_link_hash_table
*) in_arg
;
1010 if (stub_entry
->stub_type
== hppa_stub_long_branch
)
1012 else if (stub_entry
->stub_type
== hppa_stub_long_branch_shared
)
1014 else if (stub_entry
->stub_type
== hppa_stub_export
)
1016 else /* hppa_stub_import or hppa_stub_import_shared. */
1018 if (htab
->multi_subspace
)
1024 stub_entry
->stub_sec
->_raw_size
+= size
;
1028 /* Return nonzero if ABFD represents an HPPA ELF32 file.
1029 Additionally we set the default architecture and machine. */
1032 elf32_hppa_object_p (abfd
)
1035 Elf_Internal_Ehdr
* i_ehdrp
;
1038 i_ehdrp
= elf_elfheader (abfd
);
1039 if (strcmp (bfd_get_target (abfd
), "elf32-hppa-linux") == 0)
1041 if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_LINUX
)
1046 if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_HPUX
)
1050 flags
= i_ehdrp
->e_flags
;
1051 switch (flags
& (EF_PARISC_ARCH
| EF_PARISC_WIDE
))
1053 case EFA_PARISC_1_0
:
1054 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 10);
1055 case EFA_PARISC_1_1
:
1056 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 11);
1057 case EFA_PARISC_2_0
:
1058 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 20);
1059 case EFA_PARISC_2_0
| EF_PARISC_WIDE
:
1060 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 25);
1065 /* Undo the generic ELF code's subtraction of section->vma from the
1066 value of each external symbol. */
1069 elf32_hppa_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
1070 bfd
*abfd ATTRIBUTE_UNUSED
;
1071 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1072 const Elf_Internal_Sym
*sym ATTRIBUTE_UNUSED
;
1073 const char **namep ATTRIBUTE_UNUSED
;
1074 flagword
*flagsp ATTRIBUTE_UNUSED
;
1078 *valp
+= (*secp
)->vma
;
1082 /* Create the .plt and .got sections, and set up our hash table
1083 short-cuts to various dynamic sections. */
1086 elf32_hppa_create_dynamic_sections (abfd
, info
)
1088 struct bfd_link_info
*info
;
1090 struct elf32_hppa_link_hash_table
*htab
;
1092 /* Don't try to create the .plt and .got twice. */
1093 htab
= hppa_link_hash_table (info
);
1094 if (htab
->splt
!= NULL
)
1097 /* Call the generic code to do most of the work. */
1098 if (! _bfd_elf_create_dynamic_sections (abfd
, info
))
1101 htab
->splt
= bfd_get_section_by_name (abfd
, ".plt");
1102 htab
->srelplt
= bfd_get_section_by_name (abfd
, ".rela.plt");
1104 htab
->sgot
= bfd_get_section_by_name (abfd
, ".got");
1105 htab
->srelgot
= bfd_make_section (abfd
, ".rela.got");
1106 if (htab
->srelgot
== NULL
1107 || ! bfd_set_section_flags (abfd
, htab
->srelgot
,
1112 | SEC_LINKER_CREATED
1114 || ! bfd_set_section_alignment (abfd
, htab
->srelgot
, 2))
1117 htab
->sdynbss
= bfd_get_section_by_name (abfd
, ".dynbss");
1118 htab
->srelbss
= bfd_get_section_by_name (abfd
, ".rela.bss");
1123 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1126 elf32_hppa_copy_indirect_symbol (dir
, ind
)
1127 struct elf_link_hash_entry
*dir
, *ind
;
1129 struct elf32_hppa_link_hash_entry
*edir
, *eind
;
1131 edir
= (struct elf32_hppa_link_hash_entry
*) dir
;
1132 eind
= (struct elf32_hppa_link_hash_entry
*) ind
;
1134 if (eind
->dyn_relocs
!= NULL
)
1136 if (edir
->dyn_relocs
!= NULL
)
1138 struct elf32_hppa_dyn_reloc_entry
**pp
;
1139 struct elf32_hppa_dyn_reloc_entry
*p
;
1141 if (ind
->root
.type
== bfd_link_hash_indirect
)
1144 /* Add reloc counts against the weak sym to the strong sym
1145 list. Merge any entries against the same section. */
1146 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1148 struct elf32_hppa_dyn_reloc_entry
*q
;
1150 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1151 if (q
->sec
== p
->sec
)
1153 #if RELATIVE_DYNRELOCS
1154 q
->relative_count
+= p
->relative_count
;
1156 q
->count
+= p
->count
;
1163 *pp
= edir
->dyn_relocs
;
1166 edir
->dyn_relocs
= eind
->dyn_relocs
;
1167 eind
->dyn_relocs
= NULL
;
1170 _bfd_elf_link_hash_copy_indirect (dir
, ind
);
1173 /* Look through the relocs for a section during the first phase, and
1174 calculate needed space in the global offset table, procedure linkage
1175 table, and dynamic reloc sections. At this point we haven't
1176 necessarily read all the input files. */
1179 elf32_hppa_check_relocs (abfd
, info
, sec
, relocs
)
1181 struct bfd_link_info
*info
;
1183 const Elf_Internal_Rela
*relocs
;
1185 Elf_Internal_Shdr
*symtab_hdr
;
1186 struct elf_link_hash_entry
**sym_hashes
;
1187 const Elf_Internal_Rela
*rel
;
1188 const Elf_Internal_Rela
*rel_end
;
1189 struct elf32_hppa_link_hash_table
*htab
;
1191 asection
*stubreloc
;
1193 if (info
->relocateable
)
1196 htab
= hppa_link_hash_table (info
);
1197 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1198 sym_hashes
= elf_sym_hashes (abfd
);
1202 rel_end
= relocs
+ sec
->reloc_count
;
1203 for (rel
= relocs
; rel
< rel_end
; rel
++)
1212 unsigned int r_symndx
, r_type
;
1213 struct elf32_hppa_link_hash_entry
*h
;
1216 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1218 if (r_symndx
< symtab_hdr
->sh_info
)
1221 h
= ((struct elf32_hppa_link_hash_entry
*)
1222 sym_hashes
[r_symndx
- symtab_hdr
->sh_info
]);
1224 r_type
= ELF32_R_TYPE (rel
->r_info
);
1228 case R_PARISC_DLTIND14F
:
1229 case R_PARISC_DLTIND14R
:
1230 case R_PARISC_DLTIND21L
:
1231 /* This symbol requires a global offset table entry. */
1232 need_entry
= NEED_GOT
;
1234 /* Mark this section as containing PIC code. */
1235 sec
->flags
|= SEC_HAS_GOT_REF
;
1238 case R_PARISC_PLABEL14R
: /* "Official" procedure labels. */
1239 case R_PARISC_PLABEL21L
:
1240 case R_PARISC_PLABEL32
:
1241 /* If the addend is non-zero, we break badly. */
1242 if (rel
->r_addend
!= 0)
1245 /* If we are creating a shared library, then we need to
1246 create a PLT entry for all PLABELs, because PLABELs with
1247 local symbols may be passed via a pointer to another
1248 object. Additionally, output a dynamic relocation
1249 pointing to the PLT entry.
1250 For executables, the original 32-bit ABI allowed two
1251 different styles of PLABELs (function pointers): For
1252 global functions, the PLABEL word points into the .plt
1253 two bytes past a (function address, gp) pair, and for
1254 local functions the PLABEL points directly at the
1255 function. The magic +2 for the first type allows us to
1256 differentiate between the two. As you can imagine, this
1257 is a real pain when it comes to generating code to call
1258 functions indirectly or to compare function pointers.
1259 We avoid the mess by always pointing a PLABEL into the
1260 .plt, even for local functions. */
1261 need_entry
= PLT_PLABEL
| NEED_PLT
| NEED_DYNREL
;
1264 case R_PARISC_PCREL12F
:
1265 htab
->has_12bit_branch
= 1;
1267 case R_PARISC_PCREL17C
:
1268 case R_PARISC_PCREL17F
:
1269 htab
->has_17bit_branch
= 1;
1271 case R_PARISC_PCREL22F
:
1272 /* Function calls might need to go through the .plt, and
1273 might require long branch stubs. */
1276 /* We know local syms won't need a .plt entry, and if
1277 they need a long branch stub we can't guarantee that
1278 we can reach the stub. So just flag an error later
1279 if we're doing a shared link and find we need a long
1285 /* Global symbols will need a .plt entry if they remain
1286 global, and in most cases won't need a long branch
1287 stub. Unfortunately, we have to cater for the case
1288 where a symbol is forced local by versioning, or due
1289 to symbolic linking, and we lose the .plt entry. */
1290 need_entry
= NEED_PLT
;
1291 if (h
->elf
.type
== STT_PARISC_MILLI
)
1296 case R_PARISC_SEGBASE
: /* Used to set segment base. */
1297 case R_PARISC_SEGREL32
: /* Relative reloc, used for unwind. */
1298 case R_PARISC_PCREL14F
: /* PC relative load/store. */
1299 case R_PARISC_PCREL14R
:
1300 case R_PARISC_PCREL17R
: /* External branches. */
1301 case R_PARISC_PCREL21L
: /* As above, and for load/store too. */
1302 /* We don't need to propagate the relocation if linking a
1303 shared object since these are section relative. */
1306 case R_PARISC_DPREL14F
: /* Used for gp rel data load/store. */
1307 case R_PARISC_DPREL14R
:
1308 case R_PARISC_DPREL21L
:
1311 (*_bfd_error_handler
)
1312 (_("%s: relocation %s can not be used when making a shared object; recompile with -fPIC"),
1313 bfd_archive_filename (abfd
),
1314 elf_hppa_howto_table
[r_type
].name
);
1315 bfd_set_error (bfd_error_bad_value
);
1320 case R_PARISC_DIR17F
: /* Used for external branches. */
1321 case R_PARISC_DIR17R
:
1322 case R_PARISC_DIR14F
: /* Used for load/store from absolute locn. */
1323 case R_PARISC_DIR14R
:
1324 case R_PARISC_DIR21L
: /* As above, and for ext branches too. */
1326 /* Help debug shared library creation. Any of the above
1327 relocs can be used in shared libs, but they may cause
1328 pages to become unshared. */
1331 (*_bfd_error_handler
)
1332 (_("%s: relocation %s should not be used when making a shared object; recompile with -fPIC"),
1333 bfd_archive_filename (abfd
),
1334 elf_hppa_howto_table
[r_type
].name
);
1339 case R_PARISC_DIR32
: /* .word relocs. */
1340 /* We may want to output a dynamic relocation later. */
1341 need_entry
= NEED_DYNREL
;
1344 /* This relocation describes the C++ object vtable hierarchy.
1345 Reconstruct it for later use during GC. */
1346 case R_PARISC_GNU_VTINHERIT
:
1347 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
,
1348 &h
->elf
, rel
->r_offset
))
1352 /* This relocation describes which C++ vtable entries are actually
1353 used. Record for later use during GC. */
1354 case R_PARISC_GNU_VTENTRY
:
1355 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
,
1356 &h
->elf
, rel
->r_addend
))
1364 /* Now carry out our orders. */
1365 if (need_entry
& NEED_GOT
)
1367 /* Allocate space for a GOT entry, as well as a dynamic
1368 relocation for this entry. */
1369 if (htab
->sgot
== NULL
)
1371 if (htab
->elf
.dynobj
== NULL
)
1372 htab
->elf
.dynobj
= abfd
;
1373 if (!elf32_hppa_create_dynamic_sections (htab
->elf
.dynobj
, info
))
1379 h
->elf
.got
.refcount
+= 1;
1383 bfd_signed_vma
*local_got_refcounts
;
1385 /* This is a global offset table entry for a local symbol. */
1386 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1387 if (local_got_refcounts
== NULL
)
1391 /* Allocate space for local got offsets and local
1392 plt offsets. Done this way to save polluting
1393 elf_obj_tdata with another target specific
1395 size
= symtab_hdr
->sh_info
;
1396 size
*= 2 * sizeof (bfd_signed_vma
);
1397 local_got_refcounts
= ((bfd_signed_vma
*)
1398 bfd_zalloc (abfd
, size
));
1399 if (local_got_refcounts
== NULL
)
1401 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1403 local_got_refcounts
[r_symndx
] += 1;
1407 if (need_entry
& NEED_PLT
)
1409 /* If we are creating a shared library, and this is a reloc
1410 against a weak symbol or a global symbol in a dynamic
1411 object, then we will be creating an import stub and a
1412 .plt entry for the symbol. Similarly, on a normal link
1413 to symbols defined in a dynamic object we'll need the
1414 import stub and a .plt entry. We don't know yet whether
1415 the symbol is defined or not, so make an entry anyway and
1416 clean up later in adjust_dynamic_symbol. */
1417 if ((sec
->flags
& SEC_ALLOC
) != 0)
1421 h
->elf
.elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
1422 h
->elf
.plt
.refcount
+= 1;
1424 /* If this .plt entry is for a plabel, mark it so
1425 that adjust_dynamic_symbol will keep the entry
1426 even if it appears to be local. */
1427 if (need_entry
& PLT_PLABEL
)
1430 else if (need_entry
& PLT_PLABEL
)
1432 bfd_signed_vma
*local_got_refcounts
;
1433 bfd_signed_vma
*local_plt_refcounts
;
1435 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1436 if (local_got_refcounts
== NULL
)
1440 /* Allocate space for local got offsets and local
1442 size
= symtab_hdr
->sh_info
;
1443 size
*= 2 * sizeof (bfd_signed_vma
);
1444 local_got_refcounts
= ((bfd_signed_vma
*)
1445 bfd_zalloc (abfd
, size
));
1446 if (local_got_refcounts
== NULL
)
1448 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1450 local_plt_refcounts
= (local_got_refcounts
1451 + symtab_hdr
->sh_info
);
1452 local_plt_refcounts
[r_symndx
] += 1;
1457 if (need_entry
& NEED_DYNREL
)
1459 /* Flag this symbol as having a non-got, non-plt reference
1460 so that we generate copy relocs if it turns out to be
1462 if (h
!= NULL
&& !info
->shared
)
1463 h
->elf
.elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
1465 /* If we are creating a shared library then we need to copy
1466 the reloc into the shared library. However, if we are
1467 linking with -Bsymbolic, we need only copy absolute
1468 relocs or relocs against symbols that are not defined in
1469 an object we are including in the link. PC- or DP- or
1470 DLT-relative relocs against any local sym or global sym
1471 with DEF_REGULAR set, can be discarded. At this point we
1472 have not seen all the input files, so it is possible that
1473 DEF_REGULAR is not set now but will be set later (it is
1474 never cleared). We account for that possibility below by
1475 storing information in the dyn_relocs field of the
1478 A similar situation to the -Bsymbolic case occurs when
1479 creating shared libraries and symbol visibility changes
1480 render the symbol local.
1482 As it turns out, all the relocs we will be creating here
1483 are absolute, so we cannot remove them on -Bsymbolic
1484 links or visibility changes anyway. A STUB_REL reloc
1485 is absolute too, as in that case it is the reloc in the
1486 stub we will be creating, rather than copying the PCREL
1487 reloc in the branch.
1489 If on the other hand, we are creating an executable, we
1490 may need to keep relocations for symbols satisfied by a
1491 dynamic library if we manage to avoid copy relocs for the
1494 && (sec
->flags
& SEC_ALLOC
) != 0
1495 && (IS_ABSOLUTE_RELOC (r_type
)
1498 || h
->elf
.root
.type
== bfd_link_hash_defweak
1499 || (h
->elf
.elf_link_hash_flags
1500 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1502 && (sec
->flags
& SEC_ALLOC
) != 0
1504 && (h
->elf
.root
.type
== bfd_link_hash_defweak
1505 || (h
->elf
.elf_link_hash_flags
1506 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
1508 struct elf32_hppa_dyn_reloc_entry
*p
;
1509 struct elf32_hppa_dyn_reloc_entry
**head
;
1511 /* Create a reloc section in dynobj and make room for
1518 name
= (bfd_elf_string_from_elf_section
1520 elf_elfheader (abfd
)->e_shstrndx
,
1521 elf_section_data (sec
)->rel_hdr
.sh_name
));
1524 (*_bfd_error_handler
)
1525 (_("Could not find relocation section for %s"),
1527 bfd_set_error (bfd_error_bad_value
);
1531 if (htab
->elf
.dynobj
== NULL
)
1532 htab
->elf
.dynobj
= abfd
;
1534 dynobj
= htab
->elf
.dynobj
;
1535 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1540 sreloc
= bfd_make_section (dynobj
, name
);
1541 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
1542 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
1543 if ((sec
->flags
& SEC_ALLOC
) != 0)
1544 flags
|= SEC_ALLOC
| SEC_LOAD
;
1546 || !bfd_set_section_flags (dynobj
, sreloc
, flags
)
1547 || !bfd_set_section_alignment (dynobj
, sreloc
, 2))
1551 elf_section_data (sec
)->sreloc
= sreloc
;
1554 /* If this is a global symbol, we count the number of
1555 relocations we need for this symbol. */
1558 head
= &h
->dyn_relocs
;
1562 /* Track dynamic relocs needed for local syms too.
1563 We really need local syms available to do this
1567 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
1572 head
= ((struct elf32_hppa_dyn_reloc_entry
**)
1573 &elf_section_data (s
)->local_dynrel
);
1577 if (p
== NULL
|| p
->sec
!= sec
)
1579 p
= ((struct elf32_hppa_dyn_reloc_entry
*)
1580 bfd_alloc (htab
->elf
.dynobj
,
1581 (bfd_size_type
) sizeof *p
));
1588 #if RELATIVE_DYNRELOCS
1589 p
->relative_count
= 0;
1594 #if RELATIVE_DYNRELOCS
1595 if (!IS_ABSOLUTE_RELOC (rtype
))
1596 p
->relative_count
+= 1;
1605 /* Return the section that should be marked against garbage collection
1606 for a given relocation. */
1609 elf32_hppa_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
1611 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1612 Elf_Internal_Rela
*rel
;
1613 struct elf_link_hash_entry
*h
;
1614 Elf_Internal_Sym
*sym
;
1618 switch ((unsigned int) ELF32_R_TYPE (rel
->r_info
))
1620 case R_PARISC_GNU_VTINHERIT
:
1621 case R_PARISC_GNU_VTENTRY
:
1625 switch (h
->root
.type
)
1627 case bfd_link_hash_defined
:
1628 case bfd_link_hash_defweak
:
1629 return h
->root
.u
.def
.section
;
1631 case bfd_link_hash_common
:
1632 return h
->root
.u
.c
.p
->section
;
1641 if (!(elf_bad_symtab (abfd
)
1642 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
1643 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
1644 && sym
->st_shndx
!= SHN_COMMON
))
1646 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
1653 /* Update the got and plt entry reference counts for the section being
1657 elf32_hppa_gc_sweep_hook (abfd
, info
, sec
, relocs
)
1659 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1661 const Elf_Internal_Rela
*relocs
;
1663 Elf_Internal_Shdr
*symtab_hdr
;
1664 struct elf_link_hash_entry
**sym_hashes
;
1665 bfd_signed_vma
*local_got_refcounts
;
1666 bfd_signed_vma
*local_plt_refcounts
;
1667 const Elf_Internal_Rela
*rel
, *relend
;
1668 unsigned long r_symndx
;
1669 struct elf_link_hash_entry
*h
;
1670 struct elf32_hppa_link_hash_table
*htab
;
1673 elf_section_data (sec
)->local_dynrel
= NULL
;
1675 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1676 sym_hashes
= elf_sym_hashes (abfd
);
1677 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1678 local_plt_refcounts
= local_got_refcounts
;
1679 if (local_plt_refcounts
!= NULL
)
1680 local_plt_refcounts
+= symtab_hdr
->sh_info
;
1681 htab
= hppa_link_hash_table (info
);
1682 dynobj
= htab
->elf
.dynobj
;
1686 relend
= relocs
+ sec
->reloc_count
;
1687 for (rel
= relocs
; rel
< relend
; rel
++)
1688 switch ((unsigned int) ELF32_R_TYPE (rel
->r_info
))
1690 case R_PARISC_DLTIND14F
:
1691 case R_PARISC_DLTIND14R
:
1692 case R_PARISC_DLTIND21L
:
1693 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1694 if (r_symndx
>= symtab_hdr
->sh_info
)
1696 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1697 if (h
->got
.refcount
> 0)
1698 h
->got
.refcount
-= 1;
1700 else if (local_got_refcounts
!= NULL
)
1702 if (local_got_refcounts
[r_symndx
] > 0)
1703 local_got_refcounts
[r_symndx
] -= 1;
1707 case R_PARISC_PCREL12F
:
1708 case R_PARISC_PCREL17C
:
1709 case R_PARISC_PCREL17F
:
1710 case R_PARISC_PCREL22F
:
1711 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1712 if (r_symndx
>= symtab_hdr
->sh_info
)
1714 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1715 if (h
->plt
.refcount
> 0)
1716 h
->plt
.refcount
-= 1;
1720 case R_PARISC_PLABEL14R
:
1721 case R_PARISC_PLABEL21L
:
1722 case R_PARISC_PLABEL32
:
1723 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1724 if (r_symndx
>= symtab_hdr
->sh_info
)
1726 struct elf32_hppa_link_hash_entry
*eh
;
1727 struct elf32_hppa_dyn_reloc_entry
**pp
;
1728 struct elf32_hppa_dyn_reloc_entry
*p
;
1730 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1732 if (h
->plt
.refcount
> 0)
1733 h
->plt
.refcount
-= 1;
1735 eh
= (struct elf32_hppa_link_hash_entry
*) h
;
1737 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1740 #if RELATIVE_DYNRELOCS
1741 if (!IS_ABSOLUTE_RELOC (rtype
))
1742 p
->relative_count
-= 1;
1750 else if (local_plt_refcounts
!= NULL
)
1752 if (local_plt_refcounts
[r_symndx
] > 0)
1753 local_plt_refcounts
[r_symndx
] -= 1;
1757 case R_PARISC_DIR32
:
1758 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1759 if (r_symndx
>= symtab_hdr
->sh_info
)
1761 struct elf32_hppa_link_hash_entry
*eh
;
1762 struct elf32_hppa_dyn_reloc_entry
**pp
;
1763 struct elf32_hppa_dyn_reloc_entry
*p
;
1765 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1767 eh
= (struct elf32_hppa_link_hash_entry
*) h
;
1769 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1772 #if RELATIVE_DYNRELOCS
1773 if (!IS_ABSOLUTE_RELOC (R_PARISC_DIR32
))
1774 p
->relative_count
-= 1;
1791 /* Our own version of hide_symbol, so that we can keep plt entries for
1795 elf32_hppa_hide_symbol (info
, h
)
1796 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1797 struct elf_link_hash_entry
*h
;
1799 if ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
1801 if (! ((struct elf32_hppa_link_hash_entry
*) h
)->plabel
)
1803 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1804 h
->plt
.offset
= (bfd_vma
) -1;
1808 /* This is the condition under which elf32_hppa_finish_dynamic_symbol
1809 will be called from elflink.h. If elflink.h doesn't call our
1810 finish_dynamic_symbol routine, we'll need to do something about
1811 initializing any .plt and .got entries in elf32_hppa_relocate_section. */
1812 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1814 && ((INFO)->shared \
1815 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1816 && ((H)->dynindx != -1 \
1817 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1819 /* Adjust a symbol defined by a dynamic object and referenced by a
1820 regular object. The current definition is in some section of the
1821 dynamic object, but we're not including those sections. We have to
1822 change the definition to something the rest of the link can
1826 elf32_hppa_adjust_dynamic_symbol (info
, h
)
1827 struct bfd_link_info
*info
;
1828 struct elf_link_hash_entry
*h
;
1830 struct elf32_hppa_link_hash_table
*htab
;
1831 struct elf32_hppa_link_hash_entry
*eh
;
1832 struct elf32_hppa_dyn_reloc_entry
*p
;
1834 unsigned int power_of_two
;
1836 /* If this is a function, put it in the procedure linkage table. We
1837 will fill in the contents of the procedure linkage table later,
1838 when we know the address of the .got section. */
1839 if (h
->type
== STT_FUNC
1840 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
1843 && h
->plt
.refcount
> 0
1844 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1845 && (h
->root
.u
.def
.section
->flags
& SEC_HAS_GOT_REF
) != 0)
1847 ((struct elf32_hppa_link_hash_entry
*) h
)->maybe_pic_call
= 1;
1850 if (h
->plt
.refcount
<= 0
1851 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1852 && h
->root
.type
!= bfd_link_hash_defweak
1853 && ! ((struct elf32_hppa_link_hash_entry
*) h
)->plabel
1854 && (!info
->shared
|| info
->symbolic
)))
1856 /* The .plt entry is not needed when:
1857 a) Garbage collection has removed all references to the
1859 b) We know for certain the symbol is defined in this
1860 object, and it's not a weak definition, nor is the symbol
1861 used by a plabel relocation. Either this object is the
1862 application or we are doing a shared symbolic link. */
1864 /* As a special sop to the hppa ABI, we keep a .plt entry
1865 for functions in sections containing PIC code. */
1866 if (((struct elf32_hppa_link_hash_entry
*) h
)->maybe_pic_call
)
1867 ((struct elf32_hppa_link_hash_entry
*) h
)->pic_call
= 1;
1870 h
->plt
.offset
= (bfd_vma
) -1;
1871 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1878 h
->plt
.offset
= (bfd_vma
) -1;
1880 /* If this is a weak symbol, and there is a real definition, the
1881 processor independent code will have arranged for us to see the
1882 real definition first, and we can just use the same value. */
1883 if (h
->weakdef
!= NULL
)
1885 if (h
->weakdef
->root
.type
!= bfd_link_hash_defined
1886 && h
->weakdef
->root
.type
!= bfd_link_hash_defweak
)
1888 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
1889 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
1893 /* This is a reference to a symbol defined by a dynamic object which
1894 is not a function. */
1896 /* If we are creating a shared library, we must presume that the
1897 only references to the symbol are via the global offset table.
1898 For such cases we need not do anything here; the relocations will
1899 be handled correctly by relocate_section. */
1903 /* If there are no references to this symbol that do not use the
1904 GOT, we don't need to generate a copy reloc. */
1905 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
1908 eh
= (struct elf32_hppa_link_hash_entry
*) h
;
1909 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1911 s
= p
->sec
->output_section
;
1912 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1916 /* If we didn't find any dynamic relocs in read-only sections, then
1917 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1920 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_GOT_REF
;
1924 /* We must allocate the symbol in our .dynbss section, which will
1925 become part of the .bss section of the executable. There will be
1926 an entry for this symbol in the .dynsym section. The dynamic
1927 object will contain position independent code, so all references
1928 from the dynamic object to this symbol will go through the global
1929 offset table. The dynamic linker will use the .dynsym entry to
1930 determine the address it must put in the global offset table, so
1931 both the dynamic object and the regular object will refer to the
1932 same memory location for the variable. */
1934 htab
= hppa_link_hash_table (info
);
1936 /* We must generate a COPY reloc to tell the dynamic linker to
1937 copy the initial value out of the dynamic object and into the
1938 runtime process image. */
1939 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1941 htab
->srelbss
->_raw_size
+= sizeof (Elf32_External_Rela
);
1942 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
1945 /* We need to figure out the alignment required for this symbol. I
1946 have no idea how other ELF linkers handle this. */
1948 power_of_two
= bfd_log2 (h
->size
);
1949 if (power_of_two
> 3)
1952 /* Apply the required alignment. */
1954 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
1955 (bfd_size_type
) (1 << power_of_two
));
1956 if (power_of_two
> bfd_get_section_alignment (htab
->elf
.dynobj
, s
))
1958 if (! bfd_set_section_alignment (htab
->elf
.dynobj
, s
, power_of_two
))
1962 /* Define the symbol as being at this point in the section. */
1963 h
->root
.u
.def
.section
= s
;
1964 h
->root
.u
.def
.value
= s
->_raw_size
;
1966 /* Increment the section size to make room for the symbol. */
1967 s
->_raw_size
+= h
->size
;
1972 /* Called via elf_link_hash_traverse to create .plt entries for an
1973 application that uses statically linked PIC functions. Similar to
1974 the first part of elf32_hppa_adjust_dynamic_symbol. */
1977 mark_PIC_calls (h
, inf
)
1978 struct elf_link_hash_entry
*h
;
1979 PTR inf ATTRIBUTE_UNUSED
;
1981 if (! (h
->plt
.refcount
> 0
1982 && (h
->root
.type
== bfd_link_hash_defined
1983 || h
->root
.type
== bfd_link_hash_defweak
)
1984 && (h
->root
.u
.def
.section
->flags
& SEC_HAS_GOT_REF
) != 0))
1986 h
->plt
.offset
= (bfd_vma
) -1;
1987 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1991 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
1992 ((struct elf32_hppa_link_hash_entry
*) h
)->maybe_pic_call
= 1;
1993 ((struct elf32_hppa_link_hash_entry
*) h
)->pic_call
= 1;
1998 /* Allocate space in the .plt for entries that won't have relocations.
1999 ie. pic_call and plabel entries. */
2002 allocate_plt_static (h
, inf
)
2003 struct elf_link_hash_entry
*h
;
2006 struct bfd_link_info
*info
;
2007 struct elf32_hppa_link_hash_table
*htab
;
2010 if (h
->root
.type
== bfd_link_hash_indirect
2011 || h
->root
.type
== bfd_link_hash_warning
)
2014 info
= (struct bfd_link_info
*) inf
;
2015 htab
= hppa_link_hash_table (info
);
2016 if (((struct elf32_hppa_link_hash_entry
*) h
)->pic_call
)
2018 /* Make an entry in the .plt section for non-pic code that is
2019 calling pic code. */
2021 h
->plt
.offset
= s
->_raw_size
;
2022 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2024 else if (htab
->elf
.dynamic_sections_created
2025 && h
->plt
.refcount
> 0)
2027 /* Make sure this symbol is output as a dynamic symbol.
2028 Undefined weak syms won't yet be marked as dynamic. */
2029 if (h
->dynindx
== -1
2030 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0
2031 && h
->type
!= STT_PARISC_MILLI
)
2033 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2037 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
, h
))
2039 /* Allocate these later. */
2041 else if (((struct elf32_hppa_link_hash_entry
*) h
)->plabel
)
2043 /* Make an entry in the .plt section for plabel references
2044 that won't have a .plt entry for other reasons. */
2046 h
->plt
.offset
= s
->_raw_size
;
2047 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2051 /* No .plt entry needed. */
2052 h
->plt
.offset
= (bfd_vma
) -1;
2053 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
2058 h
->plt
.offset
= (bfd_vma
) -1;
2059 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
2065 /* Allocate space in .plt, .got and associated reloc sections for
2069 allocate_dynrelocs (h
, inf
)
2070 struct elf_link_hash_entry
*h
;
2073 struct bfd_link_info
*info
;
2074 struct elf32_hppa_link_hash_table
*htab
;
2076 struct elf32_hppa_link_hash_entry
*eh
;
2077 struct elf32_hppa_dyn_reloc_entry
*p
;
2079 if (h
->root
.type
== bfd_link_hash_indirect
2080 || h
->root
.type
== bfd_link_hash_warning
)
2083 info
= (struct bfd_link_info
*) inf
;
2084 htab
= hppa_link_hash_table (info
);
2085 if (htab
->elf
.dynamic_sections_created
2086 && h
->plt
.offset
!= (bfd_vma
) -1
2087 && !((struct elf32_hppa_link_hash_entry
*) h
)->pic_call
2088 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
, h
))
2090 /* Make an entry in the .plt section. */
2092 h
->plt
.offset
= s
->_raw_size
;
2093 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2095 /* We also need to make an entry in the .rela.plt section. */
2096 htab
->srelplt
->_raw_size
+= sizeof (Elf32_External_Rela
);
2097 htab
->need_plt_stub
= 1;
2100 if (h
->got
.refcount
> 0)
2102 /* Make sure this symbol is output as a dynamic symbol.
2103 Undefined weak syms won't yet be marked as dynamic. */
2104 if (h
->dynindx
== -1
2105 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0
2106 && h
->type
!= STT_PARISC_MILLI
)
2108 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2113 h
->got
.offset
= s
->_raw_size
;
2114 s
->_raw_size
+= GOT_ENTRY_SIZE
;
2115 if (htab
->elf
.dynamic_sections_created
2117 || (h
->dynindx
!= -1
2118 && h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0))
2120 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rela
);
2124 h
->got
.offset
= (bfd_vma
) -1;
2126 eh
= (struct elf32_hppa_link_hash_entry
*) h
;
2127 if (eh
->dyn_relocs
== NULL
)
2130 /* If this is a -Bsymbolic shared link, then we need to discard all
2131 space allocated for dynamic pc-relative relocs against symbols
2132 defined in a regular object. For the normal shared case, discard
2133 space for relocs that have become local due to symbol visibility
2137 #if RELATIVE_DYNRELOCS
2138 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
2139 && ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0
2142 struct elf32_hppa_dyn_reloc_entry
**pp
;
2144 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2146 p
->count
-= p
->relative_count
;
2147 p
->relative_count
= 0;
2158 /* For the non-shared case, discard space for relocs against
2159 symbols which turn out to need copy relocs or are not
2161 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
2162 && (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2163 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2164 || (htab
->elf
.dynamic_sections_created
2165 && (h
->root
.type
== bfd_link_hash_undefweak
2166 || h
->root
.type
== bfd_link_hash_undefined
))))
2168 /* Make sure this symbol is output as a dynamic symbol.
2169 Undefined weak syms won't yet be marked as dynamic. */
2170 if (h
->dynindx
== -1
2171 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0
2172 && h
->type
!= STT_PARISC_MILLI
)
2174 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2178 /* If that succeeded, we know we'll be keeping all the
2180 if (h
->dynindx
!= -1)
2184 eh
->dyn_relocs
= NULL
;
2190 /* Finally, allocate space. */
2191 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2193 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
2194 sreloc
->_raw_size
+= p
->count
* sizeof (Elf32_External_Rela
);
2200 /* This function is called via elf_link_hash_traverse to force
2201 millicode symbols local so they do not end up as globals in the
2202 dynamic symbol table. We ought to be able to do this in
2203 adjust_dynamic_symbol, but our adjust_dynamic_symbol is not called
2204 for all dynamic symbols. Arguably, this is a bug in
2205 elf_adjust_dynamic_symbol. */
2208 clobber_millicode_symbols (h
, info
)
2209 struct elf_link_hash_entry
*h
;
2210 struct bfd_link_info
*info
;
2212 /* We only want to remove these from the dynamic symbol table.
2213 Therefore we do not leave ELF_LINK_FORCED_LOCAL set. */
2214 if (h
->type
== STT_PARISC_MILLI
)
2216 struct elf32_hppa_link_hash_table
*htab
;
2217 unsigned short oldflags
= h
->elf_link_hash_flags
;
2219 h
->elf_link_hash_flags
|= ELF_LINK_FORCED_LOCAL
;
2220 elf32_hppa_hide_symbol (info
, h
);
2221 htab
= hppa_link_hash_table (info
);
2222 _bfd_elf_strtab_delref (htab
->elf
.dynstr
, h
->dynstr_index
);
2223 h
->elf_link_hash_flags
&= ~ELF_LINK_FORCED_LOCAL
;
2224 h
->elf_link_hash_flags
|= oldflags
& ELF_LINK_FORCED_LOCAL
;
2229 /* Find any dynamic relocs that apply to read-only sections. */
2232 readonly_dynrelocs (h
, inf
)
2233 struct elf_link_hash_entry
*h
;
2236 struct elf32_hppa_link_hash_entry
*eh
;
2237 struct elf32_hppa_dyn_reloc_entry
*p
;
2239 eh
= (struct elf32_hppa_link_hash_entry
*) h
;
2240 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2242 asection
*s
= p
->sec
->output_section
;
2244 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2246 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2248 info
->flags
|= DF_TEXTREL
;
2250 /* Not an error, just cut short the traversal. */
2257 /* Set the sizes of the dynamic sections. */
2260 elf32_hppa_size_dynamic_sections (output_bfd
, info
)
2261 bfd
*output_bfd ATTRIBUTE_UNUSED
;
2262 struct bfd_link_info
*info
;
2264 struct elf32_hppa_link_hash_table
*htab
;
2270 htab
= hppa_link_hash_table (info
);
2271 dynobj
= htab
->elf
.dynobj
;
2275 if (htab
->elf
.dynamic_sections_created
)
2277 /* Set the contents of the .interp section to the interpreter. */
2280 s
= bfd_get_section_by_name (dynobj
, ".interp");
2283 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2284 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2287 /* Force millicode symbols local. */
2288 elf_link_hash_traverse (&htab
->elf
,
2289 clobber_millicode_symbols
,
2294 /* Run through the function symbols, looking for any that are
2295 PIC, and mark them as needing .plt entries so that %r19 will
2298 elf_link_hash_traverse (&htab
->elf
, mark_PIC_calls
, (PTR
) info
);
2301 /* Set up .got and .plt offsets for local syms, and space for local
2303 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2305 bfd_signed_vma
*local_got
;
2306 bfd_signed_vma
*end_local_got
;
2307 bfd_signed_vma
*local_plt
;
2308 bfd_signed_vma
*end_local_plt
;
2309 bfd_size_type locsymcount
;
2310 Elf_Internal_Shdr
*symtab_hdr
;
2313 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
2316 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2318 struct elf32_hppa_dyn_reloc_entry
*p
;
2320 for (p
= ((struct elf32_hppa_dyn_reloc_entry
*)
2321 elf_section_data (s
)->local_dynrel
);
2325 if (!bfd_is_abs_section (p
->sec
)
2326 && bfd_is_abs_section (p
->sec
->output_section
))
2328 /* Input section has been discarded, either because
2329 it is a copy of a linkonce section or due to
2330 linker script /DISCARD/, so we'll be discarding
2335 srel
= elf_section_data (p
->sec
)->sreloc
;
2336 srel
->_raw_size
+= p
->count
* sizeof (Elf32_External_Rela
);
2341 local_got
= elf_local_got_refcounts (ibfd
);
2345 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2346 locsymcount
= symtab_hdr
->sh_info
;
2347 end_local_got
= local_got
+ locsymcount
;
2349 srel
= htab
->srelgot
;
2350 for (; local_got
< end_local_got
; ++local_got
)
2354 *local_got
= s
->_raw_size
;
2355 s
->_raw_size
+= GOT_ENTRY_SIZE
;
2357 srel
->_raw_size
+= sizeof (Elf32_External_Rela
);
2360 *local_got
= (bfd_vma
) -1;
2363 local_plt
= end_local_got
;
2364 end_local_plt
= local_plt
+ locsymcount
;
2365 if (! htab
->elf
.dynamic_sections_created
)
2367 /* Won't be used, but be safe. */
2368 for (; local_plt
< end_local_plt
; ++local_plt
)
2369 *local_plt
= (bfd_vma
) -1;
2374 srel
= htab
->srelplt
;
2375 for (; local_plt
< end_local_plt
; ++local_plt
)
2379 *local_plt
= s
->_raw_size
;
2380 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2382 srel
->_raw_size
+= sizeof (Elf32_External_Rela
);
2385 *local_plt
= (bfd_vma
) -1;
2390 /* Do all the .plt entries without relocs first. The dynamic linker
2391 uses the last .plt reloc to find the end of the .plt (and hence
2392 the start of the .got) for lazy linking. */
2393 elf_link_hash_traverse (&htab
->elf
, allocate_plt_static
, (PTR
) info
);
2395 /* Allocate global sym .plt and .got entries, and space for global
2396 sym dynamic relocs. */
2397 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, (PTR
) info
);
2399 /* The check_relocs and adjust_dynamic_symbol entry points have
2400 determined the sizes of the various dynamic sections. Allocate
2403 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2405 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2408 if (s
== htab
->splt
)
2410 if (htab
->need_plt_stub
)
2412 /* Make space for the plt stub at the end of the .plt
2413 section. We want this stub right at the end, up
2414 against the .got section. */
2415 int gotalign
= bfd_section_alignment (dynobj
, htab
->sgot
);
2416 int pltalign
= bfd_section_alignment (dynobj
, s
);
2419 if (gotalign
> pltalign
)
2420 bfd_set_section_alignment (dynobj
, s
, gotalign
);
2421 mask
= ((bfd_size_type
) 1 << gotalign
) - 1;
2422 s
->_raw_size
= (s
->_raw_size
+ sizeof (plt_stub
) + mask
) & ~mask
;
2425 else if (s
== htab
->sgot
)
2427 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rela", 5) == 0)
2429 if (s
->_raw_size
!= 0)
2431 /* Remember whether there are any reloc sections other
2433 if (s
!= htab
->srelplt
)
2436 /* We use the reloc_count field as a counter if we need
2437 to copy relocs into the output file. */
2443 /* It's not one of our sections, so don't allocate space. */
2447 if (s
->_raw_size
== 0)
2449 /* If we don't need this section, strip it from the
2450 output file. This is mostly to handle .rela.bss and
2451 .rela.plt. We must create both sections in
2452 create_dynamic_sections, because they must be created
2453 before the linker maps input sections to output
2454 sections. The linker does that before
2455 adjust_dynamic_symbol is called, and it is that
2456 function which decides whether anything needs to go
2457 into these sections. */
2458 _bfd_strip_section_from_output (info
, s
);
2462 /* Allocate memory for the section contents. Zero it, because
2463 we may not fill in all the reloc sections. */
2464 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
2465 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
2469 if (htab
->elf
.dynamic_sections_created
)
2471 /* Like IA-64 and HPPA64, always create a DT_PLTGOT. It
2472 actually has nothing to do with the PLT, it is how we
2473 communicate the LTP value of a load module to the dynamic
2475 #define add_dynamic_entry(TAG, VAL) \
2476 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
2478 if (!add_dynamic_entry (DT_PLTGOT
, 0))
2481 /* Add some entries to the .dynamic section. We fill in the
2482 values later, in elf32_hppa_finish_dynamic_sections, but we
2483 must add the entries now so that we get the correct size for
2484 the .dynamic section. The DT_DEBUG entry is filled in by the
2485 dynamic linker and used by the debugger. */
2488 if (!add_dynamic_entry (DT_DEBUG
, 0))
2492 if (htab
->srelplt
->_raw_size
!= 0)
2494 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
2495 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
2496 || !add_dynamic_entry (DT_JMPREL
, 0))
2502 if (!add_dynamic_entry (DT_RELA
, 0)
2503 || !add_dynamic_entry (DT_RELASZ
, 0)
2504 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
2507 /* If any dynamic relocs apply to a read-only section,
2508 then we need a DT_TEXTREL entry. */
2509 elf_link_hash_traverse (&htab
->elf
, readonly_dynrelocs
, (PTR
) info
);
2511 if ((info
->flags
& DF_TEXTREL
) != 0)
2513 if (!add_dynamic_entry (DT_TEXTREL
, 0))
2518 #undef add_dynamic_entry
2523 /* External entry points for sizing and building linker stubs. */
2525 /* Determine and set the size of the stub section for a final link.
2527 The basic idea here is to examine all the relocations looking for
2528 PC-relative calls to a target that is unreachable with a "bl"
2532 elf32_hppa_size_stubs (output_bfd
, stub_bfd
, info
, multi_subspace
, group_size
,
2533 add_stub_section
, layout_sections_again
)
2536 struct bfd_link_info
*info
;
2537 boolean multi_subspace
;
2538 bfd_signed_vma group_size
;
2539 asection
* (*add_stub_section
) PARAMS ((const char *, asection
*));
2540 void (*layout_sections_again
) PARAMS ((void));
2544 asection
**input_list
, **list
;
2545 Elf_Internal_Sym
*local_syms
, **all_local_syms
;
2546 unsigned int bfd_indx
, bfd_count
;
2547 int top_id
, top_index
;
2548 struct elf32_hppa_link_hash_table
*htab
;
2549 bfd_size_type stub_group_size
;
2550 boolean stubs_always_before_branch
;
2551 boolean stub_changed
= 0;
2555 htab
= hppa_link_hash_table (info
);
2557 /* Stash our params away. */
2558 htab
->stub_bfd
= stub_bfd
;
2559 htab
->multi_subspace
= multi_subspace
;
2560 htab
->add_stub_section
= add_stub_section
;
2561 htab
->layout_sections_again
= layout_sections_again
;
2562 stubs_always_before_branch
= group_size
< 0;
2564 stub_group_size
= -group_size
;
2566 stub_group_size
= group_size
;
2567 if (stub_group_size
== 1)
2569 /* Default values. */
2570 stub_group_size
= 7680000;
2571 if (htab
->has_17bit_branch
|| htab
->multi_subspace
)
2572 stub_group_size
= 240000;
2573 if (htab
->has_12bit_branch
)
2574 stub_group_size
= 7500;
2577 /* Count the number of input BFDs and find the top input section id. */
2578 for (input_bfd
= info
->input_bfds
, bfd_count
= 0, top_id
= 0;
2580 input_bfd
= input_bfd
->link_next
)
2583 for (section
= input_bfd
->sections
;
2585 section
= section
->next
)
2587 if (top_id
< section
->id
)
2588 top_id
= section
->id
;
2592 amt
= sizeof (struct map_stub
) * (top_id
+ 1);
2593 htab
->stub_group
= (struct map_stub
*) bfd_zmalloc (amt
);
2594 if (htab
->stub_group
== NULL
)
2597 /* Make a list of input sections for each output section included in
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;
2605 section
= section
->next
)
2607 if (top_index
< section
->index
)
2608 top_index
= section
->index
;
2611 amt
= sizeof (asection
*) * (top_index
+ 1);
2612 input_list
= (asection
**) bfd_malloc (amt
);
2613 if (input_list
== NULL
)
2616 /* For sections we aren't interested in, mark their entries with a
2617 value we can check later. */
2618 list
= input_list
+ top_index
;
2620 *list
= bfd_abs_section_ptr
;
2621 while (list
-- != input_list
);
2623 for (section
= output_bfd
->sections
;
2625 section
= section
->next
)
2627 if ((section
->flags
& SEC_CODE
) != 0)
2628 input_list
[section
->index
] = NULL
;
2631 /* Now actually build the lists. */
2632 for (input_bfd
= info
->input_bfds
;
2634 input_bfd
= input_bfd
->link_next
)
2636 for (section
= input_bfd
->sections
;
2638 section
= section
->next
)
2640 if (section
->output_section
!= NULL
2641 && section
->output_section
->owner
== output_bfd
2642 && section
->output_section
->index
<= top_index
)
2644 list
= input_list
+ section
->output_section
->index
;
2645 if (*list
!= bfd_abs_section_ptr
)
2647 /* Steal the link_sec pointer for our list. */
2648 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
2649 /* This happens to make the list in reverse order,
2650 which is what we want. */
2651 PREV_SEC (section
) = *list
;
2658 /* See whether we can group stub sections together. Grouping stub
2659 sections may result in fewer stubs. More importantly, we need to
2660 put all .init* and .fini* stubs at the beginning of the .init or
2661 .fini output sections respectively, because glibc splits the
2662 _init and _fini functions into multiple parts. Putting a stub in
2663 the middle of a function is not a good idea. */
2664 list
= input_list
+ top_index
;
2667 asection
*tail
= *list
;
2668 if (tail
== bfd_abs_section_ptr
)
2670 while (tail
!= NULL
)
2674 bfd_size_type total
;
2677 if (tail
->_cooked_size
)
2678 total
= tail
->_cooked_size
;
2680 total
= tail
->_raw_size
;
2681 while ((prev
= PREV_SEC (curr
)) != NULL
2682 && ((total
+= curr
->output_offset
- prev
->output_offset
)
2686 /* OK, the size from the start of CURR to the end is less
2687 than 240000 bytes and thus can be handled by one stub
2688 section. (or the tail section is itself larger than
2689 240000 bytes, in which case we may be toast.)
2690 We should really be keeping track of the total size of
2691 stubs added here, as stubs contribute to the final output
2692 section size. That's a little tricky, and this way will
2693 only break if stubs added total more than 22144 bytes, or
2694 2768 long branch stubs. It seems unlikely for more than
2695 2768 different functions to be called, especially from
2696 code only 240000 bytes long. This limit used to be
2697 250000, but c++ code tends to generate lots of little
2698 functions, and sometimes violated the assumption. */
2701 prev
= PREV_SEC (tail
);
2702 /* Set up this stub group. */
2703 htab
->stub_group
[tail
->id
].link_sec
= curr
;
2705 while (tail
!= curr
&& (tail
= prev
) != NULL
);
2707 /* But wait, there's more! Input sections up to 240000
2708 bytes before the stub section can be handled by it too. */
2709 if (!stubs_always_before_branch
)
2713 && ((total
+= tail
->output_offset
- prev
->output_offset
)
2717 prev
= PREV_SEC (tail
);
2718 htab
->stub_group
[tail
->id
].link_sec
= curr
;
2724 while (list
-- != input_list
);
2728 /* We want to read in symbol extension records only once. To do this
2729 we need to read in the local symbols in parallel and save them for
2730 later use; so hold pointers to the local symbols in an array. */
2731 amt
= sizeof (Elf_Internal_Sym
*) * bfd_count
;
2732 all_local_syms
= (Elf_Internal_Sym
**) bfd_zmalloc (amt
);
2733 if (all_local_syms
== NULL
)
2736 /* Walk over all the input BFDs, swapping in local symbols.
2737 If we are creating a shared library, create hash entries for the
2739 for (input_bfd
= info
->input_bfds
, bfd_indx
= 0;
2741 input_bfd
= input_bfd
->link_next
, bfd_indx
++)
2743 Elf_Internal_Shdr
*symtab_hdr
;
2744 Elf_Internal_Sym
*isym
;
2745 Elf32_External_Sym
*ext_syms
, *esym
, *end_sy
;
2746 bfd_size_type sec_size
;
2748 /* We'll need the symbol table in a second. */
2749 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2750 if (symtab_hdr
->sh_info
== 0)
2753 /* We need an array of the local symbols attached to the input bfd.
2754 Unfortunately, we're going to have to read & swap them in. */
2755 sec_size
= symtab_hdr
->sh_info
;
2756 sec_size
*= sizeof (Elf_Internal_Sym
);
2757 local_syms
= (Elf_Internal_Sym
*) bfd_malloc (sec_size
);
2758 if (local_syms
== NULL
)
2760 goto error_ret_free_local
;
2762 all_local_syms
[bfd_indx
] = local_syms
;
2763 sec_size
= symtab_hdr
->sh_info
;
2764 sec_size
*= sizeof (Elf32_External_Sym
);
2765 ext_syms
= (Elf32_External_Sym
*) bfd_malloc (sec_size
);
2766 if (ext_syms
== NULL
)
2768 goto error_ret_free_local
;
2771 if (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
2772 || (bfd_bread (ext_syms
, sec_size
, input_bfd
) != sec_size
))
2775 goto error_ret_free_local
;
2778 /* Swap the local symbols in. */
2781 for (end_sy
= esym
+ symtab_hdr
->sh_info
; esym
< end_sy
; esym
++, isym
++)
2782 bfd_elf32_swap_symbol_in (input_bfd
, esym
, isym
);
2784 /* Now we can free the external symbols. */
2787 if (info
->shared
&& htab
->multi_subspace
)
2789 struct elf_link_hash_entry
**sym_hashes
;
2790 struct elf_link_hash_entry
**end_hashes
;
2791 unsigned int symcount
;
2793 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
2794 - symtab_hdr
->sh_info
);
2795 sym_hashes
= elf_sym_hashes (input_bfd
);
2796 end_hashes
= sym_hashes
+ symcount
;
2798 /* Look through the global syms for functions; We need to
2799 build export stubs for all globally visible functions. */
2800 for (; sym_hashes
< end_hashes
; sym_hashes
++)
2802 struct elf32_hppa_link_hash_entry
*hash
;
2804 hash
= (struct elf32_hppa_link_hash_entry
*) *sym_hashes
;
2806 while (hash
->elf
.root
.type
== bfd_link_hash_indirect
2807 || hash
->elf
.root
.type
== bfd_link_hash_warning
)
2808 hash
= ((struct elf32_hppa_link_hash_entry
*)
2809 hash
->elf
.root
.u
.i
.link
);
2811 /* At this point in the link, undefined syms have been
2812 resolved, so we need to check that the symbol was
2813 defined in this BFD. */
2814 if ((hash
->elf
.root
.type
== bfd_link_hash_defined
2815 || hash
->elf
.root
.type
== bfd_link_hash_defweak
)
2816 && hash
->elf
.type
== STT_FUNC
2817 && hash
->elf
.root
.u
.def
.section
->output_section
!= NULL
2818 && (hash
->elf
.root
.u
.def
.section
->output_section
->owner
2820 && hash
->elf
.root
.u
.def
.section
->owner
== input_bfd
2821 && (hash
->elf
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)
2822 && !(hash
->elf
.elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
)
2823 && ELF_ST_VISIBILITY (hash
->elf
.other
) == STV_DEFAULT
)
2826 const char *stub_name
;
2827 struct elf32_hppa_stub_hash_entry
*stub_entry
;
2829 sec
= hash
->elf
.root
.u
.def
.section
;
2830 stub_name
= hash
->elf
.root
.root
.string
;
2831 stub_entry
= hppa_stub_hash_lookup (&htab
->stub_hash_table
,
2834 if (stub_entry
== NULL
)
2836 stub_entry
= hppa_add_stub (stub_name
, sec
, htab
);
2838 goto error_ret_free_local
;
2840 stub_entry
->target_value
= hash
->elf
.root
.u
.def
.value
;
2841 stub_entry
->target_section
= hash
->elf
.root
.u
.def
.section
;
2842 stub_entry
->stub_type
= hppa_stub_export
;
2843 stub_entry
->h
= hash
;
2848 (*_bfd_error_handler
) (_("%s: duplicate export stub %s"),
2849 bfd_archive_filename (input_bfd
),
2861 for (input_bfd
= info
->input_bfds
, bfd_indx
= 0;
2863 input_bfd
= input_bfd
->link_next
, bfd_indx
++)
2865 Elf_Internal_Shdr
*symtab_hdr
;
2867 /* We'll need the symbol table in a second. */
2868 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2869 if (symtab_hdr
->sh_info
== 0)
2872 local_syms
= all_local_syms
[bfd_indx
];
2874 /* Walk over each section attached to the input bfd. */
2875 for (section
= input_bfd
->sections
;
2877 section
= section
->next
)
2879 Elf_Internal_Shdr
*input_rel_hdr
;
2880 Elf32_External_Rela
*external_relocs
, *erelaend
, *erela
;
2881 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
2883 /* If there aren't any relocs, then there's nothing more
2885 if ((section
->flags
& SEC_RELOC
) == 0
2886 || section
->reloc_count
== 0)
2889 /* If this section is a link-once section that will be
2890 discarded, then don't create any stubs. */
2891 if (section
->output_section
== NULL
2892 || section
->output_section
->owner
!= output_bfd
)
2895 /* Allocate space for the external relocations. */
2896 amt
= section
->reloc_count
;
2897 amt
*= sizeof (Elf32_External_Rela
);
2898 external_relocs
= (Elf32_External_Rela
*) bfd_malloc (amt
);
2899 if (external_relocs
== NULL
)
2901 goto error_ret_free_local
;
2904 /* Likewise for the internal relocations. */
2905 amt
= section
->reloc_count
;
2906 amt
*= sizeof (Elf_Internal_Rela
);
2907 internal_relocs
= (Elf_Internal_Rela
*) bfd_malloc (amt
);
2908 if (internal_relocs
== NULL
)
2910 free (external_relocs
);
2911 goto error_ret_free_local
;
2914 /* Read in the external relocs. */
2915 input_rel_hdr
= &elf_section_data (section
)->rel_hdr
;
2916 if (bfd_seek (input_bfd
, input_rel_hdr
->sh_offset
, SEEK_SET
) != 0
2917 || bfd_bread (external_relocs
,
2918 input_rel_hdr
->sh_size
,
2919 input_bfd
) != input_rel_hdr
->sh_size
)
2921 free (external_relocs
);
2922 error_ret_free_internal
:
2923 free (internal_relocs
);
2924 goto error_ret_free_local
;
2927 /* Swap in the relocs. */
2928 erela
= external_relocs
;
2929 erelaend
= erela
+ section
->reloc_count
;
2930 irela
= internal_relocs
;
2931 for (; erela
< erelaend
; erela
++, irela
++)
2932 bfd_elf32_swap_reloca_in (input_bfd
, erela
, irela
);
2934 /* We're done with the external relocs, free them. */
2935 free (external_relocs
);
2937 /* Now examine each relocation. */
2938 irela
= internal_relocs
;
2939 irelaend
= irela
+ section
->reloc_count
;
2940 for (; irela
< irelaend
; irela
++)
2942 unsigned int r_type
, r_indx
;
2943 enum elf32_hppa_stub_type stub_type
;
2944 struct elf32_hppa_stub_hash_entry
*stub_entry
;
2947 bfd_vma destination
;
2948 struct elf32_hppa_link_hash_entry
*hash
;
2950 const asection
*id_sec
;
2952 r_type
= ELF32_R_TYPE (irela
->r_info
);
2953 r_indx
= ELF32_R_SYM (irela
->r_info
);
2955 if (r_type
>= (unsigned int) R_PARISC_UNIMPLEMENTED
)
2957 bfd_set_error (bfd_error_bad_value
);
2958 goto error_ret_free_internal
;
2961 /* Only look for stubs on call instructions. */
2962 if (r_type
!= (unsigned int) R_PARISC_PCREL12F
2963 && r_type
!= (unsigned int) R_PARISC_PCREL17F
2964 && r_type
!= (unsigned int) R_PARISC_PCREL22F
)
2967 /* Now determine the call target, its name, value,
2973 if (r_indx
< symtab_hdr
->sh_info
)
2975 /* It's a local symbol. */
2976 Elf_Internal_Sym
*sym
;
2977 Elf_Internal_Shdr
*hdr
;
2979 sym
= local_syms
+ r_indx
;
2980 hdr
= elf_elfsections (input_bfd
)[sym
->st_shndx
];
2981 sym_sec
= hdr
->bfd_section
;
2982 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
2983 sym_value
= sym
->st_value
;
2984 destination
= (sym_value
+ irela
->r_addend
2985 + sym_sec
->output_offset
2986 + sym_sec
->output_section
->vma
);
2990 /* It's an external symbol. */
2993 e_indx
= r_indx
- symtab_hdr
->sh_info
;
2994 hash
= ((struct elf32_hppa_link_hash_entry
*)
2995 elf_sym_hashes (input_bfd
)[e_indx
]);
2997 while (hash
->elf
.root
.type
== bfd_link_hash_indirect
2998 || hash
->elf
.root
.type
== bfd_link_hash_warning
)
2999 hash
= ((struct elf32_hppa_link_hash_entry
*)
3000 hash
->elf
.root
.u
.i
.link
);
3002 if (hash
->elf
.root
.type
== bfd_link_hash_defined
3003 || hash
->elf
.root
.type
== bfd_link_hash_defweak
)
3005 sym_sec
= hash
->elf
.root
.u
.def
.section
;
3006 sym_value
= hash
->elf
.root
.u
.def
.value
;
3007 if (sym_sec
->output_section
!= NULL
)
3008 destination
= (sym_value
+ irela
->r_addend
3009 + sym_sec
->output_offset
3010 + sym_sec
->output_section
->vma
);
3012 else if (hash
->elf
.root
.type
== bfd_link_hash_undefweak
)
3017 else if (hash
->elf
.root
.type
== bfd_link_hash_undefined
)
3020 && !info
->no_undefined
3021 && (ELF_ST_VISIBILITY (hash
->elf
.other
)
3023 && hash
->elf
.type
!= STT_PARISC_MILLI
))
3028 bfd_set_error (bfd_error_bad_value
);
3029 goto error_ret_free_internal
;
3033 /* Determine what (if any) linker stub is needed. */
3034 stub_type
= hppa_type_of_stub (section
, irela
, hash
,
3036 if (stub_type
== hppa_stub_none
)
3039 /* Support for grouping stub sections. */
3040 id_sec
= htab
->stub_group
[section
->id
].link_sec
;
3042 /* Get the name of this stub. */
3043 stub_name
= hppa_stub_name (id_sec
, sym_sec
, hash
, irela
);
3045 goto error_ret_free_internal
;
3047 stub_entry
= hppa_stub_hash_lookup (&htab
->stub_hash_table
,
3050 if (stub_entry
!= NULL
)
3052 /* The proper stub has already been created. */
3057 stub_entry
= hppa_add_stub (stub_name
, section
, htab
);
3058 if (stub_entry
== NULL
)
3061 goto error_ret_free_local
;
3064 stub_entry
->target_value
= sym_value
;
3065 stub_entry
->target_section
= sym_sec
;
3066 stub_entry
->stub_type
= stub_type
;
3069 if (stub_type
== hppa_stub_import
)
3070 stub_entry
->stub_type
= hppa_stub_import_shared
;
3071 else if (stub_type
== hppa_stub_long_branch
)
3072 stub_entry
->stub_type
= hppa_stub_long_branch_shared
;
3074 stub_entry
->h
= hash
;
3078 /* We're done with the internal relocs, free them. */
3079 free (internal_relocs
);
3086 /* OK, we've added some stubs. Find out the new size of the
3088 for (stub_sec
= htab
->stub_bfd
->sections
;
3090 stub_sec
= stub_sec
->next
)
3092 stub_sec
->_raw_size
= 0;
3093 stub_sec
->_cooked_size
= 0;
3096 bfd_hash_traverse (&htab
->stub_hash_table
, hppa_size_one_stub
, htab
);
3098 /* Ask the linker to do its stuff. */
3099 (*htab
->layout_sections_again
) ();
3105 error_ret_free_local
:
3106 while (bfd_count
-- > 0)
3107 if (all_local_syms
[bfd_count
])
3108 free (all_local_syms
[bfd_count
]);
3109 free (all_local_syms
);
3114 /* For a final link, this function is called after we have sized the
3115 stubs to provide a value for __gp. */
3118 elf32_hppa_set_gp (abfd
, info
)
3120 struct bfd_link_info
*info
;
3122 struct elf32_hppa_link_hash_table
*htab
;
3123 struct elf_link_hash_entry
*h
;
3127 htab
= hppa_link_hash_table (info
);
3128 h
= elf_link_hash_lookup (&htab
->elf
, "$global$", false, false, false);
3131 && (h
->root
.type
== bfd_link_hash_defined
3132 || h
->root
.type
== bfd_link_hash_defweak
))
3134 gp_val
= h
->root
.u
.def
.value
;
3135 sec
= h
->root
.u
.def
.section
;
3139 /* Choose to point our LTP at, in this order, one of .plt, .got,
3140 or .data, if these sections exist. In the case of choosing
3141 .plt try to make the LTP ideal for addressing anywhere in the
3142 .plt or .got with a 14 bit signed offset. Typically, the end
3143 of the .plt is the start of the .got, so choose .plt + 0x2000
3144 if either the .plt or .got is larger than 0x2000. If both
3145 the .plt and .got are smaller than 0x2000, choose the end of
3146 the .plt section. */
3151 gp_val
= sec
->_raw_size
;
3153 || (htab
->sgot
&& htab
->sgot
->_raw_size
> 0x2000))
3164 /* We know we don't have a .plt. If .got is large,
3166 if (sec
->_raw_size
> 0x2000)
3171 /* No .plt or .got. Who cares what the LTP is? */
3172 sec
= bfd_get_section_by_name (abfd
, ".data");
3178 h
->root
.type
= bfd_link_hash_defined
;
3179 h
->root
.u
.def
.value
= gp_val
;
3181 h
->root
.u
.def
.section
= sec
;
3183 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
3187 if (sec
!= NULL
&& sec
->output_section
!= NULL
)
3188 gp_val
+= sec
->output_section
->vma
+ sec
->output_offset
;
3190 elf_gp (abfd
) = gp_val
;
3194 /* Build all the stubs associated with the current output file. The
3195 stubs are kept in a hash table attached to the main linker hash
3196 table. We also set up the .plt entries for statically linked PIC
3197 functions here. This function is called via hppaelf_finish in the
3201 elf32_hppa_build_stubs (info
)
3202 struct bfd_link_info
*info
;
3205 struct bfd_hash_table
*table
;
3206 struct elf32_hppa_link_hash_table
*htab
;
3208 htab
= hppa_link_hash_table (info
);
3210 for (stub_sec
= htab
->stub_bfd
->sections
;
3212 stub_sec
= stub_sec
->next
)
3216 /* Allocate memory to hold the linker stubs. */
3217 size
= stub_sec
->_raw_size
;
3218 stub_sec
->contents
= (unsigned char *) bfd_zalloc (htab
->stub_bfd
, size
);
3219 if (stub_sec
->contents
== NULL
&& size
!= 0)
3221 stub_sec
->_raw_size
= 0;
3224 /* Build the stubs as directed by the stub hash table. */
3225 table
= &htab
->stub_hash_table
;
3226 bfd_hash_traverse (table
, hppa_build_one_stub
, info
);
3231 /* Perform a final link. */
3234 elf32_hppa_final_link (abfd
, info
)
3236 struct bfd_link_info
*info
;
3240 /* Invoke the regular ELF linker to do all the work. */
3241 if (!bfd_elf32_bfd_final_link (abfd
, info
))
3244 /* If we're producing a final executable, sort the contents of the
3245 unwind section. Magic section names, but this is much safer than
3246 having elf32_hppa_relocate_section remember where SEGREL32 relocs
3247 occurred. Consider what happens if someone inept creates a
3248 linker script that puts unwind information in .text. */
3249 s
= bfd_get_section_by_name (abfd
, ".PARISC.unwind");
3255 size
= s
->_raw_size
;
3256 contents
= bfd_malloc (size
);
3257 if (contents
== NULL
)
3260 if (! bfd_get_section_contents (abfd
, s
, contents
, (file_ptr
) 0, size
))
3263 qsort (contents
, (size_t) (size
/ 16), 16, hppa_unwind_entry_compare
);
3265 if (! bfd_set_section_contents (abfd
, s
, contents
, (file_ptr
) 0, size
))
3271 /* Record the lowest address for the data and text segments. */
3274 hppa_record_segment_addr (abfd
, section
, data
)
3275 bfd
*abfd ATTRIBUTE_UNUSED
;
3279 struct elf32_hppa_link_hash_table
*htab
;
3281 htab
= (struct elf32_hppa_link_hash_table
*) data
;
3283 if ((section
->flags
& (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
3285 bfd_vma value
= section
->vma
- section
->filepos
;
3287 if ((section
->flags
& SEC_READONLY
) != 0)
3289 if (value
< htab
->text_segment_base
)
3290 htab
->text_segment_base
= value
;
3294 if (value
< htab
->data_segment_base
)
3295 htab
->data_segment_base
= value
;
3300 /* Perform a relocation as part of a final link. */
3302 static bfd_reloc_status_type
3303 final_link_relocate (input_section
, contents
, rel
, value
, htab
, sym_sec
, h
)
3304 asection
*input_section
;
3306 const Elf_Internal_Rela
*rel
;
3308 struct elf32_hppa_link_hash_table
*htab
;
3310 struct elf32_hppa_link_hash_entry
*h
;
3313 unsigned int r_type
= ELF32_R_TYPE (rel
->r_info
);
3314 reloc_howto_type
*howto
= elf_hppa_howto_table
+ r_type
;
3315 int r_format
= howto
->bitsize
;
3316 enum hppa_reloc_field_selector_type_alt r_field
;
3317 bfd
*input_bfd
= input_section
->owner
;
3318 bfd_vma offset
= rel
->r_offset
;
3319 bfd_vma max_branch_offset
= 0;
3320 bfd_byte
*hit_data
= contents
+ offset
;
3321 bfd_signed_vma addend
= rel
->r_addend
;
3323 struct elf32_hppa_stub_hash_entry
*stub_entry
= NULL
;
3326 if (r_type
== R_PARISC_NONE
)
3327 return bfd_reloc_ok
;
3329 insn
= bfd_get_32 (input_bfd
, hit_data
);
3331 /* Find out where we are and where we're going. */
3332 location
= (offset
+
3333 input_section
->output_offset
+
3334 input_section
->output_section
->vma
);
3338 case R_PARISC_PCREL12F
:
3339 case R_PARISC_PCREL17F
:
3340 case R_PARISC_PCREL22F
:
3341 /* If this is a call to a function defined in another dynamic
3342 library, or if it is a call to a PIC function in the same
3343 object, or if this is a shared link and it is a call to a
3344 weak symbol which may or may not be in the same object, then
3345 find the import stub in the stub hash. */
3347 || sym_sec
->output_section
== NULL
3349 && ((h
->maybe_pic_call
3350 && !(input_section
->flags
& SEC_HAS_GOT_REF
))
3351 || (h
->elf
.root
.type
== bfd_link_hash_defweak
3352 && h
->elf
.dynindx
!= -1
3353 && h
->elf
.plt
.offset
!= (bfd_vma
) -1))))
3355 stub_entry
= hppa_get_stub_entry (input_section
, sym_sec
,
3357 if (stub_entry
!= NULL
)
3359 value
= (stub_entry
->stub_offset
3360 + stub_entry
->stub_sec
->output_offset
3361 + stub_entry
->stub_sec
->output_section
->vma
);
3364 else if (sym_sec
== NULL
&& h
!= NULL
3365 && h
->elf
.root
.type
== bfd_link_hash_undefweak
)
3367 /* It's OK if undefined weak. Calls to undefined weak
3368 symbols behave as if the "called" function
3369 immediately returns. We can thus call to a weak
3370 function without first checking whether the function
3376 return bfd_reloc_undefined
;
3380 case R_PARISC_PCREL21L
:
3381 case R_PARISC_PCREL17C
:
3382 case R_PARISC_PCREL17R
:
3383 case R_PARISC_PCREL14R
:
3384 case R_PARISC_PCREL14F
:
3385 /* Make it a pc relative offset. */
3390 case R_PARISC_DPREL21L
:
3391 case R_PARISC_DPREL14R
:
3392 case R_PARISC_DPREL14F
:
3393 /* For all the DP relative relocations, we need to examine the symbol's
3394 section. If it's a code section, then "data pointer relative" makes
3395 no sense. In that case we don't adjust the "value", and for 21 bit
3396 addil instructions, we change the source addend register from %dp to
3397 %r0. This situation commonly arises when a variable's "constness"
3398 is declared differently from the way the variable is defined. For
3399 instance: "extern int foo" with foo defined as "const int foo". */
3400 if (sym_sec
== NULL
)
3402 if ((sym_sec
->flags
& SEC_CODE
) != 0)
3404 if ((insn
& ((0x3f << 26) | (0x1f << 21)))
3405 == (((int) OP_ADDIL
<< 26) | (27 << 21)))
3407 insn
&= ~ (0x1f << 21);
3408 #if 1 /* debug them. */
3409 (*_bfd_error_handler
)
3410 (_("%s(%s+0x%lx): fixing %s"),
3411 bfd_archive_filename (input_bfd
),
3412 input_section
->name
,
3413 (long) rel
->r_offset
,
3417 /* Now try to make things easy for the dynamic linker. */
3423 case R_PARISC_DLTIND21L
:
3424 case R_PARISC_DLTIND14R
:
3425 case R_PARISC_DLTIND14F
:
3426 value
-= elf_gp (input_section
->output_section
->owner
);
3429 case R_PARISC_SEGREL32
:
3430 if ((sym_sec
->flags
& SEC_CODE
) != 0)
3431 value
-= htab
->text_segment_base
;
3433 value
-= htab
->data_segment_base
;
3442 case R_PARISC_DIR32
:
3443 case R_PARISC_DIR14F
:
3444 case R_PARISC_DIR17F
:
3445 case R_PARISC_PCREL17C
:
3446 case R_PARISC_PCREL14F
:
3447 case R_PARISC_DPREL14F
:
3448 case R_PARISC_PLABEL32
:
3449 case R_PARISC_DLTIND14F
:
3450 case R_PARISC_SEGBASE
:
3451 case R_PARISC_SEGREL32
:
3455 case R_PARISC_DIR21L
:
3456 case R_PARISC_PCREL21L
:
3457 case R_PARISC_DPREL21L
:
3458 case R_PARISC_PLABEL21L
:
3459 case R_PARISC_DLTIND21L
:
3463 case R_PARISC_DIR17R
:
3464 case R_PARISC_PCREL17R
:
3465 case R_PARISC_DIR14R
:
3466 case R_PARISC_PCREL14R
:
3467 case R_PARISC_DPREL14R
:
3468 case R_PARISC_PLABEL14R
:
3469 case R_PARISC_DLTIND14R
:
3473 case R_PARISC_PCREL12F
:
3474 case R_PARISC_PCREL17F
:
3475 case R_PARISC_PCREL22F
:
3478 if (r_type
== (unsigned int) R_PARISC_PCREL17F
)
3480 max_branch_offset
= (1 << (17-1)) << 2;
3482 else if (r_type
== (unsigned int) R_PARISC_PCREL12F
)
3484 max_branch_offset
= (1 << (12-1)) << 2;
3488 max_branch_offset
= (1 << (22-1)) << 2;
3491 /* sym_sec is NULL on undefined weak syms or when shared on
3492 undefined syms. We've already checked for a stub for the
3493 shared undefined case. */
3494 if (sym_sec
== NULL
)
3497 /* If the branch is out of reach, then redirect the
3498 call to the local stub for this function. */
3499 if (value
+ addend
+ max_branch_offset
>= 2*max_branch_offset
)
3501 stub_entry
= hppa_get_stub_entry (input_section
, sym_sec
,
3503 if (stub_entry
== NULL
)
3504 return bfd_reloc_undefined
;
3506 /* Munge up the value and addend so that we call the stub
3507 rather than the procedure directly. */
3508 value
= (stub_entry
->stub_offset
3509 + stub_entry
->stub_sec
->output_offset
3510 + stub_entry
->stub_sec
->output_section
->vma
3516 /* Something we don't know how to handle. */
3518 return bfd_reloc_notsupported
;
3521 /* Make sure we can reach the stub. */
3522 if (max_branch_offset
!= 0
3523 && value
+ addend
+ max_branch_offset
>= 2*max_branch_offset
)
3525 (*_bfd_error_handler
)
3526 (_("%s(%s+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
3527 bfd_archive_filename (input_bfd
),
3528 input_section
->name
,
3529 (long) rel
->r_offset
,
3530 stub_entry
->root
.string
);
3531 bfd_set_error (bfd_error_bad_value
);
3532 return bfd_reloc_notsupported
;
3535 val
= hppa_field_adjust (value
, addend
, r_field
);
3539 case R_PARISC_PCREL12F
:
3540 case R_PARISC_PCREL17C
:
3541 case R_PARISC_PCREL17F
:
3542 case R_PARISC_PCREL17R
:
3543 case R_PARISC_PCREL22F
:
3544 case R_PARISC_DIR17F
:
3545 case R_PARISC_DIR17R
:
3546 /* This is a branch. Divide the offset by four.
3547 Note that we need to decide whether it's a branch or
3548 otherwise by inspecting the reloc. Inspecting insn won't
3549 work as insn might be from a .word directive. */
3557 insn
= hppa_rebuild_insn (insn
, val
, r_format
);
3559 /* Update the instruction word. */
3560 bfd_put_32 (input_bfd
, (bfd_vma
) insn
, hit_data
);
3561 return bfd_reloc_ok
;
3564 /* Relocate an HPPA ELF section. */
3567 elf32_hppa_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
3568 contents
, relocs
, local_syms
, local_sections
)
3570 struct bfd_link_info
*info
;
3572 asection
*input_section
;
3574 Elf_Internal_Rela
*relocs
;
3575 Elf_Internal_Sym
*local_syms
;
3576 asection
**local_sections
;
3578 bfd_vma
*local_got_offsets
;
3579 struct elf32_hppa_link_hash_table
*htab
;
3580 Elf_Internal_Shdr
*symtab_hdr
;
3581 Elf_Internal_Rela
*rel
;
3582 Elf_Internal_Rela
*relend
;
3584 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3586 htab
= hppa_link_hash_table (info
);
3587 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3590 relend
= relocs
+ input_section
->reloc_count
;
3591 for (; rel
< relend
; rel
++)
3593 unsigned int r_type
;
3594 reloc_howto_type
*howto
;
3595 unsigned int r_symndx
;
3596 struct elf32_hppa_link_hash_entry
*h
;
3597 Elf_Internal_Sym
*sym
;
3600 bfd_reloc_status_type r
;
3601 const char *sym_name
;
3603 boolean warned_undef
;
3605 r_type
= ELF32_R_TYPE (rel
->r_info
);
3606 if (r_type
>= (unsigned int) R_PARISC_UNIMPLEMENTED
)
3608 bfd_set_error (bfd_error_bad_value
);
3611 if (r_type
== (unsigned int) R_PARISC_GNU_VTENTRY
3612 || r_type
== (unsigned int) R_PARISC_GNU_VTINHERIT
)
3615 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3617 if (info
->relocateable
)
3619 /* This is a relocatable link. We don't have to change
3620 anything, unless the reloc is against a section symbol,
3621 in which case we have to adjust according to where the
3622 section symbol winds up in the output section. */
3623 if (r_symndx
< symtab_hdr
->sh_info
)
3625 sym
= local_syms
+ r_symndx
;
3626 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3628 sym_sec
= local_sections
[r_symndx
];
3629 rel
->r_addend
+= sym_sec
->output_offset
;
3635 /* This is a final link. */
3639 warned_undef
= false;
3640 if (r_symndx
< symtab_hdr
->sh_info
)
3642 /* This is a local symbol, h defaults to NULL. */
3643 sym
= local_syms
+ r_symndx
;
3644 sym_sec
= local_sections
[r_symndx
];
3645 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, sym_sec
, rel
);
3651 /* It's a global; Find its entry in the link hash. */
3652 indx
= r_symndx
- symtab_hdr
->sh_info
;
3653 h
= ((struct elf32_hppa_link_hash_entry
*)
3654 elf_sym_hashes (input_bfd
)[indx
]);
3655 while (h
->elf
.root
.type
== bfd_link_hash_indirect
3656 || h
->elf
.root
.type
== bfd_link_hash_warning
)
3657 h
= (struct elf32_hppa_link_hash_entry
*) h
->elf
.root
.u
.i
.link
;
3660 if (h
->elf
.root
.type
== bfd_link_hash_defined
3661 || h
->elf
.root
.type
== bfd_link_hash_defweak
)
3663 sym_sec
= h
->elf
.root
.u
.def
.section
;
3664 /* If sym_sec->output_section is NULL, then it's a
3665 symbol defined in a shared library. */
3666 if (sym_sec
->output_section
!= NULL
)
3667 relocation
= (h
->elf
.root
.u
.def
.value
3668 + sym_sec
->output_offset
3669 + sym_sec
->output_section
->vma
);
3671 else if (h
->elf
.root
.type
== bfd_link_hash_undefweak
)
3673 else if (info
->shared
&& !info
->no_undefined
3674 && ELF_ST_VISIBILITY (h
->elf
.other
) == STV_DEFAULT
3675 && h
->elf
.type
!= STT_PARISC_MILLI
)
3677 if (info
->symbolic
&& !info
->allow_shlib_undefined
)
3679 if (!((*info
->callbacks
->undefined_symbol
)
3680 (info
, h
->elf
.root
.root
.string
, input_bfd
,
3681 input_section
, rel
->r_offset
, false)))
3683 warned_undef
= true;
3688 if (!((*info
->callbacks
->undefined_symbol
)
3689 (info
, h
->elf
.root
.root
.string
, input_bfd
,
3690 input_section
, rel
->r_offset
, true)))
3692 warned_undef
= true;
3696 /* Do any required modifications to the relocation value, and
3697 determine what types of dynamic info we need to output, if
3702 case R_PARISC_DLTIND14F
:
3703 case R_PARISC_DLTIND14R
:
3704 case R_PARISC_DLTIND21L
:
3709 /* Relocation is to the entry for this symbol in the
3710 global offset table. */
3715 off
= h
->elf
.got
.offset
;
3716 dyn
= htab
->elf
.dynamic_sections_created
;
3717 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, &h
->elf
))
3719 /* If we aren't going to call finish_dynamic_symbol,
3720 then we need to handle initialisation of the .got
3721 entry and create needed relocs here. Since the
3722 offset must always be a multiple of 4, we use the
3723 least significant bit to record whether we have
3724 initialised it already. */
3729 h
->elf
.got
.offset
|= 1;
3736 /* Local symbol case. */
3737 if (local_got_offsets
== NULL
)
3740 off
= local_got_offsets
[r_symndx
];
3742 /* The offset must always be a multiple of 4. We use
3743 the least significant bit to record whether we have
3744 already generated the necessary reloc. */
3749 local_got_offsets
[r_symndx
] |= 1;
3758 /* Output a dynamic relocation for this GOT entry.
3759 In this case it is relative to the base of the
3760 object because the symbol index is zero. */
3761 Elf_Internal_Rela outrel
;
3762 asection
*srelgot
= htab
->srelgot
;
3763 Elf32_External_Rela
*loc
;
3765 outrel
.r_offset
= (off
3766 + htab
->sgot
->output_offset
3767 + htab
->sgot
->output_section
->vma
);
3768 outrel
.r_info
= ELF32_R_INFO (0, R_PARISC_DIR32
);
3769 outrel
.r_addend
= relocation
;
3770 loc
= (Elf32_External_Rela
*) srelgot
->contents
;
3771 loc
+= srelgot
->reloc_count
++;
3772 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
3775 bfd_put_32 (output_bfd
, relocation
,
3776 htab
->sgot
->contents
+ off
);
3779 if (off
>= (bfd_vma
) -2)
3782 /* Add the base of the GOT to the relocation value. */
3784 + htab
->sgot
->output_offset
3785 + htab
->sgot
->output_section
->vma
);
3789 case R_PARISC_SEGREL32
:
3790 /* If this is the first SEGREL relocation, then initialize
3791 the segment base values. */
3792 if (htab
->text_segment_base
== (bfd_vma
) -1)
3793 bfd_map_over_sections (output_bfd
, hppa_record_segment_addr
, htab
);
3796 case R_PARISC_PLABEL14R
:
3797 case R_PARISC_PLABEL21L
:
3798 case R_PARISC_PLABEL32
:
3799 if (htab
->elf
.dynamic_sections_created
)
3804 /* If we have a global symbol with a PLT slot, then
3805 redirect this relocation to it. */
3808 off
= h
->elf
.plt
.offset
;
3809 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
, &h
->elf
))
3811 /* In a non-shared link, adjust_dynamic_symbols
3812 isn't called for symbols forced local. We
3813 need to write out the plt entry here. */
3818 h
->elf
.plt
.offset
|= 1;
3825 bfd_vma
*local_plt_offsets
;
3827 if (local_got_offsets
== NULL
)
3830 local_plt_offsets
= local_got_offsets
+ symtab_hdr
->sh_info
;
3831 off
= local_plt_offsets
[r_symndx
];
3833 /* As for the local .got entry case, we use the last
3834 bit to record whether we've already initialised
3835 this local .plt entry. */
3840 local_plt_offsets
[r_symndx
] |= 1;
3849 /* Output a dynamic IPLT relocation for this
3851 Elf_Internal_Rela outrel
;
3852 asection
*srelplt
= htab
->srelplt
;
3853 Elf32_External_Rela
*loc
;
3855 outrel
.r_offset
= (off
3856 + htab
->splt
->output_offset
3857 + htab
->splt
->output_section
->vma
);
3858 outrel
.r_info
= ELF32_R_INFO (0, R_PARISC_IPLT
);
3859 outrel
.r_addend
= relocation
;
3860 loc
= (Elf32_External_Rela
*) srelplt
->contents
;
3861 loc
+= srelplt
->reloc_count
++;
3862 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
3866 bfd_put_32 (output_bfd
,
3868 htab
->splt
->contents
+ off
);
3869 bfd_put_32 (output_bfd
,
3870 elf_gp (htab
->splt
->output_section
->owner
),
3871 htab
->splt
->contents
+ off
+ 4);
3875 if (off
>= (bfd_vma
) -2)
3878 /* PLABELs contain function pointers. Relocation is to
3879 the entry for the function in the .plt. The magic +2
3880 offset signals to $$dyncall that the function pointer
3881 is in the .plt and thus has a gp pointer too.
3882 Exception: Undefined PLABELs should have a value of
3885 || (h
->elf
.root
.type
!= bfd_link_hash_undefweak
3886 && h
->elf
.root
.type
!= bfd_link_hash_undefined
))
3889 + htab
->splt
->output_offset
3890 + htab
->splt
->output_section
->vma
3895 /* Fall through and possibly emit a dynamic relocation. */
3897 case R_PARISC_DIR17F
:
3898 case R_PARISC_DIR17R
:
3899 case R_PARISC_DIR14F
:
3900 case R_PARISC_DIR14R
:
3901 case R_PARISC_DIR21L
:
3902 case R_PARISC_DPREL14F
:
3903 case R_PARISC_DPREL14R
:
3904 case R_PARISC_DPREL21L
:
3905 case R_PARISC_DIR32
:
3906 /* r_symndx will be zero only for relocs against symbols
3907 from removed linkonce sections, or sections discarded by
3910 || (input_section
->flags
& SEC_ALLOC
) == 0)
3913 /* The reloc types handled here and this conditional
3914 expression must match the code in ..check_relocs and
3915 allocate_dynrelocs. ie. We need exactly the same condition
3916 as in ..check_relocs, with some extra conditions (dynindx
3917 test in this case) to cater for relocs removed by
3918 allocate_dynrelocs. If you squint, the non-shared test
3919 here does indeed match the one in ..check_relocs, the
3920 difference being that here we test DEF_DYNAMIC as well as
3921 !DEF_REGULAR. All common syms end up with !DEF_REGULAR,
3922 which is why we can't use just that test here.
3923 Conversely, DEF_DYNAMIC can't be used in check_relocs as
3924 there all files have not been loaded. */
3926 && (IS_ABSOLUTE_RELOC (r_type
)
3928 && h
->elf
.dynindx
!= -1
3930 || (h
->elf
.elf_link_hash_flags
3931 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
3934 && h
->elf
.dynindx
!= -1
3935 && (h
->elf
.elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
3936 && (((h
->elf
.elf_link_hash_flags
3937 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
3938 && (h
->elf
.elf_link_hash_flags
3939 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
3940 || h
->elf
.root
.type
== bfd_link_hash_undefweak
3941 || h
->elf
.root
.type
== bfd_link_hash_undefined
)))
3943 Elf_Internal_Rela outrel
;
3946 Elf32_External_Rela
*loc
;
3948 /* When generating a shared object, these relocations
3949 are copied into the output file to be resolved at run
3952 outrel
.r_offset
= rel
->r_offset
;
3953 outrel
.r_addend
= rel
->r_addend
;
3955 if (elf_section_data (input_section
)->stab_info
!= NULL
)
3959 off
= (_bfd_stab_section_offset
3960 (output_bfd
, &htab
->elf
.stab_info
,
3962 &elf_section_data (input_section
)->stab_info
,
3964 if (off
== (bfd_vma
) -1)
3966 outrel
.r_offset
= off
;
3969 outrel
.r_offset
+= (input_section
->output_offset
3970 + input_section
->output_section
->vma
);
3974 memset (&outrel
, 0, sizeof (outrel
));
3977 && h
->elf
.dynindx
!= -1
3979 || !IS_ABSOLUTE_RELOC (r_type
)
3982 || (h
->elf
.elf_link_hash_flags
3983 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
3985 outrel
.r_info
= ELF32_R_INFO (h
->elf
.dynindx
, r_type
);
3987 else /* It's a local symbol, or one marked to become local. */
3991 /* Add the absolute offset of the symbol. */
3992 outrel
.r_addend
+= relocation
;
3994 /* Global plabels need to be processed by the
3995 dynamic linker so that functions have at most one
3996 fptr. For this reason, we need to differentiate
3997 between global and local plabels, which we do by
3998 providing the function symbol for a global plabel
3999 reloc, and no symbol for local plabels. */
4002 && sym_sec
->output_section
!= NULL
4003 && ! bfd_is_abs_section (sym_sec
))
4005 indx
= elf_section_data (sym_sec
->output_section
)->dynindx
;
4006 /* We are turning this relocation into one
4007 against a section symbol, so subtract out the
4008 output section's address but not the offset
4009 of the input section in the output section. */
4010 outrel
.r_addend
-= sym_sec
->output_section
->vma
;
4013 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
4016 /* EH info can cause unaligned DIR32 relocs.
4017 Tweak the reloc type for the dynamic linker. */
4018 if (r_type
== R_PARISC_DIR32
&& (outrel
.r_offset
& 3) != 0)
4019 outrel
.r_info
= ELF32_R_INFO (ELF32_R_SYM (outrel
.r_info
),
4022 sreloc
= elf_section_data (input_section
)->sreloc
;
4026 loc
= (Elf32_External_Rela
*) sreloc
->contents
;
4027 loc
+= sreloc
->reloc_count
++;
4028 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4036 r
= final_link_relocate (input_section
, contents
, rel
, relocation
,
4039 if (r
== bfd_reloc_ok
)
4043 sym_name
= h
->elf
.root
.root
.string
;
4046 sym_name
= bfd_elf_string_from_elf_section (input_bfd
,
4047 symtab_hdr
->sh_link
,
4049 if (sym_name
== NULL
)
4051 if (*sym_name
== '\0')
4052 sym_name
= bfd_section_name (input_bfd
, sym_sec
);
4055 howto
= elf_hppa_howto_table
+ r_type
;
4057 if (r
== bfd_reloc_undefined
|| r
== bfd_reloc_notsupported
)
4059 if (r
== bfd_reloc_notsupported
|| !warned_undef
)
4061 (*_bfd_error_handler
)
4062 (_("%s(%s+0x%lx): cannot handle %s for %s"),
4063 bfd_archive_filename (input_bfd
),
4064 input_section
->name
,
4065 (long) rel
->r_offset
,
4068 bfd_set_error (bfd_error_bad_value
);
4074 if (!((*info
->callbacks
->reloc_overflow
)
4075 (info
, sym_name
, howto
->name
, (bfd_vma
) 0,
4076 input_bfd
, input_section
, rel
->r_offset
)))
4084 /* Comparison function for qsort to sort unwind section during a
4088 hppa_unwind_entry_compare (a
, b
)
4092 const bfd_byte
*ap
, *bp
;
4093 unsigned long av
, bv
;
4095 ap
= (const bfd_byte
*) a
;
4096 av
= (unsigned long) ap
[0] << 24;
4097 av
|= (unsigned long) ap
[1] << 16;
4098 av
|= (unsigned long) ap
[2] << 8;
4099 av
|= (unsigned long) ap
[3];
4101 bp
= (const bfd_byte
*) b
;
4102 bv
= (unsigned long) bp
[0] << 24;
4103 bv
|= (unsigned long) bp
[1] << 16;
4104 bv
|= (unsigned long) bp
[2] << 8;
4105 bv
|= (unsigned long) bp
[3];
4107 return av
< bv
? -1 : av
> bv
? 1 : 0;
4110 /* Finish up dynamic symbol handling. We set the contents of various
4111 dynamic sections here. */
4114 elf32_hppa_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
4116 struct bfd_link_info
*info
;
4117 struct elf_link_hash_entry
*h
;
4118 Elf_Internal_Sym
*sym
;
4120 struct elf32_hppa_link_hash_table
*htab
;
4122 htab
= hppa_link_hash_table (info
);
4124 if (h
->plt
.offset
!= (bfd_vma
) -1)
4128 if (h
->plt
.offset
& 1)
4131 /* This symbol has an entry in the procedure linkage table. Set
4134 The format of a plt entry is
4139 if (h
->root
.type
== bfd_link_hash_defined
4140 || h
->root
.type
== bfd_link_hash_defweak
)
4142 value
= h
->root
.u
.def
.value
;
4143 if (h
->root
.u
.def
.section
->output_section
!= NULL
)
4144 value
+= (h
->root
.u
.def
.section
->output_offset
4145 + h
->root
.u
.def
.section
->output_section
->vma
);
4148 if (! ((struct elf32_hppa_link_hash_entry
*) h
)->pic_call
)
4150 Elf_Internal_Rela rel
;
4151 Elf32_External_Rela
*loc
;
4153 /* Create a dynamic IPLT relocation for this entry. */
4154 rel
.r_offset
= (h
->plt
.offset
4155 + htab
->splt
->output_offset
4156 + htab
->splt
->output_section
->vma
);
4157 if (h
->dynindx
!= -1)
4159 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_PARISC_IPLT
);
4164 /* This symbol has been marked to become local, and is
4165 used by a plabel so must be kept in the .plt. */
4166 rel
.r_info
= ELF32_R_INFO (0, R_PARISC_IPLT
);
4167 rel
.r_addend
= value
;
4170 loc
= (Elf32_External_Rela
*) htab
->srelplt
->contents
;
4171 loc
+= htab
->srelplt
->reloc_count
++;
4172 bfd_elf32_swap_reloca_out (htab
->splt
->output_section
->owner
,
4177 bfd_put_32 (htab
->splt
->owner
,
4179 htab
->splt
->contents
+ h
->plt
.offset
);
4180 bfd_put_32 (htab
->splt
->owner
,
4181 elf_gp (htab
->splt
->output_section
->owner
),
4182 htab
->splt
->contents
+ h
->plt
.offset
+ 4);
4185 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
4187 /* Mark the symbol as undefined, rather than as defined in
4188 the .plt section. Leave the value alone. */
4189 sym
->st_shndx
= SHN_UNDEF
;
4193 if (h
->got
.offset
!= (bfd_vma
) -1)
4195 Elf_Internal_Rela rel
;
4196 Elf32_External_Rela
*loc
;
4198 /* This symbol has an entry in the global offset table. Set it
4201 rel
.r_offset
= ((h
->got
.offset
&~ (bfd_vma
) 1)
4202 + htab
->sgot
->output_offset
4203 + htab
->sgot
->output_section
->vma
);
4205 /* If this is a -Bsymbolic link and the symbol is defined
4206 locally or was forced to be local because of a version file,
4207 we just want to emit a RELATIVE reloc. The entry in the
4208 global offset table will already have been initialized in the
4209 relocate_section function. */
4211 && (info
->symbolic
|| h
->dynindx
== -1)
4212 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
4214 rel
.r_info
= ELF32_R_INFO (0, R_PARISC_DIR32
);
4215 rel
.r_addend
= (h
->root
.u
.def
.value
4216 + h
->root
.u
.def
.section
->output_offset
4217 + h
->root
.u
.def
.section
->output_section
->vma
);
4221 if ((h
->got
.offset
& 1) != 0)
4223 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
4224 htab
->sgot
->contents
+ h
->got
.offset
);
4225 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_PARISC_DIR32
);
4229 loc
= (Elf32_External_Rela
*) htab
->srelgot
->contents
;
4230 loc
+= htab
->srelgot
->reloc_count
++;
4231 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
4234 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
4237 Elf_Internal_Rela rel
;
4238 Elf32_External_Rela
*loc
;
4240 /* This symbol needs a copy reloc. Set it up. */
4242 if (! (h
->dynindx
!= -1
4243 && (h
->root
.type
== bfd_link_hash_defined
4244 || h
->root
.type
== bfd_link_hash_defweak
)))
4249 rel
.r_offset
= (h
->root
.u
.def
.value
4250 + h
->root
.u
.def
.section
->output_offset
4251 + h
->root
.u
.def
.section
->output_section
->vma
);
4253 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_PARISC_COPY
);
4254 loc
= (Elf32_External_Rela
*) s
->contents
+ s
->reloc_count
++;
4255 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
4258 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
4259 if (h
->root
.root
.string
[0] == '_'
4260 && (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
4261 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0))
4263 sym
->st_shndx
= SHN_ABS
;
4269 /* Used to decide how to sort relocs in an optimal manner for the
4270 dynamic linker, before writing them out. */
4272 static enum elf_reloc_type_class
4273 elf32_hppa_reloc_type_class (rela
)
4274 const Elf_Internal_Rela
*rela
;
4276 if (ELF32_R_SYM (rela
->r_info
) == 0)
4277 return reloc_class_relative
;
4279 switch ((int) ELF32_R_TYPE (rela
->r_info
))
4282 return reloc_class_plt
;
4284 return reloc_class_copy
;
4286 return reloc_class_normal
;
4290 /* Finish up the dynamic sections. */
4293 elf32_hppa_finish_dynamic_sections (output_bfd
, info
)
4295 struct bfd_link_info
*info
;
4298 struct elf32_hppa_link_hash_table
*htab
;
4301 htab
= hppa_link_hash_table (info
);
4302 dynobj
= htab
->elf
.dynobj
;
4304 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
4306 if (htab
->elf
.dynamic_sections_created
)
4308 Elf32_External_Dyn
*dyncon
, *dynconend
;
4313 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
4314 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
4315 for (; dyncon
< dynconend
; dyncon
++)
4317 Elf_Internal_Dyn dyn
;
4320 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4328 /* Use PLTGOT to set the GOT register. */
4329 dyn
.d_un
.d_ptr
= elf_gp (output_bfd
);
4334 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
4339 if (s
->_cooked_size
!= 0)
4340 dyn
.d_un
.d_val
= s
->_cooked_size
;
4342 dyn
.d_un
.d_val
= s
->_raw_size
;
4346 /* Don't count procedure linkage table relocs in the
4347 overall reloc count. */
4348 if (htab
->srelplt
!= NULL
)
4350 s
= htab
->srelplt
->output_section
;
4351 if (s
->_cooked_size
!= 0)
4352 dyn
.d_un
.d_val
-= s
->_cooked_size
;
4354 dyn
.d_un
.d_val
-= s
->_raw_size
;
4359 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4363 if (htab
->sgot
!= NULL
&& htab
->sgot
->_raw_size
!= 0)
4365 /* Fill in the first entry in the global offset table.
4366 We use it to point to our dynamic section, if we have one. */
4367 bfd_put_32 (output_bfd
,
4369 ? sdyn
->output_section
->vma
+ sdyn
->output_offset
4371 htab
->sgot
->contents
);
4373 /* The second entry is reserved for use by the dynamic linker. */
4374 memset (htab
->sgot
->contents
+ GOT_ENTRY_SIZE
, 0, GOT_ENTRY_SIZE
);
4376 /* Set .got entry size. */
4377 elf_section_data (htab
->sgot
->output_section
)
4378 ->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
4381 if (htab
->splt
!= NULL
&& htab
->splt
->_raw_size
!= 0)
4383 /* Set plt entry size. */
4384 elf_section_data (htab
->splt
->output_section
)
4385 ->this_hdr
.sh_entsize
= PLT_ENTRY_SIZE
;
4387 if (htab
->need_plt_stub
)
4389 /* Set up the .plt stub. */
4390 memcpy (htab
->splt
->contents
4391 + htab
->splt
->_raw_size
- sizeof (plt_stub
),
4392 plt_stub
, sizeof (plt_stub
));
4394 if ((htab
->splt
->output_offset
4395 + htab
->splt
->output_section
->vma
4396 + htab
->splt
->_raw_size
)
4397 != (htab
->sgot
->output_offset
4398 + htab
->sgot
->output_section
->vma
))
4400 (*_bfd_error_handler
)
4401 (_(".got section not immediately after .plt section"));
4410 /* Tweak the OSABI field of the elf header. */
4413 elf32_hppa_post_process_headers (abfd
, link_info
)
4415 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
4417 Elf_Internal_Ehdr
* i_ehdrp
;
4419 i_ehdrp
= elf_elfheader (abfd
);
4421 if (strcmp (bfd_get_target (abfd
), "elf32-hppa-linux") == 0)
4423 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_LINUX
;
4427 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_HPUX
;
4431 /* Called when writing out an object file to decide the type of a
4434 elf32_hppa_elf_get_symbol_type (elf_sym
, type
)
4435 Elf_Internal_Sym
*elf_sym
;
4438 if (ELF_ST_TYPE (elf_sym
->st_info
) == STT_PARISC_MILLI
)
4439 return STT_PARISC_MILLI
;
4444 /* Misc BFD support code. */
4445 #define bfd_elf32_bfd_is_local_label_name elf_hppa_is_local_label_name
4446 #define bfd_elf32_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
4447 #define elf_info_to_howto elf_hppa_info_to_howto
4448 #define elf_info_to_howto_rel elf_hppa_info_to_howto_rel
4450 /* Stuff for the BFD linker. */
4451 #define bfd_elf32_bfd_final_link elf32_hppa_final_link
4452 #define bfd_elf32_bfd_link_hash_table_create elf32_hppa_link_hash_table_create
4453 #define elf_backend_add_symbol_hook elf32_hppa_add_symbol_hook
4454 #define elf_backend_adjust_dynamic_symbol elf32_hppa_adjust_dynamic_symbol
4455 #define elf_backend_copy_indirect_symbol elf32_hppa_copy_indirect_symbol
4456 #define elf_backend_check_relocs elf32_hppa_check_relocs
4457 #define elf_backend_create_dynamic_sections elf32_hppa_create_dynamic_sections
4458 #define elf_backend_fake_sections elf_hppa_fake_sections
4459 #define elf_backend_relocate_section elf32_hppa_relocate_section
4460 #define elf_backend_hide_symbol elf32_hppa_hide_symbol
4461 #define elf_backend_finish_dynamic_symbol elf32_hppa_finish_dynamic_symbol
4462 #define elf_backend_finish_dynamic_sections elf32_hppa_finish_dynamic_sections
4463 #define elf_backend_size_dynamic_sections elf32_hppa_size_dynamic_sections
4464 #define elf_backend_gc_mark_hook elf32_hppa_gc_mark_hook
4465 #define elf_backend_gc_sweep_hook elf32_hppa_gc_sweep_hook
4466 #define elf_backend_object_p elf32_hppa_object_p
4467 #define elf_backend_final_write_processing elf_hppa_final_write_processing
4468 #define elf_backend_post_process_headers elf32_hppa_post_process_headers
4469 #define elf_backend_get_symbol_type elf32_hppa_elf_get_symbol_type
4470 #define elf_backend_reloc_type_class elf32_hppa_reloc_type_class
4472 #define elf_backend_can_gc_sections 1
4473 #define elf_backend_can_refcount 1
4474 #define elf_backend_plt_alignment 2
4475 #define elf_backend_want_got_plt 0
4476 #define elf_backend_plt_readonly 0
4477 #define elf_backend_want_plt_sym 0
4478 #define elf_backend_got_header_size 8
4480 #define TARGET_BIG_SYM bfd_elf32_hppa_vec
4481 #define TARGET_BIG_NAME "elf32-hppa"
4482 #define ELF_ARCH bfd_arch_hppa
4483 #define ELF_MACHINE_CODE EM_PARISC
4484 #define ELF_MAXPAGESIZE 0x1000
4486 #include "elf32-target.h"
4488 #undef TARGET_BIG_SYM
4489 #define TARGET_BIG_SYM bfd_elf32_hppa_linux_vec
4490 #undef TARGET_BIG_NAME
4491 #define TARGET_BIG_NAME "elf32-hppa-linux"
4493 #define INCLUDED_TARGET_FILE 1
4494 #include "elf32-target.h"