daily update
[binutils.git] / bfd / elf32-hppa.c
blob770706014f093bd552c67844277ef6294824d2e8
1 /* BFD back-end for HP PA-RISC ELF files.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000, 2001,
3 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
6 Original code by
7 Center for Software Science
8 Department of Computer Science
9 University of Utah
10 Largely rewritten by Alan Modra <alan@linuxcare.com.au>
11 Naming cleanup by Carlos O'Donell <carlos@systemhalted.org>
12 TLS support written by Randolph Chung <tausq@debian.org>
14 This file is part of BFD, the Binary File Descriptor library.
16 This program is free software; you can redistribute it and/or modify
17 it under the terms of the GNU General Public License as published by
18 the Free Software Foundation; either version 3 of the License, or
19 (at your option) any later version.
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program; if not, write to the Free Software
28 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
29 MA 02110-1301, USA. */
31 #include "sysdep.h"
32 #include "bfd.h"
33 #include "libbfd.h"
34 #include "elf-bfd.h"
35 #include "elf/hppa.h"
36 #include "libhppa.h"
37 #include "elf32-hppa.h"
38 #define ARCH_SIZE 32
39 #include "elf32-hppa.h"
40 #include "elf-hppa.h"
42 /* In order to gain some understanding of code in this file without
43 knowing all the intricate details of the linker, note the
44 following:
46 Functions named elf32_hppa_* are called by external routines, other
47 functions are only called locally. elf32_hppa_* functions appear
48 in this file more or less in the order in which they are called
49 from external routines. eg. elf32_hppa_check_relocs is called
50 early in the link process, elf32_hppa_finish_dynamic_sections is
51 one of the last functions. */
53 /* We use two hash tables to hold information for linking PA ELF objects.
55 The first is the elf32_hppa_link_hash_table which is derived
56 from the standard ELF linker hash table. We use this as a place to
57 attach other hash tables and static information.
59 The second is the stub hash table which is derived from the
60 base BFD hash table. The stub hash table holds the information
61 necessary to build the linker stubs during a link.
63 There are a number of different stubs generated by the linker.
65 Long branch stub:
66 : ldil LR'X,%r1
67 : be,n RR'X(%sr4,%r1)
69 PIC long branch stub:
70 : b,l .+8,%r1
71 : addil LR'X - ($PIC_pcrel$0 - 4),%r1
72 : be,n RR'X - ($PIC_pcrel$0 - 8)(%sr4,%r1)
74 Import stub to call shared library routine from normal object file
75 (single sub-space version)
76 : addil LR'lt_ptr+ltoff,%dp ; get procedure entry point
77 : ldw RR'lt_ptr+ltoff(%r1),%r21
78 : bv %r0(%r21)
79 : ldw RR'lt_ptr+ltoff+4(%r1),%r19 ; get new dlt value.
81 Import stub to call shared library routine from shared library
82 (single sub-space version)
83 : addil LR'ltoff,%r19 ; get procedure entry point
84 : ldw RR'ltoff(%r1),%r21
85 : bv %r0(%r21)
86 : ldw RR'ltoff+4(%r1),%r19 ; get new dlt value.
88 Import stub to call shared library routine from normal object file
89 (multiple sub-space support)
90 : addil LR'lt_ptr+ltoff,%dp ; get procedure entry point
91 : ldw RR'lt_ptr+ltoff(%r1),%r21
92 : ldw RR'lt_ptr+ltoff+4(%r1),%r19 ; get new dlt value.
93 : ldsid (%r21),%r1
94 : mtsp %r1,%sr0
95 : be 0(%sr0,%r21) ; branch to target
96 : stw %rp,-24(%sp) ; save rp
98 Import stub to call shared library routine from shared library
99 (multiple sub-space support)
100 : addil LR'ltoff,%r19 ; get procedure entry point
101 : ldw RR'ltoff(%r1),%r21
102 : ldw RR'ltoff+4(%r1),%r19 ; get new dlt value.
103 : ldsid (%r21),%r1
104 : mtsp %r1,%sr0
105 : be 0(%sr0,%r21) ; branch to target
106 : stw %rp,-24(%sp) ; save rp
108 Export stub to return from shared lib routine (multiple sub-space support)
109 One of these is created for each exported procedure in a shared
110 library (and stored in the shared lib). Shared lib routines are
111 called via the first instruction in the export stub so that we can
112 do an inter-space return. Not required for single sub-space.
113 : bl,n X,%rp ; trap the return
114 : nop
115 : ldw -24(%sp),%rp ; restore the original rp
116 : ldsid (%rp),%r1
117 : mtsp %r1,%sr0
118 : be,n 0(%sr0,%rp) ; inter-space return. */
121 /* Variable names follow a coding style.
122 Please follow this (Apps Hungarian) style:
124 Structure/Variable Prefix
125 elf_link_hash_table "etab"
126 elf_link_hash_entry "eh"
128 elf32_hppa_link_hash_table "htab"
129 elf32_hppa_link_hash_entry "hh"
131 bfd_hash_table "btab"
132 bfd_hash_entry "bh"
134 bfd_hash_table containing stubs "bstab"
135 elf32_hppa_stub_hash_entry "hsh"
137 elf32_hppa_dyn_reloc_entry "hdh"
139 Always remember to use GNU Coding Style. */
141 #define PLT_ENTRY_SIZE 8
142 #define GOT_ENTRY_SIZE 4
143 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
145 static const bfd_byte plt_stub[] =
147 0x0e, 0x80, 0x10, 0x96, /* 1: ldw 0(%r20),%r22 */
148 0xea, 0xc0, 0xc0, 0x00, /* bv %r0(%r22) */
149 0x0e, 0x88, 0x10, 0x95, /* ldw 4(%r20),%r21 */
150 #define PLT_STUB_ENTRY (3*4)
151 0xea, 0x9f, 0x1f, 0xdd, /* b,l 1b,%r20 */
152 0xd6, 0x80, 0x1c, 0x1e, /* depi 0,31,2,%r20 */
153 0x00, 0xc0, 0xff, 0xee, /* 9: .word fixup_func */
154 0xde, 0xad, 0xbe, 0xef /* .word fixup_ltp */
157 /* Section name for stubs is the associated section name plus this
158 string. */
159 #define STUB_SUFFIX ".stub"
161 /* We don't need to copy certain PC- or GP-relative dynamic relocs
162 into a shared object's dynamic section. All the relocs of the
163 limited class we are interested in, are absolute. */
164 #ifndef RELATIVE_DYNRELOCS
165 #define RELATIVE_DYNRELOCS 0
166 #define IS_ABSOLUTE_RELOC(r_type) 1
167 #endif
169 /* If ELIMINATE_COPY_RELOCS is non-zero, the linker will try to avoid
170 copying dynamic variables from a shared lib into an app's dynbss
171 section, and instead use a dynamic relocation to point into the
172 shared lib. */
173 #define ELIMINATE_COPY_RELOCS 1
175 enum elf32_hppa_stub_type
177 hppa_stub_long_branch,
178 hppa_stub_long_branch_shared,
179 hppa_stub_import,
180 hppa_stub_import_shared,
181 hppa_stub_export,
182 hppa_stub_none
185 struct elf32_hppa_stub_hash_entry
187 /* Base hash table entry structure. */
188 struct bfd_hash_entry bh_root;
190 /* The stub section. */
191 asection *stub_sec;
193 /* Offset within stub_sec of the beginning of this stub. */
194 bfd_vma stub_offset;
196 /* Given the symbol's value and its section we can determine its final
197 value when building the stubs (so the stub knows where to jump. */
198 bfd_vma target_value;
199 asection *target_section;
201 enum elf32_hppa_stub_type stub_type;
203 /* The symbol table entry, if any, that this was derived from. */
204 struct elf32_hppa_link_hash_entry *hh;
206 /* Where this stub is being called from, or, in the case of combined
207 stub sections, the first input section in the group. */
208 asection *id_sec;
211 struct elf32_hppa_link_hash_entry
213 struct elf_link_hash_entry eh;
215 /* A pointer to the most recently used stub hash entry against this
216 symbol. */
217 struct elf32_hppa_stub_hash_entry *hsh_cache;
219 /* Used to count relocations for delayed sizing of relocation
220 sections. */
221 struct elf32_hppa_dyn_reloc_entry
223 /* Next relocation in the chain. */
224 struct elf32_hppa_dyn_reloc_entry *hdh_next;
226 /* The input section of the reloc. */
227 asection *sec;
229 /* Number of relocs copied in this section. */
230 bfd_size_type count;
232 #if RELATIVE_DYNRELOCS
233 /* Number of relative relocs copied for the input section. */
234 bfd_size_type relative_count;
235 #endif
236 } *dyn_relocs;
238 enum
240 GOT_UNKNOWN = 0, GOT_NORMAL = 1, GOT_TLS_GD = 2, GOT_TLS_LDM = 4, GOT_TLS_IE = 8
241 } tls_type;
243 /* Set if this symbol is used by a plabel reloc. */
244 unsigned int plabel:1;
247 struct elf32_hppa_link_hash_table
249 /* The main hash table. */
250 struct elf_link_hash_table etab;
252 /* The stub hash table. */
253 struct bfd_hash_table bstab;
255 /* Linker stub bfd. */
256 bfd *stub_bfd;
258 /* Linker call-backs. */
259 asection * (*add_stub_section) (const char *, asection *);
260 void (*layout_sections_again) (void);
262 /* Array to keep track of which stub sections have been created, and
263 information on stub grouping. */
264 struct map_stub
266 /* This is the section to which stubs in the group will be
267 attached. */
268 asection *link_sec;
269 /* The stub section. */
270 asection *stub_sec;
271 } *stub_group;
273 /* Assorted information used by elf32_hppa_size_stubs. */
274 unsigned int bfd_count;
275 int top_index;
276 asection **input_list;
277 Elf_Internal_Sym **all_local_syms;
279 /* Short-cuts to get to dynamic linker sections. */
280 asection *sgot;
281 asection *srelgot;
282 asection *splt;
283 asection *srelplt;
284 asection *sdynbss;
285 asection *srelbss;
287 /* Used during a final link to store the base of the text and data
288 segments so that we can perform SEGREL relocations. */
289 bfd_vma text_segment_base;
290 bfd_vma data_segment_base;
292 /* Whether we support multiple sub-spaces for shared libs. */
293 unsigned int multi_subspace:1;
295 /* Flags set when various size branches are detected. Used to
296 select suitable defaults for the stub group size. */
297 unsigned int has_12bit_branch:1;
298 unsigned int has_17bit_branch:1;
299 unsigned int has_22bit_branch:1;
301 /* Set if we need a .plt stub to support lazy dynamic linking. */
302 unsigned int need_plt_stub:1;
304 /* Small local sym to section mapping cache. */
305 struct sym_sec_cache sym_sec;
307 /* Data for LDM relocations. */
308 union
310 bfd_signed_vma refcount;
311 bfd_vma offset;
312 } tls_ldm_got;
315 /* Various hash macros and functions. */
316 #define hppa_link_hash_table(p) \
317 ((struct elf32_hppa_link_hash_table *) ((p)->hash))
319 #define hppa_elf_hash_entry(ent) \
320 ((struct elf32_hppa_link_hash_entry *)(ent))
322 #define hppa_stub_hash_entry(ent) \
323 ((struct elf32_hppa_stub_hash_entry *)(ent))
325 #define hppa_stub_hash_lookup(table, string, create, copy) \
326 ((struct elf32_hppa_stub_hash_entry *) \
327 bfd_hash_lookup ((table), (string), (create), (copy)))
329 #define hppa_elf_local_got_tls_type(abfd) \
330 ((char *)(elf_local_got_offsets (abfd) + (elf_tdata (abfd)->symtab_hdr.sh_info * 2)))
332 #define hh_name(hh) \
333 (hh ? hh->eh.root.root.string : "<undef>")
335 #define eh_name(eh) \
336 (eh ? eh->root.root.string : "<undef>")
338 /* Override the generic function because we want to mark our BFDs. */
340 static bfd_boolean
341 elf32_hppa_mkobject (bfd *abfd)
343 return bfd_elf_allocate_object (abfd, sizeof (struct elf_obj_tdata),
344 HPPA_ELF_TDATA);
347 /* Assorted hash table functions. */
349 /* Initialize an entry in the stub hash table. */
351 static struct bfd_hash_entry *
352 stub_hash_newfunc (struct bfd_hash_entry *entry,
353 struct bfd_hash_table *table,
354 const char *string)
356 /* Allocate the structure if it has not already been allocated by a
357 subclass. */
358 if (entry == NULL)
360 entry = bfd_hash_allocate (table,
361 sizeof (struct elf32_hppa_stub_hash_entry));
362 if (entry == NULL)
363 return entry;
366 /* Call the allocation method of the superclass. */
367 entry = bfd_hash_newfunc (entry, table, string);
368 if (entry != NULL)
370 struct elf32_hppa_stub_hash_entry *hsh;
372 /* Initialize the local fields. */
373 hsh = hppa_stub_hash_entry (entry);
374 hsh->stub_sec = NULL;
375 hsh->stub_offset = 0;
376 hsh->target_value = 0;
377 hsh->target_section = NULL;
378 hsh->stub_type = hppa_stub_long_branch;
379 hsh->hh = NULL;
380 hsh->id_sec = NULL;
383 return entry;
386 /* Initialize an entry in the link hash table. */
388 static struct bfd_hash_entry *
389 hppa_link_hash_newfunc (struct bfd_hash_entry *entry,
390 struct bfd_hash_table *table,
391 const char *string)
393 /* Allocate the structure if it has not already been allocated by a
394 subclass. */
395 if (entry == NULL)
397 entry = bfd_hash_allocate (table,
398 sizeof (struct elf32_hppa_link_hash_entry));
399 if (entry == NULL)
400 return entry;
403 /* Call the allocation method of the superclass. */
404 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
405 if (entry != NULL)
407 struct elf32_hppa_link_hash_entry *hh;
409 /* Initialize the local fields. */
410 hh = hppa_elf_hash_entry (entry);
411 hh->hsh_cache = NULL;
412 hh->dyn_relocs = NULL;
413 hh->plabel = 0;
414 hh->tls_type = GOT_UNKNOWN;
417 return entry;
420 /* Create the derived linker hash table. The PA ELF port uses the derived
421 hash table to keep information specific to the PA ELF linker (without
422 using static variables). */
424 static struct bfd_link_hash_table *
425 elf32_hppa_link_hash_table_create (bfd *abfd)
427 struct elf32_hppa_link_hash_table *htab;
428 bfd_size_type amt = sizeof (*htab);
430 htab = bfd_malloc (amt);
431 if (htab == NULL)
432 return NULL;
434 if (!_bfd_elf_link_hash_table_init (&htab->etab, abfd, hppa_link_hash_newfunc,
435 sizeof (struct elf32_hppa_link_hash_entry)))
437 free (htab);
438 return NULL;
441 /* Init the stub hash table too. */
442 if (!bfd_hash_table_init (&htab->bstab, stub_hash_newfunc,
443 sizeof (struct elf32_hppa_stub_hash_entry)))
444 return NULL;
446 htab->stub_bfd = NULL;
447 htab->add_stub_section = NULL;
448 htab->layout_sections_again = NULL;
449 htab->stub_group = NULL;
450 htab->sgot = NULL;
451 htab->srelgot = NULL;
452 htab->splt = NULL;
453 htab->srelplt = NULL;
454 htab->sdynbss = NULL;
455 htab->srelbss = NULL;
456 htab->text_segment_base = (bfd_vma) -1;
457 htab->data_segment_base = (bfd_vma) -1;
458 htab->multi_subspace = 0;
459 htab->has_12bit_branch = 0;
460 htab->has_17bit_branch = 0;
461 htab->has_22bit_branch = 0;
462 htab->need_plt_stub = 0;
463 htab->sym_sec.abfd = NULL;
464 htab->tls_ldm_got.refcount = 0;
466 return &htab->etab.root;
469 /* Free the derived linker hash table. */
471 static void
472 elf32_hppa_link_hash_table_free (struct bfd_link_hash_table *btab)
474 struct elf32_hppa_link_hash_table *htab
475 = (struct elf32_hppa_link_hash_table *) btab;
477 bfd_hash_table_free (&htab->bstab);
478 _bfd_generic_link_hash_table_free (btab);
481 /* Build a name for an entry in the stub hash table. */
483 static char *
484 hppa_stub_name (const asection *input_section,
485 const asection *sym_sec,
486 const struct elf32_hppa_link_hash_entry *hh,
487 const Elf_Internal_Rela *rela)
489 char *stub_name;
490 bfd_size_type len;
492 if (hh)
494 len = 8 + 1 + strlen (hh_name (hh)) + 1 + 8 + 1;
495 stub_name = bfd_malloc (len);
496 if (stub_name != NULL)
497 sprintf (stub_name, "%08x_%s+%x",
498 input_section->id & 0xffffffff,
499 hh_name (hh),
500 (int) rela->r_addend & 0xffffffff);
502 else
504 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
505 stub_name = bfd_malloc (len);
506 if (stub_name != NULL)
507 sprintf (stub_name, "%08x_%x:%x+%x",
508 input_section->id & 0xffffffff,
509 sym_sec->id & 0xffffffff,
510 (int) ELF32_R_SYM (rela->r_info) & 0xffffffff,
511 (int) rela->r_addend & 0xffffffff);
513 return stub_name;
516 /* Look up an entry in the stub hash. Stub entries are cached because
517 creating the stub name takes a bit of time. */
519 static struct elf32_hppa_stub_hash_entry *
520 hppa_get_stub_entry (const asection *input_section,
521 const asection *sym_sec,
522 struct elf32_hppa_link_hash_entry *hh,
523 const Elf_Internal_Rela *rela,
524 struct elf32_hppa_link_hash_table *htab)
526 struct elf32_hppa_stub_hash_entry *hsh_entry;
527 const asection *id_sec;
529 /* If this input section is part of a group of sections sharing one
530 stub section, then use the id of the first section in the group.
531 Stub names need to include a section id, as there may well be
532 more than one stub used to reach say, printf, and we need to
533 distinguish between them. */
534 id_sec = htab->stub_group[input_section->id].link_sec;
536 if (hh != NULL && hh->hsh_cache != NULL
537 && hh->hsh_cache->hh == hh
538 && hh->hsh_cache->id_sec == id_sec)
540 hsh_entry = hh->hsh_cache;
542 else
544 char *stub_name;
546 stub_name = hppa_stub_name (id_sec, sym_sec, hh, rela);
547 if (stub_name == NULL)
548 return NULL;
550 hsh_entry = hppa_stub_hash_lookup (&htab->bstab,
551 stub_name, FALSE, FALSE);
552 if (hh != NULL)
553 hh->hsh_cache = hsh_entry;
555 free (stub_name);
558 return hsh_entry;
561 /* Add a new stub entry to the stub hash. Not all fields of the new
562 stub entry are initialised. */
564 static struct elf32_hppa_stub_hash_entry *
565 hppa_add_stub (const char *stub_name,
566 asection *section,
567 struct elf32_hppa_link_hash_table *htab)
569 asection *link_sec;
570 asection *stub_sec;
571 struct elf32_hppa_stub_hash_entry *hsh;
573 link_sec = htab->stub_group[section->id].link_sec;
574 stub_sec = htab->stub_group[section->id].stub_sec;
575 if (stub_sec == NULL)
577 stub_sec = htab->stub_group[link_sec->id].stub_sec;
578 if (stub_sec == NULL)
580 size_t namelen;
581 bfd_size_type len;
582 char *s_name;
584 namelen = strlen (link_sec->name);
585 len = namelen + sizeof (STUB_SUFFIX);
586 s_name = bfd_alloc (htab->stub_bfd, len);
587 if (s_name == NULL)
588 return NULL;
590 memcpy (s_name, link_sec->name, namelen);
591 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
592 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
593 if (stub_sec == NULL)
594 return NULL;
595 htab->stub_group[link_sec->id].stub_sec = stub_sec;
597 htab->stub_group[section->id].stub_sec = stub_sec;
600 /* Enter this entry into the linker stub hash table. */
601 hsh = hppa_stub_hash_lookup (&htab->bstab, stub_name,
602 TRUE, FALSE);
603 if (hsh == NULL)
605 (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
606 section->owner,
607 stub_name);
608 return NULL;
611 hsh->stub_sec = stub_sec;
612 hsh->stub_offset = 0;
613 hsh->id_sec = link_sec;
614 return hsh;
617 /* Determine the type of stub needed, if any, for a call. */
619 static enum elf32_hppa_stub_type
620 hppa_type_of_stub (asection *input_sec,
621 const Elf_Internal_Rela *rela,
622 struct elf32_hppa_link_hash_entry *hh,
623 bfd_vma destination,
624 struct bfd_link_info *info)
626 bfd_vma location;
627 bfd_vma branch_offset;
628 bfd_vma max_branch_offset;
629 unsigned int r_type;
631 if (hh != NULL
632 && hh->eh.plt.offset != (bfd_vma) -1
633 && hh->eh.dynindx != -1
634 && !hh->plabel
635 && (info->shared
636 || !hh->eh.def_regular
637 || hh->eh.root.type == bfd_link_hash_defweak))
639 /* We need an import stub. Decide between hppa_stub_import
640 and hppa_stub_import_shared later. */
641 return hppa_stub_import;
644 /* Determine where the call point is. */
645 location = (input_sec->output_offset
646 + input_sec->output_section->vma
647 + rela->r_offset);
649 branch_offset = destination - location - 8;
650 r_type = ELF32_R_TYPE (rela->r_info);
652 /* Determine if a long branch stub is needed. parisc branch offsets
653 are relative to the second instruction past the branch, ie. +8
654 bytes on from the branch instruction location. The offset is
655 signed and counts in units of 4 bytes. */
656 if (r_type == (unsigned int) R_PARISC_PCREL17F)
657 max_branch_offset = (1 << (17 - 1)) << 2;
659 else if (r_type == (unsigned int) R_PARISC_PCREL12F)
660 max_branch_offset = (1 << (12 - 1)) << 2;
662 else /* R_PARISC_PCREL22F. */
663 max_branch_offset = (1 << (22 - 1)) << 2;
665 if (branch_offset + max_branch_offset >= 2*max_branch_offset)
666 return hppa_stub_long_branch;
668 return hppa_stub_none;
671 /* Build one linker stub as defined by the stub hash table entry GEN_ENTRY.
672 IN_ARG contains the link info pointer. */
674 #define LDIL_R1 0x20200000 /* ldil LR'XXX,%r1 */
675 #define BE_SR4_R1 0xe0202002 /* be,n RR'XXX(%sr4,%r1) */
677 #define BL_R1 0xe8200000 /* b,l .+8,%r1 */
678 #define ADDIL_R1 0x28200000 /* addil LR'XXX,%r1,%r1 */
679 #define DEPI_R1 0xd4201c1e /* depi 0,31,2,%r1 */
681 #define ADDIL_DP 0x2b600000 /* addil LR'XXX,%dp,%r1 */
682 #define LDW_R1_R21 0x48350000 /* ldw RR'XXX(%sr0,%r1),%r21 */
683 #define BV_R0_R21 0xeaa0c000 /* bv %r0(%r21) */
684 #define LDW_R1_R19 0x48330000 /* ldw RR'XXX(%sr0,%r1),%r19 */
686 #define ADDIL_R19 0x2a600000 /* addil LR'XXX,%r19,%r1 */
687 #define LDW_R1_DP 0x483b0000 /* ldw RR'XXX(%sr0,%r1),%dp */
689 #define LDSID_R21_R1 0x02a010a1 /* ldsid (%sr0,%r21),%r1 */
690 #define MTSP_R1 0x00011820 /* mtsp %r1,%sr0 */
691 #define BE_SR0_R21 0xe2a00000 /* be 0(%sr0,%r21) */
692 #define STW_RP 0x6bc23fd1 /* stw %rp,-24(%sr0,%sp) */
694 #define BL22_RP 0xe800a002 /* b,l,n XXX,%rp */
695 #define BL_RP 0xe8400002 /* b,l,n XXX,%rp */
696 #define NOP 0x08000240 /* nop */
697 #define LDW_RP 0x4bc23fd1 /* ldw -24(%sr0,%sp),%rp */
698 #define LDSID_RP_R1 0x004010a1 /* ldsid (%sr0,%rp),%r1 */
699 #define BE_SR0_RP 0xe0400002 /* be,n 0(%sr0,%rp) */
701 #ifndef R19_STUBS
702 #define R19_STUBS 1
703 #endif
705 #if R19_STUBS
706 #define LDW_R1_DLT LDW_R1_R19
707 #else
708 #define LDW_R1_DLT LDW_R1_DP
709 #endif
711 static bfd_boolean
712 hppa_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
714 struct elf32_hppa_stub_hash_entry *hsh;
715 struct bfd_link_info *info;
716 struct elf32_hppa_link_hash_table *htab;
717 asection *stub_sec;
718 bfd *stub_bfd;
719 bfd_byte *loc;
720 bfd_vma sym_value;
721 bfd_vma insn;
722 bfd_vma off;
723 int val;
724 int size;
726 /* Massage our args to the form they really have. */
727 hsh = hppa_stub_hash_entry (bh);
728 info = (struct bfd_link_info *)in_arg;
730 htab = hppa_link_hash_table (info);
731 stub_sec = hsh->stub_sec;
733 /* Make a note of the offset within the stubs for this entry. */
734 hsh->stub_offset = stub_sec->size;
735 loc = stub_sec->contents + hsh->stub_offset;
737 stub_bfd = stub_sec->owner;
739 switch (hsh->stub_type)
741 case hppa_stub_long_branch:
742 /* Create the long branch. A long branch is formed with "ldil"
743 loading the upper bits of the target address into a register,
744 then branching with "be" which adds in the lower bits.
745 The "be" has its delay slot nullified. */
746 sym_value = (hsh->target_value
747 + hsh->target_section->output_offset
748 + hsh->target_section->output_section->vma);
750 val = hppa_field_adjust (sym_value, 0, e_lrsel);
751 insn = hppa_rebuild_insn ((int) LDIL_R1, val, 21);
752 bfd_put_32 (stub_bfd, insn, loc);
754 val = hppa_field_adjust (sym_value, 0, e_rrsel) >> 2;
755 insn = hppa_rebuild_insn ((int) BE_SR4_R1, val, 17);
756 bfd_put_32 (stub_bfd, insn, loc + 4);
758 size = 8;
759 break;
761 case hppa_stub_long_branch_shared:
762 /* Branches are relative. This is where we are going to. */
763 sym_value = (hsh->target_value
764 + hsh->target_section->output_offset
765 + hsh->target_section->output_section->vma);
767 /* And this is where we are coming from, more or less. */
768 sym_value -= (hsh->stub_offset
769 + stub_sec->output_offset
770 + stub_sec->output_section->vma);
772 bfd_put_32 (stub_bfd, (bfd_vma) BL_R1, loc);
773 val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_lrsel);
774 insn = hppa_rebuild_insn ((int) ADDIL_R1, val, 21);
775 bfd_put_32 (stub_bfd, insn, loc + 4);
777 val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_rrsel) >> 2;
778 insn = hppa_rebuild_insn ((int) BE_SR4_R1, val, 17);
779 bfd_put_32 (stub_bfd, insn, loc + 8);
780 size = 12;
781 break;
783 case hppa_stub_import:
784 case hppa_stub_import_shared:
785 off = hsh->hh->eh.plt.offset;
786 if (off >= (bfd_vma) -2)
787 abort ();
789 off &= ~ (bfd_vma) 1;
790 sym_value = (off
791 + htab->splt->output_offset
792 + htab->splt->output_section->vma
793 - elf_gp (htab->splt->output_section->owner));
795 insn = ADDIL_DP;
796 #if R19_STUBS
797 if (hsh->stub_type == hppa_stub_import_shared)
798 insn = ADDIL_R19;
799 #endif
800 val = hppa_field_adjust (sym_value, 0, e_lrsel),
801 insn = hppa_rebuild_insn ((int) insn, val, 21);
802 bfd_put_32 (stub_bfd, insn, loc);
804 /* It is critical to use lrsel/rrsel here because we are using
805 two different offsets (+0 and +4) from sym_value. If we use
806 lsel/rsel then with unfortunate sym_values we will round
807 sym_value+4 up to the next 2k block leading to a mis-match
808 between the lsel and rsel value. */
809 val = hppa_field_adjust (sym_value, 0, e_rrsel);
810 insn = hppa_rebuild_insn ((int) LDW_R1_R21, val, 14);
811 bfd_put_32 (stub_bfd, insn, loc + 4);
813 if (htab->multi_subspace)
815 val = hppa_field_adjust (sym_value, (bfd_signed_vma) 4, e_rrsel);
816 insn = hppa_rebuild_insn ((int) LDW_R1_DLT, val, 14);
817 bfd_put_32 (stub_bfd, insn, loc + 8);
819 bfd_put_32 (stub_bfd, (bfd_vma) LDSID_R21_R1, loc + 12);
820 bfd_put_32 (stub_bfd, (bfd_vma) MTSP_R1, loc + 16);
821 bfd_put_32 (stub_bfd, (bfd_vma) BE_SR0_R21, loc + 20);
822 bfd_put_32 (stub_bfd, (bfd_vma) STW_RP, loc + 24);
824 size = 28;
826 else
828 bfd_put_32 (stub_bfd, (bfd_vma) BV_R0_R21, loc + 8);
829 val = hppa_field_adjust (sym_value, (bfd_signed_vma) 4, e_rrsel);
830 insn = hppa_rebuild_insn ((int) LDW_R1_DLT, val, 14);
831 bfd_put_32 (stub_bfd, insn, loc + 12);
833 size = 16;
836 break;
838 case hppa_stub_export:
839 /* Branches are relative. This is where we are going to. */
840 sym_value = (hsh->target_value
841 + hsh->target_section->output_offset
842 + hsh->target_section->output_section->vma);
844 /* And this is where we are coming from. */
845 sym_value -= (hsh->stub_offset
846 + stub_sec->output_offset
847 + stub_sec->output_section->vma);
849 if (sym_value - 8 + (1 << (17 + 1)) >= (1 << (17 + 2))
850 && (!htab->has_22bit_branch
851 || sym_value - 8 + (1 << (22 + 1)) >= (1 << (22 + 2))))
853 (*_bfd_error_handler)
854 (_("%B(%A+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
855 hsh->target_section->owner,
856 stub_sec,
857 (long) hsh->stub_offset,
858 hsh->bh_root.string);
859 bfd_set_error (bfd_error_bad_value);
860 return FALSE;
863 val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_fsel) >> 2;
864 if (!htab->has_22bit_branch)
865 insn = hppa_rebuild_insn ((int) BL_RP, val, 17);
866 else
867 insn = hppa_rebuild_insn ((int) BL22_RP, val, 22);
868 bfd_put_32 (stub_bfd, insn, loc);
870 bfd_put_32 (stub_bfd, (bfd_vma) NOP, loc + 4);
871 bfd_put_32 (stub_bfd, (bfd_vma) LDW_RP, loc + 8);
872 bfd_put_32 (stub_bfd, (bfd_vma) LDSID_RP_R1, loc + 12);
873 bfd_put_32 (stub_bfd, (bfd_vma) MTSP_R1, loc + 16);
874 bfd_put_32 (stub_bfd, (bfd_vma) BE_SR0_RP, loc + 20);
876 /* Point the function symbol at the stub. */
877 hsh->hh->eh.root.u.def.section = stub_sec;
878 hsh->hh->eh.root.u.def.value = stub_sec->size;
880 size = 24;
881 break;
883 default:
884 BFD_FAIL ();
885 return FALSE;
888 stub_sec->size += size;
889 return TRUE;
892 #undef LDIL_R1
893 #undef BE_SR4_R1
894 #undef BL_R1
895 #undef ADDIL_R1
896 #undef DEPI_R1
897 #undef LDW_R1_R21
898 #undef LDW_R1_DLT
899 #undef LDW_R1_R19
900 #undef ADDIL_R19
901 #undef LDW_R1_DP
902 #undef LDSID_R21_R1
903 #undef MTSP_R1
904 #undef BE_SR0_R21
905 #undef STW_RP
906 #undef BV_R0_R21
907 #undef BL_RP
908 #undef NOP
909 #undef LDW_RP
910 #undef LDSID_RP_R1
911 #undef BE_SR0_RP
913 /* As above, but don't actually build the stub. Just bump offset so
914 we know stub section sizes. */
916 static bfd_boolean
917 hppa_size_one_stub (struct bfd_hash_entry *bh, void *in_arg)
919 struct elf32_hppa_stub_hash_entry *hsh;
920 struct elf32_hppa_link_hash_table *htab;
921 int size;
923 /* Massage our args to the form they really have. */
924 hsh = hppa_stub_hash_entry (bh);
925 htab = in_arg;
927 if (hsh->stub_type == hppa_stub_long_branch)
928 size = 8;
929 else if (hsh->stub_type == hppa_stub_long_branch_shared)
930 size = 12;
931 else if (hsh->stub_type == hppa_stub_export)
932 size = 24;
933 else /* hppa_stub_import or hppa_stub_import_shared. */
935 if (htab->multi_subspace)
936 size = 28;
937 else
938 size = 16;
941 hsh->stub_sec->size += size;
942 return TRUE;
945 /* Return nonzero if ABFD represents an HPPA ELF32 file.
946 Additionally we set the default architecture and machine. */
948 static bfd_boolean
949 elf32_hppa_object_p (bfd *abfd)
951 Elf_Internal_Ehdr * i_ehdrp;
952 unsigned int flags;
954 i_ehdrp = elf_elfheader (abfd);
955 if (strcmp (bfd_get_target (abfd), "elf32-hppa-linux") == 0)
957 /* GCC on hppa-linux produces binaries with OSABI=Linux,
958 but the kernel produces corefiles with OSABI=SysV. */
959 if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_LINUX &&
960 i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */
961 return FALSE;
963 else if (strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") == 0)
965 /* GCC on hppa-netbsd produces binaries with OSABI=NetBSD,
966 but the kernel produces corefiles with OSABI=SysV. */
967 if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NETBSD &&
968 i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_NONE) /* aka SYSV */
969 return FALSE;
971 else
973 if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_HPUX)
974 return FALSE;
977 flags = i_ehdrp->e_flags;
978 switch (flags & (EF_PARISC_ARCH | EF_PARISC_WIDE))
980 case EFA_PARISC_1_0:
981 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 10);
982 case EFA_PARISC_1_1:
983 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 11);
984 case EFA_PARISC_2_0:
985 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 20);
986 case EFA_PARISC_2_0 | EF_PARISC_WIDE:
987 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25);
989 return TRUE;
992 /* Create the .plt and .got sections, and set up our hash table
993 short-cuts to various dynamic sections. */
995 static bfd_boolean
996 elf32_hppa_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
998 struct elf32_hppa_link_hash_table *htab;
999 struct elf_link_hash_entry *eh;
1001 /* Don't try to create the .plt and .got twice. */
1002 htab = hppa_link_hash_table (info);
1003 if (htab->splt != NULL)
1004 return TRUE;
1006 /* Call the generic code to do most of the work. */
1007 if (! _bfd_elf_create_dynamic_sections (abfd, info))
1008 return FALSE;
1010 htab->splt = bfd_get_section_by_name (abfd, ".plt");
1011 htab->srelplt = bfd_get_section_by_name (abfd, ".rela.plt");
1013 htab->sgot = bfd_get_section_by_name (abfd, ".got");
1014 htab->srelgot = bfd_make_section_with_flags (abfd, ".rela.got",
1015 (SEC_ALLOC
1016 | SEC_LOAD
1017 | SEC_HAS_CONTENTS
1018 | SEC_IN_MEMORY
1019 | SEC_LINKER_CREATED
1020 | SEC_READONLY));
1021 if (htab->srelgot == NULL
1022 || ! bfd_set_section_alignment (abfd, htab->srelgot, 2))
1023 return FALSE;
1025 htab->sdynbss = bfd_get_section_by_name (abfd, ".dynbss");
1026 htab->srelbss = bfd_get_section_by_name (abfd, ".rela.bss");
1028 /* hppa-linux needs _GLOBAL_OFFSET_TABLE_ to be visible from the main
1029 application, because __canonicalize_funcptr_for_compare needs it. */
1030 eh = elf_hash_table (info)->hgot;
1031 eh->forced_local = 0;
1032 eh->other = STV_DEFAULT;
1033 return bfd_elf_link_record_dynamic_symbol (info, eh);
1036 /* Copy the extra info we tack onto an elf_link_hash_entry. */
1038 static void
1039 elf32_hppa_copy_indirect_symbol (struct bfd_link_info *info,
1040 struct elf_link_hash_entry *eh_dir,
1041 struct elf_link_hash_entry *eh_ind)
1043 struct elf32_hppa_link_hash_entry *hh_dir, *hh_ind;
1045 hh_dir = hppa_elf_hash_entry (eh_dir);
1046 hh_ind = hppa_elf_hash_entry (eh_ind);
1048 if (hh_ind->dyn_relocs != NULL)
1050 if (hh_dir->dyn_relocs != NULL)
1052 struct elf32_hppa_dyn_reloc_entry **hdh_pp;
1053 struct elf32_hppa_dyn_reloc_entry *hdh_p;
1055 /* Add reloc counts against the indirect sym to the direct sym
1056 list. Merge any entries against the same section. */
1057 for (hdh_pp = &hh_ind->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
1059 struct elf32_hppa_dyn_reloc_entry *hdh_q;
1061 for (hdh_q = hh_dir->dyn_relocs;
1062 hdh_q != NULL;
1063 hdh_q = hdh_q->hdh_next)
1064 if (hdh_q->sec == hdh_p->sec)
1066 #if RELATIVE_DYNRELOCS
1067 hdh_q->relative_count += hdh_p->relative_count;
1068 #endif
1069 hdh_q->count += hdh_p->count;
1070 *hdh_pp = hdh_p->hdh_next;
1071 break;
1073 if (hdh_q == NULL)
1074 hdh_pp = &hdh_p->hdh_next;
1076 *hdh_pp = hh_dir->dyn_relocs;
1079 hh_dir->dyn_relocs = hh_ind->dyn_relocs;
1080 hh_ind->dyn_relocs = NULL;
1083 if (ELIMINATE_COPY_RELOCS
1084 && eh_ind->root.type != bfd_link_hash_indirect
1085 && eh_dir->dynamic_adjusted)
1087 /* If called to transfer flags for a weakdef during processing
1088 of elf_adjust_dynamic_symbol, don't copy non_got_ref.
1089 We clear it ourselves for ELIMINATE_COPY_RELOCS. */
1090 eh_dir->ref_dynamic |= eh_ind->ref_dynamic;
1091 eh_dir->ref_regular |= eh_ind->ref_regular;
1092 eh_dir->ref_regular_nonweak |= eh_ind->ref_regular_nonweak;
1093 eh_dir->needs_plt |= eh_ind->needs_plt;
1095 else
1097 if (eh_ind->root.type == bfd_link_hash_indirect
1098 && eh_dir->got.refcount <= 0)
1100 hh_dir->tls_type = hh_ind->tls_type;
1101 hh_ind->tls_type = GOT_UNKNOWN;
1104 _bfd_elf_link_hash_copy_indirect (info, eh_dir, eh_ind);
1108 static int
1109 elf32_hppa_optimized_tls_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED,
1110 int r_type, int is_local ATTRIBUTE_UNUSED)
1112 /* For now we don't support linker optimizations. */
1113 return r_type;
1116 /* Look through the relocs for a section during the first phase, and
1117 calculate needed space in the global offset table, procedure linkage
1118 table, and dynamic reloc sections. At this point we haven't
1119 necessarily read all the input files. */
1121 static bfd_boolean
1122 elf32_hppa_check_relocs (bfd *abfd,
1123 struct bfd_link_info *info,
1124 asection *sec,
1125 const Elf_Internal_Rela *relocs)
1127 Elf_Internal_Shdr *symtab_hdr;
1128 struct elf_link_hash_entry **eh_syms;
1129 const Elf_Internal_Rela *rela;
1130 const Elf_Internal_Rela *rela_end;
1131 struct elf32_hppa_link_hash_table *htab;
1132 asection *sreloc;
1133 asection *stubreloc;
1134 int tls_type = GOT_UNKNOWN, old_tls_type = GOT_UNKNOWN;
1136 if (info->relocatable)
1137 return TRUE;
1139 htab = hppa_link_hash_table (info);
1140 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1141 eh_syms = elf_sym_hashes (abfd);
1142 sreloc = NULL;
1143 stubreloc = NULL;
1145 rela_end = relocs + sec->reloc_count;
1146 for (rela = relocs; rela < rela_end; rela++)
1148 enum {
1149 NEED_GOT = 1,
1150 NEED_PLT = 2,
1151 NEED_DYNREL = 4,
1152 PLT_PLABEL = 8
1155 unsigned int r_symndx, r_type;
1156 struct elf32_hppa_link_hash_entry *hh;
1157 int need_entry = 0;
1159 r_symndx = ELF32_R_SYM (rela->r_info);
1161 if (r_symndx < symtab_hdr->sh_info)
1162 hh = NULL;
1163 else
1165 hh = hppa_elf_hash_entry (eh_syms[r_symndx - symtab_hdr->sh_info]);
1166 while (hh->eh.root.type == bfd_link_hash_indirect
1167 || hh->eh.root.type == bfd_link_hash_warning)
1168 hh = hppa_elf_hash_entry (hh->eh.root.u.i.link);
1171 r_type = ELF32_R_TYPE (rela->r_info);
1172 r_type = elf32_hppa_optimized_tls_reloc (info, r_type, hh == NULL);
1174 switch (r_type)
1176 case R_PARISC_DLTIND14F:
1177 case R_PARISC_DLTIND14R:
1178 case R_PARISC_DLTIND21L:
1179 /* This symbol requires a global offset table entry. */
1180 need_entry = NEED_GOT;
1181 break;
1183 case R_PARISC_PLABEL14R: /* "Official" procedure labels. */
1184 case R_PARISC_PLABEL21L:
1185 case R_PARISC_PLABEL32:
1186 /* If the addend is non-zero, we break badly. */
1187 if (rela->r_addend != 0)
1188 abort ();
1190 /* If we are creating a shared library, then we need to
1191 create a PLT entry for all PLABELs, because PLABELs with
1192 local symbols may be passed via a pointer to another
1193 object. Additionally, output a dynamic relocation
1194 pointing to the PLT entry.
1196 For executables, the original 32-bit ABI allowed two
1197 different styles of PLABELs (function pointers): For
1198 global functions, the PLABEL word points into the .plt
1199 two bytes past a (function address, gp) pair, and for
1200 local functions the PLABEL points directly at the
1201 function. The magic +2 for the first type allows us to
1202 differentiate between the two. As you can imagine, this
1203 is a real pain when it comes to generating code to call
1204 functions indirectly or to compare function pointers.
1205 We avoid the mess by always pointing a PLABEL into the
1206 .plt, even for local functions. */
1207 need_entry = PLT_PLABEL | NEED_PLT | NEED_DYNREL;
1208 break;
1210 case R_PARISC_PCREL12F:
1211 htab->has_12bit_branch = 1;
1212 goto branch_common;
1214 case R_PARISC_PCREL17C:
1215 case R_PARISC_PCREL17F:
1216 htab->has_17bit_branch = 1;
1217 goto branch_common;
1219 case R_PARISC_PCREL22F:
1220 htab->has_22bit_branch = 1;
1221 branch_common:
1222 /* Function calls might need to go through the .plt, and
1223 might require long branch stubs. */
1224 if (hh == NULL)
1226 /* We know local syms won't need a .plt entry, and if
1227 they need a long branch stub we can't guarantee that
1228 we can reach the stub. So just flag an error later
1229 if we're doing a shared link and find we need a long
1230 branch stub. */
1231 continue;
1233 else
1235 /* Global symbols will need a .plt entry if they remain
1236 global, and in most cases won't need a long branch
1237 stub. Unfortunately, we have to cater for the case
1238 where a symbol is forced local by versioning, or due
1239 to symbolic linking, and we lose the .plt entry. */
1240 need_entry = NEED_PLT;
1241 if (hh->eh.type == STT_PARISC_MILLI)
1242 need_entry = 0;
1244 break;
1246 case R_PARISC_SEGBASE: /* Used to set segment base. */
1247 case R_PARISC_SEGREL32: /* Relative reloc, used for unwind. */
1248 case R_PARISC_PCREL14F: /* PC relative load/store. */
1249 case R_PARISC_PCREL14R:
1250 case R_PARISC_PCREL17R: /* External branches. */
1251 case R_PARISC_PCREL21L: /* As above, and for load/store too. */
1252 case R_PARISC_PCREL32:
1253 /* We don't need to propagate the relocation if linking a
1254 shared object since these are section relative. */
1255 continue;
1257 case R_PARISC_DPREL14F: /* Used for gp rel data load/store. */
1258 case R_PARISC_DPREL14R:
1259 case R_PARISC_DPREL21L:
1260 if (info->shared)
1262 (*_bfd_error_handler)
1263 (_("%B: relocation %s can not be used when making a shared object; recompile with -fPIC"),
1264 abfd,
1265 elf_hppa_howto_table[r_type].name);
1266 bfd_set_error (bfd_error_bad_value);
1267 return FALSE;
1269 /* Fall through. */
1271 case R_PARISC_DIR17F: /* Used for external branches. */
1272 case R_PARISC_DIR17R:
1273 case R_PARISC_DIR14F: /* Used for load/store from absolute locn. */
1274 case R_PARISC_DIR14R:
1275 case R_PARISC_DIR21L: /* As above, and for ext branches too. */
1276 case R_PARISC_DIR32: /* .word relocs. */
1277 /* We may want to output a dynamic relocation later. */
1278 need_entry = NEED_DYNREL;
1279 break;
1281 /* This relocation describes the C++ object vtable hierarchy.
1282 Reconstruct it for later use during GC. */
1283 case R_PARISC_GNU_VTINHERIT:
1284 if (!bfd_elf_gc_record_vtinherit (abfd, sec, &hh->eh, rela->r_offset))
1285 return FALSE;
1286 continue;
1288 /* This relocation describes which C++ vtable entries are actually
1289 used. Record for later use during GC. */
1290 case R_PARISC_GNU_VTENTRY:
1291 BFD_ASSERT (hh != NULL);
1292 if (hh != NULL
1293 && !bfd_elf_gc_record_vtentry (abfd, sec, &hh->eh, rela->r_addend))
1294 return FALSE;
1295 continue;
1297 case R_PARISC_TLS_GD21L:
1298 case R_PARISC_TLS_GD14R:
1299 case R_PARISC_TLS_LDM21L:
1300 case R_PARISC_TLS_LDM14R:
1301 need_entry = NEED_GOT;
1302 break;
1304 case R_PARISC_TLS_IE21L:
1305 case R_PARISC_TLS_IE14R:
1306 if (info->shared)
1307 info->flags |= DF_STATIC_TLS;
1308 need_entry = NEED_GOT;
1309 break;
1311 default:
1312 continue;
1315 /* Now carry out our orders. */
1316 if (need_entry & NEED_GOT)
1318 switch (r_type)
1320 default:
1321 tls_type = GOT_NORMAL;
1322 break;
1323 case R_PARISC_TLS_GD21L:
1324 case R_PARISC_TLS_GD14R:
1325 tls_type |= GOT_TLS_GD;
1326 break;
1327 case R_PARISC_TLS_LDM21L:
1328 case R_PARISC_TLS_LDM14R:
1329 tls_type |= GOT_TLS_LDM;
1330 break;
1331 case R_PARISC_TLS_IE21L:
1332 case R_PARISC_TLS_IE14R:
1333 tls_type |= GOT_TLS_IE;
1334 break;
1337 /* Allocate space for a GOT entry, as well as a dynamic
1338 relocation for this entry. */
1339 if (htab->sgot == NULL)
1341 if (htab->etab.dynobj == NULL)
1342 htab->etab.dynobj = abfd;
1343 if (!elf32_hppa_create_dynamic_sections (htab->etab.dynobj, info))
1344 return FALSE;
1347 if (r_type == R_PARISC_TLS_LDM21L
1348 || r_type == R_PARISC_TLS_LDM14R)
1349 hppa_link_hash_table (info)->tls_ldm_got.refcount += 1;
1350 else
1352 if (hh != NULL)
1354 hh->eh.got.refcount += 1;
1355 old_tls_type = hh->tls_type;
1357 else
1359 bfd_signed_vma *local_got_refcounts;
1361 /* This is a global offset table entry for a local symbol. */
1362 local_got_refcounts = elf_local_got_refcounts (abfd);
1363 if (local_got_refcounts == NULL)
1365 bfd_size_type size;
1367 /* Allocate space for local got offsets and local
1368 plt offsets. Done this way to save polluting
1369 elf_obj_tdata with another target specific
1370 pointer. */
1371 size = symtab_hdr->sh_info;
1372 size *= 2 * sizeof (bfd_signed_vma);
1373 /* Add in space to store the local GOT TLS types. */
1374 size += symtab_hdr->sh_info;
1375 local_got_refcounts = bfd_zalloc (abfd, size);
1376 if (local_got_refcounts == NULL)
1377 return FALSE;
1378 elf_local_got_refcounts (abfd) = local_got_refcounts;
1379 memset (hppa_elf_local_got_tls_type (abfd),
1380 GOT_UNKNOWN, symtab_hdr->sh_info);
1382 local_got_refcounts[r_symndx] += 1;
1384 old_tls_type = hppa_elf_local_got_tls_type (abfd) [r_symndx];
1387 tls_type |= old_tls_type;
1389 if (old_tls_type != tls_type)
1391 if (hh != NULL)
1392 hh->tls_type = tls_type;
1393 else
1394 hppa_elf_local_got_tls_type (abfd) [r_symndx] = tls_type;
1400 if (need_entry & NEED_PLT)
1402 /* If we are creating a shared library, and this is a reloc
1403 against a weak symbol or a global symbol in a dynamic
1404 object, then we will be creating an import stub and a
1405 .plt entry for the symbol. Similarly, on a normal link
1406 to symbols defined in a dynamic object we'll need the
1407 import stub and a .plt entry. We don't know yet whether
1408 the symbol is defined or not, so make an entry anyway and
1409 clean up later in adjust_dynamic_symbol. */
1410 if ((sec->flags & SEC_ALLOC) != 0)
1412 if (hh != NULL)
1414 hh->eh.needs_plt = 1;
1415 hh->eh.plt.refcount += 1;
1417 /* If this .plt entry is for a plabel, mark it so
1418 that adjust_dynamic_symbol will keep the entry
1419 even if it appears to be local. */
1420 if (need_entry & PLT_PLABEL)
1421 hh->plabel = 1;
1423 else if (need_entry & PLT_PLABEL)
1425 bfd_signed_vma *local_got_refcounts;
1426 bfd_signed_vma *local_plt_refcounts;
1428 local_got_refcounts = elf_local_got_refcounts (abfd);
1429 if (local_got_refcounts == NULL)
1431 bfd_size_type size;
1433 /* Allocate space for local got offsets and local
1434 plt offsets. */
1435 size = symtab_hdr->sh_info;
1436 size *= 2 * sizeof (bfd_signed_vma);
1437 /* Add in space to store the local GOT TLS types. */
1438 size += symtab_hdr->sh_info;
1439 local_got_refcounts = bfd_zalloc (abfd, size);
1440 if (local_got_refcounts == NULL)
1441 return FALSE;
1442 elf_local_got_refcounts (abfd) = local_got_refcounts;
1444 local_plt_refcounts = (local_got_refcounts
1445 + symtab_hdr->sh_info);
1446 local_plt_refcounts[r_symndx] += 1;
1451 if (need_entry & NEED_DYNREL)
1453 /* Flag this symbol as having a non-got, non-plt reference
1454 so that we generate copy relocs if it turns out to be
1455 dynamic. */
1456 if (hh != NULL && !info->shared)
1457 hh->eh.non_got_ref = 1;
1459 /* If we are creating a shared library then we need to copy
1460 the reloc into the shared library. However, if we are
1461 linking with -Bsymbolic, we need only copy absolute
1462 relocs or relocs against symbols that are not defined in
1463 an object we are including in the link. PC- or DP- or
1464 DLT-relative relocs against any local sym or global sym
1465 with DEF_REGULAR set, can be discarded. At this point we
1466 have not seen all the input files, so it is possible that
1467 DEF_REGULAR is not set now but will be set later (it is
1468 never cleared). We account for that possibility below by
1469 storing information in the dyn_relocs field of the
1470 hash table entry.
1472 A similar situation to the -Bsymbolic case occurs when
1473 creating shared libraries and symbol visibility changes
1474 render the symbol local.
1476 As it turns out, all the relocs we will be creating here
1477 are absolute, so we cannot remove them on -Bsymbolic
1478 links or visibility changes anyway. A STUB_REL reloc
1479 is absolute too, as in that case it is the reloc in the
1480 stub we will be creating, rather than copying the PCREL
1481 reloc in the branch.
1483 If on the other hand, we are creating an executable, we
1484 may need to keep relocations for symbols satisfied by a
1485 dynamic library if we manage to avoid copy relocs for the
1486 symbol. */
1487 if ((info->shared
1488 && (sec->flags & SEC_ALLOC) != 0
1489 && (IS_ABSOLUTE_RELOC (r_type)
1490 || (hh != NULL
1491 && (!info->symbolic
1492 || hh->eh.root.type == bfd_link_hash_defweak
1493 || !hh->eh.def_regular))))
1494 || (ELIMINATE_COPY_RELOCS
1495 && !info->shared
1496 && (sec->flags & SEC_ALLOC) != 0
1497 && hh != NULL
1498 && (hh->eh.root.type == bfd_link_hash_defweak
1499 || !hh->eh.def_regular)))
1501 struct elf32_hppa_dyn_reloc_entry *hdh_p;
1502 struct elf32_hppa_dyn_reloc_entry **hdh_head;
1504 /* Create a reloc section in dynobj and make room for
1505 this reloc. */
1506 if (sreloc == NULL)
1508 char *name;
1509 bfd *dynobj;
1511 name = (bfd_elf_string_from_elf_section
1512 (abfd,
1513 elf_elfheader (abfd)->e_shstrndx,
1514 elf_section_data (sec)->rel_hdr.sh_name));
1515 if (name == NULL)
1517 (*_bfd_error_handler)
1518 (_("Could not find relocation section for %s"),
1519 sec->name);
1520 bfd_set_error (bfd_error_bad_value);
1521 return FALSE;
1524 if (htab->etab.dynobj == NULL)
1525 htab->etab.dynobj = abfd;
1527 dynobj = htab->etab.dynobj;
1528 sreloc = bfd_get_section_by_name (dynobj, name);
1529 if (sreloc == NULL)
1531 flagword flags;
1533 flags = (SEC_HAS_CONTENTS | SEC_READONLY
1534 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1535 if ((sec->flags & SEC_ALLOC) != 0)
1536 flags |= SEC_ALLOC | SEC_LOAD;
1537 sreloc = bfd_make_section_with_flags (dynobj,
1538 name,
1539 flags);
1540 if (sreloc == NULL
1541 || !bfd_set_section_alignment (dynobj, sreloc, 2))
1542 return FALSE;
1545 elf_section_data (sec)->sreloc = sreloc;
1548 /* If this is a global symbol, we count the number of
1549 relocations we need for this symbol. */
1550 if (hh != NULL)
1552 hdh_head = &hh->dyn_relocs;
1554 else
1556 /* Track dynamic relocs needed for local syms too.
1557 We really need local syms available to do this
1558 easily. Oh well. */
1560 asection *sr;
1561 void *vpp;
1563 sr = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1564 sec, r_symndx);
1565 if (sr == NULL)
1566 return FALSE;
1568 vpp = &elf_section_data (sr)->local_dynrel;
1569 hdh_head = (struct elf32_hppa_dyn_reloc_entry **) vpp;
1572 hdh_p = *hdh_head;
1573 if (hdh_p == NULL || hdh_p->sec != sec)
1575 hdh_p = bfd_alloc (htab->etab.dynobj, sizeof *hdh_p);
1576 if (hdh_p == NULL)
1577 return FALSE;
1578 hdh_p->hdh_next = *hdh_head;
1579 *hdh_head = hdh_p;
1580 hdh_p->sec = sec;
1581 hdh_p->count = 0;
1582 #if RELATIVE_DYNRELOCS
1583 hdh_p->relative_count = 0;
1584 #endif
1587 hdh_p->count += 1;
1588 #if RELATIVE_DYNRELOCS
1589 if (!IS_ABSOLUTE_RELOC (rtype))
1590 hdh_p->relative_count += 1;
1591 #endif
1596 return TRUE;
1599 /* Return the section that should be marked against garbage collection
1600 for a given relocation. */
1602 static asection *
1603 elf32_hppa_gc_mark_hook (asection *sec,
1604 struct bfd_link_info *info,
1605 Elf_Internal_Rela *rela,
1606 struct elf_link_hash_entry *hh,
1607 Elf_Internal_Sym *sym)
1609 if (hh != NULL)
1610 switch ((unsigned int) ELF32_R_TYPE (rela->r_info))
1612 case R_PARISC_GNU_VTINHERIT:
1613 case R_PARISC_GNU_VTENTRY:
1614 return NULL;
1617 return _bfd_elf_gc_mark_hook (sec, info, rela, hh, sym);
1620 /* Update the got and plt entry reference counts for the section being
1621 removed. */
1623 static bfd_boolean
1624 elf32_hppa_gc_sweep_hook (bfd *abfd,
1625 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1626 asection *sec,
1627 const Elf_Internal_Rela *relocs)
1629 Elf_Internal_Shdr *symtab_hdr;
1630 struct elf_link_hash_entry **eh_syms;
1631 bfd_signed_vma *local_got_refcounts;
1632 bfd_signed_vma *local_plt_refcounts;
1633 const Elf_Internal_Rela *rela, *relend;
1635 if (info->relocatable)
1636 return TRUE;
1638 elf_section_data (sec)->local_dynrel = NULL;
1640 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1641 eh_syms = elf_sym_hashes (abfd);
1642 local_got_refcounts = elf_local_got_refcounts (abfd);
1643 local_plt_refcounts = local_got_refcounts;
1644 if (local_plt_refcounts != NULL)
1645 local_plt_refcounts += symtab_hdr->sh_info;
1647 relend = relocs + sec->reloc_count;
1648 for (rela = relocs; rela < relend; rela++)
1650 unsigned long r_symndx;
1651 unsigned int r_type;
1652 struct elf_link_hash_entry *eh = NULL;
1654 r_symndx = ELF32_R_SYM (rela->r_info);
1655 if (r_symndx >= symtab_hdr->sh_info)
1657 struct elf32_hppa_link_hash_entry *hh;
1658 struct elf32_hppa_dyn_reloc_entry **hdh_pp;
1659 struct elf32_hppa_dyn_reloc_entry *hdh_p;
1661 eh = eh_syms[r_symndx - symtab_hdr->sh_info];
1662 while (eh->root.type == bfd_link_hash_indirect
1663 || eh->root.type == bfd_link_hash_warning)
1664 eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
1665 hh = hppa_elf_hash_entry (eh);
1667 for (hdh_pp = &hh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; hdh_pp = &hdh_p->hdh_next)
1668 if (hdh_p->sec == sec)
1670 /* Everything must go for SEC. */
1671 *hdh_pp = hdh_p->hdh_next;
1672 break;
1676 r_type = ELF32_R_TYPE (rela->r_info);
1677 r_type = elf32_hppa_optimized_tls_reloc (info, r_type, eh != NULL);
1679 switch (r_type)
1681 case R_PARISC_DLTIND14F:
1682 case R_PARISC_DLTIND14R:
1683 case R_PARISC_DLTIND21L:
1684 case R_PARISC_TLS_GD21L:
1685 case R_PARISC_TLS_GD14R:
1686 case R_PARISC_TLS_IE21L:
1687 case R_PARISC_TLS_IE14R:
1688 if (eh != NULL)
1690 if (eh->got.refcount > 0)
1691 eh->got.refcount -= 1;
1693 else if (local_got_refcounts != NULL)
1695 if (local_got_refcounts[r_symndx] > 0)
1696 local_got_refcounts[r_symndx] -= 1;
1698 break;
1700 case R_PARISC_TLS_LDM21L:
1701 case R_PARISC_TLS_LDM14R:
1702 hppa_link_hash_table (info)->tls_ldm_got.refcount -= 1;
1703 break;
1705 case R_PARISC_PCREL12F:
1706 case R_PARISC_PCREL17C:
1707 case R_PARISC_PCREL17F:
1708 case R_PARISC_PCREL22F:
1709 if (eh != NULL)
1711 if (eh->plt.refcount > 0)
1712 eh->plt.refcount -= 1;
1714 break;
1716 case R_PARISC_PLABEL14R:
1717 case R_PARISC_PLABEL21L:
1718 case R_PARISC_PLABEL32:
1719 if (eh != NULL)
1721 if (eh->plt.refcount > 0)
1722 eh->plt.refcount -= 1;
1724 else if (local_plt_refcounts != NULL)
1726 if (local_plt_refcounts[r_symndx] > 0)
1727 local_plt_refcounts[r_symndx] -= 1;
1729 break;
1731 default:
1732 break;
1736 return TRUE;
1739 /* Support for core dump NOTE sections. */
1741 static bfd_boolean
1742 elf32_hppa_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1744 int offset;
1745 size_t size;
1747 switch (note->descsz)
1749 default:
1750 return FALSE;
1752 case 396: /* Linux/hppa */
1753 /* pr_cursig */
1754 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
1756 /* pr_pid */
1757 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
1759 /* pr_reg */
1760 offset = 72;
1761 size = 320;
1763 break;
1766 /* Make a ".reg/999" section. */
1767 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1768 size, note->descpos + offset);
1771 static bfd_boolean
1772 elf32_hppa_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
1774 switch (note->descsz)
1776 default:
1777 return FALSE;
1779 case 124: /* Linux/hppa elf_prpsinfo. */
1780 elf_tdata (abfd)->core_program
1781 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
1782 elf_tdata (abfd)->core_command
1783 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
1786 /* Note that for some reason, a spurious space is tacked
1787 onto the end of the args in some (at least one anyway)
1788 implementations, so strip it off if it exists. */
1790 char *command = elf_tdata (abfd)->core_command;
1791 int n = strlen (command);
1793 if (0 < n && command[n - 1] == ' ')
1794 command[n - 1] = '\0';
1797 return TRUE;
1800 /* Our own version of hide_symbol, so that we can keep plt entries for
1801 plabels. */
1803 static void
1804 elf32_hppa_hide_symbol (struct bfd_link_info *info,
1805 struct elf_link_hash_entry *eh,
1806 bfd_boolean force_local)
1808 if (force_local)
1810 eh->forced_local = 1;
1811 if (eh->dynindx != -1)
1813 eh->dynindx = -1;
1814 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1815 eh->dynstr_index);
1819 if (! hppa_elf_hash_entry (eh)->plabel)
1821 eh->needs_plt = 0;
1822 eh->plt = elf_hash_table (info)->init_plt_refcount;
1826 /* Adjust a symbol defined by a dynamic object and referenced by a
1827 regular object. The current definition is in some section of the
1828 dynamic object, but we're not including those sections. We have to
1829 change the definition to something the rest of the link can
1830 understand. */
1832 static bfd_boolean
1833 elf32_hppa_adjust_dynamic_symbol (struct bfd_link_info *info,
1834 struct elf_link_hash_entry *eh)
1836 struct elf32_hppa_link_hash_table *htab;
1837 asection *sec;
1839 /* If this is a function, put it in the procedure linkage table. We
1840 will fill in the contents of the procedure linkage table later. */
1841 if (eh->type == STT_FUNC
1842 || eh->needs_plt)
1844 if (eh->plt.refcount <= 0
1845 || (eh->def_regular
1846 && eh->root.type != bfd_link_hash_defweak
1847 && ! hppa_elf_hash_entry (eh)->plabel
1848 && (!info->shared || info->symbolic)))
1850 /* The .plt entry is not needed when:
1851 a) Garbage collection has removed all references to the
1852 symbol, or
1853 b) We know for certain the symbol is defined in this
1854 object, and it's not a weak definition, nor is the symbol
1855 used by a plabel relocation. Either this object is the
1856 application or we are doing a shared symbolic link. */
1858 eh->plt.offset = (bfd_vma) -1;
1859 eh->needs_plt = 0;
1862 return TRUE;
1864 else
1865 eh->plt.offset = (bfd_vma) -1;
1867 /* If this is a weak symbol, and there is a real definition, the
1868 processor independent code will have arranged for us to see the
1869 real definition first, and we can just use the same value. */
1870 if (eh->u.weakdef != NULL)
1872 if (eh->u.weakdef->root.type != bfd_link_hash_defined
1873 && eh->u.weakdef->root.type != bfd_link_hash_defweak)
1874 abort ();
1875 eh->root.u.def.section = eh->u.weakdef->root.u.def.section;
1876 eh->root.u.def.value = eh->u.weakdef->root.u.def.value;
1877 if (ELIMINATE_COPY_RELOCS)
1878 eh->non_got_ref = eh->u.weakdef->non_got_ref;
1879 return TRUE;
1882 /* This is a reference to a symbol defined by a dynamic object which
1883 is not a function. */
1885 /* If we are creating a shared library, we must presume that the
1886 only references to the symbol are via the global offset table.
1887 For such cases we need not do anything here; the relocations will
1888 be handled correctly by relocate_section. */
1889 if (info->shared)
1890 return TRUE;
1892 /* If there are no references to this symbol that do not use the
1893 GOT, we don't need to generate a copy reloc. */
1894 if (!eh->non_got_ref)
1895 return TRUE;
1897 if (ELIMINATE_COPY_RELOCS)
1899 struct elf32_hppa_link_hash_entry *hh;
1900 struct elf32_hppa_dyn_reloc_entry *hdh_p;
1902 hh = hppa_elf_hash_entry (eh);
1903 for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->hdh_next)
1905 sec = hdh_p->sec->output_section;
1906 if (sec != NULL && (sec->flags & SEC_READONLY) != 0)
1907 break;
1910 /* If we didn't find any dynamic relocs in read-only sections, then
1911 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1912 if (hdh_p == NULL)
1914 eh->non_got_ref = 0;
1915 return TRUE;
1919 if (eh->size == 0)
1921 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1922 eh->root.root.string);
1923 return TRUE;
1926 /* We must allocate the symbol in our .dynbss section, which will
1927 become part of the .bss section of the executable. There will be
1928 an entry for this symbol in the .dynsym section. The dynamic
1929 object will contain position independent code, so all references
1930 from the dynamic object to this symbol will go through the global
1931 offset table. The dynamic linker will use the .dynsym entry to
1932 determine the address it must put in the global offset table, so
1933 both the dynamic object and the regular object will refer to the
1934 same memory location for the variable. */
1936 htab = hppa_link_hash_table (info);
1938 /* We must generate a COPY reloc to tell the dynamic linker to
1939 copy the initial value out of the dynamic object and into the
1940 runtime process image. */
1941 if ((eh->root.u.def.section->flags & SEC_ALLOC) != 0)
1943 htab->srelbss->size += sizeof (Elf32_External_Rela);
1944 eh->needs_copy = 1;
1947 sec = htab->sdynbss;
1949 return _bfd_elf_adjust_dynamic_copy (eh, sec);
1952 /* Allocate space in the .plt for entries that won't have relocations.
1953 ie. plabel entries. */
1955 static bfd_boolean
1956 allocate_plt_static (struct elf_link_hash_entry *eh, void *inf)
1958 struct bfd_link_info *info;
1959 struct elf32_hppa_link_hash_table *htab;
1960 struct elf32_hppa_link_hash_entry *hh;
1961 asection *sec;
1963 if (eh->root.type == bfd_link_hash_indirect)
1964 return TRUE;
1966 if (eh->root.type == bfd_link_hash_warning)
1967 eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
1969 info = (struct bfd_link_info *) inf;
1970 hh = hppa_elf_hash_entry (eh);
1971 htab = hppa_link_hash_table (info);
1972 if (htab->etab.dynamic_sections_created
1973 && eh->plt.refcount > 0)
1975 /* Make sure this symbol is output as a dynamic symbol.
1976 Undefined weak syms won't yet be marked as dynamic. */
1977 if (eh->dynindx == -1
1978 && !eh->forced_local
1979 && eh->type != STT_PARISC_MILLI)
1981 if (! bfd_elf_link_record_dynamic_symbol (info, eh))
1982 return FALSE;
1985 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, eh))
1987 /* Allocate these later. From this point on, h->plabel
1988 means that the plt entry is only used by a plabel.
1989 We'll be using a normal plt entry for this symbol, so
1990 clear the plabel indicator. */
1992 hh->plabel = 0;
1994 else if (hh->plabel)
1996 /* Make an entry in the .plt section for plabel references
1997 that won't have a .plt entry for other reasons. */
1998 sec = htab->splt;
1999 eh->plt.offset = sec->size;
2000 sec->size += PLT_ENTRY_SIZE;
2002 else
2004 /* No .plt entry needed. */
2005 eh->plt.offset = (bfd_vma) -1;
2006 eh->needs_plt = 0;
2009 else
2011 eh->plt.offset = (bfd_vma) -1;
2012 eh->needs_plt = 0;
2015 return TRUE;
2018 /* Allocate space in .plt, .got and associated reloc sections for
2019 global syms. */
2021 static bfd_boolean
2022 allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
2024 struct bfd_link_info *info;
2025 struct elf32_hppa_link_hash_table *htab;
2026 asection *sec;
2027 struct elf32_hppa_link_hash_entry *hh;
2028 struct elf32_hppa_dyn_reloc_entry *hdh_p;
2030 if (eh->root.type == bfd_link_hash_indirect)
2031 return TRUE;
2033 if (eh->root.type == bfd_link_hash_warning)
2034 eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
2036 info = inf;
2037 htab = hppa_link_hash_table (info);
2038 hh = hppa_elf_hash_entry (eh);
2040 if (htab->etab.dynamic_sections_created
2041 && eh->plt.offset != (bfd_vma) -1
2042 && !hh->plabel
2043 && eh->plt.refcount > 0)
2045 /* Make an entry in the .plt section. */
2046 sec = htab->splt;
2047 eh->plt.offset = sec->size;
2048 sec->size += PLT_ENTRY_SIZE;
2050 /* We also need to make an entry in the .rela.plt section. */
2051 htab->srelplt->size += sizeof (Elf32_External_Rela);
2052 htab->need_plt_stub = 1;
2055 if (eh->got.refcount > 0)
2057 /* Make sure this symbol is output as a dynamic symbol.
2058 Undefined weak syms won't yet be marked as dynamic. */
2059 if (eh->dynindx == -1
2060 && !eh->forced_local
2061 && eh->type != STT_PARISC_MILLI)
2063 if (! bfd_elf_link_record_dynamic_symbol (info, eh))
2064 return FALSE;
2067 sec = htab->sgot;
2068 eh->got.offset = sec->size;
2069 sec->size += GOT_ENTRY_SIZE;
2070 /* R_PARISC_TLS_GD* needs two GOT entries */
2071 if ((hh->tls_type & (GOT_TLS_GD | GOT_TLS_IE)) == (GOT_TLS_GD | GOT_TLS_IE))
2072 sec->size += GOT_ENTRY_SIZE * 2;
2073 else if ((hh->tls_type & GOT_TLS_GD) == GOT_TLS_GD)
2074 sec->size += GOT_ENTRY_SIZE;
2075 if (htab->etab.dynamic_sections_created
2076 && (info->shared
2077 || (eh->dynindx != -1
2078 && !eh->forced_local)))
2080 htab->srelgot->size += sizeof (Elf32_External_Rela);
2081 if ((hh->tls_type & (GOT_TLS_GD | GOT_TLS_IE)) == (GOT_TLS_GD | GOT_TLS_IE))
2082 htab->srelgot->size += 2 * sizeof (Elf32_External_Rela);
2083 else if ((hh->tls_type & GOT_TLS_GD) == GOT_TLS_GD)
2084 htab->srelgot->size += sizeof (Elf32_External_Rela);
2087 else
2088 eh->got.offset = (bfd_vma) -1;
2090 if (hh->dyn_relocs == NULL)
2091 return TRUE;
2093 /* If this is a -Bsymbolic shared link, then we need to discard all
2094 space allocated for dynamic pc-relative relocs against symbols
2095 defined in a regular object. For the normal shared case, discard
2096 space for relocs that have become local due to symbol visibility
2097 changes. */
2098 if (info->shared)
2100 #if RELATIVE_DYNRELOCS
2101 if (SYMBOL_CALLS_LOCAL (info, eh))
2103 struct elf32_hppa_dyn_reloc_entry **hdh_pp;
2105 for (hdh_pp = &hh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
2107 hdh_p->count -= hdh_p->relative_count;
2108 hdh_p->relative_count = 0;
2109 if (hdh_p->count == 0)
2110 *hdh_pp = hdh_p->hdh_next;
2111 else
2112 hdh_pp = &hdh_p->hdh_next;
2115 #endif
2117 /* Also discard relocs on undefined weak syms with non-default
2118 visibility. */
2119 if (hh->dyn_relocs != NULL
2120 && eh->root.type == bfd_link_hash_undefweak)
2122 if (ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT)
2123 hh->dyn_relocs = NULL;
2125 /* Make sure undefined weak symbols are output as a dynamic
2126 symbol in PIEs. */
2127 else if (eh->dynindx == -1
2128 && !eh->forced_local)
2130 if (! bfd_elf_link_record_dynamic_symbol (info, eh))
2131 return FALSE;
2135 else
2137 /* For the non-shared case, discard space for relocs against
2138 symbols which turn out to need copy relocs or are not
2139 dynamic. */
2141 if (!eh->non_got_ref
2142 && ((ELIMINATE_COPY_RELOCS
2143 && eh->def_dynamic
2144 && !eh->def_regular)
2145 || (htab->etab.dynamic_sections_created
2146 && (eh->root.type == bfd_link_hash_undefweak
2147 || eh->root.type == bfd_link_hash_undefined))))
2149 /* Make sure this symbol is output as a dynamic symbol.
2150 Undefined weak syms won't yet be marked as dynamic. */
2151 if (eh->dynindx == -1
2152 && !eh->forced_local
2153 && eh->type != STT_PARISC_MILLI)
2155 if (! bfd_elf_link_record_dynamic_symbol (info, eh))
2156 return FALSE;
2159 /* If that succeeded, we know we'll be keeping all the
2160 relocs. */
2161 if (eh->dynindx != -1)
2162 goto keep;
2165 hh->dyn_relocs = NULL;
2166 return TRUE;
2168 keep: ;
2171 /* Finally, allocate space. */
2172 for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->hdh_next)
2174 asection *sreloc = elf_section_data (hdh_p->sec)->sreloc;
2175 sreloc->size += hdh_p->count * sizeof (Elf32_External_Rela);
2178 return TRUE;
2181 /* This function is called via elf_link_hash_traverse to force
2182 millicode symbols local so they do not end up as globals in the
2183 dynamic symbol table. We ought to be able to do this in
2184 adjust_dynamic_symbol, but our adjust_dynamic_symbol is not called
2185 for all dynamic symbols. Arguably, this is a bug in
2186 elf_adjust_dynamic_symbol. */
2188 static bfd_boolean
2189 clobber_millicode_symbols (struct elf_link_hash_entry *eh,
2190 struct bfd_link_info *info)
2192 if (eh->root.type == bfd_link_hash_warning)
2193 eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
2195 if (eh->type == STT_PARISC_MILLI
2196 && !eh->forced_local)
2198 elf32_hppa_hide_symbol (info, eh, TRUE);
2200 return TRUE;
2203 /* Find any dynamic relocs that apply to read-only sections. */
2205 static bfd_boolean
2206 readonly_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
2208 struct elf32_hppa_link_hash_entry *hh;
2209 struct elf32_hppa_dyn_reloc_entry *hdh_p;
2211 if (eh->root.type == bfd_link_hash_warning)
2212 eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
2214 hh = hppa_elf_hash_entry (eh);
2215 for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->hdh_next)
2217 asection *sec = hdh_p->sec->output_section;
2219 if (sec != NULL && (sec->flags & SEC_READONLY) != 0)
2221 struct bfd_link_info *info = inf;
2223 info->flags |= DF_TEXTREL;
2225 /* Not an error, just cut short the traversal. */
2226 return FALSE;
2229 return TRUE;
2232 /* Set the sizes of the dynamic sections. */
2234 static bfd_boolean
2235 elf32_hppa_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2236 struct bfd_link_info *info)
2238 struct elf32_hppa_link_hash_table *htab;
2239 bfd *dynobj;
2240 bfd *ibfd;
2241 asection *sec;
2242 bfd_boolean relocs;
2244 htab = hppa_link_hash_table (info);
2245 dynobj = htab->etab.dynobj;
2246 if (dynobj == NULL)
2247 abort ();
2249 if (htab->etab.dynamic_sections_created)
2251 /* Set the contents of the .interp section to the interpreter. */
2252 if (info->executable)
2254 sec = bfd_get_section_by_name (dynobj, ".interp");
2255 if (sec == NULL)
2256 abort ();
2257 sec->size = sizeof ELF_DYNAMIC_INTERPRETER;
2258 sec->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2261 /* Force millicode symbols local. */
2262 elf_link_hash_traverse (&htab->etab,
2263 clobber_millicode_symbols,
2264 info);
2267 /* Set up .got and .plt offsets for local syms, and space for local
2268 dynamic relocs. */
2269 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2271 bfd_signed_vma *local_got;
2272 bfd_signed_vma *end_local_got;
2273 bfd_signed_vma *local_plt;
2274 bfd_signed_vma *end_local_plt;
2275 bfd_size_type locsymcount;
2276 Elf_Internal_Shdr *symtab_hdr;
2277 asection *srel;
2278 char *local_tls_type;
2280 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2281 continue;
2283 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
2285 struct elf32_hppa_dyn_reloc_entry *hdh_p;
2287 for (hdh_p = ((struct elf32_hppa_dyn_reloc_entry *)
2288 elf_section_data (sec)->local_dynrel);
2289 hdh_p != NULL;
2290 hdh_p = hdh_p->hdh_next)
2292 if (!bfd_is_abs_section (hdh_p->sec)
2293 && bfd_is_abs_section (hdh_p->sec->output_section))
2295 /* Input section has been discarded, either because
2296 it is a copy of a linkonce section or due to
2297 linker script /DISCARD/, so we'll be discarding
2298 the relocs too. */
2300 else if (hdh_p->count != 0)
2302 srel = elf_section_data (hdh_p->sec)->sreloc;
2303 srel->size += hdh_p->count * sizeof (Elf32_External_Rela);
2304 if ((hdh_p->sec->output_section->flags & SEC_READONLY) != 0)
2305 info->flags |= DF_TEXTREL;
2310 local_got = elf_local_got_refcounts (ibfd);
2311 if (!local_got)
2312 continue;
2314 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2315 locsymcount = symtab_hdr->sh_info;
2316 end_local_got = local_got + locsymcount;
2317 local_tls_type = hppa_elf_local_got_tls_type (ibfd);
2318 sec = htab->sgot;
2319 srel = htab->srelgot;
2320 for (; local_got < end_local_got; ++local_got)
2322 if (*local_got > 0)
2324 *local_got = sec->size;
2325 sec->size += GOT_ENTRY_SIZE;
2326 if ((*local_tls_type & (GOT_TLS_GD | GOT_TLS_IE)) == (GOT_TLS_GD | GOT_TLS_IE))
2327 sec->size += 2 * GOT_ENTRY_SIZE;
2328 else if ((*local_tls_type & GOT_TLS_GD) == GOT_TLS_GD)
2329 sec->size += GOT_ENTRY_SIZE;
2330 if (info->shared)
2332 srel->size += sizeof (Elf32_External_Rela);
2333 if ((*local_tls_type & (GOT_TLS_GD | GOT_TLS_IE)) == (GOT_TLS_GD | GOT_TLS_IE))
2334 srel->size += 2 * sizeof (Elf32_External_Rela);
2335 else if ((*local_tls_type & GOT_TLS_GD) == GOT_TLS_GD)
2336 srel->size += sizeof (Elf32_External_Rela);
2339 else
2340 *local_got = (bfd_vma) -1;
2342 ++local_tls_type;
2345 local_plt = end_local_got;
2346 end_local_plt = local_plt + locsymcount;
2347 if (! htab->etab.dynamic_sections_created)
2349 /* Won't be used, but be safe. */
2350 for (; local_plt < end_local_plt; ++local_plt)
2351 *local_plt = (bfd_vma) -1;
2353 else
2355 sec = htab->splt;
2356 srel = htab->srelplt;
2357 for (; local_plt < end_local_plt; ++local_plt)
2359 if (*local_plt > 0)
2361 *local_plt = sec->size;
2362 sec->size += PLT_ENTRY_SIZE;
2363 if (info->shared)
2364 srel->size += sizeof (Elf32_External_Rela);
2366 else
2367 *local_plt = (bfd_vma) -1;
2372 if (htab->tls_ldm_got.refcount > 0)
2374 /* Allocate 2 got entries and 1 dynamic reloc for
2375 R_PARISC_TLS_DTPMOD32 relocs. */
2376 htab->tls_ldm_got.offset = htab->sgot->size;
2377 htab->sgot->size += (GOT_ENTRY_SIZE * 2);
2378 htab->srelgot->size += sizeof (Elf32_External_Rela);
2380 else
2381 htab->tls_ldm_got.offset = -1;
2383 /* Do all the .plt entries without relocs first. The dynamic linker
2384 uses the last .plt reloc to find the end of the .plt (and hence
2385 the start of the .got) for lazy linking. */
2386 elf_link_hash_traverse (&htab->etab, allocate_plt_static, info);
2388 /* Allocate global sym .plt and .got entries, and space for global
2389 sym dynamic relocs. */
2390 elf_link_hash_traverse (&htab->etab, allocate_dynrelocs, info);
2392 /* The check_relocs and adjust_dynamic_symbol entry points have
2393 determined the sizes of the various dynamic sections. Allocate
2394 memory for them. */
2395 relocs = FALSE;
2396 for (sec = dynobj->sections; sec != NULL; sec = sec->next)
2398 if ((sec->flags & SEC_LINKER_CREATED) == 0)
2399 continue;
2401 if (sec == htab->splt)
2403 if (htab->need_plt_stub)
2405 /* Make space for the plt stub at the end of the .plt
2406 section. We want this stub right at the end, up
2407 against the .got section. */
2408 int gotalign = bfd_section_alignment (dynobj, htab->sgot);
2409 int pltalign = bfd_section_alignment (dynobj, sec);
2410 bfd_size_type mask;
2412 if (gotalign > pltalign)
2413 bfd_set_section_alignment (dynobj, sec, gotalign);
2414 mask = ((bfd_size_type) 1 << gotalign) - 1;
2415 sec->size = (sec->size + sizeof (plt_stub) + mask) & ~mask;
2418 else if (sec == htab->sgot
2419 || sec == htab->sdynbss)
2421 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, sec), ".rela"))
2423 if (sec->size != 0)
2425 /* Remember whether there are any reloc sections other
2426 than .rela.plt. */
2427 if (sec != htab->srelplt)
2428 relocs = TRUE;
2430 /* We use the reloc_count field as a counter if we need
2431 to copy relocs into the output file. */
2432 sec->reloc_count = 0;
2435 else
2437 /* It's not one of our sections, so don't allocate space. */
2438 continue;
2441 if (sec->size == 0)
2443 /* If we don't need this section, strip it from the
2444 output file. This is mostly to handle .rela.bss and
2445 .rela.plt. We must create both sections in
2446 create_dynamic_sections, because they must be created
2447 before the linker maps input sections to output
2448 sections. The linker does that before
2449 adjust_dynamic_symbol is called, and it is that
2450 function which decides whether anything needs to go
2451 into these sections. */
2452 sec->flags |= SEC_EXCLUDE;
2453 continue;
2456 if ((sec->flags & SEC_HAS_CONTENTS) == 0)
2457 continue;
2459 /* Allocate memory for the section contents. Zero it, because
2460 we may not fill in all the reloc sections. */
2461 sec->contents = bfd_zalloc (dynobj, sec->size);
2462 if (sec->contents == NULL)
2463 return FALSE;
2466 if (htab->etab.dynamic_sections_created)
2468 /* Like IA-64 and HPPA64, always create a DT_PLTGOT. It
2469 actually has nothing to do with the PLT, it is how we
2470 communicate the LTP value of a load module to the dynamic
2471 linker. */
2472 #define add_dynamic_entry(TAG, VAL) \
2473 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2475 if (!add_dynamic_entry (DT_PLTGOT, 0))
2476 return FALSE;
2478 /* Add some entries to the .dynamic section. We fill in the
2479 values later, in elf32_hppa_finish_dynamic_sections, but we
2480 must add the entries now so that we get the correct size for
2481 the .dynamic section. The DT_DEBUG entry is filled in by the
2482 dynamic linker and used by the debugger. */
2483 if (info->executable)
2485 if (!add_dynamic_entry (DT_DEBUG, 0))
2486 return FALSE;
2489 if (htab->srelplt->size != 0)
2491 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
2492 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2493 || !add_dynamic_entry (DT_JMPREL, 0))
2494 return FALSE;
2497 if (relocs)
2499 if (!add_dynamic_entry (DT_RELA, 0)
2500 || !add_dynamic_entry (DT_RELASZ, 0)
2501 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
2502 return FALSE;
2504 /* If any dynamic relocs apply to a read-only section,
2505 then we need a DT_TEXTREL entry. */
2506 if ((info->flags & DF_TEXTREL) == 0)
2507 elf_link_hash_traverse (&htab->etab, readonly_dynrelocs, info);
2509 if ((info->flags & DF_TEXTREL) != 0)
2511 if (!add_dynamic_entry (DT_TEXTREL, 0))
2512 return FALSE;
2516 #undef add_dynamic_entry
2518 return TRUE;
2521 /* External entry points for sizing and building linker stubs. */
2523 /* Set up various things so that we can make a list of input sections
2524 for each output section included in the link. Returns -1 on error,
2525 0 when no stubs will be needed, and 1 on success. */
2528 elf32_hppa_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info)
2530 bfd *input_bfd;
2531 unsigned int bfd_count;
2532 int top_id, top_index;
2533 asection *section;
2534 asection **input_list, **list;
2535 bfd_size_type amt;
2536 struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
2538 /* Count the number of input BFDs and find the top input section id. */
2539 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
2540 input_bfd != NULL;
2541 input_bfd = input_bfd->link_next)
2543 bfd_count += 1;
2544 for (section = input_bfd->sections;
2545 section != NULL;
2546 section = section->next)
2548 if (top_id < section->id)
2549 top_id = section->id;
2552 htab->bfd_count = bfd_count;
2554 amt = sizeof (struct map_stub) * (top_id + 1);
2555 htab->stub_group = bfd_zmalloc (amt);
2556 if (htab->stub_group == NULL)
2557 return -1;
2559 /* We can't use output_bfd->section_count here to find the top output
2560 section index as some sections may have been removed, and
2561 strip_excluded_output_sections doesn't renumber the indices. */
2562 for (section = output_bfd->sections, top_index = 0;
2563 section != NULL;
2564 section = section->next)
2566 if (top_index < section->index)
2567 top_index = section->index;
2570 htab->top_index = top_index;
2571 amt = sizeof (asection *) * (top_index + 1);
2572 input_list = bfd_malloc (amt);
2573 htab->input_list = input_list;
2574 if (input_list == NULL)
2575 return -1;
2577 /* For sections we aren't interested in, mark their entries with a
2578 value we can check later. */
2579 list = input_list + top_index;
2581 *list = bfd_abs_section_ptr;
2582 while (list-- != input_list);
2584 for (section = output_bfd->sections;
2585 section != NULL;
2586 section = section->next)
2588 if ((section->flags & SEC_CODE) != 0)
2589 input_list[section->index] = NULL;
2592 return 1;
2595 /* The linker repeatedly calls this function for each input section,
2596 in the order that input sections are linked into output sections.
2597 Build lists of input sections to determine groupings between which
2598 we may insert linker stubs. */
2600 void
2601 elf32_hppa_next_input_section (struct bfd_link_info *info, asection *isec)
2603 struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
2605 if (isec->output_section->index <= htab->top_index)
2607 asection **list = htab->input_list + isec->output_section->index;
2608 if (*list != bfd_abs_section_ptr)
2610 /* Steal the link_sec pointer for our list. */
2611 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
2612 /* This happens to make the list in reverse order,
2613 which is what we want. */
2614 PREV_SEC (isec) = *list;
2615 *list = isec;
2620 /* See whether we can group stub sections together. Grouping stub
2621 sections may result in fewer stubs. More importantly, we need to
2622 put all .init* and .fini* stubs at the beginning of the .init or
2623 .fini output sections respectively, because glibc splits the
2624 _init and _fini functions into multiple parts. Putting a stub in
2625 the middle of a function is not a good idea. */
2627 static void
2628 group_sections (struct elf32_hppa_link_hash_table *htab,
2629 bfd_size_type stub_group_size,
2630 bfd_boolean stubs_always_before_branch)
2632 asection **list = htab->input_list + htab->top_index;
2635 asection *tail = *list;
2636 if (tail == bfd_abs_section_ptr)
2637 continue;
2638 while (tail != NULL)
2640 asection *curr;
2641 asection *prev;
2642 bfd_size_type total;
2643 bfd_boolean big_sec;
2645 curr = tail;
2646 total = tail->size;
2647 big_sec = total >= stub_group_size;
2649 while ((prev = PREV_SEC (curr)) != NULL
2650 && ((total += curr->output_offset - prev->output_offset)
2651 < stub_group_size))
2652 curr = prev;
2654 /* OK, the size from the start of CURR to the end is less
2655 than 240000 bytes and thus can be handled by one stub
2656 section. (or the tail section is itself larger than
2657 240000 bytes, in which case we may be toast.)
2658 We should really be keeping track of the total size of
2659 stubs added here, as stubs contribute to the final output
2660 section size. That's a little tricky, and this way will
2661 only break if stubs added total more than 22144 bytes, or
2662 2768 long branch stubs. It seems unlikely for more than
2663 2768 different functions to be called, especially from
2664 code only 240000 bytes long. This limit used to be
2665 250000, but c++ code tends to generate lots of little
2666 functions, and sometimes violated the assumption. */
2669 prev = PREV_SEC (tail);
2670 /* Set up this stub group. */
2671 htab->stub_group[tail->id].link_sec = curr;
2673 while (tail != curr && (tail = prev) != NULL);
2675 /* But wait, there's more! Input sections up to 240000
2676 bytes before the stub section can be handled by it too.
2677 Don't do this if we have a really large section after the
2678 stubs, as adding more stubs increases the chance that
2679 branches may not reach into the stub section. */
2680 if (!stubs_always_before_branch && !big_sec)
2682 total = 0;
2683 while (prev != NULL
2684 && ((total += tail->output_offset - prev->output_offset)
2685 < stub_group_size))
2687 tail = prev;
2688 prev = PREV_SEC (tail);
2689 htab->stub_group[tail->id].link_sec = curr;
2692 tail = prev;
2695 while (list-- != htab->input_list);
2696 free (htab->input_list);
2697 #undef PREV_SEC
2700 /* Read in all local syms for all input bfds, and create hash entries
2701 for export stubs if we are building a multi-subspace shared lib.
2702 Returns -1 on error, 1 if export stubs created, 0 otherwise. */
2704 static int
2705 get_local_syms (bfd *output_bfd, bfd *input_bfd, struct bfd_link_info *info)
2707 unsigned int bfd_indx;
2708 Elf_Internal_Sym *local_syms, **all_local_syms;
2709 int stub_changed = 0;
2710 struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
2712 /* We want to read in symbol extension records only once. To do this
2713 we need to read in the local symbols in parallel and save them for
2714 later use; so hold pointers to the local symbols in an array. */
2715 bfd_size_type amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
2716 all_local_syms = bfd_zmalloc (amt);
2717 htab->all_local_syms = all_local_syms;
2718 if (all_local_syms == NULL)
2719 return -1;
2721 /* Walk over all the input BFDs, swapping in local symbols.
2722 If we are creating a shared library, create hash entries for the
2723 export stubs. */
2724 for (bfd_indx = 0;
2725 input_bfd != NULL;
2726 input_bfd = input_bfd->link_next, bfd_indx++)
2728 Elf_Internal_Shdr *symtab_hdr;
2730 /* We'll need the symbol table in a second. */
2731 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2732 if (symtab_hdr->sh_info == 0)
2733 continue;
2735 /* We need an array of the local symbols attached to the input bfd. */
2736 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
2737 if (local_syms == NULL)
2739 local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2740 symtab_hdr->sh_info, 0,
2741 NULL, NULL, NULL);
2742 /* Cache them for elf_link_input_bfd. */
2743 symtab_hdr->contents = (unsigned char *) local_syms;
2745 if (local_syms == NULL)
2746 return -1;
2748 all_local_syms[bfd_indx] = local_syms;
2750 if (info->shared && htab->multi_subspace)
2752 struct elf_link_hash_entry **eh_syms;
2753 struct elf_link_hash_entry **eh_symend;
2754 unsigned int symcount;
2756 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2757 - symtab_hdr->sh_info);
2758 eh_syms = (struct elf_link_hash_entry **) elf_sym_hashes (input_bfd);
2759 eh_symend = (struct elf_link_hash_entry **) (eh_syms + symcount);
2761 /* Look through the global syms for functions; We need to
2762 build export stubs for all globally visible functions. */
2763 for (; eh_syms < eh_symend; eh_syms++)
2765 struct elf32_hppa_link_hash_entry *hh;
2767 hh = hppa_elf_hash_entry (*eh_syms);
2769 while (hh->eh.root.type == bfd_link_hash_indirect
2770 || hh->eh.root.type == bfd_link_hash_warning)
2771 hh = hppa_elf_hash_entry (hh->eh.root.u.i.link);
2773 /* At this point in the link, undefined syms have been
2774 resolved, so we need to check that the symbol was
2775 defined in this BFD. */
2776 if ((hh->eh.root.type == bfd_link_hash_defined
2777 || hh->eh.root.type == bfd_link_hash_defweak)
2778 && hh->eh.type == STT_FUNC
2779 && hh->eh.root.u.def.section->output_section != NULL
2780 && (hh->eh.root.u.def.section->output_section->owner
2781 == output_bfd)
2782 && hh->eh.root.u.def.section->owner == input_bfd
2783 && hh->eh.def_regular
2784 && !hh->eh.forced_local
2785 && ELF_ST_VISIBILITY (hh->eh.other) == STV_DEFAULT)
2787 asection *sec;
2788 const char *stub_name;
2789 struct elf32_hppa_stub_hash_entry *hsh;
2791 sec = hh->eh.root.u.def.section;
2792 stub_name = hh_name (hh);
2793 hsh = hppa_stub_hash_lookup (&htab->bstab,
2794 stub_name,
2795 FALSE, FALSE);
2796 if (hsh == NULL)
2798 hsh = hppa_add_stub (stub_name, sec, htab);
2799 if (!hsh)
2800 return -1;
2802 hsh->target_value = hh->eh.root.u.def.value;
2803 hsh->target_section = hh->eh.root.u.def.section;
2804 hsh->stub_type = hppa_stub_export;
2805 hsh->hh = hh;
2806 stub_changed = 1;
2808 else
2810 (*_bfd_error_handler) (_("%B: duplicate export stub %s"),
2811 input_bfd,
2812 stub_name);
2819 return stub_changed;
2822 /* Determine and set the size of the stub section for a final link.
2824 The basic idea here is to examine all the relocations looking for
2825 PC-relative calls to a target that is unreachable with a "bl"
2826 instruction. */
2828 bfd_boolean
2829 elf32_hppa_size_stubs
2830 (bfd *output_bfd, bfd *stub_bfd, struct bfd_link_info *info,
2831 bfd_boolean multi_subspace, bfd_signed_vma group_size,
2832 asection * (*add_stub_section) (const char *, asection *),
2833 void (*layout_sections_again) (void))
2835 bfd_size_type stub_group_size;
2836 bfd_boolean stubs_always_before_branch;
2837 bfd_boolean stub_changed;
2838 struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
2840 /* Stash our params away. */
2841 htab->stub_bfd = stub_bfd;
2842 htab->multi_subspace = multi_subspace;
2843 htab->add_stub_section = add_stub_section;
2844 htab->layout_sections_again = layout_sections_again;
2845 stubs_always_before_branch = group_size < 0;
2846 if (group_size < 0)
2847 stub_group_size = -group_size;
2848 else
2849 stub_group_size = group_size;
2850 if (stub_group_size == 1)
2852 /* Default values. */
2853 if (stubs_always_before_branch)
2855 stub_group_size = 7680000;
2856 if (htab->has_17bit_branch || htab->multi_subspace)
2857 stub_group_size = 240000;
2858 if (htab->has_12bit_branch)
2859 stub_group_size = 7500;
2861 else
2863 stub_group_size = 6971392;
2864 if (htab->has_17bit_branch || htab->multi_subspace)
2865 stub_group_size = 217856;
2866 if (htab->has_12bit_branch)
2867 stub_group_size = 6808;
2871 group_sections (htab, stub_group_size, stubs_always_before_branch);
2873 switch (get_local_syms (output_bfd, info->input_bfds, info))
2875 default:
2876 if (htab->all_local_syms)
2877 goto error_ret_free_local;
2878 return FALSE;
2880 case 0:
2881 stub_changed = FALSE;
2882 break;
2884 case 1:
2885 stub_changed = TRUE;
2886 break;
2889 while (1)
2891 bfd *input_bfd;
2892 unsigned int bfd_indx;
2893 asection *stub_sec;
2895 for (input_bfd = info->input_bfds, bfd_indx = 0;
2896 input_bfd != NULL;
2897 input_bfd = input_bfd->link_next, bfd_indx++)
2899 Elf_Internal_Shdr *symtab_hdr;
2900 asection *section;
2901 Elf_Internal_Sym *local_syms;
2903 /* We'll need the symbol table in a second. */
2904 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2905 if (symtab_hdr->sh_info == 0)
2906 continue;
2908 local_syms = htab->all_local_syms[bfd_indx];
2910 /* Walk over each section attached to the input bfd. */
2911 for (section = input_bfd->sections;
2912 section != NULL;
2913 section = section->next)
2915 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
2917 /* If there aren't any relocs, then there's nothing more
2918 to do. */
2919 if ((section->flags & SEC_RELOC) == 0
2920 || section->reloc_count == 0)
2921 continue;
2923 /* If this section is a link-once section that will be
2924 discarded, then don't create any stubs. */
2925 if (section->output_section == NULL
2926 || section->output_section->owner != output_bfd)
2927 continue;
2929 /* Get the relocs. */
2930 internal_relocs
2931 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
2932 info->keep_memory);
2933 if (internal_relocs == NULL)
2934 goto error_ret_free_local;
2936 /* Now examine each relocation. */
2937 irela = internal_relocs;
2938 irelaend = irela + section->reloc_count;
2939 for (; irela < irelaend; irela++)
2941 unsigned int r_type, r_indx;
2942 enum elf32_hppa_stub_type stub_type;
2943 struct elf32_hppa_stub_hash_entry *hsh;
2944 asection *sym_sec;
2945 bfd_vma sym_value;
2946 bfd_vma destination;
2947 struct elf32_hppa_link_hash_entry *hh;
2948 char *stub_name;
2949 const asection *id_sec;
2951 r_type = ELF32_R_TYPE (irela->r_info);
2952 r_indx = ELF32_R_SYM (irela->r_info);
2954 if (r_type >= (unsigned int) R_PARISC_UNIMPLEMENTED)
2956 bfd_set_error (bfd_error_bad_value);
2957 error_ret_free_internal:
2958 if (elf_section_data (section)->relocs == NULL)
2959 free (internal_relocs);
2960 goto error_ret_free_local;
2963 /* Only look for stubs on call instructions. */
2964 if (r_type != (unsigned int) R_PARISC_PCREL12F
2965 && r_type != (unsigned int) R_PARISC_PCREL17F
2966 && r_type != (unsigned int) R_PARISC_PCREL22F)
2967 continue;
2969 /* Now determine the call target, its name, value,
2970 section. */
2971 sym_sec = NULL;
2972 sym_value = 0;
2973 destination = 0;
2974 hh = NULL;
2975 if (r_indx < symtab_hdr->sh_info)
2977 /* It's a local symbol. */
2978 Elf_Internal_Sym *sym;
2979 Elf_Internal_Shdr *hdr;
2980 unsigned int shndx;
2982 sym = local_syms + r_indx;
2983 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2984 sym_value = sym->st_value;
2985 shndx = sym->st_shndx;
2986 if (shndx < elf_numsections (input_bfd))
2988 hdr = elf_elfsections (input_bfd)[shndx];
2989 sym_sec = hdr->bfd_section;
2990 destination = (sym_value + irela->r_addend
2991 + sym_sec->output_offset
2992 + sym_sec->output_section->vma);
2995 else
2997 /* It's an external symbol. */
2998 int e_indx;
3000 e_indx = r_indx - symtab_hdr->sh_info;
3001 hh = hppa_elf_hash_entry (elf_sym_hashes (input_bfd)[e_indx]);
3003 while (hh->eh.root.type == bfd_link_hash_indirect
3004 || hh->eh.root.type == bfd_link_hash_warning)
3005 hh = hppa_elf_hash_entry (hh->eh.root.u.i.link);
3007 if (hh->eh.root.type == bfd_link_hash_defined
3008 || hh->eh.root.type == bfd_link_hash_defweak)
3010 sym_sec = hh->eh.root.u.def.section;
3011 sym_value = hh->eh.root.u.def.value;
3012 if (sym_sec->output_section != NULL)
3013 destination = (sym_value + irela->r_addend
3014 + sym_sec->output_offset
3015 + sym_sec->output_section->vma);
3017 else if (hh->eh.root.type == bfd_link_hash_undefweak)
3019 if (! info->shared)
3020 continue;
3022 else if (hh->eh.root.type == bfd_link_hash_undefined)
3024 if (! (info->unresolved_syms_in_objects == RM_IGNORE
3025 && (ELF_ST_VISIBILITY (hh->eh.other)
3026 == STV_DEFAULT)
3027 && hh->eh.type != STT_PARISC_MILLI))
3028 continue;
3030 else
3032 bfd_set_error (bfd_error_bad_value);
3033 goto error_ret_free_internal;
3037 /* Determine what (if any) linker stub is needed. */
3038 stub_type = hppa_type_of_stub (section, irela, hh,
3039 destination, info);
3040 if (stub_type == hppa_stub_none)
3041 continue;
3043 /* Support for grouping stub sections. */
3044 id_sec = htab->stub_group[section->id].link_sec;
3046 /* Get the name of this stub. */
3047 stub_name = hppa_stub_name (id_sec, sym_sec, hh, irela);
3048 if (!stub_name)
3049 goto error_ret_free_internal;
3051 hsh = hppa_stub_hash_lookup (&htab->bstab,
3052 stub_name,
3053 FALSE, FALSE);
3054 if (hsh != NULL)
3056 /* The proper stub has already been created. */
3057 free (stub_name);
3058 continue;
3061 hsh = hppa_add_stub (stub_name, section, htab);
3062 if (hsh == NULL)
3064 free (stub_name);
3065 goto error_ret_free_internal;
3068 hsh->target_value = sym_value;
3069 hsh->target_section = sym_sec;
3070 hsh->stub_type = stub_type;
3071 if (info->shared)
3073 if (stub_type == hppa_stub_import)
3074 hsh->stub_type = hppa_stub_import_shared;
3075 else if (stub_type == hppa_stub_long_branch)
3076 hsh->stub_type = hppa_stub_long_branch_shared;
3078 hsh->hh = hh;
3079 stub_changed = TRUE;
3082 /* We're done with the internal relocs, free them. */
3083 if (elf_section_data (section)->relocs == NULL)
3084 free (internal_relocs);
3088 if (!stub_changed)
3089 break;
3091 /* OK, we've added some stubs. Find out the new size of the
3092 stub sections. */
3093 for (stub_sec = htab->stub_bfd->sections;
3094 stub_sec != NULL;
3095 stub_sec = stub_sec->next)
3096 stub_sec->size = 0;
3098 bfd_hash_traverse (&htab->bstab, hppa_size_one_stub, htab);
3100 /* Ask the linker to do its stuff. */
3101 (*htab->layout_sections_again) ();
3102 stub_changed = FALSE;
3105 free (htab->all_local_syms);
3106 return TRUE;
3108 error_ret_free_local:
3109 free (htab->all_local_syms);
3110 return FALSE;
3113 /* For a final link, this function is called after we have sized the
3114 stubs to provide a value for __gp. */
3116 bfd_boolean
3117 elf32_hppa_set_gp (bfd *abfd, struct bfd_link_info *info)
3119 struct bfd_link_hash_entry *h;
3120 asection *sec = NULL;
3121 bfd_vma gp_val = 0;
3122 struct elf32_hppa_link_hash_table *htab;
3124 htab = hppa_link_hash_table (info);
3125 h = bfd_link_hash_lookup (&htab->etab.root, "$global$", FALSE, FALSE, FALSE);
3127 if (h != NULL
3128 && (h->type == bfd_link_hash_defined
3129 || h->type == bfd_link_hash_defweak))
3131 gp_val = h->u.def.value;
3132 sec = h->u.def.section;
3134 else
3136 asection *splt = bfd_get_section_by_name (abfd, ".plt");
3137 asection *sgot = bfd_get_section_by_name (abfd, ".got");
3139 /* Choose to point our LTP at, in this order, one of .plt, .got,
3140 or .data, if these sections exist. In the case of choosing
3141 .plt try to make the LTP ideal for addressing anywhere in the
3142 .plt or .got with a 14 bit signed offset. Typically, the end
3143 of the .plt is the start of the .got, so choose .plt + 0x2000
3144 if either the .plt or .got is larger than 0x2000. If both
3145 the .plt and .got are smaller than 0x2000, choose the end of
3146 the .plt section. */
3147 sec = strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") == 0
3148 ? NULL : splt;
3149 if (sec != NULL)
3151 gp_val = sec->size;
3152 if (gp_val > 0x2000 || (sgot && sgot->size > 0x2000))
3154 gp_val = 0x2000;
3157 else
3159 sec = sgot;
3160 if (sec != NULL)
3162 if (strcmp (bfd_get_target (abfd), "elf32-hppa-netbsd") != 0)
3164 /* We know we don't have a .plt. If .got is large,
3165 offset our LTP. */
3166 if (sec->size > 0x2000)
3167 gp_val = 0x2000;
3170 else
3172 /* No .plt or .got. Who cares what the LTP is? */
3173 sec = bfd_get_section_by_name (abfd, ".data");
3177 if (h != NULL)
3179 h->type = bfd_link_hash_defined;
3180 h->u.def.value = gp_val;
3181 if (sec != NULL)
3182 h->u.def.section = sec;
3183 else
3184 h->u.def.section = bfd_abs_section_ptr;
3188 if (sec != NULL && sec->output_section != NULL)
3189 gp_val += sec->output_section->vma + sec->output_offset;
3191 elf_gp (abfd) = gp_val;
3192 return TRUE;
3195 /* Build all the stubs associated with the current output file. The
3196 stubs are kept in a hash table attached to the main linker hash
3197 table. We also set up the .plt entries for statically linked PIC
3198 functions here. This function is called via hppaelf_finish in the
3199 linker. */
3201 bfd_boolean
3202 elf32_hppa_build_stubs (struct bfd_link_info *info)
3204 asection *stub_sec;
3205 struct bfd_hash_table *table;
3206 struct elf32_hppa_link_hash_table *htab;
3208 htab = hppa_link_hash_table (info);
3210 for (stub_sec = htab->stub_bfd->sections;
3211 stub_sec != NULL;
3212 stub_sec = stub_sec->next)
3214 bfd_size_type size;
3216 /* Allocate memory to hold the linker stubs. */
3217 size = stub_sec->size;
3218 stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
3219 if (stub_sec->contents == NULL && size != 0)
3220 return FALSE;
3221 stub_sec->size = 0;
3224 /* Build the stubs as directed by the stub hash table. */
3225 table = &htab->bstab;
3226 bfd_hash_traverse (table, hppa_build_one_stub, info);
3228 return TRUE;
3231 /* Return the base vma address which should be subtracted from the real
3232 address when resolving a dtpoff relocation.
3233 This is PT_TLS segment p_vaddr. */
3235 static bfd_vma
3236 dtpoff_base (struct bfd_link_info *info)
3238 /* If tls_sec is NULL, we should have signalled an error already. */
3239 if (elf_hash_table (info)->tls_sec == NULL)
3240 return 0;
3241 return elf_hash_table (info)->tls_sec->vma;
3244 /* Return the relocation value for R_PARISC_TLS_TPOFF*.. */
3246 static bfd_vma
3247 tpoff (struct bfd_link_info *info, bfd_vma address)
3249 struct elf_link_hash_table *htab = elf_hash_table (info);
3251 /* If tls_sec is NULL, we should have signalled an error already. */
3252 if (htab->tls_sec == NULL)
3253 return 0;
3254 /* hppa TLS ABI is variant I and static TLS block start just after
3255 tcbhead structure which has 2 pointer fields. */
3256 return (address - htab->tls_sec->vma
3257 + align_power ((bfd_vma) 8, htab->tls_sec->alignment_power));
3260 /* Perform a final link. */
3262 static bfd_boolean
3263 elf32_hppa_final_link (bfd *abfd, struct bfd_link_info *info)
3265 /* Invoke the regular ELF linker to do all the work. */
3266 if (!bfd_elf_final_link (abfd, info))
3267 return FALSE;
3269 /* If we're producing a final executable, sort the contents of the
3270 unwind section. */
3271 return elf_hppa_sort_unwind (abfd);
3274 /* Record the lowest address for the data and text segments. */
3276 static void
3277 hppa_record_segment_addr (bfd *abfd, asection *section, void *data)
3279 struct elf32_hppa_link_hash_table *htab;
3281 htab = (struct elf32_hppa_link_hash_table*) data;
3283 if ((section->flags & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3285 bfd_vma value;
3286 Elf_Internal_Phdr *p;
3288 p = _bfd_elf_find_segment_containing_section (abfd, section->output_section);
3289 BFD_ASSERT (p != NULL);
3290 value = p->p_vaddr;
3292 if ((section->flags & SEC_READONLY) != 0)
3294 if (value < htab->text_segment_base)
3295 htab->text_segment_base = value;
3297 else
3299 if (value < htab->data_segment_base)
3300 htab->data_segment_base = value;
3305 /* Perform a relocation as part of a final link. */
3307 static bfd_reloc_status_type
3308 final_link_relocate (asection *input_section,
3309 bfd_byte *contents,
3310 const Elf_Internal_Rela *rela,
3311 bfd_vma value,
3312 struct elf32_hppa_link_hash_table *htab,
3313 asection *sym_sec,
3314 struct elf32_hppa_link_hash_entry *hh,
3315 struct bfd_link_info *info)
3317 int insn;
3318 unsigned int r_type = ELF32_R_TYPE (rela->r_info);
3319 unsigned int orig_r_type = r_type;
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 = rela->r_offset;
3325 bfd_vma max_branch_offset = 0;
3326 bfd_byte *hit_data = contents + offset;
3327 bfd_signed_vma addend = rela->r_addend;
3328 bfd_vma location;
3329 struct elf32_hppa_stub_hash_entry *hsh = NULL;
3330 int val;
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);
3342 /* If we are not building a shared library, convert DLTIND relocs to
3343 DPREL relocs. */
3344 if (!info->shared)
3346 switch (r_type)
3348 case R_PARISC_DLTIND21L:
3349 r_type = R_PARISC_DPREL21L;
3350 break;
3352 case R_PARISC_DLTIND14R:
3353 r_type = R_PARISC_DPREL14R;
3354 break;
3356 case R_PARISC_DLTIND14F:
3357 r_type = R_PARISC_DPREL14F;
3358 break;
3362 switch (r_type)
3364 case R_PARISC_PCREL12F:
3365 case R_PARISC_PCREL17F:
3366 case R_PARISC_PCREL22F:
3367 /* If this call should go via the plt, find the import stub in
3368 the stub hash. */
3369 if (sym_sec == NULL
3370 || sym_sec->output_section == NULL
3371 || (hh != NULL
3372 && hh->eh.plt.offset != (bfd_vma) -1
3373 && hh->eh.dynindx != -1
3374 && !hh->plabel
3375 && (info->shared
3376 || !hh->eh.def_regular
3377 || hh->eh.root.type == bfd_link_hash_defweak)))
3379 hsh = hppa_get_stub_entry (input_section, sym_sec,
3380 hh, rela, htab);
3381 if (hsh != NULL)
3383 value = (hsh->stub_offset
3384 + hsh->stub_sec->output_offset
3385 + hsh->stub_sec->output_section->vma);
3386 addend = 0;
3388 else if (sym_sec == NULL && hh != NULL
3389 && hh->eh.root.type == bfd_link_hash_undefweak)
3391 /* It's OK if undefined weak. Calls to undefined weak
3392 symbols behave as if the "called" function
3393 immediately returns. We can thus call to a weak
3394 function without first checking whether the function
3395 is defined. */
3396 value = location;
3397 addend = 8;
3399 else
3400 return bfd_reloc_undefined;
3402 /* Fall thru. */
3404 case R_PARISC_PCREL21L:
3405 case R_PARISC_PCREL17C:
3406 case R_PARISC_PCREL17R:
3407 case R_PARISC_PCREL14R:
3408 case R_PARISC_PCREL14F:
3409 case R_PARISC_PCREL32:
3410 /* Make it a pc relative offset. */
3411 value -= location;
3412 addend -= 8;
3413 break;
3415 case R_PARISC_DPREL21L:
3416 case R_PARISC_DPREL14R:
3417 case R_PARISC_DPREL14F:
3418 /* Convert instructions that use the linkage table pointer (r19) to
3419 instructions that use the global data pointer (dp). This is the
3420 most efficient way of using PIC code in an incomplete executable,
3421 but the user must follow the standard runtime conventions for
3422 accessing data for this to work. */
3423 if (orig_r_type == R_PARISC_DLTIND21L)
3425 /* Convert addil instructions if the original reloc was a
3426 DLTIND21L. GCC sometimes uses a register other than r19 for
3427 the operation, so we must convert any addil instruction
3428 that uses this relocation. */
3429 if ((insn & 0xfc000000) == ((int) OP_ADDIL << 26))
3430 insn = ADDIL_DP;
3431 else
3432 /* We must have a ldil instruction. It's too hard to find
3433 and convert the associated add instruction, so issue an
3434 error. */
3435 (*_bfd_error_handler)
3436 (_("%B(%A+0x%lx): %s fixup for insn 0x%x is not supported in a non-shared link"),
3437 input_bfd,
3438 input_section,
3439 offset,
3440 howto->name,
3441 insn);
3443 else if (orig_r_type == R_PARISC_DLTIND14F)
3445 /* This must be a format 1 load/store. Change the base
3446 register to dp. */
3447 insn = (insn & 0xfc1ffff) | (27 << 21);
3450 /* For all the DP relative relocations, we need to examine the symbol's
3451 section. If it has no section or if it's a code section, then
3452 "data pointer relative" makes no sense. In that case we don't
3453 adjust the "value", and for 21 bit addil instructions, we change the
3454 source addend register from %dp to %r0. This situation commonly
3455 arises for undefined weak symbols and when a variable's "constness"
3456 is declared differently from the way the variable is defined. For
3457 instance: "extern int foo" with foo defined as "const int foo". */
3458 if (sym_sec == NULL || (sym_sec->flags & SEC_CODE) != 0)
3460 if ((insn & ((0x3f << 26) | (0x1f << 21)))
3461 == (((int) OP_ADDIL << 26) | (27 << 21)))
3463 insn &= ~ (0x1f << 21);
3465 /* Now try to make things easy for the dynamic linker. */
3467 break;
3469 /* Fall thru. */
3471 case R_PARISC_DLTIND21L:
3472 case R_PARISC_DLTIND14R:
3473 case R_PARISC_DLTIND14F:
3474 case R_PARISC_TLS_GD21L:
3475 case R_PARISC_TLS_GD14R:
3476 case R_PARISC_TLS_LDM21L:
3477 case R_PARISC_TLS_LDM14R:
3478 case R_PARISC_TLS_IE21L:
3479 case R_PARISC_TLS_IE14R:
3480 value -= elf_gp (input_section->output_section->owner);
3481 break;
3483 case R_PARISC_SEGREL32:
3484 if ((sym_sec->flags & SEC_CODE) != 0)
3485 value -= htab->text_segment_base;
3486 else
3487 value -= htab->data_segment_base;
3488 break;
3490 default:
3491 break;
3494 switch (r_type)
3496 case R_PARISC_DIR32:
3497 case R_PARISC_DIR14F:
3498 case R_PARISC_DIR17F:
3499 case R_PARISC_PCREL17C:
3500 case R_PARISC_PCREL14F:
3501 case R_PARISC_PCREL32:
3502 case R_PARISC_DPREL14F:
3503 case R_PARISC_PLABEL32:
3504 case R_PARISC_DLTIND14F:
3505 case R_PARISC_SEGBASE:
3506 case R_PARISC_SEGREL32:
3507 case R_PARISC_TLS_DTPMOD32:
3508 case R_PARISC_TLS_DTPOFF32:
3509 case R_PARISC_TLS_TPREL32:
3510 r_field = e_fsel;
3511 break;
3513 case R_PARISC_DLTIND21L:
3514 case R_PARISC_PCREL21L:
3515 case R_PARISC_PLABEL21L:
3516 r_field = e_lsel;
3517 break;
3519 case R_PARISC_DIR21L:
3520 case R_PARISC_DPREL21L:
3521 case R_PARISC_TLS_GD21L:
3522 case R_PARISC_TLS_LDM21L:
3523 case R_PARISC_TLS_LDO21L:
3524 case R_PARISC_TLS_IE21L:
3525 case R_PARISC_TLS_LE21L:
3526 r_field = e_lrsel;
3527 break;
3529 case R_PARISC_PCREL17R:
3530 case R_PARISC_PCREL14R:
3531 case R_PARISC_PLABEL14R:
3532 case R_PARISC_DLTIND14R:
3533 r_field = e_rsel;
3534 break;
3536 case R_PARISC_DIR17R:
3537 case R_PARISC_DIR14R:
3538 case R_PARISC_DPREL14R:
3539 case R_PARISC_TLS_GD14R:
3540 case R_PARISC_TLS_LDM14R:
3541 case R_PARISC_TLS_LDO14R:
3542 case R_PARISC_TLS_IE14R:
3543 case R_PARISC_TLS_LE14R:
3544 r_field = e_rrsel;
3545 break;
3547 case R_PARISC_PCREL12F:
3548 case R_PARISC_PCREL17F:
3549 case R_PARISC_PCREL22F:
3550 r_field = e_fsel;
3552 if (r_type == (unsigned int) R_PARISC_PCREL17F)
3554 max_branch_offset = (1 << (17-1)) << 2;
3556 else if (r_type == (unsigned int) R_PARISC_PCREL12F)
3558 max_branch_offset = (1 << (12-1)) << 2;
3560 else
3562 max_branch_offset = (1 << (22-1)) << 2;
3565 /* sym_sec is NULL on undefined weak syms or when shared on
3566 undefined syms. We've already checked for a stub for the
3567 shared undefined case. */
3568 if (sym_sec == NULL)
3569 break;
3571 /* If the branch is out of reach, then redirect the
3572 call to the local stub for this function. */
3573 if (value + addend + max_branch_offset >= 2*max_branch_offset)
3575 hsh = hppa_get_stub_entry (input_section, sym_sec,
3576 hh, rela, htab);
3577 if (hsh == NULL)
3578 return bfd_reloc_undefined;
3580 /* Munge up the value and addend so that we call the stub
3581 rather than the procedure directly. */
3582 value = (hsh->stub_offset
3583 + hsh->stub_sec->output_offset
3584 + hsh->stub_sec->output_section->vma
3585 - location);
3586 addend = -8;
3588 break;
3590 /* Something we don't know how to handle. */
3591 default:
3592 return bfd_reloc_notsupported;
3595 /* Make sure we can reach the stub. */
3596 if (max_branch_offset != 0
3597 && value + addend + max_branch_offset >= 2*max_branch_offset)
3599 (*_bfd_error_handler)
3600 (_("%B(%A+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
3601 input_bfd,
3602 input_section,
3603 offset,
3604 hsh->bh_root.string);
3605 bfd_set_error (bfd_error_bad_value);
3606 return bfd_reloc_notsupported;
3609 val = hppa_field_adjust (value, addend, r_field);
3611 switch (r_type)
3613 case R_PARISC_PCREL12F:
3614 case R_PARISC_PCREL17C:
3615 case R_PARISC_PCREL17F:
3616 case R_PARISC_PCREL17R:
3617 case R_PARISC_PCREL22F:
3618 case R_PARISC_DIR17F:
3619 case R_PARISC_DIR17R:
3620 /* This is a branch. Divide the offset by four.
3621 Note that we need to decide whether it's a branch or
3622 otherwise by inspecting the reloc. Inspecting insn won't
3623 work as insn might be from a .word directive. */
3624 val >>= 2;
3625 break;
3627 default:
3628 break;
3631 insn = hppa_rebuild_insn (insn, val, r_format);
3633 /* Update the instruction word. */
3634 bfd_put_32 (input_bfd, (bfd_vma) insn, hit_data);
3635 return bfd_reloc_ok;
3638 /* Relocate an HPPA ELF section. */
3640 static bfd_boolean
3641 elf32_hppa_relocate_section (bfd *output_bfd,
3642 struct bfd_link_info *info,
3643 bfd *input_bfd,
3644 asection *input_section,
3645 bfd_byte *contents,
3646 Elf_Internal_Rela *relocs,
3647 Elf_Internal_Sym *local_syms,
3648 asection **local_sections)
3650 bfd_vma *local_got_offsets;
3651 struct elf32_hppa_link_hash_table *htab;
3652 Elf_Internal_Shdr *symtab_hdr;
3653 Elf_Internal_Rela *rela;
3654 Elf_Internal_Rela *relend;
3656 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3658 htab = hppa_link_hash_table (info);
3659 local_got_offsets = elf_local_got_offsets (input_bfd);
3661 rela = relocs;
3662 relend = relocs + input_section->reloc_count;
3663 for (; rela < relend; rela++)
3665 unsigned int r_type;
3666 reloc_howto_type *howto;
3667 unsigned int r_symndx;
3668 struct elf32_hppa_link_hash_entry *hh;
3669 Elf_Internal_Sym *sym;
3670 asection *sym_sec;
3671 bfd_vma relocation;
3672 bfd_reloc_status_type rstatus;
3673 const char *sym_name;
3674 bfd_boolean plabel;
3675 bfd_boolean warned_undef;
3677 r_type = ELF32_R_TYPE (rela->r_info);
3678 if (r_type >= (unsigned int) R_PARISC_UNIMPLEMENTED)
3680 bfd_set_error (bfd_error_bad_value);
3681 return FALSE;
3683 if (r_type == (unsigned int) R_PARISC_GNU_VTENTRY
3684 || r_type == (unsigned int) R_PARISC_GNU_VTINHERIT)
3685 continue;
3687 r_symndx = ELF32_R_SYM (rela->r_info);
3688 hh = NULL;
3689 sym = NULL;
3690 sym_sec = NULL;
3691 warned_undef = FALSE;
3692 if (r_symndx < symtab_hdr->sh_info)
3694 /* This is a local symbol, h defaults to NULL. */
3695 sym = local_syms + r_symndx;
3696 sym_sec = local_sections[r_symndx];
3697 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sym_sec, rela);
3699 else
3701 struct elf_link_hash_entry *eh;
3702 bfd_boolean unresolved_reloc;
3703 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
3705 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rela,
3706 r_symndx, symtab_hdr, sym_hashes,
3707 eh, sym_sec, relocation,
3708 unresolved_reloc, warned_undef);
3710 if (!info->relocatable
3711 && relocation == 0
3712 && eh->root.type != bfd_link_hash_defined
3713 && eh->root.type != bfd_link_hash_defweak
3714 && eh->root.type != bfd_link_hash_undefweak)
3716 if (info->unresolved_syms_in_objects == RM_IGNORE
3717 && ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT
3718 && eh->type == STT_PARISC_MILLI)
3720 if (! info->callbacks->undefined_symbol
3721 (info, eh_name (eh), input_bfd,
3722 input_section, rela->r_offset, FALSE))
3723 return FALSE;
3724 warned_undef = TRUE;
3727 hh = hppa_elf_hash_entry (eh);
3730 if (sym_sec != NULL && elf_discarded_section (sym_sec))
3732 /* For relocs against symbols from removed linkonce
3733 sections, or sections discarded by a linker script,
3734 we just want the section contents zeroed. Avoid any
3735 special processing. */
3736 _bfd_clear_contents (elf_hppa_howto_table + r_type, input_bfd,
3737 contents + rela->r_offset);
3738 rela->r_info = 0;
3739 rela->r_addend = 0;
3740 continue;
3743 if (info->relocatable)
3744 continue;
3746 /* Do any required modifications to the relocation value, and
3747 determine what types of dynamic info we need to output, if
3748 any. */
3749 plabel = 0;
3750 switch (r_type)
3752 case R_PARISC_DLTIND14F:
3753 case R_PARISC_DLTIND14R:
3754 case R_PARISC_DLTIND21L:
3756 bfd_vma off;
3757 bfd_boolean do_got = 0;
3759 /* Relocation is to the entry for this symbol in the
3760 global offset table. */
3761 if (hh != NULL)
3763 bfd_boolean dyn;
3765 off = hh->eh.got.offset;
3766 dyn = htab->etab.dynamic_sections_created;
3767 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared,
3768 &hh->eh))
3770 /* If we aren't going to call finish_dynamic_symbol,
3771 then we need to handle initialisation of the .got
3772 entry and create needed relocs here. Since the
3773 offset must always be a multiple of 4, we use the
3774 least significant bit to record whether we have
3775 initialised it already. */
3776 if ((off & 1) != 0)
3777 off &= ~1;
3778 else
3780 hh->eh.got.offset |= 1;
3781 do_got = 1;
3785 else
3787 /* Local symbol case. */
3788 if (local_got_offsets == NULL)
3789 abort ();
3791 off = local_got_offsets[r_symndx];
3793 /* The offset must always be a multiple of 4. We use
3794 the least significant bit to record whether we have
3795 already generated the necessary reloc. */
3796 if ((off & 1) != 0)
3797 off &= ~1;
3798 else
3800 local_got_offsets[r_symndx] |= 1;
3801 do_got = 1;
3805 if (do_got)
3807 if (info->shared)
3809 /* Output a dynamic relocation for this GOT entry.
3810 In this case it is relative to the base of the
3811 object because the symbol index is zero. */
3812 Elf_Internal_Rela outrel;
3813 bfd_byte *loc;
3814 asection *sec = htab->srelgot;
3816 outrel.r_offset = (off
3817 + htab->sgot->output_offset
3818 + htab->sgot->output_section->vma);
3819 outrel.r_info = ELF32_R_INFO (0, R_PARISC_DIR32);
3820 outrel.r_addend = relocation;
3821 loc = sec->contents;
3822 loc += sec->reloc_count++ * sizeof (Elf32_External_Rela);
3823 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3825 else
3826 bfd_put_32 (output_bfd, relocation,
3827 htab->sgot->contents + off);
3830 if (off >= (bfd_vma) -2)
3831 abort ();
3833 /* Add the base of the GOT to the relocation value. */
3834 relocation = (off
3835 + htab->sgot->output_offset
3836 + htab->sgot->output_section->vma);
3838 break;
3840 case R_PARISC_SEGREL32:
3841 /* If this is the first SEGREL relocation, then initialize
3842 the segment base values. */
3843 if (htab->text_segment_base == (bfd_vma) -1)
3844 bfd_map_over_sections (output_bfd, hppa_record_segment_addr, htab);
3845 break;
3847 case R_PARISC_PLABEL14R:
3848 case R_PARISC_PLABEL21L:
3849 case R_PARISC_PLABEL32:
3850 if (htab->etab.dynamic_sections_created)
3852 bfd_vma off;
3853 bfd_boolean do_plt = 0;
3854 /* If we have a global symbol with a PLT slot, then
3855 redirect this relocation to it. */
3856 if (hh != NULL)
3858 off = hh->eh.plt.offset;
3859 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared,
3860 &hh->eh))
3862 /* In a non-shared link, adjust_dynamic_symbols
3863 isn't called for symbols forced local. We
3864 need to write out the plt entry here. */
3865 if ((off & 1) != 0)
3866 off &= ~1;
3867 else
3869 hh->eh.plt.offset |= 1;
3870 do_plt = 1;
3874 else
3876 bfd_vma *local_plt_offsets;
3878 if (local_got_offsets == NULL)
3879 abort ();
3881 local_plt_offsets = local_got_offsets + symtab_hdr->sh_info;
3882 off = local_plt_offsets[r_symndx];
3884 /* As for the local .got entry case, we use the last
3885 bit to record whether we've already initialised
3886 this local .plt entry. */
3887 if ((off & 1) != 0)
3888 off &= ~1;
3889 else
3891 local_plt_offsets[r_symndx] |= 1;
3892 do_plt = 1;
3896 if (do_plt)
3898 if (info->shared)
3900 /* Output a dynamic IPLT relocation for this
3901 PLT entry. */
3902 Elf_Internal_Rela outrel;
3903 bfd_byte *loc;
3904 asection *s = htab->srelplt;
3906 outrel.r_offset = (off
3907 + htab->splt->output_offset
3908 + htab->splt->output_section->vma);
3909 outrel.r_info = ELF32_R_INFO (0, R_PARISC_IPLT);
3910 outrel.r_addend = relocation;
3911 loc = s->contents;
3912 loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
3913 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3915 else
3917 bfd_put_32 (output_bfd,
3918 relocation,
3919 htab->splt->contents + off);
3920 bfd_put_32 (output_bfd,
3921 elf_gp (htab->splt->output_section->owner),
3922 htab->splt->contents + off + 4);
3926 if (off >= (bfd_vma) -2)
3927 abort ();
3929 /* PLABELs contain function pointers. Relocation is to
3930 the entry for the function in the .plt. The magic +2
3931 offset signals to $$dyncall that the function pointer
3932 is in the .plt and thus has a gp pointer too.
3933 Exception: Undefined PLABELs should have a value of
3934 zero. */
3935 if (hh == NULL
3936 || (hh->eh.root.type != bfd_link_hash_undefweak
3937 && hh->eh.root.type != bfd_link_hash_undefined))
3939 relocation = (off
3940 + htab->splt->output_offset
3941 + htab->splt->output_section->vma
3942 + 2);
3944 plabel = 1;
3946 /* Fall through and possibly emit a dynamic relocation. */
3948 case R_PARISC_DIR17F:
3949 case R_PARISC_DIR17R:
3950 case R_PARISC_DIR14F:
3951 case R_PARISC_DIR14R:
3952 case R_PARISC_DIR21L:
3953 case R_PARISC_DPREL14F:
3954 case R_PARISC_DPREL14R:
3955 case R_PARISC_DPREL21L:
3956 case R_PARISC_DIR32:
3957 if ((input_section->flags & SEC_ALLOC) == 0)
3958 break;
3960 /* The reloc types handled here and this conditional
3961 expression must match the code in ..check_relocs and
3962 allocate_dynrelocs. ie. We need exactly the same condition
3963 as in ..check_relocs, with some extra conditions (dynindx
3964 test in this case) to cater for relocs removed by
3965 allocate_dynrelocs. If you squint, the non-shared test
3966 here does indeed match the one in ..check_relocs, the
3967 difference being that here we test DEF_DYNAMIC as well as
3968 !DEF_REGULAR. All common syms end up with !DEF_REGULAR,
3969 which is why we can't use just that test here.
3970 Conversely, DEF_DYNAMIC can't be used in check_relocs as
3971 there all files have not been loaded. */
3972 if ((info->shared
3973 && (hh == NULL
3974 || ELF_ST_VISIBILITY (hh->eh.other) == STV_DEFAULT
3975 || hh->eh.root.type != bfd_link_hash_undefweak)
3976 && (IS_ABSOLUTE_RELOC (r_type)
3977 || !SYMBOL_CALLS_LOCAL (info, &hh->eh)))
3978 || (!info->shared
3979 && hh != NULL
3980 && hh->eh.dynindx != -1
3981 && !hh->eh.non_got_ref
3982 && ((ELIMINATE_COPY_RELOCS
3983 && hh->eh.def_dynamic
3984 && !hh->eh.def_regular)
3985 || hh->eh.root.type == bfd_link_hash_undefweak
3986 || hh->eh.root.type == bfd_link_hash_undefined)))
3988 Elf_Internal_Rela outrel;
3989 bfd_boolean skip;
3990 asection *sreloc;
3991 bfd_byte *loc;
3993 /* When generating a shared object, these relocations
3994 are copied into the output file to be resolved at run
3995 time. */
3997 outrel.r_addend = rela->r_addend;
3998 outrel.r_offset =
3999 _bfd_elf_section_offset (output_bfd, info, input_section,
4000 rela->r_offset);
4001 skip = (outrel.r_offset == (bfd_vma) -1
4002 || outrel.r_offset == (bfd_vma) -2);
4003 outrel.r_offset += (input_section->output_offset
4004 + input_section->output_section->vma);
4006 if (skip)
4008 memset (&outrel, 0, sizeof (outrel));
4010 else if (hh != NULL
4011 && hh->eh.dynindx != -1
4012 && (plabel
4013 || !IS_ABSOLUTE_RELOC (r_type)
4014 || !info->shared
4015 || !info->symbolic
4016 || !hh->eh.def_regular))
4018 outrel.r_info = ELF32_R_INFO (hh->eh.dynindx, r_type);
4020 else /* It's a local symbol, or one marked to become local. */
4022 int indx = 0;
4024 /* Add the absolute offset of the symbol. */
4025 outrel.r_addend += relocation;
4027 /* Global plabels need to be processed by the
4028 dynamic linker so that functions have at most one
4029 fptr. For this reason, we need to differentiate
4030 between global and local plabels, which we do by
4031 providing the function symbol for a global plabel
4032 reloc, and no symbol for local plabels. */
4033 if (! plabel
4034 && sym_sec != NULL
4035 && sym_sec->output_section != NULL
4036 && ! bfd_is_abs_section (sym_sec))
4038 asection *osec;
4040 osec = sym_sec->output_section;
4041 indx = elf_section_data (osec)->dynindx;
4042 if (indx == 0)
4044 osec = htab->etab.text_index_section;
4045 indx = elf_section_data (osec)->dynindx;
4047 BFD_ASSERT (indx != 0);
4049 /* We are turning this relocation into one
4050 against a section symbol, so subtract out the
4051 output section's address but not the offset
4052 of the input section in the output section. */
4053 outrel.r_addend -= osec->vma;
4056 outrel.r_info = ELF32_R_INFO (indx, r_type);
4058 sreloc = elf_section_data (input_section)->sreloc;
4059 if (sreloc == NULL)
4060 abort ();
4062 loc = sreloc->contents;
4063 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4064 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4066 break;
4068 case R_PARISC_TLS_LDM21L:
4069 case R_PARISC_TLS_LDM14R:
4071 bfd_vma off;
4073 off = htab->tls_ldm_got.offset;
4074 if (off & 1)
4075 off &= ~1;
4076 else
4078 Elf_Internal_Rela outrel;
4079 bfd_byte *loc;
4081 outrel.r_offset = (off
4082 + htab->sgot->output_section->vma
4083 + htab->sgot->output_offset);
4084 outrel.r_addend = 0;
4085 outrel.r_info = ELF32_R_INFO (0, R_PARISC_TLS_DTPMOD32);
4086 loc = htab->srelgot->contents;
4087 loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
4089 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4090 htab->tls_ldm_got.offset |= 1;
4093 /* Add the base of the GOT to the relocation value. */
4094 relocation = (off
4095 + htab->sgot->output_offset
4096 + htab->sgot->output_section->vma);
4098 break;
4101 case R_PARISC_TLS_LDO21L:
4102 case R_PARISC_TLS_LDO14R:
4103 relocation -= dtpoff_base (info);
4104 break;
4106 case R_PARISC_TLS_GD21L:
4107 case R_PARISC_TLS_GD14R:
4108 case R_PARISC_TLS_IE21L:
4109 case R_PARISC_TLS_IE14R:
4111 bfd_vma off;
4112 int indx;
4113 char tls_type;
4115 indx = 0;
4116 if (hh != NULL)
4118 bfd_boolean dyn;
4119 dyn = htab->etab.dynamic_sections_created;
4121 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, &hh->eh)
4122 && (!info->shared
4123 || !SYMBOL_REFERENCES_LOCAL (info, &hh->eh)))
4125 indx = hh->eh.dynindx;
4127 off = hh->eh.got.offset;
4128 tls_type = hh->tls_type;
4130 else
4132 off = local_got_offsets[r_symndx];
4133 tls_type = hppa_elf_local_got_tls_type (input_bfd)[r_symndx];
4136 if (tls_type == GOT_UNKNOWN)
4137 abort ();
4139 if ((off & 1) != 0)
4140 off &= ~1;
4141 else
4143 bfd_boolean need_relocs = FALSE;
4144 Elf_Internal_Rela outrel;
4145 bfd_byte *loc = NULL;
4146 int cur_off = off;
4148 /* The GOT entries have not been initialized yet. Do it
4149 now, and emit any relocations. If both an IE GOT and a
4150 GD GOT are necessary, we emit the GD first. */
4152 if ((info->shared || indx != 0)
4153 && (hh == NULL
4154 || ELF_ST_VISIBILITY (hh->eh.other) == STV_DEFAULT
4155 || hh->eh.root.type != bfd_link_hash_undefweak))
4157 need_relocs = TRUE;
4158 loc = htab->srelgot->contents;
4159 /* FIXME (CAO): Should this be reloc_count++ ? */
4160 loc += htab->srelgot->reloc_count * sizeof (Elf32_External_Rela);
4163 if (tls_type & GOT_TLS_GD)
4165 if (need_relocs)
4167 outrel.r_offset = (cur_off
4168 + htab->sgot->output_section->vma
4169 + htab->sgot->output_offset);
4170 outrel.r_info = ELF32_R_INFO (indx,R_PARISC_TLS_DTPMOD32);
4171 outrel.r_addend = 0;
4172 bfd_put_32 (output_bfd, 0, htab->sgot->contents + cur_off);
4173 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4174 htab->srelgot->reloc_count++;
4175 loc += sizeof (Elf32_External_Rela);
4177 if (indx == 0)
4178 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
4179 htab->sgot->contents + cur_off + 4);
4180 else
4182 bfd_put_32 (output_bfd, 0,
4183 htab->sgot->contents + cur_off + 4);
4184 outrel.r_info = ELF32_R_INFO (indx, R_PARISC_TLS_DTPOFF32);
4185 outrel.r_offset += 4;
4186 bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
4187 htab->srelgot->reloc_count++;
4188 loc += sizeof (Elf32_External_Rela);
4191 else
4193 /* If we are not emitting relocations for a
4194 general dynamic reference, then we must be in a
4195 static link or an executable link with the
4196 symbol binding locally. Mark it as belonging
4197 to module 1, the executable. */
4198 bfd_put_32 (output_bfd, 1,
4199 htab->sgot->contents + cur_off);
4200 bfd_put_32 (output_bfd, relocation - dtpoff_base (info),
4201 htab->sgot->contents + cur_off + 4);
4205 cur_off += 8;
4208 if (tls_type & GOT_TLS_IE)
4210 if (need_relocs)
4212 outrel.r_offset = (cur_off
4213 + htab->sgot->output_section->vma
4214 + htab->sgot->output_offset);
4215 outrel.r_info = ELF32_R_INFO (indx, R_PARISC_TLS_TPREL32);
4217 if (indx == 0)
4218 outrel.r_addend = relocation - dtpoff_base (info);
4219 else
4220 outrel.r_addend = 0;
4222 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4223 htab->srelgot->reloc_count++;
4224 loc += sizeof (Elf32_External_Rela);
4226 else
4227 bfd_put_32 (output_bfd, tpoff (info, relocation),
4228 htab->sgot->contents + cur_off);
4230 cur_off += 4;
4233 if (hh != NULL)
4234 hh->eh.got.offset |= 1;
4235 else
4236 local_got_offsets[r_symndx] |= 1;
4239 if ((tls_type & GOT_TLS_GD)
4240 && r_type != R_PARISC_TLS_GD21L
4241 && r_type != R_PARISC_TLS_GD14R)
4242 off += 2 * GOT_ENTRY_SIZE;
4244 /* Add the base of the GOT to the relocation value. */
4245 relocation = (off
4246 + htab->sgot->output_offset
4247 + htab->sgot->output_section->vma);
4249 break;
4252 case R_PARISC_TLS_LE21L:
4253 case R_PARISC_TLS_LE14R:
4255 relocation = tpoff (info, relocation);
4256 break;
4258 break;
4260 default:
4261 break;
4264 rstatus = final_link_relocate (input_section, contents, rela, relocation,
4265 htab, sym_sec, hh, info);
4267 if (rstatus == bfd_reloc_ok)
4268 continue;
4270 if (hh != NULL)
4271 sym_name = hh_name (hh);
4272 else
4274 sym_name = bfd_elf_string_from_elf_section (input_bfd,
4275 symtab_hdr->sh_link,
4276 sym->st_name);
4277 if (sym_name == NULL)
4278 return FALSE;
4279 if (*sym_name == '\0')
4280 sym_name = bfd_section_name (input_bfd, sym_sec);
4283 howto = elf_hppa_howto_table + r_type;
4285 if (rstatus == bfd_reloc_undefined || rstatus == bfd_reloc_notsupported)
4287 if (rstatus == bfd_reloc_notsupported || !warned_undef)
4289 (*_bfd_error_handler)
4290 (_("%B(%A+0x%lx): cannot handle %s for %s"),
4291 input_bfd,
4292 input_section,
4293 (long) rela->r_offset,
4294 howto->name,
4295 sym_name);
4296 bfd_set_error (bfd_error_bad_value);
4297 return FALSE;
4300 else
4302 if (!((*info->callbacks->reloc_overflow)
4303 (info, (hh ? &hh->eh.root : NULL), sym_name, howto->name,
4304 (bfd_vma) 0, input_bfd, input_section, rela->r_offset)))
4305 return FALSE;
4309 return TRUE;
4312 /* Finish up dynamic symbol handling. We set the contents of various
4313 dynamic sections here. */
4315 static bfd_boolean
4316 elf32_hppa_finish_dynamic_symbol (bfd *output_bfd,
4317 struct bfd_link_info *info,
4318 struct elf_link_hash_entry *eh,
4319 Elf_Internal_Sym *sym)
4321 struct elf32_hppa_link_hash_table *htab;
4322 Elf_Internal_Rela rela;
4323 bfd_byte *loc;
4325 htab = hppa_link_hash_table (info);
4327 if (eh->plt.offset != (bfd_vma) -1)
4329 bfd_vma value;
4331 if (eh->plt.offset & 1)
4332 abort ();
4334 /* This symbol has an entry in the procedure linkage table. Set
4335 it up.
4337 The format of a plt entry is
4338 <funcaddr>
4339 <__gp>
4341 value = 0;
4342 if (eh->root.type == bfd_link_hash_defined
4343 || eh->root.type == bfd_link_hash_defweak)
4345 value = eh->root.u.def.value;
4346 if (eh->root.u.def.section->output_section != NULL)
4347 value += (eh->root.u.def.section->output_offset
4348 + eh->root.u.def.section->output_section->vma);
4351 /* Create a dynamic IPLT relocation for this entry. */
4352 rela.r_offset = (eh->plt.offset
4353 + htab->splt->output_offset
4354 + htab->splt->output_section->vma);
4355 if (eh->dynindx != -1)
4357 rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_IPLT);
4358 rela.r_addend = 0;
4360 else
4362 /* This symbol has been marked to become local, and is
4363 used by a plabel so must be kept in the .plt. */
4364 rela.r_info = ELF32_R_INFO (0, R_PARISC_IPLT);
4365 rela.r_addend = value;
4368 loc = htab->srelplt->contents;
4369 loc += htab->srelplt->reloc_count++ * sizeof (Elf32_External_Rela);
4370 bfd_elf32_swap_reloca_out (htab->splt->output_section->owner, &rela, loc);
4372 if (!eh->def_regular)
4374 /* Mark the symbol as undefined, rather than as defined in
4375 the .plt section. Leave the value alone. */
4376 sym->st_shndx = SHN_UNDEF;
4380 if (eh->got.offset != (bfd_vma) -1
4381 && (hppa_elf_hash_entry (eh)->tls_type & GOT_TLS_GD) == 0
4382 && (hppa_elf_hash_entry (eh)->tls_type & GOT_TLS_IE) == 0)
4384 /* This symbol has an entry in the global offset table. Set it
4385 up. */
4387 rela.r_offset = ((eh->got.offset &~ (bfd_vma) 1)
4388 + htab->sgot->output_offset
4389 + htab->sgot->output_section->vma);
4391 /* If this is a -Bsymbolic link and the symbol is defined
4392 locally or was forced to be local because of a version file,
4393 we just want to emit a RELATIVE reloc. The entry in the
4394 global offset table will already have been initialized in the
4395 relocate_section function. */
4396 if (info->shared
4397 && (info->symbolic || eh->dynindx == -1)
4398 && eh->def_regular)
4400 rela.r_info = ELF32_R_INFO (0, R_PARISC_DIR32);
4401 rela.r_addend = (eh->root.u.def.value
4402 + eh->root.u.def.section->output_offset
4403 + eh->root.u.def.section->output_section->vma);
4405 else
4407 if ((eh->got.offset & 1) != 0)
4408 abort ();
4410 bfd_put_32 (output_bfd, 0, htab->sgot->contents + (eh->got.offset & ~1));
4411 rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_DIR32);
4412 rela.r_addend = 0;
4415 loc = htab->srelgot->contents;
4416 loc += htab->srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
4417 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4420 if (eh->needs_copy)
4422 asection *sec;
4424 /* This symbol needs a copy reloc. Set it up. */
4426 if (! (eh->dynindx != -1
4427 && (eh->root.type == bfd_link_hash_defined
4428 || eh->root.type == bfd_link_hash_defweak)))
4429 abort ();
4431 sec = htab->srelbss;
4433 rela.r_offset = (eh->root.u.def.value
4434 + eh->root.u.def.section->output_offset
4435 + eh->root.u.def.section->output_section->vma);
4436 rela.r_addend = 0;
4437 rela.r_info = ELF32_R_INFO (eh->dynindx, R_PARISC_COPY);
4438 loc = sec->contents + sec->reloc_count++ * sizeof (Elf32_External_Rela);
4439 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
4442 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
4443 if (eh_name (eh)[0] == '_'
4444 && (strcmp (eh_name (eh), "_DYNAMIC") == 0
4445 || eh == htab->etab.hgot))
4447 sym->st_shndx = SHN_ABS;
4450 return TRUE;
4453 /* Used to decide how to sort relocs in an optimal manner for the
4454 dynamic linker, before writing them out. */
4456 static enum elf_reloc_type_class
4457 elf32_hppa_reloc_type_class (const Elf_Internal_Rela *rela)
4459 /* Handle TLS relocs first; we don't want them to be marked
4460 relative by the "if (ELF32_R_SYM (rela->r_info) == 0)"
4461 check below. */
4462 switch ((int) ELF32_R_TYPE (rela->r_info))
4464 case R_PARISC_TLS_DTPMOD32:
4465 case R_PARISC_TLS_DTPOFF32:
4466 case R_PARISC_TLS_TPREL32:
4467 return reloc_class_normal;
4470 if (ELF32_R_SYM (rela->r_info) == 0)
4471 return reloc_class_relative;
4473 switch ((int) ELF32_R_TYPE (rela->r_info))
4475 case R_PARISC_IPLT:
4476 return reloc_class_plt;
4477 case R_PARISC_COPY:
4478 return reloc_class_copy;
4479 default:
4480 return reloc_class_normal;
4484 /* Finish up the dynamic sections. */
4486 static bfd_boolean
4487 elf32_hppa_finish_dynamic_sections (bfd *output_bfd,
4488 struct bfd_link_info *info)
4490 bfd *dynobj;
4491 struct elf32_hppa_link_hash_table *htab;
4492 asection *sdyn;
4494 htab = hppa_link_hash_table (info);
4495 dynobj = htab->etab.dynobj;
4497 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4499 if (htab->etab.dynamic_sections_created)
4501 Elf32_External_Dyn *dyncon, *dynconend;
4503 if (sdyn == NULL)
4504 abort ();
4506 dyncon = (Elf32_External_Dyn *) sdyn->contents;
4507 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4508 for (; dyncon < dynconend; dyncon++)
4510 Elf_Internal_Dyn dyn;
4511 asection *s;
4513 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4515 switch (dyn.d_tag)
4517 default:
4518 continue;
4520 case DT_PLTGOT:
4521 /* Use PLTGOT to set the GOT register. */
4522 dyn.d_un.d_ptr = elf_gp (output_bfd);
4523 break;
4525 case DT_JMPREL:
4526 s = htab->srelplt;
4527 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4528 break;
4530 case DT_PLTRELSZ:
4531 s = htab->srelplt;
4532 dyn.d_un.d_val = s->size;
4533 break;
4535 case DT_RELASZ:
4536 /* Don't count procedure linkage table relocs in the
4537 overall reloc count. */
4538 s = htab->srelplt;
4539 if (s == NULL)
4540 continue;
4541 dyn.d_un.d_val -= s->size;
4542 break;
4544 case DT_RELA:
4545 /* We may not be using the standard ELF linker script.
4546 If .rela.plt is the first .rela section, we adjust
4547 DT_RELA to not include it. */
4548 s = htab->srelplt;
4549 if (s == NULL)
4550 continue;
4551 if (dyn.d_un.d_ptr != s->output_section->vma + s->output_offset)
4552 continue;
4553 dyn.d_un.d_ptr += s->size;
4554 break;
4557 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4561 if (htab->sgot != NULL && htab->sgot->size != 0)
4563 /* Fill in the first entry in the global offset table.
4564 We use it to point to our dynamic section, if we have one. */
4565 bfd_put_32 (output_bfd,
4566 sdyn ? sdyn->output_section->vma + sdyn->output_offset : 0,
4567 htab->sgot->contents);
4569 /* The second entry is reserved for use by the dynamic linker. */
4570 memset (htab->sgot->contents + GOT_ENTRY_SIZE, 0, GOT_ENTRY_SIZE);
4572 /* Set .got entry size. */
4573 elf_section_data (htab->sgot->output_section)
4574 ->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
4577 if (htab->splt != NULL && htab->splt->size != 0)
4579 /* Set plt entry size. */
4580 elf_section_data (htab->splt->output_section)
4581 ->this_hdr.sh_entsize = PLT_ENTRY_SIZE;
4583 if (htab->need_plt_stub)
4585 /* Set up the .plt stub. */
4586 memcpy (htab->splt->contents
4587 + htab->splt->size - sizeof (plt_stub),
4588 plt_stub, sizeof (plt_stub));
4590 if ((htab->splt->output_offset
4591 + htab->splt->output_section->vma
4592 + htab->splt->size)
4593 != (htab->sgot->output_offset
4594 + htab->sgot->output_section->vma))
4596 (*_bfd_error_handler)
4597 (_(".got section not immediately after .plt section"));
4598 return FALSE;
4603 return TRUE;
4606 /* Called when writing out an object file to decide the type of a
4607 symbol. */
4608 static int
4609 elf32_hppa_elf_get_symbol_type (Elf_Internal_Sym *elf_sym, int type)
4611 if (ELF_ST_TYPE (elf_sym->st_info) == STT_PARISC_MILLI)
4612 return STT_PARISC_MILLI;
4613 else
4614 return type;
4617 /* Misc BFD support code. */
4618 #define bfd_elf32_bfd_is_local_label_name elf_hppa_is_local_label_name
4619 #define bfd_elf32_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
4620 #define bfd_elf32_bfd_reloc_name_lookup elf_hppa_reloc_name_lookup
4621 #define elf_info_to_howto elf_hppa_info_to_howto
4622 #define elf_info_to_howto_rel elf_hppa_info_to_howto_rel
4624 /* Stuff for the BFD linker. */
4625 #define bfd_elf32_mkobject elf32_hppa_mkobject
4626 #define bfd_elf32_bfd_final_link elf32_hppa_final_link
4627 #define bfd_elf32_bfd_link_hash_table_create elf32_hppa_link_hash_table_create
4628 #define bfd_elf32_bfd_link_hash_table_free elf32_hppa_link_hash_table_free
4629 #define elf_backend_adjust_dynamic_symbol elf32_hppa_adjust_dynamic_symbol
4630 #define elf_backend_copy_indirect_symbol elf32_hppa_copy_indirect_symbol
4631 #define elf_backend_check_relocs elf32_hppa_check_relocs
4632 #define elf_backend_create_dynamic_sections elf32_hppa_create_dynamic_sections
4633 #define elf_backend_fake_sections elf_hppa_fake_sections
4634 #define elf_backend_relocate_section elf32_hppa_relocate_section
4635 #define elf_backend_hide_symbol elf32_hppa_hide_symbol
4636 #define elf_backend_finish_dynamic_symbol elf32_hppa_finish_dynamic_symbol
4637 #define elf_backend_finish_dynamic_sections elf32_hppa_finish_dynamic_sections
4638 #define elf_backend_size_dynamic_sections elf32_hppa_size_dynamic_sections
4639 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
4640 #define elf_backend_gc_mark_hook elf32_hppa_gc_mark_hook
4641 #define elf_backend_gc_sweep_hook elf32_hppa_gc_sweep_hook
4642 #define elf_backend_grok_prstatus elf32_hppa_grok_prstatus
4643 #define elf_backend_grok_psinfo elf32_hppa_grok_psinfo
4644 #define elf_backend_object_p elf32_hppa_object_p
4645 #define elf_backend_final_write_processing elf_hppa_final_write_processing
4646 #define elf_backend_post_process_headers _bfd_elf_set_osabi
4647 #define elf_backend_get_symbol_type elf32_hppa_elf_get_symbol_type
4648 #define elf_backend_reloc_type_class elf32_hppa_reloc_type_class
4649 #define elf_backend_action_discarded elf_hppa_action_discarded
4651 #define elf_backend_can_gc_sections 1
4652 #define elf_backend_can_refcount 1
4653 #define elf_backend_plt_alignment 2
4654 #define elf_backend_want_got_plt 0
4655 #define elf_backend_plt_readonly 0
4656 #define elf_backend_want_plt_sym 0
4657 #define elf_backend_got_header_size 8
4658 #define elf_backend_rela_normal 1
4660 #define TARGET_BIG_SYM bfd_elf32_hppa_vec
4661 #define TARGET_BIG_NAME "elf32-hppa"
4662 #define ELF_ARCH bfd_arch_hppa
4663 #define ELF_MACHINE_CODE EM_PARISC
4664 #define ELF_MAXPAGESIZE 0x1000
4665 #define ELF_OSABI ELFOSABI_HPUX
4666 #define elf32_bed elf32_hppa_hpux_bed
4668 #include "elf32-target.h"
4670 #undef TARGET_BIG_SYM
4671 #define TARGET_BIG_SYM bfd_elf32_hppa_linux_vec
4672 #undef TARGET_BIG_NAME
4673 #define TARGET_BIG_NAME "elf32-hppa-linux"
4674 #undef ELF_OSABI
4675 #define ELF_OSABI ELFOSABI_LINUX
4676 #undef elf32_bed
4677 #define elf32_bed elf32_hppa_linux_bed
4679 #include "elf32-target.h"
4681 #undef TARGET_BIG_SYM
4682 #define TARGET_BIG_SYM bfd_elf32_hppa_nbsd_vec
4683 #undef TARGET_BIG_NAME
4684 #define TARGET_BIG_NAME "elf32-hppa-netbsd"
4685 #undef ELF_OSABI
4686 #define ELF_OSABI ELFOSABI_NETBSD
4687 #undef elf32_bed
4688 #define elf32_bed elf32_hppa_netbsd_bed
4690 #include "elf32-target.h"