bfd/elfxx-ia64.c

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