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