bfd/elfxx-ia64.c

   1 /* IA-64 support for 64-bit ELF
   2    Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
   3    Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
   4
   5 This file is part of BFD, the Binary File Descriptor library.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "bfd.h"
  22 #include "sysdep.h"
  23 #include "libbfd.h"
  24 #include "elf-bfd.h"
  25 #include "opcode/ia64.h"
  26 #include "elf/ia64.h"
  27
  28 /*
  29  * THE RULES for all the stuff the linker creates --
  30  *
  31  * GOT          Entries created in response to LTOFF or LTOFF_FPTR
  32  *              relocations.  Dynamic relocs created for dynamic
  33  *              symbols in an application; REL relocs for locals
  34  *              in a shared library.
  35  *
  36  * FPTR         The canonical function descriptor.  Created for local
  37  *              symbols in applications.  Descriptors for dynamic symbols
  38  *              and local symbols in shared libraries are created by
  39  *              ld.so.  Thus there are no dynamic relocs against these
  40  *              objects.  The FPTR relocs for such _are_ passed through
  41  *              to the dynamic relocation tables.
  42  *
  43  * FULL_PLT     Created for a PCREL21B relocation against a dynamic symbol.
  44  *              Requires the creation of a PLTOFF entry.  This does not
  45  *              require any dynamic relocations.
  46  *
  47  * PLTOFF       Created by PLTOFF relocations.  For local symbols, this
  48  *              is an alternate function descriptor, and in shared libraries
  49  *              requires two REL relocations.  Note that this cannot be
  50  *              transformed into an FPTR relocation, since it must be in
  51  *              range of the GP.  For dynamic symbols, this is a function
  52  *              descriptor for a MIN_PLT entry, and requires one IPLT reloc.
  53  *
  54  * MIN_PLT      Created by PLTOFF entries against dynamic symbols.  This
  55  *              does not reqire dynamic relocations.
  56  */
  57
  58 #define USE_RELA                /* we want RELA relocs, not REL */
  59
  60 #define NELEMS(a)       ((int) (sizeof (a) / sizeof ((a)[0])))
  61
  62 typedef struct bfd_hash_entry *(*new_hash_entry_func)
  63   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
  64
  65 /* In dynamically (linker-) created sections, we generally need to keep track
  66    of the place a symbol or expression got allocated to. This is done via hash
  67    tables that store entries of the following type.  */
  68
  69 struct elfNN_ia64_dyn_sym_info
  70 {
  71   /* The addend for which this entry is relevant.  */
  72   bfd_vma addend;
  73
  74   /* Next addend in the list.  */
  75   struct elfNN_ia64_dyn_sym_info *next;
  76
  77   bfd_vma got_offset;
  78   bfd_vma fptr_offset;
  79   bfd_vma pltoff_offset;
  80   bfd_vma plt_offset;
  81   bfd_vma plt2_offset;
  82
  83   /* The symbol table entry, if any, that this was derrived from.  */
  84   struct elf_link_hash_entry *h;
  85
  86   /* Used to count non-got, non-plt relocations for delayed sizing
  87      of relocation sections.  */
  88   struct elfNN_ia64_dyn_reloc_entry
  89   {
  90     struct elfNN_ia64_dyn_reloc_entry *next;
  91     asection *srel;
  92     int type;
  93     int count;
  94   } *reloc_entries;
  95
  96   /* True when the section contents have been updated.  */
  97   unsigned got_done : 1;
  98   unsigned fptr_done : 1;
  99   unsigned pltoff_done : 1;
 100
 101   /* True for the different kinds of linker data we want created.  */
 102   unsigned want_got : 1;
 103   unsigned want_fptr : 1;
 104   unsigned want_ltoff_fptr : 1;
 105   unsigned want_plt : 1;
 106   unsigned want_plt2 : 1;
 107   unsigned want_pltoff : 1;
 108 };
 109
 110 struct elfNN_ia64_local_hash_entry
 111 {
 112   struct bfd_hash_entry root;
 113   struct elfNN_ia64_dyn_sym_info *info;
 114 };
 115
 116 struct elfNN_ia64_local_hash_table
 117 {
 118   struct bfd_hash_table root;
 119   /* No additional fields for now.  */
 120 };
 121
 122 struct elfNN_ia64_link_hash_entry
 123 {
 124   struct elf_link_hash_entry root;
 125   struct elfNN_ia64_dyn_sym_info *info;
 126 };
 127
 128 struct elfNN_ia64_link_hash_table
 129 {
 130   /* The main hash table */
 131   struct elf_link_hash_table root;
 132
 133   asection *got_sec;            /* the linkage table section (or NULL) */
 134   asection *rel_got_sec;        /* dynamic relocation section for same */
 135   asection *fptr_sec;           /* function descriptor table (or NULL) */
 136   asection *plt_sec;            /* the primary plt section (or NULL) */
 137   asection *pltoff_sec;         /* private descriptors for plt (or NULL) */
 138   asection *rel_pltoff_sec;     /* dynamic relocation section for same */
 139
 140   bfd_size_type minplt_entries; /* number of minplt entries */
 141   unsigned reltext : 1;         /* are there relocs against readonly sections? */
 142
 143   struct elfNN_ia64_local_hash_table loc_hash_table;
 144 };
 145
 146 #define elfNN_ia64_hash_table(p) \
 147   ((struct elfNN_ia64_link_hash_table *) ((p)->hash))
 148
 149 static bfd_reloc_status_type elfNN_ia64_reloc
 150   PARAMS ((bfd *abfd, arelent *reloc, asymbol *sym, PTR data,
 151            asection *input_section, bfd *output_bfd, char **error_message));
 152 static reloc_howto_type * lookup_howto
 153   PARAMS ((unsigned int rtype));
 154 static reloc_howto_type *elfNN_ia64_reloc_type_lookup
 155   PARAMS ((bfd *abfd, bfd_reloc_code_real_type bfd_code));
 156 static void elfNN_ia64_info_to_howto
 157   PARAMS ((bfd *abfd, arelent *bfd_reloc, ElfNN_Internal_Rela *elf_reloc));
 158 static boolean elfNN_ia64_relax_section
 159   PARAMS((bfd *abfd, asection *sec, struct bfd_link_info *link_info,
 160           boolean *again));
 161 static boolean is_unwind_section_name
 162   PARAMS ((const char *));
 163 static boolean elfNN_ia64_section_from_shdr
 164   PARAMS ((bfd *, ElfNN_Internal_Shdr *, char *));
 165 static boolean elfNN_ia64_section_flags
 166   PARAMS ((flagword *, ElfNN_Internal_Shdr *));
 167 static boolean elfNN_ia64_fake_sections
 168   PARAMS ((bfd *abfd, ElfNN_Internal_Shdr *hdr, asection *sec));
 169 static void elfNN_ia64_final_write_processing
 170   PARAMS ((bfd *abfd, boolean linker));
 171 static boolean elfNN_ia64_add_symbol_hook
 172   PARAMS ((bfd *abfd, struct bfd_link_info *info, const Elf_Internal_Sym *sym,
 173            const char **namep, flagword *flagsp, asection **secp,
 174            bfd_vma *valp));
 175 static boolean elfNN_ia64_aix_vec
 176   PARAMS ((const bfd_target *vec));
 177 static boolean elfNN_ia64_aix_add_symbol_hook
 178   PARAMS ((bfd *abfd, struct bfd_link_info *info, const Elf_Internal_Sym *sym,
 179            const char **namep, flagword *flagsp, asection **secp,
 180            bfd_vma *valp));
 181 static boolean elfNN_ia64_aix_link_add_symbols
 182   PARAMS ((bfd *abfd, struct bfd_link_info *info));
 183 static int elfNN_ia64_additional_program_headers
 184   PARAMS ((bfd *abfd));
 185 static boolean elfNN_ia64_modify_segment_map
 186   PARAMS ((bfd *));
 187 static boolean elfNN_ia64_is_local_label_name
 188   PARAMS ((bfd *abfd, const char *name));
 189 static boolean elfNN_ia64_dynamic_symbol_p
 190   PARAMS ((struct elf_link_hash_entry *h, struct bfd_link_info *info));
 191 static boolean elfNN_ia64_local_hash_table_init
 192   PARAMS ((struct elfNN_ia64_local_hash_table *ht, bfd *abfd,
 193            new_hash_entry_func new));
 194 static struct bfd_hash_entry *elfNN_ia64_new_loc_hash_entry
 195   PARAMS ((struct bfd_hash_entry *entry, struct bfd_hash_table *table,
 196            const char *string));
 197 static struct bfd_hash_entry *elfNN_ia64_new_elf_hash_entry
 198   PARAMS ((struct bfd_hash_entry *entry, struct bfd_hash_table *table,
 199            const char *string));
 200 static void elfNN_ia64_hash_copy_indirect
 201   PARAMS ((struct elf_link_hash_entry *, struct elf_link_hash_entry *));
 202 static void elfNN_ia64_hash_hide_symbol
 203   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
 204 static struct bfd_link_hash_table *elfNN_ia64_hash_table_create
 205   PARAMS ((bfd *abfd));
 206 static struct elfNN_ia64_local_hash_entry *elfNN_ia64_local_hash_lookup
 207   PARAMS ((struct elfNN_ia64_local_hash_table *table, const char *string,
 208            boolean create, boolean copy));
 209 static boolean elfNN_ia64_global_dyn_sym_thunk
 210   PARAMS ((struct bfd_hash_entry *, PTR));
 211 static boolean elfNN_ia64_local_dyn_sym_thunk
 212   PARAMS ((struct bfd_hash_entry *, PTR));
 213 static void elfNN_ia64_dyn_sym_traverse
 214   PARAMS ((struct elfNN_ia64_link_hash_table *ia64_info,
 215            boolean (*func) (struct elfNN_ia64_dyn_sym_info *, PTR),
 216            PTR info));
 217 static boolean elfNN_ia64_create_dynamic_sections
 218   PARAMS ((bfd *abfd, struct bfd_link_info *info));
 219 static struct elfNN_ia64_dyn_sym_info * get_dyn_sym_info
 220   PARAMS ((struct elfNN_ia64_link_hash_table *ia64_info,
 221            struct elf_link_hash_entry *h,
 222            bfd *abfd, const Elf_Internal_Rela *rel, boolean create));
 223 static asection *get_got
 224   PARAMS ((bfd *abfd, struct bfd_link_info *info,
 225            struct elfNN_ia64_link_hash_table *ia64_info));
 226 static asection *get_fptr
 227   PARAMS ((bfd *abfd, struct bfd_link_info *info,
 228            struct elfNN_ia64_link_hash_table *ia64_info));
 229 static asection *get_pltoff
 230   PARAMS ((bfd *abfd, struct bfd_link_info *info,
 231            struct elfNN_ia64_link_hash_table *ia64_info));
 232 static asection *get_reloc_section
 233   PARAMS ((bfd *abfd, struct elfNN_ia64_link_hash_table *ia64_info,
 234            asection *sec, boolean create));
 235 static boolean count_dyn_reloc
 236   PARAMS ((bfd *abfd, struct elfNN_ia64_dyn_sym_info *dyn_i,
 237            asection *srel, int type));
 238 static boolean elfNN_ia64_check_relocs
 239   PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *sec,
 240            const Elf_Internal_Rela *relocs));
 241 static boolean elfNN_ia64_adjust_dynamic_symbol
 242   PARAMS ((struct bfd_link_info *info, struct elf_link_hash_entry *h));
 243 static long global_sym_index
 244   PARAMS ((struct elf_link_hash_entry *h));
 245 static boolean allocate_fptr
 246   PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
 247 static boolean allocate_global_data_got
 248   PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
 249 static boolean allocate_global_fptr_got
 250   PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
 251 static boolean allocate_local_got
 252   PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
 253 static boolean allocate_pltoff_entries
 254   PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
 255 static boolean allocate_plt_entries
 256   PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
 257 static boolean allocate_plt2_entries
 258   PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
 259 static boolean allocate_dynrel_entries
 260   PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
 261 static boolean elfNN_ia64_size_dynamic_sections
 262   PARAMS ((bfd *output_bfd, struct bfd_link_info *info));
 263 static bfd_reloc_status_type elfNN_ia64_install_value
 264   PARAMS ((bfd *abfd, bfd_byte *hit_addr, bfd_vma val, unsigned int r_type));
 265 static void elfNN_ia64_install_dyn_reloc
 266   PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *sec,
 267            asection *srel, bfd_vma offset, unsigned int type,
 268            long dynindx, bfd_vma addend));
 269 static bfd_vma set_got_entry
 270   PARAMS ((bfd *abfd, struct bfd_link_info *info,
 271            struct elfNN_ia64_dyn_sym_info *dyn_i, long dynindx,
 272            bfd_vma addend, bfd_vma value, unsigned int dyn_r_type));
 273 static bfd_vma set_fptr_entry
 274   PARAMS ((bfd *abfd, struct bfd_link_info *info,
 275            struct elfNN_ia64_dyn_sym_info *dyn_i,
 276            bfd_vma value));
 277 static bfd_vma set_pltoff_entry
 278   PARAMS ((bfd *abfd, struct bfd_link_info *info,
 279            struct elfNN_ia64_dyn_sym_info *dyn_i,
 280            bfd_vma value, boolean));
 281 static int elfNN_ia64_unwind_entry_compare
 282   PARAMS ((const PTR, const PTR));
 283 static boolean elfNN_ia64_final_link
 284   PARAMS ((bfd *abfd, struct bfd_link_info *info));
 285 static boolean elfNN_ia64_relocate_section
 286   PARAMS ((bfd *output_bfd, struct bfd_link_info *info, bfd *input_bfd,
 287            asection *input_section, bfd_byte *contents,
 288            Elf_Internal_Rela *relocs, Elf_Internal_Sym *local_syms,
 289            asection **local_sections));
 290 static boolean elfNN_ia64_finish_dynamic_symbol
 291   PARAMS ((bfd *output_bfd, struct bfd_link_info *info,
 292            struct elf_link_hash_entry *h, Elf_Internal_Sym *sym));
 293 static boolean elfNN_ia64_finish_dynamic_sections
 294   PARAMS ((bfd *abfd, struct bfd_link_info *info));
 295 static boolean elfNN_ia64_set_private_flags
 296   PARAMS ((bfd *abfd, flagword flags));
 297 static boolean elfNN_ia64_copy_private_bfd_data
 298   PARAMS ((bfd *ibfd, bfd *obfd));
 299 static boolean elfNN_ia64_merge_private_bfd_data
 300   PARAMS ((bfd *ibfd, bfd *obfd));
 301 static boolean elfNN_ia64_print_private_bfd_data
 302   PARAMS ((bfd *abfd, PTR ptr));
 303 static enum elf_reloc_type_class elfNN_ia64_reloc_type_class
 304   PARAMS ((const Elf_Internal_Rela *));
 305 \f
 306 /* ia64-specific relocation */
 307
 308 /* Perform a relocation.  Not much to do here as all the hard work is
 309    done in elfNN_ia64_final_link_relocate.  */
 310 static bfd_reloc_status_type
 311 elfNN_ia64_reloc (abfd, reloc, sym, data, input_section,
 312                   output_bfd, error_message)
 313      bfd *abfd ATTRIBUTE_UNUSED;
 314      arelent *reloc;
 315      asymbol *sym ATTRIBUTE_UNUSED;
 316      PTR data ATTRIBUTE_UNUSED;
 317      asection *input_section;
 318      bfd *output_bfd;
 319      char **error_message;
 320 {
 321   if (output_bfd)
 322     {
 323       reloc->address += input_section->output_offset;
 324       return bfd_reloc_ok;
 325     }
 326   *error_message = "Unsupported call to elfNN_ia64_reloc";
 327   return bfd_reloc_notsupported;
 328 }
 329
 330 #define IA64_HOWTO(TYPE, NAME, SIZE, PCREL, IN)                 \
 331   HOWTO (TYPE, 0, SIZE, 0, PCREL, 0, complain_overflow_signed,  \
 332          elfNN_ia64_reloc, NAME, false, 0, 0, IN)
 333
 334 /* This table has to be sorted according to increasing number of the
 335    TYPE field.  */
 336 static reloc_howto_type ia64_howto_table[] =
 337   {
 338     IA64_HOWTO (R_IA64_NONE,        "NONE",        0, false, true),
 339
 340     IA64_HOWTO (R_IA64_IMM14,       "IMM14",       0, false, true),
 341     IA64_HOWTO (R_IA64_IMM22,       "IMM22",       0, false, true),
 342     IA64_HOWTO (R_IA64_IMM64,       "IMM64",       0, false, true),
 343     IA64_HOWTO (R_IA64_DIR32MSB,    "DIR32MSB",    2, false, true),
 344     IA64_HOWTO (R_IA64_DIR32LSB,    "DIR32LSB",    2, false, true),
 345     IA64_HOWTO (R_IA64_DIR64MSB,    "DIR64MSB",    4, false, true),
 346     IA64_HOWTO (R_IA64_DIR64LSB,    "DIR64LSB",    4, false, true),
 347
 348     IA64_HOWTO (R_IA64_GPREL22,     "GPREL22",     0, false, true),
 349     IA64_HOWTO (R_IA64_GPREL64I,    "GPREL64I",    0, false, true),
 350     IA64_HOWTO (R_IA64_GPREL32MSB,  "GPREL32MSB",  2, false, true),
 351     IA64_HOWTO (R_IA64_GPREL32LSB,  "GPREL32LSB",  2, false, true),
 352     IA64_HOWTO (R_IA64_GPREL64MSB,  "GPREL64MSB",  4, false, true),
 353     IA64_HOWTO (R_IA64_GPREL64LSB,  "GPREL64LSB",  4, false, true),
 354
 355     IA64_HOWTO (R_IA64_LTOFF22,     "LTOFF22",     0, false, true),
 356     IA64_HOWTO (R_IA64_LTOFF64I,    "LTOFF64I",    0, false, true),
 357
 358     IA64_HOWTO (R_IA64_PLTOFF22,    "PLTOFF22",    0, false, true),
 359     IA64_HOWTO (R_IA64_PLTOFF64I,   "PLTOFF64I",   0, false, true),
 360     IA64_HOWTO (R_IA64_PLTOFF64MSB, "PLTOFF64MSB", 4, false, true),
 361     IA64_HOWTO (R_IA64_PLTOFF64LSB, "PLTOFF64LSB", 4, false, true),
 362
 363     IA64_HOWTO (R_IA64_FPTR64I,     "FPTR64I",     0, false, true),
 364     IA64_HOWTO (R_IA64_FPTR32MSB,   "FPTR32MSB",   2, false, true),
 365     IA64_HOWTO (R_IA64_FPTR32LSB,   "FPTR32LSB",   2, false, true),
 366     IA64_HOWTO (R_IA64_FPTR64MSB,   "FPTR64MSB",   4, false, true),
 367     IA64_HOWTO (R_IA64_FPTR64LSB,   "FPTR64LSB",   4, false, true),
 368
 369     IA64_HOWTO (R_IA64_PCREL60B,    "PCREL60B",    0, true, true),
 370     IA64_HOWTO (R_IA64_PCREL21B,    "PCREL21B",    0, true, true),
 371     IA64_HOWTO (R_IA64_PCREL21M,    "PCREL21M",    0, true, true),
 372     IA64_HOWTO (R_IA64_PCREL21F,    "PCREL21F",    0, true, true),
 373     IA64_HOWTO (R_IA64_PCREL32MSB,  "PCREL32MSB",  2, true, true),
 374     IA64_HOWTO (R_IA64_PCREL32LSB,  "PCREL32LSB",  2, true, true),
 375     IA64_HOWTO (R_IA64_PCREL64MSB,  "PCREL64MSB",  4, true, true),
 376     IA64_HOWTO (R_IA64_PCREL64LSB,  "PCREL64LSB",  4, true, true),
 377
 378     IA64_HOWTO (R_IA64_LTOFF_FPTR22, "LTOFF_FPTR22", 0, false, true),
 379     IA64_HOWTO (R_IA64_LTOFF_FPTR64I, "LTOFF_FPTR64I", 0, false, true),
 380     IA64_HOWTO (R_IA64_LTOFF_FPTR32MSB, "LTOFF_FPTR32MSB", 2, false, true),
 381     IA64_HOWTO (R_IA64_LTOFF_FPTR32LSB, "LTOFF_FPTR32LSB", 2, false, true),
 382     IA64_HOWTO (R_IA64_LTOFF_FPTR64MSB, "LTOFF_FPTR64MSB", 4, false, true),
 383     IA64_HOWTO (R_IA64_LTOFF_FPTR64LSB, "LTOFF_FPTR64LSB", 4, false, true),
 384
 385     IA64_HOWTO (R_IA64_SEGREL32MSB, "SEGREL32MSB", 2, false, true),
 386     IA64_HOWTO (R_IA64_SEGREL32LSB, "SEGREL32LSB", 2, false, true),
 387     IA64_HOWTO (R_IA64_SEGREL64MSB, "SEGREL64MSB", 4, false, true),
 388     IA64_HOWTO (R_IA64_SEGREL64LSB, "SEGREL64LSB", 4, false, true),
 389
 390     IA64_HOWTO (R_IA64_SECREL32MSB, "SECREL32MSB", 2, false, true),
 391     IA64_HOWTO (R_IA64_SECREL32LSB, "SECREL32LSB", 2, false, true),
 392     IA64_HOWTO (R_IA64_SECREL64MSB, "SECREL64MSB", 4, false, true),
 393     IA64_HOWTO (R_IA64_SECREL64LSB, "SECREL64LSB", 4, false, true),
 394
 395     IA64_HOWTO (R_IA64_REL32MSB,    "REL32MSB",    2, false, true),
 396     IA64_HOWTO (R_IA64_REL32LSB,    "REL32LSB",    2, false, true),
 397     IA64_HOWTO (R_IA64_REL64MSB,    "REL64MSB",    4, false, true),
 398     IA64_HOWTO (R_IA64_REL64LSB,    "REL64LSB",    4, false, true),
 399
 400     IA64_HOWTO (R_IA64_LTV32MSB,    "LTV32MSB",    2, false, true),
 401     IA64_HOWTO (R_IA64_LTV32LSB,    "LTV32LSB",    2, false, true),
 402     IA64_HOWTO (R_IA64_LTV64MSB,    "LTV64MSB",    4, false, true),
 403     IA64_HOWTO (R_IA64_LTV64LSB,    "LTV64LSB",    4, false, true),
 404
 405     IA64_HOWTO (R_IA64_PCREL21BI,   "PCREL21BI",   0, true, true),
 406     IA64_HOWTO (R_IA64_PCREL22,     "PCREL22",     0, true, true),
 407     IA64_HOWTO (R_IA64_PCREL64I,    "PCREL64I",    0, true, true),
 408
 409     IA64_HOWTO (R_IA64_IPLTMSB,     "IPLTMSB",     4, false, true),
 410     IA64_HOWTO (R_IA64_IPLTLSB,     "IPLTLSB",     4, false, true),
 411     IA64_HOWTO (R_IA64_COPY,        "COPY",        4, false, true),
 412     IA64_HOWTO (R_IA64_LTOFF22X,    "LTOFF22X",    0, false, true),
 413     IA64_HOWTO (R_IA64_LDXMOV,      "LDXMOV",      0, false, true),
 414
 415     IA64_HOWTO (R_IA64_TPREL22,     "TPREL22",     0, false, false),
 416     IA64_HOWTO (R_IA64_TPREL64MSB,  "TPREL64MSB",  8, false, false),
 417     IA64_HOWTO (R_IA64_TPREL64LSB,  "TPREL64LSB",  8, false, false),
 418     IA64_HOWTO (R_IA64_LTOFF_TP22,  "LTOFF_TP22",  0, false, false),
 419   };
 420
 421 static unsigned char elf_code_to_howto_index[R_IA64_MAX_RELOC_CODE + 1];
 422
 423 /* Given a BFD reloc type, return the matching HOWTO structure.  */
 424
 425 static reloc_howto_type*
 426 lookup_howto (rtype)
 427      unsigned int rtype;
 428 {
 429   static int inited = 0;
 430   int i;
 431
 432   if (!inited)
 433     {
 434       inited = 1;
 435
 436       memset (elf_code_to_howto_index, 0xff, sizeof (elf_code_to_howto_index));
 437       for (i = 0; i < NELEMS (ia64_howto_table); ++i)
 438         elf_code_to_howto_index[ia64_howto_table[i].type] = i;
 439     }
 440
 441   BFD_ASSERT (rtype <= R_IA64_MAX_RELOC_CODE);
 442   i = elf_code_to_howto_index[rtype];
 443   if (i >= NELEMS (ia64_howto_table))
 444     return 0;
 445   return ia64_howto_table + i;
 446 }
 447
 448 static reloc_howto_type*
 449 elfNN_ia64_reloc_type_lookup (abfd, bfd_code)
 450      bfd *abfd ATTRIBUTE_UNUSED;
 451      bfd_reloc_code_real_type bfd_code;
 452 {
 453   unsigned int rtype;
 454
 455   switch (bfd_code)
 456     {
 457     case BFD_RELOC_NONE:                rtype = R_IA64_NONE; break;
 458
 459     case BFD_RELOC_IA64_IMM14:          rtype = R_IA64_IMM14; break;
 460     case BFD_RELOC_IA64_IMM22:          rtype = R_IA64_IMM22; break;
 461     case BFD_RELOC_IA64_IMM64:          rtype = R_IA64_IMM64; break;
 462
 463     case BFD_RELOC_IA64_DIR32MSB:       rtype = R_IA64_DIR32MSB; break;
 464     case BFD_RELOC_IA64_DIR32LSB:       rtype = R_IA64_DIR32LSB; break;
 465     case BFD_RELOC_IA64_DIR64MSB:       rtype = R_IA64_DIR64MSB; break;
 466     case BFD_RELOC_IA64_DIR64LSB:       rtype = R_IA64_DIR64LSB; break;
 467
 468     case BFD_RELOC_IA64_GPREL22:        rtype = R_IA64_GPREL22; break;
 469     case BFD_RELOC_IA64_GPREL64I:       rtype = R_IA64_GPREL64I; break;
 470     case BFD_RELOC_IA64_GPREL32MSB:     rtype = R_IA64_GPREL32MSB; break;
 471     case BFD_RELOC_IA64_GPREL32LSB:     rtype = R_IA64_GPREL32LSB; break;
 472     case BFD_RELOC_IA64_GPREL64MSB:     rtype = R_IA64_GPREL64MSB; break;
 473     case BFD_RELOC_IA64_GPREL64LSB:     rtype = R_IA64_GPREL64LSB; break;
 474
 475     case BFD_RELOC_IA64_LTOFF22:        rtype = R_IA64_LTOFF22; break;
 476     case BFD_RELOC_IA64_LTOFF64I:       rtype = R_IA64_LTOFF64I; break;
 477
 478     case BFD_RELOC_IA64_PLTOFF22:       rtype = R_IA64_PLTOFF22; break;
 479     case BFD_RELOC_IA64_PLTOFF64I:      rtype = R_IA64_PLTOFF64I; break;
 480     case BFD_RELOC_IA64_PLTOFF64MSB:    rtype = R_IA64_PLTOFF64MSB; break;
 481     case BFD_RELOC_IA64_PLTOFF64LSB:    rtype = R_IA64_PLTOFF64LSB; break;
 482     case BFD_RELOC_IA64_FPTR64I:        rtype = R_IA64_FPTR64I; break;
 483     case BFD_RELOC_IA64_FPTR32MSB:      rtype = R_IA64_FPTR32MSB; break;
 484     case BFD_RELOC_IA64_FPTR32LSB:      rtype = R_IA64_FPTR32LSB; break;
 485     case BFD_RELOC_IA64_FPTR64MSB:      rtype = R_IA64_FPTR64MSB; break;
 486     case BFD_RELOC_IA64_FPTR64LSB:      rtype = R_IA64_FPTR64LSB; break;
 487
 488     case BFD_RELOC_IA64_PCREL21B:       rtype = R_IA64_PCREL21B; break;
 489     case BFD_RELOC_IA64_PCREL21BI:      rtype = R_IA64_PCREL21BI; break;
 490     case BFD_RELOC_IA64_PCREL21M:       rtype = R_IA64_PCREL21M; break;
 491     case BFD_RELOC_IA64_PCREL21F:       rtype = R_IA64_PCREL21F; break;
 492     case BFD_RELOC_IA64_PCREL22:        rtype = R_IA64_PCREL22; break;
 493     case BFD_RELOC_IA64_PCREL60B:       rtype = R_IA64_PCREL60B; break;
 494     case BFD_RELOC_IA64_PCREL64I:       rtype = R_IA64_PCREL64I; break;
 495     case BFD_RELOC_IA64_PCREL32MSB:     rtype = R_IA64_PCREL32MSB; break;
 496     case BFD_RELOC_IA64_PCREL32LSB:     rtype = R_IA64_PCREL32LSB; break;
 497     case BFD_RELOC_IA64_PCREL64MSB:     rtype = R_IA64_PCREL64MSB; break;
 498     case BFD_RELOC_IA64_PCREL64LSB:     rtype = R_IA64_PCREL64LSB; break;
 499
 500     case BFD_RELOC_IA64_LTOFF_FPTR22:   rtype = R_IA64_LTOFF_FPTR22; break;
 501     case BFD_RELOC_IA64_LTOFF_FPTR64I:  rtype = R_IA64_LTOFF_FPTR64I; break;
 502     case BFD_RELOC_IA64_LTOFF_FPTR32MSB: rtype = R_IA64_LTOFF_FPTR32MSB; break;
 503     case BFD_RELOC_IA64_LTOFF_FPTR32LSB: rtype = R_IA64_LTOFF_FPTR32LSB; break;
 504     case BFD_RELOC_IA64_LTOFF_FPTR64MSB: rtype = R_IA64_LTOFF_FPTR64MSB; break;
 505     case BFD_RELOC_IA64_LTOFF_FPTR64LSB: rtype = R_IA64_LTOFF_FPTR64LSB; break;
 506
 507     case BFD_RELOC_IA64_SEGREL32MSB:    rtype = R_IA64_SEGREL32MSB; break;
 508     case BFD_RELOC_IA64_SEGREL32LSB:    rtype = R_IA64_SEGREL32LSB; break;
 509     case BFD_RELOC_IA64_SEGREL64MSB:    rtype = R_IA64_SEGREL64MSB; break;
 510     case BFD_RELOC_IA64_SEGREL64LSB:    rtype = R_IA64_SEGREL64LSB; break;
 511
 512     case BFD_RELOC_IA64_SECREL32MSB:    rtype = R_IA64_SECREL32MSB; break;
 513     case BFD_RELOC_IA64_SECREL32LSB:    rtype = R_IA64_SECREL32LSB; break;
 514     case BFD_RELOC_IA64_SECREL64MSB:    rtype = R_IA64_SECREL64MSB; break;
 515     case BFD_RELOC_IA64_SECREL64LSB:    rtype = R_IA64_SECREL64LSB; break;
 516
 517     case BFD_RELOC_IA64_REL32MSB:       rtype = R_IA64_REL32MSB; break;
 518     case BFD_RELOC_IA64_REL32LSB:       rtype = R_IA64_REL32LSB; break;
 519     case BFD_RELOC_IA64_REL64MSB:       rtype = R_IA64_REL64MSB; break;
 520     case BFD_RELOC_IA64_REL64LSB:       rtype = R_IA64_REL64LSB; break;
 521
 522     case BFD_RELOC_IA64_LTV32MSB:       rtype = R_IA64_LTV32MSB; break;
 523     case BFD_RELOC_IA64_LTV32LSB:       rtype = R_IA64_LTV32LSB; break;
 524     case BFD_RELOC_IA64_LTV64MSB:       rtype = R_IA64_LTV64MSB; break;
 525     case BFD_RELOC_IA64_LTV64LSB:       rtype = R_IA64_LTV64LSB; break;
 526
 527     case BFD_RELOC_IA64_IPLTMSB:        rtype = R_IA64_IPLTMSB; break;
 528     case BFD_RELOC_IA64_IPLTLSB:        rtype = R_IA64_IPLTLSB; break;
 529     case BFD_RELOC_IA64_COPY:           rtype = R_IA64_COPY; break;
 530     case BFD_RELOC_IA64_LTOFF22X:       rtype = R_IA64_LTOFF22X; break;
 531     case BFD_RELOC_IA64_LDXMOV:         rtype = R_IA64_LDXMOV; break;
 532
 533     case BFD_RELOC_IA64_TPREL22:        rtype = R_IA64_TPREL22; break;
 534     case BFD_RELOC_IA64_TPREL64MSB:     rtype = R_IA64_TPREL64MSB; break;
 535     case BFD_RELOC_IA64_TPREL64LSB:     rtype = R_IA64_TPREL64LSB; break;
 536     case BFD_RELOC_IA64_LTOFF_TP22:     rtype = R_IA64_LTOFF_TP22; break;
 537
 538     default: return 0;
 539     }
 540   return lookup_howto (rtype);
 541 }
 542
 543 /* Given a ELF reloc, return the matching HOWTO structure.  */
 544
 545 static void
 546 elfNN_ia64_info_to_howto (abfd, bfd_reloc, elf_reloc)
 547      bfd *abfd ATTRIBUTE_UNUSED;
 548      arelent *bfd_reloc;
 549      ElfNN_Internal_Rela *elf_reloc;
 550 {
 551   bfd_reloc->howto
 552     = lookup_howto ((unsigned int) ELFNN_R_TYPE (elf_reloc->r_info));
 553 }
 554 \f
 555 #define PLT_HEADER_SIZE         (3 * 16)
 556 #define PLT_MIN_ENTRY_SIZE      (1 * 16)
 557 #define PLT_FULL_ENTRY_SIZE     (2 * 16)
 558 #define PLT_RESERVED_WORDS      3
 559
 560 static const bfd_byte plt_header[PLT_HEADER_SIZE] =
 561 {
 562   0x0b, 0x10, 0x00, 0x1c, 0x00, 0x21,  /*   [MMI]       mov r2=r14;;       */
 563   0xe0, 0x00, 0x08, 0x00, 0x48, 0x00,  /*               addl r14=0,r2      */
 564   0x00, 0x00, 0x04, 0x00,              /*               nop.i 0x0;;        */
 565   0x0b, 0x80, 0x20, 0x1c, 0x18, 0x14,  /*   [MMI]       ld8 r16=[r14],8;;  */
 566   0x10, 0x41, 0x38, 0x30, 0x28, 0x00,  /*               ld8 r17=[r14],8    */
 567   0x00, 0x00, 0x04, 0x00,              /*               nop.i 0x0;;        */
 568   0x11, 0x08, 0x00, 0x1c, 0x18, 0x10,  /*   [MIB]       ld8 r1=[r14]       */
 569   0x60, 0x88, 0x04, 0x80, 0x03, 0x00,  /*               mov b6=r17         */
 570   0x60, 0x00, 0x80, 0x00               /*               br.few b6;;        */
 571 };
 572
 573 static const bfd_byte plt_min_entry[PLT_MIN_ENTRY_SIZE] =
 574 {
 575   0x11, 0x78, 0x00, 0x00, 0x00, 0x24,  /*   [MIB]       mov r15=0          */
 576   0x00, 0x00, 0x00, 0x02, 0x00, 0x00,  /*               nop.i 0x0          */
 577   0x00, 0x00, 0x00, 0x40               /*               br.few 0 <PLT0>;;  */
 578 };
 579
 580 static const bfd_byte plt_full_entry[PLT_FULL_ENTRY_SIZE] =
 581 {
 582   0x0b, 0x78, 0x00, 0x02, 0x00, 0x24,  /*   [MMI]       addl r15=0,r1;;    */
 583   0x00, 0x41, 0x3c, 0x30, 0x28, 0xc0,  /*               ld8 r16=[r15],8    */
 584   0x01, 0x08, 0x00, 0x84,              /*               mov r14=r1;;       */
 585   0x11, 0x08, 0x00, 0x1e, 0x18, 0x10,  /*   [MIB]       ld8 r1=[r15]       */
 586   0x60, 0x80, 0x04, 0x80, 0x03, 0x00,  /*               mov b6=r16         */
 587   0x60, 0x00, 0x80, 0x00               /*               br.few b6;;        */
 588 };
 589
 590 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
 591 #define AIX_DYNAMIC_INTERPRETER "/usr/lib/ia64l64/libc.so.1"
 592 #define DYNAMIC_INTERPRETER(abfd) \
 593   (elfNN_ia64_aix_vec (abfd->xvec) ? AIX_DYNAMIC_INTERPRETER : ELF_DYNAMIC_INTERPRETER)
 594
 595 /* Select out of range branch fixup type.  Note that Itanium does
 596    not support brl, and so it gets emulated by the kernel.  */
 597 #undef USE_BRL
 598
 599 static const bfd_byte oor_brl[16] =
 600 {
 601   0x05, 0x00, 0x00, 0x00, 0x01, 0x00,  /*  [MLX]        nop.m 0            */
 602   0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /*               brl.sptk.few tgt;; */
 603   0x00, 0x00, 0x00, 0xc0
 604 };
 605
 606 static const bfd_byte oor_ip[48] =
 607 {
 608   0x04, 0x00, 0x00, 0x00, 0x01, 0x00,  /*  [MLX]        nop.m 0            */
 609   0x00, 0x00, 0x00, 0x00, 0x00, 0xe0,  /*               movl r15=0         */
 610   0x01, 0x00, 0x00, 0x60,
 611   0x03, 0x00, 0x00, 0x00, 0x01, 0x00,  /*  [MII]        nop.m 0            */
 612   0x00, 0x01, 0x00, 0x60, 0x00, 0x00,  /*               mov r16=ip;;       */
 613   0xf2, 0x80, 0x00, 0x80,              /*               add r16=r15,r16;;  */
 614   0x11, 0x00, 0x00, 0x00, 0x01, 0x00,  /*  [MIB]        nop.m 0            */
 615   0x60, 0x80, 0x04, 0x80, 0x03, 0x00,  /*               mov b6=r16         */
 616   0x60, 0x00, 0x80, 0x00               /*               br b6;;            */
 617 };
 618 \f
 619 /* These functions do relaxation for IA-64 ELF.
 620
 621    This is primarily to support branches to targets out of range;
 622    relaxation of R_IA64_LTOFF22X and R_IA64_LDXMOV not yet supported.  */
 623
 624 static boolean
 625 elfNN_ia64_relax_section (abfd, sec, link_info, again)
 626      bfd *abfd;
 627      asection *sec;
 628      struct bfd_link_info *link_info;
 629      boolean *again;
 630 {
 631   struct one_fixup
 632     {
 633       struct one_fixup *next;
 634       asection *tsec;
 635       bfd_vma toff;
 636       bfd_vma trampoff;
 637     };
 638
 639   Elf_Internal_Shdr *symtab_hdr;
 640   Elf_Internal_Rela *internal_relocs;
 641   Elf_Internal_Rela *free_relocs = NULL;
 642   Elf_Internal_Rela *irel, *irelend;
 643   bfd_byte *contents;
 644   bfd_byte *free_contents = NULL;
 645   ElfNN_External_Sym *extsyms;
 646   ElfNN_External_Sym *free_extsyms = NULL;
 647   struct elfNN_ia64_link_hash_table *ia64_info;
 648   struct one_fixup *fixups = NULL;
 649   boolean changed_contents = false;
 650   boolean changed_relocs = false;
 651
 652   /* Assume we're not going to change any sizes, and we'll only need
 653      one pass.  */
 654   *again = false;
 655
 656   /* Nothing to do if there are no relocations.  */
 657   if ((sec->flags & SEC_RELOC) == 0
 658       || sec->reloc_count == 0)
 659     return true;
 660
 661   /* If this is the first time we have been called for this section,
 662      initialize the cooked size.  */
 663   if (sec->_cooked_size == 0)
 664     sec->_cooked_size = sec->_raw_size;
 665
 666   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 667
 668   /* Load the relocations for this section.  */
 669   internal_relocs = (_bfd_elfNN_link_read_relocs
 670                      (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
 671                       link_info->keep_memory));
 672   if (internal_relocs == NULL)
 673     goto error_return;
 674
 675   if (! link_info->keep_memory)
 676     free_relocs = internal_relocs;
 677
 678   ia64_info = elfNN_ia64_hash_table (link_info);
 679   irelend = internal_relocs + sec->reloc_count;
 680
 681   for (irel = internal_relocs; irel < irelend; irel++)
 682     if (ELFNN_R_TYPE (irel->r_info) == (int) R_IA64_PCREL21B)
 683       break;
 684
 685   /* No branch-type relocations.  */
 686   if (irel == irelend)
 687     {
 688       if (free_relocs != NULL)
 689         free (free_relocs);
 690       return true;
 691     }
 692
 693   /* Get the section contents.  */
 694   if (elf_section_data (sec)->this_hdr.contents != NULL)
 695     contents = elf_section_data (sec)->this_hdr.contents;
 696   else
 697     {
 698       contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
 699       if (contents == NULL)
 700         goto error_return;
 701       free_contents = contents;
 702
 703       if (! bfd_get_section_contents (abfd, sec, contents,
 704                                       (file_ptr) 0, sec->_raw_size))
 705         goto error_return;
 706     }
 707
 708   /* Read this BFD's symbols.  */
 709   if (symtab_hdr->contents != NULL)
 710     extsyms = (ElfNN_External_Sym *) symtab_hdr->contents;
 711   else
 712     {
 713       extsyms = (ElfNN_External_Sym *) bfd_malloc (symtab_hdr->sh_size);
 714       if (extsyms == NULL)
 715         goto error_return;
 716       free_extsyms = extsyms;
 717       if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
 718           || (bfd_bread (extsyms, symtab_hdr->sh_size, abfd)
 719               != symtab_hdr->sh_size))
 720         goto error_return;
 721     }
 722
 723   for (; irel < irelend; irel++)
 724     {
 725       bfd_vma symaddr, reladdr, trampoff, toff, roff;
 726       Elf_Internal_Sym isym;
 727       asection *tsec;
 728       struct one_fixup *f;
 729       bfd_size_type amt;
 730
 731       if (ELFNN_R_TYPE (irel->r_info) != (int) R_IA64_PCREL21B)
 732         continue;
 733
 734       /* Get the value of the symbol referred to by the reloc.  */
 735       if (ELFNN_R_SYM (irel->r_info) < symtab_hdr->sh_info)
 736         {
 737           /* A local symbol.  */
 738           bfd_elfNN_swap_symbol_in (abfd,
 739                                     extsyms + ELFNN_R_SYM (irel->r_info),
 740                                     &isym);
 741           if (isym.st_shndx == SHN_UNDEF)
 742             continue;   /* We can't do anthing with undefined symbols.  */
 743           else if (isym.st_shndx == SHN_ABS)
 744             tsec = bfd_abs_section_ptr;
 745           else if (isym.st_shndx == SHN_COMMON)
 746             tsec = bfd_com_section_ptr;
 747           else if (isym.st_shndx > 0 && isym.st_shndx < SHN_LORESERVE)
 748             tsec = bfd_section_from_elf_index (abfd, isym.st_shndx);
 749           else
 750             continue;   /* who knows.  */
 751
 752           toff = isym.st_value;
 753         }
 754       else
 755         {
 756           unsigned long indx;
 757           struct elf_link_hash_entry *h;
 758           struct elfNN_ia64_dyn_sym_info *dyn_i;
 759
 760           indx = ELFNN_R_SYM (irel->r_info) - symtab_hdr->sh_info;
 761           h = elf_sym_hashes (abfd)[indx];
 762           BFD_ASSERT (h != NULL);
 763
 764           while (h->root.type == bfd_link_hash_indirect
 765                  || h->root.type == bfd_link_hash_warning)
 766             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 767
 768           dyn_i = get_dyn_sym_info (ia64_info, h, abfd, irel, false);
 769
 770           /* For branches to dynamic symbols, we're interested instead
 771              in a branch to the PLT entry.  */
 772           if (dyn_i && dyn_i->want_plt2)
 773             {
 774               tsec = ia64_info->plt_sec;
 775               toff = dyn_i->plt2_offset;
 776             }
 777           else
 778             {
 779               /* We can't do anthing with undefined symbols.  */
 780               if (h->root.type == bfd_link_hash_undefined
 781                   || h->root.type == bfd_link_hash_undefweak)
 782                 continue;
 783
 784               tsec = h->root.u.def.section;
 785               toff = h->root.u.def.value;
 786             }
 787         }
 788
 789       symaddr = (tsec->output_section->vma
 790                  + tsec->output_offset
 791                  + toff
 792                  + irel->r_addend);
 793
 794       roff = irel->r_offset;
 795       reladdr = (sec->output_section->vma
 796                  + sec->output_offset
 797                  + roff) & (bfd_vma) -4;
 798
 799       /* If the branch is in range, no need to do anything.  */
 800       if ((bfd_signed_vma) (symaddr - reladdr) >= -0x1000000
 801           && (bfd_signed_vma) (symaddr - reladdr) <= 0x0FFFFF0)
 802         continue;
 803
 804       /* If the branch and target are in the same section, you've
 805          got one honking big section and we can't help you.  You'll
 806          get an error message later.  */
 807       if (tsec == sec)
 808         continue;
 809
 810       /* Look for an existing fixup to this address.  */
 811       for (f = fixups; f ; f = f->next)
 812         if (f->tsec == tsec && f->toff == toff)
 813           break;
 814
 815       if (f == NULL)
 816         {
 817           /* Two alternatives: If it's a branch to a PLT entry, we can
 818              make a copy of the FULL_PLT entry.  Otherwise, we'll have
 819              to use a `brl' insn to get where we're going.  */
 820
 821           size_t size;
 822
 823           if (tsec == ia64_info->plt_sec)
 824             size = sizeof (plt_full_entry);
 825           else
 826             {
 827 #ifdef USE_BRL
 828               size = sizeof (oor_brl);
 829 #else
 830               size = sizeof (oor_ip);
 831 #endif
 832             }
 833
 834           /* Resize the current section to make room for the new branch.  */
 835           trampoff = (sec->_cooked_size + 15) & (bfd_vma) -16;
 836           amt = trampoff + size;
 837           contents = (bfd_byte *) bfd_realloc (contents, amt);
 838           if (contents == NULL)
 839             goto error_return;
 840           sec->_cooked_size = amt;
 841
 842           if (tsec == ia64_info->plt_sec)
 843             {
 844               memcpy (contents + trampoff, plt_full_entry, size);
 845
 846               /* Hijack the old relocation for use as the PLTOFF reloc.  */
 847               irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
 848                                            R_IA64_PLTOFF22);
 849               irel->r_offset = trampoff;
 850             }
 851           else
 852             {
 853 #ifdef USE_BRL
 854               memcpy (contents + trampoff, oor_brl, size);
 855               irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
 856                                            R_IA64_PCREL60B);
 857               irel->r_offset = trampoff + 2;
 858 #else
 859               memcpy (contents + trampoff, oor_ip, size);
 860               irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
 861                                            R_IA64_PCREL64I);
 862               irel->r_addend -= 16;
 863               irel->r_offset = trampoff + 2;
 864 #endif
 865             }
 866
 867           /* Record the fixup so we don't do it again this section.  */
 868           f = (struct one_fixup *) bfd_malloc ((bfd_size_type) sizeof (*f));
 869           f->next = fixups;
 870           f->tsec = tsec;
 871           f->toff = toff;
 872           f->trampoff = trampoff;
 873           fixups = f;
 874         }
 875       else
 876         {
 877           /* Nop out the reloc, since we're finalizing things here.  */
 878           irel->r_info = ELFNN_R_INFO (0, R_IA64_NONE);
 879         }
 880
 881       /* Fix up the existing branch to hit the trampoline.  Hope like
 882          hell this doesn't overflow too.  */
 883       if (elfNN_ia64_install_value (abfd, contents + roff,
 884                                     f->trampoff - (roff & (bfd_vma) -4),
 885                                     R_IA64_PCREL21B) != bfd_reloc_ok)
 886         goto error_return;
 887
 888       changed_contents = true;
 889       changed_relocs = true;
 890     }
 891
 892   /* Clean up and go home.  */
 893   while (fixups)
 894     {
 895       struct one_fixup *f = fixups;
 896       fixups = fixups->next;
 897       free (f);
 898     }
 899
 900   if (changed_relocs)
 901     elf_section_data (sec)->relocs = internal_relocs;
 902   else if (free_relocs != NULL)
 903     free (free_relocs);
 904
 905   if (changed_contents)
 906     elf_section_data (sec)->this_hdr.contents = contents;
 907   else if (free_contents != NULL)
 908     {
 909       if (! link_info->keep_memory)
 910         free (free_contents);
 911       else
 912         {
 913           /* Cache the section contents for elf_link_input_bfd.  */
 914           elf_section_data (sec)->this_hdr.contents = contents;
 915         }
 916     }
 917
 918   if (free_extsyms != NULL)
 919     {
 920       if (! link_info->keep_memory)
 921         free (free_extsyms);
 922       else
 923         {
 924           /* Cache the symbols for elf_link_input_bfd.  */
 925           symtab_hdr->contents = (unsigned char *) extsyms;
 926         }
 927     }
 928
 929   *again = changed_contents || changed_relocs;
 930   return true;
 931
 932  error_return:
 933   if (free_relocs != NULL)
 934     free (free_relocs);
 935   if (free_contents != NULL)
 936     free (free_contents);
 937   if (free_extsyms != NULL)
 938     free (free_extsyms);
 939   return false;
 940 }
 941 \f
 942 /* Return true if NAME is an unwind table section name.  */
 943
 944 static inline boolean
 945 is_unwind_section_name (name)
 946         const char *name;
 947 {
 948   size_t len1, len2, len3;
 949
 950   len1 = sizeof (ELF_STRING_ia64_unwind) - 1;
 951   len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
 952   len3 = sizeof (ELF_STRING_ia64_unwind_once) - 1;
 953   return ((strncmp (name, ELF_STRING_ia64_unwind, len1) == 0
 954            && strncmp (name, ELF_STRING_ia64_unwind_info, len2) != 0)
 955           || strncmp (name, ELF_STRING_ia64_unwind_once, len3) == 0);
 956 }
 957
 958 /* Handle an IA-64 specific section when reading an object file.  This
 959    is called when elfcode.h finds a section with an unknown type.  */
 960
 961 static boolean
 962 elfNN_ia64_section_from_shdr (abfd, hdr, name)
 963      bfd *abfd;
 964      ElfNN_Internal_Shdr *hdr;
 965      char *name;
 966 {
 967   asection *newsect;
 968
 969   /* There ought to be a place to keep ELF backend specific flags, but
 970      at the moment there isn't one.  We just keep track of the
 971      sections by their name, instead.  Fortunately, the ABI gives
 972      suggested names for all the MIPS specific sections, so we will
 973      probably get away with this.  */
 974   switch (hdr->sh_type)
 975     {
 976     case SHT_IA_64_UNWIND:
 977       break;
 978
 979     case SHT_IA_64_EXT:
 980       if (strcmp (name, ELF_STRING_ia64_archext) != 0)
 981         return false;
 982       break;
 983
 984     default:
 985       return false;
 986     }
 987
 988   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
 989     return false;
 990   newsect = hdr->bfd_section;
 991
 992   return true;
 993 }
 994
 995 /* Convert IA-64 specific section flags to bfd internal section flags.  */
 996
 997 /* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
 998    flag.  */
 999
1000 static boolean
1001 elfNN_ia64_section_flags (flags, hdr)
1002      flagword *flags;
1003      ElfNN_Internal_Shdr *hdr;
1004 {
1005   if (hdr->sh_flags & SHF_IA_64_SHORT)
1006     *flags |= SEC_SMALL_DATA;
1007
1008   return true;
1009 }
1010
1011 /* Set the correct type for an IA-64 ELF section.  We do this by the
1012    section name, which is a hack, but ought to work.  */
1013
1014 static boolean
1015 elfNN_ia64_fake_sections (abfd, hdr, sec)
1016      bfd *abfd ATTRIBUTE_UNUSED;
1017      ElfNN_Internal_Shdr *hdr;
1018      asection *sec;
1019 {
1020   register const char *name;
1021
1022   name = bfd_get_section_name (abfd, sec);
1023
1024   if (is_unwind_section_name (name))
1025     {
1026       /* We don't have the sections numbered at this point, so sh_info
1027          is set later, in elfNN_ia64_final_write_processing.  */
1028       hdr->sh_type = SHT_IA_64_UNWIND;
1029       hdr->sh_flags |= SHF_LINK_ORDER;
1030     }
1031   else if (strcmp (name, ELF_STRING_ia64_archext) == 0)
1032     hdr->sh_type = SHT_IA_64_EXT;
1033   else if (strcmp (name, ".reloc") == 0)
1034     /*
1035      * This is an ugly, but unfortunately necessary hack that is
1036      * needed when producing EFI binaries on IA-64. It tells
1037      * elf.c:elf_fake_sections() not to consider ".reloc" as a section
1038      * containing ELF relocation info.  We need this hack in order to
1039      * be able to generate ELF binaries that can be translated into
1040      * EFI applications (which are essentially COFF objects).  Those
1041      * files contain a COFF ".reloc" section inside an ELFNN object,
1042      * which would normally cause BFD to segfault because it would
1043      * attempt to interpret this section as containing relocation
1044      * entries for section "oc".  With this hack enabled, ".reloc"
1045      * will be treated as a normal data section, which will avoid the
1046      * segfault.  However, you won't be able to create an ELFNN binary
1047      * with a section named "oc" that needs relocations, but that's
1048      * the kind of ugly side-effects you get when detecting section
1049      * types based on their names...  In practice, this limitation is
1050      * unlikely to bite.
1051      */
1052     hdr->sh_type = SHT_PROGBITS;
1053
1054   if (sec->flags & SEC_SMALL_DATA)
1055     hdr->sh_flags |= SHF_IA_64_SHORT;
1056
1057   return true;
1058 }
1059
1060 /* The final processing done just before writing out an IA-64 ELF
1061    object file.  */
1062
1063 static void
1064 elfNN_ia64_final_write_processing (abfd, linker)
1065      bfd *abfd;
1066      boolean linker ATTRIBUTE_UNUSED;
1067 {
1068   Elf_Internal_Shdr *hdr;
1069   const char *sname;
1070   asection *text_sect, *s;
1071   size_t len;
1072
1073   for (s = abfd->sections; s; s = s->next)
1074     {
1075       hdr = &elf_section_data (s)->this_hdr;
1076       switch (hdr->sh_type)
1077         {
1078         case SHT_IA_64_UNWIND:
1079           /* See comments in gas/config/tc-ia64.c:dot_endp on why we
1080              have to do this.  */
1081           sname = bfd_get_section_name (abfd, s);
1082           len = sizeof (ELF_STRING_ia64_unwind) - 1;
1083           if (sname && strncmp (sname, ELF_STRING_ia64_unwind, len) == 0)
1084             {
1085               sname += len;
1086
1087               if (sname[0] == '\0')
1088                 /* .IA_64.unwind -> .text */
1089                 text_sect = bfd_get_section_by_name (abfd, ".text");
1090               else
1091                 /* .IA_64.unwindFOO -> FOO */
1092                 text_sect = bfd_get_section_by_name (abfd, sname);
1093             }
1094           else if (sname
1095                    && (len = sizeof (ELF_STRING_ia64_unwind_once) - 1,
1096                        strncmp (sname, ELF_STRING_ia64_unwind_once, len)) == 0)
1097             {
1098               /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.t.FOO */
1099               size_t len2 = sizeof (".gnu.linkonce.t.") - 1;
1100               char *once_name = alloca (len2 + strlen (sname) - len + 1);
1101
1102               memcpy (once_name, ".gnu.linkonce.t.", len2);
1103               strcpy (once_name + len2, sname + len);
1104               text_sect = bfd_get_section_by_name (abfd, once_name);
1105             }
1106           else
1107             /* last resort: fall back on .text */
1108             text_sect = bfd_get_section_by_name (abfd, ".text");
1109
1110           if (text_sect)
1111             {
1112               /* The IA-64 processor-specific ABI requires setting
1113                  sh_link to the unwind section, whereas HP-UX requires
1114                  sh_info to do so.  For maximum compatibility, we'll
1115                  set both for now... */
1116               hdr->sh_link = elf_section_data (text_sect)->this_idx;
1117               hdr->sh_info = elf_section_data (text_sect)->this_idx;
1118             }
1119           break;
1120         }
1121     }
1122 }
1123
1124 /* Hook called by the linker routine which adds symbols from an object
1125    file.  We use it to put .comm items in .sbss, and not .bss.  */
1126
1127 static boolean
1128 elfNN_ia64_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1129      bfd *abfd;
1130      struct bfd_link_info *info;
1131      const Elf_Internal_Sym *sym;
1132      const char **namep ATTRIBUTE_UNUSED;
1133      flagword *flagsp ATTRIBUTE_UNUSED;
1134      asection **secp;
1135      bfd_vma *valp;
1136 {
1137   if (sym->st_shndx == SHN_COMMON
1138       && !info->relocateable
1139       && sym->st_size <= elf_gp_size (abfd))
1140     {
1141       /* Common symbols less than or equal to -G nn bytes are
1142          automatically put into .sbss.  */
1143
1144       asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1145
1146       if (scomm == NULL)
1147         {
1148           scomm = bfd_make_section (abfd, ".scommon");
1149           if (scomm == NULL
1150               || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
1151                                                        | SEC_IS_COMMON
1152                                                        | SEC_LINKER_CREATED)))
1153             return false;
1154         }
1155
1156       *secp = scomm;
1157       *valp = sym->st_size;
1158     }
1159
1160   return true;
1161 }
1162
1163 static boolean
1164 elfNN_ia64_aix_vec (const bfd_target *vec)
1165 {
1166   extern const bfd_target bfd_elfNN_ia64_aix_little_vec;
1167   extern const bfd_target bfd_elfNN_ia64_aix_big_vec;
1168
1169   return (/**/vec == & bfd_elfNN_ia64_aix_little_vec
1170           ||  vec == & bfd_elfNN_ia64_aix_big_vec);
1171 }
1172
1173 /* Hook called by the linker routine which adds symbols from an object
1174    file.  We use it to handle OS-specific symbols.  */
1175
1176 static boolean
1177 elfNN_ia64_aix_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1178      bfd *abfd;
1179      struct bfd_link_info *info;
1180      const Elf_Internal_Sym *sym;
1181      const char **namep;
1182      flagword *flagsp;
1183      asection **secp;
1184      bfd_vma *valp;
1185 {
1186   if (strcmp (*namep, "__GLOB_DATA_PTR") == 0)
1187     {
1188       /* Define __GLOB_DATA_PTR when it is encountered.  This is expected to
1189          be a linker-defined symbol by the Aix C runtime startup code. IBM sez
1190          no one else should use it b/c it is undocumented.  */
1191       struct elf_link_hash_entry *h;
1192
1193       h = elf_link_hash_lookup (elf_hash_table (info), *namep,
1194                                 false, false, false);
1195       if (h == NULL)
1196         {
1197           struct elf_backend_data *bed;
1198           struct elfNN_ia64_link_hash_table *ia64_info;
1199
1200           bed = get_elf_backend_data (abfd);
1201           ia64_info = elfNN_ia64_hash_table (info);
1202
1203           if (!(_bfd_generic_link_add_one_symbol
1204                 (info, abfd, *namep, BSF_GLOBAL,
1205                  bfd_get_section_by_name (abfd, ".bss"),
1206                  bed->got_symbol_offset, (const char *) NULL, false,
1207                  bed->collect, (struct bfd_link_hash_entry **) &h)))
1208             return false;
1209
1210           h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1211           h->type = STT_OBJECT;
1212
1213           if (! _bfd_elf_link_record_dynamic_symbol (info, h))
1214             return false;
1215         }
1216
1217       return true;
1218     }
1219   else if (sym->st_shndx == SHN_LOOS)
1220     {
1221       int i;
1222
1223       /* SHN_AIX_SYSCALL: Treat this as any other symbol.  The special symbol
1224          is only relevant when compiling code for extended system calls.
1225          Replace the "special" section with .text, if possible.
1226          Note that these symbols are always assumed to be in .text. */
1227       for (i = 1; i < elf_elfheader (abfd)->e_shnum; i++)
1228         {
1229           asection * sec = bfd_section_from_elf_index (abfd, (unsigned) i);
1230
1231           if (sec && strcmp (sec->name, ".text") == 0)
1232             {
1233               *secp = sec;
1234               break;
1235             }
1236         }
1237
1238       if (*secp == NULL)
1239         *secp = bfd_abs_section_ptr;
1240
1241       *valp = sym->st_size;
1242
1243       return true;
1244     }
1245   else
1246     {
1247       return elfNN_ia64_add_symbol_hook (abfd, info, sym,
1248                                          namep, flagsp, secp, valp);
1249     }
1250 }
1251
1252 boolean
1253 elfNN_ia64_aix_link_add_symbols (abfd, info)
1254      bfd *abfd;
1255      struct bfd_link_info *info;
1256 {
1257   /* Make sure dynamic sections are always created.  */
1258   if (! elf_hash_table (info)->dynamic_sections_created
1259       && abfd->xvec == info->hash->creator)
1260     {
1261       if (! bfd_elfNN_link_create_dynamic_sections (abfd, info))
1262         return false;
1263     }
1264
1265   /* Now do the standard call.  */
1266   return bfd_elfNN_bfd_link_add_symbols (abfd, info);
1267 }
1268
1269 /* Return the number of additional phdrs we will need.  */
1270
1271 static int
1272 elfNN_ia64_additional_program_headers (abfd)
1273      bfd *abfd;
1274 {
1275   asection *s;
1276   int ret = 0;
1277
1278   /* See if we need a PT_IA_64_ARCHEXT segment.  */
1279   s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_archext);
1280   if (s && (s->flags & SEC_LOAD))
1281     ++ret;
1282
1283   /* Count how many PT_IA_64_UNWIND segments we need.  */
1284   for (s = abfd->sections; s; s = s->next)
1285     if (is_unwind_section_name(s->name) && (s->flags & SEC_LOAD))
1286       ++ret;
1287
1288   return ret;
1289 }
1290
1291 static boolean
1292 elfNN_ia64_modify_segment_map (abfd)
1293      bfd *abfd;
1294 {
1295   struct elf_segment_map *m, **pm;
1296   Elf_Internal_Shdr *hdr;
1297   asection *s;
1298
1299   /* If we need a PT_IA_64_ARCHEXT segment, it must come before
1300      all PT_LOAD segments.  */
1301   s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_archext);
1302   if (s && (s->flags & SEC_LOAD))
1303     {
1304       for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
1305         if (m->p_type == PT_IA_64_ARCHEXT)
1306           break;
1307       if (m == NULL)
1308         {
1309           m = ((struct elf_segment_map *)
1310                bfd_zalloc (abfd, (bfd_size_type) sizeof *m));
1311           if (m == NULL)
1312             return false;
1313
1314           m->p_type = PT_IA_64_ARCHEXT;
1315           m->count = 1;
1316           m->sections[0] = s;
1317
1318           /* We want to put it after the PHDR and INTERP segments.  */
1319           pm = &elf_tdata (abfd)->segment_map;
1320           while (*pm != NULL
1321                  && ((*pm)->p_type == PT_PHDR
1322                      || (*pm)->p_type == PT_INTERP))
1323             pm = &(*pm)->next;
1324
1325           m->next = *pm;
1326           *pm = m;
1327         }
1328     }
1329
1330   /* Install PT_IA_64_UNWIND segments, if needed.  */
1331   for (s = abfd->sections; s; s = s->next)
1332     {
1333       hdr = &elf_section_data (s)->this_hdr;
1334       if (hdr->sh_type != SHT_IA_64_UNWIND)
1335         continue;
1336
1337       if (s && (s->flags & SEC_LOAD))
1338         {
1339           for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
1340             if (m->p_type == PT_IA_64_UNWIND && m->sections[0] == s)
1341               break;
1342
1343           if (m == NULL)
1344             {
1345               m = ((struct elf_segment_map *)
1346                    bfd_zalloc (abfd, (bfd_size_type) sizeof *m));
1347               if (m == NULL)
1348                 return false;
1349
1350               m->p_type = PT_IA_64_UNWIND;
1351               m->count = 1;
1352               m->sections[0] = s;
1353               m->next = NULL;
1354
1355               /* We want to put it last.  */
1356               pm = &elf_tdata (abfd)->segment_map;
1357               while (*pm != NULL)
1358                 pm = &(*pm)->next;
1359               *pm = m;
1360             }
1361         }
1362     }
1363
1364   /* Turn on PF_IA_64_NORECOV if needed.  This involves traversing all of
1365      the input sections for each output section in the segment and testing
1366      for SHF_IA_64_NORECOV on each.  */
1367   for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
1368     if (m->p_type == PT_LOAD)
1369       {
1370         int i;
1371         for (i = m->count - 1; i >= 0; --i)
1372           {
1373             struct bfd_link_order *order = m->sections[i]->link_order_head;
1374             while (order)
1375               {
1376                 if (order->type == bfd_indirect_link_order)
1377                   {
1378                     asection *is = order->u.indirect.section;
1379                     bfd_vma flags = elf_section_data(is)->this_hdr.sh_flags;
1380                     if (flags & SHF_IA_64_NORECOV)
1381                       {
1382                         m->p_flags |= PF_IA_64_NORECOV;
1383                         goto found;
1384                       }
1385                   }
1386                 order = order->next;
1387               }
1388           }
1389       found:;
1390       }
1391
1392   return true;
1393 }
1394
1395 /* According to the Tahoe assembler spec, all labels starting with a
1396    '.' are local.  */
1397
1398 static boolean
1399 elfNN_ia64_is_local_label_name (abfd, name)
1400      bfd *abfd ATTRIBUTE_UNUSED;
1401      const char *name;
1402 {
1403   return name[0] == '.';
1404 }
1405
1406 /* Should we do dynamic things to this symbol?  */
1407
1408 static boolean
1409 elfNN_ia64_dynamic_symbol_p (h, info)
1410      struct elf_link_hash_entry *h;
1411      struct bfd_link_info *info;
1412 {
1413   if (h == NULL)
1414     return false;
1415
1416   while (h->root.type == bfd_link_hash_indirect
1417          || h->root.type == bfd_link_hash_warning)
1418     h = (struct elf_link_hash_entry *) h->root.u.i.link;
1419
1420   if (h->dynindx == -1)
1421     return false;
1422   switch (ELF_ST_VISIBILITY (h->other))
1423     {
1424     case STV_INTERNAL:
1425     case STV_HIDDEN:
1426       return false;
1427     }
1428
1429   if (h->root.type == bfd_link_hash_undefweak
1430       || h->root.type == bfd_link_hash_defweak)
1431     return true;
1432
1433   if ((info->shared && (!info->symbolic || info->allow_shlib_undefined))
1434       || ((h->elf_link_hash_flags
1435            & (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR))
1436           == (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR)))
1437     return true;
1438
1439   return false;
1440 }
1441 \f
1442 static boolean
1443 elfNN_ia64_local_hash_table_init (ht, abfd, new)
1444      struct elfNN_ia64_local_hash_table *ht;
1445      bfd *abfd ATTRIBUTE_UNUSED;
1446      new_hash_entry_func new;
1447 {
1448   memset (ht, 0, sizeof (*ht));
1449   return bfd_hash_table_init (&ht->root, new);
1450 }
1451
1452 static struct bfd_hash_entry*
1453 elfNN_ia64_new_loc_hash_entry (entry, table, string)
1454      struct bfd_hash_entry *entry;
1455      struct bfd_hash_table *table;
1456      const char *string;
1457 {
1458   struct elfNN_ia64_local_hash_entry *ret;
1459   ret = (struct elfNN_ia64_local_hash_entry *) entry;
1460
1461   /* Allocate the structure if it has not already been allocated by a
1462      subclass.  */
1463   if (!ret)
1464     ret = bfd_hash_allocate (table, sizeof (*ret));
1465
1466   if (!ret)
1467     return 0;
1468
1469   /* Initialize our local data.  All zeros, and definitely easier
1470      than setting a handful of bit fields.  */
1471   memset (ret, 0, sizeof (*ret));
1472
1473   /* Call the allocation method of the superclass.  */
1474   ret = ((struct elfNN_ia64_local_hash_entry *)
1475          bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
1476
1477   return (struct bfd_hash_entry *) ret;
1478 }
1479
1480 static struct bfd_hash_entry*
1481 elfNN_ia64_new_elf_hash_entry (entry, table, string)
1482      struct bfd_hash_entry *entry;
1483      struct bfd_hash_table *table;
1484      const char *string;
1485 {
1486   struct elfNN_ia64_link_hash_entry *ret;
1487   ret = (struct elfNN_ia64_link_hash_entry *) entry;
1488
1489   /* Allocate the structure if it has not already been allocated by a
1490      subclass.  */
1491   if (!ret)
1492     ret = bfd_hash_allocate (table, sizeof (*ret));
1493
1494   if (!ret)
1495     return 0;
1496
1497   /* Initialize our local data.  All zeros, and definitely easier
1498      than setting a handful of bit fields.  */
1499   memset (ret, 0, sizeof (*ret));
1500
1501   /* Call the allocation method of the superclass.  */
1502   ret = ((struct elfNN_ia64_link_hash_entry *)
1503          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1504                                      table, string));
1505
1506   return (struct bfd_hash_entry *) ret;
1507 }
1508
1509 static void
1510 elfNN_ia64_hash_copy_indirect (xdir, xind)
1511      struct elf_link_hash_entry *xdir, *xind;
1512 {
1513   struct elfNN_ia64_link_hash_entry *dir, *ind;
1514
1515   dir = (struct elfNN_ia64_link_hash_entry *) xdir;
1516   ind = (struct elfNN_ia64_link_hash_entry *) xind;
1517
1518   /* Copy down any references that we may have already seen to the
1519      symbol which just became indirect.  */
1520
1521   dir->root.elf_link_hash_flags |=
1522     (ind->root.elf_link_hash_flags
1523      & (ELF_LINK_HASH_REF_DYNAMIC
1524         | ELF_LINK_HASH_REF_REGULAR
1525         | ELF_LINK_HASH_REF_REGULAR_NONWEAK));
1526
1527   if (ind->root.root.type != bfd_link_hash_indirect)
1528     return;
1529
1530   /* Copy over the got and plt data.  This would have been done
1531      by check_relocs.  */
1532
1533   if (dir->info == NULL)
1534     {
1535       struct elfNN_ia64_dyn_sym_info *dyn_i;
1536
1537       dir->info = dyn_i = ind->info;
1538       ind->info = NULL;
1539
1540       /* Fix up the dyn_sym_info pointers to the global symbol.  */
1541       for (; dyn_i; dyn_i = dyn_i->next)
1542         dyn_i->h = &dir->root;
1543     }
1544   BFD_ASSERT (ind->info == NULL);
1545
1546   /* Copy over the dynindx.  */
1547
1548   if (dir->root.dynindx == -1)
1549     {
1550       dir->root.dynindx = ind->root.dynindx;
1551       dir->root.dynstr_index = ind->root.dynstr_index;
1552       ind->root.dynindx = -1;
1553       ind->root.dynstr_index = 0;
1554     }
1555   BFD_ASSERT (ind->root.dynindx == -1);
1556 }
1557
1558 static void
1559 elfNN_ia64_hash_hide_symbol (info, xh)
1560      struct bfd_link_info *info ATTRIBUTE_UNUSED;
1561      struct elf_link_hash_entry *xh;
1562 {
1563   struct elfNN_ia64_link_hash_entry *h;
1564   struct elfNN_ia64_dyn_sym_info *dyn_i;
1565
1566   h = (struct elfNN_ia64_link_hash_entry *)xh;
1567
1568   h->root.elf_link_hash_flags &= ~ELF_LINK_HASH_NEEDS_PLT;
1569   if ((h->root.elf_link_hash_flags & ELF_LINK_FORCED_LOCAL) != 0)
1570     h->root.dynindx = -1;
1571
1572   for (dyn_i = h->info; dyn_i; dyn_i = dyn_i->next)
1573     dyn_i->want_plt2 = 0;
1574 }
1575
1576 /* Create the derived linker hash table.  The IA-64 ELF port uses this
1577    derived hash table to keep information specific to the IA-64 ElF
1578    linker (without using static variables).  */
1579
1580 static struct bfd_link_hash_table*
1581 elfNN_ia64_hash_table_create (abfd)
1582      bfd *abfd;
1583 {
1584   struct elfNN_ia64_link_hash_table *ret;
1585
1586   ret = bfd_zalloc (abfd, (bfd_size_type) sizeof (*ret));
1587   if (!ret)
1588     return 0;
1589   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
1590                                       elfNN_ia64_new_elf_hash_entry))
1591     {
1592       bfd_release (abfd, ret);
1593       return 0;
1594     }
1595
1596   if (!elfNN_ia64_local_hash_table_init (&ret->loc_hash_table, abfd,
1597                                          elfNN_ia64_new_loc_hash_entry))
1598     return 0;
1599   return &ret->root.root;
1600 }
1601
1602 /* Look up an entry in a Alpha ELF linker hash table.  */
1603
1604 static INLINE struct elfNN_ia64_local_hash_entry *
1605 elfNN_ia64_local_hash_lookup(table, string, create, copy)
1606      struct elfNN_ia64_local_hash_table *table;
1607      const char *string;
1608      boolean create, copy;
1609 {
1610   return ((struct elfNN_ia64_local_hash_entry *)
1611           bfd_hash_lookup (&table->root, string, create, copy));
1612 }
1613
1614 /* Traverse both local and global hash tables.  */
1615
1616 struct elfNN_ia64_dyn_sym_traverse_data
1617 {
1618   boolean (*func) PARAMS ((struct elfNN_ia64_dyn_sym_info *, PTR));
1619   PTR data;
1620 };
1621
1622 static boolean
1623 elfNN_ia64_global_dyn_sym_thunk (xentry, xdata)
1624      struct bfd_hash_entry *xentry;
1625      PTR xdata;
1626 {
1627   struct elfNN_ia64_link_hash_entry *entry
1628     = (struct elfNN_ia64_link_hash_entry *) xentry;
1629   struct elfNN_ia64_dyn_sym_traverse_data *data
1630     = (struct elfNN_ia64_dyn_sym_traverse_data *) xdata;
1631   struct elfNN_ia64_dyn_sym_info *dyn_i;
1632
1633   for (dyn_i = entry->info; dyn_i; dyn_i = dyn_i->next)
1634     if (! (*data->func) (dyn_i, data->data))
1635       return false;
1636   return true;
1637 }
1638
1639 static boolean
1640 elfNN_ia64_local_dyn_sym_thunk (xentry, xdata)
1641      struct bfd_hash_entry *xentry;
1642      PTR xdata;
1643 {
1644   struct elfNN_ia64_local_hash_entry *entry
1645     = (struct elfNN_ia64_local_hash_entry *) xentry;
1646   struct elfNN_ia64_dyn_sym_traverse_data *data
1647     = (struct elfNN_ia64_dyn_sym_traverse_data *) xdata;
1648   struct elfNN_ia64_dyn_sym_info *dyn_i;
1649
1650   for (dyn_i = entry->info; dyn_i; dyn_i = dyn_i->next)
1651     if (! (*data->func) (dyn_i, data->data))
1652       return false;
1653   return true;
1654 }
1655
1656 static void
1657 elfNN_ia64_dyn_sym_traverse (ia64_info, func, data)
1658      struct elfNN_ia64_link_hash_table *ia64_info;
1659      boolean (*func) PARAMS ((struct elfNN_ia64_dyn_sym_info *, PTR));
1660      PTR data;
1661 {
1662   struct elfNN_ia64_dyn_sym_traverse_data xdata;
1663
1664   xdata.func = func;
1665   xdata.data = data;
1666
1667   elf_link_hash_traverse (&ia64_info->root,
1668                           elfNN_ia64_global_dyn_sym_thunk, &xdata);
1669   bfd_hash_traverse (&ia64_info->loc_hash_table.root,
1670                      elfNN_ia64_local_dyn_sym_thunk, &xdata);
1671 }
1672 \f
1673 static boolean
1674 elfNN_ia64_create_dynamic_sections (abfd, info)
1675      bfd *abfd;
1676      struct bfd_link_info *info;
1677 {
1678   struct elfNN_ia64_link_hash_table *ia64_info;
1679   asection *s;
1680
1681   if (! _bfd_elf_create_dynamic_sections (abfd, info))
1682     return false;
1683
1684   ia64_info = elfNN_ia64_hash_table (info);
1685
1686   ia64_info->plt_sec = bfd_get_section_by_name (abfd, ".plt");
1687   ia64_info->got_sec = bfd_get_section_by_name (abfd, ".got");
1688
1689   {
1690     flagword flags = bfd_get_section_flags (abfd, ia64_info->got_sec);
1691     bfd_set_section_flags (abfd, ia64_info->got_sec, SEC_SMALL_DATA | flags);
1692   }
1693
1694   if (!get_pltoff (abfd, info, ia64_info))
1695     return false;
1696
1697   s = bfd_make_section(abfd, ".rela.IA_64.pltoff");
1698   if (s == NULL
1699       || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1700                                            | SEC_HAS_CONTENTS
1701                                            | SEC_IN_MEMORY
1702                                            | SEC_LINKER_CREATED
1703                                            | SEC_READONLY))
1704       || !bfd_set_section_alignment (abfd, s, 3))
1705     return false;
1706   ia64_info->rel_pltoff_sec = s;
1707
1708   s = bfd_make_section(abfd, ".rela.got");
1709   if (s == NULL
1710       || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1711                                            | SEC_HAS_CONTENTS
1712                                            | SEC_IN_MEMORY
1713                                            | SEC_LINKER_CREATED
1714                                            | SEC_READONLY))
1715       || !bfd_set_section_alignment (abfd, s, 3))
1716     return false;
1717   ia64_info->rel_got_sec = s;
1718
1719   return true;
1720 }
1721
1722 /* Find and/or create a descriptor for dynamic symbol info.  This will
1723    vary based on global or local symbol, and the addend to the reloc.  */
1724
1725 static struct elfNN_ia64_dyn_sym_info *
1726 get_dyn_sym_info (ia64_info, h, abfd, rel, create)
1727      struct elfNN_ia64_link_hash_table *ia64_info;
1728      struct elf_link_hash_entry *h;
1729      bfd *abfd;
1730      const Elf_Internal_Rela *rel;
1731      boolean create;
1732 {
1733   struct elfNN_ia64_dyn_sym_info **pp;
1734   struct elfNN_ia64_dyn_sym_info *dyn_i;
1735   bfd_vma addend = rel ? rel->r_addend : 0;
1736
1737   if (h)
1738     pp = &((struct elfNN_ia64_link_hash_entry *)h)->info;
1739   else
1740     {
1741       struct elfNN_ia64_local_hash_entry *loc_h;
1742       char *addr_name;
1743       size_t len;
1744
1745       /* Construct a string for use in the elfNN_ia64_local_hash_table.
1746          The name describes what was once anonymous memory.  */
1747
1748       len = sizeof (void*)*2 + 1 + sizeof (bfd_vma)*4 + 1 + 1;
1749       len += 10;        /* %p slop */
1750
1751       addr_name = alloca (len);
1752       sprintf (addr_name, "%p:%lx",
1753                (void *) abfd, (unsigned long) ELFNN_R_SYM (rel->r_info));
1754
1755       /* Collect the canonical entry data for this address.  */
1756       loc_h = elfNN_ia64_local_hash_lookup (&ia64_info->loc_hash_table,
1757                                             addr_name, create, create);
1758       BFD_ASSERT (loc_h);
1759
1760       pp = &loc_h->info;
1761     }
1762
1763   for (dyn_i = *pp; dyn_i && dyn_i->addend != addend; dyn_i = *pp)
1764     pp = &dyn_i->next;
1765
1766   if (dyn_i == NULL && create)
1767     {
1768       dyn_i = ((struct elfNN_ia64_dyn_sym_info *)
1769                bfd_zalloc (abfd, (bfd_size_type) sizeof *dyn_i));
1770       *pp = dyn_i;
1771       dyn_i->addend = addend;
1772     }
1773
1774   return dyn_i;
1775 }
1776
1777 static asection *
1778 get_got (abfd, info, ia64_info)
1779      bfd *abfd;
1780      struct bfd_link_info *info;
1781      struct elfNN_ia64_link_hash_table *ia64_info;
1782 {
1783   asection *got;
1784   bfd *dynobj;
1785
1786   got = ia64_info->got_sec;
1787   if (!got)
1788     {
1789       flagword flags;
1790
1791       dynobj = ia64_info->root.dynobj;
1792       if (!dynobj)
1793         ia64_info->root.dynobj = dynobj = abfd;
1794       if (!_bfd_elf_create_got_section (dynobj, info))
1795         return 0;
1796
1797       got = bfd_get_section_by_name (dynobj, ".got");
1798       BFD_ASSERT (got);
1799       ia64_info->got_sec = got;
1800
1801       flags = bfd_get_section_flags (abfd, got);
1802       bfd_set_section_flags (abfd, got, SEC_SMALL_DATA | flags);
1803     }
1804
1805   return got;
1806 }
1807
1808 /* Create function descriptor section (.opd).  This section is called .opd
1809    because it contains "official prodecure descriptors".  The "official"
1810    refers to the fact that these descriptors are used when taking the address
1811    of a procedure, thus ensuring a unique address for each procedure.  */
1812
1813 static asection *
1814 get_fptr (abfd, info, ia64_info)
1815      bfd *abfd;
1816      struct bfd_link_info *info ATTRIBUTE_UNUSED;
1817      struct elfNN_ia64_link_hash_table *ia64_info;
1818 {
1819   asection *fptr;
1820   bfd *dynobj;
1821
1822   fptr = ia64_info->fptr_sec;
1823   if (!fptr)
1824     {
1825       dynobj = ia64_info->root.dynobj;
1826       if (!dynobj)
1827         ia64_info->root.dynobj = dynobj = abfd;
1828
1829       fptr = bfd_make_section (dynobj, ".opd");
1830       if (!fptr
1831           || !bfd_set_section_flags (dynobj, fptr,
1832                                      (SEC_ALLOC
1833                                       | SEC_LOAD
1834                                       | SEC_HAS_CONTENTS
1835                                       | SEC_IN_MEMORY
1836                                       | SEC_READONLY
1837                                       | SEC_LINKER_CREATED))
1838           || !bfd_set_section_alignment (abfd, fptr, 4))
1839         {
1840           BFD_ASSERT (0);
1841           return NULL;
1842         }
1843
1844       ia64_info->fptr_sec = fptr;
1845     }
1846
1847   return fptr;
1848 }
1849
1850 static asection *
1851 get_pltoff (abfd, info, ia64_info)
1852      bfd *abfd;
1853      struct bfd_link_info *info ATTRIBUTE_UNUSED;
1854      struct elfNN_ia64_link_hash_table *ia64_info;
1855 {
1856   asection *pltoff;
1857   bfd *dynobj;
1858
1859   pltoff = ia64_info->pltoff_sec;
1860   if (!pltoff)
1861     {
1862       dynobj = ia64_info->root.dynobj;
1863       if (!dynobj)
1864         ia64_info->root.dynobj = dynobj = abfd;
1865
1866       pltoff = bfd_make_section (dynobj, ELF_STRING_ia64_pltoff);
1867       if (!pltoff
1868           || !bfd_set_section_flags (dynobj, pltoff,
1869                                      (SEC_ALLOC
1870                                       | SEC_LOAD
1871                                       | SEC_HAS_CONTENTS
1872                                       | SEC_IN_MEMORY
1873                                       | SEC_SMALL_DATA
1874                                       | SEC_LINKER_CREATED))
1875           || !bfd_set_section_alignment (abfd, pltoff, 4))
1876         {
1877           BFD_ASSERT (0);
1878           return NULL;
1879         }
1880
1881       ia64_info->pltoff_sec = pltoff;
1882     }
1883
1884   return pltoff;
1885 }
1886
1887 static asection *
1888 get_reloc_section (abfd, ia64_info, sec, create)
1889      bfd *abfd;
1890      struct elfNN_ia64_link_hash_table *ia64_info;
1891      asection *sec;
1892      boolean create;
1893 {
1894   const char *srel_name;
1895   asection *srel;
1896   bfd *dynobj;
1897
1898   srel_name = (bfd_elf_string_from_elf_section
1899                (abfd, elf_elfheader(abfd)->e_shstrndx,
1900                 elf_section_data(sec)->rel_hdr.sh_name));
1901   if (srel_name == NULL)
1902     return NULL;
1903
1904   BFD_ASSERT ((strncmp (srel_name, ".rela", 5) == 0
1905                && strcmp (bfd_get_section_name (abfd, sec),
1906                           srel_name+5) == 0)
1907               || (strncmp (srel_name, ".rel", 4) == 0
1908                   && strcmp (bfd_get_section_name (abfd, sec),
1909                              srel_name+4) == 0));
1910
1911   dynobj = ia64_info->root.dynobj;
1912   if (!dynobj)
1913     ia64_info->root.dynobj = dynobj = abfd;
1914
1915   srel = bfd_get_section_by_name (dynobj, srel_name);
1916   if (srel == NULL && create)
1917     {
1918       srel = bfd_make_section (dynobj, srel_name);
1919       if (srel == NULL
1920           || !bfd_set_section_flags (dynobj, srel,
1921                                      (SEC_ALLOC
1922                                       | SEC_LOAD
1923                                       | SEC_HAS_CONTENTS
1924                                       | SEC_IN_MEMORY
1925                                       | SEC_LINKER_CREATED
1926                                       | SEC_READONLY))
1927           || !bfd_set_section_alignment (dynobj, srel, 3))
1928         return NULL;
1929     }
1930
1931   if (sec->flags & SEC_READONLY)
1932     ia64_info->reltext = 1;
1933
1934   return srel;
1935 }
1936
1937 static boolean
1938 count_dyn_reloc (abfd, dyn_i, srel, type)
1939      bfd *abfd;
1940      struct elfNN_ia64_dyn_sym_info *dyn_i;
1941      asection *srel;
1942      int type;
1943 {
1944   struct elfNN_ia64_dyn_reloc_entry *rent;
1945
1946   for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
1947     if (rent->srel == srel && rent->type == type)
1948       break;
1949
1950   if (!rent)
1951     {
1952       rent = ((struct elfNN_ia64_dyn_reloc_entry *)
1953               bfd_alloc (abfd, (bfd_size_type) sizeof (*rent)));
1954       if (!rent)
1955         return false;
1956
1957       rent->next = dyn_i->reloc_entries;
1958       rent->srel = srel;
1959       rent->type = type;
1960       rent->count = 0;
1961       dyn_i->reloc_entries = rent;
1962     }
1963   rent->count++;
1964
1965   return true;
1966 }
1967
1968 static boolean
1969 elfNN_ia64_check_relocs (abfd, info, sec, relocs)
1970      bfd *abfd;
1971      struct bfd_link_info *info;
1972      asection *sec;
1973      const Elf_Internal_Rela *relocs;
1974 {
1975   struct elfNN_ia64_link_hash_table *ia64_info;
1976   const Elf_Internal_Rela *relend;
1977   Elf_Internal_Shdr *symtab_hdr;
1978   const Elf_Internal_Rela *rel;
1979   asection *got, *fptr, *srel;
1980
1981   if (info->relocateable)
1982     return true;
1983
1984   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1985   ia64_info = elfNN_ia64_hash_table (info);
1986
1987   got = fptr = srel = NULL;
1988
1989   relend = relocs + sec->reloc_count;
1990   for (rel = relocs; rel < relend; ++rel)
1991     {
1992       enum {
1993         NEED_GOT = 1,
1994         NEED_FPTR = 2,
1995         NEED_PLTOFF = 4,
1996         NEED_MIN_PLT = 8,
1997         NEED_FULL_PLT = 16,
1998         NEED_DYNREL = 32,
1999         NEED_LTOFF_FPTR = 64,
2000       };
2001
2002       struct elf_link_hash_entry *h = NULL;
2003       unsigned long r_symndx = ELFNN_R_SYM (rel->r_info);
2004       struct elfNN_ia64_dyn_sym_info *dyn_i;
2005       int need_entry;
2006       boolean maybe_dynamic;
2007       int dynrel_type = R_IA64_NONE;
2008
2009       if (r_symndx >= symtab_hdr->sh_info)
2010         {
2011           /* We're dealing with a global symbol -- find its hash entry
2012              and mark it as being referenced.  */
2013           long indx = r_symndx - symtab_hdr->sh_info;
2014           h = elf_sym_hashes (abfd)[indx];
2015           while (h->root.type == bfd_link_hash_indirect
2016                  || h->root.type == bfd_link_hash_warning)
2017             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2018
2019           h->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
2020         }
2021
2022       /* We can only get preliminary data on whether a symbol is
2023          locally or externally defined, as not all of the input files
2024          have yet been processed.  Do something with what we know, as
2025          this may help reduce memory usage and processing time later.  */
2026       maybe_dynamic = false;
2027       if (h && ((info->shared
2028                       && (!info->symbolic || info->allow_shlib_undefined))
2029                 || ! (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
2030                 || h->root.type == bfd_link_hash_defweak
2031                 || elfNN_ia64_aix_vec (abfd->xvec)))
2032         maybe_dynamic = true;
2033
2034       need_entry = 0;
2035       switch (ELFNN_R_TYPE (rel->r_info))
2036         {
2037         case R_IA64_TPREL22:
2038         case R_IA64_TPREL64MSB:
2039         case R_IA64_TPREL64LSB:
2040         case R_IA64_LTOFF_TP22:
2041           return false;
2042
2043         case R_IA64_LTOFF_FPTR22:
2044         case R_IA64_LTOFF_FPTR64I:
2045         case R_IA64_LTOFF_FPTR32MSB:
2046         case R_IA64_LTOFF_FPTR32LSB:
2047         case R_IA64_LTOFF_FPTR64MSB:
2048         case R_IA64_LTOFF_FPTR64LSB:
2049           need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR;
2050           break;
2051
2052         case R_IA64_FPTR64I:
2053         case R_IA64_FPTR32MSB:
2054         case R_IA64_FPTR32LSB:
2055         case R_IA64_FPTR64MSB:
2056         case R_IA64_FPTR64LSB:
2057           if (info->shared || h || elfNN_ia64_aix_vec (abfd->xvec))
2058             need_entry = NEED_FPTR | NEED_DYNREL;
2059           else
2060             need_entry = NEED_FPTR;
2061           dynrel_type = R_IA64_FPTR64LSB;
2062           break;
2063
2064         case R_IA64_LTOFF22:
2065         case R_IA64_LTOFF22X:
2066         case R_IA64_LTOFF64I:
2067           need_entry = NEED_GOT;
2068           break;
2069
2070         case R_IA64_PLTOFF22:
2071         case R_IA64_PLTOFF64I:
2072         case R_IA64_PLTOFF64MSB:
2073         case R_IA64_PLTOFF64LSB:
2074           need_entry = NEED_PLTOFF;
2075           if (h)
2076             {
2077               if (maybe_dynamic)
2078                 need_entry |= NEED_MIN_PLT;
2079             }
2080           else
2081             {
2082               (*info->callbacks->warning)
2083                 (info, _("@pltoff reloc against local symbol"), 0,
2084                  abfd, 0, (bfd_vma) 0);
2085             }
2086           break;
2087
2088         case R_IA64_PCREL21B:
2089         case R_IA64_PCREL60B:
2090           /* Depending on where this symbol is defined, we may or may not
2091              need a full plt entry.  Only skip if we know we'll not need
2092              the entry -- static or symbolic, and the symbol definition
2093              has already been seen.  */
2094           if (maybe_dynamic && rel->r_addend == 0)
2095             need_entry = NEED_FULL_PLT;
2096           break;
2097
2098         case R_IA64_IMM14:
2099         case R_IA64_IMM22:
2100         case R_IA64_IMM64:
2101         case R_IA64_DIR32MSB:
2102         case R_IA64_DIR32LSB:
2103         case R_IA64_DIR64MSB:
2104         case R_IA64_DIR64LSB:
2105           /* Shared objects will always need at least a REL relocation.  */
2106           if (info->shared || maybe_dynamic
2107               || (elfNN_ia64_aix_vec (abfd->xvec)
2108                   && (!h || strcmp (h->root.root.string,
2109                                     "__GLOB_DATA_PTR") != 0)))
2110             need_entry = NEED_DYNREL;
2111           dynrel_type = R_IA64_DIR64LSB;
2112           break;
2113
2114         case R_IA64_IPLTMSB:
2115         case R_IA64_IPLTLSB:
2116           /* Shared objects will always need at least a REL relocation.  */
2117           if (info->shared || maybe_dynamic)
2118             need_entry = NEED_DYNREL;
2119           dynrel_type = R_IA64_IPLTLSB;
2120           break;
2121
2122         case R_IA64_PCREL22:
2123         case R_IA64_PCREL64I:
2124         case R_IA64_PCREL32MSB:
2125         case R_IA64_PCREL32LSB:
2126         case R_IA64_PCREL64MSB:
2127         case R_IA64_PCREL64LSB:
2128           if (maybe_dynamic)
2129             need_entry = NEED_DYNREL;
2130           dynrel_type = R_IA64_PCREL64LSB;
2131           break;
2132         }
2133
2134       if (!need_entry)
2135         continue;
2136
2137       if ((need_entry & NEED_FPTR) != 0
2138           && rel->r_addend)
2139         {
2140           (*info->callbacks->warning)
2141             (info, _("non-zero addend in @fptr reloc"), 0,
2142              abfd, 0, (bfd_vma) 0);
2143         }
2144
2145       dyn_i = get_dyn_sym_info (ia64_info, h, abfd, rel, true);
2146
2147       /* Record whether or not this is a local symbol.  */
2148       dyn_i->h = h;
2149
2150       /* Create what's needed.  */
2151       if (need_entry & NEED_GOT)
2152         {
2153           if (!got)
2154             {
2155               got = get_got (abfd, info, ia64_info);
2156               if (!got)
2157                 return false;
2158             }
2159           dyn_i->want_got = 1;
2160         }
2161       if (need_entry & NEED_FPTR)
2162         {
2163           if (!fptr)
2164             {
2165               fptr = get_fptr (abfd, info, ia64_info);
2166               if (!fptr)
2167                 return false;
2168             }
2169
2170           /* FPTRs for shared libraries are allocated by the dynamic
2171              linker.  Make sure this local symbol will appear in the
2172              dynamic symbol table.  */
2173           if (!h && (info->shared
2174                      /* AIX also needs one */
2175                      || elfNN_ia64_aix_vec (abfd->xvec)))
2176             {
2177               if (! (_bfd_elfNN_link_record_local_dynamic_symbol
2178                      (info, abfd, (long) r_symndx)))
2179                 return false;
2180             }
2181
2182           dyn_i->want_fptr = 1;
2183         }
2184       if (need_entry & NEED_LTOFF_FPTR)
2185         dyn_i->want_ltoff_fptr = 1;
2186       if (need_entry & (NEED_MIN_PLT | NEED_FULL_PLT))
2187         {
2188           if (!ia64_info->root.dynobj)
2189             ia64_info->root.dynobj = abfd;
2190           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2191           dyn_i->want_plt = 1;
2192         }
2193       if (need_entry & NEED_FULL_PLT)
2194         dyn_i->want_plt2 = 1;
2195       if (need_entry & NEED_PLTOFF)
2196         dyn_i->want_pltoff = 1;
2197       if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC))
2198         {
2199           if (!srel)
2200             {
2201               srel = get_reloc_section (abfd, ia64_info, sec, true);
2202               if (!srel)
2203                 return false;
2204             }
2205           if (!count_dyn_reloc (abfd, dyn_i, srel, dynrel_type))
2206             return false;
2207         }
2208     }
2209
2210   return true;
2211 }
2212
2213 struct elfNN_ia64_allocate_data
2214 {
2215   struct bfd_link_info *info;
2216   bfd_size_type ofs;
2217 };
2218
2219 /* For cleanliness, and potentially faster dynamic loading, allocate
2220    external GOT entries first.  */
2221
2222 static boolean
2223 allocate_global_data_got (dyn_i, data)
2224      struct elfNN_ia64_dyn_sym_info *dyn_i;
2225      PTR data;
2226 {
2227   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2228
2229   if (dyn_i->want_got
2230       && ! dyn_i->want_fptr
2231       && (elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info)
2232           || (elfNN_ia64_aix_vec (x->info->hash->creator)
2233               && (!dyn_i->h || strcmp (dyn_i->h->root.root.string,
2234                                        "__GLOB_DATA_PTR") != 0))))
2235      {
2236        dyn_i->got_offset = x->ofs;
2237        x->ofs += 8;
2238      }
2239   return true;
2240 }
2241
2242 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs.  */
2243
2244 static boolean
2245 allocate_global_fptr_got (dyn_i, data)
2246      struct elfNN_ia64_dyn_sym_info *dyn_i;
2247      PTR data;
2248 {
2249   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2250
2251   if (dyn_i->want_got
2252       && dyn_i->want_fptr
2253       && (elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info)
2254           || elfNN_ia64_aix_vec (x->info->hash->creator)))
2255     {
2256       dyn_i->got_offset = x->ofs;
2257       x->ofs += 8;
2258     }
2259   return true;
2260 }
2261
2262 /* Lastly, allocate all the GOT entries for local data.  */
2263
2264 static boolean
2265 allocate_local_got (dyn_i, data)
2266      struct elfNN_ia64_dyn_sym_info *dyn_i;
2267      PTR data;
2268 {
2269   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2270
2271   if (dyn_i->want_got
2272       && ! (elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info)
2273             || elfNN_ia64_aix_vec (x->info->hash->creator)))
2274     {
2275       dyn_i->got_offset = x->ofs;
2276       x->ofs += 8;
2277     }
2278   return true;
2279 }
2280
2281 /* Search for the index of a global symbol in it's defining object file.  */
2282
2283 static long
2284 global_sym_index (h)
2285      struct elf_link_hash_entry *h;
2286 {
2287   struct elf_link_hash_entry **p;
2288   bfd *obj;
2289
2290   BFD_ASSERT (h->root.type == bfd_link_hash_defined
2291               || h->root.type == bfd_link_hash_defweak);
2292
2293   obj = h->root.u.def.section->owner;
2294   for (p = elf_sym_hashes (obj); *p != h; ++p)
2295     continue;
2296
2297   return p - elf_sym_hashes (obj) + elf_tdata (obj)->symtab_hdr.sh_info;
2298 }
2299
2300 /* Allocate function descriptors.  We can do these for every function
2301    in a main executable that is not exported.  */
2302
2303 static boolean
2304 allocate_fptr (dyn_i, data)
2305      struct elfNN_ia64_dyn_sym_info *dyn_i;
2306      PTR data;
2307 {
2308   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2309
2310   if (dyn_i->want_fptr)
2311     {
2312       struct elf_link_hash_entry *h = dyn_i->h;
2313
2314       if (h)
2315         while (h->root.type == bfd_link_hash_indirect
2316                || h->root.type == bfd_link_hash_warning)
2317           h = (struct elf_link_hash_entry *) h->root.u.i.link;
2318
2319       if (x->info->shared
2320           /* AIX needs an FPTR in this case. */
2321           || (elfNN_ia64_aix_vec (x->info->hash->creator)
2322               && (!h
2323                   || h->root.type == bfd_link_hash_defined
2324                   || h->root.type == bfd_link_hash_defweak)))
2325         {
2326           if (h && h->dynindx == -1)
2327             {
2328               BFD_ASSERT ((h->root.type == bfd_link_hash_defined)
2329                           || (h->root.type == bfd_link_hash_defweak));
2330
2331               if (!_bfd_elfNN_link_record_local_dynamic_symbol
2332                     (x->info, h->root.u.def.section->owner,
2333                      global_sym_index (h)))
2334                 return false;
2335             }
2336
2337           dyn_i->want_fptr = 0;
2338         }
2339       else if (h == NULL || h->dynindx == -1)
2340         {
2341           dyn_i->fptr_offset = x->ofs;
2342           x->ofs += 16;
2343         }
2344       else
2345         dyn_i->want_fptr = 0;
2346     }
2347   return true;
2348 }
2349
2350 /* Allocate all the minimal PLT entries.  */
2351
2352 static boolean
2353 allocate_plt_entries (dyn_i, data)
2354      struct elfNN_ia64_dyn_sym_info *dyn_i;
2355      PTR data;
2356 {
2357   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2358
2359   if (dyn_i->want_plt)
2360     {
2361       struct elf_link_hash_entry *h = dyn_i->h;
2362
2363       if (h)
2364         while (h->root.type == bfd_link_hash_indirect
2365                || h->root.type == bfd_link_hash_warning)
2366           h = (struct elf_link_hash_entry *) h->root.u.i.link;
2367
2368       /* ??? Versioned symbols seem to lose ELF_LINK_HASH_NEEDS_PLT.  */
2369       if (elfNN_ia64_dynamic_symbol_p (h, x->info))
2370         {
2371           bfd_size_type offset = x->ofs;
2372           if (offset == 0)
2373             offset = PLT_HEADER_SIZE;
2374           dyn_i->plt_offset = offset;
2375           x->ofs = offset + PLT_MIN_ENTRY_SIZE;
2376
2377           dyn_i->want_pltoff = 1;
2378         }
2379       else
2380         {
2381           dyn_i->want_plt = 0;
2382           dyn_i->want_plt2 = 0;
2383         }
2384     }
2385   return true;
2386 }
2387
2388 /* Allocate all the full PLT entries.  */
2389
2390 static boolean
2391 allocate_plt2_entries (dyn_i, data)
2392      struct elfNN_ia64_dyn_sym_info *dyn_i;
2393      PTR data;
2394 {
2395   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2396
2397   if (dyn_i->want_plt2)
2398     {
2399       struct elf_link_hash_entry *h = dyn_i->h;
2400       bfd_size_type ofs = x->ofs;
2401
2402       dyn_i->plt2_offset = ofs;
2403       x->ofs = ofs + PLT_FULL_ENTRY_SIZE;
2404
2405       while (h->root.type == bfd_link_hash_indirect
2406              || h->root.type == bfd_link_hash_warning)
2407         h = (struct elf_link_hash_entry *) h->root.u.i.link;
2408       dyn_i->h->plt.offset = ofs;
2409     }
2410   return true;
2411 }
2412
2413 /* Allocate all the PLTOFF entries requested by relocations and
2414    plt entries.  We can't share space with allocated FPTR entries,
2415    because the latter are not necessarily addressable by the GP.
2416    ??? Relaxation might be able to determine that they are.  */
2417
2418 static boolean
2419 allocate_pltoff_entries (dyn_i, data)
2420      struct elfNN_ia64_dyn_sym_info *dyn_i;
2421      PTR data;
2422 {
2423   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2424
2425   if (dyn_i->want_pltoff)
2426     {
2427       dyn_i->pltoff_offset = x->ofs;
2428       x->ofs += 16;
2429     }
2430   return true;
2431 }
2432
2433 /* Allocate dynamic relocations for those symbols that turned out
2434    to be dynamic.  */
2435
2436 static boolean
2437 allocate_dynrel_entries (dyn_i, data)
2438      struct elfNN_ia64_dyn_sym_info *dyn_i;
2439      PTR data;
2440 {
2441   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2442   struct elfNN_ia64_link_hash_table *ia64_info;
2443   struct elfNN_ia64_dyn_reloc_entry *rent;
2444   boolean dynamic_symbol, shared;
2445
2446   ia64_info = elfNN_ia64_hash_table (x->info);
2447   dynamic_symbol = elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info)
2448     || (elfNN_ia64_aix_vec (x->info->hash->creator)
2449         /* Don't allocate an entry for __GLOB_DATA_PTR */
2450         && (!dyn_i->h || strcmp (dyn_i->h->root.root.string,
2451           "__GLOB_DATA_PTR") != 0));
2452   shared = x->info->shared;
2453
2454   /* Take care of the normal data relocations.  */
2455
2456   for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
2457     {
2458       int count = rent->count;
2459
2460       switch (rent->type)
2461         {
2462         case R_IA64_FPTR64LSB:
2463           /* Allocate one iff !want_fptr, which by this point will
2464              be true only if we're actually allocating one statically
2465              in the main executable.  */
2466           if (dyn_i->want_fptr)
2467             continue;
2468           break;
2469         case R_IA64_PCREL64LSB:
2470           if (!dynamic_symbol)
2471             continue;
2472           break;
2473         case R_IA64_DIR64LSB:
2474           if (!dynamic_symbol && !shared)
2475             continue;
2476           break;
2477         case R_IA64_IPLTLSB:
2478           if (!dynamic_symbol && !shared)
2479             continue;
2480           /* Use two REL relocations for IPLT relocations
2481              against local symbols.  */
2482           if (!dynamic_symbol)
2483             count *= 2;
2484           break;
2485         default:
2486           abort ();
2487         }
2488       rent->srel->_raw_size += sizeof (ElfNN_External_Rela) * count;
2489     }
2490
2491   /* Take care of the GOT and PLT relocations.  */
2492
2493   if (((dynamic_symbol || shared) && dyn_i->want_got)
2494       || (dyn_i->want_ltoff_fptr && dyn_i->h && dyn_i->h->dynindx != -1))
2495     ia64_info->rel_got_sec->_raw_size += sizeof (ElfNN_External_Rela);
2496
2497   if (dyn_i->want_pltoff)
2498     {
2499       bfd_size_type t = 0;
2500
2501       /* Dynamic symbols get one IPLT relocation.  Local symbols in
2502          shared libraries get two REL relocations.  Local symbols in
2503          main applications get nothing.  */
2504       if (dynamic_symbol)
2505         t = sizeof (ElfNN_External_Rela);
2506       else if (shared)
2507         t = 2 * sizeof (ElfNN_External_Rela);
2508
2509       ia64_info->rel_pltoff_sec->_raw_size += t;
2510     }
2511
2512   return true;
2513 }
2514
2515 static boolean
2516 elfNN_ia64_adjust_dynamic_symbol (info, h)
2517      struct bfd_link_info *info ATTRIBUTE_UNUSED;
2518      struct elf_link_hash_entry *h;
2519 {
2520   /* ??? Undefined symbols with PLT entries should be re-defined
2521      to be the PLT entry.  */
2522
2523   /* If this is a weak symbol, and there is a real definition, the
2524      processor independent code will have arranged for us to see the
2525      real definition first, and we can just use the same value.  */
2526   if (h->weakdef != NULL)
2527     {
2528       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2529                   || h->weakdef->root.type == bfd_link_hash_defweak);
2530       h->root.u.def.section = h->weakdef->root.u.def.section;
2531       h->root.u.def.value = h->weakdef->root.u.def.value;
2532       return true;
2533     }
2534
2535   /* If this is a reference to a symbol defined by a dynamic object which
2536      is not a function, we might allocate the symbol in our .dynbss section
2537      and allocate a COPY dynamic relocation.
2538
2539      But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2540      of hackery.  */
2541
2542   return true;
2543 }
2544
2545 static boolean
2546 elfNN_ia64_size_dynamic_sections (output_bfd, info)
2547      bfd *output_bfd;
2548      struct bfd_link_info *info;
2549 {
2550   struct elfNN_ia64_allocate_data data;
2551   struct elfNN_ia64_link_hash_table *ia64_info;
2552   asection *sec;
2553   bfd *dynobj;
2554   boolean relplt = false;
2555
2556   dynobj = elf_hash_table(info)->dynobj;
2557   ia64_info = elfNN_ia64_hash_table (info);
2558   BFD_ASSERT(dynobj != NULL);
2559   data.info = info;
2560
2561   /* Set the contents of the .interp section to the interpreter.  */
2562   if (ia64_info->root.dynamic_sections_created
2563       && !info->shared)
2564     {
2565       sec = bfd_get_section_by_name (dynobj, ".interp");
2566       BFD_ASSERT (sec != NULL);
2567       sec->contents = (bfd_byte *) DYNAMIC_INTERPRETER (output_bfd);
2568       sec->_raw_size = strlen (DYNAMIC_INTERPRETER (output_bfd)) + 1;
2569     }
2570
2571   /* Allocate the GOT entries.  */
2572
2573   if (ia64_info->got_sec)
2574     {
2575       data.ofs = 0;
2576       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data);
2577       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data);
2578       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data);
2579       ia64_info->got_sec->_raw_size = data.ofs;
2580     }
2581
2582   /* Allocate the FPTR entries.  */
2583
2584   if (ia64_info->fptr_sec)
2585     {
2586       data.ofs = 0;
2587       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_fptr, &data);
2588       ia64_info->fptr_sec->_raw_size = data.ofs;
2589     }
2590
2591   /* Now that we've seen all of the input files, we can decide which
2592      symbols need plt entries.  Allocate the minimal PLT entries first.
2593      We do this even though dynamic_sections_created may be false, because
2594      this has the side-effect of clearing want_plt and want_plt2.  */
2595
2596   data.ofs = 0;
2597   elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_plt_entries, &data);
2598
2599   ia64_info->minplt_entries = 0;
2600   if (data.ofs)
2601     {
2602       ia64_info->minplt_entries
2603         = (data.ofs - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
2604     }
2605
2606   /* Align the pointer for the plt2 entries.  */
2607   data.ofs = (data.ofs + 31) & (bfd_vma) -32;
2608
2609   elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_plt2_entries, &data);
2610   if (data.ofs != 0)
2611     {
2612       BFD_ASSERT (ia64_info->root.dynamic_sections_created);
2613
2614       ia64_info->plt_sec->_raw_size = data.ofs;
2615
2616       /* If we've got a .plt, we need some extra memory for the dynamic
2617          linker.  We stuff these in .got.plt.  */
2618       sec = bfd_get_section_by_name (dynobj, ".got.plt");
2619       sec->_raw_size = 8 * PLT_RESERVED_WORDS;
2620     }
2621
2622   /* Allocate the PLTOFF entries.  */
2623
2624   if (ia64_info->pltoff_sec)
2625     {
2626       data.ofs = 0;
2627       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_pltoff_entries, &data);
2628       ia64_info->pltoff_sec->_raw_size = data.ofs;
2629     }
2630
2631   if (ia64_info->root.dynamic_sections_created)
2632     {
2633       /* Allocate space for the dynamic relocations that turned out to be
2634          required.  */
2635
2636       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries, &data);
2637     }
2638
2639   /* We have now determined the sizes of the various dynamic sections.
2640      Allocate memory for them.  */
2641   for (sec = dynobj->sections; sec != NULL; sec = sec->next)
2642     {
2643       boolean strip;
2644
2645       if (!(sec->flags & SEC_LINKER_CREATED))
2646         continue;
2647
2648       /* If we don't need this section, strip it from the output file.
2649          There were several sections primarily related to dynamic
2650          linking that must be create before the linker maps input
2651          sections to output sections.  The linker does that before
2652          bfd_elf_size_dynamic_sections is called, and it is that
2653          function which decides whether anything needs to go into
2654          these sections.  */
2655
2656       strip = (sec->_raw_size == 0);
2657
2658       if (sec == ia64_info->got_sec)
2659         strip = false;
2660       else if (sec == ia64_info->rel_got_sec)
2661         {
2662           if (strip)
2663             ia64_info->rel_got_sec = NULL;
2664           else
2665             /* We use the reloc_count field as a counter if we need to
2666                copy relocs into the output file.  */
2667             sec->reloc_count = 0;
2668         }
2669       else if (sec == ia64_info->fptr_sec)
2670         {
2671           if (strip)
2672             ia64_info->fptr_sec = NULL;
2673         }
2674       else if (sec == ia64_info->plt_sec)
2675         {
2676           if (strip)
2677             ia64_info->plt_sec = NULL;
2678         }
2679       else if (sec == ia64_info->pltoff_sec)
2680         {
2681           if (strip)
2682             ia64_info->pltoff_sec = NULL;
2683         }
2684       else if (sec == ia64_info->rel_pltoff_sec)
2685         {
2686           if (strip)
2687             ia64_info->rel_pltoff_sec = NULL;
2688           else
2689             {
2690               relplt = true;
2691               /* We use the reloc_count field as a counter if we need to
2692                  copy relocs into the output file.  */
2693               sec->reloc_count = 0;
2694             }
2695         }
2696       else
2697         {
2698           const char *name;
2699
2700           /* It's OK to base decisions on the section name, because none
2701              of the dynobj section names depend upon the input files.  */
2702           name = bfd_get_section_name (dynobj, sec);
2703
2704           if (strcmp (name, ".got.plt") == 0)
2705             strip = false;
2706           else if (strncmp (name, ".rel", 4) == 0)
2707             {
2708               if (!strip)
2709                 {
2710                   /* We use the reloc_count field as a counter if we need to
2711                      copy relocs into the output file.  */
2712                   sec->reloc_count = 0;
2713                 }
2714             }
2715           else
2716             continue;
2717         }
2718
2719       if (strip)
2720         _bfd_strip_section_from_output (info, sec);
2721       else
2722         {
2723           /* Allocate memory for the section contents.  */
2724           sec->contents = (bfd_byte *) bfd_zalloc (dynobj, sec->_raw_size);
2725           if (sec->contents == NULL && sec->_raw_size != 0)
2726             return false;
2727         }
2728     }
2729
2730   if (elf_hash_table (info)->dynamic_sections_created)
2731     {
2732       /* Add some entries to the .dynamic section.  We fill in the values
2733          later (in finish_dynamic_sections) but we must add the entries now
2734          so that we get the correct size for the .dynamic section.  */
2735
2736       if (!info->shared)
2737         {
2738           /* The DT_DEBUG entry is filled in by the dynamic linker and used
2739              by the debugger.  */
2740 #define add_dynamic_entry(TAG, VAL) \
2741   bfd_elfNN_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
2742
2743           if (!add_dynamic_entry (DT_DEBUG, 0))
2744             return false;
2745         }
2746
2747       if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE, 0))
2748         return false;
2749       if (!add_dynamic_entry (DT_PLTGOT, 0))
2750         return false;
2751
2752       if (relplt)
2753         {
2754           if (!add_dynamic_entry (DT_PLTRELSZ, 0)
2755               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2756               || !add_dynamic_entry (DT_JMPREL, 0))
2757             return false;
2758         }
2759
2760       if (!add_dynamic_entry (DT_RELA, 0)
2761           || !add_dynamic_entry (DT_RELASZ, 0)
2762           || !add_dynamic_entry (DT_RELAENT, sizeof (ElfNN_External_Rela)))
2763         return false;
2764
2765       if (ia64_info->reltext)
2766         {
2767           if (!add_dynamic_entry (DT_TEXTREL, 0))
2768             return false;
2769           info->flags |= DF_TEXTREL;
2770         }
2771     }
2772
2773   /* ??? Perhaps force __gp local.  */
2774
2775   return true;
2776 }
2777
2778 static bfd_reloc_status_type
2779 elfNN_ia64_install_value (abfd, hit_addr, v, r_type)
2780      bfd *abfd;
2781      bfd_byte *hit_addr;
2782      bfd_vma v;
2783      unsigned int r_type;
2784 {
2785   const struct ia64_operand *op;
2786   int bigendian = 0, shift = 0;
2787   bfd_vma t0, t1, insn, dword;
2788   enum ia64_opnd opnd;
2789   const char *err;
2790   size_t size = 8;
2791 #ifdef BFD_HOST_U_64_BIT
2792   BFD_HOST_U_64_BIT val = (BFD_HOST_U_64_BIT) v;
2793 #else
2794   bfd_vma val = v;
2795 #endif
2796
2797   opnd = IA64_OPND_NIL;
2798   switch (r_type)
2799     {
2800     case R_IA64_NONE:
2801     case R_IA64_LDXMOV:
2802       return bfd_reloc_ok;
2803
2804       /* Instruction relocations.  */
2805
2806     case R_IA64_IMM14:          opnd = IA64_OPND_IMM14; break;
2807
2808     case R_IA64_PCREL21F:       opnd = IA64_OPND_TGT25; break;
2809     case R_IA64_PCREL21M:       opnd = IA64_OPND_TGT25b; break;
2810     case R_IA64_PCREL60B:       opnd = IA64_OPND_TGT64; break;
2811     case R_IA64_PCREL21B:
2812     case R_IA64_PCREL21BI:
2813       opnd = IA64_OPND_TGT25c;
2814       break;
2815
2816     case R_IA64_IMM22:
2817     case R_IA64_GPREL22:
2818     case R_IA64_LTOFF22:
2819     case R_IA64_LTOFF22X:
2820     case R_IA64_PLTOFF22:
2821     case R_IA64_PCREL22:
2822     case R_IA64_LTOFF_FPTR22:
2823       opnd = IA64_OPND_IMM22;
2824       break;
2825
2826     case R_IA64_IMM64:
2827     case R_IA64_GPREL64I:
2828     case R_IA64_LTOFF64I:
2829     case R_IA64_PLTOFF64I:
2830     case R_IA64_PCREL64I:
2831     case R_IA64_FPTR64I:
2832     case R_IA64_LTOFF_FPTR64I:
2833       opnd = IA64_OPND_IMMU64;
2834       break;
2835
2836       /* Data relocations.  */
2837
2838     case R_IA64_DIR32MSB:
2839     case R_IA64_GPREL32MSB:
2840     case R_IA64_FPTR32MSB:
2841     case R_IA64_PCREL32MSB:
2842     case R_IA64_LTOFF_FPTR32MSB:
2843     case R_IA64_SEGREL32MSB:
2844     case R_IA64_SECREL32MSB:
2845     case R_IA64_LTV32MSB:
2846       size = 4; bigendian = 1;
2847       break;
2848
2849     case R_IA64_DIR32LSB:
2850     case R_IA64_GPREL32LSB:
2851     case R_IA64_FPTR32LSB:
2852     case R_IA64_PCREL32LSB:
2853     case R_IA64_LTOFF_FPTR32LSB:
2854     case R_IA64_SEGREL32LSB:
2855     case R_IA64_SECREL32LSB:
2856     case R_IA64_LTV32LSB:
2857       size = 4; bigendian = 0;
2858       break;
2859
2860     case R_IA64_DIR64MSB:
2861     case R_IA64_GPREL64MSB:
2862     case R_IA64_PLTOFF64MSB:
2863     case R_IA64_FPTR64MSB:
2864     case R_IA64_PCREL64MSB:
2865     case R_IA64_LTOFF_FPTR64MSB:
2866     case R_IA64_SEGREL64MSB:
2867     case R_IA64_SECREL64MSB:
2868     case R_IA64_LTV64MSB:
2869       size = 8; bigendian = 1;
2870       break;
2871
2872     case R_IA64_DIR64LSB:
2873     case R_IA64_GPREL64LSB:
2874     case R_IA64_PLTOFF64LSB:
2875     case R_IA64_FPTR64LSB:
2876     case R_IA64_PCREL64LSB:
2877     case R_IA64_LTOFF_FPTR64LSB:
2878     case R_IA64_SEGREL64LSB:
2879     case R_IA64_SECREL64LSB:
2880     case R_IA64_LTV64LSB:
2881       size = 8; bigendian = 0;
2882       break;
2883
2884       /* Unsupported / Dynamic relocations.  */
2885     default:
2886       return bfd_reloc_notsupported;
2887     }
2888
2889   switch (opnd)
2890     {
2891     case IA64_OPND_IMMU64:
2892       hit_addr -= (long) hit_addr & 0x3;
2893       t0 = bfd_get_64 (abfd, hit_addr);
2894       t1 = bfd_get_64 (abfd, hit_addr + 8);
2895
2896       /* tmpl/s: bits  0.. 5 in t0
2897          slot 0: bits  5..45 in t0
2898          slot 1: bits 46..63 in t0, bits 0..22 in t1
2899          slot 2: bits 23..63 in t1 */
2900
2901       /* First, clear the bits that form the 64 bit constant.  */
2902       t0 &= ~(0x3ffffLL << 46);
2903       t1 &= ~(0x7fffffLL
2904               | ((  (0x07fLL << 13) | (0x1ffLL << 27)
2905                     | (0x01fLL << 22) | (0x001LL << 21)
2906                     | (0x001LL << 36)) << 23));
2907
2908       t0 |= ((val >> 22) & 0x03ffffLL) << 46;           /* 18 lsbs of imm41 */
2909       t1 |= ((val >> 40) & 0x7fffffLL) <<  0;           /* 23 msbs of imm41 */
2910       t1 |= (  (((val >>  0) & 0x07f) << 13)            /* imm7b */
2911                | (((val >>  7) & 0x1ff) << 27)          /* imm9d */
2912                | (((val >> 16) & 0x01f) << 22)          /* imm5c */
2913                | (((val >> 21) & 0x001) << 21)          /* ic */
2914                | (((val >> 63) & 0x001) << 36)) << 23;  /* i */
2915
2916       bfd_put_64 (abfd, t0, hit_addr);
2917       bfd_put_64 (abfd, t1, hit_addr + 8);
2918       break;
2919
2920     case IA64_OPND_TGT64:
2921       hit_addr -= (long) hit_addr & 0x3;
2922       t0 = bfd_get_64 (abfd, hit_addr);
2923       t1 = bfd_get_64 (abfd, hit_addr + 8);
2924
2925       /* tmpl/s: bits  0.. 5 in t0
2926          slot 0: bits  5..45 in t0
2927          slot 1: bits 46..63 in t0, bits 0..22 in t1
2928          slot 2: bits 23..63 in t1 */
2929
2930       /* First, clear the bits that form the 64 bit constant.  */
2931       t0 &= ~(0x3ffffLL << 46);
2932       t1 &= ~(0x7fffffLL
2933               | ((1LL << 36 | 0xfffffLL << 13) << 23));
2934
2935       val >>= 4;
2936       t0 |= ((val >> 20) & 0xffffLL) << 2 << 46;        /* 16 lsbs of imm39 */
2937       t1 |= ((val >> 36) & 0x7fffffLL) << 0;            /* 23 msbs of imm39 */
2938       t1 |= ((((val >> 0) & 0xfffffLL) << 13)           /* imm20b */
2939               | (((val >> 59) & 0x1LL) << 36)) << 23;   /* i */
2940
2941       bfd_put_64 (abfd, t0, hit_addr);
2942       bfd_put_64 (abfd, t1, hit_addr + 8);
2943       break;
2944
2945     default:
2946       switch ((long) hit_addr & 0x3)
2947         {
2948         case 0: shift =  5; break;
2949         case 1: shift = 14; hit_addr += 3; break;
2950         case 2: shift = 23; hit_addr += 6; break;
2951         case 3: return bfd_reloc_notsupported; /* shouldn't happen...  */
2952         }
2953       dword = bfd_get_64 (abfd, hit_addr);
2954       insn = (dword >> shift) & 0x1ffffffffffLL;
2955
2956       op = elf64_ia64_operands + opnd;
2957       err = (*op->insert) (op, val, (ia64_insn *)& insn);
2958       if (err)
2959         return bfd_reloc_overflow;
2960
2961       dword &= ~(0x1ffffffffffLL << shift);
2962       dword |= (insn << shift);
2963       bfd_put_64 (abfd, dword, hit_addr);
2964       break;
2965
2966     case IA64_OPND_NIL:
2967       /* A data relocation.  */
2968       if (bigendian)
2969         if (size == 4)
2970           bfd_putb32 (val, hit_addr);
2971         else
2972           bfd_putb64 (val, hit_addr);
2973       else
2974         if (size == 4)
2975           bfd_putl32 (val, hit_addr);
2976         else
2977           bfd_putl64 (val, hit_addr);
2978       break;
2979     }
2980
2981   return bfd_reloc_ok;
2982 }
2983
2984 static void
2985 elfNN_ia64_install_dyn_reloc (abfd, info, sec, srel, offset, type,
2986                               dynindx, addend)
2987      bfd *abfd;
2988      struct bfd_link_info *info;
2989      asection *sec;
2990      asection *srel;
2991      bfd_vma offset;
2992      unsigned int type;
2993      long dynindx;
2994      bfd_vma addend;
2995 {
2996   Elf_Internal_Rela outrel;
2997
2998   outrel.r_offset = (sec->output_section->vma
2999                      + sec->output_offset
3000                      + offset);
3001
3002   BFD_ASSERT (dynindx != -1);
3003   outrel.r_info = ELFNN_R_INFO (dynindx, type);
3004   outrel.r_addend = addend;
3005
3006   if (elf_section_data (sec)->stab_info != NULL)
3007     {
3008       /* This may be NULL for linker-generated relocations, as it is
3009          inconvenient to pass all the bits around.  And this shouldn't
3010          happen.  */
3011       BFD_ASSERT (info != NULL);
3012
3013       offset = (_bfd_stab_section_offset
3014                 (abfd, &elf_hash_table (info)->stab_info, sec,
3015                  &elf_section_data (sec)->stab_info, offset));
3016       if (offset == (bfd_vma) -1)
3017         {
3018           /* Run for the hills.  We shouldn't be outputting a relocation
3019              for this.  So do what everyone else does and output a no-op.  */
3020           outrel.r_info = ELFNN_R_INFO (0, R_IA64_NONE);
3021           outrel.r_addend = 0;
3022           offset = 0;
3023         }
3024       outrel.r_offset = offset;
3025     }
3026
3027   bfd_elfNN_swap_reloca_out (abfd, &outrel,
3028                              ((ElfNN_External_Rela *) srel->contents
3029                               + srel->reloc_count++));
3030   BFD_ASSERT (sizeof (ElfNN_External_Rela) * srel->reloc_count
3031               <= srel->_cooked_size);
3032 }
3033
3034 /* Store an entry for target address TARGET_ADDR in the linkage table
3035    and return the gp-relative address of the linkage table entry.  */
3036
3037 static bfd_vma
3038 set_got_entry (abfd, info, dyn_i, dynindx, addend, value, dyn_r_type)
3039      bfd *abfd;
3040      struct bfd_link_info *info;
3041      struct elfNN_ia64_dyn_sym_info *dyn_i;
3042      long dynindx;
3043      bfd_vma addend;
3044      bfd_vma value;
3045      unsigned int dyn_r_type;
3046 {
3047   struct elfNN_ia64_link_hash_table *ia64_info;
3048   asection *got_sec;
3049
3050   ia64_info = elfNN_ia64_hash_table (info);
3051   got_sec = ia64_info->got_sec;
3052
3053   BFD_ASSERT ((dyn_i->got_offset & 7) == 0);
3054
3055   if (! dyn_i->got_done)
3056     {
3057       dyn_i->got_done = true;
3058
3059       /* Store the target address in the linkage table entry.  */
3060       bfd_put_64 (abfd, value, got_sec->contents + dyn_i->got_offset);
3061
3062       /* Install a dynamic relocation if needed.  */
3063       if (info->shared
3064           || elfNN_ia64_dynamic_symbol_p (dyn_i->h, info)
3065           || elfNN_ia64_aix_vec (abfd->xvec)
3066           || (dynindx != -1 && dyn_r_type == R_IA64_FPTR64LSB))
3067         {
3068           if (dynindx == -1)
3069             {
3070               dyn_r_type = R_IA64_REL64LSB;
3071               dynindx = 0;
3072               addend = value;
3073             }
3074
3075           if (bfd_big_endian (abfd))
3076             {
3077               switch (dyn_r_type)
3078                 {
3079                 case R_IA64_REL64LSB:
3080                   dyn_r_type = R_IA64_REL64MSB;
3081                   break;
3082                 case R_IA64_DIR64LSB:
3083                   dyn_r_type = R_IA64_DIR64MSB;
3084                   break;
3085                 case R_IA64_FPTR64LSB:
3086                   dyn_r_type = R_IA64_FPTR64MSB;
3087                   break;
3088                 default:
3089                   BFD_ASSERT (false);
3090                   break;
3091                 }
3092             }
3093
3094           elfNN_ia64_install_dyn_reloc (abfd, NULL, got_sec,
3095                                         ia64_info->rel_got_sec,
3096                                         dyn_i->got_offset, dyn_r_type,
3097                                         dynindx, addend);
3098         }
3099     }
3100
3101   /* Return the address of the linkage table entry.  */
3102   value = (got_sec->output_section->vma
3103            + got_sec->output_offset
3104            + dyn_i->got_offset);
3105
3106   return value;
3107 }
3108
3109 /* Fill in a function descriptor consisting of the function's code
3110    address and its global pointer.  Return the descriptor's address.  */
3111
3112 static bfd_vma
3113 set_fptr_entry (abfd, info, dyn_i, value)
3114      bfd *abfd;
3115      struct bfd_link_info *info;
3116      struct elfNN_ia64_dyn_sym_info *dyn_i;
3117      bfd_vma value;
3118 {
3119   struct elfNN_ia64_link_hash_table *ia64_info;
3120   asection *fptr_sec;
3121
3122   ia64_info = elfNN_ia64_hash_table (info);
3123   fptr_sec = ia64_info->fptr_sec;
3124
3125   if (!dyn_i->fptr_done)
3126     {
3127       dyn_i->fptr_done = 1;
3128
3129       /* Fill in the function descriptor.  */
3130       bfd_put_64 (abfd, value, fptr_sec->contents + dyn_i->fptr_offset);
3131       bfd_put_64 (abfd, _bfd_get_gp_value (abfd),
3132                   fptr_sec->contents + dyn_i->fptr_offset + 8);
3133     }
3134
3135   /* Return the descriptor's address.  */
3136   value = (fptr_sec->output_section->vma
3137            + fptr_sec->output_offset
3138            + dyn_i->fptr_offset);
3139
3140   return value;
3141 }
3142
3143 /* Fill in a PLTOFF entry consisting of the function's code address
3144    and its global pointer.  Return the descriptor's address.  */
3145
3146 static bfd_vma
3147 set_pltoff_entry (abfd, info, dyn_i, value, is_plt)
3148      bfd *abfd;
3149      struct bfd_link_info *info;
3150      struct elfNN_ia64_dyn_sym_info *dyn_i;
3151      bfd_vma value;
3152      boolean is_plt;
3153 {
3154   struct elfNN_ia64_link_hash_table *ia64_info;
3155   asection *pltoff_sec;
3156
3157   ia64_info = elfNN_ia64_hash_table (info);
3158   pltoff_sec = ia64_info->pltoff_sec;
3159
3160   /* Don't do anything if this symbol uses a real PLT entry.  In
3161      that case, we'll fill this in during finish_dynamic_symbol.  */
3162   if ((! dyn_i->want_plt || is_plt)
3163       && !dyn_i->pltoff_done)
3164     {
3165       bfd_vma gp = _bfd_get_gp_value (abfd);
3166
3167       /* Fill in the function descriptor.  */
3168       bfd_put_64 (abfd, value, pltoff_sec->contents + dyn_i->pltoff_offset);
3169       bfd_put_64 (abfd, gp, pltoff_sec->contents + dyn_i->pltoff_offset + 8);
3170
3171       /* Install dynamic relocations if needed.  */
3172       if (!is_plt && info->shared)
3173         {
3174           unsigned int dyn_r_type;
3175
3176           if (bfd_big_endian (abfd))
3177             dyn_r_type = R_IA64_REL64MSB;
3178           else
3179             dyn_r_type = R_IA64_REL64LSB;
3180
3181           elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
3182                                         ia64_info->rel_pltoff_sec,
3183                                         dyn_i->pltoff_offset,
3184                                         dyn_r_type, 0, value);
3185           elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
3186                                         ia64_info->rel_pltoff_sec,
3187                                         dyn_i->pltoff_offset + 8,
3188                                         dyn_r_type, 0, gp);
3189         }
3190
3191       dyn_i->pltoff_done = 1;
3192     }
3193
3194   /* Return the descriptor's address.  */
3195   value = (pltoff_sec->output_section->vma
3196            + pltoff_sec->output_offset
3197            + dyn_i->pltoff_offset);
3198
3199   return value;
3200 }
3201
3202 /* Called through qsort to sort the .IA_64.unwind section during a
3203    non-relocatable link.  Set elfNN_ia64_unwind_entry_compare_bfd
3204    to the output bfd so we can do proper endianness frobbing.  */
3205
3206 static bfd *elfNN_ia64_unwind_entry_compare_bfd;
3207
3208 static int
3209 elfNN_ia64_unwind_entry_compare (a, b)
3210      const PTR a;
3211      const PTR b;
3212 {
3213   bfd_vma av, bv;
3214
3215   av = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, a);
3216   bv = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, b);
3217
3218   return (av < bv ? -1 : av > bv ? 1 : 0);
3219 }
3220
3221 static boolean
3222 elfNN_ia64_final_link (abfd, info)
3223      bfd *abfd;
3224      struct bfd_link_info *info;
3225 {
3226   struct elfNN_ia64_link_hash_table *ia64_info;
3227   asection *unwind_output_sec;
3228
3229   ia64_info = elfNN_ia64_hash_table (info);
3230
3231   /* Make sure we've got ourselves a nice fat __gp value.  */
3232   if (!info->relocateable)
3233     {
3234       bfd_vma min_vma = (bfd_vma) -1, max_vma = 0;
3235       bfd_vma min_short_vma = min_vma, max_short_vma = 0;
3236       struct elf_link_hash_entry *gp;
3237       bfd_vma gp_val;
3238       asection *os;
3239
3240       /* Find the min and max vma of all sections marked short.  Also
3241          collect min and max vma of any type, for use in selecting a
3242          nice gp.  */
3243       for (os = abfd->sections; os ; os = os->next)
3244         {
3245           bfd_vma lo, hi;
3246
3247           if ((os->flags & SEC_ALLOC) == 0)
3248             continue;
3249
3250           lo = os->vma;
3251           hi = os->vma + os->_raw_size;
3252           if (hi < lo)
3253             hi = (bfd_vma) -1;
3254
3255           if (min_vma > lo)
3256             min_vma = lo;
3257           if (max_vma < hi)
3258             max_vma = hi;
3259           if (os->flags & SEC_SMALL_DATA)
3260             {
3261               if (min_short_vma > lo)
3262                 min_short_vma = lo;
3263               if (max_short_vma < hi)
3264                 max_short_vma = hi;
3265             }
3266         }
3267
3268       /* See if the user wants to force a value.  */
3269       gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", false,
3270                                  false, false);
3271
3272       if (gp
3273           && (gp->root.type == bfd_link_hash_defined
3274               || gp->root.type == bfd_link_hash_defweak))
3275         {
3276           asection *gp_sec = gp->root.u.def.section;
3277           gp_val = (gp->root.u.def.value
3278                     + gp_sec->output_section->vma
3279                     + gp_sec->output_offset);
3280         }
3281       else
3282         {
3283           /* Pick a sensible value.  */
3284
3285           asection *got_sec = ia64_info->got_sec;
3286
3287           /* Start with just the address of the .got.  */
3288           if (got_sec)
3289             gp_val = got_sec->output_section->vma;
3290           else if (max_short_vma != 0)
3291             gp_val = min_short_vma;
3292           else
3293             gp_val = min_vma;
3294
3295           /* If it is possible to address the entire image, but we
3296              don't with the choice above, adjust.  */
3297           if (max_vma - min_vma < 0x400000
3298               && max_vma - gp_val <= 0x200000
3299               && gp_val - min_vma > 0x200000)
3300             gp_val = min_vma + 0x200000;
3301           else if (max_short_vma != 0)
3302             {
3303               /* If we don't cover all the short data, adjust.  */
3304               if (max_short_vma - gp_val >= 0x200000)
3305                 gp_val = min_short_vma + 0x200000;
3306
3307               /* If we're addressing stuff past the end, adjust back.  */
3308               if (gp_val > max_vma)
3309                 gp_val = max_vma - 0x200000 + 8;
3310             }
3311         }
3312
3313       /* Validate whether all SHF_IA_64_SHORT sections are within
3314          range of the chosen GP.  */
3315
3316       if (max_short_vma != 0)
3317         {
3318           if (max_short_vma - min_short_vma >= 0x400000)
3319             {
3320               (*_bfd_error_handler)
3321                 (_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
3322                  bfd_get_filename (abfd),
3323                  (unsigned long) (max_short_vma - min_short_vma));
3324               return false;
3325             }
3326           else if ((gp_val > min_short_vma
3327                     && gp_val - min_short_vma > 0x200000)
3328                    || (gp_val < max_short_vma
3329                        && max_short_vma - gp_val >= 0x200000))
3330             {
3331               (*_bfd_error_handler)
3332                 (_("%s: __gp does not cover short data segment"),
3333                  bfd_get_filename (abfd));
3334               return false;
3335             }
3336         }
3337
3338       _bfd_set_gp_value (abfd, gp_val);
3339
3340       if (gp)
3341         {
3342           gp->root.type = bfd_link_hash_defined;
3343           gp->root.u.def.value = gp_val;
3344           gp->root.u.def.section = bfd_abs_section_ptr;
3345         }
3346     }
3347
3348   /* If we're producing a final executable, we need to sort the contents
3349      of the .IA_64.unwind section.  Force this section to be relocated
3350      into memory rather than written immediately to the output file.  */
3351   unwind_output_sec = NULL;
3352   if (!info->relocateable)
3353     {
3354       asection *s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind);
3355       if (s)
3356         {
3357           unwind_output_sec = s->output_section;
3358           unwind_output_sec->contents
3359             = bfd_malloc (unwind_output_sec->_raw_size);
3360           if (unwind_output_sec->contents == NULL)
3361             return false;
3362         }
3363     }
3364
3365   /* Invoke the regular ELF backend linker to do all the work.  */
3366   if (!bfd_elfNN_bfd_final_link (abfd, info))
3367     return false;
3368
3369   if (unwind_output_sec)
3370     {
3371       elfNN_ia64_unwind_entry_compare_bfd = abfd;
3372       qsort (unwind_output_sec->contents,
3373              (size_t) (unwind_output_sec->_raw_size / 24),
3374              24,
3375              elfNN_ia64_unwind_entry_compare);
3376
3377       if (! bfd_set_section_contents (abfd, unwind_output_sec,
3378                                       unwind_output_sec->contents, (bfd_vma) 0,
3379                                       unwind_output_sec->_raw_size))
3380         return false;
3381     }
3382
3383   return true;
3384 }
3385
3386 static boolean
3387 elfNN_ia64_relocate_section (output_bfd, info, input_bfd, input_section,
3388                              contents, relocs, local_syms, local_sections)
3389      bfd *output_bfd;
3390      struct bfd_link_info *info;
3391      bfd *input_bfd;
3392      asection *input_section;
3393      bfd_byte *contents;
3394      Elf_Internal_Rela *relocs;
3395      Elf_Internal_Sym *local_syms;
3396      asection **local_sections;
3397 {
3398   struct elfNN_ia64_link_hash_table *ia64_info;
3399   Elf_Internal_Shdr *symtab_hdr;
3400   Elf_Internal_Rela *rel;
3401   Elf_Internal_Rela *relend;
3402   asection *srel;
3403   boolean ret_val = true;       /* for non-fatal errors */
3404   bfd_vma gp_val;
3405
3406   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3407   ia64_info = elfNN_ia64_hash_table (info);
3408
3409   /* Infect various flags from the input section to the output section.  */
3410   if (info->relocateable)
3411     {
3412       bfd_vma flags;
3413
3414       flags = elf_section_data(input_section)->this_hdr.sh_flags;
3415       flags &= SHF_IA_64_NORECOV;
3416
3417       elf_section_data(input_section->output_section)
3418         ->this_hdr.sh_flags |= flags;
3419     }
3420
3421   gp_val = _bfd_get_gp_value (output_bfd);
3422   srel = get_reloc_section (input_bfd, ia64_info, input_section, false);
3423
3424   rel = relocs;
3425   relend = relocs + input_section->reloc_count;
3426   for (; rel < relend; ++rel)
3427     {
3428       struct elf_link_hash_entry *h;
3429       struct elfNN_ia64_dyn_sym_info *dyn_i;
3430       bfd_reloc_status_type r;
3431       reloc_howto_type *howto;
3432       unsigned long r_symndx;
3433       Elf_Internal_Sym *sym;
3434       unsigned int r_type;
3435       bfd_vma value;
3436       asection *sym_sec;
3437       bfd_byte *hit_addr;
3438       boolean dynamic_symbol_p;
3439       boolean undef_weak_ref;
3440
3441       r_type = ELFNN_R_TYPE (rel->r_info);
3442       if (r_type > R_IA64_MAX_RELOC_CODE)
3443         {
3444           (*_bfd_error_handler)
3445             (_("%s: unknown relocation type %d"),
3446              bfd_archive_filename (input_bfd), (int)r_type);
3447           bfd_set_error (bfd_error_bad_value);
3448           ret_val = false;
3449           continue;
3450         }
3451       howto = lookup_howto (r_type);
3452       r_symndx = ELFNN_R_SYM (rel->r_info);
3453
3454       if (info->relocateable)
3455         {
3456           /* This is a relocateable link.  We don't have to change
3457              anything, unless the reloc is against a section symbol,
3458              in which case we have to adjust according to where the
3459              section symbol winds up in the output section.  */
3460           if (r_symndx < symtab_hdr->sh_info)
3461             {
3462               sym = local_syms + r_symndx;
3463               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3464                 {
3465                   sym_sec = local_sections[r_symndx];
3466                   rel->r_addend += sym_sec->output_offset;
3467                 }
3468             }
3469           continue;
3470         }
3471
3472       /* This is a final link.  */
3473
3474       h = NULL;
3475       sym = NULL;
3476       sym_sec = NULL;
3477       undef_weak_ref = false;
3478
3479       if (r_symndx < symtab_hdr->sh_info)
3480         {
3481           /* Reloc against local symbol.  */
3482           sym = local_syms + r_symndx;
3483           sym_sec = local_sections[r_symndx];
3484           value  = (sym_sec->output_section->vma
3485                     + sym_sec->output_offset
3486                     + sym->st_value);
3487         }
3488       else
3489         {
3490           long indx;
3491
3492           /* Reloc against global symbol.  */
3493           indx = r_symndx - symtab_hdr->sh_info;
3494           h = elf_sym_hashes (input_bfd)[indx];
3495           while (h->root.type == bfd_link_hash_indirect
3496                  || h->root.type == bfd_link_hash_warning)
3497             h = (struct elf_link_hash_entry *) h->root.u.i.link;
3498
3499           value = 0;
3500           if (h->root.type == bfd_link_hash_defined
3501               || h->root.type == bfd_link_hash_defweak)
3502             {
3503               sym_sec = h->root.u.def.section;
3504
3505               /* Detect the cases that sym_sec->output_section is
3506                  expected to be NULL -- all cases in which the symbol
3507                  is defined in another shared module.  This includes
3508                  PLT relocs for which we've created a PLT entry and
3509                  other relocs for which we're prepared to create
3510                  dynamic relocations.  */
3511               /* ??? Just accept it NULL and continue.  */
3512
3513               if (sym_sec->output_section != NULL)
3514                 {
3515                   value = (h->root.u.def.value
3516                            + sym_sec->output_section->vma
3517                            + sym_sec->output_offset);
3518                 }
3519             }
3520           else if (h->root.type == bfd_link_hash_undefweak)
3521             undef_weak_ref = true;
3522           else if (info->shared
3523                    && (!info->symbolic || info->allow_shlib_undefined)
3524                    && !info->no_undefined
3525                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
3526             ;
3527           else
3528             {
3529               if (! ((*info->callbacks->undefined_symbol)
3530                      (info, h->root.root.string, input_bfd,
3531                       input_section, rel->r_offset,
3532                       (!info->shared || info->no_undefined
3533                        || ELF_ST_VISIBILITY (h->other)))))
3534                 return false;
3535               ret_val = false;
3536               continue;
3537             }
3538         }
3539
3540       hit_addr = contents + rel->r_offset;
3541       value += rel->r_addend;
3542       dynamic_symbol_p = elfNN_ia64_dynamic_symbol_p (h, info);
3543
3544       switch (r_type)
3545         {
3546         case R_IA64_NONE:
3547         case R_IA64_LDXMOV:
3548           continue;
3549
3550         case R_IA64_IMM14:
3551         case R_IA64_IMM22:
3552         case R_IA64_IMM64:
3553         case R_IA64_DIR32MSB:
3554         case R_IA64_DIR32LSB:
3555         case R_IA64_DIR64MSB:
3556         case R_IA64_DIR64LSB:
3557           /* Install a dynamic relocation for this reloc.  */
3558           if ((dynamic_symbol_p || info->shared
3559                || (elfNN_ia64_aix_vec (info->hash->creator)
3560                    /* Don't emit relocs for __GLOB_DATA_PTR on AIX. */
3561                    && (!h || strcmp (h->root.root.string,
3562                                      "__GLOB_DATA_PTR") != 0)))
3563               && (input_section->flags & SEC_ALLOC) != 0)
3564             {
3565               unsigned int dyn_r_type;
3566               long dynindx;
3567               bfd_vma addend;
3568
3569               BFD_ASSERT (srel != NULL);
3570
3571               /* If we don't need dynamic symbol lookup, find a
3572                  matching RELATIVE relocation.  */
3573               dyn_r_type = r_type;
3574               if (dynamic_symbol_p)
3575                 {
3576                   dynindx = h->dynindx;
3577                   addend = rel->r_addend;
3578                   value = 0;
3579                 }
3580               else
3581                 {
3582                   switch (r_type)
3583                     {
3584                     case R_IA64_DIR32MSB:
3585                       dyn_r_type = R_IA64_REL32MSB;
3586                       break;
3587                     case R_IA64_DIR32LSB:
3588                       dyn_r_type = R_IA64_REL32LSB;
3589                       break;
3590                     case R_IA64_DIR64MSB:
3591                       dyn_r_type = R_IA64_REL64MSB;
3592                       break;
3593                     case R_IA64_DIR64LSB:
3594                       dyn_r_type = R_IA64_REL64LSB;
3595                       break;
3596
3597                     default:
3598                       /* We can't represent this without a dynamic symbol.
3599                          Adjust the relocation to be against an output
3600                          section symbol, which are always present in the
3601                          dynamic symbol table.  */
3602                       /* ??? People shouldn't be doing non-pic code in
3603                          shared libraries.  Hork.  */
3604                       (*_bfd_error_handler)
3605                         (_("%s: linking non-pic code in a shared library"),
3606                          bfd_archive_filename (input_bfd));
3607                       ret_val = false;
3608                       continue;
3609                     }
3610                   dynindx = 0;
3611                   addend = value;
3612                 }
3613
3614               if (elfNN_ia64_aix_vec (info->hash->creator))
3615                 rel->r_addend = value;
3616               elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
3617                                             srel, rel->r_offset, dyn_r_type,
3618                                             dynindx, addend);
3619             }
3620           /* FALLTHRU */
3621
3622         case R_IA64_LTV32MSB:
3623         case R_IA64_LTV32LSB:
3624         case R_IA64_LTV64MSB:
3625         case R_IA64_LTV64LSB:
3626           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
3627           break;
3628
3629         case R_IA64_GPREL22:
3630         case R_IA64_GPREL64I:
3631         case R_IA64_GPREL32MSB:
3632         case R_IA64_GPREL32LSB:
3633         case R_IA64_GPREL64MSB:
3634         case R_IA64_GPREL64LSB:
3635           if (dynamic_symbol_p)
3636             {
3637               (*_bfd_error_handler)
3638                 (_("%s: @gprel relocation against dynamic symbol %s"),
3639                  bfd_archive_filename (input_bfd), h->root.root.string);
3640               ret_val = false;
3641               continue;
3642             }
3643           value -= gp_val;
3644           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
3645           break;
3646
3647         case R_IA64_LTOFF22:
3648         case R_IA64_LTOFF22X:
3649         case R_IA64_LTOFF64I:
3650           dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
3651           value = set_got_entry (input_bfd, info, dyn_i, (h ? h->dynindx : -1),
3652                                  rel->r_addend, value, R_IA64_DIR64LSB);
3653           value -= gp_val;
3654           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
3655           break;
3656
3657         case R_IA64_PLTOFF22:
3658         case R_IA64_PLTOFF64I:
3659         case R_IA64_PLTOFF64MSB:
3660         case R_IA64_PLTOFF64LSB:
3661           dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
3662           value = set_pltoff_entry (output_bfd, info, dyn_i, value, false);
3663           value -= gp_val;
3664           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
3665           break;
3666
3667         case R_IA64_FPTR64I:
3668         case R_IA64_FPTR32MSB:
3669         case R_IA64_FPTR32LSB:
3670         case R_IA64_FPTR64MSB:
3671         case R_IA64_FPTR64LSB:
3672           dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
3673           if (dyn_i->want_fptr)
3674             {
3675               if (!undef_weak_ref)
3676                 value = set_fptr_entry (output_bfd, info, dyn_i, value);
3677             }
3678           else
3679             {
3680               long dynindx;
3681
3682               /* Otherwise, we expect the dynamic linker to create
3683                  the entry.  */
3684
3685               if (h)
3686                 {
3687                   if (h->dynindx != -1)
3688                     dynindx = h->dynindx;
3689                   else
3690                     dynindx = (_bfd_elf_link_lookup_local_dynindx
3691                                (info, h->root.u.def.section->owner,
3692                                 global_sym_index (h)));
3693                 }
3694               else
3695                 {
3696                   dynindx = (_bfd_elf_link_lookup_local_dynindx
3697                              (info, input_bfd, (long) r_symndx));
3698                 }
3699
3700               elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
3701                                             srel, rel->r_offset, r_type,
3702                                             dynindx, rel->r_addend);
3703               value = 0;
3704             }
3705
3706           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
3707           break;
3708
3709         case R_IA64_LTOFF_FPTR22:
3710         case R_IA64_LTOFF_FPTR64I:
3711         case R_IA64_LTOFF_FPTR32MSB:
3712         case R_IA64_LTOFF_FPTR32LSB:
3713         case R_IA64_LTOFF_FPTR64MSB:
3714         case R_IA64_LTOFF_FPTR64LSB:
3715           {
3716             long dynindx;
3717
3718             dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
3719             if (dyn_i->want_fptr)
3720               {
3721                 BFD_ASSERT (h == NULL || h->dynindx == -1)
3722                 if (!undef_weak_ref)
3723                   value = set_fptr_entry (output_bfd, info, dyn_i, value);
3724                 dynindx = -1;
3725               }
3726             else
3727               {
3728                 /* Otherwise, we expect the dynamic linker to create
3729                    the entry.  */
3730                 if (h)
3731                   {
3732                     if (h->dynindx != -1)
3733                       dynindx = h->dynindx;
3734                     else
3735                       dynindx = (_bfd_elf_link_lookup_local_dynindx
3736                                  (info, h->root.u.def.section->owner,
3737                                   global_sym_index (h)));
3738                   }
3739                 else
3740                   dynindx = (_bfd_elf_link_lookup_local_dynindx
3741                              (info, input_bfd, (long) r_symndx));
3742                 value = 0;
3743               }
3744
3745             value = set_got_entry (output_bfd, info, dyn_i, dynindx,
3746                                    rel->r_addend, value, R_IA64_FPTR64LSB);
3747             value -= gp_val;
3748             r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
3749           }
3750           break;
3751
3752         case R_IA64_PCREL32MSB:
3753         case R_IA64_PCREL32LSB:
3754         case R_IA64_PCREL64MSB:
3755         case R_IA64_PCREL64LSB:
3756           /* Install a dynamic relocation for this reloc.  */
3757           if (dynamic_symbol_p
3758               || elfNN_ia64_aix_vec (info->hash->creator))
3759             {
3760               BFD_ASSERT (srel != NULL);
3761
3762               elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
3763                                             srel, rel->r_offset, r_type,
3764                                             h->dynindx, rel->r_addend);
3765             }
3766           goto finish_pcrel;
3767
3768         case R_IA64_PCREL21BI:
3769         case R_IA64_PCREL21F:
3770         case R_IA64_PCREL21M:
3771           /* ??? These two are only used for speculation fixup code.
3772              They should never be dynamic.  */
3773           if (dynamic_symbol_p)
3774             {
3775               (*_bfd_error_handler)
3776                 (_("%s: dynamic relocation against speculation fixup"),
3777                  bfd_archive_filename (input_bfd));
3778               ret_val = false;
3779               continue;
3780             }
3781           if (undef_weak_ref)
3782             {
3783               (*_bfd_error_handler)
3784                 (_("%s: speculation fixup against undefined weak symbol"),
3785                  bfd_archive_filename (input_bfd));
3786               ret_val = false;
3787               continue;
3788             }
3789           goto finish_pcrel;
3790
3791         case R_IA64_PCREL21B:
3792         case R_IA64_PCREL60B:
3793           /* We should have created a PLT entry for any dynamic symbol.  */
3794           dyn_i = NULL;
3795           if (h)
3796             dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, false);
3797
3798           if (dyn_i && dyn_i->want_plt2)
3799             {
3800               /* Should have caught this earlier.  */
3801               BFD_ASSERT (rel->r_addend == 0);
3802
3803               value = (ia64_info->plt_sec->output_section->vma
3804                        + ia64_info->plt_sec->output_offset
3805                        + dyn_i->plt2_offset);
3806             }
3807           else
3808             {
3809               /* Since there's no PLT entry, Validate that this is
3810                  locally defined.  */
3811               BFD_ASSERT (undef_weak_ref || sym_sec->output_section != NULL);
3812
3813               /* If the symbol is undef_weak, we shouldn't be trying
3814                  to call it.  There's every chance that we'd wind up
3815                  with an out-of-range fixup here.  Don't bother setting
3816                  any value at all.  */
3817               if (undef_weak_ref)
3818                 continue;
3819             }
3820           goto finish_pcrel;
3821
3822         case R_IA64_PCREL22:
3823         case R_IA64_PCREL64I:
3824         finish_pcrel:
3825           /* Make pc-relative.  */
3826           value -= (input_section->output_section->vma
3827                     + input_section->output_offset
3828                     + rel->r_offset) & ~ (bfd_vma) 0x3;
3829           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
3830           break;
3831
3832         case R_IA64_SEGREL32MSB:
3833         case R_IA64_SEGREL32LSB:
3834         case R_IA64_SEGREL64MSB:
3835         case R_IA64_SEGREL64LSB:
3836           {
3837             struct elf_segment_map *m;
3838             Elf_Internal_Phdr *p;
3839
3840             /* Find the segment that contains the output_section.  */
3841             for (m = elf_tdata (output_bfd)->segment_map,
3842                    p = elf_tdata (output_bfd)->phdr;
3843                  m != NULL;
3844                  m = m->next, p++)
3845               {
3846                 int i;
3847                 for (i = m->count - 1; i >= 0; i--)
3848                   if (m->sections[i] == sym_sec->output_section)
3849                     break;
3850                 if (i >= 0)
3851                   break;
3852               }
3853
3854             if (m == NULL)
3855               {
3856                 /* If the input section was discarded from the output, then
3857                    do nothing.  */
3858
3859                 if (bfd_is_abs_section (sym_sec->output_section))
3860                   r = bfd_reloc_ok;
3861                 else
3862                   r = bfd_reloc_notsupported;
3863               }
3864             else
3865               {
3866                 /* The VMA of the segment is the vaddr of the associated
3867                    program header.  */
3868                 if (value > p->p_vaddr)
3869                   value -= p->p_vaddr;
3870                 else
3871                   value = 0;
3872                 r = elfNN_ia64_install_value (output_bfd, hit_addr, value,
3873                                               r_type);
3874               }
3875             break;
3876           }
3877
3878         case R_IA64_SECREL32MSB:
3879         case R_IA64_SECREL32LSB:
3880         case R_IA64_SECREL64MSB:
3881         case R_IA64_SECREL64LSB:
3882           /* Make output-section relative.  */
3883           if (value > input_section->output_section->vma)
3884             value -= input_section->output_section->vma;
3885           else
3886             value = 0;
3887           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
3888           break;
3889
3890         case R_IA64_IPLTMSB:
3891         case R_IA64_IPLTLSB:
3892           /* Install a dynamic relocation for this reloc.  */
3893           if ((dynamic_symbol_p || info->shared)
3894               && (input_section->flags & SEC_ALLOC) != 0)
3895             {
3896               BFD_ASSERT (srel != NULL);
3897
3898               /* If we don't need dynamic symbol lookup, install two
3899                  RELATIVE relocations.  */
3900               if (! dynamic_symbol_p)
3901                 {
3902                   unsigned int dyn_r_type;
3903
3904                   if (r_type == R_IA64_IPLTMSB)
3905                     dyn_r_type = R_IA64_REL64MSB;
3906                   else
3907                     dyn_r_type = R_IA64_REL64LSB;
3908
3909                   elfNN_ia64_install_dyn_reloc (output_bfd, info,
3910                                                 input_section,
3911                                                 srel, rel->r_offset,
3912                                                 dyn_r_type, 0, value);
3913                   elfNN_ia64_install_dyn_reloc (output_bfd, info,
3914                                                 input_section,
3915                                                 srel, rel->r_offset + 8,
3916                                                 dyn_r_type, 0, gp_val);
3917                 }
3918               else
3919                 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
3920                                               srel, rel->r_offset, r_type,
3921                                               h->dynindx, rel->r_addend);
3922             }
3923
3924           if (r_type == R_IA64_IPLTMSB)
3925             r_type = R_IA64_DIR64MSB;
3926           else
3927             r_type = R_IA64_DIR64LSB;
3928           elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
3929           r = elfNN_ia64_install_value (output_bfd, hit_addr + 8, gp_val,
3930                                         r_type);
3931           break;
3932
3933         default:
3934           r = bfd_reloc_notsupported;
3935           break;
3936         }
3937
3938       switch (r)
3939         {
3940         case bfd_reloc_ok:
3941           break;
3942
3943         case bfd_reloc_undefined:
3944           /* This can happen for global table relative relocs if
3945              __gp is undefined.  This is a panic situation so we
3946              don't try to continue.  */
3947           (*info->callbacks->undefined_symbol)
3948             (info, "__gp", input_bfd, input_section, rel->r_offset, 1);
3949           return false;
3950
3951         case bfd_reloc_notsupported:
3952           {
3953             const char *name;
3954
3955             if (h)
3956               name = h->root.root.string;
3957             else
3958               {
3959                 name = bfd_elf_string_from_elf_section (input_bfd,
3960                                                         symtab_hdr->sh_link,
3961                                                         sym->st_name);
3962                 if (name == NULL)
3963                   return false;
3964                 if (*name == '\0')
3965                   name = bfd_section_name (input_bfd, input_section);
3966               }
3967             if (!(*info->callbacks->warning) (info, _("unsupported reloc"),
3968                                               name, input_bfd,
3969                                               input_section, rel->r_offset))
3970               return false;
3971             ret_val = false;
3972           }
3973           break;
3974
3975         case bfd_reloc_dangerous:
3976         case bfd_reloc_outofrange:
3977         case bfd_reloc_overflow:
3978         default:
3979           {
3980             const char *name;
3981
3982             if (h)
3983               name = h->root.root.string;
3984             else
3985               {
3986                 name = bfd_elf_string_from_elf_section (input_bfd,
3987                                                         symtab_hdr->sh_link,
3988                                                         sym->st_name);
3989                 if (name == NULL)
3990                   return false;
3991                 if (*name == '\0')
3992                   name = bfd_section_name (input_bfd, input_section);
3993               }
3994             if (!(*info->callbacks->reloc_overflow) (info, name,
3995                                                      howto->name,
3996                                                      (bfd_vma) 0,
3997                                                      input_bfd,
3998                                                      input_section,
3999                                                      rel->r_offset))
4000               return false;
4001             ret_val = false;
4002           }
4003           break;
4004         }
4005     }
4006
4007   return ret_val;
4008 }
4009
4010 static boolean
4011 elfNN_ia64_finish_dynamic_symbol (output_bfd, info, h, sym)
4012      bfd *output_bfd;
4013      struct bfd_link_info *info;
4014      struct elf_link_hash_entry *h;
4015      Elf_Internal_Sym *sym;
4016 {
4017   struct elfNN_ia64_link_hash_table *ia64_info;
4018   struct elfNN_ia64_dyn_sym_info *dyn_i;
4019
4020   ia64_info = elfNN_ia64_hash_table (info);
4021   dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, false);
4022
4023   /* Fill in the PLT data, if required.  */
4024   if (dyn_i && dyn_i->want_plt)
4025     {
4026       Elf_Internal_Rela outrel;
4027       bfd_byte *loc;
4028       asection *plt_sec;
4029       bfd_vma plt_addr, pltoff_addr, gp_val, index;
4030       ElfNN_External_Rela *rel;
4031
4032       gp_val = _bfd_get_gp_value (output_bfd);
4033
4034       /* Initialize the minimal PLT entry.  */
4035
4036       index = (dyn_i->plt_offset - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
4037       plt_sec = ia64_info->plt_sec;
4038       loc = plt_sec->contents + dyn_i->plt_offset;
4039
4040       memcpy (loc, plt_min_entry, PLT_MIN_ENTRY_SIZE);
4041       elfNN_ia64_install_value (output_bfd, loc, index, R_IA64_IMM22);
4042       elfNN_ia64_install_value (output_bfd, loc+2, -dyn_i->plt_offset,
4043                                 R_IA64_PCREL21B);
4044
4045       plt_addr = (plt_sec->output_section->vma
4046                   + plt_sec->output_offset
4047                   + dyn_i->plt_offset);
4048       pltoff_addr = set_pltoff_entry (output_bfd, info, dyn_i, plt_addr, true);
4049
4050       /* Initialize the FULL PLT entry, if needed.  */
4051       if (dyn_i->want_plt2)
4052         {
4053           loc = plt_sec->contents + dyn_i->plt2_offset;
4054
4055           memcpy (loc, plt_full_entry, PLT_FULL_ENTRY_SIZE);
4056           elfNN_ia64_install_value (output_bfd, loc, pltoff_addr - gp_val,
4057                                     R_IA64_IMM22);
4058
4059           /* Mark the symbol as undefined, rather than as defined in the
4060              plt section.  Leave the value alone.  */
4061           /* ??? We didn't redefine it in adjust_dynamic_symbol in the
4062              first place.  But perhaps elflink.h did some for us.  */
4063           if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4064             sym->st_shndx = SHN_UNDEF;
4065         }
4066
4067       /* Create the dynamic relocation.  */
4068       outrel.r_offset = pltoff_addr;
4069       if (bfd_little_endian (output_bfd))
4070         outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTLSB);
4071       else
4072         outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTMSB);
4073       outrel.r_addend = 0;
4074
4075       /* This is fun.  In the .IA_64.pltoff section, we've got entries
4076          that correspond both to real PLT entries, and those that
4077          happened to resolve to local symbols but need to be created
4078          to satisfy @pltoff relocations.  The .rela.IA_64.pltoff
4079          relocations for the real PLT should come at the end of the
4080          section, so that they can be indexed by plt entry at runtime.
4081
4082          We emitted all of the relocations for the non-PLT @pltoff
4083          entries during relocate_section.  So we can consider the
4084          existing sec->reloc_count to be the base of the array of
4085          PLT relocations.  */
4086
4087       rel = (ElfNN_External_Rela *)ia64_info->rel_pltoff_sec->contents;
4088       rel += ia64_info->rel_pltoff_sec->reloc_count;
4089
4090       bfd_elfNN_swap_reloca_out (output_bfd, &outrel, rel + index);
4091     }
4092
4093   /* Mark some specially defined symbols as absolute.  */
4094   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
4095       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
4096       || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
4097     sym->st_shndx = SHN_ABS;
4098
4099   return true;
4100 }
4101
4102 static boolean
4103 elfNN_ia64_finish_dynamic_sections (abfd, info)
4104      bfd *abfd;
4105      struct bfd_link_info *info;
4106 {
4107   struct elfNN_ia64_link_hash_table *ia64_info;
4108   bfd *dynobj;
4109
4110   ia64_info = elfNN_ia64_hash_table (info);
4111   dynobj = ia64_info->root.dynobj;
4112
4113   if (elf_hash_table (info)->dynamic_sections_created)
4114     {
4115       ElfNN_External_Dyn *dyncon, *dynconend;
4116       asection *sdyn, *sgotplt;
4117       bfd_vma gp_val;
4118
4119       sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4120       sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
4121       BFD_ASSERT (sdyn != NULL);
4122       dyncon = (ElfNN_External_Dyn *) sdyn->contents;
4123       dynconend = (ElfNN_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
4124
4125       gp_val = _bfd_get_gp_value (abfd);
4126
4127       for (; dyncon < dynconend; dyncon++)
4128         {
4129           Elf_Internal_Dyn dyn;
4130
4131           bfd_elfNN_swap_dyn_in (dynobj, dyncon, &dyn);
4132
4133           switch (dyn.d_tag)
4134             {
4135             case DT_PLTGOT:
4136               dyn.d_un.d_ptr = gp_val;
4137               break;
4138
4139             case DT_PLTRELSZ:
4140               dyn.d_un.d_val = (ia64_info->minplt_entries
4141                                 * sizeof (ElfNN_External_Rela));
4142               break;
4143
4144             case DT_JMPREL:
4145               /* See the comment above in finish_dynamic_symbol.  */
4146               dyn.d_un.d_ptr = (ia64_info->rel_pltoff_sec->output_section->vma
4147                                 + ia64_info->rel_pltoff_sec->output_offset
4148                                 + (ia64_info->rel_pltoff_sec->reloc_count
4149                                    * sizeof (ElfNN_External_Rela)));
4150               break;
4151
4152             case DT_IA_64_PLT_RESERVE:
4153               dyn.d_un.d_ptr = (sgotplt->output_section->vma
4154                                 + sgotplt->output_offset);
4155               break;
4156
4157             case DT_RELASZ:
4158               /* Do not have RELASZ include JMPREL.  This makes things
4159                  easier on ld.so.  This is not what the rest of BFD set up.  */
4160               dyn.d_un.d_val -= (ia64_info->minplt_entries
4161                                  * sizeof (ElfNN_External_Rela));
4162               break;
4163             }
4164
4165           bfd_elfNN_swap_dyn_out (abfd, &dyn, dyncon);
4166         }
4167
4168       /* Initialize the PLT0 entry */
4169       if (ia64_info->plt_sec)
4170         {
4171           bfd_byte *loc = ia64_info->plt_sec->contents;
4172           bfd_vma pltres;
4173
4174           memcpy (loc, plt_header, PLT_HEADER_SIZE);
4175
4176           pltres = (sgotplt->output_section->vma
4177                     + sgotplt->output_offset
4178                     - gp_val);
4179
4180           elfNN_ia64_install_value (abfd, loc+1, pltres, R_IA64_GPREL22);
4181         }
4182     }
4183
4184   return true;
4185 }
4186 \f
4187 /* ELF file flag handling: */
4188
4189 /* Function to keep IA-64 specific file flags.  */
4190 static boolean
4191 elfNN_ia64_set_private_flags (abfd, flags)
4192      bfd *abfd;
4193      flagword flags;
4194 {
4195   BFD_ASSERT (!elf_flags_init (abfd)
4196               || elf_elfheader (abfd)->e_flags == flags);
4197
4198   elf_elfheader (abfd)->e_flags = flags;
4199   elf_flags_init (abfd) = true;
4200   return true;
4201 }
4202
4203 /* Copy backend specific data from one object module to another */
4204 static boolean
4205 elfNN_ia64_copy_private_bfd_data (ibfd, obfd)
4206      bfd *ibfd, *obfd;
4207 {
4208   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4209       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4210     return true;
4211
4212   BFD_ASSERT (!elf_flags_init (obfd)
4213               || (elf_elfheader (obfd)->e_flags
4214                   == elf_elfheader (ibfd)->e_flags));
4215
4216   elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
4217   elf_flags_init (obfd) = true;
4218   return true;
4219 }
4220
4221 /* Merge backend specific data from an object file to the output
4222    object file when linking.  */
4223 static boolean
4224 elfNN_ia64_merge_private_bfd_data (ibfd, obfd)
4225      bfd *ibfd, *obfd;
4226 {
4227   flagword out_flags;
4228   flagword in_flags;
4229   boolean ok = true;
4230
4231   /* Don't even pretend to support mixed-format linking.  */
4232   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4233       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4234     return false;
4235
4236   in_flags  = elf_elfheader (ibfd)->e_flags;
4237   out_flags = elf_elfheader (obfd)->e_flags;
4238
4239   if (! elf_flags_init (obfd))
4240     {
4241       elf_flags_init (obfd) = true;
4242       elf_elfheader (obfd)->e_flags = in_flags;
4243
4244       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
4245           && bfd_get_arch_info (obfd)->the_default)
4246         {
4247           return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
4248                                     bfd_get_mach (ibfd));
4249         }
4250
4251       return true;
4252     }
4253
4254   /* Check flag compatibility.  */
4255   if (in_flags == out_flags)
4256     return true;
4257
4258   /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set.  */
4259   if (!(in_flags & EF_IA_64_REDUCEDFP) && (out_flags & EF_IA_64_REDUCEDFP))
4260     elf_elfheader (obfd)->e_flags &= ~EF_IA_64_REDUCEDFP;
4261
4262   if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL))
4263     {
4264       (*_bfd_error_handler)
4265         (_("%s: linking trap-on-NULL-dereference with non-trapping files"),
4266          bfd_archive_filename (ibfd));
4267
4268       bfd_set_error (bfd_error_bad_value);
4269       ok = false;
4270     }
4271   if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE))
4272     {
4273       (*_bfd_error_handler)
4274         (_("%s: linking big-endian files with little-endian files"),
4275          bfd_archive_filename (ibfd));
4276
4277       bfd_set_error (bfd_error_bad_value);
4278       ok = false;
4279     }
4280   if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64))
4281     {
4282       (*_bfd_error_handler)
4283         (_("%s: linking 64-bit files with 32-bit files"),
4284          bfd_archive_filename (ibfd));
4285
4286       bfd_set_error (bfd_error_bad_value);
4287       ok = false;
4288     }
4289   if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP))
4290     {
4291       (*_bfd_error_handler)
4292         (_("%s: linking constant-gp files with non-constant-gp files"),
4293          bfd_archive_filename (ibfd));
4294
4295       bfd_set_error (bfd_error_bad_value);
4296       ok = false;
4297     }
4298   if ((in_flags & EF_IA_64_NOFUNCDESC_CONS_GP)
4299       != (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
4300     {
4301       (*_bfd_error_handler)
4302         (_("%s: linking auto-pic files with non-auto-pic files"),
4303          bfd_archive_filename (ibfd));
4304
4305       bfd_set_error (bfd_error_bad_value);
4306       ok = false;
4307     }
4308
4309   return ok;
4310 }
4311
4312 static boolean
4313 elfNN_ia64_print_private_bfd_data (abfd, ptr)
4314      bfd *abfd;
4315      PTR ptr;
4316 {
4317   FILE *file = (FILE *) ptr;
4318   flagword flags = elf_elfheader (abfd)->e_flags;
4319
4320   BFD_ASSERT (abfd != NULL && ptr != NULL);
4321
4322   fprintf (file, "private flags = %s%s%s%s%s%s%s%s\n",
4323            (flags & EF_IA_64_TRAPNIL) ? "TRAPNIL, " : "",
4324            (flags & EF_IA_64_EXT) ? "EXT, " : "",
4325            (flags & EF_IA_64_BE) ? "BE, " : "LE, ",
4326            (flags & EF_IA_64_REDUCEDFP) ? "REDUCEDFP, " : "",
4327            (flags & EF_IA_64_CONS_GP) ? "CONS_GP, " : "",
4328            (flags & EF_IA_64_NOFUNCDESC_CONS_GP) ? "NOFUNCDESC_CONS_GP, " : "",
4329            (flags & EF_IA_64_ABSOLUTE) ? "ABSOLUTE, " : "",
4330            (flags & EF_IA_64_ABI64) ? "ABI64" : "ABI32");
4331
4332   _bfd_elf_print_private_bfd_data (abfd, ptr);
4333   return true;
4334 }
4335
4336 static enum elf_reloc_type_class
4337 elfNN_ia64_reloc_type_class (rela)
4338      const Elf_Internal_Rela *rela;
4339 {
4340   switch ((int) ELFNN_R_TYPE (rela->r_info))
4341     {
4342     case R_IA64_REL32MSB:
4343     case R_IA64_REL32LSB:
4344     case R_IA64_REL64MSB:
4345     case R_IA64_REL64LSB:
4346       return reloc_class_relative;
4347     case R_IA64_IPLTMSB:
4348     case R_IA64_IPLTLSB:
4349       return reloc_class_plt;
4350     case R_IA64_COPY:
4351       return reloc_class_copy;
4352     default:
4353       return reloc_class_normal;
4354     }
4355 }
4356 \f
4357 #define TARGET_LITTLE_SYM               bfd_elfNN_ia64_little_vec
4358 #define TARGET_LITTLE_NAME              "elfNN-ia64-little"
4359 #define TARGET_BIG_SYM                  bfd_elfNN_ia64_big_vec
4360 #define TARGET_BIG_NAME                 "elfNN-ia64-big"
4361 #define ELF_ARCH                        bfd_arch_ia64
4362 #define ELF_MACHINE_CODE                EM_IA_64
4363 #define ELF_MACHINE_ALT1                1999    /* EAS2.3 */
4364 #define ELF_MACHINE_ALT2                1998    /* EAS2.2 */
4365 #define ELF_MAXPAGESIZE                 0x10000 /* 64KB */
4366
4367 #define elf_backend_section_from_shdr \
4368         elfNN_ia64_section_from_shdr
4369 #define elf_backend_section_flags \
4370         elfNN_ia64_section_flags
4371 #define elf_backend_fake_sections \
4372         elfNN_ia64_fake_sections
4373 #define elf_backend_final_write_processing \
4374         elfNN_ia64_final_write_processing
4375 #define elf_backend_add_symbol_hook \
4376         elfNN_ia64_add_symbol_hook
4377 #define elf_backend_additional_program_headers \
4378         elfNN_ia64_additional_program_headers
4379 #define elf_backend_modify_segment_map \
4380         elfNN_ia64_modify_segment_map
4381 #define elf_info_to_howto \
4382         elfNN_ia64_info_to_howto
4383
4384 #define bfd_elfNN_bfd_reloc_type_lookup \
4385         elfNN_ia64_reloc_type_lookup
4386 #define bfd_elfNN_bfd_is_local_label_name \
4387         elfNN_ia64_is_local_label_name
4388 #define bfd_elfNN_bfd_relax_section \
4389         elfNN_ia64_relax_section
4390
4391 /* Stuff for the BFD linker: */
4392 #define bfd_elfNN_bfd_link_hash_table_create \
4393         elfNN_ia64_hash_table_create
4394 #define elf_backend_create_dynamic_sections \
4395         elfNN_ia64_create_dynamic_sections
4396 #define elf_backend_check_relocs \
4397         elfNN_ia64_check_relocs
4398 #define elf_backend_adjust_dynamic_symbol \
4399         elfNN_ia64_adjust_dynamic_symbol
4400 #define elf_backend_size_dynamic_sections \
4401         elfNN_ia64_size_dynamic_sections
4402 #define elf_backend_relocate_section \
4403         elfNN_ia64_relocate_section
4404 #define elf_backend_finish_dynamic_symbol \
4405         elfNN_ia64_finish_dynamic_symbol
4406 #define elf_backend_finish_dynamic_sections \
4407         elfNN_ia64_finish_dynamic_sections
4408 #define bfd_elfNN_bfd_final_link \
4409         elfNN_ia64_final_link
4410
4411 #define bfd_elfNN_bfd_copy_private_bfd_data \
4412         elfNN_ia64_copy_private_bfd_data
4413 #define bfd_elfNN_bfd_merge_private_bfd_data \
4414         elfNN_ia64_merge_private_bfd_data
4415 #define bfd_elfNN_bfd_set_private_flags \
4416         elfNN_ia64_set_private_flags
4417 #define bfd_elfNN_bfd_print_private_bfd_data \
4418         elfNN_ia64_print_private_bfd_data
4419
4420 #define elf_backend_plt_readonly        1
4421 #define elf_backend_want_plt_sym        0
4422 #define elf_backend_plt_alignment       5
4423 #define elf_backend_got_header_size     0
4424 #define elf_backend_plt_header_size     PLT_HEADER_SIZE
4425 #define elf_backend_want_got_plt        1
4426 #define elf_backend_may_use_rel_p       1
4427 #define elf_backend_may_use_rela_p      1
4428 #define elf_backend_default_use_rela_p  1
4429 #define elf_backend_want_dynbss         0
4430 #define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect
4431 #define elf_backend_hide_symbol         elfNN_ia64_hash_hide_symbol
4432 #define elf_backend_reloc_type_class    elfNN_ia64_reloc_type_class
4433
4434 #include "elfNN-target.h"
4435
4436 /* AIX-specific vectors.  */
4437
4438 #undef  TARGET_LITTLE_SYM
4439 #define TARGET_LITTLE_SYM               bfd_elfNN_ia64_aix_little_vec
4440 #undef  TARGET_LITTLE_NAME
4441 #define TARGET_LITTLE_NAME              "elfNN-ia64-aix-little"
4442 #undef  TARGET_BIG_SYM
4443 #define TARGET_BIG_SYM                  bfd_elfNN_ia64_aix_big_vec
4444 #undef  TARGET_BIG_NAME
4445 #define TARGET_BIG_NAME                 "elfNN-ia64-aix-big"
4446
4447 #undef  elf_backend_add_symbol_hook
4448 #define elf_backend_add_symbol_hook     elfNN_ia64_aix_add_symbol_hook
4449
4450 #undef  bfd_elfNN_bfd_link_add_symbols
4451 #define bfd_elfNN_bfd_link_add_symbols  elfNN_ia64_aix_link_add_symbols
4452
4453 #define elfNN_bed elfNN_ia64_aix_bed
4454
4455 #include "elfNN-target.h"