bfd/elfxx-ia64.c

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