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 <[email protected]>
   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     /* The .got section is always aligned at 8 bytes.  */
1785     bfd_set_section_alignment (abfd, ia64_info->got_sec, 3);
1786   }
1787
1788   if (!get_pltoff (abfd, info, ia64_info))
1789     return FALSE;
1790
1791   s = bfd_make_section(abfd, ".rela.IA_64.pltoff");
1792   if (s == NULL
1793       || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1794                                            | SEC_HAS_CONTENTS
1795                                            | SEC_IN_MEMORY
1796                                            | SEC_LINKER_CREATED
1797                                            | SEC_READONLY))
1798       || !bfd_set_section_alignment (abfd, s, 3))
1799     return FALSE;
1800   ia64_info->rel_pltoff_sec = s;
1801
1802   s = bfd_make_section(abfd, ".rela.got");
1803   if (s == NULL
1804       || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1805                                            | SEC_HAS_CONTENTS
1806                                            | SEC_IN_MEMORY
1807                                            | SEC_LINKER_CREATED
1808                                            | SEC_READONLY))
1809       || !bfd_set_section_alignment (abfd, s, 3))
1810     return FALSE;
1811   ia64_info->rel_got_sec = s;
1812
1813   return TRUE;
1814 }
1815
1816 /* Find and/or create a hash entry for local symbol.  */
1817 static struct elfNN_ia64_local_hash_entry *
1818 get_local_sym_hash (ia64_info, abfd, rel, create)
1819      struct elfNN_ia64_link_hash_table *ia64_info;
1820      bfd *abfd;
1821      const Elf_Internal_Rela *rel;
1822      bfd_boolean create;
1823 {
1824   struct elfNN_ia64_local_hash_entry *ret;
1825   asection *sec = abfd->sections;
1826   char addr_name [34];
1827
1828   BFD_ASSERT ((sizeof (sec->id)*2 + 1 + sizeof (unsigned long)*2 + 1) <= 34);
1829   BFD_ASSERT (sec);
1830
1831   /* Construct a string for use in the elfNN_ia64_local_hash_table.
1832      name describes what was once anonymous memory.  */
1833
1834   sprintf (addr_name, "%x:%lx",
1835            sec->id, (unsigned long) ELFNN_R_SYM (rel->r_info));
1836
1837   /* Collect the canonical entry data for this address.  */
1838   ret = elfNN_ia64_local_hash_lookup (&ia64_info->loc_hash_table,
1839                                       addr_name, create, create);
1840   return ret;
1841 }
1842
1843 /* Find and/or create a descriptor for dynamic symbol info.  This will
1844    vary based on global or local symbol, and the addend to the reloc.  */
1845
1846 static struct elfNN_ia64_dyn_sym_info *
1847 get_dyn_sym_info (ia64_info, h, abfd, rel, create)
1848      struct elfNN_ia64_link_hash_table *ia64_info;
1849      struct elf_link_hash_entry *h;
1850      bfd *abfd;
1851      const Elf_Internal_Rela *rel;
1852      bfd_boolean create;
1853 {
1854   struct elfNN_ia64_dyn_sym_info **pp;
1855   struct elfNN_ia64_dyn_sym_info *dyn_i;
1856   bfd_vma addend = rel ? rel->r_addend : 0;
1857
1858   if (h)
1859     pp = &((struct elfNN_ia64_link_hash_entry *)h)->info;
1860   else
1861     {
1862       struct elfNN_ia64_local_hash_entry *loc_h;
1863
1864       loc_h = get_local_sym_hash (ia64_info, abfd, rel, create);
1865       if (!loc_h)
1866         {
1867           BFD_ASSERT (!create);
1868           return NULL;
1869         }
1870
1871       pp = &loc_h->info;
1872     }
1873
1874   for (dyn_i = *pp; dyn_i && dyn_i->addend != addend; dyn_i = *pp)
1875     pp = &dyn_i->next;
1876
1877   if (dyn_i == NULL && create)
1878     {
1879       dyn_i = ((struct elfNN_ia64_dyn_sym_info *)
1880                bfd_zalloc (abfd, (bfd_size_type) sizeof *dyn_i));
1881       *pp = dyn_i;
1882       dyn_i->addend = addend;
1883     }
1884
1885   return dyn_i;
1886 }
1887
1888 static asection *
1889 get_got (abfd, info, ia64_info)
1890      bfd *abfd;
1891      struct bfd_link_info *info;
1892      struct elfNN_ia64_link_hash_table *ia64_info;
1893 {
1894   asection *got;
1895   bfd *dynobj;
1896
1897   got = ia64_info->got_sec;
1898   if (!got)
1899     {
1900       flagword flags;
1901
1902       dynobj = ia64_info->root.dynobj;
1903       if (!dynobj)
1904         ia64_info->root.dynobj = dynobj = abfd;
1905       if (!_bfd_elf_create_got_section (dynobj, info))
1906         return 0;
1907
1908       got = bfd_get_section_by_name (dynobj, ".got");
1909       BFD_ASSERT (got);
1910       ia64_info->got_sec = got;
1911
1912       /* The .got section is always aligned at 8 bytes.  */
1913       if (!bfd_set_section_alignment (abfd, got, 3))
1914         return 0;
1915
1916       flags = bfd_get_section_flags (abfd, got);
1917       bfd_set_section_flags (abfd, got, SEC_SMALL_DATA | flags);
1918     }
1919
1920   return got;
1921 }
1922
1923 /* Create function descriptor section (.opd).  This section is called .opd
1924    because it contains "official prodecure descriptors".  The "official"
1925    refers to the fact that these descriptors are used when taking the address
1926    of a procedure, thus ensuring a unique address for each procedure.  */
1927
1928 static asection *
1929 get_fptr (abfd, info, ia64_info)
1930      bfd *abfd;
1931      struct bfd_link_info *info;
1932      struct elfNN_ia64_link_hash_table *ia64_info;
1933 {
1934   asection *fptr;
1935   bfd *dynobj;
1936
1937   fptr = ia64_info->fptr_sec;
1938   if (!fptr)
1939     {
1940       dynobj = ia64_info->root.dynobj;
1941       if (!dynobj)
1942         ia64_info->root.dynobj = dynobj = abfd;
1943
1944       fptr = bfd_make_section (dynobj, ".opd");
1945       if (!fptr
1946           || !bfd_set_section_flags (dynobj, fptr,
1947                                      (SEC_ALLOC
1948                                       | SEC_LOAD
1949                                       | SEC_HAS_CONTENTS
1950                                       | SEC_IN_MEMORY
1951                                       | (info->pie ? 0 : SEC_READONLY)
1952                                       | SEC_LINKER_CREATED))
1953           || !bfd_set_section_alignment (abfd, fptr, 4))
1954         {
1955           BFD_ASSERT (0);
1956           return NULL;
1957         }
1958
1959       ia64_info->fptr_sec = fptr;
1960
1961       if (info->pie)
1962         {
1963           asection *fptr_rel;
1964           fptr_rel = bfd_make_section(abfd, ".rela.opd");
1965           if (fptr_rel == NULL
1966               || !bfd_set_section_flags (abfd, fptr_rel,
1967                                          (SEC_ALLOC | SEC_LOAD
1968                                           | SEC_HAS_CONTENTS
1969                                           | SEC_IN_MEMORY
1970                                           | SEC_LINKER_CREATED
1971                                           | SEC_READONLY))
1972               || !bfd_set_section_alignment (abfd, fptr_rel, 3))
1973             {
1974               BFD_ASSERT (0);
1975               return NULL;
1976             }
1977
1978           ia64_info->rel_fptr_sec = fptr_rel;
1979         }
1980     }
1981
1982   return fptr;
1983 }
1984
1985 static asection *
1986 get_pltoff (abfd, info, ia64_info)
1987      bfd *abfd;
1988      struct bfd_link_info *info ATTRIBUTE_UNUSED;
1989      struct elfNN_ia64_link_hash_table *ia64_info;
1990 {
1991   asection *pltoff;
1992   bfd *dynobj;
1993
1994   pltoff = ia64_info->pltoff_sec;
1995   if (!pltoff)
1996     {
1997       dynobj = ia64_info->root.dynobj;
1998       if (!dynobj)
1999         ia64_info->root.dynobj = dynobj = abfd;
2000
2001       pltoff = bfd_make_section (dynobj, ELF_STRING_ia64_pltoff);
2002       if (!pltoff
2003           || !bfd_set_section_flags (dynobj, pltoff,
2004                                      (SEC_ALLOC
2005                                       | SEC_LOAD
2006                                       | SEC_HAS_CONTENTS
2007                                       | SEC_IN_MEMORY
2008                                       | SEC_SMALL_DATA
2009                                       | SEC_LINKER_CREATED))
2010           || !bfd_set_section_alignment (abfd, pltoff, 4))
2011         {
2012           BFD_ASSERT (0);
2013           return NULL;
2014         }
2015
2016       ia64_info->pltoff_sec = pltoff;
2017     }
2018
2019   return pltoff;
2020 }
2021
2022 static asection *
2023 get_reloc_section (abfd, ia64_info, sec, create)
2024      bfd *abfd;
2025      struct elfNN_ia64_link_hash_table *ia64_info;
2026      asection *sec;
2027      bfd_boolean create;
2028 {
2029   const char *srel_name;
2030   asection *srel;
2031   bfd *dynobj;
2032
2033   srel_name = (bfd_elf_string_from_elf_section
2034                (abfd, elf_elfheader(abfd)->e_shstrndx,
2035                 elf_section_data(sec)->rel_hdr.sh_name));
2036   if (srel_name == NULL)
2037     return NULL;
2038
2039   BFD_ASSERT ((strncmp (srel_name, ".rela", 5) == 0
2040                && strcmp (bfd_get_section_name (abfd, sec),
2041                           srel_name+5) == 0)
2042               || (strncmp (srel_name, ".rel", 4) == 0
2043                   && strcmp (bfd_get_section_name (abfd, sec),
2044                              srel_name+4) == 0));
2045
2046   dynobj = ia64_info->root.dynobj;
2047   if (!dynobj)
2048     ia64_info->root.dynobj = dynobj = abfd;
2049
2050   srel = bfd_get_section_by_name (dynobj, srel_name);
2051   if (srel == NULL && create)
2052     {
2053       srel = bfd_make_section (dynobj, srel_name);
2054       if (srel == NULL
2055           || !bfd_set_section_flags (dynobj, srel,
2056                                      (SEC_ALLOC
2057                                       | SEC_LOAD
2058                                       | SEC_HAS_CONTENTS
2059                                       | SEC_IN_MEMORY
2060                                       | SEC_LINKER_CREATED
2061                                       | SEC_READONLY))
2062           || !bfd_set_section_alignment (dynobj, srel, 3))
2063         return NULL;
2064     }
2065
2066   if (sec->flags & SEC_READONLY)
2067     ia64_info->reltext = 1;
2068
2069   return srel;
2070 }
2071
2072 static bfd_boolean
2073 count_dyn_reloc (abfd, dyn_i, srel, type)
2074      bfd *abfd;
2075      struct elfNN_ia64_dyn_sym_info *dyn_i;
2076      asection *srel;
2077      int type;
2078 {
2079   struct elfNN_ia64_dyn_reloc_entry *rent;
2080
2081   for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
2082     if (rent->srel == srel && rent->type == type)
2083       break;
2084
2085   if (!rent)
2086     {
2087       rent = ((struct elfNN_ia64_dyn_reloc_entry *)
2088               bfd_alloc (abfd, (bfd_size_type) sizeof (*rent)));
2089       if (!rent)
2090         return FALSE;
2091
2092       rent->next = dyn_i->reloc_entries;
2093       rent->srel = srel;
2094       rent->type = type;
2095       rent->count = 0;
2096       dyn_i->reloc_entries = rent;
2097     }
2098   rent->count++;
2099
2100   return TRUE;
2101 }
2102
2103 static bfd_boolean
2104 elfNN_ia64_check_relocs (abfd, info, sec, relocs)
2105      bfd *abfd;
2106      struct bfd_link_info *info;
2107      asection *sec;
2108      const Elf_Internal_Rela *relocs;
2109 {
2110   struct elfNN_ia64_link_hash_table *ia64_info;
2111   const Elf_Internal_Rela *relend;
2112   Elf_Internal_Shdr *symtab_hdr;
2113   const Elf_Internal_Rela *rel;
2114   asection *got, *fptr, *srel;
2115
2116   if (info->relocatable)
2117     return TRUE;
2118
2119   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2120   ia64_info = elfNN_ia64_hash_table (info);
2121
2122   got = fptr = srel = NULL;
2123
2124   relend = relocs + sec->reloc_count;
2125   for (rel = relocs; rel < relend; ++rel)
2126     {
2127       enum {
2128         NEED_GOT = 1,
2129         NEED_GOTX = 2,
2130         NEED_FPTR = 4,
2131         NEED_PLTOFF = 8,
2132         NEED_MIN_PLT = 16,
2133         NEED_FULL_PLT = 32,
2134         NEED_DYNREL = 64,
2135         NEED_LTOFF_FPTR = 128,
2136         NEED_TPREL = 256,
2137         NEED_DTPMOD = 512,
2138         NEED_DTPREL = 1024
2139       };
2140
2141       struct elf_link_hash_entry *h = NULL;
2142       unsigned long r_symndx = ELFNN_R_SYM (rel->r_info);
2143       struct elfNN_ia64_dyn_sym_info *dyn_i;
2144       int need_entry;
2145       bfd_boolean maybe_dynamic;
2146       int dynrel_type = R_IA64_NONE;
2147
2148       if (r_symndx >= symtab_hdr->sh_info)
2149         {
2150           /* We're dealing with a global symbol -- find its hash entry
2151              and mark it as being referenced.  */
2152           long indx = r_symndx - symtab_hdr->sh_info;
2153           h = elf_sym_hashes (abfd)[indx];
2154           while (h->root.type == bfd_link_hash_indirect
2155                  || h->root.type == bfd_link_hash_warning)
2156             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2157
2158           h->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
2159         }
2160
2161       /* We can only get preliminary data on whether a symbol is
2162          locally or externally defined, as not all of the input files
2163          have yet been processed.  Do something with what we know, as
2164          this may help reduce memory usage and processing time later.  */
2165       maybe_dynamic = FALSE;
2166       if (h && ((!info->executable
2167                  && (!info->symbolic || info->unresolved_syms_in_shared_libs == RM_IGNORE))
2168                 || ! (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
2169                 || h->root.type == bfd_link_hash_defweak))
2170         maybe_dynamic = TRUE;
2171
2172       need_entry = 0;
2173       switch (ELFNN_R_TYPE (rel->r_info))
2174         {
2175         case R_IA64_TPREL64MSB:
2176         case R_IA64_TPREL64LSB:
2177           if (info->shared || maybe_dynamic)
2178             need_entry = NEED_DYNREL;
2179           dynrel_type = R_IA64_TPREL64LSB;
2180           if (info->shared)
2181             info->flags |= DF_STATIC_TLS;
2182           break;
2183
2184         case R_IA64_LTOFF_TPREL22:
2185           need_entry = NEED_TPREL;
2186           if (info->shared)
2187             info->flags |= DF_STATIC_TLS;
2188           break;
2189
2190         case R_IA64_DTPREL64MSB:
2191         case R_IA64_DTPREL64LSB:
2192           if (info->shared || maybe_dynamic)
2193             need_entry = NEED_DYNREL;
2194           dynrel_type = R_IA64_DTPREL64LSB;
2195           break;
2196
2197         case R_IA64_LTOFF_DTPREL22:
2198           need_entry = NEED_DTPREL;
2199           break;
2200
2201         case R_IA64_DTPMOD64MSB:
2202         case R_IA64_DTPMOD64LSB:
2203           if (info->shared || maybe_dynamic)
2204             need_entry = NEED_DYNREL;
2205           dynrel_type = R_IA64_DTPMOD64LSB;
2206           break;
2207
2208         case R_IA64_LTOFF_DTPMOD22:
2209           need_entry = NEED_DTPMOD;
2210           break;
2211
2212         case R_IA64_LTOFF_FPTR22:
2213         case R_IA64_LTOFF_FPTR64I:
2214         case R_IA64_LTOFF_FPTR32MSB:
2215         case R_IA64_LTOFF_FPTR32LSB:
2216         case R_IA64_LTOFF_FPTR64MSB:
2217         case R_IA64_LTOFF_FPTR64LSB:
2218           need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR;
2219           break;
2220
2221         case R_IA64_FPTR64I:
2222         case R_IA64_FPTR32MSB:
2223         case R_IA64_FPTR32LSB:
2224         case R_IA64_FPTR64MSB:
2225         case R_IA64_FPTR64LSB:
2226           if (info->shared || h)
2227             need_entry = NEED_FPTR | NEED_DYNREL;
2228           else
2229             need_entry = NEED_FPTR;
2230           dynrel_type = R_IA64_FPTR64LSB;
2231           break;
2232
2233         case R_IA64_LTOFF22:
2234         case R_IA64_LTOFF64I:
2235           need_entry = NEED_GOT;
2236           break;
2237
2238         case R_IA64_LTOFF22X:
2239           need_entry = NEED_GOTX;
2240           break;
2241
2242         case R_IA64_PLTOFF22:
2243         case R_IA64_PLTOFF64I:
2244         case R_IA64_PLTOFF64MSB:
2245         case R_IA64_PLTOFF64LSB:
2246           need_entry = NEED_PLTOFF;
2247           if (h)
2248             {
2249               if (maybe_dynamic)
2250                 need_entry |= NEED_MIN_PLT;
2251             }
2252           else
2253             {
2254               (*info->callbacks->warning)
2255                 (info, _("@pltoff reloc against local symbol"), 0,
2256                  abfd, 0, (bfd_vma) 0);
2257             }
2258           break;
2259
2260         case R_IA64_PCREL21B:
2261         case R_IA64_PCREL60B:
2262           /* Depending on where this symbol is defined, we may or may not
2263              need a full plt entry.  Only skip if we know we'll not need
2264              the entry -- static or symbolic, and the symbol definition
2265              has already been seen.  */
2266           if (maybe_dynamic && rel->r_addend == 0)
2267             need_entry = NEED_FULL_PLT;
2268           break;
2269
2270         case R_IA64_IMM14:
2271         case R_IA64_IMM22:
2272         case R_IA64_IMM64:
2273         case R_IA64_DIR32MSB:
2274         case R_IA64_DIR32LSB:
2275         case R_IA64_DIR64MSB:
2276         case R_IA64_DIR64LSB:
2277           /* Shared objects will always need at least a REL relocation.  */
2278           if (info->shared || maybe_dynamic)
2279             need_entry = NEED_DYNREL;
2280           dynrel_type = R_IA64_DIR64LSB;
2281           break;
2282
2283         case R_IA64_IPLTMSB:
2284         case R_IA64_IPLTLSB:
2285           /* Shared objects will always need at least a REL relocation.  */
2286           if (info->shared || maybe_dynamic)
2287             need_entry = NEED_DYNREL;
2288           dynrel_type = R_IA64_IPLTLSB;
2289           break;
2290
2291         case R_IA64_PCREL22:
2292         case R_IA64_PCREL64I:
2293         case R_IA64_PCREL32MSB:
2294         case R_IA64_PCREL32LSB:
2295         case R_IA64_PCREL64MSB:
2296         case R_IA64_PCREL64LSB:
2297           if (maybe_dynamic)
2298             need_entry = NEED_DYNREL;
2299           dynrel_type = R_IA64_PCREL64LSB;
2300           break;
2301         }
2302
2303       if (!need_entry)
2304         continue;
2305
2306       if ((need_entry & NEED_FPTR) != 0
2307           && rel->r_addend)
2308         {
2309           (*info->callbacks->warning)
2310             (info, _("non-zero addend in @fptr reloc"), 0,
2311              abfd, 0, (bfd_vma) 0);
2312         }
2313
2314       dyn_i = get_dyn_sym_info (ia64_info, h, abfd, rel, TRUE);
2315
2316       /* Record whether or not this is a local symbol.  */
2317       dyn_i->h = h;
2318
2319       /* Create what's needed.  */
2320       if (need_entry & (NEED_GOT | NEED_GOTX | NEED_TPREL
2321                         | NEED_DTPMOD | NEED_DTPREL))
2322         {
2323           if (!got)
2324             {
2325               got = get_got (abfd, info, ia64_info);
2326               if (!got)
2327                 return FALSE;
2328             }
2329           if (need_entry & NEED_GOT)
2330             dyn_i->want_got = 1;
2331           if (need_entry & NEED_GOTX)
2332             dyn_i->want_gotx = 1;
2333           if (need_entry & NEED_TPREL)
2334             dyn_i->want_tprel = 1;
2335           if (need_entry & NEED_DTPMOD)
2336             dyn_i->want_dtpmod = 1;
2337           if (need_entry & NEED_DTPREL)
2338             dyn_i->want_dtprel = 1;
2339         }
2340       if (need_entry & NEED_FPTR)
2341         {
2342           if (!fptr)
2343             {
2344               fptr = get_fptr (abfd, info, ia64_info);
2345               if (!fptr)
2346                 return FALSE;
2347             }
2348
2349           /* FPTRs for shared libraries are allocated by the dynamic
2350              linker.  Make sure this local symbol will appear in the
2351              dynamic symbol table.  */
2352           if (!h && info->shared)
2353             {
2354               if (! (_bfd_elfNN_link_record_local_dynamic_symbol
2355                      (info, abfd, (long) r_symndx)))
2356                 return FALSE;
2357             }
2358
2359           dyn_i->want_fptr = 1;
2360         }
2361       if (need_entry & NEED_LTOFF_FPTR)
2362         dyn_i->want_ltoff_fptr = 1;
2363       if (need_entry & (NEED_MIN_PLT | NEED_FULL_PLT))
2364         {
2365           if (!ia64_info->root.dynobj)
2366             ia64_info->root.dynobj = abfd;
2367           h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2368           dyn_i->want_plt = 1;
2369         }
2370       if (need_entry & NEED_FULL_PLT)
2371         dyn_i->want_plt2 = 1;
2372       if (need_entry & NEED_PLTOFF)
2373         dyn_i->want_pltoff = 1;
2374       if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC))
2375         {
2376           if (!srel)
2377             {
2378               srel = get_reloc_section (abfd, ia64_info, sec, TRUE);
2379               if (!srel)
2380                 return FALSE;
2381             }
2382           if (!count_dyn_reloc (abfd, dyn_i, srel, dynrel_type))
2383             return FALSE;
2384         }
2385     }
2386
2387   return TRUE;
2388 }
2389
2390 /* For cleanliness, and potentially faster dynamic loading, allocate
2391    external GOT entries first.  */
2392
2393 static bfd_boolean
2394 allocate_global_data_got (dyn_i, data)
2395      struct elfNN_ia64_dyn_sym_info *dyn_i;
2396      PTR data;
2397 {
2398   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2399
2400   if ((dyn_i->want_got || dyn_i->want_gotx)
2401       && ! dyn_i->want_fptr
2402       && elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
2403      {
2404        dyn_i->got_offset = x->ofs;
2405        x->ofs += 8;
2406      }
2407   if (dyn_i->want_tprel)
2408     {
2409       dyn_i->tprel_offset = x->ofs;
2410       x->ofs += 8;
2411     }
2412   if (dyn_i->want_dtpmod)
2413     {
2414       if (elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
2415         {
2416           dyn_i->dtpmod_offset = x->ofs;
2417           x->ofs += 8;
2418         }
2419       else
2420         {
2421           struct elfNN_ia64_link_hash_table *ia64_info;
2422
2423           ia64_info = elfNN_ia64_hash_table (x->info);
2424           if (ia64_info->self_dtpmod_offset == (bfd_vma) -1)
2425             {
2426               ia64_info->self_dtpmod_offset = x->ofs;
2427               x->ofs += 8;
2428             }
2429           dyn_i->dtpmod_offset = ia64_info->self_dtpmod_offset;
2430         }
2431     }
2432   if (dyn_i->want_dtprel)
2433     {
2434       dyn_i->dtprel_offset = x->ofs;
2435       x->ofs += 8;
2436     }
2437   return TRUE;
2438 }
2439
2440 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs.  */
2441
2442 static bfd_boolean
2443 allocate_global_fptr_got (dyn_i, data)
2444      struct elfNN_ia64_dyn_sym_info *dyn_i;
2445      PTR data;
2446 {
2447   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2448
2449   if (dyn_i->want_got
2450       && dyn_i->want_fptr
2451       && elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, R_IA64_FPTR64LSB))
2452     {
2453       dyn_i->got_offset = x->ofs;
2454       x->ofs += 8;
2455     }
2456   return TRUE;
2457 }
2458
2459 /* Lastly, allocate all the GOT entries for local data.  */
2460
2461 static bfd_boolean
2462 allocate_local_got (dyn_i, data)
2463      struct elfNN_ia64_dyn_sym_info *dyn_i;
2464      PTR data;
2465 {
2466   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2467
2468   if ((dyn_i->want_got || dyn_i->want_gotx)
2469       && !elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
2470     {
2471       dyn_i->got_offset = x->ofs;
2472       x->ofs += 8;
2473     }
2474   return TRUE;
2475 }
2476
2477 /* Search for the index of a global symbol in it's defining object file.  */
2478
2479 static long
2480 global_sym_index (h)
2481      struct elf_link_hash_entry *h;
2482 {
2483   struct elf_link_hash_entry **p;
2484   bfd *obj;
2485
2486   BFD_ASSERT (h->root.type == bfd_link_hash_defined
2487               || h->root.type == bfd_link_hash_defweak);
2488
2489   obj = h->root.u.def.section->owner;
2490   for (p = elf_sym_hashes (obj); *p != h; ++p)
2491     continue;
2492
2493   return p - elf_sym_hashes (obj) + elf_tdata (obj)->symtab_hdr.sh_info;
2494 }
2495
2496 /* Allocate function descriptors.  We can do these for every function
2497    in a main executable that is not exported.  */
2498
2499 static bfd_boolean
2500 allocate_fptr (dyn_i, data)
2501      struct elfNN_ia64_dyn_sym_info *dyn_i;
2502      PTR data;
2503 {
2504   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2505
2506   if (dyn_i->want_fptr)
2507     {
2508       struct elf_link_hash_entry *h = dyn_i->h;
2509
2510       if (h)
2511         while (h->root.type == bfd_link_hash_indirect
2512                || h->root.type == bfd_link_hash_warning)
2513           h = (struct elf_link_hash_entry *) h->root.u.i.link;
2514
2515       if (!x->info->executable
2516           && (!h
2517               || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2518               || h->root.type != bfd_link_hash_undefweak))
2519         {
2520           if (h && h->dynindx == -1)
2521             {
2522               BFD_ASSERT ((h->root.type == bfd_link_hash_defined)
2523                           || (h->root.type == bfd_link_hash_defweak));
2524
2525               if (!_bfd_elfNN_link_record_local_dynamic_symbol
2526                     (x->info, h->root.u.def.section->owner,
2527                      global_sym_index (h)))
2528                 return FALSE;
2529             }
2530
2531           dyn_i->want_fptr = 0;
2532         }
2533       else if (h == NULL || h->dynindx == -1)
2534         {
2535           dyn_i->fptr_offset = x->ofs;
2536           x->ofs += 16;
2537         }
2538       else
2539         dyn_i->want_fptr = 0;
2540     }
2541   return TRUE;
2542 }
2543
2544 /* Allocate all the minimal PLT entries.  */
2545
2546 static bfd_boolean
2547 allocate_plt_entries (dyn_i, data)
2548      struct elfNN_ia64_dyn_sym_info *dyn_i;
2549      PTR data;
2550 {
2551   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2552
2553   if (dyn_i->want_plt)
2554     {
2555       struct elf_link_hash_entry *h = dyn_i->h;
2556
2557       if (h)
2558         while (h->root.type == bfd_link_hash_indirect
2559                || h->root.type == bfd_link_hash_warning)
2560           h = (struct elf_link_hash_entry *) h->root.u.i.link;
2561
2562       /* ??? Versioned symbols seem to lose ELF_LINK_HASH_NEEDS_PLT.  */
2563       if (elfNN_ia64_dynamic_symbol_p (h, x->info, 0))
2564         {
2565           bfd_size_type offset = x->ofs;
2566           if (offset == 0)
2567             offset = PLT_HEADER_SIZE;
2568           dyn_i->plt_offset = offset;
2569           x->ofs = offset + PLT_MIN_ENTRY_SIZE;
2570
2571           dyn_i->want_pltoff = 1;
2572         }
2573       else
2574         {
2575           dyn_i->want_plt = 0;
2576           dyn_i->want_plt2 = 0;
2577         }
2578     }
2579   return TRUE;
2580 }
2581
2582 /* Allocate all the full PLT entries.  */
2583
2584 static bfd_boolean
2585 allocate_plt2_entries (dyn_i, data)
2586      struct elfNN_ia64_dyn_sym_info *dyn_i;
2587      PTR data;
2588 {
2589   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2590
2591   if (dyn_i->want_plt2)
2592     {
2593       struct elf_link_hash_entry *h = dyn_i->h;
2594       bfd_size_type ofs = x->ofs;
2595
2596       dyn_i->plt2_offset = ofs;
2597       x->ofs = ofs + PLT_FULL_ENTRY_SIZE;
2598
2599       while (h->root.type == bfd_link_hash_indirect
2600              || h->root.type == bfd_link_hash_warning)
2601         h = (struct elf_link_hash_entry *) h->root.u.i.link;
2602       dyn_i->h->plt.offset = ofs;
2603     }
2604   return TRUE;
2605 }
2606
2607 /* Allocate all the PLTOFF entries requested by relocations and
2608    plt entries.  We can't share space with allocated FPTR entries,
2609    because the latter are not necessarily addressable by the GP.
2610    ??? Relaxation might be able to determine that they are.  */
2611
2612 static bfd_boolean
2613 allocate_pltoff_entries (dyn_i, data)
2614      struct elfNN_ia64_dyn_sym_info *dyn_i;
2615      PTR data;
2616 {
2617   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2618
2619   if (dyn_i->want_pltoff)
2620     {
2621       dyn_i->pltoff_offset = x->ofs;
2622       x->ofs += 16;
2623     }
2624   return TRUE;
2625 }
2626
2627 /* Allocate dynamic relocations for those symbols that turned out
2628    to be dynamic.  */
2629
2630 static bfd_boolean
2631 allocate_dynrel_entries (dyn_i, data)
2632      struct elfNN_ia64_dyn_sym_info *dyn_i;
2633      PTR data;
2634 {
2635   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2636   struct elfNN_ia64_link_hash_table *ia64_info;
2637   struct elfNN_ia64_dyn_reloc_entry *rent;
2638   bfd_boolean dynamic_symbol, shared, resolved_zero;
2639
2640   ia64_info = elfNN_ia64_hash_table (x->info);
2641
2642   /* Note that this can't be used in relation to FPTR relocs below.  */
2643   dynamic_symbol = elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0);
2644
2645   shared = x->info->shared;
2646   resolved_zero = (dyn_i->h
2647                    && ELF_ST_VISIBILITY (dyn_i->h->other)
2648                    && dyn_i->h->root.type == bfd_link_hash_undefweak);
2649
2650   /* Take care of the normal data relocations.  */
2651
2652   for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
2653     {
2654       int count = rent->count;
2655
2656       switch (rent->type)
2657         {
2658         case R_IA64_FPTR64LSB:
2659           /* Allocate one iff !want_fptr and not PIE, which by this point
2660              will be true only if we're actually allocating one statically
2661              in the main executable.  Position independent executables
2662              need a relative reloc.  */
2663           if (dyn_i->want_fptr && !x->info->pie)
2664             continue;
2665           break;
2666         case R_IA64_PCREL64LSB:
2667           if (!dynamic_symbol)
2668             continue;
2669           break;
2670         case R_IA64_DIR64LSB:
2671           if (!dynamic_symbol && !shared)
2672             continue;
2673           break;
2674         case R_IA64_IPLTLSB:
2675           if (!dynamic_symbol && !shared)
2676             continue;
2677           /* Use two REL relocations for IPLT relocations
2678              against local symbols.  */
2679           if (!dynamic_symbol)
2680             count *= 2;
2681           break;
2682         case R_IA64_TPREL64LSB:
2683         case R_IA64_DTPREL64LSB:
2684         case R_IA64_DTPMOD64LSB:
2685           break;
2686         default:
2687           abort ();
2688         }
2689       rent->srel->_raw_size += sizeof (ElfNN_External_Rela) * count;
2690     }
2691
2692   /* Take care of the GOT and PLT relocations.  */
2693
2694   if ((!resolved_zero
2695        && (dynamic_symbol || shared)
2696        && (dyn_i->want_got || dyn_i->want_gotx))
2697       || (dyn_i->want_ltoff_fptr
2698           && dyn_i->h
2699           && dyn_i->h->dynindx != -1))
2700     {
2701       if (!dyn_i->want_ltoff_fptr
2702           || !x->info->pie
2703           || dyn_i->h == NULL
2704           || dyn_i->h->root.type != bfd_link_hash_undefweak)
2705         ia64_info->rel_got_sec->_raw_size += sizeof (ElfNN_External_Rela);
2706     }
2707   if ((dynamic_symbol || shared) && dyn_i->want_tprel)
2708     ia64_info->rel_got_sec->_raw_size += sizeof (ElfNN_External_Rela);
2709   if (dynamic_symbol && dyn_i->want_dtpmod)
2710     ia64_info->rel_got_sec->_raw_size += sizeof (ElfNN_External_Rela);
2711   if (dynamic_symbol && dyn_i->want_dtprel)
2712     ia64_info->rel_got_sec->_raw_size += sizeof (ElfNN_External_Rela);
2713   if (ia64_info->rel_fptr_sec && dyn_i->want_fptr)
2714     {
2715       if (dyn_i->h == NULL || dyn_i->h->root.type != bfd_link_hash_undefweak)
2716         ia64_info->rel_fptr_sec->_raw_size += sizeof (ElfNN_External_Rela);
2717     }
2718
2719   if (!resolved_zero && dyn_i->want_pltoff)
2720     {
2721       bfd_size_type t = 0;
2722
2723       /* Dynamic symbols get one IPLT relocation.  Local symbols in
2724          shared libraries get two REL relocations.  Local symbols in
2725          main applications get nothing.  */
2726       if (dynamic_symbol)
2727         t = sizeof (ElfNN_External_Rela);
2728       else if (shared)
2729         t = 2 * sizeof (ElfNN_External_Rela);
2730
2731       ia64_info->rel_pltoff_sec->_raw_size += t;
2732     }
2733
2734   return TRUE;
2735 }
2736
2737 static bfd_boolean
2738 elfNN_ia64_adjust_dynamic_symbol (info, h)
2739      struct bfd_link_info *info ATTRIBUTE_UNUSED;
2740      struct elf_link_hash_entry *h;
2741 {
2742   /* ??? Undefined symbols with PLT entries should be re-defined
2743      to be the PLT entry.  */
2744
2745   /* If this is a weak symbol, and there is a real definition, the
2746      processor independent code will have arranged for us to see the
2747      real definition first, and we can just use the same value.  */
2748   if (h->weakdef != NULL)
2749     {
2750       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2751                   || h->weakdef->root.type == bfd_link_hash_defweak);
2752       h->root.u.def.section = h->weakdef->root.u.def.section;
2753       h->root.u.def.value = h->weakdef->root.u.def.value;
2754       return TRUE;
2755     }
2756
2757   /* If this is a reference to a symbol defined by a dynamic object which
2758      is not a function, we might allocate the symbol in our .dynbss section
2759      and allocate a COPY dynamic relocation.
2760
2761      But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2762      of hackery.  */
2763
2764   return TRUE;
2765 }
2766
2767 static bfd_boolean
2768 elfNN_ia64_size_dynamic_sections (output_bfd, info)
2769      bfd *output_bfd ATTRIBUTE_UNUSED;
2770      struct bfd_link_info *info;
2771 {
2772   struct elfNN_ia64_allocate_data data;
2773   struct elfNN_ia64_link_hash_table *ia64_info;
2774   asection *sec;
2775   bfd *dynobj;
2776   bfd_boolean relplt = FALSE;
2777
2778   dynobj = elf_hash_table(info)->dynobj;
2779   ia64_info = elfNN_ia64_hash_table (info);
2780   ia64_info->self_dtpmod_offset = (bfd_vma) -1;
2781   BFD_ASSERT(dynobj != NULL);
2782   data.info = info;
2783
2784   /* Set the contents of the .interp section to the interpreter.  */
2785   if (ia64_info->root.dynamic_sections_created
2786       && info->executable)
2787     {
2788       sec = bfd_get_section_by_name (dynobj, ".interp");
2789       BFD_ASSERT (sec != NULL);
2790       sec->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
2791       sec->_raw_size = strlen (ELF_DYNAMIC_INTERPRETER) + 1;
2792     }
2793
2794   /* Allocate the GOT entries.  */
2795
2796   if (ia64_info->got_sec)
2797     {
2798       data.ofs = 0;
2799       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data);
2800       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data);
2801       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data);
2802       ia64_info->got_sec->_raw_size = data.ofs;
2803     }
2804
2805   /* Allocate the FPTR entries.  */
2806
2807   if (ia64_info->fptr_sec)
2808     {
2809       data.ofs = 0;
2810       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_fptr, &data);
2811       ia64_info->fptr_sec->_raw_size = data.ofs;
2812     }
2813
2814   /* Now that we've seen all of the input files, we can decide which
2815      symbols need plt entries.  Allocate the minimal PLT entries first.
2816      We do this even though dynamic_sections_created may be FALSE, because
2817      this has the side-effect of clearing want_plt and want_plt2.  */
2818
2819   data.ofs = 0;
2820   elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_plt_entries, &data);
2821
2822   ia64_info->minplt_entries = 0;
2823   if (data.ofs)
2824     {
2825       ia64_info->minplt_entries
2826         = (data.ofs - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
2827     }
2828
2829   /* Align the pointer for the plt2 entries.  */
2830   data.ofs = (data.ofs + 31) & (bfd_vma) -32;
2831
2832   elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_plt2_entries, &data);
2833   if (data.ofs != 0)
2834     {
2835       BFD_ASSERT (ia64_info->root.dynamic_sections_created);
2836
2837       ia64_info->plt_sec->_raw_size = data.ofs;
2838
2839       /* If we've got a .plt, we need some extra memory for the dynamic
2840          linker.  We stuff these in .got.plt.  */
2841       sec = bfd_get_section_by_name (dynobj, ".got.plt");
2842       sec->_raw_size = 8 * PLT_RESERVED_WORDS;
2843     }
2844
2845   /* Allocate the PLTOFF entries.  */
2846
2847   if (ia64_info->pltoff_sec)
2848     {
2849       data.ofs = 0;
2850       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_pltoff_entries, &data);
2851       ia64_info->pltoff_sec->_raw_size = data.ofs;
2852     }
2853
2854   if (ia64_info->root.dynamic_sections_created)
2855     {
2856       /* Allocate space for the dynamic relocations that turned out to be
2857          required.  */
2858
2859       if (info->shared && ia64_info->self_dtpmod_offset != (bfd_vma) -1)
2860         ia64_info->rel_got_sec->_raw_size += sizeof (ElfNN_External_Rela);
2861       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries, &data);
2862     }
2863
2864   /* We have now determined the sizes of the various dynamic sections.
2865      Allocate memory for them.  */
2866   for (sec = dynobj->sections; sec != NULL; sec = sec->next)
2867     {
2868       bfd_boolean strip;
2869
2870       if (!(sec->flags & SEC_LINKER_CREATED))
2871         continue;
2872
2873       /* If we don't need this section, strip it from the output file.
2874          There were several sections primarily related to dynamic
2875          linking that must be create before the linker maps input
2876          sections to output sections.  The linker does that before
2877          bfd_elf_size_dynamic_sections is called, and it is that
2878          function which decides whether anything needs to go into
2879          these sections.  */
2880
2881       strip = (sec->_raw_size == 0);
2882
2883       if (sec == ia64_info->got_sec)
2884         strip = FALSE;
2885       else if (sec == ia64_info->rel_got_sec)
2886         {
2887           if (strip)
2888             ia64_info->rel_got_sec = NULL;
2889           else
2890             /* We use the reloc_count field as a counter if we need to
2891                copy relocs into the output file.  */
2892             sec->reloc_count = 0;
2893         }
2894       else if (sec == ia64_info->fptr_sec)
2895         {
2896           if (strip)
2897             ia64_info->fptr_sec = NULL;
2898         }
2899       else if (sec == ia64_info->plt_sec)
2900         {
2901           if (strip)
2902             ia64_info->plt_sec = NULL;
2903         }
2904       else if (sec == ia64_info->pltoff_sec)
2905         {
2906           if (strip)
2907             ia64_info->pltoff_sec = NULL;
2908         }
2909       else if (sec == ia64_info->rel_pltoff_sec)
2910         {
2911           if (strip)
2912             ia64_info->rel_pltoff_sec = NULL;
2913           else
2914             {
2915               relplt = TRUE;
2916               /* We use the reloc_count field as a counter if we need to
2917                  copy relocs into the output file.  */
2918               sec->reloc_count = 0;
2919             }
2920         }
2921       else
2922         {
2923           const char *name;
2924
2925           /* It's OK to base decisions on the section name, because none
2926              of the dynobj section names depend upon the input files.  */
2927           name = bfd_get_section_name (dynobj, sec);
2928
2929           if (strcmp (name, ".got.plt") == 0)
2930             strip = FALSE;
2931           else if (strncmp (name, ".rel", 4) == 0)
2932             {
2933               if (!strip)
2934                 {
2935                   /* We use the reloc_count field as a counter if we need to
2936                      copy relocs into the output file.  */
2937                   sec->reloc_count = 0;
2938                 }
2939             }
2940           else
2941             continue;
2942         }
2943
2944       if (strip)
2945         _bfd_strip_section_from_output (info, sec);
2946       else
2947         {
2948           /* Allocate memory for the section contents.  */
2949           sec->contents = (bfd_byte *) bfd_zalloc (dynobj, sec->_raw_size);
2950           if (sec->contents == NULL && sec->_raw_size != 0)
2951             return FALSE;
2952         }
2953     }
2954
2955   if (elf_hash_table (info)->dynamic_sections_created)
2956     {
2957       /* Add some entries to the .dynamic section.  We fill in the values
2958          later (in finish_dynamic_sections) but we must add the entries now
2959          so that we get the correct size for the .dynamic section.  */
2960
2961       if (info->executable)
2962         {
2963           /* The DT_DEBUG entry is filled in by the dynamic linker and used
2964              by the debugger.  */
2965 #define add_dynamic_entry(TAG, VAL) \
2966   bfd_elfNN_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
2967
2968           if (!add_dynamic_entry (DT_DEBUG, 0))
2969             return FALSE;
2970         }
2971
2972       if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE, 0))
2973         return FALSE;
2974       if (!add_dynamic_entry (DT_PLTGOT, 0))
2975         return FALSE;
2976
2977       if (relplt)
2978         {
2979           if (!add_dynamic_entry (DT_PLTRELSZ, 0)
2980               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2981               || !add_dynamic_entry (DT_JMPREL, 0))
2982             return FALSE;
2983         }
2984
2985       if (!add_dynamic_entry (DT_RELA, 0)
2986           || !add_dynamic_entry (DT_RELASZ, 0)
2987           || !add_dynamic_entry (DT_RELAENT, sizeof (ElfNN_External_Rela)))
2988         return FALSE;
2989
2990       if (ia64_info->reltext)
2991         {
2992           if (!add_dynamic_entry (DT_TEXTREL, 0))
2993             return FALSE;
2994           info->flags |= DF_TEXTREL;
2995         }
2996     }
2997
2998   /* ??? Perhaps force __gp local.  */
2999
3000   return TRUE;
3001 }
3002
3003 static bfd_reloc_status_type
3004 elfNN_ia64_install_value (abfd, hit_addr, v, r_type)
3005      bfd *abfd;
3006      bfd_byte *hit_addr;
3007      bfd_vma v;
3008      unsigned int r_type;
3009 {
3010   const struct ia64_operand *op;
3011   int bigendian = 0, shift = 0;
3012   bfd_vma t0, t1, insn, dword;
3013   enum ia64_opnd opnd;
3014   const char *err;
3015   size_t size = 8;
3016 #ifdef BFD_HOST_U_64_BIT
3017   BFD_HOST_U_64_BIT val = (BFD_HOST_U_64_BIT) v;
3018 #else
3019   bfd_vma val = v;
3020 #endif
3021
3022   opnd = IA64_OPND_NIL;
3023   switch (r_type)
3024     {
3025     case R_IA64_NONE:
3026     case R_IA64_LDXMOV:
3027       return bfd_reloc_ok;
3028
3029       /* Instruction relocations.  */
3030
3031     case R_IA64_IMM14:
3032     case R_IA64_TPREL14:
3033     case R_IA64_DTPREL14:
3034       opnd = IA64_OPND_IMM14;
3035       break;
3036
3037     case R_IA64_PCREL21F:       opnd = IA64_OPND_TGT25; break;
3038     case R_IA64_PCREL21M:       opnd = IA64_OPND_TGT25b; break;
3039     case R_IA64_PCREL60B:       opnd = IA64_OPND_TGT64; break;
3040     case R_IA64_PCREL21B:
3041     case R_IA64_PCREL21BI:
3042       opnd = IA64_OPND_TGT25c;
3043       break;
3044
3045     case R_IA64_IMM22:
3046     case R_IA64_GPREL22:
3047     case R_IA64_LTOFF22:
3048     case R_IA64_LTOFF22X:
3049     case R_IA64_PLTOFF22:
3050     case R_IA64_PCREL22:
3051     case R_IA64_LTOFF_FPTR22:
3052     case R_IA64_TPREL22:
3053     case R_IA64_DTPREL22:
3054     case R_IA64_LTOFF_TPREL22:
3055     case R_IA64_LTOFF_DTPMOD22:
3056     case R_IA64_LTOFF_DTPREL22:
3057       opnd = IA64_OPND_IMM22;
3058       break;
3059
3060     case R_IA64_IMM64:
3061     case R_IA64_GPREL64I:
3062     case R_IA64_LTOFF64I:
3063     case R_IA64_PLTOFF64I:
3064     case R_IA64_PCREL64I:
3065     case R_IA64_FPTR64I:
3066     case R_IA64_LTOFF_FPTR64I:
3067     case R_IA64_TPREL64I:
3068     case R_IA64_DTPREL64I:
3069       opnd = IA64_OPND_IMMU64;
3070       break;
3071
3072       /* Data relocations.  */
3073
3074     case R_IA64_DIR32MSB:
3075     case R_IA64_GPREL32MSB:
3076     case R_IA64_FPTR32MSB:
3077     case R_IA64_PCREL32MSB:
3078     case R_IA64_LTOFF_FPTR32MSB:
3079     case R_IA64_SEGREL32MSB:
3080     case R_IA64_SECREL32MSB:
3081     case R_IA64_LTV32MSB:
3082     case R_IA64_DTPREL32MSB:
3083       size = 4; bigendian = 1;
3084       break;
3085
3086     case R_IA64_DIR32LSB:
3087     case R_IA64_GPREL32LSB:
3088     case R_IA64_FPTR32LSB:
3089     case R_IA64_PCREL32LSB:
3090     case R_IA64_LTOFF_FPTR32LSB:
3091     case R_IA64_SEGREL32LSB:
3092     case R_IA64_SECREL32LSB:
3093     case R_IA64_LTV32LSB:
3094     case R_IA64_DTPREL32LSB:
3095       size = 4; bigendian = 0;
3096       break;
3097
3098     case R_IA64_DIR64MSB:
3099     case R_IA64_GPREL64MSB:
3100     case R_IA64_PLTOFF64MSB:
3101     case R_IA64_FPTR64MSB:
3102     case R_IA64_PCREL64MSB:
3103     case R_IA64_LTOFF_FPTR64MSB:
3104     case R_IA64_SEGREL64MSB:
3105     case R_IA64_SECREL64MSB:
3106     case R_IA64_LTV64MSB:
3107     case R_IA64_TPREL64MSB:
3108     case R_IA64_DTPMOD64MSB:
3109     case R_IA64_DTPREL64MSB:
3110       size = 8; bigendian = 1;
3111       break;
3112
3113     case R_IA64_DIR64LSB:
3114     case R_IA64_GPREL64LSB:
3115     case R_IA64_PLTOFF64LSB:
3116     case R_IA64_FPTR64LSB:
3117     case R_IA64_PCREL64LSB:
3118     case R_IA64_LTOFF_FPTR64LSB:
3119     case R_IA64_SEGREL64LSB:
3120     case R_IA64_SECREL64LSB:
3121     case R_IA64_LTV64LSB:
3122     case R_IA64_TPREL64LSB:
3123     case R_IA64_DTPMOD64LSB:
3124     case R_IA64_DTPREL64LSB:
3125       size = 8; bigendian = 0;
3126       break;
3127
3128       /* Unsupported / Dynamic relocations.  */
3129     default:
3130       return bfd_reloc_notsupported;
3131     }
3132
3133   switch (opnd)
3134     {
3135     case IA64_OPND_IMMU64:
3136       hit_addr -= (long) hit_addr & 0x3;
3137       t0 = bfd_get_64 (abfd, hit_addr);
3138       t1 = bfd_get_64 (abfd, hit_addr + 8);
3139
3140       /* tmpl/s: bits  0.. 5 in t0
3141          slot 0: bits  5..45 in t0
3142          slot 1: bits 46..63 in t0, bits 0..22 in t1
3143          slot 2: bits 23..63 in t1 */
3144
3145       /* First, clear the bits that form the 64 bit constant.  */
3146       t0 &= ~(0x3ffffLL << 46);
3147       t1 &= ~(0x7fffffLL
3148               | ((  (0x07fLL << 13) | (0x1ffLL << 27)
3149                     | (0x01fLL << 22) | (0x001LL << 21)
3150                     | (0x001LL << 36)) << 23));
3151
3152       t0 |= ((val >> 22) & 0x03ffffLL) << 46;           /* 18 lsbs of imm41 */
3153       t1 |= ((val >> 40) & 0x7fffffLL) <<  0;           /* 23 msbs of imm41 */
3154       t1 |= (  (((val >>  0) & 0x07f) << 13)            /* imm7b */
3155                | (((val >>  7) & 0x1ff) << 27)          /* imm9d */
3156                | (((val >> 16) & 0x01f) << 22)          /* imm5c */
3157                | (((val >> 21) & 0x001) << 21)          /* ic */
3158                | (((val >> 63) & 0x001) << 36)) << 23;  /* i */
3159
3160       bfd_put_64 (abfd, t0, hit_addr);
3161       bfd_put_64 (abfd, t1, hit_addr + 8);
3162       break;
3163
3164     case IA64_OPND_TGT64:
3165       hit_addr -= (long) hit_addr & 0x3;
3166       t0 = bfd_get_64 (abfd, hit_addr);
3167       t1 = bfd_get_64 (abfd, hit_addr + 8);
3168
3169       /* tmpl/s: bits  0.. 5 in t0
3170          slot 0: bits  5..45 in t0
3171          slot 1: bits 46..63 in t0, bits 0..22 in t1
3172          slot 2: bits 23..63 in t1 */
3173
3174       /* First, clear the bits that form the 64 bit constant.  */
3175       t0 &= ~(0x3ffffLL << 46);
3176       t1 &= ~(0x7fffffLL
3177               | ((1LL << 36 | 0xfffffLL << 13) << 23));
3178
3179       val >>= 4;
3180       t0 |= ((val >> 20) & 0xffffLL) << 2 << 46;        /* 16 lsbs of imm39 */
3181       t1 |= ((val >> 36) & 0x7fffffLL) << 0;            /* 23 msbs of imm39 */
3182       t1 |= ((((val >> 0) & 0xfffffLL) << 13)           /* imm20b */
3183               | (((val >> 59) & 0x1LL) << 36)) << 23;   /* i */
3184
3185       bfd_put_64 (abfd, t0, hit_addr);
3186       bfd_put_64 (abfd, t1, hit_addr + 8);
3187       break;
3188
3189     default:
3190       switch ((long) hit_addr & 0x3)
3191         {
3192         case 0: shift =  5; break;
3193         case 1: shift = 14; hit_addr += 3; break;
3194         case 2: shift = 23; hit_addr += 6; break;
3195         case 3: return bfd_reloc_notsupported; /* shouldn't happen...  */
3196         }
3197       dword = bfd_get_64 (abfd, hit_addr);
3198       insn = (dword >> shift) & 0x1ffffffffffLL;
3199
3200       op = elf64_ia64_operands + opnd;
3201       err = (*op->insert) (op, val, (ia64_insn *)& insn);
3202       if (err)
3203         return bfd_reloc_overflow;
3204
3205       dword &= ~(0x1ffffffffffLL << shift);
3206       dword |= (insn << shift);
3207       bfd_put_64 (abfd, dword, hit_addr);
3208       break;
3209
3210     case IA64_OPND_NIL:
3211       /* A data relocation.  */
3212       if (bigendian)
3213         if (size == 4)
3214           bfd_putb32 (val, hit_addr);
3215         else
3216           bfd_putb64 (val, hit_addr);
3217       else
3218         if (size == 4)
3219           bfd_putl32 (val, hit_addr);
3220         else
3221           bfd_putl64 (val, hit_addr);
3222       break;
3223     }
3224
3225   return bfd_reloc_ok;
3226 }
3227
3228 static void
3229 elfNN_ia64_install_dyn_reloc (abfd, info, sec, srel, offset, type,
3230                               dynindx, addend)
3231      bfd *abfd;
3232      struct bfd_link_info *info;
3233      asection *sec;
3234      asection *srel;
3235      bfd_vma offset;
3236      unsigned int type;
3237      long dynindx;
3238      bfd_vma addend;
3239 {
3240   Elf_Internal_Rela outrel;
3241   bfd_byte *loc;
3242
3243   BFD_ASSERT (dynindx != -1);
3244   outrel.r_info = ELFNN_R_INFO (dynindx, type);
3245   outrel.r_addend = addend;
3246   outrel.r_offset = _bfd_elf_section_offset (abfd, info, sec, offset);
3247   if (outrel.r_offset >= (bfd_vma) -2)
3248     {
3249       /* Run for the hills.  We shouldn't be outputting a relocation
3250          for this.  So do what everyone else does and output a no-op.  */
3251       outrel.r_info = ELFNN_R_INFO (0, R_IA64_NONE);
3252       outrel.r_addend = 0;
3253       outrel.r_offset = 0;
3254     }
3255   else
3256     outrel.r_offset += sec->output_section->vma + sec->output_offset;
3257
3258   loc = srel->contents;
3259   loc += srel->reloc_count++ * sizeof (ElfNN_External_Rela);
3260   bfd_elfNN_swap_reloca_out (abfd, &outrel, loc);
3261   BFD_ASSERT (sizeof (ElfNN_External_Rela) * srel->reloc_count
3262               <= srel->_cooked_size);
3263 }
3264
3265 /* Store an entry for target address TARGET_ADDR in the linkage table
3266    and return the gp-relative address of the linkage table entry.  */
3267
3268 static bfd_vma
3269 set_got_entry (abfd, info, dyn_i, dynindx, addend, value, dyn_r_type)
3270      bfd *abfd;
3271      struct bfd_link_info *info;
3272      struct elfNN_ia64_dyn_sym_info *dyn_i;
3273      long dynindx;
3274      bfd_vma addend;
3275      bfd_vma value;
3276      unsigned int dyn_r_type;
3277 {
3278   struct elfNN_ia64_link_hash_table *ia64_info;
3279   asection *got_sec;
3280   bfd_boolean done;
3281   bfd_vma got_offset;
3282
3283   ia64_info = elfNN_ia64_hash_table (info);
3284   got_sec = ia64_info->got_sec;
3285
3286   switch (dyn_r_type)
3287     {
3288     case R_IA64_TPREL64LSB:
3289       done = dyn_i->tprel_done;
3290       dyn_i->tprel_done = TRUE;
3291       got_offset = dyn_i->tprel_offset;
3292       break;
3293     case R_IA64_DTPMOD64LSB:
3294       if (dyn_i->dtpmod_offset != ia64_info->self_dtpmod_offset)
3295         {
3296           done = dyn_i->dtpmod_done;
3297           dyn_i->dtpmod_done = TRUE;
3298         }
3299       else
3300         {
3301           done = ia64_info->self_dtpmod_done;
3302           ia64_info->self_dtpmod_done = TRUE;
3303           dynindx = 0;
3304         }
3305       got_offset = dyn_i->dtpmod_offset;
3306       break;
3307     case R_IA64_DTPREL64LSB:
3308       done = dyn_i->dtprel_done;
3309       dyn_i->dtprel_done = TRUE;
3310       got_offset = dyn_i->dtprel_offset;
3311       break;
3312     default:
3313       done = dyn_i->got_done;
3314       dyn_i->got_done = TRUE;
3315       got_offset = dyn_i->got_offset;
3316       break;
3317     }
3318
3319   BFD_ASSERT ((got_offset & 7) == 0);
3320
3321   if (! done)
3322     {
3323       /* Store the target address in the linkage table entry.  */
3324       bfd_put_64 (abfd, value, got_sec->contents + got_offset);
3325
3326       /* Install a dynamic relocation if needed.  */
3327       if (((info->shared
3328             && (!dyn_i->h
3329                 || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
3330                 || dyn_i->h->root.type != bfd_link_hash_undefweak)
3331             && dyn_r_type != R_IA64_DTPREL64LSB)
3332            || elfNN_ia64_dynamic_symbol_p (dyn_i->h, info, dyn_r_type)
3333            || (dynindx != -1 && dyn_r_type == R_IA64_FPTR64LSB))
3334           && (!dyn_i->want_ltoff_fptr
3335               || !info->pie
3336               || !dyn_i->h
3337               || dyn_i->h->root.type != bfd_link_hash_undefweak))
3338         {
3339           if (dynindx == -1
3340               && dyn_r_type != R_IA64_TPREL64LSB
3341               && dyn_r_type != R_IA64_DTPMOD64LSB
3342               && dyn_r_type != R_IA64_DTPREL64LSB)
3343             {
3344               dyn_r_type = R_IA64_REL64LSB;
3345               dynindx = 0;
3346               addend = value;
3347             }
3348
3349           if (bfd_big_endian (abfd))
3350             {
3351               switch (dyn_r_type)
3352                 {
3353                 case R_IA64_REL64LSB:
3354                   dyn_r_type = R_IA64_REL64MSB;
3355                   break;
3356                 case R_IA64_DIR64LSB:
3357                   dyn_r_type = R_IA64_DIR64MSB;
3358                   break;
3359                 case R_IA64_FPTR64LSB:
3360                   dyn_r_type = R_IA64_FPTR64MSB;
3361                   break;
3362                 case R_IA64_TPREL64LSB:
3363                   dyn_r_type = R_IA64_TPREL64MSB;
3364                   break;
3365                 case R_IA64_DTPMOD64LSB:
3366                   dyn_r_type = R_IA64_DTPMOD64MSB;
3367                   break;
3368                 case R_IA64_DTPREL64LSB:
3369                   dyn_r_type = R_IA64_DTPREL64MSB;
3370                   break;
3371                 default:
3372                   BFD_ASSERT (FALSE);
3373                   break;
3374                 }
3375             }
3376
3377           elfNN_ia64_install_dyn_reloc (abfd, NULL, got_sec,
3378                                         ia64_info->rel_got_sec,
3379                                         got_offset, dyn_r_type,
3380                                         dynindx, addend);
3381         }
3382     }
3383
3384   /* Return the address of the linkage table entry.  */
3385   value = (got_sec->output_section->vma
3386            + got_sec->output_offset
3387            + got_offset);
3388
3389   return value;
3390 }
3391
3392 /* Fill in a function descriptor consisting of the function's code
3393    address and its global pointer.  Return the descriptor's address.  */
3394
3395 static bfd_vma
3396 set_fptr_entry (abfd, info, dyn_i, value)
3397      bfd *abfd;
3398      struct bfd_link_info *info;
3399      struct elfNN_ia64_dyn_sym_info *dyn_i;
3400      bfd_vma value;
3401 {
3402   struct elfNN_ia64_link_hash_table *ia64_info;
3403   asection *fptr_sec;
3404
3405   ia64_info = elfNN_ia64_hash_table (info);
3406   fptr_sec = ia64_info->fptr_sec;
3407
3408   if (!dyn_i->fptr_done)
3409     {
3410       dyn_i->fptr_done = 1;
3411
3412       /* Fill in the function descriptor.  */
3413       bfd_put_64 (abfd, value, fptr_sec->contents + dyn_i->fptr_offset);
3414       bfd_put_64 (abfd, _bfd_get_gp_value (abfd),
3415                   fptr_sec->contents + dyn_i->fptr_offset + 8);
3416       if (ia64_info->rel_fptr_sec)
3417         {
3418           Elf_Internal_Rela outrel;
3419           bfd_byte *loc;
3420
3421           if (bfd_little_endian (abfd))
3422             outrel.r_info = ELFNN_R_INFO (0, R_IA64_IPLTLSB);
3423           else
3424             outrel.r_info = ELFNN_R_INFO (0, R_IA64_IPLTMSB);
3425           outrel.r_addend = value;
3426           outrel.r_offset = (fptr_sec->output_section->vma
3427                              + fptr_sec->output_offset
3428                              + dyn_i->fptr_offset);
3429           loc = ia64_info->rel_fptr_sec->contents;
3430           loc += ia64_info->rel_fptr_sec->reloc_count++
3431                  * sizeof (ElfNN_External_Rela);
3432           bfd_elfNN_swap_reloca_out (abfd, &outrel, loc);
3433         }
3434     }
3435
3436   /* Return the descriptor's address.  */
3437   value = (fptr_sec->output_section->vma
3438            + fptr_sec->output_offset
3439            + dyn_i->fptr_offset);
3440
3441   return value;
3442 }
3443
3444 /* Fill in a PLTOFF entry consisting of the function's code address
3445    and its global pointer.  Return the descriptor's address.  */
3446
3447 static bfd_vma
3448 set_pltoff_entry (abfd, info, dyn_i, value, is_plt)
3449      bfd *abfd;
3450      struct bfd_link_info *info;
3451      struct elfNN_ia64_dyn_sym_info *dyn_i;
3452      bfd_vma value;
3453      bfd_boolean is_plt;
3454 {
3455   struct elfNN_ia64_link_hash_table *ia64_info;
3456   asection *pltoff_sec;
3457
3458   ia64_info = elfNN_ia64_hash_table (info);
3459   pltoff_sec = ia64_info->pltoff_sec;
3460
3461   /* Don't do anything if this symbol uses a real PLT entry.  In
3462      that case, we'll fill this in during finish_dynamic_symbol.  */
3463   if ((! dyn_i->want_plt || is_plt)
3464       && !dyn_i->pltoff_done)
3465     {
3466       bfd_vma gp = _bfd_get_gp_value (abfd);
3467
3468       /* Fill in the function descriptor.  */
3469       bfd_put_64 (abfd, value, pltoff_sec->contents + dyn_i->pltoff_offset);
3470       bfd_put_64 (abfd, gp, pltoff_sec->contents + dyn_i->pltoff_offset + 8);
3471
3472       /* Install dynamic relocations if needed.  */
3473       if (!is_plt
3474           && info->shared
3475           && (!dyn_i->h
3476               || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
3477               || dyn_i->h->root.type != bfd_link_hash_undefweak))
3478         {
3479           unsigned int dyn_r_type;
3480
3481           if (bfd_big_endian (abfd))
3482             dyn_r_type = R_IA64_REL64MSB;
3483           else
3484             dyn_r_type = R_IA64_REL64LSB;
3485
3486           elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
3487                                         ia64_info->rel_pltoff_sec,
3488                                         dyn_i->pltoff_offset,
3489                                         dyn_r_type, 0, value);
3490           elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
3491                                         ia64_info->rel_pltoff_sec,
3492                                         dyn_i->pltoff_offset + 8,
3493                                         dyn_r_type, 0, gp);
3494         }
3495
3496       dyn_i->pltoff_done = 1;
3497     }
3498
3499   /* Return the descriptor's address.  */
3500   value = (pltoff_sec->output_section->vma
3501            + pltoff_sec->output_offset
3502            + dyn_i->pltoff_offset);
3503
3504   return value;
3505 }
3506
3507 /* Return the base VMA address which should be subtracted from real addresses
3508    when resolving @tprel() relocation.
3509    Main program TLS (whose template starts at PT_TLS p_vaddr)
3510    is assigned offset round(16, PT_TLS p_align).  */
3511
3512 static bfd_vma
3513 elfNN_ia64_tprel_base (info)
3514      struct bfd_link_info *info;
3515 {
3516   struct elf_link_tls_segment *tls_segment
3517     = elf_hash_table (info)->tls_segment;
3518
3519   BFD_ASSERT (tls_segment != NULL);
3520   return (tls_segment->start
3521           - align_power ((bfd_vma) 16, tls_segment->align));
3522 }
3523
3524 /* Return the base VMA address which should be subtracted from real addresses
3525    when resolving @dtprel() relocation.
3526    This is PT_TLS segment p_vaddr.  */
3527
3528 static bfd_vma
3529 elfNN_ia64_dtprel_base (info)
3530      struct bfd_link_info *info;
3531 {
3532   BFD_ASSERT (elf_hash_table (info)->tls_segment != NULL);
3533   return elf_hash_table (info)->tls_segment->start;
3534 }
3535
3536 /* Called through qsort to sort the .IA_64.unwind section during a
3537    non-relocatable link.  Set elfNN_ia64_unwind_entry_compare_bfd
3538    to the output bfd so we can do proper endianness frobbing.  */
3539
3540 static bfd *elfNN_ia64_unwind_entry_compare_bfd;
3541
3542 static int
3543 elfNN_ia64_unwind_entry_compare (a, b)
3544      const PTR a;
3545      const PTR b;
3546 {
3547   bfd_vma av, bv;
3548
3549   av = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, a);
3550   bv = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, b);
3551
3552   return (av < bv ? -1 : av > bv ? 1 : 0);
3553 }
3554
3555 /* Make sure we've got ourselves a nice fat __gp value.  */
3556 static bfd_boolean
3557 elfNN_ia64_choose_gp (abfd, info)
3558      bfd *abfd;
3559      struct bfd_link_info *info;
3560 {
3561   bfd_vma min_vma = (bfd_vma) -1, max_vma = 0;
3562   bfd_vma min_short_vma = min_vma, max_short_vma = 0;
3563   struct elf_link_hash_entry *gp;
3564   bfd_vma gp_val;
3565   asection *os;
3566   struct elfNN_ia64_link_hash_table *ia64_info;
3567
3568   ia64_info = elfNN_ia64_hash_table (info);
3569
3570   /* Find the min and max vma of all sections marked short.  Also collect
3571      min and max vma of any type, for use in selecting a nice gp.  */
3572   for (os = abfd->sections; os ; os = os->next)
3573     {
3574       bfd_vma lo, hi;
3575
3576       if ((os->flags & SEC_ALLOC) == 0)
3577         continue;
3578
3579       lo = os->vma;
3580       hi = os->vma + os->_raw_size;
3581       if (hi < lo)
3582         hi = (bfd_vma) -1;
3583
3584       if (min_vma > lo)
3585         min_vma = lo;
3586       if (max_vma < hi)
3587         max_vma = hi;
3588       if (os->flags & SEC_SMALL_DATA)
3589         {
3590           if (min_short_vma > lo)
3591             min_short_vma = lo;
3592           if (max_short_vma < hi)
3593             max_short_vma = hi;
3594         }
3595     }
3596
3597   /* See if the user wants to force a value.  */
3598   gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
3599                              FALSE, FALSE);
3600
3601   if (gp
3602       && (gp->root.type == bfd_link_hash_defined
3603           || gp->root.type == bfd_link_hash_defweak))
3604     {
3605       asection *gp_sec = gp->root.u.def.section;
3606       gp_val = (gp->root.u.def.value
3607                 + gp_sec->output_section->vma
3608                 + gp_sec->output_offset);
3609     }
3610   else
3611     {
3612       /* Pick a sensible value.  */
3613
3614       asection *got_sec = ia64_info->got_sec;
3615
3616       /* Start with just the address of the .got.  */
3617       if (got_sec)
3618         gp_val = got_sec->output_section->vma;
3619       else if (max_short_vma != 0)
3620         gp_val = min_short_vma;
3621       else
3622         gp_val = min_vma;
3623
3624       /* If it is possible to address the entire image, but we
3625          don't with the choice above, adjust.  */
3626       if (max_vma - min_vma < 0x400000
3627           && max_vma - gp_val <= 0x200000
3628           && gp_val - min_vma > 0x200000)
3629         gp_val = min_vma + 0x200000;
3630       else if (max_short_vma != 0)
3631         {
3632           /* If we don't cover all the short data, adjust.  */
3633           if (max_short_vma - gp_val >= 0x200000)
3634             gp_val = min_short_vma + 0x200000;
3635
3636           /* If we're addressing stuff past the end, adjust back.  */
3637           if (gp_val > max_vma)
3638             gp_val = max_vma - 0x200000 + 8;
3639         }
3640     }
3641
3642   /* Validate whether all SHF_IA_64_SHORT sections are within
3643      range of the chosen GP.  */
3644
3645   if (max_short_vma != 0)
3646     {
3647       if (max_short_vma - min_short_vma >= 0x400000)
3648         {
3649           (*_bfd_error_handler)
3650             (_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
3651              bfd_get_filename (abfd),
3652              (unsigned long) (max_short_vma - min_short_vma));
3653           return FALSE;
3654         }
3655       else if ((gp_val > min_short_vma
3656                 && gp_val - min_short_vma > 0x200000)
3657                || (gp_val < max_short_vma
3658                    && max_short_vma - gp_val >= 0x200000))
3659         {
3660           (*_bfd_error_handler)
3661             (_("%s: __gp does not cover short data segment"),
3662              bfd_get_filename (abfd));
3663           return FALSE;
3664         }
3665     }
3666
3667   _bfd_set_gp_value (abfd, gp_val);
3668
3669   return TRUE;
3670 }
3671
3672 static bfd_boolean
3673 elfNN_ia64_final_link (abfd, info)
3674      bfd *abfd;
3675      struct bfd_link_info *info;
3676 {
3677   struct elfNN_ia64_link_hash_table *ia64_info;
3678   asection *unwind_output_sec;
3679
3680   ia64_info = elfNN_ia64_hash_table (info);
3681
3682   /* Make sure we've got ourselves a nice fat __gp value.  */
3683   if (!info->relocatable)
3684     {
3685       bfd_vma gp_val = _bfd_get_gp_value (abfd);
3686       struct elf_link_hash_entry *gp;
3687
3688       if (gp_val == 0)
3689         {
3690           if (! elfNN_ia64_choose_gp (abfd, info))
3691             return FALSE;
3692           gp_val = _bfd_get_gp_value (abfd);
3693         }
3694
3695       gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
3696                                  FALSE, FALSE);
3697       if (gp)
3698         {
3699           gp->root.type = bfd_link_hash_defined;
3700           gp->root.u.def.value = gp_val;
3701           gp->root.u.def.section = bfd_abs_section_ptr;
3702         }
3703     }
3704
3705   /* If we're producing a final executable, we need to sort the contents
3706      of the .IA_64.unwind section.  Force this section to be relocated
3707      into memory rather than written immediately to the output file.  */
3708   unwind_output_sec = NULL;
3709   if (!info->relocatable)
3710     {
3711       asection *s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind);
3712       if (s)
3713         {
3714           unwind_output_sec = s->output_section;
3715           unwind_output_sec->contents
3716             = bfd_malloc (unwind_output_sec->_raw_size);
3717           if (unwind_output_sec->contents == NULL)
3718             return FALSE;
3719         }
3720     }
3721
3722   /* Invoke the regular ELF backend linker to do all the work.  */
3723   if (!bfd_elfNN_bfd_final_link (abfd, info))
3724     return FALSE;
3725
3726   if (unwind_output_sec)
3727     {
3728       elfNN_ia64_unwind_entry_compare_bfd = abfd;
3729       qsort (unwind_output_sec->contents,
3730              (size_t) (unwind_output_sec->_raw_size / 24),
3731              24,
3732              elfNN_ia64_unwind_entry_compare);
3733
3734       if (! bfd_set_section_contents (abfd, unwind_output_sec,
3735                                       unwind_output_sec->contents, (bfd_vma) 0,
3736                                       unwind_output_sec->_raw_size))
3737         return FALSE;
3738     }
3739
3740   return TRUE;
3741 }
3742
3743 static bfd_boolean
3744 elfNN_ia64_relocate_section (output_bfd, info, input_bfd, input_section,
3745                              contents, relocs, local_syms, local_sections)
3746      bfd *output_bfd;
3747      struct bfd_link_info *info;
3748      bfd *input_bfd;
3749      asection *input_section;
3750      bfd_byte *contents;
3751      Elf_Internal_Rela *relocs;
3752      Elf_Internal_Sym *local_syms;
3753      asection **local_sections;
3754 {
3755   struct elfNN_ia64_link_hash_table *ia64_info;
3756   Elf_Internal_Shdr *symtab_hdr;
3757   Elf_Internal_Rela *rel;
3758   Elf_Internal_Rela *relend;
3759   asection *srel;
3760   bfd_boolean ret_val = TRUE;   /* for non-fatal errors */
3761   bfd_vma gp_val;
3762
3763   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3764   ia64_info = elfNN_ia64_hash_table (info);
3765
3766   /* Infect various flags from the input section to the output section.  */
3767   if (info->relocatable)
3768     {
3769       bfd_vma flags;
3770
3771       flags = elf_section_data(input_section)->this_hdr.sh_flags;
3772       flags &= SHF_IA_64_NORECOV;
3773
3774       elf_section_data(input_section->output_section)
3775         ->this_hdr.sh_flags |= flags;
3776       return TRUE;
3777     }
3778
3779   gp_val = _bfd_get_gp_value (output_bfd);
3780   srel = get_reloc_section (input_bfd, ia64_info, input_section, FALSE);
3781
3782   rel = relocs;
3783   relend = relocs + input_section->reloc_count;
3784   for (; rel < relend; ++rel)
3785     {
3786       struct elf_link_hash_entry *h;
3787       struct elfNN_ia64_dyn_sym_info *dyn_i;
3788       bfd_reloc_status_type r;
3789       reloc_howto_type *howto;
3790       unsigned long r_symndx;
3791       Elf_Internal_Sym *sym;
3792       unsigned int r_type;
3793       bfd_vma value;
3794       asection *sym_sec;
3795       bfd_byte *hit_addr;
3796       bfd_boolean dynamic_symbol_p;
3797       bfd_boolean undef_weak_ref;
3798
3799       r_type = ELFNN_R_TYPE (rel->r_info);
3800       if (r_type > R_IA64_MAX_RELOC_CODE)
3801         {
3802           (*_bfd_error_handler)
3803             (_("%s: unknown relocation type %d"),
3804              bfd_archive_filename (input_bfd), (int)r_type);
3805           bfd_set_error (bfd_error_bad_value);
3806           ret_val = FALSE;
3807           continue;
3808         }
3809
3810       howto = lookup_howto (r_type);
3811       r_symndx = ELFNN_R_SYM (rel->r_info);
3812       h = NULL;
3813       sym = NULL;
3814       sym_sec = NULL;
3815       undef_weak_ref = FALSE;
3816
3817       if (r_symndx < symtab_hdr->sh_info)
3818         {
3819           /* Reloc against local symbol.  */
3820           sym = local_syms + r_symndx;
3821           sym_sec = local_sections[r_symndx];
3822           value = _bfd_elf_rela_local_sym (output_bfd, sym, sym_sec, rel);
3823           if ((sym_sec->flags & SEC_MERGE)
3824               && ELF_ST_TYPE (sym->st_info) == STT_SECTION
3825               && sym_sec->sec_info_type == ELF_INFO_TYPE_MERGE)
3826             {
3827               struct elfNN_ia64_local_hash_entry *loc_h;
3828
3829               loc_h = get_local_sym_hash (ia64_info, input_bfd, rel, FALSE);
3830               if (loc_h && ! loc_h->sec_merge_done)
3831                 {
3832                   struct elfNN_ia64_dyn_sym_info *dynent;
3833                   asection *msec;
3834
3835                   for (dynent = loc_h->info; dynent; dynent = dynent->next)
3836                     {
3837                       msec = sym_sec;
3838                       dynent->addend =
3839                         _bfd_merged_section_offset (output_bfd, &msec,
3840                                                     elf_section_data (msec)->
3841                                                     sec_info,
3842                                                     sym->st_value
3843                                                     + dynent->addend,
3844                                                     (bfd_vma) 0);
3845                       dynent->addend -= sym->st_value;
3846                       dynent->addend += msec->output_section->vma
3847                                         + msec->output_offset
3848                                         - sym_sec->output_section->vma
3849                                         - sym_sec->output_offset;
3850                     }
3851                   loc_h->sec_merge_done = 1;
3852                 }
3853             }
3854         }
3855       else
3856         {
3857           bfd_boolean unresolved_reloc;
3858           bfd_boolean warned;
3859
3860           RELOC_FOR_GLOBAL_SYMBOL (h, elf_sym_hashes (input_bfd),
3861                                    r_symndx,
3862                                    symtab_hdr, value, sym_sec,
3863                                    unresolved_reloc, info,
3864                                    warned);
3865
3866           if (h->root.type == bfd_link_hash_undefweak)
3867             undef_weak_ref = TRUE;
3868           else if (warned)
3869             continue;
3870         }
3871
3872       hit_addr = contents + rel->r_offset;
3873       value += rel->r_addend;
3874       dynamic_symbol_p = elfNN_ia64_dynamic_symbol_p (h, info, r_type);
3875
3876       switch (r_type)
3877         {
3878         case R_IA64_NONE:
3879         case R_IA64_LDXMOV:
3880           continue;
3881
3882         case R_IA64_IMM14:
3883         case R_IA64_IMM22:
3884         case R_IA64_IMM64:
3885         case R_IA64_DIR32MSB:
3886         case R_IA64_DIR32LSB:
3887         case R_IA64_DIR64MSB:
3888         case R_IA64_DIR64LSB:
3889           /* Install a dynamic relocation for this reloc.  */
3890           if ((dynamic_symbol_p || info->shared)
3891               && r_symndx != 0
3892               && (input_section->flags & SEC_ALLOC) != 0)
3893             {
3894               unsigned int dyn_r_type;
3895               long dynindx;
3896               bfd_vma addend;
3897
3898               BFD_ASSERT (srel != NULL);
3899
3900               /* If we don't need dynamic symbol lookup, find a
3901                  matching RELATIVE relocation.  */
3902               dyn_r_type = r_type;
3903               if (dynamic_symbol_p)
3904                 {
3905                   dynindx = h->dynindx;
3906                   addend = rel->r_addend;
3907                   value = 0;
3908                 }
3909               else
3910                 {
3911                   switch (r_type)
3912                     {
3913                     case R_IA64_DIR32MSB:
3914                       dyn_r_type = R_IA64_REL32MSB;
3915                       break;
3916                     case R_IA64_DIR32LSB:
3917                       dyn_r_type = R_IA64_REL32LSB;
3918                       break;
3919                     case R_IA64_DIR64MSB:
3920                       dyn_r_type = R_IA64_REL64MSB;
3921                       break;
3922                     case R_IA64_DIR64LSB:
3923                       dyn_r_type = R_IA64_REL64LSB;
3924                       break;
3925
3926                     default:
3927                       /* We can't represent this without a dynamic symbol.
3928                          Adjust the relocation to be against an output
3929                          section symbol, which are always present in the
3930                          dynamic symbol table.  */
3931                       /* ??? People shouldn't be doing non-pic code in
3932                          shared libraries.  Hork.  */
3933                       (*_bfd_error_handler)
3934                         (_("%s: linking non-pic code in a shared library"),
3935                          bfd_archive_filename (input_bfd));
3936                       ret_val = FALSE;
3937                       continue;
3938                     }
3939                   dynindx = 0;
3940                   addend = value;
3941                 }
3942
3943               elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
3944                                             srel, rel->r_offset, dyn_r_type,
3945                                             dynindx, addend);
3946             }
3947           /* Fall through.  */
3948
3949         case R_IA64_LTV32MSB:
3950         case R_IA64_LTV32LSB:
3951         case R_IA64_LTV64MSB:
3952         case R_IA64_LTV64LSB:
3953           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
3954           break;
3955
3956         case R_IA64_GPREL22:
3957         case R_IA64_GPREL64I:
3958         case R_IA64_GPREL32MSB:
3959         case R_IA64_GPREL32LSB:
3960         case R_IA64_GPREL64MSB:
3961         case R_IA64_GPREL64LSB:
3962           if (dynamic_symbol_p)
3963             {
3964               (*_bfd_error_handler)
3965                 (_("%s: @gprel relocation against dynamic symbol %s"),
3966                  bfd_archive_filename (input_bfd), h->root.root.string);
3967               ret_val = FALSE;
3968               continue;
3969             }
3970           value -= gp_val;
3971           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
3972           break;
3973
3974         case R_IA64_LTOFF22:
3975         case R_IA64_LTOFF22X:
3976         case R_IA64_LTOFF64I:
3977           dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
3978           value = set_got_entry (input_bfd, info, dyn_i, (h ? h->dynindx : -1),
3979                                  rel->r_addend, value, R_IA64_DIR64LSB);
3980           value -= gp_val;
3981           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
3982           break;
3983
3984         case R_IA64_PLTOFF22:
3985         case R_IA64_PLTOFF64I:
3986         case R_IA64_PLTOFF64MSB:
3987         case R_IA64_PLTOFF64LSB:
3988           dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
3989           value = set_pltoff_entry (output_bfd, info, dyn_i, value, FALSE);
3990           value -= gp_val;
3991           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
3992           break;
3993
3994         case R_IA64_FPTR64I:
3995         case R_IA64_FPTR32MSB:
3996         case R_IA64_FPTR32LSB:
3997         case R_IA64_FPTR64MSB:
3998         case R_IA64_FPTR64LSB:
3999           dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4000           if (dyn_i->want_fptr)
4001             {
4002               if (!undef_weak_ref)
4003                 value = set_fptr_entry (output_bfd, info, dyn_i, value);
4004             }
4005           if (!dyn_i->want_fptr || info->pie)
4006             {
4007               long dynindx;
4008               unsigned int dyn_r_type = r_type;
4009               bfd_vma addend = rel->r_addend;
4010
4011               /* Otherwise, we expect the dynamic linker to create
4012                  the entry.  */
4013
4014               if (dyn_i->want_fptr)
4015                 {
4016                   if (r_type == R_IA64_FPTR64I)
4017                     {
4018                       /* We can't represent this without a dynamic symbol.
4019                          Adjust the relocation to be against an output
4020                          section symbol, which are always present in the
4021                          dynamic symbol table.  */
4022                       /* ??? People shouldn't be doing non-pic code in
4023                          shared libraries.  Hork.  */
4024                       (*_bfd_error_handler)
4025                         (_("%s: linking non-pic code in a position independent executable"),
4026                          bfd_archive_filename (input_bfd));
4027                       ret_val = FALSE;
4028                       continue;
4029                     }
4030                   dynindx = 0;
4031                   addend = value;
4032                   dyn_r_type = r_type + R_IA64_REL64LSB - R_IA64_FPTR64LSB;
4033                 }
4034               else if (h)
4035                 {
4036                   if (h->dynindx != -1)
4037                     dynindx = h->dynindx;
4038                   else
4039                     dynindx = (_bfd_elf_link_lookup_local_dynindx
4040                                (info, h->root.u.def.section->owner,
4041                                 global_sym_index (h)));
4042                   value = 0;
4043                 }
4044               else
4045                 {
4046                   dynindx = (_bfd_elf_link_lookup_local_dynindx
4047                              (info, input_bfd, (long) r_symndx));
4048                   value = 0;
4049                 }
4050
4051               elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4052                                             srel, rel->r_offset, dyn_r_type,
4053                                             dynindx, addend);
4054             }
4055
4056           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4057           break;
4058
4059         case R_IA64_LTOFF_FPTR22:
4060         case R_IA64_LTOFF_FPTR64I:
4061         case R_IA64_LTOFF_FPTR32MSB:
4062         case R_IA64_LTOFF_FPTR32LSB:
4063         case R_IA64_LTOFF_FPTR64MSB:
4064         case R_IA64_LTOFF_FPTR64LSB:
4065           {
4066             long dynindx;
4067
4068             dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4069             if (dyn_i->want_fptr)
4070               {
4071                 BFD_ASSERT (h == NULL || h->dynindx == -1)
4072                 if (!undef_weak_ref)
4073                   value = set_fptr_entry (output_bfd, info, dyn_i, value);
4074                 dynindx = -1;
4075               }
4076             else
4077               {
4078                 /* Otherwise, we expect the dynamic linker to create
4079                    the entry.  */
4080                 if (h)
4081                   {
4082                     if (h->dynindx != -1)
4083                       dynindx = h->dynindx;
4084                     else
4085                       dynindx = (_bfd_elf_link_lookup_local_dynindx
4086                                  (info, h->root.u.def.section->owner,
4087                                   global_sym_index (h)));
4088                   }
4089                 else
4090                   dynindx = (_bfd_elf_link_lookup_local_dynindx
4091                              (info, input_bfd, (long) r_symndx));
4092                 value = 0;
4093               }
4094
4095             value = set_got_entry (output_bfd, info, dyn_i, dynindx,
4096                                    rel->r_addend, value, R_IA64_FPTR64LSB);
4097             value -= gp_val;
4098             r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4099           }
4100           break;
4101
4102         case R_IA64_PCREL32MSB:
4103         case R_IA64_PCREL32LSB:
4104         case R_IA64_PCREL64MSB:
4105         case R_IA64_PCREL64LSB:
4106           /* Install a dynamic relocation for this reloc.  */
4107           if (dynamic_symbol_p && r_symndx != 0)
4108             {
4109               BFD_ASSERT (srel != NULL);
4110
4111               elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4112                                             srel, rel->r_offset, r_type,
4113                                             h->dynindx, rel->r_addend);
4114             }
4115           goto finish_pcrel;
4116
4117         case R_IA64_PCREL21B:
4118         case R_IA64_PCREL60B:
4119           /* We should have created a PLT entry for any dynamic symbol.  */
4120           dyn_i = NULL;
4121           if (h)
4122             dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE);
4123
4124           if (dyn_i && dyn_i->want_plt2)
4125             {
4126               /* Should have caught this earlier.  */
4127               BFD_ASSERT (rel->r_addend == 0);
4128
4129               value = (ia64_info->plt_sec->output_section->vma
4130                        + ia64_info->plt_sec->output_offset
4131                        + dyn_i->plt2_offset);
4132             }
4133           else
4134             {
4135               /* Since there's no PLT entry, Validate that this is
4136                  locally defined.  */
4137               BFD_ASSERT (undef_weak_ref || sym_sec->output_section != NULL);
4138
4139               /* If the symbol is undef_weak, we shouldn't be trying
4140                  to call it.  There's every chance that we'd wind up
4141                  with an out-of-range fixup here.  Don't bother setting
4142                  any value at all.  */
4143               if (undef_weak_ref)
4144                 continue;
4145             }
4146           goto finish_pcrel;
4147
4148         case R_IA64_PCREL21BI:
4149         case R_IA64_PCREL21F:
4150         case R_IA64_PCREL21M:
4151         case R_IA64_PCREL22:
4152         case R_IA64_PCREL64I:
4153           /* The PCREL21BI reloc is specifically not intended for use with
4154              dynamic relocs.  PCREL21F and PCREL21M are used for speculation
4155              fixup code, and thus probably ought not be dynamic.  The
4156              PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs.  */
4157           if (dynamic_symbol_p)
4158             {
4159               const char *msg;
4160
4161               if (r_type == R_IA64_PCREL21BI)
4162                 msg = _("%s: @internal branch to dynamic symbol %s");
4163               else if (r_type == R_IA64_PCREL21F || r_type == R_IA64_PCREL21M)
4164                 msg = _("%s: speculation fixup to dynamic symbol %s");
4165               else
4166                 msg = _("%s: @pcrel relocation against dynamic symbol %s");
4167               (*_bfd_error_handler) (msg, bfd_archive_filename (input_bfd),
4168                                      h->root.root.string);
4169               ret_val = FALSE;
4170               continue;
4171             }
4172           goto finish_pcrel;
4173
4174         finish_pcrel:
4175           /* Make pc-relative.  */
4176           value -= (input_section->output_section->vma
4177                     + input_section->output_offset
4178                     + rel->r_offset) & ~ (bfd_vma) 0x3;
4179           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4180           break;
4181
4182         case R_IA64_SEGREL32MSB:
4183         case R_IA64_SEGREL32LSB:
4184         case R_IA64_SEGREL64MSB:
4185         case R_IA64_SEGREL64LSB:
4186           if (r_symndx == 0)
4187             {
4188               /* If the input section was discarded from the output, then
4189                  do nothing.  */
4190               r = bfd_reloc_ok;
4191             }
4192           else
4193             {
4194               struct elf_segment_map *m;
4195               Elf_Internal_Phdr *p;
4196
4197               /* Find the segment that contains the output_section.  */
4198               for (m = elf_tdata (output_bfd)->segment_map,
4199                      p = elf_tdata (output_bfd)->phdr;
4200                    m != NULL;
4201                    m = m->next, p++)
4202                 {
4203                   int i;
4204                   for (i = m->count - 1; i >= 0; i--)
4205                     if (m->sections[i] == input_section->output_section)
4206                       break;
4207                   if (i >= 0)
4208                     break;
4209                 }
4210
4211               if (m == NULL)
4212                 {
4213                   r = bfd_reloc_notsupported;
4214                 }
4215               else
4216                 {
4217                   /* The VMA of the segment is the vaddr of the associated
4218                      program header.  */
4219                   if (value > p->p_vaddr)
4220                     value -= p->p_vaddr;
4221                   else
4222                     value = 0;
4223                   r = elfNN_ia64_install_value (output_bfd, hit_addr, value,
4224                                                 r_type);
4225                 }
4226               break;
4227             }
4228
4229         case R_IA64_SECREL32MSB:
4230         case R_IA64_SECREL32LSB:
4231         case R_IA64_SECREL64MSB:
4232         case R_IA64_SECREL64LSB:
4233           /* Make output-section relative.  */
4234           if (value > input_section->output_section->vma)
4235             value -= input_section->output_section->vma;
4236           else
4237             value = 0;
4238           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4239           break;
4240
4241         case R_IA64_IPLTMSB:
4242         case R_IA64_IPLTLSB:
4243           /* Install a dynamic relocation for this reloc.  */
4244           if ((dynamic_symbol_p || info->shared)
4245               && (input_section->flags & SEC_ALLOC) != 0)
4246             {
4247               BFD_ASSERT (srel != NULL);
4248
4249               /* If we don't need dynamic symbol lookup, install two
4250                  RELATIVE relocations.  */
4251               if (!dynamic_symbol_p)
4252                 {
4253                   unsigned int dyn_r_type;
4254
4255                   if (r_type == R_IA64_IPLTMSB)
4256                     dyn_r_type = R_IA64_REL64MSB;
4257                   else
4258                     dyn_r_type = R_IA64_REL64LSB;
4259
4260                   elfNN_ia64_install_dyn_reloc (output_bfd, info,
4261                                                 input_section,
4262                                                 srel, rel->r_offset,
4263                                                 dyn_r_type, 0, value);
4264                   elfNN_ia64_install_dyn_reloc (output_bfd, info,
4265                                                 input_section,
4266                                                 srel, rel->r_offset + 8,
4267                                                 dyn_r_type, 0, gp_val);
4268                 }
4269               else
4270                 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4271                                               srel, rel->r_offset, r_type,
4272                                               h->dynindx, rel->r_addend);
4273             }
4274
4275           if (r_type == R_IA64_IPLTMSB)
4276             r_type = R_IA64_DIR64MSB;
4277           else
4278             r_type = R_IA64_DIR64LSB;
4279           elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4280           r = elfNN_ia64_install_value (output_bfd, hit_addr + 8, gp_val,
4281                                         r_type);
4282           break;
4283
4284         case R_IA64_TPREL14:
4285         case R_IA64_TPREL22:
4286         case R_IA64_TPREL64I:
4287           value -= elfNN_ia64_tprel_base (info);
4288           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4289           break;
4290
4291         case R_IA64_DTPREL14:
4292         case R_IA64_DTPREL22:
4293         case R_IA64_DTPREL64I:
4294         case R_IA64_DTPREL64LSB:
4295         case R_IA64_DTPREL64MSB:
4296           value -= elfNN_ia64_dtprel_base (info);
4297           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4298           break;
4299
4300         case R_IA64_LTOFF_TPREL22:
4301         case R_IA64_LTOFF_DTPMOD22:
4302         case R_IA64_LTOFF_DTPREL22:
4303           {
4304             int got_r_type;
4305             long dynindx = h ? h->dynindx : -1;
4306             bfd_vma r_addend = rel->r_addend;
4307
4308             switch (r_type)
4309               {
4310               default:
4311               case R_IA64_LTOFF_TPREL22:
4312                 if (!dynamic_symbol_p)
4313                   {
4314                     if (!info->shared)
4315                       value -= elfNN_ia64_tprel_base (info);
4316                     else
4317                       {
4318                         r_addend += value - elfNN_ia64_dtprel_base (info);
4319                         dynindx = 0;
4320                       }
4321                   }
4322                 got_r_type = R_IA64_TPREL64LSB;
4323                 break;
4324               case R_IA64_LTOFF_DTPMOD22:
4325                 if (!dynamic_symbol_p && !info->shared)
4326                   value = 1;
4327                 got_r_type = R_IA64_DTPMOD64LSB;
4328                 break;
4329               case R_IA64_LTOFF_DTPREL22:
4330                 if (!dynamic_symbol_p)
4331                   value -= elfNN_ia64_dtprel_base (info);
4332                 got_r_type = R_IA64_DTPREL64LSB;
4333                 break;
4334               }
4335             dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4336             value = set_got_entry (input_bfd, info, dyn_i, dynindx, r_addend,
4337                                    value, got_r_type);
4338             value -= gp_val;
4339             r = elfNN_ia64_install_value (output_bfd, hit_addr, value,
4340                                           r_type);
4341           }
4342           break;
4343
4344         default:
4345           r = bfd_reloc_notsupported;
4346           break;
4347         }
4348
4349       switch (r)
4350         {
4351         case bfd_reloc_ok:
4352           break;
4353
4354         case bfd_reloc_undefined:
4355           /* This can happen for global table relative relocs if
4356              __gp is undefined.  This is a panic situation so we
4357              don't try to continue.  */
4358           (*info->callbacks->undefined_symbol)
4359             (info, "__gp", input_bfd, input_section, rel->r_offset, 1);
4360           return FALSE;
4361
4362         case bfd_reloc_notsupported:
4363           {
4364             const char *name;
4365
4366             if (h)
4367               name = h->root.root.string;
4368             else
4369               {
4370                 name = bfd_elf_string_from_elf_section (input_bfd,
4371                                                         symtab_hdr->sh_link,
4372                                                         sym->st_name);
4373                 if (name == NULL)
4374                   return FALSE;
4375                 if (*name == '\0')
4376                   name = bfd_section_name (input_bfd, input_section);
4377               }
4378             if (!(*info->callbacks->warning) (info, _("unsupported reloc"),
4379                                               name, input_bfd,
4380                                               input_section, rel->r_offset))
4381               return FALSE;
4382             ret_val = FALSE;
4383           }
4384           break;
4385
4386         case bfd_reloc_dangerous:
4387         case bfd_reloc_outofrange:
4388         case bfd_reloc_overflow:
4389         default:
4390           {
4391             const char *name;
4392
4393             if (h)
4394               name = h->root.root.string;
4395             else
4396               {
4397                 name = bfd_elf_string_from_elf_section (input_bfd,
4398                                                         symtab_hdr->sh_link,
4399                                                         sym->st_name);
4400                 if (name == NULL)
4401                   return FALSE;
4402                 if (*name == '\0')
4403                   name = bfd_section_name (input_bfd, input_section);
4404               }
4405             if (!(*info->callbacks->reloc_overflow) (info, name,
4406                                                      howto->name,
4407                                                      (bfd_vma) 0,
4408                                                      input_bfd,
4409                                                      input_section,
4410                                                      rel->r_offset))
4411               return FALSE;
4412             ret_val = FALSE;
4413           }
4414           break;
4415         }
4416     }
4417
4418   return ret_val;
4419 }
4420
4421 static bfd_boolean
4422 elfNN_ia64_finish_dynamic_symbol (output_bfd, info, h, sym)
4423      bfd *output_bfd;
4424      struct bfd_link_info *info;
4425      struct elf_link_hash_entry *h;
4426      Elf_Internal_Sym *sym;
4427 {
4428   struct elfNN_ia64_link_hash_table *ia64_info;
4429   struct elfNN_ia64_dyn_sym_info *dyn_i;
4430
4431   ia64_info = elfNN_ia64_hash_table (info);
4432   dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE);
4433
4434   /* Fill in the PLT data, if required.  */
4435   if (dyn_i && dyn_i->want_plt)
4436     {
4437       Elf_Internal_Rela outrel;
4438       bfd_byte *loc;
4439       asection *plt_sec;
4440       bfd_vma plt_addr, pltoff_addr, gp_val, index;
4441
4442       gp_val = _bfd_get_gp_value (output_bfd);
4443
4444       /* Initialize the minimal PLT entry.  */
4445
4446       index = (dyn_i->plt_offset - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
4447       plt_sec = ia64_info->plt_sec;
4448       loc = plt_sec->contents + dyn_i->plt_offset;
4449
4450       memcpy (loc, plt_min_entry, PLT_MIN_ENTRY_SIZE);
4451       elfNN_ia64_install_value (output_bfd, loc, index, R_IA64_IMM22);
4452       elfNN_ia64_install_value (output_bfd, loc+2, -dyn_i->plt_offset,
4453                                 R_IA64_PCREL21B);
4454
4455       plt_addr = (plt_sec->output_section->vma
4456                   + plt_sec->output_offset
4457                   + dyn_i->plt_offset);
4458       pltoff_addr = set_pltoff_entry (output_bfd, info, dyn_i, plt_addr, TRUE);
4459
4460       /* Initialize the FULL PLT entry, if needed.  */
4461       if (dyn_i->want_plt2)
4462         {
4463           loc = plt_sec->contents + dyn_i->plt2_offset;
4464
4465           memcpy (loc, plt_full_entry, PLT_FULL_ENTRY_SIZE);
4466           elfNN_ia64_install_value (output_bfd, loc, pltoff_addr - gp_val,
4467                                     R_IA64_IMM22);
4468
4469           /* Mark the symbol as undefined, rather than as defined in the
4470              plt section.  Leave the value alone.  */
4471           /* ??? We didn't redefine it in adjust_dynamic_symbol in the
4472              first place.  But perhaps elflink.h did some for us.  */
4473           if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4474             sym->st_shndx = SHN_UNDEF;
4475         }
4476
4477       /* Create the dynamic relocation.  */
4478       outrel.r_offset = pltoff_addr;
4479       if (bfd_little_endian (output_bfd))
4480         outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTLSB);
4481       else
4482         outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTMSB);
4483       outrel.r_addend = 0;
4484
4485       /* This is fun.  In the .IA_64.pltoff section, we've got entries
4486          that correspond both to real PLT entries, and those that
4487          happened to resolve to local symbols but need to be created
4488          to satisfy @pltoff relocations.  The .rela.IA_64.pltoff
4489          relocations for the real PLT should come at the end of the
4490          section, so that they can be indexed by plt entry at runtime.
4491
4492          We emitted all of the relocations for the non-PLT @pltoff
4493          entries during relocate_section.  So we can consider the
4494          existing sec->reloc_count to be the base of the array of
4495          PLT relocations.  */
4496
4497       loc = ia64_info->rel_pltoff_sec->contents;
4498       loc += ((ia64_info->rel_pltoff_sec->reloc_count + index)
4499               * sizeof (ElfNN_External_Rela));
4500       bfd_elfNN_swap_reloca_out (output_bfd, &outrel, loc);
4501     }
4502
4503   /* Mark some specially defined symbols as absolute.  */
4504   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
4505       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
4506       || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
4507     sym->st_shndx = SHN_ABS;
4508
4509   return TRUE;
4510 }
4511
4512 static bfd_boolean
4513 elfNN_ia64_finish_dynamic_sections (abfd, info)
4514      bfd *abfd;
4515      struct bfd_link_info *info;
4516 {
4517   struct elfNN_ia64_link_hash_table *ia64_info;
4518   bfd *dynobj;
4519
4520   ia64_info = elfNN_ia64_hash_table (info);
4521   dynobj = ia64_info->root.dynobj;
4522
4523   if (elf_hash_table (info)->dynamic_sections_created)
4524     {
4525       ElfNN_External_Dyn *dyncon, *dynconend;
4526       asection *sdyn, *sgotplt;
4527       bfd_vma gp_val;
4528
4529       sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4530       sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
4531       BFD_ASSERT (sdyn != NULL);
4532       dyncon = (ElfNN_External_Dyn *) sdyn->contents;
4533       dynconend = (ElfNN_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
4534
4535       gp_val = _bfd_get_gp_value (abfd);
4536
4537       for (; dyncon < dynconend; dyncon++)
4538         {
4539           Elf_Internal_Dyn dyn;
4540
4541           bfd_elfNN_swap_dyn_in (dynobj, dyncon, &dyn);
4542
4543           switch (dyn.d_tag)
4544             {
4545             case DT_PLTGOT:
4546               dyn.d_un.d_ptr = gp_val;
4547               break;
4548
4549             case DT_PLTRELSZ:
4550               dyn.d_un.d_val = (ia64_info->minplt_entries
4551                                 * sizeof (ElfNN_External_Rela));
4552               break;
4553
4554             case DT_JMPREL:
4555               /* See the comment above in finish_dynamic_symbol.  */
4556               dyn.d_un.d_ptr = (ia64_info->rel_pltoff_sec->output_section->vma
4557                                 + ia64_info->rel_pltoff_sec->output_offset
4558                                 + (ia64_info->rel_pltoff_sec->reloc_count
4559                                    * sizeof (ElfNN_External_Rela)));
4560               break;
4561
4562             case DT_IA_64_PLT_RESERVE:
4563               dyn.d_un.d_ptr = (sgotplt->output_section->vma
4564                                 + sgotplt->output_offset);
4565               break;
4566
4567             case DT_RELASZ:
4568               /* Do not have RELASZ include JMPREL.  This makes things
4569                  easier on ld.so.  This is not what the rest of BFD set up.  */
4570               dyn.d_un.d_val -= (ia64_info->minplt_entries
4571                                  * sizeof (ElfNN_External_Rela));
4572               break;
4573             }
4574
4575           bfd_elfNN_swap_dyn_out (abfd, &dyn, dyncon);
4576         }
4577
4578       /* Initialize the PLT0 entry.  */
4579       if (ia64_info->plt_sec)
4580         {
4581           bfd_byte *loc = ia64_info->plt_sec->contents;
4582           bfd_vma pltres;
4583
4584           memcpy (loc, plt_header, PLT_HEADER_SIZE);
4585
4586           pltres = (sgotplt->output_section->vma
4587                     + sgotplt->output_offset
4588                     - gp_val);
4589
4590           elfNN_ia64_install_value (abfd, loc+1, pltres, R_IA64_GPREL22);
4591         }
4592     }
4593
4594   return TRUE;
4595 }
4596 \f
4597 /* ELF file flag handling:  */
4598
4599 /* Function to keep IA-64 specific file flags.  */
4600 static bfd_boolean
4601 elfNN_ia64_set_private_flags (abfd, flags)
4602      bfd *abfd;
4603      flagword flags;
4604 {
4605   BFD_ASSERT (!elf_flags_init (abfd)
4606               || elf_elfheader (abfd)->e_flags == flags);
4607
4608   elf_elfheader (abfd)->e_flags = flags;
4609   elf_flags_init (abfd) = TRUE;
4610   return TRUE;
4611 }
4612
4613 /* Merge backend specific data from an object file to the output
4614    object file when linking.  */
4615 static bfd_boolean
4616 elfNN_ia64_merge_private_bfd_data (ibfd, obfd)
4617      bfd *ibfd, *obfd;
4618 {
4619   flagword out_flags;
4620   flagword in_flags;
4621   bfd_boolean ok = TRUE;
4622
4623   /* Don't even pretend to support mixed-format linking.  */
4624   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4625       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4626     return FALSE;
4627
4628   in_flags  = elf_elfheader (ibfd)->e_flags;
4629   out_flags = elf_elfheader (obfd)->e_flags;
4630
4631   if (! elf_flags_init (obfd))
4632     {
4633       elf_flags_init (obfd) = TRUE;
4634       elf_elfheader (obfd)->e_flags = in_flags;
4635
4636       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
4637           && bfd_get_arch_info (obfd)->the_default)
4638         {
4639           return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
4640                                     bfd_get_mach (ibfd));
4641         }
4642
4643       return TRUE;
4644     }
4645
4646   /* Check flag compatibility.  */
4647   if (in_flags == out_flags)
4648     return TRUE;
4649
4650   /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set.  */
4651   if (!(in_flags & EF_IA_64_REDUCEDFP) && (out_flags & EF_IA_64_REDUCEDFP))
4652     elf_elfheader (obfd)->e_flags &= ~EF_IA_64_REDUCEDFP;
4653
4654   if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL))
4655     {
4656       (*_bfd_error_handler)
4657         (_("%s: linking trap-on-NULL-dereference with non-trapping files"),
4658          bfd_archive_filename (ibfd));
4659
4660       bfd_set_error (bfd_error_bad_value);
4661       ok = FALSE;
4662     }
4663   if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE))
4664     {
4665       (*_bfd_error_handler)
4666         (_("%s: linking big-endian files with little-endian files"),
4667          bfd_archive_filename (ibfd));
4668
4669       bfd_set_error (bfd_error_bad_value);
4670       ok = FALSE;
4671     }
4672   if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64))
4673     {
4674       (*_bfd_error_handler)
4675         (_("%s: linking 64-bit files with 32-bit files"),
4676          bfd_archive_filename (ibfd));
4677
4678       bfd_set_error (bfd_error_bad_value);
4679       ok = FALSE;
4680     }
4681   if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP))
4682     {
4683       (*_bfd_error_handler)
4684         (_("%s: linking constant-gp files with non-constant-gp files"),
4685          bfd_archive_filename (ibfd));
4686
4687       bfd_set_error (bfd_error_bad_value);
4688       ok = FALSE;
4689     }
4690   if ((in_flags & EF_IA_64_NOFUNCDESC_CONS_GP)
4691       != (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
4692     {
4693       (*_bfd_error_handler)
4694         (_("%s: linking auto-pic files with non-auto-pic files"),
4695          bfd_archive_filename (ibfd));
4696
4697       bfd_set_error (bfd_error_bad_value);
4698       ok = FALSE;
4699     }
4700
4701   return ok;
4702 }
4703
4704 static bfd_boolean
4705 elfNN_ia64_print_private_bfd_data (abfd, ptr)
4706      bfd *abfd;
4707      PTR ptr;
4708 {
4709   FILE *file = (FILE *) ptr;
4710   flagword flags = elf_elfheader (abfd)->e_flags;
4711
4712   BFD_ASSERT (abfd != NULL && ptr != NULL);
4713
4714   fprintf (file, "private flags = %s%s%s%s%s%s%s%s\n",
4715            (flags & EF_IA_64_TRAPNIL) ? "TRAPNIL, " : "",
4716            (flags & EF_IA_64_EXT) ? "EXT, " : "",
4717            (flags & EF_IA_64_BE) ? "BE, " : "LE, ",
4718            (flags & EF_IA_64_REDUCEDFP) ? "REDUCEDFP, " : "",
4719            (flags & EF_IA_64_CONS_GP) ? "CONS_GP, " : "",
4720            (flags & EF_IA_64_NOFUNCDESC_CONS_GP) ? "NOFUNCDESC_CONS_GP, " : "",
4721            (flags & EF_IA_64_ABSOLUTE) ? "ABSOLUTE, " : "",
4722            (flags & EF_IA_64_ABI64) ? "ABI64" : "ABI32");
4723
4724   _bfd_elf_print_private_bfd_data (abfd, ptr);
4725   return TRUE;
4726 }
4727
4728 static enum elf_reloc_type_class
4729 elfNN_ia64_reloc_type_class (rela)
4730      const Elf_Internal_Rela *rela;
4731 {
4732   switch ((int) ELFNN_R_TYPE (rela->r_info))
4733     {
4734     case R_IA64_REL32MSB:
4735     case R_IA64_REL32LSB:
4736     case R_IA64_REL64MSB:
4737     case R_IA64_REL64LSB:
4738       return reloc_class_relative;
4739     case R_IA64_IPLTMSB:
4740     case R_IA64_IPLTLSB:
4741       return reloc_class_plt;
4742     case R_IA64_COPY:
4743       return reloc_class_copy;
4744     default:
4745       return reloc_class_normal;
4746     }
4747 }
4748
4749 static struct bfd_elf_special_section const elfNN_ia64_special_sections[]=
4750 {
4751   { ".sbss",            0,      NULL,   0,
4752     SHT_NOBITS,         SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
4753   { ".sdata",           0,      NULL,   0,
4754     SHT_PROGBITS,       SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
4755   { NULL,               0,      NULL,   0,
4756     0,                  0 }
4757 };
4758
4759 static bfd_boolean
4760 elfNN_ia64_hpux_vec (const bfd_target *vec)
4761 {
4762   extern const bfd_target bfd_elfNN_ia64_hpux_big_vec;
4763   return (vec == & bfd_elfNN_ia64_hpux_big_vec);
4764 }
4765
4766 static void
4767 elfNN_hpux_post_process_headers (abfd, info)
4768         bfd *abfd;
4769         struct bfd_link_info *info ATTRIBUTE_UNUSED;
4770 {
4771   Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
4772
4773   i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_HPUX;
4774   i_ehdrp->e_ident[EI_ABIVERSION] = 1;
4775 }
4776
4777 bfd_boolean
4778 elfNN_hpux_backend_section_from_bfd_section (abfd, sec, retval)
4779         bfd *abfd ATTRIBUTE_UNUSED;
4780         asection *sec;
4781         int *retval;
4782 {
4783   if (bfd_is_com_section (sec))
4784     {
4785       *retval = SHN_IA_64_ANSI_COMMON;
4786       return TRUE;
4787     }
4788   return FALSE;
4789 }
4790 \f
4791 #define TARGET_LITTLE_SYM               bfd_elfNN_ia64_little_vec
4792 #define TARGET_LITTLE_NAME              "elfNN-ia64-little"
4793 #define TARGET_BIG_SYM                  bfd_elfNN_ia64_big_vec
4794 #define TARGET_BIG_NAME                 "elfNN-ia64-big"
4795 #define ELF_ARCH                        bfd_arch_ia64
4796 #define ELF_MACHINE_CODE                EM_IA_64
4797 #define ELF_MACHINE_ALT1                1999    /* EAS2.3 */
4798 #define ELF_MACHINE_ALT2                1998    /* EAS2.2 */
4799 #define ELF_MAXPAGESIZE                 0x10000 /* 64KB */
4800
4801 #define elf_backend_section_from_shdr \
4802         elfNN_ia64_section_from_shdr
4803 #define elf_backend_section_flags \
4804         elfNN_ia64_section_flags
4805 #define elf_backend_fake_sections \
4806         elfNN_ia64_fake_sections
4807 #define elf_backend_final_write_processing \
4808         elfNN_ia64_final_write_processing
4809 #define elf_backend_add_symbol_hook \
4810         elfNN_ia64_add_symbol_hook
4811 #define elf_backend_additional_program_headers \
4812         elfNN_ia64_additional_program_headers
4813 #define elf_backend_modify_segment_map \
4814         elfNN_ia64_modify_segment_map
4815 #define elf_info_to_howto \
4816         elfNN_ia64_info_to_howto
4817
4818 #define bfd_elfNN_bfd_reloc_type_lookup \
4819         elfNN_ia64_reloc_type_lookup
4820 #define bfd_elfNN_bfd_is_local_label_name \
4821         elfNN_ia64_is_local_label_name
4822 #define bfd_elfNN_bfd_relax_section \
4823         elfNN_ia64_relax_section
4824
4825 /* Stuff for the BFD linker: */
4826 #define bfd_elfNN_bfd_link_hash_table_create \
4827         elfNN_ia64_hash_table_create
4828 #define elf_backend_create_dynamic_sections \
4829         elfNN_ia64_create_dynamic_sections
4830 #define elf_backend_check_relocs \
4831         elfNN_ia64_check_relocs
4832 #define elf_backend_adjust_dynamic_symbol \
4833         elfNN_ia64_adjust_dynamic_symbol
4834 #define elf_backend_size_dynamic_sections \
4835         elfNN_ia64_size_dynamic_sections
4836 #define elf_backend_relocate_section \
4837         elfNN_ia64_relocate_section
4838 #define elf_backend_finish_dynamic_symbol \
4839         elfNN_ia64_finish_dynamic_symbol
4840 #define elf_backend_finish_dynamic_sections \
4841         elfNN_ia64_finish_dynamic_sections
4842 #define bfd_elfNN_bfd_final_link \
4843         elfNN_ia64_final_link
4844
4845 #define bfd_elfNN_bfd_merge_private_bfd_data \
4846         elfNN_ia64_merge_private_bfd_data
4847 #define bfd_elfNN_bfd_set_private_flags \
4848         elfNN_ia64_set_private_flags
4849 #define bfd_elfNN_bfd_print_private_bfd_data \
4850         elfNN_ia64_print_private_bfd_data
4851
4852 #define elf_backend_plt_readonly        1
4853 #define elf_backend_want_plt_sym        0
4854 #define elf_backend_plt_alignment       5
4855 #define elf_backend_got_header_size     0
4856 #define elf_backend_plt_header_size     PLT_HEADER_SIZE
4857 #define elf_backend_want_got_plt        1
4858 #define elf_backend_may_use_rel_p       1
4859 #define elf_backend_may_use_rela_p      1
4860 #define elf_backend_default_use_rela_p  1
4861 #define elf_backend_want_dynbss         0
4862 #define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect
4863 #define elf_backend_hide_symbol         elfNN_ia64_hash_hide_symbol
4864 #define elf_backend_reloc_type_class    elfNN_ia64_reloc_type_class
4865 #define elf_backend_rela_normal         1
4866 #define elf_backend_special_sections    elfNN_ia64_special_sections
4867
4868 #include "elfNN-target.h"
4869
4870 /* HPUX-specific vectors.  */
4871
4872 #undef  TARGET_LITTLE_SYM
4873 #undef  TARGET_LITTLE_NAME
4874 #undef  TARGET_BIG_SYM
4875 #define TARGET_BIG_SYM                  bfd_elfNN_ia64_hpux_big_vec
4876 #undef  TARGET_BIG_NAME
4877 #define TARGET_BIG_NAME                 "elfNN-ia64-hpux-big"
4878
4879 /* These are HP-UX specific functions.  */
4880
4881 #undef  elf_backend_post_process_headers
4882 #define elf_backend_post_process_headers elfNN_hpux_post_process_headers
4883
4884 #undef  elf_backend_section_from_bfd_section
4885 #define elf_backend_section_from_bfd_section elfNN_hpux_backend_section_from_bfd_section
4886
4887 #undef  elf_backend_want_p_paddr_set_to_zero
4888 #define elf_backend_want_p_paddr_set_to_zero 1
4889
4890 #undef  ELF_MAXPAGESIZE
4891 #define ELF_MAXPAGESIZE                 0x1000  /* 1K */
4892
4893 #undef  elfNN_bed
4894 #define elfNN_bed elfNN_ia64_hpux_bed
4895
4896 #include "elfNN-target.h"
4897
4898 #undef  elf_backend_want_p_paddr_set_to_zero