1 /* IA-64 support for 64-bit ELF
2 Copyright (C) 1998-2020 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 ((CONST_STRNEQ (name
, ELF_STRING_ia64_unwind
)
897 && ! CONST_STRNEQ (name
, ELF_STRING_ia64_unwind_info
))
898 || CONST_STRNEQ (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
);
1877 /* Do a quick check for the last inserted entry. */
1878 dyn_i
= info
+ count
- 1;
1879 if (dyn_i
->addend
== addend
)
1887 /* It is the very first element. We create the array of size
1890 amt
= size
* sizeof (*info
);
1891 info
= bfd_malloc (amt
);
1893 else if (size
<= count
)
1895 /* We double the array size every time when we reach the
1898 amt
= size
* sizeof (*info
);
1899 info
= bfd_realloc (info
, amt
);
1910 /* Append the new one to the array. */
1911 dyn_i
= info
+ count
;
1912 memset (dyn_i
, 0, sizeof (*dyn_i
));
1913 dyn_i
->got_offset
= (bfd_vma
) -1;
1914 dyn_i
->addend
= addend
;
1916 /* We increment count only since the new ones are unsorted and
1917 may have duplicate. */
1922 /* It is a lookup without insertion. Sort array if part of the
1923 array isn't sorted. */
1924 if (count
!= sorted_count
)
1926 count
= sort_dyn_sym_info (info
, count
);
1928 *sorted_count_p
= count
;
1931 /* Free unused memory. */
1934 amt
= count
* sizeof (*info
);
1935 info
= bfd_malloc (amt
);
1938 memcpy (info
, *info_p
, amt
);
1945 key
.addend
= addend
;
1946 dyn_i
= bsearch (&key
, info
, count
,
1947 sizeof (*info
), addend_compare
);
1954 get_got (bfd
*abfd
, struct bfd_link_info
*info
,
1955 struct elfNN_ia64_link_hash_table
*ia64_info
)
1960 got
= ia64_info
->root
.sgot
;
1965 dynobj
= ia64_info
->root
.dynobj
;
1967 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1968 if (!_bfd_elf_create_got_section (dynobj
, info
))
1971 got
= ia64_info
->root
.sgot
;
1973 /* The .got section is always aligned at 8 bytes. */
1974 if (!bfd_set_section_alignment (got
, 3))
1977 flags
= bfd_section_flags (got
);
1978 if (!bfd_set_section_flags (got
, SEC_SMALL_DATA
| flags
))
1985 /* Create function descriptor section (.opd). This section is called .opd
1986 because it contains "official procedure descriptors". The "official"
1987 refers to the fact that these descriptors are used when taking the address
1988 of a procedure, thus ensuring a unique address for each procedure. */
1991 get_fptr (bfd
*abfd
, struct bfd_link_info
*info
,
1992 struct elfNN_ia64_link_hash_table
*ia64_info
)
1997 fptr
= ia64_info
->fptr_sec
;
2000 dynobj
= ia64_info
->root
.dynobj
;
2002 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2004 fptr
= bfd_make_section_anyway_with_flags (dynobj
, ".opd",
2009 | (bfd_link_pie (info
)
2011 | SEC_LINKER_CREATED
));
2013 || !bfd_set_section_alignment (fptr
, 4))
2019 ia64_info
->fptr_sec
= fptr
;
2021 if (bfd_link_pie (info
))
2024 fptr_rel
= bfd_make_section_anyway_with_flags (dynobj
, ".rela.opd",
2025 (SEC_ALLOC
| SEC_LOAD
2028 | SEC_LINKER_CREATED
2030 if (fptr_rel
== NULL
2031 || !bfd_set_section_alignment (fptr_rel
, LOG_SECTION_ALIGN
))
2037 ia64_info
->rel_fptr_sec
= fptr_rel
;
2045 get_pltoff (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2046 struct elfNN_ia64_link_hash_table
*ia64_info
)
2051 pltoff
= ia64_info
->pltoff_sec
;
2054 dynobj
= ia64_info
->root
.dynobj
;
2056 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2058 pltoff
= bfd_make_section_anyway_with_flags (dynobj
,
2059 ELF_STRING_ia64_pltoff
,
2065 | SEC_LINKER_CREATED
));
2067 || !bfd_set_section_alignment (pltoff
, 4))
2073 ia64_info
->pltoff_sec
= pltoff
;
2080 get_reloc_section (bfd
*abfd
,
2081 struct elfNN_ia64_link_hash_table
*ia64_info
,
2082 asection
*sec
, bfd_boolean create
)
2084 const char *srel_name
;
2088 srel_name
= (bfd_elf_string_from_elf_section
2089 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
2090 _bfd_elf_single_rel_hdr (sec
)->sh_name
));
2091 if (srel_name
== NULL
)
2094 dynobj
= ia64_info
->root
.dynobj
;
2096 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2098 srel
= bfd_get_linker_section (dynobj
, srel_name
);
2099 if (srel
== NULL
&& create
)
2101 srel
= bfd_make_section_anyway_with_flags (dynobj
, srel_name
,
2102 (SEC_ALLOC
| SEC_LOAD
2105 | SEC_LINKER_CREATED
2108 || !bfd_set_section_alignment (srel
, LOG_SECTION_ALIGN
))
2116 count_dyn_reloc (bfd
*abfd
, struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2117 asection
*srel
, int type
, bfd_boolean reltext
)
2119 struct elfNN_ia64_dyn_reloc_entry
*rent
;
2121 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2122 if (rent
->srel
== srel
&& rent
->type
== type
)
2127 rent
= ((struct elfNN_ia64_dyn_reloc_entry
*)
2128 bfd_alloc (abfd
, (bfd_size_type
) sizeof (*rent
)));
2132 rent
->next
= dyn_i
->reloc_entries
;
2136 dyn_i
->reloc_entries
= rent
;
2138 rent
->reltext
= reltext
;
2145 elfNN_ia64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
2147 const Elf_Internal_Rela
*relocs
)
2149 struct elfNN_ia64_link_hash_table
*ia64_info
;
2150 const Elf_Internal_Rela
*relend
;
2151 Elf_Internal_Shdr
*symtab_hdr
;
2152 const Elf_Internal_Rela
*rel
;
2153 asection
*got
, *fptr
, *srel
, *pltoff
;
2162 NEED_LTOFF_FPTR
= 128,
2168 struct elf_link_hash_entry
*h
;
2169 unsigned long r_symndx
;
2170 bfd_boolean maybe_dynamic
;
2172 if (bfd_link_relocatable (info
))
2175 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2176 ia64_info
= elfNN_ia64_hash_table (info
);
2177 if (ia64_info
== NULL
)
2180 got
= fptr
= srel
= pltoff
= NULL
;
2182 relend
= relocs
+ sec
->reloc_count
;
2184 /* We scan relocations first to create dynamic relocation arrays. We
2185 modified get_dyn_sym_info to allow fast insertion and support fast
2186 lookup in the next loop. */
2187 for (rel
= relocs
; rel
< relend
; ++rel
)
2189 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
2190 if (r_symndx
>= symtab_hdr
->sh_info
)
2192 long indx
= r_symndx
- symtab_hdr
->sh_info
;
2193 h
= elf_sym_hashes (abfd
)[indx
];
2194 while (h
->root
.type
== bfd_link_hash_indirect
2195 || h
->root
.type
== bfd_link_hash_warning
)
2196 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2201 if (h
&& UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
2204 /* We can only get preliminary data on whether a symbol is
2205 locally or externally defined, as not all of the input files
2206 have yet been processed. Do something with what we know, as
2207 this may help reduce memory usage and processing time later. */
2208 maybe_dynamic
= (h
&& ((!bfd_link_executable (info
)
2209 && (!SYMBOLIC_BIND (info
, h
)
2210 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
2212 || h
->root
.type
== bfd_link_hash_defweak
));
2215 switch (ELFNN_R_TYPE (rel
->r_info
))
2217 case R_IA64_TPREL64MSB
:
2218 case R_IA64_TPREL64LSB
:
2219 if (bfd_link_pic (info
) || maybe_dynamic
)
2220 need_entry
= NEED_DYNREL
;
2223 case R_IA64_LTOFF_TPREL22
:
2224 need_entry
= NEED_TPREL
;
2225 if (bfd_link_pic (info
))
2226 info
->flags
|= DF_STATIC_TLS
;
2229 case R_IA64_DTPREL32MSB
:
2230 case R_IA64_DTPREL32LSB
:
2231 case R_IA64_DTPREL64MSB
:
2232 case R_IA64_DTPREL64LSB
:
2233 if (bfd_link_pic (info
) || maybe_dynamic
)
2234 need_entry
= NEED_DYNREL
;
2237 case R_IA64_LTOFF_DTPREL22
:
2238 need_entry
= NEED_DTPREL
;
2241 case R_IA64_DTPMOD64MSB
:
2242 case R_IA64_DTPMOD64LSB
:
2243 if (bfd_link_pic (info
) || maybe_dynamic
)
2244 need_entry
= NEED_DYNREL
;
2247 case R_IA64_LTOFF_DTPMOD22
:
2248 need_entry
= NEED_DTPMOD
;
2251 case R_IA64_LTOFF_FPTR22
:
2252 case R_IA64_LTOFF_FPTR64I
:
2253 case R_IA64_LTOFF_FPTR32MSB
:
2254 case R_IA64_LTOFF_FPTR32LSB
:
2255 case R_IA64_LTOFF_FPTR64MSB
:
2256 case R_IA64_LTOFF_FPTR64LSB
:
2257 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
2260 case R_IA64_FPTR64I
:
2261 case R_IA64_FPTR32MSB
:
2262 case R_IA64_FPTR32LSB
:
2263 case R_IA64_FPTR64MSB
:
2264 case R_IA64_FPTR64LSB
:
2265 if (bfd_link_pic (info
) || h
)
2266 need_entry
= NEED_FPTR
| NEED_DYNREL
;
2268 need_entry
= NEED_FPTR
;
2271 case R_IA64_LTOFF22
:
2272 case R_IA64_LTOFF64I
:
2273 need_entry
= NEED_GOT
;
2276 case R_IA64_LTOFF22X
:
2277 need_entry
= NEED_GOTX
;
2280 case R_IA64_PLTOFF22
:
2281 case R_IA64_PLTOFF64I
:
2282 case R_IA64_PLTOFF64MSB
:
2283 case R_IA64_PLTOFF64LSB
:
2284 need_entry
= NEED_PLTOFF
;
2288 need_entry
|= NEED_MIN_PLT
;
2292 (*info
->callbacks
->warning
)
2293 (info
, _("@pltoff reloc against local symbol"), 0,
2294 abfd
, 0, (bfd_vma
) 0);
2298 case R_IA64_PCREL21B
:
2299 case R_IA64_PCREL60B
:
2300 /* Depending on where this symbol is defined, we may or may not
2301 need a full plt entry. Only skip if we know we'll not need
2302 the entry -- static or symbolic, and the symbol definition
2303 has already been seen. */
2304 if (maybe_dynamic
&& rel
->r_addend
== 0)
2305 need_entry
= NEED_FULL_PLT
;
2311 case R_IA64_DIR32MSB
:
2312 case R_IA64_DIR32LSB
:
2313 case R_IA64_DIR64MSB
:
2314 case R_IA64_DIR64LSB
:
2315 /* Shared objects will always need at least a REL relocation. */
2316 if (bfd_link_pic (info
) || maybe_dynamic
)
2317 need_entry
= NEED_DYNREL
;
2320 case R_IA64_IPLTMSB
:
2321 case R_IA64_IPLTLSB
:
2322 /* Shared objects will always need at least a REL relocation. */
2323 if (bfd_link_pic (info
) || maybe_dynamic
)
2324 need_entry
= NEED_DYNREL
;
2327 case R_IA64_PCREL22
:
2328 case R_IA64_PCREL64I
:
2329 case R_IA64_PCREL32MSB
:
2330 case R_IA64_PCREL32LSB
:
2331 case R_IA64_PCREL64MSB
:
2332 case R_IA64_PCREL64LSB
:
2334 need_entry
= NEED_DYNREL
;
2341 if ((need_entry
& NEED_FPTR
) != 0
2344 (*info
->callbacks
->warning
)
2345 (info
, _("non-zero addend in @fptr reloc"), 0,
2346 abfd
, 0, (bfd_vma
) 0);
2349 if (get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, TRUE
) == NULL
)
2353 /* Now, we only do lookup without insertion, which is very fast
2354 with the modified get_dyn_sym_info. */
2355 for (rel
= relocs
; rel
< relend
; ++rel
)
2357 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2358 int dynrel_type
= R_IA64_NONE
;
2360 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
2361 if (r_symndx
>= symtab_hdr
->sh_info
)
2363 /* We're dealing with a global symbol -- find its hash entry
2364 and mark it as being referenced. */
2365 long indx
= r_symndx
- symtab_hdr
->sh_info
;
2366 h
= elf_sym_hashes (abfd
)[indx
];
2367 while (h
->root
.type
== bfd_link_hash_indirect
2368 || h
->root
.type
== bfd_link_hash_warning
)
2369 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2371 /* PR15323, ref flags aren't set for references in the same
2378 if (h
&& UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
2381 /* We can only get preliminary data on whether a symbol is
2382 locally or externally defined, as not all of the input files
2383 have yet been processed. Do something with what we know, as
2384 this may help reduce memory usage and processing time later. */
2385 maybe_dynamic
= (h
&& ((!bfd_link_executable (info
)
2386 && (!SYMBOLIC_BIND (info
, h
)
2387 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
2389 || h
->root
.type
== bfd_link_hash_defweak
));
2392 switch (ELFNN_R_TYPE (rel
->r_info
))
2394 case R_IA64_TPREL64MSB
:
2395 case R_IA64_TPREL64LSB
:
2396 if (bfd_link_pic (info
) || maybe_dynamic
)
2397 need_entry
= NEED_DYNREL
;
2398 dynrel_type
= R_IA64_TPREL64LSB
;
2399 if (bfd_link_pic (info
))
2400 info
->flags
|= DF_STATIC_TLS
;
2403 case R_IA64_LTOFF_TPREL22
:
2404 need_entry
= NEED_TPREL
;
2405 if (bfd_link_pic (info
))
2406 info
->flags
|= DF_STATIC_TLS
;
2409 case R_IA64_DTPREL32MSB
:
2410 case R_IA64_DTPREL32LSB
:
2411 case R_IA64_DTPREL64MSB
:
2412 case R_IA64_DTPREL64LSB
:
2413 if (bfd_link_pic (info
) || maybe_dynamic
)
2414 need_entry
= NEED_DYNREL
;
2415 dynrel_type
= R_IA64_DTPRELNNLSB
;
2418 case R_IA64_LTOFF_DTPREL22
:
2419 need_entry
= NEED_DTPREL
;
2422 case R_IA64_DTPMOD64MSB
:
2423 case R_IA64_DTPMOD64LSB
:
2424 if (bfd_link_pic (info
) || maybe_dynamic
)
2425 need_entry
= NEED_DYNREL
;
2426 dynrel_type
= R_IA64_DTPMOD64LSB
;
2429 case R_IA64_LTOFF_DTPMOD22
:
2430 need_entry
= NEED_DTPMOD
;
2433 case R_IA64_LTOFF_FPTR22
:
2434 case R_IA64_LTOFF_FPTR64I
:
2435 case R_IA64_LTOFF_FPTR32MSB
:
2436 case R_IA64_LTOFF_FPTR32LSB
:
2437 case R_IA64_LTOFF_FPTR64MSB
:
2438 case R_IA64_LTOFF_FPTR64LSB
:
2439 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
2442 case R_IA64_FPTR64I
:
2443 case R_IA64_FPTR32MSB
:
2444 case R_IA64_FPTR32LSB
:
2445 case R_IA64_FPTR64MSB
:
2446 case R_IA64_FPTR64LSB
:
2447 if (bfd_link_pic (info
) || h
)
2448 need_entry
= NEED_FPTR
| NEED_DYNREL
;
2450 need_entry
= NEED_FPTR
;
2451 dynrel_type
= R_IA64_FPTRNNLSB
;
2454 case R_IA64_LTOFF22
:
2455 case R_IA64_LTOFF64I
:
2456 need_entry
= NEED_GOT
;
2459 case R_IA64_LTOFF22X
:
2460 need_entry
= NEED_GOTX
;
2463 case R_IA64_PLTOFF22
:
2464 case R_IA64_PLTOFF64I
:
2465 case R_IA64_PLTOFF64MSB
:
2466 case R_IA64_PLTOFF64LSB
:
2467 need_entry
= NEED_PLTOFF
;
2471 need_entry
|= NEED_MIN_PLT
;
2475 case R_IA64_PCREL21B
:
2476 case R_IA64_PCREL60B
:
2477 /* Depending on where this symbol is defined, we may or may not
2478 need a full plt entry. Only skip if we know we'll not need
2479 the entry -- static or symbolic, and the symbol definition
2480 has already been seen. */
2481 if (maybe_dynamic
&& rel
->r_addend
== 0)
2482 need_entry
= NEED_FULL_PLT
;
2488 case R_IA64_DIR32MSB
:
2489 case R_IA64_DIR32LSB
:
2490 case R_IA64_DIR64MSB
:
2491 case R_IA64_DIR64LSB
:
2492 /* Shared objects will always need at least a REL relocation. */
2493 if (bfd_link_pic (info
) || maybe_dynamic
)
2494 need_entry
= NEED_DYNREL
;
2495 dynrel_type
= R_IA64_DIRNNLSB
;
2498 case R_IA64_IPLTMSB
:
2499 case R_IA64_IPLTLSB
:
2500 /* Shared objects will always need at least a REL relocation. */
2501 if (bfd_link_pic (info
) || maybe_dynamic
)
2502 need_entry
= NEED_DYNREL
;
2503 dynrel_type
= R_IA64_IPLTLSB
;
2506 case R_IA64_PCREL22
:
2507 case R_IA64_PCREL64I
:
2508 case R_IA64_PCREL32MSB
:
2509 case R_IA64_PCREL32LSB
:
2510 case R_IA64_PCREL64MSB
:
2511 case R_IA64_PCREL64LSB
:
2513 need_entry
= NEED_DYNREL
;
2514 dynrel_type
= R_IA64_PCRELNNLSB
;
2521 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, FALSE
);
2523 /* Record whether or not this is a local symbol. */
2526 /* Create what's needed. */
2527 if (need_entry
& (NEED_GOT
| NEED_GOTX
| NEED_TPREL
2528 | NEED_DTPMOD
| NEED_DTPREL
))
2532 got
= get_got (abfd
, info
, ia64_info
);
2536 if (need_entry
& NEED_GOT
)
2537 dyn_i
->want_got
= 1;
2538 if (need_entry
& NEED_GOTX
)
2539 dyn_i
->want_gotx
= 1;
2540 if (need_entry
& NEED_TPREL
)
2541 dyn_i
->want_tprel
= 1;
2542 if (need_entry
& NEED_DTPMOD
)
2543 dyn_i
->want_dtpmod
= 1;
2544 if (need_entry
& NEED_DTPREL
)
2545 dyn_i
->want_dtprel
= 1;
2547 if (need_entry
& NEED_FPTR
)
2551 fptr
= get_fptr (abfd
, info
, ia64_info
);
2556 /* FPTRs for shared libraries are allocated by the dynamic
2557 linker. Make sure this local symbol will appear in the
2558 dynamic symbol table. */
2559 if (!h
&& bfd_link_pic (info
))
2561 if (! (bfd_elf_link_record_local_dynamic_symbol
2562 (info
, abfd
, (long) r_symndx
)))
2566 dyn_i
->want_fptr
= 1;
2568 if (need_entry
& NEED_LTOFF_FPTR
)
2569 dyn_i
->want_ltoff_fptr
= 1;
2570 if (need_entry
& (NEED_MIN_PLT
| NEED_FULL_PLT
))
2572 if (!ia64_info
->root
.dynobj
)
2573 ia64_info
->root
.dynobj
= abfd
;
2575 dyn_i
->want_plt
= 1;
2577 if (need_entry
& NEED_FULL_PLT
)
2578 dyn_i
->want_plt2
= 1;
2579 if (need_entry
& NEED_PLTOFF
)
2581 /* This is needed here, in case @pltoff is used in a non-shared
2585 pltoff
= get_pltoff (abfd
, info
, ia64_info
);
2590 dyn_i
->want_pltoff
= 1;
2592 if ((need_entry
& NEED_DYNREL
) && (sec
->flags
& SEC_ALLOC
))
2596 srel
= get_reloc_section (abfd
, ia64_info
, sec
, TRUE
);
2600 if (!count_dyn_reloc (abfd
, dyn_i
, srel
, dynrel_type
,
2601 (sec
->flags
& SEC_READONLY
) != 0))
2609 /* For cleanliness, and potentially faster dynamic loading, allocate
2610 external GOT entries first. */
2613 allocate_global_data_got (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2616 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2618 if ((dyn_i
->want_got
|| dyn_i
->want_gotx
)
2619 && ! dyn_i
->want_fptr
2620 && elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0))
2622 dyn_i
->got_offset
= x
->ofs
;
2625 if (dyn_i
->want_tprel
)
2627 dyn_i
->tprel_offset
= x
->ofs
;
2630 if (dyn_i
->want_dtpmod
)
2632 if (elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0))
2634 dyn_i
->dtpmod_offset
= x
->ofs
;
2639 struct elfNN_ia64_link_hash_table
*ia64_info
;
2641 ia64_info
= elfNN_ia64_hash_table (x
->info
);
2642 if (ia64_info
== NULL
)
2645 if (ia64_info
->self_dtpmod_offset
== (bfd_vma
) -1)
2647 ia64_info
->self_dtpmod_offset
= x
->ofs
;
2650 dyn_i
->dtpmod_offset
= ia64_info
->self_dtpmod_offset
;
2653 if (dyn_i
->want_dtprel
)
2655 dyn_i
->dtprel_offset
= x
->ofs
;
2661 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
2664 allocate_global_fptr_got (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2667 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2671 && elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, R_IA64_FPTRNNLSB
))
2673 dyn_i
->got_offset
= x
->ofs
;
2679 /* Lastly, allocate all the GOT entries for local data. */
2682 allocate_local_got (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2685 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2687 if ((dyn_i
->want_got
|| dyn_i
->want_gotx
)
2688 && !elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0))
2690 dyn_i
->got_offset
= x
->ofs
;
2696 /* Search for the index of a global symbol in it's defining object file. */
2699 global_sym_index (struct elf_link_hash_entry
*h
)
2701 struct elf_link_hash_entry
**p
;
2704 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
2705 || h
->root
.type
== bfd_link_hash_defweak
);
2707 obj
= h
->root
.u
.def
.section
->owner
;
2708 for (p
= elf_sym_hashes (obj
); *p
!= h
; ++p
)
2711 return p
- elf_sym_hashes (obj
) + elf_tdata (obj
)->symtab_hdr
.sh_info
;
2714 /* Allocate function descriptors. We can do these for every function
2715 in a main executable that is not exported. */
2718 allocate_fptr (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
)
2720 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2722 if (dyn_i
->want_fptr
)
2724 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2727 while (h
->root
.type
== bfd_link_hash_indirect
2728 || h
->root
.type
== bfd_link_hash_warning
)
2729 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2731 if (!bfd_link_executable (x
->info
)
2733 || (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2734 && !UNDEFWEAK_NO_DYNAMIC_RELOC (x
->info
, h
))
2735 || (h
->root
.type
!= bfd_link_hash_undefweak
2736 && h
->root
.type
!= bfd_link_hash_undefined
)))
2738 if (h
&& h
->dynindx
== -1)
2740 BFD_ASSERT ((h
->root
.type
== bfd_link_hash_defined
)
2741 || (h
->root
.type
== bfd_link_hash_defweak
));
2743 if (!bfd_elf_link_record_local_dynamic_symbol
2744 (x
->info
, h
->root
.u
.def
.section
->owner
,
2745 global_sym_index (h
)))
2749 dyn_i
->want_fptr
= 0;
2751 else if (h
== NULL
|| h
->dynindx
== -1)
2753 dyn_i
->fptr_offset
= x
->ofs
;
2757 dyn_i
->want_fptr
= 0;
2762 /* Allocate all the minimal PLT entries. */
2765 allocate_plt_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2768 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2770 if (dyn_i
->want_plt
)
2772 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2775 while (h
->root
.type
== bfd_link_hash_indirect
2776 || h
->root
.type
== bfd_link_hash_warning
)
2777 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2779 /* ??? Versioned symbols seem to lose NEEDS_PLT. */
2780 if (elfNN_ia64_dynamic_symbol_p (h
, x
->info
, 0))
2782 bfd_size_type offset
= x
->ofs
;
2784 offset
= PLT_HEADER_SIZE
;
2785 dyn_i
->plt_offset
= offset
;
2786 x
->ofs
= offset
+ PLT_MIN_ENTRY_SIZE
;
2788 dyn_i
->want_pltoff
= 1;
2792 dyn_i
->want_plt
= 0;
2793 dyn_i
->want_plt2
= 0;
2799 /* Allocate all the full PLT entries. */
2802 allocate_plt2_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2805 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2807 if (dyn_i
->want_plt2
)
2809 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2810 bfd_size_type ofs
= x
->ofs
;
2812 dyn_i
->plt2_offset
= ofs
;
2813 x
->ofs
= ofs
+ PLT_FULL_ENTRY_SIZE
;
2815 while (h
->root
.type
== bfd_link_hash_indirect
2816 || h
->root
.type
== bfd_link_hash_warning
)
2817 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2818 dyn_i
->h
->plt
.offset
= ofs
;
2823 /* Allocate all the PLTOFF entries requested by relocations and
2824 plt entries. We can't share space with allocated FPTR entries,
2825 because the latter are not necessarily addressable by the GP.
2826 ??? Relaxation might be able to determine that they are. */
2829 allocate_pltoff_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2832 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2834 if (dyn_i
->want_pltoff
)
2836 dyn_i
->pltoff_offset
= x
->ofs
;
2842 /* Allocate dynamic relocations for those symbols that turned out
2846 allocate_dynrel_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2849 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2850 struct elfNN_ia64_link_hash_table
*ia64_info
;
2851 struct elfNN_ia64_dyn_reloc_entry
*rent
;
2852 bfd_boolean dynamic_symbol
, shared
, resolved_zero
;
2854 ia64_info
= elfNN_ia64_hash_table (x
->info
);
2855 if (ia64_info
== NULL
)
2858 /* Note that this can't be used in relation to FPTR relocs below. */
2859 dynamic_symbol
= elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0);
2861 shared
= bfd_link_pic (x
->info
);
2862 resolved_zero
= (dyn_i
->h
2863 && UNDEFWEAK_NO_DYNAMIC_RELOC (x
->info
,
2866 /* Take care of the GOT and PLT relocations. */
2869 && (dynamic_symbol
|| shared
)
2870 && (dyn_i
->want_got
|| dyn_i
->want_gotx
))
2871 || (dyn_i
->want_ltoff_fptr
2873 && dyn_i
->h
->dynindx
!= -1))
2875 if (!dyn_i
->want_ltoff_fptr
2876 || !bfd_link_pie (x
->info
)
2878 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
2879 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
2881 if ((dynamic_symbol
|| shared
) && dyn_i
->want_tprel
)
2882 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
2883 if (dynamic_symbol
&& dyn_i
->want_dtpmod
)
2884 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
2885 if (dynamic_symbol
&& dyn_i
->want_dtprel
)
2886 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
2891 if (ia64_info
->rel_fptr_sec
&& dyn_i
->want_fptr
)
2893 if (dyn_i
->h
== NULL
|| dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
2894 ia64_info
->rel_fptr_sec
->size
+= sizeof (ElfNN_External_Rela
);
2897 if (!resolved_zero
&& dyn_i
->want_pltoff
)
2899 bfd_size_type t
= 0;
2901 /* Dynamic symbols get one IPLT relocation. Local symbols in
2902 shared libraries get two REL relocations. Local symbols in
2903 main applications get nothing. */
2905 t
= sizeof (ElfNN_External_Rela
);
2907 t
= 2 * sizeof (ElfNN_External_Rela
);
2909 ia64_info
->rel_pltoff_sec
->size
+= t
;
2912 /* Take care of the normal data relocations. */
2914 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2916 int count
= rent
->count
;
2920 case R_IA64_FPTR32LSB
:
2921 case R_IA64_FPTR64LSB
:
2922 /* Allocate one iff !want_fptr and not PIE, which by this point
2923 will be true only if we're actually allocating one statically
2924 in the main executable. Position independent executables
2925 need a relative reloc. */
2926 if (dyn_i
->want_fptr
&& !bfd_link_pie (x
->info
))
2929 case R_IA64_PCREL32LSB
:
2930 case R_IA64_PCREL64LSB
:
2931 if (!dynamic_symbol
)
2934 case R_IA64_DIR32LSB
:
2935 case R_IA64_DIR64LSB
:
2936 if (!dynamic_symbol
&& !shared
)
2939 case R_IA64_IPLTLSB
:
2940 if (!dynamic_symbol
&& !shared
)
2942 /* Use two REL relocations for IPLT relocations
2943 against local symbols. */
2944 if (!dynamic_symbol
)
2947 case R_IA64_DTPREL32LSB
:
2948 case R_IA64_TPREL64LSB
:
2949 case R_IA64_DTPREL64LSB
:
2950 case R_IA64_DTPMOD64LSB
:
2956 x
->info
->flags
|= DF_TEXTREL
;
2957 rent
->srel
->size
+= sizeof (ElfNN_External_Rela
) * count
;
2964 elfNN_ia64_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2965 struct elf_link_hash_entry
*h
)
2967 /* ??? Undefined symbols with PLT entries should be re-defined
2968 to be the PLT entry. */
2970 /* If this is a weak symbol, and there is a real definition, the
2971 processor independent code will have arranged for us to see the
2972 real definition first, and we can just use the same value. */
2973 if (h
->is_weakalias
)
2975 struct elf_link_hash_entry
*def
= weakdef (h
);
2976 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
2977 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
2978 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
2982 /* If this is a reference to a symbol defined by a dynamic object which
2983 is not a function, we might allocate the symbol in our .dynbss section
2984 and allocate a COPY dynamic relocation.
2986 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2993 elfNN_ia64_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2994 struct bfd_link_info
*info
)
2996 struct elfNN_ia64_allocate_data data
;
2997 struct elfNN_ia64_link_hash_table
*ia64_info
;
3001 ia64_info
= elfNN_ia64_hash_table (info
);
3002 if (ia64_info
== NULL
)
3004 dynobj
= ia64_info
->root
.dynobj
;
3005 ia64_info
->self_dtpmod_offset
= (bfd_vma
) -1;
3006 BFD_ASSERT(dynobj
!= NULL
);
3009 /* Set the contents of the .interp section to the interpreter. */
3010 if (ia64_info
->root
.dynamic_sections_created
3011 && bfd_link_executable (info
) && !info
->nointerp
)
3013 sec
= bfd_get_linker_section (dynobj
, ".interp");
3014 BFD_ASSERT (sec
!= NULL
);
3015 sec
->contents
= (bfd_byte
*) ELF_DYNAMIC_INTERPRETER
;
3016 sec
->size
= strlen (ELF_DYNAMIC_INTERPRETER
) + 1;
3019 /* Allocate the GOT entries. */
3021 if (ia64_info
->root
.sgot
)
3024 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_data_got
, &data
);
3025 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_fptr_got
, &data
);
3026 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_local_got
, &data
);
3027 ia64_info
->root
.sgot
->size
= data
.ofs
;
3030 /* Allocate the FPTR entries. */
3032 if (ia64_info
->fptr_sec
)
3035 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_fptr
, &data
);
3036 ia64_info
->fptr_sec
->size
= data
.ofs
;
3039 /* Now that we've seen all of the input files, we can decide which
3040 symbols need plt entries. Allocate the minimal PLT entries first.
3041 We do this even though dynamic_sections_created may be FALSE, because
3042 this has the side-effect of clearing want_plt and want_plt2. */
3045 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_plt_entries
, &data
);
3047 ia64_info
->minplt_entries
= 0;
3050 ia64_info
->minplt_entries
3051 = (data
.ofs
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
3054 /* Align the pointer for the plt2 entries. */
3055 data
.ofs
= (data
.ofs
+ 31) & (bfd_vma
) -32;
3057 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_plt2_entries
, &data
);
3058 if (data
.ofs
!= 0 || ia64_info
->root
.dynamic_sections_created
)
3060 /* FIXME: we always reserve the memory for dynamic linker even if
3061 there are no PLT entries since dynamic linker may assume the
3062 reserved memory always exists. */
3064 BFD_ASSERT (ia64_info
->root
.dynamic_sections_created
);
3066 ia64_info
->root
.splt
->size
= data
.ofs
;
3068 /* If we've got a .plt, we need some extra memory for the dynamic
3069 linker. We stuff these in .got.plt. */
3070 ia64_info
->root
.sgotplt
->size
= 8 * PLT_RESERVED_WORDS
;
3073 /* Allocate the PLTOFF entries. */
3075 if (ia64_info
->pltoff_sec
)
3078 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_pltoff_entries
, &data
);
3079 ia64_info
->pltoff_sec
->size
= data
.ofs
;
3082 if (ia64_info
->root
.dynamic_sections_created
)
3084 /* Allocate space for the dynamic relocations that turned out to be
3087 if (bfd_link_pic (info
) && ia64_info
->self_dtpmod_offset
!= (bfd_vma
) -1)
3088 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
3089 data
.only_got
= FALSE
;
3090 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_dynrel_entries
, &data
);
3093 /* We have now determined the sizes of the various dynamic sections.
3094 Allocate memory for them. */
3095 for (sec
= dynobj
->sections
; sec
!= NULL
; sec
= sec
->next
)
3099 if (!(sec
->flags
& SEC_LINKER_CREATED
))
3102 /* If we don't need this section, strip it from the output file.
3103 There were several sections primarily related to dynamic
3104 linking that must be create before the linker maps input
3105 sections to output sections. The linker does that before
3106 bfd_elf_size_dynamic_sections is called, and it is that
3107 function which decides whether anything needs to go into
3110 strip
= (sec
->size
== 0);
3112 if (sec
== ia64_info
->root
.sgot
)
3114 else if (sec
== ia64_info
->root
.srelgot
)
3117 ia64_info
->root
.srelgot
= NULL
;
3119 /* We use the reloc_count field as a counter if we need to
3120 copy relocs into the output file. */
3121 sec
->reloc_count
= 0;
3123 else if (sec
== ia64_info
->fptr_sec
)
3126 ia64_info
->fptr_sec
= NULL
;
3128 else if (sec
== ia64_info
->rel_fptr_sec
)
3131 ia64_info
->rel_fptr_sec
= NULL
;
3133 /* We use the reloc_count field as a counter if we need to
3134 copy relocs into the output file. */
3135 sec
->reloc_count
= 0;
3137 else if (sec
== ia64_info
->root
.splt
)
3140 ia64_info
->root
.splt
= NULL
;
3142 else if (sec
== ia64_info
->pltoff_sec
)
3145 ia64_info
->pltoff_sec
= NULL
;
3147 else if (sec
== ia64_info
->rel_pltoff_sec
)
3150 ia64_info
->rel_pltoff_sec
= NULL
;
3153 ia64_info
->root
.dt_jmprel_required
= TRUE
;
3154 /* We use the reloc_count field as a counter if we need to
3155 copy relocs into the output file. */
3156 sec
->reloc_count
= 0;
3163 /* It's OK to base decisions on the section name, because none
3164 of the dynobj section names depend upon the input files. */
3165 name
= bfd_section_name (sec
);
3167 if (strcmp (name
, ".got.plt") == 0)
3169 else if (CONST_STRNEQ (name
, ".rel"))
3173 /* We use the reloc_count field as a counter if we need to
3174 copy relocs into the output file. */
3175 sec
->reloc_count
= 0;
3183 sec
->flags
|= SEC_EXCLUDE
;
3186 /* Allocate memory for the section contents. */
3187 sec
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, sec
->size
);
3188 if (sec
->contents
== NULL
&& sec
->size
!= 0)
3193 if (ia64_info
->root
.dynamic_sections_created
)
3195 /* Add some entries to the .dynamic section. We fill in the values
3196 later (in finish_dynamic_sections) but we must add the entries now
3197 so that we get the correct size for the .dynamic section. */
3199 #define add_dynamic_entry(TAG, VAL) \
3200 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3202 if (!_bfd_elf_add_dynamic_tags (output_bfd
, info
, TRUE
))
3205 if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE
, 0))
3209 /* ??? Perhaps force __gp local. */
3215 elfNN_ia64_install_dyn_reloc (bfd
*abfd
, struct bfd_link_info
*info
,
3216 asection
*sec
, asection
*srel
,
3217 bfd_vma offset
, unsigned int type
,
3218 long dynindx
, bfd_vma addend
)
3220 Elf_Internal_Rela outrel
;
3223 BFD_ASSERT (dynindx
!= -1);
3224 outrel
.r_info
= ELFNN_R_INFO (dynindx
, type
);
3225 outrel
.r_addend
= addend
;
3226 outrel
.r_offset
= _bfd_elf_section_offset (abfd
, info
, sec
, offset
);
3227 if (outrel
.r_offset
>= (bfd_vma
) -2)
3229 /* Run for the hills. We shouldn't be outputting a relocation
3230 for this. So do what everyone else does and output a no-op. */
3231 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
3232 outrel
.r_addend
= 0;
3233 outrel
.r_offset
= 0;
3236 outrel
.r_offset
+= sec
->output_section
->vma
+ sec
->output_offset
;
3238 loc
= srel
->contents
;
3239 loc
+= srel
->reloc_count
++ * sizeof (ElfNN_External_Rela
);
3240 bfd_elfNN_swap_reloca_out (abfd
, &outrel
, loc
);
3241 BFD_ASSERT (sizeof (ElfNN_External_Rela
) * srel
->reloc_count
<= srel
->size
);
3244 /* Store an entry for target address TARGET_ADDR in the linkage table
3245 and return the gp-relative address of the linkage table entry. */
3248 set_got_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3249 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3250 long dynindx
, bfd_vma addend
, bfd_vma value
,
3251 unsigned int dyn_r_type
)
3253 struct elfNN_ia64_link_hash_table
*ia64_info
;
3258 ia64_info
= elfNN_ia64_hash_table (info
);
3259 if (ia64_info
== NULL
)
3262 got_sec
= ia64_info
->root
.sgot
;
3266 case R_IA64_TPREL64LSB
:
3267 done
= dyn_i
->tprel_done
;
3268 dyn_i
->tprel_done
= TRUE
;
3269 got_offset
= dyn_i
->tprel_offset
;
3271 case R_IA64_DTPMOD64LSB
:
3272 if (dyn_i
->dtpmod_offset
!= ia64_info
->self_dtpmod_offset
)
3274 done
= dyn_i
->dtpmod_done
;
3275 dyn_i
->dtpmod_done
= TRUE
;
3279 done
= ia64_info
->self_dtpmod_done
;
3280 ia64_info
->self_dtpmod_done
= TRUE
;
3283 got_offset
= dyn_i
->dtpmod_offset
;
3285 case R_IA64_DTPREL32LSB
:
3286 case R_IA64_DTPREL64LSB
:
3287 done
= dyn_i
->dtprel_done
;
3288 dyn_i
->dtprel_done
= TRUE
;
3289 got_offset
= dyn_i
->dtprel_offset
;
3292 done
= dyn_i
->got_done
;
3293 dyn_i
->got_done
= TRUE
;
3294 got_offset
= dyn_i
->got_offset
;
3298 BFD_ASSERT ((got_offset
& 7) == 0);
3302 /* Store the target address in the linkage table entry. */
3303 bfd_put_64 (abfd
, value
, got_sec
->contents
+ got_offset
);
3305 /* Install a dynamic relocation if needed. */
3306 if (((bfd_link_pic (info
)
3308 || (ELF_ST_VISIBILITY (dyn_i
->h
->other
) == STV_DEFAULT
3309 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, dyn_i
->h
))
3310 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
3311 && dyn_r_type
!= R_IA64_DTPREL32LSB
3312 && dyn_r_type
!= R_IA64_DTPREL64LSB
)
3313 || elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, info
, dyn_r_type
)
3315 && (dyn_r_type
== R_IA64_FPTR32LSB
3316 || dyn_r_type
== R_IA64_FPTR64LSB
)))
3317 && (!dyn_i
->want_ltoff_fptr
3318 || !bfd_link_pie (info
)
3320 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
3323 && dyn_r_type
!= R_IA64_TPREL64LSB
3324 && dyn_r_type
!= R_IA64_DTPMOD64LSB
3325 && dyn_r_type
!= R_IA64_DTPREL32LSB
3326 && dyn_r_type
!= R_IA64_DTPREL64LSB
)
3328 dyn_r_type
= R_IA64_RELNNLSB
;
3333 if (bfd_big_endian (abfd
))
3337 case R_IA64_REL32LSB
:
3338 dyn_r_type
= R_IA64_REL32MSB
;
3340 case R_IA64_DIR32LSB
:
3341 dyn_r_type
= R_IA64_DIR32MSB
;
3343 case R_IA64_FPTR32LSB
:
3344 dyn_r_type
= R_IA64_FPTR32MSB
;
3346 case R_IA64_DTPREL32LSB
:
3347 dyn_r_type
= R_IA64_DTPREL32MSB
;
3349 case R_IA64_REL64LSB
:
3350 dyn_r_type
= R_IA64_REL64MSB
;
3352 case R_IA64_DIR64LSB
:
3353 dyn_r_type
= R_IA64_DIR64MSB
;
3355 case R_IA64_FPTR64LSB
:
3356 dyn_r_type
= R_IA64_FPTR64MSB
;
3358 case R_IA64_TPREL64LSB
:
3359 dyn_r_type
= R_IA64_TPREL64MSB
;
3361 case R_IA64_DTPMOD64LSB
:
3362 dyn_r_type
= R_IA64_DTPMOD64MSB
;
3364 case R_IA64_DTPREL64LSB
:
3365 dyn_r_type
= R_IA64_DTPREL64MSB
;
3373 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, got_sec
,
3374 ia64_info
->root
.srelgot
,
3375 got_offset
, dyn_r_type
,
3380 /* Return the address of the linkage table entry. */
3381 value
= (got_sec
->output_section
->vma
3382 + got_sec
->output_offset
3388 /* Fill in a function descriptor consisting of the function's code
3389 address and its global pointer. Return the descriptor's address. */
3392 set_fptr_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3393 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3396 struct elfNN_ia64_link_hash_table
*ia64_info
;
3399 ia64_info
= elfNN_ia64_hash_table (info
);
3400 if (ia64_info
== NULL
)
3403 fptr_sec
= ia64_info
->fptr_sec
;
3405 if (!dyn_i
->fptr_done
)
3407 dyn_i
->fptr_done
= 1;
3409 /* Fill in the function descriptor. */
3410 bfd_put_64 (abfd
, value
, fptr_sec
->contents
+ dyn_i
->fptr_offset
);
3411 bfd_put_64 (abfd
, _bfd_get_gp_value (abfd
),
3412 fptr_sec
->contents
+ dyn_i
->fptr_offset
+ 8);
3413 if (ia64_info
->rel_fptr_sec
)
3415 Elf_Internal_Rela outrel
;
3418 if (bfd_little_endian (abfd
))
3419 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_IPLTLSB
);
3421 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_IPLTMSB
);
3422 outrel
.r_addend
= value
;
3423 outrel
.r_offset
= (fptr_sec
->output_section
->vma
3424 + fptr_sec
->output_offset
3425 + dyn_i
->fptr_offset
);
3426 loc
= ia64_info
->rel_fptr_sec
->contents
;
3427 loc
+= ia64_info
->rel_fptr_sec
->reloc_count
++
3428 * sizeof (ElfNN_External_Rela
);
3429 bfd_elfNN_swap_reloca_out (abfd
, &outrel
, loc
);
3433 /* Return the descriptor's address. */
3434 value
= (fptr_sec
->output_section
->vma
3435 + fptr_sec
->output_offset
3436 + dyn_i
->fptr_offset
);
3441 /* Fill in a PLTOFF entry consisting of the function's code address
3442 and its global pointer. Return the descriptor's address. */
3445 set_pltoff_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3446 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3447 bfd_vma value
, bfd_boolean is_plt
)
3449 struct elfNN_ia64_link_hash_table
*ia64_info
;
3450 asection
*pltoff_sec
;
3452 ia64_info
= elfNN_ia64_hash_table (info
);
3453 if (ia64_info
== NULL
)
3456 pltoff_sec
= ia64_info
->pltoff_sec
;
3458 /* Don't do anything if this symbol uses a real PLT entry. In
3459 that case, we'll fill this in during finish_dynamic_symbol. */
3460 if ((! dyn_i
->want_plt
|| is_plt
)
3461 && !dyn_i
->pltoff_done
)
3463 bfd_vma gp
= _bfd_get_gp_value (abfd
);
3465 /* Fill in the function descriptor. */
3466 bfd_put_64 (abfd
, value
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
);
3467 bfd_put_64 (abfd
, gp
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
+ 8);
3469 /* Install dynamic relocations if needed. */
3471 && bfd_link_pic (info
)
3473 || (ELF_ST_VISIBILITY (dyn_i
->h
->other
) == STV_DEFAULT
3474 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, dyn_i
->h
))
3475 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
3477 unsigned int dyn_r_type
;
3479 if (bfd_big_endian (abfd
))
3480 dyn_r_type
= R_IA64_RELNNMSB
;
3482 dyn_r_type
= R_IA64_RELNNLSB
;
3484 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
3485 ia64_info
->rel_pltoff_sec
,
3486 dyn_i
->pltoff_offset
,
3487 dyn_r_type
, 0, value
);
3488 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
3489 ia64_info
->rel_pltoff_sec
,
3490 dyn_i
->pltoff_offset
+ ARCH_SIZE
/ 8,
3494 dyn_i
->pltoff_done
= 1;
3497 /* Return the descriptor's address. */
3498 value
= (pltoff_sec
->output_section
->vma
3499 + pltoff_sec
->output_offset
3500 + dyn_i
->pltoff_offset
);
3505 /* Return the base VMA address which should be subtracted from real addresses
3506 when resolving @tprel() relocation.
3507 Main program TLS (whose template starts at PT_TLS p_vaddr)
3508 is assigned offset round(2 * size of pointer, PT_TLS p_align). */
3511 elfNN_ia64_tprel_base (struct bfd_link_info
*info
)
3513 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3514 return tls_sec
->vma
- align_power ((bfd_vma
) ARCH_SIZE
/ 4,
3515 tls_sec
->alignment_power
);
3518 /* Return the base VMA address which should be subtracted from real addresses
3519 when resolving @dtprel() relocation.
3520 This is PT_TLS segment p_vaddr. */
3523 elfNN_ia64_dtprel_base (struct bfd_link_info
*info
)
3525 return elf_hash_table (info
)->tls_sec
->vma
;
3528 /* Called through qsort to sort the .IA_64.unwind section during a
3529 non-relocatable link. Set elfNN_ia64_unwind_entry_compare_bfd
3530 to the output bfd so we can do proper endianness frobbing. */
3532 static bfd
*elfNN_ia64_unwind_entry_compare_bfd
;
3535 elfNN_ia64_unwind_entry_compare (const void * a
, const void * b
)
3539 av
= bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd
, a
);
3540 bv
= bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd
, b
);
3542 return (av
< bv
? -1 : av
> bv
? 1 : 0);
3545 /* Make sure we've got ourselves a nice fat __gp value. */
3547 elfNN_ia64_choose_gp (bfd
*abfd
, struct bfd_link_info
*info
, bfd_boolean final
)
3549 bfd_vma min_vma
= (bfd_vma
) -1, max_vma
= 0;
3550 bfd_vma min_short_vma
= min_vma
, max_short_vma
= 0;
3551 struct elf_link_hash_entry
*gp
;
3554 struct elfNN_ia64_link_hash_table
*ia64_info
;
3556 ia64_info
= elfNN_ia64_hash_table (info
);
3557 if (ia64_info
== NULL
)
3560 /* Find the min and max vma of all sections marked short. Also collect
3561 min and max vma of any type, for use in selecting a nice gp. */
3562 for (os
= abfd
->sections
; os
; os
= os
->next
)
3566 if ((os
->flags
& SEC_ALLOC
) == 0)
3570 /* When this function is called from elfNN_ia64_final_link
3571 the correct value to use is os->size. When called from
3572 elfNN_ia64_relax_section we are in the middle of section
3573 sizing; some sections will already have os->size set, others
3574 will have os->size zero and os->rawsize the previous size. */
3575 hi
= os
->vma
+ (!final
&& os
->rawsize
? os
->rawsize
: os
->size
);
3583 if (os
->flags
& SEC_SMALL_DATA
)
3585 if (min_short_vma
> lo
)
3587 if (max_short_vma
< hi
)
3592 if (ia64_info
->min_short_sec
)
3595 > (ia64_info
->min_short_sec
->vma
3596 + ia64_info
->min_short_offset
))
3597 min_short_vma
= (ia64_info
->min_short_sec
->vma
3598 + ia64_info
->min_short_offset
);
3600 < (ia64_info
->max_short_sec
->vma
3601 + ia64_info
->max_short_offset
))
3602 max_short_vma
= (ia64_info
->max_short_sec
->vma
3603 + ia64_info
->max_short_offset
);
3606 /* See if the user wants to force a value. */
3607 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
3611 && (gp
->root
.type
== bfd_link_hash_defined
3612 || gp
->root
.type
== bfd_link_hash_defweak
))
3614 asection
*gp_sec
= gp
->root
.u
.def
.section
;
3615 gp_val
= (gp
->root
.u
.def
.value
3616 + gp_sec
->output_section
->vma
3617 + gp_sec
->output_offset
);
3621 /* Pick a sensible value. */
3623 if (ia64_info
->min_short_sec
)
3625 bfd_vma short_range
= max_short_vma
- min_short_vma
;
3627 /* If min_short_sec is set, pick one in the middle bewteen
3628 min_short_vma and max_short_vma. */
3629 if (short_range
>= 0x400000)
3631 gp_val
= min_short_vma
+ short_range
/ 2;
3635 asection
*got_sec
= ia64_info
->root
.sgot
;
3637 /* Start with just the address of the .got. */
3639 gp_val
= got_sec
->output_section
->vma
;
3640 else if (max_short_vma
!= 0)
3641 gp_val
= min_short_vma
;
3642 else if (max_vma
- min_vma
< 0x200000)
3645 gp_val
= max_vma
- 0x200000 + 8;
3648 /* If it is possible to address the entire image, but we
3649 don't with the choice above, adjust. */
3650 if (max_vma
- min_vma
< 0x400000
3651 && (max_vma
- gp_val
>= 0x200000
3652 || gp_val
- min_vma
> 0x200000))
3653 gp_val
= min_vma
+ 0x200000;
3654 else if (max_short_vma
!= 0)
3656 /* If we don't cover all the short data, adjust. */
3657 if (max_short_vma
- gp_val
>= 0x200000)
3658 gp_val
= min_short_vma
+ 0x200000;
3660 /* If we're addressing stuff past the end, adjust back. */
3661 if (gp_val
> max_vma
)
3662 gp_val
= max_vma
- 0x200000 + 8;
3666 /* Validate whether all SHF_IA_64_SHORT sections are within
3667 range of the chosen GP. */
3669 if (max_short_vma
!= 0)
3671 if (max_short_vma
- min_short_vma
>= 0x400000)
3675 /* xgettext:c-format */
3676 (_("%pB: short data segment overflowed (%#" PRIx64
" >= 0x400000)"),
3677 abfd
, (uint64_t) (max_short_vma
- min_short_vma
));
3680 else if ((gp_val
> min_short_vma
3681 && gp_val
- min_short_vma
> 0x200000)
3682 || (gp_val
< max_short_vma
3683 && max_short_vma
- gp_val
>= 0x200000))
3686 (_("%pB: __gp does not cover short data segment"), abfd
);
3691 _bfd_set_gp_value (abfd
, gp_val
);
3697 elfNN_ia64_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
3699 struct elfNN_ia64_link_hash_table
*ia64_info
;
3700 asection
*unwind_output_sec
;
3702 ia64_info
= elfNN_ia64_hash_table (info
);
3703 if (ia64_info
== NULL
)
3706 /* Make sure we've got ourselves a nice fat __gp value. */
3707 if (!bfd_link_relocatable (info
))
3710 struct elf_link_hash_entry
*gp
;
3712 /* We assume after gp is set, section size will only decrease. We
3713 need to adjust gp for it. */
3714 _bfd_set_gp_value (abfd
, 0);
3715 if (! elfNN_ia64_choose_gp (abfd
, info
, TRUE
))
3717 gp_val
= _bfd_get_gp_value (abfd
);
3719 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
3723 gp
->root
.type
= bfd_link_hash_defined
;
3724 gp
->root
.u
.def
.value
= gp_val
;
3725 gp
->root
.u
.def
.section
= bfd_abs_section_ptr
;
3729 /* If we're producing a final executable, we need to sort the contents
3730 of the .IA_64.unwind section. Force this section to be relocated
3731 into memory rather than written immediately to the output file. */
3732 unwind_output_sec
= NULL
;
3733 if (!bfd_link_relocatable (info
))
3735 asection
*s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_unwind
);
3738 unwind_output_sec
= s
->output_section
;
3739 unwind_output_sec
->contents
3740 = bfd_malloc (unwind_output_sec
->size
);
3741 if (unwind_output_sec
->contents
== NULL
)
3746 /* Invoke the regular ELF backend linker to do all the work. */
3747 if (!bfd_elf_final_link (abfd
, info
))
3750 if (unwind_output_sec
)
3752 elfNN_ia64_unwind_entry_compare_bfd
= abfd
;
3753 qsort (unwind_output_sec
->contents
,
3754 (size_t) (unwind_output_sec
->size
/ 24),
3756 elfNN_ia64_unwind_entry_compare
);
3758 if (! bfd_set_section_contents (abfd
, unwind_output_sec
,
3759 unwind_output_sec
->contents
, (bfd_vma
) 0,
3760 unwind_output_sec
->size
))
3768 elfNN_ia64_relocate_section (bfd
*output_bfd
,
3769 struct bfd_link_info
*info
,
3771 asection
*input_section
,
3773 Elf_Internal_Rela
*relocs
,
3774 Elf_Internal_Sym
*local_syms
,
3775 asection
**local_sections
)
3777 struct elfNN_ia64_link_hash_table
*ia64_info
;
3778 Elf_Internal_Shdr
*symtab_hdr
;
3779 Elf_Internal_Rela
*rel
;
3780 Elf_Internal_Rela
*relend
;
3782 bfd_boolean ret_val
= TRUE
; /* for non-fatal errors */
3785 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3786 ia64_info
= elfNN_ia64_hash_table (info
);
3787 if (ia64_info
== NULL
)
3790 /* Infect various flags from the input section to the output section. */
3791 if (bfd_link_relocatable (info
))
3795 flags
= elf_section_data(input_section
)->this_hdr
.sh_flags
;
3796 flags
&= SHF_IA_64_NORECOV
;
3798 elf_section_data(input_section
->output_section
)
3799 ->this_hdr
.sh_flags
|= flags
;
3802 gp_val
= _bfd_get_gp_value (output_bfd
);
3803 srel
= get_reloc_section (input_bfd
, ia64_info
, input_section
, FALSE
);
3806 relend
= relocs
+ input_section
->reloc_count
;
3807 for (; rel
< relend
; ++rel
)
3809 struct elf_link_hash_entry
*h
;
3810 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3811 bfd_reloc_status_type r
;
3812 reloc_howto_type
*howto
;
3813 unsigned long r_symndx
;
3814 Elf_Internal_Sym
*sym
;
3815 unsigned int r_type
;
3819 bfd_boolean dynamic_symbol_p
;
3820 bfd_boolean undef_weak_ref
;
3822 r_type
= ELFNN_R_TYPE (rel
->r_info
);
3823 if (r_type
> R_IA64_MAX_RELOC_CODE
)
3825 /* xgettext:c-format */
3826 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
3827 input_bfd
, (int) r_type
);
3828 bfd_set_error (bfd_error_bad_value
);
3833 howto
= ia64_elf_lookup_howto (r_type
);
3840 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
3844 undef_weak_ref
= FALSE
;
3846 if (r_symndx
< symtab_hdr
->sh_info
)
3848 /* Reloc against local symbol. */
3850 sym
= local_syms
+ r_symndx
;
3851 sym_sec
= local_sections
[r_symndx
];
3853 value
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &msec
, rel
);
3854 if (!bfd_link_relocatable (info
)
3855 && (sym_sec
->flags
& SEC_MERGE
) != 0
3856 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3857 && sym_sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
3859 struct elfNN_ia64_local_hash_entry
*loc_h
;
3861 loc_h
= get_local_sym_hash (ia64_info
, input_bfd
, rel
, FALSE
);
3862 if (loc_h
&& ! loc_h
->sec_merge_done
)
3864 struct elfNN_ia64_dyn_sym_info
*dynent
;
3867 for (count
= loc_h
->count
, dynent
= loc_h
->info
;
3873 _bfd_merged_section_offset (output_bfd
, &msec
,
3874 elf_section_data (msec
)->
3878 dynent
->addend
-= sym
->st_value
;
3879 dynent
->addend
+= msec
->output_section
->vma
3880 + msec
->output_offset
3881 - sym_sec
->output_section
->vma
3882 - sym_sec
->output_offset
;
3885 /* We may have introduced duplicated entries. We need
3886 to remove them properly. */
3887 count
= sort_dyn_sym_info (loc_h
->info
, loc_h
->count
);
3888 if (count
!= loc_h
->count
)
3890 loc_h
->count
= count
;
3891 loc_h
->sorted_count
= count
;
3894 loc_h
->sec_merge_done
= 1;
3900 bfd_boolean unresolved_reloc
;
3901 bfd_boolean warned
, ignored
;
3902 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
3904 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3905 r_symndx
, symtab_hdr
, sym_hashes
,
3907 unresolved_reloc
, warned
, ignored
);
3909 if (h
->root
.type
== bfd_link_hash_undefweak
)
3910 undef_weak_ref
= TRUE
;
3911 else if (warned
|| (ignored
&& bfd_link_executable (info
)))
3915 if (sym_sec
!= NULL
&& discarded_section (sym_sec
))
3916 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3917 rel
, 1, relend
, howto
, 0, contents
);
3919 if (bfd_link_relocatable (info
))
3922 hit_addr
= contents
+ rel
->r_offset
;
3923 value
+= rel
->r_addend
;
3924 dynamic_symbol_p
= elfNN_ia64_dynamic_symbol_p (h
, info
, r_type
);
3935 case R_IA64_DIR32MSB
:
3936 case R_IA64_DIR32LSB
:
3937 case R_IA64_DIR64MSB
:
3938 case R_IA64_DIR64LSB
:
3939 /* Install a dynamic relocation for this reloc. */
3940 if ((dynamic_symbol_p
|| bfd_link_pic (info
))
3941 && !(h
&& UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
3942 && r_symndx
!= STN_UNDEF
3943 && (input_section
->flags
& SEC_ALLOC
) != 0)
3945 unsigned int dyn_r_type
;
3949 BFD_ASSERT (srel
!= NULL
);
3956 /* ??? People shouldn't be doing non-pic code in
3957 shared libraries nor dynamic executables. */
3959 /* xgettext:c-format */
3960 (_("%pB: non-pic code with imm relocation against dynamic symbol `%s'"),
3962 h
? h
->root
.root
.string
3963 : bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3972 /* If we don't need dynamic symbol lookup, find a
3973 matching RELATIVE relocation. */
3974 dyn_r_type
= r_type
;
3975 if (dynamic_symbol_p
)
3977 dynindx
= h
->dynindx
;
3978 addend
= rel
->r_addend
;
3985 case R_IA64_DIR32MSB
:
3986 dyn_r_type
= R_IA64_REL32MSB
;
3988 case R_IA64_DIR32LSB
:
3989 dyn_r_type
= R_IA64_REL32LSB
;
3991 case R_IA64_DIR64MSB
:
3992 dyn_r_type
= R_IA64_REL64MSB
;
3994 case R_IA64_DIR64LSB
:
3995 dyn_r_type
= R_IA64_REL64LSB
;
4005 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4006 srel
, rel
->r_offset
, dyn_r_type
,
4011 case R_IA64_LTV32MSB
:
4012 case R_IA64_LTV32LSB
:
4013 case R_IA64_LTV64MSB
:
4014 case R_IA64_LTV64LSB
:
4015 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4018 case R_IA64_GPREL22
:
4019 case R_IA64_GPREL64I
:
4020 case R_IA64_GPREL32MSB
:
4021 case R_IA64_GPREL32LSB
:
4022 case R_IA64_GPREL64MSB
:
4023 case R_IA64_GPREL64LSB
:
4024 if (dynamic_symbol_p
)
4027 /* xgettext:c-format */
4028 (_("%pB: @gprel relocation against dynamic symbol %s"),
4030 h
? h
->root
.root
.string
4031 : bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4037 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4040 case R_IA64_LTOFF22
:
4041 case R_IA64_LTOFF22X
:
4042 case R_IA64_LTOFF64I
:
4043 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4044 value
= set_got_entry (input_bfd
, info
, dyn_i
, (h
? h
->dynindx
: -1),
4045 rel
->r_addend
, value
, R_IA64_DIRNNLSB
);
4047 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4050 case R_IA64_PLTOFF22
:
4051 case R_IA64_PLTOFF64I
:
4052 case R_IA64_PLTOFF64MSB
:
4053 case R_IA64_PLTOFF64LSB
:
4054 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4055 value
= set_pltoff_entry (output_bfd
, info
, dyn_i
, value
, FALSE
);
4057 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4060 case R_IA64_FPTR64I
:
4061 case R_IA64_FPTR32MSB
:
4062 case R_IA64_FPTR32LSB
:
4063 case R_IA64_FPTR64MSB
:
4064 case R_IA64_FPTR64LSB
:
4065 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4066 if (dyn_i
->want_fptr
)
4068 if (!undef_weak_ref
)
4069 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
4071 if (!dyn_i
->want_fptr
|| bfd_link_pie (info
))
4074 unsigned int dyn_r_type
= r_type
;
4075 bfd_vma addend
= rel
->r_addend
;
4077 /* Otherwise, we expect the dynamic linker to create
4080 if (dyn_i
->want_fptr
)
4082 if (r_type
== R_IA64_FPTR64I
)
4084 /* We can't represent this without a dynamic symbol.
4085 Adjust the relocation to be against an output
4086 section symbol, which are always present in the
4087 dynamic symbol table. */
4088 /* ??? People shouldn't be doing non-pic code in
4089 shared libraries. Hork. */
4091 (_("%pB: linking non-pic code in a position independent executable"),
4098 dyn_r_type
= r_type
+ R_IA64_RELNNLSB
- R_IA64_FPTRNNLSB
;
4102 if (h
->dynindx
!= -1)
4103 dynindx
= h
->dynindx
;
4105 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4106 (info
, h
->root
.u
.def
.section
->owner
,
4107 global_sym_index (h
)));
4112 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4113 (info
, input_bfd
, (long) r_symndx
));
4117 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4118 srel
, rel
->r_offset
, dyn_r_type
,
4122 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4125 case R_IA64_LTOFF_FPTR22
:
4126 case R_IA64_LTOFF_FPTR64I
:
4127 case R_IA64_LTOFF_FPTR32MSB
:
4128 case R_IA64_LTOFF_FPTR32LSB
:
4129 case R_IA64_LTOFF_FPTR64MSB
:
4130 case R_IA64_LTOFF_FPTR64LSB
:
4134 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4135 if (dyn_i
->want_fptr
)
4137 BFD_ASSERT (h
== NULL
|| h
->dynindx
== -1);
4138 if (!undef_weak_ref
)
4139 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
4144 /* Otherwise, we expect the dynamic linker to create
4148 if (h
->dynindx
!= -1)
4149 dynindx
= h
->dynindx
;
4151 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4152 (info
, h
->root
.u
.def
.section
->owner
,
4153 global_sym_index (h
)));
4156 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4157 (info
, input_bfd
, (long) r_symndx
));
4161 value
= set_got_entry (output_bfd
, info
, dyn_i
, dynindx
,
4162 rel
->r_addend
, value
, R_IA64_FPTRNNLSB
);
4164 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4168 case R_IA64_PCREL32MSB
:
4169 case R_IA64_PCREL32LSB
:
4170 case R_IA64_PCREL64MSB
:
4171 case R_IA64_PCREL64LSB
:
4172 /* Install a dynamic relocation for this reloc. */
4173 if (dynamic_symbol_p
&& r_symndx
!= STN_UNDEF
)
4175 BFD_ASSERT (srel
!= NULL
);
4177 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4178 srel
, rel
->r_offset
, r_type
,
4179 h
->dynindx
, rel
->r_addend
);
4183 case R_IA64_PCREL21B
:
4184 case R_IA64_PCREL60B
:
4185 /* We should have created a PLT entry for any dynamic symbol. */
4188 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, FALSE
);
4190 if (dyn_i
&& dyn_i
->want_plt2
)
4192 /* Should have caught this earlier. */
4193 BFD_ASSERT (rel
->r_addend
== 0);
4195 value
= (ia64_info
->root
.splt
->output_section
->vma
4196 + ia64_info
->root
.splt
->output_offset
4197 + dyn_i
->plt2_offset
);
4201 /* Since there's no PLT entry, Validate that this is
4203 BFD_ASSERT (undef_weak_ref
|| sym_sec
->output_section
!= NULL
);
4205 /* If the symbol is undef_weak, we shouldn't be trying
4206 to call it. There's every chance that we'd wind up
4207 with an out-of-range fixup here. Don't bother setting
4208 any value at all. */
4214 case R_IA64_PCREL21BI
:
4215 case R_IA64_PCREL21F
:
4216 case R_IA64_PCREL21M
:
4217 case R_IA64_PCREL22
:
4218 case R_IA64_PCREL64I
:
4219 /* The PCREL21BI reloc is specifically not intended for use with
4220 dynamic relocs. PCREL21F and PCREL21M are used for speculation
4221 fixup code, and thus probably ought not be dynamic. The
4222 PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs. */
4223 if (dynamic_symbol_p
)
4227 if (r_type
== R_IA64_PCREL21BI
)
4228 /* xgettext:c-format */
4229 msg
= _("%pB: @internal branch to dynamic symbol %s");
4230 else if (r_type
== R_IA64_PCREL21F
|| r_type
== R_IA64_PCREL21M
)
4231 /* xgettext:c-format */
4232 msg
= _("%pB: speculation fixup to dynamic symbol %s");
4234 /* xgettext:c-format */
4235 msg
= _("%pB: @pcrel relocation against dynamic symbol %s");
4236 _bfd_error_handler (msg
, input_bfd
,
4237 h
? h
->root
.root
.string
4238 : bfd_elf_sym_name (input_bfd
,
4248 /* Make pc-relative. */
4249 value
-= (input_section
->output_section
->vma
4250 + input_section
->output_offset
4251 + rel
->r_offset
) & ~ (bfd_vma
) 0x3;
4252 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4255 case R_IA64_SEGREL32MSB
:
4256 case R_IA64_SEGREL32LSB
:
4257 case R_IA64_SEGREL64MSB
:
4258 case R_IA64_SEGREL64LSB
:
4260 /* Find the segment that contains the output_section. */
4261 Elf_Internal_Phdr
*p
= _bfd_elf_find_segment_containing_section
4262 (output_bfd
, input_section
->output_section
);
4266 r
= bfd_reloc_notsupported
;
4270 /* The VMA of the segment is the vaddr of the associated
4272 if (value
> p
->p_vaddr
)
4273 value
-= p
->p_vaddr
;
4276 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4281 case R_IA64_SECREL32MSB
:
4282 case R_IA64_SECREL32LSB
:
4283 case R_IA64_SECREL64MSB
:
4284 case R_IA64_SECREL64LSB
:
4285 /* Make output-section relative to section where the symbol
4286 is defined. PR 475 */
4288 value
-= sym_sec
->output_section
->vma
;
4289 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4292 case R_IA64_IPLTMSB
:
4293 case R_IA64_IPLTLSB
:
4294 /* Install a dynamic relocation for this reloc. */
4295 if ((dynamic_symbol_p
|| bfd_link_pic (info
))
4296 && (input_section
->flags
& SEC_ALLOC
) != 0)
4298 BFD_ASSERT (srel
!= NULL
);
4300 /* If we don't need dynamic symbol lookup, install two
4301 RELATIVE relocations. */
4302 if (!dynamic_symbol_p
)
4304 unsigned int dyn_r_type
;
4306 if (r_type
== R_IA64_IPLTMSB
)
4307 dyn_r_type
= R_IA64_REL64MSB
;
4309 dyn_r_type
= R_IA64_REL64LSB
;
4311 elfNN_ia64_install_dyn_reloc (output_bfd
, info
,
4313 srel
, rel
->r_offset
,
4314 dyn_r_type
, 0, value
);
4315 elfNN_ia64_install_dyn_reloc (output_bfd
, info
,
4317 srel
, rel
->r_offset
+ 8,
4318 dyn_r_type
, 0, gp_val
);
4321 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4322 srel
, rel
->r_offset
, r_type
,
4323 h
->dynindx
, rel
->r_addend
);
4326 if (r_type
== R_IA64_IPLTMSB
)
4327 r_type
= R_IA64_DIR64MSB
;
4329 r_type
= R_IA64_DIR64LSB
;
4330 ia64_elf_install_value (hit_addr
, value
, r_type
);
4331 r
= ia64_elf_install_value (hit_addr
+ 8, gp_val
, r_type
);
4334 case R_IA64_TPREL14
:
4335 case R_IA64_TPREL22
:
4336 case R_IA64_TPREL64I
:
4337 if (elf_hash_table (info
)->tls_sec
== NULL
)
4338 goto missing_tls_sec
;
4339 value
-= elfNN_ia64_tprel_base (info
);
4340 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4343 case R_IA64_DTPREL14
:
4344 case R_IA64_DTPREL22
:
4345 case R_IA64_DTPREL64I
:
4346 case R_IA64_DTPREL32LSB
:
4347 case R_IA64_DTPREL32MSB
:
4348 case R_IA64_DTPREL64LSB
:
4349 case R_IA64_DTPREL64MSB
:
4350 if (elf_hash_table (info
)->tls_sec
== NULL
)
4351 goto missing_tls_sec
;
4352 value
-= elfNN_ia64_dtprel_base (info
);
4353 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4356 case R_IA64_LTOFF_TPREL22
:
4357 case R_IA64_LTOFF_DTPMOD22
:
4358 case R_IA64_LTOFF_DTPREL22
:
4361 long dynindx
= h
? h
->dynindx
: -1;
4362 bfd_vma r_addend
= rel
->r_addend
;
4367 case R_IA64_LTOFF_TPREL22
:
4368 if (!dynamic_symbol_p
)
4370 if (elf_hash_table (info
)->tls_sec
== NULL
)
4371 goto missing_tls_sec
;
4372 if (!bfd_link_pic (info
))
4373 value
-= elfNN_ia64_tprel_base (info
);
4376 r_addend
+= value
- elfNN_ia64_dtprel_base (info
);
4380 got_r_type
= R_IA64_TPREL64LSB
;
4382 case R_IA64_LTOFF_DTPMOD22
:
4383 if (!dynamic_symbol_p
&& !bfd_link_pic (info
))
4385 got_r_type
= R_IA64_DTPMOD64LSB
;
4387 case R_IA64_LTOFF_DTPREL22
:
4388 if (!dynamic_symbol_p
)
4390 if (elf_hash_table (info
)->tls_sec
== NULL
)
4391 goto missing_tls_sec
;
4392 value
-= elfNN_ia64_dtprel_base (info
);
4394 got_r_type
= R_IA64_DTPRELNNLSB
;
4397 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4398 value
= set_got_entry (input_bfd
, info
, dyn_i
, dynindx
, r_addend
,
4401 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4406 r
= bfd_reloc_notsupported
;
4415 case bfd_reloc_undefined
:
4416 /* This can happen for global table relative relocs if
4417 __gp is undefined. This is a panic situation so we
4418 don't try to continue. */
4419 (*info
->callbacks
->undefined_symbol
)
4420 (info
, "__gp", input_bfd
, input_section
, rel
->r_offset
, 1);
4423 case bfd_reloc_notsupported
:
4428 name
= h
->root
.root
.string
;
4430 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4432 (*info
->callbacks
->warning
) (info
, _("unsupported reloc"),
4434 input_section
, rel
->r_offset
);
4439 case bfd_reloc_dangerous
:
4440 case bfd_reloc_outofrange
:
4441 case bfd_reloc_overflow
:
4448 name
= h
->root
.root
.string
;
4450 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4455 case R_IA64_TPREL14
:
4456 case R_IA64_TPREL22
:
4457 case R_IA64_TPREL64I
:
4458 case R_IA64_DTPREL14
:
4459 case R_IA64_DTPREL22
:
4460 case R_IA64_DTPREL64I
:
4461 case R_IA64_DTPREL32LSB
:
4462 case R_IA64_DTPREL32MSB
:
4463 case R_IA64_DTPREL64LSB
:
4464 case R_IA64_DTPREL64MSB
:
4465 case R_IA64_LTOFF_TPREL22
:
4466 case R_IA64_LTOFF_DTPMOD22
:
4467 case R_IA64_LTOFF_DTPREL22
:
4469 /* xgettext:c-format */
4470 (_("%pB: missing TLS section for relocation %s against `%s'"
4471 " at %#" PRIx64
" in section `%pA'."),
4472 input_bfd
, howto
->name
, name
,
4473 (uint64_t) rel
->r_offset
, input_section
);
4476 case R_IA64_PCREL21B
:
4477 case R_IA64_PCREL21BI
:
4478 case R_IA64_PCREL21M
:
4479 case R_IA64_PCREL21F
:
4480 if (is_elf_hash_table (info
->hash
))
4482 /* Relaxtion is always performed for ELF output.
4483 Overflow failures for those relocations mean
4484 that the section is too big to relax. */
4486 /* xgettext:c-format */
4487 (_("%pB: Can't relax br (%s) to `%s' at %#" PRIx64
4488 " in section `%pA' with size %#" PRIx64
4490 input_bfd
, howto
->name
, name
, (uint64_t) rel
->r_offset
,
4491 input_section
, (uint64_t) input_section
->size
);
4496 (*info
->callbacks
->reloc_overflow
) (info
,
4517 elfNN_ia64_finish_dynamic_symbol (bfd
*output_bfd
,
4518 struct bfd_link_info
*info
,
4519 struct elf_link_hash_entry
*h
,
4520 Elf_Internal_Sym
*sym
)
4522 struct elfNN_ia64_link_hash_table
*ia64_info
;
4523 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
4525 ia64_info
= elfNN_ia64_hash_table (info
);
4526 if (ia64_info
== NULL
)
4529 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, FALSE
);
4531 /* Fill in the PLT data, if required. */
4532 if (dyn_i
&& dyn_i
->want_plt
)
4534 Elf_Internal_Rela outrel
;
4537 bfd_vma plt_addr
, pltoff_addr
, gp_val
, plt_index
;
4539 gp_val
= _bfd_get_gp_value (output_bfd
);
4541 /* Initialize the minimal PLT entry. */
4543 plt_index
= (dyn_i
->plt_offset
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
4544 plt_sec
= ia64_info
->root
.splt
;
4545 loc
= plt_sec
->contents
+ dyn_i
->plt_offset
;
4547 memcpy (loc
, plt_min_entry
, PLT_MIN_ENTRY_SIZE
);
4548 ia64_elf_install_value (loc
, plt_index
, R_IA64_IMM22
);
4549 ia64_elf_install_value (loc
+2, -dyn_i
->plt_offset
, R_IA64_PCREL21B
);
4551 plt_addr
= (plt_sec
->output_section
->vma
4552 + plt_sec
->output_offset
4553 + dyn_i
->plt_offset
);
4554 pltoff_addr
= set_pltoff_entry (output_bfd
, info
, dyn_i
, plt_addr
, TRUE
);
4556 /* Initialize the FULL PLT entry, if needed. */
4557 if (dyn_i
->want_plt2
)
4559 loc
= plt_sec
->contents
+ dyn_i
->plt2_offset
;
4561 memcpy (loc
, plt_full_entry
, PLT_FULL_ENTRY_SIZE
);
4562 ia64_elf_install_value (loc
, pltoff_addr
- gp_val
, R_IA64_IMM22
);
4564 /* Mark the symbol as undefined, rather than as defined in the
4565 plt section. Leave the value alone. */
4566 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
4567 first place. But perhaps elflink.c did some for us. */
4568 if (!h
->def_regular
)
4569 sym
->st_shndx
= SHN_UNDEF
;
4572 /* Create the dynamic relocation. */
4573 outrel
.r_offset
= pltoff_addr
;
4574 if (bfd_little_endian (output_bfd
))
4575 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_IA64_IPLTLSB
);
4577 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_IA64_IPLTMSB
);
4578 outrel
.r_addend
= 0;
4580 /* This is fun. In the .IA_64.pltoff section, we've got entries
4581 that correspond both to real PLT entries, and those that
4582 happened to resolve to local symbols but need to be created
4583 to satisfy @pltoff relocations. The .rela.IA_64.pltoff
4584 relocations for the real PLT should come at the end of the
4585 section, so that they can be indexed by plt entry at runtime.
4587 We emitted all of the relocations for the non-PLT @pltoff
4588 entries during relocate_section. So we can consider the
4589 existing sec->reloc_count to be the base of the array of
4592 loc
= ia64_info
->rel_pltoff_sec
->contents
;
4593 loc
+= ((ia64_info
->rel_pltoff_sec
->reloc_count
+ plt_index
)
4594 * sizeof (ElfNN_External_Rela
));
4595 bfd_elfNN_swap_reloca_out (output_bfd
, &outrel
, loc
);
4598 /* Mark some specially defined symbols as absolute. */
4599 if (h
== ia64_info
->root
.hdynamic
4600 || h
== ia64_info
->root
.hgot
4601 || h
== ia64_info
->root
.hplt
)
4602 sym
->st_shndx
= SHN_ABS
;
4608 elfNN_ia64_finish_dynamic_sections (bfd
*abfd
,
4609 struct bfd_link_info
*info
)
4611 struct elfNN_ia64_link_hash_table
*ia64_info
;
4614 ia64_info
= elfNN_ia64_hash_table (info
);
4615 if (ia64_info
== NULL
)
4618 dynobj
= ia64_info
->root
.dynobj
;
4620 if (ia64_info
->root
.dynamic_sections_created
)
4622 ElfNN_External_Dyn
*dyncon
, *dynconend
;
4623 asection
*sdyn
, *sgotplt
;
4626 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
4627 sgotplt
= ia64_info
->root
.sgotplt
;
4628 BFD_ASSERT (sdyn
!= NULL
);
4629 dyncon
= (ElfNN_External_Dyn
*) sdyn
->contents
;
4630 dynconend
= (ElfNN_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4632 gp_val
= _bfd_get_gp_value (abfd
);
4634 for (; dyncon
< dynconend
; dyncon
++)
4636 Elf_Internal_Dyn dyn
;
4638 bfd_elfNN_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4643 dyn
.d_un
.d_ptr
= gp_val
;
4647 dyn
.d_un
.d_val
= (ia64_info
->minplt_entries
4648 * sizeof (ElfNN_External_Rela
));
4652 /* See the comment above in finish_dynamic_symbol. */
4653 dyn
.d_un
.d_ptr
= (ia64_info
->rel_pltoff_sec
->output_section
->vma
4654 + ia64_info
->rel_pltoff_sec
->output_offset
4655 + (ia64_info
->rel_pltoff_sec
->reloc_count
4656 * sizeof (ElfNN_External_Rela
)));
4659 case DT_IA_64_PLT_RESERVE
:
4660 dyn
.d_un
.d_ptr
= (sgotplt
->output_section
->vma
4661 + sgotplt
->output_offset
);
4665 bfd_elfNN_swap_dyn_out (abfd
, &dyn
, dyncon
);
4668 /* Initialize the PLT0 entry. */
4669 if (ia64_info
->root
.splt
)
4671 bfd_byte
*loc
= ia64_info
->root
.splt
->contents
;
4674 memcpy (loc
, plt_header
, PLT_HEADER_SIZE
);
4676 pltres
= (sgotplt
->output_section
->vma
4677 + sgotplt
->output_offset
4680 ia64_elf_install_value (loc
+1, pltres
, R_IA64_GPREL22
);
4687 /* ELF file flag handling: */
4689 /* Function to keep IA-64 specific file flags. */
4691 elfNN_ia64_set_private_flags (bfd
*abfd
, flagword flags
)
4693 BFD_ASSERT (!elf_flags_init (abfd
)
4694 || elf_elfheader (abfd
)->e_flags
== flags
);
4696 elf_elfheader (abfd
)->e_flags
= flags
;
4697 elf_flags_init (abfd
) = TRUE
;
4701 /* Merge backend specific data from an object file to the output
4702 object file when linking. */
4705 elfNN_ia64_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
4707 bfd
*obfd
= info
->output_bfd
;
4710 bfd_boolean ok
= TRUE
;
4712 /* FIXME: What should be checked when linking shared libraries? */
4713 if ((ibfd
->flags
& DYNAMIC
) != 0)
4716 if (!is_ia64_elf (ibfd
) || !is_ia64_elf (obfd
))
4719 in_flags
= elf_elfheader (ibfd
)->e_flags
;
4720 out_flags
= elf_elfheader (obfd
)->e_flags
;
4722 if (! elf_flags_init (obfd
))
4724 elf_flags_init (obfd
) = TRUE
;
4725 elf_elfheader (obfd
)->e_flags
= in_flags
;
4727 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
4728 && bfd_get_arch_info (obfd
)->the_default
)
4730 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
4731 bfd_get_mach (ibfd
));
4737 /* Check flag compatibility. */
4738 if (in_flags
== out_flags
)
4741 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
4742 if (!(in_flags
& EF_IA_64_REDUCEDFP
) && (out_flags
& EF_IA_64_REDUCEDFP
))
4743 elf_elfheader (obfd
)->e_flags
&= ~EF_IA_64_REDUCEDFP
;
4745 if ((in_flags
& EF_IA_64_TRAPNIL
) != (out_flags
& EF_IA_64_TRAPNIL
))
4748 (_("%pB: linking trap-on-NULL-dereference with non-trapping files"),
4751 bfd_set_error (bfd_error_bad_value
);
4754 if ((in_flags
& EF_IA_64_BE
) != (out_flags
& EF_IA_64_BE
))
4757 (_("%pB: linking big-endian files with little-endian files"),
4760 bfd_set_error (bfd_error_bad_value
);
4763 if ((in_flags
& EF_IA_64_ABI64
) != (out_flags
& EF_IA_64_ABI64
))
4766 (_("%pB: linking 64-bit files with 32-bit files"),
4769 bfd_set_error (bfd_error_bad_value
);
4772 if ((in_flags
& EF_IA_64_CONS_GP
) != (out_flags
& EF_IA_64_CONS_GP
))
4775 (_("%pB: linking constant-gp files with non-constant-gp files"),
4778 bfd_set_error (bfd_error_bad_value
);
4781 if ((in_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
)
4782 != (out_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
4785 (_("%pB: linking auto-pic files with non-auto-pic files"),
4788 bfd_set_error (bfd_error_bad_value
);
4796 elfNN_ia64_print_private_bfd_data (bfd
*abfd
, void * ptr
)
4798 FILE *file
= (FILE *) ptr
;
4799 flagword flags
= elf_elfheader (abfd
)->e_flags
;
4801 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
4803 fprintf (file
, "private flags = %s%s%s%s%s%s%s%s\n",
4804 (flags
& EF_IA_64_TRAPNIL
) ? "TRAPNIL, " : "",
4805 (flags
& EF_IA_64_EXT
) ? "EXT, " : "",
4806 (flags
& EF_IA_64_BE
) ? "BE, " : "LE, ",
4807 (flags
& EF_IA_64_REDUCEDFP
) ? "REDUCEDFP, " : "",
4808 (flags
& EF_IA_64_CONS_GP
) ? "CONS_GP, " : "",
4809 (flags
& EF_IA_64_NOFUNCDESC_CONS_GP
) ? "NOFUNCDESC_CONS_GP, " : "",
4810 (flags
& EF_IA_64_ABSOLUTE
) ? "ABSOLUTE, " : "",
4811 (flags
& EF_IA_64_ABI64
) ? "ABI64" : "ABI32");
4813 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
4817 static enum elf_reloc_type_class
4818 elfNN_ia64_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4819 const asection
*rel_sec ATTRIBUTE_UNUSED
,
4820 const Elf_Internal_Rela
*rela
)
4822 switch ((int) ELFNN_R_TYPE (rela
->r_info
))
4824 case R_IA64_REL32MSB
:
4825 case R_IA64_REL32LSB
:
4826 case R_IA64_REL64MSB
:
4827 case R_IA64_REL64LSB
:
4828 return reloc_class_relative
;
4829 case R_IA64_IPLTMSB
:
4830 case R_IA64_IPLTLSB
:
4831 return reloc_class_plt
;
4833 return reloc_class_copy
;
4835 return reloc_class_normal
;
4839 static const struct bfd_elf_special_section elfNN_ia64_special_sections
[] =
4841 { STRING_COMMA_LEN (".sbss"), -1, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_IA_64_SHORT
},
4842 { STRING_COMMA_LEN (".sdata"), -1, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_IA_64_SHORT
},
4843 { NULL
, 0, 0, 0, 0 }
4847 elfNN_ia64_object_p (bfd
*abfd
)
4850 asection
*group
, *unwi
, *unw
;
4853 char *unwi_name
, *unw_name
;
4856 if (abfd
->flags
& DYNAMIC
)
4859 /* Flags for fake group section. */
4860 flags
= (SEC_LINKER_CREATED
| SEC_GROUP
| SEC_LINK_ONCE
4863 /* We add a fake section group for each .gnu.linkonce.t.* section,
4864 which isn't in a section group, and its unwind sections. */
4865 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4867 if (elf_sec_group (sec
) == NULL
4868 && ((sec
->flags
& (SEC_LINK_ONCE
| SEC_CODE
| SEC_GROUP
))
4869 == (SEC_LINK_ONCE
| SEC_CODE
))
4870 && CONST_STRNEQ (sec
->name
, ".gnu.linkonce.t."))
4872 name
= sec
->name
+ 16;
4874 amt
= strlen (name
) + sizeof (".gnu.linkonce.ia64unwi.");
4875 unwi_name
= bfd_alloc (abfd
, amt
);
4879 strcpy (stpcpy (unwi_name
, ".gnu.linkonce.ia64unwi."), name
);
4880 unwi
= bfd_get_section_by_name (abfd
, unwi_name
);
4882 amt
= strlen (name
) + sizeof (".gnu.linkonce.ia64unw.");
4883 unw_name
= bfd_alloc (abfd
, amt
);
4887 strcpy (stpcpy (unw_name
, ".gnu.linkonce.ia64unw."), name
);
4888 unw
= bfd_get_section_by_name (abfd
, unw_name
);
4890 /* We need to create a fake group section for it and its
4892 group
= bfd_make_section_anyway_with_flags (abfd
, name
,
4897 /* Move the fake group section to the beginning. */
4898 bfd_section_list_remove (abfd
, group
);
4899 bfd_section_list_prepend (abfd
, group
);
4901 elf_next_in_group (group
) = sec
;
4903 elf_group_name (sec
) = name
;
4904 elf_next_in_group (sec
) = sec
;
4905 elf_sec_group (sec
) = group
;
4909 elf_group_name (unwi
) = name
;
4910 elf_next_in_group (unwi
) = sec
;
4911 elf_next_in_group (sec
) = unwi
;
4912 elf_sec_group (unwi
) = group
;
4917 elf_group_name (unw
) = name
;
4920 elf_next_in_group (unw
) = elf_next_in_group (unwi
);
4921 elf_next_in_group (unwi
) = unw
;
4925 elf_next_in_group (unw
) = sec
;
4926 elf_next_in_group (sec
) = unw
;
4928 elf_sec_group (unw
) = group
;
4931 /* Fake SHT_GROUP section header. */
4932 elf_section_data (group
)->this_hdr
.bfd_section
= group
;
4933 elf_section_data (group
)->this_hdr
.sh_type
= SHT_GROUP
;
4940 elfNN_ia64_hpux_vec (const bfd_target
*vec
)
4942 extern const bfd_target ia64_elfNN_hpux_be_vec
;
4943 return (vec
== &ia64_elfNN_hpux_be_vec
);
4947 elfNN_hpux_init_file_header (bfd
*abfd
, struct bfd_link_info
*info
)
4949 Elf_Internal_Ehdr
*i_ehdrp
;
4951 if (!_bfd_elf_init_file_header (abfd
, info
))
4954 i_ehdrp
= elf_elfheader (abfd
);
4955 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
4956 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 1;
4961 elfNN_hpux_backend_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
4962 asection
*sec
, int *retval
)
4964 if (bfd_is_com_section (sec
))
4966 *retval
= SHN_IA_64_ANSI_COMMON
;
4973 elfNN_hpux_backend_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
4976 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
4978 switch (elfsym
->internal_elf_sym
.st_shndx
)
4980 case SHN_IA_64_ANSI_COMMON
:
4981 asym
->section
= bfd_com_section_ptr
;
4982 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
4983 asym
->flags
&= ~BSF_GLOBAL
;
4989 ignore_errors (const char *fmt ATTRIBUTE_UNUSED
, ...)
4993 #define TARGET_LITTLE_SYM ia64_elfNN_le_vec
4994 #define TARGET_LITTLE_NAME "elfNN-ia64-little"
4995 #define TARGET_BIG_SYM ia64_elfNN_be_vec
4996 #define TARGET_BIG_NAME "elfNN-ia64-big"
4997 #define ELF_ARCH bfd_arch_ia64
4998 #define ELF_TARGET_ID IA64_ELF_DATA
4999 #define ELF_MACHINE_CODE EM_IA_64
5000 #define ELF_MACHINE_ALT1 1999 /* EAS2.3 */
5001 #define ELF_MACHINE_ALT2 1998 /* EAS2.2 */
5002 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
5003 #define ELF_COMMONPAGESIZE 0x4000 /* 16KB */
5005 #define elf_backend_section_from_shdr \
5006 elfNN_ia64_section_from_shdr
5007 #define elf_backend_section_flags \
5008 elfNN_ia64_section_flags
5009 #define elf_backend_fake_sections \
5010 elfNN_ia64_fake_sections
5011 #define elf_backend_final_write_processing \
5012 elfNN_ia64_final_write_processing
5013 #define elf_backend_add_symbol_hook \
5014 elfNN_ia64_add_symbol_hook
5015 #define elf_backend_additional_program_headers \
5016 elfNN_ia64_additional_program_headers
5017 #define elf_backend_modify_segment_map \
5018 elfNN_ia64_modify_segment_map
5019 #define elf_backend_modify_headers \
5020 elfNN_ia64_modify_headers
5021 #define elf_info_to_howto \
5022 elfNN_ia64_info_to_howto
5024 #define bfd_elfNN_bfd_reloc_type_lookup \
5025 ia64_elf_reloc_type_lookup
5026 #define bfd_elfNN_bfd_reloc_name_lookup \
5027 ia64_elf_reloc_name_lookup
5028 #define bfd_elfNN_bfd_is_local_label_name \
5029 elfNN_ia64_is_local_label_name
5030 #define bfd_elfNN_bfd_relax_section \
5031 elfNN_ia64_relax_section
5033 #define elf_backend_object_p \
5036 /* Stuff for the BFD linker: */
5037 #define bfd_elfNN_bfd_link_hash_table_create \
5038 elfNN_ia64_hash_table_create
5039 #define elf_backend_create_dynamic_sections \
5040 elfNN_ia64_create_dynamic_sections
5041 #define elf_backend_check_relocs \
5042 elfNN_ia64_check_relocs
5043 #define elf_backend_adjust_dynamic_symbol \
5044 elfNN_ia64_adjust_dynamic_symbol
5045 #define elf_backend_size_dynamic_sections \
5046 elfNN_ia64_size_dynamic_sections
5047 #define elf_backend_omit_section_dynsym \
5048 _bfd_elf_omit_section_dynsym_all
5049 #define elf_backend_relocate_section \
5050 elfNN_ia64_relocate_section
5051 #define elf_backend_finish_dynamic_symbol \
5052 elfNN_ia64_finish_dynamic_symbol
5053 #define elf_backend_finish_dynamic_sections \
5054 elfNN_ia64_finish_dynamic_sections
5055 #define bfd_elfNN_bfd_final_link \
5056 elfNN_ia64_final_link
5058 #define bfd_elfNN_bfd_merge_private_bfd_data \
5059 elfNN_ia64_merge_private_bfd_data
5060 #define bfd_elfNN_bfd_set_private_flags \
5061 elfNN_ia64_set_private_flags
5062 #define bfd_elfNN_bfd_print_private_bfd_data \
5063 elfNN_ia64_print_private_bfd_data
5065 #define elf_backend_plt_readonly 1
5066 #define elf_backend_can_gc_sections 1
5067 #define elf_backend_want_plt_sym 0
5068 #define elf_backend_plt_alignment 5
5069 #define elf_backend_got_header_size 0
5070 #define elf_backend_want_got_plt 1
5071 #define elf_backend_may_use_rel_p 1
5072 #define elf_backend_may_use_rela_p 1
5073 #define elf_backend_default_use_rela_p 1
5074 #define elf_backend_want_dynbss 0
5075 #define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect
5076 #define elf_backend_hide_symbol elfNN_ia64_hash_hide_symbol
5077 #define elf_backend_fixup_symbol _bfd_elf_link_hash_fixup_symbol
5078 #define elf_backend_reloc_type_class elfNN_ia64_reloc_type_class
5079 #define elf_backend_rela_normal 1
5080 #define elf_backend_dtrel_excludes_plt 1
5081 #define elf_backend_special_sections elfNN_ia64_special_sections
5082 #define elf_backend_default_execstack 0
5084 /* FIXME: PR 290: The Intel C compiler generates SHT_IA_64_UNWIND with
5085 SHF_LINK_ORDER. But it doesn't set the sh_link or sh_info fields.
5086 We don't want to flood users with so many error messages. We turn
5087 off the warning for now. It will be turned on later when the Intel
5088 compiler is fixed. */
5089 #define elf_backend_link_order_error_handler ignore_errors
5091 #include "elfNN-target.h"
5093 /* HPUX-specific vectors. */
5095 #undef TARGET_LITTLE_SYM
5096 #undef TARGET_LITTLE_NAME
5097 #undef TARGET_BIG_SYM
5098 #define TARGET_BIG_SYM ia64_elfNN_hpux_be_vec
5099 #undef TARGET_BIG_NAME
5100 #define TARGET_BIG_NAME "elfNN-ia64-hpux-big"
5102 /* These are HP-UX specific functions. */
5104 #undef elf_backend_init_file_header
5105 #define elf_backend_init_file_header elfNN_hpux_init_file_header
5107 #undef elf_backend_section_from_bfd_section
5108 #define elf_backend_section_from_bfd_section elfNN_hpux_backend_section_from_bfd_section
5110 #undef elf_backend_symbol_processing
5111 #define elf_backend_symbol_processing elfNN_hpux_backend_symbol_processing
5113 #undef elf_backend_want_p_paddr_set_to_zero
5114 #define elf_backend_want_p_paddr_set_to_zero 1
5116 #undef ELF_COMMONPAGESIZE
5118 #define ELF_OSABI ELFOSABI_HPUX
5121 #define elfNN_bed elfNN_ia64_hpux_bed
5123 #include "elfNN-target.h"