1
/* BFD back-end for HP PA-RISC ELF files.
2
Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000, 2001,
3
2002 Free Software Foundation, Inc.
6
Center for Software Science
7
Department of Computer Science
9
Largely rewritten by Alan Modra <alan@linuxcare.com.au>
11
This file is part of BFD, the Binary File Descriptor library.
13
This program is free software; you can redistribute it and/or modify
14
it under the terms of the GNU General Public License as published by
15
the Free Software Foundation; either version 2 of the License, or
16
(at your option) any later version.
18
This program is distributed in the hope that it will be useful,
19
but WITHOUT ANY WARRANTY; without even the implied warranty of
20
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21
GNU General Public License for more details.
23
You should have received a copy of the GNU General Public License
24
along with this program; if not, write to the Free Software
25
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
33
#include "elf32-hppa.h"
35
#include "elf32-hppa.h"
38
/* In order to gain some understanding of code in this file without
39
knowing all the intricate details of the linker, note the
42
Functions named elf32_hppa_* are called by external routines, other
43
functions are only called locally. elf32_hppa_* functions appear
44
in this file more or less in the order in which they are called
45
from external routines. eg. elf32_hppa_check_relocs is called
46
early in the link process, elf32_hppa_finish_dynamic_sections is
47
one of the last functions. */
49
/* We use two hash tables to hold information for linking PA ELF objects.
51
The first is the elf32_hppa_link_hash_table which is derived
52
from the standard ELF linker hash table. We use this as a place to
53
attach other hash tables and static information.
55
The second is the stub hash table which is derived from the
56
base BFD hash table. The stub hash table holds the information
57
necessary to build the linker stubs during a link.
59
There are a number of different stubs generated by the linker.
67
: addil LR'X - ($PIC_pcrel$0 - 4),%r1
68
: be,n RR'X - ($PIC_pcrel$0 - 8)(%sr4,%r1)
70
Import stub to call shared library routine from normal object file
71
(single sub-space version)
72
: addil LR'lt_ptr+ltoff,%dp ; get procedure entry point
73
: ldw RR'lt_ptr+ltoff(%r1),%r21
75
: ldw RR'lt_ptr+ltoff+4(%r1),%r19 ; get new dlt value.
77
Import stub to call shared library routine from shared library
78
(single sub-space version)
79
: addil LR'ltoff,%r19 ; get procedure entry point
80
: ldw RR'ltoff(%r1),%r21
82
: ldw RR'ltoff+4(%r1),%r19 ; get new dlt value.
84
Import stub to call shared library routine from normal object file
85
(multiple sub-space support)
86
: addil LR'lt_ptr+ltoff,%dp ; get procedure entry point
87
: ldw RR'lt_ptr+ltoff(%r1),%r21
88
: ldw RR'lt_ptr+ltoff+4(%r1),%r19 ; get new dlt value.
91
: be 0(%sr0,%r21) ; branch to target
92
: stw %rp,-24(%sp) ; save rp
94
Import stub to call shared library routine from shared library
95
(multiple sub-space support)
96
: addil LR'ltoff,%r19 ; get procedure entry point
97
: ldw RR'ltoff(%r1),%r21
98
: ldw RR'ltoff+4(%r1),%r19 ; get new dlt value.
101
: be 0(%sr0,%r21) ; branch to target
102
: stw %rp,-24(%sp) ; save rp
104
Export stub to return from shared lib routine (multiple sub-space support)
105
One of these is created for each exported procedure in a shared
106
library (and stored in the shared lib). Shared lib routines are
107
called via the first instruction in the export stub so that we can
108
do an inter-space return. Not required for single sub-space.
109
: bl,n X,%rp ; trap the return
111
: ldw -24(%sp),%rp ; restore the original rp
114
: be,n 0(%sr0,%rp) ; inter-space return */
116
#define PLT_ENTRY_SIZE 8
117
#define GOT_ENTRY_SIZE 4
118
#define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
120
static const bfd_byte plt_stub[] =
122
0x0e, 0x80, 0x10, 0x96, /* 1: ldw 0(%r20),%r22 */
123
0xea, 0xc0, 0xc0, 0x00, /* bv %r0(%r22) */
124
0x0e, 0x88, 0x10, 0x95, /* ldw 4(%r20),%r21 */
125
#define PLT_STUB_ENTRY (3*4)
126
0xea, 0x9f, 0x1f, 0xdd, /* b,l 1b,%r20 */
127
0xd6, 0x80, 0x1c, 0x1e, /* depi 0,31,2,%r20 */
128
0x00, 0xc0, 0xff, 0xee, /* 9: .word fixup_func */
129
0xde, 0xad, 0xbe, 0xef /* .word fixup_ltp */
132
/* Section name for stubs is the associated section name plus this
134
#define STUB_SUFFIX ".stub"
136
/* We don't need to copy certain PC- or GP-relative dynamic relocs
137
into a shared object's dynamic section. All the relocs of the
138
limited class we are interested in, are absolute. */
139
#ifndef RELATIVE_DYNRELOCS
140
#define RELATIVE_DYNRELOCS 0
141
#define IS_ABSOLUTE_RELOC(r_type) 1
144
enum elf32_hppa_stub_type {
145
hppa_stub_long_branch,
146
hppa_stub_long_branch_shared,
148
hppa_stub_import_shared,
153
struct elf32_hppa_stub_hash_entry {
155
/* Base hash table entry structure. */
156
struct bfd_hash_entry root;
158
/* The stub section. */
161
/* Offset within stub_sec of the beginning of this stub. */
164
/* Given the symbol's value and its section we can determine its final
165
value when building the stubs (so the stub knows where to jump. */
166
bfd_vma target_value;
167
asection *target_section;
169
enum elf32_hppa_stub_type stub_type;
171
/* The symbol table entry, if any, that this was derived from. */
172
struct elf32_hppa_link_hash_entry *h;
174
/* Where this stub is being called from, or, in the case of combined
175
stub sections, the first input section in the group. */
179
struct elf32_hppa_link_hash_entry {
181
struct elf_link_hash_entry elf;
183
/* A pointer to the most recently used stub hash entry against this
185
struct elf32_hppa_stub_hash_entry *stub_cache;
187
/* Used to count relocations for delayed sizing of relocation
189
struct elf32_hppa_dyn_reloc_entry {
191
/* Next relocation in the chain. */
192
struct elf32_hppa_dyn_reloc_entry *next;
194
/* The input section of the reloc. */
197
/* Number of relocs copied in this section. */
200
#if RELATIVE_DYNRELOCS
201
/* Number of relative relocs copied for the input section. */
202
bfd_size_type relative_count;
206
/* Set if the only reason we need a .plt entry is for a non-PIC to
207
PIC function call. */
208
unsigned int pic_call:1;
210
/* Set if this symbol is used by a plabel reloc. */
211
unsigned int plabel:1;
214
struct elf32_hppa_link_hash_table {
216
/* The main hash table. */
217
struct elf_link_hash_table elf;
219
/* The stub hash table. */
220
struct bfd_hash_table stub_hash_table;
222
/* Linker stub bfd. */
225
/* Linker call-backs. */
226
asection * (*add_stub_section) PARAMS ((const char *, asection *));
227
void (*layout_sections_again) PARAMS ((void));
229
/* Array to keep track of which stub sections have been created, and
230
information on stub grouping. */
232
/* This is the section to which stubs in the group will be
235
/* The stub section. */
239
/* Assorted information used by elf32_hppa_size_stubs. */
240
unsigned int bfd_count;
242
asection **input_list;
243
Elf_Internal_Sym **all_local_syms;
245
/* Short-cuts to get to dynamic linker sections. */
253
/* Used during a final link to store the base of the text and data
254
segments so that we can perform SEGREL relocations. */
255
bfd_vma text_segment_base;
256
bfd_vma data_segment_base;
258
/* Whether we support multiple sub-spaces for shared libs. */
259
unsigned int multi_subspace:1;
261
/* Flags set when various size branches are detected. Used to
262
select suitable defaults for the stub group size. */
263
unsigned int has_12bit_branch:1;
264
unsigned int has_17bit_branch:1;
265
unsigned int has_22bit_branch:1;
267
/* Set if we need a .plt stub to support lazy dynamic linking. */
268
unsigned int need_plt_stub:1;
270
/* Small local sym to section mapping cache. */
271
struct sym_sec_cache sym_sec;
274
/* Various hash macros and functions. */
275
#define hppa_link_hash_table(p) \
276
((struct elf32_hppa_link_hash_table *) ((p)->hash))
278
#define hppa_stub_hash_lookup(table, string, create, copy) \
279
((struct elf32_hppa_stub_hash_entry *) \
280
bfd_hash_lookup ((table), (string), (create), (copy)))
282
static struct bfd_hash_entry *stub_hash_newfunc
283
PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
285
static struct bfd_hash_entry *hppa_link_hash_newfunc
286
PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
288
static struct bfd_link_hash_table *elf32_hppa_link_hash_table_create
291
static void elf32_hppa_link_hash_table_free
292
PARAMS ((struct bfd_link_hash_table *));
294
/* Stub handling functions. */
295
static char *hppa_stub_name
296
PARAMS ((const asection *, const asection *,
297
const struct elf32_hppa_link_hash_entry *,
298
const Elf_Internal_Rela *));
300
static struct elf32_hppa_stub_hash_entry *hppa_get_stub_entry
301
PARAMS ((const asection *, const asection *,
302
struct elf32_hppa_link_hash_entry *,
303
const Elf_Internal_Rela *,
304
struct elf32_hppa_link_hash_table *));
306
static struct elf32_hppa_stub_hash_entry *hppa_add_stub
307
PARAMS ((const char *, asection *, struct elf32_hppa_link_hash_table *));
309
static enum elf32_hppa_stub_type hppa_type_of_stub
310
PARAMS ((asection *, const Elf_Internal_Rela *,
311
struct elf32_hppa_link_hash_entry *, bfd_vma));
313
static boolean hppa_build_one_stub
314
PARAMS ((struct bfd_hash_entry *, PTR));
316
static boolean hppa_size_one_stub
317
PARAMS ((struct bfd_hash_entry *, PTR));
319
/* BFD and elf backend functions. */
320
static boolean elf32_hppa_object_p PARAMS ((bfd *));
322
static boolean elf32_hppa_add_symbol_hook
323
PARAMS ((bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
324
const char **, flagword *, asection **, bfd_vma *));
326
static boolean elf32_hppa_create_dynamic_sections
327
PARAMS ((bfd *, struct bfd_link_info *));
329
static void elf32_hppa_copy_indirect_symbol
330
PARAMS ((struct elf_link_hash_entry *, struct elf_link_hash_entry *));
332
static boolean elf32_hppa_check_relocs
333
PARAMS ((bfd *, struct bfd_link_info *,
334
asection *, const Elf_Internal_Rela *));
336
static asection *elf32_hppa_gc_mark_hook
337
PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
338
struct elf_link_hash_entry *, Elf_Internal_Sym *));
340
static boolean elf32_hppa_gc_sweep_hook
341
PARAMS ((bfd *, struct bfd_link_info *,
342
asection *, const Elf_Internal_Rela *));
344
static void elf32_hppa_hide_symbol
345
PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, boolean));
347
static boolean elf32_hppa_adjust_dynamic_symbol
348
PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
350
static boolean mark_PIC_calls
351
PARAMS ((struct elf_link_hash_entry *, PTR));
353
static boolean allocate_plt_static
354
PARAMS ((struct elf_link_hash_entry *, PTR));
356
static boolean allocate_dynrelocs
357
PARAMS ((struct elf_link_hash_entry *, PTR));
359
static boolean readonly_dynrelocs
360
PARAMS ((struct elf_link_hash_entry *, PTR));
362
static boolean clobber_millicode_symbols
363
PARAMS ((struct elf_link_hash_entry *, struct bfd_link_info *));
365
static boolean elf32_hppa_size_dynamic_sections
366
PARAMS ((bfd *, struct bfd_link_info *));
368
static void group_sections
369
PARAMS ((struct elf32_hppa_link_hash_table *, bfd_size_type, boolean));
371
static int get_local_syms
372
PARAMS ((bfd *, bfd *, struct bfd_link_info *));
374
static boolean elf32_hppa_final_link
375
PARAMS ((bfd *, struct bfd_link_info *));
377
static void hppa_record_segment_addr
378
PARAMS ((bfd *, asection *, PTR));
380
static bfd_reloc_status_type final_link_relocate
381
PARAMS ((asection *, bfd_byte *, const Elf_Internal_Rela *,
382
bfd_vma, struct elf32_hppa_link_hash_table *, asection *,
383
struct elf32_hppa_link_hash_entry *));
385
static boolean elf32_hppa_relocate_section
386
PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
387
bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
389
static boolean elf32_hppa_finish_dynamic_symbol
390
PARAMS ((bfd *, struct bfd_link_info *,
391
struct elf_link_hash_entry *, Elf_Internal_Sym *));
393
static enum elf_reloc_type_class elf32_hppa_reloc_type_class
394
PARAMS ((const Elf_Internal_Rela *));
396
static boolean elf32_hppa_finish_dynamic_sections
397
PARAMS ((bfd *, struct bfd_link_info *));
399
static void elf32_hppa_post_process_headers
400
PARAMS ((bfd *, struct bfd_link_info *));
402
static int elf32_hppa_elf_get_symbol_type
403
PARAMS ((Elf_Internal_Sym *, int));
405
/* Assorted hash table functions. */
407
/* Initialize an entry in the stub hash table. */
409
static struct bfd_hash_entry *
410
stub_hash_newfunc (entry, table, string)
411
struct bfd_hash_entry *entry;
412
struct bfd_hash_table *table;
415
/* Allocate the structure if it has not already been allocated by a
419
entry = bfd_hash_allocate (table,
420
sizeof (struct elf32_hppa_stub_hash_entry));
425
/* Call the allocation method of the superclass. */
426
entry = bfd_hash_newfunc (entry, table, string);
429
struct elf32_hppa_stub_hash_entry *eh;
431
/* Initialize the local fields. */
432
eh = (struct elf32_hppa_stub_hash_entry *) entry;
435
eh->target_value = 0;
436
eh->target_section = NULL;
437
eh->stub_type = hppa_stub_long_branch;
445
/* Initialize an entry in the link hash table. */
447
static struct bfd_hash_entry *
448
hppa_link_hash_newfunc (entry, table, string)
449
struct bfd_hash_entry *entry;
450
struct bfd_hash_table *table;
453
/* Allocate the structure if it has not already been allocated by a
457
entry = bfd_hash_allocate (table,
458
sizeof (struct elf32_hppa_link_hash_entry));
463
/* Call the allocation method of the superclass. */
464
entry = _bfd_elf_link_hash_newfunc (entry, table, string);
467
struct elf32_hppa_link_hash_entry *eh;
469
/* Initialize the local fields. */
470
eh = (struct elf32_hppa_link_hash_entry *) entry;
471
eh->stub_cache = NULL;
472
eh->dyn_relocs = NULL;
480
/* Create the derived linker hash table. The PA ELF port uses the derived
481
hash table to keep information specific to the PA ELF linker (without
482
using static variables). */
484
static struct bfd_link_hash_table *
485
elf32_hppa_link_hash_table_create (abfd)
488
struct elf32_hppa_link_hash_table *ret;
489
bfd_size_type amt = sizeof (*ret);
491
ret = (struct elf32_hppa_link_hash_table *) bfd_malloc (amt);
495
if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, hppa_link_hash_newfunc))
501
/* Init the stub hash table too. */
502
if (!bfd_hash_table_init (&ret->stub_hash_table, stub_hash_newfunc))
505
ret->stub_bfd = NULL;
506
ret->add_stub_section = NULL;
507
ret->layout_sections_again = NULL;
508
ret->stub_group = NULL;
515
ret->text_segment_base = (bfd_vma) -1;
516
ret->data_segment_base = (bfd_vma) -1;
517
ret->multi_subspace = 0;
518
ret->has_12bit_branch = 0;
519
ret->has_17bit_branch = 0;
520
ret->has_22bit_branch = 0;
521
ret->need_plt_stub = 0;
522
ret->sym_sec.abfd = NULL;
524
return &ret->elf.root;
527
/* Free the derived linker hash table. */
530
elf32_hppa_link_hash_table_free (hash)
531
struct bfd_link_hash_table *hash;
533
struct elf32_hppa_link_hash_table *ret
534
= (struct elf32_hppa_link_hash_table *) hash;
536
bfd_hash_table_free (&ret->stub_hash_table);
537
_bfd_generic_link_hash_table_free (hash);
540
/* Build a name for an entry in the stub hash table. */
543
hppa_stub_name (input_section, sym_sec, hash, rel)
544
const asection *input_section;
545
const asection *sym_sec;
546
const struct elf32_hppa_link_hash_entry *hash;
547
const Elf_Internal_Rela *rel;
554
len = 8 + 1 + strlen (hash->elf.root.root.string) + 1 + 8 + 1;
555
stub_name = bfd_malloc (len);
556
if (stub_name != NULL)
558
sprintf (stub_name, "%08x_%s+%x",
559
input_section->id & 0xffffffff,
560
hash->elf.root.root.string,
561
(int) rel->r_addend & 0xffffffff);
566
len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
567
stub_name = bfd_malloc (len);
568
if (stub_name != NULL)
570
sprintf (stub_name, "%08x_%x:%x+%x",
571
input_section->id & 0xffffffff,
572
sym_sec->id & 0xffffffff,
573
(int) ELF32_R_SYM (rel->r_info) & 0xffffffff,
574
(int) rel->r_addend & 0xffffffff);
580
/* Look up an entry in the stub hash. Stub entries are cached because
581
creating the stub name takes a bit of time. */
583
static struct elf32_hppa_stub_hash_entry *
584
hppa_get_stub_entry (input_section, sym_sec, hash, rel, htab)
585
const asection *input_section;
586
const asection *sym_sec;
587
struct elf32_hppa_link_hash_entry *hash;
588
const Elf_Internal_Rela *rel;
589
struct elf32_hppa_link_hash_table *htab;
591
struct elf32_hppa_stub_hash_entry *stub_entry;
592
const asection *id_sec;
594
/* If this input section is part of a group of sections sharing one
595
stub section, then use the id of the first section in the group.
596
Stub names need to include a section id, as there may well be
597
more than one stub used to reach say, printf, and we need to
598
distinguish between them. */
599
id_sec = htab->stub_group[input_section->id].link_sec;
601
if (hash != NULL && hash->stub_cache != NULL
602
&& hash->stub_cache->h == hash
603
&& hash->stub_cache->id_sec == id_sec)
605
stub_entry = hash->stub_cache;
611
stub_name = hppa_stub_name (id_sec, sym_sec, hash, rel);
612
if (stub_name == NULL)
615
stub_entry = hppa_stub_hash_lookup (&htab->stub_hash_table,
616
stub_name, false, false);
618
hash->stub_cache = stub_entry;
626
/* Add a new stub entry to the stub hash. Not all fields of the new
627
stub entry are initialised. */
629
static struct elf32_hppa_stub_hash_entry *
630
hppa_add_stub (stub_name, section, htab)
631
const char *stub_name;
633
struct elf32_hppa_link_hash_table *htab;
637
struct elf32_hppa_stub_hash_entry *stub_entry;
639
link_sec = htab->stub_group[section->id].link_sec;
640
stub_sec = htab->stub_group[section->id].stub_sec;
641
if (stub_sec == NULL)
643
stub_sec = htab->stub_group[link_sec->id].stub_sec;
644
if (stub_sec == NULL)
650
namelen = strlen (link_sec->name);
651
len = namelen + sizeof (STUB_SUFFIX);
652
s_name = bfd_alloc (htab->stub_bfd, len);
656
memcpy (s_name, link_sec->name, namelen);
657
memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
658
stub_sec = (*htab->add_stub_section) (s_name, link_sec);
659
if (stub_sec == NULL)
661
htab->stub_group[link_sec->id].stub_sec = stub_sec;
663
htab->stub_group[section->id].stub_sec = stub_sec;
666
/* Enter this entry into the linker stub hash table. */
667
stub_entry = hppa_stub_hash_lookup (&htab->stub_hash_table, stub_name,
669
if (stub_entry == NULL)
671
(*_bfd_error_handler) (_("%s: cannot create stub entry %s"),
672
bfd_archive_filename (section->owner),
677
stub_entry->stub_sec = stub_sec;
678
stub_entry->stub_offset = 0;
679
stub_entry->id_sec = link_sec;
683
/* Determine the type of stub needed, if any, for a call. */
685
static enum elf32_hppa_stub_type
686
hppa_type_of_stub (input_sec, rel, hash, destination)
688
const Elf_Internal_Rela *rel;
689
struct elf32_hppa_link_hash_entry *hash;
693
bfd_vma branch_offset;
694
bfd_vma max_branch_offset;
698
&& hash->elf.plt.offset != (bfd_vma) -1
699
&& (hash->elf.dynindx != -1 || hash->pic_call)
702
/* We need an import stub. Decide between hppa_stub_import
703
and hppa_stub_import_shared later. */
704
return hppa_stub_import;
707
/* Determine where the call point is. */
708
location = (input_sec->output_offset
709
+ input_sec->output_section->vma
712
branch_offset = destination - location - 8;
713
r_type = ELF32_R_TYPE (rel->r_info);
715
/* Determine if a long branch stub is needed. parisc branch offsets
716
are relative to the second instruction past the branch, ie. +8
717
bytes on from the branch instruction location. The offset is
718
signed and counts in units of 4 bytes. */
719
if (r_type == (unsigned int) R_PARISC_PCREL17F)
721
max_branch_offset = (1 << (17-1)) << 2;
723
else if (r_type == (unsigned int) R_PARISC_PCREL12F)
725
max_branch_offset = (1 << (12-1)) << 2;
727
else /* R_PARISC_PCREL22F. */
729
max_branch_offset = (1 << (22-1)) << 2;
732
if (branch_offset + max_branch_offset >= 2*max_branch_offset)
733
return hppa_stub_long_branch;
735
return hppa_stub_none;
738
/* Build one linker stub as defined by the stub hash table entry GEN_ENTRY.
739
IN_ARG contains the link info pointer. */
741
#define LDIL_R1 0x20200000 /* ldil LR'XXX,%r1 */
742
#define BE_SR4_R1 0xe0202002 /* be,n RR'XXX(%sr4,%r1) */
744
#define BL_R1 0xe8200000 /* b,l .+8,%r1 */
745
#define ADDIL_R1 0x28200000 /* addil LR'XXX,%r1,%r1 */
746
#define DEPI_R1 0xd4201c1e /* depi 0,31,2,%r1 */
748
#define ADDIL_DP 0x2b600000 /* addil LR'XXX,%dp,%r1 */
749
#define LDW_R1_R21 0x48350000 /* ldw RR'XXX(%sr0,%r1),%r21 */
750
#define BV_R0_R21 0xeaa0c000 /* bv %r0(%r21) */
751
#define LDW_R1_R19 0x48330000 /* ldw RR'XXX(%sr0,%r1),%r19 */
753
#define ADDIL_R19 0x2a600000 /* addil LR'XXX,%r19,%r1 */
754
#define LDW_R1_DP 0x483b0000 /* ldw RR'XXX(%sr0,%r1),%dp */
756
#define LDSID_R21_R1 0x02a010a1 /* ldsid (%sr0,%r21),%r1 */
757
#define MTSP_R1 0x00011820 /* mtsp %r1,%sr0 */
758
#define BE_SR0_R21 0xe2a00000 /* be 0(%sr0,%r21) */
759
#define STW_RP 0x6bc23fd1 /* stw %rp,-24(%sr0,%sp) */
761
#define BL22_RP 0xe800a002 /* b,l,n XXX,%rp */
762
#define BL_RP 0xe8400002 /* b,l,n XXX,%rp */
763
#define NOP 0x08000240 /* nop */
764
#define LDW_RP 0x4bc23fd1 /* ldw -24(%sr0,%sp),%rp */
765
#define LDSID_RP_R1 0x004010a1 /* ldsid (%sr0,%rp),%r1 */
766
#define BE_SR0_RP 0xe0400002 /* be,n 0(%sr0,%rp) */
773
#define LDW_R1_DLT LDW_R1_R19
775
#define LDW_R1_DLT LDW_R1_DP
779
hppa_build_one_stub (gen_entry, in_arg)
780
struct bfd_hash_entry *gen_entry;
783
struct elf32_hppa_stub_hash_entry *stub_entry;
784
struct bfd_link_info *info;
785
struct elf32_hppa_link_hash_table *htab;
795
/* Massage our args to the form they really have. */
796
stub_entry = (struct elf32_hppa_stub_hash_entry *) gen_entry;
797
info = (struct bfd_link_info *) in_arg;
799
htab = hppa_link_hash_table (info);
800
stub_sec = stub_entry->stub_sec;
802
/* Make a note of the offset within the stubs for this entry. */
803
stub_entry->stub_offset = stub_sec->_raw_size;
804
loc = stub_sec->contents + stub_entry->stub_offset;
806
stub_bfd = stub_sec->owner;
808
switch (stub_entry->stub_type)
810
case hppa_stub_long_branch:
811
/* Create the long branch. A long branch is formed with "ldil"
812
loading the upper bits of the target address into a register,
813
then branching with "be" which adds in the lower bits.
814
The "be" has its delay slot nullified. */
815
sym_value = (stub_entry->target_value
816
+ stub_entry->target_section->output_offset
817
+ stub_entry->target_section->output_section->vma);
819
val = hppa_field_adjust (sym_value, (bfd_signed_vma) 0, e_lrsel);
820
insn = hppa_rebuild_insn ((int) LDIL_R1, val, 21);
821
bfd_put_32 (stub_bfd, insn, loc);
823
val = hppa_field_adjust (sym_value, (bfd_signed_vma) 0, e_rrsel) >> 2;
824
insn = hppa_rebuild_insn ((int) BE_SR4_R1, val, 17);
825
bfd_put_32 (stub_bfd, insn, loc + 4);
830
case hppa_stub_long_branch_shared:
831
/* Branches are relative. This is where we are going to. */
832
sym_value = (stub_entry->target_value
833
+ stub_entry->target_section->output_offset
834
+ stub_entry->target_section->output_section->vma);
836
/* And this is where we are coming from, more or less. */
837
sym_value -= (stub_entry->stub_offset
838
+ stub_sec->output_offset
839
+ stub_sec->output_section->vma);
841
bfd_put_32 (stub_bfd, (bfd_vma) BL_R1, loc);
842
val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_lrsel);
843
insn = hppa_rebuild_insn ((int) ADDIL_R1, val, 21);
844
bfd_put_32 (stub_bfd, insn, loc + 4);
846
val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_rrsel) >> 2;
847
insn = hppa_rebuild_insn ((int) BE_SR4_R1, val, 17);
848
bfd_put_32 (stub_bfd, insn, loc + 8);
852
case hppa_stub_import:
853
case hppa_stub_import_shared:
854
off = stub_entry->h->elf.plt.offset;
855
if (off >= (bfd_vma) -2)
858
off &= ~ (bfd_vma) 1;
860
+ htab->splt->output_offset
861
+ htab->splt->output_section->vma
862
- elf_gp (htab->splt->output_section->owner));
866
if (stub_entry->stub_type == hppa_stub_import_shared)
869
val = hppa_field_adjust (sym_value, (bfd_signed_vma) 0, e_lrsel),
870
insn = hppa_rebuild_insn ((int) insn, val, 21);
871
bfd_put_32 (stub_bfd, insn, loc);
873
/* It is critical to use lrsel/rrsel here because we are using
874
two different offsets (+0 and +4) from sym_value. If we use
875
lsel/rsel then with unfortunate sym_values we will round
876
sym_value+4 up to the next 2k block leading to a mis-match
877
between the lsel and rsel value. */
878
val = hppa_field_adjust (sym_value, (bfd_signed_vma) 0, e_rrsel);
879
insn = hppa_rebuild_insn ((int) LDW_R1_R21, val, 14);
880
bfd_put_32 (stub_bfd, insn, loc + 4);
882
if (htab->multi_subspace)
884
val = hppa_field_adjust (sym_value, (bfd_signed_vma) 4, e_rrsel);
885
insn = hppa_rebuild_insn ((int) LDW_R1_DLT, val, 14);
886
bfd_put_32 (stub_bfd, insn, loc + 8);
888
bfd_put_32 (stub_bfd, (bfd_vma) LDSID_R21_R1, loc + 12);
889
bfd_put_32 (stub_bfd, (bfd_vma) MTSP_R1, loc + 16);
890
bfd_put_32 (stub_bfd, (bfd_vma) BE_SR0_R21, loc + 20);
891
bfd_put_32 (stub_bfd, (bfd_vma) STW_RP, loc + 24);
897
bfd_put_32 (stub_bfd, (bfd_vma) BV_R0_R21, loc + 8);
898
val = hppa_field_adjust (sym_value, (bfd_signed_vma) 4, e_rrsel);
899
insn = hppa_rebuild_insn ((int) LDW_R1_DLT, val, 14);
900
bfd_put_32 (stub_bfd, insn, loc + 12);
906
&& stub_entry->h != NULL
907
&& stub_entry->h->pic_call)
909
/* Build the .plt entry needed to call a PIC function from
910
statically linked code. We don't need any relocs. */
912
struct elf32_hppa_link_hash_entry *eh;
915
dynobj = htab->elf.dynobj;
916
eh = (struct elf32_hppa_link_hash_entry *) stub_entry->h;
918
if (eh->elf.root.type != bfd_link_hash_defined
919
&& eh->elf.root.type != bfd_link_hash_defweak)
922
value = (eh->elf.root.u.def.value
923
+ eh->elf.root.u.def.section->output_offset
924
+ eh->elf.root.u.def.section->output_section->vma);
926
/* Fill in the entry in the procedure linkage table.
928
The format of a plt entry is
932
bfd_put_32 (htab->splt->owner, value,
933
htab->splt->contents + off);
934
value = elf_gp (htab->splt->output_section->owner);
935
bfd_put_32 (htab->splt->owner, value,
936
htab->splt->contents + off + 4);
940
case hppa_stub_export:
941
/* Branches are relative. This is where we are going to. */
942
sym_value = (stub_entry->target_value
943
+ stub_entry->target_section->output_offset
944
+ stub_entry->target_section->output_section->vma);
946
/* And this is where we are coming from. */
947
sym_value -= (stub_entry->stub_offset
948
+ stub_sec->output_offset
949
+ stub_sec->output_section->vma);
951
if (sym_value - 8 + (1 << (17 + 1)) >= (1 << (17 + 2))
952
&& (!htab->has_22bit_branch
953
|| sym_value - 8 + (1 << (22 + 1)) >= (1 << (22 + 2))))
955
(*_bfd_error_handler)
956
(_("%s(%s+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
957
bfd_archive_filename (stub_entry->target_section->owner),
959
(long) stub_entry->stub_offset,
960
stub_entry->root.string);
961
bfd_set_error (bfd_error_bad_value);
965
val = hppa_field_adjust (sym_value, (bfd_signed_vma) -8, e_fsel) >> 2;
966
if (!htab->has_22bit_branch)
967
insn = hppa_rebuild_insn ((int) BL_RP, val, 17);
969
insn = hppa_rebuild_insn ((int) BL22_RP, val, 22);
970
bfd_put_32 (stub_bfd, insn, loc);
972
bfd_put_32 (stub_bfd, (bfd_vma) NOP, loc + 4);
973
bfd_put_32 (stub_bfd, (bfd_vma) LDW_RP, loc + 8);
974
bfd_put_32 (stub_bfd, (bfd_vma) LDSID_RP_R1, loc + 12);
975
bfd_put_32 (stub_bfd, (bfd_vma) MTSP_R1, loc + 16);
976
bfd_put_32 (stub_bfd, (bfd_vma) BE_SR0_RP, loc + 20);
978
/* Point the function symbol at the stub. */
979
stub_entry->h->elf.root.u.def.section = stub_sec;
980
stub_entry->h->elf.root.u.def.value = stub_sec->_raw_size;
990
stub_sec->_raw_size += size;
1016
/* As above, but don't actually build the stub. Just bump offset so
1017
we know stub section sizes. */
1020
hppa_size_one_stub (gen_entry, in_arg)
1021
struct bfd_hash_entry *gen_entry;
1024
struct elf32_hppa_stub_hash_entry *stub_entry;
1025
struct elf32_hppa_link_hash_table *htab;
1028
/* Massage our args to the form they really have. */
1029
stub_entry = (struct elf32_hppa_stub_hash_entry *) gen_entry;
1030
htab = (struct elf32_hppa_link_hash_table *) in_arg;
1032
if (stub_entry->stub_type == hppa_stub_long_branch)
1034
else if (stub_entry->stub_type == hppa_stub_long_branch_shared)
1036
else if (stub_entry->stub_type == hppa_stub_export)
1038
else /* hppa_stub_import or hppa_stub_import_shared. */
1040
if (htab->multi_subspace)
1046
stub_entry->stub_sec->_raw_size += size;
1050
/* Return nonzero if ABFD represents an HPPA ELF32 file.
1051
Additionally we set the default architecture and machine. */
1054
elf32_hppa_object_p (abfd)
1057
Elf_Internal_Ehdr * i_ehdrp;
1060
i_ehdrp = elf_elfheader (abfd);
1061
if (strcmp (bfd_get_target (abfd), "elf32-hppa-linux") == 0)
1063
if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_LINUX)
1068
if (i_ehdrp->e_ident[EI_OSABI] != ELFOSABI_HPUX)
1072
flags = i_ehdrp->e_flags;
1073
switch (flags & (EF_PARISC_ARCH | EF_PARISC_WIDE))
1075
case EFA_PARISC_1_0:
1076
return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 10);
1077
case EFA_PARISC_1_1:
1078
return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 11);
1079
case EFA_PARISC_2_0:
1080
return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 20);
1081
case EFA_PARISC_2_0 | EF_PARISC_WIDE:
1082
return bfd_default_set_arch_mach (abfd, bfd_arch_hppa, 25);
1087
/* Undo the generic ELF code's subtraction of section->vma from the
1088
value of each external symbol. */
1091
elf32_hppa_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1092
bfd *abfd ATTRIBUTE_UNUSED;
1093
struct bfd_link_info *info ATTRIBUTE_UNUSED;
1094
const Elf_Internal_Sym *sym ATTRIBUTE_UNUSED;
1095
const char **namep ATTRIBUTE_UNUSED;
1096
flagword *flagsp ATTRIBUTE_UNUSED;
1100
*valp += (*secp)->vma;
1104
/* Create the .plt and .got sections, and set up our hash table
1105
short-cuts to various dynamic sections. */
1108
elf32_hppa_create_dynamic_sections (abfd, info)
1110
struct bfd_link_info *info;
1112
struct elf32_hppa_link_hash_table *htab;
1114
/* Don't try to create the .plt and .got twice. */
1115
htab = hppa_link_hash_table (info);
1116
if (htab->splt != NULL)
1119
/* Call the generic code to do most of the work. */
1120
if (! _bfd_elf_create_dynamic_sections (abfd, info))
1123
htab->splt = bfd_get_section_by_name (abfd, ".plt");
1124
htab->srelplt = bfd_get_section_by_name (abfd, ".rela.plt");
1126
htab->sgot = bfd_get_section_by_name (abfd, ".got");
1127
htab->srelgot = bfd_make_section (abfd, ".rela.got");
1128
if (htab->srelgot == NULL
1129
|| ! bfd_set_section_flags (abfd, htab->srelgot,
1134
| SEC_LINKER_CREATED
1136
|| ! bfd_set_section_alignment (abfd, htab->srelgot, 2))
1139
htab->sdynbss = bfd_get_section_by_name (abfd, ".dynbss");
1140
htab->srelbss = bfd_get_section_by_name (abfd, ".rela.bss");
1145
/* Copy the extra info we tack onto an elf_link_hash_entry. */
1148
elf32_hppa_copy_indirect_symbol (dir, ind)
1149
struct elf_link_hash_entry *dir, *ind;
1151
struct elf32_hppa_link_hash_entry *edir, *eind;
1153
edir = (struct elf32_hppa_link_hash_entry *) dir;
1154
eind = (struct elf32_hppa_link_hash_entry *) ind;
1156
if (eind->dyn_relocs != NULL)
1158
if (edir->dyn_relocs != NULL)
1160
struct elf32_hppa_dyn_reloc_entry **pp;
1161
struct elf32_hppa_dyn_reloc_entry *p;
1163
if (ind->root.type == bfd_link_hash_indirect)
1166
/* Add reloc counts against the weak sym to the strong sym
1167
list. Merge any entries against the same section. */
1168
for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
1170
struct elf32_hppa_dyn_reloc_entry *q;
1172
for (q = edir->dyn_relocs; q != NULL; q = q->next)
1173
if (q->sec == p->sec)
1175
#if RELATIVE_DYNRELOCS
1176
q->relative_count += p->relative_count;
1178
q->count += p->count;
1185
*pp = edir->dyn_relocs;
1188
edir->dyn_relocs = eind->dyn_relocs;
1189
eind->dyn_relocs = NULL;
1192
_bfd_elf_link_hash_copy_indirect (dir, ind);
1195
/* Look through the relocs for a section during the first phase, and
1196
calculate needed space in the global offset table, procedure linkage
1197
table, and dynamic reloc sections. At this point we haven't
1198
necessarily read all the input files. */
1201
elf32_hppa_check_relocs (abfd, info, sec, relocs)
1203
struct bfd_link_info *info;
1205
const Elf_Internal_Rela *relocs;
1207
Elf_Internal_Shdr *symtab_hdr;
1208
struct elf_link_hash_entry **sym_hashes;
1209
const Elf_Internal_Rela *rel;
1210
const Elf_Internal_Rela *rel_end;
1211
struct elf32_hppa_link_hash_table *htab;
1213
asection *stubreloc;
1215
if (info->relocateable)
1218
htab = hppa_link_hash_table (info);
1219
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1220
sym_hashes = elf_sym_hashes (abfd);
1224
rel_end = relocs + sec->reloc_count;
1225
for (rel = relocs; rel < rel_end; rel++)
1234
unsigned int r_symndx, r_type;
1235
struct elf32_hppa_link_hash_entry *h;
1238
r_symndx = ELF32_R_SYM (rel->r_info);
1240
if (r_symndx < symtab_hdr->sh_info)
1243
h = ((struct elf32_hppa_link_hash_entry *)
1244
sym_hashes[r_symndx - symtab_hdr->sh_info]);
1246
r_type = ELF32_R_TYPE (rel->r_info);
1250
case R_PARISC_DLTIND14F:
1251
case R_PARISC_DLTIND14R:
1252
case R_PARISC_DLTIND21L:
1253
/* This symbol requires a global offset table entry. */
1254
need_entry = NEED_GOT;
1256
/* Mark this section as containing PIC code. */
1257
sec->flags |= SEC_HAS_GOT_REF;
1260
case R_PARISC_PLABEL14R: /* "Official" procedure labels. */
1261
case R_PARISC_PLABEL21L:
1262
case R_PARISC_PLABEL32:
1263
/* If the addend is non-zero, we break badly. */
1264
if (rel->r_addend != 0)
1267
/* If we are creating a shared library, then we need to
1268
create a PLT entry for all PLABELs, because PLABELs with
1269
local symbols may be passed via a pointer to another
1270
object. Additionally, output a dynamic relocation
1271
pointing to the PLT entry.
1272
For executables, the original 32-bit ABI allowed two
1273
different styles of PLABELs (function pointers): For
1274
global functions, the PLABEL word points into the .plt
1275
two bytes past a (function address, gp) pair, and for
1276
local functions the PLABEL points directly at the
1277
function. The magic +2 for the first type allows us to
1278
differentiate between the two. As you can imagine, this
1279
is a real pain when it comes to generating code to call
1280
functions indirectly or to compare function pointers.
1281
We avoid the mess by always pointing a PLABEL into the
1282
.plt, even for local functions. */
1283
need_entry = PLT_PLABEL | NEED_PLT | NEED_DYNREL;
1286
case R_PARISC_PCREL12F:
1287
htab->has_12bit_branch = 1;
1290
case R_PARISC_PCREL17C:
1291
case R_PARISC_PCREL17F:
1292
htab->has_17bit_branch = 1;
1295
case R_PARISC_PCREL22F:
1296
htab->has_22bit_branch = 1;
1298
/* Function calls might need to go through the .plt, and
1299
might require long branch stubs. */
1302
/* We know local syms won't need a .plt entry, and if
1303
they need a long branch stub we can't guarantee that
1304
we can reach the stub. So just flag an error later
1305
if we're doing a shared link and find we need a long
1311
/* Global symbols will need a .plt entry if they remain
1312
global, and in most cases won't need a long branch
1313
stub. Unfortunately, we have to cater for the case
1314
where a symbol is forced local by versioning, or due
1315
to symbolic linking, and we lose the .plt entry. */
1316
need_entry = NEED_PLT;
1317
if (h->elf.type == STT_PARISC_MILLI)
1322
case R_PARISC_SEGBASE: /* Used to set segment base. */
1323
case R_PARISC_SEGREL32: /* Relative reloc, used for unwind. */
1324
case R_PARISC_PCREL14F: /* PC relative load/store. */
1325
case R_PARISC_PCREL14R:
1326
case R_PARISC_PCREL17R: /* External branches. */
1327
case R_PARISC_PCREL21L: /* As above, and for load/store too. */
1328
/* We don't need to propagate the relocation if linking a
1329
shared object since these are section relative. */
1332
case R_PARISC_DPREL14F: /* Used for gp rel data load/store. */
1333
case R_PARISC_DPREL14R:
1334
case R_PARISC_DPREL21L:
1337
(*_bfd_error_handler)
1338
(_("%s: relocation %s can not be used when making a shared object; recompile with -fPIC"),
1339
bfd_archive_filename (abfd),
1340
elf_hppa_howto_table[r_type].name);
1341
bfd_set_error (bfd_error_bad_value);
1346
case R_PARISC_DIR17F: /* Used for external branches. */
1347
case R_PARISC_DIR17R:
1348
case R_PARISC_DIR14F: /* Used for load/store from absolute locn. */
1349
case R_PARISC_DIR14R:
1350
case R_PARISC_DIR21L: /* As above, and for ext branches too. */
1352
/* Help debug shared library creation. Any of the above
1353
relocs can be used in shared libs, but they may cause
1354
pages to become unshared. */
1357
(*_bfd_error_handler)
1358
(_("%s: relocation %s should not be used when making a shared object; recompile with -fPIC"),
1359
bfd_archive_filename (abfd),
1360
elf_hppa_howto_table[r_type].name);
1365
case R_PARISC_DIR32: /* .word relocs. */
1366
/* We may want to output a dynamic relocation later. */
1367
need_entry = NEED_DYNREL;
1370
/* This relocation describes the C++ object vtable hierarchy.
1371
Reconstruct it for later use during GC. */
1372
case R_PARISC_GNU_VTINHERIT:
1373
if (!_bfd_elf32_gc_record_vtinherit (abfd, sec,
1374
&h->elf, rel->r_offset))
1378
/* This relocation describes which C++ vtable entries are actually
1379
used. Record for later use during GC. */
1380
case R_PARISC_GNU_VTENTRY:
1381
if (!_bfd_elf32_gc_record_vtentry (abfd, sec,
1382
&h->elf, rel->r_addend))
1390
/* Now carry out our orders. */
1391
if (need_entry & NEED_GOT)
1393
/* Allocate space for a GOT entry, as well as a dynamic
1394
relocation for this entry. */
1395
if (htab->sgot == NULL)
1397
if (htab->elf.dynobj == NULL)
1398
htab->elf.dynobj = abfd;
1399
if (!elf32_hppa_create_dynamic_sections (htab->elf.dynobj, info))
1405
h->elf.got.refcount += 1;
1409
bfd_signed_vma *local_got_refcounts;
1411
/* This is a global offset table entry for a local symbol. */
1412
local_got_refcounts = elf_local_got_refcounts (abfd);
1413
if (local_got_refcounts == NULL)
1417
/* Allocate space for local got offsets and local
1418
plt offsets. Done this way to save polluting
1419
elf_obj_tdata with another target specific
1421
size = symtab_hdr->sh_info;
1422
size *= 2 * sizeof (bfd_signed_vma);
1423
local_got_refcounts = ((bfd_signed_vma *)
1424
bfd_zalloc (abfd, size));
1425
if (local_got_refcounts == NULL)
1427
elf_local_got_refcounts (abfd) = local_got_refcounts;
1429
local_got_refcounts[r_symndx] += 1;
1433
if (need_entry & NEED_PLT)
1435
/* If we are creating a shared library, and this is a reloc
1436
against a weak symbol or a global symbol in a dynamic
1437
object, then we will be creating an import stub and a
1438
.plt entry for the symbol. Similarly, on a normal link
1439
to symbols defined in a dynamic object we'll need the
1440
import stub and a .plt entry. We don't know yet whether
1441
the symbol is defined or not, so make an entry anyway and
1442
clean up later in adjust_dynamic_symbol. */
1443
if ((sec->flags & SEC_ALLOC) != 0)
1447
h->elf.elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
1448
h->elf.plt.refcount += 1;
1450
/* If this .plt entry is for a plabel, mark it so
1451
that adjust_dynamic_symbol will keep the entry
1452
even if it appears to be local. */
1453
if (need_entry & PLT_PLABEL)
1456
else if (need_entry & PLT_PLABEL)
1458
bfd_signed_vma *local_got_refcounts;
1459
bfd_signed_vma *local_plt_refcounts;
1461
local_got_refcounts = elf_local_got_refcounts (abfd);
1462
if (local_got_refcounts == NULL)
1466
/* Allocate space for local got offsets and local
1468
size = symtab_hdr->sh_info;
1469
size *= 2 * sizeof (bfd_signed_vma);
1470
local_got_refcounts = ((bfd_signed_vma *)
1471
bfd_zalloc (abfd, size));
1472
if (local_got_refcounts == NULL)
1474
elf_local_got_refcounts (abfd) = local_got_refcounts;
1476
local_plt_refcounts = (local_got_refcounts
1477
+ symtab_hdr->sh_info);
1478
local_plt_refcounts[r_symndx] += 1;
1483
if (need_entry & NEED_DYNREL)
1485
/* Flag this symbol as having a non-got, non-plt reference
1486
so that we generate copy relocs if it turns out to be
1488
if (h != NULL && !info->shared)
1489
h->elf.elf_link_hash_flags |= ELF_LINK_NON_GOT_REF;
1491
/* If we are creating a shared library then we need to copy
1492
the reloc into the shared library. However, if we are
1493
linking with -Bsymbolic, we need only copy absolute
1494
relocs or relocs against symbols that are not defined in
1495
an object we are including in the link. PC- or DP- or
1496
DLT-relative relocs against any local sym or global sym
1497
with DEF_REGULAR set, can be discarded. At this point we
1498
have not seen all the input files, so it is possible that
1499
DEF_REGULAR is not set now but will be set later (it is
1500
never cleared). We account for that possibility below by
1501
storing information in the dyn_relocs field of the
1504
A similar situation to the -Bsymbolic case occurs when
1505
creating shared libraries and symbol visibility changes
1506
render the symbol local.
1508
As it turns out, all the relocs we will be creating here
1509
are absolute, so we cannot remove them on -Bsymbolic
1510
links or visibility changes anyway. A STUB_REL reloc
1511
is absolute too, as in that case it is the reloc in the
1512
stub we will be creating, rather than copying the PCREL
1513
reloc in the branch.
1515
If on the other hand, we are creating an executable, we
1516
may need to keep relocations for symbols satisfied by a
1517
dynamic library if we manage to avoid copy relocs for the
1520
&& (sec->flags & SEC_ALLOC) != 0
1521
&& (IS_ABSOLUTE_RELOC (r_type)
1524
|| h->elf.root.type == bfd_link_hash_defweak
1525
|| (h->elf.elf_link_hash_flags
1526
& ELF_LINK_HASH_DEF_REGULAR) == 0))))
1528
&& (sec->flags & SEC_ALLOC) != 0
1530
&& (h->elf.root.type == bfd_link_hash_defweak
1531
|| (h->elf.elf_link_hash_flags
1532
& ELF_LINK_HASH_DEF_REGULAR) == 0)))
1534
struct elf32_hppa_dyn_reloc_entry *p;
1535
struct elf32_hppa_dyn_reloc_entry **head;
1537
/* Create a reloc section in dynobj and make room for
1544
name = (bfd_elf_string_from_elf_section
1546
elf_elfheader (abfd)->e_shstrndx,
1547
elf_section_data (sec)->rel_hdr.sh_name));
1550
(*_bfd_error_handler)
1551
(_("Could not find relocation section for %s"),
1553
bfd_set_error (bfd_error_bad_value);
1557
if (htab->elf.dynobj == NULL)
1558
htab->elf.dynobj = abfd;
1560
dynobj = htab->elf.dynobj;
1561
sreloc = bfd_get_section_by_name (dynobj, name);
1566
sreloc = bfd_make_section (dynobj, name);
1567
flags = (SEC_HAS_CONTENTS | SEC_READONLY
1568
| SEC_IN_MEMORY | SEC_LINKER_CREATED);
1569
if ((sec->flags & SEC_ALLOC) != 0)
1570
flags |= SEC_ALLOC | SEC_LOAD;
1572
|| !bfd_set_section_flags (dynobj, sreloc, flags)
1573
|| !bfd_set_section_alignment (dynobj, sreloc, 2))
1577
elf_section_data (sec)->sreloc = sreloc;
1580
/* If this is a global symbol, we count the number of
1581
relocations we need for this symbol. */
1584
head = &h->dyn_relocs;
1588
/* Track dynamic relocs needed for local syms too.
1589
We really need local syms available to do this
1593
s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
1598
head = ((struct elf32_hppa_dyn_reloc_entry **)
1599
&elf_section_data (s)->local_dynrel);
1603
if (p == NULL || p->sec != sec)
1605
p = ((struct elf32_hppa_dyn_reloc_entry *)
1606
bfd_alloc (htab->elf.dynobj,
1607
(bfd_size_type) sizeof *p));
1614
#if RELATIVE_DYNRELOCS
1615
p->relative_count = 0;
1620
#if RELATIVE_DYNRELOCS
1621
if (!IS_ABSOLUTE_RELOC (rtype))
1622
p->relative_count += 1;
1631
/* Return the section that should be marked against garbage collection
1632
for a given relocation. */
1635
elf32_hppa_gc_mark_hook (sec, info, rel, h, sym)
1637
struct bfd_link_info *info ATTRIBUTE_UNUSED;
1638
Elf_Internal_Rela *rel;
1639
struct elf_link_hash_entry *h;
1640
Elf_Internal_Sym *sym;
1644
switch ((unsigned int) ELF32_R_TYPE (rel->r_info))
1646
case R_PARISC_GNU_VTINHERIT:
1647
case R_PARISC_GNU_VTENTRY:
1651
switch (h->root.type)
1653
case bfd_link_hash_defined:
1654
case bfd_link_hash_defweak:
1655
return h->root.u.def.section;
1657
case bfd_link_hash_common:
1658
return h->root.u.c.p->section;
1666
return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1671
/* Update the got and plt entry reference counts for the section being
1675
elf32_hppa_gc_sweep_hook (abfd, info, sec, relocs)
1677
struct bfd_link_info *info ATTRIBUTE_UNUSED;
1679
const Elf_Internal_Rela *relocs;
1681
Elf_Internal_Shdr *symtab_hdr;
1682
struct elf_link_hash_entry **sym_hashes;
1683
bfd_signed_vma *local_got_refcounts;
1684
bfd_signed_vma *local_plt_refcounts;
1685
const Elf_Internal_Rela *rel, *relend;
1686
unsigned long r_symndx;
1687
struct elf_link_hash_entry *h;
1688
struct elf32_hppa_link_hash_table *htab;
1691
elf_section_data (sec)->local_dynrel = NULL;
1693
symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1694
sym_hashes = elf_sym_hashes (abfd);
1695
local_got_refcounts = elf_local_got_refcounts (abfd);
1696
local_plt_refcounts = local_got_refcounts;
1697
if (local_plt_refcounts != NULL)
1698
local_plt_refcounts += symtab_hdr->sh_info;
1699
htab = hppa_link_hash_table (info);
1700
dynobj = htab->elf.dynobj;
1704
relend = relocs + sec->reloc_count;
1705
for (rel = relocs; rel < relend; rel++)
1706
switch ((unsigned int) ELF32_R_TYPE (rel->r_info))
1708
case R_PARISC_DLTIND14F:
1709
case R_PARISC_DLTIND14R:
1710
case R_PARISC_DLTIND21L:
1711
r_symndx = ELF32_R_SYM (rel->r_info);
1712
if (r_symndx >= symtab_hdr->sh_info)
1714
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1715
if (h->got.refcount > 0)
1716
h->got.refcount -= 1;
1718
else if (local_got_refcounts != NULL)
1720
if (local_got_refcounts[r_symndx] > 0)
1721
local_got_refcounts[r_symndx] -= 1;
1725
case R_PARISC_PCREL12F:
1726
case R_PARISC_PCREL17C:
1727
case R_PARISC_PCREL17F:
1728
case R_PARISC_PCREL22F:
1729
r_symndx = ELF32_R_SYM (rel->r_info);
1730
if (r_symndx >= symtab_hdr->sh_info)
1732
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1733
if (h->plt.refcount > 0)
1734
h->plt.refcount -= 1;
1738
case R_PARISC_PLABEL14R:
1739
case R_PARISC_PLABEL21L:
1740
case R_PARISC_PLABEL32:
1741
r_symndx = ELF32_R_SYM (rel->r_info);
1742
if (r_symndx >= symtab_hdr->sh_info)
1744
struct elf32_hppa_link_hash_entry *eh;
1745
struct elf32_hppa_dyn_reloc_entry **pp;
1746
struct elf32_hppa_dyn_reloc_entry *p;
1748
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1750
if (h->plt.refcount > 0)
1751
h->plt.refcount -= 1;
1753
eh = (struct elf32_hppa_link_hash_entry *) h;
1755
for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1758
#if RELATIVE_DYNRELOCS
1759
if (!IS_ABSOLUTE_RELOC (rtype))
1760
p->relative_count -= 1;
1768
else if (local_plt_refcounts != NULL)
1770
if (local_plt_refcounts[r_symndx] > 0)
1771
local_plt_refcounts[r_symndx] -= 1;
1775
case R_PARISC_DIR32:
1776
r_symndx = ELF32_R_SYM (rel->r_info);
1777
if (r_symndx >= symtab_hdr->sh_info)
1779
struct elf32_hppa_link_hash_entry *eh;
1780
struct elf32_hppa_dyn_reloc_entry **pp;
1781
struct elf32_hppa_dyn_reloc_entry *p;
1783
h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1785
eh = (struct elf32_hppa_link_hash_entry *) h;
1787
for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
1790
#if RELATIVE_DYNRELOCS
1791
if (!IS_ABSOLUTE_RELOC (R_PARISC_DIR32))
1792
p->relative_count -= 1;
1809
/* Our own version of hide_symbol, so that we can keep plt entries for
1813
elf32_hppa_hide_symbol (info, h, force_local)
1814
struct bfd_link_info *info;
1815
struct elf_link_hash_entry *h;
1816
boolean force_local;
1820
h->elf_link_hash_flags |= ELF_LINK_FORCED_LOCAL;
1821
if (h->dynindx != -1)
1824
_bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1829
if (! ((struct elf32_hppa_link_hash_entry *) h)->plabel)
1831
h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1832
h->plt.offset = (bfd_vma) -1;
1836
/* This is the condition under which elf32_hppa_finish_dynamic_symbol
1837
will be called from elflink.h. If elflink.h doesn't call our
1838
finish_dynamic_symbol routine, we'll need to do something about
1839
initializing any .plt and .got entries in elf32_hppa_relocate_section. */
1840
#define WILL_CALL_FINISH_DYNAMIC_SYMBOL(DYN, INFO, H) \
1842
&& ((INFO)->shared \
1843
|| ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0) \
1844
&& ((H)->dynindx != -1 \
1845
|| ((H)->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0))
1847
/* Adjust a symbol defined by a dynamic object and referenced by a
1848
regular object. The current definition is in some section of the
1849
dynamic object, but we're not including those sections. We have to
1850
change the definition to something the rest of the link can
1854
elf32_hppa_adjust_dynamic_symbol (info, h)
1855
struct bfd_link_info *info;
1856
struct elf_link_hash_entry *h;
1858
struct elf32_hppa_link_hash_table *htab;
1859
struct elf32_hppa_link_hash_entry *eh;
1860
struct elf32_hppa_dyn_reloc_entry *p;
1862
unsigned int power_of_two;
1864
/* If this is a function, put it in the procedure linkage table. We
1865
will fill in the contents of the procedure linkage table later. */
1866
if (h->type == STT_FUNC
1867
|| (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
1869
if (h->plt.refcount <= 0
1870
|| ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1871
&& h->root.type != bfd_link_hash_defweak
1872
&& ! ((struct elf32_hppa_link_hash_entry *) h)->plabel
1873
&& (!info->shared || info->symbolic)))
1875
/* The .plt entry is not needed when:
1876
a) Garbage collection has removed all references to the
1878
b) We know for certain the symbol is defined in this
1879
object, and it's not a weak definition, nor is the symbol
1880
used by a plabel relocation. Either this object is the
1881
application or we are doing a shared symbolic link. */
1883
/* As a special sop to the hppa ABI, we keep a .plt entry
1884
for functions in sections containing PIC code. */
1886
&& h->plt.refcount > 0
1887
&& (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
1888
&& (h->root.u.def.section->flags & SEC_HAS_GOT_REF) != 0)
1889
((struct elf32_hppa_link_hash_entry *) h)->pic_call = 1;
1892
h->plt.offset = (bfd_vma) -1;
1893
h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1900
h->plt.offset = (bfd_vma) -1;
1902
/* If this is a weak symbol, and there is a real definition, the
1903
processor independent code will have arranged for us to see the
1904
real definition first, and we can just use the same value. */
1905
if (h->weakdef != NULL)
1907
if (h->weakdef->root.type != bfd_link_hash_defined
1908
&& h->weakdef->root.type != bfd_link_hash_defweak)
1910
h->root.u.def.section = h->weakdef->root.u.def.section;
1911
h->root.u.def.value = h->weakdef->root.u.def.value;
1915
/* This is a reference to a symbol defined by a dynamic object which
1916
is not a function. */
1918
/* If we are creating a shared library, we must presume that the
1919
only references to the symbol are via the global offset table.
1920
For such cases we need not do anything here; the relocations will
1921
be handled correctly by relocate_section. */
1925
/* If there are no references to this symbol that do not use the
1926
GOT, we don't need to generate a copy reloc. */
1927
if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0)
1930
eh = (struct elf32_hppa_link_hash_entry *) h;
1931
for (p = eh->dyn_relocs; p != NULL; p = p->next)
1933
s = p->sec->output_section;
1934
if (s != NULL && (s->flags & SEC_READONLY) != 0)
1938
/* If we didn't find any dynamic relocs in read-only sections, then
1939
we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1942
h->elf_link_hash_flags &= ~ELF_LINK_NON_GOT_REF;
1946
/* We must allocate the symbol in our .dynbss section, which will
1947
become part of the .bss section of the executable. There will be
1948
an entry for this symbol in the .dynsym section. The dynamic
1949
object will contain position independent code, so all references
1950
from the dynamic object to this symbol will go through the global
1951
offset table. The dynamic linker will use the .dynsym entry to
1952
determine the address it must put in the global offset table, so
1953
both the dynamic object and the regular object will refer to the
1954
same memory location for the variable. */
1956
htab = hppa_link_hash_table (info);
1958
/* We must generate a COPY reloc to tell the dynamic linker to
1959
copy the initial value out of the dynamic object and into the
1960
runtime process image. */
1961
if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1963
htab->srelbss->_raw_size += sizeof (Elf32_External_Rela);
1964
h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
1967
/* We need to figure out the alignment required for this symbol. I
1968
have no idea how other ELF linkers handle this. */
1970
power_of_two = bfd_log2 (h->size);
1971
if (power_of_two > 3)
1974
/* Apply the required alignment. */
1976
s->_raw_size = BFD_ALIGN (s->_raw_size,
1977
(bfd_size_type) (1 << power_of_two));
1978
if (power_of_two > bfd_get_section_alignment (htab->elf.dynobj, s))
1980
if (! bfd_set_section_alignment (htab->elf.dynobj, s, power_of_two))
1984
/* Define the symbol as being at this point in the section. */
1985
h->root.u.def.section = s;
1986
h->root.u.def.value = s->_raw_size;
1988
/* Increment the section size to make room for the symbol. */
1989
s->_raw_size += h->size;
1994
/* Called via elf_link_hash_traverse to create .plt entries for an
1995
application that uses statically linked PIC functions. Similar to
1996
the first part of elf32_hppa_adjust_dynamic_symbol. */
1999
mark_PIC_calls (h, inf)
2000
struct elf_link_hash_entry *h;
2001
PTR inf ATTRIBUTE_UNUSED;
2003
if (h->root.type == bfd_link_hash_warning)
2004
h = (struct elf_link_hash_entry *) h->root.u.i.link;
2006
if (! (h->plt.refcount > 0
2007
&& (h->root.type == bfd_link_hash_defined
2008
|| h->root.type == bfd_link_hash_defweak)
2009
&& (h->root.u.def.section->flags & SEC_HAS_GOT_REF) != 0))
2011
h->plt.offset = (bfd_vma) -1;
2012
h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2016
h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2017
((struct elf32_hppa_link_hash_entry *) h)->pic_call = 1;
2022
/* Allocate space in the .plt for entries that won't have relocations.
2023
ie. pic_call and plabel entries. */
2026
allocate_plt_static (h, inf)
2027
struct elf_link_hash_entry *h;
2030
struct bfd_link_info *info;
2031
struct elf32_hppa_link_hash_table *htab;
2034
if (h->root.type == bfd_link_hash_indirect)
2037
if (h->root.type == bfd_link_hash_warning)
2038
h = (struct elf_link_hash_entry *) h->root.u.i.link;
2040
info = (struct bfd_link_info *) inf;
2041
htab = hppa_link_hash_table (info);
2042
if (((struct elf32_hppa_link_hash_entry *) h)->pic_call)
2044
/* Make an entry in the .plt section for non-pic code that is
2045
calling pic code. */
2046
((struct elf32_hppa_link_hash_entry *) h)->plabel = 0;
2048
h->plt.offset = s->_raw_size;
2049
s->_raw_size += PLT_ENTRY_SIZE;
2051
else if (htab->elf.dynamic_sections_created
2052
&& h->plt.refcount > 0)
2054
/* Make sure this symbol is output as a dynamic symbol.
2055
Undefined weak syms won't yet be marked as dynamic. */
2056
if (h->dynindx == -1
2057
&& (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0
2058
&& h->type != STT_PARISC_MILLI)
2060
if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2064
if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, h))
2066
/* Allocate these later. From this point on, h->plabel
2067
means that the plt entry is only used by a plabel.
2068
We'll be using a normal plt entry for this symbol, so
2069
clear the plabel indicator. */
2070
((struct elf32_hppa_link_hash_entry *) h)->plabel = 0;
2072
else if (((struct elf32_hppa_link_hash_entry *) h)->plabel)
2074
/* Make an entry in the .plt section for plabel references
2075
that won't have a .plt entry for other reasons. */
2077
h->plt.offset = s->_raw_size;
2078
s->_raw_size += PLT_ENTRY_SIZE;
2082
/* No .plt entry needed. */
2083
h->plt.offset = (bfd_vma) -1;
2084
h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2089
h->plt.offset = (bfd_vma) -1;
2090
h->elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
2096
/* Allocate space in .plt, .got and associated reloc sections for
2100
allocate_dynrelocs (h, inf)
2101
struct elf_link_hash_entry *h;
2104
struct bfd_link_info *info;
2105
struct elf32_hppa_link_hash_table *htab;
2107
struct elf32_hppa_link_hash_entry *eh;
2108
struct elf32_hppa_dyn_reloc_entry *p;
2110
if (h->root.type == bfd_link_hash_indirect)
2113
if (h->root.type == bfd_link_hash_warning)
2114
h = (struct elf_link_hash_entry *) h->root.u.i.link;
2116
info = (struct bfd_link_info *) inf;
2117
htab = hppa_link_hash_table (info);
2118
if (htab->elf.dynamic_sections_created
2119
&& h->plt.offset != (bfd_vma) -1
2120
&& !((struct elf32_hppa_link_hash_entry *) h)->pic_call
2121
&& !((struct elf32_hppa_link_hash_entry *) h)->plabel)
2123
/* Make an entry in the .plt section. */
2125
h->plt.offset = s->_raw_size;
2126
s->_raw_size += PLT_ENTRY_SIZE;
2128
/* We also need to make an entry in the .rela.plt section. */
2129
htab->srelplt->_raw_size += sizeof (Elf32_External_Rela);
2130
htab->need_plt_stub = 1;
2133
if (h->got.refcount > 0)
2135
/* Make sure this symbol is output as a dynamic symbol.
2136
Undefined weak syms won't yet be marked as dynamic. */
2137
if (h->dynindx == -1
2138
&& (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0
2139
&& h->type != STT_PARISC_MILLI)
2141
if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2146
h->got.offset = s->_raw_size;
2147
s->_raw_size += GOT_ENTRY_SIZE;
2148
if (htab->elf.dynamic_sections_created
2150
|| (h->dynindx != -1
2151
&& h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0))
2153
htab->srelgot->_raw_size += sizeof (Elf32_External_Rela);
2157
h->got.offset = (bfd_vma) -1;
2159
eh = (struct elf32_hppa_link_hash_entry *) h;
2160
if (eh->dyn_relocs == NULL)
2163
/* If this is a -Bsymbolic shared link, then we need to discard all
2164
space allocated for dynamic pc-relative relocs against symbols
2165
defined in a regular object. For the normal shared case, discard
2166
space for relocs that have become local due to symbol visibility
2170
#if RELATIVE_DYNRELOCS
2171
if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
2172
&& ((h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0
2175
struct elf32_hppa_dyn_reloc_entry **pp;
2177
for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
2179
p->count -= p->relative_count;
2180
p->relative_count = 0;
2191
/* For the non-shared case, discard space for relocs against
2192
symbols which turn out to need copy relocs or are not
2194
if ((h->elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
2195
&& (((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2196
&& (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2197
|| (htab->elf.dynamic_sections_created
2198
&& (h->root.type == bfd_link_hash_undefweak
2199
|| h->root.type == bfd_link_hash_undefined))))
2201
/* Make sure this symbol is output as a dynamic symbol.
2202
Undefined weak syms won't yet be marked as dynamic. */
2203
if (h->dynindx == -1
2204
&& (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0
2205
&& h->type != STT_PARISC_MILLI)
2207
if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2211
/* If that succeeded, we know we'll be keeping all the
2213
if (h->dynindx != -1)
2217
eh->dyn_relocs = NULL;
2223
/* Finally, allocate space. */
2224
for (p = eh->dyn_relocs; p != NULL; p = p->next)
2226
asection *sreloc = elf_section_data (p->sec)->sreloc;
2227
sreloc->_raw_size += p->count * sizeof (Elf32_External_Rela);
2233
/* This function is called via elf_link_hash_traverse to force
2234
millicode symbols local so they do not end up as globals in the
2235
dynamic symbol table. We ought to be able to do this in
2236
adjust_dynamic_symbol, but our adjust_dynamic_symbol is not called
2237
for all dynamic symbols. Arguably, this is a bug in
2238
elf_adjust_dynamic_symbol. */
2241
clobber_millicode_symbols (h, info)
2242
struct elf_link_hash_entry *h;
2243
struct bfd_link_info *info;
2245
if (h->root.type == bfd_link_hash_warning)
2246
h = (struct elf_link_hash_entry *) h->root.u.i.link;
2248
if (h->type == STT_PARISC_MILLI
2249
&& (h->elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) == 0)
2251
elf32_hppa_hide_symbol (info, h, true);
2256
/* Find any dynamic relocs that apply to read-only sections. */
2259
readonly_dynrelocs (h, inf)
2260
struct elf_link_hash_entry *h;
2263
struct elf32_hppa_link_hash_entry *eh;
2264
struct elf32_hppa_dyn_reloc_entry *p;
2266
if (h->root.type == bfd_link_hash_warning)
2267
h = (struct elf_link_hash_entry *) h->root.u.i.link;
2269
eh = (struct elf32_hppa_link_hash_entry *) h;
2270
for (p = eh->dyn_relocs; p != NULL; p = p->next)
2272
asection *s = p->sec->output_section;
2274
if (s != NULL && (s->flags & SEC_READONLY) != 0)
2276
struct bfd_link_info *info = (struct bfd_link_info *) inf;
2278
info->flags |= DF_TEXTREL;
2280
/* Not an error, just cut short the traversal. */
2287
/* Set the sizes of the dynamic sections. */
2290
elf32_hppa_size_dynamic_sections (output_bfd, info)
2291
bfd *output_bfd ATTRIBUTE_UNUSED;
2292
struct bfd_link_info *info;
2294
struct elf32_hppa_link_hash_table *htab;
2300
htab = hppa_link_hash_table (info);
2301
dynobj = htab->elf.dynobj;
2305
if (htab->elf.dynamic_sections_created)
2307
/* Set the contents of the .interp section to the interpreter. */
2310
s = bfd_get_section_by_name (dynobj, ".interp");
2313
s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
2314
s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2317
/* Force millicode symbols local. */
2318
elf_link_hash_traverse (&htab->elf,
2319
clobber_millicode_symbols,
2324
/* Run through the function symbols, looking for any that are
2325
PIC, and mark them as needing .plt entries so that %r19 will
2328
elf_link_hash_traverse (&htab->elf, mark_PIC_calls, (PTR) info);
2331
/* Set up .got and .plt offsets for local syms, and space for local
2333
for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2335
bfd_signed_vma *local_got;
2336
bfd_signed_vma *end_local_got;
2337
bfd_signed_vma *local_plt;
2338
bfd_signed_vma *end_local_plt;
2339
bfd_size_type locsymcount;
2340
Elf_Internal_Shdr *symtab_hdr;
2343
if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2346
for (s = ibfd->sections; s != NULL; s = s->next)
2348
struct elf32_hppa_dyn_reloc_entry *p;
2350
for (p = ((struct elf32_hppa_dyn_reloc_entry *)
2351
elf_section_data (s)->local_dynrel);
2355
if (!bfd_is_abs_section (p->sec)
2356
&& bfd_is_abs_section (p->sec->output_section))
2358
/* Input section has been discarded, either because
2359
it is a copy of a linkonce section or due to
2360
linker script /DISCARD/, so we'll be discarding
2363
else if (p->count != 0)
2365
srel = elf_section_data (p->sec)->sreloc;
2366
srel->_raw_size += p->count * sizeof (Elf32_External_Rela);
2367
if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2368
info->flags |= DF_TEXTREL;
2373
local_got = elf_local_got_refcounts (ibfd);
2377
symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2378
locsymcount = symtab_hdr->sh_info;
2379
end_local_got = local_got + locsymcount;
2381
srel = htab->srelgot;
2382
for (; local_got < end_local_got; ++local_got)
2386
*local_got = s->_raw_size;
2387
s->_raw_size += GOT_ENTRY_SIZE;
2389
srel->_raw_size += sizeof (Elf32_External_Rela);
2392
*local_got = (bfd_vma) -1;
2395
local_plt = end_local_got;
2396
end_local_plt = local_plt + locsymcount;
2397
if (! htab->elf.dynamic_sections_created)
2399
/* Won't be used, but be safe. */
2400
for (; local_plt < end_local_plt; ++local_plt)
2401
*local_plt = (bfd_vma) -1;
2406
srel = htab->srelplt;
2407
for (; local_plt < end_local_plt; ++local_plt)
2411
*local_plt = s->_raw_size;
2412
s->_raw_size += PLT_ENTRY_SIZE;
2414
srel->_raw_size += sizeof (Elf32_External_Rela);
2417
*local_plt = (bfd_vma) -1;
2422
/* Do all the .plt entries without relocs first. The dynamic linker
2423
uses the last .plt reloc to find the end of the .plt (and hence
2424
the start of the .got) for lazy linking. */
2425
elf_link_hash_traverse (&htab->elf, allocate_plt_static, (PTR) info);
2427
/* Allocate global sym .plt and .got entries, and space for global
2428
sym dynamic relocs. */
2429
elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, (PTR) info);
2431
/* The check_relocs and adjust_dynamic_symbol entry points have
2432
determined the sizes of the various dynamic sections. Allocate
2435
for (s = dynobj->sections; s != NULL; s = s->next)
2437
if ((s->flags & SEC_LINKER_CREATED) == 0)
2440
if (s == htab->splt)
2442
if (htab->need_plt_stub)
2444
/* Make space for the plt stub at the end of the .plt
2445
section. We want this stub right at the end, up
2446
against the .got section. */
2447
int gotalign = bfd_section_alignment (dynobj, htab->sgot);
2448
int pltalign = bfd_section_alignment (dynobj, s);
2451
if (gotalign > pltalign)
2452
bfd_set_section_alignment (dynobj, s, gotalign);
2453
mask = ((bfd_size_type) 1 << gotalign) - 1;
2454
s->_raw_size = (s->_raw_size + sizeof (plt_stub) + mask) & ~mask;
2457
else if (s == htab->sgot)
2459
else if (strncmp (bfd_get_section_name (dynobj, s), ".rela", 5) == 0)
2461
if (s->_raw_size != 0)
2463
/* Remember whether there are any reloc sections other
2465
if (s != htab->srelplt)
2468
/* We use the reloc_count field as a counter if we need
2469
to copy relocs into the output file. */
2475
/* It's not one of our sections, so don't allocate space. */
2479
if (s->_raw_size == 0)
2481
/* If we don't need this section, strip it from the
2482
output file. This is mostly to handle .rela.bss and
2483
.rela.plt. We must create both sections in
2484
create_dynamic_sections, because they must be created
2485
before the linker maps input sections to output
2486
sections. The linker does that before
2487
adjust_dynamic_symbol is called, and it is that
2488
function which decides whether anything needs to go
2489
into these sections. */
2490
_bfd_strip_section_from_output (info, s);
2494
/* Allocate memory for the section contents. Zero it, because
2495
we may not fill in all the reloc sections. */
2496
s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
2497
if (s->contents == NULL && s->_raw_size != 0)
2501
if (htab->elf.dynamic_sections_created)
2503
/* Like IA-64 and HPPA64, always create a DT_PLTGOT. It
2504
actually has nothing to do with the PLT, it is how we
2505
communicate the LTP value of a load module to the dynamic
2507
#define add_dynamic_entry(TAG, VAL) \
2508
bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
2510
if (!add_dynamic_entry (DT_PLTGOT, 0))
2513
/* Add some entries to the .dynamic section. We fill in the
2514
values later, in elf32_hppa_finish_dynamic_sections, but we
2515
must add the entries now so that we get the correct size for
2516
the .dynamic section. The DT_DEBUG entry is filled in by the
2517
dynamic linker and used by the debugger. */
2520
if (!add_dynamic_entry (DT_DEBUG, 0))
2524
if (htab->srelplt->_raw_size != 0)
2526
if (!add_dynamic_entry (DT_PLTRELSZ, 0)
2527
|| !add_dynamic_entry (DT_PLTREL, DT_RELA)
2528
|| !add_dynamic_entry (DT_JMPREL, 0))
2534
if (!add_dynamic_entry (DT_RELA, 0)
2535
|| !add_dynamic_entry (DT_RELASZ, 0)
2536
|| !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
2539
/* If any dynamic relocs apply to a read-only section,
2540
then we need a DT_TEXTREL entry. */
2541
if ((info->flags & DF_TEXTREL) == 0)
2542
elf_link_hash_traverse (&htab->elf, readonly_dynrelocs,
2545
if ((info->flags & DF_TEXTREL) != 0)
2547
if (!add_dynamic_entry (DT_TEXTREL, 0))
2552
#undef add_dynamic_entry
2557
/* External entry points for sizing and building linker stubs. */
2559
/* Set up various things so that we can make a list of input sections
2560
for each output section included in the link. Returns -1 on error,
2561
0 when no stubs will be needed, and 1 on success. */
2564
elf32_hppa_setup_section_lists (output_bfd, info)
2566
struct bfd_link_info *info;
2569
unsigned int bfd_count;
2570
int top_id, top_index;
2572
asection **input_list, **list;
2574
struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
2576
if (htab->elf.root.creator->flavour != bfd_target_elf_flavour)
2579
/* Count the number of input BFDs and find the top input section id. */
2580
for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
2582
input_bfd = input_bfd->link_next)
2585
for (section = input_bfd->sections;
2587
section = section->next)
2589
if (top_id < section->id)
2590
top_id = section->id;
2593
htab->bfd_count = bfd_count;
2595
amt = sizeof (struct map_stub) * (top_id + 1);
2596
htab->stub_group = (struct map_stub *) bfd_zmalloc (amt);
2597
if (htab->stub_group == NULL)
2600
/* We can't use output_bfd->section_count here to find the top output
2601
section index as some sections may have been removed, and
2602
_bfd_strip_section_from_output doesn't renumber the indices. */
2603
for (section = output_bfd->sections, top_index = 0;
2605
section = section->next)
2607
if (top_index < section->index)
2608
top_index = section->index;
2611
htab->top_index = top_index;
2612
amt = sizeof (asection *) * (top_index + 1);
2613
input_list = (asection **) bfd_malloc (amt);
2614
htab->input_list = input_list;
2615
if (input_list == NULL)
2618
/* For sections we aren't interested in, mark their entries with a
2619
value we can check later. */
2620
list = input_list + top_index;
2622
*list = bfd_abs_section_ptr;
2623
while (list-- != input_list);
2625
for (section = output_bfd->sections;
2627
section = section->next)
2629
if ((section->flags & SEC_CODE) != 0)
2630
input_list[section->index] = NULL;
2636
/* The linker repeatedly calls this function for each input section,
2637
in the order that input sections are linked into output sections.
2638
Build lists of input sections to determine groupings between which
2639
we may insert linker stubs. */
2642
elf32_hppa_next_input_section (info, isec)
2643
struct bfd_link_info *info;
2646
struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
2648
if (isec->output_section->index <= htab->top_index)
2650
asection **list = htab->input_list + isec->output_section->index;
2651
if (*list != bfd_abs_section_ptr)
2653
/* Steal the link_sec pointer for our list. */
2654
#define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
2655
/* This happens to make the list in reverse order,
2656
which is what we want. */
2657
PREV_SEC (isec) = *list;
2663
/* See whether we can group stub sections together. Grouping stub
2664
sections may result in fewer stubs. More importantly, we need to
2665
put all .init* and .fini* stubs at the beginning of the .init or
2666
.fini output sections respectively, because glibc splits the
2667
_init and _fini functions into multiple parts. Putting a stub in
2668
the middle of a function is not a good idea. */
2671
group_sections (htab, stub_group_size, stubs_always_before_branch)
2672
struct elf32_hppa_link_hash_table *htab;
2673
bfd_size_type stub_group_size;
2674
boolean stubs_always_before_branch;
2676
asection **list = htab->input_list + htab->top_index;
2679
asection *tail = *list;
2680
if (tail == bfd_abs_section_ptr)
2682
while (tail != NULL)
2686
bfd_size_type total;
2689
if (tail->_cooked_size)
2690
total = tail->_cooked_size;
2692
total = tail->_raw_size;
2693
while ((prev = PREV_SEC (curr)) != NULL
2694
&& ((total += curr->output_offset - prev->output_offset)
2698
/* OK, the size from the start of CURR to the end is less
2699
than 240000 bytes and thus can be handled by one stub
2700
section. (or the tail section is itself larger than
2701
240000 bytes, in which case we may be toast.)
2702
We should really be keeping track of the total size of
2703
stubs added here, as stubs contribute to the final output
2704
section size. That's a little tricky, and this way will
2705
only break if stubs added total more than 22144 bytes, or
2706
2768 long branch stubs. It seems unlikely for more than
2707
2768 different functions to be called, especially from
2708
code only 240000 bytes long. This limit used to be
2709
250000, but c++ code tends to generate lots of little
2710
functions, and sometimes violated the assumption. */
2713
prev = PREV_SEC (tail);
2714
/* Set up this stub group. */
2715
htab->stub_group[tail->id].link_sec = curr;
2717
while (tail != curr && (tail = prev) != NULL);
2719
/* But wait, there's more! Input sections up to 240000
2720
bytes before the stub section can be handled by it too. */
2721
if (!stubs_always_before_branch)
2725
&& ((total += tail->output_offset - prev->output_offset)
2729
prev = PREV_SEC (tail);
2730
htab->stub_group[tail->id].link_sec = curr;
2736
while (list-- != htab->input_list);
2737
free (htab->input_list);
2741
/* Read in all local syms for all input bfds, and create hash entries
2742
for export stubs if we are building a multi-subspace shared lib.
2743
Returns -1 on error, 1 if export stubs created, 0 otherwise. */
2746
get_local_syms (output_bfd, input_bfd, info)
2749
struct bfd_link_info *info;
2751
unsigned int bfd_indx;
2752
Elf_Internal_Sym *local_syms, **all_local_syms;
2753
int stub_changed = 0;
2754
struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
2756
/* We want to read in symbol extension records only once. To do this
2757
we need to read in the local symbols in parallel and save them for
2758
later use; so hold pointers to the local symbols in an array. */
2759
bfd_size_type amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
2760
all_local_syms = (Elf_Internal_Sym **) bfd_zmalloc (amt);
2761
htab->all_local_syms = all_local_syms;
2762
if (all_local_syms == NULL)
2765
/* Walk over all the input BFDs, swapping in local symbols.
2766
If we are creating a shared library, create hash entries for the
2770
input_bfd = input_bfd->link_next, bfd_indx++)
2772
Elf_Internal_Shdr *symtab_hdr;
2774
/* We'll need the symbol table in a second. */
2775
symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2776
if (symtab_hdr->sh_info == 0)
2779
/* We need an array of the local symbols attached to the input bfd. */
2780
local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
2781
if (local_syms == NULL)
2783
local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2784
symtab_hdr->sh_info, 0,
2786
/* Cache them for elf_link_input_bfd. */
2787
symtab_hdr->contents = (unsigned char *) local_syms;
2789
if (local_syms == NULL)
2792
all_local_syms[bfd_indx] = local_syms;
2794
if (info->shared && htab->multi_subspace)
2796
struct elf_link_hash_entry **sym_hashes;
2797
struct elf_link_hash_entry **end_hashes;
2798
unsigned int symcount;
2800
symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2801
- symtab_hdr->sh_info);
2802
sym_hashes = elf_sym_hashes (input_bfd);
2803
end_hashes = sym_hashes + symcount;
2805
/* Look through the global syms for functions; We need to
2806
build export stubs for all globally visible functions. */
2807
for (; sym_hashes < end_hashes; sym_hashes++)
2809
struct elf32_hppa_link_hash_entry *hash;
2811
hash = (struct elf32_hppa_link_hash_entry *) *sym_hashes;
2813
while (hash->elf.root.type == bfd_link_hash_indirect
2814
|| hash->elf.root.type == bfd_link_hash_warning)
2815
hash = ((struct elf32_hppa_link_hash_entry *)
2816
hash->elf.root.u.i.link);
2818
/* At this point in the link, undefined syms have been
2819
resolved, so we need to check that the symbol was
2820
defined in this BFD. */
2821
if ((hash->elf.root.type == bfd_link_hash_defined
2822
|| hash->elf.root.type == bfd_link_hash_defweak)
2823
&& hash->elf.type == STT_FUNC
2824
&& hash->elf.root.u.def.section->output_section != NULL
2825
&& (hash->elf.root.u.def.section->output_section->owner
2827
&& hash->elf.root.u.def.section->owner == input_bfd
2828
&& (hash->elf.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
2829
&& !(hash->elf.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL)
2830
&& ELF_ST_VISIBILITY (hash->elf.other) == STV_DEFAULT)
2833
const char *stub_name;
2834
struct elf32_hppa_stub_hash_entry *stub_entry;
2836
sec = hash->elf.root.u.def.section;
2837
stub_name = hash->elf.root.root.string;
2838
stub_entry = hppa_stub_hash_lookup (&htab->stub_hash_table,
2841
if (stub_entry == NULL)
2843
stub_entry = hppa_add_stub (stub_name, sec, htab);
2847
stub_entry->target_value = hash->elf.root.u.def.value;
2848
stub_entry->target_section = hash->elf.root.u.def.section;
2849
stub_entry->stub_type = hppa_stub_export;
2850
stub_entry->h = hash;
2855
(*_bfd_error_handler) (_("%s: duplicate export stub %s"),
2856
bfd_archive_filename (input_bfd),
2864
return stub_changed;
2867
/* Determine and set the size of the stub section for a final link.
2869
The basic idea here is to examine all the relocations looking for
2870
PC-relative calls to a target that is unreachable with a "bl"
2874
elf32_hppa_size_stubs (output_bfd, stub_bfd, info, multi_subspace, group_size,
2875
add_stub_section, layout_sections_again)
2878
struct bfd_link_info *info;
2879
boolean multi_subspace;
2880
bfd_signed_vma group_size;
2881
asection * (*add_stub_section) PARAMS ((const char *, asection *));
2882
void (*layout_sections_again) PARAMS ((void));
2884
bfd_size_type stub_group_size;
2885
boolean stubs_always_before_branch;
2886
boolean stub_changed;
2887
struct elf32_hppa_link_hash_table *htab = hppa_link_hash_table (info);
2889
/* Stash our params away. */
2890
htab->stub_bfd = stub_bfd;
2891
htab->multi_subspace = multi_subspace;
2892
htab->add_stub_section = add_stub_section;
2893
htab->layout_sections_again = layout_sections_again;
2894
stubs_always_before_branch = group_size < 0;
2896
stub_group_size = -group_size;
2898
stub_group_size = group_size;
2899
if (stub_group_size == 1)
2901
/* Default values. */
2902
stub_group_size = 7680000;
2903
if (htab->has_17bit_branch || htab->multi_subspace)
2904
stub_group_size = 240000;
2905
if (htab->has_12bit_branch)
2906
stub_group_size = 7500;
2909
group_sections (htab, stub_group_size, stubs_always_before_branch);
2911
switch (get_local_syms (output_bfd, info->input_bfds, info))
2914
if (htab->all_local_syms)
2915
goto error_ret_free_local;
2919
stub_changed = false;
2923
stub_changed = true;
2930
unsigned int bfd_indx;
2933
for (input_bfd = info->input_bfds, bfd_indx = 0;
2935
input_bfd = input_bfd->link_next, bfd_indx++)
2937
Elf_Internal_Shdr *symtab_hdr;
2939
Elf_Internal_Sym *local_syms;
2941
/* We'll need the symbol table in a second. */
2942
symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2943
if (symtab_hdr->sh_info == 0)
2946
local_syms = htab->all_local_syms[bfd_indx];
2948
/* Walk over each section attached to the input bfd. */
2949
for (section = input_bfd->sections;
2951
section = section->next)
2953
Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
2955
/* If there aren't any relocs, then there's nothing more
2957
if ((section->flags & SEC_RELOC) == 0
2958
|| section->reloc_count == 0)
2961
/* If this section is a link-once section that will be
2962
discarded, then don't create any stubs. */
2963
if (section->output_section == NULL
2964
|| section->output_section->owner != output_bfd)
2967
/* Get the relocs. */
2969
= _bfd_elf32_link_read_relocs (input_bfd, section, NULL,
2970
(Elf_Internal_Rela *) NULL,
2972
if (internal_relocs == NULL)
2973
goto error_ret_free_local;
2975
/* Now examine each relocation. */
2976
irela = internal_relocs;
2977
irelaend = irela + section->reloc_count;
2978
for (; irela < irelaend; irela++)
2980
unsigned int r_type, r_indx;
2981
enum elf32_hppa_stub_type stub_type;
2982
struct elf32_hppa_stub_hash_entry *stub_entry;
2985
bfd_vma destination;
2986
struct elf32_hppa_link_hash_entry *hash;
2988
const asection *id_sec;
2990
r_type = ELF32_R_TYPE (irela->r_info);
2991
r_indx = ELF32_R_SYM (irela->r_info);
2993
if (r_type >= (unsigned int) R_PARISC_UNIMPLEMENTED)
2995
bfd_set_error (bfd_error_bad_value);
2996
error_ret_free_internal:
2997
if (elf_section_data (section)->relocs == NULL)
2998
free (internal_relocs);
2999
goto error_ret_free_local;
3002
/* Only look for stubs on call instructions. */
3003
if (r_type != (unsigned int) R_PARISC_PCREL12F
3004
&& r_type != (unsigned int) R_PARISC_PCREL17F
3005
&& r_type != (unsigned int) R_PARISC_PCREL22F)
3008
/* Now determine the call target, its name, value,
3014
if (r_indx < symtab_hdr->sh_info)
3016
/* It's a local symbol. */
3017
Elf_Internal_Sym *sym;
3018
Elf_Internal_Shdr *hdr;
3020
sym = local_syms + r_indx;
3021
hdr = elf_elfsections (input_bfd)[sym->st_shndx];
3022
sym_sec = hdr->bfd_section;
3023
if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
3024
sym_value = sym->st_value;
3025
destination = (sym_value + irela->r_addend
3026
+ sym_sec->output_offset
3027
+ sym_sec->output_section->vma);
3031
/* It's an external symbol. */
3034
e_indx = r_indx - symtab_hdr->sh_info;
3035
hash = ((struct elf32_hppa_link_hash_entry *)
3036
elf_sym_hashes (input_bfd)[e_indx]);
3038
while (hash->elf.root.type == bfd_link_hash_indirect
3039
|| hash->elf.root.type == bfd_link_hash_warning)
3040
hash = ((struct elf32_hppa_link_hash_entry *)
3041
hash->elf.root.u.i.link);
3043
if (hash->elf.root.type == bfd_link_hash_defined
3044
|| hash->elf.root.type == bfd_link_hash_defweak)
3046
sym_sec = hash->elf.root.u.def.section;
3047
sym_value = hash->elf.root.u.def.value;
3048
if (sym_sec->output_section != NULL)
3049
destination = (sym_value + irela->r_addend
3050
+ sym_sec->output_offset
3051
+ sym_sec->output_section->vma);
3053
else if (hash->elf.root.type == bfd_link_hash_undefweak)
3058
else if (hash->elf.root.type == bfd_link_hash_undefined)
3061
&& !info->no_undefined
3062
&& (ELF_ST_VISIBILITY (hash->elf.other)
3064
&& hash->elf.type != STT_PARISC_MILLI))
3069
bfd_set_error (bfd_error_bad_value);
3070
goto error_ret_free_internal;
3074
/* Determine what (if any) linker stub is needed. */
3075
stub_type = hppa_type_of_stub (section, irela, hash,
3077
if (stub_type == hppa_stub_none)
3080
/* Support for grouping stub sections. */
3081
id_sec = htab->stub_group[section->id].link_sec;
3083
/* Get the name of this stub. */
3084
stub_name = hppa_stub_name (id_sec, sym_sec, hash, irela);
3086
goto error_ret_free_internal;
3088
stub_entry = hppa_stub_hash_lookup (&htab->stub_hash_table,
3091
if (stub_entry != NULL)
3093
/* The proper stub has already been created. */
3098
stub_entry = hppa_add_stub (stub_name, section, htab);
3099
if (stub_entry == NULL)
3102
goto error_ret_free_internal;
3105
stub_entry->target_value = sym_value;
3106
stub_entry->target_section = sym_sec;
3107
stub_entry->stub_type = stub_type;
3110
if (stub_type == hppa_stub_import)
3111
stub_entry->stub_type = hppa_stub_import_shared;
3112
else if (stub_type == hppa_stub_long_branch)
3113
stub_entry->stub_type = hppa_stub_long_branch_shared;
3115
stub_entry->h = hash;
3116
stub_changed = true;
3119
/* We're done with the internal relocs, free them. */
3120
if (elf_section_data (section)->relocs == NULL)
3121
free (internal_relocs);
3128
/* OK, we've added some stubs. Find out the new size of the
3130
for (stub_sec = htab->stub_bfd->sections;
3132
stub_sec = stub_sec->next)
3134
stub_sec->_raw_size = 0;
3135
stub_sec->_cooked_size = 0;
3138
bfd_hash_traverse (&htab->stub_hash_table, hppa_size_one_stub, htab);
3140
/* Ask the linker to do its stuff. */
3141
(*htab->layout_sections_again) ();
3142
stub_changed = false;
3145
free (htab->all_local_syms);
3148
error_ret_free_local:
3149
free (htab->all_local_syms);
3153
/* For a final link, this function is called after we have sized the
3154
stubs to provide a value for __gp. */
3157
elf32_hppa_set_gp (abfd, info)
3159
struct bfd_link_info *info;
3161
struct bfd_link_hash_entry *h;
3162
asection *sec = NULL;
3164
struct elf32_hppa_link_hash_table *htab;
3166
htab = hppa_link_hash_table (info);
3167
h = bfd_link_hash_lookup (&htab->elf.root, "$global$", false, false, false);
3170
&& (h->type == bfd_link_hash_defined
3171
|| h->type == bfd_link_hash_defweak))
3173
gp_val = h->u.def.value;
3174
sec = h->u.def.section;
3181
if (htab->elf.root.creator->flavour == bfd_target_elf_flavour)
3188
/* If we're not elf, look up the output sections in the
3189
hope we may actually find them. */
3190
splt = bfd_get_section_by_name (abfd, ".plt");
3191
sgot = bfd_get_section_by_name (abfd, ".got");
3194
/* Choose to point our LTP at, in this order, one of .plt, .got,
3195
or .data, if these sections exist. In the case of choosing
3196
.plt try to make the LTP ideal for addressing anywhere in the
3197
.plt or .got with a 14 bit signed offset. Typically, the end
3198
of the .plt is the start of the .got, so choose .plt + 0x2000
3199
if either the .plt or .got is larger than 0x2000. If both
3200
the .plt and .got are smaller than 0x2000, choose the end of
3201
the .plt section. */
3205
gp_val = sec->_raw_size;
3206
if (gp_val > 0x2000 || (sgot && sgot->_raw_size > 0x2000))
3216
/* We know we don't have a .plt. If .got is large,
3218
if (sec->_raw_size > 0x2000)
3223
/* No .plt or .got. Who cares what the LTP is? */
3224
sec = bfd_get_section_by_name (abfd, ".data");
3230
h->type = bfd_link_hash_defined;
3231
h->u.def.value = gp_val;
3233
h->u.def.section = sec;
3235
h->u.def.section = bfd_abs_section_ptr;
3239
if (sec != NULL && sec->output_section != NULL)
3240
gp_val += sec->output_section->vma + sec->output_offset;
3242
elf_gp (abfd) = gp_val;
3246
/* Build all the stubs associated with the current output file. The
3247
stubs are kept in a hash table attached to the main linker hash
3248
table. We also set up the .plt entries for statically linked PIC
3249
functions here. This function is called via hppaelf_finish in the
3253
elf32_hppa_build_stubs (info)
3254
struct bfd_link_info *info;
3257
struct bfd_hash_table *table;
3258
struct elf32_hppa_link_hash_table *htab;
3260
htab = hppa_link_hash_table (info);
3262
for (stub_sec = htab->stub_bfd->sections;
3264
stub_sec = stub_sec->next)
3268
/* Allocate memory to hold the linker stubs. */
3269
size = stub_sec->_raw_size;
3270
stub_sec->contents = (unsigned char *) bfd_zalloc (htab->stub_bfd, size);
3271
if (stub_sec->contents == NULL && size != 0)
3273
stub_sec->_raw_size = 0;
3276
/* Build the stubs as directed by the stub hash table. */
3277
table = &htab->stub_hash_table;
3278
bfd_hash_traverse (table, hppa_build_one_stub, info);
3283
/* Perform a final link. */
3286
elf32_hppa_final_link (abfd, info)
3288
struct bfd_link_info *info;
3290
/* Invoke the regular ELF linker to do all the work. */
3291
if (!bfd_elf32_bfd_final_link (abfd, info))
3294
/* If we're producing a final executable, sort the contents of the
3296
return elf_hppa_sort_unwind (abfd);
3299
/* Record the lowest address for the data and text segments. */
3302
hppa_record_segment_addr (abfd, section, data)
3303
bfd *abfd ATTRIBUTE_UNUSED;
3307
struct elf32_hppa_link_hash_table *htab;
3309
htab = (struct elf32_hppa_link_hash_table *) data;
3311
if ((section->flags & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3313
bfd_vma value = section->vma - section->filepos;
3315
if ((section->flags & SEC_READONLY) != 0)
3317
if (value < htab->text_segment_base)
3318
htab->text_segment_base = value;
3322
if (value < htab->data_segment_base)
3323
htab->data_segment_base = value;
3328
/* Perform a relocation as part of a final link. */
3330
static bfd_reloc_status_type
3331
final_link_relocate (input_section, contents, rel, value, htab, sym_sec, h)
3332
asection *input_section;
3334
const Elf_Internal_Rela *rel;
3336
struct elf32_hppa_link_hash_table *htab;
3338
struct elf32_hppa_link_hash_entry *h;
3341
unsigned int r_type = ELF32_R_TYPE (rel->r_info);
3342
reloc_howto_type *howto = elf_hppa_howto_table + r_type;
3343
int r_format = howto->bitsize;
3344
enum hppa_reloc_field_selector_type_alt r_field;
3345
bfd *input_bfd = input_section->owner;
3346
bfd_vma offset = rel->r_offset;
3347
bfd_vma max_branch_offset = 0;
3348
bfd_byte *hit_data = contents + offset;
3349
bfd_signed_vma addend = rel->r_addend;
3351
struct elf32_hppa_stub_hash_entry *stub_entry = NULL;
3354
if (r_type == R_PARISC_NONE)
3355
return bfd_reloc_ok;
3357
insn = bfd_get_32 (input_bfd, hit_data);
3359
/* Find out where we are and where we're going. */
3360
location = (offset +
3361
input_section->output_offset +
3362
input_section->output_section->vma);
3366
case R_PARISC_PCREL12F:
3367
case R_PARISC_PCREL17F:
3368
case R_PARISC_PCREL22F:
3369
/* If this call should go via the plt, find the import stub in
3372
|| sym_sec->output_section == NULL
3374
&& h->elf.plt.offset != (bfd_vma) -1
3375
&& (h->elf.dynindx != -1 || h->pic_call)
3378
stub_entry = hppa_get_stub_entry (input_section, sym_sec,
3380
if (stub_entry != NULL)
3382
value = (stub_entry->stub_offset
3383
+ stub_entry->stub_sec->output_offset
3384
+ stub_entry->stub_sec->output_section->vma);
3387
else if (sym_sec == NULL && h != NULL
3388
&& h->elf.root.type == bfd_link_hash_undefweak)
3390
/* It's OK if undefined weak. Calls to undefined weak
3391
symbols behave as if the "called" function
3392
immediately returns. We can thus call to a weak
3393
function without first checking whether the function
3399
return bfd_reloc_undefined;
3403
case R_PARISC_PCREL21L:
3404
case R_PARISC_PCREL17C:
3405
case R_PARISC_PCREL17R:
3406
case R_PARISC_PCREL14R:
3407
case R_PARISC_PCREL14F:
3408
/* Make it a pc relative offset. */
3413
case R_PARISC_DPREL21L:
3414
case R_PARISC_DPREL14R:
3415
case R_PARISC_DPREL14F:
3416
/* For all the DP relative relocations, we need to examine the symbol's
3417
section. If it's a code section, then "data pointer relative" makes
3418
no sense. In that case we don't adjust the "value", and for 21 bit
3419
addil instructions, we change the source addend register from %dp to
3420
%r0. This situation commonly arises when a variable's "constness"
3421
is declared differently from the way the variable is defined. For
3422
instance: "extern int foo" with foo defined as "const int foo". */
3423
if (sym_sec == NULL)
3425
if ((sym_sec->flags & SEC_CODE) != 0)
3427
if ((insn & ((0x3f << 26) | (0x1f << 21)))
3428
== (((int) OP_ADDIL << 26) | (27 << 21)))
3430
insn &= ~ (0x1f << 21);
3431
#if 0 /* debug them. */
3432
(*_bfd_error_handler)
3433
(_("%s(%s+0x%lx): fixing %s"),
3434
bfd_archive_filename (input_bfd),
3435
input_section->name,
3436
(long) rel->r_offset,
3440
/* Now try to make things easy for the dynamic linker. */
3446
case R_PARISC_DLTIND21L:
3447
case R_PARISC_DLTIND14R:
3448
case R_PARISC_DLTIND14F:
3449
value -= elf_gp (input_section->output_section->owner);
3452
case R_PARISC_SEGREL32:
3453
if ((sym_sec->flags & SEC_CODE) != 0)
3454
value -= htab->text_segment_base;
3456
value -= htab->data_segment_base;
3465
case R_PARISC_DIR32:
3466
case R_PARISC_DIR14F:
3467
case R_PARISC_DIR17F:
3468
case R_PARISC_PCREL17C:
3469
case R_PARISC_PCREL14F:
3470
case R_PARISC_DPREL14F:
3471
case R_PARISC_PLABEL32:
3472
case R_PARISC_DLTIND14F:
3473
case R_PARISC_SEGBASE:
3474
case R_PARISC_SEGREL32:
3478
case R_PARISC_DLTIND21L:
3479
case R_PARISC_PCREL21L:
3480
case R_PARISC_PLABEL21L:
3484
case R_PARISC_DIR21L:
3485
case R_PARISC_DPREL21L:
3489
case R_PARISC_PCREL17R:
3490
case R_PARISC_PCREL14R:
3491
case R_PARISC_PLABEL14R:
3492
case R_PARISC_DLTIND14R:
3496
case R_PARISC_DIR17R:
3497
case R_PARISC_DIR14R:
3498
case R_PARISC_DPREL14R:
3502
case R_PARISC_PCREL12F:
3503
case R_PARISC_PCREL17F:
3504
case R_PARISC_PCREL22F:
3507
if (r_type == (unsigned int) R_PARISC_PCREL17F)
3509
max_branch_offset = (1 << (17-1)) << 2;
3511
else if (r_type == (unsigned int) R_PARISC_PCREL12F)
3513
max_branch_offset = (1 << (12-1)) << 2;
3517
max_branch_offset = (1 << (22-1)) << 2;
3520
/* sym_sec is NULL on undefined weak syms or when shared on
3521
undefined syms. We've already checked for a stub for the
3522
shared undefined case. */
3523
if (sym_sec == NULL)
3526
/* If the branch is out of reach, then redirect the
3527
call to the local stub for this function. */
3528
if (value + addend + max_branch_offset >= 2*max_branch_offset)
3530
stub_entry = hppa_get_stub_entry (input_section, sym_sec,
3532
if (stub_entry == NULL)
3533
return bfd_reloc_undefined;
3535
/* Munge up the value and addend so that we call the stub
3536
rather than the procedure directly. */
3537
value = (stub_entry->stub_offset
3538
+ stub_entry->stub_sec->output_offset
3539
+ stub_entry->stub_sec->output_section->vma
3545
/* Something we don't know how to handle. */
3547
return bfd_reloc_notsupported;
3550
/* Make sure we can reach the stub. */
3551
if (max_branch_offset != 0
3552
&& value + addend + max_branch_offset >= 2*max_branch_offset)
3554
(*_bfd_error_handler)
3555
(_("%s(%s+0x%lx): cannot reach %s, recompile with -ffunction-sections"),
3556
bfd_archive_filename (input_bfd),
3557
input_section->name,
3558
(long) rel->r_offset,
3559
stub_entry->root.string);
3560
bfd_set_error (bfd_error_bad_value);
3561
return bfd_reloc_notsupported;
3564
val = hppa_field_adjust (value, addend, r_field);
3568
case R_PARISC_PCREL12F:
3569
case R_PARISC_PCREL17C:
3570
case R_PARISC_PCREL17F:
3571
case R_PARISC_PCREL17R:
3572
case R_PARISC_PCREL22F:
3573
case R_PARISC_DIR17F:
3574
case R_PARISC_DIR17R:
3575
/* This is a branch. Divide the offset by four.
3576
Note that we need to decide whether it's a branch or
3577
otherwise by inspecting the reloc. Inspecting insn won't
3578
work as insn might be from a .word directive. */
3586
insn = hppa_rebuild_insn (insn, val, r_format);
3588
/* Update the instruction word. */
3589
bfd_put_32 (input_bfd, (bfd_vma) insn, hit_data);
3590
return bfd_reloc_ok;
3593
/* Relocate an HPPA ELF section. */
3596
elf32_hppa_relocate_section (output_bfd, info, input_bfd, input_section,
3597
contents, relocs, local_syms, local_sections)
3599
struct bfd_link_info *info;
3601
asection *input_section;
3603
Elf_Internal_Rela *relocs;
3604
Elf_Internal_Sym *local_syms;
3605
asection **local_sections;
3607
bfd_vma *local_got_offsets;
3608
struct elf32_hppa_link_hash_table *htab;
3609
Elf_Internal_Shdr *symtab_hdr;
3610
Elf_Internal_Rela *rel;
3611
Elf_Internal_Rela *relend;
3613
symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3615
htab = hppa_link_hash_table (info);
3616
local_got_offsets = elf_local_got_offsets (input_bfd);
3619
relend = relocs + input_section->reloc_count;
3620
for (; rel < relend; rel++)
3622
unsigned int r_type;
3623
reloc_howto_type *howto;
3624
unsigned int r_symndx;
3625
struct elf32_hppa_link_hash_entry *h;
3626
Elf_Internal_Sym *sym;
3629
bfd_reloc_status_type r;
3630
const char *sym_name;
3632
boolean warned_undef;
3634
r_type = ELF32_R_TYPE (rel->r_info);
3635
if (r_type >= (unsigned int) R_PARISC_UNIMPLEMENTED)
3637
bfd_set_error (bfd_error_bad_value);
3640
if (r_type == (unsigned int) R_PARISC_GNU_VTENTRY
3641
|| r_type == (unsigned int) R_PARISC_GNU_VTINHERIT)
3644
r_symndx = ELF32_R_SYM (rel->r_info);
3646
if (info->relocateable)
3648
/* This is a relocatable link. We don't have to change
3649
anything, unless the reloc is against a section symbol,
3650
in which case we have to adjust according to where the
3651
section symbol winds up in the output section. */
3652
if (r_symndx < symtab_hdr->sh_info)
3654
sym = local_syms + r_symndx;
3655
if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3657
sym_sec = local_sections[r_symndx];
3658
rel->r_addend += sym_sec->output_offset;
3664
/* This is a final link. */
3668
warned_undef = false;
3669
if (r_symndx < symtab_hdr->sh_info)
3671
/* This is a local symbol, h defaults to NULL. */
3672
sym = local_syms + r_symndx;
3673
sym_sec = local_sections[r_symndx];
3674
relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sym_sec, rel);
3680
/* It's a global; Find its entry in the link hash. */
3681
indx = r_symndx - symtab_hdr->sh_info;
3682
h = ((struct elf32_hppa_link_hash_entry *)
3683
elf_sym_hashes (input_bfd)[indx]);
3684
while (h->elf.root.type == bfd_link_hash_indirect
3685
|| h->elf.root.type == bfd_link_hash_warning)
3686
h = (struct elf32_hppa_link_hash_entry *) h->elf.root.u.i.link;
3689
if (h->elf.root.type == bfd_link_hash_defined
3690
|| h->elf.root.type == bfd_link_hash_defweak)
3692
sym_sec = h->elf.root.u.def.section;
3693
/* If sym_sec->output_section is NULL, then it's a
3694
symbol defined in a shared library. */
3695
if (sym_sec->output_section != NULL)
3696
relocation = (h->elf.root.u.def.value
3697
+ sym_sec->output_offset
3698
+ sym_sec->output_section->vma);
3700
else if (h->elf.root.type == bfd_link_hash_undefweak)
3702
else if (info->shared && !info->no_undefined
3703
&& ELF_ST_VISIBILITY (h->elf.other) == STV_DEFAULT
3704
&& h->elf.type != STT_PARISC_MILLI)
3706
if (info->symbolic && !info->allow_shlib_undefined)
3708
if (!((*info->callbacks->undefined_symbol)
3709
(info, h->elf.root.root.string, input_bfd,
3710
input_section, rel->r_offset, false)))
3712
warned_undef = true;
3717
if (!((*info->callbacks->undefined_symbol)
3718
(info, h->elf.root.root.string, input_bfd,
3719
input_section, rel->r_offset, true)))
3721
warned_undef = true;
3725
/* Do any required modifications to the relocation value, and
3726
determine what types of dynamic info we need to output, if
3731
case R_PARISC_DLTIND14F:
3732
case R_PARISC_DLTIND14R:
3733
case R_PARISC_DLTIND21L:
3738
/* Relocation is to the entry for this symbol in the
3739
global offset table. */
3744
off = h->elf.got.offset;
3745
dyn = htab->elf.dynamic_sections_created;
3746
if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info, &h->elf))
3748
/* If we aren't going to call finish_dynamic_symbol,
3749
then we need to handle initialisation of the .got
3750
entry and create needed relocs here. Since the
3751
offset must always be a multiple of 4, we use the
3752
least significant bit to record whether we have
3753
initialised it already. */
3758
h->elf.got.offset |= 1;
3765
/* Local symbol case. */
3766
if (local_got_offsets == NULL)
3769
off = local_got_offsets[r_symndx];
3771
/* The offset must always be a multiple of 4. We use
3772
the least significant bit to record whether we have
3773
already generated the necessary reloc. */
3778
local_got_offsets[r_symndx] |= 1;
3787
/* Output a dynamic relocation for this GOT entry.
3788
In this case it is relative to the base of the
3789
object because the symbol index is zero. */
3790
Elf_Internal_Rela outrel;
3791
asection *srelgot = htab->srelgot;
3792
Elf32_External_Rela *loc;
3794
outrel.r_offset = (off
3795
+ htab->sgot->output_offset
3796
+ htab->sgot->output_section->vma);
3797
outrel.r_info = ELF32_R_INFO (0, R_PARISC_DIR32);
3798
outrel.r_addend = relocation;
3799
loc = (Elf32_External_Rela *) srelgot->contents;
3800
loc += srelgot->reloc_count++;
3801
bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3804
bfd_put_32 (output_bfd, relocation,
3805
htab->sgot->contents + off);
3808
if (off >= (bfd_vma) -2)
3811
/* Add the base of the GOT to the relocation value. */
3813
+ htab->sgot->output_offset
3814
+ htab->sgot->output_section->vma);
3818
case R_PARISC_SEGREL32:
3819
/* If this is the first SEGREL relocation, then initialize
3820
the segment base values. */
3821
if (htab->text_segment_base == (bfd_vma) -1)
3822
bfd_map_over_sections (output_bfd, hppa_record_segment_addr, htab);
3825
case R_PARISC_PLABEL14R:
3826
case R_PARISC_PLABEL21L:
3827
case R_PARISC_PLABEL32:
3828
if (htab->elf.dynamic_sections_created)
3833
/* If we have a global symbol with a PLT slot, then
3834
redirect this relocation to it. */
3837
off = h->elf.plt.offset;
3838
if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info, &h->elf))
3840
/* In a non-shared link, adjust_dynamic_symbols
3841
isn't called for symbols forced local. We
3842
need to write out the plt entry here. */
3847
h->elf.plt.offset |= 1;
3854
bfd_vma *local_plt_offsets;
3856
if (local_got_offsets == NULL)
3859
local_plt_offsets = local_got_offsets + symtab_hdr->sh_info;
3860
off = local_plt_offsets[r_symndx];
3862
/* As for the local .got entry case, we use the last
3863
bit to record whether we've already initialised
3864
this local .plt entry. */
3869
local_plt_offsets[r_symndx] |= 1;
3878
/* Output a dynamic IPLT relocation for this
3880
Elf_Internal_Rela outrel;
3881
asection *srelplt = htab->srelplt;
3882
Elf32_External_Rela *loc;
3884
outrel.r_offset = (off
3885
+ htab->splt->output_offset
3886
+ htab->splt->output_section->vma);
3887
outrel.r_info = ELF32_R_INFO (0, R_PARISC_IPLT);
3888
outrel.r_addend = relocation;
3889
loc = (Elf32_External_Rela *) srelplt->contents;
3890
loc += srelplt->reloc_count++;
3891
bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
3895
bfd_put_32 (output_bfd,
3897
htab->splt->contents + off);
3898
bfd_put_32 (output_bfd,
3899
elf_gp (htab->splt->output_section->owner),
3900
htab->splt->contents + off + 4);
3904
if (off >= (bfd_vma) -2)
3907
/* PLABELs contain function pointers. Relocation is to
3908
the entry for the function in the .plt. The magic +2
3909
offset signals to $$dyncall that the function pointer
3910
is in the .plt and thus has a gp pointer too.
3911
Exception: Undefined PLABELs should have a value of
3914
|| (h->elf.root.type != bfd_link_hash_undefweak
3915
&& h->elf.root.type != bfd_link_hash_undefined))
3918
+ htab->splt->output_offset
3919
+ htab->splt->output_section->vma
3924
/* Fall through and possibly emit a dynamic relocation. */
3926
case R_PARISC_DIR17F:
3927
case R_PARISC_DIR17R:
3928
case R_PARISC_DIR14F:
3929
case R_PARISC_DIR14R:
3930
case R_PARISC_DIR21L:
3931
case R_PARISC_DPREL14F:
3932
case R_PARISC_DPREL14R:
3933
case R_PARISC_DPREL21L:
3934
case R_PARISC_DIR32:
3935
/* r_symndx will be zero only for relocs against symbols
3936
from removed linkonce sections, or sections discarded by
3939
|| (input_section->flags & SEC_ALLOC) == 0)
3942
/* The reloc types handled here and this conditional
3943
expression must match the code in ..check_relocs and
3944
allocate_dynrelocs. ie. We need exactly the same condition
3945
as in ..check_relocs, with some extra conditions (dynindx
3946
test in this case) to cater for relocs removed by
3947
allocate_dynrelocs. If you squint, the non-shared test
3948
here does indeed match the one in ..check_relocs, the
3949
difference being that here we test DEF_DYNAMIC as well as
3950
!DEF_REGULAR. All common syms end up with !DEF_REGULAR,
3951
which is why we can't use just that test here.
3952
Conversely, DEF_DYNAMIC can't be used in check_relocs as
3953
there all files have not been loaded. */
3955
&& (IS_ABSOLUTE_RELOC (r_type)
3957
&& h->elf.dynindx != -1
3959
|| (h->elf.elf_link_hash_flags
3960
& ELF_LINK_HASH_DEF_REGULAR) == 0))))
3963
&& h->elf.dynindx != -1
3964
&& (h->elf.elf_link_hash_flags & ELF_LINK_NON_GOT_REF) == 0
3965
&& (((h->elf.elf_link_hash_flags
3966
& ELF_LINK_HASH_DEF_DYNAMIC) != 0
3967
&& (h->elf.elf_link_hash_flags
3968
& ELF_LINK_HASH_DEF_REGULAR) == 0)
3969
|| h->elf.root.type == bfd_link_hash_undefweak
3970
|| h->elf.root.type == bfd_link_hash_undefined)))
3972
Elf_Internal_Rela outrel;
3975
Elf32_External_Rela *loc;
3977
/* When generating a shared object, these relocations
3978
are copied into the output file to be resolved at run
3981
outrel.r_addend = rel->r_addend;
3983
_bfd_elf_section_offset (output_bfd, info, input_section,
3985
skip = (outrel.r_offset == (bfd_vma) -1
3986
|| outrel.r_offset == (bfd_vma) -2);
3987
outrel.r_offset += (input_section->output_offset
3988
+ input_section->output_section->vma);
3992
memset (&outrel, 0, sizeof (outrel));
3995
&& h->elf.dynindx != -1
3997
|| !IS_ABSOLUTE_RELOC (r_type)
4000
|| (h->elf.elf_link_hash_flags
4001
& ELF_LINK_HASH_DEF_REGULAR) == 0))
4003
outrel.r_info = ELF32_R_INFO (h->elf.dynindx, r_type);
4005
else /* It's a local symbol, or one marked to become local. */
4009
/* Add the absolute offset of the symbol. */
4010
outrel.r_addend += relocation;
4012
/* Global plabels need to be processed by the
4013
dynamic linker so that functions have at most one
4014
fptr. For this reason, we need to differentiate
4015
between global and local plabels, which we do by
4016
providing the function symbol for a global plabel
4017
reloc, and no symbol for local plabels. */
4020
&& sym_sec->output_section != NULL
4021
&& ! bfd_is_abs_section (sym_sec))
4023
indx = elf_section_data (sym_sec->output_section)->dynindx;
4024
/* We are turning this relocation into one
4025
against a section symbol, so subtract out the
4026
output section's address but not the offset
4027
of the input section in the output section. */
4028
outrel.r_addend -= sym_sec->output_section->vma;
4031
outrel.r_info = ELF32_R_INFO (indx, r_type);
4034
/* EH info can cause unaligned DIR32 relocs.
4035
Tweak the reloc type for the dynamic linker. */
4036
if (r_type == R_PARISC_DIR32 && (outrel.r_offset & 3) != 0)
4037
outrel.r_info = ELF32_R_INFO (ELF32_R_SYM (outrel.r_info),
4040
sreloc = elf_section_data (input_section)->sreloc;
4044
loc = (Elf32_External_Rela *) sreloc->contents;
4045
loc += sreloc->reloc_count++;
4046
bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4054
r = final_link_relocate (input_section, contents, rel, relocation,
4057
if (r == bfd_reloc_ok)
4061
sym_name = h->elf.root.root.string;
4064
sym_name = bfd_elf_string_from_elf_section (input_bfd,
4065
symtab_hdr->sh_link,
4067
if (sym_name == NULL)
4069
if (*sym_name == '\0')
4070
sym_name = bfd_section_name (input_bfd, sym_sec);
4073
howto = elf_hppa_howto_table + r_type;
4075
if (r == bfd_reloc_undefined || r == bfd_reloc_notsupported)
4077
if (r == bfd_reloc_notsupported || !warned_undef)
4079
(*_bfd_error_handler)
4080
(_("%s(%s+0x%lx): cannot handle %s for %s"),
4081
bfd_archive_filename (input_bfd),
4082
input_section->name,
4083
(long) rel->r_offset,
4086
bfd_set_error (bfd_error_bad_value);
4092
if (!((*info->callbacks->reloc_overflow)
4093
(info, sym_name, howto->name, (bfd_vma) 0,
4094
input_bfd, input_section, rel->r_offset)))
4102
/* Finish up dynamic symbol handling. We set the contents of various
4103
dynamic sections here. */
4106
elf32_hppa_finish_dynamic_symbol (output_bfd, info, h, sym)
4108
struct bfd_link_info *info;
4109
struct elf_link_hash_entry *h;
4110
Elf_Internal_Sym *sym;
4112
struct elf32_hppa_link_hash_table *htab;
4114
htab = hppa_link_hash_table (info);
4116
if (h->plt.offset != (bfd_vma) -1)
4120
if (h->plt.offset & 1)
4123
/* This symbol has an entry in the procedure linkage table. Set
4126
The format of a plt entry is
4131
if (h->root.type == bfd_link_hash_defined
4132
|| h->root.type == bfd_link_hash_defweak)
4134
value = h->root.u.def.value;
4135
if (h->root.u.def.section->output_section != NULL)
4136
value += (h->root.u.def.section->output_offset
4137
+ h->root.u.def.section->output_section->vma);
4140
if (! ((struct elf32_hppa_link_hash_entry *) h)->pic_call)
4142
Elf_Internal_Rela rel;
4143
Elf32_External_Rela *loc;
4145
/* Create a dynamic IPLT relocation for this entry. */
4146
rel.r_offset = (h->plt.offset
4147
+ htab->splt->output_offset
4148
+ htab->splt->output_section->vma);
4149
if (h->dynindx != -1)
4151
rel.r_info = ELF32_R_INFO (h->dynindx, R_PARISC_IPLT);
4156
/* This symbol has been marked to become local, and is
4157
used by a plabel so must be kept in the .plt. */
4158
rel.r_info = ELF32_R_INFO (0, R_PARISC_IPLT);
4159
rel.r_addend = value;
4162
loc = (Elf32_External_Rela *) htab->srelplt->contents;
4163
loc += htab->srelplt->reloc_count++;
4164
bfd_elf32_swap_reloca_out (htab->splt->output_section->owner,
4169
bfd_put_32 (htab->splt->owner,
4171
htab->splt->contents + h->plt.offset);
4172
bfd_put_32 (htab->splt->owner,
4173
elf_gp (htab->splt->output_section->owner),
4174
htab->splt->contents + h->plt.offset + 4);
4177
if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4179
/* Mark the symbol as undefined, rather than as defined in
4180
the .plt section. Leave the value alone. */
4181
sym->st_shndx = SHN_UNDEF;
4185
if (h->got.offset != (bfd_vma) -1)
4187
Elf_Internal_Rela rel;
4188
Elf32_External_Rela *loc;
4190
/* This symbol has an entry in the global offset table. Set it
4193
rel.r_offset = ((h->got.offset &~ (bfd_vma) 1)
4194
+ htab->sgot->output_offset
4195
+ htab->sgot->output_section->vma);
4197
/* If this is a -Bsymbolic link and the symbol is defined
4198
locally or was forced to be local because of a version file,
4199
we just want to emit a RELATIVE reloc. The entry in the
4200
global offset table will already have been initialized in the
4201
relocate_section function. */
4203
&& (info->symbolic || h->dynindx == -1)
4204
&& (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
4206
rel.r_info = ELF32_R_INFO (0, R_PARISC_DIR32);
4207
rel.r_addend = (h->root.u.def.value
4208
+ h->root.u.def.section->output_offset
4209
+ h->root.u.def.section->output_section->vma);
4213
if ((h->got.offset & 1) != 0)
4215
bfd_put_32 (output_bfd, (bfd_vma) 0,
4216
htab->sgot->contents + h->got.offset);
4217
rel.r_info = ELF32_R_INFO (h->dynindx, R_PARISC_DIR32);
4221
loc = (Elf32_External_Rela *) htab->srelgot->contents;
4222
loc += htab->srelgot->reloc_count++;
4223
bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
4226
if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
4229
Elf_Internal_Rela rel;
4230
Elf32_External_Rela *loc;
4232
/* This symbol needs a copy reloc. Set it up. */
4234
if (! (h->dynindx != -1
4235
&& (h->root.type == bfd_link_hash_defined
4236
|| h->root.type == bfd_link_hash_defweak)))
4241
rel.r_offset = (h->root.u.def.value
4242
+ h->root.u.def.section->output_offset
4243
+ h->root.u.def.section->output_section->vma);
4245
rel.r_info = ELF32_R_INFO (h->dynindx, R_PARISC_COPY);
4246
loc = (Elf32_External_Rela *) s->contents + s->reloc_count++;
4247
bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
4250
/* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
4251
if (h->root.root.string[0] == '_'
4252
&& (strcmp (h->root.root.string, "_DYNAMIC") == 0
4253
|| strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0))
4255
sym->st_shndx = SHN_ABS;
4261
/* Used to decide how to sort relocs in an optimal manner for the
4262
dynamic linker, before writing them out. */
4264
static enum elf_reloc_type_class
4265
elf32_hppa_reloc_type_class (rela)
4266
const Elf_Internal_Rela *rela;
4268
if (ELF32_R_SYM (rela->r_info) == 0)
4269
return reloc_class_relative;
4271
switch ((int) ELF32_R_TYPE (rela->r_info))
4274
return reloc_class_plt;
4276
return reloc_class_copy;
4278
return reloc_class_normal;
4282
/* Finish up the dynamic sections. */
4285
elf32_hppa_finish_dynamic_sections (output_bfd, info)
4287
struct bfd_link_info *info;
4290
struct elf32_hppa_link_hash_table *htab;
4293
htab = hppa_link_hash_table (info);
4294
dynobj = htab->elf.dynobj;
4296
sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4298
if (htab->elf.dynamic_sections_created)
4300
Elf32_External_Dyn *dyncon, *dynconend;
4305
dyncon = (Elf32_External_Dyn *) sdyn->contents;
4306
dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
4307
for (; dyncon < dynconend; dyncon++)
4309
Elf_Internal_Dyn dyn;
4312
bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4320
/* Use PLTGOT to set the GOT register. */
4321
dyn.d_un.d_ptr = elf_gp (output_bfd);
4326
dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
4331
if (s->_cooked_size != 0)
4332
dyn.d_un.d_val = s->_cooked_size;
4334
dyn.d_un.d_val = s->_raw_size;
4338
/* Don't count procedure linkage table relocs in the
4339
overall reloc count. */
4340
if (htab->srelplt != NULL)
4342
s = htab->srelplt->output_section;
4343
if (s->_cooked_size != 0)
4344
dyn.d_un.d_val -= s->_cooked_size;
4346
dyn.d_un.d_val -= s->_raw_size;
4351
bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4355
if (htab->sgot != NULL && htab->sgot->_raw_size != 0)
4357
/* Fill in the first entry in the global offset table.
4358
We use it to point to our dynamic section, if we have one. */
4359
bfd_put_32 (output_bfd,
4361
? sdyn->output_section->vma + sdyn->output_offset
4363
htab->sgot->contents);
4365
/* The second entry is reserved for use by the dynamic linker. */
4366
memset (htab->sgot->contents + GOT_ENTRY_SIZE, 0, GOT_ENTRY_SIZE);
4368
/* Set .got entry size. */
4369
elf_section_data (htab->sgot->output_section)
4370
->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
4373
if (htab->splt != NULL && htab->splt->_raw_size != 0)
4375
/* Set plt entry size. */
4376
elf_section_data (htab->splt->output_section)
4377
->this_hdr.sh_entsize = PLT_ENTRY_SIZE;
4379
if (htab->need_plt_stub)
4381
/* Set up the .plt stub. */
4382
memcpy (htab->splt->contents
4383
+ htab->splt->_raw_size - sizeof (plt_stub),
4384
plt_stub, sizeof (plt_stub));
4386
if ((htab->splt->output_offset
4387
+ htab->splt->output_section->vma
4388
+ htab->splt->_raw_size)
4389
!= (htab->sgot->output_offset
4390
+ htab->sgot->output_section->vma))
4392
(*_bfd_error_handler)
4393
(_(".got section not immediately after .plt section"));
4402
/* Tweak the OSABI field of the elf header. */
4405
elf32_hppa_post_process_headers (abfd, link_info)
4407
struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
4409
Elf_Internal_Ehdr * i_ehdrp;
4411
i_ehdrp = elf_elfheader (abfd);
4413
if (strcmp (bfd_get_target (abfd), "elf32-hppa-linux") == 0)
4415
i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_LINUX;
4419
i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_HPUX;
4423
/* Called when writing out an object file to decide the type of a
4426
elf32_hppa_elf_get_symbol_type (elf_sym, type)
4427
Elf_Internal_Sym *elf_sym;
4430
if (ELF_ST_TYPE (elf_sym->st_info) == STT_PARISC_MILLI)
4431
return STT_PARISC_MILLI;
4436
/* Misc BFD support code. */
4437
#define bfd_elf32_bfd_is_local_label_name elf_hppa_is_local_label_name
4438
#define bfd_elf32_bfd_reloc_type_lookup elf_hppa_reloc_type_lookup
4439
#define elf_info_to_howto elf_hppa_info_to_howto
4440
#define elf_info_to_howto_rel elf_hppa_info_to_howto_rel
4442
/* Stuff for the BFD linker. */
4443
#define bfd_elf32_bfd_final_link elf32_hppa_final_link
4444
#define bfd_elf32_bfd_link_hash_table_create elf32_hppa_link_hash_table_create
4445
#define bfd_elf32_bfd_link_hash_table_free elf32_hppa_link_hash_table_free
4446
#define elf_backend_add_symbol_hook elf32_hppa_add_symbol_hook
4447
#define elf_backend_adjust_dynamic_symbol elf32_hppa_adjust_dynamic_symbol
4448
#define elf_backend_copy_indirect_symbol elf32_hppa_copy_indirect_symbol
4449
#define elf_backend_check_relocs elf32_hppa_check_relocs
4450
#define elf_backend_create_dynamic_sections elf32_hppa_create_dynamic_sections
4451
#define elf_backend_fake_sections elf_hppa_fake_sections
4452
#define elf_backend_relocate_section elf32_hppa_relocate_section
4453
#define elf_backend_hide_symbol elf32_hppa_hide_symbol
4454
#define elf_backend_finish_dynamic_symbol elf32_hppa_finish_dynamic_symbol
4455
#define elf_backend_finish_dynamic_sections elf32_hppa_finish_dynamic_sections
4456
#define elf_backend_size_dynamic_sections elf32_hppa_size_dynamic_sections
4457
#define elf_backend_gc_mark_hook elf32_hppa_gc_mark_hook
4458
#define elf_backend_gc_sweep_hook elf32_hppa_gc_sweep_hook
4459
#define elf_backend_object_p elf32_hppa_object_p
4460
#define elf_backend_final_write_processing elf_hppa_final_write_processing
4461
#define elf_backend_post_process_headers elf32_hppa_post_process_headers
4462
#define elf_backend_get_symbol_type elf32_hppa_elf_get_symbol_type
4463
#define elf_backend_reloc_type_class elf32_hppa_reloc_type_class
4465
#define elf_backend_can_gc_sections 1
4466
#define elf_backend_can_refcount 1
4467
#define elf_backend_plt_alignment 2
4468
#define elf_backend_want_got_plt 0
4469
#define elf_backend_plt_readonly 0
4470
#define elf_backend_want_plt_sym 0
4471
#define elf_backend_got_header_size 8
4473
#define TARGET_BIG_SYM bfd_elf32_hppa_vec
4474
#define TARGET_BIG_NAME "elf32-hppa"
4475
#define ELF_ARCH bfd_arch_hppa
4476
#define ELF_MACHINE_CODE EM_PARISC
4477
#define ELF_MAXPAGESIZE 0x1000
4479
#include "elf32-target.h"
4481
#undef TARGET_BIG_SYM
4482
#define TARGET_BIG_SYM bfd_elf32_hppa_linux_vec
4483
#undef TARGET_BIG_NAME
4484
#define TARGET_BIG_NAME "elf32-hppa-linux"
4486
#define INCLUDED_TARGET_FILE 1
4487
#include "elf32-target.h"
added
removed
binutils/bfd/elf32-hppa.c
