1 /* IA-64 support for 64-bit ELF
2 Copyright (C) 1998-2016 Free Software Foundation, Inc.
3 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
26 #include "opcode/ia64.h"
30 #include "bfd_stdint.h"
31 #include "elfxx-ia64.h"
36 #define LOG_SECTION_ALIGN 3
40 #define LOG_SECTION_ALIGN 2
43 typedef struct bfd_hash_entry
*(*new_hash_entry_func
)
44 (struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *);
46 /* In dynamically (linker-) created sections, we generally need to keep track
47 of the place a symbol or expression got allocated to. This is done via hash
48 tables that store entries of the following type. */
50 struct elfNN_ia64_dyn_sym_info
52 /* The addend for which this entry is relevant. */
57 bfd_vma pltoff_offset
;
61 bfd_vma dtpmod_offset
;
62 bfd_vma dtprel_offset
;
64 /* The symbol table entry, if any, that this was derived from. */
65 struct elf_link_hash_entry
*h
;
67 /* Used to count non-got, non-plt relocations for delayed sizing
68 of relocation sections. */
69 struct elfNN_ia64_dyn_reloc_entry
71 struct elfNN_ia64_dyn_reloc_entry
*next
;
76 /* Is this reloc against readonly section? */
80 /* TRUE when the section contents have been updated. */
81 unsigned got_done
: 1;
82 unsigned fptr_done
: 1;
83 unsigned pltoff_done
: 1;
84 unsigned tprel_done
: 1;
85 unsigned dtpmod_done
: 1;
86 unsigned dtprel_done
: 1;
88 /* TRUE for the different kinds of linker data we want created. */
89 unsigned want_got
: 1;
90 unsigned want_gotx
: 1;
91 unsigned want_fptr
: 1;
92 unsigned want_ltoff_fptr
: 1;
93 unsigned want_plt
: 1;
94 unsigned want_plt2
: 1;
95 unsigned want_pltoff
: 1;
96 unsigned want_tprel
: 1;
97 unsigned want_dtpmod
: 1;
98 unsigned want_dtprel
: 1;
101 struct elfNN_ia64_local_hash_entry
105 /* The number of elements in elfNN_ia64_dyn_sym_info array. */
107 /* The number of sorted elements in elfNN_ia64_dyn_sym_info array. */
108 unsigned int sorted_count
;
109 /* The size of elfNN_ia64_dyn_sym_info array. */
111 /* The array of elfNN_ia64_dyn_sym_info. */
112 struct elfNN_ia64_dyn_sym_info
*info
;
114 /* TRUE if this hash entry's addends was translated for
115 SHF_MERGE optimization. */
116 unsigned sec_merge_done
: 1;
119 struct elfNN_ia64_link_hash_entry
121 struct elf_link_hash_entry root
;
122 /* The number of elements in elfNN_ia64_dyn_sym_info array. */
124 /* The number of sorted elements in elfNN_ia64_dyn_sym_info array. */
125 unsigned int sorted_count
;
126 /* The size of elfNN_ia64_dyn_sym_info array. */
128 /* The array of elfNN_ia64_dyn_sym_info. */
129 struct elfNN_ia64_dyn_sym_info
*info
;
132 struct elfNN_ia64_link_hash_table
134 /* The main hash table. */
135 struct elf_link_hash_table root
;
137 asection
*fptr_sec
; /* Function descriptor table (or NULL). */
138 asection
*rel_fptr_sec
; /* Dynamic relocation section for same. */
139 asection
*pltoff_sec
; /* Private descriptors for plt (or NULL). */
140 asection
*rel_pltoff_sec
; /* Dynamic relocation section for same. */
142 bfd_size_type minplt_entries
; /* Number of minplt entries. */
143 unsigned reltext
: 1; /* Are there relocs against readonly sections? */
144 unsigned self_dtpmod_done
: 1;/* Has self DTPMOD entry been finished? */
145 bfd_vma self_dtpmod_offset
; /* .got offset to self DTPMOD entry. */
146 /* There are maybe R_IA64_GPREL22 relocations, including those
147 optimized from R_IA64_LTOFF22X, against non-SHF_IA_64_SHORT
148 sections. We need to record those sections so that we can choose
149 a proper GP to cover all R_IA64_GPREL22 relocations. */
150 asection
*max_short_sec
; /* Maximum short output section. */
151 bfd_vma max_short_offset
; /* Maximum short offset. */
152 asection
*min_short_sec
; /* Minimum short output section. */
153 bfd_vma min_short_offset
; /* Minimum short offset. */
155 htab_t loc_hash_table
;
156 void *loc_hash_memory
;
159 struct elfNN_ia64_allocate_data
161 struct bfd_link_info
*info
;
163 bfd_boolean only_got
;
166 #define elfNN_ia64_hash_table(p) \
167 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
168 == IA64_ELF_DATA ? ((struct elfNN_ia64_link_hash_table *) ((p)->hash)) : NULL)
170 static struct elfNN_ia64_dyn_sym_info
* get_dyn_sym_info
171 (struct elfNN_ia64_link_hash_table
*ia64_info
,
172 struct elf_link_hash_entry
*h
,
173 bfd
*abfd
, const Elf_Internal_Rela
*rel
, bfd_boolean create
);
174 static bfd_boolean elfNN_ia64_dynamic_symbol_p
175 (struct elf_link_hash_entry
*h
, struct bfd_link_info
*info
, int);
176 static bfd_boolean elfNN_ia64_choose_gp
177 (bfd
*abfd
, struct bfd_link_info
*info
, bfd_boolean final
);
178 static void elfNN_ia64_dyn_sym_traverse
179 (struct elfNN_ia64_link_hash_table
*ia64_info
,
180 bfd_boolean (*func
) (struct elfNN_ia64_dyn_sym_info
*, void *),
182 static bfd_boolean allocate_global_data_got
183 (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
);
184 static bfd_boolean allocate_global_fptr_got
185 (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
);
186 static bfd_boolean allocate_local_got
187 (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
);
188 static bfd_boolean elfNN_ia64_hpux_vec
189 (const bfd_target
*vec
);
190 static bfd_boolean allocate_dynrel_entries
191 (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
);
192 static asection
*get_pltoff
193 (bfd
*abfd
, struct bfd_link_info
*info
,
194 struct elfNN_ia64_link_hash_table
*ia64_info
);
196 /* ia64-specific relocation. */
198 /* Given a ELF reloc, return the matching HOWTO structure. */
201 elfNN_ia64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
203 Elf_Internal_Rela
*elf_reloc
)
206 = ia64_elf_lookup_howto ((unsigned int) ELFNN_R_TYPE (elf_reloc
->r_info
));
209 #define PLT_HEADER_SIZE (3 * 16)
210 #define PLT_MIN_ENTRY_SIZE (1 * 16)
211 #define PLT_FULL_ENTRY_SIZE (2 * 16)
212 #define PLT_RESERVED_WORDS 3
214 static const bfd_byte plt_header
[PLT_HEADER_SIZE
] =
216 0x0b, 0x10, 0x00, 0x1c, 0x00, 0x21, /* [MMI] mov r2=r14;; */
217 0xe0, 0x00, 0x08, 0x00, 0x48, 0x00, /* addl r14=0,r2 */
218 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
219 0x0b, 0x80, 0x20, 0x1c, 0x18, 0x14, /* [MMI] ld8 r16=[r14],8;; */
220 0x10, 0x41, 0x38, 0x30, 0x28, 0x00, /* ld8 r17=[r14],8 */
221 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
222 0x11, 0x08, 0x00, 0x1c, 0x18, 0x10, /* [MIB] ld8 r1=[r14] */
223 0x60, 0x88, 0x04, 0x80, 0x03, 0x00, /* mov b6=r17 */
224 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
227 static const bfd_byte plt_min_entry
[PLT_MIN_ENTRY_SIZE
] =
229 0x11, 0x78, 0x00, 0x00, 0x00, 0x24, /* [MIB] mov r15=0 */
230 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, /* nop.i 0x0 */
231 0x00, 0x00, 0x00, 0x40 /* br.few 0 <PLT0>;; */
234 static const bfd_byte plt_full_entry
[PLT_FULL_ENTRY_SIZE
] =
236 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
237 0x00, 0x41, 0x3c, 0x70, 0x29, 0xc0, /* ld8.acq r16=[r15],8*/
238 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
239 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
240 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
241 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
244 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
246 static const bfd_byte oor_brl
[16] =
248 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
249 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;; */
250 0x00, 0x00, 0x00, 0xc0
253 static const bfd_byte oor_ip
[48] =
255 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
256 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, /* movl r15=0 */
257 0x01, 0x00, 0x00, 0x60,
258 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MII] nop.m 0 */
259 0x00, 0x01, 0x00, 0x60, 0x00, 0x00, /* mov r16=ip;; */
260 0xf2, 0x80, 0x00, 0x80, /* add r16=r15,r16;; */
261 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MIB] nop.m 0 */
262 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
263 0x60, 0x00, 0x80, 0x00 /* br b6;; */
266 static size_t oor_branch_size
= sizeof (oor_brl
);
269 bfd_elfNN_ia64_after_parse (int itanium
)
271 oor_branch_size
= itanium
? sizeof (oor_ip
) : sizeof (oor_brl
);
275 /* Rename some of the generic section flags to better document how they
277 #define skip_relax_pass_0 sec_flg0
278 #define skip_relax_pass_1 sec_flg1
280 /* These functions do relaxation for IA-64 ELF. */
283 elfNN_ia64_update_short_info (asection
*sec
, bfd_vma offset
,
284 struct elfNN_ia64_link_hash_table
*ia64_info
)
286 /* Skip ABS and SHF_IA_64_SHORT sections. */
287 if (sec
== bfd_abs_section_ptr
288 || (sec
->flags
& SEC_SMALL_DATA
) != 0)
291 if (!ia64_info
->min_short_sec
)
293 ia64_info
->max_short_sec
= sec
;
294 ia64_info
->max_short_offset
= offset
;
295 ia64_info
->min_short_sec
= sec
;
296 ia64_info
->min_short_offset
= offset
;
298 else if (sec
== ia64_info
->max_short_sec
299 && offset
> ia64_info
->max_short_offset
)
300 ia64_info
->max_short_offset
= offset
;
301 else if (sec
== ia64_info
->min_short_sec
302 && offset
< ia64_info
->min_short_offset
)
303 ia64_info
->min_short_offset
= offset
;
304 else if (sec
->output_section
->vma
305 > ia64_info
->max_short_sec
->vma
)
307 ia64_info
->max_short_sec
= sec
;
308 ia64_info
->max_short_offset
= offset
;
310 else if (sec
->output_section
->vma
311 < ia64_info
->min_short_sec
->vma
)
313 ia64_info
->min_short_sec
= sec
;
314 ia64_info
->min_short_offset
= offset
;
319 elfNN_ia64_relax_section (bfd
*abfd
, asection
*sec
,
320 struct bfd_link_info
*link_info
,
325 struct one_fixup
*next
;
331 Elf_Internal_Shdr
*symtab_hdr
;
332 Elf_Internal_Rela
*internal_relocs
;
333 Elf_Internal_Rela
*irel
, *irelend
;
335 Elf_Internal_Sym
*isymbuf
= NULL
;
336 struct elfNN_ia64_link_hash_table
*ia64_info
;
337 struct one_fixup
*fixups
= NULL
;
338 bfd_boolean changed_contents
= FALSE
;
339 bfd_boolean changed_relocs
= FALSE
;
340 bfd_boolean changed_got
= FALSE
;
341 bfd_boolean skip_relax_pass_0
= TRUE
;
342 bfd_boolean skip_relax_pass_1
= TRUE
;
345 /* Assume we're not going to change any sizes, and we'll only need
349 if (bfd_link_relocatable (link_info
))
350 (*link_info
->callbacks
->einfo
)
351 (_("%P%F: --relax and -r may not be used together\n"));
353 /* Don't even try to relax for non-ELF outputs. */
354 if (!is_elf_hash_table (link_info
->hash
))
357 /* Nothing to do if there are no relocations or there is no need for
359 if ((sec
->flags
& SEC_RELOC
) == 0
360 || sec
->reloc_count
== 0
361 || (link_info
->relax_pass
== 0 && sec
->skip_relax_pass_0
)
362 || (link_info
->relax_pass
== 1 && sec
->skip_relax_pass_1
))
365 ia64_info
= elfNN_ia64_hash_table (link_info
);
366 if (ia64_info
== NULL
)
369 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
371 /* Load the relocations for this section. */
372 internal_relocs
= (_bfd_elf_link_read_relocs
373 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
374 link_info
->keep_memory
));
375 if (internal_relocs
== NULL
)
378 irelend
= internal_relocs
+ sec
->reloc_count
;
380 /* Get the section contents. */
381 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
382 contents
= elf_section_data (sec
)->this_hdr
.contents
;
385 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
389 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
391 unsigned long r_type
= ELFNN_R_TYPE (irel
->r_info
);
392 bfd_vma symaddr
, reladdr
, trampoff
, toff
, roff
;
396 bfd_boolean is_branch
;
397 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
402 case R_IA64_PCREL21B
:
403 case R_IA64_PCREL21BI
:
404 case R_IA64_PCREL21M
:
405 case R_IA64_PCREL21F
:
406 /* In pass 1, all br relaxations are done. We can skip it. */
407 if (link_info
->relax_pass
== 1)
409 skip_relax_pass_0
= FALSE
;
413 case R_IA64_PCREL60B
:
414 /* We can't optimize brl to br in pass 0 since br relaxations
415 will increase the code size. Defer it to pass 1. */
416 if (link_info
->relax_pass
== 0)
418 skip_relax_pass_1
= FALSE
;
425 /* Update max_short_sec/min_short_sec. */
427 case R_IA64_LTOFF22X
:
429 /* We can't relax ldx/mov in pass 0 since br relaxations will
430 increase the code size. Defer it to pass 1. */
431 if (link_info
->relax_pass
== 0)
433 skip_relax_pass_1
= FALSE
;
443 /* Get the value of the symbol referred to by the reloc. */
444 if (ELFNN_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
446 /* A local symbol. */
447 Elf_Internal_Sym
*isym
;
449 /* Read this BFD's local symbols. */
452 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
454 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
455 symtab_hdr
->sh_info
, 0,
461 isym
= isymbuf
+ ELFNN_R_SYM (irel
->r_info
);
462 if (isym
->st_shndx
== SHN_UNDEF
)
463 continue; /* We can't do anything with undefined symbols. */
464 else if (isym
->st_shndx
== SHN_ABS
)
465 tsec
= bfd_abs_section_ptr
;
466 else if (isym
->st_shndx
== SHN_COMMON
)
467 tsec
= bfd_com_section_ptr
;
468 else if (isym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
469 tsec
= bfd_com_section_ptr
;
471 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
473 toff
= isym
->st_value
;
474 dyn_i
= get_dyn_sym_info (ia64_info
, NULL
, abfd
, irel
, FALSE
);
475 symtype
= ELF_ST_TYPE (isym
->st_info
);
480 struct elf_link_hash_entry
*h
;
482 indx
= ELFNN_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
483 h
= elf_sym_hashes (abfd
)[indx
];
484 BFD_ASSERT (h
!= NULL
);
486 while (h
->root
.type
== bfd_link_hash_indirect
487 || h
->root
.type
== bfd_link_hash_warning
)
488 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
490 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, irel
, FALSE
);
492 /* For branches to dynamic symbols, we're interested instead
493 in a branch to the PLT entry. */
494 if (is_branch
&& dyn_i
&& dyn_i
->want_plt2
)
496 /* Internal branches shouldn't be sent to the PLT.
497 Leave this for now and we'll give an error later. */
498 if (r_type
!= R_IA64_PCREL21B
)
501 tsec
= ia64_info
->root
.splt
;
502 toff
= dyn_i
->plt2_offset
;
503 BFD_ASSERT (irel
->r_addend
== 0);
506 /* Can't do anything else with dynamic symbols. */
507 else if (elfNN_ia64_dynamic_symbol_p (h
, link_info
, r_type
))
512 /* We can't do anything with undefined symbols. */
513 if (h
->root
.type
== bfd_link_hash_undefined
514 || h
->root
.type
== bfd_link_hash_undefweak
)
517 tsec
= h
->root
.u
.def
.section
;
518 toff
= h
->root
.u
.def
.value
;
524 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
526 /* At this stage in linking, no SEC_MERGE symbol has been
527 adjusted, so all references to such symbols need to be
528 passed through _bfd_merged_section_offset. (Later, in
529 relocate_section, all SEC_MERGE symbols *except* for
530 section symbols have been adjusted.)
532 gas may reduce relocations against symbols in SEC_MERGE
533 sections to a relocation against the section symbol when
534 the original addend was zero. When the reloc is against
535 a section symbol we should include the addend in the
536 offset passed to _bfd_merged_section_offset, since the
537 location of interest is the original symbol. On the
538 other hand, an access to "sym+addend" where "sym" is not
539 a section symbol should not include the addend; Such an
540 access is presumed to be an offset from "sym"; The
541 location of interest is just "sym". */
542 if (symtype
== STT_SECTION
)
543 toff
+= irel
->r_addend
;
545 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
546 elf_section_data (tsec
)->sec_info
,
549 if (symtype
!= STT_SECTION
)
550 toff
+= irel
->r_addend
;
553 toff
+= irel
->r_addend
;
555 symaddr
= tsec
->output_section
->vma
+ tsec
->output_offset
+ toff
;
557 roff
= irel
->r_offset
;
561 bfd_signed_vma offset
;
563 reladdr
= (sec
->output_section
->vma
565 + roff
) & (bfd_vma
) -4;
567 /* The .plt section is aligned at 32byte and the .text section
568 is aligned at 64byte. The .text section is right after the
569 .plt section. After the first relaxation pass, linker may
570 increase the gap between the .plt and .text sections up
571 to 32byte. We assume linker will always insert 32byte
572 between the .plt and .text sections after the first
574 if (tsec
== ia64_info
->root
.splt
)
575 offset
= -0x1000000 + 32;
579 /* If the branch is in range, no need to do anything. */
580 if ((bfd_signed_vma
) (symaddr
- reladdr
) >= offset
581 && (bfd_signed_vma
) (symaddr
- reladdr
) <= 0x0FFFFF0)
583 /* If the 60-bit branch is in 21-bit range, optimize it. */
584 if (r_type
== R_IA64_PCREL60B
)
586 ia64_elf_relax_brl (contents
, roff
);
589 = ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
592 /* If the original relocation offset points to slot
593 1, change it to slot 2. */
594 if ((irel
->r_offset
& 3) == 1)
600 else if (r_type
== R_IA64_PCREL60B
)
602 else if (ia64_elf_relax_br (contents
, roff
))
605 = ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
608 /* Make the relocation offset point to slot 1. */
609 irel
->r_offset
= (irel
->r_offset
& ~((bfd_vma
) 0x3)) + 1;
613 /* We can't put a trampoline in a .init/.fini section. Issue
615 if (strcmp (sec
->output_section
->name
, ".init") == 0
616 || strcmp (sec
->output_section
->name
, ".fini") == 0)
619 /* xgettext:c-format */
620 (_("%B: Can't relax br at 0x%lx in section `%A'. Please use brl or indirect branch."),
621 sec
->owner
, sec
, (unsigned long) roff
);
622 bfd_set_error (bfd_error_bad_value
);
626 /* If the branch and target are in the same section, you've
627 got one honking big section and we can't help you unless
628 you are branching backwards. You'll get an error message
630 if (tsec
== sec
&& toff
> roff
)
633 /* Look for an existing fixup to this address. */
634 for (f
= fixups
; f
; f
= f
->next
)
635 if (f
->tsec
== tsec
&& f
->toff
== toff
)
640 /* Two alternatives: If it's a branch to a PLT entry, we can
641 make a copy of the FULL_PLT entry. Otherwise, we'll have
642 to use a `brl' insn to get where we're going. */
646 if (tsec
== ia64_info
->root
.splt
)
647 size
= sizeof (plt_full_entry
);
649 size
= oor_branch_size
;
651 /* Resize the current section to make room for the new branch. */
652 trampoff
= (sec
->size
+ 15) & (bfd_vma
) -16;
654 /* If trampoline is out of range, there is nothing we
656 offset
= trampoff
- (roff
& (bfd_vma
) -4);
657 if (offset
< -0x1000000 || offset
> 0x0FFFFF0)
660 amt
= trampoff
+ size
;
661 contents
= (bfd_byte
*) bfd_realloc (contents
, amt
);
662 if (contents
== NULL
)
666 if (tsec
== ia64_info
->root
.splt
)
668 memcpy (contents
+ trampoff
, plt_full_entry
, size
);
670 /* Hijack the old relocation for use as the PLTOFF reloc. */
671 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
673 irel
->r_offset
= trampoff
;
677 if (size
== sizeof (oor_ip
))
679 memcpy (contents
+ trampoff
, oor_ip
, size
);
680 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
682 irel
->r_addend
-= 16;
683 irel
->r_offset
= trampoff
+ 2;
687 memcpy (contents
+ trampoff
, oor_brl
, size
);
688 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
690 irel
->r_offset
= trampoff
+ 2;
695 /* Record the fixup so we don't do it again this section. */
696 f
= (struct one_fixup
*)
697 bfd_malloc ((bfd_size_type
) sizeof (*f
));
701 f
->trampoff
= trampoff
;
706 /* If trampoline is out of range, there is nothing we
708 offset
= f
->trampoff
- (roff
& (bfd_vma
) -4);
709 if (offset
< -0x1000000 || offset
> 0x0FFFFF0)
712 /* Nop out the reloc, since we're finalizing things here. */
713 irel
->r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
716 /* Fix up the existing branch to hit the trampoline. */
717 if (ia64_elf_install_value (contents
+ roff
, offset
, r_type
)
721 changed_contents
= TRUE
;
722 changed_relocs
= TRUE
;
729 bfd
*obfd
= sec
->output_section
->owner
;
730 gp
= _bfd_get_gp_value (obfd
);
733 if (!elfNN_ia64_choose_gp (obfd
, link_info
, FALSE
))
735 gp
= _bfd_get_gp_value (obfd
);
739 /* If the data is out of range, do nothing. */
740 if ((bfd_signed_vma
) (symaddr
- gp
) >= 0x200000
741 ||(bfd_signed_vma
) (symaddr
- gp
) < -0x200000)
744 if (r_type
== R_IA64_GPREL22
)
745 elfNN_ia64_update_short_info (tsec
->output_section
,
746 tsec
->output_offset
+ toff
,
748 else if (r_type
== R_IA64_LTOFF22X
)
750 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
752 changed_relocs
= TRUE
;
753 if (dyn_i
->want_gotx
)
755 dyn_i
->want_gotx
= 0;
756 changed_got
|= !dyn_i
->want_got
;
759 elfNN_ia64_update_short_info (tsec
->output_section
,
760 tsec
->output_offset
+ toff
,
765 ia64_elf_relax_ldxmov (contents
, roff
);
766 irel
->r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
767 changed_contents
= TRUE
;
768 changed_relocs
= TRUE
;
773 /* ??? If we created fixups, this may push the code segment large
774 enough that the data segment moves, which will change the GP.
775 Reset the GP so that we re-calculate next round. We need to
776 do this at the _beginning_ of the next round; now will not do. */
778 /* Clean up and go home. */
781 struct one_fixup
*f
= fixups
;
782 fixups
= fixups
->next
;
787 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
789 if (! link_info
->keep_memory
)
793 /* Cache the symbols for elf_link_input_bfd. */
794 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
799 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
801 if (!changed_contents
&& !link_info
->keep_memory
)
805 /* Cache the section contents for elf_link_input_bfd. */
806 elf_section_data (sec
)->this_hdr
.contents
= contents
;
810 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
813 free (internal_relocs
);
815 elf_section_data (sec
)->relocs
= internal_relocs
;
820 struct elfNN_ia64_allocate_data data
;
821 data
.info
= link_info
;
823 ia64_info
->self_dtpmod_offset
= (bfd_vma
) -1;
825 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_data_got
, &data
);
826 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_fptr_got
, &data
);
827 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_local_got
, &data
);
828 ia64_info
->root
.sgot
->size
= data
.ofs
;
830 if (ia64_info
->root
.dynamic_sections_created
831 && ia64_info
->root
.srelgot
!= NULL
)
833 /* Resize .rela.got. */
834 ia64_info
->root
.srelgot
->size
= 0;
835 if (bfd_link_pic (link_info
)
836 && ia64_info
->self_dtpmod_offset
!= (bfd_vma
) -1)
837 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
838 data
.only_got
= TRUE
;
839 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_dynrel_entries
,
844 if (link_info
->relax_pass
== 0)
846 /* Pass 0 is only needed to relax br. */
847 sec
->skip_relax_pass_0
= skip_relax_pass_0
;
848 sec
->skip_relax_pass_1
= skip_relax_pass_1
;
851 *again
= changed_contents
|| changed_relocs
;
855 if (isymbuf
!= NULL
&& (unsigned char *) isymbuf
!= symtab_hdr
->contents
)
858 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
860 if (internal_relocs
!= NULL
861 && elf_section_data (sec
)->relocs
!= internal_relocs
)
862 free (internal_relocs
);
865 #undef skip_relax_pass_0
866 #undef skip_relax_pass_1
868 /* Return TRUE if NAME is an unwind table section name. */
870 static inline bfd_boolean
871 is_unwind_section_name (bfd
*abfd
, const char *name
)
873 if (elfNN_ia64_hpux_vec (abfd
->xvec
)
874 && !strcmp (name
, ELF_STRING_ia64_unwind_hdr
))
877 return ((CONST_STRNEQ (name
, ELF_STRING_ia64_unwind
)
878 && ! CONST_STRNEQ (name
, ELF_STRING_ia64_unwind_info
))
879 || CONST_STRNEQ (name
, ELF_STRING_ia64_unwind_once
));
882 /* Handle an IA-64 specific section when reading an object file. This
883 is called when bfd_section_from_shdr finds a section with an unknown
887 elfNN_ia64_section_from_shdr (bfd
*abfd
,
888 Elf_Internal_Shdr
*hdr
,
892 /* There ought to be a place to keep ELF backend specific flags, but
893 at the moment there isn't one. We just keep track of the
894 sections by their name, instead. Fortunately, the ABI gives
895 suggested names for all the MIPS specific sections, so we will
896 probably get away with this. */
897 switch (hdr
->sh_type
)
899 case SHT_IA_64_UNWIND
:
900 case SHT_IA_64_HP_OPT_ANOT
:
904 if (strcmp (name
, ELF_STRING_ia64_archext
) != 0)
912 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
918 /* Convert IA-64 specific section flags to bfd internal section flags. */
920 /* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
924 elfNN_ia64_section_flags (flagword
*flags
,
925 const Elf_Internal_Shdr
*hdr
)
927 if (hdr
->sh_flags
& SHF_IA_64_SHORT
)
928 *flags
|= SEC_SMALL_DATA
;
933 /* Set the correct type for an IA-64 ELF section. We do this by the
934 section name, which is a hack, but ought to work. */
937 elfNN_ia64_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
942 name
= bfd_get_section_name (abfd
, sec
);
944 if (is_unwind_section_name (abfd
, name
))
946 /* We don't have the sections numbered at this point, so sh_info
947 is set later, in elfNN_ia64_final_write_processing. */
948 hdr
->sh_type
= SHT_IA_64_UNWIND
;
949 hdr
->sh_flags
|= SHF_LINK_ORDER
;
951 else if (strcmp (name
, ELF_STRING_ia64_archext
) == 0)
952 hdr
->sh_type
= SHT_IA_64_EXT
;
953 else if (strcmp (name
, ".HP.opt_annot") == 0)
954 hdr
->sh_type
= SHT_IA_64_HP_OPT_ANOT
;
955 else if (strcmp (name
, ".reloc") == 0)
956 /* This is an ugly, but unfortunately necessary hack that is
957 needed when producing EFI binaries on IA-64. It tells
958 elf.c:elf_fake_sections() not to consider ".reloc" as a section
959 containing ELF relocation info. We need this hack in order to
960 be able to generate ELF binaries that can be translated into
961 EFI applications (which are essentially COFF objects). Those
962 files contain a COFF ".reloc" section inside an ELFNN object,
963 which would normally cause BFD to segfault because it would
964 attempt to interpret this section as containing relocation
965 entries for section "oc". With this hack enabled, ".reloc"
966 will be treated as a normal data section, which will avoid the
967 segfault. However, you won't be able to create an ELFNN binary
968 with a section named "oc" that needs relocations, but that's
969 the kind of ugly side-effects you get when detecting section
970 types based on their names... In practice, this limitation is
972 hdr
->sh_type
= SHT_PROGBITS
;
974 if (sec
->flags
& SEC_SMALL_DATA
)
975 hdr
->sh_flags
|= SHF_IA_64_SHORT
;
977 /* Some HP linkers look for the SHF_IA_64_HP_TLS flag instead of SHF_TLS. */
979 if (elfNN_ia64_hpux_vec (abfd
->xvec
) && (sec
->flags
& SHF_TLS
))
980 hdr
->sh_flags
|= SHF_IA_64_HP_TLS
;
985 /* The final processing done just before writing out an IA-64 ELF
989 elfNN_ia64_final_write_processing (bfd
*abfd
,
990 bfd_boolean linker ATTRIBUTE_UNUSED
)
992 Elf_Internal_Shdr
*hdr
;
995 for (s
= abfd
->sections
; s
; s
= s
->next
)
997 hdr
= &elf_section_data (s
)->this_hdr
;
998 switch (hdr
->sh_type
)
1000 case SHT_IA_64_UNWIND
:
1001 /* The IA-64 processor-specific ABI requires setting sh_link
1002 to the unwind section, whereas HP-UX requires sh_info to
1003 do so. For maximum compatibility, we'll set both for
1005 hdr
->sh_info
= hdr
->sh_link
;
1010 if (! elf_flags_init (abfd
))
1012 unsigned long flags
= 0;
1014 if (abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
)
1015 flags
|= EF_IA_64_BE
;
1016 if (bfd_get_mach (abfd
) == bfd_mach_ia64_elf64
)
1017 flags
|= EF_IA_64_ABI64
;
1019 elf_elfheader(abfd
)->e_flags
= flags
;
1020 elf_flags_init (abfd
) = TRUE
;
1024 /* Hook called by the linker routine which adds symbols from an object
1025 file. We use it to put .comm items in .sbss, and not .bss. */
1028 elfNN_ia64_add_symbol_hook (bfd
*abfd
,
1029 struct bfd_link_info
*info
,
1030 Elf_Internal_Sym
*sym
,
1031 const char **namep ATTRIBUTE_UNUSED
,
1032 flagword
*flagsp ATTRIBUTE_UNUSED
,
1036 if (sym
->st_shndx
== SHN_COMMON
1037 && !bfd_link_relocatable (info
)
1038 && sym
->st_size
<= elf_gp_size (abfd
))
1040 /* Common symbols less than or equal to -G nn bytes are
1041 automatically put into .sbss. */
1043 asection
*scomm
= bfd_get_section_by_name (abfd
, ".scommon");
1047 scomm
= bfd_make_section_with_flags (abfd
, ".scommon",
1050 | SEC_LINKER_CREATED
));
1056 *valp
= sym
->st_size
;
1062 /* Return the number of additional phdrs we will need. */
1065 elfNN_ia64_additional_program_headers (bfd
*abfd
,
1066 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1071 /* See if we need a PT_IA_64_ARCHEXT segment. */
1072 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_archext
);
1073 if (s
&& (s
->flags
& SEC_LOAD
))
1076 /* Count how many PT_IA_64_UNWIND segments we need. */
1077 for (s
= abfd
->sections
; s
; s
= s
->next
)
1078 if (is_unwind_section_name (abfd
, s
->name
) && (s
->flags
& SEC_LOAD
))
1085 elfNN_ia64_modify_segment_map (bfd
*abfd
,
1086 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1088 struct elf_segment_map
*m
, **pm
;
1089 Elf_Internal_Shdr
*hdr
;
1092 /* If we need a PT_IA_64_ARCHEXT segment, it must come before
1093 all PT_LOAD segments. */
1094 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_archext
);
1095 if (s
&& (s
->flags
& SEC_LOAD
))
1097 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
1098 if (m
->p_type
== PT_IA_64_ARCHEXT
)
1102 m
= ((struct elf_segment_map
*)
1103 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *m
));
1107 m
->p_type
= PT_IA_64_ARCHEXT
;
1111 /* We want to put it after the PHDR and INTERP segments. */
1112 pm
= &elf_seg_map (abfd
);
1114 && ((*pm
)->p_type
== PT_PHDR
1115 || (*pm
)->p_type
== PT_INTERP
))
1123 /* Install PT_IA_64_UNWIND segments, if needed. */
1124 for (s
= abfd
->sections
; s
; s
= s
->next
)
1126 hdr
= &elf_section_data (s
)->this_hdr
;
1127 if (hdr
->sh_type
!= SHT_IA_64_UNWIND
)
1130 if (s
&& (s
->flags
& SEC_LOAD
))
1132 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
1133 if (m
->p_type
== PT_IA_64_UNWIND
)
1137 /* Look through all sections in the unwind segment
1138 for a match since there may be multiple sections
1140 for (i
= m
->count
- 1; i
>= 0; --i
)
1141 if (m
->sections
[i
] == s
)
1150 m
= ((struct elf_segment_map
*)
1151 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *m
));
1155 m
->p_type
= PT_IA_64_UNWIND
;
1160 /* We want to put it last. */
1161 pm
= &elf_seg_map (abfd
);
1172 /* Turn on PF_IA_64_NORECOV if needed. This involves traversing all of
1173 the input sections for each output section in the segment and testing
1174 for SHF_IA_64_NORECOV on each. */
1177 elfNN_ia64_modify_program_headers (bfd
*abfd
,
1178 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1180 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
1181 struct elf_segment_map
*m
;
1182 Elf_Internal_Phdr
*p
;
1184 for (p
= tdata
->phdr
, m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
, p
++)
1185 if (m
->p_type
== PT_LOAD
)
1188 for (i
= m
->count
- 1; i
>= 0; --i
)
1190 struct bfd_link_order
*order
= m
->sections
[i
]->map_head
.link_order
;
1192 while (order
!= NULL
)
1194 if (order
->type
== bfd_indirect_link_order
)
1196 asection
*is
= order
->u
.indirect
.section
;
1197 bfd_vma flags
= elf_section_data(is
)->this_hdr
.sh_flags
;
1198 if (flags
& SHF_IA_64_NORECOV
)
1200 p
->p_flags
|= PF_IA_64_NORECOV
;
1204 order
= order
->next
;
1213 /* According to the Tahoe assembler spec, all labels starting with a
1217 elfNN_ia64_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
1220 return name
[0] == '.';
1223 /* Should we do dynamic things to this symbol? */
1226 elfNN_ia64_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
1227 struct bfd_link_info
*info
, int r_type
)
1229 bfd_boolean ignore_protected
1230 = ((r_type
& 0xf8) == 0x40 /* FPTR relocs */
1231 || (r_type
& 0xf8) == 0x50); /* LTOFF_FPTR relocs */
1233 return _bfd_elf_dynamic_symbol_p (h
, info
, ignore_protected
);
1236 static struct bfd_hash_entry
*
1237 elfNN_ia64_new_elf_hash_entry (struct bfd_hash_entry
*entry
,
1238 struct bfd_hash_table
*table
,
1241 struct elfNN_ia64_link_hash_entry
*ret
;
1242 ret
= (struct elfNN_ia64_link_hash_entry
*) entry
;
1244 /* Allocate the structure if it has not already been allocated by a
1247 ret
= bfd_hash_allocate (table
, sizeof (*ret
));
1252 /* Call the allocation method of the superclass. */
1253 ret
= ((struct elfNN_ia64_link_hash_entry
*)
1254 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
1259 ret
->sorted_count
= 0;
1261 return (struct bfd_hash_entry
*) ret
;
1265 elfNN_ia64_hash_copy_indirect (struct bfd_link_info
*info
,
1266 struct elf_link_hash_entry
*xdir
,
1267 struct elf_link_hash_entry
*xind
)
1269 struct elfNN_ia64_link_hash_entry
*dir
, *ind
;
1271 dir
= (struct elfNN_ia64_link_hash_entry
*) xdir
;
1272 ind
= (struct elfNN_ia64_link_hash_entry
*) xind
;
1274 /* Copy down any references that we may have already seen to the
1275 symbol which just became indirect. */
1277 dir
->root
.ref_dynamic
|= ind
->root
.ref_dynamic
;
1278 dir
->root
.ref_regular
|= ind
->root
.ref_regular
;
1279 dir
->root
.ref_regular_nonweak
|= ind
->root
.ref_regular_nonweak
;
1280 dir
->root
.needs_plt
|= ind
->root
.needs_plt
;
1282 if (ind
->root
.root
.type
!= bfd_link_hash_indirect
)
1285 /* Copy over the got and plt data. This would have been done
1288 if (ind
->info
!= NULL
)
1290 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1296 dir
->info
= ind
->info
;
1297 dir
->count
= ind
->count
;
1298 dir
->sorted_count
= ind
->sorted_count
;
1299 dir
->size
= ind
->size
;
1303 ind
->sorted_count
= 0;
1306 /* Fix up the dyn_sym_info pointers to the global symbol. */
1307 for (count
= dir
->count
, dyn_i
= dir
->info
;
1310 dyn_i
->h
= &dir
->root
;
1313 /* Copy over the dynindx. */
1315 if (ind
->root
.dynindx
!= -1)
1317 if (dir
->root
.dynindx
!= -1)
1318 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1319 dir
->root
.dynstr_index
);
1320 dir
->root
.dynindx
= ind
->root
.dynindx
;
1321 dir
->root
.dynstr_index
= ind
->root
.dynstr_index
;
1322 ind
->root
.dynindx
= -1;
1323 ind
->root
.dynstr_index
= 0;
1328 elfNN_ia64_hash_hide_symbol (struct bfd_link_info
*info
,
1329 struct elf_link_hash_entry
*xh
,
1330 bfd_boolean force_local
)
1332 struct elfNN_ia64_link_hash_entry
*h
;
1333 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1336 h
= (struct elfNN_ia64_link_hash_entry
*)xh
;
1338 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
1340 for (count
= h
->count
, dyn_i
= h
->info
;
1344 dyn_i
->want_plt2
= 0;
1345 dyn_i
->want_plt
= 0;
1349 /* Compute a hash of a local hash entry. */
1352 elfNN_ia64_local_htab_hash (const void *ptr
)
1354 struct elfNN_ia64_local_hash_entry
*entry
1355 = (struct elfNN_ia64_local_hash_entry
*) ptr
;
1357 return ELF_LOCAL_SYMBOL_HASH (entry
->id
, entry
->r_sym
);
1360 /* Compare local hash entries. */
1363 elfNN_ia64_local_htab_eq (const void *ptr1
, const void *ptr2
)
1365 struct elfNN_ia64_local_hash_entry
*entry1
1366 = (struct elfNN_ia64_local_hash_entry
*) ptr1
;
1367 struct elfNN_ia64_local_hash_entry
*entry2
1368 = (struct elfNN_ia64_local_hash_entry
*) ptr2
;
1370 return entry1
->id
== entry2
->id
&& entry1
->r_sym
== entry2
->r_sym
;
1373 /* Free the global elfNN_ia64_dyn_sym_info array. */
1376 elfNN_ia64_global_dyn_info_free (void **xentry
,
1377 void * unused ATTRIBUTE_UNUSED
)
1379 struct elfNN_ia64_link_hash_entry
*entry
1380 = (struct elfNN_ia64_link_hash_entry
*) xentry
;
1387 entry
->sorted_count
= 0;
1394 /* Free the local elfNN_ia64_dyn_sym_info array. */
1397 elfNN_ia64_local_dyn_info_free (void **slot
,
1398 void * unused ATTRIBUTE_UNUSED
)
1400 struct elfNN_ia64_local_hash_entry
*entry
1401 = (struct elfNN_ia64_local_hash_entry
*) *slot
;
1408 entry
->sorted_count
= 0;
1415 /* Destroy IA-64 linker hash table. */
1418 elfNN_ia64_link_hash_table_free (bfd
*obfd
)
1420 struct elfNN_ia64_link_hash_table
*ia64_info
1421 = (struct elfNN_ia64_link_hash_table
*) obfd
->link
.hash
;
1422 if (ia64_info
->loc_hash_table
)
1424 htab_traverse (ia64_info
->loc_hash_table
,
1425 elfNN_ia64_local_dyn_info_free
, NULL
);
1426 htab_delete (ia64_info
->loc_hash_table
);
1428 if (ia64_info
->loc_hash_memory
)
1429 objalloc_free ((struct objalloc
*) ia64_info
->loc_hash_memory
);
1430 elf_link_hash_traverse (&ia64_info
->root
,
1431 elfNN_ia64_global_dyn_info_free
, NULL
);
1432 _bfd_elf_link_hash_table_free (obfd
);
1435 /* Create the derived linker hash table. The IA-64 ELF port uses this
1436 derived hash table to keep information specific to the IA-64 ElF
1437 linker (without using static variables). */
1439 static struct bfd_link_hash_table
*
1440 elfNN_ia64_hash_table_create (bfd
*abfd
)
1442 struct elfNN_ia64_link_hash_table
*ret
;
1444 ret
= bfd_zmalloc ((bfd_size_type
) sizeof (*ret
));
1448 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
1449 elfNN_ia64_new_elf_hash_entry
,
1450 sizeof (struct elfNN_ia64_link_hash_entry
),
1457 ret
->loc_hash_table
= htab_try_create (1024, elfNN_ia64_local_htab_hash
,
1458 elfNN_ia64_local_htab_eq
, NULL
);
1459 ret
->loc_hash_memory
= objalloc_create ();
1460 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1462 elfNN_ia64_link_hash_table_free (abfd
);
1465 ret
->root
.root
.hash_table_free
= elfNN_ia64_link_hash_table_free
;
1467 return &ret
->root
.root
;
1470 /* Traverse both local and global hash tables. */
1472 struct elfNN_ia64_dyn_sym_traverse_data
1474 bfd_boolean (*func
) (struct elfNN_ia64_dyn_sym_info
*, void *);
1479 elfNN_ia64_global_dyn_sym_thunk (struct bfd_hash_entry
*xentry
,
1482 struct elfNN_ia64_link_hash_entry
*entry
1483 = (struct elfNN_ia64_link_hash_entry
*) xentry
;
1484 struct elfNN_ia64_dyn_sym_traverse_data
*data
1485 = (struct elfNN_ia64_dyn_sym_traverse_data
*) xdata
;
1486 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1489 for (count
= entry
->count
, dyn_i
= entry
->info
;
1492 if (! (*data
->func
) (dyn_i
, data
->data
))
1498 elfNN_ia64_local_dyn_sym_thunk (void **slot
, void * xdata
)
1500 struct elfNN_ia64_local_hash_entry
*entry
1501 = (struct elfNN_ia64_local_hash_entry
*) *slot
;
1502 struct elfNN_ia64_dyn_sym_traverse_data
*data
1503 = (struct elfNN_ia64_dyn_sym_traverse_data
*) xdata
;
1504 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1507 for (count
= entry
->count
, dyn_i
= entry
->info
;
1510 if (! (*data
->func
) (dyn_i
, data
->data
))
1516 elfNN_ia64_dyn_sym_traverse (struct elfNN_ia64_link_hash_table
*ia64_info
,
1517 bfd_boolean (*func
) (struct elfNN_ia64_dyn_sym_info
*, void *),
1520 struct elfNN_ia64_dyn_sym_traverse_data xdata
;
1525 elf_link_hash_traverse (&ia64_info
->root
,
1526 elfNN_ia64_global_dyn_sym_thunk
, &xdata
);
1527 htab_traverse (ia64_info
->loc_hash_table
,
1528 elfNN_ia64_local_dyn_sym_thunk
, &xdata
);
1532 elfNN_ia64_create_dynamic_sections (bfd
*abfd
,
1533 struct bfd_link_info
*info
)
1535 struct elfNN_ia64_link_hash_table
*ia64_info
;
1538 if (! _bfd_elf_create_dynamic_sections (abfd
, info
))
1541 ia64_info
= elfNN_ia64_hash_table (info
);
1542 if (ia64_info
== NULL
)
1546 flagword flags
= bfd_get_section_flags (abfd
, ia64_info
->root
.sgot
);
1547 bfd_set_section_flags (abfd
, ia64_info
->root
.sgot
,
1548 SEC_SMALL_DATA
| flags
);
1549 /* The .got section is always aligned at 8 bytes. */
1550 if (! bfd_set_section_alignment (abfd
, ia64_info
->root
.sgot
, 3))
1554 if (!get_pltoff (abfd
, info
, ia64_info
))
1557 s
= bfd_make_section_anyway_with_flags (abfd
, ".rela.IA_64.pltoff",
1558 (SEC_ALLOC
| SEC_LOAD
1561 | SEC_LINKER_CREATED
1564 || !bfd_set_section_alignment (abfd
, s
, LOG_SECTION_ALIGN
))
1566 ia64_info
->rel_pltoff_sec
= s
;
1571 /* Find and/or create a hash entry for local symbol. */
1572 static struct elfNN_ia64_local_hash_entry
*
1573 get_local_sym_hash (struct elfNN_ia64_link_hash_table
*ia64_info
,
1574 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
1577 struct elfNN_ia64_local_hash_entry e
, *ret
;
1578 asection
*sec
= abfd
->sections
;
1579 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
1580 ELFNN_R_SYM (rel
->r_info
));
1584 e
.r_sym
= ELFNN_R_SYM (rel
->r_info
);
1585 slot
= htab_find_slot_with_hash (ia64_info
->loc_hash_table
, &e
, h
,
1586 create
? INSERT
: NO_INSERT
);
1592 return (struct elfNN_ia64_local_hash_entry
*) *slot
;
1594 ret
= (struct elfNN_ia64_local_hash_entry
*)
1595 objalloc_alloc ((struct objalloc
*) ia64_info
->loc_hash_memory
,
1596 sizeof (struct elfNN_ia64_local_hash_entry
));
1599 memset (ret
, 0, sizeof (*ret
));
1601 ret
->r_sym
= ELFNN_R_SYM (rel
->r_info
);
1607 /* Used to sort elfNN_ia64_dyn_sym_info array. */
1610 addend_compare (const void *xp
, const void *yp
)
1612 const struct elfNN_ia64_dyn_sym_info
*x
1613 = (const struct elfNN_ia64_dyn_sym_info
*) xp
;
1614 const struct elfNN_ia64_dyn_sym_info
*y
1615 = (const struct elfNN_ia64_dyn_sym_info
*) yp
;
1617 return x
->addend
< y
->addend
? -1 : x
->addend
> y
->addend
? 1 : 0;
1620 /* Sort elfNN_ia64_dyn_sym_info array and remove duplicates. */
1623 sort_dyn_sym_info (struct elfNN_ia64_dyn_sym_info
*info
,
1626 bfd_vma curr
, prev
, got_offset
;
1627 unsigned int i
, kept
, dupes
, diff
, dest
, src
, len
;
1629 qsort (info
, count
, sizeof (*info
), addend_compare
);
1631 /* Find the first duplicate. */
1632 prev
= info
[0].addend
;
1633 got_offset
= info
[0].got_offset
;
1634 for (i
= 1; i
< count
; i
++)
1636 curr
= info
[i
].addend
;
1639 /* For duplicates, make sure that GOT_OFFSET is valid. */
1640 if (got_offset
== (bfd_vma
) -1)
1641 got_offset
= info
[i
].got_offset
;
1644 got_offset
= info
[i
].got_offset
;
1648 /* We may move a block of elements to here. */
1651 /* Remove duplicates. */
1656 /* For duplicates, make sure that the kept one has a valid
1659 if (got_offset
!= (bfd_vma
) -1)
1660 info
[kept
].got_offset
= got_offset
;
1662 curr
= info
[i
].addend
;
1663 got_offset
= info
[i
].got_offset
;
1665 /* Move a block of elements whose first one is different from
1669 for (src
= i
+ 1; src
< count
; src
++)
1671 if (info
[src
].addend
!= curr
)
1673 /* For duplicates, make sure that GOT_OFFSET is
1675 if (got_offset
== (bfd_vma
) -1)
1676 got_offset
= info
[src
].got_offset
;
1679 /* Make sure that the kept one has a valid got_offset. */
1680 if (got_offset
!= (bfd_vma
) -1)
1681 info
[kept
].got_offset
= got_offset
;
1689 /* Find the next duplicate. SRC will be kept. */
1690 prev
= info
[src
].addend
;
1691 got_offset
= info
[src
].got_offset
;
1692 for (dupes
= src
+ 1; dupes
< count
; dupes
++)
1694 curr
= info
[dupes
].addend
;
1697 /* Make sure that got_offset is valid. */
1698 if (got_offset
== (bfd_vma
) -1)
1699 got_offset
= info
[dupes
].got_offset
;
1701 /* For duplicates, make sure that the kept one has
1702 a valid got_offset. */
1703 if (got_offset
!= (bfd_vma
) -1)
1704 info
[dupes
- 1].got_offset
= got_offset
;
1707 got_offset
= info
[dupes
].got_offset
;
1711 /* How much to move. */
1715 if (len
== 1 && dupes
< count
)
1717 /* If we only move 1 element, we combine it with the next
1718 one. There must be at least a duplicate. Find the
1719 next different one. */
1720 for (diff
= dupes
+ 1, src
++; diff
< count
; diff
++, src
++)
1722 if (info
[diff
].addend
!= curr
)
1724 /* Make sure that got_offset is valid. */
1725 if (got_offset
== (bfd_vma
) -1)
1726 got_offset
= info
[diff
].got_offset
;
1729 /* Makre sure that the last duplicated one has an valid
1731 BFD_ASSERT (curr
== prev
);
1732 if (got_offset
!= (bfd_vma
) -1)
1733 info
[diff
- 1].got_offset
= got_offset
;
1737 /* Find the next duplicate. Track the current valid
1739 prev
= info
[diff
].addend
;
1740 got_offset
= info
[diff
].got_offset
;
1741 for (dupes
= diff
+ 1; dupes
< count
; dupes
++)
1743 curr
= info
[dupes
].addend
;
1746 /* For duplicates, make sure that GOT_OFFSET
1748 if (got_offset
== (bfd_vma
) -1)
1749 got_offset
= info
[dupes
].got_offset
;
1752 got_offset
= info
[dupes
].got_offset
;
1757 len
= diff
- src
+ 1;
1762 memmove (&info
[dest
], &info
[src
], len
* sizeof (*info
));
1771 /* When we get here, either there is no duplicate at all or
1772 the only duplicate is the last element. */
1775 /* If the last element is a duplicate, make sure that the
1776 kept one has a valid got_offset. We also update count. */
1777 if (got_offset
!= (bfd_vma
) -1)
1778 info
[dest
- 1].got_offset
= got_offset
;
1786 /* Find and/or create a descriptor for dynamic symbol info. This will
1787 vary based on global or local symbol, and the addend to the reloc.
1789 We don't sort when inserting. Also, we sort and eliminate
1790 duplicates if there is an unsorted section. Typically, this will
1791 only happen once, because we do all insertions before lookups. We
1792 then use bsearch to do a lookup. This also allows lookups to be
1793 fast. So we have fast insertion (O(log N) due to duplicate check),
1794 fast lookup (O(log N)) and one sort (O(N log N) expected time).
1795 Previously, all lookups were O(N) because of the use of the linked
1796 list and also all insertions were O(N) because of the check for
1797 duplicates. There are some complications here because the array
1798 size grows occasionally, which may add an O(N) factor, but this
1799 should be rare. Also, we free the excess array allocation, which
1800 requires a copy which is O(N), but this only happens once. */
1802 static struct elfNN_ia64_dyn_sym_info
*
1803 get_dyn_sym_info (struct elfNN_ia64_link_hash_table
*ia64_info
,
1804 struct elf_link_hash_entry
*h
, bfd
*abfd
,
1805 const Elf_Internal_Rela
*rel
, bfd_boolean create
)
1807 struct elfNN_ia64_dyn_sym_info
**info_p
, *info
, *dyn_i
, key
;
1808 unsigned int *count_p
, *sorted_count_p
, *size_p
;
1809 unsigned int count
, sorted_count
, size
;
1810 bfd_vma addend
= rel
? rel
->r_addend
: 0;
1815 struct elfNN_ia64_link_hash_entry
*global_h
;
1817 global_h
= (struct elfNN_ia64_link_hash_entry
*) h
;
1818 info_p
= &global_h
->info
;
1819 count_p
= &global_h
->count
;
1820 sorted_count_p
= &global_h
->sorted_count
;
1821 size_p
= &global_h
->size
;
1825 struct elfNN_ia64_local_hash_entry
*loc_h
;
1827 loc_h
= get_local_sym_hash (ia64_info
, abfd
, rel
, create
);
1830 BFD_ASSERT (!create
);
1834 info_p
= &loc_h
->info
;
1835 count_p
= &loc_h
->count
;
1836 sorted_count_p
= &loc_h
->sorted_count
;
1837 size_p
= &loc_h
->size
;
1841 sorted_count
= *sorted_count_p
;
1846 /* When we create the array, we don't check for duplicates,
1847 except in the previously sorted section if one exists, and
1848 against the last inserted entry. This allows insertions to
1854 /* Try bsearch first on the sorted section. */
1855 key
.addend
= addend
;
1856 dyn_i
= bsearch (&key
, info
, sorted_count
,
1857 sizeof (*info
), addend_compare
);
1865 /* Do a quick check for the last inserted entry. */
1866 dyn_i
= info
+ count
- 1;
1867 if (dyn_i
->addend
== addend
)
1875 /* It is the very first element. We create the array of size
1878 amt
= size
* sizeof (*info
);
1879 info
= bfd_malloc (amt
);
1881 else if (size
<= count
)
1883 /* We double the array size every time when we reach the
1886 amt
= size
* sizeof (*info
);
1887 info
= bfd_realloc (info
, amt
);
1898 /* Append the new one to the array. */
1899 dyn_i
= info
+ count
;
1900 memset (dyn_i
, 0, sizeof (*dyn_i
));
1901 dyn_i
->got_offset
= (bfd_vma
) -1;
1902 dyn_i
->addend
= addend
;
1904 /* We increment count only since the new ones are unsorted and
1905 may have duplicate. */
1910 /* It is a lookup without insertion. Sort array if part of the
1911 array isn't sorted. */
1912 if (count
!= sorted_count
)
1914 count
= sort_dyn_sym_info (info
, count
);
1916 *sorted_count_p
= count
;
1919 /* Free unused memory. */
1922 amt
= count
* sizeof (*info
);
1923 info
= bfd_malloc (amt
);
1926 memcpy (info
, *info_p
, amt
);
1933 key
.addend
= addend
;
1934 dyn_i
= bsearch (&key
, info
, count
,
1935 sizeof (*info
), addend_compare
);
1942 get_got (bfd
*abfd
, struct bfd_link_info
*info
,
1943 struct elfNN_ia64_link_hash_table
*ia64_info
)
1948 got
= ia64_info
->root
.sgot
;
1953 dynobj
= ia64_info
->root
.dynobj
;
1955 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1956 if (!_bfd_elf_create_got_section (dynobj
, info
))
1959 got
= ia64_info
->root
.sgot
;
1961 /* The .got section is always aligned at 8 bytes. */
1962 if (!bfd_set_section_alignment (abfd
, got
, 3))
1965 flags
= bfd_get_section_flags (abfd
, got
);
1966 if (! bfd_set_section_flags (abfd
, got
, SEC_SMALL_DATA
| flags
))
1973 /* Create function descriptor section (.opd). This section is called .opd
1974 because it contains "official procedure descriptors". The "official"
1975 refers to the fact that these descriptors are used when taking the address
1976 of a procedure, thus ensuring a unique address for each procedure. */
1979 get_fptr (bfd
*abfd
, struct bfd_link_info
*info
,
1980 struct elfNN_ia64_link_hash_table
*ia64_info
)
1985 fptr
= ia64_info
->fptr_sec
;
1988 dynobj
= ia64_info
->root
.dynobj
;
1990 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1992 fptr
= bfd_make_section_anyway_with_flags (dynobj
, ".opd",
1997 | (bfd_link_pie (info
)
1999 | SEC_LINKER_CREATED
));
2001 || !bfd_set_section_alignment (abfd
, fptr
, 4))
2007 ia64_info
->fptr_sec
= fptr
;
2009 if (bfd_link_pie (info
))
2012 fptr_rel
= bfd_make_section_anyway_with_flags (dynobj
, ".rela.opd",
2013 (SEC_ALLOC
| SEC_LOAD
2016 | SEC_LINKER_CREATED
2018 if (fptr_rel
== NULL
2019 || !bfd_set_section_alignment (abfd
, fptr_rel
,
2026 ia64_info
->rel_fptr_sec
= fptr_rel
;
2034 get_pltoff (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2035 struct elfNN_ia64_link_hash_table
*ia64_info
)
2040 pltoff
= ia64_info
->pltoff_sec
;
2043 dynobj
= ia64_info
->root
.dynobj
;
2045 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2047 pltoff
= bfd_make_section_anyway_with_flags (dynobj
,
2048 ELF_STRING_ia64_pltoff
,
2054 | SEC_LINKER_CREATED
));
2056 || !bfd_set_section_alignment (abfd
, pltoff
, 4))
2062 ia64_info
->pltoff_sec
= pltoff
;
2069 get_reloc_section (bfd
*abfd
,
2070 struct elfNN_ia64_link_hash_table
*ia64_info
,
2071 asection
*sec
, bfd_boolean create
)
2073 const char *srel_name
;
2077 srel_name
= (bfd_elf_string_from_elf_section
2078 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
2079 _bfd_elf_single_rel_hdr (sec
)->sh_name
));
2080 if (srel_name
== NULL
)
2083 dynobj
= ia64_info
->root
.dynobj
;
2085 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2087 srel
= bfd_get_linker_section (dynobj
, srel_name
);
2088 if (srel
== NULL
&& create
)
2090 srel
= bfd_make_section_anyway_with_flags (dynobj
, srel_name
,
2091 (SEC_ALLOC
| SEC_LOAD
2094 | SEC_LINKER_CREATED
2097 || !bfd_set_section_alignment (dynobj
, srel
,
2106 count_dyn_reloc (bfd
*abfd
, struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2107 asection
*srel
, int type
, bfd_boolean reltext
)
2109 struct elfNN_ia64_dyn_reloc_entry
*rent
;
2111 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2112 if (rent
->srel
== srel
&& rent
->type
== type
)
2117 rent
= ((struct elfNN_ia64_dyn_reloc_entry
*)
2118 bfd_alloc (abfd
, (bfd_size_type
) sizeof (*rent
)));
2122 rent
->next
= dyn_i
->reloc_entries
;
2126 dyn_i
->reloc_entries
= rent
;
2128 rent
->reltext
= reltext
;
2135 elfNN_ia64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
2137 const Elf_Internal_Rela
*relocs
)
2139 struct elfNN_ia64_link_hash_table
*ia64_info
;
2140 const Elf_Internal_Rela
*relend
;
2141 Elf_Internal_Shdr
*symtab_hdr
;
2142 const Elf_Internal_Rela
*rel
;
2143 asection
*got
, *fptr
, *srel
, *pltoff
;
2152 NEED_LTOFF_FPTR
= 128,
2158 struct elf_link_hash_entry
*h
;
2159 unsigned long r_symndx
;
2160 bfd_boolean maybe_dynamic
;
2162 if (bfd_link_relocatable (info
))
2165 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2166 ia64_info
= elfNN_ia64_hash_table (info
);
2167 if (ia64_info
== NULL
)
2170 got
= fptr
= srel
= pltoff
= NULL
;
2172 relend
= relocs
+ sec
->reloc_count
;
2174 /* We scan relocations first to create dynamic relocation arrays. We
2175 modified get_dyn_sym_info to allow fast insertion and support fast
2176 lookup in the next loop. */
2177 for (rel
= relocs
; rel
< relend
; ++rel
)
2179 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
2180 if (r_symndx
>= symtab_hdr
->sh_info
)
2182 long indx
= r_symndx
- symtab_hdr
->sh_info
;
2183 h
= elf_sym_hashes (abfd
)[indx
];
2184 while (h
->root
.type
== bfd_link_hash_indirect
2185 || h
->root
.type
== bfd_link_hash_warning
)
2186 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2191 /* We can only get preliminary data on whether a symbol is
2192 locally or externally defined, as not all of the input files
2193 have yet been processed. Do something with what we know, as
2194 this may help reduce memory usage and processing time later. */
2195 maybe_dynamic
= (h
&& ((!bfd_link_executable (info
)
2196 && (!SYMBOLIC_BIND (info
, h
)
2197 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
2199 || h
->root
.type
== bfd_link_hash_defweak
));
2202 switch (ELFNN_R_TYPE (rel
->r_info
))
2204 case R_IA64_TPREL64MSB
:
2205 case R_IA64_TPREL64LSB
:
2206 if (bfd_link_pic (info
) || maybe_dynamic
)
2207 need_entry
= NEED_DYNREL
;
2210 case R_IA64_LTOFF_TPREL22
:
2211 need_entry
= NEED_TPREL
;
2212 if (bfd_link_pic (info
))
2213 info
->flags
|= DF_STATIC_TLS
;
2216 case R_IA64_DTPREL32MSB
:
2217 case R_IA64_DTPREL32LSB
:
2218 case R_IA64_DTPREL64MSB
:
2219 case R_IA64_DTPREL64LSB
:
2220 if (bfd_link_pic (info
) || maybe_dynamic
)
2221 need_entry
= NEED_DYNREL
;
2224 case R_IA64_LTOFF_DTPREL22
:
2225 need_entry
= NEED_DTPREL
;
2228 case R_IA64_DTPMOD64MSB
:
2229 case R_IA64_DTPMOD64LSB
:
2230 if (bfd_link_pic (info
) || maybe_dynamic
)
2231 need_entry
= NEED_DYNREL
;
2234 case R_IA64_LTOFF_DTPMOD22
:
2235 need_entry
= NEED_DTPMOD
;
2238 case R_IA64_LTOFF_FPTR22
:
2239 case R_IA64_LTOFF_FPTR64I
:
2240 case R_IA64_LTOFF_FPTR32MSB
:
2241 case R_IA64_LTOFF_FPTR32LSB
:
2242 case R_IA64_LTOFF_FPTR64MSB
:
2243 case R_IA64_LTOFF_FPTR64LSB
:
2244 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
2247 case R_IA64_FPTR64I
:
2248 case R_IA64_FPTR32MSB
:
2249 case R_IA64_FPTR32LSB
:
2250 case R_IA64_FPTR64MSB
:
2251 case R_IA64_FPTR64LSB
:
2252 if (bfd_link_pic (info
) || h
)
2253 need_entry
= NEED_FPTR
| NEED_DYNREL
;
2255 need_entry
= NEED_FPTR
;
2258 case R_IA64_LTOFF22
:
2259 case R_IA64_LTOFF64I
:
2260 need_entry
= NEED_GOT
;
2263 case R_IA64_LTOFF22X
:
2264 need_entry
= NEED_GOTX
;
2267 case R_IA64_PLTOFF22
:
2268 case R_IA64_PLTOFF64I
:
2269 case R_IA64_PLTOFF64MSB
:
2270 case R_IA64_PLTOFF64LSB
:
2271 need_entry
= NEED_PLTOFF
;
2275 need_entry
|= NEED_MIN_PLT
;
2279 (*info
->callbacks
->warning
)
2280 (info
, _("@pltoff reloc against local symbol"), 0,
2281 abfd
, 0, (bfd_vma
) 0);
2285 case R_IA64_PCREL21B
:
2286 case R_IA64_PCREL60B
:
2287 /* Depending on where this symbol is defined, we may or may not
2288 need a full plt entry. Only skip if we know we'll not need
2289 the entry -- static or symbolic, and the symbol definition
2290 has already been seen. */
2291 if (maybe_dynamic
&& rel
->r_addend
== 0)
2292 need_entry
= NEED_FULL_PLT
;
2298 case R_IA64_DIR32MSB
:
2299 case R_IA64_DIR32LSB
:
2300 case R_IA64_DIR64MSB
:
2301 case R_IA64_DIR64LSB
:
2302 /* Shared objects will always need at least a REL relocation. */
2303 if (bfd_link_pic (info
) || maybe_dynamic
)
2304 need_entry
= NEED_DYNREL
;
2307 case R_IA64_IPLTMSB
:
2308 case R_IA64_IPLTLSB
:
2309 /* Shared objects will always need at least a REL relocation. */
2310 if (bfd_link_pic (info
) || maybe_dynamic
)
2311 need_entry
= NEED_DYNREL
;
2314 case R_IA64_PCREL22
:
2315 case R_IA64_PCREL64I
:
2316 case R_IA64_PCREL32MSB
:
2317 case R_IA64_PCREL32LSB
:
2318 case R_IA64_PCREL64MSB
:
2319 case R_IA64_PCREL64LSB
:
2321 need_entry
= NEED_DYNREL
;
2328 if ((need_entry
& NEED_FPTR
) != 0
2331 (*info
->callbacks
->warning
)
2332 (info
, _("non-zero addend in @fptr reloc"), 0,
2333 abfd
, 0, (bfd_vma
) 0);
2336 if (get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, TRUE
) == NULL
)
2340 /* Now, we only do lookup without insertion, which is very fast
2341 with the modified get_dyn_sym_info. */
2342 for (rel
= relocs
; rel
< relend
; ++rel
)
2344 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2345 int dynrel_type
= R_IA64_NONE
;
2347 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
2348 if (r_symndx
>= symtab_hdr
->sh_info
)
2350 /* We're dealing with a global symbol -- find its hash entry
2351 and mark it as being referenced. */
2352 long indx
= r_symndx
- symtab_hdr
->sh_info
;
2353 h
= elf_sym_hashes (abfd
)[indx
];
2354 while (h
->root
.type
== bfd_link_hash_indirect
2355 || h
->root
.type
== bfd_link_hash_warning
)
2356 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2358 /* PR15323, ref flags aren't set for references in the same
2360 h
->root
.non_ir_ref
= 1;
2366 /* We can only get preliminary data on whether a symbol is
2367 locally or externally defined, as not all of the input files
2368 have yet been processed. Do something with what we know, as
2369 this may help reduce memory usage and processing time later. */
2370 maybe_dynamic
= (h
&& ((!bfd_link_executable (info
)
2371 && (!SYMBOLIC_BIND (info
, h
)
2372 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
2374 || h
->root
.type
== bfd_link_hash_defweak
));
2377 switch (ELFNN_R_TYPE (rel
->r_info
))
2379 case R_IA64_TPREL64MSB
:
2380 case R_IA64_TPREL64LSB
:
2381 if (bfd_link_pic (info
) || maybe_dynamic
)
2382 need_entry
= NEED_DYNREL
;
2383 dynrel_type
= R_IA64_TPREL64LSB
;
2384 if (bfd_link_pic (info
))
2385 info
->flags
|= DF_STATIC_TLS
;
2388 case R_IA64_LTOFF_TPREL22
:
2389 need_entry
= NEED_TPREL
;
2390 if (bfd_link_pic (info
))
2391 info
->flags
|= DF_STATIC_TLS
;
2394 case R_IA64_DTPREL32MSB
:
2395 case R_IA64_DTPREL32LSB
:
2396 case R_IA64_DTPREL64MSB
:
2397 case R_IA64_DTPREL64LSB
:
2398 if (bfd_link_pic (info
) || maybe_dynamic
)
2399 need_entry
= NEED_DYNREL
;
2400 dynrel_type
= R_IA64_DTPRELNNLSB
;
2403 case R_IA64_LTOFF_DTPREL22
:
2404 need_entry
= NEED_DTPREL
;
2407 case R_IA64_DTPMOD64MSB
:
2408 case R_IA64_DTPMOD64LSB
:
2409 if (bfd_link_pic (info
) || maybe_dynamic
)
2410 need_entry
= NEED_DYNREL
;
2411 dynrel_type
= R_IA64_DTPMOD64LSB
;
2414 case R_IA64_LTOFF_DTPMOD22
:
2415 need_entry
= NEED_DTPMOD
;
2418 case R_IA64_LTOFF_FPTR22
:
2419 case R_IA64_LTOFF_FPTR64I
:
2420 case R_IA64_LTOFF_FPTR32MSB
:
2421 case R_IA64_LTOFF_FPTR32LSB
:
2422 case R_IA64_LTOFF_FPTR64MSB
:
2423 case R_IA64_LTOFF_FPTR64LSB
:
2424 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
2427 case R_IA64_FPTR64I
:
2428 case R_IA64_FPTR32MSB
:
2429 case R_IA64_FPTR32LSB
:
2430 case R_IA64_FPTR64MSB
:
2431 case R_IA64_FPTR64LSB
:
2432 if (bfd_link_pic (info
) || h
)
2433 need_entry
= NEED_FPTR
| NEED_DYNREL
;
2435 need_entry
= NEED_FPTR
;
2436 dynrel_type
= R_IA64_FPTRNNLSB
;
2439 case R_IA64_LTOFF22
:
2440 case R_IA64_LTOFF64I
:
2441 need_entry
= NEED_GOT
;
2444 case R_IA64_LTOFF22X
:
2445 need_entry
= NEED_GOTX
;
2448 case R_IA64_PLTOFF22
:
2449 case R_IA64_PLTOFF64I
:
2450 case R_IA64_PLTOFF64MSB
:
2451 case R_IA64_PLTOFF64LSB
:
2452 need_entry
= NEED_PLTOFF
;
2456 need_entry
|= NEED_MIN_PLT
;
2460 case R_IA64_PCREL21B
:
2461 case R_IA64_PCREL60B
:
2462 /* Depending on where this symbol is defined, we may or may not
2463 need a full plt entry. Only skip if we know we'll not need
2464 the entry -- static or symbolic, and the symbol definition
2465 has already been seen. */
2466 if (maybe_dynamic
&& rel
->r_addend
== 0)
2467 need_entry
= NEED_FULL_PLT
;
2473 case R_IA64_DIR32MSB
:
2474 case R_IA64_DIR32LSB
:
2475 case R_IA64_DIR64MSB
:
2476 case R_IA64_DIR64LSB
:
2477 /* Shared objects will always need at least a REL relocation. */
2478 if (bfd_link_pic (info
) || maybe_dynamic
)
2479 need_entry
= NEED_DYNREL
;
2480 dynrel_type
= R_IA64_DIRNNLSB
;
2483 case R_IA64_IPLTMSB
:
2484 case R_IA64_IPLTLSB
:
2485 /* Shared objects will always need at least a REL relocation. */
2486 if (bfd_link_pic (info
) || maybe_dynamic
)
2487 need_entry
= NEED_DYNREL
;
2488 dynrel_type
= R_IA64_IPLTLSB
;
2491 case R_IA64_PCREL22
:
2492 case R_IA64_PCREL64I
:
2493 case R_IA64_PCREL32MSB
:
2494 case R_IA64_PCREL32LSB
:
2495 case R_IA64_PCREL64MSB
:
2496 case R_IA64_PCREL64LSB
:
2498 need_entry
= NEED_DYNREL
;
2499 dynrel_type
= R_IA64_PCRELNNLSB
;
2506 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, FALSE
);
2508 /* Record whether or not this is a local symbol. */
2511 /* Create what's needed. */
2512 if (need_entry
& (NEED_GOT
| NEED_GOTX
| NEED_TPREL
2513 | NEED_DTPMOD
| NEED_DTPREL
))
2517 got
= get_got (abfd
, info
, ia64_info
);
2521 if (need_entry
& NEED_GOT
)
2522 dyn_i
->want_got
= 1;
2523 if (need_entry
& NEED_GOTX
)
2524 dyn_i
->want_gotx
= 1;
2525 if (need_entry
& NEED_TPREL
)
2526 dyn_i
->want_tprel
= 1;
2527 if (need_entry
& NEED_DTPMOD
)
2528 dyn_i
->want_dtpmod
= 1;
2529 if (need_entry
& NEED_DTPREL
)
2530 dyn_i
->want_dtprel
= 1;
2532 if (need_entry
& NEED_FPTR
)
2536 fptr
= get_fptr (abfd
, info
, ia64_info
);
2541 /* FPTRs for shared libraries are allocated by the dynamic
2542 linker. Make sure this local symbol will appear in the
2543 dynamic symbol table. */
2544 if (!h
&& bfd_link_pic (info
))
2546 if (! (bfd_elf_link_record_local_dynamic_symbol
2547 (info
, abfd
, (long) r_symndx
)))
2551 dyn_i
->want_fptr
= 1;
2553 if (need_entry
& NEED_LTOFF_FPTR
)
2554 dyn_i
->want_ltoff_fptr
= 1;
2555 if (need_entry
& (NEED_MIN_PLT
| NEED_FULL_PLT
))
2557 if (!ia64_info
->root
.dynobj
)
2558 ia64_info
->root
.dynobj
= abfd
;
2560 dyn_i
->want_plt
= 1;
2562 if (need_entry
& NEED_FULL_PLT
)
2563 dyn_i
->want_plt2
= 1;
2564 if (need_entry
& NEED_PLTOFF
)
2566 /* This is needed here, in case @pltoff is used in a non-shared
2570 pltoff
= get_pltoff (abfd
, info
, ia64_info
);
2575 dyn_i
->want_pltoff
= 1;
2577 if ((need_entry
& NEED_DYNREL
) && (sec
->flags
& SEC_ALLOC
))
2581 srel
= get_reloc_section (abfd
, ia64_info
, sec
, TRUE
);
2585 if (!count_dyn_reloc (abfd
, dyn_i
, srel
, dynrel_type
,
2586 (sec
->flags
& SEC_READONLY
) != 0))
2594 /* For cleanliness, and potentially faster dynamic loading, allocate
2595 external GOT entries first. */
2598 allocate_global_data_got (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2601 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2603 if ((dyn_i
->want_got
|| dyn_i
->want_gotx
)
2604 && ! dyn_i
->want_fptr
2605 && elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0))
2607 dyn_i
->got_offset
= x
->ofs
;
2610 if (dyn_i
->want_tprel
)
2612 dyn_i
->tprel_offset
= x
->ofs
;
2615 if (dyn_i
->want_dtpmod
)
2617 if (elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0))
2619 dyn_i
->dtpmod_offset
= x
->ofs
;
2624 struct elfNN_ia64_link_hash_table
*ia64_info
;
2626 ia64_info
= elfNN_ia64_hash_table (x
->info
);
2627 if (ia64_info
== NULL
)
2630 if (ia64_info
->self_dtpmod_offset
== (bfd_vma
) -1)
2632 ia64_info
->self_dtpmod_offset
= x
->ofs
;
2635 dyn_i
->dtpmod_offset
= ia64_info
->self_dtpmod_offset
;
2638 if (dyn_i
->want_dtprel
)
2640 dyn_i
->dtprel_offset
= x
->ofs
;
2646 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
2649 allocate_global_fptr_got (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2652 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2656 && elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, R_IA64_FPTRNNLSB
))
2658 dyn_i
->got_offset
= x
->ofs
;
2664 /* Lastly, allocate all the GOT entries for local data. */
2667 allocate_local_got (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2670 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2672 if ((dyn_i
->want_got
|| dyn_i
->want_gotx
)
2673 && !elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0))
2675 dyn_i
->got_offset
= x
->ofs
;
2681 /* Search for the index of a global symbol in it's defining object file. */
2684 global_sym_index (struct elf_link_hash_entry
*h
)
2686 struct elf_link_hash_entry
**p
;
2689 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
2690 || h
->root
.type
== bfd_link_hash_defweak
);
2692 obj
= h
->root
.u
.def
.section
->owner
;
2693 for (p
= elf_sym_hashes (obj
); *p
!= h
; ++p
)
2696 return p
- elf_sym_hashes (obj
) + elf_tdata (obj
)->symtab_hdr
.sh_info
;
2699 /* Allocate function descriptors. We can do these for every function
2700 in a main executable that is not exported. */
2703 allocate_fptr (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
)
2705 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2707 if (dyn_i
->want_fptr
)
2709 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2712 while (h
->root
.type
== bfd_link_hash_indirect
2713 || h
->root
.type
== bfd_link_hash_warning
)
2714 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2716 if (!bfd_link_executable (x
->info
)
2718 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2719 || (h
->root
.type
!= bfd_link_hash_undefweak
2720 && h
->root
.type
!= bfd_link_hash_undefined
)))
2722 if (h
&& h
->dynindx
== -1)
2724 BFD_ASSERT ((h
->root
.type
== bfd_link_hash_defined
)
2725 || (h
->root
.type
== bfd_link_hash_defweak
));
2727 if (!bfd_elf_link_record_local_dynamic_symbol
2728 (x
->info
, h
->root
.u
.def
.section
->owner
,
2729 global_sym_index (h
)))
2733 dyn_i
->want_fptr
= 0;
2735 else if (h
== NULL
|| h
->dynindx
== -1)
2737 dyn_i
->fptr_offset
= x
->ofs
;
2741 dyn_i
->want_fptr
= 0;
2746 /* Allocate all the minimal PLT entries. */
2749 allocate_plt_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2752 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2754 if (dyn_i
->want_plt
)
2756 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2759 while (h
->root
.type
== bfd_link_hash_indirect
2760 || h
->root
.type
== bfd_link_hash_warning
)
2761 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2763 /* ??? Versioned symbols seem to lose NEEDS_PLT. */
2764 if (elfNN_ia64_dynamic_symbol_p (h
, x
->info
, 0))
2766 bfd_size_type offset
= x
->ofs
;
2768 offset
= PLT_HEADER_SIZE
;
2769 dyn_i
->plt_offset
= offset
;
2770 x
->ofs
= offset
+ PLT_MIN_ENTRY_SIZE
;
2772 dyn_i
->want_pltoff
= 1;
2776 dyn_i
->want_plt
= 0;
2777 dyn_i
->want_plt2
= 0;
2783 /* Allocate all the full PLT entries. */
2786 allocate_plt2_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2789 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2791 if (dyn_i
->want_plt2
)
2793 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2794 bfd_size_type ofs
= x
->ofs
;
2796 dyn_i
->plt2_offset
= ofs
;
2797 x
->ofs
= ofs
+ PLT_FULL_ENTRY_SIZE
;
2799 while (h
->root
.type
== bfd_link_hash_indirect
2800 || h
->root
.type
== bfd_link_hash_warning
)
2801 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2802 dyn_i
->h
->plt
.offset
= ofs
;
2807 /* Allocate all the PLTOFF entries requested by relocations and
2808 plt entries. We can't share space with allocated FPTR entries,
2809 because the latter are not necessarily addressable by the GP.
2810 ??? Relaxation might be able to determine that they are. */
2813 allocate_pltoff_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2816 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2818 if (dyn_i
->want_pltoff
)
2820 dyn_i
->pltoff_offset
= x
->ofs
;
2826 /* Allocate dynamic relocations for those symbols that turned out
2830 allocate_dynrel_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2833 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2834 struct elfNN_ia64_link_hash_table
*ia64_info
;
2835 struct elfNN_ia64_dyn_reloc_entry
*rent
;
2836 bfd_boolean dynamic_symbol
, shared
, resolved_zero
;
2838 ia64_info
= elfNN_ia64_hash_table (x
->info
);
2839 if (ia64_info
== NULL
)
2842 /* Note that this can't be used in relation to FPTR relocs below. */
2843 dynamic_symbol
= elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0);
2845 shared
= bfd_link_pic (x
->info
);
2846 resolved_zero
= (dyn_i
->h
2847 && ELF_ST_VISIBILITY (dyn_i
->h
->other
)
2848 && dyn_i
->h
->root
.type
== bfd_link_hash_undefweak
);
2850 /* Take care of the GOT and PLT relocations. */
2853 && (dynamic_symbol
|| shared
)
2854 && (dyn_i
->want_got
|| dyn_i
->want_gotx
))
2855 || (dyn_i
->want_ltoff_fptr
2857 && dyn_i
->h
->dynindx
!= -1))
2859 if (!dyn_i
->want_ltoff_fptr
2860 || !bfd_link_pie (x
->info
)
2862 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
2863 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
2865 if ((dynamic_symbol
|| shared
) && dyn_i
->want_tprel
)
2866 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
2867 if (dynamic_symbol
&& dyn_i
->want_dtpmod
)
2868 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
2869 if (dynamic_symbol
&& dyn_i
->want_dtprel
)
2870 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
2875 if (ia64_info
->rel_fptr_sec
&& dyn_i
->want_fptr
)
2877 if (dyn_i
->h
== NULL
|| dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
2878 ia64_info
->rel_fptr_sec
->size
+= sizeof (ElfNN_External_Rela
);
2881 if (!resolved_zero
&& dyn_i
->want_pltoff
)
2883 bfd_size_type t
= 0;
2885 /* Dynamic symbols get one IPLT relocation. Local symbols in
2886 shared libraries get two REL relocations. Local symbols in
2887 main applications get nothing. */
2889 t
= sizeof (ElfNN_External_Rela
);
2891 t
= 2 * sizeof (ElfNN_External_Rela
);
2893 ia64_info
->rel_pltoff_sec
->size
+= t
;
2896 /* Take care of the normal data relocations. */
2898 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2900 int count
= rent
->count
;
2904 case R_IA64_FPTR32LSB
:
2905 case R_IA64_FPTR64LSB
:
2906 /* Allocate one iff !want_fptr and not PIE, which by this point
2907 will be true only if we're actually allocating one statically
2908 in the main executable. Position independent executables
2909 need a relative reloc. */
2910 if (dyn_i
->want_fptr
&& !bfd_link_pie (x
->info
))
2913 case R_IA64_PCREL32LSB
:
2914 case R_IA64_PCREL64LSB
:
2915 if (!dynamic_symbol
)
2918 case R_IA64_DIR32LSB
:
2919 case R_IA64_DIR64LSB
:
2920 if (!dynamic_symbol
&& !shared
)
2923 case R_IA64_IPLTLSB
:
2924 if (!dynamic_symbol
&& !shared
)
2926 /* Use two REL relocations for IPLT relocations
2927 against local symbols. */
2928 if (!dynamic_symbol
)
2931 case R_IA64_DTPREL32LSB
:
2932 case R_IA64_TPREL64LSB
:
2933 case R_IA64_DTPREL64LSB
:
2934 case R_IA64_DTPMOD64LSB
:
2940 ia64_info
->reltext
= 1;
2941 rent
->srel
->size
+= sizeof (ElfNN_External_Rela
) * count
;
2948 elfNN_ia64_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2949 struct elf_link_hash_entry
*h
)
2951 /* ??? Undefined symbols with PLT entries should be re-defined
2952 to be the PLT entry. */
2954 /* If this is a weak symbol, and there is a real definition, the
2955 processor independent code will have arranged for us to see the
2956 real definition first, and we can just use the same value. */
2957 if (h
->u
.weakdef
!= NULL
)
2959 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2960 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2961 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2962 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2966 /* If this is a reference to a symbol defined by a dynamic object which
2967 is not a function, we might allocate the symbol in our .dynbss section
2968 and allocate a COPY dynamic relocation.
2970 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2977 elfNN_ia64_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2978 struct bfd_link_info
*info
)
2980 struct elfNN_ia64_allocate_data data
;
2981 struct elfNN_ia64_link_hash_table
*ia64_info
;
2984 bfd_boolean relplt
= FALSE
;
2986 dynobj
= elf_hash_table(info
)->dynobj
;
2987 ia64_info
= elfNN_ia64_hash_table (info
);
2988 if (ia64_info
== NULL
)
2990 ia64_info
->self_dtpmod_offset
= (bfd_vma
) -1;
2991 BFD_ASSERT(dynobj
!= NULL
);
2994 /* Set the contents of the .interp section to the interpreter. */
2995 if (ia64_info
->root
.dynamic_sections_created
2996 && bfd_link_executable (info
) && !info
->nointerp
)
2998 sec
= bfd_get_linker_section (dynobj
, ".interp");
2999 BFD_ASSERT (sec
!= NULL
);
3000 sec
->contents
= (bfd_byte
*) ELF_DYNAMIC_INTERPRETER
;
3001 sec
->size
= strlen (ELF_DYNAMIC_INTERPRETER
) + 1;
3004 /* Allocate the GOT entries. */
3006 if (ia64_info
->root
.sgot
)
3009 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_data_got
, &data
);
3010 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_fptr_got
, &data
);
3011 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_local_got
, &data
);
3012 ia64_info
->root
.sgot
->size
= data
.ofs
;
3015 /* Allocate the FPTR entries. */
3017 if (ia64_info
->fptr_sec
)
3020 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_fptr
, &data
);
3021 ia64_info
->fptr_sec
->size
= data
.ofs
;
3024 /* Now that we've seen all of the input files, we can decide which
3025 symbols need plt entries. Allocate the minimal PLT entries first.
3026 We do this even though dynamic_sections_created may be FALSE, because
3027 this has the side-effect of clearing want_plt and want_plt2. */
3030 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_plt_entries
, &data
);
3032 ia64_info
->minplt_entries
= 0;
3035 ia64_info
->minplt_entries
3036 = (data
.ofs
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
3039 /* Align the pointer for the plt2 entries. */
3040 data
.ofs
= (data
.ofs
+ 31) & (bfd_vma
) -32;
3042 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_plt2_entries
, &data
);
3043 if (data
.ofs
!= 0 || ia64_info
->root
.dynamic_sections_created
)
3045 /* FIXME: we always reserve the memory for dynamic linker even if
3046 there are no PLT entries since dynamic linker may assume the
3047 reserved memory always exists. */
3049 BFD_ASSERT (ia64_info
->root
.dynamic_sections_created
);
3051 ia64_info
->root
.splt
->size
= data
.ofs
;
3053 /* If we've got a .plt, we need some extra memory for the dynamic
3054 linker. We stuff these in .got.plt. */
3055 sec
= bfd_get_linker_section (dynobj
, ".got.plt");
3056 sec
->size
= 8 * PLT_RESERVED_WORDS
;
3059 /* Allocate the PLTOFF entries. */
3061 if (ia64_info
->pltoff_sec
)
3064 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_pltoff_entries
, &data
);
3065 ia64_info
->pltoff_sec
->size
= data
.ofs
;
3068 if (ia64_info
->root
.dynamic_sections_created
)
3070 /* Allocate space for the dynamic relocations that turned out to be
3073 if (bfd_link_pic (info
) && ia64_info
->self_dtpmod_offset
!= (bfd_vma
) -1)
3074 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
3075 data
.only_got
= FALSE
;
3076 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_dynrel_entries
, &data
);
3079 /* We have now determined the sizes of the various dynamic sections.
3080 Allocate memory for them. */
3081 for (sec
= dynobj
->sections
; sec
!= NULL
; sec
= sec
->next
)
3085 if (!(sec
->flags
& SEC_LINKER_CREATED
))
3088 /* If we don't need this section, strip it from the output file.
3089 There were several sections primarily related to dynamic
3090 linking that must be create before the linker maps input
3091 sections to output sections. The linker does that before
3092 bfd_elf_size_dynamic_sections is called, and it is that
3093 function which decides whether anything needs to go into
3096 strip
= (sec
->size
== 0);
3098 if (sec
== ia64_info
->root
.sgot
)
3100 else if (sec
== ia64_info
->root
.srelgot
)
3103 ia64_info
->root
.srelgot
= NULL
;
3105 /* We use the reloc_count field as a counter if we need to
3106 copy relocs into the output file. */
3107 sec
->reloc_count
= 0;
3109 else if (sec
== ia64_info
->fptr_sec
)
3112 ia64_info
->fptr_sec
= NULL
;
3114 else if (sec
== ia64_info
->rel_fptr_sec
)
3117 ia64_info
->rel_fptr_sec
= NULL
;
3119 /* We use the reloc_count field as a counter if we need to
3120 copy relocs into the output file. */
3121 sec
->reloc_count
= 0;
3123 else if (sec
== ia64_info
->root
.splt
)
3126 ia64_info
->root
.splt
= NULL
;
3128 else if (sec
== ia64_info
->pltoff_sec
)
3131 ia64_info
->pltoff_sec
= NULL
;
3133 else if (sec
== ia64_info
->rel_pltoff_sec
)
3136 ia64_info
->rel_pltoff_sec
= NULL
;
3140 /* We use the reloc_count field as a counter if we need to
3141 copy relocs into the output file. */
3142 sec
->reloc_count
= 0;
3149 /* It's OK to base decisions on the section name, because none
3150 of the dynobj section names depend upon the input files. */
3151 name
= bfd_get_section_name (dynobj
, sec
);
3153 if (strcmp (name
, ".got.plt") == 0)
3155 else if (CONST_STRNEQ (name
, ".rel"))
3159 /* We use the reloc_count field as a counter if we need to
3160 copy relocs into the output file. */
3161 sec
->reloc_count
= 0;
3169 sec
->flags
|= SEC_EXCLUDE
;
3172 /* Allocate memory for the section contents. */
3173 sec
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, sec
->size
);
3174 if (sec
->contents
== NULL
&& sec
->size
!= 0)
3179 if (elf_hash_table (info
)->dynamic_sections_created
)
3181 /* Add some entries to the .dynamic section. We fill in the values
3182 later (in finish_dynamic_sections) but we must add the entries now
3183 so that we get the correct size for the .dynamic section. */
3185 if (bfd_link_executable (info
))
3187 /* The DT_DEBUG entry is filled in by the dynamic linker and used
3189 #define add_dynamic_entry(TAG, VAL) \
3190 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3192 if (!add_dynamic_entry (DT_DEBUG
, 0))
3196 if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE
, 0))
3198 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3203 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3204 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3205 || !add_dynamic_entry (DT_JMPREL
, 0))
3209 if (!add_dynamic_entry (DT_RELA
, 0)
3210 || !add_dynamic_entry (DT_RELASZ
, 0)
3211 || !add_dynamic_entry (DT_RELAENT
, sizeof (ElfNN_External_Rela
)))
3214 if (ia64_info
->reltext
)
3216 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3218 info
->flags
|= DF_TEXTREL
;
3222 /* ??? Perhaps force __gp local. */
3228 elfNN_ia64_install_dyn_reloc (bfd
*abfd
, struct bfd_link_info
*info
,
3229 asection
*sec
, asection
*srel
,
3230 bfd_vma offset
, unsigned int type
,
3231 long dynindx
, bfd_vma addend
)
3233 Elf_Internal_Rela outrel
;
3236 BFD_ASSERT (dynindx
!= -1);
3237 outrel
.r_info
= ELFNN_R_INFO (dynindx
, type
);
3238 outrel
.r_addend
= addend
;
3239 outrel
.r_offset
= _bfd_elf_section_offset (abfd
, info
, sec
, offset
);
3240 if (outrel
.r_offset
>= (bfd_vma
) -2)
3242 /* Run for the hills. We shouldn't be outputting a relocation
3243 for this. So do what everyone else does and output a no-op. */
3244 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
3245 outrel
.r_addend
= 0;
3246 outrel
.r_offset
= 0;
3249 outrel
.r_offset
+= sec
->output_section
->vma
+ sec
->output_offset
;
3251 loc
= srel
->contents
;
3252 loc
+= srel
->reloc_count
++ * sizeof (ElfNN_External_Rela
);
3253 bfd_elfNN_swap_reloca_out (abfd
, &outrel
, loc
);
3254 BFD_ASSERT (sizeof (ElfNN_External_Rela
) * srel
->reloc_count
<= srel
->size
);
3257 /* Store an entry for target address TARGET_ADDR in the linkage table
3258 and return the gp-relative address of the linkage table entry. */
3261 set_got_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3262 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3263 long dynindx
, bfd_vma addend
, bfd_vma value
,
3264 unsigned int dyn_r_type
)
3266 struct elfNN_ia64_link_hash_table
*ia64_info
;
3271 ia64_info
= elfNN_ia64_hash_table (info
);
3272 if (ia64_info
== NULL
)
3275 got_sec
= ia64_info
->root
.sgot
;
3279 case R_IA64_TPREL64LSB
:
3280 done
= dyn_i
->tprel_done
;
3281 dyn_i
->tprel_done
= TRUE
;
3282 got_offset
= dyn_i
->tprel_offset
;
3284 case R_IA64_DTPMOD64LSB
:
3285 if (dyn_i
->dtpmod_offset
!= ia64_info
->self_dtpmod_offset
)
3287 done
= dyn_i
->dtpmod_done
;
3288 dyn_i
->dtpmod_done
= TRUE
;
3292 done
= ia64_info
->self_dtpmod_done
;
3293 ia64_info
->self_dtpmod_done
= TRUE
;
3296 got_offset
= dyn_i
->dtpmod_offset
;
3298 case R_IA64_DTPREL32LSB
:
3299 case R_IA64_DTPREL64LSB
:
3300 done
= dyn_i
->dtprel_done
;
3301 dyn_i
->dtprel_done
= TRUE
;
3302 got_offset
= dyn_i
->dtprel_offset
;
3305 done
= dyn_i
->got_done
;
3306 dyn_i
->got_done
= TRUE
;
3307 got_offset
= dyn_i
->got_offset
;
3311 BFD_ASSERT ((got_offset
& 7) == 0);
3315 /* Store the target address in the linkage table entry. */
3316 bfd_put_64 (abfd
, value
, got_sec
->contents
+ got_offset
);
3318 /* Install a dynamic relocation if needed. */
3319 if (((bfd_link_pic (info
)
3321 || ELF_ST_VISIBILITY (dyn_i
->h
->other
) == STV_DEFAULT
3322 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
3323 && dyn_r_type
!= R_IA64_DTPREL32LSB
3324 && dyn_r_type
!= R_IA64_DTPREL64LSB
)
3325 || elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, info
, dyn_r_type
)
3327 && (dyn_r_type
== R_IA64_FPTR32LSB
3328 || dyn_r_type
== R_IA64_FPTR64LSB
)))
3329 && (!dyn_i
->want_ltoff_fptr
3330 || !bfd_link_pie (info
)
3332 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
3335 && dyn_r_type
!= R_IA64_TPREL64LSB
3336 && dyn_r_type
!= R_IA64_DTPMOD64LSB
3337 && dyn_r_type
!= R_IA64_DTPREL32LSB
3338 && dyn_r_type
!= R_IA64_DTPREL64LSB
)
3340 dyn_r_type
= R_IA64_RELNNLSB
;
3345 if (bfd_big_endian (abfd
))
3349 case R_IA64_REL32LSB
:
3350 dyn_r_type
= R_IA64_REL32MSB
;
3352 case R_IA64_DIR32LSB
:
3353 dyn_r_type
= R_IA64_DIR32MSB
;
3355 case R_IA64_FPTR32LSB
:
3356 dyn_r_type
= R_IA64_FPTR32MSB
;
3358 case R_IA64_DTPREL32LSB
:
3359 dyn_r_type
= R_IA64_DTPREL32MSB
;
3361 case R_IA64_REL64LSB
:
3362 dyn_r_type
= R_IA64_REL64MSB
;
3364 case R_IA64_DIR64LSB
:
3365 dyn_r_type
= R_IA64_DIR64MSB
;
3367 case R_IA64_FPTR64LSB
:
3368 dyn_r_type
= R_IA64_FPTR64MSB
;
3370 case R_IA64_TPREL64LSB
:
3371 dyn_r_type
= R_IA64_TPREL64MSB
;
3373 case R_IA64_DTPMOD64LSB
:
3374 dyn_r_type
= R_IA64_DTPMOD64MSB
;
3376 case R_IA64_DTPREL64LSB
:
3377 dyn_r_type
= R_IA64_DTPREL64MSB
;
3385 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, got_sec
,
3386 ia64_info
->root
.srelgot
,
3387 got_offset
, dyn_r_type
,
3392 /* Return the address of the linkage table entry. */
3393 value
= (got_sec
->output_section
->vma
3394 + got_sec
->output_offset
3400 /* Fill in a function descriptor consisting of the function's code
3401 address and its global pointer. Return the descriptor's address. */
3404 set_fptr_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3405 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3408 struct elfNN_ia64_link_hash_table
*ia64_info
;
3411 ia64_info
= elfNN_ia64_hash_table (info
);
3412 if (ia64_info
== NULL
)
3415 fptr_sec
= ia64_info
->fptr_sec
;
3417 if (!dyn_i
->fptr_done
)
3419 dyn_i
->fptr_done
= 1;
3421 /* Fill in the function descriptor. */
3422 bfd_put_64 (abfd
, value
, fptr_sec
->contents
+ dyn_i
->fptr_offset
);
3423 bfd_put_64 (abfd
, _bfd_get_gp_value (abfd
),
3424 fptr_sec
->contents
+ dyn_i
->fptr_offset
+ 8);
3425 if (ia64_info
->rel_fptr_sec
)
3427 Elf_Internal_Rela outrel
;
3430 if (bfd_little_endian (abfd
))
3431 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_IPLTLSB
);
3433 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_IPLTMSB
);
3434 outrel
.r_addend
= value
;
3435 outrel
.r_offset
= (fptr_sec
->output_section
->vma
3436 + fptr_sec
->output_offset
3437 + dyn_i
->fptr_offset
);
3438 loc
= ia64_info
->rel_fptr_sec
->contents
;
3439 loc
+= ia64_info
->rel_fptr_sec
->reloc_count
++
3440 * sizeof (ElfNN_External_Rela
);
3441 bfd_elfNN_swap_reloca_out (abfd
, &outrel
, loc
);
3445 /* Return the descriptor's address. */
3446 value
= (fptr_sec
->output_section
->vma
3447 + fptr_sec
->output_offset
3448 + dyn_i
->fptr_offset
);
3453 /* Fill in a PLTOFF entry consisting of the function's code address
3454 and its global pointer. Return the descriptor's address. */
3457 set_pltoff_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3458 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3459 bfd_vma value
, bfd_boolean is_plt
)
3461 struct elfNN_ia64_link_hash_table
*ia64_info
;
3462 asection
*pltoff_sec
;
3464 ia64_info
= elfNN_ia64_hash_table (info
);
3465 if (ia64_info
== NULL
)
3468 pltoff_sec
= ia64_info
->pltoff_sec
;
3470 /* Don't do anything if this symbol uses a real PLT entry. In
3471 that case, we'll fill this in during finish_dynamic_symbol. */
3472 if ((! dyn_i
->want_plt
|| is_plt
)
3473 && !dyn_i
->pltoff_done
)
3475 bfd_vma gp
= _bfd_get_gp_value (abfd
);
3477 /* Fill in the function descriptor. */
3478 bfd_put_64 (abfd
, value
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
);
3479 bfd_put_64 (abfd
, gp
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
+ 8);
3481 /* Install dynamic relocations if needed. */
3483 && bfd_link_pic (info
)
3485 || ELF_ST_VISIBILITY (dyn_i
->h
->other
) == STV_DEFAULT
3486 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
3488 unsigned int dyn_r_type
;
3490 if (bfd_big_endian (abfd
))
3491 dyn_r_type
= R_IA64_RELNNMSB
;
3493 dyn_r_type
= R_IA64_RELNNLSB
;
3495 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
3496 ia64_info
->rel_pltoff_sec
,
3497 dyn_i
->pltoff_offset
,
3498 dyn_r_type
, 0, value
);
3499 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
3500 ia64_info
->rel_pltoff_sec
,
3501 dyn_i
->pltoff_offset
+ ARCH_SIZE
/ 8,
3505 dyn_i
->pltoff_done
= 1;
3508 /* Return the descriptor's address. */
3509 value
= (pltoff_sec
->output_section
->vma
3510 + pltoff_sec
->output_offset
3511 + dyn_i
->pltoff_offset
);
3516 /* Return the base VMA address which should be subtracted from real addresses
3517 when resolving @tprel() relocation.
3518 Main program TLS (whose template starts at PT_TLS p_vaddr)
3519 is assigned offset round(2 * size of pointer, PT_TLS p_align). */
3522 elfNN_ia64_tprel_base (struct bfd_link_info
*info
)
3524 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3525 return tls_sec
->vma
- align_power ((bfd_vma
) ARCH_SIZE
/ 4,
3526 tls_sec
->alignment_power
);
3529 /* Return the base VMA address which should be subtracted from real addresses
3530 when resolving @dtprel() relocation.
3531 This is PT_TLS segment p_vaddr. */
3534 elfNN_ia64_dtprel_base (struct bfd_link_info
*info
)
3536 return elf_hash_table (info
)->tls_sec
->vma
;
3539 /* Called through qsort to sort the .IA_64.unwind section during a
3540 non-relocatable link. Set elfNN_ia64_unwind_entry_compare_bfd
3541 to the output bfd so we can do proper endianness frobbing. */
3543 static bfd
*elfNN_ia64_unwind_entry_compare_bfd
;
3546 elfNN_ia64_unwind_entry_compare (const void * a
, const void * b
)
3550 av
= bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd
, a
);
3551 bv
= bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd
, b
);
3553 return (av
< bv
? -1 : av
> bv
? 1 : 0);
3556 /* Make sure we've got ourselves a nice fat __gp value. */
3558 elfNN_ia64_choose_gp (bfd
*abfd
, struct bfd_link_info
*info
, bfd_boolean final
)
3560 bfd_vma min_vma
= (bfd_vma
) -1, max_vma
= 0;
3561 bfd_vma min_short_vma
= min_vma
, max_short_vma
= 0;
3562 struct elf_link_hash_entry
*gp
;
3565 struct elfNN_ia64_link_hash_table
*ia64_info
;
3567 ia64_info
= elfNN_ia64_hash_table (info
);
3568 if (ia64_info
== NULL
)
3571 /* Find the min and max vma of all sections marked short. Also collect
3572 min and max vma of any type, for use in selecting a nice gp. */
3573 for (os
= abfd
->sections
; os
; os
= os
->next
)
3577 if ((os
->flags
& SEC_ALLOC
) == 0)
3581 /* When this function is called from elfNN_ia64_final_link
3582 the correct value to use is os->size. When called from
3583 elfNN_ia64_relax_section we are in the middle of section
3584 sizing; some sections will already have os->size set, others
3585 will have os->size zero and os->rawsize the previous size. */
3586 hi
= os
->vma
+ (!final
&& os
->rawsize
? os
->rawsize
: os
->size
);
3594 if (os
->flags
& SEC_SMALL_DATA
)
3596 if (min_short_vma
> lo
)
3598 if (max_short_vma
< hi
)
3603 if (ia64_info
->min_short_sec
)
3606 > (ia64_info
->min_short_sec
->vma
3607 + ia64_info
->min_short_offset
))
3608 min_short_vma
= (ia64_info
->min_short_sec
->vma
3609 + ia64_info
->min_short_offset
);
3611 < (ia64_info
->max_short_sec
->vma
3612 + ia64_info
->max_short_offset
))
3613 max_short_vma
= (ia64_info
->max_short_sec
->vma
3614 + ia64_info
->max_short_offset
);
3617 /* See if the user wants to force a value. */
3618 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
3622 && (gp
->root
.type
== bfd_link_hash_defined
3623 || gp
->root
.type
== bfd_link_hash_defweak
))
3625 asection
*gp_sec
= gp
->root
.u
.def
.section
;
3626 gp_val
= (gp
->root
.u
.def
.value
3627 + gp_sec
->output_section
->vma
3628 + gp_sec
->output_offset
);
3632 /* Pick a sensible value. */
3634 if (ia64_info
->min_short_sec
)
3636 bfd_vma short_range
= max_short_vma
- min_short_vma
;
3638 /* If min_short_sec is set, pick one in the middle bewteen
3639 min_short_vma and max_short_vma. */
3640 if (short_range
>= 0x400000)
3642 gp_val
= min_short_vma
+ short_range
/ 2;
3646 asection
*got_sec
= ia64_info
->root
.sgot
;
3648 /* Start with just the address of the .got. */
3650 gp_val
= got_sec
->output_section
->vma
;
3651 else if (max_short_vma
!= 0)
3652 gp_val
= min_short_vma
;
3653 else if (max_vma
- min_vma
< 0x200000)
3656 gp_val
= max_vma
- 0x200000 + 8;
3659 /* If it is possible to address the entire image, but we
3660 don't with the choice above, adjust. */
3661 if (max_vma
- min_vma
< 0x400000
3662 && (max_vma
- gp_val
>= 0x200000
3663 || gp_val
- min_vma
> 0x200000))
3664 gp_val
= min_vma
+ 0x200000;
3665 else if (max_short_vma
!= 0)
3667 /* If we don't cover all the short data, adjust. */
3668 if (max_short_vma
- gp_val
>= 0x200000)
3669 gp_val
= min_short_vma
+ 0x200000;
3671 /* If we're addressing stuff past the end, adjust back. */
3672 if (gp_val
> max_vma
)
3673 gp_val
= max_vma
- 0x200000 + 8;
3677 /* Validate whether all SHF_IA_64_SHORT sections are within
3678 range of the chosen GP. */
3680 if (max_short_vma
!= 0)
3682 if (max_short_vma
- min_short_vma
>= 0x400000)
3686 /* xgettext:c-format */
3687 (_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
3688 bfd_get_filename (abfd
),
3689 (unsigned long) (max_short_vma
- min_short_vma
));
3692 else if ((gp_val
> min_short_vma
3693 && gp_val
- min_short_vma
> 0x200000)
3694 || (gp_val
< max_short_vma
3695 && max_short_vma
- gp_val
>= 0x200000))
3698 (_("%s: __gp does not cover short data segment"),
3699 bfd_get_filename (abfd
));
3704 _bfd_set_gp_value (abfd
, gp_val
);
3710 elfNN_ia64_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
3712 struct elfNN_ia64_link_hash_table
*ia64_info
;
3713 asection
*unwind_output_sec
;
3715 ia64_info
= elfNN_ia64_hash_table (info
);
3716 if (ia64_info
== NULL
)
3719 /* Make sure we've got ourselves a nice fat __gp value. */
3720 if (!bfd_link_relocatable (info
))
3723 struct elf_link_hash_entry
*gp
;
3725 /* We assume after gp is set, section size will only decrease. We
3726 need to adjust gp for it. */
3727 _bfd_set_gp_value (abfd
, 0);
3728 if (! elfNN_ia64_choose_gp (abfd
, info
, TRUE
))
3730 gp_val
= _bfd_get_gp_value (abfd
);
3732 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
3736 gp
->root
.type
= bfd_link_hash_defined
;
3737 gp
->root
.u
.def
.value
= gp_val
;
3738 gp
->root
.u
.def
.section
= bfd_abs_section_ptr
;
3742 /* If we're producing a final executable, we need to sort the contents
3743 of the .IA_64.unwind section. Force this section to be relocated
3744 into memory rather than written immediately to the output file. */
3745 unwind_output_sec
= NULL
;
3746 if (!bfd_link_relocatable (info
))
3748 asection
*s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_unwind
);
3751 unwind_output_sec
= s
->output_section
;
3752 unwind_output_sec
->contents
3753 = bfd_malloc (unwind_output_sec
->size
);
3754 if (unwind_output_sec
->contents
== NULL
)
3759 /* Invoke the regular ELF backend linker to do all the work. */
3760 if (!bfd_elf_final_link (abfd
, info
))
3763 if (unwind_output_sec
)
3765 elfNN_ia64_unwind_entry_compare_bfd
= abfd
;
3766 qsort (unwind_output_sec
->contents
,
3767 (size_t) (unwind_output_sec
->size
/ 24),
3769 elfNN_ia64_unwind_entry_compare
);
3771 if (! bfd_set_section_contents (abfd
, unwind_output_sec
,
3772 unwind_output_sec
->contents
, (bfd_vma
) 0,
3773 unwind_output_sec
->size
))
3781 elfNN_ia64_relocate_section (bfd
*output_bfd
,
3782 struct bfd_link_info
*info
,
3784 asection
*input_section
,
3786 Elf_Internal_Rela
*relocs
,
3787 Elf_Internal_Sym
*local_syms
,
3788 asection
**local_sections
)
3790 struct elfNN_ia64_link_hash_table
*ia64_info
;
3791 Elf_Internal_Shdr
*symtab_hdr
;
3792 Elf_Internal_Rela
*rel
;
3793 Elf_Internal_Rela
*relend
;
3795 bfd_boolean ret_val
= TRUE
; /* for non-fatal errors */
3798 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3799 ia64_info
= elfNN_ia64_hash_table (info
);
3800 if (ia64_info
== NULL
)
3803 /* Infect various flags from the input section to the output section. */
3804 if (bfd_link_relocatable (info
))
3808 flags
= elf_section_data(input_section
)->this_hdr
.sh_flags
;
3809 flags
&= SHF_IA_64_NORECOV
;
3811 elf_section_data(input_section
->output_section
)
3812 ->this_hdr
.sh_flags
|= flags
;
3815 gp_val
= _bfd_get_gp_value (output_bfd
);
3816 srel
= get_reloc_section (input_bfd
, ia64_info
, input_section
, FALSE
);
3819 relend
= relocs
+ input_section
->reloc_count
;
3820 for (; rel
< relend
; ++rel
)
3822 struct elf_link_hash_entry
*h
;
3823 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3824 bfd_reloc_status_type r
;
3825 reloc_howto_type
*howto
;
3826 unsigned long r_symndx
;
3827 Elf_Internal_Sym
*sym
;
3828 unsigned int r_type
;
3832 bfd_boolean dynamic_symbol_p
;
3833 bfd_boolean undef_weak_ref
;
3835 r_type
= ELFNN_R_TYPE (rel
->r_info
);
3836 if (r_type
> R_IA64_MAX_RELOC_CODE
)
3839 /* xgettext:c-format */
3840 (_("%B: unknown relocation type %d"),
3841 input_bfd
, (int) r_type
);
3842 bfd_set_error (bfd_error_bad_value
);
3847 howto
= ia64_elf_lookup_howto (r_type
);
3848 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
3852 undef_weak_ref
= FALSE
;
3854 if (r_symndx
< symtab_hdr
->sh_info
)
3856 /* Reloc against local symbol. */
3858 sym
= local_syms
+ r_symndx
;
3859 sym_sec
= local_sections
[r_symndx
];
3861 value
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &msec
, rel
);
3862 if (!bfd_link_relocatable (info
)
3863 && (sym_sec
->flags
& SEC_MERGE
) != 0
3864 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3865 && sym_sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
3867 struct elfNN_ia64_local_hash_entry
*loc_h
;
3869 loc_h
= get_local_sym_hash (ia64_info
, input_bfd
, rel
, FALSE
);
3870 if (loc_h
&& ! loc_h
->sec_merge_done
)
3872 struct elfNN_ia64_dyn_sym_info
*dynent
;
3875 for (count
= loc_h
->count
, dynent
= loc_h
->info
;
3881 _bfd_merged_section_offset (output_bfd
, &msec
,
3882 elf_section_data (msec
)->
3886 dynent
->addend
-= sym
->st_value
;
3887 dynent
->addend
+= msec
->output_section
->vma
3888 + msec
->output_offset
3889 - sym_sec
->output_section
->vma
3890 - sym_sec
->output_offset
;
3893 /* We may have introduced duplicated entries. We need
3894 to remove them properly. */
3895 count
= sort_dyn_sym_info (loc_h
->info
, loc_h
->count
);
3896 if (count
!= loc_h
->count
)
3898 loc_h
->count
= count
;
3899 loc_h
->sorted_count
= count
;
3902 loc_h
->sec_merge_done
= 1;
3908 bfd_boolean unresolved_reloc
;
3909 bfd_boolean warned
, ignored
;
3910 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
3912 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3913 r_symndx
, symtab_hdr
, sym_hashes
,
3915 unresolved_reloc
, warned
, ignored
);
3917 if (h
->root
.type
== bfd_link_hash_undefweak
)
3918 undef_weak_ref
= TRUE
;
3919 else if (warned
|| (ignored
&& bfd_link_executable (info
)))
3923 if (sym_sec
!= NULL
&& discarded_section (sym_sec
))
3924 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3925 rel
, 1, relend
, howto
, 0, contents
);
3927 if (bfd_link_relocatable (info
))
3930 hit_addr
= contents
+ rel
->r_offset
;
3931 value
+= rel
->r_addend
;
3932 dynamic_symbol_p
= elfNN_ia64_dynamic_symbol_p (h
, info
, r_type
);
3943 case R_IA64_DIR32MSB
:
3944 case R_IA64_DIR32LSB
:
3945 case R_IA64_DIR64MSB
:
3946 case R_IA64_DIR64LSB
:
3947 /* Install a dynamic relocation for this reloc. */
3948 if ((dynamic_symbol_p
|| bfd_link_pic (info
))
3949 && r_symndx
!= STN_UNDEF
3950 && (input_section
->flags
& SEC_ALLOC
) != 0)
3952 unsigned int dyn_r_type
;
3956 BFD_ASSERT (srel
!= NULL
);
3963 /* ??? People shouldn't be doing non-pic code in
3964 shared libraries nor dynamic executables. */
3966 /* xgettext:c-format */
3967 (_("%B: non-pic code with imm relocation against dynamic symbol `%s'"),
3969 h
? h
->root
.root
.string
3970 : bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3979 /* If we don't need dynamic symbol lookup, find a
3980 matching RELATIVE relocation. */
3981 dyn_r_type
= r_type
;
3982 if (dynamic_symbol_p
)
3984 dynindx
= h
->dynindx
;
3985 addend
= rel
->r_addend
;
3992 case R_IA64_DIR32MSB
:
3993 dyn_r_type
= R_IA64_REL32MSB
;
3995 case R_IA64_DIR32LSB
:
3996 dyn_r_type
= R_IA64_REL32LSB
;
3998 case R_IA64_DIR64MSB
:
3999 dyn_r_type
= R_IA64_REL64MSB
;
4001 case R_IA64_DIR64LSB
:
4002 dyn_r_type
= R_IA64_REL64LSB
;
4012 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4013 srel
, rel
->r_offset
, dyn_r_type
,
4018 case R_IA64_LTV32MSB
:
4019 case R_IA64_LTV32LSB
:
4020 case R_IA64_LTV64MSB
:
4021 case R_IA64_LTV64LSB
:
4022 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4025 case R_IA64_GPREL22
:
4026 case R_IA64_GPREL64I
:
4027 case R_IA64_GPREL32MSB
:
4028 case R_IA64_GPREL32LSB
:
4029 case R_IA64_GPREL64MSB
:
4030 case R_IA64_GPREL64LSB
:
4031 if (dynamic_symbol_p
)
4034 /* xgettext:c-format */
4035 (_("%B: @gprel relocation against dynamic symbol %s"),
4037 h
? h
->root
.root
.string
4038 : bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4044 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4047 case R_IA64_LTOFF22
:
4048 case R_IA64_LTOFF22X
:
4049 case R_IA64_LTOFF64I
:
4050 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4051 value
= set_got_entry (input_bfd
, info
, dyn_i
, (h
? h
->dynindx
: -1),
4052 rel
->r_addend
, value
, R_IA64_DIRNNLSB
);
4054 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4057 case R_IA64_PLTOFF22
:
4058 case R_IA64_PLTOFF64I
:
4059 case R_IA64_PLTOFF64MSB
:
4060 case R_IA64_PLTOFF64LSB
:
4061 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4062 value
= set_pltoff_entry (output_bfd
, info
, dyn_i
, value
, FALSE
);
4064 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4067 case R_IA64_FPTR64I
:
4068 case R_IA64_FPTR32MSB
:
4069 case R_IA64_FPTR32LSB
:
4070 case R_IA64_FPTR64MSB
:
4071 case R_IA64_FPTR64LSB
:
4072 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4073 if (dyn_i
->want_fptr
)
4075 if (!undef_weak_ref
)
4076 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
4078 if (!dyn_i
->want_fptr
|| bfd_link_pie (info
))
4081 unsigned int dyn_r_type
= r_type
;
4082 bfd_vma addend
= rel
->r_addend
;
4084 /* Otherwise, we expect the dynamic linker to create
4087 if (dyn_i
->want_fptr
)
4089 if (r_type
== R_IA64_FPTR64I
)
4091 /* We can't represent this without a dynamic symbol.
4092 Adjust the relocation to be against an output
4093 section symbol, which are always present in the
4094 dynamic symbol table. */
4095 /* ??? People shouldn't be doing non-pic code in
4096 shared libraries. Hork. */
4098 (_("%B: linking non-pic code in a position independent executable"),
4105 dyn_r_type
= r_type
+ R_IA64_RELNNLSB
- R_IA64_FPTRNNLSB
;
4109 if (h
->dynindx
!= -1)
4110 dynindx
= h
->dynindx
;
4112 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4113 (info
, h
->root
.u
.def
.section
->owner
,
4114 global_sym_index (h
)));
4119 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4120 (info
, input_bfd
, (long) r_symndx
));
4124 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4125 srel
, rel
->r_offset
, dyn_r_type
,
4129 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4132 case R_IA64_LTOFF_FPTR22
:
4133 case R_IA64_LTOFF_FPTR64I
:
4134 case R_IA64_LTOFF_FPTR32MSB
:
4135 case R_IA64_LTOFF_FPTR32LSB
:
4136 case R_IA64_LTOFF_FPTR64MSB
:
4137 case R_IA64_LTOFF_FPTR64LSB
:
4141 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4142 if (dyn_i
->want_fptr
)
4144 BFD_ASSERT (h
== NULL
|| h
->dynindx
== -1);
4145 if (!undef_weak_ref
)
4146 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
4151 /* Otherwise, we expect the dynamic linker to create
4155 if (h
->dynindx
!= -1)
4156 dynindx
= h
->dynindx
;
4158 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4159 (info
, h
->root
.u
.def
.section
->owner
,
4160 global_sym_index (h
)));
4163 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4164 (info
, input_bfd
, (long) r_symndx
));
4168 value
= set_got_entry (output_bfd
, info
, dyn_i
, dynindx
,
4169 rel
->r_addend
, value
, R_IA64_FPTRNNLSB
);
4171 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4175 case R_IA64_PCREL32MSB
:
4176 case R_IA64_PCREL32LSB
:
4177 case R_IA64_PCREL64MSB
:
4178 case R_IA64_PCREL64LSB
:
4179 /* Install a dynamic relocation for this reloc. */
4180 if (dynamic_symbol_p
&& r_symndx
!= STN_UNDEF
)
4182 BFD_ASSERT (srel
!= NULL
);
4184 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4185 srel
, rel
->r_offset
, r_type
,
4186 h
->dynindx
, rel
->r_addend
);
4190 case R_IA64_PCREL21B
:
4191 case R_IA64_PCREL60B
:
4192 /* We should have created a PLT entry for any dynamic symbol. */
4195 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, FALSE
);
4197 if (dyn_i
&& dyn_i
->want_plt2
)
4199 /* Should have caught this earlier. */
4200 BFD_ASSERT (rel
->r_addend
== 0);
4202 value
= (ia64_info
->root
.splt
->output_section
->vma
4203 + ia64_info
->root
.splt
->output_offset
4204 + dyn_i
->plt2_offset
);
4208 /* Since there's no PLT entry, Validate that this is
4210 BFD_ASSERT (undef_weak_ref
|| sym_sec
->output_section
!= NULL
);
4212 /* If the symbol is undef_weak, we shouldn't be trying
4213 to call it. There's every chance that we'd wind up
4214 with an out-of-range fixup here. Don't bother setting
4215 any value at all. */
4221 case R_IA64_PCREL21BI
:
4222 case R_IA64_PCREL21F
:
4223 case R_IA64_PCREL21M
:
4224 case R_IA64_PCREL22
:
4225 case R_IA64_PCREL64I
:
4226 /* The PCREL21BI reloc is specifically not intended for use with
4227 dynamic relocs. PCREL21F and PCREL21M are used for speculation
4228 fixup code, and thus probably ought not be dynamic. The
4229 PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs. */
4230 if (dynamic_symbol_p
)
4234 if (r_type
== R_IA64_PCREL21BI
)
4235 /* xgettext:c-format */
4236 msg
= _("%B: @internal branch to dynamic symbol %s");
4237 else if (r_type
== R_IA64_PCREL21F
|| r_type
== R_IA64_PCREL21M
)
4238 /* xgettext:c-format */
4239 msg
= _("%B: speculation fixup to dynamic symbol %s");
4241 /* xgettext:c-format */
4242 msg
= _("%B: @pcrel relocation against dynamic symbol %s");
4243 _bfd_error_handler (msg
, input_bfd
,
4244 h
? h
->root
.root
.string
4245 : bfd_elf_sym_name (input_bfd
,
4255 /* Make pc-relative. */
4256 value
-= (input_section
->output_section
->vma
4257 + input_section
->output_offset
4258 + rel
->r_offset
) & ~ (bfd_vma
) 0x3;
4259 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4262 case R_IA64_SEGREL32MSB
:
4263 case R_IA64_SEGREL32LSB
:
4264 case R_IA64_SEGREL64MSB
:
4265 case R_IA64_SEGREL64LSB
:
4267 /* Find the segment that contains the output_section. */
4268 Elf_Internal_Phdr
*p
= _bfd_elf_find_segment_containing_section
4269 (output_bfd
, input_section
->output_section
);
4273 r
= bfd_reloc_notsupported
;
4277 /* The VMA of the segment is the vaddr of the associated
4279 if (value
> p
->p_vaddr
)
4280 value
-= p
->p_vaddr
;
4283 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4288 case R_IA64_SECREL32MSB
:
4289 case R_IA64_SECREL32LSB
:
4290 case R_IA64_SECREL64MSB
:
4291 case R_IA64_SECREL64LSB
:
4292 /* Make output-section relative to section where the symbol
4293 is defined. PR 475 */
4295 value
-= sym_sec
->output_section
->vma
;
4296 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4299 case R_IA64_IPLTMSB
:
4300 case R_IA64_IPLTLSB
:
4301 /* Install a dynamic relocation for this reloc. */
4302 if ((dynamic_symbol_p
|| bfd_link_pic (info
))
4303 && (input_section
->flags
& SEC_ALLOC
) != 0)
4305 BFD_ASSERT (srel
!= NULL
);
4307 /* If we don't need dynamic symbol lookup, install two
4308 RELATIVE relocations. */
4309 if (!dynamic_symbol_p
)
4311 unsigned int dyn_r_type
;
4313 if (r_type
== R_IA64_IPLTMSB
)
4314 dyn_r_type
= R_IA64_REL64MSB
;
4316 dyn_r_type
= R_IA64_REL64LSB
;
4318 elfNN_ia64_install_dyn_reloc (output_bfd
, info
,
4320 srel
, rel
->r_offset
,
4321 dyn_r_type
, 0, value
);
4322 elfNN_ia64_install_dyn_reloc (output_bfd
, info
,
4324 srel
, rel
->r_offset
+ 8,
4325 dyn_r_type
, 0, gp_val
);
4328 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4329 srel
, rel
->r_offset
, r_type
,
4330 h
->dynindx
, rel
->r_addend
);
4333 if (r_type
== R_IA64_IPLTMSB
)
4334 r_type
= R_IA64_DIR64MSB
;
4336 r_type
= R_IA64_DIR64LSB
;
4337 ia64_elf_install_value (hit_addr
, value
, r_type
);
4338 r
= ia64_elf_install_value (hit_addr
+ 8, gp_val
, r_type
);
4341 case R_IA64_TPREL14
:
4342 case R_IA64_TPREL22
:
4343 case R_IA64_TPREL64I
:
4344 if (elf_hash_table (info
)->tls_sec
== NULL
)
4345 goto missing_tls_sec
;
4346 value
-= elfNN_ia64_tprel_base (info
);
4347 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4350 case R_IA64_DTPREL14
:
4351 case R_IA64_DTPREL22
:
4352 case R_IA64_DTPREL64I
:
4353 case R_IA64_DTPREL32LSB
:
4354 case R_IA64_DTPREL32MSB
:
4355 case R_IA64_DTPREL64LSB
:
4356 case R_IA64_DTPREL64MSB
:
4357 if (elf_hash_table (info
)->tls_sec
== NULL
)
4358 goto missing_tls_sec
;
4359 value
-= elfNN_ia64_dtprel_base (info
);
4360 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4363 case R_IA64_LTOFF_TPREL22
:
4364 case R_IA64_LTOFF_DTPMOD22
:
4365 case R_IA64_LTOFF_DTPREL22
:
4368 long dynindx
= h
? h
->dynindx
: -1;
4369 bfd_vma r_addend
= rel
->r_addend
;
4374 case R_IA64_LTOFF_TPREL22
:
4375 if (!dynamic_symbol_p
)
4377 if (elf_hash_table (info
)->tls_sec
== NULL
)
4378 goto missing_tls_sec
;
4379 if (!bfd_link_pic (info
))
4380 value
-= elfNN_ia64_tprel_base (info
);
4383 r_addend
+= value
- elfNN_ia64_dtprel_base (info
);
4387 got_r_type
= R_IA64_TPREL64LSB
;
4389 case R_IA64_LTOFF_DTPMOD22
:
4390 if (!dynamic_symbol_p
&& !bfd_link_pic (info
))
4392 got_r_type
= R_IA64_DTPMOD64LSB
;
4394 case R_IA64_LTOFF_DTPREL22
:
4395 if (!dynamic_symbol_p
)
4397 if (elf_hash_table (info
)->tls_sec
== NULL
)
4398 goto missing_tls_sec
;
4399 value
-= elfNN_ia64_dtprel_base (info
);
4401 got_r_type
= R_IA64_DTPRELNNLSB
;
4404 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4405 value
= set_got_entry (input_bfd
, info
, dyn_i
, dynindx
, r_addend
,
4408 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4413 r
= bfd_reloc_notsupported
;
4422 case bfd_reloc_undefined
:
4423 /* This can happen for global table relative relocs if
4424 __gp is undefined. This is a panic situation so we
4425 don't try to continue. */
4426 (*info
->callbacks
->undefined_symbol
)
4427 (info
, "__gp", input_bfd
, input_section
, rel
->r_offset
, 1);
4430 case bfd_reloc_notsupported
:
4435 name
= h
->root
.root
.string
;
4437 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4439 (*info
->callbacks
->warning
) (info
, _("unsupported reloc"),
4441 input_section
, rel
->r_offset
);
4446 case bfd_reloc_dangerous
:
4447 case bfd_reloc_outofrange
:
4448 case bfd_reloc_overflow
:
4455 name
= h
->root
.root
.string
;
4457 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4462 case R_IA64_TPREL14
:
4463 case R_IA64_TPREL22
:
4464 case R_IA64_TPREL64I
:
4465 case R_IA64_DTPREL14
:
4466 case R_IA64_DTPREL22
:
4467 case R_IA64_DTPREL64I
:
4468 case R_IA64_DTPREL32LSB
:
4469 case R_IA64_DTPREL32MSB
:
4470 case R_IA64_DTPREL64LSB
:
4471 case R_IA64_DTPREL64MSB
:
4472 case R_IA64_LTOFF_TPREL22
:
4473 case R_IA64_LTOFF_DTPMOD22
:
4474 case R_IA64_LTOFF_DTPREL22
:
4476 /* xgettext:c-format */
4477 (_("%B: missing TLS section for relocation %s against `%s' at 0x%lx in section `%A'."),
4478 input_bfd
, input_section
, howto
->name
, name
,
4482 case R_IA64_PCREL21B
:
4483 case R_IA64_PCREL21BI
:
4484 case R_IA64_PCREL21M
:
4485 case R_IA64_PCREL21F
:
4486 if (is_elf_hash_table (info
->hash
))
4488 /* Relaxtion is always performed for ELF output.
4489 Overflow failures for those relocations mean
4490 that the section is too big to relax. */
4492 /* xgettext:c-format */
4493 (_("%B: Can't relax br (%s) to `%s' at 0x%lx in section `%A' with size 0x%lx (> 0x1000000)."),
4494 input_bfd
, input_section
, howto
->name
, name
,
4495 rel
->r_offset
, input_section
->size
);
4500 (*info
->callbacks
->reloc_overflow
) (info
,
4521 elfNN_ia64_finish_dynamic_symbol (bfd
*output_bfd
,
4522 struct bfd_link_info
*info
,
4523 struct elf_link_hash_entry
*h
,
4524 Elf_Internal_Sym
*sym
)
4526 struct elfNN_ia64_link_hash_table
*ia64_info
;
4527 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
4529 ia64_info
= elfNN_ia64_hash_table (info
);
4530 if (ia64_info
== NULL
)
4533 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, FALSE
);
4535 /* Fill in the PLT data, if required. */
4536 if (dyn_i
&& dyn_i
->want_plt
)
4538 Elf_Internal_Rela outrel
;
4541 bfd_vma plt_addr
, pltoff_addr
, gp_val
, plt_index
;
4543 gp_val
= _bfd_get_gp_value (output_bfd
);
4545 /* Initialize the minimal PLT entry. */
4547 plt_index
= (dyn_i
->plt_offset
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
4548 plt_sec
= ia64_info
->root
.splt
;
4549 loc
= plt_sec
->contents
+ dyn_i
->plt_offset
;
4551 memcpy (loc
, plt_min_entry
, PLT_MIN_ENTRY_SIZE
);
4552 ia64_elf_install_value (loc
, plt_index
, R_IA64_IMM22
);
4553 ia64_elf_install_value (loc
+2, -dyn_i
->plt_offset
, R_IA64_PCREL21B
);
4555 plt_addr
= (plt_sec
->output_section
->vma
4556 + plt_sec
->output_offset
4557 + dyn_i
->plt_offset
);
4558 pltoff_addr
= set_pltoff_entry (output_bfd
, info
, dyn_i
, plt_addr
, TRUE
);
4560 /* Initialize the FULL PLT entry, if needed. */
4561 if (dyn_i
->want_plt2
)
4563 loc
= plt_sec
->contents
+ dyn_i
->plt2_offset
;
4565 memcpy (loc
, plt_full_entry
, PLT_FULL_ENTRY_SIZE
);
4566 ia64_elf_install_value (loc
, pltoff_addr
- gp_val
, R_IA64_IMM22
);
4568 /* Mark the symbol as undefined, rather than as defined in the
4569 plt section. Leave the value alone. */
4570 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
4571 first place. But perhaps elflink.c did some for us. */
4572 if (!h
->def_regular
)
4573 sym
->st_shndx
= SHN_UNDEF
;
4576 /* Create the dynamic relocation. */
4577 outrel
.r_offset
= pltoff_addr
;
4578 if (bfd_little_endian (output_bfd
))
4579 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_IA64_IPLTLSB
);
4581 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_IA64_IPLTMSB
);
4582 outrel
.r_addend
= 0;
4584 /* This is fun. In the .IA_64.pltoff section, we've got entries
4585 that correspond both to real PLT entries, and those that
4586 happened to resolve to local symbols but need to be created
4587 to satisfy @pltoff relocations. The .rela.IA_64.pltoff
4588 relocations for the real PLT should come at the end of the
4589 section, so that they can be indexed by plt entry at runtime.
4591 We emitted all of the relocations for the non-PLT @pltoff
4592 entries during relocate_section. So we can consider the
4593 existing sec->reloc_count to be the base of the array of
4596 loc
= ia64_info
->rel_pltoff_sec
->contents
;
4597 loc
+= ((ia64_info
->rel_pltoff_sec
->reloc_count
+ plt_index
)
4598 * sizeof (ElfNN_External_Rela
));
4599 bfd_elfNN_swap_reloca_out (output_bfd
, &outrel
, loc
);
4602 /* Mark some specially defined symbols as absolute. */
4603 if (h
== ia64_info
->root
.hdynamic
4604 || h
== ia64_info
->root
.hgot
4605 || h
== ia64_info
->root
.hplt
)
4606 sym
->st_shndx
= SHN_ABS
;
4612 elfNN_ia64_finish_dynamic_sections (bfd
*abfd
,
4613 struct bfd_link_info
*info
)
4615 struct elfNN_ia64_link_hash_table
*ia64_info
;
4618 ia64_info
= elfNN_ia64_hash_table (info
);
4619 if (ia64_info
== NULL
)
4622 dynobj
= ia64_info
->root
.dynobj
;
4624 if (elf_hash_table (info
)->dynamic_sections_created
)
4626 ElfNN_External_Dyn
*dyncon
, *dynconend
;
4627 asection
*sdyn
, *sgotplt
;
4630 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
4631 sgotplt
= bfd_get_linker_section (dynobj
, ".got.plt");
4632 BFD_ASSERT (sdyn
!= NULL
);
4633 dyncon
= (ElfNN_External_Dyn
*) sdyn
->contents
;
4634 dynconend
= (ElfNN_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4636 gp_val
= _bfd_get_gp_value (abfd
);
4638 for (; dyncon
< dynconend
; dyncon
++)
4640 Elf_Internal_Dyn dyn
;
4642 bfd_elfNN_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4647 dyn
.d_un
.d_ptr
= gp_val
;
4651 dyn
.d_un
.d_val
= (ia64_info
->minplt_entries
4652 * sizeof (ElfNN_External_Rela
));
4656 /* See the comment above in finish_dynamic_symbol. */
4657 dyn
.d_un
.d_ptr
= (ia64_info
->rel_pltoff_sec
->output_section
->vma
4658 + ia64_info
->rel_pltoff_sec
->output_offset
4659 + (ia64_info
->rel_pltoff_sec
->reloc_count
4660 * sizeof (ElfNN_External_Rela
)));
4663 case DT_IA_64_PLT_RESERVE
:
4664 dyn
.d_un
.d_ptr
= (sgotplt
->output_section
->vma
4665 + sgotplt
->output_offset
);
4669 /* Do not have RELASZ include JMPREL. This makes things
4670 easier on ld.so. This is not what the rest of BFD set up. */
4671 dyn
.d_un
.d_val
-= (ia64_info
->minplt_entries
4672 * sizeof (ElfNN_External_Rela
));
4676 bfd_elfNN_swap_dyn_out (abfd
, &dyn
, dyncon
);
4679 /* Initialize the PLT0 entry. */
4680 if (ia64_info
->root
.splt
)
4682 bfd_byte
*loc
= ia64_info
->root
.splt
->contents
;
4685 memcpy (loc
, plt_header
, PLT_HEADER_SIZE
);
4687 pltres
= (sgotplt
->output_section
->vma
4688 + sgotplt
->output_offset
4691 ia64_elf_install_value (loc
+1, pltres
, R_IA64_GPREL22
);
4698 /* ELF file flag handling: */
4700 /* Function to keep IA-64 specific file flags. */
4702 elfNN_ia64_set_private_flags (bfd
*abfd
, flagword flags
)
4704 BFD_ASSERT (!elf_flags_init (abfd
)
4705 || elf_elfheader (abfd
)->e_flags
== flags
);
4707 elf_elfheader (abfd
)->e_flags
= flags
;
4708 elf_flags_init (abfd
) = TRUE
;
4712 /* Merge backend specific data from an object file to the output
4713 object file when linking. */
4715 elfNN_ia64_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
4717 bfd
*obfd
= info
->output_bfd
;
4720 bfd_boolean ok
= TRUE
;
4722 /* Don't even pretend to support mixed-format linking. */
4723 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4724 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4727 in_flags
= elf_elfheader (ibfd
)->e_flags
;
4728 out_flags
= elf_elfheader (obfd
)->e_flags
;
4730 if (! elf_flags_init (obfd
))
4732 elf_flags_init (obfd
) = TRUE
;
4733 elf_elfheader (obfd
)->e_flags
= in_flags
;
4735 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
4736 && bfd_get_arch_info (obfd
)->the_default
)
4738 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
4739 bfd_get_mach (ibfd
));
4745 /* Check flag compatibility. */
4746 if (in_flags
== out_flags
)
4749 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
4750 if (!(in_flags
& EF_IA_64_REDUCEDFP
) && (out_flags
& EF_IA_64_REDUCEDFP
))
4751 elf_elfheader (obfd
)->e_flags
&= ~EF_IA_64_REDUCEDFP
;
4753 if ((in_flags
& EF_IA_64_TRAPNIL
) != (out_flags
& EF_IA_64_TRAPNIL
))
4756 (_("%B: linking trap-on-NULL-dereference with non-trapping files"),
4759 bfd_set_error (bfd_error_bad_value
);
4762 if ((in_flags
& EF_IA_64_BE
) != (out_flags
& EF_IA_64_BE
))
4765 (_("%B: linking big-endian files with little-endian files"),
4768 bfd_set_error (bfd_error_bad_value
);
4771 if ((in_flags
& EF_IA_64_ABI64
) != (out_flags
& EF_IA_64_ABI64
))
4774 (_("%B: linking 64-bit files with 32-bit files"),
4777 bfd_set_error (bfd_error_bad_value
);
4780 if ((in_flags
& EF_IA_64_CONS_GP
) != (out_flags
& EF_IA_64_CONS_GP
))
4783 (_("%B: linking constant-gp files with non-constant-gp files"),
4786 bfd_set_error (bfd_error_bad_value
);
4789 if ((in_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
)
4790 != (out_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
4793 (_("%B: linking auto-pic files with non-auto-pic files"),
4796 bfd_set_error (bfd_error_bad_value
);
4804 elfNN_ia64_print_private_bfd_data (bfd
*abfd
, void * ptr
)
4806 FILE *file
= (FILE *) ptr
;
4807 flagword flags
= elf_elfheader (abfd
)->e_flags
;
4809 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
4811 fprintf (file
, "private flags = %s%s%s%s%s%s%s%s\n",
4812 (flags
& EF_IA_64_TRAPNIL
) ? "TRAPNIL, " : "",
4813 (flags
& EF_IA_64_EXT
) ? "EXT, " : "",
4814 (flags
& EF_IA_64_BE
) ? "BE, " : "LE, ",
4815 (flags
& EF_IA_64_REDUCEDFP
) ? "REDUCEDFP, " : "",
4816 (flags
& EF_IA_64_CONS_GP
) ? "CONS_GP, " : "",
4817 (flags
& EF_IA_64_NOFUNCDESC_CONS_GP
) ? "NOFUNCDESC_CONS_GP, " : "",
4818 (flags
& EF_IA_64_ABSOLUTE
) ? "ABSOLUTE, " : "",
4819 (flags
& EF_IA_64_ABI64
) ? "ABI64" : "ABI32");
4821 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
4825 static enum elf_reloc_type_class
4826 elfNN_ia64_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4827 const asection
*rel_sec ATTRIBUTE_UNUSED
,
4828 const Elf_Internal_Rela
*rela
)
4830 switch ((int) ELFNN_R_TYPE (rela
->r_info
))
4832 case R_IA64_REL32MSB
:
4833 case R_IA64_REL32LSB
:
4834 case R_IA64_REL64MSB
:
4835 case R_IA64_REL64LSB
:
4836 return reloc_class_relative
;
4837 case R_IA64_IPLTMSB
:
4838 case R_IA64_IPLTLSB
:
4839 return reloc_class_plt
;
4841 return reloc_class_copy
;
4843 return reloc_class_normal
;
4847 static const struct bfd_elf_special_section elfNN_ia64_special_sections
[] =
4849 { STRING_COMMA_LEN (".sbss"), -1, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_IA_64_SHORT
},
4850 { STRING_COMMA_LEN (".sdata"), -1, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_IA_64_SHORT
},
4851 { NULL
, 0, 0, 0, 0 }
4855 elfNN_ia64_object_p (bfd
*abfd
)
4858 asection
*group
, *unwi
, *unw
;
4861 char *unwi_name
, *unw_name
;
4864 if (abfd
->flags
& DYNAMIC
)
4867 /* Flags for fake group section. */
4868 flags
= (SEC_LINKER_CREATED
| SEC_GROUP
| SEC_LINK_ONCE
4871 /* We add a fake section group for each .gnu.linkonce.t.* section,
4872 which isn't in a section group, and its unwind sections. */
4873 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4875 if (elf_sec_group (sec
) == NULL
4876 && ((sec
->flags
& (SEC_LINK_ONCE
| SEC_CODE
| SEC_GROUP
))
4877 == (SEC_LINK_ONCE
| SEC_CODE
))
4878 && CONST_STRNEQ (sec
->name
, ".gnu.linkonce.t."))
4880 name
= sec
->name
+ 16;
4882 amt
= strlen (name
) + sizeof (".gnu.linkonce.ia64unwi.");
4883 unwi_name
= bfd_alloc (abfd
, amt
);
4887 strcpy (stpcpy (unwi_name
, ".gnu.linkonce.ia64unwi."), name
);
4888 unwi
= bfd_get_section_by_name (abfd
, unwi_name
);
4890 amt
= strlen (name
) + sizeof (".gnu.linkonce.ia64unw.");
4891 unw_name
= bfd_alloc (abfd
, amt
);
4895 strcpy (stpcpy (unw_name
, ".gnu.linkonce.ia64unw."), name
);
4896 unw
= bfd_get_section_by_name (abfd
, unw_name
);
4898 /* We need to create a fake group section for it and its
4900 group
= bfd_make_section_anyway_with_flags (abfd
, name
,
4905 /* Move the fake group section to the beginning. */
4906 bfd_section_list_remove (abfd
, group
);
4907 bfd_section_list_prepend (abfd
, group
);
4909 elf_next_in_group (group
) = sec
;
4911 elf_group_name (sec
) = name
;
4912 elf_next_in_group (sec
) = sec
;
4913 elf_sec_group (sec
) = group
;
4917 elf_group_name (unwi
) = name
;
4918 elf_next_in_group (unwi
) = sec
;
4919 elf_next_in_group (sec
) = unwi
;
4920 elf_sec_group (unwi
) = group
;
4925 elf_group_name (unw
) = name
;
4928 elf_next_in_group (unw
) = elf_next_in_group (unwi
);
4929 elf_next_in_group (unwi
) = unw
;
4933 elf_next_in_group (unw
) = sec
;
4934 elf_next_in_group (sec
) = unw
;
4936 elf_sec_group (unw
) = group
;
4939 /* Fake SHT_GROUP section header. */
4940 elf_section_data (group
)->this_hdr
.bfd_section
= group
;
4941 elf_section_data (group
)->this_hdr
.sh_type
= SHT_GROUP
;
4948 elfNN_ia64_hpux_vec (const bfd_target
*vec
)
4950 extern const bfd_target ia64_elfNN_hpux_be_vec
;
4951 return (vec
== &ia64_elfNN_hpux_be_vec
);
4955 elfNN_hpux_post_process_headers (bfd
*abfd
,
4956 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
4958 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
4960 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
4961 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 1;
4965 elfNN_hpux_backend_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
4966 asection
*sec
, int *retval
)
4968 if (bfd_is_com_section (sec
))
4970 *retval
= SHN_IA_64_ANSI_COMMON
;
4977 elfNN_hpux_backend_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
4980 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
4982 switch (elfsym
->internal_elf_sym
.st_shndx
)
4984 case SHN_IA_64_ANSI_COMMON
:
4985 asym
->section
= bfd_com_section_ptr
;
4986 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
4987 asym
->flags
&= ~BSF_GLOBAL
;
4992 #define TARGET_LITTLE_SYM ia64_elfNN_le_vec
4993 #define TARGET_LITTLE_NAME "elfNN-ia64-little"
4994 #define TARGET_BIG_SYM ia64_elfNN_be_vec
4995 #define TARGET_BIG_NAME "elfNN-ia64-big"
4996 #define ELF_ARCH bfd_arch_ia64
4997 #define ELF_TARGET_ID IA64_ELF_DATA
4998 #define ELF_MACHINE_CODE EM_IA_64
4999 #define ELF_MACHINE_ALT1 1999 /* EAS2.3 */
5000 #define ELF_MACHINE_ALT2 1998 /* EAS2.2 */
5001 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
5002 #define ELF_COMMONPAGESIZE 0x4000 /* 16KB */
5004 #define elf_backend_section_from_shdr \
5005 elfNN_ia64_section_from_shdr
5006 #define elf_backend_section_flags \
5007 elfNN_ia64_section_flags
5008 #define elf_backend_fake_sections \
5009 elfNN_ia64_fake_sections
5010 #define elf_backend_final_write_processing \
5011 elfNN_ia64_final_write_processing
5012 #define elf_backend_add_symbol_hook \
5013 elfNN_ia64_add_symbol_hook
5014 #define elf_backend_additional_program_headers \
5015 elfNN_ia64_additional_program_headers
5016 #define elf_backend_modify_segment_map \
5017 elfNN_ia64_modify_segment_map
5018 #define elf_backend_modify_program_headers \
5019 elfNN_ia64_modify_program_headers
5020 #define elf_info_to_howto \
5021 elfNN_ia64_info_to_howto
5023 #define bfd_elfNN_bfd_reloc_type_lookup \
5024 ia64_elf_reloc_type_lookup
5025 #define bfd_elfNN_bfd_reloc_name_lookup \
5026 ia64_elf_reloc_name_lookup
5027 #define bfd_elfNN_bfd_is_local_label_name \
5028 elfNN_ia64_is_local_label_name
5029 #define bfd_elfNN_bfd_relax_section \
5030 elfNN_ia64_relax_section
5032 #define elf_backend_object_p \
5035 /* Stuff for the BFD linker: */
5036 #define bfd_elfNN_bfd_link_hash_table_create \
5037 elfNN_ia64_hash_table_create
5038 #define elf_backend_create_dynamic_sections \
5039 elfNN_ia64_create_dynamic_sections
5040 #define elf_backend_check_relocs \
5041 elfNN_ia64_check_relocs
5042 #define elf_backend_adjust_dynamic_symbol \
5043 elfNN_ia64_adjust_dynamic_symbol
5044 #define elf_backend_size_dynamic_sections \
5045 elfNN_ia64_size_dynamic_sections
5046 #define elf_backend_omit_section_dynsym \
5047 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5048 #define elf_backend_relocate_section \
5049 elfNN_ia64_relocate_section
5050 #define elf_backend_finish_dynamic_symbol \
5051 elfNN_ia64_finish_dynamic_symbol
5052 #define elf_backend_finish_dynamic_sections \
5053 elfNN_ia64_finish_dynamic_sections
5054 #define bfd_elfNN_bfd_final_link \
5055 elfNN_ia64_final_link
5057 #define bfd_elfNN_bfd_merge_private_bfd_data \
5058 elfNN_ia64_merge_private_bfd_data
5059 #define bfd_elfNN_bfd_set_private_flags \
5060 elfNN_ia64_set_private_flags
5061 #define bfd_elfNN_bfd_print_private_bfd_data \
5062 elfNN_ia64_print_private_bfd_data
5064 #define elf_backend_plt_readonly 1
5065 #define elf_backend_want_plt_sym 0
5066 #define elf_backend_plt_alignment 5
5067 #define elf_backend_got_header_size 0
5068 #define elf_backend_want_got_plt 1
5069 #define elf_backend_may_use_rel_p 1
5070 #define elf_backend_may_use_rela_p 1
5071 #define elf_backend_default_use_rela_p 1
5072 #define elf_backend_want_dynbss 0
5073 #define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect
5074 #define elf_backend_hide_symbol elfNN_ia64_hash_hide_symbol
5075 #define elf_backend_fixup_symbol _bfd_elf_link_hash_fixup_symbol
5076 #define elf_backend_reloc_type_class elfNN_ia64_reloc_type_class
5077 #define elf_backend_rela_normal 1
5078 #define elf_backend_special_sections elfNN_ia64_special_sections
5079 #define elf_backend_default_execstack 0
5081 /* FIXME: PR 290: The Intel C compiler generates SHT_IA_64_UNWIND with
5082 SHF_LINK_ORDER. But it doesn't set the sh_link or sh_info fields.
5083 We don't want to flood users with so many error messages. We turn
5084 off the warning for now. It will be turned on later when the Intel
5085 compiler is fixed. */
5086 #define elf_backend_link_order_error_handler NULL
5088 #include "elfNN-target.h"
5090 /* HPUX-specific vectors. */
5092 #undef TARGET_LITTLE_SYM
5093 #undef TARGET_LITTLE_NAME
5094 #undef TARGET_BIG_SYM
5095 #define TARGET_BIG_SYM ia64_elfNN_hpux_be_vec
5096 #undef TARGET_BIG_NAME
5097 #define TARGET_BIG_NAME "elfNN-ia64-hpux-big"
5099 /* These are HP-UX specific functions. */
5101 #undef elf_backend_post_process_headers
5102 #define elf_backend_post_process_headers elfNN_hpux_post_process_headers
5104 #undef elf_backend_section_from_bfd_section
5105 #define elf_backend_section_from_bfd_section elfNN_hpux_backend_section_from_bfd_section
5107 #undef elf_backend_symbol_processing
5108 #define elf_backend_symbol_processing elfNN_hpux_backend_symbol_processing
5110 #undef elf_backend_want_p_paddr_set_to_zero
5111 #define elf_backend_want_p_paddr_set_to_zero 1
5113 #undef ELF_COMMONPAGESIZE
5115 #define ELF_OSABI ELFOSABI_HPUX
5118 #define elfNN_bed elfNN_ia64_hpux_bed
5120 #include "elfNN-target.h"