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