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