1 /* BFD back-end for HP PA-RISC ELF files.
2 Copyright (C) 1990-2020 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 PLT address
75 : ldo RR'lt_ptr+ltoff(%r1),%r22 ;
76 : ldw 0(%r22),%r21 ; get procedure entry point
78 : ldw 4(%r22),%r19 ; get new dlt value.
80 Import stub to call shared library routine from shared library
81 (single sub-space version)
82 : addil LR'ltoff,%r19 ; get PLT address
83 : ldo RR'ltoff(%r1),%r22
84 : ldw 0(%r22),%r21 ; get procedure entry point
86 : ldw 4(%r22),%r19 ; get new dlt value.
88 Import stub to call shared library routine from normal object file
89 (multiple sub-space support)
90 : addil LR'lt_ptr+ltoff,%dp ; get PLT address
91 : ldo RR'lt_ptr+ltoff(%r1),%r22 ;
92 : ldw 0(%r22),%r21 ; get procedure entry point
93 : ldsid (%r21),%r1 ; get target sid
94 : ldw 4(%r22),%r19 ; get new dlt value.
96 : be 0(%sr0,%r21) ; branch to target
97 : stw %rp,-24(%sp) ; save rp
99 Import stub to call shared library routine from shared library
100 (multiple sub-space support)
101 : addil LR'ltoff,%r19 ; get PLT address
102 : ldo RR'ltoff(%r1),%r22
103 : ldw 0(%r22),%r21 ; get procedure entry point
104 : ldsid (%r21),%r1 ; get target sid
105 : ldw 4(%r22),%r19 ; get new dlt value.
107 : be 0(%sr0,%r21) ; branch to target
108 : stw %rp,-24(%sp) ; save rp
110 Export stub to return from shared lib routine (multiple sub-space support)
111 One of these is created for each exported procedure in a shared
112 library (and stored in the shared lib). Shared lib routines are
113 called via the first instruction in the export stub so that we can
114 do an inter-space return. Not required for single sub-space.
115 : bl,n X,%rp ; trap the return
117 : ldw -24(%sp),%rp ; restore the original rp
120 : be,n 0(%sr0,%rp) ; inter-space return. */
123 /* Variable names follow a coding style.
124 Please follow this (Apps Hungarian) style:
126 Structure/Variable Prefix
127 elf_link_hash_table "etab"
128 elf_link_hash_entry "eh"
130 elf32_hppa_link_hash_table "htab"
131 elf32_hppa_link_hash_entry "hh"
133 bfd_hash_table "btab"
136 bfd_hash_table containing stubs "bstab"
137 elf32_hppa_stub_hash_entry "hsh"
139 Always remember to use GNU Coding Style. */
141 #define PLT_ENTRY_SIZE 8
142 #define GOT_ENTRY_SIZE 4
143 #define LONG_BRANCH_STUB_SIZE 8
144 #define LONG_BRANCH_SHARED_STUB_SIZE 12
145 #define IMPORT_STUB_SIZE 20
146 #define IMPORT_SHARED_STUB_SIZE 32
147 #define EXPORT_STUB_SIZE 24
148 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
150 static const bfd_byte plt_stub
[] =
152 0x0e, 0x80, 0x10, 0x95, /* 1: ldw 0(%r20),%r21 */
153 0xea, 0xa0, 0xc0, 0x00, /* bv %r0(%r21) */
154 0x0e, 0x88, 0x10, 0x95, /* ldw 4(%r20),%r21 */
155 #define PLT_STUB_ENTRY (3*4)
156 0xea, 0x9f, 0x1f, 0xdd, /* b,l 1b,%r20 */
157 0xd6, 0x80, 0x1c, 0x1e, /* depi 0,31,2,%r20 */
158 0x00, 0xc0, 0xff, 0xee, /* 9: .word fixup_func */
159 0xde, 0xad, 0xbe, 0xef /* .word fixup_ltp */
162 /* Section name for stubs is the associated section name plus this
164 #define STUB_SUFFIX ".stub"
166 /* We don't need to copy certain PC- or GP-relative dynamic relocs
167 into a shared object's dynamic section. All the relocs of the
168 limited class we are interested in, are absolute. */
169 #ifndef RELATIVE_DYNRELOCS
170 #define RELATIVE_DYNRELOCS 0
171 #define IS_ABSOLUTE_RELOC(r_type) 1
172 #define pc_dynrelocs(hh) 0
175 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
176 copying dynamic variables from a shared lib into an app's dynbss
177 section, and instead use a dynamic relocation to point into the
179 #define ELIMINATE_COPY_RELOCS 1
181 enum elf32_hppa_stub_type
183 hppa_stub_long_branch
,
184 hppa_stub_long_branch_shared
,
186 hppa_stub_import_shared
,
191 struct elf32_hppa_stub_hash_entry
193 /* Base hash table entry structure. */
194 struct bfd_hash_entry bh_root
;
196 /* The stub section. */
199 /* Offset within stub_sec of the beginning of this stub. */
202 /* Given the symbol's value and its section we can determine its final
203 value when building the stubs (so the stub knows where to jump. */
204 bfd_vma target_value
;
205 asection
*target_section
;
207 enum elf32_hppa_stub_type stub_type
;
209 /* The symbol table entry, if any, that this was derived from. */
210 struct elf32_hppa_link_hash_entry
*hh
;
212 /* Where this stub is being called from, or, in the case of combined
213 stub sections, the first input section in the group. */
226 struct elf32_hppa_link_hash_entry
228 struct elf_link_hash_entry eh
;
230 /* A pointer to the most recently used stub hash entry against this
232 struct elf32_hppa_stub_hash_entry
*hsh_cache
;
234 ENUM_BITFIELD (_tls_type
) tls_type
: 8;
236 /* Set if this symbol is used by a plabel reloc. */
237 unsigned int plabel
:1;
240 struct elf32_hppa_link_hash_table
242 /* The main hash table. */
243 struct elf_link_hash_table etab
;
245 /* The stub hash table. */
246 struct bfd_hash_table bstab
;
248 /* Linker stub bfd. */
251 /* Linker call-backs. */
252 asection
* (*add_stub_section
) (const char *, asection
*);
253 void (*layout_sections_again
) (void);
255 /* Array to keep track of which stub sections have been created, and
256 information on stub grouping. */
259 /* This is the section to which stubs in the group will be
262 /* The stub section. */
266 /* Assorted information used by elf32_hppa_size_stubs. */
267 unsigned int bfd_count
;
268 unsigned int top_index
;
269 asection
**input_list
;
270 Elf_Internal_Sym
**all_local_syms
;
272 /* Used during a final link to store the base of the text and data
273 segments so that we can perform SEGREL relocations. */
274 bfd_vma text_segment_base
;
275 bfd_vma data_segment_base
;
277 /* Whether we support multiple sub-spaces for shared libs. */
278 unsigned int multi_subspace
:1;
280 /* Flags set when various size branches are detected. Used to
281 select suitable defaults for the stub group size. */
282 unsigned int has_12bit_branch
:1;
283 unsigned int has_17bit_branch
:1;
284 unsigned int has_22bit_branch
:1;
286 /* Set if we need a .plt stub to support lazy dynamic linking. */
287 unsigned int need_plt_stub
:1;
289 /* Small local sym cache. */
290 struct sym_cache sym_cache
;
292 /* Data for LDM relocations. */
295 bfd_signed_vma refcount
;
300 /* Various hash macros and functions. */
301 #define hppa_link_hash_table(p) \
302 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
303 == HPPA32_ELF_DATA ? ((struct elf32_hppa_link_hash_table *) ((p)->hash)) : NULL)
305 #define hppa_elf_hash_entry(ent) \
306 ((struct elf32_hppa_link_hash_entry *)(ent))
308 #define hppa_stub_hash_entry(ent) \
309 ((struct elf32_hppa_stub_hash_entry *)(ent))
311 #define hppa_stub_hash_lookup(table, string, create, copy) \
312 ((struct elf32_hppa_stub_hash_entry *) \
313 bfd_hash_lookup ((table), (string), (create), (copy)))
315 #define hppa_elf_local_got_tls_type(abfd) \
316 ((char *)(elf_local_got_offsets (abfd) + (elf_tdata (abfd)->symtab_hdr.sh_info * 2)))
318 #define hh_name(hh) \
319 (hh ? hh->eh.root.root.string : "<undef>")
321 #define eh_name(eh) \
322 (eh ? eh->root.root.string : "<undef>")
324 /* Assorted hash table functions. */
326 /* Initialize an entry in the stub hash table. */
328 static struct bfd_hash_entry
*
329 stub_hash_newfunc (struct bfd_hash_entry
*entry
,
330 struct bfd_hash_table
*table
,
333 /* Allocate the structure if it has not already been allocated by a
337 entry
= bfd_hash_allocate (table
,
338 sizeof (struct elf32_hppa_stub_hash_entry
));
343 /* Call the allocation method of the superclass. */
344 entry
= bfd_hash_newfunc (entry
, table
, string
);
347 struct elf32_hppa_stub_hash_entry
*hsh
;
349 /* Initialize the local fields. */
350 hsh
= hppa_stub_hash_entry (entry
);
351 hsh
->stub_sec
= NULL
;
352 hsh
->stub_offset
= 0;
353 hsh
->target_value
= 0;
354 hsh
->target_section
= NULL
;
355 hsh
->stub_type
= hppa_stub_long_branch
;
363 /* Initialize an entry in the link hash table. */
365 static struct bfd_hash_entry
*
366 hppa_link_hash_newfunc (struct bfd_hash_entry
*entry
,
367 struct bfd_hash_table
*table
,
370 /* Allocate the structure if it has not already been allocated by a
374 entry
= bfd_hash_allocate (table
,
375 sizeof (struct elf32_hppa_link_hash_entry
));
380 /* Call the allocation method of the superclass. */
381 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
384 struct elf32_hppa_link_hash_entry
*hh
;
386 /* Initialize the local fields. */
387 hh
= hppa_elf_hash_entry (entry
);
388 hh
->hsh_cache
= NULL
;
390 hh
->tls_type
= GOT_UNKNOWN
;
396 /* Free the derived linker hash table. */
399 elf32_hppa_link_hash_table_free (bfd
*obfd
)
401 struct elf32_hppa_link_hash_table
*htab
402 = (struct elf32_hppa_link_hash_table
*) obfd
->link
.hash
;
404 bfd_hash_table_free (&htab
->bstab
);
405 _bfd_elf_link_hash_table_free (obfd
);
408 /* Create the derived linker hash table. The PA ELF port uses the derived
409 hash table to keep information specific to the PA ELF linker (without
410 using static variables). */
412 static struct bfd_link_hash_table
*
413 elf32_hppa_link_hash_table_create (bfd
*abfd
)
415 struct elf32_hppa_link_hash_table
*htab
;
416 size_t amt
= sizeof (*htab
);
418 htab
= bfd_zmalloc (amt
);
422 if (!_bfd_elf_link_hash_table_init (&htab
->etab
, abfd
, hppa_link_hash_newfunc
,
423 sizeof (struct elf32_hppa_link_hash_entry
),
430 /* Init the stub hash table too. */
431 if (!bfd_hash_table_init (&htab
->bstab
, stub_hash_newfunc
,
432 sizeof (struct elf32_hppa_stub_hash_entry
)))
434 _bfd_elf_link_hash_table_free (abfd
);
437 htab
->etab
.root
.hash_table_free
= elf32_hppa_link_hash_table_free
;
438 htab
->etab
.dt_pltgot_required
= TRUE
;
440 htab
->text_segment_base
= (bfd_vma
) -1;
441 htab
->data_segment_base
= (bfd_vma
) -1;
442 return &htab
->etab
.root
;
445 /* Initialize the linker stubs BFD so that we can use it for linker
446 created dynamic sections. */
449 elf32_hppa_init_stub_bfd (bfd
*abfd
, struct bfd_link_info
*info
)
451 struct elf32_hppa_link_hash_table
*htab
= hppa_link_hash_table (info
);
453 elf_elfheader (abfd
)->e_ident
[EI_CLASS
] = ELFCLASS32
;
454 htab
->etab
.dynobj
= abfd
;
457 /* Build a name for an entry in the stub hash table. */
460 hppa_stub_name (const asection
*input_section
,
461 const asection
*sym_sec
,
462 const struct elf32_hppa_link_hash_entry
*hh
,
463 const Elf_Internal_Rela
*rela
)
470 len
= 8 + 1 + strlen (hh_name (hh
)) + 1 + 8 + 1;
471 stub_name
= bfd_malloc (len
);
472 if (stub_name
!= NULL
)
473 sprintf (stub_name
, "%08x_%s+%x",
474 input_section
->id
& 0xffffffff,
476 (int) rela
->r_addend
& 0xffffffff);
480 len
= 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
481 stub_name
= bfd_malloc (len
);
482 if (stub_name
!= NULL
)
483 sprintf (stub_name
, "%08x_%x:%x+%x",
484 input_section
->id
& 0xffffffff,
485 sym_sec
->id
& 0xffffffff,
486 (int) ELF32_R_SYM (rela
->r_info
) & 0xffffffff,
487 (int) rela
->r_addend
& 0xffffffff);
492 /* Look up an entry in the stub hash. Stub entries are cached because
493 creating the stub name takes a bit of time. */
495 static struct elf32_hppa_stub_hash_entry
*
496 hppa_get_stub_entry (const asection
*input_section
,
497 const asection
*sym_sec
,
498 struct elf32_hppa_link_hash_entry
*hh
,
499 const Elf_Internal_Rela
*rela
,
500 struct elf32_hppa_link_hash_table
*htab
)
502 struct elf32_hppa_stub_hash_entry
*hsh_entry
;
503 const asection
*id_sec
;
505 /* If this input section is part of a group of sections sharing one
506 stub section, then use the id of the first section in the group.
507 Stub names need to include a section id, as there may well be
508 more than one stub used to reach say, printf, and we need to
509 distinguish between them. */
510 id_sec
= htab
->stub_group
[input_section
->id
].link_sec
;
514 if (hh
!= NULL
&& hh
->hsh_cache
!= NULL
515 && hh
->hsh_cache
->hh
== hh
516 && hh
->hsh_cache
->id_sec
== id_sec
)
518 hsh_entry
= hh
->hsh_cache
;
524 stub_name
= hppa_stub_name (id_sec
, sym_sec
, hh
, rela
);
525 if (stub_name
== NULL
)
528 hsh_entry
= hppa_stub_hash_lookup (&htab
->bstab
,
529 stub_name
, FALSE
, FALSE
);
531 hh
->hsh_cache
= hsh_entry
;
539 /* Add a new stub entry to the stub hash. Not all fields of the new
540 stub entry are initialised. */
542 static struct elf32_hppa_stub_hash_entry
*
543 hppa_add_stub (const char *stub_name
,
545 struct elf32_hppa_link_hash_table
*htab
)
549 struct elf32_hppa_stub_hash_entry
*hsh
;
551 link_sec
= htab
->stub_group
[section
->id
].link_sec
;
552 stub_sec
= htab
->stub_group
[section
->id
].stub_sec
;
553 if (stub_sec
== NULL
)
555 stub_sec
= htab
->stub_group
[link_sec
->id
].stub_sec
;
556 if (stub_sec
== NULL
)
562 namelen
= strlen (link_sec
->name
);
563 len
= namelen
+ sizeof (STUB_SUFFIX
);
564 s_name
= bfd_alloc (htab
->stub_bfd
, len
);
568 memcpy (s_name
, link_sec
->name
, namelen
);
569 memcpy (s_name
+ namelen
, STUB_SUFFIX
, sizeof (STUB_SUFFIX
));
570 stub_sec
= (*htab
->add_stub_section
) (s_name
, link_sec
);
571 if (stub_sec
== NULL
)
573 htab
->stub_group
[link_sec
->id
].stub_sec
= stub_sec
;
575 htab
->stub_group
[section
->id
].stub_sec
= stub_sec
;
578 /* Enter this entry into the linker stub hash table. */
579 hsh
= hppa_stub_hash_lookup (&htab
->bstab
, stub_name
,
583 /* xgettext:c-format */
584 _bfd_error_handler (_("%pB: cannot create stub entry %s"),
585 section
->owner
, stub_name
);
589 hsh
->stub_sec
= stub_sec
;
590 hsh
->stub_offset
= 0;
591 hsh
->id_sec
= link_sec
;
595 /* Determine the type of stub needed, if any, for a call. */
597 static enum elf32_hppa_stub_type
598 hppa_type_of_stub (asection
*input_sec
,
599 const Elf_Internal_Rela
*rela
,
600 struct elf32_hppa_link_hash_entry
*hh
,
602 struct bfd_link_info
*info
)
605 bfd_vma branch_offset
;
606 bfd_vma max_branch_offset
;
610 && hh
->eh
.plt
.offset
!= (bfd_vma
) -1
611 && hh
->eh
.dynindx
!= -1
613 && (bfd_link_pic (info
)
614 || !hh
->eh
.def_regular
615 || hh
->eh
.root
.type
== bfd_link_hash_defweak
))
617 /* We need an import stub. Decide between hppa_stub_import
618 and hppa_stub_import_shared later. */
619 return hppa_stub_import
;
622 if (destination
== (bfd_vma
) -1)
623 return hppa_stub_none
;
625 /* Determine where the call point is. */
626 location
= (input_sec
->output_offset
627 + input_sec
->output_section
->vma
630 branch_offset
= destination
- location
- 8;
631 r_type
= ELF32_R_TYPE (rela
->r_info
);
633 /* Determine if a long branch stub is needed. parisc branch offsets
634 are relative to the second instruction past the branch, ie. +8
635 bytes on from the branch instruction location. The offset is
636 signed and counts in units of 4 bytes. */
637 if (r_type
== (unsigned int) R_PARISC_PCREL17F
)
638 max_branch_offset
= (1 << (17 - 1)) << 2;
640 else if (r_type
== (unsigned int) R_PARISC_PCREL12F
)
641 max_branch_offset
= (1 << (12 - 1)) << 2;
643 else /* R_PARISC_PCREL22F. */
644 max_branch_offset
= (1 << (22 - 1)) << 2;
646 if (branch_offset
+ max_branch_offset
>= 2*max_branch_offset
)
647 return hppa_stub_long_branch
;
649 return hppa_stub_none
;
652 /* Build one linker stub as defined by the stub hash table entry GEN_ENTRY.
653 IN_ARG contains the link info pointer. */
655 #define LDIL_R1 0x20200000 /* ldil LR'XXX,%r1 */
656 #define BE_SR4_R1 0xe0202002 /* be,n RR'XXX(%sr4,%r1) */
658 #define BL_R1 0xe8200000 /* b,l .+8,%r1 */
659 #define ADDIL_R1 0x28200000 /* addil LR'XXX,%r1,%r1 */
660 #define DEPI_R1 0xd4201c1e /* depi 0,31,2,%r1 */
662 #define ADDIL_DP 0x2b600000 /* addil LR'XXX,%dp,%r1 */
663 #define LDW_R1_R21 0x48350000 /* ldw RR'XXX(%sr0,%r1),%r21 */
664 #define BV_R0_R21 0xeaa0c000 /* bv %r0(%r21) */
665 #define LDW_R1_R19 0x48330000 /* ldw RR'XXX(%sr0,%r1),%r19 */
667 #define ADDIL_R19 0x2a600000 /* addil LR'XXX,%r19,%r1 */
668 #define LDW_R1_DP 0x483b0000 /* ldw RR'XXX(%sr0,%r1),%dp */
670 #define LDO_R1_R22 0x34360000 /* ldo RR'XXX(%r1),%r22 */
671 #define LDW_R22_R21 0x0ec01095 /* ldw 0(%r22),%r21 */
672 #define LDW_R22_R19 0x0ec81093 /* ldw 4(%r22),%r19 */
674 #define LDSID_R21_R1 0x02a010a1 /* ldsid (%sr0,%r21),%r1 */
675 #define MTSP_R1 0x00011820 /* mtsp %r1,%sr0 */
676 #define BE_SR0_R21 0xe2a00000 /* be 0(%sr0,%r21) */
677 #define STW_RP 0x6bc23fd1 /* stw %rp,-24(%sr0,%sp) */
679 #define BL22_RP 0xe800a002 /* b,l,n XXX,%rp */
680 #define BL_RP 0xe8400002 /* b,l,n XXX,%rp */
681 #define NOP 0x08000240 /* nop */
682 #define LDW_RP 0x4bc23fd1 /* ldw -24(%sr0,%sp),%rp */
683 #define LDSID_RP_R1 0x004010a1 /* ldsid (%sr0,%rp),%r1 */
684 #define BE_SR0_RP 0xe0400002 /* be,n 0(%sr0,%rp) */
691 #define LDW_R1_DLT LDW_R1_R19
693 #define LDW_R1_DLT LDW_R1_DP
697 hppa_build_one_stub (struct bfd_hash_entry
*bh
, void *in_arg
)
699 struct elf32_hppa_stub_hash_entry
*hsh
;
700 struct bfd_link_info
*info
;
701 struct elf32_hppa_link_hash_table
*htab
;
711 /* Massage our args to the form they really have. */
712 hsh
= hppa_stub_hash_entry (bh
);
713 info
= (struct bfd_link_info
*)in_arg
;
715 htab
= hppa_link_hash_table (info
);
719 stub_sec
= hsh
->stub_sec
;
721 /* Make a note of the offset within the stubs for this entry. */
722 hsh
->stub_offset
= stub_sec
->size
;
723 loc
= stub_sec
->contents
+ hsh
->stub_offset
;
725 stub_bfd
= stub_sec
->owner
;
727 switch (hsh
->stub_type
)
729 case hppa_stub_long_branch
:
730 /* Fail if the target section could not be assigned to an output
731 section. The user should fix his linker script. */
732 if (hsh
->target_section
->output_section
== NULL
733 && info
->non_contiguous_regions
)
734 info
->callbacks
->einfo (_("%F%P: Could not assign '%pA' to an output "
735 "section. Retry without "
736 "--enable-non-contiguous-regions.\n"),
737 hsh
->target_section
);
739 /* Create the long branch. A long branch is formed with "ldil"
740 loading the upper bits of the target address into a register,
741 then branching with "be" which adds in the lower bits.
742 The "be" has its delay slot nullified. */
743 sym_value
= (hsh
->target_value
744 + hsh
->target_section
->output_offset
745 + hsh
->target_section
->output_section
->vma
);
747 val
= hppa_field_adjust (sym_value
, 0, e_lrsel
);
748 insn
= hppa_rebuild_insn ((int) LDIL_R1
, val
, 21);
749 bfd_put_32 (stub_bfd
, insn
, loc
);
751 val
= hppa_field_adjust (sym_value
, 0, e_rrsel
) >> 2;
752 insn
= hppa_rebuild_insn ((int) BE_SR4_R1
, val
, 17);
753 bfd_put_32 (stub_bfd
, insn
, loc
+ 4);
755 size
= LONG_BRANCH_STUB_SIZE
;
758 case hppa_stub_long_branch_shared
:
759 /* Fail if the target section could not be assigned to an output
760 section. The user should fix his linker script. */
761 if (hsh
->target_section
->output_section
== NULL
762 && info
->non_contiguous_regions
)
763 info
->callbacks
->einfo (_("%F%P: Could not assign %pA to an output "
764 "section. Retry without "
765 "--enable-non-contiguous-regions.\n"),
766 hsh
->target_section
);
768 /* Branches are relative. This is where we are going to. */
769 sym_value
= (hsh
->target_value
770 + hsh
->target_section
->output_offset
771 + hsh
->target_section
->output_section
->vma
);
773 /* And this is where we are coming from, more or less. */
774 sym_value
-= (hsh
->stub_offset
775 + stub_sec
->output_offset
776 + stub_sec
->output_section
->vma
);
778 bfd_put_32 (stub_bfd
, (bfd_vma
) BL_R1
, loc
);
779 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) -8, e_lrsel
);
780 insn
= hppa_rebuild_insn ((int) ADDIL_R1
, val
, 21);
781 bfd_put_32 (stub_bfd
, insn
, loc
+ 4);
783 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) -8, e_rrsel
) >> 2;
784 insn
= hppa_rebuild_insn ((int) BE_SR4_R1
, val
, 17);
785 bfd_put_32 (stub_bfd
, insn
, loc
+ 8);
786 size
= LONG_BRANCH_SHARED_STUB_SIZE
;
789 case hppa_stub_import
:
790 case hppa_stub_import_shared
:
791 off
= hsh
->hh
->eh
.plt
.offset
;
792 if (off
>= (bfd_vma
) -2)
795 off
&= ~ (bfd_vma
) 1;
797 + htab
->etab
.splt
->output_offset
798 + htab
->etab
.splt
->output_section
->vma
799 - elf_gp (htab
->etab
.splt
->output_section
->owner
));
803 if (hsh
->stub_type
== hppa_stub_import_shared
)
807 /* Load function descriptor address into register %r22. It is
808 sometimes needed for lazy binding. */
809 val
= hppa_field_adjust (sym_value
, 0, e_lrsel
),
810 insn
= hppa_rebuild_insn ((int) insn
, val
, 21);
811 bfd_put_32 (stub_bfd
, insn
, loc
);
813 val
= hppa_field_adjust (sym_value
, 0, e_rrsel
);
814 insn
= hppa_rebuild_insn ((int) LDO_R1_R22
, val
, 14);
815 bfd_put_32 (stub_bfd
, insn
, loc
+ 4);
817 bfd_put_32 (stub_bfd
, (bfd_vma
) LDW_R22_R21
, loc
+ 8);
819 if (htab
->multi_subspace
)
821 bfd_put_32 (stub_bfd
, (bfd_vma
) LDSID_R21_R1
, loc
+ 12);
822 bfd_put_32 (stub_bfd
, (bfd_vma
) LDW_R22_R19
, loc
+ 16);
823 bfd_put_32 (stub_bfd
, (bfd_vma
) MTSP_R1
, loc
+ 20);
824 bfd_put_32 (stub_bfd
, (bfd_vma
) BE_SR0_R21
, loc
+ 24);
825 bfd_put_32 (stub_bfd
, (bfd_vma
) STW_RP
, loc
+ 28);
827 size
= IMPORT_SHARED_STUB_SIZE
;
831 bfd_put_32 (stub_bfd
, (bfd_vma
) BV_R0_R21
, loc
+ 12);
832 bfd_put_32 (stub_bfd
, (bfd_vma
) LDW_R22_R19
, loc
+ 16);
834 size
= IMPORT_STUB_SIZE
;
839 case hppa_stub_export
:
840 /* Fail if the target section could not be assigned to an output
841 section. The user should fix his linker script. */
842 if (hsh
->target_section
->output_section
== NULL
843 && info
->non_contiguous_regions
)
844 info
->callbacks
->einfo (_("%F%P: Could not assign %pA to an output "
845 "section. Retry without "
846 "--enable-non-contiguous-regions.\n"),
847 hsh
->target_section
);
849 /* Branches are relative. This is where we are going to. */
850 sym_value
= (hsh
->target_value
851 + hsh
->target_section
->output_offset
852 + hsh
->target_section
->output_section
->vma
);
854 /* And this is where we are coming from. */
855 sym_value
-= (hsh
->stub_offset
856 + stub_sec
->output_offset
857 + stub_sec
->output_section
->vma
);
859 if (sym_value
- 8 + (1 << (17 + 1)) >= (1 << (17 + 2))
860 && (!htab
->has_22bit_branch
861 || sym_value
- 8 + (1 << (22 + 1)) >= (1 << (22 + 2))))
864 /* xgettext:c-format */
865 (_("%pB(%pA+%#" PRIx64
"): "
866 "cannot reach %s, recompile with -ffunction-sections"),
867 hsh
->target_section
->owner
,
869 (uint64_t) hsh
->stub_offset
,
870 hsh
->bh_root
.string
);
871 bfd_set_error (bfd_error_bad_value
);
875 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) -8, e_fsel
) >> 2;
876 if (!htab
->has_22bit_branch
)
877 insn
= hppa_rebuild_insn ((int) BL_RP
, val
, 17);
879 insn
= hppa_rebuild_insn ((int) BL22_RP
, val
, 22);
880 bfd_put_32 (stub_bfd
, insn
, loc
);
882 bfd_put_32 (stub_bfd
, (bfd_vma
) NOP
, loc
+ 4);
883 bfd_put_32 (stub_bfd
, (bfd_vma
) LDW_RP
, loc
+ 8);
884 bfd_put_32 (stub_bfd
, (bfd_vma
) LDSID_RP_R1
, loc
+ 12);
885 bfd_put_32 (stub_bfd
, (bfd_vma
) MTSP_R1
, loc
+ 16);
886 bfd_put_32 (stub_bfd
, (bfd_vma
) BE_SR0_RP
, loc
+ 20);
888 /* Point the function symbol at the stub. */
889 hsh
->hh
->eh
.root
.u
.def
.section
= stub_sec
;
890 hsh
->hh
->eh
.root
.u
.def
.value
= stub_sec
->size
;
892 size
= EXPORT_STUB_SIZE
;
900 stub_sec
->size
+= size
;
925 /* As above, but don't actually build the stub. Just bump offset so
926 we know stub section sizes. */
929 hppa_size_one_stub (struct bfd_hash_entry
*bh
, void *in_arg
)
931 struct elf32_hppa_stub_hash_entry
*hsh
;
932 struct elf32_hppa_link_hash_table
*htab
;
935 /* Massage our args to the form they really have. */
936 hsh
= hppa_stub_hash_entry (bh
);
939 if (hsh
->stub_type
== hppa_stub_long_branch
)
940 size
= LONG_BRANCH_STUB_SIZE
;
941 else if (hsh
->stub_type
== hppa_stub_long_branch_shared
)
942 size
= LONG_BRANCH_SHARED_STUB_SIZE
;
943 else if (hsh
->stub_type
== hppa_stub_export
)
944 size
= EXPORT_STUB_SIZE
;
945 else /* hppa_stub_import or hppa_stub_import_shared. */
947 if (htab
->multi_subspace
)
948 size
= IMPORT_SHARED_STUB_SIZE
;
950 size
= IMPORT_STUB_SIZE
;
953 hsh
->stub_sec
->size
+= size
;
957 /* Return nonzero if ABFD represents an HPPA ELF32 file.
958 Additionally we set the default architecture and machine. */
961 elf32_hppa_object_p (bfd
*abfd
)
963 Elf_Internal_Ehdr
* i_ehdrp
;
966 i_ehdrp
= elf_elfheader (abfd
);
967 if (strcmp (bfd_get_target (abfd
), "elf32-hppa-linux") == 0)
969 /* GCC on hppa-linux produces binaries with OSABI=GNU,
970 but the kernel produces corefiles with OSABI=SysV. */
971 if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_GNU
&&
972 i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_NONE
) /* aka SYSV */
975 else if (strcmp (bfd_get_target (abfd
), "elf32-hppa-netbsd") == 0)
977 /* GCC on hppa-netbsd produces binaries with OSABI=NetBSD,
978 but the kernel produces corefiles with OSABI=SysV. */
979 if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_NETBSD
&&
980 i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_NONE
) /* aka SYSV */
985 if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_HPUX
)
989 flags
= i_ehdrp
->e_flags
;
990 switch (flags
& (EF_PARISC_ARCH
| EF_PARISC_WIDE
))
993 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 10);
995 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 11);
997 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 20);
998 case EFA_PARISC_2_0
| EF_PARISC_WIDE
:
999 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 25);
1004 /* Create the .plt and .got sections, and set up our hash table
1005 short-cuts to various dynamic sections. */
1008 elf32_hppa_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
1010 struct elf32_hppa_link_hash_table
*htab
;
1011 struct elf_link_hash_entry
*eh
;
1013 /* Don't try to create the .plt and .got twice. */
1014 htab
= hppa_link_hash_table (info
);
1017 if (htab
->etab
.splt
!= NULL
)
1020 /* Call the generic code to do most of the work. */
1021 if (! _bfd_elf_create_dynamic_sections (abfd
, info
))
1024 /* hppa-linux needs _GLOBAL_OFFSET_TABLE_ to be visible from the main
1025 application, because __canonicalize_funcptr_for_compare needs it. */
1026 eh
= elf_hash_table (info
)->hgot
;
1027 eh
->forced_local
= 0;
1028 eh
->other
= STV_DEFAULT
;
1029 return bfd_elf_link_record_dynamic_symbol (info
, eh
);
1032 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1035 elf32_hppa_copy_indirect_symbol (struct bfd_link_info
*info
,
1036 struct elf_link_hash_entry
*eh_dir
,
1037 struct elf_link_hash_entry
*eh_ind
)
1039 struct elf32_hppa_link_hash_entry
*hh_dir
, *hh_ind
;
1041 hh_dir
= hppa_elf_hash_entry (eh_dir
);
1042 hh_ind
= hppa_elf_hash_entry (eh_ind
);
1044 if (eh_ind
->root
.type
== bfd_link_hash_indirect
)
1046 hh_dir
->plabel
|= hh_ind
->plabel
;
1047 hh_dir
->tls_type
|= hh_ind
->tls_type
;
1048 hh_ind
->tls_type
= GOT_UNKNOWN
;
1051 _bfd_elf_link_hash_copy_indirect (info
, eh_dir
, eh_ind
);
1055 elf32_hppa_optimized_tls_reloc (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1056 int r_type
, int is_local ATTRIBUTE_UNUSED
)
1058 /* For now we don't support linker optimizations. */
1062 /* Return a pointer to the local GOT, PLT and TLS reference counts
1063 for ABFD. Returns NULL if the storage allocation fails. */
1065 static bfd_signed_vma
*
1066 hppa32_elf_local_refcounts (bfd
*abfd
)
1068 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1069 bfd_signed_vma
*local_refcounts
;
1071 local_refcounts
= elf_local_got_refcounts (abfd
);
1072 if (local_refcounts
== NULL
)
1076 /* Allocate space for local GOT and PLT reference
1077 counts. Done this way to save polluting elf_obj_tdata
1078 with another target specific pointer. */
1079 size
= symtab_hdr
->sh_info
;
1080 size
*= 2 * sizeof (bfd_signed_vma
);
1081 /* Add in space to store the local GOT TLS types. */
1082 size
+= symtab_hdr
->sh_info
;
1083 local_refcounts
= bfd_zalloc (abfd
, size
);
1084 if (local_refcounts
== NULL
)
1086 elf_local_got_refcounts (abfd
) = local_refcounts
;
1087 memset (hppa_elf_local_got_tls_type (abfd
), GOT_UNKNOWN
,
1088 symtab_hdr
->sh_info
);
1090 return local_refcounts
;
1094 /* Look through the relocs for a section during the first phase, and
1095 calculate needed space in the global offset table, procedure linkage
1096 table, and dynamic reloc sections. At this point we haven't
1097 necessarily read all the input files. */
1100 elf32_hppa_check_relocs (bfd
*abfd
,
1101 struct bfd_link_info
*info
,
1103 const Elf_Internal_Rela
*relocs
)
1105 Elf_Internal_Shdr
*symtab_hdr
;
1106 struct elf_link_hash_entry
**eh_syms
;
1107 const Elf_Internal_Rela
*rela
;
1108 const Elf_Internal_Rela
*rela_end
;
1109 struct elf32_hppa_link_hash_table
*htab
;
1112 if (bfd_link_relocatable (info
))
1115 htab
= hppa_link_hash_table (info
);
1118 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1119 eh_syms
= elf_sym_hashes (abfd
);
1122 rela_end
= relocs
+ sec
->reloc_count
;
1123 for (rela
= relocs
; rela
< rela_end
; rela
++)
1132 unsigned int r_symndx
, r_type
;
1133 struct elf32_hppa_link_hash_entry
*hh
;
1136 r_symndx
= ELF32_R_SYM (rela
->r_info
);
1138 if (r_symndx
< symtab_hdr
->sh_info
)
1142 hh
= hppa_elf_hash_entry (eh_syms
[r_symndx
- symtab_hdr
->sh_info
]);
1143 while (hh
->eh
.root
.type
== bfd_link_hash_indirect
1144 || hh
->eh
.root
.type
== bfd_link_hash_warning
)
1145 hh
= hppa_elf_hash_entry (hh
->eh
.root
.u
.i
.link
);
1148 r_type
= ELF32_R_TYPE (rela
->r_info
);
1149 r_type
= elf32_hppa_optimized_tls_reloc (info
, r_type
, hh
== NULL
);
1153 case R_PARISC_DLTIND14F
:
1154 case R_PARISC_DLTIND14R
:
1155 case R_PARISC_DLTIND21L
:
1156 /* This symbol requires a global offset table entry. */
1157 need_entry
= NEED_GOT
;
1160 case R_PARISC_PLABEL14R
: /* "Official" procedure labels. */
1161 case R_PARISC_PLABEL21L
:
1162 case R_PARISC_PLABEL32
:
1163 /* If the addend is non-zero, we break badly. */
1164 if (rela
->r_addend
!= 0)
1167 /* If we are creating a shared library, then we need to
1168 create a PLT entry for all PLABELs, because PLABELs with
1169 local symbols may be passed via a pointer to another
1170 object. Additionally, output a dynamic relocation
1171 pointing to the PLT entry.
1173 For executables, the original 32-bit ABI allowed two
1174 different styles of PLABELs (function pointers): For
1175 global functions, the PLABEL word points into the .plt
1176 two bytes past a (function address, gp) pair, and for
1177 local functions the PLABEL points directly at the
1178 function. The magic +2 for the first type allows us to
1179 differentiate between the two. As you can imagine, this
1180 is a real pain when it comes to generating code to call
1181 functions indirectly or to compare function pointers.
1182 We avoid the mess by always pointing a PLABEL into the
1183 .plt, even for local functions. */
1184 need_entry
= PLT_PLABEL
| NEED_PLT
;
1185 if (bfd_link_pic (info
))
1186 need_entry
|= NEED_DYNREL
;
1189 case R_PARISC_PCREL12F
:
1190 htab
->has_12bit_branch
= 1;
1193 case R_PARISC_PCREL17C
:
1194 case R_PARISC_PCREL17F
:
1195 htab
->has_17bit_branch
= 1;
1198 case R_PARISC_PCREL22F
:
1199 htab
->has_22bit_branch
= 1;
1201 /* Function calls might need to go through the .plt, and
1202 might require long branch stubs. */
1205 /* We know local syms won't need a .plt entry, and if
1206 they need a long branch stub we can't guarantee that
1207 we can reach the stub. So just flag an error later
1208 if we're doing a shared link and find we need a long
1214 /* Global symbols will need a .plt entry if they remain
1215 global, and in most cases won't need a long branch
1216 stub. Unfortunately, we have to cater for the case
1217 where a symbol is forced local by versioning, or due
1218 to symbolic linking, and we lose the .plt entry. */
1219 need_entry
= NEED_PLT
;
1220 if (hh
->eh
.type
== STT_PARISC_MILLI
)
1225 case R_PARISC_SEGBASE
: /* Used to set segment base. */
1226 case R_PARISC_SEGREL32
: /* Relative reloc, used for unwind. */
1227 case R_PARISC_PCREL14F
: /* PC relative load/store. */
1228 case R_PARISC_PCREL14R
:
1229 case R_PARISC_PCREL17R
: /* External branches. */
1230 case R_PARISC_PCREL21L
: /* As above, and for load/store too. */
1231 case R_PARISC_PCREL32
:
1232 /* We don't need to propagate the relocation if linking a
1233 shared object since these are section relative. */
1236 case R_PARISC_DPREL14F
: /* Used for gp rel data load/store. */
1237 case R_PARISC_DPREL14R
:
1238 case R_PARISC_DPREL21L
:
1239 if (bfd_link_pic (info
))
1242 /* xgettext:c-format */
1243 (_("%pB: relocation %s can not be used when making a shared object; recompile with -fPIC"),
1245 elf_hppa_howto_table
[r_type
].name
);
1246 bfd_set_error (bfd_error_bad_value
);
1251 case R_PARISC_DIR17F
: /* Used for external branches. */
1252 case R_PARISC_DIR17R
:
1253 case R_PARISC_DIR14F
: /* Used for load/store from absolute locn. */
1254 case R_PARISC_DIR14R
:
1255 case R_PARISC_DIR21L
: /* As above, and for ext branches too. */
1256 case R_PARISC_DIR32
: /* .word relocs. */
1257 /* We may want to output a dynamic relocation later. */
1258 need_entry
= NEED_DYNREL
;
1261 /* This relocation describes the C++ object vtable hierarchy.
1262 Reconstruct it for later use during GC. */
1263 case R_PARISC_GNU_VTINHERIT
:
1264 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, &hh
->eh
, rela
->r_offset
))
1268 /* This relocation describes which C++ vtable entries are actually
1269 used. Record for later use during GC. */
1270 case R_PARISC_GNU_VTENTRY
:
1271 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, &hh
->eh
, rela
->r_addend
))
1275 case R_PARISC_TLS_GD21L
:
1276 case R_PARISC_TLS_GD14R
:
1277 case R_PARISC_TLS_LDM21L
:
1278 case R_PARISC_TLS_LDM14R
:
1279 need_entry
= NEED_GOT
;
1282 case R_PARISC_TLS_IE21L
:
1283 case R_PARISC_TLS_IE14R
:
1284 if (bfd_link_dll (info
))
1285 info
->flags
|= DF_STATIC_TLS
;
1286 need_entry
= NEED_GOT
;
1293 /* Now carry out our orders. */
1294 if (need_entry
& NEED_GOT
)
1296 int tls_type
= GOT_NORMAL
;
1302 case R_PARISC_TLS_GD21L
:
1303 case R_PARISC_TLS_GD14R
:
1304 tls_type
= GOT_TLS_GD
;
1306 case R_PARISC_TLS_LDM21L
:
1307 case R_PARISC_TLS_LDM14R
:
1308 tls_type
= GOT_TLS_LDM
;
1310 case R_PARISC_TLS_IE21L
:
1311 case R_PARISC_TLS_IE14R
:
1312 tls_type
= GOT_TLS_IE
;
1316 /* Allocate space for a GOT entry, as well as a dynamic
1317 relocation for this entry. */
1318 if (htab
->etab
.sgot
== NULL
)
1320 if (!elf32_hppa_create_dynamic_sections (htab
->etab
.dynobj
, info
))
1326 if (tls_type
== GOT_TLS_LDM
)
1327 htab
->tls_ldm_got
.refcount
+= 1;
1329 hh
->eh
.got
.refcount
+= 1;
1330 hh
->tls_type
|= tls_type
;
1334 bfd_signed_vma
*local_got_refcounts
;
1336 /* This is a global offset table entry for a local symbol. */
1337 local_got_refcounts
= hppa32_elf_local_refcounts (abfd
);
1338 if (local_got_refcounts
== NULL
)
1340 if (tls_type
== GOT_TLS_LDM
)
1341 htab
->tls_ldm_got
.refcount
+= 1;
1343 local_got_refcounts
[r_symndx
] += 1;
1345 hppa_elf_local_got_tls_type (abfd
) [r_symndx
] |= tls_type
;
1349 if (need_entry
& NEED_PLT
)
1351 /* If we are creating a shared library, and this is a reloc
1352 against a weak symbol or a global symbol in a dynamic
1353 object, then we will be creating an import stub and a
1354 .plt entry for the symbol. Similarly, on a normal link
1355 to symbols defined in a dynamic object we'll need the
1356 import stub and a .plt entry. We don't know yet whether
1357 the symbol is defined or not, so make an entry anyway and
1358 clean up later in adjust_dynamic_symbol. */
1359 if ((sec
->flags
& SEC_ALLOC
) != 0)
1363 hh
->eh
.needs_plt
= 1;
1364 hh
->eh
.plt
.refcount
+= 1;
1366 /* If this .plt entry is for a plabel, mark it so
1367 that adjust_dynamic_symbol will keep the entry
1368 even if it appears to be local. */
1369 if (need_entry
& PLT_PLABEL
)
1372 else if (need_entry
& PLT_PLABEL
)
1374 bfd_signed_vma
*local_got_refcounts
;
1375 bfd_signed_vma
*local_plt_refcounts
;
1377 local_got_refcounts
= hppa32_elf_local_refcounts (abfd
);
1378 if (local_got_refcounts
== NULL
)
1380 local_plt_refcounts
= (local_got_refcounts
1381 + symtab_hdr
->sh_info
);
1382 local_plt_refcounts
[r_symndx
] += 1;
1387 if ((need_entry
& NEED_DYNREL
) != 0
1388 && (sec
->flags
& SEC_ALLOC
) != 0)
1390 /* Flag this symbol as having a non-got, non-plt reference
1391 so that we generate copy relocs if it turns out to be
1394 hh
->eh
.non_got_ref
= 1;
1396 /* If we are creating a shared library then we need to copy
1397 the reloc into the shared library. However, if we are
1398 linking with -Bsymbolic, we need only copy absolute
1399 relocs or relocs against symbols that are not defined in
1400 an object we are including in the link. PC- or DP- or
1401 DLT-relative relocs against any local sym or global sym
1402 with DEF_REGULAR set, can be discarded. At this point we
1403 have not seen all the input files, so it is possible that
1404 DEF_REGULAR is not set now but will be set later (it is
1405 never cleared). We account for that possibility below by
1406 storing information in the dyn_relocs field of the
1409 A similar situation to the -Bsymbolic case occurs when
1410 creating shared libraries and symbol visibility changes
1411 render the symbol local.
1413 As it turns out, all the relocs we will be creating here
1414 are absolute, so we cannot remove them on -Bsymbolic
1415 links or visibility changes anyway. A STUB_REL reloc
1416 is absolute too, as in that case it is the reloc in the
1417 stub we will be creating, rather than copying the PCREL
1418 reloc in the branch.
1420 If on the other hand, we are creating an executable, we
1421 may need to keep relocations for symbols satisfied by a
1422 dynamic library if we manage to avoid copy relocs for the
1424 if ((bfd_link_pic (info
)
1425 && (IS_ABSOLUTE_RELOC (r_type
)
1427 && (!SYMBOLIC_BIND (info
, &hh
->eh
)
1428 || hh
->eh
.root
.type
== bfd_link_hash_defweak
1429 || !hh
->eh
.def_regular
))))
1430 || (ELIMINATE_COPY_RELOCS
1431 && !bfd_link_pic (info
)
1433 && (hh
->eh
.root
.type
== bfd_link_hash_defweak
1434 || !hh
->eh
.def_regular
)))
1436 struct elf_dyn_relocs
*hdh_p
;
1437 struct elf_dyn_relocs
**hdh_head
;
1439 /* Create a reloc section in dynobj and make room for
1443 sreloc
= _bfd_elf_make_dynamic_reloc_section
1444 (sec
, htab
->etab
.dynobj
, 2, abfd
, /*rela?*/ TRUE
);
1448 bfd_set_error (bfd_error_bad_value
);
1453 /* If this is a global symbol, we count the number of
1454 relocations we need for this symbol. */
1457 hdh_head
= &hh
->eh
.dyn_relocs
;
1461 /* Track dynamic relocs needed for local syms too.
1462 We really need local syms available to do this
1466 Elf_Internal_Sym
*isym
;
1468 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
1473 sr
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1477 vpp
= &elf_section_data (sr
)->local_dynrel
;
1478 hdh_head
= (struct elf_dyn_relocs
**) vpp
;
1482 if (hdh_p
== NULL
|| hdh_p
->sec
!= sec
)
1484 hdh_p
= bfd_alloc (htab
->etab
.dynobj
, sizeof *hdh_p
);
1487 hdh_p
->next
= *hdh_head
;
1491 #if RELATIVE_DYNRELOCS
1492 hdh_p
->pc_count
= 0;
1497 #if RELATIVE_DYNRELOCS
1498 if (!IS_ABSOLUTE_RELOC (rtype
))
1499 hdh_p
->pc_count
+= 1;
1508 /* Return the section that should be marked against garbage collection
1509 for a given relocation. */
1512 elf32_hppa_gc_mark_hook (asection
*sec
,
1513 struct bfd_link_info
*info
,
1514 Elf_Internal_Rela
*rela
,
1515 struct elf_link_hash_entry
*hh
,
1516 Elf_Internal_Sym
*sym
)
1519 switch ((unsigned int) ELF32_R_TYPE (rela
->r_info
))
1521 case R_PARISC_GNU_VTINHERIT
:
1522 case R_PARISC_GNU_VTENTRY
:
1526 return _bfd_elf_gc_mark_hook (sec
, info
, rela
, hh
, sym
);
1529 /* Support for core dump NOTE sections. */
1532 elf32_hppa_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
1537 switch (note
->descsz
)
1542 case 396: /* Linux/hppa */
1544 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
1547 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
1556 /* Make a ".reg/999" section. */
1557 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
1558 size
, note
->descpos
+ offset
);
1562 elf32_hppa_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
1564 switch (note
->descsz
)
1569 case 124: /* Linux/hppa elf_prpsinfo. */
1570 elf_tdata (abfd
)->core
->program
1571 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
1572 elf_tdata (abfd
)->core
->command
1573 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
1576 /* Note that for some reason, a spurious space is tacked
1577 onto the end of the args in some (at least one anyway)
1578 implementations, so strip it off if it exists. */
1580 char *command
= elf_tdata (abfd
)->core
->command
;
1581 int n
= strlen (command
);
1583 if (0 < n
&& command
[n
- 1] == ' ')
1584 command
[n
- 1] = '\0';
1590 /* Our own version of hide_symbol, so that we can keep plt entries for
1594 elf32_hppa_hide_symbol (struct bfd_link_info
*info
,
1595 struct elf_link_hash_entry
*eh
,
1596 bfd_boolean force_local
)
1600 eh
->forced_local
= 1;
1601 if (eh
->dynindx
!= -1)
1604 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1608 /* PR 16082: Remove version information from hidden symbol. */
1609 eh
->verinfo
.verdef
= NULL
;
1610 eh
->verinfo
.vertree
= NULL
;
1613 /* STT_GNU_IFUNC symbol must go through PLT. */
1614 if (! hppa_elf_hash_entry (eh
)->plabel
1615 && eh
->type
!= STT_GNU_IFUNC
)
1618 eh
->plt
= elf_hash_table (info
)->init_plt_offset
;
1622 /* Return true if we have dynamic relocs against H or any of its weak
1623 aliases, that apply to read-only sections. Cannot be used after
1624 size_dynamic_sections. */
1627 alias_readonly_dynrelocs (struct elf_link_hash_entry
*eh
)
1629 struct elf32_hppa_link_hash_entry
*hh
= hppa_elf_hash_entry (eh
);
1632 if (_bfd_elf_readonly_dynrelocs (&hh
->eh
))
1634 hh
= hppa_elf_hash_entry (hh
->eh
.u
.alias
);
1635 } while (hh
!= NULL
&& &hh
->eh
!= eh
);
1640 /* Adjust a symbol defined by a dynamic object and referenced by a
1641 regular object. The current definition is in some section of the
1642 dynamic object, but we're not including those sections. We have to
1643 change the definition to something the rest of the link can
1647 elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1648 struct elf_link_hash_entry
*eh
)
1650 struct elf32_hppa_link_hash_table
*htab
;
1651 asection
*sec
, *srel
;
1653 /* If this is a function, put it in the procedure linkage table. We
1654 will fill in the contents of the procedure linkage table later. */
1655 if (eh
->type
== STT_FUNC
1658 bfd_boolean local
= (SYMBOL_CALLS_LOCAL (info
, eh
)
1659 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, eh
));
1660 /* Discard dyn_relocs when non-pic if we've decided that a
1661 function symbol is local. */
1662 if (!bfd_link_pic (info
) && local
)
1663 eh
->dyn_relocs
= NULL
;
1665 /* If the symbol is used by a plabel, we must allocate a PLT slot.
1666 The refcounts are not reliable when it has been hidden since
1667 hide_symbol can be called before the plabel flag is set. */
1668 if (hppa_elf_hash_entry (eh
)->plabel
)
1669 eh
->plt
.refcount
= 1;
1671 /* Note that unlike some other backends, the refcount is not
1672 incremented for a non-call (and non-plabel) function reference. */
1673 else if (eh
->plt
.refcount
<= 0
1676 /* The .plt entry is not needed when:
1677 a) Garbage collection has removed all references to the
1679 b) We know for certain the symbol is defined in this
1680 object, and it's not a weak definition, nor is the symbol
1681 used by a plabel relocation. Either this object is the
1682 application or we are doing a shared symbolic link. */
1683 eh
->plt
.offset
= (bfd_vma
) -1;
1687 /* Unlike other targets, elf32-hppa.c does not define a function
1688 symbol in a non-pic executable on PLT stub code, so we don't
1689 have a local definition in that case. ie. dyn_relocs can't
1692 /* Function symbols can't have copy relocs. */
1696 eh
->plt
.offset
= (bfd_vma
) -1;
1698 htab
= hppa_link_hash_table (info
);
1702 /* If this is a weak symbol, and there is a real definition, the
1703 processor independent code will have arranged for us to see the
1704 real definition first, and we can just use the same value. */
1705 if (eh
->is_weakalias
)
1707 struct elf_link_hash_entry
*def
= weakdef (eh
);
1708 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1709 eh
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1710 eh
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1711 if (def
->root
.u
.def
.section
== htab
->etab
.sdynbss
1712 || def
->root
.u
.def
.section
== htab
->etab
.sdynrelro
)
1713 eh
->dyn_relocs
= NULL
;
1717 /* This is a reference to a symbol defined by a dynamic object which
1718 is not a function. */
1720 /* If we are creating a shared library, we must presume that the
1721 only references to the symbol are via the global offset table.
1722 For such cases we need not do anything here; the relocations will
1723 be handled correctly by relocate_section. */
1724 if (bfd_link_pic (info
))
1727 /* If there are no references to this symbol that do not use the
1728 GOT, we don't need to generate a copy reloc. */
1729 if (!eh
->non_got_ref
)
1732 /* If -z nocopyreloc was given, we won't generate them either. */
1733 if (info
->nocopyreloc
)
1736 /* If we don't find any dynamic relocs in read-only sections, then
1737 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1738 if (ELIMINATE_COPY_RELOCS
1739 && !alias_readonly_dynrelocs (eh
))
1742 /* We must allocate the symbol in our .dynbss section, which will
1743 become part of the .bss section of the executable. There will be
1744 an entry for this symbol in the .dynsym section. The dynamic
1745 object will contain position independent code, so all references
1746 from the dynamic object to this symbol will go through the global
1747 offset table. The dynamic linker will use the .dynsym entry to
1748 determine the address it must put in the global offset table, so
1749 both the dynamic object and the regular object will refer to the
1750 same memory location for the variable. */
1751 if ((eh
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
1753 sec
= htab
->etab
.sdynrelro
;
1754 srel
= htab
->etab
.sreldynrelro
;
1758 sec
= htab
->etab
.sdynbss
;
1759 srel
= htab
->etab
.srelbss
;
1761 if ((eh
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && eh
->size
!= 0)
1763 /* We must generate a COPY reloc to tell the dynamic linker to
1764 copy the initial value out of the dynamic object and into the
1765 runtime process image. */
1766 srel
->size
+= sizeof (Elf32_External_Rela
);
1770 /* We no longer want dyn_relocs. */
1771 eh
->dyn_relocs
= NULL
;
1772 return _bfd_elf_adjust_dynamic_copy (info
, eh
, sec
);
1775 /* If EH is undefined, make it dynamic if that makes sense. */
1778 ensure_undef_dynamic (struct bfd_link_info
*info
,
1779 struct elf_link_hash_entry
*eh
)
1781 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
1783 if (htab
->dynamic_sections_created
1784 && (eh
->root
.type
== bfd_link_hash_undefweak
1785 || eh
->root
.type
== bfd_link_hash_undefined
)
1786 && eh
->dynindx
== -1
1787 && !eh
->forced_local
1788 && eh
->type
!= STT_PARISC_MILLI
1789 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, eh
)
1790 && ELF_ST_VISIBILITY (eh
->other
) == STV_DEFAULT
)
1791 return bfd_elf_link_record_dynamic_symbol (info
, eh
);
1795 /* Allocate space in the .plt for entries that won't have relocations.
1796 ie. plabel entries. */
1799 allocate_plt_static (struct elf_link_hash_entry
*eh
, void *inf
)
1801 struct bfd_link_info
*info
;
1802 struct elf32_hppa_link_hash_table
*htab
;
1803 struct elf32_hppa_link_hash_entry
*hh
;
1806 if (eh
->root
.type
== bfd_link_hash_indirect
)
1809 info
= (struct bfd_link_info
*) inf
;
1810 hh
= hppa_elf_hash_entry (eh
);
1811 htab
= hppa_link_hash_table (info
);
1815 if (htab
->etab
.dynamic_sections_created
1816 && eh
->plt
.refcount
> 0)
1818 if (!ensure_undef_dynamic (info
, eh
))
1821 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info
), eh
))
1823 /* Allocate these later. From this point on, h->plabel
1824 means that the plt entry is only used by a plabel.
1825 We'll be using a normal plt entry for this symbol, so
1826 clear the plabel indicator. */
1830 else if (hh
->plabel
)
1832 /* Make an entry in the .plt section for plabel references
1833 that won't have a .plt entry for other reasons. */
1834 sec
= htab
->etab
.splt
;
1835 eh
->plt
.offset
= sec
->size
;
1836 sec
->size
+= PLT_ENTRY_SIZE
;
1837 if (bfd_link_pic (info
))
1838 htab
->etab
.srelplt
->size
+= sizeof (Elf32_External_Rela
);
1842 /* No .plt entry needed. */
1843 eh
->plt
.offset
= (bfd_vma
) -1;
1849 eh
->plt
.offset
= (bfd_vma
) -1;
1856 /* Calculate size of GOT entries for symbol given its TLS_TYPE. */
1858 static inline unsigned int
1859 got_entries_needed (int tls_type
)
1861 unsigned int need
= 0;
1863 if ((tls_type
& GOT_NORMAL
) != 0)
1864 need
+= GOT_ENTRY_SIZE
;
1865 if ((tls_type
& GOT_TLS_GD
) != 0)
1866 need
+= GOT_ENTRY_SIZE
* 2;
1867 if ((tls_type
& GOT_TLS_IE
) != 0)
1868 need
+= GOT_ENTRY_SIZE
;
1872 /* Calculate size of relocs needed for symbol given its TLS_TYPE and
1873 NEEDed GOT entries. TPREL_KNOWN says a TPREL offset can be
1874 calculated at link time. DTPREL_KNOWN says the same for a DTPREL
1877 static inline unsigned int
1878 got_relocs_needed (int tls_type
, unsigned int need
,
1879 bfd_boolean dtprel_known
, bfd_boolean tprel_known
)
1881 /* All the entries we allocated need relocs.
1882 Except for GD and IE with local symbols. */
1883 if ((tls_type
& GOT_TLS_GD
) != 0 && dtprel_known
)
1884 need
-= GOT_ENTRY_SIZE
;
1885 if ((tls_type
& GOT_TLS_IE
) != 0 && tprel_known
)
1886 need
-= GOT_ENTRY_SIZE
;
1887 return need
* sizeof (Elf32_External_Rela
) / GOT_ENTRY_SIZE
;
1890 /* Allocate space in .plt, .got and associated reloc sections for
1894 allocate_dynrelocs (struct elf_link_hash_entry
*eh
, void *inf
)
1896 struct bfd_link_info
*info
;
1897 struct elf32_hppa_link_hash_table
*htab
;
1899 struct elf32_hppa_link_hash_entry
*hh
;
1900 struct elf_dyn_relocs
*hdh_p
;
1902 if (eh
->root
.type
== bfd_link_hash_indirect
)
1906 htab
= hppa_link_hash_table (info
);
1910 hh
= hppa_elf_hash_entry (eh
);
1912 if (htab
->etab
.dynamic_sections_created
1913 && eh
->plt
.offset
!= (bfd_vma
) -1
1915 && eh
->plt
.refcount
> 0)
1917 /* Make an entry in the .plt section. */
1918 sec
= htab
->etab
.splt
;
1919 eh
->plt
.offset
= sec
->size
;
1920 sec
->size
+= PLT_ENTRY_SIZE
;
1922 /* We also need to make an entry in the .rela.plt section. */
1923 htab
->etab
.srelplt
->size
+= sizeof (Elf32_External_Rela
);
1924 htab
->need_plt_stub
= 1;
1927 if (eh
->got
.refcount
> 0)
1931 if (!ensure_undef_dynamic (info
, eh
))
1934 sec
= htab
->etab
.sgot
;
1935 eh
->got
.offset
= sec
->size
;
1936 need
= got_entries_needed (hh
->tls_type
);
1938 if (htab
->etab
.dynamic_sections_created
1939 && (bfd_link_dll (info
)
1940 || (bfd_link_pic (info
) && (hh
->tls_type
& GOT_NORMAL
) != 0)
1941 || (eh
->dynindx
!= -1
1942 && !SYMBOL_REFERENCES_LOCAL (info
, eh
)))
1943 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, eh
))
1945 bfd_boolean local
= SYMBOL_REFERENCES_LOCAL (info
, eh
);
1946 htab
->etab
.srelgot
->size
1947 += got_relocs_needed (hh
->tls_type
, need
, local
,
1948 local
&& bfd_link_executable (info
));
1952 eh
->got
.offset
= (bfd_vma
) -1;
1954 /* If no dynamic sections we can't have dynamic relocs. */
1955 if (!htab
->etab
.dynamic_sections_created
)
1956 eh
->dyn_relocs
= NULL
;
1958 /* Discard relocs on undefined syms with non-default visibility. */
1959 else if ((eh
->root
.type
== bfd_link_hash_undefined
1960 && ELF_ST_VISIBILITY (eh
->other
) != STV_DEFAULT
)
1961 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, eh
))
1962 eh
->dyn_relocs
= NULL
;
1964 if (eh
->dyn_relocs
== NULL
)
1967 /* If this is a -Bsymbolic shared link, then we need to discard all
1968 space allocated for dynamic pc-relative relocs against symbols
1969 defined in a regular object. For the normal shared case, discard
1970 space for relocs that have become local due to symbol visibility
1972 if (bfd_link_pic (info
))
1974 #if RELATIVE_DYNRELOCS
1975 if (SYMBOL_CALLS_LOCAL (info
, eh
))
1977 struct elf_dyn_relocs
**hdh_pp
;
1979 for (hdh_pp
= &eh
->dyn_relocs
; (hdh_p
= *hdh_pp
) != NULL
; )
1981 hdh_p
->count
-= hdh_p
->pc_count
;
1982 hdh_p
->pc_count
= 0;
1983 if (hdh_p
->count
== 0)
1984 *hdh_pp
= hdh_p
->next
;
1986 hdh_pp
= &hdh_p
->next
;
1991 if (eh
->dyn_relocs
!= NULL
)
1993 if (!ensure_undef_dynamic (info
, eh
))
1997 else if (ELIMINATE_COPY_RELOCS
)
1999 /* For the non-shared case, discard space for relocs against
2000 symbols which turn out to need copy relocs or are not
2003 if (eh
->dynamic_adjusted
2005 && !ELF_COMMON_DEF_P (eh
))
2007 if (!ensure_undef_dynamic (info
, eh
))
2010 if (eh
->dynindx
== -1)
2011 eh
->dyn_relocs
= NULL
;
2014 eh
->dyn_relocs
= NULL
;
2017 /* Finally, allocate space. */
2018 for (hdh_p
= eh
->dyn_relocs
; hdh_p
!= NULL
; hdh_p
= hdh_p
->next
)
2020 asection
*sreloc
= elf_section_data (hdh_p
->sec
)->sreloc
;
2021 sreloc
->size
+= hdh_p
->count
* sizeof (Elf32_External_Rela
);
2027 /* This function is called via elf_link_hash_traverse to force
2028 millicode symbols local so they do not end up as globals in the
2029 dynamic symbol table. We ought to be able to do this in
2030 adjust_dynamic_symbol, but our adjust_dynamic_symbol is not called
2031 for all dynamic symbols. Arguably, this is a bug in
2032 elf_adjust_dynamic_symbol. */
2035 clobber_millicode_symbols (struct elf_link_hash_entry
*eh
,
2036 struct bfd_link_info
*info
)
2038 if (eh
->type
== STT_PARISC_MILLI
2039 && !eh
->forced_local
)
2041 elf32_hppa_hide_symbol (info
, eh
, TRUE
);
2046 /* Set the sizes of the dynamic sections. */
2049 elf32_hppa_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2050 struct bfd_link_info
*info
)
2052 struct elf32_hppa_link_hash_table
*htab
;
2058 htab
= hppa_link_hash_table (info
);
2062 dynobj
= htab
->etab
.dynobj
;
2066 if (htab
->etab
.dynamic_sections_created
)
2068 /* Set the contents of the .interp section to the interpreter. */
2069 if (bfd_link_executable (info
) && !info
->nointerp
)
2071 sec
= bfd_get_linker_section (dynobj
, ".interp");
2074 sec
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2075 sec
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2078 /* Force millicode symbols local. */
2079 elf_link_hash_traverse (&htab
->etab
,
2080 clobber_millicode_symbols
,
2084 /* Set up .got and .plt offsets for local syms, and space for local
2086 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2088 bfd_signed_vma
*local_got
;
2089 bfd_signed_vma
*end_local_got
;
2090 bfd_signed_vma
*local_plt
;
2091 bfd_signed_vma
*end_local_plt
;
2092 bfd_size_type locsymcount
;
2093 Elf_Internal_Shdr
*symtab_hdr
;
2095 char *local_tls_type
;
2097 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
2100 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
2102 struct elf_dyn_relocs
*hdh_p
;
2104 for (hdh_p
= ((struct elf_dyn_relocs
*)
2105 elf_section_data (sec
)->local_dynrel
);
2107 hdh_p
= hdh_p
->next
)
2109 if (!bfd_is_abs_section (hdh_p
->sec
)
2110 && bfd_is_abs_section (hdh_p
->sec
->output_section
))
2112 /* Input section has been discarded, either because
2113 it is a copy of a linkonce section or due to
2114 linker script /DISCARD/, so we'll be discarding
2117 else if (hdh_p
->count
!= 0)
2119 srel
= elf_section_data (hdh_p
->sec
)->sreloc
;
2120 srel
->size
+= hdh_p
->count
* sizeof (Elf32_External_Rela
);
2121 if ((hdh_p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
2122 info
->flags
|= DF_TEXTREL
;
2127 local_got
= elf_local_got_refcounts (ibfd
);
2131 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2132 locsymcount
= symtab_hdr
->sh_info
;
2133 end_local_got
= local_got
+ locsymcount
;
2134 local_tls_type
= hppa_elf_local_got_tls_type (ibfd
);
2135 sec
= htab
->etab
.sgot
;
2136 srel
= htab
->etab
.srelgot
;
2137 for (; local_got
< end_local_got
; ++local_got
)
2143 *local_got
= sec
->size
;
2144 need
= got_entries_needed (*local_tls_type
);
2146 if (bfd_link_dll (info
)
2147 || (bfd_link_pic (info
)
2148 && (*local_tls_type
& GOT_NORMAL
) != 0))
2149 htab
->etab
.srelgot
->size
2150 += got_relocs_needed (*local_tls_type
, need
, TRUE
,
2151 bfd_link_executable (info
));
2154 *local_got
= (bfd_vma
) -1;
2159 local_plt
= end_local_got
;
2160 end_local_plt
= local_plt
+ locsymcount
;
2161 if (! htab
->etab
.dynamic_sections_created
)
2163 /* Won't be used, but be safe. */
2164 for (; local_plt
< end_local_plt
; ++local_plt
)
2165 *local_plt
= (bfd_vma
) -1;
2169 sec
= htab
->etab
.splt
;
2170 srel
= htab
->etab
.srelplt
;
2171 for (; local_plt
< end_local_plt
; ++local_plt
)
2175 *local_plt
= sec
->size
;
2176 sec
->size
+= PLT_ENTRY_SIZE
;
2177 if (bfd_link_pic (info
))
2178 srel
->size
+= sizeof (Elf32_External_Rela
);
2181 *local_plt
= (bfd_vma
) -1;
2186 if (htab
->tls_ldm_got
.refcount
> 0)
2188 /* Allocate 2 got entries and 1 dynamic reloc for
2189 R_PARISC_TLS_DTPMOD32 relocs. */
2190 htab
->tls_ldm_got
.offset
= htab
->etab
.sgot
->size
;
2191 htab
->etab
.sgot
->size
+= (GOT_ENTRY_SIZE
* 2);
2192 htab
->etab
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
2195 htab
->tls_ldm_got
.offset
= -1;
2197 /* Do all the .plt entries without relocs first. The dynamic linker
2198 uses the last .plt reloc to find the end of the .plt (and hence
2199 the start of the .got) for lazy linking. */
2200 elf_link_hash_traverse (&htab
->etab
, allocate_plt_static
, info
);
2202 /* Allocate global sym .plt and .got entries, and space for global
2203 sym dynamic relocs. */
2204 elf_link_hash_traverse (&htab
->etab
, allocate_dynrelocs
, info
);
2206 /* The check_relocs and adjust_dynamic_symbol entry points have
2207 determined the sizes of the various dynamic sections. Allocate
2210 for (sec
= dynobj
->sections
; sec
!= NULL
; sec
= sec
->next
)
2212 if ((sec
->flags
& SEC_LINKER_CREATED
) == 0)
2215 if (sec
== htab
->etab
.splt
)
2217 if (htab
->need_plt_stub
)
2219 /* Make space for the plt stub at the end of the .plt
2220 section. We want this stub right at the end, up
2221 against the .got section. */
2222 int gotalign
= bfd_section_alignment (htab
->etab
.sgot
);
2223 int pltalign
= bfd_section_alignment (sec
);
2224 int align
= gotalign
> 3 ? gotalign
: 3;
2227 if (align
> pltalign
)
2228 bfd_set_section_alignment (sec
, align
);
2229 mask
= ((bfd_size_type
) 1 << gotalign
) - 1;
2230 sec
->size
= (sec
->size
+ sizeof (plt_stub
) + mask
) & ~mask
;
2233 else if (sec
== htab
->etab
.sgot
2234 || sec
== htab
->etab
.sdynbss
2235 || sec
== htab
->etab
.sdynrelro
)
2237 else if (CONST_STRNEQ (bfd_section_name (sec
), ".rela"))
2241 /* Remember whether there are any reloc sections other
2243 if (sec
!= htab
->etab
.srelplt
)
2246 /* We use the reloc_count field as a counter if we need
2247 to copy relocs into the output file. */
2248 sec
->reloc_count
= 0;
2253 /* It's not one of our sections, so don't allocate space. */
2259 /* If we don't need this section, strip it from the
2260 output file. This is mostly to handle .rela.bss and
2261 .rela.plt. We must create both sections in
2262 create_dynamic_sections, because they must be created
2263 before the linker maps input sections to output
2264 sections. The linker does that before
2265 adjust_dynamic_symbol is called, and it is that
2266 function which decides whether anything needs to go
2267 into these sections. */
2268 sec
->flags
|= SEC_EXCLUDE
;
2272 if ((sec
->flags
& SEC_HAS_CONTENTS
) == 0)
2275 /* Allocate memory for the section contents. Zero it, because
2276 we may not fill in all the reloc sections. */
2277 sec
->contents
= bfd_zalloc (dynobj
, sec
->size
);
2278 if (sec
->contents
== NULL
)
2282 return _bfd_elf_add_dynamic_tags (output_bfd
, info
, relocs
);
2285 /* External entry points for sizing and building linker stubs. */
2287 /* Set up various things so that we can make a list of input sections
2288 for each output section included in the link. Returns -1 on error,
2289 0 when no stubs will be needed, and 1 on success. */
2292 elf32_hppa_setup_section_lists (bfd
*output_bfd
, struct bfd_link_info
*info
)
2295 unsigned int bfd_count
;
2296 unsigned int top_id
, top_index
;
2298 asection
**input_list
, **list
;
2300 struct elf32_hppa_link_hash_table
*htab
= hppa_link_hash_table (info
);
2305 /* Count the number of input BFDs and find the top input section id. */
2306 for (input_bfd
= info
->input_bfds
, bfd_count
= 0, top_id
= 0;
2308 input_bfd
= input_bfd
->link
.next
)
2311 for (section
= input_bfd
->sections
;
2313 section
= section
->next
)
2315 if (top_id
< section
->id
)
2316 top_id
= section
->id
;
2319 htab
->bfd_count
= bfd_count
;
2321 amt
= sizeof (struct map_stub
) * (top_id
+ 1);
2322 htab
->stub_group
= bfd_zmalloc (amt
);
2323 if (htab
->stub_group
== NULL
)
2326 /* We can't use output_bfd->section_count here to find the top output
2327 section index as some sections may have been removed, and
2328 strip_excluded_output_sections doesn't renumber the indices. */
2329 for (section
= output_bfd
->sections
, top_index
= 0;
2331 section
= section
->next
)
2333 if (top_index
< section
->index
)
2334 top_index
= section
->index
;
2337 htab
->top_index
= top_index
;
2338 amt
= sizeof (asection
*) * (top_index
+ 1);
2339 input_list
= bfd_malloc (amt
);
2340 htab
->input_list
= input_list
;
2341 if (input_list
== NULL
)
2344 /* For sections we aren't interested in, mark their entries with a
2345 value we can check later. */
2346 list
= input_list
+ top_index
;
2348 *list
= bfd_abs_section_ptr
;
2349 while (list
-- != input_list
);
2351 for (section
= output_bfd
->sections
;
2353 section
= section
->next
)
2355 if ((section
->flags
& SEC_CODE
) != 0)
2356 input_list
[section
->index
] = NULL
;
2362 /* The linker repeatedly calls this function for each input section,
2363 in the order that input sections are linked into output sections.
2364 Build lists of input sections to determine groupings between which
2365 we may insert linker stubs. */
2368 elf32_hppa_next_input_section (struct bfd_link_info
*info
, asection
*isec
)
2370 struct elf32_hppa_link_hash_table
*htab
= hppa_link_hash_table (info
);
2375 if (isec
->output_section
->index
<= htab
->top_index
)
2377 asection
**list
= htab
->input_list
+ isec
->output_section
->index
;
2378 if (*list
!= bfd_abs_section_ptr
)
2380 /* Steal the link_sec pointer for our list. */
2381 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
2382 /* This happens to make the list in reverse order,
2383 which is what we want. */
2384 PREV_SEC (isec
) = *list
;
2390 /* See whether we can group stub sections together. Grouping stub
2391 sections may result in fewer stubs. More importantly, we need to
2392 put all .init* and .fini* stubs at the beginning of the .init or
2393 .fini output sections respectively, because glibc splits the
2394 _init and _fini functions into multiple parts. Putting a stub in
2395 the middle of a function is not a good idea. */
2398 group_sections (struct elf32_hppa_link_hash_table
*htab
,
2399 bfd_size_type stub_group_size
,
2400 bfd_boolean stubs_always_before_branch
)
2402 asection
**list
= htab
->input_list
+ htab
->top_index
;
2405 asection
*tail
= *list
;
2406 if (tail
== bfd_abs_section_ptr
)
2408 while (tail
!= NULL
)
2412 bfd_size_type total
;
2413 bfd_boolean big_sec
;
2417 big_sec
= total
>= stub_group_size
;
2419 while ((prev
= PREV_SEC (curr
)) != NULL
2420 && ((total
+= curr
->output_offset
- prev
->output_offset
)
2424 /* OK, the size from the start of CURR to the end is less
2425 than 240000 bytes and thus can be handled by one stub
2426 section. (or the tail section is itself larger than
2427 240000 bytes, in which case we may be toast.)
2428 We should really be keeping track of the total size of
2429 stubs added here, as stubs contribute to the final output
2430 section size. That's a little tricky, and this way will
2431 only break if stubs added total more than 22144 bytes, or
2432 2768 long branch stubs. It seems unlikely for more than
2433 2768 different functions to be called, especially from
2434 code only 240000 bytes long. This limit used to be
2435 250000, but c++ code tends to generate lots of little
2436 functions, and sometimes violated the assumption. */
2439 prev
= PREV_SEC (tail
);
2440 /* Set up this stub group. */
2441 htab
->stub_group
[tail
->id
].link_sec
= curr
;
2443 while (tail
!= curr
&& (tail
= prev
) != NULL
);
2445 /* But wait, there's more! Input sections up to 240000
2446 bytes before the stub section can be handled by it too.
2447 Don't do this if we have a really large section after the
2448 stubs, as adding more stubs increases the chance that
2449 branches may not reach into the stub section. */
2450 if (!stubs_always_before_branch
&& !big_sec
)
2454 && ((total
+= tail
->output_offset
- prev
->output_offset
)
2458 prev
= PREV_SEC (tail
);
2459 htab
->stub_group
[tail
->id
].link_sec
= curr
;
2465 while (list
-- != htab
->input_list
);
2466 free (htab
->input_list
);
2470 /* Read in all local syms for all input bfds, and create hash entries
2471 for export stubs if we are building a multi-subspace shared lib.
2472 Returns -1 on error, 1 if export stubs created, 0 otherwise. */
2475 get_local_syms (bfd
*output_bfd
, bfd
*input_bfd
, struct bfd_link_info
*info
)
2477 unsigned int bfd_indx
;
2478 Elf_Internal_Sym
*local_syms
, **all_local_syms
;
2479 int stub_changed
= 0;
2480 struct elf32_hppa_link_hash_table
*htab
= hppa_link_hash_table (info
);
2485 /* We want to read in symbol extension records only once. To do this
2486 we need to read in the local symbols in parallel and save them for
2487 later use; so hold pointers to the local symbols in an array. */
2488 size_t amt
= sizeof (Elf_Internal_Sym
*) * htab
->bfd_count
;
2489 all_local_syms
= bfd_zmalloc (amt
);
2490 htab
->all_local_syms
= all_local_syms
;
2491 if (all_local_syms
== NULL
)
2494 /* Walk over all the input BFDs, swapping in local symbols.
2495 If we are creating a shared library, create hash entries for the
2499 input_bfd
= input_bfd
->link
.next
, bfd_indx
++)
2501 Elf_Internal_Shdr
*symtab_hdr
;
2503 /* We'll need the symbol table in a second. */
2504 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2505 if (symtab_hdr
->sh_info
== 0)
2508 /* We need an array of the local symbols attached to the input bfd. */
2509 local_syms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2510 if (local_syms
== NULL
)
2512 local_syms
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
2513 symtab_hdr
->sh_info
, 0,
2515 /* Cache them for elf_link_input_bfd. */
2516 symtab_hdr
->contents
= (unsigned char *) local_syms
;
2518 if (local_syms
== NULL
)
2521 all_local_syms
[bfd_indx
] = local_syms
;
2523 if (bfd_link_pic (info
) && htab
->multi_subspace
)
2525 struct elf_link_hash_entry
**eh_syms
;
2526 struct elf_link_hash_entry
**eh_symend
;
2527 unsigned int symcount
;
2529 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
2530 - symtab_hdr
->sh_info
);
2531 eh_syms
= (struct elf_link_hash_entry
**) elf_sym_hashes (input_bfd
);
2532 eh_symend
= (struct elf_link_hash_entry
**) (eh_syms
+ symcount
);
2534 /* Look through the global syms for functions; We need to
2535 build export stubs for all globally visible functions. */
2536 for (; eh_syms
< eh_symend
; eh_syms
++)
2538 struct elf32_hppa_link_hash_entry
*hh
;
2540 hh
= hppa_elf_hash_entry (*eh_syms
);
2542 while (hh
->eh
.root
.type
== bfd_link_hash_indirect
2543 || hh
->eh
.root
.type
== bfd_link_hash_warning
)
2544 hh
= hppa_elf_hash_entry (hh
->eh
.root
.u
.i
.link
);
2546 /* At this point in the link, undefined syms have been
2547 resolved, so we need to check that the symbol was
2548 defined in this BFD. */
2549 if ((hh
->eh
.root
.type
== bfd_link_hash_defined
2550 || hh
->eh
.root
.type
== bfd_link_hash_defweak
)
2551 && hh
->eh
.type
== STT_FUNC
2552 && hh
->eh
.root
.u
.def
.section
->output_section
!= NULL
2553 && (hh
->eh
.root
.u
.def
.section
->output_section
->owner
2555 && hh
->eh
.root
.u
.def
.section
->owner
== input_bfd
2556 && hh
->eh
.def_regular
2557 && !hh
->eh
.forced_local
2558 && ELF_ST_VISIBILITY (hh
->eh
.other
) == STV_DEFAULT
)
2561 const char *stub_name
;
2562 struct elf32_hppa_stub_hash_entry
*hsh
;
2564 sec
= hh
->eh
.root
.u
.def
.section
;
2565 stub_name
= hh_name (hh
);
2566 hsh
= hppa_stub_hash_lookup (&htab
->bstab
,
2571 hsh
= hppa_add_stub (stub_name
, sec
, htab
);
2575 hsh
->target_value
= hh
->eh
.root
.u
.def
.value
;
2576 hsh
->target_section
= hh
->eh
.root
.u
.def
.section
;
2577 hsh
->stub_type
= hppa_stub_export
;
2583 /* xgettext:c-format */
2584 _bfd_error_handler (_("%pB: duplicate export stub %s"),
2585 input_bfd
, stub_name
);
2592 return stub_changed
;
2595 /* Determine and set the size of the stub section for a final link.
2597 The basic idea here is to examine all the relocations looking for
2598 PC-relative calls to a target that is unreachable with a "bl"
2602 elf32_hppa_size_stubs
2603 (bfd
*output_bfd
, bfd
*stub_bfd
, struct bfd_link_info
*info
,
2604 bfd_boolean multi_subspace
, bfd_signed_vma group_size
,
2605 asection
* (*add_stub_section
) (const char *, asection
*),
2606 void (*layout_sections_again
) (void))
2608 bfd_size_type stub_group_size
;
2609 bfd_boolean stubs_always_before_branch
;
2610 bfd_boolean stub_changed
;
2611 struct elf32_hppa_link_hash_table
*htab
= hppa_link_hash_table (info
);
2616 /* Stash our params away. */
2617 htab
->stub_bfd
= stub_bfd
;
2618 htab
->multi_subspace
= multi_subspace
;
2619 htab
->add_stub_section
= add_stub_section
;
2620 htab
->layout_sections_again
= layout_sections_again
;
2621 stubs_always_before_branch
= group_size
< 0;
2623 stub_group_size
= -group_size
;
2625 stub_group_size
= group_size
;
2626 if (stub_group_size
== 1)
2628 /* Default values. */
2629 if (stubs_always_before_branch
)
2631 stub_group_size
= 7680000;
2632 if (htab
->has_17bit_branch
|| htab
->multi_subspace
)
2633 stub_group_size
= 240000;
2634 if (htab
->has_12bit_branch
)
2635 stub_group_size
= 7500;
2639 stub_group_size
= 6971392;
2640 if (htab
->has_17bit_branch
|| htab
->multi_subspace
)
2641 stub_group_size
= 217856;
2642 if (htab
->has_12bit_branch
)
2643 stub_group_size
= 6808;
2647 group_sections (htab
, stub_group_size
, stubs_always_before_branch
);
2649 switch (get_local_syms (output_bfd
, info
->input_bfds
, info
))
2652 if (htab
->all_local_syms
)
2653 goto error_ret_free_local
;
2657 stub_changed
= FALSE
;
2661 stub_changed
= TRUE
;
2668 unsigned int bfd_indx
;
2671 for (input_bfd
= info
->input_bfds
, bfd_indx
= 0;
2673 input_bfd
= input_bfd
->link
.next
, bfd_indx
++)
2675 Elf_Internal_Shdr
*symtab_hdr
;
2677 Elf_Internal_Sym
*local_syms
;
2679 /* We'll need the symbol table in a second. */
2680 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2681 if (symtab_hdr
->sh_info
== 0)
2684 local_syms
= htab
->all_local_syms
[bfd_indx
];
2686 /* Walk over each section attached to the input bfd. */
2687 for (section
= input_bfd
->sections
;
2689 section
= section
->next
)
2691 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
2693 /* If there aren't any relocs, then there's nothing more
2695 if ((section
->flags
& SEC_RELOC
) == 0
2696 || (section
->flags
& SEC_ALLOC
) == 0
2697 || (section
->flags
& SEC_LOAD
) == 0
2698 || (section
->flags
& SEC_CODE
) == 0
2699 || section
->reloc_count
== 0)
2702 /* If this section is a link-once section that will be
2703 discarded, then don't create any stubs. */
2704 if (section
->output_section
== NULL
2705 || section
->output_section
->owner
!= output_bfd
)
2708 /* Get the relocs. */
2710 = _bfd_elf_link_read_relocs (input_bfd
, section
, NULL
, NULL
,
2712 if (internal_relocs
== NULL
)
2713 goto error_ret_free_local
;
2715 /* Now examine each relocation. */
2716 irela
= internal_relocs
;
2717 irelaend
= irela
+ section
->reloc_count
;
2718 for (; irela
< irelaend
; irela
++)
2720 unsigned int r_type
, r_indx
;
2721 enum elf32_hppa_stub_type stub_type
;
2722 struct elf32_hppa_stub_hash_entry
*hsh
;
2725 bfd_vma destination
;
2726 struct elf32_hppa_link_hash_entry
*hh
;
2728 const asection
*id_sec
;
2730 r_type
= ELF32_R_TYPE (irela
->r_info
);
2731 r_indx
= ELF32_R_SYM (irela
->r_info
);
2733 if (r_type
>= (unsigned int) R_PARISC_UNIMPLEMENTED
)
2735 bfd_set_error (bfd_error_bad_value
);
2736 error_ret_free_internal
:
2737 if (elf_section_data (section
)->relocs
== NULL
)
2738 free (internal_relocs
);
2739 goto error_ret_free_local
;
2742 /* Only look for stubs on call instructions. */
2743 if (r_type
!= (unsigned int) R_PARISC_PCREL12F
2744 && r_type
!= (unsigned int) R_PARISC_PCREL17F
2745 && r_type
!= (unsigned int) R_PARISC_PCREL22F
)
2748 /* Now determine the call target, its name, value,
2754 if (r_indx
< symtab_hdr
->sh_info
)
2756 /* It's a local symbol. */
2757 Elf_Internal_Sym
*sym
;
2758 Elf_Internal_Shdr
*hdr
;
2761 sym
= local_syms
+ r_indx
;
2762 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
2763 sym_value
= sym
->st_value
;
2764 shndx
= sym
->st_shndx
;
2765 if (shndx
< elf_numsections (input_bfd
))
2767 hdr
= elf_elfsections (input_bfd
)[shndx
];
2768 sym_sec
= hdr
->bfd_section
;
2769 destination
= (sym_value
+ irela
->r_addend
2770 + sym_sec
->output_offset
2771 + sym_sec
->output_section
->vma
);
2776 /* It's an external symbol. */
2779 e_indx
= r_indx
- symtab_hdr
->sh_info
;
2780 hh
= hppa_elf_hash_entry (elf_sym_hashes (input_bfd
)[e_indx
]);
2782 while (hh
->eh
.root
.type
== bfd_link_hash_indirect
2783 || hh
->eh
.root
.type
== bfd_link_hash_warning
)
2784 hh
= hppa_elf_hash_entry (hh
->eh
.root
.u
.i
.link
);
2786 if (hh
->eh
.root
.type
== bfd_link_hash_defined
2787 || hh
->eh
.root
.type
== bfd_link_hash_defweak
)
2789 sym_sec
= hh
->eh
.root
.u
.def
.section
;
2790 sym_value
= hh
->eh
.root
.u
.def
.value
;
2791 if (sym_sec
->output_section
!= NULL
)
2792 destination
= (sym_value
+ irela
->r_addend
2793 + sym_sec
->output_offset
2794 + sym_sec
->output_section
->vma
);
2796 else if (hh
->eh
.root
.type
== bfd_link_hash_undefweak
)
2798 if (! bfd_link_pic (info
))
2801 else if (hh
->eh
.root
.type
== bfd_link_hash_undefined
)
2803 if (! (info
->unresolved_syms_in_objects
== RM_IGNORE
2804 && (ELF_ST_VISIBILITY (hh
->eh
.other
)
2806 && hh
->eh
.type
!= STT_PARISC_MILLI
))
2811 bfd_set_error (bfd_error_bad_value
);
2812 goto error_ret_free_internal
;
2816 /* Determine what (if any) linker stub is needed. */
2817 stub_type
= hppa_type_of_stub (section
, irela
, hh
,
2819 if (stub_type
== hppa_stub_none
)
2822 /* Support for grouping stub sections. */
2823 id_sec
= htab
->stub_group
[section
->id
].link_sec
;
2825 /* Get the name of this stub. */
2826 stub_name
= hppa_stub_name (id_sec
, sym_sec
, hh
, irela
);
2828 goto error_ret_free_internal
;
2830 hsh
= hppa_stub_hash_lookup (&htab
->bstab
,
2835 /* The proper stub has already been created. */
2840 hsh
= hppa_add_stub (stub_name
, section
, htab
);
2844 goto error_ret_free_internal
;
2847 hsh
->target_value
= sym_value
;
2848 hsh
->target_section
= sym_sec
;
2849 hsh
->stub_type
= stub_type
;
2850 if (bfd_link_pic (info
))
2852 if (stub_type
== hppa_stub_import
)
2853 hsh
->stub_type
= hppa_stub_import_shared
;
2854 else if (stub_type
== hppa_stub_long_branch
)
2855 hsh
->stub_type
= hppa_stub_long_branch_shared
;
2858 stub_changed
= TRUE
;
2861 /* We're done with the internal relocs, free them. */
2862 if (elf_section_data (section
)->relocs
== NULL
)
2863 free (internal_relocs
);
2870 /* OK, we've added some stubs. Find out the new size of the
2872 for (stub_sec
= htab
->stub_bfd
->sections
;
2874 stub_sec
= stub_sec
->next
)
2875 if ((stub_sec
->flags
& SEC_LINKER_CREATED
) == 0)
2878 bfd_hash_traverse (&htab
->bstab
, hppa_size_one_stub
, htab
);
2880 /* Ask the linker to do its stuff. */
2881 (*htab
->layout_sections_again
) ();
2882 stub_changed
= FALSE
;
2885 free (htab
->all_local_syms
);
2888 error_ret_free_local
:
2889 free (htab
->all_local_syms
);
2893 /* For a final link, this function is called after we have sized the
2894 stubs to provide a value for __gp. */
2897 elf32_hppa_set_gp (bfd
*abfd
, struct bfd_link_info
*info
)
2899 struct bfd_link_hash_entry
*h
;
2900 asection
*sec
= NULL
;
2903 h
= bfd_link_hash_lookup (info
->hash
, "$global$", FALSE
, FALSE
, FALSE
);
2906 && (h
->type
== bfd_link_hash_defined
2907 || h
->type
== bfd_link_hash_defweak
))
2909 gp_val
= h
->u
.def
.value
;
2910 sec
= h
->u
.def
.section
;
2914 asection
*splt
= bfd_get_section_by_name (abfd
, ".plt");
2915 asection
*sgot
= bfd_get_section_by_name (abfd
, ".got");
2917 /* Choose to point our LTP at, in this order, one of .plt, .got,
2918 or .data, if these sections exist. In the case of choosing
2919 .plt try to make the LTP ideal for addressing anywhere in the
2920 .plt or .got with a 14 bit signed offset. Typically, the end
2921 of the .plt is the start of the .got, so choose .plt + 0x2000
2922 if either the .plt or .got is larger than 0x2000. If both
2923 the .plt and .got are smaller than 0x2000, choose the end of
2924 the .plt section. */
2925 sec
= strcmp (bfd_get_target (abfd
), "elf32-hppa-netbsd") == 0
2930 if (gp_val
> 0x2000 || (sgot
&& sgot
->size
> 0x2000))
2940 if (strcmp (bfd_get_target (abfd
), "elf32-hppa-netbsd") != 0)
2942 /* We know we don't have a .plt. If .got is large,
2944 if (sec
->size
> 0x2000)
2950 /* No .plt or .got. Who cares what the LTP is? */
2951 sec
= bfd_get_section_by_name (abfd
, ".data");
2957 h
->type
= bfd_link_hash_defined
;
2958 h
->u
.def
.value
= gp_val
;
2960 h
->u
.def
.section
= sec
;
2962 h
->u
.def
.section
= bfd_abs_section_ptr
;
2966 if (bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
2968 if (sec
!= NULL
&& sec
->output_section
!= NULL
)
2969 gp_val
+= sec
->output_section
->vma
+ sec
->output_offset
;
2971 elf_gp (abfd
) = gp_val
;
2976 /* Build all the stubs associated with the current output file. The
2977 stubs are kept in a hash table attached to the main linker hash
2978 table. We also set up the .plt entries for statically linked PIC
2979 functions here. This function is called via hppaelf_finish in the
2983 elf32_hppa_build_stubs (struct bfd_link_info
*info
)
2986 struct bfd_hash_table
*table
;
2987 struct elf32_hppa_link_hash_table
*htab
;
2989 htab
= hppa_link_hash_table (info
);
2993 for (stub_sec
= htab
->stub_bfd
->sections
;
2995 stub_sec
= stub_sec
->next
)
2996 if ((stub_sec
->flags
& SEC_LINKER_CREATED
) == 0
2997 && stub_sec
->size
!= 0)
2999 /* Allocate memory to hold the linker stubs. */
3000 stub_sec
->contents
= bfd_zalloc (htab
->stub_bfd
, stub_sec
->size
);
3001 if (stub_sec
->contents
== NULL
)
3006 /* Build the stubs as directed by the stub hash table. */
3007 table
= &htab
->bstab
;
3008 bfd_hash_traverse (table
, hppa_build_one_stub
, info
);
3013 /* Return the base vma address which should be subtracted from the real
3014 address when resolving a dtpoff relocation.
3015 This is PT_TLS segment p_vaddr. */
3018 dtpoff_base (struct bfd_link_info
*info
)
3020 /* If tls_sec is NULL, we should have signalled an error already. */
3021 if (elf_hash_table (info
)->tls_sec
== NULL
)
3023 return elf_hash_table (info
)->tls_sec
->vma
;
3026 /* Return the relocation value for R_PARISC_TLS_TPOFF*.. */
3029 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
3031 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
3033 /* If tls_sec is NULL, we should have signalled an error already. */
3034 if (htab
->tls_sec
== NULL
)
3036 /* hppa TLS ABI is variant I and static TLS block start just after
3037 tcbhead structure which has 2 pointer fields. */
3038 return (address
- htab
->tls_sec
->vma
3039 + align_power ((bfd_vma
) 8, htab
->tls_sec
->alignment_power
));
3042 /* Perform a final link. */
3045 elf32_hppa_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
3049 /* Invoke the regular ELF linker to do all the work. */
3050 if (!bfd_elf_final_link (abfd
, info
))
3053 /* If we're producing a final executable, sort the contents of the
3055 if (bfd_link_relocatable (info
))
3058 /* Do not attempt to sort non-regular files. This is here
3059 especially for configure scripts and kernel builds which run
3060 tests with "ld [...] -o /dev/null". */
3061 if (stat (bfd_get_filename (abfd
), &buf
) != 0
3062 || !S_ISREG(buf
.st_mode
))
3065 return elf_hppa_sort_unwind (abfd
);
3068 /* Record the lowest address for the data and text segments. */
3071 hppa_record_segment_addr (bfd
*abfd
, asection
*section
, void *data
)
3073 struct elf32_hppa_link_hash_table
*htab
;
3075 htab
= (struct elf32_hppa_link_hash_table
*) data
;
3079 if ((section
->flags
& (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
3082 Elf_Internal_Phdr
*p
;
3084 p
= _bfd_elf_find_segment_containing_section (abfd
, section
->output_section
);
3085 BFD_ASSERT (p
!= NULL
);
3088 if ((section
->flags
& SEC_READONLY
) != 0)
3090 if (value
< htab
->text_segment_base
)
3091 htab
->text_segment_base
= value
;
3095 if (value
< htab
->data_segment_base
)
3096 htab
->data_segment_base
= value
;
3101 /* Perform a relocation as part of a final link. */
3103 static bfd_reloc_status_type
3104 final_link_relocate (asection
*input_section
,
3106 const Elf_Internal_Rela
*rela
,
3108 struct elf32_hppa_link_hash_table
*htab
,
3110 struct elf32_hppa_link_hash_entry
*hh
,
3111 struct bfd_link_info
*info
)
3114 unsigned int r_type
= ELF32_R_TYPE (rela
->r_info
);
3115 unsigned int orig_r_type
= r_type
;
3116 reloc_howto_type
*howto
= elf_hppa_howto_table
+ r_type
;
3117 int r_format
= howto
->bitsize
;
3118 enum hppa_reloc_field_selector_type_alt r_field
;
3119 bfd
*input_bfd
= input_section
->owner
;
3120 bfd_vma offset
= rela
->r_offset
;
3121 bfd_vma max_branch_offset
= 0;
3122 bfd_byte
*hit_data
= contents
+ offset
;
3123 bfd_signed_vma addend
= rela
->r_addend
;
3125 struct elf32_hppa_stub_hash_entry
*hsh
= NULL
;
3128 if (r_type
== R_PARISC_NONE
)
3129 return bfd_reloc_ok
;
3131 insn
= bfd_get_32 (input_bfd
, hit_data
);
3133 /* Find out where we are and where we're going. */
3134 location
= (offset
+
3135 input_section
->output_offset
+
3136 input_section
->output_section
->vma
);
3138 /* If we are not building a shared library, convert DLTIND relocs to
3140 if (!bfd_link_pic (info
))
3144 case R_PARISC_DLTIND21L
:
3145 case R_PARISC_TLS_GD21L
:
3146 case R_PARISC_TLS_LDM21L
:
3147 case R_PARISC_TLS_IE21L
:
3148 r_type
= R_PARISC_DPREL21L
;
3151 case R_PARISC_DLTIND14R
:
3152 case R_PARISC_TLS_GD14R
:
3153 case R_PARISC_TLS_LDM14R
:
3154 case R_PARISC_TLS_IE14R
:
3155 r_type
= R_PARISC_DPREL14R
;
3158 case R_PARISC_DLTIND14F
:
3159 r_type
= R_PARISC_DPREL14F
;
3166 case R_PARISC_PCREL12F
:
3167 case R_PARISC_PCREL17F
:
3168 case R_PARISC_PCREL22F
:
3169 /* If this call should go via the plt, find the import stub in
3172 || sym_sec
->output_section
== NULL
3174 && hh
->eh
.plt
.offset
!= (bfd_vma
) -1
3175 && hh
->eh
.dynindx
!= -1
3177 && (bfd_link_pic (info
)
3178 || !hh
->eh
.def_regular
3179 || hh
->eh
.root
.type
== bfd_link_hash_defweak
)))
3181 hsh
= hppa_get_stub_entry (input_section
, sym_sec
,
3185 value
= (hsh
->stub_offset
3186 + hsh
->stub_sec
->output_offset
3187 + hsh
->stub_sec
->output_section
->vma
);
3190 else if (sym_sec
== NULL
&& hh
!= NULL
3191 && hh
->eh
.root
.type
== bfd_link_hash_undefweak
)
3193 /* It's OK if undefined weak. Calls to undefined weak
3194 symbols behave as if the "called" function
3195 immediately returns. We can thus call to a weak
3196 function without first checking whether the function
3202 return bfd_reloc_undefined
;
3206 case R_PARISC_PCREL21L
:
3207 case R_PARISC_PCREL17C
:
3208 case R_PARISC_PCREL17R
:
3209 case R_PARISC_PCREL14R
:
3210 case R_PARISC_PCREL14F
:
3211 case R_PARISC_PCREL32
:
3212 /* Make it a pc relative offset. */
3217 case R_PARISC_DPREL21L
:
3218 case R_PARISC_DPREL14R
:
3219 case R_PARISC_DPREL14F
:
3220 /* Convert instructions that use the linkage table pointer (r19) to
3221 instructions that use the global data pointer (dp). This is the
3222 most efficient way of using PIC code in an incomplete executable,
3223 but the user must follow the standard runtime conventions for
3224 accessing data for this to work. */
3225 if (orig_r_type
!= r_type
)
3227 if (r_type
== R_PARISC_DPREL21L
)
3229 /* GCC sometimes uses a register other than r19 for the
3230 operation, so we must convert any addil instruction
3231 that uses this relocation. */
3232 if ((insn
& 0xfc000000) == OP_ADDIL
<< 26)
3235 /* We must have a ldil instruction. It's too hard to find
3236 and convert the associated add instruction, so issue an
3239 /* xgettext:c-format */
3240 (_("%pB(%pA+%#" PRIx64
"): %s fixup for insn %#x "
3241 "is not supported in a non-shared link"),
3248 else if (r_type
== R_PARISC_DPREL14F
)
3250 /* This must be a format 1 load/store. Change the base
3252 insn
= (insn
& 0xfc1ffff) | (27 << 21);
3256 /* For all the DP relative relocations, we need to examine the symbol's
3257 section. If it has no section or if it's a code section, then
3258 "data pointer relative" makes no sense. In that case we don't
3259 adjust the "value", and for 21 bit addil instructions, we change the
3260 source addend register from %dp to %r0. This situation commonly
3261 arises for undefined weak symbols and when a variable's "constness"
3262 is declared differently from the way the variable is defined. For
3263 instance: "extern int foo" with foo defined as "const int foo". */
3264 if (sym_sec
== NULL
|| (sym_sec
->flags
& SEC_CODE
) != 0)
3266 if ((insn
& ((0x3fu
<< 26) | (0x1f << 21)))
3267 == ((OP_ADDIL
<< 26) | (27 << 21)))
3269 insn
&= ~ (0x1f << 21);
3271 /* Now try to make things easy for the dynamic linker. */
3277 case R_PARISC_DLTIND21L
:
3278 case R_PARISC_DLTIND14R
:
3279 case R_PARISC_DLTIND14F
:
3280 case R_PARISC_TLS_GD21L
:
3281 case R_PARISC_TLS_LDM21L
:
3282 case R_PARISC_TLS_IE21L
:
3283 case R_PARISC_TLS_GD14R
:
3284 case R_PARISC_TLS_LDM14R
:
3285 case R_PARISC_TLS_IE14R
:
3286 value
-= elf_gp (input_section
->output_section
->owner
);
3289 case R_PARISC_SEGREL32
:
3290 if ((sym_sec
->flags
& SEC_CODE
) != 0)
3291 value
-= htab
->text_segment_base
;
3293 value
-= htab
->data_segment_base
;
3302 case R_PARISC_DIR32
:
3303 case R_PARISC_DIR14F
:
3304 case R_PARISC_DIR17F
:
3305 case R_PARISC_PCREL17C
:
3306 case R_PARISC_PCREL14F
:
3307 case R_PARISC_PCREL32
:
3308 case R_PARISC_DPREL14F
:
3309 case R_PARISC_PLABEL32
:
3310 case R_PARISC_DLTIND14F
:
3311 case R_PARISC_SEGBASE
:
3312 case R_PARISC_SEGREL32
:
3313 case R_PARISC_TLS_DTPMOD32
:
3314 case R_PARISC_TLS_DTPOFF32
:
3315 case R_PARISC_TLS_TPREL32
:
3319 case R_PARISC_DLTIND21L
:
3320 case R_PARISC_PCREL21L
:
3321 case R_PARISC_PLABEL21L
:
3325 case R_PARISC_DIR21L
:
3326 case R_PARISC_DPREL21L
:
3327 case R_PARISC_TLS_GD21L
:
3328 case R_PARISC_TLS_LDM21L
:
3329 case R_PARISC_TLS_LDO21L
:
3330 case R_PARISC_TLS_IE21L
:
3331 case R_PARISC_TLS_LE21L
:
3335 case R_PARISC_PCREL17R
:
3336 case R_PARISC_PCREL14R
:
3337 case R_PARISC_PLABEL14R
:
3338 case R_PARISC_DLTIND14R
:
3342 case R_PARISC_DIR17R
:
3343 case R_PARISC_DIR14R
:
3344 case R_PARISC_DPREL14R
:
3345 case R_PARISC_TLS_GD14R
:
3346 case R_PARISC_TLS_LDM14R
:
3347 case R_PARISC_TLS_LDO14R
:
3348 case R_PARISC_TLS_IE14R
:
3349 case R_PARISC_TLS_LE14R
:
3353 case R_PARISC_PCREL12F
:
3354 case R_PARISC_PCREL17F
:
3355 case R_PARISC_PCREL22F
:
3358 if (r_type
== (unsigned int) R_PARISC_PCREL17F
)
3360 max_branch_offset
= (1 << (17-1)) << 2;
3362 else if (r_type
== (unsigned int) R_PARISC_PCREL12F
)
3364 max_branch_offset
= (1 << (12-1)) << 2;
3368 max_branch_offset
= (1 << (22-1)) << 2;
3371 /* sym_sec is NULL on undefined weak syms or when shared on
3372 undefined syms. We've already checked for a stub for the
3373 shared undefined case. */
3374 if (sym_sec
== NULL
)
3377 /* If the branch is out of reach, then redirect the
3378 call to the local stub for this function. */
3379 if (value
+ addend
+ max_branch_offset
>= 2*max_branch_offset
)
3381 hsh
= hppa_get_stub_entry (input_section
, sym_sec
,
3384 return bfd_reloc_undefined
;
3386 /* Munge up the value and addend so that we call the stub
3387 rather than the procedure directly. */
3388 value
= (hsh
->stub_offset
3389 + hsh
->stub_sec
->output_offset
3390 + hsh
->stub_sec
->output_section
->vma
3396 /* Something we don't know how to handle. */
3398 return bfd_reloc_notsupported
;
3401 /* Make sure we can reach the stub. */
3402 if (max_branch_offset
!= 0
3403 && value
+ addend
+ max_branch_offset
>= 2*max_branch_offset
)
3406 /* xgettext:c-format */
3407 (_("%pB(%pA+%#" PRIx64
"): cannot reach %s, "
3408 "recompile with -ffunction-sections"),
3412 hsh
->bh_root
.string
);
3413 bfd_set_error (bfd_error_bad_value
);
3414 return bfd_reloc_notsupported
;
3417 val
= hppa_field_adjust (value
, addend
, r_field
);
3421 case R_PARISC_PCREL12F
:
3422 case R_PARISC_PCREL17C
:
3423 case R_PARISC_PCREL17F
:
3424 case R_PARISC_PCREL17R
:
3425 case R_PARISC_PCREL22F
:
3426 case R_PARISC_DIR17F
:
3427 case R_PARISC_DIR17R
:
3428 /* This is a branch. Divide the offset by four.
3429 Note that we need to decide whether it's a branch or
3430 otherwise by inspecting the reloc. Inspecting insn won't
3431 work as insn might be from a .word directive. */
3439 insn
= hppa_rebuild_insn (insn
, val
, r_format
);
3441 /* Update the instruction word. */
3442 bfd_put_32 (input_bfd
, (bfd_vma
) insn
, hit_data
);
3443 return bfd_reloc_ok
;
3446 /* Relocate an HPPA ELF section. */
3449 elf32_hppa_relocate_section (bfd
*output_bfd
,
3450 struct bfd_link_info
*info
,
3452 asection
*input_section
,
3454 Elf_Internal_Rela
*relocs
,
3455 Elf_Internal_Sym
*local_syms
,
3456 asection
**local_sections
)
3458 bfd_vma
*local_got_offsets
;
3459 struct elf32_hppa_link_hash_table
*htab
;
3460 Elf_Internal_Shdr
*symtab_hdr
;
3461 Elf_Internal_Rela
*rela
;
3462 Elf_Internal_Rela
*relend
;
3464 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3466 htab
= hppa_link_hash_table (info
);
3470 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3473 relend
= relocs
+ input_section
->reloc_count
;
3474 for (; rela
< relend
; rela
++)
3476 unsigned int r_type
;
3477 reloc_howto_type
*howto
;
3478 unsigned int r_symndx
;
3479 struct elf32_hppa_link_hash_entry
*hh
;
3480 Elf_Internal_Sym
*sym
;
3483 bfd_reloc_status_type rstatus
;
3484 const char *sym_name
;
3486 bfd_boolean warned_undef
;
3488 r_type
= ELF32_R_TYPE (rela
->r_info
);
3489 if (r_type
>= (unsigned int) R_PARISC_UNIMPLEMENTED
)
3491 bfd_set_error (bfd_error_bad_value
);
3494 if (r_type
== (unsigned int) R_PARISC_GNU_VTENTRY
3495 || r_type
== (unsigned int) R_PARISC_GNU_VTINHERIT
)
3498 r_symndx
= ELF32_R_SYM (rela
->r_info
);
3502 warned_undef
= FALSE
;
3503 if (r_symndx
< symtab_hdr
->sh_info
)
3505 /* This is a local symbol, h defaults to NULL. */
3506 sym
= local_syms
+ r_symndx
;
3507 sym_sec
= local_sections
[r_symndx
];
3508 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sym_sec
, rela
);
3512 struct elf_link_hash_entry
*eh
;
3513 bfd_boolean unresolved_reloc
, ignored
;
3514 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
3516 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rela
,
3517 r_symndx
, symtab_hdr
, sym_hashes
,
3518 eh
, sym_sec
, relocation
,
3519 unresolved_reloc
, warned_undef
,
3522 if (!bfd_link_relocatable (info
)
3524 && eh
->root
.type
!= bfd_link_hash_defined
3525 && eh
->root
.type
!= bfd_link_hash_defweak
3526 && eh
->root
.type
!= bfd_link_hash_undefweak
)
3528 if (info
->unresolved_syms_in_objects
== RM_IGNORE
3529 && ELF_ST_VISIBILITY (eh
->other
) == STV_DEFAULT
3530 && eh
->type
== STT_PARISC_MILLI
)
3532 (*info
->callbacks
->undefined_symbol
)
3533 (info
, eh_name (eh
), input_bfd
,
3534 input_section
, rela
->r_offset
, FALSE
);
3535 warned_undef
= TRUE
;
3538 hh
= hppa_elf_hash_entry (eh
);
3541 if (sym_sec
!= NULL
&& discarded_section (sym_sec
))
3542 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3544 elf_hppa_howto_table
+ r_type
, 0,
3547 if (bfd_link_relocatable (info
))
3550 /* Do any required modifications to the relocation value, and
3551 determine what types of dynamic info we need to output, if
3556 case R_PARISC_DLTIND14F
:
3557 case R_PARISC_DLTIND14R
:
3558 case R_PARISC_DLTIND21L
:
3561 bfd_boolean do_got
= FALSE
;
3562 bfd_boolean reloc
= bfd_link_pic (info
);
3564 /* Relocation is to the entry for this symbol in the
3565 global offset table. */
3570 off
= hh
->eh
.got
.offset
;
3571 dyn
= htab
->etab
.dynamic_sections_created
;
3572 reloc
= (!UNDEFWEAK_NO_DYNAMIC_RELOC (info
, &hh
->eh
)
3574 || (hh
->eh
.dynindx
!= -1
3575 && !SYMBOL_REFERENCES_LOCAL (info
, &hh
->eh
))));
3577 || !WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
3578 bfd_link_pic (info
),
3581 /* If we aren't going to call finish_dynamic_symbol,
3582 then we need to handle initialisation of the .got
3583 entry and create needed relocs here. Since the
3584 offset must always be a multiple of 4, we use the
3585 least significant bit to record whether we have
3586 initialised it already. */
3591 hh
->eh
.got
.offset
|= 1;
3598 /* Local symbol case. */
3599 if (local_got_offsets
== NULL
)
3602 off
= local_got_offsets
[r_symndx
];
3604 /* The offset must always be a multiple of 4. We use
3605 the least significant bit to record whether we have
3606 already generated the necessary reloc. */
3611 local_got_offsets
[r_symndx
] |= 1;
3620 /* Output a dynamic relocation for this GOT entry.
3621 In this case it is relative to the base of the
3622 object because the symbol index is zero. */
3623 Elf_Internal_Rela outrel
;
3625 asection
*sec
= htab
->etab
.srelgot
;
3627 outrel
.r_offset
= (off
3628 + htab
->etab
.sgot
->output_offset
3629 + htab
->etab
.sgot
->output_section
->vma
);
3630 outrel
.r_info
= ELF32_R_INFO (0, R_PARISC_DIR32
);
3631 outrel
.r_addend
= relocation
;
3632 loc
= sec
->contents
;
3633 loc
+= sec
->reloc_count
++ * sizeof (Elf32_External_Rela
);
3634 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
3637 bfd_put_32 (output_bfd
, relocation
,
3638 htab
->etab
.sgot
->contents
+ off
);
3641 if (off
>= (bfd_vma
) -2)
3644 /* Add the base of the GOT to the relocation value. */
3646 + htab
->etab
.sgot
->output_offset
3647 + htab
->etab
.sgot
->output_section
->vma
);
3651 case R_PARISC_SEGREL32
:
3652 /* If this is the first SEGREL relocation, then initialize
3653 the segment base values. */
3654 if (htab
->text_segment_base
== (bfd_vma
) -1)
3655 bfd_map_over_sections (output_bfd
, hppa_record_segment_addr
, htab
);
3658 case R_PARISC_PLABEL14R
:
3659 case R_PARISC_PLABEL21L
:
3660 case R_PARISC_PLABEL32
:
3661 if (htab
->etab
.dynamic_sections_created
)
3664 bfd_boolean do_plt
= 0;
3665 /* If we have a global symbol with a PLT slot, then
3666 redirect this relocation to it. */
3669 off
= hh
->eh
.plt
.offset
;
3670 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (1,
3671 bfd_link_pic (info
),
3674 /* In a non-shared link, adjust_dynamic_symbol
3675 isn't called for symbols forced local. We
3676 need to write out the plt entry here. */
3681 hh
->eh
.plt
.offset
|= 1;
3688 bfd_vma
*local_plt_offsets
;
3690 if (local_got_offsets
== NULL
)
3693 local_plt_offsets
= local_got_offsets
+ symtab_hdr
->sh_info
;
3694 off
= local_plt_offsets
[r_symndx
];
3696 /* As for the local .got entry case, we use the last
3697 bit to record whether we've already initialised
3698 this local .plt entry. */
3703 local_plt_offsets
[r_symndx
] |= 1;
3710 if (bfd_link_pic (info
))
3712 /* Output a dynamic IPLT relocation for this
3714 Elf_Internal_Rela outrel
;
3716 asection
*s
= htab
->etab
.srelplt
;
3718 outrel
.r_offset
= (off
3719 + htab
->etab
.splt
->output_offset
3720 + htab
->etab
.splt
->output_section
->vma
);
3721 outrel
.r_info
= ELF32_R_INFO (0, R_PARISC_IPLT
);
3722 outrel
.r_addend
= relocation
;
3724 loc
+= s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
3725 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
3729 bfd_put_32 (output_bfd
,
3731 htab
->etab
.splt
->contents
+ off
);
3732 bfd_put_32 (output_bfd
,
3733 elf_gp (htab
->etab
.splt
->output_section
->owner
),
3734 htab
->etab
.splt
->contents
+ off
+ 4);
3738 if (off
>= (bfd_vma
) -2)
3741 /* PLABELs contain function pointers. Relocation is to
3742 the entry for the function in the .plt. The magic +2
3743 offset signals to $$dyncall that the function pointer
3744 is in the .plt and thus has a gp pointer too.
3745 Exception: Undefined PLABELs should have a value of
3748 || (hh
->eh
.root
.type
!= bfd_link_hash_undefweak
3749 && hh
->eh
.root
.type
!= bfd_link_hash_undefined
))
3752 + htab
->etab
.splt
->output_offset
3753 + htab
->etab
.splt
->output_section
->vma
3760 case R_PARISC_DIR17F
:
3761 case R_PARISC_DIR17R
:
3762 case R_PARISC_DIR14F
:
3763 case R_PARISC_DIR14R
:
3764 case R_PARISC_DIR21L
:
3765 case R_PARISC_DPREL14F
:
3766 case R_PARISC_DPREL14R
:
3767 case R_PARISC_DPREL21L
:
3768 case R_PARISC_DIR32
:
3769 if ((input_section
->flags
& SEC_ALLOC
) == 0)
3772 if (bfd_link_pic (info
)
3774 || hh
->eh
.dyn_relocs
!= NULL
)
3775 && ((hh
!= NULL
&& pc_dynrelocs (hh
))
3776 || IS_ABSOLUTE_RELOC (r_type
)))
3778 && hh
->eh
.dyn_relocs
!= NULL
))
3780 Elf_Internal_Rela outrel
;
3785 /* When generating a shared object, these relocations
3786 are copied into the output file to be resolved at run
3789 outrel
.r_addend
= rela
->r_addend
;
3791 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
3793 skip
= (outrel
.r_offset
== (bfd_vma
) -1
3794 || outrel
.r_offset
== (bfd_vma
) -2);
3795 outrel
.r_offset
+= (input_section
->output_offset
3796 + input_section
->output_section
->vma
);
3800 memset (&outrel
, 0, sizeof (outrel
));
3803 && hh
->eh
.dynindx
!= -1
3805 || !IS_ABSOLUTE_RELOC (r_type
)
3806 || !bfd_link_pic (info
)
3807 || !SYMBOLIC_BIND (info
, &hh
->eh
)
3808 || !hh
->eh
.def_regular
))
3810 outrel
.r_info
= ELF32_R_INFO (hh
->eh
.dynindx
, r_type
);
3812 else /* It's a local symbol, or one marked to become local. */
3816 /* Add the absolute offset of the symbol. */
3817 outrel
.r_addend
+= relocation
;
3819 /* Global plabels need to be processed by the
3820 dynamic linker so that functions have at most one
3821 fptr. For this reason, we need to differentiate
3822 between global and local plabels, which we do by
3823 providing the function symbol for a global plabel
3824 reloc, and no symbol for local plabels. */
3827 && sym_sec
->output_section
!= NULL
3828 && ! bfd_is_abs_section (sym_sec
))
3832 osec
= sym_sec
->output_section
;
3833 indx
= elf_section_data (osec
)->dynindx
;
3836 osec
= htab
->etab
.text_index_section
;
3837 indx
= elf_section_data (osec
)->dynindx
;
3839 BFD_ASSERT (indx
!= 0);
3841 /* We are turning this relocation into one
3842 against a section symbol, so subtract out the
3843 output section's address but not the offset
3844 of the input section in the output section. */
3845 outrel
.r_addend
-= osec
->vma
;
3848 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
3850 sreloc
= elf_section_data (input_section
)->sreloc
;
3854 loc
= sreloc
->contents
;
3855 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
3856 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
3860 case R_PARISC_TLS_LDM21L
:
3861 case R_PARISC_TLS_LDM14R
:
3865 off
= htab
->tls_ldm_got
.offset
;
3870 Elf_Internal_Rela outrel
;
3873 outrel
.r_offset
= (off
3874 + htab
->etab
.sgot
->output_section
->vma
3875 + htab
->etab
.sgot
->output_offset
);
3876 outrel
.r_addend
= 0;
3877 outrel
.r_info
= ELF32_R_INFO (0, R_PARISC_TLS_DTPMOD32
);
3878 loc
= htab
->etab
.srelgot
->contents
;
3879 loc
+= htab
->etab
.srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
3881 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
3882 htab
->tls_ldm_got
.offset
|= 1;
3885 /* Add the base of the GOT to the relocation value. */
3887 + htab
->etab
.sgot
->output_offset
3888 + htab
->etab
.sgot
->output_section
->vma
);
3893 case R_PARISC_TLS_LDO21L
:
3894 case R_PARISC_TLS_LDO14R
:
3895 relocation
-= dtpoff_base (info
);
3898 case R_PARISC_TLS_GD21L
:
3899 case R_PARISC_TLS_GD14R
:
3900 case R_PARISC_TLS_IE21L
:
3901 case R_PARISC_TLS_IE14R
:
3910 if (!htab
->etab
.dynamic_sections_created
3911 || hh
->eh
.dynindx
== -1
3912 || SYMBOL_REFERENCES_LOCAL (info
, &hh
->eh
)
3913 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, &hh
->eh
))
3914 /* This is actually a static link, or it is a
3915 -Bsymbolic link and the symbol is defined
3916 locally, or the symbol was forced to be local
3917 because of a version file. */
3920 indx
= hh
->eh
.dynindx
;
3921 off
= hh
->eh
.got
.offset
;
3922 tls_type
= hh
->tls_type
;
3926 off
= local_got_offsets
[r_symndx
];
3927 tls_type
= hppa_elf_local_got_tls_type (input_bfd
)[r_symndx
];
3930 if (tls_type
== GOT_UNKNOWN
)
3937 bfd_boolean need_relocs
= FALSE
;
3938 Elf_Internal_Rela outrel
;
3939 bfd_byte
*loc
= NULL
;
3942 /* The GOT entries have not been initialized yet. Do it
3943 now, and emit any relocations. If both an IE GOT and a
3944 GD GOT are necessary, we emit the GD first. */
3947 || (bfd_link_dll (info
)
3949 || !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, &hh
->eh
))))
3952 loc
= htab
->etab
.srelgot
->contents
;
3953 loc
+= (htab
->etab
.srelgot
->reloc_count
3954 * sizeof (Elf32_External_Rela
));
3957 if (tls_type
& GOT_TLS_GD
)
3963 + htab
->etab
.sgot
->output_section
->vma
3964 + htab
->etab
.sgot
->output_offset
);
3966 = ELF32_R_INFO (indx
, R_PARISC_TLS_DTPMOD32
);
3967 outrel
.r_addend
= 0;
3968 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
3969 htab
->etab
.srelgot
->reloc_count
++;
3970 loc
+= sizeof (Elf32_External_Rela
);
3971 bfd_put_32 (output_bfd
, 0,
3972 htab
->etab
.sgot
->contents
+ cur_off
);
3975 /* If we are not emitting relocations for a
3976 general dynamic reference, then we must be in a
3977 static link or an executable link with the
3978 symbol binding locally. Mark it as belonging
3979 to module 1, the executable. */
3980 bfd_put_32 (output_bfd
, 1,
3981 htab
->etab
.sgot
->contents
+ cur_off
);
3986 = ELF32_R_INFO (indx
, R_PARISC_TLS_DTPOFF32
);
3987 outrel
.r_offset
+= 4;
3988 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
3989 htab
->etab
.srelgot
->reloc_count
++;
3990 loc
+= sizeof (Elf32_External_Rela
);
3991 bfd_put_32 (output_bfd
, 0,
3992 htab
->etab
.sgot
->contents
+ cur_off
+ 4);
3995 bfd_put_32 (output_bfd
, relocation
- dtpoff_base (info
),
3996 htab
->etab
.sgot
->contents
+ cur_off
+ 4);
4000 if (tls_type
& GOT_TLS_IE
)
4003 && !(bfd_link_executable (info
)
4004 && SYMBOL_REFERENCES_LOCAL (info
, &hh
->eh
)))
4008 + htab
->etab
.sgot
->output_section
->vma
4009 + htab
->etab
.sgot
->output_offset
);
4010 outrel
.r_info
= ELF32_R_INFO (indx
,
4011 R_PARISC_TLS_TPREL32
);
4013 outrel
.r_addend
= relocation
- dtpoff_base (info
);
4015 outrel
.r_addend
= 0;
4016 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4017 htab
->etab
.srelgot
->reloc_count
++;
4018 loc
+= sizeof (Elf32_External_Rela
);
4021 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
4022 htab
->etab
.sgot
->contents
+ cur_off
);
4027 hh
->eh
.got
.offset
|= 1;
4029 local_got_offsets
[r_symndx
] |= 1;
4032 if ((tls_type
& GOT_NORMAL
) != 0
4033 && (tls_type
& (GOT_TLS_GD
| GOT_TLS_LDM
| GOT_TLS_IE
)) != 0)
4036 _bfd_error_handler (_("%s has both normal and TLS relocs"),
4040 Elf_Internal_Sym
*isym
4041 = bfd_sym_from_r_symndx (&htab
->sym_cache
,
4042 input_bfd
, r_symndx
);
4046 = bfd_elf_string_from_elf_section (input_bfd
,
4047 symtab_hdr
->sh_link
,
4049 if (sym_name
== NULL
)
4051 if (*sym_name
== '\0')
4052 sym_name
= bfd_section_name (sym_sec
);
4054 (_("%pB:%s has both normal and TLS relocs"),
4055 input_bfd
, sym_name
);
4057 bfd_set_error (bfd_error_bad_value
);
4061 if ((tls_type
& GOT_TLS_GD
)
4062 && r_type
!= R_PARISC_TLS_GD21L
4063 && r_type
!= R_PARISC_TLS_GD14R
)
4064 off
+= 2 * GOT_ENTRY_SIZE
;
4066 /* Add the base of the GOT to the relocation value. */
4068 + htab
->etab
.sgot
->output_offset
4069 + htab
->etab
.sgot
->output_section
->vma
);
4074 case R_PARISC_TLS_LE21L
:
4075 case R_PARISC_TLS_LE14R
:
4077 relocation
= tpoff (info
, relocation
);
4086 rstatus
= final_link_relocate (input_section
, contents
, rela
, relocation
,
4087 htab
, sym_sec
, hh
, info
);
4089 if (rstatus
== bfd_reloc_ok
)
4093 sym_name
= hh_name (hh
);
4096 sym_name
= bfd_elf_string_from_elf_section (input_bfd
,
4097 symtab_hdr
->sh_link
,
4099 if (sym_name
== NULL
)
4101 if (*sym_name
== '\0')
4102 sym_name
= bfd_section_name (sym_sec
);
4105 howto
= elf_hppa_howto_table
+ r_type
;
4107 if (rstatus
== bfd_reloc_undefined
|| rstatus
== bfd_reloc_notsupported
)
4109 if (rstatus
== bfd_reloc_notsupported
|| !warned_undef
)
4112 /* xgettext:c-format */
4113 (_("%pB(%pA+%#" PRIx64
"): cannot handle %s for %s"),
4116 (uint64_t) rela
->r_offset
,
4119 bfd_set_error (bfd_error_bad_value
);
4124 (*info
->callbacks
->reloc_overflow
)
4125 (info
, (hh
? &hh
->eh
.root
: NULL
), sym_name
, howto
->name
,
4126 (bfd_vma
) 0, input_bfd
, input_section
, rela
->r_offset
);
4132 /* Finish up dynamic symbol handling. We set the contents of various
4133 dynamic sections here. */
4136 elf32_hppa_finish_dynamic_symbol (bfd
*output_bfd
,
4137 struct bfd_link_info
*info
,
4138 struct elf_link_hash_entry
*eh
,
4139 Elf_Internal_Sym
*sym
)
4141 struct elf32_hppa_link_hash_table
*htab
;
4142 Elf_Internal_Rela rela
;
4145 htab
= hppa_link_hash_table (info
);
4149 if (eh
->plt
.offset
!= (bfd_vma
) -1)
4153 if (eh
->plt
.offset
& 1)
4156 /* This symbol has an entry in the procedure linkage table. Set
4159 The format of a plt entry is
4164 if (eh
->root
.type
== bfd_link_hash_defined
4165 || eh
->root
.type
== bfd_link_hash_defweak
)
4167 value
= eh
->root
.u
.def
.value
;
4168 if (eh
->root
.u
.def
.section
->output_section
!= NULL
)
4169 value
+= (eh
->root
.u
.def
.section
->output_offset
4170 + eh
->root
.u
.def
.section
->output_section
->vma
);
4173 /* Create a dynamic IPLT relocation for this entry. */
4174 rela
.r_offset
= (eh
->plt
.offset
4175 + htab
->etab
.splt
->output_offset
4176 + htab
->etab
.splt
->output_section
->vma
);
4177 if (eh
->dynindx
!= -1)
4179 rela
.r_info
= ELF32_R_INFO (eh
->dynindx
, R_PARISC_IPLT
);
4184 /* This symbol has been marked to become local, and is
4185 used by a plabel so must be kept in the .plt. */
4186 rela
.r_info
= ELF32_R_INFO (0, R_PARISC_IPLT
);
4187 rela
.r_addend
= value
;
4190 loc
= htab
->etab
.srelplt
->contents
;
4191 loc
+= htab
->etab
.srelplt
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4192 bfd_elf32_swap_reloca_out (htab
->etab
.splt
->output_section
->owner
, &rela
, loc
);
4194 if (!eh
->def_regular
)
4196 /* Mark the symbol as undefined, rather than as defined in
4197 the .plt section. Leave the value alone. */
4198 sym
->st_shndx
= SHN_UNDEF
;
4202 if (eh
->got
.offset
!= (bfd_vma
) -1
4203 && (hppa_elf_hash_entry (eh
)->tls_type
& GOT_NORMAL
) != 0
4204 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, eh
))
4206 bfd_boolean is_dyn
= (eh
->dynindx
!= -1
4207 && !SYMBOL_REFERENCES_LOCAL (info
, eh
));
4209 if (is_dyn
|| bfd_link_pic (info
))
4211 /* This symbol has an entry in the global offset table. Set
4214 rela
.r_offset
= ((eh
->got
.offset
&~ (bfd_vma
) 1)
4215 + htab
->etab
.sgot
->output_offset
4216 + htab
->etab
.sgot
->output_section
->vma
);
4218 /* If this is a -Bsymbolic link and the symbol is defined
4219 locally or was forced to be local because of a version
4220 file, we just want to emit a RELATIVE reloc. The entry
4221 in the global offset table will already have been
4222 initialized in the relocate_section function. */
4225 rela
.r_info
= ELF32_R_INFO (0, R_PARISC_DIR32
);
4226 rela
.r_addend
= (eh
->root
.u
.def
.value
4227 + eh
->root
.u
.def
.section
->output_offset
4228 + eh
->root
.u
.def
.section
->output_section
->vma
);
4232 if ((eh
->got
.offset
& 1) != 0)
4235 bfd_put_32 (output_bfd
, 0,
4236 htab
->etab
.sgot
->contents
+ (eh
->got
.offset
& ~1));
4237 rela
.r_info
= ELF32_R_INFO (eh
->dynindx
, R_PARISC_DIR32
);
4241 loc
= htab
->etab
.srelgot
->contents
;
4242 loc
+= (htab
->etab
.srelgot
->reloc_count
++
4243 * sizeof (Elf32_External_Rela
));
4244 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
4252 /* This symbol needs a copy reloc. Set it up. */
4254 if (! (eh
->dynindx
!= -1
4255 && (eh
->root
.type
== bfd_link_hash_defined
4256 || eh
->root
.type
== bfd_link_hash_defweak
)))
4259 rela
.r_offset
= (eh
->root
.u
.def
.value
4260 + eh
->root
.u
.def
.section
->output_offset
4261 + eh
->root
.u
.def
.section
->output_section
->vma
);
4263 rela
.r_info
= ELF32_R_INFO (eh
->dynindx
, R_PARISC_COPY
);
4264 if (eh
->root
.u
.def
.section
== htab
->etab
.sdynrelro
)
4265 sec
= htab
->etab
.sreldynrelro
;
4267 sec
= htab
->etab
.srelbss
;
4268 loc
= sec
->contents
+ sec
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4269 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
4272 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
4273 if (eh
== htab
->etab
.hdynamic
|| eh
== htab
->etab
.hgot
)
4275 sym
->st_shndx
= SHN_ABS
;
4281 /* Used to decide how to sort relocs in an optimal manner for the
4282 dynamic linker, before writing them out. */
4284 static enum elf_reloc_type_class
4285 elf32_hppa_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4286 const asection
*rel_sec ATTRIBUTE_UNUSED
,
4287 const Elf_Internal_Rela
*rela
)
4289 /* Handle TLS relocs first; we don't want them to be marked
4290 relative by the "if (ELF32_R_SYM (rela->r_info) == STN_UNDEF)"
4292 switch ((int) ELF32_R_TYPE (rela
->r_info
))
4294 case R_PARISC_TLS_DTPMOD32
:
4295 case R_PARISC_TLS_DTPOFF32
:
4296 case R_PARISC_TLS_TPREL32
:
4297 return reloc_class_normal
;
4300 if (ELF32_R_SYM (rela
->r_info
) == STN_UNDEF
)
4301 return reloc_class_relative
;
4303 switch ((int) ELF32_R_TYPE (rela
->r_info
))
4306 return reloc_class_plt
;
4308 return reloc_class_copy
;
4310 return reloc_class_normal
;
4314 /* Finish up the dynamic sections. */
4317 elf32_hppa_finish_dynamic_sections (bfd
*output_bfd
,
4318 struct bfd_link_info
*info
)
4321 struct elf32_hppa_link_hash_table
*htab
;
4325 htab
= hppa_link_hash_table (info
);
4329 dynobj
= htab
->etab
.dynobj
;
4331 sgot
= htab
->etab
.sgot
;
4332 /* A broken linker script might have discarded the dynamic sections.
4333 Catch this here so that we do not seg-fault later on. */
4334 if (sgot
!= NULL
&& bfd_is_abs_section (sgot
->output_section
))
4337 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
4339 if (htab
->etab
.dynamic_sections_created
)
4341 Elf32_External_Dyn
*dyncon
, *dynconend
;
4346 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
4347 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4348 for (; dyncon
< dynconend
; dyncon
++)
4350 Elf_Internal_Dyn dyn
;
4353 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4361 /* Use PLTGOT to set the GOT register. */
4362 dyn
.d_un
.d_ptr
= elf_gp (output_bfd
);
4366 s
= htab
->etab
.srelplt
;
4367 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
4371 s
= htab
->etab
.srelplt
;
4372 dyn
.d_un
.d_val
= s
->size
;
4376 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4380 if (sgot
!= NULL
&& sgot
->size
!= 0)
4382 /* Fill in the first entry in the global offset table.
4383 We use it to point to our dynamic section, if we have one. */
4384 bfd_put_32 (output_bfd
,
4385 sdyn
? sdyn
->output_section
->vma
+ sdyn
->output_offset
: 0,
4388 /* The second entry is reserved for use by the dynamic linker. */
4389 memset (sgot
->contents
+ GOT_ENTRY_SIZE
, 0, GOT_ENTRY_SIZE
);
4391 /* Set .got entry size. */
4392 elf_section_data (sgot
->output_section
)
4393 ->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
4396 if (htab
->etab
.splt
!= NULL
&& htab
->etab
.splt
->size
!= 0)
4398 /* Set plt entry size to 0 instead of PLT_ENTRY_SIZE, since we add the
4399 plt stubs and as such the section does not hold a table of fixed-size
4401 elf_section_data (htab
->etab
.splt
->output_section
)->this_hdr
.sh_entsize
= 0;
4403 if (htab
->need_plt_stub
)
4405 /* Set up the .plt stub. */
4406 memcpy (htab
->etab
.splt
->contents
4407 + htab
->etab
.splt
->size
- sizeof (plt_stub
),
4408 plt_stub
, sizeof (plt_stub
));
4410 if ((htab
->etab
.splt
->output_offset
4411 + htab
->etab
.splt
->output_section
->vma
4412 + htab
->etab
.splt
->size
)
4413 != (sgot
->output_offset
4414 + sgot
->output_section
->vma
))
4417 (_(".got section not immediately after .plt section"));
4426 /* Called when writing out an object file to decide the type of a
4429 elf32_hppa_elf_get_symbol_type (Elf_Internal_Sym
*elf_sym
, int type
)
4431 if (ELF_ST_TYPE (elf_sym
->st_info
) == STT_PARISC_MILLI
)
4432 return STT_PARISC_MILLI
;
4437 /* Misc BFD support code. */
4438 #define bfd_elf32_bfd_is_local_label_name elf_hppa_is_local_label_name
4439 #define bfd_elf32_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
4440 #define bfd_elf32_bfd_reloc_name_lookup elf_hppa_reloc_name_lookup
4441 #define elf_info_to_howto elf_hppa_info_to_howto
4442 #define elf_info_to_howto_rel elf_hppa_info_to_howto_rel
4444 /* Stuff for the BFD linker. */
4445 #define bfd_elf32_bfd_final_link elf32_hppa_final_link
4446 #define bfd_elf32_bfd_link_hash_table_create elf32_hppa_link_hash_table_create
4447 #define elf_backend_adjust_dynamic_symbol elf32_hppa_adjust_dynamic_symbol
4448 #define elf_backend_copy_indirect_symbol elf32_hppa_copy_indirect_symbol
4449 #define elf_backend_check_relocs elf32_hppa_check_relocs
4450 #define elf_backend_relocs_compatible _bfd_elf_relocs_compatible
4451 #define elf_backend_create_dynamic_sections elf32_hppa_create_dynamic_sections
4452 #define elf_backend_fake_sections elf_hppa_fake_sections
4453 #define elf_backend_relocate_section elf32_hppa_relocate_section
4454 #define elf_backend_hide_symbol elf32_hppa_hide_symbol
4455 #define elf_backend_finish_dynamic_symbol elf32_hppa_finish_dynamic_symbol
4456 #define elf_backend_finish_dynamic_sections elf32_hppa_finish_dynamic_sections
4457 #define elf_backend_size_dynamic_sections elf32_hppa_size_dynamic_sections
4458 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
4459 #define elf_backend_gc_mark_hook elf32_hppa_gc_mark_hook
4460 #define elf_backend_grok_prstatus elf32_hppa_grok_prstatus
4461 #define elf_backend_grok_psinfo elf32_hppa_grok_psinfo
4462 #define elf_backend_object_p elf32_hppa_object_p
4463 #define elf_backend_final_write_processing elf_hppa_final_write_processing
4464 #define elf_backend_get_symbol_type elf32_hppa_elf_get_symbol_type
4465 #define elf_backend_reloc_type_class elf32_hppa_reloc_type_class
4466 #define elf_backend_action_discarded elf_hppa_action_discarded
4468 #define elf_backend_can_gc_sections 1
4469 #define elf_backend_can_refcount 1
4470 #define elf_backend_plt_alignment 2
4471 #define elf_backend_want_got_plt 0
4472 #define elf_backend_plt_readonly 0
4473 #define elf_backend_want_plt_sym 0
4474 #define elf_backend_got_header_size 8
4475 #define elf_backend_want_dynrelro 1
4476 #define elf_backend_rela_normal 1
4477 #define elf_backend_dtrel_excludes_plt 1
4478 #define elf_backend_no_page_alias 1
4480 #define TARGET_BIG_SYM hppa_elf32_vec
4481 #define TARGET_BIG_NAME "elf32-hppa"
4482 #define ELF_ARCH bfd_arch_hppa
4483 #define ELF_TARGET_ID HPPA32_ELF_DATA
4484 #define ELF_MACHINE_CODE EM_PARISC
4485 #define ELF_MAXPAGESIZE 0x1000
4486 #define ELF_OSABI ELFOSABI_HPUX
4487 #define elf32_bed elf32_hppa_hpux_bed
4489 #include "elf32-target.h"
4491 #undef TARGET_BIG_SYM
4492 #define TARGET_BIG_SYM hppa_elf32_linux_vec
4493 #undef TARGET_BIG_NAME
4494 #define TARGET_BIG_NAME "elf32-hppa-linux"
4496 #define ELF_OSABI ELFOSABI_GNU
4498 #define elf32_bed elf32_hppa_linux_bed
4500 #include "elf32-target.h"
4502 #undef TARGET_BIG_SYM
4503 #define TARGET_BIG_SYM hppa_elf32_nbsd_vec
4504 #undef TARGET_BIG_NAME
4505 #define TARGET_BIG_NAME "elf32-hppa-netbsd"
4507 #define ELF_OSABI ELFOSABI_NETBSD
4509 #define elf32_bed elf32_hppa_netbsd_bed
4511 #include "elf32-target.h"