bfd/elfxx-ia64.c

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