1 /* IA-64 support for 64-bit ELF
2 Copyright (C) 1998-2018 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 "bfd_stdint.h"
31 #include "elfxx-ia64.h"
36 #define LOG_SECTION_ALIGN 3
40 #define LOG_SECTION_ALIGN 2
43 typedef struct bfd_hash_entry *(*new_hash_entry_func)
44 (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
46 /* In dynamically (linker-) created sections, we generally need to keep track
47 of the place a symbol or expression got allocated to. This is done via hash
48 tables that store entries of the following type. */
50 struct elfNN_ia64_dyn_sym_info
52 /* The addend for which this entry is relevant. */
57 bfd_vma pltoff_offset;
61 bfd_vma dtpmod_offset;
62 bfd_vma dtprel_offset;
64 /* The symbol table entry, if any, that this was derived from. */
65 struct elf_link_hash_entry *h;
67 /* Used to count non-got, non-plt relocations for delayed sizing
68 of relocation sections. */
69 struct elfNN_ia64_dyn_reloc_entry
71 struct elfNN_ia64_dyn_reloc_entry *next;
76 /* Is this reloc against readonly section? */
80 /* TRUE when the section contents have been updated. */
81 unsigned got_done : 1;
82 unsigned fptr_done : 1;
83 unsigned pltoff_done : 1;
84 unsigned tprel_done : 1;
85 unsigned dtpmod_done : 1;
86 unsigned dtprel_done : 1;
88 /* TRUE for the different kinds of linker data we want created. */
89 unsigned want_got : 1;
90 unsigned want_gotx : 1;
91 unsigned want_fptr : 1;
92 unsigned want_ltoff_fptr : 1;
93 unsigned want_plt : 1;
94 unsigned want_plt2 : 1;
95 unsigned want_pltoff : 1;
96 unsigned want_tprel : 1;
97 unsigned want_dtpmod : 1;
98 unsigned want_dtprel : 1;
101 struct elfNN_ia64_local_hash_entry
105 /* The number of elements in elfNN_ia64_dyn_sym_info array. */
107 /* The number of sorted elements in elfNN_ia64_dyn_sym_info array. */
108 unsigned int sorted_count;
109 /* The size of elfNN_ia64_dyn_sym_info array. */
111 /* The array of elfNN_ia64_dyn_sym_info. */
112 struct elfNN_ia64_dyn_sym_info *info;
114 /* TRUE if this hash entry's addends was translated for
115 SHF_MERGE optimization. */
116 unsigned sec_merge_done : 1;
119 struct elfNN_ia64_link_hash_entry
121 struct elf_link_hash_entry root;
122 /* The number of elements in elfNN_ia64_dyn_sym_info array. */
124 /* The number of sorted elements in elfNN_ia64_dyn_sym_info array. */
125 unsigned int sorted_count;
126 /* The size of elfNN_ia64_dyn_sym_info array. */
128 /* The array of elfNN_ia64_dyn_sym_info. */
129 struct elfNN_ia64_dyn_sym_info *info;
132 struct elfNN_ia64_link_hash_table
134 /* The main hash table. */
135 struct elf_link_hash_table root;
137 asection *fptr_sec; /* Function descriptor table (or NULL). */
138 asection *rel_fptr_sec; /* Dynamic relocation section for same. */
139 asection *pltoff_sec; /* Private descriptors for plt (or NULL). */
140 asection *rel_pltoff_sec; /* Dynamic relocation section for same. */
142 bfd_size_type minplt_entries; /* Number of minplt entries. */
143 unsigned reltext : 1; /* Are there relocs against readonly sections? */
144 unsigned self_dtpmod_done : 1;/* Has self DTPMOD entry been finished? */
145 bfd_vma self_dtpmod_offset; /* .got offset to self DTPMOD entry. */
146 /* There are maybe R_IA64_GPREL22 relocations, including those
147 optimized from R_IA64_LTOFF22X, against non-SHF_IA_64_SHORT
148 sections. We need to record those sections so that we can choose
149 a proper GP to cover all R_IA64_GPREL22 relocations. */
150 asection *max_short_sec; /* Maximum short output section. */
151 bfd_vma max_short_offset; /* Maximum short offset. */
152 asection *min_short_sec; /* Minimum short output section. */
153 bfd_vma min_short_offset; /* Minimum short offset. */
155 htab_t loc_hash_table;
156 void *loc_hash_memory;
159 struct elfNN_ia64_allocate_data
161 struct bfd_link_info *info;
163 bfd_boolean only_got;
166 #define elfNN_ia64_hash_table(p) \
167 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
168 == IA64_ELF_DATA ? ((struct elfNN_ia64_link_hash_table *) ((p)->hash)) : NULL)
170 static struct elfNN_ia64_dyn_sym_info * get_dyn_sym_info
171 (struct elfNN_ia64_link_hash_table *ia64_info,
172 struct elf_link_hash_entry *h,
173 bfd *abfd, const Elf_Internal_Rela *rel, bfd_boolean create);
174 static bfd_boolean elfNN_ia64_dynamic_symbol_p
175 (struct elf_link_hash_entry *h, struct bfd_link_info *info, int);
176 static bfd_boolean elfNN_ia64_choose_gp
177 (bfd *abfd, struct bfd_link_info *info, bfd_boolean final);
178 static void elfNN_ia64_dyn_sym_traverse
179 (struct elfNN_ia64_link_hash_table *ia64_info,
180 bfd_boolean (*func) (struct elfNN_ia64_dyn_sym_info *, void *),
182 static bfd_boolean allocate_global_data_got
183 (struct elfNN_ia64_dyn_sym_info *dyn_i, void * data);
184 static bfd_boolean allocate_global_fptr_got
185 (struct elfNN_ia64_dyn_sym_info *dyn_i, void * data);
186 static bfd_boolean allocate_local_got
187 (struct elfNN_ia64_dyn_sym_info *dyn_i, void * data);
188 static bfd_boolean elfNN_ia64_hpux_vec
189 (const bfd_target *vec);
190 static bfd_boolean allocate_dynrel_entries
191 (struct elfNN_ia64_dyn_sym_info *dyn_i, void * data);
192 static asection *get_pltoff
193 (bfd *abfd, struct bfd_link_info *info,
194 struct elfNN_ia64_link_hash_table *ia64_info);
196 /* ia64-specific relocation. */
198 /* Given a ELF reloc, return the matching HOWTO structure. */
201 elfNN_ia64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
203 Elf_Internal_Rela *elf_reloc)
206 = ia64_elf_lookup_howto ((unsigned int) ELFNN_R_TYPE (elf_reloc->r_info));
209 #define PLT_HEADER_SIZE (3 * 16)
210 #define PLT_MIN_ENTRY_SIZE (1 * 16)
211 #define PLT_FULL_ENTRY_SIZE (2 * 16)
212 #define PLT_RESERVED_WORDS 3
214 static const bfd_byte plt_header[PLT_HEADER_SIZE] =
216 0x0b, 0x10, 0x00, 0x1c, 0x00, 0x21, /* [MMI] mov r2=r14;; */
217 0xe0, 0x00, 0x08, 0x00, 0x48, 0x00, /* addl r14=0,r2 */
218 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
219 0x0b, 0x80, 0x20, 0x1c, 0x18, 0x14, /* [MMI] ld8 r16=[r14],8;; */
220 0x10, 0x41, 0x38, 0x30, 0x28, 0x00, /* ld8 r17=[r14],8 */
221 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
222 0x11, 0x08, 0x00, 0x1c, 0x18, 0x10, /* [MIB] ld8 r1=[r14] */
223 0x60, 0x88, 0x04, 0x80, 0x03, 0x00, /* mov b6=r17 */
224 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
227 static const bfd_byte plt_min_entry[PLT_MIN_ENTRY_SIZE] =
229 0x11, 0x78, 0x00, 0x00, 0x00, 0x24, /* [MIB] mov r15=0 */
230 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, /* nop.i 0x0 */
231 0x00, 0x00, 0x00, 0x40 /* br.few 0 <PLT0>;; */
234 static const bfd_byte plt_full_entry[PLT_FULL_ENTRY_SIZE] =
236 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
237 0x00, 0x41, 0x3c, 0x70, 0x29, 0xc0, /* ld8.acq r16=[r15],8*/
238 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
239 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
240 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
241 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
244 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
246 static const bfd_byte oor_brl[16] =
248 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
249 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;; */
250 0x00, 0x00, 0x00, 0xc0
253 static const bfd_byte oor_ip[48] =
255 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
256 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, /* movl r15=0 */
257 0x01, 0x00, 0x00, 0x60,
258 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MII] nop.m 0 */
259 0x00, 0x01, 0x00, 0x60, 0x00, 0x00, /* mov r16=ip;; */
260 0xf2, 0x80, 0x00, 0x80, /* add r16=r15,r16;; */
261 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MIB] nop.m 0 */
262 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
263 0x60, 0x00, 0x80, 0x00 /* br b6;; */
266 static size_t oor_branch_size = sizeof (oor_brl);
269 bfd_elfNN_ia64_after_parse (int itanium)
271 oor_branch_size = itanium ? sizeof (oor_ip) : sizeof (oor_brl);
275 /* Rename some of the generic section flags to better document how they
277 #define skip_relax_pass_0 sec_flg0
278 #define skip_relax_pass_1 sec_flg1
280 /* These functions do relaxation for IA-64 ELF. */
283 elfNN_ia64_update_short_info (asection *sec, bfd_vma offset,
284 struct elfNN_ia64_link_hash_table *ia64_info)
286 /* Skip ABS and SHF_IA_64_SHORT sections. */
287 if (sec == bfd_abs_section_ptr
288 || (sec->flags & SEC_SMALL_DATA) != 0)
291 if (!ia64_info->min_short_sec)
293 ia64_info->max_short_sec = sec;
294 ia64_info->max_short_offset = offset;
295 ia64_info->min_short_sec = sec;
296 ia64_info->min_short_offset = offset;
298 else if (sec == ia64_info->max_short_sec
299 && offset > ia64_info->max_short_offset)
300 ia64_info->max_short_offset = offset;
301 else if (sec == ia64_info->min_short_sec
302 && offset < ia64_info->min_short_offset)
303 ia64_info->min_short_offset = offset;
304 else if (sec->output_section->vma
305 > ia64_info->max_short_sec->vma)
307 ia64_info->max_short_sec = sec;
308 ia64_info->max_short_offset = offset;
310 else if (sec->output_section->vma
311 < ia64_info->min_short_sec->vma)
313 ia64_info->min_short_sec = sec;
314 ia64_info->min_short_offset = offset;
319 elfNN_ia64_relax_section (bfd *abfd, asection *sec,
320 struct bfd_link_info *link_info,
325 struct one_fixup *next;
331 Elf_Internal_Shdr *symtab_hdr;
332 Elf_Internal_Rela *internal_relocs;
333 Elf_Internal_Rela *irel, *irelend;
335 Elf_Internal_Sym *isymbuf = NULL;
336 struct elfNN_ia64_link_hash_table *ia64_info;
337 struct one_fixup *fixups = NULL;
338 bfd_boolean changed_contents = FALSE;
339 bfd_boolean changed_relocs = FALSE;
340 bfd_boolean changed_got = FALSE;
341 bfd_boolean skip_relax_pass_0 = TRUE;
342 bfd_boolean skip_relax_pass_1 = TRUE;
345 /* Assume we're not going to change any sizes, and we'll only need
349 if (bfd_link_relocatable (link_info))
350 (*link_info->callbacks->einfo)
351 (_("%P%F: --relax and -r may not be used together\n"));
353 /* Don't even try to relax for non-ELF outputs. */
354 if (!is_elf_hash_table (link_info->hash))
357 /* Nothing to do if there are no relocations or there is no need for
359 if ((sec->flags & SEC_RELOC) == 0
360 || sec->reloc_count == 0
361 || (link_info->relax_pass == 0 && sec->skip_relax_pass_0)
362 || (link_info->relax_pass == 1 && sec->skip_relax_pass_1))
365 ia64_info = elfNN_ia64_hash_table (link_info);
366 if (ia64_info == NULL)
369 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
371 /* Load the relocations for this section. */
372 internal_relocs = (_bfd_elf_link_read_relocs
373 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
374 link_info->keep_memory));
375 if (internal_relocs == NULL)
378 irelend = internal_relocs + sec->reloc_count;
380 /* Get the section contents. */
381 if (elf_section_data (sec)->this_hdr.contents != NULL)
382 contents = elf_section_data (sec)->this_hdr.contents;
385 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
389 for (irel = internal_relocs; irel < irelend; irel++)
391 unsigned long r_type = ELFNN_R_TYPE (irel->r_info);
392 bfd_vma symaddr, reladdr, trampoff, toff, roff;
396 bfd_boolean is_branch;
397 struct elfNN_ia64_dyn_sym_info *dyn_i;
402 case R_IA64_PCREL21B:
403 case R_IA64_PCREL21BI:
404 case R_IA64_PCREL21M:
405 case R_IA64_PCREL21F:
406 /* In pass 1, all br relaxations are done. We can skip it. */
407 if (link_info->relax_pass == 1)
409 skip_relax_pass_0 = FALSE;
413 case R_IA64_PCREL60B:
414 /* We can't optimize brl to br in pass 0 since br relaxations
415 will increase the code size. Defer it to pass 1. */
416 if (link_info->relax_pass == 0)
418 skip_relax_pass_1 = FALSE;
425 /* Update max_short_sec/min_short_sec. */
427 case R_IA64_LTOFF22X:
429 /* We can't relax ldx/mov in pass 0 since br relaxations will
430 increase the code size. Defer it to pass 1. */
431 if (link_info->relax_pass == 0)
433 skip_relax_pass_1 = FALSE;
443 /* Get the value of the symbol referred to by the reloc. */
444 if (ELFNN_R_SYM (irel->r_info) < symtab_hdr->sh_info)
446 /* A local symbol. */
447 Elf_Internal_Sym *isym;
449 /* Read this BFD's local symbols. */
452 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
454 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
455 symtab_hdr->sh_info, 0,
461 isym = isymbuf + ELFNN_R_SYM (irel->r_info);
462 if (isym->st_shndx == SHN_UNDEF)
463 continue; /* We can't do anything with undefined symbols. */
464 else if (isym->st_shndx == SHN_ABS)
465 tsec = bfd_abs_section_ptr;
466 else if (isym->st_shndx == SHN_COMMON)
467 tsec = bfd_com_section_ptr;
468 else if (isym->st_shndx == SHN_IA_64_ANSI_COMMON)
469 tsec = bfd_com_section_ptr;
471 tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
473 toff = isym->st_value;
474 dyn_i = get_dyn_sym_info (ia64_info, NULL, abfd, irel, FALSE);
475 symtype = ELF_ST_TYPE (isym->st_info);
480 struct elf_link_hash_entry *h;
482 indx = ELFNN_R_SYM (irel->r_info) - symtab_hdr->sh_info;
483 h = elf_sym_hashes (abfd)[indx];
484 BFD_ASSERT (h != NULL);
486 while (h->root.type == bfd_link_hash_indirect
487 || h->root.type == bfd_link_hash_warning)
488 h = (struct elf_link_hash_entry *) h->root.u.i.link;
490 dyn_i = get_dyn_sym_info (ia64_info, h, abfd, irel, FALSE);
492 /* For branches to dynamic symbols, we're interested instead
493 in a branch to the PLT entry. */
494 if (is_branch && dyn_i && dyn_i->want_plt2)
496 /* Internal branches shouldn't be sent to the PLT.
497 Leave this for now and we'll give an error later. */
498 if (r_type != R_IA64_PCREL21B)
501 tsec = ia64_info->root.splt;
502 toff = dyn_i->plt2_offset;
503 BFD_ASSERT (irel->r_addend == 0);
506 /* Can't do anything else with dynamic symbols. */
507 else if (elfNN_ia64_dynamic_symbol_p (h, link_info, r_type))
512 /* We can't do anything with undefined symbols. */
513 if (h->root.type == bfd_link_hash_undefined
514 || h->root.type == bfd_link_hash_undefweak)
517 tsec = h->root.u.def.section;
518 toff = h->root.u.def.value;
524 if (tsec->sec_info_type == SEC_INFO_TYPE_MERGE)
526 /* At this stage in linking, no SEC_MERGE symbol has been
527 adjusted, so all references to such symbols need to be
528 passed through _bfd_merged_section_offset. (Later, in
529 relocate_section, all SEC_MERGE symbols *except* for
530 section symbols have been adjusted.)
532 gas may reduce relocations against symbols in SEC_MERGE
533 sections to a relocation against the section symbol when
534 the original addend was zero. When the reloc is against
535 a section symbol we should include the addend in the
536 offset passed to _bfd_merged_section_offset, since the
537 location of interest is the original symbol. On the
538 other hand, an access to "sym+addend" where "sym" is not
539 a section symbol should not include the addend; Such an
540 access is presumed to be an offset from "sym"; The
541 location of interest is just "sym". */
542 if (symtype == STT_SECTION)
543 toff += irel->r_addend;
545 toff = _bfd_merged_section_offset (abfd, &tsec,
546 elf_section_data (tsec)->sec_info,
549 if (symtype != STT_SECTION)
550 toff += irel->r_addend;
553 toff += irel->r_addend;
555 symaddr = tsec->output_section->vma + tsec->output_offset + toff;
557 roff = irel->r_offset;
561 bfd_signed_vma offset;
563 reladdr = (sec->output_section->vma
565 + roff) & (bfd_vma) -4;
567 /* The .plt section is aligned at 32byte and the .text section
568 is aligned at 64byte. The .text section is right after the
569 .plt section. After the first relaxation pass, linker may
570 increase the gap between the .plt and .text sections up
571 to 32byte. We assume linker will always insert 32byte
572 between the .plt and .text sections after the first
574 if (tsec == ia64_info->root.splt)
575 offset = -0x1000000 + 32;
579 /* If the branch is in range, no need to do anything. */
580 if ((bfd_signed_vma) (symaddr - reladdr) >= offset
581 && (bfd_signed_vma) (symaddr - reladdr) <= 0x0FFFFF0)
583 /* If the 60-bit branch is in 21-bit range, optimize it. */
584 if (r_type == R_IA64_PCREL60B)
586 ia64_elf_relax_brl (contents, roff);
589 = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
592 /* If the original relocation offset points to slot
593 1, change it to slot 2. */
594 if ((irel->r_offset & 3) == 1)
597 changed_contents = TRUE;
598 changed_relocs = TRUE;
603 else if (r_type == R_IA64_PCREL60B)
605 else if (ia64_elf_relax_br (contents, roff))
608 = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
611 /* Make the relocation offset point to slot 1. */
612 irel->r_offset = (irel->r_offset & ~((bfd_vma) 0x3)) + 1;
614 changed_contents = TRUE;
615 changed_relocs = TRUE;
619 /* We can't put a trampoline in a .init/.fini section. Issue
621 if (strcmp (sec->output_section->name, ".init") == 0
622 || strcmp (sec->output_section->name, ".fini") == 0)
625 /* xgettext:c-format */
626 (_("%pB: can't relax br at %#" PRIx64 " in section `%pA';"
627 " please use brl or indirect branch"),
628 sec->owner, (uint64_t) roff, sec);
629 bfd_set_error (bfd_error_bad_value);
633 /* If the branch and target are in the same section, you've
634 got one honking big section and we can't help you unless
635 you are branching backwards. You'll get an error message
637 if (tsec == sec && toff > roff)
640 /* Look for an existing fixup to this address. */
641 for (f = fixups; f ; f = f->next)
642 if (f->tsec == tsec && f->toff == toff)
647 /* Two alternatives: If it's a branch to a PLT entry, we can
648 make a copy of the FULL_PLT entry. Otherwise, we'll have
649 to use a `brl' insn to get where we're going. */
653 if (tsec == ia64_info->root.splt)
654 size = sizeof (plt_full_entry);
656 size = oor_branch_size;
658 /* Resize the current section to make room for the new branch. */
659 trampoff = (sec->size + 15) & (bfd_vma) -16;
661 /* If trampoline is out of range, there is nothing we
663 offset = trampoff - (roff & (bfd_vma) -4);
664 if (offset < -0x1000000 || offset > 0x0FFFFF0)
667 amt = trampoff + size;
668 contents = (bfd_byte *) bfd_realloc (contents, amt);
669 if (contents == NULL)
673 if (tsec == ia64_info->root.splt)
675 memcpy (contents + trampoff, plt_full_entry, size);
677 /* Hijack the old relocation for use as the PLTOFF reloc. */
678 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
680 irel->r_offset = trampoff;
684 if (size == sizeof (oor_ip))
686 memcpy (contents + trampoff, oor_ip, size);
687 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
689 irel->r_addend -= 16;
690 irel->r_offset = trampoff + 2;
694 memcpy (contents + trampoff, oor_brl, size);
695 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
697 irel->r_offset = trampoff + 2;
702 /* Record the fixup so we don't do it again this section. */
703 f = (struct one_fixup *)
704 bfd_malloc ((bfd_size_type) sizeof (*f));
708 f->trampoff = trampoff;
713 /* If trampoline is out of range, there is nothing we
715 offset = f->trampoff - (roff & (bfd_vma) -4);
716 if (offset < -0x1000000 || offset > 0x0FFFFF0)
719 /* Nop out the reloc, since we're finalizing things here. */
720 irel->r_info = ELFNN_R_INFO (0, R_IA64_NONE);
723 /* Fix up the existing branch to hit the trampoline. */
724 if (ia64_elf_install_value (contents + roff, offset, r_type)
728 changed_contents = TRUE;
729 changed_relocs = TRUE;
736 bfd *obfd = sec->output_section->owner;
737 gp = _bfd_get_gp_value (obfd);
740 if (!elfNN_ia64_choose_gp (obfd, link_info, FALSE))
742 gp = _bfd_get_gp_value (obfd);
746 /* If the data is out of range, do nothing. */
747 if ((bfd_signed_vma) (symaddr - gp) >= 0x200000
748 ||(bfd_signed_vma) (symaddr - gp) < -0x200000)
751 if (r_type == R_IA64_GPREL22)
752 elfNN_ia64_update_short_info (tsec->output_section,
753 tsec->output_offset + toff,
755 else if (r_type == R_IA64_LTOFF22X)
757 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
759 changed_relocs = TRUE;
760 if (dyn_i->want_gotx)
762 dyn_i->want_gotx = 0;
763 changed_got |= !dyn_i->want_got;
766 elfNN_ia64_update_short_info (tsec->output_section,
767 tsec->output_offset + toff,
772 ia64_elf_relax_ldxmov (contents, roff);
773 irel->r_info = ELFNN_R_INFO (0, R_IA64_NONE);
774 changed_contents = TRUE;
775 changed_relocs = TRUE;
780 /* ??? If we created fixups, this may push the code segment large
781 enough that the data segment moves, which will change the GP.
782 Reset the GP so that we re-calculate next round. We need to
783 do this at the _beginning_ of the next round; now will not do. */
785 /* Clean up and go home. */
788 struct one_fixup *f = fixups;
789 fixups = fixups->next;
794 && symtab_hdr->contents != (unsigned char *) isymbuf)
796 if (! link_info->keep_memory)
800 /* Cache the symbols for elf_link_input_bfd. */
801 symtab_hdr->contents = (unsigned char *) isymbuf;
806 && elf_section_data (sec)->this_hdr.contents != contents)
808 if (!changed_contents && !link_info->keep_memory)
812 /* Cache the section contents for elf_link_input_bfd. */
813 elf_section_data (sec)->this_hdr.contents = contents;
817 if (elf_section_data (sec)->relocs != internal_relocs)
820 free (internal_relocs);
822 elf_section_data (sec)->relocs = internal_relocs;
827 struct elfNN_ia64_allocate_data data;
828 data.info = link_info;
830 ia64_info->self_dtpmod_offset = (bfd_vma) -1;
832 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data);
833 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data);
834 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data);
835 ia64_info->root.sgot->size = data.ofs;
837 if (ia64_info->root.dynamic_sections_created
838 && ia64_info->root.srelgot != NULL)
840 /* Resize .rela.got. */
841 ia64_info->root.srelgot->size = 0;
842 if (bfd_link_pic (link_info)
843 && ia64_info->self_dtpmod_offset != (bfd_vma) -1)
844 ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela);
845 data.only_got = TRUE;
846 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries,
851 if (link_info->relax_pass == 0)
853 /* Pass 0 is only needed to relax br. */
854 sec->skip_relax_pass_0 = skip_relax_pass_0;
855 sec->skip_relax_pass_1 = skip_relax_pass_1;
858 *again = changed_contents || changed_relocs;
862 if (isymbuf != NULL && (unsigned char *) isymbuf != symtab_hdr->contents)
865 && elf_section_data (sec)->this_hdr.contents != contents)
867 if (internal_relocs != NULL
868 && elf_section_data (sec)->relocs != internal_relocs)
869 free (internal_relocs);
872 #undef skip_relax_pass_0
873 #undef skip_relax_pass_1
875 /* Return TRUE if NAME is an unwind table section name. */
877 static inline bfd_boolean
878 is_unwind_section_name (bfd *abfd, const char *name)
880 if (elfNN_ia64_hpux_vec (abfd->xvec)
881 && !strcmp (name, ELF_STRING_ia64_unwind_hdr))
884 return ((CONST_STRNEQ (name, ELF_STRING_ia64_unwind)
885 && ! CONST_STRNEQ (name, ELF_STRING_ia64_unwind_info))
886 || CONST_STRNEQ (name, ELF_STRING_ia64_unwind_once));
889 /* Handle an IA-64 specific section when reading an object file. This
890 is called when bfd_section_from_shdr finds a section with an unknown
894 elfNN_ia64_section_from_shdr (bfd *abfd,
895 Elf_Internal_Shdr *hdr,
899 /* There ought to be a place to keep ELF backend specific flags, but
900 at the moment there isn't one. We just keep track of the
901 sections by their name, instead. Fortunately, the ABI gives
902 suggested names for all the MIPS specific sections, so we will
903 probably get away with this. */
904 switch (hdr->sh_type)
906 case SHT_IA_64_UNWIND:
907 case SHT_IA_64_HP_OPT_ANOT:
911 if (strcmp (name, ELF_STRING_ia64_archext) != 0)
919 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
925 /* Convert IA-64 specific section flags to bfd internal section flags. */
927 /* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
931 elfNN_ia64_section_flags (flagword *flags,
932 const Elf_Internal_Shdr *hdr)
934 if (hdr->sh_flags & SHF_IA_64_SHORT)
935 *flags |= SEC_SMALL_DATA;
940 /* Set the correct type for an IA-64 ELF section. We do this by the
941 section name, which is a hack, but ought to work. */
944 elfNN_ia64_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr,
949 name = bfd_get_section_name (abfd, sec);
951 if (is_unwind_section_name (abfd, name))
953 /* We don't have the sections numbered at this point, so sh_info
954 is set later, in elfNN_ia64_final_write_processing. */
955 hdr->sh_type = SHT_IA_64_UNWIND;
956 hdr->sh_flags |= SHF_LINK_ORDER;
958 else if (strcmp (name, ELF_STRING_ia64_archext) == 0)
959 hdr->sh_type = SHT_IA_64_EXT;
960 else if (strcmp (name, ".HP.opt_annot") == 0)
961 hdr->sh_type = SHT_IA_64_HP_OPT_ANOT;
962 else if (strcmp (name, ".reloc") == 0)
963 /* This is an ugly, but unfortunately necessary hack that is
964 needed when producing EFI binaries on IA-64. It tells
965 elf.c:elf_fake_sections() not to consider ".reloc" as a section
966 containing ELF relocation info. We need this hack in order to
967 be able to generate ELF binaries that can be translated into
968 EFI applications (which are essentially COFF objects). Those
969 files contain a COFF ".reloc" section inside an ELFNN object,
970 which would normally cause BFD to segfault because it would
971 attempt to interpret this section as containing relocation
972 entries for section "oc". With this hack enabled, ".reloc"
973 will be treated as a normal data section, which will avoid the
974 segfault. However, you won't be able to create an ELFNN binary
975 with a section named "oc" that needs relocations, but that's
976 the kind of ugly side-effects you get when detecting section
977 types based on their names... In practice, this limitation is
979 hdr->sh_type = SHT_PROGBITS;
981 if (sec->flags & SEC_SMALL_DATA)
982 hdr->sh_flags |= SHF_IA_64_SHORT;
984 /* Some HP linkers look for the SHF_IA_64_HP_TLS flag instead of SHF_TLS. */
986 if (elfNN_ia64_hpux_vec (abfd->xvec) && (sec->flags & SHF_TLS))
987 hdr->sh_flags |= SHF_IA_64_HP_TLS;
992 /* The final processing done just before writing out an IA-64 ELF
996 elfNN_ia64_final_write_processing (bfd *abfd,
997 bfd_boolean linker ATTRIBUTE_UNUSED)
999 Elf_Internal_Shdr *hdr;
1002 for (s = abfd->sections; s; s = s->next)
1004 hdr = &elf_section_data (s)->this_hdr;
1005 switch (hdr->sh_type)
1007 case SHT_IA_64_UNWIND:
1008 /* The IA-64 processor-specific ABI requires setting sh_link
1009 to the unwind section, whereas HP-UX requires sh_info to
1010 do so. For maximum compatibility, we'll set both for
1012 hdr->sh_info = hdr->sh_link;
1017 if (! elf_flags_init (abfd))
1019 unsigned long flags = 0;
1021 if (abfd->xvec->byteorder == BFD_ENDIAN_BIG)
1022 flags |= EF_IA_64_BE;
1023 if (bfd_get_mach (abfd) == bfd_mach_ia64_elf64)
1024 flags |= EF_IA_64_ABI64;
1026 elf_elfheader(abfd)->e_flags = flags;
1027 elf_flags_init (abfd) = TRUE;
1031 /* Hook called by the linker routine which adds symbols from an object
1032 file. We use it to put .comm items in .sbss, and not .bss. */
1035 elfNN_ia64_add_symbol_hook (bfd *abfd,
1036 struct bfd_link_info *info,
1037 Elf_Internal_Sym *sym,
1038 const char **namep ATTRIBUTE_UNUSED,
1039 flagword *flagsp ATTRIBUTE_UNUSED,
1043 if (sym->st_shndx == SHN_COMMON
1044 && !bfd_link_relocatable (info)
1045 && sym->st_size <= elf_gp_size (abfd))
1047 /* Common symbols less than or equal to -G nn bytes are
1048 automatically put into .sbss. */
1050 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1054 scomm = bfd_make_section_with_flags (abfd, ".scommon",
1057 | SEC_LINKER_CREATED));
1063 *valp = sym->st_size;
1069 /* Return the number of additional phdrs we will need. */
1072 elfNN_ia64_additional_program_headers (bfd *abfd,
1073 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1078 /* See if we need a PT_IA_64_ARCHEXT segment. */
1079 s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_archext);
1080 if (s && (s->flags & SEC_LOAD))
1083 /* Count how many PT_IA_64_UNWIND segments we need. */
1084 for (s = abfd->sections; s; s = s->next)
1085 if (is_unwind_section_name (abfd, s->name) && (s->flags & SEC_LOAD))
1092 elfNN_ia64_modify_segment_map (bfd *abfd,
1093 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1095 struct elf_segment_map *m, **pm;
1096 Elf_Internal_Shdr *hdr;
1099 /* If we need a PT_IA_64_ARCHEXT segment, it must come before
1100 all PT_LOAD segments. */
1101 s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_archext);
1102 if (s && (s->flags & SEC_LOAD))
1104 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
1105 if (m->p_type == PT_IA_64_ARCHEXT)
1109 m = ((struct elf_segment_map *)
1110 bfd_zalloc (abfd, (bfd_size_type) sizeof *m));
1114 m->p_type = PT_IA_64_ARCHEXT;
1118 /* We want to put it after the PHDR and INTERP segments. */
1119 pm = &elf_seg_map (abfd);
1121 && ((*pm)->p_type == PT_PHDR
1122 || (*pm)->p_type == PT_INTERP))
1130 /* Install PT_IA_64_UNWIND segments, if needed. */
1131 for (s = abfd->sections; s; s = s->next)
1133 hdr = &elf_section_data (s)->this_hdr;
1134 if (hdr->sh_type != SHT_IA_64_UNWIND)
1137 if (s && (s->flags & SEC_LOAD))
1139 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
1140 if (m->p_type == PT_IA_64_UNWIND)
1144 /* Look through all sections in the unwind segment
1145 for a match since there may be multiple sections
1147 for (i = m->count - 1; i >= 0; --i)
1148 if (m->sections[i] == s)
1157 m = ((struct elf_segment_map *)
1158 bfd_zalloc (abfd, (bfd_size_type) sizeof *m));
1162 m->p_type = PT_IA_64_UNWIND;
1167 /* We want to put it last. */
1168 pm = &elf_seg_map (abfd);
1179 /* Turn on PF_IA_64_NORECOV if needed. This involves traversing all of
1180 the input sections for each output section in the segment and testing
1181 for SHF_IA_64_NORECOV on each. */
1184 elfNN_ia64_modify_program_headers (bfd *abfd,
1185 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1187 struct elf_obj_tdata *tdata = elf_tdata (abfd);
1188 struct elf_segment_map *m;
1189 Elf_Internal_Phdr *p;
1191 for (p = tdata->phdr, m = elf_seg_map (abfd); m != NULL; m = m->next, p++)
1192 if (m->p_type == PT_LOAD)
1195 for (i = m->count - 1; i >= 0; --i)
1197 struct bfd_link_order *order = m->sections[i]->map_head.link_order;
1199 while (order != NULL)
1201 if (order->type == bfd_indirect_link_order)
1203 asection *is = order->u.indirect.section;
1204 bfd_vma flags = elf_section_data(is)->this_hdr.sh_flags;
1205 if (flags & SHF_IA_64_NORECOV)
1207 p->p_flags |= PF_IA_64_NORECOV;
1211 order = order->next;
1220 /* According to the Tahoe assembler spec, all labels starting with a
1224 elfNN_ia64_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
1227 return name[0] == '.';
1230 /* Should we do dynamic things to this symbol? */
1233 elfNN_ia64_dynamic_symbol_p (struct elf_link_hash_entry *h,
1234 struct bfd_link_info *info, int r_type)
1236 bfd_boolean ignore_protected
1237 = ((r_type & 0xf8) == 0x40 /* FPTR relocs */
1238 || (r_type & 0xf8) == 0x50); /* LTOFF_FPTR relocs */
1240 return _bfd_elf_dynamic_symbol_p (h, info, ignore_protected);
1243 static struct bfd_hash_entry*
1244 elfNN_ia64_new_elf_hash_entry (struct bfd_hash_entry *entry,
1245 struct bfd_hash_table *table,
1248 struct elfNN_ia64_link_hash_entry *ret;
1249 ret = (struct elfNN_ia64_link_hash_entry *) entry;
1251 /* Allocate the structure if it has not already been allocated by a
1254 ret = bfd_hash_allocate (table, sizeof (*ret));
1259 /* Call the allocation method of the superclass. */
1260 ret = ((struct elfNN_ia64_link_hash_entry *)
1261 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1266 ret->sorted_count = 0;
1268 return (struct bfd_hash_entry *) ret;
1272 elfNN_ia64_hash_copy_indirect (struct bfd_link_info *info,
1273 struct elf_link_hash_entry *xdir,
1274 struct elf_link_hash_entry *xind)
1276 struct elfNN_ia64_link_hash_entry *dir, *ind;
1278 dir = (struct elfNN_ia64_link_hash_entry *) xdir;
1279 ind = (struct elfNN_ia64_link_hash_entry *) xind;
1281 /* Copy down any references that we may have already seen to the
1282 symbol which just became indirect. */
1284 if (dir->root.versioned != versioned_hidden)
1285 dir->root.ref_dynamic |= ind->root.ref_dynamic;
1286 dir->root.ref_regular |= ind->root.ref_regular;
1287 dir->root.ref_regular_nonweak |= ind->root.ref_regular_nonweak;
1288 dir->root.needs_plt |= ind->root.needs_plt;
1290 if (ind->root.root.type != bfd_link_hash_indirect)
1293 /* Copy over the got and plt data. This would have been done
1296 if (ind->info != NULL)
1298 struct elfNN_ia64_dyn_sym_info *dyn_i;
1304 dir->info = ind->info;
1305 dir->count = ind->count;
1306 dir->sorted_count = ind->sorted_count;
1307 dir->size = ind->size;
1311 ind->sorted_count = 0;
1314 /* Fix up the dyn_sym_info pointers to the global symbol. */
1315 for (count = dir->count, dyn_i = dir->info;
1318 dyn_i->h = &dir->root;
1321 /* Copy over the dynindx. */
1323 if (ind->root.dynindx != -1)
1325 if (dir->root.dynindx != -1)
1326 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1327 dir->root.dynstr_index);
1328 dir->root.dynindx = ind->root.dynindx;
1329 dir->root.dynstr_index = ind->root.dynstr_index;
1330 ind->root.dynindx = -1;
1331 ind->root.dynstr_index = 0;
1336 elfNN_ia64_hash_hide_symbol (struct bfd_link_info *info,
1337 struct elf_link_hash_entry *xh,
1338 bfd_boolean force_local)
1340 struct elfNN_ia64_link_hash_entry *h;
1341 struct elfNN_ia64_dyn_sym_info *dyn_i;
1344 h = (struct elfNN_ia64_link_hash_entry *)xh;
1346 _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local);
1348 for (count = h->count, dyn_i = h->info;
1352 dyn_i->want_plt2 = 0;
1353 dyn_i->want_plt = 0;
1357 /* Compute a hash of a local hash entry. */
1360 elfNN_ia64_local_htab_hash (const void *ptr)
1362 struct elfNN_ia64_local_hash_entry *entry
1363 = (struct elfNN_ia64_local_hash_entry *) ptr;
1365 return ELF_LOCAL_SYMBOL_HASH (entry->id, entry->r_sym);
1368 /* Compare local hash entries. */
1371 elfNN_ia64_local_htab_eq (const void *ptr1, const void *ptr2)
1373 struct elfNN_ia64_local_hash_entry *entry1
1374 = (struct elfNN_ia64_local_hash_entry *) ptr1;
1375 struct elfNN_ia64_local_hash_entry *entry2
1376 = (struct elfNN_ia64_local_hash_entry *) ptr2;
1378 return entry1->id == entry2->id && entry1->r_sym == entry2->r_sym;
1381 /* Free the global elfNN_ia64_dyn_sym_info array. */
1384 elfNN_ia64_global_dyn_info_free (void **xentry,
1385 void * unused ATTRIBUTE_UNUSED)
1387 struct elfNN_ia64_link_hash_entry *entry
1388 = (struct elfNN_ia64_link_hash_entry *) xentry;
1395 entry->sorted_count = 0;
1402 /* Free the local elfNN_ia64_dyn_sym_info array. */
1405 elfNN_ia64_local_dyn_info_free (void **slot,
1406 void * unused ATTRIBUTE_UNUSED)
1408 struct elfNN_ia64_local_hash_entry *entry
1409 = (struct elfNN_ia64_local_hash_entry *) *slot;
1416 entry->sorted_count = 0;
1423 /* Destroy IA-64 linker hash table. */
1426 elfNN_ia64_link_hash_table_free (bfd *obfd)
1428 struct elfNN_ia64_link_hash_table *ia64_info
1429 = (struct elfNN_ia64_link_hash_table *) obfd->link.hash;
1430 if (ia64_info->loc_hash_table)
1432 htab_traverse (ia64_info->loc_hash_table,
1433 elfNN_ia64_local_dyn_info_free, NULL);
1434 htab_delete (ia64_info->loc_hash_table);
1436 if (ia64_info->loc_hash_memory)
1437 objalloc_free ((struct objalloc *) ia64_info->loc_hash_memory);
1438 elf_link_hash_traverse (&ia64_info->root,
1439 elfNN_ia64_global_dyn_info_free, NULL);
1440 _bfd_elf_link_hash_table_free (obfd);
1443 /* Create the derived linker hash table. The IA-64 ELF port uses this
1444 derived hash table to keep information specific to the IA-64 ElF
1445 linker (without using static variables). */
1447 static struct bfd_link_hash_table *
1448 elfNN_ia64_hash_table_create (bfd *abfd)
1450 struct elfNN_ia64_link_hash_table *ret;
1452 ret = bfd_zmalloc ((bfd_size_type) sizeof (*ret));
1456 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
1457 elfNN_ia64_new_elf_hash_entry,
1458 sizeof (struct elfNN_ia64_link_hash_entry),
1465 ret->loc_hash_table = htab_try_create (1024, elfNN_ia64_local_htab_hash,
1466 elfNN_ia64_local_htab_eq, NULL);
1467 ret->loc_hash_memory = objalloc_create ();
1468 if (!ret->loc_hash_table || !ret->loc_hash_memory)
1470 elfNN_ia64_link_hash_table_free (abfd);
1473 ret->root.root.hash_table_free = elfNN_ia64_link_hash_table_free;
1475 return &ret->root.root;
1478 /* Traverse both local and global hash tables. */
1480 struct elfNN_ia64_dyn_sym_traverse_data
1482 bfd_boolean (*func) (struct elfNN_ia64_dyn_sym_info *, void *);
1487 elfNN_ia64_global_dyn_sym_thunk (struct bfd_hash_entry *xentry,
1490 struct elfNN_ia64_link_hash_entry *entry
1491 = (struct elfNN_ia64_link_hash_entry *) xentry;
1492 struct elfNN_ia64_dyn_sym_traverse_data *data
1493 = (struct elfNN_ia64_dyn_sym_traverse_data *) xdata;
1494 struct elfNN_ia64_dyn_sym_info *dyn_i;
1497 for (count = entry->count, dyn_i = entry->info;
1500 if (! (*data->func) (dyn_i, data->data))
1506 elfNN_ia64_local_dyn_sym_thunk (void **slot, void * xdata)
1508 struct elfNN_ia64_local_hash_entry *entry
1509 = (struct elfNN_ia64_local_hash_entry *) *slot;
1510 struct elfNN_ia64_dyn_sym_traverse_data *data
1511 = (struct elfNN_ia64_dyn_sym_traverse_data *) xdata;
1512 struct elfNN_ia64_dyn_sym_info *dyn_i;
1515 for (count = entry->count, dyn_i = entry->info;
1518 if (! (*data->func) (dyn_i, data->data))
1524 elfNN_ia64_dyn_sym_traverse (struct elfNN_ia64_link_hash_table *ia64_info,
1525 bfd_boolean (*func) (struct elfNN_ia64_dyn_sym_info *, void *),
1528 struct elfNN_ia64_dyn_sym_traverse_data xdata;
1533 elf_link_hash_traverse (&ia64_info->root,
1534 elfNN_ia64_global_dyn_sym_thunk, &xdata);
1535 htab_traverse (ia64_info->loc_hash_table,
1536 elfNN_ia64_local_dyn_sym_thunk, &xdata);
1540 elfNN_ia64_create_dynamic_sections (bfd *abfd,
1541 struct bfd_link_info *info)
1543 struct elfNN_ia64_link_hash_table *ia64_info;
1546 if (! _bfd_elf_create_dynamic_sections (abfd, info))
1549 ia64_info = elfNN_ia64_hash_table (info);
1550 if (ia64_info == NULL)
1554 flagword flags = bfd_get_section_flags (abfd, ia64_info->root.sgot);
1555 bfd_set_section_flags (abfd, ia64_info->root.sgot,
1556 SEC_SMALL_DATA | flags);
1557 /* The .got section is always aligned at 8 bytes. */
1558 if (! bfd_set_section_alignment (abfd, ia64_info->root.sgot, 3))
1562 if (!get_pltoff (abfd, info, ia64_info))
1565 s = bfd_make_section_anyway_with_flags (abfd, ".rela.IA_64.pltoff",
1566 (SEC_ALLOC | SEC_LOAD
1569 | SEC_LINKER_CREATED
1572 || !bfd_set_section_alignment (abfd, s, LOG_SECTION_ALIGN))
1574 ia64_info->rel_pltoff_sec = s;
1579 /* Find and/or create a hash entry for local symbol. */
1580 static struct elfNN_ia64_local_hash_entry *
1581 get_local_sym_hash (struct elfNN_ia64_link_hash_table *ia64_info,
1582 bfd *abfd, const Elf_Internal_Rela *rel,
1585 struct elfNN_ia64_local_hash_entry e, *ret;
1586 asection *sec = abfd->sections;
1587 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
1588 ELFNN_R_SYM (rel->r_info));
1592 e.r_sym = ELFNN_R_SYM (rel->r_info);
1593 slot = htab_find_slot_with_hash (ia64_info->loc_hash_table, &e, h,
1594 create ? INSERT : NO_INSERT);
1600 return (struct elfNN_ia64_local_hash_entry *) *slot;
1602 ret = (struct elfNN_ia64_local_hash_entry *)
1603 objalloc_alloc ((struct objalloc *) ia64_info->loc_hash_memory,
1604 sizeof (struct elfNN_ia64_local_hash_entry));
1607 memset (ret, 0, sizeof (*ret));
1609 ret->r_sym = ELFNN_R_SYM (rel->r_info);
1615 /* Used to sort elfNN_ia64_dyn_sym_info array. */
1618 addend_compare (const void *xp, const void *yp)
1620 const struct elfNN_ia64_dyn_sym_info *x
1621 = (const struct elfNN_ia64_dyn_sym_info *) xp;
1622 const struct elfNN_ia64_dyn_sym_info *y
1623 = (const struct elfNN_ia64_dyn_sym_info *) yp;
1625 return x->addend < y->addend ? -1 : x->addend > y->addend ? 1 : 0;
1628 /* Sort elfNN_ia64_dyn_sym_info array and remove duplicates. */
1631 sort_dyn_sym_info (struct elfNN_ia64_dyn_sym_info *info,
1634 bfd_vma curr, prev, got_offset;
1635 unsigned int i, kept, dupes, diff, dest, src, len;
1637 qsort (info, count, sizeof (*info), addend_compare);
1639 /* Find the first duplicate. */
1640 prev = info [0].addend;
1641 got_offset = info [0].got_offset;
1642 for (i = 1; i < count; i++)
1644 curr = info [i].addend;
1647 /* For duplicates, make sure that GOT_OFFSET is valid. */
1648 if (got_offset == (bfd_vma) -1)
1649 got_offset = info [i].got_offset;
1652 got_offset = info [i].got_offset;
1656 /* We may move a block of elements to here. */
1659 /* Remove duplicates. */
1664 /* For duplicates, make sure that the kept one has a valid
1667 if (got_offset != (bfd_vma) -1)
1668 info [kept].got_offset = got_offset;
1670 curr = info [i].addend;
1671 got_offset = info [i].got_offset;
1673 /* Move a block of elements whose first one is different from
1677 for (src = i + 1; src < count; src++)
1679 if (info [src].addend != curr)
1681 /* For duplicates, make sure that GOT_OFFSET is
1683 if (got_offset == (bfd_vma) -1)
1684 got_offset = info [src].got_offset;
1687 /* Make sure that the kept one has a valid got_offset. */
1688 if (got_offset != (bfd_vma) -1)
1689 info [kept].got_offset = got_offset;
1697 /* Find the next duplicate. SRC will be kept. */
1698 prev = info [src].addend;
1699 got_offset = info [src].got_offset;
1700 for (dupes = src + 1; dupes < count; dupes ++)
1702 curr = info [dupes].addend;
1705 /* Make sure that got_offset is valid. */
1706 if (got_offset == (bfd_vma) -1)
1707 got_offset = info [dupes].got_offset;
1709 /* For duplicates, make sure that the kept one has
1710 a valid got_offset. */
1711 if (got_offset != (bfd_vma) -1)
1712 info [dupes - 1].got_offset = got_offset;
1715 got_offset = info [dupes].got_offset;
1719 /* How much to move. */
1723 if (len == 1 && dupes < count)
1725 /* If we only move 1 element, we combine it with the next
1726 one. There must be at least a duplicate. Find the
1727 next different one. */
1728 for (diff = dupes + 1, src++; diff < count; diff++, src++)
1730 if (info [diff].addend != curr)
1732 /* Make sure that got_offset is valid. */
1733 if (got_offset == (bfd_vma) -1)
1734 got_offset = info [diff].got_offset;
1737 /* Makre sure that the last duplicated one has an valid
1739 BFD_ASSERT (curr == prev);
1740 if (got_offset != (bfd_vma) -1)
1741 info [diff - 1].got_offset = got_offset;
1745 /* Find the next duplicate. Track the current valid
1747 prev = info [diff].addend;
1748 got_offset = info [diff].got_offset;
1749 for (dupes = diff + 1; dupes < count; dupes ++)
1751 curr = info [dupes].addend;
1754 /* For duplicates, make sure that GOT_OFFSET
1756 if (got_offset == (bfd_vma) -1)
1757 got_offset = info [dupes].got_offset;
1760 got_offset = info [dupes].got_offset;
1765 len = diff - src + 1;
1770 memmove (&info [dest], &info [src], len * sizeof (*info));
1779 /* When we get here, either there is no duplicate at all or
1780 the only duplicate is the last element. */
1783 /* If the last element is a duplicate, make sure that the
1784 kept one has a valid got_offset. We also update count. */
1785 if (got_offset != (bfd_vma) -1)
1786 info [dest - 1].got_offset = got_offset;
1794 /* Find and/or create a descriptor for dynamic symbol info. This will
1795 vary based on global or local symbol, and the addend to the reloc.
1797 We don't sort when inserting. Also, we sort and eliminate
1798 duplicates if there is an unsorted section. Typically, this will
1799 only happen once, because we do all insertions before lookups. We
1800 then use bsearch to do a lookup. This also allows lookups to be
1801 fast. So we have fast insertion (O(log N) due to duplicate check),
1802 fast lookup (O(log N)) and one sort (O(N log N) expected time).
1803 Previously, all lookups were O(N) because of the use of the linked
1804 list and also all insertions were O(N) because of the check for
1805 duplicates. There are some complications here because the array
1806 size grows occasionally, which may add an O(N) factor, but this
1807 should be rare. Also, we free the excess array allocation, which
1808 requires a copy which is O(N), but this only happens once. */
1810 static struct elfNN_ia64_dyn_sym_info *
1811 get_dyn_sym_info (struct elfNN_ia64_link_hash_table *ia64_info,
1812 struct elf_link_hash_entry *h, bfd *abfd,
1813 const Elf_Internal_Rela *rel, bfd_boolean create)
1815 struct elfNN_ia64_dyn_sym_info **info_p, *info, *dyn_i, key;
1816 unsigned int *count_p, *sorted_count_p, *size_p;
1817 unsigned int count, sorted_count, size;
1818 bfd_vma addend = rel ? rel->r_addend : 0;
1823 struct elfNN_ia64_link_hash_entry *global_h;
1825 global_h = (struct elfNN_ia64_link_hash_entry *) h;
1826 info_p = &global_h->info;
1827 count_p = &global_h->count;
1828 sorted_count_p = &global_h->sorted_count;
1829 size_p = &global_h->size;
1833 struct elfNN_ia64_local_hash_entry *loc_h;
1835 loc_h = get_local_sym_hash (ia64_info, abfd, rel, create);
1838 BFD_ASSERT (!create);
1842 info_p = &loc_h->info;
1843 count_p = &loc_h->count;
1844 sorted_count_p = &loc_h->sorted_count;
1845 size_p = &loc_h->size;
1849 sorted_count = *sorted_count_p;
1854 /* When we create the array, we don't check for duplicates,
1855 except in the previously sorted section if one exists, and
1856 against the last inserted entry. This allows insertions to
1862 /* Try bsearch first on the sorted section. */
1863 key.addend = addend;
1864 dyn_i = bsearch (&key, info, sorted_count,
1865 sizeof (*info), addend_compare);
1873 /* Do a quick check for the last inserted entry. */
1874 dyn_i = info + count - 1;
1875 if (dyn_i->addend == addend)
1883 /* It is the very first element. We create the array of size
1886 amt = size * sizeof (*info);
1887 info = bfd_malloc (amt);
1889 else if (size <= count)
1891 /* We double the array size every time when we reach the
1894 amt = size * sizeof (*info);
1895 info = bfd_realloc (info, amt);
1906 /* Append the new one to the array. */
1907 dyn_i = info + count;
1908 memset (dyn_i, 0, sizeof (*dyn_i));
1909 dyn_i->got_offset = (bfd_vma) -1;
1910 dyn_i->addend = addend;
1912 /* We increment count only since the new ones are unsorted and
1913 may have duplicate. */
1918 /* It is a lookup without insertion. Sort array if part of the
1919 array isn't sorted. */
1920 if (count != sorted_count)
1922 count = sort_dyn_sym_info (info, count);
1924 *sorted_count_p = count;
1927 /* Free unused memory. */
1930 amt = count * sizeof (*info);
1931 info = bfd_malloc (amt);
1934 memcpy (info, *info_p, amt);
1941 key.addend = addend;
1942 dyn_i = bsearch (&key, info, count,
1943 sizeof (*info), addend_compare);
1950 get_got (bfd *abfd, struct bfd_link_info *info,
1951 struct elfNN_ia64_link_hash_table *ia64_info)
1956 got = ia64_info->root.sgot;
1961 dynobj = ia64_info->root.dynobj;
1963 ia64_info->root.dynobj = dynobj = abfd;
1964 if (!_bfd_elf_create_got_section (dynobj, info))
1967 got = ia64_info->root.sgot;
1969 /* The .got section is always aligned at 8 bytes. */
1970 if (!bfd_set_section_alignment (abfd, got, 3))
1973 flags = bfd_get_section_flags (abfd, got);
1974 if (! bfd_set_section_flags (abfd, got, SEC_SMALL_DATA | flags))
1981 /* Create function descriptor section (.opd). This section is called .opd
1982 because it contains "official procedure descriptors". The "official"
1983 refers to the fact that these descriptors are used when taking the address
1984 of a procedure, thus ensuring a unique address for each procedure. */
1987 get_fptr (bfd *abfd, struct bfd_link_info *info,
1988 struct elfNN_ia64_link_hash_table *ia64_info)
1993 fptr = ia64_info->fptr_sec;
1996 dynobj = ia64_info->root.dynobj;
1998 ia64_info->root.dynobj = dynobj = abfd;
2000 fptr = bfd_make_section_anyway_with_flags (dynobj, ".opd",
2005 | (bfd_link_pie (info)
2007 | SEC_LINKER_CREATED));
2009 || !bfd_set_section_alignment (abfd, fptr, 4))
2015 ia64_info->fptr_sec = fptr;
2017 if (bfd_link_pie (info))
2020 fptr_rel = bfd_make_section_anyway_with_flags (dynobj, ".rela.opd",
2021 (SEC_ALLOC | SEC_LOAD
2024 | SEC_LINKER_CREATED
2026 if (fptr_rel == NULL
2027 || !bfd_set_section_alignment (abfd, fptr_rel,
2034 ia64_info->rel_fptr_sec = fptr_rel;
2042 get_pltoff (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED,
2043 struct elfNN_ia64_link_hash_table *ia64_info)
2048 pltoff = ia64_info->pltoff_sec;
2051 dynobj = ia64_info->root.dynobj;
2053 ia64_info->root.dynobj = dynobj = abfd;
2055 pltoff = bfd_make_section_anyway_with_flags (dynobj,
2056 ELF_STRING_ia64_pltoff,
2062 | SEC_LINKER_CREATED));
2064 || !bfd_set_section_alignment (abfd, pltoff, 4))
2070 ia64_info->pltoff_sec = pltoff;
2077 get_reloc_section (bfd *abfd,
2078 struct elfNN_ia64_link_hash_table *ia64_info,
2079 asection *sec, bfd_boolean create)
2081 const char *srel_name;
2085 srel_name = (bfd_elf_string_from_elf_section
2086 (abfd, elf_elfheader(abfd)->e_shstrndx,
2087 _bfd_elf_single_rel_hdr (sec)->sh_name));
2088 if (srel_name == NULL)
2091 dynobj = ia64_info->root.dynobj;
2093 ia64_info->root.dynobj = dynobj = abfd;
2095 srel = bfd_get_linker_section (dynobj, srel_name);
2096 if (srel == NULL && create)
2098 srel = bfd_make_section_anyway_with_flags (dynobj, srel_name,
2099 (SEC_ALLOC | SEC_LOAD
2102 | SEC_LINKER_CREATED
2105 || !bfd_set_section_alignment (dynobj, srel,
2114 count_dyn_reloc (bfd *abfd, struct elfNN_ia64_dyn_sym_info *dyn_i,
2115 asection *srel, int type, bfd_boolean reltext)
2117 struct elfNN_ia64_dyn_reloc_entry *rent;
2119 for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
2120 if (rent->srel == srel && rent->type == type)
2125 rent = ((struct elfNN_ia64_dyn_reloc_entry *)
2126 bfd_alloc (abfd, (bfd_size_type) sizeof (*rent)));
2130 rent->next = dyn_i->reloc_entries;
2134 dyn_i->reloc_entries = rent;
2136 rent->reltext = reltext;
2143 elfNN_ia64_check_relocs (bfd *abfd, struct bfd_link_info *info,
2145 const Elf_Internal_Rela *relocs)
2147 struct elfNN_ia64_link_hash_table *ia64_info;
2148 const Elf_Internal_Rela *relend;
2149 Elf_Internal_Shdr *symtab_hdr;
2150 const Elf_Internal_Rela *rel;
2151 asection *got, *fptr, *srel, *pltoff;
2160 NEED_LTOFF_FPTR = 128,
2166 struct elf_link_hash_entry *h;
2167 unsigned long r_symndx;
2168 bfd_boolean maybe_dynamic;
2170 if (bfd_link_relocatable (info))
2173 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2174 ia64_info = elfNN_ia64_hash_table (info);
2175 if (ia64_info == NULL)
2178 got = fptr = srel = pltoff = NULL;
2180 relend = relocs + sec->reloc_count;
2182 /* We scan relocations first to create dynamic relocation arrays. We
2183 modified get_dyn_sym_info to allow fast insertion and support fast
2184 lookup in the next loop. */
2185 for (rel = relocs; rel < relend; ++rel)
2187 r_symndx = ELFNN_R_SYM (rel->r_info);
2188 if (r_symndx >= symtab_hdr->sh_info)
2190 long indx = r_symndx - symtab_hdr->sh_info;
2191 h = elf_sym_hashes (abfd)[indx];
2192 while (h->root.type == bfd_link_hash_indirect
2193 || h->root.type == bfd_link_hash_warning)
2194 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2199 if (h && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
2202 /* We can only get preliminary data on whether a symbol is
2203 locally or externally defined, as not all of the input files
2204 have yet been processed. Do something with what we know, as
2205 this may help reduce memory usage and processing time later. */
2206 maybe_dynamic = (h && ((!bfd_link_executable (info)
2207 && (!SYMBOLIC_BIND (info, h)
2208 || info->unresolved_syms_in_shared_libs == RM_IGNORE))
2210 || h->root.type == bfd_link_hash_defweak));
2213 switch (ELFNN_R_TYPE (rel->r_info))
2215 case R_IA64_TPREL64MSB:
2216 case R_IA64_TPREL64LSB:
2217 if (bfd_link_pic (info) || maybe_dynamic)
2218 need_entry = NEED_DYNREL;
2221 case R_IA64_LTOFF_TPREL22:
2222 need_entry = NEED_TPREL;
2223 if (bfd_link_pic (info))
2224 info->flags |= DF_STATIC_TLS;
2227 case R_IA64_DTPREL32MSB:
2228 case R_IA64_DTPREL32LSB:
2229 case R_IA64_DTPREL64MSB:
2230 case R_IA64_DTPREL64LSB:
2231 if (bfd_link_pic (info) || maybe_dynamic)
2232 need_entry = NEED_DYNREL;
2235 case R_IA64_LTOFF_DTPREL22:
2236 need_entry = NEED_DTPREL;
2239 case R_IA64_DTPMOD64MSB:
2240 case R_IA64_DTPMOD64LSB:
2241 if (bfd_link_pic (info) || maybe_dynamic)
2242 need_entry = NEED_DYNREL;
2245 case R_IA64_LTOFF_DTPMOD22:
2246 need_entry = NEED_DTPMOD;
2249 case R_IA64_LTOFF_FPTR22:
2250 case R_IA64_LTOFF_FPTR64I:
2251 case R_IA64_LTOFF_FPTR32MSB:
2252 case R_IA64_LTOFF_FPTR32LSB:
2253 case R_IA64_LTOFF_FPTR64MSB:
2254 case R_IA64_LTOFF_FPTR64LSB:
2255 need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR;
2258 case R_IA64_FPTR64I:
2259 case R_IA64_FPTR32MSB:
2260 case R_IA64_FPTR32LSB:
2261 case R_IA64_FPTR64MSB:
2262 case R_IA64_FPTR64LSB:
2263 if (bfd_link_pic (info) || h)
2264 need_entry = NEED_FPTR | NEED_DYNREL;
2266 need_entry = NEED_FPTR;
2269 case R_IA64_LTOFF22:
2270 case R_IA64_LTOFF64I:
2271 need_entry = NEED_GOT;
2274 case R_IA64_LTOFF22X:
2275 need_entry = NEED_GOTX;
2278 case R_IA64_PLTOFF22:
2279 case R_IA64_PLTOFF64I:
2280 case R_IA64_PLTOFF64MSB:
2281 case R_IA64_PLTOFF64LSB:
2282 need_entry = NEED_PLTOFF;
2286 need_entry |= NEED_MIN_PLT;
2290 (*info->callbacks->warning)
2291 (info, _("@pltoff reloc against local symbol"), 0,
2292 abfd, 0, (bfd_vma) 0);
2296 case R_IA64_PCREL21B:
2297 case R_IA64_PCREL60B:
2298 /* Depending on where this symbol is defined, we may or may not
2299 need a full plt entry. Only skip if we know we'll not need
2300 the entry -- static or symbolic, and the symbol definition
2301 has already been seen. */
2302 if (maybe_dynamic && rel->r_addend == 0)
2303 need_entry = NEED_FULL_PLT;
2309 case R_IA64_DIR32MSB:
2310 case R_IA64_DIR32LSB:
2311 case R_IA64_DIR64MSB:
2312 case R_IA64_DIR64LSB:
2313 /* Shared objects will always need at least a REL relocation. */
2314 if (bfd_link_pic (info) || maybe_dynamic)
2315 need_entry = NEED_DYNREL;
2318 case R_IA64_IPLTMSB:
2319 case R_IA64_IPLTLSB:
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_PCREL22:
2326 case R_IA64_PCREL64I:
2327 case R_IA64_PCREL32MSB:
2328 case R_IA64_PCREL32LSB:
2329 case R_IA64_PCREL64MSB:
2330 case R_IA64_PCREL64LSB:
2332 need_entry = NEED_DYNREL;
2339 if ((need_entry & NEED_FPTR) != 0
2342 (*info->callbacks->warning)
2343 (info, _("non-zero addend in @fptr reloc"), 0,
2344 abfd, 0, (bfd_vma) 0);
2347 if (get_dyn_sym_info (ia64_info, h, abfd, rel, TRUE) == NULL)
2351 /* Now, we only do lookup without insertion, which is very fast
2352 with the modified get_dyn_sym_info. */
2353 for (rel = relocs; rel < relend; ++rel)
2355 struct elfNN_ia64_dyn_sym_info *dyn_i;
2356 int dynrel_type = R_IA64_NONE;
2358 r_symndx = ELFNN_R_SYM (rel->r_info);
2359 if (r_symndx >= symtab_hdr->sh_info)
2361 /* We're dealing with a global symbol -- find its hash entry
2362 and mark it as being referenced. */
2363 long indx = r_symndx - symtab_hdr->sh_info;
2364 h = elf_sym_hashes (abfd)[indx];
2365 while (h->root.type == bfd_link_hash_indirect
2366 || h->root.type == bfd_link_hash_warning)
2367 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2369 /* PR15323, ref flags aren't set for references in the same
2376 if (h && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
2379 /* We can only get preliminary data on whether a symbol is
2380 locally or externally defined, as not all of the input files
2381 have yet been processed. Do something with what we know, as
2382 this may help reduce memory usage and processing time later. */
2383 maybe_dynamic = (h && ((!bfd_link_executable (info)
2384 && (!SYMBOLIC_BIND (info, h)
2385 || info->unresolved_syms_in_shared_libs == RM_IGNORE))
2387 || h->root.type == bfd_link_hash_defweak));
2390 switch (ELFNN_R_TYPE (rel->r_info))
2392 case R_IA64_TPREL64MSB:
2393 case R_IA64_TPREL64LSB:
2394 if (bfd_link_pic (info) || maybe_dynamic)
2395 need_entry = NEED_DYNREL;
2396 dynrel_type = R_IA64_TPREL64LSB;
2397 if (bfd_link_pic (info))
2398 info->flags |= DF_STATIC_TLS;
2401 case R_IA64_LTOFF_TPREL22:
2402 need_entry = NEED_TPREL;
2403 if (bfd_link_pic (info))
2404 info->flags |= DF_STATIC_TLS;
2407 case R_IA64_DTPREL32MSB:
2408 case R_IA64_DTPREL32LSB:
2409 case R_IA64_DTPREL64MSB:
2410 case R_IA64_DTPREL64LSB:
2411 if (bfd_link_pic (info) || maybe_dynamic)
2412 need_entry = NEED_DYNREL;
2413 dynrel_type = R_IA64_DTPRELNNLSB;
2416 case R_IA64_LTOFF_DTPREL22:
2417 need_entry = NEED_DTPREL;
2420 case R_IA64_DTPMOD64MSB:
2421 case R_IA64_DTPMOD64LSB:
2422 if (bfd_link_pic (info) || maybe_dynamic)
2423 need_entry = NEED_DYNREL;
2424 dynrel_type = R_IA64_DTPMOD64LSB;
2427 case R_IA64_LTOFF_DTPMOD22:
2428 need_entry = NEED_DTPMOD;
2431 case R_IA64_LTOFF_FPTR22:
2432 case R_IA64_LTOFF_FPTR64I:
2433 case R_IA64_LTOFF_FPTR32MSB:
2434 case R_IA64_LTOFF_FPTR32LSB:
2435 case R_IA64_LTOFF_FPTR64MSB:
2436 case R_IA64_LTOFF_FPTR64LSB:
2437 need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR;
2440 case R_IA64_FPTR64I:
2441 case R_IA64_FPTR32MSB:
2442 case R_IA64_FPTR32LSB:
2443 case R_IA64_FPTR64MSB:
2444 case R_IA64_FPTR64LSB:
2445 if (bfd_link_pic (info) || h)
2446 need_entry = NEED_FPTR | NEED_DYNREL;
2448 need_entry = NEED_FPTR;
2449 dynrel_type = R_IA64_FPTRNNLSB;
2452 case R_IA64_LTOFF22:
2453 case R_IA64_LTOFF64I:
2454 need_entry = NEED_GOT;
2457 case R_IA64_LTOFF22X:
2458 need_entry = NEED_GOTX;
2461 case R_IA64_PLTOFF22:
2462 case R_IA64_PLTOFF64I:
2463 case R_IA64_PLTOFF64MSB:
2464 case R_IA64_PLTOFF64LSB:
2465 need_entry = NEED_PLTOFF;
2469 need_entry |= NEED_MIN_PLT;
2473 case R_IA64_PCREL21B:
2474 case R_IA64_PCREL60B:
2475 /* Depending on where this symbol is defined, we may or may not
2476 need a full plt entry. Only skip if we know we'll not need
2477 the entry -- static or symbolic, and the symbol definition
2478 has already been seen. */
2479 if (maybe_dynamic && rel->r_addend == 0)
2480 need_entry = NEED_FULL_PLT;
2486 case R_IA64_DIR32MSB:
2487 case R_IA64_DIR32LSB:
2488 case R_IA64_DIR64MSB:
2489 case R_IA64_DIR64LSB:
2490 /* Shared objects will always need at least a REL relocation. */
2491 if (bfd_link_pic (info) || maybe_dynamic)
2492 need_entry = NEED_DYNREL;
2493 dynrel_type = R_IA64_DIRNNLSB;
2496 case R_IA64_IPLTMSB:
2497 case R_IA64_IPLTLSB:
2498 /* Shared objects will always need at least a REL relocation. */
2499 if (bfd_link_pic (info) || maybe_dynamic)
2500 need_entry = NEED_DYNREL;
2501 dynrel_type = R_IA64_IPLTLSB;
2504 case R_IA64_PCREL22:
2505 case R_IA64_PCREL64I:
2506 case R_IA64_PCREL32MSB:
2507 case R_IA64_PCREL32LSB:
2508 case R_IA64_PCREL64MSB:
2509 case R_IA64_PCREL64LSB:
2511 need_entry = NEED_DYNREL;
2512 dynrel_type = R_IA64_PCRELNNLSB;
2519 dyn_i = get_dyn_sym_info (ia64_info, h, abfd, rel, FALSE);
2521 /* Record whether or not this is a local symbol. */
2524 /* Create what's needed. */
2525 if (need_entry & (NEED_GOT | NEED_GOTX | NEED_TPREL
2526 | NEED_DTPMOD | NEED_DTPREL))
2530 got = get_got (abfd, info, ia64_info);
2534 if (need_entry & NEED_GOT)
2535 dyn_i->want_got = 1;
2536 if (need_entry & NEED_GOTX)
2537 dyn_i->want_gotx = 1;
2538 if (need_entry & NEED_TPREL)
2539 dyn_i->want_tprel = 1;
2540 if (need_entry & NEED_DTPMOD)
2541 dyn_i->want_dtpmod = 1;
2542 if (need_entry & NEED_DTPREL)
2543 dyn_i->want_dtprel = 1;
2545 if (need_entry & NEED_FPTR)
2549 fptr = get_fptr (abfd, info, ia64_info);
2554 /* FPTRs for shared libraries are allocated by the dynamic
2555 linker. Make sure this local symbol will appear in the
2556 dynamic symbol table. */
2557 if (!h && bfd_link_pic (info))
2559 if (! (bfd_elf_link_record_local_dynamic_symbol
2560 (info, abfd, (long) r_symndx)))
2564 dyn_i->want_fptr = 1;
2566 if (need_entry & NEED_LTOFF_FPTR)
2567 dyn_i->want_ltoff_fptr = 1;
2568 if (need_entry & (NEED_MIN_PLT | NEED_FULL_PLT))
2570 if (!ia64_info->root.dynobj)
2571 ia64_info->root.dynobj = abfd;
2573 dyn_i->want_plt = 1;
2575 if (need_entry & NEED_FULL_PLT)
2576 dyn_i->want_plt2 = 1;
2577 if (need_entry & NEED_PLTOFF)
2579 /* This is needed here, in case @pltoff is used in a non-shared
2583 pltoff = get_pltoff (abfd, info, ia64_info);
2588 dyn_i->want_pltoff = 1;
2590 if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC))
2594 srel = get_reloc_section (abfd, ia64_info, sec, TRUE);
2598 if (!count_dyn_reloc (abfd, dyn_i, srel, dynrel_type,
2599 (sec->flags & SEC_READONLY) != 0))
2607 /* For cleanliness, and potentially faster dynamic loading, allocate
2608 external GOT entries first. */
2611 allocate_global_data_got (struct elfNN_ia64_dyn_sym_info *dyn_i,
2614 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2616 if ((dyn_i->want_got || dyn_i->want_gotx)
2617 && ! dyn_i->want_fptr
2618 && elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
2620 dyn_i->got_offset = x->ofs;
2623 if (dyn_i->want_tprel)
2625 dyn_i->tprel_offset = x->ofs;
2628 if (dyn_i->want_dtpmod)
2630 if (elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
2632 dyn_i->dtpmod_offset = x->ofs;
2637 struct elfNN_ia64_link_hash_table *ia64_info;
2639 ia64_info = elfNN_ia64_hash_table (x->info);
2640 if (ia64_info == NULL)
2643 if (ia64_info->self_dtpmod_offset == (bfd_vma) -1)
2645 ia64_info->self_dtpmod_offset = x->ofs;
2648 dyn_i->dtpmod_offset = ia64_info->self_dtpmod_offset;
2651 if (dyn_i->want_dtprel)
2653 dyn_i->dtprel_offset = x->ofs;
2659 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
2662 allocate_global_fptr_got (struct elfNN_ia64_dyn_sym_info *dyn_i,
2665 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2669 && elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, R_IA64_FPTRNNLSB))
2671 dyn_i->got_offset = x->ofs;
2677 /* Lastly, allocate all the GOT entries for local data. */
2680 allocate_local_got (struct elfNN_ia64_dyn_sym_info *dyn_i,
2683 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2685 if ((dyn_i->want_got || dyn_i->want_gotx)
2686 && !elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
2688 dyn_i->got_offset = x->ofs;
2694 /* Search for the index of a global symbol in it's defining object file. */
2697 global_sym_index (struct elf_link_hash_entry *h)
2699 struct elf_link_hash_entry **p;
2702 BFD_ASSERT (h->root.type == bfd_link_hash_defined
2703 || h->root.type == bfd_link_hash_defweak);
2705 obj = h->root.u.def.section->owner;
2706 for (p = elf_sym_hashes (obj); *p != h; ++p)
2709 return p - elf_sym_hashes (obj) + elf_tdata (obj)->symtab_hdr.sh_info;
2712 /* Allocate function descriptors. We can do these for every function
2713 in a main executable that is not exported. */
2716 allocate_fptr (struct elfNN_ia64_dyn_sym_info *dyn_i, void * data)
2718 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2720 if (dyn_i->want_fptr)
2722 struct elf_link_hash_entry *h = dyn_i->h;
2725 while (h->root.type == bfd_link_hash_indirect
2726 || h->root.type == bfd_link_hash_warning)
2727 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2729 if (!bfd_link_executable (x->info)
2731 || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2732 && !UNDEFWEAK_NO_DYNAMIC_RELOC (x->info, h))
2733 || (h->root.type != bfd_link_hash_undefweak
2734 && h->root.type != bfd_link_hash_undefined)))
2736 if (h && h->dynindx == -1)
2738 BFD_ASSERT ((h->root.type == bfd_link_hash_defined)
2739 || (h->root.type == bfd_link_hash_defweak));
2741 if (!bfd_elf_link_record_local_dynamic_symbol
2742 (x->info, h->root.u.def.section->owner,
2743 global_sym_index (h)))
2747 dyn_i->want_fptr = 0;
2749 else if (h == NULL || h->dynindx == -1)
2751 dyn_i->fptr_offset = x->ofs;
2755 dyn_i->want_fptr = 0;
2760 /* Allocate all the minimal PLT entries. */
2763 allocate_plt_entries (struct elfNN_ia64_dyn_sym_info *dyn_i,
2766 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2768 if (dyn_i->want_plt)
2770 struct elf_link_hash_entry *h = dyn_i->h;
2773 while (h->root.type == bfd_link_hash_indirect
2774 || h->root.type == bfd_link_hash_warning)
2775 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2777 /* ??? Versioned symbols seem to lose NEEDS_PLT. */
2778 if (elfNN_ia64_dynamic_symbol_p (h, x->info, 0))
2780 bfd_size_type offset = x->ofs;
2782 offset = PLT_HEADER_SIZE;
2783 dyn_i->plt_offset = offset;
2784 x->ofs = offset + PLT_MIN_ENTRY_SIZE;
2786 dyn_i->want_pltoff = 1;
2790 dyn_i->want_plt = 0;
2791 dyn_i->want_plt2 = 0;
2797 /* Allocate all the full PLT entries. */
2800 allocate_plt2_entries (struct elfNN_ia64_dyn_sym_info *dyn_i,
2803 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2805 if (dyn_i->want_plt2)
2807 struct elf_link_hash_entry *h = dyn_i->h;
2808 bfd_size_type ofs = x->ofs;
2810 dyn_i->plt2_offset = ofs;
2811 x->ofs = ofs + PLT_FULL_ENTRY_SIZE;
2813 while (h->root.type == bfd_link_hash_indirect
2814 || h->root.type == bfd_link_hash_warning)
2815 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2816 dyn_i->h->plt.offset = ofs;
2821 /* Allocate all the PLTOFF entries requested by relocations and
2822 plt entries. We can't share space with allocated FPTR entries,
2823 because the latter are not necessarily addressable by the GP.
2824 ??? Relaxation might be able to determine that they are. */
2827 allocate_pltoff_entries (struct elfNN_ia64_dyn_sym_info *dyn_i,
2830 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2832 if (dyn_i->want_pltoff)
2834 dyn_i->pltoff_offset = x->ofs;
2840 /* Allocate dynamic relocations for those symbols that turned out
2844 allocate_dynrel_entries (struct elfNN_ia64_dyn_sym_info *dyn_i,
2847 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2848 struct elfNN_ia64_link_hash_table *ia64_info;
2849 struct elfNN_ia64_dyn_reloc_entry *rent;
2850 bfd_boolean dynamic_symbol, shared, resolved_zero;
2852 ia64_info = elfNN_ia64_hash_table (x->info);
2853 if (ia64_info == NULL)
2856 /* Note that this can't be used in relation to FPTR relocs below. */
2857 dynamic_symbol = elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0);
2859 shared = bfd_link_pic (x->info);
2860 resolved_zero = (dyn_i->h
2861 && UNDEFWEAK_NO_DYNAMIC_RELOC (x->info,
2864 /* Take care of the GOT and PLT relocations. */
2867 && (dynamic_symbol || shared)
2868 && (dyn_i->want_got || dyn_i->want_gotx))
2869 || (dyn_i->want_ltoff_fptr
2871 && dyn_i->h->dynindx != -1))
2873 if (!dyn_i->want_ltoff_fptr
2874 || !bfd_link_pie (x->info)
2876 || dyn_i->h->root.type != bfd_link_hash_undefweak)
2877 ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela);
2879 if ((dynamic_symbol || shared) && dyn_i->want_tprel)
2880 ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela);
2881 if (dynamic_symbol && dyn_i->want_dtpmod)
2882 ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela);
2883 if (dynamic_symbol && dyn_i->want_dtprel)
2884 ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela);
2889 if (ia64_info->rel_fptr_sec && dyn_i->want_fptr)
2891 if (dyn_i->h == NULL || dyn_i->h->root.type != bfd_link_hash_undefweak)
2892 ia64_info->rel_fptr_sec->size += sizeof (ElfNN_External_Rela);
2895 if (!resolved_zero && dyn_i->want_pltoff)
2897 bfd_size_type t = 0;
2899 /* Dynamic symbols get one IPLT relocation. Local symbols in
2900 shared libraries get two REL relocations. Local symbols in
2901 main applications get nothing. */
2903 t = sizeof (ElfNN_External_Rela);
2905 t = 2 * sizeof (ElfNN_External_Rela);
2907 ia64_info->rel_pltoff_sec->size += t;
2910 /* Take care of the normal data relocations. */
2912 for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
2914 int count = rent->count;
2918 case R_IA64_FPTR32LSB:
2919 case R_IA64_FPTR64LSB:
2920 /* Allocate one iff !want_fptr and not PIE, which by this point
2921 will be true only if we're actually allocating one statically
2922 in the main executable. Position independent executables
2923 need a relative reloc. */
2924 if (dyn_i->want_fptr && !bfd_link_pie (x->info))
2927 case R_IA64_PCREL32LSB:
2928 case R_IA64_PCREL64LSB:
2929 if (!dynamic_symbol)
2932 case R_IA64_DIR32LSB:
2933 case R_IA64_DIR64LSB:
2934 if (!dynamic_symbol && !shared)
2937 case R_IA64_IPLTLSB:
2938 if (!dynamic_symbol && !shared)
2940 /* Use two REL relocations for IPLT relocations
2941 against local symbols. */
2942 if (!dynamic_symbol)
2945 case R_IA64_DTPREL32LSB:
2946 case R_IA64_TPREL64LSB:
2947 case R_IA64_DTPREL64LSB:
2948 case R_IA64_DTPMOD64LSB:
2954 ia64_info->reltext = 1;
2955 rent->srel->size += sizeof (ElfNN_External_Rela) * count;
2962 elfNN_ia64_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
2963 struct elf_link_hash_entry *h)
2965 /* ??? Undefined symbols with PLT entries should be re-defined
2966 to be the PLT entry. */
2968 /* If this is a weak symbol, and there is a real definition, the
2969 processor independent code will have arranged for us to see the
2970 real definition first, and we can just use the same value. */
2971 if (h->is_weakalias)
2973 struct elf_link_hash_entry *def = weakdef (h);
2974 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
2975 h->root.u.def.section = def->root.u.def.section;
2976 h->root.u.def.value = def->root.u.def.value;
2980 /* If this is a reference to a symbol defined by a dynamic object which
2981 is not a function, we might allocate the symbol in our .dynbss section
2982 and allocate a COPY dynamic relocation.
2984 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2991 elfNN_ia64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2992 struct bfd_link_info *info)
2994 struct elfNN_ia64_allocate_data data;
2995 struct elfNN_ia64_link_hash_table *ia64_info;
2998 bfd_boolean relplt = FALSE;
3000 ia64_info = elfNN_ia64_hash_table (info);
3001 if (ia64_info == NULL)
3003 dynobj = ia64_info->root.dynobj;
3004 ia64_info->self_dtpmod_offset = (bfd_vma) -1;
3005 BFD_ASSERT(dynobj != NULL);
3008 /* Set the contents of the .interp section to the interpreter. */
3009 if (ia64_info->root.dynamic_sections_created
3010 && bfd_link_executable (info) && !info->nointerp)
3012 sec = bfd_get_linker_section (dynobj, ".interp");
3013 BFD_ASSERT (sec != NULL);
3014 sec->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
3015 sec->size = strlen (ELF_DYNAMIC_INTERPRETER) + 1;
3018 /* Allocate the GOT entries. */
3020 if (ia64_info->root.sgot)
3023 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data);
3024 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data);
3025 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data);
3026 ia64_info->root.sgot->size = data.ofs;
3029 /* Allocate the FPTR entries. */
3031 if (ia64_info->fptr_sec)
3034 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_fptr, &data);
3035 ia64_info->fptr_sec->size = data.ofs;
3038 /* Now that we've seen all of the input files, we can decide which
3039 symbols need plt entries. Allocate the minimal PLT entries first.
3040 We do this even though dynamic_sections_created may be FALSE, because
3041 this has the side-effect of clearing want_plt and want_plt2. */
3044 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_plt_entries, &data);
3046 ia64_info->minplt_entries = 0;
3049 ia64_info->minplt_entries
3050 = (data.ofs - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
3053 /* Align the pointer for the plt2 entries. */
3054 data.ofs = (data.ofs + 31) & (bfd_vma) -32;
3056 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_plt2_entries, &data);
3057 if (data.ofs != 0 || ia64_info->root.dynamic_sections_created)
3059 /* FIXME: we always reserve the memory for dynamic linker even if
3060 there are no PLT entries since dynamic linker may assume the
3061 reserved memory always exists. */
3063 BFD_ASSERT (ia64_info->root.dynamic_sections_created);
3065 ia64_info->root.splt->size = data.ofs;
3067 /* If we've got a .plt, we need some extra memory for the dynamic
3068 linker. We stuff these in .got.plt. */
3069 ia64_info->root.sgotplt->size = 8 * PLT_RESERVED_WORDS;
3072 /* Allocate the PLTOFF entries. */
3074 if (ia64_info->pltoff_sec)
3077 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_pltoff_entries, &data);
3078 ia64_info->pltoff_sec->size = data.ofs;
3081 if (ia64_info->root.dynamic_sections_created)
3083 /* Allocate space for the dynamic relocations that turned out to be
3086 if (bfd_link_pic (info) && ia64_info->self_dtpmod_offset != (bfd_vma) -1)
3087 ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela);
3088 data.only_got = FALSE;
3089 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries, &data);
3092 /* We have now determined the sizes of the various dynamic sections.
3093 Allocate memory for them. */
3094 for (sec = dynobj->sections; sec != NULL; sec = sec->next)
3098 if (!(sec->flags & SEC_LINKER_CREATED))
3101 /* If we don't need this section, strip it from the output file.
3102 There were several sections primarily related to dynamic
3103 linking that must be create before the linker maps input
3104 sections to output sections. The linker does that before
3105 bfd_elf_size_dynamic_sections is called, and it is that
3106 function which decides whether anything needs to go into
3109 strip = (sec->size == 0);
3111 if (sec == ia64_info->root.sgot)
3113 else if (sec == ia64_info->root.srelgot)
3116 ia64_info->root.srelgot = NULL;
3118 /* We use the reloc_count field as a counter if we need to
3119 copy relocs into the output file. */
3120 sec->reloc_count = 0;
3122 else if (sec == ia64_info->fptr_sec)
3125 ia64_info->fptr_sec = NULL;
3127 else if (sec == ia64_info->rel_fptr_sec)
3130 ia64_info->rel_fptr_sec = NULL;
3132 /* We use the reloc_count field as a counter if we need to
3133 copy relocs into the output file. */
3134 sec->reloc_count = 0;
3136 else if (sec == ia64_info->root.splt)
3139 ia64_info->root.splt = NULL;
3141 else if (sec == ia64_info->pltoff_sec)
3144 ia64_info->pltoff_sec = NULL;
3146 else if (sec == ia64_info->rel_pltoff_sec)
3149 ia64_info->rel_pltoff_sec = NULL;
3153 /* We use the reloc_count field as a counter if we need to
3154 copy relocs into the output file. */
3155 sec->reloc_count = 0;
3162 /* It's OK to base decisions on the section name, because none
3163 of the dynobj section names depend upon the input files. */
3164 name = bfd_get_section_name (dynobj, sec);
3166 if (strcmp (name, ".got.plt") == 0)
3168 else if (CONST_STRNEQ (name, ".rel"))
3172 /* We use the reloc_count field as a counter if we need to
3173 copy relocs into the output file. */
3174 sec->reloc_count = 0;
3182 sec->flags |= SEC_EXCLUDE;
3185 /* Allocate memory for the section contents. */
3186 sec->contents = (bfd_byte *) bfd_zalloc (dynobj, sec->size);
3187 if (sec->contents == NULL && sec->size != 0)
3192 if (ia64_info->root.dynamic_sections_created)
3194 /* Add some entries to the .dynamic section. We fill in the values
3195 later (in finish_dynamic_sections) but we must add the entries now
3196 so that we get the correct size for the .dynamic section. */
3198 if (bfd_link_executable (info))
3200 /* The DT_DEBUG entry is filled in by the dynamic linker and used
3202 #define add_dynamic_entry(TAG, VAL) \
3203 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3205 if (!add_dynamic_entry (DT_DEBUG, 0))
3209 if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE, 0))
3211 if (!add_dynamic_entry (DT_PLTGOT, 0))
3216 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3217 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3218 || !add_dynamic_entry (DT_JMPREL, 0))
3222 if (!add_dynamic_entry (DT_RELA, 0)
3223 || !add_dynamic_entry (DT_RELASZ, 0)
3224 || !add_dynamic_entry (DT_RELAENT, sizeof (ElfNN_External_Rela)))
3227 if (ia64_info->reltext)
3229 if (!add_dynamic_entry (DT_TEXTREL, 0))
3231 info->flags |= DF_TEXTREL;
3235 /* ??? Perhaps force __gp local. */
3241 elfNN_ia64_install_dyn_reloc (bfd *abfd, struct bfd_link_info *info,
3242 asection *sec, asection *srel,
3243 bfd_vma offset, unsigned int type,
3244 long dynindx, bfd_vma addend)
3246 Elf_Internal_Rela outrel;
3249 BFD_ASSERT (dynindx != -1);
3250 outrel.r_info = ELFNN_R_INFO (dynindx, type);
3251 outrel.r_addend = addend;
3252 outrel.r_offset = _bfd_elf_section_offset (abfd, info, sec, offset);
3253 if (outrel.r_offset >= (bfd_vma) -2)
3255 /* Run for the hills. We shouldn't be outputting a relocation
3256 for this. So do what everyone else does and output a no-op. */
3257 outrel.r_info = ELFNN_R_INFO (0, R_IA64_NONE);
3258 outrel.r_addend = 0;
3259 outrel.r_offset = 0;
3262 outrel.r_offset += sec->output_section->vma + sec->output_offset;
3264 loc = srel->contents;
3265 loc += srel->reloc_count++ * sizeof (ElfNN_External_Rela);
3266 bfd_elfNN_swap_reloca_out (abfd, &outrel, loc);
3267 BFD_ASSERT (sizeof (ElfNN_External_Rela) * srel->reloc_count <= srel->size);
3270 /* Store an entry for target address TARGET_ADDR in the linkage table
3271 and return the gp-relative address of the linkage table entry. */
3274 set_got_entry (bfd *abfd, struct bfd_link_info *info,
3275 struct elfNN_ia64_dyn_sym_info *dyn_i,
3276 long dynindx, bfd_vma addend, bfd_vma value,
3277 unsigned int dyn_r_type)
3279 struct elfNN_ia64_link_hash_table *ia64_info;
3284 ia64_info = elfNN_ia64_hash_table (info);
3285 if (ia64_info == NULL)
3288 got_sec = ia64_info->root.sgot;
3292 case R_IA64_TPREL64LSB:
3293 done = dyn_i->tprel_done;
3294 dyn_i->tprel_done = TRUE;
3295 got_offset = dyn_i->tprel_offset;
3297 case R_IA64_DTPMOD64LSB:
3298 if (dyn_i->dtpmod_offset != ia64_info->self_dtpmod_offset)
3300 done = dyn_i->dtpmod_done;
3301 dyn_i->dtpmod_done = TRUE;
3305 done = ia64_info->self_dtpmod_done;
3306 ia64_info->self_dtpmod_done = TRUE;
3309 got_offset = dyn_i->dtpmod_offset;
3311 case R_IA64_DTPREL32LSB:
3312 case R_IA64_DTPREL64LSB:
3313 done = dyn_i->dtprel_done;
3314 dyn_i->dtprel_done = TRUE;
3315 got_offset = dyn_i->dtprel_offset;
3318 done = dyn_i->got_done;
3319 dyn_i->got_done = TRUE;
3320 got_offset = dyn_i->got_offset;
3324 BFD_ASSERT ((got_offset & 7) == 0);
3328 /* Store the target address in the linkage table entry. */
3329 bfd_put_64 (abfd, value, got_sec->contents + got_offset);
3331 /* Install a dynamic relocation if needed. */
3332 if (((bfd_link_pic (info)
3334 || (ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
3335 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, dyn_i->h))
3336 || dyn_i->h->root.type != bfd_link_hash_undefweak)
3337 && dyn_r_type != R_IA64_DTPREL32LSB
3338 && dyn_r_type != R_IA64_DTPREL64LSB)
3339 || elfNN_ia64_dynamic_symbol_p (dyn_i->h, info, dyn_r_type)
3341 && (dyn_r_type == R_IA64_FPTR32LSB
3342 || dyn_r_type == R_IA64_FPTR64LSB)))
3343 && (!dyn_i->want_ltoff_fptr
3344 || !bfd_link_pie (info)
3346 || dyn_i->h->root.type != bfd_link_hash_undefweak))
3349 && dyn_r_type != R_IA64_TPREL64LSB
3350 && dyn_r_type != R_IA64_DTPMOD64LSB
3351 && dyn_r_type != R_IA64_DTPREL32LSB
3352 && dyn_r_type != R_IA64_DTPREL64LSB)
3354 dyn_r_type = R_IA64_RELNNLSB;
3359 if (bfd_big_endian (abfd))
3363 case R_IA64_REL32LSB:
3364 dyn_r_type = R_IA64_REL32MSB;
3366 case R_IA64_DIR32LSB:
3367 dyn_r_type = R_IA64_DIR32MSB;
3369 case R_IA64_FPTR32LSB:
3370 dyn_r_type = R_IA64_FPTR32MSB;
3372 case R_IA64_DTPREL32LSB:
3373 dyn_r_type = R_IA64_DTPREL32MSB;
3375 case R_IA64_REL64LSB:
3376 dyn_r_type = R_IA64_REL64MSB;
3378 case R_IA64_DIR64LSB:
3379 dyn_r_type = R_IA64_DIR64MSB;
3381 case R_IA64_FPTR64LSB:
3382 dyn_r_type = R_IA64_FPTR64MSB;
3384 case R_IA64_TPREL64LSB:
3385 dyn_r_type = R_IA64_TPREL64MSB;
3387 case R_IA64_DTPMOD64LSB:
3388 dyn_r_type = R_IA64_DTPMOD64MSB;
3390 case R_IA64_DTPREL64LSB:
3391 dyn_r_type = R_IA64_DTPREL64MSB;
3399 elfNN_ia64_install_dyn_reloc (abfd, NULL, got_sec,
3400 ia64_info->root.srelgot,
3401 got_offset, dyn_r_type,
3406 /* Return the address of the linkage table entry. */
3407 value = (got_sec->output_section->vma
3408 + got_sec->output_offset
3414 /* Fill in a function descriptor consisting of the function's code
3415 address and its global pointer. Return the descriptor's address. */
3418 set_fptr_entry (bfd *abfd, struct bfd_link_info *info,
3419 struct elfNN_ia64_dyn_sym_info *dyn_i,
3422 struct elfNN_ia64_link_hash_table *ia64_info;
3425 ia64_info = elfNN_ia64_hash_table (info);
3426 if (ia64_info == NULL)
3429 fptr_sec = ia64_info->fptr_sec;
3431 if (!dyn_i->fptr_done)
3433 dyn_i->fptr_done = 1;
3435 /* Fill in the function descriptor. */
3436 bfd_put_64 (abfd, value, fptr_sec->contents + dyn_i->fptr_offset);
3437 bfd_put_64 (abfd, _bfd_get_gp_value (abfd),
3438 fptr_sec->contents + dyn_i->fptr_offset + 8);
3439 if (ia64_info->rel_fptr_sec)
3441 Elf_Internal_Rela outrel;
3444 if (bfd_little_endian (abfd))
3445 outrel.r_info = ELFNN_R_INFO (0, R_IA64_IPLTLSB);
3447 outrel.r_info = ELFNN_R_INFO (0, R_IA64_IPLTMSB);
3448 outrel.r_addend = value;
3449 outrel.r_offset = (fptr_sec->output_section->vma
3450 + fptr_sec->output_offset
3451 + dyn_i->fptr_offset);
3452 loc = ia64_info->rel_fptr_sec->contents;
3453 loc += ia64_info->rel_fptr_sec->reloc_count++
3454 * sizeof (ElfNN_External_Rela);
3455 bfd_elfNN_swap_reloca_out (abfd, &outrel, loc);
3459 /* Return the descriptor's address. */
3460 value = (fptr_sec->output_section->vma
3461 + fptr_sec->output_offset
3462 + dyn_i->fptr_offset);
3467 /* Fill in a PLTOFF entry consisting of the function's code address
3468 and its global pointer. Return the descriptor's address. */
3471 set_pltoff_entry (bfd *abfd, struct bfd_link_info *info,
3472 struct elfNN_ia64_dyn_sym_info *dyn_i,
3473 bfd_vma value, bfd_boolean is_plt)
3475 struct elfNN_ia64_link_hash_table *ia64_info;
3476 asection *pltoff_sec;
3478 ia64_info = elfNN_ia64_hash_table (info);
3479 if (ia64_info == NULL)
3482 pltoff_sec = ia64_info->pltoff_sec;
3484 /* Don't do anything if this symbol uses a real PLT entry. In
3485 that case, we'll fill this in during finish_dynamic_symbol. */
3486 if ((! dyn_i->want_plt || is_plt)
3487 && !dyn_i->pltoff_done)
3489 bfd_vma gp = _bfd_get_gp_value (abfd);
3491 /* Fill in the function descriptor. */
3492 bfd_put_64 (abfd, value, pltoff_sec->contents + dyn_i->pltoff_offset);
3493 bfd_put_64 (abfd, gp, pltoff_sec->contents + dyn_i->pltoff_offset + 8);
3495 /* Install dynamic relocations if needed. */
3497 && bfd_link_pic (info)
3499 || (ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
3500 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, dyn_i->h))
3501 || dyn_i->h->root.type != bfd_link_hash_undefweak))
3503 unsigned int dyn_r_type;
3505 if (bfd_big_endian (abfd))
3506 dyn_r_type = R_IA64_RELNNMSB;
3508 dyn_r_type = R_IA64_RELNNLSB;
3510 elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
3511 ia64_info->rel_pltoff_sec,
3512 dyn_i->pltoff_offset,
3513 dyn_r_type, 0, value);
3514 elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
3515 ia64_info->rel_pltoff_sec,
3516 dyn_i->pltoff_offset + ARCH_SIZE / 8,
3520 dyn_i->pltoff_done = 1;
3523 /* Return the descriptor's address. */
3524 value = (pltoff_sec->output_section->vma
3525 + pltoff_sec->output_offset
3526 + dyn_i->pltoff_offset);
3531 /* Return the base VMA address which should be subtracted from real addresses
3532 when resolving @tprel() relocation.
3533 Main program TLS (whose template starts at PT_TLS p_vaddr)
3534 is assigned offset round(2 * size of pointer, PT_TLS p_align). */
3537 elfNN_ia64_tprel_base (struct bfd_link_info *info)
3539 asection *tls_sec = elf_hash_table (info)->tls_sec;
3540 return tls_sec->vma - align_power ((bfd_vma) ARCH_SIZE / 4,
3541 tls_sec->alignment_power);
3544 /* Return the base VMA address which should be subtracted from real addresses
3545 when resolving @dtprel() relocation.
3546 This is PT_TLS segment p_vaddr. */
3549 elfNN_ia64_dtprel_base (struct bfd_link_info *info)
3551 return elf_hash_table (info)->tls_sec->vma;
3554 /* Called through qsort to sort the .IA_64.unwind section during a
3555 non-relocatable link. Set elfNN_ia64_unwind_entry_compare_bfd
3556 to the output bfd so we can do proper endianness frobbing. */
3558 static bfd *elfNN_ia64_unwind_entry_compare_bfd;
3561 elfNN_ia64_unwind_entry_compare (const void * a, const void * b)
3565 av = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, a);
3566 bv = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, b);
3568 return (av < bv ? -1 : av > bv ? 1 : 0);
3571 /* Make sure we've got ourselves a nice fat __gp value. */
3573 elfNN_ia64_choose_gp (bfd *abfd, struct bfd_link_info *info, bfd_boolean final)
3575 bfd_vma min_vma = (bfd_vma) -1, max_vma = 0;
3576 bfd_vma min_short_vma = min_vma, max_short_vma = 0;
3577 struct elf_link_hash_entry *gp;
3580 struct elfNN_ia64_link_hash_table *ia64_info;
3582 ia64_info = elfNN_ia64_hash_table (info);
3583 if (ia64_info == NULL)
3586 /* Find the min and max vma of all sections marked short. Also collect
3587 min and max vma of any type, for use in selecting a nice gp. */
3588 for (os = abfd->sections; os ; os = os->next)
3592 if ((os->flags & SEC_ALLOC) == 0)
3596 /* When this function is called from elfNN_ia64_final_link
3597 the correct value to use is os->size. When called from
3598 elfNN_ia64_relax_section we are in the middle of section
3599 sizing; some sections will already have os->size set, others
3600 will have os->size zero and os->rawsize the previous size. */
3601 hi = os->vma + (!final && os->rawsize ? os->rawsize : os->size);
3609 if (os->flags & SEC_SMALL_DATA)
3611 if (min_short_vma > lo)
3613 if (max_short_vma < hi)
3618 if (ia64_info->min_short_sec)
3621 > (ia64_info->min_short_sec->vma
3622 + ia64_info->min_short_offset))
3623 min_short_vma = (ia64_info->min_short_sec->vma
3624 + ia64_info->min_short_offset);
3626 < (ia64_info->max_short_sec->vma
3627 + ia64_info->max_short_offset))
3628 max_short_vma = (ia64_info->max_short_sec->vma
3629 + ia64_info->max_short_offset);
3632 /* See if the user wants to force a value. */
3633 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
3637 && (gp->root.type == bfd_link_hash_defined
3638 || gp->root.type == bfd_link_hash_defweak))
3640 asection *gp_sec = gp->root.u.def.section;
3641 gp_val = (gp->root.u.def.value
3642 + gp_sec->output_section->vma
3643 + gp_sec->output_offset);
3647 /* Pick a sensible value. */
3649 if (ia64_info->min_short_sec)
3651 bfd_vma short_range = max_short_vma - min_short_vma;
3653 /* If min_short_sec is set, pick one in the middle bewteen
3654 min_short_vma and max_short_vma. */
3655 if (short_range >= 0x400000)
3657 gp_val = min_short_vma + short_range / 2;
3661 asection *got_sec = ia64_info->root.sgot;
3663 /* Start with just the address of the .got. */
3665 gp_val = got_sec->output_section->vma;
3666 else if (max_short_vma != 0)
3667 gp_val = min_short_vma;
3668 else if (max_vma - min_vma < 0x200000)
3671 gp_val = max_vma - 0x200000 + 8;
3674 /* If it is possible to address the entire image, but we
3675 don't with the choice above, adjust. */
3676 if (max_vma - min_vma < 0x400000
3677 && (max_vma - gp_val >= 0x200000
3678 || gp_val - min_vma > 0x200000))
3679 gp_val = min_vma + 0x200000;
3680 else if (max_short_vma != 0)
3682 /* If we don't cover all the short data, adjust. */
3683 if (max_short_vma - gp_val >= 0x200000)
3684 gp_val = min_short_vma + 0x200000;
3686 /* If we're addressing stuff past the end, adjust back. */
3687 if (gp_val > max_vma)
3688 gp_val = max_vma - 0x200000 + 8;
3692 /* Validate whether all SHF_IA_64_SHORT sections are within
3693 range of the chosen GP. */
3695 if (max_short_vma != 0)
3697 if (max_short_vma - min_short_vma >= 0x400000)
3701 /* xgettext:c-format */
3702 (_("%pB: short data segment overflowed (%#" PRIx64 " >= 0x400000)"),
3703 abfd, (uint64_t) (max_short_vma - min_short_vma));
3706 else if ((gp_val > min_short_vma
3707 && gp_val - min_short_vma > 0x200000)
3708 || (gp_val < max_short_vma
3709 && max_short_vma - gp_val >= 0x200000))
3712 (_("%pB: __gp does not cover short data segment"), abfd);
3717 _bfd_set_gp_value (abfd, gp_val);
3723 elfNN_ia64_final_link (bfd *abfd, struct bfd_link_info *info)
3725 struct elfNN_ia64_link_hash_table *ia64_info;
3726 asection *unwind_output_sec;
3728 ia64_info = elfNN_ia64_hash_table (info);
3729 if (ia64_info == NULL)
3732 /* Make sure we've got ourselves a nice fat __gp value. */
3733 if (!bfd_link_relocatable (info))
3736 struct elf_link_hash_entry *gp;
3738 /* We assume after gp is set, section size will only decrease. We
3739 need to adjust gp for it. */
3740 _bfd_set_gp_value (abfd, 0);
3741 if (! elfNN_ia64_choose_gp (abfd, info, TRUE))
3743 gp_val = _bfd_get_gp_value (abfd);
3745 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
3749 gp->root.type = bfd_link_hash_defined;
3750 gp->root.u.def.value = gp_val;
3751 gp->root.u.def.section = bfd_abs_section_ptr;
3755 /* If we're producing a final executable, we need to sort the contents
3756 of the .IA_64.unwind section. Force this section to be relocated
3757 into memory rather than written immediately to the output file. */
3758 unwind_output_sec = NULL;
3759 if (!bfd_link_relocatable (info))
3761 asection *s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind);
3764 unwind_output_sec = s->output_section;
3765 unwind_output_sec->contents
3766 = bfd_malloc (unwind_output_sec->size);
3767 if (unwind_output_sec->contents == NULL)
3772 /* Invoke the regular ELF backend linker to do all the work. */
3773 if (!bfd_elf_final_link (abfd, info))
3776 if (unwind_output_sec)
3778 elfNN_ia64_unwind_entry_compare_bfd = abfd;
3779 qsort (unwind_output_sec->contents,
3780 (size_t) (unwind_output_sec->size / 24),
3782 elfNN_ia64_unwind_entry_compare);
3784 if (! bfd_set_section_contents (abfd, unwind_output_sec,
3785 unwind_output_sec->contents, (bfd_vma) 0,
3786 unwind_output_sec->size))
3794 elfNN_ia64_relocate_section (bfd *output_bfd,
3795 struct bfd_link_info *info,
3797 asection *input_section,
3799 Elf_Internal_Rela *relocs,
3800 Elf_Internal_Sym *local_syms,
3801 asection **local_sections)
3803 struct elfNN_ia64_link_hash_table *ia64_info;
3804 Elf_Internal_Shdr *symtab_hdr;
3805 Elf_Internal_Rela *rel;
3806 Elf_Internal_Rela *relend;
3808 bfd_boolean ret_val = TRUE; /* for non-fatal errors */
3811 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3812 ia64_info = elfNN_ia64_hash_table (info);
3813 if (ia64_info == NULL)
3816 /* Infect various flags from the input section to the output section. */
3817 if (bfd_link_relocatable (info))
3821 flags = elf_section_data(input_section)->this_hdr.sh_flags;
3822 flags &= SHF_IA_64_NORECOV;
3824 elf_section_data(input_section->output_section)
3825 ->this_hdr.sh_flags |= flags;
3828 gp_val = _bfd_get_gp_value (output_bfd);
3829 srel = get_reloc_section (input_bfd, ia64_info, input_section, FALSE);
3832 relend = relocs + input_section->reloc_count;
3833 for (; rel < relend; ++rel)
3835 struct elf_link_hash_entry *h;
3836 struct elfNN_ia64_dyn_sym_info *dyn_i;
3837 bfd_reloc_status_type r;
3838 reloc_howto_type *howto;
3839 unsigned long r_symndx;
3840 Elf_Internal_Sym *sym;
3841 unsigned int r_type;
3845 bfd_boolean dynamic_symbol_p;
3846 bfd_boolean undef_weak_ref;
3848 r_type = ELFNN_R_TYPE (rel->r_info);
3849 if (r_type > R_IA64_MAX_RELOC_CODE)
3851 /* xgettext:c-format */
3852 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
3853 input_bfd, (int) r_type);
3854 bfd_set_error (bfd_error_bad_value);
3859 howto = ia64_elf_lookup_howto (r_type);
3860 r_symndx = ELFNN_R_SYM (rel->r_info);
3864 undef_weak_ref = FALSE;
3866 if (r_symndx < symtab_hdr->sh_info)
3868 /* Reloc against local symbol. */
3870 sym = local_syms + r_symndx;
3871 sym_sec = local_sections[r_symndx];
3873 value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
3874 if (!bfd_link_relocatable (info)
3875 && (sym_sec->flags & SEC_MERGE) != 0
3876 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
3877 && sym_sec->sec_info_type == SEC_INFO_TYPE_MERGE)
3879 struct elfNN_ia64_local_hash_entry *loc_h;
3881 loc_h = get_local_sym_hash (ia64_info, input_bfd, rel, FALSE);
3882 if (loc_h && ! loc_h->sec_merge_done)
3884 struct elfNN_ia64_dyn_sym_info *dynent;
3887 for (count = loc_h->count, dynent = loc_h->info;
3893 _bfd_merged_section_offset (output_bfd, &msec,
3894 elf_section_data (msec)->
3898 dynent->addend -= sym->st_value;
3899 dynent->addend += msec->output_section->vma
3900 + msec->output_offset
3901 - sym_sec->output_section->vma
3902 - sym_sec->output_offset;
3905 /* We may have introduced duplicated entries. We need
3906 to remove them properly. */
3907 count = sort_dyn_sym_info (loc_h->info, loc_h->count);
3908 if (count != loc_h->count)
3910 loc_h->count = count;
3911 loc_h->sorted_count = count;
3914 loc_h->sec_merge_done = 1;
3920 bfd_boolean unresolved_reloc;
3921 bfd_boolean warned, ignored;
3922 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
3924 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3925 r_symndx, symtab_hdr, sym_hashes,
3927 unresolved_reloc, warned, ignored);
3929 if (h->root.type == bfd_link_hash_undefweak)
3930 undef_weak_ref = TRUE;
3931 else if (warned || (ignored && bfd_link_executable (info)))
3935 if (sym_sec != NULL && discarded_section (sym_sec))
3936 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3937 rel, 1, relend, howto, 0, contents);
3939 if (bfd_link_relocatable (info))
3942 hit_addr = contents + rel->r_offset;
3943 value += rel->r_addend;
3944 dynamic_symbol_p = elfNN_ia64_dynamic_symbol_p (h, info, r_type);
3955 case R_IA64_DIR32MSB:
3956 case R_IA64_DIR32LSB:
3957 case R_IA64_DIR64MSB:
3958 case R_IA64_DIR64LSB:
3959 /* Install a dynamic relocation for this reloc. */
3960 if ((dynamic_symbol_p || bfd_link_pic (info))
3961 && !(h && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
3962 && r_symndx != STN_UNDEF
3963 && (input_section->flags & SEC_ALLOC) != 0)
3965 unsigned int dyn_r_type;
3969 BFD_ASSERT (srel != NULL);
3976 /* ??? People shouldn't be doing non-pic code in
3977 shared libraries nor dynamic executables. */
3979 /* xgettext:c-format */
3980 (_("%pB: non-pic code with imm relocation against dynamic symbol `%s'"),
3982 h ? h->root.root.string
3983 : bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3992 /* If we don't need dynamic symbol lookup, find a
3993 matching RELATIVE relocation. */
3994 dyn_r_type = r_type;
3995 if (dynamic_symbol_p)
3997 dynindx = h->dynindx;
3998 addend = rel->r_addend;
4005 case R_IA64_DIR32MSB:
4006 dyn_r_type = R_IA64_REL32MSB;
4008 case R_IA64_DIR32LSB:
4009 dyn_r_type = R_IA64_REL32LSB;
4011 case R_IA64_DIR64MSB:
4012 dyn_r_type = R_IA64_REL64MSB;
4014 case R_IA64_DIR64LSB:
4015 dyn_r_type = R_IA64_REL64LSB;
4025 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4026 srel, rel->r_offset, dyn_r_type,
4031 case R_IA64_LTV32MSB:
4032 case R_IA64_LTV32LSB:
4033 case R_IA64_LTV64MSB:
4034 case R_IA64_LTV64LSB:
4035 r = ia64_elf_install_value (hit_addr, value, r_type);
4038 case R_IA64_GPREL22:
4039 case R_IA64_GPREL64I:
4040 case R_IA64_GPREL32MSB:
4041 case R_IA64_GPREL32LSB:
4042 case R_IA64_GPREL64MSB:
4043 case R_IA64_GPREL64LSB:
4044 if (dynamic_symbol_p)
4047 /* xgettext:c-format */
4048 (_("%pB: @gprel relocation against dynamic symbol %s"),
4050 h ? h->root.root.string
4051 : bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4057 r = ia64_elf_install_value (hit_addr, value, r_type);
4060 case R_IA64_LTOFF22:
4061 case R_IA64_LTOFF22X:
4062 case R_IA64_LTOFF64I:
4063 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4064 value = set_got_entry (input_bfd, info, dyn_i, (h ? h->dynindx : -1),
4065 rel->r_addend, value, R_IA64_DIRNNLSB);
4067 r = ia64_elf_install_value (hit_addr, value, r_type);
4070 case R_IA64_PLTOFF22:
4071 case R_IA64_PLTOFF64I:
4072 case R_IA64_PLTOFF64MSB:
4073 case R_IA64_PLTOFF64LSB:
4074 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4075 value = set_pltoff_entry (output_bfd, info, dyn_i, value, FALSE);
4077 r = ia64_elf_install_value (hit_addr, value, r_type);
4080 case R_IA64_FPTR64I:
4081 case R_IA64_FPTR32MSB:
4082 case R_IA64_FPTR32LSB:
4083 case R_IA64_FPTR64MSB:
4084 case R_IA64_FPTR64LSB:
4085 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4086 if (dyn_i->want_fptr)
4088 if (!undef_weak_ref)
4089 value = set_fptr_entry (output_bfd, info, dyn_i, value);
4091 if (!dyn_i->want_fptr || bfd_link_pie (info))
4094 unsigned int dyn_r_type = r_type;
4095 bfd_vma addend = rel->r_addend;
4097 /* Otherwise, we expect the dynamic linker to create
4100 if (dyn_i->want_fptr)
4102 if (r_type == R_IA64_FPTR64I)
4104 /* We can't represent this without a dynamic symbol.
4105 Adjust the relocation to be against an output
4106 section symbol, which are always present in the
4107 dynamic symbol table. */
4108 /* ??? People shouldn't be doing non-pic code in
4109 shared libraries. Hork. */
4111 (_("%pB: linking non-pic code in a position independent executable"),
4118 dyn_r_type = r_type + R_IA64_RELNNLSB - R_IA64_FPTRNNLSB;
4122 if (h->dynindx != -1)
4123 dynindx = h->dynindx;
4125 dynindx = (_bfd_elf_link_lookup_local_dynindx
4126 (info, h->root.u.def.section->owner,
4127 global_sym_index (h)));
4132 dynindx = (_bfd_elf_link_lookup_local_dynindx
4133 (info, input_bfd, (long) r_symndx));
4137 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4138 srel, rel->r_offset, dyn_r_type,
4142 r = ia64_elf_install_value (hit_addr, value, r_type);
4145 case R_IA64_LTOFF_FPTR22:
4146 case R_IA64_LTOFF_FPTR64I:
4147 case R_IA64_LTOFF_FPTR32MSB:
4148 case R_IA64_LTOFF_FPTR32LSB:
4149 case R_IA64_LTOFF_FPTR64MSB:
4150 case R_IA64_LTOFF_FPTR64LSB:
4154 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4155 if (dyn_i->want_fptr)
4157 BFD_ASSERT (h == NULL || h->dynindx == -1);
4158 if (!undef_weak_ref)
4159 value = set_fptr_entry (output_bfd, info, dyn_i, value);
4164 /* Otherwise, we expect the dynamic linker to create
4168 if (h->dynindx != -1)
4169 dynindx = h->dynindx;
4171 dynindx = (_bfd_elf_link_lookup_local_dynindx
4172 (info, h->root.u.def.section->owner,
4173 global_sym_index (h)));
4176 dynindx = (_bfd_elf_link_lookup_local_dynindx
4177 (info, input_bfd, (long) r_symndx));
4181 value = set_got_entry (output_bfd, info, dyn_i, dynindx,
4182 rel->r_addend, value, R_IA64_FPTRNNLSB);
4184 r = ia64_elf_install_value (hit_addr, value, r_type);
4188 case R_IA64_PCREL32MSB:
4189 case R_IA64_PCREL32LSB:
4190 case R_IA64_PCREL64MSB:
4191 case R_IA64_PCREL64LSB:
4192 /* Install a dynamic relocation for this reloc. */
4193 if (dynamic_symbol_p && r_symndx != STN_UNDEF)
4195 BFD_ASSERT (srel != NULL);
4197 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4198 srel, rel->r_offset, r_type,
4199 h->dynindx, rel->r_addend);
4203 case R_IA64_PCREL21B:
4204 case R_IA64_PCREL60B:
4205 /* We should have created a PLT entry for any dynamic symbol. */
4208 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE);
4210 if (dyn_i && dyn_i->want_plt2)
4212 /* Should have caught this earlier. */
4213 BFD_ASSERT (rel->r_addend == 0);
4215 value = (ia64_info->root.splt->output_section->vma
4216 + ia64_info->root.splt->output_offset
4217 + dyn_i->plt2_offset);
4221 /* Since there's no PLT entry, Validate that this is
4223 BFD_ASSERT (undef_weak_ref || sym_sec->output_section != NULL);
4225 /* If the symbol is undef_weak, we shouldn't be trying
4226 to call it. There's every chance that we'd wind up
4227 with an out-of-range fixup here. Don't bother setting
4228 any value at all. */
4234 case R_IA64_PCREL21BI:
4235 case R_IA64_PCREL21F:
4236 case R_IA64_PCREL21M:
4237 case R_IA64_PCREL22:
4238 case R_IA64_PCREL64I:
4239 /* The PCREL21BI reloc is specifically not intended for use with
4240 dynamic relocs. PCREL21F and PCREL21M are used for speculation
4241 fixup code, and thus probably ought not be dynamic. The
4242 PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs. */
4243 if (dynamic_symbol_p)
4247 if (r_type == R_IA64_PCREL21BI)
4248 /* xgettext:c-format */
4249 msg = _("%pB: @internal branch to dynamic symbol %s");
4250 else if (r_type == R_IA64_PCREL21F || r_type == R_IA64_PCREL21M)
4251 /* xgettext:c-format */
4252 msg = _("%pB: speculation fixup to dynamic symbol %s");
4254 /* xgettext:c-format */
4255 msg = _("%pB: @pcrel relocation against dynamic symbol %s");
4256 _bfd_error_handler (msg, input_bfd,
4257 h ? h->root.root.string
4258 : bfd_elf_sym_name (input_bfd,
4268 /* Make pc-relative. */
4269 value -= (input_section->output_section->vma
4270 + input_section->output_offset
4271 + rel->r_offset) & ~ (bfd_vma) 0x3;
4272 r = ia64_elf_install_value (hit_addr, value, r_type);
4275 case R_IA64_SEGREL32MSB:
4276 case R_IA64_SEGREL32LSB:
4277 case R_IA64_SEGREL64MSB:
4278 case R_IA64_SEGREL64LSB:
4280 /* Find the segment that contains the output_section. */
4281 Elf_Internal_Phdr *p = _bfd_elf_find_segment_containing_section
4282 (output_bfd, input_section->output_section);
4286 r = bfd_reloc_notsupported;
4290 /* The VMA of the segment is the vaddr of the associated
4292 if (value > p->p_vaddr)
4293 value -= p->p_vaddr;
4296 r = ia64_elf_install_value (hit_addr, value, r_type);
4301 case R_IA64_SECREL32MSB:
4302 case R_IA64_SECREL32LSB:
4303 case R_IA64_SECREL64MSB:
4304 case R_IA64_SECREL64LSB:
4305 /* Make output-section relative to section where the symbol
4306 is defined. PR 475 */
4308 value -= sym_sec->output_section->vma;
4309 r = ia64_elf_install_value (hit_addr, value, r_type);
4312 case R_IA64_IPLTMSB:
4313 case R_IA64_IPLTLSB:
4314 /* Install a dynamic relocation for this reloc. */
4315 if ((dynamic_symbol_p || bfd_link_pic (info))
4316 && (input_section->flags & SEC_ALLOC) != 0)
4318 BFD_ASSERT (srel != NULL);
4320 /* If we don't need dynamic symbol lookup, install two
4321 RELATIVE relocations. */
4322 if (!dynamic_symbol_p)
4324 unsigned int dyn_r_type;
4326 if (r_type == R_IA64_IPLTMSB)
4327 dyn_r_type = R_IA64_REL64MSB;
4329 dyn_r_type = R_IA64_REL64LSB;
4331 elfNN_ia64_install_dyn_reloc (output_bfd, info,
4333 srel, rel->r_offset,
4334 dyn_r_type, 0, value);
4335 elfNN_ia64_install_dyn_reloc (output_bfd, info,
4337 srel, rel->r_offset + 8,
4338 dyn_r_type, 0, gp_val);
4341 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4342 srel, rel->r_offset, r_type,
4343 h->dynindx, rel->r_addend);
4346 if (r_type == R_IA64_IPLTMSB)
4347 r_type = R_IA64_DIR64MSB;
4349 r_type = R_IA64_DIR64LSB;
4350 ia64_elf_install_value (hit_addr, value, r_type);
4351 r = ia64_elf_install_value (hit_addr + 8, gp_val, r_type);
4354 case R_IA64_TPREL14:
4355 case R_IA64_TPREL22:
4356 case R_IA64_TPREL64I:
4357 if (elf_hash_table (info)->tls_sec == NULL)
4358 goto missing_tls_sec;
4359 value -= elfNN_ia64_tprel_base (info);
4360 r = ia64_elf_install_value (hit_addr, value, r_type);
4363 case R_IA64_DTPREL14:
4364 case R_IA64_DTPREL22:
4365 case R_IA64_DTPREL64I:
4366 case R_IA64_DTPREL32LSB:
4367 case R_IA64_DTPREL32MSB:
4368 case R_IA64_DTPREL64LSB:
4369 case R_IA64_DTPREL64MSB:
4370 if (elf_hash_table (info)->tls_sec == NULL)
4371 goto missing_tls_sec;
4372 value -= elfNN_ia64_dtprel_base (info);
4373 r = ia64_elf_install_value (hit_addr, value, r_type);
4376 case R_IA64_LTOFF_TPREL22:
4377 case R_IA64_LTOFF_DTPMOD22:
4378 case R_IA64_LTOFF_DTPREL22:
4381 long dynindx = h ? h->dynindx : -1;
4382 bfd_vma r_addend = rel->r_addend;
4387 case R_IA64_LTOFF_TPREL22:
4388 if (!dynamic_symbol_p)
4390 if (elf_hash_table (info)->tls_sec == NULL)
4391 goto missing_tls_sec;
4392 if (!bfd_link_pic (info))
4393 value -= elfNN_ia64_tprel_base (info);
4396 r_addend += value - elfNN_ia64_dtprel_base (info);
4400 got_r_type = R_IA64_TPREL64LSB;
4402 case R_IA64_LTOFF_DTPMOD22:
4403 if (!dynamic_symbol_p && !bfd_link_pic (info))
4405 got_r_type = R_IA64_DTPMOD64LSB;
4407 case R_IA64_LTOFF_DTPREL22:
4408 if (!dynamic_symbol_p)
4410 if (elf_hash_table (info)->tls_sec == NULL)
4411 goto missing_tls_sec;
4412 value -= elfNN_ia64_dtprel_base (info);
4414 got_r_type = R_IA64_DTPRELNNLSB;
4417 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4418 value = set_got_entry (input_bfd, info, dyn_i, dynindx, r_addend,
4421 r = ia64_elf_install_value (hit_addr, value, r_type);
4426 r = bfd_reloc_notsupported;
4435 case bfd_reloc_undefined:
4436 /* This can happen for global table relative relocs if
4437 __gp is undefined. This is a panic situation so we
4438 don't try to continue. */
4439 (*info->callbacks->undefined_symbol)
4440 (info, "__gp", input_bfd, input_section, rel->r_offset, 1);
4443 case bfd_reloc_notsupported:
4448 name = h->root.root.string;
4450 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4452 (*info->callbacks->warning) (info, _("unsupported reloc"),
4454 input_section, rel->r_offset);
4459 case bfd_reloc_dangerous:
4460 case bfd_reloc_outofrange:
4461 case bfd_reloc_overflow:
4468 name = h->root.root.string;
4470 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4475 case R_IA64_TPREL14:
4476 case R_IA64_TPREL22:
4477 case R_IA64_TPREL64I:
4478 case R_IA64_DTPREL14:
4479 case R_IA64_DTPREL22:
4480 case R_IA64_DTPREL64I:
4481 case R_IA64_DTPREL32LSB:
4482 case R_IA64_DTPREL32MSB:
4483 case R_IA64_DTPREL64LSB:
4484 case R_IA64_DTPREL64MSB:
4485 case R_IA64_LTOFF_TPREL22:
4486 case R_IA64_LTOFF_DTPMOD22:
4487 case R_IA64_LTOFF_DTPREL22:
4489 /* xgettext:c-format */
4490 (_("%pB: missing TLS section for relocation %s against `%s'"
4491 " at %#" PRIx64 " in section `%pA'."),
4492 input_bfd, howto->name, name,
4493 (uint64_t) rel->r_offset, input_section);
4496 case R_IA64_PCREL21B:
4497 case R_IA64_PCREL21BI:
4498 case R_IA64_PCREL21M:
4499 case R_IA64_PCREL21F:
4500 if (is_elf_hash_table (info->hash))
4502 /* Relaxtion is always performed for ELF output.
4503 Overflow failures for those relocations mean
4504 that the section is too big to relax. */
4506 /* xgettext:c-format */
4507 (_("%pB: Can't relax br (%s) to `%s' at %#" PRIx64
4508 " in section `%pA' with size %#" PRIx64
4510 input_bfd, howto->name, name, (uint64_t) rel->r_offset,
4511 input_section, (uint64_t) input_section->size);
4516 (*info->callbacks->reloc_overflow) (info,
4537 elfNN_ia64_finish_dynamic_symbol (bfd *output_bfd,
4538 struct bfd_link_info *info,
4539 struct elf_link_hash_entry *h,
4540 Elf_Internal_Sym *sym)
4542 struct elfNN_ia64_link_hash_table *ia64_info;
4543 struct elfNN_ia64_dyn_sym_info *dyn_i;
4545 ia64_info = elfNN_ia64_hash_table (info);
4546 if (ia64_info == NULL)
4549 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE);
4551 /* Fill in the PLT data, if required. */
4552 if (dyn_i && dyn_i->want_plt)
4554 Elf_Internal_Rela outrel;
4557 bfd_vma plt_addr, pltoff_addr, gp_val, plt_index;
4559 gp_val = _bfd_get_gp_value (output_bfd);
4561 /* Initialize the minimal PLT entry. */
4563 plt_index = (dyn_i->plt_offset - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
4564 plt_sec = ia64_info->root.splt;
4565 loc = plt_sec->contents + dyn_i->plt_offset;
4567 memcpy (loc, plt_min_entry, PLT_MIN_ENTRY_SIZE);
4568 ia64_elf_install_value (loc, plt_index, R_IA64_IMM22);
4569 ia64_elf_install_value (loc+2, -dyn_i->plt_offset, R_IA64_PCREL21B);
4571 plt_addr = (plt_sec->output_section->vma
4572 + plt_sec->output_offset
4573 + dyn_i->plt_offset);
4574 pltoff_addr = set_pltoff_entry (output_bfd, info, dyn_i, plt_addr, TRUE);
4576 /* Initialize the FULL PLT entry, if needed. */
4577 if (dyn_i->want_plt2)
4579 loc = plt_sec->contents + dyn_i->plt2_offset;
4581 memcpy (loc, plt_full_entry, PLT_FULL_ENTRY_SIZE);
4582 ia64_elf_install_value (loc, pltoff_addr - gp_val, R_IA64_IMM22);
4584 /* Mark the symbol as undefined, rather than as defined in the
4585 plt section. Leave the value alone. */
4586 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
4587 first place. But perhaps elflink.c did some for us. */
4588 if (!h->def_regular)
4589 sym->st_shndx = SHN_UNDEF;
4592 /* Create the dynamic relocation. */
4593 outrel.r_offset = pltoff_addr;
4594 if (bfd_little_endian (output_bfd))
4595 outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTLSB);
4597 outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTMSB);
4598 outrel.r_addend = 0;
4600 /* This is fun. In the .IA_64.pltoff section, we've got entries
4601 that correspond both to real PLT entries, and those that
4602 happened to resolve to local symbols but need to be created
4603 to satisfy @pltoff relocations. The .rela.IA_64.pltoff
4604 relocations for the real PLT should come at the end of the
4605 section, so that they can be indexed by plt entry at runtime.
4607 We emitted all of the relocations for the non-PLT @pltoff
4608 entries during relocate_section. So we can consider the
4609 existing sec->reloc_count to be the base of the array of
4612 loc = ia64_info->rel_pltoff_sec->contents;
4613 loc += ((ia64_info->rel_pltoff_sec->reloc_count + plt_index)
4614 * sizeof (ElfNN_External_Rela));
4615 bfd_elfNN_swap_reloca_out (output_bfd, &outrel, loc);
4618 /* Mark some specially defined symbols as absolute. */
4619 if (h == ia64_info->root.hdynamic
4620 || h == ia64_info->root.hgot
4621 || h == ia64_info->root.hplt)
4622 sym->st_shndx = SHN_ABS;
4628 elfNN_ia64_finish_dynamic_sections (bfd *abfd,
4629 struct bfd_link_info *info)
4631 struct elfNN_ia64_link_hash_table *ia64_info;
4634 ia64_info = elfNN_ia64_hash_table (info);
4635 if (ia64_info == NULL)
4638 dynobj = ia64_info->root.dynobj;
4640 if (ia64_info->root.dynamic_sections_created)
4642 ElfNN_External_Dyn *dyncon, *dynconend;
4643 asection *sdyn, *sgotplt;
4646 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4647 sgotplt = ia64_info->root.sgotplt;
4648 BFD_ASSERT (sdyn != NULL);
4649 dyncon = (ElfNN_External_Dyn *) sdyn->contents;
4650 dynconend = (ElfNN_External_Dyn *) (sdyn->contents + sdyn->size);
4652 gp_val = _bfd_get_gp_value (abfd);
4654 for (; dyncon < dynconend; dyncon++)
4656 Elf_Internal_Dyn dyn;
4658 bfd_elfNN_swap_dyn_in (dynobj, dyncon, &dyn);
4663 dyn.d_un.d_ptr = gp_val;
4667 dyn.d_un.d_val = (ia64_info->minplt_entries
4668 * sizeof (ElfNN_External_Rela));
4672 /* See the comment above in finish_dynamic_symbol. */
4673 dyn.d_un.d_ptr = (ia64_info->rel_pltoff_sec->output_section->vma
4674 + ia64_info->rel_pltoff_sec->output_offset
4675 + (ia64_info->rel_pltoff_sec->reloc_count
4676 * sizeof (ElfNN_External_Rela)));
4679 case DT_IA_64_PLT_RESERVE:
4680 dyn.d_un.d_ptr = (sgotplt->output_section->vma
4681 + sgotplt->output_offset);
4685 bfd_elfNN_swap_dyn_out (abfd, &dyn, dyncon);
4688 /* Initialize the PLT0 entry. */
4689 if (ia64_info->root.splt)
4691 bfd_byte *loc = ia64_info->root.splt->contents;
4694 memcpy (loc, plt_header, PLT_HEADER_SIZE);
4696 pltres = (sgotplt->output_section->vma
4697 + sgotplt->output_offset
4700 ia64_elf_install_value (loc+1, pltres, R_IA64_GPREL22);
4707 /* ELF file flag handling: */
4709 /* Function to keep IA-64 specific file flags. */
4711 elfNN_ia64_set_private_flags (bfd *abfd, flagword flags)
4713 BFD_ASSERT (!elf_flags_init (abfd)
4714 || elf_elfheader (abfd)->e_flags == flags);
4716 elf_elfheader (abfd)->e_flags = flags;
4717 elf_flags_init (abfd) = TRUE;
4721 /* Merge backend specific data from an object file to the output
4722 object file when linking. */
4724 elfNN_ia64_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
4726 bfd *obfd = info->output_bfd;
4729 bfd_boolean ok = TRUE;
4731 /* Don't even pretend to support mixed-format linking. */
4732 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4733 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4736 in_flags = elf_elfheader (ibfd)->e_flags;
4737 out_flags = elf_elfheader (obfd)->e_flags;
4739 if (! elf_flags_init (obfd))
4741 elf_flags_init (obfd) = TRUE;
4742 elf_elfheader (obfd)->e_flags = in_flags;
4744 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
4745 && bfd_get_arch_info (obfd)->the_default)
4747 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
4748 bfd_get_mach (ibfd));
4754 /* Check flag compatibility. */
4755 if (in_flags == out_flags)
4758 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
4759 if (!(in_flags & EF_IA_64_REDUCEDFP) && (out_flags & EF_IA_64_REDUCEDFP))
4760 elf_elfheader (obfd)->e_flags &= ~EF_IA_64_REDUCEDFP;
4762 if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL))
4765 (_("%pB: linking trap-on-NULL-dereference with non-trapping files"),
4768 bfd_set_error (bfd_error_bad_value);
4771 if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE))
4774 (_("%pB: linking big-endian files with little-endian files"),
4777 bfd_set_error (bfd_error_bad_value);
4780 if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64))
4783 (_("%pB: linking 64-bit files with 32-bit files"),
4786 bfd_set_error (bfd_error_bad_value);
4789 if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP))
4792 (_("%pB: linking constant-gp files with non-constant-gp files"),
4795 bfd_set_error (bfd_error_bad_value);
4798 if ((in_flags & EF_IA_64_NOFUNCDESC_CONS_GP)
4799 != (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
4802 (_("%pB: linking auto-pic files with non-auto-pic files"),
4805 bfd_set_error (bfd_error_bad_value);
4813 elfNN_ia64_print_private_bfd_data (bfd *abfd, void * ptr)
4815 FILE *file = (FILE *) ptr;
4816 flagword flags = elf_elfheader (abfd)->e_flags;
4818 BFD_ASSERT (abfd != NULL && ptr != NULL);
4820 fprintf (file, "private flags = %s%s%s%s%s%s%s%s\n",
4821 (flags & EF_IA_64_TRAPNIL) ? "TRAPNIL, " : "",
4822 (flags & EF_IA_64_EXT) ? "EXT, " : "",
4823 (flags & EF_IA_64_BE) ? "BE, " : "LE, ",
4824 (flags & EF_IA_64_REDUCEDFP) ? "REDUCEDFP, " : "",
4825 (flags & EF_IA_64_CONS_GP) ? "CONS_GP, " : "",
4826 (flags & EF_IA_64_NOFUNCDESC_CONS_GP) ? "NOFUNCDESC_CONS_GP, " : "",
4827 (flags & EF_IA_64_ABSOLUTE) ? "ABSOLUTE, " : "",
4828 (flags & EF_IA_64_ABI64) ? "ABI64" : "ABI32");
4830 _bfd_elf_print_private_bfd_data (abfd, ptr);
4834 static enum elf_reloc_type_class
4835 elfNN_ia64_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
4836 const asection *rel_sec ATTRIBUTE_UNUSED,
4837 const Elf_Internal_Rela *rela)
4839 switch ((int) ELFNN_R_TYPE (rela->r_info))
4841 case R_IA64_REL32MSB:
4842 case R_IA64_REL32LSB:
4843 case R_IA64_REL64MSB:
4844 case R_IA64_REL64LSB:
4845 return reloc_class_relative;
4846 case R_IA64_IPLTMSB:
4847 case R_IA64_IPLTLSB:
4848 return reloc_class_plt;
4850 return reloc_class_copy;
4852 return reloc_class_normal;
4856 static const struct bfd_elf_special_section elfNN_ia64_special_sections[] =
4858 { STRING_COMMA_LEN (".sbss"), -1, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
4859 { STRING_COMMA_LEN (".sdata"), -1, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
4860 { NULL, 0, 0, 0, 0 }
4864 elfNN_ia64_object_p (bfd *abfd)
4867 asection *group, *unwi, *unw;
4870 char *unwi_name, *unw_name;
4873 if (abfd->flags & DYNAMIC)
4876 /* Flags for fake group section. */
4877 flags = (SEC_LINKER_CREATED | SEC_GROUP | SEC_LINK_ONCE
4880 /* We add a fake section group for each .gnu.linkonce.t.* section,
4881 which isn't in a section group, and its unwind sections. */
4882 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4884 if (elf_sec_group (sec) == NULL
4885 && ((sec->flags & (SEC_LINK_ONCE | SEC_CODE | SEC_GROUP))
4886 == (SEC_LINK_ONCE | SEC_CODE))
4887 && CONST_STRNEQ (sec->name, ".gnu.linkonce.t."))
4889 name = sec->name + 16;
4891 amt = strlen (name) + sizeof (".gnu.linkonce.ia64unwi.");
4892 unwi_name = bfd_alloc (abfd, amt);
4896 strcpy (stpcpy (unwi_name, ".gnu.linkonce.ia64unwi."), name);
4897 unwi = bfd_get_section_by_name (abfd, unwi_name);
4899 amt = strlen (name) + sizeof (".gnu.linkonce.ia64unw.");
4900 unw_name = bfd_alloc (abfd, amt);
4904 strcpy (stpcpy (unw_name, ".gnu.linkonce.ia64unw."), name);
4905 unw = bfd_get_section_by_name (abfd, unw_name);
4907 /* We need to create a fake group section for it and its
4909 group = bfd_make_section_anyway_with_flags (abfd, name,
4914 /* Move the fake group section to the beginning. */
4915 bfd_section_list_remove (abfd, group);
4916 bfd_section_list_prepend (abfd, group);
4918 elf_next_in_group (group) = sec;
4920 elf_group_name (sec) = name;
4921 elf_next_in_group (sec) = sec;
4922 elf_sec_group (sec) = group;
4926 elf_group_name (unwi) = name;
4927 elf_next_in_group (unwi) = sec;
4928 elf_next_in_group (sec) = unwi;
4929 elf_sec_group (unwi) = group;
4934 elf_group_name (unw) = name;
4937 elf_next_in_group (unw) = elf_next_in_group (unwi);
4938 elf_next_in_group (unwi) = unw;
4942 elf_next_in_group (unw) = sec;
4943 elf_next_in_group (sec) = unw;
4945 elf_sec_group (unw) = group;
4948 /* Fake SHT_GROUP section header. */
4949 elf_section_data (group)->this_hdr.bfd_section = group;
4950 elf_section_data (group)->this_hdr.sh_type = SHT_GROUP;
4957 elfNN_ia64_hpux_vec (const bfd_target *vec)
4959 extern const bfd_target ia64_elfNN_hpux_be_vec;
4960 return (vec == &ia64_elfNN_hpux_be_vec);
4964 elfNN_hpux_post_process_headers (bfd *abfd,
4965 struct bfd_link_info *info ATTRIBUTE_UNUSED)
4967 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
4969 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
4970 i_ehdrp->e_ident[EI_ABIVERSION] = 1;
4974 elfNN_hpux_backend_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
4975 asection *sec, int *retval)
4977 if (bfd_is_com_section (sec))
4979 *retval = SHN_IA_64_ANSI_COMMON;
4986 elfNN_hpux_backend_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
4989 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
4991 switch (elfsym->internal_elf_sym.st_shndx)
4993 case SHN_IA_64_ANSI_COMMON:
4994 asym->section = bfd_com_section_ptr;
4995 asym->value = elfsym->internal_elf_sym.st_size;
4996 asym->flags &= ~BSF_GLOBAL;
5001 #define TARGET_LITTLE_SYM ia64_elfNN_le_vec
5002 #define TARGET_LITTLE_NAME "elfNN-ia64-little"
5003 #define TARGET_BIG_SYM ia64_elfNN_be_vec
5004 #define TARGET_BIG_NAME "elfNN-ia64-big"
5005 #define ELF_ARCH bfd_arch_ia64
5006 #define ELF_TARGET_ID IA64_ELF_DATA
5007 #define ELF_MACHINE_CODE EM_IA_64
5008 #define ELF_MACHINE_ALT1 1999 /* EAS2.3 */
5009 #define ELF_MACHINE_ALT2 1998 /* EAS2.2 */
5010 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
5011 #define ELF_COMMONPAGESIZE 0x4000 /* 16KB */
5013 #define elf_backend_section_from_shdr \
5014 elfNN_ia64_section_from_shdr
5015 #define elf_backend_section_flags \
5016 elfNN_ia64_section_flags
5017 #define elf_backend_fake_sections \
5018 elfNN_ia64_fake_sections
5019 #define elf_backend_final_write_processing \
5020 elfNN_ia64_final_write_processing
5021 #define elf_backend_add_symbol_hook \
5022 elfNN_ia64_add_symbol_hook
5023 #define elf_backend_additional_program_headers \
5024 elfNN_ia64_additional_program_headers
5025 #define elf_backend_modify_segment_map \
5026 elfNN_ia64_modify_segment_map
5027 #define elf_backend_modify_program_headers \
5028 elfNN_ia64_modify_program_headers
5029 #define elf_info_to_howto \
5030 elfNN_ia64_info_to_howto
5032 #define bfd_elfNN_bfd_reloc_type_lookup \
5033 ia64_elf_reloc_type_lookup
5034 #define bfd_elfNN_bfd_reloc_name_lookup \
5035 ia64_elf_reloc_name_lookup
5036 #define bfd_elfNN_bfd_is_local_label_name \
5037 elfNN_ia64_is_local_label_name
5038 #define bfd_elfNN_bfd_relax_section \
5039 elfNN_ia64_relax_section
5041 #define elf_backend_object_p \
5044 /* Stuff for the BFD linker: */
5045 #define bfd_elfNN_bfd_link_hash_table_create \
5046 elfNN_ia64_hash_table_create
5047 #define elf_backend_create_dynamic_sections \
5048 elfNN_ia64_create_dynamic_sections
5049 #define elf_backend_check_relocs \
5050 elfNN_ia64_check_relocs
5051 #define elf_backend_adjust_dynamic_symbol \
5052 elfNN_ia64_adjust_dynamic_symbol
5053 #define elf_backend_size_dynamic_sections \
5054 elfNN_ia64_size_dynamic_sections
5055 #define elf_backend_omit_section_dynsym \
5056 _bfd_elf_omit_section_dynsym_all
5057 #define elf_backend_relocate_section \
5058 elfNN_ia64_relocate_section
5059 #define elf_backend_finish_dynamic_symbol \
5060 elfNN_ia64_finish_dynamic_symbol
5061 #define elf_backend_finish_dynamic_sections \
5062 elfNN_ia64_finish_dynamic_sections
5063 #define bfd_elfNN_bfd_final_link \
5064 elfNN_ia64_final_link
5066 #define bfd_elfNN_bfd_merge_private_bfd_data \
5067 elfNN_ia64_merge_private_bfd_data
5068 #define bfd_elfNN_bfd_set_private_flags \
5069 elfNN_ia64_set_private_flags
5070 #define bfd_elfNN_bfd_print_private_bfd_data \
5071 elfNN_ia64_print_private_bfd_data
5073 #define elf_backend_plt_readonly 1
5074 #define elf_backend_can_gc_sections 1
5075 #define elf_backend_want_plt_sym 0
5076 #define elf_backend_plt_alignment 5
5077 #define elf_backend_got_header_size 0
5078 #define elf_backend_want_got_plt 1
5079 #define elf_backend_may_use_rel_p 1
5080 #define elf_backend_may_use_rela_p 1
5081 #define elf_backend_default_use_rela_p 1
5082 #define elf_backend_want_dynbss 0
5083 #define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect
5084 #define elf_backend_hide_symbol elfNN_ia64_hash_hide_symbol
5085 #define elf_backend_fixup_symbol _bfd_elf_link_hash_fixup_symbol
5086 #define elf_backend_reloc_type_class elfNN_ia64_reloc_type_class
5087 #define elf_backend_rela_normal 1
5088 #define elf_backend_dtrel_excludes_plt 1
5089 #define elf_backend_special_sections elfNN_ia64_special_sections
5090 #define elf_backend_default_execstack 0
5092 /* FIXME: PR 290: The Intel C compiler generates SHT_IA_64_UNWIND with
5093 SHF_LINK_ORDER. But it doesn't set the sh_link or sh_info fields.
5094 We don't want to flood users with so many error messages. We turn
5095 off the warning for now. It will be turned on later when the Intel
5096 compiler is fixed. */
5097 #define elf_backend_link_order_error_handler NULL
5099 #include "elfNN-target.h"
5101 /* HPUX-specific vectors. */
5103 #undef TARGET_LITTLE_SYM
5104 #undef TARGET_LITTLE_NAME
5105 #undef TARGET_BIG_SYM
5106 #define TARGET_BIG_SYM ia64_elfNN_hpux_be_vec
5107 #undef TARGET_BIG_NAME
5108 #define TARGET_BIG_NAME "elfNN-ia64-hpux-big"
5110 /* These are HP-UX specific functions. */
5112 #undef elf_backend_post_process_headers
5113 #define elf_backend_post_process_headers elfNN_hpux_post_process_headers
5115 #undef elf_backend_section_from_bfd_section
5116 #define elf_backend_section_from_bfd_section elfNN_hpux_backend_section_from_bfd_section
5118 #undef elf_backend_symbol_processing
5119 #define elf_backend_symbol_processing elfNN_hpux_backend_symbol_processing
5121 #undef elf_backend_want_p_paddr_set_to_zero
5122 #define elf_backend_want_p_paddr_set_to_zero 1
5124 #undef ELF_COMMONPAGESIZE
5126 #define ELF_OSABI ELFOSABI_HPUX
5129 #define elfNN_bed elfNN_ia64_hpux_bed
5131 #include "elfNN-target.h"