From 202e23565d36f4696d5e836ec06d4c685c30fb16 Mon Sep 17 00:00:00 2001 From: Nick Clifton Date: Thu, 12 Apr 2012 07:35:07 +0000 Subject: [PATCH] * configure.ac (ia64*-*-*vms*): Add support for ld. * configure: Regenerate. * scripttempl/ia64vms.sc: New file. * emultempl/vms.em (_before_parse): Support for ia64. (elf64-ia64-vms): New fragment for ia64. * emulparams/elf64_ia64_vms.sh: New file. * configure.tgt (ia64-*-*vms*): Add. * Makefile.am (ALL_64_EMULATION_SOURCES): Add eelf64_ia64_vms.c (eelf64_ia64_vms.c): New rule. * Makefile.in: Regenerate. * elflink.c (elf_link_output_extsym): Add a guard. (bfd_elf_final_link): Remove assertion. (bfd_elf_final_link): Add a guard. * elfnn-ia64.c (INCLUDE_IA64_VMS): Removed. (elfNN_vms_section_from_shdr, elfNN_vms_object_p) (elfNN_vms_post_process_headers, elfNN_vms_section_processing) (elfNN_vms_final_write_processing, elfNN_vms_close_and_cleanup): Remove. (elfNN-ia64-vms target): Move to ... * elf64-ia64-vms.c: New file. * configure.in (bfd_elf64_ia64_vms_vec): Add elf64-ia64-vms.lo * Makefile.am (BFD64_BACKENDS): Add elf64-ia64-vms.lo. (BFD64_BACKENDS_CFILES): Ad elf64-ia64-vms.c. * configure: Regenerate. * Makefile.in: Regenerate. --- ChangeLog | 5 + bfd/ChangeLog | 18 + bfd/Makefile.am | 2 + bfd/Makefile.in | 3 + bfd/configure | 2 +- bfd/configure.in | 2 +- bfd/elf64-ia64-vms.c | 5601 +++++++++++++++++++++++++++++++ bfd/elflink.c | 6 +- bfd/elfnn-ia64.c | 364 +- configure | 7 +- configure.ac | 9 +- ld/ChangeLog | 11 + ld/Makefile.am | 5 + ld/Makefile.in | 7 + ld/configure.tgt | 1 + ld/emulparams/elf64_ia64_vms.sh | 7 + ld/emultempl/vms.em | 64 +- ld/scripttempl/ia64vms.sc | 129 + 18 files changed, 5868 insertions(+), 375 deletions(-) create mode 100644 bfd/elf64-ia64-vms.c create mode 100644 ld/emulparams/elf64_ia64_vms.sh create mode 100644 ld/scripttempl/ia64vms.sc diff --git a/ChangeLog b/ChangeLog index cff1dfb1e61..c4b159fd5cb 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,8 @@ +2012-03-19 Tristan Gingold + + * configure.ac (ia64*-*-*vms*): Add support for ld. + * configure: Regenerate. + 2012-03-14 Rainer Orth * configure.ac (enable_libgomp): Remove *-*-irix6*. diff --git a/bfd/ChangeLog b/bfd/ChangeLog index 74f8c3a3559..f84e7584b01 100644 --- a/bfd/ChangeLog +++ b/bfd/ChangeLog @@ -1,3 +1,21 @@ +2012-04-12 Tristan Gingold + + * elflink.c (elf_link_output_extsym): Add a guard. + (bfd_elf_final_link): Remove assertion. + (bfd_elf_final_link): Add a guard. + * elfnn-ia64.c (INCLUDE_IA64_VMS): Removed. + (elfNN_vms_section_from_shdr, elfNN_vms_object_p) + (elfNN_vms_post_process_headers, elfNN_vms_section_processing) + (elfNN_vms_final_write_processing, elfNN_vms_close_and_cleanup): + Remove. + (elfNN-ia64-vms target): Move to ... + * elf64-ia64-vms.c: New file. + * configure.in (bfd_elf64_ia64_vms_vec): Add elf64-ia64-vms.lo + * Makefile.am (BFD64_BACKENDS): Add elf64-ia64-vms.lo. + (BFD64_BACKENDS_CFILES): Ad elf64-ia64-vms.c. + * configure: Regenerate. + * Makefile.in: Regenerate. + 2012-04-11 Nick Clifton PR binutils/13897 diff --git a/bfd/Makefile.am b/bfd/Makefile.am index 50c84ee0ea5..627f1bb8dcc 100644 --- a/bfd/Makefile.am +++ b/bfd/Makefile.am @@ -619,6 +619,7 @@ BFD64_BACKENDS = \ elf64-gen.lo \ elf64-hppa.lo \ elf64-ia64.lo \ + elf64-ia64-vms.lo \ elf64-mips.lo \ elf64-mmix.lo \ elf64-ppc.lo \ @@ -654,6 +655,7 @@ BFD64_BACKENDS_CFILES = \ elf64-alpha.c \ elf64-gen.c \ elf64-hppa.c \ + elf64-ia64-vms.c \ elf64-mips.c \ elf64-mmix.c \ elf64-ppc.c \ diff --git a/bfd/Makefile.in b/bfd/Makefile.in index cf7b3807917..6d9c760cee8 100644 --- a/bfd/Makefile.in +++ b/bfd/Makefile.in @@ -920,6 +920,7 @@ BFD64_BACKENDS = \ elf64-gen.lo \ elf64-hppa.lo \ elf64-ia64.lo \ + elf64-ia64-vms.lo \ elf64-mips.lo \ elf64-mmix.lo \ elf64-ppc.lo \ @@ -955,6 +956,7 @@ BFD64_BACKENDS_CFILES = \ elf64-alpha.c \ elf64-gen.c \ elf64-hppa.c \ + elf64-ia64-vms.c \ elf64-mips.c \ elf64-mmix.c \ elf64-ppc.c \ @@ -1416,6 +1418,7 @@ distclean-compile: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf64-alpha.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf64-gen.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf64-hppa.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf64-ia64-vms.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf64-ia64.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf64-mips.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elf64-mmix.Plo@am__quote@ diff --git a/bfd/configure b/bfd/configure index dd274bd8868..d90e52f2306 100755 --- a/bfd/configure +++ b/bfd/configure @@ -15341,7 +15341,7 @@ do bfd_elf64_ia64_big_vec) tb="$tb elf64-ia64.lo elfxx-ia64.lo elf64.lo $elf"; target_size=64 ;; bfd_elf64_ia64_hpux_big_vec) tb="$tb elf64-ia64.lo elfxx-ia64.lo elf64.lo $elf"; target_size=64 ;; bfd_elf64_ia64_little_vec) tb="$tb elf64-ia64.lo elfxx-ia64.lo elf64.lo $elf"; target_size=64 ;; - bfd_elf64_ia64_vms_vec) tb="$tb elf64-ia64.lo elfxx-ia64.lo elf64.lo vms-lib.lo vms-misc.lo $elf"; target_size=64 ;; + bfd_elf64_ia64_vms_vec) tb="$tb elf64-ia64-vms.lo elf64-ia64.lo elfxx-ia64.lo elf64.lo vms-lib.lo vms-misc.lo $elf"; target_size=64 ;; bfd_elf64_little_generic_vec) tb="$tb elf64-gen.lo elf64.lo $elf"; target_size=64 ;; bfd_elf64_littlemips_vec) tb="$tb elf64-mips.lo elf64.lo elfxx-mips.lo elf-vxworks.lo elf32.lo $elf ecofflink.lo"; target_size=64 ;; bfd_elf64_mmix_vec) tb="$tb elf64-mmix.lo elf64.lo $elf" target_size=64 ;; diff --git a/bfd/configure.in b/bfd/configure.in index af3622b426f..37cc769290a 100644 --- a/bfd/configure.in +++ b/bfd/configure.in @@ -827,7 +827,7 @@ do bfd_elf64_ia64_big_vec) tb="$tb elf64-ia64.lo elfxx-ia64.lo elf64.lo $elf"; target_size=64 ;; bfd_elf64_ia64_hpux_big_vec) tb="$tb elf64-ia64.lo elfxx-ia64.lo elf64.lo $elf"; target_size=64 ;; bfd_elf64_ia64_little_vec) tb="$tb elf64-ia64.lo elfxx-ia64.lo elf64.lo $elf"; target_size=64 ;; - bfd_elf64_ia64_vms_vec) tb="$tb elf64-ia64.lo elfxx-ia64.lo elf64.lo vms-lib.lo vms-misc.lo $elf"; target_size=64 ;; + bfd_elf64_ia64_vms_vec) tb="$tb elf64-ia64-vms.lo elf64-ia64.lo elfxx-ia64.lo elf64.lo vms-lib.lo vms-misc.lo $elf"; target_size=64 ;; bfd_elf64_little_generic_vec) tb="$tb elf64-gen.lo elf64.lo $elf"; target_size=64 ;; bfd_elf64_littlemips_vec) tb="$tb elf64-mips.lo elf64.lo elfxx-mips.lo elf-vxworks.lo elf32.lo $elf ecofflink.lo"; target_size=64 ;; bfd_elf64_mmix_vec) tb="$tb elf64-mmix.lo elf64.lo $elf" target_size=64 ;; diff --git a/bfd/elf64-ia64-vms.c b/bfd/elf64-ia64-vms.c new file mode 100644 index 00000000000..1ab8e385f2f --- /dev/null +++ b/bfd/elf64-ia64-vms.c @@ -0,0 +1,5601 @@ +/* IA-64 support for OpenVMS + Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, + 2008, 2009, 2010, 2012 Free Software Foundation, Inc. + + This file is part of BFD, the Binary File Descriptor library. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, + MA 02110-1301, USA. */ + +#include "sysdep.h" +#include "bfd.h" +#include "libbfd.h" +#include "elf-bfd.h" +#include "opcode/ia64.h" +#include "elf/ia64.h" +#include "objalloc.h" +#include "hashtab.h" +#include "elfxx-ia64.h" +#include "vms.h" +#include "bfdver.h" + +/* THE RULES for all the stuff the linker creates -- + + GOT Entries created in response to LTOFF or LTOFF_FPTR + relocations. Dynamic relocs created for dynamic + symbols in an application; REL relocs for locals + in a shared library. + + FPTR The canonical function descriptor. Created for local + symbols in applications. Descriptors for dynamic symbols + and local symbols in shared libraries are created by + ld.so. Thus there are no dynamic relocs against these + objects. The FPTR relocs for such _are_ passed through + to the dynamic relocation tables. + + FULL_PLT Created for a PCREL21B relocation against a dynamic symbol. + Requires the creation of a PLTOFF entry. This does not + require any dynamic relocations. + + PLTOFF Created by PLTOFF relocations. For local symbols, this + is an alternate function descriptor, and in shared libraries + requires two REL relocations. Note that this cannot be + transformed into an FPTR relocation, since it must be in + range of the GP. For dynamic symbols, this is a function + descriptor. */ + +typedef struct bfd_hash_entry *(*new_hash_entry_func) + (struct bfd_hash_entry *, struct bfd_hash_table *, const char *); + +/* In dynamically (linker-) created sections, we generally need to keep track + of the place a symbol or expression got allocated to. This is done via hash + tables that store entries of the following type. */ + +struct elf64_ia64_dyn_sym_info +{ + /* The addend for which this entry is relevant. */ + bfd_vma addend; + + bfd_vma got_offset; + bfd_vma fptr_offset; + bfd_vma pltoff_offset; + bfd_vma plt_offset; + bfd_vma plt2_offset; + + /* The symbol table entry, if any, that this was derived from. */ + struct elf_link_hash_entry *h; + + /* Used to count non-got, non-plt relocations for delayed sizing + of relocation sections. */ + struct elf64_ia64_dyn_reloc_entry + { + struct elf64_ia64_dyn_reloc_entry *next; + asection *srel; + int type; + int count; + } *reloc_entries; + + /* TRUE when the section contents have been updated. */ + unsigned got_done : 1; + unsigned fptr_done : 1; + unsigned pltoff_done : 1; + + /* TRUE for the different kinds of linker data we want created. */ + unsigned want_got : 1; + unsigned want_gotx : 1; + unsigned want_fptr : 1; + unsigned want_ltoff_fptr : 1; + unsigned want_plt : 1; /* A MIN_PLT entry. */ + unsigned want_plt2 : 1; /* A FULL_PLT. */ + unsigned want_pltoff : 1; +}; + +struct elf64_ia64_local_hash_entry +{ + int id; + unsigned int r_sym; + /* The number of elements in elf64_ia64_dyn_sym_info array. */ + unsigned int count; + /* The number of sorted elements in elf64_ia64_dyn_sym_info array. */ + unsigned int sorted_count; + /* The size of elf64_ia64_dyn_sym_info array. */ + unsigned int size; + /* The array of elf64_ia64_dyn_sym_info. */ + struct elf64_ia64_dyn_sym_info *info; + + /* TRUE if this hash entry's addends was translated for + SHF_MERGE optimization. */ + unsigned sec_merge_done : 1; +}; + +struct elf64_ia64_link_hash_entry +{ + struct elf_link_hash_entry root; + + /* Set if this symbol is defined in a shared library. + We can't use root.u.def.section->owner as the symbol is an absolute + symbol. */ + bfd *shl; + + /* The number of elements in elf64_ia64_dyn_sym_info array. */ + unsigned int count; + /* The number of sorted elements in elf64_ia64_dyn_sym_info array. */ + unsigned int sorted_count; + /* The size of elf64_ia64_dyn_sym_info array. */ + unsigned int size; + /* The array of elf64_ia64_dyn_sym_info. */ + struct elf64_ia64_dyn_sym_info *info; +}; + +struct elf64_ia64_link_hash_table +{ + /* The main hash table. */ + struct elf_link_hash_table root; + + asection *fptr_sec; /* Function descriptor table (or NULL). */ + asection *rel_fptr_sec; /* Dynamic relocation section for same. */ + asection *pltoff_sec; /* Private descriptors for plt (or NULL). */ + asection *fixups_sec; /* Fixups section. */ + asection *transfer_sec; /* Transfer vector section. */ + asection *note_sec; /* .note section. */ + + /* There are maybe R_IA64_GPREL22 relocations, including those + optimized from R_IA64_LTOFF22X, against non-SHF_IA_64_SHORT + sections. We need to record those sections so that we can choose + a proper GP to cover all R_IA64_GPREL22 relocations. */ + asection *max_short_sec; /* Maximum short output section. */ + bfd_vma max_short_offset; /* Maximum short offset. */ + asection *min_short_sec; /* Minimum short output section. */ + bfd_vma min_short_offset; /* Minimum short offset. */ + + htab_t loc_hash_table; + void *loc_hash_memory; +}; + +struct elf64_ia64_allocate_data +{ + struct bfd_link_info *info; + bfd_size_type ofs; +}; + +#define elf64_ia64_hash_table(p) \ + (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \ + == IA64_ELF_DATA ? ((struct elf64_ia64_link_hash_table *) ((p)->hash)) : NULL) + +struct elf64_ia64_vms_obj_tdata +{ + struct elf_obj_tdata root; + + /* Ident for shared library. */ + bfd_uint64_t ident; + + /* Used only during link: offset in the .fixups section for this bfd. */ + bfd_vma fixups_off; + + /* Max number of shared libraries. */ + unsigned int needed_count; +}; + +#define elf_ia64_vms_tdata(abfd) \ + ((struct elf64_ia64_vms_obj_tdata *)((abfd)->tdata.any)) +#define elf_ia64_vms_ident(abfd) (elf_ia64_vms_tdata(abfd)->ident) + +struct elf64_vms_transfer +{ + unsigned char size[4]; + unsigned char spare[4]; + unsigned char tfradr1[8]; + unsigned char tfradr2[8]; + unsigned char tfradr3[8]; + unsigned char tfradr4[8]; + unsigned char tfradr5[8]; + + /* Local function descriptor for tfr3. */ + unsigned char tfr3_func[8]; + unsigned char tfr3_gp[8]; +}; + +typedef struct +{ + Elf64_External_Ehdr ehdr; + unsigned char vms_needed_count[8]; +} Elf64_External_VMS_Ehdr; + +static struct elf64_ia64_dyn_sym_info * get_dyn_sym_info + (struct elf64_ia64_link_hash_table *, + struct elf_link_hash_entry *, + bfd *, const Elf_Internal_Rela *, bfd_boolean); +static bfd_boolean elf64_ia64_dynamic_symbol_p + (struct elf_link_hash_entry *); +static bfd_boolean elf64_ia64_choose_gp + (bfd *, struct bfd_link_info *, bfd_boolean); +static void elf64_ia64_dyn_sym_traverse + (struct elf64_ia64_link_hash_table *, + bfd_boolean (*) (struct elf64_ia64_dyn_sym_info *, void *), + void *); +static bfd_boolean allocate_global_data_got + (struct elf64_ia64_dyn_sym_info *, void *); +static bfd_boolean allocate_global_fptr_got + (struct elf64_ia64_dyn_sym_info *, void *); +static bfd_boolean allocate_local_got + (struct elf64_ia64_dyn_sym_info *, void *); +static bfd_boolean allocate_dynrel_entries + (struct elf64_ia64_dyn_sym_info *, void *); +static asection *get_pltoff + (bfd *, struct elf64_ia64_link_hash_table *); +static asection *get_got + (bfd *, struct elf64_ia64_link_hash_table *); + + +/* Given a ELF reloc, return the matching HOWTO structure. */ + +static void +elf64_ia64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, + arelent *bfd_reloc, + Elf_Internal_Rela *elf_reloc) +{ + bfd_reloc->howto + = ia64_elf_lookup_howto ((unsigned int) ELF64_R_TYPE (elf_reloc->r_info)); +} + + +#define PLT_FULL_ENTRY_SIZE (2 * 16) + +static const bfd_byte plt_full_entry[PLT_FULL_ENTRY_SIZE] = +{ + 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */ + 0x00, 0x41, 0x3c, 0x70, 0x29, 0xc0, /* ld8.acq r16=[r15],8*/ + 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */ + 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */ + 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */ + 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */ +}; + +static const bfd_byte oor_brl[16] = +{ + 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;;*/ + 0x00, 0x00, 0x00, 0xc0 +}; + + +/* These functions do relaxation for IA-64 ELF. */ + +/* Rename some of the generic section flags to better document how they + are used here. */ +#define skip_relax_pass_0 sec_flg0 +#define skip_relax_pass_1 sec_flg1 + +static void +elf64_ia64_update_short_info (asection *sec, bfd_vma offset, + struct elf64_ia64_link_hash_table *ia64_info) +{ + /* Skip ABS and SHF_IA_64_SHORT sections. */ + if (sec == bfd_abs_section_ptr + || (sec->flags & SEC_SMALL_DATA) != 0) + return; + + if (!ia64_info->min_short_sec) + { + ia64_info->max_short_sec = sec; + ia64_info->max_short_offset = offset; + ia64_info->min_short_sec = sec; + ia64_info->min_short_offset = offset; + } + else if (sec == ia64_info->max_short_sec + && offset > ia64_info->max_short_offset) + ia64_info->max_short_offset = offset; + else if (sec == ia64_info->min_short_sec + && offset < ia64_info->min_short_offset) + ia64_info->min_short_offset = offset; + else if (sec->output_section->vma + > ia64_info->max_short_sec->vma) + { + ia64_info->max_short_sec = sec; + ia64_info->max_short_offset = offset; + } + else if (sec->output_section->vma + < ia64_info->min_short_sec->vma) + { + ia64_info->min_short_sec = sec; + ia64_info->min_short_offset = offset; + } +} + +/* Use a two passes algorithm. In the first pass, branches are relaxed + (which may increase the size of the section). In the second pass, + the other relaxations are done. +*/ + +static bfd_boolean +elf64_ia64_relax_section (bfd *abfd, asection *sec, + struct bfd_link_info *link_info, + bfd_boolean *again) +{ + struct one_fixup + { + struct one_fixup *next; + asection *tsec; + bfd_vma toff; + bfd_vma trampoff; + }; + + Elf_Internal_Shdr *symtab_hdr; + Elf_Internal_Rela *internal_relocs; + Elf_Internal_Rela *irel, *irelend; + bfd_byte *contents; + Elf_Internal_Sym *isymbuf = NULL; + struct elf64_ia64_link_hash_table *ia64_info; + struct one_fixup *fixups = NULL; + bfd_boolean changed_contents = FALSE; + bfd_boolean changed_relocs = FALSE; + bfd_boolean skip_relax_pass_0 = TRUE; + bfd_boolean skip_relax_pass_1 = TRUE; + bfd_vma gp = 0; + + /* Assume we're not going to change any sizes, and we'll only need + one pass. */ + *again = FALSE; + + if (link_info->relocatable) + (*link_info->callbacks->einfo) + (_("%P%F: --relax and -r may not be used together\n")); + + /* Don't even try to relax for non-ELF outputs. */ + if (!is_elf_hash_table (link_info->hash)) + return FALSE; + + /* Nothing to do if there are no relocations or there is no need for + the current pass. */ + if ((sec->flags & SEC_RELOC) == 0 + || sec->reloc_count == 0 + || (link_info->relax_pass == 0 && sec->skip_relax_pass_0) + || (link_info->relax_pass == 1 && sec->skip_relax_pass_1)) + return TRUE; + + ia64_info = elf64_ia64_hash_table (link_info); + if (ia64_info == NULL) + return FALSE; + + symtab_hdr = &elf_tdata (abfd)->symtab_hdr; + + /* Load the relocations for this section. */ + internal_relocs = (_bfd_elf_link_read_relocs + (abfd, sec, NULL, (Elf_Internal_Rela *) NULL, + link_info->keep_memory)); + if (internal_relocs == NULL) + return FALSE; + + irelend = internal_relocs + sec->reloc_count; + + /* Get the section contents. */ + if (elf_section_data (sec)->this_hdr.contents != NULL) + contents = elf_section_data (sec)->this_hdr.contents; + else + { + if (!bfd_malloc_and_get_section (abfd, sec, &contents)) + goto error_return; + } + + for (irel = internal_relocs; irel < irelend; irel++) + { + unsigned long r_type = ELF64_R_TYPE (irel->r_info); + bfd_vma symaddr, reladdr, trampoff, toff, roff; + asection *tsec; + struct one_fixup *f; + bfd_size_type amt; + bfd_boolean is_branch; + struct elf64_ia64_dyn_sym_info *dyn_i; + + switch (r_type) + { + case R_IA64_PCREL21B: + case R_IA64_PCREL21BI: + case R_IA64_PCREL21M: + case R_IA64_PCREL21F: + /* In pass 1, all br relaxations are done. We can skip it. */ + if (link_info->relax_pass == 1) + continue; + skip_relax_pass_0 = FALSE; + is_branch = TRUE; + break; + + case R_IA64_PCREL60B: + /* We can't optimize brl to br in pass 0 since br relaxations + will increase the code size. Defer it to pass 1. */ + if (link_info->relax_pass == 0) + { + skip_relax_pass_1 = FALSE; + continue; + } + is_branch = TRUE; + break; + + case R_IA64_GPREL22: + /* Update max_short_sec/min_short_sec. */ + + case R_IA64_LTOFF22X: + case R_IA64_LDXMOV: + /* We can't relax ldx/mov in pass 0 since br relaxations will + increase the code size. Defer it to pass 1. */ + if (link_info->relax_pass == 0) + { + skip_relax_pass_1 = FALSE; + continue; + } + is_branch = FALSE; + break; + + default: + continue; + } + + /* Get the value of the symbol referred to by the reloc. */ + if (ELF64_R_SYM (irel->r_info) < symtab_hdr->sh_info) + { + /* A local symbol. */ + Elf_Internal_Sym *isym; + + /* Read this BFD's local symbols. */ + if (isymbuf == NULL) + { + isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; + if (isymbuf == NULL) + isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, + symtab_hdr->sh_info, 0, + NULL, NULL, NULL); + if (isymbuf == 0) + goto error_return; + } + + isym = isymbuf + ELF64_R_SYM (irel->r_info); + if (isym->st_shndx == SHN_UNDEF) + continue; /* We can't do anything with undefined symbols. */ + else if (isym->st_shndx == SHN_ABS) + tsec = bfd_abs_section_ptr; + else if (isym->st_shndx == SHN_COMMON) + tsec = bfd_com_section_ptr; + else if (isym->st_shndx == SHN_IA_64_ANSI_COMMON) + tsec = bfd_com_section_ptr; + else + tsec = bfd_section_from_elf_index (abfd, isym->st_shndx); + + toff = isym->st_value; + dyn_i = get_dyn_sym_info (ia64_info, NULL, abfd, irel, FALSE); + } + else + { + unsigned long indx; + struct elf_link_hash_entry *h; + + indx = ELF64_R_SYM (irel->r_info) - symtab_hdr->sh_info; + h = elf_sym_hashes (abfd)[indx]; + BFD_ASSERT (h != NULL); + + while (h->root.type == bfd_link_hash_indirect + || h->root.type == bfd_link_hash_warning) + h = (struct elf_link_hash_entry *) h->root.u.i.link; + + dyn_i = get_dyn_sym_info (ia64_info, h, abfd, irel, FALSE); + + /* For branches to dynamic symbols, we're interested instead + in a branch to the PLT entry. */ + if (is_branch && dyn_i && dyn_i->want_plt2) + { + /* Internal branches shouldn't be sent to the PLT. + Leave this for now and we'll give an error later. */ + if (r_type != R_IA64_PCREL21B) + continue; + + tsec = ia64_info->root.splt; + toff = dyn_i->plt2_offset; + BFD_ASSERT (irel->r_addend == 0); + } + + /* Can't do anything else with dynamic symbols. */ + else if (elf64_ia64_dynamic_symbol_p (h)) + continue; + + else + { + /* We can't do anything with undefined symbols. */ + if (h->root.type == bfd_link_hash_undefined + || h->root.type == bfd_link_hash_undefweak) + continue; + + tsec = h->root.u.def.section; + toff = h->root.u.def.value; + } + } + + toff += irel->r_addend; + + symaddr = tsec->output_section->vma + tsec->output_offset + toff; + + roff = irel->r_offset; + + if (is_branch) + { + bfd_signed_vma offset; + + reladdr = (sec->output_section->vma + + sec->output_offset + + roff) & (bfd_vma) -4; + + /* The .plt section is aligned at 32byte and the .text section + is aligned at 64byte. The .text section is right after the + .plt section. After the first relaxation pass, linker may + increase the gap between the .plt and .text sections up + to 32byte. We assume linker will always insert 32byte + between the .plt and .text sections after the the first + relaxation pass. */ + if (tsec == ia64_info->root.splt) + offset = -0x1000000 + 32; + else + offset = -0x1000000; + + /* If the branch is in range, no need to do anything. */ + if ((bfd_signed_vma) (symaddr - reladdr) >= offset + && (bfd_signed_vma) (symaddr - reladdr) <= 0x0FFFFF0) + { + /* If the 60-bit branch is in 21-bit range, optimize it. */ + if (r_type == R_IA64_PCREL60B) + { + ia64_elf_relax_brl (contents, roff); + + irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), + R_IA64_PCREL21B); + + /* If the original relocation offset points to slot + 1, change it to slot 2. */ + if ((irel->r_offset & 3) == 1) + irel->r_offset += 1; + } + + continue; + } + else if (r_type == R_IA64_PCREL60B) + continue; + else if (ia64_elf_relax_br (contents, roff)) + { + irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), + R_IA64_PCREL60B); + + /* Make the relocation offset point to slot 1. */ + irel->r_offset = (irel->r_offset & ~((bfd_vma) 0x3)) + 1; + continue; + } + + /* We can't put a trampoline in a .init/.fini section. Issue + an error. */ + if (strcmp (sec->output_section->name, ".init") == 0 + || strcmp (sec->output_section->name, ".fini") == 0) + { + (*_bfd_error_handler) + (_("%B: Can't relax br at 0x%lx in section `%A'. Please use brl or indirect branch."), + sec->owner, sec, (unsigned long) roff); + bfd_set_error (bfd_error_bad_value); + goto error_return; + } + + /* If the branch and target are in the same section, you've + got one honking big section and we can't help you unless + you are branching backwards. You'll get an error message + later. */ + if (tsec == sec && toff > roff) + continue; + + /* Look for an existing fixup to this address. */ + for (f = fixups; f ; f = f->next) + if (f->tsec == tsec && f->toff == toff) + break; + + if (f == NULL) + { + /* Two alternatives: If it's a branch to a PLT entry, we can + make a copy of the FULL_PLT entry. Otherwise, we'll have + to use a `brl' insn to get where we're going. */ + + size_t size; + + if (tsec == ia64_info->root.splt) + size = sizeof (plt_full_entry); + else + size = sizeof (oor_brl); + + /* Resize the current section to make room for the new branch. */ + trampoff = (sec->size + 15) & (bfd_vma) -16; + + /* If trampoline is out of range, there is nothing we + can do. */ + offset = trampoff - (roff & (bfd_vma) -4); + if (offset < -0x1000000 || offset > 0x0FFFFF0) + continue; + + amt = trampoff + size; + contents = (bfd_byte *) bfd_realloc (contents, amt); + if (contents == NULL) + goto error_return; + sec->size = amt; + + if (tsec == ia64_info->root.splt) + { + memcpy (contents + trampoff, plt_full_entry, size); + + /* Hijack the old relocation for use as the PLTOFF reloc. */ + irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), + R_IA64_PLTOFF22); + irel->r_offset = trampoff; + } + else + { + memcpy (contents + trampoff, oor_brl, size); + irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), + R_IA64_PCREL60B); + irel->r_offset = trampoff + 2; + } + + /* Record the fixup so we don't do it again this section. */ + f = (struct one_fixup *) + bfd_malloc ((bfd_size_type) sizeof (*f)); + f->next = fixups; + f->tsec = tsec; + f->toff = toff; + f->trampoff = trampoff; + fixups = f; + } + else + { + /* If trampoline is out of range, there is nothing we + can do. */ + offset = f->trampoff - (roff & (bfd_vma) -4); + if (offset < -0x1000000 || offset > 0x0FFFFF0) + continue; + + /* Nop out the reloc, since we're finalizing things here. */ + irel->r_info = ELF64_R_INFO (0, R_IA64_NONE); + } + + /* Fix up the existing branch to hit the trampoline. */ + if (ia64_elf_install_value (contents + roff, offset, r_type) + != bfd_reloc_ok) + goto error_return; + + changed_contents = TRUE; + changed_relocs = TRUE; + } + else + { + /* Fetch the gp. */ + if (gp == 0) + { + bfd *obfd = sec->output_section->owner; + gp = _bfd_get_gp_value (obfd); + if (gp == 0) + { + if (!elf64_ia64_choose_gp (obfd, link_info, FALSE)) + goto error_return; + gp = _bfd_get_gp_value (obfd); + } + } + + /* If the data is out of range, do nothing. */ + if ((bfd_signed_vma) (symaddr - gp) >= 0x200000 + ||(bfd_signed_vma) (symaddr - gp) < -0x200000) + continue; + + if (r_type == R_IA64_GPREL22) + elf64_ia64_update_short_info (tsec->output_section, + tsec->output_offset + toff, + ia64_info); + else if (r_type == R_IA64_LTOFF22X) + { + /* Can't deal yet correctly with ABS symbols. */ + if (bfd_is_abs_section (tsec)) + continue; + + irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), + R_IA64_GPREL22); + changed_relocs = TRUE; + + elf64_ia64_update_short_info (tsec->output_section, + tsec->output_offset + toff, + ia64_info); + } + else + { + ia64_elf_relax_ldxmov (contents, roff); + irel->r_info = ELF64_R_INFO (0, R_IA64_NONE); + changed_contents = TRUE; + changed_relocs = TRUE; + } + } + } + + /* ??? If we created fixups, this may push the code segment large + enough that the data segment moves, which will change the GP. + Reset the GP so that we re-calculate next round. We need to + do this at the _beginning_ of the next round; now will not do. */ + + /* Clean up and go home. */ + while (fixups) + { + struct one_fixup *f = fixups; + fixups = fixups->next; + free (f); + } + + if (isymbuf != NULL + && symtab_hdr->contents != (unsigned char *) isymbuf) + { + if (! link_info->keep_memory) + free (isymbuf); + else + { + /* Cache the symbols for elf_link_input_bfd. */ + symtab_hdr->contents = (unsigned char *) isymbuf; + } + } + + if (contents != NULL + && elf_section_data (sec)->this_hdr.contents != contents) + { + if (!changed_contents && !link_info->keep_memory) + free (contents); + else + { + /* Cache the section contents for elf_link_input_bfd. */ + elf_section_data (sec)->this_hdr.contents = contents; + } + } + + if (elf_section_data (sec)->relocs != internal_relocs) + { + if (!changed_relocs) + free (internal_relocs); + else + elf_section_data (sec)->relocs = internal_relocs; + } + + if (link_info->relax_pass == 0) + { + /* Pass 0 is only needed to relax br. */ + sec->skip_relax_pass_0 = skip_relax_pass_0; + sec->skip_relax_pass_1 = skip_relax_pass_1; + } + + *again = changed_contents || changed_relocs; + return TRUE; + + error_return: + if (isymbuf != NULL && (unsigned char *) isymbuf != symtab_hdr->contents) + free (isymbuf); + if (contents != NULL + && elf_section_data (sec)->this_hdr.contents != contents) + free (contents); + if (internal_relocs != NULL + && elf_section_data (sec)->relocs != internal_relocs) + free (internal_relocs); + return FALSE; +} +#undef skip_relax_pass_0 +#undef skip_relax_pass_1 + +/* Return TRUE if NAME is an unwind table section name. */ + +static inline bfd_boolean +is_unwind_section_name (bfd *abfd ATTRIBUTE_UNUSED, const char *name) +{ + return ((CONST_STRNEQ (name, ELF_STRING_ia64_unwind) + && ! CONST_STRNEQ (name, ELF_STRING_ia64_unwind_info)) + || CONST_STRNEQ (name, ELF_STRING_ia64_unwind_once)); +} + + +/* Convert IA-64 specific section flags to bfd internal section flags. */ + +/* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV + flag. */ + +static bfd_boolean +elf64_ia64_section_flags (flagword *flags, + const Elf_Internal_Shdr *hdr) +{ + if (hdr->sh_flags & SHF_IA_64_SHORT) + *flags |= SEC_SMALL_DATA; + + return TRUE; +} + +/* Set the correct type for an IA-64 ELF section. We do this by the + section name, which is a hack, but ought to work. */ + +static bfd_boolean +elf64_ia64_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, + asection *sec) +{ + const char *name; + + name = bfd_get_section_name (abfd, sec); + + if (is_unwind_section_name (abfd, name)) + { + /* We don't have the sections numbered at this point, so sh_info + is set later, in elf64_ia64_final_write_processing. */ + hdr->sh_type = SHT_IA_64_UNWIND; + hdr->sh_flags |= SHF_LINK_ORDER; + } + else if (strcmp (name, ELF_STRING_ia64_archext) == 0) + hdr->sh_type = SHT_IA_64_EXT; + + if (sec->flags & SEC_SMALL_DATA) + hdr->sh_flags |= SHF_IA_64_SHORT; + + return TRUE; +} + +/* Hook called by the linker routine which adds symbols from an object + file. We use it to put .comm items in .sbss, and not .bss. */ + +static bfd_boolean +elf64_ia64_add_symbol_hook (bfd *abfd, + struct bfd_link_info *info, + Elf_Internal_Sym *sym, + const char **namep ATTRIBUTE_UNUSED, + flagword *flagsp ATTRIBUTE_UNUSED, + asection **secp, + bfd_vma *valp) +{ + if (sym->st_shndx == SHN_COMMON + && !info->relocatable + && sym->st_size <= elf_gp_size (abfd)) + { + /* Common symbols less than or equal to -G nn bytes are + automatically put into .sbss. */ + + asection *scomm = bfd_get_section_by_name (abfd, ".scommon"); + + if (scomm == NULL) + { + scomm = bfd_make_section_with_flags (abfd, ".scommon", + (SEC_ALLOC + | SEC_IS_COMMON + | SEC_LINKER_CREATED)); + if (scomm == NULL) + return FALSE; + } + + *secp = scomm; + *valp = sym->st_size; + } + + return TRUE; +} + +/* According to the Tahoe assembler spec, all labels starting with a + '.' are local. */ + +static bfd_boolean +elf64_ia64_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, + const char *name) +{ + return name[0] == '.'; +} + +/* Should we do dynamic things to this symbol? */ + +static bfd_boolean +elf64_ia64_dynamic_symbol_p (struct elf_link_hash_entry *h) +{ + return h != NULL && h->def_dynamic; +} + +static struct bfd_hash_entry* +elf64_ia64_new_elf_hash_entry (struct bfd_hash_entry *entry, + struct bfd_hash_table *table, + const char *string) +{ + struct elf64_ia64_link_hash_entry *ret; + ret = (struct elf64_ia64_link_hash_entry *) entry; + + /* Allocate the structure if it has not already been allocated by a + subclass. */ + if (!ret) + ret = bfd_hash_allocate (table, sizeof (*ret)); + + if (!ret) + return 0; + + /* Call the allocation method of the superclass. */ + ret = ((struct elf64_ia64_link_hash_entry *) + _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, + table, string)); + + ret->info = NULL; + ret->count = 0; + ret->sorted_count = 0; + ret->size = 0; + return (struct bfd_hash_entry *) ret; +} + +static void +elf64_ia64_hash_hide_symbol (struct bfd_link_info *info, + struct elf_link_hash_entry *xh, + bfd_boolean force_local) +{ + struct elf64_ia64_link_hash_entry *h; + struct elf64_ia64_dyn_sym_info *dyn_i; + unsigned int count; + + h = (struct elf64_ia64_link_hash_entry *)xh; + + _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local); + + for (count = h->count, dyn_i = h->info; + count != 0; + count--, dyn_i++) + { + dyn_i->want_plt2 = 0; + dyn_i->want_plt = 0; + } +} + +/* Compute a hash of a local hash entry. */ + +static hashval_t +elf64_ia64_local_htab_hash (const void *ptr) +{ + struct elf64_ia64_local_hash_entry *entry + = (struct elf64_ia64_local_hash_entry *) ptr; + + return ELF_LOCAL_SYMBOL_HASH (entry->id, entry->r_sym); +} + +/* Compare local hash entries. */ + +static int +elf64_ia64_local_htab_eq (const void *ptr1, const void *ptr2) +{ + struct elf64_ia64_local_hash_entry *entry1 + = (struct elf64_ia64_local_hash_entry *) ptr1; + struct elf64_ia64_local_hash_entry *entry2 + = (struct elf64_ia64_local_hash_entry *) ptr2; + + return entry1->id == entry2->id && entry1->r_sym == entry2->r_sym; +} + +/* Create the derived linker hash table. The IA-64 ELF port uses this + derived hash table to keep information specific to the IA-64 ElF + linker (without using static variables). */ + +static struct bfd_link_hash_table * +elf64_ia64_hash_table_create (bfd *abfd) +{ + struct elf64_ia64_link_hash_table *ret; + + ret = bfd_zmalloc ((bfd_size_type) sizeof (*ret)); + if (!ret) + return NULL; + + if (!_bfd_elf_link_hash_table_init (&ret->root, abfd, + elf64_ia64_new_elf_hash_entry, + sizeof (struct elf64_ia64_link_hash_entry), + IA64_ELF_DATA)) + { + free (ret); + return NULL; + } + + ret->loc_hash_table = htab_try_create (1024, elf64_ia64_local_htab_hash, + elf64_ia64_local_htab_eq, NULL); + ret->loc_hash_memory = objalloc_create (); + if (!ret->loc_hash_table || !ret->loc_hash_memory) + { + free (ret); + return NULL; + } + + return &ret->root.root; +} + +/* Free the global elf64_ia64_dyn_sym_info array. */ + +static bfd_boolean +elf64_ia64_global_dyn_info_free (void **xentry, + void * unused ATTRIBUTE_UNUSED) +{ + struct elf64_ia64_link_hash_entry *entry + = (struct elf64_ia64_link_hash_entry *) xentry; + + if (entry->root.root.type == bfd_link_hash_warning) + entry = (struct elf64_ia64_link_hash_entry *) entry->root.root.u.i.link; + + if (entry->info) + { + free (entry->info); + entry->info = NULL; + entry->count = 0; + entry->sorted_count = 0; + entry->size = 0; + } + + return TRUE; +} + +/* Free the local elf64_ia64_dyn_sym_info array. */ + +static bfd_boolean +elf64_ia64_local_dyn_info_free (void **slot, + void * unused ATTRIBUTE_UNUSED) +{ + struct elf64_ia64_local_hash_entry *entry + = (struct elf64_ia64_local_hash_entry *) *slot; + + if (entry->info) + { + free (entry->info); + entry->info = NULL; + entry->count = 0; + entry->sorted_count = 0; + entry->size = 0; + } + + return TRUE; +} + +/* Destroy IA-64 linker hash table. */ + +static void +elf64_ia64_hash_table_free (struct bfd_link_hash_table *hash) +{ + struct elf64_ia64_link_hash_table *ia64_info + = (struct elf64_ia64_link_hash_table *) hash; + if (ia64_info->loc_hash_table) + { + htab_traverse (ia64_info->loc_hash_table, + elf64_ia64_local_dyn_info_free, NULL); + htab_delete (ia64_info->loc_hash_table); + } + if (ia64_info->loc_hash_memory) + objalloc_free ((struct objalloc *) ia64_info->loc_hash_memory); + elf_link_hash_traverse (&ia64_info->root, + elf64_ia64_global_dyn_info_free, NULL); + _bfd_generic_link_hash_table_free (hash); +} + +/* Traverse both local and global hash tables. */ + +struct elf64_ia64_dyn_sym_traverse_data +{ + bfd_boolean (*func) (struct elf64_ia64_dyn_sym_info *, void *); + void * data; +}; + +static bfd_boolean +elf64_ia64_global_dyn_sym_thunk (struct bfd_hash_entry *xentry, + void * xdata) +{ + struct elf64_ia64_link_hash_entry *entry + = (struct elf64_ia64_link_hash_entry *) xentry; + struct elf64_ia64_dyn_sym_traverse_data *data + = (struct elf64_ia64_dyn_sym_traverse_data *) xdata; + struct elf64_ia64_dyn_sym_info *dyn_i; + unsigned int count; + + if (entry->root.root.type == bfd_link_hash_warning) + entry = (struct elf64_ia64_link_hash_entry *) entry->root.root.u.i.link; + + for (count = entry->count, dyn_i = entry->info; + count != 0; + count--, dyn_i++) + if (! (*data->func) (dyn_i, data->data)) + return FALSE; + return TRUE; +} + +static bfd_boolean +elf64_ia64_local_dyn_sym_thunk (void **slot, void * xdata) +{ + struct elf64_ia64_local_hash_entry *entry + = (struct elf64_ia64_local_hash_entry *) *slot; + struct elf64_ia64_dyn_sym_traverse_data *data + = (struct elf64_ia64_dyn_sym_traverse_data *) xdata; + struct elf64_ia64_dyn_sym_info *dyn_i; + unsigned int count; + + for (count = entry->count, dyn_i = entry->info; + count != 0; + count--, dyn_i++) + if (! (*data->func) (dyn_i, data->data)) + return FALSE; + return TRUE; +} + +static void +elf64_ia64_dyn_sym_traverse (struct elf64_ia64_link_hash_table *ia64_info, + bfd_boolean (*func) (struct elf64_ia64_dyn_sym_info *, void *), + void * data) +{ + struct elf64_ia64_dyn_sym_traverse_data xdata; + + xdata.func = func; + xdata.data = data; + + elf_link_hash_traverse (&ia64_info->root, + elf64_ia64_global_dyn_sym_thunk, &xdata); + htab_traverse (ia64_info->loc_hash_table, + elf64_ia64_local_dyn_sym_thunk, &xdata); +} + +#define NOTE_NAME "IPF/VMS" + +static bfd_boolean +create_ia64_vms_notes (bfd *abfd, struct bfd_link_info *info, + unsigned int time_hi, unsigned int time_lo) +{ +#define NBR_NOTES 7 + Elf_Internal_Note notes[NBR_NOTES]; + char *module_name; + int module_name_len; + unsigned char cur_time[8]; + Elf64_External_VMS_ORIG_DYN_Note *orig_dyn; + unsigned int orig_dyn_size; + unsigned int note_size; + int i; + unsigned char *noteptr; + unsigned char *note_contents; + struct elf64_ia64_link_hash_table *ia64_info; + + ia64_info = elf64_ia64_hash_table (info); + + module_name = vms_get_module_name (bfd_get_filename (abfd), TRUE); + module_name_len = strlen (module_name) + 1; + + bfd_putl32 (time_lo, cur_time + 0); + bfd_putl32 (time_hi, cur_time + 4); + + /* Note 0: IMGNAM. */ + notes[0].type = NT_VMS_IMGNAM; + notes[0].descdata = module_name; + notes[0].descsz = module_name_len; + + /* Note 1: GSTNAM. */ + notes[1].type = NT_VMS_GSTNAM; + notes[1].descdata = module_name; + notes[1].descsz = module_name_len; + + /* Note 2: IMGID. */ +#define IMG_ID "V1.0" + notes[2].type = NT_VMS_IMGID; + notes[2].descdata = IMG_ID; + notes[2].descsz = sizeof (IMG_ID); + + /* Note 3: Linktime. */ + notes[3].type = NT_VMS_LINKTIME; + notes[3].descdata = (char *)cur_time; + notes[3].descsz = sizeof (cur_time); + + /* Note 4: Linker id. */ + notes[4].type = NT_VMS_LINKID; + notes[4].descdata = "GNU ld " BFD_VERSION_STRING; + notes[4].descsz = strlen (notes[4].descdata) + 1; + + /* Note 5: Original dyn. */ + orig_dyn_size = (sizeof (*orig_dyn) + sizeof (IMG_ID) - 1 + 7) & ~7; + orig_dyn = bfd_zalloc (abfd, orig_dyn_size); + if (orig_dyn == NULL) + return FALSE; + bfd_putl32 (1, orig_dyn->major_id); + bfd_putl32 (3, orig_dyn->minor_id); + memcpy (orig_dyn->manipulation_date, cur_time, sizeof (cur_time)); + bfd_putl64 (VMS_LF_IMGSTA | VMS_LF_MAIN, orig_dyn->link_flags); + bfd_putl32 (EF_IA_64_ABI64, orig_dyn->elf_flags); + memcpy (orig_dyn->imgid, IMG_ID, sizeof (IMG_ID)); + notes[5].type = NT_VMS_ORIG_DYN; + notes[5].descdata = (char *)orig_dyn; + notes[5].descsz = orig_dyn_size; + + /* Note 3: Patchtime. */ + notes[6].type = NT_VMS_PATCHTIME; + notes[6].descdata = (char *)cur_time; + notes[6].descsz = sizeof (cur_time); + + /* Compute notes size. */ + note_size = 0; + for (i = 0; i < NBR_NOTES; i++) + note_size += sizeof (Elf64_External_VMS_Note) - 1 + + ((sizeof (NOTE_NAME) - 1 + 7) & ~7) + + ((notes[i].descsz + 7) & ~7); + + /* Malloc a temporary buffer large enough for most notes */ + note_contents = (unsigned char *) bfd_zalloc (abfd, note_size); + if (note_contents == NULL) + return FALSE; + noteptr = note_contents; + + /* Fill notes. */ + for (i = 0; i < NBR_NOTES; i++) + { + Elf64_External_VMS_Note *enote = (Elf64_External_VMS_Note *) noteptr; + + bfd_putl64 (sizeof (NOTE_NAME) - 1, enote->namesz); + bfd_putl64 (notes[i].descsz, enote->descsz); + bfd_putl64 (notes[i].type, enote->type); + + noteptr = (unsigned char *)enote->name; + memcpy (noteptr, NOTE_NAME, sizeof (NOTE_NAME) - 1); + noteptr += (sizeof (NOTE_NAME) - 1 + 7) & ~7; + memcpy (noteptr, notes[i].descdata, notes[i].descsz); + noteptr += (notes[i].descsz + 7) & ~7; + } + + ia64_info->note_sec->contents = note_contents; + ia64_info->note_sec->size = note_size; + + free (module_name); + + return TRUE; +} + +static bfd_boolean +elf64_ia64_create_dynamic_sections (bfd *abfd, + struct bfd_link_info *info) +{ + struct elf64_ia64_link_hash_table *ia64_info; + asection *s; + flagword flags; + const struct elf_backend_data *bed; + + ia64_info = elf64_ia64_hash_table (info); + if (ia64_info == NULL) + return FALSE; + + if (elf_hash_table (info)->dynamic_sections_created) + return TRUE; + + abfd = elf_hash_table (info)->dynobj; + bed = get_elf_backend_data (abfd); + + flags = bed->dynamic_sec_flags; + + s = bfd_make_section_with_flags (abfd, ".dynamic", flags | SEC_READONLY); + if (s == NULL + || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align)) + return FALSE; + + s = bfd_make_section_with_flags (abfd, ".plt", flags | SEC_READONLY); + if (s == NULL + || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment)) + return FALSE; + ia64_info->root.splt = s; + + if (!get_got (abfd, ia64_info)) + return FALSE; + + if (!get_pltoff (abfd, ia64_info)) + return FALSE; + + s = bfd_make_section_with_flags (abfd, ".vmsdynstr", + (SEC_ALLOC + | SEC_HAS_CONTENTS + | SEC_IN_MEMORY + | SEC_LINKER_CREATED)); + if (s == NULL + || !bfd_set_section_alignment (abfd, s, 0)) + return FALSE; + + /* Create a fixup section. */ + s = bfd_make_section_with_flags (abfd, ".fixups", + (SEC_ALLOC + | SEC_HAS_CONTENTS + | SEC_IN_MEMORY + | SEC_LINKER_CREATED)); + if (s == NULL + || !bfd_set_section_alignment (abfd, s, 3)) + return FALSE; + ia64_info->fixups_sec = s; + + /* Create the transfer fixup section. */ + s = bfd_make_section_with_flags (abfd, ".transfer", + (SEC_ALLOC + | SEC_HAS_CONTENTS + | SEC_IN_MEMORY + | SEC_LINKER_CREATED)); + if (s == NULL + || !bfd_set_section_alignment (abfd, s, 3)) + return FALSE; + s->size = sizeof (struct elf64_vms_transfer); + ia64_info->transfer_sec = s; + + /* Create note section. */ + s = bfd_make_section_anyway_with_flags (abfd, ".vms.note", + (SEC_LINKER_CREATED + | SEC_HAS_CONTENTS + | SEC_IN_MEMORY + | SEC_READONLY)); + if (s == NULL + || !bfd_set_section_alignment (abfd, s, 3)) + return FALSE; + ia64_info->note_sec = s; + + elf_hash_table (info)->dynamic_sections_created = TRUE; + return TRUE; +} + +/* Find and/or create a hash entry for local symbol. */ +static struct elf64_ia64_local_hash_entry * +get_local_sym_hash (struct elf64_ia64_link_hash_table *ia64_info, + bfd *abfd, const Elf_Internal_Rela *rel, + bfd_boolean create) +{ + struct elf64_ia64_local_hash_entry e, *ret; + asection *sec = abfd->sections; + hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id, + ELF64_R_SYM (rel->r_info)); + void **slot; + + e.id = sec->id; + e.r_sym = ELF64_R_SYM (rel->r_info); + slot = htab_find_slot_with_hash (ia64_info->loc_hash_table, &e, h, + create ? INSERT : NO_INSERT); + + if (!slot) + return NULL; + + if (*slot) + return (struct elf64_ia64_local_hash_entry *) *slot; + + ret = (struct elf64_ia64_local_hash_entry *) + objalloc_alloc ((struct objalloc *) ia64_info->loc_hash_memory, + sizeof (struct elf64_ia64_local_hash_entry)); + if (ret) + { + memset (ret, 0, sizeof (*ret)); + ret->id = sec->id; + ret->r_sym = ELF64_R_SYM (rel->r_info); + *slot = ret; + } + return ret; +} + +/* Used to sort elf64_ia64_dyn_sym_info array. */ + +static int +addend_compare (const void *xp, const void *yp) +{ + const struct elf64_ia64_dyn_sym_info *x + = (const struct elf64_ia64_dyn_sym_info *) xp; + const struct elf64_ia64_dyn_sym_info *y + = (const struct elf64_ia64_dyn_sym_info *) yp; + + return x->addend < y->addend ? -1 : x->addend > y->addend ? 1 : 0; +} + +/* Sort elf64_ia64_dyn_sym_info array and remove duplicates. */ + +static unsigned int +sort_dyn_sym_info (struct elf64_ia64_dyn_sym_info *info, + unsigned int count) +{ + bfd_vma curr, prev, got_offset; + unsigned int i, kept, dupes, diff, dest, src, len; + + qsort (info, count, sizeof (*info), addend_compare); + + /* Find the first duplicate. */ + prev = info [0].addend; + got_offset = info [0].got_offset; + for (i = 1; i < count; i++) + { + curr = info [i].addend; + if (curr == prev) + { + /* For duplicates, make sure that GOT_OFFSET is valid. */ + if (got_offset == (bfd_vma) -1) + got_offset = info [i].got_offset; + break; + } + got_offset = info [i].got_offset; + prev = curr; + } + + /* We may move a block of elements to here. */ + dest = i++; + + /* Remove duplicates. */ + if (i < count) + { + while (i < count) + { + /* For duplicates, make sure that the kept one has a valid + got_offset. */ + kept = dest - 1; + if (got_offset != (bfd_vma) -1) + info [kept].got_offset = got_offset; + + curr = info [i].addend; + got_offset = info [i].got_offset; + + /* Move a block of elements whose first one is different from + the previous. */ + if (curr == prev) + { + for (src = i + 1; src < count; src++) + { + if (info [src].addend != curr) + break; + /* For duplicates, make sure that GOT_OFFSET is + valid. */ + if (got_offset == (bfd_vma) -1) + got_offset = info [src].got_offset; + } + + /* Make sure that the kept one has a valid got_offset. */ + if (got_offset != (bfd_vma) -1) + info [kept].got_offset = got_offset; + } + else + src = i; + + if (src >= count) + break; + + /* Find the next duplicate. SRC will be kept. */ + prev = info [src].addend; + got_offset = info [src].got_offset; + for (dupes = src + 1; dupes < count; dupes ++) + { + curr = info [dupes].addend; + if (curr == prev) + { + /* Make sure that got_offset is valid. */ + if (got_offset == (bfd_vma) -1) + got_offset = info [dupes].got_offset; + + /* For duplicates, make sure that the kept one has + a valid got_offset. */ + if (got_offset != (bfd_vma) -1) + info [dupes - 1].got_offset = got_offset; + break; + } + got_offset = info [dupes].got_offset; + prev = curr; + } + + /* How much to move. */ + len = dupes - src; + i = dupes + 1; + + if (len == 1 && dupes < count) + { + /* If we only move 1 element, we combine it with the next + one. There must be at least a duplicate. Find the + next different one. */ + for (diff = dupes + 1, src++; diff < count; diff++, src++) + { + if (info [diff].addend != curr) + break; + /* Make sure that got_offset is valid. */ + if (got_offset == (bfd_vma) -1) + got_offset = info [diff].got_offset; + } + + /* Makre sure that the last duplicated one has an valid + offset. */ + BFD_ASSERT (curr == prev); + if (got_offset != (bfd_vma) -1) + info [diff - 1].got_offset = got_offset; + + if (diff < count) + { + /* Find the next duplicate. Track the current valid + offset. */ + prev = info [diff].addend; + got_offset = info [diff].got_offset; + for (dupes = diff + 1; dupes < count; dupes ++) + { + curr = info [dupes].addend; + if (curr == prev) + { + /* For duplicates, make sure that GOT_OFFSET + is valid. */ + if (got_offset == (bfd_vma) -1) + got_offset = info [dupes].got_offset; + break; + } + got_offset = info [dupes].got_offset; + prev = curr; + diff++; + } + + len = diff - src + 1; + i = diff + 1; + } + } + + memmove (&info [dest], &info [src], len * sizeof (*info)); + + dest += len; + } + + count = dest; + } + else + { + /* When we get here, either there is no duplicate at all or + the only duplicate is the last element. */ + if (dest < count) + { + /* If the last element is a duplicate, make sure that the + kept one has a valid got_offset. We also update count. */ + if (got_offset != (bfd_vma) -1) + info [dest - 1].got_offset = got_offset; + count = dest; + } + } + + return count; +} + +/* Find and/or create a descriptor for dynamic symbol info. This will + vary based on global or local symbol, and the addend to the reloc. + + We don't sort when inserting. Also, we sort and eliminate + duplicates if there is an unsorted section. Typically, this will + only happen once, because we do all insertions before lookups. We + then use bsearch to do a lookup. This also allows lookups to be + fast. So we have fast insertion (O(log N) due to duplicate check), + fast lookup (O(log N)) and one sort (O(N log N) expected time). + Previously, all lookups were O(N) because of the use of the linked + list and also all insertions were O(N) because of the check for + duplicates. There are some complications here because the array + size grows occasionally, which may add an O(N) factor, but this + should be rare. Also, we free the excess array allocation, which + requires a copy which is O(N), but this only happens once. */ + +static struct elf64_ia64_dyn_sym_info * +get_dyn_sym_info (struct elf64_ia64_link_hash_table *ia64_info, + struct elf_link_hash_entry *h, bfd *abfd, + const Elf_Internal_Rela *rel, bfd_boolean create) +{ + struct elf64_ia64_dyn_sym_info **info_p, *info, *dyn_i, key; + unsigned int *count_p, *sorted_count_p, *size_p; + unsigned int count, sorted_count, size; + bfd_vma addend = rel ? rel->r_addend : 0; + bfd_size_type amt; + + if (h) + { + struct elf64_ia64_link_hash_entry *global_h; + + global_h = (struct elf64_ia64_link_hash_entry *) h; + info_p = &global_h->info; + count_p = &global_h->count; + sorted_count_p = &global_h->sorted_count; + size_p = &global_h->size; + } + else + { + struct elf64_ia64_local_hash_entry *loc_h; + + loc_h = get_local_sym_hash (ia64_info, abfd, rel, create); + if (!loc_h) + { + BFD_ASSERT (!create); + return NULL; + } + + info_p = &loc_h->info; + count_p = &loc_h->count; + sorted_count_p = &loc_h->sorted_count; + size_p = &loc_h->size; + } + + count = *count_p; + sorted_count = *sorted_count_p; + size = *size_p; + info = *info_p; + if (create) + { + /* When we create the array, we don't check for duplicates, + except in the previously sorted section if one exists, and + against the last inserted entry. This allows insertions to + be fast. */ + if (info) + { + if (sorted_count) + { + /* Try bsearch first on the sorted section. */ + key.addend = addend; + dyn_i = bsearch (&key, info, sorted_count, + sizeof (*info), addend_compare); + + if (dyn_i) + { + return dyn_i; + } + } + + /* Do a quick check for the last inserted entry. */ + dyn_i = info + count - 1; + if (dyn_i->addend == addend) + { + return dyn_i; + } + } + + if (size == 0) + { + /* It is the very first element. We create the array of size + 1. */ + size = 1; + amt = size * sizeof (*info); + info = bfd_malloc (amt); + } + else if (size <= count) + { + /* We double the array size every time when we reach the + size limit. */ + size += size; + amt = size * sizeof (*info); + info = bfd_realloc (info, amt); + } + else + goto has_space; + + if (info == NULL) + return NULL; + *size_p = size; + *info_p = info; + +has_space: + /* Append the new one to the array. */ + dyn_i = info + count; + memset (dyn_i, 0, sizeof (*dyn_i)); + dyn_i->got_offset = (bfd_vma) -1; + dyn_i->addend = addend; + + /* We increment count only since the new ones are unsorted and + may have duplicate. */ + (*count_p)++; + } + else + { + /* It is a lookup without insertion. Sort array if part of the + array isn't sorted. */ + if (count != sorted_count) + { + count = sort_dyn_sym_info (info, count); + *count_p = count; + *sorted_count_p = count; + } + + /* Free unused memory. */ + if (size != count) + { + amt = count * sizeof (*info); + info = bfd_malloc (amt); + if (info != NULL) + { + memcpy (info, *info_p, amt); + free (*info_p); + *size_p = count; + *info_p = info; + } + } + + key.addend = addend; + dyn_i = bsearch (&key, info, count, + sizeof (*info), addend_compare); + } + + return dyn_i; +} + +static asection * +get_got (bfd *abfd, struct elf64_ia64_link_hash_table *ia64_info) +{ + asection *got; + bfd *dynobj; + + got = ia64_info->root.sgot; + if (!got) + { + flagword flags; + + dynobj = ia64_info->root.dynobj; + if (!dynobj) + ia64_info->root.dynobj = dynobj = abfd; + + /* The .got section is always aligned at 8 bytes. */ + flags = get_elf_backend_data (dynobj)->dynamic_sec_flags; + got = bfd_make_section_with_flags (dynobj, ".got", flags | SEC_SMALL_DATA); + if (got == NULL + || !bfd_set_section_alignment (dynobj, got, 3)) + return NULL; + ia64_info->root.sgot = got; + } + + return got; +} + +/* Create function descriptor section (.opd). This section is called .opd + because it contains "official procedure descriptors". The "official" + refers to the fact that these descriptors are used when taking the address + of a procedure, thus ensuring a unique address for each procedure. */ + +static asection * +get_fptr (bfd *abfd, struct bfd_link_info *info, + struct elf64_ia64_link_hash_table *ia64_info) +{ + asection *fptr; + bfd *dynobj; + + fptr = ia64_info->fptr_sec; + if (!fptr) + { + dynobj = ia64_info->root.dynobj; + if (!dynobj) + ia64_info->root.dynobj = dynobj = abfd; + + fptr = bfd_make_section_with_flags (dynobj, ".opd", + (SEC_ALLOC + | SEC_LOAD + | SEC_HAS_CONTENTS + | SEC_IN_MEMORY + | (info->pie ? 0 : SEC_READONLY) + | SEC_LINKER_CREATED)); + if (!fptr + || !bfd_set_section_alignment (dynobj, fptr, 4)) + { + BFD_ASSERT (0); + return NULL; + } + + ia64_info->fptr_sec = fptr; + + if (info->pie) + { + asection *fptr_rel; + fptr_rel = bfd_make_section_with_flags (dynobj, ".rela.opd", + (SEC_ALLOC | SEC_LOAD + | SEC_HAS_CONTENTS + | SEC_IN_MEMORY + | SEC_LINKER_CREATED + | SEC_READONLY)); + if (fptr_rel == NULL + || !bfd_set_section_alignment (dynobj, fptr_rel, 3)) + { + BFD_ASSERT (0); + return NULL; + } + + ia64_info->rel_fptr_sec = fptr_rel; + } + } + + return fptr; +} + +static asection * +get_pltoff (bfd *abfd, struct elf64_ia64_link_hash_table *ia64_info) +{ + asection *pltoff; + bfd *dynobj; + + pltoff = ia64_info->pltoff_sec; + if (!pltoff) + { + dynobj = ia64_info->root.dynobj; + if (!dynobj) + ia64_info->root.dynobj = dynobj = abfd; + + pltoff = bfd_make_section_with_flags (dynobj, + ELF_STRING_ia64_pltoff, + (SEC_ALLOC + | SEC_LOAD + | SEC_HAS_CONTENTS + | SEC_IN_MEMORY + | SEC_SMALL_DATA + | SEC_LINKER_CREATED)); + if (!pltoff + || !bfd_set_section_alignment (dynobj, pltoff, 4)) + { + BFD_ASSERT (0); + return NULL; + } + + ia64_info->pltoff_sec = pltoff; + } + + return pltoff; +} + +static asection * +get_reloc_section (bfd *abfd, + struct elf64_ia64_link_hash_table *ia64_info, + asection *sec, bfd_boolean create) +{ + const char *srel_name; + asection *srel; + bfd *dynobj; + + srel_name = (bfd_elf_string_from_elf_section + (abfd, elf_elfheader(abfd)->e_shstrndx, + _bfd_elf_single_rel_hdr (sec)->sh_name)); + if (srel_name == NULL) + return NULL; + + BFD_ASSERT ((CONST_STRNEQ (srel_name, ".rela") + && strcmp (bfd_get_section_name (abfd, sec), + srel_name+5) == 0) + || (CONST_STRNEQ (srel_name, ".rel") + && strcmp (bfd_get_section_name (abfd, sec), + srel_name+4) == 0)); + + dynobj = ia64_info->root.dynobj; + if (!dynobj) + ia64_info->root.dynobj = dynobj = abfd; + + srel = bfd_get_section_by_name (dynobj, srel_name); + if (srel == NULL && create) + { + srel = bfd_make_section_with_flags (dynobj, srel_name, + (SEC_ALLOC | SEC_LOAD + | SEC_HAS_CONTENTS + | SEC_IN_MEMORY + | SEC_LINKER_CREATED + | SEC_READONLY)); + if (srel == NULL + || !bfd_set_section_alignment (dynobj, srel, 3)) + return NULL; + } + + return srel; +} + +static bfd_boolean +count_dyn_reloc (bfd *abfd, struct elf64_ia64_dyn_sym_info *dyn_i, + asection *srel, int type) +{ + struct elf64_ia64_dyn_reloc_entry *rent; + + for (rent = dyn_i->reloc_entries; rent; rent = rent->next) + if (rent->srel == srel && rent->type == type) + break; + + if (!rent) + { + rent = ((struct elf64_ia64_dyn_reloc_entry *) + bfd_alloc (abfd, (bfd_size_type) sizeof (*rent))); + if (!rent) + return FALSE; + + rent->next = dyn_i->reloc_entries; + rent->srel = srel; + rent->type = type; + rent->count = 0; + dyn_i->reloc_entries = rent; + } + rent->count++; + + return TRUE; +} + +static bfd_boolean +elf64_ia64_check_relocs (bfd *abfd, struct bfd_link_info *info, + asection *sec, + const Elf_Internal_Rela *relocs) +{ + struct elf64_ia64_link_hash_table *ia64_info; + const Elf_Internal_Rela *relend; + Elf_Internal_Shdr *symtab_hdr; + const Elf_Internal_Rela *rel; + asection *got, *fptr, *srel, *pltoff; + enum { + NEED_GOT = 1, + NEED_GOTX = 2, + NEED_FPTR = 4, + NEED_PLTOFF = 8, + NEED_MIN_PLT = 16, + NEED_FULL_PLT = 32, + NEED_DYNREL = 64, + NEED_LTOFF_FPTR = 128 + }; + int need_entry; + struct elf_link_hash_entry *h; + unsigned long r_symndx; + bfd_boolean maybe_dynamic; + + if (info->relocatable) + return TRUE; + + symtab_hdr = &elf_tdata (abfd)->symtab_hdr; + ia64_info = elf64_ia64_hash_table (info); + if (ia64_info == NULL) + return FALSE; + + got = fptr = srel = pltoff = NULL; + + relend = relocs + sec->reloc_count; + + /* We scan relocations first to create dynamic relocation arrays. We + modified get_dyn_sym_info to allow fast insertion and support fast + lookup in the next loop. */ + for (rel = relocs; rel < relend; ++rel) + { + r_symndx = ELF64_R_SYM (rel->r_info); + if (r_symndx >= symtab_hdr->sh_info) + { + long indx = r_symndx - symtab_hdr->sh_info; + h = elf_sym_hashes (abfd)[indx]; + while (h->root.type == bfd_link_hash_indirect + || h->root.type == bfd_link_hash_warning) + h = (struct elf_link_hash_entry *) h->root.u.i.link; + } + else + h = NULL; + + /* We can only get preliminary data on whether a symbol is + locally or externally defined, as not all of the input files + have yet been processed. Do something with what we know, as + this may help reduce memory usage and processing time later. */ + maybe_dynamic = (h && ((!info->executable + && (!SYMBOLIC_BIND (info, h) + || info->unresolved_syms_in_shared_libs == RM_IGNORE)) + || !h->def_regular + || h->root.type == bfd_link_hash_defweak)); + + need_entry = 0; + switch (ELF64_R_TYPE (rel->r_info)) + { + case R_IA64_TPREL64MSB: + case R_IA64_TPREL64LSB: + case R_IA64_LTOFF_TPREL22: + case R_IA64_DTPREL32MSB: + case R_IA64_DTPREL32LSB: + case R_IA64_DTPREL64MSB: + case R_IA64_DTPREL64LSB: + case R_IA64_LTOFF_DTPREL22: + case R_IA64_DTPMOD64MSB: + case R_IA64_DTPMOD64LSB: + case R_IA64_LTOFF_DTPMOD22: + abort (); + break; + + case R_IA64_IPLTMSB: + case R_IA64_IPLTLSB: + break; + + case R_IA64_LTOFF_FPTR22: + case R_IA64_LTOFF_FPTR64I: + case R_IA64_LTOFF_FPTR32MSB: + case R_IA64_LTOFF_FPTR32LSB: + case R_IA64_LTOFF_FPTR64MSB: + case R_IA64_LTOFF_FPTR64LSB: + need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR; + break; + + case R_IA64_FPTR64I: + case R_IA64_FPTR32MSB: + case R_IA64_FPTR32LSB: + case R_IA64_FPTR64MSB: + case R_IA64_FPTR64LSB: + if (info->shared || h) + need_entry = NEED_FPTR | NEED_DYNREL; + else + need_entry = NEED_FPTR; + break; + + case R_IA64_LTOFF22: + case R_IA64_LTOFF64I: + need_entry = NEED_GOT; + break; + + case R_IA64_LTOFF22X: + need_entry = NEED_GOTX; + break; + + case R_IA64_PLTOFF22: + case R_IA64_PLTOFF64I: + case R_IA64_PLTOFF64MSB: + case R_IA64_PLTOFF64LSB: + need_entry = NEED_PLTOFF; + if (h) + { + if (maybe_dynamic) + need_entry |= NEED_MIN_PLT; + } + else + { + (*info->callbacks->warning) + (info, _("@pltoff reloc against local symbol"), 0, + abfd, 0, (bfd_vma) 0); + } + break; + + case R_IA64_PCREL21B: + case R_IA64_PCREL60B: + /* Depending on where this symbol is defined, we may or may not + need a full plt entry. Only skip if we know we'll not need + the entry -- static or symbolic, and the symbol definition + has already been seen. */ + if (maybe_dynamic && rel->r_addend == 0) + need_entry = NEED_FULL_PLT; + break; + + case R_IA64_IMM14: + case R_IA64_IMM22: + case R_IA64_IMM64: + case R_IA64_DIR32MSB: + case R_IA64_DIR32LSB: + case R_IA64_DIR64MSB: + case R_IA64_DIR64LSB: + /* Shared objects will always need at least a REL relocation. */ + if (info->shared || maybe_dynamic) + need_entry = NEED_DYNREL; + break; + + case R_IA64_PCREL22: + case R_IA64_PCREL64I: + case R_IA64_PCREL32MSB: + case R_IA64_PCREL32LSB: + case R_IA64_PCREL64MSB: + case R_IA64_PCREL64LSB: + if (maybe_dynamic) + need_entry = NEED_DYNREL; + break; + } + + if (!need_entry) + continue; + + if ((need_entry & NEED_FPTR) != 0 + && rel->r_addend) + { + (*info->callbacks->warning) + (info, _("non-zero addend in @fptr reloc"), 0, + abfd, 0, (bfd_vma) 0); + } + + if (get_dyn_sym_info (ia64_info, h, abfd, rel, TRUE) == NULL) + return FALSE; + } + + /* Now, we only do lookup without insertion, which is very fast + with the modified get_dyn_sym_info. */ + for (rel = relocs; rel < relend; ++rel) + { + struct elf64_ia64_dyn_sym_info *dyn_i; + int dynrel_type = R_IA64_NONE; + + r_symndx = ELF64_R_SYM (rel->r_info); + if (r_symndx >= symtab_hdr->sh_info) + { + /* We're dealing with a global symbol -- find its hash entry + and mark it as being referenced. */ + long indx = r_symndx - symtab_hdr->sh_info; + h = elf_sym_hashes (abfd)[indx]; + while (h->root.type == bfd_link_hash_indirect + || h->root.type == bfd_link_hash_warning) + h = (struct elf_link_hash_entry *) h->root.u.i.link; + + h->ref_regular = 1; + } + else + h = NULL; + + /* We can only get preliminary data on whether a symbol is + locally or externally defined, as not all of the input files + have yet been processed. Do something with what we know, as + this may help reduce memory usage and processing time later. */ + maybe_dynamic = (h && ((!info->executable + && (!SYMBOLIC_BIND (info, h) + || info->unresolved_syms_in_shared_libs == RM_IGNORE)) + || !h->def_regular + || h->root.type == bfd_link_hash_defweak)); + + need_entry = 0; + switch (ELF64_R_TYPE (rel->r_info)) + { + case R_IA64_TPREL64MSB: + case R_IA64_TPREL64LSB: + case R_IA64_LTOFF_TPREL22: + case R_IA64_DTPREL32MSB: + case R_IA64_DTPREL32LSB: + case R_IA64_DTPREL64MSB: + case R_IA64_DTPREL64LSB: + case R_IA64_LTOFF_DTPREL22: + case R_IA64_DTPMOD64MSB: + case R_IA64_DTPMOD64LSB: + case R_IA64_LTOFF_DTPMOD22: + abort (); + break; + + case R_IA64_LTOFF_FPTR22: + case R_IA64_LTOFF_FPTR64I: + case R_IA64_LTOFF_FPTR32MSB: + case R_IA64_LTOFF_FPTR32LSB: + case R_IA64_LTOFF_FPTR64MSB: + case R_IA64_LTOFF_FPTR64LSB: + need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR; + break; + + case R_IA64_FPTR64I: + case R_IA64_FPTR32MSB: + case R_IA64_FPTR32LSB: + case R_IA64_FPTR64MSB: + case R_IA64_FPTR64LSB: + if (info->shared || h) + need_entry = NEED_FPTR | NEED_DYNREL; + else + need_entry = NEED_FPTR; + dynrel_type = R_IA64_FPTR64LSB; + break; + + case R_IA64_LTOFF22: + case R_IA64_LTOFF64I: + need_entry = NEED_GOT; + break; + + case R_IA64_LTOFF22X: + need_entry = NEED_GOTX; + break; + + case R_IA64_PLTOFF22: + case R_IA64_PLTOFF64I: + case R_IA64_PLTOFF64MSB: + case R_IA64_PLTOFF64LSB: + need_entry = NEED_PLTOFF; + if (h) + { + if (maybe_dynamic) + need_entry |= NEED_MIN_PLT; + } + break; + + case R_IA64_PCREL21B: + case R_IA64_PCREL60B: + /* Depending on where this symbol is defined, we may or may not + need a full plt entry. Only skip if we know we'll not need + the entry -- static or symbolic, and the symbol definition + has already been seen. */ + if (maybe_dynamic && rel->r_addend == 0) + need_entry = NEED_FULL_PLT; + break; + + case R_IA64_IMM14: + case R_IA64_IMM22: + case R_IA64_IMM64: + case R_IA64_DIR32MSB: + case R_IA64_DIR32LSB: + case R_IA64_DIR64MSB: + case R_IA64_DIR64LSB: + /* Shared objects will always need at least a REL relocation. */ + if (info->shared || maybe_dynamic) + need_entry = NEED_DYNREL; + dynrel_type = R_IA64_DIR64LSB; + break; + + case R_IA64_IPLTMSB: + case R_IA64_IPLTLSB: + break; + + case R_IA64_PCREL22: + case R_IA64_PCREL64I: + case R_IA64_PCREL32MSB: + case R_IA64_PCREL32LSB: + case R_IA64_PCREL64MSB: + case R_IA64_PCREL64LSB: + if (maybe_dynamic) + need_entry = NEED_DYNREL; + dynrel_type = R_IA64_PCREL64LSB; + break; + } + + if (!need_entry) + continue; + + dyn_i = get_dyn_sym_info (ia64_info, h, abfd, rel, FALSE); + + /* Record whether or not this is a local symbol. */ + dyn_i->h = h; + + /* Create what's needed. */ + if (need_entry & (NEED_GOT | NEED_GOTX)) + { + if (!got) + { + got = get_got (abfd, ia64_info); + if (!got) + return FALSE; + } + if (need_entry & NEED_GOT) + dyn_i->want_got = 1; + if (need_entry & NEED_GOTX) + dyn_i->want_gotx = 1; + } + if (need_entry & NEED_FPTR) + { + /* Create the .opd section. */ + if (!fptr) + { + fptr = get_fptr (abfd, info, ia64_info); + if (!fptr) + return FALSE; + } + dyn_i->want_fptr = 1; + } + if (need_entry & NEED_LTOFF_FPTR) + dyn_i->want_ltoff_fptr = 1; + if (need_entry & (NEED_MIN_PLT | NEED_FULL_PLT)) + { + if (!ia64_info->root.dynobj) + ia64_info->root.dynobj = abfd; + h->needs_plt = 1; + dyn_i->want_plt = 1; + } + if (need_entry & NEED_FULL_PLT) + dyn_i->want_plt2 = 1; + if (need_entry & NEED_PLTOFF) + { + /* This is needed here, in case @pltoff is used in a non-shared + link. */ + if (!pltoff) + { + pltoff = get_pltoff (abfd, ia64_info); + if (!pltoff) + return FALSE; + } + + dyn_i->want_pltoff = 1; + } + if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC)) + { + if (!srel) + { + srel = get_reloc_section (abfd, ia64_info, sec, TRUE); + if (!srel) + return FALSE; + } + if (!count_dyn_reloc (abfd, dyn_i, srel, dynrel_type)) + return FALSE; + } + } + + return TRUE; +} + +/* For cleanliness, and potentially faster dynamic loading, allocate + external GOT entries first. */ + +static bfd_boolean +allocate_global_data_got (struct elf64_ia64_dyn_sym_info *dyn_i, + void * data) +{ + struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data; + + if ((dyn_i->want_got || dyn_i->want_gotx) + && ! dyn_i->want_fptr + && elf64_ia64_dynamic_symbol_p (dyn_i->h)) + { + /* GOT entry with FPTR is done by allocate_global_fptr_got. */ + dyn_i->got_offset = x->ofs; + x->ofs += 8; + } + return TRUE; +} + +/* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */ + +static bfd_boolean +allocate_global_fptr_got (struct elf64_ia64_dyn_sym_info *dyn_i, + void * data) +{ + struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data; + + if (dyn_i->want_got + && dyn_i->want_fptr + && elf64_ia64_dynamic_symbol_p (dyn_i->h)) + { + dyn_i->got_offset = x->ofs; + x->ofs += 8; + } + return TRUE; +} + +/* Lastly, allocate all the GOT entries for local data. */ + +static bfd_boolean +allocate_local_got (struct elf64_ia64_dyn_sym_info *dyn_i, + void * data) +{ + struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *) data; + + if ((dyn_i->want_got || dyn_i->want_gotx) + && !elf64_ia64_dynamic_symbol_p (dyn_i->h)) + { + dyn_i->got_offset = x->ofs; + x->ofs += 8; + } + return TRUE; +} + +/* Allocate function descriptors. We can do these for every function + in a main executable that is not exported. */ + +static bfd_boolean +allocate_fptr (struct elf64_ia64_dyn_sym_info *dyn_i, void * data) +{ + struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *) data; + + if (dyn_i->want_fptr) + { + struct elf_link_hash_entry *h = dyn_i->h; + + if (h) + while (h->root.type == bfd_link_hash_indirect + || h->root.type == bfd_link_hash_warning) + h = (struct elf_link_hash_entry *) h->root.u.i.link; + + if (h == NULL || !h->def_dynamic) + { + /* A non dynamic symbol. */ + dyn_i->fptr_offset = x->ofs; + x->ofs += 16; + } + else + dyn_i->want_fptr = 0; + } + return TRUE; +} + +/* Allocate all the minimal PLT entries. */ + +static bfd_boolean +allocate_plt_entries (struct elf64_ia64_dyn_sym_info *dyn_i, + void * data ATTRIBUTE_UNUSED) +{ + if (dyn_i->want_plt) + { + struct elf_link_hash_entry *h = dyn_i->h; + + if (h) + while (h->root.type == bfd_link_hash_indirect + || h->root.type == bfd_link_hash_warning) + h = (struct elf_link_hash_entry *) h->root.u.i.link; + + /* ??? Versioned symbols seem to lose NEEDS_PLT. */ + if (elf64_ia64_dynamic_symbol_p (h)) + { + dyn_i->want_pltoff = 1; + } + else + { + dyn_i->want_plt = 0; + dyn_i->want_plt2 = 0; + } + } + return TRUE; +} + +/* Allocate all the full PLT entries. */ + +static bfd_boolean +allocate_plt2_entries (struct elf64_ia64_dyn_sym_info *dyn_i, + void * data) +{ + struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data; + + if (dyn_i->want_plt2) + { + struct elf_link_hash_entry *h = dyn_i->h; + bfd_size_type ofs = x->ofs; + + dyn_i->plt2_offset = ofs; + x->ofs = ofs + PLT_FULL_ENTRY_SIZE; + + while (h->root.type == bfd_link_hash_indirect + || h->root.type == bfd_link_hash_warning) + h = (struct elf_link_hash_entry *) h->root.u.i.link; + dyn_i->h->plt.offset = ofs; + } + return TRUE; +} + +/* Allocate all the PLTOFF entries requested by relocations and + plt entries. We can't share space with allocated FPTR entries, + because the latter are not necessarily addressable by the GP. + ??? Relaxation might be able to determine that they are. */ + +static bfd_boolean +allocate_pltoff_entries (struct elf64_ia64_dyn_sym_info *dyn_i, + void * data) +{ + struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data; + + if (dyn_i->want_pltoff) + { + dyn_i->pltoff_offset = x->ofs; + x->ofs += 16; + } + return TRUE; +} + +/* Allocate dynamic relocations for those symbols that turned out + to be dynamic. */ + +static bfd_boolean +allocate_dynrel_entries (struct elf64_ia64_dyn_sym_info *dyn_i, + void * data) +{ + struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data; + struct elf64_ia64_link_hash_table *ia64_info; + struct elf64_ia64_dyn_reloc_entry *rent; + bfd_boolean dynamic_symbol, shared, resolved_zero; + struct elf64_ia64_link_hash_entry *h_ia64; + + ia64_info = elf64_ia64_hash_table (x->info); + if (ia64_info == NULL) + return FALSE; + + /* Note that this can't be used in relation to FPTR relocs below. */ + dynamic_symbol = elf64_ia64_dynamic_symbol_p (dyn_i->h); + + shared = x->info->shared; + resolved_zero = (dyn_i->h + && ELF_ST_VISIBILITY (dyn_i->h->other) + && dyn_i->h->root.type == bfd_link_hash_undefweak); + + /* Take care of the GOT and PLT relocations. */ + + if ((!resolved_zero + && (dynamic_symbol || shared) + && (dyn_i->want_got || dyn_i->want_gotx)) + || (dyn_i->want_ltoff_fptr + && dyn_i->h + && dyn_i->h->def_dynamic)) + { + /* VMS: FIX64. */ + if (dyn_i->h != NULL && dyn_i->h->def_dynamic) + { + h_ia64 = (struct elf64_ia64_link_hash_entry *) dyn_i->h; + elf_ia64_vms_tdata (h_ia64->shl)->fixups_off += + sizeof (Elf64_External_VMS_IMAGE_FIXUP); + ia64_info->fixups_sec->size += + sizeof (Elf64_External_VMS_IMAGE_FIXUP); + } + } + + if (ia64_info->rel_fptr_sec && dyn_i->want_fptr) + { + /* VMS: only image reloc. */ + if (dyn_i->h == NULL || dyn_i->h->root.type != bfd_link_hash_undefweak) + ia64_info->rel_fptr_sec->size += sizeof (Elf64_External_Rela); + } + + if (!resolved_zero && dyn_i->want_pltoff) + { + /* VMS: FIXFD. */ + if (dyn_i->h != NULL && dyn_i->h->def_dynamic) + { + h_ia64 = (struct elf64_ia64_link_hash_entry *) dyn_i->h; + elf_ia64_vms_tdata (h_ia64->shl)->fixups_off += + sizeof (Elf64_External_VMS_IMAGE_FIXUP); + ia64_info->fixups_sec->size += + sizeof (Elf64_External_VMS_IMAGE_FIXUP); + } + } + + /* Take care of the normal data relocations. */ + + for (rent = dyn_i->reloc_entries; rent; rent = rent->next) + { + int count = rent->count; + + switch (rent->type) + { + case R_IA64_FPTR32LSB: + case R_IA64_FPTR64LSB: + /* Allocate one iff !want_fptr and not PIE, which by this point + will be true only if we're actually allocating one statically + in the main executable. Position independent executables + need a relative reloc. */ + if (dyn_i->want_fptr && !x->info->pie) + continue; + break; + case R_IA64_PCREL32LSB: + case R_IA64_PCREL64LSB: + if (!dynamic_symbol) + continue; + break; + case R_IA64_DIR32LSB: + case R_IA64_DIR64LSB: + if (!dynamic_symbol && !shared) + continue; + break; + case R_IA64_IPLTLSB: + if (!dynamic_symbol && !shared) + continue; + /* Use two REL relocations for IPLT relocations + against local symbols. */ + if (!dynamic_symbol) + count *= 2; + break; + case R_IA64_DTPREL32LSB: + case R_IA64_TPREL64LSB: + case R_IA64_DTPREL64LSB: + case R_IA64_DTPMOD64LSB: + break; + default: + abort (); + } + + /* Add a fixup. */ + if (!dynamic_symbol) + abort (); + + h_ia64 = (struct elf64_ia64_link_hash_entry *) dyn_i->h; + elf_ia64_vms_tdata (h_ia64->shl)->fixups_off += + sizeof (Elf64_External_VMS_IMAGE_FIXUP); + ia64_info->fixups_sec->size += + sizeof (Elf64_External_VMS_IMAGE_FIXUP); + } + + return TRUE; +} + +static bfd_boolean +elf64_ia64_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED, + struct elf_link_hash_entry *h) +{ + /* ??? Undefined symbols with PLT entries should be re-defined + to be the PLT entry. */ + + /* If this is a weak symbol, and there is a real definition, the + processor independent code will have arranged for us to see the + real definition first, and we can just use the same value. */ + if (h->u.weakdef != NULL) + { + BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined + || h->u.weakdef->root.type == bfd_link_hash_defweak); + h->root.u.def.section = h->u.weakdef->root.u.def.section; + h->root.u.def.value = h->u.weakdef->root.u.def.value; + return TRUE; + } + + /* If this is a reference to a symbol defined by a dynamic object which + is not a function, we might allocate the symbol in our .dynbss section + and allocate a COPY dynamic relocation. + + But IA-64 code is canonically PIC, so as a rule we can avoid this sort + of hackery. */ + + return TRUE; +} + +static bfd_boolean +elf64_ia64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, + struct bfd_link_info *info) +{ + struct elf64_ia64_allocate_data data; + struct elf64_ia64_link_hash_table *ia64_info; + asection *sec; + bfd *dynobj; + struct elf_link_hash_table *hash_table; + + hash_table = elf_hash_table (info); + dynobj = hash_table->dynobj; + ia64_info = elf64_ia64_hash_table (info); + if (ia64_info == NULL) + return FALSE; + BFD_ASSERT(dynobj != NULL); + data.info = info; + + /* Allocate the GOT entries. */ + + if (ia64_info->root.sgot) + { + data.ofs = 0; + elf64_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data); + elf64_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data); + elf64_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data); + ia64_info->root.sgot->size = data.ofs; + } + + /* Allocate the FPTR entries. */ + + if (ia64_info->fptr_sec) + { + data.ofs = 0; + elf64_ia64_dyn_sym_traverse (ia64_info, allocate_fptr, &data); + ia64_info->fptr_sec->size = data.ofs; + } + + /* Now that we've seen all of the input files, we can decide which + symbols need plt entries. Allocate the minimal PLT entries first. + We do this even though dynamic_sections_created may be FALSE, because + this has the side-effect of clearing want_plt and want_plt2. */ + + data.ofs = 0; + elf64_ia64_dyn_sym_traverse (ia64_info, allocate_plt_entries, &data); + + /* Align the pointer for the plt2 entries. */ + data.ofs = (data.ofs + 31) & (bfd_vma) -32; + + elf64_ia64_dyn_sym_traverse (ia64_info, allocate_plt2_entries, &data); + if (data.ofs != 0 || ia64_info->root.dynamic_sections_created) + { + /* FIXME: we always reserve the memory for dynamic linker even if + there are no PLT entries since dynamic linker may assume the + reserved memory always exists. */ + + BFD_ASSERT (ia64_info->root.dynamic_sections_created); + + ia64_info->root.splt->size = data.ofs; + } + + /* Allocate the PLTOFF entries. */ + + if (ia64_info->pltoff_sec) + { + data.ofs = 0; + elf64_ia64_dyn_sym_traverse (ia64_info, allocate_pltoff_entries, &data); + ia64_info->pltoff_sec->size = data.ofs; + } + + if (ia64_info->root.dynamic_sections_created) + { + /* Allocate space for the dynamic relocations that turned out to be + required. */ + elf64_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries, &data); + } + + /* We have now determined the sizes of the various dynamic sections. + Allocate memory for them. */ + for (sec = dynobj->sections; sec != NULL; sec = sec->next) + { + bfd_boolean strip; + + if (!(sec->flags & SEC_LINKER_CREATED)) + continue; + + /* If we don't need this section, strip it from the output file. + There were several sections primarily related to dynamic + linking that must be create before the linker maps input + sections to output sections. The linker does that before + bfd_elf_size_dynamic_sections is called, and it is that + function which decides whether anything needs to go into + these sections. */ + + strip = (sec->size == 0); + + if (sec == ia64_info->root.sgot) + strip = FALSE; + else if (sec == ia64_info->root.srelgot) + { + if (strip) + ia64_info->root.srelgot = NULL; + else + /* We use the reloc_count field as a counter if we need to + copy relocs into the output file. */ + sec->reloc_count = 0; + } + else if (sec == ia64_info->fptr_sec) + { + if (strip) + ia64_info->fptr_sec = NULL; + } + else if (sec == ia64_info->rel_fptr_sec) + { + if (strip) + ia64_info->rel_fptr_sec = NULL; + else + /* We use the reloc_count field as a counter if we need to + copy relocs into the output file. */ + sec->reloc_count = 0; + } + else if (sec == ia64_info->root.splt) + { + if (strip) + ia64_info->root.splt = NULL; + } + else if (sec == ia64_info->pltoff_sec) + { + if (strip) + ia64_info->pltoff_sec = NULL; + } + else if (sec == ia64_info->fixups_sec) + { + if (strip) + ia64_info->fixups_sec = NULL; + } + else if (sec == ia64_info->transfer_sec) + { + ; + } + else + { + const char *name; + + /* It's OK to base decisions on the section name, because none + of the dynobj section names depend upon the input files. */ + name = bfd_get_section_name (dynobj, sec); + + if (strcmp (name, ".got.plt") == 0) + strip = FALSE; + else if (CONST_STRNEQ (name, ".rel")) + { + if (!strip) + { + /* We use the reloc_count field as a counter if we need to + copy relocs into the output file. */ + sec->reloc_count = 0; + } + } + else + continue; + } + + if (strip) + sec->flags |= SEC_EXCLUDE; + else + { + /* Allocate memory for the section contents. */ + sec->contents = (bfd_byte *) bfd_zalloc (dynobj, sec->size); + if (sec->contents == NULL && sec->size != 0) + return FALSE; + } + } + + if (elf_hash_table (info)->dynamic_sections_created) + { + bfd *abfd; + asection *dynsec; + asection *dynstrsec; + Elf_Internal_Dyn dyn; + const struct elf_backend_data *bed; + unsigned int shl_num = 0; + bfd_vma fixups_off = 0; + bfd_vma strdyn_off; + unsigned int time_hi, time_lo; + + /* The .dynamic section must exist and be empty. */ + dynsec = bfd_get_section_by_name (hash_table->dynobj, ".dynamic"); + BFD_ASSERT (dynsec != NULL); + BFD_ASSERT (dynsec->size == 0); + + dynstrsec = bfd_get_section_by_name (hash_table->dynobj, ".vmsdynstr"); + BFD_ASSERT (dynstrsec != NULL); + BFD_ASSERT (dynstrsec->size == 0); + dynstrsec->size = 1; /* Initial blank. */ + + /* Ident + link time. */ + vms_get_time (&time_hi, &time_lo); + + if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_IDENT, 0)) + return FALSE; + if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_LINKTIME, + (((bfd_uint64_t)time_hi) << 32) + + time_lo)) + return FALSE; + + /* Strtab. */ + strdyn_off = dynsec->size; + if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_STRTAB_OFFSET, 0)) + return FALSE; + if (!_bfd_elf_add_dynamic_entry (info, DT_STRSZ, 0)) + return FALSE; + + /* PLTGOT */ + if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_PLTGOT_SEG, 0)) + return FALSE; + if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_PLTGOT_OFFSET, 0)) + return FALSE; + + /* Misc. */ + if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_FPMODE, 0x9800000)) + return FALSE; + if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_LNKFLAGS, + VMS_LF_IMGSTA | VMS_LF_MAIN)) + return FALSE; + + /* Add entries for shared libraries. */ + for (abfd = info->input_bfds; abfd; abfd = abfd->link_next) + { + char *soname; + size_t soname_len; + bfd_size_type strindex; + bfd_byte *newcontents; + bfd_vma fixups_shl_off; + + if (!(abfd->flags & DYNAMIC)) + continue; + BFD_ASSERT (abfd->xvec == output_bfd->xvec); + + if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_NEEDED_IDENT, + elf_ia64_vms_ident (abfd))) + return FALSE; + + soname = vms_get_module_name (abfd->filename, TRUE); + if (soname == NULL) + return FALSE; + strindex = dynstrsec->size; + soname_len = strlen (soname) + 1; + newcontents = (bfd_byte *) bfd_realloc (dynstrsec->contents, + strindex + soname_len); + if (newcontents == NULL) + return FALSE; + memcpy (newcontents + strindex, soname, soname_len); + dynstrsec->size += soname_len; + dynstrsec->contents = newcontents; + + if (!_bfd_elf_add_dynamic_entry (info, DT_NEEDED, strindex)) + return FALSE; + + if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_FIXUP_NEEDED, + shl_num)) + return FALSE; + shl_num++; + + /* The fixups_off was in fact containing the size of the fixup + section. Remap into the offset. */ + fixups_shl_off = elf_ia64_vms_tdata (abfd)->fixups_off; + elf_ia64_vms_tdata (abfd)->fixups_off = fixups_off; + + if (!_bfd_elf_add_dynamic_entry + (info, DT_IA_64_VMS_FIXUP_RELA_CNT, + fixups_shl_off / sizeof (Elf64_External_VMS_IMAGE_FIXUP))) + return FALSE; + if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_FIXUP_RELA_OFF, + fixups_off)) + return FALSE; + fixups_off += fixups_shl_off; + } + + /* Unwind. */ + if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWINDSZ, 0)) + return FALSE; + if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWIND_CODSEG, 0)) + return FALSE; + if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWIND_INFOSEG, 0)) + return FALSE; + if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWIND_OFFSET, 0)) + return FALSE; + if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWIND_SEG, 0)) + return FALSE; + + if (!_bfd_elf_add_dynamic_entry (info, DT_NULL, 0xdead)) + return FALSE; + + /* Fix the strtab entries. */ + bed = get_elf_backend_data (hash_table->dynobj); + + if (dynstrsec->size > 1) + dynstrsec->contents[0] = 0; + else + dynstrsec->size = 0; + + /* Note: one 'spare' (ie DT_NULL) entry is added by + bfd_elf_size_dynsym_hash_dynstr. */ + dyn.d_tag = DT_IA_64_VMS_STRTAB_OFFSET; + dyn.d_un.d_val = dynsec->size /* + sizeof (Elf64_External_Dyn) */; + bed->s->swap_dyn_out (hash_table->dynobj, &dyn, + dynsec->contents + strdyn_off); + + dyn.d_tag = DT_STRSZ; + dyn.d_un.d_val = dynstrsec->size; + bed->s->swap_dyn_out (hash_table->dynobj, &dyn, + dynsec->contents + strdyn_off + bed->s->sizeof_dyn); + + elf_ia64_vms_tdata (output_bfd)->needed_count = shl_num; + + /* Note section. */ + if (!create_ia64_vms_notes (output_bfd, info, time_hi, time_lo)) + return FALSE; + } + + /* ??? Perhaps force __gp local. */ + + return TRUE; +} + +static void +elf64_ia64_install_fixup (bfd *output_bfd, + struct elf64_ia64_link_hash_table *ia64_info, + struct elf_link_hash_entry *h, + unsigned int type, asection *sec, bfd_vma offset, + bfd_vma addend) +{ + asection *relsec; + Elf64_External_VMS_IMAGE_FIXUP *fixup; + struct elf64_ia64_link_hash_entry *h_ia64; + bfd_vma fixoff; + Elf_Internal_Phdr *phdr; + + if (h == NULL || !h->def_dynamic) + abort (); + + h_ia64 = (struct elf64_ia64_link_hash_entry *) h; + fixoff = elf_ia64_vms_tdata (h_ia64->shl)->fixups_off; + elf_ia64_vms_tdata (h_ia64->shl)->fixups_off += + sizeof (Elf64_External_VMS_IMAGE_FIXUP); + relsec = ia64_info->fixups_sec; + + fixup = (Elf64_External_VMS_IMAGE_FIXUP *)(relsec->contents + fixoff); + offset += sec->output_section->vma + sec->output_offset; + + /* FIXME: this is slow. We should cache the last one used, or create a + map. */ + phdr = _bfd_elf_find_segment_containing_section + (output_bfd, sec->output_section); + BFD_ASSERT (phdr != NULL); + + bfd_putl64 (offset - phdr->p_vaddr, fixup->fixup_offset); + bfd_putl32 (type, fixup->type); + bfd_putl32 (phdr - elf_tdata (output_bfd)->phdr, fixup->fixup_seg); + bfd_putl64 (addend, fixup->addend); + bfd_putl32 (h->root.u.def.value, fixup->symvec_index); + bfd_putl32 (2, fixup->data_type); +} + +/* Store an entry for target address TARGET_ADDR in the linkage table + and return the gp-relative address of the linkage table entry. */ + +static bfd_vma +set_got_entry (bfd *abfd, struct bfd_link_info *info, + struct elf64_ia64_dyn_sym_info *dyn_i, + bfd_vma addend, bfd_vma value, unsigned int dyn_r_type) +{ + struct elf64_ia64_link_hash_table *ia64_info; + asection *got_sec; + bfd_boolean done; + bfd_vma got_offset; + + ia64_info = elf64_ia64_hash_table (info); + if (ia64_info == NULL) + return 0; + + got_sec = ia64_info->root.sgot; + + switch (dyn_r_type) + { + case R_IA64_TPREL64LSB: + case R_IA64_DTPMOD64LSB: + case R_IA64_DTPREL32LSB: + case R_IA64_DTPREL64LSB: + abort (); + break; + default: + done = dyn_i->got_done; + dyn_i->got_done = TRUE; + got_offset = dyn_i->got_offset; + break; + } + + BFD_ASSERT ((got_offset & 7) == 0); + + if (! done) + { + /* Store the target address in the linkage table entry. */ + bfd_put_64 (abfd, value, got_sec->contents + got_offset); + + /* Install a dynamic relocation if needed. */ + if (((info->shared + && (!dyn_i->h + || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT + || dyn_i->h->root.type != bfd_link_hash_undefweak)) + || elf64_ia64_dynamic_symbol_p (dyn_i->h)) + && (!dyn_i->want_ltoff_fptr + || !info->pie + || !dyn_i->h + || dyn_i->h->root.type != bfd_link_hash_undefweak)) + { + if (!dyn_i->h || !dyn_i->h->def_dynamic) + { + dyn_r_type = R_IA64_REL64LSB; + addend = value; + } + + /* VMS: install a FIX32 or FIX64. */ + switch (dyn_r_type) + { + case R_IA64_DIR32LSB: + case R_IA64_FPTR32LSB: + dyn_r_type = R_IA64_VMS_FIX32; + break; + case R_IA64_DIR64LSB: + case R_IA64_FPTR64LSB: + dyn_r_type = R_IA64_VMS_FIX64; + break; + default: + BFD_ASSERT (FALSE); + break; + } + elf64_ia64_install_fixup + (info->output_bfd, ia64_info, dyn_i->h, + dyn_r_type, got_sec, got_offset, addend); + } + } + + /* Return the address of the linkage table entry. */ + value = (got_sec->output_section->vma + + got_sec->output_offset + + got_offset); + + return value; +} + +/* Fill in a function descriptor consisting of the function's code + address and its global pointer. Return the descriptor's address. */ + +static bfd_vma +set_fptr_entry (bfd *abfd, struct bfd_link_info *info, + struct elf64_ia64_dyn_sym_info *dyn_i, + bfd_vma value) +{ + struct elf64_ia64_link_hash_table *ia64_info; + asection *fptr_sec; + + ia64_info = elf64_ia64_hash_table (info); + if (ia64_info == NULL) + return 0; + + fptr_sec = ia64_info->fptr_sec; + + if (!dyn_i->fptr_done) + { + dyn_i->fptr_done = 1; + + /* Fill in the function descriptor. */ + bfd_put_64 (abfd, value, fptr_sec->contents + dyn_i->fptr_offset); + bfd_put_64 (abfd, _bfd_get_gp_value (abfd), + fptr_sec->contents + dyn_i->fptr_offset + 8); + } + + /* Return the descriptor's address. */ + value = (fptr_sec->output_section->vma + + fptr_sec->output_offset + + dyn_i->fptr_offset); + + return value; +} + +/* Fill in a PLTOFF entry consisting of the function's code address + and its global pointer. Return the descriptor's address. */ + +static bfd_vma +set_pltoff_entry (bfd *abfd, struct bfd_link_info *info, + struct elf64_ia64_dyn_sym_info *dyn_i, + bfd_vma value, bfd_boolean is_plt) +{ + struct elf64_ia64_link_hash_table *ia64_info; + asection *pltoff_sec; + + ia64_info = elf64_ia64_hash_table (info); + if (ia64_info == NULL) + return 0; + + pltoff_sec = ia64_info->pltoff_sec; + + /* Don't do anything if this symbol uses a real PLT entry. In + that case, we'll fill this in during finish_dynamic_symbol. */ + if ((! dyn_i->want_plt || is_plt) + && !dyn_i->pltoff_done) + { + bfd_vma gp = _bfd_get_gp_value (abfd); + + /* Fill in the function descriptor. */ + bfd_put_64 (abfd, value, pltoff_sec->contents + dyn_i->pltoff_offset); + bfd_put_64 (abfd, gp, pltoff_sec->contents + dyn_i->pltoff_offset + 8); + + /* Install dynamic relocations if needed. */ + if (!is_plt + && info->shared + && (!dyn_i->h + || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT + || dyn_i->h->root.type != bfd_link_hash_undefweak)) + { + /* VMS: */ + abort (); + } + + dyn_i->pltoff_done = 1; + } + + /* Return the descriptor's address. */ + value = (pltoff_sec->output_section->vma + + pltoff_sec->output_offset + + dyn_i->pltoff_offset); + + return value; +} + +/* Called through qsort to sort the .IA_64.unwind section during a + non-relocatable link. Set elf64_ia64_unwind_entry_compare_bfd + to the output bfd so we can do proper endianness frobbing. */ + +static bfd *elf64_ia64_unwind_entry_compare_bfd; + +static int +elf64_ia64_unwind_entry_compare (const void * a, const void * b) +{ + bfd_vma av, bv; + + av = bfd_get_64 (elf64_ia64_unwind_entry_compare_bfd, a); + bv = bfd_get_64 (elf64_ia64_unwind_entry_compare_bfd, b); + + return (av < bv ? -1 : av > bv ? 1 : 0); +} + +/* Make sure we've got ourselves a nice fat __gp value. */ +static bfd_boolean +elf64_ia64_choose_gp (bfd *abfd, struct bfd_link_info *info, bfd_boolean final) +{ + bfd_vma min_vma = (bfd_vma) -1, max_vma = 0; + bfd_vma min_short_vma = min_vma, max_short_vma = 0; + struct elf_link_hash_entry *gp; + bfd_vma gp_val; + asection *os; + struct elf64_ia64_link_hash_table *ia64_info; + + ia64_info = elf64_ia64_hash_table (info); + if (ia64_info == NULL) + return FALSE; + + /* Find the min and max vma of all sections marked short. Also collect + min and max vma of any type, for use in selecting a nice gp. */ + for (os = abfd->sections; os ; os = os->next) + { + bfd_vma lo, hi; + + if ((os->flags & SEC_ALLOC) == 0) + continue; + + lo = os->vma; + /* When this function is called from elfNN_ia64_final_link + the correct value to use is os->size. When called from + elfNN_ia64_relax_section we are in the middle of section + sizing; some sections will already have os->size set, others + will have os->size zero and os->rawsize the previous size. */ + hi = os->vma + (!final && os->rawsize ? os->rawsize : os->size); + if (hi < lo) + hi = (bfd_vma) -1; + + if (min_vma > lo) + min_vma = lo; + if (max_vma < hi) + max_vma = hi; + if (os->flags & SEC_SMALL_DATA) + { + if (min_short_vma > lo) + min_short_vma = lo; + if (max_short_vma < hi) + max_short_vma = hi; + } + } + + if (ia64_info->min_short_sec) + { + if (min_short_vma + > (ia64_info->min_short_sec->vma + + ia64_info->min_short_offset)) + min_short_vma = (ia64_info->min_short_sec->vma + + ia64_info->min_short_offset); + if (max_short_vma + < (ia64_info->max_short_sec->vma + + ia64_info->max_short_offset)) + max_short_vma = (ia64_info->max_short_sec->vma + + ia64_info->max_short_offset); + } + + /* See if the user wants to force a value. */ + gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE, + FALSE, FALSE); + + if (gp + && (gp->root.type == bfd_link_hash_defined + || gp->root.type == bfd_link_hash_defweak)) + { + asection *gp_sec = gp->root.u.def.section; + gp_val = (gp->root.u.def.value + + gp_sec->output_section->vma + + gp_sec->output_offset); + } + else + { + /* Pick a sensible value. */ + + if (ia64_info->min_short_sec) + { + bfd_vma short_range = max_short_vma - min_short_vma; + + /* If min_short_sec is set, pick one in the middle bewteen + min_short_vma and max_short_vma. */ + if (short_range >= 0x400000) + goto overflow; + gp_val = min_short_vma + short_range / 2; + } + else + { + asection *got_sec = ia64_info->root.sgot; + + /* Start with just the address of the .got. */ + if (got_sec) + gp_val = got_sec->output_section->vma; + else if (max_short_vma != 0) + gp_val = min_short_vma; + else if (max_vma - min_vma < 0x200000) + gp_val = min_vma; + else + gp_val = max_vma - 0x200000 + 8; + } + + /* If it is possible to address the entire image, but we + don't with the choice above, adjust. */ + if (max_vma - min_vma < 0x400000 + && (max_vma - gp_val >= 0x200000 + || gp_val - min_vma > 0x200000)) + gp_val = min_vma + 0x200000; + else if (max_short_vma != 0) + { + /* If we don't cover all the short data, adjust. */ + if (max_short_vma - gp_val >= 0x200000) + gp_val = min_short_vma + 0x200000; + + /* If we're addressing stuff past the end, adjust back. */ + if (gp_val > max_vma) + gp_val = max_vma - 0x200000 + 8; + } + } + + /* Validate whether all SHF_IA_64_SHORT sections are within + range of the chosen GP. */ + + if (max_short_vma != 0) + { + if (max_short_vma - min_short_vma >= 0x400000) + { +overflow: + (*_bfd_error_handler) + (_("%s: short data segment overflowed (0x%lx >= 0x400000)"), + bfd_get_filename (abfd), + (unsigned long) (max_short_vma - min_short_vma)); + return FALSE; + } + else if ((gp_val > min_short_vma + && gp_val - min_short_vma > 0x200000) + || (gp_val < max_short_vma + && max_short_vma - gp_val >= 0x200000)) + { + (*_bfd_error_handler) + (_("%s: __gp does not cover short data segment"), + bfd_get_filename (abfd)); + return FALSE; + } + } + + _bfd_set_gp_value (abfd, gp_val); + + return TRUE; +} + +static bfd_boolean +elf64_ia64_final_link (bfd *abfd, struct bfd_link_info *info) +{ + struct elf64_ia64_link_hash_table *ia64_info; + asection *unwind_output_sec; + + ia64_info = elf64_ia64_hash_table (info); + if (ia64_info == NULL) + return FALSE; + + /* Make sure we've got ourselves a nice fat __gp value. */ + if (!info->relocatable) + { + bfd_vma gp_val; + struct elf_link_hash_entry *gp; + + /* We assume after gp is set, section size will only decrease. We + need to adjust gp for it. */ + _bfd_set_gp_value (abfd, 0); + if (! elf64_ia64_choose_gp (abfd, info, TRUE)) + return FALSE; + gp_val = _bfd_get_gp_value (abfd); + + gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE, + FALSE, FALSE); + if (gp) + { + gp->root.type = bfd_link_hash_defined; + gp->root.u.def.value = gp_val; + gp->root.u.def.section = bfd_abs_section_ptr; + } + } + + /* If we're producing a final executable, we need to sort the contents + of the .IA_64.unwind section. Force this section to be relocated + into memory rather than written immediately to the output file. */ + unwind_output_sec = NULL; + if (!info->relocatable) + { + asection *s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind); + if (s) + { + unwind_output_sec = s->output_section; + unwind_output_sec->contents + = bfd_malloc (unwind_output_sec->size); + if (unwind_output_sec->contents == NULL) + return FALSE; + } + } + + /* Invoke the regular ELF backend linker to do all the work. */ + if (!bfd_elf_final_link (abfd, info)) + return FALSE; + + if (unwind_output_sec) + { + elf64_ia64_unwind_entry_compare_bfd = abfd; + qsort (unwind_output_sec->contents, + (size_t) (unwind_output_sec->size / 24), + 24, + elf64_ia64_unwind_entry_compare); + + if (! bfd_set_section_contents (abfd, unwind_output_sec, + unwind_output_sec->contents, (bfd_vma) 0, + unwind_output_sec->size)) + return FALSE; + } + + return TRUE; +} + +static bfd_boolean +elf64_ia64_relocate_section (bfd *output_bfd, + struct bfd_link_info *info, + bfd *input_bfd, + asection *input_section, + bfd_byte *contents, + Elf_Internal_Rela *relocs, + Elf_Internal_Sym *local_syms, + asection **local_sections) +{ + struct elf64_ia64_link_hash_table *ia64_info; + Elf_Internal_Shdr *symtab_hdr; + Elf_Internal_Rela *rel; + Elf_Internal_Rela *relend; + bfd_boolean ret_val = TRUE; /* for non-fatal errors */ + bfd_vma gp_val; + + symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; + ia64_info = elf64_ia64_hash_table (info); + if (ia64_info == NULL) + return FALSE; + + /* Infect various flags from the input section to the output section. */ + if (info->relocatable) + { + bfd_vma flags; + + flags = elf_section_data(input_section)->this_hdr.sh_flags; + flags &= SHF_IA_64_NORECOV; + + elf_section_data(input_section->output_section) + ->this_hdr.sh_flags |= flags; + } + + gp_val = _bfd_get_gp_value (output_bfd); + + rel = relocs; + relend = relocs + input_section->reloc_count; + for (; rel < relend; ++rel) + { + struct elf_link_hash_entry *h; + struct elf64_ia64_dyn_sym_info *dyn_i; + bfd_reloc_status_type r; + reloc_howto_type *howto; + unsigned long r_symndx; + Elf_Internal_Sym *sym; + unsigned int r_type; + bfd_vma value; + asection *sym_sec; + bfd_byte *hit_addr; + bfd_boolean dynamic_symbol_p; + bfd_boolean undef_weak_ref; + + r_type = ELF64_R_TYPE (rel->r_info); + if (r_type > R_IA64_MAX_RELOC_CODE) + { + (*_bfd_error_handler) + (_("%B: unknown relocation type %d"), + input_bfd, (int) r_type); + bfd_set_error (bfd_error_bad_value); + ret_val = FALSE; + continue; + } + + howto = ia64_elf_lookup_howto (r_type); + r_symndx = ELF64_R_SYM (rel->r_info); + h = NULL; + sym = NULL; + sym_sec = NULL; + undef_weak_ref = FALSE; + + if (r_symndx < symtab_hdr->sh_info) + { + /* Reloc against local symbol. */ + asection *msec; + sym = local_syms + r_symndx; + sym_sec = local_sections[r_symndx]; + msec = sym_sec; + value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel); + if (!info->relocatable + && (sym_sec->flags & SEC_MERGE) != 0 + && ELF_ST_TYPE (sym->st_info) == STT_SECTION + && sym_sec->sec_info_type == ELF_INFO_TYPE_MERGE) + { + struct elf64_ia64_local_hash_entry *loc_h; + + loc_h = get_local_sym_hash (ia64_info, input_bfd, rel, FALSE); + if (loc_h && ! loc_h->sec_merge_done) + { + struct elf64_ia64_dyn_sym_info *dynent; + unsigned int count; + + for (count = loc_h->count, dynent = loc_h->info; + count != 0; + count--, dynent++) + { + msec = sym_sec; + dynent->addend = + _bfd_merged_section_offset (output_bfd, &msec, + elf_section_data (msec)-> + sec_info, + sym->st_value + + dynent->addend); + dynent->addend -= sym->st_value; + dynent->addend += msec->output_section->vma + + msec->output_offset + - sym_sec->output_section->vma + - sym_sec->output_offset; + } + + /* We may have introduced duplicated entries. We need + to remove them properly. */ + count = sort_dyn_sym_info (loc_h->info, loc_h->count); + if (count != loc_h->count) + { + loc_h->count = count; + loc_h->sorted_count = count; + } + + loc_h->sec_merge_done = 1; + } + } + } + else + { + bfd_boolean unresolved_reloc; + bfd_boolean warned; + struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd); + + RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, + r_symndx, symtab_hdr, sym_hashes, + h, sym_sec, value, + unresolved_reloc, warned); + + if (h->root.type == bfd_link_hash_undefweak) + undef_weak_ref = TRUE; + else if (warned) + continue; + } + + /* For relocs against symbols from removed linkonce sections, + or sections discarded by a linker script, we just want the + section contents zeroed. Avoid any special processing. */ + if (sym_sec != NULL && elf_discarded_section (sym_sec)) + RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, + rel, relend, howto, contents); + + if (info->relocatable) + continue; + + hit_addr = contents + rel->r_offset; + value += rel->r_addend; + dynamic_symbol_p = elf64_ia64_dynamic_symbol_p (h); + + switch (r_type) + { + case R_IA64_NONE: + case R_IA64_LDXMOV: + continue; + + case R_IA64_IMM14: + case R_IA64_IMM22: + case R_IA64_IMM64: + case R_IA64_DIR32MSB: + case R_IA64_DIR32LSB: + case R_IA64_DIR64MSB: + case R_IA64_DIR64LSB: + /* Install a dynamic relocation for this reloc. */ + if ((dynamic_symbol_p || info->shared) + && r_symndx != 0 + && (input_section->flags & SEC_ALLOC) != 0) + { + unsigned int dyn_r_type; + bfd_vma addend; + + switch (r_type) + { + case R_IA64_IMM14: + case R_IA64_IMM22: + case R_IA64_IMM64: + /* ??? People shouldn't be doing non-pic code in + shared libraries nor dynamic executables. */ + (*_bfd_error_handler) + (_("%B: non-pic code with imm relocation against dynamic symbol `%s'"), + input_bfd, + h ? h->root.root.string + : bfd_elf_sym_name (input_bfd, symtab_hdr, sym, + sym_sec)); + ret_val = FALSE; + continue; + + default: + break; + } + + /* If we don't need dynamic symbol lookup, find a + matching RELATIVE relocation. */ + dyn_r_type = r_type; + if (dynamic_symbol_p) + { + addend = rel->r_addend; + value = 0; + } + else + { + addend = value; + } + + /* VMS: install a FIX64. */ + switch (dyn_r_type) + { + case R_IA64_DIR32LSB: + dyn_r_type = R_IA64_VMS_FIX32; + break; + case R_IA64_DIR64LSB: + dyn_r_type = R_IA64_VMS_FIX64; + break; + default: + BFD_ASSERT (FALSE); + break; + } + elf64_ia64_install_fixup + (output_bfd, ia64_info, h, + dyn_r_type, input_section, rel->r_offset, addend); + r = bfd_reloc_ok; + break; + } + /* Fall through. */ + + case R_IA64_LTV32MSB: + case R_IA64_LTV32LSB: + case R_IA64_LTV64MSB: + case R_IA64_LTV64LSB: + r = ia64_elf_install_value (hit_addr, value, r_type); + break; + + case R_IA64_GPREL22: + case R_IA64_GPREL64I: + case R_IA64_GPREL32MSB: + case R_IA64_GPREL32LSB: + case R_IA64_GPREL64MSB: + case R_IA64_GPREL64LSB: + if (dynamic_symbol_p) + { + (*_bfd_error_handler) + (_("%B: @gprel relocation against dynamic symbol %s"), + input_bfd, + h ? h->root.root.string + : bfd_elf_sym_name (input_bfd, symtab_hdr, sym, + sym_sec)); + ret_val = FALSE; + continue; + } + value -= gp_val; + r = ia64_elf_install_value (hit_addr, value, r_type); + break; + + case R_IA64_LTOFF22: + case R_IA64_LTOFF22X: + case R_IA64_LTOFF64I: + dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE); + value = set_got_entry (input_bfd, info, dyn_i, + rel->r_addend, value, R_IA64_DIR64LSB); + value -= gp_val; + r = ia64_elf_install_value (hit_addr, value, r_type); + break; + + case R_IA64_PLTOFF22: + case R_IA64_PLTOFF64I: + case R_IA64_PLTOFF64MSB: + case R_IA64_PLTOFF64LSB: + dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE); + value = set_pltoff_entry (output_bfd, info, dyn_i, value, FALSE); + value -= gp_val; + r = ia64_elf_install_value (hit_addr, value, r_type); + break; + + case R_IA64_FPTR64I: + case R_IA64_FPTR32MSB: + case R_IA64_FPTR32LSB: + case R_IA64_FPTR64MSB: + case R_IA64_FPTR64LSB: + dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE); + if (dyn_i->want_fptr) + { + if (!undef_weak_ref) + value = set_fptr_entry (output_bfd, info, dyn_i, value); + } + if (!dyn_i->want_fptr || info->pie) + { + /* Otherwise, we expect the dynamic linker to create + the entry. */ + + if (dyn_i->want_fptr) + { + if (r_type == R_IA64_FPTR64I) + { + /* We can't represent this without a dynamic symbol. + Adjust the relocation to be against an output + section symbol, which are always present in the + dynamic symbol table. */ + /* ??? People shouldn't be doing non-pic code in + shared libraries. Hork. */ + (*_bfd_error_handler) + (_("%B: linking non-pic code in a position independent executable"), + input_bfd); + ret_val = FALSE; + continue; + } + } + else + { + value = 0; + } + + /* VMS: FIXFD. */ + elf64_ia64_install_fixup + (output_bfd, ia64_info, h, R_IA64_VMS_FIXFD, + input_section, rel->r_offset, 0); + r = bfd_reloc_ok; + break; + } + + r = ia64_elf_install_value (hit_addr, value, r_type); + break; + + case R_IA64_LTOFF_FPTR22: + case R_IA64_LTOFF_FPTR64I: + case R_IA64_LTOFF_FPTR32MSB: + case R_IA64_LTOFF_FPTR32LSB: + case R_IA64_LTOFF_FPTR64MSB: + case R_IA64_LTOFF_FPTR64LSB: + dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE); + if (dyn_i->want_fptr) + { + BFD_ASSERT (h == NULL || !h->def_dynamic); + if (!undef_weak_ref) + value = set_fptr_entry (output_bfd, info, dyn_i, value); + } + else + value = 0; + + value = set_got_entry (output_bfd, info, dyn_i, + rel->r_addend, value, R_IA64_FPTR64LSB); + value -= gp_val; + r = ia64_elf_install_value (hit_addr, value, r_type); + break; + + case R_IA64_PCREL32MSB: + case R_IA64_PCREL32LSB: + case R_IA64_PCREL64MSB: + case R_IA64_PCREL64LSB: + /* Install a dynamic relocation for this reloc. */ + if (dynamic_symbol_p && r_symndx != 0) + { + /* VMS: doesn't exist ??? */ + abort (); + } + goto finish_pcrel; + + case R_IA64_PCREL21B: + case R_IA64_PCREL60B: + /* We should have created a PLT entry for any dynamic symbol. */ + dyn_i = NULL; + if (h) + dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE); + + if (dyn_i && dyn_i->want_plt2) + { + /* Should have caught this earlier. */ + BFD_ASSERT (rel->r_addend == 0); + + value = (ia64_info->root.splt->output_section->vma + + ia64_info->root.splt->output_offset + + dyn_i->plt2_offset); + } + else + { + /* Since there's no PLT entry, Validate that this is + locally defined. */ + BFD_ASSERT (undef_weak_ref || sym_sec->output_section != NULL); + + /* If the symbol is undef_weak, we shouldn't be trying + to call it. There's every chance that we'd wind up + with an out-of-range fixup here. Don't bother setting + any value at all. */ + if (undef_weak_ref) + continue; + } + goto finish_pcrel; + + case R_IA64_PCREL21BI: + case R_IA64_PCREL21F: + case R_IA64_PCREL21M: + case R_IA64_PCREL22: + case R_IA64_PCREL64I: + /* The PCREL21BI reloc is specifically not intended for use with + dynamic relocs. PCREL21F and PCREL21M are used for speculation + fixup code, and thus probably ought not be dynamic. The + PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs. */ + if (dynamic_symbol_p) + { + const char *msg; + + if (r_type == R_IA64_PCREL21BI) + msg = _("%B: @internal branch to dynamic symbol %s"); + else if (r_type == R_IA64_PCREL21F || r_type == R_IA64_PCREL21M) + msg = _("%B: speculation fixup to dynamic symbol %s"); + else + msg = _("%B: @pcrel relocation against dynamic symbol %s"); + (*_bfd_error_handler) (msg, input_bfd, + h ? h->root.root.string + : bfd_elf_sym_name (input_bfd, + symtab_hdr, + sym, + sym_sec)); + ret_val = FALSE; + continue; + } + goto finish_pcrel; + + finish_pcrel: + /* Make pc-relative. */ + value -= (input_section->output_section->vma + + input_section->output_offset + + rel->r_offset) & ~ (bfd_vma) 0x3; + r = ia64_elf_install_value (hit_addr, value, r_type); + break; + + case R_IA64_SEGREL32MSB: + case R_IA64_SEGREL32LSB: + case R_IA64_SEGREL64MSB: + case R_IA64_SEGREL64LSB: + { + /* Find the segment that contains the output_section. */ + Elf_Internal_Phdr *p = _bfd_elf_find_segment_containing_section + (output_bfd, sym_sec->output_section); + + if (p == NULL) + { + r = bfd_reloc_notsupported; + } + else + { + /* The VMA of the segment is the vaddr of the associated + program header. */ + if (value > p->p_vaddr) + value -= p->p_vaddr; + else + value = 0; + r = ia64_elf_install_value (hit_addr, value, r_type); + } + break; + } + + case R_IA64_SECREL32MSB: + case R_IA64_SECREL32LSB: + case R_IA64_SECREL64MSB: + case R_IA64_SECREL64LSB: + /* Make output-section relative to section where the symbol + is defined. PR 475 */ + if (sym_sec) + value -= sym_sec->output_section->vma; + r = ia64_elf_install_value (hit_addr, value, r_type); + break; + + case R_IA64_IPLTMSB: + case R_IA64_IPLTLSB: + /* Install a dynamic relocation for this reloc. */ + if ((dynamic_symbol_p || info->shared) + && (input_section->flags & SEC_ALLOC) != 0) + { + /* VMS: FIXFD ?? */ + abort (); + } + + if (r_type == R_IA64_IPLTMSB) + r_type = R_IA64_DIR64MSB; + else + r_type = R_IA64_DIR64LSB; + ia64_elf_install_value (hit_addr, value, r_type); + r = ia64_elf_install_value (hit_addr + 8, gp_val, r_type); + break; + + case R_IA64_TPREL14: + case R_IA64_TPREL22: + case R_IA64_TPREL64I: + r = bfd_reloc_notsupported; + break; + + case R_IA64_DTPREL14: + case R_IA64_DTPREL22: + case R_IA64_DTPREL64I: + case R_IA64_DTPREL32LSB: + case R_IA64_DTPREL32MSB: + case R_IA64_DTPREL64LSB: + case R_IA64_DTPREL64MSB: + r = bfd_reloc_notsupported; + break; + + case R_IA64_LTOFF_TPREL22: + case R_IA64_LTOFF_DTPMOD22: + case R_IA64_LTOFF_DTPREL22: + r = bfd_reloc_notsupported; + break; + + default: + r = bfd_reloc_notsupported; + break; + } + + switch (r) + { + case bfd_reloc_ok: + break; + + case bfd_reloc_undefined: + /* This can happen for global table relative relocs if + __gp is undefined. This is a panic situation so we + don't try to continue. */ + (*info->callbacks->undefined_symbol) + (info, "__gp", input_bfd, input_section, rel->r_offset, 1); + return FALSE; + + case bfd_reloc_notsupported: + { + const char *name; + + if (h) + name = h->root.root.string; + else + name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, + sym_sec); + if (!(*info->callbacks->warning) (info, _("unsupported reloc"), + name, input_bfd, + input_section, rel->r_offset)) + return FALSE; + ret_val = FALSE; + } + break; + + case bfd_reloc_dangerous: + case bfd_reloc_outofrange: + case bfd_reloc_overflow: + default: + { + const char *name; + + if (h) + name = h->root.root.string; + else + name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, + sym_sec); + + switch (r_type) + { + case R_IA64_TPREL14: + case R_IA64_TPREL22: + case R_IA64_TPREL64I: + case R_IA64_DTPREL14: + case R_IA64_DTPREL22: + case R_IA64_DTPREL64I: + case R_IA64_DTPREL32LSB: + case R_IA64_DTPREL32MSB: + case R_IA64_DTPREL64LSB: + case R_IA64_DTPREL64MSB: + case R_IA64_LTOFF_TPREL22: + case R_IA64_LTOFF_DTPMOD22: + case R_IA64_LTOFF_DTPREL22: + (*_bfd_error_handler) + (_("%B: missing TLS section for relocation %s against `%s' at 0x%lx in section `%A'."), + input_bfd, input_section, howto->name, name, + rel->r_offset); + break; + + case R_IA64_PCREL21B: + case R_IA64_PCREL21BI: + case R_IA64_PCREL21M: + case R_IA64_PCREL21F: + if (is_elf_hash_table (info->hash)) + { + /* Relaxtion is always performed for ELF output. + Overflow failures for those relocations mean + that the section is too big to relax. */ + (*_bfd_error_handler) + (_("%B: Can't relax br (%s) to `%s' at 0x%lx in section `%A' with size 0x%lx (> 0x1000000)."), + input_bfd, input_section, howto->name, name, + rel->r_offset, input_section->size); + break; + } + default: + if (!(*info->callbacks->reloc_overflow) (info, + &h->root, + name, + howto->name, + (bfd_vma) 0, + input_bfd, + input_section, + rel->r_offset)) + return FALSE; + break; + } + + ret_val = FALSE; + } + break; + } + } + + return ret_val; +} + +static bfd_boolean +elf64_ia64_finish_dynamic_symbol (bfd *output_bfd, + struct bfd_link_info *info, + struct elf_link_hash_entry *h, + Elf_Internal_Sym *sym) +{ + struct elf64_ia64_link_hash_table *ia64_info; + struct elf64_ia64_dyn_sym_info *dyn_i; + + ia64_info = elf64_ia64_hash_table (info); + if (ia64_info == NULL) + return FALSE; + + dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE); + + /* Fill in the PLT data, if required. */ + if (dyn_i && dyn_i->want_plt) + { + bfd_byte *loc; + asection *plt_sec; + bfd_vma plt_addr, pltoff_addr, gp_val; + + gp_val = _bfd_get_gp_value (output_bfd); + + plt_sec = ia64_info->root.splt; + plt_addr = 0; /* Not used as overriden by FIXUPs. */ + pltoff_addr = set_pltoff_entry (output_bfd, info, dyn_i, plt_addr, TRUE); + + /* Initialize the FULL PLT entry, if needed. */ + if (dyn_i->want_plt2) + { + loc = plt_sec->contents + dyn_i->plt2_offset; + + memcpy (loc, plt_full_entry, PLT_FULL_ENTRY_SIZE); + ia64_elf_install_value (loc, pltoff_addr - gp_val, R_IA64_IMM22); + + /* Mark the symbol as undefined, rather than as defined in the + plt section. Leave the value alone. */ + /* ??? We didn't redefine it in adjust_dynamic_symbol in the + first place. But perhaps elflink.c did some for us. */ + if (!h->def_regular) + sym->st_shndx = SHN_UNDEF; + } + + /* VMS: FIXFD. */ + elf64_ia64_install_fixup + (output_bfd, ia64_info, h, R_IA64_VMS_FIXFD, ia64_info->pltoff_sec, + pltoff_addr - (ia64_info->pltoff_sec->output_section->vma + + ia64_info->pltoff_sec->output_offset), 0); + } + + /* Mark some specially defined symbols as absolute. */ + if (strcmp (h->root.root.string, "_DYNAMIC") == 0 + || h == ia64_info->root.hgot + || h == ia64_info->root.hplt) + sym->st_shndx = SHN_ABS; + + return TRUE; +} + +static bfd_boolean +elf64_ia64_finish_dynamic_sections (bfd *abfd, + struct bfd_link_info *info) +{ + struct elf64_ia64_link_hash_table *ia64_info; + bfd *dynobj; + + ia64_info = elf64_ia64_hash_table (info); + if (ia64_info == NULL) + return FALSE; + + dynobj = ia64_info->root.dynobj; + + if (elf_hash_table (info)->dynamic_sections_created) + { + Elf64_External_Dyn *dyncon, *dynconend; + asection *sdyn; + asection *unwind_sec; + bfd_vma gp_val; + unsigned int gp_seg; + bfd_vma gp_off; + Elf_Internal_Phdr *phdr; + Elf_Internal_Phdr *base_phdr; + unsigned int unwind_seg = 0; + unsigned int code_seg = 0; + + sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); + BFD_ASSERT (sdyn != NULL); + dyncon = (Elf64_External_Dyn *) sdyn->contents; + dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size); + + gp_val = _bfd_get_gp_value (abfd); + phdr = _bfd_elf_find_segment_containing_section + (info->output_bfd, ia64_info->pltoff_sec->output_section); + BFD_ASSERT (phdr != NULL); + base_phdr = elf_tdata (info->output_bfd)->phdr; + gp_seg = phdr - base_phdr; + gp_off = gp_val - phdr->p_vaddr; + + unwind_sec = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind); + if (unwind_sec != NULL) + { + asection *code_sec; + + phdr = _bfd_elf_find_segment_containing_section (abfd, unwind_sec); + BFD_ASSERT (phdr != NULL); + unwind_seg = phdr - base_phdr; + + code_sec = bfd_get_section_by_name (abfd, "$CODE$"); + phdr = _bfd_elf_find_segment_containing_section (abfd, code_sec); + BFD_ASSERT (phdr != NULL); + code_seg = phdr - base_phdr; + } + + for (; dyncon < dynconend; dyncon++) + { + Elf_Internal_Dyn dyn; + + bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn); + + switch (dyn.d_tag) + { + case DT_IA_64_VMS_FIXUP_RELA_OFF: + dyn.d_un.d_val += + (ia64_info->fixups_sec->output_section->vma + + ia64_info->fixups_sec->output_offset) + - (sdyn->output_section->vma + sdyn->output_offset); + break; + + case DT_IA_64_VMS_PLTGOT_OFFSET: + dyn.d_un.d_val = gp_off; + break; + + case DT_IA_64_VMS_PLTGOT_SEG: + dyn.d_un.d_val = gp_seg; + break; + + case DT_IA_64_VMS_UNWINDSZ: + if (unwind_sec == NULL) + { + dyn.d_tag = DT_NULL; + dyn.d_un.d_val = 0xdead; + } + else + dyn.d_un.d_val = unwind_sec->size; + break; + + case DT_IA_64_VMS_UNWIND_CODSEG: + dyn.d_un.d_val = code_seg; + break; + + case DT_IA_64_VMS_UNWIND_INFOSEG: + case DT_IA_64_VMS_UNWIND_SEG: + dyn.d_un.d_val = unwind_seg; + break; + + case DT_IA_64_VMS_UNWIND_OFFSET: + break; + + default: + /* No need to rewrite the entry. */ + continue; + } + + bfd_elf64_swap_dyn_out (abfd, &dyn, dyncon); + } + } + + /* Handle transfer addresses. */ + { + asection *tfr_sec = ia64_info->transfer_sec; + struct elf64_vms_transfer *tfr; + struct elf_link_hash_entry *tfr3; + + tfr = (struct elf64_vms_transfer *)tfr_sec->contents; + bfd_putl32 (6 * 8, tfr->size); + bfd_putl64 (tfr_sec->output_section->vma + + tfr_sec->output_offset + + 6 * 8, tfr->tfradr3); + + tfr3 = elf_link_hash_lookup (elf_hash_table (info), "ELF$TFRADR", FALSE, + FALSE, FALSE); + + if (tfr3 + && (tfr3->root.type == bfd_link_hash_defined + || tfr3->root.type == bfd_link_hash_defweak)) + { + asection *tfr3_sec = tfr3->root.u.def.section; + bfd_vma tfr3_val; + + tfr3_val = (tfr3->root.u.def.value + + tfr3_sec->output_section->vma + + tfr3_sec->output_offset); + + bfd_putl64 (tfr3_val, tfr->tfr3_func); + bfd_putl64 (_bfd_get_gp_value (info->output_bfd), tfr->tfr3_gp); + } + + /* FIXME: set linker flags, + handle lib$initialize. */ + } + + return TRUE; +} + +/* ELF file flag handling: */ + +/* Function to keep IA-64 specific file flags. */ +static bfd_boolean +elf64_ia64_set_private_flags (bfd *abfd, flagword flags) +{ + BFD_ASSERT (!elf_flags_init (abfd) + || elf_elfheader (abfd)->e_flags == flags); + + elf_elfheader (abfd)->e_flags = flags; + elf_flags_init (abfd) = TRUE; + return TRUE; +} + +/* Merge backend specific data from an object file to the output + object file when linking. */ +static bfd_boolean +elf64_ia64_merge_private_bfd_data (bfd *ibfd, bfd *obfd) +{ + flagword out_flags; + flagword in_flags; + bfd_boolean ok = TRUE; + + /* Don't even pretend to support mixed-format linking. */ + if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour + || bfd_get_flavour (obfd) != bfd_target_elf_flavour) + return FALSE; + + in_flags = elf_elfheader (ibfd)->e_flags; + out_flags = elf_elfheader (obfd)->e_flags; + + if (! elf_flags_init (obfd)) + { + elf_flags_init (obfd) = TRUE; + elf_elfheader (obfd)->e_flags = in_flags; + + if (bfd_get_arch (obfd) == bfd_get_arch (ibfd) + && bfd_get_arch_info (obfd)->the_default) + { + return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), + bfd_get_mach (ibfd)); + } + + return TRUE; + } + + /* Check flag compatibility. */ + if (in_flags == out_flags) + return TRUE; + + /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */ + if (!(in_flags & EF_IA_64_REDUCEDFP) && (out_flags & EF_IA_64_REDUCEDFP)) + elf_elfheader (obfd)->e_flags &= ~EF_IA_64_REDUCEDFP; + + if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL)) + { + (*_bfd_error_handler) + (_("%B: linking trap-on-NULL-dereference with non-trapping files"), + ibfd); + + bfd_set_error (bfd_error_bad_value); + ok = FALSE; + } + if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE)) + { + (*_bfd_error_handler) + (_("%B: linking big-endian files with little-endian files"), + ibfd); + + bfd_set_error (bfd_error_bad_value); + ok = FALSE; + } + if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64)) + { + (*_bfd_error_handler) + (_("%B: linking 64-bit files with 32-bit files"), + ibfd); + + bfd_set_error (bfd_error_bad_value); + ok = FALSE; + } + if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP)) + { + (*_bfd_error_handler) + (_("%B: linking constant-gp files with non-constant-gp files"), + ibfd); + + bfd_set_error (bfd_error_bad_value); + ok = FALSE; + } + if ((in_flags & EF_IA_64_NOFUNCDESC_CONS_GP) + != (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP)) + { + (*_bfd_error_handler) + (_("%B: linking auto-pic files with non-auto-pic files"), + ibfd); + + bfd_set_error (bfd_error_bad_value); + ok = FALSE; + } + + return ok; +} + +static bfd_boolean +elf64_ia64_print_private_bfd_data (bfd *abfd, void * ptr) +{ + FILE *file = (FILE *) ptr; + flagword flags = elf_elfheader (abfd)->e_flags; + + BFD_ASSERT (abfd != NULL && ptr != NULL); + + fprintf (file, "private flags = %s%s%s%s%s%s%s%s\n", + (flags & EF_IA_64_TRAPNIL) ? "TRAPNIL, " : "", + (flags & EF_IA_64_EXT) ? "EXT, " : "", + (flags & EF_IA_64_BE) ? "BE, " : "LE, ", + (flags & EF_IA_64_REDUCEDFP) ? "REDUCEDFP, " : "", + (flags & EF_IA_64_CONS_GP) ? "CONS_GP, " : "", + (flags & EF_IA_64_NOFUNCDESC_CONS_GP) ? "NOFUNCDESC_CONS_GP, " : "", + (flags & EF_IA_64_ABSOLUTE) ? "ABSOLUTE, " : "", + (flags & EF_IA_64_ABI64) ? "ABI64" : "ABI32"); + + _bfd_elf_print_private_bfd_data (abfd, ptr); + return TRUE; +} + +static enum elf_reloc_type_class +elf64_ia64_reloc_type_class (const Elf_Internal_Rela *rela) +{ + switch ((int) ELF64_R_TYPE (rela->r_info)) + { + case R_IA64_REL32MSB: + case R_IA64_REL32LSB: + case R_IA64_REL64MSB: + case R_IA64_REL64LSB: + return reloc_class_relative; + case R_IA64_IPLTMSB: + case R_IA64_IPLTLSB: + return reloc_class_plt; + case R_IA64_COPY: + return reloc_class_copy; + default: + return reloc_class_normal; + } +} + +static const struct bfd_elf_special_section elf64_ia64_special_sections[] = +{ + { STRING_COMMA_LEN (".sbss"), -1, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT }, + { STRING_COMMA_LEN (".sdata"), -1, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT }, + { NULL, 0, 0, 0, 0 } +}; + +static bfd_boolean +elf64_ia64_object_p (bfd *abfd) +{ + asection *sec; + asection *group, *unwi, *unw; + flagword flags; + const char *name; + char *unwi_name, *unw_name; + bfd_size_type amt; + + if (abfd->flags & DYNAMIC) + return TRUE; + + /* Flags for fake group section. */ + flags = (SEC_LINKER_CREATED | SEC_GROUP | SEC_LINK_ONCE + | SEC_EXCLUDE); + + /* We add a fake section group for each .gnu.linkonce.t.* section, + which isn't in a section group, and its unwind sections. */ + for (sec = abfd->sections; sec != NULL; sec = sec->next) + { + if (elf_sec_group (sec) == NULL + && ((sec->flags & (SEC_LINK_ONCE | SEC_CODE | SEC_GROUP)) + == (SEC_LINK_ONCE | SEC_CODE)) + && CONST_STRNEQ (sec->name, ".gnu.linkonce.t.")) + { + name = sec->name + 16; + + amt = strlen (name) + sizeof (".gnu.linkonce.ia64unwi."); + unwi_name = bfd_alloc (abfd, amt); + if (!unwi_name) + return FALSE; + + strcpy (stpcpy (unwi_name, ".gnu.linkonce.ia64unwi."), name); + unwi = bfd_get_section_by_name (abfd, unwi_name); + + amt = strlen (name) + sizeof (".gnu.linkonce.ia64unw."); + unw_name = bfd_alloc (abfd, amt); + if (!unw_name) + return FALSE; + + strcpy (stpcpy (unw_name, ".gnu.linkonce.ia64unw."), name); + unw = bfd_get_section_by_name (abfd, unw_name); + + /* We need to create a fake group section for it and its + unwind sections. */ + group = bfd_make_section_anyway_with_flags (abfd, name, + flags); + if (group == NULL) + return FALSE; + + /* Move the fake group section to the beginning. */ + bfd_section_list_remove (abfd, group); + bfd_section_list_prepend (abfd, group); + + elf_next_in_group (group) = sec; + + elf_group_name (sec) = name; + elf_next_in_group (sec) = sec; + elf_sec_group (sec) = group; + + if (unwi) + { + elf_group_name (unwi) = name; + elf_next_in_group (unwi) = sec; + elf_next_in_group (sec) = unwi; + elf_sec_group (unwi) = group; + } + + if (unw) + { + elf_group_name (unw) = name; + if (unwi) + { + elf_next_in_group (unw) = elf_next_in_group (unwi); + elf_next_in_group (unwi) = unw; + } + else + { + elf_next_in_group (unw) = sec; + elf_next_in_group (sec) = unw; + } + elf_sec_group (unw) = group; + } + + /* Fake SHT_GROUP section header. */ + elf_section_data (group)->this_hdr.bfd_section = group; + elf_section_data (group)->this_hdr.sh_type = SHT_GROUP; + } + } + return TRUE; +} + +/* Handle an IA-64 specific section when reading an object file. This + is called when bfd_section_from_shdr finds a section with an unknown + type. */ + +static bfd_boolean +elf64_vms_section_from_shdr (bfd *abfd, + Elf_Internal_Shdr *hdr, + const char *name, + int shindex) +{ + flagword secflags = 0; + + switch (hdr->sh_type) + { + case SHT_IA_64_VMS_TRACE: + case SHT_IA_64_VMS_DEBUG: + case SHT_IA_64_VMS_DEBUG_STR: + secflags = SEC_DEBUGGING; + break; + + case SHT_IA_64_UNWIND: + case SHT_IA_64_HP_OPT_ANOT: + break; + + case SHT_IA_64_EXT: + if (strcmp (name, ELF_STRING_ia64_archext) != 0) + return FALSE; + break; + + default: + return FALSE; + } + + if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex)) + return FALSE; + + if (secflags != 0) + { + asection *newsect = hdr->bfd_section; + + if (! bfd_set_section_flags + (abfd, newsect, bfd_get_section_flags (abfd, newsect) | secflags)) + return FALSE; + } + + return TRUE; +} + +static bfd_boolean +elf64_vms_object_p (bfd *abfd) +{ + Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd); + Elf_Internal_Phdr *i_phdr = elf_tdata (abfd)->phdr; + unsigned int i; + unsigned int num_text = 0; + unsigned int num_data = 0; + unsigned int num_rodata = 0; + char name[16]; + + if (!elf64_ia64_object_p (abfd)) + return FALSE; + + /* Many VMS compilers do not generate sections for the corresponding + segment. This is boring as binutils tools won't be able to disassemble + the code. So we simply create all the missing sections. */ + for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++) + { + /* Is there a section for this segment? */ + bfd_vma base_vma = i_phdr->p_vaddr; + bfd_vma limit_vma = base_vma + i_phdr->p_filesz; + + if (i_phdr->p_type != PT_LOAD) + continue; + + /* We need to cover from base_vms to limit_vma. */ + again: + while (base_vma < limit_vma) + { + bfd_vma next_vma = limit_vma; + asection *nsec; + asection *sec; + flagword flags; + char *nname = NULL; + + /* Find a section covering [base_vma;limit_vma) */ + for (sec = abfd->sections; sec != NULL; sec = sec->next) + { + /* Skip uninteresting sections (either not in memory or + below base_vma. */ + if ((sec->flags & (SEC_ALLOC | SEC_LOAD)) == 0 + || sec->vma + sec->size <= base_vma) + continue; + if (sec->vma <= base_vma) + { + /* This section covers (maybe partially) the beginning + of the range. */ + base_vma = sec->vma + sec->size; + goto again; + } + if (sec->vma < next_vma) + { + /* This section partially covers the end of the range. + Used to compute the size of the hole. */ + next_vma = sec->vma; + } + } + + /* No section covering [base_vma; next_vma). Create a fake one. */ + flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS; + if (i_phdr->p_flags & PF_X) + { + flags |= SEC_CODE; + if (num_text++ == 0) + nname = ".text"; + else + sprintf (name, ".text$%u", num_text); + } + else if ((i_phdr->p_flags & (PF_R | PF_W)) == PF_R) + { + flags |= SEC_READONLY; + sprintf (name, ".rodata$%u", num_rodata++); + } + else + { + flags |= SEC_DATA; + sprintf (name, ".data$%u", num_data++); + } + + /* Allocate name. */ + if (nname == NULL) + { + size_t name_len = strlen (name) + 1; + nname = bfd_alloc (abfd, name_len); + if (nname == NULL) + return FALSE; + memcpy (nname, name, name_len); + } + + /* Create and fill new section. */ + nsec = bfd_make_section_anyway_with_flags (abfd, nname, flags); + if (nsec == NULL) + return FALSE; + nsec->vma = base_vma; + nsec->size = next_vma - base_vma; + nsec->filepos = i_phdr->p_offset + (base_vma - i_phdr->p_vaddr); + + base_vma = next_vma; + } + } + return TRUE; +} + +static void +elf64_vms_post_process_headers (bfd *abfd, + struct bfd_link_info *info ATTRIBUTE_UNUSED) +{ + Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd); + + i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_OPENVMS; + i_ehdrp->e_ident[EI_ABIVERSION] = 2; +} + +static bfd_boolean +elf64_vms_section_processing (bfd *abfd ATTRIBUTE_UNUSED, + Elf_Internal_Shdr *hdr) +{ + if (hdr->bfd_section != NULL) + { + const char *name = bfd_get_section_name (abfd, hdr->bfd_section); + + if (strcmp (name, ".text") == 0) + hdr->sh_flags |= SHF_IA_64_VMS_SHARED; + else if ((strcmp (name, ".debug") == 0) + || (strcmp (name, ".debug_abbrev") == 0) + || (strcmp (name, ".debug_aranges") == 0) + || (strcmp (name, ".debug_frame") == 0) + || (strcmp (name, ".debug_info") == 0) + || (strcmp (name, ".debug_loc") == 0) + || (strcmp (name, ".debug_macinfo") == 0) + || (strcmp (name, ".debug_pubnames") == 0) + || (strcmp (name, ".debug_pubtypes") == 0)) + hdr->sh_type = SHT_IA_64_VMS_DEBUG; + else if ((strcmp (name, ".debug_line") == 0) + || (strcmp (name, ".debug_ranges") == 0) + || (strcmp (name, ".trace_info") == 0) + || (strcmp (name, ".trace_abbrev") == 0) + || (strcmp (name, ".trace_aranges") == 0)) + hdr->sh_type = SHT_IA_64_VMS_TRACE; + else if (strcmp (name, ".debug_str") == 0) + hdr->sh_type = SHT_IA_64_VMS_DEBUG_STR; + } + + return TRUE; +} + +/* The final processing done just before writing out a VMS IA-64 ELF + object file. */ + +static void +elf64_vms_final_write_processing (bfd *abfd, + bfd_boolean linker ATTRIBUTE_UNUSED) +{ + Elf_Internal_Shdr *hdr; + asection *s; + int unwind_info_sect_idx = 0; + + for (s = abfd->sections; s; s = s->next) + { + hdr = &elf_section_data (s)->this_hdr; + + if (strcmp (bfd_get_section_name (abfd, hdr->bfd_section), + ".IA_64.unwind_info") == 0) + unwind_info_sect_idx = elf_section_data (s)->this_idx; + + switch (hdr->sh_type) + { + case SHT_IA_64_UNWIND: + /* VMS requires sh_info to point to the unwind info section. */ + hdr->sh_info = unwind_info_sect_idx; + break; + } + } + + if (! elf_flags_init (abfd)) + { + unsigned long flags = 0; + + if (abfd->xvec->byteorder == BFD_ENDIAN_BIG) + flags |= EF_IA_64_BE; + if (bfd_get_mach (abfd) == bfd_mach_ia64_elf64) + flags |= EF_IA_64_ABI64; + + elf_elfheader (abfd)->e_flags = flags; + elf_flags_init (abfd) = TRUE; + } +} + +static bfd_boolean +elf64_vms_write_shdrs_and_ehdr (bfd *abfd) +{ + unsigned char needed_count[8]; + + if (!bfd_elf64_write_shdrs_and_ehdr (abfd)) + return FALSE; + + bfd_putl64 (elf_ia64_vms_tdata (abfd)->needed_count, needed_count); + + if (bfd_seek (abfd, sizeof (Elf64_External_Ehdr), SEEK_SET) != 0 + || bfd_bwrite (needed_count, 8, abfd) != 8) + return FALSE; + + return TRUE; +} + +static bfd_boolean +elf64_vms_close_and_cleanup (bfd *abfd) +{ + if (bfd_get_format (abfd) == bfd_object) + { + long isize; + + /* Pad to 8 byte boundary for IPF/VMS. */ + isize = bfd_get_size (abfd); + if ((isize & 7) != 0) + { + int ishort = 8 - (isize & 7); + bfd_uint64_t pad = 0; + + bfd_seek (abfd, isize, SEEK_SET); + bfd_bwrite (&pad, ishort, abfd); + } + } + + return _bfd_elf_close_and_cleanup (abfd); +} + +/* Add symbols from an ELF object file to the linker hash table. */ + +static bfd_boolean +elf64_vms_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info) +{ + Elf_Internal_Shdr *hdr; + bfd_size_type symcount; + bfd_size_type extsymcount; + bfd_size_type extsymoff; + struct elf_link_hash_entry **sym_hash; + bfd_boolean dynamic; + Elf_Internal_Sym *isymbuf = NULL; + Elf_Internal_Sym *isym; + Elf_Internal_Sym *isymend; + const struct elf_backend_data *bed; + struct elf_link_hash_table *htab; + bfd_size_type amt; + + htab = elf_hash_table (info); + bed = get_elf_backend_data (abfd); + + if ((abfd->flags & DYNAMIC) == 0) + dynamic = FALSE; + else + { + dynamic = TRUE; + + /* You can't use -r against a dynamic object. Also, there's no + hope of using a dynamic object which does not exactly match + the format of the output file. */ + if (info->relocatable + || !is_elf_hash_table (htab) + || info->output_bfd->xvec != abfd->xvec) + { + if (info->relocatable) + bfd_set_error (bfd_error_invalid_operation); + else + bfd_set_error (bfd_error_wrong_format); + goto error_return; + } + } + + if (! dynamic) + { + /* If we are creating a shared library, create all the dynamic + sections immediately. We need to attach them to something, + so we attach them to this BFD, provided it is the right + format. FIXME: If there are no input BFD's of the same + format as the output, we can't make a shared library. */ + if (info->shared + && is_elf_hash_table (htab) + && info->output_bfd->xvec == abfd->xvec + && !htab->dynamic_sections_created) + { + if (! elf64_ia64_create_dynamic_sections (abfd, info)) + goto error_return; + } + } + else if (!is_elf_hash_table (htab)) + goto error_return; + else + { + asection *s; + bfd_byte *dynbuf; + bfd_byte *extdyn; + + /* ld --just-symbols and dynamic objects don't mix very well. + ld shouldn't allow it. */ + if ((s = abfd->sections) != NULL + && s->sec_info_type == ELF_INFO_TYPE_JUST_SYMS) + abort (); + + /* Be sure there are dynamic sections. */ + if (! elf64_ia64_create_dynamic_sections (htab->dynobj, info)) + goto error_return; + + s = bfd_get_section_by_name (abfd, ".dynamic"); + if (s == NULL) + { + /* VMS libraries do not have dynamic sections. Create one from + the segment. */ + Elf_Internal_Phdr *phdr; + unsigned int i, phnum; + + phdr = elf_tdata (abfd)->phdr; + if (phdr == NULL) + goto error_return; + phnum = elf_elfheader (abfd)->e_phnum; + for (i = 0; i < phnum; phdr++) + if (phdr->p_type == PT_DYNAMIC) + { + s = bfd_make_section (abfd, ".dynamic"); + if (s == NULL) + goto error_return; + s->vma = phdr->p_vaddr; + s->lma = phdr->p_paddr; + s->size = phdr->p_filesz; + s->filepos = phdr->p_offset; + s->flags |= SEC_HAS_CONTENTS; + s->alignment_power = bfd_log2 (phdr->p_align); + break; + } + if (s == NULL) + goto error_return; + } + + /* Extract IDENT. */ + if (!bfd_malloc_and_get_section (abfd, s, &dynbuf)) + { +error_free_dyn: + free (dynbuf); + goto error_return; + } + + for (extdyn = dynbuf; + extdyn < dynbuf + s->size; + extdyn += bed->s->sizeof_dyn) + { + Elf_Internal_Dyn dyn; + + bed->s->swap_dyn_in (abfd, extdyn, &dyn); + if (dyn.d_tag == DT_IA_64_VMS_IDENT) + { + bfd_uint64_t tagv = dyn.d_un.d_val; + elf_ia64_vms_ident (abfd) = tagv; + break; + } + } + if (extdyn >= dynbuf + s->size) + { + /* Ident not found. */ + goto error_free_dyn; + } + free (dynbuf); + + /* We do not want to include any of the sections in a dynamic + object in the output file. We hack by simply clobbering the + list of sections in the BFD. This could be handled more + cleanly by, say, a new section flag; the existing + SEC_NEVER_LOAD flag is not the one we want, because that one + still implies that the section takes up space in the output + file. */ + bfd_section_list_clear (abfd); + + /* FIXME: should we detect if this library is already included ? + This should be harmless and shouldn't happen in practice. */ + } + + hdr = &elf_tdata (abfd)->symtab_hdr; + symcount = hdr->sh_size / bed->s->sizeof_sym; + + /* The sh_info field of the symtab header tells us where the + external symbols start. We don't care about the local symbols at + this point. */ + extsymcount = symcount - hdr->sh_info; + extsymoff = hdr->sh_info; + + sym_hash = NULL; + if (extsymcount != 0) + { + isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff, + NULL, NULL, NULL); + if (isymbuf == NULL) + goto error_return; + + /* We store a pointer to the hash table entry for each external + symbol. */ + amt = extsymcount * sizeof (struct elf_link_hash_entry *); + sym_hash = (struct elf_link_hash_entry **) bfd_alloc (abfd, amt); + if (sym_hash == NULL) + goto error_free_sym; + elf_sym_hashes (abfd) = sym_hash; + } + + for (isym = isymbuf, isymend = isymbuf + extsymcount; + isym < isymend; + isym++, sym_hash++) + { + int bind; + bfd_vma value; + asection *sec, *new_sec; + flagword flags; + const char *name; + struct elf_link_hash_entry *h; + bfd_boolean definition; + bfd_boolean size_change_ok; + bfd_boolean type_change_ok; + bfd_boolean common; + unsigned int old_alignment; + bfd *old_bfd; + + flags = BSF_NO_FLAGS; + sec = NULL; + value = isym->st_value; + *sym_hash = NULL; + common = bed->common_definition (isym); + + bind = ELF_ST_BIND (isym->st_info); + switch (bind) + { + case STB_LOCAL: + /* This should be impossible, since ELF requires that all + global symbols follow all local symbols, and that sh_info + point to the first global symbol. Unfortunately, Irix 5 + screws this up. */ + continue; + + case STB_GLOBAL: + if (isym->st_shndx != SHN_UNDEF && !common) + flags = BSF_GLOBAL; + break; + + case STB_WEAK: + flags = BSF_WEAK; + break; + + case STB_GNU_UNIQUE: + flags = BSF_GNU_UNIQUE; + break; + + default: + /* Leave it up to the processor backend. */ + break; + } + + if (isym->st_shndx == SHN_UNDEF) + sec = bfd_und_section_ptr; + else if (isym->st_shndx == SHN_ABS) + sec = bfd_abs_section_ptr; + else if (isym->st_shndx == SHN_COMMON) + { + sec = bfd_com_section_ptr; + /* What ELF calls the size we call the value. What ELF + calls the value we call the alignment. */ + value = isym->st_size; + } + else + { + sec = bfd_section_from_elf_index (abfd, isym->st_shndx); + if (sec == NULL) + sec = bfd_abs_section_ptr; + else if (sec->kept_section) + { + /* Symbols from discarded section are undefined. We keep + its visibility. */ + sec = bfd_und_section_ptr; + isym->st_shndx = SHN_UNDEF; + } + else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0) + value -= sec->vma; + } + + name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link, + isym->st_name); + if (name == NULL) + goto error_free_vers; + + if (bed->elf_add_symbol_hook) + { + if (! (*bed->elf_add_symbol_hook) (abfd, info, isym, &name, &flags, + &sec, &value)) + goto error_free_vers; + + /* The hook function sets the name to NULL if this symbol + should be skipped for some reason. */ + if (name == NULL) + continue; + } + + /* Sanity check that all possibilities were handled. */ + if (sec == NULL) + { + bfd_set_error (bfd_error_bad_value); + goto error_free_vers; + } + + if (bfd_is_und_section (sec) + || bfd_is_com_section (sec)) + definition = FALSE; + else + definition = TRUE; + + size_change_ok = FALSE; + type_change_ok = bed->type_change_ok; + old_alignment = 0; + old_bfd = NULL; + new_sec = sec; + + if (! bfd_is_und_section (sec)) + h = elf_link_hash_lookup (htab, name, TRUE, FALSE, FALSE); + else + h = ((struct elf_link_hash_entry *) bfd_wrapped_link_hash_lookup + (abfd, info, name, TRUE, FALSE, FALSE)); + if (h == NULL) + goto error_free_sym; + + *sym_hash = h; + + if (is_elf_hash_table (htab)) + { + while (h->root.type == bfd_link_hash_indirect + || h->root.type == bfd_link_hash_warning) + h = (struct elf_link_hash_entry *) h->root.u.i.link; + + /* Remember the old alignment if this is a common symbol, so + that we don't reduce the alignment later on. We can't + check later, because _bfd_generic_link_add_one_symbol + will set a default for the alignment which we want to + override. We also remember the old bfd where the existing + definition comes from. */ + switch (h->root.type) + { + default: + break; + + case bfd_link_hash_defined: + if (abfd->selective_search) + continue; + /* Fall-through. */ + case bfd_link_hash_defweak: + old_bfd = h->root.u.def.section->owner; + break; + + case bfd_link_hash_common: + old_bfd = h->root.u.c.p->section->owner; + old_alignment = h->root.u.c.p->alignment_power; + break; + } + } + + if (! (_bfd_generic_link_add_one_symbol + (info, abfd, name, flags, sec, value, NULL, FALSE, bed->collect, + (struct bfd_link_hash_entry **) sym_hash))) + goto error_free_vers; + + h = *sym_hash; + while (h->root.type == bfd_link_hash_indirect + || h->root.type == bfd_link_hash_warning) + h = (struct elf_link_hash_entry *) h->root.u.i.link; + + *sym_hash = h; + h->unique_global = (flags & BSF_GNU_UNIQUE) != 0; + + /* Set the alignment of a common symbol. */ + if ((common || bfd_is_com_section (sec)) + && h->root.type == bfd_link_hash_common) + { + unsigned int align; + + if (common) + align = bfd_log2 (isym->st_value); + else + { + /* The new symbol is a common symbol in a shared object. + We need to get the alignment from the section. */ + align = new_sec->alignment_power; + } + if (align > old_alignment + /* Permit an alignment power of zero if an alignment of one + is specified and no other alignments have been specified. */ + || (isym->st_value == 1 && old_alignment == 0)) + h->root.u.c.p->alignment_power = align; + else + h->root.u.c.p->alignment_power = old_alignment; + } + + if (is_elf_hash_table (htab)) + { + /* Check the alignment when a common symbol is involved. This + can change when a common symbol is overridden by a normal + definition or a common symbol is ignored due to the old + normal definition. We need to make sure the maximum + alignment is maintained. */ + if ((old_alignment || common) + && h->root.type != bfd_link_hash_common) + { + unsigned int common_align; + unsigned int normal_align; + unsigned int symbol_align; + bfd *normal_bfd; + bfd *common_bfd; + + symbol_align = ffs (h->root.u.def.value) - 1; + if (h->root.u.def.section->owner != NULL + && (h->root.u.def.section->owner->flags & DYNAMIC) == 0) + { + normal_align = h->root.u.def.section->alignment_power; + if (normal_align > symbol_align) + normal_align = symbol_align; + } + else + normal_align = symbol_align; + + if (old_alignment) + { + common_align = old_alignment; + common_bfd = old_bfd; + normal_bfd = abfd; + } + else + { + common_align = bfd_log2 (isym->st_value); + common_bfd = abfd; + normal_bfd = old_bfd; + } + + if (normal_align < common_align) + { + /* PR binutils/2735 */ + if (normal_bfd == NULL) + (*_bfd_error_handler) + (_("Warning: alignment %u of common symbol `%s' in %B" + " is greater than the alignment (%u) of its section %A"), + common_bfd, h->root.u.def.section, + 1 << common_align, name, 1 << normal_align); + else + (*_bfd_error_handler) + (_("Warning: alignment %u of symbol `%s' in %B" + " is smaller than %u in %B"), + normal_bfd, common_bfd, + 1 << normal_align, name, 1 << common_align); + } + } + + /* Remember the symbol size if it isn't undefined. */ + if ((isym->st_size != 0 && isym->st_shndx != SHN_UNDEF) + && (definition || h->size == 0)) + { + if (h->size != 0 + && h->size != isym->st_size + && ! size_change_ok) + (*_bfd_error_handler) + (_("Warning: size of symbol `%s' changed" + " from %lu in %B to %lu in %B"), + old_bfd, abfd, + name, (unsigned long) h->size, + (unsigned long) isym->st_size); + + h->size = isym->st_size; + } + + /* If this is a common symbol, then we always want H->SIZE + to be the size of the common symbol. The code just above + won't fix the size if a common symbol becomes larger. We + don't warn about a size change here, because that is + covered by --warn-common. Allow changed between different + function types. */ + if (h->root.type == bfd_link_hash_common) + h->size = h->root.u.c.size; + + if (ELF_ST_TYPE (isym->st_info) != STT_NOTYPE + && (definition || h->type == STT_NOTYPE)) + { + unsigned int type = ELF_ST_TYPE (isym->st_info); + + if (h->type != type) + { + if (h->type != STT_NOTYPE && ! type_change_ok) + (*_bfd_error_handler) + (_("Warning: type of symbol `%s' changed" + " from %d to %d in %B"), + abfd, name, h->type, type); + + h->type = type; + } + } + + /* Set a flag in the hash table entry indicating the type of + reference or definition we just found. Keep a count of + the number of dynamic symbols we find. A dynamic symbol + is one which is referenced or defined by both a regular + object and a shared object. */ + if (! dynamic) + { + if (! definition) + { + h->ref_regular = 1; + if (bind != STB_WEAK) + h->ref_regular_nonweak = 1; + } + else + { + BFD_ASSERT (!h->def_dynamic); + h->def_regular = 1; + } + } + else + { + BFD_ASSERT (definition); + h->def_dynamic = 1; + h->dynindx = -2; + ((struct elf64_ia64_link_hash_entry *)h)->shl = abfd; + } + } + } + + if (isymbuf != NULL) + { + free (isymbuf); + isymbuf = NULL; + } + + /* If this object is the same format as the output object, and it is + not a shared library, then let the backend look through the + relocs. + + This is required to build global offset table entries and to + arrange for dynamic relocs. It is not required for the + particular common case of linking non PIC code, even when linking + against shared libraries, but unfortunately there is no way of + knowing whether an object file has been compiled PIC or not. + Looking through the relocs is not particularly time consuming. + The problem is that we must either (1) keep the relocs in memory, + which causes the linker to require additional runtime memory or + (2) read the relocs twice from the input file, which wastes time. + This would be a good case for using mmap. + + I have no idea how to handle linking PIC code into a file of a + different format. It probably can't be done. */ + if (! dynamic + && is_elf_hash_table (htab) + && bed->check_relocs != NULL + && (*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec)) + { + asection *o; + + for (o = abfd->sections; o != NULL; o = o->next) + { + Elf_Internal_Rela *internal_relocs; + bfd_boolean ok; + + if ((o->flags & SEC_RELOC) == 0 + || o->reloc_count == 0 + || ((info->strip == strip_all || info->strip == strip_debugger) + && (o->flags & SEC_DEBUGGING) != 0) + || bfd_is_abs_section (o->output_section)) + continue; + + internal_relocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL, + info->keep_memory); + if (internal_relocs == NULL) + goto error_return; + + ok = (*bed->check_relocs) (abfd, info, o, internal_relocs); + + if (elf_section_data (o)->relocs != internal_relocs) + free (internal_relocs); + + if (! ok) + goto error_return; + } + } + + return TRUE; + + error_free_vers: + error_free_sym: + if (isymbuf != NULL) + free (isymbuf); + error_return: + return FALSE; +} + +static bfd_boolean +elf64_vms_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info) +{ + int pass; + struct bfd_link_hash_entry **pundef; + struct bfd_link_hash_entry **next_pundef; + + /* We only accept VMS libraries. */ + if (info->output_bfd->xvec != abfd->xvec) + { + bfd_set_error (bfd_error_wrong_format); + return FALSE; + } + + /* The archive_pass field in the archive itself is used to + initialize PASS, since we may search the same archive multiple + times. */ + pass = ++abfd->archive_pass; + + /* Look through the list of undefined symbols. */ + for (pundef = &info->hash->undefs; *pundef != NULL; pundef = next_pundef) + { + struct bfd_link_hash_entry *h; + symindex symidx; + bfd *element; + bfd *orig_element; + + h = *pundef; + next_pundef = &(*pundef)->u.undef.next; + + /* When a symbol is defined, it is not necessarily removed from + the list. */ + if (h->type != bfd_link_hash_undefined + && h->type != bfd_link_hash_common) + { + /* Remove this entry from the list, for general cleanliness + and because we are going to look through the list again + if we search any more libraries. We can't remove the + entry if it is the tail, because that would lose any + entries we add to the list later on. */ + if (*pundef != info->hash->undefs_tail) + { + *pundef = *next_pundef; + next_pundef = pundef; + } + continue; + } + + /* Look for this symbol in the archive hash table. */ + symidx = _bfd_vms_lib_find_symbol (abfd, h->root.string); + if (symidx == BFD_NO_MORE_SYMBOLS) + { + /* Nothing in this slot. */ + continue; + } + + element = bfd_get_elt_at_index (abfd, symidx); + if (element == NULL) + return FALSE; + + if (element->archive_pass == -1 || element->archive_pass == pass) + { + /* Next symbol if this archive is wrong or already handled. */ + continue; + } + + orig_element = element; + if (bfd_is_thin_archive (abfd)) + { + element = _bfd_vms_lib_get_imagelib_file (element); + if (element == NULL || !bfd_check_format (element, bfd_object)) + { + orig_element->archive_pass = -1; + return FALSE; + } + } + else if (! bfd_check_format (element, bfd_object)) + { + element->archive_pass = -1; + return FALSE; + } + + /* Unlike the generic linker, we know that this element provides + a definition for an undefined symbol and we know that we want + to include it. We don't need to check anything. */ + if (! (*info->callbacks->add_archive_element) (info, element, + h->root.string, &element)) + return FALSE; + if (! elf64_vms_link_add_object_symbols (element, info)) + return FALSE; + + orig_element->archive_pass = pass; + } + + return TRUE; +} + +static bfd_boolean +elf64_vms_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info) +{ + switch (bfd_get_format (abfd)) + { + case bfd_object: + return elf64_vms_link_add_object_symbols (abfd, info); + break; + case bfd_archive: + return elf64_vms_link_add_archive_symbols (abfd, info); + break; + default: + bfd_set_error (bfd_error_wrong_format); + return FALSE; + } +} + +static bfd_boolean +elf64_ia64_vms_mkobject (bfd *abfd) +{ + return bfd_elf_allocate_object + (abfd, sizeof (struct elf64_ia64_vms_obj_tdata), IA64_ELF_DATA); +} + + +/* Size-dependent data and functions. */ +static const struct elf_size_info elf64_ia64_vms_size_info = { + sizeof (Elf64_External_VMS_Ehdr), + sizeof (Elf64_External_Phdr), + sizeof (Elf64_External_Shdr), + sizeof (Elf64_External_Rel), + sizeof (Elf64_External_Rela), + sizeof (Elf64_External_Sym), + sizeof (Elf64_External_Dyn), + sizeof (Elf_External_Note), + 4, + 1, + 64, 3, /* ARCH_SIZE, LOG_FILE_ALIGN */ + ELFCLASS64, EV_CURRENT, + bfd_elf64_write_out_phdrs, + elf64_vms_write_shdrs_and_ehdr, + bfd_elf64_checksum_contents, + bfd_elf64_write_relocs, + bfd_elf64_swap_symbol_in, + bfd_elf64_swap_symbol_out, + bfd_elf64_slurp_reloc_table, + bfd_elf64_slurp_symbol_table, + bfd_elf64_swap_dyn_in, + bfd_elf64_swap_dyn_out, + bfd_elf64_swap_reloc_in, + bfd_elf64_swap_reloc_out, + bfd_elf64_swap_reloca_in, + bfd_elf64_swap_reloca_out +}; + +#define ELF_ARCH bfd_arch_ia64 +#define ELF_MACHINE_CODE EM_IA_64 +#define ELF_MAXPAGESIZE 0x10000 /* 64KB */ +#define ELF_COMMONPAGESIZE 0x200 /* 16KB */ + +#define elf_backend_section_from_shdr \ + elf64_ia64_section_from_shdr +#define elf_backend_section_flags \ + elf64_ia64_section_flags +#define elf_backend_fake_sections \ + elf64_ia64_fake_sections +#define elf_backend_final_write_processing \ + elf64_ia64_final_write_processing +#define elf_backend_add_symbol_hook \ + elf64_ia64_add_symbol_hook +#define elf_info_to_howto \ + elf64_ia64_info_to_howto + +#define bfd_elf64_bfd_reloc_type_lookup \ + ia64_elf_reloc_type_lookup +#define bfd_elf64_bfd_reloc_name_lookup \ + ia64_elf_reloc_name_lookup +#define bfd_elf64_bfd_is_local_label_name \ + elf64_ia64_is_local_label_name +#define bfd_elf64_bfd_relax_section \ + elf64_ia64_relax_section + +#define elf_backend_object_p \ + elf64_ia64_object_p + +/* Stuff for the BFD linker: */ +#define bfd_elf64_bfd_link_hash_table_create \ + elf64_ia64_hash_table_create +#define bfd_elf64_bfd_link_hash_table_free \ + elf64_ia64_hash_table_free +#define elf_backend_create_dynamic_sections \ + elf64_ia64_create_dynamic_sections +#define elf_backend_check_relocs \ + elf64_ia64_check_relocs +#define elf_backend_adjust_dynamic_symbol \ + elf64_ia64_adjust_dynamic_symbol +#define elf_backend_size_dynamic_sections \ + elf64_ia64_size_dynamic_sections +#define elf_backend_omit_section_dynsym \ + ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true) +#define elf_backend_relocate_section \ + elf64_ia64_relocate_section +#define elf_backend_finish_dynamic_symbol \ + elf64_ia64_finish_dynamic_symbol +#define elf_backend_finish_dynamic_sections \ + elf64_ia64_finish_dynamic_sections +#define bfd_elf64_bfd_final_link \ + elf64_ia64_final_link + +#define bfd_elf64_bfd_merge_private_bfd_data \ + elf64_ia64_merge_private_bfd_data +#define bfd_elf64_bfd_set_private_flags \ + elf64_ia64_set_private_flags +#define bfd_elf64_bfd_print_private_bfd_data \ + elf64_ia64_print_private_bfd_data + +#define elf_backend_plt_readonly 1 +#define elf_backend_want_plt_sym 0 +#define elf_backend_plt_alignment 5 +#define elf_backend_got_header_size 0 +#define elf_backend_want_got_plt 1 +#define elf_backend_may_use_rel_p 1 +#define elf_backend_may_use_rela_p 1 +#define elf_backend_default_use_rela_p 1 +#define elf_backend_want_dynbss 0 +#define elf_backend_hide_symbol elf64_ia64_hash_hide_symbol +#define elf_backend_fixup_symbol _bfd_elf_link_hash_fixup_symbol +#define elf_backend_reloc_type_class elf64_ia64_reloc_type_class +#define elf_backend_rela_normal 1 +#define elf_backend_special_sections elf64_ia64_special_sections +#define elf_backend_default_execstack 0 + +/* FIXME: PR 290: The Intel C compiler generates SHT_IA_64_UNWIND with + SHF_LINK_ORDER. But it doesn't set the sh_link or sh_info fields. + We don't want to flood users with so many error messages. We turn + off the warning for now. It will be turned on later when the Intel + compiler is fixed. */ +#define elf_backend_link_order_error_handler NULL + +/* VMS-specific vectors. */ + +#undef TARGET_LITTLE_SYM +#define TARGET_LITTLE_SYM bfd_elf64_ia64_vms_vec +#undef TARGET_LITTLE_NAME +#define TARGET_LITTLE_NAME "elf64-ia64-vms" +#undef TARGET_BIG_SYM +#undef TARGET_BIG_NAME + +/* These are VMS specific functions. */ + +#undef elf_backend_object_p +#define elf_backend_object_p elf64_vms_object_p + +#undef elf_backend_section_from_shdr +#define elf_backend_section_from_shdr elf64_vms_section_from_shdr + +#undef elf_backend_post_process_headers +#define elf_backend_post_process_headers elf64_vms_post_process_headers + +#undef elf_backend_section_processing +#define elf_backend_section_processing elf64_vms_section_processing + +#undef elf_backend_final_write_processing +#define elf_backend_final_write_processing elf64_vms_final_write_processing + +#undef bfd_elf64_close_and_cleanup +#define bfd_elf64_close_and_cleanup elf64_vms_close_and_cleanup + +#undef elf_backend_section_from_bfd_section + +#undef elf_backend_symbol_processing + +#undef elf_backend_want_p_paddr_set_to_zero + +#undef ELF_OSABI +#define ELF_OSABI ELFOSABI_OPENVMS + +#undef ELF_MAXPAGESIZE +#define ELF_MAXPAGESIZE 0x10000 /* 64KB */ + +#undef elf64_bed +#define elf64_bed elf64_ia64_vms_bed + +#define elf_backend_size_info elf64_ia64_vms_size_info + +/* Use VMS-style archives (in particular, don't use the standard coff + archive format). */ +#define bfd_elf64_archive_functions + +#undef bfd_elf64_archive_p +#define bfd_elf64_archive_p _bfd_vms_lib_ia64_archive_p +#undef bfd_elf64_write_archive_contents +#define bfd_elf64_write_archive_contents _bfd_vms_lib_write_archive_contents +#undef bfd_elf64_mkarchive +#define bfd_elf64_mkarchive _bfd_vms_lib_ia64_mkarchive + +#define bfd_elf64_archive_slurp_armap \ + _bfd_vms_lib_slurp_armap +#define bfd_elf64_archive_slurp_extended_name_table \ + _bfd_vms_lib_slurp_extended_name_table +#define bfd_elf64_archive_construct_extended_name_table \ + _bfd_vms_lib_construct_extended_name_table +#define bfd_elf64_archive_truncate_arname \ + _bfd_vms_lib_truncate_arname +#define bfd_elf64_archive_write_armap \ + _bfd_vms_lib_write_armap +#define bfd_elf64_archive_read_ar_hdr \ + _bfd_vms_lib_read_ar_hdr +#define bfd_elf64_archive_write_ar_hdr \ + _bfd_vms_lib_write_ar_hdr +#define bfd_elf64_archive_openr_next_archived_file \ + _bfd_vms_lib_openr_next_archived_file +#define bfd_elf64_archive_get_elt_at_index \ + _bfd_vms_lib_get_elt_at_index +#define bfd_elf64_archive_generic_stat_arch_elt \ + _bfd_vms_lib_generic_stat_arch_elt +#define bfd_elf64_archive_update_armap_timestamp \ + _bfd_vms_lib_update_armap_timestamp + +/* VMS link methods. */ +#undef bfd_elf64_bfd_link_add_symbols +#define bfd_elf64_bfd_link_add_symbols elf64_vms_bfd_link_add_symbols + +#undef elf_backend_want_got_sym +#define elf_backend_want_got_sym 0 + +#undef bfd_elf64_mkobject +#define bfd_elf64_mkobject elf64_ia64_vms_mkobject + +/* Redefine to align segments on block size. */ +#undef ELF_MAXPAGESIZE +#define ELF_MAXPAGESIZE 0x200 /* 512B */ + +#undef elf_backend_want_got_plt +#define elf_backend_want_got_plt 0 + +#include "elf64-target.h" diff --git a/bfd/elflink.c b/bfd/elflink.c index 12025a3b053..0ed52081999 100644 --- a/bfd/elflink.c +++ b/bfd/elflink.c @@ -8908,7 +8908,8 @@ elf_link_output_extsym (struct bfd_hash_entry *bh, void *data) /* If this symbol should be put in the .dynsym section, then put it there now. We already know the symbol index. We also fill in the entry in the .hash section. */ - if (h->dynindx != -1 + if (finfo->dynsym_sec != NULL + && h->dynindx != -1 && elf_hash_table (finfo->info)->dynamic_sections_created) { bfd_byte *esym; @@ -10305,7 +10306,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info) { finfo.dynsym_sec = bfd_get_section_by_name (dynobj, ".dynsym"); finfo.hash_sec = bfd_get_section_by_name (dynobj, ".hash"); - BFD_ASSERT (finfo.dynsym_sec != NULL); + /* Note that dynsym_sec can be NULL (on VMS). */ finfo.symver_sec = bfd_get_section_by_name (dynobj, ".gnu.version"); /* Note that it is OK if symver_sec is NULL. */ } @@ -10825,6 +10826,7 @@ bfd_elf_final_link (bfd *abfd, struct bfd_link_info *info) symtab_hdr->sh_info = bfd_get_symcount (abfd); if (dynamic + && finfo.dynsym_sec != NULL && finfo.dynsym_sec->output_section != bfd_abs_section_ptr) { Elf_Internal_Sym sym; diff --git a/bfd/elfnn-ia64.c b/bfd/elfnn-ia64.c index d70b28e9d33..7ea2981e380 100644 --- a/bfd/elfnn-ia64.c +++ b/bfd/elfnn-ia64.c @@ -1,6 +1,6 @@ /* IA-64 support for 64-bit ELF Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, - 2008, 2009, 2010, 2011 Free Software Foundation, Inc. + 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc. Contributed by David Mosberger-Tang This file is part of BFD, the Binary File Descriptor library. @@ -41,14 +41,6 @@ #define LOG_SECTION_ALIGN 2 #endif -/* Only add code for vms when the vms target is enabled. This is required - because it depends on vms-lib.c for its archive format and we don't want - to compile that code if it is not used. */ -#if ARCH_SIZE == 64 && \ - (defined (HAVE_bfd_elf64_ia64_vms_vec) || defined (HAVE_all_vecs)) -#define INCLUDE_IA64_VMS -#endif - typedef struct bfd_hash_entry *(*new_hash_entry_func) (struct bfd_hash_entry *, struct bfd_hash_table *, const char *); @@ -4978,277 +4970,6 @@ elfNN_hpux_backend_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, break; } } - -#ifdef INCLUDE_IA64_VMS - -static bfd_boolean -elfNN_vms_section_from_shdr (bfd *abfd, - Elf_Internal_Shdr *hdr, - const char *name, - int shindex) -{ - switch (hdr->sh_type) - { - case SHT_IA_64_VMS_TRACE: - case SHT_IA_64_VMS_DEBUG: - case SHT_IA_64_VMS_DEBUG_STR: - break; - - default: - return elfNN_ia64_section_from_shdr (abfd, hdr, name, shindex); - } - - if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex)) - return FALSE; - - return TRUE; -} - -static bfd_boolean -elfNN_vms_object_p (bfd *abfd) -{ - Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd); - Elf_Internal_Phdr *i_phdr = elf_tdata (abfd)->phdr; - unsigned int i; - unsigned int num_text = 0; - unsigned int num_data = 0; - unsigned int num_rodata = 0; - char name[16]; - - if (!elfNN_ia64_object_p (abfd)) - return FALSE; - - for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++) - { - /* Is there a section for this segment? */ - bfd_vma base_vma = i_phdr->p_vaddr; - bfd_vma limit_vma = base_vma + i_phdr->p_filesz; - - if (i_phdr->p_type != PT_LOAD) - continue; - - again: - while (base_vma < limit_vma) - { - bfd_vma next_vma = limit_vma; - asection *nsec; - asection *sec; - flagword flags; - char *nname = NULL; - - /* Find a section covering [base_vma;limit_vma) */ - for (sec = abfd->sections; sec != NULL; sec = sec->next) - { - /* Skip uninteresting sections (either not in memory or - below base_vma. */ - if ((sec->flags & (SEC_ALLOC | SEC_LOAD)) == 0 - || sec->vma + sec->size <= base_vma) - continue; - if (sec->vma <= base_vma) - { - /* This section covers (maybe partially) the beginning - of the range. */ - base_vma = sec->vma + sec->size; - goto again; - } - if (sec->vma < next_vma) - { - /* This section partially covers the end of the range. - Used to compute the size of the hole. */ - next_vma = sec->vma; - } - } - - /* No section covering [base_vma; next_vma). Create a fake one. */ - flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS; - if (i_phdr->p_flags & PF_X) - { - flags |= SEC_CODE; - if (num_text++ == 0) - nname = ".text"; - else - sprintf (name, ".text$%u", num_text); - } - else if ((i_phdr->p_flags & (PF_R | PF_W)) == PF_R) - { - flags |= SEC_READONLY; - sprintf (name, ".rodata$%u", num_rodata++); - } - else - { - flags |= SEC_DATA; - sprintf (name, ".data$%u", num_data++); - } - - /* Allocate name. */ - if (nname == NULL) - { - size_t name_len = strlen (name) + 1; - nname = bfd_alloc (abfd, name_len); - if (nname == NULL) - return FALSE; - memcpy (nname, name, name_len); - } - - /* Create and fill new section. */ - nsec = bfd_make_section_anyway_with_flags (abfd, nname, flags); - if (nsec == NULL) - return FALSE; - nsec->vma = base_vma; - nsec->size = next_vma - base_vma; - nsec->filepos = i_phdr->p_offset + (base_vma - i_phdr->p_vaddr); - - base_vma = next_vma; - } - } - return TRUE; -} - -static void -elfNN_vms_post_process_headers (bfd *abfd, - struct bfd_link_info *info ATTRIBUTE_UNUSED) -{ - Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd); - - i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_OPENVMS; - i_ehdrp->e_ident[EI_ABIVERSION] = 2; -} - -static bfd_boolean -elfNN_vms_section_processing (bfd *abfd ATTRIBUTE_UNUSED, - Elf_Internal_Shdr *hdr) -{ - if (hdr->bfd_section != NULL) - { - const char *name = bfd_get_section_name (abfd, hdr->bfd_section); - - if (strcmp (name, ".text") == 0) - hdr->sh_flags |= SHF_IA_64_VMS_SHARED; - else if ((strcmp (name, ".debug") == 0) - || (strcmp (name, ".debug_abbrev") == 0) - || (strcmp (name, ".debug_aranges") == 0) - || (strcmp (name, ".debug_frame") == 0) - || (strcmp (name, ".debug_info") == 0) - || (strcmp (name, ".debug_loc") == 0) - || (strcmp (name, ".debug_macinfo") == 0) - || (strcmp (name, ".debug_pubnames") == 0) - || (strcmp (name, ".debug_pubtypes") == 0)) - hdr->sh_type = SHT_IA_64_VMS_DEBUG; - else if ((strcmp (name, ".debug_line") == 0) - || (strcmp (name, ".debug_ranges") == 0)) - hdr->sh_type = SHT_IA_64_VMS_TRACE; - else if (strcmp (name, ".debug_str") == 0) - hdr->sh_type = SHT_IA_64_VMS_DEBUG_STR; - else if (strcmp (name, ".vms_display_name_info") == 0) - { - int idx, symcount; - asymbol **syms; - struct elf_obj_tdata *t = elf_tdata (abfd); - int buf[2]; - int demangler_sym_idx = -1; - - symcount = bfd_get_symcount (abfd); - syms = bfd_get_outsymbols (abfd); - for (idx = 0; idx < symcount; idx++) - { - asymbol *sym; - sym = syms[idx]; - if ((sym->flags & (BSF_DEBUGGING | BSF_DYNAMIC)) - && strchr (sym->name, '@') - && (strcmp (sym->section->name, BFD_ABS_SECTION_NAME) == 0)) - { - demangler_sym_idx = sym->udata.i; - break; - } - } - - hdr->sh_type = SHT_IA_64_VMS_DISPLAY_NAME_INFO; - hdr->sh_entsize = 4; - hdr->sh_addralign = 0; - hdr->sh_link = t->symtab_section; - - /* Find symtab index of demangler routine and stuff it in - the second long word of section data. */ - - if (demangler_sym_idx > -1) - { - bfd_seek (abfd, hdr->sh_offset, SEEK_SET); - bfd_bread (buf, hdr->sh_size, abfd); - buf [1] = demangler_sym_idx; - bfd_seek (abfd, hdr->sh_offset, SEEK_SET); - bfd_bwrite (buf, hdr->sh_size, abfd); - } - } - } - - return TRUE; -} - -/* The final processing done just before writing out a VMS IA-64 ELF - object file. */ - -static void -elfNN_vms_final_write_processing (bfd *abfd, - bfd_boolean linker ATTRIBUTE_UNUSED) -{ - Elf_Internal_Shdr *hdr; - asection *s; - int unwind_info_sect_idx = 0; - - for (s = abfd->sections; s; s = s->next) - { - hdr = &elf_section_data (s)->this_hdr; - - if (strcmp (bfd_get_section_name (abfd, hdr->bfd_section), - ".IA_64.unwind_info") == 0) - unwind_info_sect_idx = elf_section_data (s)->this_idx; - - switch (hdr->sh_type) - { - case SHT_IA_64_UNWIND: - /* VMS requires sh_info to point to the unwind info section. */ - hdr->sh_info = unwind_info_sect_idx; - break; - } - } - - if (! elf_flags_init (abfd)) - { - unsigned long flags = 0; - - if (abfd->xvec->byteorder == BFD_ENDIAN_BIG) - flags |= EF_IA_64_BE; - if (bfd_get_mach (abfd) == bfd_mach_ia64_elf64) - flags |= EF_IA_64_ABI64; - - elf_elfheader(abfd)->e_flags = flags; - elf_flags_init (abfd) = TRUE; - } -} - -static bfd_boolean -elfNN_vms_close_and_cleanup (bfd *abfd) -{ - if (bfd_get_format (abfd) == bfd_object) - { - long isize, irsize; - - if (elf_shstrtab (abfd) != NULL) - _bfd_elf_strtab_free (elf_shstrtab (abfd)); - - /* Pad to 8 byte boundary for IPF/VMS. */ - isize = bfd_get_size (abfd); - if ((irsize = isize/8*8) < isize) - { - int ishort = (irsize + 8) - isize; - bfd_seek (abfd, isize, SEEK_SET); - bfd_bwrite (bfd_zmalloc (ishort), ishort, abfd); - } - } - - return _bfd_generic_close_and_cleanup (abfd); -} -#endif /* INCLUDE_IA64_VMS */ #define TARGET_LITTLE_SYM bfd_elfNN_ia64_little_vec #define TARGET_LITTLE_NAME "elfNN-ia64-little" @@ -5381,86 +5102,3 @@ elfNN_vms_close_and_cleanup (bfd *abfd) #define elfNN_bed elfNN_ia64_hpux_bed #include "elfNN-target.h" - -/* VMS-specific vectors. */ -#ifdef INCLUDE_IA64_VMS - -#undef TARGET_LITTLE_SYM -#define TARGET_LITTLE_SYM bfd_elfNN_ia64_vms_vec -#undef TARGET_LITTLE_NAME -#define TARGET_LITTLE_NAME "elfNN-ia64-vms" -#undef TARGET_BIG_SYM -#undef TARGET_BIG_NAME - -/* These are VMS specific functions. */ - -#undef elf_backend_object_p -#define elf_backend_object_p elfNN_vms_object_p - -#undef elf_backend_section_from_shdr -#define elf_backend_section_from_shdr elfNN_vms_section_from_shdr - -#undef elf_backend_post_process_headers -#define elf_backend_post_process_headers elfNN_vms_post_process_headers - -#undef elf_backend_section_processing -#define elf_backend_section_processing elfNN_vms_section_processing - -#undef elf_backend_final_write_processing -#define elf_backend_final_write_processing elfNN_vms_final_write_processing - -#undef bfd_elfNN_close_and_cleanup -#define bfd_elfNN_close_and_cleanup elfNN_vms_close_and_cleanup - -#undef elf_backend_section_from_bfd_section - -#undef elf_backend_symbol_processing - -#undef elf_backend_want_p_paddr_set_to_zero - -#undef ELF_OSABI -#define ELF_OSABI ELFOSABI_OPENVMS - -#undef ELF_MAXPAGESIZE -#define ELF_MAXPAGESIZE 0x10000 /* 64KB */ - -#undef elfNN_bed -#define elfNN_bed elfNN_ia64_vms_bed - -/* Use VMS-style archives (in particular, don't use the standard coff - archive format). */ -#define bfd_elfNN_archive_functions - -#undef bfd_elfNN_archive_p -#define bfd_elfNN_archive_p _bfd_vms_lib_ia64_archive_p -#undef bfd_elfNN_write_archive_contents -#define bfd_elfNN_write_archive_contents _bfd_vms_lib_write_archive_contents -#undef bfd_elfNN_mkarchive -#define bfd_elfNN_mkarchive _bfd_vms_lib_ia64_mkarchive - -#define bfd_elfNN_archive_slurp_armap \ - _bfd_vms_lib_slurp_armap -#define bfd_elfNN_archive_slurp_extended_name_table \ - _bfd_vms_lib_slurp_extended_name_table -#define bfd_elfNN_archive_construct_extended_name_table \ - _bfd_vms_lib_construct_extended_name_table -#define bfd_elfNN_archive_truncate_arname \ - _bfd_vms_lib_truncate_arname -#define bfd_elfNN_archive_write_armap \ - _bfd_vms_lib_write_armap -#define bfd_elfNN_archive_read_ar_hdr \ - _bfd_vms_lib_read_ar_hdr -#define bfd_elfNN_archive_write_ar_hdr \ - _bfd_vms_lib_write_ar_hdr -#define bfd_elfNN_archive_openr_next_archived_file \ - _bfd_vms_lib_openr_next_archived_file -#define bfd_elfNN_archive_get_elt_at_index \ - _bfd_vms_lib_get_elt_at_index -#define bfd_elfNN_archive_generic_stat_arch_elt \ - _bfd_vms_lib_generic_stat_arch_elt -#define bfd_elfNN_archive_update_armap_timestamp \ - _bfd_vms_lib_update_armap_timestamp - -#include "elfNN-target.h" - -#endif /* INCLUDE_IA64_VMS */ diff --git a/configure b/configure index e3fef4fc775..2fee66b16e7 100755 --- a/configure +++ b/configure @@ -3093,7 +3093,9 @@ case "${target}" in noconfigdirs="$noconfigdirs target-libssp" ;; rl78-*-*) - # Dereferencing -1 is a compile-time error + # libssp uses a misaligned load to trigger a fault, but the RL78 + # doesn't fault for those - instead, it gives a build-time error + # for explicit misaligned loads. noconfigdirs="$noconfigdirs target-libssp" ;; esac @@ -3496,8 +3498,7 @@ case "${target}" in noconfigdirs="$noconfigdirs libgui itcl ld" ;; ia64*-*-*vms*) - # No ld support yet. - noconfigdirs="$noconfigdirs libgui itcl ld" + noconfigdirs="$noconfigdirs libgui itcl" ;; i[3456789]86-w64-mingw*) ;; diff --git a/configure.ac b/configure.ac index 386ec78b668..c2795874c2b 100644 --- a/configure.ac +++ b/configure.ac @@ -1,5 +1,5 @@ # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, -# 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 +# 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 # Free Software Foundation, Inc. # # This file is free software; you can redistribute it and/or modify it @@ -519,7 +519,9 @@ case "${target}" in noconfigdirs="$noconfigdirs target-libssp" ;; rl78-*-*) - # Dereferencing -1 is a compile-time error + # libssp uses a misaligned load to trigger a fault, but the RL78 + # doesn't fault for those - instead, it gives a build-time error + # for explicit misaligned loads. noconfigdirs="$noconfigdirs target-libssp" ;; esac @@ -922,8 +924,7 @@ case "${target}" in noconfigdirs="$noconfigdirs libgui itcl ld" ;; ia64*-*-*vms*) - # No ld support yet. - noconfigdirs="$noconfigdirs libgui itcl ld" + noconfigdirs="$noconfigdirs libgui itcl" ;; i[[3456789]]86-w64-mingw*) ;; diff --git a/ld/ChangeLog b/ld/ChangeLog index ebad05a7a77..b97aa868a3c 100644 --- a/ld/ChangeLog +++ b/ld/ChangeLog @@ -1,3 +1,14 @@ +2012-04-11 Tristan Gingold + + * scripttempl/ia64vms.sc: New file. + * emultempl/vms.em (_before_parse): Support for ia64. + (elf64-ia64-vms): New fragment for ia64. + * emulparams/elf64_ia64_vms.sh: New file. + * configure.tgt (ia64-*-*vms*): Add. + * Makefile.am (ALL_64_EMULATION_SOURCES): Add eelf64_ia64_vms.c + (eelf64_ia64_vms.c): New rule. + * Makefile.in: Regenerate. + 2012-04-06 Roland McGrath * configure.in (AC_CHECK_HEADERS): Add locale.h. diff --git a/ld/Makefile.am b/ld/Makefile.am index 524350ea34c..df7ab98d22e 100644 --- a/ld/Makefile.am +++ b/ld/Makefile.am @@ -467,6 +467,7 @@ ALL_64_EMULATION_SOURCES = \ eelf64_aix.c \ eelf64_ia64.c \ eelf64_ia64_fbsd.c \ + eelf64_ia64_vms.c \ eelf64_s390.c \ eelf64_sparc.c \ eelf64_sparc_fbsd.c \ @@ -1928,6 +1929,10 @@ eelf64_ia64_fbsd.c: $(srcdir)/emulparams/elf64_ia64_fbsd.sh \ $(srcdir)/emultempl/needrelax.em \ $(srcdir)/scripttempl/elf.sc ${GEN_DEPENDS} ${GENSCRIPTS} elf64_ia64_fbsd "$(tdir_elf64_ia64_fbsd)" +eelf64_ia64_vms.c: $(srcdir)/emulparams/elf64_ia64_vms.sh \ + $(srcdir)/emultempl/vms.em \ + $(srcdir)/scripttempl/ia64vms.sc ${GEN_DEPENDS} + ${GENSCRIPTS} elf64_ia64_vms "$(tdir_elf64_ia64_vms)" eelf64_s390.c: $(srcdir)/emulparams/elf64_s390.sh \ $(ELF_DEPS) $(srcdir)/scripttempl/elf.sc ${GEN_DEPENDS} ${GENSCRIPTS} elf64_s390 "$(tdir_elf64_s390)" diff --git a/ld/Makefile.in b/ld/Makefile.in index 776a4e0380b..af27d3f8f33 100644 --- a/ld/Makefile.in +++ b/ld/Makefile.in @@ -55,6 +55,7 @@ am__aclocal_m4_deps = $(top_srcdir)/../bfd/acinclude.m4 \ $(top_srcdir)/../config/depstand.m4 \ $(top_srcdir)/../config/gettext-sister.m4 \ $(top_srcdir)/../config/largefile.m4 \ + $(top_srcdir)/../config/lcmessage.m4 \ $(top_srcdir)/../config/lead-dot.m4 \ $(top_srcdir)/../config/nls.m4 \ $(top_srcdir)/../config/override.m4 \ @@ -772,6 +773,7 @@ ALL_64_EMULATION_SOURCES = \ eelf64_aix.c \ eelf64_ia64.c \ eelf64_ia64_fbsd.c \ + eelf64_ia64_vms.c \ eelf64_s390.c \ eelf64_sparc.c \ eelf64_sparc_fbsd.c \ @@ -1176,6 +1178,7 @@ distclean-compile: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eelf64_aix.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eelf64_ia64.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eelf64_ia64_fbsd.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eelf64_ia64_vms.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eelf64_s390.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eelf64_sparc.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eelf64_sparc_fbsd.Po@am__quote@ @@ -3389,6 +3392,10 @@ eelf64_ia64_fbsd.c: $(srcdir)/emulparams/elf64_ia64_fbsd.sh \ $(srcdir)/emultempl/needrelax.em \ $(srcdir)/scripttempl/elf.sc ${GEN_DEPENDS} ${GENSCRIPTS} elf64_ia64_fbsd "$(tdir_elf64_ia64_fbsd)" +eelf64_ia64_vms.c: $(srcdir)/emulparams/elf64_ia64_vms.sh \ + $(srcdir)/emultempl/vms.em \ + $(srcdir)/scripttempl/ia64vms.sc ${GEN_DEPENDS} + ${GENSCRIPTS} elf64_ia64_vms "$(tdir_elf64_ia64_vms)" eelf64_s390.c: $(srcdir)/emulparams/elf64_s390.sh \ $(ELF_DEPS) $(srcdir)/scripttempl/elf.sc ${GEN_DEPENDS} ${GENSCRIPTS} elf64_s390 "$(tdir_elf64_s390)" diff --git a/ld/configure.tgt b/ld/configure.tgt index 6418768c959..abb47065fe5 100644 --- a/ld/configure.tgt +++ b/ld/configure.tgt @@ -308,6 +308,7 @@ ia64-*-freebsd* | ia64-*-kfreebsd*-gnu) targ_extra_emuls="elf64_ia64" ;; ia64-*-netbsd*) targ_emul=elf64_ia64 ;; ia64-*-linux*) targ_emul=elf64_ia64 ;; +ia64-*-*vms*) targ_emul=elf64_ia64_vms ;; ia64-*-aix*) targ_emul=elf64_aix ;; ip2k-*-elf) targ_emul=elf32ip2k diff --git a/ld/emulparams/elf64_ia64_vms.sh b/ld/emulparams/elf64_ia64_vms.sh new file mode 100644 index 00000000000..068840281f6 --- /dev/null +++ b/ld/emulparams/elf64_ia64_vms.sh @@ -0,0 +1,7 @@ +SCRIPT_NAME=ia64vms + +OUTPUT_FORMAT="elf64-ia64-vms" +ARCH=ia64 + +COMPILE_IN=yes +EXTRA_EM_FILE=vms diff --git a/ld/emultempl/vms.em b/ld/emultempl/vms.em index 164f2e19038..98837e34a64 100644 --- a/ld/emultempl/vms.em +++ b/ld/emultempl/vms.em @@ -31,6 +31,10 @@ gld${EMULATION_NAME}_before_parse (void) ldfile_set_output_arch ("${ARCH}", bfd_arch_`echo ${ARCH} | sed -e 's/:.*//'`); input_flags.dynamic = TRUE; config.has_shared = FALSE; /* Not yet. */ + + /* For ia64, harmless for alpha. */ + link_info.emit_hash = FALSE; + link_info.spare_dynamic_tags = 0; } /* This is called before the input files are opened. We add the @@ -132,7 +136,8 @@ gld${EMULATION_NAME}_add_options int nrl ATTRIBUTE_UNUSED, struct option **really_longopts ATTRIBUTE_UNUSED) { - static const struct option xtra_long[] = { + static const struct option xtra_long[] = + { {"identification", required_argument, NULL, OPTION_IDENTIFICATION}, {NULL, no_argument, NULL, 0} }; @@ -166,6 +171,63 @@ gld${EMULATION_NAME}_handle_option (int optc) EOF +if test "$OUTPUT_FORMAT" = "elf64-ia64-vms"; then + +fragment <dynamic_sections_created + && bed->elf_backend_size_dynamic_sections + && ! (*bed->elf_backend_size_dynamic_sections) (link_info.output_bfd, + &link_info)) + einfo ("%P%F: failed to set dynamic section sizes: %E\n"); + + before_allocation_default (); +} + +static void +gld${EMULATION_NAME}_after_allocation (void) +{ + bfd_boolean need_layout = bfd_elf_discard_info (link_info.output_bfd, + &link_info); + gld${EMULATION_NAME}_map_segments (need_layout); +} + +static void +gld${EMULATION_NAME}_after_parse (void) +{ + link_info.relax_pass = 2; + after_parse_default (); +} +EOF + +LDEMUL_BEFORE_ALLOCATION=gld"$EMULATION_NAME"_before_allocation +LDEMUL_AFTER_ALLOCATION=gld"$EMULATION_NAME"_after_allocation + +LDEMUL_AFTER_PARSE=gld${EMULATION_NAME}_after_parse +source_em ${srcdir}/emultempl/needrelax.em +fi + LDEMUL_PLACE_ORPHAN=vms_place_orphan LDEMUL_BEFORE_PARSE=gld"$EMULATION_NAME"_before_parse LDEMUL_CREATE_OUTPUT_SECTION_STATEMENTS=gld"$EMULATION_NAME"_create_output_section_statements diff --git a/ld/scripttempl/ia64vms.sc b/ld/scripttempl/ia64vms.sc new file mode 100644 index 00000000000..b0b1c42a17d --- /dev/null +++ b/ld/scripttempl/ia64vms.sc @@ -0,0 +1,129 @@ +# Linker script for Itanium VMS systems. +# Tristan Gingold . + +PAGESIZE=0x10000 +BLOCKSIZE=0x200 + +cat <