1 /* IA-64 support for 64-bit ELF
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
4 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
27 #include "opcode/ia64.h"
31 #include "bfd_stdint.h"
32 #include "elfxx-ia64.h"
37 #define LOG_SECTION_ALIGN 3
41 #define LOG_SECTION_ALIGN 2
44 typedef struct bfd_hash_entry
*(*new_hash_entry_func
)
45 (struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *);
47 /* In dynamically (linker-) created sections, we generally need to keep track
48 of the place a symbol or expression got allocated to. This is done via hash
49 tables that store entries of the following type. */
51 struct elfNN_ia64_dyn_sym_info
53 /* The addend for which this entry is relevant. */
58 bfd_vma pltoff_offset
;
62 bfd_vma dtpmod_offset
;
63 bfd_vma dtprel_offset
;
65 /* The symbol table entry, if any, that this was derived from. */
66 struct elf_link_hash_entry
*h
;
68 /* Used to count non-got, non-plt relocations for delayed sizing
69 of relocation sections. */
70 struct elfNN_ia64_dyn_reloc_entry
72 struct elfNN_ia64_dyn_reloc_entry
*next
;
77 /* Is this reloc against readonly section? */
81 /* TRUE when the section contents have been updated. */
82 unsigned got_done
: 1;
83 unsigned fptr_done
: 1;
84 unsigned pltoff_done
: 1;
85 unsigned tprel_done
: 1;
86 unsigned dtpmod_done
: 1;
87 unsigned dtprel_done
: 1;
89 /* TRUE for the different kinds of linker data we want created. */
90 unsigned want_got
: 1;
91 unsigned want_gotx
: 1;
92 unsigned want_fptr
: 1;
93 unsigned want_ltoff_fptr
: 1;
94 unsigned want_plt
: 1;
95 unsigned want_plt2
: 1;
96 unsigned want_pltoff
: 1;
97 unsigned want_tprel
: 1;
98 unsigned want_dtpmod
: 1;
99 unsigned want_dtprel
: 1;
102 struct elfNN_ia64_local_hash_entry
106 /* The number of elements in elfNN_ia64_dyn_sym_info array. */
108 /* The number of sorted elements in elfNN_ia64_dyn_sym_info array. */
109 unsigned int sorted_count
;
110 /* The size of elfNN_ia64_dyn_sym_info array. */
112 /* The array of elfNN_ia64_dyn_sym_info. */
113 struct elfNN_ia64_dyn_sym_info
*info
;
115 /* TRUE if this hash entry's addends was translated for
116 SHF_MERGE optimization. */
117 unsigned sec_merge_done
: 1;
120 struct elfNN_ia64_link_hash_entry
122 struct elf_link_hash_entry root
;
123 /* The number of elements in elfNN_ia64_dyn_sym_info array. */
125 /* The number of sorted elements in elfNN_ia64_dyn_sym_info array. */
126 unsigned int sorted_count
;
127 /* The size of elfNN_ia64_dyn_sym_info array. */
129 /* The array of elfNN_ia64_dyn_sym_info. */
130 struct elfNN_ia64_dyn_sym_info
*info
;
133 struct elfNN_ia64_link_hash_table
135 /* The main hash table. */
136 struct elf_link_hash_table root
;
138 asection
*fptr_sec
; /* Function descriptor table (or NULL). */
139 asection
*rel_fptr_sec
; /* Dynamic relocation section for same. */
140 asection
*pltoff_sec
; /* Private descriptors for plt (or NULL). */
141 asection
*rel_pltoff_sec
; /* Dynamic relocation section for same. */
143 bfd_size_type minplt_entries
; /* Number of minplt entries. */
144 unsigned reltext
: 1; /* Are there relocs against readonly sections? */
145 unsigned self_dtpmod_done
: 1;/* Has self DTPMOD entry been finished? */
146 bfd_vma self_dtpmod_offset
; /* .got offset to self DTPMOD entry. */
147 /* There are maybe R_IA64_GPREL22 relocations, including those
148 optimized from R_IA64_LTOFF22X, against non-SHF_IA_64_SHORT
149 sections. We need to record those sections so that we can choose
150 a proper GP to cover all R_IA64_GPREL22 relocations. */
151 asection
*max_short_sec
; /* Maximum short output section. */
152 bfd_vma max_short_offset
; /* Maximum short offset. */
153 asection
*min_short_sec
; /* Minimum short output section. */
154 bfd_vma min_short_offset
; /* Minimum short offset. */
156 htab_t loc_hash_table
;
157 void *loc_hash_memory
;
160 struct elfNN_ia64_allocate_data
162 struct bfd_link_info
*info
;
164 bfd_boolean only_got
;
167 #define elfNN_ia64_hash_table(p) \
168 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
169 == IA64_ELF_DATA ? ((struct elfNN_ia64_link_hash_table *) ((p)->hash)) : NULL)
171 static struct elfNN_ia64_dyn_sym_info
* get_dyn_sym_info
172 (struct elfNN_ia64_link_hash_table
*ia64_info
,
173 struct elf_link_hash_entry
*h
,
174 bfd
*abfd
, const Elf_Internal_Rela
*rel
, bfd_boolean create
);
175 static bfd_boolean elfNN_ia64_dynamic_symbol_p
176 (struct elf_link_hash_entry
*h
, struct bfd_link_info
*info
, int);
177 static bfd_boolean elfNN_ia64_choose_gp
178 (bfd
*abfd
, struct bfd_link_info
*info
, bfd_boolean final
);
179 static void elfNN_ia64_dyn_sym_traverse
180 (struct elfNN_ia64_link_hash_table
*ia64_info
,
181 bfd_boolean (*func
) (struct elfNN_ia64_dyn_sym_info
*, void *),
183 static bfd_boolean allocate_global_data_got
184 (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
);
185 static bfd_boolean allocate_global_fptr_got
186 (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
);
187 static bfd_boolean allocate_local_got
188 (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
);
189 static bfd_boolean elfNN_ia64_hpux_vec
190 (const bfd_target
*vec
);
191 static bfd_boolean allocate_dynrel_entries
192 (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
);
193 static asection
*get_pltoff
194 (bfd
*abfd
, struct bfd_link_info
*info
,
195 struct elfNN_ia64_link_hash_table
*ia64_info
);
197 /* ia64-specific relocation. */
199 /* Given a ELF reloc, return the matching HOWTO structure. */
202 elfNN_ia64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
204 Elf_Internal_Rela
*elf_reloc
)
207 = ia64_elf_lookup_howto ((unsigned int) ELFNN_R_TYPE (elf_reloc
->r_info
));
210 #define PLT_HEADER_SIZE (3 * 16)
211 #define PLT_MIN_ENTRY_SIZE (1 * 16)
212 #define PLT_FULL_ENTRY_SIZE (2 * 16)
213 #define PLT_RESERVED_WORDS 3
215 static const bfd_byte plt_header
[PLT_HEADER_SIZE
] =
217 0x0b, 0x10, 0x00, 0x1c, 0x00, 0x21, /* [MMI] mov r2=r14;; */
218 0xe0, 0x00, 0x08, 0x00, 0x48, 0x00, /* addl r14=0,r2 */
219 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
220 0x0b, 0x80, 0x20, 0x1c, 0x18, 0x14, /* [MMI] ld8 r16=[r14],8;; */
221 0x10, 0x41, 0x38, 0x30, 0x28, 0x00, /* ld8 r17=[r14],8 */
222 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
223 0x11, 0x08, 0x00, 0x1c, 0x18, 0x10, /* [MIB] ld8 r1=[r14] */
224 0x60, 0x88, 0x04, 0x80, 0x03, 0x00, /* mov b6=r17 */
225 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
228 static const bfd_byte plt_min_entry
[PLT_MIN_ENTRY_SIZE
] =
230 0x11, 0x78, 0x00, 0x00, 0x00, 0x24, /* [MIB] mov r15=0 */
231 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, /* nop.i 0x0 */
232 0x00, 0x00, 0x00, 0x40 /* br.few 0 <PLT0>;; */
235 static const bfd_byte plt_full_entry
[PLT_FULL_ENTRY_SIZE
] =
237 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
238 0x00, 0x41, 0x3c, 0x70, 0x29, 0xc0, /* ld8.acq r16=[r15],8*/
239 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
240 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
241 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
242 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
245 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
247 static const bfd_byte oor_brl
[16] =
249 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
250 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;; */
251 0x00, 0x00, 0x00, 0xc0
254 static const bfd_byte oor_ip
[48] =
256 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
257 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, /* movl r15=0 */
258 0x01, 0x00, 0x00, 0x60,
259 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MII] nop.m 0 */
260 0x00, 0x01, 0x00, 0x60, 0x00, 0x00, /* mov r16=ip;; */
261 0xf2, 0x80, 0x00, 0x80, /* add r16=r15,r16;; */
262 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MIB] nop.m 0 */
263 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
264 0x60, 0x00, 0x80, 0x00 /* br b6;; */
267 static size_t oor_branch_size
= sizeof (oor_brl
);
270 bfd_elfNN_ia64_after_parse (int itanium
)
272 oor_branch_size
= itanium
? sizeof (oor_ip
) : sizeof (oor_brl
);
276 /* Rename some of the generic section flags to better document how they
278 #define skip_relax_pass_0 sec_flg0
279 #define skip_relax_pass_1 sec_flg1
281 /* These functions do relaxation for IA-64 ELF. */
284 elfNN_ia64_update_short_info (asection
*sec
, bfd_vma offset
,
285 struct elfNN_ia64_link_hash_table
*ia64_info
)
287 /* Skip ABS and SHF_IA_64_SHORT sections. */
288 if (sec
== bfd_abs_section_ptr
289 || (sec
->flags
& SEC_SMALL_DATA
) != 0)
292 if (!ia64_info
->min_short_sec
)
294 ia64_info
->max_short_sec
= sec
;
295 ia64_info
->max_short_offset
= offset
;
296 ia64_info
->min_short_sec
= sec
;
297 ia64_info
->min_short_offset
= offset
;
299 else if (sec
== ia64_info
->max_short_sec
300 && offset
> ia64_info
->max_short_offset
)
301 ia64_info
->max_short_offset
= offset
;
302 else if (sec
== ia64_info
->min_short_sec
303 && offset
< ia64_info
->min_short_offset
)
304 ia64_info
->min_short_offset
= offset
;
305 else if (sec
->output_section
->vma
306 > ia64_info
->max_short_sec
->vma
)
308 ia64_info
->max_short_sec
= sec
;
309 ia64_info
->max_short_offset
= offset
;
311 else if (sec
->output_section
->vma
312 < ia64_info
->min_short_sec
->vma
)
314 ia64_info
->min_short_sec
= sec
;
315 ia64_info
->min_short_offset
= offset
;
320 elfNN_ia64_relax_section (bfd
*abfd
, asection
*sec
,
321 struct bfd_link_info
*link_info
,
326 struct one_fixup
*next
;
332 Elf_Internal_Shdr
*symtab_hdr
;
333 Elf_Internal_Rela
*internal_relocs
;
334 Elf_Internal_Rela
*irel
, *irelend
;
336 Elf_Internal_Sym
*isymbuf
= NULL
;
337 struct elfNN_ia64_link_hash_table
*ia64_info
;
338 struct one_fixup
*fixups
= NULL
;
339 bfd_boolean changed_contents
= FALSE
;
340 bfd_boolean changed_relocs
= FALSE
;
341 bfd_boolean changed_got
= FALSE
;
342 bfd_boolean skip_relax_pass_0
= TRUE
;
343 bfd_boolean skip_relax_pass_1
= TRUE
;
346 /* Assume we're not going to change any sizes, and we'll only need
350 if (link_info
->relocatable
)
351 (*link_info
->callbacks
->einfo
)
352 (_("%P%F: --relax and -r may not be used together\n"));
354 /* Don't even try to relax for non-ELF outputs. */
355 if (!is_elf_hash_table (link_info
->hash
))
358 /* Nothing to do if there are no relocations or there is no need for
360 if ((sec
->flags
& SEC_RELOC
) == 0
361 || sec
->reloc_count
== 0
362 || (link_info
->relax_pass
== 0 && sec
->skip_relax_pass_0
)
363 || (link_info
->relax_pass
== 1 && sec
->skip_relax_pass_1
))
366 ia64_info
= elfNN_ia64_hash_table (link_info
);
367 if (ia64_info
== NULL
)
370 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
372 /* Load the relocations for this section. */
373 internal_relocs
= (_bfd_elf_link_read_relocs
374 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
375 link_info
->keep_memory
));
376 if (internal_relocs
== NULL
)
379 irelend
= internal_relocs
+ sec
->reloc_count
;
381 /* Get the section contents. */
382 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
383 contents
= elf_section_data (sec
)->this_hdr
.contents
;
386 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
390 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
392 unsigned long r_type
= ELFNN_R_TYPE (irel
->r_info
);
393 bfd_vma symaddr
, reladdr
, trampoff
, toff
, roff
;
397 bfd_boolean is_branch
;
398 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
403 case R_IA64_PCREL21B
:
404 case R_IA64_PCREL21BI
:
405 case R_IA64_PCREL21M
:
406 case R_IA64_PCREL21F
:
407 /* In pass 1, all br relaxations are done. We can skip it. */
408 if (link_info
->relax_pass
== 1)
410 skip_relax_pass_0
= FALSE
;
414 case R_IA64_PCREL60B
:
415 /* We can't optimize brl to br in pass 0 since br relaxations
416 will increase the code size. Defer it to pass 1. */
417 if (link_info
->relax_pass
== 0)
419 skip_relax_pass_1
= FALSE
;
426 /* Update max_short_sec/min_short_sec. */
428 case R_IA64_LTOFF22X
:
430 /* We can't relax ldx/mov in pass 0 since br relaxations will
431 increase the code size. Defer it to pass 1. */
432 if (link_info
->relax_pass
== 0)
434 skip_relax_pass_1
= FALSE
;
444 /* Get the value of the symbol referred to by the reloc. */
445 if (ELFNN_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
447 /* A local symbol. */
448 Elf_Internal_Sym
*isym
;
450 /* Read this BFD's local symbols. */
453 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
455 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
456 symtab_hdr
->sh_info
, 0,
462 isym
= isymbuf
+ ELFNN_R_SYM (irel
->r_info
);
463 if (isym
->st_shndx
== SHN_UNDEF
)
464 continue; /* We can't do anything with undefined symbols. */
465 else if (isym
->st_shndx
== SHN_ABS
)
466 tsec
= bfd_abs_section_ptr
;
467 else if (isym
->st_shndx
== SHN_COMMON
)
468 tsec
= bfd_com_section_ptr
;
469 else if (isym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
470 tsec
= bfd_com_section_ptr
;
472 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
474 toff
= isym
->st_value
;
475 dyn_i
= get_dyn_sym_info (ia64_info
, NULL
, abfd
, irel
, FALSE
);
476 symtype
= ELF_ST_TYPE (isym
->st_info
);
481 struct elf_link_hash_entry
*h
;
483 indx
= ELFNN_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
484 h
= elf_sym_hashes (abfd
)[indx
];
485 BFD_ASSERT (h
!= NULL
);
487 while (h
->root
.type
== bfd_link_hash_indirect
488 || h
->root
.type
== bfd_link_hash_warning
)
489 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
491 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, irel
, FALSE
);
493 /* For branches to dynamic symbols, we're interested instead
494 in a branch to the PLT entry. */
495 if (is_branch
&& dyn_i
&& dyn_i
->want_plt2
)
497 /* Internal branches shouldn't be sent to the PLT.
498 Leave this for now and we'll give an error later. */
499 if (r_type
!= R_IA64_PCREL21B
)
502 tsec
= ia64_info
->root
.splt
;
503 toff
= dyn_i
->plt2_offset
;
504 BFD_ASSERT (irel
->r_addend
== 0);
507 /* Can't do anything else with dynamic symbols. */
508 else if (elfNN_ia64_dynamic_symbol_p (h
, link_info
, r_type
))
513 /* We can't do anything with undefined symbols. */
514 if (h
->root
.type
== bfd_link_hash_undefined
515 || h
->root
.type
== bfd_link_hash_undefweak
)
518 tsec
= h
->root
.u
.def
.section
;
519 toff
= h
->root
.u
.def
.value
;
525 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
527 /* At this stage in linking, no SEC_MERGE symbol has been
528 adjusted, so all references to such symbols need to be
529 passed through _bfd_merged_section_offset. (Later, in
530 relocate_section, all SEC_MERGE symbols *except* for
531 section symbols have been adjusted.)
533 gas may reduce relocations against symbols in SEC_MERGE
534 sections to a relocation against the section symbol when
535 the original addend was zero. When the reloc is against
536 a section symbol we should include the addend in the
537 offset passed to _bfd_merged_section_offset, since the
538 location of interest is the original symbol. On the
539 other hand, an access to "sym+addend" where "sym" is not
540 a section symbol should not include the addend; Such an
541 access is presumed to be an offset from "sym"; The
542 location of interest is just "sym". */
543 if (symtype
== STT_SECTION
)
544 toff
+= irel
->r_addend
;
546 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
547 elf_section_data (tsec
)->sec_info
,
550 if (symtype
!= STT_SECTION
)
551 toff
+= irel
->r_addend
;
554 toff
+= irel
->r_addend
;
556 symaddr
= tsec
->output_section
->vma
+ tsec
->output_offset
+ toff
;
558 roff
= irel
->r_offset
;
562 bfd_signed_vma offset
;
564 reladdr
= (sec
->output_section
->vma
566 + roff
) & (bfd_vma
) -4;
568 /* The .plt section is aligned at 32byte and the .text section
569 is aligned at 64byte. The .text section is right after the
570 .plt section. After the first relaxation pass, linker may
571 increase the gap between the .plt and .text sections up
572 to 32byte. We assume linker will always insert 32byte
573 between the .plt and .text sections after the first
575 if (tsec
== ia64_info
->root
.splt
)
576 offset
= -0x1000000 + 32;
580 /* If the branch is in range, no need to do anything. */
581 if ((bfd_signed_vma
) (symaddr
- reladdr
) >= offset
582 && (bfd_signed_vma
) (symaddr
- reladdr
) <= 0x0FFFFF0)
584 /* If the 60-bit branch is in 21-bit range, optimize it. */
585 if (r_type
== R_IA64_PCREL60B
)
587 ia64_elf_relax_brl (contents
, roff
);
590 = ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
593 /* If the original relocation offset points to slot
594 1, change it to slot 2. */
595 if ((irel
->r_offset
& 3) == 1)
601 else if (r_type
== R_IA64_PCREL60B
)
603 else if (ia64_elf_relax_br (contents
, roff
))
606 = ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
609 /* Make the relocation offset point to slot 1. */
610 irel
->r_offset
= (irel
->r_offset
& ~((bfd_vma
) 0x3)) + 1;
614 /* We can't put a trampoline in a .init/.fini section. Issue
616 if (strcmp (sec
->output_section
->name
, ".init") == 0
617 || strcmp (sec
->output_section
->name
, ".fini") == 0)
619 (*_bfd_error_handler
)
620 (_("%B: Can't relax br at 0x%lx in section `%A'. Please use brl or indirect branch."),
621 sec
->owner
, sec
, (unsigned long) roff
);
622 bfd_set_error (bfd_error_bad_value
);
626 /* If the branch and target are in the same section, you've
627 got one honking big section and we can't help you unless
628 you are branching backwards. You'll get an error message
630 if (tsec
== sec
&& toff
> roff
)
633 /* Look for an existing fixup to this address. */
634 for (f
= fixups
; f
; f
= f
->next
)
635 if (f
->tsec
== tsec
&& f
->toff
== toff
)
640 /* Two alternatives: If it's a branch to a PLT entry, we can
641 make a copy of the FULL_PLT entry. Otherwise, we'll have
642 to use a `brl' insn to get where we're going. */
646 if (tsec
== ia64_info
->root
.splt
)
647 size
= sizeof (plt_full_entry
);
649 size
= oor_branch_size
;
651 /* Resize the current section to make room for the new branch. */
652 trampoff
= (sec
->size
+ 15) & (bfd_vma
) -16;
654 /* If trampoline is out of range, there is nothing we
656 offset
= trampoff
- (roff
& (bfd_vma
) -4);
657 if (offset
< -0x1000000 || offset
> 0x0FFFFF0)
660 amt
= trampoff
+ size
;
661 contents
= (bfd_byte
*) bfd_realloc (contents
, amt
);
662 if (contents
== NULL
)
666 if (tsec
== ia64_info
->root
.splt
)
668 memcpy (contents
+ trampoff
, plt_full_entry
, size
);
670 /* Hijack the old relocation for use as the PLTOFF reloc. */
671 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
673 irel
->r_offset
= trampoff
;
677 if (size
== sizeof (oor_ip
))
679 memcpy (contents
+ trampoff
, oor_ip
, size
);
680 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
682 irel
->r_addend
-= 16;
683 irel
->r_offset
= trampoff
+ 2;
687 memcpy (contents
+ trampoff
, oor_brl
, size
);
688 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
690 irel
->r_offset
= trampoff
+ 2;
695 /* Record the fixup so we don't do it again this section. */
696 f
= (struct one_fixup
*)
697 bfd_malloc ((bfd_size_type
) sizeof (*f
));
701 f
->trampoff
= trampoff
;
706 /* If trampoline is out of range, there is nothing we
708 offset
= f
->trampoff
- (roff
& (bfd_vma
) -4);
709 if (offset
< -0x1000000 || offset
> 0x0FFFFF0)
712 /* Nop out the reloc, since we're finalizing things here. */
713 irel
->r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
716 /* Fix up the existing branch to hit the trampoline. */
717 if (ia64_elf_install_value (contents
+ roff
, offset
, r_type
)
721 changed_contents
= TRUE
;
722 changed_relocs
= TRUE
;
729 bfd
*obfd
= sec
->output_section
->owner
;
730 gp
= _bfd_get_gp_value (obfd
);
733 if (!elfNN_ia64_choose_gp (obfd
, link_info
, FALSE
))
735 gp
= _bfd_get_gp_value (obfd
);
739 /* If the data is out of range, do nothing. */
740 if ((bfd_signed_vma
) (symaddr
- gp
) >= 0x200000
741 ||(bfd_signed_vma
) (symaddr
- gp
) < -0x200000)
744 if (r_type
== R_IA64_GPREL22
)
745 elfNN_ia64_update_short_info (tsec
->output_section
,
746 tsec
->output_offset
+ toff
,
748 else if (r_type
== R_IA64_LTOFF22X
)
750 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
752 changed_relocs
= TRUE
;
753 if (dyn_i
->want_gotx
)
755 dyn_i
->want_gotx
= 0;
756 changed_got
|= !dyn_i
->want_got
;
759 elfNN_ia64_update_short_info (tsec
->output_section
,
760 tsec
->output_offset
+ toff
,
765 ia64_elf_relax_ldxmov (contents
, roff
);
766 irel
->r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
767 changed_contents
= TRUE
;
768 changed_relocs
= TRUE
;
773 /* ??? If we created fixups, this may push the code segment large
774 enough that the data segment moves, which will change the GP.
775 Reset the GP so that we re-calculate next round. We need to
776 do this at the _beginning_ of the next round; now will not do. */
778 /* Clean up and go home. */
781 struct one_fixup
*f
= fixups
;
782 fixups
= fixups
->next
;
787 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
789 if (! link_info
->keep_memory
)
793 /* Cache the symbols for elf_link_input_bfd. */
794 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
799 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
801 if (!changed_contents
&& !link_info
->keep_memory
)
805 /* Cache the section contents for elf_link_input_bfd. */
806 elf_section_data (sec
)->this_hdr
.contents
= contents
;
810 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
813 free (internal_relocs
);
815 elf_section_data (sec
)->relocs
= internal_relocs
;
820 struct elfNN_ia64_allocate_data data
;
821 data
.info
= link_info
;
823 ia64_info
->self_dtpmod_offset
= (bfd_vma
) -1;
825 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_data_got
, &data
);
826 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_fptr_got
, &data
);
827 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_local_got
, &data
);
828 ia64_info
->root
.sgot
->size
= data
.ofs
;
830 if (ia64_info
->root
.dynamic_sections_created
831 && ia64_info
->root
.srelgot
!= NULL
)
833 /* Resize .rela.got. */
834 ia64_info
->root
.srelgot
->size
= 0;
835 if (link_info
->shared
836 && ia64_info
->self_dtpmod_offset
!= (bfd_vma
) -1)
837 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
838 data
.only_got
= TRUE
;
839 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_dynrel_entries
,
844 if (link_info
->relax_pass
== 0)
846 /* Pass 0 is only needed to relax br. */
847 sec
->skip_relax_pass_0
= skip_relax_pass_0
;
848 sec
->skip_relax_pass_1
= skip_relax_pass_1
;
851 *again
= changed_contents
|| changed_relocs
;
855 if (isymbuf
!= NULL
&& (unsigned char *) isymbuf
!= symtab_hdr
->contents
)
858 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
860 if (internal_relocs
!= NULL
861 && elf_section_data (sec
)->relocs
!= internal_relocs
)
862 free (internal_relocs
);
865 #undef skip_relax_pass_0
866 #undef skip_relax_pass_1
868 /* Return TRUE if NAME is an unwind table section name. */
870 static inline bfd_boolean
871 is_unwind_section_name (bfd
*abfd
, const char *name
)
873 if (elfNN_ia64_hpux_vec (abfd
->xvec
)
874 && !strcmp (name
, ELF_STRING_ia64_unwind_hdr
))
877 return ((CONST_STRNEQ (name
, ELF_STRING_ia64_unwind
)
878 && ! CONST_STRNEQ (name
, ELF_STRING_ia64_unwind_info
))
879 || CONST_STRNEQ (name
, ELF_STRING_ia64_unwind_once
));
882 /* Handle an IA-64 specific section when reading an object file. This
883 is called when bfd_section_from_shdr finds a section with an unknown
887 elfNN_ia64_section_from_shdr (bfd
*abfd
,
888 Elf_Internal_Shdr
*hdr
,
892 /* There ought to be a place to keep ELF backend specific flags, but
893 at the moment there isn't one. We just keep track of the
894 sections by their name, instead. Fortunately, the ABI gives
895 suggested names for all the MIPS specific sections, so we will
896 probably get away with this. */
897 switch (hdr
->sh_type
)
899 case SHT_IA_64_UNWIND
:
900 case SHT_IA_64_HP_OPT_ANOT
:
904 if (strcmp (name
, ELF_STRING_ia64_archext
) != 0)
912 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
918 /* Convert IA-64 specific section flags to bfd internal section flags. */
920 /* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
924 elfNN_ia64_section_flags (flagword
*flags
,
925 const Elf_Internal_Shdr
*hdr
)
927 if (hdr
->sh_flags
& SHF_IA_64_SHORT
)
928 *flags
|= SEC_SMALL_DATA
;
933 /* Set the correct type for an IA-64 ELF section. We do this by the
934 section name, which is a hack, but ought to work. */
937 elfNN_ia64_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
942 name
= bfd_get_section_name (abfd
, sec
);
944 if (is_unwind_section_name (abfd
, name
))
946 /* We don't have the sections numbered at this point, so sh_info
947 is set later, in elfNN_ia64_final_write_processing. */
948 hdr
->sh_type
= SHT_IA_64_UNWIND
;
949 hdr
->sh_flags
|= SHF_LINK_ORDER
;
951 else if (strcmp (name
, ELF_STRING_ia64_archext
) == 0)
952 hdr
->sh_type
= SHT_IA_64_EXT
;
953 else if (strcmp (name
, ".HP.opt_annot") == 0)
954 hdr
->sh_type
= SHT_IA_64_HP_OPT_ANOT
;
955 else if (strcmp (name
, ".reloc") == 0)
956 /* This is an ugly, but unfortunately necessary hack that is
957 needed when producing EFI binaries on IA-64. It tells
958 elf.c:elf_fake_sections() not to consider ".reloc" as a section
959 containing ELF relocation info. We need this hack in order to
960 be able to generate ELF binaries that can be translated into
961 EFI applications (which are essentially COFF objects). Those
962 files contain a COFF ".reloc" section inside an ELFNN object,
963 which would normally cause BFD to segfault because it would
964 attempt to interpret this section as containing relocation
965 entries for section "oc". With this hack enabled, ".reloc"
966 will be treated as a normal data section, which will avoid the
967 segfault. However, you won't be able to create an ELFNN binary
968 with a section named "oc" that needs relocations, but that's
969 the kind of ugly side-effects you get when detecting section
970 types based on their names... In practice, this limitation is
972 hdr
->sh_type
= SHT_PROGBITS
;
974 if (sec
->flags
& SEC_SMALL_DATA
)
975 hdr
->sh_flags
|= SHF_IA_64_SHORT
;
977 /* Some HP linkers look for the SHF_IA_64_HP_TLS flag instead of SHF_TLS. */
979 if (elfNN_ia64_hpux_vec (abfd
->xvec
) && (sec
->flags
& SHF_TLS
))
980 hdr
->sh_flags
|= SHF_IA_64_HP_TLS
;
985 /* The final processing done just before writing out an IA-64 ELF
989 elfNN_ia64_final_write_processing (bfd
*abfd
,
990 bfd_boolean linker ATTRIBUTE_UNUSED
)
992 Elf_Internal_Shdr
*hdr
;
995 for (s
= abfd
->sections
; s
; s
= s
->next
)
997 hdr
= &elf_section_data (s
)->this_hdr
;
998 switch (hdr
->sh_type
)
1000 case SHT_IA_64_UNWIND
:
1001 /* The IA-64 processor-specific ABI requires setting sh_link
1002 to the unwind section, whereas HP-UX requires sh_info to
1003 do so. For maximum compatibility, we'll set both for
1005 hdr
->sh_info
= hdr
->sh_link
;
1010 if (! elf_flags_init (abfd
))
1012 unsigned long flags
= 0;
1014 if (abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
)
1015 flags
|= EF_IA_64_BE
;
1016 if (bfd_get_mach (abfd
) == bfd_mach_ia64_elf64
)
1017 flags
|= EF_IA_64_ABI64
;
1019 elf_elfheader(abfd
)->e_flags
= flags
;
1020 elf_flags_init (abfd
) = TRUE
;
1024 /* Hook called by the linker routine which adds symbols from an object
1025 file. We use it to put .comm items in .sbss, and not .bss. */
1028 elfNN_ia64_add_symbol_hook (bfd
*abfd
,
1029 struct bfd_link_info
*info
,
1030 Elf_Internal_Sym
*sym
,
1031 const char **namep ATTRIBUTE_UNUSED
,
1032 flagword
*flagsp ATTRIBUTE_UNUSED
,
1036 if (sym
->st_shndx
== SHN_COMMON
1037 && !info
->relocatable
1038 && sym
->st_size
<= elf_gp_size (abfd
))
1040 /* Common symbols less than or equal to -G nn bytes are
1041 automatically put into .sbss. */
1043 asection
*scomm
= bfd_get_section_by_name (abfd
, ".scommon");
1047 scomm
= bfd_make_section_with_flags (abfd
, ".scommon",
1050 | SEC_LINKER_CREATED
));
1056 *valp
= sym
->st_size
;
1062 /* Return the number of additional phdrs we will need. */
1065 elfNN_ia64_additional_program_headers (bfd
*abfd
,
1066 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1071 /* See if we need a PT_IA_64_ARCHEXT segment. */
1072 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_archext
);
1073 if (s
&& (s
->flags
& SEC_LOAD
))
1076 /* Count how many PT_IA_64_UNWIND segments we need. */
1077 for (s
= abfd
->sections
; s
; s
= s
->next
)
1078 if (is_unwind_section_name (abfd
, s
->name
) && (s
->flags
& SEC_LOAD
))
1085 elfNN_ia64_modify_segment_map (bfd
*abfd
,
1086 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1088 struct elf_segment_map
*m
, **pm
;
1089 Elf_Internal_Shdr
*hdr
;
1092 /* If we need a PT_IA_64_ARCHEXT segment, it must come before
1093 all PT_LOAD segments. */
1094 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_archext
);
1095 if (s
&& (s
->flags
& SEC_LOAD
))
1097 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
1098 if (m
->p_type
== PT_IA_64_ARCHEXT
)
1102 m
= ((struct elf_segment_map
*)
1103 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *m
));
1107 m
->p_type
= PT_IA_64_ARCHEXT
;
1111 /* We want to put it after the PHDR and INTERP segments. */
1112 pm
= &elf_seg_map (abfd
);
1114 && ((*pm
)->p_type
== PT_PHDR
1115 || (*pm
)->p_type
== PT_INTERP
))
1123 /* Install PT_IA_64_UNWIND segments, if needed. */
1124 for (s
= abfd
->sections
; s
; s
= s
->next
)
1126 hdr
= &elf_section_data (s
)->this_hdr
;
1127 if (hdr
->sh_type
!= SHT_IA_64_UNWIND
)
1130 if (s
&& (s
->flags
& SEC_LOAD
))
1132 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
1133 if (m
->p_type
== PT_IA_64_UNWIND
)
1137 /* Look through all sections in the unwind segment
1138 for a match since there may be multiple sections
1140 for (i
= m
->count
- 1; i
>= 0; --i
)
1141 if (m
->sections
[i
] == s
)
1150 m
= ((struct elf_segment_map
*)
1151 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *m
));
1155 m
->p_type
= PT_IA_64_UNWIND
;
1160 /* We want to put it last. */
1161 pm
= &elf_seg_map (abfd
);
1172 /* Turn on PF_IA_64_NORECOV if needed. This involves traversing all of
1173 the input sections for each output section in the segment and testing
1174 for SHF_IA_64_NORECOV on each. */
1177 elfNN_ia64_modify_program_headers (bfd
*abfd
,
1178 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1180 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
1181 struct elf_segment_map
*m
;
1182 Elf_Internal_Phdr
*p
;
1184 for (p
= tdata
->phdr
, m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
, p
++)
1185 if (m
->p_type
== PT_LOAD
)
1188 for (i
= m
->count
- 1; i
>= 0; --i
)
1190 struct bfd_link_order
*order
= m
->sections
[i
]->map_head
.link_order
;
1192 while (order
!= NULL
)
1194 if (order
->type
== bfd_indirect_link_order
)
1196 asection
*is
= order
->u
.indirect
.section
;
1197 bfd_vma flags
= elf_section_data(is
)->this_hdr
.sh_flags
;
1198 if (flags
& SHF_IA_64_NORECOV
)
1200 p
->p_flags
|= PF_IA_64_NORECOV
;
1204 order
= order
->next
;
1213 /* According to the Tahoe assembler spec, all labels starting with a
1217 elfNN_ia64_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
1220 return name
[0] == '.';
1223 /* Should we do dynamic things to this symbol? */
1226 elfNN_ia64_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
1227 struct bfd_link_info
*info
, int r_type
)
1229 bfd_boolean ignore_protected
1230 = ((r_type
& 0xf8) == 0x40 /* FPTR relocs */
1231 || (r_type
& 0xf8) == 0x50); /* LTOFF_FPTR relocs */
1233 return _bfd_elf_dynamic_symbol_p (h
, info
, ignore_protected
);
1236 static struct bfd_hash_entry
*
1237 elfNN_ia64_new_elf_hash_entry (struct bfd_hash_entry
*entry
,
1238 struct bfd_hash_table
*table
,
1241 struct elfNN_ia64_link_hash_entry
*ret
;
1242 ret
= (struct elfNN_ia64_link_hash_entry
*) entry
;
1244 /* Allocate the structure if it has not already been allocated by a
1247 ret
= bfd_hash_allocate (table
, sizeof (*ret
));
1252 /* Call the allocation method of the superclass. */
1253 ret
= ((struct elfNN_ia64_link_hash_entry
*)
1254 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
1259 ret
->sorted_count
= 0;
1261 return (struct bfd_hash_entry
*) ret
;
1265 elfNN_ia64_hash_copy_indirect (struct bfd_link_info
*info
,
1266 struct elf_link_hash_entry
*xdir
,
1267 struct elf_link_hash_entry
*xind
)
1269 struct elfNN_ia64_link_hash_entry
*dir
, *ind
;
1271 dir
= (struct elfNN_ia64_link_hash_entry
*) xdir
;
1272 ind
= (struct elfNN_ia64_link_hash_entry
*) xind
;
1274 /* Copy down any references that we may have already seen to the
1275 symbol which just became indirect. */
1277 dir
->root
.ref_dynamic
|= ind
->root
.ref_dynamic
;
1278 dir
->root
.ref_regular
|= ind
->root
.ref_regular
;
1279 dir
->root
.ref_regular_nonweak
|= ind
->root
.ref_regular_nonweak
;
1280 dir
->root
.needs_plt
|= ind
->root
.needs_plt
;
1282 if (ind
->root
.root
.type
!= bfd_link_hash_indirect
)
1285 /* Copy over the got and plt data. This would have been done
1288 if (ind
->info
!= NULL
)
1290 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1296 dir
->info
= ind
->info
;
1297 dir
->count
= ind
->count
;
1298 dir
->sorted_count
= ind
->sorted_count
;
1299 dir
->size
= ind
->size
;
1303 ind
->sorted_count
= 0;
1306 /* Fix up the dyn_sym_info pointers to the global symbol. */
1307 for (count
= dir
->count
, dyn_i
= dir
->info
;
1310 dyn_i
->h
= &dir
->root
;
1313 /* Copy over the dynindx. */
1315 if (ind
->root
.dynindx
!= -1)
1317 if (dir
->root
.dynindx
!= -1)
1318 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1319 dir
->root
.dynstr_index
);
1320 dir
->root
.dynindx
= ind
->root
.dynindx
;
1321 dir
->root
.dynstr_index
= ind
->root
.dynstr_index
;
1322 ind
->root
.dynindx
= -1;
1323 ind
->root
.dynstr_index
= 0;
1328 elfNN_ia64_hash_hide_symbol (struct bfd_link_info
*info
,
1329 struct elf_link_hash_entry
*xh
,
1330 bfd_boolean force_local
)
1332 struct elfNN_ia64_link_hash_entry
*h
;
1333 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1336 h
= (struct elfNN_ia64_link_hash_entry
*)xh
;
1338 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
1340 for (count
= h
->count
, dyn_i
= h
->info
;
1344 dyn_i
->want_plt2
= 0;
1345 dyn_i
->want_plt
= 0;
1349 /* Compute a hash of a local hash entry. */
1352 elfNN_ia64_local_htab_hash (const void *ptr
)
1354 struct elfNN_ia64_local_hash_entry
*entry
1355 = (struct elfNN_ia64_local_hash_entry
*) ptr
;
1357 return ELF_LOCAL_SYMBOL_HASH (entry
->id
, entry
->r_sym
);
1360 /* Compare local hash entries. */
1363 elfNN_ia64_local_htab_eq (const void *ptr1
, const void *ptr2
)
1365 struct elfNN_ia64_local_hash_entry
*entry1
1366 = (struct elfNN_ia64_local_hash_entry
*) ptr1
;
1367 struct elfNN_ia64_local_hash_entry
*entry2
1368 = (struct elfNN_ia64_local_hash_entry
*) ptr2
;
1370 return entry1
->id
== entry2
->id
&& entry1
->r_sym
== entry2
->r_sym
;
1373 /* Create the derived linker hash table. The IA-64 ELF port uses this
1374 derived hash table to keep information specific to the IA-64 ElF
1375 linker (without using static variables). */
1377 static struct bfd_link_hash_table
*
1378 elfNN_ia64_hash_table_create (bfd
*abfd
)
1380 struct elfNN_ia64_link_hash_table
*ret
;
1382 ret
= bfd_zmalloc ((bfd_size_type
) sizeof (*ret
));
1386 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
1387 elfNN_ia64_new_elf_hash_entry
,
1388 sizeof (struct elfNN_ia64_link_hash_entry
),
1395 ret
->loc_hash_table
= htab_try_create (1024, elfNN_ia64_local_htab_hash
,
1396 elfNN_ia64_local_htab_eq
, NULL
);
1397 ret
->loc_hash_memory
= objalloc_create ();
1398 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1404 return &ret
->root
.root
;
1407 /* Free the global elfNN_ia64_dyn_sym_info array. */
1410 elfNN_ia64_global_dyn_info_free (void **xentry
,
1411 void * unused ATTRIBUTE_UNUSED
)
1413 struct elfNN_ia64_link_hash_entry
*entry
1414 = (struct elfNN_ia64_link_hash_entry
*) xentry
;
1421 entry
->sorted_count
= 0;
1428 /* Free the local elfNN_ia64_dyn_sym_info array. */
1431 elfNN_ia64_local_dyn_info_free (void **slot
,
1432 void * unused ATTRIBUTE_UNUSED
)
1434 struct elfNN_ia64_local_hash_entry
*entry
1435 = (struct elfNN_ia64_local_hash_entry
*) *slot
;
1442 entry
->sorted_count
= 0;
1449 /* Destroy IA-64 linker hash table. */
1452 elfNN_ia64_hash_table_free (struct bfd_link_hash_table
*hash
)
1454 struct elfNN_ia64_link_hash_table
*ia64_info
1455 = (struct elfNN_ia64_link_hash_table
*) hash
;
1456 if (ia64_info
->loc_hash_table
)
1458 htab_traverse (ia64_info
->loc_hash_table
,
1459 elfNN_ia64_local_dyn_info_free
, NULL
);
1460 htab_delete (ia64_info
->loc_hash_table
);
1462 if (ia64_info
->loc_hash_memory
)
1463 objalloc_free ((struct objalloc
*) ia64_info
->loc_hash_memory
);
1464 elf_link_hash_traverse (&ia64_info
->root
,
1465 elfNN_ia64_global_dyn_info_free
, NULL
);
1466 _bfd_elf_link_hash_table_free (hash
);
1469 /* Traverse both local and global hash tables. */
1471 struct elfNN_ia64_dyn_sym_traverse_data
1473 bfd_boolean (*func
) (struct elfNN_ia64_dyn_sym_info
*, void *);
1478 elfNN_ia64_global_dyn_sym_thunk (struct bfd_hash_entry
*xentry
,
1481 struct elfNN_ia64_link_hash_entry
*entry
1482 = (struct elfNN_ia64_link_hash_entry
*) xentry
;
1483 struct elfNN_ia64_dyn_sym_traverse_data
*data
1484 = (struct elfNN_ia64_dyn_sym_traverse_data
*) xdata
;
1485 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1488 for (count
= entry
->count
, dyn_i
= entry
->info
;
1491 if (! (*data
->func
) (dyn_i
, data
->data
))
1497 elfNN_ia64_local_dyn_sym_thunk (void **slot
, void * xdata
)
1499 struct elfNN_ia64_local_hash_entry
*entry
1500 = (struct elfNN_ia64_local_hash_entry
*) *slot
;
1501 struct elfNN_ia64_dyn_sym_traverse_data
*data
1502 = (struct elfNN_ia64_dyn_sym_traverse_data
*) xdata
;
1503 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1506 for (count
= entry
->count
, dyn_i
= entry
->info
;
1509 if (! (*data
->func
) (dyn_i
, data
->data
))
1515 elfNN_ia64_dyn_sym_traverse (struct elfNN_ia64_link_hash_table
*ia64_info
,
1516 bfd_boolean (*func
) (struct elfNN_ia64_dyn_sym_info
*, void *),
1519 struct elfNN_ia64_dyn_sym_traverse_data xdata
;
1524 elf_link_hash_traverse (&ia64_info
->root
,
1525 elfNN_ia64_global_dyn_sym_thunk
, &xdata
);
1526 htab_traverse (ia64_info
->loc_hash_table
,
1527 elfNN_ia64_local_dyn_sym_thunk
, &xdata
);
1531 elfNN_ia64_create_dynamic_sections (bfd
*abfd
,
1532 struct bfd_link_info
*info
)
1534 struct elfNN_ia64_link_hash_table
*ia64_info
;
1537 if (! _bfd_elf_create_dynamic_sections (abfd
, info
))
1540 ia64_info
= elfNN_ia64_hash_table (info
);
1541 if (ia64_info
== NULL
)
1545 flagword flags
= bfd_get_section_flags (abfd
, ia64_info
->root
.sgot
);
1546 bfd_set_section_flags (abfd
, ia64_info
->root
.sgot
,
1547 SEC_SMALL_DATA
| flags
);
1548 /* The .got section is always aligned at 8 bytes. */
1549 bfd_set_section_alignment (abfd
, ia64_info
->root
.sgot
, 3);
1552 if (!get_pltoff (abfd
, info
, ia64_info
))
1555 s
= bfd_make_section_anyway_with_flags (abfd
, ".rela.IA_64.pltoff",
1556 (SEC_ALLOC
| SEC_LOAD
1559 | SEC_LINKER_CREATED
1562 || !bfd_set_section_alignment (abfd
, s
, LOG_SECTION_ALIGN
))
1564 ia64_info
->rel_pltoff_sec
= s
;
1569 /* Find and/or create a hash entry for local symbol. */
1570 static struct elfNN_ia64_local_hash_entry
*
1571 get_local_sym_hash (struct elfNN_ia64_link_hash_table
*ia64_info
,
1572 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
1575 struct elfNN_ia64_local_hash_entry e
, *ret
;
1576 asection
*sec
= abfd
->sections
;
1577 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
1578 ELFNN_R_SYM (rel
->r_info
));
1582 e
.r_sym
= ELFNN_R_SYM (rel
->r_info
);
1583 slot
= htab_find_slot_with_hash (ia64_info
->loc_hash_table
, &e
, h
,
1584 create
? INSERT
: NO_INSERT
);
1590 return (struct elfNN_ia64_local_hash_entry
*) *slot
;
1592 ret
= (struct elfNN_ia64_local_hash_entry
*)
1593 objalloc_alloc ((struct objalloc
*) ia64_info
->loc_hash_memory
,
1594 sizeof (struct elfNN_ia64_local_hash_entry
));
1597 memset (ret
, 0, sizeof (*ret
));
1599 ret
->r_sym
= ELFNN_R_SYM (rel
->r_info
);
1605 /* Used to sort elfNN_ia64_dyn_sym_info array. */
1608 addend_compare (const void *xp
, const void *yp
)
1610 const struct elfNN_ia64_dyn_sym_info
*x
1611 = (const struct elfNN_ia64_dyn_sym_info
*) xp
;
1612 const struct elfNN_ia64_dyn_sym_info
*y
1613 = (const struct elfNN_ia64_dyn_sym_info
*) yp
;
1615 return x
->addend
< y
->addend
? -1 : x
->addend
> y
->addend
? 1 : 0;
1618 /* Sort elfNN_ia64_dyn_sym_info array and remove duplicates. */
1621 sort_dyn_sym_info (struct elfNN_ia64_dyn_sym_info
*info
,
1624 bfd_vma curr
, prev
, got_offset
;
1625 unsigned int i
, kept
, dupes
, diff
, dest
, src
, len
;
1627 qsort (info
, count
, sizeof (*info
), addend_compare
);
1629 /* Find the first duplicate. */
1630 prev
= info
[0].addend
;
1631 got_offset
= info
[0].got_offset
;
1632 for (i
= 1; i
< count
; i
++)
1634 curr
= info
[i
].addend
;
1637 /* For duplicates, make sure that GOT_OFFSET is valid. */
1638 if (got_offset
== (bfd_vma
) -1)
1639 got_offset
= info
[i
].got_offset
;
1642 got_offset
= info
[i
].got_offset
;
1646 /* We may move a block of elements to here. */
1649 /* Remove duplicates. */
1654 /* For duplicates, make sure that the kept one has a valid
1657 if (got_offset
!= (bfd_vma
) -1)
1658 info
[kept
].got_offset
= got_offset
;
1660 curr
= info
[i
].addend
;
1661 got_offset
= info
[i
].got_offset
;
1663 /* Move a block of elements whose first one is different from
1667 for (src
= i
+ 1; src
< count
; src
++)
1669 if (info
[src
].addend
!= curr
)
1671 /* For duplicates, make sure that GOT_OFFSET is
1673 if (got_offset
== (bfd_vma
) -1)
1674 got_offset
= info
[src
].got_offset
;
1677 /* Make sure that the kept one has a valid got_offset. */
1678 if (got_offset
!= (bfd_vma
) -1)
1679 info
[kept
].got_offset
= got_offset
;
1687 /* Find the next duplicate. SRC will be kept. */
1688 prev
= info
[src
].addend
;
1689 got_offset
= info
[src
].got_offset
;
1690 for (dupes
= src
+ 1; dupes
< count
; dupes
++)
1692 curr
= info
[dupes
].addend
;
1695 /* Make sure that got_offset is valid. */
1696 if (got_offset
== (bfd_vma
) -1)
1697 got_offset
= info
[dupes
].got_offset
;
1699 /* For duplicates, make sure that the kept one has
1700 a valid got_offset. */
1701 if (got_offset
!= (bfd_vma
) -1)
1702 info
[dupes
- 1].got_offset
= got_offset
;
1705 got_offset
= info
[dupes
].got_offset
;
1709 /* How much to move. */
1713 if (len
== 1 && dupes
< count
)
1715 /* If we only move 1 element, we combine it with the next
1716 one. There must be at least a duplicate. Find the
1717 next different one. */
1718 for (diff
= dupes
+ 1, src
++; diff
< count
; diff
++, src
++)
1720 if (info
[diff
].addend
!= curr
)
1722 /* Make sure that got_offset is valid. */
1723 if (got_offset
== (bfd_vma
) -1)
1724 got_offset
= info
[diff
].got_offset
;
1727 /* Makre sure that the last duplicated one has an valid
1729 BFD_ASSERT (curr
== prev
);
1730 if (got_offset
!= (bfd_vma
) -1)
1731 info
[diff
- 1].got_offset
= got_offset
;
1735 /* Find the next duplicate. Track the current valid
1737 prev
= info
[diff
].addend
;
1738 got_offset
= info
[diff
].got_offset
;
1739 for (dupes
= diff
+ 1; dupes
< count
; dupes
++)
1741 curr
= info
[dupes
].addend
;
1744 /* For duplicates, make sure that GOT_OFFSET
1746 if (got_offset
== (bfd_vma
) -1)
1747 got_offset
= info
[dupes
].got_offset
;
1750 got_offset
= info
[dupes
].got_offset
;
1755 len
= diff
- src
+ 1;
1760 memmove (&info
[dest
], &info
[src
], len
* sizeof (*info
));
1769 /* When we get here, either there is no duplicate at all or
1770 the only duplicate is the last element. */
1773 /* If the last element is a duplicate, make sure that the
1774 kept one has a valid got_offset. We also update count. */
1775 if (got_offset
!= (bfd_vma
) -1)
1776 info
[dest
- 1].got_offset
= got_offset
;
1784 /* Find and/or create a descriptor for dynamic symbol info. This will
1785 vary based on global or local symbol, and the addend to the reloc.
1787 We don't sort when inserting. Also, we sort and eliminate
1788 duplicates if there is an unsorted section. Typically, this will
1789 only happen once, because we do all insertions before lookups. We
1790 then use bsearch to do a lookup. This also allows lookups to be
1791 fast. So we have fast insertion (O(log N) due to duplicate check),
1792 fast lookup (O(log N)) and one sort (O(N log N) expected time).
1793 Previously, all lookups were O(N) because of the use of the linked
1794 list and also all insertions were O(N) because of the check for
1795 duplicates. There are some complications here because the array
1796 size grows occasionally, which may add an O(N) factor, but this
1797 should be rare. Also, we free the excess array allocation, which
1798 requires a copy which is O(N), but this only happens once. */
1800 static struct elfNN_ia64_dyn_sym_info
*
1801 get_dyn_sym_info (struct elfNN_ia64_link_hash_table
*ia64_info
,
1802 struct elf_link_hash_entry
*h
, bfd
*abfd
,
1803 const Elf_Internal_Rela
*rel
, bfd_boolean create
)
1805 struct elfNN_ia64_dyn_sym_info
**info_p
, *info
, *dyn_i
, key
;
1806 unsigned int *count_p
, *sorted_count_p
, *size_p
;
1807 unsigned int count
, sorted_count
, size
;
1808 bfd_vma addend
= rel
? rel
->r_addend
: 0;
1813 struct elfNN_ia64_link_hash_entry
*global_h
;
1815 global_h
= (struct elfNN_ia64_link_hash_entry
*) h
;
1816 info_p
= &global_h
->info
;
1817 count_p
= &global_h
->count
;
1818 sorted_count_p
= &global_h
->sorted_count
;
1819 size_p
= &global_h
->size
;
1823 struct elfNN_ia64_local_hash_entry
*loc_h
;
1825 loc_h
= get_local_sym_hash (ia64_info
, abfd
, rel
, create
);
1828 BFD_ASSERT (!create
);
1832 info_p
= &loc_h
->info
;
1833 count_p
= &loc_h
->count
;
1834 sorted_count_p
= &loc_h
->sorted_count
;
1835 size_p
= &loc_h
->size
;
1839 sorted_count
= *sorted_count_p
;
1844 /* When we create the array, we don't check for duplicates,
1845 except in the previously sorted section if one exists, and
1846 against the last inserted entry. This allows insertions to
1852 /* Try bsearch first on the sorted section. */
1853 key
.addend
= addend
;
1854 dyn_i
= bsearch (&key
, info
, sorted_count
,
1855 sizeof (*info
), addend_compare
);
1863 /* Do a quick check for the last inserted entry. */
1864 dyn_i
= info
+ count
- 1;
1865 if (dyn_i
->addend
== addend
)
1873 /* It is the very first element. We create the array of size
1876 amt
= size
* sizeof (*info
);
1877 info
= bfd_malloc (amt
);
1879 else if (size
<= count
)
1881 /* We double the array size every time when we reach the
1884 amt
= size
* sizeof (*info
);
1885 info
= bfd_realloc (info
, amt
);
1896 /* Append the new one to the array. */
1897 dyn_i
= info
+ count
;
1898 memset (dyn_i
, 0, sizeof (*dyn_i
));
1899 dyn_i
->got_offset
= (bfd_vma
) -1;
1900 dyn_i
->addend
= addend
;
1902 /* We increment count only since the new ones are unsorted and
1903 may have duplicate. */
1908 /* It is a lookup without insertion. Sort array if part of the
1909 array isn't sorted. */
1910 if (count
!= sorted_count
)
1912 count
= sort_dyn_sym_info (info
, count
);
1914 *sorted_count_p
= count
;
1917 /* Free unused memory. */
1920 amt
= count
* sizeof (*info
);
1921 info
= bfd_malloc (amt
);
1924 memcpy (info
, *info_p
, amt
);
1931 key
.addend
= addend
;
1932 dyn_i
= bsearch (&key
, info
, count
,
1933 sizeof (*info
), addend_compare
);
1940 get_got (bfd
*abfd
, struct bfd_link_info
*info
,
1941 struct elfNN_ia64_link_hash_table
*ia64_info
)
1946 got
= ia64_info
->root
.sgot
;
1951 dynobj
= ia64_info
->root
.dynobj
;
1953 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1954 if (!_bfd_elf_create_got_section (dynobj
, info
))
1957 got
= ia64_info
->root
.sgot
;
1959 /* The .got section is always aligned at 8 bytes. */
1960 if (!bfd_set_section_alignment (abfd
, got
, 3))
1963 flags
= bfd_get_section_flags (abfd
, got
);
1964 bfd_set_section_flags (abfd
, got
, SEC_SMALL_DATA
| flags
);
1970 /* Create function descriptor section (.opd). This section is called .opd
1971 because it contains "official procedure descriptors". The "official"
1972 refers to the fact that these descriptors are used when taking the address
1973 of a procedure, thus ensuring a unique address for each procedure. */
1976 get_fptr (bfd
*abfd
, struct bfd_link_info
*info
,
1977 struct elfNN_ia64_link_hash_table
*ia64_info
)
1982 fptr
= ia64_info
->fptr_sec
;
1985 dynobj
= ia64_info
->root
.dynobj
;
1987 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1989 fptr
= bfd_make_section_anyway_with_flags (dynobj
, ".opd",
1996 | SEC_LINKER_CREATED
));
1998 || !bfd_set_section_alignment (abfd
, fptr
, 4))
2004 ia64_info
->fptr_sec
= fptr
;
2009 fptr_rel
= bfd_make_section_anyway_with_flags (dynobj
, ".rela.opd",
2010 (SEC_ALLOC
| SEC_LOAD
2013 | SEC_LINKER_CREATED
2015 if (fptr_rel
== NULL
2016 || !bfd_set_section_alignment (abfd
, fptr_rel
,
2023 ia64_info
->rel_fptr_sec
= fptr_rel
;
2031 get_pltoff (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2032 struct elfNN_ia64_link_hash_table
*ia64_info
)
2037 pltoff
= ia64_info
->pltoff_sec
;
2040 dynobj
= ia64_info
->root
.dynobj
;
2042 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2044 pltoff
= bfd_make_section_anyway_with_flags (dynobj
,
2045 ELF_STRING_ia64_pltoff
,
2051 | SEC_LINKER_CREATED
));
2053 || !bfd_set_section_alignment (abfd
, pltoff
, 4))
2059 ia64_info
->pltoff_sec
= pltoff
;
2066 get_reloc_section (bfd
*abfd
,
2067 struct elfNN_ia64_link_hash_table
*ia64_info
,
2068 asection
*sec
, bfd_boolean create
)
2070 const char *srel_name
;
2074 srel_name
= (bfd_elf_string_from_elf_section
2075 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
2076 _bfd_elf_single_rel_hdr (sec
)->sh_name
));
2077 if (srel_name
== NULL
)
2080 dynobj
= ia64_info
->root
.dynobj
;
2082 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2084 srel
= bfd_get_linker_section (dynobj
, srel_name
);
2085 if (srel
== NULL
&& create
)
2087 srel
= bfd_make_section_anyway_with_flags (dynobj
, srel_name
,
2088 (SEC_ALLOC
| SEC_LOAD
2091 | SEC_LINKER_CREATED
2094 || !bfd_set_section_alignment (dynobj
, srel
,
2103 count_dyn_reloc (bfd
*abfd
, struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2104 asection
*srel
, int type
, bfd_boolean reltext
)
2106 struct elfNN_ia64_dyn_reloc_entry
*rent
;
2108 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2109 if (rent
->srel
== srel
&& rent
->type
== type
)
2114 rent
= ((struct elfNN_ia64_dyn_reloc_entry
*)
2115 bfd_alloc (abfd
, (bfd_size_type
) sizeof (*rent
)));
2119 rent
->next
= dyn_i
->reloc_entries
;
2123 dyn_i
->reloc_entries
= rent
;
2125 rent
->reltext
= reltext
;
2132 elfNN_ia64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
2134 const Elf_Internal_Rela
*relocs
)
2136 struct elfNN_ia64_link_hash_table
*ia64_info
;
2137 const Elf_Internal_Rela
*relend
;
2138 Elf_Internal_Shdr
*symtab_hdr
;
2139 const Elf_Internal_Rela
*rel
;
2140 asection
*got
, *fptr
, *srel
, *pltoff
;
2149 NEED_LTOFF_FPTR
= 128,
2155 struct elf_link_hash_entry
*h
;
2156 unsigned long r_symndx
;
2157 bfd_boolean maybe_dynamic
;
2159 if (info
->relocatable
)
2162 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2163 ia64_info
= elfNN_ia64_hash_table (info
);
2164 if (ia64_info
== NULL
)
2167 got
= fptr
= srel
= pltoff
= NULL
;
2169 relend
= relocs
+ sec
->reloc_count
;
2171 /* We scan relocations first to create dynamic relocation arrays. We
2172 modified get_dyn_sym_info to allow fast insertion and support fast
2173 lookup in the next loop. */
2174 for (rel
= relocs
; rel
< relend
; ++rel
)
2176 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
2177 if (r_symndx
>= symtab_hdr
->sh_info
)
2179 long indx
= r_symndx
- symtab_hdr
->sh_info
;
2180 h
= elf_sym_hashes (abfd
)[indx
];
2181 while (h
->root
.type
== bfd_link_hash_indirect
2182 || h
->root
.type
== bfd_link_hash_warning
)
2183 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2188 /* We can only get preliminary data on whether a symbol is
2189 locally or externally defined, as not all of the input files
2190 have yet been processed. Do something with what we know, as
2191 this may help reduce memory usage and processing time later. */
2192 maybe_dynamic
= (h
&& ((!info
->executable
2193 && (!SYMBOLIC_BIND (info
, h
)
2194 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
2196 || h
->root
.type
== bfd_link_hash_defweak
));
2199 switch (ELFNN_R_TYPE (rel
->r_info
))
2201 case R_IA64_TPREL64MSB
:
2202 case R_IA64_TPREL64LSB
:
2203 if (info
->shared
|| maybe_dynamic
)
2204 need_entry
= NEED_DYNREL
;
2207 case R_IA64_LTOFF_TPREL22
:
2208 need_entry
= NEED_TPREL
;
2210 info
->flags
|= DF_STATIC_TLS
;
2213 case R_IA64_DTPREL32MSB
:
2214 case R_IA64_DTPREL32LSB
:
2215 case R_IA64_DTPREL64MSB
:
2216 case R_IA64_DTPREL64LSB
:
2217 if (info
->shared
|| maybe_dynamic
)
2218 need_entry
= NEED_DYNREL
;
2221 case R_IA64_LTOFF_DTPREL22
:
2222 need_entry
= NEED_DTPREL
;
2225 case R_IA64_DTPMOD64MSB
:
2226 case R_IA64_DTPMOD64LSB
:
2227 if (info
->shared
|| maybe_dynamic
)
2228 need_entry
= NEED_DYNREL
;
2231 case R_IA64_LTOFF_DTPMOD22
:
2232 need_entry
= NEED_DTPMOD
;
2235 case R_IA64_LTOFF_FPTR22
:
2236 case R_IA64_LTOFF_FPTR64I
:
2237 case R_IA64_LTOFF_FPTR32MSB
:
2238 case R_IA64_LTOFF_FPTR32LSB
:
2239 case R_IA64_LTOFF_FPTR64MSB
:
2240 case R_IA64_LTOFF_FPTR64LSB
:
2241 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
2244 case R_IA64_FPTR64I
:
2245 case R_IA64_FPTR32MSB
:
2246 case R_IA64_FPTR32LSB
:
2247 case R_IA64_FPTR64MSB
:
2248 case R_IA64_FPTR64LSB
:
2249 if (info
->shared
|| h
)
2250 need_entry
= NEED_FPTR
| NEED_DYNREL
;
2252 need_entry
= NEED_FPTR
;
2255 case R_IA64_LTOFF22
:
2256 case R_IA64_LTOFF64I
:
2257 need_entry
= NEED_GOT
;
2260 case R_IA64_LTOFF22X
:
2261 need_entry
= NEED_GOTX
;
2264 case R_IA64_PLTOFF22
:
2265 case R_IA64_PLTOFF64I
:
2266 case R_IA64_PLTOFF64MSB
:
2267 case R_IA64_PLTOFF64LSB
:
2268 need_entry
= NEED_PLTOFF
;
2272 need_entry
|= NEED_MIN_PLT
;
2276 (*info
->callbacks
->warning
)
2277 (info
, _("@pltoff reloc against local symbol"), 0,
2278 abfd
, 0, (bfd_vma
) 0);
2282 case R_IA64_PCREL21B
:
2283 case R_IA64_PCREL60B
:
2284 /* Depending on where this symbol is defined, we may or may not
2285 need a full plt entry. Only skip if we know we'll not need
2286 the entry -- static or symbolic, and the symbol definition
2287 has already been seen. */
2288 if (maybe_dynamic
&& rel
->r_addend
== 0)
2289 need_entry
= NEED_FULL_PLT
;
2295 case R_IA64_DIR32MSB
:
2296 case R_IA64_DIR32LSB
:
2297 case R_IA64_DIR64MSB
:
2298 case R_IA64_DIR64LSB
:
2299 /* Shared objects will always need at least a REL relocation. */
2300 if (info
->shared
|| maybe_dynamic
)
2301 need_entry
= NEED_DYNREL
;
2304 case R_IA64_IPLTMSB
:
2305 case R_IA64_IPLTLSB
:
2306 /* Shared objects will always need at least a REL relocation. */
2307 if (info
->shared
|| maybe_dynamic
)
2308 need_entry
= NEED_DYNREL
;
2311 case R_IA64_PCREL22
:
2312 case R_IA64_PCREL64I
:
2313 case R_IA64_PCREL32MSB
:
2314 case R_IA64_PCREL32LSB
:
2315 case R_IA64_PCREL64MSB
:
2316 case R_IA64_PCREL64LSB
:
2318 need_entry
= NEED_DYNREL
;
2325 if ((need_entry
& NEED_FPTR
) != 0
2328 (*info
->callbacks
->warning
)
2329 (info
, _("non-zero addend in @fptr reloc"), 0,
2330 abfd
, 0, (bfd_vma
) 0);
2333 if (get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, TRUE
) == NULL
)
2337 /* Now, we only do lookup without insertion, which is very fast
2338 with the modified get_dyn_sym_info. */
2339 for (rel
= relocs
; rel
< relend
; ++rel
)
2341 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2342 int dynrel_type
= R_IA64_NONE
;
2344 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
2345 if (r_symndx
>= symtab_hdr
->sh_info
)
2347 /* We're dealing with a global symbol -- find its hash entry
2348 and mark it as being referenced. */
2349 long indx
= r_symndx
- symtab_hdr
->sh_info
;
2350 h
= elf_sym_hashes (abfd
)[indx
];
2351 while (h
->root
.type
== bfd_link_hash_indirect
2352 || h
->root
.type
== bfd_link_hash_warning
)
2353 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2355 /* PR15323, ref flags aren't set for references in the same
2357 h
->root
.non_ir_ref
= 1;
2363 /* We can only get preliminary data on whether a symbol is
2364 locally or externally defined, as not all of the input files
2365 have yet been processed. Do something with what we know, as
2366 this may help reduce memory usage and processing time later. */
2367 maybe_dynamic
= (h
&& ((!info
->executable
2368 && (!SYMBOLIC_BIND (info
, h
)
2369 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
2371 || h
->root
.type
== bfd_link_hash_defweak
));
2374 switch (ELFNN_R_TYPE (rel
->r_info
))
2376 case R_IA64_TPREL64MSB
:
2377 case R_IA64_TPREL64LSB
:
2378 if (info
->shared
|| maybe_dynamic
)
2379 need_entry
= NEED_DYNREL
;
2380 dynrel_type
= R_IA64_TPREL64LSB
;
2382 info
->flags
|= DF_STATIC_TLS
;
2385 case R_IA64_LTOFF_TPREL22
:
2386 need_entry
= NEED_TPREL
;
2388 info
->flags
|= DF_STATIC_TLS
;
2391 case R_IA64_DTPREL32MSB
:
2392 case R_IA64_DTPREL32LSB
:
2393 case R_IA64_DTPREL64MSB
:
2394 case R_IA64_DTPREL64LSB
:
2395 if (info
->shared
|| maybe_dynamic
)
2396 need_entry
= NEED_DYNREL
;
2397 dynrel_type
= R_IA64_DTPRELNNLSB
;
2400 case R_IA64_LTOFF_DTPREL22
:
2401 need_entry
= NEED_DTPREL
;
2404 case R_IA64_DTPMOD64MSB
:
2405 case R_IA64_DTPMOD64LSB
:
2406 if (info
->shared
|| maybe_dynamic
)
2407 need_entry
= NEED_DYNREL
;
2408 dynrel_type
= R_IA64_DTPMOD64LSB
;
2411 case R_IA64_LTOFF_DTPMOD22
:
2412 need_entry
= NEED_DTPMOD
;
2415 case R_IA64_LTOFF_FPTR22
:
2416 case R_IA64_LTOFF_FPTR64I
:
2417 case R_IA64_LTOFF_FPTR32MSB
:
2418 case R_IA64_LTOFF_FPTR32LSB
:
2419 case R_IA64_LTOFF_FPTR64MSB
:
2420 case R_IA64_LTOFF_FPTR64LSB
:
2421 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
2424 case R_IA64_FPTR64I
:
2425 case R_IA64_FPTR32MSB
:
2426 case R_IA64_FPTR32LSB
:
2427 case R_IA64_FPTR64MSB
:
2428 case R_IA64_FPTR64LSB
:
2429 if (info
->shared
|| h
)
2430 need_entry
= NEED_FPTR
| NEED_DYNREL
;
2432 need_entry
= NEED_FPTR
;
2433 dynrel_type
= R_IA64_FPTRNNLSB
;
2436 case R_IA64_LTOFF22
:
2437 case R_IA64_LTOFF64I
:
2438 need_entry
= NEED_GOT
;
2441 case R_IA64_LTOFF22X
:
2442 need_entry
= NEED_GOTX
;
2445 case R_IA64_PLTOFF22
:
2446 case R_IA64_PLTOFF64I
:
2447 case R_IA64_PLTOFF64MSB
:
2448 case R_IA64_PLTOFF64LSB
:
2449 need_entry
= NEED_PLTOFF
;
2453 need_entry
|= NEED_MIN_PLT
;
2457 case R_IA64_PCREL21B
:
2458 case R_IA64_PCREL60B
:
2459 /* Depending on where this symbol is defined, we may or may not
2460 need a full plt entry. Only skip if we know we'll not need
2461 the entry -- static or symbolic, and the symbol definition
2462 has already been seen. */
2463 if (maybe_dynamic
&& rel
->r_addend
== 0)
2464 need_entry
= NEED_FULL_PLT
;
2470 case R_IA64_DIR32MSB
:
2471 case R_IA64_DIR32LSB
:
2472 case R_IA64_DIR64MSB
:
2473 case R_IA64_DIR64LSB
:
2474 /* Shared objects will always need at least a REL relocation. */
2475 if (info
->shared
|| maybe_dynamic
)
2476 need_entry
= NEED_DYNREL
;
2477 dynrel_type
= R_IA64_DIRNNLSB
;
2480 case R_IA64_IPLTMSB
:
2481 case R_IA64_IPLTLSB
:
2482 /* Shared objects will always need at least a REL relocation. */
2483 if (info
->shared
|| maybe_dynamic
)
2484 need_entry
= NEED_DYNREL
;
2485 dynrel_type
= R_IA64_IPLTLSB
;
2488 case R_IA64_PCREL22
:
2489 case R_IA64_PCREL64I
:
2490 case R_IA64_PCREL32MSB
:
2491 case R_IA64_PCREL32LSB
:
2492 case R_IA64_PCREL64MSB
:
2493 case R_IA64_PCREL64LSB
:
2495 need_entry
= NEED_DYNREL
;
2496 dynrel_type
= R_IA64_PCRELNNLSB
;
2503 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, FALSE
);
2505 /* Record whether or not this is a local symbol. */
2508 /* Create what's needed. */
2509 if (need_entry
& (NEED_GOT
| NEED_GOTX
| NEED_TPREL
2510 | NEED_DTPMOD
| NEED_DTPREL
))
2514 got
= get_got (abfd
, info
, ia64_info
);
2518 if (need_entry
& NEED_GOT
)
2519 dyn_i
->want_got
= 1;
2520 if (need_entry
& NEED_GOTX
)
2521 dyn_i
->want_gotx
= 1;
2522 if (need_entry
& NEED_TPREL
)
2523 dyn_i
->want_tprel
= 1;
2524 if (need_entry
& NEED_DTPMOD
)
2525 dyn_i
->want_dtpmod
= 1;
2526 if (need_entry
& NEED_DTPREL
)
2527 dyn_i
->want_dtprel
= 1;
2529 if (need_entry
& NEED_FPTR
)
2533 fptr
= get_fptr (abfd
, info
, ia64_info
);
2538 /* FPTRs for shared libraries are allocated by the dynamic
2539 linker. Make sure this local symbol will appear in the
2540 dynamic symbol table. */
2541 if (!h
&& info
->shared
)
2543 if (! (bfd_elf_link_record_local_dynamic_symbol
2544 (info
, abfd
, (long) r_symndx
)))
2548 dyn_i
->want_fptr
= 1;
2550 if (need_entry
& NEED_LTOFF_FPTR
)
2551 dyn_i
->want_ltoff_fptr
= 1;
2552 if (need_entry
& (NEED_MIN_PLT
| NEED_FULL_PLT
))
2554 if (!ia64_info
->root
.dynobj
)
2555 ia64_info
->root
.dynobj
= abfd
;
2557 dyn_i
->want_plt
= 1;
2559 if (need_entry
& NEED_FULL_PLT
)
2560 dyn_i
->want_plt2
= 1;
2561 if (need_entry
& NEED_PLTOFF
)
2563 /* This is needed here, in case @pltoff is used in a non-shared
2567 pltoff
= get_pltoff (abfd
, info
, ia64_info
);
2572 dyn_i
->want_pltoff
= 1;
2574 if ((need_entry
& NEED_DYNREL
) && (sec
->flags
& SEC_ALLOC
))
2578 srel
= get_reloc_section (abfd
, ia64_info
, sec
, TRUE
);
2582 if (!count_dyn_reloc (abfd
, dyn_i
, srel
, dynrel_type
,
2583 (sec
->flags
& SEC_READONLY
) != 0))
2591 /* For cleanliness, and potentially faster dynamic loading, allocate
2592 external GOT entries first. */
2595 allocate_global_data_got (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2598 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2600 if ((dyn_i
->want_got
|| dyn_i
->want_gotx
)
2601 && ! dyn_i
->want_fptr
2602 && elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0))
2604 dyn_i
->got_offset
= x
->ofs
;
2607 if (dyn_i
->want_tprel
)
2609 dyn_i
->tprel_offset
= x
->ofs
;
2612 if (dyn_i
->want_dtpmod
)
2614 if (elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0))
2616 dyn_i
->dtpmod_offset
= x
->ofs
;
2621 struct elfNN_ia64_link_hash_table
*ia64_info
;
2623 ia64_info
= elfNN_ia64_hash_table (x
->info
);
2624 if (ia64_info
== NULL
)
2627 if (ia64_info
->self_dtpmod_offset
== (bfd_vma
) -1)
2629 ia64_info
->self_dtpmod_offset
= x
->ofs
;
2632 dyn_i
->dtpmod_offset
= ia64_info
->self_dtpmod_offset
;
2635 if (dyn_i
->want_dtprel
)
2637 dyn_i
->dtprel_offset
= x
->ofs
;
2643 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
2646 allocate_global_fptr_got (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2649 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2653 && elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, R_IA64_FPTRNNLSB
))
2655 dyn_i
->got_offset
= x
->ofs
;
2661 /* Lastly, allocate all the GOT entries for local data. */
2664 allocate_local_got (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2667 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2669 if ((dyn_i
->want_got
|| dyn_i
->want_gotx
)
2670 && !elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0))
2672 dyn_i
->got_offset
= x
->ofs
;
2678 /* Search for the index of a global symbol in it's defining object file. */
2681 global_sym_index (struct elf_link_hash_entry
*h
)
2683 struct elf_link_hash_entry
**p
;
2686 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
2687 || h
->root
.type
== bfd_link_hash_defweak
);
2689 obj
= h
->root
.u
.def
.section
->owner
;
2690 for (p
= elf_sym_hashes (obj
); *p
!= h
; ++p
)
2693 return p
- elf_sym_hashes (obj
) + elf_tdata (obj
)->symtab_hdr
.sh_info
;
2696 /* Allocate function descriptors. We can do these for every function
2697 in a main executable that is not exported. */
2700 allocate_fptr (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
)
2702 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2704 if (dyn_i
->want_fptr
)
2706 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2709 while (h
->root
.type
== bfd_link_hash_indirect
2710 || h
->root
.type
== bfd_link_hash_warning
)
2711 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2713 if (!x
->info
->executable
2715 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2716 || (h
->root
.type
!= bfd_link_hash_undefweak
2717 && h
->root
.type
!= bfd_link_hash_undefined
)))
2719 if (h
&& h
->dynindx
== -1)
2721 BFD_ASSERT ((h
->root
.type
== bfd_link_hash_defined
)
2722 || (h
->root
.type
== bfd_link_hash_defweak
));
2724 if (!bfd_elf_link_record_local_dynamic_symbol
2725 (x
->info
, h
->root
.u
.def
.section
->owner
,
2726 global_sym_index (h
)))
2730 dyn_i
->want_fptr
= 0;
2732 else if (h
== NULL
|| h
->dynindx
== -1)
2734 dyn_i
->fptr_offset
= x
->ofs
;
2738 dyn_i
->want_fptr
= 0;
2743 /* Allocate all the minimal PLT entries. */
2746 allocate_plt_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2749 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2751 if (dyn_i
->want_plt
)
2753 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2756 while (h
->root
.type
== bfd_link_hash_indirect
2757 || h
->root
.type
== bfd_link_hash_warning
)
2758 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2760 /* ??? Versioned symbols seem to lose NEEDS_PLT. */
2761 if (elfNN_ia64_dynamic_symbol_p (h
, x
->info
, 0))
2763 bfd_size_type offset
= x
->ofs
;
2765 offset
= PLT_HEADER_SIZE
;
2766 dyn_i
->plt_offset
= offset
;
2767 x
->ofs
= offset
+ PLT_MIN_ENTRY_SIZE
;
2769 dyn_i
->want_pltoff
= 1;
2773 dyn_i
->want_plt
= 0;
2774 dyn_i
->want_plt2
= 0;
2780 /* Allocate all the full PLT entries. */
2783 allocate_plt2_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2786 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2788 if (dyn_i
->want_plt2
)
2790 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2791 bfd_size_type ofs
= x
->ofs
;
2793 dyn_i
->plt2_offset
= ofs
;
2794 x
->ofs
= ofs
+ PLT_FULL_ENTRY_SIZE
;
2796 while (h
->root
.type
== bfd_link_hash_indirect
2797 || h
->root
.type
== bfd_link_hash_warning
)
2798 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2799 dyn_i
->h
->plt
.offset
= ofs
;
2804 /* Allocate all the PLTOFF entries requested by relocations and
2805 plt entries. We can't share space with allocated FPTR entries,
2806 because the latter are not necessarily addressable by the GP.
2807 ??? Relaxation might be able to determine that they are. */
2810 allocate_pltoff_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2813 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2815 if (dyn_i
->want_pltoff
)
2817 dyn_i
->pltoff_offset
= x
->ofs
;
2823 /* Allocate dynamic relocations for those symbols that turned out
2827 allocate_dynrel_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2830 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2831 struct elfNN_ia64_link_hash_table
*ia64_info
;
2832 struct elfNN_ia64_dyn_reloc_entry
*rent
;
2833 bfd_boolean dynamic_symbol
, shared
, resolved_zero
;
2835 ia64_info
= elfNN_ia64_hash_table (x
->info
);
2836 if (ia64_info
== NULL
)
2839 /* Note that this can't be used in relation to FPTR relocs below. */
2840 dynamic_symbol
= elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0);
2842 shared
= x
->info
->shared
;
2843 resolved_zero
= (dyn_i
->h
2844 && ELF_ST_VISIBILITY (dyn_i
->h
->other
)
2845 && dyn_i
->h
->root
.type
== bfd_link_hash_undefweak
);
2847 /* Take care of the GOT and PLT relocations. */
2850 && (dynamic_symbol
|| shared
)
2851 && (dyn_i
->want_got
|| dyn_i
->want_gotx
))
2852 || (dyn_i
->want_ltoff_fptr
2854 && dyn_i
->h
->dynindx
!= -1))
2856 if (!dyn_i
->want_ltoff_fptr
2859 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
2860 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
2862 if ((dynamic_symbol
|| shared
) && dyn_i
->want_tprel
)
2863 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
2864 if (dynamic_symbol
&& dyn_i
->want_dtpmod
)
2865 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
2866 if (dynamic_symbol
&& dyn_i
->want_dtprel
)
2867 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
2872 if (ia64_info
->rel_fptr_sec
&& dyn_i
->want_fptr
)
2874 if (dyn_i
->h
== NULL
|| dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
2875 ia64_info
->rel_fptr_sec
->size
+= sizeof (ElfNN_External_Rela
);
2878 if (!resolved_zero
&& dyn_i
->want_pltoff
)
2880 bfd_size_type t
= 0;
2882 /* Dynamic symbols get one IPLT relocation. Local symbols in
2883 shared libraries get two REL relocations. Local symbols in
2884 main applications get nothing. */
2886 t
= sizeof (ElfNN_External_Rela
);
2888 t
= 2 * sizeof (ElfNN_External_Rela
);
2890 ia64_info
->rel_pltoff_sec
->size
+= t
;
2893 /* Take care of the normal data relocations. */
2895 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2897 int count
= rent
->count
;
2901 case R_IA64_FPTR32LSB
:
2902 case R_IA64_FPTR64LSB
:
2903 /* Allocate one iff !want_fptr and not PIE, which by this point
2904 will be true only if we're actually allocating one statically
2905 in the main executable. Position independent executables
2906 need a relative reloc. */
2907 if (dyn_i
->want_fptr
&& !x
->info
->pie
)
2910 case R_IA64_PCREL32LSB
:
2911 case R_IA64_PCREL64LSB
:
2912 if (!dynamic_symbol
)
2915 case R_IA64_DIR32LSB
:
2916 case R_IA64_DIR64LSB
:
2917 if (!dynamic_symbol
&& !shared
)
2920 case R_IA64_IPLTLSB
:
2921 if (!dynamic_symbol
&& !shared
)
2923 /* Use two REL relocations for IPLT relocations
2924 against local symbols. */
2925 if (!dynamic_symbol
)
2928 case R_IA64_DTPREL32LSB
:
2929 case R_IA64_TPREL64LSB
:
2930 case R_IA64_DTPREL64LSB
:
2931 case R_IA64_DTPMOD64LSB
:
2937 ia64_info
->reltext
= 1;
2938 rent
->srel
->size
+= sizeof (ElfNN_External_Rela
) * count
;
2945 elfNN_ia64_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2946 struct elf_link_hash_entry
*h
)
2948 /* ??? Undefined symbols with PLT entries should be re-defined
2949 to be the PLT entry. */
2951 /* If this is a weak symbol, and there is a real definition, the
2952 processor independent code will have arranged for us to see the
2953 real definition first, and we can just use the same value. */
2954 if (h
->u
.weakdef
!= NULL
)
2956 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2957 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2958 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2959 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2963 /* If this is a reference to a symbol defined by a dynamic object which
2964 is not a function, we might allocate the symbol in our .dynbss section
2965 and allocate a COPY dynamic relocation.
2967 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2974 elfNN_ia64_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2975 struct bfd_link_info
*info
)
2977 struct elfNN_ia64_allocate_data data
;
2978 struct elfNN_ia64_link_hash_table
*ia64_info
;
2981 bfd_boolean relplt
= FALSE
;
2983 dynobj
= elf_hash_table(info
)->dynobj
;
2984 ia64_info
= elfNN_ia64_hash_table (info
);
2985 if (ia64_info
== NULL
)
2987 ia64_info
->self_dtpmod_offset
= (bfd_vma
) -1;
2988 BFD_ASSERT(dynobj
!= NULL
);
2991 /* Set the contents of the .interp section to the interpreter. */
2992 if (ia64_info
->root
.dynamic_sections_created
2993 && info
->executable
)
2995 sec
= bfd_get_linker_section (dynobj
, ".interp");
2996 BFD_ASSERT (sec
!= NULL
);
2997 sec
->contents
= (bfd_byte
*) ELF_DYNAMIC_INTERPRETER
;
2998 sec
->size
= strlen (ELF_DYNAMIC_INTERPRETER
) + 1;
3001 /* Allocate the GOT entries. */
3003 if (ia64_info
->root
.sgot
)
3006 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_data_got
, &data
);
3007 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_fptr_got
, &data
);
3008 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_local_got
, &data
);
3009 ia64_info
->root
.sgot
->size
= data
.ofs
;
3012 /* Allocate the FPTR entries. */
3014 if (ia64_info
->fptr_sec
)
3017 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_fptr
, &data
);
3018 ia64_info
->fptr_sec
->size
= data
.ofs
;
3021 /* Now that we've seen all of the input files, we can decide which
3022 symbols need plt entries. Allocate the minimal PLT entries first.
3023 We do this even though dynamic_sections_created may be FALSE, because
3024 this has the side-effect of clearing want_plt and want_plt2. */
3027 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_plt_entries
, &data
);
3029 ia64_info
->minplt_entries
= 0;
3032 ia64_info
->minplt_entries
3033 = (data
.ofs
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
3036 /* Align the pointer for the plt2 entries. */
3037 data
.ofs
= (data
.ofs
+ 31) & (bfd_vma
) -32;
3039 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_plt2_entries
, &data
);
3040 if (data
.ofs
!= 0 || ia64_info
->root
.dynamic_sections_created
)
3042 /* FIXME: we always reserve the memory for dynamic linker even if
3043 there are no PLT entries since dynamic linker may assume the
3044 reserved memory always exists. */
3046 BFD_ASSERT (ia64_info
->root
.dynamic_sections_created
);
3048 ia64_info
->root
.splt
->size
= data
.ofs
;
3050 /* If we've got a .plt, we need some extra memory for the dynamic
3051 linker. We stuff these in .got.plt. */
3052 sec
= bfd_get_linker_section (dynobj
, ".got.plt");
3053 sec
->size
= 8 * PLT_RESERVED_WORDS
;
3056 /* Allocate the PLTOFF entries. */
3058 if (ia64_info
->pltoff_sec
)
3061 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_pltoff_entries
, &data
);
3062 ia64_info
->pltoff_sec
->size
= data
.ofs
;
3065 if (ia64_info
->root
.dynamic_sections_created
)
3067 /* Allocate space for the dynamic relocations that turned out to be
3070 if (info
->shared
&& ia64_info
->self_dtpmod_offset
!= (bfd_vma
) -1)
3071 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
3072 data
.only_got
= FALSE
;
3073 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_dynrel_entries
, &data
);
3076 /* We have now determined the sizes of the various dynamic sections.
3077 Allocate memory for them. */
3078 for (sec
= dynobj
->sections
; sec
!= NULL
; sec
= sec
->next
)
3082 if (!(sec
->flags
& SEC_LINKER_CREATED
))
3085 /* If we don't need this section, strip it from the output file.
3086 There were several sections primarily related to dynamic
3087 linking that must be create before the linker maps input
3088 sections to output sections. The linker does that before
3089 bfd_elf_size_dynamic_sections is called, and it is that
3090 function which decides whether anything needs to go into
3093 strip
= (sec
->size
== 0);
3095 if (sec
== ia64_info
->root
.sgot
)
3097 else if (sec
== ia64_info
->root
.srelgot
)
3100 ia64_info
->root
.srelgot
= NULL
;
3102 /* We use the reloc_count field as a counter if we need to
3103 copy relocs into the output file. */
3104 sec
->reloc_count
= 0;
3106 else if (sec
== ia64_info
->fptr_sec
)
3109 ia64_info
->fptr_sec
= NULL
;
3111 else if (sec
== ia64_info
->rel_fptr_sec
)
3114 ia64_info
->rel_fptr_sec
= NULL
;
3116 /* We use the reloc_count field as a counter if we need to
3117 copy relocs into the output file. */
3118 sec
->reloc_count
= 0;
3120 else if (sec
== ia64_info
->root
.splt
)
3123 ia64_info
->root
.splt
= NULL
;
3125 else if (sec
== ia64_info
->pltoff_sec
)
3128 ia64_info
->pltoff_sec
= NULL
;
3130 else if (sec
== ia64_info
->rel_pltoff_sec
)
3133 ia64_info
->rel_pltoff_sec
= NULL
;
3137 /* We use the reloc_count field as a counter if we need to
3138 copy relocs into the output file. */
3139 sec
->reloc_count
= 0;
3146 /* It's OK to base decisions on the section name, because none
3147 of the dynobj section names depend upon the input files. */
3148 name
= bfd_get_section_name (dynobj
, sec
);
3150 if (strcmp (name
, ".got.plt") == 0)
3152 else if (CONST_STRNEQ (name
, ".rel"))
3156 /* We use the reloc_count field as a counter if we need to
3157 copy relocs into the output file. */
3158 sec
->reloc_count
= 0;
3166 sec
->flags
|= SEC_EXCLUDE
;
3169 /* Allocate memory for the section contents. */
3170 sec
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, sec
->size
);
3171 if (sec
->contents
== NULL
&& sec
->size
!= 0)
3176 if (elf_hash_table (info
)->dynamic_sections_created
)
3178 /* Add some entries to the .dynamic section. We fill in the values
3179 later (in finish_dynamic_sections) but we must add the entries now
3180 so that we get the correct size for the .dynamic section. */
3182 if (info
->executable
)
3184 /* The DT_DEBUG entry is filled in by the dynamic linker and used
3186 #define add_dynamic_entry(TAG, VAL) \
3187 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3189 if (!add_dynamic_entry (DT_DEBUG
, 0))
3193 if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE
, 0))
3195 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3200 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3201 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3202 || !add_dynamic_entry (DT_JMPREL
, 0))
3206 if (!add_dynamic_entry (DT_RELA
, 0)
3207 || !add_dynamic_entry (DT_RELASZ
, 0)
3208 || !add_dynamic_entry (DT_RELAENT
, sizeof (ElfNN_External_Rela
)))
3211 if (ia64_info
->reltext
)
3213 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3215 info
->flags
|= DF_TEXTREL
;
3219 /* ??? Perhaps force __gp local. */
3225 elfNN_ia64_install_dyn_reloc (bfd
*abfd
, struct bfd_link_info
*info
,
3226 asection
*sec
, asection
*srel
,
3227 bfd_vma offset
, unsigned int type
,
3228 long dynindx
, bfd_vma addend
)
3230 Elf_Internal_Rela outrel
;
3233 BFD_ASSERT (dynindx
!= -1);
3234 outrel
.r_info
= ELFNN_R_INFO (dynindx
, type
);
3235 outrel
.r_addend
= addend
;
3236 outrel
.r_offset
= _bfd_elf_section_offset (abfd
, info
, sec
, offset
);
3237 if (outrel
.r_offset
>= (bfd_vma
) -2)
3239 /* Run for the hills. We shouldn't be outputting a relocation
3240 for this. So do what everyone else does and output a no-op. */
3241 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
3242 outrel
.r_addend
= 0;
3243 outrel
.r_offset
= 0;
3246 outrel
.r_offset
+= sec
->output_section
->vma
+ sec
->output_offset
;
3248 loc
= srel
->contents
;
3249 loc
+= srel
->reloc_count
++ * sizeof (ElfNN_External_Rela
);
3250 bfd_elfNN_swap_reloca_out (abfd
, &outrel
, loc
);
3251 BFD_ASSERT (sizeof (ElfNN_External_Rela
) * srel
->reloc_count
<= srel
->size
);
3254 /* Store an entry for target address TARGET_ADDR in the linkage table
3255 and return the gp-relative address of the linkage table entry. */
3258 set_got_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3259 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3260 long dynindx
, bfd_vma addend
, bfd_vma value
,
3261 unsigned int dyn_r_type
)
3263 struct elfNN_ia64_link_hash_table
*ia64_info
;
3268 ia64_info
= elfNN_ia64_hash_table (info
);
3269 if (ia64_info
== NULL
)
3272 got_sec
= ia64_info
->root
.sgot
;
3276 case R_IA64_TPREL64LSB
:
3277 done
= dyn_i
->tprel_done
;
3278 dyn_i
->tprel_done
= TRUE
;
3279 got_offset
= dyn_i
->tprel_offset
;
3281 case R_IA64_DTPMOD64LSB
:
3282 if (dyn_i
->dtpmod_offset
!= ia64_info
->self_dtpmod_offset
)
3284 done
= dyn_i
->dtpmod_done
;
3285 dyn_i
->dtpmod_done
= TRUE
;
3289 done
= ia64_info
->self_dtpmod_done
;
3290 ia64_info
->self_dtpmod_done
= TRUE
;
3293 got_offset
= dyn_i
->dtpmod_offset
;
3295 case R_IA64_DTPREL32LSB
:
3296 case R_IA64_DTPREL64LSB
:
3297 done
= dyn_i
->dtprel_done
;
3298 dyn_i
->dtprel_done
= TRUE
;
3299 got_offset
= dyn_i
->dtprel_offset
;
3302 done
= dyn_i
->got_done
;
3303 dyn_i
->got_done
= TRUE
;
3304 got_offset
= dyn_i
->got_offset
;
3308 BFD_ASSERT ((got_offset
& 7) == 0);
3312 /* Store the target address in the linkage table entry. */
3313 bfd_put_64 (abfd
, value
, got_sec
->contents
+ got_offset
);
3315 /* Install a dynamic relocation if needed. */
3318 || ELF_ST_VISIBILITY (dyn_i
->h
->other
) == STV_DEFAULT
3319 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
3320 && dyn_r_type
!= R_IA64_DTPREL32LSB
3321 && dyn_r_type
!= R_IA64_DTPREL64LSB
)
3322 || elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, info
, dyn_r_type
)
3324 && (dyn_r_type
== R_IA64_FPTR32LSB
3325 || dyn_r_type
== R_IA64_FPTR64LSB
)))
3326 && (!dyn_i
->want_ltoff_fptr
3329 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
3332 && dyn_r_type
!= R_IA64_TPREL64LSB
3333 && dyn_r_type
!= R_IA64_DTPMOD64LSB
3334 && dyn_r_type
!= R_IA64_DTPREL32LSB
3335 && dyn_r_type
!= R_IA64_DTPREL64LSB
)
3337 dyn_r_type
= R_IA64_RELNNLSB
;
3342 if (bfd_big_endian (abfd
))
3346 case R_IA64_REL32LSB
:
3347 dyn_r_type
= R_IA64_REL32MSB
;
3349 case R_IA64_DIR32LSB
:
3350 dyn_r_type
= R_IA64_DIR32MSB
;
3352 case R_IA64_FPTR32LSB
:
3353 dyn_r_type
= R_IA64_FPTR32MSB
;
3355 case R_IA64_DTPREL32LSB
:
3356 dyn_r_type
= R_IA64_DTPREL32MSB
;
3358 case R_IA64_REL64LSB
:
3359 dyn_r_type
= R_IA64_REL64MSB
;
3361 case R_IA64_DIR64LSB
:
3362 dyn_r_type
= R_IA64_DIR64MSB
;
3364 case R_IA64_FPTR64LSB
:
3365 dyn_r_type
= R_IA64_FPTR64MSB
;
3367 case R_IA64_TPREL64LSB
:
3368 dyn_r_type
= R_IA64_TPREL64MSB
;
3370 case R_IA64_DTPMOD64LSB
:
3371 dyn_r_type
= R_IA64_DTPMOD64MSB
;
3373 case R_IA64_DTPREL64LSB
:
3374 dyn_r_type
= R_IA64_DTPREL64MSB
;
3382 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, got_sec
,
3383 ia64_info
->root
.srelgot
,
3384 got_offset
, dyn_r_type
,
3389 /* Return the address of the linkage table entry. */
3390 value
= (got_sec
->output_section
->vma
3391 + got_sec
->output_offset
3397 /* Fill in a function descriptor consisting of the function's code
3398 address and its global pointer. Return the descriptor's address. */
3401 set_fptr_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3402 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3405 struct elfNN_ia64_link_hash_table
*ia64_info
;
3408 ia64_info
= elfNN_ia64_hash_table (info
);
3409 if (ia64_info
== NULL
)
3412 fptr_sec
= ia64_info
->fptr_sec
;
3414 if (!dyn_i
->fptr_done
)
3416 dyn_i
->fptr_done
= 1;
3418 /* Fill in the function descriptor. */
3419 bfd_put_64 (abfd
, value
, fptr_sec
->contents
+ dyn_i
->fptr_offset
);
3420 bfd_put_64 (abfd
, _bfd_get_gp_value (abfd
),
3421 fptr_sec
->contents
+ dyn_i
->fptr_offset
+ 8);
3422 if (ia64_info
->rel_fptr_sec
)
3424 Elf_Internal_Rela outrel
;
3427 if (bfd_little_endian (abfd
))
3428 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_IPLTLSB
);
3430 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_IPLTMSB
);
3431 outrel
.r_addend
= value
;
3432 outrel
.r_offset
= (fptr_sec
->output_section
->vma
3433 + fptr_sec
->output_offset
3434 + dyn_i
->fptr_offset
);
3435 loc
= ia64_info
->rel_fptr_sec
->contents
;
3436 loc
+= ia64_info
->rel_fptr_sec
->reloc_count
++
3437 * sizeof (ElfNN_External_Rela
);
3438 bfd_elfNN_swap_reloca_out (abfd
, &outrel
, loc
);
3442 /* Return the descriptor's address. */
3443 value
= (fptr_sec
->output_section
->vma
3444 + fptr_sec
->output_offset
3445 + dyn_i
->fptr_offset
);
3450 /* Fill in a PLTOFF entry consisting of the function's code address
3451 and its global pointer. Return the descriptor's address. */
3454 set_pltoff_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3455 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3456 bfd_vma value
, bfd_boolean is_plt
)
3458 struct elfNN_ia64_link_hash_table
*ia64_info
;
3459 asection
*pltoff_sec
;
3461 ia64_info
= elfNN_ia64_hash_table (info
);
3462 if (ia64_info
== NULL
)
3465 pltoff_sec
= ia64_info
->pltoff_sec
;
3467 /* Don't do anything if this symbol uses a real PLT entry. In
3468 that case, we'll fill this in during finish_dynamic_symbol. */
3469 if ((! dyn_i
->want_plt
|| is_plt
)
3470 && !dyn_i
->pltoff_done
)
3472 bfd_vma gp
= _bfd_get_gp_value (abfd
);
3474 /* Fill in the function descriptor. */
3475 bfd_put_64 (abfd
, value
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
);
3476 bfd_put_64 (abfd
, gp
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
+ 8);
3478 /* Install dynamic relocations if needed. */
3482 || ELF_ST_VISIBILITY (dyn_i
->h
->other
) == STV_DEFAULT
3483 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
3485 unsigned int dyn_r_type
;
3487 if (bfd_big_endian (abfd
))
3488 dyn_r_type
= R_IA64_RELNNMSB
;
3490 dyn_r_type
= R_IA64_RELNNLSB
;
3492 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
3493 ia64_info
->rel_pltoff_sec
,
3494 dyn_i
->pltoff_offset
,
3495 dyn_r_type
, 0, value
);
3496 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
3497 ia64_info
->rel_pltoff_sec
,
3498 dyn_i
->pltoff_offset
+ ARCH_SIZE
/ 8,
3502 dyn_i
->pltoff_done
= 1;
3505 /* Return the descriptor's address. */
3506 value
= (pltoff_sec
->output_section
->vma
3507 + pltoff_sec
->output_offset
3508 + dyn_i
->pltoff_offset
);
3513 /* Return the base VMA address which should be subtracted from real addresses
3514 when resolving @tprel() relocation.
3515 Main program TLS (whose template starts at PT_TLS p_vaddr)
3516 is assigned offset round(2 * size of pointer, PT_TLS p_align). */
3519 elfNN_ia64_tprel_base (struct bfd_link_info
*info
)
3521 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3522 return tls_sec
->vma
- align_power ((bfd_vma
) ARCH_SIZE
/ 4,
3523 tls_sec
->alignment_power
);
3526 /* Return the base VMA address which should be subtracted from real addresses
3527 when resolving @dtprel() relocation.
3528 This is PT_TLS segment p_vaddr. */
3531 elfNN_ia64_dtprel_base (struct bfd_link_info
*info
)
3533 return elf_hash_table (info
)->tls_sec
->vma
;
3536 /* Called through qsort to sort the .IA_64.unwind section during a
3537 non-relocatable link. Set elfNN_ia64_unwind_entry_compare_bfd
3538 to the output bfd so we can do proper endianness frobbing. */
3540 static bfd
*elfNN_ia64_unwind_entry_compare_bfd
;
3543 elfNN_ia64_unwind_entry_compare (const void * a
, const void * b
)
3547 av
= bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd
, a
);
3548 bv
= bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd
, b
);
3550 return (av
< bv
? -1 : av
> bv
? 1 : 0);
3553 /* Make sure we've got ourselves a nice fat __gp value. */
3555 elfNN_ia64_choose_gp (bfd
*abfd
, struct bfd_link_info
*info
, bfd_boolean final
)
3557 bfd_vma min_vma
= (bfd_vma
) -1, max_vma
= 0;
3558 bfd_vma min_short_vma
= min_vma
, max_short_vma
= 0;
3559 struct elf_link_hash_entry
*gp
;
3562 struct elfNN_ia64_link_hash_table
*ia64_info
;
3564 ia64_info
= elfNN_ia64_hash_table (info
);
3565 if (ia64_info
== NULL
)
3568 /* Find the min and max vma of all sections marked short. Also collect
3569 min and max vma of any type, for use in selecting a nice gp. */
3570 for (os
= abfd
->sections
; os
; os
= os
->next
)
3574 if ((os
->flags
& SEC_ALLOC
) == 0)
3578 /* When this function is called from elfNN_ia64_final_link
3579 the correct value to use is os->size. When called from
3580 elfNN_ia64_relax_section we are in the middle of section
3581 sizing; some sections will already have os->size set, others
3582 will have os->size zero and os->rawsize the previous size. */
3583 hi
= os
->vma
+ (!final
&& os
->rawsize
? os
->rawsize
: os
->size
);
3591 if (os
->flags
& SEC_SMALL_DATA
)
3593 if (min_short_vma
> lo
)
3595 if (max_short_vma
< hi
)
3600 if (ia64_info
->min_short_sec
)
3603 > (ia64_info
->min_short_sec
->vma
3604 + ia64_info
->min_short_offset
))
3605 min_short_vma
= (ia64_info
->min_short_sec
->vma
3606 + ia64_info
->min_short_offset
);
3608 < (ia64_info
->max_short_sec
->vma
3609 + ia64_info
->max_short_offset
))
3610 max_short_vma
= (ia64_info
->max_short_sec
->vma
3611 + ia64_info
->max_short_offset
);
3614 /* See if the user wants to force a value. */
3615 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
3619 && (gp
->root
.type
== bfd_link_hash_defined
3620 || gp
->root
.type
== bfd_link_hash_defweak
))
3622 asection
*gp_sec
= gp
->root
.u
.def
.section
;
3623 gp_val
= (gp
->root
.u
.def
.value
3624 + gp_sec
->output_section
->vma
3625 + gp_sec
->output_offset
);
3629 /* Pick a sensible value. */
3631 if (ia64_info
->min_short_sec
)
3633 bfd_vma short_range
= max_short_vma
- min_short_vma
;
3635 /* If min_short_sec is set, pick one in the middle bewteen
3636 min_short_vma and max_short_vma. */
3637 if (short_range
>= 0x400000)
3639 gp_val
= min_short_vma
+ short_range
/ 2;
3643 asection
*got_sec
= ia64_info
->root
.sgot
;
3645 /* Start with just the address of the .got. */
3647 gp_val
= got_sec
->output_section
->vma
;
3648 else if (max_short_vma
!= 0)
3649 gp_val
= min_short_vma
;
3650 else if (max_vma
- min_vma
< 0x200000)
3653 gp_val
= max_vma
- 0x200000 + 8;
3656 /* If it is possible to address the entire image, but we
3657 don't with the choice above, adjust. */
3658 if (max_vma
- min_vma
< 0x400000
3659 && (max_vma
- gp_val
>= 0x200000
3660 || gp_val
- min_vma
> 0x200000))
3661 gp_val
= min_vma
+ 0x200000;
3662 else if (max_short_vma
!= 0)
3664 /* If we don't cover all the short data, adjust. */
3665 if (max_short_vma
- gp_val
>= 0x200000)
3666 gp_val
= min_short_vma
+ 0x200000;
3668 /* If we're addressing stuff past the end, adjust back. */
3669 if (gp_val
> max_vma
)
3670 gp_val
= max_vma
- 0x200000 + 8;
3674 /* Validate whether all SHF_IA_64_SHORT sections are within
3675 range of the chosen GP. */
3677 if (max_short_vma
!= 0)
3679 if (max_short_vma
- min_short_vma
>= 0x400000)
3682 (*_bfd_error_handler
)
3683 (_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
3684 bfd_get_filename (abfd
),
3685 (unsigned long) (max_short_vma
- min_short_vma
));
3688 else if ((gp_val
> min_short_vma
3689 && gp_val
- min_short_vma
> 0x200000)
3690 || (gp_val
< max_short_vma
3691 && max_short_vma
- gp_val
>= 0x200000))
3693 (*_bfd_error_handler
)
3694 (_("%s: __gp does not cover short data segment"),
3695 bfd_get_filename (abfd
));
3700 _bfd_set_gp_value (abfd
, gp_val
);
3706 elfNN_ia64_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
3708 struct elfNN_ia64_link_hash_table
*ia64_info
;
3709 asection
*unwind_output_sec
;
3711 ia64_info
= elfNN_ia64_hash_table (info
);
3712 if (ia64_info
== NULL
)
3715 /* Make sure we've got ourselves a nice fat __gp value. */
3716 if (!info
->relocatable
)
3719 struct elf_link_hash_entry
*gp
;
3721 /* We assume after gp is set, section size will only decrease. We
3722 need to adjust gp for it. */
3723 _bfd_set_gp_value (abfd
, 0);
3724 if (! elfNN_ia64_choose_gp (abfd
, info
, TRUE
))
3726 gp_val
= _bfd_get_gp_value (abfd
);
3728 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
3732 gp
->root
.type
= bfd_link_hash_defined
;
3733 gp
->root
.u
.def
.value
= gp_val
;
3734 gp
->root
.u
.def
.section
= bfd_abs_section_ptr
;
3738 /* If we're producing a final executable, we need to sort the contents
3739 of the .IA_64.unwind section. Force this section to be relocated
3740 into memory rather than written immediately to the output file. */
3741 unwind_output_sec
= NULL
;
3742 if (!info
->relocatable
)
3744 asection
*s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_unwind
);
3747 unwind_output_sec
= s
->output_section
;
3748 unwind_output_sec
->contents
3749 = bfd_malloc (unwind_output_sec
->size
);
3750 if (unwind_output_sec
->contents
== NULL
)
3755 /* Invoke the regular ELF backend linker to do all the work. */
3756 if (!bfd_elf_final_link (abfd
, info
))
3759 if (unwind_output_sec
)
3761 elfNN_ia64_unwind_entry_compare_bfd
= abfd
;
3762 qsort (unwind_output_sec
->contents
,
3763 (size_t) (unwind_output_sec
->size
/ 24),
3765 elfNN_ia64_unwind_entry_compare
);
3767 if (! bfd_set_section_contents (abfd
, unwind_output_sec
,
3768 unwind_output_sec
->contents
, (bfd_vma
) 0,
3769 unwind_output_sec
->size
))
3777 elfNN_ia64_relocate_section (bfd
*output_bfd
,
3778 struct bfd_link_info
*info
,
3780 asection
*input_section
,
3782 Elf_Internal_Rela
*relocs
,
3783 Elf_Internal_Sym
*local_syms
,
3784 asection
**local_sections
)
3786 struct elfNN_ia64_link_hash_table
*ia64_info
;
3787 Elf_Internal_Shdr
*symtab_hdr
;
3788 Elf_Internal_Rela
*rel
;
3789 Elf_Internal_Rela
*relend
;
3791 bfd_boolean ret_val
= TRUE
; /* for non-fatal errors */
3794 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3795 ia64_info
= elfNN_ia64_hash_table (info
);
3796 if (ia64_info
== NULL
)
3799 /* Infect various flags from the input section to the output section. */
3800 if (info
->relocatable
)
3804 flags
= elf_section_data(input_section
)->this_hdr
.sh_flags
;
3805 flags
&= SHF_IA_64_NORECOV
;
3807 elf_section_data(input_section
->output_section
)
3808 ->this_hdr
.sh_flags
|= flags
;
3811 gp_val
= _bfd_get_gp_value (output_bfd
);
3812 srel
= get_reloc_section (input_bfd
, ia64_info
, input_section
, FALSE
);
3815 relend
= relocs
+ input_section
->reloc_count
;
3816 for (; rel
< relend
; ++rel
)
3818 struct elf_link_hash_entry
*h
;
3819 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3820 bfd_reloc_status_type r
;
3821 reloc_howto_type
*howto
;
3822 unsigned long r_symndx
;
3823 Elf_Internal_Sym
*sym
;
3824 unsigned int r_type
;
3828 bfd_boolean dynamic_symbol_p
;
3829 bfd_boolean undef_weak_ref
;
3831 r_type
= ELFNN_R_TYPE (rel
->r_info
);
3832 if (r_type
> R_IA64_MAX_RELOC_CODE
)
3834 (*_bfd_error_handler
)
3835 (_("%B: unknown relocation type %d"),
3836 input_bfd
, (int) r_type
);
3837 bfd_set_error (bfd_error_bad_value
);
3842 howto
= ia64_elf_lookup_howto (r_type
);
3843 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
3847 undef_weak_ref
= FALSE
;
3849 if (r_symndx
< symtab_hdr
->sh_info
)
3851 /* Reloc against local symbol. */
3853 sym
= local_syms
+ r_symndx
;
3854 sym_sec
= local_sections
[r_symndx
];
3856 value
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &msec
, rel
);
3857 if (!info
->relocatable
3858 && (sym_sec
->flags
& SEC_MERGE
) != 0
3859 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3860 && sym_sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
3862 struct elfNN_ia64_local_hash_entry
*loc_h
;
3864 loc_h
= get_local_sym_hash (ia64_info
, input_bfd
, rel
, FALSE
);
3865 if (loc_h
&& ! loc_h
->sec_merge_done
)
3867 struct elfNN_ia64_dyn_sym_info
*dynent
;
3870 for (count
= loc_h
->count
, dynent
= loc_h
->info
;
3876 _bfd_merged_section_offset (output_bfd
, &msec
,
3877 elf_section_data (msec
)->
3881 dynent
->addend
-= sym
->st_value
;
3882 dynent
->addend
+= msec
->output_section
->vma
3883 + msec
->output_offset
3884 - sym_sec
->output_section
->vma
3885 - sym_sec
->output_offset
;
3888 /* We may have introduced duplicated entries. We need
3889 to remove them properly. */
3890 count
= sort_dyn_sym_info (loc_h
->info
, loc_h
->count
);
3891 if (count
!= loc_h
->count
)
3893 loc_h
->count
= count
;
3894 loc_h
->sorted_count
= count
;
3897 loc_h
->sec_merge_done
= 1;
3903 bfd_boolean unresolved_reloc
;
3905 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
3907 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3908 r_symndx
, symtab_hdr
, sym_hashes
,
3910 unresolved_reloc
, warned
);
3912 if (h
->root
.type
== bfd_link_hash_undefweak
)
3913 undef_weak_ref
= TRUE
;
3918 if (sym_sec
!= NULL
&& discarded_section (sym_sec
))
3919 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3920 rel
, 1, relend
, howto
, 0, contents
);
3922 if (info
->relocatable
)
3925 hit_addr
= contents
+ rel
->r_offset
;
3926 value
+= rel
->r_addend
;
3927 dynamic_symbol_p
= elfNN_ia64_dynamic_symbol_p (h
, info
, r_type
);
3938 case R_IA64_DIR32MSB
:
3939 case R_IA64_DIR32LSB
:
3940 case R_IA64_DIR64MSB
:
3941 case R_IA64_DIR64LSB
:
3942 /* Install a dynamic relocation for this reloc. */
3943 if ((dynamic_symbol_p
|| info
->shared
)
3944 && r_symndx
!= STN_UNDEF
3945 && (input_section
->flags
& SEC_ALLOC
) != 0)
3947 unsigned int dyn_r_type
;
3951 BFD_ASSERT (srel
!= NULL
);
3958 /* ??? People shouldn't be doing non-pic code in
3959 shared libraries nor dynamic executables. */
3960 (*_bfd_error_handler
)
3961 (_("%B: non-pic code with imm relocation against dynamic symbol `%s'"),
3963 h
? h
->root
.root
.string
3964 : bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3973 /* If we don't need dynamic symbol lookup, find a
3974 matching RELATIVE relocation. */
3975 dyn_r_type
= r_type
;
3976 if (dynamic_symbol_p
)
3978 dynindx
= h
->dynindx
;
3979 addend
= rel
->r_addend
;
3986 case R_IA64_DIR32MSB
:
3987 dyn_r_type
= R_IA64_REL32MSB
;
3989 case R_IA64_DIR32LSB
:
3990 dyn_r_type
= R_IA64_REL32LSB
;
3992 case R_IA64_DIR64MSB
:
3993 dyn_r_type
= R_IA64_REL64MSB
;
3995 case R_IA64_DIR64LSB
:
3996 dyn_r_type
= R_IA64_REL64LSB
;
4006 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4007 srel
, rel
->r_offset
, dyn_r_type
,
4012 case R_IA64_LTV32MSB
:
4013 case R_IA64_LTV32LSB
:
4014 case R_IA64_LTV64MSB
:
4015 case R_IA64_LTV64LSB
:
4016 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4019 case R_IA64_GPREL22
:
4020 case R_IA64_GPREL64I
:
4021 case R_IA64_GPREL32MSB
:
4022 case R_IA64_GPREL32LSB
:
4023 case R_IA64_GPREL64MSB
:
4024 case R_IA64_GPREL64LSB
:
4025 if (dynamic_symbol_p
)
4027 (*_bfd_error_handler
)
4028 (_("%B: @gprel relocation against dynamic symbol %s"),
4030 h
? h
->root
.root
.string
4031 : bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4037 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4040 case R_IA64_LTOFF22
:
4041 case R_IA64_LTOFF22X
:
4042 case R_IA64_LTOFF64I
:
4043 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4044 value
= set_got_entry (input_bfd
, info
, dyn_i
, (h
? h
->dynindx
: -1),
4045 rel
->r_addend
, value
, R_IA64_DIRNNLSB
);
4047 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4050 case R_IA64_PLTOFF22
:
4051 case R_IA64_PLTOFF64I
:
4052 case R_IA64_PLTOFF64MSB
:
4053 case R_IA64_PLTOFF64LSB
:
4054 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4055 value
= set_pltoff_entry (output_bfd
, info
, dyn_i
, value
, FALSE
);
4057 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4060 case R_IA64_FPTR64I
:
4061 case R_IA64_FPTR32MSB
:
4062 case R_IA64_FPTR32LSB
:
4063 case R_IA64_FPTR64MSB
:
4064 case R_IA64_FPTR64LSB
:
4065 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4066 if (dyn_i
->want_fptr
)
4068 if (!undef_weak_ref
)
4069 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
4071 if (!dyn_i
->want_fptr
|| info
->pie
)
4074 unsigned int dyn_r_type
= r_type
;
4075 bfd_vma addend
= rel
->r_addend
;
4077 /* Otherwise, we expect the dynamic linker to create
4080 if (dyn_i
->want_fptr
)
4082 if (r_type
== R_IA64_FPTR64I
)
4084 /* We can't represent this without a dynamic symbol.
4085 Adjust the relocation to be against an output
4086 section symbol, which are always present in the
4087 dynamic symbol table. */
4088 /* ??? People shouldn't be doing non-pic code in
4089 shared libraries. Hork. */
4090 (*_bfd_error_handler
)
4091 (_("%B: linking non-pic code in a position independent executable"),
4098 dyn_r_type
= r_type
+ R_IA64_RELNNLSB
- R_IA64_FPTRNNLSB
;
4102 if (h
->dynindx
!= -1)
4103 dynindx
= h
->dynindx
;
4105 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4106 (info
, h
->root
.u
.def
.section
->owner
,
4107 global_sym_index (h
)));
4112 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4113 (info
, input_bfd
, (long) r_symndx
));
4117 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4118 srel
, rel
->r_offset
, dyn_r_type
,
4122 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4125 case R_IA64_LTOFF_FPTR22
:
4126 case R_IA64_LTOFF_FPTR64I
:
4127 case R_IA64_LTOFF_FPTR32MSB
:
4128 case R_IA64_LTOFF_FPTR32LSB
:
4129 case R_IA64_LTOFF_FPTR64MSB
:
4130 case R_IA64_LTOFF_FPTR64LSB
:
4134 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4135 if (dyn_i
->want_fptr
)
4137 BFD_ASSERT (h
== NULL
|| h
->dynindx
== -1);
4138 if (!undef_weak_ref
)
4139 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
4144 /* Otherwise, we expect the dynamic linker to create
4148 if (h
->dynindx
!= -1)
4149 dynindx
= h
->dynindx
;
4151 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4152 (info
, h
->root
.u
.def
.section
->owner
,
4153 global_sym_index (h
)));
4156 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4157 (info
, input_bfd
, (long) r_symndx
));
4161 value
= set_got_entry (output_bfd
, info
, dyn_i
, dynindx
,
4162 rel
->r_addend
, value
, R_IA64_FPTRNNLSB
);
4164 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4168 case R_IA64_PCREL32MSB
:
4169 case R_IA64_PCREL32LSB
:
4170 case R_IA64_PCREL64MSB
:
4171 case R_IA64_PCREL64LSB
:
4172 /* Install a dynamic relocation for this reloc. */
4173 if (dynamic_symbol_p
&& r_symndx
!= STN_UNDEF
)
4175 BFD_ASSERT (srel
!= NULL
);
4177 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4178 srel
, rel
->r_offset
, r_type
,
4179 h
->dynindx
, rel
->r_addend
);
4183 case R_IA64_PCREL21B
:
4184 case R_IA64_PCREL60B
:
4185 /* We should have created a PLT entry for any dynamic symbol. */
4188 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, FALSE
);
4190 if (dyn_i
&& dyn_i
->want_plt2
)
4192 /* Should have caught this earlier. */
4193 BFD_ASSERT (rel
->r_addend
== 0);
4195 value
= (ia64_info
->root
.splt
->output_section
->vma
4196 + ia64_info
->root
.splt
->output_offset
4197 + dyn_i
->plt2_offset
);
4201 /* Since there's no PLT entry, Validate that this is
4203 BFD_ASSERT (undef_weak_ref
|| sym_sec
->output_section
!= NULL
);
4205 /* If the symbol is undef_weak, we shouldn't be trying
4206 to call it. There's every chance that we'd wind up
4207 with an out-of-range fixup here. Don't bother setting
4208 any value at all. */
4214 case R_IA64_PCREL21BI
:
4215 case R_IA64_PCREL21F
:
4216 case R_IA64_PCREL21M
:
4217 case R_IA64_PCREL22
:
4218 case R_IA64_PCREL64I
:
4219 /* The PCREL21BI reloc is specifically not intended for use with
4220 dynamic relocs. PCREL21F and PCREL21M are used for speculation
4221 fixup code, and thus probably ought not be dynamic. The
4222 PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs. */
4223 if (dynamic_symbol_p
)
4227 if (r_type
== R_IA64_PCREL21BI
)
4228 msg
= _("%B: @internal branch to dynamic symbol %s");
4229 else if (r_type
== R_IA64_PCREL21F
|| r_type
== R_IA64_PCREL21M
)
4230 msg
= _("%B: speculation fixup to dynamic symbol %s");
4232 msg
= _("%B: @pcrel relocation against dynamic symbol %s");
4233 (*_bfd_error_handler
) (msg
, input_bfd
,
4234 h
? h
->root
.root
.string
4235 : bfd_elf_sym_name (input_bfd
,
4245 /* Make pc-relative. */
4246 value
-= (input_section
->output_section
->vma
4247 + input_section
->output_offset
4248 + rel
->r_offset
) & ~ (bfd_vma
) 0x3;
4249 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4252 case R_IA64_SEGREL32MSB
:
4253 case R_IA64_SEGREL32LSB
:
4254 case R_IA64_SEGREL64MSB
:
4255 case R_IA64_SEGREL64LSB
:
4257 /* Find the segment that contains the output_section. */
4258 Elf_Internal_Phdr
*p
= _bfd_elf_find_segment_containing_section
4259 (output_bfd
, input_section
->output_section
);
4263 r
= bfd_reloc_notsupported
;
4267 /* The VMA of the segment is the vaddr of the associated
4269 if (value
> p
->p_vaddr
)
4270 value
-= p
->p_vaddr
;
4273 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4278 case R_IA64_SECREL32MSB
:
4279 case R_IA64_SECREL32LSB
:
4280 case R_IA64_SECREL64MSB
:
4281 case R_IA64_SECREL64LSB
:
4282 /* Make output-section relative to section where the symbol
4283 is defined. PR 475 */
4285 value
-= sym_sec
->output_section
->vma
;
4286 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4289 case R_IA64_IPLTMSB
:
4290 case R_IA64_IPLTLSB
:
4291 /* Install a dynamic relocation for this reloc. */
4292 if ((dynamic_symbol_p
|| info
->shared
)
4293 && (input_section
->flags
& SEC_ALLOC
) != 0)
4295 BFD_ASSERT (srel
!= NULL
);
4297 /* If we don't need dynamic symbol lookup, install two
4298 RELATIVE relocations. */
4299 if (!dynamic_symbol_p
)
4301 unsigned int dyn_r_type
;
4303 if (r_type
== R_IA64_IPLTMSB
)
4304 dyn_r_type
= R_IA64_REL64MSB
;
4306 dyn_r_type
= R_IA64_REL64LSB
;
4308 elfNN_ia64_install_dyn_reloc (output_bfd
, info
,
4310 srel
, rel
->r_offset
,
4311 dyn_r_type
, 0, value
);
4312 elfNN_ia64_install_dyn_reloc (output_bfd
, info
,
4314 srel
, rel
->r_offset
+ 8,
4315 dyn_r_type
, 0, gp_val
);
4318 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4319 srel
, rel
->r_offset
, r_type
,
4320 h
->dynindx
, rel
->r_addend
);
4323 if (r_type
== R_IA64_IPLTMSB
)
4324 r_type
= R_IA64_DIR64MSB
;
4326 r_type
= R_IA64_DIR64LSB
;
4327 ia64_elf_install_value (hit_addr
, value
, r_type
);
4328 r
= ia64_elf_install_value (hit_addr
+ 8, gp_val
, r_type
);
4331 case R_IA64_TPREL14
:
4332 case R_IA64_TPREL22
:
4333 case R_IA64_TPREL64I
:
4334 if (elf_hash_table (info
)->tls_sec
== NULL
)
4335 goto missing_tls_sec
;
4336 value
-= elfNN_ia64_tprel_base (info
);
4337 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4340 case R_IA64_DTPREL14
:
4341 case R_IA64_DTPREL22
:
4342 case R_IA64_DTPREL64I
:
4343 case R_IA64_DTPREL32LSB
:
4344 case R_IA64_DTPREL32MSB
:
4345 case R_IA64_DTPREL64LSB
:
4346 case R_IA64_DTPREL64MSB
:
4347 if (elf_hash_table (info
)->tls_sec
== NULL
)
4348 goto missing_tls_sec
;
4349 value
-= elfNN_ia64_dtprel_base (info
);
4350 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4353 case R_IA64_LTOFF_TPREL22
:
4354 case R_IA64_LTOFF_DTPMOD22
:
4355 case R_IA64_LTOFF_DTPREL22
:
4358 long dynindx
= h
? h
->dynindx
: -1;
4359 bfd_vma r_addend
= rel
->r_addend
;
4364 case R_IA64_LTOFF_TPREL22
:
4365 if (!dynamic_symbol_p
)
4367 if (elf_hash_table (info
)->tls_sec
== NULL
)
4368 goto missing_tls_sec
;
4370 value
-= elfNN_ia64_tprel_base (info
);
4373 r_addend
+= value
- elfNN_ia64_dtprel_base (info
);
4377 got_r_type
= R_IA64_TPREL64LSB
;
4379 case R_IA64_LTOFF_DTPMOD22
:
4380 if (!dynamic_symbol_p
&& !info
->shared
)
4382 got_r_type
= R_IA64_DTPMOD64LSB
;
4384 case R_IA64_LTOFF_DTPREL22
:
4385 if (!dynamic_symbol_p
)
4387 if (elf_hash_table (info
)->tls_sec
== NULL
)
4388 goto missing_tls_sec
;
4389 value
-= elfNN_ia64_dtprel_base (info
);
4391 got_r_type
= R_IA64_DTPRELNNLSB
;
4394 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4395 value
= set_got_entry (input_bfd
, info
, dyn_i
, dynindx
, r_addend
,
4398 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4403 r
= bfd_reloc_notsupported
;
4412 case bfd_reloc_undefined
:
4413 /* This can happen for global table relative relocs if
4414 __gp is undefined. This is a panic situation so we
4415 don't try to continue. */
4416 (*info
->callbacks
->undefined_symbol
)
4417 (info
, "__gp", input_bfd
, input_section
, rel
->r_offset
, 1);
4420 case bfd_reloc_notsupported
:
4425 name
= h
->root
.root
.string
;
4427 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4429 if (!(*info
->callbacks
->warning
) (info
, _("unsupported reloc"),
4431 input_section
, rel
->r_offset
))
4437 case bfd_reloc_dangerous
:
4438 case bfd_reloc_outofrange
:
4439 case bfd_reloc_overflow
:
4446 name
= h
->root
.root
.string
;
4448 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4453 case R_IA64_TPREL14
:
4454 case R_IA64_TPREL22
:
4455 case R_IA64_TPREL64I
:
4456 case R_IA64_DTPREL14
:
4457 case R_IA64_DTPREL22
:
4458 case R_IA64_DTPREL64I
:
4459 case R_IA64_DTPREL32LSB
:
4460 case R_IA64_DTPREL32MSB
:
4461 case R_IA64_DTPREL64LSB
:
4462 case R_IA64_DTPREL64MSB
:
4463 case R_IA64_LTOFF_TPREL22
:
4464 case R_IA64_LTOFF_DTPMOD22
:
4465 case R_IA64_LTOFF_DTPREL22
:
4466 (*_bfd_error_handler
)
4467 (_("%B: missing TLS section for relocation %s against `%s' at 0x%lx in section `%A'."),
4468 input_bfd
, input_section
, howto
->name
, name
,
4472 case R_IA64_PCREL21B
:
4473 case R_IA64_PCREL21BI
:
4474 case R_IA64_PCREL21M
:
4475 case R_IA64_PCREL21F
:
4476 if (is_elf_hash_table (info
->hash
))
4478 /* Relaxtion is always performed for ELF output.
4479 Overflow failures for those relocations mean
4480 that the section is too big to relax. */
4481 (*_bfd_error_handler
)
4482 (_("%B: Can't relax br (%s) to `%s' at 0x%lx in section `%A' with size 0x%lx (> 0x1000000)."),
4483 input_bfd
, input_section
, howto
->name
, name
,
4484 rel
->r_offset
, input_section
->size
);
4488 if (!(*info
->callbacks
->reloc_overflow
) (info
,
4510 elfNN_ia64_finish_dynamic_symbol (bfd
*output_bfd
,
4511 struct bfd_link_info
*info
,
4512 struct elf_link_hash_entry
*h
,
4513 Elf_Internal_Sym
*sym
)
4515 struct elfNN_ia64_link_hash_table
*ia64_info
;
4516 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
4518 ia64_info
= elfNN_ia64_hash_table (info
);
4519 if (ia64_info
== NULL
)
4522 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, FALSE
);
4524 /* Fill in the PLT data, if required. */
4525 if (dyn_i
&& dyn_i
->want_plt
)
4527 Elf_Internal_Rela outrel
;
4530 bfd_vma plt_addr
, pltoff_addr
, gp_val
, plt_index
;
4532 gp_val
= _bfd_get_gp_value (output_bfd
);
4534 /* Initialize the minimal PLT entry. */
4536 plt_index
= (dyn_i
->plt_offset
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
4537 plt_sec
= ia64_info
->root
.splt
;
4538 loc
= plt_sec
->contents
+ dyn_i
->plt_offset
;
4540 memcpy (loc
, plt_min_entry
, PLT_MIN_ENTRY_SIZE
);
4541 ia64_elf_install_value (loc
, plt_index
, R_IA64_IMM22
);
4542 ia64_elf_install_value (loc
+2, -dyn_i
->plt_offset
, R_IA64_PCREL21B
);
4544 plt_addr
= (plt_sec
->output_section
->vma
4545 + plt_sec
->output_offset
4546 + dyn_i
->plt_offset
);
4547 pltoff_addr
= set_pltoff_entry (output_bfd
, info
, dyn_i
, plt_addr
, TRUE
);
4549 /* Initialize the FULL PLT entry, if needed. */
4550 if (dyn_i
->want_plt2
)
4552 loc
= plt_sec
->contents
+ dyn_i
->plt2_offset
;
4554 memcpy (loc
, plt_full_entry
, PLT_FULL_ENTRY_SIZE
);
4555 ia64_elf_install_value (loc
, pltoff_addr
- gp_val
, R_IA64_IMM22
);
4557 /* Mark the symbol as undefined, rather than as defined in the
4558 plt section. Leave the value alone. */
4559 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
4560 first place. But perhaps elflink.c did some for us. */
4561 if (!h
->def_regular
)
4562 sym
->st_shndx
= SHN_UNDEF
;
4565 /* Create the dynamic relocation. */
4566 outrel
.r_offset
= pltoff_addr
;
4567 if (bfd_little_endian (output_bfd
))
4568 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_IA64_IPLTLSB
);
4570 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_IA64_IPLTMSB
);
4571 outrel
.r_addend
= 0;
4573 /* This is fun. In the .IA_64.pltoff section, we've got entries
4574 that correspond both to real PLT entries, and those that
4575 happened to resolve to local symbols but need to be created
4576 to satisfy @pltoff relocations. The .rela.IA_64.pltoff
4577 relocations for the real PLT should come at the end of the
4578 section, so that they can be indexed by plt entry at runtime.
4580 We emitted all of the relocations for the non-PLT @pltoff
4581 entries during relocate_section. So we can consider the
4582 existing sec->reloc_count to be the base of the array of
4585 loc
= ia64_info
->rel_pltoff_sec
->contents
;
4586 loc
+= ((ia64_info
->rel_pltoff_sec
->reloc_count
+ plt_index
)
4587 * sizeof (ElfNN_External_Rela
));
4588 bfd_elfNN_swap_reloca_out (output_bfd
, &outrel
, loc
);
4591 /* Mark some specially defined symbols as absolute. */
4592 if (h
== ia64_info
->root
.hdynamic
4593 || h
== ia64_info
->root
.hgot
4594 || h
== ia64_info
->root
.hplt
)
4595 sym
->st_shndx
= SHN_ABS
;
4601 elfNN_ia64_finish_dynamic_sections (bfd
*abfd
,
4602 struct bfd_link_info
*info
)
4604 struct elfNN_ia64_link_hash_table
*ia64_info
;
4607 ia64_info
= elfNN_ia64_hash_table (info
);
4608 if (ia64_info
== NULL
)
4611 dynobj
= ia64_info
->root
.dynobj
;
4613 if (elf_hash_table (info
)->dynamic_sections_created
)
4615 ElfNN_External_Dyn
*dyncon
, *dynconend
;
4616 asection
*sdyn
, *sgotplt
;
4619 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
4620 sgotplt
= bfd_get_linker_section (dynobj
, ".got.plt");
4621 BFD_ASSERT (sdyn
!= NULL
);
4622 dyncon
= (ElfNN_External_Dyn
*) sdyn
->contents
;
4623 dynconend
= (ElfNN_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4625 gp_val
= _bfd_get_gp_value (abfd
);
4627 for (; dyncon
< dynconend
; dyncon
++)
4629 Elf_Internal_Dyn dyn
;
4631 bfd_elfNN_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4636 dyn
.d_un
.d_ptr
= gp_val
;
4640 dyn
.d_un
.d_val
= (ia64_info
->minplt_entries
4641 * sizeof (ElfNN_External_Rela
));
4645 /* See the comment above in finish_dynamic_symbol. */
4646 dyn
.d_un
.d_ptr
= (ia64_info
->rel_pltoff_sec
->output_section
->vma
4647 + ia64_info
->rel_pltoff_sec
->output_offset
4648 + (ia64_info
->rel_pltoff_sec
->reloc_count
4649 * sizeof (ElfNN_External_Rela
)));
4652 case DT_IA_64_PLT_RESERVE
:
4653 dyn
.d_un
.d_ptr
= (sgotplt
->output_section
->vma
4654 + sgotplt
->output_offset
);
4658 /* Do not have RELASZ include JMPREL. This makes things
4659 easier on ld.so. This is not what the rest of BFD set up. */
4660 dyn
.d_un
.d_val
-= (ia64_info
->minplt_entries
4661 * sizeof (ElfNN_External_Rela
));
4665 bfd_elfNN_swap_dyn_out (abfd
, &dyn
, dyncon
);
4668 /* Initialize the PLT0 entry. */
4669 if (ia64_info
->root
.splt
)
4671 bfd_byte
*loc
= ia64_info
->root
.splt
->contents
;
4674 memcpy (loc
, plt_header
, PLT_HEADER_SIZE
);
4676 pltres
= (sgotplt
->output_section
->vma
4677 + sgotplt
->output_offset
4680 ia64_elf_install_value (loc
+1, pltres
, R_IA64_GPREL22
);
4687 /* ELF file flag handling: */
4689 /* Function to keep IA-64 specific file flags. */
4691 elfNN_ia64_set_private_flags (bfd
*abfd
, flagword flags
)
4693 BFD_ASSERT (!elf_flags_init (abfd
)
4694 || elf_elfheader (abfd
)->e_flags
== flags
);
4696 elf_elfheader (abfd
)->e_flags
= flags
;
4697 elf_flags_init (abfd
) = TRUE
;
4701 /* Merge backend specific data from an object file to the output
4702 object file when linking. */
4704 elfNN_ia64_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
4708 bfd_boolean ok
= TRUE
;
4710 /* Don't even pretend to support mixed-format linking. */
4711 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4712 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4715 in_flags
= elf_elfheader (ibfd
)->e_flags
;
4716 out_flags
= elf_elfheader (obfd
)->e_flags
;
4718 if (! elf_flags_init (obfd
))
4720 elf_flags_init (obfd
) = TRUE
;
4721 elf_elfheader (obfd
)->e_flags
= in_flags
;
4723 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
4724 && bfd_get_arch_info (obfd
)->the_default
)
4726 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
4727 bfd_get_mach (ibfd
));
4733 /* Check flag compatibility. */
4734 if (in_flags
== out_flags
)
4737 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
4738 if (!(in_flags
& EF_IA_64_REDUCEDFP
) && (out_flags
& EF_IA_64_REDUCEDFP
))
4739 elf_elfheader (obfd
)->e_flags
&= ~EF_IA_64_REDUCEDFP
;
4741 if ((in_flags
& EF_IA_64_TRAPNIL
) != (out_flags
& EF_IA_64_TRAPNIL
))
4743 (*_bfd_error_handler
)
4744 (_("%B: linking trap-on-NULL-dereference with non-trapping files"),
4747 bfd_set_error (bfd_error_bad_value
);
4750 if ((in_flags
& EF_IA_64_BE
) != (out_flags
& EF_IA_64_BE
))
4752 (*_bfd_error_handler
)
4753 (_("%B: linking big-endian files with little-endian files"),
4756 bfd_set_error (bfd_error_bad_value
);
4759 if ((in_flags
& EF_IA_64_ABI64
) != (out_flags
& EF_IA_64_ABI64
))
4761 (*_bfd_error_handler
)
4762 (_("%B: linking 64-bit files with 32-bit files"),
4765 bfd_set_error (bfd_error_bad_value
);
4768 if ((in_flags
& EF_IA_64_CONS_GP
) != (out_flags
& EF_IA_64_CONS_GP
))
4770 (*_bfd_error_handler
)
4771 (_("%B: linking constant-gp files with non-constant-gp files"),
4774 bfd_set_error (bfd_error_bad_value
);
4777 if ((in_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
)
4778 != (out_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
4780 (*_bfd_error_handler
)
4781 (_("%B: linking auto-pic files with non-auto-pic files"),
4784 bfd_set_error (bfd_error_bad_value
);
4792 elfNN_ia64_print_private_bfd_data (bfd
*abfd
, void * ptr
)
4794 FILE *file
= (FILE *) ptr
;
4795 flagword flags
= elf_elfheader (abfd
)->e_flags
;
4797 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
4799 fprintf (file
, "private flags = %s%s%s%s%s%s%s%s\n",
4800 (flags
& EF_IA_64_TRAPNIL
) ? "TRAPNIL, " : "",
4801 (flags
& EF_IA_64_EXT
) ? "EXT, " : "",
4802 (flags
& EF_IA_64_BE
) ? "BE, " : "LE, ",
4803 (flags
& EF_IA_64_REDUCEDFP
) ? "REDUCEDFP, " : "",
4804 (flags
& EF_IA_64_CONS_GP
) ? "CONS_GP, " : "",
4805 (flags
& EF_IA_64_NOFUNCDESC_CONS_GP
) ? "NOFUNCDESC_CONS_GP, " : "",
4806 (flags
& EF_IA_64_ABSOLUTE
) ? "ABSOLUTE, " : "",
4807 (flags
& EF_IA_64_ABI64
) ? "ABI64" : "ABI32");
4809 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
4813 static enum elf_reloc_type_class
4814 elfNN_ia64_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4815 const asection
*rel_sec ATTRIBUTE_UNUSED
,
4816 const Elf_Internal_Rela
*rela
)
4818 switch ((int) ELFNN_R_TYPE (rela
->r_info
))
4820 case R_IA64_REL32MSB
:
4821 case R_IA64_REL32LSB
:
4822 case R_IA64_REL64MSB
:
4823 case R_IA64_REL64LSB
:
4824 return reloc_class_relative
;
4825 case R_IA64_IPLTMSB
:
4826 case R_IA64_IPLTLSB
:
4827 return reloc_class_plt
;
4829 return reloc_class_copy
;
4831 return reloc_class_normal
;
4835 static const struct bfd_elf_special_section elfNN_ia64_special_sections
[] =
4837 { STRING_COMMA_LEN (".sbss"), -1, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_IA_64_SHORT
},
4838 { STRING_COMMA_LEN (".sdata"), -1, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_IA_64_SHORT
},
4839 { NULL
, 0, 0, 0, 0 }
4843 elfNN_ia64_object_p (bfd
*abfd
)
4846 asection
*group
, *unwi
, *unw
;
4849 char *unwi_name
, *unw_name
;
4852 if (abfd
->flags
& DYNAMIC
)
4855 /* Flags for fake group section. */
4856 flags
= (SEC_LINKER_CREATED
| SEC_GROUP
| SEC_LINK_ONCE
4859 /* We add a fake section group for each .gnu.linkonce.t.* section,
4860 which isn't in a section group, and its unwind sections. */
4861 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4863 if (elf_sec_group (sec
) == NULL
4864 && ((sec
->flags
& (SEC_LINK_ONCE
| SEC_CODE
| SEC_GROUP
))
4865 == (SEC_LINK_ONCE
| SEC_CODE
))
4866 && CONST_STRNEQ (sec
->name
, ".gnu.linkonce.t."))
4868 name
= sec
->name
+ 16;
4870 amt
= strlen (name
) + sizeof (".gnu.linkonce.ia64unwi.");
4871 unwi_name
= bfd_alloc (abfd
, amt
);
4875 strcpy (stpcpy (unwi_name
, ".gnu.linkonce.ia64unwi."), name
);
4876 unwi
= bfd_get_section_by_name (abfd
, unwi_name
);
4878 amt
= strlen (name
) + sizeof (".gnu.linkonce.ia64unw.");
4879 unw_name
= bfd_alloc (abfd
, amt
);
4883 strcpy (stpcpy (unw_name
, ".gnu.linkonce.ia64unw."), name
);
4884 unw
= bfd_get_section_by_name (abfd
, unw_name
);
4886 /* We need to create a fake group section for it and its
4888 group
= bfd_make_section_anyway_with_flags (abfd
, name
,
4893 /* Move the fake group section to the beginning. */
4894 bfd_section_list_remove (abfd
, group
);
4895 bfd_section_list_prepend (abfd
, group
);
4897 elf_next_in_group (group
) = sec
;
4899 elf_group_name (sec
) = name
;
4900 elf_next_in_group (sec
) = sec
;
4901 elf_sec_group (sec
) = group
;
4905 elf_group_name (unwi
) = name
;
4906 elf_next_in_group (unwi
) = sec
;
4907 elf_next_in_group (sec
) = unwi
;
4908 elf_sec_group (unwi
) = group
;
4913 elf_group_name (unw
) = name
;
4916 elf_next_in_group (unw
) = elf_next_in_group (unwi
);
4917 elf_next_in_group (unwi
) = unw
;
4921 elf_next_in_group (unw
) = sec
;
4922 elf_next_in_group (sec
) = unw
;
4924 elf_sec_group (unw
) = group
;
4927 /* Fake SHT_GROUP section header. */
4928 elf_section_data (group
)->this_hdr
.bfd_section
= group
;
4929 elf_section_data (group
)->this_hdr
.sh_type
= SHT_GROUP
;
4936 elfNN_ia64_hpux_vec (const bfd_target
*vec
)
4938 extern const bfd_target bfd_elfNN_ia64_hpux_big_vec
;
4939 return (vec
== & bfd_elfNN_ia64_hpux_big_vec
);
4943 elfNN_hpux_post_process_headers (bfd
*abfd
,
4944 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
4946 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
4948 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
4949 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 1;
4953 elfNN_hpux_backend_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
4954 asection
*sec
, int *retval
)
4956 if (bfd_is_com_section (sec
))
4958 *retval
= SHN_IA_64_ANSI_COMMON
;
4965 elfNN_hpux_backend_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
4968 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
4970 switch (elfsym
->internal_elf_sym
.st_shndx
)
4972 case SHN_IA_64_ANSI_COMMON
:
4973 asym
->section
= bfd_com_section_ptr
;
4974 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
4975 asym
->flags
&= ~BSF_GLOBAL
;
4980 #define TARGET_LITTLE_SYM bfd_elfNN_ia64_little_vec
4981 #define TARGET_LITTLE_NAME "elfNN-ia64-little"
4982 #define TARGET_BIG_SYM bfd_elfNN_ia64_big_vec
4983 #define TARGET_BIG_NAME "elfNN-ia64-big"
4984 #define ELF_ARCH bfd_arch_ia64
4985 #define ELF_TARGET_ID IA64_ELF_DATA
4986 #define ELF_MACHINE_CODE EM_IA_64
4987 #define ELF_MACHINE_ALT1 1999 /* EAS2.3 */
4988 #define ELF_MACHINE_ALT2 1998 /* EAS2.2 */
4989 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
4990 #define ELF_COMMONPAGESIZE 0x4000 /* 16KB */
4992 #define elf_backend_section_from_shdr \
4993 elfNN_ia64_section_from_shdr
4994 #define elf_backend_section_flags \
4995 elfNN_ia64_section_flags
4996 #define elf_backend_fake_sections \
4997 elfNN_ia64_fake_sections
4998 #define elf_backend_final_write_processing \
4999 elfNN_ia64_final_write_processing
5000 #define elf_backend_add_symbol_hook \
5001 elfNN_ia64_add_symbol_hook
5002 #define elf_backend_additional_program_headers \
5003 elfNN_ia64_additional_program_headers
5004 #define elf_backend_modify_segment_map \
5005 elfNN_ia64_modify_segment_map
5006 #define elf_backend_modify_program_headers \
5007 elfNN_ia64_modify_program_headers
5008 #define elf_info_to_howto \
5009 elfNN_ia64_info_to_howto
5011 #define bfd_elfNN_bfd_reloc_type_lookup \
5012 ia64_elf_reloc_type_lookup
5013 #define bfd_elfNN_bfd_reloc_name_lookup \
5014 ia64_elf_reloc_name_lookup
5015 #define bfd_elfNN_bfd_is_local_label_name \
5016 elfNN_ia64_is_local_label_name
5017 #define bfd_elfNN_bfd_relax_section \
5018 elfNN_ia64_relax_section
5020 #define elf_backend_object_p \
5023 /* Stuff for the BFD linker: */
5024 #define bfd_elfNN_bfd_link_hash_table_create \
5025 elfNN_ia64_hash_table_create
5026 #define bfd_elfNN_bfd_link_hash_table_free \
5027 elfNN_ia64_hash_table_free
5028 #define elf_backend_create_dynamic_sections \
5029 elfNN_ia64_create_dynamic_sections
5030 #define elf_backend_check_relocs \
5031 elfNN_ia64_check_relocs
5032 #define elf_backend_adjust_dynamic_symbol \
5033 elfNN_ia64_adjust_dynamic_symbol
5034 #define elf_backend_size_dynamic_sections \
5035 elfNN_ia64_size_dynamic_sections
5036 #define elf_backend_omit_section_dynsym \
5037 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5038 #define elf_backend_relocate_section \
5039 elfNN_ia64_relocate_section
5040 #define elf_backend_finish_dynamic_symbol \
5041 elfNN_ia64_finish_dynamic_symbol
5042 #define elf_backend_finish_dynamic_sections \
5043 elfNN_ia64_finish_dynamic_sections
5044 #define bfd_elfNN_bfd_final_link \
5045 elfNN_ia64_final_link
5047 #define bfd_elfNN_bfd_merge_private_bfd_data \
5048 elfNN_ia64_merge_private_bfd_data
5049 #define bfd_elfNN_bfd_set_private_flags \
5050 elfNN_ia64_set_private_flags
5051 #define bfd_elfNN_bfd_print_private_bfd_data \
5052 elfNN_ia64_print_private_bfd_data
5054 #define elf_backend_plt_readonly 1
5055 #define elf_backend_want_plt_sym 0
5056 #define elf_backend_plt_alignment 5
5057 #define elf_backend_got_header_size 0
5058 #define elf_backend_want_got_plt 1
5059 #define elf_backend_may_use_rel_p 1
5060 #define elf_backend_may_use_rela_p 1
5061 #define elf_backend_default_use_rela_p 1
5062 #define elf_backend_want_dynbss 0
5063 #define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect
5064 #define elf_backend_hide_symbol elfNN_ia64_hash_hide_symbol
5065 #define elf_backend_fixup_symbol _bfd_elf_link_hash_fixup_symbol
5066 #define elf_backend_reloc_type_class elfNN_ia64_reloc_type_class
5067 #define elf_backend_rela_normal 1
5068 #define elf_backend_special_sections elfNN_ia64_special_sections
5069 #define elf_backend_default_execstack 0
5071 /* FIXME: PR 290: The Intel C compiler generates SHT_IA_64_UNWIND with
5072 SHF_LINK_ORDER. But it doesn't set the sh_link or sh_info fields.
5073 We don't want to flood users with so many error messages. We turn
5074 off the warning for now. It will be turned on later when the Intel
5075 compiler is fixed. */
5076 #define elf_backend_link_order_error_handler NULL
5078 #include "elfNN-target.h"
5080 /* HPUX-specific vectors. */
5082 #undef TARGET_LITTLE_SYM
5083 #undef TARGET_LITTLE_NAME
5084 #undef TARGET_BIG_SYM
5085 #define TARGET_BIG_SYM bfd_elfNN_ia64_hpux_big_vec
5086 #undef TARGET_BIG_NAME
5087 #define TARGET_BIG_NAME "elfNN-ia64-hpux-big"
5089 /* These are HP-UX specific functions. */
5091 #undef elf_backend_post_process_headers
5092 #define elf_backend_post_process_headers elfNN_hpux_post_process_headers
5094 #undef elf_backend_section_from_bfd_section
5095 #define elf_backend_section_from_bfd_section elfNN_hpux_backend_section_from_bfd_section
5097 #undef elf_backend_symbol_processing
5098 #define elf_backend_symbol_processing elfNN_hpux_backend_symbol_processing
5100 #undef elf_backend_want_p_paddr_set_to_zero
5101 #define elf_backend_want_p_paddr_set_to_zero 1
5103 #undef ELF_COMMONPAGESIZE
5105 #define ELF_OSABI ELFOSABI_HPUX
5108 #define elfNN_bed elfNN_ia64_hpux_bed
5110 #include "elfNN-target.h"