1 /* IA-64 support for 64-bit ELF
2 Copyright (C) 1998-2021 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 "elfxx-ia64.h"
35 #define LOG_SECTION_ALIGN 3
39 #define LOG_SECTION_ALIGN 2
42 #define is_ia64_elf(bfd) \
43 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
44 && elf_object_id (bfd) == IA64_ELF_DATA)
46 typedef struct bfd_hash_entry
*(*new_hash_entry_func
)
47 (struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *);
49 /* In dynamically (linker-) created sections, we generally need to keep track
50 of the place a symbol or expression got allocated to. This is done via hash
51 tables that store entries of the following type. */
53 struct elfNN_ia64_dyn_sym_info
55 /* The addend for which this entry is relevant. */
60 bfd_vma pltoff_offset
;
64 bfd_vma dtpmod_offset
;
65 bfd_vma dtprel_offset
;
67 /* The symbol table entry, if any, that this was derived from. */
68 struct elf_link_hash_entry
*h
;
70 /* Used to count non-got, non-plt relocations for delayed sizing
71 of relocation sections. */
72 struct elfNN_ia64_dyn_reloc_entry
74 struct elfNN_ia64_dyn_reloc_entry
*next
;
79 /* Is this reloc against readonly section? */
83 /* TRUE when the section contents have been updated. */
84 unsigned got_done
: 1;
85 unsigned fptr_done
: 1;
86 unsigned pltoff_done
: 1;
87 unsigned tprel_done
: 1;
88 unsigned dtpmod_done
: 1;
89 unsigned dtprel_done
: 1;
91 /* TRUE for the different kinds of linker data we want created. */
92 unsigned want_got
: 1;
93 unsigned want_gotx
: 1;
94 unsigned want_fptr
: 1;
95 unsigned want_ltoff_fptr
: 1;
96 unsigned want_plt
: 1;
97 unsigned want_plt2
: 1;
98 unsigned want_pltoff
: 1;
99 unsigned want_tprel
: 1;
100 unsigned want_dtpmod
: 1;
101 unsigned want_dtprel
: 1;
104 struct elfNN_ia64_local_hash_entry
108 /* The number of elements in elfNN_ia64_dyn_sym_info array. */
110 /* The number of sorted elements in elfNN_ia64_dyn_sym_info array. */
111 unsigned int sorted_count
;
112 /* The size of elfNN_ia64_dyn_sym_info array. */
114 /* The array of elfNN_ia64_dyn_sym_info. */
115 struct elfNN_ia64_dyn_sym_info
*info
;
117 /* TRUE if this hash entry's addends was translated for
118 SHF_MERGE optimization. */
119 unsigned sec_merge_done
: 1;
122 struct elfNN_ia64_link_hash_entry
124 struct elf_link_hash_entry root
;
125 /* The number of elements in elfNN_ia64_dyn_sym_info array. */
127 /* The number of sorted elements in elfNN_ia64_dyn_sym_info array. */
128 unsigned int sorted_count
;
129 /* The size of elfNN_ia64_dyn_sym_info array. */
131 /* The array of elfNN_ia64_dyn_sym_info. */
132 struct elfNN_ia64_dyn_sym_info
*info
;
135 struct elfNN_ia64_link_hash_table
137 /* The main hash table. */
138 struct elf_link_hash_table root
;
140 asection
*fptr_sec
; /* Function descriptor table (or NULL). */
141 asection
*rel_fptr_sec
; /* Dynamic relocation section for same. */
142 asection
*pltoff_sec
; /* Private descriptors for plt (or NULL). */
143 asection
*rel_pltoff_sec
; /* Dynamic relocation section for same. */
145 bfd_size_type minplt_entries
; /* Number of minplt entries. */
146 unsigned self_dtpmod_done
: 1;/* Has self DTPMOD entry been finished? */
147 bfd_vma self_dtpmod_offset
; /* .got offset to self DTPMOD entry. */
148 /* There are maybe R_IA64_GPREL22 relocations, including those
149 optimized from R_IA64_LTOFF22X, against non-SHF_IA_64_SHORT
150 sections. We need to record those sections so that we can choose
151 a proper GP to cover all R_IA64_GPREL22 relocations. */
152 asection
*max_short_sec
; /* Maximum short output section. */
153 bfd_vma max_short_offset
; /* Maximum short offset. */
154 asection
*min_short_sec
; /* Minimum short output section. */
155 bfd_vma min_short_offset
; /* Minimum short offset. */
157 htab_t loc_hash_table
;
158 void *loc_hash_memory
;
161 struct elfNN_ia64_allocate_data
163 struct bfd_link_info
*info
;
165 bfd_boolean only_got
;
168 #define elfNN_ia64_hash_table(p) \
169 ((is_elf_hash_table ((p)->hash) \
170 && elf_hash_table_id (elf_hash_table (p)) == IA64_ELF_DATA) \
171 ? (struct elfNN_ia64_link_hash_table *) (p)->hash : NULL)
173 static struct elfNN_ia64_dyn_sym_info
* get_dyn_sym_info
174 (struct elfNN_ia64_link_hash_table
*ia64_info
,
175 struct elf_link_hash_entry
*h
,
176 bfd
*abfd
, const Elf_Internal_Rela
*rel
, bfd_boolean create
);
177 static bfd_boolean elfNN_ia64_dynamic_symbol_p
178 (struct elf_link_hash_entry
*h
, struct bfd_link_info
*info
, int);
179 static bfd_boolean elfNN_ia64_choose_gp
180 (bfd
*abfd
, struct bfd_link_info
*info
, bfd_boolean final
);
181 static void elfNN_ia64_dyn_sym_traverse
182 (struct elfNN_ia64_link_hash_table
*ia64_info
,
183 bfd_boolean (*func
) (struct elfNN_ia64_dyn_sym_info
*, void *),
185 static bfd_boolean allocate_global_data_got
186 (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
);
187 static bfd_boolean allocate_global_fptr_got
188 (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
);
189 static bfd_boolean allocate_local_got
190 (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
);
191 static bfd_boolean elfNN_ia64_hpux_vec
192 (const bfd_target
*vec
);
193 static bfd_boolean allocate_dynrel_entries
194 (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
);
195 static asection
*get_pltoff
196 (bfd
*abfd
, struct bfd_link_info
*info
,
197 struct elfNN_ia64_link_hash_table
*ia64_info
);
199 /* ia64-specific relocation. */
201 /* Given a ELF reloc, return the matching HOWTO structure. */
204 elfNN_ia64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
206 Elf_Internal_Rela
*elf_reloc
)
208 unsigned int r_type
= ELF32_R_TYPE (elf_reloc
->r_info
);
210 bfd_reloc
->howto
= ia64_elf_lookup_howto (r_type
);
211 if (bfd_reloc
->howto
== NULL
)
213 /* xgettext:c-format */
214 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
216 bfd_set_error (bfd_error_bad_value
);
223 #define PLT_HEADER_SIZE (3 * 16)
224 #define PLT_MIN_ENTRY_SIZE (1 * 16)
225 #define PLT_FULL_ENTRY_SIZE (2 * 16)
226 #define PLT_RESERVED_WORDS 3
228 static const bfd_byte plt_header
[PLT_HEADER_SIZE
] =
230 0x0b, 0x10, 0x00, 0x1c, 0x00, 0x21, /* [MMI] mov r2=r14;; */
231 0xe0, 0x00, 0x08, 0x00, 0x48, 0x00, /* addl r14=0,r2 */
232 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
233 0x0b, 0x80, 0x20, 0x1c, 0x18, 0x14, /* [MMI] ld8 r16=[r14],8;; */
234 0x10, 0x41, 0x38, 0x30, 0x28, 0x00, /* ld8 r17=[r14],8 */
235 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
236 0x11, 0x08, 0x00, 0x1c, 0x18, 0x10, /* [MIB] ld8 r1=[r14] */
237 0x60, 0x88, 0x04, 0x80, 0x03, 0x00, /* mov b6=r17 */
238 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
241 static const bfd_byte plt_min_entry
[PLT_MIN_ENTRY_SIZE
] =
243 0x11, 0x78, 0x00, 0x00, 0x00, 0x24, /* [MIB] mov r15=0 */
244 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, /* nop.i 0x0 */
245 0x00, 0x00, 0x00, 0x40 /* br.few 0 <PLT0>;; */
248 static const bfd_byte plt_full_entry
[PLT_FULL_ENTRY_SIZE
] =
250 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
251 0x00, 0x41, 0x3c, 0x70, 0x29, 0xc0, /* ld8.acq r16=[r15],8*/
252 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
253 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
254 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
255 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
258 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
260 static const bfd_byte oor_brl
[16] =
262 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
263 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;; */
264 0x00, 0x00, 0x00, 0xc0
267 static const bfd_byte oor_ip
[48] =
269 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
270 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, /* movl r15=0 */
271 0x01, 0x00, 0x00, 0x60,
272 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MII] nop.m 0 */
273 0x00, 0x01, 0x00, 0x60, 0x00, 0x00, /* mov r16=ip;; */
274 0xf2, 0x80, 0x00, 0x80, /* add r16=r15,r16;; */
275 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MIB] nop.m 0 */
276 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
277 0x60, 0x00, 0x80, 0x00 /* br b6;; */
280 static size_t oor_branch_size
= sizeof (oor_brl
);
283 bfd_elfNN_ia64_after_parse (int itanium
)
285 oor_branch_size
= itanium
? sizeof (oor_ip
) : sizeof (oor_brl
);
289 /* Rename some of the generic section flags to better document how they
291 #define skip_relax_pass_0 sec_flg0
292 #define skip_relax_pass_1 sec_flg1
294 /* These functions do relaxation for IA-64 ELF. */
297 elfNN_ia64_update_short_info (asection
*sec
, bfd_vma offset
,
298 struct elfNN_ia64_link_hash_table
*ia64_info
)
300 /* Skip ABS and SHF_IA_64_SHORT sections. */
301 if (sec
== bfd_abs_section_ptr
302 || (sec
->flags
& SEC_SMALL_DATA
) != 0)
305 if (!ia64_info
->min_short_sec
)
307 ia64_info
->max_short_sec
= sec
;
308 ia64_info
->max_short_offset
= offset
;
309 ia64_info
->min_short_sec
= sec
;
310 ia64_info
->min_short_offset
= offset
;
312 else if (sec
== ia64_info
->max_short_sec
313 && offset
> ia64_info
->max_short_offset
)
314 ia64_info
->max_short_offset
= offset
;
315 else if (sec
== ia64_info
->min_short_sec
316 && offset
< ia64_info
->min_short_offset
)
317 ia64_info
->min_short_offset
= offset
;
318 else if (sec
->output_section
->vma
319 > ia64_info
->max_short_sec
->vma
)
321 ia64_info
->max_short_sec
= sec
;
322 ia64_info
->max_short_offset
= offset
;
324 else if (sec
->output_section
->vma
325 < ia64_info
->min_short_sec
->vma
)
327 ia64_info
->min_short_sec
= sec
;
328 ia64_info
->min_short_offset
= offset
;
333 elfNN_ia64_relax_section (bfd
*abfd
, asection
*sec
,
334 struct bfd_link_info
*link_info
,
339 struct one_fixup
*next
;
345 Elf_Internal_Shdr
*symtab_hdr
;
346 Elf_Internal_Rela
*internal_relocs
;
347 Elf_Internal_Rela
*irel
, *irelend
;
349 Elf_Internal_Sym
*isymbuf
= NULL
;
350 struct elfNN_ia64_link_hash_table
*ia64_info
;
351 struct one_fixup
*fixups
= NULL
;
352 bfd_boolean changed_contents
= FALSE
;
353 bfd_boolean changed_relocs
= FALSE
;
354 bfd_boolean changed_got
= FALSE
;
355 bfd_boolean skip_relax_pass_0
= TRUE
;
356 bfd_boolean skip_relax_pass_1
= TRUE
;
359 /* Assume we're not going to change any sizes, and we'll only need
363 if (bfd_link_relocatable (link_info
))
364 (*link_info
->callbacks
->einfo
)
365 (_("%P%F: --relax and -r may not be used together\n"));
367 /* Don't even try to relax for non-ELF outputs. */
368 if (!is_elf_hash_table (link_info
->hash
))
371 /* Nothing to do if there are no relocations or there is no need for
373 if ((sec
->flags
& SEC_RELOC
) == 0
374 || sec
->reloc_count
== 0
375 || (link_info
->relax_pass
== 0 && sec
->skip_relax_pass_0
)
376 || (link_info
->relax_pass
== 1 && sec
->skip_relax_pass_1
))
379 ia64_info
= elfNN_ia64_hash_table (link_info
);
380 if (ia64_info
== NULL
)
383 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
385 /* Load the relocations for this section. */
386 internal_relocs
= (_bfd_elf_link_read_relocs
387 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
388 link_info
->keep_memory
));
389 if (internal_relocs
== NULL
)
392 irelend
= internal_relocs
+ sec
->reloc_count
;
394 /* Get the section contents. */
395 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
396 contents
= elf_section_data (sec
)->this_hdr
.contents
;
399 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
403 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
405 unsigned long r_type
= ELFNN_R_TYPE (irel
->r_info
);
406 bfd_vma symaddr
, reladdr
, trampoff
, toff
, roff
;
410 bfd_boolean is_branch
;
411 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
416 case R_IA64_PCREL21B
:
417 case R_IA64_PCREL21BI
:
418 case R_IA64_PCREL21M
:
419 case R_IA64_PCREL21F
:
420 /* In pass 1, all br relaxations are done. We can skip it. */
421 if (link_info
->relax_pass
== 1)
423 skip_relax_pass_0
= FALSE
;
427 case R_IA64_PCREL60B
:
428 /* We can't optimize brl to br in pass 0 since br relaxations
429 will increase the code size. Defer it to pass 1. */
430 if (link_info
->relax_pass
== 0)
432 skip_relax_pass_1
= FALSE
;
439 /* Update max_short_sec/min_short_sec. */
441 case R_IA64_LTOFF22X
:
443 /* We can't relax ldx/mov in pass 0 since br relaxations will
444 increase the code size. Defer it to pass 1. */
445 if (link_info
->relax_pass
== 0)
447 skip_relax_pass_1
= FALSE
;
457 /* Get the value of the symbol referred to by the reloc. */
458 if (ELFNN_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
460 /* A local symbol. */
461 Elf_Internal_Sym
*isym
;
463 /* Read this BFD's local symbols. */
466 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
468 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
469 symtab_hdr
->sh_info
, 0,
475 isym
= isymbuf
+ ELFNN_R_SYM (irel
->r_info
);
476 if (isym
->st_shndx
== SHN_UNDEF
)
477 continue; /* We can't do anything with undefined symbols. */
478 else if (isym
->st_shndx
== SHN_ABS
)
479 tsec
= bfd_abs_section_ptr
;
480 else if (isym
->st_shndx
== SHN_COMMON
)
481 tsec
= bfd_com_section_ptr
;
482 else if (isym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
483 tsec
= bfd_com_section_ptr
;
485 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
487 toff
= isym
->st_value
;
488 dyn_i
= get_dyn_sym_info (ia64_info
, NULL
, abfd
, irel
, FALSE
);
489 symtype
= ELF_ST_TYPE (isym
->st_info
);
494 struct elf_link_hash_entry
*h
;
496 indx
= ELFNN_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
497 h
= elf_sym_hashes (abfd
)[indx
];
498 BFD_ASSERT (h
!= NULL
);
500 while (h
->root
.type
== bfd_link_hash_indirect
501 || h
->root
.type
== bfd_link_hash_warning
)
502 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
504 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, irel
, FALSE
);
506 /* For branches to dynamic symbols, we're interested instead
507 in a branch to the PLT entry. */
508 if (is_branch
&& dyn_i
&& dyn_i
->want_plt2
)
510 /* Internal branches shouldn't be sent to the PLT.
511 Leave this for now and we'll give an error later. */
512 if (r_type
!= R_IA64_PCREL21B
)
515 tsec
= ia64_info
->root
.splt
;
516 toff
= dyn_i
->plt2_offset
;
517 BFD_ASSERT (irel
->r_addend
== 0);
520 /* Can't do anything else with dynamic symbols. */
521 else if (elfNN_ia64_dynamic_symbol_p (h
, link_info
, r_type
))
526 /* We can't do anything with undefined symbols. */
527 if (h
->root
.type
== bfd_link_hash_undefined
528 || h
->root
.type
== bfd_link_hash_undefweak
)
531 tsec
= h
->root
.u
.def
.section
;
532 toff
= h
->root
.u
.def
.value
;
538 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
540 /* At this stage in linking, no SEC_MERGE symbol has been
541 adjusted, so all references to such symbols need to be
542 passed through _bfd_merged_section_offset. (Later, in
543 relocate_section, all SEC_MERGE symbols *except* for
544 section symbols have been adjusted.)
546 gas may reduce relocations against symbols in SEC_MERGE
547 sections to a relocation against the section symbol when
548 the original addend was zero. When the reloc is against
549 a section symbol we should include the addend in the
550 offset passed to _bfd_merged_section_offset, since the
551 location of interest is the original symbol. On the
552 other hand, an access to "sym+addend" where "sym" is not
553 a section symbol should not include the addend; Such an
554 access is presumed to be an offset from "sym"; The
555 location of interest is just "sym". */
556 if (symtype
== STT_SECTION
)
557 toff
+= irel
->r_addend
;
559 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
560 elf_section_data (tsec
)->sec_info
,
563 if (symtype
!= STT_SECTION
)
564 toff
+= irel
->r_addend
;
567 toff
+= irel
->r_addend
;
569 symaddr
= tsec
->output_section
->vma
+ tsec
->output_offset
+ toff
;
571 roff
= irel
->r_offset
;
575 bfd_signed_vma offset
;
577 reladdr
= (sec
->output_section
->vma
579 + roff
) & (bfd_vma
) -4;
581 /* The .plt section is aligned at 32byte and the .text section
582 is aligned at 64byte. The .text section is right after the
583 .plt section. After the first relaxation pass, linker may
584 increase the gap between the .plt and .text sections up
585 to 32byte. We assume linker will always insert 32byte
586 between the .plt and .text sections after the first
588 if (tsec
== ia64_info
->root
.splt
)
589 offset
= -0x1000000 + 32;
593 /* If the branch is in range, no need to do anything. */
594 if ((bfd_signed_vma
) (symaddr
- reladdr
) >= offset
595 && (bfd_signed_vma
) (symaddr
- reladdr
) <= 0x0FFFFF0)
597 /* If the 60-bit branch is in 21-bit range, optimize it. */
598 if (r_type
== R_IA64_PCREL60B
)
600 ia64_elf_relax_brl (contents
, roff
);
603 = ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
606 /* If the original relocation offset points to slot
607 1, change it to slot 2. */
608 if ((irel
->r_offset
& 3) == 1)
611 changed_contents
= TRUE
;
612 changed_relocs
= TRUE
;
617 else if (r_type
== R_IA64_PCREL60B
)
619 else if (ia64_elf_relax_br (contents
, roff
))
622 = ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
625 /* Make the relocation offset point to slot 1. */
626 irel
->r_offset
= (irel
->r_offset
& ~((bfd_vma
) 0x3)) + 1;
628 changed_contents
= TRUE
;
629 changed_relocs
= TRUE
;
633 /* We can't put a trampoline in a .init/.fini section. Issue
635 if (strcmp (sec
->output_section
->name
, ".init") == 0
636 || strcmp (sec
->output_section
->name
, ".fini") == 0)
639 /* xgettext:c-format */
640 (_("%pB: can't relax br at %#" PRIx64
" in section `%pA';"
641 " please use brl or indirect branch"),
642 sec
->owner
, (uint64_t) roff
, sec
);
643 bfd_set_error (bfd_error_bad_value
);
647 /* If the branch and target are in the same section, you've
648 got one honking big section and we can't help you unless
649 you are branching backwards. You'll get an error message
651 if (tsec
== sec
&& toff
> roff
)
654 /* Look for an existing fixup to this address. */
655 for (f
= fixups
; f
; f
= f
->next
)
656 if (f
->tsec
== tsec
&& f
->toff
== toff
)
661 /* Two alternatives: If it's a branch to a PLT entry, we can
662 make a copy of the FULL_PLT entry. Otherwise, we'll have
663 to use a `brl' insn to get where we're going. */
667 if (tsec
== ia64_info
->root
.splt
)
668 size
= sizeof (plt_full_entry
);
670 size
= oor_branch_size
;
672 /* Resize the current section to make room for the new branch. */
673 trampoff
= (sec
->size
+ 15) & (bfd_vma
) -16;
675 /* If trampoline is out of range, there is nothing we
677 offset
= trampoff
- (roff
& (bfd_vma
) -4);
678 if (offset
< -0x1000000 || offset
> 0x0FFFFF0)
681 amt
= trampoff
+ size
;
682 contents
= (bfd_byte
*) bfd_realloc (contents
, amt
);
683 if (contents
== NULL
)
687 if (tsec
== ia64_info
->root
.splt
)
689 memcpy (contents
+ trampoff
, plt_full_entry
, size
);
691 /* Hijack the old relocation for use as the PLTOFF reloc. */
692 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
694 irel
->r_offset
= trampoff
;
698 if (size
== sizeof (oor_ip
))
700 memcpy (contents
+ trampoff
, oor_ip
, size
);
701 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
703 irel
->r_addend
-= 16;
704 irel
->r_offset
= trampoff
+ 2;
708 memcpy (contents
+ trampoff
, oor_brl
, size
);
709 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
711 irel
->r_offset
= trampoff
+ 2;
716 /* Record the fixup so we don't do it again this section. */
717 f
= (struct one_fixup
*)
718 bfd_malloc ((bfd_size_type
) sizeof (*f
));
722 f
->trampoff
= trampoff
;
727 /* If trampoline is out of range, there is nothing we
729 offset
= f
->trampoff
- (roff
& (bfd_vma
) -4);
730 if (offset
< -0x1000000 || offset
> 0x0FFFFF0)
733 /* Nop out the reloc, since we're finalizing things here. */
734 irel
->r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
737 /* Fix up the existing branch to hit the trampoline. */
738 if (ia64_elf_install_value (contents
+ roff
, offset
, r_type
)
742 changed_contents
= TRUE
;
743 changed_relocs
= TRUE
;
750 bfd
*obfd
= sec
->output_section
->owner
;
751 gp
= _bfd_get_gp_value (obfd
);
754 if (!elfNN_ia64_choose_gp (obfd
, link_info
, FALSE
))
756 gp
= _bfd_get_gp_value (obfd
);
760 /* If the data is out of range, do nothing. */
761 if ((bfd_signed_vma
) (symaddr
- gp
) >= 0x200000
762 ||(bfd_signed_vma
) (symaddr
- gp
) < -0x200000)
765 if (r_type
== R_IA64_GPREL22
)
766 elfNN_ia64_update_short_info (tsec
->output_section
,
767 tsec
->output_offset
+ toff
,
769 else if (r_type
== R_IA64_LTOFF22X
)
771 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
773 changed_relocs
= TRUE
;
774 if (dyn_i
->want_gotx
)
776 dyn_i
->want_gotx
= 0;
777 changed_got
|= !dyn_i
->want_got
;
780 elfNN_ia64_update_short_info (tsec
->output_section
,
781 tsec
->output_offset
+ toff
,
786 ia64_elf_relax_ldxmov (contents
, roff
);
787 irel
->r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
788 changed_contents
= TRUE
;
789 changed_relocs
= TRUE
;
794 /* ??? If we created fixups, this may push the code segment large
795 enough that the data segment moves, which will change the GP.
796 Reset the GP so that we re-calculate next round. We need to
797 do this at the _beginning_ of the next round; now will not do. */
799 /* Clean up and go home. */
802 struct one_fixup
*f
= fixups
;
803 fixups
= fixups
->next
;
808 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
810 if (! link_info
->keep_memory
)
814 /* Cache the symbols for elf_link_input_bfd. */
815 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
820 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
822 if (!changed_contents
&& !link_info
->keep_memory
)
826 /* Cache the section contents for elf_link_input_bfd. */
827 elf_section_data (sec
)->this_hdr
.contents
= contents
;
831 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
834 free (internal_relocs
);
836 elf_section_data (sec
)->relocs
= internal_relocs
;
841 struct elfNN_ia64_allocate_data data
;
842 data
.info
= link_info
;
844 ia64_info
->self_dtpmod_offset
= (bfd_vma
) -1;
846 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_data_got
, &data
);
847 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_fptr_got
, &data
);
848 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_local_got
, &data
);
849 ia64_info
->root
.sgot
->size
= data
.ofs
;
851 if (ia64_info
->root
.dynamic_sections_created
852 && ia64_info
->root
.srelgot
!= NULL
)
854 /* Resize .rela.got. */
855 ia64_info
->root
.srelgot
->size
= 0;
856 if (bfd_link_pic (link_info
)
857 && ia64_info
->self_dtpmod_offset
!= (bfd_vma
) -1)
858 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
859 data
.only_got
= TRUE
;
860 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_dynrel_entries
,
865 if (link_info
->relax_pass
== 0)
867 /* Pass 0 is only needed to relax br. */
868 sec
->skip_relax_pass_0
= skip_relax_pass_0
;
869 sec
->skip_relax_pass_1
= skip_relax_pass_1
;
872 *again
= changed_contents
|| changed_relocs
;
876 if ((unsigned char *) isymbuf
!= symtab_hdr
->contents
)
878 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
880 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
881 free (internal_relocs
);
884 #undef skip_relax_pass_0
885 #undef skip_relax_pass_1
887 /* Return TRUE if NAME is an unwind table section name. */
889 static inline bfd_boolean
890 is_unwind_section_name (bfd
*abfd
, const char *name
)
892 if (elfNN_ia64_hpux_vec (abfd
->xvec
)
893 && !strcmp (name
, ELF_STRING_ia64_unwind_hdr
))
896 return ((startswith (name
, ELF_STRING_ia64_unwind
)
897 && ! startswith (name
, ELF_STRING_ia64_unwind_info
))
898 || startswith (name
, ELF_STRING_ia64_unwind_once
));
901 /* Handle an IA-64 specific section when reading an object file. This
902 is called when bfd_section_from_shdr finds a section with an unknown
906 elfNN_ia64_section_from_shdr (bfd
*abfd
,
907 Elf_Internal_Shdr
*hdr
,
911 /* There ought to be a place to keep ELF backend specific flags, but
912 at the moment there isn't one. We just keep track of the
913 sections by their name, instead. Fortunately, the ABI gives
914 suggested names for all the MIPS specific sections, so we will
915 probably get away with this. */
916 switch (hdr
->sh_type
)
918 case SHT_IA_64_UNWIND
:
919 case SHT_IA_64_HP_OPT_ANOT
:
923 if (strcmp (name
, ELF_STRING_ia64_archext
) != 0)
931 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
937 /* Convert IA-64 specific section flags to bfd internal section flags. */
939 /* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
943 elfNN_ia64_section_flags (const Elf_Internal_Shdr
*hdr
)
945 if (hdr
->sh_flags
& SHF_IA_64_SHORT
)
946 hdr
->bfd_section
->flags
|= SEC_SMALL_DATA
;
951 /* Set the correct type for an IA-64 ELF section. We do this by the
952 section name, which is a hack, but ought to work. */
955 elfNN_ia64_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
960 name
= bfd_section_name (sec
);
962 if (is_unwind_section_name (abfd
, name
))
964 /* We don't have the sections numbered at this point, so sh_info
965 is set later, in elfNN_ia64_final_write_processing. */
966 hdr
->sh_type
= SHT_IA_64_UNWIND
;
967 hdr
->sh_flags
|= SHF_LINK_ORDER
;
969 else if (strcmp (name
, ELF_STRING_ia64_archext
) == 0)
970 hdr
->sh_type
= SHT_IA_64_EXT
;
971 else if (strcmp (name
, ".HP.opt_annot") == 0)
972 hdr
->sh_type
= SHT_IA_64_HP_OPT_ANOT
;
973 else if (strcmp (name
, ".reloc") == 0)
974 /* This is an ugly, but unfortunately necessary hack that is
975 needed when producing EFI binaries on IA-64. It tells
976 elf.c:elf_fake_sections() not to consider ".reloc" as a section
977 containing ELF relocation info. We need this hack in order to
978 be able to generate ELF binaries that can be translated into
979 EFI applications (which are essentially COFF objects). Those
980 files contain a COFF ".reloc" section inside an ELFNN object,
981 which would normally cause BFD to segfault because it would
982 attempt to interpret this section as containing relocation
983 entries for section "oc". With this hack enabled, ".reloc"
984 will be treated as a normal data section, which will avoid the
985 segfault. However, you won't be able to create an ELFNN binary
986 with a section named "oc" that needs relocations, but that's
987 the kind of ugly side-effects you get when detecting section
988 types based on their names... In practice, this limitation is
990 hdr
->sh_type
= SHT_PROGBITS
;
992 if (sec
->flags
& SEC_SMALL_DATA
)
993 hdr
->sh_flags
|= SHF_IA_64_SHORT
;
995 /* Some HP linkers look for the SHF_IA_64_HP_TLS flag instead of SHF_TLS. */
997 if (elfNN_ia64_hpux_vec (abfd
->xvec
) && (sec
->flags
& SHF_TLS
))
998 hdr
->sh_flags
|= SHF_IA_64_HP_TLS
;
1003 /* The final processing done just before writing out an IA-64 ELF
1007 elfNN_ia64_final_write_processing (bfd
*abfd
)
1009 Elf_Internal_Shdr
*hdr
;
1012 for (s
= abfd
->sections
; s
; s
= s
->next
)
1014 hdr
= &elf_section_data (s
)->this_hdr
;
1015 switch (hdr
->sh_type
)
1017 case SHT_IA_64_UNWIND
:
1018 /* The IA-64 processor-specific ABI requires setting sh_link
1019 to the unwind section, whereas HP-UX requires sh_info to
1020 do so. For maximum compatibility, we'll set both for
1022 hdr
->sh_info
= hdr
->sh_link
;
1027 if (! elf_flags_init (abfd
))
1029 unsigned long flags
= 0;
1031 if (abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
)
1032 flags
|= EF_IA_64_BE
;
1033 if (bfd_get_mach (abfd
) == bfd_mach_ia64_elf64
)
1034 flags
|= EF_IA_64_ABI64
;
1036 elf_elfheader(abfd
)->e_flags
= flags
;
1037 elf_flags_init (abfd
) = TRUE
;
1039 return _bfd_elf_final_write_processing (abfd
);
1042 /* Hook called by the linker routine which adds symbols from an object
1043 file. We use it to put .comm items in .sbss, and not .bss. */
1046 elfNN_ia64_add_symbol_hook (bfd
*abfd
,
1047 struct bfd_link_info
*info
,
1048 Elf_Internal_Sym
*sym
,
1049 const char **namep ATTRIBUTE_UNUSED
,
1050 flagword
*flagsp ATTRIBUTE_UNUSED
,
1054 if (sym
->st_shndx
== SHN_COMMON
1055 && !bfd_link_relocatable (info
)
1056 && sym
->st_size
<= elf_gp_size (abfd
))
1058 /* Common symbols less than or equal to -G nn bytes are
1059 automatically put into .sbss. */
1061 asection
*scomm
= bfd_get_section_by_name (abfd
, ".scommon");
1065 scomm
= bfd_make_section_with_flags (abfd
, ".scommon",
1069 | SEC_LINKER_CREATED
));
1075 *valp
= sym
->st_size
;
1081 /* Return the number of additional phdrs we will need. */
1084 elfNN_ia64_additional_program_headers (bfd
*abfd
,
1085 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1090 /* See if we need a PT_IA_64_ARCHEXT segment. */
1091 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_archext
);
1092 if (s
&& (s
->flags
& SEC_LOAD
))
1095 /* Count how many PT_IA_64_UNWIND segments we need. */
1096 for (s
= abfd
->sections
; s
; s
= s
->next
)
1097 if (is_unwind_section_name (abfd
, s
->name
) && (s
->flags
& SEC_LOAD
))
1104 elfNN_ia64_modify_segment_map (bfd
*abfd
,
1105 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1107 struct elf_segment_map
*m
, **pm
;
1108 Elf_Internal_Shdr
*hdr
;
1111 /* If we need a PT_IA_64_ARCHEXT segment, it must come before
1112 all PT_LOAD segments. */
1113 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_archext
);
1114 if (s
&& (s
->flags
& SEC_LOAD
))
1116 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
1117 if (m
->p_type
== PT_IA_64_ARCHEXT
)
1121 m
= ((struct elf_segment_map
*)
1122 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *m
));
1126 m
->p_type
= PT_IA_64_ARCHEXT
;
1130 /* We want to put it after the PHDR and INTERP segments. */
1131 pm
= &elf_seg_map (abfd
);
1133 && ((*pm
)->p_type
== PT_PHDR
1134 || (*pm
)->p_type
== PT_INTERP
))
1142 /* Install PT_IA_64_UNWIND segments, if needed. */
1143 for (s
= abfd
->sections
; s
; s
= s
->next
)
1145 hdr
= &elf_section_data (s
)->this_hdr
;
1146 if (hdr
->sh_type
!= SHT_IA_64_UNWIND
)
1149 if (s
&& (s
->flags
& SEC_LOAD
))
1151 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
1152 if (m
->p_type
== PT_IA_64_UNWIND
)
1156 /* Look through all sections in the unwind segment
1157 for a match since there may be multiple sections
1159 for (i
= m
->count
- 1; i
>= 0; --i
)
1160 if (m
->sections
[i
] == s
)
1169 m
= ((struct elf_segment_map
*)
1170 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *m
));
1174 m
->p_type
= PT_IA_64_UNWIND
;
1179 /* We want to put it last. */
1180 pm
= &elf_seg_map (abfd
);
1191 /* Turn on PF_IA_64_NORECOV if needed. This involves traversing all of
1192 the input sections for each output section in the segment and testing
1193 for SHF_IA_64_NORECOV on each. */
1196 elfNN_ia64_modify_headers (bfd
*abfd
, struct bfd_link_info
*info
)
1198 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
1199 struct elf_segment_map
*m
;
1200 Elf_Internal_Phdr
*p
;
1202 for (p
= tdata
->phdr
, m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
, p
++)
1203 if (m
->p_type
== PT_LOAD
)
1206 for (i
= m
->count
- 1; i
>= 0; --i
)
1208 struct bfd_link_order
*order
= m
->sections
[i
]->map_head
.link_order
;
1210 while (order
!= NULL
)
1212 if (order
->type
== bfd_indirect_link_order
)
1214 asection
*is
= order
->u
.indirect
.section
;
1215 bfd_vma flags
= elf_section_data(is
)->this_hdr
.sh_flags
;
1216 if (flags
& SHF_IA_64_NORECOV
)
1218 p
->p_flags
|= PF_IA_64_NORECOV
;
1222 order
= order
->next
;
1228 return _bfd_elf_modify_headers (abfd
, info
);
1231 /* According to the Tahoe assembler spec, all labels starting with a
1235 elfNN_ia64_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
1238 return name
[0] == '.';
1241 /* Should we do dynamic things to this symbol? */
1244 elfNN_ia64_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
1245 struct bfd_link_info
*info
, int r_type
)
1247 bfd_boolean ignore_protected
1248 = ((r_type
& 0xf8) == 0x40 /* FPTR relocs */
1249 || (r_type
& 0xf8) == 0x50); /* LTOFF_FPTR relocs */
1251 return _bfd_elf_dynamic_symbol_p (h
, info
, ignore_protected
);
1254 static struct bfd_hash_entry
*
1255 elfNN_ia64_new_elf_hash_entry (struct bfd_hash_entry
*entry
,
1256 struct bfd_hash_table
*table
,
1259 struct elfNN_ia64_link_hash_entry
*ret
;
1260 ret
= (struct elfNN_ia64_link_hash_entry
*) entry
;
1262 /* Allocate the structure if it has not already been allocated by a
1265 ret
= bfd_hash_allocate (table
, sizeof (*ret
));
1270 /* Call the allocation method of the superclass. */
1271 ret
= ((struct elfNN_ia64_link_hash_entry
*)
1272 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
1277 ret
->sorted_count
= 0;
1279 return (struct bfd_hash_entry
*) ret
;
1283 elfNN_ia64_hash_copy_indirect (struct bfd_link_info
*info
,
1284 struct elf_link_hash_entry
*xdir
,
1285 struct elf_link_hash_entry
*xind
)
1287 struct elfNN_ia64_link_hash_entry
*dir
, *ind
;
1289 dir
= (struct elfNN_ia64_link_hash_entry
*) xdir
;
1290 ind
= (struct elfNN_ia64_link_hash_entry
*) xind
;
1292 /* Copy down any references that we may have already seen to the
1293 symbol which just became indirect. */
1295 if (dir
->root
.versioned
!= versioned_hidden
)
1296 dir
->root
.ref_dynamic
|= ind
->root
.ref_dynamic
;
1297 dir
->root
.ref_regular
|= ind
->root
.ref_regular
;
1298 dir
->root
.ref_regular_nonweak
|= ind
->root
.ref_regular_nonweak
;
1299 dir
->root
.needs_plt
|= ind
->root
.needs_plt
;
1301 if (ind
->root
.root
.type
!= bfd_link_hash_indirect
)
1304 /* Copy over the got and plt data. This would have been done
1307 if (ind
->info
!= NULL
)
1309 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1314 dir
->info
= ind
->info
;
1315 dir
->count
= ind
->count
;
1316 dir
->sorted_count
= ind
->sorted_count
;
1317 dir
->size
= ind
->size
;
1321 ind
->sorted_count
= 0;
1324 /* Fix up the dyn_sym_info pointers to the global symbol. */
1325 for (count
= dir
->count
, dyn_i
= dir
->info
;
1328 dyn_i
->h
= &dir
->root
;
1331 /* Copy over the dynindx. */
1333 if (ind
->root
.dynindx
!= -1)
1335 if (dir
->root
.dynindx
!= -1)
1336 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1337 dir
->root
.dynstr_index
);
1338 dir
->root
.dynindx
= ind
->root
.dynindx
;
1339 dir
->root
.dynstr_index
= ind
->root
.dynstr_index
;
1340 ind
->root
.dynindx
= -1;
1341 ind
->root
.dynstr_index
= 0;
1346 elfNN_ia64_hash_hide_symbol (struct bfd_link_info
*info
,
1347 struct elf_link_hash_entry
*xh
,
1348 bfd_boolean force_local
)
1350 struct elfNN_ia64_link_hash_entry
*h
;
1351 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1354 h
= (struct elfNN_ia64_link_hash_entry
*)xh
;
1356 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
1358 for (count
= h
->count
, dyn_i
= h
->info
;
1362 dyn_i
->want_plt2
= 0;
1363 dyn_i
->want_plt
= 0;
1367 /* Compute a hash of a local hash entry. */
1370 elfNN_ia64_local_htab_hash (const void *ptr
)
1372 struct elfNN_ia64_local_hash_entry
*entry
1373 = (struct elfNN_ia64_local_hash_entry
*) ptr
;
1375 return ELF_LOCAL_SYMBOL_HASH (entry
->id
, entry
->r_sym
);
1378 /* Compare local hash entries. */
1381 elfNN_ia64_local_htab_eq (const void *ptr1
, const void *ptr2
)
1383 struct elfNN_ia64_local_hash_entry
*entry1
1384 = (struct elfNN_ia64_local_hash_entry
*) ptr1
;
1385 struct elfNN_ia64_local_hash_entry
*entry2
1386 = (struct elfNN_ia64_local_hash_entry
*) ptr2
;
1388 return entry1
->id
== entry2
->id
&& entry1
->r_sym
== entry2
->r_sym
;
1391 /* Free the global elfNN_ia64_dyn_sym_info array. */
1394 elfNN_ia64_global_dyn_info_free (void **xentry
,
1395 void * unused ATTRIBUTE_UNUSED
)
1397 struct elfNN_ia64_link_hash_entry
*entry
1398 = (struct elfNN_ia64_link_hash_entry
*) xentry
;
1403 entry
->sorted_count
= 0;
1409 /* Free the local elfNN_ia64_dyn_sym_info array. */
1412 elfNN_ia64_local_dyn_info_free (void **slot
,
1413 void * unused ATTRIBUTE_UNUSED
)
1415 struct elfNN_ia64_local_hash_entry
*entry
1416 = (struct elfNN_ia64_local_hash_entry
*) *slot
;
1421 entry
->sorted_count
= 0;
1427 /* Destroy IA-64 linker hash table. */
1430 elfNN_ia64_link_hash_table_free (bfd
*obfd
)
1432 struct elfNN_ia64_link_hash_table
*ia64_info
1433 = (struct elfNN_ia64_link_hash_table
*) obfd
->link
.hash
;
1434 if (ia64_info
->loc_hash_table
)
1436 htab_traverse (ia64_info
->loc_hash_table
,
1437 elfNN_ia64_local_dyn_info_free
, NULL
);
1438 htab_delete (ia64_info
->loc_hash_table
);
1440 if (ia64_info
->loc_hash_memory
)
1441 objalloc_free ((struct objalloc
*) ia64_info
->loc_hash_memory
);
1442 elf_link_hash_traverse (&ia64_info
->root
,
1443 elfNN_ia64_global_dyn_info_free
, NULL
);
1444 _bfd_elf_link_hash_table_free (obfd
);
1447 /* Create the derived linker hash table. The IA-64 ELF port uses this
1448 derived hash table to keep information specific to the IA-64 ElF
1449 linker (without using static variables). */
1451 static struct bfd_link_hash_table
*
1452 elfNN_ia64_hash_table_create (bfd
*abfd
)
1454 struct elfNN_ia64_link_hash_table
*ret
;
1456 ret
= bfd_zmalloc ((bfd_size_type
) sizeof (*ret
));
1460 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
1461 elfNN_ia64_new_elf_hash_entry
,
1462 sizeof (struct elfNN_ia64_link_hash_entry
),
1469 ret
->loc_hash_table
= htab_try_create (1024, elfNN_ia64_local_htab_hash
,
1470 elfNN_ia64_local_htab_eq
, NULL
);
1471 ret
->loc_hash_memory
= objalloc_create ();
1472 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1474 elfNN_ia64_link_hash_table_free (abfd
);
1477 ret
->root
.root
.hash_table_free
= elfNN_ia64_link_hash_table_free
;
1478 ret
->root
.dt_pltgot_required
= TRUE
;
1480 return &ret
->root
.root
;
1483 /* Traverse both local and global hash tables. */
1485 struct elfNN_ia64_dyn_sym_traverse_data
1487 bfd_boolean (*func
) (struct elfNN_ia64_dyn_sym_info
*, void *);
1492 elfNN_ia64_global_dyn_sym_thunk (struct bfd_hash_entry
*xentry
,
1495 struct elfNN_ia64_link_hash_entry
*entry
1496 = (struct elfNN_ia64_link_hash_entry
*) xentry
;
1497 struct elfNN_ia64_dyn_sym_traverse_data
*data
1498 = (struct elfNN_ia64_dyn_sym_traverse_data
*) xdata
;
1499 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1502 for (count
= entry
->count
, dyn_i
= entry
->info
;
1505 if (! (*data
->func
) (dyn_i
, data
->data
))
1511 elfNN_ia64_local_dyn_sym_thunk (void **slot
, void * xdata
)
1513 struct elfNN_ia64_local_hash_entry
*entry
1514 = (struct elfNN_ia64_local_hash_entry
*) *slot
;
1515 struct elfNN_ia64_dyn_sym_traverse_data
*data
1516 = (struct elfNN_ia64_dyn_sym_traverse_data
*) xdata
;
1517 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1520 for (count
= entry
->count
, dyn_i
= entry
->info
;
1523 if (! (*data
->func
) (dyn_i
, data
->data
))
1529 elfNN_ia64_dyn_sym_traverse (struct elfNN_ia64_link_hash_table
*ia64_info
,
1530 bfd_boolean (*func
) (struct elfNN_ia64_dyn_sym_info
*, void *),
1533 struct elfNN_ia64_dyn_sym_traverse_data xdata
;
1538 elf_link_hash_traverse (&ia64_info
->root
,
1539 elfNN_ia64_global_dyn_sym_thunk
, &xdata
);
1540 htab_traverse (ia64_info
->loc_hash_table
,
1541 elfNN_ia64_local_dyn_sym_thunk
, &xdata
);
1545 elfNN_ia64_create_dynamic_sections (bfd
*abfd
,
1546 struct bfd_link_info
*info
)
1548 struct elfNN_ia64_link_hash_table
*ia64_info
;
1551 if (! _bfd_elf_create_dynamic_sections (abfd
, info
))
1554 ia64_info
= elfNN_ia64_hash_table (info
);
1555 if (ia64_info
== NULL
)
1559 flagword flags
= bfd_section_flags (ia64_info
->root
.sgot
);
1560 bfd_set_section_flags (ia64_info
->root
.sgot
, SEC_SMALL_DATA
| flags
);
1561 /* The .got section is always aligned at 8 bytes. */
1562 if (!bfd_set_section_alignment (ia64_info
->root
.sgot
, 3))
1566 if (!get_pltoff (abfd
, info
, ia64_info
))
1569 s
= bfd_make_section_anyway_with_flags (abfd
, ".rela.IA_64.pltoff",
1570 (SEC_ALLOC
| SEC_LOAD
1573 | SEC_LINKER_CREATED
1576 || !bfd_set_section_alignment (s
, LOG_SECTION_ALIGN
))
1578 ia64_info
->rel_pltoff_sec
= s
;
1583 /* Find and/or create a hash entry for local symbol. */
1584 static struct elfNN_ia64_local_hash_entry
*
1585 get_local_sym_hash (struct elfNN_ia64_link_hash_table
*ia64_info
,
1586 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
1589 struct elfNN_ia64_local_hash_entry e
, *ret
;
1590 asection
*sec
= abfd
->sections
;
1591 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
1592 ELFNN_R_SYM (rel
->r_info
));
1596 e
.r_sym
= ELFNN_R_SYM (rel
->r_info
);
1597 slot
= htab_find_slot_with_hash (ia64_info
->loc_hash_table
, &e
, h
,
1598 create
? INSERT
: NO_INSERT
);
1604 return (struct elfNN_ia64_local_hash_entry
*) *slot
;
1606 ret
= (struct elfNN_ia64_local_hash_entry
*)
1607 objalloc_alloc ((struct objalloc
*) ia64_info
->loc_hash_memory
,
1608 sizeof (struct elfNN_ia64_local_hash_entry
));
1611 memset (ret
, 0, sizeof (*ret
));
1613 ret
->r_sym
= ELFNN_R_SYM (rel
->r_info
);
1619 /* Used to sort elfNN_ia64_dyn_sym_info array. */
1622 addend_compare (const void *xp
, const void *yp
)
1624 const struct elfNN_ia64_dyn_sym_info
*x
1625 = (const struct elfNN_ia64_dyn_sym_info
*) xp
;
1626 const struct elfNN_ia64_dyn_sym_info
*y
1627 = (const struct elfNN_ia64_dyn_sym_info
*) yp
;
1629 return x
->addend
< y
->addend
? -1 : x
->addend
> y
->addend
? 1 : 0;
1632 /* Sort elfNN_ia64_dyn_sym_info array and remove duplicates. */
1635 sort_dyn_sym_info (struct elfNN_ia64_dyn_sym_info
*info
,
1638 bfd_vma curr
, prev
, got_offset
;
1639 unsigned int i
, kept
, dupes
, diff
, dest
, src
, len
;
1641 qsort (info
, count
, sizeof (*info
), addend_compare
);
1643 /* Find the first duplicate. */
1644 prev
= info
[0].addend
;
1645 got_offset
= info
[0].got_offset
;
1646 for (i
= 1; i
< count
; i
++)
1648 curr
= info
[i
].addend
;
1651 /* For duplicates, make sure that GOT_OFFSET is valid. */
1652 if (got_offset
== (bfd_vma
) -1)
1653 got_offset
= info
[i
].got_offset
;
1656 got_offset
= info
[i
].got_offset
;
1660 /* We may move a block of elements to here. */
1663 /* Remove duplicates. */
1668 /* For duplicates, make sure that the kept one has a valid
1671 if (got_offset
!= (bfd_vma
) -1)
1672 info
[kept
].got_offset
= got_offset
;
1674 curr
= info
[i
].addend
;
1675 got_offset
= info
[i
].got_offset
;
1677 /* Move a block of elements whose first one is different from
1681 for (src
= i
+ 1; src
< count
; src
++)
1683 if (info
[src
].addend
!= curr
)
1685 /* For duplicates, make sure that GOT_OFFSET is
1687 if (got_offset
== (bfd_vma
) -1)
1688 got_offset
= info
[src
].got_offset
;
1691 /* Make sure that the kept one has a valid got_offset. */
1692 if (got_offset
!= (bfd_vma
) -1)
1693 info
[kept
].got_offset
= got_offset
;
1701 /* Find the next duplicate. SRC will be kept. */
1702 prev
= info
[src
].addend
;
1703 got_offset
= info
[src
].got_offset
;
1704 for (dupes
= src
+ 1; dupes
< count
; dupes
++)
1706 curr
= info
[dupes
].addend
;
1709 /* Make sure that got_offset is valid. */
1710 if (got_offset
== (bfd_vma
) -1)
1711 got_offset
= info
[dupes
].got_offset
;
1713 /* For duplicates, make sure that the kept one has
1714 a valid got_offset. */
1715 if (got_offset
!= (bfd_vma
) -1)
1716 info
[dupes
- 1].got_offset
= got_offset
;
1719 got_offset
= info
[dupes
].got_offset
;
1723 /* How much to move. */
1727 if (len
== 1 && dupes
< count
)
1729 /* If we only move 1 element, we combine it with the next
1730 one. There must be at least a duplicate. Find the
1731 next different one. */
1732 for (diff
= dupes
+ 1, src
++; diff
< count
; diff
++, src
++)
1734 if (info
[diff
].addend
!= curr
)
1736 /* Make sure that got_offset is valid. */
1737 if (got_offset
== (bfd_vma
) -1)
1738 got_offset
= info
[diff
].got_offset
;
1741 /* Makre sure that the last duplicated one has an valid
1743 BFD_ASSERT (curr
== prev
);
1744 if (got_offset
!= (bfd_vma
) -1)
1745 info
[diff
- 1].got_offset
= got_offset
;
1749 /* Find the next duplicate. Track the current valid
1751 prev
= info
[diff
].addend
;
1752 got_offset
= info
[diff
].got_offset
;
1753 for (dupes
= diff
+ 1; dupes
< count
; dupes
++)
1755 curr
= info
[dupes
].addend
;
1758 /* For duplicates, make sure that GOT_OFFSET
1760 if (got_offset
== (bfd_vma
) -1)
1761 got_offset
= info
[dupes
].got_offset
;
1764 got_offset
= info
[dupes
].got_offset
;
1769 len
= diff
- src
+ 1;
1774 memmove (&info
[dest
], &info
[src
], len
* sizeof (*info
));
1783 /* When we get here, either there is no duplicate at all or
1784 the only duplicate is the last element. */
1787 /* If the last element is a duplicate, make sure that the
1788 kept one has a valid got_offset. We also update count. */
1789 if (got_offset
!= (bfd_vma
) -1)
1790 info
[dest
- 1].got_offset
= got_offset
;
1798 /* Find and/or create a descriptor for dynamic symbol info. This will
1799 vary based on global or local symbol, and the addend to the reloc.
1801 We don't sort when inserting. Also, we sort and eliminate
1802 duplicates if there is an unsorted section. Typically, this will
1803 only happen once, because we do all insertions before lookups. We
1804 then use bsearch to do a lookup. This also allows lookups to be
1805 fast. So we have fast insertion (O(log N) due to duplicate check),
1806 fast lookup (O(log N)) and one sort (O(N log N) expected time).
1807 Previously, all lookups were O(N) because of the use of the linked
1808 list and also all insertions were O(N) because of the check for
1809 duplicates. There are some complications here because the array
1810 size grows occasionally, which may add an O(N) factor, but this
1811 should be rare. Also, we free the excess array allocation, which
1812 requires a copy which is O(N), but this only happens once. */
1814 static struct elfNN_ia64_dyn_sym_info
*
1815 get_dyn_sym_info (struct elfNN_ia64_link_hash_table
*ia64_info
,
1816 struct elf_link_hash_entry
*h
, bfd
*abfd
,
1817 const Elf_Internal_Rela
*rel
, bfd_boolean create
)
1819 struct elfNN_ia64_dyn_sym_info
**info_p
, *info
, *dyn_i
, key
;
1820 unsigned int *count_p
, *sorted_count_p
, *size_p
;
1821 unsigned int count
, sorted_count
, size
;
1822 bfd_vma addend
= rel
? rel
->r_addend
: 0;
1827 struct elfNN_ia64_link_hash_entry
*global_h
;
1829 global_h
= (struct elfNN_ia64_link_hash_entry
*) h
;
1830 info_p
= &global_h
->info
;
1831 count_p
= &global_h
->count
;
1832 sorted_count_p
= &global_h
->sorted_count
;
1833 size_p
= &global_h
->size
;
1837 struct elfNN_ia64_local_hash_entry
*loc_h
;
1839 loc_h
= get_local_sym_hash (ia64_info
, abfd
, rel
, create
);
1842 BFD_ASSERT (!create
);
1846 info_p
= &loc_h
->info
;
1847 count_p
= &loc_h
->count
;
1848 sorted_count_p
= &loc_h
->sorted_count
;
1849 size_p
= &loc_h
->size
;
1853 sorted_count
= *sorted_count_p
;
1858 /* When we create the array, we don't check for duplicates,
1859 except in the previously sorted section if one exists, and
1860 against the last inserted entry. This allows insertions to
1866 /* Try bsearch first on the sorted section. */
1867 key
.addend
= addend
;
1868 dyn_i
= bsearch (&key
, info
, sorted_count
,
1869 sizeof (*info
), addend_compare
);
1876 /* Do a quick check for the last inserted entry. */
1877 dyn_i
= info
+ count
- 1;
1878 if (dyn_i
->addend
== addend
)
1885 /* It is the very first element. We create the array of size
1888 amt
= size
* sizeof (*info
);
1889 info
= bfd_malloc (amt
);
1891 else if (size
<= count
)
1893 /* We double the array size every time when we reach the
1896 amt
= size
* sizeof (*info
);
1897 info
= bfd_realloc (info
, amt
);
1908 /* Append the new one to the array. */
1909 dyn_i
= info
+ count
;
1910 memset (dyn_i
, 0, sizeof (*dyn_i
));
1911 dyn_i
->got_offset
= (bfd_vma
) -1;
1912 dyn_i
->addend
= addend
;
1914 /* We increment count only since the new ones are unsorted and
1915 may have duplicate. */
1920 /* It is a lookup without insertion. Sort array if part of the
1921 array isn't sorted. */
1922 if (count
!= sorted_count
)
1924 count
= sort_dyn_sym_info (info
, count
);
1926 *sorted_count_p
= count
;
1929 /* Free unused memory. */
1932 amt
= count
* sizeof (*info
);
1933 info
= bfd_realloc (info
, amt
);
1935 if (info
== NULL
&& count
!= 0)
1936 /* realloc should never fail since we are reducing size here,
1937 but if it does use the old array. */
1947 key
.addend
= addend
;
1948 dyn_i
= bsearch (&key
, info
, count
, sizeof (*info
), addend_compare
);
1956 get_got (bfd
*abfd
, struct bfd_link_info
*info
,
1957 struct elfNN_ia64_link_hash_table
*ia64_info
)
1962 got
= ia64_info
->root
.sgot
;
1967 dynobj
= ia64_info
->root
.dynobj
;
1969 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1970 if (!_bfd_elf_create_got_section (dynobj
, info
))
1973 got
= ia64_info
->root
.sgot
;
1975 /* The .got section is always aligned at 8 bytes. */
1976 if (!bfd_set_section_alignment (got
, 3))
1979 flags
= bfd_section_flags (got
);
1980 if (!bfd_set_section_flags (got
, SEC_SMALL_DATA
| flags
))
1987 /* Create function descriptor section (.opd). This section is called .opd
1988 because it contains "official procedure descriptors". The "official"
1989 refers to the fact that these descriptors are used when taking the address
1990 of a procedure, thus ensuring a unique address for each procedure. */
1993 get_fptr (bfd
*abfd
, struct bfd_link_info
*info
,
1994 struct elfNN_ia64_link_hash_table
*ia64_info
)
1999 fptr
= ia64_info
->fptr_sec
;
2002 dynobj
= ia64_info
->root
.dynobj
;
2004 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2006 fptr
= bfd_make_section_anyway_with_flags (dynobj
, ".opd",
2011 | (bfd_link_pie (info
)
2013 | SEC_LINKER_CREATED
));
2015 || !bfd_set_section_alignment (fptr
, 4))
2021 ia64_info
->fptr_sec
= fptr
;
2023 if (bfd_link_pie (info
))
2026 fptr_rel
= bfd_make_section_anyway_with_flags (dynobj
, ".rela.opd",
2027 (SEC_ALLOC
| SEC_LOAD
2030 | SEC_LINKER_CREATED
2032 if (fptr_rel
== NULL
2033 || !bfd_set_section_alignment (fptr_rel
, LOG_SECTION_ALIGN
))
2039 ia64_info
->rel_fptr_sec
= fptr_rel
;
2047 get_pltoff (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2048 struct elfNN_ia64_link_hash_table
*ia64_info
)
2053 pltoff
= ia64_info
->pltoff_sec
;
2056 dynobj
= ia64_info
->root
.dynobj
;
2058 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2060 pltoff
= bfd_make_section_anyway_with_flags (dynobj
,
2061 ELF_STRING_ia64_pltoff
,
2067 | SEC_LINKER_CREATED
));
2069 || !bfd_set_section_alignment (pltoff
, 4))
2075 ia64_info
->pltoff_sec
= pltoff
;
2082 get_reloc_section (bfd
*abfd
,
2083 struct elfNN_ia64_link_hash_table
*ia64_info
,
2084 asection
*sec
, bfd_boolean create
)
2086 const char *srel_name
;
2090 srel_name
= (bfd_elf_string_from_elf_section
2091 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
2092 _bfd_elf_single_rel_hdr (sec
)->sh_name
));
2093 if (srel_name
== NULL
)
2096 dynobj
= ia64_info
->root
.dynobj
;
2098 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2100 srel
= bfd_get_linker_section (dynobj
, srel_name
);
2101 if (srel
== NULL
&& create
)
2103 srel
= bfd_make_section_anyway_with_flags (dynobj
, srel_name
,
2104 (SEC_ALLOC
| SEC_LOAD
2107 | SEC_LINKER_CREATED
2110 || !bfd_set_section_alignment (srel
, LOG_SECTION_ALIGN
))
2118 count_dyn_reloc (bfd
*abfd
, struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2119 asection
*srel
, int type
, bfd_boolean reltext
)
2121 struct elfNN_ia64_dyn_reloc_entry
*rent
;
2123 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2124 if (rent
->srel
== srel
&& rent
->type
== type
)
2129 rent
= ((struct elfNN_ia64_dyn_reloc_entry
*)
2130 bfd_alloc (abfd
, (bfd_size_type
) sizeof (*rent
)));
2134 rent
->next
= dyn_i
->reloc_entries
;
2138 dyn_i
->reloc_entries
= rent
;
2140 rent
->reltext
= reltext
;
2147 elfNN_ia64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
2149 const Elf_Internal_Rela
*relocs
)
2151 struct elfNN_ia64_link_hash_table
*ia64_info
;
2152 const Elf_Internal_Rela
*relend
;
2153 Elf_Internal_Shdr
*symtab_hdr
;
2154 const Elf_Internal_Rela
*rel
;
2155 asection
*got
, *fptr
, *srel
, *pltoff
;
2164 NEED_LTOFF_FPTR
= 128,
2170 struct elf_link_hash_entry
*h
;
2171 unsigned long r_symndx
;
2172 bfd_boolean maybe_dynamic
;
2174 if (bfd_link_relocatable (info
))
2177 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2178 ia64_info
= elfNN_ia64_hash_table (info
);
2179 if (ia64_info
== NULL
)
2182 got
= fptr
= srel
= pltoff
= NULL
;
2184 relend
= relocs
+ sec
->reloc_count
;
2186 /* We scan relocations first to create dynamic relocation arrays. We
2187 modified get_dyn_sym_info to allow fast insertion and support fast
2188 lookup in the next loop. */
2189 for (rel
= relocs
; rel
< relend
; ++rel
)
2191 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
2192 if (r_symndx
>= symtab_hdr
->sh_info
)
2194 long indx
= r_symndx
- symtab_hdr
->sh_info
;
2195 h
= elf_sym_hashes (abfd
)[indx
];
2196 while (h
->root
.type
== bfd_link_hash_indirect
2197 || h
->root
.type
== bfd_link_hash_warning
)
2198 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2203 /* We can only get preliminary data on whether a symbol is
2204 locally or externally defined, as not all of the input files
2205 have yet been processed. Do something with what we know, as
2206 this may help reduce memory usage and processing time later. */
2207 maybe_dynamic
= (h
&& ((!bfd_link_executable (info
)
2208 && (!SYMBOLIC_BIND (info
, h
)
2209 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
2211 || h
->root
.type
== bfd_link_hash_defweak
));
2214 switch (ELFNN_R_TYPE (rel
->r_info
))
2216 case R_IA64_TPREL64MSB
:
2217 case R_IA64_TPREL64LSB
:
2218 if (bfd_link_pic (info
) || maybe_dynamic
)
2219 need_entry
= NEED_DYNREL
;
2222 case R_IA64_LTOFF_TPREL22
:
2223 need_entry
= NEED_TPREL
;
2224 if (bfd_link_pic (info
))
2225 info
->flags
|= DF_STATIC_TLS
;
2228 case R_IA64_DTPREL32MSB
:
2229 case R_IA64_DTPREL32LSB
:
2230 case R_IA64_DTPREL64MSB
:
2231 case R_IA64_DTPREL64LSB
:
2232 if (bfd_link_pic (info
) || maybe_dynamic
)
2233 need_entry
= NEED_DYNREL
;
2236 case R_IA64_LTOFF_DTPREL22
:
2237 need_entry
= NEED_DTPREL
;
2240 case R_IA64_DTPMOD64MSB
:
2241 case R_IA64_DTPMOD64LSB
:
2242 if (bfd_link_pic (info
) || maybe_dynamic
)
2243 need_entry
= NEED_DYNREL
;
2246 case R_IA64_LTOFF_DTPMOD22
:
2247 need_entry
= NEED_DTPMOD
;
2250 case R_IA64_LTOFF_FPTR22
:
2251 case R_IA64_LTOFF_FPTR64I
:
2252 case R_IA64_LTOFF_FPTR32MSB
:
2253 case R_IA64_LTOFF_FPTR32LSB
:
2254 case R_IA64_LTOFF_FPTR64MSB
:
2255 case R_IA64_LTOFF_FPTR64LSB
:
2256 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
2259 case R_IA64_FPTR64I
:
2260 case R_IA64_FPTR32MSB
:
2261 case R_IA64_FPTR32LSB
:
2262 case R_IA64_FPTR64MSB
:
2263 case R_IA64_FPTR64LSB
:
2264 if (bfd_link_pic (info
) || h
)
2265 need_entry
= NEED_FPTR
| NEED_DYNREL
;
2267 need_entry
= NEED_FPTR
;
2270 case R_IA64_LTOFF22
:
2271 case R_IA64_LTOFF64I
:
2272 need_entry
= NEED_GOT
;
2275 case R_IA64_LTOFF22X
:
2276 need_entry
= NEED_GOTX
;
2279 case R_IA64_PLTOFF22
:
2280 case R_IA64_PLTOFF64I
:
2281 case R_IA64_PLTOFF64MSB
:
2282 case R_IA64_PLTOFF64LSB
:
2283 need_entry
= NEED_PLTOFF
;
2287 need_entry
|= NEED_MIN_PLT
;
2291 (*info
->callbacks
->warning
)
2292 (info
, _("@pltoff reloc against local symbol"), 0,
2293 abfd
, 0, (bfd_vma
) 0);
2297 case R_IA64_PCREL21B
:
2298 case R_IA64_PCREL60B
:
2299 /* Depending on where this symbol is defined, we may or may not
2300 need a full plt entry. Only skip if we know we'll not need
2301 the entry -- static or symbolic, and the symbol definition
2302 has already been seen. */
2303 if (maybe_dynamic
&& rel
->r_addend
== 0)
2304 need_entry
= NEED_FULL_PLT
;
2310 case R_IA64_DIR32MSB
:
2311 case R_IA64_DIR32LSB
:
2312 case R_IA64_DIR64MSB
:
2313 case R_IA64_DIR64LSB
:
2314 /* Shared objects will always need at least a REL relocation. */
2315 if (bfd_link_pic (info
) || maybe_dynamic
)
2316 need_entry
= NEED_DYNREL
;
2319 case R_IA64_IPLTMSB
:
2320 case R_IA64_IPLTLSB
:
2321 /* Shared objects will always need at least a REL relocation. */
2322 if (bfd_link_pic (info
) || maybe_dynamic
)
2323 need_entry
= NEED_DYNREL
;
2326 case R_IA64_PCREL22
:
2327 case R_IA64_PCREL64I
:
2328 case R_IA64_PCREL32MSB
:
2329 case R_IA64_PCREL32LSB
:
2330 case R_IA64_PCREL64MSB
:
2331 case R_IA64_PCREL64LSB
:
2333 need_entry
= NEED_DYNREL
;
2340 if ((need_entry
& NEED_FPTR
) != 0
2343 (*info
->callbacks
->warning
)
2344 (info
, _("non-zero addend in @fptr reloc"), 0,
2345 abfd
, 0, (bfd_vma
) 0);
2348 if (get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, TRUE
) == NULL
)
2352 /* Now, we only do lookup without insertion, which is very fast
2353 with the modified get_dyn_sym_info. */
2354 for (rel
= relocs
; rel
< relend
; ++rel
)
2356 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2357 int dynrel_type
= R_IA64_NONE
;
2359 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
2360 if (r_symndx
>= symtab_hdr
->sh_info
)
2362 /* We're dealing with a global symbol -- find its hash entry
2363 and mark it as being referenced. */
2364 long indx
= r_symndx
- symtab_hdr
->sh_info
;
2365 h
= elf_sym_hashes (abfd
)[indx
];
2366 while (h
->root
.type
== bfd_link_hash_indirect
2367 || h
->root
.type
== bfd_link_hash_warning
)
2368 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2370 /* PR15323, ref flags aren't set for references in the same
2377 /* We can only get preliminary data on whether a symbol is
2378 locally or externally defined, as not all of the input files
2379 have yet been processed. Do something with what we know, as
2380 this may help reduce memory usage and processing time later. */
2381 maybe_dynamic
= (h
&& ((!bfd_link_executable (info
)
2382 && (!SYMBOLIC_BIND (info
, h
)
2383 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
2385 || h
->root
.type
== bfd_link_hash_defweak
));
2388 switch (ELFNN_R_TYPE (rel
->r_info
))
2390 case R_IA64_TPREL64MSB
:
2391 case R_IA64_TPREL64LSB
:
2392 if (bfd_link_pic (info
) || maybe_dynamic
)
2393 need_entry
= NEED_DYNREL
;
2394 dynrel_type
= R_IA64_TPREL64LSB
;
2395 if (bfd_link_pic (info
))
2396 info
->flags
|= DF_STATIC_TLS
;
2399 case R_IA64_LTOFF_TPREL22
:
2400 need_entry
= NEED_TPREL
;
2401 if (bfd_link_pic (info
))
2402 info
->flags
|= DF_STATIC_TLS
;
2405 case R_IA64_DTPREL32MSB
:
2406 case R_IA64_DTPREL32LSB
:
2407 case R_IA64_DTPREL64MSB
:
2408 case R_IA64_DTPREL64LSB
:
2409 if (bfd_link_pic (info
) || maybe_dynamic
)
2410 need_entry
= NEED_DYNREL
;
2411 dynrel_type
= R_IA64_DTPRELNNLSB
;
2414 case R_IA64_LTOFF_DTPREL22
:
2415 need_entry
= NEED_DTPREL
;
2418 case R_IA64_DTPMOD64MSB
:
2419 case R_IA64_DTPMOD64LSB
:
2420 if (bfd_link_pic (info
) || maybe_dynamic
)
2421 need_entry
= NEED_DYNREL
;
2422 dynrel_type
= R_IA64_DTPMOD64LSB
;
2425 case R_IA64_LTOFF_DTPMOD22
:
2426 need_entry
= NEED_DTPMOD
;
2429 case R_IA64_LTOFF_FPTR22
:
2430 case R_IA64_LTOFF_FPTR64I
:
2431 case R_IA64_LTOFF_FPTR32MSB
:
2432 case R_IA64_LTOFF_FPTR32LSB
:
2433 case R_IA64_LTOFF_FPTR64MSB
:
2434 case R_IA64_LTOFF_FPTR64LSB
:
2435 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
2438 case R_IA64_FPTR64I
:
2439 case R_IA64_FPTR32MSB
:
2440 case R_IA64_FPTR32LSB
:
2441 case R_IA64_FPTR64MSB
:
2442 case R_IA64_FPTR64LSB
:
2443 if (bfd_link_pic (info
) || h
)
2444 need_entry
= NEED_FPTR
| NEED_DYNREL
;
2446 need_entry
= NEED_FPTR
;
2447 dynrel_type
= R_IA64_FPTRNNLSB
;
2450 case R_IA64_LTOFF22
:
2451 case R_IA64_LTOFF64I
:
2452 need_entry
= NEED_GOT
;
2455 case R_IA64_LTOFF22X
:
2456 need_entry
= NEED_GOTX
;
2459 case R_IA64_PLTOFF22
:
2460 case R_IA64_PLTOFF64I
:
2461 case R_IA64_PLTOFF64MSB
:
2462 case R_IA64_PLTOFF64LSB
:
2463 need_entry
= NEED_PLTOFF
;
2467 need_entry
|= NEED_MIN_PLT
;
2471 case R_IA64_PCREL21B
:
2472 case R_IA64_PCREL60B
:
2473 /* Depending on where this symbol is defined, we may or may not
2474 need a full plt entry. Only skip if we know we'll not need
2475 the entry -- static or symbolic, and the symbol definition
2476 has already been seen. */
2477 if (maybe_dynamic
&& rel
->r_addend
== 0)
2478 need_entry
= NEED_FULL_PLT
;
2484 case R_IA64_DIR32MSB
:
2485 case R_IA64_DIR32LSB
:
2486 case R_IA64_DIR64MSB
:
2487 case R_IA64_DIR64LSB
:
2488 /* Shared objects will always need at least a REL relocation. */
2489 if (bfd_link_pic (info
) || maybe_dynamic
)
2490 need_entry
= NEED_DYNREL
;
2491 dynrel_type
= R_IA64_DIRNNLSB
;
2494 case R_IA64_IPLTMSB
:
2495 case R_IA64_IPLTLSB
:
2496 /* Shared objects will always need at least a REL relocation. */
2497 if (bfd_link_pic (info
) || maybe_dynamic
)
2498 need_entry
= NEED_DYNREL
;
2499 dynrel_type
= R_IA64_IPLTLSB
;
2502 case R_IA64_PCREL22
:
2503 case R_IA64_PCREL64I
:
2504 case R_IA64_PCREL32MSB
:
2505 case R_IA64_PCREL32LSB
:
2506 case R_IA64_PCREL64MSB
:
2507 case R_IA64_PCREL64LSB
:
2509 need_entry
= NEED_DYNREL
;
2510 dynrel_type
= R_IA64_PCRELNNLSB
;
2517 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, FALSE
);
2519 /* Record whether or not this is a local symbol. */
2522 /* Create what's needed. */
2523 if (need_entry
& (NEED_GOT
| NEED_GOTX
| NEED_TPREL
2524 | NEED_DTPMOD
| NEED_DTPREL
))
2528 got
= get_got (abfd
, info
, ia64_info
);
2532 if (need_entry
& NEED_GOT
)
2533 dyn_i
->want_got
= 1;
2534 if (need_entry
& NEED_GOTX
)
2535 dyn_i
->want_gotx
= 1;
2536 if (need_entry
& NEED_TPREL
)
2537 dyn_i
->want_tprel
= 1;
2538 if (need_entry
& NEED_DTPMOD
)
2539 dyn_i
->want_dtpmod
= 1;
2540 if (need_entry
& NEED_DTPREL
)
2541 dyn_i
->want_dtprel
= 1;
2543 if (need_entry
& NEED_FPTR
)
2547 fptr
= get_fptr (abfd
, info
, ia64_info
);
2552 /* FPTRs for shared libraries are allocated by the dynamic
2553 linker. Make sure this local symbol will appear in the
2554 dynamic symbol table. */
2555 if (!h
&& bfd_link_pic (info
))
2557 if (! (bfd_elf_link_record_local_dynamic_symbol
2558 (info
, abfd
, (long) r_symndx
)))
2562 dyn_i
->want_fptr
= 1;
2564 if (need_entry
& NEED_LTOFF_FPTR
)
2565 dyn_i
->want_ltoff_fptr
= 1;
2566 if (need_entry
& (NEED_MIN_PLT
| NEED_FULL_PLT
))
2568 if (!ia64_info
->root
.dynobj
)
2569 ia64_info
->root
.dynobj
= abfd
;
2571 dyn_i
->want_plt
= 1;
2573 if (need_entry
& NEED_FULL_PLT
)
2574 dyn_i
->want_plt2
= 1;
2575 if (need_entry
& NEED_PLTOFF
)
2577 /* This is needed here, in case @pltoff is used in a non-shared
2581 pltoff
= get_pltoff (abfd
, info
, ia64_info
);
2586 dyn_i
->want_pltoff
= 1;
2588 if ((need_entry
& NEED_DYNREL
) && (sec
->flags
& SEC_ALLOC
))
2592 srel
= get_reloc_section (abfd
, ia64_info
, sec
, TRUE
);
2596 if (!count_dyn_reloc (abfd
, dyn_i
, srel
, dynrel_type
,
2597 (sec
->flags
& SEC_READONLY
) != 0))
2605 /* For cleanliness, and potentially faster dynamic loading, allocate
2606 external GOT entries first. */
2609 allocate_global_data_got (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2612 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2614 if ((dyn_i
->want_got
|| dyn_i
->want_gotx
)
2615 && ! dyn_i
->want_fptr
2616 && elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0))
2618 dyn_i
->got_offset
= x
->ofs
;
2621 if (dyn_i
->want_tprel
)
2623 dyn_i
->tprel_offset
= x
->ofs
;
2626 if (dyn_i
->want_dtpmod
)
2628 if (elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0))
2630 dyn_i
->dtpmod_offset
= x
->ofs
;
2635 struct elfNN_ia64_link_hash_table
*ia64_info
;
2637 ia64_info
= elfNN_ia64_hash_table (x
->info
);
2638 if (ia64_info
== NULL
)
2641 if (ia64_info
->self_dtpmod_offset
== (bfd_vma
) -1)
2643 ia64_info
->self_dtpmod_offset
= x
->ofs
;
2646 dyn_i
->dtpmod_offset
= ia64_info
->self_dtpmod_offset
;
2649 if (dyn_i
->want_dtprel
)
2651 dyn_i
->dtprel_offset
= x
->ofs
;
2657 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
2660 allocate_global_fptr_got (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2663 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2667 && elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, R_IA64_FPTRNNLSB
))
2669 dyn_i
->got_offset
= x
->ofs
;
2675 /* Lastly, allocate all the GOT entries for local data. */
2678 allocate_local_got (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2681 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2683 if ((dyn_i
->want_got
|| dyn_i
->want_gotx
)
2684 && !elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0))
2686 dyn_i
->got_offset
= x
->ofs
;
2692 /* Search for the index of a global symbol in it's defining object file. */
2695 global_sym_index (struct elf_link_hash_entry
*h
)
2697 struct elf_link_hash_entry
**p
;
2700 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
2701 || h
->root
.type
== bfd_link_hash_defweak
);
2703 obj
= h
->root
.u
.def
.section
->owner
;
2704 for (p
= elf_sym_hashes (obj
); *p
!= h
; ++p
)
2707 return p
- elf_sym_hashes (obj
) + elf_tdata (obj
)->symtab_hdr
.sh_info
;
2710 /* Allocate function descriptors. We can do these for every function
2711 in a main executable that is not exported. */
2714 allocate_fptr (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
)
2716 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2718 if (dyn_i
->want_fptr
)
2720 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2723 while (h
->root
.type
== bfd_link_hash_indirect
2724 || h
->root
.type
== bfd_link_hash_warning
)
2725 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2727 if (!bfd_link_executable (x
->info
)
2729 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2730 || (h
->root
.type
!= bfd_link_hash_undefweak
2731 && h
->root
.type
!= bfd_link_hash_undefined
)))
2733 if (h
&& h
->dynindx
== -1)
2735 BFD_ASSERT ((h
->root
.type
== bfd_link_hash_defined
)
2736 || (h
->root
.type
== bfd_link_hash_defweak
));
2738 if (!bfd_elf_link_record_local_dynamic_symbol
2739 (x
->info
, h
->root
.u
.def
.section
->owner
,
2740 global_sym_index (h
)))
2744 dyn_i
->want_fptr
= 0;
2746 else if (h
== NULL
|| h
->dynindx
== -1)
2748 dyn_i
->fptr_offset
= x
->ofs
;
2752 dyn_i
->want_fptr
= 0;
2757 /* Allocate all the minimal PLT entries. */
2760 allocate_plt_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2763 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2765 if (dyn_i
->want_plt
)
2767 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2770 while (h
->root
.type
== bfd_link_hash_indirect
2771 || h
->root
.type
== bfd_link_hash_warning
)
2772 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2774 /* ??? Versioned symbols seem to lose NEEDS_PLT. */
2775 if (elfNN_ia64_dynamic_symbol_p (h
, x
->info
, 0))
2777 bfd_size_type offset
= x
->ofs
;
2779 offset
= PLT_HEADER_SIZE
;
2780 dyn_i
->plt_offset
= offset
;
2781 x
->ofs
= offset
+ PLT_MIN_ENTRY_SIZE
;
2783 dyn_i
->want_pltoff
= 1;
2787 dyn_i
->want_plt
= 0;
2788 dyn_i
->want_plt2
= 0;
2794 /* Allocate all the full PLT entries. */
2797 allocate_plt2_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2800 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2802 if (dyn_i
->want_plt2
)
2804 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2805 bfd_size_type ofs
= x
->ofs
;
2807 dyn_i
->plt2_offset
= ofs
;
2808 x
->ofs
= ofs
+ PLT_FULL_ENTRY_SIZE
;
2810 while (h
->root
.type
== bfd_link_hash_indirect
2811 || h
->root
.type
== bfd_link_hash_warning
)
2812 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2813 dyn_i
->h
->plt
.offset
= ofs
;
2818 /* Allocate all the PLTOFF entries requested by relocations and
2819 plt entries. We can't share space with allocated FPTR entries,
2820 because the latter are not necessarily addressable by the GP.
2821 ??? Relaxation might be able to determine that they are. */
2824 allocate_pltoff_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2827 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2829 if (dyn_i
->want_pltoff
)
2831 dyn_i
->pltoff_offset
= x
->ofs
;
2837 /* Allocate dynamic relocations for those symbols that turned out
2841 allocate_dynrel_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2844 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2845 struct elfNN_ia64_link_hash_table
*ia64_info
;
2846 struct elfNN_ia64_dyn_reloc_entry
*rent
;
2847 bfd_boolean dynamic_symbol
, shared
, resolved_zero
;
2849 ia64_info
= elfNN_ia64_hash_table (x
->info
);
2850 if (ia64_info
== NULL
)
2853 /* Note that this can't be used in relation to FPTR relocs below. */
2854 dynamic_symbol
= elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0);
2856 shared
= bfd_link_pic (x
->info
);
2857 resolved_zero
= (dyn_i
->h
2858 && ELF_ST_VISIBILITY (dyn_i
->h
->other
)
2859 && dyn_i
->h
->root
.type
== bfd_link_hash_undefweak
);
2861 /* Take care of the GOT and PLT relocations. */
2864 && (dynamic_symbol
|| shared
)
2865 && (dyn_i
->want_got
|| dyn_i
->want_gotx
))
2866 || (dyn_i
->want_ltoff_fptr
2868 && dyn_i
->h
->dynindx
!= -1))
2870 if (!dyn_i
->want_ltoff_fptr
2871 || !bfd_link_pie (x
->info
)
2873 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
2874 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
2876 if ((dynamic_symbol
|| shared
) && dyn_i
->want_tprel
)
2877 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
2878 if (dynamic_symbol
&& dyn_i
->want_dtpmod
)
2879 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
2880 if (dynamic_symbol
&& dyn_i
->want_dtprel
)
2881 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
2886 if (ia64_info
->rel_fptr_sec
&& dyn_i
->want_fptr
)
2888 if (dyn_i
->h
== NULL
|| dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
2889 ia64_info
->rel_fptr_sec
->size
+= sizeof (ElfNN_External_Rela
);
2892 if (!resolved_zero
&& dyn_i
->want_pltoff
)
2894 bfd_size_type t
= 0;
2896 /* Dynamic symbols get one IPLT relocation. Local symbols in
2897 shared libraries get two REL relocations. Local symbols in
2898 main applications get nothing. */
2900 t
= sizeof (ElfNN_External_Rela
);
2902 t
= 2 * sizeof (ElfNN_External_Rela
);
2904 ia64_info
->rel_pltoff_sec
->size
+= t
;
2907 /* Take care of the normal data relocations. */
2909 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2911 int count
= rent
->count
;
2915 case R_IA64_FPTR32LSB
:
2916 case R_IA64_FPTR64LSB
:
2917 /* Allocate one iff !want_fptr and not PIE, which by this point
2918 will be true only if we're actually allocating one statically
2919 in the main executable. Position independent executables
2920 need a relative reloc. */
2921 if (dyn_i
->want_fptr
&& !bfd_link_pie (x
->info
))
2924 case R_IA64_PCREL32LSB
:
2925 case R_IA64_PCREL64LSB
:
2926 if (!dynamic_symbol
)
2929 case R_IA64_DIR32LSB
:
2930 case R_IA64_DIR64LSB
:
2931 if (!dynamic_symbol
&& !shared
)
2934 case R_IA64_IPLTLSB
:
2935 if (!dynamic_symbol
&& !shared
)
2937 /* Use two REL relocations for IPLT relocations
2938 against local symbols. */
2939 if (!dynamic_symbol
)
2942 case R_IA64_DTPREL32LSB
:
2943 case R_IA64_TPREL64LSB
:
2944 case R_IA64_DTPREL64LSB
:
2945 case R_IA64_DTPMOD64LSB
:
2951 x
->info
->flags
|= DF_TEXTREL
;
2952 rent
->srel
->size
+= sizeof (ElfNN_External_Rela
) * count
;
2959 elfNN_ia64_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2960 struct elf_link_hash_entry
*h
)
2962 /* ??? Undefined symbols with PLT entries should be re-defined
2963 to be the PLT entry. */
2965 /* If this is a weak symbol, and there is a real definition, the
2966 processor independent code will have arranged for us to see the
2967 real definition first, and we can just use the same value. */
2968 if (h
->is_weakalias
)
2970 struct elf_link_hash_entry
*def
= weakdef (h
);
2971 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
2972 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
2973 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
2977 /* If this is a reference to a symbol defined by a dynamic object which
2978 is not a function, we might allocate the symbol in our .dynbss section
2979 and allocate a COPY dynamic relocation.
2981 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2988 elfNN_ia64_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2989 struct bfd_link_info
*info
)
2991 struct elfNN_ia64_allocate_data data
;
2992 struct elfNN_ia64_link_hash_table
*ia64_info
;
2996 ia64_info
= elfNN_ia64_hash_table (info
);
2997 if (ia64_info
== NULL
)
2999 dynobj
= ia64_info
->root
.dynobj
;
3000 ia64_info
->self_dtpmod_offset
= (bfd_vma
) -1;
3001 BFD_ASSERT(dynobj
!= NULL
);
3004 /* Set the contents of the .interp section to the interpreter. */
3005 if (ia64_info
->root
.dynamic_sections_created
3006 && bfd_link_executable (info
) && !info
->nointerp
)
3008 sec
= bfd_get_linker_section (dynobj
, ".interp");
3009 BFD_ASSERT (sec
!= NULL
);
3010 sec
->contents
= (bfd_byte
*) ELF_DYNAMIC_INTERPRETER
;
3011 sec
->size
= strlen (ELF_DYNAMIC_INTERPRETER
) + 1;
3014 /* Allocate the GOT entries. */
3016 if (ia64_info
->root
.sgot
)
3019 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_data_got
, &data
);
3020 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_fptr_got
, &data
);
3021 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_local_got
, &data
);
3022 ia64_info
->root
.sgot
->size
= data
.ofs
;
3025 /* Allocate the FPTR entries. */
3027 if (ia64_info
->fptr_sec
)
3030 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_fptr
, &data
);
3031 ia64_info
->fptr_sec
->size
= data
.ofs
;
3034 /* Now that we've seen all of the input files, we can decide which
3035 symbols need plt entries. Allocate the minimal PLT entries first.
3036 We do this even though dynamic_sections_created may be FALSE, because
3037 this has the side-effect of clearing want_plt and want_plt2. */
3040 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_plt_entries
, &data
);
3042 ia64_info
->minplt_entries
= 0;
3045 ia64_info
->minplt_entries
3046 = (data
.ofs
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
3049 /* Align the pointer for the plt2 entries. */
3050 data
.ofs
= (data
.ofs
+ 31) & (bfd_vma
) -32;
3052 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_plt2_entries
, &data
);
3053 if (data
.ofs
!= 0 || ia64_info
->root
.dynamic_sections_created
)
3055 /* FIXME: we always reserve the memory for dynamic linker even if
3056 there are no PLT entries since dynamic linker may assume the
3057 reserved memory always exists. */
3059 BFD_ASSERT (ia64_info
->root
.dynamic_sections_created
);
3061 ia64_info
->root
.splt
->size
= data
.ofs
;
3063 /* If we've got a .plt, we need some extra memory for the dynamic
3064 linker. We stuff these in .got.plt. */
3065 ia64_info
->root
.sgotplt
->size
= 8 * PLT_RESERVED_WORDS
;
3068 /* Allocate the PLTOFF entries. */
3070 if (ia64_info
->pltoff_sec
)
3073 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_pltoff_entries
, &data
);
3074 ia64_info
->pltoff_sec
->size
= data
.ofs
;
3077 if (ia64_info
->root
.dynamic_sections_created
)
3079 /* Allocate space for the dynamic relocations that turned out to be
3082 if (bfd_link_pic (info
) && ia64_info
->self_dtpmod_offset
!= (bfd_vma
) -1)
3083 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
3084 data
.only_got
= FALSE
;
3085 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_dynrel_entries
, &data
);
3088 /* We have now determined the sizes of the various dynamic sections.
3089 Allocate memory for them. */
3090 for (sec
= dynobj
->sections
; sec
!= NULL
; sec
= sec
->next
)
3094 if (!(sec
->flags
& SEC_LINKER_CREATED
))
3097 /* If we don't need this section, strip it from the output file.
3098 There were several sections primarily related to dynamic
3099 linking that must be create before the linker maps input
3100 sections to output sections. The linker does that before
3101 bfd_elf_size_dynamic_sections is called, and it is that
3102 function which decides whether anything needs to go into
3105 strip
= (sec
->size
== 0);
3107 if (sec
== ia64_info
->root
.sgot
)
3109 else if (sec
== ia64_info
->root
.srelgot
)
3112 ia64_info
->root
.srelgot
= NULL
;
3114 /* We use the reloc_count field as a counter if we need to
3115 copy relocs into the output file. */
3116 sec
->reloc_count
= 0;
3118 else if (sec
== ia64_info
->fptr_sec
)
3121 ia64_info
->fptr_sec
= NULL
;
3123 else if (sec
== ia64_info
->rel_fptr_sec
)
3126 ia64_info
->rel_fptr_sec
= NULL
;
3128 /* We use the reloc_count field as a counter if we need to
3129 copy relocs into the output file. */
3130 sec
->reloc_count
= 0;
3132 else if (sec
== ia64_info
->root
.splt
)
3135 ia64_info
->root
.splt
= NULL
;
3137 else if (sec
== ia64_info
->pltoff_sec
)
3140 ia64_info
->pltoff_sec
= NULL
;
3142 else if (sec
== ia64_info
->rel_pltoff_sec
)
3145 ia64_info
->rel_pltoff_sec
= NULL
;
3148 ia64_info
->root
.dt_jmprel_required
= TRUE
;
3149 /* We use the reloc_count field as a counter if we need to
3150 copy relocs into the output file. */
3151 sec
->reloc_count
= 0;
3158 /* It's OK to base decisions on the section name, because none
3159 of the dynobj section names depend upon the input files. */
3160 name
= bfd_section_name (sec
);
3162 if (strcmp (name
, ".got.plt") == 0)
3164 else if (startswith (name
, ".rel"))
3168 /* We use the reloc_count field as a counter if we need to
3169 copy relocs into the output file. */
3170 sec
->reloc_count
= 0;
3178 sec
->flags
|= SEC_EXCLUDE
;
3181 /* Allocate memory for the section contents. */
3182 sec
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, sec
->size
);
3183 if (sec
->contents
== NULL
&& sec
->size
!= 0)
3188 if (ia64_info
->root
.dynamic_sections_created
)
3190 /* Add some entries to the .dynamic section. We fill in the values
3191 later (in finish_dynamic_sections) but we must add the entries now
3192 so that we get the correct size for the .dynamic section. */
3194 #define add_dynamic_entry(TAG, VAL) \
3195 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3197 if (!_bfd_elf_add_dynamic_tags (output_bfd
, info
, TRUE
))
3200 if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE
, 0))
3204 /* ??? Perhaps force __gp local. */
3210 elfNN_ia64_install_dyn_reloc (bfd
*abfd
, struct bfd_link_info
*info
,
3211 asection
*sec
, asection
*srel
,
3212 bfd_vma offset
, unsigned int type
,
3213 long dynindx
, bfd_vma addend
)
3215 Elf_Internal_Rela outrel
;
3218 BFD_ASSERT (dynindx
!= -1);
3219 outrel
.r_info
= ELFNN_R_INFO (dynindx
, type
);
3220 outrel
.r_addend
= addend
;
3221 outrel
.r_offset
= _bfd_elf_section_offset (abfd
, info
, sec
, offset
);
3222 if (outrel
.r_offset
>= (bfd_vma
) -2)
3224 /* Run for the hills. We shouldn't be outputting a relocation
3225 for this. So do what everyone else does and output a no-op. */
3226 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
3227 outrel
.r_addend
= 0;
3228 outrel
.r_offset
= 0;
3231 outrel
.r_offset
+= sec
->output_section
->vma
+ sec
->output_offset
;
3233 loc
= srel
->contents
;
3234 loc
+= srel
->reloc_count
++ * sizeof (ElfNN_External_Rela
);
3235 bfd_elfNN_swap_reloca_out (abfd
, &outrel
, loc
);
3236 BFD_ASSERT (sizeof (ElfNN_External_Rela
) * srel
->reloc_count
<= srel
->size
);
3239 /* Store an entry for target address TARGET_ADDR in the linkage table
3240 and return the gp-relative address of the linkage table entry. */
3243 set_got_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3244 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3245 long dynindx
, bfd_vma addend
, bfd_vma value
,
3246 unsigned int dyn_r_type
)
3248 struct elfNN_ia64_link_hash_table
*ia64_info
;
3253 ia64_info
= elfNN_ia64_hash_table (info
);
3254 if (ia64_info
== NULL
)
3257 got_sec
= ia64_info
->root
.sgot
;
3261 case R_IA64_TPREL64LSB
:
3262 done
= dyn_i
->tprel_done
;
3263 dyn_i
->tprel_done
= TRUE
;
3264 got_offset
= dyn_i
->tprel_offset
;
3266 case R_IA64_DTPMOD64LSB
:
3267 if (dyn_i
->dtpmod_offset
!= ia64_info
->self_dtpmod_offset
)
3269 done
= dyn_i
->dtpmod_done
;
3270 dyn_i
->dtpmod_done
= TRUE
;
3274 done
= ia64_info
->self_dtpmod_done
;
3275 ia64_info
->self_dtpmod_done
= TRUE
;
3278 got_offset
= dyn_i
->dtpmod_offset
;
3280 case R_IA64_DTPREL32LSB
:
3281 case R_IA64_DTPREL64LSB
:
3282 done
= dyn_i
->dtprel_done
;
3283 dyn_i
->dtprel_done
= TRUE
;
3284 got_offset
= dyn_i
->dtprel_offset
;
3287 done
= dyn_i
->got_done
;
3288 dyn_i
->got_done
= TRUE
;
3289 got_offset
= dyn_i
->got_offset
;
3293 BFD_ASSERT ((got_offset
& 7) == 0);
3297 /* Store the target address in the linkage table entry. */
3298 bfd_put_64 (abfd
, value
, got_sec
->contents
+ got_offset
);
3300 /* Install a dynamic relocation if needed. */
3301 if (((bfd_link_pic (info
)
3303 || ELF_ST_VISIBILITY (dyn_i
->h
->other
) == STV_DEFAULT
3304 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
3305 && dyn_r_type
!= R_IA64_DTPREL32LSB
3306 && dyn_r_type
!= R_IA64_DTPREL64LSB
)
3307 || elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, info
, dyn_r_type
)
3309 && (dyn_r_type
== R_IA64_FPTR32LSB
3310 || dyn_r_type
== R_IA64_FPTR64LSB
)))
3311 && (!dyn_i
->want_ltoff_fptr
3312 || !bfd_link_pie (info
)
3314 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
3317 && dyn_r_type
!= R_IA64_TPREL64LSB
3318 && dyn_r_type
!= R_IA64_DTPMOD64LSB
3319 && dyn_r_type
!= R_IA64_DTPREL32LSB
3320 && dyn_r_type
!= R_IA64_DTPREL64LSB
)
3322 dyn_r_type
= R_IA64_RELNNLSB
;
3327 if (bfd_big_endian (abfd
))
3331 case R_IA64_REL32LSB
:
3332 dyn_r_type
= R_IA64_REL32MSB
;
3334 case R_IA64_DIR32LSB
:
3335 dyn_r_type
= R_IA64_DIR32MSB
;
3337 case R_IA64_FPTR32LSB
:
3338 dyn_r_type
= R_IA64_FPTR32MSB
;
3340 case R_IA64_DTPREL32LSB
:
3341 dyn_r_type
= R_IA64_DTPREL32MSB
;
3343 case R_IA64_REL64LSB
:
3344 dyn_r_type
= R_IA64_REL64MSB
;
3346 case R_IA64_DIR64LSB
:
3347 dyn_r_type
= R_IA64_DIR64MSB
;
3349 case R_IA64_FPTR64LSB
:
3350 dyn_r_type
= R_IA64_FPTR64MSB
;
3352 case R_IA64_TPREL64LSB
:
3353 dyn_r_type
= R_IA64_TPREL64MSB
;
3355 case R_IA64_DTPMOD64LSB
:
3356 dyn_r_type
= R_IA64_DTPMOD64MSB
;
3358 case R_IA64_DTPREL64LSB
:
3359 dyn_r_type
= R_IA64_DTPREL64MSB
;
3367 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, got_sec
,
3368 ia64_info
->root
.srelgot
,
3369 got_offset
, dyn_r_type
,
3374 /* Return the address of the linkage table entry. */
3375 value
= (got_sec
->output_section
->vma
3376 + got_sec
->output_offset
3382 /* Fill in a function descriptor consisting of the function's code
3383 address and its global pointer. Return the descriptor's address. */
3386 set_fptr_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3387 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3390 struct elfNN_ia64_link_hash_table
*ia64_info
;
3393 ia64_info
= elfNN_ia64_hash_table (info
);
3394 if (ia64_info
== NULL
)
3397 fptr_sec
= ia64_info
->fptr_sec
;
3399 if (!dyn_i
->fptr_done
)
3401 dyn_i
->fptr_done
= 1;
3403 /* Fill in the function descriptor. */
3404 bfd_put_64 (abfd
, value
, fptr_sec
->contents
+ dyn_i
->fptr_offset
);
3405 bfd_put_64 (abfd
, _bfd_get_gp_value (abfd
),
3406 fptr_sec
->contents
+ dyn_i
->fptr_offset
+ 8);
3407 if (ia64_info
->rel_fptr_sec
)
3409 Elf_Internal_Rela outrel
;
3412 if (bfd_little_endian (abfd
))
3413 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_IPLTLSB
);
3415 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_IPLTMSB
);
3416 outrel
.r_addend
= value
;
3417 outrel
.r_offset
= (fptr_sec
->output_section
->vma
3418 + fptr_sec
->output_offset
3419 + dyn_i
->fptr_offset
);
3420 loc
= ia64_info
->rel_fptr_sec
->contents
;
3421 loc
+= ia64_info
->rel_fptr_sec
->reloc_count
++
3422 * sizeof (ElfNN_External_Rela
);
3423 bfd_elfNN_swap_reloca_out (abfd
, &outrel
, loc
);
3427 /* Return the descriptor's address. */
3428 value
= (fptr_sec
->output_section
->vma
3429 + fptr_sec
->output_offset
3430 + dyn_i
->fptr_offset
);
3435 /* Fill in a PLTOFF entry consisting of the function's code address
3436 and its global pointer. Return the descriptor's address. */
3439 set_pltoff_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3440 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3441 bfd_vma value
, bfd_boolean is_plt
)
3443 struct elfNN_ia64_link_hash_table
*ia64_info
;
3444 asection
*pltoff_sec
;
3446 ia64_info
= elfNN_ia64_hash_table (info
);
3447 if (ia64_info
== NULL
)
3450 pltoff_sec
= ia64_info
->pltoff_sec
;
3452 /* Don't do anything if this symbol uses a real PLT entry. In
3453 that case, we'll fill this in during finish_dynamic_symbol. */
3454 if ((! dyn_i
->want_plt
|| is_plt
)
3455 && !dyn_i
->pltoff_done
)
3457 bfd_vma gp
= _bfd_get_gp_value (abfd
);
3459 /* Fill in the function descriptor. */
3460 bfd_put_64 (abfd
, value
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
);
3461 bfd_put_64 (abfd
, gp
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
+ 8);
3463 /* Install dynamic relocations if needed. */
3465 && bfd_link_pic (info
)
3467 || ELF_ST_VISIBILITY (dyn_i
->h
->other
) == STV_DEFAULT
3468 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
3470 unsigned int dyn_r_type
;
3472 if (bfd_big_endian (abfd
))
3473 dyn_r_type
= R_IA64_RELNNMSB
;
3475 dyn_r_type
= R_IA64_RELNNLSB
;
3477 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
3478 ia64_info
->rel_pltoff_sec
,
3479 dyn_i
->pltoff_offset
,
3480 dyn_r_type
, 0, value
);
3481 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
3482 ia64_info
->rel_pltoff_sec
,
3483 dyn_i
->pltoff_offset
+ ARCH_SIZE
/ 8,
3487 dyn_i
->pltoff_done
= 1;
3490 /* Return the descriptor's address. */
3491 value
= (pltoff_sec
->output_section
->vma
3492 + pltoff_sec
->output_offset
3493 + dyn_i
->pltoff_offset
);
3498 /* Return the base VMA address which should be subtracted from real addresses
3499 when resolving @tprel() relocation.
3500 Main program TLS (whose template starts at PT_TLS p_vaddr)
3501 is assigned offset round(2 * size of pointer, PT_TLS p_align). */
3504 elfNN_ia64_tprel_base (struct bfd_link_info
*info
)
3506 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3507 return tls_sec
->vma
- align_power ((bfd_vma
) ARCH_SIZE
/ 4,
3508 tls_sec
->alignment_power
);
3511 /* Return the base VMA address which should be subtracted from real addresses
3512 when resolving @dtprel() relocation.
3513 This is PT_TLS segment p_vaddr. */
3516 elfNN_ia64_dtprel_base (struct bfd_link_info
*info
)
3518 return elf_hash_table (info
)->tls_sec
->vma
;
3521 /* Called through qsort to sort the .IA_64.unwind section during a
3522 non-relocatable link. Set elfNN_ia64_unwind_entry_compare_bfd
3523 to the output bfd so we can do proper endianness frobbing. */
3525 static bfd
*elfNN_ia64_unwind_entry_compare_bfd
;
3528 elfNN_ia64_unwind_entry_compare (const void * a
, const void * b
)
3532 av
= bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd
, a
);
3533 bv
= bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd
, b
);
3535 return (av
< bv
? -1 : av
> bv
? 1 : 0);
3538 /* Make sure we've got ourselves a nice fat __gp value. */
3540 elfNN_ia64_choose_gp (bfd
*abfd
, struct bfd_link_info
*info
, bfd_boolean final
)
3542 bfd_vma min_vma
= (bfd_vma
) -1, max_vma
= 0;
3543 bfd_vma min_short_vma
= min_vma
, max_short_vma
= 0;
3544 struct elf_link_hash_entry
*gp
;
3547 struct elfNN_ia64_link_hash_table
*ia64_info
;
3549 ia64_info
= elfNN_ia64_hash_table (info
);
3550 if (ia64_info
== NULL
)
3553 /* Find the min and max vma of all sections marked short. Also collect
3554 min and max vma of any type, for use in selecting a nice gp. */
3555 for (os
= abfd
->sections
; os
; os
= os
->next
)
3559 if ((os
->flags
& SEC_ALLOC
) == 0)
3563 /* When this function is called from elfNN_ia64_final_link
3564 the correct value to use is os->size. When called from
3565 elfNN_ia64_relax_section we are in the middle of section
3566 sizing; some sections will already have os->size set, others
3567 will have os->size zero and os->rawsize the previous size. */
3568 hi
= os
->vma
+ (!final
&& os
->rawsize
? os
->rawsize
: os
->size
);
3576 if (os
->flags
& SEC_SMALL_DATA
)
3578 if (min_short_vma
> lo
)
3580 if (max_short_vma
< hi
)
3585 if (ia64_info
->min_short_sec
)
3588 > (ia64_info
->min_short_sec
->vma
3589 + ia64_info
->min_short_offset
))
3590 min_short_vma
= (ia64_info
->min_short_sec
->vma
3591 + ia64_info
->min_short_offset
);
3593 < (ia64_info
->max_short_sec
->vma
3594 + ia64_info
->max_short_offset
))
3595 max_short_vma
= (ia64_info
->max_short_sec
->vma
3596 + ia64_info
->max_short_offset
);
3599 /* See if the user wants to force a value. */
3600 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
3604 && (gp
->root
.type
== bfd_link_hash_defined
3605 || gp
->root
.type
== bfd_link_hash_defweak
))
3607 asection
*gp_sec
= gp
->root
.u
.def
.section
;
3608 gp_val
= (gp
->root
.u
.def
.value
3609 + gp_sec
->output_section
->vma
3610 + gp_sec
->output_offset
);
3614 /* Pick a sensible value. */
3616 if (ia64_info
->min_short_sec
)
3618 bfd_vma short_range
= max_short_vma
- min_short_vma
;
3620 /* If min_short_sec is set, pick one in the middle bewteen
3621 min_short_vma and max_short_vma. */
3622 if (short_range
>= 0x400000)
3624 gp_val
= min_short_vma
+ short_range
/ 2;
3628 asection
*got_sec
= ia64_info
->root
.sgot
;
3630 /* Start with just the address of the .got. */
3632 gp_val
= got_sec
->output_section
->vma
;
3633 else if (max_short_vma
!= 0)
3634 gp_val
= min_short_vma
;
3635 else if (max_vma
- min_vma
< 0x200000)
3638 gp_val
= max_vma
- 0x200000 + 8;
3641 /* If it is possible to address the entire image, but we
3642 don't with the choice above, adjust. */
3643 if (max_vma
- min_vma
< 0x400000
3644 && (max_vma
- gp_val
>= 0x200000
3645 || gp_val
- min_vma
> 0x200000))
3646 gp_val
= min_vma
+ 0x200000;
3647 else if (max_short_vma
!= 0)
3649 /* If we don't cover all the short data, adjust. */
3650 if (max_short_vma
- gp_val
>= 0x200000)
3651 gp_val
= min_short_vma
+ 0x200000;
3653 /* If we're addressing stuff past the end, adjust back. */
3654 if (gp_val
> max_vma
)
3655 gp_val
= max_vma
- 0x200000 + 8;
3659 /* Validate whether all SHF_IA_64_SHORT sections are within
3660 range of the chosen GP. */
3662 if (max_short_vma
!= 0)
3664 if (max_short_vma
- min_short_vma
>= 0x400000)
3668 /* xgettext:c-format */
3669 (_("%pB: short data segment overflowed (%#" PRIx64
" >= 0x400000)"),
3670 abfd
, (uint64_t) (max_short_vma
- min_short_vma
));
3673 else if ((gp_val
> min_short_vma
3674 && gp_val
- min_short_vma
> 0x200000)
3675 || (gp_val
< max_short_vma
3676 && max_short_vma
- gp_val
>= 0x200000))
3679 (_("%pB: __gp does not cover short data segment"), abfd
);
3684 _bfd_set_gp_value (abfd
, gp_val
);
3690 elfNN_ia64_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
3692 struct elfNN_ia64_link_hash_table
*ia64_info
;
3693 asection
*unwind_output_sec
;
3695 ia64_info
= elfNN_ia64_hash_table (info
);
3696 if (ia64_info
== NULL
)
3699 /* Make sure we've got ourselves a nice fat __gp value. */
3700 if (!bfd_link_relocatable (info
))
3703 struct elf_link_hash_entry
*gp
;
3705 /* We assume after gp is set, section size will only decrease. We
3706 need to adjust gp for it. */
3707 _bfd_set_gp_value (abfd
, 0);
3708 if (! elfNN_ia64_choose_gp (abfd
, info
, TRUE
))
3710 gp_val
= _bfd_get_gp_value (abfd
);
3712 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
3716 gp
->root
.type
= bfd_link_hash_defined
;
3717 gp
->root
.u
.def
.value
= gp_val
;
3718 gp
->root
.u
.def
.section
= bfd_abs_section_ptr
;
3722 /* If we're producing a final executable, we need to sort the contents
3723 of the .IA_64.unwind section. Force this section to be relocated
3724 into memory rather than written immediately to the output file. */
3725 unwind_output_sec
= NULL
;
3726 if (!bfd_link_relocatable (info
))
3728 asection
*s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_unwind
);
3731 unwind_output_sec
= s
->output_section
;
3732 unwind_output_sec
->contents
3733 = bfd_malloc (unwind_output_sec
->size
);
3734 if (unwind_output_sec
->contents
== NULL
)
3739 /* Invoke the regular ELF backend linker to do all the work. */
3740 if (!bfd_elf_final_link (abfd
, info
))
3743 if (unwind_output_sec
)
3745 elfNN_ia64_unwind_entry_compare_bfd
= abfd
;
3746 qsort (unwind_output_sec
->contents
,
3747 (size_t) (unwind_output_sec
->size
/ 24),
3749 elfNN_ia64_unwind_entry_compare
);
3751 if (! bfd_set_section_contents (abfd
, unwind_output_sec
,
3752 unwind_output_sec
->contents
, (bfd_vma
) 0,
3753 unwind_output_sec
->size
))
3761 elfNN_ia64_relocate_section (bfd
*output_bfd
,
3762 struct bfd_link_info
*info
,
3764 asection
*input_section
,
3766 Elf_Internal_Rela
*relocs
,
3767 Elf_Internal_Sym
*local_syms
,
3768 asection
**local_sections
)
3770 struct elfNN_ia64_link_hash_table
*ia64_info
;
3771 Elf_Internal_Shdr
*symtab_hdr
;
3772 Elf_Internal_Rela
*rel
;
3773 Elf_Internal_Rela
*relend
;
3775 bfd_boolean ret_val
= TRUE
; /* for non-fatal errors */
3778 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3779 ia64_info
= elfNN_ia64_hash_table (info
);
3780 if (ia64_info
== NULL
)
3783 /* Infect various flags from the input section to the output section. */
3784 if (bfd_link_relocatable (info
))
3788 flags
= elf_section_data(input_section
)->this_hdr
.sh_flags
;
3789 flags
&= SHF_IA_64_NORECOV
;
3791 elf_section_data(input_section
->output_section
)
3792 ->this_hdr
.sh_flags
|= flags
;
3795 gp_val
= _bfd_get_gp_value (output_bfd
);
3796 srel
= get_reloc_section (input_bfd
, ia64_info
, input_section
, FALSE
);
3799 relend
= relocs
+ input_section
->reloc_count
;
3800 for (; rel
< relend
; ++rel
)
3802 struct elf_link_hash_entry
*h
;
3803 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3804 bfd_reloc_status_type r
;
3805 reloc_howto_type
*howto
;
3806 unsigned long r_symndx
;
3807 Elf_Internal_Sym
*sym
;
3808 unsigned int r_type
;
3812 bfd_boolean dynamic_symbol_p
;
3813 bfd_boolean undef_weak_ref
;
3815 r_type
= ELFNN_R_TYPE (rel
->r_info
);
3816 if (r_type
> R_IA64_MAX_RELOC_CODE
)
3818 /* xgettext:c-format */
3819 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
3820 input_bfd
, (int) r_type
);
3821 bfd_set_error (bfd_error_bad_value
);
3826 howto
= ia64_elf_lookup_howto (r_type
);
3833 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
3837 undef_weak_ref
= FALSE
;
3839 if (r_symndx
< symtab_hdr
->sh_info
)
3841 /* Reloc against local symbol. */
3843 sym
= local_syms
+ r_symndx
;
3844 sym_sec
= local_sections
[r_symndx
];
3846 value
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &msec
, rel
);
3847 if (!bfd_link_relocatable (info
)
3848 && (sym_sec
->flags
& SEC_MERGE
) != 0
3849 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3850 && sym_sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
3852 struct elfNN_ia64_local_hash_entry
*loc_h
;
3854 loc_h
= get_local_sym_hash (ia64_info
, input_bfd
, rel
, FALSE
);
3855 if (loc_h
&& ! loc_h
->sec_merge_done
)
3857 struct elfNN_ia64_dyn_sym_info
*dynent
;
3860 for (count
= loc_h
->count
, dynent
= loc_h
->info
;
3866 _bfd_merged_section_offset (output_bfd
, &msec
,
3867 elf_section_data (msec
)->
3871 dynent
->addend
-= sym
->st_value
;
3872 dynent
->addend
+= msec
->output_section
->vma
3873 + msec
->output_offset
3874 - sym_sec
->output_section
->vma
3875 - sym_sec
->output_offset
;
3878 /* We may have introduced duplicated entries. We need
3879 to remove them properly. */
3880 count
= sort_dyn_sym_info (loc_h
->info
, loc_h
->count
);
3881 if (count
!= loc_h
->count
)
3883 loc_h
->count
= count
;
3884 loc_h
->sorted_count
= count
;
3887 loc_h
->sec_merge_done
= 1;
3893 bfd_boolean unresolved_reloc
;
3894 bfd_boolean warned
, ignored
;
3895 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
3897 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3898 r_symndx
, symtab_hdr
, sym_hashes
,
3900 unresolved_reloc
, warned
, ignored
);
3902 if (h
->root
.type
== bfd_link_hash_undefweak
)
3903 undef_weak_ref
= TRUE
;
3904 else if (warned
|| (ignored
&& bfd_link_executable (info
)))
3908 if (sym_sec
!= NULL
&& discarded_section (sym_sec
))
3909 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3910 rel
, 1, relend
, howto
, 0, contents
);
3912 if (bfd_link_relocatable (info
))
3915 hit_addr
= contents
+ rel
->r_offset
;
3916 value
+= rel
->r_addend
;
3917 dynamic_symbol_p
= elfNN_ia64_dynamic_symbol_p (h
, info
, r_type
);
3928 case R_IA64_DIR32MSB
:
3929 case R_IA64_DIR32LSB
:
3930 case R_IA64_DIR64MSB
:
3931 case R_IA64_DIR64LSB
:
3932 /* Install a dynamic relocation for this reloc. */
3933 if ((dynamic_symbol_p
|| bfd_link_pic (info
))
3934 && r_symndx
!= STN_UNDEF
3935 && (input_section
->flags
& SEC_ALLOC
) != 0)
3937 unsigned int dyn_r_type
;
3941 BFD_ASSERT (srel
!= NULL
);
3948 /* ??? People shouldn't be doing non-pic code in
3949 shared libraries nor dynamic executables. */
3951 /* xgettext:c-format */
3952 (_("%pB: non-pic code with imm relocation against dynamic symbol `%s'"),
3954 h
? h
->root
.root
.string
3955 : bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3964 /* If we don't need dynamic symbol lookup, find a
3965 matching RELATIVE relocation. */
3966 dyn_r_type
= r_type
;
3967 if (dynamic_symbol_p
)
3969 dynindx
= h
->dynindx
;
3970 addend
= rel
->r_addend
;
3977 case R_IA64_DIR32MSB
:
3978 dyn_r_type
= R_IA64_REL32MSB
;
3980 case R_IA64_DIR32LSB
:
3981 dyn_r_type
= R_IA64_REL32LSB
;
3983 case R_IA64_DIR64MSB
:
3984 dyn_r_type
= R_IA64_REL64MSB
;
3986 case R_IA64_DIR64LSB
:
3987 dyn_r_type
= R_IA64_REL64LSB
;
3997 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
3998 srel
, rel
->r_offset
, dyn_r_type
,
4003 case R_IA64_LTV32MSB
:
4004 case R_IA64_LTV32LSB
:
4005 case R_IA64_LTV64MSB
:
4006 case R_IA64_LTV64LSB
:
4007 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4010 case R_IA64_GPREL22
:
4011 case R_IA64_GPREL64I
:
4012 case R_IA64_GPREL32MSB
:
4013 case R_IA64_GPREL32LSB
:
4014 case R_IA64_GPREL64MSB
:
4015 case R_IA64_GPREL64LSB
:
4016 if (dynamic_symbol_p
)
4019 /* xgettext:c-format */
4020 (_("%pB: @gprel relocation against dynamic symbol %s"),
4022 h
? h
->root
.root
.string
4023 : bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4029 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4032 case R_IA64_LTOFF22
:
4033 case R_IA64_LTOFF22X
:
4034 case R_IA64_LTOFF64I
:
4035 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4036 value
= set_got_entry (input_bfd
, info
, dyn_i
, (h
? h
->dynindx
: -1),
4037 rel
->r_addend
, value
, R_IA64_DIRNNLSB
);
4039 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4042 case R_IA64_PLTOFF22
:
4043 case R_IA64_PLTOFF64I
:
4044 case R_IA64_PLTOFF64MSB
:
4045 case R_IA64_PLTOFF64LSB
:
4046 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4047 value
= set_pltoff_entry (output_bfd
, info
, dyn_i
, value
, FALSE
);
4049 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4052 case R_IA64_FPTR64I
:
4053 case R_IA64_FPTR32MSB
:
4054 case R_IA64_FPTR32LSB
:
4055 case R_IA64_FPTR64MSB
:
4056 case R_IA64_FPTR64LSB
:
4057 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4058 if (dyn_i
->want_fptr
)
4060 if (!undef_weak_ref
)
4061 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
4063 if (!dyn_i
->want_fptr
|| bfd_link_pie (info
))
4066 unsigned int dyn_r_type
= r_type
;
4067 bfd_vma addend
= rel
->r_addend
;
4069 /* Otherwise, we expect the dynamic linker to create
4072 if (dyn_i
->want_fptr
)
4074 if (r_type
== R_IA64_FPTR64I
)
4076 /* We can't represent this without a dynamic symbol.
4077 Adjust the relocation to be against an output
4078 section symbol, which are always present in the
4079 dynamic symbol table. */
4080 /* ??? People shouldn't be doing non-pic code in
4081 shared libraries. Hork. */
4083 (_("%pB: linking non-pic code in a position independent executable"),
4090 dyn_r_type
= r_type
+ R_IA64_RELNNLSB
- R_IA64_FPTRNNLSB
;
4094 if (h
->dynindx
!= -1)
4095 dynindx
= h
->dynindx
;
4097 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4098 (info
, h
->root
.u
.def
.section
->owner
,
4099 global_sym_index (h
)));
4104 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4105 (info
, input_bfd
, (long) r_symndx
));
4109 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4110 srel
, rel
->r_offset
, dyn_r_type
,
4114 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4117 case R_IA64_LTOFF_FPTR22
:
4118 case R_IA64_LTOFF_FPTR64I
:
4119 case R_IA64_LTOFF_FPTR32MSB
:
4120 case R_IA64_LTOFF_FPTR32LSB
:
4121 case R_IA64_LTOFF_FPTR64MSB
:
4122 case R_IA64_LTOFF_FPTR64LSB
:
4126 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4127 if (dyn_i
->want_fptr
)
4129 BFD_ASSERT (h
== NULL
|| h
->dynindx
== -1);
4130 if (!undef_weak_ref
)
4131 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
4136 /* Otherwise, we expect the dynamic linker to create
4140 if (h
->dynindx
!= -1)
4141 dynindx
= h
->dynindx
;
4143 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4144 (info
, h
->root
.u
.def
.section
->owner
,
4145 global_sym_index (h
)));
4148 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4149 (info
, input_bfd
, (long) r_symndx
));
4153 value
= set_got_entry (output_bfd
, info
, dyn_i
, dynindx
,
4154 rel
->r_addend
, value
, R_IA64_FPTRNNLSB
);
4156 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4160 case R_IA64_PCREL32MSB
:
4161 case R_IA64_PCREL32LSB
:
4162 case R_IA64_PCREL64MSB
:
4163 case R_IA64_PCREL64LSB
:
4164 /* Install a dynamic relocation for this reloc. */
4165 if (dynamic_symbol_p
&& r_symndx
!= STN_UNDEF
)
4167 BFD_ASSERT (srel
!= NULL
);
4169 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4170 srel
, rel
->r_offset
, r_type
,
4171 h
->dynindx
, rel
->r_addend
);
4175 case R_IA64_PCREL21B
:
4176 case R_IA64_PCREL60B
:
4177 /* We should have created a PLT entry for any dynamic symbol. */
4180 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, FALSE
);
4182 if (dyn_i
&& dyn_i
->want_plt2
)
4184 /* Should have caught this earlier. */
4185 BFD_ASSERT (rel
->r_addend
== 0);
4187 value
= (ia64_info
->root
.splt
->output_section
->vma
4188 + ia64_info
->root
.splt
->output_offset
4189 + dyn_i
->plt2_offset
);
4193 /* Since there's no PLT entry, Validate that this is
4195 BFD_ASSERT (undef_weak_ref
|| sym_sec
->output_section
!= NULL
);
4197 /* If the symbol is undef_weak, we shouldn't be trying
4198 to call it. There's every chance that we'd wind up
4199 with an out-of-range fixup here. Don't bother setting
4200 any value at all. */
4206 case R_IA64_PCREL21BI
:
4207 case R_IA64_PCREL21F
:
4208 case R_IA64_PCREL21M
:
4209 case R_IA64_PCREL22
:
4210 case R_IA64_PCREL64I
:
4211 /* The PCREL21BI reloc is specifically not intended for use with
4212 dynamic relocs. PCREL21F and PCREL21M are used for speculation
4213 fixup code, and thus probably ought not be dynamic. The
4214 PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs. */
4215 if (dynamic_symbol_p
)
4219 if (r_type
== R_IA64_PCREL21BI
)
4220 /* xgettext:c-format */
4221 msg
= _("%pB: @internal branch to dynamic symbol %s");
4222 else if (r_type
== R_IA64_PCREL21F
|| r_type
== R_IA64_PCREL21M
)
4223 /* xgettext:c-format */
4224 msg
= _("%pB: speculation fixup to dynamic symbol %s");
4226 /* xgettext:c-format */
4227 msg
= _("%pB: @pcrel relocation against dynamic symbol %s");
4228 _bfd_error_handler (msg
, input_bfd
,
4229 h
? h
->root
.root
.string
4230 : bfd_elf_sym_name (input_bfd
,
4240 /* Make pc-relative. */
4241 value
-= (input_section
->output_section
->vma
4242 + input_section
->output_offset
4243 + rel
->r_offset
) & ~ (bfd_vma
) 0x3;
4244 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4247 case R_IA64_SEGREL32MSB
:
4248 case R_IA64_SEGREL32LSB
:
4249 case R_IA64_SEGREL64MSB
:
4250 case R_IA64_SEGREL64LSB
:
4252 /* Find the segment that contains the output_section. */
4253 Elf_Internal_Phdr
*p
= _bfd_elf_find_segment_containing_section
4254 (output_bfd
, input_section
->output_section
);
4258 r
= bfd_reloc_notsupported
;
4262 /* The VMA of the segment is the vaddr of the associated
4264 if (value
> p
->p_vaddr
)
4265 value
-= p
->p_vaddr
;
4268 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4273 case R_IA64_SECREL32MSB
:
4274 case R_IA64_SECREL32LSB
:
4275 case R_IA64_SECREL64MSB
:
4276 case R_IA64_SECREL64LSB
:
4277 /* Make output-section relative to section where the symbol
4278 is defined. PR 475 */
4280 value
-= sym_sec
->output_section
->vma
;
4281 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4284 case R_IA64_IPLTMSB
:
4285 case R_IA64_IPLTLSB
:
4286 /* Install a dynamic relocation for this reloc. */
4287 if ((dynamic_symbol_p
|| bfd_link_pic (info
))
4288 && (input_section
->flags
& SEC_ALLOC
) != 0)
4290 BFD_ASSERT (srel
!= NULL
);
4292 /* If we don't need dynamic symbol lookup, install two
4293 RELATIVE relocations. */
4294 if (!dynamic_symbol_p
)
4296 unsigned int dyn_r_type
;
4298 if (r_type
== R_IA64_IPLTMSB
)
4299 dyn_r_type
= R_IA64_REL64MSB
;
4301 dyn_r_type
= R_IA64_REL64LSB
;
4303 elfNN_ia64_install_dyn_reloc (output_bfd
, info
,
4305 srel
, rel
->r_offset
,
4306 dyn_r_type
, 0, value
);
4307 elfNN_ia64_install_dyn_reloc (output_bfd
, info
,
4309 srel
, rel
->r_offset
+ 8,
4310 dyn_r_type
, 0, gp_val
);
4313 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4314 srel
, rel
->r_offset
, r_type
,
4315 h
->dynindx
, rel
->r_addend
);
4318 if (r_type
== R_IA64_IPLTMSB
)
4319 r_type
= R_IA64_DIR64MSB
;
4321 r_type
= R_IA64_DIR64LSB
;
4322 ia64_elf_install_value (hit_addr
, value
, r_type
);
4323 r
= ia64_elf_install_value (hit_addr
+ 8, gp_val
, r_type
);
4326 case R_IA64_TPREL14
:
4327 case R_IA64_TPREL22
:
4328 case R_IA64_TPREL64I
:
4329 if (elf_hash_table (info
)->tls_sec
== NULL
)
4330 goto missing_tls_sec
;
4331 value
-= elfNN_ia64_tprel_base (info
);
4332 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4335 case R_IA64_DTPREL14
:
4336 case R_IA64_DTPREL22
:
4337 case R_IA64_DTPREL64I
:
4338 case R_IA64_DTPREL32LSB
:
4339 case R_IA64_DTPREL32MSB
:
4340 case R_IA64_DTPREL64LSB
:
4341 case R_IA64_DTPREL64MSB
:
4342 if (elf_hash_table (info
)->tls_sec
== NULL
)
4343 goto missing_tls_sec
;
4344 value
-= elfNN_ia64_dtprel_base (info
);
4345 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4348 case R_IA64_LTOFF_TPREL22
:
4349 case R_IA64_LTOFF_DTPMOD22
:
4350 case R_IA64_LTOFF_DTPREL22
:
4353 long dynindx
= h
? h
->dynindx
: -1;
4354 bfd_vma r_addend
= rel
->r_addend
;
4359 case R_IA64_LTOFF_TPREL22
:
4360 if (!dynamic_symbol_p
)
4362 if (elf_hash_table (info
)->tls_sec
== NULL
)
4363 goto missing_tls_sec
;
4364 if (!bfd_link_pic (info
))
4365 value
-= elfNN_ia64_tprel_base (info
);
4368 r_addend
+= value
- elfNN_ia64_dtprel_base (info
);
4372 got_r_type
= R_IA64_TPREL64LSB
;
4374 case R_IA64_LTOFF_DTPMOD22
:
4375 if (!dynamic_symbol_p
&& !bfd_link_pic (info
))
4377 got_r_type
= R_IA64_DTPMOD64LSB
;
4379 case R_IA64_LTOFF_DTPREL22
:
4380 if (!dynamic_symbol_p
)
4382 if (elf_hash_table (info
)->tls_sec
== NULL
)
4383 goto missing_tls_sec
;
4384 value
-= elfNN_ia64_dtprel_base (info
);
4386 got_r_type
= R_IA64_DTPRELNNLSB
;
4389 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4390 value
= set_got_entry (input_bfd
, info
, dyn_i
, dynindx
, r_addend
,
4393 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4398 r
= bfd_reloc_notsupported
;
4407 case bfd_reloc_undefined
:
4408 /* This can happen for global table relative relocs if
4409 __gp is undefined. This is a panic situation so we
4410 don't try to continue. */
4411 (*info
->callbacks
->undefined_symbol
)
4412 (info
, "__gp", input_bfd
, input_section
, rel
->r_offset
, 1);
4415 case bfd_reloc_notsupported
:
4420 name
= h
->root
.root
.string
;
4422 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4424 (*info
->callbacks
->warning
) (info
, _("unsupported reloc"),
4426 input_section
, rel
->r_offset
);
4431 case bfd_reloc_dangerous
:
4432 case bfd_reloc_outofrange
:
4433 case bfd_reloc_overflow
:
4440 name
= h
->root
.root
.string
;
4442 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4447 case R_IA64_TPREL14
:
4448 case R_IA64_TPREL22
:
4449 case R_IA64_TPREL64I
:
4450 case R_IA64_DTPREL14
:
4451 case R_IA64_DTPREL22
:
4452 case R_IA64_DTPREL64I
:
4453 case R_IA64_DTPREL32LSB
:
4454 case R_IA64_DTPREL32MSB
:
4455 case R_IA64_DTPREL64LSB
:
4456 case R_IA64_DTPREL64MSB
:
4457 case R_IA64_LTOFF_TPREL22
:
4458 case R_IA64_LTOFF_DTPMOD22
:
4459 case R_IA64_LTOFF_DTPREL22
:
4461 /* xgettext:c-format */
4462 (_("%pB: missing TLS section for relocation %s against `%s'"
4463 " at %#" PRIx64
" in section `%pA'."),
4464 input_bfd
, howto
->name
, name
,
4465 (uint64_t) rel
->r_offset
, input_section
);
4468 case R_IA64_PCREL21B
:
4469 case R_IA64_PCREL21BI
:
4470 case R_IA64_PCREL21M
:
4471 case R_IA64_PCREL21F
:
4472 if (is_elf_hash_table (info
->hash
))
4474 /* Relaxtion is always performed for ELF output.
4475 Overflow failures for those relocations mean
4476 that the section is too big to relax. */
4478 /* xgettext:c-format */
4479 (_("%pB: Can't relax br (%s) to `%s' at %#" PRIx64
4480 " in section `%pA' with size %#" PRIx64
4482 input_bfd
, howto
->name
, name
, (uint64_t) rel
->r_offset
,
4483 input_section
, (uint64_t) input_section
->size
);
4488 (*info
->callbacks
->reloc_overflow
) (info
,
4509 elfNN_ia64_finish_dynamic_symbol (bfd
*output_bfd
,
4510 struct bfd_link_info
*info
,
4511 struct elf_link_hash_entry
*h
,
4512 Elf_Internal_Sym
*sym
)
4514 struct elfNN_ia64_link_hash_table
*ia64_info
;
4515 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
4517 ia64_info
= elfNN_ia64_hash_table (info
);
4518 if (ia64_info
== NULL
)
4521 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, FALSE
);
4523 /* Fill in the PLT data, if required. */
4524 if (dyn_i
&& dyn_i
->want_plt
)
4526 Elf_Internal_Rela outrel
;
4529 bfd_vma plt_addr
, pltoff_addr
, gp_val
, plt_index
;
4531 gp_val
= _bfd_get_gp_value (output_bfd
);
4533 /* Initialize the minimal PLT entry. */
4535 plt_index
= (dyn_i
->plt_offset
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
4536 plt_sec
= ia64_info
->root
.splt
;
4537 loc
= plt_sec
->contents
+ dyn_i
->plt_offset
;
4539 memcpy (loc
, plt_min_entry
, PLT_MIN_ENTRY_SIZE
);
4540 ia64_elf_install_value (loc
, plt_index
, R_IA64_IMM22
);
4541 ia64_elf_install_value (loc
+2, -dyn_i
->plt_offset
, R_IA64_PCREL21B
);
4543 plt_addr
= (plt_sec
->output_section
->vma
4544 + plt_sec
->output_offset
4545 + dyn_i
->plt_offset
);
4546 pltoff_addr
= set_pltoff_entry (output_bfd
, info
, dyn_i
, plt_addr
, TRUE
);
4548 /* Initialize the FULL PLT entry, if needed. */
4549 if (dyn_i
->want_plt2
)
4551 loc
= plt_sec
->contents
+ dyn_i
->plt2_offset
;
4553 memcpy (loc
, plt_full_entry
, PLT_FULL_ENTRY_SIZE
);
4554 ia64_elf_install_value (loc
, pltoff_addr
- gp_val
, R_IA64_IMM22
);
4556 /* Mark the symbol as undefined, rather than as defined in the
4557 plt section. Leave the value alone. */
4558 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
4559 first place. But perhaps elflink.c did some for us. */
4560 if (!h
->def_regular
)
4561 sym
->st_shndx
= SHN_UNDEF
;
4564 /* Create the dynamic relocation. */
4565 outrel
.r_offset
= pltoff_addr
;
4566 if (bfd_little_endian (output_bfd
))
4567 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_IA64_IPLTLSB
);
4569 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_IA64_IPLTMSB
);
4570 outrel
.r_addend
= 0;
4572 /* This is fun. In the .IA_64.pltoff section, we've got entries
4573 that correspond both to real PLT entries, and those that
4574 happened to resolve to local symbols but need to be created
4575 to satisfy @pltoff relocations. The .rela.IA_64.pltoff
4576 relocations for the real PLT should come at the end of the
4577 section, so that they can be indexed by plt entry at runtime.
4579 We emitted all of the relocations for the non-PLT @pltoff
4580 entries during relocate_section. So we can consider the
4581 existing sec->reloc_count to be the base of the array of
4584 loc
= ia64_info
->rel_pltoff_sec
->contents
;
4585 loc
+= ((ia64_info
->rel_pltoff_sec
->reloc_count
+ plt_index
)
4586 * sizeof (ElfNN_External_Rela
));
4587 bfd_elfNN_swap_reloca_out (output_bfd
, &outrel
, loc
);
4590 /* Mark some specially defined symbols as absolute. */
4591 if (h
== ia64_info
->root
.hdynamic
4592 || h
== ia64_info
->root
.hgot
4593 || h
== ia64_info
->root
.hplt
)
4594 sym
->st_shndx
= SHN_ABS
;
4600 elfNN_ia64_finish_dynamic_sections (bfd
*abfd
,
4601 struct bfd_link_info
*info
)
4603 struct elfNN_ia64_link_hash_table
*ia64_info
;
4606 ia64_info
= elfNN_ia64_hash_table (info
);
4607 if (ia64_info
== NULL
)
4610 dynobj
= ia64_info
->root
.dynobj
;
4612 if (ia64_info
->root
.dynamic_sections_created
)
4614 ElfNN_External_Dyn
*dyncon
, *dynconend
;
4615 asection
*sdyn
, *sgotplt
;
4618 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
4619 sgotplt
= ia64_info
->root
.sgotplt
;
4620 BFD_ASSERT (sdyn
!= NULL
);
4621 dyncon
= (ElfNN_External_Dyn
*) sdyn
->contents
;
4622 dynconend
= (ElfNN_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4624 gp_val
= _bfd_get_gp_value (abfd
);
4626 for (; dyncon
< dynconend
; dyncon
++)
4628 Elf_Internal_Dyn dyn
;
4630 bfd_elfNN_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4635 dyn
.d_un
.d_ptr
= gp_val
;
4639 dyn
.d_un
.d_val
= (ia64_info
->minplt_entries
4640 * sizeof (ElfNN_External_Rela
));
4644 /* See the comment above in finish_dynamic_symbol. */
4645 dyn
.d_un
.d_ptr
= (ia64_info
->rel_pltoff_sec
->output_section
->vma
4646 + ia64_info
->rel_pltoff_sec
->output_offset
4647 + (ia64_info
->rel_pltoff_sec
->reloc_count
4648 * sizeof (ElfNN_External_Rela
)));
4651 case DT_IA_64_PLT_RESERVE
:
4652 dyn
.d_un
.d_ptr
= (sgotplt
->output_section
->vma
4653 + sgotplt
->output_offset
);
4657 bfd_elfNN_swap_dyn_out (abfd
, &dyn
, dyncon
);
4660 /* Initialize the PLT0 entry. */
4661 if (ia64_info
->root
.splt
)
4663 bfd_byte
*loc
= ia64_info
->root
.splt
->contents
;
4666 memcpy (loc
, plt_header
, PLT_HEADER_SIZE
);
4668 pltres
= (sgotplt
->output_section
->vma
4669 + sgotplt
->output_offset
4672 ia64_elf_install_value (loc
+1, pltres
, R_IA64_GPREL22
);
4679 /* ELF file flag handling: */
4681 /* Function to keep IA-64 specific file flags. */
4683 elfNN_ia64_set_private_flags (bfd
*abfd
, flagword flags
)
4685 BFD_ASSERT (!elf_flags_init (abfd
)
4686 || elf_elfheader (abfd
)->e_flags
== flags
);
4688 elf_elfheader (abfd
)->e_flags
= flags
;
4689 elf_flags_init (abfd
) = TRUE
;
4693 /* Merge backend specific data from an object file to the output
4694 object file when linking. */
4697 elfNN_ia64_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
4699 bfd
*obfd
= info
->output_bfd
;
4702 bfd_boolean ok
= TRUE
;
4704 /* FIXME: What should be checked when linking shared libraries? */
4705 if ((ibfd
->flags
& DYNAMIC
) != 0)
4708 if (!is_ia64_elf (ibfd
) || !is_ia64_elf (obfd
))
4711 in_flags
= elf_elfheader (ibfd
)->e_flags
;
4712 out_flags
= elf_elfheader (obfd
)->e_flags
;
4714 if (! elf_flags_init (obfd
))
4716 elf_flags_init (obfd
) = TRUE
;
4717 elf_elfheader (obfd
)->e_flags
= in_flags
;
4719 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
4720 && bfd_get_arch_info (obfd
)->the_default
)
4722 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
4723 bfd_get_mach (ibfd
));
4729 /* Check flag compatibility. */
4730 if (in_flags
== out_flags
)
4733 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
4734 if (!(in_flags
& EF_IA_64_REDUCEDFP
) && (out_flags
& EF_IA_64_REDUCEDFP
))
4735 elf_elfheader (obfd
)->e_flags
&= ~EF_IA_64_REDUCEDFP
;
4737 if ((in_flags
& EF_IA_64_TRAPNIL
) != (out_flags
& EF_IA_64_TRAPNIL
))
4740 (_("%pB: linking trap-on-NULL-dereference with non-trapping files"),
4743 bfd_set_error (bfd_error_bad_value
);
4746 if ((in_flags
& EF_IA_64_BE
) != (out_flags
& EF_IA_64_BE
))
4749 (_("%pB: linking big-endian files with little-endian files"),
4752 bfd_set_error (bfd_error_bad_value
);
4755 if ((in_flags
& EF_IA_64_ABI64
) != (out_flags
& EF_IA_64_ABI64
))
4758 (_("%pB: linking 64-bit files with 32-bit files"),
4761 bfd_set_error (bfd_error_bad_value
);
4764 if ((in_flags
& EF_IA_64_CONS_GP
) != (out_flags
& EF_IA_64_CONS_GP
))
4767 (_("%pB: linking constant-gp files with non-constant-gp files"),
4770 bfd_set_error (bfd_error_bad_value
);
4773 if ((in_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
)
4774 != (out_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
4777 (_("%pB: linking auto-pic files with non-auto-pic files"),
4780 bfd_set_error (bfd_error_bad_value
);
4788 elfNN_ia64_print_private_bfd_data (bfd
*abfd
, void * ptr
)
4790 FILE *file
= (FILE *) ptr
;
4791 flagword flags
= elf_elfheader (abfd
)->e_flags
;
4793 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
4795 fprintf (file
, "private flags = %s%s%s%s%s%s%s%s\n",
4796 (flags
& EF_IA_64_TRAPNIL
) ? "TRAPNIL, " : "",
4797 (flags
& EF_IA_64_EXT
) ? "EXT, " : "",
4798 (flags
& EF_IA_64_BE
) ? "BE, " : "LE, ",
4799 (flags
& EF_IA_64_REDUCEDFP
) ? "REDUCEDFP, " : "",
4800 (flags
& EF_IA_64_CONS_GP
) ? "CONS_GP, " : "",
4801 (flags
& EF_IA_64_NOFUNCDESC_CONS_GP
) ? "NOFUNCDESC_CONS_GP, " : "",
4802 (flags
& EF_IA_64_ABSOLUTE
) ? "ABSOLUTE, " : "",
4803 (flags
& EF_IA_64_ABI64
) ? "ABI64" : "ABI32");
4805 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
4809 static enum elf_reloc_type_class
4810 elfNN_ia64_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4811 const asection
*rel_sec ATTRIBUTE_UNUSED
,
4812 const Elf_Internal_Rela
*rela
)
4814 switch ((int) ELFNN_R_TYPE (rela
->r_info
))
4816 case R_IA64_REL32MSB
:
4817 case R_IA64_REL32LSB
:
4818 case R_IA64_REL64MSB
:
4819 case R_IA64_REL64LSB
:
4820 return reloc_class_relative
;
4821 case R_IA64_IPLTMSB
:
4822 case R_IA64_IPLTLSB
:
4823 return reloc_class_plt
;
4825 return reloc_class_copy
;
4827 return reloc_class_normal
;
4831 static const struct bfd_elf_special_section elfNN_ia64_special_sections
[] =
4833 { STRING_COMMA_LEN (".sbss"), -1, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_IA_64_SHORT
},
4834 { STRING_COMMA_LEN (".sdata"), -1, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_IA_64_SHORT
},
4835 { NULL
, 0, 0, 0, 0 }
4839 elfNN_ia64_object_p (bfd
*abfd
)
4842 asection
*group
, *unwi
, *unw
;
4845 char *unwi_name
, *unw_name
;
4848 if (abfd
->flags
& DYNAMIC
)
4851 /* Flags for fake group section. */
4852 flags
= (SEC_LINKER_CREATED
| SEC_GROUP
| SEC_LINK_ONCE
4855 /* We add a fake section group for each .gnu.linkonce.t.* section,
4856 which isn't in a section group, and its unwind sections. */
4857 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4859 if (elf_sec_group (sec
) == NULL
4860 && ((sec
->flags
& (SEC_LINK_ONCE
| SEC_CODE
| SEC_GROUP
))
4861 == (SEC_LINK_ONCE
| SEC_CODE
))
4862 && startswith (sec
->name
, ".gnu.linkonce.t."))
4864 name
= sec
->name
+ 16;
4866 amt
= strlen (name
) + sizeof (".gnu.linkonce.ia64unwi.");
4867 unwi_name
= bfd_alloc (abfd
, amt
);
4871 strcpy (stpcpy (unwi_name
, ".gnu.linkonce.ia64unwi."), name
);
4872 unwi
= bfd_get_section_by_name (abfd
, unwi_name
);
4874 amt
= strlen (name
) + sizeof (".gnu.linkonce.ia64unw.");
4875 unw_name
= bfd_alloc (abfd
, amt
);
4879 strcpy (stpcpy (unw_name
, ".gnu.linkonce.ia64unw."), name
);
4880 unw
= bfd_get_section_by_name (abfd
, unw_name
);
4882 /* We need to create a fake group section for it and its
4884 group
= bfd_make_section_anyway_with_flags (abfd
, name
,
4889 /* Move the fake group section to the beginning. */
4890 bfd_section_list_remove (abfd
, group
);
4891 bfd_section_list_prepend (abfd
, group
);
4893 elf_next_in_group (group
) = sec
;
4895 elf_group_name (sec
) = name
;
4896 elf_next_in_group (sec
) = sec
;
4897 elf_sec_group (sec
) = group
;
4901 elf_group_name (unwi
) = name
;
4902 elf_next_in_group (unwi
) = sec
;
4903 elf_next_in_group (sec
) = unwi
;
4904 elf_sec_group (unwi
) = group
;
4909 elf_group_name (unw
) = name
;
4912 elf_next_in_group (unw
) = elf_next_in_group (unwi
);
4913 elf_next_in_group (unwi
) = unw
;
4917 elf_next_in_group (unw
) = sec
;
4918 elf_next_in_group (sec
) = unw
;
4920 elf_sec_group (unw
) = group
;
4923 /* Fake SHT_GROUP section header. */
4924 elf_section_data (group
)->this_hdr
.bfd_section
= group
;
4925 elf_section_data (group
)->this_hdr
.sh_type
= SHT_GROUP
;
4932 elfNN_ia64_hpux_vec (const bfd_target
*vec
)
4934 extern const bfd_target ia64_elfNN_hpux_be_vec
;
4935 return (vec
== &ia64_elfNN_hpux_be_vec
);
4939 elfNN_hpux_init_file_header (bfd
*abfd
, struct bfd_link_info
*info
)
4941 Elf_Internal_Ehdr
*i_ehdrp
;
4943 if (!_bfd_elf_init_file_header (abfd
, info
))
4946 i_ehdrp
= elf_elfheader (abfd
);
4947 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
4948 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 1;
4953 elfNN_hpux_backend_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
4954 asection
*sec
, int *retval
)
4956 if (bfd_is_com_section (sec
))
4958 *retval
= SHN_IA_64_ANSI_COMMON
;
4965 elfNN_hpux_backend_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
4968 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
4970 switch (elfsym
->internal_elf_sym
.st_shndx
)
4972 case SHN_IA_64_ANSI_COMMON
:
4973 asym
->section
= bfd_com_section_ptr
;
4974 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
4975 asym
->flags
&= ~BSF_GLOBAL
;
4981 ignore_errors (const char *fmt ATTRIBUTE_UNUSED
, ...)
4985 #define TARGET_LITTLE_SYM ia64_elfNN_le_vec
4986 #define TARGET_LITTLE_NAME "elfNN-ia64-little"
4987 #define TARGET_BIG_SYM ia64_elfNN_be_vec
4988 #define TARGET_BIG_NAME "elfNN-ia64-big"
4989 #define ELF_ARCH bfd_arch_ia64
4990 #define ELF_TARGET_ID IA64_ELF_DATA
4991 #define ELF_MACHINE_CODE EM_IA_64
4992 #define ELF_MACHINE_ALT1 1999 /* EAS2.3 */
4993 #define ELF_MACHINE_ALT2 1998 /* EAS2.2 */
4994 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
4995 #define ELF_COMMONPAGESIZE 0x4000 /* 16KB */
4997 #define elf_backend_section_from_shdr \
4998 elfNN_ia64_section_from_shdr
4999 #define elf_backend_section_flags \
5000 elfNN_ia64_section_flags
5001 #define elf_backend_fake_sections \
5002 elfNN_ia64_fake_sections
5003 #define elf_backend_final_write_processing \
5004 elfNN_ia64_final_write_processing
5005 #define elf_backend_add_symbol_hook \
5006 elfNN_ia64_add_symbol_hook
5007 #define elf_backend_additional_program_headers \
5008 elfNN_ia64_additional_program_headers
5009 #define elf_backend_modify_segment_map \
5010 elfNN_ia64_modify_segment_map
5011 #define elf_backend_modify_headers \
5012 elfNN_ia64_modify_headers
5013 #define elf_info_to_howto \
5014 elfNN_ia64_info_to_howto
5016 #define bfd_elfNN_bfd_reloc_type_lookup \
5017 ia64_elf_reloc_type_lookup
5018 #define bfd_elfNN_bfd_reloc_name_lookup \
5019 ia64_elf_reloc_name_lookup
5020 #define bfd_elfNN_bfd_is_local_label_name \
5021 elfNN_ia64_is_local_label_name
5022 #define bfd_elfNN_bfd_relax_section \
5023 elfNN_ia64_relax_section
5025 #define elf_backend_object_p \
5028 /* Stuff for the BFD linker: */
5029 #define bfd_elfNN_bfd_link_hash_table_create \
5030 elfNN_ia64_hash_table_create
5031 #define elf_backend_create_dynamic_sections \
5032 elfNN_ia64_create_dynamic_sections
5033 #define elf_backend_check_relocs \
5034 elfNN_ia64_check_relocs
5035 #define elf_backend_adjust_dynamic_symbol \
5036 elfNN_ia64_adjust_dynamic_symbol
5037 #define elf_backend_size_dynamic_sections \
5038 elfNN_ia64_size_dynamic_sections
5039 #define elf_backend_omit_section_dynsym \
5040 _bfd_elf_omit_section_dynsym_all
5041 #define elf_backend_relocate_section \
5042 elfNN_ia64_relocate_section
5043 #define elf_backend_finish_dynamic_symbol \
5044 elfNN_ia64_finish_dynamic_symbol
5045 #define elf_backend_finish_dynamic_sections \
5046 elfNN_ia64_finish_dynamic_sections
5047 #define bfd_elfNN_bfd_final_link \
5048 elfNN_ia64_final_link
5050 #define bfd_elfNN_bfd_merge_private_bfd_data \
5051 elfNN_ia64_merge_private_bfd_data
5052 #define bfd_elfNN_bfd_set_private_flags \
5053 elfNN_ia64_set_private_flags
5054 #define bfd_elfNN_bfd_print_private_bfd_data \
5055 elfNN_ia64_print_private_bfd_data
5057 #define elf_backend_plt_readonly 1
5058 #define elf_backend_can_gc_sections 1
5059 #define elf_backend_want_plt_sym 0
5060 #define elf_backend_plt_alignment 5
5061 #define elf_backend_got_header_size 0
5062 #define elf_backend_want_got_plt 1
5063 #define elf_backend_may_use_rel_p 1
5064 #define elf_backend_may_use_rela_p 1
5065 #define elf_backend_default_use_rela_p 1
5066 #define elf_backend_want_dynbss 0
5067 #define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect
5068 #define elf_backend_hide_symbol elfNN_ia64_hash_hide_symbol
5069 #define elf_backend_fixup_symbol _bfd_elf_link_hash_fixup_symbol
5070 #define elf_backend_reloc_type_class elfNN_ia64_reloc_type_class
5071 #define elf_backend_rela_normal 1
5072 #define elf_backend_dtrel_excludes_plt 1
5073 #define elf_backend_special_sections elfNN_ia64_special_sections
5074 #define elf_backend_default_execstack 0
5076 /* FIXME: PR 290: The Intel C compiler generates SHT_IA_64_UNWIND with
5077 SHF_LINK_ORDER. But it doesn't set the sh_link or sh_info fields.
5078 We don't want to flood users with so many error messages. We turn
5079 off the warning for now. It will be turned on later when the Intel
5080 compiler is fixed. */
5081 #define elf_backend_link_order_error_handler ignore_errors
5083 #include "elfNN-target.h"
5085 /* HPUX-specific vectors. */
5087 #undef TARGET_LITTLE_SYM
5088 #undef TARGET_LITTLE_NAME
5089 #undef TARGET_BIG_SYM
5090 #define TARGET_BIG_SYM ia64_elfNN_hpux_be_vec
5091 #undef TARGET_BIG_NAME
5092 #define TARGET_BIG_NAME "elfNN-ia64-hpux-big"
5094 /* These are HP-UX specific functions. */
5096 #undef elf_backend_init_file_header
5097 #define elf_backend_init_file_header elfNN_hpux_init_file_header
5099 #undef elf_backend_section_from_bfd_section
5100 #define elf_backend_section_from_bfd_section elfNN_hpux_backend_section_from_bfd_section
5102 #undef elf_backend_symbol_processing
5103 #define elf_backend_symbol_processing elfNN_hpux_backend_symbol_processing
5105 #undef elf_backend_want_p_paddr_set_to_zero
5106 #define elf_backend_want_p_paddr_set_to_zero 1
5108 #undef ELF_COMMONPAGESIZE
5110 #define ELF_OSABI ELFOSABI_HPUX
5113 #define elfNN_bed elfNN_ia64_hpux_bed
5115 #include "elfNN-target.h"