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