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