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)
600 else if (r_type == R_IA64_PCREL60B)
602 else if (ia64_elf_relax_br (contents, roff))
605 = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
608 /* Make the relocation offset point to slot 1. */
609 irel->r_offset = (irel->r_offset & ~((bfd_vma) 0x3)) + 1;
613 /* We can't put a trampoline in a .init/.fini section. Issue
615 if (strcmp (sec->output_section->name, ".init") == 0
616 || strcmp (sec->output_section->name, ".fini") == 0)
619 /* xgettext:c-format */
620 (_("%pB: Can't relax br at %#Lx in section `%pA'."
621 " Please use brl or indirect branch."),
622 sec->owner, roff, sec);
623 bfd_set_error (bfd_error_bad_value);
627 /* If the branch and target are in the same section, you've
628 got one honking big section and we can't help you unless
629 you are branching backwards. You'll get an error message
631 if (tsec == sec && toff > roff)
634 /* Look for an existing fixup to this address. */
635 for (f = fixups; f ; f = f->next)
636 if (f->tsec == tsec && f->toff == toff)
641 /* Two alternatives: If it's a branch to a PLT entry, we can
642 make a copy of the FULL_PLT entry. Otherwise, we'll have
643 to use a `brl' insn to get where we're going. */
647 if (tsec == ia64_info->root.splt)
648 size = sizeof (plt_full_entry);
650 size = oor_branch_size;
652 /* Resize the current section to make room for the new branch. */
653 trampoff = (sec->size + 15) & (bfd_vma) -16;
655 /* If trampoline is out of range, there is nothing we
657 offset = trampoff - (roff & (bfd_vma) -4);
658 if (offset < -0x1000000 || offset > 0x0FFFFF0)
661 amt = trampoff + size;
662 contents = (bfd_byte *) bfd_realloc (contents, amt);
663 if (contents == NULL)
667 if (tsec == ia64_info->root.splt)
669 memcpy (contents + trampoff, plt_full_entry, size);
671 /* Hijack the old relocation for use as the PLTOFF reloc. */
672 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
674 irel->r_offset = trampoff;
678 if (size == sizeof (oor_ip))
680 memcpy (contents + trampoff, oor_ip, size);
681 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
683 irel->r_addend -= 16;
684 irel->r_offset = trampoff + 2;
688 memcpy (contents + trampoff, oor_brl, size);
689 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
691 irel->r_offset = trampoff + 2;
696 /* Record the fixup so we don't do it again this section. */
697 f = (struct one_fixup *)
698 bfd_malloc ((bfd_size_type) sizeof (*f));
702 f->trampoff = trampoff;
707 /* If trampoline is out of range, there is nothing we
709 offset = f->trampoff - (roff & (bfd_vma) -4);
710 if (offset < -0x1000000 || offset > 0x0FFFFF0)
713 /* Nop out the reloc, since we're finalizing things here. */
714 irel->r_info = ELFNN_R_INFO (0, R_IA64_NONE);
717 /* Fix up the existing branch to hit the trampoline. */
718 if (ia64_elf_install_value (contents + roff, offset, r_type)
722 changed_contents = TRUE;
723 changed_relocs = TRUE;
730 bfd *obfd = sec->output_section->owner;
731 gp = _bfd_get_gp_value (obfd);
734 if (!elfNN_ia64_choose_gp (obfd, link_info, FALSE))
736 gp = _bfd_get_gp_value (obfd);
740 /* If the data is out of range, do nothing. */
741 if ((bfd_signed_vma) (symaddr - gp) >= 0x200000
742 ||(bfd_signed_vma) (symaddr - gp) < -0x200000)
745 if (r_type == R_IA64_GPREL22)
746 elfNN_ia64_update_short_info (tsec->output_section,
747 tsec->output_offset + toff,
749 else if (r_type == R_IA64_LTOFF22X)
751 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
753 changed_relocs = TRUE;
754 if (dyn_i->want_gotx)
756 dyn_i->want_gotx = 0;
757 changed_got |= !dyn_i->want_got;
760 elfNN_ia64_update_short_info (tsec->output_section,
761 tsec->output_offset + toff,
766 ia64_elf_relax_ldxmov (contents, roff);
767 irel->r_info = ELFNN_R_INFO (0, R_IA64_NONE);
768 changed_contents = TRUE;
769 changed_relocs = TRUE;
774 /* ??? If we created fixups, this may push the code segment large
775 enough that the data segment moves, which will change the GP.
776 Reset the GP so that we re-calculate next round. We need to
777 do this at the _beginning_ of the next round; now will not do. */
779 /* Clean up and go home. */
782 struct one_fixup *f = fixups;
783 fixups = fixups->next;
788 && symtab_hdr->contents != (unsigned char *) isymbuf)
790 if (! link_info->keep_memory)
794 /* Cache the symbols for elf_link_input_bfd. */
795 symtab_hdr->contents = (unsigned char *) isymbuf;
800 && elf_section_data (sec)->this_hdr.contents != contents)
802 if (!changed_contents && !link_info->keep_memory)
806 /* Cache the section contents for elf_link_input_bfd. */
807 elf_section_data (sec)->this_hdr.contents = contents;
811 if (elf_section_data (sec)->relocs != internal_relocs)
814 free (internal_relocs);
816 elf_section_data (sec)->relocs = internal_relocs;
821 struct elfNN_ia64_allocate_data data;
822 data.info = link_info;
824 ia64_info->self_dtpmod_offset = (bfd_vma) -1;
826 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data);
827 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data);
828 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data);
829 ia64_info->root.sgot->size = data.ofs;
831 if (ia64_info->root.dynamic_sections_created
832 && ia64_info->root.srelgot != NULL)
834 /* Resize .rela.got. */
835 ia64_info->root.srelgot->size = 0;
836 if (bfd_link_pic (link_info)
837 && ia64_info->self_dtpmod_offset != (bfd_vma) -1)
838 ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela);
839 data.only_got = TRUE;
840 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries,
845 if (link_info->relax_pass == 0)
847 /* Pass 0 is only needed to relax br. */
848 sec->skip_relax_pass_0 = skip_relax_pass_0;
849 sec->skip_relax_pass_1 = skip_relax_pass_1;
852 *again = changed_contents || changed_relocs;
856 if (isymbuf != NULL && (unsigned char *) isymbuf != symtab_hdr->contents)
859 && elf_section_data (sec)->this_hdr.contents != contents)
861 if (internal_relocs != NULL
862 && elf_section_data (sec)->relocs != internal_relocs)
863 free (internal_relocs);
866 #undef skip_relax_pass_0
867 #undef skip_relax_pass_1
869 /* Return TRUE if NAME is an unwind table section name. */
871 static inline bfd_boolean
872 is_unwind_section_name (bfd *abfd, const char *name)
874 if (elfNN_ia64_hpux_vec (abfd->xvec)
875 && !strcmp (name, ELF_STRING_ia64_unwind_hdr))
878 return ((CONST_STRNEQ (name, ELF_STRING_ia64_unwind)
879 && ! CONST_STRNEQ (name, ELF_STRING_ia64_unwind_info))
880 || CONST_STRNEQ (name, ELF_STRING_ia64_unwind_once));
883 /* Handle an IA-64 specific section when reading an object file. This
884 is called when bfd_section_from_shdr finds a section with an unknown
888 elfNN_ia64_section_from_shdr (bfd *abfd,
889 Elf_Internal_Shdr *hdr,
893 /* There ought to be a place to keep ELF backend specific flags, but
894 at the moment there isn't one. We just keep track of the
895 sections by their name, instead. Fortunately, the ABI gives
896 suggested names for all the MIPS specific sections, so we will
897 probably get away with this. */
898 switch (hdr->sh_type)
900 case SHT_IA_64_UNWIND:
901 case SHT_IA_64_HP_OPT_ANOT:
905 if (strcmp (name, ELF_STRING_ia64_archext) != 0)
913 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
919 /* Convert IA-64 specific section flags to bfd internal section flags. */
921 /* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
925 elfNN_ia64_section_flags (flagword *flags,
926 const Elf_Internal_Shdr *hdr)
928 if (hdr->sh_flags & SHF_IA_64_SHORT)
929 *flags |= SEC_SMALL_DATA;
934 /* Set the correct type for an IA-64 ELF section. We do this by the
935 section name, which is a hack, but ought to work. */
938 elfNN_ia64_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr,
943 name = bfd_get_section_name (abfd, sec);
945 if (is_unwind_section_name (abfd, name))
947 /* We don't have the sections numbered at this point, so sh_info
948 is set later, in elfNN_ia64_final_write_processing. */
949 hdr->sh_type = SHT_IA_64_UNWIND;
950 hdr->sh_flags |= SHF_LINK_ORDER;
952 else if (strcmp (name, ELF_STRING_ia64_archext) == 0)
953 hdr->sh_type = SHT_IA_64_EXT;
954 else if (strcmp (name, ".HP.opt_annot") == 0)
955 hdr->sh_type = SHT_IA_64_HP_OPT_ANOT;
956 else if (strcmp (name, ".reloc") == 0)
957 /* This is an ugly, but unfortunately necessary hack that is
958 needed when producing EFI binaries on IA-64. It tells
959 elf.c:elf_fake_sections() not to consider ".reloc" as a section
960 containing ELF relocation info. We need this hack in order to
961 be able to generate ELF binaries that can be translated into
962 EFI applications (which are essentially COFF objects). Those
963 files contain a COFF ".reloc" section inside an ELFNN object,
964 which would normally cause BFD to segfault because it would
965 attempt to interpret this section as containing relocation
966 entries for section "oc". With this hack enabled, ".reloc"
967 will be treated as a normal data section, which will avoid the
968 segfault. However, you won't be able to create an ELFNN binary
969 with a section named "oc" that needs relocations, but that's
970 the kind of ugly side-effects you get when detecting section
971 types based on their names... In practice, this limitation is
973 hdr->sh_type = SHT_PROGBITS;
975 if (sec->flags & SEC_SMALL_DATA)
976 hdr->sh_flags |= SHF_IA_64_SHORT;
978 /* Some HP linkers look for the SHF_IA_64_HP_TLS flag instead of SHF_TLS. */
980 if (elfNN_ia64_hpux_vec (abfd->xvec) && (sec->flags & SHF_TLS))
981 hdr->sh_flags |= SHF_IA_64_HP_TLS;
986 /* The final processing done just before writing out an IA-64 ELF
990 elfNN_ia64_final_write_processing (bfd *abfd,
991 bfd_boolean linker ATTRIBUTE_UNUSED)
993 Elf_Internal_Shdr *hdr;
996 for (s = abfd->sections; s; s = s->next)
998 hdr = &elf_section_data (s)->this_hdr;
999 switch (hdr->sh_type)
1001 case SHT_IA_64_UNWIND:
1002 /* The IA-64 processor-specific ABI requires setting sh_link
1003 to the unwind section, whereas HP-UX requires sh_info to
1004 do so. For maximum compatibility, we'll set both for
1006 hdr->sh_info = hdr->sh_link;
1011 if (! elf_flags_init (abfd))
1013 unsigned long flags = 0;
1015 if (abfd->xvec->byteorder == BFD_ENDIAN_BIG)
1016 flags |= EF_IA_64_BE;
1017 if (bfd_get_mach (abfd) == bfd_mach_ia64_elf64)
1018 flags |= EF_IA_64_ABI64;
1020 elf_elfheader(abfd)->e_flags = flags;
1021 elf_flags_init (abfd) = TRUE;
1025 /* Hook called by the linker routine which adds symbols from an object
1026 file. We use it to put .comm items in .sbss, and not .bss. */
1029 elfNN_ia64_add_symbol_hook (bfd *abfd,
1030 struct bfd_link_info *info,
1031 Elf_Internal_Sym *sym,
1032 const char **namep ATTRIBUTE_UNUSED,
1033 flagword *flagsp ATTRIBUTE_UNUSED,
1037 if (sym->st_shndx == SHN_COMMON
1038 && !bfd_link_relocatable (info)
1039 && sym->st_size <= elf_gp_size (abfd))
1041 /* Common symbols less than or equal to -G nn bytes are
1042 automatically put into .sbss. */
1044 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1048 scomm = bfd_make_section_with_flags (abfd, ".scommon",
1051 | SEC_LINKER_CREATED));
1057 *valp = sym->st_size;
1063 /* Return the number of additional phdrs we will need. */
1066 elfNN_ia64_additional_program_headers (bfd *abfd,
1067 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1072 /* See if we need a PT_IA_64_ARCHEXT segment. */
1073 s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_archext);
1074 if (s && (s->flags & SEC_LOAD))
1077 /* Count how many PT_IA_64_UNWIND segments we need. */
1078 for (s = abfd->sections; s; s = s->next)
1079 if (is_unwind_section_name (abfd, s->name) && (s->flags & SEC_LOAD))
1086 elfNN_ia64_modify_segment_map (bfd *abfd,
1087 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1089 struct elf_segment_map *m, **pm;
1090 Elf_Internal_Shdr *hdr;
1093 /* If we need a PT_IA_64_ARCHEXT segment, it must come before
1094 all PT_LOAD segments. */
1095 s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_archext);
1096 if (s && (s->flags & SEC_LOAD))
1098 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
1099 if (m->p_type == PT_IA_64_ARCHEXT)
1103 m = ((struct elf_segment_map *)
1104 bfd_zalloc (abfd, (bfd_size_type) sizeof *m));
1108 m->p_type = PT_IA_64_ARCHEXT;
1112 /* We want to put it after the PHDR and INTERP segments. */
1113 pm = &elf_seg_map (abfd);
1115 && ((*pm)->p_type == PT_PHDR
1116 || (*pm)->p_type == PT_INTERP))
1124 /* Install PT_IA_64_UNWIND segments, if needed. */
1125 for (s = abfd->sections; s; s = s->next)
1127 hdr = &elf_section_data (s)->this_hdr;
1128 if (hdr->sh_type != SHT_IA_64_UNWIND)
1131 if (s && (s->flags & SEC_LOAD))
1133 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
1134 if (m->p_type == PT_IA_64_UNWIND)
1138 /* Look through all sections in the unwind segment
1139 for a match since there may be multiple sections
1141 for (i = m->count - 1; i >= 0; --i)
1142 if (m->sections[i] == s)
1151 m = ((struct elf_segment_map *)
1152 bfd_zalloc (abfd, (bfd_size_type) sizeof *m));
1156 m->p_type = PT_IA_64_UNWIND;
1161 /* We want to put it last. */
1162 pm = &elf_seg_map (abfd);
1173 /* Turn on PF_IA_64_NORECOV if needed. This involves traversing all of
1174 the input sections for each output section in the segment and testing
1175 for SHF_IA_64_NORECOV on each. */
1178 elfNN_ia64_modify_program_headers (bfd *abfd,
1179 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1181 struct elf_obj_tdata *tdata = elf_tdata (abfd);
1182 struct elf_segment_map *m;
1183 Elf_Internal_Phdr *p;
1185 for (p = tdata->phdr, m = elf_seg_map (abfd); m != NULL; m = m->next, p++)
1186 if (m->p_type == PT_LOAD)
1189 for (i = m->count - 1; i >= 0; --i)
1191 struct bfd_link_order *order = m->sections[i]->map_head.link_order;
1193 while (order != NULL)
1195 if (order->type == bfd_indirect_link_order)
1197 asection *is = order->u.indirect.section;
1198 bfd_vma flags = elf_section_data(is)->this_hdr.sh_flags;
1199 if (flags & SHF_IA_64_NORECOV)
1201 p->p_flags |= PF_IA_64_NORECOV;
1205 order = order->next;
1214 /* According to the Tahoe assembler spec, all labels starting with a
1218 elfNN_ia64_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
1221 return name[0] == '.';
1224 /* Should we do dynamic things to this symbol? */
1227 elfNN_ia64_dynamic_symbol_p (struct elf_link_hash_entry *h,
1228 struct bfd_link_info *info, int r_type)
1230 bfd_boolean ignore_protected
1231 = ((r_type & 0xf8) == 0x40 /* FPTR relocs */
1232 || (r_type & 0xf8) == 0x50); /* LTOFF_FPTR relocs */
1234 return _bfd_elf_dynamic_symbol_p (h, info, ignore_protected);
1237 static struct bfd_hash_entry*
1238 elfNN_ia64_new_elf_hash_entry (struct bfd_hash_entry *entry,
1239 struct bfd_hash_table *table,
1242 struct elfNN_ia64_link_hash_entry *ret;
1243 ret = (struct elfNN_ia64_link_hash_entry *) entry;
1245 /* Allocate the structure if it has not already been allocated by a
1248 ret = bfd_hash_allocate (table, sizeof (*ret));
1253 /* Call the allocation method of the superclass. */
1254 ret = ((struct elfNN_ia64_link_hash_entry *)
1255 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1260 ret->sorted_count = 0;
1262 return (struct bfd_hash_entry *) ret;
1266 elfNN_ia64_hash_copy_indirect (struct bfd_link_info *info,
1267 struct elf_link_hash_entry *xdir,
1268 struct elf_link_hash_entry *xind)
1270 struct elfNN_ia64_link_hash_entry *dir, *ind;
1272 dir = (struct elfNN_ia64_link_hash_entry *) xdir;
1273 ind = (struct elfNN_ia64_link_hash_entry *) xind;
1275 /* Copy down any references that we may have already seen to the
1276 symbol which just became indirect. */
1278 if (dir->root.versioned != versioned_hidden)
1279 dir->root.ref_dynamic |= ind->root.ref_dynamic;
1280 dir->root.ref_regular |= ind->root.ref_regular;
1281 dir->root.ref_regular_nonweak |= ind->root.ref_regular_nonweak;
1282 dir->root.needs_plt |= ind->root.needs_plt;
1284 if (ind->root.root.type != bfd_link_hash_indirect)
1287 /* Copy over the got and plt data. This would have been done
1290 if (ind->info != NULL)
1292 struct elfNN_ia64_dyn_sym_info *dyn_i;
1298 dir->info = ind->info;
1299 dir->count = ind->count;
1300 dir->sorted_count = ind->sorted_count;
1301 dir->size = ind->size;
1305 ind->sorted_count = 0;
1308 /* Fix up the dyn_sym_info pointers to the global symbol. */
1309 for (count = dir->count, dyn_i = dir->info;
1312 dyn_i->h = &dir->root;
1315 /* Copy over the dynindx. */
1317 if (ind->root.dynindx != -1)
1319 if (dir->root.dynindx != -1)
1320 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1321 dir->root.dynstr_index);
1322 dir->root.dynindx = ind->root.dynindx;
1323 dir->root.dynstr_index = ind->root.dynstr_index;
1324 ind->root.dynindx = -1;
1325 ind->root.dynstr_index = 0;
1330 elfNN_ia64_hash_hide_symbol (struct bfd_link_info *info,
1331 struct elf_link_hash_entry *xh,
1332 bfd_boolean force_local)
1334 struct elfNN_ia64_link_hash_entry *h;
1335 struct elfNN_ia64_dyn_sym_info *dyn_i;
1338 h = (struct elfNN_ia64_link_hash_entry *)xh;
1340 _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local);
1342 for (count = h->count, dyn_i = h->info;
1346 dyn_i->want_plt2 = 0;
1347 dyn_i->want_plt = 0;
1351 /* Compute a hash of a local hash entry. */
1354 elfNN_ia64_local_htab_hash (const void *ptr)
1356 struct elfNN_ia64_local_hash_entry *entry
1357 = (struct elfNN_ia64_local_hash_entry *) ptr;
1359 return ELF_LOCAL_SYMBOL_HASH (entry->id, entry->r_sym);
1362 /* Compare local hash entries. */
1365 elfNN_ia64_local_htab_eq (const void *ptr1, const void *ptr2)
1367 struct elfNN_ia64_local_hash_entry *entry1
1368 = (struct elfNN_ia64_local_hash_entry *) ptr1;
1369 struct elfNN_ia64_local_hash_entry *entry2
1370 = (struct elfNN_ia64_local_hash_entry *) ptr2;
1372 return entry1->id == entry2->id && entry1->r_sym == entry2->r_sym;
1375 /* Free the global elfNN_ia64_dyn_sym_info array. */
1378 elfNN_ia64_global_dyn_info_free (void **xentry,
1379 void * unused ATTRIBUTE_UNUSED)
1381 struct elfNN_ia64_link_hash_entry *entry
1382 = (struct elfNN_ia64_link_hash_entry *) xentry;
1389 entry->sorted_count = 0;
1396 /* Free the local elfNN_ia64_dyn_sym_info array. */
1399 elfNN_ia64_local_dyn_info_free (void **slot,
1400 void * unused ATTRIBUTE_UNUSED)
1402 struct elfNN_ia64_local_hash_entry *entry
1403 = (struct elfNN_ia64_local_hash_entry *) *slot;
1410 entry->sorted_count = 0;
1417 /* Destroy IA-64 linker hash table. */
1420 elfNN_ia64_link_hash_table_free (bfd *obfd)
1422 struct elfNN_ia64_link_hash_table *ia64_info
1423 = (struct elfNN_ia64_link_hash_table *) obfd->link.hash;
1424 if (ia64_info->loc_hash_table)
1426 htab_traverse (ia64_info->loc_hash_table,
1427 elfNN_ia64_local_dyn_info_free, NULL);
1428 htab_delete (ia64_info->loc_hash_table);
1430 if (ia64_info->loc_hash_memory)
1431 objalloc_free ((struct objalloc *) ia64_info->loc_hash_memory);
1432 elf_link_hash_traverse (&ia64_info->root,
1433 elfNN_ia64_global_dyn_info_free, NULL);
1434 _bfd_elf_link_hash_table_free (obfd);
1437 /* Create the derived linker hash table. The IA-64 ELF port uses this
1438 derived hash table to keep information specific to the IA-64 ElF
1439 linker (without using static variables). */
1441 static struct bfd_link_hash_table *
1442 elfNN_ia64_hash_table_create (bfd *abfd)
1444 struct elfNN_ia64_link_hash_table *ret;
1446 ret = bfd_zmalloc ((bfd_size_type) sizeof (*ret));
1450 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
1451 elfNN_ia64_new_elf_hash_entry,
1452 sizeof (struct elfNN_ia64_link_hash_entry),
1459 ret->loc_hash_table = htab_try_create (1024, elfNN_ia64_local_htab_hash,
1460 elfNN_ia64_local_htab_eq, NULL);
1461 ret->loc_hash_memory = objalloc_create ();
1462 if (!ret->loc_hash_table || !ret->loc_hash_memory)
1464 elfNN_ia64_link_hash_table_free (abfd);
1467 ret->root.root.hash_table_free = elfNN_ia64_link_hash_table_free;
1469 return &ret->root.root;
1472 /* Traverse both local and global hash tables. */
1474 struct elfNN_ia64_dyn_sym_traverse_data
1476 bfd_boolean (*func) (struct elfNN_ia64_dyn_sym_info *, void *);
1481 elfNN_ia64_global_dyn_sym_thunk (struct bfd_hash_entry *xentry,
1484 struct elfNN_ia64_link_hash_entry *entry
1485 = (struct elfNN_ia64_link_hash_entry *) xentry;
1486 struct elfNN_ia64_dyn_sym_traverse_data *data
1487 = (struct elfNN_ia64_dyn_sym_traverse_data *) xdata;
1488 struct elfNN_ia64_dyn_sym_info *dyn_i;
1491 for (count = entry->count, dyn_i = entry->info;
1494 if (! (*data->func) (dyn_i, data->data))
1500 elfNN_ia64_local_dyn_sym_thunk (void **slot, void * xdata)
1502 struct elfNN_ia64_local_hash_entry *entry
1503 = (struct elfNN_ia64_local_hash_entry *) *slot;
1504 struct elfNN_ia64_dyn_sym_traverse_data *data
1505 = (struct elfNN_ia64_dyn_sym_traverse_data *) xdata;
1506 struct elfNN_ia64_dyn_sym_info *dyn_i;
1509 for (count = entry->count, dyn_i = entry->info;
1512 if (! (*data->func) (dyn_i, data->data))
1518 elfNN_ia64_dyn_sym_traverse (struct elfNN_ia64_link_hash_table *ia64_info,
1519 bfd_boolean (*func) (struct elfNN_ia64_dyn_sym_info *, void *),
1522 struct elfNN_ia64_dyn_sym_traverse_data xdata;
1527 elf_link_hash_traverse (&ia64_info->root,
1528 elfNN_ia64_global_dyn_sym_thunk, &xdata);
1529 htab_traverse (ia64_info->loc_hash_table,
1530 elfNN_ia64_local_dyn_sym_thunk, &xdata);
1534 elfNN_ia64_create_dynamic_sections (bfd *abfd,
1535 struct bfd_link_info *info)
1537 struct elfNN_ia64_link_hash_table *ia64_info;
1540 if (! _bfd_elf_create_dynamic_sections (abfd, info))
1543 ia64_info = elfNN_ia64_hash_table (info);
1544 if (ia64_info == NULL)
1548 flagword flags = bfd_get_section_flags (abfd, ia64_info->root.sgot);
1549 bfd_set_section_flags (abfd, ia64_info->root.sgot,
1550 SEC_SMALL_DATA | flags);
1551 /* The .got section is always aligned at 8 bytes. */
1552 if (! bfd_set_section_alignment (abfd, ia64_info->root.sgot, 3))
1556 if (!get_pltoff (abfd, info, ia64_info))
1559 s = bfd_make_section_anyway_with_flags (abfd, ".rela.IA_64.pltoff",
1560 (SEC_ALLOC | SEC_LOAD
1563 | SEC_LINKER_CREATED
1566 || !bfd_set_section_alignment (abfd, s, LOG_SECTION_ALIGN))
1568 ia64_info->rel_pltoff_sec = s;
1573 /* Find and/or create a hash entry for local symbol. */
1574 static struct elfNN_ia64_local_hash_entry *
1575 get_local_sym_hash (struct elfNN_ia64_link_hash_table *ia64_info,
1576 bfd *abfd, const Elf_Internal_Rela *rel,
1579 struct elfNN_ia64_local_hash_entry e, *ret;
1580 asection *sec = abfd->sections;
1581 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
1582 ELFNN_R_SYM (rel->r_info));
1586 e.r_sym = ELFNN_R_SYM (rel->r_info);
1587 slot = htab_find_slot_with_hash (ia64_info->loc_hash_table, &e, h,
1588 create ? INSERT : NO_INSERT);
1594 return (struct elfNN_ia64_local_hash_entry *) *slot;
1596 ret = (struct elfNN_ia64_local_hash_entry *)
1597 objalloc_alloc ((struct objalloc *) ia64_info->loc_hash_memory,
1598 sizeof (struct elfNN_ia64_local_hash_entry));
1601 memset (ret, 0, sizeof (*ret));
1603 ret->r_sym = ELFNN_R_SYM (rel->r_info);
1609 /* Used to sort elfNN_ia64_dyn_sym_info array. */
1612 addend_compare (const void *xp, const void *yp)
1614 const struct elfNN_ia64_dyn_sym_info *x
1615 = (const struct elfNN_ia64_dyn_sym_info *) xp;
1616 const struct elfNN_ia64_dyn_sym_info *y
1617 = (const struct elfNN_ia64_dyn_sym_info *) yp;
1619 return x->addend < y->addend ? -1 : x->addend > y->addend ? 1 : 0;
1622 /* Sort elfNN_ia64_dyn_sym_info array and remove duplicates. */
1625 sort_dyn_sym_info (struct elfNN_ia64_dyn_sym_info *info,
1628 bfd_vma curr, prev, got_offset;
1629 unsigned int i, kept, dupes, diff, dest, src, len;
1631 qsort (info, count, sizeof (*info), addend_compare);
1633 /* Find the first duplicate. */
1634 prev = info [0].addend;
1635 got_offset = info [0].got_offset;
1636 for (i = 1; i < count; i++)
1638 curr = info [i].addend;
1641 /* For duplicates, make sure that GOT_OFFSET is valid. */
1642 if (got_offset == (bfd_vma) -1)
1643 got_offset = info [i].got_offset;
1646 got_offset = info [i].got_offset;
1650 /* We may move a block of elements to here. */
1653 /* Remove duplicates. */
1658 /* For duplicates, make sure that the kept one has a valid
1661 if (got_offset != (bfd_vma) -1)
1662 info [kept].got_offset = got_offset;
1664 curr = info [i].addend;
1665 got_offset = info [i].got_offset;
1667 /* Move a block of elements whose first one is different from
1671 for (src = i + 1; src < count; src++)
1673 if (info [src].addend != curr)
1675 /* For duplicates, make sure that GOT_OFFSET is
1677 if (got_offset == (bfd_vma) -1)
1678 got_offset = info [src].got_offset;
1681 /* Make sure that the kept one has a valid got_offset. */
1682 if (got_offset != (bfd_vma) -1)
1683 info [kept].got_offset = got_offset;
1691 /* Find the next duplicate. SRC will be kept. */
1692 prev = info [src].addend;
1693 got_offset = info [src].got_offset;
1694 for (dupes = src + 1; dupes < count; dupes ++)
1696 curr = info [dupes].addend;
1699 /* Make sure that got_offset is valid. */
1700 if (got_offset == (bfd_vma) -1)
1701 got_offset = info [dupes].got_offset;
1703 /* For duplicates, make sure that the kept one has
1704 a valid got_offset. */
1705 if (got_offset != (bfd_vma) -1)
1706 info [dupes - 1].got_offset = got_offset;
1709 got_offset = info [dupes].got_offset;
1713 /* How much to move. */
1717 if (len == 1 && dupes < count)
1719 /* If we only move 1 element, we combine it with the next
1720 one. There must be at least a duplicate. Find the
1721 next different one. */
1722 for (diff = dupes + 1, src++; diff < count; diff++, src++)
1724 if (info [diff].addend != curr)
1726 /* Make sure that got_offset is valid. */
1727 if (got_offset == (bfd_vma) -1)
1728 got_offset = info [diff].got_offset;
1731 /* Makre sure that the last duplicated one has an valid
1733 BFD_ASSERT (curr == prev);
1734 if (got_offset != (bfd_vma) -1)
1735 info [diff - 1].got_offset = got_offset;
1739 /* Find the next duplicate. Track the current valid
1741 prev = info [diff].addend;
1742 got_offset = info [diff].got_offset;
1743 for (dupes = diff + 1; dupes < count; dupes ++)
1745 curr = info [dupes].addend;
1748 /* For duplicates, make sure that GOT_OFFSET
1750 if (got_offset == (bfd_vma) -1)
1751 got_offset = info [dupes].got_offset;
1754 got_offset = info [dupes].got_offset;
1759 len = diff - src + 1;
1764 memmove (&info [dest], &info [src], len * sizeof (*info));
1773 /* When we get here, either there is no duplicate at all or
1774 the only duplicate is the last element. */
1777 /* If the last element is a duplicate, make sure that the
1778 kept one has a valid got_offset. We also update count. */
1779 if (got_offset != (bfd_vma) -1)
1780 info [dest - 1].got_offset = got_offset;
1788 /* Find and/or create a descriptor for dynamic symbol info. This will
1789 vary based on global or local symbol, and the addend to the reloc.
1791 We don't sort when inserting. Also, we sort and eliminate
1792 duplicates if there is an unsorted section. Typically, this will
1793 only happen once, because we do all insertions before lookups. We
1794 then use bsearch to do a lookup. This also allows lookups to be
1795 fast. So we have fast insertion (O(log N) due to duplicate check),
1796 fast lookup (O(log N)) and one sort (O(N log N) expected time).
1797 Previously, all lookups were O(N) because of the use of the linked
1798 list and also all insertions were O(N) because of the check for
1799 duplicates. There are some complications here because the array
1800 size grows occasionally, which may add an O(N) factor, but this
1801 should be rare. Also, we free the excess array allocation, which
1802 requires a copy which is O(N), but this only happens once. */
1804 static struct elfNN_ia64_dyn_sym_info *
1805 get_dyn_sym_info (struct elfNN_ia64_link_hash_table *ia64_info,
1806 struct elf_link_hash_entry *h, bfd *abfd,
1807 const Elf_Internal_Rela *rel, bfd_boolean create)
1809 struct elfNN_ia64_dyn_sym_info **info_p, *info, *dyn_i, key;
1810 unsigned int *count_p, *sorted_count_p, *size_p;
1811 unsigned int count, sorted_count, size;
1812 bfd_vma addend = rel ? rel->r_addend : 0;
1817 struct elfNN_ia64_link_hash_entry *global_h;
1819 global_h = (struct elfNN_ia64_link_hash_entry *) h;
1820 info_p = &global_h->info;
1821 count_p = &global_h->count;
1822 sorted_count_p = &global_h->sorted_count;
1823 size_p = &global_h->size;
1827 struct elfNN_ia64_local_hash_entry *loc_h;
1829 loc_h = get_local_sym_hash (ia64_info, abfd, rel, create);
1832 BFD_ASSERT (!create);
1836 info_p = &loc_h->info;
1837 count_p = &loc_h->count;
1838 sorted_count_p = &loc_h->sorted_count;
1839 size_p = &loc_h->size;
1843 sorted_count = *sorted_count_p;
1848 /* When we create the array, we don't check for duplicates,
1849 except in the previously sorted section if one exists, and
1850 against the last inserted entry. This allows insertions to
1856 /* Try bsearch first on the sorted section. */
1857 key.addend = addend;
1858 dyn_i = bsearch (&key, info, sorted_count,
1859 sizeof (*info), addend_compare);
1867 /* Do a quick check for the last inserted entry. */
1868 dyn_i = info + count - 1;
1869 if (dyn_i->addend == addend)
1877 /* It is the very first element. We create the array of size
1880 amt = size * sizeof (*info);
1881 info = bfd_malloc (amt);
1883 else if (size <= count)
1885 /* We double the array size every time when we reach the
1888 amt = size * sizeof (*info);
1889 info = bfd_realloc (info, amt);
1900 /* Append the new one to the array. */
1901 dyn_i = info + count;
1902 memset (dyn_i, 0, sizeof (*dyn_i));
1903 dyn_i->got_offset = (bfd_vma) -1;
1904 dyn_i->addend = addend;
1906 /* We increment count only since the new ones are unsorted and
1907 may have duplicate. */
1912 /* It is a lookup without insertion. Sort array if part of the
1913 array isn't sorted. */
1914 if (count != sorted_count)
1916 count = sort_dyn_sym_info (info, count);
1918 *sorted_count_p = count;
1921 /* Free unused memory. */
1924 amt = count * sizeof (*info);
1925 info = bfd_malloc (amt);
1928 memcpy (info, *info_p, amt);
1935 key.addend = addend;
1936 dyn_i = bsearch (&key, info, count,
1937 sizeof (*info), addend_compare);
1944 get_got (bfd *abfd, struct bfd_link_info *info,
1945 struct elfNN_ia64_link_hash_table *ia64_info)
1950 got = ia64_info->root.sgot;
1955 dynobj = ia64_info->root.dynobj;
1957 ia64_info->root.dynobj = dynobj = abfd;
1958 if (!_bfd_elf_create_got_section (dynobj, info))
1961 got = ia64_info->root.sgot;
1963 /* The .got section is always aligned at 8 bytes. */
1964 if (!bfd_set_section_alignment (abfd, got, 3))
1967 flags = bfd_get_section_flags (abfd, got);
1968 if (! bfd_set_section_flags (abfd, got, SEC_SMALL_DATA | flags))
1975 /* Create function descriptor section (.opd). This section is called .opd
1976 because it contains "official procedure descriptors". The "official"
1977 refers to the fact that these descriptors are used when taking the address
1978 of a procedure, thus ensuring a unique address for each procedure. */
1981 get_fptr (bfd *abfd, struct bfd_link_info *info,
1982 struct elfNN_ia64_link_hash_table *ia64_info)
1987 fptr = ia64_info->fptr_sec;
1990 dynobj = ia64_info->root.dynobj;
1992 ia64_info->root.dynobj = dynobj = abfd;
1994 fptr = bfd_make_section_anyway_with_flags (dynobj, ".opd",
1999 | (bfd_link_pie (info)
2001 | SEC_LINKER_CREATED));
2003 || !bfd_set_section_alignment (abfd, fptr, 4))
2009 ia64_info->fptr_sec = fptr;
2011 if (bfd_link_pie (info))
2014 fptr_rel = bfd_make_section_anyway_with_flags (dynobj, ".rela.opd",
2015 (SEC_ALLOC | SEC_LOAD
2018 | SEC_LINKER_CREATED
2020 if (fptr_rel == NULL
2021 || !bfd_set_section_alignment (abfd, fptr_rel,
2028 ia64_info->rel_fptr_sec = fptr_rel;
2036 get_pltoff (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED,
2037 struct elfNN_ia64_link_hash_table *ia64_info)
2042 pltoff = ia64_info->pltoff_sec;
2045 dynobj = ia64_info->root.dynobj;
2047 ia64_info->root.dynobj = dynobj = abfd;
2049 pltoff = bfd_make_section_anyway_with_flags (dynobj,
2050 ELF_STRING_ia64_pltoff,
2056 | SEC_LINKER_CREATED));
2058 || !bfd_set_section_alignment (abfd, pltoff, 4))
2064 ia64_info->pltoff_sec = pltoff;
2071 get_reloc_section (bfd *abfd,
2072 struct elfNN_ia64_link_hash_table *ia64_info,
2073 asection *sec, bfd_boolean create)
2075 const char *srel_name;
2079 srel_name = (bfd_elf_string_from_elf_section
2080 (abfd, elf_elfheader(abfd)->e_shstrndx,
2081 _bfd_elf_single_rel_hdr (sec)->sh_name));
2082 if (srel_name == NULL)
2085 dynobj = ia64_info->root.dynobj;
2087 ia64_info->root.dynobj = dynobj = abfd;
2089 srel = bfd_get_linker_section (dynobj, srel_name);
2090 if (srel == NULL && create)
2092 srel = bfd_make_section_anyway_with_flags (dynobj, srel_name,
2093 (SEC_ALLOC | SEC_LOAD
2096 | SEC_LINKER_CREATED
2099 || !bfd_set_section_alignment (dynobj, srel,
2108 count_dyn_reloc (bfd *abfd, struct elfNN_ia64_dyn_sym_info *dyn_i,
2109 asection *srel, int type, bfd_boolean reltext)
2111 struct elfNN_ia64_dyn_reloc_entry *rent;
2113 for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
2114 if (rent->srel == srel && rent->type == type)
2119 rent = ((struct elfNN_ia64_dyn_reloc_entry *)
2120 bfd_alloc (abfd, (bfd_size_type) sizeof (*rent)));
2124 rent->next = dyn_i->reloc_entries;
2128 dyn_i->reloc_entries = rent;
2130 rent->reltext = reltext;
2137 elfNN_ia64_check_relocs (bfd *abfd, struct bfd_link_info *info,
2139 const Elf_Internal_Rela *relocs)
2141 struct elfNN_ia64_link_hash_table *ia64_info;
2142 const Elf_Internal_Rela *relend;
2143 Elf_Internal_Shdr *symtab_hdr;
2144 const Elf_Internal_Rela *rel;
2145 asection *got, *fptr, *srel, *pltoff;
2154 NEED_LTOFF_FPTR = 128,
2160 struct elf_link_hash_entry *h;
2161 unsigned long r_symndx;
2162 bfd_boolean maybe_dynamic;
2164 if (bfd_link_relocatable (info))
2167 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2168 ia64_info = elfNN_ia64_hash_table (info);
2169 if (ia64_info == NULL)
2172 got = fptr = srel = pltoff = NULL;
2174 relend = relocs + sec->reloc_count;
2176 /* We scan relocations first to create dynamic relocation arrays. We
2177 modified get_dyn_sym_info to allow fast insertion and support fast
2178 lookup in the next loop. */
2179 for (rel = relocs; rel < relend; ++rel)
2181 r_symndx = ELFNN_R_SYM (rel->r_info);
2182 if (r_symndx >= symtab_hdr->sh_info)
2184 long indx = r_symndx - symtab_hdr->sh_info;
2185 h = elf_sym_hashes (abfd)[indx];
2186 while (h->root.type == bfd_link_hash_indirect
2187 || h->root.type == bfd_link_hash_warning)
2188 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2193 if (h && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
2196 /* We can only get preliminary data on whether a symbol is
2197 locally or externally defined, as not all of the input files
2198 have yet been processed. Do something with what we know, as
2199 this may help reduce memory usage and processing time later. */
2200 maybe_dynamic = (h && ((!bfd_link_executable (info)
2201 && (!SYMBOLIC_BIND (info, h)
2202 || info->unresolved_syms_in_shared_libs == RM_IGNORE))
2204 || h->root.type == bfd_link_hash_defweak));
2207 switch (ELFNN_R_TYPE (rel->r_info))
2209 case R_IA64_TPREL64MSB:
2210 case R_IA64_TPREL64LSB:
2211 if (bfd_link_pic (info) || maybe_dynamic)
2212 need_entry = NEED_DYNREL;
2215 case R_IA64_LTOFF_TPREL22:
2216 need_entry = NEED_TPREL;
2217 if (bfd_link_pic (info))
2218 info->flags |= DF_STATIC_TLS;
2221 case R_IA64_DTPREL32MSB:
2222 case R_IA64_DTPREL32LSB:
2223 case R_IA64_DTPREL64MSB:
2224 case R_IA64_DTPREL64LSB:
2225 if (bfd_link_pic (info) || maybe_dynamic)
2226 need_entry = NEED_DYNREL;
2229 case R_IA64_LTOFF_DTPREL22:
2230 need_entry = NEED_DTPREL;
2233 case R_IA64_DTPMOD64MSB:
2234 case R_IA64_DTPMOD64LSB:
2235 if (bfd_link_pic (info) || maybe_dynamic)
2236 need_entry = NEED_DYNREL;
2239 case R_IA64_LTOFF_DTPMOD22:
2240 need_entry = NEED_DTPMOD;
2243 case R_IA64_LTOFF_FPTR22:
2244 case R_IA64_LTOFF_FPTR64I:
2245 case R_IA64_LTOFF_FPTR32MSB:
2246 case R_IA64_LTOFF_FPTR32LSB:
2247 case R_IA64_LTOFF_FPTR64MSB:
2248 case R_IA64_LTOFF_FPTR64LSB:
2249 need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR;
2252 case R_IA64_FPTR64I:
2253 case R_IA64_FPTR32MSB:
2254 case R_IA64_FPTR32LSB:
2255 case R_IA64_FPTR64MSB:
2256 case R_IA64_FPTR64LSB:
2257 if (bfd_link_pic (info) || h)
2258 need_entry = NEED_FPTR | NEED_DYNREL;
2260 need_entry = NEED_FPTR;
2263 case R_IA64_LTOFF22:
2264 case R_IA64_LTOFF64I:
2265 need_entry = NEED_GOT;
2268 case R_IA64_LTOFF22X:
2269 need_entry = NEED_GOTX;
2272 case R_IA64_PLTOFF22:
2273 case R_IA64_PLTOFF64I:
2274 case R_IA64_PLTOFF64MSB:
2275 case R_IA64_PLTOFF64LSB:
2276 need_entry = NEED_PLTOFF;
2280 need_entry |= NEED_MIN_PLT;
2284 (*info->callbacks->warning)
2285 (info, _("@pltoff reloc against local symbol"), 0,
2286 abfd, 0, (bfd_vma) 0);
2290 case R_IA64_PCREL21B:
2291 case R_IA64_PCREL60B:
2292 /* Depending on where this symbol is defined, we may or may not
2293 need a full plt entry. Only skip if we know we'll not need
2294 the entry -- static or symbolic, and the symbol definition
2295 has already been seen. */
2296 if (maybe_dynamic && rel->r_addend == 0)
2297 need_entry = NEED_FULL_PLT;
2303 case R_IA64_DIR32MSB:
2304 case R_IA64_DIR32LSB:
2305 case R_IA64_DIR64MSB:
2306 case R_IA64_DIR64LSB:
2307 /* Shared objects will always need at least a REL relocation. */
2308 if (bfd_link_pic (info) || maybe_dynamic)
2309 need_entry = NEED_DYNREL;
2312 case R_IA64_IPLTMSB:
2313 case R_IA64_IPLTLSB:
2314 /* Shared objects will always need at least a REL relocation. */
2315 if (bfd_link_pic (info) || maybe_dynamic)
2316 need_entry = NEED_DYNREL;
2319 case R_IA64_PCREL22:
2320 case R_IA64_PCREL64I:
2321 case R_IA64_PCREL32MSB:
2322 case R_IA64_PCREL32LSB:
2323 case R_IA64_PCREL64MSB:
2324 case R_IA64_PCREL64LSB:
2326 need_entry = NEED_DYNREL;
2333 if ((need_entry & NEED_FPTR) != 0
2336 (*info->callbacks->warning)
2337 (info, _("non-zero addend in @fptr reloc"), 0,
2338 abfd, 0, (bfd_vma) 0);
2341 if (get_dyn_sym_info (ia64_info, h, abfd, rel, TRUE) == NULL)
2345 /* Now, we only do lookup without insertion, which is very fast
2346 with the modified get_dyn_sym_info. */
2347 for (rel = relocs; rel < relend; ++rel)
2349 struct elfNN_ia64_dyn_sym_info *dyn_i;
2350 int dynrel_type = R_IA64_NONE;
2352 r_symndx = ELFNN_R_SYM (rel->r_info);
2353 if (r_symndx >= symtab_hdr->sh_info)
2355 /* We're dealing with a global symbol -- find its hash entry
2356 and mark it as being referenced. */
2357 long indx = r_symndx - symtab_hdr->sh_info;
2358 h = elf_sym_hashes (abfd)[indx];
2359 while (h->root.type == bfd_link_hash_indirect
2360 || h->root.type == bfd_link_hash_warning)
2361 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2363 /* PR15323, ref flags aren't set for references in the same
2370 if (h && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
2373 /* We can only get preliminary data on whether a symbol is
2374 locally or externally defined, as not all of the input files
2375 have yet been processed. Do something with what we know, as
2376 this may help reduce memory usage and processing time later. */
2377 maybe_dynamic = (h && ((!bfd_link_executable (info)
2378 && (!SYMBOLIC_BIND (info, h)
2379 || info->unresolved_syms_in_shared_libs == RM_IGNORE))
2381 || h->root.type == bfd_link_hash_defweak));
2384 switch (ELFNN_R_TYPE (rel->r_info))
2386 case R_IA64_TPREL64MSB:
2387 case R_IA64_TPREL64LSB:
2388 if (bfd_link_pic (info) || maybe_dynamic)
2389 need_entry = NEED_DYNREL;
2390 dynrel_type = R_IA64_TPREL64LSB;
2391 if (bfd_link_pic (info))
2392 info->flags |= DF_STATIC_TLS;
2395 case R_IA64_LTOFF_TPREL22:
2396 need_entry = NEED_TPREL;
2397 if (bfd_link_pic (info))
2398 info->flags |= DF_STATIC_TLS;
2401 case R_IA64_DTPREL32MSB:
2402 case R_IA64_DTPREL32LSB:
2403 case R_IA64_DTPREL64MSB:
2404 case R_IA64_DTPREL64LSB:
2405 if (bfd_link_pic (info) || maybe_dynamic)
2406 need_entry = NEED_DYNREL;
2407 dynrel_type = R_IA64_DTPRELNNLSB;
2410 case R_IA64_LTOFF_DTPREL22:
2411 need_entry = NEED_DTPREL;
2414 case R_IA64_DTPMOD64MSB:
2415 case R_IA64_DTPMOD64LSB:
2416 if (bfd_link_pic (info) || maybe_dynamic)
2417 need_entry = NEED_DYNREL;
2418 dynrel_type = R_IA64_DTPMOD64LSB;
2421 case R_IA64_LTOFF_DTPMOD22:
2422 need_entry = NEED_DTPMOD;
2425 case R_IA64_LTOFF_FPTR22:
2426 case R_IA64_LTOFF_FPTR64I:
2427 case R_IA64_LTOFF_FPTR32MSB:
2428 case R_IA64_LTOFF_FPTR32LSB:
2429 case R_IA64_LTOFF_FPTR64MSB:
2430 case R_IA64_LTOFF_FPTR64LSB:
2431 need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR;
2434 case R_IA64_FPTR64I:
2435 case R_IA64_FPTR32MSB:
2436 case R_IA64_FPTR32LSB:
2437 case R_IA64_FPTR64MSB:
2438 case R_IA64_FPTR64LSB:
2439 if (bfd_link_pic (info) || h)
2440 need_entry = NEED_FPTR | NEED_DYNREL;
2442 need_entry = NEED_FPTR;
2443 dynrel_type = R_IA64_FPTRNNLSB;
2446 case R_IA64_LTOFF22:
2447 case R_IA64_LTOFF64I:
2448 need_entry = NEED_GOT;
2451 case R_IA64_LTOFF22X:
2452 need_entry = NEED_GOTX;
2455 case R_IA64_PLTOFF22:
2456 case R_IA64_PLTOFF64I:
2457 case R_IA64_PLTOFF64MSB:
2458 case R_IA64_PLTOFF64LSB:
2459 need_entry = NEED_PLTOFF;
2463 need_entry |= NEED_MIN_PLT;
2467 case R_IA64_PCREL21B:
2468 case R_IA64_PCREL60B:
2469 /* Depending on where this symbol is defined, we may or may not
2470 need a full plt entry. Only skip if we know we'll not need
2471 the entry -- static or symbolic, and the symbol definition
2472 has already been seen. */
2473 if (maybe_dynamic && rel->r_addend == 0)
2474 need_entry = NEED_FULL_PLT;
2480 case R_IA64_DIR32MSB:
2481 case R_IA64_DIR32LSB:
2482 case R_IA64_DIR64MSB:
2483 case R_IA64_DIR64LSB:
2484 /* Shared objects will always need at least a REL relocation. */
2485 if (bfd_link_pic (info) || maybe_dynamic)
2486 need_entry = NEED_DYNREL;
2487 dynrel_type = R_IA64_DIRNNLSB;
2490 case R_IA64_IPLTMSB:
2491 case R_IA64_IPLTLSB:
2492 /* Shared objects will always need at least a REL relocation. */
2493 if (bfd_link_pic (info) || maybe_dynamic)
2494 need_entry = NEED_DYNREL;
2495 dynrel_type = R_IA64_IPLTLSB;
2498 case R_IA64_PCREL22:
2499 case R_IA64_PCREL64I:
2500 case R_IA64_PCREL32MSB:
2501 case R_IA64_PCREL32LSB:
2502 case R_IA64_PCREL64MSB:
2503 case R_IA64_PCREL64LSB:
2505 need_entry = NEED_DYNREL;
2506 dynrel_type = R_IA64_PCRELNNLSB;
2513 dyn_i = get_dyn_sym_info (ia64_info, h, abfd, rel, FALSE);
2515 /* Record whether or not this is a local symbol. */
2518 /* Create what's needed. */
2519 if (need_entry & (NEED_GOT | NEED_GOTX | NEED_TPREL
2520 | NEED_DTPMOD | NEED_DTPREL))
2524 got = get_got (abfd, info, ia64_info);
2528 if (need_entry & NEED_GOT)
2529 dyn_i->want_got = 1;
2530 if (need_entry & NEED_GOTX)
2531 dyn_i->want_gotx = 1;
2532 if (need_entry & NEED_TPREL)
2533 dyn_i->want_tprel = 1;
2534 if (need_entry & NEED_DTPMOD)
2535 dyn_i->want_dtpmod = 1;
2536 if (need_entry & NEED_DTPREL)
2537 dyn_i->want_dtprel = 1;
2539 if (need_entry & NEED_FPTR)
2543 fptr = get_fptr (abfd, info, ia64_info);
2548 /* FPTRs for shared libraries are allocated by the dynamic
2549 linker. Make sure this local symbol will appear in the
2550 dynamic symbol table. */
2551 if (!h && bfd_link_pic (info))
2553 if (! (bfd_elf_link_record_local_dynamic_symbol
2554 (info, abfd, (long) r_symndx)))
2558 dyn_i->want_fptr = 1;
2560 if (need_entry & NEED_LTOFF_FPTR)
2561 dyn_i->want_ltoff_fptr = 1;
2562 if (need_entry & (NEED_MIN_PLT | NEED_FULL_PLT))
2564 if (!ia64_info->root.dynobj)
2565 ia64_info->root.dynobj = abfd;
2567 dyn_i->want_plt = 1;
2569 if (need_entry & NEED_FULL_PLT)
2570 dyn_i->want_plt2 = 1;
2571 if (need_entry & NEED_PLTOFF)
2573 /* This is needed here, in case @pltoff is used in a non-shared
2577 pltoff = get_pltoff (abfd, info, ia64_info);
2582 dyn_i->want_pltoff = 1;
2584 if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC))
2588 srel = get_reloc_section (abfd, ia64_info, sec, TRUE);
2592 if (!count_dyn_reloc (abfd, dyn_i, srel, dynrel_type,
2593 (sec->flags & SEC_READONLY) != 0))
2601 /* For cleanliness, and potentially faster dynamic loading, allocate
2602 external GOT entries first. */
2605 allocate_global_data_got (struct elfNN_ia64_dyn_sym_info *dyn_i,
2608 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2610 if ((dyn_i->want_got || dyn_i->want_gotx)
2611 && ! dyn_i->want_fptr
2612 && elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
2614 dyn_i->got_offset = x->ofs;
2617 if (dyn_i->want_tprel)
2619 dyn_i->tprel_offset = x->ofs;
2622 if (dyn_i->want_dtpmod)
2624 if (elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
2626 dyn_i->dtpmod_offset = x->ofs;
2631 struct elfNN_ia64_link_hash_table *ia64_info;
2633 ia64_info = elfNN_ia64_hash_table (x->info);
2634 if (ia64_info == NULL)
2637 if (ia64_info->self_dtpmod_offset == (bfd_vma) -1)
2639 ia64_info->self_dtpmod_offset = x->ofs;
2642 dyn_i->dtpmod_offset = ia64_info->self_dtpmod_offset;
2645 if (dyn_i->want_dtprel)
2647 dyn_i->dtprel_offset = x->ofs;
2653 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
2656 allocate_global_fptr_got (struct elfNN_ia64_dyn_sym_info *dyn_i,
2659 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2663 && elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, R_IA64_FPTRNNLSB))
2665 dyn_i->got_offset = x->ofs;
2671 /* Lastly, allocate all the GOT entries for local data. */
2674 allocate_local_got (struct elfNN_ia64_dyn_sym_info *dyn_i,
2677 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2679 if ((dyn_i->want_got || dyn_i->want_gotx)
2680 && !elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
2682 dyn_i->got_offset = x->ofs;
2688 /* Search for the index of a global symbol in it's defining object file. */
2691 global_sym_index (struct elf_link_hash_entry *h)
2693 struct elf_link_hash_entry **p;
2696 BFD_ASSERT (h->root.type == bfd_link_hash_defined
2697 || h->root.type == bfd_link_hash_defweak);
2699 obj = h->root.u.def.section->owner;
2700 for (p = elf_sym_hashes (obj); *p != h; ++p)
2703 return p - elf_sym_hashes (obj) + elf_tdata (obj)->symtab_hdr.sh_info;
2706 /* Allocate function descriptors. We can do these for every function
2707 in a main executable that is not exported. */
2710 allocate_fptr (struct elfNN_ia64_dyn_sym_info *dyn_i, void * data)
2712 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2714 if (dyn_i->want_fptr)
2716 struct elf_link_hash_entry *h = dyn_i->h;
2719 while (h->root.type == bfd_link_hash_indirect
2720 || h->root.type == bfd_link_hash_warning)
2721 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2723 if (!bfd_link_executable (x->info)
2725 || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2726 && !UNDEFWEAK_NO_DYNAMIC_RELOC (x->info, h))
2727 || (h->root.type != bfd_link_hash_undefweak
2728 && h->root.type != bfd_link_hash_undefined)))
2730 if (h && h->dynindx == -1)
2732 BFD_ASSERT ((h->root.type == bfd_link_hash_defined)
2733 || (h->root.type == bfd_link_hash_defweak));
2735 if (!bfd_elf_link_record_local_dynamic_symbol
2736 (x->info, h->root.u.def.section->owner,
2737 global_sym_index (h)))
2741 dyn_i->want_fptr = 0;
2743 else if (h == NULL || h->dynindx == -1)
2745 dyn_i->fptr_offset = x->ofs;
2749 dyn_i->want_fptr = 0;
2754 /* Allocate all the minimal PLT entries. */
2757 allocate_plt_entries (struct elfNN_ia64_dyn_sym_info *dyn_i,
2760 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2762 if (dyn_i->want_plt)
2764 struct elf_link_hash_entry *h = dyn_i->h;
2767 while (h->root.type == bfd_link_hash_indirect
2768 || h->root.type == bfd_link_hash_warning)
2769 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2771 /* ??? Versioned symbols seem to lose NEEDS_PLT. */
2772 if (elfNN_ia64_dynamic_symbol_p (h, x->info, 0))
2774 bfd_size_type offset = x->ofs;
2776 offset = PLT_HEADER_SIZE;
2777 dyn_i->plt_offset = offset;
2778 x->ofs = offset + PLT_MIN_ENTRY_SIZE;
2780 dyn_i->want_pltoff = 1;
2784 dyn_i->want_plt = 0;
2785 dyn_i->want_plt2 = 0;
2791 /* Allocate all the full PLT entries. */
2794 allocate_plt2_entries (struct elfNN_ia64_dyn_sym_info *dyn_i,
2797 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2799 if (dyn_i->want_plt2)
2801 struct elf_link_hash_entry *h = dyn_i->h;
2802 bfd_size_type ofs = x->ofs;
2804 dyn_i->plt2_offset = ofs;
2805 x->ofs = ofs + PLT_FULL_ENTRY_SIZE;
2807 while (h->root.type == bfd_link_hash_indirect
2808 || h->root.type == bfd_link_hash_warning)
2809 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2810 dyn_i->h->plt.offset = ofs;
2815 /* Allocate all the PLTOFF entries requested by relocations and
2816 plt entries. We can't share space with allocated FPTR entries,
2817 because the latter are not necessarily addressable by the GP.
2818 ??? Relaxation might be able to determine that they are. */
2821 allocate_pltoff_entries (struct elfNN_ia64_dyn_sym_info *dyn_i,
2824 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2826 if (dyn_i->want_pltoff)
2828 dyn_i->pltoff_offset = x->ofs;
2834 /* Allocate dynamic relocations for those symbols that turned out
2838 allocate_dynrel_entries (struct elfNN_ia64_dyn_sym_info *dyn_i,
2841 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2842 struct elfNN_ia64_link_hash_table *ia64_info;
2843 struct elfNN_ia64_dyn_reloc_entry *rent;
2844 bfd_boolean dynamic_symbol, shared, resolved_zero;
2846 ia64_info = elfNN_ia64_hash_table (x->info);
2847 if (ia64_info == NULL)
2850 /* Note that this can't be used in relation to FPTR relocs below. */
2851 dynamic_symbol = elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0);
2853 shared = bfd_link_pic (x->info);
2854 resolved_zero = (dyn_i->h
2855 && UNDEFWEAK_NO_DYNAMIC_RELOC (x->info,
2858 /* Take care of the GOT and PLT relocations. */
2861 && (dynamic_symbol || shared)
2862 && (dyn_i->want_got || dyn_i->want_gotx))
2863 || (dyn_i->want_ltoff_fptr
2865 && dyn_i->h->dynindx != -1))
2867 if (!dyn_i->want_ltoff_fptr
2868 || !bfd_link_pie (x->info)
2870 || dyn_i->h->root.type != bfd_link_hash_undefweak)
2871 ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela);
2873 if ((dynamic_symbol || shared) && dyn_i->want_tprel)
2874 ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela);
2875 if (dynamic_symbol && dyn_i->want_dtpmod)
2876 ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela);
2877 if (dynamic_symbol && dyn_i->want_dtprel)
2878 ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela);
2883 if (ia64_info->rel_fptr_sec && dyn_i->want_fptr)
2885 if (dyn_i->h == NULL || dyn_i->h->root.type != bfd_link_hash_undefweak)
2886 ia64_info->rel_fptr_sec->size += sizeof (ElfNN_External_Rela);
2889 if (!resolved_zero && dyn_i->want_pltoff)
2891 bfd_size_type t = 0;
2893 /* Dynamic symbols get one IPLT relocation. Local symbols in
2894 shared libraries get two REL relocations. Local symbols in
2895 main applications get nothing. */
2897 t = sizeof (ElfNN_External_Rela);
2899 t = 2 * sizeof (ElfNN_External_Rela);
2901 ia64_info->rel_pltoff_sec->size += t;
2904 /* Take care of the normal data relocations. */
2906 for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
2908 int count = rent->count;
2912 case R_IA64_FPTR32LSB:
2913 case R_IA64_FPTR64LSB:
2914 /* Allocate one iff !want_fptr and not PIE, which by this point
2915 will be true only if we're actually allocating one statically
2916 in the main executable. Position independent executables
2917 need a relative reloc. */
2918 if (dyn_i->want_fptr && !bfd_link_pie (x->info))
2921 case R_IA64_PCREL32LSB:
2922 case R_IA64_PCREL64LSB:
2923 if (!dynamic_symbol)
2926 case R_IA64_DIR32LSB:
2927 case R_IA64_DIR64LSB:
2928 if (!dynamic_symbol && !shared)
2931 case R_IA64_IPLTLSB:
2932 if (!dynamic_symbol && !shared)
2934 /* Use two REL relocations for IPLT relocations
2935 against local symbols. */
2936 if (!dynamic_symbol)
2939 case R_IA64_DTPREL32LSB:
2940 case R_IA64_TPREL64LSB:
2941 case R_IA64_DTPREL64LSB:
2942 case R_IA64_DTPMOD64LSB:
2948 ia64_info->reltext = 1;
2949 rent->srel->size += sizeof (ElfNN_External_Rela) * count;
2956 elfNN_ia64_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
2957 struct elf_link_hash_entry *h)
2959 /* ??? Undefined symbols with PLT entries should be re-defined
2960 to be the PLT entry. */
2962 /* If this is a weak symbol, and there is a real definition, the
2963 processor independent code will have arranged for us to see the
2964 real definition first, and we can just use the same value. */
2965 if (h->is_weakalias)
2967 struct elf_link_hash_entry *def = weakdef (h);
2968 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
2969 h->root.u.def.section = def->root.u.def.section;
2970 h->root.u.def.value = def->root.u.def.value;
2974 /* If this is a reference to a symbol defined by a dynamic object which
2975 is not a function, we might allocate the symbol in our .dynbss section
2976 and allocate a COPY dynamic relocation.
2978 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2985 elfNN_ia64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2986 struct bfd_link_info *info)
2988 struct elfNN_ia64_allocate_data data;
2989 struct elfNN_ia64_link_hash_table *ia64_info;
2992 bfd_boolean relplt = FALSE;
2994 ia64_info = elfNN_ia64_hash_table (info);
2995 if (ia64_info == NULL)
2997 dynobj = ia64_info->root.dynobj;
2998 ia64_info->self_dtpmod_offset = (bfd_vma) -1;
2999 BFD_ASSERT(dynobj != NULL);
3002 /* Set the contents of the .interp section to the interpreter. */
3003 if (ia64_info->root.dynamic_sections_created
3004 && bfd_link_executable (info) && !info->nointerp)
3006 sec = bfd_get_linker_section (dynobj, ".interp");
3007 BFD_ASSERT (sec != NULL);
3008 sec->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
3009 sec->size = strlen (ELF_DYNAMIC_INTERPRETER) + 1;
3012 /* Allocate the GOT entries. */
3014 if (ia64_info->root.sgot)
3017 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data);
3018 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data);
3019 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data);
3020 ia64_info->root.sgot->size = data.ofs;
3023 /* Allocate the FPTR entries. */
3025 if (ia64_info->fptr_sec)
3028 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_fptr, &data);
3029 ia64_info->fptr_sec->size = data.ofs;
3032 /* Now that we've seen all of the input files, we can decide which
3033 symbols need plt entries. Allocate the minimal PLT entries first.
3034 We do this even though dynamic_sections_created may be FALSE, because
3035 this has the side-effect of clearing want_plt and want_plt2. */
3038 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_plt_entries, &data);
3040 ia64_info->minplt_entries = 0;
3043 ia64_info->minplt_entries
3044 = (data.ofs - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
3047 /* Align the pointer for the plt2 entries. */
3048 data.ofs = (data.ofs + 31) & (bfd_vma) -32;
3050 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_plt2_entries, &data);
3051 if (data.ofs != 0 || ia64_info->root.dynamic_sections_created)
3053 /* FIXME: we always reserve the memory for dynamic linker even if
3054 there are no PLT entries since dynamic linker may assume the
3055 reserved memory always exists. */
3057 BFD_ASSERT (ia64_info->root.dynamic_sections_created);
3059 ia64_info->root.splt->size = data.ofs;
3061 /* If we've got a .plt, we need some extra memory for the dynamic
3062 linker. We stuff these in .got.plt. */
3063 ia64_info->root.sgotplt->size = 8 * PLT_RESERVED_WORDS;
3066 /* Allocate the PLTOFF entries. */
3068 if (ia64_info->pltoff_sec)
3071 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_pltoff_entries, &data);
3072 ia64_info->pltoff_sec->size = data.ofs;
3075 if (ia64_info->root.dynamic_sections_created)
3077 /* Allocate space for the dynamic relocations that turned out to be
3080 if (bfd_link_pic (info) && ia64_info->self_dtpmod_offset != (bfd_vma) -1)
3081 ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela);
3082 data.only_got = FALSE;
3083 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries, &data);
3086 /* We have now determined the sizes of the various dynamic sections.
3087 Allocate memory for them. */
3088 for (sec = dynobj->sections; sec != NULL; sec = sec->next)
3092 if (!(sec->flags & SEC_LINKER_CREATED))
3095 /* If we don't need this section, strip it from the output file.
3096 There were several sections primarily related to dynamic
3097 linking that must be create before the linker maps input
3098 sections to output sections. The linker does that before
3099 bfd_elf_size_dynamic_sections is called, and it is that
3100 function which decides whether anything needs to go into
3103 strip = (sec->size == 0);
3105 if (sec == ia64_info->root.sgot)
3107 else if (sec == ia64_info->root.srelgot)
3110 ia64_info->root.srelgot = NULL;
3112 /* We use the reloc_count field as a counter if we need to
3113 copy relocs into the output file. */
3114 sec->reloc_count = 0;
3116 else if (sec == ia64_info->fptr_sec)
3119 ia64_info->fptr_sec = NULL;
3121 else if (sec == ia64_info->rel_fptr_sec)
3124 ia64_info->rel_fptr_sec = NULL;
3126 /* We use the reloc_count field as a counter if we need to
3127 copy relocs into the output file. */
3128 sec->reloc_count = 0;
3130 else if (sec == ia64_info->root.splt)
3133 ia64_info->root.splt = NULL;
3135 else if (sec == ia64_info->pltoff_sec)
3138 ia64_info->pltoff_sec = NULL;
3140 else if (sec == ia64_info->rel_pltoff_sec)
3143 ia64_info->rel_pltoff_sec = NULL;
3147 /* We use the reloc_count field as a counter if we need to
3148 copy relocs into the output file. */
3149 sec->reloc_count = 0;
3156 /* It's OK to base decisions on the section name, because none
3157 of the dynobj section names depend upon the input files. */
3158 name = bfd_get_section_name (dynobj, sec);
3160 if (strcmp (name, ".got.plt") == 0)
3162 else if (CONST_STRNEQ (name, ".rel"))
3166 /* We use the reloc_count field as a counter if we need to
3167 copy relocs into the output file. */
3168 sec->reloc_count = 0;
3176 sec->flags |= SEC_EXCLUDE;
3179 /* Allocate memory for the section contents. */
3180 sec->contents = (bfd_byte *) bfd_zalloc (dynobj, sec->size);
3181 if (sec->contents == NULL && sec->size != 0)
3186 if (ia64_info->root.dynamic_sections_created)
3188 /* Add some entries to the .dynamic section. We fill in the values
3189 later (in finish_dynamic_sections) but we must add the entries now
3190 so that we get the correct size for the .dynamic section. */
3192 if (bfd_link_executable (info))
3194 /* The DT_DEBUG entry is filled in by the dynamic linker and used
3196 #define add_dynamic_entry(TAG, VAL) \
3197 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3199 if (!add_dynamic_entry (DT_DEBUG, 0))
3203 if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE, 0))
3205 if (!add_dynamic_entry (DT_PLTGOT, 0))
3210 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3211 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3212 || !add_dynamic_entry (DT_JMPREL, 0))
3216 if (!add_dynamic_entry (DT_RELA, 0)
3217 || !add_dynamic_entry (DT_RELASZ, 0)
3218 || !add_dynamic_entry (DT_RELAENT, sizeof (ElfNN_External_Rela)))
3221 if (ia64_info->reltext)
3223 if (!add_dynamic_entry (DT_TEXTREL, 0))
3225 info->flags |= DF_TEXTREL;
3229 /* ??? Perhaps force __gp local. */
3235 elfNN_ia64_install_dyn_reloc (bfd *abfd, struct bfd_link_info *info,
3236 asection *sec, asection *srel,
3237 bfd_vma offset, unsigned int type,
3238 long dynindx, bfd_vma addend)
3240 Elf_Internal_Rela outrel;
3243 BFD_ASSERT (dynindx != -1);
3244 outrel.r_info = ELFNN_R_INFO (dynindx, type);
3245 outrel.r_addend = addend;
3246 outrel.r_offset = _bfd_elf_section_offset (abfd, info, sec, offset);
3247 if (outrel.r_offset >= (bfd_vma) -2)
3249 /* Run for the hills. We shouldn't be outputting a relocation
3250 for this. So do what everyone else does and output a no-op. */
3251 outrel.r_info = ELFNN_R_INFO (0, R_IA64_NONE);
3252 outrel.r_addend = 0;
3253 outrel.r_offset = 0;
3256 outrel.r_offset += sec->output_section->vma + sec->output_offset;
3258 loc = srel->contents;
3259 loc += srel->reloc_count++ * sizeof (ElfNN_External_Rela);
3260 bfd_elfNN_swap_reloca_out (abfd, &outrel, loc);
3261 BFD_ASSERT (sizeof (ElfNN_External_Rela) * srel->reloc_count <= srel->size);
3264 /* Store an entry for target address TARGET_ADDR in the linkage table
3265 and return the gp-relative address of the linkage table entry. */
3268 set_got_entry (bfd *abfd, struct bfd_link_info *info,
3269 struct elfNN_ia64_dyn_sym_info *dyn_i,
3270 long dynindx, bfd_vma addend, bfd_vma value,
3271 unsigned int dyn_r_type)
3273 struct elfNN_ia64_link_hash_table *ia64_info;
3278 ia64_info = elfNN_ia64_hash_table (info);
3279 if (ia64_info == NULL)
3282 got_sec = ia64_info->root.sgot;
3286 case R_IA64_TPREL64LSB:
3287 done = dyn_i->tprel_done;
3288 dyn_i->tprel_done = TRUE;
3289 got_offset = dyn_i->tprel_offset;
3291 case R_IA64_DTPMOD64LSB:
3292 if (dyn_i->dtpmod_offset != ia64_info->self_dtpmod_offset)
3294 done = dyn_i->dtpmod_done;
3295 dyn_i->dtpmod_done = TRUE;
3299 done = ia64_info->self_dtpmod_done;
3300 ia64_info->self_dtpmod_done = TRUE;
3303 got_offset = dyn_i->dtpmod_offset;
3305 case R_IA64_DTPREL32LSB:
3306 case R_IA64_DTPREL64LSB:
3307 done = dyn_i->dtprel_done;
3308 dyn_i->dtprel_done = TRUE;
3309 got_offset = dyn_i->dtprel_offset;
3312 done = dyn_i->got_done;
3313 dyn_i->got_done = TRUE;
3314 got_offset = dyn_i->got_offset;
3318 BFD_ASSERT ((got_offset & 7) == 0);
3322 /* Store the target address in the linkage table entry. */
3323 bfd_put_64 (abfd, value, got_sec->contents + got_offset);
3325 /* Install a dynamic relocation if needed. */
3326 if (((bfd_link_pic (info)
3328 || (ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
3329 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, dyn_i->h))
3330 || dyn_i->h->root.type != bfd_link_hash_undefweak)
3331 && dyn_r_type != R_IA64_DTPREL32LSB
3332 && dyn_r_type != R_IA64_DTPREL64LSB)
3333 || elfNN_ia64_dynamic_symbol_p (dyn_i->h, info, dyn_r_type)
3335 && (dyn_r_type == R_IA64_FPTR32LSB
3336 || dyn_r_type == R_IA64_FPTR64LSB)))
3337 && (!dyn_i->want_ltoff_fptr
3338 || !bfd_link_pie (info)
3340 || dyn_i->h->root.type != bfd_link_hash_undefweak))
3343 && dyn_r_type != R_IA64_TPREL64LSB
3344 && dyn_r_type != R_IA64_DTPMOD64LSB
3345 && dyn_r_type != R_IA64_DTPREL32LSB
3346 && dyn_r_type != R_IA64_DTPREL64LSB)
3348 dyn_r_type = R_IA64_RELNNLSB;
3353 if (bfd_big_endian (abfd))
3357 case R_IA64_REL32LSB:
3358 dyn_r_type = R_IA64_REL32MSB;
3360 case R_IA64_DIR32LSB:
3361 dyn_r_type = R_IA64_DIR32MSB;
3363 case R_IA64_FPTR32LSB:
3364 dyn_r_type = R_IA64_FPTR32MSB;
3366 case R_IA64_DTPREL32LSB:
3367 dyn_r_type = R_IA64_DTPREL32MSB;
3369 case R_IA64_REL64LSB:
3370 dyn_r_type = R_IA64_REL64MSB;
3372 case R_IA64_DIR64LSB:
3373 dyn_r_type = R_IA64_DIR64MSB;
3375 case R_IA64_FPTR64LSB:
3376 dyn_r_type = R_IA64_FPTR64MSB;
3378 case R_IA64_TPREL64LSB:
3379 dyn_r_type = R_IA64_TPREL64MSB;
3381 case R_IA64_DTPMOD64LSB:
3382 dyn_r_type = R_IA64_DTPMOD64MSB;
3384 case R_IA64_DTPREL64LSB:
3385 dyn_r_type = R_IA64_DTPREL64MSB;
3393 elfNN_ia64_install_dyn_reloc (abfd, NULL, got_sec,
3394 ia64_info->root.srelgot,
3395 got_offset, dyn_r_type,
3400 /* Return the address of the linkage table entry. */
3401 value = (got_sec->output_section->vma
3402 + got_sec->output_offset
3408 /* Fill in a function descriptor consisting of the function's code
3409 address and its global pointer. Return the descriptor's address. */
3412 set_fptr_entry (bfd *abfd, struct bfd_link_info *info,
3413 struct elfNN_ia64_dyn_sym_info *dyn_i,
3416 struct elfNN_ia64_link_hash_table *ia64_info;
3419 ia64_info = elfNN_ia64_hash_table (info);
3420 if (ia64_info == NULL)
3423 fptr_sec = ia64_info->fptr_sec;
3425 if (!dyn_i->fptr_done)
3427 dyn_i->fptr_done = 1;
3429 /* Fill in the function descriptor. */
3430 bfd_put_64 (abfd, value, fptr_sec->contents + dyn_i->fptr_offset);
3431 bfd_put_64 (abfd, _bfd_get_gp_value (abfd),
3432 fptr_sec->contents + dyn_i->fptr_offset + 8);
3433 if (ia64_info->rel_fptr_sec)
3435 Elf_Internal_Rela outrel;
3438 if (bfd_little_endian (abfd))
3439 outrel.r_info = ELFNN_R_INFO (0, R_IA64_IPLTLSB);
3441 outrel.r_info = ELFNN_R_INFO (0, R_IA64_IPLTMSB);
3442 outrel.r_addend = value;
3443 outrel.r_offset = (fptr_sec->output_section->vma
3444 + fptr_sec->output_offset
3445 + dyn_i->fptr_offset);
3446 loc = ia64_info->rel_fptr_sec->contents;
3447 loc += ia64_info->rel_fptr_sec->reloc_count++
3448 * sizeof (ElfNN_External_Rela);
3449 bfd_elfNN_swap_reloca_out (abfd, &outrel, loc);
3453 /* Return the descriptor's address. */
3454 value = (fptr_sec->output_section->vma
3455 + fptr_sec->output_offset
3456 + dyn_i->fptr_offset);
3461 /* Fill in a PLTOFF entry consisting of the function's code address
3462 and its global pointer. Return the descriptor's address. */
3465 set_pltoff_entry (bfd *abfd, struct bfd_link_info *info,
3466 struct elfNN_ia64_dyn_sym_info *dyn_i,
3467 bfd_vma value, bfd_boolean is_plt)
3469 struct elfNN_ia64_link_hash_table *ia64_info;
3470 asection *pltoff_sec;
3472 ia64_info = elfNN_ia64_hash_table (info);
3473 if (ia64_info == NULL)
3476 pltoff_sec = ia64_info->pltoff_sec;
3478 /* Don't do anything if this symbol uses a real PLT entry. In
3479 that case, we'll fill this in during finish_dynamic_symbol. */
3480 if ((! dyn_i->want_plt || is_plt)
3481 && !dyn_i->pltoff_done)
3483 bfd_vma gp = _bfd_get_gp_value (abfd);
3485 /* Fill in the function descriptor. */
3486 bfd_put_64 (abfd, value, pltoff_sec->contents + dyn_i->pltoff_offset);
3487 bfd_put_64 (abfd, gp, pltoff_sec->contents + dyn_i->pltoff_offset + 8);
3489 /* Install dynamic relocations if needed. */
3491 && bfd_link_pic (info)
3493 || (ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
3494 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, dyn_i->h))
3495 || dyn_i->h->root.type != bfd_link_hash_undefweak))
3497 unsigned int dyn_r_type;
3499 if (bfd_big_endian (abfd))
3500 dyn_r_type = R_IA64_RELNNMSB;
3502 dyn_r_type = R_IA64_RELNNLSB;
3504 elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
3505 ia64_info->rel_pltoff_sec,
3506 dyn_i->pltoff_offset,
3507 dyn_r_type, 0, value);
3508 elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
3509 ia64_info->rel_pltoff_sec,
3510 dyn_i->pltoff_offset + ARCH_SIZE / 8,
3514 dyn_i->pltoff_done = 1;
3517 /* Return the descriptor's address. */
3518 value = (pltoff_sec->output_section->vma
3519 + pltoff_sec->output_offset
3520 + dyn_i->pltoff_offset);
3525 /* Return the base VMA address which should be subtracted from real addresses
3526 when resolving @tprel() relocation.
3527 Main program TLS (whose template starts at PT_TLS p_vaddr)
3528 is assigned offset round(2 * size of pointer, PT_TLS p_align). */
3531 elfNN_ia64_tprel_base (struct bfd_link_info *info)
3533 asection *tls_sec = elf_hash_table (info)->tls_sec;
3534 return tls_sec->vma - align_power ((bfd_vma) ARCH_SIZE / 4,
3535 tls_sec->alignment_power);
3538 /* Return the base VMA address which should be subtracted from real addresses
3539 when resolving @dtprel() relocation.
3540 This is PT_TLS segment p_vaddr. */
3543 elfNN_ia64_dtprel_base (struct bfd_link_info *info)
3545 return elf_hash_table (info)->tls_sec->vma;
3548 /* Called through qsort to sort the .IA_64.unwind section during a
3549 non-relocatable link. Set elfNN_ia64_unwind_entry_compare_bfd
3550 to the output bfd so we can do proper endianness frobbing. */
3552 static bfd *elfNN_ia64_unwind_entry_compare_bfd;
3555 elfNN_ia64_unwind_entry_compare (const void * a, const void * b)
3559 av = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, a);
3560 bv = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, b);
3562 return (av < bv ? -1 : av > bv ? 1 : 0);
3565 /* Make sure we've got ourselves a nice fat __gp value. */
3567 elfNN_ia64_choose_gp (bfd *abfd, struct bfd_link_info *info, bfd_boolean final)
3569 bfd_vma min_vma = (bfd_vma) -1, max_vma = 0;
3570 bfd_vma min_short_vma = min_vma, max_short_vma = 0;
3571 struct elf_link_hash_entry *gp;
3574 struct elfNN_ia64_link_hash_table *ia64_info;
3576 ia64_info = elfNN_ia64_hash_table (info);
3577 if (ia64_info == NULL)
3580 /* Find the min and max vma of all sections marked short. Also collect
3581 min and max vma of any type, for use in selecting a nice gp. */
3582 for (os = abfd->sections; os ; os = os->next)
3586 if ((os->flags & SEC_ALLOC) == 0)
3590 /* When this function is called from elfNN_ia64_final_link
3591 the correct value to use is os->size. When called from
3592 elfNN_ia64_relax_section we are in the middle of section
3593 sizing; some sections will already have os->size set, others
3594 will have os->size zero and os->rawsize the previous size. */
3595 hi = os->vma + (!final && os->rawsize ? os->rawsize : os->size);
3603 if (os->flags & SEC_SMALL_DATA)
3605 if (min_short_vma > lo)
3607 if (max_short_vma < hi)
3612 if (ia64_info->min_short_sec)
3615 > (ia64_info->min_short_sec->vma
3616 + ia64_info->min_short_offset))
3617 min_short_vma = (ia64_info->min_short_sec->vma
3618 + ia64_info->min_short_offset);
3620 < (ia64_info->max_short_sec->vma
3621 + ia64_info->max_short_offset))
3622 max_short_vma = (ia64_info->max_short_sec->vma
3623 + ia64_info->max_short_offset);
3626 /* See if the user wants to force a value. */
3627 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
3631 && (gp->root.type == bfd_link_hash_defined
3632 || gp->root.type == bfd_link_hash_defweak))
3634 asection *gp_sec = gp->root.u.def.section;
3635 gp_val = (gp->root.u.def.value
3636 + gp_sec->output_section->vma
3637 + gp_sec->output_offset);
3641 /* Pick a sensible value. */
3643 if (ia64_info->min_short_sec)
3645 bfd_vma short_range = max_short_vma - min_short_vma;
3647 /* If min_short_sec is set, pick one in the middle bewteen
3648 min_short_vma and max_short_vma. */
3649 if (short_range >= 0x400000)
3651 gp_val = min_short_vma + short_range / 2;
3655 asection *got_sec = ia64_info->root.sgot;
3657 /* Start with just the address of the .got. */
3659 gp_val = got_sec->output_section->vma;
3660 else if (max_short_vma != 0)
3661 gp_val = min_short_vma;
3662 else if (max_vma - min_vma < 0x200000)
3665 gp_val = max_vma - 0x200000 + 8;
3668 /* If it is possible to address the entire image, but we
3669 don't with the choice above, adjust. */
3670 if (max_vma - min_vma < 0x400000
3671 && (max_vma - gp_val >= 0x200000
3672 || gp_val - min_vma > 0x200000))
3673 gp_val = min_vma + 0x200000;
3674 else if (max_short_vma != 0)
3676 /* If we don't cover all the short data, adjust. */
3677 if (max_short_vma - gp_val >= 0x200000)
3678 gp_val = min_short_vma + 0x200000;
3680 /* If we're addressing stuff past the end, adjust back. */
3681 if (gp_val > max_vma)
3682 gp_val = max_vma - 0x200000 + 8;
3686 /* Validate whether all SHF_IA_64_SHORT sections are within
3687 range of the chosen GP. */
3689 if (max_short_vma != 0)
3691 if (max_short_vma - min_short_vma >= 0x400000)
3695 /* xgettext:c-format */
3696 (_("%pB: short data segment overflowed (%#Lx >= 0x400000)"),
3697 abfd, max_short_vma - min_short_vma);
3700 else if ((gp_val > min_short_vma
3701 && gp_val - min_short_vma > 0x200000)
3702 || (gp_val < max_short_vma
3703 && max_short_vma - gp_val >= 0x200000))
3706 (_("%pB: __gp does not cover short data segment"), abfd);
3711 _bfd_set_gp_value (abfd, gp_val);
3717 elfNN_ia64_final_link (bfd *abfd, struct bfd_link_info *info)
3719 struct elfNN_ia64_link_hash_table *ia64_info;
3720 asection *unwind_output_sec;
3722 ia64_info = elfNN_ia64_hash_table (info);
3723 if (ia64_info == NULL)
3726 /* Make sure we've got ourselves a nice fat __gp value. */
3727 if (!bfd_link_relocatable (info))
3730 struct elf_link_hash_entry *gp;
3732 /* We assume after gp is set, section size will only decrease. We
3733 need to adjust gp for it. */
3734 _bfd_set_gp_value (abfd, 0);
3735 if (! elfNN_ia64_choose_gp (abfd, info, TRUE))
3737 gp_val = _bfd_get_gp_value (abfd);
3739 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
3743 gp->root.type = bfd_link_hash_defined;
3744 gp->root.u.def.value = gp_val;
3745 gp->root.u.def.section = bfd_abs_section_ptr;
3749 /* If we're producing a final executable, we need to sort the contents
3750 of the .IA_64.unwind section. Force this section to be relocated
3751 into memory rather than written immediately to the output file. */
3752 unwind_output_sec = NULL;
3753 if (!bfd_link_relocatable (info))
3755 asection *s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind);
3758 unwind_output_sec = s->output_section;
3759 unwind_output_sec->contents
3760 = bfd_malloc (unwind_output_sec->size);
3761 if (unwind_output_sec->contents == NULL)
3766 /* Invoke the regular ELF backend linker to do all the work. */
3767 if (!bfd_elf_final_link (abfd, info))
3770 if (unwind_output_sec)
3772 elfNN_ia64_unwind_entry_compare_bfd = abfd;
3773 qsort (unwind_output_sec->contents,
3774 (size_t) (unwind_output_sec->size / 24),
3776 elfNN_ia64_unwind_entry_compare);
3778 if (! bfd_set_section_contents (abfd, unwind_output_sec,
3779 unwind_output_sec->contents, (bfd_vma) 0,
3780 unwind_output_sec->size))
3788 elfNN_ia64_relocate_section (bfd *output_bfd,
3789 struct bfd_link_info *info,
3791 asection *input_section,
3793 Elf_Internal_Rela *relocs,
3794 Elf_Internal_Sym *local_syms,
3795 asection **local_sections)
3797 struct elfNN_ia64_link_hash_table *ia64_info;
3798 Elf_Internal_Shdr *symtab_hdr;
3799 Elf_Internal_Rela *rel;
3800 Elf_Internal_Rela *relend;
3802 bfd_boolean ret_val = TRUE; /* for non-fatal errors */
3805 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3806 ia64_info = elfNN_ia64_hash_table (info);
3807 if (ia64_info == NULL)
3810 /* Infect various flags from the input section to the output section. */
3811 if (bfd_link_relocatable (info))
3815 flags = elf_section_data(input_section)->this_hdr.sh_flags;
3816 flags &= SHF_IA_64_NORECOV;
3818 elf_section_data(input_section->output_section)
3819 ->this_hdr.sh_flags |= flags;
3822 gp_val = _bfd_get_gp_value (output_bfd);
3823 srel = get_reloc_section (input_bfd, ia64_info, input_section, FALSE);
3826 relend = relocs + input_section->reloc_count;
3827 for (; rel < relend; ++rel)
3829 struct elf_link_hash_entry *h;
3830 struct elfNN_ia64_dyn_sym_info *dyn_i;
3831 bfd_reloc_status_type r;
3832 reloc_howto_type *howto;
3833 unsigned long r_symndx;
3834 Elf_Internal_Sym *sym;
3835 unsigned int r_type;
3839 bfd_boolean dynamic_symbol_p;
3840 bfd_boolean undef_weak_ref;
3842 r_type = ELFNN_R_TYPE (rel->r_info);
3843 if (r_type > R_IA64_MAX_RELOC_CODE)
3846 /* xgettext:c-format */
3847 (_("%pB: unknown relocation type %d"), input_bfd, (int) r_type);
3848 bfd_set_error (bfd_error_bad_value);
3853 howto = ia64_elf_lookup_howto (r_type);
3854 r_symndx = ELFNN_R_SYM (rel->r_info);
3858 undef_weak_ref = FALSE;
3860 if (r_symndx < symtab_hdr->sh_info)
3862 /* Reloc against local symbol. */
3864 sym = local_syms + r_symndx;
3865 sym_sec = local_sections[r_symndx];
3867 value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
3868 if (!bfd_link_relocatable (info)
3869 && (sym_sec->flags & SEC_MERGE) != 0
3870 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
3871 && sym_sec->sec_info_type == SEC_INFO_TYPE_MERGE)
3873 struct elfNN_ia64_local_hash_entry *loc_h;
3875 loc_h = get_local_sym_hash (ia64_info, input_bfd, rel, FALSE);
3876 if (loc_h && ! loc_h->sec_merge_done)
3878 struct elfNN_ia64_dyn_sym_info *dynent;
3881 for (count = loc_h->count, dynent = loc_h->info;
3887 _bfd_merged_section_offset (output_bfd, &msec,
3888 elf_section_data (msec)->
3892 dynent->addend -= sym->st_value;
3893 dynent->addend += msec->output_section->vma
3894 + msec->output_offset
3895 - sym_sec->output_section->vma
3896 - sym_sec->output_offset;
3899 /* We may have introduced duplicated entries. We need
3900 to remove them properly. */
3901 count = sort_dyn_sym_info (loc_h->info, loc_h->count);
3902 if (count != loc_h->count)
3904 loc_h->count = count;
3905 loc_h->sorted_count = count;
3908 loc_h->sec_merge_done = 1;
3914 bfd_boolean unresolved_reloc;
3915 bfd_boolean warned, ignored;
3916 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
3918 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3919 r_symndx, symtab_hdr, sym_hashes,
3921 unresolved_reloc, warned, ignored);
3923 if (h->root.type == bfd_link_hash_undefweak)
3924 undef_weak_ref = TRUE;
3925 else if (warned || (ignored && bfd_link_executable (info)))
3929 if (sym_sec != NULL && discarded_section (sym_sec))
3930 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3931 rel, 1, relend, howto, 0, contents);
3933 if (bfd_link_relocatable (info))
3936 hit_addr = contents + rel->r_offset;
3937 value += rel->r_addend;
3938 dynamic_symbol_p = elfNN_ia64_dynamic_symbol_p (h, info, r_type);
3949 case R_IA64_DIR32MSB:
3950 case R_IA64_DIR32LSB:
3951 case R_IA64_DIR64MSB:
3952 case R_IA64_DIR64LSB:
3953 /* Install a dynamic relocation for this reloc. */
3954 if ((dynamic_symbol_p || bfd_link_pic (info))
3955 && !(h && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
3956 && r_symndx != STN_UNDEF
3957 && (input_section->flags & SEC_ALLOC) != 0)
3959 unsigned int dyn_r_type;
3963 BFD_ASSERT (srel != NULL);
3970 /* ??? People shouldn't be doing non-pic code in
3971 shared libraries nor dynamic executables. */
3973 /* xgettext:c-format */
3974 (_("%pB: non-pic code with imm relocation against dynamic symbol `%s'"),
3976 h ? h->root.root.string
3977 : bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3986 /* If we don't need dynamic symbol lookup, find a
3987 matching RELATIVE relocation. */
3988 dyn_r_type = r_type;
3989 if (dynamic_symbol_p)
3991 dynindx = h->dynindx;
3992 addend = rel->r_addend;
3999 case R_IA64_DIR32MSB:
4000 dyn_r_type = R_IA64_REL32MSB;
4002 case R_IA64_DIR32LSB:
4003 dyn_r_type = R_IA64_REL32LSB;
4005 case R_IA64_DIR64MSB:
4006 dyn_r_type = R_IA64_REL64MSB;
4008 case R_IA64_DIR64LSB:
4009 dyn_r_type = R_IA64_REL64LSB;
4019 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4020 srel, rel->r_offset, dyn_r_type,
4025 case R_IA64_LTV32MSB:
4026 case R_IA64_LTV32LSB:
4027 case R_IA64_LTV64MSB:
4028 case R_IA64_LTV64LSB:
4029 r = ia64_elf_install_value (hit_addr, value, r_type);
4032 case R_IA64_GPREL22:
4033 case R_IA64_GPREL64I:
4034 case R_IA64_GPREL32MSB:
4035 case R_IA64_GPREL32LSB:
4036 case R_IA64_GPREL64MSB:
4037 case R_IA64_GPREL64LSB:
4038 if (dynamic_symbol_p)
4041 /* xgettext:c-format */
4042 (_("%pB: @gprel relocation against dynamic symbol %s"),
4044 h ? h->root.root.string
4045 : bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4051 r = ia64_elf_install_value (hit_addr, value, r_type);
4054 case R_IA64_LTOFF22:
4055 case R_IA64_LTOFF22X:
4056 case R_IA64_LTOFF64I:
4057 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4058 value = set_got_entry (input_bfd, info, dyn_i, (h ? h->dynindx : -1),
4059 rel->r_addend, value, R_IA64_DIRNNLSB);
4061 r = ia64_elf_install_value (hit_addr, value, r_type);
4064 case R_IA64_PLTOFF22:
4065 case R_IA64_PLTOFF64I:
4066 case R_IA64_PLTOFF64MSB:
4067 case R_IA64_PLTOFF64LSB:
4068 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4069 value = set_pltoff_entry (output_bfd, info, dyn_i, value, FALSE);
4071 r = ia64_elf_install_value (hit_addr, value, r_type);
4074 case R_IA64_FPTR64I:
4075 case R_IA64_FPTR32MSB:
4076 case R_IA64_FPTR32LSB:
4077 case R_IA64_FPTR64MSB:
4078 case R_IA64_FPTR64LSB:
4079 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4080 if (dyn_i->want_fptr)
4082 if (!undef_weak_ref)
4083 value = set_fptr_entry (output_bfd, info, dyn_i, value);
4085 if (!dyn_i->want_fptr || bfd_link_pie (info))
4088 unsigned int dyn_r_type = r_type;
4089 bfd_vma addend = rel->r_addend;
4091 /* Otherwise, we expect the dynamic linker to create
4094 if (dyn_i->want_fptr)
4096 if (r_type == R_IA64_FPTR64I)
4098 /* We can't represent this without a dynamic symbol.
4099 Adjust the relocation to be against an output
4100 section symbol, which are always present in the
4101 dynamic symbol table. */
4102 /* ??? People shouldn't be doing non-pic code in
4103 shared libraries. Hork. */
4105 (_("%pB: linking non-pic code in a position independent executable"),
4112 dyn_r_type = r_type + R_IA64_RELNNLSB - R_IA64_FPTRNNLSB;
4116 if (h->dynindx != -1)
4117 dynindx = h->dynindx;
4119 dynindx = (_bfd_elf_link_lookup_local_dynindx
4120 (info, h->root.u.def.section->owner,
4121 global_sym_index (h)));
4126 dynindx = (_bfd_elf_link_lookup_local_dynindx
4127 (info, input_bfd, (long) r_symndx));
4131 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4132 srel, rel->r_offset, dyn_r_type,
4136 r = ia64_elf_install_value (hit_addr, value, r_type);
4139 case R_IA64_LTOFF_FPTR22:
4140 case R_IA64_LTOFF_FPTR64I:
4141 case R_IA64_LTOFF_FPTR32MSB:
4142 case R_IA64_LTOFF_FPTR32LSB:
4143 case R_IA64_LTOFF_FPTR64MSB:
4144 case R_IA64_LTOFF_FPTR64LSB:
4148 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4149 if (dyn_i->want_fptr)
4151 BFD_ASSERT (h == NULL || h->dynindx == -1);
4152 if (!undef_weak_ref)
4153 value = set_fptr_entry (output_bfd, info, dyn_i, value);
4158 /* Otherwise, we expect the dynamic linker to create
4162 if (h->dynindx != -1)
4163 dynindx = h->dynindx;
4165 dynindx = (_bfd_elf_link_lookup_local_dynindx
4166 (info, h->root.u.def.section->owner,
4167 global_sym_index (h)));
4170 dynindx = (_bfd_elf_link_lookup_local_dynindx
4171 (info, input_bfd, (long) r_symndx));
4175 value = set_got_entry (output_bfd, info, dyn_i, dynindx,
4176 rel->r_addend, value, R_IA64_FPTRNNLSB);
4178 r = ia64_elf_install_value (hit_addr, value, r_type);
4182 case R_IA64_PCREL32MSB:
4183 case R_IA64_PCREL32LSB:
4184 case R_IA64_PCREL64MSB:
4185 case R_IA64_PCREL64LSB:
4186 /* Install a dynamic relocation for this reloc. */
4187 if (dynamic_symbol_p && r_symndx != STN_UNDEF)
4189 BFD_ASSERT (srel != NULL);
4191 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4192 srel, rel->r_offset, r_type,
4193 h->dynindx, rel->r_addend);
4197 case R_IA64_PCREL21B:
4198 case R_IA64_PCREL60B:
4199 /* We should have created a PLT entry for any dynamic symbol. */
4202 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE);
4204 if (dyn_i && dyn_i->want_plt2)
4206 /* Should have caught this earlier. */
4207 BFD_ASSERT (rel->r_addend == 0);
4209 value = (ia64_info->root.splt->output_section->vma
4210 + ia64_info->root.splt->output_offset
4211 + dyn_i->plt2_offset);
4215 /* Since there's no PLT entry, Validate that this is
4217 BFD_ASSERT (undef_weak_ref || sym_sec->output_section != NULL);
4219 /* If the symbol is undef_weak, we shouldn't be trying
4220 to call it. There's every chance that we'd wind up
4221 with an out-of-range fixup here. Don't bother setting
4222 any value at all. */
4228 case R_IA64_PCREL21BI:
4229 case R_IA64_PCREL21F:
4230 case R_IA64_PCREL21M:
4231 case R_IA64_PCREL22:
4232 case R_IA64_PCREL64I:
4233 /* The PCREL21BI reloc is specifically not intended for use with
4234 dynamic relocs. PCREL21F and PCREL21M are used for speculation
4235 fixup code, and thus probably ought not be dynamic. The
4236 PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs. */
4237 if (dynamic_symbol_p)
4241 if (r_type == R_IA64_PCREL21BI)
4242 /* xgettext:c-format */
4243 msg = _("%pB: @internal branch to dynamic symbol %s");
4244 else if (r_type == R_IA64_PCREL21F || r_type == R_IA64_PCREL21M)
4245 /* xgettext:c-format */
4246 msg = _("%pB: speculation fixup to dynamic symbol %s");
4248 /* xgettext:c-format */
4249 msg = _("%pB: @pcrel relocation against dynamic symbol %s");
4250 _bfd_error_handler (msg, input_bfd,
4251 h ? h->root.root.string
4252 : bfd_elf_sym_name (input_bfd,
4262 /* Make pc-relative. */
4263 value -= (input_section->output_section->vma
4264 + input_section->output_offset
4265 + rel->r_offset) & ~ (bfd_vma) 0x3;
4266 r = ia64_elf_install_value (hit_addr, value, r_type);
4269 case R_IA64_SEGREL32MSB:
4270 case R_IA64_SEGREL32LSB:
4271 case R_IA64_SEGREL64MSB:
4272 case R_IA64_SEGREL64LSB:
4274 /* Find the segment that contains the output_section. */
4275 Elf_Internal_Phdr *p = _bfd_elf_find_segment_containing_section
4276 (output_bfd, input_section->output_section);
4280 r = bfd_reloc_notsupported;
4284 /* The VMA of the segment is the vaddr of the associated
4286 if (value > p->p_vaddr)
4287 value -= p->p_vaddr;
4290 r = ia64_elf_install_value (hit_addr, value, r_type);
4295 case R_IA64_SECREL32MSB:
4296 case R_IA64_SECREL32LSB:
4297 case R_IA64_SECREL64MSB:
4298 case R_IA64_SECREL64LSB:
4299 /* Make output-section relative to section where the symbol
4300 is defined. PR 475 */
4302 value -= sym_sec->output_section->vma;
4303 r = ia64_elf_install_value (hit_addr, value, r_type);
4306 case R_IA64_IPLTMSB:
4307 case R_IA64_IPLTLSB:
4308 /* Install a dynamic relocation for this reloc. */
4309 if ((dynamic_symbol_p || bfd_link_pic (info))
4310 && (input_section->flags & SEC_ALLOC) != 0)
4312 BFD_ASSERT (srel != NULL);
4314 /* If we don't need dynamic symbol lookup, install two
4315 RELATIVE relocations. */
4316 if (!dynamic_symbol_p)
4318 unsigned int dyn_r_type;
4320 if (r_type == R_IA64_IPLTMSB)
4321 dyn_r_type = R_IA64_REL64MSB;
4323 dyn_r_type = R_IA64_REL64LSB;
4325 elfNN_ia64_install_dyn_reloc (output_bfd, info,
4327 srel, rel->r_offset,
4328 dyn_r_type, 0, value);
4329 elfNN_ia64_install_dyn_reloc (output_bfd, info,
4331 srel, rel->r_offset + 8,
4332 dyn_r_type, 0, gp_val);
4335 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4336 srel, rel->r_offset, r_type,
4337 h->dynindx, rel->r_addend);
4340 if (r_type == R_IA64_IPLTMSB)
4341 r_type = R_IA64_DIR64MSB;
4343 r_type = R_IA64_DIR64LSB;
4344 ia64_elf_install_value (hit_addr, value, r_type);
4345 r = ia64_elf_install_value (hit_addr + 8, gp_val, r_type);
4348 case R_IA64_TPREL14:
4349 case R_IA64_TPREL22:
4350 case R_IA64_TPREL64I:
4351 if (elf_hash_table (info)->tls_sec == NULL)
4352 goto missing_tls_sec;
4353 value -= elfNN_ia64_tprel_base (info);
4354 r = ia64_elf_install_value (hit_addr, value, r_type);
4357 case R_IA64_DTPREL14:
4358 case R_IA64_DTPREL22:
4359 case R_IA64_DTPREL64I:
4360 case R_IA64_DTPREL32LSB:
4361 case R_IA64_DTPREL32MSB:
4362 case R_IA64_DTPREL64LSB:
4363 case R_IA64_DTPREL64MSB:
4364 if (elf_hash_table (info)->tls_sec == NULL)
4365 goto missing_tls_sec;
4366 value -= elfNN_ia64_dtprel_base (info);
4367 r = ia64_elf_install_value (hit_addr, value, r_type);
4370 case R_IA64_LTOFF_TPREL22:
4371 case R_IA64_LTOFF_DTPMOD22:
4372 case R_IA64_LTOFF_DTPREL22:
4375 long dynindx = h ? h->dynindx : -1;
4376 bfd_vma r_addend = rel->r_addend;
4381 case R_IA64_LTOFF_TPREL22:
4382 if (!dynamic_symbol_p)
4384 if (elf_hash_table (info)->tls_sec == NULL)
4385 goto missing_tls_sec;
4386 if (!bfd_link_pic (info))
4387 value -= elfNN_ia64_tprel_base (info);
4390 r_addend += value - elfNN_ia64_dtprel_base (info);
4394 got_r_type = R_IA64_TPREL64LSB;
4396 case R_IA64_LTOFF_DTPMOD22:
4397 if (!dynamic_symbol_p && !bfd_link_pic (info))
4399 got_r_type = R_IA64_DTPMOD64LSB;
4401 case R_IA64_LTOFF_DTPREL22:
4402 if (!dynamic_symbol_p)
4404 if (elf_hash_table (info)->tls_sec == NULL)
4405 goto missing_tls_sec;
4406 value -= elfNN_ia64_dtprel_base (info);
4408 got_r_type = R_IA64_DTPRELNNLSB;
4411 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4412 value = set_got_entry (input_bfd, info, dyn_i, dynindx, r_addend,
4415 r = ia64_elf_install_value (hit_addr, value, r_type);
4420 r = bfd_reloc_notsupported;
4429 case bfd_reloc_undefined:
4430 /* This can happen for global table relative relocs if
4431 __gp is undefined. This is a panic situation so we
4432 don't try to continue. */
4433 (*info->callbacks->undefined_symbol)
4434 (info, "__gp", input_bfd, input_section, rel->r_offset, 1);
4437 case bfd_reloc_notsupported:
4442 name = h->root.root.string;
4444 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4446 (*info->callbacks->warning) (info, _("unsupported reloc"),
4448 input_section, rel->r_offset);
4453 case bfd_reloc_dangerous:
4454 case bfd_reloc_outofrange:
4455 case bfd_reloc_overflow:
4462 name = h->root.root.string;
4464 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4469 case R_IA64_TPREL14:
4470 case R_IA64_TPREL22:
4471 case R_IA64_TPREL64I:
4472 case R_IA64_DTPREL14:
4473 case R_IA64_DTPREL22:
4474 case R_IA64_DTPREL64I:
4475 case R_IA64_DTPREL32LSB:
4476 case R_IA64_DTPREL32MSB:
4477 case R_IA64_DTPREL64LSB:
4478 case R_IA64_DTPREL64MSB:
4479 case R_IA64_LTOFF_TPREL22:
4480 case R_IA64_LTOFF_DTPMOD22:
4481 case R_IA64_LTOFF_DTPREL22:
4483 /* xgettext:c-format */
4484 (_("%pB: missing TLS section for relocation %s against `%s'"
4485 " at %#Lx in section `%pA'."),
4486 input_bfd, howto->name, name,
4487 rel->r_offset, input_section);
4490 case R_IA64_PCREL21B:
4491 case R_IA64_PCREL21BI:
4492 case R_IA64_PCREL21M:
4493 case R_IA64_PCREL21F:
4494 if (is_elf_hash_table (info->hash))
4496 /* Relaxtion is always performed for ELF output.
4497 Overflow failures for those relocations mean
4498 that the section is too big to relax. */
4500 /* xgettext:c-format */
4501 (_("%pB: Can't relax br (%s) to `%s' at %#Lx"
4502 " in section `%pA' with size %#Lx (> 0x1000000)."),
4503 input_bfd, howto->name, name, rel->r_offset,
4504 input_section, input_section->size);
4509 (*info->callbacks->reloc_overflow) (info,
4530 elfNN_ia64_finish_dynamic_symbol (bfd *output_bfd,
4531 struct bfd_link_info *info,
4532 struct elf_link_hash_entry *h,
4533 Elf_Internal_Sym *sym)
4535 struct elfNN_ia64_link_hash_table *ia64_info;
4536 struct elfNN_ia64_dyn_sym_info *dyn_i;
4538 ia64_info = elfNN_ia64_hash_table (info);
4539 if (ia64_info == NULL)
4542 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE);
4544 /* Fill in the PLT data, if required. */
4545 if (dyn_i && dyn_i->want_plt)
4547 Elf_Internal_Rela outrel;
4550 bfd_vma plt_addr, pltoff_addr, gp_val, plt_index;
4552 gp_val = _bfd_get_gp_value (output_bfd);
4554 /* Initialize the minimal PLT entry. */
4556 plt_index = (dyn_i->plt_offset - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
4557 plt_sec = ia64_info->root.splt;
4558 loc = plt_sec->contents + dyn_i->plt_offset;
4560 memcpy (loc, plt_min_entry, PLT_MIN_ENTRY_SIZE);
4561 ia64_elf_install_value (loc, plt_index, R_IA64_IMM22);
4562 ia64_elf_install_value (loc+2, -dyn_i->plt_offset, R_IA64_PCREL21B);
4564 plt_addr = (plt_sec->output_section->vma
4565 + plt_sec->output_offset
4566 + dyn_i->plt_offset);
4567 pltoff_addr = set_pltoff_entry (output_bfd, info, dyn_i, plt_addr, TRUE);
4569 /* Initialize the FULL PLT entry, if needed. */
4570 if (dyn_i->want_plt2)
4572 loc = plt_sec->contents + dyn_i->plt2_offset;
4574 memcpy (loc, plt_full_entry, PLT_FULL_ENTRY_SIZE);
4575 ia64_elf_install_value (loc, pltoff_addr - gp_val, R_IA64_IMM22);
4577 /* Mark the symbol as undefined, rather than as defined in the
4578 plt section. Leave the value alone. */
4579 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
4580 first place. But perhaps elflink.c did some for us. */
4581 if (!h->def_regular)
4582 sym->st_shndx = SHN_UNDEF;
4585 /* Create the dynamic relocation. */
4586 outrel.r_offset = pltoff_addr;
4587 if (bfd_little_endian (output_bfd))
4588 outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTLSB);
4590 outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTMSB);
4591 outrel.r_addend = 0;
4593 /* This is fun. In the .IA_64.pltoff section, we've got entries
4594 that correspond both to real PLT entries, and those that
4595 happened to resolve to local symbols but need to be created
4596 to satisfy @pltoff relocations. The .rela.IA_64.pltoff
4597 relocations for the real PLT should come at the end of the
4598 section, so that they can be indexed by plt entry at runtime.
4600 We emitted all of the relocations for the non-PLT @pltoff
4601 entries during relocate_section. So we can consider the
4602 existing sec->reloc_count to be the base of the array of
4605 loc = ia64_info->rel_pltoff_sec->contents;
4606 loc += ((ia64_info->rel_pltoff_sec->reloc_count + plt_index)
4607 * sizeof (ElfNN_External_Rela));
4608 bfd_elfNN_swap_reloca_out (output_bfd, &outrel, loc);
4611 /* Mark some specially defined symbols as absolute. */
4612 if (h == ia64_info->root.hdynamic
4613 || h == ia64_info->root.hgot
4614 || h == ia64_info->root.hplt)
4615 sym->st_shndx = SHN_ABS;
4621 elfNN_ia64_finish_dynamic_sections (bfd *abfd,
4622 struct bfd_link_info *info)
4624 struct elfNN_ia64_link_hash_table *ia64_info;
4627 ia64_info = elfNN_ia64_hash_table (info);
4628 if (ia64_info == NULL)
4631 dynobj = ia64_info->root.dynobj;
4633 if (ia64_info->root.dynamic_sections_created)
4635 ElfNN_External_Dyn *dyncon, *dynconend;
4636 asection *sdyn, *sgotplt;
4639 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4640 sgotplt = ia64_info->root.sgotplt;
4641 BFD_ASSERT (sdyn != NULL);
4642 dyncon = (ElfNN_External_Dyn *) sdyn->contents;
4643 dynconend = (ElfNN_External_Dyn *) (sdyn->contents + sdyn->size);
4645 gp_val = _bfd_get_gp_value (abfd);
4647 for (; dyncon < dynconend; dyncon++)
4649 Elf_Internal_Dyn dyn;
4651 bfd_elfNN_swap_dyn_in (dynobj, dyncon, &dyn);
4656 dyn.d_un.d_ptr = gp_val;
4660 dyn.d_un.d_val = (ia64_info->minplt_entries
4661 * sizeof (ElfNN_External_Rela));
4665 /* See the comment above in finish_dynamic_symbol. */
4666 dyn.d_un.d_ptr = (ia64_info->rel_pltoff_sec->output_section->vma
4667 + ia64_info->rel_pltoff_sec->output_offset
4668 + (ia64_info->rel_pltoff_sec->reloc_count
4669 * sizeof (ElfNN_External_Rela)));
4672 case DT_IA_64_PLT_RESERVE:
4673 dyn.d_un.d_ptr = (sgotplt->output_section->vma
4674 + sgotplt->output_offset);
4678 bfd_elfNN_swap_dyn_out (abfd, &dyn, dyncon);
4681 /* Initialize the PLT0 entry. */
4682 if (ia64_info->root.splt)
4684 bfd_byte *loc = ia64_info->root.splt->contents;
4687 memcpy (loc, plt_header, PLT_HEADER_SIZE);
4689 pltres = (sgotplt->output_section->vma
4690 + sgotplt->output_offset
4693 ia64_elf_install_value (loc+1, pltres, R_IA64_GPREL22);
4700 /* ELF file flag handling: */
4702 /* Function to keep IA-64 specific file flags. */
4704 elfNN_ia64_set_private_flags (bfd *abfd, flagword flags)
4706 BFD_ASSERT (!elf_flags_init (abfd)
4707 || elf_elfheader (abfd)->e_flags == flags);
4709 elf_elfheader (abfd)->e_flags = flags;
4710 elf_flags_init (abfd) = TRUE;
4714 /* Merge backend specific data from an object file to the output
4715 object file when linking. */
4717 elfNN_ia64_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
4719 bfd *obfd = info->output_bfd;
4722 bfd_boolean ok = TRUE;
4724 /* Don't even pretend to support mixed-format linking. */
4725 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4726 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4729 in_flags = elf_elfheader (ibfd)->e_flags;
4730 out_flags = elf_elfheader (obfd)->e_flags;
4732 if (! elf_flags_init (obfd))
4734 elf_flags_init (obfd) = TRUE;
4735 elf_elfheader (obfd)->e_flags = in_flags;
4737 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
4738 && bfd_get_arch_info (obfd)->the_default)
4740 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
4741 bfd_get_mach (ibfd));
4747 /* Check flag compatibility. */
4748 if (in_flags == out_flags)
4751 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
4752 if (!(in_flags & EF_IA_64_REDUCEDFP) && (out_flags & EF_IA_64_REDUCEDFP))
4753 elf_elfheader (obfd)->e_flags &= ~EF_IA_64_REDUCEDFP;
4755 if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL))
4758 (_("%pB: linking trap-on-NULL-dereference with non-trapping files"),
4761 bfd_set_error (bfd_error_bad_value);
4764 if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE))
4767 (_("%pB: linking big-endian files with little-endian files"),
4770 bfd_set_error (bfd_error_bad_value);
4773 if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64))
4776 (_("%pB: linking 64-bit files with 32-bit files"),
4779 bfd_set_error (bfd_error_bad_value);
4782 if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP))
4785 (_("%pB: linking constant-gp files with non-constant-gp files"),
4788 bfd_set_error (bfd_error_bad_value);
4791 if ((in_flags & EF_IA_64_NOFUNCDESC_CONS_GP)
4792 != (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
4795 (_("%pB: linking auto-pic files with non-auto-pic files"),
4798 bfd_set_error (bfd_error_bad_value);
4806 elfNN_ia64_print_private_bfd_data (bfd *abfd, void * ptr)
4808 FILE *file = (FILE *) ptr;
4809 flagword flags = elf_elfheader (abfd)->e_flags;
4811 BFD_ASSERT (abfd != NULL && ptr != NULL);
4813 fprintf (file, "private flags = %s%s%s%s%s%s%s%s\n",
4814 (flags & EF_IA_64_TRAPNIL) ? "TRAPNIL, " : "",
4815 (flags & EF_IA_64_EXT) ? "EXT, " : "",
4816 (flags & EF_IA_64_BE) ? "BE, " : "LE, ",
4817 (flags & EF_IA_64_REDUCEDFP) ? "REDUCEDFP, " : "",
4818 (flags & EF_IA_64_CONS_GP) ? "CONS_GP, " : "",
4819 (flags & EF_IA_64_NOFUNCDESC_CONS_GP) ? "NOFUNCDESC_CONS_GP, " : "",
4820 (flags & EF_IA_64_ABSOLUTE) ? "ABSOLUTE, " : "",
4821 (flags & EF_IA_64_ABI64) ? "ABI64" : "ABI32");
4823 _bfd_elf_print_private_bfd_data (abfd, ptr);
4827 static enum elf_reloc_type_class
4828 elfNN_ia64_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
4829 const asection *rel_sec ATTRIBUTE_UNUSED,
4830 const Elf_Internal_Rela *rela)
4832 switch ((int) ELFNN_R_TYPE (rela->r_info))
4834 case R_IA64_REL32MSB:
4835 case R_IA64_REL32LSB:
4836 case R_IA64_REL64MSB:
4837 case R_IA64_REL64LSB:
4838 return reloc_class_relative;
4839 case R_IA64_IPLTMSB:
4840 case R_IA64_IPLTLSB:
4841 return reloc_class_plt;
4843 return reloc_class_copy;
4845 return reloc_class_normal;
4849 static const struct bfd_elf_special_section elfNN_ia64_special_sections[] =
4851 { STRING_COMMA_LEN (".sbss"), -1, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
4852 { STRING_COMMA_LEN (".sdata"), -1, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
4853 { NULL, 0, 0, 0, 0 }
4857 elfNN_ia64_object_p (bfd *abfd)
4860 asection *group, *unwi, *unw;
4863 char *unwi_name, *unw_name;
4866 if (abfd->flags & DYNAMIC)
4869 /* Flags for fake group section. */
4870 flags = (SEC_LINKER_CREATED | SEC_GROUP | SEC_LINK_ONCE
4873 /* We add a fake section group for each .gnu.linkonce.t.* section,
4874 which isn't in a section group, and its unwind sections. */
4875 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4877 if (elf_sec_group (sec) == NULL
4878 && ((sec->flags & (SEC_LINK_ONCE | SEC_CODE | SEC_GROUP))
4879 == (SEC_LINK_ONCE | SEC_CODE))
4880 && CONST_STRNEQ (sec->name, ".gnu.linkonce.t."))
4882 name = sec->name + 16;
4884 amt = strlen (name) + sizeof (".gnu.linkonce.ia64unwi.");
4885 unwi_name = bfd_alloc (abfd, amt);
4889 strcpy (stpcpy (unwi_name, ".gnu.linkonce.ia64unwi."), name);
4890 unwi = bfd_get_section_by_name (abfd, unwi_name);
4892 amt = strlen (name) + sizeof (".gnu.linkonce.ia64unw.");
4893 unw_name = bfd_alloc (abfd, amt);
4897 strcpy (stpcpy (unw_name, ".gnu.linkonce.ia64unw."), name);
4898 unw = bfd_get_section_by_name (abfd, unw_name);
4900 /* We need to create a fake group section for it and its
4902 group = bfd_make_section_anyway_with_flags (abfd, name,
4907 /* Move the fake group section to the beginning. */
4908 bfd_section_list_remove (abfd, group);
4909 bfd_section_list_prepend (abfd, group);
4911 elf_next_in_group (group) = sec;
4913 elf_group_name (sec) = name;
4914 elf_next_in_group (sec) = sec;
4915 elf_sec_group (sec) = group;
4919 elf_group_name (unwi) = name;
4920 elf_next_in_group (unwi) = sec;
4921 elf_next_in_group (sec) = unwi;
4922 elf_sec_group (unwi) = group;
4927 elf_group_name (unw) = name;
4930 elf_next_in_group (unw) = elf_next_in_group (unwi);
4931 elf_next_in_group (unwi) = unw;
4935 elf_next_in_group (unw) = sec;
4936 elf_next_in_group (sec) = unw;
4938 elf_sec_group (unw) = group;
4941 /* Fake SHT_GROUP section header. */
4942 elf_section_data (group)->this_hdr.bfd_section = group;
4943 elf_section_data (group)->this_hdr.sh_type = SHT_GROUP;
4950 elfNN_ia64_hpux_vec (const bfd_target *vec)
4952 extern const bfd_target ia64_elfNN_hpux_be_vec;
4953 return (vec == &ia64_elfNN_hpux_be_vec);
4957 elfNN_hpux_post_process_headers (bfd *abfd,
4958 struct bfd_link_info *info ATTRIBUTE_UNUSED)
4960 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
4962 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
4963 i_ehdrp->e_ident[EI_ABIVERSION] = 1;
4967 elfNN_hpux_backend_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
4968 asection *sec, int *retval)
4970 if (bfd_is_com_section (sec))
4972 *retval = SHN_IA_64_ANSI_COMMON;
4979 elfNN_hpux_backend_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
4982 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
4984 switch (elfsym->internal_elf_sym.st_shndx)
4986 case SHN_IA_64_ANSI_COMMON:
4987 asym->section = bfd_com_section_ptr;
4988 asym->value = elfsym->internal_elf_sym.st_size;
4989 asym->flags &= ~BSF_GLOBAL;
4994 #define TARGET_LITTLE_SYM ia64_elfNN_le_vec
4995 #define TARGET_LITTLE_NAME "elfNN-ia64-little"
4996 #define TARGET_BIG_SYM ia64_elfNN_be_vec
4997 #define TARGET_BIG_NAME "elfNN-ia64-big"
4998 #define ELF_ARCH bfd_arch_ia64
4999 #define ELF_TARGET_ID IA64_ELF_DATA
5000 #define ELF_MACHINE_CODE EM_IA_64
5001 #define ELF_MACHINE_ALT1 1999 /* EAS2.3 */
5002 #define ELF_MACHINE_ALT2 1998 /* EAS2.2 */
5003 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
5004 #define ELF_COMMONPAGESIZE 0x4000 /* 16KB */
5006 #define elf_backend_section_from_shdr \
5007 elfNN_ia64_section_from_shdr
5008 #define elf_backend_section_flags \
5009 elfNN_ia64_section_flags
5010 #define elf_backend_fake_sections \
5011 elfNN_ia64_fake_sections
5012 #define elf_backend_final_write_processing \
5013 elfNN_ia64_final_write_processing
5014 #define elf_backend_add_symbol_hook \
5015 elfNN_ia64_add_symbol_hook
5016 #define elf_backend_additional_program_headers \
5017 elfNN_ia64_additional_program_headers
5018 #define elf_backend_modify_segment_map \
5019 elfNN_ia64_modify_segment_map
5020 #define elf_backend_modify_program_headers \
5021 elfNN_ia64_modify_program_headers
5022 #define elf_info_to_howto \
5023 elfNN_ia64_info_to_howto
5025 #define bfd_elfNN_bfd_reloc_type_lookup \
5026 ia64_elf_reloc_type_lookup
5027 #define bfd_elfNN_bfd_reloc_name_lookup \
5028 ia64_elf_reloc_name_lookup
5029 #define bfd_elfNN_bfd_is_local_label_name \
5030 elfNN_ia64_is_local_label_name
5031 #define bfd_elfNN_bfd_relax_section \
5032 elfNN_ia64_relax_section
5034 #define elf_backend_object_p \
5037 /* Stuff for the BFD linker: */
5038 #define bfd_elfNN_bfd_link_hash_table_create \
5039 elfNN_ia64_hash_table_create
5040 #define elf_backend_create_dynamic_sections \
5041 elfNN_ia64_create_dynamic_sections
5042 #define elf_backend_check_relocs \
5043 elfNN_ia64_check_relocs
5044 #define elf_backend_adjust_dynamic_symbol \
5045 elfNN_ia64_adjust_dynamic_symbol
5046 #define elf_backend_size_dynamic_sections \
5047 elfNN_ia64_size_dynamic_sections
5048 #define elf_backend_omit_section_dynsym \
5049 _bfd_elf_omit_section_dynsym_all
5050 #define elf_backend_relocate_section \
5051 elfNN_ia64_relocate_section
5052 #define elf_backend_finish_dynamic_symbol \
5053 elfNN_ia64_finish_dynamic_symbol
5054 #define elf_backend_finish_dynamic_sections \
5055 elfNN_ia64_finish_dynamic_sections
5056 #define bfd_elfNN_bfd_final_link \
5057 elfNN_ia64_final_link
5059 #define bfd_elfNN_bfd_merge_private_bfd_data \
5060 elfNN_ia64_merge_private_bfd_data
5061 #define bfd_elfNN_bfd_set_private_flags \
5062 elfNN_ia64_set_private_flags
5063 #define bfd_elfNN_bfd_print_private_bfd_data \
5064 elfNN_ia64_print_private_bfd_data
5066 #define elf_backend_plt_readonly 1
5067 #define elf_backend_want_plt_sym 0
5068 #define elf_backend_plt_alignment 5
5069 #define elf_backend_got_header_size 0
5070 #define elf_backend_want_got_plt 1
5071 #define elf_backend_may_use_rel_p 1
5072 #define elf_backend_may_use_rela_p 1
5073 #define elf_backend_default_use_rela_p 1
5074 #define elf_backend_want_dynbss 0
5075 #define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect
5076 #define elf_backend_hide_symbol elfNN_ia64_hash_hide_symbol
5077 #define elf_backend_fixup_symbol _bfd_elf_link_hash_fixup_symbol
5078 #define elf_backend_reloc_type_class elfNN_ia64_reloc_type_class
5079 #define elf_backend_rela_normal 1
5080 #define elf_backend_dtrel_excludes_plt 1
5081 #define elf_backend_special_sections elfNN_ia64_special_sections
5082 #define elf_backend_default_execstack 0
5084 /* FIXME: PR 290: The Intel C compiler generates SHT_IA_64_UNWIND with
5085 SHF_LINK_ORDER. But it doesn't set the sh_link or sh_info fields.
5086 We don't want to flood users with so many error messages. We turn
5087 off the warning for now. It will be turned on later when the Intel
5088 compiler is fixed. */
5089 #define elf_backend_link_order_error_handler NULL
5091 #include "elfNN-target.h"
5093 /* HPUX-specific vectors. */
5095 #undef TARGET_LITTLE_SYM
5096 #undef TARGET_LITTLE_NAME
5097 #undef TARGET_BIG_SYM
5098 #define TARGET_BIG_SYM ia64_elfNN_hpux_be_vec
5099 #undef TARGET_BIG_NAME
5100 #define TARGET_BIG_NAME "elfNN-ia64-hpux-big"
5102 /* These are HP-UX specific functions. */
5104 #undef elf_backend_post_process_headers
5105 #define elf_backend_post_process_headers elfNN_hpux_post_process_headers
5107 #undef elf_backend_section_from_bfd_section
5108 #define elf_backend_section_from_bfd_section elfNN_hpux_backend_section_from_bfd_section
5110 #undef elf_backend_symbol_processing
5111 #define elf_backend_symbol_processing elfNN_hpux_backend_symbol_processing
5113 #undef elf_backend_want_p_paddr_set_to_zero
5114 #define elf_backend_want_p_paddr_set_to_zero 1
5116 #undef ELF_COMMONPAGESIZE
5118 #define ELF_OSABI ELFOSABI_HPUX
5121 #define elfNN_bed elfNN_ia64_hpux_bed
5123 #include "elfNN-target.h"