]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - bfd/elf32-hppa.c
* elf32-hppa.c (elf32_hppa_size_dynamic_sections): Set DT_RELASZ
[thirdparty/binutils-gdb.git] / bfd / elf32-hppa.c
CommitLineData
252b5132 1/* BFD back-end for HP PA-RISC ELF files.
7898deda 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000, 2001
252b5132
RH
3 Free Software Foundation, Inc.
4
30667bf3 5 Original code by
252b5132
RH
6 Center for Software Science
7 Department of Computer Science
8 University of Utah
30667bf3 9 Largely rewritten by Alan Modra <alan@linuxcare.com.au>
252b5132
RH
10
11This file is part of BFD, the Binary File Descriptor library.
12
13This program is free software; you can redistribute it and/or modify
14it under the terms of the GNU General Public License as published by
15the Free Software Foundation; either version 2 of the License, or
16(at your option) any later version.
17
18This program is distributed in the hope that it will be useful,
19but WITHOUT ANY WARRANTY; without even the implied warranty of
20MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21GNU General Public License for more details.
22
23You should have received a copy of the GNU General Public License
24along with this program; if not, write to the Free Software
25Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26
27#include "bfd.h"
28#include "sysdep.h"
252b5132
RH
29#include "libbfd.h"
30#include "elf-bfd.h"
9e103c9c
JL
31#include "elf/hppa.h"
32#include "libhppa.h"
33#include "elf32-hppa.h"
34#define ARCH_SIZE 32
35#include "elf-hppa.h"
edd21aca 36#include "elf32-hppa.h"
9e103c9c 37
74d1c347
AM
38/* In order to gain some understanding of code in this file without
39 knowing all the intricate details of the linker, note the
40 following:
41
42 Functions named elf32_hppa_* are called by external routines, other
43 functions are only called locally. elf32_hppa_* functions appear
44 in this file more or less in the order in which they are called
45 from external routines. eg. elf32_hppa_check_relocs is called
46 early in the link process, elf32_hppa_finish_dynamic_sections is
47 one of the last functions. */
48
edd21aca 49/* We use two hash tables to hold information for linking PA ELF objects.
252b5132
RH
50
51 The first is the elf32_hppa_link_hash_table which is derived
52 from the standard ELF linker hash table. We use this as a place to
53 attach other hash tables and static information.
54
55 The second is the stub hash table which is derived from the
56 base BFD hash table. The stub hash table holds the information
30667bf3
AM
57 necessary to build the linker stubs during a link.
58
59 There are a number of different stubs generated by the linker.
60
61 Long branch stub:
62 : ldil LR'X,%r1
63 : be,n RR'X(%sr4,%r1)
64
65 PIC long branch stub:
66 : b,l .+8,%r1
3ee1d854
AM
67 : addil LR'X - ($PIC_pcrel$0 - 4),%r1
68 : be,n RR'X - ($PIC_pcrel$0 - 8)(%sr4,%r1)
30667bf3
AM
69
70 Import stub to call shared library routine from normal object file
71 (single sub-space version)
3ee1d854
AM
72 : addil LR'lt_ptr+ltoff,%dp ; get procedure entry point
73 : ldw RR'lt_ptr+ltoff(%r1),%r21
30667bf3 74 : bv %r0(%r21)
3ee1d854 75 : ldw RR'lt_ptr+ltoff+4(%r1),%r19 ; get new dlt value.
30667bf3
AM
76
77 Import stub to call shared library routine from shared library
78 (single sub-space version)
3ee1d854
AM
79 : addil LR'ltoff,%r19 ; get procedure entry point
80 : ldw RR'ltoff(%r1),%r21
30667bf3 81 : bv %r0(%r21)
3ee1d854 82 : ldw RR'ltoff+4(%r1),%r19 ; get new dlt value.
30667bf3
AM
83
84 Import stub to call shared library routine from normal object file
85 (multiple sub-space support)
3ee1d854
AM
86 : addil LR'lt_ptr+ltoff,%dp ; get procedure entry point
87 : ldw RR'lt_ptr+ltoff(%r1),%r21
88 : ldw RR'lt_ptr+ltoff+4(%r1),%r19 ; get new dlt value.
30667bf3
AM
89 : ldsid (%r21),%r1
90 : mtsp %r1,%sr0
91 : be 0(%sr0,%r21) ; branch to target
92 : stw %rp,-24(%sp) ; save rp
93
94 Import stub to call shared library routine from shared library
95 (multiple sub-space support)
3ee1d854
AM
96 : addil LR'ltoff,%r19 ; get procedure entry point
97 : ldw RR'ltoff(%r1),%r21
98 : ldw RR'ltoff+4(%r1),%r19 ; get new dlt value.
30667bf3
AM
99 : ldsid (%r21),%r1
100 : mtsp %r1,%sr0
101 : be 0(%sr0,%r21) ; branch to target
102 : stw %rp,-24(%sp) ; save rp
103
104 Export stub to return from shared lib routine (multiple sub-space support)
105 One of these is created for each exported procedure in a shared
106 library (and stored in the shared lib). Shared lib routines are
107 called via the first instruction in the export stub so that we can
108 do an inter-space return. Not required for single sub-space.
109 : bl,n X,%rp ; trap the return
110 : nop
111 : ldw -24(%sp),%rp ; restore the original rp
112 : ldsid (%rp),%r1
113 : mtsp %r1,%sr0
74d1c347 114 : be,n 0(%sr0,%rp) ; inter-space return */
30667bf3
AM
115
116#define PLT_ENTRY_SIZE 8
74d1c347 117#define PLABEL_PLT_ENTRY_SIZE PLT_ENTRY_SIZE
30667bf3
AM
118#define GOT_ENTRY_SIZE 4
119#define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
120
47d89dba
AM
121static const bfd_byte plt_stub[] =
122{
123 0x0e, 0x80, 0x10, 0x96, /* 1: ldw 0(%r20),%r22 */
124 0xea, 0xc0, 0xc0, 0x00, /* bv %r0(%r22) */
125 0x0e, 0x88, 0x10, 0x95, /* ldw 4(%r20),%r21 */
126#define PLT_STUB_ENTRY (3*4)
127 0xea, 0x9f, 0x1f, 0xdd, /* b,l 1b,%r20 */
128 0xd6, 0x80, 0x1c, 0x1e, /* depi 0,31,2,%r20 */
129 0x00, 0xc0, 0xff, 0xee, /* 9: .word fixup_func */
130 0xde, 0xad, 0xbe, 0xef /* .word fixup_ltp */
131};
132
30667bf3
AM
133/* Section name for stubs is the associated section name plus this
134 string. */
135#define STUB_SUFFIX ".stub"
136
98ceb8ce
AM
137/* We don't need to copy certain PC- or GP-relative dynamic relocs
138 into a shared object's dynamic section. All the relocs of the
139 limited class we are interested in, are absolute. */
140#ifndef RELATIVE_DYNRELOCS
141#define RELATIVE_DYNRELOCS 0
446f2863 142#define IS_ABSOLUTE_RELOC(r_type) 1
30667bf3
AM
143#endif
144
30667bf3
AM
145enum elf32_hppa_stub_type {
146 hppa_stub_long_branch,
147 hppa_stub_long_branch_shared,
148 hppa_stub_import,
149 hppa_stub_import_shared,
150 hppa_stub_export,
151 hppa_stub_none
152};
153
30667bf3 154struct elf32_hppa_stub_hash_entry {
252b5132 155
edd21aca 156 /* Base hash table entry structure. */
252b5132
RH
157 struct bfd_hash_entry root;
158
edd21aca
AM
159 /* The stub section. */
160 asection *stub_sec;
161
162 /* Offset within stub_sec of the beginning of this stub. */
30667bf3 163 bfd_vma stub_offset;
252b5132
RH
164
165 /* Given the symbol's value and its section we can determine its final
166 value when building the stubs (so the stub knows where to jump. */
30667bf3 167 bfd_vma target_value;
252b5132 168 asection *target_section;
30667bf3
AM
169
170 enum elf32_hppa_stub_type stub_type;
171
172 /* The symbol table entry, if any, that this was derived from. */
173 struct elf32_hppa_link_hash_entry *h;
174
25f72752
AM
175 /* Where this stub is being called from, or, in the case of combined
176 stub sections, the first input section in the group. */
177 asection *id_sec;
252b5132
RH
178};
179
30667bf3
AM
180struct elf32_hppa_link_hash_entry {
181
182 struct elf_link_hash_entry elf;
183
184 /* A pointer to the most recently used stub hash entry against this
185 symbol. */
186 struct elf32_hppa_stub_hash_entry *stub_cache;
187
30667bf3
AM
188 /* Used to count relocations for delayed sizing of relocation
189 sections. */
190 struct elf32_hppa_dyn_reloc_entry {
191
192 /* Next relocation in the chain. */
193 struct elf32_hppa_dyn_reloc_entry *next;
194
98ceb8ce
AM
195 /* The input section of the reloc. */
196 asection *sec;
30667bf3
AM
197
198 /* Number of relocs copied in this section. */
199 bfd_size_type count;
98ceb8ce
AM
200
201#if RELATIVE_DYNRELOCS
202 /* Number of relative relocs copied for the input section. */
203 bfd_size_type relative_count;
204#endif
205 } *dyn_relocs;
30667bf3
AM
206
207 /* Set during a static link if we detect a function is PIC. */
12cca0d2
AM
208 unsigned int maybe_pic_call:1;
209
210 /* Set if the only reason we need a .plt entry is for a non-PIC to
211 PIC function call. */
74d1c347
AM
212 unsigned int pic_call:1;
213
214 /* Set if this symbol is used by a plabel reloc. */
215 unsigned int plabel:1;
30667bf3
AM
216};
217
30667bf3
AM
218struct elf32_hppa_link_hash_table {
219
252b5132 220 /* The main hash table. */
ebe50bae 221 struct elf_link_hash_table elf;
252b5132
RH
222
223 /* The stub hash table. */
edd21aca 224 struct bfd_hash_table stub_hash_table;
252b5132 225
30667bf3
AM
226 /* Linker stub bfd. */
227 bfd *stub_bfd;
228
30667bf3
AM
229 /* Linker call-backs. */
230 asection * (*add_stub_section) PARAMS ((const char *, asection *));
231 void (*layout_sections_again) PARAMS ((void));
232
25f72752
AM
233 /* Array to keep track of which stub sections have been created, and
234 information on stub grouping. */
235 struct map_stub {
236 /* This is the section to which stubs in the group will be
237 attached. */
238 asection *link_sec;
239 /* The stub section. */
240 asection *stub_sec;
25f72752 241 } *stub_group;
30667bf3 242
30667bf3
AM
243 /* Short-cuts to get to dynamic linker sections. */
244 asection *sgot;
245 asection *srelgot;
246 asection *splt;
247 asection *srelplt;
248 asection *sdynbss;
249 asection *srelbss;
47d89dba 250
c46b7515
AM
251 /* Used during a final link to store the base of the text and data
252 segments so that we can perform SEGREL relocations. */
253 bfd_vma text_segment_base;
254 bfd_vma data_segment_base;
255
47d89dba
AM
256 /* Whether we support multiple sub-spaces for shared libs. */
257 unsigned int multi_subspace:1;
258
259 /* Flags set when PCREL12F and PCREL17F branches detected. Used to
260 select suitable defaults for the stub group size. */
261 unsigned int has_12bit_branch:1;
262 unsigned int has_17bit_branch:1;
263
264 /* Set if we need a .plt stub to support lazy dynamic linking. */
265 unsigned int need_plt_stub:1;
252b5132
RH
266};
267
30667bf3
AM
268/* Various hash macros and functions. */
269#define hppa_link_hash_table(p) \
edd21aca 270 ((struct elf32_hppa_link_hash_table *) ((p)->hash))
252b5132 271
30667bf3
AM
272#define hppa_stub_hash_lookup(table, string, create, copy) \
273 ((struct elf32_hppa_stub_hash_entry *) \
274 bfd_hash_lookup ((table), (string), (create), (copy)))
275
276static struct bfd_hash_entry *stub_hash_newfunc
277 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
edd21aca 278
30667bf3 279static struct bfd_hash_entry *hppa_link_hash_newfunc
edd21aca 280 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
252b5132
RH
281
282static struct bfd_link_hash_table *elf32_hppa_link_hash_table_create
283 PARAMS ((bfd *));
284
30667bf3
AM
285/* Stub handling functions. */
286static char *hppa_stub_name
287 PARAMS ((const asection *, const asection *,
288 const struct elf32_hppa_link_hash_entry *,
289 const Elf_Internal_Rela *));
edd21aca 290
30667bf3
AM
291static struct elf32_hppa_stub_hash_entry *hppa_get_stub_entry
292 PARAMS ((const asection *, const asection *,
293 struct elf32_hppa_link_hash_entry *,
25f72752
AM
294 const Elf_Internal_Rela *,
295 struct elf32_hppa_link_hash_table *));
edd21aca 296
30667bf3 297static struct elf32_hppa_stub_hash_entry *hppa_add_stub
25f72752 298 PARAMS ((const char *, asection *, struct elf32_hppa_link_hash_table *));
30667bf3
AM
299
300static enum elf32_hppa_stub_type hppa_type_of_stub
301 PARAMS ((asection *, const Elf_Internal_Rela *,
302 struct elf32_hppa_link_hash_entry *, bfd_vma));
303
304static boolean hppa_build_one_stub
305 PARAMS ((struct bfd_hash_entry *, PTR));
306
307static boolean hppa_size_one_stub
308 PARAMS ((struct bfd_hash_entry *, PTR));
309
30667bf3
AM
310/* BFD and elf backend functions. */
311static boolean elf32_hppa_object_p PARAMS ((bfd *));
252b5132 312
edd21aca
AM
313static boolean elf32_hppa_add_symbol_hook
314 PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
315 const char **, flagword *, asection **, bfd_vma *));
252b5132 316
30667bf3
AM
317static boolean elf32_hppa_create_dynamic_sections
318 PARAMS ((bfd *, struct bfd_link_info *));
252b5132 319
ebe50bae
AM
320static void elf32_hppa_copy_indirect_symbol
321 PARAMS ((struct elf_link_hash_entry *, struct elf_link_hash_entry *));
322
30667bf3
AM
323static boolean elf32_hppa_check_relocs
324 PARAMS ((bfd *, struct bfd_link_info *,
325 asection *, const Elf_Internal_Rela *));
326
327static asection *elf32_hppa_gc_mark_hook
328 PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
329 struct elf_link_hash_entry *, Elf_Internal_Sym *));
330
331static boolean elf32_hppa_gc_sweep_hook
332 PARAMS ((bfd *, struct bfd_link_info *,
333 asection *, const Elf_Internal_Rela *));
334
74d1c347
AM
335static void elf32_hppa_hide_symbol
336 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
337
30667bf3
AM
338static boolean elf32_hppa_adjust_dynamic_symbol
339 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
340
341static boolean hppa_handle_PIC_calls
342 PARAMS ((struct elf_link_hash_entry *, PTR));
343
98ceb8ce
AM
344static boolean allocate_dynrelocs
345 PARAMS ((struct elf_link_hash_entry *, PTR));
346
347static boolean readonly_dynrelocs
30667bf3 348 PARAMS ((struct elf_link_hash_entry *, PTR));
30667bf3 349
d5c73c2f
AM
350static boolean clobber_millicode_symbols
351 PARAMS ((struct elf_link_hash_entry *, struct bfd_link_info *));
352
30667bf3
AM
353static boolean elf32_hppa_size_dynamic_sections
354 PARAMS ((bfd *, struct bfd_link_info *));
355
c46b7515
AM
356static boolean elf32_hppa_final_link
357 PARAMS ((bfd *, struct bfd_link_info *));
358
359static void hppa_record_segment_addr
360 PARAMS ((bfd *, asection *, PTR));
361
30667bf3
AM
362static bfd_reloc_status_type final_link_relocate
363 PARAMS ((asection *, bfd_byte *, const Elf_Internal_Rela *,
25f72752 364 bfd_vma, struct elf32_hppa_link_hash_table *, asection *,
30667bf3
AM
365 struct elf32_hppa_link_hash_entry *));
366
367static boolean elf32_hppa_relocate_section
368 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
369 bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
370
c46b7515
AM
371static int hppa_unwind_entry_compare
372 PARAMS ((const PTR, const PTR));
373
30667bf3
AM
374static boolean elf32_hppa_finish_dynamic_symbol
375 PARAMS ((bfd *, struct bfd_link_info *,
376 struct elf_link_hash_entry *, Elf_Internal_Sym *));
377
98ceb8ce
AM
378static enum elf_reloc_type_class elf32_hppa_reloc_type_class
379 PARAMS ((const Elf_Internal_Rela *));
380
30667bf3
AM
381static boolean elf32_hppa_finish_dynamic_sections
382 PARAMS ((bfd *, struct bfd_link_info *));
383
d952f17a
AM
384static void elf32_hppa_post_process_headers
385 PARAMS ((bfd *, struct bfd_link_info *));
386
30667bf3
AM
387static int elf32_hppa_elf_get_symbol_type
388 PARAMS ((Elf_Internal_Sym *, int));
252b5132 389
252b5132
RH
390/* Assorted hash table functions. */
391
392/* Initialize an entry in the stub hash table. */
393
394static struct bfd_hash_entry *
30667bf3 395stub_hash_newfunc (entry, table, string)
252b5132
RH
396 struct bfd_hash_entry *entry;
397 struct bfd_hash_table *table;
398 const char *string;
399{
252b5132
RH
400 /* Allocate the structure if it has not already been allocated by a
401 subclass. */
ebe50bae 402 if (entry == NULL)
30667bf3 403 {
ebe50bae
AM
404 entry = bfd_hash_allocate (table,
405 sizeof (struct elf32_hppa_stub_hash_entry));
406 if (entry == NULL)
407 return entry;
30667bf3 408 }
252b5132
RH
409
410 /* Call the allocation method of the superclass. */
ebe50bae
AM
411 entry = bfd_hash_newfunc (entry, table, string);
412 if (entry != NULL)
252b5132 413 {
ebe50bae
AM
414 struct elf32_hppa_stub_hash_entry *eh;
415
252b5132 416 /* Initialize the local fields. */
ebe50bae
AM
417 eh = (struct elf32_hppa_stub_hash_entry *) entry;
418 eh->stub_sec = NULL;
419 eh->stub_offset = 0;
420 eh->target_value = 0;
421 eh->target_section = NULL;
422 eh->stub_type = hppa_stub_long_branch;
423 eh->h = NULL;
424 eh->id_sec = NULL;
30667bf3
AM
425 }
426
ebe50bae 427 return entry;
30667bf3
AM
428}
429
30667bf3
AM
430/* Initialize an entry in the link hash table. */
431
432static struct bfd_hash_entry *
433hppa_link_hash_newfunc (entry, table, string)
434 struct bfd_hash_entry *entry;
435 struct bfd_hash_table *table;
436 const char *string;
437{
30667bf3
AM
438 /* Allocate the structure if it has not already been allocated by a
439 subclass. */
ebe50bae 440 if (entry == NULL)
30667bf3 441 {
ebe50bae
AM
442 entry = bfd_hash_allocate (table,
443 sizeof (struct elf32_hppa_link_hash_entry));
444 if (entry == NULL)
445 return entry;
30667bf3
AM
446 }
447
448 /* Call the allocation method of the superclass. */
ebe50bae
AM
449 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
450 if (entry != NULL)
30667bf3 451 {
ebe50bae
AM
452 struct elf32_hppa_link_hash_entry *eh;
453
30667bf3 454 /* Initialize the local fields. */
ebe50bae
AM
455 eh = (struct elf32_hppa_link_hash_entry *) entry;
456 eh->stub_cache = NULL;
457 eh->dyn_relocs = NULL;
458 eh->maybe_pic_call = 0;
459 eh->pic_call = 0;
460 eh->plabel = 0;
252b5132
RH
461 }
462
ebe50bae 463 return entry;
252b5132
RH
464}
465
252b5132
RH
466/* Create the derived linker hash table. The PA ELF port uses the derived
467 hash table to keep information specific to the PA ELF linker (without
468 using static variables). */
469
470static struct bfd_link_hash_table *
471elf32_hppa_link_hash_table_create (abfd)
472 bfd *abfd;
473{
474 struct elf32_hppa_link_hash_table *ret;
dc810e39 475 bfd_size_type amt = sizeof (*ret);
252b5132 476
dc810e39 477 ret = (struct elf32_hppa_link_hash_table *) bfd_alloc (abfd, amt);
252b5132
RH
478 if (ret == NULL)
479 return NULL;
edd21aca 480
ebe50bae 481 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, hppa_link_hash_newfunc))
252b5132
RH
482 {
483 bfd_release (abfd, ret);
484 return NULL;
485 }
edd21aca
AM
486
487 /* Init the stub hash table too. */
30667bf3 488 if (!bfd_hash_table_init (&ret->stub_hash_table, stub_hash_newfunc))
edd21aca
AM
489 return NULL;
490
30667bf3 491 ret->stub_bfd = NULL;
30667bf3
AM
492 ret->add_stub_section = NULL;
493 ret->layout_sections_again = NULL;
25f72752 494 ret->stub_group = NULL;
30667bf3
AM
495 ret->sgot = NULL;
496 ret->srelgot = NULL;
497 ret->splt = NULL;
498 ret->srelplt = NULL;
499 ret->sdynbss = NULL;
500 ret->srelbss = NULL;
c46b7515
AM
501 ret->text_segment_base = (bfd_vma) -1;
502 ret->data_segment_base = (bfd_vma) -1;
47d89dba
AM
503 ret->multi_subspace = 0;
504 ret->has_12bit_branch = 0;
505 ret->has_17bit_branch = 0;
506 ret->need_plt_stub = 0;
252b5132 507
ebe50bae 508 return &ret->elf.root;
252b5132
RH
509}
510
30667bf3
AM
511/* Build a name for an entry in the stub hash table. */
512
edd21aca 513static char *
30667bf3 514hppa_stub_name (input_section, sym_sec, hash, rel)
edd21aca 515 const asection *input_section;
30667bf3
AM
516 const asection *sym_sec;
517 const struct elf32_hppa_link_hash_entry *hash;
518 const Elf_Internal_Rela *rel;
edd21aca
AM
519{
520 char *stub_name;
dc810e39 521 bfd_size_type len;
edd21aca 522
30667bf3
AM
523 if (hash)
524 {
525 len = 8 + 1 + strlen (hash->elf.root.root.string) + 1 + 8 + 1;
526 stub_name = bfd_malloc (len);
527 if (stub_name != NULL)
528 {
529 sprintf (stub_name, "%08x_%s+%x",
530 input_section->id & 0xffffffff,
531 hash->elf.root.root.string,
532 (int) rel->r_addend & 0xffffffff);
533 }
534 }
535 else
edd21aca 536 {
30667bf3
AM
537 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
538 stub_name = bfd_malloc (len);
539 if (stub_name != NULL)
540 {
541 sprintf (stub_name, "%08x_%x:%x+%x",
542 input_section->id & 0xffffffff,
543 sym_sec->id & 0xffffffff,
544 (int) ELF32_R_SYM (rel->r_info) & 0xffffffff,
545 (int) rel->r_addend & 0xffffffff);
546 }
edd21aca
AM
547 }
548 return stub_name;
549}
252b5132 550
30667bf3
AM
551/* Look up an entry in the stub hash. Stub entries are cached because
552 creating the stub name takes a bit of time. */
553
554static struct elf32_hppa_stub_hash_entry *
83c81bfe 555hppa_get_stub_entry (input_section, sym_sec, hash, rel, htab)
30667bf3
AM
556 const asection *input_section;
557 const asection *sym_sec;
558 struct elf32_hppa_link_hash_entry *hash;
559 const Elf_Internal_Rela *rel;
83c81bfe 560 struct elf32_hppa_link_hash_table *htab;
252b5132 561{
30667bf3 562 struct elf32_hppa_stub_hash_entry *stub_entry;
25f72752
AM
563 const asection *id_sec;
564
565 /* If this input section is part of a group of sections sharing one
566 stub section, then use the id of the first section in the group.
567 Stub names need to include a section id, as there may well be
568 more than one stub used to reach say, printf, and we need to
569 distinguish between them. */
83c81bfe 570 id_sec = htab->stub_group[input_section->id].link_sec;
edd21aca 571
30667bf3
AM
572 if (hash != NULL && hash->stub_cache != NULL
573 && hash->stub_cache->h == hash
25f72752 574 && hash->stub_cache->id_sec == id_sec)
edd21aca 575 {
30667bf3
AM
576 stub_entry = hash->stub_cache;
577 }
578 else
579 {
30667bf3 580 char *stub_name;
edd21aca 581
25f72752 582 stub_name = hppa_stub_name (id_sec, sym_sec, hash, rel);
30667bf3
AM
583 if (stub_name == NULL)
584 return NULL;
edd21aca 585
83c81bfe 586 stub_entry = hppa_stub_hash_lookup (&htab->stub_hash_table,
25f72752 587 stub_name, false, false);
30667bf3
AM
588 if (stub_entry == NULL)
589 {
590 if (hash == NULL || hash->elf.root.type != bfd_link_hash_undefweak)
591 (*_bfd_error_handler) (_("%s(%s+0x%lx): cannot find stub entry %s"),
8f615d07 592 bfd_archive_filename (input_section->owner),
30667bf3
AM
593 input_section->name,
594 (long) rel->r_offset,
595 stub_name);
596 }
597 else
598 {
599 if (hash != NULL)
600 hash->stub_cache = stub_entry;
601 }
602
603 free (stub_name);
edd21aca 604 }
30667bf3
AM
605
606 return stub_entry;
607}
608
30667bf3
AM
609/* Add a new stub entry to the stub hash. Not all fields of the new
610 stub entry are initialised. */
611
612static struct elf32_hppa_stub_hash_entry *
83c81bfe 613hppa_add_stub (stub_name, section, htab)
30667bf3
AM
614 const char *stub_name;
615 asection *section;
83c81bfe 616 struct elf32_hppa_link_hash_table *htab;
30667bf3 617{
25f72752 618 asection *link_sec;
30667bf3 619 asection *stub_sec;
30667bf3 620 struct elf32_hppa_stub_hash_entry *stub_entry;
edd21aca 621
83c81bfe
AM
622 link_sec = htab->stub_group[section->id].link_sec;
623 stub_sec = htab->stub_group[section->id].stub_sec;
30667bf3 624 if (stub_sec == NULL)
edd21aca 625 {
83c81bfe 626 stub_sec = htab->stub_group[link_sec->id].stub_sec;
30667bf3
AM
627 if (stub_sec == NULL)
628 {
dc810e39 629 bfd_size_type len;
30667bf3
AM
630 char *s_name;
631
25f72752 632 len = strlen (link_sec->name) + sizeof (STUB_SUFFIX);
83c81bfe 633 s_name = bfd_alloc (htab->stub_bfd, len);
30667bf3
AM
634 if (s_name == NULL)
635 return NULL;
636
25f72752 637 strcpy (s_name, link_sec->name);
30667bf3 638 strcpy (s_name + len - sizeof (STUB_SUFFIX), STUB_SUFFIX);
83c81bfe 639 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
30667bf3
AM
640 if (stub_sec == NULL)
641 return NULL;
83c81bfe 642 htab->stub_group[link_sec->id].stub_sec = stub_sec;
30667bf3 643 }
83c81bfe 644 htab->stub_group[section->id].stub_sec = stub_sec;
edd21aca 645 }
252b5132 646
30667bf3 647 /* Enter this entry into the linker stub hash table. */
83c81bfe 648 stub_entry = hppa_stub_hash_lookup (&htab->stub_hash_table, stub_name,
30667bf3
AM
649 true, false);
650 if (stub_entry == NULL)
651 {
652 (*_bfd_error_handler) (_("%s: cannot create stub entry %s"),
8f615d07 653 bfd_archive_filename (section->owner),
30667bf3
AM
654 stub_name);
655 return NULL;
edd21aca
AM
656 }
657
30667bf3 658 stub_entry->stub_sec = stub_sec;
30667bf3 659 stub_entry->stub_offset = 0;
25f72752 660 stub_entry->id_sec = link_sec;
30667bf3 661 return stub_entry;
edd21aca
AM
662}
663
30667bf3
AM
664/* Determine the type of stub needed, if any, for a call. */
665
666static enum elf32_hppa_stub_type
667hppa_type_of_stub (input_sec, rel, hash, destination)
668 asection *input_sec;
669 const Elf_Internal_Rela *rel;
670 struct elf32_hppa_link_hash_entry *hash;
671 bfd_vma destination;
edd21aca 672{
edd21aca 673 bfd_vma location;
30667bf3
AM
674 bfd_vma branch_offset;
675 bfd_vma max_branch_offset;
676 unsigned int r_type;
677
678 if (hash != NULL
679 && (((hash->elf.root.type == bfd_link_hash_defined
74d1c347
AM
680 || hash->elf.root.type == bfd_link_hash_defweak)
681 && hash->elf.root.u.def.section->output_section == NULL)
682 || (hash->elf.root.type == bfd_link_hash_defweak
683 && hash->elf.dynindx != -1
684 && hash->elf.plt.offset != (bfd_vma) -1)
30667bf3
AM
685 || hash->elf.root.type == bfd_link_hash_undefweak
686 || hash->elf.root.type == bfd_link_hash_undefined
12cca0d2 687 || (hash->maybe_pic_call && !(input_sec->flags & SEC_HAS_GOT_REF))))
30667bf3
AM
688 {
689 /* If output_section is NULL, then it's a symbol defined in a
690 shared library. We will need an import stub. Decide between
74d1c347
AM
691 hppa_stub_import and hppa_stub_import_shared later. For
692 shared links we need stubs for undefined or weak syms too;
693 They will presumably be resolved by the dynamic linker. */
30667bf3
AM
694 return hppa_stub_import;
695 }
edd21aca 696
30667bf3
AM
697 /* Determine where the call point is. */
698 location = (input_sec->output_offset
699 + input_sec->output_section->vma
700 + rel->r_offset);
edd21aca 701
30667bf3
AM
702 branch_offset = destination - location - 8;
703 r_type = ELF32_R_TYPE (rel->r_info);
edd21aca 704
30667bf3
AM
705 /* Determine if a long branch stub is needed. parisc branch offsets
706 are relative to the second instruction past the branch, ie. +8
707 bytes on from the branch instruction location. The offset is
708 signed and counts in units of 4 bytes. */
709 if (r_type == (unsigned int) R_PARISC_PCREL17F)
edd21aca 710 {
30667bf3
AM
711 max_branch_offset = (1 << (17-1)) << 2;
712 }
713 else if (r_type == (unsigned int) R_PARISC_PCREL12F)
714 {
715 max_branch_offset = (1 << (12-1)) << 2;
716 }
25f72752 717 else /* R_PARISC_PCREL22F. */
30667bf3
AM
718 {
719 max_branch_offset = (1 << (22-1)) << 2;
edd21aca
AM
720 }
721
30667bf3 722 if (branch_offset + max_branch_offset >= 2*max_branch_offset)
98ceb8ce
AM
723 return hppa_stub_long_branch;
724
30667bf3
AM
725 return hppa_stub_none;
726}
edd21aca 727
30667bf3
AM
728/* Build one linker stub as defined by the stub hash table entry GEN_ENTRY.
729 IN_ARG contains the link info pointer. */
edd21aca 730
30667bf3
AM
731#define LDIL_R1 0x20200000 /* ldil LR'XXX,%r1 */
732#define BE_SR4_R1 0xe0202002 /* be,n RR'XXX(%sr4,%r1) */
edd21aca 733
30667bf3 734#define BL_R1 0xe8200000 /* b,l .+8,%r1 */
3ee1d854 735#define ADDIL_R1 0x28200000 /* addil LR'XXX,%r1,%r1 */
30667bf3 736#define DEPI_R1 0xd4201c1e /* depi 0,31,2,%r1 */
252b5132 737
3ee1d854
AM
738#define ADDIL_DP 0x2b600000 /* addil LR'XXX,%dp,%r1 */
739#define LDW_R1_R21 0x48350000 /* ldw RR'XXX(%sr0,%r1),%r21 */
30667bf3 740#define BV_R0_R21 0xeaa0c000 /* bv %r0(%r21) */
3ee1d854 741#define LDW_R1_R19 0x48330000 /* ldw RR'XXX(%sr0,%r1),%r19 */
252b5132 742
3ee1d854
AM
743#define ADDIL_R19 0x2a600000 /* addil LR'XXX,%r19,%r1 */
744#define LDW_R1_DP 0x483b0000 /* ldw RR'XXX(%sr0,%r1),%dp */
edd21aca 745
30667bf3
AM
746#define LDSID_R21_R1 0x02a010a1 /* ldsid (%sr0,%r21),%r1 */
747#define MTSP_R1 0x00011820 /* mtsp %r1,%sr0 */
748#define BE_SR0_R21 0xe2a00000 /* be 0(%sr0,%r21) */
749#define STW_RP 0x6bc23fd1 /* stw %rp,-24(%sr0,%sp) */
edd21aca 750
30667bf3
AM
751#define BL_RP 0xe8400002 /* b,l,n XXX,%rp */
752#define NOP 0x08000240 /* nop */
753#define LDW_RP 0x4bc23fd1 /* ldw -24(%sr0,%sp),%rp */
754#define LDSID_RP_R1 0x004010a1 /* ldsid (%sr0,%rp),%r1 */
755#define BE_SR0_RP 0xe0400002 /* be,n 0(%sr0,%rp) */
edd21aca 756
30667bf3
AM
757#ifndef R19_STUBS
758#define R19_STUBS 1
759#endif
edd21aca 760
30667bf3
AM
761#if R19_STUBS
762#define LDW_R1_DLT LDW_R1_R19
763#else
764#define LDW_R1_DLT LDW_R1_DP
765#endif
edd21aca 766
30667bf3
AM
767static boolean
768hppa_build_one_stub (gen_entry, in_arg)
769 struct bfd_hash_entry *gen_entry;
770 PTR in_arg;
771{
772 struct elf32_hppa_stub_hash_entry *stub_entry;
773 struct bfd_link_info *info;
83c81bfe 774 struct elf32_hppa_link_hash_table *htab;
30667bf3
AM
775 asection *stub_sec;
776 bfd *stub_bfd;
777 bfd_byte *loc;
778 bfd_vma sym_value;
74d1c347 779 bfd_vma insn;
8dea1268 780 bfd_vma off;
74d1c347 781 int val;
30667bf3 782 int size;
edd21aca 783
30667bf3
AM
784 /* Massage our args to the form they really have. */
785 stub_entry = (struct elf32_hppa_stub_hash_entry *) gen_entry;
786 info = (struct bfd_link_info *) in_arg;
787
83c81bfe 788 htab = hppa_link_hash_table (info);
30667bf3 789 stub_sec = stub_entry->stub_sec;
edd21aca 790
30667bf3 791 /* Make a note of the offset within the stubs for this entry. */
74d1c347 792 stub_entry->stub_offset = stub_sec->_raw_size;
30667bf3 793 loc = stub_sec->contents + stub_entry->stub_offset;
252b5132 794
30667bf3
AM
795 stub_bfd = stub_sec->owner;
796
797 switch (stub_entry->stub_type)
798 {
799 case hppa_stub_long_branch:
800 /* Create the long branch. A long branch is formed with "ldil"
801 loading the upper bits of the target address into a register,
802 then branching with "be" which adds in the lower bits.
803 The "be" has its delay slot nullified. */
804 sym_value = (stub_entry->target_value
805 + stub_entry->target_section->output_offset
806 + stub_entry->target_section->output_section->vma);
807
74d1c347
AM
808 val = hppa_field_adjust (sym_value, (bfd_signed_vma) 0, e_lrsel);
809 insn = hppa_rebuild_insn ((int) LDIL_R1, val, 21);
30667bf3
AM
810 bfd_put_32 (stub_bfd, insn, loc);
811
74d1c347
AM
812 val = hppa_field_adjust (sym_value, (bfd_signed_vma) 0, e_rrsel) >> 2;
813 insn = hppa_rebuild_insn ((int) BE_SR4_R1, val, 17);
30667bf3
AM
814 bfd_put_32 (stub_bfd, insn, loc + 4);
815
30667bf3 816 size = 8;
edd21aca
AM
817 break;
818
30667bf3
AM
819 case hppa_stub_long_branch_shared:
820 /* Branches are relative. This is where we are going to. */
821 sym_value = (stub_entry->target_value
822 + stub_entry->target_section->output_offset
823 + stub_entry->target_section->output_section->vma);
824
825 /* And this is where we are coming from, more or less. */
826 sym_value -= (stub_entry->stub_offset
827 + stub_sec->output_offset
828 + stub_sec->output_section->vma);
829
74d1c347 830 bfd_put_32 (stub_bfd, (bfd_vma) BL_R1, loc);
47d89dba 831 val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_lrsel);
74d1c347 832 insn = hppa_rebuild_insn ((int) ADDIL_R1, val, 21);
30667bf3
AM
833 bfd_put_32 (stub_bfd, insn, loc + 4);
834
47d89dba 835 val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_rrsel) >> 2;
74d1c347 836 insn = hppa_rebuild_insn ((int) BE_SR4_R1, val, 17);
30667bf3
AM
837 bfd_put_32 (stub_bfd, insn, loc + 8);
838 size = 12;
839 break;
edd21aca 840
30667bf3
AM
841 case hppa_stub_import:
842 case hppa_stub_import_shared:
8dea1268
AM
843 off = stub_entry->h->elf.plt.offset;
844 if (off >= (bfd_vma) -2)
49e9d0d3 845 abort ();
8dea1268
AM
846
847 off &= ~ (bfd_vma) 1;
848 sym_value = (off
83c81bfe
AM
849 + htab->splt->output_offset
850 + htab->splt->output_section->vma
851 - elf_gp (htab->splt->output_section->owner));
30667bf3
AM
852
853 insn = ADDIL_DP;
854#if R19_STUBS
855 if (stub_entry->stub_type == hppa_stub_import_shared)
856 insn = ADDIL_R19;
857#endif
47d89dba 858 val = hppa_field_adjust (sym_value, (bfd_signed_vma) 0, e_lrsel),
74d1c347 859 insn = hppa_rebuild_insn ((int) insn, val, 21);
30667bf3 860 bfd_put_32 (stub_bfd, insn, loc);
edd21aca 861
47d89dba
AM
862 /* It is critical to use lrsel/rrsel here because we are using
863 two different offsets (+0 and +4) from sym_value. If we use
864 lsel/rsel then with unfortunate sym_values we will round
865 sym_value+4 up to the next 2k block leading to a mis-match
866 between the lsel and rsel value. */
867 val = hppa_field_adjust (sym_value, (bfd_signed_vma) 0, e_rrsel);
74d1c347 868 insn = hppa_rebuild_insn ((int) LDW_R1_R21, val, 14);
30667bf3 869 bfd_put_32 (stub_bfd, insn, loc + 4);
252b5132 870
83c81bfe 871 if (htab->multi_subspace)
30667bf3 872 {
47d89dba 873 val = hppa_field_adjust (sym_value, (bfd_signed_vma) 4, e_rrsel);
74d1c347 874 insn = hppa_rebuild_insn ((int) LDW_R1_DLT, val, 14);
30667bf3 875 bfd_put_32 (stub_bfd, insn, loc + 8);
252b5132 876
74d1c347
AM
877 bfd_put_32 (stub_bfd, (bfd_vma) LDSID_R21_R1, loc + 12);
878 bfd_put_32 (stub_bfd, (bfd_vma) MTSP_R1, loc + 16);
879 bfd_put_32 (stub_bfd, (bfd_vma) BE_SR0_R21, loc + 20);
880 bfd_put_32 (stub_bfd, (bfd_vma) STW_RP, loc + 24);
252b5132 881
30667bf3
AM
882 size = 28;
883 }
884 else
885 {
74d1c347 886 bfd_put_32 (stub_bfd, (bfd_vma) BV_R0_R21, loc + 8);
47d89dba 887 val = hppa_field_adjust (sym_value, (bfd_signed_vma) 4, e_rrsel);
74d1c347 888 insn = hppa_rebuild_insn ((int) LDW_R1_DLT, val, 14);
30667bf3 889 bfd_put_32 (stub_bfd, insn, loc + 12);
252b5132 890
30667bf3
AM
891 size = 16;
892 }
252b5132 893
30667bf3
AM
894 if (!info->shared
895 && stub_entry->h != NULL
896 && stub_entry->h->pic_call)
252b5132 897 {
30667bf3
AM
898 /* Build the .plt entry needed to call a PIC function from
899 statically linked code. We don't need any relocs. */
900 bfd *dynobj;
901 struct elf32_hppa_link_hash_entry *eh;
902 bfd_vma value;
252b5132 903
ebe50bae 904 dynobj = htab->elf.dynobj;
30667bf3 905 eh = (struct elf32_hppa_link_hash_entry *) stub_entry->h;
252b5132 906
49e9d0d3
AM
907 if (eh->elf.root.type != bfd_link_hash_defined
908 && eh->elf.root.type != bfd_link_hash_defweak)
909 abort ();
252b5132 910
30667bf3
AM
911 value = (eh->elf.root.u.def.value
912 + eh->elf.root.u.def.section->output_offset
913 + eh->elf.root.u.def.section->output_section->vma);
252b5132 914
30667bf3 915 /* Fill in the entry in the procedure linkage table.
252b5132 916
30667bf3 917 The format of a plt entry is
74d1c347
AM
918 <funcaddr>
919 <__gp>. */
252b5132 920
83c81bfe
AM
921 bfd_put_32 (htab->splt->owner, value,
922 htab->splt->contents + off);
923 value = elf_gp (htab->splt->output_section->owner);
924 bfd_put_32 (htab->splt->owner, value,
925 htab->splt->contents + off + 4);
252b5132 926 }
30667bf3 927 break;
252b5132 928
30667bf3
AM
929 case hppa_stub_export:
930 /* Branches are relative. This is where we are going to. */
931 sym_value = (stub_entry->target_value
932 + stub_entry->target_section->output_offset
933 + stub_entry->target_section->output_section->vma);
252b5132 934
30667bf3
AM
935 /* And this is where we are coming from. */
936 sym_value -= (stub_entry->stub_offset
937 + stub_sec->output_offset
938 + stub_sec->output_section->vma);
edd21aca 939
30667bf3
AM
940 if (sym_value - 8 + 0x40000 >= 0x80000)
941 {
edd21aca 942 (*_bfd_error_handler)
30667bf3 943 (_("%s(%s+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
8f615d07 944 bfd_archive_filename (stub_entry->target_section->owner),
30667bf3
AM
945 stub_sec->name,
946 (long) stub_entry->stub_offset,
947 stub_entry->root.string);
948 bfd_set_error (bfd_error_bad_value);
edd21aca 949 return false;
252b5132 950 }
30667bf3 951
74d1c347
AM
952 val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_fsel) >> 2;
953 insn = hppa_rebuild_insn ((int) BL_RP, val, 17);
30667bf3
AM
954 bfd_put_32 (stub_bfd, insn, loc);
955
74d1c347
AM
956 bfd_put_32 (stub_bfd, (bfd_vma) NOP, loc + 4);
957 bfd_put_32 (stub_bfd, (bfd_vma) LDW_RP, loc + 8);
958 bfd_put_32 (stub_bfd, (bfd_vma) LDSID_RP_R1, loc + 12);
959 bfd_put_32 (stub_bfd, (bfd_vma) MTSP_R1, loc + 16);
960 bfd_put_32 (stub_bfd, (bfd_vma) BE_SR0_RP, loc + 20);
30667bf3
AM
961
962 /* Point the function symbol at the stub. */
963 stub_entry->h->elf.root.u.def.section = stub_sec;
74d1c347 964 stub_entry->h->elf.root.u.def.value = stub_sec->_raw_size;
30667bf3
AM
965
966 size = 24;
967 break;
968
969 default:
970 BFD_FAIL ();
971 return false;
252b5132
RH
972 }
973
74d1c347 974 stub_sec->_raw_size += size;
252b5132
RH
975 return true;
976}
977
30667bf3
AM
978#undef LDIL_R1
979#undef BE_SR4_R1
980#undef BL_R1
981#undef ADDIL_R1
982#undef DEPI_R1
983#undef ADDIL_DP
984#undef LDW_R1_R21
985#undef LDW_R1_DLT
986#undef LDW_R1_R19
987#undef ADDIL_R19
988#undef LDW_R1_DP
989#undef LDSID_R21_R1
990#undef MTSP_R1
991#undef BE_SR0_R21
992#undef STW_RP
993#undef BV_R0_R21
994#undef BL_RP
995#undef NOP
996#undef LDW_RP
997#undef LDSID_RP_R1
998#undef BE_SR0_RP
252b5132 999
30667bf3
AM
1000/* As above, but don't actually build the stub. Just bump offset so
1001 we know stub section sizes. */
1002
1003static boolean
1004hppa_size_one_stub (gen_entry, in_arg)
1005 struct bfd_hash_entry *gen_entry;
1006 PTR in_arg;
252b5132 1007{
30667bf3 1008 struct elf32_hppa_stub_hash_entry *stub_entry;
83c81bfe 1009 struct elf32_hppa_link_hash_table *htab;
30667bf3
AM
1010 int size;
1011
1012 /* Massage our args to the form they really have. */
1013 stub_entry = (struct elf32_hppa_stub_hash_entry *) gen_entry;
83c81bfe 1014 htab = (struct elf32_hppa_link_hash_table *) in_arg;
30667bf3
AM
1015
1016 if (stub_entry->stub_type == hppa_stub_long_branch)
98ceb8ce 1017 size = 8;
30667bf3
AM
1018 else if (stub_entry->stub_type == hppa_stub_long_branch_shared)
1019 size = 12;
1020 else if (stub_entry->stub_type == hppa_stub_export)
1021 size = 24;
74d1c347 1022 else /* hppa_stub_import or hppa_stub_import_shared. */
252b5132 1023 {
83c81bfe 1024 if (htab->multi_subspace)
30667bf3
AM
1025 size = 28;
1026 else
1027 size = 16;
1028 }
252b5132 1029
74d1c347 1030 stub_entry->stub_sec->_raw_size += size;
30667bf3
AM
1031 return true;
1032}
252b5132 1033
30667bf3
AM
1034/* Return nonzero if ABFD represents an HPPA ELF32 file.
1035 Additionally we set the default architecture and machine. */
1036
1037static boolean
1038elf32_hppa_object_p (abfd)
1039 bfd *abfd;
1040{
24a5e751
L
1041 Elf_Internal_Ehdr * i_ehdrp;
1042 unsigned int flags;
252b5132 1043
24a5e751
L
1044 i_ehdrp = elf_elfheader (abfd);
1045 if (strcmp (bfd_get_target (abfd), "elf32-hppa-linux") == 0)
1046 {
1047 if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_LINUX)
1048 return false;
1049 }
1050 else
1051 {
1052 if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_HPUX)
1053 return false;
1054 }
1055
1056 flags = i_ehdrp->e_flags;
30667bf3
AM
1057 switch (flags & (EF_PARISC_ARCH | EF_PARISC_WIDE))
1058 {
1059 case EFA_PARISC_1_0:
1060 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 10);
1061 case EFA_PARISC_1_1:
1062 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 11);
1063 case EFA_PARISC_2_0:
1064 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 20);
1065 case EFA_PARISC_2_0 | EF_PARISC_WIDE:
1066 return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25);
1067 }
1068 return true;
252b5132
RH
1069}
1070
252b5132
RH
1071/* Undo the generic ELF code's subtraction of section->vma from the
1072 value of each external symbol. */
1073
1074static boolean
1075elf32_hppa_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
5f771d47
ILT
1076 bfd *abfd ATTRIBUTE_UNUSED;
1077 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1078 const Elf_Internal_Sym *sym ATTRIBUTE_UNUSED;
1079 const char **namep ATTRIBUTE_UNUSED;
1080 flagword *flagsp ATTRIBUTE_UNUSED;
252b5132
RH
1081 asection **secp;
1082 bfd_vma *valp;
1083{
1084 *valp += (*secp)->vma;
1085 return true;
1086}
1087
30667bf3
AM
1088/* Create the .plt and .got sections, and set up our hash table
1089 short-cuts to various dynamic sections. */
1090
1091static boolean
1092elf32_hppa_create_dynamic_sections (abfd, info)
1093 bfd *abfd;
1094 struct bfd_link_info *info;
252b5132 1095{
83c81bfe 1096 struct elf32_hppa_link_hash_table *htab;
edd21aca 1097
30667bf3 1098 /* Don't try to create the .plt and .got twice. */
83c81bfe
AM
1099 htab = hppa_link_hash_table (info);
1100 if (htab->splt != NULL)
30667bf3 1101 return true;
edd21aca 1102
30667bf3
AM
1103 /* Call the generic code to do most of the work. */
1104 if (! _bfd_elf_create_dynamic_sections (abfd, info))
1105 return false;
252b5132 1106
83c81bfe
AM
1107 htab->splt = bfd_get_section_by_name (abfd, ".plt");
1108 htab->srelplt = bfd_get_section_by_name (abfd, ".rela.plt");
30667bf3 1109
83c81bfe
AM
1110 htab->sgot = bfd_get_section_by_name (abfd, ".got");
1111 htab->srelgot = bfd_make_section (abfd, ".rela.got");
1112 if (htab->srelgot == NULL
1113 || ! bfd_set_section_flags (abfd, htab->srelgot,
30667bf3
AM
1114 (SEC_ALLOC
1115 | SEC_LOAD
1116 | SEC_HAS_CONTENTS
1117 | SEC_IN_MEMORY
1118 | SEC_LINKER_CREATED
1119 | SEC_READONLY))
83c81bfe 1120 || ! bfd_set_section_alignment (abfd, htab->srelgot, 2))
30667bf3 1121 return false;
edd21aca 1122
83c81bfe
AM
1123 htab->sdynbss = bfd_get_section_by_name (abfd, ".dynbss");
1124 htab->srelbss = bfd_get_section_by_name (abfd, ".rela.bss");
30667bf3
AM
1125
1126 return true;
1127}
1128
ebe50bae
AM
1129/* Copy the extra info we tack onto an elf_link_hash_entry. */
1130
51b64d56 1131static void
ebe50bae
AM
1132elf32_hppa_copy_indirect_symbol (dir, ind)
1133 struct elf_link_hash_entry *dir, *ind;
1134{
1135 struct elf32_hppa_link_hash_entry *edir, *eind;
1136
1137 edir = (struct elf32_hppa_link_hash_entry *) dir;
1138 eind = (struct elf32_hppa_link_hash_entry *) ind;
1139
bbd7ec4a 1140 if (eind->dyn_relocs != NULL)
ebe50bae 1141 {
bbd7ec4a
AM
1142 if (edir->dyn_relocs != NULL)
1143 {
1144 struct elf32_hppa_dyn_reloc_entry **pp;
1145 struct elf32_hppa_dyn_reloc_entry *p;
1146
1e370bd2 1147 if (ind->root.type == bfd_link_hash_indirect)
bbd7ec4a
AM
1148 abort ();
1149
1150 /* Add reloc counts against the weak sym to the strong sym
1151 list. Merge any entries against the same section. */
1152 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1153 {
1154 struct elf32_hppa_dyn_reloc_entry *q;
1155
1156 for (q = edir->dyn_relocs; q != NULL; q = q->next)
1157 if (q->sec == p->sec)
1158 {
1159#if RELATIVE_DYNRELOCS
1160 q->relative_count += p->relative_count;
1161#endif
1162 q->count += p->count;
1163 *pp = p->next;
1164 break;
1165 }
1166 if (q == NULL)
1167 pp = &p->next;
1168 }
1169 *pp = edir->dyn_relocs;
1170 }
1171
ebe50bae
AM
1172 edir->dyn_relocs = eind->dyn_relocs;
1173 eind->dyn_relocs = NULL;
1174 }
ebe50bae
AM
1175
1176 _bfd_elf_link_hash_copy_indirect (dir, ind);
1177}
1178
30667bf3 1179/* Look through the relocs for a section during the first phase, and
3ac8354b
AM
1180 calculate needed space in the global offset table, procedure linkage
1181 table, and dynamic reloc sections. At this point we haven't
1182 necessarily read all the input files. */
252b5132
RH
1183
1184static boolean
30667bf3
AM
1185elf32_hppa_check_relocs (abfd, info, sec, relocs)
1186 bfd *abfd;
1187 struct bfd_link_info *info;
1188 asection *sec;
1189 const Elf_Internal_Rela *relocs;
252b5132 1190{
30667bf3
AM
1191 Elf_Internal_Shdr *symtab_hdr;
1192 struct elf_link_hash_entry **sym_hashes;
30667bf3
AM
1193 const Elf_Internal_Rela *rel;
1194 const Elf_Internal_Rela *rel_end;
83c81bfe 1195 struct elf32_hppa_link_hash_table *htab;
30667bf3
AM
1196 asection *sreloc;
1197 asection *stubreloc;
1198
1199 if (info->relocateable)
1200 return true;
1201
83c81bfe 1202 htab = hppa_link_hash_table (info);
30667bf3
AM
1203 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1204 sym_hashes = elf_sym_hashes (abfd);
30667bf3
AM
1205 sreloc = NULL;
1206 stubreloc = NULL;
1207
1208 rel_end = relocs + sec->reloc_count;
1209 for (rel = relocs; rel < rel_end; rel++)
1210 {
1211 enum {
1212 NEED_GOT = 1,
1213 NEED_PLT = 2,
1214 NEED_DYNREL = 4,
98ceb8ce 1215 PLT_PLABEL = 8
30667bf3 1216 };
edd21aca 1217
30667bf3
AM
1218 unsigned int r_symndx, r_type;
1219 struct elf32_hppa_link_hash_entry *h;
1220 int need_entry;
252b5132 1221
30667bf3 1222 r_symndx = ELF32_R_SYM (rel->r_info);
252b5132 1223
30667bf3
AM
1224 if (r_symndx < symtab_hdr->sh_info)
1225 h = NULL;
1226 else
1227 h = ((struct elf32_hppa_link_hash_entry *)
1228 sym_hashes[r_symndx - symtab_hdr->sh_info]);
252b5132 1229
30667bf3 1230 r_type = ELF32_R_TYPE (rel->r_info);
252b5132 1231
30667bf3
AM
1232 switch (r_type)
1233 {
1234 case R_PARISC_DLTIND14F:
1235 case R_PARISC_DLTIND14R:
1236 case R_PARISC_DLTIND21L:
1237 /* This symbol requires a global offset table entry. */
1238 need_entry = NEED_GOT;
1239
1240 /* Mark this section as containing PIC code. */
1241 sec->flags |= SEC_HAS_GOT_REF;
1242 break;
1243
1244 case R_PARISC_PLABEL14R: /* "Official" procedure labels. */
1245 case R_PARISC_PLABEL21L:
1246 case R_PARISC_PLABEL32:
74d1c347 1247 /* If the addend is non-zero, we break badly. */
49e9d0d3
AM
1248 if (rel->r_addend != 0)
1249 abort ();
74d1c347
AM
1250
1251 /* If we are creating a shared library, then we need to
1252 create a PLT entry for all PLABELs, because PLABELs with
1253 local symbols may be passed via a pointer to another
1254 object. Additionally, output a dynamic relocation
4dc86686
AM
1255 pointing to the PLT entry.
1256 For executables, the original 32-bit ABI allowed two
1257 different styles of PLABELs (function pointers): For
1258 global functions, the PLABEL word points into the .plt
1259 two bytes past a (function address, gp) pair, and for
1260 local functions the PLABEL points directly at the
1261 function. The magic +2 for the first type allows us to
1262 differentiate between the two. As you can imagine, this
1263 is a real pain when it comes to generating code to call
1264 functions indirectly or to compare function pointers.
1265 We avoid the mess by always pointing a PLABEL into the
1266 .plt, even for local functions. */
74d1c347 1267 need_entry = PLT_PLABEL | NEED_PLT | NEED_DYNREL;
30667bf3
AM
1268 break;
1269
1270 case R_PARISC_PCREL12F:
83c81bfe 1271 htab->has_12bit_branch = 1;
47d89dba 1272 /* Fall thru. */
30667bf3
AM
1273 case R_PARISC_PCREL17C:
1274 case R_PARISC_PCREL17F:
83c81bfe 1275 htab->has_17bit_branch = 1;
47d89dba 1276 /* Fall thru. */
30667bf3 1277 case R_PARISC_PCREL22F:
47d89dba
AM
1278 /* Function calls might need to go through the .plt, and
1279 might require long branch stubs. */
30667bf3
AM
1280 if (h == NULL)
1281 {
1282 /* We know local syms won't need a .plt entry, and if
1283 they need a long branch stub we can't guarantee that
1284 we can reach the stub. So just flag an error later
1285 if we're doing a shared link and find we need a long
1286 branch stub. */
1287 continue;
1288 }
1289 else
1290 {
1291 /* Global symbols will need a .plt entry if they remain
1292 global, and in most cases won't need a long branch
1293 stub. Unfortunately, we have to cater for the case
1294 where a symbol is forced local by versioning, or due
1295 to symbolic linking, and we lose the .plt entry. */
98ceb8ce 1296 need_entry = NEED_PLT;
4dc86686 1297 if (h->elf.type == STT_PARISC_MILLI)
98ceb8ce 1298 need_entry = 0;
30667bf3
AM
1299 }
1300 break;
1301
1302 case R_PARISC_SEGBASE: /* Used to set segment base. */
c46b7515 1303 case R_PARISC_SEGREL32: /* Relative reloc, used for unwind. */
30667bf3
AM
1304 case R_PARISC_PCREL14F: /* PC relative load/store. */
1305 case R_PARISC_PCREL14R:
1306 case R_PARISC_PCREL17R: /* External branches. */
1307 case R_PARISC_PCREL21L: /* As above, and for load/store too. */
1308 /* We don't need to propagate the relocation if linking a
1309 shared object since these are section relative. */
1310 continue;
1311
1312 case R_PARISC_DPREL14F: /* Used for gp rel data load/store. */
1313 case R_PARISC_DPREL14R:
1314 case R_PARISC_DPREL21L:
1315 if (info->shared)
1316 {
1317 (*_bfd_error_handler)
1318 (_("%s: relocation %s can not be used when making a shared object; recompile with -fPIC"),
8f615d07 1319 bfd_archive_filename (abfd),
30667bf3
AM
1320 elf_hppa_howto_table[r_type].name);
1321 bfd_set_error (bfd_error_bad_value);
1322 return false;
1323 }
1324 /* Fall through. */
1325
1326 case R_PARISC_DIR17F: /* Used for external branches. */
1327 case R_PARISC_DIR17R:
47d89dba
AM
1328 case R_PARISC_DIR14F: /* Used for load/store from absolute locn. */
1329 case R_PARISC_DIR14R:
30667bf3
AM
1330 case R_PARISC_DIR21L: /* As above, and for ext branches too. */
1331#if 1
1332 /* Help debug shared library creation. Any of the above
1333 relocs can be used in shared libs, but they may cause
1334 pages to become unshared. */
1335 if (info->shared)
1336 {
1337 (*_bfd_error_handler)
1338 (_("%s: relocation %s should not be used when making a shared object; recompile with -fPIC"),
8f615d07 1339 bfd_archive_filename (abfd),
30667bf3
AM
1340 elf_hppa_howto_table[r_type].name);
1341 }
1342 /* Fall through. */
1343#endif
1344
c46b7515 1345 case R_PARISC_DIR32: /* .word relocs. */
30667bf3
AM
1346 /* We may want to output a dynamic relocation later. */
1347 need_entry = NEED_DYNREL;
1348 break;
1349
1350 /* This relocation describes the C++ object vtable hierarchy.
1351 Reconstruct it for later use during GC. */
1352 case R_PARISC_GNU_VTINHERIT:
1353 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec,
1354 &h->elf, rel->r_offset))
1355 return false;
1356 continue;
1357
1358 /* This relocation describes which C++ vtable entries are actually
1359 used. Record for later use during GC. */
1360 case R_PARISC_GNU_VTENTRY:
1361 if (!_bfd_elf32_gc_record_vtentry (abfd, sec,
36605136 1362 &h->elf, rel->r_addend))
30667bf3
AM
1363 return false;
1364 continue;
1365
1366 default:
1367 continue;
1368 }
1369
1370 /* Now carry out our orders. */
1371 if (need_entry & NEED_GOT)
1372 {
1373 /* Allocate space for a GOT entry, as well as a dynamic
25f72752 1374 relocation for this entry. */
83c81bfe 1375 if (htab->sgot == NULL)
30667bf3 1376 {
3ac8354b
AM
1377 if (htab->elf.dynobj == NULL)
1378 htab->elf.dynobj = abfd;
1379 if (!elf32_hppa_create_dynamic_sections (htab->elf.dynobj, info))
30667bf3
AM
1380 return false;
1381 }
1382
1383 if (h != NULL)
1384 {
51b64d56 1385 h->elf.got.refcount += 1;
30667bf3
AM
1386 }
1387 else
1388 {
3ac8354b
AM
1389 bfd_signed_vma *local_got_refcounts;
1390
30667bf3 1391 /* This is a global offset table entry for a local symbol. */
3ac8354b 1392 local_got_refcounts = elf_local_got_refcounts (abfd);
30667bf3
AM
1393 if (local_got_refcounts == NULL)
1394 {
dc810e39 1395 bfd_size_type size;
30667bf3 1396
74d1c347
AM
1397 /* Allocate space for local got offsets and local
1398 plt offsets. Done this way to save polluting
1399 elf_obj_tdata with another target specific
1400 pointer. */
dc810e39
AM
1401 size = symtab_hdr->sh_info;
1402 size *= 2 * sizeof (bfd_signed_vma);
30667bf3 1403 local_got_refcounts = ((bfd_signed_vma *)
ebe50bae 1404 bfd_zalloc (abfd, size));
30667bf3
AM
1405 if (local_got_refcounts == NULL)
1406 return false;
1407 elf_local_got_refcounts (abfd) = local_got_refcounts;
30667bf3 1408 }
ebe50bae 1409 local_got_refcounts[r_symndx] += 1;
30667bf3
AM
1410 }
1411 }
1412
1413 if (need_entry & NEED_PLT)
1414 {
1415 /* If we are creating a shared library, and this is a reloc
1416 against a weak symbol or a global symbol in a dynamic
1417 object, then we will be creating an import stub and a
1418 .plt entry for the symbol. Similarly, on a normal link
1419 to symbols defined in a dynamic object we'll need the
1420 import stub and a .plt entry. We don't know yet whether
1421 the symbol is defined or not, so make an entry anyway and
1422 clean up later in adjust_dynamic_symbol. */
1423 if ((sec->flags & SEC_ALLOC) != 0)
1424 {
74d1c347 1425 if (h != NULL)
30667bf3 1426 {
51b64d56
AM
1427 h->elf.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
1428 h->elf.plt.refcount += 1;
74d1c347 1429
36605136
AM
1430 /* If this .plt entry is for a plabel, mark it so
1431 that adjust_dynamic_symbol will keep the entry
1432 even if it appears to be local. */
74d1c347
AM
1433 if (need_entry & PLT_PLABEL)
1434 h->plabel = 1;
1435 }
1436 else if (need_entry & PLT_PLABEL)
1437 {
3ac8354b 1438 bfd_signed_vma *local_got_refcounts;
68fb2e56 1439 bfd_signed_vma *local_plt_refcounts;
74d1c347 1440
3ac8354b 1441 local_got_refcounts = elf_local_got_refcounts (abfd);
74d1c347
AM
1442 if (local_got_refcounts == NULL)
1443 {
dc810e39 1444 bfd_size_type size;
74d1c347
AM
1445
1446 /* Allocate space for local got offsets and local
1447 plt offsets. */
dc810e39
AM
1448 size = symtab_hdr->sh_info;
1449 size *= 2 * sizeof (bfd_signed_vma);
74d1c347 1450 local_got_refcounts = ((bfd_signed_vma *)
ebe50bae 1451 bfd_zalloc (abfd, size));
74d1c347
AM
1452 if (local_got_refcounts == NULL)
1453 return false;
1454 elf_local_got_refcounts (abfd) = local_got_refcounts;
74d1c347 1455 }
68fb2e56
AM
1456 local_plt_refcounts = (local_got_refcounts
1457 + symtab_hdr->sh_info);
ebe50bae 1458 local_plt_refcounts[r_symndx] += 1;
30667bf3 1459 }
30667bf3
AM
1460 }
1461 }
1462
98ceb8ce 1463 if (need_entry & NEED_DYNREL)
30667bf3
AM
1464 {
1465 /* Flag this symbol as having a non-got, non-plt reference
1466 so that we generate copy relocs if it turns out to be
1467 dynamic. */
ebe50bae 1468 if (h != NULL && !info->shared)
30667bf3
AM
1469 h->elf.elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
1470
1471 /* If we are creating a shared library then we need to copy
1472 the reloc into the shared library. However, if we are
1473 linking with -Bsymbolic, we need only copy absolute
1474 relocs or relocs against symbols that are not defined in
1475 an object we are including in the link. PC- or DP- or
1476 DLT-relative relocs against any local sym or global sym
1477 with DEF_REGULAR set, can be discarded. At this point we
1478 have not seen all the input files, so it is possible that
1479 DEF_REGULAR is not set now but will be set later (it is
1480 never cleared). We account for that possibility below by
98ceb8ce 1481 storing information in the dyn_relocs field of the
30667bf3
AM
1482 hash table entry.
1483
1484 A similar situation to the -Bsymbolic case occurs when
1485 creating shared libraries and symbol visibility changes
1486 render the symbol local.
1487
1488 As it turns out, all the relocs we will be creating here
1489 are absolute, so we cannot remove them on -Bsymbolic
1490 links or visibility changes anyway. A STUB_REL reloc
1491 is absolute too, as in that case it is the reloc in the
1492 stub we will be creating, rather than copying the PCREL
56882138
AM
1493 reloc in the branch.
1494
1495 If on the other hand, we are creating an executable, we
1496 may need to keep relocations for symbols satisfied by a
1497 dynamic library if we manage to avoid copy relocs for the
1498 symbol. */
446f2863
AM
1499 if ((info->shared
1500 && (sec->flags & SEC_ALLOC) != 0
1501 && (IS_ABSOLUTE_RELOC (r_type)
1502 || (h != NULL
1503 && (!info->symbolic
1504 || h->elf.root.type == bfd_link_hash_defweak
1505 || (h->elf.elf_link_hash_flags
1506 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1507 || (!info->shared
1508 && (sec->flags & SEC_ALLOC) != 0
1509 && h != NULL
446f2863
AM
1510 && (h->elf.root.type == bfd_link_hash_defweak
1511 || (h->elf.elf_link_hash_flags
1512 & ELF_LINK_HASH_DEF_REGULAR) == 0)))
30667bf3 1513 {
30667bf3
AM
1514 /* Create a reloc section in dynobj and make room for
1515 this reloc. */
98ceb8ce 1516 if (sreloc == NULL)
30667bf3
AM
1517 {
1518 char *name;
3ac8354b 1519 bfd *dynobj;
30667bf3 1520
98ceb8ce
AM
1521 name = (bfd_elf_string_from_elf_section
1522 (abfd,
1523 elf_elfheader (abfd)->e_shstrndx,
1524 elf_section_data (sec)->rel_hdr.sh_name));
30667bf3
AM
1525 if (name == NULL)
1526 {
1527 (*_bfd_error_handler)
1528 (_("Could not find relocation section for %s"),
1529 sec->name);
1530 bfd_set_error (bfd_error_bad_value);
1531 return false;
1532 }
1533
3ac8354b
AM
1534 if (htab->elf.dynobj == NULL)
1535 htab->elf.dynobj = abfd;
1536
1537 dynobj = htab->elf.dynobj;
98ceb8ce
AM
1538 sreloc = bfd_get_section_by_name (dynobj, name);
1539 if (sreloc == NULL)
30667bf3
AM
1540 {
1541 flagword flags;
1542
98ceb8ce 1543 sreloc = bfd_make_section (dynobj, name);
30667bf3
AM
1544 flags = (SEC_HAS_CONTENTS | SEC_READONLY
1545 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1546 if ((sec->flags & SEC_ALLOC) != 0)
1547 flags |= SEC_ALLOC | SEC_LOAD;
98ceb8ce
AM
1548 if (sreloc == NULL
1549 || !bfd_set_section_flags (dynobj, sreloc, flags)
1550 || !bfd_set_section_alignment (dynobj, sreloc, 2))
30667bf3
AM
1551 return false;
1552 }
30667bf3 1553
98ceb8ce 1554 elf_section_data (sec)->sreloc = sreloc;
30667bf3
AM
1555 }
1556
98ceb8ce
AM
1557 /* If this is a global symbol, we count the number of
1558 relocations we need for this symbol. */
1559 if (h != NULL)
30667bf3 1560 {
98ceb8ce 1561 struct elf32_hppa_dyn_reloc_entry *p;
30667bf3 1562
98ceb8ce
AM
1563 p = h->dyn_relocs;
1564 if (p == NULL || p->sec != sec)
30667bf3 1565 {
98ceb8ce 1566 p = ((struct elf32_hppa_dyn_reloc_entry *)
3ac8354b
AM
1567 bfd_alloc (htab->elf.dynobj,
1568 (bfd_size_type) sizeof *p));
30667bf3 1569 if (p == NULL)
98ceb8ce
AM
1570 return false;
1571 p->next = h->dyn_relocs;
1572 h->dyn_relocs = p;
1573 p->sec = sec;
1574 p->count = 0;
1575#if RELATIVE_DYNRELOCS
1576 p->relative_count = 0;
1577#endif
30667bf3 1578 }
98ceb8ce
AM
1579
1580 p->count += 1;
1581#if RELATIVE_DYNRELOCS
1582 if (!IS_ABSOLUTE_RELOC (rtype))
1583 p->relative_count += 1;
1584#endif
1585 }
1586 else
1587 {
1588 /* Track dynamic relocs needed for local syms too. */
1589 elf_section_data (sec)->local_dynrel += 1;
30667bf3
AM
1590 }
1591 }
1592 }
1593 }
edd21aca
AM
1594
1595 return true;
1596}
1597
30667bf3
AM
1598/* Return the section that should be marked against garbage collection
1599 for a given relocation. */
1600
1601static asection *
1602elf32_hppa_gc_mark_hook (abfd, info, rel, h, sym)
1603 bfd *abfd;
1604 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1605 Elf_Internal_Rela *rel;
1606 struct elf_link_hash_entry *h;
1607 Elf_Internal_Sym *sym;
1608{
1609 if (h != NULL)
1610 {
1611 switch ((unsigned int) ELF32_R_TYPE (rel->r_info))
1612 {
1613 case R_PARISC_GNU_VTINHERIT:
1614 case R_PARISC_GNU_VTENTRY:
1615 break;
1616
1617 default:
1618 switch (h->root.type)
1619 {
1620 case bfd_link_hash_defined:
1621 case bfd_link_hash_defweak:
1622 return h->root.u.def.section;
1623
1624 case bfd_link_hash_common:
1625 return h->root.u.c.p->section;
1626
1627 default:
1628 break;
1629 }
1630 }
1631 }
1632 else
1633 {
1634 if (!(elf_bad_symtab (abfd)
1635 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
1636 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
1637 && sym->st_shndx != SHN_COMMON))
1638 {
1639 return bfd_section_from_elf_index (abfd, sym->st_shndx);
1640 }
1641 }
1642
1643 return NULL;
1644}
1645
30667bf3
AM
1646/* Update the got and plt entry reference counts for the section being
1647 removed. */
edd21aca
AM
1648
1649static boolean
30667bf3
AM
1650elf32_hppa_gc_sweep_hook (abfd, info, sec, relocs)
1651 bfd *abfd;
1652 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1653 asection *sec;
1654 const Elf_Internal_Rela *relocs;
edd21aca 1655{
30667bf3
AM
1656 Elf_Internal_Shdr *symtab_hdr;
1657 struct elf_link_hash_entry **sym_hashes;
1658 bfd_signed_vma *local_got_refcounts;
74d1c347 1659 bfd_signed_vma *local_plt_refcounts;
30667bf3
AM
1660 const Elf_Internal_Rela *rel, *relend;
1661 unsigned long r_symndx;
1662 struct elf_link_hash_entry *h;
83c81bfe 1663 struct elf32_hppa_link_hash_table *htab;
30667bf3 1664 bfd *dynobj;
30667bf3 1665
98ceb8ce
AM
1666 elf_section_data (sec)->local_dynrel = 0;
1667
30667bf3
AM
1668 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1669 sym_hashes = elf_sym_hashes (abfd);
1670 local_got_refcounts = elf_local_got_refcounts (abfd);
74d1c347
AM
1671 local_plt_refcounts = local_got_refcounts;
1672 if (local_plt_refcounts != NULL)
1673 local_plt_refcounts += symtab_hdr->sh_info;
83c81bfe 1674 htab = hppa_link_hash_table (info);
ebe50bae 1675 dynobj = htab->elf.dynobj;
30667bf3
AM
1676 if (dynobj == NULL)
1677 return true;
1678
30667bf3
AM
1679 relend = relocs + sec->reloc_count;
1680 for (rel = relocs; rel < relend; rel++)
1681 switch ((unsigned int) ELF32_R_TYPE (rel->r_info))
1682 {
1683 case R_PARISC_DLTIND14F:
1684 case R_PARISC_DLTIND14R:
1685 case R_PARISC_DLTIND21L:
1686 r_symndx = ELF32_R_SYM (rel->r_info);
1687 if (r_symndx >= symtab_hdr->sh_info)
1688 {
1689 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1690 if (h->got.refcount > 0)
4dc86686 1691 h->got.refcount -= 1;
30667bf3
AM
1692 }
1693 else if (local_got_refcounts != NULL)
1694 {
1695 if (local_got_refcounts[r_symndx] > 0)
4dc86686 1696 local_got_refcounts[r_symndx] -= 1;
30667bf3
AM
1697 }
1698 break;
edd21aca 1699
30667bf3
AM
1700 case R_PARISC_PCREL12F:
1701 case R_PARISC_PCREL17C:
1702 case R_PARISC_PCREL17F:
1703 case R_PARISC_PCREL22F:
1704 r_symndx = ELF32_R_SYM (rel->r_info);
1705 if (r_symndx >= symtab_hdr->sh_info)
1706 {
1707 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1708 if (h->plt.refcount > 0)
1709 h->plt.refcount -= 1;
1710 }
1711 break;
edd21aca 1712
74d1c347
AM
1713 case R_PARISC_PLABEL14R:
1714 case R_PARISC_PLABEL21L:
1715 case R_PARISC_PLABEL32:
1716 r_symndx = ELF32_R_SYM (rel->r_info);
1717 if (r_symndx >= symtab_hdr->sh_info)
1718 {
98ceb8ce
AM
1719 struct elf32_hppa_link_hash_entry *eh;
1720 struct elf32_hppa_dyn_reloc_entry **pp;
1721 struct elf32_hppa_dyn_reloc_entry *p;
1722
74d1c347 1723 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
98ceb8ce 1724
74d1c347
AM
1725 if (h->plt.refcount > 0)
1726 h->plt.refcount -= 1;
98ceb8ce
AM
1727
1728 eh = (struct elf32_hppa_link_hash_entry *) h;
1729
1730 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1731 if (p->sec == sec)
1732 {
1733#if RELATIVE_DYNRELOCS
1734 if (!IS_ABSOLUTE_RELOC (rtype))
1735 p->relative_count -= 1;
1736#endif
1737 p->count -= 1;
1738 if (p->count == 0)
1739 *pp = p->next;
1740 break;
1741 }
74d1c347
AM
1742 }
1743 else if (local_plt_refcounts != NULL)
1744 {
1745 if (local_plt_refcounts[r_symndx] > 0)
1746 local_plt_refcounts[r_symndx] -= 1;
1747 }
1748 break;
1749
98ceb8ce
AM
1750 case R_PARISC_DIR32:
1751 r_symndx = ELF32_R_SYM (rel->r_info);
1752 if (r_symndx >= symtab_hdr->sh_info)
1753 {
1754 struct elf32_hppa_link_hash_entry *eh;
1755 struct elf32_hppa_dyn_reloc_entry **pp;
1756 struct elf32_hppa_dyn_reloc_entry *p;
1757
1758 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1759
1760 eh = (struct elf32_hppa_link_hash_entry *) h;
1761
1762 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1763 if (p->sec == sec)
1764 {
1765#if RELATIVE_DYNRELOCS
1766 if (!IS_ABSOLUTE_RELOC (R_PARISC_DIR32))
1767 p->relative_count -= 1;
1768#endif
1769 p->count -= 1;
1770 if (p->count == 0)
1771 *pp = p->next;
1772 break;
1773 }
1774 }
1775 break;
1776
30667bf3
AM
1777 default:
1778 break;
1779 }
252b5132 1780
252b5132
RH
1781 return true;
1782}
1783
74d1c347
AM
1784/* Our own version of hide_symbol, so that we can keep plt entries for
1785 plabels. */
1786
1787static void
1788elf32_hppa_hide_symbol (info, h)
1789 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1790 struct elf_link_hash_entry *h;
1791{
5fba655a
L
1792 if ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
1793 h->dynindx = -1;
74d1c347
AM
1794 if (! ((struct elf32_hppa_link_hash_entry *) h)->plabel)
1795 {
1796 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1797 h->plt.offset = (bfd_vma) -1;
1798 }
1799}
1800
4dc86686
AM
1801/* This is the condition under which elf32_hppa_finish_dynamic_symbol
1802 will be called from elflink.h. If elflink.h doesn't call our
1803 finish_dynamic_symbol routine, we'll need to do something about
1804 initializing any .plt and .got entries in elf32_hppa_relocate_section. */
1805#define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1806 ((DYN) \
1807 && ((INFO)->shared \
1808 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1809 && ((H)->dynindx != -1 \
1810 || ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1811
30667bf3
AM
1812/* Adjust a symbol defined by a dynamic object and referenced by a
1813 regular object. The current definition is in some section of the
1814 dynamic object, but we're not including those sections. We have to
1815 change the definition to something the rest of the link can
1816 understand. */
252b5132 1817
30667bf3
AM
1818static boolean
1819elf32_hppa_adjust_dynamic_symbol (info, h)
1820 struct bfd_link_info *info;
1821 struct elf_link_hash_entry *h;
252b5132 1822{
83c81bfe 1823 struct elf32_hppa_link_hash_table *htab;
ebe50bae
AM
1824 struct elf32_hppa_link_hash_entry *eh;
1825 struct elf32_hppa_dyn_reloc_entry *p;
30667bf3 1826 asection *s;
3ac8354b 1827 unsigned int power_of_two;
30667bf3
AM
1828
1829 /* If this is a function, put it in the procedure linkage table. We
1830 will fill in the contents of the procedure linkage table later,
1831 when we know the address of the .got section. */
1832 if (h->type == STT_FUNC
1833 || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
1834 {
12cca0d2
AM
1835 if (!info->shared
1836 && h->plt.refcount > 0
1837 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1838 && (h->root.u.def.section->flags & SEC_HAS_GOT_REF) != 0)
1839 {
1840 ((struct elf32_hppa_link_hash_entry *) h)->maybe_pic_call = 1;
1841 }
1842
30667bf3
AM
1843 if (h->plt.refcount <= 0
1844 || ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1845 && h->root.type != bfd_link_hash_defweak
74d1c347 1846 && ! ((struct elf32_hppa_link_hash_entry *) h)->plabel
30667bf3
AM
1847 && (!info->shared || info->symbolic)))
1848 {
1849 /* The .plt entry is not needed when:
1850 a) Garbage collection has removed all references to the
1851 symbol, or
1852 b) We know for certain the symbol is defined in this
74d1c347
AM
1853 object, and it's not a weak definition, nor is the symbol
1854 used by a plabel relocation. Either this object is the
1855 application or we are doing a shared symbolic link. */
1856
1857 /* As a special sop to the hppa ABI, we keep a .plt entry
1858 for functions in sections containing PIC code. */
12cca0d2
AM
1859 if (((struct elf32_hppa_link_hash_entry *) h)->maybe_pic_call)
1860 ((struct elf32_hppa_link_hash_entry *) h)->pic_call = 1;
30667bf3
AM
1861 else
1862 {
1863 h->plt.offset = (bfd_vma) -1;
1864 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
30667bf3 1865 }
30667bf3 1866 }
4dc86686 1867
30667bf3
AM
1868 return true;
1869 }
bbd7ec4a
AM
1870 else
1871 h->plt.offset = (bfd_vma) -1;
edd21aca 1872
30667bf3
AM
1873 /* If this is a weak symbol, and there is a real definition, the
1874 processor independent code will have arranged for us to see the
1875 real definition first, and we can just use the same value. */
1876 if (h->weakdef != NULL)
edd21aca 1877 {
49e9d0d3
AM
1878 if (h->weakdef->root.type != bfd_link_hash_defined
1879 && h->weakdef->root.type != bfd_link_hash_defweak)
1880 abort ();
30667bf3
AM
1881 h->root.u.def.section = h->weakdef->root.u.def.section;
1882 h->root.u.def.value = h->weakdef->root.u.def.value;
0a991dfe 1883 return true;
30667bf3 1884 }
edd21aca 1885
30667bf3
AM
1886 /* This is a reference to a symbol defined by a dynamic object which
1887 is not a function. */
1888
1889 /* If we are creating a shared library, we must presume that the
1890 only references to the symbol are via the global offset table.
1891 For such cases we need not do anything here; the relocations will
1892 be handled correctly by relocate_section. */
1893 if (info->shared)
1894 return true;
1895
1896 /* If there are no references to this symbol that do not use the
1897 GOT, we don't need to generate a copy reloc. */
1898 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1899 return true;
1900
ebe50bae
AM
1901 eh = (struct elf32_hppa_link_hash_entry *) h;
1902 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1903 {
1904 s = p->sec->output_section;
1905 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1906 break;
1907 }
1908
1909 /* If we didn't find any dynamic relocs in read-only sections, then
1910 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1911 if (p == NULL)
1912 {
1913 h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1914 return true;
1915 }
1916
30667bf3
AM
1917 /* We must allocate the symbol in our .dynbss section, which will
1918 become part of the .bss section of the executable. There will be
1919 an entry for this symbol in the .dynsym section. The dynamic
1920 object will contain position independent code, so all references
1921 from the dynamic object to this symbol will go through the global
1922 offset table. The dynamic linker will use the .dynsym entry to
1923 determine the address it must put in the global offset table, so
1924 both the dynamic object and the regular object will refer to the
1925 same memory location for the variable. */
1926
3ac8354b 1927 htab = hppa_link_hash_table (info);
30667bf3
AM
1928
1929 /* We must generate a COPY reloc to tell the dynamic linker to
1930 copy the initial value out of the dynamic object and into the
3ac8354b 1931 runtime process image. */
30667bf3
AM
1932 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1933 {
3ac8354b 1934 htab->srelbss->_raw_size += sizeof (Elf32_External_Rela);
30667bf3 1935 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
edd21aca 1936 }
252b5132 1937
3ac8354b
AM
1938 /* We need to figure out the alignment required for this symbol. I
1939 have no idea how other ELF linkers handle this. */
30667bf3 1940
3ac8354b
AM
1941 power_of_two = bfd_log2 (h->size);
1942 if (power_of_two > 3)
1943 power_of_two = 3;
1944
1945 /* Apply the required alignment. */
1946 s = htab->sdynbss;
1947 s->_raw_size = BFD_ALIGN (s->_raw_size,
1948 (bfd_size_type) (1 << power_of_two));
1949 if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
1950 {
1951 if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
1952 return false;
1953 }
30667bf3 1954
30667bf3
AM
1955 /* Define the symbol as being at this point in the section. */
1956 h->root.u.def.section = s;
1957 h->root.u.def.value = s->_raw_size;
edd21aca 1958
30667bf3
AM
1959 /* Increment the section size to make room for the symbol. */
1960 s->_raw_size += h->size;
252b5132
RH
1961
1962 return true;
1963}
1964
30667bf3
AM
1965/* Called via elf_link_hash_traverse to create .plt entries for an
1966 application that uses statically linked PIC functions. Similar to
1967 the first part of elf32_hppa_adjust_dynamic_symbol. */
252b5132 1968
30667bf3
AM
1969static boolean
1970hppa_handle_PIC_calls (h, inf)
1971 struct elf_link_hash_entry *h;
4dc86686 1972 PTR inf ATTRIBUTE_UNUSED;
252b5132 1973{
30667bf3
AM
1974 if (! (h->plt.refcount > 0
1975 && (h->root.type == bfd_link_hash_defined
1976 || h->root.type == bfd_link_hash_defweak)
1977 && (h->root.u.def.section->flags & SEC_HAS_GOT_REF) != 0))
252b5132 1978 {
30667bf3
AM
1979 h->plt.offset = (bfd_vma) -1;
1980 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1981 return true;
252b5132
RH
1982 }
1983
74d1c347 1984 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
12cca0d2 1985 ((struct elf32_hppa_link_hash_entry *) h)->maybe_pic_call = 1;
30667bf3 1986 ((struct elf32_hppa_link_hash_entry *) h)->pic_call = 1;
edd21aca 1987
4dc86686
AM
1988 return true;
1989}
1990
1991/* Allocate space in .plt, .got and associated reloc sections for
1992 global syms. */
1993
1994static boolean
98ceb8ce 1995allocate_dynrelocs (h, inf)
4dc86686
AM
1996 struct elf_link_hash_entry *h;
1997 PTR inf;
1998{
1999 struct bfd_link_info *info;
83c81bfe 2000 struct elf32_hppa_link_hash_table *htab;
4dc86686 2001 asection *s;
446f2863 2002 struct elf32_hppa_link_hash_entry *eh;
98ceb8ce 2003 struct elf32_hppa_dyn_reloc_entry *p;
4dc86686 2004
73a74a62
AM
2005 if (h->root.type == bfd_link_hash_indirect
2006 || h->root.type == bfd_link_hash_warning)
2007 return true;
2008
30667bf3 2009 info = (struct bfd_link_info *) inf;
83c81bfe 2010 htab = hppa_link_hash_table (info);
ebe50bae 2011 if ((htab->elf.dynamic_sections_created
4dc86686
AM
2012 && h->plt.refcount > 0)
2013 || ((struct elf32_hppa_link_hash_entry *) h)->pic_call)
2014 {
446f2863
AM
2015 /* Make sure this symbol is output as a dynamic symbol.
2016 Undefined weak syms won't yet be marked as dynamic. */
2017 if (h->dynindx == -1
2018 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0
2019 && h->type != STT_PARISC_MILLI
2020 && !((struct elf32_hppa_link_hash_entry *) h)->pic_call)
2021 {
2022 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2023 return false;
2024 }
2025
3ac8354b
AM
2026 if (((struct elf32_hppa_link_hash_entry *) h)->pic_call
2027 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
4dc86686 2028 {
3ac8354b
AM
2029 /* Make an entry in the .plt section. */
2030 s = htab->splt;
2031 h->plt.offset = s->_raw_size;
2032 if (PLABEL_PLT_ENTRY_SIZE != PLT_ENTRY_SIZE
2033 && ((struct elf32_hppa_link_hash_entry *) h)->plabel
2034 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
2035 {
2036 /* Add some extra space for the dynamic linker to use. */
2037 s->_raw_size += PLABEL_PLT_ENTRY_SIZE;
2038 }
2039 else
2040 s->_raw_size += PLT_ENTRY_SIZE;
2041
2042 if (! ((struct elf32_hppa_link_hash_entry *) h)->pic_call)
2043 {
2044 /* We also need to make an entry in the .rela.plt section. */
2045 htab->srelplt->_raw_size += sizeof (Elf32_External_Rela);
2046 htab->need_plt_stub = 1;
2047 }
4dc86686
AM
2048 }
2049 else
4dc86686 2050 {
3ac8354b
AM
2051 h->plt.offset = (bfd_vma) -1;
2052 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
4dc86686
AM
2053 }
2054 }
2055 else
2056 {
2057 h->plt.offset = (bfd_vma) -1;
2058 h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2059 }
edd21aca 2060
4dc86686
AM
2061 if (h->got.refcount > 0)
2062 {
446f2863
AM
2063 /* Make sure this symbol is output as a dynamic symbol.
2064 Undefined weak syms won't yet be marked as dynamic. */
2065 if (h->dynindx == -1
2066 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0
2067 && h->type != STT_PARISC_MILLI)
2068 {
2069 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2070 return false;
2071 }
2072
83c81bfe 2073 s = htab->sgot;
4dc86686
AM
2074 h->got.offset = s->_raw_size;
2075 s->_raw_size += GOT_ENTRY_SIZE;
ce757d15
AM
2076 if (htab->elf.dynamic_sections_created
2077 && (info->shared
2078 || (h->dynindx != -1
2079 && h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0))
2080 {
2081 htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
2082 }
4dc86686
AM
2083 }
2084 else
2085 h->got.offset = (bfd_vma) -1;
30667bf3 2086
446f2863 2087 eh = (struct elf32_hppa_link_hash_entry *) h;
98ceb8ce 2088 if (eh->dyn_relocs == NULL)
446f2863 2089 return true;
30667bf3 2090
98ceb8ce
AM
2091 /* If this is a -Bsymbolic shared link, then we need to discard all
2092 space allocated for dynamic pc-relative relocs against symbols
2093 defined in a regular object. For the normal shared case, discard
2094 space for relocs that have become local due to symbol visibility
2095 changes. */
2096 if (info->shared)
446f2863 2097 {
98ceb8ce
AM
2098#if RELATIVE_DYNRELOCS
2099 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
2100 && ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
2101 || info->symbolic))
446f2863 2102 {
98ceb8ce 2103 struct elf32_hppa_dyn_reloc_entry **pp;
30667bf3 2104
98ceb8ce
AM
2105 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2106 {
2107 p->count -= p->relative_count;
2108 p->relative_count = 0;
2109 if (p->count == 0)
2110 *pp = p->next;
2111 else
2112 pp = &p->next;
2113 }
2114 }
2115#endif
446f2863 2116 }
98ceb8ce 2117 else
30667bf3 2118 {
98ceb8ce
AM
2119 /* For the non-shared case, discard space for relocs against
2120 symbols which turn out to need copy relocs or are not
2121 dynamic. */
2122 if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
2123 && (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2124 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
ebe50bae 2125 || (htab->elf.dynamic_sections_created
98ceb8ce
AM
2126 && (h->root.type == bfd_link_hash_undefweak
2127 || h->root.type == bfd_link_hash_undefined))))
2128 {
2129 /* Make sure this symbol is output as a dynamic symbol.
2130 Undefined weak syms won't yet be marked as dynamic. */
2131 if (h->dynindx == -1
2132 && (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0
2133 && h->type != STT_PARISC_MILLI)
2134 {
2135 if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2136 return false;
2137 }
2138
2139 /* If that succeeded, we know we'll be keeping all the
2140 relocs. */
2141 if (h->dynindx != -1)
2142 goto keep;
2143 }
446f2863 2144
98ceb8ce
AM
2145 eh->dyn_relocs = NULL;
2146 return true;
2147
2148 keep:
30667bf3 2149 }
30667bf3 2150
98ceb8ce
AM
2151 /* Finally, allocate space. */
2152 for (p = eh->dyn_relocs; p != NULL; p = p->next)
30667bf3 2153 {
98ceb8ce
AM
2154 asection *sreloc = elf_section_data (p->sec)->sreloc;
2155 sreloc->_raw_size += p->count * sizeof (Elf32_External_Rela);
30667bf3 2156 }
30667bf3
AM
2157
2158 return true;
2159}
30667bf3 2160
d5c73c2f
AM
2161/* This function is called via elf_link_hash_traverse to force
2162 millicode symbols local so they do not end up as globals in the
2163 dynamic symbol table. We ought to be able to do this in
2164 adjust_dynamic_symbol, but our adjust_dynamic_symbol is not called
2165 for all dynamic symbols. Arguably, this is a bug in
2166 elf_adjust_dynamic_symbol. */
2167
2168static boolean
2169clobber_millicode_symbols (h, info)
2170 struct elf_link_hash_entry *h;
2171 struct bfd_link_info *info;
2172{
8dea1268
AM
2173 /* We only want to remove these from the dynamic symbol table.
2174 Therefore we do not leave ELF_LINK_FORCED_LOCAL set. */
d5c73c2f 2175 if (h->type == STT_PARISC_MILLI)
e0522e89
AM
2176 {
2177 unsigned short oldflags = h->elf_link_hash_flags;
2178 h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
2179 elf32_hppa_hide_symbol (info, h);
2180 h->elf_link_hash_flags &= ~ELF_LINK_FORCED_LOCAL;
2181 h->elf_link_hash_flags |= oldflags & ELF_LINK_FORCED_LOCAL;
2182 }
d5c73c2f
AM
2183 return true;
2184}
2185
98ceb8ce
AM
2186/* Find any dynamic relocs that apply to read-only sections. */
2187
2188static boolean
2189readonly_dynrelocs (h, inf)
2190 struct elf_link_hash_entry *h;
2191 PTR inf;
2192{
2193 struct elf32_hppa_link_hash_entry *eh;
2194 struct elf32_hppa_dyn_reloc_entry *p;
2195
2196 eh = (struct elf32_hppa_link_hash_entry *) h;
2197 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2198 {
2199 asection *s = p->sec->output_section;
2200
2201 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2202 {
2203 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2204
2205 info->flags |= DF_TEXTREL;
2206
2207 /* Not an error, just cut short the traversal. */
2208 return false;
2209 }
2210 }
2211 return true;
2212}
2213
30667bf3
AM
2214/* Set the sizes of the dynamic sections. */
2215
2216static boolean
2217elf32_hppa_size_dynamic_sections (output_bfd, info)
98ceb8ce 2218 bfd *output_bfd ATTRIBUTE_UNUSED;
30667bf3
AM
2219 struct bfd_link_info *info;
2220{
83c81bfe 2221 struct elf32_hppa_link_hash_table *htab;
30667bf3 2222 bfd *dynobj;
98ceb8ce 2223 bfd *ibfd;
30667bf3
AM
2224 asection *s;
2225 boolean relocs;
30667bf3 2226
83c81bfe 2227 htab = hppa_link_hash_table (info);
ebe50bae 2228 dynobj = htab->elf.dynobj;
49e9d0d3
AM
2229 if (dynobj == NULL)
2230 abort ();
30667bf3 2231
ebe50bae 2232 if (htab->elf.dynamic_sections_created)
30667bf3
AM
2233 {
2234 /* Set the contents of the .interp section to the interpreter. */
2235 if (! info->shared)
2236 {
2237 s = bfd_get_section_by_name (dynobj, ".interp");
49e9d0d3
AM
2238 if (s == NULL)
2239 abort ();
30667bf3
AM
2240 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
2241 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2242 }
74d1c347 2243
d5c73c2f 2244 /* Force millicode symbols local. */
ebe50bae 2245 elf_link_hash_traverse (&htab->elf,
d5c73c2f
AM
2246 clobber_millicode_symbols,
2247 info);
68fb2e56
AM
2248 }
2249 else
2250 {
2251 /* Run through the function symbols, looking for any that are
2252 PIC, and allocate space for the necessary .plt entries so
2253 that %r19 will be set up. */
2254 if (! info->shared)
ebe50bae 2255 elf_link_hash_traverse (&htab->elf,
68fb2e56
AM
2256 hppa_handle_PIC_calls,
2257 info);
2258 }
d5c73c2f 2259
98ceb8ce
AM
2260 /* Set up .got and .plt offsets for local syms, and space for local
2261 dynamic relocs. */
2262 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
68fb2e56
AM
2263 {
2264 bfd_signed_vma *local_got;
2265 bfd_signed_vma *end_local_got;
2266 bfd_signed_vma *local_plt;
2267 bfd_signed_vma *end_local_plt;
2268 bfd_size_type locsymcount;
2269 Elf_Internal_Shdr *symtab_hdr;
2270 asection *srel;
74d1c347 2271
98ceb8ce 2272 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
68fb2e56 2273 continue;
4dc86686 2274
98ceb8ce
AM
2275 for (s = ibfd->sections; s != NULL; s = s->next)
2276 {
2277 bfd_size_type count = elf_section_data (s)->local_dynrel;
2278
2279 if (count != 0)
2280 {
2281 srel = elf_section_data (s)->sreloc;
2282 srel->_raw_size += count * sizeof (Elf32_External_Rela);
2283 }
2284 }
2285
2286 local_got = elf_local_got_refcounts (ibfd);
68fb2e56
AM
2287 if (!local_got)
2288 continue;
74d1c347 2289
98ceb8ce 2290 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
68fb2e56
AM
2291 locsymcount = symtab_hdr->sh_info;
2292 end_local_got = local_got + locsymcount;
83c81bfe
AM
2293 s = htab->sgot;
2294 srel = htab->srelgot;
68fb2e56
AM
2295 for (; local_got < end_local_got; ++local_got)
2296 {
2297 if (*local_got > 0)
4dc86686 2298 {
68fb2e56
AM
2299 *local_got = s->_raw_size;
2300 s->_raw_size += GOT_ENTRY_SIZE;
2301 if (info->shared)
2302 srel->_raw_size += sizeof (Elf32_External_Rela);
4dc86686 2303 }
68fb2e56
AM
2304 else
2305 *local_got = (bfd_vma) -1;
2306 }
74d1c347 2307
68fb2e56
AM
2308 local_plt = end_local_got;
2309 end_local_plt = local_plt + locsymcount;
ebe50bae 2310 if (! htab->elf.dynamic_sections_created)
68fb2e56
AM
2311 {
2312 /* Won't be used, but be safe. */
2313 for (; local_plt < end_local_plt; ++local_plt)
2314 *local_plt = (bfd_vma) -1;
2315 }
2316 else
2317 {
83c81bfe
AM
2318 s = htab->splt;
2319 srel = htab->srelplt;
74d1c347
AM
2320 for (; local_plt < end_local_plt; ++local_plt)
2321 {
2322 if (*local_plt > 0)
2323 {
74d1c347
AM
2324 *local_plt = s->_raw_size;
2325 s->_raw_size += PLT_ENTRY_SIZE;
2326 if (info->shared)
4dc86686 2327 srel->_raw_size += sizeof (Elf32_External_Rela);
74d1c347
AM
2328 }
2329 else
2330 *local_plt = (bfd_vma) -1;
2331 }
2332 }
30667bf3 2333 }
30667bf3 2334
98ceb8ce
AM
2335 /* Allocate global sym .plt and .got entries, and space for global
2336 sym dynamic relocs. */
ebe50bae 2337 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
30667bf3
AM
2338
2339 /* The check_relocs and adjust_dynamic_symbol entry points have
2340 determined the sizes of the various dynamic sections. Allocate
2341 memory for them. */
2342 relocs = false;
30667bf3
AM
2343 for (s = dynobj->sections; s != NULL; s = s->next)
2344 {
30667bf3
AM
2345 if ((s->flags & SEC_LINKER_CREATED) == 0)
2346 continue;
2347
83c81bfe 2348 if (s == htab->splt)
68fb2e56 2349 {
83c81bfe 2350 if (htab->need_plt_stub)
68fb2e56
AM
2351 {
2352 /* Make space for the plt stub at the end of the .plt
2353 section. We want this stub right at the end, up
2354 against the .got section. */
83c81bfe 2355 int gotalign = bfd_section_alignment (dynobj, htab->sgot);
68fb2e56
AM
2356 int pltalign = bfd_section_alignment (dynobj, s);
2357 bfd_size_type mask;
30667bf3 2358
68fb2e56
AM
2359 if (gotalign > pltalign)
2360 bfd_set_section_alignment (dynobj, s, gotalign);
2361 mask = ((bfd_size_type) 1 << gotalign) - 1;
2362 s->_raw_size = (s->_raw_size + sizeof (plt_stub) + mask) & ~mask;
2363 }
2364 }
83c81bfe 2365 else if (s == htab->sgot)
68fb2e56
AM
2366 ;
2367 else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
30667bf3
AM
2368 {
2369 if (s->_raw_size != 0)
2370 {
4578e0a7
AM
2371 /* Remember whether there are any reloc sections. */
2372 relocs = true;
47d89dba 2373
30667bf3
AM
2374 /* We use the reloc_count field as a counter if we need
2375 to copy relocs into the output file. */
2376 s->reloc_count = 0;
2377 }
2378 }
30667bf3
AM
2379 else
2380 {
2381 /* It's not one of our sections, so don't allocate space. */
2382 continue;
2383 }
2384
2385 if (s->_raw_size == 0)
2386 {
2387 /* If we don't need this section, strip it from the
2388 output file. This is mostly to handle .rela.bss and
2389 .rela.plt. We must create both sections in
2390 create_dynamic_sections, because they must be created
2391 before the linker maps input sections to output
2392 sections. The linker does that before
2393 adjust_dynamic_symbol is called, and it is that
2394 function which decides whether anything needs to go
2395 into these sections. */
2396 _bfd_strip_section_from_output (info, s);
2397 continue;
2398 }
2399
2400 /* Allocate memory for the section contents. Zero it, because
2401 we may not fill in all the reloc sections. */
2402 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
2403 if (s->contents == NULL && s->_raw_size != 0)
2404 return false;
2405 }
2406
ebe50bae 2407 if (htab->elf.dynamic_sections_created)
30667bf3
AM
2408 {
2409 /* Like IA-64 and HPPA64, always create a DT_PLTGOT. It
2410 actually has nothing to do with the PLT, it is how we
2411 communicate the LTP value of a load module to the dynamic
2412 linker. */
dc810e39
AM
2413#define add_dynamic_entry(TAG, VAL) \
2414 bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
2415
2416 if (!add_dynamic_entry (DT_PLTGOT, 0))
30667bf3
AM
2417 return false;
2418
2419 /* Add some entries to the .dynamic section. We fill in the
2420 values later, in elf32_hppa_finish_dynamic_sections, but we
2421 must add the entries now so that we get the correct size for
2422 the .dynamic section. The DT_DEBUG entry is filled in by the
2423 dynamic linker and used by the debugger. */
dc810e39 2424 if (!info->shared)
30667bf3 2425 {
dc810e39 2426 if (!add_dynamic_entry (DT_DEBUG, 0))
30667bf3
AM
2427 return false;
2428 }
2429
83c81bfe 2430 if (htab->srelplt->_raw_size != 0)
30667bf3 2431 {
dc810e39
AM
2432 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
2433 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2434 || !add_dynamic_entry (DT_JMPREL, 0))
30667bf3
AM
2435 return false;
2436 }
2437
2438 if (relocs)
2439 {
dc810e39
AM
2440 if (!add_dynamic_entry (DT_RELA, 0)
2441 || !add_dynamic_entry (DT_RELASZ, 0)
2442 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
30667bf3 2443 return false;
30667bf3 2444
98ceb8ce
AM
2445 /* If any dynamic relocs apply to a read-only section,
2446 then we need a DT_TEXTREL entry. */
ebe50bae 2447 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, (PTR) info);
98ceb8ce
AM
2448
2449 if ((info->flags & DF_TEXTREL) != 0)
2450 {
2451 if (!add_dynamic_entry (DT_TEXTREL, 0))
2452 return false;
2453 }
30667bf3
AM
2454 }
2455 }
dc810e39 2456#undef add_dynamic_entry
30667bf3
AM
2457
2458 return true;
2459}
2460
30667bf3
AM
2461/* External entry points for sizing and building linker stubs. */
2462
2463/* Determine and set the size of the stub section for a final link.
2464
2465 The basic idea here is to examine all the relocations looking for
2466 PC-relative calls to a target that is unreachable with a "bl"
2467 instruction. */
2468
2469boolean
47d89dba 2470elf32_hppa_size_stubs (output_bfd, stub_bfd, info, multi_subspace, group_size,
30667bf3 2471 add_stub_section, layout_sections_again)
25f72752 2472 bfd *output_bfd;
30667bf3 2473 bfd *stub_bfd;
30667bf3 2474 struct bfd_link_info *info;
25f72752 2475 boolean multi_subspace;
47d89dba 2476 bfd_signed_vma group_size;
30667bf3
AM
2477 asection * (*add_stub_section) PARAMS ((const char *, asection *));
2478 void (*layout_sections_again) PARAMS ((void));
2479{
2480 bfd *input_bfd;
2481 asection *section;
25f72752 2482 asection **input_list, **list;
30667bf3 2483 Elf_Internal_Sym *local_syms, **all_local_syms;
25f72752
AM
2484 unsigned int bfd_indx, bfd_count;
2485 int top_id, top_index;
83c81bfe 2486 struct elf32_hppa_link_hash_table *htab;
47d89dba
AM
2487 bfd_size_type stub_group_size;
2488 boolean stubs_always_before_branch;
30667bf3 2489 boolean stub_changed = 0;
25f72752 2490 boolean ret = 0;
dc810e39 2491 bfd_size_type amt;
30667bf3 2492
83c81bfe 2493 htab = hppa_link_hash_table (info);
30667bf3
AM
2494
2495 /* Stash our params away. */
83c81bfe
AM
2496 htab->stub_bfd = stub_bfd;
2497 htab->multi_subspace = multi_subspace;
2498 htab->add_stub_section = add_stub_section;
2499 htab->layout_sections_again = layout_sections_again;
47d89dba
AM
2500 stubs_always_before_branch = group_size < 0;
2501 if (group_size < 0)
2502 stub_group_size = -group_size;
2503 else
2504 stub_group_size = group_size;
2505 if (stub_group_size == 1)
2506 {
2507 /* Default values. */
2508 stub_group_size = 8000000;
83c81bfe 2509 if (htab->has_17bit_branch || htab->multi_subspace)
47d89dba 2510 stub_group_size = 250000;
83c81bfe 2511 if (htab->has_12bit_branch)
47d89dba
AM
2512 stub_group_size = 7812;
2513 }
30667bf3 2514
1badb539
AM
2515 /* Count the number of input BFDs and find the top input section id. */
2516 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
30667bf3
AM
2517 input_bfd != NULL;
2518 input_bfd = input_bfd->link_next)
2519 {
2520 bfd_count += 1;
25f72752
AM
2521 for (section = input_bfd->sections;
2522 section != NULL;
2523 section = section->next)
2524 {
2525 if (top_id < section->id)
2526 top_id = section->id;
2527 }
30667bf3
AM
2528 }
2529
dc810e39 2530 amt = sizeof (struct map_stub) * (top_id + 1);
83c81bfe
AM
2531 htab->stub_group = (struct map_stub *) bfd_zmalloc (amt);
2532 if (htab->stub_group == NULL)
30667bf3
AM
2533 return false;
2534
1badb539
AM
2535 /* Make a list of input sections for each output section included in
2536 the link.
2537
2538 We can't use output_bfd->section_count here to find the top output
2539 section index as some sections may have been removed, and
2540 _bfd_strip_section_from_output doesn't renumber the indices. */
2541 for (section = output_bfd->sections, top_index = 0;
2542 section != NULL;
2543 section = section->next)
2544 {
2545 if (top_index < section->index)
2546 top_index = section->index;
2547 }
2548
dc810e39
AM
2549 amt = sizeof (asection *) * (top_index + 1);
2550 input_list = (asection **) bfd_malloc (amt);
25f72752
AM
2551 if (input_list == NULL)
2552 return false;
2553
1badb539
AM
2554 /* For sections we aren't interested in, mark their entries with a
2555 value we can check later. */
2556 list = input_list + top_index;
2557 do
2558 *list = bfd_abs_section_ptr;
2559 while (list-- != input_list);
2560
2561 for (section = output_bfd->sections;
2562 section != NULL;
2563 section = section->next)
2564 {
47d89dba 2565 if ((section->flags & SEC_CODE) != 0)
1badb539
AM
2566 input_list[section->index] = NULL;
2567 }
2568
2569 /* Now actually build the lists. */
25f72752
AM
2570 for (input_bfd = info->input_bfds;
2571 input_bfd != NULL;
2572 input_bfd = input_bfd->link_next)
2573 {
2574 for (section = input_bfd->sections;
2575 section != NULL;
2576 section = section->next)
2577 {
2578 if (section->output_section != NULL
1badb539
AM
2579 && section->output_section->owner == output_bfd
2580 && section->output_section->index <= top_index)
25f72752
AM
2581 {
2582 list = input_list + section->output_section->index;
1badb539
AM
2583 if (*list != bfd_abs_section_ptr)
2584 {
2585 /* Steal the link_sec pointer for our list. */
83c81bfe 2586#define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
1badb539
AM
2587 /* This happens to make the list in reverse order,
2588 which is what we want. */
2589 PREV_SEC (section) = *list;
2590 *list = section;
2591 }
25f72752
AM
2592 }
2593 }
2594 }
2595
2596 /* See whether we can group stub sections together. Grouping stub
2597 sections may result in fewer stubs. More importantly, we need to
2598 put all .init* and .fini* stubs at the beginning of the .init or
2599 .fini output sections respectively, because glibc splits the
2600 _init and _fini functions into multiple parts. Putting a stub in
2601 the middle of a function is not a good idea. */
a017a724 2602 list = input_list + top_index;
1badb539 2603 do
25f72752
AM
2604 {
2605 asection *tail = *list;
1badb539
AM
2606 if (tail == bfd_abs_section_ptr)
2607 continue;
25f72752
AM
2608 while (tail != NULL)
2609 {
2610 asection *curr;
2611 asection *prev;
2612 bfd_size_type total;
2613
2614 curr = tail;
2615 if (tail->_cooked_size)
2616 total = tail->_cooked_size;
2617 else
2618 total = tail->_raw_size;
2619 while ((prev = PREV_SEC (curr)) != NULL
2620 && ((total += curr->output_offset - prev->output_offset)
47d89dba 2621 < stub_group_size))
25f72752
AM
2622 curr = prev;
2623
2624 /* OK, the size from the start of CURR to the end is less
2625 than 250000 bytes and thus can be handled by one stub
2626 section. (or the tail section is itself larger than
2627 250000 bytes, in which case we may be toast.)
2628 We should really be keeping track of the total size of
2629 stubs added here, as stubs contribute to the final output
2630 section size. That's a little tricky, and this way will
2631 only break if stubs added total more than 12144 bytes, or
2632 1518 long branch stubs. It seems unlikely for more than
2633 1518 different functions to be called, especially from
2634 code only 250000 bytes long. */
2635 do
2636 {
2637 prev = PREV_SEC (tail);
2638 /* Set up this stub group. */
83c81bfe 2639 htab->stub_group[tail->id].link_sec = curr;
25f72752
AM
2640 }
2641 while (tail != curr && (tail = prev) != NULL);
2642
2643 /* But wait, there's more! Input sections up to 250000
2644 bytes before the stub section can be handled by it too. */
47d89dba 2645 if (!stubs_always_before_branch)
25f72752 2646 {
47d89dba
AM
2647 total = 0;
2648 while (prev != NULL
2649 && ((total += tail->output_offset - prev->output_offset)
2650 < stub_group_size))
2651 {
2652 tail = prev;
2653 prev = PREV_SEC (tail);
83c81bfe 2654 htab->stub_group[tail->id].link_sec = curr;
47d89dba 2655 }
25f72752
AM
2656 }
2657 tail = prev;
2658 }
2659 }
1badb539 2660 while (list-- != input_list);
25f72752 2661 free (input_list);
1badb539 2662#undef PREV_SEC
30667bf3
AM
2663
2664 /* We want to read in symbol extension records only once. To do this
2665 we need to read in the local symbols in parallel and save them for
2666 later use; so hold pointers to the local symbols in an array. */
dc810e39
AM
2667 amt = sizeof (Elf_Internal_Sym *) * bfd_count;
2668 all_local_syms = (Elf_Internal_Sym **) bfd_zmalloc (amt);
30667bf3 2669 if (all_local_syms == NULL)
25f72752 2670 return false;
30667bf3
AM
2671
2672 /* Walk over all the input BFDs, swapping in local symbols.
2673 If we are creating a shared library, create hash entries for the
2674 export stubs. */
25f72752 2675 for (input_bfd = info->input_bfds, bfd_indx = 0;
30667bf3 2676 input_bfd != NULL;
25f72752 2677 input_bfd = input_bfd->link_next, bfd_indx++)
30667bf3
AM
2678 {
2679 Elf_Internal_Shdr *symtab_hdr;
2680 Elf_Internal_Sym *isym;
25f72752 2681 Elf32_External_Sym *ext_syms, *esym, *end_sy;
dc810e39 2682 bfd_size_type sec_size;
edd21aca 2683
252b5132
RH
2684 /* We'll need the symbol table in a second. */
2685 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2686 if (symtab_hdr->sh_info == 0)
2687 continue;
2688
edd21aca
AM
2689 /* We need an array of the local symbols attached to the input bfd.
2690 Unfortunately, we're going to have to read & swap them in. */
dc810e39
AM
2691 sec_size = symtab_hdr->sh_info;
2692 sec_size *= sizeof (Elf_Internal_Sym);
2693 local_syms = (Elf_Internal_Sym *) bfd_malloc (sec_size);
edd21aca
AM
2694 if (local_syms == NULL)
2695 {
2696 goto error_ret_free_local;
2697 }
25f72752 2698 all_local_syms[bfd_indx] = local_syms;
dc810e39
AM
2699 sec_size = symtab_hdr->sh_info;
2700 sec_size *= sizeof (Elf32_External_Sym);
2701 ext_syms = (Elf32_External_Sym *) bfd_malloc (sec_size);
edd21aca
AM
2702 if (ext_syms == NULL)
2703 {
2704 goto error_ret_free_local;
2705 }
2706
2707 if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
dc810e39 2708 || (bfd_bread (ext_syms, sec_size, input_bfd) != sec_size))
edd21aca
AM
2709 {
2710 free (ext_syms);
2711 goto error_ret_free_local;
2712 }
2713
2714 /* Swap the local symbols in. */
2715 isym = local_syms;
2716 esym = ext_syms;
25f72752 2717 for (end_sy = esym + symtab_hdr->sh_info; esym < end_sy; esym++, isym++)
edd21aca
AM
2718 bfd_elf32_swap_symbol_in (input_bfd, esym, isym);
2719
2720 /* Now we can free the external symbols. */
2721 free (ext_syms);
edd21aca 2722
83c81bfe 2723 if (info->shared && htab->multi_subspace)
30667bf3 2724 {
25f72752
AM
2725 struct elf_link_hash_entry **sym_hashes;
2726 struct elf_link_hash_entry **end_hashes;
30667bf3
AM
2727 unsigned int symcount;
2728
2729 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2730 - symtab_hdr->sh_info);
25f72752
AM
2731 sym_hashes = elf_sym_hashes (input_bfd);
2732 end_hashes = sym_hashes + symcount;
30667bf3
AM
2733
2734 /* Look through the global syms for functions; We need to
2735 build export stubs for all globally visible functions. */
25f72752 2736 for (; sym_hashes < end_hashes; sym_hashes++)
30667bf3
AM
2737 {
2738 struct elf32_hppa_link_hash_entry *hash;
2739
25f72752 2740 hash = (struct elf32_hppa_link_hash_entry *) *sym_hashes;
30667bf3
AM
2741
2742 while (hash->elf.root.type == bfd_link_hash_indirect
2743 || hash->elf.root.type == bfd_link_hash_warning)
2744 hash = ((struct elf32_hppa_link_hash_entry *)
2745 hash->elf.root.u.i.link);
2746
2747 /* At this point in the link, undefined syms have been
2748 resolved, so we need to check that the symbol was
2749 defined in this BFD. */
2750 if ((hash->elf.root.type == bfd_link_hash_defined
2751 || hash->elf.root.type == bfd_link_hash_defweak)
2752 && hash->elf.type == STT_FUNC
2753 && hash->elf.root.u.def.section->output_section != NULL
25f72752
AM
2754 && (hash->elf.root.u.def.section->output_section->owner
2755 == output_bfd)
30667bf3
AM
2756 && hash->elf.root.u.def.section->owner == input_bfd
2757 && (hash->elf.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
2758 && !(hash->elf.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
2759 && ELF_ST_VISIBILITY (hash->elf.other) == STV_DEFAULT)
2760 {
2761 asection *sec;
2762 const char *stub_name;
2763 struct elf32_hppa_stub_hash_entry *stub_entry;
2764
2765 sec = hash->elf.root.u.def.section;
2766 stub_name = hash->elf.root.root.string;
83c81bfe 2767 stub_entry = hppa_stub_hash_lookup (&htab->stub_hash_table,
30667bf3
AM
2768 stub_name,
2769 false, false);
2770 if (stub_entry == NULL)
2771 {
83c81bfe 2772 stub_entry = hppa_add_stub (stub_name, sec, htab);
30667bf3
AM
2773 if (!stub_entry)
2774 goto error_ret_free_local;
2775
2776 stub_entry->target_value = hash->elf.root.u.def.value;
2777 stub_entry->target_section = hash->elf.root.u.def.section;
2778 stub_entry->stub_type = hppa_stub_export;
2779 stub_entry->h = hash;
2780 stub_changed = 1;
2781 }
2782 else
2783 {
2784 (*_bfd_error_handler) (_("%s: duplicate export stub %s"),
8f615d07
AM
2785 bfd_archive_filename (input_bfd),
2786 stub_name);
30667bf3
AM
2787 }
2788 }
2789 }
30667bf3
AM
2790 }
2791 }
edd21aca
AM
2792
2793 while (1)
2794 {
30667bf3
AM
2795 asection *stub_sec;
2796
25f72752 2797 for (input_bfd = info->input_bfds, bfd_indx = 0;
30667bf3 2798 input_bfd != NULL;
25f72752 2799 input_bfd = input_bfd->link_next, bfd_indx++)
30667bf3
AM
2800 {
2801 Elf_Internal_Shdr *symtab_hdr;
2802
2803 /* We'll need the symbol table in a second. */
2804 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2805 if (symtab_hdr->sh_info == 0)
2806 continue;
2807
25f72752 2808 local_syms = all_local_syms[bfd_indx];
30667bf3
AM
2809
2810 /* Walk over each section attached to the input bfd. */
2811 for (section = input_bfd->sections;
2812 section != NULL;
25f72752 2813 section = section->next)
30667bf3
AM
2814 {
2815 Elf_Internal_Shdr *input_rel_hdr;
2816 Elf32_External_Rela *external_relocs, *erelaend, *erela;
2817 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
2818
2819 /* If there aren't any relocs, then there's nothing more
2820 to do. */
2821 if ((section->flags & SEC_RELOC) == 0
2822 || section->reloc_count == 0)
2823 continue;
2824
25f72752
AM
2825 /* If this section is a link-once section that will be
2826 discarded, then don't create any stubs. */
2827 if (section->output_section == NULL
2828 || section->output_section->owner != output_bfd)
2829 continue;
2830
30667bf3 2831 /* Allocate space for the external relocations. */
dc810e39
AM
2832 amt = section->reloc_count;
2833 amt *= sizeof (Elf32_External_Rela);
2834 external_relocs = (Elf32_External_Rela *) bfd_malloc (amt);
30667bf3
AM
2835 if (external_relocs == NULL)
2836 {
2837 goto error_ret_free_local;
2838 }
2839
2840 /* Likewise for the internal relocations. */
dc810e39
AM
2841 amt = section->reloc_count;
2842 amt *= sizeof (Elf_Internal_Rela);
2843 internal_relocs = (Elf_Internal_Rela *) bfd_malloc (amt);
30667bf3
AM
2844 if (internal_relocs == NULL)
2845 {
2846 free (external_relocs);
2847 goto error_ret_free_local;
2848 }
2849
2850 /* Read in the external relocs. */
2851 input_rel_hdr = &elf_section_data (section)->rel_hdr;
2852 if (bfd_seek (input_bfd, input_rel_hdr->sh_offset, SEEK_SET) != 0
dc810e39 2853 || bfd_bread (external_relocs,
30667bf3
AM
2854 input_rel_hdr->sh_size,
2855 input_bfd) != input_rel_hdr->sh_size)
2856 {
2857 free (external_relocs);
2858 error_ret_free_internal:
2859 free (internal_relocs);
2860 goto error_ret_free_local;
2861 }
2862
2863 /* Swap in the relocs. */
2864 erela = external_relocs;
2865 erelaend = erela + section->reloc_count;
2866 irela = internal_relocs;
2867 for (; erela < erelaend; erela++, irela++)
2868 bfd_elf32_swap_reloca_in (input_bfd, erela, irela);
2869
2870 /* We're done with the external relocs, free them. */
2871 free (external_relocs);
2872
2873 /* Now examine each relocation. */
2874 irela = internal_relocs;
2875 irelaend = irela + section->reloc_count;
2876 for (; irela < irelaend; irela++)
2877 {
2878 unsigned int r_type, r_indx;
2879 enum elf32_hppa_stub_type stub_type;
2880 struct elf32_hppa_stub_hash_entry *stub_entry;
2881 asection *sym_sec;
2882 bfd_vma sym_value;
2883 bfd_vma destination;
2884 struct elf32_hppa_link_hash_entry *hash;
2885 char *stub_name;
25f72752 2886 const asection *id_sec;
30667bf3
AM
2887
2888 r_type = ELF32_R_TYPE (irela->r_info);
2889 r_indx = ELF32_R_SYM (irela->r_info);
2890
2891 if (r_type >= (unsigned int) R_PARISC_UNIMPLEMENTED)
2892 {
2893 bfd_set_error (bfd_error_bad_value);
2894 goto error_ret_free_internal;
2895 }
2896
2897 /* Only look for stubs on call instructions. */
2898 if (r_type != (unsigned int) R_PARISC_PCREL12F
2899 && r_type != (unsigned int) R_PARISC_PCREL17F
2900 && r_type != (unsigned int) R_PARISC_PCREL22F)
2901 continue;
2902
2903 /* Now determine the call target, its name, value,
2904 section. */
2905 sym_sec = NULL;
2906 sym_value = 0;
2907 destination = 0;
2908 hash = NULL;
2909 if (r_indx < symtab_hdr->sh_info)
2910 {
2911 /* It's a local symbol. */
2912 Elf_Internal_Sym *sym;
2913 Elf_Internal_Shdr *hdr;
2914
2915 sym = local_syms + r_indx;
2916 hdr = elf_elfsections (input_bfd)[sym->st_shndx];
2917 sym_sec = hdr->bfd_section;
2918 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2919 sym_value = sym->st_value;
2920 destination = (sym_value + irela->r_addend
2921 + sym_sec->output_offset
2922 + sym_sec->output_section->vma);
2923 }
2924 else
2925 {
2926 /* It's an external symbol. */
2927 int e_indx;
2928
2929 e_indx = r_indx - symtab_hdr->sh_info;
2930 hash = ((struct elf32_hppa_link_hash_entry *)
2931 elf_sym_hashes (input_bfd)[e_indx]);
2932
2933 while (hash->elf.root.type == bfd_link_hash_indirect
2934 || hash->elf.root.type == bfd_link_hash_warning)
2935 hash = ((struct elf32_hppa_link_hash_entry *)
2936 hash->elf.root.u.i.link);
2937
2938 if (hash->elf.root.type == bfd_link_hash_defined
2939 || hash->elf.root.type == bfd_link_hash_defweak)
2940 {
2941 sym_sec = hash->elf.root.u.def.section;
2942 sym_value = hash->elf.root.u.def.value;
2943 if (sym_sec->output_section != NULL)
2944 destination = (sym_value + irela->r_addend
2945 + sym_sec->output_offset
2946 + sym_sec->output_section->vma);
2947 }
2948 else if (hash->elf.root.type == bfd_link_hash_undefweak)
2949 {
2950 if (! info->shared)
2951 continue;
2952 }
2953 else if (hash->elf.root.type == bfd_link_hash_undefined)
2954 {
2955 if (! (info->shared
2956 && !info->no_undefined
2957 && (ELF_ST_VISIBILITY (hash->elf.other)
2958 == STV_DEFAULT)))
2959 continue;
2960 }
2961 else
2962 {
2963 bfd_set_error (bfd_error_bad_value);
2964 goto error_ret_free_internal;
2965 }
2966 }
2967
2968 /* Determine what (if any) linker stub is needed. */
2969 stub_type = hppa_type_of_stub (section, irela, hash,
2970 destination);
2971 if (stub_type == hppa_stub_none)
2972 continue;
2973
25f72752 2974 /* Support for grouping stub sections. */
83c81bfe 2975 id_sec = htab->stub_group[section->id].link_sec;
25f72752 2976
30667bf3 2977 /* Get the name of this stub. */
25f72752 2978 stub_name = hppa_stub_name (id_sec, sym_sec, hash, irela);
30667bf3
AM
2979 if (!stub_name)
2980 goto error_ret_free_internal;
2981
83c81bfe 2982 stub_entry = hppa_stub_hash_lookup (&htab->stub_hash_table,
30667bf3
AM
2983 stub_name,
2984 false, false);
2985 if (stub_entry != NULL)
2986 {
2987 /* The proper stub has already been created. */
2988 free (stub_name);
2989 continue;
2990 }
2991
83c81bfe 2992 stub_entry = hppa_add_stub (stub_name, section, htab);
30667bf3
AM
2993 if (stub_entry == NULL)
2994 {
2995 free (stub_name);
2996 goto error_ret_free_local;
2997 }
2998
2999 stub_entry->target_value = sym_value;
3000 stub_entry->target_section = sym_sec;
3001 stub_entry->stub_type = stub_type;
3002 if (info->shared)
3003 {
3004 if (stub_type == hppa_stub_import)
3005 stub_entry->stub_type = hppa_stub_import_shared;
98ceb8ce 3006 else if (stub_type == hppa_stub_long_branch)
30667bf3
AM
3007 stub_entry->stub_type = hppa_stub_long_branch_shared;
3008 }
3009 stub_entry->h = hash;
3010 stub_changed = 1;
3011 }
3012
3013 /* We're done with the internal relocs, free them. */
3014 free (internal_relocs);
3015 }
3016 }
3017
3018 if (!stub_changed)
3019 break;
3020
3021 /* OK, we've added some stubs. Find out the new size of the
3022 stub sections. */
83c81bfe 3023 for (stub_sec = htab->stub_bfd->sections;
30667bf3
AM
3024 stub_sec != NULL;
3025 stub_sec = stub_sec->next)
3026 {
74d1c347
AM
3027 stub_sec->_raw_size = 0;
3028 stub_sec->_cooked_size = 0;
3029 }
74d1c347 3030
83c81bfe 3031 bfd_hash_traverse (&htab->stub_hash_table, hppa_size_one_stub, htab);
74d1c347 3032
30667bf3 3033 /* Ask the linker to do its stuff. */
83c81bfe 3034 (*htab->layout_sections_again) ();
30667bf3
AM
3035 stub_changed = 0;
3036 }
3037
25f72752 3038 ret = 1;
30667bf3
AM
3039
3040 error_ret_free_local:
25f72752
AM
3041 while (bfd_count-- > 0)
3042 if (all_local_syms[bfd_count])
3043 free (all_local_syms[bfd_count]);
30667bf3
AM
3044 free (all_local_syms);
3045
25f72752 3046 return ret;
30667bf3
AM
3047}
3048
30667bf3
AM
3049/* For a final link, this function is called after we have sized the
3050 stubs to provide a value for __gp. */
3051
3052boolean
3053elf32_hppa_set_gp (abfd, info)
3054 bfd *abfd;
3055 struct bfd_link_info *info;
3056{
83c81bfe 3057 struct elf32_hppa_link_hash_table *htab;
30667bf3
AM
3058 struct elf_link_hash_entry *h;
3059 asection *sec;
3060 bfd_vma gp_val;
3061
83c81bfe 3062 htab = hppa_link_hash_table (info);
ebe50bae 3063 h = elf_link_hash_lookup (&htab->elf, "$global$", false, false, false);
30667bf3 3064
df8634e3
AM
3065 if (h != NULL
3066 && (h->root.type == bfd_link_hash_defined
3067 || h->root.type == bfd_link_hash_defweak))
30667bf3
AM
3068 {
3069 gp_val = h->root.u.def.value;
3070 sec = h->root.u.def.section;
3071 }
3072 else
3073 {
74d1c347
AM
3074 /* Choose to point our LTP at, in this order, one of .plt, .got,
3075 or .data, if these sections exist. In the case of choosing
3076 .plt try to make the LTP ideal for addressing anywhere in the
3077 .plt or .got with a 14 bit signed offset. Typically, the end
3078 of the .plt is the start of the .got, so choose .plt + 0x2000
3079 if either the .plt or .got is larger than 0x2000. If both
3080 the .plt and .got are smaller than 0x2000, choose the end of
3081 the .plt section. */
3082
83c81bfe 3083 sec = htab->splt;
74d1c347 3084 if (sec != NULL)
30667bf3 3085 {
74d1c347
AM
3086 gp_val = sec->_raw_size;
3087 if (gp_val > 0x2000
83c81bfe 3088 || (htab->sgot && htab->sgot->_raw_size > 0x2000))
74d1c347
AM
3089 {
3090 gp_val = 0x2000;
3091 }
3092 }
3093 else
3094 {
3095 gp_val = 0;
83c81bfe 3096 sec = htab->sgot;
74d1c347
AM
3097 if (sec != NULL)
3098 {
3099 /* We know we don't have a .plt. If .got is large,
3100 offset our LTP. */
3101 if (sec->_raw_size > 0x2000)
3102 gp_val = 0x2000;
3103 }
3104 else
3105 {
3106 /* No .plt or .got. Who cares what the LTP is? */
3107 sec = bfd_get_section_by_name (abfd, ".data");
3108 }
30667bf3 3109 }
df8634e3
AM
3110
3111 if (h != NULL)
3112 {
3113 h->root.type = bfd_link_hash_defined;
3114 h->root.u.def.value = gp_val;
3115 if (sec != NULL)
3116 h->root.u.def.section = sec;
3117 else
3118 h->root.u.def.section = bfd_abs_section_ptr;
3119 }
30667bf3
AM
3120 }
3121
b32b5d6e 3122 if (sec != NULL && sec->output_section != NULL)
74d1c347
AM
3123 gp_val += sec->output_section->vma + sec->output_offset;
3124
3125 elf_gp (abfd) = gp_val;
30667bf3
AM
3126 return true;
3127}
3128
30667bf3
AM
3129/* Build all the stubs associated with the current output file. The
3130 stubs are kept in a hash table attached to the main linker hash
3131 table. We also set up the .plt entries for statically linked PIC
3132 functions here. This function is called via hppaelf_finish in the
3133 linker. */
3134
3135boolean
3136elf32_hppa_build_stubs (info)
3137 struct bfd_link_info *info;
3138{
3139 asection *stub_sec;
3140 struct bfd_hash_table *table;
83c81bfe 3141 struct elf32_hppa_link_hash_table *htab;
30667bf3 3142
83c81bfe 3143 htab = hppa_link_hash_table (info);
30667bf3 3144
83c81bfe 3145 for (stub_sec = htab->stub_bfd->sections;
30667bf3
AM
3146 stub_sec != NULL;
3147 stub_sec = stub_sec->next)
3148 {
dc810e39 3149 bfd_size_type size;
30667bf3
AM
3150
3151 /* Allocate memory to hold the linker stubs. */
74d1c347 3152 size = stub_sec->_raw_size;
83c81bfe 3153 stub_sec->contents = (unsigned char *) bfd_zalloc (htab->stub_bfd, size);
30667bf3
AM
3154 if (stub_sec->contents == NULL && size != 0)
3155 return false;
74d1c347 3156 stub_sec->_raw_size = 0;
30667bf3
AM
3157 }
3158
3159 /* Build the stubs as directed by the stub hash table. */
83c81bfe 3160 table = &htab->stub_hash_table;
30667bf3
AM
3161 bfd_hash_traverse (table, hppa_build_one_stub, info);
3162
3163 return true;
3164}
3165
c46b7515
AM
3166/* Perform a final link. */
3167
3168static boolean
3169elf32_hppa_final_link (abfd, info)
3170 bfd *abfd;
3171 struct bfd_link_info *info;
3172{
3173 asection *s;
3174
4dc86686
AM
3175 /* Invoke the regular ELF linker to do all the work. */
3176 if (!bfd_elf32_bfd_final_link (abfd, info))
c46b7515
AM
3177 return false;
3178
3179 /* If we're producing a final executable, sort the contents of the
3180 unwind section. Magic section names, but this is much safer than
3181 having elf32_hppa_relocate_section remember where SEGREL32 relocs
3182 occurred. Consider what happens if someone inept creates a
3183 linker script that puts unwind information in .text. */
3184 s = bfd_get_section_by_name (abfd, ".PARISC.unwind");
3185 if (s != NULL)
3186 {
3187 bfd_size_type size;
3188 char *contents;
3189
3190 size = s->_raw_size;
3191 contents = bfd_malloc (size);
3192 if (contents == NULL)
3193 return false;
3194
3195 if (! bfd_get_section_contents (abfd, s, contents, (file_ptr) 0, size))
3196 return false;
3197
dc810e39 3198 qsort (contents, (size_t) (size / 16), 16, hppa_unwind_entry_compare);
c46b7515
AM
3199
3200 if (! bfd_set_section_contents (abfd, s, contents, (file_ptr) 0, size))
3201 return false;
3202 }
3203 return true;
3204}
3205
3206/* Record the lowest address for the data and text segments. */
3207
3208static void
3209hppa_record_segment_addr (abfd, section, data)
3210 bfd *abfd ATTRIBUTE_UNUSED;
3211 asection *section;
3212 PTR data;
3213{
83c81bfe 3214 struct elf32_hppa_link_hash_table *htab;
c46b7515 3215
83c81bfe 3216 htab = (struct elf32_hppa_link_hash_table *) data;
c46b7515
AM
3217
3218 if ((section->flags & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3219 {
3220 bfd_vma value = section->vma - section->filepos;
3221
3222 if ((section->flags & SEC_READONLY) != 0)
3223 {
83c81bfe
AM
3224 if (value < htab->text_segment_base)
3225 htab->text_segment_base = value;
c46b7515
AM
3226 }
3227 else
3228 {
83c81bfe
AM
3229 if (value < htab->data_segment_base)
3230 htab->data_segment_base = value;
c46b7515
AM
3231 }
3232 }
3233}
3234
30667bf3
AM
3235/* Perform a relocation as part of a final link. */
3236
3237static bfd_reloc_status_type
83c81bfe 3238final_link_relocate (input_section, contents, rel, value, htab, sym_sec, h)
30667bf3
AM
3239 asection *input_section;
3240 bfd_byte *contents;
3241 const Elf_Internal_Rela *rel;
3242 bfd_vma value;
83c81bfe 3243 struct elf32_hppa_link_hash_table *htab;
30667bf3
AM
3244 asection *sym_sec;
3245 struct elf32_hppa_link_hash_entry *h;
3246{
3247 int insn;
3248 unsigned int r_type = ELF32_R_TYPE (rel->r_info);
3249 reloc_howto_type *howto = elf_hppa_howto_table + r_type;
3250 int r_format = howto->bitsize;
3251 enum hppa_reloc_field_selector_type_alt r_field;
3252 bfd *input_bfd = input_section->owner;
3253 bfd_vma offset = rel->r_offset;
3254 bfd_vma max_branch_offset = 0;
3255 bfd_byte *hit_data = contents + offset;
3256 bfd_signed_vma addend = rel->r_addend;
3257 bfd_vma location;
3258 struct elf32_hppa_stub_hash_entry *stub_entry = NULL;
3259 int val;
3260
3261 if (r_type == R_PARISC_NONE)
3262 return bfd_reloc_ok;
3263
3264 insn = bfd_get_32 (input_bfd, hit_data);
3265
3266 /* Find out where we are and where we're going. */
3267 location = (offset +
3268 input_section->output_offset +
3269 input_section->output_section->vma);
3270
3271 switch (r_type)
3272 {
3273 case R_PARISC_PCREL12F:
3274 case R_PARISC_PCREL17F:
3275 case R_PARISC_PCREL22F:
3276 /* If this is a call to a function defined in another dynamic
3277 library, or if it is a call to a PIC function in the same
74d1c347
AM
3278 object, or if this is a shared link and it is a call to a
3279 weak symbol which may or may not be in the same object, then
3280 find the import stub in the stub hash. */
30667bf3
AM
3281 if (sym_sec == NULL
3282 || sym_sec->output_section == NULL
12cca0d2
AM
3283 || (h != NULL
3284 && ((h->maybe_pic_call
3285 && !(input_section->flags & SEC_HAS_GOT_REF))
3286 || (h->elf.root.type == bfd_link_hash_defweak
3287 && h->elf.dynindx != -1
3288 && h->elf.plt.offset != (bfd_vma) -1))))
30667bf3
AM
3289 {
3290 stub_entry = hppa_get_stub_entry (input_section, sym_sec,
83c81bfe 3291 h, rel, htab);
30667bf3
AM
3292 if (stub_entry != NULL)
3293 {
3294 value = (stub_entry->stub_offset
3295 + stub_entry->stub_sec->output_offset
3296 + stub_entry->stub_sec->output_section->vma);
3297 addend = 0;
3298 }
3299 else if (sym_sec == NULL && h != NULL
3300 && h->elf.root.type == bfd_link_hash_undefweak)
3301 {
db20fd76
AM
3302 /* It's OK if undefined weak. Calls to undefined weak
3303 symbols behave as if the "called" function
3304 immediately returns. We can thus call to a weak
3305 function without first checking whether the function
3306 is defined. */
30667bf3 3307 value = location;
db20fd76 3308 addend = 8;
30667bf3
AM
3309 }
3310 else
3311 return bfd_reloc_notsupported;
3312 }
3313 /* Fall thru. */
3314
3315 case R_PARISC_PCREL21L:
3316 case R_PARISC_PCREL17C:
3317 case R_PARISC_PCREL17R:
3318 case R_PARISC_PCREL14R:
3319 case R_PARISC_PCREL14F:
3320 /* Make it a pc relative offset. */
3321 value -= location;
3322 addend -= 8;
3323 break;
3324
3325 case R_PARISC_DPREL21L:
3326 case R_PARISC_DPREL14R:
3327 case R_PARISC_DPREL14F:
3328 /* For all the DP relative relocations, we need to examine the symbol's
3329 section. If it's a code section, then "data pointer relative" makes
3330 no sense. In that case we don't adjust the "value", and for 21 bit
3331 addil instructions, we change the source addend register from %dp to
3332 %r0. This situation commonly arises when a variable's "constness"
3333 is declared differently from the way the variable is defined. For
3334 instance: "extern int foo" with foo defined as "const int foo". */
3335 if (sym_sec == NULL)
3336 break;
3337 if ((sym_sec->flags & SEC_CODE) != 0)
3338 {
3339 if ((insn & ((0x3f << 26) | (0x1f << 21)))
3340 == (((int) OP_ADDIL << 26) | (27 << 21)))
3341 {
3342 insn &= ~ (0x1f << 21);
74d1c347 3343#if 1 /* debug them. */
30667bf3
AM
3344 (*_bfd_error_handler)
3345 (_("%s(%s+0x%lx): fixing %s"),
8f615d07 3346 bfd_archive_filename (input_bfd),
30667bf3
AM
3347 input_section->name,
3348 (long) rel->r_offset,
3349 howto->name);
3350#endif
3351 }
3352 /* Now try to make things easy for the dynamic linker. */
3353
3354 break;
3355 }
74d1c347 3356 /* Fall thru. */
30667bf3
AM
3357
3358 case R_PARISC_DLTIND21L:
3359 case R_PARISC_DLTIND14R:
3360 case R_PARISC_DLTIND14F:
3361 value -= elf_gp (input_section->output_section->owner);
3362 break;
3363
c46b7515
AM
3364 case R_PARISC_SEGREL32:
3365 if ((sym_sec->flags & SEC_CODE) != 0)
83c81bfe 3366 value -= htab->text_segment_base;
c46b7515 3367 else
83c81bfe 3368 value -= htab->data_segment_base;
c46b7515
AM
3369 break;
3370
30667bf3
AM
3371 default:
3372 break;
3373 }
3374
3375 switch (r_type)
3376 {
3377 case R_PARISC_DIR32:
47d89dba 3378 case R_PARISC_DIR14F:
30667bf3
AM
3379 case R_PARISC_DIR17F:
3380 case R_PARISC_PCREL17C:
3381 case R_PARISC_PCREL14F:
3382 case R_PARISC_DPREL14F:
3383 case R_PARISC_PLABEL32:
3384 case R_PARISC_DLTIND14F:
3385 case R_PARISC_SEGBASE:
3386 case R_PARISC_SEGREL32:
3387 r_field = e_fsel;
3388 break;
3389
3390 case R_PARISC_DIR21L:
3391 case R_PARISC_PCREL21L:
3392 case R_PARISC_DPREL21L:
3393 case R_PARISC_PLABEL21L:
3394 case R_PARISC_DLTIND21L:
3395 r_field = e_lrsel;
3396 break;
3397
3398 case R_PARISC_DIR17R:
3399 case R_PARISC_PCREL17R:
3400 case R_PARISC_DIR14R:
3401 case R_PARISC_PCREL14R:
3402 case R_PARISC_DPREL14R:
3403 case R_PARISC_PLABEL14R:
3404 case R_PARISC_DLTIND14R:
3405 r_field = e_rrsel;
3406 break;
3407
3408 case R_PARISC_PCREL12F:
3409 case R_PARISC_PCREL17F:
3410 case R_PARISC_PCREL22F:
3411 r_field = e_fsel;
3412
3413 if (r_type == (unsigned int) R_PARISC_PCREL17F)
3414 {
3415 max_branch_offset = (1 << (17-1)) << 2;
3416 }
3417 else if (r_type == (unsigned int) R_PARISC_PCREL12F)
3418 {
3419 max_branch_offset = (1 << (12-1)) << 2;
3420 }
3421 else
3422 {
3423 max_branch_offset = (1 << (22-1)) << 2;
3424 }
3425
3426 /* sym_sec is NULL on undefined weak syms or when shared on
3427 undefined syms. We've already checked for a stub for the
3428 shared undefined case. */
3429 if (sym_sec == NULL)
3430 break;
3431
3432 /* If the branch is out of reach, then redirect the
3433 call to the local stub for this function. */
3434 if (value + addend + max_branch_offset >= 2*max_branch_offset)
3435 {
3436 stub_entry = hppa_get_stub_entry (input_section, sym_sec,
83c81bfe 3437 h, rel, htab);
30667bf3
AM
3438 if (stub_entry == NULL)
3439 return bfd_reloc_notsupported;
3440
3441 /* Munge up the value and addend so that we call the stub
3442 rather than the procedure directly. */
3443 value = (stub_entry->stub_offset
3444 + stub_entry->stub_sec->output_offset
3445 + stub_entry->stub_sec->output_section->vma
3446 - location);
3447 addend = -8;
3448 }
3449 break;
3450
3451 /* Something we don't know how to handle. */
3452 default:
3453 return bfd_reloc_notsupported;
3454 }
3455
3456 /* Make sure we can reach the stub. */
3457 if (max_branch_offset != 0
3458 && value + addend + max_branch_offset >= 2*max_branch_offset)
3459 {
3460 (*_bfd_error_handler)
3461 (_("%s(%s+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
8f615d07 3462 bfd_archive_filename (input_bfd),
30667bf3
AM
3463 input_section->name,
3464 (long) rel->r_offset,
3465 stub_entry->root.string);
ce757d15 3466 bfd_set_error (bfd_error_bad_value);
30667bf3
AM
3467 return bfd_reloc_notsupported;
3468 }
3469
3470 val = hppa_field_adjust (value, addend, r_field);
3471
3472 switch (r_type)
3473 {
3474 case R_PARISC_PCREL12F:
3475 case R_PARISC_PCREL17C:
3476 case R_PARISC_PCREL17F:
3477 case R_PARISC_PCREL17R:
3478 case R_PARISC_PCREL22F:
3479 case R_PARISC_DIR17F:
3480 case R_PARISC_DIR17R:
3481 /* This is a branch. Divide the offset by four.
3482 Note that we need to decide whether it's a branch or
3483 otherwise by inspecting the reloc. Inspecting insn won't
3484 work as insn might be from a .word directive. */
3485 val >>= 2;
3486 break;
3487
3488 default:
3489 break;
3490 }
3491
3492 insn = hppa_rebuild_insn (insn, val, r_format);
3493
3494 /* Update the instruction word. */
74d1c347 3495 bfd_put_32 (input_bfd, (bfd_vma) insn, hit_data);
30667bf3
AM
3496 return bfd_reloc_ok;
3497}
3498
30667bf3
AM
3499/* Relocate an HPPA ELF section. */
3500
3501static boolean
3502elf32_hppa_relocate_section (output_bfd, info, input_bfd, input_section,
3503 contents, relocs, local_syms, local_sections)
3504 bfd *output_bfd;
3505 struct bfd_link_info *info;
3506 bfd *input_bfd;
3507 asection *input_section;
3508 bfd_byte *contents;
3509 Elf_Internal_Rela *relocs;
3510 Elf_Internal_Sym *local_syms;
3511 asection **local_sections;
3512{
30667bf3 3513 bfd_vma *local_got_offsets;
83c81bfe 3514 struct elf32_hppa_link_hash_table *htab;
30667bf3
AM
3515 Elf_Internal_Shdr *symtab_hdr;
3516 Elf_Internal_Rela *rel;
3517 Elf_Internal_Rela *relend;
30667bf3
AM
3518
3519 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3520
83c81bfe 3521 htab = hppa_link_hash_table (info);
74d1c347 3522 local_got_offsets = elf_local_got_offsets (input_bfd);
30667bf3
AM
3523
3524 rel = relocs;
3525 relend = relocs + input_section->reloc_count;
3526 for (; rel < relend; rel++)
3527 {
3528 unsigned int r_type;
3529 reloc_howto_type *howto;
3530 unsigned int r_symndx;
3531 struct elf32_hppa_link_hash_entry *h;
3532 Elf_Internal_Sym *sym;
3533 asection *sym_sec;
3534 bfd_vma relocation;
3535 bfd_reloc_status_type r;
3536 const char *sym_name;
74d1c347 3537 boolean plabel;
30667bf3
AM
3538
3539 r_type = ELF32_R_TYPE (rel->r_info);
3540 if (r_type >= (unsigned int) R_PARISC_UNIMPLEMENTED)
3541 {
3542 bfd_set_error (bfd_error_bad_value);
3543 return false;
3544 }
3545 if (r_type == (unsigned int) R_PARISC_GNU_VTENTRY
3546 || r_type == (unsigned int) R_PARISC_GNU_VTINHERIT)
3547 continue;
3548
3549 r_symndx = ELF32_R_SYM (rel->r_info);
3550
3551 if (info->relocateable)
3552 {
3ac8354b 3553 /* This is a relocatable link. We don't have to change
30667bf3
AM
3554 anything, unless the reloc is against a section symbol,
3555 in which case we have to adjust according to where the
3556 section symbol winds up in the output section. */
3557 if (r_symndx < symtab_hdr->sh_info)
3558 {
3559 sym = local_syms + r_symndx;
3560 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3561 {
3562 sym_sec = local_sections[r_symndx];
3563 rel->r_addend += sym_sec->output_offset;
3564 }
3565 }
3566 continue;
3567 }
3568
3569 /* This is a final link. */
3570 h = NULL;
3571 sym = NULL;
3572 sym_sec = NULL;
3573 if (r_symndx < symtab_hdr->sh_info)
3574 {
3575 /* This is a local symbol, h defaults to NULL. */
3576 sym = local_syms + r_symndx;
3577 sym_sec = local_sections[r_symndx];
3578 relocation = ((ELF_ST_TYPE (sym->st_info) == STT_SECTION
3579 ? 0 : sym->st_value)
3580 + sym_sec->output_offset
3581 + sym_sec->output_section->vma);
3582 }
3583 else
3584 {
3585 int indx;
3586
3587 /* It's a global; Find its entry in the link hash. */
3588 indx = r_symndx - symtab_hdr->sh_info;
3589 h = ((struct elf32_hppa_link_hash_entry *)
3590 elf_sym_hashes (input_bfd)[indx]);
3591 while (h->elf.root.type == bfd_link_hash_indirect
3592 || h->elf.root.type == bfd_link_hash_warning)
3593 h = (struct elf32_hppa_link_hash_entry *) h->elf.root.u.i.link;
3594
3595 relocation = 0;
3596 if (h->elf.root.type == bfd_link_hash_defined
3597 || h->elf.root.type == bfd_link_hash_defweak)
3598 {
3599 sym_sec = h->elf.root.u.def.section;
3600 /* If sym_sec->output_section is NULL, then it's a
3601 symbol defined in a shared library. */
3602 if (sym_sec->output_section != NULL)
3603 relocation = (h->elf.root.u.def.value
3604 + sym_sec->output_offset
3605 + sym_sec->output_section->vma);
3606 }
3607 else if (h->elf.root.type == bfd_link_hash_undefweak)
3608 ;
3609 else if (info->shared && !info->no_undefined
49e9d0d3
AM
3610 && ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
3611 && h->elf.type != STT_PARISC_MILLI)
30667bf3 3612 {
671bae9c 3613 if (info->symbolic && !info->allow_shlib_undefined)
30667bf3
AM
3614 if (!((*info->callbacks->undefined_symbol)
3615 (info, h->elf.root.root.string, input_bfd,
3616 input_section, rel->r_offset, false)))
3617 return false;
3618 }
3619 else
3620 {
3621 if (!((*info->callbacks->undefined_symbol)
3622 (info, h->elf.root.root.string, input_bfd,
3623 input_section, rel->r_offset, true)))
3624 return false;
3625 }
3626 }
3627
3628 /* Do any required modifications to the relocation value, and
25f72752
AM
3629 determine what types of dynamic info we need to output, if
3630 any. */
74d1c347 3631 plabel = 0;
30667bf3
AM
3632 switch (r_type)
3633 {
3634 case R_PARISC_DLTIND14F:
3635 case R_PARISC_DLTIND14R:
3636 case R_PARISC_DLTIND21L:
ce757d15
AM
3637 {
3638 bfd_vma off;
3639 boolean do_got = 0;
3640
3641 /* Relocation is to the entry for this symbol in the
3642 global offset table. */
3643 if (h != NULL)
3644 {
3645 boolean dyn;
3646
3647 off = h->elf.got.offset;
3648 dyn = htab->elf.dynamic_sections_created;
3649 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, &h->elf))
3650 {
3651 /* If we aren't going to call finish_dynamic_symbol,
3652 then we need to handle initialisation of the .got
3653 entry and create needed relocs here. Since the
3654 offset must always be a multiple of 4, we use the
3655 least significant bit to record whether we have
3656 initialised it already. */
3657 if ((off & 1) != 0)
3658 off &= ~1;
3659 else
3660 {
3661 h->elf.got.offset |= 1;
3662 do_got = 1;
3663 }
3664 }
3665 }
3666 else
3667 {
3668 /* Local symbol case. */
3669 if (local_got_offsets == NULL)
3670 abort ();
3671
3672 off = local_got_offsets[r_symndx];
3673
3674 /* The offset must always be a multiple of 4. We use
3675 the least significant bit to record whether we have
3676 already generated the necessary reloc. */
3677 if ((off & 1) != 0)
3678 off &= ~1;
3679 else
3680 {
3681 local_got_offsets[r_symndx] |= 1;
3682 do_got = 1;
3683 }
3684 }
68fb2e56 3685
ce757d15
AM
3686 if (do_got)
3687 {
3688 if (info->shared)
3689 {
3690 /* Output a dynamic relocation for this GOT entry.
3691 In this case it is relative to the base of the
3692 object because the symbol index is zero. */
3693 Elf_Internal_Rela outrel;
3694 asection *srelgot = htab->srelgot;
3695 Elf32_External_Rela *loc;
3696
3697 outrel.r_offset = (off
3698 + htab->sgot->output_offset
3699 + htab->sgot->output_section->vma);
3700 outrel.r_info = ELF32_R_INFO (0, R_PARISC_DIR32);
3701 outrel.r_addend = relocation;
3702 loc = (Elf32_External_Rela *) srelgot->contents;
3703 loc += srelgot->reloc_count++;
3704 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3705 }
3706 else
30667bf3 3707 bfd_put_32 (output_bfd, relocation,
83c81bfe 3708 htab->sgot->contents + off);
ce757d15 3709 }
30667bf3 3710
ce757d15
AM
3711 if (off >= (bfd_vma) -2)
3712 abort ();
30667bf3 3713
ce757d15
AM
3714 /* Add the base of the GOT to the relocation value. */
3715 relocation = (off
3716 + htab->sgot->output_offset
3717 + htab->sgot->output_section->vma);
3718 }
30667bf3 3719 break;
252b5132 3720
c46b7515
AM
3721 case R_PARISC_SEGREL32:
3722 /* If this is the first SEGREL relocation, then initialize
3723 the segment base values. */
83c81bfe
AM
3724 if (htab->text_segment_base == (bfd_vma) -1)
3725 bfd_map_over_sections (output_bfd, hppa_record_segment_addr, htab);
c46b7515
AM
3726 break;
3727
30667bf3
AM
3728 case R_PARISC_PLABEL14R:
3729 case R_PARISC_PLABEL21L:
3730 case R_PARISC_PLABEL32:
ebe50bae 3731 if (htab->elf.dynamic_sections_created)
252b5132 3732 {
ce757d15
AM
3733 bfd_vma off;
3734 boolean do_plt = 0;
3735
74d1c347
AM
3736 /* If we have a global symbol with a PLT slot, then
3737 redirect this relocation to it. */
3738 if (h != NULL)
3739 {
3740 off = h->elf.plt.offset;
4dc86686 3741 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, &h->elf))
8dea1268
AM
3742 {
3743 /* In a non-shared link, adjust_dynamic_symbols
3744 isn't called for symbols forced local. We
dc810e39 3745 need to write out the plt entry here. */
8dea1268
AM
3746 if ((off & 1) != 0)
3747 off &= ~1;
3748 else
3749 {
8dea1268 3750 h->elf.plt.offset |= 1;
ce757d15 3751 do_plt = 1;
8dea1268
AM
3752 }
3753 }
74d1c347
AM
3754 }
3755 else
3756 {
68fb2e56
AM
3757 bfd_vma *local_plt_offsets;
3758
3759 if (local_got_offsets == NULL)
3760 abort ();
74d1c347 3761
68fb2e56
AM
3762 local_plt_offsets = local_got_offsets + symtab_hdr->sh_info;
3763 off = local_plt_offsets[r_symndx];
74d1c347
AM
3764
3765 /* As for the local .got entry case, we use the last
3766 bit to record whether we've already initialised
3767 this local .plt entry. */
3768 if ((off & 1) != 0)
3769 off &= ~1;
ce757d15
AM
3770 else
3771 {
3772 local_plt_offsets[r_symndx] |= 1;
3773 do_plt = 1;
3774 }
3775 }
3776
3777 if (do_plt)
3778 {
3779 if (info->shared)
3780 {
3781 /* Output a dynamic IPLT relocation for this
3782 PLT entry. */
3783 Elf_Internal_Rela outrel;
3784 asection *srelplt = htab->srelplt;
3785 Elf32_External_Rela *loc;
3786
3787 outrel.r_offset = (off
3788 + htab->splt->output_offset
3789 + htab->splt->output_section->vma);
3790 outrel.r_info = ELF32_R_INFO (0, R_PARISC_IPLT);
3791 outrel.r_addend = relocation;
3792 loc = (Elf32_External_Rela *) srelplt->contents;
3793 loc += srelplt->reloc_count++;
3794 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3795 }
74d1c347
AM
3796 else
3797 {
3798 bfd_put_32 (output_bfd,
3799 relocation,
83c81bfe 3800 htab->splt->contents + off);
74d1c347 3801 bfd_put_32 (output_bfd,
83c81bfe
AM
3802 elf_gp (htab->splt->output_section->owner),
3803 htab->splt->contents + off + 4);
74d1c347
AM
3804 }
3805 }
3806
68fb2e56 3807 if (off >= (bfd_vma) -2)
49e9d0d3 3808 abort ();
74d1c347
AM
3809
3810 /* PLABELs contain function pointers. Relocation is to
3811 the entry for the function in the .plt. The magic +2
3812 offset signals to $$dyncall that the function pointer
3813 is in the .plt and thus has a gp pointer too.
3814 Exception: Undefined PLABELs should have a value of
3815 zero. */
3816 if (h == NULL
3817 || (h->elf.root.type != bfd_link_hash_undefweak
3818 && h->elf.root.type != bfd_link_hash_undefined))
3819 {
3820 relocation = (off
83c81bfe
AM
3821 + htab->splt->output_offset
3822 + htab->splt->output_section->vma
74d1c347
AM
3823 + 2);
3824 }
3825 plabel = 1;
30667bf3
AM
3826 }
3827 /* Fall through and possibly emit a dynamic relocation. */
3828
3829 case R_PARISC_DIR17F:
3830 case R_PARISC_DIR17R:
47d89dba 3831 case R_PARISC_DIR14F:
30667bf3
AM
3832 case R_PARISC_DIR14R:
3833 case R_PARISC_DIR21L:
3834 case R_PARISC_DPREL14F:
3835 case R_PARISC_DPREL14R:
3836 case R_PARISC_DPREL21L:
3837 case R_PARISC_DIR32:
3838 /* The reloc types handled here and this conditional
56882138
AM
3839 expression must match the code in ..check_relocs and
3840 ..discard_relocs. ie. We need exactly the same condition
3841 as in ..check_relocs, with some extra conditions (dynindx
3842 test in this case) to cater for relocs removed by
3843 ..discard_relocs. If you squint, the non-shared test
3844 here does indeed match the one in ..check_relocs, the
3845 difference being that here we test DEF_DYNAMIC as well as
3846 !DEF_REGULAR. All common syms end up with !DEF_REGULAR,
3847 which is why we can't use just that test here.
3848 Conversely, DEF_DYNAMIC can't be used in check_relocs as
3849 there all files have not been loaded. */
446f2863
AM
3850 if ((info->shared
3851 && (input_section->flags & SEC_ALLOC) != 0
3852 && (IS_ABSOLUTE_RELOC (r_type)
3853 || (h != NULL
3854 && h->elf.dynindx != -1
3855 && (!info->symbolic
3856 || (h->elf.elf_link_hash_flags
3857 & ELF_LINK_HASH_DEF_REGULAR) == 0))))
3858 || (!info->shared
3859 && (input_section->flags & SEC_ALLOC) != 0
3860 && h != NULL
3861 && h->elf.dynindx != -1
3862 && (h->elf.elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
56882138
AM
3863 && (((h->elf.elf_link_hash_flags
3864 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
3865 && (h->elf.elf_link_hash_flags
3866 & ELF_LINK_HASH_DEF_REGULAR) == 0)
446f2863
AM
3867 || h->elf.root.type == bfd_link_hash_undefweak
3868 || h->elf.root.type == bfd_link_hash_undefined)))
30667bf3
AM
3869 {
3870 Elf_Internal_Rela outrel;
3871 boolean skip;
98ceb8ce
AM
3872 asection *sreloc;
3873 Elf32_External_Rela *loc;
252b5132 3874
30667bf3
AM
3875 /* When generating a shared object, these relocations
3876 are copied into the output file to be resolved at run
3877 time. */
252b5132 3878
30667bf3
AM
3879 outrel.r_offset = rel->r_offset;
3880 outrel.r_addend = rel->r_addend;
3881 skip = false;
3882 if (elf_section_data (input_section)->stab_info != NULL)
edd21aca 3883 {
ce757d15
AM
3884 bfd_vma off;
3885
30667bf3 3886 off = (_bfd_stab_section_offset
ebe50bae 3887 (output_bfd, &htab->elf.stab_info,
30667bf3
AM
3888 input_section,
3889 &elf_section_data (input_section)->stab_info,
3890 rel->r_offset));
3891 if (off == (bfd_vma) -1)
3892 skip = true;
3893 outrel.r_offset = off;
edd21aca 3894 }
252b5132 3895
30667bf3
AM
3896 outrel.r_offset += (input_section->output_offset
3897 + input_section->output_section->vma);
3898
3899 if (skip)
252b5132 3900 {
30667bf3 3901 memset (&outrel, 0, sizeof (outrel));
252b5132 3902 }
74d1c347
AM
3903 else if (h != NULL
3904 && h->elf.dynindx != -1
3905 && (plabel
446f2863
AM
3906 || !IS_ABSOLUTE_RELOC (r_type)
3907 || !info->shared
74d1c347 3908 || !info->symbolic
30667bf3
AM
3909 || (h->elf.elf_link_hash_flags
3910 & ELF_LINK_HASH_DEF_REGULAR) == 0))
252b5132 3911 {
30667bf3
AM
3912 outrel.r_info = ELF32_R_INFO (h->elf.dynindx, r_type);
3913 }
3914 else /* It's a local symbol, or one marked to become local. */
3915 {
3916 int indx = 0;
edd21aca 3917
30667bf3
AM
3918 /* Add the absolute offset of the symbol. */
3919 outrel.r_addend += relocation;
edd21aca 3920
74d1c347
AM
3921 /* Global plabels need to be processed by the
3922 dynamic linker so that functions have at most one
3923 fptr. For this reason, we need to differentiate
3924 between global and local plabels, which we do by
3925 providing the function symbol for a global plabel
3926 reloc, and no symbol for local plabels. */
3927 if (! plabel
3928 && sym_sec != NULL
30667bf3
AM
3929 && sym_sec->output_section != NULL
3930 && ! bfd_is_abs_section (sym_sec))
252b5132 3931 {
30667bf3
AM
3932 indx = elf_section_data (sym_sec->output_section)->dynindx;
3933 /* We are turning this relocation into one
3934 against a section symbol, so subtract out the
3935 output section's address but not the offset
3936 of the input section in the output section. */
3937 outrel.r_addend -= sym_sec->output_section->vma;
252b5132 3938 }
252b5132 3939
30667bf3
AM
3940 outrel.r_info = ELF32_R_INFO (indx, r_type);
3941 }
68fb2e56
AM
3942#if 0
3943 /* EH info can cause unaligned DIR32 relocs.
3944 Tweak the reloc type for the dynamic linker. */
3945 if (r_type == R_PARISC_DIR32 && (outrel.r_offset & 3) != 0)
3946 outrel.r_info = ELF32_R_INFO (ELF32_R_SYM (outrel.r_info),
3947 R_PARISC_DIR32U);
3948#endif
98ceb8ce
AM
3949 sreloc = elf_section_data (input_section)->sreloc;
3950 if (sreloc == NULL)
3951 abort ();
3952
3ac8354b
AM
3953 loc = (Elf32_External_Rela *) sreloc->contents;
3954 loc += sreloc->reloc_count++;
98ceb8ce 3955 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
30667bf3
AM
3956 }
3957 break;
edd21aca 3958
30667bf3
AM
3959 default:
3960 break;
3961 }
252b5132 3962
30667bf3 3963 r = final_link_relocate (input_section, contents, rel, relocation,
83c81bfe 3964 htab, sym_sec, h);
252b5132 3965
30667bf3
AM
3966 if (r == bfd_reloc_ok)
3967 continue;
252b5132 3968
30667bf3
AM
3969 if (h != NULL)
3970 sym_name = h->elf.root.root.string;
3971 else
3972 {
3973 sym_name = bfd_elf_string_from_elf_section (input_bfd,
3974 symtab_hdr->sh_link,
3975 sym->st_name);
3976 if (sym_name == NULL)
3977 return false;
3978 if (*sym_name == '\0')
3979 sym_name = bfd_section_name (input_bfd, sym_sec);
3980 }
edd21aca 3981
30667bf3 3982 howto = elf_hppa_howto_table + r_type;
252b5132 3983
30667bf3
AM
3984 if (r == bfd_reloc_undefined || r == bfd_reloc_notsupported)
3985 {
3986 (*_bfd_error_handler)
3987 (_("%s(%s+0x%lx): cannot handle %s for %s"),
8f615d07 3988 bfd_archive_filename (input_bfd),
30667bf3
AM
3989 input_section->name,
3990 (long) rel->r_offset,
3991 howto->name,
3992 sym_name);
8f615d07
AM
3993 bfd_set_error (bfd_error_bad_value);
3994 return false;
30667bf3
AM
3995 }
3996 else
3997 {
3998 if (!((*info->callbacks->reloc_overflow)
3999 (info, sym_name, howto->name, (bfd_vma) 0,
4000 input_bfd, input_section, rel->r_offset)))
4001 return false;
4002 }
4003 }
edd21aca 4004
30667bf3
AM
4005 return true;
4006}
252b5132 4007
c46b7515
AM
4008/* Comparison function for qsort to sort unwind section during a
4009 final link. */
4010
4011static int
4012hppa_unwind_entry_compare (a, b)
4013 const PTR a;
4014 const PTR b;
4015{
4016 const bfd_byte *ap, *bp;
4017 unsigned long av, bv;
4018
4019 ap = (const bfd_byte *) a;
4020 av = (unsigned long) ap[0] << 24;
4021 av |= (unsigned long) ap[1] << 16;
4022 av |= (unsigned long) ap[2] << 8;
4023 av |= (unsigned long) ap[3];
4024
4025 bp = (const bfd_byte *) b;
4026 bv = (unsigned long) bp[0] << 24;
4027 bv |= (unsigned long) bp[1] << 16;
4028 bv |= (unsigned long) bp[2] << 8;
4029 bv |= (unsigned long) bp[3];
4030
4031 return av < bv ? -1 : av > bv ? 1 : 0;
4032}
4033
30667bf3
AM
4034/* Finish up dynamic symbol handling. We set the contents of various
4035 dynamic sections here. */
252b5132 4036
30667bf3
AM
4037static boolean
4038elf32_hppa_finish_dynamic_symbol (output_bfd, info, h, sym)
4039 bfd *output_bfd;
4040 struct bfd_link_info *info;
4041 struct elf_link_hash_entry *h;
4042 Elf_Internal_Sym *sym;
4043{
83c81bfe 4044 struct elf32_hppa_link_hash_table *htab;
edd21aca 4045
83c81bfe 4046 htab = hppa_link_hash_table (info);
30667bf3 4047
30667bf3
AM
4048 if (h->plt.offset != (bfd_vma) -1)
4049 {
4050 bfd_vma value;
30667bf3 4051
8dea1268
AM
4052 if (h->plt.offset & 1)
4053 abort ();
4054
30667bf3
AM
4055 /* This symbol has an entry in the procedure linkage table. Set
4056 it up.
4057
4058 The format of a plt entry is
74d1c347
AM
4059 <funcaddr>
4060 <__gp>
47d89dba 4061 */
30667bf3
AM
4062 value = 0;
4063 if (h->root.type == bfd_link_hash_defined
4064 || h->root.type == bfd_link_hash_defweak)
4065 {
4066 value = h->root.u.def.value;
4067 if (h->root.u.def.section->output_section != NULL)
4068 value += (h->root.u.def.section->output_offset
4069 + h->root.u.def.section->output_section->vma);
252b5132 4070 }
edd21aca 4071
74d1c347 4072 if (! ((struct elf32_hppa_link_hash_entry *) h)->pic_call)
30667bf3 4073 {
47d89dba 4074 Elf_Internal_Rela rel;
3ac8354b 4075 Elf32_External_Rela *loc;
47d89dba 4076
30667bf3
AM
4077 /* Create a dynamic IPLT relocation for this entry. */
4078 rel.r_offset = (h->plt.offset
83c81bfe
AM
4079 + htab->splt->output_offset
4080 + htab->splt->output_section->vma);
ce757d15 4081 if (h->dynindx != -1)
74d1c347 4082 {
47d89dba
AM
4083 /* To support lazy linking, the function pointer is
4084 initialised to point to a special stub stored at the
8dea1268
AM
4085 end of the .plt. This is not done for plt entries
4086 with a base-relative dynamic relocation. */
83c81bfe
AM
4087 value = (htab->splt->output_offset
4088 + htab->splt->output_section->vma
4089 + htab->splt->_raw_size
47d89dba
AM
4090 - sizeof (plt_stub)
4091 + PLT_STUB_ENTRY);
74d1c347
AM
4092 rel.r_info = ELF32_R_INFO (h->dynindx, R_PARISC_IPLT);
4093 rel.r_addend = 0;
4094 }
4095 else
4096 {
4097 /* This symbol has been marked to become local, and is
4098 used by a plabel so must be kept in the .plt. */
4099 rel.r_info = ELF32_R_INFO (0, R_PARISC_IPLT);
4100 rel.r_addend = value;
4101 }
30667bf3 4102
3ac8354b
AM
4103 loc = (Elf32_External_Rela *) htab->srelplt->contents;
4104 loc += htab->srelplt->reloc_count++;
83c81bfe 4105 bfd_elf32_swap_reloca_out (htab->splt->output_section->owner,
3ac8354b 4106 &rel, loc);
30667bf3 4107 }
ce757d15 4108 else
47d89dba 4109 {
ce757d15
AM
4110 bfd_put_32 (htab->splt->owner,
4111 value,
4112 htab->splt->contents + h->plt.offset);
4113 bfd_put_32 (htab->splt->owner,
4114 elf_gp (htab->splt->output_section->owner),
4115 htab->splt->contents + h->plt.offset + 4);
47d89dba
AM
4116 }
4117
30667bf3
AM
4118 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4119 {
4120 /* Mark the symbol as undefined, rather than as defined in
4121 the .plt section. Leave the value alone. */
4122 sym->st_shndx = SHN_UNDEF;
4123 }
4124 }
edd21aca 4125
30667bf3
AM
4126 if (h->got.offset != (bfd_vma) -1)
4127 {
4128 Elf_Internal_Rela rel;
3ac8354b 4129 Elf32_External_Rela *loc;
30667bf3
AM
4130
4131 /* This symbol has an entry in the global offset table. Set it
4132 up. */
4133
4134 rel.r_offset = ((h->got.offset &~ (bfd_vma) 1)
83c81bfe
AM
4135 + htab->sgot->output_offset
4136 + htab->sgot->output_section->vma);
30667bf3 4137
4dc86686
AM
4138 /* If this is a -Bsymbolic link and the symbol is defined
4139 locally or was forced to be local because of a version file,
4140 we just want to emit a RELATIVE reloc. The entry in the
4141 global offset table will already have been initialized in the
4142 relocate_section function. */
4143 if (info->shared
4144 && (info->symbolic || h->dynindx == -1)
4145 && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
30667bf3 4146 {
74d1c347 4147 rel.r_info = ELF32_R_INFO (0, R_PARISC_DIR32);
30667bf3
AM
4148 rel.r_addend = (h->root.u.def.value
4149 + h->root.u.def.section->output_offset
4150 + h->root.u.def.section->output_section->vma);
4151 }
4152 else
4153 {
49e9d0d3
AM
4154 if ((h->got.offset & 1) != 0)
4155 abort ();
30667bf3 4156 bfd_put_32 (output_bfd, (bfd_vma) 0,
83c81bfe 4157 htab->sgot->contents + h->got.offset);
30667bf3
AM
4158 rel.r_info = ELF32_R_INFO (h->dynindx, R_PARISC_DIR32);
4159 rel.r_addend = 0;
4160 }
edd21aca 4161
3ac8354b
AM
4162 loc = (Elf32_External_Rela *) htab->srelgot->contents;
4163 loc += htab->srelgot->reloc_count++;
4164 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
30667bf3 4165 }
edd21aca 4166
30667bf3
AM
4167 if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
4168 {
4169 asection *s;
4170 Elf_Internal_Rela rel;
3ac8354b 4171 Elf32_External_Rela *loc;
30667bf3
AM
4172
4173 /* This symbol needs a copy reloc. Set it up. */
4174
49e9d0d3
AM
4175 if (! (h->dynindx != -1
4176 && (h->root.type == bfd_link_hash_defined
4177 || h->root.type == bfd_link_hash_defweak)))
4178 abort ();
30667bf3 4179
83c81bfe 4180 s = htab->srelbss;
30667bf3
AM
4181
4182 rel.r_offset = (h->root.u.def.value
4183 + h->root.u.def.section->output_offset
4184 + h->root.u.def.section->output_section->vma);
4185 rel.r_addend = 0;
4186 rel.r_info = ELF32_R_INFO (h->dynindx, R_PARISC_COPY);
3ac8354b
AM
4187 loc = (Elf32_External_Rela *) s->contents + s->reloc_count++;
4188 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
30667bf3
AM
4189 }
4190
4191 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
4192 if (h->root.root.string[0] == '_'
4193 && (strcmp (h->root.root.string, "_DYNAMIC") == 0
4194 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0))
4195 {
4196 sym->st_shndx = SHN_ABS;
4197 }
4198
4199 return true;
4200}
4201
98ceb8ce
AM
4202/* Used to decide how to sort relocs in an optimal manner for the
4203 dynamic linker, before writing them out. */
4204
4205static enum elf_reloc_type_class
4206elf32_hppa_reloc_type_class (rela)
4207 const Elf_Internal_Rela *rela;
4208{
4209 if (ELF32_R_SYM (rela->r_info) == 0)
4210 return reloc_class_relative;
4211
4212 switch ((int) ELF32_R_TYPE (rela->r_info))
4213 {
4214 case R_PARISC_IPLT:
4215 return reloc_class_plt;
4216 case R_PARISC_COPY:
4217 return reloc_class_copy;
4218 default:
4219 return reloc_class_normal;
4220 }
4221}
4222
30667bf3
AM
4223/* Finish up the dynamic sections. */
4224
4225static boolean
4226elf32_hppa_finish_dynamic_sections (output_bfd, info)
4227 bfd *output_bfd;
4228 struct bfd_link_info *info;
4229{
4230 bfd *dynobj;
83c81bfe 4231 struct elf32_hppa_link_hash_table *htab;
30667bf3
AM
4232 asection *sdyn;
4233
83c81bfe 4234 htab = hppa_link_hash_table (info);
ebe50bae 4235 dynobj = htab->elf.dynobj;
30667bf3
AM
4236
4237 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4238
ebe50bae 4239 if (htab->elf.dynamic_sections_created)
30667bf3
AM
4240 {
4241 Elf32_External_Dyn *dyncon, *dynconend;
4242
49e9d0d3
AM
4243 if (sdyn == NULL)
4244 abort ();
30667bf3
AM
4245
4246 dyncon = (Elf32_External_Dyn *) sdyn->contents;
4247 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
4248 for (; dyncon < dynconend; dyncon++)
edd21aca 4249 {
30667bf3
AM
4250 Elf_Internal_Dyn dyn;
4251 asection *s;
4252
4253 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4254
4255 switch (dyn.d_tag)
4256 {
4257 default:
3ac8354b 4258 continue;
30667bf3
AM
4259
4260 case DT_PLTGOT:
4261 /* Use PLTGOT to set the GOT register. */
4262 dyn.d_un.d_ptr = elf_gp (output_bfd);
30667bf3
AM
4263 break;
4264
4265 case DT_JMPREL:
83c81bfe 4266 s = htab->srelplt;
30667bf3 4267 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
30667bf3
AM
4268 break;
4269
4270 case DT_PLTRELSZ:
83c81bfe 4271 s = htab->srelplt;
30667bf3
AM
4272 if (s->_cooked_size != 0)
4273 dyn.d_un.d_val = s->_cooked_size;
4274 else
4275 dyn.d_un.d_val = s->_raw_size;
30667bf3
AM
4276 break;
4277 }
3ac8354b
AM
4278
4279 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
edd21aca 4280 }
252b5132 4281 }
edd21aca 4282
83c81bfe 4283 if (htab->sgot != NULL && htab->sgot->_raw_size != 0)
30667bf3 4284 {
74d1c347
AM
4285 /* Fill in the first entry in the global offset table.
4286 We use it to point to our dynamic section, if we have one. */
30667bf3
AM
4287 bfd_put_32 (output_bfd,
4288 (sdyn != NULL
4289 ? sdyn->output_section->vma + sdyn->output_offset
4290 : (bfd_vma) 0),
83c81bfe 4291 htab->sgot->contents);
30667bf3 4292
74d1c347 4293 /* The second entry is reserved for use by the dynamic linker. */
83c81bfe 4294 memset (htab->sgot->contents + GOT_ENTRY_SIZE, 0, GOT_ENTRY_SIZE);
74d1c347 4295
30667bf3 4296 /* Set .got entry size. */
83c81bfe 4297 elf_section_data (htab->sgot->output_section)
74d1c347 4298 ->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
30667bf3
AM
4299 }
4300
83c81bfe 4301 if (htab->splt != NULL && htab->splt->_raw_size != 0)
47d89dba
AM
4302 {
4303 /* Set plt entry size. */
83c81bfe 4304 elf_section_data (htab->splt->output_section)
47d89dba
AM
4305 ->this_hdr.sh_entsize = PLT_ENTRY_SIZE;
4306
83c81bfe 4307 if (htab->need_plt_stub)
47d89dba
AM
4308 {
4309 /* Set up the .plt stub. */
83c81bfe
AM
4310 memcpy (htab->splt->contents
4311 + htab->splt->_raw_size - sizeof (plt_stub),
47d89dba
AM
4312 plt_stub, sizeof (plt_stub));
4313
83c81bfe
AM
4314 if ((htab->splt->output_offset
4315 + htab->splt->output_section->vma
4316 + htab->splt->_raw_size)
4317 != (htab->sgot->output_offset
4318 + htab->sgot->output_section->vma))
47d89dba
AM
4319 {
4320 (*_bfd_error_handler)
4321 (_(".got section not immediately after .plt section"));
4322 return false;
4323 }
4324 }
4325 }
30667bf3 4326
252b5132 4327 return true;
30667bf3 4328}
252b5132 4329
d952f17a
AM
4330/* Tweak the OSABI field of the elf header. */
4331
4332static void
4333elf32_hppa_post_process_headers (abfd, link_info)
4334 bfd *abfd;
4335 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
4336{
4337 Elf_Internal_Ehdr * i_ehdrp;
4338
4339 i_ehdrp = elf_elfheader (abfd);
4340
4341 if (strcmp (bfd_get_target (abfd), "elf32-hppa-linux") == 0)
4342 {
4343 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_LINUX;
4344 }
4345 else
4346 {
4347 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_HPUX;
4348 }
4349}
4350
30667bf3
AM
4351/* Called when writing out an object file to decide the type of a
4352 symbol. */
4353static int
4354elf32_hppa_elf_get_symbol_type (elf_sym, type)
4355 Elf_Internal_Sym *elf_sym;
4356 int type;
4357{
4358 if (ELF_ST_TYPE (elf_sym->st_info) == STT_PARISC_MILLI)
4359 return STT_PARISC_MILLI;
4360 else
4361 return type;
252b5132
RH
4362}
4363
4364/* Misc BFD support code. */
30667bf3
AM
4365#define bfd_elf32_bfd_is_local_label_name elf_hppa_is_local_label_name
4366#define bfd_elf32_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
4367#define elf_info_to_howto elf_hppa_info_to_howto
4368#define elf_info_to_howto_rel elf_hppa_info_to_howto_rel
252b5132 4369
252b5132 4370/* Stuff for the BFD linker. */
c46b7515 4371#define bfd_elf32_bfd_final_link elf32_hppa_final_link
30667bf3
AM
4372#define bfd_elf32_bfd_link_hash_table_create elf32_hppa_link_hash_table_create
4373#define elf_backend_add_symbol_hook elf32_hppa_add_symbol_hook
4374#define elf_backend_adjust_dynamic_symbol elf32_hppa_adjust_dynamic_symbol
ebe50bae 4375#define elf_backend_copy_indirect_symbol elf32_hppa_copy_indirect_symbol
30667bf3
AM
4376#define elf_backend_check_relocs elf32_hppa_check_relocs
4377#define elf_backend_create_dynamic_sections elf32_hppa_create_dynamic_sections
4378#define elf_backend_fake_sections elf_hppa_fake_sections
4379#define elf_backend_relocate_section elf32_hppa_relocate_section
74d1c347 4380#define elf_backend_hide_symbol elf32_hppa_hide_symbol
30667bf3
AM
4381#define elf_backend_finish_dynamic_symbol elf32_hppa_finish_dynamic_symbol
4382#define elf_backend_finish_dynamic_sections elf32_hppa_finish_dynamic_sections
4383#define elf_backend_size_dynamic_sections elf32_hppa_size_dynamic_sections
4384#define elf_backend_gc_mark_hook elf32_hppa_gc_mark_hook
4385#define elf_backend_gc_sweep_hook elf32_hppa_gc_sweep_hook
4386#define elf_backend_object_p elf32_hppa_object_p
4387#define elf_backend_final_write_processing elf_hppa_final_write_processing
d952f17a 4388#define elf_backend_post_process_headers elf32_hppa_post_process_headers
30667bf3 4389#define elf_backend_get_symbol_type elf32_hppa_elf_get_symbol_type
98ceb8ce 4390#define elf_backend_reloc_type_class elf32_hppa_reloc_type_class
30667bf3
AM
4391
4392#define elf_backend_can_gc_sections 1
51b64d56 4393#define elf_backend_can_refcount 1
30667bf3
AM
4394#define elf_backend_plt_alignment 2
4395#define elf_backend_want_got_plt 0
4396#define elf_backend_plt_readonly 0
4397#define elf_backend_want_plt_sym 0
74d1c347 4398#define elf_backend_got_header_size 8
252b5132
RH
4399
4400#define TARGET_BIG_SYM bfd_elf32_hppa_vec
4401#define TARGET_BIG_NAME "elf32-hppa"
4402#define ELF_ARCH bfd_arch_hppa
4403#define ELF_MACHINE_CODE EM_PARISC
4404#define ELF_MAXPAGESIZE 0x1000
4405
4406#include "elf32-target.h"
d952f17a
AM
4407
4408#undef TARGET_BIG_SYM
4409#define TARGET_BIG_SYM bfd_elf32_hppa_linux_vec
4410#undef TARGET_BIG_NAME
4411#define TARGET_BIG_NAME "elf32-hppa-linux"
4412
4413#define INCLUDED_TARGET_FILE 1
4414#include "elf32-target.h"