1 /* BFD back-end for HP PA-RISC ELF files.
2 Copyright (C) 1990-2016 Free Software Foundation, Inc.
5 Center for Software Science
6 Department of Computer Science
8 Largely rewritten by Alan Modra <alan@linuxcare.com.au>
9 Naming cleanup by Carlos O'Donell <carlos@systemhalted.org>
10 TLS support written by Randolph Chung <tausq@debian.org>
12 This file is part of BFD, the Binary File Descriptor library.
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 3 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
27 MA 02110-1301, USA. */
35 #include "elf32-hppa.h"
37 #include "elf32-hppa.h"
40 /* In order to gain some understanding of code in this file without
41 knowing all the intricate details of the linker, note the
44 Functions named elf32_hppa_* are called by external routines, other
45 functions are only called locally. elf32_hppa_* functions appear
46 in this file more or less in the order in which they are called
47 from external routines. eg. elf32_hppa_check_relocs is called
48 early in the link process, elf32_hppa_finish_dynamic_sections is
49 one of the last functions. */
51 /* We use two hash tables to hold information for linking PA ELF objects.
53 The first is the elf32_hppa_link_hash_table which is derived
54 from the standard ELF linker hash table. We use this as a place to
55 attach other hash tables and static information.
57 The second is the stub hash table which is derived from the
58 base BFD hash table. The stub hash table holds the information
59 necessary to build the linker stubs during a link.
61 There are a number of different stubs generated by the linker.
69 : addil LR'X - ($PIC_pcrel$0 - 4),%r1
70 : be,n RR'X - ($PIC_pcrel$0 - 8)(%sr4,%r1)
72 Import stub to call shared library routine from normal object file
73 (single sub-space version)
74 : addil LR'lt_ptr+ltoff,%dp ; get procedure entry point
75 : ldw RR'lt_ptr+ltoff(%r1),%r21
77 : ldw RR'lt_ptr+ltoff+4(%r1),%r19 ; get new dlt value.
79 Import stub to call shared library routine from shared library
80 (single sub-space version)
81 : addil LR'ltoff,%r19 ; get procedure entry point
82 : ldw RR'ltoff(%r1),%r21
84 : ldw RR'ltoff+4(%r1),%r19 ; get new dlt value.
86 Import stub to call shared library routine from normal object file
87 (multiple sub-space support)
88 : addil LR'lt_ptr+ltoff,%dp ; get procedure entry point
89 : ldw RR'lt_ptr+ltoff(%r1),%r21
90 : ldw RR'lt_ptr+ltoff+4(%r1),%r19 ; get new dlt value.
93 : be 0(%sr0,%r21) ; branch to target
94 : stw %rp,-24(%sp) ; save rp
96 Import stub to call shared library routine from shared library
97 (multiple sub-space support)
98 : addil LR'ltoff,%r19 ; get procedure entry point
99 : ldw RR'ltoff(%r1),%r21
100 : ldw RR'ltoff+4(%r1),%r19 ; get new dlt value.
103 : be 0(%sr0,%r21) ; branch to target
104 : stw %rp,-24(%sp) ; save rp
106 Export stub to return from shared lib routine (multiple sub-space support)
107 One of these is created for each exported procedure in a shared
108 library (and stored in the shared lib). Shared lib routines are
109 called via the first instruction in the export stub so that we can
110 do an inter-space return. Not required for single sub-space.
111 : bl,n X,%rp ; trap the return
113 : ldw -24(%sp),%rp ; restore the original rp
116 : be,n 0(%sr0,%rp) ; inter-space return. */
119 /* Variable names follow a coding style.
120 Please follow this (Apps Hungarian) style:
122 Structure/Variable Prefix
123 elf_link_hash_table "etab"
124 elf_link_hash_entry "eh"
126 elf32_hppa_link_hash_table "htab"
127 elf32_hppa_link_hash_entry "hh"
129 bfd_hash_table "btab"
132 bfd_hash_table containing stubs "bstab"
133 elf32_hppa_stub_hash_entry "hsh"
135 elf32_hppa_dyn_reloc_entry "hdh"
137 Always remember to use GNU Coding Style. */
139 #define PLT_ENTRY_SIZE 8
140 #define GOT_ENTRY_SIZE 4
141 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
143 static const bfd_byte plt_stub
[] =
145 0x0e, 0x80, 0x10, 0x96, /* 1: ldw 0(%r20),%r22 */
146 0xea, 0xc0, 0xc0, 0x00, /* bv %r0(%r22) */
147 0x0e, 0x88, 0x10, 0x95, /* ldw 4(%r20),%r21 */
148 #define PLT_STUB_ENTRY (3*4)
149 0xea, 0x9f, 0x1f, 0xdd, /* b,l 1b,%r20 */
150 0xd6, 0x80, 0x1c, 0x1e, /* depi 0,31,2,%r20 */
151 0x00, 0xc0, 0xff, 0xee, /* 9: .word fixup_func */
152 0xde, 0xad, 0xbe, 0xef /* .word fixup_ltp */
155 /* Section name for stubs is the associated section name plus this
157 #define STUB_SUFFIX ".stub"
159 /* We don't need to copy certain PC- or GP-relative dynamic relocs
160 into a shared object's dynamic section. All the relocs of the
161 limited class we are interested in, are absolute. */
162 #ifndef RELATIVE_DYNRELOCS
163 #define RELATIVE_DYNRELOCS 0
164 #define IS_ABSOLUTE_RELOC(r_type) 1
167 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
168 copying dynamic variables from a shared lib into an app's dynbss
169 section, and instead use a dynamic relocation to point into the
171 #define ELIMINATE_COPY_RELOCS 1
173 enum elf32_hppa_stub_type
175 hppa_stub_long_branch
,
176 hppa_stub_long_branch_shared
,
178 hppa_stub_import_shared
,
183 struct elf32_hppa_stub_hash_entry
185 /* Base hash table entry structure. */
186 struct bfd_hash_entry bh_root
;
188 /* The stub section. */
191 /* Offset within stub_sec of the beginning of this stub. */
194 /* Given the symbol's value and its section we can determine its final
195 value when building the stubs (so the stub knows where to jump. */
196 bfd_vma target_value
;
197 asection
*target_section
;
199 enum elf32_hppa_stub_type stub_type
;
201 /* The symbol table entry, if any, that this was derived from. */
202 struct elf32_hppa_link_hash_entry
*hh
;
204 /* Where this stub is being called from, or, in the case of combined
205 stub sections, the first input section in the group. */
209 struct elf32_hppa_link_hash_entry
211 struct elf_link_hash_entry eh
;
213 /* A pointer to the most recently used stub hash entry against this
215 struct elf32_hppa_stub_hash_entry
*hsh_cache
;
217 /* Used to count relocations for delayed sizing of relocation
219 struct elf32_hppa_dyn_reloc_entry
221 /* Next relocation in the chain. */
222 struct elf32_hppa_dyn_reloc_entry
*hdh_next
;
224 /* The input section of the reloc. */
227 /* Number of relocs copied in this section. */
230 #if RELATIVE_DYNRELOCS
231 /* Number of relative relocs copied for the input section. */
232 bfd_size_type relative_count
;
238 GOT_UNKNOWN
= 0, GOT_NORMAL
= 1, GOT_TLS_GD
= 2, GOT_TLS_LDM
= 4, GOT_TLS_IE
= 8
241 /* Set if this symbol is used by a plabel reloc. */
242 unsigned int plabel
:1;
245 struct elf32_hppa_link_hash_table
247 /* The main hash table. */
248 struct elf_link_hash_table etab
;
250 /* The stub hash table. */
251 struct bfd_hash_table bstab
;
253 /* Linker stub bfd. */
256 /* Linker call-backs. */
257 asection
* (*add_stub_section
) (const char *, asection
*);
258 void (*layout_sections_again
) (void);
260 /* Array to keep track of which stub sections have been created, and
261 information on stub grouping. */
264 /* This is the section to which stubs in the group will be
267 /* The stub section. */
271 /* Assorted information used by elf32_hppa_size_stubs. */
272 unsigned int bfd_count
;
273 unsigned int top_index
;
274 asection
**input_list
;
275 Elf_Internal_Sym
**all_local_syms
;
277 /* Short-cuts to get to dynamic linker sections. */
285 /* Used during a final link to store the base of the text and data
286 segments so that we can perform SEGREL relocations. */
287 bfd_vma text_segment_base
;
288 bfd_vma data_segment_base
;
290 /* Whether we support multiple sub-spaces for shared libs. */
291 unsigned int multi_subspace
:1;
293 /* Flags set when various size branches are detected. Used to
294 select suitable defaults for the stub group size. */
295 unsigned int has_12bit_branch
:1;
296 unsigned int has_17bit_branch
:1;
297 unsigned int has_22bit_branch
:1;
299 /* Set if we need a .plt stub to support lazy dynamic linking. */
300 unsigned int need_plt_stub
:1;
302 /* Small local sym cache. */
303 struct sym_cache sym_cache
;
305 /* Data for LDM relocations. */
308 bfd_signed_vma refcount
;
313 /* Various hash macros and functions. */
314 #define hppa_link_hash_table(p) \
315 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
316 == HPPA32_ELF_DATA ? ((struct elf32_hppa_link_hash_table *) ((p)->hash)) : NULL)
318 #define hppa_elf_hash_entry(ent) \
319 ((struct elf32_hppa_link_hash_entry *)(ent))
321 #define hppa_stub_hash_entry(ent) \
322 ((struct elf32_hppa_stub_hash_entry *)(ent))
324 #define hppa_stub_hash_lookup(table, string, create, copy) \
325 ((struct elf32_hppa_stub_hash_entry *) \
326 bfd_hash_lookup ((table), (string), (create), (copy)))
328 #define hppa_elf_local_got_tls_type(abfd) \
329 ((char *)(elf_local_got_offsets (abfd) + (elf_tdata (abfd)->symtab_hdr.sh_info * 2)))
331 #define hh_name(hh) \
332 (hh ? hh->eh.root.root.string : "<undef>")
334 #define eh_name(eh) \
335 (eh ? eh->root.root.string : "<undef>")
337 /* Assorted hash table functions. */
339 /* Initialize an entry in the stub hash table. */
341 static struct bfd_hash_entry
*
342 stub_hash_newfunc (struct bfd_hash_entry
*entry
,
343 struct bfd_hash_table
*table
,
346 /* Allocate the structure if it has not already been allocated by a
350 entry
= bfd_hash_allocate (table
,
351 sizeof (struct elf32_hppa_stub_hash_entry
));
356 /* Call the allocation method of the superclass. */
357 entry
= bfd_hash_newfunc (entry
, table
, string
);
360 struct elf32_hppa_stub_hash_entry
*hsh
;
362 /* Initialize the local fields. */
363 hsh
= hppa_stub_hash_entry (entry
);
364 hsh
->stub_sec
= NULL
;
365 hsh
->stub_offset
= 0;
366 hsh
->target_value
= 0;
367 hsh
->target_section
= NULL
;
368 hsh
->stub_type
= hppa_stub_long_branch
;
376 /* Initialize an entry in the link hash table. */
378 static struct bfd_hash_entry
*
379 hppa_link_hash_newfunc (struct bfd_hash_entry
*entry
,
380 struct bfd_hash_table
*table
,
383 /* Allocate the structure if it has not already been allocated by a
387 entry
= bfd_hash_allocate (table
,
388 sizeof (struct elf32_hppa_link_hash_entry
));
393 /* Call the allocation method of the superclass. */
394 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
397 struct elf32_hppa_link_hash_entry
*hh
;
399 /* Initialize the local fields. */
400 hh
= hppa_elf_hash_entry (entry
);
401 hh
->hsh_cache
= NULL
;
402 hh
->dyn_relocs
= NULL
;
404 hh
->tls_type
= GOT_UNKNOWN
;
410 /* Free the derived linker hash table. */
413 elf32_hppa_link_hash_table_free (bfd
*obfd
)
415 struct elf32_hppa_link_hash_table
*htab
416 = (struct elf32_hppa_link_hash_table
*) obfd
->link
.hash
;
418 bfd_hash_table_free (&htab
->bstab
);
419 _bfd_elf_link_hash_table_free (obfd
);
422 /* Create the derived linker hash table. The PA ELF port uses the derived
423 hash table to keep information specific to the PA ELF linker (without
424 using static variables). */
426 static struct bfd_link_hash_table
*
427 elf32_hppa_link_hash_table_create (bfd
*abfd
)
429 struct elf32_hppa_link_hash_table
*htab
;
430 bfd_size_type amt
= sizeof (*htab
);
432 htab
= bfd_zmalloc (amt
);
436 if (!_bfd_elf_link_hash_table_init (&htab
->etab
, abfd
, hppa_link_hash_newfunc
,
437 sizeof (struct elf32_hppa_link_hash_entry
),
444 /* Init the stub hash table too. */
445 if (!bfd_hash_table_init (&htab
->bstab
, stub_hash_newfunc
,
446 sizeof (struct elf32_hppa_stub_hash_entry
)))
448 _bfd_elf_link_hash_table_free (abfd
);
451 htab
->etab
.root
.hash_table_free
= elf32_hppa_link_hash_table_free
;
453 htab
->text_segment_base
= (bfd_vma
) -1;
454 htab
->data_segment_base
= (bfd_vma
) -1;
455 return &htab
->etab
.root
;
458 /* Initialize the linker stubs BFD so that we can use it for linker
459 created dynamic sections. */
462 elf32_hppa_init_stub_bfd (bfd
*abfd
, struct bfd_link_info
*info
)
464 struct elf32_hppa_link_hash_table
*htab
= hppa_link_hash_table (info
);
466 elf_elfheader (abfd
)->e_ident
[EI_CLASS
] = ELFCLASS32
;
467 htab
->etab
.dynobj
= abfd
;
470 /* Build a name for an entry in the stub hash table. */
473 hppa_stub_name (const asection
*input_section
,
474 const asection
*sym_sec
,
475 const struct elf32_hppa_link_hash_entry
*hh
,
476 const Elf_Internal_Rela
*rela
)
483 len
= 8 + 1 + strlen (hh_name (hh
)) + 1 + 8 + 1;
484 stub_name
= bfd_malloc (len
);
485 if (stub_name
!= NULL
)
486 sprintf (stub_name
, "%08x_%s+%x",
487 input_section
->id
& 0xffffffff,
489 (int) rela
->r_addend
& 0xffffffff);
493 len
= 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
494 stub_name
= bfd_malloc (len
);
495 if (stub_name
!= NULL
)
496 sprintf (stub_name
, "%08x_%x:%x+%x",
497 input_section
->id
& 0xffffffff,
498 sym_sec
->id
& 0xffffffff,
499 (int) ELF32_R_SYM (rela
->r_info
) & 0xffffffff,
500 (int) rela
->r_addend
& 0xffffffff);
505 /* Look up an entry in the stub hash. Stub entries are cached because
506 creating the stub name takes a bit of time. */
508 static struct elf32_hppa_stub_hash_entry
*
509 hppa_get_stub_entry (const asection
*input_section
,
510 const asection
*sym_sec
,
511 struct elf32_hppa_link_hash_entry
*hh
,
512 const Elf_Internal_Rela
*rela
,
513 struct elf32_hppa_link_hash_table
*htab
)
515 struct elf32_hppa_stub_hash_entry
*hsh_entry
;
516 const asection
*id_sec
;
518 /* If this input section is part of a group of sections sharing one
519 stub section, then use the id of the first section in the group.
520 Stub names need to include a section id, as there may well be
521 more than one stub used to reach say, printf, and we need to
522 distinguish between them. */
523 id_sec
= htab
->stub_group
[input_section
->id
].link_sec
;
525 if (hh
!= NULL
&& hh
->hsh_cache
!= NULL
526 && hh
->hsh_cache
->hh
== hh
527 && hh
->hsh_cache
->id_sec
== id_sec
)
529 hsh_entry
= hh
->hsh_cache
;
535 stub_name
= hppa_stub_name (id_sec
, sym_sec
, hh
, rela
);
536 if (stub_name
== NULL
)
539 hsh_entry
= hppa_stub_hash_lookup (&htab
->bstab
,
540 stub_name
, FALSE
, FALSE
);
542 hh
->hsh_cache
= hsh_entry
;
550 /* Add a new stub entry to the stub hash. Not all fields of the new
551 stub entry are initialised. */
553 static struct elf32_hppa_stub_hash_entry
*
554 hppa_add_stub (const char *stub_name
,
556 struct elf32_hppa_link_hash_table
*htab
)
560 struct elf32_hppa_stub_hash_entry
*hsh
;
562 link_sec
= htab
->stub_group
[section
->id
].link_sec
;
563 stub_sec
= htab
->stub_group
[section
->id
].stub_sec
;
564 if (stub_sec
== NULL
)
566 stub_sec
= htab
->stub_group
[link_sec
->id
].stub_sec
;
567 if (stub_sec
== NULL
)
573 namelen
= strlen (link_sec
->name
);
574 len
= namelen
+ sizeof (STUB_SUFFIX
);
575 s_name
= bfd_alloc (htab
->stub_bfd
, len
);
579 memcpy (s_name
, link_sec
->name
, namelen
);
580 memcpy (s_name
+ namelen
, STUB_SUFFIX
, sizeof (STUB_SUFFIX
));
581 stub_sec
= (*htab
->add_stub_section
) (s_name
, link_sec
);
582 if (stub_sec
== NULL
)
584 htab
->stub_group
[link_sec
->id
].stub_sec
= stub_sec
;
586 htab
->stub_group
[section
->id
].stub_sec
= stub_sec
;
589 /* Enter this entry into the linker stub hash table. */
590 hsh
= hppa_stub_hash_lookup (&htab
->bstab
, stub_name
,
594 /* xgettext:c-format */
595 _bfd_error_handler (_("%B: cannot create stub entry %s"),
596 section
->owner
, stub_name
);
600 hsh
->stub_sec
= stub_sec
;
601 hsh
->stub_offset
= 0;
602 hsh
->id_sec
= link_sec
;
606 /* Determine the type of stub needed, if any, for a call. */
608 static enum elf32_hppa_stub_type
609 hppa_type_of_stub (asection
*input_sec
,
610 const Elf_Internal_Rela
*rela
,
611 struct elf32_hppa_link_hash_entry
*hh
,
613 struct bfd_link_info
*info
)
616 bfd_vma branch_offset
;
617 bfd_vma max_branch_offset
;
621 && hh
->eh
.plt
.offset
!= (bfd_vma
) -1
622 && hh
->eh
.dynindx
!= -1
624 && (bfd_link_pic (info
)
625 || !hh
->eh
.def_regular
626 || hh
->eh
.root
.type
== bfd_link_hash_defweak
))
628 /* We need an import stub. Decide between hppa_stub_import
629 and hppa_stub_import_shared later. */
630 return hppa_stub_import
;
633 /* Determine where the call point is. */
634 location
= (input_sec
->output_offset
635 + input_sec
->output_section
->vma
638 branch_offset
= destination
- location
- 8;
639 r_type
= ELF32_R_TYPE (rela
->r_info
);
641 /* Determine if a long branch stub is needed. parisc branch offsets
642 are relative to the second instruction past the branch, ie. +8
643 bytes on from the branch instruction location. The offset is
644 signed and counts in units of 4 bytes. */
645 if (r_type
== (unsigned int) R_PARISC_PCREL17F
)
646 max_branch_offset
= (1 << (17 - 1)) << 2;
648 else if (r_type
== (unsigned int) R_PARISC_PCREL12F
)
649 max_branch_offset
= (1 << (12 - 1)) << 2;
651 else /* R_PARISC_PCREL22F. */
652 max_branch_offset
= (1 << (22 - 1)) << 2;
654 if (branch_offset
+ max_branch_offset
>= 2*max_branch_offset
)
655 return hppa_stub_long_branch
;
657 return hppa_stub_none
;
660 /* Build one linker stub as defined by the stub hash table entry GEN_ENTRY.
661 IN_ARG contains the link info pointer. */
663 #define LDIL_R1 0x20200000 /* ldil LR'XXX,%r1 */
664 #define BE_SR4_R1 0xe0202002 /* be,n RR'XXX(%sr4,%r1) */
666 #define BL_R1 0xe8200000 /* b,l .+8,%r1 */
667 #define ADDIL_R1 0x28200000 /* addil LR'XXX,%r1,%r1 */
668 #define DEPI_R1 0xd4201c1e /* depi 0,31,2,%r1 */
670 #define ADDIL_DP 0x2b600000 /* addil LR'XXX,%dp,%r1 */
671 #define LDW_R1_R21 0x48350000 /* ldw RR'XXX(%sr0,%r1),%r21 */
672 #define BV_R0_R21 0xeaa0c000 /* bv %r0(%r21) */
673 #define LDW_R1_R19 0x48330000 /* ldw RR'XXX(%sr0,%r1),%r19 */
675 #define ADDIL_R19 0x2a600000 /* addil LR'XXX,%r19,%r1 */
676 #define LDW_R1_DP 0x483b0000 /* ldw RR'XXX(%sr0,%r1),%dp */
678 #define LDSID_R21_R1 0x02a010a1 /* ldsid (%sr0,%r21),%r1 */
679 #define MTSP_R1 0x00011820 /* mtsp %r1,%sr0 */
680 #define BE_SR0_R21 0xe2a00000 /* be 0(%sr0,%r21) */
681 #define STW_RP 0x6bc23fd1 /* stw %rp,-24(%sr0,%sp) */
683 #define BL22_RP 0xe800a002 /* b,l,n XXX,%rp */
684 #define BL_RP 0xe8400002 /* b,l,n XXX,%rp */
685 #define NOP 0x08000240 /* nop */
686 #define LDW_RP 0x4bc23fd1 /* ldw -24(%sr0,%sp),%rp */
687 #define LDSID_RP_R1 0x004010a1 /* ldsid (%sr0,%rp),%r1 */
688 #define BE_SR0_RP 0xe0400002 /* be,n 0(%sr0,%rp) */
695 #define LDW_R1_DLT LDW_R1_R19
697 #define LDW_R1_DLT LDW_R1_DP
701 hppa_build_one_stub (struct bfd_hash_entry
*bh
, void *in_arg
)
703 struct elf32_hppa_stub_hash_entry
*hsh
;
704 struct bfd_link_info
*info
;
705 struct elf32_hppa_link_hash_table
*htab
;
715 /* Massage our args to the form they really have. */
716 hsh
= hppa_stub_hash_entry (bh
);
717 info
= (struct bfd_link_info
*)in_arg
;
719 htab
= hppa_link_hash_table (info
);
723 stub_sec
= hsh
->stub_sec
;
725 /* Make a note of the offset within the stubs for this entry. */
726 hsh
->stub_offset
= stub_sec
->size
;
727 loc
= stub_sec
->contents
+ hsh
->stub_offset
;
729 stub_bfd
= stub_sec
->owner
;
731 switch (hsh
->stub_type
)
733 case hppa_stub_long_branch
:
734 /* Create the long branch. A long branch is formed with "ldil"
735 loading the upper bits of the target address into a register,
736 then branching with "be" which adds in the lower bits.
737 The "be" has its delay slot nullified. */
738 sym_value
= (hsh
->target_value
739 + hsh
->target_section
->output_offset
740 + hsh
->target_section
->output_section
->vma
);
742 val
= hppa_field_adjust (sym_value
, 0, e_lrsel
);
743 insn
= hppa_rebuild_insn ((int) LDIL_R1
, val
, 21);
744 bfd_put_32 (stub_bfd
, insn
, loc
);
746 val
= hppa_field_adjust (sym_value
, 0, e_rrsel
) >> 2;
747 insn
= hppa_rebuild_insn ((int) BE_SR4_R1
, val
, 17);
748 bfd_put_32 (stub_bfd
, insn
, loc
+ 4);
753 case hppa_stub_long_branch_shared
:
754 /* Branches are relative. This is where we are going to. */
755 sym_value
= (hsh
->target_value
756 + hsh
->target_section
->output_offset
757 + hsh
->target_section
->output_section
->vma
);
759 /* And this is where we are coming from, more or less. */
760 sym_value
-= (hsh
->stub_offset
761 + stub_sec
->output_offset
762 + stub_sec
->output_section
->vma
);
764 bfd_put_32 (stub_bfd
, (bfd_vma
) BL_R1
, loc
);
765 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) -8, e_lrsel
);
766 insn
= hppa_rebuild_insn ((int) ADDIL_R1
, val
, 21);
767 bfd_put_32 (stub_bfd
, insn
, loc
+ 4);
769 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) -8, e_rrsel
) >> 2;
770 insn
= hppa_rebuild_insn ((int) BE_SR4_R1
, val
, 17);
771 bfd_put_32 (stub_bfd
, insn
, loc
+ 8);
775 case hppa_stub_import
:
776 case hppa_stub_import_shared
:
777 off
= hsh
->hh
->eh
.plt
.offset
;
778 if (off
>= (bfd_vma
) -2)
781 off
&= ~ (bfd_vma
) 1;
783 + htab
->splt
->output_offset
784 + htab
->splt
->output_section
->vma
785 - elf_gp (htab
->splt
->output_section
->owner
));
789 if (hsh
->stub_type
== hppa_stub_import_shared
)
792 val
= hppa_field_adjust (sym_value
, 0, e_lrsel
),
793 insn
= hppa_rebuild_insn ((int) insn
, val
, 21);
794 bfd_put_32 (stub_bfd
, insn
, loc
);
796 /* It is critical to use lrsel/rrsel here because we are using
797 two different offsets (+0 and +4) from sym_value. If we use
798 lsel/rsel then with unfortunate sym_values we will round
799 sym_value+4 up to the next 2k block leading to a mis-match
800 between the lsel and rsel value. */
801 val
= hppa_field_adjust (sym_value
, 0, e_rrsel
);
802 insn
= hppa_rebuild_insn ((int) LDW_R1_R21
, val
, 14);
803 bfd_put_32 (stub_bfd
, insn
, loc
+ 4);
805 if (htab
->multi_subspace
)
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
+ 8);
811 bfd_put_32 (stub_bfd
, (bfd_vma
) LDSID_R21_R1
, loc
+ 12);
812 bfd_put_32 (stub_bfd
, (bfd_vma
) MTSP_R1
, loc
+ 16);
813 bfd_put_32 (stub_bfd
, (bfd_vma
) BE_SR0_R21
, loc
+ 20);
814 bfd_put_32 (stub_bfd
, (bfd_vma
) STW_RP
, loc
+ 24);
820 bfd_put_32 (stub_bfd
, (bfd_vma
) BV_R0_R21
, loc
+ 8);
821 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) 4, e_rrsel
);
822 insn
= hppa_rebuild_insn ((int) LDW_R1_DLT
, val
, 14);
823 bfd_put_32 (stub_bfd
, insn
, loc
+ 12);
830 case hppa_stub_export
:
831 /* Branches are relative. This is where we are going to. */
832 sym_value
= (hsh
->target_value
833 + hsh
->target_section
->output_offset
834 + hsh
->target_section
->output_section
->vma
);
836 /* And this is where we are coming from. */
837 sym_value
-= (hsh
->stub_offset
838 + stub_sec
->output_offset
839 + stub_sec
->output_section
->vma
);
841 if (sym_value
- 8 + (1 << (17 + 1)) >= (1 << (17 + 2))
842 && (!htab
->has_22bit_branch
843 || sym_value
- 8 + (1 << (22 + 1)) >= (1 << (22 + 2))))
846 /* xgettext:c-format */
847 (_("%B(%A+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
848 hsh
->target_section
->owner
,
850 (long) hsh
->stub_offset
,
851 hsh
->bh_root
.string
);
852 bfd_set_error (bfd_error_bad_value
);
856 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) -8, e_fsel
) >> 2;
857 if (!htab
->has_22bit_branch
)
858 insn
= hppa_rebuild_insn ((int) BL_RP
, val
, 17);
860 insn
= hppa_rebuild_insn ((int) BL22_RP
, val
, 22);
861 bfd_put_32 (stub_bfd
, insn
, loc
);
863 bfd_put_32 (stub_bfd
, (bfd_vma
) NOP
, loc
+ 4);
864 bfd_put_32 (stub_bfd
, (bfd_vma
) LDW_RP
, loc
+ 8);
865 bfd_put_32 (stub_bfd
, (bfd_vma
) LDSID_RP_R1
, loc
+ 12);
866 bfd_put_32 (stub_bfd
, (bfd_vma
) MTSP_R1
, loc
+ 16);
867 bfd_put_32 (stub_bfd
, (bfd_vma
) BE_SR0_RP
, loc
+ 20);
869 /* Point the function symbol at the stub. */
870 hsh
->hh
->eh
.root
.u
.def
.section
= stub_sec
;
871 hsh
->hh
->eh
.root
.u
.def
.value
= stub_sec
->size
;
881 stub_sec
->size
+= size
;
906 /* As above, but don't actually build the stub. Just bump offset so
907 we know stub section sizes. */
910 hppa_size_one_stub (struct bfd_hash_entry
*bh
, void *in_arg
)
912 struct elf32_hppa_stub_hash_entry
*hsh
;
913 struct elf32_hppa_link_hash_table
*htab
;
916 /* Massage our args to the form they really have. */
917 hsh
= hppa_stub_hash_entry (bh
);
920 if (hsh
->stub_type
== hppa_stub_long_branch
)
922 else if (hsh
->stub_type
== hppa_stub_long_branch_shared
)
924 else if (hsh
->stub_type
== hppa_stub_export
)
926 else /* hppa_stub_import or hppa_stub_import_shared. */
928 if (htab
->multi_subspace
)
934 hsh
->stub_sec
->size
+= size
;
938 /* Return nonzero if ABFD represents an HPPA ELF32 file.
939 Additionally we set the default architecture and machine. */
942 elf32_hppa_object_p (bfd
*abfd
)
944 Elf_Internal_Ehdr
* i_ehdrp
;
947 i_ehdrp
= elf_elfheader (abfd
);
948 if (strcmp (bfd_get_target (abfd
), "elf32-hppa-linux") == 0)
950 /* GCC on hppa-linux produces binaries with OSABI=GNU,
951 but the kernel produces corefiles with OSABI=SysV. */
952 if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_GNU
&&
953 i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_NONE
) /* aka SYSV */
956 else if (strcmp (bfd_get_target (abfd
), "elf32-hppa-netbsd") == 0)
958 /* GCC on hppa-netbsd produces binaries with OSABI=NetBSD,
959 but the kernel produces corefiles with OSABI=SysV. */
960 if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_NETBSD
&&
961 i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_NONE
) /* aka SYSV */
966 if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_HPUX
)
970 flags
= i_ehdrp
->e_flags
;
971 switch (flags
& (EF_PARISC_ARCH
| EF_PARISC_WIDE
))
974 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 10);
976 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 11);
978 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 20);
979 case EFA_PARISC_2_0
| EF_PARISC_WIDE
:
980 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 25);
985 /* Create the .plt and .got sections, and set up our hash table
986 short-cuts to various dynamic sections. */
989 elf32_hppa_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
991 struct elf32_hppa_link_hash_table
*htab
;
992 struct elf_link_hash_entry
*eh
;
994 /* Don't try to create the .plt and .got twice. */
995 htab
= hppa_link_hash_table (info
);
998 if (htab
->splt
!= NULL
)
1001 /* Call the generic code to do most of the work. */
1002 if (! _bfd_elf_create_dynamic_sections (abfd
, info
))
1005 htab
->splt
= bfd_get_linker_section (abfd
, ".plt");
1006 htab
->srelplt
= bfd_get_linker_section (abfd
, ".rela.plt");
1008 htab
->sgot
= bfd_get_linker_section (abfd
, ".got");
1009 htab
->srelgot
= bfd_get_linker_section (abfd
, ".rela.got");
1011 htab
->sdynbss
= bfd_get_linker_section (abfd
, ".dynbss");
1012 htab
->srelbss
= bfd_get_linker_section (abfd
, ".rela.bss");
1014 /* hppa-linux needs _GLOBAL_OFFSET_TABLE_ to be visible from the main
1015 application, because __canonicalize_funcptr_for_compare needs it. */
1016 eh
= elf_hash_table (info
)->hgot
;
1017 eh
->forced_local
= 0;
1018 eh
->other
= STV_DEFAULT
;
1019 return bfd_elf_link_record_dynamic_symbol (info
, eh
);
1022 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1025 elf32_hppa_copy_indirect_symbol (struct bfd_link_info
*info
,
1026 struct elf_link_hash_entry
*eh_dir
,
1027 struct elf_link_hash_entry
*eh_ind
)
1029 struct elf32_hppa_link_hash_entry
*hh_dir
, *hh_ind
;
1031 hh_dir
= hppa_elf_hash_entry (eh_dir
);
1032 hh_ind
= hppa_elf_hash_entry (eh_ind
);
1034 if (hh_ind
->dyn_relocs
!= NULL
)
1036 if (hh_dir
->dyn_relocs
!= NULL
)
1038 struct elf32_hppa_dyn_reloc_entry
**hdh_pp
;
1039 struct elf32_hppa_dyn_reloc_entry
*hdh_p
;
1041 /* Add reloc counts against the indirect sym to the direct sym
1042 list. Merge any entries against the same section. */
1043 for (hdh_pp
= &hh_ind
->dyn_relocs
; (hdh_p
= *hdh_pp
) != NULL
; )
1045 struct elf32_hppa_dyn_reloc_entry
*hdh_q
;
1047 for (hdh_q
= hh_dir
->dyn_relocs
;
1049 hdh_q
= hdh_q
->hdh_next
)
1050 if (hdh_q
->sec
== hdh_p
->sec
)
1052 #if RELATIVE_DYNRELOCS
1053 hdh_q
->relative_count
+= hdh_p
->relative_count
;
1055 hdh_q
->count
+= hdh_p
->count
;
1056 *hdh_pp
= hdh_p
->hdh_next
;
1060 hdh_pp
= &hdh_p
->hdh_next
;
1062 *hdh_pp
= hh_dir
->dyn_relocs
;
1065 hh_dir
->dyn_relocs
= hh_ind
->dyn_relocs
;
1066 hh_ind
->dyn_relocs
= NULL
;
1069 if (ELIMINATE_COPY_RELOCS
1070 && eh_ind
->root
.type
!= bfd_link_hash_indirect
1071 && eh_dir
->dynamic_adjusted
)
1073 /* If called to transfer flags for a weakdef during processing
1074 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1075 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1076 eh_dir
->ref_dynamic
|= eh_ind
->ref_dynamic
;
1077 eh_dir
->ref_regular
|= eh_ind
->ref_regular
;
1078 eh_dir
->ref_regular_nonweak
|= eh_ind
->ref_regular_nonweak
;
1079 eh_dir
->needs_plt
|= eh_ind
->needs_plt
;
1083 if (eh_ind
->root
.type
== bfd_link_hash_indirect
1084 && eh_dir
->got
.refcount
<= 0)
1086 hh_dir
->tls_type
= hh_ind
->tls_type
;
1087 hh_ind
->tls_type
= GOT_UNKNOWN
;
1090 _bfd_elf_link_hash_copy_indirect (info
, eh_dir
, eh_ind
);
1095 elf32_hppa_optimized_tls_reloc (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1096 int r_type
, int is_local ATTRIBUTE_UNUSED
)
1098 /* For now we don't support linker optimizations. */
1102 /* Return a pointer to the local GOT, PLT and TLS reference counts
1103 for ABFD. Returns NULL if the storage allocation fails. */
1105 static bfd_signed_vma
*
1106 hppa32_elf_local_refcounts (bfd
*abfd
)
1108 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1109 bfd_signed_vma
*local_refcounts
;
1111 local_refcounts
= elf_local_got_refcounts (abfd
);
1112 if (local_refcounts
== NULL
)
1116 /* Allocate space for local GOT and PLT reference
1117 counts. Done this way to save polluting elf_obj_tdata
1118 with another target specific pointer. */
1119 size
= symtab_hdr
->sh_info
;
1120 size
*= 2 * sizeof (bfd_signed_vma
);
1121 /* Add in space to store the local GOT TLS types. */
1122 size
+= symtab_hdr
->sh_info
;
1123 local_refcounts
= bfd_zalloc (abfd
, size
);
1124 if (local_refcounts
== NULL
)
1126 elf_local_got_refcounts (abfd
) = local_refcounts
;
1127 memset (hppa_elf_local_got_tls_type (abfd
), GOT_UNKNOWN
,
1128 symtab_hdr
->sh_info
);
1130 return local_refcounts
;
1134 /* Look through the relocs for a section during the first phase, and
1135 calculate needed space in the global offset table, procedure linkage
1136 table, and dynamic reloc sections. At this point we haven't
1137 necessarily read all the input files. */
1140 elf32_hppa_check_relocs (bfd
*abfd
,
1141 struct bfd_link_info
*info
,
1143 const Elf_Internal_Rela
*relocs
)
1145 Elf_Internal_Shdr
*symtab_hdr
;
1146 struct elf_link_hash_entry
**eh_syms
;
1147 const Elf_Internal_Rela
*rela
;
1148 const Elf_Internal_Rela
*rela_end
;
1149 struct elf32_hppa_link_hash_table
*htab
;
1151 int tls_type
= GOT_UNKNOWN
, old_tls_type
= GOT_UNKNOWN
;
1153 if (bfd_link_relocatable (info
))
1156 htab
= hppa_link_hash_table (info
);
1159 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1160 eh_syms
= elf_sym_hashes (abfd
);
1163 rela_end
= relocs
+ sec
->reloc_count
;
1164 for (rela
= relocs
; rela
< rela_end
; rela
++)
1173 unsigned int r_symndx
, r_type
;
1174 struct elf32_hppa_link_hash_entry
*hh
;
1177 r_symndx
= ELF32_R_SYM (rela
->r_info
);
1179 if (r_symndx
< symtab_hdr
->sh_info
)
1183 hh
= hppa_elf_hash_entry (eh_syms
[r_symndx
- symtab_hdr
->sh_info
]);
1184 while (hh
->eh
.root
.type
== bfd_link_hash_indirect
1185 || hh
->eh
.root
.type
== bfd_link_hash_warning
)
1186 hh
= hppa_elf_hash_entry (hh
->eh
.root
.u
.i
.link
);
1188 /* PR15323, ref flags aren't set for references in the same
1190 hh
->eh
.root
.non_ir_ref
= 1;
1193 r_type
= ELF32_R_TYPE (rela
->r_info
);
1194 r_type
= elf32_hppa_optimized_tls_reloc (info
, r_type
, hh
== NULL
);
1198 case R_PARISC_DLTIND14F
:
1199 case R_PARISC_DLTIND14R
:
1200 case R_PARISC_DLTIND21L
:
1201 /* This symbol requires a global offset table entry. */
1202 need_entry
= NEED_GOT
;
1205 case R_PARISC_PLABEL14R
: /* "Official" procedure labels. */
1206 case R_PARISC_PLABEL21L
:
1207 case R_PARISC_PLABEL32
:
1208 /* If the addend is non-zero, we break badly. */
1209 if (rela
->r_addend
!= 0)
1212 /* If we are creating a shared library, then we need to
1213 create a PLT entry for all PLABELs, because PLABELs with
1214 local symbols may be passed via a pointer to another
1215 object. Additionally, output a dynamic relocation
1216 pointing to the PLT entry.
1218 For executables, the original 32-bit ABI allowed two
1219 different styles of PLABELs (function pointers): For
1220 global functions, the PLABEL word points into the .plt
1221 two bytes past a (function address, gp) pair, and for
1222 local functions the PLABEL points directly at the
1223 function. The magic +2 for the first type allows us to
1224 differentiate between the two. As you can imagine, this
1225 is a real pain when it comes to generating code to call
1226 functions indirectly or to compare function pointers.
1227 We avoid the mess by always pointing a PLABEL into the
1228 .plt, even for local functions. */
1229 need_entry
= PLT_PLABEL
| NEED_PLT
| NEED_DYNREL
;
1232 case R_PARISC_PCREL12F
:
1233 htab
->has_12bit_branch
= 1;
1236 case R_PARISC_PCREL17C
:
1237 case R_PARISC_PCREL17F
:
1238 htab
->has_17bit_branch
= 1;
1241 case R_PARISC_PCREL22F
:
1242 htab
->has_22bit_branch
= 1;
1244 /* Function calls might need to go through the .plt, and
1245 might require long branch stubs. */
1248 /* We know local syms won't need a .plt entry, and if
1249 they need a long branch stub we can't guarantee that
1250 we can reach the stub. So just flag an error later
1251 if we're doing a shared link and find we need a long
1257 /* Global symbols will need a .plt entry if they remain
1258 global, and in most cases won't need a long branch
1259 stub. Unfortunately, we have to cater for the case
1260 where a symbol is forced local by versioning, or due
1261 to symbolic linking, and we lose the .plt entry. */
1262 need_entry
= NEED_PLT
;
1263 if (hh
->eh
.type
== STT_PARISC_MILLI
)
1268 case R_PARISC_SEGBASE
: /* Used to set segment base. */
1269 case R_PARISC_SEGREL32
: /* Relative reloc, used for unwind. */
1270 case R_PARISC_PCREL14F
: /* PC relative load/store. */
1271 case R_PARISC_PCREL14R
:
1272 case R_PARISC_PCREL17R
: /* External branches. */
1273 case R_PARISC_PCREL21L
: /* As above, and for load/store too. */
1274 case R_PARISC_PCREL32
:
1275 /* We don't need to propagate the relocation if linking a
1276 shared object since these are section relative. */
1279 case R_PARISC_DPREL14F
: /* Used for gp rel data load/store. */
1280 case R_PARISC_DPREL14R
:
1281 case R_PARISC_DPREL21L
:
1282 if (bfd_link_pic (info
))
1285 /* xgettext:c-format */
1286 (_("%B: relocation %s can not be used when making a shared object; recompile with -fPIC"),
1288 elf_hppa_howto_table
[r_type
].name
);
1289 bfd_set_error (bfd_error_bad_value
);
1294 case R_PARISC_DIR17F
: /* Used for external branches. */
1295 case R_PARISC_DIR17R
:
1296 case R_PARISC_DIR14F
: /* Used for load/store from absolute locn. */
1297 case R_PARISC_DIR14R
:
1298 case R_PARISC_DIR21L
: /* As above, and for ext branches too. */
1299 case R_PARISC_DIR32
: /* .word relocs. */
1300 /* We may want to output a dynamic relocation later. */
1301 need_entry
= NEED_DYNREL
;
1304 /* This relocation describes the C++ object vtable hierarchy.
1305 Reconstruct it for later use during GC. */
1306 case R_PARISC_GNU_VTINHERIT
:
1307 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, &hh
->eh
, rela
->r_offset
))
1311 /* This relocation describes which C++ vtable entries are actually
1312 used. Record for later use during GC. */
1313 case R_PARISC_GNU_VTENTRY
:
1314 BFD_ASSERT (hh
!= NULL
);
1316 && !bfd_elf_gc_record_vtentry (abfd
, sec
, &hh
->eh
, rela
->r_addend
))
1320 case R_PARISC_TLS_GD21L
:
1321 case R_PARISC_TLS_GD14R
:
1322 case R_PARISC_TLS_LDM21L
:
1323 case R_PARISC_TLS_LDM14R
:
1324 need_entry
= NEED_GOT
;
1327 case R_PARISC_TLS_IE21L
:
1328 case R_PARISC_TLS_IE14R
:
1329 if (bfd_link_pic (info
))
1330 info
->flags
|= DF_STATIC_TLS
;
1331 need_entry
= NEED_GOT
;
1338 /* Now carry out our orders. */
1339 if (need_entry
& NEED_GOT
)
1344 tls_type
= GOT_NORMAL
;
1346 case R_PARISC_TLS_GD21L
:
1347 case R_PARISC_TLS_GD14R
:
1348 tls_type
|= GOT_TLS_GD
;
1350 case R_PARISC_TLS_LDM21L
:
1351 case R_PARISC_TLS_LDM14R
:
1352 tls_type
|= GOT_TLS_LDM
;
1354 case R_PARISC_TLS_IE21L
:
1355 case R_PARISC_TLS_IE14R
:
1356 tls_type
|= GOT_TLS_IE
;
1360 /* Allocate space for a GOT entry, as well as a dynamic
1361 relocation for this entry. */
1362 if (htab
->sgot
== NULL
)
1364 if (!elf32_hppa_create_dynamic_sections (htab
->etab
.dynobj
, info
))
1368 if (r_type
== R_PARISC_TLS_LDM21L
1369 || r_type
== R_PARISC_TLS_LDM14R
)
1370 htab
->tls_ldm_got
.refcount
+= 1;
1375 hh
->eh
.got
.refcount
+= 1;
1376 old_tls_type
= hh
->tls_type
;
1380 bfd_signed_vma
*local_got_refcounts
;
1382 /* This is a global offset table entry for a local symbol. */
1383 local_got_refcounts
= hppa32_elf_local_refcounts (abfd
);
1384 if (local_got_refcounts
== NULL
)
1386 local_got_refcounts
[r_symndx
] += 1;
1388 old_tls_type
= hppa_elf_local_got_tls_type (abfd
) [r_symndx
];
1391 tls_type
|= old_tls_type
;
1393 if (old_tls_type
!= tls_type
)
1396 hh
->tls_type
= tls_type
;
1398 hppa_elf_local_got_tls_type (abfd
) [r_symndx
] = tls_type
;
1404 if (need_entry
& NEED_PLT
)
1406 /* If we are creating a shared library, and this is a reloc
1407 against a weak symbol or a global symbol in a dynamic
1408 object, then we will be creating an import stub and a
1409 .plt entry for the symbol. Similarly, on a normal link
1410 to symbols defined in a dynamic object we'll need the
1411 import stub and a .plt entry. We don't know yet whether
1412 the symbol is defined or not, so make an entry anyway and
1413 clean up later in adjust_dynamic_symbol. */
1414 if ((sec
->flags
& SEC_ALLOC
) != 0)
1418 hh
->eh
.needs_plt
= 1;
1419 hh
->eh
.plt
.refcount
+= 1;
1421 /* If this .plt entry is for a plabel, mark it so
1422 that adjust_dynamic_symbol will keep the entry
1423 even if it appears to be local. */
1424 if (need_entry
& PLT_PLABEL
)
1427 else if (need_entry
& PLT_PLABEL
)
1429 bfd_signed_vma
*local_got_refcounts
;
1430 bfd_signed_vma
*local_plt_refcounts
;
1432 local_got_refcounts
= hppa32_elf_local_refcounts (abfd
);
1433 if (local_got_refcounts
== NULL
)
1435 local_plt_refcounts
= (local_got_refcounts
1436 + symtab_hdr
->sh_info
);
1437 local_plt_refcounts
[r_symndx
] += 1;
1442 if (need_entry
& NEED_DYNREL
)
1444 /* Flag this symbol as having a non-got, non-plt reference
1445 so that we generate copy relocs if it turns out to be
1447 if (hh
!= NULL
&& !bfd_link_pic (info
))
1448 hh
->eh
.non_got_ref
= 1;
1450 /* If we are creating a shared library then we need to copy
1451 the reloc into the shared library. However, if we are
1452 linking with -Bsymbolic, we need only copy absolute
1453 relocs or relocs against symbols that are not defined in
1454 an object we are including in the link. PC- or DP- or
1455 DLT-relative relocs against any local sym or global sym
1456 with DEF_REGULAR set, can be discarded. At this point we
1457 have not seen all the input files, so it is possible that
1458 DEF_REGULAR is not set now but will be set later (it is
1459 never cleared). We account for that possibility below by
1460 storing information in the dyn_relocs field of the
1463 A similar situation to the -Bsymbolic case occurs when
1464 creating shared libraries and symbol visibility changes
1465 render the symbol local.
1467 As it turns out, all the relocs we will be creating here
1468 are absolute, so we cannot remove them on -Bsymbolic
1469 links or visibility changes anyway. A STUB_REL reloc
1470 is absolute too, as in that case it is the reloc in the
1471 stub we will be creating, rather than copying the PCREL
1472 reloc in the branch.
1474 If on the other hand, we are creating an executable, we
1475 may need to keep relocations for symbols satisfied by a
1476 dynamic library if we manage to avoid copy relocs for the
1478 if ((bfd_link_pic (info
)
1479 && (sec
->flags
& SEC_ALLOC
) != 0
1480 && (IS_ABSOLUTE_RELOC (r_type
)
1482 && (!SYMBOLIC_BIND (info
, &hh
->eh
)
1483 || hh
->eh
.root
.type
== bfd_link_hash_defweak
1484 || !hh
->eh
.def_regular
))))
1485 || (ELIMINATE_COPY_RELOCS
1486 && !bfd_link_pic (info
)
1487 && (sec
->flags
& SEC_ALLOC
) != 0
1489 && (hh
->eh
.root
.type
== bfd_link_hash_defweak
1490 || !hh
->eh
.def_regular
)))
1492 struct elf32_hppa_dyn_reloc_entry
*hdh_p
;
1493 struct elf32_hppa_dyn_reloc_entry
**hdh_head
;
1495 /* Create a reloc section in dynobj and make room for
1499 sreloc
= _bfd_elf_make_dynamic_reloc_section
1500 (sec
, htab
->etab
.dynobj
, 2, abfd
, /*rela?*/ TRUE
);
1504 bfd_set_error (bfd_error_bad_value
);
1509 /* If this is a global symbol, we count the number of
1510 relocations we need for this symbol. */
1513 hdh_head
= &hh
->dyn_relocs
;
1517 /* Track dynamic relocs needed for local syms too.
1518 We really need local syms available to do this
1522 Elf_Internal_Sym
*isym
;
1524 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1529 sr
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1533 vpp
= &elf_section_data (sr
)->local_dynrel
;
1534 hdh_head
= (struct elf32_hppa_dyn_reloc_entry
**) vpp
;
1538 if (hdh_p
== NULL
|| hdh_p
->sec
!= sec
)
1540 hdh_p
= bfd_alloc (htab
->etab
.dynobj
, sizeof *hdh_p
);
1543 hdh_p
->hdh_next
= *hdh_head
;
1547 #if RELATIVE_DYNRELOCS
1548 hdh_p
->relative_count
= 0;
1553 #if RELATIVE_DYNRELOCS
1554 if (!IS_ABSOLUTE_RELOC (rtype
))
1555 hdh_p
->relative_count
+= 1;
1564 /* Return the section that should be marked against garbage collection
1565 for a given relocation. */
1568 elf32_hppa_gc_mark_hook (asection
*sec
,
1569 struct bfd_link_info
*info
,
1570 Elf_Internal_Rela
*rela
,
1571 struct elf_link_hash_entry
*hh
,
1572 Elf_Internal_Sym
*sym
)
1575 switch ((unsigned int) ELF32_R_TYPE (rela
->r_info
))
1577 case R_PARISC_GNU_VTINHERIT
:
1578 case R_PARISC_GNU_VTENTRY
:
1582 return _bfd_elf_gc_mark_hook (sec
, info
, rela
, hh
, sym
);
1585 /* Update the got and plt entry reference counts for the section being
1589 elf32_hppa_gc_sweep_hook (bfd
*abfd
,
1590 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1592 const Elf_Internal_Rela
*relocs
)
1594 Elf_Internal_Shdr
*symtab_hdr
;
1595 struct elf_link_hash_entry
**eh_syms
;
1596 bfd_signed_vma
*local_got_refcounts
;
1597 bfd_signed_vma
*local_plt_refcounts
;
1598 const Elf_Internal_Rela
*rela
, *relend
;
1599 struct elf32_hppa_link_hash_table
*htab
;
1601 if (bfd_link_relocatable (info
))
1604 htab
= hppa_link_hash_table (info
);
1608 elf_section_data (sec
)->local_dynrel
= NULL
;
1610 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1611 eh_syms
= elf_sym_hashes (abfd
);
1612 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1613 local_plt_refcounts
= local_got_refcounts
;
1614 if (local_plt_refcounts
!= NULL
)
1615 local_plt_refcounts
+= symtab_hdr
->sh_info
;
1617 relend
= relocs
+ sec
->reloc_count
;
1618 for (rela
= relocs
; rela
< relend
; rela
++)
1620 unsigned long r_symndx
;
1621 unsigned int r_type
;
1622 struct elf_link_hash_entry
*eh
= NULL
;
1624 r_symndx
= ELF32_R_SYM (rela
->r_info
);
1625 if (r_symndx
>= symtab_hdr
->sh_info
)
1627 struct elf32_hppa_link_hash_entry
*hh
;
1628 struct elf32_hppa_dyn_reloc_entry
**hdh_pp
;
1629 struct elf32_hppa_dyn_reloc_entry
*hdh_p
;
1631 eh
= eh_syms
[r_symndx
- symtab_hdr
->sh_info
];
1632 while (eh
->root
.type
== bfd_link_hash_indirect
1633 || eh
->root
.type
== bfd_link_hash_warning
)
1634 eh
= (struct elf_link_hash_entry
*) eh
->root
.u
.i
.link
;
1635 hh
= hppa_elf_hash_entry (eh
);
1637 for (hdh_pp
= &hh
->dyn_relocs
; (hdh_p
= *hdh_pp
) != NULL
; hdh_pp
= &hdh_p
->hdh_next
)
1638 if (hdh_p
->sec
== sec
)
1640 /* Everything must go for SEC. */
1641 *hdh_pp
= hdh_p
->hdh_next
;
1646 r_type
= ELF32_R_TYPE (rela
->r_info
);
1647 r_type
= elf32_hppa_optimized_tls_reloc (info
, r_type
, eh
!= NULL
);
1651 case R_PARISC_DLTIND14F
:
1652 case R_PARISC_DLTIND14R
:
1653 case R_PARISC_DLTIND21L
:
1654 case R_PARISC_TLS_GD21L
:
1655 case R_PARISC_TLS_GD14R
:
1656 case R_PARISC_TLS_IE21L
:
1657 case R_PARISC_TLS_IE14R
:
1660 if (eh
->got
.refcount
> 0)
1661 eh
->got
.refcount
-= 1;
1663 else if (local_got_refcounts
!= NULL
)
1665 if (local_got_refcounts
[r_symndx
] > 0)
1666 local_got_refcounts
[r_symndx
] -= 1;
1670 case R_PARISC_TLS_LDM21L
:
1671 case R_PARISC_TLS_LDM14R
:
1672 htab
->tls_ldm_got
.refcount
-= 1;
1675 case R_PARISC_PCREL12F
:
1676 case R_PARISC_PCREL17C
:
1677 case R_PARISC_PCREL17F
:
1678 case R_PARISC_PCREL22F
:
1681 if (eh
->plt
.refcount
> 0)
1682 eh
->plt
.refcount
-= 1;
1686 case R_PARISC_PLABEL14R
:
1687 case R_PARISC_PLABEL21L
:
1688 case R_PARISC_PLABEL32
:
1691 if (eh
->plt
.refcount
> 0)
1692 eh
->plt
.refcount
-= 1;
1694 else if (local_plt_refcounts
!= NULL
)
1696 if (local_plt_refcounts
[r_symndx
] > 0)
1697 local_plt_refcounts
[r_symndx
] -= 1;
1709 /* Support for core dump NOTE sections. */
1712 elf32_hppa_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
1717 switch (note
->descsz
)
1722 case 396: /* Linux/hppa */
1724 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
1727 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
1736 /* Make a ".reg/999" section. */
1737 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
1738 size
, note
->descpos
+ offset
);
1742 elf32_hppa_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
1744 switch (note
->descsz
)
1749 case 124: /* Linux/hppa elf_prpsinfo. */
1750 elf_tdata (abfd
)->core
->program
1751 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
1752 elf_tdata (abfd
)->core
->command
1753 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
1756 /* Note that for some reason, a spurious space is tacked
1757 onto the end of the args in some (at least one anyway)
1758 implementations, so strip it off if it exists. */
1760 char *command
= elf_tdata (abfd
)->core
->command
;
1761 int n
= strlen (command
);
1763 if (0 < n
&& command
[n
- 1] == ' ')
1764 command
[n
- 1] = '\0';
1770 /* Our own version of hide_symbol, so that we can keep plt entries for
1774 elf32_hppa_hide_symbol (struct bfd_link_info
*info
,
1775 struct elf_link_hash_entry
*eh
,
1776 bfd_boolean force_local
)
1780 eh
->forced_local
= 1;
1781 if (eh
->dynindx
!= -1)
1784 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1788 /* PR 16082: Remove version information from hidden symbol. */
1789 eh
->verinfo
.verdef
= NULL
;
1790 eh
->verinfo
.vertree
= NULL
;
1793 /* STT_GNU_IFUNC symbol must go through PLT. */
1794 if (! hppa_elf_hash_entry (eh
)->plabel
1795 && eh
->type
!= STT_GNU_IFUNC
)
1798 eh
->plt
= elf_hash_table (info
)->init_plt_offset
;
1802 /* Adjust a symbol defined by a dynamic object and referenced by a
1803 regular object. The current definition is in some section of the
1804 dynamic object, but we're not including those sections. We have to
1805 change the definition to something the rest of the link can
1809 elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1810 struct elf_link_hash_entry
*eh
)
1812 struct elf32_hppa_link_hash_table
*htab
;
1815 /* If this is a function, put it in the procedure linkage table. We
1816 will fill in the contents of the procedure linkage table later. */
1817 if (eh
->type
== STT_FUNC
1820 /* If the symbol is used by a plabel, we must allocate a PLT slot.
1821 The refcounts are not reliable when it has been hidden since
1822 hide_symbol can be called before the plabel flag is set. */
1823 if (hppa_elf_hash_entry (eh
)->plabel
1824 && eh
->plt
.refcount
<= 0)
1825 eh
->plt
.refcount
= 1;
1827 if (eh
->plt
.refcount
<= 0
1829 && eh
->root
.type
!= bfd_link_hash_defweak
1830 && ! hppa_elf_hash_entry (eh
)->plabel
1831 && (!bfd_link_pic (info
) || SYMBOLIC_BIND (info
, eh
))))
1833 /* The .plt entry is not needed when:
1834 a) Garbage collection has removed all references to the
1836 b) We know for certain the symbol is defined in this
1837 object, and it's not a weak definition, nor is the symbol
1838 used by a plabel relocation. Either this object is the
1839 application or we are doing a shared symbolic link. */
1841 eh
->plt
.offset
= (bfd_vma
) -1;
1848 eh
->plt
.offset
= (bfd_vma
) -1;
1850 /* If this is a weak symbol, and there is a real definition, the
1851 processor independent code will have arranged for us to see the
1852 real definition first, and we can just use the same value. */
1853 if (eh
->u
.weakdef
!= NULL
)
1855 if (eh
->u
.weakdef
->root
.type
!= bfd_link_hash_defined
1856 && eh
->u
.weakdef
->root
.type
!= bfd_link_hash_defweak
)
1858 eh
->root
.u
.def
.section
= eh
->u
.weakdef
->root
.u
.def
.section
;
1859 eh
->root
.u
.def
.value
= eh
->u
.weakdef
->root
.u
.def
.value
;
1860 if (ELIMINATE_COPY_RELOCS
)
1861 eh
->non_got_ref
= eh
->u
.weakdef
->non_got_ref
;
1865 /* This is a reference to a symbol defined by a dynamic object which
1866 is not a function. */
1868 /* If we are creating a shared library, we must presume that the
1869 only references to the symbol are via the global offset table.
1870 For such cases we need not do anything here; the relocations will
1871 be handled correctly by relocate_section. */
1872 if (bfd_link_pic (info
))
1875 /* If there are no references to this symbol that do not use the
1876 GOT, we don't need to generate a copy reloc. */
1877 if (!eh
->non_got_ref
)
1880 if (ELIMINATE_COPY_RELOCS
)
1882 struct elf32_hppa_link_hash_entry
*hh
;
1883 struct elf32_hppa_dyn_reloc_entry
*hdh_p
;
1885 hh
= hppa_elf_hash_entry (eh
);
1886 for (hdh_p
= hh
->dyn_relocs
; hdh_p
!= NULL
; hdh_p
= hdh_p
->hdh_next
)
1888 sec
= hdh_p
->sec
->output_section
;
1889 if (sec
!= NULL
&& (sec
->flags
& SEC_READONLY
) != 0)
1893 /* If we didn't find any dynamic relocs in read-only sections, then
1894 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1897 eh
->non_got_ref
= 0;
1902 /* We must allocate the symbol in our .dynbss section, which will
1903 become part of the .bss section of the executable. There will be
1904 an entry for this symbol in the .dynsym section. The dynamic
1905 object will contain position independent code, so all references
1906 from the dynamic object to this symbol will go through the global
1907 offset table. The dynamic linker will use the .dynsym entry to
1908 determine the address it must put in the global offset table, so
1909 both the dynamic object and the regular object will refer to the
1910 same memory location for the variable. */
1912 htab
= hppa_link_hash_table (info
);
1916 /* We must generate a COPY reloc to tell the dynamic linker to
1917 copy the initial value out of the dynamic object and into the
1918 runtime process image. */
1919 if ((eh
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && eh
->size
!= 0)
1921 htab
->srelbss
->size
+= sizeof (Elf32_External_Rela
);
1925 sec
= htab
->sdynbss
;
1927 return _bfd_elf_adjust_dynamic_copy (info
, eh
, sec
);
1930 /* Allocate space in the .plt for entries that won't have relocations.
1931 ie. plabel entries. */
1934 allocate_plt_static (struct elf_link_hash_entry
*eh
, void *inf
)
1936 struct bfd_link_info
*info
;
1937 struct elf32_hppa_link_hash_table
*htab
;
1938 struct elf32_hppa_link_hash_entry
*hh
;
1941 if (eh
->root
.type
== bfd_link_hash_indirect
)
1944 info
= (struct bfd_link_info
*) inf
;
1945 hh
= hppa_elf_hash_entry (eh
);
1946 htab
= hppa_link_hash_table (info
);
1950 if (htab
->etab
.dynamic_sections_created
1951 && eh
->plt
.refcount
> 0)
1953 /* Make sure this symbol is output as a dynamic symbol.
1954 Undefined weak syms won't yet be marked as dynamic. */
1955 if (eh
->dynindx
== -1
1956 && !eh
->forced_local
1957 && eh
->type
!= STT_PARISC_MILLI
)
1959 if (! bfd_elf_link_record_dynamic_symbol (info
, eh
))
1963 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info
), eh
))
1965 /* Allocate these later. From this point on, h->plabel
1966 means that the plt entry is only used by a plabel.
1967 We'll be using a normal plt entry for this symbol, so
1968 clear the plabel indicator. */
1972 else if (hh
->plabel
)
1974 /* Make an entry in the .plt section for plabel references
1975 that won't have a .plt entry for other reasons. */
1977 eh
->plt
.offset
= sec
->size
;
1978 sec
->size
+= PLT_ENTRY_SIZE
;
1982 /* No .plt entry needed. */
1983 eh
->plt
.offset
= (bfd_vma
) -1;
1989 eh
->plt
.offset
= (bfd_vma
) -1;
1996 /* Allocate space in .plt, .got and associated reloc sections for
2000 allocate_dynrelocs (struct elf_link_hash_entry
*eh
, void *inf
)
2002 struct bfd_link_info
*info
;
2003 struct elf32_hppa_link_hash_table
*htab
;
2005 struct elf32_hppa_link_hash_entry
*hh
;
2006 struct elf32_hppa_dyn_reloc_entry
*hdh_p
;
2008 if (eh
->root
.type
== bfd_link_hash_indirect
)
2012 htab
= hppa_link_hash_table (info
);
2016 hh
= hppa_elf_hash_entry (eh
);
2018 if (htab
->etab
.dynamic_sections_created
2019 && eh
->plt
.offset
!= (bfd_vma
) -1
2021 && eh
->plt
.refcount
> 0)
2023 /* Make an entry in the .plt section. */
2025 eh
->plt
.offset
= sec
->size
;
2026 sec
->size
+= PLT_ENTRY_SIZE
;
2028 /* We also need to make an entry in the .rela.plt section. */
2029 htab
->srelplt
->size
+= sizeof (Elf32_External_Rela
);
2030 htab
->need_plt_stub
= 1;
2033 if (eh
->got
.refcount
> 0)
2035 /* Make sure this symbol is output as a dynamic symbol.
2036 Undefined weak syms won't yet be marked as dynamic. */
2037 if (eh
->dynindx
== -1
2038 && !eh
->forced_local
2039 && eh
->type
!= STT_PARISC_MILLI
)
2041 if (! bfd_elf_link_record_dynamic_symbol (info
, eh
))
2046 eh
->got
.offset
= sec
->size
;
2047 sec
->size
+= GOT_ENTRY_SIZE
;
2048 /* R_PARISC_TLS_GD* needs two GOT entries */
2049 if ((hh
->tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
)) == (GOT_TLS_GD
| GOT_TLS_IE
))
2050 sec
->size
+= GOT_ENTRY_SIZE
* 2;
2051 else if ((hh
->tls_type
& GOT_TLS_GD
) == GOT_TLS_GD
)
2052 sec
->size
+= GOT_ENTRY_SIZE
;
2053 if (htab
->etab
.dynamic_sections_created
2054 && (bfd_link_pic (info
)
2055 || (eh
->dynindx
!= -1
2056 && !eh
->forced_local
)))
2058 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
2059 if ((hh
->tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
)) == (GOT_TLS_GD
| GOT_TLS_IE
))
2060 htab
->srelgot
->size
+= 2 * sizeof (Elf32_External_Rela
);
2061 else if ((hh
->tls_type
& GOT_TLS_GD
) == GOT_TLS_GD
)
2062 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
2066 eh
->got
.offset
= (bfd_vma
) -1;
2068 if (hh
->dyn_relocs
== NULL
)
2071 /* If this is a -Bsymbolic shared link, then we need to discard all
2072 space allocated for dynamic pc-relative relocs against symbols
2073 defined in a regular object. For the normal shared case, discard
2074 space for relocs that have become local due to symbol visibility
2076 if (bfd_link_pic (info
))
2078 #if RELATIVE_DYNRELOCS
2079 if (SYMBOL_CALLS_LOCAL (info
, eh
))
2081 struct elf32_hppa_dyn_reloc_entry
**hdh_pp
;
2083 for (hdh_pp
= &hh
->dyn_relocs
; (hdh_p
= *hdh_pp
) != NULL
; )
2085 hdh_p
->count
-= hdh_p
->relative_count
;
2086 hdh_p
->relative_count
= 0;
2087 if (hdh_p
->count
== 0)
2088 *hdh_pp
= hdh_p
->hdh_next
;
2090 hdh_pp
= &hdh_p
->hdh_next
;
2095 /* Also discard relocs on undefined weak syms with non-default
2097 if (hh
->dyn_relocs
!= NULL
2098 && eh
->root
.type
== bfd_link_hash_undefweak
)
2100 if (ELF_ST_VISIBILITY (eh
->other
) != STV_DEFAULT
)
2101 hh
->dyn_relocs
= NULL
;
2103 /* Make sure undefined weak symbols are output as a dynamic
2105 else if (eh
->dynindx
== -1
2106 && !eh
->forced_local
)
2108 if (! bfd_elf_link_record_dynamic_symbol (info
, eh
))
2115 /* For the non-shared case, discard space for relocs against
2116 symbols which turn out to need copy relocs or are not
2119 if (!eh
->non_got_ref
2120 && ((ELIMINATE_COPY_RELOCS
2122 && !eh
->def_regular
)
2123 || (htab
->etab
.dynamic_sections_created
2124 && (eh
->root
.type
== bfd_link_hash_undefweak
2125 || eh
->root
.type
== bfd_link_hash_undefined
))))
2127 /* Make sure this symbol is output as a dynamic symbol.
2128 Undefined weak syms won't yet be marked as dynamic. */
2129 if (eh
->dynindx
== -1
2130 && !eh
->forced_local
2131 && eh
->type
!= STT_PARISC_MILLI
)
2133 if (! bfd_elf_link_record_dynamic_symbol (info
, eh
))
2137 /* If that succeeded, we know we'll be keeping all the
2139 if (eh
->dynindx
!= -1)
2143 hh
->dyn_relocs
= NULL
;
2149 /* Finally, allocate space. */
2150 for (hdh_p
= hh
->dyn_relocs
; hdh_p
!= NULL
; hdh_p
= hdh_p
->hdh_next
)
2152 asection
*sreloc
= elf_section_data (hdh_p
->sec
)->sreloc
;
2153 sreloc
->size
+= hdh_p
->count
* sizeof (Elf32_External_Rela
);
2159 /* This function is called via elf_link_hash_traverse to force
2160 millicode symbols local so they do not end up as globals in the
2161 dynamic symbol table. We ought to be able to do this in
2162 adjust_dynamic_symbol, but our adjust_dynamic_symbol is not called
2163 for all dynamic symbols. Arguably, this is a bug in
2164 elf_adjust_dynamic_symbol. */
2167 clobber_millicode_symbols (struct elf_link_hash_entry
*eh
,
2168 struct bfd_link_info
*info
)
2170 if (eh
->type
== STT_PARISC_MILLI
2171 && !eh
->forced_local
)
2173 elf32_hppa_hide_symbol (info
, eh
, TRUE
);
2178 /* Find any dynamic relocs that apply to read-only sections. */
2181 readonly_dynrelocs (struct elf_link_hash_entry
*eh
, void *inf
)
2183 struct elf32_hppa_link_hash_entry
*hh
;
2184 struct elf32_hppa_dyn_reloc_entry
*hdh_p
;
2186 hh
= hppa_elf_hash_entry (eh
);
2187 for (hdh_p
= hh
->dyn_relocs
; hdh_p
!= NULL
; hdh_p
= hdh_p
->hdh_next
)
2189 asection
*sec
= hdh_p
->sec
->output_section
;
2191 if (sec
!= NULL
&& (sec
->flags
& SEC_READONLY
) != 0)
2193 struct bfd_link_info
*info
= inf
;
2195 info
->flags
|= DF_TEXTREL
;
2197 /* Not an error, just cut short the traversal. */
2204 /* Set the sizes of the dynamic sections. */
2207 elf32_hppa_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2208 struct bfd_link_info
*info
)
2210 struct elf32_hppa_link_hash_table
*htab
;
2216 htab
= hppa_link_hash_table (info
);
2220 dynobj
= htab
->etab
.dynobj
;
2224 if (htab
->etab
.dynamic_sections_created
)
2226 /* Set the contents of the .interp section to the interpreter. */
2227 if (bfd_link_executable (info
) && !info
->nointerp
)
2229 sec
= bfd_get_linker_section (dynobj
, ".interp");
2232 sec
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2233 sec
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2236 /* Force millicode symbols local. */
2237 elf_link_hash_traverse (&htab
->etab
,
2238 clobber_millicode_symbols
,
2242 /* Set up .got and .plt offsets for local syms, and space for local
2244 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2246 bfd_signed_vma
*local_got
;
2247 bfd_signed_vma
*end_local_got
;
2248 bfd_signed_vma
*local_plt
;
2249 bfd_signed_vma
*end_local_plt
;
2250 bfd_size_type locsymcount
;
2251 Elf_Internal_Shdr
*symtab_hdr
;
2253 char *local_tls_type
;
2255 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
2258 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2260 struct elf32_hppa_dyn_reloc_entry
*hdh_p
;
2262 for (hdh_p
= ((struct elf32_hppa_dyn_reloc_entry
*)
2263 elf_section_data (sec
)->local_dynrel
);
2265 hdh_p
= hdh_p
->hdh_next
)
2267 if (!bfd_is_abs_section (hdh_p
->sec
)
2268 && bfd_is_abs_section (hdh_p
->sec
->output_section
))
2270 /* Input section has been discarded, either because
2271 it is a copy of a linkonce section or due to
2272 linker script /DISCARD/, so we'll be discarding
2275 else if (hdh_p
->count
!= 0)
2277 srel
= elf_section_data (hdh_p
->sec
)->sreloc
;
2278 srel
->size
+= hdh_p
->count
* sizeof (Elf32_External_Rela
);
2279 if ((hdh_p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
2280 info
->flags
|= DF_TEXTREL
;
2285 local_got
= elf_local_got_refcounts (ibfd
);
2289 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2290 locsymcount
= symtab_hdr
->sh_info
;
2291 end_local_got
= local_got
+ locsymcount
;
2292 local_tls_type
= hppa_elf_local_got_tls_type (ibfd
);
2294 srel
= htab
->srelgot
;
2295 for (; local_got
< end_local_got
; ++local_got
)
2299 *local_got
= sec
->size
;
2300 sec
->size
+= GOT_ENTRY_SIZE
;
2301 if ((*local_tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
)) == (GOT_TLS_GD
| GOT_TLS_IE
))
2302 sec
->size
+= 2 * GOT_ENTRY_SIZE
;
2303 else if ((*local_tls_type
& GOT_TLS_GD
) == GOT_TLS_GD
)
2304 sec
->size
+= GOT_ENTRY_SIZE
;
2305 if (bfd_link_pic (info
))
2307 srel
->size
+= sizeof (Elf32_External_Rela
);
2308 if ((*local_tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
)) == (GOT_TLS_GD
| GOT_TLS_IE
))
2309 srel
->size
+= 2 * sizeof (Elf32_External_Rela
);
2310 else if ((*local_tls_type
& GOT_TLS_GD
) == GOT_TLS_GD
)
2311 srel
->size
+= sizeof (Elf32_External_Rela
);
2315 *local_got
= (bfd_vma
) -1;
2320 local_plt
= end_local_got
;
2321 end_local_plt
= local_plt
+ locsymcount
;
2322 if (! htab
->etab
.dynamic_sections_created
)
2324 /* Won't be used, but be safe. */
2325 for (; local_plt
< end_local_plt
; ++local_plt
)
2326 *local_plt
= (bfd_vma
) -1;
2331 srel
= htab
->srelplt
;
2332 for (; local_plt
< end_local_plt
; ++local_plt
)
2336 *local_plt
= sec
->size
;
2337 sec
->size
+= PLT_ENTRY_SIZE
;
2338 if (bfd_link_pic (info
))
2339 srel
->size
+= sizeof (Elf32_External_Rela
);
2342 *local_plt
= (bfd_vma
) -1;
2347 if (htab
->tls_ldm_got
.refcount
> 0)
2349 /* Allocate 2 got entries and 1 dynamic reloc for
2350 R_PARISC_TLS_DTPMOD32 relocs. */
2351 htab
->tls_ldm_got
.offset
= htab
->sgot
->size
;
2352 htab
->sgot
->size
+= (GOT_ENTRY_SIZE
* 2);
2353 htab
->srelgot
->size
+= sizeof (Elf32_External_Rela
);
2356 htab
->tls_ldm_got
.offset
= -1;
2358 /* Do all the .plt entries without relocs first. The dynamic linker
2359 uses the last .plt reloc to find the end of the .plt (and hence
2360 the start of the .got) for lazy linking. */
2361 elf_link_hash_traverse (&htab
->etab
, allocate_plt_static
, info
);
2363 /* Allocate global sym .plt and .got entries, and space for global
2364 sym dynamic relocs. */
2365 elf_link_hash_traverse (&htab
->etab
, allocate_dynrelocs
, info
);
2367 /* The check_relocs and adjust_dynamic_symbol entry points have
2368 determined the sizes of the various dynamic sections. Allocate
2371 for (sec
= dynobj
->sections
; sec
!= NULL
; sec
= sec
->next
)
2373 if ((sec
->flags
& SEC_LINKER_CREATED
) == 0)
2376 if (sec
== htab
->splt
)
2378 if (htab
->need_plt_stub
)
2380 /* Make space for the plt stub at the end of the .plt
2381 section. We want this stub right at the end, up
2382 against the .got section. */
2383 int gotalign
= bfd_section_alignment (dynobj
, htab
->sgot
);
2384 int pltalign
= bfd_section_alignment (dynobj
, sec
);
2387 if (gotalign
> pltalign
)
2388 (void) bfd_set_section_alignment (dynobj
, sec
, gotalign
);
2389 mask
= ((bfd_size_type
) 1 << gotalign
) - 1;
2390 sec
->size
= (sec
->size
+ sizeof (plt_stub
) + mask
) & ~mask
;
2393 else if (sec
== htab
->sgot
2394 || sec
== htab
->sdynbss
)
2396 else if (CONST_STRNEQ (bfd_get_section_name (dynobj
, sec
), ".rela"))
2400 /* Remember whether there are any reloc sections other
2402 if (sec
!= htab
->srelplt
)
2405 /* We use the reloc_count field as a counter if we need
2406 to copy relocs into the output file. */
2407 sec
->reloc_count
= 0;
2412 /* It's not one of our sections, so don't allocate space. */
2418 /* If we don't need this section, strip it from the
2419 output file. This is mostly to handle .rela.bss and
2420 .rela.plt. We must create both sections in
2421 create_dynamic_sections, because they must be created
2422 before the linker maps input sections to output
2423 sections. The linker does that before
2424 adjust_dynamic_symbol is called, and it is that
2425 function which decides whether anything needs to go
2426 into these sections. */
2427 sec
->flags
|= SEC_EXCLUDE
;
2431 if ((sec
->flags
& SEC_HAS_CONTENTS
) == 0)
2434 /* Allocate memory for the section contents. Zero it, because
2435 we may not fill in all the reloc sections. */
2436 sec
->contents
= bfd_zalloc (dynobj
, sec
->size
);
2437 if (sec
->contents
== NULL
)
2441 if (htab
->etab
.dynamic_sections_created
)
2443 /* Like IA-64 and HPPA64, always create a DT_PLTGOT. It
2444 actually has nothing to do with the PLT, it is how we
2445 communicate the LTP value of a load module to the dynamic
2447 #define add_dynamic_entry(TAG, VAL) \
2448 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2450 if (!add_dynamic_entry (DT_PLTGOT
, 0))
2453 /* Add some entries to the .dynamic section. We fill in the
2454 values later, in elf32_hppa_finish_dynamic_sections, but we
2455 must add the entries now so that we get the correct size for
2456 the .dynamic section. The DT_DEBUG entry is filled in by the
2457 dynamic linker and used by the debugger. */
2458 if (bfd_link_executable (info
))
2460 if (!add_dynamic_entry (DT_DEBUG
, 0))
2464 if (htab
->srelplt
->size
!= 0)
2466 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
2467 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
2468 || !add_dynamic_entry (DT_JMPREL
, 0))
2474 if (!add_dynamic_entry (DT_RELA
, 0)
2475 || !add_dynamic_entry (DT_RELASZ
, 0)
2476 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
2479 /* If any dynamic relocs apply to a read-only section,
2480 then we need a DT_TEXTREL entry. */
2481 if ((info
->flags
& DF_TEXTREL
) == 0)
2482 elf_link_hash_traverse (&htab
->etab
, readonly_dynrelocs
, info
);
2484 if ((info
->flags
& DF_TEXTREL
) != 0)
2486 if (!add_dynamic_entry (DT_TEXTREL
, 0))
2491 #undef add_dynamic_entry
2496 /* External entry points for sizing and building linker stubs. */
2498 /* Set up various things so that we can make a list of input sections
2499 for each output section included in the link. Returns -1 on error,
2500 0 when no stubs will be needed, and 1 on success. */
2503 elf32_hppa_setup_section_lists (bfd
*output_bfd
, struct bfd_link_info
*info
)
2506 unsigned int bfd_count
;
2507 unsigned int top_id
, top_index
;
2509 asection
**input_list
, **list
;
2511 struct elf32_hppa_link_hash_table
*htab
= hppa_link_hash_table (info
);
2516 /* Count the number of input BFDs and find the top input section id. */
2517 for (input_bfd
= info
->input_bfds
, bfd_count
= 0, top_id
= 0;
2519 input_bfd
= input_bfd
->link
.next
)
2522 for (section
= input_bfd
->sections
;
2524 section
= section
->next
)
2526 if (top_id
< section
->id
)
2527 top_id
= section
->id
;
2530 htab
->bfd_count
= bfd_count
;
2532 amt
= sizeof (struct map_stub
) * (top_id
+ 1);
2533 htab
->stub_group
= bfd_zmalloc (amt
);
2534 if (htab
->stub_group
== NULL
)
2537 /* We can't use output_bfd->section_count here to find the top output
2538 section index as some sections may have been removed, and
2539 strip_excluded_output_sections doesn't renumber the indices. */
2540 for (section
= output_bfd
->sections
, top_index
= 0;
2542 section
= section
->next
)
2544 if (top_index
< section
->index
)
2545 top_index
= section
->index
;
2548 htab
->top_index
= top_index
;
2549 amt
= sizeof (asection
*) * (top_index
+ 1);
2550 input_list
= bfd_malloc (amt
);
2551 htab
->input_list
= input_list
;
2552 if (input_list
== NULL
)
2555 /* For sections we aren't interested in, mark their entries with a
2556 value we can check later. */
2557 list
= input_list
+ top_index
;
2559 *list
= bfd_abs_section_ptr
;
2560 while (list
-- != input_list
);
2562 for (section
= output_bfd
->sections
;
2564 section
= section
->next
)
2566 if ((section
->flags
& SEC_CODE
) != 0)
2567 input_list
[section
->index
] = NULL
;
2573 /* The linker repeatedly calls this function for each input section,
2574 in the order that input sections are linked into output sections.
2575 Build lists of input sections to determine groupings between which
2576 we may insert linker stubs. */
2579 elf32_hppa_next_input_section (struct bfd_link_info
*info
, asection
*isec
)
2581 struct elf32_hppa_link_hash_table
*htab
= hppa_link_hash_table (info
);
2586 if (isec
->output_section
->index
<= htab
->top_index
)
2588 asection
**list
= htab
->input_list
+ isec
->output_section
->index
;
2589 if (*list
!= bfd_abs_section_ptr
)
2591 /* Steal the link_sec pointer for our list. */
2592 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
2593 /* This happens to make the list in reverse order,
2594 which is what we want. */
2595 PREV_SEC (isec
) = *list
;
2601 /* See whether we can group stub sections together. Grouping stub
2602 sections may result in fewer stubs. More importantly, we need to
2603 put all .init* and .fini* stubs at the beginning of the .init or
2604 .fini output sections respectively, because glibc splits the
2605 _init and _fini functions into multiple parts. Putting a stub in
2606 the middle of a function is not a good idea. */
2609 group_sections (struct elf32_hppa_link_hash_table
*htab
,
2610 bfd_size_type stub_group_size
,
2611 bfd_boolean stubs_always_before_branch
)
2613 asection
**list
= htab
->input_list
+ htab
->top_index
;
2616 asection
*tail
= *list
;
2617 if (tail
== bfd_abs_section_ptr
)
2619 while (tail
!= NULL
)
2623 bfd_size_type total
;
2624 bfd_boolean big_sec
;
2628 big_sec
= total
>= stub_group_size
;
2630 while ((prev
= PREV_SEC (curr
)) != NULL
2631 && ((total
+= curr
->output_offset
- prev
->output_offset
)
2635 /* OK, the size from the start of CURR to the end is less
2636 than 240000 bytes and thus can be handled by one stub
2637 section. (or the tail section is itself larger than
2638 240000 bytes, in which case we may be toast.)
2639 We should really be keeping track of the total size of
2640 stubs added here, as stubs contribute to the final output
2641 section size. That's a little tricky, and this way will
2642 only break if stubs added total more than 22144 bytes, or
2643 2768 long branch stubs. It seems unlikely for more than
2644 2768 different functions to be called, especially from
2645 code only 240000 bytes long. This limit used to be
2646 250000, but c++ code tends to generate lots of little
2647 functions, and sometimes violated the assumption. */
2650 prev
= PREV_SEC (tail
);
2651 /* Set up this stub group. */
2652 htab
->stub_group
[tail
->id
].link_sec
= curr
;
2654 while (tail
!= curr
&& (tail
= prev
) != NULL
);
2656 /* But wait, there's more! Input sections up to 240000
2657 bytes before the stub section can be handled by it too.
2658 Don't do this if we have a really large section after the
2659 stubs, as adding more stubs increases the chance that
2660 branches may not reach into the stub section. */
2661 if (!stubs_always_before_branch
&& !big_sec
)
2665 && ((total
+= tail
->output_offset
- prev
->output_offset
)
2669 prev
= PREV_SEC (tail
);
2670 htab
->stub_group
[tail
->id
].link_sec
= curr
;
2676 while (list
-- != htab
->input_list
);
2677 free (htab
->input_list
);
2681 /* Read in all local syms for all input bfds, and create hash entries
2682 for export stubs if we are building a multi-subspace shared lib.
2683 Returns -1 on error, 1 if export stubs created, 0 otherwise. */
2686 get_local_syms (bfd
*output_bfd
, bfd
*input_bfd
, struct bfd_link_info
*info
)
2688 unsigned int bfd_indx
;
2689 Elf_Internal_Sym
*local_syms
, **all_local_syms
;
2690 int stub_changed
= 0;
2691 struct elf32_hppa_link_hash_table
*htab
= hppa_link_hash_table (info
);
2696 /* We want to read in symbol extension records only once. To do this
2697 we need to read in the local symbols in parallel and save them for
2698 later use; so hold pointers to the local symbols in an array. */
2699 bfd_size_type amt
= sizeof (Elf_Internal_Sym
*) * htab
->bfd_count
;
2700 all_local_syms
= bfd_zmalloc (amt
);
2701 htab
->all_local_syms
= all_local_syms
;
2702 if (all_local_syms
== NULL
)
2705 /* Walk over all the input BFDs, swapping in local symbols.
2706 If we are creating a shared library, create hash entries for the
2710 input_bfd
= input_bfd
->link
.next
, bfd_indx
++)
2712 Elf_Internal_Shdr
*symtab_hdr
;
2714 /* We'll need the symbol table in a second. */
2715 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2716 if (symtab_hdr
->sh_info
== 0)
2719 /* We need an array of the local symbols attached to the input bfd. */
2720 local_syms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2721 if (local_syms
== NULL
)
2723 local_syms
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
2724 symtab_hdr
->sh_info
, 0,
2726 /* Cache them for elf_link_input_bfd. */
2727 symtab_hdr
->contents
= (unsigned char *) local_syms
;
2729 if (local_syms
== NULL
)
2732 all_local_syms
[bfd_indx
] = local_syms
;
2734 if (bfd_link_pic (info
) && htab
->multi_subspace
)
2736 struct elf_link_hash_entry
**eh_syms
;
2737 struct elf_link_hash_entry
**eh_symend
;
2738 unsigned int symcount
;
2740 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
2741 - symtab_hdr
->sh_info
);
2742 eh_syms
= (struct elf_link_hash_entry
**) elf_sym_hashes (input_bfd
);
2743 eh_symend
= (struct elf_link_hash_entry
**) (eh_syms
+ symcount
);
2745 /* Look through the global syms for functions; We need to
2746 build export stubs for all globally visible functions. */
2747 for (; eh_syms
< eh_symend
; eh_syms
++)
2749 struct elf32_hppa_link_hash_entry
*hh
;
2751 hh
= hppa_elf_hash_entry (*eh_syms
);
2753 while (hh
->eh
.root
.type
== bfd_link_hash_indirect
2754 || hh
->eh
.root
.type
== bfd_link_hash_warning
)
2755 hh
= hppa_elf_hash_entry (hh
->eh
.root
.u
.i
.link
);
2757 /* At this point in the link, undefined syms have been
2758 resolved, so we need to check that the symbol was
2759 defined in this BFD. */
2760 if ((hh
->eh
.root
.type
== bfd_link_hash_defined
2761 || hh
->eh
.root
.type
== bfd_link_hash_defweak
)
2762 && hh
->eh
.type
== STT_FUNC
2763 && hh
->eh
.root
.u
.def
.section
->output_section
!= NULL
2764 && (hh
->eh
.root
.u
.def
.section
->output_section
->owner
2766 && hh
->eh
.root
.u
.def
.section
->owner
== input_bfd
2767 && hh
->eh
.def_regular
2768 && !hh
->eh
.forced_local
2769 && ELF_ST_VISIBILITY (hh
->eh
.other
) == STV_DEFAULT
)
2772 const char *stub_name
;
2773 struct elf32_hppa_stub_hash_entry
*hsh
;
2775 sec
= hh
->eh
.root
.u
.def
.section
;
2776 stub_name
= hh_name (hh
);
2777 hsh
= hppa_stub_hash_lookup (&htab
->bstab
,
2782 hsh
= hppa_add_stub (stub_name
, sec
, htab
);
2786 hsh
->target_value
= hh
->eh
.root
.u
.def
.value
;
2787 hsh
->target_section
= hh
->eh
.root
.u
.def
.section
;
2788 hsh
->stub_type
= hppa_stub_export
;
2794 /* xgettext:c-format */
2795 _bfd_error_handler (_("%B: duplicate export stub %s"),
2796 input_bfd
, stub_name
);
2803 return stub_changed
;
2806 /* Determine and set the size of the stub section for a final link.
2808 The basic idea here is to examine all the relocations looking for
2809 PC-relative calls to a target that is unreachable with a "bl"
2813 elf32_hppa_size_stubs
2814 (bfd
*output_bfd
, bfd
*stub_bfd
, struct bfd_link_info
*info
,
2815 bfd_boolean multi_subspace
, bfd_signed_vma group_size
,
2816 asection
* (*add_stub_section
) (const char *, asection
*),
2817 void (*layout_sections_again
) (void))
2819 bfd_size_type stub_group_size
;
2820 bfd_boolean stubs_always_before_branch
;
2821 bfd_boolean stub_changed
;
2822 struct elf32_hppa_link_hash_table
*htab
= hppa_link_hash_table (info
);
2827 /* Stash our params away. */
2828 htab
->stub_bfd
= stub_bfd
;
2829 htab
->multi_subspace
= multi_subspace
;
2830 htab
->add_stub_section
= add_stub_section
;
2831 htab
->layout_sections_again
= layout_sections_again
;
2832 stubs_always_before_branch
= group_size
< 0;
2834 stub_group_size
= -group_size
;
2836 stub_group_size
= group_size
;
2837 if (stub_group_size
== 1)
2839 /* Default values. */
2840 if (stubs_always_before_branch
)
2842 stub_group_size
= 7680000;
2843 if (htab
->has_17bit_branch
|| htab
->multi_subspace
)
2844 stub_group_size
= 240000;
2845 if (htab
->has_12bit_branch
)
2846 stub_group_size
= 7500;
2850 stub_group_size
= 6971392;
2851 if (htab
->has_17bit_branch
|| htab
->multi_subspace
)
2852 stub_group_size
= 217856;
2853 if (htab
->has_12bit_branch
)
2854 stub_group_size
= 6808;
2858 group_sections (htab
, stub_group_size
, stubs_always_before_branch
);
2860 switch (get_local_syms (output_bfd
, info
->input_bfds
, info
))
2863 if (htab
->all_local_syms
)
2864 goto error_ret_free_local
;
2868 stub_changed
= FALSE
;
2872 stub_changed
= TRUE
;
2879 unsigned int bfd_indx
;
2882 for (input_bfd
= info
->input_bfds
, bfd_indx
= 0;
2884 input_bfd
= input_bfd
->link
.next
, bfd_indx
++)
2886 Elf_Internal_Shdr
*symtab_hdr
;
2888 Elf_Internal_Sym
*local_syms
;
2890 /* We'll need the symbol table in a second. */
2891 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2892 if (symtab_hdr
->sh_info
== 0)
2895 local_syms
= htab
->all_local_syms
[bfd_indx
];
2897 /* Walk over each section attached to the input bfd. */
2898 for (section
= input_bfd
->sections
;
2900 section
= section
->next
)
2902 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
2904 /* If there aren't any relocs, then there's nothing more
2906 if ((section
->flags
& SEC_RELOC
) == 0
2907 || section
->reloc_count
== 0)
2910 /* If this section is a link-once section that will be
2911 discarded, then don't create any stubs. */
2912 if (section
->output_section
== NULL
2913 || section
->output_section
->owner
!= output_bfd
)
2916 /* Get the relocs. */
2918 = _bfd_elf_link_read_relocs (input_bfd
, section
, NULL
, NULL
,
2920 if (internal_relocs
== NULL
)
2921 goto error_ret_free_local
;
2923 /* Now examine each relocation. */
2924 irela
= internal_relocs
;
2925 irelaend
= irela
+ section
->reloc_count
;
2926 for (; irela
< irelaend
; irela
++)
2928 unsigned int r_type
, r_indx
;
2929 enum elf32_hppa_stub_type stub_type
;
2930 struct elf32_hppa_stub_hash_entry
*hsh
;
2933 bfd_vma destination
;
2934 struct elf32_hppa_link_hash_entry
*hh
;
2936 const asection
*id_sec
;
2938 r_type
= ELF32_R_TYPE (irela
->r_info
);
2939 r_indx
= ELF32_R_SYM (irela
->r_info
);
2941 if (r_type
>= (unsigned int) R_PARISC_UNIMPLEMENTED
)
2943 bfd_set_error (bfd_error_bad_value
);
2944 error_ret_free_internal
:
2945 if (elf_section_data (section
)->relocs
== NULL
)
2946 free (internal_relocs
);
2947 goto error_ret_free_local
;
2950 /* Only look for stubs on call instructions. */
2951 if (r_type
!= (unsigned int) R_PARISC_PCREL12F
2952 && r_type
!= (unsigned int) R_PARISC_PCREL17F
2953 && r_type
!= (unsigned int) R_PARISC_PCREL22F
)
2956 /* Now determine the call target, its name, value,
2962 if (r_indx
< symtab_hdr
->sh_info
)
2964 /* It's a local symbol. */
2965 Elf_Internal_Sym
*sym
;
2966 Elf_Internal_Shdr
*hdr
;
2969 sym
= local_syms
+ r_indx
;
2970 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
2971 sym_value
= sym
->st_value
;
2972 shndx
= sym
->st_shndx
;
2973 if (shndx
< elf_numsections (input_bfd
))
2975 hdr
= elf_elfsections (input_bfd
)[shndx
];
2976 sym_sec
= hdr
->bfd_section
;
2977 destination
= (sym_value
+ irela
->r_addend
2978 + sym_sec
->output_offset
2979 + sym_sec
->output_section
->vma
);
2984 /* It's an external symbol. */
2987 e_indx
= r_indx
- symtab_hdr
->sh_info
;
2988 hh
= hppa_elf_hash_entry (elf_sym_hashes (input_bfd
)[e_indx
]);
2990 while (hh
->eh
.root
.type
== bfd_link_hash_indirect
2991 || hh
->eh
.root
.type
== bfd_link_hash_warning
)
2992 hh
= hppa_elf_hash_entry (hh
->eh
.root
.u
.i
.link
);
2994 if (hh
->eh
.root
.type
== bfd_link_hash_defined
2995 || hh
->eh
.root
.type
== bfd_link_hash_defweak
)
2997 sym_sec
= hh
->eh
.root
.u
.def
.section
;
2998 sym_value
= hh
->eh
.root
.u
.def
.value
;
2999 if (sym_sec
->output_section
!= NULL
)
3000 destination
= (sym_value
+ irela
->r_addend
3001 + sym_sec
->output_offset
3002 + sym_sec
->output_section
->vma
);
3004 else if (hh
->eh
.root
.type
== bfd_link_hash_undefweak
)
3006 if (! bfd_link_pic (info
))
3009 else if (hh
->eh
.root
.type
== bfd_link_hash_undefined
)
3011 if (! (info
->unresolved_syms_in_objects
== RM_IGNORE
3012 && (ELF_ST_VISIBILITY (hh
->eh
.other
)
3014 && hh
->eh
.type
!= STT_PARISC_MILLI
))
3019 bfd_set_error (bfd_error_bad_value
);
3020 goto error_ret_free_internal
;
3024 /* Determine what (if any) linker stub is needed. */
3025 stub_type
= hppa_type_of_stub (section
, irela
, hh
,
3027 if (stub_type
== hppa_stub_none
)
3030 /* Support for grouping stub sections. */
3031 id_sec
= htab
->stub_group
[section
->id
].link_sec
;
3033 /* Get the name of this stub. */
3034 stub_name
= hppa_stub_name (id_sec
, sym_sec
, hh
, irela
);
3036 goto error_ret_free_internal
;
3038 hsh
= hppa_stub_hash_lookup (&htab
->bstab
,
3043 /* The proper stub has already been created. */
3048 hsh
= hppa_add_stub (stub_name
, section
, htab
);
3052 goto error_ret_free_internal
;
3055 hsh
->target_value
= sym_value
;
3056 hsh
->target_section
= sym_sec
;
3057 hsh
->stub_type
= stub_type
;
3058 if (bfd_link_pic (info
))
3060 if (stub_type
== hppa_stub_import
)
3061 hsh
->stub_type
= hppa_stub_import_shared
;
3062 else if (stub_type
== hppa_stub_long_branch
)
3063 hsh
->stub_type
= hppa_stub_long_branch_shared
;
3066 stub_changed
= TRUE
;
3069 /* We're done with the internal relocs, free them. */
3070 if (elf_section_data (section
)->relocs
== NULL
)
3071 free (internal_relocs
);
3078 /* OK, we've added some stubs. Find out the new size of the
3080 for (stub_sec
= htab
->stub_bfd
->sections
;
3082 stub_sec
= stub_sec
->next
)
3083 if ((stub_sec
->flags
& SEC_LINKER_CREATED
) == 0)
3086 bfd_hash_traverse (&htab
->bstab
, hppa_size_one_stub
, htab
);
3088 /* Ask the linker to do its stuff. */
3089 (*htab
->layout_sections_again
) ();
3090 stub_changed
= FALSE
;
3093 free (htab
->all_local_syms
);
3096 error_ret_free_local
:
3097 free (htab
->all_local_syms
);
3101 /* For a final link, this function is called after we have sized the
3102 stubs to provide a value for __gp. */
3105 elf32_hppa_set_gp (bfd
*abfd
, struct bfd_link_info
*info
)
3107 struct bfd_link_hash_entry
*h
;
3108 asection
*sec
= NULL
;
3110 struct elf32_hppa_link_hash_table
*htab
;
3112 htab
= hppa_link_hash_table (info
);
3116 h
= bfd_link_hash_lookup (&htab
->etab
.root
, "$global$", FALSE
, FALSE
, FALSE
);
3119 && (h
->type
== bfd_link_hash_defined
3120 || h
->type
== bfd_link_hash_defweak
))
3122 gp_val
= h
->u
.def
.value
;
3123 sec
= h
->u
.def
.section
;
3127 asection
*splt
= bfd_get_section_by_name (abfd
, ".plt");
3128 asection
*sgot
= bfd_get_section_by_name (abfd
, ".got");
3130 /* Choose to point our LTP at, in this order, one of .plt, .got,
3131 or .data, if these sections exist. In the case of choosing
3132 .plt try to make the LTP ideal for addressing anywhere in the
3133 .plt or .got with a 14 bit signed offset. Typically, the end
3134 of the .plt is the start of the .got, so choose .plt + 0x2000
3135 if either the .plt or .got is larger than 0x2000. If both
3136 the .plt and .got are smaller than 0x2000, choose the end of
3137 the .plt section. */
3138 sec
= strcmp (bfd_get_target (abfd
), "elf32-hppa-netbsd") == 0
3143 if (gp_val
> 0x2000 || (sgot
&& sgot
->size
> 0x2000))
3153 if (strcmp (bfd_get_target (abfd
), "elf32-hppa-netbsd") != 0)
3155 /* We know we don't have a .plt. If .got is large,
3157 if (sec
->size
> 0x2000)
3163 /* No .plt or .got. Who cares what the LTP is? */
3164 sec
= bfd_get_section_by_name (abfd
, ".data");
3170 h
->type
= bfd_link_hash_defined
;
3171 h
->u
.def
.value
= gp_val
;
3173 h
->u
.def
.section
= sec
;
3175 h
->u
.def
.section
= bfd_abs_section_ptr
;
3179 if (sec
!= NULL
&& sec
->output_section
!= NULL
)
3180 gp_val
+= sec
->output_section
->vma
+ sec
->output_offset
;
3182 elf_gp (abfd
) = gp_val
;
3186 /* Build all the stubs associated with the current output file. The
3187 stubs are kept in a hash table attached to the main linker hash
3188 table. We also set up the .plt entries for statically linked PIC
3189 functions here. This function is called via hppaelf_finish in the
3193 elf32_hppa_build_stubs (struct bfd_link_info
*info
)
3196 struct bfd_hash_table
*table
;
3197 struct elf32_hppa_link_hash_table
*htab
;
3199 htab
= hppa_link_hash_table (info
);
3203 for (stub_sec
= htab
->stub_bfd
->sections
;
3205 stub_sec
= stub_sec
->next
)
3206 if ((stub_sec
->flags
& SEC_LINKER_CREATED
) == 0
3207 && stub_sec
->size
!= 0)
3209 /* Allocate memory to hold the linker stubs. */
3210 stub_sec
->contents
= bfd_zalloc (htab
->stub_bfd
, stub_sec
->size
);
3211 if (stub_sec
->contents
== NULL
)
3216 /* Build the stubs as directed by the stub hash table. */
3217 table
= &htab
->bstab
;
3218 bfd_hash_traverse (table
, hppa_build_one_stub
, info
);
3223 /* Return the base vma address which should be subtracted from the real
3224 address when resolving a dtpoff relocation.
3225 This is PT_TLS segment p_vaddr. */
3228 dtpoff_base (struct bfd_link_info
*info
)
3230 /* If tls_sec is NULL, we should have signalled an error already. */
3231 if (elf_hash_table (info
)->tls_sec
== NULL
)
3233 return elf_hash_table (info
)->tls_sec
->vma
;
3236 /* Return the relocation value for R_PARISC_TLS_TPOFF*.. */
3239 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3241 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3243 /* If tls_sec is NULL, we should have signalled an error already. */
3244 if (htab
->tls_sec
== NULL
)
3246 /* hppa TLS ABI is variant I and static TLS block start just after
3247 tcbhead structure which has 2 pointer fields. */
3248 return (address
- htab
->tls_sec
->vma
3249 + align_power ((bfd_vma
) 8, htab
->tls_sec
->alignment_power
));
3252 /* Perform a final link. */
3255 elf32_hppa_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
3259 /* Invoke the regular ELF linker to do all the work. */
3260 if (!bfd_elf_final_link (abfd
, info
))
3263 /* If we're producing a final executable, sort the contents of the
3265 if (bfd_link_relocatable (info
))
3268 /* Do not attempt to sort non-regular files. This is here
3269 especially for configure scripts and kernel builds which run
3270 tests with "ld [...] -o /dev/null". */
3271 if (stat (abfd
->filename
, &buf
) != 0
3272 || !S_ISREG(buf
.st_mode
))
3275 return elf_hppa_sort_unwind (abfd
);
3278 /* Record the lowest address for the data and text segments. */
3281 hppa_record_segment_addr (bfd
*abfd
, asection
*section
, void *data
)
3283 struct elf32_hppa_link_hash_table
*htab
;
3285 htab
= (struct elf32_hppa_link_hash_table
*) data
;
3289 if ((section
->flags
& (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
3292 Elf_Internal_Phdr
*p
;
3294 p
= _bfd_elf_find_segment_containing_section (abfd
, section
->output_section
);
3295 BFD_ASSERT (p
!= NULL
);
3298 if ((section
->flags
& SEC_READONLY
) != 0)
3300 if (value
< htab
->text_segment_base
)
3301 htab
->text_segment_base
= value
;
3305 if (value
< htab
->data_segment_base
)
3306 htab
->data_segment_base
= value
;
3311 /* Perform a relocation as part of a final link. */
3313 static bfd_reloc_status_type
3314 final_link_relocate (asection
*input_section
,
3316 const Elf_Internal_Rela
*rela
,
3318 struct elf32_hppa_link_hash_table
*htab
,
3320 struct elf32_hppa_link_hash_entry
*hh
,
3321 struct bfd_link_info
*info
)
3324 unsigned int r_type
= ELF32_R_TYPE (rela
->r_info
);
3325 unsigned int orig_r_type
= r_type
;
3326 reloc_howto_type
*howto
= elf_hppa_howto_table
+ r_type
;
3327 int r_format
= howto
->bitsize
;
3328 enum hppa_reloc_field_selector_type_alt r_field
;
3329 bfd
*input_bfd
= input_section
->owner
;
3330 bfd_vma offset
= rela
->r_offset
;
3331 bfd_vma max_branch_offset
= 0;
3332 bfd_byte
*hit_data
= contents
+ offset
;
3333 bfd_signed_vma addend
= rela
->r_addend
;
3335 struct elf32_hppa_stub_hash_entry
*hsh
= NULL
;
3338 if (r_type
== R_PARISC_NONE
)
3339 return bfd_reloc_ok
;
3341 insn
= bfd_get_32 (input_bfd
, hit_data
);
3343 /* Find out where we are and where we're going. */
3344 location
= (offset
+
3345 input_section
->output_offset
+
3346 input_section
->output_section
->vma
);
3348 /* If we are not building a shared library, convert DLTIND relocs to
3350 if (!bfd_link_pic (info
))
3354 case R_PARISC_DLTIND21L
:
3355 case R_PARISC_TLS_GD21L
:
3356 case R_PARISC_TLS_LDM21L
:
3357 case R_PARISC_TLS_IE21L
:
3358 r_type
= R_PARISC_DPREL21L
;
3361 case R_PARISC_DLTIND14R
:
3362 case R_PARISC_TLS_GD14R
:
3363 case R_PARISC_TLS_LDM14R
:
3364 case R_PARISC_TLS_IE14R
:
3365 r_type
= R_PARISC_DPREL14R
;
3368 case R_PARISC_DLTIND14F
:
3369 r_type
= R_PARISC_DPREL14F
;
3376 case R_PARISC_PCREL12F
:
3377 case R_PARISC_PCREL17F
:
3378 case R_PARISC_PCREL22F
:
3379 /* If this call should go via the plt, find the import stub in
3382 || sym_sec
->output_section
== NULL
3384 && hh
->eh
.plt
.offset
!= (bfd_vma
) -1
3385 && hh
->eh
.dynindx
!= -1
3387 && (bfd_link_pic (info
)
3388 || !hh
->eh
.def_regular
3389 || hh
->eh
.root
.type
== bfd_link_hash_defweak
)))
3391 hsh
= hppa_get_stub_entry (input_section
, sym_sec
,
3395 value
= (hsh
->stub_offset
3396 + hsh
->stub_sec
->output_offset
3397 + hsh
->stub_sec
->output_section
->vma
);
3400 else if (sym_sec
== NULL
&& hh
!= NULL
3401 && hh
->eh
.root
.type
== bfd_link_hash_undefweak
)
3403 /* It's OK if undefined weak. Calls to undefined weak
3404 symbols behave as if the "called" function
3405 immediately returns. We can thus call to a weak
3406 function without first checking whether the function
3412 return bfd_reloc_undefined
;
3416 case R_PARISC_PCREL21L
:
3417 case R_PARISC_PCREL17C
:
3418 case R_PARISC_PCREL17R
:
3419 case R_PARISC_PCREL14R
:
3420 case R_PARISC_PCREL14F
:
3421 case R_PARISC_PCREL32
:
3422 /* Make it a pc relative offset. */
3427 case R_PARISC_DPREL21L
:
3428 case R_PARISC_DPREL14R
:
3429 case R_PARISC_DPREL14F
:
3430 /* Convert instructions that use the linkage table pointer (r19) to
3431 instructions that use the global data pointer (dp). This is the
3432 most efficient way of using PIC code in an incomplete executable,
3433 but the user must follow the standard runtime conventions for
3434 accessing data for this to work. */
3435 if (orig_r_type
!= r_type
)
3437 if (r_type
== R_PARISC_DPREL21L
)
3439 /* GCC sometimes uses a register other than r19 for the
3440 operation, so we must convert any addil instruction
3441 that uses this relocation. */
3442 if ((insn
& 0xfc000000) == ((int) OP_ADDIL
<< 26))
3445 /* We must have a ldil instruction. It's too hard to find
3446 and convert the associated add instruction, so issue an
3449 /* xgettext:c-format */
3450 (_("%B(%A+0x%lx): %s fixup for insn 0x%x is not supported in a non-shared link"),
3457 else if (r_type
== R_PARISC_DPREL14F
)
3459 /* This must be a format 1 load/store. Change the base
3461 insn
= (insn
& 0xfc1ffff) | (27 << 21);
3465 /* For all the DP relative relocations, we need to examine the symbol's
3466 section. If it has no section or if it's a code section, then
3467 "data pointer relative" makes no sense. In that case we don't
3468 adjust the "value", and for 21 bit addil instructions, we change the
3469 source addend register from %dp to %r0. This situation commonly
3470 arises for undefined weak symbols and when a variable's "constness"
3471 is declared differently from the way the variable is defined. For
3472 instance: "extern int foo" with foo defined as "const int foo". */
3473 if (sym_sec
== NULL
|| (sym_sec
->flags
& SEC_CODE
) != 0)
3475 if ((insn
& ((0x3f << 26) | (0x1f << 21)))
3476 == (((int) OP_ADDIL
<< 26) | (27 << 21)))
3478 insn
&= ~ (0x1f << 21);
3480 /* Now try to make things easy for the dynamic linker. */
3486 case R_PARISC_DLTIND21L
:
3487 case R_PARISC_DLTIND14R
:
3488 case R_PARISC_DLTIND14F
:
3489 case R_PARISC_TLS_GD21L
:
3490 case R_PARISC_TLS_LDM21L
:
3491 case R_PARISC_TLS_IE21L
:
3492 case R_PARISC_TLS_GD14R
:
3493 case R_PARISC_TLS_LDM14R
:
3494 case R_PARISC_TLS_IE14R
:
3495 value
-= elf_gp (input_section
->output_section
->owner
);
3498 case R_PARISC_SEGREL32
:
3499 if ((sym_sec
->flags
& SEC_CODE
) != 0)
3500 value
-= htab
->text_segment_base
;
3502 value
-= htab
->data_segment_base
;
3511 case R_PARISC_DIR32
:
3512 case R_PARISC_DIR14F
:
3513 case R_PARISC_DIR17F
:
3514 case R_PARISC_PCREL17C
:
3515 case R_PARISC_PCREL14F
:
3516 case R_PARISC_PCREL32
:
3517 case R_PARISC_DPREL14F
:
3518 case R_PARISC_PLABEL32
:
3519 case R_PARISC_DLTIND14F
:
3520 case R_PARISC_SEGBASE
:
3521 case R_PARISC_SEGREL32
:
3522 case R_PARISC_TLS_DTPMOD32
:
3523 case R_PARISC_TLS_DTPOFF32
:
3524 case R_PARISC_TLS_TPREL32
:
3528 case R_PARISC_DLTIND21L
:
3529 case R_PARISC_PCREL21L
:
3530 case R_PARISC_PLABEL21L
:
3534 case R_PARISC_DIR21L
:
3535 case R_PARISC_DPREL21L
:
3536 case R_PARISC_TLS_GD21L
:
3537 case R_PARISC_TLS_LDM21L
:
3538 case R_PARISC_TLS_LDO21L
:
3539 case R_PARISC_TLS_IE21L
:
3540 case R_PARISC_TLS_LE21L
:
3544 case R_PARISC_PCREL17R
:
3545 case R_PARISC_PCREL14R
:
3546 case R_PARISC_PLABEL14R
:
3547 case R_PARISC_DLTIND14R
:
3551 case R_PARISC_DIR17R
:
3552 case R_PARISC_DIR14R
:
3553 case R_PARISC_DPREL14R
:
3554 case R_PARISC_TLS_GD14R
:
3555 case R_PARISC_TLS_LDM14R
:
3556 case R_PARISC_TLS_LDO14R
:
3557 case R_PARISC_TLS_IE14R
:
3558 case R_PARISC_TLS_LE14R
:
3562 case R_PARISC_PCREL12F
:
3563 case R_PARISC_PCREL17F
:
3564 case R_PARISC_PCREL22F
:
3567 if (r_type
== (unsigned int) R_PARISC_PCREL17F
)
3569 max_branch_offset
= (1 << (17-1)) << 2;
3571 else if (r_type
== (unsigned int) R_PARISC_PCREL12F
)
3573 max_branch_offset
= (1 << (12-1)) << 2;
3577 max_branch_offset
= (1 << (22-1)) << 2;
3580 /* sym_sec is NULL on undefined weak syms or when shared on
3581 undefined syms. We've already checked for a stub for the
3582 shared undefined case. */
3583 if (sym_sec
== NULL
)
3586 /* If the branch is out of reach, then redirect the
3587 call to the local stub for this function. */
3588 if (value
+ addend
+ max_branch_offset
>= 2*max_branch_offset
)
3590 hsh
= hppa_get_stub_entry (input_section
, sym_sec
,
3593 return bfd_reloc_undefined
;
3595 /* Munge up the value and addend so that we call the stub
3596 rather than the procedure directly. */
3597 value
= (hsh
->stub_offset
3598 + hsh
->stub_sec
->output_offset
3599 + hsh
->stub_sec
->output_section
->vma
3605 /* Something we don't know how to handle. */
3607 return bfd_reloc_notsupported
;
3610 /* Make sure we can reach the stub. */
3611 if (max_branch_offset
!= 0
3612 && value
+ addend
+ max_branch_offset
>= 2*max_branch_offset
)
3615 /* xgettext:c-format */
3616 (_("%B(%A+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
3620 hsh
->bh_root
.string
);
3621 bfd_set_error (bfd_error_bad_value
);
3622 return bfd_reloc_notsupported
;
3625 val
= hppa_field_adjust (value
, addend
, r_field
);
3629 case R_PARISC_PCREL12F
:
3630 case R_PARISC_PCREL17C
:
3631 case R_PARISC_PCREL17F
:
3632 case R_PARISC_PCREL17R
:
3633 case R_PARISC_PCREL22F
:
3634 case R_PARISC_DIR17F
:
3635 case R_PARISC_DIR17R
:
3636 /* This is a branch. Divide the offset by four.
3637 Note that we need to decide whether it's a branch or
3638 otherwise by inspecting the reloc. Inspecting insn won't
3639 work as insn might be from a .word directive. */
3647 insn
= hppa_rebuild_insn (insn
, val
, r_format
);
3649 /* Update the instruction word. */
3650 bfd_put_32 (input_bfd
, (bfd_vma
) insn
, hit_data
);
3651 return bfd_reloc_ok
;
3654 /* Relocate an HPPA ELF section. */
3657 elf32_hppa_relocate_section (bfd
*output_bfd
,
3658 struct bfd_link_info
*info
,
3660 asection
*input_section
,
3662 Elf_Internal_Rela
*relocs
,
3663 Elf_Internal_Sym
*local_syms
,
3664 asection
**local_sections
)
3666 bfd_vma
*local_got_offsets
;
3667 struct elf32_hppa_link_hash_table
*htab
;
3668 Elf_Internal_Shdr
*symtab_hdr
;
3669 Elf_Internal_Rela
*rela
;
3670 Elf_Internal_Rela
*relend
;
3672 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3674 htab
= hppa_link_hash_table (info
);
3678 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3681 relend
= relocs
+ input_section
->reloc_count
;
3682 for (; rela
< relend
; rela
++)
3684 unsigned int r_type
;
3685 reloc_howto_type
*howto
;
3686 unsigned int r_symndx
;
3687 struct elf32_hppa_link_hash_entry
*hh
;
3688 Elf_Internal_Sym
*sym
;
3691 bfd_reloc_status_type rstatus
;
3692 const char *sym_name
;
3694 bfd_boolean warned_undef
;
3696 r_type
= ELF32_R_TYPE (rela
->r_info
);
3697 if (r_type
>= (unsigned int) R_PARISC_UNIMPLEMENTED
)
3699 bfd_set_error (bfd_error_bad_value
);
3702 if (r_type
== (unsigned int) R_PARISC_GNU_VTENTRY
3703 || r_type
== (unsigned int) R_PARISC_GNU_VTINHERIT
)
3706 r_symndx
= ELF32_R_SYM (rela
->r_info
);
3710 warned_undef
= FALSE
;
3711 if (r_symndx
< symtab_hdr
->sh_info
)
3713 /* This is a local symbol, h defaults to NULL. */
3714 sym
= local_syms
+ r_symndx
;
3715 sym_sec
= local_sections
[r_symndx
];
3716 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sym_sec
, rela
);
3720 struct elf_link_hash_entry
*eh
;
3721 bfd_boolean unresolved_reloc
, ignored
;
3722 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
3724 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rela
,
3725 r_symndx
, symtab_hdr
, sym_hashes
,
3726 eh
, sym_sec
, relocation
,
3727 unresolved_reloc
, warned_undef
,
3730 if (!bfd_link_relocatable (info
)
3732 && eh
->root
.type
!= bfd_link_hash_defined
3733 && eh
->root
.type
!= bfd_link_hash_defweak
3734 && eh
->root
.type
!= bfd_link_hash_undefweak
)
3736 if (info
->unresolved_syms_in_objects
== RM_IGNORE
3737 && ELF_ST_VISIBILITY (eh
->other
) == STV_DEFAULT
3738 && eh
->type
== STT_PARISC_MILLI
)
3740 (*info
->callbacks
->undefined_symbol
)
3741 (info
, eh_name (eh
), input_bfd
,
3742 input_section
, rela
->r_offset
, FALSE
);
3743 warned_undef
= TRUE
;
3746 hh
= hppa_elf_hash_entry (eh
);
3749 if (sym_sec
!= NULL
&& discarded_section (sym_sec
))
3750 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3752 elf_hppa_howto_table
+ r_type
, 0,
3755 if (bfd_link_relocatable (info
))
3758 /* Do any required modifications to the relocation value, and
3759 determine what types of dynamic info we need to output, if
3764 case R_PARISC_DLTIND14F
:
3765 case R_PARISC_DLTIND14R
:
3766 case R_PARISC_DLTIND21L
:
3769 bfd_boolean do_got
= 0;
3771 /* Relocation is to the entry for this symbol in the
3772 global offset table. */
3777 off
= hh
->eh
.got
.offset
;
3778 dyn
= htab
->etab
.dynamic_sections_created
;
3779 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
3780 bfd_link_pic (info
),
3783 /* If we aren't going to call finish_dynamic_symbol,
3784 then we need to handle initialisation of the .got
3785 entry and create needed relocs here. Since the
3786 offset must always be a multiple of 4, we use the
3787 least significant bit to record whether we have
3788 initialised it already. */
3793 hh
->eh
.got
.offset
|= 1;
3800 /* Local symbol case. */
3801 if (local_got_offsets
== NULL
)
3804 off
= local_got_offsets
[r_symndx
];
3806 /* The offset must always be a multiple of 4. We use
3807 the least significant bit to record whether we have
3808 already generated the necessary reloc. */
3813 local_got_offsets
[r_symndx
] |= 1;
3820 if (bfd_link_pic (info
))
3822 /* Output a dynamic relocation for this GOT entry.
3823 In this case it is relative to the base of the
3824 object because the symbol index is zero. */
3825 Elf_Internal_Rela outrel
;
3827 asection
*sec
= htab
->srelgot
;
3829 outrel
.r_offset
= (off
3830 + htab
->sgot
->output_offset
3831 + htab
->sgot
->output_section
->vma
);
3832 outrel
.r_info
= ELF32_R_INFO (0, R_PARISC_DIR32
);
3833 outrel
.r_addend
= relocation
;
3834 loc
= sec
->contents
;
3835 loc
+= sec
->reloc_count
++ * sizeof (Elf32_External_Rela
);
3836 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
3839 bfd_put_32 (output_bfd
, relocation
,
3840 htab
->sgot
->contents
+ off
);
3843 if (off
>= (bfd_vma
) -2)
3846 /* Add the base of the GOT to the relocation value. */
3848 + htab
->sgot
->output_offset
3849 + htab
->sgot
->output_section
->vma
);
3853 case R_PARISC_SEGREL32
:
3854 /* If this is the first SEGREL relocation, then initialize
3855 the segment base values. */
3856 if (htab
->text_segment_base
== (bfd_vma
) -1)
3857 bfd_map_over_sections (output_bfd
, hppa_record_segment_addr
, htab
);
3860 case R_PARISC_PLABEL14R
:
3861 case R_PARISC_PLABEL21L
:
3862 case R_PARISC_PLABEL32
:
3863 if (htab
->etab
.dynamic_sections_created
)
3866 bfd_boolean do_plt
= 0;
3867 /* If we have a global symbol with a PLT slot, then
3868 redirect this relocation to it. */
3871 off
= hh
->eh
.plt
.offset
;
3872 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (1,
3873 bfd_link_pic (info
),
3876 /* In a non-shared link, adjust_dynamic_symbols
3877 isn't called for symbols forced local. We
3878 need to write out the plt entry here. */
3883 hh
->eh
.plt
.offset
|= 1;
3890 bfd_vma
*local_plt_offsets
;
3892 if (local_got_offsets
== NULL
)
3895 local_plt_offsets
= local_got_offsets
+ symtab_hdr
->sh_info
;
3896 off
= local_plt_offsets
[r_symndx
];
3898 /* As for the local .got entry case, we use the last
3899 bit to record whether we've already initialised
3900 this local .plt entry. */
3905 local_plt_offsets
[r_symndx
] |= 1;
3912 if (bfd_link_pic (info
))
3914 /* Output a dynamic IPLT relocation for this
3916 Elf_Internal_Rela outrel
;
3918 asection
*s
= htab
->srelplt
;
3920 outrel
.r_offset
= (off
3921 + htab
->splt
->output_offset
3922 + htab
->splt
->output_section
->vma
);
3923 outrel
.r_info
= ELF32_R_INFO (0, R_PARISC_IPLT
);
3924 outrel
.r_addend
= relocation
;
3926 loc
+= s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
3927 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
3931 bfd_put_32 (output_bfd
,
3933 htab
->splt
->contents
+ off
);
3934 bfd_put_32 (output_bfd
,
3935 elf_gp (htab
->splt
->output_section
->owner
),
3936 htab
->splt
->contents
+ off
+ 4);
3940 if (off
>= (bfd_vma
) -2)
3943 /* PLABELs contain function pointers. Relocation is to
3944 the entry for the function in the .plt. The magic +2
3945 offset signals to $$dyncall that the function pointer
3946 is in the .plt and thus has a gp pointer too.
3947 Exception: Undefined PLABELs should have a value of
3950 || (hh
->eh
.root
.type
!= bfd_link_hash_undefweak
3951 && hh
->eh
.root
.type
!= bfd_link_hash_undefined
))
3954 + htab
->splt
->output_offset
3955 + htab
->splt
->output_section
->vma
3962 case R_PARISC_DIR17F
:
3963 case R_PARISC_DIR17R
:
3964 case R_PARISC_DIR14F
:
3965 case R_PARISC_DIR14R
:
3966 case R_PARISC_DIR21L
:
3967 case R_PARISC_DPREL14F
:
3968 case R_PARISC_DPREL14R
:
3969 case R_PARISC_DPREL21L
:
3970 case R_PARISC_DIR32
:
3971 if ((input_section
->flags
& SEC_ALLOC
) == 0)
3974 /* The reloc types handled here and this conditional
3975 expression must match the code in ..check_relocs and
3976 allocate_dynrelocs. ie. We need exactly the same condition
3977 as in ..check_relocs, with some extra conditions (dynindx
3978 test in this case) to cater for relocs removed by
3979 allocate_dynrelocs. If you squint, the non-shared test
3980 here does indeed match the one in ..check_relocs, the
3981 difference being that here we test DEF_DYNAMIC as well as
3982 !DEF_REGULAR. All common syms end up with !DEF_REGULAR,
3983 which is why we can't use just that test here.
3984 Conversely, DEF_DYNAMIC can't be used in check_relocs as
3985 there all files have not been loaded. */
3986 if ((bfd_link_pic (info
)
3988 || ELF_ST_VISIBILITY (hh
->eh
.other
) == STV_DEFAULT
3989 || hh
->eh
.root
.type
!= bfd_link_hash_undefweak
)
3990 && (IS_ABSOLUTE_RELOC (r_type
)
3991 || !SYMBOL_CALLS_LOCAL (info
, &hh
->eh
)))
3992 || (!bfd_link_pic (info
)
3994 && hh
->eh
.dynindx
!= -1
3995 && !hh
->eh
.non_got_ref
3996 && ((ELIMINATE_COPY_RELOCS
3997 && hh
->eh
.def_dynamic
3998 && !hh
->eh
.def_regular
)
3999 || hh
->eh
.root
.type
== bfd_link_hash_undefweak
4000 || hh
->eh
.root
.type
== bfd_link_hash_undefined
)))
4002 Elf_Internal_Rela outrel
;
4007 /* When generating a shared object, these relocations
4008 are copied into the output file to be resolved at run
4011 outrel
.r_addend
= rela
->r_addend
;
4013 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4015 skip
= (outrel
.r_offset
== (bfd_vma
) -1
4016 || outrel
.r_offset
== (bfd_vma
) -2);
4017 outrel
.r_offset
+= (input_section
->output_offset
4018 + input_section
->output_section
->vma
);
4022 memset (&outrel
, 0, sizeof (outrel
));
4025 && hh
->eh
.dynindx
!= -1
4027 || !IS_ABSOLUTE_RELOC (r_type
)
4028 || !bfd_link_pic (info
)
4029 || !SYMBOLIC_BIND (info
, &hh
->eh
)
4030 || !hh
->eh
.def_regular
))
4032 outrel
.r_info
= ELF32_R_INFO (hh
->eh
.dynindx
, r_type
);
4034 else /* It's a local symbol, or one marked to become local. */
4038 /* Add the absolute offset of the symbol. */
4039 outrel
.r_addend
+= relocation
;
4041 /* Global plabels need to be processed by the
4042 dynamic linker so that functions have at most one
4043 fptr. For this reason, we need to differentiate
4044 between global and local plabels, which we do by
4045 providing the function symbol for a global plabel
4046 reloc, and no symbol for local plabels. */
4049 && sym_sec
->output_section
!= NULL
4050 && ! bfd_is_abs_section (sym_sec
))
4054 osec
= sym_sec
->output_section
;
4055 indx
= elf_section_data (osec
)->dynindx
;
4058 osec
= htab
->etab
.text_index_section
;
4059 indx
= elf_section_data (osec
)->dynindx
;
4061 BFD_ASSERT (indx
!= 0);
4063 /* We are turning this relocation into one
4064 against a section symbol, so subtract out the
4065 output section's address but not the offset
4066 of the input section in the output section. */
4067 outrel
.r_addend
-= osec
->vma
;
4070 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
4072 sreloc
= elf_section_data (input_section
)->sreloc
;
4076 loc
= sreloc
->contents
;
4077 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4078 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4082 case R_PARISC_TLS_LDM21L
:
4083 case R_PARISC_TLS_LDM14R
:
4087 off
= htab
->tls_ldm_got
.offset
;
4092 Elf_Internal_Rela outrel
;
4095 outrel
.r_offset
= (off
4096 + htab
->sgot
->output_section
->vma
4097 + htab
->sgot
->output_offset
);
4098 outrel
.r_addend
= 0;
4099 outrel
.r_info
= ELF32_R_INFO (0, R_PARISC_TLS_DTPMOD32
);
4100 loc
= htab
->srelgot
->contents
;
4101 loc
+= htab
->srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4103 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4104 htab
->tls_ldm_got
.offset
|= 1;
4107 /* Add the base of the GOT to the relocation value. */
4109 + htab
->sgot
->output_offset
4110 + htab
->sgot
->output_section
->vma
);
4115 case R_PARISC_TLS_LDO21L
:
4116 case R_PARISC_TLS_LDO14R
:
4117 relocation
-= dtpoff_base (info
);
4120 case R_PARISC_TLS_GD21L
:
4121 case R_PARISC_TLS_GD14R
:
4122 case R_PARISC_TLS_IE21L
:
4123 case R_PARISC_TLS_IE14R
:
4133 dyn
= htab
->etab
.dynamic_sections_created
;
4135 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
4136 bfd_link_pic (info
),
4138 && (!bfd_link_pic (info
)
4139 || !SYMBOL_REFERENCES_LOCAL (info
, &hh
->eh
)))
4141 indx
= hh
->eh
.dynindx
;
4143 off
= hh
->eh
.got
.offset
;
4144 tls_type
= hh
->tls_type
;
4148 off
= local_got_offsets
[r_symndx
];
4149 tls_type
= hppa_elf_local_got_tls_type (input_bfd
)[r_symndx
];
4152 if (tls_type
== GOT_UNKNOWN
)
4159 bfd_boolean need_relocs
= FALSE
;
4160 Elf_Internal_Rela outrel
;
4161 bfd_byte
*loc
= NULL
;
4164 /* The GOT entries have not been initialized yet. Do it
4165 now, and emit any relocations. If both an IE GOT and a
4166 GD GOT are necessary, we emit the GD first. */
4168 if ((bfd_link_pic (info
) || indx
!= 0)
4170 || ELF_ST_VISIBILITY (hh
->eh
.other
) == STV_DEFAULT
4171 || hh
->eh
.root
.type
!= bfd_link_hash_undefweak
))
4174 loc
= htab
->srelgot
->contents
;
4175 /* FIXME (CAO): Should this be reloc_count++ ? */
4176 loc
+= htab
->srelgot
->reloc_count
* sizeof (Elf32_External_Rela
);
4179 if (tls_type
& GOT_TLS_GD
)
4183 outrel
.r_offset
= (cur_off
4184 + htab
->sgot
->output_section
->vma
4185 + htab
->sgot
->output_offset
);
4186 outrel
.r_info
= ELF32_R_INFO (indx
,R_PARISC_TLS_DTPMOD32
);
4187 outrel
.r_addend
= 0;
4188 bfd_put_32 (output_bfd
, 0, htab
->sgot
->contents
+ cur_off
);
4189 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4190 htab
->srelgot
->reloc_count
++;
4191 loc
+= sizeof (Elf32_External_Rela
);
4194 bfd_put_32 (output_bfd
, relocation
- dtpoff_base (info
),
4195 htab
->sgot
->contents
+ cur_off
+ 4);
4198 bfd_put_32 (output_bfd
, 0,
4199 htab
->sgot
->contents
+ cur_off
+ 4);
4200 outrel
.r_info
= ELF32_R_INFO (indx
, R_PARISC_TLS_DTPOFF32
);
4201 outrel
.r_offset
+= 4;
4202 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,loc
);
4203 htab
->srelgot
->reloc_count
++;
4204 loc
+= sizeof (Elf32_External_Rela
);
4209 /* If we are not emitting relocations for a
4210 general dynamic reference, then we must be in a
4211 static link or an executable link with the
4212 symbol binding locally. Mark it as belonging
4213 to module 1, the executable. */
4214 bfd_put_32 (output_bfd
, 1,
4215 htab
->sgot
->contents
+ cur_off
);
4216 bfd_put_32 (output_bfd
, relocation
- dtpoff_base (info
),
4217 htab
->sgot
->contents
+ cur_off
+ 4);
4224 if (tls_type
& GOT_TLS_IE
)
4228 outrel
.r_offset
= (cur_off
4229 + htab
->sgot
->output_section
->vma
4230 + htab
->sgot
->output_offset
);
4231 outrel
.r_info
= ELF32_R_INFO (indx
, R_PARISC_TLS_TPREL32
);
4234 outrel
.r_addend
= relocation
- dtpoff_base (info
);
4236 outrel
.r_addend
= 0;
4238 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4239 htab
->srelgot
->reloc_count
++;
4240 loc
+= sizeof (Elf32_External_Rela
);
4243 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
4244 htab
->sgot
->contents
+ cur_off
);
4250 hh
->eh
.got
.offset
|= 1;
4252 local_got_offsets
[r_symndx
] |= 1;
4255 if ((tls_type
& GOT_TLS_GD
)
4256 && r_type
!= R_PARISC_TLS_GD21L
4257 && r_type
!= R_PARISC_TLS_GD14R
)
4258 off
+= 2 * GOT_ENTRY_SIZE
;
4260 /* Add the base of the GOT to the relocation value. */
4262 + htab
->sgot
->output_offset
4263 + htab
->sgot
->output_section
->vma
);
4268 case R_PARISC_TLS_LE21L
:
4269 case R_PARISC_TLS_LE14R
:
4271 relocation
= tpoff (info
, relocation
);
4280 rstatus
= final_link_relocate (input_section
, contents
, rela
, relocation
,
4281 htab
, sym_sec
, hh
, info
);
4283 if (rstatus
== bfd_reloc_ok
)
4287 sym_name
= hh_name (hh
);
4290 sym_name
= bfd_elf_string_from_elf_section (input_bfd
,
4291 symtab_hdr
->sh_link
,
4293 if (sym_name
== NULL
)
4295 if (*sym_name
== '\0')
4296 sym_name
= bfd_section_name (input_bfd
, sym_sec
);
4299 howto
= elf_hppa_howto_table
+ r_type
;
4301 if (rstatus
== bfd_reloc_undefined
|| rstatus
== bfd_reloc_notsupported
)
4303 if (rstatus
== bfd_reloc_notsupported
|| !warned_undef
)
4306 /* xgettext:c-format */
4307 (_("%B(%A+0x%lx): cannot handle %s for %s"),
4310 (long) rela
->r_offset
,
4313 bfd_set_error (bfd_error_bad_value
);
4318 (*info
->callbacks
->reloc_overflow
)
4319 (info
, (hh
? &hh
->eh
.root
: NULL
), sym_name
, howto
->name
,
4320 (bfd_vma
) 0, input_bfd
, input_section
, rela
->r_offset
);
4326 /* Finish up dynamic symbol handling. We set the contents of various
4327 dynamic sections here. */
4330 elf32_hppa_finish_dynamic_symbol (bfd
*output_bfd
,
4331 struct bfd_link_info
*info
,
4332 struct elf_link_hash_entry
*eh
,
4333 Elf_Internal_Sym
*sym
)
4335 struct elf32_hppa_link_hash_table
*htab
;
4336 Elf_Internal_Rela rela
;
4339 htab
= hppa_link_hash_table (info
);
4343 if (eh
->plt
.offset
!= (bfd_vma
) -1)
4347 if (eh
->plt
.offset
& 1)
4350 /* This symbol has an entry in the procedure linkage table. Set
4353 The format of a plt entry is
4358 if (eh
->root
.type
== bfd_link_hash_defined
4359 || eh
->root
.type
== bfd_link_hash_defweak
)
4361 value
= eh
->root
.u
.def
.value
;
4362 if (eh
->root
.u
.def
.section
->output_section
!= NULL
)
4363 value
+= (eh
->root
.u
.def
.section
->output_offset
4364 + eh
->root
.u
.def
.section
->output_section
->vma
);
4367 /* Create a dynamic IPLT relocation for this entry. */
4368 rela
.r_offset
= (eh
->plt
.offset
4369 + htab
->splt
->output_offset
4370 + htab
->splt
->output_section
->vma
);
4371 if (eh
->dynindx
!= -1)
4373 rela
.r_info
= ELF32_R_INFO (eh
->dynindx
, R_PARISC_IPLT
);
4378 /* This symbol has been marked to become local, and is
4379 used by a plabel so must be kept in the .plt. */
4380 rela
.r_info
= ELF32_R_INFO (0, R_PARISC_IPLT
);
4381 rela
.r_addend
= value
;
4384 loc
= htab
->srelplt
->contents
;
4385 loc
+= htab
->srelplt
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4386 bfd_elf32_swap_reloca_out (htab
->splt
->output_section
->owner
, &rela
, loc
);
4388 if (!eh
->def_regular
)
4390 /* Mark the symbol as undefined, rather than as defined in
4391 the .plt section. Leave the value alone. */
4392 sym
->st_shndx
= SHN_UNDEF
;
4396 if (eh
->got
.offset
!= (bfd_vma
) -1
4397 && (hppa_elf_hash_entry (eh
)->tls_type
& GOT_TLS_GD
) == 0
4398 && (hppa_elf_hash_entry (eh
)->tls_type
& GOT_TLS_IE
) == 0)
4400 /* This symbol has an entry in the global offset table. Set it
4403 rela
.r_offset
= ((eh
->got
.offset
&~ (bfd_vma
) 1)
4404 + htab
->sgot
->output_offset
4405 + htab
->sgot
->output_section
->vma
);
4407 /* If this is a -Bsymbolic link and the symbol is defined
4408 locally or was forced to be local because of a version file,
4409 we just want to emit a RELATIVE reloc. The entry in the
4410 global offset table will already have been initialized in the
4411 relocate_section function. */
4412 if (bfd_link_pic (info
)
4413 && (SYMBOLIC_BIND (info
, eh
) || eh
->dynindx
== -1)
4416 rela
.r_info
= ELF32_R_INFO (0, R_PARISC_DIR32
);
4417 rela
.r_addend
= (eh
->root
.u
.def
.value
4418 + eh
->root
.u
.def
.section
->output_offset
4419 + eh
->root
.u
.def
.section
->output_section
->vma
);
4423 if ((eh
->got
.offset
& 1) != 0)
4426 bfd_put_32 (output_bfd
, 0, htab
->sgot
->contents
+ (eh
->got
.offset
& ~1));
4427 rela
.r_info
= ELF32_R_INFO (eh
->dynindx
, R_PARISC_DIR32
);
4431 loc
= htab
->srelgot
->contents
;
4432 loc
+= htab
->srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4433 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
4440 /* This symbol needs a copy reloc. Set it up. */
4442 if (! (eh
->dynindx
!= -1
4443 && (eh
->root
.type
== bfd_link_hash_defined
4444 || eh
->root
.type
== bfd_link_hash_defweak
)))
4447 sec
= htab
->srelbss
;
4449 rela
.r_offset
= (eh
->root
.u
.def
.value
4450 + eh
->root
.u
.def
.section
->output_offset
4451 + eh
->root
.u
.def
.section
->output_section
->vma
);
4453 rela
.r_info
= ELF32_R_INFO (eh
->dynindx
, R_PARISC_COPY
);
4454 loc
= sec
->contents
+ sec
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4455 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
4458 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
4459 if (eh
== htab
->etab
.hdynamic
|| eh
== htab
->etab
.hgot
)
4461 sym
->st_shndx
= SHN_ABS
;
4467 /* Used to decide how to sort relocs in an optimal manner for the
4468 dynamic linker, before writing them out. */
4470 static enum elf_reloc_type_class
4471 elf32_hppa_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4472 const asection
*rel_sec ATTRIBUTE_UNUSED
,
4473 const Elf_Internal_Rela
*rela
)
4475 /* Handle TLS relocs first; we don't want them to be marked
4476 relative by the "if (ELF32_R_SYM (rela->r_info) == STN_UNDEF)"
4478 switch ((int) ELF32_R_TYPE (rela
->r_info
))
4480 case R_PARISC_TLS_DTPMOD32
:
4481 case R_PARISC_TLS_DTPOFF32
:
4482 case R_PARISC_TLS_TPREL32
:
4483 return reloc_class_normal
;
4486 if (ELF32_R_SYM (rela
->r_info
) == STN_UNDEF
)
4487 return reloc_class_relative
;
4489 switch ((int) ELF32_R_TYPE (rela
->r_info
))
4492 return reloc_class_plt
;
4494 return reloc_class_copy
;
4496 return reloc_class_normal
;
4500 /* Finish up the dynamic sections. */
4503 elf32_hppa_finish_dynamic_sections (bfd
*output_bfd
,
4504 struct bfd_link_info
*info
)
4507 struct elf32_hppa_link_hash_table
*htab
;
4511 htab
= hppa_link_hash_table (info
);
4515 dynobj
= htab
->etab
.dynobj
;
4518 /* A broken linker script might have discarded the dynamic sections.
4519 Catch this here so that we do not seg-fault later on. */
4520 if (sgot
!= NULL
&& bfd_is_abs_section (sgot
->output_section
))
4523 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
4525 if (htab
->etab
.dynamic_sections_created
)
4527 Elf32_External_Dyn
*dyncon
, *dynconend
;
4532 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
4533 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4534 for (; dyncon
< dynconend
; dyncon
++)
4536 Elf_Internal_Dyn dyn
;
4539 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4547 /* Use PLTGOT to set the GOT register. */
4548 dyn
.d_un
.d_ptr
= elf_gp (output_bfd
);
4553 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
4558 dyn
.d_un
.d_val
= s
->size
;
4562 /* Don't count procedure linkage table relocs in the
4563 overall reloc count. */
4567 dyn
.d_un
.d_val
-= s
->size
;
4571 /* We may not be using the standard ELF linker script.
4572 If .rela.plt is the first .rela section, we adjust
4573 DT_RELA to not include it. */
4577 if (dyn
.d_un
.d_ptr
!= s
->output_section
->vma
+ s
->output_offset
)
4579 dyn
.d_un
.d_ptr
+= s
->size
;
4583 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4587 if (sgot
!= NULL
&& sgot
->size
!= 0)
4589 /* Fill in the first entry in the global offset table.
4590 We use it to point to our dynamic section, if we have one. */
4591 bfd_put_32 (output_bfd
,
4592 sdyn
? sdyn
->output_section
->vma
+ sdyn
->output_offset
: 0,
4595 /* The second entry is reserved for use by the dynamic linker. */
4596 memset (sgot
->contents
+ GOT_ENTRY_SIZE
, 0, GOT_ENTRY_SIZE
);
4598 /* Set .got entry size. */
4599 elf_section_data (sgot
->output_section
)
4600 ->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
4603 if (htab
->splt
!= NULL
&& htab
->splt
->size
!= 0)
4605 /* Set plt entry size to 0 instead of PLT_ENTRY_SIZE, since we add the
4606 plt stubs and as such the section does not hold a table of fixed-size
4608 elf_section_data (htab
->splt
->output_section
)->this_hdr
.sh_entsize
= 0;
4610 if (htab
->need_plt_stub
)
4612 /* Set up the .plt stub. */
4613 memcpy (htab
->splt
->contents
4614 + htab
->splt
->size
- sizeof (plt_stub
),
4615 plt_stub
, sizeof (plt_stub
));
4617 if ((htab
->splt
->output_offset
4618 + htab
->splt
->output_section
->vma
4620 != (sgot
->output_offset
4621 + sgot
->output_section
->vma
))
4624 (_(".got section not immediately after .plt section"));
4633 /* Called when writing out an object file to decide the type of a
4636 elf32_hppa_elf_get_symbol_type (Elf_Internal_Sym
*elf_sym
, int type
)
4638 if (ELF_ST_TYPE (elf_sym
->st_info
) == STT_PARISC_MILLI
)
4639 return STT_PARISC_MILLI
;
4644 /* Misc BFD support code. */
4645 #define bfd_elf32_bfd_is_local_label_name elf_hppa_is_local_label_name
4646 #define bfd_elf32_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
4647 #define bfd_elf32_bfd_reloc_name_lookup elf_hppa_reloc_name_lookup
4648 #define elf_info_to_howto elf_hppa_info_to_howto
4649 #define elf_info_to_howto_rel elf_hppa_info_to_howto_rel
4651 /* Stuff for the BFD linker. */
4652 #define bfd_elf32_bfd_final_link elf32_hppa_final_link
4653 #define bfd_elf32_bfd_link_hash_table_create elf32_hppa_link_hash_table_create
4654 #define elf_backend_adjust_dynamic_symbol elf32_hppa_adjust_dynamic_symbol
4655 #define elf_backend_copy_indirect_symbol elf32_hppa_copy_indirect_symbol
4656 #define elf_backend_check_relocs elf32_hppa_check_relocs
4657 #define elf_backend_create_dynamic_sections elf32_hppa_create_dynamic_sections
4658 #define elf_backend_fake_sections elf_hppa_fake_sections
4659 #define elf_backend_relocate_section elf32_hppa_relocate_section
4660 #define elf_backend_hide_symbol elf32_hppa_hide_symbol
4661 #define elf_backend_finish_dynamic_symbol elf32_hppa_finish_dynamic_symbol
4662 #define elf_backend_finish_dynamic_sections elf32_hppa_finish_dynamic_sections
4663 #define elf_backend_size_dynamic_sections elf32_hppa_size_dynamic_sections
4664 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
4665 #define elf_backend_gc_mark_hook elf32_hppa_gc_mark_hook
4666 #define elf_backend_gc_sweep_hook elf32_hppa_gc_sweep_hook
4667 #define elf_backend_grok_prstatus elf32_hppa_grok_prstatus
4668 #define elf_backend_grok_psinfo elf32_hppa_grok_psinfo
4669 #define elf_backend_object_p elf32_hppa_object_p
4670 #define elf_backend_final_write_processing elf_hppa_final_write_processing
4671 #define elf_backend_get_symbol_type elf32_hppa_elf_get_symbol_type
4672 #define elf_backend_reloc_type_class elf32_hppa_reloc_type_class
4673 #define elf_backend_action_discarded elf_hppa_action_discarded
4675 #define elf_backend_can_gc_sections 1
4676 #define elf_backend_can_refcount 1
4677 #define elf_backend_plt_alignment 2
4678 #define elf_backend_want_got_plt 0
4679 #define elf_backend_plt_readonly 0
4680 #define elf_backend_want_plt_sym 0
4681 #define elf_backend_got_header_size 8
4682 #define elf_backend_rela_normal 1
4684 #define TARGET_BIG_SYM hppa_elf32_vec
4685 #define TARGET_BIG_NAME "elf32-hppa"
4686 #define ELF_ARCH bfd_arch_hppa
4687 #define ELF_TARGET_ID HPPA32_ELF_DATA
4688 #define ELF_MACHINE_CODE EM_PARISC
4689 #define ELF_MAXPAGESIZE 0x1000
4690 #define ELF_OSABI ELFOSABI_HPUX
4691 #define elf32_bed elf32_hppa_hpux_bed
4693 #include "elf32-target.h"
4695 #undef TARGET_BIG_SYM
4696 #define TARGET_BIG_SYM hppa_elf32_linux_vec
4697 #undef TARGET_BIG_NAME
4698 #define TARGET_BIG_NAME "elf32-hppa-linux"
4700 #define ELF_OSABI ELFOSABI_GNU
4702 #define elf32_bed elf32_hppa_linux_bed
4704 #include "elf32-target.h"
4706 #undef TARGET_BIG_SYM
4707 #define TARGET_BIG_SYM hppa_elf32_nbsd_vec
4708 #undef TARGET_BIG_NAME
4709 #define TARGET_BIG_NAME "elf32-hppa-netbsd"
4711 #define ELF_OSABI ELFOSABI_NETBSD
4713 #define elf32_bed elf32_hppa_netbsd_bed
4715 #include "elf32-target.h"