1 /* IA-64 support for OpenVMS
2 Copyright (C) 1998-2024 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 ((is_elf_hash_table ((p)->hash) \
174 && elf_hash_table_id (elf_hash_table (p)) == IA64_ELF_DATA) \
175 ? (struct elf64_ia64_link_hash_table *) (p)->hash : NULL)
177 struct elf64_ia64_vms_obj_tdata
179 struct elf_obj_tdata root
;
181 /* Ident for shared library. */
184 /* Used only during link: offset in the .fixups section for this bfd. */
187 /* Max number of shared libraries. */
188 unsigned int needed_count
;
191 #define elf_ia64_vms_tdata(abfd) \
192 ((struct elf64_ia64_vms_obj_tdata *)((abfd)->tdata.any))
193 #define elf_ia64_vms_ident(abfd) (elf_ia64_vms_tdata(abfd)->ident)
195 struct elf64_vms_transfer
197 unsigned char size
[4];
198 unsigned char spare
[4];
199 unsigned char tfradr1
[8];
200 unsigned char tfradr2
[8];
201 unsigned char tfradr3
[8];
202 unsigned char tfradr4
[8];
203 unsigned char tfradr5
[8];
205 /* Local function descriptor for tfr3. */
206 unsigned char tfr3_func
[8];
207 unsigned char tfr3_gp
[8];
212 Elf64_External_Ehdr ehdr
;
213 unsigned char vms_needed_count
[8];
214 } Elf64_External_VMS_Ehdr
;
216 static struct elf64_ia64_dyn_sym_info
* get_dyn_sym_info
217 (struct elf64_ia64_link_hash_table
*,
218 struct elf_link_hash_entry
*,
219 bfd
*, const Elf_Internal_Rela
*, bool);
220 static bool elf64_ia64_dynamic_symbol_p
221 (struct elf_link_hash_entry
*);
222 static bool elf64_ia64_choose_gp
223 (bfd
*, struct bfd_link_info
*, bool);
224 static void elf64_ia64_dyn_sym_traverse
225 (struct elf64_ia64_link_hash_table
*,
226 bool (*) (struct elf64_ia64_dyn_sym_info
*, void *),
228 static bool allocate_global_data_got
229 (struct elf64_ia64_dyn_sym_info
*, void *);
230 static bool allocate_global_fptr_got
231 (struct elf64_ia64_dyn_sym_info
*, void *);
232 static bool allocate_local_got
233 (struct elf64_ia64_dyn_sym_info
*, void *);
234 static bool allocate_dynrel_entries
235 (struct elf64_ia64_dyn_sym_info
*, void *);
236 static asection
*get_pltoff
237 (bfd
*, struct elf64_ia64_link_hash_table
*);
238 static asection
*get_got
239 (bfd
*, struct elf64_ia64_link_hash_table
*);
242 /* Given a ELF reloc, return the matching HOWTO structure. */
245 elf64_ia64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
247 Elf_Internal_Rela
*elf_reloc
)
249 unsigned int r_type
= ELF32_R_TYPE (elf_reloc
->r_info
);
251 bfd_reloc
->howto
= ia64_elf_lookup_howto (r_type
);
252 if (bfd_reloc
->howto
== NULL
)
254 /* xgettext:c-format */
255 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
257 bfd_set_error (bfd_error_bad_value
);
265 #define PLT_FULL_ENTRY_SIZE (2 * 16)
267 static const bfd_byte plt_full_entry
[PLT_FULL_ENTRY_SIZE
] =
269 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
270 0x00, 0x41, 0x3c, 0x70, 0x29, 0xc0, /* ld8.acq r16=[r15],8*/
271 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
272 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
273 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
274 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
277 static const bfd_byte oor_brl
[16] =
279 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
280 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;;*/
281 0x00, 0x00, 0x00, 0xc0
285 /* These functions do relaxation for IA-64 ELF. */
287 /* Rename some of the generic section flags to better document how they
289 #define skip_relax_pass_0 sec_flg0
290 #define skip_relax_pass_1 sec_flg1
293 elf64_ia64_update_short_info (asection
*sec
, bfd_vma offset
,
294 struct elf64_ia64_link_hash_table
*ia64_info
)
296 /* Skip ABS and SHF_IA_64_SHORT sections. */
297 if (sec
== bfd_abs_section_ptr
298 || (sec
->flags
& SEC_SMALL_DATA
) != 0)
301 if (!ia64_info
->min_short_sec
)
303 ia64_info
->max_short_sec
= sec
;
304 ia64_info
->max_short_offset
= offset
;
305 ia64_info
->min_short_sec
= sec
;
306 ia64_info
->min_short_offset
= offset
;
308 else if (sec
== ia64_info
->max_short_sec
309 && offset
> ia64_info
->max_short_offset
)
310 ia64_info
->max_short_offset
= offset
;
311 else if (sec
== ia64_info
->min_short_sec
312 && offset
< ia64_info
->min_short_offset
)
313 ia64_info
->min_short_offset
= offset
;
314 else if (sec
->output_section
->vma
315 > ia64_info
->max_short_sec
->vma
)
317 ia64_info
->max_short_sec
= sec
;
318 ia64_info
->max_short_offset
= offset
;
320 else if (sec
->output_section
->vma
321 < ia64_info
->min_short_sec
->vma
)
323 ia64_info
->min_short_sec
= sec
;
324 ia64_info
->min_short_offset
= offset
;
328 /* Use a two passes algorithm. In the first pass, branches are relaxed
329 (which may increase the size of the section). In the second pass,
330 the other relaxations are done.
334 elf64_ia64_relax_section (bfd
*abfd
, asection
*sec
,
335 struct bfd_link_info
*link_info
,
340 struct one_fixup
*next
;
346 Elf_Internal_Shdr
*symtab_hdr
;
347 Elf_Internal_Rela
*internal_relocs
;
348 Elf_Internal_Rela
*irel
, *irelend
;
350 Elf_Internal_Sym
*isymbuf
= NULL
;
351 struct elf64_ia64_link_hash_table
*ia64_info
;
352 struct one_fixup
*fixups
= NULL
;
353 bool changed_contents
= false;
354 bool changed_relocs
= false;
355 bool skip_relax_pass_0
= true;
356 bool skip_relax_pass_1
= true;
359 /* Assume we're not going to change any sizes, and we'll only need
363 if (bfd_link_relocatable (link_info
))
364 (*link_info
->callbacks
->einfo
)
365 (_("%P%F: --relax and -r may not be used together\n"));
367 /* Don't even try to relax for non-ELF outputs. */
368 if (!is_elf_hash_table (link_info
->hash
))
371 /* Nothing to do if there are no relocations or there is no need for
373 if (sec
->reloc_count
== 0
374 || (sec
->flags
& SEC_RELOC
) == 0
375 || (sec
->flags
& SEC_HAS_CONTENTS
) == 0
376 || (link_info
->relax_pass
== 0 && sec
->skip_relax_pass_0
)
377 || (link_info
->relax_pass
== 1 && sec
->skip_relax_pass_1
))
380 ia64_info
= elf64_ia64_hash_table (link_info
);
381 if (ia64_info
== NULL
)
384 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
386 /* Load the relocations for this section. */
387 internal_relocs
= (_bfd_elf_link_read_relocs
388 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
389 link_info
->keep_memory
));
390 if (internal_relocs
== NULL
)
393 irelend
= internal_relocs
+ sec
->reloc_count
;
395 /* Get the section contents. */
396 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
397 contents
= elf_section_data (sec
)->this_hdr
.contents
;
400 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
404 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
406 unsigned long r_type
= ELF64_R_TYPE (irel
->r_info
);
407 bfd_vma symaddr
, reladdr
, trampoff
, toff
, roff
;
412 struct elf64_ia64_dyn_sym_info
*dyn_i
;
416 case R_IA64_PCREL21B
:
417 case R_IA64_PCREL21BI
:
418 case R_IA64_PCREL21M
:
419 case R_IA64_PCREL21F
:
420 /* In pass 1, all br relaxations are done. We can skip it. */
421 if (link_info
->relax_pass
== 1)
423 skip_relax_pass_0
= false;
427 case R_IA64_PCREL60B
:
428 /* We can't optimize brl to br in pass 0 since br relaxations
429 will increase the code size. Defer it to pass 1. */
430 if (link_info
->relax_pass
== 0)
432 skip_relax_pass_1
= false;
439 /* Update max_short_sec/min_short_sec. */
441 case R_IA64_LTOFF22X
:
443 /* We can't relax ldx/mov in pass 0 since br relaxations will
444 increase the code size. Defer it to pass 1. */
445 if (link_info
->relax_pass
== 0)
447 skip_relax_pass_1
= false;
457 /* Get the value of the symbol referred to by the reloc. */
458 if (ELF64_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
460 /* A local symbol. */
461 Elf_Internal_Sym
*isym
;
463 /* Read this BFD's local symbols. */
466 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
468 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
469 symtab_hdr
->sh_info
, 0,
475 isym
= isymbuf
+ ELF64_R_SYM (irel
->r_info
);
476 if (isym
->st_shndx
== SHN_UNDEF
)
477 continue; /* We can't do anything with undefined symbols. */
478 else if (isym
->st_shndx
== SHN_ABS
)
479 tsec
= bfd_abs_section_ptr
;
480 else if (isym
->st_shndx
== SHN_COMMON
)
481 tsec
= bfd_com_section_ptr
;
482 else if (isym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
483 tsec
= bfd_com_section_ptr
;
485 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
487 toff
= isym
->st_value
;
488 dyn_i
= get_dyn_sym_info (ia64_info
, NULL
, abfd
, irel
, false);
493 struct elf_link_hash_entry
*h
;
495 indx
= ELF64_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
496 h
= elf_sym_hashes (abfd
)[indx
];
497 BFD_ASSERT (h
!= NULL
);
499 while (h
->root
.type
== bfd_link_hash_indirect
500 || h
->root
.type
== bfd_link_hash_warning
)
501 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
503 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, irel
, false);
505 /* For branches to dynamic symbols, we're interested instead
506 in a branch to the PLT entry. */
507 if (is_branch
&& dyn_i
&& dyn_i
->want_plt2
)
509 /* Internal branches shouldn't be sent to the PLT.
510 Leave this for now and we'll give an error later. */
511 if (r_type
!= R_IA64_PCREL21B
)
514 tsec
= ia64_info
->root
.splt
;
515 toff
= dyn_i
->plt2_offset
;
516 BFD_ASSERT (irel
->r_addend
== 0);
519 /* Can't do anything else with dynamic symbols. */
520 else if (elf64_ia64_dynamic_symbol_p (h
))
525 /* We can't do anything with undefined symbols. */
526 if (h
->root
.type
== bfd_link_hash_undefined
527 || h
->root
.type
== bfd_link_hash_undefweak
)
530 tsec
= h
->root
.u
.def
.section
;
531 toff
= h
->root
.u
.def
.value
;
535 toff
+= irel
->r_addend
;
537 symaddr
= tsec
->output_section
->vma
+ tsec
->output_offset
+ toff
;
539 roff
= irel
->r_offset
;
543 bfd_signed_vma offset
;
545 reladdr
= (sec
->output_section
->vma
547 + roff
) & (bfd_vma
) -4;
549 /* The .plt section is aligned at 32byte and the .text section
550 is aligned at 64byte. The .text section is right after the
551 .plt section. After the first relaxation pass, linker may
552 increase the gap between the .plt and .text sections up
553 to 32byte. We assume linker will always insert 32byte
554 between the .plt and .text sections after the first
556 if (tsec
== ia64_info
->root
.splt
)
557 offset
= -0x1000000 + 32;
561 /* If the branch is in range, no need to do anything. */
562 if ((bfd_signed_vma
) (symaddr
- reladdr
) >= offset
563 && (bfd_signed_vma
) (symaddr
- reladdr
) <= 0x0FFFFF0)
565 /* If the 60-bit branch is in 21-bit range, optimize it. */
566 if (r_type
== R_IA64_PCREL60B
)
568 ia64_elf_relax_brl (contents
, roff
);
570 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
573 /* If the original relocation offset points to slot
574 1, change it to slot 2. */
575 if ((irel
->r_offset
& 3) == 1)
581 else if (r_type
== R_IA64_PCREL60B
)
583 else if (ia64_elf_relax_br (contents
, roff
))
585 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
588 /* Make the relocation offset point to slot 1. */
589 irel
->r_offset
= (irel
->r_offset
& ~((bfd_vma
) 0x3)) + 1;
593 /* We can't put a trampoline in a .init/.fini section. Issue
595 if (strcmp (sec
->output_section
->name
, ".init") == 0
596 || strcmp (sec
->output_section
->name
, ".fini") == 0)
599 /* xgettext:c-format */
600 (_("%pB: can't relax br at %#" PRIx64
" in section `%pA';"
601 " please use brl or indirect branch"),
602 sec
->owner
, (uint64_t) roff
, sec
);
603 bfd_set_error (bfd_error_bad_value
);
607 /* If the branch and target are in the same section, you've
608 got one honking big section and we can't help you unless
609 you are branching backwards. You'll get an error message
611 if (tsec
== sec
&& toff
> roff
)
614 /* Look for an existing fixup to this address. */
615 for (f
= fixups
; f
; f
= f
->next
)
616 if (f
->tsec
== tsec
&& f
->toff
== toff
)
621 /* Two alternatives: If it's a branch to a PLT entry, we can
622 make a copy of the FULL_PLT entry. Otherwise, we'll have
623 to use a `brl' insn to get where we're going. */
627 if (tsec
== ia64_info
->root
.splt
)
628 size
= sizeof (plt_full_entry
);
630 size
= sizeof (oor_brl
);
632 /* Resize the current section to make room for the new branch. */
633 trampoff
= (sec
->size
+ 15) & (bfd_vma
) -16;
635 /* If trampoline is out of range, there is nothing we
637 offset
= trampoff
- (roff
& (bfd_vma
) -4);
638 if (offset
< -0x1000000 || offset
> 0x0FFFFF0)
641 amt
= trampoff
+ size
;
642 contents
= (bfd_byte
*) bfd_realloc (contents
, amt
);
643 if (contents
== NULL
)
647 if (tsec
== ia64_info
->root
.splt
)
649 memcpy (contents
+ trampoff
, plt_full_entry
, size
);
651 /* Hijack the old relocation for use as the PLTOFF reloc. */
652 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
654 irel
->r_offset
= trampoff
;
658 memcpy (contents
+ trampoff
, oor_brl
, size
);
659 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
661 irel
->r_offset
= trampoff
+ 2;
664 /* Record the fixup so we don't do it again this section. */
665 f
= (struct one_fixup
*)
666 bfd_malloc ((bfd_size_type
) sizeof (*f
));
670 f
->trampoff
= trampoff
;
675 /* If trampoline is out of range, there is nothing we
677 offset
= f
->trampoff
- (roff
& (bfd_vma
) -4);
678 if (offset
< -0x1000000 || offset
> 0x0FFFFF0)
681 /* Nop out the reloc, since we're finalizing things here. */
682 irel
->r_info
= ELF64_R_INFO (0, R_IA64_NONE
);
685 /* Fix up the existing branch to hit the trampoline. */
686 if (ia64_elf_install_value (contents
+ roff
, offset
, r_type
)
690 changed_contents
= true;
691 changed_relocs
= true;
698 bfd
*obfd
= sec
->output_section
->owner
;
699 gp
= _bfd_get_gp_value (obfd
);
702 if (!elf64_ia64_choose_gp (obfd
, link_info
, false))
704 gp
= _bfd_get_gp_value (obfd
);
708 /* If the data is out of range, do nothing. */
709 if ((bfd_signed_vma
) (symaddr
- gp
) >= 0x200000
710 ||(bfd_signed_vma
) (symaddr
- gp
) < -0x200000)
713 if (r_type
== R_IA64_GPREL22
)
714 elf64_ia64_update_short_info (tsec
->output_section
,
715 tsec
->output_offset
+ toff
,
717 else if (r_type
== R_IA64_LTOFF22X
)
719 /* Can't deal yet correctly with ABS symbols. */
720 if (bfd_is_abs_section (tsec
))
723 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
725 changed_relocs
= true;
727 elf64_ia64_update_short_info (tsec
->output_section
,
728 tsec
->output_offset
+ toff
,
733 ia64_elf_relax_ldxmov (contents
, roff
);
734 irel
->r_info
= ELF64_R_INFO (0, R_IA64_NONE
);
735 changed_contents
= true;
736 changed_relocs
= true;
741 /* ??? If we created fixups, this may push the code segment large
742 enough that the data segment moves, which will change the GP.
743 Reset the GP so that we re-calculate next round. We need to
744 do this at the _beginning_ of the next round; now will not do. */
746 /* Clean up and go home. */
749 struct one_fixup
*f
= fixups
;
750 fixups
= fixups
->next
;
755 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
757 if (! link_info
->keep_memory
)
761 /* Cache the symbols for elf_link_input_bfd. */
762 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
767 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
769 if (!changed_contents
&& !link_info
->keep_memory
)
773 /* Cache the section contents for elf_link_input_bfd. */
774 elf_section_data (sec
)->this_hdr
.contents
= contents
;
778 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
781 free (internal_relocs
);
783 elf_section_data (sec
)->relocs
= internal_relocs
;
786 if (link_info
->relax_pass
== 0)
788 /* Pass 0 is only needed to relax br. */
789 sec
->skip_relax_pass_0
= skip_relax_pass_0
;
790 sec
->skip_relax_pass_1
= skip_relax_pass_1
;
793 *again
= changed_contents
|| changed_relocs
;
797 if ((unsigned char *) isymbuf
!= symtab_hdr
->contents
)
799 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
801 if (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. */
811 is_unwind_section_name (bfd
*abfd ATTRIBUTE_UNUSED
, const char *name
)
813 return ((startswith (name
, ELF_STRING_ia64_unwind
)
814 && ! startswith (name
, ELF_STRING_ia64_unwind_info
))
815 || startswith (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",
887 | SEC_LINKER_CREATED
));
893 *valp
= sym
->st_size
;
899 /* According to the Tahoe assembler spec, all labels starting with a
903 elf64_ia64_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
906 return name
[0] == '.';
909 /* Should we do dynamic things to this symbol? */
912 elf64_ia64_dynamic_symbol_p (struct elf_link_hash_entry
*h
)
914 return h
!= NULL
&& h
->def_dynamic
;
917 static struct bfd_hash_entry
*
918 elf64_ia64_new_elf_hash_entry (struct bfd_hash_entry
*entry
,
919 struct bfd_hash_table
*table
,
922 struct elf64_ia64_link_hash_entry
*ret
;
923 ret
= (struct elf64_ia64_link_hash_entry
*) entry
;
925 /* Allocate the structure if it has not already been allocated by a
928 ret
= bfd_hash_allocate (table
, sizeof (*ret
));
933 /* Call the allocation method of the superclass. */
934 ret
= ((struct elf64_ia64_link_hash_entry
*)
935 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
940 ret
->sorted_count
= 0;
942 return (struct bfd_hash_entry
*) ret
;
946 elf64_ia64_hash_hide_symbol (struct bfd_link_info
*info
,
947 struct elf_link_hash_entry
*xh
,
950 struct elf64_ia64_link_hash_entry
*h
;
951 struct elf64_ia64_dyn_sym_info
*dyn_i
;
954 h
= (struct elf64_ia64_link_hash_entry
*)xh
;
956 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
958 for (count
= h
->count
, dyn_i
= h
->info
;
962 dyn_i
->want_plt2
= 0;
967 /* Compute a hash of a local hash entry. */
970 elf64_ia64_local_htab_hash (const void *ptr
)
972 struct elf64_ia64_local_hash_entry
*entry
973 = (struct elf64_ia64_local_hash_entry
*) ptr
;
975 return ELF_LOCAL_SYMBOL_HASH (entry
->id
, entry
->r_sym
);
978 /* Compare local hash entries. */
981 elf64_ia64_local_htab_eq (const void *ptr1
, const void *ptr2
)
983 struct elf64_ia64_local_hash_entry
*entry1
984 = (struct elf64_ia64_local_hash_entry
*) ptr1
;
985 struct elf64_ia64_local_hash_entry
*entry2
986 = (struct elf64_ia64_local_hash_entry
*) ptr2
;
988 return entry1
->id
== entry2
->id
&& entry1
->r_sym
== entry2
->r_sym
;
991 /* Free the global elf64_ia64_dyn_sym_info array. */
994 elf64_ia64_global_dyn_info_free (struct elf_link_hash_entry
*xentry
,
995 void * unused ATTRIBUTE_UNUSED
)
997 struct elf64_ia64_link_hash_entry
*entry
998 = (struct elf64_ia64_link_hash_entry
*) xentry
;
1000 if (entry
->root
.root
.type
== bfd_link_hash_warning
)
1001 entry
= (struct elf64_ia64_link_hash_entry
*) entry
->root
.root
.u
.i
.link
;
1006 entry
->sorted_count
= 0;
1012 /* Free the local elf64_ia64_dyn_sym_info array. */
1015 elf64_ia64_local_dyn_info_free (void **slot
,
1016 void * unused ATTRIBUTE_UNUSED
)
1018 struct elf64_ia64_local_hash_entry
*entry
1019 = (struct elf64_ia64_local_hash_entry
*) *slot
;
1024 entry
->sorted_count
= 0;
1030 /* Destroy IA-64 linker hash table. */
1033 elf64_ia64_link_hash_table_free (bfd
*obfd
)
1035 struct elf64_ia64_link_hash_table
*ia64_info
1036 = (struct elf64_ia64_link_hash_table
*) obfd
->link
.hash
;
1037 if (ia64_info
->loc_hash_table
)
1039 htab_traverse (ia64_info
->loc_hash_table
,
1040 elf64_ia64_local_dyn_info_free
, NULL
);
1041 htab_delete (ia64_info
->loc_hash_table
);
1043 if (ia64_info
->loc_hash_memory
)
1044 objalloc_free ((struct objalloc
*) ia64_info
->loc_hash_memory
);
1045 elf_link_hash_traverse (&ia64_info
->root
,
1046 elf64_ia64_global_dyn_info_free
, NULL
);
1047 _bfd_elf_link_hash_table_free (obfd
);
1050 /* Create the derived linker hash table. The IA-64 ELF port uses this
1051 derived hash table to keep information specific to the IA-64 ElF
1052 linker (without using static variables). */
1054 static struct bfd_link_hash_table
*
1055 elf64_ia64_hash_table_create (bfd
*abfd
)
1057 struct elf64_ia64_link_hash_table
*ret
;
1059 ret
= bfd_zmalloc ((bfd_size_type
) sizeof (*ret
));
1063 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
1064 elf64_ia64_new_elf_hash_entry
,
1065 sizeof (struct elf64_ia64_link_hash_entry
),
1072 ret
->loc_hash_table
= htab_try_create (1024, elf64_ia64_local_htab_hash
,
1073 elf64_ia64_local_htab_eq
, NULL
);
1074 ret
->loc_hash_memory
= objalloc_create ();
1075 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1077 elf64_ia64_link_hash_table_free (abfd
);
1080 ret
->root
.root
.hash_table_free
= elf64_ia64_link_hash_table_free
;
1082 return &ret
->root
.root
;
1085 /* Traverse both local and global hash tables. */
1087 struct elf64_ia64_dyn_sym_traverse_data
1089 bool (*func
) (struct elf64_ia64_dyn_sym_info
*, void *);
1094 elf64_ia64_global_dyn_sym_thunk (struct elf_link_hash_entry
*xentry
,
1097 struct elf64_ia64_link_hash_entry
*entry
1098 = (struct elf64_ia64_link_hash_entry
*) xentry
;
1099 struct elf64_ia64_dyn_sym_traverse_data
*data
1100 = (struct elf64_ia64_dyn_sym_traverse_data
*) xdata
;
1101 struct elf64_ia64_dyn_sym_info
*dyn_i
;
1104 if (entry
->root
.root
.type
== bfd_link_hash_warning
)
1105 entry
= (struct elf64_ia64_link_hash_entry
*) entry
->root
.root
.u
.i
.link
;
1107 for (count
= entry
->count
, dyn_i
= entry
->info
;
1110 if (! (*data
->func
) (dyn_i
, data
->data
))
1116 elf64_ia64_local_dyn_sym_thunk (void **slot
, void * xdata
)
1118 struct elf64_ia64_local_hash_entry
*entry
1119 = (struct elf64_ia64_local_hash_entry
*) *slot
;
1120 struct elf64_ia64_dyn_sym_traverse_data
*data
1121 = (struct elf64_ia64_dyn_sym_traverse_data
*) xdata
;
1122 struct elf64_ia64_dyn_sym_info
*dyn_i
;
1125 for (count
= entry
->count
, dyn_i
= entry
->info
;
1128 if (! (*data
->func
) (dyn_i
, data
->data
))
1134 elf64_ia64_dyn_sym_traverse (struct elf64_ia64_link_hash_table
*ia64_info
,
1135 bool (*func
) (struct elf64_ia64_dyn_sym_info
*, void *),
1138 struct elf64_ia64_dyn_sym_traverse_data xdata
;
1143 elf_link_hash_traverse (&ia64_info
->root
,
1144 elf64_ia64_global_dyn_sym_thunk
, &xdata
);
1145 htab_traverse (ia64_info
->loc_hash_table
,
1146 elf64_ia64_local_dyn_sym_thunk
, &xdata
);
1149 #define NOTE_NAME "IPF/VMS"
1152 create_ia64_vms_notes (bfd
*abfd
, struct bfd_link_info
*info
,
1153 unsigned int time_hi
, unsigned int time_lo
)
1156 Elf_Internal_Note notes
[NBR_NOTES
];
1158 int module_name_len
;
1159 unsigned char cur_time
[8];
1160 Elf64_External_VMS_ORIG_DYN_Note
*orig_dyn
;
1161 unsigned int orig_dyn_size
;
1162 unsigned int note_size
;
1164 unsigned char *noteptr
;
1165 unsigned char *note_contents
;
1166 struct elf64_ia64_link_hash_table
*ia64_info
;
1168 ia64_info
= elf64_ia64_hash_table (info
);
1170 module_name
= vms_get_module_name (bfd_get_filename (abfd
), true);
1171 module_name_len
= strlen (module_name
) + 1;
1173 bfd_putl32 (time_lo
, cur_time
+ 0);
1174 bfd_putl32 (time_hi
, cur_time
+ 4);
1176 /* Note 0: IMGNAM. */
1177 notes
[0].type
= NT_VMS_IMGNAM
;
1178 notes
[0].descdata
= module_name
;
1179 notes
[0].descsz
= module_name_len
;
1181 /* Note 1: GSTNAM. */
1182 notes
[1].type
= NT_VMS_GSTNAM
;
1183 notes
[1].descdata
= module_name
;
1184 notes
[1].descsz
= module_name_len
;
1186 /* Note 2: IMGID. */
1187 #define IMG_ID "V1.0"
1188 notes
[2].type
= NT_VMS_IMGID
;
1189 notes
[2].descdata
= IMG_ID
;
1190 notes
[2].descsz
= sizeof (IMG_ID
);
1192 /* Note 3: Linktime. */
1193 notes
[3].type
= NT_VMS_LINKTIME
;
1194 notes
[3].descdata
= (char *)cur_time
;
1195 notes
[3].descsz
= sizeof (cur_time
);
1197 /* Note 4: Linker id. */
1198 notes
[4].type
= NT_VMS_LINKID
;
1199 notes
[4].descdata
= "GNU ld " BFD_VERSION_STRING
;
1200 notes
[4].descsz
= strlen (notes
[4].descdata
) + 1;
1202 /* Note 5: Original dyn. */
1203 orig_dyn_size
= (sizeof (*orig_dyn
) + sizeof (IMG_ID
) - 1 + 7) & ~7;
1204 orig_dyn
= bfd_zalloc (abfd
, orig_dyn_size
);
1205 if (orig_dyn
== NULL
)
1207 bfd_putl32 (1, orig_dyn
->major_id
);
1208 bfd_putl32 (3, orig_dyn
->minor_id
);
1209 memcpy (orig_dyn
->manipulation_date
, cur_time
, sizeof (cur_time
));
1210 bfd_putl64 (VMS_LF_IMGSTA
| VMS_LF_MAIN
, orig_dyn
->link_flags
);
1211 bfd_putl32 (EF_IA_64_ABI64
, orig_dyn
->elf_flags
);
1212 memcpy (orig_dyn
->imgid
, IMG_ID
, sizeof (IMG_ID
));
1213 notes
[5].type
= NT_VMS_ORIG_DYN
;
1214 notes
[5].descdata
= (char *)orig_dyn
;
1215 notes
[5].descsz
= orig_dyn_size
;
1217 /* Note 3: Patchtime. */
1218 notes
[6].type
= NT_VMS_PATCHTIME
;
1219 notes
[6].descdata
= (char *)cur_time
;
1220 notes
[6].descsz
= sizeof (cur_time
);
1222 /* Compute notes size. */
1224 for (i
= 0; i
< NBR_NOTES
; i
++)
1225 note_size
+= sizeof (Elf64_External_VMS_Note
) - 1
1226 + ((sizeof (NOTE_NAME
) - 1 + 7) & ~7)
1227 + ((notes
[i
].descsz
+ 7) & ~7);
1229 /* Malloc a temporary buffer large enough for most notes */
1230 note_contents
= (unsigned char *) bfd_zalloc (abfd
, note_size
);
1231 if (note_contents
== NULL
)
1233 noteptr
= note_contents
;
1236 for (i
= 0; i
< NBR_NOTES
; i
++)
1238 Elf64_External_VMS_Note
*enote
= (Elf64_External_VMS_Note
*) noteptr
;
1240 bfd_putl64 (sizeof (NOTE_NAME
) - 1, enote
->namesz
);
1241 bfd_putl64 (notes
[i
].descsz
, enote
->descsz
);
1242 bfd_putl64 (notes
[i
].type
, enote
->type
);
1244 noteptr
= (unsigned char *)enote
->name
;
1245 memcpy (noteptr
, NOTE_NAME
, sizeof (NOTE_NAME
) - 1);
1246 noteptr
+= (sizeof (NOTE_NAME
) - 1 + 7) & ~7;
1247 memcpy (noteptr
, notes
[i
].descdata
, notes
[i
].descsz
);
1248 noteptr
+= (notes
[i
].descsz
+ 7) & ~7;
1251 ia64_info
->note_sec
->contents
= note_contents
;
1252 ia64_info
->note_sec
->size
= note_size
;
1260 elf64_ia64_create_dynamic_sections (bfd
*abfd
,
1261 struct bfd_link_info
*info
)
1263 struct elf64_ia64_link_hash_table
*ia64_info
;
1266 const struct elf_backend_data
*bed
;
1268 ia64_info
= elf64_ia64_hash_table (info
);
1269 if (ia64_info
== NULL
)
1272 if (elf_hash_table (info
)->dynamic_sections_created
)
1275 abfd
= elf_hash_table (info
)->dynobj
;
1276 bed
= get_elf_backend_data (abfd
);
1278 flags
= bed
->dynamic_sec_flags
;
1280 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynamic",
1281 flags
| SEC_READONLY
);
1283 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
1286 s
= bfd_make_section_anyway_with_flags (abfd
, ".plt", flags
| SEC_READONLY
);
1288 || !bfd_set_section_alignment (s
, bed
->plt_alignment
))
1290 ia64_info
->root
.splt
= s
;
1292 if (!get_got (abfd
, ia64_info
))
1295 if (!get_pltoff (abfd
, ia64_info
))
1298 s
= bfd_make_section_anyway_with_flags (abfd
, ".vmsdynstr",
1302 | SEC_LINKER_CREATED
));
1304 || !bfd_set_section_alignment (s
, 0))
1307 /* Create a fixup section. */
1308 s
= bfd_make_section_anyway_with_flags (abfd
, ".fixups",
1312 | SEC_LINKER_CREATED
));
1314 || !bfd_set_section_alignment (s
, 3))
1316 ia64_info
->fixups_sec
= s
;
1318 /* Create the transfer fixup section. */
1319 s
= bfd_make_section_anyway_with_flags (abfd
, ".transfer",
1323 | SEC_LINKER_CREATED
));
1325 || !bfd_set_section_alignment (s
, 3))
1327 s
->size
= sizeof (struct elf64_vms_transfer
);
1328 ia64_info
->transfer_sec
= s
;
1330 /* Create note section. */
1331 s
= bfd_make_section_anyway_with_flags (abfd
, ".vms.note",
1337 || !bfd_set_section_alignment (s
, 3))
1339 ia64_info
->note_sec
= s
;
1341 elf_hash_table (info
)->dynamic_sections_created
= true;
1345 /* Find and/or create a hash entry for local symbol. */
1346 static struct elf64_ia64_local_hash_entry
*
1347 get_local_sym_hash (struct elf64_ia64_link_hash_table
*ia64_info
,
1348 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
1351 struct elf64_ia64_local_hash_entry e
, *ret
;
1352 asection
*sec
= abfd
->sections
;
1353 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
1354 ELF64_R_SYM (rel
->r_info
));
1358 e
.r_sym
= ELF64_R_SYM (rel
->r_info
);
1359 slot
= htab_find_slot_with_hash (ia64_info
->loc_hash_table
, &e
, h
,
1360 create
? INSERT
: NO_INSERT
);
1366 return (struct elf64_ia64_local_hash_entry
*) *slot
;
1368 ret
= (struct elf64_ia64_local_hash_entry
*)
1369 objalloc_alloc ((struct objalloc
*) ia64_info
->loc_hash_memory
,
1370 sizeof (struct elf64_ia64_local_hash_entry
));
1373 memset (ret
, 0, sizeof (*ret
));
1375 ret
->r_sym
= ELF64_R_SYM (rel
->r_info
);
1381 /* Used to sort elf64_ia64_dyn_sym_info array. */
1384 addend_compare (const void *xp
, const void *yp
)
1386 const struct elf64_ia64_dyn_sym_info
*x
1387 = (const struct elf64_ia64_dyn_sym_info
*) xp
;
1388 const struct elf64_ia64_dyn_sym_info
*y
1389 = (const struct elf64_ia64_dyn_sym_info
*) yp
;
1391 return x
->addend
< y
->addend
? -1 : x
->addend
> y
->addend
? 1 : 0;
1394 /* Sort elf64_ia64_dyn_sym_info array and remove duplicates. */
1397 sort_dyn_sym_info (struct elf64_ia64_dyn_sym_info
*info
,
1400 bfd_vma curr
, prev
, got_offset
;
1401 unsigned int i
, kept
, dupes
, diff
, dest
, src
, len
;
1403 qsort (info
, count
, sizeof (*info
), addend_compare
);
1405 /* Find the first duplicate. */
1406 prev
= info
[0].addend
;
1407 got_offset
= info
[0].got_offset
;
1408 for (i
= 1; i
< count
; i
++)
1410 curr
= info
[i
].addend
;
1413 /* For duplicates, make sure that GOT_OFFSET is valid. */
1414 if (got_offset
== (bfd_vma
) -1)
1415 got_offset
= info
[i
].got_offset
;
1418 got_offset
= info
[i
].got_offset
;
1422 /* We may move a block of elements to here. */
1425 /* Remove duplicates. */
1430 /* For duplicates, make sure that the kept one has a valid
1433 if (got_offset
!= (bfd_vma
) -1)
1434 info
[kept
].got_offset
= got_offset
;
1436 curr
= info
[i
].addend
;
1437 got_offset
= info
[i
].got_offset
;
1439 /* Move a block of elements whose first one is different from
1443 for (src
= i
+ 1; src
< count
; src
++)
1445 if (info
[src
].addend
!= curr
)
1447 /* For duplicates, make sure that GOT_OFFSET is
1449 if (got_offset
== (bfd_vma
) -1)
1450 got_offset
= info
[src
].got_offset
;
1453 /* Make sure that the kept one has a valid got_offset. */
1454 if (got_offset
!= (bfd_vma
) -1)
1455 info
[kept
].got_offset
= got_offset
;
1463 /* Find the next duplicate. SRC will be kept. */
1464 prev
= info
[src
].addend
;
1465 got_offset
= info
[src
].got_offset
;
1466 for (dupes
= src
+ 1; dupes
< count
; dupes
++)
1468 curr
= info
[dupes
].addend
;
1471 /* Make sure that got_offset is valid. */
1472 if (got_offset
== (bfd_vma
) -1)
1473 got_offset
= info
[dupes
].got_offset
;
1475 /* For duplicates, make sure that the kept one has
1476 a valid got_offset. */
1477 if (got_offset
!= (bfd_vma
) -1)
1478 info
[dupes
- 1].got_offset
= got_offset
;
1481 got_offset
= info
[dupes
].got_offset
;
1485 /* How much to move. */
1489 if (len
== 1 && dupes
< count
)
1491 /* If we only move 1 element, we combine it with the next
1492 one. There must be at least a duplicate. Find the
1493 next different one. */
1494 for (diff
= dupes
+ 1, src
++; diff
< count
; diff
++, src
++)
1496 if (info
[diff
].addend
!= curr
)
1498 /* Make sure that got_offset is valid. */
1499 if (got_offset
== (bfd_vma
) -1)
1500 got_offset
= info
[diff
].got_offset
;
1503 /* Makre sure that the last duplicated one has an valid
1505 BFD_ASSERT (curr
== prev
);
1506 if (got_offset
!= (bfd_vma
) -1)
1507 info
[diff
- 1].got_offset
= got_offset
;
1511 /* Find the next duplicate. Track the current valid
1513 prev
= info
[diff
].addend
;
1514 got_offset
= info
[diff
].got_offset
;
1515 for (dupes
= diff
+ 1; dupes
< count
; dupes
++)
1517 curr
= info
[dupes
].addend
;
1520 /* For duplicates, make sure that GOT_OFFSET
1522 if (got_offset
== (bfd_vma
) -1)
1523 got_offset
= info
[dupes
].got_offset
;
1526 got_offset
= info
[dupes
].got_offset
;
1531 len
= diff
- src
+ 1;
1536 memmove (&info
[dest
], &info
[src
], len
* sizeof (*info
));
1545 /* When we get here, either there is no duplicate at all or
1546 the only duplicate is the last element. */
1549 /* If the last element is a duplicate, make sure that the
1550 kept one has a valid got_offset. We also update count. */
1551 if (got_offset
!= (bfd_vma
) -1)
1552 info
[dest
- 1].got_offset
= got_offset
;
1560 /* Find and/or create a descriptor for dynamic symbol info. This will
1561 vary based on global or local symbol, and the addend to the reloc.
1563 We don't sort when inserting. Also, we sort and eliminate
1564 duplicates if there is an unsorted section. Typically, this will
1565 only happen once, because we do all insertions before lookups. We
1566 then use bsearch to do a lookup. This also allows lookups to be
1567 fast. So we have fast insertion (O(log N) due to duplicate check),
1568 fast lookup (O(log N)) and one sort (O(N log N) expected time).
1569 Previously, all lookups were O(N) because of the use of the linked
1570 list and also all insertions were O(N) because of the check for
1571 duplicates. There are some complications here because the array
1572 size grows occasionally, which may add an O(N) factor, but this
1573 should be rare. Also, we free the excess array allocation, which
1574 requires a copy which is O(N), but this only happens once. */
1576 static struct elf64_ia64_dyn_sym_info
*
1577 get_dyn_sym_info (struct elf64_ia64_link_hash_table
*ia64_info
,
1578 struct elf_link_hash_entry
*h
, bfd
*abfd
,
1579 const Elf_Internal_Rela
*rel
, bool create
)
1581 struct elf64_ia64_dyn_sym_info
**info_p
, *info
, *dyn_i
, key
;
1582 unsigned int *count_p
, *sorted_count_p
, *size_p
;
1583 unsigned int count
, sorted_count
, size
;
1584 bfd_vma addend
= rel
? rel
->r_addend
: 0;
1589 struct elf64_ia64_link_hash_entry
*global_h
;
1591 global_h
= (struct elf64_ia64_link_hash_entry
*) h
;
1592 info_p
= &global_h
->info
;
1593 count_p
= &global_h
->count
;
1594 sorted_count_p
= &global_h
->sorted_count
;
1595 size_p
= &global_h
->size
;
1599 struct elf64_ia64_local_hash_entry
*loc_h
;
1601 loc_h
= get_local_sym_hash (ia64_info
, abfd
, rel
, create
);
1604 BFD_ASSERT (!create
);
1608 info_p
= &loc_h
->info
;
1609 count_p
= &loc_h
->count
;
1610 sorted_count_p
= &loc_h
->sorted_count
;
1611 size_p
= &loc_h
->size
;
1615 sorted_count
= *sorted_count_p
;
1620 /* When we create the array, we don't check for duplicates,
1621 except in the previously sorted section if one exists, and
1622 against the last inserted entry. This allows insertions to
1628 /* Try bsearch first on the sorted section. */
1629 key
.addend
= addend
;
1630 dyn_i
= bsearch (&key
, info
, sorted_count
,
1631 sizeof (*info
), addend_compare
);
1639 /* Do a quick check for the last inserted entry. */
1640 dyn_i
= info
+ count
- 1;
1641 if (dyn_i
->addend
== addend
)
1649 /* It is the very first element. We create the array of size
1652 amt
= size
* sizeof (*info
);
1653 info
= bfd_malloc (amt
);
1655 else if (size
<= count
)
1657 /* We double the array size every time when we reach the
1660 amt
= size
* sizeof (*info
);
1661 info
= bfd_realloc (info
, amt
);
1672 /* Append the new one to the array. */
1673 dyn_i
= info
+ count
;
1674 memset (dyn_i
, 0, sizeof (*dyn_i
));
1675 dyn_i
->got_offset
= (bfd_vma
) -1;
1676 dyn_i
->addend
= addend
;
1678 /* We increment count only since the new ones are unsorted and
1679 may have duplicate. */
1684 /* It is a lookup without insertion. Sort array if part of the
1685 array isn't sorted. */
1686 if (count
!= sorted_count
)
1688 count
= sort_dyn_sym_info (info
, count
);
1690 *sorted_count_p
= count
;
1693 /* Free unused memory. */
1696 amt
= count
* sizeof (*info
);
1697 info
= bfd_malloc (amt
);
1700 memcpy (info
, *info_p
, amt
);
1707 key
.addend
= addend
;
1708 dyn_i
= bsearch (&key
, info
, count
,
1709 sizeof (*info
), addend_compare
);
1716 get_got (bfd
*abfd
, struct elf64_ia64_link_hash_table
*ia64_info
)
1721 got
= ia64_info
->root
.sgot
;
1726 dynobj
= ia64_info
->root
.dynobj
;
1728 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1730 /* The .got section is always aligned at 8 bytes. */
1731 flags
= get_elf_backend_data (dynobj
)->dynamic_sec_flags
;
1732 got
= bfd_make_section_anyway_with_flags (dynobj
, ".got",
1733 flags
| SEC_SMALL_DATA
);
1735 || !bfd_set_section_alignment (got
, 3))
1737 ia64_info
->root
.sgot
= got
;
1743 /* Create function descriptor section (.opd). This section is called .opd
1744 because it contains "official procedure descriptors". The "official"
1745 refers to the fact that these descriptors are used when taking the address
1746 of a procedure, thus ensuring a unique address for each procedure. */
1749 get_fptr (bfd
*abfd
, struct bfd_link_info
*info
,
1750 struct elf64_ia64_link_hash_table
*ia64_info
)
1755 fptr
= ia64_info
->fptr_sec
;
1758 dynobj
= ia64_info
->root
.dynobj
;
1760 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1762 fptr
= bfd_make_section_anyway_with_flags (dynobj
, ".opd",
1767 | (bfd_link_pie (info
) ? 0
1769 | SEC_LINKER_CREATED
));
1771 || !bfd_set_section_alignment (fptr
, 4))
1777 ia64_info
->fptr_sec
= fptr
;
1779 if (bfd_link_pie (info
))
1782 fptr_rel
= bfd_make_section_anyway_with_flags (dynobj
, ".rela.opd",
1783 (SEC_ALLOC
| SEC_LOAD
1786 | SEC_LINKER_CREATED
1788 if (fptr_rel
== NULL
1789 || !bfd_set_section_alignment (fptr_rel
, 3))
1795 ia64_info
->rel_fptr_sec
= fptr_rel
;
1803 get_pltoff (bfd
*abfd
, struct elf64_ia64_link_hash_table
*ia64_info
)
1808 pltoff
= ia64_info
->pltoff_sec
;
1811 dynobj
= ia64_info
->root
.dynobj
;
1813 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1815 pltoff
= bfd_make_section_anyway_with_flags (dynobj
,
1816 ELF_STRING_ia64_pltoff
,
1822 | SEC_LINKER_CREATED
));
1824 || !bfd_set_section_alignment (pltoff
, 4))
1830 ia64_info
->pltoff_sec
= pltoff
;
1837 get_reloc_section (bfd
*abfd
,
1838 struct elf64_ia64_link_hash_table
*ia64_info
,
1839 asection
*sec
, bool create
)
1841 const char *srel_name
;
1845 srel_name
= (bfd_elf_string_from_elf_section
1846 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
1847 _bfd_elf_single_rel_hdr (sec
)->sh_name
));
1848 if (srel_name
== NULL
)
1851 BFD_ASSERT ((startswith (srel_name
, ".rela")
1852 && strcmp (bfd_section_name (sec
), srel_name
+5) == 0)
1853 || (startswith (srel_name
, ".rel")
1854 && strcmp (bfd_section_name (sec
), srel_name
+4) == 0));
1856 dynobj
= ia64_info
->root
.dynobj
;
1858 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1860 srel
= bfd_get_linker_section (dynobj
, srel_name
);
1861 if (srel
== NULL
&& create
)
1863 srel
= bfd_make_section_anyway_with_flags (dynobj
, srel_name
,
1864 (SEC_ALLOC
| SEC_LOAD
1867 | SEC_LINKER_CREATED
1870 || !bfd_set_section_alignment (srel
, 3))
1878 count_dyn_reloc (bfd
*abfd
, struct elf64_ia64_dyn_sym_info
*dyn_i
,
1879 asection
*srel
, int type
)
1881 struct elf64_ia64_dyn_reloc_entry
*rent
;
1883 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
1884 if (rent
->srel
== srel
&& rent
->type
== type
)
1889 rent
= ((struct elf64_ia64_dyn_reloc_entry
*)
1890 bfd_alloc (abfd
, (bfd_size_type
) sizeof (*rent
)));
1894 rent
->next
= dyn_i
->reloc_entries
;
1898 dyn_i
->reloc_entries
= rent
;
1906 elf64_ia64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1908 const Elf_Internal_Rela
*relocs
)
1910 struct elf64_ia64_link_hash_table
*ia64_info
;
1911 const Elf_Internal_Rela
*relend
;
1912 Elf_Internal_Shdr
*symtab_hdr
;
1913 const Elf_Internal_Rela
*rel
;
1914 asection
*got
, *fptr
, *srel
, *pltoff
;
1923 NEED_LTOFF_FPTR
= 128
1926 struct elf_link_hash_entry
*h
;
1927 unsigned long r_symndx
;
1930 if (bfd_link_relocatable (info
))
1933 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1934 ia64_info
= elf64_ia64_hash_table (info
);
1935 if (ia64_info
== NULL
)
1938 got
= fptr
= srel
= pltoff
= NULL
;
1940 relend
= relocs
+ sec
->reloc_count
;
1942 /* We scan relocations first to create dynamic relocation arrays. We
1943 modified get_dyn_sym_info to allow fast insertion and support fast
1944 lookup in the next loop. */
1945 for (rel
= relocs
; rel
< relend
; ++rel
)
1947 r_symndx
= ELF64_R_SYM (rel
->r_info
);
1948 if (r_symndx
>= symtab_hdr
->sh_info
)
1950 long indx
= r_symndx
- symtab_hdr
->sh_info
;
1951 h
= elf_sym_hashes (abfd
)[indx
];
1952 while (h
->root
.type
== bfd_link_hash_indirect
1953 || h
->root
.type
== bfd_link_hash_warning
)
1954 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1959 /* We can only get preliminary data on whether a symbol is
1960 locally or externally defined, as not all of the input files
1961 have yet been processed. Do something with what we know, as
1962 this may help reduce memory usage and processing time later. */
1963 maybe_dynamic
= (h
&& ((!bfd_link_executable (info
)
1964 && (!SYMBOLIC_BIND (info
, h
)
1965 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
1967 || h
->root
.type
== bfd_link_hash_defweak
));
1970 switch (ELF64_R_TYPE (rel
->r_info
))
1972 case R_IA64_TPREL64MSB
:
1973 case R_IA64_TPREL64LSB
:
1974 case R_IA64_LTOFF_TPREL22
:
1975 case R_IA64_DTPREL32MSB
:
1976 case R_IA64_DTPREL32LSB
:
1977 case R_IA64_DTPREL64MSB
:
1978 case R_IA64_DTPREL64LSB
:
1979 case R_IA64_LTOFF_DTPREL22
:
1980 case R_IA64_DTPMOD64MSB
:
1981 case R_IA64_DTPMOD64LSB
:
1982 case R_IA64_LTOFF_DTPMOD22
:
1986 case R_IA64_IPLTMSB
:
1987 case R_IA64_IPLTLSB
:
1990 case R_IA64_LTOFF_FPTR22
:
1991 case R_IA64_LTOFF_FPTR64I
:
1992 case R_IA64_LTOFF_FPTR32MSB
:
1993 case R_IA64_LTOFF_FPTR32LSB
:
1994 case R_IA64_LTOFF_FPTR64MSB
:
1995 case R_IA64_LTOFF_FPTR64LSB
:
1996 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
1999 case R_IA64_FPTR64I
:
2000 case R_IA64_FPTR32MSB
:
2001 case R_IA64_FPTR32LSB
:
2002 case R_IA64_FPTR64MSB
:
2003 case R_IA64_FPTR64LSB
:
2004 if (bfd_link_pic (info
) || h
)
2005 need_entry
= NEED_FPTR
| NEED_DYNREL
;
2007 need_entry
= NEED_FPTR
;
2010 case R_IA64_LTOFF22
:
2011 case R_IA64_LTOFF64I
:
2012 need_entry
= NEED_GOT
;
2015 case R_IA64_LTOFF22X
:
2016 need_entry
= NEED_GOTX
;
2019 case R_IA64_PLTOFF22
:
2020 case R_IA64_PLTOFF64I
:
2021 case R_IA64_PLTOFF64MSB
:
2022 case R_IA64_PLTOFF64LSB
:
2023 need_entry
= NEED_PLTOFF
;
2027 need_entry
|= NEED_MIN_PLT
;
2031 (*info
->callbacks
->warning
)
2032 (info
, _("@pltoff reloc against local symbol"), 0,
2033 abfd
, 0, (bfd_vma
) 0);
2037 case R_IA64_PCREL21B
:
2038 case R_IA64_PCREL60B
:
2039 /* Depending on where this symbol is defined, we may or may not
2040 need a full plt entry. Only skip if we know we'll not need
2041 the entry -- static or symbolic, and the symbol definition
2042 has already been seen. */
2043 if (maybe_dynamic
&& rel
->r_addend
== 0)
2044 need_entry
= NEED_FULL_PLT
;
2050 case R_IA64_DIR32MSB
:
2051 case R_IA64_DIR32LSB
:
2052 case R_IA64_DIR64MSB
:
2053 case R_IA64_DIR64LSB
:
2054 /* Shared objects will always need at least a REL relocation. */
2055 if (bfd_link_pic (info
) || maybe_dynamic
)
2056 need_entry
= NEED_DYNREL
;
2059 case R_IA64_PCREL22
:
2060 case R_IA64_PCREL64I
:
2061 case R_IA64_PCREL32MSB
:
2062 case R_IA64_PCREL32LSB
:
2063 case R_IA64_PCREL64MSB
:
2064 case R_IA64_PCREL64LSB
:
2066 need_entry
= NEED_DYNREL
;
2073 if ((need_entry
& NEED_FPTR
) != 0
2076 (*info
->callbacks
->warning
)
2077 (info
, _("non-zero addend in @fptr reloc"), 0,
2078 abfd
, 0, (bfd_vma
) 0);
2081 if (get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, true) == NULL
)
2085 /* Now, we only do lookup without insertion, which is very fast
2086 with the modified get_dyn_sym_info. */
2087 for (rel
= relocs
; rel
< relend
; ++rel
)
2089 struct elf64_ia64_dyn_sym_info
*dyn_i
;
2090 int dynrel_type
= R_IA64_NONE
;
2092 r_symndx
= ELF64_R_SYM (rel
->r_info
);
2093 if (r_symndx
>= symtab_hdr
->sh_info
)
2095 /* We're dealing with a global symbol -- find its hash entry
2096 and mark it as being referenced. */
2097 long indx
= r_symndx
- symtab_hdr
->sh_info
;
2098 h
= elf_sym_hashes (abfd
)[indx
];
2099 while (h
->root
.type
== bfd_link_hash_indirect
2100 || h
->root
.type
== bfd_link_hash_warning
)
2101 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2103 /* PR15323, ref flags aren't set for references in the same
2110 /* We can only get preliminary data on whether a symbol is
2111 locally or externally defined, as not all of the input files
2112 have yet been processed. Do something with what we know, as
2113 this may help reduce memory usage and processing time later. */
2114 maybe_dynamic
= (h
&& ((!bfd_link_executable (info
)
2115 && (!SYMBOLIC_BIND (info
, h
)
2116 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
2118 || h
->root
.type
== bfd_link_hash_defweak
));
2121 switch (ELF64_R_TYPE (rel
->r_info
))
2123 case R_IA64_TPREL64MSB
:
2124 case R_IA64_TPREL64LSB
:
2125 case R_IA64_LTOFF_TPREL22
:
2126 case R_IA64_DTPREL32MSB
:
2127 case R_IA64_DTPREL32LSB
:
2128 case R_IA64_DTPREL64MSB
:
2129 case R_IA64_DTPREL64LSB
:
2130 case R_IA64_LTOFF_DTPREL22
:
2131 case R_IA64_DTPMOD64MSB
:
2132 case R_IA64_DTPMOD64LSB
:
2133 case R_IA64_LTOFF_DTPMOD22
:
2137 case R_IA64_LTOFF_FPTR22
:
2138 case R_IA64_LTOFF_FPTR64I
:
2139 case R_IA64_LTOFF_FPTR32MSB
:
2140 case R_IA64_LTOFF_FPTR32LSB
:
2141 case R_IA64_LTOFF_FPTR64MSB
:
2142 case R_IA64_LTOFF_FPTR64LSB
:
2143 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
2146 case R_IA64_FPTR64I
:
2147 case R_IA64_FPTR32MSB
:
2148 case R_IA64_FPTR32LSB
:
2149 case R_IA64_FPTR64MSB
:
2150 case R_IA64_FPTR64LSB
:
2151 if (bfd_link_pic (info
) || h
)
2152 need_entry
= NEED_FPTR
| NEED_DYNREL
;
2154 need_entry
= NEED_FPTR
;
2155 dynrel_type
= R_IA64_FPTR64LSB
;
2158 case R_IA64_LTOFF22
:
2159 case R_IA64_LTOFF64I
:
2160 need_entry
= NEED_GOT
;
2163 case R_IA64_LTOFF22X
:
2164 need_entry
= NEED_GOTX
;
2167 case R_IA64_PLTOFF22
:
2168 case R_IA64_PLTOFF64I
:
2169 case R_IA64_PLTOFF64MSB
:
2170 case R_IA64_PLTOFF64LSB
:
2171 need_entry
= NEED_PLTOFF
;
2175 need_entry
|= NEED_MIN_PLT
;
2179 case R_IA64_PCREL21B
:
2180 case R_IA64_PCREL60B
:
2181 /* Depending on where this symbol is defined, we may or may not
2182 need a full plt entry. Only skip if we know we'll not need
2183 the entry -- static or symbolic, and the symbol definition
2184 has already been seen. */
2185 if (maybe_dynamic
&& rel
->r_addend
== 0)
2186 need_entry
= NEED_FULL_PLT
;
2192 case R_IA64_DIR32MSB
:
2193 case R_IA64_DIR32LSB
:
2194 case R_IA64_DIR64MSB
:
2195 case R_IA64_DIR64LSB
:
2196 /* Shared objects will always need at least a REL relocation. */
2197 if (bfd_link_pic (info
) || maybe_dynamic
)
2198 need_entry
= NEED_DYNREL
;
2199 dynrel_type
= R_IA64_DIR64LSB
;
2202 case R_IA64_IPLTMSB
:
2203 case R_IA64_IPLTLSB
:
2206 case R_IA64_PCREL22
:
2207 case R_IA64_PCREL64I
:
2208 case R_IA64_PCREL32MSB
:
2209 case R_IA64_PCREL32LSB
:
2210 case R_IA64_PCREL64MSB
:
2211 case R_IA64_PCREL64LSB
:
2213 need_entry
= NEED_DYNREL
;
2214 dynrel_type
= R_IA64_PCREL64LSB
;
2221 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, false);
2223 /* Record whether or not this is a local symbol. */
2226 /* Create what's needed. */
2227 if (need_entry
& (NEED_GOT
| NEED_GOTX
))
2231 got
= get_got (abfd
, ia64_info
);
2235 if (need_entry
& NEED_GOT
)
2236 dyn_i
->want_got
= 1;
2237 if (need_entry
& NEED_GOTX
)
2238 dyn_i
->want_gotx
= 1;
2240 if (need_entry
& NEED_FPTR
)
2242 /* Create the .opd section. */
2245 fptr
= get_fptr (abfd
, info
, ia64_info
);
2249 dyn_i
->want_fptr
= 1;
2251 if (need_entry
& NEED_LTOFF_FPTR
)
2252 dyn_i
->want_ltoff_fptr
= 1;
2253 if (need_entry
& (NEED_MIN_PLT
| NEED_FULL_PLT
))
2255 if (!ia64_info
->root
.dynobj
)
2256 ia64_info
->root
.dynobj
= abfd
;
2258 dyn_i
->want_plt
= 1;
2260 if (need_entry
& NEED_FULL_PLT
)
2261 dyn_i
->want_plt2
= 1;
2262 if (need_entry
& NEED_PLTOFF
)
2264 /* This is needed here, in case @pltoff is used in a non-shared
2268 pltoff
= get_pltoff (abfd
, ia64_info
);
2273 dyn_i
->want_pltoff
= 1;
2275 if ((need_entry
& NEED_DYNREL
) && (sec
->flags
& SEC_ALLOC
))
2279 srel
= get_reloc_section (abfd
, ia64_info
, sec
, true);
2283 if (!count_dyn_reloc (abfd
, dyn_i
, srel
, dynrel_type
))
2291 /* For cleanliness, and potentially faster dynamic loading, allocate
2292 external GOT entries first. */
2295 allocate_global_data_got (struct elf64_ia64_dyn_sym_info
*dyn_i
,
2298 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*)data
;
2300 if ((dyn_i
->want_got
|| dyn_i
->want_gotx
)
2301 && ! dyn_i
->want_fptr
2302 && elf64_ia64_dynamic_symbol_p (dyn_i
->h
))
2304 /* GOT entry with FPTR is done by allocate_global_fptr_got. */
2305 dyn_i
->got_offset
= x
->ofs
;
2311 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
2314 allocate_global_fptr_got (struct elf64_ia64_dyn_sym_info
*dyn_i
,
2317 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*)data
;
2321 && elf64_ia64_dynamic_symbol_p (dyn_i
->h
))
2323 dyn_i
->got_offset
= x
->ofs
;
2329 /* Lastly, allocate all the GOT entries for local data. */
2332 allocate_local_got (struct elf64_ia64_dyn_sym_info
*dyn_i
,
2335 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*) data
;
2337 if ((dyn_i
->want_got
|| dyn_i
->want_gotx
)
2338 && !elf64_ia64_dynamic_symbol_p (dyn_i
->h
))
2340 dyn_i
->got_offset
= x
->ofs
;
2346 /* Allocate function descriptors. We can do these for every function
2347 in a main executable that is not exported. */
2350 allocate_fptr (struct elf64_ia64_dyn_sym_info
*dyn_i
, void * data
)
2352 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*) data
;
2354 if (dyn_i
->want_fptr
)
2356 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2359 while (h
->root
.type
== bfd_link_hash_indirect
2360 || h
->root
.type
== bfd_link_hash_warning
)
2361 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2363 if (h
== NULL
|| !h
->def_dynamic
)
2365 /* A non dynamic symbol. */
2366 dyn_i
->fptr_offset
= x
->ofs
;
2370 dyn_i
->want_fptr
= 0;
2375 /* Allocate all the minimal PLT entries. */
2378 allocate_plt_entries (struct elf64_ia64_dyn_sym_info
*dyn_i
,
2379 void * data ATTRIBUTE_UNUSED
)
2381 if (dyn_i
->want_plt
)
2383 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2386 while (h
->root
.type
== bfd_link_hash_indirect
2387 || h
->root
.type
== bfd_link_hash_warning
)
2388 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2390 /* ??? Versioned symbols seem to lose NEEDS_PLT. */
2391 if (elf64_ia64_dynamic_symbol_p (h
))
2393 dyn_i
->want_pltoff
= 1;
2397 dyn_i
->want_plt
= 0;
2398 dyn_i
->want_plt2
= 0;
2404 /* Allocate all the full PLT entries. */
2407 allocate_plt2_entries (struct elf64_ia64_dyn_sym_info
*dyn_i
,
2410 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*)data
;
2412 if (dyn_i
->want_plt2
)
2414 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2415 bfd_size_type ofs
= x
->ofs
;
2417 dyn_i
->plt2_offset
= ofs
;
2418 x
->ofs
= ofs
+ PLT_FULL_ENTRY_SIZE
;
2420 while (h
->root
.type
== bfd_link_hash_indirect
2421 || h
->root
.type
== bfd_link_hash_warning
)
2422 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2423 dyn_i
->h
->plt
.offset
= ofs
;
2428 /* Allocate all the PLTOFF entries requested by relocations and
2429 plt entries. We can't share space with allocated FPTR entries,
2430 because the latter are not necessarily addressable by the GP.
2431 ??? Relaxation might be able to determine that they are. */
2434 allocate_pltoff_entries (struct elf64_ia64_dyn_sym_info
*dyn_i
,
2437 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*)data
;
2439 if (dyn_i
->want_pltoff
)
2441 dyn_i
->pltoff_offset
= x
->ofs
;
2447 /* Allocate dynamic relocations for those symbols that turned out
2451 allocate_dynrel_entries (struct elf64_ia64_dyn_sym_info
*dyn_i
,
2454 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*)data
;
2455 struct elf64_ia64_link_hash_table
*ia64_info
;
2456 struct elf64_ia64_dyn_reloc_entry
*rent
;
2457 bool dynamic_symbol
, shared
, resolved_zero
;
2458 struct elf64_ia64_link_hash_entry
*h_ia64
;
2460 ia64_info
= elf64_ia64_hash_table (x
->info
);
2461 if (ia64_info
== NULL
)
2464 /* Note that this can't be used in relation to FPTR relocs below. */
2465 dynamic_symbol
= elf64_ia64_dynamic_symbol_p (dyn_i
->h
);
2467 shared
= bfd_link_pic (x
->info
);
2468 resolved_zero
= (dyn_i
->h
2469 && ELF_ST_VISIBILITY (dyn_i
->h
->other
)
2470 && dyn_i
->h
->root
.type
== bfd_link_hash_undefweak
);
2472 /* Take care of the GOT and PLT relocations. */
2475 && (dynamic_symbol
|| shared
)
2476 && (dyn_i
->want_got
|| dyn_i
->want_gotx
))
2477 || (dyn_i
->want_ltoff_fptr
2479 && dyn_i
->h
->def_dynamic
))
2482 if (dyn_i
->h
!= NULL
&& dyn_i
->h
->def_dynamic
)
2484 h_ia64
= (struct elf64_ia64_link_hash_entry
*) dyn_i
->h
;
2485 elf_ia64_vms_tdata (h_ia64
->shl
)->fixups_off
+=
2486 sizeof (Elf64_External_VMS_IMAGE_FIXUP
);
2487 ia64_info
->fixups_sec
->size
+=
2488 sizeof (Elf64_External_VMS_IMAGE_FIXUP
);
2492 if (ia64_info
->rel_fptr_sec
&& dyn_i
->want_fptr
)
2494 /* VMS: only image reloc. */
2495 if (dyn_i
->h
== NULL
|| dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
2496 ia64_info
->rel_fptr_sec
->size
+= sizeof (Elf64_External_Rela
);
2499 if (!resolved_zero
&& dyn_i
->want_pltoff
)
2502 if (dyn_i
->h
!= NULL
&& dyn_i
->h
->def_dynamic
)
2504 h_ia64
= (struct elf64_ia64_link_hash_entry
*) dyn_i
->h
;
2505 elf_ia64_vms_tdata (h_ia64
->shl
)->fixups_off
+=
2506 sizeof (Elf64_External_VMS_IMAGE_FIXUP
);
2507 ia64_info
->fixups_sec
->size
+=
2508 sizeof (Elf64_External_VMS_IMAGE_FIXUP
);
2512 /* Take care of the normal data relocations. */
2514 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2518 case R_IA64_FPTR32LSB
:
2519 case R_IA64_FPTR64LSB
:
2520 /* Allocate one iff !want_fptr and not PIE, which by this point
2521 will be true only if we're actually allocating one statically
2522 in the main executable. Position independent executables
2523 need a relative reloc. */
2524 if (dyn_i
->want_fptr
&& !bfd_link_pie (x
->info
))
2527 case R_IA64_PCREL32LSB
:
2528 case R_IA64_PCREL64LSB
:
2529 if (!dynamic_symbol
)
2532 case R_IA64_DIR32LSB
:
2533 case R_IA64_DIR64LSB
:
2534 if (!dynamic_symbol
&& !shared
)
2537 case R_IA64_IPLTLSB
:
2538 if (!dynamic_symbol
&& !shared
)
2541 case R_IA64_DTPREL32LSB
:
2542 case R_IA64_TPREL64LSB
:
2543 case R_IA64_DTPREL64LSB
:
2544 case R_IA64_DTPMOD64LSB
:
2551 if (!dynamic_symbol
)
2554 h_ia64
= (struct elf64_ia64_link_hash_entry
*) dyn_i
->h
;
2555 elf_ia64_vms_tdata (h_ia64
->shl
)->fixups_off
+=
2556 sizeof (Elf64_External_VMS_IMAGE_FIXUP
);
2557 ia64_info
->fixups_sec
->size
+=
2558 sizeof (Elf64_External_VMS_IMAGE_FIXUP
);
2565 elf64_ia64_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2566 struct elf_link_hash_entry
*h
)
2568 /* ??? Undefined symbols with PLT entries should be re-defined
2569 to be the PLT entry. */
2571 /* If this is a weak symbol, and there is a real definition, the
2572 processor independent code will have arranged for us to see the
2573 real definition first, and we can just use the same value. */
2574 if (h
->is_weakalias
)
2576 struct elf_link_hash_entry
*def
= weakdef (h
);
2577 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
2578 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
2579 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
2583 /* If this is a reference to a symbol defined by a dynamic object which
2584 is not a function, we might allocate the symbol in our .dynbss section
2585 and allocate a COPY dynamic relocation.
2587 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2594 elf64_ia64_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2595 struct bfd_link_info
*info
)
2597 struct elf64_ia64_allocate_data data
;
2598 struct elf64_ia64_link_hash_table
*ia64_info
;
2601 struct elf_link_hash_table
*hash_table
;
2603 hash_table
= elf_hash_table (info
);
2604 dynobj
= hash_table
->dynobj
;
2605 ia64_info
= elf64_ia64_hash_table (info
);
2606 if (ia64_info
== NULL
)
2608 BFD_ASSERT(dynobj
!= NULL
);
2611 /* Allocate the GOT entries. */
2613 if (ia64_info
->root
.sgot
)
2616 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_global_data_got
, &data
);
2617 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_global_fptr_got
, &data
);
2618 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_local_got
, &data
);
2619 ia64_info
->root
.sgot
->size
= data
.ofs
;
2622 /* Allocate the FPTR entries. */
2624 if (ia64_info
->fptr_sec
)
2627 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_fptr
, &data
);
2628 ia64_info
->fptr_sec
->size
= data
.ofs
;
2631 /* Now that we've seen all of the input files, we can decide which
2632 symbols need plt entries. Allocate the minimal PLT entries first.
2633 We do this even though dynamic_sections_created may be FALSE, because
2634 this has the side-effect of clearing want_plt and want_plt2. */
2637 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_plt_entries
, &data
);
2639 /* Align the pointer for the plt2 entries. */
2640 data
.ofs
= (data
.ofs
+ 31) & (bfd_vma
) -32;
2642 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_plt2_entries
, &data
);
2643 if (data
.ofs
!= 0 || ia64_info
->root
.dynamic_sections_created
)
2645 /* FIXME: we always reserve the memory for dynamic linker even if
2646 there are no PLT entries since dynamic linker may assume the
2647 reserved memory always exists. */
2649 BFD_ASSERT (ia64_info
->root
.dynamic_sections_created
);
2651 ia64_info
->root
.splt
->size
= data
.ofs
;
2654 /* Allocate the PLTOFF entries. */
2656 if (ia64_info
->pltoff_sec
)
2659 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_pltoff_entries
, &data
);
2660 ia64_info
->pltoff_sec
->size
= data
.ofs
;
2663 if (ia64_info
->root
.dynamic_sections_created
)
2665 /* Allocate space for the dynamic relocations that turned out to be
2667 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_dynrel_entries
, &data
);
2670 /* We have now determined the sizes of the various dynamic sections.
2671 Allocate memory for them. */
2672 for (sec
= dynobj
->sections
; sec
!= NULL
; sec
= sec
->next
)
2676 if (!(sec
->flags
& SEC_LINKER_CREATED
))
2679 /* If we don't need this section, strip it from the output file.
2680 There were several sections primarily related to dynamic
2681 linking that must be create before the linker maps input
2682 sections to output sections. The linker does that before
2683 bfd_elf_size_dynamic_sections is called, and it is that
2684 function which decides whether anything needs to go into
2687 strip
= (sec
->size
== 0);
2689 if (sec
== ia64_info
->root
.sgot
)
2691 else if (sec
== ia64_info
->root
.srelgot
)
2694 ia64_info
->root
.srelgot
= NULL
;
2696 /* We use the reloc_count field as a counter if we need to
2697 copy relocs into the output file. */
2698 sec
->reloc_count
= 0;
2700 else if (sec
== ia64_info
->fptr_sec
)
2703 ia64_info
->fptr_sec
= NULL
;
2705 else if (sec
== ia64_info
->rel_fptr_sec
)
2708 ia64_info
->rel_fptr_sec
= NULL
;
2710 /* We use the reloc_count field as a counter if we need to
2711 copy relocs into the output file. */
2712 sec
->reloc_count
= 0;
2714 else if (sec
== ia64_info
->root
.splt
)
2717 ia64_info
->root
.splt
= NULL
;
2719 else if (sec
== ia64_info
->pltoff_sec
)
2722 ia64_info
->pltoff_sec
= NULL
;
2724 else if (sec
== ia64_info
->fixups_sec
)
2727 ia64_info
->fixups_sec
= NULL
;
2729 else if (sec
== ia64_info
->transfer_sec
)
2737 /* It's OK to base decisions on the section name, because none
2738 of the dynobj section names depend upon the input files. */
2739 name
= bfd_section_name (sec
);
2741 if (strcmp (name
, ".got.plt") == 0)
2743 else if (startswith (name
, ".rel"))
2747 /* We use the reloc_count field as a counter if we need to
2748 copy relocs into the output file. */
2749 sec
->reloc_count
= 0;
2757 sec
->flags
|= SEC_EXCLUDE
;
2760 /* Allocate memory for the section contents. */
2761 sec
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, sec
->size
);
2762 if (sec
->contents
== NULL
&& sec
->size
!= 0)
2767 if (elf_hash_table (info
)->dynamic_sections_created
)
2771 asection
*dynstrsec
;
2772 Elf_Internal_Dyn dyn
;
2773 const struct elf_backend_data
*bed
;
2774 unsigned int shl_num
= 0;
2775 bfd_vma fixups_off
= 0;
2777 unsigned int time_hi
, time_lo
;
2779 /* The .dynamic section must exist and be empty. */
2780 dynsec
= bfd_get_linker_section (hash_table
->dynobj
, ".dynamic");
2781 BFD_ASSERT (dynsec
!= NULL
);
2782 BFD_ASSERT (dynsec
->size
== 0);
2784 dynstrsec
= bfd_get_linker_section (hash_table
->dynobj
, ".vmsdynstr");
2785 BFD_ASSERT (dynstrsec
!= NULL
);
2786 BFD_ASSERT (dynstrsec
->size
== 0);
2787 dynstrsec
->size
= 1; /* Initial blank. */
2789 /* Ident + link time. */
2790 vms_get_time (&time_hi
, &time_lo
);
2792 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_IDENT
, 0))
2794 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_LINKTIME
,
2795 ((uint64_t) time_hi
<< 32)
2800 strdyn_off
= dynsec
->size
;
2801 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_STRTAB_OFFSET
, 0))
2803 if (!_bfd_elf_add_dynamic_entry (info
, DT_STRSZ
, 0))
2807 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_PLTGOT_SEG
, 0))
2809 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_PLTGOT_OFFSET
, 0))
2813 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_FPMODE
, 0x9800000))
2815 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_LNKFLAGS
,
2816 VMS_LF_IMGSTA
| VMS_LF_MAIN
))
2819 /* Add entries for shared libraries. */
2820 for (abfd
= info
->input_bfds
; abfd
; abfd
= abfd
->link
.next
)
2824 bfd_size_type strindex
;
2825 bfd_byte
*newcontents
;
2826 bfd_vma fixups_shl_off
;
2828 if (!(abfd
->flags
& DYNAMIC
))
2830 BFD_ASSERT (abfd
->xvec
== output_bfd
->xvec
);
2832 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_NEEDED_IDENT
,
2833 elf_ia64_vms_ident (abfd
)))
2836 soname
= vms_get_module_name (bfd_get_filename (abfd
), true);
2839 strindex
= dynstrsec
->size
;
2840 soname_len
= strlen (soname
) + 1;
2841 newcontents
= (bfd_byte
*) bfd_realloc (dynstrsec
->contents
,
2842 strindex
+ soname_len
);
2843 if (newcontents
== NULL
)
2845 memcpy (newcontents
+ strindex
, soname
, soname_len
);
2846 dynstrsec
->size
+= soname_len
;
2847 dynstrsec
->contents
= newcontents
;
2849 if (!_bfd_elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
2852 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_FIXUP_NEEDED
,
2857 /* The fixups_off was in fact containing the size of the fixup
2858 section. Remap into the offset. */
2859 fixups_shl_off
= elf_ia64_vms_tdata (abfd
)->fixups_off
;
2860 elf_ia64_vms_tdata (abfd
)->fixups_off
= fixups_off
;
2862 if (!_bfd_elf_add_dynamic_entry
2863 (info
, DT_IA_64_VMS_FIXUP_RELA_CNT
,
2864 fixups_shl_off
/ sizeof (Elf64_External_VMS_IMAGE_FIXUP
)))
2866 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_FIXUP_RELA_OFF
,
2869 fixups_off
+= fixups_shl_off
;
2873 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_UNWINDSZ
, 0))
2875 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_UNWIND_CODSEG
, 0))
2877 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_UNWIND_INFOSEG
, 0))
2879 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_UNWIND_OFFSET
, 0))
2881 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_UNWIND_SEG
, 0))
2884 if (!_bfd_elf_add_dynamic_entry (info
, DT_NULL
, 0xdead))
2887 /* Fix the strtab entries. */
2888 bed
= get_elf_backend_data (hash_table
->dynobj
);
2890 if (dynstrsec
->size
> 1)
2891 dynstrsec
->contents
[0] = 0;
2893 dynstrsec
->size
= 0;
2895 /* Note: one 'spare' (ie DT_NULL) entry is added by
2896 bfd_elf_size_dynsym_hash_dynstr. */
2897 dyn
.d_tag
= DT_IA_64_VMS_STRTAB_OFFSET
;
2898 dyn
.d_un
.d_val
= dynsec
->size
/* + sizeof (Elf64_External_Dyn) */;
2899 bed
->s
->swap_dyn_out (hash_table
->dynobj
, &dyn
,
2900 dynsec
->contents
+ strdyn_off
);
2902 dyn
.d_tag
= DT_STRSZ
;
2903 dyn
.d_un
.d_val
= dynstrsec
->size
;
2904 bed
->s
->swap_dyn_out (hash_table
->dynobj
, &dyn
,
2905 dynsec
->contents
+ strdyn_off
+ bed
->s
->sizeof_dyn
);
2907 elf_ia64_vms_tdata (output_bfd
)->needed_count
= shl_num
;
2910 if (!create_ia64_vms_notes (output_bfd
, info
, time_hi
, time_lo
))
2914 /* ??? Perhaps force __gp local. */
2920 elf64_ia64_install_fixup (bfd
*output_bfd
,
2921 struct elf64_ia64_link_hash_table
*ia64_info
,
2922 struct elf_link_hash_entry
*h
,
2923 unsigned int type
, asection
*sec
, bfd_vma offset
,
2927 Elf64_External_VMS_IMAGE_FIXUP
*fixup
;
2928 struct elf64_ia64_link_hash_entry
*h_ia64
;
2930 Elf_Internal_Phdr
*phdr
;
2932 if (h
== NULL
|| !h
->def_dynamic
)
2935 h_ia64
= (struct elf64_ia64_link_hash_entry
*) h
;
2936 fixoff
= elf_ia64_vms_tdata (h_ia64
->shl
)->fixups_off
;
2937 elf_ia64_vms_tdata (h_ia64
->shl
)->fixups_off
+=
2938 sizeof (Elf64_External_VMS_IMAGE_FIXUP
);
2939 relsec
= ia64_info
->fixups_sec
;
2941 fixup
= (Elf64_External_VMS_IMAGE_FIXUP
*)(relsec
->contents
+ fixoff
);
2942 offset
+= sec
->output_section
->vma
+ sec
->output_offset
;
2944 /* FIXME: this is slow. We should cache the last one used, or create a
2946 phdr
= _bfd_elf_find_segment_containing_section
2947 (output_bfd
, sec
->output_section
);
2948 BFD_ASSERT (phdr
!= NULL
);
2950 bfd_putl64 (offset
- phdr
->p_vaddr
, fixup
->fixup_offset
);
2951 bfd_putl32 (type
, fixup
->type
);
2952 bfd_putl32 (phdr
- elf_tdata (output_bfd
)->phdr
, fixup
->fixup_seg
);
2953 bfd_putl64 (addend
, fixup
->addend
);
2954 bfd_putl32 (h
->root
.u
.def
.value
, fixup
->symvec_index
);
2955 bfd_putl32 (2, fixup
->data_type
);
2958 /* Store an entry for target address TARGET_ADDR in the linkage table
2959 and return the gp-relative address of the linkage table entry. */
2962 set_got_entry (bfd
*abfd
, struct bfd_link_info
*info
,
2963 struct elf64_ia64_dyn_sym_info
*dyn_i
,
2964 bfd_vma addend
, bfd_vma value
, unsigned int dyn_r_type
)
2966 struct elf64_ia64_link_hash_table
*ia64_info
;
2971 ia64_info
= elf64_ia64_hash_table (info
);
2972 if (ia64_info
== NULL
)
2975 got_sec
= ia64_info
->root
.sgot
;
2979 case R_IA64_TPREL64LSB
:
2980 case R_IA64_DTPMOD64LSB
:
2981 case R_IA64_DTPREL32LSB
:
2982 case R_IA64_DTPREL64LSB
:
2986 done
= dyn_i
->got_done
;
2987 dyn_i
->got_done
= true;
2988 got_offset
= dyn_i
->got_offset
;
2992 BFD_ASSERT ((got_offset
& 7) == 0);
2996 /* Store the target address in the linkage table entry. */
2997 bfd_put_64 (abfd
, value
, got_sec
->contents
+ got_offset
);
2999 /* Install a dynamic relocation if needed. */
3000 if (((bfd_link_pic (info
)
3002 || ELF_ST_VISIBILITY (dyn_i
->h
->other
) == STV_DEFAULT
3003 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
3004 || elf64_ia64_dynamic_symbol_p (dyn_i
->h
))
3005 && (!dyn_i
->want_ltoff_fptr
3006 || !bfd_link_pie (info
)
3008 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
3010 if (!dyn_i
->h
|| !dyn_i
->h
->def_dynamic
)
3012 dyn_r_type
= R_IA64_REL64LSB
;
3016 /* VMS: install a FIX32 or FIX64. */
3019 case R_IA64_DIR32LSB
:
3020 case R_IA64_FPTR32LSB
:
3021 dyn_r_type
= R_IA64_VMS_FIX32
;
3023 case R_IA64_DIR64LSB
:
3024 case R_IA64_FPTR64LSB
:
3025 dyn_r_type
= R_IA64_VMS_FIX64
;
3031 elf64_ia64_install_fixup
3032 (info
->output_bfd
, ia64_info
, dyn_i
->h
,
3033 dyn_r_type
, got_sec
, got_offset
, addend
);
3037 /* Return the address of the linkage table entry. */
3038 value
= (got_sec
->output_section
->vma
3039 + got_sec
->output_offset
3045 /* Fill in a function descriptor consisting of the function's code
3046 address and its global pointer. Return the descriptor's address. */
3049 set_fptr_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3050 struct elf64_ia64_dyn_sym_info
*dyn_i
,
3053 struct elf64_ia64_link_hash_table
*ia64_info
;
3056 ia64_info
= elf64_ia64_hash_table (info
);
3057 if (ia64_info
== NULL
)
3060 fptr_sec
= ia64_info
->fptr_sec
;
3062 if (!dyn_i
->fptr_done
)
3064 dyn_i
->fptr_done
= 1;
3066 /* Fill in the function descriptor. */
3067 bfd_put_64 (abfd
, value
, fptr_sec
->contents
+ dyn_i
->fptr_offset
);
3068 bfd_put_64 (abfd
, _bfd_get_gp_value (abfd
),
3069 fptr_sec
->contents
+ dyn_i
->fptr_offset
+ 8);
3072 /* Return the descriptor's address. */
3073 value
= (fptr_sec
->output_section
->vma
3074 + fptr_sec
->output_offset
3075 + dyn_i
->fptr_offset
);
3080 /* Fill in a PLTOFF entry consisting of the function's code address
3081 and its global pointer. Return the descriptor's address. */
3084 set_pltoff_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3085 struct elf64_ia64_dyn_sym_info
*dyn_i
,
3086 bfd_vma value
, bool is_plt
)
3088 struct elf64_ia64_link_hash_table
*ia64_info
;
3089 asection
*pltoff_sec
;
3091 ia64_info
= elf64_ia64_hash_table (info
);
3092 if (ia64_info
== NULL
)
3095 pltoff_sec
= ia64_info
->pltoff_sec
;
3097 /* Don't do anything if this symbol uses a real PLT entry. In
3098 that case, we'll fill this in during finish_dynamic_symbol. */
3099 if ((! dyn_i
->want_plt
|| is_plt
)
3100 && !dyn_i
->pltoff_done
)
3102 bfd_vma gp
= _bfd_get_gp_value (abfd
);
3104 /* Fill in the function descriptor. */
3105 bfd_put_64 (abfd
, value
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
);
3106 bfd_put_64 (abfd
, gp
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
+ 8);
3108 /* Install dynamic relocations if needed. */
3110 && bfd_link_pic (info
)
3112 || ELF_ST_VISIBILITY (dyn_i
->h
->other
) == STV_DEFAULT
3113 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
3119 dyn_i
->pltoff_done
= 1;
3122 /* Return the descriptor's address. */
3123 value
= (pltoff_sec
->output_section
->vma
3124 + pltoff_sec
->output_offset
3125 + dyn_i
->pltoff_offset
);
3130 /* Called through qsort to sort the .IA_64.unwind section during a
3131 non-relocatable link. Set elf64_ia64_unwind_entry_compare_bfd
3132 to the output bfd so we can do proper endianness frobbing. */
3134 static bfd
*elf64_ia64_unwind_entry_compare_bfd
;
3137 elf64_ia64_unwind_entry_compare (const void * a
, const void * b
)
3141 av
= bfd_get_64 (elf64_ia64_unwind_entry_compare_bfd
, a
);
3142 bv
= bfd_get_64 (elf64_ia64_unwind_entry_compare_bfd
, b
);
3144 return (av
< bv
? -1 : av
> bv
? 1 : 0);
3147 /* Make sure we've got ourselves a nice fat __gp value. */
3149 elf64_ia64_choose_gp (bfd
*abfd
, struct bfd_link_info
*info
, bool final
)
3151 bfd_vma min_vma
= (bfd_vma
) -1, max_vma
= 0;
3152 bfd_vma min_short_vma
= min_vma
, max_short_vma
= 0;
3153 struct elf_link_hash_entry
*gp
;
3156 struct elf64_ia64_link_hash_table
*ia64_info
;
3158 ia64_info
= elf64_ia64_hash_table (info
);
3159 if (ia64_info
== NULL
)
3162 /* Find the min and max vma of all sections marked short. Also collect
3163 min and max vma of any type, for use in selecting a nice gp. */
3164 for (os
= abfd
->sections
; os
; os
= os
->next
)
3168 if ((os
->flags
& SEC_ALLOC
) == 0)
3172 /* When this function is called from elfNN_ia64_final_link
3173 the correct value to use is os->size. When called from
3174 elfNN_ia64_relax_section we are in the middle of section
3175 sizing; some sections will already have os->size set, others
3176 will have os->size zero and os->rawsize the previous size. */
3177 hi
= os
->vma
+ (!final
&& os
->rawsize
? os
->rawsize
: os
->size
);
3185 if (os
->flags
& SEC_SMALL_DATA
)
3187 if (min_short_vma
> lo
)
3189 if (max_short_vma
< hi
)
3194 if (ia64_info
->min_short_sec
)
3197 > (ia64_info
->min_short_sec
->vma
3198 + ia64_info
->min_short_offset
))
3199 min_short_vma
= (ia64_info
->min_short_sec
->vma
3200 + ia64_info
->min_short_offset
);
3202 < (ia64_info
->max_short_sec
->vma
3203 + ia64_info
->max_short_offset
))
3204 max_short_vma
= (ia64_info
->max_short_sec
->vma
3205 + ia64_info
->max_short_offset
);
3208 /* See if the user wants to force a value. */
3209 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", false,
3213 && (gp
->root
.type
== bfd_link_hash_defined
3214 || gp
->root
.type
== bfd_link_hash_defweak
))
3216 asection
*gp_sec
= gp
->root
.u
.def
.section
;
3217 gp_val
= (gp
->root
.u
.def
.value
3218 + gp_sec
->output_section
->vma
3219 + gp_sec
->output_offset
);
3223 /* Pick a sensible value. */
3225 if (ia64_info
->min_short_sec
)
3227 bfd_vma short_range
= max_short_vma
- min_short_vma
;
3229 /* If min_short_sec is set, pick one in the middle bewteen
3230 min_short_vma and max_short_vma. */
3231 if (short_range
>= 0x400000)
3233 gp_val
= min_short_vma
+ short_range
/ 2;
3237 asection
*got_sec
= ia64_info
->root
.sgot
;
3239 /* Start with just the address of the .got. */
3241 gp_val
= got_sec
->output_section
->vma
;
3242 else if (max_short_vma
!= 0)
3243 gp_val
= min_short_vma
;
3244 else if (max_vma
- min_vma
< 0x200000)
3247 gp_val
= max_vma
- 0x200000 + 8;
3250 /* If it is possible to address the entire image, but we
3251 don't with the choice above, adjust. */
3252 if (max_vma
- min_vma
< 0x400000
3253 && (max_vma
- gp_val
>= 0x200000
3254 || gp_val
- min_vma
> 0x200000))
3255 gp_val
= min_vma
+ 0x200000;
3256 else if (max_short_vma
!= 0)
3258 /* If we don't cover all the short data, adjust. */
3259 if (max_short_vma
- gp_val
>= 0x200000)
3260 gp_val
= min_short_vma
+ 0x200000;
3262 /* If we're addressing stuff past the end, adjust back. */
3263 if (gp_val
> max_vma
)
3264 gp_val
= max_vma
- 0x200000 + 8;
3268 /* Validate whether all SHF_IA_64_SHORT sections are within
3269 range of the chosen GP. */
3271 if (max_short_vma
!= 0)
3273 if (max_short_vma
- min_short_vma
>= 0x400000)
3277 /* xgettext:c-format */
3278 (_("%pB: short data segment overflowed (%#" PRIx64
" >= 0x400000)"),
3279 abfd
, (uint64_t) (max_short_vma
- min_short_vma
));
3282 else if ((gp_val
> min_short_vma
3283 && gp_val
- min_short_vma
> 0x200000)
3284 || (gp_val
< max_short_vma
3285 && max_short_vma
- gp_val
>= 0x200000))
3288 (_("%pB: __gp does not cover short data segment"), abfd
);
3293 _bfd_set_gp_value (abfd
, gp_val
);
3299 elf64_ia64_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
3301 struct elf64_ia64_link_hash_table
*ia64_info
;
3302 asection
*unwind_output_sec
;
3304 ia64_info
= elf64_ia64_hash_table (info
);
3305 if (ia64_info
== NULL
)
3308 /* Make sure we've got ourselves a nice fat __gp value. */
3309 if (!bfd_link_relocatable (info
))
3312 struct elf_link_hash_entry
*gp
;
3314 /* We assume after gp is set, section size will only decrease. We
3315 need to adjust gp for it. */
3316 _bfd_set_gp_value (abfd
, 0);
3317 if (! elf64_ia64_choose_gp (abfd
, info
, true))
3319 gp_val
= _bfd_get_gp_value (abfd
);
3321 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", false,
3325 gp
->root
.type
= bfd_link_hash_defined
;
3326 gp
->root
.u
.def
.value
= gp_val
;
3327 gp
->root
.u
.def
.section
= bfd_abs_section_ptr
;
3331 /* If we're producing a final executable, we need to sort the contents
3332 of the .IA_64.unwind section. Force this section to be relocated
3333 into memory rather than written immediately to the output file. */
3334 unwind_output_sec
= NULL
;
3335 if (!bfd_link_relocatable (info
))
3337 asection
*s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_unwind
);
3340 unwind_output_sec
= s
->output_section
;
3341 unwind_output_sec
->contents
3342 = bfd_malloc (unwind_output_sec
->size
);
3343 if (unwind_output_sec
->contents
== NULL
)
3348 /* Invoke the regular ELF backend linker to do all the work. */
3349 if (!bfd_elf_final_link (abfd
, info
))
3352 if (unwind_output_sec
)
3354 elf64_ia64_unwind_entry_compare_bfd
= abfd
;
3355 qsort (unwind_output_sec
->contents
,
3356 (size_t) (unwind_output_sec
->size
/ 24),
3358 elf64_ia64_unwind_entry_compare
);
3360 if (! bfd_set_section_contents (abfd
, unwind_output_sec
,
3361 unwind_output_sec
->contents
, (bfd_vma
) 0,
3362 unwind_output_sec
->size
))
3370 elf64_ia64_relocate_section (bfd
*output_bfd
,
3371 struct bfd_link_info
*info
,
3373 asection
*input_section
,
3375 Elf_Internal_Rela
*relocs
,
3376 Elf_Internal_Sym
*local_syms
,
3377 asection
**local_sections
)
3379 struct elf64_ia64_link_hash_table
*ia64_info
;
3380 Elf_Internal_Shdr
*symtab_hdr
;
3381 Elf_Internal_Rela
*rel
;
3382 Elf_Internal_Rela
*relend
;
3383 bool ret_val
= true; /* for non-fatal errors */
3386 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3387 ia64_info
= elf64_ia64_hash_table (info
);
3388 if (ia64_info
== NULL
)
3391 /* Infect various flags from the input section to the output section. */
3392 if (bfd_link_relocatable (info
))
3396 flags
= elf_section_data(input_section
)->this_hdr
.sh_flags
;
3397 flags
&= SHF_IA_64_NORECOV
;
3399 elf_section_data(input_section
->output_section
)
3400 ->this_hdr
.sh_flags
|= flags
;
3403 gp_val
= _bfd_get_gp_value (output_bfd
);
3406 relend
= relocs
+ input_section
->reloc_count
;
3407 for (; rel
< relend
; ++rel
)
3409 struct elf_link_hash_entry
*h
;
3410 struct elf64_ia64_dyn_sym_info
*dyn_i
;
3411 bfd_reloc_status_type r
;
3412 reloc_howto_type
*howto
;
3413 unsigned long r_symndx
;
3414 Elf_Internal_Sym
*sym
;
3415 unsigned int r_type
;
3419 bool dynamic_symbol_p
;
3420 bool undef_weak_ref
;
3422 r_type
= ELF64_R_TYPE (rel
->r_info
);
3423 if (r_type
> R_IA64_MAX_RELOC_CODE
)
3425 /* xgettext:c-format */
3426 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
3427 input_bfd
, (int) r_type
);
3428 bfd_set_error (bfd_error_bad_value
);
3433 howto
= ia64_elf_lookup_howto (r_type
);
3439 r_symndx
= ELF64_R_SYM (rel
->r_info
);
3443 undef_weak_ref
= false;
3445 if (r_symndx
< symtab_hdr
->sh_info
)
3447 /* Reloc against local symbol. */
3449 sym
= local_syms
+ r_symndx
;
3450 sym_sec
= local_sections
[r_symndx
];
3452 value
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &msec
, rel
);
3453 if (!bfd_link_relocatable (info
)
3454 && (sym_sec
->flags
& SEC_MERGE
) != 0
3455 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3456 && sym_sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
3458 struct elf64_ia64_local_hash_entry
*loc_h
;
3460 loc_h
= get_local_sym_hash (ia64_info
, input_bfd
, rel
, false);
3461 if (loc_h
&& ! loc_h
->sec_merge_done
)
3463 struct elf64_ia64_dyn_sym_info
*dynent
;
3466 for (count
= loc_h
->count
, dynent
= loc_h
->info
;
3472 _bfd_merged_section_offset (output_bfd
, &msec
,
3473 elf_section_data (msec
)->
3477 dynent
->addend
-= sym
->st_value
;
3478 dynent
->addend
+= msec
->output_section
->vma
3479 + msec
->output_offset
3480 - sym_sec
->output_section
->vma
3481 - sym_sec
->output_offset
;
3484 /* We may have introduced duplicated entries. We need
3485 to remove them properly. */
3486 count
= sort_dyn_sym_info (loc_h
->info
, loc_h
->count
);
3487 if (count
!= loc_h
->count
)
3489 loc_h
->count
= count
;
3490 loc_h
->sorted_count
= count
;
3493 loc_h
->sec_merge_done
= 1;
3499 bool unresolved_reloc
;
3500 bool warned
, ignored
;
3501 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
3503 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3504 r_symndx
, symtab_hdr
, sym_hashes
,
3506 unresolved_reloc
, warned
, ignored
);
3508 if (h
->root
.type
== bfd_link_hash_undefweak
)
3509 undef_weak_ref
= true;
3514 /* For relocs against symbols from removed linkonce sections,
3515 or sections discarded by a linker script, we just want the
3516 section contents zeroed. Avoid any special processing. */
3517 if (sym_sec
!= NULL
&& discarded_section (sym_sec
))
3518 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3519 rel
, 1, relend
, howto
, 0, contents
);
3521 if (bfd_link_relocatable (info
))
3524 hit_addr
= contents
+ rel
->r_offset
;
3525 value
+= rel
->r_addend
;
3526 dynamic_symbol_p
= elf64_ia64_dynamic_symbol_p (h
);
3537 case R_IA64_DIR32MSB
:
3538 case R_IA64_DIR32LSB
:
3539 case R_IA64_DIR64MSB
:
3540 case R_IA64_DIR64LSB
:
3541 /* Install a dynamic relocation for this reloc. */
3542 if ((dynamic_symbol_p
|| bfd_link_pic (info
))
3544 && (input_section
->flags
& SEC_ALLOC
) != 0)
3546 unsigned int dyn_r_type
;
3554 /* ??? People shouldn't be doing non-pic code in
3555 shared libraries nor dynamic executables. */
3557 /* xgettext:c-format */
3558 (_("%pB: non-pic code with imm relocation against"
3559 " dynamic symbol `%s'"),
3561 h
? h
->root
.root
.string
3562 : bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3571 /* If we don't need dynamic symbol lookup, find a
3572 matching RELATIVE relocation. */
3573 dyn_r_type
= r_type
;
3574 if (dynamic_symbol_p
)
3576 addend
= rel
->r_addend
;
3584 /* VMS: install a FIX64. */
3587 case R_IA64_DIR32LSB
:
3588 dyn_r_type
= R_IA64_VMS_FIX32
;
3590 case R_IA64_DIR64LSB
:
3591 dyn_r_type
= R_IA64_VMS_FIX64
;
3597 elf64_ia64_install_fixup
3598 (output_bfd
, ia64_info
, h
,
3599 dyn_r_type
, input_section
, rel
->r_offset
, addend
);
3605 case R_IA64_LTV32MSB
:
3606 case R_IA64_LTV32LSB
:
3607 case R_IA64_LTV64MSB
:
3608 case R_IA64_LTV64LSB
:
3609 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
3612 case R_IA64_GPREL22
:
3613 case R_IA64_GPREL64I
:
3614 case R_IA64_GPREL32MSB
:
3615 case R_IA64_GPREL32LSB
:
3616 case R_IA64_GPREL64MSB
:
3617 case R_IA64_GPREL64LSB
:
3618 if (dynamic_symbol_p
)
3621 /* xgettext:c-format */
3622 (_("%pB: @gprel relocation against dynamic symbol %s"),
3624 h
? h
->root
.root
.string
3625 : bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3631 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
3634 case R_IA64_LTOFF22
:
3635 case R_IA64_LTOFF22X
:
3636 case R_IA64_LTOFF64I
:
3637 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, false);
3638 value
= set_got_entry (input_bfd
, info
, dyn_i
,
3639 rel
->r_addend
, value
, R_IA64_DIR64LSB
);
3641 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
3644 case R_IA64_PLTOFF22
:
3645 case R_IA64_PLTOFF64I
:
3646 case R_IA64_PLTOFF64MSB
:
3647 case R_IA64_PLTOFF64LSB
:
3648 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, false);
3649 value
= set_pltoff_entry (output_bfd
, info
, dyn_i
, value
, false);
3651 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
3654 case R_IA64_FPTR64I
:
3655 case R_IA64_FPTR32MSB
:
3656 case R_IA64_FPTR32LSB
:
3657 case R_IA64_FPTR64MSB
:
3658 case R_IA64_FPTR64LSB
:
3659 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, false);
3660 if (dyn_i
->want_fptr
)
3662 if (!undef_weak_ref
)
3663 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
3665 if (!dyn_i
->want_fptr
|| bfd_link_pie (info
))
3667 /* Otherwise, we expect the dynamic linker to create
3670 if (dyn_i
->want_fptr
)
3672 if (r_type
== R_IA64_FPTR64I
)
3674 /* We can't represent this without a dynamic symbol.
3675 Adjust the relocation to be against an output
3676 section symbol, which are always present in the
3677 dynamic symbol table. */
3678 /* ??? People shouldn't be doing non-pic code in
3679 shared libraries. Hork. */
3681 (_("%pB: linking non-pic code in a position independent executable"),
3693 elf64_ia64_install_fixup
3694 (output_bfd
, ia64_info
, h
, R_IA64_VMS_FIXFD
,
3695 input_section
, rel
->r_offset
, 0);
3700 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
3703 case R_IA64_LTOFF_FPTR22
:
3704 case R_IA64_LTOFF_FPTR64I
:
3705 case R_IA64_LTOFF_FPTR32MSB
:
3706 case R_IA64_LTOFF_FPTR32LSB
:
3707 case R_IA64_LTOFF_FPTR64MSB
:
3708 case R_IA64_LTOFF_FPTR64LSB
:
3709 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, false);
3710 if (dyn_i
->want_fptr
)
3712 BFD_ASSERT (h
== NULL
|| !h
->def_dynamic
);
3713 if (!undef_weak_ref
)
3714 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
3719 value
= set_got_entry (output_bfd
, info
, dyn_i
,
3720 rel
->r_addend
, value
, R_IA64_FPTR64LSB
);
3722 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
3725 case R_IA64_PCREL32MSB
:
3726 case R_IA64_PCREL32LSB
:
3727 case R_IA64_PCREL64MSB
:
3728 case R_IA64_PCREL64LSB
:
3729 /* Install a dynamic relocation for this reloc. */
3730 if (dynamic_symbol_p
&& r_symndx
!= 0)
3732 /* VMS: doesn't exist ??? */
3737 case R_IA64_PCREL21B
:
3738 case R_IA64_PCREL60B
:
3739 /* We should have created a PLT entry for any dynamic symbol. */
3742 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, false);
3744 if (dyn_i
&& dyn_i
->want_plt2
)
3746 /* Should have caught this earlier. */
3747 BFD_ASSERT (rel
->r_addend
== 0);
3749 value
= (ia64_info
->root
.splt
->output_section
->vma
3750 + ia64_info
->root
.splt
->output_offset
3751 + dyn_i
->plt2_offset
);
3755 /* Since there's no PLT entry, Validate that this is
3757 BFD_ASSERT (undef_weak_ref
|| sym_sec
->output_section
!= NULL
);
3759 /* If the symbol is undef_weak, we shouldn't be trying
3760 to call it. There's every chance that we'd wind up
3761 with an out-of-range fixup here. Don't bother setting
3762 any value at all. */
3768 case R_IA64_PCREL21BI
:
3769 case R_IA64_PCREL21F
:
3770 case R_IA64_PCREL21M
:
3771 case R_IA64_PCREL22
:
3772 case R_IA64_PCREL64I
:
3773 /* The PCREL21BI reloc is specifically not intended for use with
3774 dynamic relocs. PCREL21F and PCREL21M are used for speculation
3775 fixup code, and thus probably ought not be dynamic. The
3776 PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs. */
3777 if (dynamic_symbol_p
)
3781 if (r_type
== R_IA64_PCREL21BI
)
3782 /* xgettext:c-format */
3783 msg
= _("%pB: @internal branch to dynamic symbol %s");
3784 else if (r_type
== R_IA64_PCREL21F
|| r_type
== R_IA64_PCREL21M
)
3785 /* xgettext:c-format */
3786 msg
= _("%pB: speculation fixup to dynamic symbol %s");
3788 /* xgettext:c-format */
3789 msg
= _("%pB: @pcrel relocation against dynamic symbol %s");
3790 _bfd_error_handler (msg
, input_bfd
,
3791 h
? h
->root
.root
.string
3792 : bfd_elf_sym_name (input_bfd
,
3802 /* Make pc-relative. */
3803 value
-= (input_section
->output_section
->vma
3804 + input_section
->output_offset
3805 + rel
->r_offset
) & ~ (bfd_vma
) 0x3;
3806 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
3809 case R_IA64_SEGREL32MSB
:
3810 case R_IA64_SEGREL32LSB
:
3811 case R_IA64_SEGREL64MSB
:
3812 case R_IA64_SEGREL64LSB
:
3814 /* Find the segment that contains the output_section. */
3815 Elf_Internal_Phdr
*p
= _bfd_elf_find_segment_containing_section
3816 (output_bfd
, sym_sec
->output_section
);
3820 r
= bfd_reloc_notsupported
;
3824 /* The VMA of the segment is the vaddr of the associated
3826 if (value
> p
->p_vaddr
)
3827 value
-= p
->p_vaddr
;
3830 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
3835 case R_IA64_SECREL32MSB
:
3836 case R_IA64_SECREL32LSB
:
3837 case R_IA64_SECREL64MSB
:
3838 case R_IA64_SECREL64LSB
:
3839 /* Make output-section relative to section where the symbol
3840 is defined. PR 475 */
3842 value
-= sym_sec
->output_section
->vma
;
3843 r
= ia64_elf_install_value (hit_addr
, value
, r_type
);
3846 case R_IA64_IPLTMSB
:
3847 case R_IA64_IPLTLSB
:
3848 /* Install a dynamic relocation for this reloc. */
3849 if ((dynamic_symbol_p
|| bfd_link_pic (info
))
3850 && (input_section
->flags
& SEC_ALLOC
) != 0)
3856 if (r_type
== R_IA64_IPLTMSB
)
3857 r_type
= R_IA64_DIR64MSB
;
3859 r_type
= R_IA64_DIR64LSB
;
3860 ia64_elf_install_value (hit_addr
, value
, r_type
);
3861 r
= ia64_elf_install_value (hit_addr
+ 8, gp_val
, r_type
);
3864 case R_IA64_TPREL14
:
3865 case R_IA64_TPREL22
:
3866 case R_IA64_TPREL64I
:
3867 r
= bfd_reloc_notsupported
;
3870 case R_IA64_DTPREL14
:
3871 case R_IA64_DTPREL22
:
3872 case R_IA64_DTPREL64I
:
3873 case R_IA64_DTPREL32LSB
:
3874 case R_IA64_DTPREL32MSB
:
3875 case R_IA64_DTPREL64LSB
:
3876 case R_IA64_DTPREL64MSB
:
3877 r
= bfd_reloc_notsupported
;
3880 case R_IA64_LTOFF_TPREL22
:
3881 case R_IA64_LTOFF_DTPMOD22
:
3882 case R_IA64_LTOFF_DTPREL22
:
3883 r
= bfd_reloc_notsupported
;
3887 r
= bfd_reloc_notsupported
;
3896 case bfd_reloc_undefined
:
3897 /* This can happen for global table relative relocs if
3898 __gp is undefined. This is a panic situation so we
3899 don't try to continue. */
3900 (*info
->callbacks
->undefined_symbol
)
3901 (info
, "__gp", input_bfd
, input_section
, rel
->r_offset
, 1);
3904 case bfd_reloc_notsupported
:
3909 name
= h
->root
.root
.string
;
3911 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3913 (*info
->callbacks
->warning
) (info
, _("unsupported reloc"),
3915 input_section
, rel
->r_offset
);
3920 case bfd_reloc_dangerous
:
3921 case bfd_reloc_outofrange
:
3922 case bfd_reloc_overflow
:
3928 name
= h
->root
.root
.string
;
3930 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
3935 case R_IA64_TPREL14
:
3936 case R_IA64_TPREL22
:
3937 case R_IA64_TPREL64I
:
3938 case R_IA64_DTPREL14
:
3939 case R_IA64_DTPREL22
:
3940 case R_IA64_DTPREL64I
:
3941 case R_IA64_DTPREL32LSB
:
3942 case R_IA64_DTPREL32MSB
:
3943 case R_IA64_DTPREL64LSB
:
3944 case R_IA64_DTPREL64MSB
:
3945 case R_IA64_LTOFF_TPREL22
:
3946 case R_IA64_LTOFF_DTPMOD22
:
3947 case R_IA64_LTOFF_DTPREL22
:
3949 /* xgettext:c-format */
3950 (_("%pB: missing TLS section for relocation %s against `%s'"
3951 " at %#" PRIx64
" in section `%pA'."),
3952 input_bfd
, howto
->name
, name
,
3953 (uint64_t) rel
->r_offset
, input_section
);
3956 case R_IA64_PCREL21B
:
3957 case R_IA64_PCREL21BI
:
3958 case R_IA64_PCREL21M
:
3959 case R_IA64_PCREL21F
:
3960 if (is_elf_hash_table (info
->hash
))
3962 /* Relaxtion is always performed for ELF output.
3963 Overflow failures for those relocations mean
3964 that the section is too big to relax. */
3966 /* xgettext:c-format */
3967 (_("%pB: Can't relax br (%s) to `%s' "
3968 "at %#" PRIx64
" in section `%pA' "
3969 "with size %#" PRIx64
" (> 0x1000000)."),
3970 input_bfd
, howto
->name
, name
, (uint64_t) rel
->r_offset
,
3971 input_section
, (uint64_t) input_section
->size
);
3976 (*info
->callbacks
->reloc_overflow
) (info
,
3997 elf64_ia64_finish_dynamic_symbol (bfd
*output_bfd
,
3998 struct bfd_link_info
*info
,
3999 struct elf_link_hash_entry
*h
,
4000 Elf_Internal_Sym
*sym
)
4002 struct elf64_ia64_link_hash_table
*ia64_info
;
4003 struct elf64_ia64_dyn_sym_info
*dyn_i
;
4005 ia64_info
= elf64_ia64_hash_table (info
);
4007 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, false);
4009 /* Fill in the PLT data, if required. */
4010 if (dyn_i
&& dyn_i
->want_plt
)
4014 bfd_vma plt_addr
, pltoff_addr
, gp_val
;
4016 gp_val
= _bfd_get_gp_value (output_bfd
);
4018 plt_sec
= ia64_info
->root
.splt
;
4019 plt_addr
= 0; /* Not used as overriden by FIXUPs. */
4020 pltoff_addr
= set_pltoff_entry (output_bfd
, info
, dyn_i
, plt_addr
, true);
4022 /* Initialize the FULL PLT entry, if needed. */
4023 if (dyn_i
->want_plt2
)
4025 loc
= plt_sec
->contents
+ dyn_i
->plt2_offset
;
4027 memcpy (loc
, plt_full_entry
, PLT_FULL_ENTRY_SIZE
);
4028 ia64_elf_install_value (loc
, pltoff_addr
- gp_val
, R_IA64_IMM22
);
4030 /* Mark the symbol as undefined, rather than as defined in the
4031 plt section. Leave the value alone. */
4032 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
4033 first place. But perhaps elflink.c did some for us. */
4034 if (!h
->def_regular
)
4035 sym
->st_shndx
= SHN_UNDEF
;
4039 elf64_ia64_install_fixup
4040 (output_bfd
, ia64_info
, h
, R_IA64_VMS_FIXFD
, ia64_info
->pltoff_sec
,
4041 pltoff_addr
- (ia64_info
->pltoff_sec
->output_section
->vma
4042 + ia64_info
->pltoff_sec
->output_offset
), 0);
4045 /* Mark some specially defined symbols as absolute. */
4046 if (h
== ia64_info
->root
.hdynamic
4047 || h
== ia64_info
->root
.hgot
4048 || h
== ia64_info
->root
.hplt
)
4049 sym
->st_shndx
= SHN_ABS
;
4055 elf64_ia64_finish_dynamic_sections (bfd
*abfd
,
4056 struct bfd_link_info
*info
)
4058 struct elf64_ia64_link_hash_table
*ia64_info
;
4061 ia64_info
= elf64_ia64_hash_table (info
);
4062 if (ia64_info
== NULL
)
4065 dynobj
= ia64_info
->root
.dynobj
;
4067 if (elf_hash_table (info
)->dynamic_sections_created
)
4069 Elf64_External_Dyn
*dyncon
, *dynconend
;
4071 asection
*unwind_sec
;
4073 unsigned int gp_seg
;
4075 Elf_Internal_Phdr
*phdr
;
4076 Elf_Internal_Phdr
*base_phdr
;
4077 unsigned int unwind_seg
= 0;
4078 unsigned int code_seg
= 0;
4080 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
4081 BFD_ASSERT (sdyn
!= NULL
);
4082 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
4083 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4085 gp_val
= _bfd_get_gp_value (abfd
);
4086 phdr
= _bfd_elf_find_segment_containing_section
4087 (info
->output_bfd
, ia64_info
->pltoff_sec
->output_section
);
4088 BFD_ASSERT (phdr
!= NULL
);
4089 base_phdr
= elf_tdata (info
->output_bfd
)->phdr
;
4090 gp_seg
= phdr
- base_phdr
;
4091 gp_off
= gp_val
- phdr
->p_vaddr
;
4093 unwind_sec
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_unwind
);
4094 if (unwind_sec
!= NULL
)
4098 phdr
= _bfd_elf_find_segment_containing_section (abfd
, unwind_sec
);
4099 BFD_ASSERT (phdr
!= NULL
);
4100 unwind_seg
= phdr
- base_phdr
;
4102 code_sec
= bfd_get_section_by_name (abfd
, "$CODE$");
4103 phdr
= _bfd_elf_find_segment_containing_section (abfd
, code_sec
);
4104 BFD_ASSERT (phdr
!= NULL
);
4105 code_seg
= phdr
- base_phdr
;
4108 for (; dyncon
< dynconend
; dyncon
++)
4110 Elf_Internal_Dyn dyn
;
4112 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4116 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
4118 (ia64_info
->fixups_sec
->output_section
->vma
4119 + ia64_info
->fixups_sec
->output_offset
)
4120 - (sdyn
->output_section
->vma
+ sdyn
->output_offset
);
4123 case DT_IA_64_VMS_PLTGOT_OFFSET
:
4124 dyn
.d_un
.d_val
= gp_off
;
4127 case DT_IA_64_VMS_PLTGOT_SEG
:
4128 dyn
.d_un
.d_val
= gp_seg
;
4131 case DT_IA_64_VMS_UNWINDSZ
:
4132 if (unwind_sec
== NULL
)
4134 dyn
.d_tag
= DT_NULL
;
4135 dyn
.d_un
.d_val
= 0xdead;
4138 dyn
.d_un
.d_val
= unwind_sec
->size
;
4141 case DT_IA_64_VMS_UNWIND_CODSEG
:
4142 dyn
.d_un
.d_val
= code_seg
;
4145 case DT_IA_64_VMS_UNWIND_INFOSEG
:
4146 case DT_IA_64_VMS_UNWIND_SEG
:
4147 dyn
.d_un
.d_val
= unwind_seg
;
4150 case DT_IA_64_VMS_UNWIND_OFFSET
:
4154 /* No need to rewrite the entry. */
4158 bfd_elf64_swap_dyn_out (abfd
, &dyn
, dyncon
);
4162 /* Handle transfer addresses. */
4164 asection
*tfr_sec
= ia64_info
->transfer_sec
;
4165 struct elf64_vms_transfer
*tfr
;
4166 struct elf_link_hash_entry
*tfr3
;
4168 tfr
= (struct elf64_vms_transfer
*)tfr_sec
->contents
;
4169 bfd_putl32 (6 * 8, tfr
->size
);
4170 bfd_putl64 (tfr_sec
->output_section
->vma
4171 + tfr_sec
->output_offset
4172 + 6 * 8, tfr
->tfradr3
);
4174 tfr3
= elf_link_hash_lookup (elf_hash_table (info
), "ELF$TFRADR", false,
4178 && (tfr3
->root
.type
== bfd_link_hash_defined
4179 || tfr3
->root
.type
== bfd_link_hash_defweak
))
4181 asection
*tfr3_sec
= tfr3
->root
.u
.def
.section
;
4184 tfr3_val
= (tfr3
->root
.u
.def
.value
4185 + tfr3_sec
->output_section
->vma
4186 + tfr3_sec
->output_offset
);
4188 bfd_putl64 (tfr3_val
, tfr
->tfr3_func
);
4189 bfd_putl64 (_bfd_get_gp_value (info
->output_bfd
), tfr
->tfr3_gp
);
4192 /* FIXME: set linker flags,
4193 handle lib$initialize. */
4199 /* ELF file flag handling: */
4201 /* Function to keep IA-64 specific file flags. */
4203 elf64_ia64_set_private_flags (bfd
*abfd
, flagword flags
)
4205 BFD_ASSERT (!elf_flags_init (abfd
)
4206 || elf_elfheader (abfd
)->e_flags
== flags
);
4208 elf_elfheader (abfd
)->e_flags
= flags
;
4209 elf_flags_init (abfd
) = true;
4213 /* Merge backend specific data from an object file to the output
4214 object file when linking. */
4216 elf64_ia64_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
4218 bfd
*obfd
= info
->output_bfd
;
4223 /* FIXME: What should be checked when linking shared libraries? */
4224 if ((ibfd
->flags
& DYNAMIC
) != 0)
4227 /* Don't even pretend to support mixed-format linking. */
4228 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4229 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4232 in_flags
= elf_elfheader (ibfd
)->e_flags
;
4233 out_flags
= elf_elfheader (obfd
)->e_flags
;
4235 if (! elf_flags_init (obfd
))
4237 elf_flags_init (obfd
) = true;
4238 elf_elfheader (obfd
)->e_flags
= in_flags
;
4240 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
4241 && bfd_get_arch_info (obfd
)->the_default
)
4243 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
4244 bfd_get_mach (ibfd
));
4250 /* Check flag compatibility. */
4251 if (in_flags
== out_flags
)
4254 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
4255 if (!(in_flags
& EF_IA_64_REDUCEDFP
) && (out_flags
& EF_IA_64_REDUCEDFP
))
4256 elf_elfheader (obfd
)->e_flags
&= ~EF_IA_64_REDUCEDFP
;
4258 if ((in_flags
& EF_IA_64_TRAPNIL
) != (out_flags
& EF_IA_64_TRAPNIL
))
4261 (_("%pB: linking trap-on-NULL-dereference with non-trapping files"),
4264 bfd_set_error (bfd_error_bad_value
);
4267 if ((in_flags
& EF_IA_64_BE
) != (out_flags
& EF_IA_64_BE
))
4270 (_("%pB: linking big-endian files with little-endian files"),
4273 bfd_set_error (bfd_error_bad_value
);
4276 if ((in_flags
& EF_IA_64_ABI64
) != (out_flags
& EF_IA_64_ABI64
))
4279 (_("%pB: linking 64-bit files with 32-bit files"),
4282 bfd_set_error (bfd_error_bad_value
);
4285 if ((in_flags
& EF_IA_64_CONS_GP
) != (out_flags
& EF_IA_64_CONS_GP
))
4288 (_("%pB: linking constant-gp files with non-constant-gp files"),
4291 bfd_set_error (bfd_error_bad_value
);
4294 if ((in_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
)
4295 != (out_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
4298 (_("%pB: linking auto-pic files with non-auto-pic files"),
4301 bfd_set_error (bfd_error_bad_value
);
4309 elf64_ia64_print_private_bfd_data (bfd
*abfd
, void * ptr
)
4311 FILE *file
= (FILE *) ptr
;
4312 flagword flags
= elf_elfheader (abfd
)->e_flags
;
4314 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
4316 fprintf (file
, "private flags = %s%s%s%s%s%s%s%s\n",
4317 (flags
& EF_IA_64_TRAPNIL
) ? "TRAPNIL, " : "",
4318 (flags
& EF_IA_64_EXT
) ? "EXT, " : "",
4319 (flags
& EF_IA_64_BE
) ? "BE, " : "LE, ",
4320 (flags
& EF_IA_64_REDUCEDFP
) ? "REDUCEDFP, " : "",
4321 (flags
& EF_IA_64_CONS_GP
) ? "CONS_GP, " : "",
4322 (flags
& EF_IA_64_NOFUNCDESC_CONS_GP
) ? "NOFUNCDESC_CONS_GP, " : "",
4323 (flags
& EF_IA_64_ABSOLUTE
) ? "ABSOLUTE, " : "",
4324 (flags
& EF_IA_64_ABI64
) ? "ABI64" : "ABI32");
4326 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
4330 static enum elf_reloc_type_class
4331 elf64_ia64_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4332 const asection
*rel_sec ATTRIBUTE_UNUSED
,
4333 const Elf_Internal_Rela
*rela
)
4335 switch ((int) ELF64_R_TYPE (rela
->r_info
))
4337 case R_IA64_REL32MSB
:
4338 case R_IA64_REL32LSB
:
4339 case R_IA64_REL64MSB
:
4340 case R_IA64_REL64LSB
:
4341 return reloc_class_relative
;
4342 case R_IA64_IPLTMSB
:
4343 case R_IA64_IPLTLSB
:
4344 return reloc_class_plt
;
4346 return reloc_class_copy
;
4348 return reloc_class_normal
;
4352 static const struct bfd_elf_special_section elf64_ia64_special_sections
[] =
4354 { STRING_COMMA_LEN (".sbss"), -1, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_IA_64_SHORT
},
4355 { STRING_COMMA_LEN (".sdata"), -1, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_IA_64_SHORT
},
4356 { NULL
, 0, 0, 0, 0 }
4360 elf64_ia64_object_p (bfd
*abfd
)
4363 asection
*group
, *unwi
, *unw
;
4366 char *unwi_name
, *unw_name
;
4369 if (abfd
->flags
& DYNAMIC
)
4372 /* Flags for fake group section. */
4373 flags
= (SEC_LINKER_CREATED
| SEC_GROUP
| SEC_LINK_ONCE
4376 /* We add a fake section group for each .gnu.linkonce.t.* section,
4377 which isn't in a section group, and its unwind sections. */
4378 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4380 if (elf_sec_group (sec
) == NULL
4381 && ((sec
->flags
& (SEC_LINK_ONCE
| SEC_CODE
| SEC_GROUP
))
4382 == (SEC_LINK_ONCE
| SEC_CODE
))
4383 && startswith (sec
->name
, ".gnu.linkonce.t."))
4385 name
= sec
->name
+ 16;
4387 amt
= strlen (name
) + sizeof (".gnu.linkonce.ia64unwi.");
4388 unwi_name
= bfd_alloc (abfd
, amt
);
4392 strcpy (stpcpy (unwi_name
, ".gnu.linkonce.ia64unwi."), name
);
4393 unwi
= bfd_get_section_by_name (abfd
, unwi_name
);
4395 amt
= strlen (name
) + sizeof (".gnu.linkonce.ia64unw.");
4396 unw_name
= bfd_alloc (abfd
, amt
);
4400 strcpy (stpcpy (unw_name
, ".gnu.linkonce.ia64unw."), name
);
4401 unw
= bfd_get_section_by_name (abfd
, unw_name
);
4403 /* We need to create a fake group section for it and its
4405 group
= bfd_make_section_anyway_with_flags (abfd
, name
,
4410 /* Move the fake group section to the beginning. */
4411 bfd_section_list_remove (abfd
, group
);
4412 bfd_section_list_prepend (abfd
, group
);
4414 elf_next_in_group (group
) = sec
;
4416 elf_group_name (sec
) = name
;
4417 elf_next_in_group (sec
) = sec
;
4418 elf_sec_group (sec
) = group
;
4422 elf_group_name (unwi
) = name
;
4423 elf_next_in_group (unwi
) = sec
;
4424 elf_next_in_group (sec
) = unwi
;
4425 elf_sec_group (unwi
) = group
;
4430 elf_group_name (unw
) = name
;
4433 elf_next_in_group (unw
) = elf_next_in_group (unwi
);
4434 elf_next_in_group (unwi
) = unw
;
4438 elf_next_in_group (unw
) = sec
;
4439 elf_next_in_group (sec
) = unw
;
4441 elf_sec_group (unw
) = group
;
4444 /* Fake SHT_GROUP section header. */
4445 elf_section_data (group
)->this_hdr
.bfd_section
= group
;
4446 elf_section_data (group
)->this_hdr
.sh_type
= SHT_GROUP
;
4452 /* Handle an IA-64 specific section when reading an object file. This
4453 is called when bfd_section_from_shdr finds a section with an unknown
4457 elf64_vms_section_from_shdr (bfd
*abfd
,
4458 Elf_Internal_Shdr
*hdr
,
4462 flagword secflags
= 0;
4464 switch (hdr
->sh_type
)
4466 case SHT_IA_64_VMS_TRACE
:
4467 case SHT_IA_64_VMS_DEBUG
:
4468 case SHT_IA_64_VMS_DEBUG_STR
:
4469 secflags
= SEC_DEBUGGING
;
4472 case SHT_IA_64_UNWIND
:
4473 case SHT_IA_64_HP_OPT_ANOT
:
4477 if (strcmp (name
, ELF_STRING_ia64_archext
) != 0)
4485 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
4490 asection
*newsect
= hdr
->bfd_section
;
4492 if (!bfd_set_section_flags (newsect
,
4493 bfd_section_flags (newsect
) | secflags
))
4501 elf64_vms_object_p (bfd
*abfd
)
4503 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
4504 Elf_Internal_Phdr
*i_phdr
= elf_tdata (abfd
)->phdr
;
4506 unsigned int num_text
= 0;
4507 unsigned int num_data
= 0;
4508 unsigned int num_rodata
= 0;
4511 if (!elf64_ia64_object_p (abfd
))
4514 /* Many VMS compilers do not generate sections for the corresponding
4515 segment. This is boring as binutils tools won't be able to disassemble
4516 the code. So we simply create all the missing sections. */
4517 for (i
= 0; i
< i_ehdrp
->e_phnum
; i
++, i_phdr
++)
4519 /* Is there a section for this segment? */
4520 bfd_vma base_vma
= i_phdr
->p_vaddr
;
4521 bfd_vma limit_vma
= base_vma
+ i_phdr
->p_filesz
;
4523 if (i_phdr
->p_type
!= PT_LOAD
)
4526 /* We need to cover from base_vms to limit_vma. */
4528 while (base_vma
< limit_vma
)
4530 bfd_vma next_vma
= limit_vma
;
4536 /* Find a section covering [base_vma;limit_vma) */
4537 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4539 /* Skip uninteresting sections (either not in memory or
4541 if ((sec
->flags
& (SEC_ALLOC
| SEC_LOAD
)) == 0
4542 || sec
->vma
+ sec
->size
<= base_vma
)
4544 if (sec
->vma
<= base_vma
)
4546 /* This section covers (maybe partially) the beginning
4548 base_vma
= sec
->vma
+ sec
->size
;
4551 if (sec
->vma
< next_vma
)
4553 /* This section partially covers the end of the range.
4554 Used to compute the size of the hole. */
4555 next_vma
= sec
->vma
;
4559 /* No section covering [base_vma; next_vma). Create a fake one. */
4560 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
;
4561 if (i_phdr
->p_flags
& PF_X
)
4564 if (num_text
++ == 0)
4567 sprintf (name
, ".text$%u", num_text
);
4569 else if ((i_phdr
->p_flags
& (PF_R
| PF_W
)) == PF_R
)
4571 flags
|= SEC_READONLY
;
4572 sprintf (name
, ".rodata$%u", num_rodata
++);
4577 sprintf (name
, ".data$%u", num_data
++);
4580 /* Allocate name. */
4583 size_t name_len
= strlen (name
) + 1;
4584 nname
= bfd_alloc (abfd
, name_len
);
4587 memcpy (nname
, name
, name_len
);
4590 /* Create and fill new section. */
4591 nsec
= bfd_make_section_anyway_with_flags (abfd
, nname
, flags
);
4594 nsec
->vma
= base_vma
;
4595 nsec
->size
= next_vma
- base_vma
;
4596 nsec
->filepos
= i_phdr
->p_offset
+ (base_vma
- i_phdr
->p_vaddr
);
4598 base_vma
= next_vma
;
4605 elf64_vms_init_file_header (bfd
*abfd
, struct bfd_link_info
*info
)
4607 Elf_Internal_Ehdr
*i_ehdrp
;
4609 if (!_bfd_elf_init_file_header (abfd
, info
))
4612 i_ehdrp
= elf_elfheader (abfd
);
4613 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_OPENVMS
;
4614 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 2;
4619 elf64_vms_section_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
4620 Elf_Internal_Shdr
*hdr
)
4622 if (hdr
->bfd_section
!= NULL
)
4624 const char *name
= bfd_section_name (hdr
->bfd_section
);
4626 if (strcmp (name
, ".text") == 0)
4627 hdr
->sh_flags
|= SHF_IA_64_VMS_SHARED
;
4628 else if ((strcmp (name
, ".debug") == 0)
4629 || (strcmp (name
, ".debug_abbrev") == 0)
4630 || (strcmp (name
, ".debug_aranges") == 0)
4631 || (strcmp (name
, ".debug_frame") == 0)
4632 || (strcmp (name
, ".debug_info") == 0)
4633 || (strcmp (name
, ".debug_loc") == 0)
4634 || (strcmp (name
, ".debug_macinfo") == 0)
4635 || (strcmp (name
, ".debug_pubnames") == 0)
4636 || (strcmp (name
, ".debug_pubtypes") == 0))
4637 hdr
->sh_type
= SHT_IA_64_VMS_DEBUG
;
4638 else if ((strcmp (name
, ".debug_line") == 0)
4639 || (strcmp (name
, ".debug_ranges") == 0)
4640 || (strcmp (name
, ".trace_info") == 0)
4641 || (strcmp (name
, ".trace_abbrev") == 0)
4642 || (strcmp (name
, ".trace_aranges") == 0))
4643 hdr
->sh_type
= SHT_IA_64_VMS_TRACE
;
4644 else if (strcmp (name
, ".debug_str") == 0)
4645 hdr
->sh_type
= SHT_IA_64_VMS_DEBUG_STR
;
4651 /* The final processing done just before writing out a VMS IA-64 ELF
4655 elf64_vms_final_write_processing (bfd
*abfd
)
4657 Elf_Internal_Shdr
*hdr
;
4659 int unwind_info_sect_idx
= 0;
4661 for (s
= abfd
->sections
; s
; s
= s
->next
)
4663 hdr
= &elf_section_data (s
)->this_hdr
;
4665 if (strcmp (bfd_section_name (hdr
->bfd_section
),
4666 ".IA_64.unwind_info") == 0)
4667 unwind_info_sect_idx
= elf_section_data (s
)->this_idx
;
4669 switch (hdr
->sh_type
)
4671 case SHT_IA_64_UNWIND
:
4672 /* VMS requires sh_info to point to the unwind info section. */
4673 hdr
->sh_info
= unwind_info_sect_idx
;
4678 if (! elf_flags_init (abfd
))
4680 unsigned long flags
= 0;
4682 if (abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
)
4683 flags
|= EF_IA_64_BE
;
4684 if (bfd_get_mach (abfd
) == bfd_mach_ia64_elf64
)
4685 flags
|= EF_IA_64_ABI64
;
4687 elf_elfheader (abfd
)->e_flags
= flags
;
4688 elf_flags_init (abfd
) = true;
4690 return _bfd_elf_final_write_processing (abfd
);
4694 elf64_vms_write_shdrs_and_ehdr (bfd
*abfd
)
4696 unsigned char needed_count
[8];
4698 if (!bfd_elf64_write_shdrs_and_ehdr (abfd
))
4701 bfd_putl64 (elf_ia64_vms_tdata (abfd
)->needed_count
, needed_count
);
4703 if (bfd_seek (abfd
, sizeof (Elf64_External_Ehdr
), SEEK_SET
) != 0
4704 || bfd_write (needed_count
, 8, abfd
) != 8)
4711 elf64_vms_close_and_cleanup (bfd
*abfd
)
4714 if (bfd_get_format (abfd
) == bfd_object
4715 && bfd_write_p (abfd
))
4719 /* Pad to 8 byte boundary for IPF/VMS. */
4720 isize
= bfd_get_size (abfd
);
4721 if ((isize
& 7) != 0)
4723 unsigned int ishort
= 8 - (isize
& 7);
4726 if (bfd_seek (abfd
, isize
, SEEK_SET
) != 0
4727 || bfd_write (&pad
, ishort
, abfd
) != ishort
)
4732 return _bfd_generic_close_and_cleanup (abfd
) && ret
;
4735 /* Add symbols from an ELF object file to the linker hash table. */
4738 elf64_vms_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
4740 Elf_Internal_Shdr
*hdr
;
4741 bfd_size_type symcount
;
4742 bfd_size_type extsymcount
;
4743 bfd_size_type extsymoff
;
4744 struct elf_link_hash_entry
**sym_hash
;
4746 Elf_Internal_Sym
*isymbuf
= NULL
;
4747 Elf_Internal_Sym
*isym
;
4748 Elf_Internal_Sym
*isymend
;
4749 const struct elf_backend_data
*bed
;
4750 struct elf_link_hash_table
*htab
;
4753 htab
= elf_hash_table (info
);
4754 bed
= get_elf_backend_data (abfd
);
4756 if ((abfd
->flags
& DYNAMIC
) == 0)
4762 /* You can't use -r against a dynamic object. Also, there's no
4763 hope of using a dynamic object which does not exactly match
4764 the format of the output file. */
4765 if (bfd_link_relocatable (info
)
4766 || !is_elf_hash_table (&htab
->root
)
4767 || info
->output_bfd
->xvec
!= abfd
->xvec
)
4769 if (bfd_link_relocatable (info
))
4770 bfd_set_error (bfd_error_invalid_operation
);
4772 bfd_set_error (bfd_error_wrong_format
);
4779 /* If we are creating a shared library, create all the dynamic
4780 sections immediately. We need to attach them to something,
4781 so we attach them to this BFD, provided it is the right
4782 format. FIXME: If there are no input BFD's of the same
4783 format as the output, we can't make a shared library. */
4784 if (bfd_link_pic (info
)
4785 && is_elf_hash_table (&htab
->root
)
4786 && info
->output_bfd
->xvec
== abfd
->xvec
4787 && !htab
->dynamic_sections_created
)
4789 if (! elf64_ia64_create_dynamic_sections (abfd
, info
))
4793 else if (!is_elf_hash_table (&htab
->root
))
4801 /* ld --just-symbols and dynamic objects don't mix very well.
4802 ld shouldn't allow it. */
4803 if ((s
= abfd
->sections
) != NULL
4804 && s
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
4807 /* Be sure there are dynamic sections. */
4808 if (! elf64_ia64_create_dynamic_sections (htab
->dynobj
, info
))
4811 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4814 /* VMS libraries do not have dynamic sections. Create one from
4816 Elf_Internal_Phdr
*phdr
;
4817 unsigned int i
, phnum
;
4819 phdr
= elf_tdata (abfd
)->phdr
;
4822 phnum
= elf_elfheader (abfd
)->e_phnum
;
4823 for (i
= 0; i
< phnum
; phdr
++)
4824 if (phdr
->p_type
== PT_DYNAMIC
)
4826 s
= bfd_make_section (abfd
, ".dynamic");
4829 s
->vma
= phdr
->p_vaddr
;
4830 s
->lma
= phdr
->p_paddr
;
4831 s
->size
= phdr
->p_filesz
;
4832 s
->filepos
= phdr
->p_offset
;
4833 s
->flags
|= SEC_HAS_CONTENTS
;
4834 s
->alignment_power
= bfd_log2 (phdr
->p_align
);
4841 /* Extract IDENT. */
4842 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
4849 for (extdyn
= dynbuf
;
4850 (size_t) (dynbuf
+ s
->size
- extdyn
) >= bed
->s
->sizeof_dyn
;
4851 extdyn
+= bed
->s
->sizeof_dyn
)
4853 Elf_Internal_Dyn dyn
;
4855 bed
->s
->swap_dyn_in (abfd
, extdyn
, &dyn
);
4856 if (dyn
.d_tag
== DT_IA_64_VMS_IDENT
)
4858 uint64_t tagv
= dyn
.d_un
.d_val
;
4859 elf_ia64_vms_ident (abfd
) = tagv
;
4863 if (extdyn
>= dynbuf
+ s
->size
)
4865 /* Ident not found. */
4866 goto error_free_dyn
;
4870 /* We do not want to include any of the sections in a dynamic
4871 object in the output file. We hack by simply clobbering the
4872 list of sections in the BFD. This could be handled more
4873 cleanly by, say, a new section flag; the existing
4874 SEC_NEVER_LOAD flag is not the one we want, because that one
4875 still implies that the section takes up space in the output
4877 bfd_section_list_clear (abfd
);
4879 /* FIXME: should we detect if this library is already included ?
4880 This should be harmless and shouldn't happen in practice. */
4883 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4884 symcount
= hdr
->sh_size
/ bed
->s
->sizeof_sym
;
4886 /* The sh_info field of the symtab header tells us where the
4887 external symbols start. We don't care about the local symbols at
4889 extsymcount
= symcount
- hdr
->sh_info
;
4890 extsymoff
= hdr
->sh_info
;
4893 if (extsymcount
!= 0)
4895 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, extsymcount
, extsymoff
,
4897 if (isymbuf
== NULL
)
4900 /* We store a pointer to the hash table entry for each external
4902 amt
= extsymcount
* sizeof (struct elf_link_hash_entry
*);
4903 sym_hash
= (struct elf_link_hash_entry
**) bfd_alloc (abfd
, amt
);
4904 if (sym_hash
== NULL
)
4905 goto error_free_sym
;
4906 elf_sym_hashes (abfd
) = sym_hash
;
4909 for (isym
= isymbuf
, isymend
= isymbuf
+ extsymcount
;
4915 asection
*sec
, *new_sec
;
4918 struct elf_link_hash_entry
*h
;
4920 bool size_change_ok
;
4921 bool type_change_ok
;
4923 unsigned int old_alignment
;
4926 flags
= BSF_NO_FLAGS
;
4928 value
= isym
->st_value
;
4930 common
= bed
->common_definition (isym
);
4932 bind
= ELF_ST_BIND (isym
->st_info
);
4936 /* This should be impossible, since ELF requires that all
4937 global symbols follow all local symbols, and that sh_info
4938 point to the first global symbol. Unfortunately, Irix 5
4943 if (isym
->st_shndx
!= SHN_UNDEF
&& !common
)
4951 case STB_GNU_UNIQUE
:
4952 flags
= BSF_GNU_UNIQUE
;
4956 /* Leave it up to the processor backend. */
4960 if (isym
->st_shndx
== SHN_UNDEF
)
4961 sec
= bfd_und_section_ptr
;
4962 else if (isym
->st_shndx
== SHN_ABS
)
4963 sec
= bfd_abs_section_ptr
;
4964 else if (isym
->st_shndx
== SHN_COMMON
)
4966 sec
= bfd_com_section_ptr
;
4967 /* What ELF calls the size we call the value. What ELF
4968 calls the value we call the alignment. */
4969 value
= isym
->st_size
;
4973 sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
4975 sec
= bfd_abs_section_ptr
;
4976 else if (sec
->kept_section
)
4978 /* Symbols from discarded section are undefined. We keep
4980 sec
= bfd_und_section_ptr
;
4981 isym
->st_shndx
= SHN_UNDEF
;
4983 else if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
4987 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
4990 goto error_free_vers
;
4992 if (bed
->elf_add_symbol_hook
)
4994 if (! (*bed
->elf_add_symbol_hook
) (abfd
, info
, isym
, &name
, &flags
,
4996 goto error_free_vers
;
4998 /* The hook function sets the name to NULL if this symbol
4999 should be skipped for some reason. */
5004 /* Sanity check that all possibilities were handled. */
5007 bfd_set_error (bfd_error_bad_value
);
5008 goto error_free_vers
;
5011 if (bfd_is_und_section (sec
)
5012 || bfd_is_com_section (sec
))
5017 size_change_ok
= false;
5018 type_change_ok
= bed
->type_change_ok
;
5023 if (! bfd_is_und_section (sec
))
5024 h
= elf_link_hash_lookup (htab
, name
, true, false, false);
5026 h
= ((struct elf_link_hash_entry
*) bfd_wrapped_link_hash_lookup
5027 (abfd
, info
, name
, true, false, false));
5029 goto error_free_sym
;
5033 if (is_elf_hash_table (&htab
->root
))
5035 while (h
->root
.type
== bfd_link_hash_indirect
5036 || h
->root
.type
== bfd_link_hash_warning
)
5037 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5039 /* Remember the old alignment if this is a common symbol, so
5040 that we don't reduce the alignment later on. We can't
5041 check later, because _bfd_generic_link_add_one_symbol
5042 will set a default for the alignment which we want to
5043 override. We also remember the old bfd where the existing
5044 definition comes from. */
5045 switch (h
->root
.type
)
5050 case bfd_link_hash_defined
:
5051 if (abfd
->selective_search
)
5054 case bfd_link_hash_defweak
:
5055 old_bfd
= h
->root
.u
.def
.section
->owner
;
5058 case bfd_link_hash_common
:
5059 old_bfd
= h
->root
.u
.c
.p
->section
->owner
;
5060 old_alignment
= h
->root
.u
.c
.p
->alignment_power
;
5065 if (! (_bfd_generic_link_add_one_symbol
5066 (info
, abfd
, name
, flags
, sec
, value
, NULL
, false, bed
->collect
,
5067 (struct bfd_link_hash_entry
**) sym_hash
)))
5068 goto error_free_vers
;
5071 while (h
->root
.type
== bfd_link_hash_indirect
5072 || h
->root
.type
== bfd_link_hash_warning
)
5073 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5077 h
->unique_global
= (flags
& BSF_GNU_UNIQUE
) != 0;
5079 /* Set the alignment of a common symbol. */
5080 if ((common
|| bfd_is_com_section (sec
))
5081 && h
->root
.type
== bfd_link_hash_common
)
5086 align
= bfd_log2 (isym
->st_value
);
5089 /* The new symbol is a common symbol in a shared object.
5090 We need to get the alignment from the section. */
5091 align
= new_sec
->alignment_power
;
5093 if (align
> old_alignment
5094 /* Permit an alignment power of zero if an alignment of one
5095 is specified and no other alignments have been specified. */
5096 || (isym
->st_value
== 1 && old_alignment
== 0))
5097 h
->root
.u
.c
.p
->alignment_power
= align
;
5099 h
->root
.u
.c
.p
->alignment_power
= old_alignment
;
5102 if (is_elf_hash_table (&htab
->root
))
5104 /* Check the alignment when a common symbol is involved. This
5105 can change when a common symbol is overridden by a normal
5106 definition or a common symbol is ignored due to the old
5107 normal definition. We need to make sure the maximum
5108 alignment is maintained. */
5109 if ((old_alignment
|| common
)
5110 && h
->root
.type
!= bfd_link_hash_common
)
5112 unsigned int common_align
;
5113 unsigned int normal_align
;
5114 unsigned int symbol_align
;
5118 symbol_align
= ffs (h
->root
.u
.def
.value
) - 1;
5119 if (h
->root
.u
.def
.section
->owner
!= NULL
5120 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
5122 normal_align
= h
->root
.u
.def
.section
->alignment_power
;
5123 if (normal_align
> symbol_align
)
5124 normal_align
= symbol_align
;
5127 normal_align
= symbol_align
;
5131 common_align
= old_alignment
;
5132 common_bfd
= old_bfd
;
5137 common_align
= bfd_log2 (isym
->st_value
);
5139 normal_bfd
= old_bfd
;
5142 if (normal_align
< common_align
)
5144 /* PR binutils/2735 */
5145 if (normal_bfd
== NULL
)
5147 /* xgettext:c-format */
5148 (_("warning: alignment %u of common symbol `%s' in %pB"
5149 " is greater than the alignment (%u) of its section %pA"),
5150 1 << common_align
, name
, common_bfd
,
5151 1 << normal_align
, h
->root
.u
.def
.section
);
5154 /* xgettext:c-format */
5155 (_("warning: alignment %u of symbol `%s' in %pB"
5156 " is smaller than %u in %pB"),
5157 1 << normal_align
, name
, normal_bfd
,
5158 1 << common_align
, common_bfd
);
5162 /* Remember the symbol size if it isn't undefined. */
5163 if ((isym
->st_size
!= 0 && isym
->st_shndx
!= SHN_UNDEF
)
5164 && (definition
|| h
->size
== 0))
5167 && h
->size
!= isym
->st_size
5168 && ! size_change_ok
)
5170 /* xgettext:c-format */
5171 (_("warning: size of symbol `%s' changed"
5172 " from %" PRIu64
" in %pB to %" PRIu64
" in %pB"),
5173 name
, (uint64_t) h
->size
, old_bfd
,
5174 (uint64_t) isym
->st_size
, abfd
);
5176 h
->size
= isym
->st_size
;
5179 /* If this is a common symbol, then we always want H->SIZE
5180 to be the size of the common symbol. The code just above
5181 won't fix the size if a common symbol becomes larger. We
5182 don't warn about a size change here, because that is
5183 covered by --warn-common. Allow changed between different
5185 if (h
->root
.type
== bfd_link_hash_common
)
5186 h
->size
= h
->root
.u
.c
.size
;
5188 if (ELF_ST_TYPE (isym
->st_info
) != STT_NOTYPE
5189 && (definition
|| h
->type
== STT_NOTYPE
))
5191 unsigned int type
= ELF_ST_TYPE (isym
->st_info
);
5193 if (h
->type
!= type
)
5195 if (h
->type
!= STT_NOTYPE
&& ! type_change_ok
)
5197 /* xgettext:c-format */
5198 (_("warning: type of symbol `%s' changed"
5199 " from %d to %d in %pB"),
5200 name
, h
->type
, type
, abfd
);
5206 /* Set a flag in the hash table entry indicating the type of
5207 reference or definition we just found. Keep a count of
5208 the number of dynamic symbols we find. A dynamic symbol
5209 is one which is referenced or defined by both a regular
5210 object and a shared object. */
5216 if (bind
!= STB_WEAK
)
5217 h
->ref_regular_nonweak
= 1;
5221 BFD_ASSERT (!h
->def_dynamic
);
5227 BFD_ASSERT (definition
);
5230 ((struct elf64_ia64_link_hash_entry
*)h
)->shl
= abfd
;
5238 /* If this object is the same format as the output object, and it is
5239 not a shared library, then let the backend look through the
5242 This is required to build global offset table entries and to
5243 arrange for dynamic relocs. It is not required for the
5244 particular common case of linking non PIC code, even when linking
5245 against shared libraries, but unfortunately there is no way of
5246 knowing whether an object file has been compiled PIC or not.
5247 Looking through the relocs is not particularly time consuming.
5248 The problem is that we must either (1) keep the relocs in memory,
5249 which causes the linker to require additional runtime memory or
5250 (2) read the relocs twice from the input file, which wastes time.
5251 This would be a good case for using mmap.
5253 I have no idea how to handle linking PIC code into a file of a
5254 different format. It probably can't be done. */
5256 && is_elf_hash_table (&htab
->root
)
5257 && bed
->check_relocs
!= NULL
5258 && (*bed
->relocs_compatible
) (abfd
->xvec
, info
->output_bfd
->xvec
))
5262 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5264 Elf_Internal_Rela
*internal_relocs
;
5267 if ((o
->flags
& SEC_RELOC
) == 0
5268 || o
->reloc_count
== 0
5269 || ((info
->strip
== strip_all
|| info
->strip
== strip_debugger
)
5270 && (o
->flags
& SEC_DEBUGGING
) != 0)
5271 || bfd_is_abs_section (o
->output_section
))
5274 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
5276 if (internal_relocs
== NULL
)
5279 ok
= (*bed
->check_relocs
) (abfd
, info
, o
, internal_relocs
);
5281 if (elf_section_data (o
)->relocs
!= internal_relocs
)
5282 free (internal_relocs
);
5299 elf64_vms_link_add_archive_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
5302 struct bfd_link_hash_entry
**pundef
;
5303 struct bfd_link_hash_entry
**next_pundef
;
5305 /* We only accept VMS libraries. */
5306 if (info
->output_bfd
->xvec
!= abfd
->xvec
)
5308 bfd_set_error (bfd_error_wrong_format
);
5312 /* The archive_pass field in the archive itself is used to
5313 initialize PASS, since we may search the same archive multiple
5315 pass
= ++abfd
->archive_pass
;
5317 /* Look through the list of undefined symbols. */
5318 for (pundef
= &info
->hash
->undefs
; *pundef
!= NULL
; pundef
= next_pundef
)
5320 struct bfd_link_hash_entry
*h
;
5326 next_pundef
= &(*pundef
)->u
.undef
.next
;
5328 /* When a symbol is defined, it is not necessarily removed from
5330 if (h
->type
!= bfd_link_hash_undefined
5331 && h
->type
!= bfd_link_hash_common
)
5333 /* Remove this entry from the list, for general cleanliness
5334 and because we are going to look through the list again
5335 if we search any more libraries. We can't remove the
5336 entry if it is the tail, because that would lose any
5337 entries we add to the list later on. */
5338 if (*pundef
!= info
->hash
->undefs_tail
)
5340 *pundef
= *next_pundef
;
5341 next_pundef
= pundef
;
5346 /* Look for this symbol in the archive hash table. */
5347 symidx
= _bfd_vms_lib_find_symbol (abfd
, h
->root
.string
);
5348 if (symidx
== BFD_NO_MORE_SYMBOLS
)
5350 /* Nothing in this slot. */
5354 element
= bfd_get_elt_at_index (abfd
, symidx
);
5355 if (element
== NULL
)
5358 if (element
->archive_pass
== -1 || element
->archive_pass
== pass
)
5360 /* Next symbol if this archive is wrong or already handled. */
5364 orig_element
= element
;
5365 if (bfd_is_thin_archive (abfd
))
5367 element
= _bfd_vms_lib_get_imagelib_file (element
);
5368 if (element
== NULL
|| !bfd_check_format (element
, bfd_object
))
5370 orig_element
->archive_pass
= -1;
5374 else if (! bfd_check_format (element
, bfd_object
))
5376 element
->archive_pass
= -1;
5380 /* Unlike the generic linker, we know that this element provides
5381 a definition for an undefined symbol and we know that we want
5382 to include it. We don't need to check anything. */
5383 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
5384 h
->root
.string
, &element
))
5386 if (! elf64_vms_link_add_object_symbols (element
, info
))
5389 orig_element
->archive_pass
= pass
;
5396 elf64_vms_bfd_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
5398 switch (bfd_get_format (abfd
))
5401 return elf64_vms_link_add_object_symbols (abfd
, info
);
5404 return elf64_vms_link_add_archive_symbols (abfd
, info
);
5407 bfd_set_error (bfd_error_wrong_format
);
5413 elf64_ia64_vms_mkobject (bfd
*abfd
)
5415 return bfd_elf_allocate_object
5416 (abfd
, sizeof (struct elf64_ia64_vms_obj_tdata
), IA64_ELF_DATA
);
5420 /* Size-dependent data and functions. */
5421 static const struct elf_size_info elf64_ia64_vms_size_info
= {
5422 sizeof (Elf64_External_VMS_Ehdr
),
5423 sizeof (Elf64_External_Phdr
),
5424 sizeof (Elf64_External_Shdr
),
5425 sizeof (Elf64_External_Rel
),
5426 sizeof (Elf64_External_Rela
),
5427 sizeof (Elf64_External_Sym
),
5428 sizeof (Elf64_External_Dyn
),
5429 sizeof (Elf_External_Note
),
5432 64, 3, /* ARCH_SIZE, LOG_FILE_ALIGN */
5433 ELFCLASS64
, EV_CURRENT
,
5434 bfd_elf64_write_out_phdrs
,
5435 elf64_vms_write_shdrs_and_ehdr
,
5436 bfd_elf64_checksum_contents
,
5437 bfd_elf64_write_relocs
,
5438 bfd_elf64_swap_symbol_in
,
5439 bfd_elf64_swap_symbol_out
,
5440 bfd_elf64_slurp_reloc_table
,
5441 bfd_elf64_slurp_symbol_table
,
5442 bfd_elf64_swap_dyn_in
,
5443 bfd_elf64_swap_dyn_out
,
5444 bfd_elf64_swap_reloc_in
,
5445 bfd_elf64_swap_reloc_out
,
5446 bfd_elf64_swap_reloca_in
,
5447 bfd_elf64_swap_reloca_out
5450 #define ELF_ARCH bfd_arch_ia64
5451 #define ELF_MACHINE_CODE EM_IA_64
5452 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
5453 #define ELF_COMMONPAGESIZE 0x200 /* 16KB */
5455 #define elf_backend_section_from_shdr \
5456 elf64_ia64_section_from_shdr
5457 #define elf_backend_section_flags \
5458 elf64_ia64_section_flags
5459 #define elf_backend_fake_sections \
5460 elf64_ia64_fake_sections
5461 #define elf_backend_final_write_processing \
5462 elf64_ia64_final_write_processing
5463 #define elf_backend_add_symbol_hook \
5464 elf64_ia64_add_symbol_hook
5465 #define elf_info_to_howto \
5466 elf64_ia64_info_to_howto
5468 #define bfd_elf64_bfd_reloc_type_lookup \
5469 ia64_elf_reloc_type_lookup
5470 #define bfd_elf64_bfd_reloc_name_lookup \
5471 ia64_elf_reloc_name_lookup
5472 #define bfd_elf64_bfd_is_local_label_name \
5473 elf64_ia64_is_local_label_name
5474 #define bfd_elf64_bfd_relax_section \
5475 elf64_ia64_relax_section
5477 #define elf_backend_object_p \
5480 /* Stuff for the BFD linker: */
5481 #define bfd_elf64_bfd_link_hash_table_create \
5482 elf64_ia64_hash_table_create
5483 #define elf_backend_create_dynamic_sections \
5484 elf64_ia64_create_dynamic_sections
5485 #define elf_backend_check_relocs \
5486 elf64_ia64_check_relocs
5487 #define elf_backend_adjust_dynamic_symbol \
5488 elf64_ia64_adjust_dynamic_symbol
5489 #define elf_backend_size_dynamic_sections \
5490 elf64_ia64_size_dynamic_sections
5491 #define elf_backend_omit_section_dynsym \
5492 _bfd_elf_omit_section_dynsym_all
5493 #define elf_backend_relocate_section \
5494 elf64_ia64_relocate_section
5495 #define elf_backend_finish_dynamic_symbol \
5496 elf64_ia64_finish_dynamic_symbol
5497 #define elf_backend_finish_dynamic_sections \
5498 elf64_ia64_finish_dynamic_sections
5499 #define bfd_elf64_bfd_final_link \
5500 elf64_ia64_final_link
5502 #define bfd_elf64_bfd_merge_private_bfd_data \
5503 elf64_ia64_merge_private_bfd_data
5504 #define bfd_elf64_bfd_set_private_flags \
5505 elf64_ia64_set_private_flags
5506 #define bfd_elf64_bfd_print_private_bfd_data \
5507 elf64_ia64_print_private_bfd_data
5509 #define elf_backend_plt_readonly 1
5510 #define elf_backend_want_plt_sym 0
5511 #define elf_backend_plt_alignment 5
5512 #define elf_backend_got_header_size 0
5513 #define elf_backend_want_got_plt 1
5514 #define elf_backend_may_use_rel_p 1
5515 #define elf_backend_may_use_rela_p 1
5516 #define elf_backend_default_use_rela_p 1
5517 #define elf_backend_want_dynbss 0
5518 #define elf_backend_hide_symbol elf64_ia64_hash_hide_symbol
5519 #define elf_backend_fixup_symbol _bfd_elf_link_hash_fixup_symbol
5520 #define elf_backend_reloc_type_class elf64_ia64_reloc_type_class
5521 #define elf_backend_rela_normal 1
5522 #define elf_backend_special_sections elf64_ia64_special_sections
5523 #define elf_backend_default_execstack 0
5525 /* FIXME: PR 290: The Intel C compiler generates SHT_IA_64_UNWIND with
5526 SHF_LINK_ORDER. But it doesn't set the sh_link or sh_info fields.
5527 We don't want to flood users with so many error messages. We turn
5528 off the warning for now. It will be turned on later when the Intel
5529 compiler is fixed. */
5530 #define elf_backend_link_order_error_handler NULL
5532 /* VMS-specific vectors. */
5534 #undef TARGET_LITTLE_SYM
5535 #define TARGET_LITTLE_SYM ia64_elf64_vms_vec
5536 #undef TARGET_LITTLE_NAME
5537 #define TARGET_LITTLE_NAME "elf64-ia64-vms"
5538 #undef TARGET_BIG_SYM
5539 #undef TARGET_BIG_NAME
5541 /* These are VMS specific functions. */
5543 #undef elf_backend_object_p
5544 #define elf_backend_object_p elf64_vms_object_p
5546 #undef elf_backend_section_from_shdr
5547 #define elf_backend_section_from_shdr elf64_vms_section_from_shdr
5549 #undef elf_backend_init_file_header
5550 #define elf_backend_init_file_header elf64_vms_init_file_header
5552 #undef elf_backend_section_processing
5553 #define elf_backend_section_processing elf64_vms_section_processing
5555 #undef elf_backend_final_write_processing
5556 #define elf_backend_final_write_processing elf64_vms_final_write_processing
5558 #undef bfd_elf64_close_and_cleanup
5559 #define bfd_elf64_close_and_cleanup elf64_vms_close_and_cleanup
5561 #undef elf_backend_section_from_bfd_section
5563 #undef elf_backend_symbol_processing
5565 #undef elf_backend_want_p_paddr_set_to_zero
5568 #define ELF_OSABI ELFOSABI_OPENVMS
5570 #undef ELF_MAXPAGESIZE
5571 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
5574 #define elf64_bed elf64_ia64_vms_bed
5576 #define elf_backend_size_info elf64_ia64_vms_size_info
5578 /* Use VMS-style archives (in particular, don't use the standard coff
5580 #define bfd_elf64_archive_functions
5582 #undef bfd_elf64_archive_p
5583 #define bfd_elf64_archive_p _bfd_vms_lib_ia64_archive_p
5584 #undef bfd_elf64_write_archive_contents
5585 #define bfd_elf64_write_archive_contents _bfd_vms_lib_write_archive_contents
5586 #undef bfd_elf64_mkarchive
5587 #define bfd_elf64_mkarchive _bfd_vms_lib_ia64_mkarchive
5589 #define bfd_elf64_archive_slurp_armap \
5590 _bfd_vms_lib_slurp_armap
5591 #define bfd_elf64_archive_slurp_extended_name_table \
5592 _bfd_vms_lib_slurp_extended_name_table
5593 #define bfd_elf64_archive_construct_extended_name_table \
5594 _bfd_vms_lib_construct_extended_name_table
5595 #define bfd_elf64_archive_truncate_arname \
5596 _bfd_vms_lib_truncate_arname
5597 #define bfd_elf64_archive_write_armap \
5598 _bfd_vms_lib_write_armap
5599 #define bfd_elf64_archive_read_ar_hdr \
5600 _bfd_vms_lib_read_ar_hdr
5601 #define bfd_elf64_archive_write_ar_hdr \
5602 _bfd_vms_lib_write_ar_hdr
5603 #define bfd_elf64_archive_openr_next_archived_file \
5604 _bfd_vms_lib_openr_next_archived_file
5605 #define bfd_elf64_archive_get_elt_at_index \
5606 _bfd_vms_lib_get_elt_at_index
5607 #define bfd_elf64_archive_generic_stat_arch_elt \
5608 _bfd_vms_lib_generic_stat_arch_elt
5609 #define bfd_elf64_archive_update_armap_timestamp \
5610 _bfd_vms_lib_update_armap_timestamp
5612 /* VMS link methods. */
5613 #undef bfd_elf64_bfd_link_add_symbols
5614 #define bfd_elf64_bfd_link_add_symbols elf64_vms_bfd_link_add_symbols
5616 #undef elf_backend_want_got_sym
5617 #define elf_backend_want_got_sym 0
5619 #undef bfd_elf64_mkobject
5620 #define bfd_elf64_mkobject elf64_ia64_vms_mkobject
5622 /* Redefine to align segments on block size. */
5623 #undef ELF_MAXPAGESIZE
5624 #define ELF_MAXPAGESIZE 0x200 /* 512B */
5626 #undef elf_backend_want_got_plt
5627 #define elf_backend_want_got_plt 0
5629 #include "elf64-target.h"