1 /* IA-64 support for OpenVMS
2 Copyright (C) 1998-2017 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
25 #include "opcode/ia64.h"
29 #include "elfxx-ia64.h"
33 /* THE RULES for all the stuff the linker creates --
35 GOT Entries created in response to LTOFF or LTOFF_FPTR
36 relocations. Dynamic relocs created for dynamic
37 symbols in an application; REL relocs for locals
40 FPTR The canonical function descriptor. Created for local
41 symbols in applications. Descriptors for dynamic symbols
42 and local symbols in shared libraries are created by
43 ld.so. Thus there are no dynamic relocs against these
44 objects. The FPTR relocs for such _are_ passed through
45 to the dynamic relocation tables.
47 FULL_PLT Created for a PCREL21B relocation against a dynamic symbol.
48 Requires the creation of a PLTOFF entry. This does not
49 require any dynamic relocations.
51 PLTOFF Created by PLTOFF relocations. For local symbols, this
52 is an alternate function descriptor, and in shared libraries
53 requires two REL relocations. Note that this cannot be
54 transformed into an FPTR relocation, since it must be in
55 range of the GP. For dynamic symbols, this is a function
58 typedef struct bfd_hash_entry
*(*new_hash_entry_func
)
59 (struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *);
61 /* In dynamically (linker-) created sections, we generally need to keep track
62 of the place a symbol or expression got allocated to. This is done via hash
63 tables that store entries of the following type. */
65 struct elf64_ia64_dyn_sym_info
67 /* The addend for which this entry is relevant. */
72 bfd_vma pltoff_offset
;
76 /* The symbol table entry, if any, that this was derived from. */
77 struct elf_link_hash_entry
*h
;
79 /* Used to count non-got, non-plt relocations for delayed sizing
80 of relocation sections. */
81 struct elf64_ia64_dyn_reloc_entry
83 struct elf64_ia64_dyn_reloc_entry
*next
;
89 /* TRUE when the section contents have been updated. */
90 unsigned got_done
: 1;
91 unsigned fptr_done
: 1;
92 unsigned pltoff_done
: 1;
94 /* TRUE for the different kinds of linker data we want created. */
95 unsigned want_got
: 1;
96 unsigned want_gotx
: 1;
97 unsigned want_fptr
: 1;
98 unsigned want_ltoff_fptr
: 1;
99 unsigned want_plt
: 1; /* A MIN_PLT entry. */
100 unsigned want_plt2
: 1; /* A FULL_PLT. */
101 unsigned want_pltoff
: 1;
104 struct elf64_ia64_local_hash_entry
108 /* The number of elements in elf64_ia64_dyn_sym_info array. */
110 /* The number of sorted elements in elf64_ia64_dyn_sym_info array. */
111 unsigned int sorted_count
;
112 /* The size of elf64_ia64_dyn_sym_info array. */
114 /* The array of elf64_ia64_dyn_sym_info. */
115 struct elf64_ia64_dyn_sym_info
*info
;
117 /* TRUE if this hash entry's addends was translated for
118 SHF_MERGE optimization. */
119 unsigned sec_merge_done
: 1;
122 struct elf64_ia64_link_hash_entry
124 struct elf_link_hash_entry root
;
126 /* Set if this symbol is defined in a shared library.
127 We can't use root.u.def.section->owner as the symbol is an absolute
131 /* The number of elements in elf64_ia64_dyn_sym_info array. */
133 /* The number of sorted elements in elf64_ia64_dyn_sym_info array. */
134 unsigned int sorted_count
;
135 /* The size of elf64_ia64_dyn_sym_info array. */
137 /* The array of elf64_ia64_dyn_sym_info. */
138 struct elf64_ia64_dyn_sym_info
*info
;
141 struct elf64_ia64_link_hash_table
143 /* The main hash table. */
144 struct elf_link_hash_table root
;
146 asection
*fptr_sec
; /* Function descriptor table (or NULL). */
147 asection
*rel_fptr_sec
; /* Dynamic relocation section for same. */
148 asection
*pltoff_sec
; /* Private descriptors for plt (or NULL). */
149 asection
*fixups_sec
; /* Fixups section. */
150 asection
*transfer_sec
; /* Transfer vector section. */
151 asection
*note_sec
; /* .note section. */
153 /* There are maybe R_IA64_GPREL22 relocations, including those
154 optimized from R_IA64_LTOFF22X, against non-SHF_IA_64_SHORT
155 sections. We need to record those sections so that we can choose
156 a proper GP to cover all R_IA64_GPREL22 relocations. */
157 asection
*max_short_sec
; /* Maximum short output section. */
158 bfd_vma max_short_offset
; /* Maximum short offset. */
159 asection
*min_short_sec
; /* Minimum short output section. */
160 bfd_vma min_short_offset
; /* Minimum short offset. */
162 htab_t loc_hash_table
;
163 void *loc_hash_memory
;
166 struct elf64_ia64_allocate_data
168 struct bfd_link_info
*info
;
172 #define elf64_ia64_hash_table(p) \
173 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
174 == IA64_ELF_DATA ? ((struct elf64_ia64_link_hash_table *) ((p)->hash)) : NULL)
176 struct elf64_ia64_vms_obj_tdata
178 struct elf_obj_tdata root
;
180 /* Ident for shared library. */
183 /* Used only during link: offset in the .fixups section for this bfd. */
186 /* Max number of shared libraries. */
187 unsigned int needed_count
;
190 #define elf_ia64_vms_tdata(abfd) \
191 ((struct elf64_ia64_vms_obj_tdata *)((abfd)->tdata.any))
192 #define elf_ia64_vms_ident(abfd) (elf_ia64_vms_tdata(abfd)->ident)
194 struct elf64_vms_transfer
196 unsigned char size
[4];
197 unsigned char spare
[4];
198 unsigned char tfradr1
[8];
199 unsigned char tfradr2
[8];
200 unsigned char tfradr3
[8];
201 unsigned char tfradr4
[8];
202 unsigned char tfradr5
[8];
204 /* Local function descriptor for tfr3. */
205 unsigned char tfr3_func
[8];
206 unsigned char tfr3_gp
[8];
211 Elf64_External_Ehdr ehdr
;
212 unsigned char vms_needed_count
[8];
213 } Elf64_External_VMS_Ehdr
;
215 static struct elf64_ia64_dyn_sym_info
* get_dyn_sym_info
216 (struct elf64_ia64_link_hash_table
*,
217 struct elf_link_hash_entry
*,
218 bfd
*, const Elf_Internal_Rela
*, bfd_boolean
);
219 static bfd_boolean elf64_ia64_dynamic_symbol_p
220 (struct elf_link_hash_entry
*);
221 static bfd_boolean elf64_ia64_choose_gp
222 (bfd
*, struct bfd_link_info
*, bfd_boolean
);
223 static void elf64_ia64_dyn_sym_traverse
224 (struct elf64_ia64_link_hash_table
*,
225 bfd_boolean (*) (struct elf64_ia64_dyn_sym_info
*, void *),
227 static bfd_boolean allocate_global_data_got
228 (struct elf64_ia64_dyn_sym_info
*, void *);
229 static bfd_boolean allocate_global_fptr_got
230 (struct elf64_ia64_dyn_sym_info
*, void *);
231 static bfd_boolean allocate_local_got
232 (struct elf64_ia64_dyn_sym_info
*, void *);
233 static bfd_boolean allocate_dynrel_entries
234 (struct elf64_ia64_dyn_sym_info
*, void *);
235 static asection
*get_pltoff
236 (bfd
*, struct elf64_ia64_link_hash_table
*);
237 static asection
*get_got
238 (bfd
*, struct elf64_ia64_link_hash_table
*);
241 /* Given a ELF reloc, return the matching HOWTO structure. */
244 elf64_ia64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
246 Elf_Internal_Rela
*elf_reloc
)
249 = ia64_elf_lookup_howto ((unsigned int) ELF64_R_TYPE (elf_reloc
->r_info
));
253 #define PLT_FULL_ENTRY_SIZE (2 * 16)
255 static const bfd_byte plt_full_entry
[PLT_FULL_ENTRY_SIZE
] =
257 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
258 0x00, 0x41, 0x3c, 0x70, 0x29, 0xc0, /* ld8.acq r16=[r15],8*/
259 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
260 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
261 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
262 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
265 static const bfd_byte oor_brl
[16] =
267 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
268 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;;*/
269 0x00, 0x00, 0x00, 0xc0
273 /* These functions do relaxation for IA-64 ELF. */
275 /* Rename some of the generic section flags to better document how they
277 #define skip_relax_pass_0 sec_flg0
278 #define skip_relax_pass_1 sec_flg1
281 elf64_ia64_update_short_info (asection
*sec
, bfd_vma offset
,
282 struct elf64_ia64_link_hash_table
*ia64_info
)
284 /* Skip ABS and SHF_IA_64_SHORT sections. */
285 if (sec
== bfd_abs_section_ptr
286 || (sec
->flags
& SEC_SMALL_DATA
) != 0)
289 if (!ia64_info
->min_short_sec
)
291 ia64_info
->max_short_sec
= sec
;
292 ia64_info
->max_short_offset
= offset
;
293 ia64_info
->min_short_sec
= sec
;
294 ia64_info
->min_short_offset
= offset
;
296 else if (sec
== ia64_info
->max_short_sec
297 && offset
> ia64_info
->max_short_offset
)
298 ia64_info
->max_short_offset
= offset
;
299 else if (sec
== ia64_info
->min_short_sec
300 && offset
< ia64_info
->min_short_offset
)
301 ia64_info
->min_short_offset
= offset
;
302 else if (sec
->output_section
->vma
303 > ia64_info
->max_short_sec
->vma
)
305 ia64_info
->max_short_sec
= sec
;
306 ia64_info
->max_short_offset
= offset
;
308 else if (sec
->output_section
->vma
309 < ia64_info
->min_short_sec
->vma
)
311 ia64_info
->min_short_sec
= sec
;
312 ia64_info
->min_short_offset
= offset
;
316 /* Use a two passes algorithm. In the first pass, branches are relaxed
317 (which may increase the size of the section). In the second pass,
318 the other relaxations are done.
322 elf64_ia64_relax_section (bfd
*abfd
, asection
*sec
,
323 struct bfd_link_info
*link_info
,
328 struct one_fixup
*next
;
334 Elf_Internal_Shdr
*symtab_hdr
;
335 Elf_Internal_Rela
*internal_relocs
;
336 Elf_Internal_Rela
*irel
, *irelend
;
338 Elf_Internal_Sym
*isymbuf
= NULL
;
339 struct elf64_ia64_link_hash_table
*ia64_info
;
340 struct one_fixup
*fixups
= NULL
;
341 bfd_boolean changed_contents
= FALSE
;
342 bfd_boolean changed_relocs
= FALSE
;
343 bfd_boolean skip_relax_pass_0
= TRUE
;
344 bfd_boolean skip_relax_pass_1
= TRUE
;
347 /* Assume we're not going to change any sizes, and we'll only need
351 if (bfd_link_relocatable (link_info
))
352 (*link_info
->callbacks
->einfo
)
353 (_("%P%F: --relax and -r may not be used together\n"));
355 /* Don't even try to relax for non-ELF outputs. */
356 if (!is_elf_hash_table (link_info
->hash
))
359 /* Nothing to do if there are no relocations or there is no need for
361 if ((sec
->flags
& SEC_RELOC
) == 0
362 || sec
->reloc_count
== 0
363 || (link_info
->relax_pass
== 0 && sec
->skip_relax_pass_0
)
364 || (link_info
->relax_pass
== 1 && sec
->skip_relax_pass_1
))
367 ia64_info
= elf64_ia64_hash_table (link_info
);
368 if (ia64_info
== NULL
)
371 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
373 /* Load the relocations for this section. */
374 internal_relocs
= (_bfd_elf_link_read_relocs
375 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
376 link_info
->keep_memory
));
377 if (internal_relocs
== NULL
)
380 irelend
= internal_relocs
+ sec
->reloc_count
;
382 /* Get the section contents. */
383 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
384 contents
= elf_section_data (sec
)->this_hdr
.contents
;
387 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
391 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
393 unsigned long r_type
= ELF64_R_TYPE (irel
->r_info
);
394 bfd_vma symaddr
, reladdr
, trampoff
, toff
, roff
;
398 bfd_boolean is_branch
;
399 struct elf64_ia64_dyn_sym_info
*dyn_i
;
403 case R_IA64_PCREL21B
:
404 case R_IA64_PCREL21BI
:
405 case R_IA64_PCREL21M
:
406 case R_IA64_PCREL21F
:
407 /* In pass 1, all br relaxations are done. We can skip it. */
408 if (link_info
->relax_pass
== 1)
410 skip_relax_pass_0
= FALSE
;
414 case R_IA64_PCREL60B
:
415 /* We can't optimize brl to br in pass 0 since br relaxations
416 will increase the code size. Defer it to pass 1. */
417 if (link_info
->relax_pass
== 0)
419 skip_relax_pass_1
= FALSE
;
426 /* Update max_short_sec/min_short_sec. */
428 case R_IA64_LTOFF22X
:
430 /* We can't relax ldx/mov in pass 0 since br relaxations will
431 increase the code size. Defer it to pass 1. */
432 if (link_info
->relax_pass
== 0)
434 skip_relax_pass_1
= FALSE
;
444 /* Get the value of the symbol referred to by the reloc. */
445 if (ELF64_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
447 /* A local symbol. */
448 Elf_Internal_Sym
*isym
;
450 /* Read this BFD's local symbols. */
453 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
455 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
456 symtab_hdr
->sh_info
, 0,
462 isym
= isymbuf
+ ELF64_R_SYM (irel
->r_info
);
463 if (isym
->st_shndx
== SHN_UNDEF
)
464 continue; /* We can't do anything with undefined symbols. */
465 else if (isym
->st_shndx
== SHN_ABS
)
466 tsec
= bfd_abs_section_ptr
;
467 else if (isym
->st_shndx
== SHN_COMMON
)
468 tsec
= bfd_com_section_ptr
;
469 else if (isym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
470 tsec
= bfd_com_section_ptr
;
472 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
474 toff
= isym
->st_value
;
475 dyn_i
= get_dyn_sym_info (ia64_info
, NULL
, abfd
, irel
, FALSE
);
480 struct elf_link_hash_entry
*h
;
482 indx
= ELF64_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
483 h
= elf_sym_hashes (abfd
)[indx
];
484 BFD_ASSERT (h
!= NULL
);
486 while (h
->root
.type
== bfd_link_hash_indirect
487 || h
->root
.type
== bfd_link_hash_warning
)
488 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
490 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, irel
, FALSE
);
492 /* For branches to dynamic symbols, we're interested instead
493 in a branch to the PLT entry. */
494 if (is_branch
&& dyn_i
&& dyn_i
->want_plt2
)
496 /* Internal branches shouldn't be sent to the PLT.
497 Leave this for now and we'll give an error later. */
498 if (r_type
!= R_IA64_PCREL21B
)
501 tsec
= ia64_info
->root
.splt
;
502 toff
= dyn_i
->plt2_offset
;
503 BFD_ASSERT (irel
->r_addend
== 0);
506 /* Can't do anything else with dynamic symbols. */
507 else if (elf64_ia64_dynamic_symbol_p (h
))
512 /* We can't do anything with undefined symbols. */
513 if (h
->root
.type
== bfd_link_hash_undefined
514 || h
->root
.type
== bfd_link_hash_undefweak
)
517 tsec
= h
->root
.u
.def
.section
;
518 toff
= h
->root
.u
.def
.value
;
522 toff
+= irel
->r_addend
;
524 symaddr
= tsec
->output_section
->vma
+ tsec
->output_offset
+ toff
;
526 roff
= irel
->r_offset
;
530 bfd_signed_vma offset
;
532 reladdr
= (sec
->output_section
->vma
534 + roff
) & (bfd_vma
) -4;
536 /* The .plt section is aligned at 32byte and the .text section
537 is aligned at 64byte. The .text section is right after the
538 .plt section. After the first relaxation pass, linker may
539 increase the gap between the .plt and .text sections up
540 to 32byte. We assume linker will always insert 32byte
541 between the .plt and .text sections after the first
543 if (tsec
== ia64_info
->root
.splt
)
544 offset
= -0x1000000 + 32;
548 /* If the branch is in range, no need to do anything. */
549 if ((bfd_signed_vma
) (symaddr
- reladdr
) >= offset
550 && (bfd_signed_vma
) (symaddr
- reladdr
) <= 0x0FFFFF0)
552 /* If the 60-bit branch is in 21-bit range, optimize it. */
553 if (r_type
== R_IA64_PCREL60B
)
555 ia64_elf_relax_brl (contents
, roff
);
557 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
560 /* If the original relocation offset points to slot
561 1, change it to slot 2. */
562 if ((irel
->r_offset
& 3) == 1)
568 else if (r_type
== R_IA64_PCREL60B
)
570 else if (ia64_elf_relax_br (contents
, roff
))
572 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
575 /* Make the relocation offset point to slot 1. */
576 irel
->r_offset
= (irel
->r_offset
& ~((bfd_vma
) 0x3)) + 1;
580 /* We can't put a trampoline in a .init/.fini section. Issue
582 if (strcmp (sec
->output_section
->name
, ".init") == 0
583 || strcmp (sec
->output_section
->name
, ".fini") == 0)
586 /* xgettext:c-format */
587 (_("%B: Can't relax br at 0x%lx in section `%A'. Please use brl or indirect branch."),
588 sec
->owner
, sec
, (unsigned long) roff
);
589 bfd_set_error (bfd_error_bad_value
);
593 /* If the branch and target are in the same section, you've
594 got one honking big section and we can't help you unless
595 you are branching backwards. You'll get an error message
597 if (tsec
== sec
&& toff
> roff
)
600 /* Look for an existing fixup to this address. */
601 for (f
= fixups
; f
; f
= f
->next
)
602 if (f
->tsec
== tsec
&& f
->toff
== toff
)
607 /* Two alternatives: If it's a branch to a PLT entry, we can
608 make a copy of the FULL_PLT entry. Otherwise, we'll have
609 to use a `brl' insn to get where we're going. */
613 if (tsec
== ia64_info
->root
.splt
)
614 size
= sizeof (plt_full_entry
);
616 size
= sizeof (oor_brl
);
618 /* Resize the current section to make room for the new branch. */
619 trampoff
= (sec
->size
+ 15) & (bfd_vma
) -16;
621 /* If trampoline is out of range, there is nothing we
623 offset
= trampoff
- (roff
& (bfd_vma
) -4);
624 if (offset
< -0x1000000 || offset
> 0x0FFFFF0)
627 amt
= trampoff
+ size
;
628 contents
= (bfd_byte
*) bfd_realloc (contents
, amt
);
629 if (contents
== NULL
)
633 if (tsec
== ia64_info
->root
.splt
)
635 memcpy (contents
+ trampoff
, plt_full_entry
, size
);
637 /* Hijack the old relocation for use as the PLTOFF reloc. */
638 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
640 irel
->r_offset
= trampoff
;
644 memcpy (contents
+ trampoff
, oor_brl
, size
);
645 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
647 irel
->r_offset
= trampoff
+ 2;
650 /* Record the fixup so we don't do it again this section. */
651 f
= (struct one_fixup
*)
652 bfd_malloc ((bfd_size_type
) sizeof (*f
));
656 f
->trampoff
= trampoff
;
661 /* If trampoline is out of range, there is nothing we
663 offset
= f
->trampoff
- (roff
& (bfd_vma
) -4);
664 if (offset
< -0x1000000 || offset
> 0x0FFFFF0)
667 /* Nop out the reloc, since we're finalizing things here. */
668 irel
->r_info
= ELF64_R_INFO (0, R_IA64_NONE
);
671 /* Fix up the existing branch to hit the trampoline. */
672 if (ia64_elf_install_value (contents
+ roff
, offset
, r_type
)
676 changed_contents
= TRUE
;
677 changed_relocs
= TRUE
;
684 bfd
*obfd
= sec
->output_section
->owner
;
685 gp
= _bfd_get_gp_value (obfd
);
688 if (!elf64_ia64_choose_gp (obfd
, link_info
, FALSE
))
690 gp
= _bfd_get_gp_value (obfd
);
694 /* If the data is out of range, do nothing. */
695 if ((bfd_signed_vma
) (symaddr
- gp
) >= 0x200000
696 ||(bfd_signed_vma
) (symaddr
- gp
) < -0x200000)
699 if (r_type
== R_IA64_GPREL22
)
700 elf64_ia64_update_short_info (tsec
->output_section
,
701 tsec
->output_offset
+ toff
,
703 else if (r_type
== R_IA64_LTOFF22X
)
705 /* Can't deal yet correctly with ABS symbols. */
706 if (bfd_is_abs_section (tsec
))
709 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
711 changed_relocs
= TRUE
;
713 elf64_ia64_update_short_info (tsec
->output_section
,
714 tsec
->output_offset
+ toff
,
719 ia64_elf_relax_ldxmov (contents
, roff
);
720 irel
->r_info
= ELF64_R_INFO (0, R_IA64_NONE
);
721 changed_contents
= TRUE
;
722 changed_relocs
= TRUE
;
727 /* ??? If we created fixups, this may push the code segment large
728 enough that the data segment moves, which will change the GP.
729 Reset the GP so that we re-calculate next round. We need to
730 do this at the _beginning_ of the next round; now will not do. */
732 /* Clean up and go home. */
735 struct one_fixup
*f
= fixups
;
736 fixups
= fixups
->next
;
741 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
743 if (! link_info
->keep_memory
)
747 /* Cache the symbols for elf_link_input_bfd. */
748 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
753 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
755 if (!changed_contents
&& !link_info
->keep_memory
)
759 /* Cache the section contents for elf_link_input_bfd. */
760 elf_section_data (sec
)->this_hdr
.contents
= contents
;
764 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
767 free (internal_relocs
);
769 elf_section_data (sec
)->relocs
= internal_relocs
;
772 if (link_info
->relax_pass
== 0)
774 /* Pass 0 is only needed to relax br. */
775 sec
->skip_relax_pass_0
= skip_relax_pass_0
;
776 sec
->skip_relax_pass_1
= skip_relax_pass_1
;
779 *again
= changed_contents
|| changed_relocs
;
783 if (isymbuf
!= NULL
&& (unsigned char *) isymbuf
!= symtab_hdr
->contents
)
786 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
788 if (internal_relocs
!= NULL
789 && elf_section_data (sec
)->relocs
!= internal_relocs
)
790 free (internal_relocs
);
793 #undef skip_relax_pass_0
794 #undef skip_relax_pass_1
796 /* Return TRUE if NAME is an unwind table section name. */
798 static inline bfd_boolean
799 is_unwind_section_name (bfd
*abfd ATTRIBUTE_UNUSED
, const char *name
)
801 return ((CONST_STRNEQ (name
, ELF_STRING_ia64_unwind
)
802 && ! CONST_STRNEQ (name
, ELF_STRING_ia64_unwind_info
))
803 || CONST_STRNEQ (name
, ELF_STRING_ia64_unwind_once
));
807 /* Convert IA-64 specific section flags to bfd internal section flags. */
809 /* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
813 elf64_ia64_section_flags (flagword
*flags
,
814 const Elf_Internal_Shdr
*hdr
)
816 if (hdr
->sh_flags
& SHF_IA_64_SHORT
)
817 *flags
|= SEC_SMALL_DATA
;
822 /* Set the correct type for an IA-64 ELF section. We do this by the
823 section name, which is a hack, but ought to work. */
826 elf64_ia64_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
831 name
= bfd_get_section_name (abfd
, sec
);
833 if (is_unwind_section_name (abfd
, name
))
835 /* We don't have the sections numbered at this point, so sh_info
836 is set later, in elf64_ia64_final_write_processing. */
837 hdr
->sh_type
= SHT_IA_64_UNWIND
;
838 hdr
->sh_flags
|= SHF_LINK_ORDER
;
840 else if (strcmp (name
, ELF_STRING_ia64_archext
) == 0)
841 hdr
->sh_type
= SHT_IA_64_EXT
;
843 if (sec
->flags
& SEC_SMALL_DATA
)
844 hdr
->sh_flags
|= SHF_IA_64_SHORT
;
849 /* Hook called by the linker routine which adds symbols from an object
850 file. We use it to put .comm items in .sbss, and not .bss. */
853 elf64_ia64_add_symbol_hook (bfd
*abfd
,
854 struct bfd_link_info
*info
,
855 Elf_Internal_Sym
*sym
,
856 const char **namep ATTRIBUTE_UNUSED
,
857 flagword
*flagsp ATTRIBUTE_UNUSED
,
861 if (sym
->st_shndx
== SHN_COMMON
862 && !bfd_link_relocatable (info
)
863 && sym
->st_size
<= elf_gp_size (abfd
))
865 /* Common symbols less than or equal to -G nn bytes are
866 automatically put into .sbss. */
868 asection
*scomm
= bfd_get_section_by_name (abfd
, ".scommon");
872 scomm
= bfd_make_section_with_flags (abfd
, ".scommon",
875 | SEC_LINKER_CREATED
));
881 *valp
= sym
->st_size
;
887 /* According to the Tahoe assembler spec, all labels starting with a
891 elf64_ia64_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
894 return name
[0] == '.';
897 /* Should we do dynamic things to this symbol? */
900 elf64_ia64_dynamic_symbol_p (struct elf_link_hash_entry
*h
)
902 return h
!= NULL
&& h
->def_dynamic
;
905 static struct bfd_hash_entry
*
906 elf64_ia64_new_elf_hash_entry (struct bfd_hash_entry
*entry
,
907 struct bfd_hash_table
*table
,
910 struct elf64_ia64_link_hash_entry
*ret
;
911 ret
= (struct elf64_ia64_link_hash_entry
*) entry
;
913 /* Allocate the structure if it has not already been allocated by a
916 ret
= bfd_hash_allocate (table
, sizeof (*ret
));
921 /* Call the allocation method of the superclass. */
922 ret
= ((struct elf64_ia64_link_hash_entry
*)
923 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
928 ret
->sorted_count
= 0;
930 return (struct bfd_hash_entry
*) ret
;
934 elf64_ia64_hash_hide_symbol (struct bfd_link_info
*info
,
935 struct elf_link_hash_entry
*xh
,
936 bfd_boolean force_local
)
938 struct elf64_ia64_link_hash_entry
*h
;
939 struct elf64_ia64_dyn_sym_info
*dyn_i
;
942 h
= (struct elf64_ia64_link_hash_entry
*)xh
;
944 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
946 for (count
= h
->count
, dyn_i
= h
->info
;
950 dyn_i
->want_plt2
= 0;
955 /* Compute a hash of a local hash entry. */
958 elf64_ia64_local_htab_hash (const void *ptr
)
960 struct elf64_ia64_local_hash_entry
*entry
961 = (struct elf64_ia64_local_hash_entry
*) ptr
;
963 return ELF_LOCAL_SYMBOL_HASH (entry
->id
, entry
->r_sym
);
966 /* Compare local hash entries. */
969 elf64_ia64_local_htab_eq (const void *ptr1
, const void *ptr2
)
971 struct elf64_ia64_local_hash_entry
*entry1
972 = (struct elf64_ia64_local_hash_entry
*) ptr1
;
973 struct elf64_ia64_local_hash_entry
*entry2
974 = (struct elf64_ia64_local_hash_entry
*) ptr2
;
976 return entry1
->id
== entry2
->id
&& entry1
->r_sym
== entry2
->r_sym
;
979 /* Free the global elf64_ia64_dyn_sym_info array. */
982 elf64_ia64_global_dyn_info_free (void **xentry
,
983 void * unused ATTRIBUTE_UNUSED
)
985 struct elf64_ia64_link_hash_entry
*entry
986 = (struct elf64_ia64_link_hash_entry
*) xentry
;
988 if (entry
->root
.root
.type
== bfd_link_hash_warning
)
989 entry
= (struct elf64_ia64_link_hash_entry
*) entry
->root
.root
.u
.i
.link
;
996 entry
->sorted_count
= 0;
1003 /* Free the local elf64_ia64_dyn_sym_info array. */
1006 elf64_ia64_local_dyn_info_free (void **slot
,
1007 void * unused ATTRIBUTE_UNUSED
)
1009 struct elf64_ia64_local_hash_entry
*entry
1010 = (struct elf64_ia64_local_hash_entry
*) *slot
;
1017 entry
->sorted_count
= 0;
1024 /* Destroy IA-64 linker hash table. */
1027 elf64_ia64_link_hash_table_free (bfd
*obfd
)
1029 struct elf64_ia64_link_hash_table
*ia64_info
1030 = (struct elf64_ia64_link_hash_table
*) obfd
->link
.hash
;
1031 if (ia64_info
->loc_hash_table
)
1033 htab_traverse (ia64_info
->loc_hash_table
,
1034 elf64_ia64_local_dyn_info_free
, NULL
);
1035 htab_delete (ia64_info
->loc_hash_table
);
1037 if (ia64_info
->loc_hash_memory
)
1038 objalloc_free ((struct objalloc
*) ia64_info
->loc_hash_memory
);
1039 elf_link_hash_traverse (&ia64_info
->root
,
1040 elf64_ia64_global_dyn_info_free
, NULL
);
1041 _bfd_elf_link_hash_table_free (obfd
);
1044 /* Create the derived linker hash table. The IA-64 ELF port uses this
1045 derived hash table to keep information specific to the IA-64 ElF
1046 linker (without using static variables). */
1048 static struct bfd_link_hash_table
*
1049 elf64_ia64_hash_table_create (bfd
*abfd
)
1051 struct elf64_ia64_link_hash_table
*ret
;
1053 ret
= bfd_zmalloc ((bfd_size_type
) sizeof (*ret
));
1057 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
1058 elf64_ia64_new_elf_hash_entry
,
1059 sizeof (struct elf64_ia64_link_hash_entry
),
1066 ret
->loc_hash_table
= htab_try_create (1024, elf64_ia64_local_htab_hash
,
1067 elf64_ia64_local_htab_eq
, NULL
);
1068 ret
->loc_hash_memory
= objalloc_create ();
1069 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1071 elf64_ia64_link_hash_table_free (abfd
);
1074 ret
->root
.root
.hash_table_free
= elf64_ia64_link_hash_table_free
;
1076 return &ret
->root
.root
;
1079 /* Traverse both local and global hash tables. */
1081 struct elf64_ia64_dyn_sym_traverse_data
1083 bfd_boolean (*func
) (struct elf64_ia64_dyn_sym_info
*, void *);
1088 elf64_ia64_global_dyn_sym_thunk (struct bfd_hash_entry
*xentry
,
1091 struct elf64_ia64_link_hash_entry
*entry
1092 = (struct elf64_ia64_link_hash_entry
*) xentry
;
1093 struct elf64_ia64_dyn_sym_traverse_data
*data
1094 = (struct elf64_ia64_dyn_sym_traverse_data
*) xdata
;
1095 struct elf64_ia64_dyn_sym_info
*dyn_i
;
1098 if (entry
->root
.root
.type
== bfd_link_hash_warning
)
1099 entry
= (struct elf64_ia64_link_hash_entry
*) entry
->root
.root
.u
.i
.link
;
1101 for (count
= entry
->count
, dyn_i
= entry
->info
;
1104 if (! (*data
->func
) (dyn_i
, data
->data
))
1110 elf64_ia64_local_dyn_sym_thunk (void **slot
, void * xdata
)
1112 struct elf64_ia64_local_hash_entry
*entry
1113 = (struct elf64_ia64_local_hash_entry
*) *slot
;
1114 struct elf64_ia64_dyn_sym_traverse_data
*data
1115 = (struct elf64_ia64_dyn_sym_traverse_data
*) xdata
;
1116 struct elf64_ia64_dyn_sym_info
*dyn_i
;
1119 for (count
= entry
->count
, dyn_i
= entry
->info
;
1122 if (! (*data
->func
) (dyn_i
, data
->data
))
1128 elf64_ia64_dyn_sym_traverse (struct elf64_ia64_link_hash_table
*ia64_info
,
1129 bfd_boolean (*func
) (struct elf64_ia64_dyn_sym_info
*, void *),
1132 struct elf64_ia64_dyn_sym_traverse_data xdata
;
1137 elf_link_hash_traverse (&ia64_info
->root
,
1138 elf64_ia64_global_dyn_sym_thunk
, &xdata
);
1139 htab_traverse (ia64_info
->loc_hash_table
,
1140 elf64_ia64_local_dyn_sym_thunk
, &xdata
);
1143 #define NOTE_NAME "IPF/VMS"
1146 create_ia64_vms_notes (bfd
*abfd
, struct bfd_link_info
*info
,
1147 unsigned int time_hi
, unsigned int time_lo
)
1150 Elf_Internal_Note notes
[NBR_NOTES
];
1152 int module_name_len
;
1153 unsigned char cur_time
[8];
1154 Elf64_External_VMS_ORIG_DYN_Note
*orig_dyn
;
1155 unsigned int orig_dyn_size
;
1156 unsigned int note_size
;
1158 unsigned char *noteptr
;
1159 unsigned char *note_contents
;
1160 struct elf64_ia64_link_hash_table
*ia64_info
;
1162 ia64_info
= elf64_ia64_hash_table (info
);
1164 module_name
= vms_get_module_name (bfd_get_filename (abfd
), TRUE
);
1165 module_name_len
= strlen (module_name
) + 1;
1167 bfd_putl32 (time_lo
, cur_time
+ 0);
1168 bfd_putl32 (time_hi
, cur_time
+ 4);
1170 /* Note 0: IMGNAM. */
1171 notes
[0].type
= NT_VMS_IMGNAM
;
1172 notes
[0].descdata
= module_name
;
1173 notes
[0].descsz
= module_name_len
;
1175 /* Note 1: GSTNAM. */
1176 notes
[1].type
= NT_VMS_GSTNAM
;
1177 notes
[1].descdata
= module_name
;
1178 notes
[1].descsz
= module_name_len
;
1180 /* Note 2: IMGID. */
1181 #define IMG_ID "V1.0"
1182 notes
[2].type
= NT_VMS_IMGID
;
1183 notes
[2].descdata
= IMG_ID
;
1184 notes
[2].descsz
= sizeof (IMG_ID
);
1186 /* Note 3: Linktime. */
1187 notes
[3].type
= NT_VMS_LINKTIME
;
1188 notes
[3].descdata
= (char *)cur_time
;
1189 notes
[3].descsz
= sizeof (cur_time
);
1191 /* Note 4: Linker id. */
1192 notes
[4].type
= NT_VMS_LINKID
;
1193 notes
[4].descdata
= "GNU ld " BFD_VERSION_STRING
;
1194 notes
[4].descsz
= strlen (notes
[4].descdata
) + 1;
1196 /* Note 5: Original dyn. */
1197 orig_dyn_size
= (sizeof (*orig_dyn
) + sizeof (IMG_ID
) - 1 + 7) & ~7;
1198 orig_dyn
= bfd_zalloc (abfd
, orig_dyn_size
);
1199 if (orig_dyn
== NULL
)
1201 bfd_putl32 (1, orig_dyn
->major_id
);
1202 bfd_putl32 (3, orig_dyn
->minor_id
);
1203 memcpy (orig_dyn
->manipulation_date
, cur_time
, sizeof (cur_time
));
1204 bfd_putl64 (VMS_LF_IMGSTA
| VMS_LF_MAIN
, orig_dyn
->link_flags
);
1205 bfd_putl32 (EF_IA_64_ABI64
, orig_dyn
->elf_flags
);
1206 memcpy (orig_dyn
->imgid
, IMG_ID
, sizeof (IMG_ID
));
1207 notes
[5].type
= NT_VMS_ORIG_DYN
;
1208 notes
[5].descdata
= (char *)orig_dyn
;
1209 notes
[5].descsz
= orig_dyn_size
;
1211 /* Note 3: Patchtime. */
1212 notes
[6].type
= NT_VMS_PATCHTIME
;
1213 notes
[6].descdata
= (char *)cur_time
;
1214 notes
[6].descsz
= sizeof (cur_time
);
1216 /* Compute notes size. */
1218 for (i
= 0; i
< NBR_NOTES
; i
++)
1219 note_size
+= sizeof (Elf64_External_VMS_Note
) - 1
1220 + ((sizeof (NOTE_NAME
) - 1 + 7) & ~7)
1221 + ((notes
[i
].descsz
+ 7) & ~7);
1223 /* Malloc a temporary buffer large enough for most notes */
1224 note_contents
= (unsigned char *) bfd_zalloc (abfd
, note_size
);
1225 if (note_contents
== NULL
)
1227 noteptr
= note_contents
;
1230 for (i
= 0; i
< NBR_NOTES
; i
++)
1232 Elf64_External_VMS_Note
*enote
= (Elf64_External_VMS_Note
*) noteptr
;
1234 bfd_putl64 (sizeof (NOTE_NAME
) - 1, enote
->namesz
);
1235 bfd_putl64 (notes
[i
].descsz
, enote
->descsz
);
1236 bfd_putl64 (notes
[i
].type
, enote
->type
);
1238 noteptr
= (unsigned char *)enote
->name
;
1239 memcpy (noteptr
, NOTE_NAME
, sizeof (NOTE_NAME
) - 1);
1240 noteptr
+= (sizeof (NOTE_NAME
) - 1 + 7) & ~7;
1241 memcpy (noteptr
, notes
[i
].descdata
, notes
[i
].descsz
);
1242 noteptr
+= (notes
[i
].descsz
+ 7) & ~7;
1245 ia64_info
->note_sec
->contents
= note_contents
;
1246 ia64_info
->note_sec
->size
= note_size
;
1254 elf64_ia64_create_dynamic_sections (bfd
*abfd
,
1255 struct bfd_link_info
*info
)
1257 struct elf64_ia64_link_hash_table
*ia64_info
;
1260 const struct elf_backend_data
*bed
;
1262 ia64_info
= elf64_ia64_hash_table (info
);
1263 if (ia64_info
== NULL
)
1266 if (elf_hash_table (info
)->dynamic_sections_created
)
1269 abfd
= elf_hash_table (info
)->dynobj
;
1270 bed
= get_elf_backend_data (abfd
);
1272 flags
= bed
->dynamic_sec_flags
;
1274 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynamic",
1275 flags
| SEC_READONLY
);
1277 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
1280 s
= bfd_make_section_anyway_with_flags (abfd
, ".plt", flags
| SEC_READONLY
);
1282 || ! bfd_set_section_alignment (abfd
, s
, bed
->plt_alignment
))
1284 ia64_info
->root
.splt
= s
;
1286 if (!get_got (abfd
, ia64_info
))
1289 if (!get_pltoff (abfd
, ia64_info
))
1292 s
= bfd_make_section_anyway_with_flags (abfd
, ".vmsdynstr",
1296 | SEC_LINKER_CREATED
));
1298 || !bfd_set_section_alignment (abfd
, s
, 0))
1301 /* Create a fixup section. */
1302 s
= bfd_make_section_anyway_with_flags (abfd
, ".fixups",
1306 | SEC_LINKER_CREATED
));
1308 || !bfd_set_section_alignment (abfd
, s
, 3))
1310 ia64_info
->fixups_sec
= s
;
1312 /* Create the transfer fixup section. */
1313 s
= bfd_make_section_anyway_with_flags (abfd
, ".transfer",
1317 | SEC_LINKER_CREATED
));
1319 || !bfd_set_section_alignment (abfd
, s
, 3))
1321 s
->size
= sizeof (struct elf64_vms_transfer
);
1322 ia64_info
->transfer_sec
= s
;
1324 /* Create note section. */
1325 s
= bfd_make_section_anyway_with_flags (abfd
, ".vms.note",
1331 || !bfd_set_section_alignment (abfd
, s
, 3))
1333 ia64_info
->note_sec
= s
;
1335 elf_hash_table (info
)->dynamic_sections_created
= TRUE
;
1339 /* Find and/or create a hash entry for local symbol. */
1340 static struct elf64_ia64_local_hash_entry
*
1341 get_local_sym_hash (struct elf64_ia64_link_hash_table
*ia64_info
,
1342 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
1345 struct elf64_ia64_local_hash_entry e
, *ret
;
1346 asection
*sec
= abfd
->sections
;
1347 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
1348 ELF64_R_SYM (rel
->r_info
));
1352 e
.r_sym
= ELF64_R_SYM (rel
->r_info
);
1353 slot
= htab_find_slot_with_hash (ia64_info
->loc_hash_table
, &e
, h
,
1354 create
? INSERT
: NO_INSERT
);
1360 return (struct elf64_ia64_local_hash_entry
*) *slot
;
1362 ret
= (struct elf64_ia64_local_hash_entry
*)
1363 objalloc_alloc ((struct objalloc
*) ia64_info
->loc_hash_memory
,
1364 sizeof (struct elf64_ia64_local_hash_entry
));
1367 memset (ret
, 0, sizeof (*ret
));
1369 ret
->r_sym
= ELF64_R_SYM (rel
->r_info
);
1375 /* Used to sort elf64_ia64_dyn_sym_info array. */
1378 addend_compare (const void *xp
, const void *yp
)
1380 const struct elf64_ia64_dyn_sym_info
*x
1381 = (const struct elf64_ia64_dyn_sym_info
*) xp
;
1382 const struct elf64_ia64_dyn_sym_info
*y
1383 = (const struct elf64_ia64_dyn_sym_info
*) yp
;
1385 return x
->addend
< y
->addend
? -1 : x
->addend
> y
->addend
? 1 : 0;
1388 /* Sort elf64_ia64_dyn_sym_info array and remove duplicates. */
1391 sort_dyn_sym_info (struct elf64_ia64_dyn_sym_info
*info
,
1394 bfd_vma curr
, prev
, got_offset
;
1395 unsigned int i
, kept
, dupes
, diff
, dest
, src
, len
;
1397 qsort (info
, count
, sizeof (*info
), addend_compare
);
1399 /* Find the first duplicate. */
1400 prev
= info
[0].addend
;
1401 got_offset
= info
[0].got_offset
;
1402 for (i
= 1; i
< count
; i
++)
1404 curr
= info
[i
].addend
;
1407 /* For duplicates, make sure that GOT_OFFSET is valid. */
1408 if (got_offset
== (bfd_vma
) -1)
1409 got_offset
= info
[i
].got_offset
;
1412 got_offset
= info
[i
].got_offset
;
1416 /* We may move a block of elements to here. */
1419 /* Remove duplicates. */
1424 /* For duplicates, make sure that the kept one has a valid
1427 if (got_offset
!= (bfd_vma
) -1)
1428 info
[kept
].got_offset
= got_offset
;
1430 curr
= info
[i
].addend
;
1431 got_offset
= info
[i
].got_offset
;
1433 /* Move a block of elements whose first one is different from
1437 for (src
= i
+ 1; src
< count
; src
++)
1439 if (info
[src
].addend
!= curr
)
1441 /* For duplicates, make sure that GOT_OFFSET is
1443 if (got_offset
== (bfd_vma
) -1)
1444 got_offset
= info
[src
].got_offset
;
1447 /* Make sure that the kept one has a valid got_offset. */
1448 if (got_offset
!= (bfd_vma
) -1)
1449 info
[kept
].got_offset
= got_offset
;
1457 /* Find the next duplicate. SRC will be kept. */
1458 prev
= info
[src
].addend
;
1459 got_offset
= info
[src
].got_offset
;
1460 for (dupes
= src
+ 1; dupes
< count
; dupes
++)
1462 curr
= info
[dupes
].addend
;
1465 /* Make sure that got_offset is valid. */
1466 if (got_offset
== (bfd_vma
) -1)
1467 got_offset
= info
[dupes
].got_offset
;
1469 /* For duplicates, make sure that the kept one has
1470 a valid got_offset. */
1471 if (got_offset
!= (bfd_vma
) -1)
1472 info
[dupes
- 1].got_offset
= got_offset
;
1475 got_offset
= info
[dupes
].got_offset
;
1479 /* How much to move. */
1483 if (len
== 1 && dupes
< count
)
1485 /* If we only move 1 element, we combine it with the next
1486 one. There must be at least a duplicate. Find the
1487 next different one. */
1488 for (diff
= dupes
+ 1, src
++; diff
< count
; diff
++, src
++)
1490 if (info
[diff
].addend
!= curr
)
1492 /* Make sure that got_offset is valid. */
1493 if (got_offset
== (bfd_vma
) -1)
1494 got_offset
= info
[diff
].got_offset
;
1497 /* Makre sure that the last duplicated one has an valid
1499 BFD_ASSERT (curr
== prev
);
1500 if (got_offset
!= (bfd_vma
) -1)
1501 info
[diff
- 1].got_offset
= got_offset
;
1505 /* Find the next duplicate. Track the current valid
1507 prev
= info
[diff
].addend
;
1508 got_offset
= info
[diff
].got_offset
;
1509 for (dupes
= diff
+ 1; dupes
< count
; dupes
++)
1511 curr
= info
[dupes
].addend
;
1514 /* For duplicates, make sure that GOT_OFFSET
1516 if (got_offset
== (bfd_vma
) -1)
1517 got_offset
= info
[dupes
].got_offset
;
1520 got_offset
= info
[dupes
].got_offset
;
1525 len
= diff
- src
+ 1;
1530 memmove (&info
[dest
], &info
[src
], len
* sizeof (*info
));
1539 /* When we get here, either there is no duplicate at all or
1540 the only duplicate is the last element. */
1543 /* If the last element is a duplicate, make sure that the
1544 kept one has a valid got_offset. We also update count. */
1545 if (got_offset
!= (bfd_vma
) -1)
1546 info
[dest
- 1].got_offset
= got_offset
;
1554 /* Find and/or create a descriptor for dynamic symbol info. This will
1555 vary based on global or local symbol, and the addend to the reloc.
1557 We don't sort when inserting. Also, we sort and eliminate
1558 duplicates if there is an unsorted section. Typically, this will
1559 only happen once, because we do all insertions before lookups. We
1560 then use bsearch to do a lookup. This also allows lookups to be
1561 fast. So we have fast insertion (O(log N) due to duplicate check),
1562 fast lookup (O(log N)) and one sort (O(N log N) expected time).
1563 Previously, all lookups were O(N) because of the use of the linked
1564 list and also all insertions were O(N) because of the check for
1565 duplicates. There are some complications here because the array
1566 size grows occasionally, which may add an O(N) factor, but this
1567 should be rare. Also, we free the excess array allocation, which
1568 requires a copy which is O(N), but this only happens once. */
1570 static struct elf64_ia64_dyn_sym_info
*
1571 get_dyn_sym_info (struct elf64_ia64_link_hash_table
*ia64_info
,
1572 struct elf_link_hash_entry
*h
, bfd
*abfd
,
1573 const Elf_Internal_Rela
*rel
, bfd_boolean create
)
1575 struct elf64_ia64_dyn_sym_info
**info_p
, *info
, *dyn_i
, key
;
1576 unsigned int *count_p
, *sorted_count_p
, *size_p
;
1577 unsigned int count
, sorted_count
, size
;
1578 bfd_vma addend
= rel
? rel
->r_addend
: 0;
1583 struct elf64_ia64_link_hash_entry
*global_h
;
1585 global_h
= (struct elf64_ia64_link_hash_entry
*) h
;
1586 info_p
= &global_h
->info
;
1587 count_p
= &global_h
->count
;
1588 sorted_count_p
= &global_h
->sorted_count
;
1589 size_p
= &global_h
->size
;
1593 struct elf64_ia64_local_hash_entry
*loc_h
;
1595 loc_h
= get_local_sym_hash (ia64_info
, abfd
, rel
, create
);
1598 BFD_ASSERT (!create
);
1602 info_p
= &loc_h
->info
;
1603 count_p
= &loc_h
->count
;
1604 sorted_count_p
= &loc_h
->sorted_count
;
1605 size_p
= &loc_h
->size
;
1609 sorted_count
= *sorted_count_p
;
1614 /* When we create the array, we don't check for duplicates,
1615 except in the previously sorted section if one exists, and
1616 against the last inserted entry. This allows insertions to
1622 /* Try bsearch first on the sorted section. */
1623 key
.addend
= addend
;
1624 dyn_i
= bsearch (&key
, info
, sorted_count
,
1625 sizeof (*info
), addend_compare
);
1633 /* Do a quick check for the last inserted entry. */
1634 dyn_i
= info
+ count
- 1;
1635 if (dyn_i
->addend
== addend
)
1643 /* It is the very first element. We create the array of size
1646 amt
= size
* sizeof (*info
);
1647 info
= bfd_malloc (amt
);
1649 else if (size
<= count
)
1651 /* We double the array size every time when we reach the
1654 amt
= size
* sizeof (*info
);
1655 info
= bfd_realloc (info
, amt
);
1666 /* Append the new one to the array. */
1667 dyn_i
= info
+ count
;
1668 memset (dyn_i
, 0, sizeof (*dyn_i
));
1669 dyn_i
->got_offset
= (bfd_vma
) -1;
1670 dyn_i
->addend
= addend
;
1672 /* We increment count only since the new ones are unsorted and
1673 may have duplicate. */
1678 /* It is a lookup without insertion. Sort array if part of the
1679 array isn't sorted. */
1680 if (count
!= sorted_count
)
1682 count
= sort_dyn_sym_info (info
, count
);
1684 *sorted_count_p
= count
;
1687 /* Free unused memory. */
1690 amt
= count
* sizeof (*info
);
1691 info
= bfd_malloc (amt
);
1694 memcpy (info
, *info_p
, amt
);
1701 key
.addend
= addend
;
1702 dyn_i
= bsearch (&key
, info
, count
,
1703 sizeof (*info
), addend_compare
);
1710 get_got (bfd
*abfd
, struct elf64_ia64_link_hash_table
*ia64_info
)
1715 got
= ia64_info
->root
.sgot
;
1720 dynobj
= ia64_info
->root
.dynobj
;
1722 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1724 /* The .got section is always aligned at 8 bytes. */
1725 flags
= get_elf_backend_data (dynobj
)->dynamic_sec_flags
;
1726 got
= bfd_make_section_anyway_with_flags (dynobj
, ".got",
1727 flags
| SEC_SMALL_DATA
);
1729 || !bfd_set_section_alignment (dynobj
, got
, 3))
1731 ia64_info
->root
.sgot
= got
;
1737 /* Create function descriptor section (.opd). This section is called .opd
1738 because it contains "official procedure descriptors". The "official"
1739 refers to the fact that these descriptors are used when taking the address
1740 of a procedure, thus ensuring a unique address for each procedure. */
1743 get_fptr (bfd
*abfd
, struct bfd_link_info
*info
,
1744 struct elf64_ia64_link_hash_table
*ia64_info
)
1749 fptr
= ia64_info
->fptr_sec
;
1752 dynobj
= ia64_info
->root
.dynobj
;
1754 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1756 fptr
= bfd_make_section_anyway_with_flags (dynobj
, ".opd",
1761 | (bfd_link_pie (info
) ? 0
1763 | SEC_LINKER_CREATED
));
1765 || !bfd_set_section_alignment (dynobj
, fptr
, 4))
1771 ia64_info
->fptr_sec
= fptr
;
1773 if (bfd_link_pie (info
))
1776 fptr_rel
= bfd_make_section_anyway_with_flags (dynobj
, ".rela.opd",
1777 (SEC_ALLOC
| SEC_LOAD
1780 | SEC_LINKER_CREATED
1782 if (fptr_rel
== NULL
1783 || !bfd_set_section_alignment (dynobj
, fptr_rel
, 3))
1789 ia64_info
->rel_fptr_sec
= fptr_rel
;
1797 get_pltoff (bfd
*abfd
, struct elf64_ia64_link_hash_table
*ia64_info
)
1802 pltoff
= ia64_info
->pltoff_sec
;
1805 dynobj
= ia64_info
->root
.dynobj
;
1807 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1809 pltoff
= bfd_make_section_anyway_with_flags (dynobj
,
1810 ELF_STRING_ia64_pltoff
,
1816 | SEC_LINKER_CREATED
));
1818 || !bfd_set_section_alignment (dynobj
, pltoff
, 4))
1824 ia64_info
->pltoff_sec
= pltoff
;
1831 get_reloc_section (bfd
*abfd
,
1832 struct elf64_ia64_link_hash_table
*ia64_info
,
1833 asection
*sec
, bfd_boolean create
)
1835 const char *srel_name
;
1839 srel_name
= (bfd_elf_string_from_elf_section
1840 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
1841 _bfd_elf_single_rel_hdr (sec
)->sh_name
));
1842 if (srel_name
== NULL
)
1845 BFD_ASSERT ((CONST_STRNEQ (srel_name
, ".rela")
1846 && strcmp (bfd_get_section_name (abfd
, sec
),
1848 || (CONST_STRNEQ (srel_name
, ".rel")
1849 && strcmp (bfd_get_section_name (abfd
, sec
),
1850 srel_name
+4) == 0));
1852 dynobj
= ia64_info
->root
.dynobj
;
1854 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1856 srel
= bfd_get_linker_section (dynobj
, srel_name
);
1857 if (srel
== NULL
&& create
)
1859 srel
= bfd_make_section_anyway_with_flags (dynobj
, srel_name
,
1860 (SEC_ALLOC
| SEC_LOAD
1863 | SEC_LINKER_CREATED
1866 || !bfd_set_section_alignment (dynobj
, srel
, 3))
1874 count_dyn_reloc (bfd
*abfd
, struct elf64_ia64_dyn_sym_info
*dyn_i
,
1875 asection
*srel
, int type
)
1877 struct elf64_ia64_dyn_reloc_entry
*rent
;
1879 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
1880 if (rent
->srel
== srel
&& rent
->type
== type
)
1885 rent
= ((struct elf64_ia64_dyn_reloc_entry
*)
1886 bfd_alloc (abfd
, (bfd_size_type
) sizeof (*rent
)));
1890 rent
->next
= dyn_i
->reloc_entries
;
1894 dyn_i
->reloc_entries
= rent
;
1902 elf64_ia64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
1904 const Elf_Internal_Rela
*relocs
)
1906 struct elf64_ia64_link_hash_table
*ia64_info
;
1907 const Elf_Internal_Rela
*relend
;
1908 Elf_Internal_Shdr
*symtab_hdr
;
1909 const Elf_Internal_Rela
*rel
;
1910 asection
*got
, *fptr
, *srel
, *pltoff
;
1919 NEED_LTOFF_FPTR
= 128
1922 struct elf_link_hash_entry
*h
;
1923 unsigned long r_symndx
;
1924 bfd_boolean maybe_dynamic
;
1926 if (bfd_link_relocatable (info
))
1929 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1930 ia64_info
= elf64_ia64_hash_table (info
);
1931 if (ia64_info
== NULL
)
1934 got
= fptr
= srel
= pltoff
= NULL
;
1936 relend
= relocs
+ sec
->reloc_count
;
1938 /* We scan relocations first to create dynamic relocation arrays. We
1939 modified get_dyn_sym_info to allow fast insertion and support fast
1940 lookup in the next loop. */
1941 for (rel
= relocs
; rel
< relend
; ++rel
)
1943 r_symndx
= ELF64_R_SYM (rel
->r_info
);
1944 if (r_symndx
>= symtab_hdr
->sh_info
)
1946 long indx
= r_symndx
- symtab_hdr
->sh_info
;
1947 h
= elf_sym_hashes (abfd
)[indx
];
1948 while (h
->root
.type
== bfd_link_hash_indirect
1949 || h
->root
.type
== bfd_link_hash_warning
)
1950 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1955 /* We can only get preliminary data on whether a symbol is
1956 locally or externally defined, as not all of the input files
1957 have yet been processed. Do something with what we know, as
1958 this may help reduce memory usage and processing time later. */
1959 maybe_dynamic
= (h
&& ((!bfd_link_executable (info
)
1960 && (!SYMBOLIC_BIND (info
, h
)
1961 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
1963 || h
->root
.type
== bfd_link_hash_defweak
));
1966 switch (ELF64_R_TYPE (rel
->r_info
))
1968 case R_IA64_TPREL64MSB
:
1969 case R_IA64_TPREL64LSB
:
1970 case R_IA64_LTOFF_TPREL22
:
1971 case R_IA64_DTPREL32MSB
:
1972 case R_IA64_DTPREL32LSB
:
1973 case R_IA64_DTPREL64MSB
:
1974 case R_IA64_DTPREL64LSB
:
1975 case R_IA64_LTOFF_DTPREL22
:
1976 case R_IA64_DTPMOD64MSB
:
1977 case R_IA64_DTPMOD64LSB
:
1978 case R_IA64_LTOFF_DTPMOD22
:
1982 case R_IA64_IPLTMSB
:
1983 case R_IA64_IPLTLSB
:
1986 case R_IA64_LTOFF_FPTR22
:
1987 case R_IA64_LTOFF_FPTR64I
:
1988 case R_IA64_LTOFF_FPTR32MSB
:
1989 case R_IA64_LTOFF_FPTR32LSB
:
1990 case R_IA64_LTOFF_FPTR64MSB
:
1991 case R_IA64_LTOFF_FPTR64LSB
:
1992 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
1995 case R_IA64_FPTR64I
:
1996 case R_IA64_FPTR32MSB
:
1997 case R_IA64_FPTR32LSB
:
1998 case R_IA64_FPTR64MSB
:
1999 case R_IA64_FPTR64LSB
:
2000 if (bfd_link_pic (info
) || h
)
2001 need_entry
= NEED_FPTR
| NEED_DYNREL
;
2003 need_entry
= NEED_FPTR
;
2006 case R_IA64_LTOFF22
:
2007 case R_IA64_LTOFF64I
:
2008 need_entry
= NEED_GOT
;
2011 case R_IA64_LTOFF22X
:
2012 need_entry
= NEED_GOTX
;
2015 case R_IA64_PLTOFF22
:
2016 case R_IA64_PLTOFF64I
:
2017 case R_IA64_PLTOFF64MSB
:
2018 case R_IA64_PLTOFF64LSB
:
2019 need_entry
= NEED_PLTOFF
;
2023 need_entry
|= NEED_MIN_PLT
;
2027 (*info
->callbacks
->warning
)
2028 (info
, _("@pltoff reloc against local symbol"), 0,
2029 abfd
, 0, (bfd_vma
) 0);
2033 case R_IA64_PCREL21B
:
2034 case R_IA64_PCREL60B
:
2035 /* Depending on where this symbol is defined, we may or may not
2036 need a full plt entry. Only skip if we know we'll not need
2037 the entry -- static or symbolic, and the symbol definition
2038 has already been seen. */
2039 if (maybe_dynamic
&& rel
->r_addend
== 0)
2040 need_entry
= NEED_FULL_PLT
;
2046 case R_IA64_DIR32MSB
:
2047 case R_IA64_DIR32LSB
:
2048 case R_IA64_DIR64MSB
:
2049 case R_IA64_DIR64LSB
:
2050 /* Shared objects will always need at least a REL relocation. */
2051 if (bfd_link_pic (info
) || maybe_dynamic
)
2052 need_entry
= NEED_DYNREL
;
2055 case R_IA64_PCREL22
:
2056 case R_IA64_PCREL64I
:
2057 case R_IA64_PCREL32MSB
:
2058 case R_IA64_PCREL32LSB
:
2059 case R_IA64_PCREL64MSB
:
2060 case R_IA64_PCREL64LSB
:
2062 need_entry
= NEED_DYNREL
;
2069 if ((need_entry
& NEED_FPTR
) != 0
2072 (*info
->callbacks
->warning
)
2073 (info
, _("non-zero addend in @fptr reloc"), 0,
2074 abfd
, 0, (bfd_vma
) 0);
2077 if (get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, TRUE
) == NULL
)
2081 /* Now, we only do lookup without insertion, which is very fast
2082 with the modified get_dyn_sym_info. */
2083 for (rel
= relocs
; rel
< relend
; ++rel
)
2085 struct elf64_ia64_dyn_sym_info
*dyn_i
;
2086 int dynrel_type
= R_IA64_NONE
;
2088 r_symndx
= ELF64_R_SYM (rel
->r_info
);
2089 if (r_symndx
>= symtab_hdr
->sh_info
)
2091 /* We're dealing with a global symbol -- find its hash entry
2092 and mark it as being referenced. */
2093 long indx
= r_symndx
- symtab_hdr
->sh_info
;
2094 h
= elf_sym_hashes (abfd
)[indx
];
2095 while (h
->root
.type
== bfd_link_hash_indirect
2096 || h
->root
.type
== bfd_link_hash_warning
)
2097 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2099 /* PR15323, ref flags aren't set for references in the same
2101 h
->root
.non_ir_ref
= 1;
2107 /* We can only get preliminary data on whether a symbol is
2108 locally or externally defined, as not all of the input files
2109 have yet been processed. Do something with what we know, as
2110 this may help reduce memory usage and processing time later. */
2111 maybe_dynamic
= (h
&& ((!bfd_link_executable (info
)
2112 && (!SYMBOLIC_BIND (info
, h
)
2113 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
2115 || h
->root
.type
== bfd_link_hash_defweak
));
2118 switch (ELF64_R_TYPE (rel
->r_info
))
2120 case R_IA64_TPREL64MSB
:
2121 case R_IA64_TPREL64LSB
:
2122 case R_IA64_LTOFF_TPREL22
:
2123 case R_IA64_DTPREL32MSB
:
2124 case R_IA64_DTPREL32LSB
:
2125 case R_IA64_DTPREL64MSB
:
2126 case R_IA64_DTPREL64LSB
:
2127 case R_IA64_LTOFF_DTPREL22
:
2128 case R_IA64_DTPMOD64MSB
:
2129 case R_IA64_DTPMOD64LSB
:
2130 case R_IA64_LTOFF_DTPMOD22
:
2134 case R_IA64_LTOFF_FPTR22
:
2135 case R_IA64_LTOFF_FPTR64I
:
2136 case R_IA64_LTOFF_FPTR32MSB
:
2137 case R_IA64_LTOFF_FPTR32LSB
:
2138 case R_IA64_LTOFF_FPTR64MSB
:
2139 case R_IA64_LTOFF_FPTR64LSB
:
2140 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
2143 case R_IA64_FPTR64I
:
2144 case R_IA64_FPTR32MSB
:
2145 case R_IA64_FPTR32LSB
:
2146 case R_IA64_FPTR64MSB
:
2147 case R_IA64_FPTR64LSB
:
2148 if (bfd_link_pic (info
) || h
)
2149 need_entry
= NEED_FPTR
| NEED_DYNREL
;
2151 need_entry
= NEED_FPTR
;
2152 dynrel_type
= R_IA64_FPTR64LSB
;
2155 case R_IA64_LTOFF22
:
2156 case R_IA64_LTOFF64I
:
2157 need_entry
= NEED_GOT
;
2160 case R_IA64_LTOFF22X
:
2161 need_entry
= NEED_GOTX
;
2164 case R_IA64_PLTOFF22
:
2165 case R_IA64_PLTOFF64I
:
2166 case R_IA64_PLTOFF64MSB
:
2167 case R_IA64_PLTOFF64LSB
:
2168 need_entry
= NEED_PLTOFF
;
2172 need_entry
|= NEED_MIN_PLT
;
2176 case R_IA64_PCREL21B
:
2177 case R_IA64_PCREL60B
:
2178 /* Depending on where this symbol is defined, we may or may not
2179 need a full plt entry. Only skip if we know we'll not need
2180 the entry -- static or symbolic, and the symbol definition
2181 has already been seen. */
2182 if (maybe_dynamic
&& rel
->r_addend
== 0)
2183 need_entry
= NEED_FULL_PLT
;
2189 case R_IA64_DIR32MSB
:
2190 case R_IA64_DIR32LSB
:
2191 case R_IA64_DIR64MSB
:
2192 case R_IA64_DIR64LSB
:
2193 /* Shared objects will always need at least a REL relocation. */
2194 if (bfd_link_pic (info
) || maybe_dynamic
)
2195 need_entry
= NEED_DYNREL
;
2196 dynrel_type
= R_IA64_DIR64LSB
;
2199 case R_IA64_IPLTMSB
:
2200 case R_IA64_IPLTLSB
:
2203 case R_IA64_PCREL22
:
2204 case R_IA64_PCREL64I
:
2205 case R_IA64_PCREL32MSB
:
2206 case R_IA64_PCREL32LSB
:
2207 case R_IA64_PCREL64MSB
:
2208 case R_IA64_PCREL64LSB
:
2210 need_entry
= NEED_DYNREL
;
2211 dynrel_type
= R_IA64_PCREL64LSB
;
2218 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, FALSE
);
2220 /* Record whether or not this is a local symbol. */
2223 /* Create what's needed. */
2224 if (need_entry
& (NEED_GOT
| NEED_GOTX
))
2228 got
= get_got (abfd
, ia64_info
);
2232 if (need_entry
& NEED_GOT
)
2233 dyn_i
->want_got
= 1;
2234 if (need_entry
& NEED_GOTX
)
2235 dyn_i
->want_gotx
= 1;
2237 if (need_entry
& NEED_FPTR
)
2239 /* Create the .opd section. */
2242 fptr
= get_fptr (abfd
, info
, ia64_info
);
2246 dyn_i
->want_fptr
= 1;
2248 if (need_entry
& NEED_LTOFF_FPTR
)
2249 dyn_i
->want_ltoff_fptr
= 1;
2250 if (need_entry
& (NEED_MIN_PLT
| NEED_FULL_PLT
))
2252 if (!ia64_info
->root
.dynobj
)
2253 ia64_info
->root
.dynobj
= abfd
;
2255 dyn_i
->want_plt
= 1;
2257 if (need_entry
& NEED_FULL_PLT
)
2258 dyn_i
->want_plt2
= 1;
2259 if (need_entry
& NEED_PLTOFF
)
2261 /* This is needed here, in case @pltoff is used in a non-shared
2265 pltoff
= get_pltoff (abfd
, ia64_info
);
2270 dyn_i
->want_pltoff
= 1;
2272 if ((need_entry
& NEED_DYNREL
) && (sec
->flags
& SEC_ALLOC
))
2276 srel
= get_reloc_section (abfd
, ia64_info
, sec
, TRUE
);
2280 if (!count_dyn_reloc (abfd
, dyn_i
, srel
, dynrel_type
))
2288 /* For cleanliness, and potentially faster dynamic loading, allocate
2289 external GOT entries first. */
2292 allocate_global_data_got (struct elf64_ia64_dyn_sym_info
*dyn_i
,
2295 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*)data
;
2297 if ((dyn_i
->want_got
|| dyn_i
->want_gotx
)
2298 && ! dyn_i
->want_fptr
2299 && elf64_ia64_dynamic_symbol_p (dyn_i
->h
))
2301 /* GOT entry with FPTR is done by allocate_global_fptr_got. */
2302 dyn_i
->got_offset
= x
->ofs
;
2308 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
2311 allocate_global_fptr_got (struct elf64_ia64_dyn_sym_info
*dyn_i
,
2314 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*)data
;
2318 && elf64_ia64_dynamic_symbol_p (dyn_i
->h
))
2320 dyn_i
->got_offset
= x
->ofs
;
2326 /* Lastly, allocate all the GOT entries for local data. */
2329 allocate_local_got (struct elf64_ia64_dyn_sym_info
*dyn_i
,
2332 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*) data
;
2334 if ((dyn_i
->want_got
|| dyn_i
->want_gotx
)
2335 && !elf64_ia64_dynamic_symbol_p (dyn_i
->h
))
2337 dyn_i
->got_offset
= x
->ofs
;
2343 /* Allocate function descriptors. We can do these for every function
2344 in a main executable that is not exported. */
2347 allocate_fptr (struct elf64_ia64_dyn_sym_info
*dyn_i
, void * data
)
2349 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*) data
;
2351 if (dyn_i
->want_fptr
)
2353 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2356 while (h
->root
.type
== bfd_link_hash_indirect
2357 || h
->root
.type
== bfd_link_hash_warning
)
2358 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2360 if (h
== NULL
|| !h
->def_dynamic
)
2362 /* A non dynamic symbol. */
2363 dyn_i
->fptr_offset
= x
->ofs
;
2367 dyn_i
->want_fptr
= 0;
2372 /* Allocate all the minimal PLT entries. */
2375 allocate_plt_entries (struct elf64_ia64_dyn_sym_info
*dyn_i
,
2376 void * data ATTRIBUTE_UNUSED
)
2378 if (dyn_i
->want_plt
)
2380 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2383 while (h
->root
.type
== bfd_link_hash_indirect
2384 || h
->root
.type
== bfd_link_hash_warning
)
2385 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2387 /* ??? Versioned symbols seem to lose NEEDS_PLT. */
2388 if (elf64_ia64_dynamic_symbol_p (h
))
2390 dyn_i
->want_pltoff
= 1;
2394 dyn_i
->want_plt
= 0;
2395 dyn_i
->want_plt2
= 0;
2401 /* Allocate all the full PLT entries. */
2404 allocate_plt2_entries (struct elf64_ia64_dyn_sym_info
*dyn_i
,
2407 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*)data
;
2409 if (dyn_i
->want_plt2
)
2411 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2412 bfd_size_type ofs
= x
->ofs
;
2414 dyn_i
->plt2_offset
= ofs
;
2415 x
->ofs
= ofs
+ PLT_FULL_ENTRY_SIZE
;
2417 while (h
->root
.type
== bfd_link_hash_indirect
2418 || h
->root
.type
== bfd_link_hash_warning
)
2419 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2420 dyn_i
->h
->plt
.offset
= ofs
;
2425 /* Allocate all the PLTOFF entries requested by relocations and
2426 plt entries. We can't share space with allocated FPTR entries,
2427 because the latter are not necessarily addressable by the GP.
2428 ??? Relaxation might be able to determine that they are. */
2431 allocate_pltoff_entries (struct elf64_ia64_dyn_sym_info
*dyn_i
,
2434 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*)data
;
2436 if (dyn_i
->want_pltoff
)
2438 dyn_i
->pltoff_offset
= x
->ofs
;
2444 /* Allocate dynamic relocations for those symbols that turned out
2448 allocate_dynrel_entries (struct elf64_ia64_dyn_sym_info
*dyn_i
,
2451 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*)data
;
2452 struct elf64_ia64_link_hash_table
*ia64_info
;
2453 struct elf64_ia64_dyn_reloc_entry
*rent
;
2454 bfd_boolean dynamic_symbol
, shared
, resolved_zero
;
2455 struct elf64_ia64_link_hash_entry
*h_ia64
;
2457 ia64_info
= elf64_ia64_hash_table (x
->info
);
2458 if (ia64_info
== NULL
)
2461 /* Note that this can't be used in relation to FPTR relocs below. */
2462 dynamic_symbol
= elf64_ia64_dynamic_symbol_p (dyn_i
->h
);
2464 shared
= bfd_link_pic (x
->info
);
2465 resolved_zero
= (dyn_i
->h
2466 && ELF_ST_VISIBILITY (dyn_i
->h
->other
)
2467 && dyn_i
->h
->root
.type
== bfd_link_hash_undefweak
);
2469 /* Take care of the GOT and PLT relocations. */
2472 && (dynamic_symbol
|| shared
)
2473 && (dyn_i
->want_got
|| dyn_i
->want_gotx
))
2474 || (dyn_i
->want_ltoff_fptr
2476 && dyn_i
->h
->def_dynamic
))
2479 if (dyn_i
->h
!= NULL
&& dyn_i
->h
->def_dynamic
)
2481 h_ia64
= (struct elf64_ia64_link_hash_entry
*) dyn_i
->h
;
2482 elf_ia64_vms_tdata (h_ia64
->shl
)->fixups_off
+=
2483 sizeof (Elf64_External_VMS_IMAGE_FIXUP
);
2484 ia64_info
->fixups_sec
->size
+=
2485 sizeof (Elf64_External_VMS_IMAGE_FIXUP
);
2489 if (ia64_info
->rel_fptr_sec
&& dyn_i
->want_fptr
)
2491 /* VMS: only image reloc. */
2492 if (dyn_i
->h
== NULL
|| dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
2493 ia64_info
->rel_fptr_sec
->size
+= sizeof (Elf64_External_Rela
);
2496 if (!resolved_zero
&& dyn_i
->want_pltoff
)
2499 if (dyn_i
->h
!= NULL
&& dyn_i
->h
->def_dynamic
)
2501 h_ia64
= (struct elf64_ia64_link_hash_entry
*) dyn_i
->h
;
2502 elf_ia64_vms_tdata (h_ia64
->shl
)->fixups_off
+=
2503 sizeof (Elf64_External_VMS_IMAGE_FIXUP
);
2504 ia64_info
->fixups_sec
->size
+=
2505 sizeof (Elf64_External_VMS_IMAGE_FIXUP
);
2509 /* Take care of the normal data relocations. */
2511 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2513 int count
= rent
->count
;
2517 case R_IA64_FPTR32LSB
:
2518 case R_IA64_FPTR64LSB
:
2519 /* Allocate one iff !want_fptr and not PIE, which by this point
2520 will be true only if we're actually allocating one statically
2521 in the main executable. Position independent executables
2522 need a relative reloc. */
2523 if (dyn_i
->want_fptr
&& !bfd_link_pie (x
->info
))
2526 case R_IA64_PCREL32LSB
:
2527 case R_IA64_PCREL64LSB
:
2528 if (!dynamic_symbol
)
2531 case R_IA64_DIR32LSB
:
2532 case R_IA64_DIR64LSB
:
2533 if (!dynamic_symbol
&& !shared
)
2536 case R_IA64_IPLTLSB
:
2537 if (!dynamic_symbol
&& !shared
)
2539 /* Use two REL relocations for IPLT relocations
2540 against local symbols. */
2541 if (!dynamic_symbol
)
2544 case R_IA64_DTPREL32LSB
:
2545 case R_IA64_TPREL64LSB
:
2546 case R_IA64_DTPREL64LSB
:
2547 case R_IA64_DTPMOD64LSB
:
2554 if (!dynamic_symbol
)
2557 h_ia64
= (struct elf64_ia64_link_hash_entry
*) dyn_i
->h
;
2558 elf_ia64_vms_tdata (h_ia64
->shl
)->fixups_off
+=
2559 sizeof (Elf64_External_VMS_IMAGE_FIXUP
);
2560 ia64_info
->fixups_sec
->size
+=
2561 sizeof (Elf64_External_VMS_IMAGE_FIXUP
);
2568 elf64_ia64_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2569 struct elf_link_hash_entry
*h
)
2571 /* ??? Undefined symbols with PLT entries should be re-defined
2572 to be the PLT entry. */
2574 /* If this is a weak symbol, and there is a real definition, the
2575 processor independent code will have arranged for us to see the
2576 real definition first, and we can just use the same value. */
2577 if (h
->u
.weakdef
!= NULL
)
2579 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2580 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2581 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2582 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2586 /* If this is a reference to a symbol defined by a dynamic object which
2587 is not a function, we might allocate the symbol in our .dynbss section
2588 and allocate a COPY dynamic relocation.
2590 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2597 elf64_ia64_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2598 struct bfd_link_info
*info
)
2600 struct elf64_ia64_allocate_data data
;
2601 struct elf64_ia64_link_hash_table
*ia64_info
;
2604 struct elf_link_hash_table
*hash_table
;
2606 hash_table
= elf_hash_table (info
);
2607 dynobj
= hash_table
->dynobj
;
2608 ia64_info
= elf64_ia64_hash_table (info
);
2609 if (ia64_info
== NULL
)
2611 BFD_ASSERT(dynobj
!= NULL
);
2614 /* Allocate the GOT entries. */
2616 if (ia64_info
->root
.sgot
)
2619 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_global_data_got
, &data
);
2620 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_global_fptr_got
, &data
);
2621 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_local_got
, &data
);
2622 ia64_info
->root
.sgot
->size
= data
.ofs
;
2625 /* Allocate the FPTR entries. */
2627 if (ia64_info
->fptr_sec
)
2630 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_fptr
, &data
);
2631 ia64_info
->fptr_sec
->size
= data
.ofs
;
2634 /* Now that we've seen all of the input files, we can decide which
2635 symbols need plt entries. Allocate the minimal PLT entries first.
2636 We do this even though dynamic_sections_created may be FALSE, because
2637 this has the side-effect of clearing want_plt and want_plt2. */
2640 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_plt_entries
, &data
);
2642 /* Align the pointer for the plt2 entries. */
2643 data
.ofs
= (data
.ofs
+ 31) & (bfd_vma
) -32;
2645 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_plt2_entries
, &data
);
2646 if (data
.ofs
!= 0 || ia64_info
->root
.dynamic_sections_created
)
2648 /* FIXME: we always reserve the memory for dynamic linker even if
2649 there are no PLT entries since dynamic linker may assume the
2650 reserved memory always exists. */
2652 BFD_ASSERT (ia64_info
->root
.dynamic_sections_created
);
2654 ia64_info
->root
.splt
->size
= data
.ofs
;
2657 /* Allocate the PLTOFF entries. */
2659 if (ia64_info
->pltoff_sec
)
2662 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_pltoff_entries
, &data
);
2663 ia64_info
->pltoff_sec
->size
= data
.ofs
;
2666 if (ia64_info
->root
.dynamic_sections_created
)
2668 /* Allocate space for the dynamic relocations that turned out to be
2670 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_dynrel_entries
, &data
);
2673 /* We have now determined the sizes of the various dynamic sections.
2674 Allocate memory for them. */
2675 for (sec
= dynobj
->sections
; sec
!= NULL
; sec
= sec
->next
)
2679 if (!(sec
->flags
& SEC_LINKER_CREATED
))
2682 /* If we don't need this section, strip it from the output file.
2683 There were several sections primarily related to dynamic
2684 linking that must be create before the linker maps input
2685 sections to output sections. The linker does that before
2686 bfd_elf_size_dynamic_sections is called, and it is that
2687 function which decides whether anything needs to go into
2690 strip
= (sec
->size
== 0);
2692 if (sec
== ia64_info
->root
.sgot
)
2694 else if (sec
== ia64_info
->root
.srelgot
)
2697 ia64_info
->root
.srelgot
= NULL
;
2699 /* We use the reloc_count field as a counter if we need to
2700 copy relocs into the output file. */
2701 sec
->reloc_count
= 0;
2703 else if (sec
== ia64_info
->fptr_sec
)
2706 ia64_info
->fptr_sec
= NULL
;
2708 else if (sec
== ia64_info
->rel_fptr_sec
)
2711 ia64_info
->rel_fptr_sec
= NULL
;
2713 /* We use the reloc_count field as a counter if we need to
2714 copy relocs into the output file. */
2715 sec
->reloc_count
= 0;
2717 else if (sec
== ia64_info
->root
.splt
)
2720 ia64_info
->root
.splt
= NULL
;
2722 else if (sec
== ia64_info
->pltoff_sec
)
2725 ia64_info
->pltoff_sec
= NULL
;
2727 else if (sec
== ia64_info
->fixups_sec
)
2730 ia64_info
->fixups_sec
= NULL
;
2732 else if (sec
== ia64_info
->transfer_sec
)
2740 /* It's OK to base decisions on the section name, because none
2741 of the dynobj section names depend upon the input files. */
2742 name
= bfd_get_section_name (dynobj
, sec
);
2744 if (strcmp (name
, ".got.plt") == 0)
2746 else if (CONST_STRNEQ (name
, ".rel"))
2750 /* We use the reloc_count field as a counter if we need to
2751 copy relocs into the output file. */
2752 sec
->reloc_count
= 0;
2760 sec
->flags
|= SEC_EXCLUDE
;
2763 /* Allocate memory for the section contents. */
2764 sec
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, sec
->size
);
2765 if (sec
->contents
== NULL
&& sec
->size
!= 0)
2770 if (elf_hash_table (info
)->dynamic_sections_created
)
2774 asection
*dynstrsec
;
2775 Elf_Internal_Dyn dyn
;
2776 const struct elf_backend_data
*bed
;
2777 unsigned int shl_num
= 0;
2778 bfd_vma fixups_off
= 0;
2780 unsigned int time_hi
, time_lo
;
2782 /* The .dynamic section must exist and be empty. */
2783 dynsec
= bfd_get_linker_section (hash_table
->dynobj
, ".dynamic");
2784 BFD_ASSERT (dynsec
!= NULL
);
2785 BFD_ASSERT (dynsec
->size
== 0);
2787 dynstrsec
= bfd_get_linker_section (hash_table
->dynobj
, ".vmsdynstr");
2788 BFD_ASSERT (dynstrsec
!= NULL
);
2789 BFD_ASSERT (dynstrsec
->size
== 0);
2790 dynstrsec
->size
= 1; /* Initial blank. */
2792 /* Ident + link time. */
2793 vms_get_time (&time_hi
, &time_lo
);
2795 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_IDENT
, 0))
2797 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_LINKTIME
,
2798 (((bfd_uint64_t
)time_hi
) << 32)
2803 strdyn_off
= dynsec
->size
;
2804 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_STRTAB_OFFSET
, 0))
2806 if (!_bfd_elf_add_dynamic_entry (info
, DT_STRSZ
, 0))
2810 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_PLTGOT_SEG
, 0))
2812 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_PLTGOT_OFFSET
, 0))
2816 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_FPMODE
, 0x9800000))
2818 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_LNKFLAGS
,
2819 VMS_LF_IMGSTA
| VMS_LF_MAIN
))
2822 /* Add entries for shared libraries. */
2823 for (abfd
= info
->input_bfds
; abfd
; abfd
= abfd
->link
.next
)
2827 bfd_size_type strindex
;
2828 bfd_byte
*newcontents
;
2829 bfd_vma fixups_shl_off
;
2831 if (!(abfd
->flags
& DYNAMIC
))
2833 BFD_ASSERT (abfd
->xvec
== output_bfd
->xvec
);
2835 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_NEEDED_IDENT
,
2836 elf_ia64_vms_ident (abfd
)))
2839 soname
= vms_get_module_name (abfd
->filename
, TRUE
);
2842 strindex
= dynstrsec
->size
;
2843 soname_len
= strlen (soname
) + 1;
2844 newcontents
= (bfd_byte
*) bfd_realloc (dynstrsec
->contents
,
2845 strindex
+ soname_len
);
2846 if (newcontents
== NULL
)
2848 memcpy (newcontents
+ strindex
, soname
, soname_len
);
2849 dynstrsec
->size
+= soname_len
;
2850 dynstrsec
->contents
= newcontents
;
2852 if (!_bfd_elf_add_dynamic_entry (info
, DT_NEEDED
, strindex
))
2855 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_FIXUP_NEEDED
,
2860 /* The fixups_off was in fact containing the size of the fixup
2861 section. Remap into the offset. */
2862 fixups_shl_off
= elf_ia64_vms_tdata (abfd
)->fixups_off
;
2863 elf_ia64_vms_tdata (abfd
)->fixups_off
= fixups_off
;
2865 if (!_bfd_elf_add_dynamic_entry
2866 (info
, DT_IA_64_VMS_FIXUP_RELA_CNT
,
2867 fixups_shl_off
/ sizeof (Elf64_External_VMS_IMAGE_FIXUP
)))
2869 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_FIXUP_RELA_OFF
,
2872 fixups_off
+= fixups_shl_off
;
2876 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_UNWINDSZ
, 0))
2878 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_UNWIND_CODSEG
, 0))
2880 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_UNWIND_INFOSEG
, 0))
2882 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_UNWIND_OFFSET
, 0))
2884 if (!_bfd_elf_add_dynamic_entry (info
, DT_IA_64_VMS_UNWIND_SEG
, 0))
2887 if (!_bfd_elf_add_dynamic_entry (info
, DT_NULL
, 0xdead))
2890 /* Fix the strtab entries. */
2891 bed
= get_elf_backend_data (hash_table
->dynobj
);
2893 if (dynstrsec
->size
> 1)
2894 dynstrsec
->contents
[0] = 0;
2896 dynstrsec
->size
= 0;
2898 /* Note: one 'spare' (ie DT_NULL) entry is added by
2899 bfd_elf_size_dynsym_hash_dynstr. */
2900 dyn
.d_tag
= DT_IA_64_VMS_STRTAB_OFFSET
;
2901 dyn
.d_un
.d_val
= dynsec
->size
/* + sizeof (Elf64_External_Dyn) */;
2902 bed
->s
->swap_dyn_out (hash_table
->dynobj
, &dyn
,
2903 dynsec
->contents
+ strdyn_off
);
2905 dyn
.d_tag
= DT_STRSZ
;
2906 dyn
.d_un
.d_val
= dynstrsec
->size
;
2907 bed
->s
->swap_dyn_out (hash_table
->dynobj
, &dyn
,
2908 dynsec
->contents
+ strdyn_off
+ bed
->s
->sizeof_dyn
);
2910 elf_ia64_vms_tdata (output_bfd
)->needed_count
= shl_num
;
2913 if (!create_ia64_vms_notes (output_bfd
, info
, time_hi
, time_lo
))
2917 /* ??? Perhaps force __gp local. */
2923 elf64_ia64_install_fixup (bfd
*output_bfd
,
2924 struct elf64_ia64_link_hash_table
*ia64_info
,
2925 struct elf_link_hash_entry
*h
,
2926 unsigned int type
, asection
*sec
, bfd_vma offset
,
2930 Elf64_External_VMS_IMAGE_FIXUP
*fixup
;
2931 struct elf64_ia64_link_hash_entry
*h_ia64
;
2933 Elf_Internal_Phdr
*phdr
;
2935 if (h
== NULL
|| !h
->def_dynamic
)
2938 h_ia64
= (struct elf64_ia64_link_hash_entry
*) h
;
2939 fixoff
= elf_ia64_vms_tdata (h_ia64
->shl
)->fixups_off
;
2940 elf_ia64_vms_tdata (h_ia64
->shl
)->fixups_off
+=
2941 sizeof (Elf64_External_VMS_IMAGE_FIXUP
);
2942 relsec
= ia64_info
->fixups_sec
;
2944 fixup
= (Elf64_External_VMS_IMAGE_FIXUP
*)(relsec
->contents
+ fixoff
);
2945 offset
+= sec
->output_section
->vma
+ sec
->output_offset
;
2947 /* FIXME: this is slow. We should cache the last one used, or create a
2949 phdr
= _bfd_elf_find_segment_containing_section
2950 (output_bfd
, sec
->output_section
);
2951 BFD_ASSERT (phdr
!= NULL
);
2953 bfd_putl64 (offset
- phdr
->p_vaddr
, fixup
->fixup_offset
);
2954 bfd_putl32 (type
, fixup
->type
);
2955 bfd_putl32 (phdr
- elf_tdata (output_bfd
)->phdr
, fixup
->fixup_seg
);
2956 bfd_putl64 (addend
, fixup
->addend
);
2957 bfd_putl32 (h
->root
.u
.def
.value
, fixup
->symvec_index
);
2958 bfd_putl32 (2, fixup
->data_type
);
2961 /* Store an entry for target address TARGET_ADDR in the linkage table
2962 and return the gp-relative address of the linkage table entry. */
2965 set_got_entry (bfd
*abfd
, struct bfd_link_info
*info
,
2966 struct elf64_ia64_dyn_sym_info
*dyn_i
,
2967 bfd_vma addend
, bfd_vma value
, unsigned int dyn_r_type
)
2969 struct elf64_ia64_link_hash_table
*ia64_info
;
2974 ia64_info
= elf64_ia64_hash_table (info
);
2975 if (ia64_info
== NULL
)
2978 got_sec
= ia64_info
->root
.sgot
;
2982 case R_IA64_TPREL64LSB
:
2983 case R_IA64_DTPMOD64LSB
:
2984 case R_IA64_DTPREL32LSB
:
2985 case R_IA64_DTPREL64LSB
:
2989 done
= dyn_i
->got_done
;
2990 dyn_i
->got_done
= TRUE
;
2991 got_offset
= dyn_i
->got_offset
;
2995 BFD_ASSERT ((got_offset
& 7) == 0);
2999 /* Store the target address in the linkage table entry. */
3000 bfd_put_64 (abfd
, value
, got_sec
->contents
+ got_offset
);
3002 /* Install a dynamic relocation if needed. */
3003 if (((bfd_link_pic (info
)
3005 || ELF_ST_VISIBILITY (dyn_i
->h
->other
) == STV_DEFAULT
3006 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
3007 || elf64_ia64_dynamic_symbol_p (dyn_i
->h
))
3008 && (!dyn_i
->want_ltoff_fptr
3009 || !bfd_link_pie (info
)
3011 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
3013 if (!dyn_i
->h
|| !dyn_i
->h
->def_dynamic
)
3015 dyn_r_type
= R_IA64_REL64LSB
;
3019 /* VMS: install a FIX32 or FIX64. */
3022 case R_IA64_DIR32LSB
:
3023 case R_IA64_FPTR32LSB
:
3024 dyn_r_type
= R_IA64_VMS_FIX32
;
3026 case R_IA64_DIR64LSB
:
3027 case R_IA64_FPTR64LSB
:
3028 dyn_r_type
= R_IA64_VMS_FIX64
;
3034 elf64_ia64_install_fixup
3035 (info
->output_bfd
, ia64_info
, dyn_i
->h
,
3036 dyn_r_type
, got_sec
, got_offset
, addend
);
3040 /* Return the address of the linkage table entry. */
3041 value
= (got_sec
->output_section
->vma
3042 + got_sec
->output_offset
3048 /* Fill in a function descriptor consisting of the function's code
3049 address and its global pointer. Return the descriptor's address. */
3052 set_fptr_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3053 struct elf64_ia64_dyn_sym_info
*dyn_i
,
3056 struct elf64_ia64_link_hash_table
*ia64_info
;
3059 ia64_info
= elf64_ia64_hash_table (info
);
3060 if (ia64_info
== NULL
)
3063 fptr_sec
= ia64_info
->fptr_sec
;
3065 if (!dyn_i
->fptr_done
)
3067 dyn_i
->fptr_done
= 1;
3069 /* Fill in the function descriptor. */
3070 bfd_put_64 (abfd
, value
, fptr_sec
->contents
+ dyn_i
->fptr_offset
);
3071 bfd_put_64 (abfd
, _bfd_get_gp_value (abfd
),
3072 fptr_sec
->contents
+ dyn_i
->fptr_offset
+ 8);
3075 /* Return the descriptor's address. */
3076 value
= (fptr_sec
->output_section
->vma
3077 + fptr_sec
->output_offset
3078 + dyn_i
->fptr_offset
);
3083 /* Fill in a PLTOFF entry consisting of the function's code address
3084 and its global pointer. Return the descriptor's address. */
3087 set_pltoff_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3088 struct elf64_ia64_dyn_sym_info
*dyn_i
,
3089 bfd_vma value
, bfd_boolean is_plt
)
3091 struct elf64_ia64_link_hash_table
*ia64_info
;
3092 asection
*pltoff_sec
;
3094 ia64_info
= elf64_ia64_hash_table (info
);
3095 if (ia64_info
== NULL
)
3098 pltoff_sec
= ia64_info
->pltoff_sec
;
3100 /* Don't do anything if this symbol uses a real PLT entry. In
3101 that case, we'll fill this in during finish_dynamic_symbol. */
3102 if ((! dyn_i
->want_plt
|| is_plt
)
3103 && !dyn_i
->pltoff_done
)
3105 bfd_vma gp
= _bfd_get_gp_value (abfd
);
3107 /* Fill in the function descriptor. */
3108 bfd_put_64 (abfd
, value
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
);
3109 bfd_put_64 (abfd
, gp
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
+ 8);
3111 /* Install dynamic relocations if needed. */
3113 && bfd_link_pic (info
)
3115 || ELF_ST_VISIBILITY (dyn_i
->h
->other
) == STV_DEFAULT
3116 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
3122 dyn_i
->pltoff_done
= 1;
3125 /* Return the descriptor's address. */
3126 value
= (pltoff_sec
->output_section
->vma
3127 + pltoff_sec
->output_offset
3128 + dyn_i
->pltoff_offset
);
3133 /* Called through qsort to sort the .IA_64.unwind section during a
3134 non-relocatable link. Set elf64_ia64_unwind_entry_compare_bfd
3135 to the output bfd so we can do proper endianness frobbing. */
3137 static bfd
*elf64_ia64_unwind_entry_compare_bfd
;
3140 elf64_ia64_unwind_entry_compare (const void * a
, const void * b
)
3144 av
= bfd_get_64 (elf64_ia64_unwind_entry_compare_bfd
, a
);
3145 bv
= bfd_get_64 (elf64_ia64_unwind_entry_compare_bfd
, b
);
3147 return (av
< bv
? -1 : av
> bv
? 1 : 0);
3150 /* Make sure we've got ourselves a nice fat __gp value. */
3152 elf64_ia64_choose_gp (bfd
*abfd
, struct bfd_link_info
*info
, bfd_boolean final
)
3154 bfd_vma min_vma
= (bfd_vma
) -1, max_vma
= 0;
3155 bfd_vma min_short_vma
= min_vma
, max_short_vma
= 0;
3156 struct elf_link_hash_entry
*gp
;
3159 struct elf64_ia64_link_hash_table
*ia64_info
;
3161 ia64_info
= elf64_ia64_hash_table (info
);
3162 if (ia64_info
== NULL
)
3165 /* Find the min and max vma of all sections marked short. Also collect
3166 min and max vma of any type, for use in selecting a nice gp. */
3167 for (os
= abfd
->sections
; os
; os
= os
->next
)
3171 if ((os
->flags
& SEC_ALLOC
) == 0)
3175 /* When this function is called from elfNN_ia64_final_link
3176 the correct value to use is os->size. When called from
3177 elfNN_ia64_relax_section we are in the middle of section
3178 sizing; some sections will already have os->size set, others
3179 will have os->size zero and os->rawsize the previous size. */
3180 hi
= os
->vma
+ (!final
&& os
->rawsize
? os
->rawsize
: os
->size
);
3188 if (os
->flags
& SEC_SMALL_DATA
)
3190 if (min_short_vma
> lo
)
3192 if (max_short_vma
< hi
)
3197 if (ia64_info
->min_short_sec
)
3200 > (ia64_info
->min_short_sec
->vma
3201 + ia64_info
->min_short_offset
))
3202 min_short_vma
= (ia64_info
->min_short_sec
->vma
3203 + ia64_info
->min_short_offset
);
3205 < (ia64_info
->max_short_sec
->vma
3206 + ia64_info
->max_short_offset
))
3207 max_short_vma
= (ia64_info
->max_short_sec
->vma
3208 + ia64_info
->max_short_offset
);
3211 /* See if the user wants to force a value. */
3212 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
3216 && (gp
->root
.type
== bfd_link_hash_defined
3217 || gp
->root
.type
== bfd_link_hash_defweak
))
3219 asection
*gp_sec
= gp
->root
.u
.def
.section
;
3220 gp_val
= (gp
->root
.u
.def
.value
3221 + gp_sec
->output_section
->vma
3222 + gp_sec
->output_offset
);
3226 /* Pick a sensible value. */
3228 if (ia64_info
->min_short_sec
)
3230 bfd_vma short_range
= max_short_vma
- min_short_vma
;
3232 /* If min_short_sec is set, pick one in the middle bewteen
3233 min_short_vma and max_short_vma. */
3234 if (short_range
>= 0x400000)
3236 gp_val
= min_short_vma
+ short_range
/ 2;
3240 asection
*got_sec
= ia64_info
->root
.sgot
;
3242 /* Start with just the address of the .got. */
3244 gp_val
= got_sec
->output_section
->vma
;
3245 else if (max_short_vma
!= 0)
3246 gp_val
= min_short_vma
;
3247 else if (max_vma
- min_vma
< 0x200000)
3250 gp_val
= max_vma
- 0x200000 + 8;
3253 /* If it is possible to address the entire image, but we
3254 don't with the choice above, adjust. */
3255 if (max_vma
- min_vma
< 0x400000
3256 && (max_vma
- gp_val
>= 0x200000
3257 || gp_val
- min_vma
> 0x200000))
3258 gp_val
= min_vma
+ 0x200000;
3259 else if (max_short_vma
!= 0)
3261 /* If we don't cover all the short data, adjust. */
3262 if (max_short_vma
- gp_val
>= 0x200000)
3263 gp_val
= min_short_vma
+ 0x200000;
3265 /* If we're addressing stuff past the end, adjust back. */
3266 if (gp_val
> max_vma
)
3267 gp_val
= max_vma
- 0x200000 + 8;
3271 /* Validate whether all SHF_IA_64_SHORT sections are within
3272 range of the chosen GP. */
3274 if (max_short_vma
!= 0)
3276 if (max_short_vma
- min_short_vma
>= 0x400000)
3280 /* xgettext:c-format */
3281 (_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
3282 bfd_get_filename (abfd
),
3283 (unsigned long) (max_short_vma
- min_short_vma
));
3286 else if ((gp_val
> min_short_vma
3287 && gp_val
- min_short_vma
> 0x200000)
3288 || (gp_val
< max_short_vma
3289 && max_short_vma
- gp_val
>= 0x200000))
3292 (_("%s: __gp does not cover short data segment"),
3293 bfd_get_filename (abfd
));
3298 _bfd_set_gp_value (abfd
, gp_val
);
3304 elf64_ia64_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
3306 struct elf64_ia64_link_hash_table
*ia64_info
;
3307 asection
*unwind_output_sec
;
3309 ia64_info
= elf64_ia64_hash_table (info
);
3310 if (ia64_info
== NULL
)
3313 /* Make sure we've got ourselves a nice fat __gp value. */
3314 if (!bfd_link_relocatable (info
))
3317 struct elf_link_hash_entry
*gp
;
3319 /* We assume after gp is set, section size will only decrease. We
3320 need to adjust gp for it. */
3321 _bfd_set_gp_value (abfd
, 0);
3322 if (! elf64_ia64_choose_gp (abfd
, info
, TRUE
))
3324 gp_val
= _bfd_get_gp_value (abfd
);
3326 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
3330 gp
->root
.type
= bfd_link_hash_defined
;
3331 gp
->root
.u
.def
.value
= gp_val
;
3332 gp
->root
.u
.def
.section
= bfd_abs_section_ptr
;
3336 /* If we're producing a final executable, we need to sort the contents
3337 of the .IA_64.unwind section. Force this section to be relocated
3338 into memory rather than written immediately to the output file. */
3339 unwind_output_sec
= NULL
;
3340 if (!bfd_link_relocatable (info
))
3342 asection
*s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_unwind
);
3345 unwind_output_sec
= s
->output_section
;
3346 unwind_output_sec
->contents
3347 = bfd_malloc (unwind_output_sec
->size
);
3348 if (unwind_output_sec
->contents
== NULL
)
3353 /* Invoke the regular ELF backend linker to do all the work. */
3354 if (!bfd_elf_final_link (abfd
, info
))
3357 if (unwind_output_sec
)
3359 elf64_ia64_unwind_entry_compare_bfd
= abfd
;
3360 qsort (unwind_output_sec
->contents
,
3361 (size_t) (unwind_output_sec
->size
/ 24),
3363 elf64_ia64_unwind_entry_compare
);
3365 if (! bfd_set_section_contents (abfd
, unwind_output_sec
,
3366 unwind_output_sec
->contents
, (bfd_vma
) 0,
3367 unwind_output_sec
->size
))
3375 elf64_ia64_relocate_section (bfd
*output_bfd
,
3376 struct bfd_link_info
*info
,
3378 asection
*input_section
,
3380 Elf_Internal_Rela
*relocs
,
3381 Elf_Internal_Sym
*local_syms
,
3382 asection
**local_sections
)
3384 struct elf64_ia64_link_hash_table
*ia64_info
;
3385 Elf_Internal_Shdr
*symtab_hdr
;
3386 Elf_Internal_Rela
*rel
;
3387 Elf_Internal_Rela
*relend
;
3388 bfd_boolean ret_val
= TRUE
; /* for non-fatal errors */
3391 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3392 ia64_info
= elf64_ia64_hash_table (info
);
3393 if (ia64_info
== NULL
)
3396 /* Infect various flags from the input section to the output section. */
3397 if (bfd_link_relocatable (info
))
3401 flags
= elf_section_data(input_section
)->this_hdr
.sh_flags
;
3402 flags
&= SHF_IA_64_NORECOV
;
3404 elf_section_data(input_section
->output_section
)
3405 ->this_hdr
.sh_flags
|= flags
;
3408 gp_val
= _bfd_get_gp_value (output_bfd
);
3411 relend
= relocs
+ input_section
->reloc_count
;
3412 for (; rel
< relend
; ++rel
)
3414 struct elf_link_hash_entry
*h
;
3415 struct elf64_ia64_dyn_sym_info
*dyn_i
;
3416 bfd_reloc_status_type r
;
3417 reloc_howto_type
*howto
;
3418 unsigned long r_symndx
;
3419 Elf_Internal_Sym
*sym
;
3420 unsigned int r_type
;
3424 bfd_boolean dynamic_symbol_p
;
3425 bfd_boolean undef_weak_ref
;
3427 r_type
= ELF64_R_TYPE (rel
->r_info
);
3428 if (r_type
> R_IA64_MAX_RELOC_CODE
)
3431 /* xgettext:c-format */
3432 (_("%B: unknown relocation type %d"),
3433 input_bfd
, (int) r_type
);
3434 bfd_set_error (bfd_error_bad_value
);
3439 howto
= ia64_elf_lookup_howto (r_type
);
3440 r_symndx
= ELF64_R_SYM (rel
->r_info
);
3444 undef_weak_ref
= FALSE
;
3446 if (r_symndx
< symtab_hdr
->sh_info
)
3448 /* Reloc against local symbol. */
3450 sym
= local_syms
+ r_symndx
;
3451 sym_sec
= local_sections
[r_symndx
];
3453 value
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &msec
, rel
);
3454 if (!bfd_link_relocatable (info
)
3455 && (sym_sec
->flags
& SEC_MERGE
) != 0
3456 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3457 && sym_sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
)
3459 struct elf64_ia64_local_hash_entry
*loc_h
;
3461 loc_h
= get_local_sym_hash (ia64_info
, input_bfd
, rel
, FALSE
);
3462 if (loc_h
&& ! loc_h
->sec_merge_done
)
3464 struct elf64_ia64_dyn_sym_info
*dynent
;
3467 for (count
= loc_h
->count
, dynent
= loc_h
->info
;
3473 _bfd_merged_section_offset (output_bfd
, &msec
,
3474 elf_section_data (msec
)->
3478 dynent
->addend
-= sym
->st_value
;
3479 dynent
->addend
+= msec
->output_section
->vma
3480 + msec
->output_offset
3481 - sym_sec
->output_section
->vma
3482 - sym_sec
->output_offset
;
3485 /* We may have introduced duplicated entries. We need
3486 to remove them properly. */
3487 count
= sort_dyn_sym_info (loc_h
->info
, loc_h
->count
);
3488 if (count
!= loc_h
->count
)
3490 loc_h
->count
= count
;
3491 loc_h
->sorted_count
= count
;
3494 loc_h
->sec_merge_done
= 1;
3500 bfd_boolean unresolved_reloc
;
3501 bfd_boolean warned
, ignored
;
3502 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
3504 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3505 r_symndx
, symtab_hdr
, sym_hashes
,
3507 unresolved_reloc
, warned
, ignored
);
3509 if (h
->root
.type
== bfd_link_hash_undefweak
)
3510 undef_weak_ref
= TRUE
;
3515 /* For relocs against symbols from removed linkonce sections,
3516 or sections discarded by a linker script, we just want the
3517 section contents zeroed. Avoid any special processing. */
3518 if (sym_sec
!= NULL
&& discarded_section (sym_sec
))
3519 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
3520 rel
, 1, relend
, howto
, 0, contents
);
3522 if (bfd_link_relocatable (info
))
3525 hit_addr
= contents
+ rel
->r_offset
;
3526 value
+= rel
->r_addend
;
3527 dynamic_symbol_p
= elf64_ia64_dynamic_symbol_p (h
);
3538 case R_IA64_DIR32MSB
:
3539 case R_IA64_DIR32LSB
:
3540 case R_IA64_DIR64MSB
:
3541 case R_IA64_DIR64LSB
:
3542 /* Install a dynamic relocation for this reloc. */
3543 if ((dynamic_symbol_p
|| bfd_link_pic (info
))
3545 && (input_section
->flags
& SEC_ALLOC
) != 0)
3547 unsigned int dyn_r_type
;
3555 /* ??? People shouldn't be doing non-pic code in
3556 shared libraries nor dynamic executables. */
3558 /* xgettext:c-format */
3559 (_("%B: non-pic code with imm relocation against 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 (_("%B: @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 (_("%B: 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
= _("%B: @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
= _("%B: speculation fixup to dynamic symbol %s");
3788 /* xgettext:c-format */
3789 msg
= _("%B: @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 (_("%B: missing TLS section for relocation %s against `%s' at 0x%lx in section `%A'."),
3951 input_bfd
, input_section
, howto
->name
, name
,
3955 case R_IA64_PCREL21B
:
3956 case R_IA64_PCREL21BI
:
3957 case R_IA64_PCREL21M
:
3958 case R_IA64_PCREL21F
:
3959 if (is_elf_hash_table (info
->hash
))
3961 /* Relaxtion is always performed for ELF output.
3962 Overflow failures for those relocations mean
3963 that the section is too big to relax. */
3965 /* xgettext:c-format */
3966 (_("%B: Can't relax br (%s) to `%s' at 0x%lx in section `%A' with size 0x%lx (> 0x1000000)."),
3967 input_bfd
, input_section
, howto
->name
, name
,
3968 rel
->r_offset
, input_section
->size
);
3973 (*info
->callbacks
->reloc_overflow
) (info
,
3994 elf64_ia64_finish_dynamic_symbol (bfd
*output_bfd
,
3995 struct bfd_link_info
*info
,
3996 struct elf_link_hash_entry
*h
,
3997 Elf_Internal_Sym
*sym
)
3999 struct elf64_ia64_link_hash_table
*ia64_info
;
4000 struct elf64_ia64_dyn_sym_info
*dyn_i
;
4002 ia64_info
= elf64_ia64_hash_table (info
);
4003 if (ia64_info
== NULL
)
4006 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, FALSE
);
4008 /* Fill in the PLT data, if required. */
4009 if (dyn_i
&& dyn_i
->want_plt
)
4013 bfd_vma plt_addr
, pltoff_addr
, gp_val
;
4015 gp_val
= _bfd_get_gp_value (output_bfd
);
4017 plt_sec
= ia64_info
->root
.splt
;
4018 plt_addr
= 0; /* Not used as overriden by FIXUPs. */
4019 pltoff_addr
= set_pltoff_entry (output_bfd
, info
, dyn_i
, plt_addr
, TRUE
);
4021 /* Initialize the FULL PLT entry, if needed. */
4022 if (dyn_i
->want_plt2
)
4024 loc
= plt_sec
->contents
+ dyn_i
->plt2_offset
;
4026 memcpy (loc
, plt_full_entry
, PLT_FULL_ENTRY_SIZE
);
4027 ia64_elf_install_value (loc
, pltoff_addr
- gp_val
, R_IA64_IMM22
);
4029 /* Mark the symbol as undefined, rather than as defined in the
4030 plt section. Leave the value alone. */
4031 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
4032 first place. But perhaps elflink.c did some for us. */
4033 if (!h
->def_regular
)
4034 sym
->st_shndx
= SHN_UNDEF
;
4038 elf64_ia64_install_fixup
4039 (output_bfd
, ia64_info
, h
, R_IA64_VMS_FIXFD
, ia64_info
->pltoff_sec
,
4040 pltoff_addr
- (ia64_info
->pltoff_sec
->output_section
->vma
4041 + ia64_info
->pltoff_sec
->output_offset
), 0);
4044 /* Mark some specially defined symbols as absolute. */
4045 if (h
== ia64_info
->root
.hdynamic
4046 || h
== ia64_info
->root
.hgot
4047 || h
== ia64_info
->root
.hplt
)
4048 sym
->st_shndx
= SHN_ABS
;
4054 elf64_ia64_finish_dynamic_sections (bfd
*abfd
,
4055 struct bfd_link_info
*info
)
4057 struct elf64_ia64_link_hash_table
*ia64_info
;
4060 ia64_info
= elf64_ia64_hash_table (info
);
4061 if (ia64_info
== NULL
)
4064 dynobj
= ia64_info
->root
.dynobj
;
4066 if (elf_hash_table (info
)->dynamic_sections_created
)
4068 Elf64_External_Dyn
*dyncon
, *dynconend
;
4070 asection
*unwind_sec
;
4072 unsigned int gp_seg
;
4074 Elf_Internal_Phdr
*phdr
;
4075 Elf_Internal_Phdr
*base_phdr
;
4076 unsigned int unwind_seg
= 0;
4077 unsigned int code_seg
= 0;
4079 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
4080 BFD_ASSERT (sdyn
!= NULL
);
4081 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
4082 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4084 gp_val
= _bfd_get_gp_value (abfd
);
4085 phdr
= _bfd_elf_find_segment_containing_section
4086 (info
->output_bfd
, ia64_info
->pltoff_sec
->output_section
);
4087 BFD_ASSERT (phdr
!= NULL
);
4088 base_phdr
= elf_tdata (info
->output_bfd
)->phdr
;
4089 gp_seg
= phdr
- base_phdr
;
4090 gp_off
= gp_val
- phdr
->p_vaddr
;
4092 unwind_sec
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_unwind
);
4093 if (unwind_sec
!= NULL
)
4097 phdr
= _bfd_elf_find_segment_containing_section (abfd
, unwind_sec
);
4098 BFD_ASSERT (phdr
!= NULL
);
4099 unwind_seg
= phdr
- base_phdr
;
4101 code_sec
= bfd_get_section_by_name (abfd
, "$CODE$");
4102 phdr
= _bfd_elf_find_segment_containing_section (abfd
, code_sec
);
4103 BFD_ASSERT (phdr
!= NULL
);
4104 code_seg
= phdr
- base_phdr
;
4107 for (; dyncon
< dynconend
; dyncon
++)
4109 Elf_Internal_Dyn dyn
;
4111 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4115 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
4117 (ia64_info
->fixups_sec
->output_section
->vma
4118 + ia64_info
->fixups_sec
->output_offset
)
4119 - (sdyn
->output_section
->vma
+ sdyn
->output_offset
);
4122 case DT_IA_64_VMS_PLTGOT_OFFSET
:
4123 dyn
.d_un
.d_val
= gp_off
;
4126 case DT_IA_64_VMS_PLTGOT_SEG
:
4127 dyn
.d_un
.d_val
= gp_seg
;
4130 case DT_IA_64_VMS_UNWINDSZ
:
4131 if (unwind_sec
== NULL
)
4133 dyn
.d_tag
= DT_NULL
;
4134 dyn
.d_un
.d_val
= 0xdead;
4137 dyn
.d_un
.d_val
= unwind_sec
->size
;
4140 case DT_IA_64_VMS_UNWIND_CODSEG
:
4141 dyn
.d_un
.d_val
= code_seg
;
4144 case DT_IA_64_VMS_UNWIND_INFOSEG
:
4145 case DT_IA_64_VMS_UNWIND_SEG
:
4146 dyn
.d_un
.d_val
= unwind_seg
;
4149 case DT_IA_64_VMS_UNWIND_OFFSET
:
4153 /* No need to rewrite the entry. */
4157 bfd_elf64_swap_dyn_out (abfd
, &dyn
, dyncon
);
4161 /* Handle transfer addresses. */
4163 asection
*tfr_sec
= ia64_info
->transfer_sec
;
4164 struct elf64_vms_transfer
*tfr
;
4165 struct elf_link_hash_entry
*tfr3
;
4167 tfr
= (struct elf64_vms_transfer
*)tfr_sec
->contents
;
4168 bfd_putl32 (6 * 8, tfr
->size
);
4169 bfd_putl64 (tfr_sec
->output_section
->vma
4170 + tfr_sec
->output_offset
4171 + 6 * 8, tfr
->tfradr3
);
4173 tfr3
= elf_link_hash_lookup (elf_hash_table (info
), "ELF$TFRADR", FALSE
,
4177 && (tfr3
->root
.type
== bfd_link_hash_defined
4178 || tfr3
->root
.type
== bfd_link_hash_defweak
))
4180 asection
*tfr3_sec
= tfr3
->root
.u
.def
.section
;
4183 tfr3_val
= (tfr3
->root
.u
.def
.value
4184 + tfr3_sec
->output_section
->vma
4185 + tfr3_sec
->output_offset
);
4187 bfd_putl64 (tfr3_val
, tfr
->tfr3_func
);
4188 bfd_putl64 (_bfd_get_gp_value (info
->output_bfd
), tfr
->tfr3_gp
);
4191 /* FIXME: set linker flags,
4192 handle lib$initialize. */
4198 /* ELF file flag handling: */
4200 /* Function to keep IA-64 specific file flags. */
4202 elf64_ia64_set_private_flags (bfd
*abfd
, flagword flags
)
4204 BFD_ASSERT (!elf_flags_init (abfd
)
4205 || elf_elfheader (abfd
)->e_flags
== flags
);
4207 elf_elfheader (abfd
)->e_flags
= flags
;
4208 elf_flags_init (abfd
) = TRUE
;
4212 /* Merge backend specific data from an object file to the output
4213 object file when linking. */
4215 elf64_ia64_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
4217 bfd
*obfd
= info
->output_bfd
;
4220 bfd_boolean ok
= TRUE
;
4222 /* Don't even pretend to support mixed-format linking. */
4223 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4224 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4227 in_flags
= elf_elfheader (ibfd
)->e_flags
;
4228 out_flags
= elf_elfheader (obfd
)->e_flags
;
4230 if (! elf_flags_init (obfd
))
4232 elf_flags_init (obfd
) = TRUE
;
4233 elf_elfheader (obfd
)->e_flags
= in_flags
;
4235 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
4236 && bfd_get_arch_info (obfd
)->the_default
)
4238 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
4239 bfd_get_mach (ibfd
));
4245 /* Check flag compatibility. */
4246 if (in_flags
== out_flags
)
4249 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
4250 if (!(in_flags
& EF_IA_64_REDUCEDFP
) && (out_flags
& EF_IA_64_REDUCEDFP
))
4251 elf_elfheader (obfd
)->e_flags
&= ~EF_IA_64_REDUCEDFP
;
4253 if ((in_flags
& EF_IA_64_TRAPNIL
) != (out_flags
& EF_IA_64_TRAPNIL
))
4256 (_("%B: linking trap-on-NULL-dereference with non-trapping files"),
4259 bfd_set_error (bfd_error_bad_value
);
4262 if ((in_flags
& EF_IA_64_BE
) != (out_flags
& EF_IA_64_BE
))
4265 (_("%B: linking big-endian files with little-endian files"),
4268 bfd_set_error (bfd_error_bad_value
);
4271 if ((in_flags
& EF_IA_64_ABI64
) != (out_flags
& EF_IA_64_ABI64
))
4274 (_("%B: linking 64-bit files with 32-bit files"),
4277 bfd_set_error (bfd_error_bad_value
);
4280 if ((in_flags
& EF_IA_64_CONS_GP
) != (out_flags
& EF_IA_64_CONS_GP
))
4283 (_("%B: linking constant-gp files with non-constant-gp files"),
4286 bfd_set_error (bfd_error_bad_value
);
4289 if ((in_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
)
4290 != (out_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
4293 (_("%B: linking auto-pic files with non-auto-pic files"),
4296 bfd_set_error (bfd_error_bad_value
);
4304 elf64_ia64_print_private_bfd_data (bfd
*abfd
, void * ptr
)
4306 FILE *file
= (FILE *) ptr
;
4307 flagword flags
= elf_elfheader (abfd
)->e_flags
;
4309 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
4311 fprintf (file
, "private flags = %s%s%s%s%s%s%s%s\n",
4312 (flags
& EF_IA_64_TRAPNIL
) ? "TRAPNIL, " : "",
4313 (flags
& EF_IA_64_EXT
) ? "EXT, " : "",
4314 (flags
& EF_IA_64_BE
) ? "BE, " : "LE, ",
4315 (flags
& EF_IA_64_REDUCEDFP
) ? "REDUCEDFP, " : "",
4316 (flags
& EF_IA_64_CONS_GP
) ? "CONS_GP, " : "",
4317 (flags
& EF_IA_64_NOFUNCDESC_CONS_GP
) ? "NOFUNCDESC_CONS_GP, " : "",
4318 (flags
& EF_IA_64_ABSOLUTE
) ? "ABSOLUTE, " : "",
4319 (flags
& EF_IA_64_ABI64
) ? "ABI64" : "ABI32");
4321 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
4325 static enum elf_reloc_type_class
4326 elf64_ia64_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4327 const asection
*rel_sec ATTRIBUTE_UNUSED
,
4328 const Elf_Internal_Rela
*rela
)
4330 switch ((int) ELF64_R_TYPE (rela
->r_info
))
4332 case R_IA64_REL32MSB
:
4333 case R_IA64_REL32LSB
:
4334 case R_IA64_REL64MSB
:
4335 case R_IA64_REL64LSB
:
4336 return reloc_class_relative
;
4337 case R_IA64_IPLTMSB
:
4338 case R_IA64_IPLTLSB
:
4339 return reloc_class_plt
;
4341 return reloc_class_copy
;
4343 return reloc_class_normal
;
4347 static const struct bfd_elf_special_section elf64_ia64_special_sections
[] =
4349 { STRING_COMMA_LEN (".sbss"), -1, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_IA_64_SHORT
},
4350 { STRING_COMMA_LEN (".sdata"), -1, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_IA_64_SHORT
},
4351 { NULL
, 0, 0, 0, 0 }
4355 elf64_ia64_object_p (bfd
*abfd
)
4358 asection
*group
, *unwi
, *unw
;
4361 char *unwi_name
, *unw_name
;
4364 if (abfd
->flags
& DYNAMIC
)
4367 /* Flags for fake group section. */
4368 flags
= (SEC_LINKER_CREATED
| SEC_GROUP
| SEC_LINK_ONCE
4371 /* We add a fake section group for each .gnu.linkonce.t.* section,
4372 which isn't in a section group, and its unwind sections. */
4373 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4375 if (elf_sec_group (sec
) == NULL
4376 && ((sec
->flags
& (SEC_LINK_ONCE
| SEC_CODE
| SEC_GROUP
))
4377 == (SEC_LINK_ONCE
| SEC_CODE
))
4378 && CONST_STRNEQ (sec
->name
, ".gnu.linkonce.t."))
4380 name
= sec
->name
+ 16;
4382 amt
= strlen (name
) + sizeof (".gnu.linkonce.ia64unwi.");
4383 unwi_name
= bfd_alloc (abfd
, amt
);
4387 strcpy (stpcpy (unwi_name
, ".gnu.linkonce.ia64unwi."), name
);
4388 unwi
= bfd_get_section_by_name (abfd
, unwi_name
);
4390 amt
= strlen (name
) + sizeof (".gnu.linkonce.ia64unw.");
4391 unw_name
= bfd_alloc (abfd
, amt
);
4395 strcpy (stpcpy (unw_name
, ".gnu.linkonce.ia64unw."), name
);
4396 unw
= bfd_get_section_by_name (abfd
, unw_name
);
4398 /* We need to create a fake group section for it and its
4400 group
= bfd_make_section_anyway_with_flags (abfd
, name
,
4405 /* Move the fake group section to the beginning. */
4406 bfd_section_list_remove (abfd
, group
);
4407 bfd_section_list_prepend (abfd
, group
);
4409 elf_next_in_group (group
) = sec
;
4411 elf_group_name (sec
) = name
;
4412 elf_next_in_group (sec
) = sec
;
4413 elf_sec_group (sec
) = group
;
4417 elf_group_name (unwi
) = name
;
4418 elf_next_in_group (unwi
) = sec
;
4419 elf_next_in_group (sec
) = unwi
;
4420 elf_sec_group (unwi
) = group
;
4425 elf_group_name (unw
) = name
;
4428 elf_next_in_group (unw
) = elf_next_in_group (unwi
);
4429 elf_next_in_group (unwi
) = unw
;
4433 elf_next_in_group (unw
) = sec
;
4434 elf_next_in_group (sec
) = unw
;
4436 elf_sec_group (unw
) = group
;
4439 /* Fake SHT_GROUP section header. */
4440 elf_section_data (group
)->this_hdr
.bfd_section
= group
;
4441 elf_section_data (group
)->this_hdr
.sh_type
= SHT_GROUP
;
4447 /* Handle an IA-64 specific section when reading an object file. This
4448 is called when bfd_section_from_shdr finds a section with an unknown
4452 elf64_vms_section_from_shdr (bfd
*abfd
,
4453 Elf_Internal_Shdr
*hdr
,
4457 flagword secflags
= 0;
4459 switch (hdr
->sh_type
)
4461 case SHT_IA_64_VMS_TRACE
:
4462 case SHT_IA_64_VMS_DEBUG
:
4463 case SHT_IA_64_VMS_DEBUG_STR
:
4464 secflags
= SEC_DEBUGGING
;
4467 case SHT_IA_64_UNWIND
:
4468 case SHT_IA_64_HP_OPT_ANOT
:
4472 if (strcmp (name
, ELF_STRING_ia64_archext
) != 0)
4480 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
4485 asection
*newsect
= hdr
->bfd_section
;
4487 if (! bfd_set_section_flags
4488 (abfd
, newsect
, bfd_get_section_flags (abfd
, newsect
) | secflags
))
4496 elf64_vms_object_p (bfd
*abfd
)
4498 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
4499 Elf_Internal_Phdr
*i_phdr
= elf_tdata (abfd
)->phdr
;
4501 unsigned int num_text
= 0;
4502 unsigned int num_data
= 0;
4503 unsigned int num_rodata
= 0;
4506 if (!elf64_ia64_object_p (abfd
))
4509 /* Many VMS compilers do not generate sections for the corresponding
4510 segment. This is boring as binutils tools won't be able to disassemble
4511 the code. So we simply create all the missing sections. */
4512 for (i
= 0; i
< i_ehdrp
->e_phnum
; i
++, i_phdr
++)
4514 /* Is there a section for this segment? */
4515 bfd_vma base_vma
= i_phdr
->p_vaddr
;
4516 bfd_vma limit_vma
= base_vma
+ i_phdr
->p_filesz
;
4518 if (i_phdr
->p_type
!= PT_LOAD
)
4521 /* We need to cover from base_vms to limit_vma. */
4523 while (base_vma
< limit_vma
)
4525 bfd_vma next_vma
= limit_vma
;
4531 /* Find a section covering [base_vma;limit_vma) */
4532 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4534 /* Skip uninteresting sections (either not in memory or
4536 if ((sec
->flags
& (SEC_ALLOC
| SEC_LOAD
)) == 0
4537 || sec
->vma
+ sec
->size
<= base_vma
)
4539 if (sec
->vma
<= base_vma
)
4541 /* This section covers (maybe partially) the beginning
4543 base_vma
= sec
->vma
+ sec
->size
;
4546 if (sec
->vma
< next_vma
)
4548 /* This section partially covers the end of the range.
4549 Used to compute the size of the hole. */
4550 next_vma
= sec
->vma
;
4554 /* No section covering [base_vma; next_vma). Create a fake one. */
4555 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
;
4556 if (i_phdr
->p_flags
& PF_X
)
4559 if (num_text
++ == 0)
4562 sprintf (name
, ".text$%u", num_text
);
4564 else if ((i_phdr
->p_flags
& (PF_R
| PF_W
)) == PF_R
)
4566 flags
|= SEC_READONLY
;
4567 sprintf (name
, ".rodata$%u", num_rodata
++);
4572 sprintf (name
, ".data$%u", num_data
++);
4575 /* Allocate name. */
4578 size_t name_len
= strlen (name
) + 1;
4579 nname
= bfd_alloc (abfd
, name_len
);
4582 memcpy (nname
, name
, name_len
);
4585 /* Create and fill new section. */
4586 nsec
= bfd_make_section_anyway_with_flags (abfd
, nname
, flags
);
4589 nsec
->vma
= base_vma
;
4590 nsec
->size
= next_vma
- base_vma
;
4591 nsec
->filepos
= i_phdr
->p_offset
+ (base_vma
- i_phdr
->p_vaddr
);
4593 base_vma
= next_vma
;
4600 elf64_vms_post_process_headers (bfd
*abfd
,
4601 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
4603 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
4605 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_OPENVMS
;
4606 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 2;
4610 elf64_vms_section_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
4611 Elf_Internal_Shdr
*hdr
)
4613 if (hdr
->bfd_section
!= NULL
)
4615 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
4617 if (strcmp (name
, ".text") == 0)
4618 hdr
->sh_flags
|= SHF_IA_64_VMS_SHARED
;
4619 else if ((strcmp (name
, ".debug") == 0)
4620 || (strcmp (name
, ".debug_abbrev") == 0)
4621 || (strcmp (name
, ".debug_aranges") == 0)
4622 || (strcmp (name
, ".debug_frame") == 0)
4623 || (strcmp (name
, ".debug_info") == 0)
4624 || (strcmp (name
, ".debug_loc") == 0)
4625 || (strcmp (name
, ".debug_macinfo") == 0)
4626 || (strcmp (name
, ".debug_pubnames") == 0)
4627 || (strcmp (name
, ".debug_pubtypes") == 0))
4628 hdr
->sh_type
= SHT_IA_64_VMS_DEBUG
;
4629 else if ((strcmp (name
, ".debug_line") == 0)
4630 || (strcmp (name
, ".debug_ranges") == 0)
4631 || (strcmp (name
, ".trace_info") == 0)
4632 || (strcmp (name
, ".trace_abbrev") == 0)
4633 || (strcmp (name
, ".trace_aranges") == 0))
4634 hdr
->sh_type
= SHT_IA_64_VMS_TRACE
;
4635 else if (strcmp (name
, ".debug_str") == 0)
4636 hdr
->sh_type
= SHT_IA_64_VMS_DEBUG_STR
;
4642 /* The final processing done just before writing out a VMS IA-64 ELF
4646 elf64_vms_final_write_processing (bfd
*abfd
,
4647 bfd_boolean linker ATTRIBUTE_UNUSED
)
4649 Elf_Internal_Shdr
*hdr
;
4651 int unwind_info_sect_idx
= 0;
4653 for (s
= abfd
->sections
; s
; s
= s
->next
)
4655 hdr
= &elf_section_data (s
)->this_hdr
;
4657 if (strcmp (bfd_get_section_name (abfd
, hdr
->bfd_section
),
4658 ".IA_64.unwind_info") == 0)
4659 unwind_info_sect_idx
= elf_section_data (s
)->this_idx
;
4661 switch (hdr
->sh_type
)
4663 case SHT_IA_64_UNWIND
:
4664 /* VMS requires sh_info to point to the unwind info section. */
4665 hdr
->sh_info
= unwind_info_sect_idx
;
4670 if (! elf_flags_init (abfd
))
4672 unsigned long flags
= 0;
4674 if (abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
)
4675 flags
|= EF_IA_64_BE
;
4676 if (bfd_get_mach (abfd
) == bfd_mach_ia64_elf64
)
4677 flags
|= EF_IA_64_ABI64
;
4679 elf_elfheader (abfd
)->e_flags
= flags
;
4680 elf_flags_init (abfd
) = TRUE
;
4685 elf64_vms_write_shdrs_and_ehdr (bfd
*abfd
)
4687 unsigned char needed_count
[8];
4689 if (!bfd_elf64_write_shdrs_and_ehdr (abfd
))
4692 bfd_putl64 (elf_ia64_vms_tdata (abfd
)->needed_count
, needed_count
);
4694 if (bfd_seek (abfd
, sizeof (Elf64_External_Ehdr
), SEEK_SET
) != 0
4695 || bfd_bwrite (needed_count
, 8, abfd
) != 8)
4702 elf64_vms_close_and_cleanup (bfd
*abfd
)
4704 if (bfd_get_format (abfd
) == bfd_object
)
4708 /* Pad to 8 byte boundary for IPF/VMS. */
4709 isize
= bfd_get_size (abfd
);
4710 if ((isize
& 7) != 0)
4712 int ishort
= 8 - (isize
& 7);
4713 bfd_uint64_t pad
= 0;
4715 bfd_seek (abfd
, isize
, SEEK_SET
);
4716 bfd_bwrite (&pad
, ishort
, abfd
);
4720 return _bfd_elf_close_and_cleanup (abfd
);
4723 /* Add symbols from an ELF object file to the linker hash table. */
4726 elf64_vms_link_add_object_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
4728 Elf_Internal_Shdr
*hdr
;
4729 bfd_size_type symcount
;
4730 bfd_size_type extsymcount
;
4731 bfd_size_type extsymoff
;
4732 struct elf_link_hash_entry
**sym_hash
;
4733 bfd_boolean dynamic
;
4734 Elf_Internal_Sym
*isymbuf
= NULL
;
4735 Elf_Internal_Sym
*isym
;
4736 Elf_Internal_Sym
*isymend
;
4737 const struct elf_backend_data
*bed
;
4738 struct elf_link_hash_table
*htab
;
4741 htab
= elf_hash_table (info
);
4742 bed
= get_elf_backend_data (abfd
);
4744 if ((abfd
->flags
& DYNAMIC
) == 0)
4750 /* You can't use -r against a dynamic object. Also, there's no
4751 hope of using a dynamic object which does not exactly match
4752 the format of the output file. */
4753 if (bfd_link_relocatable (info
)
4754 || !is_elf_hash_table (htab
)
4755 || info
->output_bfd
->xvec
!= abfd
->xvec
)
4757 if (bfd_link_relocatable (info
))
4758 bfd_set_error (bfd_error_invalid_operation
);
4760 bfd_set_error (bfd_error_wrong_format
);
4767 /* If we are creating a shared library, create all the dynamic
4768 sections immediately. We need to attach them to something,
4769 so we attach them to this BFD, provided it is the right
4770 format. FIXME: If there are no input BFD's of the same
4771 format as the output, we can't make a shared library. */
4772 if (bfd_link_pic (info
)
4773 && is_elf_hash_table (htab
)
4774 && info
->output_bfd
->xvec
== abfd
->xvec
4775 && !htab
->dynamic_sections_created
)
4777 if (! elf64_ia64_create_dynamic_sections (abfd
, info
))
4781 else if (!is_elf_hash_table (htab
))
4789 /* ld --just-symbols and dynamic objects don't mix very well.
4790 ld shouldn't allow it. */
4791 if ((s
= abfd
->sections
) != NULL
4792 && s
->sec_info_type
== SEC_INFO_TYPE_JUST_SYMS
)
4795 /* Be sure there are dynamic sections. */
4796 if (! elf64_ia64_create_dynamic_sections (htab
->dynobj
, info
))
4799 s
= bfd_get_section_by_name (abfd
, ".dynamic");
4802 /* VMS libraries do not have dynamic sections. Create one from
4804 Elf_Internal_Phdr
*phdr
;
4805 unsigned int i
, phnum
;
4807 phdr
= elf_tdata (abfd
)->phdr
;
4810 phnum
= elf_elfheader (abfd
)->e_phnum
;
4811 for (i
= 0; i
< phnum
; phdr
++)
4812 if (phdr
->p_type
== PT_DYNAMIC
)
4814 s
= bfd_make_section (abfd
, ".dynamic");
4817 s
->vma
= phdr
->p_vaddr
;
4818 s
->lma
= phdr
->p_paddr
;
4819 s
->size
= phdr
->p_filesz
;
4820 s
->filepos
= phdr
->p_offset
;
4821 s
->flags
|= SEC_HAS_CONTENTS
;
4822 s
->alignment_power
= bfd_log2 (phdr
->p_align
);
4829 /* Extract IDENT. */
4830 if (!bfd_malloc_and_get_section (abfd
, s
, &dynbuf
))
4837 for (extdyn
= dynbuf
;
4838 extdyn
< dynbuf
+ s
->size
;
4839 extdyn
+= bed
->s
->sizeof_dyn
)
4841 Elf_Internal_Dyn dyn
;
4843 bed
->s
->swap_dyn_in (abfd
, extdyn
, &dyn
);
4844 if (dyn
.d_tag
== DT_IA_64_VMS_IDENT
)
4846 bfd_uint64_t tagv
= dyn
.d_un
.d_val
;
4847 elf_ia64_vms_ident (abfd
) = tagv
;
4851 if (extdyn
>= dynbuf
+ s
->size
)
4853 /* Ident not found. */
4854 goto error_free_dyn
;
4858 /* We do not want to include any of the sections in a dynamic
4859 object in the output file. We hack by simply clobbering the
4860 list of sections in the BFD. This could be handled more
4861 cleanly by, say, a new section flag; the existing
4862 SEC_NEVER_LOAD flag is not the one we want, because that one
4863 still implies that the section takes up space in the output
4865 bfd_section_list_clear (abfd
);
4867 /* FIXME: should we detect if this library is already included ?
4868 This should be harmless and shouldn't happen in practice. */
4871 hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4872 symcount
= hdr
->sh_size
/ bed
->s
->sizeof_sym
;
4874 /* The sh_info field of the symtab header tells us where the
4875 external symbols start. We don't care about the local symbols at
4877 extsymcount
= symcount
- hdr
->sh_info
;
4878 extsymoff
= hdr
->sh_info
;
4881 if (extsymcount
!= 0)
4883 isymbuf
= bfd_elf_get_elf_syms (abfd
, hdr
, extsymcount
, extsymoff
,
4885 if (isymbuf
== NULL
)
4888 /* We store a pointer to the hash table entry for each external
4890 amt
= extsymcount
* sizeof (struct elf_link_hash_entry
*);
4891 sym_hash
= (struct elf_link_hash_entry
**) bfd_alloc (abfd
, amt
);
4892 if (sym_hash
== NULL
)
4893 goto error_free_sym
;
4894 elf_sym_hashes (abfd
) = sym_hash
;
4897 for (isym
= isymbuf
, isymend
= isymbuf
+ extsymcount
;
4903 asection
*sec
, *new_sec
;
4906 struct elf_link_hash_entry
*h
;
4907 bfd_boolean definition
;
4908 bfd_boolean size_change_ok
;
4909 bfd_boolean type_change_ok
;
4911 unsigned int old_alignment
;
4914 flags
= BSF_NO_FLAGS
;
4916 value
= isym
->st_value
;
4918 common
= bed
->common_definition (isym
);
4920 bind
= ELF_ST_BIND (isym
->st_info
);
4924 /* This should be impossible, since ELF requires that all
4925 global symbols follow all local symbols, and that sh_info
4926 point to the first global symbol. Unfortunately, Irix 5
4931 if (isym
->st_shndx
!= SHN_UNDEF
&& !common
)
4939 case STB_GNU_UNIQUE
:
4940 flags
= BSF_GNU_UNIQUE
;
4944 /* Leave it up to the processor backend. */
4948 if (isym
->st_shndx
== SHN_UNDEF
)
4949 sec
= bfd_und_section_ptr
;
4950 else if (isym
->st_shndx
== SHN_ABS
)
4951 sec
= bfd_abs_section_ptr
;
4952 else if (isym
->st_shndx
== SHN_COMMON
)
4954 sec
= bfd_com_section_ptr
;
4955 /* What ELF calls the size we call the value. What ELF
4956 calls the value we call the alignment. */
4957 value
= isym
->st_size
;
4961 sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
4963 sec
= bfd_abs_section_ptr
;
4964 else if (sec
->kept_section
)
4966 /* Symbols from discarded section are undefined. We keep
4968 sec
= bfd_und_section_ptr
;
4969 isym
->st_shndx
= SHN_UNDEF
;
4971 else if ((abfd
->flags
& (EXEC_P
| DYNAMIC
)) != 0)
4975 name
= bfd_elf_string_from_elf_section (abfd
, hdr
->sh_link
,
4978 goto error_free_vers
;
4980 if (bed
->elf_add_symbol_hook
)
4982 if (! (*bed
->elf_add_symbol_hook
) (abfd
, info
, isym
, &name
, &flags
,
4984 goto error_free_vers
;
4986 /* The hook function sets the name to NULL if this symbol
4987 should be skipped for some reason. */
4992 /* Sanity check that all possibilities were handled. */
4995 bfd_set_error (bfd_error_bad_value
);
4996 goto error_free_vers
;
4999 if (bfd_is_und_section (sec
)
5000 || bfd_is_com_section (sec
))
5005 size_change_ok
= FALSE
;
5006 type_change_ok
= bed
->type_change_ok
;
5011 if (! bfd_is_und_section (sec
))
5012 h
= elf_link_hash_lookup (htab
, name
, TRUE
, FALSE
, FALSE
);
5014 h
= ((struct elf_link_hash_entry
*) bfd_wrapped_link_hash_lookup
5015 (abfd
, info
, name
, TRUE
, FALSE
, FALSE
));
5017 goto error_free_sym
;
5021 if (is_elf_hash_table (htab
))
5023 while (h
->root
.type
== bfd_link_hash_indirect
5024 || h
->root
.type
== bfd_link_hash_warning
)
5025 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5027 /* Remember the old alignment if this is a common symbol, so
5028 that we don't reduce the alignment later on. We can't
5029 check later, because _bfd_generic_link_add_one_symbol
5030 will set a default for the alignment which we want to
5031 override. We also remember the old bfd where the existing
5032 definition comes from. */
5033 switch (h
->root
.type
)
5038 case bfd_link_hash_defined
:
5039 if (abfd
->selective_search
)
5042 case bfd_link_hash_defweak
:
5043 old_bfd
= h
->root
.u
.def
.section
->owner
;
5046 case bfd_link_hash_common
:
5047 old_bfd
= h
->root
.u
.c
.p
->section
->owner
;
5048 old_alignment
= h
->root
.u
.c
.p
->alignment_power
;
5053 if (! (_bfd_generic_link_add_one_symbol
5054 (info
, abfd
, name
, flags
, sec
, value
, NULL
, FALSE
, bed
->collect
,
5055 (struct bfd_link_hash_entry
**) sym_hash
)))
5056 goto error_free_vers
;
5059 while (h
->root
.type
== bfd_link_hash_indirect
5060 || h
->root
.type
== bfd_link_hash_warning
)
5061 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5065 h
->unique_global
= (flags
& BSF_GNU_UNIQUE
) != 0;
5067 /* Set the alignment of a common symbol. */
5068 if ((common
|| bfd_is_com_section (sec
))
5069 && h
->root
.type
== bfd_link_hash_common
)
5074 align
= bfd_log2 (isym
->st_value
);
5077 /* The new symbol is a common symbol in a shared object.
5078 We need to get the alignment from the section. */
5079 align
= new_sec
->alignment_power
;
5081 if (align
> old_alignment
5082 /* Permit an alignment power of zero if an alignment of one
5083 is specified and no other alignments have been specified. */
5084 || (isym
->st_value
== 1 && old_alignment
== 0))
5085 h
->root
.u
.c
.p
->alignment_power
= align
;
5087 h
->root
.u
.c
.p
->alignment_power
= old_alignment
;
5090 if (is_elf_hash_table (htab
))
5092 /* Check the alignment when a common symbol is involved. This
5093 can change when a common symbol is overridden by a normal
5094 definition or a common symbol is ignored due to the old
5095 normal definition. We need to make sure the maximum
5096 alignment is maintained. */
5097 if ((old_alignment
|| common
)
5098 && h
->root
.type
!= bfd_link_hash_common
)
5100 unsigned int common_align
;
5101 unsigned int normal_align
;
5102 unsigned int symbol_align
;
5106 symbol_align
= ffs (h
->root
.u
.def
.value
) - 1;
5107 if (h
->root
.u
.def
.section
->owner
!= NULL
5108 && (h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
) == 0)
5110 normal_align
= h
->root
.u
.def
.section
->alignment_power
;
5111 if (normal_align
> symbol_align
)
5112 normal_align
= symbol_align
;
5115 normal_align
= symbol_align
;
5119 common_align
= old_alignment
;
5120 common_bfd
= old_bfd
;
5125 common_align
= bfd_log2 (isym
->st_value
);
5127 normal_bfd
= old_bfd
;
5130 if (normal_align
< common_align
)
5132 /* PR binutils/2735 */
5133 if (normal_bfd
== NULL
)
5135 /* xgettext:c-format */
5136 (_("Warning: alignment %u of common symbol `%s' in %B"
5137 " is greater than the alignment (%u) of its section %A"),
5138 common_bfd
, h
->root
.u
.def
.section
,
5139 1 << common_align
, name
, 1 << normal_align
);
5142 /* xgettext:c-format */
5143 (_("Warning: alignment %u of symbol `%s' in %B"
5144 " is smaller than %u in %B"),
5145 normal_bfd
, common_bfd
,
5146 1 << normal_align
, name
, 1 << common_align
);
5150 /* Remember the symbol size if it isn't undefined. */
5151 if ((isym
->st_size
!= 0 && isym
->st_shndx
!= SHN_UNDEF
)
5152 && (definition
|| h
->size
== 0))
5155 && h
->size
!= isym
->st_size
5156 && ! size_change_ok
)
5158 /* xgettext:c-format */
5159 (_("Warning: size of symbol `%s' changed"
5160 " from %lu in %B to %lu in %B"),
5162 name
, (unsigned long) h
->size
,
5163 (unsigned long) isym
->st_size
);
5165 h
->size
= isym
->st_size
;
5168 /* If this is a common symbol, then we always want H->SIZE
5169 to be the size of the common symbol. The code just above
5170 won't fix the size if a common symbol becomes larger. We
5171 don't warn about a size change here, because that is
5172 covered by --warn-common. Allow changed between different
5174 if (h
->root
.type
== bfd_link_hash_common
)
5175 h
->size
= h
->root
.u
.c
.size
;
5177 if (ELF_ST_TYPE (isym
->st_info
) != STT_NOTYPE
5178 && (definition
|| h
->type
== STT_NOTYPE
))
5180 unsigned int type
= ELF_ST_TYPE (isym
->st_info
);
5182 if (h
->type
!= type
)
5184 if (h
->type
!= STT_NOTYPE
&& ! type_change_ok
)
5186 /* xgettext:c-format */
5187 (_("Warning: type of symbol `%s' changed"
5188 " from %d to %d in %B"),
5189 abfd
, name
, h
->type
, type
);
5195 /* Set a flag in the hash table entry indicating the type of
5196 reference or definition we just found. Keep a count of
5197 the number of dynamic symbols we find. A dynamic symbol
5198 is one which is referenced or defined by both a regular
5199 object and a shared object. */
5205 if (bind
!= STB_WEAK
)
5206 h
->ref_regular_nonweak
= 1;
5210 BFD_ASSERT (!h
->def_dynamic
);
5216 BFD_ASSERT (definition
);
5219 ((struct elf64_ia64_link_hash_entry
*)h
)->shl
= abfd
;
5224 if (isymbuf
!= NULL
)
5230 /* If this object is the same format as the output object, and it is
5231 not a shared library, then let the backend look through the
5234 This is required to build global offset table entries and to
5235 arrange for dynamic relocs. It is not required for the
5236 particular common case of linking non PIC code, even when linking
5237 against shared libraries, but unfortunately there is no way of
5238 knowing whether an object file has been compiled PIC or not.
5239 Looking through the relocs is not particularly time consuming.
5240 The problem is that we must either (1) keep the relocs in memory,
5241 which causes the linker to require additional runtime memory or
5242 (2) read the relocs twice from the input file, which wastes time.
5243 This would be a good case for using mmap.
5245 I have no idea how to handle linking PIC code into a file of a
5246 different format. It probably can't be done. */
5248 && is_elf_hash_table (htab
)
5249 && bed
->check_relocs
!= NULL
5250 && (*bed
->relocs_compatible
) (abfd
->xvec
, info
->output_bfd
->xvec
))
5254 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
5256 Elf_Internal_Rela
*internal_relocs
;
5259 if ((o
->flags
& SEC_RELOC
) == 0
5260 || o
->reloc_count
== 0
5261 || ((info
->strip
== strip_all
|| info
->strip
== strip_debugger
)
5262 && (o
->flags
& SEC_DEBUGGING
) != 0)
5263 || bfd_is_abs_section (o
->output_section
))
5266 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
,
5268 if (internal_relocs
== NULL
)
5271 ok
= (*bed
->check_relocs
) (abfd
, info
, o
, internal_relocs
);
5273 if (elf_section_data (o
)->relocs
!= internal_relocs
)
5274 free (internal_relocs
);
5285 if (isymbuf
!= NULL
)
5292 elf64_vms_link_add_archive_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
5295 struct bfd_link_hash_entry
**pundef
;
5296 struct bfd_link_hash_entry
**next_pundef
;
5298 /* We only accept VMS libraries. */
5299 if (info
->output_bfd
->xvec
!= abfd
->xvec
)
5301 bfd_set_error (bfd_error_wrong_format
);
5305 /* The archive_pass field in the archive itself is used to
5306 initialize PASS, since we may search the same archive multiple
5308 pass
= ++abfd
->archive_pass
;
5310 /* Look through the list of undefined symbols. */
5311 for (pundef
= &info
->hash
->undefs
; *pundef
!= NULL
; pundef
= next_pundef
)
5313 struct bfd_link_hash_entry
*h
;
5319 next_pundef
= &(*pundef
)->u
.undef
.next
;
5321 /* When a symbol is defined, it is not necessarily removed from
5323 if (h
->type
!= bfd_link_hash_undefined
5324 && h
->type
!= bfd_link_hash_common
)
5326 /* Remove this entry from the list, for general cleanliness
5327 and because we are going to look through the list again
5328 if we search any more libraries. We can't remove the
5329 entry if it is the tail, because that would lose any
5330 entries we add to the list later on. */
5331 if (*pundef
!= info
->hash
->undefs_tail
)
5333 *pundef
= *next_pundef
;
5334 next_pundef
= pundef
;
5339 /* Look for this symbol in the archive hash table. */
5340 symidx
= _bfd_vms_lib_find_symbol (abfd
, h
->root
.string
);
5341 if (symidx
== BFD_NO_MORE_SYMBOLS
)
5343 /* Nothing in this slot. */
5347 element
= bfd_get_elt_at_index (abfd
, symidx
);
5348 if (element
== NULL
)
5351 if (element
->archive_pass
== -1 || element
->archive_pass
== pass
)
5353 /* Next symbol if this archive is wrong or already handled. */
5357 orig_element
= element
;
5358 if (bfd_is_thin_archive (abfd
))
5360 element
= _bfd_vms_lib_get_imagelib_file (element
);
5361 if (element
== NULL
|| !bfd_check_format (element
, bfd_object
))
5363 orig_element
->archive_pass
= -1;
5367 else if (! bfd_check_format (element
, bfd_object
))
5369 element
->archive_pass
= -1;
5373 /* Unlike the generic linker, we know that this element provides
5374 a definition for an undefined symbol and we know that we want
5375 to include it. We don't need to check anything. */
5376 if (! (*info
->callbacks
->add_archive_element
) (info
, element
,
5377 h
->root
.string
, &element
))
5379 if (! elf64_vms_link_add_object_symbols (element
, info
))
5382 orig_element
->archive_pass
= pass
;
5389 elf64_vms_bfd_link_add_symbols (bfd
*abfd
, struct bfd_link_info
*info
)
5391 switch (bfd_get_format (abfd
))
5394 return elf64_vms_link_add_object_symbols (abfd
, info
);
5397 return elf64_vms_link_add_archive_symbols (abfd
, info
);
5400 bfd_set_error (bfd_error_wrong_format
);
5406 elf64_ia64_vms_mkobject (bfd
*abfd
)
5408 return bfd_elf_allocate_object
5409 (abfd
, sizeof (struct elf64_ia64_vms_obj_tdata
), IA64_ELF_DATA
);
5413 /* Size-dependent data and functions. */
5414 static const struct elf_size_info elf64_ia64_vms_size_info
= {
5415 sizeof (Elf64_External_VMS_Ehdr
),
5416 sizeof (Elf64_External_Phdr
),
5417 sizeof (Elf64_External_Shdr
),
5418 sizeof (Elf64_External_Rel
),
5419 sizeof (Elf64_External_Rela
),
5420 sizeof (Elf64_External_Sym
),
5421 sizeof (Elf64_External_Dyn
),
5422 sizeof (Elf_External_Note
),
5425 64, 3, /* ARCH_SIZE, LOG_FILE_ALIGN */
5426 ELFCLASS64
, EV_CURRENT
,
5427 bfd_elf64_write_out_phdrs
,
5428 elf64_vms_write_shdrs_and_ehdr
,
5429 bfd_elf64_checksum_contents
,
5430 bfd_elf64_write_relocs
,
5431 bfd_elf64_swap_symbol_in
,
5432 bfd_elf64_swap_symbol_out
,
5433 bfd_elf64_slurp_reloc_table
,
5434 bfd_elf64_slurp_symbol_table
,
5435 bfd_elf64_swap_dyn_in
,
5436 bfd_elf64_swap_dyn_out
,
5437 bfd_elf64_swap_reloc_in
,
5438 bfd_elf64_swap_reloc_out
,
5439 bfd_elf64_swap_reloca_in
,
5440 bfd_elf64_swap_reloca_out
5443 #define ELF_ARCH bfd_arch_ia64
5444 #define ELF_MACHINE_CODE EM_IA_64
5445 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
5446 #define ELF_COMMONPAGESIZE 0x200 /* 16KB */
5448 #define elf_backend_section_from_shdr \
5449 elf64_ia64_section_from_shdr
5450 #define elf_backend_section_flags \
5451 elf64_ia64_section_flags
5452 #define elf_backend_fake_sections \
5453 elf64_ia64_fake_sections
5454 #define elf_backend_final_write_processing \
5455 elf64_ia64_final_write_processing
5456 #define elf_backend_add_symbol_hook \
5457 elf64_ia64_add_symbol_hook
5458 #define elf_info_to_howto \
5459 elf64_ia64_info_to_howto
5461 #define bfd_elf64_bfd_reloc_type_lookup \
5462 ia64_elf_reloc_type_lookup
5463 #define bfd_elf64_bfd_reloc_name_lookup \
5464 ia64_elf_reloc_name_lookup
5465 #define bfd_elf64_bfd_is_local_label_name \
5466 elf64_ia64_is_local_label_name
5467 #define bfd_elf64_bfd_relax_section \
5468 elf64_ia64_relax_section
5470 #define elf_backend_object_p \
5473 /* Stuff for the BFD linker: */
5474 #define bfd_elf64_bfd_link_hash_table_create \
5475 elf64_ia64_hash_table_create
5476 #define elf_backend_create_dynamic_sections \
5477 elf64_ia64_create_dynamic_sections
5478 #define elf_backend_check_relocs \
5479 elf64_ia64_check_relocs
5480 #define elf_backend_adjust_dynamic_symbol \
5481 elf64_ia64_adjust_dynamic_symbol
5482 #define elf_backend_size_dynamic_sections \
5483 elf64_ia64_size_dynamic_sections
5484 #define elf_backend_omit_section_dynsym \
5485 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5486 #define elf_backend_relocate_section \
5487 elf64_ia64_relocate_section
5488 #define elf_backend_finish_dynamic_symbol \
5489 elf64_ia64_finish_dynamic_symbol
5490 #define elf_backend_finish_dynamic_sections \
5491 elf64_ia64_finish_dynamic_sections
5492 #define bfd_elf64_bfd_final_link \
5493 elf64_ia64_final_link
5495 #define bfd_elf64_bfd_merge_private_bfd_data \
5496 elf64_ia64_merge_private_bfd_data
5497 #define bfd_elf64_bfd_set_private_flags \
5498 elf64_ia64_set_private_flags
5499 #define bfd_elf64_bfd_print_private_bfd_data \
5500 elf64_ia64_print_private_bfd_data
5502 #define elf_backend_plt_readonly 1
5503 #define elf_backend_want_plt_sym 0
5504 #define elf_backend_plt_alignment 5
5505 #define elf_backend_got_header_size 0
5506 #define elf_backend_want_got_plt 1
5507 #define elf_backend_may_use_rel_p 1
5508 #define elf_backend_may_use_rela_p 1
5509 #define elf_backend_default_use_rela_p 1
5510 #define elf_backend_want_dynbss 0
5511 #define elf_backend_hide_symbol elf64_ia64_hash_hide_symbol
5512 #define elf_backend_fixup_symbol _bfd_elf_link_hash_fixup_symbol
5513 #define elf_backend_reloc_type_class elf64_ia64_reloc_type_class
5514 #define elf_backend_rela_normal 1
5515 #define elf_backend_special_sections elf64_ia64_special_sections
5516 #define elf_backend_default_execstack 0
5518 /* FIXME: PR 290: The Intel C compiler generates SHT_IA_64_UNWIND with
5519 SHF_LINK_ORDER. But it doesn't set the sh_link or sh_info fields.
5520 We don't want to flood users with so many error messages. We turn
5521 off the warning for now. It will be turned on later when the Intel
5522 compiler is fixed. */
5523 #define elf_backend_link_order_error_handler NULL
5525 /* VMS-specific vectors. */
5527 #undef TARGET_LITTLE_SYM
5528 #define TARGET_LITTLE_SYM ia64_elf64_vms_vec
5529 #undef TARGET_LITTLE_NAME
5530 #define TARGET_LITTLE_NAME "elf64-ia64-vms"
5531 #undef TARGET_BIG_SYM
5532 #undef TARGET_BIG_NAME
5534 /* These are VMS specific functions. */
5536 #undef elf_backend_object_p
5537 #define elf_backend_object_p elf64_vms_object_p
5539 #undef elf_backend_section_from_shdr
5540 #define elf_backend_section_from_shdr elf64_vms_section_from_shdr
5542 #undef elf_backend_post_process_headers
5543 #define elf_backend_post_process_headers elf64_vms_post_process_headers
5545 #undef elf_backend_section_processing
5546 #define elf_backend_section_processing elf64_vms_section_processing
5548 #undef elf_backend_final_write_processing
5549 #define elf_backend_final_write_processing elf64_vms_final_write_processing
5551 #undef bfd_elf64_close_and_cleanup
5552 #define bfd_elf64_close_and_cleanup elf64_vms_close_and_cleanup
5554 #undef elf_backend_section_from_bfd_section
5556 #undef elf_backend_symbol_processing
5558 #undef elf_backend_want_p_paddr_set_to_zero
5561 #define ELF_OSABI ELFOSABI_OPENVMS
5563 #undef ELF_MAXPAGESIZE
5564 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
5567 #define elf64_bed elf64_ia64_vms_bed
5569 #define elf_backend_size_info elf64_ia64_vms_size_info
5571 /* Use VMS-style archives (in particular, don't use the standard coff
5573 #define bfd_elf64_archive_functions
5575 #undef bfd_elf64_archive_p
5576 #define bfd_elf64_archive_p _bfd_vms_lib_ia64_archive_p
5577 #undef bfd_elf64_write_archive_contents
5578 #define bfd_elf64_write_archive_contents _bfd_vms_lib_write_archive_contents
5579 #undef bfd_elf64_mkarchive
5580 #define bfd_elf64_mkarchive _bfd_vms_lib_ia64_mkarchive
5582 #define bfd_elf64_archive_slurp_armap \
5583 _bfd_vms_lib_slurp_armap
5584 #define bfd_elf64_archive_slurp_extended_name_table \
5585 _bfd_vms_lib_slurp_extended_name_table
5586 #define bfd_elf64_archive_construct_extended_name_table \
5587 _bfd_vms_lib_construct_extended_name_table
5588 #define bfd_elf64_archive_truncate_arname \
5589 _bfd_vms_lib_truncate_arname
5590 #define bfd_elf64_archive_write_armap \
5591 _bfd_vms_lib_write_armap
5592 #define bfd_elf64_archive_read_ar_hdr \
5593 _bfd_vms_lib_read_ar_hdr
5594 #define bfd_elf64_archive_write_ar_hdr \
5595 _bfd_vms_lib_write_ar_hdr
5596 #define bfd_elf64_archive_openr_next_archived_file \
5597 _bfd_vms_lib_openr_next_archived_file
5598 #define bfd_elf64_archive_get_elt_at_index \
5599 _bfd_vms_lib_get_elt_at_index
5600 #define bfd_elf64_archive_generic_stat_arch_elt \
5601 _bfd_vms_lib_generic_stat_arch_elt
5602 #define bfd_elf64_archive_update_armap_timestamp \
5603 _bfd_vms_lib_update_armap_timestamp
5605 /* VMS link methods. */
5606 #undef bfd_elf64_bfd_link_add_symbols
5607 #define bfd_elf64_bfd_link_add_symbols elf64_vms_bfd_link_add_symbols
5609 #undef elf_backend_want_got_sym
5610 #define elf_backend_want_got_sym 0
5612 #undef bfd_elf64_mkobject
5613 #define bfd_elf64_mkobject elf64_ia64_vms_mkobject
5615 /* Redefine to align segments on block size. */
5616 #undef ELF_MAXPAGESIZE
5617 #define ELF_MAXPAGESIZE 0x200 /* 512B */
5619 #undef elf_backend_want_got_plt
5620 #define elf_backend_want_got_plt 0
5622 #include "elf64-target.h"