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 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
170 == IA64_ELF_DATA ? ((struct elfNN_ia64_link_hash_table *) ((p)->hash)) : NULL)
172 static struct elfNN_ia64_dyn_sym_info
* get_dyn_sym_info
173 (struct elfNN_ia64_link_hash_table
*ia64_info
,
174 struct elf_link_hash_entry
*h
,
175 bfd
*abfd
, const Elf_Internal_Rela
*rel
, bfd_boolean create
);
176 static bfd_boolean elfNN_ia64_dynamic_symbol_p
177 (struct elf_link_hash_entry
*h
, struct bfd_link_info
*info
, int);
178 static bfd_boolean elfNN_ia64_choose_gp
179 (bfd
*abfd
, struct bfd_link_info
*info
, bfd_boolean final
);
180 static void elfNN_ia64_dyn_sym_traverse
181 (struct elfNN_ia64_link_hash_table
*ia64_info
,
182 bfd_boolean (*func
) (struct elfNN_ia64_dyn_sym_info
*, void *),
184 static bfd_boolean allocate_global_data_got
185 (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
);
186 static bfd_boolean allocate_global_fptr_got
187 (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
);
188 static bfd_boolean allocate_local_got
189 (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
);
190 static bfd_boolean elfNN_ia64_hpux_vec
191 (const bfd_target
*vec
);
192 static bfd_boolean allocate_dynrel_entries
193 (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
);
194 static asection
*get_pltoff
195 (bfd
*abfd
, struct bfd_link_info
*info
,
196 struct elfNN_ia64_link_hash_table
*ia64_info
);
198 /* ia64-specific relocation. */
200 /* Given a ELF reloc, return the matching HOWTO structure. */
203 elfNN_ia64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
205 Elf_Internal_Rela
*elf_reloc
)
207 unsigned int r_type
= ELF32_R_TYPE (elf_reloc
->r_info
);
209 bfd_reloc
->howto
= ia64_elf_lookup_howto (r_type
);
210 if (bfd_reloc
->howto
== NULL
)
212 /* xgettext:c-format */
213 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
215 bfd_set_error (bfd_error_bad_value
);
222 #define PLT_HEADER_SIZE (3 * 16)
223 #define PLT_MIN_ENTRY_SIZE (1 * 16)
224 #define PLT_FULL_ENTRY_SIZE (2 * 16)
225 #define PLT_RESERVED_WORDS 3
227 static const bfd_byte plt_header
[PLT_HEADER_SIZE
] =
229 0x0b, 0x10, 0x00, 0x1c, 0x00, 0x21, /* [MMI] mov r2=r14;; */
230 0xe0, 0x00, 0x08, 0x00, 0x48, 0x00, /* addl r14=0,r2 */
231 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
232 0x0b, 0x80, 0x20, 0x1c, 0x18, 0x14, /* [MMI] ld8 r16=[r14],8;; */
233 0x10, 0x41, 0x38, 0x30, 0x28, 0x00, /* ld8 r17=[r14],8 */
234 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
235 0x11, 0x08, 0x00, 0x1c, 0x18, 0x10, /* [MIB] ld8 r1=[r14] */
236 0x60, 0x88, 0x04, 0x80, 0x03, 0x00, /* mov b6=r17 */
237 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
240 static const bfd_byte plt_min_entry
[PLT_MIN_ENTRY_SIZE
] =
242 0x11, 0x78, 0x00, 0x00, 0x00, 0x24, /* [MIB] mov r15=0 */
243 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, /* nop.i 0x0 */
244 0x00, 0x00, 0x00, 0x40 /* br.few 0 <PLT0>;; */
247 static const bfd_byte plt_full_entry
[PLT_FULL_ENTRY_SIZE
] =
249 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
250 0x00, 0x41, 0x3c, 0x70, 0x29, 0xc0, /* ld8.acq r16=[r15],8*/
251 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
252 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
253 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
254 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
257 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
259 static const bfd_byte oor_brl
[16] =
261 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
262 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;; */
263 0x00, 0x00, 0x00, 0xc0
266 static const bfd_byte oor_ip
[48] =
268 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
269 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, /* movl r15=0 */
270 0x01, 0x00, 0x00, 0x60,
271 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MII] nop.m 0 */
272 0x00, 0x01, 0x00, 0x60, 0x00, 0x00, /* mov r16=ip;; */
273 0xf2, 0x80, 0x00, 0x80, /* add r16=r15,r16;; */
274 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MIB] nop.m 0 */
275 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
276 0x60, 0x00, 0x80, 0x00 /* br b6;; */
279 static size_t oor_branch_size
= sizeof (oor_brl
);
282 bfd_elfNN_ia64_after_parse (int itanium
)
284 oor_branch_size
= itanium
? sizeof (oor_ip
) : sizeof (oor_brl
);
288 /* Rename some of the generic section flags to better document how they
290 #define skip_relax_pass_0 sec_flg0
291 #define skip_relax_pass_1 sec_flg1
293 /* These functions do relaxation for IA-64 ELF. */
296 elfNN_ia64_update_short_info (asection
*sec
, bfd_vma offset
,
297 struct elfNN_ia64_link_hash_table
*ia64_info
)
299 /* Skip ABS and SHF_IA_64_SHORT sections. */
300 if (sec
== bfd_abs_section_ptr
301 || (sec
->flags
& SEC_SMALL_DATA
) != 0)
304 if (!ia64_info
->min_short_sec
)
306 ia64_info
->max_short_sec
= sec
;
307 ia64_info
->max_short_offset
= offset
;
308 ia64_info
->min_short_sec
= sec
;
309 ia64_info
->min_short_offset
= offset
;
311 else if (sec
== ia64_info
->max_short_sec
312 && offset
> ia64_info
->max_short_offset
)
313 ia64_info
->max_short_offset
= offset
;
314 else if (sec
== ia64_info
->min_short_sec
315 && offset
< ia64_info
->min_short_offset
)
316 ia64_info
->min_short_offset
= offset
;
317 else if (sec
->output_section
->vma
318 > ia64_info
->max_short_sec
->vma
)
320 ia64_info
->max_short_sec
= sec
;
321 ia64_info
->max_short_offset
= offset
;
323 else if (sec
->output_section
->vma
324 < ia64_info
->min_short_sec
->vma
)
326 ia64_info
->min_short_sec
= sec
;
327 ia64_info
->min_short_offset
= offset
;
332 elfNN_ia64_relax_section (bfd
*abfd
, asection
*sec
,
333 struct bfd_link_info
*link_info
,
338 struct one_fixup
*next
;
344 Elf_Internal_Shdr
*symtab_hdr
;
345 Elf_Internal_Rela
*internal_relocs
;
346 Elf_Internal_Rela
*irel
, *irelend
;
348 Elf_Internal_Sym
*isymbuf
= NULL
;
349 struct elfNN_ia64_link_hash_table
*ia64_info
;
350 struct one_fixup
*fixups
= NULL
;
351 bfd_boolean changed_contents
= FALSE
;
352 bfd_boolean changed_relocs
= FALSE
;
353 bfd_boolean changed_got
= FALSE
;
354 bfd_boolean skip_relax_pass_0
= TRUE
;
355 bfd_boolean skip_relax_pass_1
= TRUE
;
358 /* Assume we're not going to change any sizes, and we'll only need
362 if (bfd_link_relocatable (link_info
))
363 (*link_info
->callbacks
->einfo
)
364 (_("%P%F: --relax and -r may not be used together\n"));
366 /* Don't even try to relax for non-ELF outputs. */
367 if (!is_elf_hash_table (link_info
->hash
))
370 /* Nothing to do if there are no relocations or there is no need for
372 if ((sec
->flags
& SEC_RELOC
) == 0
373 || sec
->reloc_count
== 0
374 || (link_info
->relax_pass
== 0 && sec
->skip_relax_pass_0
)
375 || (link_info
->relax_pass
== 1 && sec
->skip_relax_pass_1
))
378 ia64_info
= elfNN_ia64_hash_table (link_info
);
379 if (ia64_info
== NULL
)
382 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
384 /* Load the relocations for this section. */
385 internal_relocs
= (_bfd_elf_link_read_relocs
386 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
387 link_info
->keep_memory
));
388 if (internal_relocs
== NULL
)
391 irelend
= internal_relocs
+ sec
->reloc_count
;
393 /* Get the section contents. */
394 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
395 contents
= elf_section_data (sec
)->this_hdr
.contents
;
398 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
402 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
404 unsigned long r_type
= ELFNN_R_TYPE (irel
->r_info
);
405 bfd_vma symaddr
, reladdr
, trampoff
, toff
, roff
;
409 bfd_boolean is_branch
;
410 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
415 case R_IA64_PCREL21B
:
416 case R_IA64_PCREL21BI
:
417 case R_IA64_PCREL21M
:
418 case R_IA64_PCREL21F
:
419 /* In pass 1, all br relaxations are done. We can skip it. */
420 if (link_info
->relax_pass
== 1)
422 skip_relax_pass_0
= FALSE
;
426 case R_IA64_PCREL60B
:
427 /* We can't optimize brl to br in pass 0 since br relaxations
428 will increase the code size. Defer it to pass 1. */
429 if (link_info
->relax_pass
== 0)
431 skip_relax_pass_1
= FALSE
;
438 /* Update max_short_sec/min_short_sec. */
440 case R_IA64_LTOFF22X
:
442 /* We can't relax ldx/mov in pass 0 since br relaxations will
443 increase the code size. Defer it to pass 1. */
444 if (link_info
->relax_pass
== 0)
446 skip_relax_pass_1
= FALSE
;
456 /* Get the value of the symbol referred to by the reloc. */
457 if (ELFNN_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
459 /* A local symbol. */
460 Elf_Internal_Sym
*isym
;
462 /* Read this BFD's local symbols. */
465 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
467 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
468 symtab_hdr
->sh_info
, 0,
474 isym
= isymbuf
+ ELFNN_R_SYM (irel
->r_info
);
475 if (isym
->st_shndx
== SHN_UNDEF
)
476 continue; /* We can't do anything with undefined symbols. */
477 else if (isym
->st_shndx
== SHN_ABS
)
478 tsec
= bfd_abs_section_ptr
;
479 else if (isym
->st_shndx
== SHN_COMMON
)
480 tsec
= bfd_com_section_ptr
;
481 else if (isym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
482 tsec
= bfd_com_section_ptr
;
484 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
486 toff
= isym
->st_value
;
487 dyn_i
= get_dyn_sym_info (ia64_info
, NULL
, abfd
, irel
, FALSE
);
488 symtype
= ELF_ST_TYPE (isym
->st_info
);
493 struct elf_link_hash_entry
*h
;
495 indx
= ELFNN_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
496 h
= elf_sym_hashes (abfd
)[indx
];
497 BFD_ASSERT (h
!= NULL
);
499 while (h
->root
.type
== bfd_link_hash_indirect
500 || h
->root
.type
== bfd_link_hash_warning
)
501 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
503 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, irel
, FALSE
);
505 /* For branches to dynamic symbols, we're interested instead
506 in a branch to the PLT entry. */
507 if (is_branch
&& dyn_i
&& dyn_i
->want_plt2
)
509 /* Internal branches shouldn't be sent to the PLT.
510 Leave this for now and we'll give an error later. */
511 if (r_type
!= R_IA64_PCREL21B
)
514 tsec
= ia64_info
->root
.splt
;
515 toff
= dyn_i
->plt2_offset
;
516 BFD_ASSERT (irel
->r_addend
== 0);
519 /* Can't do anything else with dynamic symbols. */
520 else if (elfNN_ia64_dynamic_symbol_p (h
, link_info
, r_type
))
525 /* We can't do anything with undefined symbols. */
526 if (h
->root
.type
== bfd_link_hash_undefined
527 || h
->root
.type
== bfd_link_hash_undefweak
)
530 tsec
= h
->root
.u
.def
.section
;
531 toff
= h
->root
.u
.def
.value
;
537 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
539 /* At this stage in linking, no SEC_MERGE symbol has been
540 adjusted, so all references to such symbols need to be
541 passed through _bfd_merged_section_offset. (Later, in
542 relocate_section, all SEC_MERGE symbols *except* for
543 section symbols have been adjusted.)
545 gas may reduce relocations against symbols in SEC_MERGE
546 sections to a relocation against the section symbol when
547 the original addend was zero. When the reloc is against
548 a section symbol we should include the addend in the
549 offset passed to _bfd_merged_section_offset, since the
550 location of interest is the original symbol. On the
551 other hand, an access to "sym+addend" where "sym" is not
552 a section symbol should not include the addend; Such an
553 access is presumed to be an offset from "sym"; The
554 location of interest is just "sym". */
555 if (symtype
== STT_SECTION
)
556 toff
+= irel
->r_addend
;
558 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
559 elf_section_data (tsec
)->sec_info
,
562 if (symtype
!= STT_SECTION
)
563 toff
+= irel
->r_addend
;
566 toff
+= irel
->r_addend
;
568 symaddr
= tsec
->output_section
->vma
+ tsec
->output_offset
+ toff
;
570 roff
= irel
->r_offset
;
574 bfd_signed_vma offset
;
576 reladdr
= (sec
->output_section
->vma
578 + roff
) & (bfd_vma
) -4;
580 /* The .plt section is aligned at 32byte and the .text section
581 is aligned at 64byte. The .text section is right after the
582 .plt section. After the first relaxation pass, linker may
583 increase the gap between the .plt and .text sections up
584 to 32byte. We assume linker will always insert 32byte
585 between the .plt and .text sections after the first
587 if (tsec
== ia64_info
->root
.splt
)
588 offset
= -0x1000000 + 32;
592 /* If the branch is in range, no need to do anything. */
593 if ((bfd_signed_vma
) (symaddr
- reladdr
) >= offset
594 && (bfd_signed_vma
) (symaddr
- reladdr
) <= 0x0FFFFF0)
596 /* If the 60-bit branch is in 21-bit range, optimize it. */
597 if (r_type
== R_IA64_PCREL60B
)
599 ia64_elf_relax_brl (contents
, roff
);
602 = ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
605 /* If the original relocation offset points to slot
606 1, change it to slot 2. */
607 if ((irel
->r_offset
& 3) == 1)
610 changed_contents
= TRUE
;
611 changed_relocs
= TRUE
;
616 else if (r_type
== R_IA64_PCREL60B
)
618 else if (ia64_elf_relax_br (contents
, roff
))
621 = ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
624 /* Make the relocation offset point to slot 1. */
625 irel
->r_offset
= (irel
->r_offset
& ~((bfd_vma
) 0x3)) + 1;
627 changed_contents
= TRUE
;
628 changed_relocs
= TRUE
;
632 /* We can't put a trampoline in a .init/.fini section. Issue
634 if (strcmp (sec
->output_section
->name
, ".init") == 0
635 || strcmp (sec
->output_section
->name
, ".fini") == 0)
638 /* xgettext:c-format */
639 (_("%pB: can't relax br at %#" PRIx64
" in section `%pA';"
640 " please use brl or indirect branch"),
641 sec
->owner
, (uint64_t) roff
, sec
);
642 bfd_set_error (bfd_error_bad_value
);
646 /* If the branch and target are in the same section, you've
647 got one honking big section and we can't help you unless
648 you are branching backwards. You'll get an error message
650 if (tsec
== sec
&& toff
> roff
)
653 /* Look for an existing fixup to this address. */
654 for (f
= fixups
; f
; f
= f
->next
)
655 if (f
->tsec
== tsec
&& f
->toff
== toff
)
660 /* Two alternatives: If it's a branch to a PLT entry, we can
661 make a copy of the FULL_PLT entry. Otherwise, we'll have
662 to use a `brl' insn to get where we're going. */
666 if (tsec
== ia64_info
->root
.splt
)
667 size
= sizeof (plt_full_entry
);
669 size
= oor_branch_size
;
671 /* Resize the current section to make room for the new branch. */
672 trampoff
= (sec
->size
+ 15) & (bfd_vma
) -16;
674 /* If trampoline is out of range, there is nothing we
676 offset
= trampoff
- (roff
& (bfd_vma
) -4);
677 if (offset
< -0x1000000 || offset
> 0x0FFFFF0)
680 amt
= trampoff
+ size
;
681 contents
= (bfd_byte
*) bfd_realloc (contents
, amt
);
682 if (contents
== NULL
)
686 if (tsec
== ia64_info
->root
.splt
)
688 memcpy (contents
+ trampoff
, plt_full_entry
, size
);
690 /* Hijack the old relocation for use as the PLTOFF reloc. */
691 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
693 irel
->r_offset
= trampoff
;
697 if (size
== sizeof (oor_ip
))
699 memcpy (contents
+ trampoff
, oor_ip
, size
);
700 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
702 irel
->r_addend
-= 16;
703 irel
->r_offset
= trampoff
+ 2;
707 memcpy (contents
+ trampoff
, oor_brl
, size
);
708 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
710 irel
->r_offset
= trampoff
+ 2;
715 /* Record the fixup so we don't do it again this section. */
716 f
= (struct one_fixup
*)
717 bfd_malloc ((bfd_size_type
) sizeof (*f
));
721 f
->trampoff
= trampoff
;
726 /* If trampoline is out of range, there is nothing we
728 offset
= f
->trampoff
- (roff
& (bfd_vma
) -4);
729 if (offset
< -0x1000000 || offset
> 0x0FFFFF0)
732 /* Nop out the reloc, since we're finalizing things here. */
733 irel
->r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
736 /* Fix up the existing branch to hit the trampoline. */
737 if (ia64_elf_install_value (contents
+ roff
, offset
, r_type
)
741 changed_contents
= TRUE
;
742 changed_relocs
= TRUE
;
749 bfd
*obfd
= sec
->output_section
->owner
;
750 gp
= _bfd_get_gp_value (obfd
);
753 if (!elfNN_ia64_choose_gp (obfd
, link_info
, FALSE
))
755 gp
= _bfd_get_gp_value (obfd
);
759 /* If the data is out of range, do nothing. */
760 if ((bfd_signed_vma
) (symaddr
- gp
) >= 0x200000
761 ||(bfd_signed_vma
) (symaddr
- gp
) < -0x200000)
764 if (r_type
== R_IA64_GPREL22
)
765 elfNN_ia64_update_short_info (tsec
->output_section
,
766 tsec
->output_offset
+ toff
,
768 else if (r_type
== R_IA64_LTOFF22X
)
770 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
772 changed_relocs
= TRUE
;
773 if (dyn_i
->want_gotx
)
775 dyn_i
->want_gotx
= 0;
776 changed_got
|= !dyn_i
->want_got
;
779 elfNN_ia64_update_short_info (tsec
->output_section
,
780 tsec
->output_offset
+ toff
,
785 ia64_elf_relax_ldxmov (contents
, roff
);
786 irel
->r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
787 changed_contents
= TRUE
;
788 changed_relocs
= TRUE
;
793 /* ??? If we created fixups, this may push the code segment large
794 enough that the data segment moves, which will change the GP.
795 Reset the GP so that we re-calculate next round. We need to
796 do this at the _beginning_ of the next round; now will not do. */
798 /* Clean up and go home. */
801 struct one_fixup
*f
= fixups
;
802 fixups
= fixups
->next
;
807 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
809 if (! link_info
->keep_memory
)
813 /* Cache the symbols for elf_link_input_bfd. */
814 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
819 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
821 if (!changed_contents
&& !link_info
->keep_memory
)
825 /* Cache the section contents for elf_link_input_bfd. */
826 elf_section_data (sec
)->this_hdr
.contents
= contents
;
830 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
833 free (internal_relocs
);
835 elf_section_data (sec
)->relocs
= internal_relocs
;
840 struct elfNN_ia64_allocate_data data
;
841 data
.info
= link_info
;
843 ia64_info
->self_dtpmod_offset
= (bfd_vma
) -1;
845 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_data_got
, &data
);
846 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_fptr_got
, &data
);
847 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_local_got
, &data
);
848 ia64_info
->root
.sgot
->size
= data
.ofs
;
850 if (ia64_info
->root
.dynamic_sections_created
851 && ia64_info
->root
.srelgot
!= NULL
)
853 /* Resize .rela.got. */
854 ia64_info
->root
.srelgot
->size
= 0;
855 if (bfd_link_pic (link_info
)
856 && ia64_info
->self_dtpmod_offset
!= (bfd_vma
) -1)
857 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
858 data
.only_got
= TRUE
;
859 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_dynrel_entries
,
864 if (link_info
->relax_pass
== 0)
866 /* Pass 0 is only needed to relax br. */
867 sec
->skip_relax_pass_0
= skip_relax_pass_0
;
868 sec
->skip_relax_pass_1
= skip_relax_pass_1
;
871 *again
= changed_contents
|| changed_relocs
;
875 if ((unsigned char *) isymbuf
!= symtab_hdr
->contents
)
877 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
879 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
880 free (internal_relocs
);
883 #undef skip_relax_pass_0
884 #undef skip_relax_pass_1
886 /* Return TRUE if NAME is an unwind table section name. */
888 static inline bfd_boolean
889 is_unwind_section_name (bfd
*abfd
, const char *name
)
891 if (elfNN_ia64_hpux_vec (abfd
->xvec
)
892 && !strcmp (name
, ELF_STRING_ia64_unwind_hdr
))
895 return ((CONST_STRNEQ (name
, ELF_STRING_ia64_unwind
)
896 && ! CONST_STRNEQ (name
, ELF_STRING_ia64_unwind_info
))
897 || CONST_STRNEQ (name
, ELF_STRING_ia64_unwind_once
));
900 /* Handle an IA-64 specific section when reading an object file. This
901 is called when bfd_section_from_shdr finds a section with an unknown
905 elfNN_ia64_section_from_shdr (bfd
*abfd
,
906 Elf_Internal_Shdr
*hdr
,
910 /* There ought to be a place to keep ELF backend specific flags, but
911 at the moment there isn't one. We just keep track of the
912 sections by their name, instead. Fortunately, the ABI gives
913 suggested names for all the MIPS specific sections, so we will
914 probably get away with this. */
915 switch (hdr
->sh_type
)
917 case SHT_IA_64_UNWIND
:
918 case SHT_IA_64_HP_OPT_ANOT
:
922 if (strcmp (name
, ELF_STRING_ia64_archext
) != 0)
930 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
936 /* Convert IA-64 specific section flags to bfd internal section flags. */
938 /* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
942 elfNN_ia64_section_flags (const Elf_Internal_Shdr
*hdr
)
944 if (hdr
->sh_flags
& SHF_IA_64_SHORT
)
945 hdr
->bfd_section
->flags
|= SEC_SMALL_DATA
;
950 /* Set the correct type for an IA-64 ELF section. We do this by the
951 section name, which is a hack, but ought to work. */
954 elfNN_ia64_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
959 name
= bfd_section_name (sec
);
961 if (is_unwind_section_name (abfd
, name
))
963 /* We don't have the sections numbered at this point, so sh_info
964 is set later, in elfNN_ia64_final_write_processing. */
965 hdr
->sh_type
= SHT_IA_64_UNWIND
;
966 hdr
->sh_flags
|= SHF_LINK_ORDER
;
968 else if (strcmp (name
, ELF_STRING_ia64_archext
) == 0)
969 hdr
->sh_type
= SHT_IA_64_EXT
;
970 else if (strcmp (name
, ".HP.opt_annot") == 0)
971 hdr
->sh_type
= SHT_IA_64_HP_OPT_ANOT
;
972 else if (strcmp (name
, ".reloc") == 0)
973 /* This is an ugly, but unfortunately necessary hack that is
974 needed when producing EFI binaries on IA-64. It tells
975 elf.c:elf_fake_sections() not to consider ".reloc" as a section
976 containing ELF relocation info. We need this hack in order to
977 be able to generate ELF binaries that can be translated into
978 EFI applications (which are essentially COFF objects). Those
979 files contain a COFF ".reloc" section inside an ELFNN object,
980 which would normally cause BFD to segfault because it would
981 attempt to interpret this section as containing relocation
982 entries for section "oc". With this hack enabled, ".reloc"
983 will be treated as a normal data section, which will avoid the
984 segfault. However, you won't be able to create an ELFNN binary
985 with a section named "oc" that needs relocations, but that's
986 the kind of ugly side-effects you get when detecting section
987 types based on their names... In practice, this limitation is
989 hdr
->sh_type
= SHT_PROGBITS
;
991 if (sec
->flags
& SEC_SMALL_DATA
)
992 hdr
->sh_flags
|= SHF_IA_64_SHORT
;
994 /* Some HP linkers look for the SHF_IA_64_HP_TLS flag instead of SHF_TLS. */
996 if (elfNN_ia64_hpux_vec (abfd
->xvec
) && (sec
->flags
& SHF_TLS
))
997 hdr
->sh_flags
|= SHF_IA_64_HP_TLS
;
1002 /* The final processing done just before writing out an IA-64 ELF
1006 elfNN_ia64_final_write_processing (bfd
*abfd
)
1008 Elf_Internal_Shdr
*hdr
;
1011 for (s
= abfd
->sections
; s
; s
= s
->next
)
1013 hdr
= &elf_section_data (s
)->this_hdr
;
1014 switch (hdr
->sh_type
)
1016 case SHT_IA_64_UNWIND
:
1017 /* The IA-64 processor-specific ABI requires setting sh_link
1018 to the unwind section, whereas HP-UX requires sh_info to
1019 do so. For maximum compatibility, we'll set both for
1021 hdr
->sh_info
= hdr
->sh_link
;
1026 if (! elf_flags_init (abfd
))
1028 unsigned long flags
= 0;
1030 if (abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
)
1031 flags
|= EF_IA_64_BE
;
1032 if (bfd_get_mach (abfd
) == bfd_mach_ia64_elf64
)
1033 flags
|= EF_IA_64_ABI64
;
1035 elf_elfheader(abfd
)->e_flags
= flags
;
1036 elf_flags_init (abfd
) = TRUE
;
1038 return _bfd_elf_final_write_processing (abfd
);
1041 /* Hook called by the linker routine which adds symbols from an object
1042 file. We use it to put .comm items in .sbss, and not .bss. */
1045 elfNN_ia64_add_symbol_hook (bfd
*abfd
,
1046 struct bfd_link_info
*info
,
1047 Elf_Internal_Sym
*sym
,
1048 const char **namep ATTRIBUTE_UNUSED
,
1049 flagword
*flagsp ATTRIBUTE_UNUSED
,
1053 if (sym
->st_shndx
== SHN_COMMON
1054 && !bfd_link_relocatable (info
)
1055 && sym
->st_size
<= elf_gp_size (abfd
))
1057 /* Common symbols less than or equal to -G nn bytes are
1058 automatically put into .sbss. */
1060 asection
*scomm
= bfd_get_section_by_name (abfd
, ".scommon");
1064 scomm
= bfd_make_section_with_flags (abfd
, ".scommon",
1067 | SEC_LINKER_CREATED
));
1073 *valp
= sym
->st_size
;
1079 /* Return the number of additional phdrs we will need. */
1082 elfNN_ia64_additional_program_headers (bfd
*abfd
,
1083 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1088 /* See if we need a PT_IA_64_ARCHEXT segment. */
1089 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_archext
);
1090 if (s
&& (s
->flags
& SEC_LOAD
))
1093 /* Count how many PT_IA_64_UNWIND segments we need. */
1094 for (s
= abfd
->sections
; s
; s
= s
->next
)
1095 if (is_unwind_section_name (abfd
, s
->name
) && (s
->flags
& SEC_LOAD
))
1102 elfNN_ia64_modify_segment_map (bfd
*abfd
,
1103 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1105 struct elf_segment_map
*m
, **pm
;
1106 Elf_Internal_Shdr
*hdr
;
1109 /* If we need a PT_IA_64_ARCHEXT segment, it must come before
1110 all PT_LOAD segments. */
1111 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_archext
);
1112 if (s
&& (s
->flags
& SEC_LOAD
))
1114 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
1115 if (m
->p_type
== PT_IA_64_ARCHEXT
)
1119 m
= ((struct elf_segment_map
*)
1120 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *m
));
1124 m
->p_type
= PT_IA_64_ARCHEXT
;
1128 /* We want to put it after the PHDR and INTERP segments. */
1129 pm
= &elf_seg_map (abfd
);
1131 && ((*pm
)->p_type
== PT_PHDR
1132 || (*pm
)->p_type
== PT_INTERP
))
1140 /* Install PT_IA_64_UNWIND segments, if needed. */
1141 for (s
= abfd
->sections
; s
; s
= s
->next
)
1143 hdr
= &elf_section_data (s
)->this_hdr
;
1144 if (hdr
->sh_type
!= SHT_IA_64_UNWIND
)
1147 if (s
&& (s
->flags
& SEC_LOAD
))
1149 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
1150 if (m
->p_type
== PT_IA_64_UNWIND
)
1154 /* Look through all sections in the unwind segment
1155 for a match since there may be multiple sections
1157 for (i
= m
->count
- 1; i
>= 0; --i
)
1158 if (m
->sections
[i
] == s
)
1167 m
= ((struct elf_segment_map
*)
1168 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *m
));
1172 m
->p_type
= PT_IA_64_UNWIND
;
1177 /* We want to put it last. */
1178 pm
= &elf_seg_map (abfd
);
1189 /* Turn on PF_IA_64_NORECOV if needed. This involves traversing all of
1190 the input sections for each output section in the segment and testing
1191 for SHF_IA_64_NORECOV on each. */
1194 elfNN_ia64_modify_headers (bfd
*abfd
, struct bfd_link_info
*info
)
1196 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
1197 struct elf_segment_map
*m
;
1198 Elf_Internal_Phdr
*p
;
1200 for (p
= tdata
->phdr
, m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
, p
++)
1201 if (m
->p_type
== PT_LOAD
)
1204 for (i
= m
->count
- 1; i
>= 0; --i
)
1206 struct bfd_link_order
*order
= m
->sections
[i
]->map_head
.link_order
;
1208 while (order
!= NULL
)
1210 if (order
->type
== bfd_indirect_link_order
)
1212 asection
*is
= order
->u
.indirect
.section
;
1213 bfd_vma flags
= elf_section_data(is
)->this_hdr
.sh_flags
;
1214 if (flags
& SHF_IA_64_NORECOV
)
1216 p
->p_flags
|= PF_IA_64_NORECOV
;
1220 order
= order
->next
;
1226 return _bfd_elf_modify_headers (abfd
, info
);
1229 /* According to the Tahoe assembler spec, all labels starting with a
1233 elfNN_ia64_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
1236 return name
[0] == '.';
1239 /* Should we do dynamic things to this symbol? */
1242 elfNN_ia64_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
1243 struct bfd_link_info
*info
, int r_type
)
1245 bfd_boolean ignore_protected
1246 = ((r_type
& 0xf8) == 0x40 /* FPTR relocs */
1247 || (r_type
& 0xf8) == 0x50); /* LTOFF_FPTR relocs */
1249 return _bfd_elf_dynamic_symbol_p (h
, info
, ignore_protected
);
1252 static struct bfd_hash_entry
*
1253 elfNN_ia64_new_elf_hash_entry (struct bfd_hash_entry
*entry
,
1254 struct bfd_hash_table
*table
,
1257 struct elfNN_ia64_link_hash_entry
*ret
;
1258 ret
= (struct elfNN_ia64_link_hash_entry
*) entry
;
1260 /* Allocate the structure if it has not already been allocated by a
1263 ret
= bfd_hash_allocate (table
, sizeof (*ret
));
1268 /* Call the allocation method of the superclass. */
1269 ret
= ((struct elfNN_ia64_link_hash_entry
*)
1270 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
1275 ret
->sorted_count
= 0;
1277 return (struct bfd_hash_entry
*) ret
;
1281 elfNN_ia64_hash_copy_indirect (struct bfd_link_info
*info
,
1282 struct elf_link_hash_entry
*xdir
,
1283 struct elf_link_hash_entry
*xind
)
1285 struct elfNN_ia64_link_hash_entry
*dir
, *ind
;
1287 dir
= (struct elfNN_ia64_link_hash_entry
*) xdir
;
1288 ind
= (struct elfNN_ia64_link_hash_entry
*) xind
;
1290 /* Copy down any references that we may have already seen to the
1291 symbol which just became indirect. */
1293 if (dir
->root
.versioned
!= versioned_hidden
)
1294 dir
->root
.ref_dynamic
|= ind
->root
.ref_dynamic
;
1295 dir
->root
.ref_regular
|= ind
->root
.ref_regular
;
1296 dir
->root
.ref_regular_nonweak
|= ind
->root
.ref_regular_nonweak
;
1297 dir
->root
.needs_plt
|= ind
->root
.needs_plt
;
1299 if (ind
->root
.root
.type
!= bfd_link_hash_indirect
)
1302 /* Copy over the got and plt data. This would have been done
1305 if (ind
->info
!= NULL
)
1307 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1312 dir
->info
= ind
->info
;
1313 dir
->count
= ind
->count
;
1314 dir
->sorted_count
= ind
->sorted_count
;
1315 dir
->size
= ind
->size
;
1319 ind
->sorted_count
= 0;
1322 /* Fix up the dyn_sym_info pointers to the global symbol. */
1323 for (count
= dir
->count
, dyn_i
= dir
->info
;
1326 dyn_i
->h
= &dir
->root
;
1329 /* Copy over the dynindx. */
1331 if (ind
->root
.dynindx
!= -1)
1333 if (dir
->root
.dynindx
!= -1)
1334 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1335 dir
->root
.dynstr_index
);
1336 dir
->root
.dynindx
= ind
->root
.dynindx
;
1337 dir
->root
.dynstr_index
= ind
->root
.dynstr_index
;
1338 ind
->root
.dynindx
= -1;
1339 ind
->root
.dynstr_index
= 0;
1344 elfNN_ia64_hash_hide_symbol (struct bfd_link_info
*info
,
1345 struct elf_link_hash_entry
*xh
,
1346 bfd_boolean force_local
)
1348 struct elfNN_ia64_link_hash_entry
*h
;
1349 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1352 h
= (struct elfNN_ia64_link_hash_entry
*)xh
;
1354 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
1356 for (count
= h
->count
, dyn_i
= h
->info
;
1360 dyn_i
->want_plt2
= 0;
1361 dyn_i
->want_plt
= 0;
1365 /* Compute a hash of a local hash entry. */
1368 elfNN_ia64_local_htab_hash (const void *ptr
)
1370 struct elfNN_ia64_local_hash_entry
*entry
1371 = (struct elfNN_ia64_local_hash_entry
*) ptr
;
1373 return ELF_LOCAL_SYMBOL_HASH (entry
->id
, entry
->r_sym
);
1376 /* Compare local hash entries. */
1379 elfNN_ia64_local_htab_eq (const void *ptr1
, const void *ptr2
)
1381 struct elfNN_ia64_local_hash_entry
*entry1
1382 = (struct elfNN_ia64_local_hash_entry
*) ptr1
;
1383 struct elfNN_ia64_local_hash_entry
*entry2
1384 = (struct elfNN_ia64_local_hash_entry
*) ptr2
;
1386 return entry1
->id
== entry2
->id
&& entry1
->r_sym
== entry2
->r_sym
;
1389 /* Free the global elfNN_ia64_dyn_sym_info array. */
1392 elfNN_ia64_global_dyn_info_free (void **xentry
,
1393 void * unused ATTRIBUTE_UNUSED
)
1395 struct elfNN_ia64_link_hash_entry
*entry
1396 = (struct elfNN_ia64_link_hash_entry
*) xentry
;
1401 entry
->sorted_count
= 0;
1407 /* Free the local elfNN_ia64_dyn_sym_info array. */
1410 elfNN_ia64_local_dyn_info_free (void **slot
,
1411 void * unused ATTRIBUTE_UNUSED
)
1413 struct elfNN_ia64_local_hash_entry
*entry
1414 = (struct elfNN_ia64_local_hash_entry
*) *slot
;
1419 entry
->sorted_count
= 0;
1425 /* Destroy IA-64 linker hash table. */
1428 elfNN_ia64_link_hash_table_free (bfd
*obfd
)
1430 struct elfNN_ia64_link_hash_table
*ia64_info
1431 = (struct elfNN_ia64_link_hash_table
*) obfd
->link
.hash
;
1432 if (ia64_info
->loc_hash_table
)
1434 htab_traverse (ia64_info
->loc_hash_table
,
1435 elfNN_ia64_local_dyn_info_free
, NULL
);
1436 htab_delete (ia64_info
->loc_hash_table
);
1438 if (ia64_info
->loc_hash_memory
)
1439 objalloc_free ((struct objalloc
*) ia64_info
->loc_hash_memory
);
1440 elf_link_hash_traverse (&ia64_info
->root
,
1441 elfNN_ia64_global_dyn_info_free
, NULL
);
1442 _bfd_elf_link_hash_table_free (obfd
);
1445 /* Create the derived linker hash table. The IA-64 ELF port uses this
1446 derived hash table to keep information specific to the IA-64 ElF
1447 linker (without using static variables). */
1449 static struct bfd_link_hash_table
*
1450 elfNN_ia64_hash_table_create (bfd
*abfd
)
1452 struct elfNN_ia64_link_hash_table
*ret
;
1454 ret
= bfd_zmalloc ((bfd_size_type
) sizeof (*ret
));
1458 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
1459 elfNN_ia64_new_elf_hash_entry
,
1460 sizeof (struct elfNN_ia64_link_hash_entry
),
1467 ret
->loc_hash_table
= htab_try_create (1024, elfNN_ia64_local_htab_hash
,
1468 elfNN_ia64_local_htab_eq
, NULL
);
1469 ret
->loc_hash_memory
= objalloc_create ();
1470 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1472 elfNN_ia64_link_hash_table_free (abfd
);
1475 ret
->root
.root
.hash_table_free
= elfNN_ia64_link_hash_table_free
;
1477 return &ret
->root
.root
;
1480 /* Traverse both local and global hash tables. */
1482 struct elfNN_ia64_dyn_sym_traverse_data
1484 bfd_boolean (*func
) (struct elfNN_ia64_dyn_sym_info
*, void *);
1489 elfNN_ia64_global_dyn_sym_thunk (struct bfd_hash_entry
*xentry
,
1492 struct elfNN_ia64_link_hash_entry
*entry
1493 = (struct elfNN_ia64_link_hash_entry
*) xentry
;
1494 struct elfNN_ia64_dyn_sym_traverse_data
*data
1495 = (struct elfNN_ia64_dyn_sym_traverse_data
*) xdata
;
1496 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1499 for (count
= entry
->count
, dyn_i
= entry
->info
;
1502 if (! (*data
->func
) (dyn_i
, data
->data
))
1508 elfNN_ia64_local_dyn_sym_thunk (void **slot
, void * xdata
)
1510 struct elfNN_ia64_local_hash_entry
*entry
1511 = (struct elfNN_ia64_local_hash_entry
*) *slot
;
1512 struct elfNN_ia64_dyn_sym_traverse_data
*data
1513 = (struct elfNN_ia64_dyn_sym_traverse_data
*) xdata
;
1514 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1517 for (count
= entry
->count
, dyn_i
= entry
->info
;
1520 if (! (*data
->func
) (dyn_i
, data
->data
))
1526 elfNN_ia64_dyn_sym_traverse (struct elfNN_ia64_link_hash_table
*ia64_info
,
1527 bfd_boolean (*func
) (struct elfNN_ia64_dyn_sym_info
*, void *),
1530 struct elfNN_ia64_dyn_sym_traverse_data xdata
;
1535 elf_link_hash_traverse (&ia64_info
->root
,
1536 elfNN_ia64_global_dyn_sym_thunk
, &xdata
);
1537 htab_traverse (ia64_info
->loc_hash_table
,
1538 elfNN_ia64_local_dyn_sym_thunk
, &xdata
);
1542 elfNN_ia64_create_dynamic_sections (bfd
*abfd
,
1543 struct bfd_link_info
*info
)
1545 struct elfNN_ia64_link_hash_table
*ia64_info
;
1548 if (! _bfd_elf_create_dynamic_sections (abfd
, info
))
1551 ia64_info
= elfNN_ia64_hash_table (info
);
1552 if (ia64_info
== NULL
)
1556 flagword flags
= bfd_section_flags (ia64_info
->root
.sgot
);
1557 bfd_set_section_flags (ia64_info
->root
.sgot
, SEC_SMALL_DATA
| flags
);
1558 /* The .got section is always aligned at 8 bytes. */
1559 if (!bfd_set_section_alignment (ia64_info
->root
.sgot
, 3))
1563 if (!get_pltoff (abfd
, info
, ia64_info
))
1566 s
= bfd_make_section_anyway_with_flags (abfd
, ".rela.IA_64.pltoff",
1567 (SEC_ALLOC
| SEC_LOAD
1570 | SEC_LINKER_CREATED
1573 || !bfd_set_section_alignment (s
, LOG_SECTION_ALIGN
))
1575 ia64_info
->rel_pltoff_sec
= s
;
1580 /* Find and/or create a hash entry for local symbol. */
1581 static struct elfNN_ia64_local_hash_entry
*
1582 get_local_sym_hash (struct elfNN_ia64_link_hash_table
*ia64_info
,
1583 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
1586 struct elfNN_ia64_local_hash_entry e
, *ret
;
1587 asection
*sec
= abfd
->sections
;
1588 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
1589 ELFNN_R_SYM (rel
->r_info
));
1593 e
.r_sym
= ELFNN_R_SYM (rel
->r_info
);
1594 slot
= htab_find_slot_with_hash (ia64_info
->loc_hash_table
, &e
, h
,
1595 create
? INSERT
: NO_INSERT
);
1601 return (struct elfNN_ia64_local_hash_entry
*) *slot
;
1603 ret
= (struct elfNN_ia64_local_hash_entry
*)
1604 objalloc_alloc ((struct objalloc
*) ia64_info
->loc_hash_memory
,
1605 sizeof (struct elfNN_ia64_local_hash_entry
));
1608 memset (ret
, 0, sizeof (*ret
));
1610 ret
->r_sym
= ELFNN_R_SYM (rel
->r_info
);
1616 /* Used to sort elfNN_ia64_dyn_sym_info array. */
1619 addend_compare (const void *xp
, const void *yp
)
1621 const struct elfNN_ia64_dyn_sym_info
*x
1622 = (const struct elfNN_ia64_dyn_sym_info
*) xp
;
1623 const struct elfNN_ia64_dyn_sym_info
*y
1624 = (const struct elfNN_ia64_dyn_sym_info
*) yp
;
1626 return x
->addend
< y
->addend
? -1 : x
->addend
> y
->addend
? 1 : 0;
1629 /* Sort elfNN_ia64_dyn_sym_info array and remove duplicates. */
1632 sort_dyn_sym_info (struct elfNN_ia64_dyn_sym_info
*info
,
1635 bfd_vma curr
, prev
, got_offset
;
1636 unsigned int i
, kept
, dupes
, diff
, dest
, src
, len
;
1638 qsort (info
, count
, sizeof (*info
), addend_compare
);
1640 /* Find the first duplicate. */
1641 prev
= info
[0].addend
;
1642 got_offset
= info
[0].got_offset
;
1643 for (i
= 1; i
< count
; i
++)
1645 curr
= info
[i
].addend
;
1648 /* For duplicates, make sure that GOT_OFFSET is valid. */
1649 if (got_offset
== (bfd_vma
) -1)
1650 got_offset
= info
[i
].got_offset
;
1653 got_offset
= info
[i
].got_offset
;
1657 /* We may move a block of elements to here. */
1660 /* Remove duplicates. */
1665 /* For duplicates, make sure that the kept one has a valid
1668 if (got_offset
!= (bfd_vma
) -1)
1669 info
[kept
].got_offset
= got_offset
;
1671 curr
= info
[i
].addend
;
1672 got_offset
= info
[i
].got_offset
;
1674 /* Move a block of elements whose first one is different from
1678 for (src
= i
+ 1; src
< count
; src
++)
1680 if (info
[src
].addend
!= curr
)
1682 /* For duplicates, make sure that GOT_OFFSET is
1684 if (got_offset
== (bfd_vma
) -1)
1685 got_offset
= info
[src
].got_offset
;
1688 /* Make sure that the kept one has a valid got_offset. */
1689 if (got_offset
!= (bfd_vma
) -1)
1690 info
[kept
].got_offset
= got_offset
;
1698 /* Find the next duplicate. SRC will be kept. */
1699 prev
= info
[src
].addend
;
1700 got_offset
= info
[src
].got_offset
;
1701 for (dupes
= src
+ 1; dupes
< count
; dupes
++)
1703 curr
= info
[dupes
].addend
;
1706 /* Make sure that got_offset is valid. */
1707 if (got_offset
== (bfd_vma
) -1)
1708 got_offset
= info
[dupes
].got_offset
;
1710 /* For duplicates, make sure that the kept one has
1711 a valid got_offset. */
1712 if (got_offset
!= (bfd_vma
) -1)
1713 info
[dupes
- 1].got_offset
= got_offset
;
1716 got_offset
= info
[dupes
].got_offset
;
1720 /* How much to move. */
1724 if (len
== 1 && dupes
< count
)
1726 /* If we only move 1 element, we combine it with the next
1727 one. There must be at least a duplicate. Find the
1728 next different one. */
1729 for (diff
= dupes
+ 1, src
++; diff
< count
; diff
++, src
++)
1731 if (info
[diff
].addend
!= curr
)
1733 /* Make sure that got_offset is valid. */
1734 if (got_offset
== (bfd_vma
) -1)
1735 got_offset
= info
[diff
].got_offset
;
1738 /* Makre sure that the last duplicated one has an valid
1740 BFD_ASSERT (curr
== prev
);
1741 if (got_offset
!= (bfd_vma
) -1)
1742 info
[diff
- 1].got_offset
= got_offset
;
1746 /* Find the next duplicate. Track the current valid
1748 prev
= info
[diff
].addend
;
1749 got_offset
= info
[diff
].got_offset
;
1750 for (dupes
= diff
+ 1; dupes
< count
; dupes
++)
1752 curr
= info
[dupes
].addend
;
1755 /* For duplicates, make sure that GOT_OFFSET
1757 if (got_offset
== (bfd_vma
) -1)
1758 got_offset
= info
[dupes
].got_offset
;
1761 got_offset
= info
[dupes
].got_offset
;
1766 len
= diff
- src
+ 1;
1771 memmove (&info
[dest
], &info
[src
], len
* sizeof (*info
));
1780 /* When we get here, either there is no duplicate at all or
1781 the only duplicate is the last element. */
1784 /* If the last element is a duplicate, make sure that the
1785 kept one has a valid got_offset. We also update count. */
1786 if (got_offset
!= (bfd_vma
) -1)
1787 info
[dest
- 1].got_offset
= got_offset
;
1795 /* Find and/or create a descriptor for dynamic symbol info. This will
1796 vary based on global or local symbol, and the addend to the reloc.
1798 We don't sort when inserting. Also, we sort and eliminate
1799 duplicates if there is an unsorted section. Typically, this will
1800 only happen once, because we do all insertions before lookups. We
1801 then use bsearch to do a lookup. This also allows lookups to be
1802 fast. So we have fast insertion (O(log N) due to duplicate check),
1803 fast lookup (O(log N)) and one sort (O(N log N) expected time).
1804 Previously, all lookups were O(N) because of the use of the linked
1805 list and also all insertions were O(N) because of the check for
1806 duplicates. There are some complications here because the array
1807 size grows occasionally, which may add an O(N) factor, but this
1808 should be rare. Also, we free the excess array allocation, which
1809 requires a copy which is O(N), but this only happens once. */
1811 static struct elfNN_ia64_dyn_sym_info
*
1812 get_dyn_sym_info (struct elfNN_ia64_link_hash_table
*ia64_info
,
1813 struct elf_link_hash_entry
*h
, bfd
*abfd
,
1814 const Elf_Internal_Rela
*rel
, bfd_boolean create
)
1816 struct elfNN_ia64_dyn_sym_info
**info_p
, *info
, *dyn_i
, key
;
1817 unsigned int *count_p
, *sorted_count_p
, *size_p
;
1818 unsigned int count
, sorted_count
, size
;
1819 bfd_vma addend
= rel
? rel
->r_addend
: 0;
1824 struct elfNN_ia64_link_hash_entry
*global_h
;
1826 global_h
= (struct elfNN_ia64_link_hash_entry
*) h
;
1827 info_p
= &global_h
->info
;
1828 count_p
= &global_h
->count
;
1829 sorted_count_p
= &global_h
->sorted_count
;
1830 size_p
= &global_h
->size
;
1834 struct elfNN_ia64_local_hash_entry
*loc_h
;
1836 loc_h
= get_local_sym_hash (ia64_info
, abfd
, rel
, create
);
1839 BFD_ASSERT (!create
);
1843 info_p
= &loc_h
->info
;
1844 count_p
= &loc_h
->count
;
1845 sorted_count_p
= &loc_h
->sorted_count
;
1846 size_p
= &loc_h
->size
;
1850 sorted_count
= *sorted_count_p
;
1855 /* When we create the array, we don't check for duplicates,
1856 except in the previously sorted section if one exists, and
1857 against the last inserted entry. This allows insertions to
1863 /* Try bsearch first on the sorted section. */
1864 key
.addend
= addend
;
1865 dyn_i
= bsearch (&key
, info
, sorted_count
,
1866 sizeof (*info
), addend_compare
);
1874 /* Do a quick check for the last inserted entry. */
1875 dyn_i
= info
+ count
- 1;
1876 if (dyn_i
->addend
== addend
)
1884 /* It is the very first element. We create the array of size
1887 amt
= size
* sizeof (*info
);
1888 info
= bfd_malloc (amt
);
1890 else if (size
<= count
)
1892 /* We double the array size every time when we reach the
1895 amt
= size
* sizeof (*info
);
1896 info
= bfd_realloc (info
, amt
);
1907 /* Append the new one to the array. */
1908 dyn_i
= info
+ count
;
1909 memset (dyn_i
, 0, sizeof (*dyn_i
));
1910 dyn_i
->got_offset
= (bfd_vma
) -1;
1911 dyn_i
->addend
= addend
;
1913 /* We increment count only since the new ones are unsorted and
1914 may have duplicate. */
1919 /* It is a lookup without insertion. Sort array if part of the
1920 array isn't sorted. */
1921 if (count
!= sorted_count
)
1923 count
= sort_dyn_sym_info (info
, count
);
1925 *sorted_count_p
= count
;
1928 /* Free unused memory. */
1931 amt
= count
* sizeof (*info
);
1932 info
= bfd_malloc (amt
);
1935 memcpy (info
, *info_p
, amt
);
1942 key
.addend
= addend
;
1943 dyn_i
= bsearch (&key
, info
, count
,
1944 sizeof (*info
), addend_compare
);
1951 get_got (bfd
*abfd
, struct bfd_link_info
*info
,
1952 struct elfNN_ia64_link_hash_table
*ia64_info
)
1957 got
= ia64_info
->root
.sgot
;
1962 dynobj
= ia64_info
->root
.dynobj
;
1964 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1965 if (!_bfd_elf_create_got_section (dynobj
, info
))
1968 got
= ia64_info
->root
.sgot
;
1970 /* The .got section is always aligned at 8 bytes. */
1971 if (!bfd_set_section_alignment (got
, 3))
1974 flags
= bfd_section_flags (got
);
1975 if (!bfd_set_section_flags (got
, SEC_SMALL_DATA
| flags
))
1982 /* Create function descriptor section (.opd). This section is called .opd
1983 because it contains "official procedure descriptors". The "official"
1984 refers to the fact that these descriptors are used when taking the address
1985 of a procedure, thus ensuring a unique address for each procedure. */
1988 get_fptr (bfd
*abfd
, struct bfd_link_info
*info
,
1989 struct elfNN_ia64_link_hash_table
*ia64_info
)
1994 fptr
= ia64_info
->fptr_sec
;
1997 dynobj
= ia64_info
->root
.dynobj
;
1999 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2001 fptr
= bfd_make_section_anyway_with_flags (dynobj
, ".opd",
2006 | (bfd_link_pie (info
)
2008 | SEC_LINKER_CREATED
));
2010 || !bfd_set_section_alignment (fptr
, 4))
2016 ia64_info
->fptr_sec
= fptr
;
2018 if (bfd_link_pie (info
))
2021 fptr_rel
= bfd_make_section_anyway_with_flags (dynobj
, ".rela.opd",
2022 (SEC_ALLOC
| SEC_LOAD
2025 | SEC_LINKER_CREATED
2027 if (fptr_rel
== NULL
2028 || !bfd_set_section_alignment (fptr_rel
, LOG_SECTION_ALIGN
))
2034 ia64_info
->rel_fptr_sec
= fptr_rel
;
2042 get_pltoff (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2043 struct elfNN_ia64_link_hash_table
*ia64_info
)
2048 pltoff
= ia64_info
->pltoff_sec
;
2051 dynobj
= ia64_info
->root
.dynobj
;
2053 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2055 pltoff
= bfd_make_section_anyway_with_flags (dynobj
,
2056 ELF_STRING_ia64_pltoff
,
2062 | SEC_LINKER_CREATED
));
2064 || !bfd_set_section_alignment (pltoff
, 4))
2070 ia64_info
->pltoff_sec
= pltoff
;
2077 get_reloc_section (bfd
*abfd
,
2078 struct elfNN_ia64_link_hash_table
*ia64_info
,
2079 asection
*sec
, bfd_boolean create
)
2081 const char *srel_name
;
2085 srel_name
= (bfd_elf_string_from_elf_section
2086 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
2087 _bfd_elf_single_rel_hdr (sec
)->sh_name
));
2088 if (srel_name
== NULL
)
2091 dynobj
= ia64_info
->root
.dynobj
;
2093 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2095 srel
= bfd_get_linker_section (dynobj
, srel_name
);
2096 if (srel
== NULL
&& create
)
2098 srel
= bfd_make_section_anyway_with_flags (dynobj
, srel_name
,
2099 (SEC_ALLOC
| SEC_LOAD
2102 | SEC_LINKER_CREATED
2105 || !bfd_set_section_alignment (srel
, LOG_SECTION_ALIGN
))
2113 count_dyn_reloc (bfd
*abfd
, struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2114 asection
*srel
, int type
, bfd_boolean reltext
)
2116 struct elfNN_ia64_dyn_reloc_entry
*rent
;
2118 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2119 if (rent
->srel
== srel
&& rent
->type
== type
)
2124 rent
= ((struct elfNN_ia64_dyn_reloc_entry
*)
2125 bfd_alloc (abfd
, (bfd_size_type
) sizeof (*rent
)));
2129 rent
->next
= dyn_i
->reloc_entries
;
2133 dyn_i
->reloc_entries
= rent
;
2135 rent
->reltext
= reltext
;
2142 elfNN_ia64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
2144 const Elf_Internal_Rela
*relocs
)
2146 struct elfNN_ia64_link_hash_table
*ia64_info
;
2147 const Elf_Internal_Rela
*relend
;
2148 Elf_Internal_Shdr
*symtab_hdr
;
2149 const Elf_Internal_Rela
*rel
;
2150 asection
*got
, *fptr
, *srel
, *pltoff
;
2159 NEED_LTOFF_FPTR
= 128,
2165 struct elf_link_hash_entry
*h
;
2166 unsigned long r_symndx
;
2167 bfd_boolean maybe_dynamic
;
2169 if (bfd_link_relocatable (info
))
2172 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2173 ia64_info
= elfNN_ia64_hash_table (info
);
2174 if (ia64_info
== NULL
)
2177 got
= fptr
= srel
= pltoff
= NULL
;
2179 relend
= relocs
+ sec
->reloc_count
;
2181 /* We scan relocations first to create dynamic relocation arrays. We
2182 modified get_dyn_sym_info to allow fast insertion and support fast
2183 lookup in the next loop. */
2184 for (rel
= relocs
; rel
< relend
; ++rel
)
2186 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
2187 if (r_symndx
>= symtab_hdr
->sh_info
)
2189 long indx
= r_symndx
- symtab_hdr
->sh_info
;
2190 h
= elf_sym_hashes (abfd
)[indx
];
2191 while (h
->root
.type
== bfd_link_hash_indirect
2192 || h
->root
.type
== bfd_link_hash_warning
)
2193 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2198 if (h
&& UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
2201 /* We can only get preliminary data on whether a symbol is
2202 locally or externally defined, as not all of the input files
2203 have yet been processed. Do something with what we know, as
2204 this may help reduce memory usage and processing time later. */
2205 maybe_dynamic
= (h
&& ((!bfd_link_executable (info
)
2206 && (!SYMBOLIC_BIND (info
, h
)
2207 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
2209 || h
->root
.type
== bfd_link_hash_defweak
));
2212 switch (ELFNN_R_TYPE (rel
->r_info
))
2214 case R_IA64_TPREL64MSB
:
2215 case R_IA64_TPREL64LSB
:
2216 if (bfd_link_pic (info
) || maybe_dynamic
)
2217 need_entry
= NEED_DYNREL
;
2220 case R_IA64_LTOFF_TPREL22
:
2221 need_entry
= NEED_TPREL
;
2222 if (bfd_link_pic (info
))
2223 info
->flags
|= DF_STATIC_TLS
;
2226 case R_IA64_DTPREL32MSB
:
2227 case R_IA64_DTPREL32LSB
:
2228 case R_IA64_DTPREL64MSB
:
2229 case R_IA64_DTPREL64LSB
:
2230 if (bfd_link_pic (info
) || maybe_dynamic
)
2231 need_entry
= NEED_DYNREL
;
2234 case R_IA64_LTOFF_DTPREL22
:
2235 need_entry
= NEED_DTPREL
;
2238 case R_IA64_DTPMOD64MSB
:
2239 case R_IA64_DTPMOD64LSB
:
2240 if (bfd_link_pic (info
) || maybe_dynamic
)
2241 need_entry
= NEED_DYNREL
;
2244 case R_IA64_LTOFF_DTPMOD22
:
2245 need_entry
= NEED_DTPMOD
;
2248 case R_IA64_LTOFF_FPTR22
:
2249 case R_IA64_LTOFF_FPTR64I
:
2250 case R_IA64_LTOFF_FPTR32MSB
:
2251 case R_IA64_LTOFF_FPTR32LSB
:
2252 case R_IA64_LTOFF_FPTR64MSB
:
2253 case R_IA64_LTOFF_FPTR64LSB
:
2254 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
2257 case R_IA64_FPTR64I
:
2258 case R_IA64_FPTR32MSB
:
2259 case R_IA64_FPTR32LSB
:
2260 case R_IA64_FPTR64MSB
:
2261 case R_IA64_FPTR64LSB
:
2262 if (bfd_link_pic (info
) || h
)
2263 need_entry
= NEED_FPTR
| NEED_DYNREL
;
2265 need_entry
= NEED_FPTR
;
2268 case R_IA64_LTOFF22
:
2269 case R_IA64_LTOFF64I
:
2270 need_entry
= NEED_GOT
;
2273 case R_IA64_LTOFF22X
:
2274 need_entry
= NEED_GOTX
;
2277 case R_IA64_PLTOFF22
:
2278 case R_IA64_PLTOFF64I
:
2279 case R_IA64_PLTOFF64MSB
:
2280 case R_IA64_PLTOFF64LSB
:
2281 need_entry
= NEED_PLTOFF
;
2285 need_entry
|= NEED_MIN_PLT
;
2289 (*info
->callbacks
->warning
)
2290 (info
, _("@pltoff reloc against local symbol"), 0,
2291 abfd
, 0, (bfd_vma
) 0);
2295 case R_IA64_PCREL21B
:
2296 case R_IA64_PCREL60B
:
2297 /* Depending on where this symbol is defined, we may or may not
2298 need a full plt entry. Only skip if we know we'll not need
2299 the entry -- static or symbolic, and the symbol definition
2300 has already been seen. */
2301 if (maybe_dynamic
&& rel
->r_addend
== 0)
2302 need_entry
= NEED_FULL_PLT
;
2308 case R_IA64_DIR32MSB
:
2309 case R_IA64_DIR32LSB
:
2310 case R_IA64_DIR64MSB
:
2311 case R_IA64_DIR64LSB
:
2312 /* Shared objects will always need at least a REL relocation. */
2313 if (bfd_link_pic (info
) || maybe_dynamic
)
2314 need_entry
= NEED_DYNREL
;
2317 case R_IA64_IPLTMSB
:
2318 case R_IA64_IPLTLSB
:
2319 /* Shared objects will always need at least a REL relocation. */
2320 if (bfd_link_pic (info
) || maybe_dynamic
)
2321 need_entry
= NEED_DYNREL
;
2324 case R_IA64_PCREL22
:
2325 case R_IA64_PCREL64I
:
2326 case R_IA64_PCREL32MSB
:
2327 case R_IA64_PCREL32LSB
:
2328 case R_IA64_PCREL64MSB
:
2329 case R_IA64_PCREL64LSB
:
2331 need_entry
= NEED_DYNREL
;
2338 if ((need_entry
& NEED_FPTR
) != 0
2341 (*info
->callbacks
->warning
)
2342 (info
, _("non-zero addend in @fptr reloc"), 0,
2343 abfd
, 0, (bfd_vma
) 0);
2346 if (get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, TRUE
) == NULL
)
2350 /* Now, we only do lookup without insertion, which is very fast
2351 with the modified get_dyn_sym_info. */
2352 for (rel
= relocs
; rel
< relend
; ++rel
)
2354 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2355 int dynrel_type
= R_IA64_NONE
;
2357 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
2358 if (r_symndx
>= symtab_hdr
->sh_info
)
2360 /* We're dealing with a global symbol -- find its hash entry
2361 and mark it as being referenced. */
2362 long indx
= r_symndx
- symtab_hdr
->sh_info
;
2363 h
= elf_sym_hashes (abfd
)[indx
];
2364 while (h
->root
.type
== bfd_link_hash_indirect
2365 || h
->root
.type
== bfd_link_hash_warning
)
2366 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2368 /* PR15323, ref flags aren't set for references in the same
2375 if (h
&& UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
2378 /* We can only get preliminary data on whether a symbol is
2379 locally or externally defined, as not all of the input files
2380 have yet been processed. Do something with what we know, as
2381 this may help reduce memory usage and processing time later. */
2382 maybe_dynamic
= (h
&& ((!bfd_link_executable (info
)
2383 && (!SYMBOLIC_BIND (info
, h
)
2384 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
2386 || h
->root
.type
== bfd_link_hash_defweak
));
2389 switch (ELFNN_R_TYPE (rel
->r_info
))
2391 case R_IA64_TPREL64MSB
:
2392 case R_IA64_TPREL64LSB
:
2393 if (bfd_link_pic (info
) || maybe_dynamic
)
2394 need_entry
= NEED_DYNREL
;
2395 dynrel_type
= R_IA64_TPREL64LSB
;
2396 if (bfd_link_pic (info
))
2397 info
->flags
|= DF_STATIC_TLS
;
2400 case R_IA64_LTOFF_TPREL22
:
2401 need_entry
= NEED_TPREL
;
2402 if (bfd_link_pic (info
))
2403 info
->flags
|= DF_STATIC_TLS
;
2406 case R_IA64_DTPREL32MSB
:
2407 case R_IA64_DTPREL32LSB
:
2408 case R_IA64_DTPREL64MSB
:
2409 case R_IA64_DTPREL64LSB
:
2410 if (bfd_link_pic (info
) || maybe_dynamic
)
2411 need_entry
= NEED_DYNREL
;
2412 dynrel_type
= R_IA64_DTPRELNNLSB
;
2415 case R_IA64_LTOFF_DTPREL22
:
2416 need_entry
= NEED_DTPREL
;
2419 case R_IA64_DTPMOD64MSB
:
2420 case R_IA64_DTPMOD64LSB
:
2421 if (bfd_link_pic (info
) || maybe_dynamic
)
2422 need_entry
= NEED_DYNREL
;
2423 dynrel_type
= R_IA64_DTPMOD64LSB
;
2426 case R_IA64_LTOFF_DTPMOD22
:
2427 need_entry
= NEED_DTPMOD
;
2430 case R_IA64_LTOFF_FPTR22
:
2431 case R_IA64_LTOFF_FPTR64I
:
2432 case R_IA64_LTOFF_FPTR32MSB
:
2433 case R_IA64_LTOFF_FPTR32LSB
:
2434 case R_IA64_LTOFF_FPTR64MSB
:
2435 case R_IA64_LTOFF_FPTR64LSB
:
2436 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
2439 case R_IA64_FPTR64I
:
2440 case R_IA64_FPTR32MSB
:
2441 case R_IA64_FPTR32LSB
:
2442 case R_IA64_FPTR64MSB
:
2443 case R_IA64_FPTR64LSB
:
2444 if (bfd_link_pic (info
) || h
)
2445 need_entry
= NEED_FPTR
| NEED_DYNREL
;
2447 need_entry
= NEED_FPTR
;
2448 dynrel_type
= R_IA64_FPTRNNLSB
;
2451 case R_IA64_LTOFF22
:
2452 case R_IA64_LTOFF64I
:
2453 need_entry
= NEED_GOT
;
2456 case R_IA64_LTOFF22X
:
2457 need_entry
= NEED_GOTX
;
2460 case R_IA64_PLTOFF22
:
2461 case R_IA64_PLTOFF64I
:
2462 case R_IA64_PLTOFF64MSB
:
2463 case R_IA64_PLTOFF64LSB
:
2464 need_entry
= NEED_PLTOFF
;
2468 need_entry
|= NEED_MIN_PLT
;
2472 case R_IA64_PCREL21B
:
2473 case R_IA64_PCREL60B
:
2474 /* Depending on where this symbol is defined, we may or may not
2475 need a full plt entry. Only skip if we know we'll not need
2476 the entry -- static or symbolic, and the symbol definition
2477 has already been seen. */
2478 if (maybe_dynamic
&& rel
->r_addend
== 0)
2479 need_entry
= NEED_FULL_PLT
;
2485 case R_IA64_DIR32MSB
:
2486 case R_IA64_DIR32LSB
:
2487 case R_IA64_DIR64MSB
:
2488 case R_IA64_DIR64LSB
:
2489 /* Shared objects will always need at least a REL relocation. */
2490 if (bfd_link_pic (info
) || maybe_dynamic
)
2491 need_entry
= NEED_DYNREL
;
2492 dynrel_type
= R_IA64_DIRNNLSB
;
2495 case R_IA64_IPLTMSB
:
2496 case R_IA64_IPLTLSB
:
2497 /* Shared objects will always need at least a REL relocation. */
2498 if (bfd_link_pic (info
) || maybe_dynamic
)
2499 need_entry
= NEED_DYNREL
;
2500 dynrel_type
= R_IA64_IPLTLSB
;
2503 case R_IA64_PCREL22
:
2504 case R_IA64_PCREL64I
:
2505 case R_IA64_PCREL32MSB
:
2506 case R_IA64_PCREL32LSB
:
2507 case R_IA64_PCREL64MSB
:
2508 case R_IA64_PCREL64LSB
:
2510 need_entry
= NEED_DYNREL
;
2511 dynrel_type
= R_IA64_PCRELNNLSB
;
2518 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, FALSE
);
2520 /* Record whether or not this is a local symbol. */
2523 /* Create what's needed. */
2524 if (need_entry
& (NEED_GOT
| NEED_GOTX
| NEED_TPREL
2525 | NEED_DTPMOD
| NEED_DTPREL
))
2529 got
= get_got (abfd
, info
, ia64_info
);
2533 if (need_entry
& NEED_GOT
)
2534 dyn_i
->want_got
= 1;
2535 if (need_entry
& NEED_GOTX
)
2536 dyn_i
->want_gotx
= 1;
2537 if (need_entry
& NEED_TPREL
)
2538 dyn_i
->want_tprel
= 1;
2539 if (need_entry
& NEED_DTPMOD
)
2540 dyn_i
->want_dtpmod
= 1;
2541 if (need_entry
& NEED_DTPREL
)
2542 dyn_i
->want_dtprel
= 1;
2544 if (need_entry
& NEED_FPTR
)
2548 fptr
= get_fptr (abfd
, info
, ia64_info
);
2553 /* FPTRs for shared libraries are allocated by the dynamic
2554 linker. Make sure this local symbol will appear in the
2555 dynamic symbol table. */
2556 if (!h
&& bfd_link_pic (info
))
2558 if (! (bfd_elf_link_record_local_dynamic_symbol
2559 (info
, abfd
, (long) r_symndx
)))
2563 dyn_i
->want_fptr
= 1;
2565 if (need_entry
& NEED_LTOFF_FPTR
)
2566 dyn_i
->want_ltoff_fptr
= 1;
2567 if (need_entry
& (NEED_MIN_PLT
| NEED_FULL_PLT
))
2569 if (!ia64_info
->root
.dynobj
)
2570 ia64_info
->root
.dynobj
= abfd
;
2572 dyn_i
->want_plt
= 1;
2574 if (need_entry
& NEED_FULL_PLT
)
2575 dyn_i
->want_plt2
= 1;
2576 if (need_entry
& NEED_PLTOFF
)
2578 /* This is needed here, in case @pltoff is used in a non-shared
2582 pltoff
= get_pltoff (abfd
, info
, ia64_info
);
2587 dyn_i
->want_pltoff
= 1;
2589 if ((need_entry
& NEED_DYNREL
) && (sec
->flags
& SEC_ALLOC
))
2593 srel
= get_reloc_section (abfd
, ia64_info
, sec
, TRUE
);
2597 if (!count_dyn_reloc (abfd
, dyn_i
, srel
, dynrel_type
,
2598 (sec
->flags
& SEC_READONLY
) != 0))
2606 /* For cleanliness, and potentially faster dynamic loading, allocate
2607 external GOT entries first. */
2610 allocate_global_data_got (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2613 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2615 if ((dyn_i
->want_got
|| dyn_i
->want_gotx
)
2616 && ! dyn_i
->want_fptr
2617 && elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0))
2619 dyn_i
->got_offset
= x
->ofs
;
2622 if (dyn_i
->want_tprel
)
2624 dyn_i
->tprel_offset
= x
->ofs
;
2627 if (dyn_i
->want_dtpmod
)
2629 if (elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0))
2631 dyn_i
->dtpmod_offset
= x
->ofs
;
2636 struct elfNN_ia64_link_hash_table
*ia64_info
;
2638 ia64_info
= elfNN_ia64_hash_table (x
->info
);
2639 if (ia64_info
== NULL
)
2642 if (ia64_info
->self_dtpmod_offset
== (bfd_vma
) -1)
2644 ia64_info
->self_dtpmod_offset
= x
->ofs
;
2647 dyn_i
->dtpmod_offset
= ia64_info
->self_dtpmod_offset
;
2650 if (dyn_i
->want_dtprel
)
2652 dyn_i
->dtprel_offset
= x
->ofs
;
2658 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
2661 allocate_global_fptr_got (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2664 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2668 && elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, R_IA64_FPTRNNLSB
))
2670 dyn_i
->got_offset
= x
->ofs
;
2676 /* Lastly, allocate all the GOT entries for local data. */
2679 allocate_local_got (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2682 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2684 if ((dyn_i
->want_got
|| dyn_i
->want_gotx
)
2685 && !elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0))
2687 dyn_i
->got_offset
= x
->ofs
;
2693 /* Search for the index of a global symbol in it's defining object file. */
2696 global_sym_index (struct elf_link_hash_entry
*h
)
2698 struct elf_link_hash_entry
**p
;
2701 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
2702 || h
->root
.type
== bfd_link_hash_defweak
);
2704 obj
= h
->root
.u
.def
.section
->owner
;
2705 for (p
= elf_sym_hashes (obj
); *p
!= h
; ++p
)
2708 return p
- elf_sym_hashes (obj
) + elf_tdata (obj
)->symtab_hdr
.sh_info
;
2711 /* Allocate function descriptors. We can do these for every function
2712 in a main executable that is not exported. */
2715 allocate_fptr (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
)
2717 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2719 if (dyn_i
->want_fptr
)
2721 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2724 while (h
->root
.type
== bfd_link_hash_indirect
2725 || h
->root
.type
== bfd_link_hash_warning
)
2726 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2728 if (!bfd_link_executable (x
->info
)
2730 || (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2731 && !UNDEFWEAK_NO_DYNAMIC_RELOC (x
->info
, h
))
2732 || (h
->root
.type
!= bfd_link_hash_undefweak
2733 && h
->root
.type
!= bfd_link_hash_undefined
)))
2735 if (h
&& h
->dynindx
== -1)
2737 BFD_ASSERT ((h
->root
.type
== bfd_link_hash_defined
)
2738 || (h
->root
.type
== bfd_link_hash_defweak
));
2740 if (!bfd_elf_link_record_local_dynamic_symbol
2741 (x
->info
, h
->root
.u
.def
.section
->owner
,
2742 global_sym_index (h
)))
2746 dyn_i
->want_fptr
= 0;
2748 else if (h
== NULL
|| h
->dynindx
== -1)
2750 dyn_i
->fptr_offset
= x
->ofs
;
2754 dyn_i
->want_fptr
= 0;
2759 /* Allocate all the minimal PLT entries. */
2762 allocate_plt_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2765 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2767 if (dyn_i
->want_plt
)
2769 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2772 while (h
->root
.type
== bfd_link_hash_indirect
2773 || h
->root
.type
== bfd_link_hash_warning
)
2774 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2776 /* ??? Versioned symbols seem to lose NEEDS_PLT. */
2777 if (elfNN_ia64_dynamic_symbol_p (h
, x
->info
, 0))
2779 bfd_size_type offset
= x
->ofs
;
2781 offset
= PLT_HEADER_SIZE
;
2782 dyn_i
->plt_offset
= offset
;
2783 x
->ofs
= offset
+ PLT_MIN_ENTRY_SIZE
;
2785 dyn_i
->want_pltoff
= 1;
2789 dyn_i
->want_plt
= 0;
2790 dyn_i
->want_plt2
= 0;
2796 /* Allocate all the full PLT entries. */
2799 allocate_plt2_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2802 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2804 if (dyn_i
->want_plt2
)
2806 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2807 bfd_size_type ofs
= x
->ofs
;
2809 dyn_i
->plt2_offset
= ofs
;
2810 x
->ofs
= ofs
+ PLT_FULL_ENTRY_SIZE
;
2812 while (h
->root
.type
== bfd_link_hash_indirect
2813 || h
->root
.type
== bfd_link_hash_warning
)
2814 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2815 dyn_i
->h
->plt
.offset
= ofs
;
2820 /* Allocate all the PLTOFF entries requested by relocations and
2821 plt entries. We can't share space with allocated FPTR entries,
2822 because the latter are not necessarily addressable by the GP.
2823 ??? Relaxation might be able to determine that they are. */
2826 allocate_pltoff_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2829 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2831 if (dyn_i
->want_pltoff
)
2833 dyn_i
->pltoff_offset
= x
->ofs
;
2839 /* Allocate dynamic relocations for those symbols that turned out
2843 allocate_dynrel_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2846 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2847 struct elfNN_ia64_link_hash_table
*ia64_info
;
2848 struct elfNN_ia64_dyn_reloc_entry
*rent
;
2849 bfd_boolean dynamic_symbol
, shared
, resolved_zero
;
2851 ia64_info
= elfNN_ia64_hash_table (x
->info
);
2852 if (ia64_info
== NULL
)
2855 /* Note that this can't be used in relation to FPTR relocs below. */
2856 dynamic_symbol
= elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0);
2858 shared
= bfd_link_pic (x
->info
);
2859 resolved_zero
= (dyn_i
->h
2860 && UNDEFWEAK_NO_DYNAMIC_RELOC (x
->info
,
2863 /* Take care of the GOT and PLT relocations. */
2866 && (dynamic_symbol
|| shared
)
2867 && (dyn_i
->want_got
|| dyn_i
->want_gotx
))
2868 || (dyn_i
->want_ltoff_fptr
2870 && dyn_i
->h
->dynindx
!= -1))
2872 if (!dyn_i
->want_ltoff_fptr
2873 || !bfd_link_pie (x
->info
)
2875 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
2876 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
2878 if ((dynamic_symbol
|| shared
) && dyn_i
->want_tprel
)
2879 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
2880 if (dynamic_symbol
&& dyn_i
->want_dtpmod
)
2881 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
2882 if (dynamic_symbol
&& dyn_i
->want_dtprel
)
2883 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
2888 if (ia64_info
->rel_fptr_sec
&& dyn_i
->want_fptr
)
2890 if (dyn_i
->h
== NULL
|| dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
2891 ia64_info
->rel_fptr_sec
->size
+= sizeof (ElfNN_External_Rela
);
2894 if (!resolved_zero
&& dyn_i
->want_pltoff
)
2896 bfd_size_type t
= 0;
2898 /* Dynamic symbols get one IPLT relocation. Local symbols in
2899 shared libraries get two REL relocations. Local symbols in
2900 main applications get nothing. */
2902 t
= sizeof (ElfNN_External_Rela
);
2904 t
= 2 * sizeof (ElfNN_External_Rela
);
2906 ia64_info
->rel_pltoff_sec
->size
+= t
;
2909 /* Take care of the normal data relocations. */
2911 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2913 int count
= rent
->count
;
2917 case R_IA64_FPTR32LSB
:
2918 case R_IA64_FPTR64LSB
:
2919 /* Allocate one iff !want_fptr and not PIE, which by this point
2920 will be true only if we're actually allocating one statically
2921 in the main executable. Position independent executables
2922 need a relative reloc. */
2923 if (dyn_i
->want_fptr
&& !bfd_link_pie (x
->info
))
2926 case R_IA64_PCREL32LSB
:
2927 case R_IA64_PCREL64LSB
:
2928 if (!dynamic_symbol
)
2931 case R_IA64_DIR32LSB
:
2932 case R_IA64_DIR64LSB
:
2933 if (!dynamic_symbol
&& !shared
)
2936 case R_IA64_IPLTLSB
:
2937 if (!dynamic_symbol
&& !shared
)
2939 /* Use two REL relocations for IPLT relocations
2940 against local symbols. */
2941 if (!dynamic_symbol
)
2944 case R_IA64_DTPREL32LSB
:
2945 case R_IA64_TPREL64LSB
:
2946 case R_IA64_DTPREL64LSB
:
2947 case R_IA64_DTPMOD64LSB
:
2953 x
->info
->flags
|= DF_TEXTREL
;
2954 rent
->srel
->size
+= sizeof (ElfNN_External_Rela
) * count
;
2961 elfNN_ia64_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2962 struct elf_link_hash_entry
*h
)
2964 /* ??? Undefined symbols with PLT entries should be re-defined
2965 to be the PLT entry. */
2967 /* If this is a weak symbol, and there is a real definition, the
2968 processor independent code will have arranged for us to see the
2969 real definition first, and we can just use the same value. */
2970 if (h
->is_weakalias
)
2972 struct elf_link_hash_entry
*def
= weakdef (h
);
2973 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
2974 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
2975 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
2979 /* If this is a reference to a symbol defined by a dynamic object which
2980 is not a function, we might allocate the symbol in our .dynbss section
2981 and allocate a COPY dynamic relocation.
2983 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2990 elfNN_ia64_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2991 struct bfd_link_info
*info
)
2993 struct elfNN_ia64_allocate_data data
;
2994 struct elfNN_ia64_link_hash_table
*ia64_info
;
2997 bfd_boolean relplt
= FALSE
;
2999 ia64_info
= elfNN_ia64_hash_table (info
);
3000 if (ia64_info
== NULL
)
3002 dynobj
= ia64_info
->root
.dynobj
;
3003 ia64_info
->self_dtpmod_offset
= (bfd_vma
) -1;
3004 BFD_ASSERT(dynobj
!= NULL
);
3007 /* Set the contents of the .interp section to the interpreter. */
3008 if (ia64_info
->root
.dynamic_sections_created
3009 && bfd_link_executable (info
) && !info
->nointerp
)
3011 sec
= bfd_get_linker_section (dynobj
, ".interp");
3012 BFD_ASSERT (sec
!= NULL
);
3013 sec
->contents
= (bfd_byte
*) ELF_DYNAMIC_INTERPRETER
;
3014 sec
->size
= strlen (ELF_DYNAMIC_INTERPRETER
) + 1;
3017 /* Allocate the GOT entries. */
3019 if (ia64_info
->root
.sgot
)
3022 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_data_got
, &data
);
3023 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_fptr_got
, &data
);
3024 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_local_got
, &data
);
3025 ia64_info
->root
.sgot
->size
= data
.ofs
;
3028 /* Allocate the FPTR entries. */
3030 if (ia64_info
->fptr_sec
)
3033 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_fptr
, &data
);
3034 ia64_info
->fptr_sec
->size
= data
.ofs
;
3037 /* Now that we've seen all of the input files, we can decide which
3038 symbols need plt entries. Allocate the minimal PLT entries first.
3039 We do this even though dynamic_sections_created may be FALSE, because
3040 this has the side-effect of clearing want_plt and want_plt2. */
3043 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_plt_entries
, &data
);
3045 ia64_info
->minplt_entries
= 0;
3048 ia64_info
->minplt_entries
3049 = (data
.ofs
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
3052 /* Align the pointer for the plt2 entries. */
3053 data
.ofs
= (data
.ofs
+ 31) & (bfd_vma
) -32;
3055 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_plt2_entries
, &data
);
3056 if (data
.ofs
!= 0 || ia64_info
->root
.dynamic_sections_created
)
3058 /* FIXME: we always reserve the memory for dynamic linker even if
3059 there are no PLT entries since dynamic linker may assume the
3060 reserved memory always exists. */
3062 BFD_ASSERT (ia64_info
->root
.dynamic_sections_created
);
3064 ia64_info
->root
.splt
->size
= data
.ofs
;
3066 /* If we've got a .plt, we need some extra memory for the dynamic
3067 linker. We stuff these in .got.plt. */
3068 ia64_info
->root
.sgotplt
->size
= 8 * PLT_RESERVED_WORDS
;
3071 /* Allocate the PLTOFF entries. */
3073 if (ia64_info
->pltoff_sec
)
3076 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_pltoff_entries
, &data
);
3077 ia64_info
->pltoff_sec
->size
= data
.ofs
;
3080 if (ia64_info
->root
.dynamic_sections_created
)
3082 /* Allocate space for the dynamic relocations that turned out to be
3085 if (bfd_link_pic (info
) && ia64_info
->self_dtpmod_offset
!= (bfd_vma
) -1)
3086 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
3087 data
.only_got
= FALSE
;
3088 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_dynrel_entries
, &data
);
3091 /* We have now determined the sizes of the various dynamic sections.
3092 Allocate memory for them. */
3093 for (sec
= dynobj
->sections
; sec
!= NULL
; sec
= sec
->next
)
3097 if (!(sec
->flags
& SEC_LINKER_CREATED
))
3100 /* If we don't need this section, strip it from the output file.
3101 There were several sections primarily related to dynamic
3102 linking that must be create before the linker maps input
3103 sections to output sections. The linker does that before
3104 bfd_elf_size_dynamic_sections is called, and it is that
3105 function which decides whether anything needs to go into
3108 strip
= (sec
->size
== 0);
3110 if (sec
== ia64_info
->root
.sgot
)
3112 else if (sec
== ia64_info
->root
.srelgot
)
3115 ia64_info
->root
.srelgot
= NULL
;
3117 /* We use the reloc_count field as a counter if we need to
3118 copy relocs into the output file. */
3119 sec
->reloc_count
= 0;
3121 else if (sec
== ia64_info
->fptr_sec
)
3124 ia64_info
->fptr_sec
= NULL
;
3126 else if (sec
== ia64_info
->rel_fptr_sec
)
3129 ia64_info
->rel_fptr_sec
= NULL
;
3131 /* We use the reloc_count field as a counter if we need to
3132 copy relocs into the output file. */
3133 sec
->reloc_count
= 0;
3135 else if (sec
== ia64_info
->root
.splt
)
3138 ia64_info
->root
.splt
= NULL
;
3140 else if (sec
== ia64_info
->pltoff_sec
)
3143 ia64_info
->pltoff_sec
= NULL
;
3145 else if (sec
== ia64_info
->rel_pltoff_sec
)
3148 ia64_info
->rel_pltoff_sec
= NULL
;
3152 /* We use the reloc_count field as a counter if we need to
3153 copy relocs into the output file. */
3154 sec
->reloc_count
= 0;
3161 /* It's OK to base decisions on the section name, because none
3162 of the dynobj section names depend upon the input files. */
3163 name
= bfd_section_name (sec
);
3165 if (strcmp (name
, ".got.plt") == 0)
3167 else if (CONST_STRNEQ (name
, ".rel"))
3171 /* We use the reloc_count field as a counter if we need to
3172 copy relocs into the output file. */
3173 sec
->reloc_count
= 0;
3181 sec
->flags
|= SEC_EXCLUDE
;
3184 /* Allocate memory for the section contents. */
3185 sec
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, sec
->size
);
3186 if (sec
->contents
== NULL
&& sec
->size
!= 0)
3191 if (ia64_info
->root
.dynamic_sections_created
)
3193 /* Add some entries to the .dynamic section. We fill in the values
3194 later (in finish_dynamic_sections) but we must add the entries now
3195 so that we get the correct size for the .dynamic section. */
3197 if (bfd_link_executable (info
))
3199 /* The DT_DEBUG entry is filled in by the dynamic linker and used
3201 #define add_dynamic_entry(TAG, VAL) \
3202 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3204 if (!add_dynamic_entry (DT_DEBUG
, 0))
3208 if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE
, 0))
3210 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3215 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3216 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3217 || !add_dynamic_entry (DT_JMPREL
, 0))
3221 if (!add_dynamic_entry (DT_RELA
, 0)
3222 || !add_dynamic_entry (DT_RELASZ
, 0)
3223 || !add_dynamic_entry (DT_RELAENT
, sizeof (ElfNN_External_Rela
)))
3226 if ((info
->flags
& DF_TEXTREL
) != 0)
3228 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3233 /* ??? Perhaps force __gp local. */
3239 elfNN_ia64_install_dyn_reloc (bfd
*abfd
, struct bfd_link_info
*info
,
3240 asection
*sec
, asection
*srel
,
3241 bfd_vma offset
, unsigned int type
,
3242 long dynindx
, bfd_vma addend
)
3244 Elf_Internal_Rela outrel
;
3247 BFD_ASSERT (dynindx
!= -1);
3248 outrel
.r_info
= ELFNN_R_INFO (dynindx
, type
);
3249 outrel
.r_addend
= addend
;
3250 outrel
.r_offset
= _bfd_elf_section_offset (abfd
, info
, sec
, offset
);
3251 if (outrel
.r_offset
>= (bfd_vma
) -2)
3253 /* Run for the hills. We shouldn't be outputting a relocation
3254 for this. So do what everyone else does and output a no-op. */
3255 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
3256 outrel
.r_addend
= 0;
3257 outrel
.r_offset
= 0;
3260 outrel
.r_offset
+= sec
->output_section
->vma
+ sec
->output_offset
;
3262 loc
= srel
->contents
;
3263 loc
+= srel
->reloc_count
++ * sizeof (ElfNN_External_Rela
);
3264 bfd_elfNN_swap_reloca_out (abfd
, &outrel
, loc
);
3265 BFD_ASSERT (sizeof (ElfNN_External_Rela
) * srel
->reloc_count
<= srel
->size
);
3268 /* Store an entry for target address TARGET_ADDR in the linkage table
3269 and return the gp-relative address of the linkage table entry. */
3272 set_got_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3273 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3274 long dynindx
, bfd_vma addend
, bfd_vma value
,
3275 unsigned int dyn_r_type
)
3277 struct elfNN_ia64_link_hash_table
*ia64_info
;
3282 ia64_info
= elfNN_ia64_hash_table (info
);
3283 if (ia64_info
== NULL
)
3286 got_sec
= ia64_info
->root
.sgot
;
3290 case R_IA64_TPREL64LSB
:
3291 done
= dyn_i
->tprel_done
;
3292 dyn_i
->tprel_done
= TRUE
;
3293 got_offset
= dyn_i
->tprel_offset
;
3295 case R_IA64_DTPMOD64LSB
:
3296 if (dyn_i
->dtpmod_offset
!= ia64_info
->self_dtpmod_offset
)
3298 done
= dyn_i
->dtpmod_done
;
3299 dyn_i
->dtpmod_done
= TRUE
;
3303 done
= ia64_info
->self_dtpmod_done
;
3304 ia64_info
->self_dtpmod_done
= TRUE
;
3307 got_offset
= dyn_i
->dtpmod_offset
;
3309 case R_IA64_DTPREL32LSB
:
3310 case R_IA64_DTPREL64LSB
:
3311 done
= dyn_i
->dtprel_done
;
3312 dyn_i
->dtprel_done
= TRUE
;
3313 got_offset
= dyn_i
->dtprel_offset
;
3316 done
= dyn_i
->got_done
;
3317 dyn_i
->got_done
= TRUE
;
3318 got_offset
= dyn_i
->got_offset
;
3322 BFD_ASSERT ((got_offset
& 7) == 0);
3326 /* Store the target address in the linkage table entry. */
3327 bfd_put_64 (abfd
, value
, got_sec
->contents
+ got_offset
);
3329 /* Install a dynamic relocation if needed. */
3330 if (((bfd_link_pic (info
)
3332 || (ELF_ST_VISIBILITY (dyn_i
->h
->other
) == STV_DEFAULT
3333 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, dyn_i
->h
))
3334 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
3335 && dyn_r_type
!= R_IA64_DTPREL32LSB
3336 && dyn_r_type
!= R_IA64_DTPREL64LSB
)
3337 || elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, info
, dyn_r_type
)
3339 && (dyn_r_type
== R_IA64_FPTR32LSB
3340 || dyn_r_type
== R_IA64_FPTR64LSB
)))
3341 && (!dyn_i
->want_ltoff_fptr
3342 || !bfd_link_pie (info
)
3344 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
3347 && dyn_r_type
!= R_IA64_TPREL64LSB
3348 && dyn_r_type
!= R_IA64_DTPMOD64LSB
3349 && dyn_r_type
!= R_IA64_DTPREL32LSB
3350 && dyn_r_type
!= R_IA64_DTPREL64LSB
)
3352 dyn_r_type
= R_IA64_RELNNLSB
;
3357 if (bfd_big_endian (abfd
))
3361 case R_IA64_REL32LSB
:
3362 dyn_r_type
= R_IA64_REL32MSB
;
3364 case R_IA64_DIR32LSB
:
3365 dyn_r_type
= R_IA64_DIR32MSB
;
3367 case R_IA64_FPTR32LSB
:
3368 dyn_r_type
= R_IA64_FPTR32MSB
;
3370 case R_IA64_DTPREL32LSB
:
3371 dyn_r_type
= R_IA64_DTPREL32MSB
;
3373 case R_IA64_REL64LSB
:
3374 dyn_r_type
= R_IA64_REL64MSB
;
3376 case R_IA64_DIR64LSB
:
3377 dyn_r_type
= R_IA64_DIR64MSB
;
3379 case R_IA64_FPTR64LSB
:
3380 dyn_r_type
= R_IA64_FPTR64MSB
;
3382 case R_IA64_TPREL64LSB
:
3383 dyn_r_type
= R_IA64_TPREL64MSB
;
3385 case R_IA64_DTPMOD64LSB
:
3386 dyn_r_type
= R_IA64_DTPMOD64MSB
;
3388 case R_IA64_DTPREL64LSB
:
3389 dyn_r_type
= R_IA64_DTPREL64MSB
;
3397 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, got_sec
,
3398 ia64_info
->root
.srelgot
,
3399 got_offset
, dyn_r_type
,
3404 /* Return the address of the linkage table entry. */
3405 value
= (got_sec
->output_section
->vma
3406 + got_sec
->output_offset
3412 /* Fill in a function descriptor consisting of the function's code
3413 address and its global pointer. Return the descriptor's address. */
3416 set_fptr_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3417 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3420 struct elfNN_ia64_link_hash_table
*ia64_info
;
3423 ia64_info
= elfNN_ia64_hash_table (info
);
3424 if (ia64_info
== NULL
)
3427 fptr_sec
= ia64_info
->fptr_sec
;
3429 if (!dyn_i
->fptr_done
)
3431 dyn_i
->fptr_done
= 1;
3433 /* Fill in the function descriptor. */
3434 bfd_put_64 (abfd
, value
, fptr_sec
->contents
+ dyn_i
->fptr_offset
);
3435 bfd_put_64 (abfd
, _bfd_get_gp_value (abfd
),
3436 fptr_sec
->contents
+ dyn_i
->fptr_offset
+ 8);
3437 if (ia64_info
->rel_fptr_sec
)
3439 Elf_Internal_Rela outrel
;
3442 if (bfd_little_endian (abfd
))
3443 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_IPLTLSB
);
3445 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_IPLTMSB
);
3446 outrel
.r_addend
= value
;
3447 outrel
.r_offset
= (fptr_sec
->output_section
->vma
3448 + fptr_sec
->output_offset
3449 + dyn_i
->fptr_offset
);
3450 loc
= ia64_info
->rel_fptr_sec
->contents
;
3451 loc
+= ia64_info
->rel_fptr_sec
->reloc_count
++
3452 * sizeof (ElfNN_External_Rela
);
3453 bfd_elfNN_swap_reloca_out (abfd
, &outrel
, loc
);
3457 /* Return the descriptor's address. */
3458 value
= (fptr_sec
->output_section
->vma
3459 + fptr_sec
->output_offset
3460 + dyn_i
->fptr_offset
);
3465 /* Fill in a PLTOFF entry consisting of the function's code address
3466 and its global pointer. Return the descriptor's address. */
3469 set_pltoff_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3470 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3471 bfd_vma value
, bfd_boolean is_plt
)
3473 struct elfNN_ia64_link_hash_table
*ia64_info
;
3474 asection
*pltoff_sec
;
3476 ia64_info
= elfNN_ia64_hash_table (info
);
3477 if (ia64_info
== NULL
)
3480 pltoff_sec
= ia64_info
->pltoff_sec
;
3482 /* Don't do anything if this symbol uses a real PLT entry. In
3483 that case, we'll fill this in during finish_dynamic_symbol. */
3484 if ((! dyn_i
->want_plt
|| is_plt
)
3485 && !dyn_i
->pltoff_done
)
3487 bfd_vma gp
= _bfd_get_gp_value (abfd
);
3489 /* Fill in the function descriptor. */
3490 bfd_put_64 (abfd
, value
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
);
3491 bfd_put_64 (abfd
, gp
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
+ 8);
3493 /* Install dynamic relocations if needed. */
3495 && bfd_link_pic (info
)
3497 || (ELF_ST_VISIBILITY (dyn_i
->h
->other
) == STV_DEFAULT
3498 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, dyn_i
->h
))
3499 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
3501 unsigned int dyn_r_type
;
3503 if (bfd_big_endian (abfd
))
3504 dyn_r_type
= R_IA64_RELNNMSB
;
3506 dyn_r_type
= R_IA64_RELNNLSB
;
3508 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
3509 ia64_info
->rel_pltoff_sec
,
3510 dyn_i
->pltoff_offset
,
3511 dyn_r_type
, 0, value
);
3512 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
3513 ia64_info
->rel_pltoff_sec
,
3514 dyn_i
->pltoff_offset
+ ARCH_SIZE
/ 8,
3518 dyn_i
->pltoff_done
= 1;
3521 /* Return the descriptor's address. */
3522 value
= (pltoff_sec
->output_section
->vma
3523 + pltoff_sec
->output_offset
3524 + dyn_i
->pltoff_offset
);
3529 /* Return the base VMA address which should be subtracted from real addresses
3530 when resolving @tprel() relocation.
3531 Main program TLS (whose template starts at PT_TLS p_vaddr)
3532 is assigned offset round(2 * size of pointer, PT_TLS p_align). */
3535 elfNN_ia64_tprel_base (struct bfd_link_info
*info
)
3537 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3538 return tls_sec
->vma
- align_power ((bfd_vma
) ARCH_SIZE
/ 4,
3539 tls_sec
->alignment_power
);
3542 /* Return the base VMA address which should be subtracted from real addresses
3543 when resolving @dtprel() relocation.
3544 This is PT_TLS segment p_vaddr. */
3547 elfNN_ia64_dtprel_base (struct bfd_link_info
*info
)
3549 return elf_hash_table (info
)->tls_sec
->vma
;
3552 /* Called through qsort to sort the .IA_64.unwind section during a
3553 non-relocatable link. Set elfNN_ia64_unwind_entry_compare_bfd
3554 to the output bfd so we can do proper endianness frobbing. */
3556 static bfd
*elfNN_ia64_unwind_entry_compare_bfd
;
3559 elfNN_ia64_unwind_entry_compare (const void * a
, const void * b
)
3563 av
= bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd
, a
);
3564 bv
= bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd
, b
);
3566 return (av
< bv
? -1 : av
> bv
? 1 : 0);
3569 /* Make sure we've got ourselves a nice fat __gp value. */
3571 elfNN_ia64_choose_gp (bfd
*abfd
, struct bfd_link_info
*info
, bfd_boolean final
)
3573 bfd_vma min_vma
= (bfd_vma
) -1, max_vma
= 0;
3574 bfd_vma min_short_vma
= min_vma
, max_short_vma
= 0;
3575 struct elf_link_hash_entry
*gp
;
3578 struct elfNN_ia64_link_hash_table
*ia64_info
;
3580 ia64_info
= elfNN_ia64_hash_table (info
);
3581 if (ia64_info
== NULL
)
3584 /* Find the min and max vma of all sections marked short. Also collect
3585 min and max vma of any type, for use in selecting a nice gp. */
3586 for (os
= abfd
->sections
; os
; os
= os
->next
)
3590 if ((os
->flags
& SEC_ALLOC
) == 0)
3594 /* When this function is called from elfNN_ia64_final_link
3595 the correct value to use is os->size. When called from
3596 elfNN_ia64_relax_section we are in the middle of section
3597 sizing; some sections will already have os->size set, others
3598 will have os->size zero and os->rawsize the previous size. */
3599 hi
= os
->vma
+ (!final
&& os
->rawsize
? os
->rawsize
: os
->size
);
3607 if (os
->flags
& SEC_SMALL_DATA
)
3609 if (min_short_vma
> lo
)
3611 if (max_short_vma
< hi
)
3616 if (ia64_info
->min_short_sec
)
3619 > (ia64_info
->min_short_sec
->vma
3620 + ia64_info
->min_short_offset
))
3621 min_short_vma
= (ia64_info
->min_short_sec
->vma
3622 + ia64_info
->min_short_offset
);
3624 < (ia64_info
->max_short_sec
->vma
3625 + ia64_info
->max_short_offset
))
3626 max_short_vma
= (ia64_info
->max_short_sec
->vma
3627 + ia64_info
->max_short_offset
);
3630 /* See if the user wants to force a value. */
3631 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
3635 && (gp
->root
.type
== bfd_link_hash_defined
3636 || gp
->root
.type
== bfd_link_hash_defweak
))
3638 asection
*gp_sec
= gp
->root
.u
.def
.section
;
3639 gp_val
= (gp
->root
.u
.def
.value
3640 + gp_sec
->output_section
->vma
3641 + gp_sec
->output_offset
);
3645 /* Pick a sensible value. */
3647 if (ia64_info
->min_short_sec
)
3649 bfd_vma short_range
= max_short_vma
- min_short_vma
;
3651 /* If min_short_sec is set, pick one in the middle bewteen
3652 min_short_vma and max_short_vma. */
3653 if (short_range
>= 0x400000)
3655 gp_val
= min_short_vma
+ short_range
/ 2;
3659 asection
*got_sec
= ia64_info
->root
.sgot
;
3661 /* Start with just the address of the .got. */
3663 gp_val
= got_sec
->output_section
->vma
;
3664 else if (max_short_vma
!= 0)
3665 gp_val
= min_short_vma
;
3666 else if (max_vma
- min_vma
< 0x200000)
3669 gp_val
= max_vma
- 0x200000 + 8;
3672 /* If it is possible to address the entire image, but we
3673 don't with the choice above, adjust. */
3674 if (max_vma
- min_vma
< 0x400000
3675 && (max_vma
- gp_val
>= 0x200000
3676 || gp_val
- min_vma
> 0x200000))
3677 gp_val
= min_vma
+ 0x200000;
3678 else if (max_short_vma
!= 0)
3680 /* If we don't cover all the short data, adjust. */
3681 if (max_short_vma
- gp_val
>= 0x200000)
3682 gp_val
= min_short_vma
+ 0x200000;
3684 /* If we're addressing stuff past the end, adjust back. */
3685 if (gp_val
> max_vma
)
3686 gp_val
= max_vma
- 0x200000 + 8;
3690 /* Validate whether all SHF_IA_64_SHORT sections are within
3691 range of the chosen GP. */
3693 if (max_short_vma
!= 0)
3695 if (max_short_vma
- min_short_vma
>= 0x400000)
3699 /* xgettext:c-format */
3700 (_("%pB: short data segment overflowed (%#" PRIx64
" >= 0x400000)"),
3701 abfd
, (uint64_t) (max_short_vma
- min_short_vma
));
3704 else if ((gp_val
> min_short_vma
3705 && gp_val
- min_short_vma
> 0x200000)
3706 || (gp_val
< max_short_vma
3707 && max_short_vma
- gp_val
>= 0x200000))
3710 (_("%pB: __gp does not cover short data segment"), abfd
);
3715 _bfd_set_gp_value (abfd
, gp_val
);
3721 elfNN_ia64_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
3723 struct elfNN_ia64_link_hash_table
*ia64_info
;
3724 asection
*unwind_output_sec
;
3726 ia64_info
= elfNN_ia64_hash_table (info
);
3727 if (ia64_info
== NULL
)
3730 /* Make sure we've got ourselves a nice fat __gp value. */
3731 if (!bfd_link_relocatable (info
))
3734 struct elf_link_hash_entry
*gp
;
3736 /* We assume after gp is set, section size will only decrease. We
3737 need to adjust gp for it. */
3738 _bfd_set_gp_value (abfd
, 0);
3739 if (! elfNN_ia64_choose_gp (abfd
, info
, TRUE
))
3741 gp_val
= _bfd_get_gp_value (abfd
);
3743 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
3747 gp
->root
.type
= bfd_link_hash_defined
;
3748 gp
->root
.u
.def
.value
= gp_val
;
3749 gp
->root
.u
.def
.section
= bfd_abs_section_ptr
;
3753 /* If we're producing a final executable, we need to sort the contents
3754 of the .IA_64.unwind section. Force this section to be relocated
3755 into memory rather than written immediately to the output file. */
3756 unwind_output_sec
= NULL
;
3757 if (!bfd_link_relocatable (info
))
3759 asection
*s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_unwind
);
3762 unwind_output_sec
= s
->output_section
;
3763 unwind_output_sec
->contents
3764 = bfd_malloc (unwind_output_sec
->size
);
3765 if (unwind_output_sec
->contents
== NULL
)
3770 /* Invoke the regular ELF backend linker to do all the work. */
3771 if (!bfd_elf_final_link (abfd
, info
))
3774 if (unwind_output_sec
)
3776 elfNN_ia64_unwind_entry_compare_bfd
= abfd
;
3777 qsort (unwind_output_sec
->contents
,
3778 (size_t) (unwind_output_sec
->size
/ 24),
3780 elfNN_ia64_unwind_entry_compare
);
3782 if (! bfd_set_section_contents (abfd
, unwind_output_sec
,
3783 unwind_output_sec
->contents
, (bfd_vma
) 0,
3784 unwind_output_sec
->size
))
3792 elfNN_ia64_relocate_section (bfd
*output_bfd
,
3793 struct bfd_link_info
*info
,
3795 asection
*input_section
,
3797 Elf_Internal_Rela
*relocs
,
3798 Elf_Internal_Sym
*local_syms
,
3799 asection
**local_sections
)
3801 struct elfNN_ia64_link_hash_table
*ia64_info
;
3802 Elf_Internal_Shdr
*symtab_hdr
;
3803 Elf_Internal_Rela
*rel
;
3804 Elf_Internal_Rela
*relend
;
3806 bfd_boolean ret_val
= TRUE
; /* for non-fatal errors */
3809 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3810 ia64_info
= elfNN_ia64_hash_table (info
);
3811 if (ia64_info
== NULL
)
3814 /* Infect various flags from the input section to the output section. */
3815 if (bfd_link_relocatable (info
))
3819 flags
= elf_section_data(input_section
)->this_hdr
.sh_flags
;
3820 flags
&= SHF_IA_64_NORECOV
;
3822 elf_section_data(input_section
->output_section
)
3823 ->this_hdr
.sh_flags
|= flags
;
3826 gp_val
= _bfd_get_gp_value (output_bfd
);
3827 srel
= get_reloc_section (input_bfd
, ia64_info
, input_section
, FALSE
);
3830 relend
= relocs
+ input_section
->reloc_count
;
3831 for (; rel
< relend
; ++rel
)
3833 struct elf_link_hash_entry
*h
;
3834 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3835 bfd_reloc_status_type r
;
3836 reloc_howto_type
*howto
;
3837 unsigned long r_symndx
;
3838 Elf_Internal_Sym
*sym
;
3839 unsigned int r_type
;
3843 bfd_boolean dynamic_symbol_p
;
3844 bfd_boolean undef_weak_ref
;
3846 r_type
= ELFNN_R_TYPE (rel
->r_info
);
3847 if (r_type
> R_IA64_MAX_RELOC_CODE
)
3849 /* xgettext:c-format */
3850 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
3851 input_bfd
, (int) r_type
);
3852 bfd_set_error (bfd_error_bad_value
);
3857 howto
= ia64_elf_lookup_howto (r_type
);
3864 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
3868 undef_weak_ref
= FALSE
;
3870 if (r_symndx
< symtab_hdr
->sh_info
)
3872 /* Reloc against local symbol. */
3874 sym
= local_syms
+ r_symndx
;
3875 sym_sec
= local_sections
[r_symndx
];
3877 value
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &msec
, rel
);
3878 if (!bfd_link_relocatable (info
)
3879 && (sym_sec
->flags
& SEC_MERGE
) != 0
3880 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3881 && sym_sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
3883 struct elfNN_ia64_local_hash_entry
*loc_h
;
3885 loc_h
= get_local_sym_hash (ia64_info
, input_bfd
, rel
, FALSE
);
3886 if (loc_h
&& ! loc_h
->sec_merge_done
)
3888 struct elfNN_ia64_dyn_sym_info
*dynent
;
3891 for (count
= loc_h
->count
, dynent
= loc_h
->info
;
3897 _bfd_merged_section_offset (output_bfd
, &msec
,
3898 elf_section_data (msec
)->
3902 dynent
->addend
-= sym
->st_value
;
3903 dynent
->addend
+= msec
->output_section
->vma
3904 + msec
->output_offset
3905 - sym_sec
->output_section
->vma
3906 - sym_sec
->output_offset
;
3909 /* We may have introduced duplicated entries. We need
3910 to remove them properly. */
3911 count
= sort_dyn_sym_info (loc_h
->info
, loc_h
->count
);
3912 if (count
!= loc_h
->count
)
3914 loc_h
->count
= count
;
3915 loc_h
->sorted_count
= count
;
3918 loc_h
->sec_merge_done
= 1;
3924 bfd_boolean unresolved_reloc
;
3925 bfd_boolean warned
, ignored
;
3926 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
3928 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3929 r_symndx
, symtab_hdr
, sym_hashes
,
3931 unresolved_reloc
, warned
, ignored
);
3933 if (h
->root
.type
== bfd_link_hash_undefweak
)
3934 undef_weak_ref
= TRUE
;
3935 else if (warned
|| (ignored
&& bfd_link_executable (info
)))
3939 if (sym_sec
!= NULL
&& discarded_section (sym_sec
))
3940 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3941 rel
, 1, relend
, howto
, 0, contents
);
3943 if (bfd_link_relocatable (info
))
3946 hit_addr
= contents
+ rel
->r_offset
;
3947 value
+= rel
->r_addend
;
3948 dynamic_symbol_p
= elfNN_ia64_dynamic_symbol_p (h
, info
, r_type
);
3959 case R_IA64_DIR32MSB
:
3960 case R_IA64_DIR32LSB
:
3961 case R_IA64_DIR64MSB
:
3962 case R_IA64_DIR64LSB
:
3963 /* Install a dynamic relocation for this reloc. */
3964 if ((dynamic_symbol_p
|| bfd_link_pic (info
))
3965 && !(h
&& UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
3966 && r_symndx
!= STN_UNDEF
3967 && (input_section
->flags
& SEC_ALLOC
) != 0)
3969 unsigned int dyn_r_type
;
3973 BFD_ASSERT (srel
!= NULL
);
3980 /* ??? People shouldn't be doing non-pic code in
3981 shared libraries nor dynamic executables. */
3983 /* xgettext:c-format */
3984 (_("%pB: non-pic code with imm relocation against dynamic symbol `%s'"),
3986 h
? h
->root
.root
.string
3987 : bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3996 /* If we don't need dynamic symbol lookup, find a
3997 matching RELATIVE relocation. */
3998 dyn_r_type
= r_type
;
3999 if (dynamic_symbol_p
)
4001 dynindx
= h
->dynindx
;
4002 addend
= rel
->r_addend
;
4009 case R_IA64_DIR32MSB
:
4010 dyn_r_type
= R_IA64_REL32MSB
;
4012 case R_IA64_DIR32LSB
:
4013 dyn_r_type
= R_IA64_REL32LSB
;
4015 case R_IA64_DIR64MSB
:
4016 dyn_r_type
= R_IA64_REL64MSB
;
4018 case R_IA64_DIR64LSB
:
4019 dyn_r_type
= R_IA64_REL64LSB
;
4029 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4030 srel
, rel
->r_offset
, dyn_r_type
,
4035 case R_IA64_LTV32MSB
:
4036 case R_IA64_LTV32LSB
:
4037 case R_IA64_LTV64MSB
:
4038 case R_IA64_LTV64LSB
:
4039 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4042 case R_IA64_GPREL22
:
4043 case R_IA64_GPREL64I
:
4044 case R_IA64_GPREL32MSB
:
4045 case R_IA64_GPREL32LSB
:
4046 case R_IA64_GPREL64MSB
:
4047 case R_IA64_GPREL64LSB
:
4048 if (dynamic_symbol_p
)
4051 /* xgettext:c-format */
4052 (_("%pB: @gprel relocation against dynamic symbol %s"),
4054 h
? h
->root
.root
.string
4055 : bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4061 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4064 case R_IA64_LTOFF22
:
4065 case R_IA64_LTOFF22X
:
4066 case R_IA64_LTOFF64I
:
4067 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4068 value
= set_got_entry (input_bfd
, info
, dyn_i
, (h
? h
->dynindx
: -1),
4069 rel
->r_addend
, value
, R_IA64_DIRNNLSB
);
4071 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4074 case R_IA64_PLTOFF22
:
4075 case R_IA64_PLTOFF64I
:
4076 case R_IA64_PLTOFF64MSB
:
4077 case R_IA64_PLTOFF64LSB
:
4078 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4079 value
= set_pltoff_entry (output_bfd
, info
, dyn_i
, value
, FALSE
);
4081 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4084 case R_IA64_FPTR64I
:
4085 case R_IA64_FPTR32MSB
:
4086 case R_IA64_FPTR32LSB
:
4087 case R_IA64_FPTR64MSB
:
4088 case R_IA64_FPTR64LSB
:
4089 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4090 if (dyn_i
->want_fptr
)
4092 if (!undef_weak_ref
)
4093 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
4095 if (!dyn_i
->want_fptr
|| bfd_link_pie (info
))
4098 unsigned int dyn_r_type
= r_type
;
4099 bfd_vma addend
= rel
->r_addend
;
4101 /* Otherwise, we expect the dynamic linker to create
4104 if (dyn_i
->want_fptr
)
4106 if (r_type
== R_IA64_FPTR64I
)
4108 /* We can't represent this without a dynamic symbol.
4109 Adjust the relocation to be against an output
4110 section symbol, which are always present in the
4111 dynamic symbol table. */
4112 /* ??? People shouldn't be doing non-pic code in
4113 shared libraries. Hork. */
4115 (_("%pB: linking non-pic code in a position independent executable"),
4122 dyn_r_type
= r_type
+ R_IA64_RELNNLSB
- R_IA64_FPTRNNLSB
;
4126 if (h
->dynindx
!= -1)
4127 dynindx
= h
->dynindx
;
4129 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4130 (info
, h
->root
.u
.def
.section
->owner
,
4131 global_sym_index (h
)));
4136 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4137 (info
, input_bfd
, (long) r_symndx
));
4141 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4142 srel
, rel
->r_offset
, dyn_r_type
,
4146 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4149 case R_IA64_LTOFF_FPTR22
:
4150 case R_IA64_LTOFF_FPTR64I
:
4151 case R_IA64_LTOFF_FPTR32MSB
:
4152 case R_IA64_LTOFF_FPTR32LSB
:
4153 case R_IA64_LTOFF_FPTR64MSB
:
4154 case R_IA64_LTOFF_FPTR64LSB
:
4158 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4159 if (dyn_i
->want_fptr
)
4161 BFD_ASSERT (h
== NULL
|| h
->dynindx
== -1);
4162 if (!undef_weak_ref
)
4163 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
4168 /* Otherwise, we expect the dynamic linker to create
4172 if (h
->dynindx
!= -1)
4173 dynindx
= h
->dynindx
;
4175 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4176 (info
, h
->root
.u
.def
.section
->owner
,
4177 global_sym_index (h
)));
4180 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4181 (info
, input_bfd
, (long) r_symndx
));
4185 value
= set_got_entry (output_bfd
, info
, dyn_i
, dynindx
,
4186 rel
->r_addend
, value
, R_IA64_FPTRNNLSB
);
4188 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4192 case R_IA64_PCREL32MSB
:
4193 case R_IA64_PCREL32LSB
:
4194 case R_IA64_PCREL64MSB
:
4195 case R_IA64_PCREL64LSB
:
4196 /* Install a dynamic relocation for this reloc. */
4197 if (dynamic_symbol_p
&& r_symndx
!= STN_UNDEF
)
4199 BFD_ASSERT (srel
!= NULL
);
4201 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4202 srel
, rel
->r_offset
, r_type
,
4203 h
->dynindx
, rel
->r_addend
);
4207 case R_IA64_PCREL21B
:
4208 case R_IA64_PCREL60B
:
4209 /* We should have created a PLT entry for any dynamic symbol. */
4212 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, FALSE
);
4214 if (dyn_i
&& dyn_i
->want_plt2
)
4216 /* Should have caught this earlier. */
4217 BFD_ASSERT (rel
->r_addend
== 0);
4219 value
= (ia64_info
->root
.splt
->output_section
->vma
4220 + ia64_info
->root
.splt
->output_offset
4221 + dyn_i
->plt2_offset
);
4225 /* Since there's no PLT entry, Validate that this is
4227 BFD_ASSERT (undef_weak_ref
|| sym_sec
->output_section
!= NULL
);
4229 /* If the symbol is undef_weak, we shouldn't be trying
4230 to call it. There's every chance that we'd wind up
4231 with an out-of-range fixup here. Don't bother setting
4232 any value at all. */
4238 case R_IA64_PCREL21BI
:
4239 case R_IA64_PCREL21F
:
4240 case R_IA64_PCREL21M
:
4241 case R_IA64_PCREL22
:
4242 case R_IA64_PCREL64I
:
4243 /* The PCREL21BI reloc is specifically not intended for use with
4244 dynamic relocs. PCREL21F and PCREL21M are used for speculation
4245 fixup code, and thus probably ought not be dynamic. The
4246 PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs. */
4247 if (dynamic_symbol_p
)
4251 if (r_type
== R_IA64_PCREL21BI
)
4252 /* xgettext:c-format */
4253 msg
= _("%pB: @internal branch to dynamic symbol %s");
4254 else if (r_type
== R_IA64_PCREL21F
|| r_type
== R_IA64_PCREL21M
)
4255 /* xgettext:c-format */
4256 msg
= _("%pB: speculation fixup to dynamic symbol %s");
4258 /* xgettext:c-format */
4259 msg
= _("%pB: @pcrel relocation against dynamic symbol %s");
4260 _bfd_error_handler (msg
, input_bfd
,
4261 h
? h
->root
.root
.string
4262 : bfd_elf_sym_name (input_bfd
,
4272 /* Make pc-relative. */
4273 value
-= (input_section
->output_section
->vma
4274 + input_section
->output_offset
4275 + rel
->r_offset
) & ~ (bfd_vma
) 0x3;
4276 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4279 case R_IA64_SEGREL32MSB
:
4280 case R_IA64_SEGREL32LSB
:
4281 case R_IA64_SEGREL64MSB
:
4282 case R_IA64_SEGREL64LSB
:
4284 /* Find the segment that contains the output_section. */
4285 Elf_Internal_Phdr
*p
= _bfd_elf_find_segment_containing_section
4286 (output_bfd
, input_section
->output_section
);
4290 r
= bfd_reloc_notsupported
;
4294 /* The VMA of the segment is the vaddr of the associated
4296 if (value
> p
->p_vaddr
)
4297 value
-= p
->p_vaddr
;
4300 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4305 case R_IA64_SECREL32MSB
:
4306 case R_IA64_SECREL32LSB
:
4307 case R_IA64_SECREL64MSB
:
4308 case R_IA64_SECREL64LSB
:
4309 /* Make output-section relative to section where the symbol
4310 is defined. PR 475 */
4312 value
-= sym_sec
->output_section
->vma
;
4313 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4316 case R_IA64_IPLTMSB
:
4317 case R_IA64_IPLTLSB
:
4318 /* Install a dynamic relocation for this reloc. */
4319 if ((dynamic_symbol_p
|| bfd_link_pic (info
))
4320 && (input_section
->flags
& SEC_ALLOC
) != 0)
4322 BFD_ASSERT (srel
!= NULL
);
4324 /* If we don't need dynamic symbol lookup, install two
4325 RELATIVE relocations. */
4326 if (!dynamic_symbol_p
)
4328 unsigned int dyn_r_type
;
4330 if (r_type
== R_IA64_IPLTMSB
)
4331 dyn_r_type
= R_IA64_REL64MSB
;
4333 dyn_r_type
= R_IA64_REL64LSB
;
4335 elfNN_ia64_install_dyn_reloc (output_bfd
, info
,
4337 srel
, rel
->r_offset
,
4338 dyn_r_type
, 0, value
);
4339 elfNN_ia64_install_dyn_reloc (output_bfd
, info
,
4341 srel
, rel
->r_offset
+ 8,
4342 dyn_r_type
, 0, gp_val
);
4345 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4346 srel
, rel
->r_offset
, r_type
,
4347 h
->dynindx
, rel
->r_addend
);
4350 if (r_type
== R_IA64_IPLTMSB
)
4351 r_type
= R_IA64_DIR64MSB
;
4353 r_type
= R_IA64_DIR64LSB
;
4354 ia64_elf_install_value (hit_addr
, value
, r_type
);
4355 r
= ia64_elf_install_value (hit_addr
+ 8, gp_val
, r_type
);
4358 case R_IA64_TPREL14
:
4359 case R_IA64_TPREL22
:
4360 case R_IA64_TPREL64I
:
4361 if (elf_hash_table (info
)->tls_sec
== NULL
)
4362 goto missing_tls_sec
;
4363 value
-= elfNN_ia64_tprel_base (info
);
4364 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4367 case R_IA64_DTPREL14
:
4368 case R_IA64_DTPREL22
:
4369 case R_IA64_DTPREL64I
:
4370 case R_IA64_DTPREL32LSB
:
4371 case R_IA64_DTPREL32MSB
:
4372 case R_IA64_DTPREL64LSB
:
4373 case R_IA64_DTPREL64MSB
:
4374 if (elf_hash_table (info
)->tls_sec
== NULL
)
4375 goto missing_tls_sec
;
4376 value
-= elfNN_ia64_dtprel_base (info
);
4377 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4380 case R_IA64_LTOFF_TPREL22
:
4381 case R_IA64_LTOFF_DTPMOD22
:
4382 case R_IA64_LTOFF_DTPREL22
:
4385 long dynindx
= h
? h
->dynindx
: -1;
4386 bfd_vma r_addend
= rel
->r_addend
;
4391 case R_IA64_LTOFF_TPREL22
:
4392 if (!dynamic_symbol_p
)
4394 if (elf_hash_table (info
)->tls_sec
== NULL
)
4395 goto missing_tls_sec
;
4396 if (!bfd_link_pic (info
))
4397 value
-= elfNN_ia64_tprel_base (info
);
4400 r_addend
+= value
- elfNN_ia64_dtprel_base (info
);
4404 got_r_type
= R_IA64_TPREL64LSB
;
4406 case R_IA64_LTOFF_DTPMOD22
:
4407 if (!dynamic_symbol_p
&& !bfd_link_pic (info
))
4409 got_r_type
= R_IA64_DTPMOD64LSB
;
4411 case R_IA64_LTOFF_DTPREL22
:
4412 if (!dynamic_symbol_p
)
4414 if (elf_hash_table (info
)->tls_sec
== NULL
)
4415 goto missing_tls_sec
;
4416 value
-= elfNN_ia64_dtprel_base (info
);
4418 got_r_type
= R_IA64_DTPRELNNLSB
;
4421 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4422 value
= set_got_entry (input_bfd
, info
, dyn_i
, dynindx
, r_addend
,
4425 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4430 r
= bfd_reloc_notsupported
;
4439 case bfd_reloc_undefined
:
4440 /* This can happen for global table relative relocs if
4441 __gp is undefined. This is a panic situation so we
4442 don't try to continue. */
4443 (*info
->callbacks
->undefined_symbol
)
4444 (info
, "__gp", input_bfd
, input_section
, rel
->r_offset
, 1);
4447 case bfd_reloc_notsupported
:
4452 name
= h
->root
.root
.string
;
4454 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4456 (*info
->callbacks
->warning
) (info
, _("unsupported reloc"),
4458 input_section
, rel
->r_offset
);
4463 case bfd_reloc_dangerous
:
4464 case bfd_reloc_outofrange
:
4465 case bfd_reloc_overflow
:
4472 name
= h
->root
.root
.string
;
4474 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4479 case R_IA64_TPREL14
:
4480 case R_IA64_TPREL22
:
4481 case R_IA64_TPREL64I
:
4482 case R_IA64_DTPREL14
:
4483 case R_IA64_DTPREL22
:
4484 case R_IA64_DTPREL64I
:
4485 case R_IA64_DTPREL32LSB
:
4486 case R_IA64_DTPREL32MSB
:
4487 case R_IA64_DTPREL64LSB
:
4488 case R_IA64_DTPREL64MSB
:
4489 case R_IA64_LTOFF_TPREL22
:
4490 case R_IA64_LTOFF_DTPMOD22
:
4491 case R_IA64_LTOFF_DTPREL22
:
4493 /* xgettext:c-format */
4494 (_("%pB: missing TLS section for relocation %s against `%s'"
4495 " at %#" PRIx64
" in section `%pA'."),
4496 input_bfd
, howto
->name
, name
,
4497 (uint64_t) rel
->r_offset
, input_section
);
4500 case R_IA64_PCREL21B
:
4501 case R_IA64_PCREL21BI
:
4502 case R_IA64_PCREL21M
:
4503 case R_IA64_PCREL21F
:
4504 if (is_elf_hash_table (info
->hash
))
4506 /* Relaxtion is always performed for ELF output.
4507 Overflow failures for those relocations mean
4508 that the section is too big to relax. */
4510 /* xgettext:c-format */
4511 (_("%pB: Can't relax br (%s) to `%s' at %#" PRIx64
4512 " in section `%pA' with size %#" PRIx64
4514 input_bfd
, howto
->name
, name
, (uint64_t) rel
->r_offset
,
4515 input_section
, (uint64_t) input_section
->size
);
4520 (*info
->callbacks
->reloc_overflow
) (info
,
4541 elfNN_ia64_finish_dynamic_symbol (bfd
*output_bfd
,
4542 struct bfd_link_info
*info
,
4543 struct elf_link_hash_entry
*h
,
4544 Elf_Internal_Sym
*sym
)
4546 struct elfNN_ia64_link_hash_table
*ia64_info
;
4547 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
4549 ia64_info
= elfNN_ia64_hash_table (info
);
4550 if (ia64_info
== NULL
)
4553 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, FALSE
);
4555 /* Fill in the PLT data, if required. */
4556 if (dyn_i
&& dyn_i
->want_plt
)
4558 Elf_Internal_Rela outrel
;
4561 bfd_vma plt_addr
, pltoff_addr
, gp_val
, plt_index
;
4563 gp_val
= _bfd_get_gp_value (output_bfd
);
4565 /* Initialize the minimal PLT entry. */
4567 plt_index
= (dyn_i
->plt_offset
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
4568 plt_sec
= ia64_info
->root
.splt
;
4569 loc
= plt_sec
->contents
+ dyn_i
->plt_offset
;
4571 memcpy (loc
, plt_min_entry
, PLT_MIN_ENTRY_SIZE
);
4572 ia64_elf_install_value (loc
, plt_index
, R_IA64_IMM22
);
4573 ia64_elf_install_value (loc
+2, -dyn_i
->plt_offset
, R_IA64_PCREL21B
);
4575 plt_addr
= (plt_sec
->output_section
->vma
4576 + plt_sec
->output_offset
4577 + dyn_i
->plt_offset
);
4578 pltoff_addr
= set_pltoff_entry (output_bfd
, info
, dyn_i
, plt_addr
, TRUE
);
4580 /* Initialize the FULL PLT entry, if needed. */
4581 if (dyn_i
->want_plt2
)
4583 loc
= plt_sec
->contents
+ dyn_i
->plt2_offset
;
4585 memcpy (loc
, plt_full_entry
, PLT_FULL_ENTRY_SIZE
);
4586 ia64_elf_install_value (loc
, pltoff_addr
- gp_val
, R_IA64_IMM22
);
4588 /* Mark the symbol as undefined, rather than as defined in the
4589 plt section. Leave the value alone. */
4590 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
4591 first place. But perhaps elflink.c did some for us. */
4592 if (!h
->def_regular
)
4593 sym
->st_shndx
= SHN_UNDEF
;
4596 /* Create the dynamic relocation. */
4597 outrel
.r_offset
= pltoff_addr
;
4598 if (bfd_little_endian (output_bfd
))
4599 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_IA64_IPLTLSB
);
4601 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_IA64_IPLTMSB
);
4602 outrel
.r_addend
= 0;
4604 /* This is fun. In the .IA_64.pltoff section, we've got entries
4605 that correspond both to real PLT entries, and those that
4606 happened to resolve to local symbols but need to be created
4607 to satisfy @pltoff relocations. The .rela.IA_64.pltoff
4608 relocations for the real PLT should come at the end of the
4609 section, so that they can be indexed by plt entry at runtime.
4611 We emitted all of the relocations for the non-PLT @pltoff
4612 entries during relocate_section. So we can consider the
4613 existing sec->reloc_count to be the base of the array of
4616 loc
= ia64_info
->rel_pltoff_sec
->contents
;
4617 loc
+= ((ia64_info
->rel_pltoff_sec
->reloc_count
+ plt_index
)
4618 * sizeof (ElfNN_External_Rela
));
4619 bfd_elfNN_swap_reloca_out (output_bfd
, &outrel
, loc
);
4622 /* Mark some specially defined symbols as absolute. */
4623 if (h
== ia64_info
->root
.hdynamic
4624 || h
== ia64_info
->root
.hgot
4625 || h
== ia64_info
->root
.hplt
)
4626 sym
->st_shndx
= SHN_ABS
;
4632 elfNN_ia64_finish_dynamic_sections (bfd
*abfd
,
4633 struct bfd_link_info
*info
)
4635 struct elfNN_ia64_link_hash_table
*ia64_info
;
4638 ia64_info
= elfNN_ia64_hash_table (info
);
4639 if (ia64_info
== NULL
)
4642 dynobj
= ia64_info
->root
.dynobj
;
4644 if (ia64_info
->root
.dynamic_sections_created
)
4646 ElfNN_External_Dyn
*dyncon
, *dynconend
;
4647 asection
*sdyn
, *sgotplt
;
4650 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
4651 sgotplt
= ia64_info
->root
.sgotplt
;
4652 BFD_ASSERT (sdyn
!= NULL
);
4653 dyncon
= (ElfNN_External_Dyn
*) sdyn
->contents
;
4654 dynconend
= (ElfNN_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4656 gp_val
= _bfd_get_gp_value (abfd
);
4658 for (; dyncon
< dynconend
; dyncon
++)
4660 Elf_Internal_Dyn dyn
;
4662 bfd_elfNN_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4667 dyn
.d_un
.d_ptr
= gp_val
;
4671 dyn
.d_un
.d_val
= (ia64_info
->minplt_entries
4672 * sizeof (ElfNN_External_Rela
));
4676 /* See the comment above in finish_dynamic_symbol. */
4677 dyn
.d_un
.d_ptr
= (ia64_info
->rel_pltoff_sec
->output_section
->vma
4678 + ia64_info
->rel_pltoff_sec
->output_offset
4679 + (ia64_info
->rel_pltoff_sec
->reloc_count
4680 * sizeof (ElfNN_External_Rela
)));
4683 case DT_IA_64_PLT_RESERVE
:
4684 dyn
.d_un
.d_ptr
= (sgotplt
->output_section
->vma
4685 + sgotplt
->output_offset
);
4689 bfd_elfNN_swap_dyn_out (abfd
, &dyn
, dyncon
);
4692 /* Initialize the PLT0 entry. */
4693 if (ia64_info
->root
.splt
)
4695 bfd_byte
*loc
= ia64_info
->root
.splt
->contents
;
4698 memcpy (loc
, plt_header
, PLT_HEADER_SIZE
);
4700 pltres
= (sgotplt
->output_section
->vma
4701 + sgotplt
->output_offset
4704 ia64_elf_install_value (loc
+1, pltres
, R_IA64_GPREL22
);
4711 /* ELF file flag handling: */
4713 /* Function to keep IA-64 specific file flags. */
4715 elfNN_ia64_set_private_flags (bfd
*abfd
, flagword flags
)
4717 BFD_ASSERT (!elf_flags_init (abfd
)
4718 || elf_elfheader (abfd
)->e_flags
== flags
);
4720 elf_elfheader (abfd
)->e_flags
= flags
;
4721 elf_flags_init (abfd
) = TRUE
;
4725 /* Merge backend specific data from an object file to the output
4726 object file when linking. */
4729 elfNN_ia64_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
4731 bfd
*obfd
= info
->output_bfd
;
4734 bfd_boolean ok
= TRUE
;
4736 /* FIXME: What should be checked when linking shared libraries? */
4737 if ((ibfd
->flags
& DYNAMIC
) != 0)
4740 if (!is_ia64_elf (ibfd
) || !is_ia64_elf (obfd
))
4743 in_flags
= elf_elfheader (ibfd
)->e_flags
;
4744 out_flags
= elf_elfheader (obfd
)->e_flags
;
4746 if (! elf_flags_init (obfd
))
4748 elf_flags_init (obfd
) = TRUE
;
4749 elf_elfheader (obfd
)->e_flags
= in_flags
;
4751 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
4752 && bfd_get_arch_info (obfd
)->the_default
)
4754 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
4755 bfd_get_mach (ibfd
));
4761 /* Check flag compatibility. */
4762 if (in_flags
== out_flags
)
4765 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
4766 if (!(in_flags
& EF_IA_64_REDUCEDFP
) && (out_flags
& EF_IA_64_REDUCEDFP
))
4767 elf_elfheader (obfd
)->e_flags
&= ~EF_IA_64_REDUCEDFP
;
4769 if ((in_flags
& EF_IA_64_TRAPNIL
) != (out_flags
& EF_IA_64_TRAPNIL
))
4772 (_("%pB: linking trap-on-NULL-dereference with non-trapping files"),
4775 bfd_set_error (bfd_error_bad_value
);
4778 if ((in_flags
& EF_IA_64_BE
) != (out_flags
& EF_IA_64_BE
))
4781 (_("%pB: linking big-endian files with little-endian files"),
4784 bfd_set_error (bfd_error_bad_value
);
4787 if ((in_flags
& EF_IA_64_ABI64
) != (out_flags
& EF_IA_64_ABI64
))
4790 (_("%pB: linking 64-bit files with 32-bit files"),
4793 bfd_set_error (bfd_error_bad_value
);
4796 if ((in_flags
& EF_IA_64_CONS_GP
) != (out_flags
& EF_IA_64_CONS_GP
))
4799 (_("%pB: linking constant-gp files with non-constant-gp files"),
4802 bfd_set_error (bfd_error_bad_value
);
4805 if ((in_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
)
4806 != (out_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
4809 (_("%pB: linking auto-pic files with non-auto-pic files"),
4812 bfd_set_error (bfd_error_bad_value
);
4820 elfNN_ia64_print_private_bfd_data (bfd
*abfd
, void * ptr
)
4822 FILE *file
= (FILE *) ptr
;
4823 flagword flags
= elf_elfheader (abfd
)->e_flags
;
4825 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
4827 fprintf (file
, "private flags = %s%s%s%s%s%s%s%s\n",
4828 (flags
& EF_IA_64_TRAPNIL
) ? "TRAPNIL, " : "",
4829 (flags
& EF_IA_64_EXT
) ? "EXT, " : "",
4830 (flags
& EF_IA_64_BE
) ? "BE, " : "LE, ",
4831 (flags
& EF_IA_64_REDUCEDFP
) ? "REDUCEDFP, " : "",
4832 (flags
& EF_IA_64_CONS_GP
) ? "CONS_GP, " : "",
4833 (flags
& EF_IA_64_NOFUNCDESC_CONS_GP
) ? "NOFUNCDESC_CONS_GP, " : "",
4834 (flags
& EF_IA_64_ABSOLUTE
) ? "ABSOLUTE, " : "",
4835 (flags
& EF_IA_64_ABI64
) ? "ABI64" : "ABI32");
4837 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
4841 static enum elf_reloc_type_class
4842 elfNN_ia64_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4843 const asection
*rel_sec ATTRIBUTE_UNUSED
,
4844 const Elf_Internal_Rela
*rela
)
4846 switch ((int) ELFNN_R_TYPE (rela
->r_info
))
4848 case R_IA64_REL32MSB
:
4849 case R_IA64_REL32LSB
:
4850 case R_IA64_REL64MSB
:
4851 case R_IA64_REL64LSB
:
4852 return reloc_class_relative
;
4853 case R_IA64_IPLTMSB
:
4854 case R_IA64_IPLTLSB
:
4855 return reloc_class_plt
;
4857 return reloc_class_copy
;
4859 return reloc_class_normal
;
4863 static const struct bfd_elf_special_section elfNN_ia64_special_sections
[] =
4865 { STRING_COMMA_LEN (".sbss"), -1, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_IA_64_SHORT
},
4866 { STRING_COMMA_LEN (".sdata"), -1, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_IA_64_SHORT
},
4867 { NULL
, 0, 0, 0, 0 }
4871 elfNN_ia64_object_p (bfd
*abfd
)
4874 asection
*group
, *unwi
, *unw
;
4877 char *unwi_name
, *unw_name
;
4880 if (abfd
->flags
& DYNAMIC
)
4883 /* Flags for fake group section. */
4884 flags
= (SEC_LINKER_CREATED
| SEC_GROUP
| SEC_LINK_ONCE
4887 /* We add a fake section group for each .gnu.linkonce.t.* section,
4888 which isn't in a section group, and its unwind sections. */
4889 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4891 if (elf_sec_group (sec
) == NULL
4892 && ((sec
->flags
& (SEC_LINK_ONCE
| SEC_CODE
| SEC_GROUP
))
4893 == (SEC_LINK_ONCE
| SEC_CODE
))
4894 && CONST_STRNEQ (sec
->name
, ".gnu.linkonce.t."))
4896 name
= sec
->name
+ 16;
4898 amt
= strlen (name
) + sizeof (".gnu.linkonce.ia64unwi.");
4899 unwi_name
= bfd_alloc (abfd
, amt
);
4903 strcpy (stpcpy (unwi_name
, ".gnu.linkonce.ia64unwi."), name
);
4904 unwi
= bfd_get_section_by_name (abfd
, unwi_name
);
4906 amt
= strlen (name
) + sizeof (".gnu.linkonce.ia64unw.");
4907 unw_name
= bfd_alloc (abfd
, amt
);
4911 strcpy (stpcpy (unw_name
, ".gnu.linkonce.ia64unw."), name
);
4912 unw
= bfd_get_section_by_name (abfd
, unw_name
);
4914 /* We need to create a fake group section for it and its
4916 group
= bfd_make_section_anyway_with_flags (abfd
, name
,
4921 /* Move the fake group section to the beginning. */
4922 bfd_section_list_remove (abfd
, group
);
4923 bfd_section_list_prepend (abfd
, group
);
4925 elf_next_in_group (group
) = sec
;
4927 elf_group_name (sec
) = name
;
4928 elf_next_in_group (sec
) = sec
;
4929 elf_sec_group (sec
) = group
;
4933 elf_group_name (unwi
) = name
;
4934 elf_next_in_group (unwi
) = sec
;
4935 elf_next_in_group (sec
) = unwi
;
4936 elf_sec_group (unwi
) = group
;
4941 elf_group_name (unw
) = name
;
4944 elf_next_in_group (unw
) = elf_next_in_group (unwi
);
4945 elf_next_in_group (unwi
) = unw
;
4949 elf_next_in_group (unw
) = sec
;
4950 elf_next_in_group (sec
) = unw
;
4952 elf_sec_group (unw
) = group
;
4955 /* Fake SHT_GROUP section header. */
4956 elf_section_data (group
)->this_hdr
.bfd_section
= group
;
4957 elf_section_data (group
)->this_hdr
.sh_type
= SHT_GROUP
;
4964 elfNN_ia64_hpux_vec (const bfd_target
*vec
)
4966 extern const bfd_target ia64_elfNN_hpux_be_vec
;
4967 return (vec
== &ia64_elfNN_hpux_be_vec
);
4971 elfNN_hpux_init_file_header (bfd
*abfd
, struct bfd_link_info
*info
)
4973 Elf_Internal_Ehdr
*i_ehdrp
;
4975 if (!_bfd_elf_init_file_header (abfd
, info
))
4978 i_ehdrp
= elf_elfheader (abfd
);
4979 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
4980 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 1;
4985 elfNN_hpux_backend_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
4986 asection
*sec
, int *retval
)
4988 if (bfd_is_com_section (sec
))
4990 *retval
= SHN_IA_64_ANSI_COMMON
;
4997 elfNN_hpux_backend_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
5000 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
5002 switch (elfsym
->internal_elf_sym
.st_shndx
)
5004 case SHN_IA_64_ANSI_COMMON
:
5005 asym
->section
= bfd_com_section_ptr
;
5006 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
5007 asym
->flags
&= ~BSF_GLOBAL
;
5013 ignore_errors (const char *fmt ATTRIBUTE_UNUSED
, ...)
5017 #define TARGET_LITTLE_SYM ia64_elfNN_le_vec
5018 #define TARGET_LITTLE_NAME "elfNN-ia64-little"
5019 #define TARGET_BIG_SYM ia64_elfNN_be_vec
5020 #define TARGET_BIG_NAME "elfNN-ia64-big"
5021 #define ELF_ARCH bfd_arch_ia64
5022 #define ELF_TARGET_ID IA64_ELF_DATA
5023 #define ELF_MACHINE_CODE EM_IA_64
5024 #define ELF_MACHINE_ALT1 1999 /* EAS2.3 */
5025 #define ELF_MACHINE_ALT2 1998 /* EAS2.2 */
5026 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
5027 #define ELF_COMMONPAGESIZE 0x4000 /* 16KB */
5029 #define elf_backend_section_from_shdr \
5030 elfNN_ia64_section_from_shdr
5031 #define elf_backend_section_flags \
5032 elfNN_ia64_section_flags
5033 #define elf_backend_fake_sections \
5034 elfNN_ia64_fake_sections
5035 #define elf_backend_final_write_processing \
5036 elfNN_ia64_final_write_processing
5037 #define elf_backend_add_symbol_hook \
5038 elfNN_ia64_add_symbol_hook
5039 #define elf_backend_additional_program_headers \
5040 elfNN_ia64_additional_program_headers
5041 #define elf_backend_modify_segment_map \
5042 elfNN_ia64_modify_segment_map
5043 #define elf_backend_modify_headers \
5044 elfNN_ia64_modify_headers
5045 #define elf_info_to_howto \
5046 elfNN_ia64_info_to_howto
5048 #define bfd_elfNN_bfd_reloc_type_lookup \
5049 ia64_elf_reloc_type_lookup
5050 #define bfd_elfNN_bfd_reloc_name_lookup \
5051 ia64_elf_reloc_name_lookup
5052 #define bfd_elfNN_bfd_is_local_label_name \
5053 elfNN_ia64_is_local_label_name
5054 #define bfd_elfNN_bfd_relax_section \
5055 elfNN_ia64_relax_section
5057 #define elf_backend_object_p \
5060 /* Stuff for the BFD linker: */
5061 #define bfd_elfNN_bfd_link_hash_table_create \
5062 elfNN_ia64_hash_table_create
5063 #define elf_backend_create_dynamic_sections \
5064 elfNN_ia64_create_dynamic_sections
5065 #define elf_backend_check_relocs \
5066 elfNN_ia64_check_relocs
5067 #define elf_backend_adjust_dynamic_symbol \
5068 elfNN_ia64_adjust_dynamic_symbol
5069 #define elf_backend_size_dynamic_sections \
5070 elfNN_ia64_size_dynamic_sections
5071 #define elf_backend_omit_section_dynsym \
5072 _bfd_elf_omit_section_dynsym_all
5073 #define elf_backend_relocate_section \
5074 elfNN_ia64_relocate_section
5075 #define elf_backend_finish_dynamic_symbol \
5076 elfNN_ia64_finish_dynamic_symbol
5077 #define elf_backend_finish_dynamic_sections \
5078 elfNN_ia64_finish_dynamic_sections
5079 #define bfd_elfNN_bfd_final_link \
5080 elfNN_ia64_final_link
5082 #define bfd_elfNN_bfd_merge_private_bfd_data \
5083 elfNN_ia64_merge_private_bfd_data
5084 #define bfd_elfNN_bfd_set_private_flags \
5085 elfNN_ia64_set_private_flags
5086 #define bfd_elfNN_bfd_print_private_bfd_data \
5087 elfNN_ia64_print_private_bfd_data
5089 #define elf_backend_plt_readonly 1
5090 #define elf_backend_can_gc_sections 1
5091 #define elf_backend_want_plt_sym 0
5092 #define elf_backend_plt_alignment 5
5093 #define elf_backend_got_header_size 0
5094 #define elf_backend_want_got_plt 1
5095 #define elf_backend_may_use_rel_p 1
5096 #define elf_backend_may_use_rela_p 1
5097 #define elf_backend_default_use_rela_p 1
5098 #define elf_backend_want_dynbss 0
5099 #define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect
5100 #define elf_backend_hide_symbol elfNN_ia64_hash_hide_symbol
5101 #define elf_backend_fixup_symbol _bfd_elf_link_hash_fixup_symbol
5102 #define elf_backend_reloc_type_class elfNN_ia64_reloc_type_class
5103 #define elf_backend_rela_normal 1
5104 #define elf_backend_dtrel_excludes_plt 1
5105 #define elf_backend_special_sections elfNN_ia64_special_sections
5106 #define elf_backend_default_execstack 0
5108 /* FIXME: PR 290: The Intel C compiler generates SHT_IA_64_UNWIND with
5109 SHF_LINK_ORDER. But it doesn't set the sh_link or sh_info fields.
5110 We don't want to flood users with so many error messages. We turn
5111 off the warning for now. It will be turned on later when the Intel
5112 compiler is fixed. */
5113 #define elf_backend_link_order_error_handler ignore_errors
5115 #include "elfNN-target.h"
5117 /* HPUX-specific vectors. */
5119 #undef TARGET_LITTLE_SYM
5120 #undef TARGET_LITTLE_NAME
5121 #undef TARGET_BIG_SYM
5122 #define TARGET_BIG_SYM ia64_elfNN_hpux_be_vec
5123 #undef TARGET_BIG_NAME
5124 #define TARGET_BIG_NAME "elfNN-ia64-hpux-big"
5126 /* These are HP-UX specific functions. */
5128 #undef elf_backend_init_file_header
5129 #define elf_backend_init_file_header elfNN_hpux_init_file_header
5131 #undef elf_backend_section_from_bfd_section
5132 #define elf_backend_section_from_bfd_section elfNN_hpux_backend_section_from_bfd_section
5134 #undef elf_backend_symbol_processing
5135 #define elf_backend_symbol_processing elfNN_hpux_backend_symbol_processing
5137 #undef elf_backend_want_p_paddr_set_to_zero
5138 #define elf_backend_want_p_paddr_set_to_zero 1
5140 #undef ELF_COMMONPAGESIZE
5142 #define ELF_OSABI ELFOSABI_HPUX
5145 #define elfNN_bed elfNN_ia64_hpux_bed
5147 #include "elfNN-target.h"