1 /* BFD back-end for HP PA-RISC ELF files.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000, 2001
3 Free Software Foundation, Inc.
6 Center for Software Science
7 Department of Computer Science
9 Largely rewritten by Alan Modra <alan@linuxcare.com.au>
11 This file is part of BFD, the Binary File Descriptor library.
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2 of the License, or
16 (at your option) any later version.
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
33 #include "elf32-hppa.h"
36 #include "elf32-hppa.h"
38 /* In order to gain some understanding of code in this file without
39 knowing all the intricate details of the linker, note the
42 Functions named elf32_hppa_* are called by external routines, other
43 functions are only called locally. elf32_hppa_* functions appear
44 in this file more or less in the order in which they are called
45 from external routines. eg. elf32_hppa_check_relocs is called
46 early in the link process, elf32_hppa_finish_dynamic_sections is
47 one of the last functions. */
49 /* We use two hash tables to hold information for linking PA ELF objects.
51 The first is the elf32_hppa_link_hash_table which is derived
52 from the standard ELF linker hash table. We use this as a place to
53 attach other hash tables and static information.
55 The second is the stub hash table which is derived from the
56 base BFD hash table. The stub hash table holds the information
57 necessary to build the linker stubs during a link.
59 There are a number of different stubs generated by the linker.
67 : addil LR'X - ($PIC_pcrel$0 - 4),%r1
68 : be,n RR'X - ($PIC_pcrel$0 - 8)(%sr4,%r1)
70 Import stub to call shared library routine from normal object file
71 (single sub-space version)
72 : addil LR'lt_ptr+ltoff,%dp ; get procedure entry point
73 : ldw RR'lt_ptr+ltoff(%r1),%r21
75 : ldw RR'lt_ptr+ltoff+4(%r1),%r19 ; get new dlt value.
77 Import stub to call shared library routine from shared library
78 (single sub-space version)
79 : addil LR'ltoff,%r19 ; get procedure entry point
80 : ldw RR'ltoff(%r1),%r21
82 : ldw RR'ltoff+4(%r1),%r19 ; get new dlt value.
84 Import stub to call shared library routine from normal object file
85 (multiple sub-space support)
86 : addil LR'lt_ptr+ltoff,%dp ; get procedure entry point
87 : ldw RR'lt_ptr+ltoff(%r1),%r21
88 : ldw RR'lt_ptr+ltoff+4(%r1),%r19 ; get new dlt value.
91 : be 0(%sr0,%r21) ; branch to target
92 : stw %rp,-24(%sp) ; save rp
94 Import stub to call shared library routine from shared library
95 (multiple sub-space support)
96 : addil LR'ltoff,%r19 ; get procedure entry point
97 : ldw RR'ltoff(%r1),%r21
98 : ldw RR'ltoff+4(%r1),%r19 ; get new dlt value.
101 : be 0(%sr0,%r21) ; branch to target
102 : stw %rp,-24(%sp) ; save rp
104 Export stub to return from shared lib routine (multiple sub-space support)
105 One of these is created for each exported procedure in a shared
106 library (and stored in the shared lib). Shared lib routines are
107 called via the first instruction in the export stub so that we can
108 do an inter-space return. Not required for single sub-space.
109 : bl,n X,%rp ; trap the return
111 : ldw -24(%sp),%rp ; restore the original rp
114 : be,n 0(%sr0,%rp) ; inter-space return */
116 #define PLT_ENTRY_SIZE 8
117 #define GOT_ENTRY_SIZE 4
118 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
120 static const bfd_byte plt_stub
[] =
122 0x0e, 0x80, 0x10, 0x96, /* 1: ldw 0(%r20),%r22 */
123 0xea, 0xc0, 0xc0, 0x00, /* bv %r0(%r22) */
124 0x0e, 0x88, 0x10, 0x95, /* ldw 4(%r20),%r21 */
125 #define PLT_STUB_ENTRY (3*4)
126 0xea, 0x9f, 0x1f, 0xdd, /* b,l 1b,%r20 */
127 0xd6, 0x80, 0x1c, 0x1e, /* depi 0,31,2,%r20 */
128 0x00, 0xc0, 0xff, 0xee, /* 9: .word fixup_func */
129 0xde, 0xad, 0xbe, 0xef /* .word fixup_ltp */
132 /* Section name for stubs is the associated section name plus this
134 #define STUB_SUFFIX ".stub"
136 /* We don't need to copy certain PC- or GP-relative dynamic relocs
137 into a shared object's dynamic section. All the relocs of the
138 limited class we are interested in, are absolute. */
139 #ifndef RELATIVE_DYNRELOCS
140 #define RELATIVE_DYNRELOCS 0
141 #define IS_ABSOLUTE_RELOC(r_type) 1
144 enum elf32_hppa_stub_type
{
145 hppa_stub_long_branch
,
146 hppa_stub_long_branch_shared
,
148 hppa_stub_import_shared
,
153 struct elf32_hppa_stub_hash_entry
{
155 /* Base hash table entry structure. */
156 struct bfd_hash_entry root
;
158 /* The stub section. */
161 /* Offset within stub_sec of the beginning of this stub. */
164 /* Given the symbol's value and its section we can determine its final
165 value when building the stubs (so the stub knows where to jump. */
166 bfd_vma target_value
;
167 asection
*target_section
;
169 enum elf32_hppa_stub_type stub_type
;
171 /* The symbol table entry, if any, that this was derived from. */
172 struct elf32_hppa_link_hash_entry
*h
;
174 /* Where this stub is being called from, or, in the case of combined
175 stub sections, the first input section in the group. */
179 struct elf32_hppa_link_hash_entry
{
181 struct elf_link_hash_entry elf
;
183 /* A pointer to the most recently used stub hash entry against this
185 struct elf32_hppa_stub_hash_entry
*stub_cache
;
187 /* Used to count relocations for delayed sizing of relocation
189 struct elf32_hppa_dyn_reloc_entry
{
191 /* Next relocation in the chain. */
192 struct elf32_hppa_dyn_reloc_entry
*next
;
194 /* The input section of the reloc. */
197 /* Number of relocs copied in this section. */
200 #if RELATIVE_DYNRELOCS
201 /* Number of relative relocs copied for the input section. */
202 bfd_size_type relative_count
;
206 /* Set during a static link if we detect a function is PIC. */
207 unsigned int maybe_pic_call
:1;
209 /* Set if the only reason we need a .plt entry is for a non-PIC to
210 PIC function call. */
211 unsigned int pic_call
:1;
213 /* Set if this symbol is used by a plabel reloc. */
214 unsigned int plabel
:1;
217 struct elf32_hppa_link_hash_table
{
219 /* The main hash table. */
220 struct elf_link_hash_table elf
;
222 /* The stub hash table. */
223 struct bfd_hash_table stub_hash_table
;
225 /* Linker stub bfd. */
228 /* Linker call-backs. */
229 asection
* (*add_stub_section
) PARAMS ((const char *, asection
*));
230 void (*layout_sections_again
) PARAMS ((void));
232 /* Array to keep track of which stub sections have been created, and
233 information on stub grouping. */
235 /* This is the section to which stubs in the group will be
238 /* The stub section. */
242 /* Short-cuts to get to dynamic linker sections. */
250 /* Used during a final link to store the base of the text and data
251 segments so that we can perform SEGREL relocations. */
252 bfd_vma text_segment_base
;
253 bfd_vma data_segment_base
;
255 /* Whether we support multiple sub-spaces for shared libs. */
256 unsigned int multi_subspace
:1;
258 /* Flags set when PCREL12F and PCREL17F branches detected. Used to
259 select suitable defaults for the stub group size. */
260 unsigned int has_12bit_branch
:1;
261 unsigned int has_17bit_branch
:1;
263 /* Set if we need a .plt stub to support lazy dynamic linking. */
264 unsigned int need_plt_stub
:1;
266 /* Small local sym to section mapping cache. */
267 struct sym_sec_cache sym_sec
;
270 /* Various hash macros and functions. */
271 #define hppa_link_hash_table(p) \
272 ((struct elf32_hppa_link_hash_table *) ((p)->hash))
274 #define hppa_stub_hash_lookup(table, string, create, copy) \
275 ((struct elf32_hppa_stub_hash_entry *) \
276 bfd_hash_lookup ((table), (string), (create), (copy)))
278 static struct bfd_hash_entry
*stub_hash_newfunc
279 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
281 static struct bfd_hash_entry
*hppa_link_hash_newfunc
282 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
284 static struct bfd_link_hash_table
*elf32_hppa_link_hash_table_create
287 /* Stub handling functions. */
288 static char *hppa_stub_name
289 PARAMS ((const asection
*, const asection
*,
290 const struct elf32_hppa_link_hash_entry
*,
291 const Elf_Internal_Rela
*));
293 static struct elf32_hppa_stub_hash_entry
*hppa_get_stub_entry
294 PARAMS ((const asection
*, const asection
*,
295 struct elf32_hppa_link_hash_entry
*,
296 const Elf_Internal_Rela
*,
297 struct elf32_hppa_link_hash_table
*));
299 static struct elf32_hppa_stub_hash_entry
*hppa_add_stub
300 PARAMS ((const char *, asection
*, struct elf32_hppa_link_hash_table
*));
302 static enum elf32_hppa_stub_type hppa_type_of_stub
303 PARAMS ((asection
*, const Elf_Internal_Rela
*,
304 struct elf32_hppa_link_hash_entry
*, bfd_vma
));
306 static boolean hppa_build_one_stub
307 PARAMS ((struct bfd_hash_entry
*, PTR
));
309 static boolean hppa_size_one_stub
310 PARAMS ((struct bfd_hash_entry
*, PTR
));
312 /* BFD and elf backend functions. */
313 static boolean elf32_hppa_object_p
PARAMS ((bfd
*));
315 static boolean elf32_hppa_add_symbol_hook
316 PARAMS ((bfd
*, struct bfd_link_info
*, const Elf_Internal_Sym
*,
317 const char **, flagword
*, asection
**, bfd_vma
*));
319 static boolean elf32_hppa_create_dynamic_sections
320 PARAMS ((bfd
*, struct bfd_link_info
*));
322 static void elf32_hppa_copy_indirect_symbol
323 PARAMS ((struct elf_link_hash_entry
*, struct elf_link_hash_entry
*));
325 static boolean elf32_hppa_check_relocs
326 PARAMS ((bfd
*, struct bfd_link_info
*,
327 asection
*, const Elf_Internal_Rela
*));
329 static asection
*elf32_hppa_gc_mark_hook
330 PARAMS ((bfd
*, struct bfd_link_info
*, Elf_Internal_Rela
*,
331 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
333 static boolean elf32_hppa_gc_sweep_hook
334 PARAMS ((bfd
*, struct bfd_link_info
*,
335 asection
*, const Elf_Internal_Rela
*));
337 static void elf32_hppa_hide_symbol
338 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
340 static boolean elf32_hppa_adjust_dynamic_symbol
341 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*));
343 static boolean mark_PIC_calls
344 PARAMS ((struct elf_link_hash_entry
*, PTR
));
346 static boolean allocate_plt_static
347 PARAMS ((struct elf_link_hash_entry
*, PTR
));
349 static boolean allocate_dynrelocs
350 PARAMS ((struct elf_link_hash_entry
*, PTR
));
352 static boolean readonly_dynrelocs
353 PARAMS ((struct elf_link_hash_entry
*, PTR
));
355 static boolean clobber_millicode_symbols
356 PARAMS ((struct elf_link_hash_entry
*, struct bfd_link_info
*));
358 static boolean elf32_hppa_size_dynamic_sections
359 PARAMS ((bfd
*, struct bfd_link_info
*));
361 static boolean elf32_hppa_final_link
362 PARAMS ((bfd
*, struct bfd_link_info
*));
364 static void hppa_record_segment_addr
365 PARAMS ((bfd
*, asection
*, PTR
));
367 static bfd_reloc_status_type final_link_relocate
368 PARAMS ((asection
*, bfd_byte
*, const Elf_Internal_Rela
*,
369 bfd_vma
, struct elf32_hppa_link_hash_table
*, asection
*,
370 struct elf32_hppa_link_hash_entry
*));
372 static boolean elf32_hppa_relocate_section
373 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*,
374 bfd_byte
*, Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
376 static int hppa_unwind_entry_compare
377 PARAMS ((const PTR
, const PTR
));
379 static boolean elf32_hppa_finish_dynamic_symbol
380 PARAMS ((bfd
*, struct bfd_link_info
*,
381 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
383 static enum elf_reloc_type_class elf32_hppa_reloc_type_class
384 PARAMS ((const Elf_Internal_Rela
*));
386 static boolean elf32_hppa_finish_dynamic_sections
387 PARAMS ((bfd
*, struct bfd_link_info
*));
389 static void elf32_hppa_post_process_headers
390 PARAMS ((bfd
*, struct bfd_link_info
*));
392 static int elf32_hppa_elf_get_symbol_type
393 PARAMS ((Elf_Internal_Sym
*, int));
395 /* Assorted hash table functions. */
397 /* Initialize an entry in the stub hash table. */
399 static struct bfd_hash_entry
*
400 stub_hash_newfunc (entry
, table
, string
)
401 struct bfd_hash_entry
*entry
;
402 struct bfd_hash_table
*table
;
405 /* Allocate the structure if it has not already been allocated by a
409 entry
= bfd_hash_allocate (table
,
410 sizeof (struct elf32_hppa_stub_hash_entry
));
415 /* Call the allocation method of the superclass. */
416 entry
= bfd_hash_newfunc (entry
, table
, string
);
419 struct elf32_hppa_stub_hash_entry
*eh
;
421 /* Initialize the local fields. */
422 eh
= (struct elf32_hppa_stub_hash_entry
*) entry
;
425 eh
->target_value
= 0;
426 eh
->target_section
= NULL
;
427 eh
->stub_type
= hppa_stub_long_branch
;
435 /* Initialize an entry in the link hash table. */
437 static struct bfd_hash_entry
*
438 hppa_link_hash_newfunc (entry
, table
, string
)
439 struct bfd_hash_entry
*entry
;
440 struct bfd_hash_table
*table
;
443 /* Allocate the structure if it has not already been allocated by a
447 entry
= bfd_hash_allocate (table
,
448 sizeof (struct elf32_hppa_link_hash_entry
));
453 /* Call the allocation method of the superclass. */
454 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
457 struct elf32_hppa_link_hash_entry
*eh
;
459 /* Initialize the local fields. */
460 eh
= (struct elf32_hppa_link_hash_entry
*) entry
;
461 eh
->stub_cache
= NULL
;
462 eh
->dyn_relocs
= NULL
;
463 eh
->maybe_pic_call
= 0;
471 /* Create the derived linker hash table. The PA ELF port uses the derived
472 hash table to keep information specific to the PA ELF linker (without
473 using static variables). */
475 static struct bfd_link_hash_table
*
476 elf32_hppa_link_hash_table_create (abfd
)
479 struct elf32_hppa_link_hash_table
*ret
;
480 bfd_size_type amt
= sizeof (*ret
);
482 ret
= (struct elf32_hppa_link_hash_table
*) bfd_alloc (abfd
, amt
);
486 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, hppa_link_hash_newfunc
))
488 bfd_release (abfd
, ret
);
492 /* Init the stub hash table too. */
493 if (!bfd_hash_table_init (&ret
->stub_hash_table
, stub_hash_newfunc
))
496 ret
->stub_bfd
= NULL
;
497 ret
->add_stub_section
= NULL
;
498 ret
->layout_sections_again
= NULL
;
499 ret
->stub_group
= NULL
;
506 ret
->text_segment_base
= (bfd_vma
) -1;
507 ret
->data_segment_base
= (bfd_vma
) -1;
508 ret
->multi_subspace
= 0;
509 ret
->has_12bit_branch
= 0;
510 ret
->has_17bit_branch
= 0;
511 ret
->need_plt_stub
= 0;
512 ret
->sym_sec
.abfd
= NULL
;
514 return &ret
->elf
.root
;
517 /* Build a name for an entry in the stub hash table. */
520 hppa_stub_name (input_section
, sym_sec
, hash
, rel
)
521 const asection
*input_section
;
522 const asection
*sym_sec
;
523 const struct elf32_hppa_link_hash_entry
*hash
;
524 const Elf_Internal_Rela
*rel
;
531 len
= 8 + 1 + strlen (hash
->elf
.root
.root
.string
) + 1 + 8 + 1;
532 stub_name
= bfd_malloc (len
);
533 if (stub_name
!= NULL
)
535 sprintf (stub_name
, "%08x_%s+%x",
536 input_section
->id
& 0xffffffff,
537 hash
->elf
.root
.root
.string
,
538 (int) rel
->r_addend
& 0xffffffff);
543 len
= 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
544 stub_name
= bfd_malloc (len
);
545 if (stub_name
!= NULL
)
547 sprintf (stub_name
, "%08x_%x:%x+%x",
548 input_section
->id
& 0xffffffff,
549 sym_sec
->id
& 0xffffffff,
550 (int) ELF32_R_SYM (rel
->r_info
) & 0xffffffff,
551 (int) rel
->r_addend
& 0xffffffff);
557 /* Look up an entry in the stub hash. Stub entries are cached because
558 creating the stub name takes a bit of time. */
560 static struct elf32_hppa_stub_hash_entry
*
561 hppa_get_stub_entry (input_section
, sym_sec
, hash
, rel
, htab
)
562 const asection
*input_section
;
563 const asection
*sym_sec
;
564 struct elf32_hppa_link_hash_entry
*hash
;
565 const Elf_Internal_Rela
*rel
;
566 struct elf32_hppa_link_hash_table
*htab
;
568 struct elf32_hppa_stub_hash_entry
*stub_entry
;
569 const asection
*id_sec
;
571 /* If this input section is part of a group of sections sharing one
572 stub section, then use the id of the first section in the group.
573 Stub names need to include a section id, as there may well be
574 more than one stub used to reach say, printf, and we need to
575 distinguish between them. */
576 id_sec
= htab
->stub_group
[input_section
->id
].link_sec
;
578 if (hash
!= NULL
&& hash
->stub_cache
!= NULL
579 && hash
->stub_cache
->h
== hash
580 && hash
->stub_cache
->id_sec
== id_sec
)
582 stub_entry
= hash
->stub_cache
;
588 stub_name
= hppa_stub_name (id_sec
, sym_sec
, hash
, rel
);
589 if (stub_name
== NULL
)
592 stub_entry
= hppa_stub_hash_lookup (&htab
->stub_hash_table
,
593 stub_name
, false, false);
594 if (stub_entry
== NULL
)
596 if (hash
== NULL
|| hash
->elf
.root
.type
!= bfd_link_hash_undefweak
)
597 (*_bfd_error_handler
) (_("%s(%s+0x%lx): cannot find stub entry %s"),
598 bfd_archive_filename (input_section
->owner
),
600 (long) rel
->r_offset
,
606 hash
->stub_cache
= stub_entry
;
615 /* Add a new stub entry to the stub hash. Not all fields of the new
616 stub entry are initialised. */
618 static struct elf32_hppa_stub_hash_entry
*
619 hppa_add_stub (stub_name
, section
, htab
)
620 const char *stub_name
;
622 struct elf32_hppa_link_hash_table
*htab
;
626 struct elf32_hppa_stub_hash_entry
*stub_entry
;
628 link_sec
= htab
->stub_group
[section
->id
].link_sec
;
629 stub_sec
= htab
->stub_group
[section
->id
].stub_sec
;
630 if (stub_sec
== NULL
)
632 stub_sec
= htab
->stub_group
[link_sec
->id
].stub_sec
;
633 if (stub_sec
== NULL
)
638 len
= strlen (link_sec
->name
) + sizeof (STUB_SUFFIX
);
639 s_name
= bfd_alloc (htab
->stub_bfd
, len
);
643 strcpy (s_name
, link_sec
->name
);
644 strcpy (s_name
+ len
- sizeof (STUB_SUFFIX
), STUB_SUFFIX
);
645 stub_sec
= (*htab
->add_stub_section
) (s_name
, link_sec
);
646 if (stub_sec
== NULL
)
648 htab
->stub_group
[link_sec
->id
].stub_sec
= stub_sec
;
650 htab
->stub_group
[section
->id
].stub_sec
= stub_sec
;
653 /* Enter this entry into the linker stub hash table. */
654 stub_entry
= hppa_stub_hash_lookup (&htab
->stub_hash_table
, stub_name
,
656 if (stub_entry
== NULL
)
658 (*_bfd_error_handler
) (_("%s: cannot create stub entry %s"),
659 bfd_archive_filename (section
->owner
),
664 stub_entry
->stub_sec
= stub_sec
;
665 stub_entry
->stub_offset
= 0;
666 stub_entry
->id_sec
= link_sec
;
670 /* Determine the type of stub needed, if any, for a call. */
672 static enum elf32_hppa_stub_type
673 hppa_type_of_stub (input_sec
, rel
, hash
, destination
)
675 const Elf_Internal_Rela
*rel
;
676 struct elf32_hppa_link_hash_entry
*hash
;
680 bfd_vma branch_offset
;
681 bfd_vma max_branch_offset
;
685 && (((hash
->elf
.root
.type
== bfd_link_hash_defined
686 || hash
->elf
.root
.type
== bfd_link_hash_defweak
)
687 && hash
->elf
.root
.u
.def
.section
->output_section
== NULL
)
688 || (hash
->elf
.root
.type
== bfd_link_hash_defweak
689 && hash
->elf
.dynindx
!= -1
690 && hash
->elf
.plt
.offset
!= (bfd_vma
) -1)
691 || hash
->elf
.root
.type
== bfd_link_hash_undefweak
692 || hash
->elf
.root
.type
== bfd_link_hash_undefined
693 || (hash
->maybe_pic_call
&& !(input_sec
->flags
& SEC_HAS_GOT_REF
))))
695 /* If output_section is NULL, then it's a symbol defined in a
696 shared library. We will need an import stub. Decide between
697 hppa_stub_import and hppa_stub_import_shared later. For
698 shared links we need stubs for undefined or weak syms too;
699 They will presumably be resolved by the dynamic linker. */
700 return hppa_stub_import
;
703 /* Determine where the call point is. */
704 location
= (input_sec
->output_offset
705 + input_sec
->output_section
->vma
708 branch_offset
= destination
- location
- 8;
709 r_type
= ELF32_R_TYPE (rel
->r_info
);
711 /* Determine if a long branch stub is needed. parisc branch offsets
712 are relative to the second instruction past the branch, ie. +8
713 bytes on from the branch instruction location. The offset is
714 signed and counts in units of 4 bytes. */
715 if (r_type
== (unsigned int) R_PARISC_PCREL17F
)
717 max_branch_offset
= (1 << (17-1)) << 2;
719 else if (r_type
== (unsigned int) R_PARISC_PCREL12F
)
721 max_branch_offset
= (1 << (12-1)) << 2;
723 else /* R_PARISC_PCREL22F. */
725 max_branch_offset
= (1 << (22-1)) << 2;
728 if (branch_offset
+ max_branch_offset
>= 2*max_branch_offset
)
729 return hppa_stub_long_branch
;
731 return hppa_stub_none
;
734 /* Build one linker stub as defined by the stub hash table entry GEN_ENTRY.
735 IN_ARG contains the link info pointer. */
737 #define LDIL_R1 0x20200000 /* ldil LR'XXX,%r1 */
738 #define BE_SR4_R1 0xe0202002 /* be,n RR'XXX(%sr4,%r1) */
740 #define BL_R1 0xe8200000 /* b,l .+8,%r1 */
741 #define ADDIL_R1 0x28200000 /* addil LR'XXX,%r1,%r1 */
742 #define DEPI_R1 0xd4201c1e /* depi 0,31,2,%r1 */
744 #define ADDIL_DP 0x2b600000 /* addil LR'XXX,%dp,%r1 */
745 #define LDW_R1_R21 0x48350000 /* ldw RR'XXX(%sr0,%r1),%r21 */
746 #define BV_R0_R21 0xeaa0c000 /* bv %r0(%r21) */
747 #define LDW_R1_R19 0x48330000 /* ldw RR'XXX(%sr0,%r1),%r19 */
749 #define ADDIL_R19 0x2a600000 /* addil LR'XXX,%r19,%r1 */
750 #define LDW_R1_DP 0x483b0000 /* ldw RR'XXX(%sr0,%r1),%dp */
752 #define LDSID_R21_R1 0x02a010a1 /* ldsid (%sr0,%r21),%r1 */
753 #define MTSP_R1 0x00011820 /* mtsp %r1,%sr0 */
754 #define BE_SR0_R21 0xe2a00000 /* be 0(%sr0,%r21) */
755 #define STW_RP 0x6bc23fd1 /* stw %rp,-24(%sr0,%sp) */
757 #define BL_RP 0xe8400002 /* b,l,n XXX,%rp */
758 #define NOP 0x08000240 /* nop */
759 #define LDW_RP 0x4bc23fd1 /* ldw -24(%sr0,%sp),%rp */
760 #define LDSID_RP_R1 0x004010a1 /* ldsid (%sr0,%rp),%r1 */
761 #define BE_SR0_RP 0xe0400002 /* be,n 0(%sr0,%rp) */
768 #define LDW_R1_DLT LDW_R1_R19
770 #define LDW_R1_DLT LDW_R1_DP
774 hppa_build_one_stub (gen_entry
, in_arg
)
775 struct bfd_hash_entry
*gen_entry
;
778 struct elf32_hppa_stub_hash_entry
*stub_entry
;
779 struct bfd_link_info
*info
;
780 struct elf32_hppa_link_hash_table
*htab
;
790 /* Massage our args to the form they really have. */
791 stub_entry
= (struct elf32_hppa_stub_hash_entry
*) gen_entry
;
792 info
= (struct bfd_link_info
*) in_arg
;
794 htab
= hppa_link_hash_table (info
);
795 stub_sec
= stub_entry
->stub_sec
;
797 /* Make a note of the offset within the stubs for this entry. */
798 stub_entry
->stub_offset
= stub_sec
->_raw_size
;
799 loc
= stub_sec
->contents
+ stub_entry
->stub_offset
;
801 stub_bfd
= stub_sec
->owner
;
803 switch (stub_entry
->stub_type
)
805 case hppa_stub_long_branch
:
806 /* Create the long branch. A long branch is formed with "ldil"
807 loading the upper bits of the target address into a register,
808 then branching with "be" which adds in the lower bits.
809 The "be" has its delay slot nullified. */
810 sym_value
= (stub_entry
->target_value
811 + stub_entry
->target_section
->output_offset
812 + stub_entry
->target_section
->output_section
->vma
);
814 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) 0, e_lrsel
);
815 insn
= hppa_rebuild_insn ((int) LDIL_R1
, val
, 21);
816 bfd_put_32 (stub_bfd
, insn
, loc
);
818 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) 0, e_rrsel
) >> 2;
819 insn
= hppa_rebuild_insn ((int) BE_SR4_R1
, val
, 17);
820 bfd_put_32 (stub_bfd
, insn
, loc
+ 4);
825 case hppa_stub_long_branch_shared
:
826 /* Branches are relative. This is where we are going to. */
827 sym_value
= (stub_entry
->target_value
828 + stub_entry
->target_section
->output_offset
829 + stub_entry
->target_section
->output_section
->vma
);
831 /* And this is where we are coming from, more or less. */
832 sym_value
-= (stub_entry
->stub_offset
833 + stub_sec
->output_offset
834 + stub_sec
->output_section
->vma
);
836 bfd_put_32 (stub_bfd
, (bfd_vma
) BL_R1
, loc
);
837 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) -8, e_lrsel
);
838 insn
= hppa_rebuild_insn ((int) ADDIL_R1
, val
, 21);
839 bfd_put_32 (stub_bfd
, insn
, loc
+ 4);
841 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) -8, e_rrsel
) >> 2;
842 insn
= hppa_rebuild_insn ((int) BE_SR4_R1
, val
, 17);
843 bfd_put_32 (stub_bfd
, insn
, loc
+ 8);
847 case hppa_stub_import
:
848 case hppa_stub_import_shared
:
849 off
= stub_entry
->h
->elf
.plt
.offset
;
850 if (off
>= (bfd_vma
) -2)
853 off
&= ~ (bfd_vma
) 1;
855 + htab
->splt
->output_offset
856 + htab
->splt
->output_section
->vma
857 - elf_gp (htab
->splt
->output_section
->owner
));
861 if (stub_entry
->stub_type
== hppa_stub_import_shared
)
864 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) 0, e_lrsel
),
865 insn
= hppa_rebuild_insn ((int) insn
, val
, 21);
866 bfd_put_32 (stub_bfd
, insn
, loc
);
868 /* It is critical to use lrsel/rrsel here because we are using
869 two different offsets (+0 and +4) from sym_value. If we use
870 lsel/rsel then with unfortunate sym_values we will round
871 sym_value+4 up to the next 2k block leading to a mis-match
872 between the lsel and rsel value. */
873 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) 0, e_rrsel
);
874 insn
= hppa_rebuild_insn ((int) LDW_R1_R21
, val
, 14);
875 bfd_put_32 (stub_bfd
, insn
, loc
+ 4);
877 if (htab
->multi_subspace
)
879 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) 4, e_rrsel
);
880 insn
= hppa_rebuild_insn ((int) LDW_R1_DLT
, val
, 14);
881 bfd_put_32 (stub_bfd
, insn
, loc
+ 8);
883 bfd_put_32 (stub_bfd
, (bfd_vma
) LDSID_R21_R1
, loc
+ 12);
884 bfd_put_32 (stub_bfd
, (bfd_vma
) MTSP_R1
, loc
+ 16);
885 bfd_put_32 (stub_bfd
, (bfd_vma
) BE_SR0_R21
, loc
+ 20);
886 bfd_put_32 (stub_bfd
, (bfd_vma
) STW_RP
, loc
+ 24);
892 bfd_put_32 (stub_bfd
, (bfd_vma
) BV_R0_R21
, loc
+ 8);
893 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) 4, e_rrsel
);
894 insn
= hppa_rebuild_insn ((int) LDW_R1_DLT
, val
, 14);
895 bfd_put_32 (stub_bfd
, insn
, loc
+ 12);
901 && stub_entry
->h
!= NULL
902 && stub_entry
->h
->pic_call
)
904 /* Build the .plt entry needed to call a PIC function from
905 statically linked code. We don't need any relocs. */
907 struct elf32_hppa_link_hash_entry
*eh
;
910 dynobj
= htab
->elf
.dynobj
;
911 eh
= (struct elf32_hppa_link_hash_entry
*) stub_entry
->h
;
913 if (eh
->elf
.root
.type
!= bfd_link_hash_defined
914 && eh
->elf
.root
.type
!= bfd_link_hash_defweak
)
917 value
= (eh
->elf
.root
.u
.def
.value
918 + eh
->elf
.root
.u
.def
.section
->output_offset
919 + eh
->elf
.root
.u
.def
.section
->output_section
->vma
);
921 /* Fill in the entry in the procedure linkage table.
923 The format of a plt entry is
927 bfd_put_32 (htab
->splt
->owner
, value
,
928 htab
->splt
->contents
+ off
);
929 value
= elf_gp (htab
->splt
->output_section
->owner
);
930 bfd_put_32 (htab
->splt
->owner
, value
,
931 htab
->splt
->contents
+ off
+ 4);
935 case hppa_stub_export
:
936 /* Branches are relative. This is where we are going to. */
937 sym_value
= (stub_entry
->target_value
938 + stub_entry
->target_section
->output_offset
939 + stub_entry
->target_section
->output_section
->vma
);
941 /* And this is where we are coming from. */
942 sym_value
-= (stub_entry
->stub_offset
943 + stub_sec
->output_offset
944 + stub_sec
->output_section
->vma
);
946 if (sym_value
- 8 + 0x40000 >= 0x80000)
948 (*_bfd_error_handler
)
949 (_("%s(%s+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
950 bfd_archive_filename (stub_entry
->target_section
->owner
),
952 (long) stub_entry
->stub_offset
,
953 stub_entry
->root
.string
);
954 bfd_set_error (bfd_error_bad_value
);
958 val
= hppa_field_adjust (sym_value
, (bfd_signed_vma
) -8, e_fsel
) >> 2;
959 insn
= hppa_rebuild_insn ((int) BL_RP
, val
, 17);
960 bfd_put_32 (stub_bfd
, insn
, loc
);
962 bfd_put_32 (stub_bfd
, (bfd_vma
) NOP
, loc
+ 4);
963 bfd_put_32 (stub_bfd
, (bfd_vma
) LDW_RP
, loc
+ 8);
964 bfd_put_32 (stub_bfd
, (bfd_vma
) LDSID_RP_R1
, loc
+ 12);
965 bfd_put_32 (stub_bfd
, (bfd_vma
) MTSP_R1
, loc
+ 16);
966 bfd_put_32 (stub_bfd
, (bfd_vma
) BE_SR0_RP
, loc
+ 20);
968 /* Point the function symbol at the stub. */
969 stub_entry
->h
->elf
.root
.u
.def
.section
= stub_sec
;
970 stub_entry
->h
->elf
.root
.u
.def
.value
= stub_sec
->_raw_size
;
980 stub_sec
->_raw_size
+= size
;
1006 /* As above, but don't actually build the stub. Just bump offset so
1007 we know stub section sizes. */
1010 hppa_size_one_stub (gen_entry
, in_arg
)
1011 struct bfd_hash_entry
*gen_entry
;
1014 struct elf32_hppa_stub_hash_entry
*stub_entry
;
1015 struct elf32_hppa_link_hash_table
*htab
;
1018 /* Massage our args to the form they really have. */
1019 stub_entry
= (struct elf32_hppa_stub_hash_entry
*) gen_entry
;
1020 htab
= (struct elf32_hppa_link_hash_table
*) in_arg
;
1022 if (stub_entry
->stub_type
== hppa_stub_long_branch
)
1024 else if (stub_entry
->stub_type
== hppa_stub_long_branch_shared
)
1026 else if (stub_entry
->stub_type
== hppa_stub_export
)
1028 else /* hppa_stub_import or hppa_stub_import_shared. */
1030 if (htab
->multi_subspace
)
1036 stub_entry
->stub_sec
->_raw_size
+= size
;
1040 /* Return nonzero if ABFD represents an HPPA ELF32 file.
1041 Additionally we set the default architecture and machine. */
1044 elf32_hppa_object_p (abfd
)
1047 Elf_Internal_Ehdr
* i_ehdrp
;
1050 i_ehdrp
= elf_elfheader (abfd
);
1051 if (strcmp (bfd_get_target (abfd
), "elf32-hppa-linux") == 0)
1053 if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_LINUX
)
1058 if (i_ehdrp
->e_ident
[EI_OSABI
] != ELFOSABI_HPUX
)
1062 flags
= i_ehdrp
->e_flags
;
1063 switch (flags
& (EF_PARISC_ARCH
| EF_PARISC_WIDE
))
1065 case EFA_PARISC_1_0
:
1066 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 10);
1067 case EFA_PARISC_1_1
:
1068 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 11);
1069 case EFA_PARISC_2_0
:
1070 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 20);
1071 case EFA_PARISC_2_0
| EF_PARISC_WIDE
:
1072 return bfd_default_set_arch_mach (abfd
, bfd_arch_hppa
, 25);
1077 /* Undo the generic ELF code's subtraction of section->vma from the
1078 value of each external symbol. */
1081 elf32_hppa_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
1082 bfd
*abfd ATTRIBUTE_UNUSED
;
1083 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1084 const Elf_Internal_Sym
*sym ATTRIBUTE_UNUSED
;
1085 const char **namep ATTRIBUTE_UNUSED
;
1086 flagword
*flagsp ATTRIBUTE_UNUSED
;
1090 *valp
+= (*secp
)->vma
;
1094 /* Create the .plt and .got sections, and set up our hash table
1095 short-cuts to various dynamic sections. */
1098 elf32_hppa_create_dynamic_sections (abfd
, info
)
1100 struct bfd_link_info
*info
;
1102 struct elf32_hppa_link_hash_table
*htab
;
1104 /* Don't try to create the .plt and .got twice. */
1105 htab
= hppa_link_hash_table (info
);
1106 if (htab
->splt
!= NULL
)
1109 /* Call the generic code to do most of the work. */
1110 if (! _bfd_elf_create_dynamic_sections (abfd
, info
))
1113 htab
->splt
= bfd_get_section_by_name (abfd
, ".plt");
1114 htab
->srelplt
= bfd_get_section_by_name (abfd
, ".rela.plt");
1116 htab
->sgot
= bfd_get_section_by_name (abfd
, ".got");
1117 htab
->srelgot
= bfd_make_section (abfd
, ".rela.got");
1118 if (htab
->srelgot
== NULL
1119 || ! bfd_set_section_flags (abfd
, htab
->srelgot
,
1124 | SEC_LINKER_CREATED
1126 || ! bfd_set_section_alignment (abfd
, htab
->srelgot
, 2))
1129 htab
->sdynbss
= bfd_get_section_by_name (abfd
, ".dynbss");
1130 htab
->srelbss
= bfd_get_section_by_name (abfd
, ".rela.bss");
1135 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1138 elf32_hppa_copy_indirect_symbol (dir
, ind
)
1139 struct elf_link_hash_entry
*dir
, *ind
;
1141 struct elf32_hppa_link_hash_entry
*edir
, *eind
;
1143 edir
= (struct elf32_hppa_link_hash_entry
*) dir
;
1144 eind
= (struct elf32_hppa_link_hash_entry
*) ind
;
1146 if (eind
->dyn_relocs
!= NULL
)
1148 if (edir
->dyn_relocs
!= NULL
)
1150 struct elf32_hppa_dyn_reloc_entry
**pp
;
1151 struct elf32_hppa_dyn_reloc_entry
*p
;
1153 if (ind
->root
.type
== bfd_link_hash_indirect
)
1156 /* Add reloc counts against the weak sym to the strong sym
1157 list. Merge any entries against the same section. */
1158 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
1160 struct elf32_hppa_dyn_reloc_entry
*q
;
1162 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
1163 if (q
->sec
== p
->sec
)
1165 #if RELATIVE_DYNRELOCS
1166 q
->relative_count
+= p
->relative_count
;
1168 q
->count
+= p
->count
;
1175 *pp
= edir
->dyn_relocs
;
1178 edir
->dyn_relocs
= eind
->dyn_relocs
;
1179 eind
->dyn_relocs
= NULL
;
1182 _bfd_elf_link_hash_copy_indirect (dir
, ind
);
1185 /* Look through the relocs for a section during the first phase, and
1186 calculate needed space in the global offset table, procedure linkage
1187 table, and dynamic reloc sections. At this point we haven't
1188 necessarily read all the input files. */
1191 elf32_hppa_check_relocs (abfd
, info
, sec
, relocs
)
1193 struct bfd_link_info
*info
;
1195 const Elf_Internal_Rela
*relocs
;
1197 Elf_Internal_Shdr
*symtab_hdr
;
1198 struct elf_link_hash_entry
**sym_hashes
;
1199 const Elf_Internal_Rela
*rel
;
1200 const Elf_Internal_Rela
*rel_end
;
1201 struct elf32_hppa_link_hash_table
*htab
;
1203 asection
*stubreloc
;
1205 if (info
->relocateable
)
1208 htab
= hppa_link_hash_table (info
);
1209 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1210 sym_hashes
= elf_sym_hashes (abfd
);
1214 rel_end
= relocs
+ sec
->reloc_count
;
1215 for (rel
= relocs
; rel
< rel_end
; rel
++)
1224 unsigned int r_symndx
, r_type
;
1225 struct elf32_hppa_link_hash_entry
*h
;
1228 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1230 if (r_symndx
< symtab_hdr
->sh_info
)
1233 h
= ((struct elf32_hppa_link_hash_entry
*)
1234 sym_hashes
[r_symndx
- symtab_hdr
->sh_info
]);
1236 r_type
= ELF32_R_TYPE (rel
->r_info
);
1240 case R_PARISC_DLTIND14F
:
1241 case R_PARISC_DLTIND14R
:
1242 case R_PARISC_DLTIND21L
:
1243 /* This symbol requires a global offset table entry. */
1244 need_entry
= NEED_GOT
;
1246 /* Mark this section as containing PIC code. */
1247 sec
->flags
|= SEC_HAS_GOT_REF
;
1250 case R_PARISC_PLABEL14R
: /* "Official" procedure labels. */
1251 case R_PARISC_PLABEL21L
:
1252 case R_PARISC_PLABEL32
:
1253 /* If the addend is non-zero, we break badly. */
1254 if (rel
->r_addend
!= 0)
1257 /* If we are creating a shared library, then we need to
1258 create a PLT entry for all PLABELs, because PLABELs with
1259 local symbols may be passed via a pointer to another
1260 object. Additionally, output a dynamic relocation
1261 pointing to the PLT entry.
1262 For executables, the original 32-bit ABI allowed two
1263 different styles of PLABELs (function pointers): For
1264 global functions, the PLABEL word points into the .plt
1265 two bytes past a (function address, gp) pair, and for
1266 local functions the PLABEL points directly at the
1267 function. The magic +2 for the first type allows us to
1268 differentiate between the two. As you can imagine, this
1269 is a real pain when it comes to generating code to call
1270 functions indirectly or to compare function pointers.
1271 We avoid the mess by always pointing a PLABEL into the
1272 .plt, even for local functions. */
1273 need_entry
= PLT_PLABEL
| NEED_PLT
| NEED_DYNREL
;
1276 case R_PARISC_PCREL12F
:
1277 htab
->has_12bit_branch
= 1;
1279 case R_PARISC_PCREL17C
:
1280 case R_PARISC_PCREL17F
:
1281 htab
->has_17bit_branch
= 1;
1283 case R_PARISC_PCREL22F
:
1284 /* Function calls might need to go through the .plt, and
1285 might require long branch stubs. */
1288 /* We know local syms won't need a .plt entry, and if
1289 they need a long branch stub we can't guarantee that
1290 we can reach the stub. So just flag an error later
1291 if we're doing a shared link and find we need a long
1297 /* Global symbols will need a .plt entry if they remain
1298 global, and in most cases won't need a long branch
1299 stub. Unfortunately, we have to cater for the case
1300 where a symbol is forced local by versioning, or due
1301 to symbolic linking, and we lose the .plt entry. */
1302 need_entry
= NEED_PLT
;
1303 if (h
->elf
.type
== STT_PARISC_MILLI
)
1308 case R_PARISC_SEGBASE
: /* Used to set segment base. */
1309 case R_PARISC_SEGREL32
: /* Relative reloc, used for unwind. */
1310 case R_PARISC_PCREL14F
: /* PC relative load/store. */
1311 case R_PARISC_PCREL14R
:
1312 case R_PARISC_PCREL17R
: /* External branches. */
1313 case R_PARISC_PCREL21L
: /* As above, and for load/store too. */
1314 /* We don't need to propagate the relocation if linking a
1315 shared object since these are section relative. */
1318 case R_PARISC_DPREL14F
: /* Used for gp rel data load/store. */
1319 case R_PARISC_DPREL14R
:
1320 case R_PARISC_DPREL21L
:
1323 (*_bfd_error_handler
)
1324 (_("%s: relocation %s can not be used when making a shared object; recompile with -fPIC"),
1325 bfd_archive_filename (abfd
),
1326 elf_hppa_howto_table
[r_type
].name
);
1327 bfd_set_error (bfd_error_bad_value
);
1332 case R_PARISC_DIR17F
: /* Used for external branches. */
1333 case R_PARISC_DIR17R
:
1334 case R_PARISC_DIR14F
: /* Used for load/store from absolute locn. */
1335 case R_PARISC_DIR14R
:
1336 case R_PARISC_DIR21L
: /* As above, and for ext branches too. */
1338 /* Help debug shared library creation. Any of the above
1339 relocs can be used in shared libs, but they may cause
1340 pages to become unshared. */
1343 (*_bfd_error_handler
)
1344 (_("%s: relocation %s should not be used when making a shared object; recompile with -fPIC"),
1345 bfd_archive_filename (abfd
),
1346 elf_hppa_howto_table
[r_type
].name
);
1351 case R_PARISC_DIR32
: /* .word relocs. */
1352 /* We may want to output a dynamic relocation later. */
1353 need_entry
= NEED_DYNREL
;
1356 /* This relocation describes the C++ object vtable hierarchy.
1357 Reconstruct it for later use during GC. */
1358 case R_PARISC_GNU_VTINHERIT
:
1359 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
,
1360 &h
->elf
, rel
->r_offset
))
1364 /* This relocation describes which C++ vtable entries are actually
1365 used. Record for later use during GC. */
1366 case R_PARISC_GNU_VTENTRY
:
1367 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
,
1368 &h
->elf
, rel
->r_addend
))
1376 /* Now carry out our orders. */
1377 if (need_entry
& NEED_GOT
)
1379 /* Allocate space for a GOT entry, as well as a dynamic
1380 relocation for this entry. */
1381 if (htab
->sgot
== NULL
)
1383 if (htab
->elf
.dynobj
== NULL
)
1384 htab
->elf
.dynobj
= abfd
;
1385 if (!elf32_hppa_create_dynamic_sections (htab
->elf
.dynobj
, info
))
1391 h
->elf
.got
.refcount
+= 1;
1395 bfd_signed_vma
*local_got_refcounts
;
1397 /* This is a global offset table entry for a local symbol. */
1398 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1399 if (local_got_refcounts
== NULL
)
1403 /* Allocate space for local got offsets and local
1404 plt offsets. Done this way to save polluting
1405 elf_obj_tdata with another target specific
1407 size
= symtab_hdr
->sh_info
;
1408 size
*= 2 * sizeof (bfd_signed_vma
);
1409 local_got_refcounts
= ((bfd_signed_vma
*)
1410 bfd_zalloc (abfd
, size
));
1411 if (local_got_refcounts
== NULL
)
1413 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1415 local_got_refcounts
[r_symndx
] += 1;
1419 if (need_entry
& NEED_PLT
)
1421 /* If we are creating a shared library, and this is a reloc
1422 against a weak symbol or a global symbol in a dynamic
1423 object, then we will be creating an import stub and a
1424 .plt entry for the symbol. Similarly, on a normal link
1425 to symbols defined in a dynamic object we'll need the
1426 import stub and a .plt entry. We don't know yet whether
1427 the symbol is defined or not, so make an entry anyway and
1428 clean up later in adjust_dynamic_symbol. */
1429 if ((sec
->flags
& SEC_ALLOC
) != 0)
1433 h
->elf
.elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
1434 h
->elf
.plt
.refcount
+= 1;
1436 /* If this .plt entry is for a plabel, mark it so
1437 that adjust_dynamic_symbol will keep the entry
1438 even if it appears to be local. */
1439 if (need_entry
& PLT_PLABEL
)
1442 else if (need_entry
& PLT_PLABEL
)
1444 bfd_signed_vma
*local_got_refcounts
;
1445 bfd_signed_vma
*local_plt_refcounts
;
1447 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1448 if (local_got_refcounts
== NULL
)
1452 /* Allocate space for local got offsets and local
1454 size
= symtab_hdr
->sh_info
;
1455 size
*= 2 * sizeof (bfd_signed_vma
);
1456 local_got_refcounts
= ((bfd_signed_vma
*)
1457 bfd_zalloc (abfd
, size
));
1458 if (local_got_refcounts
== NULL
)
1460 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1462 local_plt_refcounts
= (local_got_refcounts
1463 + symtab_hdr
->sh_info
);
1464 local_plt_refcounts
[r_symndx
] += 1;
1469 if (need_entry
& NEED_DYNREL
)
1471 /* Flag this symbol as having a non-got, non-plt reference
1472 so that we generate copy relocs if it turns out to be
1474 if (h
!= NULL
&& !info
->shared
)
1475 h
->elf
.elf_link_hash_flags
|= ELF_LINK_NON_GOT_REF
;
1477 /* If we are creating a shared library then we need to copy
1478 the reloc into the shared library. However, if we are
1479 linking with -Bsymbolic, we need only copy absolute
1480 relocs or relocs against symbols that are not defined in
1481 an object we are including in the link. PC- or DP- or
1482 DLT-relative relocs against any local sym or global sym
1483 with DEF_REGULAR set, can be discarded. At this point we
1484 have not seen all the input files, so it is possible that
1485 DEF_REGULAR is not set now but will be set later (it is
1486 never cleared). We account for that possibility below by
1487 storing information in the dyn_relocs field of the
1490 A similar situation to the -Bsymbolic case occurs when
1491 creating shared libraries and symbol visibility changes
1492 render the symbol local.
1494 As it turns out, all the relocs we will be creating here
1495 are absolute, so we cannot remove them on -Bsymbolic
1496 links or visibility changes anyway. A STUB_REL reloc
1497 is absolute too, as in that case it is the reloc in the
1498 stub we will be creating, rather than copying the PCREL
1499 reloc in the branch.
1501 If on the other hand, we are creating an executable, we
1502 may need to keep relocations for symbols satisfied by a
1503 dynamic library if we manage to avoid copy relocs for the
1506 && (sec
->flags
& SEC_ALLOC
) != 0
1507 && (IS_ABSOLUTE_RELOC (r_type
)
1510 || h
->elf
.root
.type
== bfd_link_hash_defweak
1511 || (h
->elf
.elf_link_hash_flags
1512 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
1514 && (sec
->flags
& SEC_ALLOC
) != 0
1516 && (h
->elf
.root
.type
== bfd_link_hash_defweak
1517 || (h
->elf
.elf_link_hash_flags
1518 & ELF_LINK_HASH_DEF_REGULAR
) == 0)))
1520 struct elf32_hppa_dyn_reloc_entry
*p
;
1521 struct elf32_hppa_dyn_reloc_entry
**head
;
1523 /* Create a reloc section in dynobj and make room for
1530 name
= (bfd_elf_string_from_elf_section
1532 elf_elfheader (abfd
)->e_shstrndx
,
1533 elf_section_data (sec
)->rel_hdr
.sh_name
));
1536 (*_bfd_error_handler
)
1537 (_("Could not find relocation section for %s"),
1539 bfd_set_error (bfd_error_bad_value
);
1543 if (htab
->elf
.dynobj
== NULL
)
1544 htab
->elf
.dynobj
= abfd
;
1546 dynobj
= htab
->elf
.dynobj
;
1547 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1552 sreloc
= bfd_make_section (dynobj
, name
);
1553 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
1554 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
1555 if ((sec
->flags
& SEC_ALLOC
) != 0)
1556 flags
|= SEC_ALLOC
| SEC_LOAD
;
1558 || !bfd_set_section_flags (dynobj
, sreloc
, flags
)
1559 || !bfd_set_section_alignment (dynobj
, sreloc
, 2))
1563 elf_section_data (sec
)->sreloc
= sreloc
;
1566 /* If this is a global symbol, we count the number of
1567 relocations we need for this symbol. */
1570 head
= &h
->dyn_relocs
;
1574 /* Track dynamic relocs needed for local syms too.
1575 We really need local syms available to do this
1579 s
= bfd_section_from_r_symndx (abfd
, &htab
->sym_sec
,
1584 head
= ((struct elf32_hppa_dyn_reloc_entry
**)
1585 &elf_section_data (s
)->local_dynrel
);
1589 if (p
== NULL
|| p
->sec
!= sec
)
1591 p
= ((struct elf32_hppa_dyn_reloc_entry
*)
1592 bfd_alloc (htab
->elf
.dynobj
,
1593 (bfd_size_type
) sizeof *p
));
1600 #if RELATIVE_DYNRELOCS
1601 p
->relative_count
= 0;
1606 #if RELATIVE_DYNRELOCS
1607 if (!IS_ABSOLUTE_RELOC (rtype
))
1608 p
->relative_count
+= 1;
1617 /* Return the section that should be marked against garbage collection
1618 for a given relocation. */
1621 elf32_hppa_gc_mark_hook (abfd
, info
, rel
, h
, sym
)
1623 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1624 Elf_Internal_Rela
*rel
;
1625 struct elf_link_hash_entry
*h
;
1626 Elf_Internal_Sym
*sym
;
1630 switch ((unsigned int) ELF32_R_TYPE (rel
->r_info
))
1632 case R_PARISC_GNU_VTINHERIT
:
1633 case R_PARISC_GNU_VTENTRY
:
1637 switch (h
->root
.type
)
1639 case bfd_link_hash_defined
:
1640 case bfd_link_hash_defweak
:
1641 return h
->root
.u
.def
.section
;
1643 case bfd_link_hash_common
:
1644 return h
->root
.u
.c
.p
->section
;
1653 if (!(elf_bad_symtab (abfd
)
1654 && ELF_ST_BIND (sym
->st_info
) != STB_LOCAL
)
1655 && ! ((sym
->st_shndx
<= 0 || sym
->st_shndx
>= SHN_LORESERVE
)
1656 && sym
->st_shndx
!= SHN_COMMON
))
1658 return bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
1665 /* Update the got and plt entry reference counts for the section being
1669 elf32_hppa_gc_sweep_hook (abfd
, info
, sec
, relocs
)
1671 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1673 const Elf_Internal_Rela
*relocs
;
1675 Elf_Internal_Shdr
*symtab_hdr
;
1676 struct elf_link_hash_entry
**sym_hashes
;
1677 bfd_signed_vma
*local_got_refcounts
;
1678 bfd_signed_vma
*local_plt_refcounts
;
1679 const Elf_Internal_Rela
*rel
, *relend
;
1680 unsigned long r_symndx
;
1681 struct elf_link_hash_entry
*h
;
1682 struct elf32_hppa_link_hash_table
*htab
;
1685 elf_section_data (sec
)->local_dynrel
= NULL
;
1687 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1688 sym_hashes
= elf_sym_hashes (abfd
);
1689 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1690 local_plt_refcounts
= local_got_refcounts
;
1691 if (local_plt_refcounts
!= NULL
)
1692 local_plt_refcounts
+= symtab_hdr
->sh_info
;
1693 htab
= hppa_link_hash_table (info
);
1694 dynobj
= htab
->elf
.dynobj
;
1698 relend
= relocs
+ sec
->reloc_count
;
1699 for (rel
= relocs
; rel
< relend
; rel
++)
1700 switch ((unsigned int) ELF32_R_TYPE (rel
->r_info
))
1702 case R_PARISC_DLTIND14F
:
1703 case R_PARISC_DLTIND14R
:
1704 case R_PARISC_DLTIND21L
:
1705 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1706 if (r_symndx
>= symtab_hdr
->sh_info
)
1708 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1709 if (h
->got
.refcount
> 0)
1710 h
->got
.refcount
-= 1;
1712 else if (local_got_refcounts
!= NULL
)
1714 if (local_got_refcounts
[r_symndx
] > 0)
1715 local_got_refcounts
[r_symndx
] -= 1;
1719 case R_PARISC_PCREL12F
:
1720 case R_PARISC_PCREL17C
:
1721 case R_PARISC_PCREL17F
:
1722 case R_PARISC_PCREL22F
:
1723 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1724 if (r_symndx
>= symtab_hdr
->sh_info
)
1726 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1727 if (h
->plt
.refcount
> 0)
1728 h
->plt
.refcount
-= 1;
1732 case R_PARISC_PLABEL14R
:
1733 case R_PARISC_PLABEL21L
:
1734 case R_PARISC_PLABEL32
:
1735 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1736 if (r_symndx
>= symtab_hdr
->sh_info
)
1738 struct elf32_hppa_link_hash_entry
*eh
;
1739 struct elf32_hppa_dyn_reloc_entry
**pp
;
1740 struct elf32_hppa_dyn_reloc_entry
*p
;
1742 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1744 if (h
->plt
.refcount
> 0)
1745 h
->plt
.refcount
-= 1;
1747 eh
= (struct elf32_hppa_link_hash_entry
*) h
;
1749 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1752 #if RELATIVE_DYNRELOCS
1753 if (!IS_ABSOLUTE_RELOC (rtype
))
1754 p
->relative_count
-= 1;
1762 else if (local_plt_refcounts
!= NULL
)
1764 if (local_plt_refcounts
[r_symndx
] > 0)
1765 local_plt_refcounts
[r_symndx
] -= 1;
1769 case R_PARISC_DIR32
:
1770 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1771 if (r_symndx
>= symtab_hdr
->sh_info
)
1773 struct elf32_hppa_link_hash_entry
*eh
;
1774 struct elf32_hppa_dyn_reloc_entry
**pp
;
1775 struct elf32_hppa_dyn_reloc_entry
*p
;
1777 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1779 eh
= (struct elf32_hppa_link_hash_entry
*) h
;
1781 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; pp
= &p
->next
)
1784 #if RELATIVE_DYNRELOCS
1785 if (!IS_ABSOLUTE_RELOC (R_PARISC_DIR32
))
1786 p
->relative_count
-= 1;
1803 /* Our own version of hide_symbol, so that we can keep plt entries for
1807 elf32_hppa_hide_symbol (info
, h
)
1808 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1809 struct elf_link_hash_entry
*h
;
1811 if ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0)
1813 if (! ((struct elf32_hppa_link_hash_entry
*) h
)->plabel
)
1815 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1816 h
->plt
.offset
= (bfd_vma
) -1;
1820 /* This is the condition under which elf32_hppa_finish_dynamic_symbol
1821 will be called from elflink.h. If elflink.h doesn't call our
1822 finish_dynamic_symbol routine, we'll need to do something about
1823 initializing any .plt and .got entries in elf32_hppa_relocate_section. */
1824 #define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1826 && ((INFO)->shared \
1827 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1828 && ((H)->dynindx != -1 \
1829 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1831 /* Adjust a symbol defined by a dynamic object and referenced by a
1832 regular object. The current definition is in some section of the
1833 dynamic object, but we're not including those sections. We have to
1834 change the definition to something the rest of the link can
1838 elf32_hppa_adjust_dynamic_symbol (info
, h
)
1839 struct bfd_link_info
*info
;
1840 struct elf_link_hash_entry
*h
;
1842 struct elf32_hppa_link_hash_table
*htab
;
1843 struct elf32_hppa_link_hash_entry
*eh
;
1844 struct elf32_hppa_dyn_reloc_entry
*p
;
1846 unsigned int power_of_two
;
1848 /* If this is a function, put it in the procedure linkage table. We
1849 will fill in the contents of the procedure linkage table later,
1850 when we know the address of the .got section. */
1851 if (h
->type
== STT_FUNC
1852 || (h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_PLT
) != 0)
1855 && h
->plt
.refcount
> 0
1856 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1857 && (h
->root
.u
.def
.section
->flags
& SEC_HAS_GOT_REF
) != 0)
1859 ((struct elf32_hppa_link_hash_entry
*) h
)->maybe_pic_call
= 1;
1862 if (h
->plt
.refcount
<= 0
1863 || ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
1864 && h
->root
.type
!= bfd_link_hash_defweak
1865 && ! ((struct elf32_hppa_link_hash_entry
*) h
)->plabel
1866 && (!info
->shared
|| info
->symbolic
)))
1868 /* The .plt entry is not needed when:
1869 a) Garbage collection has removed all references to the
1871 b) We know for certain the symbol is defined in this
1872 object, and it's not a weak definition, nor is the symbol
1873 used by a plabel relocation. Either this object is the
1874 application or we are doing a shared symbolic link. */
1876 /* As a special sop to the hppa ABI, we keep a .plt entry
1877 for functions in sections containing PIC code. */
1878 if (((struct elf32_hppa_link_hash_entry
*) h
)->maybe_pic_call
)
1879 ((struct elf32_hppa_link_hash_entry
*) h
)->pic_call
= 1;
1882 h
->plt
.offset
= (bfd_vma
) -1;
1883 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1890 h
->plt
.offset
= (bfd_vma
) -1;
1892 /* If this is a weak symbol, and there is a real definition, the
1893 processor independent code will have arranged for us to see the
1894 real definition first, and we can just use the same value. */
1895 if (h
->weakdef
!= NULL
)
1897 if (h
->weakdef
->root
.type
!= bfd_link_hash_defined
1898 && h
->weakdef
->root
.type
!= bfd_link_hash_defweak
)
1900 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
1901 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
1905 /* This is a reference to a symbol defined by a dynamic object which
1906 is not a function. */
1908 /* If we are creating a shared library, we must presume that the
1909 only references to the symbol are via the global offset table.
1910 For such cases we need not do anything here; the relocations will
1911 be handled correctly by relocate_section. */
1915 /* If there are no references to this symbol that do not use the
1916 GOT, we don't need to generate a copy reloc. */
1917 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0)
1920 eh
= (struct elf32_hppa_link_hash_entry
*) h
;
1921 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1923 s
= p
->sec
->output_section
;
1924 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1928 /* If we didn't find any dynamic relocs in read-only sections, then
1929 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1932 h
->elf_link_hash_flags
&= ~ELF_LINK_NON_GOT_REF
;
1936 /* We must allocate the symbol in our .dynbss section, which will
1937 become part of the .bss section of the executable. There will be
1938 an entry for this symbol in the .dynsym section. The dynamic
1939 object will contain position independent code, so all references
1940 from the dynamic object to this symbol will go through the global
1941 offset table. The dynamic linker will use the .dynsym entry to
1942 determine the address it must put in the global offset table, so
1943 both the dynamic object and the regular object will refer to the
1944 same memory location for the variable. */
1946 htab
= hppa_link_hash_table (info
);
1948 /* We must generate a COPY reloc to tell the dynamic linker to
1949 copy the initial value out of the dynamic object and into the
1950 runtime process image. */
1951 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
1953 htab
->srelbss
->_raw_size
+= sizeof (Elf32_External_Rela
);
1954 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_COPY
;
1957 /* We need to figure out the alignment required for this symbol. I
1958 have no idea how other ELF linkers handle this. */
1960 power_of_two
= bfd_log2 (h
->size
);
1961 if (power_of_two
> 3)
1964 /* Apply the required alignment. */
1966 s
->_raw_size
= BFD_ALIGN (s
->_raw_size
,
1967 (bfd_size_type
) (1 << power_of_two
));
1968 if (power_of_two
> bfd_get_section_alignment (htab
->elf
.dynobj
, s
))
1970 if (! bfd_set_section_alignment (htab
->elf
.dynobj
, s
, power_of_two
))
1974 /* Define the symbol as being at this point in the section. */
1975 h
->root
.u
.def
.section
= s
;
1976 h
->root
.u
.def
.value
= s
->_raw_size
;
1978 /* Increment the section size to make room for the symbol. */
1979 s
->_raw_size
+= h
->size
;
1984 /* Called via elf_link_hash_traverse to create .plt entries for an
1985 application that uses statically linked PIC functions. Similar to
1986 the first part of elf32_hppa_adjust_dynamic_symbol. */
1989 mark_PIC_calls (h
, inf
)
1990 struct elf_link_hash_entry
*h
;
1991 PTR inf ATTRIBUTE_UNUSED
;
1993 if (! (h
->plt
.refcount
> 0
1994 && (h
->root
.type
== bfd_link_hash_defined
1995 || h
->root
.type
== bfd_link_hash_defweak
)
1996 && (h
->root
.u
.def
.section
->flags
& SEC_HAS_GOT_REF
) != 0))
1998 h
->plt
.offset
= (bfd_vma
) -1;
1999 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
2003 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2004 ((struct elf32_hppa_link_hash_entry
*) h
)->maybe_pic_call
= 1;
2005 ((struct elf32_hppa_link_hash_entry
*) h
)->pic_call
= 1;
2010 /* Allocate space in the .plt for entries that won't have relocations.
2011 ie. pic_call and plabel entries. */
2014 allocate_plt_static (h
, inf
)
2015 struct elf_link_hash_entry
*h
;
2018 struct bfd_link_info
*info
;
2019 struct elf32_hppa_link_hash_table
*htab
;
2022 if (h
->root
.type
== bfd_link_hash_indirect
2023 || h
->root
.type
== bfd_link_hash_warning
)
2026 info
= (struct bfd_link_info
*) inf
;
2027 htab
= hppa_link_hash_table (info
);
2028 if (((struct elf32_hppa_link_hash_entry
*) h
)->pic_call
)
2030 /* Make an entry in the .plt section for non-pic code that is
2031 calling pic code. */
2033 h
->plt
.offset
= s
->_raw_size
;
2034 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2036 else if (htab
->elf
.dynamic_sections_created
2037 && h
->plt
.refcount
> 0)
2039 /* Make sure this symbol is output as a dynamic symbol.
2040 Undefined weak syms won't yet be marked as dynamic. */
2041 if (h
->dynindx
== -1
2042 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0
2043 && h
->type
!= STT_PARISC_MILLI
)
2045 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2049 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
, h
))
2051 /* Allocate these later. */
2053 else if (((struct elf32_hppa_link_hash_entry
*) h
)->plabel
)
2055 /* Make an entry in the .plt section for plabel references
2056 that won't have a .plt entry for other reasons. */
2058 h
->plt
.offset
= s
->_raw_size
;
2059 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2063 /* No .plt entry needed. */
2064 h
->plt
.offset
= (bfd_vma
) -1;
2065 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
2070 h
->plt
.offset
= (bfd_vma
) -1;
2071 h
->elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
2077 /* Allocate space in .plt, .got and associated reloc sections for
2081 allocate_dynrelocs (h
, inf
)
2082 struct elf_link_hash_entry
*h
;
2085 struct bfd_link_info
*info
;
2086 struct elf32_hppa_link_hash_table
*htab
;
2088 struct elf32_hppa_link_hash_entry
*eh
;
2089 struct elf32_hppa_dyn_reloc_entry
*p
;
2091 if (h
->root
.type
== bfd_link_hash_indirect
2092 || h
->root
.type
== bfd_link_hash_warning
)
2095 info
= (struct bfd_link_info
*) inf
;
2096 htab
= hppa_link_hash_table (info
);
2097 if (htab
->elf
.dynamic_sections_created
2098 && h
->plt
.offset
!= (bfd_vma
) -1
2099 && !((struct elf32_hppa_link_hash_entry
*) h
)->pic_call
2100 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
, h
))
2102 /* Make an entry in the .plt section. */
2104 h
->plt
.offset
= s
->_raw_size
;
2105 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2107 /* We also need to make an entry in the .rela.plt section. */
2108 htab
->srelplt
->_raw_size
+= sizeof (Elf32_External_Rela
);
2109 htab
->need_plt_stub
= 1;
2112 if (h
->got
.refcount
> 0)
2114 /* Make sure this symbol is output as a dynamic symbol.
2115 Undefined weak syms won't yet be marked as dynamic. */
2116 if (h
->dynindx
== -1
2117 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0
2118 && h
->type
!= STT_PARISC_MILLI
)
2120 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2125 h
->got
.offset
= s
->_raw_size
;
2126 s
->_raw_size
+= GOT_ENTRY_SIZE
;
2127 if (htab
->elf
.dynamic_sections_created
2129 || (h
->dynindx
!= -1
2130 && h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0))
2132 htab
->srelgot
->_raw_size
+= sizeof (Elf32_External_Rela
);
2136 h
->got
.offset
= (bfd_vma
) -1;
2138 eh
= (struct elf32_hppa_link_hash_entry
*) h
;
2139 if (eh
->dyn_relocs
== NULL
)
2142 /* If this is a -Bsymbolic shared link, then we need to discard all
2143 space allocated for dynamic pc-relative relocs against symbols
2144 defined in a regular object. For the normal shared case, discard
2145 space for relocs that have become local due to symbol visibility
2149 #if RELATIVE_DYNRELOCS
2150 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) != 0
2151 && ((h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) != 0
2154 struct elf32_hppa_dyn_reloc_entry
**pp
;
2156 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
2158 p
->count
-= p
->relative_count
;
2159 p
->relative_count
= 0;
2170 /* For the non-shared case, discard space for relocs against
2171 symbols which turn out to need copy relocs or are not
2173 if ((h
->elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
2174 && (((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_DYNAMIC
) != 0
2175 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
2176 || (htab
->elf
.dynamic_sections_created
2177 && (h
->root
.type
== bfd_link_hash_undefweak
2178 || h
->root
.type
== bfd_link_hash_undefined
))))
2180 /* Make sure this symbol is output as a dynamic symbol.
2181 Undefined weak syms won't yet be marked as dynamic. */
2182 if (h
->dynindx
== -1
2183 && (h
->elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
) == 0
2184 && h
->type
!= STT_PARISC_MILLI
)
2186 if (! bfd_elf32_link_record_dynamic_symbol (info
, h
))
2190 /* If that succeeded, we know we'll be keeping all the
2192 if (h
->dynindx
!= -1)
2196 eh
->dyn_relocs
= NULL
;
2202 /* Finally, allocate space. */
2203 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2205 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
2206 sreloc
->_raw_size
+= p
->count
* sizeof (Elf32_External_Rela
);
2212 /* This function is called via elf_link_hash_traverse to force
2213 millicode symbols local so they do not end up as globals in the
2214 dynamic symbol table. We ought to be able to do this in
2215 adjust_dynamic_symbol, but our adjust_dynamic_symbol is not called
2216 for all dynamic symbols. Arguably, this is a bug in
2217 elf_adjust_dynamic_symbol. */
2220 clobber_millicode_symbols (h
, info
)
2221 struct elf_link_hash_entry
*h
;
2222 struct bfd_link_info
*info
;
2224 /* We only want to remove these from the dynamic symbol table.
2225 Therefore we do not leave ELF_LINK_FORCED_LOCAL set. */
2226 if (h
->type
== STT_PARISC_MILLI
)
2228 unsigned short oldflags
= h
->elf_link_hash_flags
;
2229 h
->elf_link_hash_flags
|= ELF_LINK_FORCED_LOCAL
;
2230 elf32_hppa_hide_symbol (info
, h
);
2231 h
->elf_link_hash_flags
&= ~ELF_LINK_FORCED_LOCAL
;
2232 h
->elf_link_hash_flags
|= oldflags
& ELF_LINK_FORCED_LOCAL
;
2237 /* Find any dynamic relocs that apply to read-only sections. */
2240 readonly_dynrelocs (h
, inf
)
2241 struct elf_link_hash_entry
*h
;
2244 struct elf32_hppa_link_hash_entry
*eh
;
2245 struct elf32_hppa_dyn_reloc_entry
*p
;
2247 eh
= (struct elf32_hppa_link_hash_entry
*) h
;
2248 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
2250 asection
*s
= p
->sec
->output_section
;
2252 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
2254 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
2256 info
->flags
|= DF_TEXTREL
;
2258 /* Not an error, just cut short the traversal. */
2265 /* Set the sizes of the dynamic sections. */
2268 elf32_hppa_size_dynamic_sections (output_bfd
, info
)
2269 bfd
*output_bfd ATTRIBUTE_UNUSED
;
2270 struct bfd_link_info
*info
;
2272 struct elf32_hppa_link_hash_table
*htab
;
2278 htab
= hppa_link_hash_table (info
);
2279 dynobj
= htab
->elf
.dynobj
;
2283 if (htab
->elf
.dynamic_sections_created
)
2285 /* Set the contents of the .interp section to the interpreter. */
2288 s
= bfd_get_section_by_name (dynobj
, ".interp");
2291 s
->_raw_size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2292 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2295 /* Force millicode symbols local. */
2296 elf_link_hash_traverse (&htab
->elf
,
2297 clobber_millicode_symbols
,
2302 /* Run through the function symbols, looking for any that are
2303 PIC, and mark them as needing .plt entries so that %r19 will
2306 elf_link_hash_traverse (&htab
->elf
, mark_PIC_calls
, (PTR
) info
);
2309 /* Set up .got and .plt offsets for local syms, and space for local
2311 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
2313 bfd_signed_vma
*local_got
;
2314 bfd_signed_vma
*end_local_got
;
2315 bfd_signed_vma
*local_plt
;
2316 bfd_signed_vma
*end_local_plt
;
2317 bfd_size_type locsymcount
;
2318 Elf_Internal_Shdr
*symtab_hdr
;
2321 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
2324 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
2326 struct elf32_hppa_dyn_reloc_entry
*p
;
2328 for (p
= ((struct elf32_hppa_dyn_reloc_entry
*)
2329 elf_section_data (s
)->local_dynrel
);
2333 if (!bfd_is_abs_section (p
->sec
)
2334 && bfd_is_abs_section (p
->sec
->output_section
))
2336 /* Input section has been discarded, either because
2337 it is a copy of a linkonce section or due to
2338 linker script /DISCARD/, so we'll be discarding
2343 srel
= elf_section_data (p
->sec
)->sreloc
;
2344 srel
->_raw_size
+= p
->count
* sizeof (Elf32_External_Rela
);
2349 local_got
= elf_local_got_refcounts (ibfd
);
2353 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2354 locsymcount
= symtab_hdr
->sh_info
;
2355 end_local_got
= local_got
+ locsymcount
;
2357 srel
= htab
->srelgot
;
2358 for (; local_got
< end_local_got
; ++local_got
)
2362 *local_got
= s
->_raw_size
;
2363 s
->_raw_size
+= GOT_ENTRY_SIZE
;
2365 srel
->_raw_size
+= sizeof (Elf32_External_Rela
);
2368 *local_got
= (bfd_vma
) -1;
2371 local_plt
= end_local_got
;
2372 end_local_plt
= local_plt
+ locsymcount
;
2373 if (! htab
->elf
.dynamic_sections_created
)
2375 /* Won't be used, but be safe. */
2376 for (; local_plt
< end_local_plt
; ++local_plt
)
2377 *local_plt
= (bfd_vma
) -1;
2382 srel
= htab
->srelplt
;
2383 for (; local_plt
< end_local_plt
; ++local_plt
)
2387 *local_plt
= s
->_raw_size
;
2388 s
->_raw_size
+= PLT_ENTRY_SIZE
;
2390 srel
->_raw_size
+= sizeof (Elf32_External_Rela
);
2393 *local_plt
= (bfd_vma
) -1;
2398 /* Do all the .plt entries without relocs first. The dynamic linker
2399 uses the last .plt reloc to find the end of the .plt (and hence
2400 the start of the .got) for lazy linking. */
2401 elf_link_hash_traverse (&htab
->elf
, allocate_plt_static
, (PTR
) info
);
2403 /* Allocate global sym .plt and .got entries, and space for global
2404 sym dynamic relocs. */
2405 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, (PTR
) info
);
2407 /* The check_relocs and adjust_dynamic_symbol entry points have
2408 determined the sizes of the various dynamic sections. Allocate
2411 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2413 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2416 if (s
== htab
->splt
)
2418 if (htab
->need_plt_stub
)
2420 /* Make space for the plt stub at the end of the .plt
2421 section. We want this stub right at the end, up
2422 against the .got section. */
2423 int gotalign
= bfd_section_alignment (dynobj
, htab
->sgot
);
2424 int pltalign
= bfd_section_alignment (dynobj
, s
);
2427 if (gotalign
> pltalign
)
2428 bfd_set_section_alignment (dynobj
, s
, gotalign
);
2429 mask
= ((bfd_size_type
) 1 << gotalign
) - 1;
2430 s
->_raw_size
= (s
->_raw_size
+ sizeof (plt_stub
) + mask
) & ~mask
;
2433 else if (s
== htab
->sgot
)
2435 else if (strncmp (bfd_get_section_name (dynobj
, s
), ".rela", 5) == 0)
2437 if (s
->_raw_size
!= 0)
2439 /* Remember whether there are any reloc sections other
2441 if (s
!= htab
->srelplt
)
2444 /* We use the reloc_count field as a counter if we need
2445 to copy relocs into the output file. */
2451 /* It's not one of our sections, so don't allocate space. */
2455 if (s
->_raw_size
== 0)
2457 /* If we don't need this section, strip it from the
2458 output file. This is mostly to handle .rela.bss and
2459 .rela.plt. We must create both sections in
2460 create_dynamic_sections, because they must be created
2461 before the linker maps input sections to output
2462 sections. The linker does that before
2463 adjust_dynamic_symbol is called, and it is that
2464 function which decides whether anything needs to go
2465 into these sections. */
2466 _bfd_strip_section_from_output (info
, s
);
2470 /* Allocate memory for the section contents. Zero it, because
2471 we may not fill in all the reloc sections. */
2472 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->_raw_size
);
2473 if (s
->contents
== NULL
&& s
->_raw_size
!= 0)
2477 if (htab
->elf
.dynamic_sections_created
)
2479 /* Like IA-64 and HPPA64, always create a DT_PLTGOT. It
2480 actually has nothing to do with the PLT, it is how we
2481 communicate the LTP value of a load module to the dynamic
2483 #define add_dynamic_entry(TAG, VAL) \
2484 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
2486 if (!add_dynamic_entry (DT_PLTGOT
, 0))
2489 /* Add some entries to the .dynamic section. We fill in the
2490 values later, in elf32_hppa_finish_dynamic_sections, but we
2491 must add the entries now so that we get the correct size for
2492 the .dynamic section. The DT_DEBUG entry is filled in by the
2493 dynamic linker and used by the debugger. */
2496 if (!add_dynamic_entry (DT_DEBUG
, 0))
2500 if (htab
->srelplt
->_raw_size
!= 0)
2502 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
2503 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
2504 || !add_dynamic_entry (DT_JMPREL
, 0))
2510 if (!add_dynamic_entry (DT_RELA
, 0)
2511 || !add_dynamic_entry (DT_RELASZ
, 0)
2512 || !add_dynamic_entry (DT_RELAENT
, sizeof (Elf32_External_Rela
)))
2515 /* If any dynamic relocs apply to a read-only section,
2516 then we need a DT_TEXTREL entry. */
2517 elf_link_hash_traverse (&htab
->elf
, readonly_dynrelocs
, (PTR
) info
);
2519 if ((info
->flags
& DF_TEXTREL
) != 0)
2521 if (!add_dynamic_entry (DT_TEXTREL
, 0))
2526 #undef add_dynamic_entry
2531 /* External entry points for sizing and building linker stubs. */
2533 /* Determine and set the size of the stub section for a final link.
2535 The basic idea here is to examine all the relocations looking for
2536 PC-relative calls to a target that is unreachable with a "bl"
2540 elf32_hppa_size_stubs (output_bfd
, stub_bfd
, info
, multi_subspace
, group_size
,
2541 add_stub_section
, layout_sections_again
)
2544 struct bfd_link_info
*info
;
2545 boolean multi_subspace
;
2546 bfd_signed_vma group_size
;
2547 asection
* (*add_stub_section
) PARAMS ((const char *, asection
*));
2548 void (*layout_sections_again
) PARAMS ((void));
2552 asection
**input_list
, **list
;
2553 Elf_Internal_Sym
*local_syms
, **all_local_syms
;
2554 unsigned int bfd_indx
, bfd_count
;
2555 int top_id
, top_index
;
2556 struct elf32_hppa_link_hash_table
*htab
;
2557 bfd_size_type stub_group_size
;
2558 boolean stubs_always_before_branch
;
2559 boolean stub_changed
= 0;
2563 htab
= hppa_link_hash_table (info
);
2565 /* Stash our params away. */
2566 htab
->stub_bfd
= stub_bfd
;
2567 htab
->multi_subspace
= multi_subspace
;
2568 htab
->add_stub_section
= add_stub_section
;
2569 htab
->layout_sections_again
= layout_sections_again
;
2570 stubs_always_before_branch
= group_size
< 0;
2572 stub_group_size
= -group_size
;
2574 stub_group_size
= group_size
;
2575 if (stub_group_size
== 1)
2577 /* Default values. */
2578 stub_group_size
= 8000000;
2579 if (htab
->has_17bit_branch
|| htab
->multi_subspace
)
2580 stub_group_size
= 250000;
2581 if (htab
->has_12bit_branch
)
2582 stub_group_size
= 7812;
2585 /* Count the number of input BFDs and find the top input section id. */
2586 for (input_bfd
= info
->input_bfds
, bfd_count
= 0, top_id
= 0;
2588 input_bfd
= input_bfd
->link_next
)
2591 for (section
= input_bfd
->sections
;
2593 section
= section
->next
)
2595 if (top_id
< section
->id
)
2596 top_id
= section
->id
;
2600 amt
= sizeof (struct map_stub
) * (top_id
+ 1);
2601 htab
->stub_group
= (struct map_stub
*) bfd_zmalloc (amt
);
2602 if (htab
->stub_group
== NULL
)
2605 /* Make a list of input sections for each output section included in
2608 We can't use output_bfd->section_count here to find the top output
2609 section index as some sections may have been removed, and
2610 _bfd_strip_section_from_output doesn't renumber the indices. */
2611 for (section
= output_bfd
->sections
, top_index
= 0;
2613 section
= section
->next
)
2615 if (top_index
< section
->index
)
2616 top_index
= section
->index
;
2619 amt
= sizeof (asection
*) * (top_index
+ 1);
2620 input_list
= (asection
**) bfd_malloc (amt
);
2621 if (input_list
== NULL
)
2624 /* For sections we aren't interested in, mark their entries with a
2625 value we can check later. */
2626 list
= input_list
+ top_index
;
2628 *list
= bfd_abs_section_ptr
;
2629 while (list
-- != input_list
);
2631 for (section
= output_bfd
->sections
;
2633 section
= section
->next
)
2635 if ((section
->flags
& SEC_CODE
) != 0)
2636 input_list
[section
->index
] = NULL
;
2639 /* Now actually build the lists. */
2640 for (input_bfd
= info
->input_bfds
;
2642 input_bfd
= input_bfd
->link_next
)
2644 for (section
= input_bfd
->sections
;
2646 section
= section
->next
)
2648 if (section
->output_section
!= NULL
2649 && section
->output_section
->owner
== output_bfd
2650 && section
->output_section
->index
<= top_index
)
2652 list
= input_list
+ section
->output_section
->index
;
2653 if (*list
!= bfd_abs_section_ptr
)
2655 /* Steal the link_sec pointer for our list. */
2656 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
2657 /* This happens to make the list in reverse order,
2658 which is what we want. */
2659 PREV_SEC (section
) = *list
;
2666 /* See whether we can group stub sections together. Grouping stub
2667 sections may result in fewer stubs. More importantly, we need to
2668 put all .init* and .fini* stubs at the beginning of the .init or
2669 .fini output sections respectively, because glibc splits the
2670 _init and _fini functions into multiple parts. Putting a stub in
2671 the middle of a function is not a good idea. */
2672 list
= input_list
+ top_index
;
2675 asection
*tail
= *list
;
2676 if (tail
== bfd_abs_section_ptr
)
2678 while (tail
!= NULL
)
2682 bfd_size_type total
;
2685 if (tail
->_cooked_size
)
2686 total
= tail
->_cooked_size
;
2688 total
= tail
->_raw_size
;
2689 while ((prev
= PREV_SEC (curr
)) != NULL
2690 && ((total
+= curr
->output_offset
- prev
->output_offset
)
2694 /* OK, the size from the start of CURR to the end is less
2695 than 250000 bytes and thus can be handled by one stub
2696 section. (or the tail section is itself larger than
2697 250000 bytes, in which case we may be toast.)
2698 We should really be keeping track of the total size of
2699 stubs added here, as stubs contribute to the final output
2700 section size. That's a little tricky, and this way will
2701 only break if stubs added total more than 12144 bytes, or
2702 1518 long branch stubs. It seems unlikely for more than
2703 1518 different functions to be called, especially from
2704 code only 250000 bytes long. */
2707 prev
= PREV_SEC (tail
);
2708 /* Set up this stub group. */
2709 htab
->stub_group
[tail
->id
].link_sec
= curr
;
2711 while (tail
!= curr
&& (tail
= prev
) != NULL
);
2713 /* But wait, there's more! Input sections up to 250000
2714 bytes before the stub section can be handled by it too. */
2715 if (!stubs_always_before_branch
)
2719 && ((total
+= tail
->output_offset
- prev
->output_offset
)
2723 prev
= PREV_SEC (tail
);
2724 htab
->stub_group
[tail
->id
].link_sec
= curr
;
2730 while (list
-- != input_list
);
2734 /* We want to read in symbol extension records only once. To do this
2735 we need to read in the local symbols in parallel and save them for
2736 later use; so hold pointers to the local symbols in an array. */
2737 amt
= sizeof (Elf_Internal_Sym
*) * bfd_count
;
2738 all_local_syms
= (Elf_Internal_Sym
**) bfd_zmalloc (amt
);
2739 if (all_local_syms
== NULL
)
2742 /* Walk over all the input BFDs, swapping in local symbols.
2743 If we are creating a shared library, create hash entries for the
2745 for (input_bfd
= info
->input_bfds
, bfd_indx
= 0;
2747 input_bfd
= input_bfd
->link_next
, bfd_indx
++)
2749 Elf_Internal_Shdr
*symtab_hdr
;
2750 Elf_Internal_Sym
*isym
;
2751 Elf32_External_Sym
*ext_syms
, *esym
, *end_sy
;
2752 bfd_size_type sec_size
;
2754 /* We'll need the symbol table in a second. */
2755 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2756 if (symtab_hdr
->sh_info
== 0)
2759 /* We need an array of the local symbols attached to the input bfd.
2760 Unfortunately, we're going to have to read & swap them in. */
2761 sec_size
= symtab_hdr
->sh_info
;
2762 sec_size
*= sizeof (Elf_Internal_Sym
);
2763 local_syms
= (Elf_Internal_Sym
*) bfd_malloc (sec_size
);
2764 if (local_syms
== NULL
)
2766 goto error_ret_free_local
;
2768 all_local_syms
[bfd_indx
] = local_syms
;
2769 sec_size
= symtab_hdr
->sh_info
;
2770 sec_size
*= sizeof (Elf32_External_Sym
);
2771 ext_syms
= (Elf32_External_Sym
*) bfd_malloc (sec_size
);
2772 if (ext_syms
== NULL
)
2774 goto error_ret_free_local
;
2777 if (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
2778 || (bfd_bread (ext_syms
, sec_size
, input_bfd
) != sec_size
))
2781 goto error_ret_free_local
;
2784 /* Swap the local symbols in. */
2787 for (end_sy
= esym
+ symtab_hdr
->sh_info
; esym
< end_sy
; esym
++, isym
++)
2788 bfd_elf32_swap_symbol_in (input_bfd
, esym
, isym
);
2790 /* Now we can free the external symbols. */
2793 if (info
->shared
&& htab
->multi_subspace
)
2795 struct elf_link_hash_entry
**sym_hashes
;
2796 struct elf_link_hash_entry
**end_hashes
;
2797 unsigned int symcount
;
2799 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
2800 - symtab_hdr
->sh_info
);
2801 sym_hashes
= elf_sym_hashes (input_bfd
);
2802 end_hashes
= sym_hashes
+ symcount
;
2804 /* Look through the global syms for functions; We need to
2805 build export stubs for all globally visible functions. */
2806 for (; sym_hashes
< end_hashes
; sym_hashes
++)
2808 struct elf32_hppa_link_hash_entry
*hash
;
2810 hash
= (struct elf32_hppa_link_hash_entry
*) *sym_hashes
;
2812 while (hash
->elf
.root
.type
== bfd_link_hash_indirect
2813 || hash
->elf
.root
.type
== bfd_link_hash_warning
)
2814 hash
= ((struct elf32_hppa_link_hash_entry
*)
2815 hash
->elf
.root
.u
.i
.link
);
2817 /* At this point in the link, undefined syms have been
2818 resolved, so we need to check that the symbol was
2819 defined in this BFD. */
2820 if ((hash
->elf
.root
.type
== bfd_link_hash_defined
2821 || hash
->elf
.root
.type
== bfd_link_hash_defweak
)
2822 && hash
->elf
.type
== STT_FUNC
2823 && hash
->elf
.root
.u
.def
.section
->output_section
!= NULL
2824 && (hash
->elf
.root
.u
.def
.section
->output_section
->owner
2826 && hash
->elf
.root
.u
.def
.section
->owner
== input_bfd
2827 && (hash
->elf
.elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)
2828 && !(hash
->elf
.elf_link_hash_flags
& ELF_LINK_FORCED_LOCAL
)
2829 && ELF_ST_VISIBILITY (hash
->elf
.other
) == STV_DEFAULT
)
2832 const char *stub_name
;
2833 struct elf32_hppa_stub_hash_entry
*stub_entry
;
2835 sec
= hash
->elf
.root
.u
.def
.section
;
2836 stub_name
= hash
->elf
.root
.root
.string
;
2837 stub_entry
= hppa_stub_hash_lookup (&htab
->stub_hash_table
,
2840 if (stub_entry
== NULL
)
2842 stub_entry
= hppa_add_stub (stub_name
, sec
, htab
);
2844 goto error_ret_free_local
;
2846 stub_entry
->target_value
= hash
->elf
.root
.u
.def
.value
;
2847 stub_entry
->target_section
= hash
->elf
.root
.u
.def
.section
;
2848 stub_entry
->stub_type
= hppa_stub_export
;
2849 stub_entry
->h
= hash
;
2854 (*_bfd_error_handler
) (_("%s: duplicate export stub %s"),
2855 bfd_archive_filename (input_bfd
),
2867 for (input_bfd
= info
->input_bfds
, bfd_indx
= 0;
2869 input_bfd
= input_bfd
->link_next
, bfd_indx
++)
2871 Elf_Internal_Shdr
*symtab_hdr
;
2873 /* We'll need the symbol table in a second. */
2874 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2875 if (symtab_hdr
->sh_info
== 0)
2878 local_syms
= all_local_syms
[bfd_indx
];
2880 /* Walk over each section attached to the input bfd. */
2881 for (section
= input_bfd
->sections
;
2883 section
= section
->next
)
2885 Elf_Internal_Shdr
*input_rel_hdr
;
2886 Elf32_External_Rela
*external_relocs
, *erelaend
, *erela
;
2887 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
2889 /* If there aren't any relocs, then there's nothing more
2891 if ((section
->flags
& SEC_RELOC
) == 0
2892 || section
->reloc_count
== 0)
2895 /* If this section is a link-once section that will be
2896 discarded, then don't create any stubs. */
2897 if (section
->output_section
== NULL
2898 || section
->output_section
->owner
!= output_bfd
)
2901 /* Allocate space for the external relocations. */
2902 amt
= section
->reloc_count
;
2903 amt
*= sizeof (Elf32_External_Rela
);
2904 external_relocs
= (Elf32_External_Rela
*) bfd_malloc (amt
);
2905 if (external_relocs
== NULL
)
2907 goto error_ret_free_local
;
2910 /* Likewise for the internal relocations. */
2911 amt
= section
->reloc_count
;
2912 amt
*= sizeof (Elf_Internal_Rela
);
2913 internal_relocs
= (Elf_Internal_Rela
*) bfd_malloc (amt
);
2914 if (internal_relocs
== NULL
)
2916 free (external_relocs
);
2917 goto error_ret_free_local
;
2920 /* Read in the external relocs. */
2921 input_rel_hdr
= &elf_section_data (section
)->rel_hdr
;
2922 if (bfd_seek (input_bfd
, input_rel_hdr
->sh_offset
, SEEK_SET
) != 0
2923 || bfd_bread (external_relocs
,
2924 input_rel_hdr
->sh_size
,
2925 input_bfd
) != input_rel_hdr
->sh_size
)
2927 free (external_relocs
);
2928 error_ret_free_internal
:
2929 free (internal_relocs
);
2930 goto error_ret_free_local
;
2933 /* Swap in the relocs. */
2934 erela
= external_relocs
;
2935 erelaend
= erela
+ section
->reloc_count
;
2936 irela
= internal_relocs
;
2937 for (; erela
< erelaend
; erela
++, irela
++)
2938 bfd_elf32_swap_reloca_in (input_bfd
, erela
, irela
);
2940 /* We're done with the external relocs, free them. */
2941 free (external_relocs
);
2943 /* Now examine each relocation. */
2944 irela
= internal_relocs
;
2945 irelaend
= irela
+ section
->reloc_count
;
2946 for (; irela
< irelaend
; irela
++)
2948 unsigned int r_type
, r_indx
;
2949 enum elf32_hppa_stub_type stub_type
;
2950 struct elf32_hppa_stub_hash_entry
*stub_entry
;
2953 bfd_vma destination
;
2954 struct elf32_hppa_link_hash_entry
*hash
;
2956 const asection
*id_sec
;
2958 r_type
= ELF32_R_TYPE (irela
->r_info
);
2959 r_indx
= ELF32_R_SYM (irela
->r_info
);
2961 if (r_type
>= (unsigned int) R_PARISC_UNIMPLEMENTED
)
2963 bfd_set_error (bfd_error_bad_value
);
2964 goto error_ret_free_internal
;
2967 /* Only look for stubs on call instructions. */
2968 if (r_type
!= (unsigned int) R_PARISC_PCREL12F
2969 && r_type
!= (unsigned int) R_PARISC_PCREL17F
2970 && r_type
!= (unsigned int) R_PARISC_PCREL22F
)
2973 /* Now determine the call target, its name, value,
2979 if (r_indx
< symtab_hdr
->sh_info
)
2981 /* It's a local symbol. */
2982 Elf_Internal_Sym
*sym
;
2983 Elf_Internal_Shdr
*hdr
;
2985 sym
= local_syms
+ r_indx
;
2986 hdr
= elf_elfsections (input_bfd
)[sym
->st_shndx
];
2987 sym_sec
= hdr
->bfd_section
;
2988 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
2989 sym_value
= sym
->st_value
;
2990 destination
= (sym_value
+ irela
->r_addend
2991 + sym_sec
->output_offset
2992 + sym_sec
->output_section
->vma
);
2996 /* It's an external symbol. */
2999 e_indx
= r_indx
- symtab_hdr
->sh_info
;
3000 hash
= ((struct elf32_hppa_link_hash_entry
*)
3001 elf_sym_hashes (input_bfd
)[e_indx
]);
3003 while (hash
->elf
.root
.type
== bfd_link_hash_indirect
3004 || hash
->elf
.root
.type
== bfd_link_hash_warning
)
3005 hash
= ((struct elf32_hppa_link_hash_entry
*)
3006 hash
->elf
.root
.u
.i
.link
);
3008 if (hash
->elf
.root
.type
== bfd_link_hash_defined
3009 || hash
->elf
.root
.type
== bfd_link_hash_defweak
)
3011 sym_sec
= hash
->elf
.root
.u
.def
.section
;
3012 sym_value
= hash
->elf
.root
.u
.def
.value
;
3013 if (sym_sec
->output_section
!= NULL
)
3014 destination
= (sym_value
+ irela
->r_addend
3015 + sym_sec
->output_offset
3016 + sym_sec
->output_section
->vma
);
3018 else if (hash
->elf
.root
.type
== bfd_link_hash_undefweak
)
3023 else if (hash
->elf
.root
.type
== bfd_link_hash_undefined
)
3026 && !info
->no_undefined
3027 && (ELF_ST_VISIBILITY (hash
->elf
.other
)
3029 && hash
->elf
.type
!= STT_PARISC_MILLI
))
3034 bfd_set_error (bfd_error_bad_value
);
3035 goto error_ret_free_internal
;
3039 /* Determine what (if any) linker stub is needed. */
3040 stub_type
= hppa_type_of_stub (section
, irela
, hash
,
3042 if (stub_type
== hppa_stub_none
)
3045 /* Support for grouping stub sections. */
3046 id_sec
= htab
->stub_group
[section
->id
].link_sec
;
3048 /* Get the name of this stub. */
3049 stub_name
= hppa_stub_name (id_sec
, sym_sec
, hash
, irela
);
3051 goto error_ret_free_internal
;
3053 stub_entry
= hppa_stub_hash_lookup (&htab
->stub_hash_table
,
3056 if (stub_entry
!= NULL
)
3058 /* The proper stub has already been created. */
3063 stub_entry
= hppa_add_stub (stub_name
, section
, htab
);
3064 if (stub_entry
== NULL
)
3067 goto error_ret_free_local
;
3070 stub_entry
->target_value
= sym_value
;
3071 stub_entry
->target_section
= sym_sec
;
3072 stub_entry
->stub_type
= stub_type
;
3075 if (stub_type
== hppa_stub_import
)
3076 stub_entry
->stub_type
= hppa_stub_import_shared
;
3077 else if (stub_type
== hppa_stub_long_branch
)
3078 stub_entry
->stub_type
= hppa_stub_long_branch_shared
;
3080 stub_entry
->h
= hash
;
3084 /* We're done with the internal relocs, free them. */
3085 free (internal_relocs
);
3092 /* OK, we've added some stubs. Find out the new size of the
3094 for (stub_sec
= htab
->stub_bfd
->sections
;
3096 stub_sec
= stub_sec
->next
)
3098 stub_sec
->_raw_size
= 0;
3099 stub_sec
->_cooked_size
= 0;
3102 bfd_hash_traverse (&htab
->stub_hash_table
, hppa_size_one_stub
, htab
);
3104 /* Ask the linker to do its stuff. */
3105 (*htab
->layout_sections_again
) ();
3111 error_ret_free_local
:
3112 while (bfd_count
-- > 0)
3113 if (all_local_syms
[bfd_count
])
3114 free (all_local_syms
[bfd_count
]);
3115 free (all_local_syms
);
3120 /* For a final link, this function is called after we have sized the
3121 stubs to provide a value for __gp. */
3124 elf32_hppa_set_gp (abfd
, info
)
3126 struct bfd_link_info
*info
;
3128 struct elf32_hppa_link_hash_table
*htab
;
3129 struct elf_link_hash_entry
*h
;
3133 htab
= hppa_link_hash_table (info
);
3134 h
= elf_link_hash_lookup (&htab
->elf
, "$global$", false, false, false);
3137 && (h
->root
.type
== bfd_link_hash_defined
3138 || h
->root
.type
== bfd_link_hash_defweak
))
3140 gp_val
= h
->root
.u
.def
.value
;
3141 sec
= h
->root
.u
.def
.section
;
3145 /* Choose to point our LTP at, in this order, one of .plt, .got,
3146 or .data, if these sections exist. In the case of choosing
3147 .plt try to make the LTP ideal for addressing anywhere in the
3148 .plt or .got with a 14 bit signed offset. Typically, the end
3149 of the .plt is the start of the .got, so choose .plt + 0x2000
3150 if either the .plt or .got is larger than 0x2000. If both
3151 the .plt and .got are smaller than 0x2000, choose the end of
3152 the .plt section. */
3157 gp_val
= sec
->_raw_size
;
3159 || (htab
->sgot
&& htab
->sgot
->_raw_size
> 0x2000))
3170 /* We know we don't have a .plt. If .got is large,
3172 if (sec
->_raw_size
> 0x2000)
3177 /* No .plt or .got. Who cares what the LTP is? */
3178 sec
= bfd_get_section_by_name (abfd
, ".data");
3184 h
->root
.type
= bfd_link_hash_defined
;
3185 h
->root
.u
.def
.value
= gp_val
;
3187 h
->root
.u
.def
.section
= sec
;
3189 h
->root
.u
.def
.section
= bfd_abs_section_ptr
;
3193 if (sec
!= NULL
&& sec
->output_section
!= NULL
)
3194 gp_val
+= sec
->output_section
->vma
+ sec
->output_offset
;
3196 elf_gp (abfd
) = gp_val
;
3200 /* Build all the stubs associated with the current output file. The
3201 stubs are kept in a hash table attached to the main linker hash
3202 table. We also set up the .plt entries for statically linked PIC
3203 functions here. This function is called via hppaelf_finish in the
3207 elf32_hppa_build_stubs (info
)
3208 struct bfd_link_info
*info
;
3211 struct bfd_hash_table
*table
;
3212 struct elf32_hppa_link_hash_table
*htab
;
3214 htab
= hppa_link_hash_table (info
);
3216 for (stub_sec
= htab
->stub_bfd
->sections
;
3218 stub_sec
= stub_sec
->next
)
3222 /* Allocate memory to hold the linker stubs. */
3223 size
= stub_sec
->_raw_size
;
3224 stub_sec
->contents
= (unsigned char *) bfd_zalloc (htab
->stub_bfd
, size
);
3225 if (stub_sec
->contents
== NULL
&& size
!= 0)
3227 stub_sec
->_raw_size
= 0;
3230 /* Build the stubs as directed by the stub hash table. */
3231 table
= &htab
->stub_hash_table
;
3232 bfd_hash_traverse (table
, hppa_build_one_stub
, info
);
3237 /* Perform a final link. */
3240 elf32_hppa_final_link (abfd
, info
)
3242 struct bfd_link_info
*info
;
3246 /* Invoke the regular ELF linker to do all the work. */
3247 if (!bfd_elf32_bfd_final_link (abfd
, info
))
3250 /* If we're producing a final executable, sort the contents of the
3251 unwind section. Magic section names, but this is much safer than
3252 having elf32_hppa_relocate_section remember where SEGREL32 relocs
3253 occurred. Consider what happens if someone inept creates a
3254 linker script that puts unwind information in .text. */
3255 s
= bfd_get_section_by_name (abfd
, ".PARISC.unwind");
3261 size
= s
->_raw_size
;
3262 contents
= bfd_malloc (size
);
3263 if (contents
== NULL
)
3266 if (! bfd_get_section_contents (abfd
, s
, contents
, (file_ptr
) 0, size
))
3269 qsort (contents
, (size_t) (size
/ 16), 16, hppa_unwind_entry_compare
);
3271 if (! bfd_set_section_contents (abfd
, s
, contents
, (file_ptr
) 0, size
))
3277 /* Record the lowest address for the data and text segments. */
3280 hppa_record_segment_addr (abfd
, section
, data
)
3281 bfd
*abfd ATTRIBUTE_UNUSED
;
3285 struct elf32_hppa_link_hash_table
*htab
;
3287 htab
= (struct elf32_hppa_link_hash_table
*) data
;
3289 if ((section
->flags
& (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
3291 bfd_vma value
= section
->vma
- section
->filepos
;
3293 if ((section
->flags
& SEC_READONLY
) != 0)
3295 if (value
< htab
->text_segment_base
)
3296 htab
->text_segment_base
= value
;
3300 if (value
< htab
->data_segment_base
)
3301 htab
->data_segment_base
= value
;
3306 /* Perform a relocation as part of a final link. */
3308 static bfd_reloc_status_type
3309 final_link_relocate (input_section
, contents
, rel
, value
, htab
, sym_sec
, h
)
3310 asection
*input_section
;
3312 const Elf_Internal_Rela
*rel
;
3314 struct elf32_hppa_link_hash_table
*htab
;
3316 struct elf32_hppa_link_hash_entry
*h
;
3319 unsigned int r_type
= ELF32_R_TYPE (rel
->r_info
);
3320 reloc_howto_type
*howto
= elf_hppa_howto_table
+ r_type
;
3321 int r_format
= howto
->bitsize
;
3322 enum hppa_reloc_field_selector_type_alt r_field
;
3323 bfd
*input_bfd
= input_section
->owner
;
3324 bfd_vma offset
= rel
->r_offset
;
3325 bfd_vma max_branch_offset
= 0;
3326 bfd_byte
*hit_data
= contents
+ offset
;
3327 bfd_signed_vma addend
= rel
->r_addend
;
3329 struct elf32_hppa_stub_hash_entry
*stub_entry
= NULL
;
3332 if (r_type
== R_PARISC_NONE
)
3333 return bfd_reloc_ok
;
3335 insn
= bfd_get_32 (input_bfd
, hit_data
);
3337 /* Find out where we are and where we're going. */
3338 location
= (offset
+
3339 input_section
->output_offset
+
3340 input_section
->output_section
->vma
);
3344 case R_PARISC_PCREL12F
:
3345 case R_PARISC_PCREL17F
:
3346 case R_PARISC_PCREL22F
:
3347 /* If this is a call to a function defined in another dynamic
3348 library, or if it is a call to a PIC function in the same
3349 object, or if this is a shared link and it is a call to a
3350 weak symbol which may or may not be in the same object, then
3351 find the import stub in the stub hash. */
3353 || sym_sec
->output_section
== NULL
3355 && ((h
->maybe_pic_call
3356 && !(input_section
->flags
& SEC_HAS_GOT_REF
))
3357 || (h
->elf
.root
.type
== bfd_link_hash_defweak
3358 && h
->elf
.dynindx
!= -1
3359 && h
->elf
.plt
.offset
!= (bfd_vma
) -1))))
3361 stub_entry
= hppa_get_stub_entry (input_section
, sym_sec
,
3363 if (stub_entry
!= NULL
)
3365 value
= (stub_entry
->stub_offset
3366 + stub_entry
->stub_sec
->output_offset
3367 + stub_entry
->stub_sec
->output_section
->vma
);
3370 else if (sym_sec
== NULL
&& h
!= NULL
3371 && h
->elf
.root
.type
== bfd_link_hash_undefweak
)
3373 /* It's OK if undefined weak. Calls to undefined weak
3374 symbols behave as if the "called" function
3375 immediately returns. We can thus call to a weak
3376 function without first checking whether the function
3382 return bfd_reloc_notsupported
;
3386 case R_PARISC_PCREL21L
:
3387 case R_PARISC_PCREL17C
:
3388 case R_PARISC_PCREL17R
:
3389 case R_PARISC_PCREL14R
:
3390 case R_PARISC_PCREL14F
:
3391 /* Make it a pc relative offset. */
3396 case R_PARISC_DPREL21L
:
3397 case R_PARISC_DPREL14R
:
3398 case R_PARISC_DPREL14F
:
3399 /* For all the DP relative relocations, we need to examine the symbol's
3400 section. If it's a code section, then "data pointer relative" makes
3401 no sense. In that case we don't adjust the "value", and for 21 bit
3402 addil instructions, we change the source addend register from %dp to
3403 %r0. This situation commonly arises when a variable's "constness"
3404 is declared differently from the way the variable is defined. For
3405 instance: "extern int foo" with foo defined as "const int foo". */
3406 if (sym_sec
== NULL
)
3408 if ((sym_sec
->flags
& SEC_CODE
) != 0)
3410 if ((insn
& ((0x3f << 26) | (0x1f << 21)))
3411 == (((int) OP_ADDIL
<< 26) | (27 << 21)))
3413 insn
&= ~ (0x1f << 21);
3414 #if 1 /* debug them. */
3415 (*_bfd_error_handler
)
3416 (_("%s(%s+0x%lx): fixing %s"),
3417 bfd_archive_filename (input_bfd
),
3418 input_section
->name
,
3419 (long) rel
->r_offset
,
3423 /* Now try to make things easy for the dynamic linker. */
3429 case R_PARISC_DLTIND21L
:
3430 case R_PARISC_DLTIND14R
:
3431 case R_PARISC_DLTIND14F
:
3432 value
-= elf_gp (input_section
->output_section
->owner
);
3435 case R_PARISC_SEGREL32
:
3436 if ((sym_sec
->flags
& SEC_CODE
) != 0)
3437 value
-= htab
->text_segment_base
;
3439 value
-= htab
->data_segment_base
;
3448 case R_PARISC_DIR32
:
3449 case R_PARISC_DIR14F
:
3450 case R_PARISC_DIR17F
:
3451 case R_PARISC_PCREL17C
:
3452 case R_PARISC_PCREL14F
:
3453 case R_PARISC_DPREL14F
:
3454 case R_PARISC_PLABEL32
:
3455 case R_PARISC_DLTIND14F
:
3456 case R_PARISC_SEGBASE
:
3457 case R_PARISC_SEGREL32
:
3461 case R_PARISC_DIR21L
:
3462 case R_PARISC_PCREL21L
:
3463 case R_PARISC_DPREL21L
:
3464 case R_PARISC_PLABEL21L
:
3465 case R_PARISC_DLTIND21L
:
3469 case R_PARISC_DIR17R
:
3470 case R_PARISC_PCREL17R
:
3471 case R_PARISC_DIR14R
:
3472 case R_PARISC_PCREL14R
:
3473 case R_PARISC_DPREL14R
:
3474 case R_PARISC_PLABEL14R
:
3475 case R_PARISC_DLTIND14R
:
3479 case R_PARISC_PCREL12F
:
3480 case R_PARISC_PCREL17F
:
3481 case R_PARISC_PCREL22F
:
3484 if (r_type
== (unsigned int) R_PARISC_PCREL17F
)
3486 max_branch_offset
= (1 << (17-1)) << 2;
3488 else if (r_type
== (unsigned int) R_PARISC_PCREL12F
)
3490 max_branch_offset
= (1 << (12-1)) << 2;
3494 max_branch_offset
= (1 << (22-1)) << 2;
3497 /* sym_sec is NULL on undefined weak syms or when shared on
3498 undefined syms. We've already checked for a stub for the
3499 shared undefined case. */
3500 if (sym_sec
== NULL
)
3503 /* If the branch is out of reach, then redirect the
3504 call to the local stub for this function. */
3505 if (value
+ addend
+ max_branch_offset
>= 2*max_branch_offset
)
3507 stub_entry
= hppa_get_stub_entry (input_section
, sym_sec
,
3509 if (stub_entry
== NULL
)
3510 return bfd_reloc_notsupported
;
3512 /* Munge up the value and addend so that we call the stub
3513 rather than the procedure directly. */
3514 value
= (stub_entry
->stub_offset
3515 + stub_entry
->stub_sec
->output_offset
3516 + stub_entry
->stub_sec
->output_section
->vma
3522 /* Something we don't know how to handle. */
3524 return bfd_reloc_notsupported
;
3527 /* Make sure we can reach the stub. */
3528 if (max_branch_offset
!= 0
3529 && value
+ addend
+ max_branch_offset
>= 2*max_branch_offset
)
3531 (*_bfd_error_handler
)
3532 (_("%s(%s+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
3533 bfd_archive_filename (input_bfd
),
3534 input_section
->name
,
3535 (long) rel
->r_offset
,
3536 stub_entry
->root
.string
);
3537 bfd_set_error (bfd_error_bad_value
);
3538 return bfd_reloc_notsupported
;
3541 val
= hppa_field_adjust (value
, addend
, r_field
);
3545 case R_PARISC_PCREL12F
:
3546 case R_PARISC_PCREL17C
:
3547 case R_PARISC_PCREL17F
:
3548 case R_PARISC_PCREL17R
:
3549 case R_PARISC_PCREL22F
:
3550 case R_PARISC_DIR17F
:
3551 case R_PARISC_DIR17R
:
3552 /* This is a branch. Divide the offset by four.
3553 Note that we need to decide whether it's a branch or
3554 otherwise by inspecting the reloc. Inspecting insn won't
3555 work as insn might be from a .word directive. */
3563 insn
= hppa_rebuild_insn (insn
, val
, r_format
);
3565 /* Update the instruction word. */
3566 bfd_put_32 (input_bfd
, (bfd_vma
) insn
, hit_data
);
3567 return bfd_reloc_ok
;
3570 /* Relocate an HPPA ELF section. */
3573 elf32_hppa_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
3574 contents
, relocs
, local_syms
, local_sections
)
3576 struct bfd_link_info
*info
;
3578 asection
*input_section
;
3580 Elf_Internal_Rela
*relocs
;
3581 Elf_Internal_Sym
*local_syms
;
3582 asection
**local_sections
;
3584 bfd_vma
*local_got_offsets
;
3585 struct elf32_hppa_link_hash_table
*htab
;
3586 Elf_Internal_Shdr
*symtab_hdr
;
3587 Elf_Internal_Rela
*rel
;
3588 Elf_Internal_Rela
*relend
;
3590 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3592 htab
= hppa_link_hash_table (info
);
3593 local_got_offsets
= elf_local_got_offsets (input_bfd
);
3596 relend
= relocs
+ input_section
->reloc_count
;
3597 for (; rel
< relend
; rel
++)
3599 unsigned int r_type
;
3600 reloc_howto_type
*howto
;
3601 unsigned int r_symndx
;
3602 struct elf32_hppa_link_hash_entry
*h
;
3603 Elf_Internal_Sym
*sym
;
3606 bfd_reloc_status_type r
;
3607 const char *sym_name
;
3610 r_type
= ELF32_R_TYPE (rel
->r_info
);
3611 if (r_type
>= (unsigned int) R_PARISC_UNIMPLEMENTED
)
3613 bfd_set_error (bfd_error_bad_value
);
3616 if (r_type
== (unsigned int) R_PARISC_GNU_VTENTRY
3617 || r_type
== (unsigned int) R_PARISC_GNU_VTINHERIT
)
3620 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3622 if (info
->relocateable
)
3624 /* This is a relocatable link. We don't have to change
3625 anything, unless the reloc is against a section symbol,
3626 in which case we have to adjust according to where the
3627 section symbol winds up in the output section. */
3628 if (r_symndx
< symtab_hdr
->sh_info
)
3630 sym
= local_syms
+ r_symndx
;
3631 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3633 sym_sec
= local_sections
[r_symndx
];
3634 rel
->r_addend
+= sym_sec
->output_offset
;
3640 /* This is a final link. */
3644 if (r_symndx
< symtab_hdr
->sh_info
)
3646 /* This is a local symbol, h defaults to NULL. */
3647 sym
= local_syms
+ r_symndx
;
3648 sym_sec
= local_sections
[r_symndx
];
3649 relocation
= ((ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3650 ? 0 : sym
->st_value
)
3651 + sym_sec
->output_offset
3652 + sym_sec
->output_section
->vma
);
3658 /* It's a global; Find its entry in the link hash. */
3659 indx
= r_symndx
- symtab_hdr
->sh_info
;
3660 h
= ((struct elf32_hppa_link_hash_entry
*)
3661 elf_sym_hashes (input_bfd
)[indx
]);
3662 while (h
->elf
.root
.type
== bfd_link_hash_indirect
3663 || h
->elf
.root
.type
== bfd_link_hash_warning
)
3664 h
= (struct elf32_hppa_link_hash_entry
*) h
->elf
.root
.u
.i
.link
;
3667 if (h
->elf
.root
.type
== bfd_link_hash_defined
3668 || h
->elf
.root
.type
== bfd_link_hash_defweak
)
3670 sym_sec
= h
->elf
.root
.u
.def
.section
;
3671 /* If sym_sec->output_section is NULL, then it's a
3672 symbol defined in a shared library. */
3673 if (sym_sec
->output_section
!= NULL
)
3674 relocation
= (h
->elf
.root
.u
.def
.value
3675 + sym_sec
->output_offset
3676 + sym_sec
->output_section
->vma
);
3678 else if (h
->elf
.root
.type
== bfd_link_hash_undefweak
)
3680 else if (info
->shared
&& !info
->no_undefined
3681 && ELF_ST_VISIBILITY (h
->elf
.other
) == STV_DEFAULT
3682 && h
->elf
.type
!= STT_PARISC_MILLI
)
3684 if (info
->symbolic
&& !info
->allow_shlib_undefined
)
3685 if (!((*info
->callbacks
->undefined_symbol
)
3686 (info
, h
->elf
.root
.root
.string
, input_bfd
,
3687 input_section
, rel
->r_offset
, false)))
3692 if (!((*info
->callbacks
->undefined_symbol
)
3693 (info
, h
->elf
.root
.root
.string
, input_bfd
,
3694 input_section
, rel
->r_offset
, true)))
3699 /* Do any required modifications to the relocation value, and
3700 determine what types of dynamic info we need to output, if
3705 case R_PARISC_DLTIND14F
:
3706 case R_PARISC_DLTIND14R
:
3707 case R_PARISC_DLTIND21L
:
3712 /* Relocation is to the entry for this symbol in the
3713 global offset table. */
3718 off
= h
->elf
.got
.offset
;
3719 dyn
= htab
->elf
.dynamic_sections_created
;
3720 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
, &h
->elf
))
3722 /* If we aren't going to call finish_dynamic_symbol,
3723 then we need to handle initialisation of the .got
3724 entry and create needed relocs here. Since the
3725 offset must always be a multiple of 4, we use the
3726 least significant bit to record whether we have
3727 initialised it already. */
3732 h
->elf
.got
.offset
|= 1;
3739 /* Local symbol case. */
3740 if (local_got_offsets
== NULL
)
3743 off
= local_got_offsets
[r_symndx
];
3745 /* The offset must always be a multiple of 4. We use
3746 the least significant bit to record whether we have
3747 already generated the necessary reloc. */
3752 local_got_offsets
[r_symndx
] |= 1;
3761 /* Output a dynamic relocation for this GOT entry.
3762 In this case it is relative to the base of the
3763 object because the symbol index is zero. */
3764 Elf_Internal_Rela outrel
;
3765 asection
*srelgot
= htab
->srelgot
;
3766 Elf32_External_Rela
*loc
;
3768 outrel
.r_offset
= (off
3769 + htab
->sgot
->output_offset
3770 + htab
->sgot
->output_section
->vma
);
3771 outrel
.r_info
= ELF32_R_INFO (0, R_PARISC_DIR32
);
3772 outrel
.r_addend
= relocation
;
3773 loc
= (Elf32_External_Rela
*) srelgot
->contents
;
3774 loc
+= srelgot
->reloc_count
++;
3775 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
3778 bfd_put_32 (output_bfd
, relocation
,
3779 htab
->sgot
->contents
+ off
);
3782 if (off
>= (bfd_vma
) -2)
3785 /* Add the base of the GOT to the relocation value. */
3787 + htab
->sgot
->output_offset
3788 + htab
->sgot
->output_section
->vma
);
3792 case R_PARISC_SEGREL32
:
3793 /* If this is the first SEGREL relocation, then initialize
3794 the segment base values. */
3795 if (htab
->text_segment_base
== (bfd_vma
) -1)
3796 bfd_map_over_sections (output_bfd
, hppa_record_segment_addr
, htab
);
3799 case R_PARISC_PLABEL14R
:
3800 case R_PARISC_PLABEL21L
:
3801 case R_PARISC_PLABEL32
:
3802 if (htab
->elf
.dynamic_sections_created
)
3807 /* If we have a global symbol with a PLT slot, then
3808 redirect this relocation to it. */
3811 off
= h
->elf
.plt
.offset
;
3812 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info
, &h
->elf
))
3814 /* In a non-shared link, adjust_dynamic_symbols
3815 isn't called for symbols forced local. We
3816 need to write out the plt entry here. */
3821 h
->elf
.plt
.offset
|= 1;
3828 bfd_vma
*local_plt_offsets
;
3830 if (local_got_offsets
== NULL
)
3833 local_plt_offsets
= local_got_offsets
+ symtab_hdr
->sh_info
;
3834 off
= local_plt_offsets
[r_symndx
];
3836 /* As for the local .got entry case, we use the last
3837 bit to record whether we've already initialised
3838 this local .plt entry. */
3843 local_plt_offsets
[r_symndx
] |= 1;
3852 /* Output a dynamic IPLT relocation for this
3854 Elf_Internal_Rela outrel
;
3855 asection
*srelplt
= htab
->srelplt
;
3856 Elf32_External_Rela
*loc
;
3858 outrel
.r_offset
= (off
3859 + htab
->splt
->output_offset
3860 + htab
->splt
->output_section
->vma
);
3861 outrel
.r_info
= ELF32_R_INFO (0, R_PARISC_IPLT
);
3862 outrel
.r_addend
= relocation
;
3863 loc
= (Elf32_External_Rela
*) srelplt
->contents
;
3864 loc
+= srelplt
->reloc_count
++;
3865 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
3869 bfd_put_32 (output_bfd
,
3871 htab
->splt
->contents
+ off
);
3872 bfd_put_32 (output_bfd
,
3873 elf_gp (htab
->splt
->output_section
->owner
),
3874 htab
->splt
->contents
+ off
+ 4);
3878 if (off
>= (bfd_vma
) -2)
3881 /* PLABELs contain function pointers. Relocation is to
3882 the entry for the function in the .plt. The magic +2
3883 offset signals to $$dyncall that the function pointer
3884 is in the .plt and thus has a gp pointer too.
3885 Exception: Undefined PLABELs should have a value of
3888 || (h
->elf
.root
.type
!= bfd_link_hash_undefweak
3889 && h
->elf
.root
.type
!= bfd_link_hash_undefined
))
3892 + htab
->splt
->output_offset
3893 + htab
->splt
->output_section
->vma
3898 /* Fall through and possibly emit a dynamic relocation. */
3900 case R_PARISC_DIR17F
:
3901 case R_PARISC_DIR17R
:
3902 case R_PARISC_DIR14F
:
3903 case R_PARISC_DIR14R
:
3904 case R_PARISC_DIR21L
:
3905 case R_PARISC_DPREL14F
:
3906 case R_PARISC_DPREL14R
:
3907 case R_PARISC_DPREL21L
:
3908 case R_PARISC_DIR32
:
3909 /* r_symndx will be zero only for relocs against symbols
3910 from removed linkonce sections, or sections discarded by
3913 || (input_section
->flags
& SEC_ALLOC
) == 0)
3916 /* The reloc types handled here and this conditional
3917 expression must match the code in ..check_relocs and
3918 allocate_dynrelocs. ie. We need exactly the same condition
3919 as in ..check_relocs, with some extra conditions (dynindx
3920 test in this case) to cater for relocs removed by
3921 allocate_dynrelocs. If you squint, the non-shared test
3922 here does indeed match the one in ..check_relocs, the
3923 difference being that here we test DEF_DYNAMIC as well as
3924 !DEF_REGULAR. All common syms end up with !DEF_REGULAR,
3925 which is why we can't use just that test here.
3926 Conversely, DEF_DYNAMIC can't be used in check_relocs as
3927 there all files have not been loaded. */
3929 && (IS_ABSOLUTE_RELOC (r_type
)
3931 && h
->elf
.dynindx
!= -1
3933 || (h
->elf
.elf_link_hash_flags
3934 & ELF_LINK_HASH_DEF_REGULAR
) == 0))))
3937 && h
->elf
.dynindx
!= -1
3938 && (h
->elf
.elf_link_hash_flags
& ELF_LINK_NON_GOT_REF
) == 0
3939 && (((h
->elf
.elf_link_hash_flags
3940 & ELF_LINK_HASH_DEF_DYNAMIC
) != 0
3941 && (h
->elf
.elf_link_hash_flags
3942 & ELF_LINK_HASH_DEF_REGULAR
) == 0)
3943 || h
->elf
.root
.type
== bfd_link_hash_undefweak
3944 || h
->elf
.root
.type
== bfd_link_hash_undefined
)))
3946 Elf_Internal_Rela outrel
;
3949 Elf32_External_Rela
*loc
;
3951 /* When generating a shared object, these relocations
3952 are copied into the output file to be resolved at run
3955 outrel
.r_offset
= rel
->r_offset
;
3956 outrel
.r_addend
= rel
->r_addend
;
3958 if (elf_section_data (input_section
)->stab_info
!= NULL
)
3962 off
= (_bfd_stab_section_offset
3963 (output_bfd
, &htab
->elf
.stab_info
,
3965 &elf_section_data (input_section
)->stab_info
,
3967 if (off
== (bfd_vma
) -1)
3969 outrel
.r_offset
= off
;
3972 outrel
.r_offset
+= (input_section
->output_offset
3973 + input_section
->output_section
->vma
);
3977 memset (&outrel
, 0, sizeof (outrel
));
3980 && h
->elf
.dynindx
!= -1
3982 || !IS_ABSOLUTE_RELOC (r_type
)
3985 || (h
->elf
.elf_link_hash_flags
3986 & ELF_LINK_HASH_DEF_REGULAR
) == 0))
3988 outrel
.r_info
= ELF32_R_INFO (h
->elf
.dynindx
, r_type
);
3990 else /* It's a local symbol, or one marked to become local. */
3994 /* Add the absolute offset of the symbol. */
3995 outrel
.r_addend
+= relocation
;
3997 /* Global plabels need to be processed by the
3998 dynamic linker so that functions have at most one
3999 fptr. For this reason, we need to differentiate
4000 between global and local plabels, which we do by
4001 providing the function symbol for a global plabel
4002 reloc, and no symbol for local plabels. */
4005 && sym_sec
->output_section
!= NULL
4006 && ! bfd_is_abs_section (sym_sec
))
4008 indx
= elf_section_data (sym_sec
->output_section
)->dynindx
;
4009 /* We are turning this relocation into one
4010 against a section symbol, so subtract out the
4011 output section's address but not the offset
4012 of the input section in the output section. */
4013 outrel
.r_addend
-= sym_sec
->output_section
->vma
;
4016 outrel
.r_info
= ELF32_R_INFO (indx
, r_type
);
4019 /* EH info can cause unaligned DIR32 relocs.
4020 Tweak the reloc type for the dynamic linker. */
4021 if (r_type
== R_PARISC_DIR32
&& (outrel
.r_offset
& 3) != 0)
4022 outrel
.r_info
= ELF32_R_INFO (ELF32_R_SYM (outrel
.r_info
),
4025 sreloc
= elf_section_data (input_section
)->sreloc
;
4029 loc
= (Elf32_External_Rela
*) sreloc
->contents
;
4030 loc
+= sreloc
->reloc_count
++;
4031 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4039 r
= final_link_relocate (input_section
, contents
, rel
, relocation
,
4042 if (r
== bfd_reloc_ok
)
4046 sym_name
= h
->elf
.root
.root
.string
;
4049 sym_name
= bfd_elf_string_from_elf_section (input_bfd
,
4050 symtab_hdr
->sh_link
,
4052 if (sym_name
== NULL
)
4054 if (*sym_name
== '\0')
4055 sym_name
= bfd_section_name (input_bfd
, sym_sec
);
4058 howto
= elf_hppa_howto_table
+ r_type
;
4060 if (r
== bfd_reloc_undefined
|| r
== bfd_reloc_notsupported
)
4062 (*_bfd_error_handler
)
4063 (_("%s(%s+0x%lx): cannot handle %s for %s"),
4064 bfd_archive_filename (input_bfd
),
4065 input_section
->name
,
4066 (long) rel
->r_offset
,
4069 bfd_set_error (bfd_error_bad_value
);
4074 if (!((*info
->callbacks
->reloc_overflow
)
4075 (info
, sym_name
, howto
->name
, (bfd_vma
) 0,
4076 input_bfd
, input_section
, rel
->r_offset
)))
4084 /* Comparison function for qsort to sort unwind section during a
4088 hppa_unwind_entry_compare (a
, b
)
4092 const bfd_byte
*ap
, *bp
;
4093 unsigned long av
, bv
;
4095 ap
= (const bfd_byte
*) a
;
4096 av
= (unsigned long) ap
[0] << 24;
4097 av
|= (unsigned long) ap
[1] << 16;
4098 av
|= (unsigned long) ap
[2] << 8;
4099 av
|= (unsigned long) ap
[3];
4101 bp
= (const bfd_byte
*) b
;
4102 bv
= (unsigned long) bp
[0] << 24;
4103 bv
|= (unsigned long) bp
[1] << 16;
4104 bv
|= (unsigned long) bp
[2] << 8;
4105 bv
|= (unsigned long) bp
[3];
4107 return av
< bv
? -1 : av
> bv
? 1 : 0;
4110 /* Finish up dynamic symbol handling. We set the contents of various
4111 dynamic sections here. */
4114 elf32_hppa_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
4116 struct bfd_link_info
*info
;
4117 struct elf_link_hash_entry
*h
;
4118 Elf_Internal_Sym
*sym
;
4120 struct elf32_hppa_link_hash_table
*htab
;
4122 htab
= hppa_link_hash_table (info
);
4124 if (h
->plt
.offset
!= (bfd_vma
) -1)
4128 if (h
->plt
.offset
& 1)
4131 /* This symbol has an entry in the procedure linkage table. Set
4134 The format of a plt entry is
4139 if (h
->root
.type
== bfd_link_hash_defined
4140 || h
->root
.type
== bfd_link_hash_defweak
)
4142 value
= h
->root
.u
.def
.value
;
4143 if (h
->root
.u
.def
.section
->output_section
!= NULL
)
4144 value
+= (h
->root
.u
.def
.section
->output_offset
4145 + h
->root
.u
.def
.section
->output_section
->vma
);
4148 if (! ((struct elf32_hppa_link_hash_entry
*) h
)->pic_call
)
4150 Elf_Internal_Rela rel
;
4151 Elf32_External_Rela
*loc
;
4153 /* Create a dynamic IPLT relocation for this entry. */
4154 rel
.r_offset
= (h
->plt
.offset
4155 + htab
->splt
->output_offset
4156 + htab
->splt
->output_section
->vma
);
4157 if (h
->dynindx
!= -1)
4159 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_PARISC_IPLT
);
4164 /* This symbol has been marked to become local, and is
4165 used by a plabel so must be kept in the .plt. */
4166 rel
.r_info
= ELF32_R_INFO (0, R_PARISC_IPLT
);
4167 rel
.r_addend
= value
;
4170 loc
= (Elf32_External_Rela
*) htab
->srelplt
->contents
;
4171 loc
+= htab
->srelplt
->reloc_count
++;
4172 bfd_elf32_swap_reloca_out (htab
->splt
->output_section
->owner
,
4177 bfd_put_32 (htab
->splt
->owner
,
4179 htab
->splt
->contents
+ h
->plt
.offset
);
4180 bfd_put_32 (htab
->splt
->owner
,
4181 elf_gp (htab
->splt
->output_section
->owner
),
4182 htab
->splt
->contents
+ h
->plt
.offset
+ 4);
4185 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
4187 /* Mark the symbol as undefined, rather than as defined in
4188 the .plt section. Leave the value alone. */
4189 sym
->st_shndx
= SHN_UNDEF
;
4193 if (h
->got
.offset
!= (bfd_vma
) -1)
4195 Elf_Internal_Rela rel
;
4196 Elf32_External_Rela
*loc
;
4198 /* This symbol has an entry in the global offset table. Set it
4201 rel
.r_offset
= ((h
->got
.offset
&~ (bfd_vma
) 1)
4202 + htab
->sgot
->output_offset
4203 + htab
->sgot
->output_section
->vma
);
4205 /* If this is a -Bsymbolic link and the symbol is defined
4206 locally or was forced to be local because of a version file,
4207 we just want to emit a RELATIVE reloc. The entry in the
4208 global offset table will already have been initialized in the
4209 relocate_section function. */
4211 && (info
->symbolic
|| h
->dynindx
== -1)
4212 && (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
))
4214 rel
.r_info
= ELF32_R_INFO (0, R_PARISC_DIR32
);
4215 rel
.r_addend
= (h
->root
.u
.def
.value
4216 + h
->root
.u
.def
.section
->output_offset
4217 + h
->root
.u
.def
.section
->output_section
->vma
);
4221 if ((h
->got
.offset
& 1) != 0)
4223 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
4224 htab
->sgot
->contents
+ h
->got
.offset
);
4225 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_PARISC_DIR32
);
4229 loc
= (Elf32_External_Rela
*) htab
->srelgot
->contents
;
4230 loc
+= htab
->srelgot
->reloc_count
++;
4231 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
4234 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_NEEDS_COPY
) != 0)
4237 Elf_Internal_Rela rel
;
4238 Elf32_External_Rela
*loc
;
4240 /* This symbol needs a copy reloc. Set it up. */
4242 if (! (h
->dynindx
!= -1
4243 && (h
->root
.type
== bfd_link_hash_defined
4244 || h
->root
.type
== bfd_link_hash_defweak
)))
4249 rel
.r_offset
= (h
->root
.u
.def
.value
4250 + h
->root
.u
.def
.section
->output_offset
4251 + h
->root
.u
.def
.section
->output_section
->vma
);
4253 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_PARISC_COPY
);
4254 loc
= (Elf32_External_Rela
*) s
->contents
+ s
->reloc_count
++;
4255 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
4258 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
4259 if (h
->root
.root
.string
[0] == '_'
4260 && (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
4261 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0))
4263 sym
->st_shndx
= SHN_ABS
;
4269 /* Used to decide how to sort relocs in an optimal manner for the
4270 dynamic linker, before writing them out. */
4272 static enum elf_reloc_type_class
4273 elf32_hppa_reloc_type_class (rela
)
4274 const Elf_Internal_Rela
*rela
;
4276 if (ELF32_R_SYM (rela
->r_info
) == 0)
4277 return reloc_class_relative
;
4279 switch ((int) ELF32_R_TYPE (rela
->r_info
))
4282 return reloc_class_plt
;
4284 return reloc_class_copy
;
4286 return reloc_class_normal
;
4290 /* Finish up the dynamic sections. */
4293 elf32_hppa_finish_dynamic_sections (output_bfd
, info
)
4295 struct bfd_link_info
*info
;
4298 struct elf32_hppa_link_hash_table
*htab
;
4301 htab
= hppa_link_hash_table (info
);
4302 dynobj
= htab
->elf
.dynobj
;
4304 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
4306 if (htab
->elf
.dynamic_sections_created
)
4308 Elf32_External_Dyn
*dyncon
, *dynconend
;
4313 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
4314 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
4315 for (; dyncon
< dynconend
; dyncon
++)
4317 Elf_Internal_Dyn dyn
;
4320 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4328 /* Use PLTGOT to set the GOT register. */
4329 dyn
.d_un
.d_ptr
= elf_gp (output_bfd
);
4334 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
4339 if (s
->_cooked_size
!= 0)
4340 dyn
.d_un
.d_val
= s
->_cooked_size
;
4342 dyn
.d_un
.d_val
= s
->_raw_size
;
4346 /* Don't count procedure linkage table relocs in the
4347 overall reloc count. */
4348 if (htab
->srelplt
!= NULL
)
4350 s
= htab
->srelplt
->output_section
;
4351 if (s
->_cooked_size
!= 0)
4352 dyn
.d_un
.d_val
-= s
->_cooked_size
;
4354 dyn
.d_un
.d_val
-= s
->_raw_size
;
4359 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4363 if (htab
->sgot
!= NULL
&& htab
->sgot
->_raw_size
!= 0)
4365 /* Fill in the first entry in the global offset table.
4366 We use it to point to our dynamic section, if we have one. */
4367 bfd_put_32 (output_bfd
,
4369 ? sdyn
->output_section
->vma
+ sdyn
->output_offset
4371 htab
->sgot
->contents
);
4373 /* The second entry is reserved for use by the dynamic linker. */
4374 memset (htab
->sgot
->contents
+ GOT_ENTRY_SIZE
, 0, GOT_ENTRY_SIZE
);
4376 /* Set .got entry size. */
4377 elf_section_data (htab
->sgot
->output_section
)
4378 ->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
4381 if (htab
->splt
!= NULL
&& htab
->splt
->_raw_size
!= 0)
4383 /* Set plt entry size. */
4384 elf_section_data (htab
->splt
->output_section
)
4385 ->this_hdr
.sh_entsize
= PLT_ENTRY_SIZE
;
4387 if (htab
->need_plt_stub
)
4389 /* Set up the .plt stub. */
4390 memcpy (htab
->splt
->contents
4391 + htab
->splt
->_raw_size
- sizeof (plt_stub
),
4392 plt_stub
, sizeof (plt_stub
));
4394 if ((htab
->splt
->output_offset
4395 + htab
->splt
->output_section
->vma
4396 + htab
->splt
->_raw_size
)
4397 != (htab
->sgot
->output_offset
4398 + htab
->sgot
->output_section
->vma
))
4400 (*_bfd_error_handler
)
4401 (_(".got section not immediately after .plt section"));
4410 /* Tweak the OSABI field of the elf header. */
4413 elf32_hppa_post_process_headers (abfd
, link_info
)
4415 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
4417 Elf_Internal_Ehdr
* i_ehdrp
;
4419 i_ehdrp
= elf_elfheader (abfd
);
4421 if (strcmp (bfd_get_target (abfd
), "elf32-hppa-linux") == 0)
4423 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_LINUX
;
4427 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_HPUX
;
4431 /* Called when writing out an object file to decide the type of a
4434 elf32_hppa_elf_get_symbol_type (elf_sym
, type
)
4435 Elf_Internal_Sym
*elf_sym
;
4438 if (ELF_ST_TYPE (elf_sym
->st_info
) == STT_PARISC_MILLI
)
4439 return STT_PARISC_MILLI
;
4444 /* Misc BFD support code. */
4445 #define bfd_elf32_bfd_is_local_label_name elf_hppa_is_local_label_name
4446 #define bfd_elf32_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
4447 #define elf_info_to_howto elf_hppa_info_to_howto
4448 #define elf_info_to_howto_rel elf_hppa_info_to_howto_rel
4450 /* Stuff for the BFD linker. */
4451 #define bfd_elf32_bfd_final_link elf32_hppa_final_link
4452 #define bfd_elf32_bfd_link_hash_table_create elf32_hppa_link_hash_table_create
4453 #define elf_backend_add_symbol_hook elf32_hppa_add_symbol_hook
4454 #define elf_backend_adjust_dynamic_symbol elf32_hppa_adjust_dynamic_symbol
4455 #define elf_backend_copy_indirect_symbol elf32_hppa_copy_indirect_symbol
4456 #define elf_backend_check_relocs elf32_hppa_check_relocs
4457 #define elf_backend_create_dynamic_sections elf32_hppa_create_dynamic_sections
4458 #define elf_backend_fake_sections elf_hppa_fake_sections
4459 #define elf_backend_relocate_section elf32_hppa_relocate_section
4460 #define elf_backend_hide_symbol elf32_hppa_hide_symbol
4461 #define elf_backend_finish_dynamic_symbol elf32_hppa_finish_dynamic_symbol
4462 #define elf_backend_finish_dynamic_sections elf32_hppa_finish_dynamic_sections
4463 #define elf_backend_size_dynamic_sections elf32_hppa_size_dynamic_sections
4464 #define elf_backend_gc_mark_hook elf32_hppa_gc_mark_hook
4465 #define elf_backend_gc_sweep_hook elf32_hppa_gc_sweep_hook
4466 #define elf_backend_object_p elf32_hppa_object_p
4467 #define elf_backend_final_write_processing elf_hppa_final_write_processing
4468 #define elf_backend_post_process_headers elf32_hppa_post_process_headers
4469 #define elf_backend_get_symbol_type elf32_hppa_elf_get_symbol_type
4470 #define elf_backend_reloc_type_class elf32_hppa_reloc_type_class
4472 #define elf_backend_can_gc_sections 1
4473 #define elf_backend_can_refcount 1
4474 #define elf_backend_plt_alignment 2
4475 #define elf_backend_want_got_plt 0
4476 #define elf_backend_plt_readonly 0
4477 #define elf_backend_want_plt_sym 0
4478 #define elf_backend_got_header_size 8
4480 #define TARGET_BIG_SYM bfd_elf32_hppa_vec
4481 #define TARGET_BIG_NAME "elf32-hppa"
4482 #define ELF_ARCH bfd_arch_hppa
4483 #define ELF_MACHINE_CODE EM_PARISC
4484 #define ELF_MAXPAGESIZE 0x1000
4486 #include "elf32-target.h"
4488 #undef TARGET_BIG_SYM
4489 #define TARGET_BIG_SYM bfd_elf32_hppa_linux_vec
4490 #undef TARGET_BIG_NAME
4491 #define TARGET_BIG_NAME "elf32-hppa-linux"
4493 #define INCLUDED_TARGET_FILE 1
4494 #include "elf32-target.h"