1 /* IA-64 support for OpenVMS
2 Copyright (C) 1998-2020 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
25 #include "opcode/ia64.h"
29 #include "elfxx-ia64.h"
33 /* THE RULES for all the stuff the linker creates --
35 GOT Entries created in response to LTOFF or LTOFF_FPTR
36 relocations. Dynamic relocs created for dynamic
37 symbols in an application; REL relocs for locals
40 FPTR The canonical function descriptor. Created for local
41 symbols in applications. Descriptors for dynamic symbols
42 and local symbols in shared libraries are created by
43 ld.so. Thus there are no dynamic relocs against these
44 objects. The FPTR relocs for such _are_ passed through
45 to the dynamic relocation tables.
47 FULL_PLT Created for a PCREL21B relocation against a dynamic symbol.
48 Requires the creation of a PLTOFF entry. This does not
49 require any dynamic relocations.
51 PLTOFF Created by PLTOFF relocations. For local symbols, this
52 is an alternate function descriptor, and in shared libraries
53 requires two REL relocations. Note that this cannot be
54 transformed into an FPTR relocation, since it must be in
55 range of the GP. For dynamic symbols, this is a function
58 typedef struct bfd_hash_entry
*(*new_hash_entry_func
)
59 (struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *);
61 /* In dynamically (linker-) created sections, we generally need to keep track
62 of the place a symbol or expression got allocated to. This is done via hash
63 tables that store entries of the following type. */
65 struct elf64_ia64_dyn_sym_info
67 /* The addend for which this entry is relevant. */
72 bfd_vma pltoff_offset
;
76 /* The symbol table entry, if any, that this was derived from. */
77 struct elf_link_hash_entry
*h
;
79 /* Used to count non-got, non-plt relocations for delayed sizing
80 of relocation sections. */
81 struct elf64_ia64_dyn_reloc_entry
83 struct elf64_ia64_dyn_reloc_entry
*next
;
89 /* TRUE when the section contents have been updated. */
90 unsigned got_done
: 1;
91 unsigned fptr_done
: 1;
92 unsigned pltoff_done
: 1;
94 /* TRUE for the different kinds of linker data we want created. */
95 unsigned want_got
: 1;
96 unsigned want_gotx
: 1;
97 unsigned want_fptr
: 1;
98 unsigned want_ltoff_fptr
: 1;
99 unsigned want_plt
: 1; /* A MIN_PLT entry. */
100 unsigned want_plt2
: 1; /* A FULL_PLT. */
101 unsigned want_pltoff
: 1;
104 struct elf64_ia64_local_hash_entry
108 /* The number of elements in elf64_ia64_dyn_sym_info array. */
110 /* The number of sorted elements in elf64_ia64_dyn_sym_info array. */
111 unsigned int sorted_count
;
112 /* The size of elf64_ia64_dyn_sym_info array. */
114 /* The array of elf64_ia64_dyn_sym_info. */
115 struct elf64_ia64_dyn_sym_info
*info
;
117 /* TRUE if this hash entry's addends was translated for
118 SHF_MERGE optimization. */
119 unsigned sec_merge_done
: 1;
122 struct elf64_ia64_link_hash_entry
124 struct elf_link_hash_entry root
;
126 /* Set if this symbol is defined in a shared library.
127 We can't use root.u.def.section->owner as the symbol is an absolute
131 /* The number of elements in elf64_ia64_dyn_sym_info array. */
133 /* The number of sorted elements in elf64_ia64_dyn_sym_info array. */
134 unsigned int sorted_count
;
135 /* The size of elf64_ia64_dyn_sym_info array. */
137 /* The array of elf64_ia64_dyn_sym_info. */
138 struct elf64_ia64_dyn_sym_info
*info
;
141 struct elf64_ia64_link_hash_table
143 /* The main hash table. */
144 struct elf_link_hash_table root
;
146 asection
*fptr_sec
; /* Function descriptor table (or NULL). */
147 asection
*rel_fptr_sec
; /* Dynamic relocation section for same. */
148 asection
*pltoff_sec
; /* Private descriptors for plt (or NULL). */
149 asection
*fixups_sec
; /* Fixups section. */
150 asection
*transfer_sec
; /* Transfer vector section. */
151 asection
*note_sec
; /* .note section. */
153 /* There are maybe R_IA64_GPREL22 relocations, including those
154 optimized from R_IA64_LTOFF22X, against non-SHF_IA_64_SHORT
155 sections. We need to record those sections so that we can choose
156 a proper GP to cover all R_IA64_GPREL22 relocations. */
157 asection
*max_short_sec
; /* Maximum short output section. */
158 bfd_vma max_short_offset
; /* Maximum short offset. */
159 asection
*min_short_sec
; /* Minimum short output section. */
160 bfd_vma min_short_offset
; /* Minimum short offset. */
162 htab_t loc_hash_table
;
163 void *loc_hash_memory
;
166 struct elf64_ia64_allocate_data
168 struct bfd_link_info
*info
;
172 #define elf64_ia64_hash_table(p) \
173 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
174 == IA64_ELF_DATA ? ((struct elf64_ia64_link_hash_table *) ((p)->hash)) : NULL)
176 struct elf64_ia64_vms_obj_tdata
178 struct elf_obj_tdata root
;
180 /* Ident for shared library. */
183 /* Used only during link: offset in the .fixups section for this bfd. */
186 /* Max number of shared libraries. */
187 unsigned int needed_count
;
190 #define elf_ia64_vms_tdata(abfd) \
191 ((struct elf64_ia64_vms_obj_tdata *)((abfd)->tdata.any))
192 #define elf_ia64_vms_ident(abfd) (elf_ia64_vms_tdata(abfd)->ident)
194 struct elf64_vms_transfer
196 unsigned char size
[4];
197 unsigned char spare
[4];
198 unsigned char tfradr1
[8];
199 unsigned char tfradr2
[8];
200 unsigned char tfradr3
[8];
201 unsigned char tfradr4
[8];
202 unsigned char tfradr5
[8];
204 /* Local function descriptor for tfr3. */
205 unsigned char tfr3_func
[8];
206 unsigned char tfr3_gp
[8];
211 Elf64_External_Ehdr ehdr
;
212 unsigned char vms_needed_count
[8];
213 } Elf64_External_VMS_Ehdr
;
215 static struct elf64_ia64_dyn_sym_info
* get_dyn_sym_info
216 (struct elf64_ia64_link_hash_table
*,
217 struct elf_link_hash_entry
*,
218 bfd
*, const Elf_Internal_Rela
*, bfd_boolean
);
219 static bfd_boolean elf64_ia64_dynamic_symbol_p
220 (struct elf_link_hash_entry
*);
221 static bfd_boolean elf64_ia64_choose_gp
222 (bfd
*, struct bfd_link_info
*, bfd_boolean
);
223 static void elf64_ia64_dyn_sym_traverse
224 (struct elf64_ia64_link_hash_table
*,
225 bfd_boolean (*) (struct elf64_ia64_dyn_sym_info
*, void *),
227 static bfd_boolean allocate_global_data_got
228 (struct elf64_ia64_dyn_sym_info
*, void *);
229 static bfd_boolean allocate_global_fptr_got
230 (struct elf64_ia64_dyn_sym_info
*, void *);
231 static bfd_boolean allocate_local_got
232 (struct elf64_ia64_dyn_sym_info
*, void *);
233 static bfd_boolean allocate_dynrel_entries
234 (struct elf64_ia64_dyn_sym_info
*, void *);
235 static asection
*get_pltoff
236 (bfd
*, struct elf64_ia64_link_hash_table
*);
237 static asection
*get_got
238 (bfd
*, struct elf64_ia64_link_hash_table
*);
241 /* Given a ELF reloc, return the matching HOWTO structure. */
244 elf64_ia64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
246 Elf_Internal_Rela
*elf_reloc
)
248 unsigned int r_type
= ELF32_R_TYPE (elf_reloc
->r_info
);
250 bfd_reloc
->howto
= ia64_elf_lookup_howto (r_type
);
251 if (bfd_reloc
->howto
== NULL
)
253 /* xgettext:c-format */
254 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
256 bfd_set_error (bfd_error_bad_value
);
264 #define PLT_FULL_ENTRY_SIZE (2 * 16)
266 static const bfd_byte plt_full_entry
[PLT_FULL_ENTRY_SIZE
] =
268 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
269 0x00, 0x41, 0x3c, 0x70, 0x29, 0xc0, /* ld8.acq r16=[r15],8*/
270 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
271 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
272 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
273 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
276 static const bfd_byte oor_brl
[16] =
278 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
279 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;;*/
280 0x00, 0x00, 0x00, 0xc0
284 /* These functions do relaxation for IA-64 ELF. */
286 /* Rename some of the generic section flags to better document how they
288 #define skip_relax_pass_0 sec_flg0
289 #define skip_relax_pass_1 sec_flg1
292 elf64_ia64_update_short_info (asection
*sec
, bfd_vma offset
,
293 struct elf64_ia64_link_hash_table
*ia64_info
)
295 /* Skip ABS and SHF_IA_64_SHORT sections. */
296 if (sec
== bfd_abs_section_ptr
297 || (sec
->flags
& SEC_SMALL_DATA
) != 0)
300 if (!ia64_info
->min_short_sec
)
302 ia64_info
->max_short_sec
= sec
;
303 ia64_info
->max_short_offset
= offset
;
304 ia64_info
->min_short_sec
= sec
;
305 ia64_info
->min_short_offset
= offset
;
307 else if (sec
== ia64_info
->max_short_sec
308 && offset
> ia64_info
->max_short_offset
)
309 ia64_info
->max_short_offset
= offset
;
310 else if (sec
== ia64_info
->min_short_sec
311 && offset
< ia64_info
->min_short_offset
)
312 ia64_info
->min_short_offset
= offset
;
313 else if (sec
->output_section
->vma
314 > ia64_info
->max_short_sec
->vma
)
316 ia64_info
->max_short_sec
= sec
;
317 ia64_info
->max_short_offset
= offset
;
319 else if (sec
->output_section
->vma
320 < ia64_info
->min_short_sec
->vma
)
322 ia64_info
->min_short_sec
= sec
;
323 ia64_info
->min_short_offset
= offset
;
327 /* Use a two passes algorithm. In the first pass, branches are relaxed
328 (which may increase the size of the section). In the second pass,
329 the other relaxations are done.
333 elf64_ia64_relax_section (bfd
*abfd
, asection
*sec
,
334 struct bfd_link_info
*link_info
,
339 struct one_fixup
*next
;
345 Elf_Internal_Shdr
*symtab_hdr
;
346 Elf_Internal_Rela
*internal_relocs
;
347 Elf_Internal_Rela
*irel
, *irelend
;
349 Elf_Internal_Sym
*isymbuf
= NULL
;
350 struct elf64_ia64_link_hash_table
*ia64_info
;
351 struct one_fixup
*fixups
= NULL
;
352 bfd_boolean changed_contents
= FALSE
;
353 bfd_boolean changed_relocs
= FALSE
;
354 bfd_boolean skip_relax_pass_0
= TRUE
;
355 bfd_boolean skip_relax_pass_1
= TRUE
;
358 /* Assume we're not going to change any sizes, and we'll only need
362 if (bfd_link_relocatable (link_info
))
363 (*link_info
->callbacks
->einfo
)
364 (_("%P%F: --relax and -r may not be used together\n"));
366 /* Don't even try to relax for non-ELF outputs. */
367 if (!is_elf_hash_table (link_info
->hash
))
370 /* Nothing to do if there are no relocations or there is no need for
372 if ((sec
->flags
& SEC_RELOC
) == 0
373 || sec
->reloc_count
== 0
374 || (link_info
->relax_pass
== 0 && sec
->skip_relax_pass_0
)
375 || (link_info
->relax_pass
== 1 && sec
->skip_relax_pass_1
))
378 ia64_info
= elf64_ia64_hash_table (link_info
);
379 if (ia64_info
== NULL
)
382 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
384 /* Load the relocations for this section. */
385 internal_relocs
= (_bfd_elf_link_read_relocs
386 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
387 link_info
->keep_memory
));
388 if (internal_relocs
== NULL
)
391 irelend
= internal_relocs
+ sec
->reloc_count
;
393 /* Get the section contents. */
394 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
395 contents
= elf_section_data (sec
)->this_hdr
.contents
;
398 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
402 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
404 unsigned long r_type
= ELF64_R_TYPE (irel
->r_info
);
405 bfd_vma symaddr
, reladdr
, trampoff
, toff
, roff
;
409 bfd_boolean is_branch
;
410 struct elf64_ia64_dyn_sym_info
*dyn_i
;
414 case R_IA64_PCREL21B
:
415 case R_IA64_PCREL21BI
:
416 case R_IA64_PCREL21M
:
417 case R_IA64_PCREL21F
:
418 /* In pass 1, all br relaxations are done. We can skip it. */
419 if (link_info
->relax_pass
== 1)
421 skip_relax_pass_0
= FALSE
;
425 case R_IA64_PCREL60B
:
426 /* We can't optimize brl to br in pass 0 since br relaxations
427 will increase the code size. Defer it to pass 1. */
428 if (link_info
->relax_pass
== 0)
430 skip_relax_pass_1
= FALSE
;
437 /* Update max_short_sec/min_short_sec. */
439 case R_IA64_LTOFF22X
:
441 /* We can't relax ldx/mov in pass 0 since br relaxations will
442 increase the code size. Defer it to pass 1. */
443 if (link_info
->relax_pass
== 0)
445 skip_relax_pass_1
= FALSE
;
455 /* Get the value of the symbol referred to by the reloc. */
456 if (ELF64_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
458 /* A local symbol. */
459 Elf_Internal_Sym
*isym
;
461 /* Read this BFD's local symbols. */
464 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
466 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
467 symtab_hdr
->sh_info
, 0,
473 isym
= isymbuf
+ ELF64_R_SYM (irel
->r_info
);
474 if (isym
->st_shndx
== SHN_UNDEF
)
475 continue; /* We can't do anything with undefined symbols. */
476 else if (isym
->st_shndx
== SHN_ABS
)
477 tsec
= bfd_abs_section_ptr
;
478 else if (isym
->st_shndx
== SHN_COMMON
)
479 tsec
= bfd_com_section_ptr
;
480 else if (isym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
481 tsec
= bfd_com_section_ptr
;
483 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
485 toff
= isym
->st_value
;
486 dyn_i
= get_dyn_sym_info (ia64_info
, NULL
, abfd
, irel
, FALSE
);
491 struct elf_link_hash_entry
*h
;
493 indx
= ELF64_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
494 h
= elf_sym_hashes (abfd
)[indx
];
495 BFD_ASSERT (h
!= NULL
);
497 while (h
->root
.type
== bfd_link_hash_indirect
498 || h
->root
.type
== bfd_link_hash_warning
)
499 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
501 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, irel
, FALSE
);
503 /* For branches to dynamic symbols, we're interested instead
504 in a branch to the PLT entry. */
505 if (is_branch
&& dyn_i
&& dyn_i
->want_plt2
)
507 /* Internal branches shouldn't be sent to the PLT.
508 Leave this for now and we'll give an error later. */
509 if (r_type
!= R_IA64_PCREL21B
)
512 tsec
= ia64_info
->root
.splt
;
513 toff
= dyn_i
->plt2_offset
;
514 BFD_ASSERT (irel
->r_addend
== 0);
517 /* Can't do anything else with dynamic symbols. */
518 else if (elf64_ia64_dynamic_symbol_p (h
))
523 /* We can't do anything with undefined symbols. */
524 if (h
->root
.type
== bfd_link_hash_undefined
525 || h
->root
.type
== bfd_link_hash_undefweak
)
528 tsec
= h
->root
.u
.def
.section
;
529 toff
= h
->root
.u
.def
.value
;
533 toff
+= irel
->r_addend
;
535 symaddr
= tsec
->output_section
->vma
+ tsec
->output_offset
+ toff
;
537 roff
= irel
->r_offset
;
541 bfd_signed_vma offset
;
543 reladdr
= (sec
->output_section
->vma
545 + roff
) & (bfd_vma
) -4;
547 /* The .plt section is aligned at 32byte and the .text section
548 is aligned at 64byte. The .text section is right after the
549 .plt section. After the first relaxation pass, linker may
550 increase the gap between the .plt and .text sections up
551 to 32byte. We assume linker will always insert 32byte
552 between the .plt and .text sections after the first
554 if (tsec
== ia64_info
->root
.splt
)
555 offset
= -0x1000000 + 32;
559 /* If the branch is in range, no need to do anything. */
560 if ((bfd_signed_vma
) (symaddr
- reladdr
) >= offset
561 && (bfd_signed_vma
) (symaddr
- reladdr
) <= 0x0FFFFF0)
563 /* If the 60-bit branch is in 21-bit range, optimize it. */
564 if (r_type
== R_IA64_PCREL60B
)
566 ia64_elf_relax_brl (contents
, roff
);
568 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
571 /* If the original relocation offset points to slot
572 1, change it to slot 2. */
573 if ((irel
->r_offset
& 3) == 1)
579 else if (r_type
== R_IA64_PCREL60B
)
581 else if (ia64_elf_relax_br (contents
, roff
))
583 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
586 /* Make the relocation offset point to slot 1. */
587 irel
->r_offset
= (irel
->r_offset
& ~((bfd_vma
) 0x3)) + 1;
591 /* We can't put a trampoline in a .init/.fini section. Issue
593 if (strcmp (sec
->output_section
->name
, ".init") == 0
594 || strcmp (sec
->output_section
->name
, ".fini") == 0)
597 /* xgettext:c-format */
598 (_("%pB: can't relax br at %#" PRIx64
" in section `%pA';"
599 " please use brl or indirect branch"),
600 sec
->owner
, (uint64_t) roff
, sec
);
601 bfd_set_error (bfd_error_bad_value
);
605 /* If the branch and target are in the same section, you've
606 got one honking big section and we can't help you unless
607 you are branching backwards. You'll get an error message
609 if (tsec
== sec
&& toff
> roff
)
612 /* Look for an existing fixup to this address. */
613 for (f
= fixups
; f
; f
= f
->next
)
614 if (f
->tsec
== tsec
&& f
->toff
== toff
)
619 /* Two alternatives: If it's a branch to a PLT entry, we can
620 make a copy of the FULL_PLT entry. Otherwise, we'll have
621 to use a `brl' insn to get where we're going. */
625 if (tsec
== ia64_info
->root
.splt
)
626 size
= sizeof (plt_full_entry
);
628 size
= sizeof (oor_brl
);
630 /* Resize the current section to make room for the new branch. */
631 trampoff
= (sec
->size
+ 15) & (bfd_vma
) -16;
633 /* If trampoline is out of range, there is nothing we
635 offset
= trampoff
- (roff
& (bfd_vma
) -4);
636 if (offset
< -0x1000000 || offset
> 0x0FFFFF0)
639 amt
= trampoff
+ size
;
640 contents
= (bfd_byte
*) bfd_realloc (contents
, amt
);
641 if (contents
== NULL
)
645 if (tsec
== ia64_info
->root
.splt
)
647 memcpy (contents
+ trampoff
, plt_full_entry
, size
);
649 /* Hijack the old relocation for use as the PLTOFF reloc. */
650 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
652 irel
->r_offset
= trampoff
;
656 memcpy (contents
+ trampoff
, oor_brl
, size
);
657 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
659 irel
->r_offset
= trampoff
+ 2;
662 /* Record the fixup so we don't do it again this section. */
663 f
= (struct one_fixup
*)
664 bfd_malloc ((bfd_size_type
) sizeof (*f
));
668 f
->trampoff
= trampoff
;
673 /* If trampoline is out of range, there is nothing we
675 offset
= f
->trampoff
- (roff
& (bfd_vma
) -4);
676 if (offset
< -0x1000000 || offset
> 0x0FFFFF0)
679 /* Nop out the reloc, since we're finalizing things here. */
680 irel
->r_info
= ELF64_R_INFO (0, R_IA64_NONE
);
683 /* Fix up the existing branch to hit the trampoline. */
684 if (ia64_elf_install_value (contents
+ roff
, offset
, r_type
)
688 changed_contents
= TRUE
;
689 changed_relocs
= TRUE
;
696 bfd
*obfd
= sec
->output_section
->owner
;
697 gp
= _bfd_get_gp_value (obfd
);
700 if (!elf64_ia64_choose_gp (obfd
, link_info
, FALSE
))
702 gp
= _bfd_get_gp_value (obfd
);
706 /* If the data is out of range, do nothing. */
707 if ((bfd_signed_vma
) (symaddr
- gp
) >= 0x200000
708 ||(bfd_signed_vma
) (symaddr
- gp
) < -0x200000)
711 if (r_type
== R_IA64_GPREL22
)
712 elf64_ia64_update_short_info (tsec
->output_section
,
713 tsec
->output_offset
+ toff
,
715 else if (r_type
== R_IA64_LTOFF22X
)
717 /* Can't deal yet correctly with ABS symbols. */
718 if (bfd_is_abs_section (tsec
))
721 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
723 changed_relocs
= TRUE
;
725 elf64_ia64_update_short_info (tsec
->output_section
,
726 tsec
->output_offset
+ toff
,
731 ia64_elf_relax_ldxmov (contents
, roff
);
732 irel
->r_info
= ELF64_R_INFO (0, R_IA64_NONE
);
733 changed_contents
= TRUE
;
734 changed_relocs
= TRUE
;
739 /* ??? If we created fixups, this may push the code segment large
740 enough that the data segment moves, which will change the GP.
741 Reset the GP so that we re-calculate next round. We need to
742 do this at the _beginning_ of the next round; now will not do. */
744 /* Clean up and go home. */
747 struct one_fixup
*f
= fixups
;
748 fixups
= fixups
->next
;
753 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
755 if (! link_info
->keep_memory
)
759 /* Cache the symbols for elf_link_input_bfd. */
760 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
765 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
767 if (!changed_contents
&& !link_info
->keep_memory
)
771 /* Cache the section contents for elf_link_input_bfd. */
772 elf_section_data (sec
)->this_hdr
.contents
= contents
;
776 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
779 free (internal_relocs
);
781 elf_section_data (sec
)->relocs
= internal_relocs
;
784 if (link_info
->relax_pass
== 0)
786 /* Pass 0 is only needed to relax br. */
787 sec
->skip_relax_pass_0
= skip_relax_pass_0
;
788 sec
->skip_relax_pass_1
= skip_relax_pass_1
;
791 *again
= changed_contents
|| changed_relocs
;
795 if (isymbuf
!= NULL
&& (unsigned char *) isymbuf
!= symtab_hdr
->contents
)
798 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
800 if (internal_relocs
!= NULL
801 && elf_section_data (sec
)->relocs
!= internal_relocs
)
802 free (internal_relocs
);
805 #undef skip_relax_pass_0
806 #undef skip_relax_pass_1
808 /* Return TRUE if NAME is an unwind table section name. */
810 static inline bfd_boolean
811 is_unwind_section_name (bfd
*abfd ATTRIBUTE_UNUSED
, const char *name
)
813 return ((CONST_STRNEQ (name
, ELF_STRING_ia64_unwind
)
814 && ! CONST_STRNEQ (name
, ELF_STRING_ia64_unwind_info
))
815 || CONST_STRNEQ (name
, ELF_STRING_ia64_unwind_once
));
819 /* Convert IA-64 specific section flags to bfd internal section flags. */
821 /* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
825 elf64_ia64_section_flags (const Elf_Internal_Shdr
*hdr
)
827 if (hdr
->sh_flags
& SHF_IA_64_SHORT
)
828 hdr
->bfd_section
->flags
|= SEC_SMALL_DATA
;
833 /* Set the correct type for an IA-64 ELF section. We do this by the
834 section name, which is a hack, but ought to work. */
837 elf64_ia64_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
842 name
= bfd_section_name (sec
);
844 if (is_unwind_section_name (abfd
, name
))
846 /* We don't have the sections numbered at this point, so sh_info
847 is set later, in elf64_ia64_final_write_processing. */
848 hdr
->sh_type
= SHT_IA_64_UNWIND
;
849 hdr
->sh_flags
|= SHF_LINK_ORDER
;
851 else if (strcmp (name
, ELF_STRING_ia64_archext
) == 0)
852 hdr
->sh_type
= SHT_IA_64_EXT
;
854 if (sec
->flags
& SEC_SMALL_DATA
)
855 hdr
->sh_flags
|= SHF_IA_64_SHORT
;
860 /* Hook called by the linker routine which adds symbols from an object
861 file. We use it to put .comm items in .sbss, and not .bss. */
864 elf64_ia64_add_symbol_hook (bfd
*abfd
,
865 struct bfd_link_info
*info
,
866 Elf_Internal_Sym
*sym
,
867 const char **namep ATTRIBUTE_UNUSED
,
868 flagword
*flagsp ATTRIBUTE_UNUSED
,
872 if (sym
->st_shndx
== SHN_COMMON
873 && !bfd_link_relocatable (info
)
874 && sym
->st_size
<= elf_gp_size (abfd
))
876 /* Common symbols less than or equal to -G nn bytes are
877 automatically put into .sbss. */
879 asection
*scomm
= bfd_get_section_by_name (abfd
, ".scommon");
883 scomm
= bfd_make_section_with_flags (abfd
, ".scommon",
886 | SEC_LINKER_CREATED
));
892 *valp
= sym
->st_size
;
898 /* According to the Tahoe assembler spec, all labels starting with a
902 elf64_ia64_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
905 return name
[0] == '.';
908 /* Should we do dynamic things to this symbol? */
911 elf64_ia64_dynamic_symbol_p (struct elf_link_hash_entry
*h
)
913 return h
!= NULL
&& h
->def_dynamic
;
916 static struct bfd_hash_entry
*
917 elf64_ia64_new_elf_hash_entry (struct bfd_hash_entry
*entry
,
918 struct bfd_hash_table
*table
,
921 struct elf64_ia64_link_hash_entry
*ret
;
922 ret
= (struct elf64_ia64_link_hash_entry
*) entry
;
924 /* Allocate the structure if it has not already been allocated by a
927 ret
= bfd_hash_allocate (table
, sizeof (*ret
));
932 /* Call the allocation method of the superclass. */
933 ret
= ((struct elf64_ia64_link_hash_entry
*)
934 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
939 ret
->sorted_count
= 0;
941 return (struct bfd_hash_entry
*) ret
;
945 elf64_ia64_hash_hide_symbol (struct bfd_link_info
*info
,
946 struct elf_link_hash_entry
*xh
,
947 bfd_boolean force_local
)
949 struct elf64_ia64_link_hash_entry
*h
;
950 struct elf64_ia64_dyn_sym_info
*dyn_i
;
953 h
= (struct elf64_ia64_link_hash_entry
*)xh
;
955 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
957 for (count
= h
->count
, dyn_i
= h
->info
;
961 dyn_i
->want_plt2
= 0;
966 /* Compute a hash of a local hash entry. */
969 elf64_ia64_local_htab_hash (const void *ptr
)
971 struct elf64_ia64_local_hash_entry
*entry
972 = (struct elf64_ia64_local_hash_entry
*) ptr
;
974 return ELF_LOCAL_SYMBOL_HASH (entry
->id
, entry
->r_sym
);
977 /* Compare local hash entries. */
980 elf64_ia64_local_htab_eq (const void *ptr1
, const void *ptr2
)
982 struct elf64_ia64_local_hash_entry
*entry1
983 = (struct elf64_ia64_local_hash_entry
*) ptr1
;
984 struct elf64_ia64_local_hash_entry
*entry2
985 = (struct elf64_ia64_local_hash_entry
*) ptr2
;
987 return entry1
->id
== entry2
->id
&& entry1
->r_sym
== entry2
->r_sym
;
990 /* Free the global elf64_ia64_dyn_sym_info array. */
993 elf64_ia64_global_dyn_info_free (void **xentry
,
994 void * unused ATTRIBUTE_UNUSED
)
996 struct elf64_ia64_link_hash_entry
*entry
997 = (struct elf64_ia64_link_hash_entry
*) xentry
;
999 if (entry
->root
.root
.type
== bfd_link_hash_warning
)
1000 entry
= (struct elf64_ia64_link_hash_entry
*) entry
->root
.root
.u
.i
.link
;
1007 entry
->sorted_count
= 0;
1014 /* Free the local elf64_ia64_dyn_sym_info array. */
1017 elf64_ia64_local_dyn_info_free (void **slot
,
1018 void * unused ATTRIBUTE_UNUSED
)
1020 struct elf64_ia64_local_hash_entry
*entry
1021 = (struct elf64_ia64_local_hash_entry
*) *slot
;
1028 entry
->sorted_count
= 0;
1035 /* Destroy IA-64 linker hash table. */
1038 elf64_ia64_link_hash_table_free (bfd
*obfd
)
1040 struct elf64_ia64_link_hash_table
*ia64_info
1041 = (struct elf64_ia64_link_hash_table
*) obfd
->link
.hash
;
1042 if (ia64_info
->loc_hash_table
)
1044 htab_traverse (ia64_info
->loc_hash_table
,
1045 elf64_ia64_local_dyn_info_free
, NULL
);
1046 htab_delete (ia64_info
->loc_hash_table
);
1048 if (ia64_info
->loc_hash_memory
)
1049 objalloc_free ((struct objalloc
*) ia64_info
->loc_hash_memory
);
1050 elf_link_hash_traverse (&ia64_info
->root
,
1051 elf64_ia64_global_dyn_info_free
, NULL
);
1052 _bfd_elf_link_hash_table_free (obfd
);
1055 /* Create the derived linker hash table. The IA-64 ELF port uses this
1056 derived hash table to keep information specific to the IA-64 ElF
1057 linker (without using static variables). */
1059 static struct bfd_link_hash_table
*
1060 elf64_ia64_hash_table_create (bfd
*abfd
)
1062 struct elf64_ia64_link_hash_table
*ret
;
1064 ret
= bfd_zmalloc ((bfd_size_type
) sizeof (*ret
));
1068 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
1069 elf64_ia64_new_elf_hash_entry
,
1070 sizeof (struct elf64_ia64_link_hash_entry
),
1077 ret
->loc_hash_table
= htab_try_create (1024, elf64_ia64_local_htab_hash
,
1078 elf64_ia64_local_htab_eq
, NULL
);
1079 ret
->loc_hash_memory
= objalloc_create ();
1080 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1082 elf64_ia64_link_hash_table_free (abfd
);
1085 ret
->root
.root
.hash_table_free
= elf64_ia64_link_hash_table_free
;
1087 return &ret
->root
.root
;
1090 /* Traverse both local and global hash tables. */
1092 struct elf64_ia64_dyn_sym_traverse_data
1094 bfd_boolean (*func
) (struct elf64_ia64_dyn_sym_info
*, void *);
1099 elf64_ia64_global_dyn_sym_thunk (struct bfd_hash_entry
*xentry
,
1102 struct elf64_ia64_link_hash_entry
*entry
1103 = (struct elf64_ia64_link_hash_entry
*) xentry
;
1104 struct elf64_ia64_dyn_sym_traverse_data
*data
1105 = (struct elf64_ia64_dyn_sym_traverse_data
*) xdata
;
1106 struct elf64_ia64_dyn_sym_info
*dyn_i
;
1109 if (entry
->root
.root
.type
== bfd_link_hash_warning
)
1110 entry
= (struct elf64_ia64_link_hash_entry
*) entry
->root
.root
.u
.i
.link
;
1112 for (count
= entry
->count
, dyn_i
= entry
->info
;
1115 if (! (*data
->func
) (dyn_i
, data
->data
))
1121 elf64_ia64_local_dyn_sym_thunk (void **slot
, void * xdata
)
1123 struct elf64_ia64_local_hash_entry
*entry
1124 = (struct elf64_ia64_local_hash_entry
*) *slot
;
1125 struct elf64_ia64_dyn_sym_traverse_data
*data
1126 = (struct elf64_ia64_dyn_sym_traverse_data
*) xdata
;
1127 struct elf64_ia64_dyn_sym_info
*dyn_i
;
1130 for (count
= entry
->count
, dyn_i
= entry
->info
;
1133 if (! (*data
->func
) (dyn_i
, data
->data
))
1139 elf64_ia64_dyn_sym_traverse (struct elf64_ia64_link_hash_table
*ia64_info
,
1140 bfd_boolean (*func
) (struct elf64_ia64_dyn_sym_info
*, void *),
1143 struct elf64_ia64_dyn_sym_traverse_data xdata
;
1148 elf_link_hash_traverse (&ia64_info
->root
,
1149 elf64_ia64_global_dyn_sym_thunk
, &xdata
);
1150 htab_traverse (ia64_info
->loc_hash_table
,
1151 elf64_ia64_local_dyn_sym_thunk
, &xdata
);
1154 #define NOTE_NAME "IPF/VMS"
1157 create_ia64_vms_notes (bfd
*abfd
, struct bfd_link_info
*info
,
1158 unsigned int time_hi
, unsigned int time_lo
)
1161 Elf_Internal_Note notes
[NBR_NOTES
];
1163 int module_name_len
;
1164 unsigned char cur_time
[8];
1165 Elf64_External_VMS_ORIG_DYN_Note
*orig_dyn
;
1166 unsigned int orig_dyn_size
;
1167 unsigned int note_size
;
1169 unsigned char *noteptr
;
1170 unsigned char *note_contents
;
1171 struct elf64_ia64_link_hash_table
*ia64_info
;
1173 ia64_info
= elf64_ia64_hash_table (info
);
1175 module_name
= vms_get_module_name (bfd_get_filename (abfd
), TRUE
);
1176 module_name_len
= strlen (module_name
) + 1;
1178 bfd_putl32 (time_lo
, cur_time
+ 0);
1179 bfd_putl32 (time_hi
, cur_time
+ 4);
1181 /* Note 0: IMGNAM. */
1182 notes
[0].type
= NT_VMS_IMGNAM
;
1183 notes
[0].descdata
= module_name
;
1184 notes
[0].descsz
= module_name_len
;
1186 /* Note 1: GSTNAM. */
1187 notes
[1].type
= NT_VMS_GSTNAM
;
1188 notes
[1].descdata
= module_name
;
1189 notes
[1].descsz
= module_name_len
;
1191 /* Note 2: IMGID. */
1192 #define IMG_ID "V1.0"
1193 notes
[2].type
= NT_VMS_IMGID
;
1194 notes
[2].descdata
= IMG_ID
;
1195 notes
[2].descsz
= sizeof (IMG_ID
);
1197 /* Note 3: Linktime. */
1198 notes
[3].type
= NT_VMS_LINKTIME
;
1199 notes
[3].descdata
= (char *)cur_time
;
1200 notes
[3].descsz
= sizeof (cur_time
);
1202 /* Note 4: Linker id. */
1203 notes
[4].type
= NT_VMS_LINKID
;
1204 notes
[4].descdata
= "GNU ld " BFD_VERSION_STRING
;
1205 notes
[4].descsz
= strlen (notes
[4].descdata
) + 1;
1207 /* Note 5: Original dyn. */
1208 orig_dyn_size
= (sizeof (*orig_dyn
) + sizeof (IMG_ID
) - 1 + 7) & ~7;
1209 orig_dyn
= bfd_zalloc (abfd
, orig_dyn_size
);
1210 if (orig_dyn
== NULL
)
1212 bfd_putl32 (1, orig_dyn
->major_id
);
1213 bfd_putl32 (3, orig_dyn
->minor_id
);
1214 memcpy (orig_dyn
->manipulation_date
, cur_time
, sizeof (cur_time
));
1215 bfd_putl64 (VMS_LF_IMGSTA
| VMS_LF_MAIN
, orig_dyn
->link_flags
);
1216 bfd_putl32 (EF_IA_64_ABI64
, orig_dyn
->elf_flags
);
1217 memcpy (orig_dyn
->imgid
, IMG_ID
, sizeof (IMG_ID
));
1218 notes
[5].type
= NT_VMS_ORIG_DYN
;
1219 notes
[5].descdata
= (char *)orig_dyn
;
1220 notes
[5].descsz
= orig_dyn_size
;
1222 /* Note 3: Patchtime. */
1223 notes
[6].type
= NT_VMS_PATCHTIME
;
1224 notes
[6].descdata
= (char *)cur_time
;
1225 notes
[6].descsz
= sizeof (cur_time
);
1227 /* Compute notes size. */
1229 for (i
= 0; i
< NBR_NOTES
; i
++)
1230 note_size
+= sizeof (Elf64_External_VMS_Note
) - 1
1231 + ((sizeof (NOTE_NAME
) - 1 + 7) & ~7)
1232 + ((notes
[i
].descsz
+ 7) & ~7);
1234 /* Malloc a temporary buffer large enough for most notes */
1235 note_contents
= (unsigned char *) bfd_zalloc (abfd
, note_size
);
1236 if (note_contents
== NULL
)
1238 noteptr
= note_contents
;
1241 for (i
= 0; i
< NBR_NOTES
; i
++)
1243 Elf64_External_VMS_Note
*enote
= (Elf64_External_VMS_Note
*) noteptr
;
1245 bfd_putl64 (sizeof (NOTE_NAME
) - 1, enote
->namesz
);
1246 bfd_putl64 (notes
[i
].descsz
, enote
->descsz
);
1247 bfd_putl64 (notes
[i
].type
, enote
->type
);
1249 noteptr
= (unsigned char *)enote
->name
;
1250 memcpy (noteptr
, NOTE_NAME
, sizeof (NOTE_NAME
) - 1);
1251 noteptr
+= (sizeof (NOTE_NAME
) - 1 + 7) & ~7;
1252 memcpy (noteptr
, notes
[i
].descdata
, notes
[i
].descsz
);
1253 noteptr
+= (notes
[i
].descsz
+ 7) & ~7;
1256 ia64_info
->note_sec
->contents
= note_contents
;
1257 ia64_info
->note_sec
->size
= note_size
;
1265 elf64_ia64_create_dynamic_sections (bfd
*abfd
,
1266 struct bfd_link_info
*info
)
1268 struct elf64_ia64_link_hash_table
*ia64_info
;
1271 const struct elf_backend_data
*bed
;
1273 ia64_info
= elf64_ia64_hash_table (info
);
1274 if (ia64_info
== NULL
)
1277 if (elf_hash_table (info
)->dynamic_sections_created
)
1280 abfd
= elf_hash_table (info
)->dynobj
;
1281 bed
= get_elf_backend_data (abfd
);
1283 flags
= bed
->dynamic_sec_flags
;
1285 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynamic",
1286 flags
| SEC_READONLY
);
1288 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
1291 s
= bfd_make_section_anyway_with_flags (abfd
, ".plt", flags
| SEC_READONLY
);
1293 || !bfd_set_section_alignment (s
, bed
->plt_alignment
))
1295 ia64_info
->root
.splt
= s
;
1297 if (!get_got (abfd
, ia64_info
))
1300 if (!get_pltoff (abfd
, ia64_info
))
1303 s
= bfd_make_section_anyway_with_flags (abfd
, ".vmsdynstr",
1307 | SEC_LINKER_CREATED
));
1309 || !bfd_set_section_alignment (s
, 0))
1312 /* Create a fixup section. */
1313 s
= bfd_make_section_anyway_with_flags (abfd
, ".fixups",
1317 | SEC_LINKER_CREATED
));
1319 || !bfd_set_section_alignment (s
, 3))
1321 ia64_info
->fixups_sec
= s
;
1323 /* Create the transfer fixup section. */
1324 s
= bfd_make_section_anyway_with_flags (abfd
, ".transfer",
1328 | SEC_LINKER_CREATED
));
1330 || !bfd_set_section_alignment (s
, 3))
1332 s
->size
= sizeof (struct elf64_vms_transfer
);
1333 ia64_info
->transfer_sec
= s
;
1335 /* Create note section. */
1336 s
= bfd_make_section_anyway_with_flags (abfd
, ".vms.note",
1342 || !bfd_set_section_alignment (s
, 3))
1344 ia64_info
->note_sec
= s
;
1346 elf_hash_table (info
)->dynamic_sections_created
= TRUE
;
1350 /* Find and/or create a hash entry for local symbol. */
1351 static struct elf64_ia64_local_hash_entry
*
1352 get_local_sym_hash (struct elf64_ia64_link_hash_table
*ia64_info
,
1353 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
1356 struct elf64_ia64_local_hash_entry e
, *ret
;
1357 asection
*sec
= abfd
->sections
;
1358 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
1359 ELF64_R_SYM (rel
->r_info
));
1363 e
.r_sym
= ELF64_R_SYM (rel
->r_info
);
1364 slot
= htab_find_slot_with_hash (ia64_info
->loc_hash_table
, &e
, h
,
1365 create
? INSERT
: NO_INSERT
);
1371 return (struct elf64_ia64_local_hash_entry
*) *slot
;
1373 ret
= (struct elf64_ia64_local_hash_entry
*)
1374 objalloc_alloc ((struct objalloc
*) ia64_info
->loc_hash_memory
,
1375 sizeof (struct elf64_ia64_local_hash_entry
));
1378 memset (ret
, 0, sizeof (*ret
));
1380 ret
->r_sym
= ELF64_R_SYM (rel
->r_info
);
1386 /* Used to sort elf64_ia64_dyn_sym_info array. */
1389 addend_compare (const void *xp
, const void *yp
)
1391 const struct elf64_ia64_dyn_sym_info
*x
1392 = (const struct elf64_ia64_dyn_sym_info
*) xp
;
1393 const struct elf64_ia64_dyn_sym_info
*y
1394 = (const struct elf64_ia64_dyn_sym_info
*) yp
;
1396 return x
->addend
< y
->addend
? -1 : x
->addend
> y
->addend
? 1 : 0;
1399 /* Sort elf64_ia64_dyn_sym_info array and remove duplicates. */
1402 sort_dyn_sym_info (struct elf64_ia64_dyn_sym_info
*info
,
1405 bfd_vma curr
, prev
, got_offset
;
1406 unsigned int i
, kept
, dupes
, diff
, dest
, src
, len
;
1408 qsort (info
, count
, sizeof (*info
), addend_compare
);
1410 /* Find the first duplicate. */
1411 prev
= info
[0].addend
;
1412 got_offset
= info
[0].got_offset
;
1413 for (i
= 1; i
< count
; i
++)
1415 curr
= info
[i
].addend
;
1418 /* For duplicates, make sure that GOT_OFFSET is valid. */
1419 if (got_offset
== (bfd_vma
) -1)
1420 got_offset
= info
[i
].got_offset
;
1423 got_offset
= info
[i
].got_offset
;
1427 /* We may move a block of elements to here. */
1430 /* Remove duplicates. */
1435 /* For duplicates, make sure that the kept one has a valid
1438 if (got_offset
!= (bfd_vma
) -1)
1439 info
[kept
].got_offset
= got_offset
;
1441 curr
= info
[i
].addend
;
1442 got_offset
= info
[i
].got_offset
;
1444 /* Move a block of elements whose first one is different from
1448 for (src
= i
+ 1; src
< count
; src
++)
1450 if (info
[src
].addend
!= curr
)
1452 /* For duplicates, make sure that GOT_OFFSET is
1454 if (got_offset
== (bfd_vma
) -1)
1455 got_offset
= info
[src
].got_offset
;
1458 /* Make sure that the kept one has a valid got_offset. */
1459 if (got_offset
!= (bfd_vma
) -1)
1460 info
[kept
].got_offset
= got_offset
;
1468 /* Find the next duplicate. SRC will be kept. */
1469 prev
= info
[src
].addend
;
1470 got_offset
= info
[src
].got_offset
;
1471 for (dupes
= src
+ 1; dupes
< count
; dupes
++)
1473 curr
= info
[dupes
].addend
;
1476 /* Make sure that got_offset is valid. */
1477 if (got_offset
== (bfd_vma
) -1)
1478 got_offset
= info
[dupes
].got_offset
;
1480 /* For duplicates, make sure that the kept one has
1481 a valid got_offset. */
1482 if (got_offset
!= (bfd_vma
) -1)
1483 info
[dupes
- 1].got_offset
= got_offset
;
1486 got_offset
= info
[dupes
].got_offset
;
1490 /* How much to move. */
1494 if (len
== 1 && dupes
< count
)
1496 /* If we only move 1 element, we combine it with the next
1497 one. There must be at least a duplicate. Find the
1498 next different one. */
1499 for (diff
= dupes
+ 1, src
++; diff
< count
; diff
++, src
++)
1501 if (info
[diff
].addend
!= curr
)
1503 /* Make sure that got_offset is valid. */
1504 if (got_offset
== (bfd_vma
) -1)
1505 got_offset
= info
[diff
].got_offset
;
1508 /* Makre sure that the last duplicated one has an valid
1510 BFD_ASSERT (curr
== prev
);
1511 if (got_offset
!= (bfd_vma
) -1)
1512 info
[diff
- 1].got_offset
= got_offset
;
1516 /* Find the next duplicate. Track the current valid
1518 prev
= info
[diff
].addend
;
1519 got_offset
= info
[diff
].got_offset
;
1520 for (dupes
= diff
+ 1; dupes
< count
; dupes
++)
1522 curr
= info
[dupes
].addend
;
1525 /* For duplicates, make sure that GOT_OFFSET
1527 if (got_offset
== (bfd_vma
) -1)
1528 got_offset
= info
[dupes
].got_offset
;
1531 got_offset
= info
[dupes
].got_offset
;
1536 len
= diff
- src
+ 1;
1541 memmove (&info
[dest
], &info
[src
], len
* sizeof (*info
));
1550 /* When we get here, either there is no duplicate at all or
1551 the only duplicate is the last element. */
1554 /* If the last element is a duplicate, make sure that the
1555 kept one has a valid got_offset. We also update count. */
1556 if (got_offset
!= (bfd_vma
) -1)
1557 info
[dest
- 1].got_offset
= got_offset
;
1565 /* Find and/or create a descriptor for dynamic symbol info. This will
1566 vary based on global or local symbol, and the addend to the reloc.
1568 We don't sort when inserting. Also, we sort and eliminate
1569 duplicates if there is an unsorted section. Typically, this will
1570 only happen once, because we do all insertions before lookups. We
1571 then use bsearch to do a lookup. This also allows lookups to be
1572 fast. So we have fast insertion (O(log N) due to duplicate check),
1573 fast lookup (O(log N)) and one sort (O(N log N) expected time).
1574 Previously, all lookups were O(N) because of the use of the linked
1575 list and also all insertions were O(N) because of the check for
1576 duplicates. There are some complications here because the array
1577 size grows occasionally, which may add an O(N) factor, but this
1578 should be rare. Also, we free the excess array allocation, which
1579 requires a copy which is O(N), but this only happens once. */
1581 static struct elf64_ia64_dyn_sym_info
*
1582 get_dyn_sym_info (struct elf64_ia64_link_hash_table
*ia64_info
,
1583 struct elf_link_hash_entry
*h
, bfd
*abfd
,
1584 const Elf_Internal_Rela
*rel
, bfd_boolean create
)
1586 struct elf64_ia64_dyn_sym_info
**info_p
, *info
, *dyn_i
, key
;
1587 unsigned int *count_p
, *sorted_count_p
, *size_p
;
1588 unsigned int count
, sorted_count
, size
;
1589 bfd_vma addend
= rel
? rel
->r_addend
: 0;
1594 struct elf64_ia64_link_hash_entry
*global_h
;
1596 global_h
= (struct elf64_ia64_link_hash_entry
*) h
;
1597 info_p
= &global_h
->info
;
1598 count_p
= &global_h
->count
;
1599 sorted_count_p
= &global_h
->sorted_count
;
1600 size_p
= &global_h
->size
;
1604 struct elf64_ia64_local_hash_entry
*loc_h
;
1606 loc_h
= get_local_sym_hash (ia64_info
, abfd
, rel
, create
);
1609 BFD_ASSERT (!create
);
1613 info_p
= &loc_h
->info
;
1614 count_p
= &loc_h
->count
;
1615 sorted_count_p
= &loc_h
->sorted_count
;
1616 size_p
= &loc_h
->size
;
1620 sorted_count
= *sorted_count_p
;
1625 /* When we create the array, we don't check for duplicates,
1626 except in the previously sorted section if one exists, and
1627 against the last inserted entry. This allows insertions to
1633 /* Try bsearch first on the sorted section. */
1634 key
.addend
= addend
;
1635 dyn_i
= bsearch (&key
, info
, sorted_count
,
1636 sizeof (*info
), addend_compare
);
1644 /* Do a quick check for the last inserted entry. */
1645 dyn_i
= info
+ count
- 1;
1646 if (dyn_i
->addend
== addend
)
1654 /* It is the very first element. We create the array of size
1657 amt
= size
* sizeof (*info
);
1658 info
= bfd_malloc (amt
);
1660 else if (size
<= count
)
1662 /* We double the array size every time when we reach the
1665 amt
= size
* sizeof (*info
);
1666 info
= bfd_realloc (info
, amt
);
1677 /* Append the new one to the array. */
1678 dyn_i
= info
+ count
;
1679 memset (dyn_i
, 0, sizeof (*dyn_i
));
1680 dyn_i
->got_offset
= (bfd_vma
) -1;
1681 dyn_i
->addend
= addend
;
1683 /* We increment count only since the new ones are unsorted and
1684 may have duplicate. */
1689 /* It is a lookup without insertion. Sort array if part of the
1690 array isn't sorted. */
1691 if (count
!= sorted_count
)
1693 count
= sort_dyn_sym_info (info
, count
);
1695 *sorted_count_p
= count
;
1698 /* Free unused memory. */
1701 amt
= count
* sizeof (*info
);
1702 info
= bfd_malloc (amt
);
1705 memcpy (info
, *info_p
, amt
);
1712 key
.addend
= addend
;
1713 dyn_i
= bsearch (&key
, info
, count
,
1714 sizeof (*info
), addend_compare
);
1721 get_got (bfd
*abfd
, struct elf64_ia64_link_hash_table
*ia64_info
)
1726 got
= ia64_info
->root
.sgot
;
1731 dynobj
= ia64_info
->root
.dynobj
;
1733 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1735 /* The .got section is always aligned at 8 bytes. */
1736 flags
= get_elf_backend_data (dynobj
)->dynamic_sec_flags
;
1737 got
= bfd_make_section_anyway_with_flags (dynobj
, ".got",
1738 flags
| SEC_SMALL_DATA
);
1740 || !bfd_set_section_alignment (got
, 3))
1742 ia64_info
->root
.sgot
= got
;
1748 /* Create function descriptor section (.opd). This section is called .opd
1749 because it contains "official procedure descriptors". The "official"
1750 refers to the fact that these descriptors are used when taking the address
1751 of a procedure, thus ensuring a unique address for each procedure. */
1754 get_fptr (bfd
*abfd
, struct bfd_link_info
*info
,
1755 struct elf64_ia64_link_hash_table
*ia64_info
)
1760 fptr
= ia64_info
->fptr_sec
;
1763 dynobj
= ia64_info
->root
.dynobj
;
1765 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1767 fptr
= bfd_make_section_anyway_with_flags (dynobj
, ".opd",
1772 | (bfd_link_pie (info
) ? 0
1774 | SEC_LINKER_CREATED
));
1776 || !bfd_set_section_alignment (fptr
, 4))
1782 ia64_info
->fptr_sec
= fptr
;
1784 if (bfd_link_pie (info
))
1787 fptr_rel
= bfd_make_section_anyway_with_flags (dynobj
, ".rela.opd",
1788 (SEC_ALLOC
| SEC_LOAD
1791 | SEC_LINKER_CREATED
1793 if (fptr_rel
== NULL
1794 || !bfd_set_section_alignment (fptr_rel
, 3))
1800 ia64_info
->rel_fptr_sec
= fptr_rel
;
1808 get_pltoff (bfd
*abfd
, struct elf64_ia64_link_hash_table
*ia64_info
)
1813 pltoff
= ia64_info
->pltoff_sec
;
1816 dynobj
= ia64_info
->root
.dynobj
;
1818 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1820 pltoff
= bfd_make_section_anyway_with_flags (dynobj
,
1821 ELF_STRING_ia64_pltoff
,
1827 | SEC_LINKER_CREATED
));
1829 || !bfd_set_section_alignment (pltoff
, 4))
1835 ia64_info
->pltoff_sec
= pltoff
;
1842 get_reloc_section (bfd
*abfd
,
1843 struct elf64_ia64_link_hash_table
*ia64_info
,
1844 asection
*sec
, bfd_boolean create
)
1846 const char *srel_name
;
1850 srel_name
= (bfd_elf_string_from_elf_section
1851 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
1852 _bfd_elf_single_rel_hdr (sec
)->sh_name
));
1853 if (srel_name
== NULL
)
1856 BFD_ASSERT ((CONST_STRNEQ (srel_name
, ".rela")
1857 && strcmp (bfd_section_name (sec
), srel_name
+5) == 0)
1858 || (CONST_STRNEQ (srel_name
, ".rel")
1859 && strcmp (bfd_section_name (sec
), srel_name
+4) == 0));
1861 dynobj
= ia64_info
->root
.dynobj
;
1863 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1865 srel
= bfd_get_linker_section (dynobj
, srel_name
);
1866 if (srel
== NULL
&& create
)
1868 srel
= bfd_make_section_anyway_with_flags (dynobj
, srel_name
,
1869 (SEC_ALLOC
| SEC_LOAD
1872 | SEC_LINKER_CREATED
1875 || !bfd_set_section_alignment (srel
, 3))
1883 count_dyn_reloc (bfd
*abfd
, struct elf64_ia64_dyn_sym_info
*dyn_i
,
1884 asection
*srel
, int type
)
1886 struct elf64_ia64_dyn_reloc_entry
*rent
;
1888 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
1889 if (rent
->srel
== srel
&& rent
->type
== type
)
1894 rent
= ((struct elf64_ia64_dyn_reloc_entry
*)
1895 bfd_alloc (abfd
, (bfd_size_type
) sizeof (*rent
)));
1899 rent
->next
= dyn_i
->reloc_entries
;
1903 dyn_i
->reloc_entries
= rent
;
1911 elf64_ia64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1913 const Elf_Internal_Rela
*relocs
)
1915 struct elf64_ia64_link_hash_table
*ia64_info
;
1916 const Elf_Internal_Rela
*relend
;
1917 Elf_Internal_Shdr
*symtab_hdr
;
1918 const Elf_Internal_Rela
*rel
;
1919 asection
*got
, *fptr
, *srel
, *pltoff
;
1928 NEED_LTOFF_FPTR
= 128
1931 struct elf_link_hash_entry
*h
;
1932 unsigned long r_symndx
;
1933 bfd_boolean maybe_dynamic
;
1935 if (bfd_link_relocatable (info
))
1938 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1939 ia64_info
= elf64_ia64_hash_table (info
);
1940 if (ia64_info
== NULL
)
1943 got
= fptr
= srel
= pltoff
= NULL
;
1945 relend
= relocs
+ sec
->reloc_count
;
1947 /* We scan relocations first to create dynamic relocation arrays. We
1948 modified get_dyn_sym_info to allow fast insertion and support fast
1949 lookup in the next loop. */
1950 for (rel
= relocs
; rel
< relend
; ++rel
)
1952 r_symndx
= ELF64_R_SYM (rel
->r_info
);
1953 if (r_symndx
>= symtab_hdr
->sh_info
)
1955 long indx
= r_symndx
- symtab_hdr
->sh_info
;
1956 h
= elf_sym_hashes (abfd
)[indx
];
1957 while (h
->root
.type
== bfd_link_hash_indirect
1958 || h
->root
.type
== bfd_link_hash_warning
)
1959 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1964 /* We can only get preliminary data on whether a symbol is
1965 locally or externally defined, as not all of the input files
1966 have yet been processed. Do something with what we know, as
1967 this may help reduce memory usage and processing time later. */
1968 maybe_dynamic
= (h
&& ((!bfd_link_executable (info
)
1969 && (!SYMBOLIC_BIND (info
, h
)
1970 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
1972 || h
->root
.type
== bfd_link_hash_defweak
));
1975 switch (ELF64_R_TYPE (rel
->r_info
))
1977 case R_IA64_TPREL64MSB
:
1978 case R_IA64_TPREL64LSB
:
1979 case R_IA64_LTOFF_TPREL22
:
1980 case R_IA64_DTPREL32MSB
:
1981 case R_IA64_DTPREL32LSB
:
1982 case R_IA64_DTPREL64MSB
:
1983 case R_IA64_DTPREL64LSB
:
1984 case R_IA64_LTOFF_DTPREL22
:
1985 case R_IA64_DTPMOD64MSB
:
1986 case R_IA64_DTPMOD64LSB
:
1987 case R_IA64_LTOFF_DTPMOD22
:
1991 case R_IA64_IPLTMSB
:
1992 case R_IA64_IPLTLSB
:
1995 case R_IA64_LTOFF_FPTR22
:
1996 case R_IA64_LTOFF_FPTR64I
:
1997 case R_IA64_LTOFF_FPTR32MSB
:
1998 case R_IA64_LTOFF_FPTR32LSB
:
1999 case R_IA64_LTOFF_FPTR64MSB
:
2000 case R_IA64_LTOFF_FPTR64LSB
:
2001 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
2004 case R_IA64_FPTR64I
:
2005 case R_IA64_FPTR32MSB
:
2006 case R_IA64_FPTR32LSB
:
2007 case R_IA64_FPTR64MSB
:
2008 case R_IA64_FPTR64LSB
:
2009 if (bfd_link_pic (info
) || h
)
2010 need_entry
= NEED_FPTR
| NEED_DYNREL
;
2012 need_entry
= NEED_FPTR
;
2015 case R_IA64_LTOFF22
:
2016 case R_IA64_LTOFF64I
:
2017 need_entry
= NEED_GOT
;
2020 case R_IA64_LTOFF22X
:
2021 need_entry
= NEED_GOTX
;
2024 case R_IA64_PLTOFF22
:
2025 case R_IA64_PLTOFF64I
:
2026 case R_IA64_PLTOFF64MSB
:
2027 case R_IA64_PLTOFF64LSB
:
2028 need_entry
= NEED_PLTOFF
;
2032 need_entry
|= NEED_MIN_PLT
;
2036 (*info
->callbacks
->warning
)
2037 (info
, _("@pltoff reloc against local symbol"), 0,
2038 abfd
, 0, (bfd_vma
) 0);
2042 case R_IA64_PCREL21B
:
2043 case R_IA64_PCREL60B
:
2044 /* Depending on where this symbol is defined, we may or may not
2045 need a full plt entry. Only skip if we know we'll not need
2046 the entry -- static or symbolic, and the symbol definition
2047 has already been seen. */
2048 if (maybe_dynamic
&& rel
->r_addend
== 0)
2049 need_entry
= NEED_FULL_PLT
;
2055 case R_IA64_DIR32MSB
:
2056 case R_IA64_DIR32LSB
:
2057 case R_IA64_DIR64MSB
:
2058 case R_IA64_DIR64LSB
:
2059 /* Shared objects will always need at least a REL relocation. */
2060 if (bfd_link_pic (info
) || maybe_dynamic
)
2061 need_entry
= NEED_DYNREL
;
2064 case R_IA64_PCREL22
:
2065 case R_IA64_PCREL64I
:
2066 case R_IA64_PCREL32MSB
:
2067 case R_IA64_PCREL32LSB
:
2068 case R_IA64_PCREL64MSB
:
2069 case R_IA64_PCREL64LSB
:
2071 need_entry
= NEED_DYNREL
;
2078 if ((need_entry
& NEED_FPTR
) != 0
2081 (*info
->callbacks
->warning
)
2082 (info
, _("non-zero addend in @fptr reloc"), 0,
2083 abfd
, 0, (bfd_vma
) 0);
2086 if (get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, TRUE
) == NULL
)
2090 /* Now, we only do lookup without insertion, which is very fast
2091 with the modified get_dyn_sym_info. */
2092 for (rel
= relocs
; rel
< relend
; ++rel
)
2094 struct elf64_ia64_dyn_sym_info
*dyn_i
;
2095 int dynrel_type
= R_IA64_NONE
;
2097 r_symndx
= ELF64_R_SYM (rel
->r_info
);
2098 if (r_symndx
>= symtab_hdr
->sh_info
)
2100 /* We're dealing with a global symbol -- find its hash entry
2101 and mark it as being referenced. */
2102 long indx
= r_symndx
- symtab_hdr
->sh_info
;
2103 h
= elf_sym_hashes (abfd
)[indx
];
2104 while (h
->root
.type
== bfd_link_hash_indirect
2105 || h
->root
.type
== bfd_link_hash_warning
)
2106 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2108 /* PR15323, ref flags aren't set for references in the same
2115 /* We can only get preliminary data on whether a symbol is
2116 locally or externally defined, as not all of the input files
2117 have yet been processed. Do something with what we know, as
2118 this may help reduce memory usage and processing time later. */
2119 maybe_dynamic
= (h
&& ((!bfd_link_executable (info
)
2120 && (!SYMBOLIC_BIND (info
, h
)
2121 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
2123 || h
->root
.type
== bfd_link_hash_defweak
));
2126 switch (ELF64_R_TYPE (rel
->r_info
))
2128 case R_IA64_TPREL64MSB
:
2129 case R_IA64_TPREL64LSB
:
2130 case R_IA64_LTOFF_TPREL22
:
2131 case R_IA64_DTPREL32MSB
:
2132 case R_IA64_DTPREL32LSB
:
2133 case R_IA64_DTPREL64MSB
:
2134 case R_IA64_DTPREL64LSB
:
2135 case R_IA64_LTOFF_DTPREL22
:
2136 case R_IA64_DTPMOD64MSB
:
2137 case R_IA64_DTPMOD64LSB
:
2138 case R_IA64_LTOFF_DTPMOD22
:
2142 case R_IA64_LTOFF_FPTR22
:
2143 case R_IA64_LTOFF_FPTR64I
:
2144 case R_IA64_LTOFF_FPTR32MSB
:
2145 case R_IA64_LTOFF_FPTR32LSB
:
2146 case R_IA64_LTOFF_FPTR64MSB
:
2147 case R_IA64_LTOFF_FPTR64LSB
:
2148 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
2151 case R_IA64_FPTR64I
:
2152 case R_IA64_FPTR32MSB
:
2153 case R_IA64_FPTR32LSB
:
2154 case R_IA64_FPTR64MSB
:
2155 case R_IA64_FPTR64LSB
:
2156 if (bfd_link_pic (info
) || h
)
2157 need_entry
= NEED_FPTR
| NEED_DYNREL
;
2159 need_entry
= NEED_FPTR
;
2160 dynrel_type
= R_IA64_FPTR64LSB
;
2163 case R_IA64_LTOFF22
:
2164 case R_IA64_LTOFF64I
:
2165 need_entry
= NEED_GOT
;
2168 case R_IA64_LTOFF22X
:
2169 need_entry
= NEED_GOTX
;
2172 case R_IA64_PLTOFF22
:
2173 case R_IA64_PLTOFF64I
:
2174 case R_IA64_PLTOFF64MSB
:
2175 case R_IA64_PLTOFF64LSB
:
2176 need_entry
= NEED_PLTOFF
;
2180 need_entry
|= NEED_MIN_PLT
;
2184 case R_IA64_PCREL21B
:
2185 case R_IA64_PCREL60B
:
2186 /* Depending on where this symbol is defined, we may or may not
2187 need a full plt entry. Only skip if we know we'll not need
2188 the entry -- static or symbolic, and the symbol definition
2189 has already been seen. */
2190 if (maybe_dynamic
&& rel
->r_addend
== 0)
2191 need_entry
= NEED_FULL_PLT
;
2197 case R_IA64_DIR32MSB
:
2198 case R_IA64_DIR32LSB
:
2199 case R_IA64_DIR64MSB
:
2200 case R_IA64_DIR64LSB
:
2201 /* Shared objects will always need at least a REL relocation. */
2202 if (bfd_link_pic (info
) || maybe_dynamic
)
2203 need_entry
= NEED_DYNREL
;
2204 dynrel_type
= R_IA64_DIR64LSB
;
2207 case R_IA64_IPLTMSB
:
2208 case R_IA64_IPLTLSB
:
2211 case R_IA64_PCREL22
:
2212 case R_IA64_PCREL64I
:
2213 case R_IA64_PCREL32MSB
:
2214 case R_IA64_PCREL32LSB
:
2215 case R_IA64_PCREL64MSB
:
2216 case R_IA64_PCREL64LSB
:
2218 need_entry
= NEED_DYNREL
;
2219 dynrel_type
= R_IA64_PCREL64LSB
;
2226 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, FALSE
);
2228 /* Record whether or not this is a local symbol. */
2231 /* Create what's needed. */
2232 if (need_entry
& (NEED_GOT
| NEED_GOTX
))
2236 got
= get_got (abfd
, ia64_info
);
2240 if (need_entry
& NEED_GOT
)
2241 dyn_i
->want_got
= 1;
2242 if (need_entry
& NEED_GOTX
)
2243 dyn_i
->want_gotx
= 1;
2245 if (need_entry
& NEED_FPTR
)
2247 /* Create the .opd section. */
2250 fptr
= get_fptr (abfd
, info
, ia64_info
);
2254 dyn_i
->want_fptr
= 1;
2256 if (need_entry
& NEED_LTOFF_FPTR
)
2257 dyn_i
->want_ltoff_fptr
= 1;
2258 if (need_entry
& (NEED_MIN_PLT
| NEED_FULL_PLT
))
2260 if (!ia64_info
->root
.dynobj
)
2261 ia64_info
->root
.dynobj
= abfd
;
2263 dyn_i
->want_plt
= 1;
2265 if (need_entry
& NEED_FULL_PLT
)
2266 dyn_i
->want_plt2
= 1;
2267 if (need_entry
& NEED_PLTOFF
)
2269 /* This is needed here, in case @pltoff is used in a non-shared
2273 pltoff
= get_pltoff (abfd
, ia64_info
);
2278 dyn_i
->want_pltoff
= 1;
2280 if ((need_entry
& NEED_DYNREL
) && (sec
->flags
& SEC_ALLOC
))
2284 srel
= get_reloc_section (abfd
, ia64_info
, sec
, TRUE
);
2288 if (!count_dyn_reloc (abfd
, dyn_i
, srel
, dynrel_type
))
2296 /* For cleanliness, and potentially faster dynamic loading, allocate
2297 external GOT entries first. */
2300 allocate_global_data_got (struct elf64_ia64_dyn_sym_info
*dyn_i
,
2303 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*)data
;
2305 if ((dyn_i
->want_got
|| dyn_i
->want_gotx
)
2306 && ! dyn_i
->want_fptr
2307 && elf64_ia64_dynamic_symbol_p (dyn_i
->h
))
2309 /* GOT entry with FPTR is done by allocate_global_fptr_got. */
2310 dyn_i
->got_offset
= x
->ofs
;
2316 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
2319 allocate_global_fptr_got (struct elf64_ia64_dyn_sym_info
*dyn_i
,
2322 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*)data
;
2326 && elf64_ia64_dynamic_symbol_p (dyn_i
->h
))
2328 dyn_i
->got_offset
= x
->ofs
;
2334 /* Lastly, allocate all the GOT entries for local data. */
2337 allocate_local_got (struct elf64_ia64_dyn_sym_info
*dyn_i
,
2340 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*) data
;
2342 if ((dyn_i
->want_got
|| dyn_i
->want_gotx
)
2343 && !elf64_ia64_dynamic_symbol_p (dyn_i
->h
))
2345 dyn_i
->got_offset
= x
->ofs
;
2351 /* Allocate function descriptors. We can do these for every function
2352 in a main executable that is not exported. */
2355 allocate_fptr (struct elf64_ia64_dyn_sym_info
*dyn_i
, void * data
)
2357 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*) data
;
2359 if (dyn_i
->want_fptr
)
2361 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2364 while (h
->root
.type
== bfd_link_hash_indirect
2365 || h
->root
.type
== bfd_link_hash_warning
)
2366 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2368 if (h
== NULL
|| !h
->def_dynamic
)
2370 /* A non dynamic symbol. */
2371 dyn_i
->fptr_offset
= x
->ofs
;
2375 dyn_i
->want_fptr
= 0;
2380 /* Allocate all the minimal PLT entries. */
2383 allocate_plt_entries (struct elf64_ia64_dyn_sym_info
*dyn_i
,
2384 void * data ATTRIBUTE_UNUSED
)
2386 if (dyn_i
->want_plt
)
2388 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2391 while (h
->root
.type
== bfd_link_hash_indirect
2392 || h
->root
.type
== bfd_link_hash_warning
)
2393 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2395 /* ??? Versioned symbols seem to lose NEEDS_PLT. */
2396 if (elf64_ia64_dynamic_symbol_p (h
))
2398 dyn_i
->want_pltoff
= 1;
2402 dyn_i
->want_plt
= 0;
2403 dyn_i
->want_plt2
= 0;
2409 /* Allocate all the full PLT entries. */
2412 allocate_plt2_entries (struct elf64_ia64_dyn_sym_info
*dyn_i
,
2415 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*)data
;
2417 if (dyn_i
->want_plt2
)
2419 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2420 bfd_size_type ofs
= x
->ofs
;
2422 dyn_i
->plt2_offset
= ofs
;
2423 x
->ofs
= ofs
+ PLT_FULL_ENTRY_SIZE
;
2425 while (h
->root
.type
== bfd_link_hash_indirect
2426 || h
->root
.type
== bfd_link_hash_warning
)
2427 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2428 dyn_i
->h
->plt
.offset
= ofs
;
2433 /* Allocate all the PLTOFF entries requested by relocations and
2434 plt entries. We can't share space with allocated FPTR entries,
2435 because the latter are not necessarily addressable by the GP.
2436 ??? Relaxation might be able to determine that they are. */
2439 allocate_pltoff_entries (struct elf64_ia64_dyn_sym_info
*dyn_i
,
2442 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*)data
;
2444 if (dyn_i
->want_pltoff
)
2446 dyn_i
->pltoff_offset
= x
->ofs
;
2452 /* Allocate dynamic relocations for those symbols that turned out
2456 allocate_dynrel_entries (struct elf64_ia64_dyn_sym_info
*dyn_i
,
2459 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*)data
;
2460 struct elf64_ia64_link_hash_table
*ia64_info
;
2461 struct elf64_ia64_dyn_reloc_entry
*rent
;
2462 bfd_boolean dynamic_symbol
, shared
, resolved_zero
;
2463 struct elf64_ia64_link_hash_entry
*h_ia64
;
2465 ia64_info
= elf64_ia64_hash_table (x
->info
);
2466 if (ia64_info
== NULL
)
2469 /* Note that this can't be used in relation to FPTR relocs below. */
2470 dynamic_symbol
= elf64_ia64_dynamic_symbol_p (dyn_i
->h
);
2472 shared
= bfd_link_pic (x
->info
);
2473 resolved_zero
= (dyn_i
->h
2474 && ELF_ST_VISIBILITY (dyn_i
->h
->other
)
2475 && dyn_i
->h
->root
.type
== bfd_link_hash_undefweak
);
2477 /* Take care of the GOT and PLT relocations. */
2480 && (dynamic_symbol
|| shared
)
2481 && (dyn_i
->want_got
|| dyn_i
->want_gotx
))
2482 || (dyn_i
->want_ltoff_fptr
2484 && dyn_i
->h
->def_dynamic
))
2487 if (dyn_i
->h
!= NULL
&& dyn_i
->h
->def_dynamic
)
2489 h_ia64
= (struct elf64_ia64_link_hash_entry
*) dyn_i
->h
;
2490 elf_ia64_vms_tdata (h_ia64
->shl
)->fixups_off
+=
2491 sizeof (Elf64_External_VMS_IMAGE_FIXUP
);
2492 ia64_info
->fixups_sec
->size
+=
2493 sizeof (Elf64_External_VMS_IMAGE_FIXUP
);
2497 if (ia64_info
->rel_fptr_sec
&& dyn_i
->want_fptr
)
2499 /* VMS: only image reloc. */
2500 if (dyn_i
->h
== NULL
|| dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
2501 ia64_info
->rel_fptr_sec
->size
+= sizeof (Elf64_External_Rela
);
2504 if (!resolved_zero
&& dyn_i
->want_pltoff
)
2507 if (dyn_i
->h
!= NULL
&& dyn_i
->h
->def_dynamic
)
2509 h_ia64
= (struct elf64_ia64_link_hash_entry
*) dyn_i
->h
;
2510 elf_ia64_vms_tdata (h_ia64
->shl
)->fixups_off
+=
2511 sizeof (Elf64_External_VMS_IMAGE_FIXUP
);
2512 ia64_info
->fixups_sec
->size
+=
2513 sizeof (Elf64_External_VMS_IMAGE_FIXUP
);
2517 /* Take care of the normal data relocations. */
2519 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2521 int count
= rent
->count
;
2525 case R_IA64_FPTR32LSB
:
2526 case R_IA64_FPTR64LSB
:
2527 /* Allocate one iff !want_fptr and not PIE, which by this point
2528 will be true only if we're actually allocating one statically
2529 in the main executable. Position independent executables
2530 need a relative reloc. */
2531 if (dyn_i
->want_fptr
&& !bfd_link_pie (x
->info
))
2534 case R_IA64_PCREL32LSB
:
2535 case R_IA64_PCREL64LSB
:
2536 if (!dynamic_symbol
)
2539 case R_IA64_DIR32LSB
:
2540 case R_IA64_DIR64LSB
:
2541 if (!dynamic_symbol
&& !shared
)
2544 case R_IA64_IPLTLSB
:
2545 if (!dynamic_symbol
&& !shared
)
2547 /* Use two REL relocations for IPLT relocations
2548 against local symbols. */
2549 if (!dynamic_symbol
)
2552 case R_IA64_DTPREL32LSB
:
2553 case R_IA64_TPREL64LSB
:
2554 case R_IA64_DTPREL64LSB
:
2555 case R_IA64_DTPMOD64LSB
:
2562 if (!dynamic_symbol
)
2565 h_ia64
= (struct elf64_ia64_link_hash_entry
*) dyn_i
->h
;
2566 elf_ia64_vms_tdata (h_ia64
->shl
)->fixups_off
+=
2567 sizeof (Elf64_External_VMS_IMAGE_FIXUP
);
2568 ia64_info
->fixups_sec
->size
+=
2569 sizeof (Elf64_External_VMS_IMAGE_FIXUP
);
2576 elf64_ia64_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2577 struct elf_link_hash_entry
*h
)
2579 /* ??? Undefined symbols with PLT entries should be re-defined
2580 to be the PLT entry. */
2582 /* If this is a weak symbol, and there is a real definition, the
2583 processor independent code will have arranged for us to see the
2584 real definition first, and we can just use the same value. */
2585 if (h
->is_weakalias
)
2587 struct elf_link_hash_entry
*def
= weakdef (h
);
2588 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
2589 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
2590 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
2594 /* If this is a reference to a symbol defined by a dynamic object which
2595 is not a function, we might allocate the symbol in our .dynbss section
2596 and allocate a COPY dynamic relocation.
2598 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2605 elf64_ia64_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2606 struct bfd_link_info
*info
)
2608 struct elf64_ia64_allocate_data data
;
2609 struct elf64_ia64_link_hash_table
*ia64_info
;
2612 struct elf_link_hash_table
*hash_table
;
2614 hash_table
= elf_hash_table (info
);
2615 dynobj
= hash_table
->dynobj
;
2616 ia64_info
= elf64_ia64_hash_table (info
);
2617 if (ia64_info
== NULL
)
2619 BFD_ASSERT(dynobj
!= NULL
);
2622 /* Allocate the GOT entries. */
2624 if (ia64_info
->root
.sgot
)
2627 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_global_data_got
, &data
);
2628 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_global_fptr_got
, &data
);
2629 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_local_got
, &data
);
2630 ia64_info
->root
.sgot
->size
= data
.ofs
;
2633 /* Allocate the FPTR entries. */
2635 if (ia64_info
->fptr_sec
)
2638 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_fptr
, &data
);
2639 ia64_info
->fptr_sec
->size
= data
.ofs
;
2642 /* Now that we've seen all of the input files, we can decide which
2643 symbols need plt entries. Allocate the minimal PLT entries first.
2644 We do this even though dynamic_sections_created may be FALSE, because
2645 this has the side-effect of clearing want_plt and want_plt2. */
2648 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_plt_entries
, &data
);
2650 /* Align the pointer for the plt2 entries. */
2651 data
.ofs
= (data
.ofs
+ 31) & (bfd_vma
) -32;
2653 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_plt2_entries
, &data
);
2654 if (data
.ofs
!= 0 || ia64_info
->root
.dynamic_sections_created
)
2656 /* FIXME: we always reserve the memory for dynamic linker even if
2657 there are no PLT entries since dynamic linker may assume the
2658 reserved memory always exists. */
2660 BFD_ASSERT (ia64_info
->root
.dynamic_sections_created
);
2662 ia64_info
->root
.splt
->size
= data
.ofs
;
2665 /* Allocate the PLTOFF entries. */
2667 if (ia64_info
->pltoff_sec
)
2670 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_pltoff_entries
, &data
);
2671 ia64_info
->pltoff_sec
->size
= data
.ofs
;
2674 if (ia64_info
->root
.dynamic_sections_created
)
2676 /* Allocate space for the dynamic relocations that turned out to be
2678 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_dynrel_entries
, &data
);
2681 /* We have now determined the sizes of the various dynamic sections.
2682 Allocate memory for them. */
2683 for (sec
= dynobj
->sections
; sec
!= NULL
; sec
= sec
->next
)
2687 if (!(sec
->flags
& SEC_LINKER_CREATED
))
2690 /* If we don't need this section, strip it from the output file.
2691 There were several sections primarily related to dynamic
2692 linking that must be create before the linker maps input
2693 sections to output sections. The linker does that before
2694 bfd_elf_size_dynamic_sections is called, and it is that
2695 function which decides whether anything needs to go into
2698 strip
= (sec
->size
== 0);
2700 if (sec
== ia64_info
->root
.sgot
)
2702 else if (sec
== ia64_info
->root
.srelgot
)
2705 ia64_info
->root
.srelgot
= NULL
;
2707 /* We use the reloc_count field as a counter if we need to
2708 copy relocs into the output file. */
2709 sec
->reloc_count
= 0;
2711 else if (sec
== ia64_info
->fptr_sec
)
2714 ia64_info
->fptr_sec
= NULL
;
2716 else if (sec
== ia64_info
->rel_fptr_sec
)
2719 ia64_info
->rel_fptr_sec
= NULL
;
2721 /* We use the reloc_count field as a counter if we need to
2722 copy relocs into the output file. */
2723 sec
->reloc_count
= 0;
2725 else if (sec
== ia64_info
->root
.splt
)
2728 ia64_info
->root
.splt
= NULL
;
2730 else if (sec
== ia64_info
->pltoff_sec
)
2733 ia64_info
->pltoff_sec
= NULL
;
2735 else if (sec
== ia64_info
->fixups_sec
)
2738 ia64_info
->fixups_sec
= NULL
;
2740 else if (sec
== ia64_info
->transfer_sec
)
2748 /* It's OK to base decisions on the section name, because none
2749 of the dynobj section names depend upon the input files. */
2750 name
= bfd_section_name (sec
);
2752 if (strcmp (name
, ".got.plt") == 0)
2754 else if (CONST_STRNEQ (name
, ".rel"))
2758 /* We use the reloc_count field as a counter if we need to
2759 copy relocs into the output file. */
2760 sec
->reloc_count
= 0;
2768 sec
->flags
|= SEC_EXCLUDE
;
2771 /* Allocate memory for the section contents. */
2772 sec
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, sec
->size
);
2773 if (sec
->contents
== NULL
&& sec
->size
!= 0)
2778 if (elf_hash_table (info
)->dynamic_sections_created
)
2782 asection
*dynstrsec
;
2783 Elf_Internal_Dyn dyn
;
2784 const struct elf_backend_data
*bed
;
2785 unsigned int shl_num
= 0;
2786 bfd_vma fixups_off
= 0;
2788 unsigned int time_hi
, time_lo
;
2790 /* The .dynamic section must exist and be empty. */
2791 dynsec
= bfd_get_linker_section (hash_table
->dynobj
, ".dynamic");
2792 BFD_ASSERT (dynsec
!= NULL
);
2793 BFD_ASSERT (dynsec
->size
== 0);
2795 dynstrsec
= bfd_get_linker_section (hash_table
->dynobj
, ".vmsdynstr");
2796 BFD_ASSERT (dynstrsec
!= NULL
);
2797 BFD_ASSERT (dynstrsec
->size
== 0);
2798 dynstrsec
->size
= 1; /* Initial blank. */
2800 /* Ident + link time. */
2801 vms_get_time (&time_hi
, &time_lo
);
2803 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_IDENT
, 0))
2805 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_LINKTIME
,
2806 (((bfd_uint64_t
)time_hi
) << 32)
2811 strdyn_off
= dynsec
->size
;
2812 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_STRTAB_OFFSET
, 0))
2814 if (!_bfd_elf_add_dynamic_entry (info
, DT_STRSZ
, 0))
2818 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_PLTGOT_SEG
, 0))
2820 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_PLTGOT_OFFSET
, 0))
2824 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_FPMODE
, 0x9800000))
2826 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_LNKFLAGS
,
2827 VMS_LF_IMGSTA
| VMS_LF_MAIN
))
2830 /* Add entries for shared libraries. */
2831 for (abfd
= info
->input_bfds
; abfd
; abfd
= abfd
->link
.next
)
2835 bfd_size_type strindex
;
2836 bfd_byte
*newcontents
;
2837 bfd_vma fixups_shl_off
;
2839 if (!(abfd
->flags
& DYNAMIC
))
2841 BFD_ASSERT (abfd
->xvec
== output_bfd
->xvec
);
2843 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_NEEDED_IDENT
,
2844 elf_ia64_vms_ident (abfd
)))
2847 soname
= vms_get_module_name (bfd_get_filename (abfd
), TRUE
);
2850 strindex
= dynstrsec
->size
;
2851 soname_len
= strlen (soname
) + 1;
2852 newcontents
= (bfd_byte
*) bfd_realloc (dynstrsec
->contents
,
2853 strindex
+ soname_len
);
2854 if (newcontents
== NULL
)
2856 memcpy (newcontents
+ strindex
, soname
, soname_len
);
2857 dynstrsec
->size
+= soname_len
;
2858 dynstrsec
->contents
= newcontents
;
2860 if (!_bfd_elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
2863 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_FIXUP_NEEDED
,
2868 /* The fixups_off was in fact containing the size of the fixup
2869 section. Remap into the offset. */
2870 fixups_shl_off
= elf_ia64_vms_tdata (abfd
)->fixups_off
;
2871 elf_ia64_vms_tdata (abfd
)->fixups_off
= fixups_off
;
2873 if (!_bfd_elf_add_dynamic_entry
2874 (info
, DT_IA_64_VMS_FIXUP_RELA_CNT
,
2875 fixups_shl_off
/ sizeof (Elf64_External_VMS_IMAGE_FIXUP
)))
2877 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_FIXUP_RELA_OFF
,
2880 fixups_off
+= fixups_shl_off
;
2884 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_UNWINDSZ
, 0))
2886 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_UNWIND_CODSEG
, 0))
2888 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_UNWIND_INFOSEG
, 0))
2890 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_UNWIND_OFFSET
, 0))
2892 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_UNWIND_SEG
, 0))
2895 if (!_bfd_elf_add_dynamic_entry (info
, DT_NULL
, 0xdead))
2898 /* Fix the strtab entries. */
2899 bed
= get_elf_backend_data (hash_table
->dynobj
);
2901 if (dynstrsec
->size
> 1)
2902 dynstrsec
->contents
[0] = 0;
2904 dynstrsec
->size
= 0;
2906 /* Note: one 'spare' (ie DT_NULL) entry is added by
2907 bfd_elf_size_dynsym_hash_dynstr. */
2908 dyn
.d_tag
= DT_IA_64_VMS_STRTAB_OFFSET
;
2909 dyn
.d_un
.d_val
= dynsec
->size
/* + sizeof (Elf64_External_Dyn) */;
2910 bed
->s
->swap_dyn_out (hash_table
->dynobj
, &dyn
,
2911 dynsec
->contents
+ strdyn_off
);
2913 dyn
.d_tag
= DT_STRSZ
;
2914 dyn
.d_un
.d_val
= dynstrsec
->size
;
2915 bed
->s
->swap_dyn_out (hash_table
->dynobj
, &dyn
,
2916 dynsec
->contents
+ strdyn_off
+ bed
->s
->sizeof_dyn
);
2918 elf_ia64_vms_tdata (output_bfd
)->needed_count
= shl_num
;
2921 if (!create_ia64_vms_notes (output_bfd
, info
, time_hi
, time_lo
))
2925 /* ??? Perhaps force __gp local. */
2931 elf64_ia64_install_fixup (bfd
*output_bfd
,
2932 struct elf64_ia64_link_hash_table
*ia64_info
,
2933 struct elf_link_hash_entry
*h
,
2934 unsigned int type
, asection
*sec
, bfd_vma offset
,
2938 Elf64_External_VMS_IMAGE_FIXUP
*fixup
;
2939 struct elf64_ia64_link_hash_entry
*h_ia64
;
2941 Elf_Internal_Phdr
*phdr
;
2943 if (h
== NULL
|| !h
->def_dynamic
)
2946 h_ia64
= (struct elf64_ia64_link_hash_entry
*) h
;
2947 fixoff
= elf_ia64_vms_tdata (h_ia64
->shl
)->fixups_off
;
2948 elf_ia64_vms_tdata (h_ia64
->shl
)->fixups_off
+=
2949 sizeof (Elf64_External_VMS_IMAGE_FIXUP
);
2950 relsec
= ia64_info
->fixups_sec
;
2952 fixup
= (Elf64_External_VMS_IMAGE_FIXUP
*)(relsec
->contents
+ fixoff
);
2953 offset
+= sec
->output_section
->vma
+ sec
->output_offset
;
2955 /* FIXME: this is slow. We should cache the last one used, or create a
2957 phdr
= _bfd_elf_find_segment_containing_section
2958 (output_bfd
, sec
->output_section
);
2959 BFD_ASSERT (phdr
!= NULL
);
2961 bfd_putl64 (offset
- phdr
->p_vaddr
, fixup
->fixup_offset
);
2962 bfd_putl32 (type
, fixup
->type
);
2963 bfd_putl32 (phdr
- elf_tdata (output_bfd
)->phdr
, fixup
->fixup_seg
);
2964 bfd_putl64 (addend
, fixup
->addend
);
2965 bfd_putl32 (h
->root
.u
.def
.value
, fixup
->symvec_index
);
2966 bfd_putl32 (2, fixup
->data_type
);
2969 /* Store an entry for target address TARGET_ADDR in the linkage table
2970 and return the gp-relative address of the linkage table entry. */
2973 set_got_entry (bfd
*abfd
, struct bfd_link_info
*info
,
2974 struct elf64_ia64_dyn_sym_info
*dyn_i
,
2975 bfd_vma addend
, bfd_vma value
, unsigned int dyn_r_type
)
2977 struct elf64_ia64_link_hash_table
*ia64_info
;
2982 ia64_info
= elf64_ia64_hash_table (info
);
2983 if (ia64_info
== NULL
)
2986 got_sec
= ia64_info
->root
.sgot
;
2990 case R_IA64_TPREL64LSB
:
2991 case R_IA64_DTPMOD64LSB
:
2992 case R_IA64_DTPREL32LSB
:
2993 case R_IA64_DTPREL64LSB
:
2997 done
= dyn_i
->got_done
;
2998 dyn_i
->got_done
= TRUE
;
2999 got_offset
= dyn_i
->got_offset
;
3003 BFD_ASSERT ((got_offset
& 7) == 0);
3007 /* Store the target address in the linkage table entry. */
3008 bfd_put_64 (abfd
, value
, got_sec
->contents
+ got_offset
);
3010 /* Install a dynamic relocation if needed. */
3011 if (((bfd_link_pic (info
)
3013 || ELF_ST_VISIBILITY (dyn_i
->h
->other
) == STV_DEFAULT
3014 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
3015 || elf64_ia64_dynamic_symbol_p (dyn_i
->h
))
3016 && (!dyn_i
->want_ltoff_fptr
3017 || !bfd_link_pie (info
)
3019 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
3021 if (!dyn_i
->h
|| !dyn_i
->h
->def_dynamic
)
3023 dyn_r_type
= R_IA64_REL64LSB
;
3027 /* VMS: install a FIX32 or FIX64. */
3030 case R_IA64_DIR32LSB
:
3031 case R_IA64_FPTR32LSB
:
3032 dyn_r_type
= R_IA64_VMS_FIX32
;
3034 case R_IA64_DIR64LSB
:
3035 case R_IA64_FPTR64LSB
:
3036 dyn_r_type
= R_IA64_VMS_FIX64
;
3042 elf64_ia64_install_fixup
3043 (info
->output_bfd
, ia64_info
, dyn_i
->h
,
3044 dyn_r_type
, got_sec
, got_offset
, addend
);
3048 /* Return the address of the linkage table entry. */
3049 value
= (got_sec
->output_section
->vma
3050 + got_sec
->output_offset
3056 /* Fill in a function descriptor consisting of the function's code
3057 address and its global pointer. Return the descriptor's address. */
3060 set_fptr_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3061 struct elf64_ia64_dyn_sym_info
*dyn_i
,
3064 struct elf64_ia64_link_hash_table
*ia64_info
;
3067 ia64_info
= elf64_ia64_hash_table (info
);
3068 if (ia64_info
== NULL
)
3071 fptr_sec
= ia64_info
->fptr_sec
;
3073 if (!dyn_i
->fptr_done
)
3075 dyn_i
->fptr_done
= 1;
3077 /* Fill in the function descriptor. */
3078 bfd_put_64 (abfd
, value
, fptr_sec
->contents
+ dyn_i
->fptr_offset
);
3079 bfd_put_64 (abfd
, _bfd_get_gp_value (abfd
),
3080 fptr_sec
->contents
+ dyn_i
->fptr_offset
+ 8);
3083 /* Return the descriptor's address. */
3084 value
= (fptr_sec
->output_section
->vma
3085 + fptr_sec
->output_offset
3086 + dyn_i
->fptr_offset
);
3091 /* Fill in a PLTOFF entry consisting of the function's code address
3092 and its global pointer. Return the descriptor's address. */
3095 set_pltoff_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3096 struct elf64_ia64_dyn_sym_info
*dyn_i
,
3097 bfd_vma value
, bfd_boolean is_plt
)
3099 struct elf64_ia64_link_hash_table
*ia64_info
;
3100 asection
*pltoff_sec
;
3102 ia64_info
= elf64_ia64_hash_table (info
);
3103 if (ia64_info
== NULL
)
3106 pltoff_sec
= ia64_info
->pltoff_sec
;
3108 /* Don't do anything if this symbol uses a real PLT entry. In
3109 that case, we'll fill this in during finish_dynamic_symbol. */
3110 if ((! dyn_i
->want_plt
|| is_plt
)
3111 && !dyn_i
->pltoff_done
)
3113 bfd_vma gp
= _bfd_get_gp_value (abfd
);
3115 /* Fill in the function descriptor. */
3116 bfd_put_64 (abfd
, value
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
);
3117 bfd_put_64 (abfd
, gp
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
+ 8);
3119 /* Install dynamic relocations if needed. */
3121 && bfd_link_pic (info
)
3123 || ELF_ST_VISIBILITY (dyn_i
->h
->other
) == STV_DEFAULT
3124 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
3130 dyn_i
->pltoff_done
= 1;
3133 /* Return the descriptor's address. */
3134 value
= (pltoff_sec
->output_section
->vma
3135 + pltoff_sec
->output_offset
3136 + dyn_i
->pltoff_offset
);
3141 /* Called through qsort to sort the .IA_64.unwind section during a
3142 non-relocatable link. Set elf64_ia64_unwind_entry_compare_bfd
3143 to the output bfd so we can do proper endianness frobbing. */
3145 static bfd
*elf64_ia64_unwind_entry_compare_bfd
;
3148 elf64_ia64_unwind_entry_compare (const void * a
, const void * b
)
3152 av
= bfd_get_64 (elf64_ia64_unwind_entry_compare_bfd
, a
);
3153 bv
= bfd_get_64 (elf64_ia64_unwind_entry_compare_bfd
, b
);
3155 return (av
< bv
? -1 : av
> bv
? 1 : 0);
3158 /* Make sure we've got ourselves a nice fat __gp value. */
3160 elf64_ia64_choose_gp (bfd
*abfd
, struct bfd_link_info
*info
, bfd_boolean final
)
3162 bfd_vma min_vma
= (bfd_vma
) -1, max_vma
= 0;
3163 bfd_vma min_short_vma
= min_vma
, max_short_vma
= 0;
3164 struct elf_link_hash_entry
*gp
;
3167 struct elf64_ia64_link_hash_table
*ia64_info
;
3169 ia64_info
= elf64_ia64_hash_table (info
);
3170 if (ia64_info
== NULL
)
3173 /* Find the min and max vma of all sections marked short. Also collect
3174 min and max vma of any type, for use in selecting a nice gp. */
3175 for (os
= abfd
->sections
; os
; os
= os
->next
)
3179 if ((os
->flags
& SEC_ALLOC
) == 0)
3183 /* When this function is called from elfNN_ia64_final_link
3184 the correct value to use is os->size. When called from
3185 elfNN_ia64_relax_section we are in the middle of section
3186 sizing; some sections will already have os->size set, others
3187 will have os->size zero and os->rawsize the previous size. */
3188 hi
= os
->vma
+ (!final
&& os
->rawsize
? os
->rawsize
: os
->size
);
3196 if (os
->flags
& SEC_SMALL_DATA
)
3198 if (min_short_vma
> lo
)
3200 if (max_short_vma
< hi
)
3205 if (ia64_info
->min_short_sec
)
3208 > (ia64_info
->min_short_sec
->vma
3209 + ia64_info
->min_short_offset
))
3210 min_short_vma
= (ia64_info
->min_short_sec
->vma
3211 + ia64_info
->min_short_offset
);
3213 < (ia64_info
->max_short_sec
->vma
3214 + ia64_info
->max_short_offset
))
3215 max_short_vma
= (ia64_info
->max_short_sec
->vma
3216 + ia64_info
->max_short_offset
);
3219 /* See if the user wants to force a value. */
3220 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
3224 && (gp
->root
.type
== bfd_link_hash_defined
3225 || gp
->root
.type
== bfd_link_hash_defweak
))
3227 asection
*gp_sec
= gp
->root
.u
.def
.section
;
3228 gp_val
= (gp
->root
.u
.def
.value
3229 + gp_sec
->output_section
->vma
3230 + gp_sec
->output_offset
);
3234 /* Pick a sensible value. */
3236 if (ia64_info
->min_short_sec
)
3238 bfd_vma short_range
= max_short_vma
- min_short_vma
;
3240 /* If min_short_sec is set, pick one in the middle bewteen
3241 min_short_vma and max_short_vma. */
3242 if (short_range
>= 0x400000)
3244 gp_val
= min_short_vma
+ short_range
/ 2;
3248 asection
*got_sec
= ia64_info
->root
.sgot
;
3250 /* Start with just the address of the .got. */
3252 gp_val
= got_sec
->output_section
->vma
;
3253 else if (max_short_vma
!= 0)
3254 gp_val
= min_short_vma
;
3255 else if (max_vma
- min_vma
< 0x200000)
3258 gp_val
= max_vma
- 0x200000 + 8;
3261 /* If it is possible to address the entire image, but we
3262 don't with the choice above, adjust. */
3263 if (max_vma
- min_vma
< 0x400000
3264 && (max_vma
- gp_val
>= 0x200000
3265 || gp_val
- min_vma
> 0x200000))
3266 gp_val
= min_vma
+ 0x200000;
3267 else if (max_short_vma
!= 0)
3269 /* If we don't cover all the short data, adjust. */
3270 if (max_short_vma
- gp_val
>= 0x200000)
3271 gp_val
= min_short_vma
+ 0x200000;
3273 /* If we're addressing stuff past the end, adjust back. */
3274 if (gp_val
> max_vma
)
3275 gp_val
= max_vma
- 0x200000 + 8;
3279 /* Validate whether all SHF_IA_64_SHORT sections are within
3280 range of the chosen GP. */
3282 if (max_short_vma
!= 0)
3284 if (max_short_vma
- min_short_vma
>= 0x400000)
3288 /* xgettext:c-format */
3289 (_("%pB: short data segment overflowed (%#" PRIx64
" >= 0x400000)"),
3290 abfd
, (uint64_t) (max_short_vma
- min_short_vma
));
3293 else if ((gp_val
> min_short_vma
3294 && gp_val
- min_short_vma
> 0x200000)
3295 || (gp_val
< max_short_vma
3296 && max_short_vma
- gp_val
>= 0x200000))
3299 (_("%pB: __gp does not cover short data segment"), abfd
);
3304 _bfd_set_gp_value (abfd
, gp_val
);
3310 elf64_ia64_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
3312 struct elf64_ia64_link_hash_table
*ia64_info
;
3313 asection
*unwind_output_sec
;
3315 ia64_info
= elf64_ia64_hash_table (info
);
3316 if (ia64_info
== NULL
)
3319 /* Make sure we've got ourselves a nice fat __gp value. */
3320 if (!bfd_link_relocatable (info
))
3323 struct elf_link_hash_entry
*gp
;
3325 /* We assume after gp is set, section size will only decrease. We
3326 need to adjust gp for it. */
3327 _bfd_set_gp_value (abfd
, 0);
3328 if (! elf64_ia64_choose_gp (abfd
, info
, TRUE
))
3330 gp_val
= _bfd_get_gp_value (abfd
);
3332 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
3336 gp
->root
.type
= bfd_link_hash_defined
;
3337 gp
->root
.u
.def
.value
= gp_val
;
3338 gp
->root
.u
.def
.section
= bfd_abs_section_ptr
;
3342 /* If we're producing a final executable, we need to sort the contents
3343 of the .IA_64.unwind section. Force this section to be relocated
3344 into memory rather than written immediately to the output file. */
3345 unwind_output_sec
= NULL
;
3346 if (!bfd_link_relocatable (info
))
3348 asection
*s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_unwind
);
3351 unwind_output_sec
= s
->output_section
;
3352 unwind_output_sec
->contents
3353 = bfd_malloc (unwind_output_sec
->size
);
3354 if (unwind_output_sec
->contents
== NULL
)
3359 /* Invoke the regular ELF backend linker to do all the work. */
3360 if (!bfd_elf_final_link (abfd
, info
))
3363 if (unwind_output_sec
)
3365 elf64_ia64_unwind_entry_compare_bfd
= abfd
;
3366 qsort (unwind_output_sec
->contents
,
3367 (size_t) (unwind_output_sec
->size
/ 24),
3369 elf64_ia64_unwind_entry_compare
);
3371 if (! bfd_set_section_contents (abfd
, unwind_output_sec
,
3372 unwind_output_sec
->contents
, (bfd_vma
) 0,
3373 unwind_output_sec
->size
))
3381 elf64_ia64_relocate_section (bfd
*output_bfd
,
3382 struct bfd_link_info
*info
,
3384 asection
*input_section
,
3386 Elf_Internal_Rela
*relocs
,
3387 Elf_Internal_Sym
*local_syms
,
3388 asection
**local_sections
)
3390 struct elf64_ia64_link_hash_table
*ia64_info
;
3391 Elf_Internal_Shdr
*symtab_hdr
;
3392 Elf_Internal_Rela
*rel
;
3393 Elf_Internal_Rela
*relend
;
3394 bfd_boolean ret_val
= TRUE
; /* for non-fatal errors */
3397 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3398 ia64_info
= elf64_ia64_hash_table (info
);
3399 if (ia64_info
== NULL
)
3402 /* Infect various flags from the input section to the output section. */
3403 if (bfd_link_relocatable (info
))
3407 flags
= elf_section_data(input_section
)->this_hdr
.sh_flags
;
3408 flags
&= SHF_IA_64_NORECOV
;
3410 elf_section_data(input_section
->output_section
)
3411 ->this_hdr
.sh_flags
|= flags
;
3414 gp_val
= _bfd_get_gp_value (output_bfd
);
3417 relend
= relocs
+ input_section
->reloc_count
;
3418 for (; rel
< relend
; ++rel
)
3420 struct elf_link_hash_entry
*h
;
3421 struct elf64_ia64_dyn_sym_info
*dyn_i
;
3422 bfd_reloc_status_type r
;
3423 reloc_howto_type
*howto
;
3424 unsigned long r_symndx
;
3425 Elf_Internal_Sym
*sym
;
3426 unsigned int r_type
;
3430 bfd_boolean dynamic_symbol_p
;
3431 bfd_boolean undef_weak_ref
;
3433 r_type
= ELF64_R_TYPE (rel
->r_info
);
3434 if (r_type
> R_IA64_MAX_RELOC_CODE
)
3436 /* xgettext:c-format */
3437 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
3438 input_bfd
, (int) r_type
);
3439 bfd_set_error (bfd_error_bad_value
);
3444 howto
= ia64_elf_lookup_howto (r_type
);
3450 r_symndx
= ELF64_R_SYM (rel
->r_info
);
3454 undef_weak_ref
= FALSE
;
3456 if (r_symndx
< symtab_hdr
->sh_info
)
3458 /* Reloc against local symbol. */
3460 sym
= local_syms
+ r_symndx
;
3461 sym_sec
= local_sections
[r_symndx
];
3463 value
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &msec
, rel
);
3464 if (!bfd_link_relocatable (info
)
3465 && (sym_sec
->flags
& SEC_MERGE
) != 0
3466 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3467 && sym_sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
3469 struct elf64_ia64_local_hash_entry
*loc_h
;
3471 loc_h
= get_local_sym_hash (ia64_info
, input_bfd
, rel
, FALSE
);
3472 if (loc_h
&& ! loc_h
->sec_merge_done
)
3474 struct elf64_ia64_dyn_sym_info
*dynent
;
3477 for (count
= loc_h
->count
, dynent
= loc_h
->info
;
3483 _bfd_merged_section_offset (output_bfd
, &msec
,
3484 elf_section_data (msec
)->
3488 dynent
->addend
-= sym
->st_value
;
3489 dynent
->addend
+= msec
->output_section
->vma
3490 + msec
->output_offset
3491 - sym_sec
->output_section
->vma
3492 - sym_sec
->output_offset
;
3495 /* We may have introduced duplicated entries. We need
3496 to remove them properly. */
3497 count
= sort_dyn_sym_info (loc_h
->info
, loc_h
->count
);
3498 if (count
!= loc_h
->count
)
3500 loc_h
->count
= count
;
3501 loc_h
->sorted_count
= count
;
3504 loc_h
->sec_merge_done
= 1;
3510 bfd_boolean unresolved_reloc
;
3511 bfd_boolean warned
, ignored
;
3512 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
3514 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3515 r_symndx
, symtab_hdr
, sym_hashes
,
3517 unresolved_reloc
, warned
, ignored
);
3519 if (h
->root
.type
== bfd_link_hash_undefweak
)
3520 undef_weak_ref
= TRUE
;
3525 /* For relocs against symbols from removed linkonce sections,
3526 or sections discarded by a linker script, we just want the
3527 section contents zeroed. Avoid any special processing. */
3528 if (sym_sec
!= NULL
&& discarded_section (sym_sec
))
3529 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3530 rel
, 1, relend
, howto
, 0, contents
);
3532 if (bfd_link_relocatable (info
))
3535 hit_addr
= contents
+ rel
->r_offset
;
3536 value
+= rel
->r_addend
;
3537 dynamic_symbol_p
= elf64_ia64_dynamic_symbol_p (h
);
3548 case R_IA64_DIR32MSB
:
3549 case R_IA64_DIR32LSB
:
3550 case R_IA64_DIR64MSB
:
3551 case R_IA64_DIR64LSB
:
3552 /* Install a dynamic relocation for this reloc. */
3553 if ((dynamic_symbol_p
|| bfd_link_pic (info
))
3555 && (input_section
->flags
& SEC_ALLOC
) != 0)
3557 unsigned int dyn_r_type
;
3565 /* ??? People shouldn't be doing non-pic code in
3566 shared libraries nor dynamic executables. */
3568 /* xgettext:c-format */
3569 (_("%pB: non-pic code with imm relocation against"
3570 " dynamic symbol `%s'"),
3572 h
? h
->root
.root
.string
3573 : bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3582 /* If we don't need dynamic symbol lookup, find a
3583 matching RELATIVE relocation. */
3584 dyn_r_type
= r_type
;
3585 if (dynamic_symbol_p
)
3587 addend
= rel
->r_addend
;
3595 /* VMS: install a FIX64. */
3598 case R_IA64_DIR32LSB
:
3599 dyn_r_type
= R_IA64_VMS_FIX32
;
3601 case R_IA64_DIR64LSB
:
3602 dyn_r_type
= R_IA64_VMS_FIX64
;
3608 elf64_ia64_install_fixup
3609 (output_bfd
, ia64_info
, h
,
3610 dyn_r_type
, input_section
, rel
->r_offset
, addend
);
3616 case R_IA64_LTV32MSB
:
3617 case R_IA64_LTV32LSB
:
3618 case R_IA64_LTV64MSB
:
3619 case R_IA64_LTV64LSB
:
3620 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
3623 case R_IA64_GPREL22
:
3624 case R_IA64_GPREL64I
:
3625 case R_IA64_GPREL32MSB
:
3626 case R_IA64_GPREL32LSB
:
3627 case R_IA64_GPREL64MSB
:
3628 case R_IA64_GPREL64LSB
:
3629 if (dynamic_symbol_p
)
3632 /* xgettext:c-format */
3633 (_("%pB: @gprel relocation against dynamic symbol %s"),
3635 h
? h
->root
.root
.string
3636 : bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3642 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
3645 case R_IA64_LTOFF22
:
3646 case R_IA64_LTOFF22X
:
3647 case R_IA64_LTOFF64I
:
3648 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
3649 value
= set_got_entry (input_bfd
, info
, dyn_i
,
3650 rel
->r_addend
, value
, R_IA64_DIR64LSB
);
3652 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
3655 case R_IA64_PLTOFF22
:
3656 case R_IA64_PLTOFF64I
:
3657 case R_IA64_PLTOFF64MSB
:
3658 case R_IA64_PLTOFF64LSB
:
3659 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
3660 value
= set_pltoff_entry (output_bfd
, info
, dyn_i
, value
, FALSE
);
3662 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
3665 case R_IA64_FPTR64I
:
3666 case R_IA64_FPTR32MSB
:
3667 case R_IA64_FPTR32LSB
:
3668 case R_IA64_FPTR64MSB
:
3669 case R_IA64_FPTR64LSB
:
3670 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
3671 if (dyn_i
->want_fptr
)
3673 if (!undef_weak_ref
)
3674 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
3676 if (!dyn_i
->want_fptr
|| bfd_link_pie (info
))
3678 /* Otherwise, we expect the dynamic linker to create
3681 if (dyn_i
->want_fptr
)
3683 if (r_type
== R_IA64_FPTR64I
)
3685 /* We can't represent this without a dynamic symbol.
3686 Adjust the relocation to be against an output
3687 section symbol, which are always present in the
3688 dynamic symbol table. */
3689 /* ??? People shouldn't be doing non-pic code in
3690 shared libraries. Hork. */
3692 (_("%pB: linking non-pic code in a position independent executable"),
3704 elf64_ia64_install_fixup
3705 (output_bfd
, ia64_info
, h
, R_IA64_VMS_FIXFD
,
3706 input_section
, rel
->r_offset
, 0);
3711 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
3714 case R_IA64_LTOFF_FPTR22
:
3715 case R_IA64_LTOFF_FPTR64I
:
3716 case R_IA64_LTOFF_FPTR32MSB
:
3717 case R_IA64_LTOFF_FPTR32LSB
:
3718 case R_IA64_LTOFF_FPTR64MSB
:
3719 case R_IA64_LTOFF_FPTR64LSB
:
3720 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
3721 if (dyn_i
->want_fptr
)
3723 BFD_ASSERT (h
== NULL
|| !h
->def_dynamic
);
3724 if (!undef_weak_ref
)
3725 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
3730 value
= set_got_entry (output_bfd
, info
, dyn_i
,
3731 rel
->r_addend
, value
, R_IA64_FPTR64LSB
);
3733 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
3736 case R_IA64_PCREL32MSB
:
3737 case R_IA64_PCREL32LSB
:
3738 case R_IA64_PCREL64MSB
:
3739 case R_IA64_PCREL64LSB
:
3740 /* Install a dynamic relocation for this reloc. */
3741 if (dynamic_symbol_p
&& r_symndx
!= 0)
3743 /* VMS: doesn't exist ??? */
3748 case R_IA64_PCREL21B
:
3749 case R_IA64_PCREL60B
:
3750 /* We should have created a PLT entry for any dynamic symbol. */
3753 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, FALSE
);
3755 if (dyn_i
&& dyn_i
->want_plt2
)
3757 /* Should have caught this earlier. */
3758 BFD_ASSERT (rel
->r_addend
== 0);
3760 value
= (ia64_info
->root
.splt
->output_section
->vma
3761 + ia64_info
->root
.splt
->output_offset
3762 + dyn_i
->plt2_offset
);
3766 /* Since there's no PLT entry, Validate that this is
3768 BFD_ASSERT (undef_weak_ref
|| sym_sec
->output_section
!= NULL
);
3770 /* If the symbol is undef_weak, we shouldn't be trying
3771 to call it. There's every chance that we'd wind up
3772 with an out-of-range fixup here. Don't bother setting
3773 any value at all. */
3779 case R_IA64_PCREL21BI
:
3780 case R_IA64_PCREL21F
:
3781 case R_IA64_PCREL21M
:
3782 case R_IA64_PCREL22
:
3783 case R_IA64_PCREL64I
:
3784 /* The PCREL21BI reloc is specifically not intended for use with
3785 dynamic relocs. PCREL21F and PCREL21M are used for speculation
3786 fixup code, and thus probably ought not be dynamic. The
3787 PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs. */
3788 if (dynamic_symbol_p
)
3792 if (r_type
== R_IA64_PCREL21BI
)
3793 /* xgettext:c-format */
3794 msg
= _("%pB: @internal branch to dynamic symbol %s");
3795 else if (r_type
== R_IA64_PCREL21F
|| r_type
== R_IA64_PCREL21M
)
3796 /* xgettext:c-format */
3797 msg
= _("%pB: speculation fixup to dynamic symbol %s");
3799 /* xgettext:c-format */
3800 msg
= _("%pB: @pcrel relocation against dynamic symbol %s");
3801 _bfd_error_handler (msg
, input_bfd
,
3802 h
? h
->root
.root
.string
3803 : bfd_elf_sym_name (input_bfd
,
3813 /* Make pc-relative. */
3814 value
-= (input_section
->output_section
->vma
3815 + input_section
->output_offset
3816 + rel
->r_offset
) & ~ (bfd_vma
) 0x3;
3817 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
3820 case R_IA64_SEGREL32MSB
:
3821 case R_IA64_SEGREL32LSB
:
3822 case R_IA64_SEGREL64MSB
:
3823 case R_IA64_SEGREL64LSB
:
3825 /* Find the segment that contains the output_section. */
3826 Elf_Internal_Phdr
*p
= _bfd_elf_find_segment_containing_section
3827 (output_bfd
, sym_sec
->output_section
);
3831 r
= bfd_reloc_notsupported
;
3835 /* The VMA of the segment is the vaddr of the associated
3837 if (value
> p
->p_vaddr
)
3838 value
-= p
->p_vaddr
;
3841 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
3846 case R_IA64_SECREL32MSB
:
3847 case R_IA64_SECREL32LSB
:
3848 case R_IA64_SECREL64MSB
:
3849 case R_IA64_SECREL64LSB
:
3850 /* Make output-section relative to section where the symbol
3851 is defined. PR 475 */
3853 value
-= sym_sec
->output_section
->vma
;
3854 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
3857 case R_IA64_IPLTMSB
:
3858 case R_IA64_IPLTLSB
:
3859 /* Install a dynamic relocation for this reloc. */
3860 if ((dynamic_symbol_p
|| bfd_link_pic (info
))
3861 && (input_section
->flags
& SEC_ALLOC
) != 0)
3867 if (r_type
== R_IA64_IPLTMSB
)
3868 r_type
= R_IA64_DIR64MSB
;
3870 r_type
= R_IA64_DIR64LSB
;
3871 ia64_elf_install_value (hit_addr
, value
, r_type
);
3872 r
= ia64_elf_install_value (hit_addr
+ 8, gp_val
, r_type
);
3875 case R_IA64_TPREL14
:
3876 case R_IA64_TPREL22
:
3877 case R_IA64_TPREL64I
:
3878 r
= bfd_reloc_notsupported
;
3881 case R_IA64_DTPREL14
:
3882 case R_IA64_DTPREL22
:
3883 case R_IA64_DTPREL64I
:
3884 case R_IA64_DTPREL32LSB
:
3885 case R_IA64_DTPREL32MSB
:
3886 case R_IA64_DTPREL64LSB
:
3887 case R_IA64_DTPREL64MSB
:
3888 r
= bfd_reloc_notsupported
;
3891 case R_IA64_LTOFF_TPREL22
:
3892 case R_IA64_LTOFF_DTPMOD22
:
3893 case R_IA64_LTOFF_DTPREL22
:
3894 r
= bfd_reloc_notsupported
;
3898 r
= bfd_reloc_notsupported
;
3907 case bfd_reloc_undefined
:
3908 /* This can happen for global table relative relocs if
3909 __gp is undefined. This is a panic situation so we
3910 don't try to continue. */
3911 (*info
->callbacks
->undefined_symbol
)
3912 (info
, "__gp", input_bfd
, input_section
, rel
->r_offset
, 1);
3915 case bfd_reloc_notsupported
:
3920 name
= h
->root
.root
.string
;
3922 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3924 (*info
->callbacks
->warning
) (info
, _("unsupported reloc"),
3926 input_section
, rel
->r_offset
);
3931 case bfd_reloc_dangerous
:
3932 case bfd_reloc_outofrange
:
3933 case bfd_reloc_overflow
:
3939 name
= h
->root
.root
.string
;
3941 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3946 case R_IA64_TPREL14
:
3947 case R_IA64_TPREL22
:
3948 case R_IA64_TPREL64I
:
3949 case R_IA64_DTPREL14
:
3950 case R_IA64_DTPREL22
:
3951 case R_IA64_DTPREL64I
:
3952 case R_IA64_DTPREL32LSB
:
3953 case R_IA64_DTPREL32MSB
:
3954 case R_IA64_DTPREL64LSB
:
3955 case R_IA64_DTPREL64MSB
:
3956 case R_IA64_LTOFF_TPREL22
:
3957 case R_IA64_LTOFF_DTPMOD22
:
3958 case R_IA64_LTOFF_DTPREL22
:
3960 /* xgettext:c-format */
3961 (_("%pB: missing TLS section for relocation %s against `%s'"
3962 " at %#" PRIx64
" in section `%pA'."),
3963 input_bfd
, howto
->name
, name
,
3964 (uint64_t) rel
->r_offset
, input_section
);
3967 case R_IA64_PCREL21B
:
3968 case R_IA64_PCREL21BI
:
3969 case R_IA64_PCREL21M
:
3970 case R_IA64_PCREL21F
:
3971 if (is_elf_hash_table (info
->hash
))
3973 /* Relaxtion is always performed for ELF output.
3974 Overflow failures for those relocations mean
3975 that the section is too big to relax. */
3977 /* xgettext:c-format */
3978 (_("%pB: Can't relax br (%s) to `%s' "
3979 "at %#" PRIx64
" in section `%pA' "
3980 "with size %#" PRIx64
" (> 0x1000000)."),
3981 input_bfd
, howto
->name
, name
, (uint64_t) rel
->r_offset
,
3982 input_section
, (uint64_t) input_section
->size
);
3987 (*info
->callbacks
->reloc_overflow
) (info
,
4008 elf64_ia64_finish_dynamic_symbol (bfd
*output_bfd
,
4009 struct bfd_link_info
*info
,
4010 struct elf_link_hash_entry
*h
,
4011 Elf_Internal_Sym
*sym
)
4013 struct elf64_ia64_link_hash_table
*ia64_info
;
4014 struct elf64_ia64_dyn_sym_info
*dyn_i
;
4016 ia64_info
= elf64_ia64_hash_table (info
);
4017 if (ia64_info
== NULL
)
4020 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, FALSE
);
4022 /* Fill in the PLT data, if required. */
4023 if (dyn_i
&& dyn_i
->want_plt
)
4027 bfd_vma plt_addr
, pltoff_addr
, gp_val
;
4029 gp_val
= _bfd_get_gp_value (output_bfd
);
4031 plt_sec
= ia64_info
->root
.splt
;
4032 plt_addr
= 0; /* Not used as overriden by FIXUPs. */
4033 pltoff_addr
= set_pltoff_entry (output_bfd
, info
, dyn_i
, plt_addr
, TRUE
);
4035 /* Initialize the FULL PLT entry, if needed. */
4036 if (dyn_i
->want_plt2
)
4038 loc
= plt_sec
->contents
+ dyn_i
->plt2_offset
;
4040 memcpy (loc
, plt_full_entry
, PLT_FULL_ENTRY_SIZE
);
4041 ia64_elf_install_value (loc
, pltoff_addr
- gp_val
, R_IA64_IMM22
);
4043 /* Mark the symbol as undefined, rather than as defined in the
4044 plt section. Leave the value alone. */
4045 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
4046 first place. But perhaps elflink.c did some for us. */
4047 if (!h
->def_regular
)
4048 sym
->st_shndx
= SHN_UNDEF
;
4052 elf64_ia64_install_fixup
4053 (output_bfd
, ia64_info
, h
, R_IA64_VMS_FIXFD
, ia64_info
->pltoff_sec
,
4054 pltoff_addr
- (ia64_info
->pltoff_sec
->output_section
->vma
4055 + ia64_info
->pltoff_sec
->output_offset
), 0);
4058 /* Mark some specially defined symbols as absolute. */
4059 if (h
== ia64_info
->root
.hdynamic
4060 || h
== ia64_info
->root
.hgot
4061 || h
== ia64_info
->root
.hplt
)
4062 sym
->st_shndx
= SHN_ABS
;
4068 elf64_ia64_finish_dynamic_sections (bfd
*abfd
,
4069 struct bfd_link_info
*info
)
4071 struct elf64_ia64_link_hash_table
*ia64_info
;
4074 ia64_info
= elf64_ia64_hash_table (info
);
4075 if (ia64_info
== NULL
)
4078 dynobj
= ia64_info
->root
.dynobj
;
4080 if (elf_hash_table (info
)->dynamic_sections_created
)
4082 Elf64_External_Dyn
*dyncon
, *dynconend
;
4084 asection
*unwind_sec
;
4086 unsigned int gp_seg
;
4088 Elf_Internal_Phdr
*phdr
;
4089 Elf_Internal_Phdr
*base_phdr
;
4090 unsigned int unwind_seg
= 0;
4091 unsigned int code_seg
= 0;
4093 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
4094 BFD_ASSERT (sdyn
!= NULL
);
4095 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
4096 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4098 gp_val
= _bfd_get_gp_value (abfd
);
4099 phdr
= _bfd_elf_find_segment_containing_section
4100 (info
->output_bfd
, ia64_info
->pltoff_sec
->output_section
);
4101 BFD_ASSERT (phdr
!= NULL
);
4102 base_phdr
= elf_tdata (info
->output_bfd
)->phdr
;
4103 gp_seg
= phdr
- base_phdr
;
4104 gp_off
= gp_val
- phdr
->p_vaddr
;
4106 unwind_sec
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_unwind
);
4107 if (unwind_sec
!= NULL
)
4111 phdr
= _bfd_elf_find_segment_containing_section (abfd
, unwind_sec
);
4112 BFD_ASSERT (phdr
!= NULL
);
4113 unwind_seg
= phdr
- base_phdr
;
4115 code_sec
= bfd_get_section_by_name (abfd
, "$CODE$");
4116 phdr
= _bfd_elf_find_segment_containing_section (abfd
, code_sec
);
4117 BFD_ASSERT (phdr
!= NULL
);
4118 code_seg
= phdr
- base_phdr
;
4121 for (; dyncon
< dynconend
; dyncon
++)
4123 Elf_Internal_Dyn dyn
;
4125 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4129 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
4131 (ia64_info
->fixups_sec
->output_section
->vma
4132 + ia64_info
->fixups_sec
->output_offset
)
4133 - (sdyn
->output_section
->vma
+ sdyn
->output_offset
);
4136 case DT_IA_64_VMS_PLTGOT_OFFSET
:
4137 dyn
.d_un
.d_val
= gp_off
;
4140 case DT_IA_64_VMS_PLTGOT_SEG
:
4141 dyn
.d_un
.d_val
= gp_seg
;
4144 case DT_IA_64_VMS_UNWINDSZ
:
4145 if (unwind_sec
== NULL
)
4147 dyn
.d_tag
= DT_NULL
;
4148 dyn
.d_un
.d_val
= 0xdead;
4151 dyn
.d_un
.d_val
= unwind_sec
->size
;
4154 case DT_IA_64_VMS_UNWIND_CODSEG
:
4155 dyn
.d_un
.d_val
= code_seg
;
4158 case DT_IA_64_VMS_UNWIND_INFOSEG
:
4159 case DT_IA_64_VMS_UNWIND_SEG
:
4160 dyn
.d_un
.d_val
= unwind_seg
;
4163 case DT_IA_64_VMS_UNWIND_OFFSET
:
4167 /* No need to rewrite the entry. */
4171 bfd_elf64_swap_dyn_out (abfd
, &dyn
, dyncon
);
4175 /* Handle transfer addresses. */
4177 asection
*tfr_sec
= ia64_info
->transfer_sec
;
4178 struct elf64_vms_transfer
*tfr
;
4179 struct elf_link_hash_entry
*tfr3
;
4181 tfr
= (struct elf64_vms_transfer
*)tfr_sec
->contents
;
4182 bfd_putl32 (6 * 8, tfr
->size
);
4183 bfd_putl64 (tfr_sec
->output_section
->vma
4184 + tfr_sec
->output_offset
4185 + 6 * 8, tfr
->tfradr3
);
4187 tfr3
= elf_link_hash_lookup (elf_hash_table (info
), "ELF$TFRADR", FALSE
,
4191 && (tfr3
->root
.type
== bfd_link_hash_defined
4192 || tfr3
->root
.type
== bfd_link_hash_defweak
))
4194 asection
*tfr3_sec
= tfr3
->root
.u
.def
.section
;
4197 tfr3_val
= (tfr3
->root
.u
.def
.value
4198 + tfr3_sec
->output_section
->vma
4199 + tfr3_sec
->output_offset
);
4201 bfd_putl64 (tfr3_val
, tfr
->tfr3_func
);
4202 bfd_putl64 (_bfd_get_gp_value (info
->output_bfd
), tfr
->tfr3_gp
);
4205 /* FIXME: set linker flags,
4206 handle lib$initialize. */
4212 /* ELF file flag handling: */
4214 /* Function to keep IA-64 specific file flags. */
4216 elf64_ia64_set_private_flags (bfd
*abfd
, flagword flags
)
4218 BFD_ASSERT (!elf_flags_init (abfd
)
4219 || elf_elfheader (abfd
)->e_flags
== flags
);
4221 elf_elfheader (abfd
)->e_flags
= flags
;
4222 elf_flags_init (abfd
) = TRUE
;
4226 /* Merge backend specific data from an object file to the output
4227 object file when linking. */
4229 elf64_ia64_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
4231 bfd
*obfd
= info
->output_bfd
;
4234 bfd_boolean ok
= TRUE
;
4236 /* FIXME: What should be checked when linking shared libraries? */
4237 if ((ibfd
->flags
& DYNAMIC
) != 0)
4240 /* Don't even pretend to support mixed-format linking. */
4241 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4242 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4245 in_flags
= elf_elfheader (ibfd
)->e_flags
;
4246 out_flags
= elf_elfheader (obfd
)->e_flags
;
4248 if (! elf_flags_init (obfd
))
4250 elf_flags_init (obfd
) = TRUE
;
4251 elf_elfheader (obfd
)->e_flags
= in_flags
;
4253 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
4254 && bfd_get_arch_info (obfd
)->the_default
)
4256 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
4257 bfd_get_mach (ibfd
));
4263 /* Check flag compatibility. */
4264 if (in_flags
== out_flags
)
4267 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
4268 if (!(in_flags
& EF_IA_64_REDUCEDFP
) && (out_flags
& EF_IA_64_REDUCEDFP
))
4269 elf_elfheader (obfd
)->e_flags
&= ~EF_IA_64_REDUCEDFP
;
4271 if ((in_flags
& EF_IA_64_TRAPNIL
) != (out_flags
& EF_IA_64_TRAPNIL
))
4274 (_("%pB: linking trap-on-NULL-dereference with non-trapping files"),
4277 bfd_set_error (bfd_error_bad_value
);
4280 if ((in_flags
& EF_IA_64_BE
) != (out_flags
& EF_IA_64_BE
))
4283 (_("%pB: linking big-endian files with little-endian files"),
4286 bfd_set_error (bfd_error_bad_value
);
4289 if ((in_flags
& EF_IA_64_ABI64
) != (out_flags
& EF_IA_64_ABI64
))
4292 (_("%pB: linking 64-bit files with 32-bit files"),
4295 bfd_set_error (bfd_error_bad_value
);
4298 if ((in_flags
& EF_IA_64_CONS_GP
) != (out_flags
& EF_IA_64_CONS_GP
))
4301 (_("%pB: linking constant-gp files with non-constant-gp files"),
4304 bfd_set_error (bfd_error_bad_value
);
4307 if ((in_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
)
4308 != (out_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
4311 (_("%pB: linking auto-pic files with non-auto-pic files"),
4314 bfd_set_error (bfd_error_bad_value
);
4322 elf64_ia64_print_private_bfd_data (bfd
*abfd
, void * ptr
)
4324 FILE *file
= (FILE *) ptr
;
4325 flagword flags
= elf_elfheader (abfd
)->e_flags
;
4327 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
4329 fprintf (file
, "private flags = %s%s%s%s%s%s%s%s\n",
4330 (flags
& EF_IA_64_TRAPNIL
) ? "TRAPNIL, " : "",
4331 (flags
& EF_IA_64_EXT
) ? "EXT, " : "",
4332 (flags
& EF_IA_64_BE
) ? "BE, " : "LE, ",
4333 (flags
& EF_IA_64_REDUCEDFP
) ? "REDUCEDFP, " : "",
4334 (flags
& EF_IA_64_CONS_GP
) ? "CONS_GP, " : "",
4335 (flags
& EF_IA_64_NOFUNCDESC_CONS_GP
) ? "NOFUNCDESC_CONS_GP, " : "",
4336 (flags
& EF_IA_64_ABSOLUTE
) ? "ABSOLUTE, " : "",
4337 (flags
& EF_IA_64_ABI64
) ? "ABI64" : "ABI32");
4339 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
4343 static enum elf_reloc_type_class
4344 elf64_ia64_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4345 const asection
*rel_sec ATTRIBUTE_UNUSED
,
4346 const Elf_Internal_Rela
*rela
)
4348 switch ((int) ELF64_R_TYPE (rela
->r_info
))
4350 case R_IA64_REL32MSB
:
4351 case R_IA64_REL32LSB
:
4352 case R_IA64_REL64MSB
:
4353 case R_IA64_REL64LSB
:
4354 return reloc_class_relative
;
4355 case R_IA64_IPLTMSB
:
4356 case R_IA64_IPLTLSB
:
4357 return reloc_class_plt
;
4359 return reloc_class_copy
;
4361 return reloc_class_normal
;
4365 static const struct bfd_elf_special_section elf64_ia64_special_sections
[] =
4367 { STRING_COMMA_LEN (".sbss"), -1, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_IA_64_SHORT
},
4368 { STRING_COMMA_LEN (".sdata"), -1, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_IA_64_SHORT
},
4369 { NULL
, 0, 0, 0, 0 }
4373 elf64_ia64_object_p (bfd
*abfd
)
4376 asection
*group
, *unwi
, *unw
;
4379 char *unwi_name
, *unw_name
;
4382 if (abfd
->flags
& DYNAMIC
)
4385 /* Flags for fake group section. */
4386 flags
= (SEC_LINKER_CREATED
| SEC_GROUP
| SEC_LINK_ONCE
4389 /* We add a fake section group for each .gnu.linkonce.t.* section,
4390 which isn't in a section group, and its unwind sections. */
4391 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4393 if (elf_sec_group (sec
) == NULL
4394 && ((sec
->flags
& (SEC_LINK_ONCE
| SEC_CODE
| SEC_GROUP
))
4395 == (SEC_LINK_ONCE
| SEC_CODE
))
4396 && CONST_STRNEQ (sec
->name
, ".gnu.linkonce.t."))
4398 name
= sec
->name
+ 16;
4400 amt
= strlen (name
) + sizeof (".gnu.linkonce.ia64unwi.");
4401 unwi_name
= bfd_alloc (abfd
, amt
);
4405 strcpy (stpcpy (unwi_name
, ".gnu.linkonce.ia64unwi."), name
);
4406 unwi
= bfd_get_section_by_name (abfd
, unwi_name
);
4408 amt
= strlen (name
) + sizeof (".gnu.linkonce.ia64unw.");
4409 unw_name
= bfd_alloc (abfd
, amt
);
4413 strcpy (stpcpy (unw_name
, ".gnu.linkonce.ia64unw."), name
);
4414 unw
= bfd_get_section_by_name (abfd
, unw_name
);
4416 /* We need to create a fake group section for it and its
4418 group
= bfd_make_section_anyway_with_flags (abfd
, name
,
4423 /* Move the fake group section to the beginning. */
4424 bfd_section_list_remove (abfd
, group
);
4425 bfd_section_list_prepend (abfd
, group
);
4427 elf_next_in_group (group
) = sec
;
4429 elf_group_name (sec
) = name
;
4430 elf_next_in_group (sec
) = sec
;
4431 elf_sec_group (sec
) = group
;
4435 elf_group_name (unwi
) = name
;
4436 elf_next_in_group (unwi
) = sec
;
4437 elf_next_in_group (sec
) = unwi
;
4438 elf_sec_group (unwi
) = group
;
4443 elf_group_name (unw
) = name
;
4446 elf_next_in_group (unw
) = elf_next_in_group (unwi
);
4447 elf_next_in_group (unwi
) = unw
;
4451 elf_next_in_group (unw
) = sec
;
4452 elf_next_in_group (sec
) = unw
;
4454 elf_sec_group (unw
) = group
;
4457 /* Fake SHT_GROUP section header. */
4458 elf_section_data (group
)->this_hdr
.bfd_section
= group
;
4459 elf_section_data (group
)->this_hdr
.sh_type
= SHT_GROUP
;
4465 /* Handle an IA-64 specific section when reading an object file. This
4466 is called when bfd_section_from_shdr finds a section with an unknown
4470 elf64_vms_section_from_shdr (bfd
*abfd
,
4471 Elf_Internal_Shdr
*hdr
,
4475 flagword secflags
= 0;
4477 switch (hdr
->sh_type
)
4479 case SHT_IA_64_VMS_TRACE
:
4480 case SHT_IA_64_VMS_DEBUG
:
4481 case SHT_IA_64_VMS_DEBUG_STR
:
4482 secflags
= SEC_DEBUGGING
;
4485 case SHT_IA_64_UNWIND
:
4486 case SHT_IA_64_HP_OPT_ANOT
:
4490 if (strcmp (name
, ELF_STRING_ia64_archext
) != 0)
4498 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
4503 asection
*newsect
= hdr
->bfd_section
;
4505 if (!bfd_set_section_flags (newsect
,
4506 bfd_section_flags (newsect
) | secflags
))
4514 elf64_vms_object_p (bfd
*abfd
)
4516 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
4517 Elf_Internal_Phdr
*i_phdr
= elf_tdata (abfd
)->phdr
;
4519 unsigned int num_text
= 0;
4520 unsigned int num_data
= 0;
4521 unsigned int num_rodata
= 0;
4524 if (!elf64_ia64_object_p (abfd
))
4527 /* Many VMS compilers do not generate sections for the corresponding
4528 segment. This is boring as binutils tools won't be able to disassemble
4529 the code. So we simply create all the missing sections. */
4530 for (i
= 0; i
< i_ehdrp
->e_phnum
; i
++, i_phdr
++)
4532 /* Is there a section for this segment? */
4533 bfd_vma base_vma
= i_phdr
->p_vaddr
;
4534 bfd_vma limit_vma
= base_vma
+ i_phdr
->p_filesz
;
4536 if (i_phdr
->p_type
!= PT_LOAD
)
4539 /* We need to cover from base_vms to limit_vma. */
4541 while (base_vma
< limit_vma
)
4543 bfd_vma next_vma
= limit_vma
;
4549 /* Find a section covering [base_vma;limit_vma) */
4550 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4552 /* Skip uninteresting sections (either not in memory or
4554 if ((sec
->flags
& (SEC_ALLOC
| SEC_LOAD
)) == 0
4555 || sec
->vma
+ sec
->size
<= base_vma
)
4557 if (sec
->vma
<= base_vma
)
4559 /* This section covers (maybe partially) the beginning
4561 base_vma
= sec
->vma
+ sec
->size
;
4564 if (sec
->vma
< next_vma
)
4566 /* This section partially covers the end of the range.
4567 Used to compute the size of the hole. */
4568 next_vma
= sec
->vma
;
4572 /* No section covering [base_vma; next_vma). Create a fake one. */
4573 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
;
4574 if (i_phdr
->p_flags
& PF_X
)
4577 if (num_text
++ == 0)
4580 sprintf (name
, ".text$%u", num_text
);
4582 else if ((i_phdr
->p_flags
& (PF_R
| PF_W
)) == PF_R
)
4584 flags
|= SEC_READONLY
;
4585 sprintf (name
, ".rodata$%u", num_rodata
++);
4590 sprintf (name
, ".data$%u", num_data
++);
4593 /* Allocate name. */
4596 size_t name_len
= strlen (name
) + 1;
4597 nname
= bfd_alloc (abfd
, name_len
);
4600 memcpy (nname
, name
, name_len
);
4603 /* Create and fill new section. */
4604 nsec
= bfd_make_section_anyway_with_flags (abfd
, nname
, flags
);
4607 nsec
->vma
= base_vma
;
4608 nsec
->size
= next_vma
- base_vma
;
4609 nsec
->filepos
= i_phdr
->p_offset
+ (base_vma
- i_phdr
->p_vaddr
);
4611 base_vma
= next_vma
;
4618 elf64_vms_init_file_header (bfd
*abfd
, struct bfd_link_info
*info
)
4620 Elf_Internal_Ehdr
*i_ehdrp
;
4622 if (!_bfd_elf_init_file_header (abfd
, info
))
4625 i_ehdrp
= elf_elfheader (abfd
);
4626 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_OPENVMS
;
4627 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 2;
4632 elf64_vms_section_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
4633 Elf_Internal_Shdr
*hdr
)
4635 if (hdr
->bfd_section
!= NULL
)
4637 const char *name
= bfd_section_name (hdr
->bfd_section
);
4639 if (strcmp (name
, ".text") == 0)
4640 hdr
->sh_flags
|= SHF_IA_64_VMS_SHARED
;
4641 else if ((strcmp (name
, ".debug") == 0)
4642 || (strcmp (name
, ".debug_abbrev") == 0)
4643 || (strcmp (name
, ".debug_aranges") == 0)
4644 || (strcmp (name
, ".debug_frame") == 0)
4645 || (strcmp (name
, ".debug_info") == 0)
4646 || (strcmp (name
, ".debug_loc") == 0)
4647 || (strcmp (name
, ".debug_macinfo") == 0)
4648 || (strcmp (name
, ".debug_pubnames") == 0)
4649 || (strcmp (name
, ".debug_pubtypes") == 0))
4650 hdr
->sh_type
= SHT_IA_64_VMS_DEBUG
;
4651 else if ((strcmp (name
, ".debug_line") == 0)
4652 || (strcmp (name
, ".debug_ranges") == 0)
4653 || (strcmp (name
, ".trace_info") == 0)
4654 || (strcmp (name
, ".trace_abbrev") == 0)
4655 || (strcmp (name
, ".trace_aranges") == 0))
4656 hdr
->sh_type
= SHT_IA_64_VMS_TRACE
;
4657 else if (strcmp (name
, ".debug_str") == 0)
4658 hdr
->sh_type
= SHT_IA_64_VMS_DEBUG_STR
;
4664 /* The final processing done just before writing out a VMS IA-64 ELF
4668 elf64_vms_final_write_processing (bfd
*abfd
)
4670 Elf_Internal_Shdr
*hdr
;
4672 int unwind_info_sect_idx
= 0;
4674 for (s
= abfd
->sections
; s
; s
= s
->next
)
4676 hdr
= &elf_section_data (s
)->this_hdr
;
4678 if (strcmp (bfd_section_name (hdr
->bfd_section
),
4679 ".IA_64.unwind_info") == 0)
4680 unwind_info_sect_idx
= elf_section_data (s
)->this_idx
;
4682 switch (hdr
->sh_type
)
4684 case SHT_IA_64_UNWIND
:
4685 /* VMS requires sh_info to point to the unwind info section. */
4686 hdr
->sh_info
= unwind_info_sect_idx
;
4691 if (! elf_flags_init (abfd
))
4693 unsigned long flags
= 0;
4695 if (abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
)
4696 flags
|= EF_IA_64_BE
;
4697 if (bfd_get_mach (abfd
) == bfd_mach_ia64_elf64
)
4698 flags
|= EF_IA_64_ABI64
;
4700 elf_elfheader (abfd
)->e_flags
= flags
;
4701 elf_flags_init (abfd
) = TRUE
;
4703 return _bfd_elf_final_write_processing (abfd
);
4707 elf64_vms_write_shdrs_and_ehdr (bfd
*abfd
)
4709 unsigned char needed_count
[8];
4711 if (!bfd_elf64_write_shdrs_and_ehdr (abfd
))
4714 bfd_putl64 (elf_ia64_vms_tdata (abfd
)->needed_count
, needed_count
);
4716 if (bfd_seek (abfd
, sizeof (Elf64_External_Ehdr
), SEEK_SET
) != 0
4717 || bfd_bwrite (needed_count
, 8, abfd
) != 8)
4724 elf64_vms_close_and_cleanup (bfd
*abfd
)
4726 if (bfd_get_format (abfd
) == bfd_object
)
4730 /* Pad to 8 byte boundary for IPF/VMS. */
4731 isize
= bfd_get_size (abfd
);
4732 if ((isize
& 7) != 0)
4734 int ishort
= 8 - (isize
& 7);
4735 bfd_uint64_t pad
= 0;
4737 bfd_seek (abfd
, isize
, SEEK_SET
);
4738 bfd_bwrite (&pad
, ishort
, abfd
);
4742 return _bfd_elf_close_and_cleanup (abfd
);
4745 /* Add symbols from an ELF object file to the linker hash table. */
4748 elf64_vms_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
4750 Elf_Internal_Shdr
*hdr
;
4751 bfd_size_type symcount
;
4752 bfd_size_type extsymcount
;
4753 bfd_size_type extsymoff
;
4754 struct elf_link_hash_entry
**sym_hash
;
4755 bfd_boolean dynamic
;
4756 Elf_Internal_Sym
*isymbuf
= NULL
;
4757 Elf_Internal_Sym
*isym
;
4758 Elf_Internal_Sym
*isymend
;
4759 const struct elf_backend_data
*bed
;
4760 struct elf_link_hash_table
*htab
;
4763 htab
= elf_hash_table (info
);
4764 bed
= get_elf_backend_data (abfd
);
4766 if ((abfd
->flags
& DYNAMIC
) == 0)
4772 /* You can't use -r against a dynamic object. Also, there's no
4773 hope of using a dynamic object which does not exactly match
4774 the format of the output file. */
4775 if (bfd_link_relocatable (info
)
4776 || !is_elf_hash_table (htab
)
4777 || info
->output_bfd
->xvec
!= abfd
->xvec
)
4779 if (bfd_link_relocatable (info
))
4780 bfd_set_error (bfd_error_invalid_operation
);
4782 bfd_set_error (bfd_error_wrong_format
);
4789 /* If we are creating a shared library, create all the dynamic
4790 sections immediately. We need to attach them to something,
4791 so we attach them to this BFD, provided it is the right
4792 format. FIXME: If there are no input BFD's of the same
4793 format as the output, we can't make a shared library. */
4794 if (bfd_link_pic (info
)
4795 && is_elf_hash_table (htab
)
4796 && info
->output_bfd
->xvec
== abfd
->xvec
4797 && !htab
->dynamic_sections_created
)
4799 if (! elf64_ia64_create_dynamic_sections (abfd
, info
))
4803 else if (!is_elf_hash_table (htab
))
4811 /* ld --just-symbols and dynamic objects don't mix very well.
4812 ld shouldn't allow it. */
4813 if ((s
= abfd
->sections
) != NULL
4814 && s
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
4817 /* Be sure there are dynamic sections. */
4818 if (! elf64_ia64_create_dynamic_sections (htab
->dynobj
, info
))
4821 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4824 /* VMS libraries do not have dynamic sections. Create one from
4826 Elf_Internal_Phdr
*phdr
;
4827 unsigned int i
, phnum
;
4829 phdr
= elf_tdata (abfd
)->phdr
;
4832 phnum
= elf_elfheader (abfd
)->e_phnum
;
4833 for (i
= 0; i
< phnum
; phdr
++)
4834 if (phdr
->p_type
== PT_DYNAMIC
)
4836 s
= bfd_make_section (abfd
, ".dynamic");
4839 s
->vma
= phdr
->p_vaddr
;
4840 s
->lma
= phdr
->p_paddr
;
4841 s
->size
= phdr
->p_filesz
;
4842 s
->filepos
= phdr
->p_offset
;
4843 s
->flags
|= SEC_HAS_CONTENTS
;
4844 s
->alignment_power
= bfd_log2 (phdr
->p_align
);
4851 /* Extract IDENT. */
4852 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
4859 for (extdyn
= dynbuf
;
4860 extdyn
< dynbuf
+ s
->size
;
4861 extdyn
+= bed
->s
->sizeof_dyn
)
4863 Elf_Internal_Dyn dyn
;
4865 bed
->s
->swap_dyn_in (abfd
, extdyn
, &dyn
);
4866 if (dyn
.d_tag
== DT_IA_64_VMS_IDENT
)
4868 bfd_uint64_t tagv
= dyn
.d_un
.d_val
;
4869 elf_ia64_vms_ident (abfd
) = tagv
;
4873 if (extdyn
>= dynbuf
+ s
->size
)
4875 /* Ident not found. */
4876 goto error_free_dyn
;
4880 /* We do not want to include any of the sections in a dynamic
4881 object in the output file. We hack by simply clobbering the
4882 list of sections in the BFD. This could be handled more
4883 cleanly by, say, a new section flag; the existing
4884 SEC_NEVER_LOAD flag is not the one we want, because that one
4885 still implies that the section takes up space in the output
4887 bfd_section_list_clear (abfd
);
4889 /* FIXME: should we detect if this library is already included ?
4890 This should be harmless and shouldn't happen in practice. */
4893 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4894 symcount
= hdr
->sh_size
/ bed
->s
->sizeof_sym
;
4896 /* The sh_info field of the symtab header tells us where the
4897 external symbols start. We don't care about the local symbols at
4899 extsymcount
= symcount
- hdr
->sh_info
;
4900 extsymoff
= hdr
->sh_info
;
4903 if (extsymcount
!= 0)
4905 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, extsymcount
, extsymoff
,
4907 if (isymbuf
== NULL
)
4910 /* We store a pointer to the hash table entry for each external
4912 amt
= extsymcount
* sizeof (struct elf_link_hash_entry
*);
4913 sym_hash
= (struct elf_link_hash_entry
**) bfd_alloc (abfd
, amt
);
4914 if (sym_hash
== NULL
)
4915 goto error_free_sym
;
4916 elf_sym_hashes (abfd
) = sym_hash
;
4919 for (isym
= isymbuf
, isymend
= isymbuf
+ extsymcount
;
4925 asection
*sec
, *new_sec
;
4928 struct elf_link_hash_entry
*h
;
4929 bfd_boolean definition
;
4930 bfd_boolean size_change_ok
;
4931 bfd_boolean type_change_ok
;
4933 unsigned int old_alignment
;
4936 flags
= BSF_NO_FLAGS
;
4938 value
= isym
->st_value
;
4940 common
= bed
->common_definition (isym
);
4942 bind
= ELF_ST_BIND (isym
->st_info
);
4946 /* This should be impossible, since ELF requires that all
4947 global symbols follow all local symbols, and that sh_info
4948 point to the first global symbol. Unfortunately, Irix 5
4953 if (isym
->st_shndx
!= SHN_UNDEF
&& !common
)
4961 case STB_GNU_UNIQUE
:
4962 flags
= BSF_GNU_UNIQUE
;
4966 /* Leave it up to the processor backend. */
4970 if (isym
->st_shndx
== SHN_UNDEF
)
4971 sec
= bfd_und_section_ptr
;
4972 else if (isym
->st_shndx
== SHN_ABS
)
4973 sec
= bfd_abs_section_ptr
;
4974 else if (isym
->st_shndx
== SHN_COMMON
)
4976 sec
= bfd_com_section_ptr
;
4977 /* What ELF calls the size we call the value. What ELF
4978 calls the value we call the alignment. */
4979 value
= isym
->st_size
;
4983 sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
4985 sec
= bfd_abs_section_ptr
;
4986 else if (sec
->kept_section
)
4988 /* Symbols from discarded section are undefined. We keep
4990 sec
= bfd_und_section_ptr
;
4991 isym
->st_shndx
= SHN_UNDEF
;
4993 else if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
4997 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
5000 goto error_free_vers
;
5002 if (bed
->elf_add_symbol_hook
)
5004 if (! (*bed
->elf_add_symbol_hook
) (abfd
, info
, isym
, &name
, &flags
,
5006 goto error_free_vers
;
5008 /* The hook function sets the name to NULL if this symbol
5009 should be skipped for some reason. */
5014 /* Sanity check that all possibilities were handled. */
5017 bfd_set_error (bfd_error_bad_value
);
5018 goto error_free_vers
;
5021 if (bfd_is_und_section (sec
)
5022 || bfd_is_com_section (sec
))
5027 size_change_ok
= FALSE
;
5028 type_change_ok
= bed
->type_change_ok
;
5033 if (! bfd_is_und_section (sec
))
5034 h
= elf_link_hash_lookup (htab
, name
, TRUE
, FALSE
, FALSE
);
5036 h
= ((struct elf_link_hash_entry
*) bfd_wrapped_link_hash_lookup
5037 (abfd
, info
, name
, TRUE
, FALSE
, FALSE
));
5039 goto error_free_sym
;
5043 if (is_elf_hash_table (htab
))
5045 while (h
->root
.type
== bfd_link_hash_indirect
5046 || h
->root
.type
== bfd_link_hash_warning
)
5047 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5049 /* Remember the old alignment if this is a common symbol, so
5050 that we don't reduce the alignment later on. We can't
5051 check later, because _bfd_generic_link_add_one_symbol
5052 will set a default for the alignment which we want to
5053 override. We also remember the old bfd where the existing
5054 definition comes from. */
5055 switch (h
->root
.type
)
5060 case bfd_link_hash_defined
:
5061 if (abfd
->selective_search
)
5064 case bfd_link_hash_defweak
:
5065 old_bfd
= h
->root
.u
.def
.section
->owner
;
5068 case bfd_link_hash_common
:
5069 old_bfd
= h
->root
.u
.c
.p
->section
->owner
;
5070 old_alignment
= h
->root
.u
.c
.p
->alignment_power
;
5075 if (! (_bfd_generic_link_add_one_symbol
5076 (info
, abfd
, name
, flags
, sec
, value
, NULL
, FALSE
, bed
->collect
,
5077 (struct bfd_link_hash_entry
**) sym_hash
)))
5078 goto error_free_vers
;
5081 while (h
->root
.type
== bfd_link_hash_indirect
5082 || h
->root
.type
== bfd_link_hash_warning
)
5083 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5087 h
->unique_global
= (flags
& BSF_GNU_UNIQUE
) != 0;
5089 /* Set the alignment of a common symbol. */
5090 if ((common
|| bfd_is_com_section (sec
))
5091 && h
->root
.type
== bfd_link_hash_common
)
5096 align
= bfd_log2 (isym
->st_value
);
5099 /* The new symbol is a common symbol in a shared object.
5100 We need to get the alignment from the section. */
5101 align
= new_sec
->alignment_power
;
5103 if (align
> old_alignment
5104 /* Permit an alignment power of zero if an alignment of one
5105 is specified and no other alignments have been specified. */
5106 || (isym
->st_value
== 1 && old_alignment
== 0))
5107 h
->root
.u
.c
.p
->alignment_power
= align
;
5109 h
->root
.u
.c
.p
->alignment_power
= old_alignment
;
5112 if (is_elf_hash_table (htab
))
5114 /* Check the alignment when a common symbol is involved. This
5115 can change when a common symbol is overridden by a normal
5116 definition or a common symbol is ignored due to the old
5117 normal definition. We need to make sure the maximum
5118 alignment is maintained. */
5119 if ((old_alignment
|| common
)
5120 && h
->root
.type
!= bfd_link_hash_common
)
5122 unsigned int common_align
;
5123 unsigned int normal_align
;
5124 unsigned int symbol_align
;
5128 symbol_align
= ffs (h
->root
.u
.def
.value
) - 1;
5129 if (h
->root
.u
.def
.section
->owner
!= NULL
5130 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
5132 normal_align
= h
->root
.u
.def
.section
->alignment_power
;
5133 if (normal_align
> symbol_align
)
5134 normal_align
= symbol_align
;
5137 normal_align
= symbol_align
;
5141 common_align
= old_alignment
;
5142 common_bfd
= old_bfd
;
5147 common_align
= bfd_log2 (isym
->st_value
);
5149 normal_bfd
= old_bfd
;
5152 if (normal_align
< common_align
)
5154 /* PR binutils/2735 */
5155 if (normal_bfd
== NULL
)
5157 /* xgettext:c-format */
5158 (_("warning: alignment %u of common symbol `%s' in %pB"
5159 " is greater than the alignment (%u) of its section %pA"),
5160 1 << common_align
, name
, common_bfd
,
5161 1 << normal_align
, h
->root
.u
.def
.section
);
5164 /* xgettext:c-format */
5165 (_("warning: alignment %u of symbol `%s' in %pB"
5166 " is smaller than %u in %pB"),
5167 1 << normal_align
, name
, normal_bfd
,
5168 1 << common_align
, common_bfd
);
5172 /* Remember the symbol size if it isn't undefined. */
5173 if ((isym
->st_size
!= 0 && isym
->st_shndx
!= SHN_UNDEF
)
5174 && (definition
|| h
->size
== 0))
5177 && h
->size
!= isym
->st_size
5178 && ! size_change_ok
)
5180 /* xgettext:c-format */
5181 (_("warning: size of symbol `%s' changed"
5182 " from %" PRIu64
" in %pB to %" PRIu64
" in %pB"),
5183 name
, (uint64_t) h
->size
, old_bfd
,
5184 (uint64_t) isym
->st_size
, abfd
);
5186 h
->size
= isym
->st_size
;
5189 /* If this is a common symbol, then we always want H->SIZE
5190 to be the size of the common symbol. The code just above
5191 won't fix the size if a common symbol becomes larger. We
5192 don't warn about a size change here, because that is
5193 covered by --warn-common. Allow changed between different
5195 if (h
->root
.type
== bfd_link_hash_common
)
5196 h
->size
= h
->root
.u
.c
.size
;
5198 if (ELF_ST_TYPE (isym
->st_info
) != STT_NOTYPE
5199 && (definition
|| h
->type
== STT_NOTYPE
))
5201 unsigned int type
= ELF_ST_TYPE (isym
->st_info
);
5203 if (h
->type
!= type
)
5205 if (h
->type
!= STT_NOTYPE
&& ! type_change_ok
)
5207 /* xgettext:c-format */
5208 (_("warning: type of symbol `%s' changed"
5209 " from %d to %d in %pB"),
5210 name
, h
->type
, type
, abfd
);
5216 /* Set a flag in the hash table entry indicating the type of
5217 reference or definition we just found. Keep a count of
5218 the number of dynamic symbols we find. A dynamic symbol
5219 is one which is referenced or defined by both a regular
5220 object and a shared object. */
5226 if (bind
!= STB_WEAK
)
5227 h
->ref_regular_nonweak
= 1;
5231 BFD_ASSERT (!h
->def_dynamic
);
5237 BFD_ASSERT (definition
);
5240 ((struct elf64_ia64_link_hash_entry
*)h
)->shl
= abfd
;
5245 if (isymbuf
!= NULL
)
5251 /* If this object is the same format as the output object, and it is
5252 not a shared library, then let the backend look through the
5255 This is required to build global offset table entries and to
5256 arrange for dynamic relocs. It is not required for the
5257 particular common case of linking non PIC code, even when linking
5258 against shared libraries, but unfortunately there is no way of
5259 knowing whether an object file has been compiled PIC or not.
5260 Looking through the relocs is not particularly time consuming.
5261 The problem is that we must either (1) keep the relocs in memory,
5262 which causes the linker to require additional runtime memory or
5263 (2) read the relocs twice from the input file, which wastes time.
5264 This would be a good case for using mmap.
5266 I have no idea how to handle linking PIC code into a file of a
5267 different format. It probably can't be done. */
5269 && is_elf_hash_table (htab
)
5270 && bed
->check_relocs
!= NULL
5271 && (*bed
->relocs_compatible
) (abfd
->xvec
, info
->output_bfd
->xvec
))
5275 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5277 Elf_Internal_Rela
*internal_relocs
;
5280 if ((o
->flags
& SEC_RELOC
) == 0
5281 || o
->reloc_count
== 0
5282 || ((info
->strip
== strip_all
|| info
->strip
== strip_debugger
)
5283 && (o
->flags
& SEC_DEBUGGING
) != 0)
5284 || bfd_is_abs_section (o
->output_section
))
5287 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
5289 if (internal_relocs
== NULL
)
5292 ok
= (*bed
->check_relocs
) (abfd
, info
, o
, internal_relocs
);
5294 if (elf_section_data (o
)->relocs
!= internal_relocs
)
5295 free (internal_relocs
);
5306 if (isymbuf
!= NULL
)
5313 elf64_vms_link_add_archive_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
5316 struct bfd_link_hash_entry
**pundef
;
5317 struct bfd_link_hash_entry
**next_pundef
;
5319 /* We only accept VMS libraries. */
5320 if (info
->output_bfd
->xvec
!= abfd
->xvec
)
5322 bfd_set_error (bfd_error_wrong_format
);
5326 /* The archive_pass field in the archive itself is used to
5327 initialize PASS, since we may search the same archive multiple
5329 pass
= ++abfd
->archive_pass
;
5331 /* Look through the list of undefined symbols. */
5332 for (pundef
= &info
->hash
->undefs
; *pundef
!= NULL
; pundef
= next_pundef
)
5334 struct bfd_link_hash_entry
*h
;
5340 next_pundef
= &(*pundef
)->u
.undef
.next
;
5342 /* When a symbol is defined, it is not necessarily removed from
5344 if (h
->type
!= bfd_link_hash_undefined
5345 && h
->type
!= bfd_link_hash_common
)
5347 /* Remove this entry from the list, for general cleanliness
5348 and because we are going to look through the list again
5349 if we search any more libraries. We can't remove the
5350 entry if it is the tail, because that would lose any
5351 entries we add to the list later on. */
5352 if (*pundef
!= info
->hash
->undefs_tail
)
5354 *pundef
= *next_pundef
;
5355 next_pundef
= pundef
;
5360 /* Look for this symbol in the archive hash table. */
5361 symidx
= _bfd_vms_lib_find_symbol (abfd
, h
->root
.string
);
5362 if (symidx
== BFD_NO_MORE_SYMBOLS
)
5364 /* Nothing in this slot. */
5368 element
= bfd_get_elt_at_index (abfd
, symidx
);
5369 if (element
== NULL
)
5372 if (element
->archive_pass
== -1 || element
->archive_pass
== pass
)
5374 /* Next symbol if this archive is wrong or already handled. */
5378 orig_element
= element
;
5379 if (bfd_is_thin_archive (abfd
))
5381 element
= _bfd_vms_lib_get_imagelib_file (element
);
5382 if (element
== NULL
|| !bfd_check_format (element
, bfd_object
))
5384 orig_element
->archive_pass
= -1;
5388 else if (! bfd_check_format (element
, bfd_object
))
5390 element
->archive_pass
= -1;
5394 /* Unlike the generic linker, we know that this element provides
5395 a definition for an undefined symbol and we know that we want
5396 to include it. We don't need to check anything. */
5397 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
5398 h
->root
.string
, &element
))
5400 if (! elf64_vms_link_add_object_symbols (element
, info
))
5403 orig_element
->archive_pass
= pass
;
5410 elf64_vms_bfd_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
5412 switch (bfd_get_format (abfd
))
5415 return elf64_vms_link_add_object_symbols (abfd
, info
);
5418 return elf64_vms_link_add_archive_symbols (abfd
, info
);
5421 bfd_set_error (bfd_error_wrong_format
);
5427 elf64_ia64_vms_mkobject (bfd
*abfd
)
5429 return bfd_elf_allocate_object
5430 (abfd
, sizeof (struct elf64_ia64_vms_obj_tdata
), IA64_ELF_DATA
);
5434 /* Size-dependent data and functions. */
5435 static const struct elf_size_info elf64_ia64_vms_size_info
= {
5436 sizeof (Elf64_External_VMS_Ehdr
),
5437 sizeof (Elf64_External_Phdr
),
5438 sizeof (Elf64_External_Shdr
),
5439 sizeof (Elf64_External_Rel
),
5440 sizeof (Elf64_External_Rela
),
5441 sizeof (Elf64_External_Sym
),
5442 sizeof (Elf64_External_Dyn
),
5443 sizeof (Elf_External_Note
),
5446 64, 3, /* ARCH_SIZE, LOG_FILE_ALIGN */
5447 ELFCLASS64
, EV_CURRENT
,
5448 bfd_elf64_write_out_phdrs
,
5449 elf64_vms_write_shdrs_and_ehdr
,
5450 bfd_elf64_checksum_contents
,
5451 bfd_elf64_write_relocs
,
5452 bfd_elf64_swap_symbol_in
,
5453 bfd_elf64_swap_symbol_out
,
5454 bfd_elf64_slurp_reloc_table
,
5455 bfd_elf64_slurp_symbol_table
,
5456 bfd_elf64_swap_dyn_in
,
5457 bfd_elf64_swap_dyn_out
,
5458 bfd_elf64_swap_reloc_in
,
5459 bfd_elf64_swap_reloc_out
,
5460 bfd_elf64_swap_reloca_in
,
5461 bfd_elf64_swap_reloca_out
5464 #define ELF_ARCH bfd_arch_ia64
5465 #define ELF_MACHINE_CODE EM_IA_64
5466 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
5467 #define ELF_COMMONPAGESIZE 0x200 /* 16KB */
5469 #define elf_backend_section_from_shdr \
5470 elf64_ia64_section_from_shdr
5471 #define elf_backend_section_flags \
5472 elf64_ia64_section_flags
5473 #define elf_backend_fake_sections \
5474 elf64_ia64_fake_sections
5475 #define elf_backend_final_write_processing \
5476 elf64_ia64_final_write_processing
5477 #define elf_backend_add_symbol_hook \
5478 elf64_ia64_add_symbol_hook
5479 #define elf_info_to_howto \
5480 elf64_ia64_info_to_howto
5482 #define bfd_elf64_bfd_reloc_type_lookup \
5483 ia64_elf_reloc_type_lookup
5484 #define bfd_elf64_bfd_reloc_name_lookup \
5485 ia64_elf_reloc_name_lookup
5486 #define bfd_elf64_bfd_is_local_label_name \
5487 elf64_ia64_is_local_label_name
5488 #define bfd_elf64_bfd_relax_section \
5489 elf64_ia64_relax_section
5491 #define elf_backend_object_p \
5494 /* Stuff for the BFD linker: */
5495 #define bfd_elf64_bfd_link_hash_table_create \
5496 elf64_ia64_hash_table_create
5497 #define elf_backend_create_dynamic_sections \
5498 elf64_ia64_create_dynamic_sections
5499 #define elf_backend_check_relocs \
5500 elf64_ia64_check_relocs
5501 #define elf_backend_adjust_dynamic_symbol \
5502 elf64_ia64_adjust_dynamic_symbol
5503 #define elf_backend_size_dynamic_sections \
5504 elf64_ia64_size_dynamic_sections
5505 #define elf_backend_omit_section_dynsym \
5506 _bfd_elf_omit_section_dynsym_all
5507 #define elf_backend_relocate_section \
5508 elf64_ia64_relocate_section
5509 #define elf_backend_finish_dynamic_symbol \
5510 elf64_ia64_finish_dynamic_symbol
5511 #define elf_backend_finish_dynamic_sections \
5512 elf64_ia64_finish_dynamic_sections
5513 #define bfd_elf64_bfd_final_link \
5514 elf64_ia64_final_link
5516 #define bfd_elf64_bfd_merge_private_bfd_data \
5517 elf64_ia64_merge_private_bfd_data
5518 #define bfd_elf64_bfd_set_private_flags \
5519 elf64_ia64_set_private_flags
5520 #define bfd_elf64_bfd_print_private_bfd_data \
5521 elf64_ia64_print_private_bfd_data
5523 #define elf_backend_plt_readonly 1
5524 #define elf_backend_want_plt_sym 0
5525 #define elf_backend_plt_alignment 5
5526 #define elf_backend_got_header_size 0
5527 #define elf_backend_want_got_plt 1
5528 #define elf_backend_may_use_rel_p 1
5529 #define elf_backend_may_use_rela_p 1
5530 #define elf_backend_default_use_rela_p 1
5531 #define elf_backend_want_dynbss 0
5532 #define elf_backend_hide_symbol elf64_ia64_hash_hide_symbol
5533 #define elf_backend_fixup_symbol _bfd_elf_link_hash_fixup_symbol
5534 #define elf_backend_reloc_type_class elf64_ia64_reloc_type_class
5535 #define elf_backend_rela_normal 1
5536 #define elf_backend_special_sections elf64_ia64_special_sections
5537 #define elf_backend_default_execstack 0
5539 /* FIXME: PR 290: The Intel C compiler generates SHT_IA_64_UNWIND with
5540 SHF_LINK_ORDER. But it doesn't set the sh_link or sh_info fields.
5541 We don't want to flood users with so many error messages. We turn
5542 off the warning for now. It will be turned on later when the Intel
5543 compiler is fixed. */
5544 #define elf_backend_link_order_error_handler NULL
5546 /* VMS-specific vectors. */
5548 #undef TARGET_LITTLE_SYM
5549 #define TARGET_LITTLE_SYM ia64_elf64_vms_vec
5550 #undef TARGET_LITTLE_NAME
5551 #define TARGET_LITTLE_NAME "elf64-ia64-vms"
5552 #undef TARGET_BIG_SYM
5553 #undef TARGET_BIG_NAME
5555 /* These are VMS specific functions. */
5557 #undef elf_backend_object_p
5558 #define elf_backend_object_p elf64_vms_object_p
5560 #undef elf_backend_section_from_shdr
5561 #define elf_backend_section_from_shdr elf64_vms_section_from_shdr
5563 #undef elf_backend_init_file_header
5564 #define elf_backend_init_file_header elf64_vms_init_file_header
5566 #undef elf_backend_section_processing
5567 #define elf_backend_section_processing elf64_vms_section_processing
5569 #undef elf_backend_final_write_processing
5570 #define elf_backend_final_write_processing elf64_vms_final_write_processing
5572 #undef bfd_elf64_close_and_cleanup
5573 #define bfd_elf64_close_and_cleanup elf64_vms_close_and_cleanup
5575 #undef elf_backend_section_from_bfd_section
5577 #undef elf_backend_symbol_processing
5579 #undef elf_backend_want_p_paddr_set_to_zero
5582 #define ELF_OSABI ELFOSABI_OPENVMS
5584 #undef ELF_MAXPAGESIZE
5585 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
5588 #define elf64_bed elf64_ia64_vms_bed
5590 #define elf_backend_size_info elf64_ia64_vms_size_info
5592 /* Use VMS-style archives (in particular, don't use the standard coff
5594 #define bfd_elf64_archive_functions
5596 #undef bfd_elf64_archive_p
5597 #define bfd_elf64_archive_p _bfd_vms_lib_ia64_archive_p
5598 #undef bfd_elf64_write_archive_contents
5599 #define bfd_elf64_write_archive_contents _bfd_vms_lib_write_archive_contents
5600 #undef bfd_elf64_mkarchive
5601 #define bfd_elf64_mkarchive _bfd_vms_lib_ia64_mkarchive
5603 #define bfd_elf64_archive_slurp_armap \
5604 _bfd_vms_lib_slurp_armap
5605 #define bfd_elf64_archive_slurp_extended_name_table \
5606 _bfd_vms_lib_slurp_extended_name_table
5607 #define bfd_elf64_archive_construct_extended_name_table \
5608 _bfd_vms_lib_construct_extended_name_table
5609 #define bfd_elf64_archive_truncate_arname \
5610 _bfd_vms_lib_truncate_arname
5611 #define bfd_elf64_archive_write_armap \
5612 _bfd_vms_lib_write_armap
5613 #define bfd_elf64_archive_read_ar_hdr \
5614 _bfd_vms_lib_read_ar_hdr
5615 #define bfd_elf64_archive_write_ar_hdr \
5616 _bfd_vms_lib_write_ar_hdr
5617 #define bfd_elf64_archive_openr_next_archived_file \
5618 _bfd_vms_lib_openr_next_archived_file
5619 #define bfd_elf64_archive_get_elt_at_index \
5620 _bfd_vms_lib_get_elt_at_index
5621 #define bfd_elf64_archive_generic_stat_arch_elt \
5622 _bfd_vms_lib_generic_stat_arch_elt
5623 #define bfd_elf64_archive_update_armap_timestamp \
5624 _bfd_vms_lib_update_armap_timestamp
5626 /* VMS link methods. */
5627 #undef bfd_elf64_bfd_link_add_symbols
5628 #define bfd_elf64_bfd_link_add_symbols elf64_vms_bfd_link_add_symbols
5630 #undef elf_backend_want_got_sym
5631 #define elf_backend_want_got_sym 0
5633 #undef bfd_elf64_mkobject
5634 #define bfd_elf64_mkobject elf64_ia64_vms_mkobject
5636 /* Redefine to align segments on block size. */
5637 #undef ELF_MAXPAGESIZE
5638 #define ELF_MAXPAGESIZE 0x200 /* 512B */
5640 #undef elf_backend_want_got_plt
5641 #define elf_backend_want_got_plt 0
5643 #include "elf64-target.h"