bfd/elfxx-ia64.c

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