1 /* IA-64 support for 64-bit ELF
2 Copyright (C) 1998-2019 Free Software Foundation, Inc.
3 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
26 #include "opcode/ia64.h"
30 #include "elfxx-ia64.h"
35 #define LOG_SECTION_ALIGN 3
39 #define LOG_SECTION_ALIGN 2
42 typedef struct bfd_hash_entry
*(*new_hash_entry_func
)
43 (struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *);
45 /* In dynamically (linker-) created sections, we generally need to keep track
46 of the place a symbol or expression got allocated to. This is done via hash
47 tables that store entries of the following type. */
49 struct elfNN_ia64_dyn_sym_info
51 /* The addend for which this entry is relevant. */
56 bfd_vma pltoff_offset
;
60 bfd_vma dtpmod_offset
;
61 bfd_vma dtprel_offset
;
63 /* The symbol table entry, if any, that this was derived from. */
64 struct elf_link_hash_entry
*h
;
66 /* Used to count non-got, non-plt relocations for delayed sizing
67 of relocation sections. */
68 struct elfNN_ia64_dyn_reloc_entry
70 struct elfNN_ia64_dyn_reloc_entry
*next
;
75 /* Is this reloc against readonly section? */
79 /* TRUE when the section contents have been updated. */
80 unsigned got_done
: 1;
81 unsigned fptr_done
: 1;
82 unsigned pltoff_done
: 1;
83 unsigned tprel_done
: 1;
84 unsigned dtpmod_done
: 1;
85 unsigned dtprel_done
: 1;
87 /* TRUE for the different kinds of linker data we want created. */
88 unsigned want_got
: 1;
89 unsigned want_gotx
: 1;
90 unsigned want_fptr
: 1;
91 unsigned want_ltoff_fptr
: 1;
92 unsigned want_plt
: 1;
93 unsigned want_plt2
: 1;
94 unsigned want_pltoff
: 1;
95 unsigned want_tprel
: 1;
96 unsigned want_dtpmod
: 1;
97 unsigned want_dtprel
: 1;
100 struct elfNN_ia64_local_hash_entry
104 /* The number of elements in elfNN_ia64_dyn_sym_info array. */
106 /* The number of sorted elements in elfNN_ia64_dyn_sym_info array. */
107 unsigned int sorted_count
;
108 /* The size of elfNN_ia64_dyn_sym_info array. */
110 /* The array of elfNN_ia64_dyn_sym_info. */
111 struct elfNN_ia64_dyn_sym_info
*info
;
113 /* TRUE if this hash entry's addends was translated for
114 SHF_MERGE optimization. */
115 unsigned sec_merge_done
: 1;
118 struct elfNN_ia64_link_hash_entry
120 struct elf_link_hash_entry root
;
121 /* The number of elements in elfNN_ia64_dyn_sym_info array. */
123 /* The number of sorted elements in elfNN_ia64_dyn_sym_info array. */
124 unsigned int sorted_count
;
125 /* The size of elfNN_ia64_dyn_sym_info array. */
127 /* The array of elfNN_ia64_dyn_sym_info. */
128 struct elfNN_ia64_dyn_sym_info
*info
;
131 struct elfNN_ia64_link_hash_table
133 /* The main hash table. */
134 struct elf_link_hash_table root
;
136 asection
*fptr_sec
; /* Function descriptor table (or NULL). */
137 asection
*rel_fptr_sec
; /* Dynamic relocation section for same. */
138 asection
*pltoff_sec
; /* Private descriptors for plt (or NULL). */
139 asection
*rel_pltoff_sec
; /* Dynamic relocation section for same. */
141 bfd_size_type minplt_entries
; /* Number of minplt entries. */
142 unsigned reltext
: 1; /* Are there relocs against readonly sections? */
143 unsigned self_dtpmod_done
: 1;/* Has self DTPMOD entry been finished? */
144 bfd_vma self_dtpmod_offset
; /* .got offset to self DTPMOD entry. */
145 /* There are maybe R_IA64_GPREL22 relocations, including those
146 optimized from R_IA64_LTOFF22X, against non-SHF_IA_64_SHORT
147 sections. We need to record those sections so that we can choose
148 a proper GP to cover all R_IA64_GPREL22 relocations. */
149 asection
*max_short_sec
; /* Maximum short output section. */
150 bfd_vma max_short_offset
; /* Maximum short offset. */
151 asection
*min_short_sec
; /* Minimum short output section. */
152 bfd_vma min_short_offset
; /* Minimum short offset. */
154 htab_t loc_hash_table
;
155 void *loc_hash_memory
;
158 struct elfNN_ia64_allocate_data
160 struct bfd_link_info
*info
;
162 bfd_boolean only_got
;
165 #define elfNN_ia64_hash_table(p) \
166 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
167 == IA64_ELF_DATA ? ((struct elfNN_ia64_link_hash_table *) ((p)->hash)) : NULL)
169 static struct elfNN_ia64_dyn_sym_info
* get_dyn_sym_info
170 (struct elfNN_ia64_link_hash_table
*ia64_info
,
171 struct elf_link_hash_entry
*h
,
172 bfd
*abfd
, const Elf_Internal_Rela
*rel
, bfd_boolean create
);
173 static bfd_boolean elfNN_ia64_dynamic_symbol_p
174 (struct elf_link_hash_entry
*h
, struct bfd_link_info
*info
, int);
175 static bfd_boolean elfNN_ia64_choose_gp
176 (bfd
*abfd
, struct bfd_link_info
*info
, bfd_boolean final
);
177 static void elfNN_ia64_dyn_sym_traverse
178 (struct elfNN_ia64_link_hash_table
*ia64_info
,
179 bfd_boolean (*func
) (struct elfNN_ia64_dyn_sym_info
*, void *),
181 static bfd_boolean allocate_global_data_got
182 (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
);
183 static bfd_boolean allocate_global_fptr_got
184 (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
);
185 static bfd_boolean allocate_local_got
186 (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
);
187 static bfd_boolean elfNN_ia64_hpux_vec
188 (const bfd_target
*vec
);
189 static bfd_boolean allocate_dynrel_entries
190 (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
);
191 static asection
*get_pltoff
192 (bfd
*abfd
, struct bfd_link_info
*info
,
193 struct elfNN_ia64_link_hash_table
*ia64_info
);
195 /* ia64-specific relocation. */
197 /* Given a ELF reloc, return the matching HOWTO structure. */
200 elfNN_ia64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
202 Elf_Internal_Rela
*elf_reloc
)
204 unsigned int r_type
= ELF32_R_TYPE (elf_reloc
->r_info
);
206 bfd_reloc
->howto
= ia64_elf_lookup_howto (r_type
);
207 if (bfd_reloc
->howto
== NULL
)
209 /* xgettext:c-format */
210 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
212 bfd_set_error (bfd_error_bad_value
);
219 #define PLT_HEADER_SIZE (3 * 16)
220 #define PLT_MIN_ENTRY_SIZE (1 * 16)
221 #define PLT_FULL_ENTRY_SIZE (2 * 16)
222 #define PLT_RESERVED_WORDS 3
224 static const bfd_byte plt_header
[PLT_HEADER_SIZE
] =
226 0x0b, 0x10, 0x00, 0x1c, 0x00, 0x21, /* [MMI] mov r2=r14;; */
227 0xe0, 0x00, 0x08, 0x00, 0x48, 0x00, /* addl r14=0,r2 */
228 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
229 0x0b, 0x80, 0x20, 0x1c, 0x18, 0x14, /* [MMI] ld8 r16=[r14],8;; */
230 0x10, 0x41, 0x38, 0x30, 0x28, 0x00, /* ld8 r17=[r14],8 */
231 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
232 0x11, 0x08, 0x00, 0x1c, 0x18, 0x10, /* [MIB] ld8 r1=[r14] */
233 0x60, 0x88, 0x04, 0x80, 0x03, 0x00, /* mov b6=r17 */
234 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
237 static const bfd_byte plt_min_entry
[PLT_MIN_ENTRY_SIZE
] =
239 0x11, 0x78, 0x00, 0x00, 0x00, 0x24, /* [MIB] mov r15=0 */
240 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, /* nop.i 0x0 */
241 0x00, 0x00, 0x00, 0x40 /* br.few 0 <PLT0>;; */
244 static const bfd_byte plt_full_entry
[PLT_FULL_ENTRY_SIZE
] =
246 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
247 0x00, 0x41, 0x3c, 0x70, 0x29, 0xc0, /* ld8.acq r16=[r15],8*/
248 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
249 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
250 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
251 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
254 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
256 static const bfd_byte oor_brl
[16] =
258 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
259 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;; */
260 0x00, 0x00, 0x00, 0xc0
263 static const bfd_byte oor_ip
[48] =
265 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
266 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, /* movl r15=0 */
267 0x01, 0x00, 0x00, 0x60,
268 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MII] nop.m 0 */
269 0x00, 0x01, 0x00, 0x60, 0x00, 0x00, /* mov r16=ip;; */
270 0xf2, 0x80, 0x00, 0x80, /* add r16=r15,r16;; */
271 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MIB] nop.m 0 */
272 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
273 0x60, 0x00, 0x80, 0x00 /* br b6;; */
276 static size_t oor_branch_size
= sizeof (oor_brl
);
279 bfd_elfNN_ia64_after_parse (int itanium
)
281 oor_branch_size
= itanium
? sizeof (oor_ip
) : sizeof (oor_brl
);
285 /* Rename some of the generic section flags to better document how they
287 #define skip_relax_pass_0 sec_flg0
288 #define skip_relax_pass_1 sec_flg1
290 /* These functions do relaxation for IA-64 ELF. */
293 elfNN_ia64_update_short_info (asection
*sec
, bfd_vma offset
,
294 struct elfNN_ia64_link_hash_table
*ia64_info
)
296 /* Skip ABS and SHF_IA_64_SHORT sections. */
297 if (sec
== bfd_abs_section_ptr
298 || (sec
->flags
& SEC_SMALL_DATA
) != 0)
301 if (!ia64_info
->min_short_sec
)
303 ia64_info
->max_short_sec
= sec
;
304 ia64_info
->max_short_offset
= offset
;
305 ia64_info
->min_short_sec
= sec
;
306 ia64_info
->min_short_offset
= offset
;
308 else if (sec
== ia64_info
->max_short_sec
309 && offset
> ia64_info
->max_short_offset
)
310 ia64_info
->max_short_offset
= offset
;
311 else if (sec
== ia64_info
->min_short_sec
312 && offset
< ia64_info
->min_short_offset
)
313 ia64_info
->min_short_offset
= offset
;
314 else if (sec
->output_section
->vma
315 > ia64_info
->max_short_sec
->vma
)
317 ia64_info
->max_short_sec
= sec
;
318 ia64_info
->max_short_offset
= offset
;
320 else if (sec
->output_section
->vma
321 < ia64_info
->min_short_sec
->vma
)
323 ia64_info
->min_short_sec
= sec
;
324 ia64_info
->min_short_offset
= offset
;
329 elfNN_ia64_relax_section (bfd
*abfd
, asection
*sec
,
330 struct bfd_link_info
*link_info
,
335 struct one_fixup
*next
;
341 Elf_Internal_Shdr
*symtab_hdr
;
342 Elf_Internal_Rela
*internal_relocs
;
343 Elf_Internal_Rela
*irel
, *irelend
;
345 Elf_Internal_Sym
*isymbuf
= NULL
;
346 struct elfNN_ia64_link_hash_table
*ia64_info
;
347 struct one_fixup
*fixups
= NULL
;
348 bfd_boolean changed_contents
= FALSE
;
349 bfd_boolean changed_relocs
= FALSE
;
350 bfd_boolean changed_got
= FALSE
;
351 bfd_boolean skip_relax_pass_0
= TRUE
;
352 bfd_boolean skip_relax_pass_1
= TRUE
;
355 /* Assume we're not going to change any sizes, and we'll only need
359 if (bfd_link_relocatable (link_info
))
360 (*link_info
->callbacks
->einfo
)
361 (_("%P%F: --relax and -r may not be used together\n"));
363 /* Don't even try to relax for non-ELF outputs. */
364 if (!is_elf_hash_table (link_info
->hash
))
367 /* Nothing to do if there are no relocations or there is no need for
369 if ((sec
->flags
& SEC_RELOC
) == 0
370 || sec
->reloc_count
== 0
371 || (link_info
->relax_pass
== 0 && sec
->skip_relax_pass_0
)
372 || (link_info
->relax_pass
== 1 && sec
->skip_relax_pass_1
))
375 ia64_info
= elfNN_ia64_hash_table (link_info
);
376 if (ia64_info
== NULL
)
379 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
381 /* Load the relocations for this section. */
382 internal_relocs
= (_bfd_elf_link_read_relocs
383 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
384 link_info
->keep_memory
));
385 if (internal_relocs
== NULL
)
388 irelend
= internal_relocs
+ sec
->reloc_count
;
390 /* Get the section contents. */
391 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
392 contents
= elf_section_data (sec
)->this_hdr
.contents
;
395 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
399 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
401 unsigned long r_type
= ELFNN_R_TYPE (irel
->r_info
);
402 bfd_vma symaddr
, reladdr
, trampoff
, toff
, roff
;
406 bfd_boolean is_branch
;
407 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
412 case R_IA64_PCREL21B
:
413 case R_IA64_PCREL21BI
:
414 case R_IA64_PCREL21M
:
415 case R_IA64_PCREL21F
:
416 /* In pass 1, all br relaxations are done. We can skip it. */
417 if (link_info
->relax_pass
== 1)
419 skip_relax_pass_0
= FALSE
;
423 case R_IA64_PCREL60B
:
424 /* We can't optimize brl to br in pass 0 since br relaxations
425 will increase the code size. Defer it to pass 1. */
426 if (link_info
->relax_pass
== 0)
428 skip_relax_pass_1
= FALSE
;
435 /* Update max_short_sec/min_short_sec. */
437 case R_IA64_LTOFF22X
:
439 /* We can't relax ldx/mov in pass 0 since br relaxations will
440 increase the code size. Defer it to pass 1. */
441 if (link_info
->relax_pass
== 0)
443 skip_relax_pass_1
= FALSE
;
453 /* Get the value of the symbol referred to by the reloc. */
454 if (ELFNN_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
456 /* A local symbol. */
457 Elf_Internal_Sym
*isym
;
459 /* Read this BFD's local symbols. */
462 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
464 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
465 symtab_hdr
->sh_info
, 0,
471 isym
= isymbuf
+ ELFNN_R_SYM (irel
->r_info
);
472 if (isym
->st_shndx
== SHN_UNDEF
)
473 continue; /* We can't do anything with undefined symbols. */
474 else if (isym
->st_shndx
== SHN_ABS
)
475 tsec
= bfd_abs_section_ptr
;
476 else if (isym
->st_shndx
== SHN_COMMON
)
477 tsec
= bfd_com_section_ptr
;
478 else if (isym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
479 tsec
= bfd_com_section_ptr
;
481 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
483 toff
= isym
->st_value
;
484 dyn_i
= get_dyn_sym_info (ia64_info
, NULL
, abfd
, irel
, FALSE
);
485 symtype
= ELF_ST_TYPE (isym
->st_info
);
490 struct elf_link_hash_entry
*h
;
492 indx
= ELFNN_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
493 h
= elf_sym_hashes (abfd
)[indx
];
494 BFD_ASSERT (h
!= NULL
);
496 while (h
->root
.type
== bfd_link_hash_indirect
497 || h
->root
.type
== bfd_link_hash_warning
)
498 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
500 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, irel
, FALSE
);
502 /* For branches to dynamic symbols, we're interested instead
503 in a branch to the PLT entry. */
504 if (is_branch
&& dyn_i
&& dyn_i
->want_plt2
)
506 /* Internal branches shouldn't be sent to the PLT.
507 Leave this for now and we'll give an error later. */
508 if (r_type
!= R_IA64_PCREL21B
)
511 tsec
= ia64_info
->root
.splt
;
512 toff
= dyn_i
->plt2_offset
;
513 BFD_ASSERT (irel
->r_addend
== 0);
516 /* Can't do anything else with dynamic symbols. */
517 else if (elfNN_ia64_dynamic_symbol_p (h
, link_info
, r_type
))
522 /* We can't do anything with undefined symbols. */
523 if (h
->root
.type
== bfd_link_hash_undefined
524 || h
->root
.type
== bfd_link_hash_undefweak
)
527 tsec
= h
->root
.u
.def
.section
;
528 toff
= h
->root
.u
.def
.value
;
534 if (tsec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
536 /* At this stage in linking, no SEC_MERGE symbol has been
537 adjusted, so all references to such symbols need to be
538 passed through _bfd_merged_section_offset. (Later, in
539 relocate_section, all SEC_MERGE symbols *except* for
540 section symbols have been adjusted.)
542 gas may reduce relocations against symbols in SEC_MERGE
543 sections to a relocation against the section symbol when
544 the original addend was zero. When the reloc is against
545 a section symbol we should include the addend in the
546 offset passed to _bfd_merged_section_offset, since the
547 location of interest is the original symbol. On the
548 other hand, an access to "sym+addend" where "sym" is not
549 a section symbol should not include the addend; Such an
550 access is presumed to be an offset from "sym"; The
551 location of interest is just "sym". */
552 if (symtype
== STT_SECTION
)
553 toff
+= irel
->r_addend
;
555 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
556 elf_section_data (tsec
)->sec_info
,
559 if (symtype
!= STT_SECTION
)
560 toff
+= irel
->r_addend
;
563 toff
+= irel
->r_addend
;
565 symaddr
= tsec
->output_section
->vma
+ tsec
->output_offset
+ toff
;
567 roff
= irel
->r_offset
;
571 bfd_signed_vma offset
;
573 reladdr
= (sec
->output_section
->vma
575 + roff
) & (bfd_vma
) -4;
577 /* The .plt section is aligned at 32byte and the .text section
578 is aligned at 64byte. The .text section is right after the
579 .plt section. After the first relaxation pass, linker may
580 increase the gap between the .plt and .text sections up
581 to 32byte. We assume linker will always insert 32byte
582 between the .plt and .text sections after the first
584 if (tsec
== ia64_info
->root
.splt
)
585 offset
= -0x1000000 + 32;
589 /* If the branch is in range, no need to do anything. */
590 if ((bfd_signed_vma
) (symaddr
- reladdr
) >= offset
591 && (bfd_signed_vma
) (symaddr
- reladdr
) <= 0x0FFFFF0)
593 /* If the 60-bit branch is in 21-bit range, optimize it. */
594 if (r_type
== R_IA64_PCREL60B
)
596 ia64_elf_relax_brl (contents
, roff
);
599 = ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
602 /* If the original relocation offset points to slot
603 1, change it to slot 2. */
604 if ((irel
->r_offset
& 3) == 1)
607 changed_contents
= TRUE
;
608 changed_relocs
= TRUE
;
613 else if (r_type
== R_IA64_PCREL60B
)
615 else if (ia64_elf_relax_br (contents
, roff
))
618 = ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
621 /* Make the relocation offset point to slot 1. */
622 irel
->r_offset
= (irel
->r_offset
& ~((bfd_vma
) 0x3)) + 1;
624 changed_contents
= TRUE
;
625 changed_relocs
= TRUE
;
629 /* We can't put a trampoline in a .init/.fini section. Issue
631 if (strcmp (sec
->output_section
->name
, ".init") == 0
632 || strcmp (sec
->output_section
->name
, ".fini") == 0)
635 /* xgettext:c-format */
636 (_("%pB: can't relax br at %#" PRIx64
" in section `%pA';"
637 " please use brl or indirect branch"),
638 sec
->owner
, (uint64_t) roff
, sec
);
639 bfd_set_error (bfd_error_bad_value
);
643 /* If the branch and target are in the same section, you've
644 got one honking big section and we can't help you unless
645 you are branching backwards. You'll get an error message
647 if (tsec
== sec
&& toff
> roff
)
650 /* Look for an existing fixup to this address. */
651 for (f
= fixups
; f
; f
= f
->next
)
652 if (f
->tsec
== tsec
&& f
->toff
== toff
)
657 /* Two alternatives: If it's a branch to a PLT entry, we can
658 make a copy of the FULL_PLT entry. Otherwise, we'll have
659 to use a `brl' insn to get where we're going. */
663 if (tsec
== ia64_info
->root
.splt
)
664 size
= sizeof (plt_full_entry
);
666 size
= oor_branch_size
;
668 /* Resize the current section to make room for the new branch. */
669 trampoff
= (sec
->size
+ 15) & (bfd_vma
) -16;
671 /* If trampoline is out of range, there is nothing we
673 offset
= trampoff
- (roff
& (bfd_vma
) -4);
674 if (offset
< -0x1000000 || offset
> 0x0FFFFF0)
677 amt
= trampoff
+ size
;
678 contents
= (bfd_byte
*) bfd_realloc (contents
, amt
);
679 if (contents
== NULL
)
683 if (tsec
== ia64_info
->root
.splt
)
685 memcpy (contents
+ trampoff
, plt_full_entry
, size
);
687 /* Hijack the old relocation for use as the PLTOFF reloc. */
688 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
690 irel
->r_offset
= trampoff
;
694 if (size
== sizeof (oor_ip
))
696 memcpy (contents
+ trampoff
, oor_ip
, size
);
697 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
699 irel
->r_addend
-= 16;
700 irel
->r_offset
= trampoff
+ 2;
704 memcpy (contents
+ trampoff
, oor_brl
, size
);
705 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
707 irel
->r_offset
= trampoff
+ 2;
712 /* Record the fixup so we don't do it again this section. */
713 f
= (struct one_fixup
*)
714 bfd_malloc ((bfd_size_type
) sizeof (*f
));
718 f
->trampoff
= trampoff
;
723 /* If trampoline is out of range, there is nothing we
725 offset
= f
->trampoff
- (roff
& (bfd_vma
) -4);
726 if (offset
< -0x1000000 || offset
> 0x0FFFFF0)
729 /* Nop out the reloc, since we're finalizing things here. */
730 irel
->r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
733 /* Fix up the existing branch to hit the trampoline. */
734 if (ia64_elf_install_value (contents
+ roff
, offset
, r_type
)
738 changed_contents
= TRUE
;
739 changed_relocs
= TRUE
;
746 bfd
*obfd
= sec
->output_section
->owner
;
747 gp
= _bfd_get_gp_value (obfd
);
750 if (!elfNN_ia64_choose_gp (obfd
, link_info
, FALSE
))
752 gp
= _bfd_get_gp_value (obfd
);
756 /* If the data is out of range, do nothing. */
757 if ((bfd_signed_vma
) (symaddr
- gp
) >= 0x200000
758 ||(bfd_signed_vma
) (symaddr
- gp
) < -0x200000)
761 if (r_type
== R_IA64_GPREL22
)
762 elfNN_ia64_update_short_info (tsec
->output_section
,
763 tsec
->output_offset
+ toff
,
765 else if (r_type
== R_IA64_LTOFF22X
)
767 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
769 changed_relocs
= TRUE
;
770 if (dyn_i
->want_gotx
)
772 dyn_i
->want_gotx
= 0;
773 changed_got
|= !dyn_i
->want_got
;
776 elfNN_ia64_update_short_info (tsec
->output_section
,
777 tsec
->output_offset
+ toff
,
782 ia64_elf_relax_ldxmov (contents
, roff
);
783 irel
->r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
784 changed_contents
= TRUE
;
785 changed_relocs
= TRUE
;
790 /* ??? If we created fixups, this may push the code segment large
791 enough that the data segment moves, which will change the GP.
792 Reset the GP so that we re-calculate next round. We need to
793 do this at the _beginning_ of the next round; now will not do. */
795 /* Clean up and go home. */
798 struct one_fixup
*f
= fixups
;
799 fixups
= fixups
->next
;
804 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
806 if (! link_info
->keep_memory
)
810 /* Cache the symbols for elf_link_input_bfd. */
811 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
816 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
818 if (!changed_contents
&& !link_info
->keep_memory
)
822 /* Cache the section contents for elf_link_input_bfd. */
823 elf_section_data (sec
)->this_hdr
.contents
= contents
;
827 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
830 free (internal_relocs
);
832 elf_section_data (sec
)->relocs
= internal_relocs
;
837 struct elfNN_ia64_allocate_data data
;
838 data
.info
= link_info
;
840 ia64_info
->self_dtpmod_offset
= (bfd_vma
) -1;
842 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_data_got
, &data
);
843 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_fptr_got
, &data
);
844 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_local_got
, &data
);
845 ia64_info
->root
.sgot
->size
= data
.ofs
;
847 if (ia64_info
->root
.dynamic_sections_created
848 && ia64_info
->root
.srelgot
!= NULL
)
850 /* Resize .rela.got. */
851 ia64_info
->root
.srelgot
->size
= 0;
852 if (bfd_link_pic (link_info
)
853 && ia64_info
->self_dtpmod_offset
!= (bfd_vma
) -1)
854 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
855 data
.only_got
= TRUE
;
856 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_dynrel_entries
,
861 if (link_info
->relax_pass
== 0)
863 /* Pass 0 is only needed to relax br. */
864 sec
->skip_relax_pass_0
= skip_relax_pass_0
;
865 sec
->skip_relax_pass_1
= skip_relax_pass_1
;
868 *again
= changed_contents
|| changed_relocs
;
872 if (isymbuf
!= NULL
&& (unsigned char *) isymbuf
!= symtab_hdr
->contents
)
875 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
877 if (internal_relocs
!= NULL
878 && elf_section_data (sec
)->relocs
!= internal_relocs
)
879 free (internal_relocs
);
882 #undef skip_relax_pass_0
883 #undef skip_relax_pass_1
885 /* Return TRUE if NAME is an unwind table section name. */
887 static inline bfd_boolean
888 is_unwind_section_name (bfd
*abfd
, const char *name
)
890 if (elfNN_ia64_hpux_vec (abfd
->xvec
)
891 && !strcmp (name
, ELF_STRING_ia64_unwind_hdr
))
894 return ((CONST_STRNEQ (name
, ELF_STRING_ia64_unwind
)
895 && ! CONST_STRNEQ (name
, ELF_STRING_ia64_unwind_info
))
896 || CONST_STRNEQ (name
, ELF_STRING_ia64_unwind_once
));
899 /* Handle an IA-64 specific section when reading an object file. This
900 is called when bfd_section_from_shdr finds a section with an unknown
904 elfNN_ia64_section_from_shdr (bfd
*abfd
,
905 Elf_Internal_Shdr
*hdr
,
909 /* There ought to be a place to keep ELF backend specific flags, but
910 at the moment there isn't one. We just keep track of the
911 sections by their name, instead. Fortunately, the ABI gives
912 suggested names for all the MIPS specific sections, so we will
913 probably get away with this. */
914 switch (hdr
->sh_type
)
916 case SHT_IA_64_UNWIND
:
917 case SHT_IA_64_HP_OPT_ANOT
:
921 if (strcmp (name
, ELF_STRING_ia64_archext
) != 0)
929 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
935 /* Convert IA-64 specific section flags to bfd internal section flags. */
937 /* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
941 elfNN_ia64_section_flags (flagword
*flags
,
942 const Elf_Internal_Shdr
*hdr
)
944 if (hdr
->sh_flags
& SHF_IA_64_SHORT
)
945 *flags
|= SEC_SMALL_DATA
;
950 /* Set the correct type for an IA-64 ELF section. We do this by the
951 section name, which is a hack, but ought to work. */
954 elfNN_ia64_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
959 name
= bfd_section_name (sec
);
961 if (is_unwind_section_name (abfd
, name
))
963 /* We don't have the sections numbered at this point, so sh_info
964 is set later, in elfNN_ia64_final_write_processing. */
965 hdr
->sh_type
= SHT_IA_64_UNWIND
;
966 hdr
->sh_flags
|= SHF_LINK_ORDER
;
968 else if (strcmp (name
, ELF_STRING_ia64_archext
) == 0)
969 hdr
->sh_type
= SHT_IA_64_EXT
;
970 else if (strcmp (name
, ".HP.opt_annot") == 0)
971 hdr
->sh_type
= SHT_IA_64_HP_OPT_ANOT
;
972 else if (strcmp (name
, ".reloc") == 0)
973 /* This is an ugly, but unfortunately necessary hack that is
974 needed when producing EFI binaries on IA-64. It tells
975 elf.c:elf_fake_sections() not to consider ".reloc" as a section
976 containing ELF relocation info. We need this hack in order to
977 be able to generate ELF binaries that can be translated into
978 EFI applications (which are essentially COFF objects). Those
979 files contain a COFF ".reloc" section inside an ELFNN object,
980 which would normally cause BFD to segfault because it would
981 attempt to interpret this section as containing relocation
982 entries for section "oc". With this hack enabled, ".reloc"
983 will be treated as a normal data section, which will avoid the
984 segfault. However, you won't be able to create an ELFNN binary
985 with a section named "oc" that needs relocations, but that's
986 the kind of ugly side-effects you get when detecting section
987 types based on their names... In practice, this limitation is
989 hdr
->sh_type
= SHT_PROGBITS
;
991 if (sec
->flags
& SEC_SMALL_DATA
)
992 hdr
->sh_flags
|= SHF_IA_64_SHORT
;
994 /* Some HP linkers look for the SHF_IA_64_HP_TLS flag instead of SHF_TLS. */
996 if (elfNN_ia64_hpux_vec (abfd
->xvec
) && (sec
->flags
& SHF_TLS
))
997 hdr
->sh_flags
|= SHF_IA_64_HP_TLS
;
1002 /* The final processing done just before writing out an IA-64 ELF
1006 elfNN_ia64_final_write_processing (bfd
*abfd
)
1008 Elf_Internal_Shdr
*hdr
;
1011 for (s
= abfd
->sections
; s
; s
= s
->next
)
1013 hdr
= &elf_section_data (s
)->this_hdr
;
1014 switch (hdr
->sh_type
)
1016 case SHT_IA_64_UNWIND
:
1017 /* The IA-64 processor-specific ABI requires setting sh_link
1018 to the unwind section, whereas HP-UX requires sh_info to
1019 do so. For maximum compatibility, we'll set both for
1021 hdr
->sh_info
= hdr
->sh_link
;
1026 if (! elf_flags_init (abfd
))
1028 unsigned long flags
= 0;
1030 if (abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
)
1031 flags
|= EF_IA_64_BE
;
1032 if (bfd_get_mach (abfd
) == bfd_mach_ia64_elf64
)
1033 flags
|= EF_IA_64_ABI64
;
1035 elf_elfheader(abfd
)->e_flags
= flags
;
1036 elf_flags_init (abfd
) = TRUE
;
1038 return _bfd_elf_final_write_processing (abfd
);
1041 /* Hook called by the linker routine which adds symbols from an object
1042 file. We use it to put .comm items in .sbss, and not .bss. */
1045 elfNN_ia64_add_symbol_hook (bfd
*abfd
,
1046 struct bfd_link_info
*info
,
1047 Elf_Internal_Sym
*sym
,
1048 const char **namep ATTRIBUTE_UNUSED
,
1049 flagword
*flagsp ATTRIBUTE_UNUSED
,
1053 if (sym
->st_shndx
== SHN_COMMON
1054 && !bfd_link_relocatable (info
)
1055 && sym
->st_size
<= elf_gp_size (abfd
))
1057 /* Common symbols less than or equal to -G nn bytes are
1058 automatically put into .sbss. */
1060 asection
*scomm
= bfd_get_section_by_name (abfd
, ".scommon");
1064 scomm
= bfd_make_section_with_flags (abfd
, ".scommon",
1067 | SEC_LINKER_CREATED
));
1073 *valp
= sym
->st_size
;
1079 /* Return the number of additional phdrs we will need. */
1082 elfNN_ia64_additional_program_headers (bfd
*abfd
,
1083 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1088 /* See if we need a PT_IA_64_ARCHEXT segment. */
1089 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_archext
);
1090 if (s
&& (s
->flags
& SEC_LOAD
))
1093 /* Count how many PT_IA_64_UNWIND segments we need. */
1094 for (s
= abfd
->sections
; s
; s
= s
->next
)
1095 if (is_unwind_section_name (abfd
, s
->name
) && (s
->flags
& SEC_LOAD
))
1102 elfNN_ia64_modify_segment_map (bfd
*abfd
,
1103 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1105 struct elf_segment_map
*m
, **pm
;
1106 Elf_Internal_Shdr
*hdr
;
1109 /* If we need a PT_IA_64_ARCHEXT segment, it must come before
1110 all PT_LOAD segments. */
1111 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_archext
);
1112 if (s
&& (s
->flags
& SEC_LOAD
))
1114 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
1115 if (m
->p_type
== PT_IA_64_ARCHEXT
)
1119 m
= ((struct elf_segment_map
*)
1120 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *m
));
1124 m
->p_type
= PT_IA_64_ARCHEXT
;
1128 /* We want to put it after the PHDR and INTERP segments. */
1129 pm
= &elf_seg_map (abfd
);
1131 && ((*pm
)->p_type
== PT_PHDR
1132 || (*pm
)->p_type
== PT_INTERP
))
1140 /* Install PT_IA_64_UNWIND segments, if needed. */
1141 for (s
= abfd
->sections
; s
; s
= s
->next
)
1143 hdr
= &elf_section_data (s
)->this_hdr
;
1144 if (hdr
->sh_type
!= SHT_IA_64_UNWIND
)
1147 if (s
&& (s
->flags
& SEC_LOAD
))
1149 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
1150 if (m
->p_type
== PT_IA_64_UNWIND
)
1154 /* Look through all sections in the unwind segment
1155 for a match since there may be multiple sections
1157 for (i
= m
->count
- 1; i
>= 0; --i
)
1158 if (m
->sections
[i
] == s
)
1167 m
= ((struct elf_segment_map
*)
1168 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *m
));
1172 m
->p_type
= PT_IA_64_UNWIND
;
1177 /* We want to put it last. */
1178 pm
= &elf_seg_map (abfd
);
1189 /* Turn on PF_IA_64_NORECOV if needed. This involves traversing all of
1190 the input sections for each output section in the segment and testing
1191 for SHF_IA_64_NORECOV on each. */
1194 elfNN_ia64_modify_program_headers (bfd
*abfd
,
1195 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1197 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
1198 struct elf_segment_map
*m
;
1199 Elf_Internal_Phdr
*p
;
1201 for (p
= tdata
->phdr
, m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
, p
++)
1202 if (m
->p_type
== PT_LOAD
)
1205 for (i
= m
->count
- 1; i
>= 0; --i
)
1207 struct bfd_link_order
*order
= m
->sections
[i
]->map_head
.link_order
;
1209 while (order
!= NULL
)
1211 if (order
->type
== bfd_indirect_link_order
)
1213 asection
*is
= order
->u
.indirect
.section
;
1214 bfd_vma flags
= elf_section_data(is
)->this_hdr
.sh_flags
;
1215 if (flags
& SHF_IA_64_NORECOV
)
1217 p
->p_flags
|= PF_IA_64_NORECOV
;
1221 order
= order
->next
;
1230 /* According to the Tahoe assembler spec, all labels starting with a
1234 elfNN_ia64_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
1237 return name
[0] == '.';
1240 /* Should we do dynamic things to this symbol? */
1243 elfNN_ia64_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
1244 struct bfd_link_info
*info
, int r_type
)
1246 bfd_boolean ignore_protected
1247 = ((r_type
& 0xf8) == 0x40 /* FPTR relocs */
1248 || (r_type
& 0xf8) == 0x50); /* LTOFF_FPTR relocs */
1250 return _bfd_elf_dynamic_symbol_p (h
, info
, ignore_protected
);
1253 static struct bfd_hash_entry
*
1254 elfNN_ia64_new_elf_hash_entry (struct bfd_hash_entry
*entry
,
1255 struct bfd_hash_table
*table
,
1258 struct elfNN_ia64_link_hash_entry
*ret
;
1259 ret
= (struct elfNN_ia64_link_hash_entry
*) entry
;
1261 /* Allocate the structure if it has not already been allocated by a
1264 ret
= bfd_hash_allocate (table
, sizeof (*ret
));
1269 /* Call the allocation method of the superclass. */
1270 ret
= ((struct elfNN_ia64_link_hash_entry
*)
1271 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
1276 ret
->sorted_count
= 0;
1278 return (struct bfd_hash_entry
*) ret
;
1282 elfNN_ia64_hash_copy_indirect (struct bfd_link_info
*info
,
1283 struct elf_link_hash_entry
*xdir
,
1284 struct elf_link_hash_entry
*xind
)
1286 struct elfNN_ia64_link_hash_entry
*dir
, *ind
;
1288 dir
= (struct elfNN_ia64_link_hash_entry
*) xdir
;
1289 ind
= (struct elfNN_ia64_link_hash_entry
*) xind
;
1291 /* Copy down any references that we may have already seen to the
1292 symbol which just became indirect. */
1294 if (dir
->root
.versioned
!= versioned_hidden
)
1295 dir
->root
.ref_dynamic
|= ind
->root
.ref_dynamic
;
1296 dir
->root
.ref_regular
|= ind
->root
.ref_regular
;
1297 dir
->root
.ref_regular_nonweak
|= ind
->root
.ref_regular_nonweak
;
1298 dir
->root
.needs_plt
|= ind
->root
.needs_plt
;
1300 if (ind
->root
.root
.type
!= bfd_link_hash_indirect
)
1303 /* Copy over the got and plt data. This would have been done
1306 if (ind
->info
!= NULL
)
1308 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1314 dir
->info
= ind
->info
;
1315 dir
->count
= ind
->count
;
1316 dir
->sorted_count
= ind
->sorted_count
;
1317 dir
->size
= ind
->size
;
1321 ind
->sorted_count
= 0;
1324 /* Fix up the dyn_sym_info pointers to the global symbol. */
1325 for (count
= dir
->count
, dyn_i
= dir
->info
;
1328 dyn_i
->h
= &dir
->root
;
1331 /* Copy over the dynindx. */
1333 if (ind
->root
.dynindx
!= -1)
1335 if (dir
->root
.dynindx
!= -1)
1336 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1337 dir
->root
.dynstr_index
);
1338 dir
->root
.dynindx
= ind
->root
.dynindx
;
1339 dir
->root
.dynstr_index
= ind
->root
.dynstr_index
;
1340 ind
->root
.dynindx
= -1;
1341 ind
->root
.dynstr_index
= 0;
1346 elfNN_ia64_hash_hide_symbol (struct bfd_link_info
*info
,
1347 struct elf_link_hash_entry
*xh
,
1348 bfd_boolean force_local
)
1350 struct elfNN_ia64_link_hash_entry
*h
;
1351 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1354 h
= (struct elfNN_ia64_link_hash_entry
*)xh
;
1356 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
1358 for (count
= h
->count
, dyn_i
= h
->info
;
1362 dyn_i
->want_plt2
= 0;
1363 dyn_i
->want_plt
= 0;
1367 /* Compute a hash of a local hash entry. */
1370 elfNN_ia64_local_htab_hash (const void *ptr
)
1372 struct elfNN_ia64_local_hash_entry
*entry
1373 = (struct elfNN_ia64_local_hash_entry
*) ptr
;
1375 return ELF_LOCAL_SYMBOL_HASH (entry
->id
, entry
->r_sym
);
1378 /* Compare local hash entries. */
1381 elfNN_ia64_local_htab_eq (const void *ptr1
, const void *ptr2
)
1383 struct elfNN_ia64_local_hash_entry
*entry1
1384 = (struct elfNN_ia64_local_hash_entry
*) ptr1
;
1385 struct elfNN_ia64_local_hash_entry
*entry2
1386 = (struct elfNN_ia64_local_hash_entry
*) ptr2
;
1388 return entry1
->id
== entry2
->id
&& entry1
->r_sym
== entry2
->r_sym
;
1391 /* Free the global elfNN_ia64_dyn_sym_info array. */
1394 elfNN_ia64_global_dyn_info_free (void **xentry
,
1395 void * unused ATTRIBUTE_UNUSED
)
1397 struct elfNN_ia64_link_hash_entry
*entry
1398 = (struct elfNN_ia64_link_hash_entry
*) xentry
;
1405 entry
->sorted_count
= 0;
1412 /* Free the local elfNN_ia64_dyn_sym_info array. */
1415 elfNN_ia64_local_dyn_info_free (void **slot
,
1416 void * unused ATTRIBUTE_UNUSED
)
1418 struct elfNN_ia64_local_hash_entry
*entry
1419 = (struct elfNN_ia64_local_hash_entry
*) *slot
;
1426 entry
->sorted_count
= 0;
1433 /* Destroy IA-64 linker hash table. */
1436 elfNN_ia64_link_hash_table_free (bfd
*obfd
)
1438 struct elfNN_ia64_link_hash_table
*ia64_info
1439 = (struct elfNN_ia64_link_hash_table
*) obfd
->link
.hash
;
1440 if (ia64_info
->loc_hash_table
)
1442 htab_traverse (ia64_info
->loc_hash_table
,
1443 elfNN_ia64_local_dyn_info_free
, NULL
);
1444 htab_delete (ia64_info
->loc_hash_table
);
1446 if (ia64_info
->loc_hash_memory
)
1447 objalloc_free ((struct objalloc
*) ia64_info
->loc_hash_memory
);
1448 elf_link_hash_traverse (&ia64_info
->root
,
1449 elfNN_ia64_global_dyn_info_free
, NULL
);
1450 _bfd_elf_link_hash_table_free (obfd
);
1453 /* Create the derived linker hash table. The IA-64 ELF port uses this
1454 derived hash table to keep information specific to the IA-64 ElF
1455 linker (without using static variables). */
1457 static struct bfd_link_hash_table
*
1458 elfNN_ia64_hash_table_create (bfd
*abfd
)
1460 struct elfNN_ia64_link_hash_table
*ret
;
1462 ret
= bfd_zmalloc ((bfd_size_type
) sizeof (*ret
));
1466 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
1467 elfNN_ia64_new_elf_hash_entry
,
1468 sizeof (struct elfNN_ia64_link_hash_entry
),
1475 ret
->loc_hash_table
= htab_try_create (1024, elfNN_ia64_local_htab_hash
,
1476 elfNN_ia64_local_htab_eq
, NULL
);
1477 ret
->loc_hash_memory
= objalloc_create ();
1478 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1480 elfNN_ia64_link_hash_table_free (abfd
);
1483 ret
->root
.root
.hash_table_free
= elfNN_ia64_link_hash_table_free
;
1485 return &ret
->root
.root
;
1488 /* Traverse both local and global hash tables. */
1490 struct elfNN_ia64_dyn_sym_traverse_data
1492 bfd_boolean (*func
) (struct elfNN_ia64_dyn_sym_info
*, void *);
1497 elfNN_ia64_global_dyn_sym_thunk (struct bfd_hash_entry
*xentry
,
1500 struct elfNN_ia64_link_hash_entry
*entry
1501 = (struct elfNN_ia64_link_hash_entry
*) xentry
;
1502 struct elfNN_ia64_dyn_sym_traverse_data
*data
1503 = (struct elfNN_ia64_dyn_sym_traverse_data
*) xdata
;
1504 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1507 for (count
= entry
->count
, dyn_i
= entry
->info
;
1510 if (! (*data
->func
) (dyn_i
, data
->data
))
1516 elfNN_ia64_local_dyn_sym_thunk (void **slot
, void * xdata
)
1518 struct elfNN_ia64_local_hash_entry
*entry
1519 = (struct elfNN_ia64_local_hash_entry
*) *slot
;
1520 struct elfNN_ia64_dyn_sym_traverse_data
*data
1521 = (struct elfNN_ia64_dyn_sym_traverse_data
*) xdata
;
1522 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1525 for (count
= entry
->count
, dyn_i
= entry
->info
;
1528 if (! (*data
->func
) (dyn_i
, data
->data
))
1534 elfNN_ia64_dyn_sym_traverse (struct elfNN_ia64_link_hash_table
*ia64_info
,
1535 bfd_boolean (*func
) (struct elfNN_ia64_dyn_sym_info
*, void *),
1538 struct elfNN_ia64_dyn_sym_traverse_data xdata
;
1543 elf_link_hash_traverse (&ia64_info
->root
,
1544 elfNN_ia64_global_dyn_sym_thunk
, &xdata
);
1545 htab_traverse (ia64_info
->loc_hash_table
,
1546 elfNN_ia64_local_dyn_sym_thunk
, &xdata
);
1550 elfNN_ia64_create_dynamic_sections (bfd
*abfd
,
1551 struct bfd_link_info
*info
)
1553 struct elfNN_ia64_link_hash_table
*ia64_info
;
1556 if (! _bfd_elf_create_dynamic_sections (abfd
, info
))
1559 ia64_info
= elfNN_ia64_hash_table (info
);
1560 if (ia64_info
== NULL
)
1564 flagword flags
= bfd_section_flags (ia64_info
->root
.sgot
);
1565 bfd_set_section_flags (ia64_info
->root
.sgot
, SEC_SMALL_DATA
| flags
);
1566 /* The .got section is always aligned at 8 bytes. */
1567 if (!bfd_set_section_alignment (ia64_info
->root
.sgot
, 3))
1571 if (!get_pltoff (abfd
, info
, ia64_info
))
1574 s
= bfd_make_section_anyway_with_flags (abfd
, ".rela.IA_64.pltoff",
1575 (SEC_ALLOC
| SEC_LOAD
1578 | SEC_LINKER_CREATED
1581 || !bfd_set_section_alignment (s
, LOG_SECTION_ALIGN
))
1583 ia64_info
->rel_pltoff_sec
= s
;
1588 /* Find and/or create a hash entry for local symbol. */
1589 static struct elfNN_ia64_local_hash_entry
*
1590 get_local_sym_hash (struct elfNN_ia64_link_hash_table
*ia64_info
,
1591 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
1594 struct elfNN_ia64_local_hash_entry e
, *ret
;
1595 asection
*sec
= abfd
->sections
;
1596 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
1597 ELFNN_R_SYM (rel
->r_info
));
1601 e
.r_sym
= ELFNN_R_SYM (rel
->r_info
);
1602 slot
= htab_find_slot_with_hash (ia64_info
->loc_hash_table
, &e
, h
,
1603 create
? INSERT
: NO_INSERT
);
1609 return (struct elfNN_ia64_local_hash_entry
*) *slot
;
1611 ret
= (struct elfNN_ia64_local_hash_entry
*)
1612 objalloc_alloc ((struct objalloc
*) ia64_info
->loc_hash_memory
,
1613 sizeof (struct elfNN_ia64_local_hash_entry
));
1616 memset (ret
, 0, sizeof (*ret
));
1618 ret
->r_sym
= ELFNN_R_SYM (rel
->r_info
);
1624 /* Used to sort elfNN_ia64_dyn_sym_info array. */
1627 addend_compare (const void *xp
, const void *yp
)
1629 const struct elfNN_ia64_dyn_sym_info
*x
1630 = (const struct elfNN_ia64_dyn_sym_info
*) xp
;
1631 const struct elfNN_ia64_dyn_sym_info
*y
1632 = (const struct elfNN_ia64_dyn_sym_info
*) yp
;
1634 return x
->addend
< y
->addend
? -1 : x
->addend
> y
->addend
? 1 : 0;
1637 /* Sort elfNN_ia64_dyn_sym_info array and remove duplicates. */
1640 sort_dyn_sym_info (struct elfNN_ia64_dyn_sym_info
*info
,
1643 bfd_vma curr
, prev
, got_offset
;
1644 unsigned int i
, kept
, dupes
, diff
, dest
, src
, len
;
1646 qsort (info
, count
, sizeof (*info
), addend_compare
);
1648 /* Find the first duplicate. */
1649 prev
= info
[0].addend
;
1650 got_offset
= info
[0].got_offset
;
1651 for (i
= 1; i
< count
; i
++)
1653 curr
= info
[i
].addend
;
1656 /* For duplicates, make sure that GOT_OFFSET is valid. */
1657 if (got_offset
== (bfd_vma
) -1)
1658 got_offset
= info
[i
].got_offset
;
1661 got_offset
= info
[i
].got_offset
;
1665 /* We may move a block of elements to here. */
1668 /* Remove duplicates. */
1673 /* For duplicates, make sure that the kept one has a valid
1676 if (got_offset
!= (bfd_vma
) -1)
1677 info
[kept
].got_offset
= got_offset
;
1679 curr
= info
[i
].addend
;
1680 got_offset
= info
[i
].got_offset
;
1682 /* Move a block of elements whose first one is different from
1686 for (src
= i
+ 1; src
< count
; src
++)
1688 if (info
[src
].addend
!= curr
)
1690 /* For duplicates, make sure that GOT_OFFSET is
1692 if (got_offset
== (bfd_vma
) -1)
1693 got_offset
= info
[src
].got_offset
;
1696 /* Make sure that the kept one has a valid got_offset. */
1697 if (got_offset
!= (bfd_vma
) -1)
1698 info
[kept
].got_offset
= got_offset
;
1706 /* Find the next duplicate. SRC will be kept. */
1707 prev
= info
[src
].addend
;
1708 got_offset
= info
[src
].got_offset
;
1709 for (dupes
= src
+ 1; dupes
< count
; dupes
++)
1711 curr
= info
[dupes
].addend
;
1714 /* Make sure that got_offset is valid. */
1715 if (got_offset
== (bfd_vma
) -1)
1716 got_offset
= info
[dupes
].got_offset
;
1718 /* For duplicates, make sure that the kept one has
1719 a valid got_offset. */
1720 if (got_offset
!= (bfd_vma
) -1)
1721 info
[dupes
- 1].got_offset
= got_offset
;
1724 got_offset
= info
[dupes
].got_offset
;
1728 /* How much to move. */
1732 if (len
== 1 && dupes
< count
)
1734 /* If we only move 1 element, we combine it with the next
1735 one. There must be at least a duplicate. Find the
1736 next different one. */
1737 for (diff
= dupes
+ 1, src
++; diff
< count
; diff
++, src
++)
1739 if (info
[diff
].addend
!= curr
)
1741 /* Make sure that got_offset is valid. */
1742 if (got_offset
== (bfd_vma
) -1)
1743 got_offset
= info
[diff
].got_offset
;
1746 /* Makre sure that the last duplicated one has an valid
1748 BFD_ASSERT (curr
== prev
);
1749 if (got_offset
!= (bfd_vma
) -1)
1750 info
[diff
- 1].got_offset
= got_offset
;
1754 /* Find the next duplicate. Track the current valid
1756 prev
= info
[diff
].addend
;
1757 got_offset
= info
[diff
].got_offset
;
1758 for (dupes
= diff
+ 1; dupes
< count
; dupes
++)
1760 curr
= info
[dupes
].addend
;
1763 /* For duplicates, make sure that GOT_OFFSET
1765 if (got_offset
== (bfd_vma
) -1)
1766 got_offset
= info
[dupes
].got_offset
;
1769 got_offset
= info
[dupes
].got_offset
;
1774 len
= diff
- src
+ 1;
1779 memmove (&info
[dest
], &info
[src
], len
* sizeof (*info
));
1788 /* When we get here, either there is no duplicate at all or
1789 the only duplicate is the last element. */
1792 /* If the last element is a duplicate, make sure that the
1793 kept one has a valid got_offset. We also update count. */
1794 if (got_offset
!= (bfd_vma
) -1)
1795 info
[dest
- 1].got_offset
= got_offset
;
1803 /* Find and/or create a descriptor for dynamic symbol info. This will
1804 vary based on global or local symbol, and the addend to the reloc.
1806 We don't sort when inserting. Also, we sort and eliminate
1807 duplicates if there is an unsorted section. Typically, this will
1808 only happen once, because we do all insertions before lookups. We
1809 then use bsearch to do a lookup. This also allows lookups to be
1810 fast. So we have fast insertion (O(log N) due to duplicate check),
1811 fast lookup (O(log N)) and one sort (O(N log N) expected time).
1812 Previously, all lookups were O(N) because of the use of the linked
1813 list and also all insertions were O(N) because of the check for
1814 duplicates. There are some complications here because the array
1815 size grows occasionally, which may add an O(N) factor, but this
1816 should be rare. Also, we free the excess array allocation, which
1817 requires a copy which is O(N), but this only happens once. */
1819 static struct elfNN_ia64_dyn_sym_info
*
1820 get_dyn_sym_info (struct elfNN_ia64_link_hash_table
*ia64_info
,
1821 struct elf_link_hash_entry
*h
, bfd
*abfd
,
1822 const Elf_Internal_Rela
*rel
, bfd_boolean create
)
1824 struct elfNN_ia64_dyn_sym_info
**info_p
, *info
, *dyn_i
, key
;
1825 unsigned int *count_p
, *sorted_count_p
, *size_p
;
1826 unsigned int count
, sorted_count
, size
;
1827 bfd_vma addend
= rel
? rel
->r_addend
: 0;
1832 struct elfNN_ia64_link_hash_entry
*global_h
;
1834 global_h
= (struct elfNN_ia64_link_hash_entry
*) h
;
1835 info_p
= &global_h
->info
;
1836 count_p
= &global_h
->count
;
1837 sorted_count_p
= &global_h
->sorted_count
;
1838 size_p
= &global_h
->size
;
1842 struct elfNN_ia64_local_hash_entry
*loc_h
;
1844 loc_h
= get_local_sym_hash (ia64_info
, abfd
, rel
, create
);
1847 BFD_ASSERT (!create
);
1851 info_p
= &loc_h
->info
;
1852 count_p
= &loc_h
->count
;
1853 sorted_count_p
= &loc_h
->sorted_count
;
1854 size_p
= &loc_h
->size
;
1858 sorted_count
= *sorted_count_p
;
1863 /* When we create the array, we don't check for duplicates,
1864 except in the previously sorted section if one exists, and
1865 against the last inserted entry. This allows insertions to
1871 /* Try bsearch first on the sorted section. */
1872 key
.addend
= addend
;
1873 dyn_i
= bsearch (&key
, info
, sorted_count
,
1874 sizeof (*info
), addend_compare
);
1882 /* Do a quick check for the last inserted entry. */
1883 dyn_i
= info
+ count
- 1;
1884 if (dyn_i
->addend
== addend
)
1892 /* It is the very first element. We create the array of size
1895 amt
= size
* sizeof (*info
);
1896 info
= bfd_malloc (amt
);
1898 else if (size
<= count
)
1900 /* We double the array size every time when we reach the
1903 amt
= size
* sizeof (*info
);
1904 info
= bfd_realloc (info
, amt
);
1915 /* Append the new one to the array. */
1916 dyn_i
= info
+ count
;
1917 memset (dyn_i
, 0, sizeof (*dyn_i
));
1918 dyn_i
->got_offset
= (bfd_vma
) -1;
1919 dyn_i
->addend
= addend
;
1921 /* We increment count only since the new ones are unsorted and
1922 may have duplicate. */
1927 /* It is a lookup without insertion. Sort array if part of the
1928 array isn't sorted. */
1929 if (count
!= sorted_count
)
1931 count
= sort_dyn_sym_info (info
, count
);
1933 *sorted_count_p
= count
;
1936 /* Free unused memory. */
1939 amt
= count
* sizeof (*info
);
1940 info
= bfd_malloc (amt
);
1943 memcpy (info
, *info_p
, amt
);
1950 key
.addend
= addend
;
1951 dyn_i
= bsearch (&key
, info
, count
,
1952 sizeof (*info
), addend_compare
);
1959 get_got (bfd
*abfd
, struct bfd_link_info
*info
,
1960 struct elfNN_ia64_link_hash_table
*ia64_info
)
1965 got
= ia64_info
->root
.sgot
;
1970 dynobj
= ia64_info
->root
.dynobj
;
1972 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1973 if (!_bfd_elf_create_got_section (dynobj
, info
))
1976 got
= ia64_info
->root
.sgot
;
1978 /* The .got section is always aligned at 8 bytes. */
1979 if (!bfd_set_section_alignment (got
, 3))
1982 flags
= bfd_section_flags (got
);
1983 if (!bfd_set_section_flags (got
, SEC_SMALL_DATA
| flags
))
1990 /* Create function descriptor section (.opd). This section is called .opd
1991 because it contains "official procedure descriptors". The "official"
1992 refers to the fact that these descriptors are used when taking the address
1993 of a procedure, thus ensuring a unique address for each procedure. */
1996 get_fptr (bfd
*abfd
, struct bfd_link_info
*info
,
1997 struct elfNN_ia64_link_hash_table
*ia64_info
)
2002 fptr
= ia64_info
->fptr_sec
;
2005 dynobj
= ia64_info
->root
.dynobj
;
2007 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2009 fptr
= bfd_make_section_anyway_with_flags (dynobj
, ".opd",
2014 | (bfd_link_pie (info
)
2016 | SEC_LINKER_CREATED
));
2018 || !bfd_set_section_alignment (fptr
, 4))
2024 ia64_info
->fptr_sec
= fptr
;
2026 if (bfd_link_pie (info
))
2029 fptr_rel
= bfd_make_section_anyway_with_flags (dynobj
, ".rela.opd",
2030 (SEC_ALLOC
| SEC_LOAD
2033 | SEC_LINKER_CREATED
2035 if (fptr_rel
== NULL
2036 || !bfd_set_section_alignment (fptr_rel
, LOG_SECTION_ALIGN
))
2042 ia64_info
->rel_fptr_sec
= fptr_rel
;
2050 get_pltoff (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2051 struct elfNN_ia64_link_hash_table
*ia64_info
)
2056 pltoff
= ia64_info
->pltoff_sec
;
2059 dynobj
= ia64_info
->root
.dynobj
;
2061 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2063 pltoff
= bfd_make_section_anyway_with_flags (dynobj
,
2064 ELF_STRING_ia64_pltoff
,
2070 | SEC_LINKER_CREATED
));
2072 || !bfd_set_section_alignment (pltoff
, 4))
2078 ia64_info
->pltoff_sec
= pltoff
;
2085 get_reloc_section (bfd
*abfd
,
2086 struct elfNN_ia64_link_hash_table
*ia64_info
,
2087 asection
*sec
, bfd_boolean create
)
2089 const char *srel_name
;
2093 srel_name
= (bfd_elf_string_from_elf_section
2094 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
2095 _bfd_elf_single_rel_hdr (sec
)->sh_name
));
2096 if (srel_name
== NULL
)
2099 dynobj
= ia64_info
->root
.dynobj
;
2101 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2103 srel
= bfd_get_linker_section (dynobj
, srel_name
);
2104 if (srel
== NULL
&& create
)
2106 srel
= bfd_make_section_anyway_with_flags (dynobj
, srel_name
,
2107 (SEC_ALLOC
| SEC_LOAD
2110 | SEC_LINKER_CREATED
2113 || !bfd_set_section_alignment (srel
, LOG_SECTION_ALIGN
))
2121 count_dyn_reloc (bfd
*abfd
, struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2122 asection
*srel
, int type
, bfd_boolean reltext
)
2124 struct elfNN_ia64_dyn_reloc_entry
*rent
;
2126 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2127 if (rent
->srel
== srel
&& rent
->type
== type
)
2132 rent
= ((struct elfNN_ia64_dyn_reloc_entry
*)
2133 bfd_alloc (abfd
, (bfd_size_type
) sizeof (*rent
)));
2137 rent
->next
= dyn_i
->reloc_entries
;
2141 dyn_i
->reloc_entries
= rent
;
2143 rent
->reltext
= reltext
;
2150 elfNN_ia64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
2152 const Elf_Internal_Rela
*relocs
)
2154 struct elfNN_ia64_link_hash_table
*ia64_info
;
2155 const Elf_Internal_Rela
*relend
;
2156 Elf_Internal_Shdr
*symtab_hdr
;
2157 const Elf_Internal_Rela
*rel
;
2158 asection
*got
, *fptr
, *srel
, *pltoff
;
2167 NEED_LTOFF_FPTR
= 128,
2173 struct elf_link_hash_entry
*h
;
2174 unsigned long r_symndx
;
2175 bfd_boolean maybe_dynamic
;
2177 if (bfd_link_relocatable (info
))
2180 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2181 ia64_info
= elfNN_ia64_hash_table (info
);
2182 if (ia64_info
== NULL
)
2185 got
= fptr
= srel
= pltoff
= NULL
;
2187 relend
= relocs
+ sec
->reloc_count
;
2189 /* We scan relocations first to create dynamic relocation arrays. We
2190 modified get_dyn_sym_info to allow fast insertion and support fast
2191 lookup in the next loop. */
2192 for (rel
= relocs
; rel
< relend
; ++rel
)
2194 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
2195 if (r_symndx
>= symtab_hdr
->sh_info
)
2197 long indx
= r_symndx
- symtab_hdr
->sh_info
;
2198 h
= elf_sym_hashes (abfd
)[indx
];
2199 while (h
->root
.type
== bfd_link_hash_indirect
2200 || h
->root
.type
== bfd_link_hash_warning
)
2201 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2206 if (h
&& UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
2209 /* We can only get preliminary data on whether a symbol is
2210 locally or externally defined, as not all of the input files
2211 have yet been processed. Do something with what we know, as
2212 this may help reduce memory usage and processing time later. */
2213 maybe_dynamic
= (h
&& ((!bfd_link_executable (info
)
2214 && (!SYMBOLIC_BIND (info
, h
)
2215 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
2217 || h
->root
.type
== bfd_link_hash_defweak
));
2220 switch (ELFNN_R_TYPE (rel
->r_info
))
2222 case R_IA64_TPREL64MSB
:
2223 case R_IA64_TPREL64LSB
:
2224 if (bfd_link_pic (info
) || maybe_dynamic
)
2225 need_entry
= NEED_DYNREL
;
2228 case R_IA64_LTOFF_TPREL22
:
2229 need_entry
= NEED_TPREL
;
2230 if (bfd_link_pic (info
))
2231 info
->flags
|= DF_STATIC_TLS
;
2234 case R_IA64_DTPREL32MSB
:
2235 case R_IA64_DTPREL32LSB
:
2236 case R_IA64_DTPREL64MSB
:
2237 case R_IA64_DTPREL64LSB
:
2238 if (bfd_link_pic (info
) || maybe_dynamic
)
2239 need_entry
= NEED_DYNREL
;
2242 case R_IA64_LTOFF_DTPREL22
:
2243 need_entry
= NEED_DTPREL
;
2246 case R_IA64_DTPMOD64MSB
:
2247 case R_IA64_DTPMOD64LSB
:
2248 if (bfd_link_pic (info
) || maybe_dynamic
)
2249 need_entry
= NEED_DYNREL
;
2252 case R_IA64_LTOFF_DTPMOD22
:
2253 need_entry
= NEED_DTPMOD
;
2256 case R_IA64_LTOFF_FPTR22
:
2257 case R_IA64_LTOFF_FPTR64I
:
2258 case R_IA64_LTOFF_FPTR32MSB
:
2259 case R_IA64_LTOFF_FPTR32LSB
:
2260 case R_IA64_LTOFF_FPTR64MSB
:
2261 case R_IA64_LTOFF_FPTR64LSB
:
2262 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
2265 case R_IA64_FPTR64I
:
2266 case R_IA64_FPTR32MSB
:
2267 case R_IA64_FPTR32LSB
:
2268 case R_IA64_FPTR64MSB
:
2269 case R_IA64_FPTR64LSB
:
2270 if (bfd_link_pic (info
) || h
)
2271 need_entry
= NEED_FPTR
| NEED_DYNREL
;
2273 need_entry
= NEED_FPTR
;
2276 case R_IA64_LTOFF22
:
2277 case R_IA64_LTOFF64I
:
2278 need_entry
= NEED_GOT
;
2281 case R_IA64_LTOFF22X
:
2282 need_entry
= NEED_GOTX
;
2285 case R_IA64_PLTOFF22
:
2286 case R_IA64_PLTOFF64I
:
2287 case R_IA64_PLTOFF64MSB
:
2288 case R_IA64_PLTOFF64LSB
:
2289 need_entry
= NEED_PLTOFF
;
2293 need_entry
|= NEED_MIN_PLT
;
2297 (*info
->callbacks
->warning
)
2298 (info
, _("@pltoff reloc against local symbol"), 0,
2299 abfd
, 0, (bfd_vma
) 0);
2303 case R_IA64_PCREL21B
:
2304 case R_IA64_PCREL60B
:
2305 /* Depending on where this symbol is defined, we may or may not
2306 need a full plt entry. Only skip if we know we'll not need
2307 the entry -- static or symbolic, and the symbol definition
2308 has already been seen. */
2309 if (maybe_dynamic
&& rel
->r_addend
== 0)
2310 need_entry
= NEED_FULL_PLT
;
2316 case R_IA64_DIR32MSB
:
2317 case R_IA64_DIR32LSB
:
2318 case R_IA64_DIR64MSB
:
2319 case R_IA64_DIR64LSB
:
2320 /* Shared objects will always need at least a REL relocation. */
2321 if (bfd_link_pic (info
) || maybe_dynamic
)
2322 need_entry
= NEED_DYNREL
;
2325 case R_IA64_IPLTMSB
:
2326 case R_IA64_IPLTLSB
:
2327 /* Shared objects will always need at least a REL relocation. */
2328 if (bfd_link_pic (info
) || maybe_dynamic
)
2329 need_entry
= NEED_DYNREL
;
2332 case R_IA64_PCREL22
:
2333 case R_IA64_PCREL64I
:
2334 case R_IA64_PCREL32MSB
:
2335 case R_IA64_PCREL32LSB
:
2336 case R_IA64_PCREL64MSB
:
2337 case R_IA64_PCREL64LSB
:
2339 need_entry
= NEED_DYNREL
;
2346 if ((need_entry
& NEED_FPTR
) != 0
2349 (*info
->callbacks
->warning
)
2350 (info
, _("non-zero addend in @fptr reloc"), 0,
2351 abfd
, 0, (bfd_vma
) 0);
2354 if (get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, TRUE
) == NULL
)
2358 /* Now, we only do lookup without insertion, which is very fast
2359 with the modified get_dyn_sym_info. */
2360 for (rel
= relocs
; rel
< relend
; ++rel
)
2362 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2363 int dynrel_type
= R_IA64_NONE
;
2365 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
2366 if (r_symndx
>= symtab_hdr
->sh_info
)
2368 /* We're dealing with a global symbol -- find its hash entry
2369 and mark it as being referenced. */
2370 long indx
= r_symndx
- symtab_hdr
->sh_info
;
2371 h
= elf_sym_hashes (abfd
)[indx
];
2372 while (h
->root
.type
== bfd_link_hash_indirect
2373 || h
->root
.type
== bfd_link_hash_warning
)
2374 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2376 /* PR15323, ref flags aren't set for references in the same
2383 if (h
&& UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
2386 /* We can only get preliminary data on whether a symbol is
2387 locally or externally defined, as not all of the input files
2388 have yet been processed. Do something with what we know, as
2389 this may help reduce memory usage and processing time later. */
2390 maybe_dynamic
= (h
&& ((!bfd_link_executable (info
)
2391 && (!SYMBOLIC_BIND (info
, h
)
2392 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
2394 || h
->root
.type
== bfd_link_hash_defweak
));
2397 switch (ELFNN_R_TYPE (rel
->r_info
))
2399 case R_IA64_TPREL64MSB
:
2400 case R_IA64_TPREL64LSB
:
2401 if (bfd_link_pic (info
) || maybe_dynamic
)
2402 need_entry
= NEED_DYNREL
;
2403 dynrel_type
= R_IA64_TPREL64LSB
;
2404 if (bfd_link_pic (info
))
2405 info
->flags
|= DF_STATIC_TLS
;
2408 case R_IA64_LTOFF_TPREL22
:
2409 need_entry
= NEED_TPREL
;
2410 if (bfd_link_pic (info
))
2411 info
->flags
|= DF_STATIC_TLS
;
2414 case R_IA64_DTPREL32MSB
:
2415 case R_IA64_DTPREL32LSB
:
2416 case R_IA64_DTPREL64MSB
:
2417 case R_IA64_DTPREL64LSB
:
2418 if (bfd_link_pic (info
) || maybe_dynamic
)
2419 need_entry
= NEED_DYNREL
;
2420 dynrel_type
= R_IA64_DTPRELNNLSB
;
2423 case R_IA64_LTOFF_DTPREL22
:
2424 need_entry
= NEED_DTPREL
;
2427 case R_IA64_DTPMOD64MSB
:
2428 case R_IA64_DTPMOD64LSB
:
2429 if (bfd_link_pic (info
) || maybe_dynamic
)
2430 need_entry
= NEED_DYNREL
;
2431 dynrel_type
= R_IA64_DTPMOD64LSB
;
2434 case R_IA64_LTOFF_DTPMOD22
:
2435 need_entry
= NEED_DTPMOD
;
2438 case R_IA64_LTOFF_FPTR22
:
2439 case R_IA64_LTOFF_FPTR64I
:
2440 case R_IA64_LTOFF_FPTR32MSB
:
2441 case R_IA64_LTOFF_FPTR32LSB
:
2442 case R_IA64_LTOFF_FPTR64MSB
:
2443 case R_IA64_LTOFF_FPTR64LSB
:
2444 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
2447 case R_IA64_FPTR64I
:
2448 case R_IA64_FPTR32MSB
:
2449 case R_IA64_FPTR32LSB
:
2450 case R_IA64_FPTR64MSB
:
2451 case R_IA64_FPTR64LSB
:
2452 if (bfd_link_pic (info
) || h
)
2453 need_entry
= NEED_FPTR
| NEED_DYNREL
;
2455 need_entry
= NEED_FPTR
;
2456 dynrel_type
= R_IA64_FPTRNNLSB
;
2459 case R_IA64_LTOFF22
:
2460 case R_IA64_LTOFF64I
:
2461 need_entry
= NEED_GOT
;
2464 case R_IA64_LTOFF22X
:
2465 need_entry
= NEED_GOTX
;
2468 case R_IA64_PLTOFF22
:
2469 case R_IA64_PLTOFF64I
:
2470 case R_IA64_PLTOFF64MSB
:
2471 case R_IA64_PLTOFF64LSB
:
2472 need_entry
= NEED_PLTOFF
;
2476 need_entry
|= NEED_MIN_PLT
;
2480 case R_IA64_PCREL21B
:
2481 case R_IA64_PCREL60B
:
2482 /* Depending on where this symbol is defined, we may or may not
2483 need a full plt entry. Only skip if we know we'll not need
2484 the entry -- static or symbolic, and the symbol definition
2485 has already been seen. */
2486 if (maybe_dynamic
&& rel
->r_addend
== 0)
2487 need_entry
= NEED_FULL_PLT
;
2493 case R_IA64_DIR32MSB
:
2494 case R_IA64_DIR32LSB
:
2495 case R_IA64_DIR64MSB
:
2496 case R_IA64_DIR64LSB
:
2497 /* Shared objects will always need at least a REL relocation. */
2498 if (bfd_link_pic (info
) || maybe_dynamic
)
2499 need_entry
= NEED_DYNREL
;
2500 dynrel_type
= R_IA64_DIRNNLSB
;
2503 case R_IA64_IPLTMSB
:
2504 case R_IA64_IPLTLSB
:
2505 /* Shared objects will always need at least a REL relocation. */
2506 if (bfd_link_pic (info
) || maybe_dynamic
)
2507 need_entry
= NEED_DYNREL
;
2508 dynrel_type
= R_IA64_IPLTLSB
;
2511 case R_IA64_PCREL22
:
2512 case R_IA64_PCREL64I
:
2513 case R_IA64_PCREL32MSB
:
2514 case R_IA64_PCREL32LSB
:
2515 case R_IA64_PCREL64MSB
:
2516 case R_IA64_PCREL64LSB
:
2518 need_entry
= NEED_DYNREL
;
2519 dynrel_type
= R_IA64_PCRELNNLSB
;
2526 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, FALSE
);
2528 /* Record whether or not this is a local symbol. */
2531 /* Create what's needed. */
2532 if (need_entry
& (NEED_GOT
| NEED_GOTX
| NEED_TPREL
2533 | NEED_DTPMOD
| NEED_DTPREL
))
2537 got
= get_got (abfd
, info
, ia64_info
);
2541 if (need_entry
& NEED_GOT
)
2542 dyn_i
->want_got
= 1;
2543 if (need_entry
& NEED_GOTX
)
2544 dyn_i
->want_gotx
= 1;
2545 if (need_entry
& NEED_TPREL
)
2546 dyn_i
->want_tprel
= 1;
2547 if (need_entry
& NEED_DTPMOD
)
2548 dyn_i
->want_dtpmod
= 1;
2549 if (need_entry
& NEED_DTPREL
)
2550 dyn_i
->want_dtprel
= 1;
2552 if (need_entry
& NEED_FPTR
)
2556 fptr
= get_fptr (abfd
, info
, ia64_info
);
2561 /* FPTRs for shared libraries are allocated by the dynamic
2562 linker. Make sure this local symbol will appear in the
2563 dynamic symbol table. */
2564 if (!h
&& bfd_link_pic (info
))
2566 if (! (bfd_elf_link_record_local_dynamic_symbol
2567 (info
, abfd
, (long) r_symndx
)))
2571 dyn_i
->want_fptr
= 1;
2573 if (need_entry
& NEED_LTOFF_FPTR
)
2574 dyn_i
->want_ltoff_fptr
= 1;
2575 if (need_entry
& (NEED_MIN_PLT
| NEED_FULL_PLT
))
2577 if (!ia64_info
->root
.dynobj
)
2578 ia64_info
->root
.dynobj
= abfd
;
2580 dyn_i
->want_plt
= 1;
2582 if (need_entry
& NEED_FULL_PLT
)
2583 dyn_i
->want_plt2
= 1;
2584 if (need_entry
& NEED_PLTOFF
)
2586 /* This is needed here, in case @pltoff is used in a non-shared
2590 pltoff
= get_pltoff (abfd
, info
, ia64_info
);
2595 dyn_i
->want_pltoff
= 1;
2597 if ((need_entry
& NEED_DYNREL
) && (sec
->flags
& SEC_ALLOC
))
2601 srel
= get_reloc_section (abfd
, ia64_info
, sec
, TRUE
);
2605 if (!count_dyn_reloc (abfd
, dyn_i
, srel
, dynrel_type
,
2606 (sec
->flags
& SEC_READONLY
) != 0))
2614 /* For cleanliness, and potentially faster dynamic loading, allocate
2615 external GOT entries first. */
2618 allocate_global_data_got (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2621 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2623 if ((dyn_i
->want_got
|| dyn_i
->want_gotx
)
2624 && ! dyn_i
->want_fptr
2625 && elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0))
2627 dyn_i
->got_offset
= x
->ofs
;
2630 if (dyn_i
->want_tprel
)
2632 dyn_i
->tprel_offset
= x
->ofs
;
2635 if (dyn_i
->want_dtpmod
)
2637 if (elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0))
2639 dyn_i
->dtpmod_offset
= x
->ofs
;
2644 struct elfNN_ia64_link_hash_table
*ia64_info
;
2646 ia64_info
= elfNN_ia64_hash_table (x
->info
);
2647 if (ia64_info
== NULL
)
2650 if (ia64_info
->self_dtpmod_offset
== (bfd_vma
) -1)
2652 ia64_info
->self_dtpmod_offset
= x
->ofs
;
2655 dyn_i
->dtpmod_offset
= ia64_info
->self_dtpmod_offset
;
2658 if (dyn_i
->want_dtprel
)
2660 dyn_i
->dtprel_offset
= x
->ofs
;
2666 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
2669 allocate_global_fptr_got (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2672 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2676 && elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, R_IA64_FPTRNNLSB
))
2678 dyn_i
->got_offset
= x
->ofs
;
2684 /* Lastly, allocate all the GOT entries for local data. */
2687 allocate_local_got (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2690 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2692 if ((dyn_i
->want_got
|| dyn_i
->want_gotx
)
2693 && !elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0))
2695 dyn_i
->got_offset
= x
->ofs
;
2701 /* Search for the index of a global symbol in it's defining object file. */
2704 global_sym_index (struct elf_link_hash_entry
*h
)
2706 struct elf_link_hash_entry
**p
;
2709 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
2710 || h
->root
.type
== bfd_link_hash_defweak
);
2712 obj
= h
->root
.u
.def
.section
->owner
;
2713 for (p
= elf_sym_hashes (obj
); *p
!= h
; ++p
)
2716 return p
- elf_sym_hashes (obj
) + elf_tdata (obj
)->symtab_hdr
.sh_info
;
2719 /* Allocate function descriptors. We can do these for every function
2720 in a main executable that is not exported. */
2723 allocate_fptr (struct elfNN_ia64_dyn_sym_info
*dyn_i
, void * data
)
2725 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2727 if (dyn_i
->want_fptr
)
2729 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2732 while (h
->root
.type
== bfd_link_hash_indirect
2733 || h
->root
.type
== bfd_link_hash_warning
)
2734 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2736 if (!bfd_link_executable (x
->info
)
2738 || (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2739 && !UNDEFWEAK_NO_DYNAMIC_RELOC (x
->info
, h
))
2740 || (h
->root
.type
!= bfd_link_hash_undefweak
2741 && h
->root
.type
!= bfd_link_hash_undefined
)))
2743 if (h
&& h
->dynindx
== -1)
2745 BFD_ASSERT ((h
->root
.type
== bfd_link_hash_defined
)
2746 || (h
->root
.type
== bfd_link_hash_defweak
));
2748 if (!bfd_elf_link_record_local_dynamic_symbol
2749 (x
->info
, h
->root
.u
.def
.section
->owner
,
2750 global_sym_index (h
)))
2754 dyn_i
->want_fptr
= 0;
2756 else if (h
== NULL
|| h
->dynindx
== -1)
2758 dyn_i
->fptr_offset
= x
->ofs
;
2762 dyn_i
->want_fptr
= 0;
2767 /* Allocate all the minimal PLT entries. */
2770 allocate_plt_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2773 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2775 if (dyn_i
->want_plt
)
2777 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2780 while (h
->root
.type
== bfd_link_hash_indirect
2781 || h
->root
.type
== bfd_link_hash_warning
)
2782 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2784 /* ??? Versioned symbols seem to lose NEEDS_PLT. */
2785 if (elfNN_ia64_dynamic_symbol_p (h
, x
->info
, 0))
2787 bfd_size_type offset
= x
->ofs
;
2789 offset
= PLT_HEADER_SIZE
;
2790 dyn_i
->plt_offset
= offset
;
2791 x
->ofs
= offset
+ PLT_MIN_ENTRY_SIZE
;
2793 dyn_i
->want_pltoff
= 1;
2797 dyn_i
->want_plt
= 0;
2798 dyn_i
->want_plt2
= 0;
2804 /* Allocate all the full PLT entries. */
2807 allocate_plt2_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2810 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2812 if (dyn_i
->want_plt2
)
2814 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2815 bfd_size_type ofs
= x
->ofs
;
2817 dyn_i
->plt2_offset
= ofs
;
2818 x
->ofs
= ofs
+ PLT_FULL_ENTRY_SIZE
;
2820 while (h
->root
.type
== bfd_link_hash_indirect
2821 || h
->root
.type
== bfd_link_hash_warning
)
2822 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2823 dyn_i
->h
->plt
.offset
= ofs
;
2828 /* Allocate all the PLTOFF entries requested by relocations and
2829 plt entries. We can't share space with allocated FPTR entries,
2830 because the latter are not necessarily addressable by the GP.
2831 ??? Relaxation might be able to determine that they are. */
2834 allocate_pltoff_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2837 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2839 if (dyn_i
->want_pltoff
)
2841 dyn_i
->pltoff_offset
= x
->ofs
;
2847 /* Allocate dynamic relocations for those symbols that turned out
2851 allocate_dynrel_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2854 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2855 struct elfNN_ia64_link_hash_table
*ia64_info
;
2856 struct elfNN_ia64_dyn_reloc_entry
*rent
;
2857 bfd_boolean dynamic_symbol
, shared
, resolved_zero
;
2859 ia64_info
= elfNN_ia64_hash_table (x
->info
);
2860 if (ia64_info
== NULL
)
2863 /* Note that this can't be used in relation to FPTR relocs below. */
2864 dynamic_symbol
= elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0);
2866 shared
= bfd_link_pic (x
->info
);
2867 resolved_zero
= (dyn_i
->h
2868 && UNDEFWEAK_NO_DYNAMIC_RELOC (x
->info
,
2871 /* Take care of the GOT and PLT relocations. */
2874 && (dynamic_symbol
|| shared
)
2875 && (dyn_i
->want_got
|| dyn_i
->want_gotx
))
2876 || (dyn_i
->want_ltoff_fptr
2878 && dyn_i
->h
->dynindx
!= -1))
2880 if (!dyn_i
->want_ltoff_fptr
2881 || !bfd_link_pie (x
->info
)
2883 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
2884 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
2886 if ((dynamic_symbol
|| shared
) && dyn_i
->want_tprel
)
2887 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
2888 if (dynamic_symbol
&& dyn_i
->want_dtpmod
)
2889 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
2890 if (dynamic_symbol
&& dyn_i
->want_dtprel
)
2891 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
2896 if (ia64_info
->rel_fptr_sec
&& dyn_i
->want_fptr
)
2898 if (dyn_i
->h
== NULL
|| dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
2899 ia64_info
->rel_fptr_sec
->size
+= sizeof (ElfNN_External_Rela
);
2902 if (!resolved_zero
&& dyn_i
->want_pltoff
)
2904 bfd_size_type t
= 0;
2906 /* Dynamic symbols get one IPLT relocation. Local symbols in
2907 shared libraries get two REL relocations. Local symbols in
2908 main applications get nothing. */
2910 t
= sizeof (ElfNN_External_Rela
);
2912 t
= 2 * sizeof (ElfNN_External_Rela
);
2914 ia64_info
->rel_pltoff_sec
->size
+= t
;
2917 /* Take care of the normal data relocations. */
2919 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2921 int count
= rent
->count
;
2925 case R_IA64_FPTR32LSB
:
2926 case R_IA64_FPTR64LSB
:
2927 /* Allocate one iff !want_fptr and not PIE, which by this point
2928 will be true only if we're actually allocating one statically
2929 in the main executable. Position independent executables
2930 need a relative reloc. */
2931 if (dyn_i
->want_fptr
&& !bfd_link_pie (x
->info
))
2934 case R_IA64_PCREL32LSB
:
2935 case R_IA64_PCREL64LSB
:
2936 if (!dynamic_symbol
)
2939 case R_IA64_DIR32LSB
:
2940 case R_IA64_DIR64LSB
:
2941 if (!dynamic_symbol
&& !shared
)
2944 case R_IA64_IPLTLSB
:
2945 if (!dynamic_symbol
&& !shared
)
2947 /* Use two REL relocations for IPLT relocations
2948 against local symbols. */
2949 if (!dynamic_symbol
)
2952 case R_IA64_DTPREL32LSB
:
2953 case R_IA64_TPREL64LSB
:
2954 case R_IA64_DTPREL64LSB
:
2955 case R_IA64_DTPMOD64LSB
:
2961 ia64_info
->reltext
= 1;
2962 rent
->srel
->size
+= sizeof (ElfNN_External_Rela
) * count
;
2969 elfNN_ia64_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2970 struct elf_link_hash_entry
*h
)
2972 /* ??? Undefined symbols with PLT entries should be re-defined
2973 to be the PLT entry. */
2975 /* If this is a weak symbol, and there is a real definition, the
2976 processor independent code will have arranged for us to see the
2977 real definition first, and we can just use the same value. */
2978 if (h
->is_weakalias
)
2980 struct elf_link_hash_entry
*def
= weakdef (h
);
2981 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
2982 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
2983 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
2987 /* If this is a reference to a symbol defined by a dynamic object which
2988 is not a function, we might allocate the symbol in our .dynbss section
2989 and allocate a COPY dynamic relocation.
2991 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2998 elfNN_ia64_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2999 struct bfd_link_info
*info
)
3001 struct elfNN_ia64_allocate_data data
;
3002 struct elfNN_ia64_link_hash_table
*ia64_info
;
3005 bfd_boolean relplt
= FALSE
;
3007 ia64_info
= elfNN_ia64_hash_table (info
);
3008 if (ia64_info
== NULL
)
3010 dynobj
= ia64_info
->root
.dynobj
;
3011 ia64_info
->self_dtpmod_offset
= (bfd_vma
) -1;
3012 BFD_ASSERT(dynobj
!= NULL
);
3015 /* Set the contents of the .interp section to the interpreter. */
3016 if (ia64_info
->root
.dynamic_sections_created
3017 && bfd_link_executable (info
) && !info
->nointerp
)
3019 sec
= bfd_get_linker_section (dynobj
, ".interp");
3020 BFD_ASSERT (sec
!= NULL
);
3021 sec
->contents
= (bfd_byte
*) ELF_DYNAMIC_INTERPRETER
;
3022 sec
->size
= strlen (ELF_DYNAMIC_INTERPRETER
) + 1;
3025 /* Allocate the GOT entries. */
3027 if (ia64_info
->root
.sgot
)
3030 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_data_got
, &data
);
3031 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_fptr_got
, &data
);
3032 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_local_got
, &data
);
3033 ia64_info
->root
.sgot
->size
= data
.ofs
;
3036 /* Allocate the FPTR entries. */
3038 if (ia64_info
->fptr_sec
)
3041 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_fptr
, &data
);
3042 ia64_info
->fptr_sec
->size
= data
.ofs
;
3045 /* Now that we've seen all of the input files, we can decide which
3046 symbols need plt entries. Allocate the minimal PLT entries first.
3047 We do this even though dynamic_sections_created may be FALSE, because
3048 this has the side-effect of clearing want_plt and want_plt2. */
3051 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_plt_entries
, &data
);
3053 ia64_info
->minplt_entries
= 0;
3056 ia64_info
->minplt_entries
3057 = (data
.ofs
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
3060 /* Align the pointer for the plt2 entries. */
3061 data
.ofs
= (data
.ofs
+ 31) & (bfd_vma
) -32;
3063 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_plt2_entries
, &data
);
3064 if (data
.ofs
!= 0 || ia64_info
->root
.dynamic_sections_created
)
3066 /* FIXME: we always reserve the memory for dynamic linker even if
3067 there are no PLT entries since dynamic linker may assume the
3068 reserved memory always exists. */
3070 BFD_ASSERT (ia64_info
->root
.dynamic_sections_created
);
3072 ia64_info
->root
.splt
->size
= data
.ofs
;
3074 /* If we've got a .plt, we need some extra memory for the dynamic
3075 linker. We stuff these in .got.plt. */
3076 ia64_info
->root
.sgotplt
->size
= 8 * PLT_RESERVED_WORDS
;
3079 /* Allocate the PLTOFF entries. */
3081 if (ia64_info
->pltoff_sec
)
3084 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_pltoff_entries
, &data
);
3085 ia64_info
->pltoff_sec
->size
= data
.ofs
;
3088 if (ia64_info
->root
.dynamic_sections_created
)
3090 /* Allocate space for the dynamic relocations that turned out to be
3093 if (bfd_link_pic (info
) && ia64_info
->self_dtpmod_offset
!= (bfd_vma
) -1)
3094 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
3095 data
.only_got
= FALSE
;
3096 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_dynrel_entries
, &data
);
3099 /* We have now determined the sizes of the various dynamic sections.
3100 Allocate memory for them. */
3101 for (sec
= dynobj
->sections
; sec
!= NULL
; sec
= sec
->next
)
3105 if (!(sec
->flags
& SEC_LINKER_CREATED
))
3108 /* If we don't need this section, strip it from the output file.
3109 There were several sections primarily related to dynamic
3110 linking that must be create before the linker maps input
3111 sections to output sections. The linker does that before
3112 bfd_elf_size_dynamic_sections is called, and it is that
3113 function which decides whether anything needs to go into
3116 strip
= (sec
->size
== 0);
3118 if (sec
== ia64_info
->root
.sgot
)
3120 else if (sec
== ia64_info
->root
.srelgot
)
3123 ia64_info
->root
.srelgot
= NULL
;
3125 /* We use the reloc_count field as a counter if we need to
3126 copy relocs into the output file. */
3127 sec
->reloc_count
= 0;
3129 else if (sec
== ia64_info
->fptr_sec
)
3132 ia64_info
->fptr_sec
= NULL
;
3134 else if (sec
== ia64_info
->rel_fptr_sec
)
3137 ia64_info
->rel_fptr_sec
= NULL
;
3139 /* We use the reloc_count field as a counter if we need to
3140 copy relocs into the output file. */
3141 sec
->reloc_count
= 0;
3143 else if (sec
== ia64_info
->root
.splt
)
3146 ia64_info
->root
.splt
= NULL
;
3148 else if (sec
== ia64_info
->pltoff_sec
)
3151 ia64_info
->pltoff_sec
= NULL
;
3153 else if (sec
== ia64_info
->rel_pltoff_sec
)
3156 ia64_info
->rel_pltoff_sec
= NULL
;
3160 /* We use the reloc_count field as a counter if we need to
3161 copy relocs into the output file. */
3162 sec
->reloc_count
= 0;
3169 /* It's OK to base decisions on the section name, because none
3170 of the dynobj section names depend upon the input files. */
3171 name
= bfd_section_name (sec
);
3173 if (strcmp (name
, ".got.plt") == 0)
3175 else if (CONST_STRNEQ (name
, ".rel"))
3179 /* We use the reloc_count field as a counter if we need to
3180 copy relocs into the output file. */
3181 sec
->reloc_count
= 0;
3189 sec
->flags
|= SEC_EXCLUDE
;
3192 /* Allocate memory for the section contents. */
3193 sec
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, sec
->size
);
3194 if (sec
->contents
== NULL
&& sec
->size
!= 0)
3199 if (ia64_info
->root
.dynamic_sections_created
)
3201 /* Add some entries to the .dynamic section. We fill in the values
3202 later (in finish_dynamic_sections) but we must add the entries now
3203 so that we get the correct size for the .dynamic section. */
3205 if (bfd_link_executable (info
))
3207 /* The DT_DEBUG entry is filled in by the dynamic linker and used
3209 #define add_dynamic_entry(TAG, VAL) \
3210 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3212 if (!add_dynamic_entry (DT_DEBUG
, 0))
3216 if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE
, 0))
3218 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3223 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3224 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3225 || !add_dynamic_entry (DT_JMPREL
, 0))
3229 if (!add_dynamic_entry (DT_RELA
, 0)
3230 || !add_dynamic_entry (DT_RELASZ
, 0)
3231 || !add_dynamic_entry (DT_RELAENT
, sizeof (ElfNN_External_Rela
)))
3234 if (ia64_info
->reltext
)
3236 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3238 info
->flags
|= DF_TEXTREL
;
3242 /* ??? Perhaps force __gp local. */
3248 elfNN_ia64_install_dyn_reloc (bfd
*abfd
, struct bfd_link_info
*info
,
3249 asection
*sec
, asection
*srel
,
3250 bfd_vma offset
, unsigned int type
,
3251 long dynindx
, bfd_vma addend
)
3253 Elf_Internal_Rela outrel
;
3256 BFD_ASSERT (dynindx
!= -1);
3257 outrel
.r_info
= ELFNN_R_INFO (dynindx
, type
);
3258 outrel
.r_addend
= addend
;
3259 outrel
.r_offset
= _bfd_elf_section_offset (abfd
, info
, sec
, offset
);
3260 if (outrel
.r_offset
>= (bfd_vma
) -2)
3262 /* Run for the hills. We shouldn't be outputting a relocation
3263 for this. So do what everyone else does and output a no-op. */
3264 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
3265 outrel
.r_addend
= 0;
3266 outrel
.r_offset
= 0;
3269 outrel
.r_offset
+= sec
->output_section
->vma
+ sec
->output_offset
;
3271 loc
= srel
->contents
;
3272 loc
+= srel
->reloc_count
++ * sizeof (ElfNN_External_Rela
);
3273 bfd_elfNN_swap_reloca_out (abfd
, &outrel
, loc
);
3274 BFD_ASSERT (sizeof (ElfNN_External_Rela
) * srel
->reloc_count
<= srel
->size
);
3277 /* Store an entry for target address TARGET_ADDR in the linkage table
3278 and return the gp-relative address of the linkage table entry. */
3281 set_got_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3282 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3283 long dynindx
, bfd_vma addend
, bfd_vma value
,
3284 unsigned int dyn_r_type
)
3286 struct elfNN_ia64_link_hash_table
*ia64_info
;
3291 ia64_info
= elfNN_ia64_hash_table (info
);
3292 if (ia64_info
== NULL
)
3295 got_sec
= ia64_info
->root
.sgot
;
3299 case R_IA64_TPREL64LSB
:
3300 done
= dyn_i
->tprel_done
;
3301 dyn_i
->tprel_done
= TRUE
;
3302 got_offset
= dyn_i
->tprel_offset
;
3304 case R_IA64_DTPMOD64LSB
:
3305 if (dyn_i
->dtpmod_offset
!= ia64_info
->self_dtpmod_offset
)
3307 done
= dyn_i
->dtpmod_done
;
3308 dyn_i
->dtpmod_done
= TRUE
;
3312 done
= ia64_info
->self_dtpmod_done
;
3313 ia64_info
->self_dtpmod_done
= TRUE
;
3316 got_offset
= dyn_i
->dtpmod_offset
;
3318 case R_IA64_DTPREL32LSB
:
3319 case R_IA64_DTPREL64LSB
:
3320 done
= dyn_i
->dtprel_done
;
3321 dyn_i
->dtprel_done
= TRUE
;
3322 got_offset
= dyn_i
->dtprel_offset
;
3325 done
= dyn_i
->got_done
;
3326 dyn_i
->got_done
= TRUE
;
3327 got_offset
= dyn_i
->got_offset
;
3331 BFD_ASSERT ((got_offset
& 7) == 0);
3335 /* Store the target address in the linkage table entry. */
3336 bfd_put_64 (abfd
, value
, got_sec
->contents
+ got_offset
);
3338 /* Install a dynamic relocation if needed. */
3339 if (((bfd_link_pic (info
)
3341 || (ELF_ST_VISIBILITY (dyn_i
->h
->other
) == STV_DEFAULT
3342 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, dyn_i
->h
))
3343 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
3344 && dyn_r_type
!= R_IA64_DTPREL32LSB
3345 && dyn_r_type
!= R_IA64_DTPREL64LSB
)
3346 || elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, info
, dyn_r_type
)
3348 && (dyn_r_type
== R_IA64_FPTR32LSB
3349 || dyn_r_type
== R_IA64_FPTR64LSB
)))
3350 && (!dyn_i
->want_ltoff_fptr
3351 || !bfd_link_pie (info
)
3353 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
3356 && dyn_r_type
!= R_IA64_TPREL64LSB
3357 && dyn_r_type
!= R_IA64_DTPMOD64LSB
3358 && dyn_r_type
!= R_IA64_DTPREL32LSB
3359 && dyn_r_type
!= R_IA64_DTPREL64LSB
)
3361 dyn_r_type
= R_IA64_RELNNLSB
;
3366 if (bfd_big_endian (abfd
))
3370 case R_IA64_REL32LSB
:
3371 dyn_r_type
= R_IA64_REL32MSB
;
3373 case R_IA64_DIR32LSB
:
3374 dyn_r_type
= R_IA64_DIR32MSB
;
3376 case R_IA64_FPTR32LSB
:
3377 dyn_r_type
= R_IA64_FPTR32MSB
;
3379 case R_IA64_DTPREL32LSB
:
3380 dyn_r_type
= R_IA64_DTPREL32MSB
;
3382 case R_IA64_REL64LSB
:
3383 dyn_r_type
= R_IA64_REL64MSB
;
3385 case R_IA64_DIR64LSB
:
3386 dyn_r_type
= R_IA64_DIR64MSB
;
3388 case R_IA64_FPTR64LSB
:
3389 dyn_r_type
= R_IA64_FPTR64MSB
;
3391 case R_IA64_TPREL64LSB
:
3392 dyn_r_type
= R_IA64_TPREL64MSB
;
3394 case R_IA64_DTPMOD64LSB
:
3395 dyn_r_type
= R_IA64_DTPMOD64MSB
;
3397 case R_IA64_DTPREL64LSB
:
3398 dyn_r_type
= R_IA64_DTPREL64MSB
;
3406 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, got_sec
,
3407 ia64_info
->root
.srelgot
,
3408 got_offset
, dyn_r_type
,
3413 /* Return the address of the linkage table entry. */
3414 value
= (got_sec
->output_section
->vma
3415 + got_sec
->output_offset
3421 /* Fill in a function descriptor consisting of the function's code
3422 address and its global pointer. Return the descriptor's address. */
3425 set_fptr_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3426 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3429 struct elfNN_ia64_link_hash_table
*ia64_info
;
3432 ia64_info
= elfNN_ia64_hash_table (info
);
3433 if (ia64_info
== NULL
)
3436 fptr_sec
= ia64_info
->fptr_sec
;
3438 if (!dyn_i
->fptr_done
)
3440 dyn_i
->fptr_done
= 1;
3442 /* Fill in the function descriptor. */
3443 bfd_put_64 (abfd
, value
, fptr_sec
->contents
+ dyn_i
->fptr_offset
);
3444 bfd_put_64 (abfd
, _bfd_get_gp_value (abfd
),
3445 fptr_sec
->contents
+ dyn_i
->fptr_offset
+ 8);
3446 if (ia64_info
->rel_fptr_sec
)
3448 Elf_Internal_Rela outrel
;
3451 if (bfd_little_endian (abfd
))
3452 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_IPLTLSB
);
3454 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_IPLTMSB
);
3455 outrel
.r_addend
= value
;
3456 outrel
.r_offset
= (fptr_sec
->output_section
->vma
3457 + fptr_sec
->output_offset
3458 + dyn_i
->fptr_offset
);
3459 loc
= ia64_info
->rel_fptr_sec
->contents
;
3460 loc
+= ia64_info
->rel_fptr_sec
->reloc_count
++
3461 * sizeof (ElfNN_External_Rela
);
3462 bfd_elfNN_swap_reloca_out (abfd
, &outrel
, loc
);
3466 /* Return the descriptor's address. */
3467 value
= (fptr_sec
->output_section
->vma
3468 + fptr_sec
->output_offset
3469 + dyn_i
->fptr_offset
);
3474 /* Fill in a PLTOFF entry consisting of the function's code address
3475 and its global pointer. Return the descriptor's address. */
3478 set_pltoff_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3479 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3480 bfd_vma value
, bfd_boolean is_plt
)
3482 struct elfNN_ia64_link_hash_table
*ia64_info
;
3483 asection
*pltoff_sec
;
3485 ia64_info
= elfNN_ia64_hash_table (info
);
3486 if (ia64_info
== NULL
)
3489 pltoff_sec
= ia64_info
->pltoff_sec
;
3491 /* Don't do anything if this symbol uses a real PLT entry. In
3492 that case, we'll fill this in during finish_dynamic_symbol. */
3493 if ((! dyn_i
->want_plt
|| is_plt
)
3494 && !dyn_i
->pltoff_done
)
3496 bfd_vma gp
= _bfd_get_gp_value (abfd
);
3498 /* Fill in the function descriptor. */
3499 bfd_put_64 (abfd
, value
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
);
3500 bfd_put_64 (abfd
, gp
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
+ 8);
3502 /* Install dynamic relocations if needed. */
3504 && bfd_link_pic (info
)
3506 || (ELF_ST_VISIBILITY (dyn_i
->h
->other
) == STV_DEFAULT
3507 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, dyn_i
->h
))
3508 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
3510 unsigned int dyn_r_type
;
3512 if (bfd_big_endian (abfd
))
3513 dyn_r_type
= R_IA64_RELNNMSB
;
3515 dyn_r_type
= R_IA64_RELNNLSB
;
3517 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
3518 ia64_info
->rel_pltoff_sec
,
3519 dyn_i
->pltoff_offset
,
3520 dyn_r_type
, 0, value
);
3521 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
3522 ia64_info
->rel_pltoff_sec
,
3523 dyn_i
->pltoff_offset
+ ARCH_SIZE
/ 8,
3527 dyn_i
->pltoff_done
= 1;
3530 /* Return the descriptor's address. */
3531 value
= (pltoff_sec
->output_section
->vma
3532 + pltoff_sec
->output_offset
3533 + dyn_i
->pltoff_offset
);
3538 /* Return the base VMA address which should be subtracted from real addresses
3539 when resolving @tprel() relocation.
3540 Main program TLS (whose template starts at PT_TLS p_vaddr)
3541 is assigned offset round(2 * size of pointer, PT_TLS p_align). */
3544 elfNN_ia64_tprel_base (struct bfd_link_info
*info
)
3546 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3547 return tls_sec
->vma
- align_power ((bfd_vma
) ARCH_SIZE
/ 4,
3548 tls_sec
->alignment_power
);
3551 /* Return the base VMA address which should be subtracted from real addresses
3552 when resolving @dtprel() relocation.
3553 This is PT_TLS segment p_vaddr. */
3556 elfNN_ia64_dtprel_base (struct bfd_link_info
*info
)
3558 return elf_hash_table (info
)->tls_sec
->vma
;
3561 /* Called through qsort to sort the .IA_64.unwind section during a
3562 non-relocatable link. Set elfNN_ia64_unwind_entry_compare_bfd
3563 to the output bfd so we can do proper endianness frobbing. */
3565 static bfd
*elfNN_ia64_unwind_entry_compare_bfd
;
3568 elfNN_ia64_unwind_entry_compare (const void * a
, const void * b
)
3572 av
= bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd
, a
);
3573 bv
= bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd
, b
);
3575 return (av
< bv
? -1 : av
> bv
? 1 : 0);
3578 /* Make sure we've got ourselves a nice fat __gp value. */
3580 elfNN_ia64_choose_gp (bfd
*abfd
, struct bfd_link_info
*info
, bfd_boolean final
)
3582 bfd_vma min_vma
= (bfd_vma
) -1, max_vma
= 0;
3583 bfd_vma min_short_vma
= min_vma
, max_short_vma
= 0;
3584 struct elf_link_hash_entry
*gp
;
3587 struct elfNN_ia64_link_hash_table
*ia64_info
;
3589 ia64_info
= elfNN_ia64_hash_table (info
);
3590 if (ia64_info
== NULL
)
3593 /* Find the min and max vma of all sections marked short. Also collect
3594 min and max vma of any type, for use in selecting a nice gp. */
3595 for (os
= abfd
->sections
; os
; os
= os
->next
)
3599 if ((os
->flags
& SEC_ALLOC
) == 0)
3603 /* When this function is called from elfNN_ia64_final_link
3604 the correct value to use is os->size. When called from
3605 elfNN_ia64_relax_section we are in the middle of section
3606 sizing; some sections will already have os->size set, others
3607 will have os->size zero and os->rawsize the previous size. */
3608 hi
= os
->vma
+ (!final
&& os
->rawsize
? os
->rawsize
: os
->size
);
3616 if (os
->flags
& SEC_SMALL_DATA
)
3618 if (min_short_vma
> lo
)
3620 if (max_short_vma
< hi
)
3625 if (ia64_info
->min_short_sec
)
3628 > (ia64_info
->min_short_sec
->vma
3629 + ia64_info
->min_short_offset
))
3630 min_short_vma
= (ia64_info
->min_short_sec
->vma
3631 + ia64_info
->min_short_offset
);
3633 < (ia64_info
->max_short_sec
->vma
3634 + ia64_info
->max_short_offset
))
3635 max_short_vma
= (ia64_info
->max_short_sec
->vma
3636 + ia64_info
->max_short_offset
);
3639 /* See if the user wants to force a value. */
3640 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
3644 && (gp
->root
.type
== bfd_link_hash_defined
3645 || gp
->root
.type
== bfd_link_hash_defweak
))
3647 asection
*gp_sec
= gp
->root
.u
.def
.section
;
3648 gp_val
= (gp
->root
.u
.def
.value
3649 + gp_sec
->output_section
->vma
3650 + gp_sec
->output_offset
);
3654 /* Pick a sensible value. */
3656 if (ia64_info
->min_short_sec
)
3658 bfd_vma short_range
= max_short_vma
- min_short_vma
;
3660 /* If min_short_sec is set, pick one in the middle bewteen
3661 min_short_vma and max_short_vma. */
3662 if (short_range
>= 0x400000)
3664 gp_val
= min_short_vma
+ short_range
/ 2;
3668 asection
*got_sec
= ia64_info
->root
.sgot
;
3670 /* Start with just the address of the .got. */
3672 gp_val
= got_sec
->output_section
->vma
;
3673 else if (max_short_vma
!= 0)
3674 gp_val
= min_short_vma
;
3675 else if (max_vma
- min_vma
< 0x200000)
3678 gp_val
= max_vma
- 0x200000 + 8;
3681 /* If it is possible to address the entire image, but we
3682 don't with the choice above, adjust. */
3683 if (max_vma
- min_vma
< 0x400000
3684 && (max_vma
- gp_val
>= 0x200000
3685 || gp_val
- min_vma
> 0x200000))
3686 gp_val
= min_vma
+ 0x200000;
3687 else if (max_short_vma
!= 0)
3689 /* If we don't cover all the short data, adjust. */
3690 if (max_short_vma
- gp_val
>= 0x200000)
3691 gp_val
= min_short_vma
+ 0x200000;
3693 /* If we're addressing stuff past the end, adjust back. */
3694 if (gp_val
> max_vma
)
3695 gp_val
= max_vma
- 0x200000 + 8;
3699 /* Validate whether all SHF_IA_64_SHORT sections are within
3700 range of the chosen GP. */
3702 if (max_short_vma
!= 0)
3704 if (max_short_vma
- min_short_vma
>= 0x400000)
3708 /* xgettext:c-format */
3709 (_("%pB: short data segment overflowed (%#" PRIx64
" >= 0x400000)"),
3710 abfd
, (uint64_t) (max_short_vma
- min_short_vma
));
3713 else if ((gp_val
> min_short_vma
3714 && gp_val
- min_short_vma
> 0x200000)
3715 || (gp_val
< max_short_vma
3716 && max_short_vma
- gp_val
>= 0x200000))
3719 (_("%pB: __gp does not cover short data segment"), abfd
);
3724 _bfd_set_gp_value (abfd
, gp_val
);
3730 elfNN_ia64_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
3732 struct elfNN_ia64_link_hash_table
*ia64_info
;
3733 asection
*unwind_output_sec
;
3735 ia64_info
= elfNN_ia64_hash_table (info
);
3736 if (ia64_info
== NULL
)
3739 /* Make sure we've got ourselves a nice fat __gp value. */
3740 if (!bfd_link_relocatable (info
))
3743 struct elf_link_hash_entry
*gp
;
3745 /* We assume after gp is set, section size will only decrease. We
3746 need to adjust gp for it. */
3747 _bfd_set_gp_value (abfd
, 0);
3748 if (! elfNN_ia64_choose_gp (abfd
, info
, TRUE
))
3750 gp_val
= _bfd_get_gp_value (abfd
);
3752 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
3756 gp
->root
.type
= bfd_link_hash_defined
;
3757 gp
->root
.u
.def
.value
= gp_val
;
3758 gp
->root
.u
.def
.section
= bfd_abs_section_ptr
;
3762 /* If we're producing a final executable, we need to sort the contents
3763 of the .IA_64.unwind section. Force this section to be relocated
3764 into memory rather than written immediately to the output file. */
3765 unwind_output_sec
= NULL
;
3766 if (!bfd_link_relocatable (info
))
3768 asection
*s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_unwind
);
3771 unwind_output_sec
= s
->output_section
;
3772 unwind_output_sec
->contents
3773 = bfd_malloc (unwind_output_sec
->size
);
3774 if (unwind_output_sec
->contents
== NULL
)
3779 /* Invoke the regular ELF backend linker to do all the work. */
3780 if (!bfd_elf_final_link (abfd
, info
))
3783 if (unwind_output_sec
)
3785 elfNN_ia64_unwind_entry_compare_bfd
= abfd
;
3786 qsort (unwind_output_sec
->contents
,
3787 (size_t) (unwind_output_sec
->size
/ 24),
3789 elfNN_ia64_unwind_entry_compare
);
3791 if (! bfd_set_section_contents (abfd
, unwind_output_sec
,
3792 unwind_output_sec
->contents
, (bfd_vma
) 0,
3793 unwind_output_sec
->size
))
3801 elfNN_ia64_relocate_section (bfd
*output_bfd
,
3802 struct bfd_link_info
*info
,
3804 asection
*input_section
,
3806 Elf_Internal_Rela
*relocs
,
3807 Elf_Internal_Sym
*local_syms
,
3808 asection
**local_sections
)
3810 struct elfNN_ia64_link_hash_table
*ia64_info
;
3811 Elf_Internal_Shdr
*symtab_hdr
;
3812 Elf_Internal_Rela
*rel
;
3813 Elf_Internal_Rela
*relend
;
3815 bfd_boolean ret_val
= TRUE
; /* for non-fatal errors */
3818 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3819 ia64_info
= elfNN_ia64_hash_table (info
);
3820 if (ia64_info
== NULL
)
3823 /* Infect various flags from the input section to the output section. */
3824 if (bfd_link_relocatable (info
))
3828 flags
= elf_section_data(input_section
)->this_hdr
.sh_flags
;
3829 flags
&= SHF_IA_64_NORECOV
;
3831 elf_section_data(input_section
->output_section
)
3832 ->this_hdr
.sh_flags
|= flags
;
3835 gp_val
= _bfd_get_gp_value (output_bfd
);
3836 srel
= get_reloc_section (input_bfd
, ia64_info
, input_section
, FALSE
);
3839 relend
= relocs
+ input_section
->reloc_count
;
3840 for (; rel
< relend
; ++rel
)
3842 struct elf_link_hash_entry
*h
;
3843 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3844 bfd_reloc_status_type r
;
3845 reloc_howto_type
*howto
;
3846 unsigned long r_symndx
;
3847 Elf_Internal_Sym
*sym
;
3848 unsigned int r_type
;
3852 bfd_boolean dynamic_symbol_p
;
3853 bfd_boolean undef_weak_ref
;
3855 r_type
= ELFNN_R_TYPE (rel
->r_info
);
3856 if (r_type
> R_IA64_MAX_RELOC_CODE
)
3858 /* xgettext:c-format */
3859 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
3860 input_bfd
, (int) r_type
);
3861 bfd_set_error (bfd_error_bad_value
);
3866 howto
= ia64_elf_lookup_howto (r_type
);
3873 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
3877 undef_weak_ref
= FALSE
;
3879 if (r_symndx
< symtab_hdr
->sh_info
)
3881 /* Reloc against local symbol. */
3883 sym
= local_syms
+ r_symndx
;
3884 sym_sec
= local_sections
[r_symndx
];
3886 value
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &msec
, rel
);
3887 if (!bfd_link_relocatable (info
)
3888 && (sym_sec
->flags
& SEC_MERGE
) != 0
3889 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3890 && sym_sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
3892 struct elfNN_ia64_local_hash_entry
*loc_h
;
3894 loc_h
= get_local_sym_hash (ia64_info
, input_bfd
, rel
, FALSE
);
3895 if (loc_h
&& ! loc_h
->sec_merge_done
)
3897 struct elfNN_ia64_dyn_sym_info
*dynent
;
3900 for (count
= loc_h
->count
, dynent
= loc_h
->info
;
3906 _bfd_merged_section_offset (output_bfd
, &msec
,
3907 elf_section_data (msec
)->
3911 dynent
->addend
-= sym
->st_value
;
3912 dynent
->addend
+= msec
->output_section
->vma
3913 + msec
->output_offset
3914 - sym_sec
->output_section
->vma
3915 - sym_sec
->output_offset
;
3918 /* We may have introduced duplicated entries. We need
3919 to remove them properly. */
3920 count
= sort_dyn_sym_info (loc_h
->info
, loc_h
->count
);
3921 if (count
!= loc_h
->count
)
3923 loc_h
->count
= count
;
3924 loc_h
->sorted_count
= count
;
3927 loc_h
->sec_merge_done
= 1;
3933 bfd_boolean unresolved_reloc
;
3934 bfd_boolean warned
, ignored
;
3935 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
3937 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3938 r_symndx
, symtab_hdr
, sym_hashes
,
3940 unresolved_reloc
, warned
, ignored
);
3942 if (h
->root
.type
== bfd_link_hash_undefweak
)
3943 undef_weak_ref
= TRUE
;
3944 else if (warned
|| (ignored
&& bfd_link_executable (info
)))
3948 if (sym_sec
!= NULL
&& discarded_section (sym_sec
))
3949 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3950 rel
, 1, relend
, howto
, 0, contents
);
3952 if (bfd_link_relocatable (info
))
3955 hit_addr
= contents
+ rel
->r_offset
;
3956 value
+= rel
->r_addend
;
3957 dynamic_symbol_p
= elfNN_ia64_dynamic_symbol_p (h
, info
, r_type
);
3968 case R_IA64_DIR32MSB
:
3969 case R_IA64_DIR32LSB
:
3970 case R_IA64_DIR64MSB
:
3971 case R_IA64_DIR64LSB
:
3972 /* Install a dynamic relocation for this reloc. */
3973 if ((dynamic_symbol_p
|| bfd_link_pic (info
))
3974 && !(h
&& UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
3975 && r_symndx
!= STN_UNDEF
3976 && (input_section
->flags
& SEC_ALLOC
) != 0)
3978 unsigned int dyn_r_type
;
3982 BFD_ASSERT (srel
!= NULL
);
3989 /* ??? People shouldn't be doing non-pic code in
3990 shared libraries nor dynamic executables. */
3992 /* xgettext:c-format */
3993 (_("%pB: non-pic code with imm relocation against dynamic symbol `%s'"),
3995 h
? h
->root
.root
.string
3996 : bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4005 /* If we don't need dynamic symbol lookup, find a
4006 matching RELATIVE relocation. */
4007 dyn_r_type
= r_type
;
4008 if (dynamic_symbol_p
)
4010 dynindx
= h
->dynindx
;
4011 addend
= rel
->r_addend
;
4018 case R_IA64_DIR32MSB
:
4019 dyn_r_type
= R_IA64_REL32MSB
;
4021 case R_IA64_DIR32LSB
:
4022 dyn_r_type
= R_IA64_REL32LSB
;
4024 case R_IA64_DIR64MSB
:
4025 dyn_r_type
= R_IA64_REL64MSB
;
4027 case R_IA64_DIR64LSB
:
4028 dyn_r_type
= R_IA64_REL64LSB
;
4038 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4039 srel
, rel
->r_offset
, dyn_r_type
,
4044 case R_IA64_LTV32MSB
:
4045 case R_IA64_LTV32LSB
:
4046 case R_IA64_LTV64MSB
:
4047 case R_IA64_LTV64LSB
:
4048 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4051 case R_IA64_GPREL22
:
4052 case R_IA64_GPREL64I
:
4053 case R_IA64_GPREL32MSB
:
4054 case R_IA64_GPREL32LSB
:
4055 case R_IA64_GPREL64MSB
:
4056 case R_IA64_GPREL64LSB
:
4057 if (dynamic_symbol_p
)
4060 /* xgettext:c-format */
4061 (_("%pB: @gprel relocation against dynamic symbol %s"),
4063 h
? h
->root
.root
.string
4064 : bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4070 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4073 case R_IA64_LTOFF22
:
4074 case R_IA64_LTOFF22X
:
4075 case R_IA64_LTOFF64I
:
4076 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4077 value
= set_got_entry (input_bfd
, info
, dyn_i
, (h
? h
->dynindx
: -1),
4078 rel
->r_addend
, value
, R_IA64_DIRNNLSB
);
4080 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4083 case R_IA64_PLTOFF22
:
4084 case R_IA64_PLTOFF64I
:
4085 case R_IA64_PLTOFF64MSB
:
4086 case R_IA64_PLTOFF64LSB
:
4087 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4088 value
= set_pltoff_entry (output_bfd
, info
, dyn_i
, value
, FALSE
);
4090 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4093 case R_IA64_FPTR64I
:
4094 case R_IA64_FPTR32MSB
:
4095 case R_IA64_FPTR32LSB
:
4096 case R_IA64_FPTR64MSB
:
4097 case R_IA64_FPTR64LSB
:
4098 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4099 if (dyn_i
->want_fptr
)
4101 if (!undef_weak_ref
)
4102 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
4104 if (!dyn_i
->want_fptr
|| bfd_link_pie (info
))
4107 unsigned int dyn_r_type
= r_type
;
4108 bfd_vma addend
= rel
->r_addend
;
4110 /* Otherwise, we expect the dynamic linker to create
4113 if (dyn_i
->want_fptr
)
4115 if (r_type
== R_IA64_FPTR64I
)
4117 /* We can't represent this without a dynamic symbol.
4118 Adjust the relocation to be against an output
4119 section symbol, which are always present in the
4120 dynamic symbol table. */
4121 /* ??? People shouldn't be doing non-pic code in
4122 shared libraries. Hork. */
4124 (_("%pB: linking non-pic code in a position independent executable"),
4131 dyn_r_type
= r_type
+ R_IA64_RELNNLSB
- R_IA64_FPTRNNLSB
;
4135 if (h
->dynindx
!= -1)
4136 dynindx
= h
->dynindx
;
4138 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4139 (info
, h
->root
.u
.def
.section
->owner
,
4140 global_sym_index (h
)));
4145 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4146 (info
, input_bfd
, (long) r_symndx
));
4150 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4151 srel
, rel
->r_offset
, dyn_r_type
,
4155 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4158 case R_IA64_LTOFF_FPTR22
:
4159 case R_IA64_LTOFF_FPTR64I
:
4160 case R_IA64_LTOFF_FPTR32MSB
:
4161 case R_IA64_LTOFF_FPTR32LSB
:
4162 case R_IA64_LTOFF_FPTR64MSB
:
4163 case R_IA64_LTOFF_FPTR64LSB
:
4167 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4168 if (dyn_i
->want_fptr
)
4170 BFD_ASSERT (h
== NULL
|| h
->dynindx
== -1);
4171 if (!undef_weak_ref
)
4172 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
4177 /* Otherwise, we expect the dynamic linker to create
4181 if (h
->dynindx
!= -1)
4182 dynindx
= h
->dynindx
;
4184 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4185 (info
, h
->root
.u
.def
.section
->owner
,
4186 global_sym_index (h
)));
4189 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4190 (info
, input_bfd
, (long) r_symndx
));
4194 value
= set_got_entry (output_bfd
, info
, dyn_i
, dynindx
,
4195 rel
->r_addend
, value
, R_IA64_FPTRNNLSB
);
4197 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4201 case R_IA64_PCREL32MSB
:
4202 case R_IA64_PCREL32LSB
:
4203 case R_IA64_PCREL64MSB
:
4204 case R_IA64_PCREL64LSB
:
4205 /* Install a dynamic relocation for this reloc. */
4206 if (dynamic_symbol_p
&& r_symndx
!= STN_UNDEF
)
4208 BFD_ASSERT (srel
!= NULL
);
4210 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4211 srel
, rel
->r_offset
, r_type
,
4212 h
->dynindx
, rel
->r_addend
);
4216 case R_IA64_PCREL21B
:
4217 case R_IA64_PCREL60B
:
4218 /* We should have created a PLT entry for any dynamic symbol. */
4221 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, FALSE
);
4223 if (dyn_i
&& dyn_i
->want_plt2
)
4225 /* Should have caught this earlier. */
4226 BFD_ASSERT (rel
->r_addend
== 0);
4228 value
= (ia64_info
->root
.splt
->output_section
->vma
4229 + ia64_info
->root
.splt
->output_offset
4230 + dyn_i
->plt2_offset
);
4234 /* Since there's no PLT entry, Validate that this is
4236 BFD_ASSERT (undef_weak_ref
|| sym_sec
->output_section
!= NULL
);
4238 /* If the symbol is undef_weak, we shouldn't be trying
4239 to call it. There's every chance that we'd wind up
4240 with an out-of-range fixup here. Don't bother setting
4241 any value at all. */
4247 case R_IA64_PCREL21BI
:
4248 case R_IA64_PCREL21F
:
4249 case R_IA64_PCREL21M
:
4250 case R_IA64_PCREL22
:
4251 case R_IA64_PCREL64I
:
4252 /* The PCREL21BI reloc is specifically not intended for use with
4253 dynamic relocs. PCREL21F and PCREL21M are used for speculation
4254 fixup code, and thus probably ought not be dynamic. The
4255 PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs. */
4256 if (dynamic_symbol_p
)
4260 if (r_type
== R_IA64_PCREL21BI
)
4261 /* xgettext:c-format */
4262 msg
= _("%pB: @internal branch to dynamic symbol %s");
4263 else if (r_type
== R_IA64_PCREL21F
|| r_type
== R_IA64_PCREL21M
)
4264 /* xgettext:c-format */
4265 msg
= _("%pB: speculation fixup to dynamic symbol %s");
4267 /* xgettext:c-format */
4268 msg
= _("%pB: @pcrel relocation against dynamic symbol %s");
4269 _bfd_error_handler (msg
, input_bfd
,
4270 h
? h
->root
.root
.string
4271 : bfd_elf_sym_name (input_bfd
,
4281 /* Make pc-relative. */
4282 value
-= (input_section
->output_section
->vma
4283 + input_section
->output_offset
4284 + rel
->r_offset
) & ~ (bfd_vma
) 0x3;
4285 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4288 case R_IA64_SEGREL32MSB
:
4289 case R_IA64_SEGREL32LSB
:
4290 case R_IA64_SEGREL64MSB
:
4291 case R_IA64_SEGREL64LSB
:
4293 /* Find the segment that contains the output_section. */
4294 Elf_Internal_Phdr
*p
= _bfd_elf_find_segment_containing_section
4295 (output_bfd
, input_section
->output_section
);
4299 r
= bfd_reloc_notsupported
;
4303 /* The VMA of the segment is the vaddr of the associated
4305 if (value
> p
->p_vaddr
)
4306 value
-= p
->p_vaddr
;
4309 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4314 case R_IA64_SECREL32MSB
:
4315 case R_IA64_SECREL32LSB
:
4316 case R_IA64_SECREL64MSB
:
4317 case R_IA64_SECREL64LSB
:
4318 /* Make output-section relative to section where the symbol
4319 is defined. PR 475 */
4321 value
-= sym_sec
->output_section
->vma
;
4322 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4325 case R_IA64_IPLTMSB
:
4326 case R_IA64_IPLTLSB
:
4327 /* Install a dynamic relocation for this reloc. */
4328 if ((dynamic_symbol_p
|| bfd_link_pic (info
))
4329 && (input_section
->flags
& SEC_ALLOC
) != 0)
4331 BFD_ASSERT (srel
!= NULL
);
4333 /* If we don't need dynamic symbol lookup, install two
4334 RELATIVE relocations. */
4335 if (!dynamic_symbol_p
)
4337 unsigned int dyn_r_type
;
4339 if (r_type
== R_IA64_IPLTMSB
)
4340 dyn_r_type
= R_IA64_REL64MSB
;
4342 dyn_r_type
= R_IA64_REL64LSB
;
4344 elfNN_ia64_install_dyn_reloc (output_bfd
, info
,
4346 srel
, rel
->r_offset
,
4347 dyn_r_type
, 0, value
);
4348 elfNN_ia64_install_dyn_reloc (output_bfd
, info
,
4350 srel
, rel
->r_offset
+ 8,
4351 dyn_r_type
, 0, gp_val
);
4354 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4355 srel
, rel
->r_offset
, r_type
,
4356 h
->dynindx
, rel
->r_addend
);
4359 if (r_type
== R_IA64_IPLTMSB
)
4360 r_type
= R_IA64_DIR64MSB
;
4362 r_type
= R_IA64_DIR64LSB
;
4363 ia64_elf_install_value (hit_addr
, value
, r_type
);
4364 r
= ia64_elf_install_value (hit_addr
+ 8, gp_val
, r_type
);
4367 case R_IA64_TPREL14
:
4368 case R_IA64_TPREL22
:
4369 case R_IA64_TPREL64I
:
4370 if (elf_hash_table (info
)->tls_sec
== NULL
)
4371 goto missing_tls_sec
;
4372 value
-= elfNN_ia64_tprel_base (info
);
4373 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4376 case R_IA64_DTPREL14
:
4377 case R_IA64_DTPREL22
:
4378 case R_IA64_DTPREL64I
:
4379 case R_IA64_DTPREL32LSB
:
4380 case R_IA64_DTPREL32MSB
:
4381 case R_IA64_DTPREL64LSB
:
4382 case R_IA64_DTPREL64MSB
:
4383 if (elf_hash_table (info
)->tls_sec
== NULL
)
4384 goto missing_tls_sec
;
4385 value
-= elfNN_ia64_dtprel_base (info
);
4386 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4389 case R_IA64_LTOFF_TPREL22
:
4390 case R_IA64_LTOFF_DTPMOD22
:
4391 case R_IA64_LTOFF_DTPREL22
:
4394 long dynindx
= h
? h
->dynindx
: -1;
4395 bfd_vma r_addend
= rel
->r_addend
;
4400 case R_IA64_LTOFF_TPREL22
:
4401 if (!dynamic_symbol_p
)
4403 if (elf_hash_table (info
)->tls_sec
== NULL
)
4404 goto missing_tls_sec
;
4405 if (!bfd_link_pic (info
))
4406 value
-= elfNN_ia64_tprel_base (info
);
4409 r_addend
+= value
- elfNN_ia64_dtprel_base (info
);
4413 got_r_type
= R_IA64_TPREL64LSB
;
4415 case R_IA64_LTOFF_DTPMOD22
:
4416 if (!dynamic_symbol_p
&& !bfd_link_pic (info
))
4418 got_r_type
= R_IA64_DTPMOD64LSB
;
4420 case R_IA64_LTOFF_DTPREL22
:
4421 if (!dynamic_symbol_p
)
4423 if (elf_hash_table (info
)->tls_sec
== NULL
)
4424 goto missing_tls_sec
;
4425 value
-= elfNN_ia64_dtprel_base (info
);
4427 got_r_type
= R_IA64_DTPRELNNLSB
;
4430 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4431 value
= set_got_entry (input_bfd
, info
, dyn_i
, dynindx
, r_addend
,
4434 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
4439 r
= bfd_reloc_notsupported
;
4448 case bfd_reloc_undefined
:
4449 /* This can happen for global table relative relocs if
4450 __gp is undefined. This is a panic situation so we
4451 don't try to continue. */
4452 (*info
->callbacks
->undefined_symbol
)
4453 (info
, "__gp", input_bfd
, input_section
, rel
->r_offset
, 1);
4456 case bfd_reloc_notsupported
:
4461 name
= h
->root
.root
.string
;
4463 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4465 (*info
->callbacks
->warning
) (info
, _("unsupported reloc"),
4467 input_section
, rel
->r_offset
);
4472 case bfd_reloc_dangerous
:
4473 case bfd_reloc_outofrange
:
4474 case bfd_reloc_overflow
:
4481 name
= h
->root
.root
.string
;
4483 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4488 case R_IA64_TPREL14
:
4489 case R_IA64_TPREL22
:
4490 case R_IA64_TPREL64I
:
4491 case R_IA64_DTPREL14
:
4492 case R_IA64_DTPREL22
:
4493 case R_IA64_DTPREL64I
:
4494 case R_IA64_DTPREL32LSB
:
4495 case R_IA64_DTPREL32MSB
:
4496 case R_IA64_DTPREL64LSB
:
4497 case R_IA64_DTPREL64MSB
:
4498 case R_IA64_LTOFF_TPREL22
:
4499 case R_IA64_LTOFF_DTPMOD22
:
4500 case R_IA64_LTOFF_DTPREL22
:
4502 /* xgettext:c-format */
4503 (_("%pB: missing TLS section for relocation %s against `%s'"
4504 " at %#" PRIx64
" in section `%pA'."),
4505 input_bfd
, howto
->name
, name
,
4506 (uint64_t) rel
->r_offset
, input_section
);
4509 case R_IA64_PCREL21B
:
4510 case R_IA64_PCREL21BI
:
4511 case R_IA64_PCREL21M
:
4512 case R_IA64_PCREL21F
:
4513 if (is_elf_hash_table (info
->hash
))
4515 /* Relaxtion is always performed for ELF output.
4516 Overflow failures for those relocations mean
4517 that the section is too big to relax. */
4519 /* xgettext:c-format */
4520 (_("%pB: Can't relax br (%s) to `%s' at %#" PRIx64
4521 " in section `%pA' with size %#" PRIx64
4523 input_bfd
, howto
->name
, name
, (uint64_t) rel
->r_offset
,
4524 input_section
, (uint64_t) input_section
->size
);
4529 (*info
->callbacks
->reloc_overflow
) (info
,
4550 elfNN_ia64_finish_dynamic_symbol (bfd
*output_bfd
,
4551 struct bfd_link_info
*info
,
4552 struct elf_link_hash_entry
*h
,
4553 Elf_Internal_Sym
*sym
)
4555 struct elfNN_ia64_link_hash_table
*ia64_info
;
4556 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
4558 ia64_info
= elfNN_ia64_hash_table (info
);
4559 if (ia64_info
== NULL
)
4562 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, FALSE
);
4564 /* Fill in the PLT data, if required. */
4565 if (dyn_i
&& dyn_i
->want_plt
)
4567 Elf_Internal_Rela outrel
;
4570 bfd_vma plt_addr
, pltoff_addr
, gp_val
, plt_index
;
4572 gp_val
= _bfd_get_gp_value (output_bfd
);
4574 /* Initialize the minimal PLT entry. */
4576 plt_index
= (dyn_i
->plt_offset
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
4577 plt_sec
= ia64_info
->root
.splt
;
4578 loc
= plt_sec
->contents
+ dyn_i
->plt_offset
;
4580 memcpy (loc
, plt_min_entry
, PLT_MIN_ENTRY_SIZE
);
4581 ia64_elf_install_value (loc
, plt_index
, R_IA64_IMM22
);
4582 ia64_elf_install_value (loc
+2, -dyn_i
->plt_offset
, R_IA64_PCREL21B
);
4584 plt_addr
= (plt_sec
->output_section
->vma
4585 + plt_sec
->output_offset
4586 + dyn_i
->plt_offset
);
4587 pltoff_addr
= set_pltoff_entry (output_bfd
, info
, dyn_i
, plt_addr
, TRUE
);
4589 /* Initialize the FULL PLT entry, if needed. */
4590 if (dyn_i
->want_plt2
)
4592 loc
= plt_sec
->contents
+ dyn_i
->plt2_offset
;
4594 memcpy (loc
, plt_full_entry
, PLT_FULL_ENTRY_SIZE
);
4595 ia64_elf_install_value (loc
, pltoff_addr
- gp_val
, R_IA64_IMM22
);
4597 /* Mark the symbol as undefined, rather than as defined in the
4598 plt section. Leave the value alone. */
4599 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
4600 first place. But perhaps elflink.c did some for us. */
4601 if (!h
->def_regular
)
4602 sym
->st_shndx
= SHN_UNDEF
;
4605 /* Create the dynamic relocation. */
4606 outrel
.r_offset
= pltoff_addr
;
4607 if (bfd_little_endian (output_bfd
))
4608 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_IA64_IPLTLSB
);
4610 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_IA64_IPLTMSB
);
4611 outrel
.r_addend
= 0;
4613 /* This is fun. In the .IA_64.pltoff section, we've got entries
4614 that correspond both to real PLT entries, and those that
4615 happened to resolve to local symbols but need to be created
4616 to satisfy @pltoff relocations. The .rela.IA_64.pltoff
4617 relocations for the real PLT should come at the end of the
4618 section, so that they can be indexed by plt entry at runtime.
4620 We emitted all of the relocations for the non-PLT @pltoff
4621 entries during relocate_section. So we can consider the
4622 existing sec->reloc_count to be the base of the array of
4625 loc
= ia64_info
->rel_pltoff_sec
->contents
;
4626 loc
+= ((ia64_info
->rel_pltoff_sec
->reloc_count
+ plt_index
)
4627 * sizeof (ElfNN_External_Rela
));
4628 bfd_elfNN_swap_reloca_out (output_bfd
, &outrel
, loc
);
4631 /* Mark some specially defined symbols as absolute. */
4632 if (h
== ia64_info
->root
.hdynamic
4633 || h
== ia64_info
->root
.hgot
4634 || h
== ia64_info
->root
.hplt
)
4635 sym
->st_shndx
= SHN_ABS
;
4641 elfNN_ia64_finish_dynamic_sections (bfd
*abfd
,
4642 struct bfd_link_info
*info
)
4644 struct elfNN_ia64_link_hash_table
*ia64_info
;
4647 ia64_info
= elfNN_ia64_hash_table (info
);
4648 if (ia64_info
== NULL
)
4651 dynobj
= ia64_info
->root
.dynobj
;
4653 if (ia64_info
->root
.dynamic_sections_created
)
4655 ElfNN_External_Dyn
*dyncon
, *dynconend
;
4656 asection
*sdyn
, *sgotplt
;
4659 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
4660 sgotplt
= ia64_info
->root
.sgotplt
;
4661 BFD_ASSERT (sdyn
!= NULL
);
4662 dyncon
= (ElfNN_External_Dyn
*) sdyn
->contents
;
4663 dynconend
= (ElfNN_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4665 gp_val
= _bfd_get_gp_value (abfd
);
4667 for (; dyncon
< dynconend
; dyncon
++)
4669 Elf_Internal_Dyn dyn
;
4671 bfd_elfNN_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4676 dyn
.d_un
.d_ptr
= gp_val
;
4680 dyn
.d_un
.d_val
= (ia64_info
->minplt_entries
4681 * sizeof (ElfNN_External_Rela
));
4685 /* See the comment above in finish_dynamic_symbol. */
4686 dyn
.d_un
.d_ptr
= (ia64_info
->rel_pltoff_sec
->output_section
->vma
4687 + ia64_info
->rel_pltoff_sec
->output_offset
4688 + (ia64_info
->rel_pltoff_sec
->reloc_count
4689 * sizeof (ElfNN_External_Rela
)));
4692 case DT_IA_64_PLT_RESERVE
:
4693 dyn
.d_un
.d_ptr
= (sgotplt
->output_section
->vma
4694 + sgotplt
->output_offset
);
4698 bfd_elfNN_swap_dyn_out (abfd
, &dyn
, dyncon
);
4701 /* Initialize the PLT0 entry. */
4702 if (ia64_info
->root
.splt
)
4704 bfd_byte
*loc
= ia64_info
->root
.splt
->contents
;
4707 memcpy (loc
, plt_header
, PLT_HEADER_SIZE
);
4709 pltres
= (sgotplt
->output_section
->vma
4710 + sgotplt
->output_offset
4713 ia64_elf_install_value (loc
+1, pltres
, R_IA64_GPREL22
);
4720 /* ELF file flag handling: */
4722 /* Function to keep IA-64 specific file flags. */
4724 elfNN_ia64_set_private_flags (bfd
*abfd
, flagword flags
)
4726 BFD_ASSERT (!elf_flags_init (abfd
)
4727 || elf_elfheader (abfd
)->e_flags
== flags
);
4729 elf_elfheader (abfd
)->e_flags
= flags
;
4730 elf_flags_init (abfd
) = TRUE
;
4734 /* Merge backend specific data from an object file to the output
4735 object file when linking. */
4737 elfNN_ia64_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
4739 bfd
*obfd
= info
->output_bfd
;
4742 bfd_boolean ok
= TRUE
;
4744 /* Don't even pretend to support mixed-format linking. */
4745 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4746 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4749 in_flags
= elf_elfheader (ibfd
)->e_flags
;
4750 out_flags
= elf_elfheader (obfd
)->e_flags
;
4752 if (! elf_flags_init (obfd
))
4754 elf_flags_init (obfd
) = TRUE
;
4755 elf_elfheader (obfd
)->e_flags
= in_flags
;
4757 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
4758 && bfd_get_arch_info (obfd
)->the_default
)
4760 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
4761 bfd_get_mach (ibfd
));
4767 /* Check flag compatibility. */
4768 if (in_flags
== out_flags
)
4771 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
4772 if (!(in_flags
& EF_IA_64_REDUCEDFP
) && (out_flags
& EF_IA_64_REDUCEDFP
))
4773 elf_elfheader (obfd
)->e_flags
&= ~EF_IA_64_REDUCEDFP
;
4775 if ((in_flags
& EF_IA_64_TRAPNIL
) != (out_flags
& EF_IA_64_TRAPNIL
))
4778 (_("%pB: linking trap-on-NULL-dereference with non-trapping files"),
4781 bfd_set_error (bfd_error_bad_value
);
4784 if ((in_flags
& EF_IA_64_BE
) != (out_flags
& EF_IA_64_BE
))
4787 (_("%pB: linking big-endian files with little-endian files"),
4790 bfd_set_error (bfd_error_bad_value
);
4793 if ((in_flags
& EF_IA_64_ABI64
) != (out_flags
& EF_IA_64_ABI64
))
4796 (_("%pB: linking 64-bit files with 32-bit files"),
4799 bfd_set_error (bfd_error_bad_value
);
4802 if ((in_flags
& EF_IA_64_CONS_GP
) != (out_flags
& EF_IA_64_CONS_GP
))
4805 (_("%pB: linking constant-gp files with non-constant-gp files"),
4808 bfd_set_error (bfd_error_bad_value
);
4811 if ((in_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
)
4812 != (out_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
4815 (_("%pB: linking auto-pic files with non-auto-pic files"),
4818 bfd_set_error (bfd_error_bad_value
);
4826 elfNN_ia64_print_private_bfd_data (bfd
*abfd
, void * ptr
)
4828 FILE *file
= (FILE *) ptr
;
4829 flagword flags
= elf_elfheader (abfd
)->e_flags
;
4831 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
4833 fprintf (file
, "private flags = %s%s%s%s%s%s%s%s\n",
4834 (flags
& EF_IA_64_TRAPNIL
) ? "TRAPNIL, " : "",
4835 (flags
& EF_IA_64_EXT
) ? "EXT, " : "",
4836 (flags
& EF_IA_64_BE
) ? "BE, " : "LE, ",
4837 (flags
& EF_IA_64_REDUCEDFP
) ? "REDUCEDFP, " : "",
4838 (flags
& EF_IA_64_CONS_GP
) ? "CONS_GP, " : "",
4839 (flags
& EF_IA_64_NOFUNCDESC_CONS_GP
) ? "NOFUNCDESC_CONS_GP, " : "",
4840 (flags
& EF_IA_64_ABSOLUTE
) ? "ABSOLUTE, " : "",
4841 (flags
& EF_IA_64_ABI64
) ? "ABI64" : "ABI32");
4843 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
4847 static enum elf_reloc_type_class
4848 elfNN_ia64_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4849 const asection
*rel_sec ATTRIBUTE_UNUSED
,
4850 const Elf_Internal_Rela
*rela
)
4852 switch ((int) ELFNN_R_TYPE (rela
->r_info
))
4854 case R_IA64_REL32MSB
:
4855 case R_IA64_REL32LSB
:
4856 case R_IA64_REL64MSB
:
4857 case R_IA64_REL64LSB
:
4858 return reloc_class_relative
;
4859 case R_IA64_IPLTMSB
:
4860 case R_IA64_IPLTLSB
:
4861 return reloc_class_plt
;
4863 return reloc_class_copy
;
4865 return reloc_class_normal
;
4869 static const struct bfd_elf_special_section elfNN_ia64_special_sections
[] =
4871 { STRING_COMMA_LEN (".sbss"), -1, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_IA_64_SHORT
},
4872 { STRING_COMMA_LEN (".sdata"), -1, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_IA_64_SHORT
},
4873 { NULL
, 0, 0, 0, 0 }
4877 elfNN_ia64_object_p (bfd
*abfd
)
4880 asection
*group
, *unwi
, *unw
;
4883 char *unwi_name
, *unw_name
;
4886 if (abfd
->flags
& DYNAMIC
)
4889 /* Flags for fake group section. */
4890 flags
= (SEC_LINKER_CREATED
| SEC_GROUP
| SEC_LINK_ONCE
4893 /* We add a fake section group for each .gnu.linkonce.t.* section,
4894 which isn't in a section group, and its unwind sections. */
4895 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4897 if (elf_sec_group (sec
) == NULL
4898 && ((sec
->flags
& (SEC_LINK_ONCE
| SEC_CODE
| SEC_GROUP
))
4899 == (SEC_LINK_ONCE
| SEC_CODE
))
4900 && CONST_STRNEQ (sec
->name
, ".gnu.linkonce.t."))
4902 name
= sec
->name
+ 16;
4904 amt
= strlen (name
) + sizeof (".gnu.linkonce.ia64unwi.");
4905 unwi_name
= bfd_alloc (abfd
, amt
);
4909 strcpy (stpcpy (unwi_name
, ".gnu.linkonce.ia64unwi."), name
);
4910 unwi
= bfd_get_section_by_name (abfd
, unwi_name
);
4912 amt
= strlen (name
) + sizeof (".gnu.linkonce.ia64unw.");
4913 unw_name
= bfd_alloc (abfd
, amt
);
4917 strcpy (stpcpy (unw_name
, ".gnu.linkonce.ia64unw."), name
);
4918 unw
= bfd_get_section_by_name (abfd
, unw_name
);
4920 /* We need to create a fake group section for it and its
4922 group
= bfd_make_section_anyway_with_flags (abfd
, name
,
4927 /* Move the fake group section to the beginning. */
4928 bfd_section_list_remove (abfd
, group
);
4929 bfd_section_list_prepend (abfd
, group
);
4931 elf_next_in_group (group
) = sec
;
4933 elf_group_name (sec
) = name
;
4934 elf_next_in_group (sec
) = sec
;
4935 elf_sec_group (sec
) = group
;
4939 elf_group_name (unwi
) = name
;
4940 elf_next_in_group (unwi
) = sec
;
4941 elf_next_in_group (sec
) = unwi
;
4942 elf_sec_group (unwi
) = group
;
4947 elf_group_name (unw
) = name
;
4950 elf_next_in_group (unw
) = elf_next_in_group (unwi
);
4951 elf_next_in_group (unwi
) = unw
;
4955 elf_next_in_group (unw
) = sec
;
4956 elf_next_in_group (sec
) = unw
;
4958 elf_sec_group (unw
) = group
;
4961 /* Fake SHT_GROUP section header. */
4962 elf_section_data (group
)->this_hdr
.bfd_section
= group
;
4963 elf_section_data (group
)->this_hdr
.sh_type
= SHT_GROUP
;
4970 elfNN_ia64_hpux_vec (const bfd_target
*vec
)
4972 extern const bfd_target ia64_elfNN_hpux_be_vec
;
4973 return (vec
== &ia64_elfNN_hpux_be_vec
);
4977 elfNN_hpux_post_process_headers (bfd
*abfd
,
4978 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
4980 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
4982 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
4983 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 1;
4987 elfNN_hpux_backend_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
4988 asection
*sec
, int *retval
)
4990 if (bfd_is_com_section (sec
))
4992 *retval
= SHN_IA_64_ANSI_COMMON
;
4999 elfNN_hpux_backend_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
5002 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
5004 switch (elfsym
->internal_elf_sym
.st_shndx
)
5006 case SHN_IA_64_ANSI_COMMON
:
5007 asym
->section
= bfd_com_section_ptr
;
5008 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
5009 asym
->flags
&= ~BSF_GLOBAL
;
5014 #define TARGET_LITTLE_SYM ia64_elfNN_le_vec
5015 #define TARGET_LITTLE_NAME "elfNN-ia64-little"
5016 #define TARGET_BIG_SYM ia64_elfNN_be_vec
5017 #define TARGET_BIG_NAME "elfNN-ia64-big"
5018 #define ELF_ARCH bfd_arch_ia64
5019 #define ELF_TARGET_ID IA64_ELF_DATA
5020 #define ELF_MACHINE_CODE EM_IA_64
5021 #define ELF_MACHINE_ALT1 1999 /* EAS2.3 */
5022 #define ELF_MACHINE_ALT2 1998 /* EAS2.2 */
5023 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
5024 #define ELF_COMMONPAGESIZE 0x4000 /* 16KB */
5026 #define elf_backend_section_from_shdr \
5027 elfNN_ia64_section_from_shdr
5028 #define elf_backend_section_flags \
5029 elfNN_ia64_section_flags
5030 #define elf_backend_fake_sections \
5031 elfNN_ia64_fake_sections
5032 #define elf_backend_final_write_processing \
5033 elfNN_ia64_final_write_processing
5034 #define elf_backend_add_symbol_hook \
5035 elfNN_ia64_add_symbol_hook
5036 #define elf_backend_additional_program_headers \
5037 elfNN_ia64_additional_program_headers
5038 #define elf_backend_modify_segment_map \
5039 elfNN_ia64_modify_segment_map
5040 #define elf_backend_modify_program_headers \
5041 elfNN_ia64_modify_program_headers
5042 #define elf_info_to_howto \
5043 elfNN_ia64_info_to_howto
5045 #define bfd_elfNN_bfd_reloc_type_lookup \
5046 ia64_elf_reloc_type_lookup
5047 #define bfd_elfNN_bfd_reloc_name_lookup \
5048 ia64_elf_reloc_name_lookup
5049 #define bfd_elfNN_bfd_is_local_label_name \
5050 elfNN_ia64_is_local_label_name
5051 #define bfd_elfNN_bfd_relax_section \
5052 elfNN_ia64_relax_section
5054 #define elf_backend_object_p \
5057 /* Stuff for the BFD linker: */
5058 #define bfd_elfNN_bfd_link_hash_table_create \
5059 elfNN_ia64_hash_table_create
5060 #define elf_backend_create_dynamic_sections \
5061 elfNN_ia64_create_dynamic_sections
5062 #define elf_backend_check_relocs \
5063 elfNN_ia64_check_relocs
5064 #define elf_backend_adjust_dynamic_symbol \
5065 elfNN_ia64_adjust_dynamic_symbol
5066 #define elf_backend_size_dynamic_sections \
5067 elfNN_ia64_size_dynamic_sections
5068 #define elf_backend_omit_section_dynsym \
5069 _bfd_elf_omit_section_dynsym_all
5070 #define elf_backend_relocate_section \
5071 elfNN_ia64_relocate_section
5072 #define elf_backend_finish_dynamic_symbol \
5073 elfNN_ia64_finish_dynamic_symbol
5074 #define elf_backend_finish_dynamic_sections \
5075 elfNN_ia64_finish_dynamic_sections
5076 #define bfd_elfNN_bfd_final_link \
5077 elfNN_ia64_final_link
5079 #define bfd_elfNN_bfd_merge_private_bfd_data \
5080 elfNN_ia64_merge_private_bfd_data
5081 #define bfd_elfNN_bfd_set_private_flags \
5082 elfNN_ia64_set_private_flags
5083 #define bfd_elfNN_bfd_print_private_bfd_data \
5084 elfNN_ia64_print_private_bfd_data
5086 #define elf_backend_plt_readonly 1
5087 #define elf_backend_can_gc_sections 1
5088 #define elf_backend_want_plt_sym 0
5089 #define elf_backend_plt_alignment 5
5090 #define elf_backend_got_header_size 0
5091 #define elf_backend_want_got_plt 1
5092 #define elf_backend_may_use_rel_p 1
5093 #define elf_backend_may_use_rela_p 1
5094 #define elf_backend_default_use_rela_p 1
5095 #define elf_backend_want_dynbss 0
5096 #define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect
5097 #define elf_backend_hide_symbol elfNN_ia64_hash_hide_symbol
5098 #define elf_backend_fixup_symbol _bfd_elf_link_hash_fixup_symbol
5099 #define elf_backend_reloc_type_class elfNN_ia64_reloc_type_class
5100 #define elf_backend_rela_normal 1
5101 #define elf_backend_dtrel_excludes_plt 1
5102 #define elf_backend_special_sections elfNN_ia64_special_sections
5103 #define elf_backend_default_execstack 0
5105 /* FIXME: PR 290: The Intel C compiler generates SHT_IA_64_UNWIND with
5106 SHF_LINK_ORDER. But it doesn't set the sh_link or sh_info fields.
5107 We don't want to flood users with so many error messages. We turn
5108 off the warning for now. It will be turned on later when the Intel
5109 compiler is fixed. */
5110 #define elf_backend_link_order_error_handler NULL
5112 #include "elfNN-target.h"
5114 /* HPUX-specific vectors. */
5116 #undef TARGET_LITTLE_SYM
5117 #undef TARGET_LITTLE_NAME
5118 #undef TARGET_BIG_SYM
5119 #define TARGET_BIG_SYM ia64_elfNN_hpux_be_vec
5120 #undef TARGET_BIG_NAME
5121 #define TARGET_BIG_NAME "elfNN-ia64-hpux-big"
5123 /* These are HP-UX specific functions. */
5125 #undef elf_backend_post_process_headers
5126 #define elf_backend_post_process_headers elfNN_hpux_post_process_headers
5128 #undef elf_backend_section_from_bfd_section
5129 #define elf_backend_section_from_bfd_section elfNN_hpux_backend_section_from_bfd_section
5131 #undef elf_backend_symbol_processing
5132 #define elf_backend_symbol_processing elfNN_hpux_backend_symbol_processing
5134 #undef elf_backend_want_p_paddr_set_to_zero
5135 #define elf_backend_want_p_paddr_set_to_zero 1
5137 #undef ELF_COMMONPAGESIZE
5139 #define ELF_OSABI ELFOSABI_HPUX
5142 #define elfNN_bed elfNN_ia64_hpux_bed
5144 #include "elfNN-target.h"