bfd/elfxx-ia64.c

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