1 /* BFD back-end for HP PA-RISC ELF files.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000, 2001,
3 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
4 Free Software Foundation, Inc.
7 Center for Software Science
8 Department of Computer Science
10 Largely rewritten by Alan Modra <alan@linuxcare.com.au>
11 Naming cleanup by Carlos O'Donell <carlos@systemhalted.org>
12 TLS support written by Randolph Chung <tausq@debian.org>
14 This file is part of BFD, the Binary File Descriptor library.
16 This program is free software; you can redistribute it and/or modify
17 it under the terms of the GNU General Public License as published by
18 the Free Software Foundation; either version 3 of the License, or
19 (at your option) any later version.
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program; if not, write to the Free Software
28 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
29 MA 02110-1301, USA. */
37 #include "elf32-hppa.h"
39 #include "elf32-hppa.h"
42 /* In order to gain some understanding of code in this file without
43 knowing all the intricate details of the linker, note the
46 Functions named elf32_hppa_* are called by external routines, other
47 functions are only called locally. elf32_hppa_* functions appear
48 in this file more or less in the order in which they are called
49 from external routines. eg. elf32_hppa_check_relocs is called
50 early in the link process, elf32_hppa_finish_dynamic_sections is
51 one of the last functions. */
53 /* We use two hash tables to hold information for linking PA ELF objects.
55 The first is the elf32_hppa_link_hash_table which is derived
56 from the standard ELF linker hash table. We use this as a place to
57 attach other hash tables and static information.
59 The second is the stub hash table which is derived from the
60 base BFD hash table. The stub hash table holds the information
61 necessary to build the linker stubs during a link.
63 There are a number of different stubs generated by the linker.
71 : addil LR'X - ($PIC_pcrel$0 - 4),%r1
72 : be,n RR'X - ($PIC_pcrel$0 - 8)(%sr4,%r1)
74 Import stub to call shared library routine from normal object file
75 (single sub-space version)
76 : addil LR'lt_ptr+ltoff,%dp ; get procedure entry point
77 : ldw RR'lt_ptr+ltoff(%r1),%r21
79 : ldw RR'lt_ptr+ltoff+4(%r1),%r19 ; get new dlt value.
81 Import stub to call shared library routine from shared library
82 (single sub-space version)
83 : addil LR'ltoff,%r19 ; get procedure entry point
84 : ldw RR'ltoff(%r1),%r21
86 : ldw RR'ltoff+4(%r1),%r19 ; get new dlt value.
88 Import stub to call shared library routine from normal object file
89 (multiple sub-space support)
90 : addil LR'lt_ptr+ltoff,%dp ; get procedure entry point
91 : ldw RR'lt_ptr+ltoff(%r1),%r21
92 : ldw RR'lt_ptr+ltoff+4(%r1),%r19 ; get new dlt value.
95 : be 0(%sr0,%r21) ; branch to target
96 : stw %rp,-24(%sp) ; save rp
98 Import stub to call shared library routine from shared library
99 (multiple sub-space support)
100 : addil LR'ltoff,%r19 ; get procedure entry point
101 : ldw RR'ltoff(%r1),%r21
102 : ldw RR'ltoff+4(%r1),%r19 ; get new dlt value.
105 : be 0(%sr0,%r21) ; branch to target
106 : stw %rp,-24(%sp) ; save rp
108 Export stub to return from shared lib routine (multiple sub-space support)
109 One of these is created for each exported procedure in a shared
110 library (and stored in the shared lib). Shared lib routines are
111 called via the first instruction in the export stub so that we can
112 do an inter-space return. Not required for single sub-space.
113 : bl,n X,%rp ; trap the return
115 : ldw -24(%sp),%rp ; restore the original rp
118 : be,n 0(%sr0,%rp) ; inter-space return. */
121 /* Variable names follow a coding style.
122 Please follow this (Apps Hungarian) style:
124 Structure/Variable Prefix
125 elf_link_hash_table "etab"
126 elf_link_hash_entry "eh"
128 elf32_hppa_link_hash_table "htab"
129 elf32_hppa_link_hash_entry "hh"
131 bfd_hash_table "btab"
134 bfd_hash_table containing stubs "bstab"
135 elf32_hppa_stub_hash_entry "hsh"
137 elf32_hppa_dyn_reloc_entry "hdh"
139 Always remember to use GNU Coding Style. */
141 #define PLT_ENTRY_SIZE 8
142 #define GOT_ENTRY_SIZE 4
143 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
145 static const bfd_byte plt_stub
[] =
147 0x0e, 0x80, 0x10, 0x96, /* 1: ldw 0(%r20),%r22 */
148 0xea, 0xc0, 0xc0, 0x00, /* bv %r0(%r22) */
149 0x0e, 0x88, 0x10, 0x95, /* ldw 4(%r20),%r21 */
150 #define PLT_STUB_ENTRY (3*4)
151 0xea, 0x9f, 0x1f, 0xdd, /* b,l 1b,%r20 */
152 0xd6, 0x80, 0x1c, 0x1e, /* depi 0,31,2,%r20 */
153 0x00, 0xc0, 0xff, 0xee, /* 9: .word fixup_func */
154 0xde, 0xad, 0xbe, 0xef /* .word fixup_ltp */
157 /* Section name for stubs is the associated section name plus this
159 #define STUB_SUFFIX ".stub"
161 /* We don't need to copy certain PC- or GP-relative dynamic relocs
162 into a shared object's dynamic section. All the relocs of the
163 limited class we are interested in, are absolute. */
164 #ifndef RELATIVE_DYNRELOCS
165 #define RELATIVE_DYNRELOCS 0
166 #define IS_ABSOLUTE_RELOC(r_type) 1
169 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
170 copying dynamic variables from a shared lib into an app's dynbss
171 section, and instead use a dynamic relocation to point into the
173 #define ELIMINATE_COPY_RELOCS 1
175 enum elf32_hppa_stub_type
177 hppa_stub_long_branch
,
178 hppa_stub_long_branch_shared
,
180 hppa_stub_import_shared
,
185 struct elf32_hppa_stub_hash_entry
187 /* Base hash table entry structure. */
188 struct bfd_hash_entry bh_root
;
190 /* The stub section. */
193 /* Offset within stub_sec of the beginning of this stub. */
196 /* Given the symbol's value and its section we can determine its final
197 value when building the stubs (so the stub knows where to jump. */
198 bfd_vma target_value
;
199 asection
*target_section
;
201 enum elf32_hppa_stub_type stub_type
;
203 /* The symbol table entry, if any, that this was derived from. */
204 struct elf32_hppa_link_hash_entry
*hh
;
206 /* Where this stub is being called from, or, in the case of combined
207 stub sections, the first input section in the group. */
211 struct elf32_hppa_link_hash_entry
213 struct elf_link_hash_entry eh
;
215 /* A pointer to the most recently used stub hash entry against this
217 struct elf32_hppa_stub_hash_entry
*hsh_cache
;
219 /* Used to count relocations for delayed sizing of relocation
221 struct elf32_hppa_dyn_reloc_entry
223 /* Next relocation in the chain. */
224 struct elf32_hppa_dyn_reloc_entry
*hdh_next
;
226 /* The input section of the reloc. */
229 /* Number of relocs copied in this section. */
232 #if RELATIVE_DYNRELOCS
233 /* Number of relative relocs copied for the input section. */
234 bfd_size_type relative_count
;
240 GOT_UNKNOWN
= 0, GOT_NORMAL
= 1, GOT_TLS_GD
= 2, GOT_TLS_LDM
= 4, GOT_TLS_IE
= 8
243 /* Set if this symbol is used by a plabel reloc. */
244 unsigned int plabel
:1;
247 struct elf32_hppa_link_hash_table
249 /* The main hash table. */
250 struct elf_link_hash_table etab
;
252 /* The stub hash table. */
253 struct bfd_hash_table bstab
;
255 /* Linker stub bfd. */
258 /* Linker call-backs. */
259 asection
* (*add_stub_section
) (const char *, asection
*);
260 void (*layout_sections_again
) (void);
262 /* Array to keep track of which stub sections have been created, and
263 information on stub grouping. */
266 /* This is the section to which stubs in the group will be
269 /* The stub section. */
273 /* Assorted information used by elf32_hppa_size_stubs. */
274 unsigned int bfd_count
;
276 asection
**input_list
;
277 Elf_Internal_Sym
**all_local_syms
;
279 /* Short-cuts to get to dynamic linker sections. */
287 /* Used during a final link to store the base of the text and data
288 segments so that we can perform SEGREL relocations. */
289 bfd_vma text_segment_base
;
290 bfd_vma data_segment_base
;
292 /* Whether we support multiple sub-spaces for shared libs. */
293 unsigned int multi_subspace
:1;
295 /* Flags set when various size branches are detected. Used to
296 select suitable defaults for the stub group size. */
297 unsigned int has_12bit_branch
:1;
298 unsigned int has_17bit_branch
:1;
299 unsigned int has_22bit_branch
:1;
301 /* Set if we need a .plt stub to support lazy dynamic linking. */
302 unsigned int need_plt_stub
:1;
304 /* Small local sym cache. */
305 struct sym_cache sym_cache
;
307 /* Data for LDM relocations. */
310 bfd_signed_vma refcount
;
315 /* Various hash macros and functions. */
316 #define hppa_link_hash_table(p) \
317 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
318 == HPPA32_ELF_DATA ? ((struct elf32_hppa_link_hash_table *) ((p)->hash)) : NULL)
320 #define hppa_elf_hash_entry(ent) \
321 ((struct elf32_hppa_link_hash_entry *)(ent))
323 #define hppa_stub_hash_entry(ent) \
324 ((struct elf32_hppa_stub_hash_entry *)(ent))
326 #define hppa_stub_hash_lookup(table, string, create, copy) \
327 ((struct elf32_hppa_stub_hash_entry *) \
328 bfd_hash_lookup ((table), (string), (create), (copy)))
330 #define hppa_elf_local_got_tls_type(abfd) \
331 ((char *)(elf_local_got_offsets (abfd) + (elf_tdata (abfd)->symtab_hdr.sh_info * 2)))
333 #define hh_name(hh) \
334 (hh ? hh->eh.root.root.string : "<undef>")
336 #define eh_name(eh) \
337 (eh ? eh->root.root.string : "<undef>")
339 /* Assorted hash table functions. */
341 /* Initialize an entry in the stub hash table. */
343 static struct bfd_hash_entry
*
344 stub_hash_newfunc (struct bfd_hash_entry
*entry
,
345 struct bfd_hash_table
*table
,
348 /* Allocate the structure if it has not already been allocated by a
352 entry
= bfd_hash_allocate (table
,
353 sizeof (struct elf32_hppa_stub_hash_entry
));
358 /* Call the allocation method of the superclass. */
359 entry
= bfd_hash_newfunc (entry
, table
, string
);
362 struct elf32_hppa_stub_hash_entry
*hsh
;
364 /* Initialize the local fields. */
365 hsh
= hppa_stub_hash_entry (entry
);
366 hsh
->stub_sec
= NULL
;
367 hsh
->stub_offset
= 0;
368 hsh
->target_value
= 0;
369 hsh
->target_section
= NULL
;
370 hsh
->stub_type
= hppa_stub_long_branch
;
378 /* Initialize an entry in the link hash table. */
380 static struct bfd_hash_entry
*
381 hppa_link_hash_newfunc (struct bfd_hash_entry
*entry
,
382 struct bfd_hash_table
*table
,
385 /* Allocate the structure if it has not already been allocated by a
389 entry
= bfd_hash_allocate (table
,
390 sizeof (struct elf32_hppa_link_hash_entry
));
395 /* Call the allocation method of the superclass. */
396 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
399 struct elf32_hppa_link_hash_entry
*hh
;
401 /* Initialize the local fields. */
402 hh
= hppa_elf_hash_entry (entry
);
403 hh
->hsh_cache
= NULL
;
404 hh
->dyn_relocs
= NULL
;
406 hh
->tls_type
= GOT_UNKNOWN
;
412 /* Create the derived linker hash table. The PA ELF port uses the derived
413 hash table to keep information specific to the PA ELF linker (without
414 using static variables). */
416 static struct bfd_link_hash_table
*
417 elf32_hppa_link_hash_table_create (bfd
*abfd
)
419 struct elf32_hppa_link_hash_table
*htab
;
420 bfd_size_type amt
= sizeof (*htab
);
422 htab
= bfd_zmalloc (amt
);
426 if (!_bfd_elf_link_hash_table_init (&htab
->etab
, abfd
, hppa_link_hash_newfunc
,
427 sizeof (struct elf32_hppa_link_hash_entry
),
434 /* Init the stub hash table too. */
435 if (!bfd_hash_table_init (&htab
->bstab
, stub_hash_newfunc
,
436 sizeof (struct elf32_hppa_stub_hash_entry
)))
439 htab
->text_segment_base
= (bfd_vma
) -1;
440 htab
->data_segment_base
= (bfd_vma
) -1;
441 return &htab
->etab
.root
;
444 /* Free the derived linker hash table. */
447 elf32_hppa_link_hash_table_free (struct bfd_link_hash_table
*btab
)
449 struct elf32_hppa_link_hash_table
*htab
450 = (struct elf32_hppa_link_hash_table
*) btab
;
452 bfd_hash_table_free (&htab
->bstab
);
453 _bfd_elf_link_hash_table_free (btab
);
456 /* Build a name for an entry in the stub hash table. */
459 hppa_stub_name (const asection
*input_section
,
460 const asection
*sym_sec
,
461 const struct elf32_hppa_link_hash_entry
*hh
,
462 const Elf_Internal_Rela
*rela
)
469 len
= 8 + 1 + strlen (hh_name (hh
)) + 1 + 8 + 1;
470 stub_name
= bfd_malloc (len
);
471 if (stub_name
!= NULL
)
472 sprintf (stub_name
, "%08x_%s+%x",
473 input_section
->id
& 0xffffffff,
475 (int) rela
->r_addend
& 0xffffffff);
479 len
= 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
480 stub_name
= bfd_malloc (len
);
481 if (stub_name
!= NULL
)
482 sprintf (stub_name
, "%08x_%x:%x+%x",
483 input_section
->id
& 0xffffffff,
484 sym_sec
->id
& 0xffffffff,
485 (int) ELF32_R_SYM (rela
->r_info
) & 0xffffffff,
486 (int) rela
->r_addend
& 0xffffffff);
491 /* Look up an entry in the stub hash. Stub entries are cached because
492 creating the stub name takes a bit of time. */
494 static struct elf32_hppa_stub_hash_entry
*
495 hppa_get_stub_entry (const asection
*input_section
,
496 const asection
*sym_sec
,
497 struct elf32_hppa_link_hash_entry
*hh
,
498 const Elf_Internal_Rela
*rela
,
499 struct elf32_hppa_link_hash_table
*htab
)
501 struct elf32_hppa_stub_hash_entry
*hsh_entry
;
502 const asection
*id_sec
;
504 /* If this input section is part of a group of sections sharing one
505 stub section, then use the id of the first section in the group.
506 Stub names need to include a section id, as there may well be
507 more than one stub used to reach say, printf, and we need to
508 distinguish between them. */
509 id_sec
= htab
->stub_group
[input_section
->id
].link_sec
;
511 if (hh
!= NULL
&& hh
->hsh_cache
!= NULL
512 && hh
->hsh_cache
->hh
== hh
513 && hh
->hsh_cache
->id_sec
== id_sec
)
515 hsh_entry
= hh
->hsh_cache
;
521 stub_name
= hppa_stub_name (id_sec
, sym_sec
, hh
, rela
);
522 if (stub_name
== NULL
)
525 hsh_entry
= hppa_stub_hash_lookup (&htab
->bstab
,
526 stub_name
, FALSE
, FALSE
);
528 hh
->hsh_cache
= hsh_entry
;
536 /* Add a new stub entry to the stub hash. Not all fields of the new
537 stub entry are initialised. */
539 static struct elf32_hppa_stub_hash_entry
*
540 hppa_add_stub (const char *stub_name
,
542 struct elf32_hppa_link_hash_table
*htab
)
546 struct elf32_hppa_stub_hash_entry
*hsh
;
548 link_sec
= htab
->stub_group
[section
->id
].link_sec
;
549 stub_sec
= htab
->stub_group
[section
->id
].stub_sec
;
550 if (stub_sec
== NULL
)
552 stub_sec
= htab
->stub_group
[link_sec
->id
].stub_sec
;
553 if (stub_sec
== NULL
)
559 namelen
= strlen (link_sec
->name
);
560 len
= namelen
+ sizeof (STUB_SUFFIX
);
561 s_name
= bfd_alloc (htab
->stub_bfd
, len
);
565 memcpy (s_name
, link_sec
->name
, namelen
);
566 memcpy (s_name
+ namelen
, STUB_SUFFIX
, sizeof (STUB_SUFFIX
));
567 stub_sec
= (*htab
->add_stub_section
) (s_name
, link_sec
);
568 if (stub_sec
== NULL
)
570 htab
->stub_group
[link_sec
->id
].stub_sec
= stub_sec
;
572 htab
->stub_group
[section
->id
].stub_sec
= stub_sec
;
575 /* Enter this entry into the linker stub hash table. */
576 hsh
= hppa_stub_hash_lookup (&htab
->bstab
, stub_name
,
580 (*_bfd_error_handler
) (_("%B: cannot create stub entry %s"),
586 hsh
->stub_sec
= stub_sec
;
587 hsh
->stub_offset
= 0;
588 hsh
->id_sec
= link_sec
;
592 /* Determine the type of stub needed, if any, for a call. */
594 static enum elf32_hppa_stub_type
595 hppa_type_of_stub (asection
*input_sec
,
596 const Elf_Internal_Rela
*rela
,
597 struct elf32_hppa_link_hash_entry
*hh
,
599 struct bfd_link_info
*info
)
602 bfd_vma branch_offset
;
603 bfd_vma max_branch_offset
;
607 && hh
->eh
.plt
.offset
!= (bfd_vma
) -1
608 && hh
->eh
.dynindx
!= -1
611 || !hh
->eh
.def_regular
612 || hh
->eh
.root
.type
== bfd_link_hash_defweak
))
614 /* We need an import stub. Decide between hppa_stub_import
615 and hppa_stub_import_shared later. */
616 return hppa_stub_import
;
619 /* Determine where the call point is. */
620 location
= (input_sec
->output_offset
621 + input_sec
->output_section
->vma
624 branch_offset
= destination
- location
- 8;
625 r_type
= ELF32_R_TYPE (rela
->r_info
);
627 /* Determine if a long branch stub is needed. parisc branch offsets
628 are relative to the second instruction past the branch, ie. +8
629 bytes on from the branch instruction location. The offset is
630 signed and counts in units of 4 bytes. */
631 if (r_type
== (unsigned int) R_PARISC_PCREL17F
)
632 max_branch_offset
= (1 << (17 - 1)) << 2;
634 else if (r_type
== (unsigned int) R_PARISC_PCREL12F
)
635 max_branch_offset
= (1 << (12 - 1)) << 2;
637 else /* R_PARISC_PCREL22F. */
638 max_branch_offset
= (1 << (22 - 1)) << 2;
640 if (branch_offset
+ max_branch_offset
>= 2*max_branch_offset
)
641 return hppa_stub_long_branch
;
643 return hppa_stub_none
;
646 /* Build one linker stub as defined by the stub hash table entry GEN_ENTRY.
647 IN_ARG contains the link info pointer. */
649 #define LDIL_R1 0x20200000 /* ldil LR'XXX,%r1 */
650 #define BE_SR4_R1 0xe0202002 /* be,n RR'XXX(%sr4,%r1) */
652 #define BL_R1 0xe8200000 /* b,l .+8,%r1 */
653 #define ADDIL_R1 0x28200000 /* addil LR'XXX,%r1,%r1 */
654 #define DEPI_R1 0xd4201c1e /* depi 0,31,2,%r1 */
656 #define ADDIL_DP 0x2b600000 /* addil LR'XXX,%dp,%r1 */
657 #define LDW_R1_R21 0x48350000 /* ldw RR'XXX(%sr0,%r1),%r21 */
658 #define BV_R0_R21 0xeaa0c000 /* bv %r0(%r21) */
659 #define LDW_R1_R19 0x48330000 /* ldw RR'XXX(%sr0,%r1),%r19 */
661 #define ADDIL_R19 0x2a600000 /* addil LR'XXX,%r19,%r1 */
662 #define LDW_R1_DP 0x483b0000 /* ldw RR'XXX(%sr0,%r1),%dp */
664 #define LDSID_R21_R1 0x02a010a1 /* ldsid (%sr0,%r21),%r1 */
665 #define MTSP_R1 0x00011820 /* mtsp %r1,%sr0 */
666 #define BE_SR0_R21 0xe2a00000 /* be 0(%sr0,%r21) */
667 #define STW_RP 0x6bc23fd1 /* stw %rp,-24(%sr0,%sp) */
669 #define BL22_RP 0xe800a002 /* b,l,n XXX,%rp */
670 #define BL_RP 0xe8400002 /* b,l,n XXX,%rp */
671 #define NOP 0x08000240 /* nop */
672 #define LDW_RP 0x4bc23fd1 /* ldw -24(%sr0,%sp),%rp */
673 #define LDSID_RP_R1 0x004010a1 /* ldsid (%sr0,%rp),%r1 */
674 #define BE_SR0_RP 0xe0400002 /* be,n 0(%sr0,%rp) */
681 #define LDW_R1_DLT LDW_R1_R19
683 #define LDW_R1_DLT LDW_R1_DP
687 hppa_build_one_stub (struct bfd_hash_entry
*bh
, void *in_arg
)
689 struct elf32_hppa_stub_hash_entry
*hsh
;
690 struct bfd_link_info
*info
;
691 struct elf32_hppa_link_hash_table
*htab
;
701 /* Massage our args to the form they really have. */
702 hsh
= hppa_stub_hash_entry (bh
);
703 info
= (struct bfd_link_info
*)in_arg
;
705 htab
= hppa_link_hash_table (info
);
709 stub_sec
= hsh
->stub_sec
;
711 /* Make a note of the offset within the stubs for this entry. */
712 hsh
->stub_offset
= stub_sec
->size
;
713 loc
= stub_sec
->contents
+ hsh
->stub_offset
;
715 stub_bfd
= stub_sec
->owner
;
717 switch (hsh
->stub_type
)
719 case hppa_stub_long_branch
:
720 /* Create the long branch. A long branch is formed with "ldil"
721 loading the upper bits of the target address into a register,
722 then branching with "be" which adds in the lower bits.
723 The "be" has its delay slot nullified. */
724 sym_value
= (hsh
->target_value
725 + hsh
->target_section
->output_offset
726 + hsh
->target_section
->output_section
->vma
);
728 val
= hppa_field_adjust (sym_value
, 0, e_lrsel
);
729 insn
= hppa_rebuild_insn ((int) LDIL_R1
, val
, 21);
730 bfd_put_32 (stub_bfd
, insn
, loc
);
732 val
= hppa_field_adjust (sym_value
, 0, e_rrsel
) >> 2;
733 insn
= hppa_rebuild_insn ((int) BE_SR4_R1
, val
, 17);
734 bfd_put_32 (stub_bfd
, insn
, loc
+ 4);
739 case hppa_stub_long_branch_shared
:
740 /* Branches are relative. This is where we are going to. */
741 sym_value
= (hsh
->target_value
742 + hsh
->target_section
->output_offset
743 + hsh
->target_section
->output_section
->vma
);
745 /* And this is where we are coming from, more or less. */
746 sym_value
-= (hsh
->stub_offset
747 + stub_sec
->output_offset
748 + stub_sec
->output_section
->vma
);
750 bfd_put_32 (stub_bfd
, (bfd_vma
) BL_R1
, loc
);
751 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) -8, e_lrsel
);
752 insn
= hppa_rebuild_insn ((int) ADDIL_R1
, val
, 21);
753 bfd_put_32 (stub_bfd
, insn
, loc
+ 4);
755 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) -8, e_rrsel
) >> 2;
756 insn
= hppa_rebuild_insn ((int) BE_SR4_R1
, val
, 17);
757 bfd_put_32 (stub_bfd
, insn
, loc
+ 8);
761 case hppa_stub_import
:
762 case hppa_stub_import_shared
:
763 off
= hsh
->hh
->eh
.plt
.offset
;
764 if (off
>= (bfd_vma
) -2)
767 off
&= ~ (bfd_vma
) 1;
769 + htab
->splt
->output_offset
770 + htab
->splt
->output_section
->vma
771 - elf_gp (htab
->splt
->output_section
->owner
));
775 if (hsh
->stub_type
== hppa_stub_import_shared
)
778 val
= hppa_field_adjust (sym_value
, 0, e_lrsel
),
779 insn
= hppa_rebuild_insn ((int) insn
, val
, 21);
780 bfd_put_32 (stub_bfd
, insn
, loc
);
782 /* It is critical to use lrsel/rrsel here because we are using
783 two different offsets (+0 and +4) from sym_value. If we use
784 lsel/rsel then with unfortunate sym_values we will round
785 sym_value+4 up to the next 2k block leading to a mis-match
786 between the lsel and rsel value. */
787 val
= hppa_field_adjust (sym_value
, 0, e_rrsel
);
788 insn
= hppa_rebuild_insn ((int) LDW_R1_R21
, val
, 14);
789 bfd_put_32 (stub_bfd
, insn
, loc
+ 4);
791 if (htab
->multi_subspace
)
793 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) 4, e_rrsel
);
794 insn
= hppa_rebuild_insn ((int) LDW_R1_DLT
, val
, 14);
795 bfd_put_32 (stub_bfd
, insn
, loc
+ 8);
797 bfd_put_32 (stub_bfd
, (bfd_vma
) LDSID_R21_R1
, loc
+ 12);
798 bfd_put_32 (stub_bfd
, (bfd_vma
) MTSP_R1
, loc
+ 16);
799 bfd_put_32 (stub_bfd
, (bfd_vma
) BE_SR0_R21
, loc
+ 20);
800 bfd_put_32 (stub_bfd
, (bfd_vma
) STW_RP
, loc
+ 24);
806 bfd_put_32 (stub_bfd
, (bfd_vma
) BV_R0_R21
, loc
+ 8);
807 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) 4, e_rrsel
);
808 insn
= hppa_rebuild_insn ((int) LDW_R1_DLT
, val
, 14);
809 bfd_put_32 (stub_bfd
, insn
, loc
+ 12);
816 case hppa_stub_export
:
817 /* Branches are relative. This is where we are going to. */
818 sym_value
= (hsh
->target_value
819 + hsh
->target_section
->output_offset
820 + hsh
->target_section
->output_section
->vma
);
822 /* And this is where we are coming from. */
823 sym_value
-= (hsh
->stub_offset
824 + stub_sec
->output_offset
825 + stub_sec
->output_section
->vma
);
827 if (sym_value
- 8 + (1 << (17 + 1)) >= (1 << (17 + 2))
828 && (!htab
->has_22bit_branch
829 || sym_value
- 8 + (1 << (22 + 1)) >= (1 << (22 + 2))))
831 (*_bfd_error_handler
)
832 (_("%B(%A+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
833 hsh
->target_section
->owner
,
835 (long) hsh
->stub_offset
,
836 hsh
->bh_root
.string
);
837 bfd_set_error (bfd_error_bad_value
);
841 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) -8, e_fsel
) >> 2;
842 if (!htab
->has_22bit_branch
)
843 insn
= hppa_rebuild_insn ((int) BL_RP
, val
, 17);
845 insn
= hppa_rebuild_insn ((int) BL22_RP
, val
, 22);
846 bfd_put_32 (stub_bfd
, insn
, loc
);
848 bfd_put_32 (stub_bfd
, (bfd_vma
) NOP
, loc
+ 4);
849 bfd_put_32 (stub_bfd
, (bfd_vma
) LDW_RP
, loc
+ 8);
850 bfd_put_32 (stub_bfd
, (bfd_vma
) LDSID_RP_R1
, loc
+ 12);
851 bfd_put_32 (stub_bfd
, (bfd_vma
) MTSP_R1
, loc
+ 16);
852 bfd_put_32 (stub_bfd
, (bfd_vma
) BE_SR0_RP
, loc
+ 20);
854 /* Point the function symbol at the stub. */
855 hsh
->hh
->eh
.root
.u
.def
.section
= stub_sec
;
856 hsh
->hh
->eh
.root
.u
.def
.value
= stub_sec
->size
;
866 stub_sec
->size
+= size
;
891 /* As above, but don't actually build the stub. Just bump offset so
892 we know stub section sizes. */
895 hppa_size_one_stub (struct bfd_hash_entry
*bh
, void *in_arg
)
897 struct elf32_hppa_stub_hash_entry
*hsh
;
898 struct elf32_hppa_link_hash_table
*htab
;
901 /* Massage our args to the form they really have. */
902 hsh
= hppa_stub_hash_entry (bh
);
905 if (hsh
->stub_type
== hppa_stub_long_branch
)
907 else if (hsh
->stub_type
== hppa_stub_long_branch_shared
)
909 else if (hsh
->stub_type
== hppa_stub_export
)
911 else /* hppa_stub_import or hppa_stub_import_shared. */
913 if (htab
->multi_subspace
)
919 hsh
->stub_sec
->size
+= size
;
923 /* Return nonzero if ABFD represents an HPPA ELF32 file.
924 Additionally we set the default architecture and machine. */
927 elf32_hppa_object_p (bfd
*abfd
)
929 Elf_Internal_Ehdr
* i_ehdrp
;
932 i_ehdrp
= elf_elfheader (abfd
);
933 if (strcmp (bfd_get_target (abfd
), "elf32-hppa-linux") == 0)
935 /* GCC on hppa-linux produces binaries with OSABI=GNU,
936 but the kernel produces corefiles with OSABI=SysV. */
937 if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_GNU
&&
938 i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_NONE
) /* aka SYSV */
941 else if (strcmp (bfd_get_target (abfd
), "elf32-hppa-netbsd") == 0)
943 /* GCC on hppa-netbsd produces binaries with OSABI=NetBSD,
944 but the kernel produces corefiles with OSABI=SysV. */
945 if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_NETBSD
&&
946 i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_NONE
) /* aka SYSV */
951 if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_HPUX
)
955 flags
= i_ehdrp
->e_flags
;
956 switch (flags
& (EF_PARISC_ARCH
| EF_PARISC_WIDE
))
959 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 10);
961 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 11);
963 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 20);
964 case EFA_PARISC_2_0
| EF_PARISC_WIDE
:
965 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 25);
970 /* Create the .plt and .got sections, and set up our hash table
971 short-cuts to various dynamic sections. */
974 elf32_hppa_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
976 struct elf32_hppa_link_hash_table
*htab
;
977 struct elf_link_hash_entry
*eh
;
979 /* Don't try to create the .plt and .got twice. */
980 htab
= hppa_link_hash_table (info
);
983 if (htab
->splt
!= NULL
)
986 /* Call the generic code to do most of the work. */
987 if (! _bfd_elf_create_dynamic_sections (abfd
, info
))
990 htab
->splt
= bfd_get_linker_section (abfd
, ".plt");
991 htab
->srelplt
= bfd_get_linker_section (abfd
, ".rela.plt");
993 htab
->sgot
= bfd_get_linker_section (abfd
, ".got");
994 htab
->srelgot
= bfd_get_linker_section (abfd
, ".rela.got");
996 htab
->sdynbss
= bfd_get_linker_section (abfd
, ".dynbss");
997 htab
->srelbss
= bfd_get_linker_section (abfd
, ".rela.bss");
999 /* hppa-linux needs _GLOBAL_OFFSET_TABLE_ to be visible from the main
1000 application, because __canonicalize_funcptr_for_compare needs it. */
1001 eh
= elf_hash_table (info
)->hgot
;
1002 eh
->forced_local
= 0;
1003 eh
->other
= STV_DEFAULT
;
1004 return bfd_elf_link_record_dynamic_symbol (info
, eh
);
1007 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1010 elf32_hppa_copy_indirect_symbol (struct bfd_link_info
*info
,
1011 struct elf_link_hash_entry
*eh_dir
,
1012 struct elf_link_hash_entry
*eh_ind
)
1014 struct elf32_hppa_link_hash_entry
*hh_dir
, *hh_ind
;
1016 hh_dir
= hppa_elf_hash_entry (eh_dir
);
1017 hh_ind
= hppa_elf_hash_entry (eh_ind
);
1019 if (hh_ind
->dyn_relocs
!= NULL
)
1021 if (hh_dir
->dyn_relocs
!= NULL
)
1023 struct elf32_hppa_dyn_reloc_entry
**hdh_pp
;
1024 struct elf32_hppa_dyn_reloc_entry
*hdh_p
;
1026 /* Add reloc counts against the indirect sym to the direct sym
1027 list. Merge any entries against the same section. */
1028 for (hdh_pp
= &hh_ind
->dyn_relocs
; (hdh_p
= *hdh_pp
) != NULL
; )
1030 struct elf32_hppa_dyn_reloc_entry
*hdh_q
;
1032 for (hdh_q
= hh_dir
->dyn_relocs
;
1034 hdh_q
= hdh_q
->hdh_next
)
1035 if (hdh_q
->sec
== hdh_p
->sec
)
1037 #if RELATIVE_DYNRELOCS
1038 hdh_q
->relative_count
+= hdh_p
->relative_count
;
1040 hdh_q
->count
+= hdh_p
->count
;
1041 *hdh_pp
= hdh_p
->hdh_next
;
1045 hdh_pp
= &hdh_p
->hdh_next
;
1047 *hdh_pp
= hh_dir
->dyn_relocs
;
1050 hh_dir
->dyn_relocs
= hh_ind
->dyn_relocs
;
1051 hh_ind
->dyn_relocs
= NULL
;
1054 if (ELIMINATE_COPY_RELOCS
1055 && eh_ind
->root
.type
!= bfd_link_hash_indirect
1056 && eh_dir
->dynamic_adjusted
)
1058 /* If called to transfer flags for a weakdef during processing
1059 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1060 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1061 eh_dir
->ref_dynamic
|= eh_ind
->ref_dynamic
;
1062 eh_dir
->ref_regular
|= eh_ind
->ref_regular
;
1063 eh_dir
->ref_regular_nonweak
|= eh_ind
->ref_regular_nonweak
;
1064 eh_dir
->needs_plt
|= eh_ind
->needs_plt
;
1068 if (eh_ind
->root
.type
== bfd_link_hash_indirect
1069 && eh_dir
->got
.refcount
<= 0)
1071 hh_dir
->tls_type
= hh_ind
->tls_type
;
1072 hh_ind
->tls_type
= GOT_UNKNOWN
;
1075 _bfd_elf_link_hash_copy_indirect (info
, eh_dir
, eh_ind
);
1080 elf32_hppa_optimized_tls_reloc (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1081 int r_type
, int is_local ATTRIBUTE_UNUSED
)
1083 /* For now we don't support linker optimizations. */
1087 /* Return a pointer to the local GOT, PLT and TLS reference counts
1088 for ABFD. Returns NULL if the storage allocation fails. */
1090 static bfd_signed_vma
*
1091 hppa32_elf_local_refcounts (bfd
*abfd
)
1093 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1094 bfd_signed_vma
*local_refcounts
;
1096 local_refcounts
= elf_local_got_refcounts (abfd
);
1097 if (local_refcounts
== NULL
)
1101 /* Allocate space for local GOT and PLT reference
1102 counts. Done this way to save polluting elf_obj_tdata
1103 with another target specific pointer. */
1104 size
= symtab_hdr
->sh_info
;
1105 size
*= 2 * sizeof (bfd_signed_vma
);
1106 /* Add in space to store the local GOT TLS types. */
1107 size
+= symtab_hdr
->sh_info
;
1108 local_refcounts
= bfd_zalloc (abfd
, size
);
1109 if (local_refcounts
== NULL
)
1111 elf_local_got_refcounts (abfd
) = local_refcounts
;
1112 memset (hppa_elf_local_got_tls_type (abfd
), GOT_UNKNOWN
,
1113 symtab_hdr
->sh_info
);
1115 return local_refcounts
;
1119 /* Look through the relocs for a section during the first phase, and
1120 calculate needed space in the global offset table, procedure linkage
1121 table, and dynamic reloc sections. At this point we haven't
1122 necessarily read all the input files. */
1125 elf32_hppa_check_relocs (bfd
*abfd
,
1126 struct bfd_link_info
*info
,
1128 const Elf_Internal_Rela
*relocs
)
1130 Elf_Internal_Shdr
*symtab_hdr
;
1131 struct elf_link_hash_entry
**eh_syms
;
1132 const Elf_Internal_Rela
*rela
;
1133 const Elf_Internal_Rela
*rela_end
;
1134 struct elf32_hppa_link_hash_table
*htab
;
1136 int tls_type
= GOT_UNKNOWN
, old_tls_type
= GOT_UNKNOWN
;
1138 if (info
->relocatable
)
1141 htab
= hppa_link_hash_table (info
);
1144 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1145 eh_syms
= elf_sym_hashes (abfd
);
1148 rela_end
= relocs
+ sec
->reloc_count
;
1149 for (rela
= relocs
; rela
< rela_end
; rela
++)
1158 unsigned int r_symndx
, r_type
;
1159 struct elf32_hppa_link_hash_entry
*hh
;
1162 r_symndx
= ELF32_R_SYM (rela
->r_info
);
1164 if (r_symndx
< symtab_hdr
->sh_info
)
1168 hh
= hppa_elf_hash_entry (eh_syms
[r_symndx
- symtab_hdr
->sh_info
]);
1169 while (hh
->eh
.root
.type
== bfd_link_hash_indirect
1170 || hh
->eh
.root
.type
== bfd_link_hash_warning
)
1171 hh
= hppa_elf_hash_entry (hh
->eh
.root
.u
.i
.link
);
1173 /* PR15323, ref flags aren't set for references in the same
1175 hh
->eh
.root
.non_ir_ref
= 1;
1178 r_type
= ELF32_R_TYPE (rela
->r_info
);
1179 r_type
= elf32_hppa_optimized_tls_reloc (info
, r_type
, hh
== NULL
);
1183 case R_PARISC_DLTIND14F
:
1184 case R_PARISC_DLTIND14R
:
1185 case R_PARISC_DLTIND21L
:
1186 /* This symbol requires a global offset table entry. */
1187 need_entry
= NEED_GOT
;
1190 case R_PARISC_PLABEL14R
: /* "Official" procedure labels. */
1191 case R_PARISC_PLABEL21L
:
1192 case R_PARISC_PLABEL32
:
1193 /* If the addend is non-zero, we break badly. */
1194 if (rela
->r_addend
!= 0)
1197 /* If we are creating a shared library, then we need to
1198 create a PLT entry for all PLABELs, because PLABELs with
1199 local symbols may be passed via a pointer to another
1200 object. Additionally, output a dynamic relocation
1201 pointing to the PLT entry.
1203 For executables, the original 32-bit ABI allowed two
1204 different styles of PLABELs (function pointers): For
1205 global functions, the PLABEL word points into the .plt
1206 two bytes past a (function address, gp) pair, and for
1207 local functions the PLABEL points directly at the
1208 function. The magic +2 for the first type allows us to
1209 differentiate between the two. As you can imagine, this
1210 is a real pain when it comes to generating code to call
1211 functions indirectly or to compare function pointers.
1212 We avoid the mess by always pointing a PLABEL into the
1213 .plt, even for local functions. */
1214 need_entry
= PLT_PLABEL
| NEED_PLT
| NEED_DYNREL
;
1217 case R_PARISC_PCREL12F
:
1218 htab
->has_12bit_branch
= 1;
1221 case R_PARISC_PCREL17C
:
1222 case R_PARISC_PCREL17F
:
1223 htab
->has_17bit_branch
= 1;
1226 case R_PARISC_PCREL22F
:
1227 htab
->has_22bit_branch
= 1;
1229 /* Function calls might need to go through the .plt, and
1230 might require long branch stubs. */
1233 /* We know local syms won't need a .plt entry, and if
1234 they need a long branch stub we can't guarantee that
1235 we can reach the stub. So just flag an error later
1236 if we're doing a shared link and find we need a long
1242 /* Global symbols will need a .plt entry if they remain
1243 global, and in most cases won't need a long branch
1244 stub. Unfortunately, we have to cater for the case
1245 where a symbol is forced local by versioning, or due
1246 to symbolic linking, and we lose the .plt entry. */
1247 need_entry
= NEED_PLT
;
1248 if (hh
->eh
.type
== STT_PARISC_MILLI
)
1253 case R_PARISC_SEGBASE
: /* Used to set segment base. */
1254 case R_PARISC_SEGREL32
: /* Relative reloc, used for unwind. */
1255 case R_PARISC_PCREL14F
: /* PC relative load/store. */
1256 case R_PARISC_PCREL14R
:
1257 case R_PARISC_PCREL17R
: /* External branches. */
1258 case R_PARISC_PCREL21L
: /* As above, and for load/store too. */
1259 case R_PARISC_PCREL32
:
1260 /* We don't need to propagate the relocation if linking a
1261 shared object since these are section relative. */
1264 case R_PARISC_DPREL14F
: /* Used for gp rel data load/store. */
1265 case R_PARISC_DPREL14R
:
1266 case R_PARISC_DPREL21L
:
1269 (*_bfd_error_handler
)
1270 (_("%B: relocation %s can not be used when making a shared object; recompile with -fPIC"),
1272 elf_hppa_howto_table
[r_type
].name
);
1273 bfd_set_error (bfd_error_bad_value
);
1278 case R_PARISC_DIR17F
: /* Used for external branches. */
1279 case R_PARISC_DIR17R
:
1280 case R_PARISC_DIR14F
: /* Used for load/store from absolute locn. */
1281 case R_PARISC_DIR14R
:
1282 case R_PARISC_DIR21L
: /* As above, and for ext branches too. */
1283 case R_PARISC_DIR32
: /* .word relocs. */
1284 /* We may want to output a dynamic relocation later. */
1285 need_entry
= NEED_DYNREL
;
1288 /* This relocation describes the C++ object vtable hierarchy.
1289 Reconstruct it for later use during GC. */
1290 case R_PARISC_GNU_VTINHERIT
:
1291 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, &hh
->eh
, rela
->r_offset
))
1295 /* This relocation describes which C++ vtable entries are actually
1296 used. Record for later use during GC. */
1297 case R_PARISC_GNU_VTENTRY
:
1298 BFD_ASSERT (hh
!= NULL
);
1300 && !bfd_elf_gc_record_vtentry (abfd
, sec
, &hh
->eh
, rela
->r_addend
))
1304 case R_PARISC_TLS_GD21L
:
1305 case R_PARISC_TLS_GD14R
:
1306 case R_PARISC_TLS_LDM21L
:
1307 case R_PARISC_TLS_LDM14R
:
1308 need_entry
= NEED_GOT
;
1311 case R_PARISC_TLS_IE21L
:
1312 case R_PARISC_TLS_IE14R
:
1314 info
->flags
|= DF_STATIC_TLS
;
1315 need_entry
= NEED_GOT
;
1322 /* Now carry out our orders. */
1323 if (need_entry
& NEED_GOT
)
1328 tls_type
= GOT_NORMAL
;
1330 case R_PARISC_TLS_GD21L
:
1331 case R_PARISC_TLS_GD14R
:
1332 tls_type
|= GOT_TLS_GD
;
1334 case R_PARISC_TLS_LDM21L
:
1335 case R_PARISC_TLS_LDM14R
:
1336 tls_type
|= GOT_TLS_LDM
;
1338 case R_PARISC_TLS_IE21L
:
1339 case R_PARISC_TLS_IE14R
:
1340 tls_type
|= GOT_TLS_IE
;
1344 /* Allocate space for a GOT entry, as well as a dynamic
1345 relocation for this entry. */
1346 if (htab
->sgot
== NULL
)
1348 if (htab
->etab
.dynobj
== NULL
)
1349 htab
->etab
.dynobj
= abfd
;
1350 if (!elf32_hppa_create_dynamic_sections (htab
->etab
.dynobj
, info
))
1354 if (r_type
== R_PARISC_TLS_LDM21L
1355 || r_type
== R_PARISC_TLS_LDM14R
)
1356 htab
->tls_ldm_got
.refcount
+= 1;
1361 hh
->eh
.got
.refcount
+= 1;
1362 old_tls_type
= hh
->tls_type
;
1366 bfd_signed_vma
*local_got_refcounts
;
1368 /* This is a global offset table entry for a local symbol. */
1369 local_got_refcounts
= hppa32_elf_local_refcounts (abfd
);
1370 if (local_got_refcounts
== NULL
)
1372 local_got_refcounts
[r_symndx
] += 1;
1374 old_tls_type
= hppa_elf_local_got_tls_type (abfd
) [r_symndx
];
1377 tls_type
|= old_tls_type
;
1379 if (old_tls_type
!= tls_type
)
1382 hh
->tls_type
= tls_type
;
1384 hppa_elf_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1390 if (need_entry
& NEED_PLT
)
1392 /* If we are creating a shared library, and this is a reloc
1393 against a weak symbol or a global symbol in a dynamic
1394 object, then we will be creating an import stub and a
1395 .plt entry for the symbol. Similarly, on a normal link
1396 to symbols defined in a dynamic object we'll need the
1397 import stub and a .plt entry. We don't know yet whether
1398 the symbol is defined or not, so make an entry anyway and
1399 clean up later in adjust_dynamic_symbol. */
1400 if ((sec
->flags
& SEC_ALLOC
) != 0)
1404 hh
->eh
.needs_plt
= 1;
1405 hh
->eh
.plt
.refcount
+= 1;
1407 /* If this .plt entry is for a plabel, mark it so
1408 that adjust_dynamic_symbol will keep the entry
1409 even if it appears to be local. */
1410 if (need_entry
& PLT_PLABEL
)
1413 else if (need_entry
& PLT_PLABEL
)
1415 bfd_signed_vma
*local_got_refcounts
;
1416 bfd_signed_vma
*local_plt_refcounts
;
1418 local_got_refcounts
= hppa32_elf_local_refcounts (abfd
);
1419 if (local_got_refcounts
== NULL
)
1421 local_plt_refcounts
= (local_got_refcounts
1422 + symtab_hdr
->sh_info
);
1423 local_plt_refcounts
[r_symndx
] += 1;
1428 if (need_entry
& NEED_DYNREL
)
1430 /* Flag this symbol as having a non-got, non-plt reference
1431 so that we generate copy relocs if it turns out to be
1433 if (hh
!= NULL
&& !info
->shared
)
1434 hh
->eh
.non_got_ref
= 1;
1436 /* If we are creating a shared library then we need to copy
1437 the reloc into the shared library. However, if we are
1438 linking with -Bsymbolic, we need only copy absolute
1439 relocs or relocs against symbols that are not defined in
1440 an object we are including in the link. PC- or DP- or
1441 DLT-relative relocs against any local sym or global sym
1442 with DEF_REGULAR set, can be discarded. At this point we
1443 have not seen all the input files, so it is possible that
1444 DEF_REGULAR is not set now but will be set later (it is
1445 never cleared). We account for that possibility below by
1446 storing information in the dyn_relocs field of the
1449 A similar situation to the -Bsymbolic case occurs when
1450 creating shared libraries and symbol visibility changes
1451 render the symbol local.
1453 As it turns out, all the relocs we will be creating here
1454 are absolute, so we cannot remove them on -Bsymbolic
1455 links or visibility changes anyway. A STUB_REL reloc
1456 is absolute too, as in that case it is the reloc in the
1457 stub we will be creating, rather than copying the PCREL
1458 reloc in the branch.
1460 If on the other hand, we are creating an executable, we
1461 may need to keep relocations for symbols satisfied by a
1462 dynamic library if we manage to avoid copy relocs for the
1465 && (sec
->flags
& SEC_ALLOC
) != 0
1466 && (IS_ABSOLUTE_RELOC (r_type
)
1469 || hh
->eh
.root
.type
== bfd_link_hash_defweak
1470 || !hh
->eh
.def_regular
))))
1471 || (ELIMINATE_COPY_RELOCS
1473 && (sec
->flags
& SEC_ALLOC
) != 0
1475 && (hh
->eh
.root
.type
== bfd_link_hash_defweak
1476 || !hh
->eh
.def_regular
)))
1478 struct elf32_hppa_dyn_reloc_entry
*hdh_p
;
1479 struct elf32_hppa_dyn_reloc_entry
**hdh_head
;
1481 /* Create a reloc section in dynobj and make room for
1485 if (htab
->etab
.dynobj
== NULL
)
1486 htab
->etab
.dynobj
= abfd
;
1488 sreloc
= _bfd_elf_make_dynamic_reloc_section
1489 (sec
, htab
->etab
.dynobj
, 2, abfd
, /*rela?*/ TRUE
);
1493 bfd_set_error (bfd_error_bad_value
);
1498 /* If this is a global symbol, we count the number of
1499 relocations we need for this symbol. */
1502 hdh_head
= &hh
->dyn_relocs
;
1506 /* Track dynamic relocs needed for local syms too.
1507 We really need local syms available to do this
1511 Elf_Internal_Sym
*isym
;
1513 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1518 sr
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1522 vpp
= &elf_section_data (sr
)->local_dynrel
;
1523 hdh_head
= (struct elf32_hppa_dyn_reloc_entry
**) vpp
;
1527 if (hdh_p
== NULL
|| hdh_p
->sec
!= sec
)
1529 hdh_p
= bfd_alloc (htab
->etab
.dynobj
, sizeof *hdh_p
);
1532 hdh_p
->hdh_next
= *hdh_head
;
1536 #if RELATIVE_DYNRELOCS
1537 hdh_p
->relative_count
= 0;
1542 #if RELATIVE_DYNRELOCS
1543 if (!IS_ABSOLUTE_RELOC (rtype
))
1544 hdh_p
->relative_count
+= 1;
1553 /* Return the section that should be marked against garbage collection
1554 for a given relocation. */
1557 elf32_hppa_gc_mark_hook (asection
*sec
,
1558 struct bfd_link_info
*info
,
1559 Elf_Internal_Rela
*rela
,
1560 struct elf_link_hash_entry
*hh
,
1561 Elf_Internal_Sym
*sym
)
1564 switch ((unsigned int) ELF32_R_TYPE (rela
->r_info
))
1566 case R_PARISC_GNU_VTINHERIT
:
1567 case R_PARISC_GNU_VTENTRY
:
1571 return _bfd_elf_gc_mark_hook (sec
, info
, rela
, hh
, sym
);
1574 /* Update the got and plt entry reference counts for the section being
1578 elf32_hppa_gc_sweep_hook (bfd
*abfd
,
1579 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1581 const Elf_Internal_Rela
*relocs
)
1583 Elf_Internal_Shdr
*symtab_hdr
;
1584 struct elf_link_hash_entry
**eh_syms
;
1585 bfd_signed_vma
*local_got_refcounts
;
1586 bfd_signed_vma
*local_plt_refcounts
;
1587 const Elf_Internal_Rela
*rela
, *relend
;
1588 struct elf32_hppa_link_hash_table
*htab
;
1590 if (info
->relocatable
)
1593 htab
= hppa_link_hash_table (info
);
1597 elf_section_data (sec
)->local_dynrel
= NULL
;
1599 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1600 eh_syms
= elf_sym_hashes (abfd
);
1601 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1602 local_plt_refcounts
= local_got_refcounts
;
1603 if (local_plt_refcounts
!= NULL
)
1604 local_plt_refcounts
+= symtab_hdr
->sh_info
;
1606 relend
= relocs
+ sec
->reloc_count
;
1607 for (rela
= relocs
; rela
< relend
; rela
++)
1609 unsigned long r_symndx
;
1610 unsigned int r_type
;
1611 struct elf_link_hash_entry
*eh
= NULL
;
1613 r_symndx
= ELF32_R_SYM (rela
->r_info
);
1614 if (r_symndx
>= symtab_hdr
->sh_info
)
1616 struct elf32_hppa_link_hash_entry
*hh
;
1617 struct elf32_hppa_dyn_reloc_entry
**hdh_pp
;
1618 struct elf32_hppa_dyn_reloc_entry
*hdh_p
;
1620 eh
= eh_syms
[r_symndx
- symtab_hdr
->sh_info
];
1621 while (eh
->root
.type
== bfd_link_hash_indirect
1622 || eh
->root
.type
== bfd_link_hash_warning
)
1623 eh
= (struct elf_link_hash_entry
*) eh
->root
.u
.i
.link
;
1624 hh
= hppa_elf_hash_entry (eh
);
1626 for (hdh_pp
= &hh
->dyn_relocs
; (hdh_p
= *hdh_pp
) != NULL
; hdh_pp
= &hdh_p
->hdh_next
)
1627 if (hdh_p
->sec
== sec
)
1629 /* Everything must go for SEC. */
1630 *hdh_pp
= hdh_p
->hdh_next
;
1635 r_type
= ELF32_R_TYPE (rela
->r_info
);
1636 r_type
= elf32_hppa_optimized_tls_reloc (info
, r_type
, eh
!= NULL
);
1640 case R_PARISC_DLTIND14F
:
1641 case R_PARISC_DLTIND14R
:
1642 case R_PARISC_DLTIND21L
:
1643 case R_PARISC_TLS_GD21L
:
1644 case R_PARISC_TLS_GD14R
:
1645 case R_PARISC_TLS_IE21L
:
1646 case R_PARISC_TLS_IE14R
:
1649 if (eh
->got
.refcount
> 0)
1650 eh
->got
.refcount
-= 1;
1652 else if (local_got_refcounts
!= NULL
)
1654 if (local_got_refcounts
[r_symndx
] > 0)
1655 local_got_refcounts
[r_symndx
] -= 1;
1659 case R_PARISC_TLS_LDM21L
:
1660 case R_PARISC_TLS_LDM14R
:
1661 htab
->tls_ldm_got
.refcount
-= 1;
1664 case R_PARISC_PCREL12F
:
1665 case R_PARISC_PCREL17C
:
1666 case R_PARISC_PCREL17F
:
1667 case R_PARISC_PCREL22F
:
1670 if (eh
->plt
.refcount
> 0)
1671 eh
->plt
.refcount
-= 1;
1675 case R_PARISC_PLABEL14R
:
1676 case R_PARISC_PLABEL21L
:
1677 case R_PARISC_PLABEL32
:
1680 if (eh
->plt
.refcount
> 0)
1681 eh
->plt
.refcount
-= 1;
1683 else if (local_plt_refcounts
!= NULL
)
1685 if (local_plt_refcounts
[r_symndx
] > 0)
1686 local_plt_refcounts
[r_symndx
] -= 1;
1698 /* Support for core dump NOTE sections. */
1701 elf32_hppa_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
1706 switch (note
->descsz
)
1711 case 396: /* Linux/hppa */
1713 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
1716 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
1725 /* Make a ".reg/999" section. */
1726 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
1727 size
, note
->descpos
+ offset
);
1731 elf32_hppa_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
1733 switch (note
->descsz
)
1738 case 124: /* Linux/hppa elf_prpsinfo. */
1739 elf_tdata (abfd
)->core
->program
1740 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
1741 elf_tdata (abfd
)->core
->command
1742 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
1745 /* Note that for some reason, a spurious space is tacked
1746 onto the end of the args in some (at least one anyway)
1747 implementations, so strip it off if it exists. */
1749 char *command
= elf_tdata (abfd
)->core
->command
;
1750 int n
= strlen (command
);
1752 if (0 < n
&& command
[n
- 1] == ' ')
1753 command
[n
- 1] = '\0';
1759 /* Our own version of hide_symbol, so that we can keep plt entries for
1763 elf32_hppa_hide_symbol (struct bfd_link_info
*info
,
1764 struct elf_link_hash_entry
*eh
,
1765 bfd_boolean force_local
)
1769 eh
->forced_local
= 1;
1770 if (eh
->dynindx
!= -1)
1773 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1778 /* STT_GNU_IFUNC symbol must go through PLT. */
1779 if (! hppa_elf_hash_entry (eh
)->plabel
1780 && eh
->type
!= STT_GNU_IFUNC
)
1783 eh
->plt
= elf_hash_table (info
)->init_plt_offset
;
1787 /* Adjust a symbol defined by a dynamic object and referenced by a
1788 regular object. The current definition is in some section of the
1789 dynamic object, but we're not including those sections. We have to
1790 change the definition to something the rest of the link can
1794 elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1795 struct elf_link_hash_entry
*eh
)
1797 struct elf32_hppa_link_hash_table
*htab
;
1800 /* If this is a function, put it in the procedure linkage table. We
1801 will fill in the contents of the procedure linkage table later. */
1802 if (eh
->type
== STT_FUNC
1805 /* If the symbol is used by a plabel, we must allocate a PLT slot.
1806 The refcounts are not reliable when it has been hidden since
1807 hide_symbol can be called before the plabel flag is set. */
1808 if (hppa_elf_hash_entry (eh
)->plabel
1809 && eh
->plt
.refcount
<= 0)
1810 eh
->plt
.refcount
= 1;
1812 if (eh
->plt
.refcount
<= 0
1814 && eh
->root
.type
!= bfd_link_hash_defweak
1815 && ! hppa_elf_hash_entry (eh
)->plabel
1816 && (!info
->shared
|| info
->symbolic
)))
1818 /* The .plt entry is not needed when:
1819 a) Garbage collection has removed all references to the
1821 b) We know for certain the symbol is defined in this
1822 object, and it's not a weak definition, nor is the symbol
1823 used by a plabel relocation. Either this object is the
1824 application or we are doing a shared symbolic link. */
1826 eh
->plt
.offset
= (bfd_vma
) -1;
1833 eh
->plt
.offset
= (bfd_vma
) -1;
1835 /* If this is a weak symbol, and there is a real definition, the
1836 processor independent code will have arranged for us to see the
1837 real definition first, and we can just use the same value. */
1838 if (eh
->u
.weakdef
!= NULL
)
1840 if (eh
->u
.weakdef
->root
.type
!= bfd_link_hash_defined
1841 && eh
->u
.weakdef
->root
.type
!= bfd_link_hash_defweak
)
1843 eh
->root
.u
.def
.section
= eh
->u
.weakdef
->root
.u
.def
.section
;
1844 eh
->root
.u
.def
.value
= eh
->u
.weakdef
->root
.u
.def
.value
;
1845 if (ELIMINATE_COPY_RELOCS
)
1846 eh
->non_got_ref
= eh
->u
.weakdef
->non_got_ref
;
1850 /* This is a reference to a symbol defined by a dynamic object which
1851 is not a function. */
1853 /* If we are creating a shared library, we must presume that the
1854 only references to the symbol are via the global offset table.
1855 For such cases we need not do anything here; the relocations will
1856 be handled correctly by relocate_section. */
1860 /* If there are no references to this symbol that do not use the
1861 GOT, we don't need to generate a copy reloc. */
1862 if (!eh
->non_got_ref
)
1865 if (ELIMINATE_COPY_RELOCS
)
1867 struct elf32_hppa_link_hash_entry
*hh
;
1868 struct elf32_hppa_dyn_reloc_entry
*hdh_p
;
1870 hh
= hppa_elf_hash_entry (eh
);
1871 for (hdh_p
= hh
->dyn_relocs
; hdh_p
!= NULL
; hdh_p
= hdh_p
->hdh_next
)
1873 sec
= hdh_p
->sec
->output_section
;
1874 if (sec
!= NULL
&& (sec
->flags
& SEC_READONLY
) != 0)
1878 /* If we didn't find any dynamic relocs in read-only sections, then
1879 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1882 eh
->non_got_ref
= 0;
1887 /* We must allocate the symbol in our .dynbss section, which will
1888 become part of the .bss section of the executable. There will be
1889 an entry for this symbol in the .dynsym section. The dynamic
1890 object will contain position independent code, so all references
1891 from the dynamic object to this symbol will go through the global
1892 offset table. The dynamic linker will use the .dynsym entry to
1893 determine the address it must put in the global offset table, so
1894 both the dynamic object and the regular object will refer to the
1895 same memory location for the variable. */
1897 htab
= hppa_link_hash_table (info
);
1901 /* We must generate a COPY reloc to tell the dynamic linker to
1902 copy the initial value out of the dynamic object and into the
1903 runtime process image. */
1904 if ((eh
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && eh
->size
!= 0)
1906 htab
->srelbss
->size
+= sizeof (Elf32_External_Rela
);
1910 sec
= htab
->sdynbss
;
1912 return _bfd_elf_adjust_dynamic_copy (eh
, sec
);
1915 /* Allocate space in the .plt for entries that won't have relocations.
1916 ie. plabel entries. */
1919 allocate_plt_static (struct elf_link_hash_entry
*eh
, void *inf
)
1921 struct bfd_link_info
*info
;
1922 struct elf32_hppa_link_hash_table
*htab
;
1923 struct elf32_hppa_link_hash_entry
*hh
;
1926 if (eh
->root
.type
== bfd_link_hash_indirect
)
1929 info
= (struct bfd_link_info
*) inf
;
1930 hh
= hppa_elf_hash_entry (eh
);
1931 htab
= hppa_link_hash_table (info
);
1935 if (htab
->etab
.dynamic_sections_created
1936 && eh
->plt
.refcount
> 0)
1938 /* Make sure this symbol is output as a dynamic symbol.
1939 Undefined weak syms won't yet be marked as dynamic. */
1940 if (eh
->dynindx
== -1
1941 && !eh
->forced_local
1942 && eh
->type
!= STT_PARISC_MILLI
)
1944 if (! bfd_elf_link_record_dynamic_symbol (info
, eh
))
1948 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
->shared
, eh
))
1950 /* Allocate these later. From this point on, h->plabel
1951 means that the plt entry is only used by a plabel.
1952 We'll be using a normal plt entry for this symbol, so
1953 clear the plabel indicator. */
1957 else if (hh
->plabel
)
1959 /* Make an entry in the .plt section for plabel references
1960 that won't have a .plt entry for other reasons. */
1962 eh
->plt
.offset
= sec
->size
;
1963 sec
->size
+= PLT_ENTRY_SIZE
;
1967 /* No .plt entry needed. */
1968 eh
->plt
.offset
= (bfd_vma
) -1;
1974 eh
->plt
.offset
= (bfd_vma
) -1;
1981 /* Allocate space in .plt, .got and associated reloc sections for
1985 allocate_dynrelocs (struct elf_link_hash_entry
*eh
, void *inf
)
1987 struct bfd_link_info
*info
;
1988 struct elf32_hppa_link_hash_table
*htab
;
1990 struct elf32_hppa_link_hash_entry
*hh
;
1991 struct elf32_hppa_dyn_reloc_entry
*hdh_p
;
1993 if (eh
->root
.type
== bfd_link_hash_indirect
)
1997 htab
= hppa_link_hash_table (info
);
2001 hh
= hppa_elf_hash_entry (eh
);
2003 if (htab
->etab
.dynamic_sections_created
2004 && eh
->plt
.offset
!= (bfd_vma
) -1
2006 && eh
->plt
.refcount
> 0)
2008 /* Make an entry in the .plt section. */
2010 eh
->plt
.offset
= sec
->size
;
2011 sec
->size
+= PLT_ENTRY_SIZE
;
2013 /* We also need to make an entry in the .rela.plt section. */
2014 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
2015 htab
->need_plt_stub
= 1;
2018 if (eh
->got
.refcount
> 0)
2020 /* Make sure this symbol is output as a dynamic symbol.
2021 Undefined weak syms won't yet be marked as dynamic. */
2022 if (eh
->dynindx
== -1
2023 && !eh
->forced_local
2024 && eh
->type
!= STT_PARISC_MILLI
)
2026 if (! bfd_elf_link_record_dynamic_symbol (info
, eh
))
2031 eh
->got
.offset
= sec
->size
;
2032 sec
->size
+= GOT_ENTRY_SIZE
;
2033 /* R_PARISC_TLS_GD* needs two GOT entries */
2034 if ((hh
->tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
)) == (GOT_TLS_GD
| GOT_TLS_IE
))
2035 sec
->size
+= GOT_ENTRY_SIZE
* 2;
2036 else if ((hh
->tls_type
& GOT_TLS_GD
) == GOT_TLS_GD
)
2037 sec
->size
+= GOT_ENTRY_SIZE
;
2038 if (htab
->etab
.dynamic_sections_created
2040 || (eh
->dynindx
!= -1
2041 && !eh
->forced_local
)))
2043 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
2044 if ((hh
->tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
)) == (GOT_TLS_GD
| GOT_TLS_IE
))
2045 htab
->srelgot
->size
+= 2 * sizeof (Elf32_External_Rela
);
2046 else if ((hh
->tls_type
& GOT_TLS_GD
) == GOT_TLS_GD
)
2047 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
2051 eh
->got
.offset
= (bfd_vma
) -1;
2053 if (hh
->dyn_relocs
== NULL
)
2056 /* If this is a -Bsymbolic shared link, then we need to discard all
2057 space allocated for dynamic pc-relative relocs against symbols
2058 defined in a regular object. For the normal shared case, discard
2059 space for relocs that have become local due to symbol visibility
2063 #if RELATIVE_DYNRELOCS
2064 if (SYMBOL_CALLS_LOCAL (info
, eh
))
2066 struct elf32_hppa_dyn_reloc_entry
**hdh_pp
;
2068 for (hdh_pp
= &hh
->dyn_relocs
; (hdh_p
= *hdh_pp
) != NULL
; )
2070 hdh_p
->count
-= hdh_p
->relative_count
;
2071 hdh_p
->relative_count
= 0;
2072 if (hdh_p
->count
== 0)
2073 *hdh_pp
= hdh_p
->hdh_next
;
2075 hdh_pp
= &hdh_p
->hdh_next
;
2080 /* Also discard relocs on undefined weak syms with non-default
2082 if (hh
->dyn_relocs
!= NULL
2083 && eh
->root
.type
== bfd_link_hash_undefweak
)
2085 if (ELF_ST_VISIBILITY (eh
->other
) != STV_DEFAULT
)
2086 hh
->dyn_relocs
= NULL
;
2088 /* Make sure undefined weak symbols are output as a dynamic
2090 else if (eh
->dynindx
== -1
2091 && !eh
->forced_local
)
2093 if (! bfd_elf_link_record_dynamic_symbol (info
, eh
))
2100 /* For the non-shared case, discard space for relocs against
2101 symbols which turn out to need copy relocs or are not
2104 if (!eh
->non_got_ref
2105 && ((ELIMINATE_COPY_RELOCS
2107 && !eh
->def_regular
)
2108 || (htab
->etab
.dynamic_sections_created
2109 && (eh
->root
.type
== bfd_link_hash_undefweak
2110 || eh
->root
.type
== bfd_link_hash_undefined
))))
2112 /* Make sure this symbol is output as a dynamic symbol.
2113 Undefined weak syms won't yet be marked as dynamic. */
2114 if (eh
->dynindx
== -1
2115 && !eh
->forced_local
2116 && eh
->type
!= STT_PARISC_MILLI
)
2118 if (! bfd_elf_link_record_dynamic_symbol (info
, eh
))
2122 /* If that succeeded, we know we'll be keeping all the
2124 if (eh
->dynindx
!= -1)
2128 hh
->dyn_relocs
= NULL
;
2134 /* Finally, allocate space. */
2135 for (hdh_p
= hh
->dyn_relocs
; hdh_p
!= NULL
; hdh_p
= hdh_p
->hdh_next
)
2137 asection
*sreloc
= elf_section_data (hdh_p
->sec
)->sreloc
;
2138 sreloc
->size
+= hdh_p
->count
* sizeof (Elf32_External_Rela
);
2144 /* This function is called via elf_link_hash_traverse to force
2145 millicode symbols local so they do not end up as globals in the
2146 dynamic symbol table. We ought to be able to do this in
2147 adjust_dynamic_symbol, but our adjust_dynamic_symbol is not called
2148 for all dynamic symbols. Arguably, this is a bug in
2149 elf_adjust_dynamic_symbol. */
2152 clobber_millicode_symbols (struct elf_link_hash_entry
*eh
,
2153 struct bfd_link_info
*info
)
2155 if (eh
->type
== STT_PARISC_MILLI
2156 && !eh
->forced_local
)
2158 elf32_hppa_hide_symbol (info
, eh
, TRUE
);
2163 /* Find any dynamic relocs that apply to read-only sections. */
2166 readonly_dynrelocs (struct elf_link_hash_entry
*eh
, void *inf
)
2168 struct elf32_hppa_link_hash_entry
*hh
;
2169 struct elf32_hppa_dyn_reloc_entry
*hdh_p
;
2171 hh
= hppa_elf_hash_entry (eh
);
2172 for (hdh_p
= hh
->dyn_relocs
; hdh_p
!= NULL
; hdh_p
= hdh_p
->hdh_next
)
2174 asection
*sec
= hdh_p
->sec
->output_section
;
2176 if (sec
!= NULL
&& (sec
->flags
& SEC_READONLY
) != 0)
2178 struct bfd_link_info
*info
= inf
;
2180 info
->flags
|= DF_TEXTREL
;
2182 /* Not an error, just cut short the traversal. */
2189 /* Set the sizes of the dynamic sections. */
2192 elf32_hppa_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2193 struct bfd_link_info
*info
)
2195 struct elf32_hppa_link_hash_table
*htab
;
2201 htab
= hppa_link_hash_table (info
);
2205 dynobj
= htab
->etab
.dynobj
;
2209 if (htab
->etab
.dynamic_sections_created
)
2211 /* Set the contents of the .interp section to the interpreter. */
2212 if (info
->executable
)
2214 sec
= bfd_get_linker_section (dynobj
, ".interp");
2217 sec
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2218 sec
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2221 /* Force millicode symbols local. */
2222 elf_link_hash_traverse (&htab
->etab
,
2223 clobber_millicode_symbols
,
2227 /* Set up .got and .plt offsets for local syms, and space for local
2229 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2231 bfd_signed_vma
*local_got
;
2232 bfd_signed_vma
*end_local_got
;
2233 bfd_signed_vma
*local_plt
;
2234 bfd_signed_vma
*end_local_plt
;
2235 bfd_size_type locsymcount
;
2236 Elf_Internal_Shdr
*symtab_hdr
;
2238 char *local_tls_type
;
2240 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
2243 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2245 struct elf32_hppa_dyn_reloc_entry
*hdh_p
;
2247 for (hdh_p
= ((struct elf32_hppa_dyn_reloc_entry
*)
2248 elf_section_data (sec
)->local_dynrel
);
2250 hdh_p
= hdh_p
->hdh_next
)
2252 if (!bfd_is_abs_section (hdh_p
->sec
)
2253 && bfd_is_abs_section (hdh_p
->sec
->output_section
))
2255 /* Input section has been discarded, either because
2256 it is a copy of a linkonce section or due to
2257 linker script /DISCARD/, so we'll be discarding
2260 else if (hdh_p
->count
!= 0)
2262 srel
= elf_section_data (hdh_p
->sec
)->sreloc
;
2263 srel
->size
+= hdh_p
->count
* sizeof (Elf32_External_Rela
);
2264 if ((hdh_p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
2265 info
->flags
|= DF_TEXTREL
;
2270 local_got
= elf_local_got_refcounts (ibfd
);
2274 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2275 locsymcount
= symtab_hdr
->sh_info
;
2276 end_local_got
= local_got
+ locsymcount
;
2277 local_tls_type
= hppa_elf_local_got_tls_type (ibfd
);
2279 srel
= htab
->srelgot
;
2280 for (; local_got
< end_local_got
; ++local_got
)
2284 *local_got
= sec
->size
;
2285 sec
->size
+= GOT_ENTRY_SIZE
;
2286 if ((*local_tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
)) == (GOT_TLS_GD
| GOT_TLS_IE
))
2287 sec
->size
+= 2 * GOT_ENTRY_SIZE
;
2288 else if ((*local_tls_type
& GOT_TLS_GD
) == GOT_TLS_GD
)
2289 sec
->size
+= GOT_ENTRY_SIZE
;
2292 srel
->size
+= sizeof (Elf32_External_Rela
);
2293 if ((*local_tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
)) == (GOT_TLS_GD
| GOT_TLS_IE
))
2294 srel
->size
+= 2 * sizeof (Elf32_External_Rela
);
2295 else if ((*local_tls_type
& GOT_TLS_GD
) == GOT_TLS_GD
)
2296 srel
->size
+= sizeof (Elf32_External_Rela
);
2300 *local_got
= (bfd_vma
) -1;
2305 local_plt
= end_local_got
;
2306 end_local_plt
= local_plt
+ locsymcount
;
2307 if (! htab
->etab
.dynamic_sections_created
)
2309 /* Won't be used, but be safe. */
2310 for (; local_plt
< end_local_plt
; ++local_plt
)
2311 *local_plt
= (bfd_vma
) -1;
2316 srel
= htab
->srelplt
;
2317 for (; local_plt
< end_local_plt
; ++local_plt
)
2321 *local_plt
= sec
->size
;
2322 sec
->size
+= PLT_ENTRY_SIZE
;
2324 srel
->size
+= sizeof (Elf32_External_Rela
);
2327 *local_plt
= (bfd_vma
) -1;
2332 if (htab
->tls_ldm_got
.refcount
> 0)
2334 /* Allocate 2 got entries and 1 dynamic reloc for
2335 R_PARISC_TLS_DTPMOD32 relocs. */
2336 htab
->tls_ldm_got
.offset
= htab
->sgot
->size
;
2337 htab
->sgot
->size
+= (GOT_ENTRY_SIZE
* 2);
2338 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
2341 htab
->tls_ldm_got
.offset
= -1;
2343 /* Do all the .plt entries without relocs first. The dynamic linker
2344 uses the last .plt reloc to find the end of the .plt (and hence
2345 the start of the .got) for lazy linking. */
2346 elf_link_hash_traverse (&htab
->etab
, allocate_plt_static
, info
);
2348 /* Allocate global sym .plt and .got entries, and space for global
2349 sym dynamic relocs. */
2350 elf_link_hash_traverse (&htab
->etab
, allocate_dynrelocs
, info
);
2352 /* The check_relocs and adjust_dynamic_symbol entry points have
2353 determined the sizes of the various dynamic sections. Allocate
2356 for (sec
= dynobj
->sections
; sec
!= NULL
; sec
= sec
->next
)
2358 if ((sec
->flags
& SEC_LINKER_CREATED
) == 0)
2361 if (sec
== htab
->splt
)
2363 if (htab
->need_plt_stub
)
2365 /* Make space for the plt stub at the end of the .plt
2366 section. We want this stub right at the end, up
2367 against the .got section. */
2368 int gotalign
= bfd_section_alignment (dynobj
, htab
->sgot
);
2369 int pltalign
= bfd_section_alignment (dynobj
, sec
);
2372 if (gotalign
> pltalign
)
2373 bfd_set_section_alignment (dynobj
, sec
, gotalign
);
2374 mask
= ((bfd_size_type
) 1 << gotalign
) - 1;
2375 sec
->size
= (sec
->size
+ sizeof (plt_stub
) + mask
) & ~mask
;
2378 else if (sec
== htab
->sgot
2379 || sec
== htab
->sdynbss
)
2381 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, sec
), ".rela"))
2385 /* Remember whether there are any reloc sections other
2387 if (sec
!= htab
->srelplt
)
2390 /* We use the reloc_count field as a counter if we need
2391 to copy relocs into the output file. */
2392 sec
->reloc_count
= 0;
2397 /* It's not one of our sections, so don't allocate space. */
2403 /* If we don't need this section, strip it from the
2404 output file. This is mostly to handle .rela.bss and
2405 .rela.plt. We must create both sections in
2406 create_dynamic_sections, because they must be created
2407 before the linker maps input sections to output
2408 sections. The linker does that before
2409 adjust_dynamic_symbol is called, and it is that
2410 function which decides whether anything needs to go
2411 into these sections. */
2412 sec
->flags
|= SEC_EXCLUDE
;
2416 if ((sec
->flags
& SEC_HAS_CONTENTS
) == 0)
2419 /* Allocate memory for the section contents. Zero it, because
2420 we may not fill in all the reloc sections. */
2421 sec
->contents
= bfd_zalloc (dynobj
, sec
->size
);
2422 if (sec
->contents
== NULL
)
2426 if (htab
->etab
.dynamic_sections_created
)
2428 /* Like IA-64 and HPPA64, always create a DT_PLTGOT. It
2429 actually has nothing to do with the PLT, it is how we
2430 communicate the LTP value of a load module to the dynamic
2432 #define add_dynamic_entry(TAG, VAL) \
2433 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2435 if (!add_dynamic_entry (DT_PLTGOT
, 0))
2438 /* Add some entries to the .dynamic section. We fill in the
2439 values later, in elf32_hppa_finish_dynamic_sections, but we
2440 must add the entries now so that we get the correct size for
2441 the .dynamic section. The DT_DEBUG entry is filled in by the
2442 dynamic linker and used by the debugger. */
2443 if (info
->executable
)
2445 if (!add_dynamic_entry (DT_DEBUG
, 0))
2449 if (htab
->srelplt
->size
!= 0)
2451 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
2452 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
2453 || !add_dynamic_entry (DT_JMPREL
, 0))
2459 if (!add_dynamic_entry (DT_RELA
, 0)
2460 || !add_dynamic_entry (DT_RELASZ
, 0)
2461 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
2464 /* If any dynamic relocs apply to a read-only section,
2465 then we need a DT_TEXTREL entry. */
2466 if ((info
->flags
& DF_TEXTREL
) == 0)
2467 elf_link_hash_traverse (&htab
->etab
, readonly_dynrelocs
, info
);
2469 if ((info
->flags
& DF_TEXTREL
) != 0)
2471 if (!add_dynamic_entry (DT_TEXTREL
, 0))
2476 #undef add_dynamic_entry
2481 /* External entry points for sizing and building linker stubs. */
2483 /* Set up various things so that we can make a list of input sections
2484 for each output section included in the link. Returns -1 on error,
2485 0 when no stubs will be needed, and 1 on success. */
2488 elf32_hppa_setup_section_lists (bfd
*output_bfd
, struct bfd_link_info
*info
)
2491 unsigned int bfd_count
;
2492 int top_id
, top_index
;
2494 asection
**input_list
, **list
;
2496 struct elf32_hppa_link_hash_table
*htab
= hppa_link_hash_table (info
);
2501 /* Count the number of input BFDs and find the top input section id. */
2502 for (input_bfd
= info
->input_bfds
, bfd_count
= 0, top_id
= 0;
2504 input_bfd
= input_bfd
->link_next
)
2507 for (section
= input_bfd
->sections
;
2509 section
= section
->next
)
2511 if (top_id
< section
->id
)
2512 top_id
= section
->id
;
2515 htab
->bfd_count
= bfd_count
;
2517 amt
= sizeof (struct map_stub
) * (top_id
+ 1);
2518 htab
->stub_group
= bfd_zmalloc (amt
);
2519 if (htab
->stub_group
== NULL
)
2522 /* We can't use output_bfd->section_count here to find the top output
2523 section index as some sections may have been removed, and
2524 strip_excluded_output_sections doesn't renumber the indices. */
2525 for (section
= output_bfd
->sections
, top_index
= 0;
2527 section
= section
->next
)
2529 if (top_index
< section
->index
)
2530 top_index
= section
->index
;
2533 htab
->top_index
= top_index
;
2534 amt
= sizeof (asection
*) * (top_index
+ 1);
2535 input_list
= bfd_malloc (amt
);
2536 htab
->input_list
= input_list
;
2537 if (input_list
== NULL
)
2540 /* For sections we aren't interested in, mark their entries with a
2541 value we can check later. */
2542 list
= input_list
+ top_index
;
2544 *list
= bfd_abs_section_ptr
;
2545 while (list
-- != input_list
);
2547 for (section
= output_bfd
->sections
;
2549 section
= section
->next
)
2551 if ((section
->flags
& SEC_CODE
) != 0)
2552 input_list
[section
->index
] = NULL
;
2558 /* The linker repeatedly calls this function for each input section,
2559 in the order that input sections are linked into output sections.
2560 Build lists of input sections to determine groupings between which
2561 we may insert linker stubs. */
2564 elf32_hppa_next_input_section (struct bfd_link_info
*info
, asection
*isec
)
2566 struct elf32_hppa_link_hash_table
*htab
= hppa_link_hash_table (info
);
2571 if (isec
->output_section
->index
<= htab
->top_index
)
2573 asection
**list
= htab
->input_list
+ isec
->output_section
->index
;
2574 if (*list
!= bfd_abs_section_ptr
)
2576 /* Steal the link_sec pointer for our list. */
2577 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
2578 /* This happens to make the list in reverse order,
2579 which is what we want. */
2580 PREV_SEC (isec
) = *list
;
2586 /* See whether we can group stub sections together. Grouping stub
2587 sections may result in fewer stubs. More importantly, we need to
2588 put all .init* and .fini* stubs at the beginning of the .init or
2589 .fini output sections respectively, because glibc splits the
2590 _init and _fini functions into multiple parts. Putting a stub in
2591 the middle of a function is not a good idea. */
2594 group_sections (struct elf32_hppa_link_hash_table
*htab
,
2595 bfd_size_type stub_group_size
,
2596 bfd_boolean stubs_always_before_branch
)
2598 asection
**list
= htab
->input_list
+ htab
->top_index
;
2601 asection
*tail
= *list
;
2602 if (tail
== bfd_abs_section_ptr
)
2604 while (tail
!= NULL
)
2608 bfd_size_type total
;
2609 bfd_boolean big_sec
;
2613 big_sec
= total
>= stub_group_size
;
2615 while ((prev
= PREV_SEC (curr
)) != NULL
2616 && ((total
+= curr
->output_offset
- prev
->output_offset
)
2620 /* OK, the size from the start of CURR to the end is less
2621 than 240000 bytes and thus can be handled by one stub
2622 section. (or the tail section is itself larger than
2623 240000 bytes, in which case we may be toast.)
2624 We should really be keeping track of the total size of
2625 stubs added here, as stubs contribute to the final output
2626 section size. That's a little tricky, and this way will
2627 only break if stubs added total more than 22144 bytes, or
2628 2768 long branch stubs. It seems unlikely for more than
2629 2768 different functions to be called, especially from
2630 code only 240000 bytes long. This limit used to be
2631 250000, but c++ code tends to generate lots of little
2632 functions, and sometimes violated the assumption. */
2635 prev
= PREV_SEC (tail
);
2636 /* Set up this stub group. */
2637 htab
->stub_group
[tail
->id
].link_sec
= curr
;
2639 while (tail
!= curr
&& (tail
= prev
) != NULL
);
2641 /* But wait, there's more! Input sections up to 240000
2642 bytes before the stub section can be handled by it too.
2643 Don't do this if we have a really large section after the
2644 stubs, as adding more stubs increases the chance that
2645 branches may not reach into the stub section. */
2646 if (!stubs_always_before_branch
&& !big_sec
)
2650 && ((total
+= tail
->output_offset
- prev
->output_offset
)
2654 prev
= PREV_SEC (tail
);
2655 htab
->stub_group
[tail
->id
].link_sec
= curr
;
2661 while (list
-- != htab
->input_list
);
2662 free (htab
->input_list
);
2666 /* Read in all local syms for all input bfds, and create hash entries
2667 for export stubs if we are building a multi-subspace shared lib.
2668 Returns -1 on error, 1 if export stubs created, 0 otherwise. */
2671 get_local_syms (bfd
*output_bfd
, bfd
*input_bfd
, struct bfd_link_info
*info
)
2673 unsigned int bfd_indx
;
2674 Elf_Internal_Sym
*local_syms
, **all_local_syms
;
2675 int stub_changed
= 0;
2676 struct elf32_hppa_link_hash_table
*htab
= hppa_link_hash_table (info
);
2681 /* We want to read in symbol extension records only once. To do this
2682 we need to read in the local symbols in parallel and save them for
2683 later use; so hold pointers to the local symbols in an array. */
2684 bfd_size_type amt
= sizeof (Elf_Internal_Sym
*) * htab
->bfd_count
;
2685 all_local_syms
= bfd_zmalloc (amt
);
2686 htab
->all_local_syms
= all_local_syms
;
2687 if (all_local_syms
== NULL
)
2690 /* Walk over all the input BFDs, swapping in local symbols.
2691 If we are creating a shared library, create hash entries for the
2695 input_bfd
= input_bfd
->link_next
, bfd_indx
++)
2697 Elf_Internal_Shdr
*symtab_hdr
;
2699 /* We'll need the symbol table in a second. */
2700 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2701 if (symtab_hdr
->sh_info
== 0)
2704 /* We need an array of the local symbols attached to the input bfd. */
2705 local_syms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2706 if (local_syms
== NULL
)
2708 local_syms
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
2709 symtab_hdr
->sh_info
, 0,
2711 /* Cache them for elf_link_input_bfd. */
2712 symtab_hdr
->contents
= (unsigned char *) local_syms
;
2714 if (local_syms
== NULL
)
2717 all_local_syms
[bfd_indx
] = local_syms
;
2719 if (info
->shared
&& htab
->multi_subspace
)
2721 struct elf_link_hash_entry
**eh_syms
;
2722 struct elf_link_hash_entry
**eh_symend
;
2723 unsigned int symcount
;
2725 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
2726 - symtab_hdr
->sh_info
);
2727 eh_syms
= (struct elf_link_hash_entry
**) elf_sym_hashes (input_bfd
);
2728 eh_symend
= (struct elf_link_hash_entry
**) (eh_syms
+ symcount
);
2730 /* Look through the global syms for functions; We need to
2731 build export stubs for all globally visible functions. */
2732 for (; eh_syms
< eh_symend
; eh_syms
++)
2734 struct elf32_hppa_link_hash_entry
*hh
;
2736 hh
= hppa_elf_hash_entry (*eh_syms
);
2738 while (hh
->eh
.root
.type
== bfd_link_hash_indirect
2739 || hh
->eh
.root
.type
== bfd_link_hash_warning
)
2740 hh
= hppa_elf_hash_entry (hh
->eh
.root
.u
.i
.link
);
2742 /* At this point in the link, undefined syms have been
2743 resolved, so we need to check that the symbol was
2744 defined in this BFD. */
2745 if ((hh
->eh
.root
.type
== bfd_link_hash_defined
2746 || hh
->eh
.root
.type
== bfd_link_hash_defweak
)
2747 && hh
->eh
.type
== STT_FUNC
2748 && hh
->eh
.root
.u
.def
.section
->output_section
!= NULL
2749 && (hh
->eh
.root
.u
.def
.section
->output_section
->owner
2751 && hh
->eh
.root
.u
.def
.section
->owner
== input_bfd
2752 && hh
->eh
.def_regular
2753 && !hh
->eh
.forced_local
2754 && ELF_ST_VISIBILITY (hh
->eh
.other
) == STV_DEFAULT
)
2757 const char *stub_name
;
2758 struct elf32_hppa_stub_hash_entry
*hsh
;
2760 sec
= hh
->eh
.root
.u
.def
.section
;
2761 stub_name
= hh_name (hh
);
2762 hsh
= hppa_stub_hash_lookup (&htab
->bstab
,
2767 hsh
= hppa_add_stub (stub_name
, sec
, htab
);
2771 hsh
->target_value
= hh
->eh
.root
.u
.def
.value
;
2772 hsh
->target_section
= hh
->eh
.root
.u
.def
.section
;
2773 hsh
->stub_type
= hppa_stub_export
;
2779 (*_bfd_error_handler
) (_("%B: duplicate export stub %s"),
2788 return stub_changed
;
2791 /* Determine and set the size of the stub section for a final link.
2793 The basic idea here is to examine all the relocations looking for
2794 PC-relative calls to a target that is unreachable with a "bl"
2798 elf32_hppa_size_stubs
2799 (bfd
*output_bfd
, bfd
*stub_bfd
, struct bfd_link_info
*info
,
2800 bfd_boolean multi_subspace
, bfd_signed_vma group_size
,
2801 asection
* (*add_stub_section
) (const char *, asection
*),
2802 void (*layout_sections_again
) (void))
2804 bfd_size_type stub_group_size
;
2805 bfd_boolean stubs_always_before_branch
;
2806 bfd_boolean stub_changed
;
2807 struct elf32_hppa_link_hash_table
*htab
= hppa_link_hash_table (info
);
2812 /* Stash our params away. */
2813 htab
->stub_bfd
= stub_bfd
;
2814 htab
->multi_subspace
= multi_subspace
;
2815 htab
->add_stub_section
= add_stub_section
;
2816 htab
->layout_sections_again
= layout_sections_again
;
2817 stubs_always_before_branch
= group_size
< 0;
2819 stub_group_size
= -group_size
;
2821 stub_group_size
= group_size
;
2822 if (stub_group_size
== 1)
2824 /* Default values. */
2825 if (stubs_always_before_branch
)
2827 stub_group_size
= 7680000;
2828 if (htab
->has_17bit_branch
|| htab
->multi_subspace
)
2829 stub_group_size
= 240000;
2830 if (htab
->has_12bit_branch
)
2831 stub_group_size
= 7500;
2835 stub_group_size
= 6971392;
2836 if (htab
->has_17bit_branch
|| htab
->multi_subspace
)
2837 stub_group_size
= 217856;
2838 if (htab
->has_12bit_branch
)
2839 stub_group_size
= 6808;
2843 group_sections (htab
, stub_group_size
, stubs_always_before_branch
);
2845 switch (get_local_syms (output_bfd
, info
->input_bfds
, info
))
2848 if (htab
->all_local_syms
)
2849 goto error_ret_free_local
;
2853 stub_changed
= FALSE
;
2857 stub_changed
= TRUE
;
2864 unsigned int bfd_indx
;
2867 for (input_bfd
= info
->input_bfds
, bfd_indx
= 0;
2869 input_bfd
= input_bfd
->link_next
, bfd_indx
++)
2871 Elf_Internal_Shdr
*symtab_hdr
;
2873 Elf_Internal_Sym
*local_syms
;
2875 /* We'll need the symbol table in a second. */
2876 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2877 if (symtab_hdr
->sh_info
== 0)
2880 local_syms
= htab
->all_local_syms
[bfd_indx
];
2882 /* Walk over each section attached to the input bfd. */
2883 for (section
= input_bfd
->sections
;
2885 section
= section
->next
)
2887 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
2889 /* If there aren't any relocs, then there's nothing more
2891 if ((section
->flags
& SEC_RELOC
) == 0
2892 || section
->reloc_count
== 0)
2895 /* If this section is a link-once section that will be
2896 discarded, then don't create any stubs. */
2897 if (section
->output_section
== NULL
2898 || section
->output_section
->owner
!= output_bfd
)
2901 /* Get the relocs. */
2903 = _bfd_elf_link_read_relocs (input_bfd
, section
, NULL
, NULL
,
2905 if (internal_relocs
== NULL
)
2906 goto error_ret_free_local
;
2908 /* Now examine each relocation. */
2909 irela
= internal_relocs
;
2910 irelaend
= irela
+ section
->reloc_count
;
2911 for (; irela
< irelaend
; irela
++)
2913 unsigned int r_type
, r_indx
;
2914 enum elf32_hppa_stub_type stub_type
;
2915 struct elf32_hppa_stub_hash_entry
*hsh
;
2918 bfd_vma destination
;
2919 struct elf32_hppa_link_hash_entry
*hh
;
2921 const asection
*id_sec
;
2923 r_type
= ELF32_R_TYPE (irela
->r_info
);
2924 r_indx
= ELF32_R_SYM (irela
->r_info
);
2926 if (r_type
>= (unsigned int) R_PARISC_UNIMPLEMENTED
)
2928 bfd_set_error (bfd_error_bad_value
);
2929 error_ret_free_internal
:
2930 if (elf_section_data (section
)->relocs
== NULL
)
2931 free (internal_relocs
);
2932 goto error_ret_free_local
;
2935 /* Only look for stubs on call instructions. */
2936 if (r_type
!= (unsigned int) R_PARISC_PCREL12F
2937 && r_type
!= (unsigned int) R_PARISC_PCREL17F
2938 && r_type
!= (unsigned int) R_PARISC_PCREL22F
)
2941 /* Now determine the call target, its name, value,
2947 if (r_indx
< symtab_hdr
->sh_info
)
2949 /* It's a local symbol. */
2950 Elf_Internal_Sym
*sym
;
2951 Elf_Internal_Shdr
*hdr
;
2954 sym
= local_syms
+ r_indx
;
2955 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
2956 sym_value
= sym
->st_value
;
2957 shndx
= sym
->st_shndx
;
2958 if (shndx
< elf_numsections (input_bfd
))
2960 hdr
= elf_elfsections (input_bfd
)[shndx
];
2961 sym_sec
= hdr
->bfd_section
;
2962 destination
= (sym_value
+ irela
->r_addend
2963 + sym_sec
->output_offset
2964 + sym_sec
->output_section
->vma
);
2969 /* It's an external symbol. */
2972 e_indx
= r_indx
- symtab_hdr
->sh_info
;
2973 hh
= hppa_elf_hash_entry (elf_sym_hashes (input_bfd
)[e_indx
]);
2975 while (hh
->eh
.root
.type
== bfd_link_hash_indirect
2976 || hh
->eh
.root
.type
== bfd_link_hash_warning
)
2977 hh
= hppa_elf_hash_entry (hh
->eh
.root
.u
.i
.link
);
2979 if (hh
->eh
.root
.type
== bfd_link_hash_defined
2980 || hh
->eh
.root
.type
== bfd_link_hash_defweak
)
2982 sym_sec
= hh
->eh
.root
.u
.def
.section
;
2983 sym_value
= hh
->eh
.root
.u
.def
.value
;
2984 if (sym_sec
->output_section
!= NULL
)
2985 destination
= (sym_value
+ irela
->r_addend
2986 + sym_sec
->output_offset
2987 + sym_sec
->output_section
->vma
);
2989 else if (hh
->eh
.root
.type
== bfd_link_hash_undefweak
)
2994 else if (hh
->eh
.root
.type
== bfd_link_hash_undefined
)
2996 if (! (info
->unresolved_syms_in_objects
== RM_IGNORE
2997 && (ELF_ST_VISIBILITY (hh
->eh
.other
)
2999 && hh
->eh
.type
!= STT_PARISC_MILLI
))
3004 bfd_set_error (bfd_error_bad_value
);
3005 goto error_ret_free_internal
;
3009 /* Determine what (if any) linker stub is needed. */
3010 stub_type
= hppa_type_of_stub (section
, irela
, hh
,
3012 if (stub_type
== hppa_stub_none
)
3015 /* Support for grouping stub sections. */
3016 id_sec
= htab
->stub_group
[section
->id
].link_sec
;
3018 /* Get the name of this stub. */
3019 stub_name
= hppa_stub_name (id_sec
, sym_sec
, hh
, irela
);
3021 goto error_ret_free_internal
;
3023 hsh
= hppa_stub_hash_lookup (&htab
->bstab
,
3028 /* The proper stub has already been created. */
3033 hsh
= hppa_add_stub (stub_name
, section
, htab
);
3037 goto error_ret_free_internal
;
3040 hsh
->target_value
= sym_value
;
3041 hsh
->target_section
= sym_sec
;
3042 hsh
->stub_type
= stub_type
;
3045 if (stub_type
== hppa_stub_import
)
3046 hsh
->stub_type
= hppa_stub_import_shared
;
3047 else if (stub_type
== hppa_stub_long_branch
)
3048 hsh
->stub_type
= hppa_stub_long_branch_shared
;
3051 stub_changed
= TRUE
;
3054 /* We're done with the internal relocs, free them. */
3055 if (elf_section_data (section
)->relocs
== NULL
)
3056 free (internal_relocs
);
3063 /* OK, we've added some stubs. Find out the new size of the
3065 for (stub_sec
= htab
->stub_bfd
->sections
;
3067 stub_sec
= stub_sec
->next
)
3070 bfd_hash_traverse (&htab
->bstab
, hppa_size_one_stub
, htab
);
3072 /* Ask the linker to do its stuff. */
3073 (*htab
->layout_sections_again
) ();
3074 stub_changed
= FALSE
;
3077 free (htab
->all_local_syms
);
3080 error_ret_free_local
:
3081 free (htab
->all_local_syms
);
3085 /* For a final link, this function is called after we have sized the
3086 stubs to provide a value for __gp. */
3089 elf32_hppa_set_gp (bfd
*abfd
, struct bfd_link_info
*info
)
3091 struct bfd_link_hash_entry
*h
;
3092 asection
*sec
= NULL
;
3094 struct elf32_hppa_link_hash_table
*htab
;
3096 htab
= hppa_link_hash_table (info
);
3100 h
= bfd_link_hash_lookup (&htab
->etab
.root
, "$global$", FALSE
, FALSE
, FALSE
);
3103 && (h
->type
== bfd_link_hash_defined
3104 || h
->type
== bfd_link_hash_defweak
))
3106 gp_val
= h
->u
.def
.value
;
3107 sec
= h
->u
.def
.section
;
3111 asection
*splt
= bfd_get_section_by_name (abfd
, ".plt");
3112 asection
*sgot
= bfd_get_section_by_name (abfd
, ".got");
3114 /* Choose to point our LTP at, in this order, one of .plt, .got,
3115 or .data, if these sections exist. In the case of choosing
3116 .plt try to make the LTP ideal for addressing anywhere in the
3117 .plt or .got with a 14 bit signed offset. Typically, the end
3118 of the .plt is the start of the .got, so choose .plt + 0x2000
3119 if either the .plt or .got is larger than 0x2000. If both
3120 the .plt and .got are smaller than 0x2000, choose the end of
3121 the .plt section. */
3122 sec
= strcmp (bfd_get_target (abfd
), "elf32-hppa-netbsd") == 0
3127 if (gp_val
> 0x2000 || (sgot
&& sgot
->size
> 0x2000))
3137 if (strcmp (bfd_get_target (abfd
), "elf32-hppa-netbsd") != 0)
3139 /* We know we don't have a .plt. If .got is large,
3141 if (sec
->size
> 0x2000)
3147 /* No .plt or .got. Who cares what the LTP is? */
3148 sec
= bfd_get_section_by_name (abfd
, ".data");
3154 h
->type
= bfd_link_hash_defined
;
3155 h
->u
.def
.value
= gp_val
;
3157 h
->u
.def
.section
= sec
;
3159 h
->u
.def
.section
= bfd_abs_section_ptr
;
3163 if (sec
!= NULL
&& sec
->output_section
!= NULL
)
3164 gp_val
+= sec
->output_section
->vma
+ sec
->output_offset
;
3166 elf_gp (abfd
) = gp_val
;
3170 /* Build all the stubs associated with the current output file. The
3171 stubs are kept in a hash table attached to the main linker hash
3172 table. We also set up the .plt entries for statically linked PIC
3173 functions here. This function is called via hppaelf_finish in the
3177 elf32_hppa_build_stubs (struct bfd_link_info
*info
)
3180 struct bfd_hash_table
*table
;
3181 struct elf32_hppa_link_hash_table
*htab
;
3183 htab
= hppa_link_hash_table (info
);
3187 for (stub_sec
= htab
->stub_bfd
->sections
;
3189 stub_sec
= stub_sec
->next
)
3193 /* Allocate memory to hold the linker stubs. */
3194 size
= stub_sec
->size
;
3195 stub_sec
->contents
= bfd_zalloc (htab
->stub_bfd
, size
);
3196 if (stub_sec
->contents
== NULL
&& size
!= 0)
3201 /* Build the stubs as directed by the stub hash table. */
3202 table
= &htab
->bstab
;
3203 bfd_hash_traverse (table
, hppa_build_one_stub
, info
);
3208 /* Return the base vma address which should be subtracted from the real
3209 address when resolving a dtpoff relocation.
3210 This is PT_TLS segment p_vaddr. */
3213 dtpoff_base (struct bfd_link_info
*info
)
3215 /* If tls_sec is NULL, we should have signalled an error already. */
3216 if (elf_hash_table (info
)->tls_sec
== NULL
)
3218 return elf_hash_table (info
)->tls_sec
->vma
;
3221 /* Return the relocation value for R_PARISC_TLS_TPOFF*.. */
3224 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3226 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3228 /* If tls_sec is NULL, we should have signalled an error already. */
3229 if (htab
->tls_sec
== NULL
)
3231 /* hppa TLS ABI is variant I and static TLS block start just after
3232 tcbhead structure which has 2 pointer fields. */
3233 return (address
- htab
->tls_sec
->vma
3234 + align_power ((bfd_vma
) 8, htab
->tls_sec
->alignment_power
));
3237 /* Perform a final link. */
3240 elf32_hppa_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
3242 /* Invoke the regular ELF linker to do all the work. */
3243 if (!bfd_elf_final_link (abfd
, info
))
3246 /* If we're producing a final executable, sort the contents of the
3248 if (info
->relocatable
)
3251 return elf_hppa_sort_unwind (abfd
);
3254 /* Record the lowest address for the data and text segments. */
3257 hppa_record_segment_addr (bfd
*abfd
, asection
*section
, void *data
)
3259 struct elf32_hppa_link_hash_table
*htab
;
3261 htab
= (struct elf32_hppa_link_hash_table
*) data
;
3265 if ((section
->flags
& (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
3268 Elf_Internal_Phdr
*p
;
3270 p
= _bfd_elf_find_segment_containing_section (abfd
, section
->output_section
);
3271 BFD_ASSERT (p
!= NULL
);
3274 if ((section
->flags
& SEC_READONLY
) != 0)
3276 if (value
< htab
->text_segment_base
)
3277 htab
->text_segment_base
= value
;
3281 if (value
< htab
->data_segment_base
)
3282 htab
->data_segment_base
= value
;
3287 /* Perform a relocation as part of a final link. */
3289 static bfd_reloc_status_type
3290 final_link_relocate (asection
*input_section
,
3292 const Elf_Internal_Rela
*rela
,
3294 struct elf32_hppa_link_hash_table
*htab
,
3296 struct elf32_hppa_link_hash_entry
*hh
,
3297 struct bfd_link_info
*info
)
3300 unsigned int r_type
= ELF32_R_TYPE (rela
->r_info
);
3301 unsigned int orig_r_type
= r_type
;
3302 reloc_howto_type
*howto
= elf_hppa_howto_table
+ r_type
;
3303 int r_format
= howto
->bitsize
;
3304 enum hppa_reloc_field_selector_type_alt r_field
;
3305 bfd
*input_bfd
= input_section
->owner
;
3306 bfd_vma offset
= rela
->r_offset
;
3307 bfd_vma max_branch_offset
= 0;
3308 bfd_byte
*hit_data
= contents
+ offset
;
3309 bfd_signed_vma addend
= rela
->r_addend
;
3311 struct elf32_hppa_stub_hash_entry
*hsh
= NULL
;
3314 if (r_type
== R_PARISC_NONE
)
3315 return bfd_reloc_ok
;
3317 insn
= bfd_get_32 (input_bfd
, hit_data
);
3319 /* Find out where we are and where we're going. */
3320 location
= (offset
+
3321 input_section
->output_offset
+
3322 input_section
->output_section
->vma
);
3324 /* If we are not building a shared library, convert DLTIND relocs to
3330 case R_PARISC_DLTIND21L
:
3331 case R_PARISC_TLS_GD21L
:
3332 case R_PARISC_TLS_LDM21L
:
3333 case R_PARISC_TLS_IE21L
:
3334 r_type
= R_PARISC_DPREL21L
;
3337 case R_PARISC_DLTIND14R
:
3338 case R_PARISC_TLS_GD14R
:
3339 case R_PARISC_TLS_LDM14R
:
3340 case R_PARISC_TLS_IE14R
:
3341 r_type
= R_PARISC_DPREL14R
;
3344 case R_PARISC_DLTIND14F
:
3345 r_type
= R_PARISC_DPREL14F
;
3352 case R_PARISC_PCREL12F
:
3353 case R_PARISC_PCREL17F
:
3354 case R_PARISC_PCREL22F
:
3355 /* If this call should go via the plt, find the import stub in
3358 || sym_sec
->output_section
== NULL
3360 && hh
->eh
.plt
.offset
!= (bfd_vma
) -1
3361 && hh
->eh
.dynindx
!= -1
3364 || !hh
->eh
.def_regular
3365 || hh
->eh
.root
.type
== bfd_link_hash_defweak
)))
3367 hsh
= hppa_get_stub_entry (input_section
, sym_sec
,
3371 value
= (hsh
->stub_offset
3372 + hsh
->stub_sec
->output_offset
3373 + hsh
->stub_sec
->output_section
->vma
);
3376 else if (sym_sec
== NULL
&& hh
!= NULL
3377 && hh
->eh
.root
.type
== bfd_link_hash_undefweak
)
3379 /* It's OK if undefined weak. Calls to undefined weak
3380 symbols behave as if the "called" function
3381 immediately returns. We can thus call to a weak
3382 function without first checking whether the function
3388 return bfd_reloc_undefined
;
3392 case R_PARISC_PCREL21L
:
3393 case R_PARISC_PCREL17C
:
3394 case R_PARISC_PCREL17R
:
3395 case R_PARISC_PCREL14R
:
3396 case R_PARISC_PCREL14F
:
3397 case R_PARISC_PCREL32
:
3398 /* Make it a pc relative offset. */
3403 case R_PARISC_DPREL21L
:
3404 case R_PARISC_DPREL14R
:
3405 case R_PARISC_DPREL14F
:
3406 /* Convert instructions that use the linkage table pointer (r19) to
3407 instructions that use the global data pointer (dp). This is the
3408 most efficient way of using PIC code in an incomplete executable,
3409 but the user must follow the standard runtime conventions for
3410 accessing data for this to work. */
3411 if (orig_r_type
!= r_type
)
3413 if (r_type
== R_PARISC_DPREL21L
)
3415 /* GCC sometimes uses a register other than r19 for the
3416 operation, so we must convert any addil instruction
3417 that uses this relocation. */
3418 if ((insn
& 0xfc000000) == ((int) OP_ADDIL
<< 26))
3421 /* We must have a ldil instruction. It's too hard to find
3422 and convert the associated add instruction, so issue an
3424 (*_bfd_error_handler
)
3425 (_("%B(%A+0x%lx): %s fixup for insn 0x%x is not supported in a non-shared link"),
3432 else if (r_type
== R_PARISC_DPREL14F
)
3434 /* This must be a format 1 load/store. Change the base
3436 insn
= (insn
& 0xfc1ffff) | (27 << 21);
3440 /* For all the DP relative relocations, we need to examine the symbol's
3441 section. If it has no section or if it's a code section, then
3442 "data pointer relative" makes no sense. In that case we don't
3443 adjust the "value", and for 21 bit addil instructions, we change the
3444 source addend register from %dp to %r0. This situation commonly
3445 arises for undefined weak symbols and when a variable's "constness"
3446 is declared differently from the way the variable is defined. For
3447 instance: "extern int foo" with foo defined as "const int foo". */
3448 if (sym_sec
== NULL
|| (sym_sec
->flags
& SEC_CODE
) != 0)
3450 if ((insn
& ((0x3f << 26) | (0x1f << 21)))
3451 == (((int) OP_ADDIL
<< 26) | (27 << 21)))
3453 insn
&= ~ (0x1f << 21);
3455 /* Now try to make things easy for the dynamic linker. */
3461 case R_PARISC_DLTIND21L
:
3462 case R_PARISC_DLTIND14R
:
3463 case R_PARISC_DLTIND14F
:
3464 case R_PARISC_TLS_GD21L
:
3465 case R_PARISC_TLS_LDM21L
:
3466 case R_PARISC_TLS_IE21L
:
3467 case R_PARISC_TLS_GD14R
:
3468 case R_PARISC_TLS_LDM14R
:
3469 case R_PARISC_TLS_IE14R
:
3470 value
-= elf_gp (input_section
->output_section
->owner
);
3473 case R_PARISC_SEGREL32
:
3474 if ((sym_sec
->flags
& SEC_CODE
) != 0)
3475 value
-= htab
->text_segment_base
;
3477 value
-= htab
->data_segment_base
;
3486 case R_PARISC_DIR32
:
3487 case R_PARISC_DIR14F
:
3488 case R_PARISC_DIR17F
:
3489 case R_PARISC_PCREL17C
:
3490 case R_PARISC_PCREL14F
:
3491 case R_PARISC_PCREL32
:
3492 case R_PARISC_DPREL14F
:
3493 case R_PARISC_PLABEL32
:
3494 case R_PARISC_DLTIND14F
:
3495 case R_PARISC_SEGBASE
:
3496 case R_PARISC_SEGREL32
:
3497 case R_PARISC_TLS_DTPMOD32
:
3498 case R_PARISC_TLS_DTPOFF32
:
3499 case R_PARISC_TLS_TPREL32
:
3503 case R_PARISC_DLTIND21L
:
3504 case R_PARISC_PCREL21L
:
3505 case R_PARISC_PLABEL21L
:
3509 case R_PARISC_DIR21L
:
3510 case R_PARISC_DPREL21L
:
3511 case R_PARISC_TLS_GD21L
:
3512 case R_PARISC_TLS_LDM21L
:
3513 case R_PARISC_TLS_LDO21L
:
3514 case R_PARISC_TLS_IE21L
:
3515 case R_PARISC_TLS_LE21L
:
3519 case R_PARISC_PCREL17R
:
3520 case R_PARISC_PCREL14R
:
3521 case R_PARISC_PLABEL14R
:
3522 case R_PARISC_DLTIND14R
:
3526 case R_PARISC_DIR17R
:
3527 case R_PARISC_DIR14R
:
3528 case R_PARISC_DPREL14R
:
3529 case R_PARISC_TLS_GD14R
:
3530 case R_PARISC_TLS_LDM14R
:
3531 case R_PARISC_TLS_LDO14R
:
3532 case R_PARISC_TLS_IE14R
:
3533 case R_PARISC_TLS_LE14R
:
3537 case R_PARISC_PCREL12F
:
3538 case R_PARISC_PCREL17F
:
3539 case R_PARISC_PCREL22F
:
3542 if (r_type
== (unsigned int) R_PARISC_PCREL17F
)
3544 max_branch_offset
= (1 << (17-1)) << 2;
3546 else if (r_type
== (unsigned int) R_PARISC_PCREL12F
)
3548 max_branch_offset
= (1 << (12-1)) << 2;
3552 max_branch_offset
= (1 << (22-1)) << 2;
3555 /* sym_sec is NULL on undefined weak syms or when shared on
3556 undefined syms. We've already checked for a stub for the
3557 shared undefined case. */
3558 if (sym_sec
== NULL
)
3561 /* If the branch is out of reach, then redirect the
3562 call to the local stub for this function. */
3563 if (value
+ addend
+ max_branch_offset
>= 2*max_branch_offset
)
3565 hsh
= hppa_get_stub_entry (input_section
, sym_sec
,
3568 return bfd_reloc_undefined
;
3570 /* Munge up the value and addend so that we call the stub
3571 rather than the procedure directly. */
3572 value
= (hsh
->stub_offset
3573 + hsh
->stub_sec
->output_offset
3574 + hsh
->stub_sec
->output_section
->vma
3580 /* Something we don't know how to handle. */
3582 return bfd_reloc_notsupported
;
3585 /* Make sure we can reach the stub. */
3586 if (max_branch_offset
!= 0
3587 && value
+ addend
+ max_branch_offset
>= 2*max_branch_offset
)
3589 (*_bfd_error_handler
)
3590 (_("%B(%A+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
3594 hsh
->bh_root
.string
);
3595 bfd_set_error (bfd_error_bad_value
);
3596 return bfd_reloc_notsupported
;
3599 val
= hppa_field_adjust (value
, addend
, r_field
);
3603 case R_PARISC_PCREL12F
:
3604 case R_PARISC_PCREL17C
:
3605 case R_PARISC_PCREL17F
:
3606 case R_PARISC_PCREL17R
:
3607 case R_PARISC_PCREL22F
:
3608 case R_PARISC_DIR17F
:
3609 case R_PARISC_DIR17R
:
3610 /* This is a branch. Divide the offset by four.
3611 Note that we need to decide whether it's a branch or
3612 otherwise by inspecting the reloc. Inspecting insn won't
3613 work as insn might be from a .word directive. */
3621 insn
= hppa_rebuild_insn (insn
, val
, r_format
);
3623 /* Update the instruction word. */
3624 bfd_put_32 (input_bfd
, (bfd_vma
) insn
, hit_data
);
3625 return bfd_reloc_ok
;
3628 /* Relocate an HPPA ELF section. */
3631 elf32_hppa_relocate_section (bfd
*output_bfd
,
3632 struct bfd_link_info
*info
,
3634 asection
*input_section
,
3636 Elf_Internal_Rela
*relocs
,
3637 Elf_Internal_Sym
*local_syms
,
3638 asection
**local_sections
)
3640 bfd_vma
*local_got_offsets
;
3641 struct elf32_hppa_link_hash_table
*htab
;
3642 Elf_Internal_Shdr
*symtab_hdr
;
3643 Elf_Internal_Rela
*rela
;
3644 Elf_Internal_Rela
*relend
;
3646 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3648 htab
= hppa_link_hash_table (info
);
3652 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3655 relend
= relocs
+ input_section
->reloc_count
;
3656 for (; rela
< relend
; rela
++)
3658 unsigned int r_type
;
3659 reloc_howto_type
*howto
;
3660 unsigned int r_symndx
;
3661 struct elf32_hppa_link_hash_entry
*hh
;
3662 Elf_Internal_Sym
*sym
;
3665 bfd_reloc_status_type rstatus
;
3666 const char *sym_name
;
3668 bfd_boolean warned_undef
;
3670 r_type
= ELF32_R_TYPE (rela
->r_info
);
3671 if (r_type
>= (unsigned int) R_PARISC_UNIMPLEMENTED
)
3673 bfd_set_error (bfd_error_bad_value
);
3676 if (r_type
== (unsigned int) R_PARISC_GNU_VTENTRY
3677 || r_type
== (unsigned int) R_PARISC_GNU_VTINHERIT
)
3680 r_symndx
= ELF32_R_SYM (rela
->r_info
);
3684 warned_undef
= FALSE
;
3685 if (r_symndx
< symtab_hdr
->sh_info
)
3687 /* This is a local symbol, h defaults to NULL. */
3688 sym
= local_syms
+ r_symndx
;
3689 sym_sec
= local_sections
[r_symndx
];
3690 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sym_sec
, rela
);
3694 struct elf_link_hash_entry
*eh
;
3695 bfd_boolean unresolved_reloc
;
3696 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
3698 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rela
,
3699 r_symndx
, symtab_hdr
, sym_hashes
,
3700 eh
, sym_sec
, relocation
,
3701 unresolved_reloc
, warned_undef
);
3703 if (!info
->relocatable
3705 && eh
->root
.type
!= bfd_link_hash_defined
3706 && eh
->root
.type
!= bfd_link_hash_defweak
3707 && eh
->root
.type
!= bfd_link_hash_undefweak
)
3709 if (info
->unresolved_syms_in_objects
== RM_IGNORE
3710 && ELF_ST_VISIBILITY (eh
->other
) == STV_DEFAULT
3711 && eh
->type
== STT_PARISC_MILLI
)
3713 if (! info
->callbacks
->undefined_symbol
3714 (info
, eh_name (eh
), input_bfd
,
3715 input_section
, rela
->r_offset
, FALSE
))
3717 warned_undef
= TRUE
;
3720 hh
= hppa_elf_hash_entry (eh
);
3723 if (sym_sec
!= NULL
&& discarded_section (sym_sec
))
3724 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3726 elf_hppa_howto_table
+ r_type
, 0,
3729 if (info
->relocatable
)
3732 /* Do any required modifications to the relocation value, and
3733 determine what types of dynamic info we need to output, if
3738 case R_PARISC_DLTIND14F
:
3739 case R_PARISC_DLTIND14R
:
3740 case R_PARISC_DLTIND21L
:
3743 bfd_boolean do_got
= 0;
3745 /* Relocation is to the entry for this symbol in the
3746 global offset table. */
3751 off
= hh
->eh
.got
.offset
;
3752 dyn
= htab
->etab
.dynamic_sections_created
;
3753 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
,
3756 /* If we aren't going to call finish_dynamic_symbol,
3757 then we need to handle initialisation of the .got
3758 entry and create needed relocs here. Since the
3759 offset must always be a multiple of 4, we use the
3760 least significant bit to record whether we have
3761 initialised it already. */
3766 hh
->eh
.got
.offset
|= 1;
3773 /* Local symbol case. */
3774 if (local_got_offsets
== NULL
)
3777 off
= local_got_offsets
[r_symndx
];
3779 /* The offset must always be a multiple of 4. We use
3780 the least significant bit to record whether we have
3781 already generated the necessary reloc. */
3786 local_got_offsets
[r_symndx
] |= 1;
3795 /* Output a dynamic relocation for this GOT entry.
3796 In this case it is relative to the base of the
3797 object because the symbol index is zero. */
3798 Elf_Internal_Rela outrel
;
3800 asection
*sec
= htab
->srelgot
;
3802 outrel
.r_offset
= (off
3803 + htab
->sgot
->output_offset
3804 + htab
->sgot
->output_section
->vma
);
3805 outrel
.r_info
= ELF32_R_INFO (0, R_PARISC_DIR32
);
3806 outrel
.r_addend
= relocation
;
3807 loc
= sec
->contents
;
3808 loc
+= sec
->reloc_count
++ * sizeof (Elf32_External_Rela
);
3809 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
3812 bfd_put_32 (output_bfd
, relocation
,
3813 htab
->sgot
->contents
+ off
);
3816 if (off
>= (bfd_vma
) -2)
3819 /* Add the base of the GOT to the relocation value. */
3821 + htab
->sgot
->output_offset
3822 + htab
->sgot
->output_section
->vma
);
3826 case R_PARISC_SEGREL32
:
3827 /* If this is the first SEGREL relocation, then initialize
3828 the segment base values. */
3829 if (htab
->text_segment_base
== (bfd_vma
) -1)
3830 bfd_map_over_sections (output_bfd
, hppa_record_segment_addr
, htab
);
3833 case R_PARISC_PLABEL14R
:
3834 case R_PARISC_PLABEL21L
:
3835 case R_PARISC_PLABEL32
:
3836 if (htab
->etab
.dynamic_sections_created
)
3839 bfd_boolean do_plt
= 0;
3840 /* If we have a global symbol with a PLT slot, then
3841 redirect this relocation to it. */
3844 off
= hh
->eh
.plt
.offset
;
3845 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
->shared
,
3848 /* In a non-shared link, adjust_dynamic_symbols
3849 isn't called for symbols forced local. We
3850 need to write out the plt entry here. */
3855 hh
->eh
.plt
.offset
|= 1;
3862 bfd_vma
*local_plt_offsets
;
3864 if (local_got_offsets
== NULL
)
3867 local_plt_offsets
= local_got_offsets
+ symtab_hdr
->sh_info
;
3868 off
= local_plt_offsets
[r_symndx
];
3870 /* As for the local .got entry case, we use the last
3871 bit to record whether we've already initialised
3872 this local .plt entry. */
3877 local_plt_offsets
[r_symndx
] |= 1;
3886 /* Output a dynamic IPLT relocation for this
3888 Elf_Internal_Rela outrel
;
3890 asection
*s
= htab
->srelplt
;
3892 outrel
.r_offset
= (off
3893 + htab
->splt
->output_offset
3894 + htab
->splt
->output_section
->vma
);
3895 outrel
.r_info
= ELF32_R_INFO (0, R_PARISC_IPLT
);
3896 outrel
.r_addend
= relocation
;
3898 loc
+= s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
3899 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
3903 bfd_put_32 (output_bfd
,
3905 htab
->splt
->contents
+ off
);
3906 bfd_put_32 (output_bfd
,
3907 elf_gp (htab
->splt
->output_section
->owner
),
3908 htab
->splt
->contents
+ off
+ 4);
3912 if (off
>= (bfd_vma
) -2)
3915 /* PLABELs contain function pointers. Relocation is to
3916 the entry for the function in the .plt. The magic +2
3917 offset signals to $$dyncall that the function pointer
3918 is in the .plt and thus has a gp pointer too.
3919 Exception: Undefined PLABELs should have a value of
3922 || (hh
->eh
.root
.type
!= bfd_link_hash_undefweak
3923 && hh
->eh
.root
.type
!= bfd_link_hash_undefined
))
3926 + htab
->splt
->output_offset
3927 + htab
->splt
->output_section
->vma
3932 /* Fall through and possibly emit a dynamic relocation. */
3934 case R_PARISC_DIR17F
:
3935 case R_PARISC_DIR17R
:
3936 case R_PARISC_DIR14F
:
3937 case R_PARISC_DIR14R
:
3938 case R_PARISC_DIR21L
:
3939 case R_PARISC_DPREL14F
:
3940 case R_PARISC_DPREL14R
:
3941 case R_PARISC_DPREL21L
:
3942 case R_PARISC_DIR32
:
3943 if ((input_section
->flags
& SEC_ALLOC
) == 0)
3946 /* The reloc types handled here and this conditional
3947 expression must match the code in ..check_relocs and
3948 allocate_dynrelocs. ie. We need exactly the same condition
3949 as in ..check_relocs, with some extra conditions (dynindx
3950 test in this case) to cater for relocs removed by
3951 allocate_dynrelocs. If you squint, the non-shared test
3952 here does indeed match the one in ..check_relocs, the
3953 difference being that here we test DEF_DYNAMIC as well as
3954 !DEF_REGULAR. All common syms end up with !DEF_REGULAR,
3955 which is why we can't use just that test here.
3956 Conversely, DEF_DYNAMIC can't be used in check_relocs as
3957 there all files have not been loaded. */
3960 || ELF_ST_VISIBILITY (hh
->eh
.other
) == STV_DEFAULT
3961 || hh
->eh
.root
.type
!= bfd_link_hash_undefweak
)
3962 && (IS_ABSOLUTE_RELOC (r_type
)
3963 || !SYMBOL_CALLS_LOCAL (info
, &hh
->eh
)))
3966 && hh
->eh
.dynindx
!= -1
3967 && !hh
->eh
.non_got_ref
3968 && ((ELIMINATE_COPY_RELOCS
3969 && hh
->eh
.def_dynamic
3970 && !hh
->eh
.def_regular
)
3971 || hh
->eh
.root
.type
== bfd_link_hash_undefweak
3972 || hh
->eh
.root
.type
== bfd_link_hash_undefined
)))
3974 Elf_Internal_Rela outrel
;
3979 /* When generating a shared object, these relocations
3980 are copied into the output file to be resolved at run
3983 outrel
.r_addend
= rela
->r_addend
;
3985 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3987 skip
= (outrel
.r_offset
== (bfd_vma
) -1
3988 || outrel
.r_offset
== (bfd_vma
) -2);
3989 outrel
.r_offset
+= (input_section
->output_offset
3990 + input_section
->output_section
->vma
);
3994 memset (&outrel
, 0, sizeof (outrel
));
3997 && hh
->eh
.dynindx
!= -1
3999 || !IS_ABSOLUTE_RELOC (r_type
)
4002 || !hh
->eh
.def_regular
))
4004 outrel
.r_info
= ELF32_R_INFO (hh
->eh
.dynindx
, r_type
);
4006 else /* It's a local symbol, or one marked to become local. */
4010 /* Add the absolute offset of the symbol. */
4011 outrel
.r_addend
+= relocation
;
4013 /* Global plabels need to be processed by the
4014 dynamic linker so that functions have at most one
4015 fptr. For this reason, we need to differentiate
4016 between global and local plabels, which we do by
4017 providing the function symbol for a global plabel
4018 reloc, and no symbol for local plabels. */
4021 && sym_sec
->output_section
!= NULL
4022 && ! bfd_is_abs_section (sym_sec
))
4026 osec
= sym_sec
->output_section
;
4027 indx
= elf_section_data (osec
)->dynindx
;
4030 osec
= htab
->etab
.text_index_section
;
4031 indx
= elf_section_data (osec
)->dynindx
;
4033 BFD_ASSERT (indx
!= 0);
4035 /* We are turning this relocation into one
4036 against a section symbol, so subtract out the
4037 output section's address but not the offset
4038 of the input section in the output section. */
4039 outrel
.r_addend
-= osec
->vma
;
4042 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
4044 sreloc
= elf_section_data (input_section
)->sreloc
;
4048 loc
= sreloc
->contents
;
4049 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4050 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4054 case R_PARISC_TLS_LDM21L
:
4055 case R_PARISC_TLS_LDM14R
:
4059 off
= htab
->tls_ldm_got
.offset
;
4064 Elf_Internal_Rela outrel
;
4067 outrel
.r_offset
= (off
4068 + htab
->sgot
->output_section
->vma
4069 + htab
->sgot
->output_offset
);
4070 outrel
.r_addend
= 0;
4071 outrel
.r_info
= ELF32_R_INFO (0, R_PARISC_TLS_DTPMOD32
);
4072 loc
= htab
->srelgot
->contents
;
4073 loc
+= htab
->srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4075 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4076 htab
->tls_ldm_got
.offset
|= 1;
4079 /* Add the base of the GOT to the relocation value. */
4081 + htab
->sgot
->output_offset
4082 + htab
->sgot
->output_section
->vma
);
4087 case R_PARISC_TLS_LDO21L
:
4088 case R_PARISC_TLS_LDO14R
:
4089 relocation
-= dtpoff_base (info
);
4092 case R_PARISC_TLS_GD21L
:
4093 case R_PARISC_TLS_GD14R
:
4094 case R_PARISC_TLS_IE21L
:
4095 case R_PARISC_TLS_IE14R
:
4105 dyn
= htab
->etab
.dynamic_sections_created
;
4107 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, &hh
->eh
)
4109 || !SYMBOL_REFERENCES_LOCAL (info
, &hh
->eh
)))
4111 indx
= hh
->eh
.dynindx
;
4113 off
= hh
->eh
.got
.offset
;
4114 tls_type
= hh
->tls_type
;
4118 off
= local_got_offsets
[r_symndx
];
4119 tls_type
= hppa_elf_local_got_tls_type (input_bfd
)[r_symndx
];
4122 if (tls_type
== GOT_UNKNOWN
)
4129 bfd_boolean need_relocs
= FALSE
;
4130 Elf_Internal_Rela outrel
;
4131 bfd_byte
*loc
= NULL
;
4134 /* The GOT entries have not been initialized yet. Do it
4135 now, and emit any relocations. If both an IE GOT and a
4136 GD GOT are necessary, we emit the GD first. */
4138 if ((info
->shared
|| indx
!= 0)
4140 || ELF_ST_VISIBILITY (hh
->eh
.other
) == STV_DEFAULT
4141 || hh
->eh
.root
.type
!= bfd_link_hash_undefweak
))
4144 loc
= htab
->srelgot
->contents
;
4145 /* FIXME (CAO): Should this be reloc_count++ ? */
4146 loc
+= htab
->srelgot
->reloc_count
* sizeof (Elf32_External_Rela
);
4149 if (tls_type
& GOT_TLS_GD
)
4153 outrel
.r_offset
= (cur_off
4154 + htab
->sgot
->output_section
->vma
4155 + htab
->sgot
->output_offset
);
4156 outrel
.r_info
= ELF32_R_INFO (indx
,R_PARISC_TLS_DTPMOD32
);
4157 outrel
.r_addend
= 0;
4158 bfd_put_32 (output_bfd
, 0, htab
->sgot
->contents
+ cur_off
);
4159 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4160 htab
->srelgot
->reloc_count
++;
4161 loc
+= sizeof (Elf32_External_Rela
);
4164 bfd_put_32 (output_bfd
, relocation
- dtpoff_base (info
),
4165 htab
->sgot
->contents
+ cur_off
+ 4);
4168 bfd_put_32 (output_bfd
, 0,
4169 htab
->sgot
->contents
+ cur_off
+ 4);
4170 outrel
.r_info
= ELF32_R_INFO (indx
, R_PARISC_TLS_DTPOFF32
);
4171 outrel
.r_offset
+= 4;
4172 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,loc
);
4173 htab
->srelgot
->reloc_count
++;
4174 loc
+= sizeof (Elf32_External_Rela
);
4179 /* If we are not emitting relocations for a
4180 general dynamic reference, then we must be in a
4181 static link or an executable link with the
4182 symbol binding locally. Mark it as belonging
4183 to module 1, the executable. */
4184 bfd_put_32 (output_bfd
, 1,
4185 htab
->sgot
->contents
+ cur_off
);
4186 bfd_put_32 (output_bfd
, relocation
- dtpoff_base (info
),
4187 htab
->sgot
->contents
+ cur_off
+ 4);
4194 if (tls_type
& GOT_TLS_IE
)
4198 outrel
.r_offset
= (cur_off
4199 + htab
->sgot
->output_section
->vma
4200 + htab
->sgot
->output_offset
);
4201 outrel
.r_info
= ELF32_R_INFO (indx
, R_PARISC_TLS_TPREL32
);
4204 outrel
.r_addend
= relocation
- dtpoff_base (info
);
4206 outrel
.r_addend
= 0;
4208 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4209 htab
->srelgot
->reloc_count
++;
4210 loc
+= sizeof (Elf32_External_Rela
);
4213 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
4214 htab
->sgot
->contents
+ cur_off
);
4220 hh
->eh
.got
.offset
|= 1;
4222 local_got_offsets
[r_symndx
] |= 1;
4225 if ((tls_type
& GOT_TLS_GD
)
4226 && r_type
!= R_PARISC_TLS_GD21L
4227 && r_type
!= R_PARISC_TLS_GD14R
)
4228 off
+= 2 * GOT_ENTRY_SIZE
;
4230 /* Add the base of the GOT to the relocation value. */
4232 + htab
->sgot
->output_offset
4233 + htab
->sgot
->output_section
->vma
);
4238 case R_PARISC_TLS_LE21L
:
4239 case R_PARISC_TLS_LE14R
:
4241 relocation
= tpoff (info
, relocation
);
4250 rstatus
= final_link_relocate (input_section
, contents
, rela
, relocation
,
4251 htab
, sym_sec
, hh
, info
);
4253 if (rstatus
== bfd_reloc_ok
)
4257 sym_name
= hh_name (hh
);
4260 sym_name
= bfd_elf_string_from_elf_section (input_bfd
,
4261 symtab_hdr
->sh_link
,
4263 if (sym_name
== NULL
)
4265 if (*sym_name
== '\0')
4266 sym_name
= bfd_section_name (input_bfd
, sym_sec
);
4269 howto
= elf_hppa_howto_table
+ r_type
;
4271 if (rstatus
== bfd_reloc_undefined
|| rstatus
== bfd_reloc_notsupported
)
4273 if (rstatus
== bfd_reloc_notsupported
|| !warned_undef
)
4275 (*_bfd_error_handler
)
4276 (_("%B(%A+0x%lx): cannot handle %s for %s"),
4279 (long) rela
->r_offset
,
4282 bfd_set_error (bfd_error_bad_value
);
4288 if (!((*info
->callbacks
->reloc_overflow
)
4289 (info
, (hh
? &hh
->eh
.root
: NULL
), sym_name
, howto
->name
,
4290 (bfd_vma
) 0, input_bfd
, input_section
, rela
->r_offset
)))
4298 /* Finish up dynamic symbol handling. We set the contents of various
4299 dynamic sections here. */
4302 elf32_hppa_finish_dynamic_symbol (bfd
*output_bfd
,
4303 struct bfd_link_info
*info
,
4304 struct elf_link_hash_entry
*eh
,
4305 Elf_Internal_Sym
*sym
)
4307 struct elf32_hppa_link_hash_table
*htab
;
4308 Elf_Internal_Rela rela
;
4311 htab
= hppa_link_hash_table (info
);
4315 if (eh
->plt
.offset
!= (bfd_vma
) -1)
4319 if (eh
->plt
.offset
& 1)
4322 /* This symbol has an entry in the procedure linkage table. Set
4325 The format of a plt entry is
4330 if (eh
->root
.type
== bfd_link_hash_defined
4331 || eh
->root
.type
== bfd_link_hash_defweak
)
4333 value
= eh
->root
.u
.def
.value
;
4334 if (eh
->root
.u
.def
.section
->output_section
!= NULL
)
4335 value
+= (eh
->root
.u
.def
.section
->output_offset
4336 + eh
->root
.u
.def
.section
->output_section
->vma
);
4339 /* Create a dynamic IPLT relocation for this entry. */
4340 rela
.r_offset
= (eh
->plt
.offset
4341 + htab
->splt
->output_offset
4342 + htab
->splt
->output_section
->vma
);
4343 if (eh
->dynindx
!= -1)
4345 rela
.r_info
= ELF32_R_INFO (eh
->dynindx
, R_PARISC_IPLT
);
4350 /* This symbol has been marked to become local, and is
4351 used by a plabel so must be kept in the .plt. */
4352 rela
.r_info
= ELF32_R_INFO (0, R_PARISC_IPLT
);
4353 rela
.r_addend
= value
;
4356 loc
= htab
->srelplt
->contents
;
4357 loc
+= htab
->srelplt
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4358 bfd_elf32_swap_reloca_out (htab
->splt
->output_section
->owner
, &rela
, loc
);
4360 if (!eh
->def_regular
)
4362 /* Mark the symbol as undefined, rather than as defined in
4363 the .plt section. Leave the value alone. */
4364 sym
->st_shndx
= SHN_UNDEF
;
4368 if (eh
->got
.offset
!= (bfd_vma
) -1
4369 && (hppa_elf_hash_entry (eh
)->tls_type
& GOT_TLS_GD
) == 0
4370 && (hppa_elf_hash_entry (eh
)->tls_type
& GOT_TLS_IE
) == 0)
4372 /* This symbol has an entry in the global offset table. Set it
4375 rela
.r_offset
= ((eh
->got
.offset
&~ (bfd_vma
) 1)
4376 + htab
->sgot
->output_offset
4377 + htab
->sgot
->output_section
->vma
);
4379 /* If this is a -Bsymbolic link and the symbol is defined
4380 locally or was forced to be local because of a version file,
4381 we just want to emit a RELATIVE reloc. The entry in the
4382 global offset table will already have been initialized in the
4383 relocate_section function. */
4385 && (info
->symbolic
|| eh
->dynindx
== -1)
4388 rela
.r_info
= ELF32_R_INFO (0, R_PARISC_DIR32
);
4389 rela
.r_addend
= (eh
->root
.u
.def
.value
4390 + eh
->root
.u
.def
.section
->output_offset
4391 + eh
->root
.u
.def
.section
->output_section
->vma
);
4395 if ((eh
->got
.offset
& 1) != 0)
4398 bfd_put_32 (output_bfd
, 0, htab
->sgot
->contents
+ (eh
->got
.offset
& ~1));
4399 rela
.r_info
= ELF32_R_INFO (eh
->dynindx
, R_PARISC_DIR32
);
4403 loc
= htab
->srelgot
->contents
;
4404 loc
+= htab
->srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4405 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
4412 /* This symbol needs a copy reloc. Set it up. */
4414 if (! (eh
->dynindx
!= -1
4415 && (eh
->root
.type
== bfd_link_hash_defined
4416 || eh
->root
.type
== bfd_link_hash_defweak
)))
4419 sec
= htab
->srelbss
;
4421 rela
.r_offset
= (eh
->root
.u
.def
.value
4422 + eh
->root
.u
.def
.section
->output_offset
4423 + eh
->root
.u
.def
.section
->output_section
->vma
);
4425 rela
.r_info
= ELF32_R_INFO (eh
->dynindx
, R_PARISC_COPY
);
4426 loc
= sec
->contents
+ sec
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4427 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
4430 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
4431 if (eh
== htab
->etab
.hdynamic
|| eh
== htab
->etab
.hgot
)
4433 sym
->st_shndx
= SHN_ABS
;
4439 /* Used to decide how to sort relocs in an optimal manner for the
4440 dynamic linker, before writing them out. */
4442 static enum elf_reloc_type_class
4443 elf32_hppa_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4444 const asection
*rel_sec ATTRIBUTE_UNUSED
,
4445 const Elf_Internal_Rela
*rela
)
4447 /* Handle TLS relocs first; we don't want them to be marked
4448 relative by the "if (ELF32_R_SYM (rela->r_info) == STN_UNDEF)"
4450 switch ((int) ELF32_R_TYPE (rela
->r_info
))
4452 case R_PARISC_TLS_DTPMOD32
:
4453 case R_PARISC_TLS_DTPOFF32
:
4454 case R_PARISC_TLS_TPREL32
:
4455 return reloc_class_normal
;
4458 if (ELF32_R_SYM (rela
->r_info
) == STN_UNDEF
)
4459 return reloc_class_relative
;
4461 switch ((int) ELF32_R_TYPE (rela
->r_info
))
4464 return reloc_class_plt
;
4466 return reloc_class_copy
;
4468 return reloc_class_normal
;
4472 /* Finish up the dynamic sections. */
4475 elf32_hppa_finish_dynamic_sections (bfd
*output_bfd
,
4476 struct bfd_link_info
*info
)
4479 struct elf32_hppa_link_hash_table
*htab
;
4483 htab
= hppa_link_hash_table (info
);
4487 dynobj
= htab
->etab
.dynobj
;
4490 /* A broken linker script might have discarded the dynamic sections.
4491 Catch this here so that we do not seg-fault later on. */
4492 if (sgot
!= NULL
&& bfd_is_abs_section (sgot
->output_section
))
4495 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
4497 if (htab
->etab
.dynamic_sections_created
)
4499 Elf32_External_Dyn
*dyncon
, *dynconend
;
4504 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
4505 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4506 for (; dyncon
< dynconend
; dyncon
++)
4508 Elf_Internal_Dyn dyn
;
4511 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4519 /* Use PLTGOT to set the GOT register. */
4520 dyn
.d_un
.d_ptr
= elf_gp (output_bfd
);
4525 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
4530 dyn
.d_un
.d_val
= s
->size
;
4534 /* Don't count procedure linkage table relocs in the
4535 overall reloc count. */
4539 dyn
.d_un
.d_val
-= s
->size
;
4543 /* We may not be using the standard ELF linker script.
4544 If .rela.plt is the first .rela section, we adjust
4545 DT_RELA to not include it. */
4549 if (dyn
.d_un
.d_ptr
!= s
->output_section
->vma
+ s
->output_offset
)
4551 dyn
.d_un
.d_ptr
+= s
->size
;
4555 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4559 if (sgot
!= NULL
&& sgot
->size
!= 0)
4561 /* Fill in the first entry in the global offset table.
4562 We use it to point to our dynamic section, if we have one. */
4563 bfd_put_32 (output_bfd
,
4564 sdyn
? sdyn
->output_section
->vma
+ sdyn
->output_offset
: 0,
4567 /* The second entry is reserved for use by the dynamic linker. */
4568 memset (sgot
->contents
+ GOT_ENTRY_SIZE
, 0, GOT_ENTRY_SIZE
);
4570 /* Set .got entry size. */
4571 elf_section_data (sgot
->output_section
)
4572 ->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
4575 if (htab
->splt
!= NULL
&& htab
->splt
->size
!= 0)
4577 /* Set plt entry size. */
4578 elf_section_data (htab
->splt
->output_section
)
4579 ->this_hdr
.sh_entsize
= PLT_ENTRY_SIZE
;
4581 if (htab
->need_plt_stub
)
4583 /* Set up the .plt stub. */
4584 memcpy (htab
->splt
->contents
4585 + htab
->splt
->size
- sizeof (plt_stub
),
4586 plt_stub
, sizeof (plt_stub
));
4588 if ((htab
->splt
->output_offset
4589 + htab
->splt
->output_section
->vma
4591 != (sgot
->output_offset
4592 + sgot
->output_section
->vma
))
4594 (*_bfd_error_handler
)
4595 (_(".got section not immediately after .plt section"));
4604 /* Called when writing out an object file to decide the type of a
4607 elf32_hppa_elf_get_symbol_type (Elf_Internal_Sym
*elf_sym
, int type
)
4609 if (ELF_ST_TYPE (elf_sym
->st_info
) == STT_PARISC_MILLI
)
4610 return STT_PARISC_MILLI
;
4615 /* Misc BFD support code. */
4616 #define bfd_elf32_bfd_is_local_label_name elf_hppa_is_local_label_name
4617 #define bfd_elf32_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
4618 #define bfd_elf32_bfd_reloc_name_lookup elf_hppa_reloc_name_lookup
4619 #define elf_info_to_howto elf_hppa_info_to_howto
4620 #define elf_info_to_howto_rel elf_hppa_info_to_howto_rel
4622 /* Stuff for the BFD linker. */
4623 #define bfd_elf32_bfd_final_link elf32_hppa_final_link
4624 #define bfd_elf32_bfd_link_hash_table_create elf32_hppa_link_hash_table_create
4625 #define bfd_elf32_bfd_link_hash_table_free elf32_hppa_link_hash_table_free
4626 #define elf_backend_adjust_dynamic_symbol elf32_hppa_adjust_dynamic_symbol
4627 #define elf_backend_copy_indirect_symbol elf32_hppa_copy_indirect_symbol
4628 #define elf_backend_check_relocs elf32_hppa_check_relocs
4629 #define elf_backend_create_dynamic_sections elf32_hppa_create_dynamic_sections
4630 #define elf_backend_fake_sections elf_hppa_fake_sections
4631 #define elf_backend_relocate_section elf32_hppa_relocate_section
4632 #define elf_backend_hide_symbol elf32_hppa_hide_symbol
4633 #define elf_backend_finish_dynamic_symbol elf32_hppa_finish_dynamic_symbol
4634 #define elf_backend_finish_dynamic_sections elf32_hppa_finish_dynamic_sections
4635 #define elf_backend_size_dynamic_sections elf32_hppa_size_dynamic_sections
4636 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
4637 #define elf_backend_gc_mark_hook elf32_hppa_gc_mark_hook
4638 #define elf_backend_gc_sweep_hook elf32_hppa_gc_sweep_hook
4639 #define elf_backend_grok_prstatus elf32_hppa_grok_prstatus
4640 #define elf_backend_grok_psinfo elf32_hppa_grok_psinfo
4641 #define elf_backend_object_p elf32_hppa_object_p
4642 #define elf_backend_final_write_processing elf_hppa_final_write_processing
4643 #define elf_backend_post_process_headers _bfd_elf_set_osabi
4644 #define elf_backend_get_symbol_type elf32_hppa_elf_get_symbol_type
4645 #define elf_backend_reloc_type_class elf32_hppa_reloc_type_class
4646 #define elf_backend_action_discarded elf_hppa_action_discarded
4648 #define elf_backend_can_gc_sections 1
4649 #define elf_backend_can_refcount 1
4650 #define elf_backend_plt_alignment 2
4651 #define elf_backend_want_got_plt 0
4652 #define elf_backend_plt_readonly 0
4653 #define elf_backend_want_plt_sym 0
4654 #define elf_backend_got_header_size 8
4655 #define elf_backend_rela_normal 1
4657 #define TARGET_BIG_SYM bfd_elf32_hppa_vec
4658 #define TARGET_BIG_NAME "elf32-hppa"
4659 #define ELF_ARCH bfd_arch_hppa
4660 #define ELF_TARGET_ID HPPA32_ELF_DATA
4661 #define ELF_MACHINE_CODE EM_PARISC
4662 #define ELF_MAXPAGESIZE 0x1000
4663 #define ELF_OSABI ELFOSABI_HPUX
4664 #define elf32_bed elf32_hppa_hpux_bed
4666 #include "elf32-target.h"
4668 #undef TARGET_BIG_SYM
4669 #define TARGET_BIG_SYM bfd_elf32_hppa_linux_vec
4670 #undef TARGET_BIG_NAME
4671 #define TARGET_BIG_NAME "elf32-hppa-linux"
4673 #define ELF_OSABI ELFOSABI_GNU
4675 #define elf32_bed elf32_hppa_linux_bed
4677 #include "elf32-target.h"
4679 #undef TARGET_BIG_SYM
4680 #define TARGET_BIG_SYM bfd_elf32_hppa_nbsd_vec
4681 #undef TARGET_BIG_NAME
4682 #define TARGET_BIG_NAME "elf32-hppa-netbsd"
4684 #define ELF_OSABI ELFOSABI_NETBSD
4686 #define elf32_bed elf32_hppa_netbsd_bed
4688 #include "elf32-target.h"