bfd/elfxx-ia64.c

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