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;
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 = 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         dyn_i->want_pltoff = 1;
2511       if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC))
2512         {
2513           if (!srel)
2514             {
2515               srel = get_reloc_section (abfd, ia64_info, sec, TRUE);
2516               if (!srel)
2517                 return FALSE;
2518             }
2519           if (!count_dyn_reloc (abfd, dyn_i, srel, dynrel_type,
2520                                 (sec->flags & SEC_READONLY) != 0))
2521             return FALSE;
2522         }
2523     }
2524
2525   return TRUE;
2526 }
2527
2528 /* For cleanliness, and potentially faster dynamic loading, allocate
2529    external GOT entries first.  */
2530
2531 static bfd_boolean
2532 allocate_global_data_got (dyn_i, data)
2533      struct elfNN_ia64_dyn_sym_info *dyn_i;
2534      PTR data;
2535 {
2536   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2537
2538   if ((dyn_i->want_got || dyn_i->want_gotx)
2539       && ! dyn_i->want_fptr
2540       && elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
2541      {
2542        dyn_i->got_offset = x->ofs;
2543        x->ofs += 8;
2544      }
2545   if (dyn_i->want_tprel)
2546     {
2547       dyn_i->tprel_offset = x->ofs;
2548       x->ofs += 8;
2549     }
2550   if (dyn_i->want_dtpmod)
2551     {
2552       if (elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
2553         {
2554           dyn_i->dtpmod_offset = x->ofs;
2555           x->ofs += 8;
2556         }
2557       else
2558         {
2559           struct elfNN_ia64_link_hash_table *ia64_info;
2560
2561           ia64_info = elfNN_ia64_hash_table (x->info);
2562           if (ia64_info->self_dtpmod_offset == (bfd_vma) -1)
2563             {
2564               ia64_info->self_dtpmod_offset = x->ofs;
2565               x->ofs += 8;
2566             }
2567           dyn_i->dtpmod_offset = ia64_info->self_dtpmod_offset;
2568         }
2569     }
2570   if (dyn_i->want_dtprel)
2571     {
2572       dyn_i->dtprel_offset = x->ofs;
2573       x->ofs += 8;
2574     }
2575   return TRUE;
2576 }
2577
2578 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs.  */
2579
2580 static bfd_boolean
2581 allocate_global_fptr_got (dyn_i, data)
2582      struct elfNN_ia64_dyn_sym_info *dyn_i;
2583      PTR data;
2584 {
2585   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2586
2587   if (dyn_i->want_got
2588       && dyn_i->want_fptr
2589       && elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, R_IA64_FPTR64LSB))
2590     {
2591       dyn_i->got_offset = x->ofs;
2592       x->ofs += 8;
2593     }
2594   return TRUE;
2595 }
2596
2597 /* Lastly, allocate all the GOT entries for local data.  */
2598
2599 static bfd_boolean
2600 allocate_local_got (dyn_i, data)
2601      struct elfNN_ia64_dyn_sym_info *dyn_i;
2602      PTR data;
2603 {
2604   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2605
2606   if ((dyn_i->want_got || dyn_i->want_gotx)
2607       && !elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
2608     {
2609       dyn_i->got_offset = x->ofs;
2610       x->ofs += 8;
2611     }
2612   return TRUE;
2613 }
2614
2615 /* Search for the index of a global symbol in it's defining object file.  */
2616
2617 static long
2618 global_sym_index (h)
2619      struct elf_link_hash_entry *h;
2620 {
2621   struct elf_link_hash_entry **p;
2622   bfd *obj;
2623
2624   BFD_ASSERT (h->root.type == bfd_link_hash_defined
2625               || h->root.type == bfd_link_hash_defweak);
2626
2627   obj = h->root.u.def.section->owner;
2628   for (p = elf_sym_hashes (obj); *p != h; ++p)
2629     continue;
2630
2631   return p - elf_sym_hashes (obj) + elf_tdata (obj)->symtab_hdr.sh_info;
2632 }
2633
2634 /* Allocate function descriptors.  We can do these for every function
2635    in a main executable that is not exported.  */
2636
2637 static bfd_boolean
2638 allocate_fptr (dyn_i, data)
2639      struct elfNN_ia64_dyn_sym_info *dyn_i;
2640      PTR data;
2641 {
2642   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2643
2644   if (dyn_i->want_fptr)
2645     {
2646       struct elf_link_hash_entry *h = dyn_i->h;
2647
2648       if (h)
2649         while (h->root.type == bfd_link_hash_indirect
2650                || h->root.type == bfd_link_hash_warning)
2651           h = (struct elf_link_hash_entry *) h->root.u.i.link;
2652
2653       if (!x->info->executable
2654           && (!h
2655               || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2656               || h->root.type != bfd_link_hash_undefweak))
2657         {
2658           if (h && h->dynindx == -1)
2659             {
2660               BFD_ASSERT ((h->root.type == bfd_link_hash_defined)
2661                           || (h->root.type == bfd_link_hash_defweak));
2662
2663               if (!bfd_elf_link_record_local_dynamic_symbol
2664                     (x->info, h->root.u.def.section->owner,
2665                      global_sym_index (h)))
2666                 return FALSE;
2667             }
2668
2669           dyn_i->want_fptr = 0;
2670         }
2671       else if (h == NULL || h->dynindx == -1)
2672         {
2673           dyn_i->fptr_offset = x->ofs;
2674           x->ofs += 16;
2675         }
2676       else
2677         dyn_i->want_fptr = 0;
2678     }
2679   return TRUE;
2680 }
2681
2682 /* Allocate all the minimal PLT entries.  */
2683
2684 static bfd_boolean
2685 allocate_plt_entries (dyn_i, data)
2686      struct elfNN_ia64_dyn_sym_info *dyn_i;
2687      PTR data;
2688 {
2689   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2690
2691   if (dyn_i->want_plt)
2692     {
2693       struct elf_link_hash_entry *h = dyn_i->h;
2694
2695       if (h)
2696         while (h->root.type == bfd_link_hash_indirect
2697                || h->root.type == bfd_link_hash_warning)
2698           h = (struct elf_link_hash_entry *) h->root.u.i.link;
2699
2700       /* ??? Versioned symbols seem to lose ELF_LINK_HASH_NEEDS_PLT.  */
2701       if (elfNN_ia64_dynamic_symbol_p (h, x->info, 0))
2702         {
2703           bfd_size_type offset = x->ofs;
2704           if (offset == 0)
2705             offset = PLT_HEADER_SIZE;
2706           dyn_i->plt_offset = offset;
2707           x->ofs = offset + PLT_MIN_ENTRY_SIZE;
2708
2709           dyn_i->want_pltoff = 1;
2710         }
2711       else
2712         {
2713           dyn_i->want_plt = 0;
2714           dyn_i->want_plt2 = 0;
2715         }
2716     }
2717   return TRUE;
2718 }
2719
2720 /* Allocate all the full PLT entries.  */
2721
2722 static bfd_boolean
2723 allocate_plt2_entries (dyn_i, data)
2724      struct elfNN_ia64_dyn_sym_info *dyn_i;
2725      PTR data;
2726 {
2727   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2728
2729   if (dyn_i->want_plt2)
2730     {
2731       struct elf_link_hash_entry *h = dyn_i->h;
2732       bfd_size_type ofs = x->ofs;
2733
2734       dyn_i->plt2_offset = ofs;
2735       x->ofs = ofs + PLT_FULL_ENTRY_SIZE;
2736
2737       while (h->root.type == bfd_link_hash_indirect
2738              || h->root.type == bfd_link_hash_warning)
2739         h = (struct elf_link_hash_entry *) h->root.u.i.link;
2740       dyn_i->h->plt.offset = ofs;
2741     }
2742   return TRUE;
2743 }
2744
2745 /* Allocate all the PLTOFF entries requested by relocations and
2746    plt entries.  We can't share space with allocated FPTR entries,
2747    because the latter are not necessarily addressable by the GP.
2748    ??? Relaxation might be able to determine that they are.  */
2749
2750 static bfd_boolean
2751 allocate_pltoff_entries (dyn_i, data)
2752      struct elfNN_ia64_dyn_sym_info *dyn_i;
2753      PTR data;
2754 {
2755   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2756
2757   if (dyn_i->want_pltoff)
2758     {
2759       dyn_i->pltoff_offset = x->ofs;
2760       x->ofs += 16;
2761     }
2762   return TRUE;
2763 }
2764
2765 /* Allocate dynamic relocations for those symbols that turned out
2766    to be dynamic.  */
2767
2768 static bfd_boolean
2769 allocate_dynrel_entries (dyn_i, data)
2770      struct elfNN_ia64_dyn_sym_info *dyn_i;
2771      PTR data;
2772 {
2773   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2774   struct elfNN_ia64_link_hash_table *ia64_info;
2775   struct elfNN_ia64_dyn_reloc_entry *rent;
2776   bfd_boolean dynamic_symbol, shared, resolved_zero;
2777
2778   ia64_info = elfNN_ia64_hash_table (x->info);
2779
2780   /* Note that this can't be used in relation to FPTR relocs below.  */
2781   dynamic_symbol = elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0);
2782
2783   shared = x->info->shared;
2784   resolved_zero = (dyn_i->h
2785                    && ELF_ST_VISIBILITY (dyn_i->h->other)
2786                    && dyn_i->h->root.type == bfd_link_hash_undefweak);
2787
2788   /* Take care of the normal data relocations.  */
2789
2790   for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
2791     {
2792       int count = rent->count;
2793
2794       switch (rent->type)
2795         {
2796         case R_IA64_FPTR64LSB:
2797           /* Allocate one iff !want_fptr and not PIE, which by this point
2798              will be true only if we're actually allocating one statically
2799              in the main executable.  Position independent executables
2800              need a relative reloc.  */
2801           if (dyn_i->want_fptr && !x->info->pie)
2802             continue;
2803           break;
2804         case R_IA64_PCREL64LSB:
2805           if (!dynamic_symbol)
2806             continue;
2807           break;
2808         case R_IA64_DIR64LSB:
2809           if (!dynamic_symbol && !shared)
2810             continue;
2811           break;
2812         case R_IA64_IPLTLSB:
2813           if (!dynamic_symbol && !shared)
2814             continue;
2815           /* Use two REL relocations for IPLT relocations
2816              against local symbols.  */
2817           if (!dynamic_symbol)
2818             count *= 2;
2819           break;
2820         case R_IA64_TPREL64LSB:
2821         case R_IA64_DTPREL64LSB:
2822         case R_IA64_DTPMOD64LSB:
2823           break;
2824         default:
2825           abort ();
2826         }
2827       if (rent->reltext)
2828         ia64_info->reltext = 1;
2829       rent->srel->size += sizeof (ElfNN_External_Rela) * count;
2830     }
2831
2832   /* Take care of the GOT and PLT relocations.  */
2833
2834   if ((!resolved_zero
2835        && (dynamic_symbol || shared)
2836        && (dyn_i->want_got || dyn_i->want_gotx))
2837       || (dyn_i->want_ltoff_fptr
2838           && dyn_i->h
2839           && dyn_i->h->dynindx != -1))
2840     {
2841       if (!dyn_i->want_ltoff_fptr
2842           || !x->info->pie
2843           || dyn_i->h == NULL
2844           || dyn_i->h->root.type != bfd_link_hash_undefweak)
2845         ia64_info->rel_got_sec->size += sizeof (ElfNN_External_Rela);
2846     }
2847   if ((dynamic_symbol || shared) && dyn_i->want_tprel)
2848     ia64_info->rel_got_sec->size += sizeof (ElfNN_External_Rela);
2849   if (dynamic_symbol && dyn_i->want_dtpmod)
2850     ia64_info->rel_got_sec->size += sizeof (ElfNN_External_Rela);
2851   if (dynamic_symbol && dyn_i->want_dtprel)
2852     ia64_info->rel_got_sec->size += sizeof (ElfNN_External_Rela);
2853   if (ia64_info->rel_fptr_sec && dyn_i->want_fptr)
2854     {
2855       if (dyn_i->h == NULL || dyn_i->h->root.type != bfd_link_hash_undefweak)
2856         ia64_info->rel_fptr_sec->size += sizeof (ElfNN_External_Rela);
2857     }
2858
2859   if (!resolved_zero && dyn_i->want_pltoff)
2860     {
2861       bfd_size_type t = 0;
2862
2863       /* Dynamic symbols get one IPLT relocation.  Local symbols in
2864          shared libraries get two REL relocations.  Local symbols in
2865          main applications get nothing.  */
2866       if (dynamic_symbol)
2867         t = sizeof (ElfNN_External_Rela);
2868       else if (shared)
2869         t = 2 * sizeof (ElfNN_External_Rela);
2870
2871       ia64_info->rel_pltoff_sec->size += t;
2872     }
2873
2874   return TRUE;
2875 }
2876
2877 static bfd_boolean
2878 elfNN_ia64_adjust_dynamic_symbol (info, h)
2879      struct bfd_link_info *info ATTRIBUTE_UNUSED;
2880      struct elf_link_hash_entry *h;
2881 {
2882   /* ??? Undefined symbols with PLT entries should be re-defined
2883      to be the PLT entry.  */
2884
2885   /* If this is a weak symbol, and there is a real definition, the
2886      processor independent code will have arranged for us to see the
2887      real definition first, and we can just use the same value.  */
2888   if (h->weakdef != NULL)
2889     {
2890       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2891                   || h->weakdef->root.type == bfd_link_hash_defweak);
2892       h->root.u.def.section = h->weakdef->root.u.def.section;
2893       h->root.u.def.value = h->weakdef->root.u.def.value;
2894       return TRUE;
2895     }
2896
2897   /* If this is a reference to a symbol defined by a dynamic object which
2898      is not a function, we might allocate the symbol in our .dynbss section
2899      and allocate a COPY dynamic relocation.
2900
2901      But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2902      of hackery.  */
2903
2904   return TRUE;
2905 }
2906
2907 static bfd_boolean
2908 elfNN_ia64_size_dynamic_sections (output_bfd, info)
2909      bfd *output_bfd ATTRIBUTE_UNUSED;
2910      struct bfd_link_info *info;
2911 {
2912   struct elfNN_ia64_allocate_data data;
2913   struct elfNN_ia64_link_hash_table *ia64_info;
2914   asection *sec;
2915   bfd *dynobj;
2916   bfd_boolean relplt = FALSE;
2917
2918   dynobj = elf_hash_table(info)->dynobj;
2919   ia64_info = elfNN_ia64_hash_table (info);
2920   ia64_info->self_dtpmod_offset = (bfd_vma) -1;
2921   BFD_ASSERT(dynobj != NULL);
2922   data.info = info;
2923
2924   /* Set the contents of the .interp section to the interpreter.  */
2925   if (ia64_info->root.dynamic_sections_created
2926       && info->executable)
2927     {
2928       sec = bfd_get_section_by_name (dynobj, ".interp");
2929       BFD_ASSERT (sec != NULL);
2930       sec->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
2931       sec->size = strlen (ELF_DYNAMIC_INTERPRETER) + 1;
2932     }
2933
2934   /* Allocate the GOT entries.  */
2935
2936   if (ia64_info->got_sec)
2937     {
2938       data.ofs = 0;
2939       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data);
2940       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data);
2941       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data);
2942       ia64_info->got_sec->size = data.ofs;
2943     }
2944
2945   /* Allocate the FPTR entries.  */
2946
2947   if (ia64_info->fptr_sec)
2948     {
2949       data.ofs = 0;
2950       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_fptr, &data);
2951       ia64_info->fptr_sec->size = data.ofs;
2952     }
2953
2954   /* Now that we've seen all of the input files, we can decide which
2955      symbols need plt entries.  Allocate the minimal PLT entries first.
2956      We do this even though dynamic_sections_created may be FALSE, because
2957      this has the side-effect of clearing want_plt and want_plt2.  */
2958
2959   data.ofs = 0;
2960   elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_plt_entries, &data);
2961
2962   ia64_info->minplt_entries = 0;
2963   if (data.ofs)
2964     {
2965       ia64_info->minplt_entries
2966         = (data.ofs - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
2967     }
2968
2969   /* Align the pointer for the plt2 entries.  */
2970   data.ofs = (data.ofs + 31) & (bfd_vma) -32;
2971
2972   elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_plt2_entries, &data);
2973   if (data.ofs != 0 || ia64_info->root.dynamic_sections_created)
2974     {
2975       /* FIXME: we always reserve the memory for dynamic linker even if
2976          there are no PLT entries since dynamic linker may assume the
2977          reserved memory always exists.  */
2978
2979       BFD_ASSERT (ia64_info->root.dynamic_sections_created);
2980
2981       ia64_info->plt_sec->size = data.ofs;
2982
2983       /* If we've got a .plt, we need some extra memory for the dynamic
2984          linker.  We stuff these in .got.plt.  */
2985       sec = bfd_get_section_by_name (dynobj, ".got.plt");
2986       sec->size = 8 * PLT_RESERVED_WORDS;
2987     }
2988
2989   /* Allocate the PLTOFF entries.  */
2990
2991   if (ia64_info->pltoff_sec)
2992     {
2993       data.ofs = 0;
2994       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_pltoff_entries, &data);
2995       ia64_info->pltoff_sec->size = data.ofs;
2996     }
2997
2998   if (ia64_info->root.dynamic_sections_created)
2999     {
3000       /* Allocate space for the dynamic relocations that turned out to be
3001          required.  */
3002
3003       if (info->shared && ia64_info->self_dtpmod_offset != (bfd_vma) -1)
3004         ia64_info->rel_got_sec->size += sizeof (ElfNN_External_Rela);
3005       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries, &data);
3006     }
3007
3008   /* We have now determined the sizes of the various dynamic sections.
3009      Allocate memory for them.  */
3010   for (sec = dynobj->sections; sec != NULL; sec = sec->next)
3011     {
3012       bfd_boolean strip;
3013
3014       if (!(sec->flags & SEC_LINKER_CREATED))
3015         continue;
3016
3017       /* If we don't need this section, strip it from the output file.
3018          There were several sections primarily related to dynamic
3019          linking that must be create before the linker maps input
3020          sections to output sections.  The linker does that before
3021          bfd_elf_size_dynamic_sections is called, and it is that
3022          function which decides whether anything needs to go into
3023          these sections.  */
3024
3025       strip = (sec->size == 0);
3026
3027       if (sec == ia64_info->got_sec)
3028         strip = FALSE;
3029       else if (sec == ia64_info->rel_got_sec)
3030         {
3031           if (strip)
3032             ia64_info->rel_got_sec = NULL;
3033           else
3034             /* We use the reloc_count field as a counter if we need to
3035                copy relocs into the output file.  */
3036             sec->reloc_count = 0;
3037         }
3038       else if (sec == ia64_info->fptr_sec)
3039         {
3040           if (strip)
3041             ia64_info->fptr_sec = NULL;
3042         }
3043       else if (sec == ia64_info->rel_fptr_sec)
3044         {
3045           if (strip)
3046             ia64_info->rel_fptr_sec = NULL;
3047           else
3048             /* We use the reloc_count field as a counter if we need to
3049                copy relocs into the output file.  */
3050             sec->reloc_count = 0;
3051         }
3052       else if (sec == ia64_info->plt_sec)
3053         {
3054           if (strip)
3055             ia64_info->plt_sec = NULL;
3056         }
3057       else if (sec == ia64_info->pltoff_sec)
3058         {
3059           if (strip)
3060             ia64_info->pltoff_sec = NULL;
3061         }
3062       else if (sec == ia64_info->rel_pltoff_sec)
3063         {
3064           if (strip)
3065             ia64_info->rel_pltoff_sec = NULL;
3066           else
3067             {
3068               relplt = TRUE;
3069               /* We use the reloc_count field as a counter if we need to
3070                  copy relocs into the output file.  */
3071               sec->reloc_count = 0;
3072             }
3073         }
3074       else
3075         {
3076           const char *name;
3077
3078           /* It's OK to base decisions on the section name, because none
3079              of the dynobj section names depend upon the input files.  */
3080           name = bfd_get_section_name (dynobj, sec);
3081
3082           if (strcmp (name, ".got.plt") == 0)
3083             strip = FALSE;
3084           else if (strncmp (name, ".rel", 4) == 0)
3085             {
3086               if (!strip)
3087                 {
3088                   /* We use the reloc_count field as a counter if we need to
3089                      copy relocs into the output file.  */
3090                   sec->reloc_count = 0;
3091                 }
3092             }
3093           else
3094             continue;
3095         }
3096
3097       if (strip)
3098         _bfd_strip_section_from_output (info, sec);
3099       else
3100         {
3101           /* Allocate memory for the section contents.  */
3102           sec->contents = (bfd_byte *) bfd_zalloc (dynobj, sec->size);
3103           if (sec->contents == NULL && sec->size != 0)
3104             return FALSE;
3105         }
3106     }
3107
3108   if (elf_hash_table (info)->dynamic_sections_created)
3109     {
3110       /* Add some entries to the .dynamic section.  We fill in the values
3111          later (in finish_dynamic_sections) but we must add the entries now
3112          so that we get the correct size for the .dynamic section.  */
3113
3114       if (info->executable)
3115         {
3116           /* The DT_DEBUG entry is filled in by the dynamic linker and used
3117              by the debugger.  */
3118 #define add_dynamic_entry(TAG, VAL) \
3119   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3120
3121           if (!add_dynamic_entry (DT_DEBUG, 0))
3122             return FALSE;
3123         }
3124
3125       if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE, 0))
3126         return FALSE;
3127       if (!add_dynamic_entry (DT_PLTGOT, 0))
3128         return FALSE;
3129
3130       if (relplt)
3131         {
3132           if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3133               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3134               || !add_dynamic_entry (DT_JMPREL, 0))
3135             return FALSE;
3136         }
3137
3138       if (!add_dynamic_entry (DT_RELA, 0)
3139           || !add_dynamic_entry (DT_RELASZ, 0)
3140           || !add_dynamic_entry (DT_RELAENT, sizeof (ElfNN_External_Rela)))
3141         return FALSE;
3142
3143       if (ia64_info->reltext)
3144         {
3145           if (!add_dynamic_entry (DT_TEXTREL, 0))
3146             return FALSE;
3147           info->flags |= DF_TEXTREL;
3148         }
3149     }
3150
3151   /* ??? Perhaps force __gp local.  */
3152
3153   return TRUE;
3154 }
3155
3156 static bfd_reloc_status_type
3157 elfNN_ia64_install_value (abfd, hit_addr, v, r_type)
3158      bfd *abfd;
3159      bfd_byte *hit_addr;
3160      bfd_vma v;
3161      unsigned int r_type;
3162 {
3163   const struct ia64_operand *op;
3164   int bigendian = 0, shift = 0;
3165   bfd_vma t0, t1, insn, dword;
3166   enum ia64_opnd opnd;
3167   const char *err;
3168   size_t size = 8;
3169 #ifdef BFD_HOST_U_64_BIT
3170   BFD_HOST_U_64_BIT val = (BFD_HOST_U_64_BIT) v;
3171 #else
3172   bfd_vma val = v;
3173 #endif
3174
3175   opnd = IA64_OPND_NIL;
3176   switch (r_type)
3177     {
3178     case R_IA64_NONE:
3179     case R_IA64_LDXMOV:
3180       return bfd_reloc_ok;
3181
3182       /* Instruction relocations.  */
3183
3184     case R_IA64_IMM14:
3185     case R_IA64_TPREL14:
3186     case R_IA64_DTPREL14:
3187       opnd = IA64_OPND_IMM14;
3188       break;
3189
3190     case R_IA64_PCREL21F:       opnd = IA64_OPND_TGT25; break;
3191     case R_IA64_PCREL21M:       opnd = IA64_OPND_TGT25b; break;
3192     case R_IA64_PCREL60B:       opnd = IA64_OPND_TGT64; break;
3193     case R_IA64_PCREL21B:
3194     case R_IA64_PCREL21BI:
3195       opnd = IA64_OPND_TGT25c;
3196       break;
3197
3198     case R_IA64_IMM22:
3199     case R_IA64_GPREL22:
3200     case R_IA64_LTOFF22:
3201     case R_IA64_LTOFF22X:
3202     case R_IA64_PLTOFF22:
3203     case R_IA64_PCREL22:
3204     case R_IA64_LTOFF_FPTR22:
3205     case R_IA64_TPREL22:
3206     case R_IA64_DTPREL22:
3207     case R_IA64_LTOFF_TPREL22:
3208     case R_IA64_LTOFF_DTPMOD22:
3209     case R_IA64_LTOFF_DTPREL22:
3210       opnd = IA64_OPND_IMM22;
3211       break;
3212
3213     case R_IA64_IMM64:
3214     case R_IA64_GPREL64I:
3215     case R_IA64_LTOFF64I:
3216     case R_IA64_PLTOFF64I:
3217     case R_IA64_PCREL64I:
3218     case R_IA64_FPTR64I:
3219     case R_IA64_LTOFF_FPTR64I:
3220     case R_IA64_TPREL64I:
3221     case R_IA64_DTPREL64I:
3222       opnd = IA64_OPND_IMMU64;
3223       break;
3224
3225       /* Data relocations.  */
3226
3227     case R_IA64_DIR32MSB:
3228     case R_IA64_GPREL32MSB:
3229     case R_IA64_FPTR32MSB:
3230     case R_IA64_PCREL32MSB:
3231     case R_IA64_LTOFF_FPTR32MSB:
3232     case R_IA64_SEGREL32MSB:
3233     case R_IA64_SECREL32MSB:
3234     case R_IA64_LTV32MSB:
3235     case R_IA64_DTPREL32MSB:
3236       size = 4; bigendian = 1;
3237       break;
3238
3239     case R_IA64_DIR32LSB:
3240     case R_IA64_GPREL32LSB:
3241     case R_IA64_FPTR32LSB:
3242     case R_IA64_PCREL32LSB:
3243     case R_IA64_LTOFF_FPTR32LSB:
3244     case R_IA64_SEGREL32LSB:
3245     case R_IA64_SECREL32LSB:
3246     case R_IA64_LTV32LSB:
3247     case R_IA64_DTPREL32LSB:
3248       size = 4; bigendian = 0;
3249       break;
3250
3251     case R_IA64_DIR64MSB:
3252     case R_IA64_GPREL64MSB:
3253     case R_IA64_PLTOFF64MSB:
3254     case R_IA64_FPTR64MSB:
3255     case R_IA64_PCREL64MSB:
3256     case R_IA64_LTOFF_FPTR64MSB:
3257     case R_IA64_SEGREL64MSB:
3258     case R_IA64_SECREL64MSB:
3259     case R_IA64_LTV64MSB:
3260     case R_IA64_TPREL64MSB:
3261     case R_IA64_DTPMOD64MSB:
3262     case R_IA64_DTPREL64MSB:
3263       size = 8; bigendian = 1;
3264       break;
3265
3266     case R_IA64_DIR64LSB:
3267     case R_IA64_GPREL64LSB:
3268     case R_IA64_PLTOFF64LSB:
3269     case R_IA64_FPTR64LSB:
3270     case R_IA64_PCREL64LSB:
3271     case R_IA64_LTOFF_FPTR64LSB:
3272     case R_IA64_SEGREL64LSB:
3273     case R_IA64_SECREL64LSB:
3274     case R_IA64_LTV64LSB:
3275     case R_IA64_TPREL64LSB:
3276     case R_IA64_DTPMOD64LSB:
3277     case R_IA64_DTPREL64LSB:
3278       size = 8; bigendian = 0;
3279       break;
3280
3281       /* Unsupported / Dynamic relocations.  */
3282     default:
3283       return bfd_reloc_notsupported;
3284     }
3285
3286   switch (opnd)
3287     {
3288     case IA64_OPND_IMMU64:
3289       hit_addr -= (long) hit_addr & 0x3;
3290       t0 = bfd_get_64 (abfd, hit_addr);
3291       t1 = bfd_get_64 (abfd, hit_addr + 8);
3292
3293       /* tmpl/s: bits  0.. 5 in t0
3294          slot 0: bits  5..45 in t0
3295          slot 1: bits 46..63 in t0, bits 0..22 in t1
3296          slot 2: bits 23..63 in t1 */
3297
3298       /* First, clear the bits that form the 64 bit constant.  */
3299       t0 &= ~(0x3ffffLL << 46);
3300       t1 &= ~(0x7fffffLL
3301               | ((  (0x07fLL << 13) | (0x1ffLL << 27)
3302                     | (0x01fLL << 22) | (0x001LL << 21)
3303                     | (0x001LL << 36)) << 23));
3304
3305       t0 |= ((val >> 22) & 0x03ffffLL) << 46;           /* 18 lsbs of imm41 */
3306       t1 |= ((val >> 40) & 0x7fffffLL) <<  0;           /* 23 msbs of imm41 */
3307       t1 |= (  (((val >>  0) & 0x07f) << 13)            /* imm7b */
3308                | (((val >>  7) & 0x1ff) << 27)          /* imm9d */
3309                | (((val >> 16) & 0x01f) << 22)          /* imm5c */
3310                | (((val >> 21) & 0x001) << 21)          /* ic */
3311                | (((val >> 63) & 0x001) << 36)) << 23;  /* i */
3312
3313       bfd_put_64 (abfd, t0, hit_addr);
3314       bfd_put_64 (abfd, t1, hit_addr + 8);
3315       break;
3316
3317     case IA64_OPND_TGT64:
3318       hit_addr -= (long) hit_addr & 0x3;
3319       t0 = bfd_get_64 (abfd, hit_addr);
3320       t1 = bfd_get_64 (abfd, hit_addr + 8);
3321
3322       /* tmpl/s: bits  0.. 5 in t0
3323          slot 0: bits  5..45 in t0
3324          slot 1: bits 46..63 in t0, bits 0..22 in t1
3325          slot 2: bits 23..63 in t1 */
3326
3327       /* First, clear the bits that form the 64 bit constant.  */
3328       t0 &= ~(0x3ffffLL << 46);
3329       t1 &= ~(0x7fffffLL
3330               | ((1LL << 36 | 0xfffffLL << 13) << 23));
3331
3332       val >>= 4;
3333       t0 |= ((val >> 20) & 0xffffLL) << 2 << 46;        /* 16 lsbs of imm39 */
3334       t1 |= ((val >> 36) & 0x7fffffLL) << 0;            /* 23 msbs of imm39 */
3335       t1 |= ((((val >> 0) & 0xfffffLL) << 13)           /* imm20b */
3336               | (((val >> 59) & 0x1LL) << 36)) << 23;   /* i */
3337
3338       bfd_put_64 (abfd, t0, hit_addr);
3339       bfd_put_64 (abfd, t1, hit_addr + 8);
3340       break;
3341
3342     default:
3343       switch ((long) hit_addr & 0x3)
3344         {
3345         case 0: shift =  5; break;
3346         case 1: shift = 14; hit_addr += 3; break;
3347         case 2: shift = 23; hit_addr += 6; break;
3348         case 3: return bfd_reloc_notsupported; /* shouldn't happen...  */
3349         }
3350       dword = bfd_get_64 (abfd, hit_addr);
3351       insn = (dword >> shift) & 0x1ffffffffffLL;
3352
3353       op = elf64_ia64_operands + opnd;
3354       err = (*op->insert) (op, val, (ia64_insn *)& insn);
3355       if (err)
3356         return bfd_reloc_overflow;
3357
3358       dword &= ~(0x1ffffffffffLL << shift);
3359       dword |= (insn << shift);
3360       bfd_put_64 (abfd, dword, hit_addr);
3361       break;
3362
3363     case IA64_OPND_NIL:
3364       /* A data relocation.  */
3365       if (bigendian)
3366         if (size == 4)
3367           bfd_putb32 (val, hit_addr);
3368         else
3369           bfd_putb64 (val, hit_addr);
3370       else
3371         if (size == 4)
3372           bfd_putl32 (val, hit_addr);
3373         else
3374           bfd_putl64 (val, hit_addr);
3375       break;
3376     }
3377
3378   return bfd_reloc_ok;
3379 }
3380
3381 static void
3382 elfNN_ia64_install_dyn_reloc (abfd, info, sec, srel, offset, type,
3383                               dynindx, addend)
3384      bfd *abfd;
3385      struct bfd_link_info *info;
3386      asection *sec;
3387      asection *srel;
3388      bfd_vma offset;
3389      unsigned int type;
3390      long dynindx;
3391      bfd_vma addend;
3392 {
3393   Elf_Internal_Rela outrel;
3394   bfd_byte *loc;
3395
3396   BFD_ASSERT (dynindx != -1);
3397   outrel.r_info = ELFNN_R_INFO (dynindx, type);
3398   outrel.r_addend = addend;
3399   outrel.r_offset = _bfd_elf_section_offset (abfd, info, sec, offset);
3400   if (outrel.r_offset >= (bfd_vma) -2)
3401     {
3402       /* Run for the hills.  We shouldn't be outputting a relocation
3403          for this.  So do what everyone else does and output a no-op.  */
3404       outrel.r_info = ELFNN_R_INFO (0, R_IA64_NONE);
3405       outrel.r_addend = 0;
3406       outrel.r_offset = 0;
3407     }
3408   else
3409     outrel.r_offset += sec->output_section->vma + sec->output_offset;
3410
3411   loc = srel->contents;
3412   loc += srel->reloc_count++ * sizeof (ElfNN_External_Rela);
3413   bfd_elfNN_swap_reloca_out (abfd, &outrel, loc);
3414   BFD_ASSERT (sizeof (ElfNN_External_Rela) * srel->reloc_count <= srel->size);
3415 }
3416
3417 /* Store an entry for target address TARGET_ADDR in the linkage table
3418    and return the gp-relative address of the linkage table entry.  */
3419
3420 static bfd_vma
3421 set_got_entry (abfd, info, dyn_i, dynindx, addend, value, dyn_r_type)
3422      bfd *abfd;
3423      struct bfd_link_info *info;
3424      struct elfNN_ia64_dyn_sym_info *dyn_i;
3425      long dynindx;
3426      bfd_vma addend;
3427      bfd_vma value;
3428      unsigned int dyn_r_type;
3429 {
3430   struct elfNN_ia64_link_hash_table *ia64_info;
3431   asection *got_sec;
3432   bfd_boolean done;
3433   bfd_vma got_offset;
3434
3435   ia64_info = elfNN_ia64_hash_table (info);
3436   got_sec = ia64_info->got_sec;
3437
3438   switch (dyn_r_type)
3439     {
3440     case R_IA64_TPREL64LSB:
3441       done = dyn_i->tprel_done;
3442       dyn_i->tprel_done = TRUE;
3443       got_offset = dyn_i->tprel_offset;
3444       break;
3445     case R_IA64_DTPMOD64LSB:
3446       if (dyn_i->dtpmod_offset != ia64_info->self_dtpmod_offset)
3447         {
3448           done = dyn_i->dtpmod_done;
3449           dyn_i->dtpmod_done = TRUE;
3450         }
3451       else
3452         {
3453           done = ia64_info->self_dtpmod_done;
3454           ia64_info->self_dtpmod_done = TRUE;
3455           dynindx = 0;
3456         }
3457       got_offset = dyn_i->dtpmod_offset;
3458       break;
3459     case R_IA64_DTPREL64LSB:
3460       done = dyn_i->dtprel_done;
3461       dyn_i->dtprel_done = TRUE;
3462       got_offset = dyn_i->dtprel_offset;
3463       break;
3464     default:
3465       done = dyn_i->got_done;
3466       dyn_i->got_done = TRUE;
3467       got_offset = dyn_i->got_offset;
3468       break;
3469     }
3470
3471   BFD_ASSERT ((got_offset & 7) == 0);
3472
3473   if (! done)
3474     {
3475       /* Store the target address in the linkage table entry.  */
3476       bfd_put_64 (abfd, value, got_sec->contents + got_offset);
3477
3478       /* Install a dynamic relocation if needed.  */
3479       if (((info->shared
3480             && (!dyn_i->h
3481                 || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
3482                 || dyn_i->h->root.type != bfd_link_hash_undefweak)
3483             && dyn_r_type != R_IA64_DTPREL64LSB)
3484            || elfNN_ia64_dynamic_symbol_p (dyn_i->h, info, dyn_r_type)
3485            || (dynindx != -1 && dyn_r_type == R_IA64_FPTR64LSB))
3486           && (!dyn_i->want_ltoff_fptr
3487               || !info->pie
3488               || !dyn_i->h
3489               || dyn_i->h->root.type != bfd_link_hash_undefweak))
3490         {
3491           if (dynindx == -1
3492               && dyn_r_type != R_IA64_TPREL64LSB
3493               && dyn_r_type != R_IA64_DTPMOD64LSB
3494               && dyn_r_type != R_IA64_DTPREL64LSB)
3495             {
3496               dyn_r_type = R_IA64_REL64LSB;
3497               dynindx = 0;
3498               addend = value;
3499             }
3500
3501           if (bfd_big_endian (abfd))
3502             {
3503               switch (dyn_r_type)
3504                 {
3505                 case R_IA64_REL64LSB:
3506                   dyn_r_type = R_IA64_REL64MSB;
3507                   break;
3508                 case R_IA64_DIR64LSB:
3509                   dyn_r_type = R_IA64_DIR64MSB;
3510                   break;
3511                 case R_IA64_FPTR64LSB:
3512                   dyn_r_type = R_IA64_FPTR64MSB;
3513                   break;
3514                 case R_IA64_TPREL64LSB:
3515                   dyn_r_type = R_IA64_TPREL64MSB;
3516                   break;
3517                 case R_IA64_DTPMOD64LSB:
3518                   dyn_r_type = R_IA64_DTPMOD64MSB;
3519                   break;
3520                 case R_IA64_DTPREL64LSB:
3521                   dyn_r_type = R_IA64_DTPREL64MSB;
3522                   break;
3523                 default:
3524                   BFD_ASSERT (FALSE);
3525                   break;
3526                 }
3527             }
3528
3529           elfNN_ia64_install_dyn_reloc (abfd, NULL, got_sec,
3530                                         ia64_info->rel_got_sec,
3531                                         got_offset, dyn_r_type,
3532                                         dynindx, addend);
3533         }
3534     }
3535
3536   /* Return the address of the linkage table entry.  */
3537   value = (got_sec->output_section->vma
3538            + got_sec->output_offset
3539            + got_offset);
3540
3541   return value;
3542 }
3543
3544 /* Fill in a function descriptor consisting of the function's code
3545    address and its global pointer.  Return the descriptor's address.  */
3546
3547 static bfd_vma
3548 set_fptr_entry (abfd, info, dyn_i, value)
3549      bfd *abfd;
3550      struct bfd_link_info *info;
3551      struct elfNN_ia64_dyn_sym_info *dyn_i;
3552      bfd_vma value;
3553 {
3554   struct elfNN_ia64_link_hash_table *ia64_info;
3555   asection *fptr_sec;
3556
3557   ia64_info = elfNN_ia64_hash_table (info);
3558   fptr_sec = ia64_info->fptr_sec;
3559
3560   if (!dyn_i->fptr_done)
3561     {
3562       dyn_i->fptr_done = 1;
3563
3564       /* Fill in the function descriptor.  */
3565       bfd_put_64 (abfd, value, fptr_sec->contents + dyn_i->fptr_offset);
3566       bfd_put_64 (abfd, _bfd_get_gp_value (abfd),
3567                   fptr_sec->contents + dyn_i->fptr_offset + 8);
3568       if (ia64_info->rel_fptr_sec)
3569         {
3570           Elf_Internal_Rela outrel;
3571           bfd_byte *loc;
3572
3573           if (bfd_little_endian (abfd))
3574             outrel.r_info = ELFNN_R_INFO (0, R_IA64_IPLTLSB);
3575           else
3576             outrel.r_info = ELFNN_R_INFO (0, R_IA64_IPLTMSB);
3577           outrel.r_addend = value;
3578           outrel.r_offset = (fptr_sec->output_section->vma
3579                              + fptr_sec->output_offset
3580                              + dyn_i->fptr_offset);
3581           loc = ia64_info->rel_fptr_sec->contents;
3582           loc += ia64_info->rel_fptr_sec->reloc_count++
3583                  * sizeof (ElfNN_External_Rela);
3584           bfd_elfNN_swap_reloca_out (abfd, &outrel, loc);
3585         }
3586     }
3587
3588   /* Return the descriptor's address.  */
3589   value = (fptr_sec->output_section->vma
3590            + fptr_sec->output_offset
3591            + dyn_i->fptr_offset);
3592
3593   return value;
3594 }
3595
3596 /* Fill in a PLTOFF entry consisting of the function's code address
3597    and its global pointer.  Return the descriptor's address.  */
3598
3599 static bfd_vma
3600 set_pltoff_entry (abfd, info, dyn_i, value, is_plt)
3601      bfd *abfd;
3602      struct bfd_link_info *info;
3603      struct elfNN_ia64_dyn_sym_info *dyn_i;
3604      bfd_vma value;
3605      bfd_boolean is_plt;
3606 {
3607   struct elfNN_ia64_link_hash_table *ia64_info;
3608   asection *pltoff_sec;
3609
3610   ia64_info = elfNN_ia64_hash_table (info);
3611   pltoff_sec = ia64_info->pltoff_sec;
3612
3613   /* Don't do anything if this symbol uses a real PLT entry.  In
3614      that case, we'll fill this in during finish_dynamic_symbol.  */
3615   if ((! dyn_i->want_plt || is_plt)
3616       && !dyn_i->pltoff_done)
3617     {
3618       bfd_vma gp = _bfd_get_gp_value (abfd);
3619
3620       /* Fill in the function descriptor.  */
3621       bfd_put_64 (abfd, value, pltoff_sec->contents + dyn_i->pltoff_offset);
3622       bfd_put_64 (abfd, gp, pltoff_sec->contents + dyn_i->pltoff_offset + 8);
3623
3624       /* Install dynamic relocations if needed.  */
3625       if (!is_plt
3626           && info->shared
3627           && (!dyn_i->h
3628               || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
3629               || dyn_i->h->root.type != bfd_link_hash_undefweak))
3630         {
3631           unsigned int dyn_r_type;
3632
3633           if (bfd_big_endian (abfd))
3634             dyn_r_type = R_IA64_REL64MSB;
3635           else
3636             dyn_r_type = R_IA64_REL64LSB;
3637
3638           elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
3639                                         ia64_info->rel_pltoff_sec,
3640                                         dyn_i->pltoff_offset,
3641                                         dyn_r_type, 0, value);
3642           elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
3643                                         ia64_info->rel_pltoff_sec,
3644                                         dyn_i->pltoff_offset + 8,
3645                                         dyn_r_type, 0, gp);
3646         }
3647
3648       dyn_i->pltoff_done = 1;
3649     }
3650
3651   /* Return the descriptor's address.  */
3652   value = (pltoff_sec->output_section->vma
3653            + pltoff_sec->output_offset
3654            + dyn_i->pltoff_offset);
3655
3656   return value;
3657 }
3658
3659 /* Return the base VMA address which should be subtracted from real addresses
3660    when resolving @tprel() relocation.
3661    Main program TLS (whose template starts at PT_TLS p_vaddr)
3662    is assigned offset round(16, PT_TLS p_align).  */
3663
3664 static bfd_vma
3665 elfNN_ia64_tprel_base (info)
3666      struct bfd_link_info *info;
3667 {
3668   asection *tls_sec = elf_hash_table (info)->tls_sec;
3669
3670   BFD_ASSERT (tls_sec != NULL);
3671   return tls_sec->vma - align_power ((bfd_vma) 16, tls_sec->alignment_power);
3672 }
3673
3674 /* Return the base VMA address which should be subtracted from real addresses
3675    when resolving @dtprel() relocation.
3676    This is PT_TLS segment p_vaddr.  */
3677
3678 static bfd_vma
3679 elfNN_ia64_dtprel_base (info)
3680      struct bfd_link_info *info;
3681 {
3682   BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
3683   return elf_hash_table (info)->tls_sec->vma;
3684 }
3685
3686 /* Called through qsort to sort the .IA_64.unwind section during a
3687    non-relocatable link.  Set elfNN_ia64_unwind_entry_compare_bfd
3688    to the output bfd so we can do proper endianness frobbing.  */
3689
3690 static bfd *elfNN_ia64_unwind_entry_compare_bfd;
3691
3692 static int
3693 elfNN_ia64_unwind_entry_compare (a, b)
3694      const PTR a;
3695      const PTR b;
3696 {
3697   bfd_vma av, bv;
3698
3699   av = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, a);
3700   bv = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, b);
3701
3702   return (av < bv ? -1 : av > bv ? 1 : 0);
3703 }
3704
3705 /* Make sure we've got ourselves a nice fat __gp value.  */
3706 static bfd_boolean
3707 elfNN_ia64_choose_gp (abfd, info)
3708      bfd *abfd;
3709      struct bfd_link_info *info;
3710 {
3711   bfd_vma min_vma = (bfd_vma) -1, max_vma = 0;
3712   bfd_vma min_short_vma = min_vma, max_short_vma = 0;
3713   struct elf_link_hash_entry *gp;
3714   bfd_vma gp_val;
3715   asection *os;
3716   struct elfNN_ia64_link_hash_table *ia64_info;
3717
3718   ia64_info = elfNN_ia64_hash_table (info);
3719
3720   /* Find the min and max vma of all sections marked short.  Also collect
3721      min and max vma of any type, for use in selecting a nice gp.  */
3722   for (os = abfd->sections; os ; os = os->next)
3723     {
3724       bfd_vma lo, hi;
3725
3726       if ((os->flags & SEC_ALLOC) == 0)
3727         continue;
3728
3729       lo = os->vma;
3730       hi = os->vma + os->size;
3731       if (hi < lo)
3732         hi = (bfd_vma) -1;
3733
3734       if (min_vma > lo)
3735         min_vma = lo;
3736       if (max_vma < hi)
3737         max_vma = hi;
3738       if (os->flags & SEC_SMALL_DATA)
3739         {
3740           if (min_short_vma > lo)
3741             min_short_vma = lo;
3742           if (max_short_vma < hi)
3743             max_short_vma = hi;
3744         }
3745     }
3746
3747   /* See if the user wants to force a value.  */
3748   gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
3749                              FALSE, FALSE);
3750
3751   if (gp
3752       && (gp->root.type == bfd_link_hash_defined
3753           || gp->root.type == bfd_link_hash_defweak))
3754     {
3755       asection *gp_sec = gp->root.u.def.section;
3756       gp_val = (gp->root.u.def.value
3757                 + gp_sec->output_section->vma
3758                 + gp_sec->output_offset);
3759     }
3760   else
3761     {
3762       /* Pick a sensible value.  */
3763
3764       asection *got_sec = ia64_info->got_sec;
3765
3766       /* Start with just the address of the .got.  */
3767       if (got_sec)
3768         gp_val = got_sec->output_section->vma;
3769       else if (max_short_vma != 0)
3770         gp_val = min_short_vma;
3771       else
3772         gp_val = min_vma;
3773
3774       /* If it is possible to address the entire image, but we
3775          don't with the choice above, adjust.  */
3776       if (max_vma - min_vma < 0x400000
3777           && max_vma - gp_val <= 0x200000
3778           && gp_val - min_vma > 0x200000)
3779         gp_val = min_vma + 0x200000;
3780       else if (max_short_vma != 0)
3781         {
3782           /* If we don't cover all the short data, adjust.  */
3783           if (max_short_vma - gp_val >= 0x200000)
3784             gp_val = min_short_vma + 0x200000;
3785
3786           /* If we're addressing stuff past the end, adjust back.  */
3787           if (gp_val > max_vma)
3788             gp_val = max_vma - 0x200000 + 8;
3789         }
3790     }
3791
3792   /* Validate whether all SHF_IA_64_SHORT sections are within
3793      range of the chosen GP.  */
3794
3795   if (max_short_vma != 0)
3796     {
3797       if (max_short_vma - min_short_vma >= 0x400000)
3798         {
3799           (*_bfd_error_handler)
3800             (_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
3801              bfd_get_filename (abfd),
3802              (unsigned long) (max_short_vma - min_short_vma));
3803           return FALSE;
3804         }
3805       else if ((gp_val > min_short_vma
3806                 && gp_val - min_short_vma > 0x200000)
3807                || (gp_val < max_short_vma
3808                    && max_short_vma - gp_val >= 0x200000))
3809         {
3810           (*_bfd_error_handler)
3811             (_("%s: __gp does not cover short data segment"),
3812              bfd_get_filename (abfd));
3813           return FALSE;
3814         }
3815     }
3816
3817   _bfd_set_gp_value (abfd, gp_val);
3818
3819   return TRUE;
3820 }
3821
3822 static bfd_boolean
3823 elfNN_ia64_final_link (abfd, info)
3824      bfd *abfd;
3825      struct bfd_link_info *info;
3826 {
3827   struct elfNN_ia64_link_hash_table *ia64_info;
3828   asection *unwind_output_sec;
3829
3830   ia64_info = elfNN_ia64_hash_table (info);
3831
3832   /* Make sure we've got ourselves a nice fat __gp value.  */
3833   if (!info->relocatable)
3834     {
3835       bfd_vma gp_val = _bfd_get_gp_value (abfd);
3836       struct elf_link_hash_entry *gp;
3837
3838       if (gp_val == 0)
3839         {
3840           if (! elfNN_ia64_choose_gp (abfd, info))
3841             return FALSE;
3842           gp_val = _bfd_get_gp_value (abfd);
3843         }
3844
3845       gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
3846                                  FALSE, FALSE);
3847       if (gp)
3848         {
3849           gp->root.type = bfd_link_hash_defined;
3850           gp->root.u.def.value = gp_val;
3851           gp->root.u.def.section = bfd_abs_section_ptr;
3852         }
3853     }
3854
3855   /* If we're producing a final executable, we need to sort the contents
3856      of the .IA_64.unwind section.  Force this section to be relocated
3857      into memory rather than written immediately to the output file.  */
3858   unwind_output_sec = NULL;
3859   if (!info->relocatable)
3860     {
3861       asection *s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind);
3862       if (s)
3863         {
3864           unwind_output_sec = s->output_section;
3865           unwind_output_sec->contents
3866             = bfd_malloc (unwind_output_sec->size);
3867           if (unwind_output_sec->contents == NULL)
3868             return FALSE;
3869         }
3870     }
3871
3872   /* Invoke the regular ELF backend linker to do all the work.  */
3873   if (!bfd_elf_final_link (abfd, info))
3874     return FALSE;
3875
3876   if (unwind_output_sec)
3877     {
3878       elfNN_ia64_unwind_entry_compare_bfd = abfd;
3879       qsort (unwind_output_sec->contents,
3880              (size_t) (unwind_output_sec->size / 24),
3881              24,
3882              elfNN_ia64_unwind_entry_compare);
3883
3884       if (! bfd_set_section_contents (abfd, unwind_output_sec,
3885                                       unwind_output_sec->contents, (bfd_vma) 0,
3886                                       unwind_output_sec->size))
3887         return FALSE;
3888     }
3889
3890   return TRUE;
3891 }
3892
3893 static bfd_boolean
3894 elfNN_ia64_relocate_section (output_bfd, info, input_bfd, input_section,
3895                              contents, relocs, local_syms, local_sections)
3896      bfd *output_bfd;
3897      struct bfd_link_info *info;
3898      bfd *input_bfd;
3899      asection *input_section;
3900      bfd_byte *contents;
3901      Elf_Internal_Rela *relocs;
3902      Elf_Internal_Sym *local_syms;
3903      asection **local_sections;
3904 {
3905   struct elfNN_ia64_link_hash_table *ia64_info;
3906   Elf_Internal_Shdr *symtab_hdr;
3907   Elf_Internal_Rela *rel;
3908   Elf_Internal_Rela *relend;
3909   asection *srel;
3910   bfd_boolean ret_val = TRUE;   /* for non-fatal errors */
3911   bfd_vma gp_val;
3912
3913   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3914   ia64_info = elfNN_ia64_hash_table (info);
3915
3916   /* Infect various flags from the input section to the output section.  */
3917   if (info->relocatable)
3918     {
3919       bfd_vma flags;
3920
3921       flags = elf_section_data(input_section)->this_hdr.sh_flags;
3922       flags &= SHF_IA_64_NORECOV;
3923
3924       elf_section_data(input_section->output_section)
3925         ->this_hdr.sh_flags |= flags;
3926       return TRUE;
3927     }
3928
3929   gp_val = _bfd_get_gp_value (output_bfd);
3930   srel = get_reloc_section (input_bfd, ia64_info, input_section, FALSE);
3931
3932   rel = relocs;
3933   relend = relocs + input_section->reloc_count;
3934   for (; rel < relend; ++rel)
3935     {
3936       struct elf_link_hash_entry *h;
3937       struct elfNN_ia64_dyn_sym_info *dyn_i;
3938       bfd_reloc_status_type r;
3939       reloc_howto_type *howto;
3940       unsigned long r_symndx;
3941       Elf_Internal_Sym *sym;
3942       unsigned int r_type;
3943       bfd_vma value;
3944       asection *sym_sec;
3945       bfd_byte *hit_addr;
3946       bfd_boolean dynamic_symbol_p;
3947       bfd_boolean undef_weak_ref;
3948
3949       r_type = ELFNN_R_TYPE (rel->r_info);
3950       if (r_type > R_IA64_MAX_RELOC_CODE)
3951         {
3952           (*_bfd_error_handler)
3953             (_("%s: unknown relocation type %d"),
3954              bfd_archive_filename (input_bfd), (int)r_type);
3955           bfd_set_error (bfd_error_bad_value);
3956           ret_val = FALSE;
3957           continue;
3958         }
3959
3960       howto = lookup_howto (r_type);
3961       r_symndx = ELFNN_R_SYM (rel->r_info);
3962       h = NULL;
3963       sym = NULL;
3964       sym_sec = NULL;
3965       undef_weak_ref = FALSE;
3966
3967       if (r_symndx < symtab_hdr->sh_info)
3968         {
3969           /* Reloc against local symbol.  */
3970           asection *msec;
3971           sym = local_syms + r_symndx;
3972           sym_sec = local_sections[r_symndx];
3973           msec = sym_sec;
3974           value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
3975           if ((sym_sec->flags & SEC_MERGE)
3976               && ELF_ST_TYPE (sym->st_info) == STT_SECTION
3977               && sym_sec->sec_info_type == ELF_INFO_TYPE_MERGE)
3978             {
3979               struct elfNN_ia64_local_hash_entry *loc_h;
3980
3981               loc_h = get_local_sym_hash (ia64_info, input_bfd, rel, FALSE);
3982               if (loc_h && ! loc_h->sec_merge_done)
3983                 {
3984                   struct elfNN_ia64_dyn_sym_info *dynent;
3985
3986                   for (dynent = loc_h->info; dynent; dynent = dynent->next)
3987                     {
3988                       msec = sym_sec;
3989                       dynent->addend =
3990                         _bfd_merged_section_offset (output_bfd, &msec,
3991                                                     elf_section_data (msec)->
3992                                                     sec_info,
3993                                                     sym->st_value
3994                                                     + dynent->addend);
3995                       dynent->addend -= sym->st_value;
3996                       dynent->addend += msec->output_section->vma
3997                                         + msec->output_offset
3998                                         - sym_sec->output_section->vma
3999                                         - sym_sec->output_offset;
4000                     }
4001                   loc_h->sec_merge_done = 1;
4002                 }
4003             }
4004         }
4005       else
4006         {
4007           bfd_boolean unresolved_reloc;
4008           bfd_boolean warned;
4009           struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
4010
4011           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4012                                    r_symndx, symtab_hdr, sym_hashes,
4013                                    h, sym_sec, value,
4014                                    unresolved_reloc, warned);
4015
4016           if (h->root.type == bfd_link_hash_undefweak)
4017             undef_weak_ref = TRUE;
4018           else if (warned)
4019             continue;
4020         }
4021
4022       hit_addr = contents + rel->r_offset;
4023       value += rel->r_addend;
4024       dynamic_symbol_p = elfNN_ia64_dynamic_symbol_p (h, info, r_type);
4025
4026       switch (r_type)
4027         {
4028         case R_IA64_NONE:
4029         case R_IA64_LDXMOV:
4030           continue;
4031
4032         case R_IA64_IMM14:
4033         case R_IA64_IMM22:
4034         case R_IA64_IMM64:
4035         case R_IA64_DIR32MSB:
4036         case R_IA64_DIR32LSB:
4037         case R_IA64_DIR64MSB:
4038         case R_IA64_DIR64LSB:
4039           /* Install a dynamic relocation for this reloc.  */
4040           if ((dynamic_symbol_p || info->shared)
4041               && r_symndx != 0
4042               && (input_section->flags & SEC_ALLOC) != 0)
4043             {
4044               unsigned int dyn_r_type;
4045               long dynindx;
4046               bfd_vma addend;
4047
4048               BFD_ASSERT (srel != NULL);
4049
4050               switch (r_type)
4051                 {
4052                 case R_IA64_IMM14:
4053                 case R_IA64_IMM22:
4054                 case R_IA64_IMM64:
4055                   /* ??? People shouldn't be doing non-pic code in
4056                      shared libraries nor dynamic executables.  */
4057                   (*_bfd_error_handler)
4058                     (_("%s: non-pic code with imm relocation against dynamic symbol `%s'"),
4059                      bfd_archive_filename (input_bfd),
4060                      h->root.root.string);
4061                   ret_val = FALSE;
4062                   continue;
4063
4064                 default:
4065                   break;
4066                 }
4067
4068               /* If we don't need dynamic symbol lookup, find a
4069                  matching RELATIVE relocation.  */
4070               dyn_r_type = r_type;
4071               if (dynamic_symbol_p)
4072                 {
4073                   dynindx = h->dynindx;
4074                   addend = rel->r_addend;
4075                   value = 0;
4076                 }
4077               else
4078                 {
4079                   switch (r_type)
4080                     {
4081                     case R_IA64_DIR32MSB:
4082                       dyn_r_type = R_IA64_REL32MSB;
4083                       break;
4084                     case R_IA64_DIR32LSB:
4085                       dyn_r_type = R_IA64_REL32LSB;
4086                       break;
4087                     case R_IA64_DIR64MSB:
4088                       dyn_r_type = R_IA64_REL64MSB;
4089                       break;
4090                     case R_IA64_DIR64LSB:
4091                       dyn_r_type = R_IA64_REL64LSB;
4092                       break;
4093
4094                     default:
4095                       break;
4096                     }
4097                   dynindx = 0;
4098                   addend = value;
4099                 }
4100
4101               elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4102                                             srel, rel->r_offset, dyn_r_type,
4103                                             dynindx, addend);
4104             }
4105           /* Fall through.  */
4106
4107         case R_IA64_LTV32MSB:
4108         case R_IA64_LTV32LSB:
4109         case R_IA64_LTV64MSB:
4110         case R_IA64_LTV64LSB:
4111           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4112           break;
4113
4114         case R_IA64_GPREL22:
4115         case R_IA64_GPREL64I:
4116         case R_IA64_GPREL32MSB:
4117         case R_IA64_GPREL32LSB:
4118         case R_IA64_GPREL64MSB:
4119         case R_IA64_GPREL64LSB:
4120           if (dynamic_symbol_p)
4121             {
4122               (*_bfd_error_handler)
4123                 (_("%s: @gprel relocation against dynamic symbol %s"),
4124                  bfd_archive_filename (input_bfd), h->root.root.string);
4125               ret_val = FALSE;
4126               continue;
4127             }
4128           value -= gp_val;
4129           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4130           break;
4131
4132         case R_IA64_LTOFF22:
4133         case R_IA64_LTOFF22X:
4134         case R_IA64_LTOFF64I:
4135           dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4136           value = set_got_entry (input_bfd, info, dyn_i, (h ? h->dynindx : -1),
4137                                  rel->r_addend, value, R_IA64_DIR64LSB);
4138           value -= gp_val;
4139           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4140           break;
4141
4142         case R_IA64_PLTOFF22:
4143         case R_IA64_PLTOFF64I:
4144         case R_IA64_PLTOFF64MSB:
4145         case R_IA64_PLTOFF64LSB:
4146           dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4147           value = set_pltoff_entry (output_bfd, info, dyn_i, value, FALSE);
4148           value -= gp_val;
4149           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4150           break;
4151
4152         case R_IA64_FPTR64I:
4153         case R_IA64_FPTR32MSB:
4154         case R_IA64_FPTR32LSB:
4155         case R_IA64_FPTR64MSB:
4156         case R_IA64_FPTR64LSB:
4157           dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4158           if (dyn_i->want_fptr)
4159             {
4160               if (!undef_weak_ref)
4161                 value = set_fptr_entry (output_bfd, info, dyn_i, value);
4162             }
4163           if (!dyn_i->want_fptr || info->pie)
4164             {
4165               long dynindx;
4166               unsigned int dyn_r_type = r_type;
4167               bfd_vma addend = rel->r_addend;
4168
4169               /* Otherwise, we expect the dynamic linker to create
4170                  the entry.  */
4171
4172               if (dyn_i->want_fptr)
4173                 {
4174                   if (r_type == R_IA64_FPTR64I)
4175                     {
4176                       /* We can't represent this without a dynamic symbol.
4177                          Adjust the relocation to be against an output
4178                          section symbol, which are always present in the
4179                          dynamic symbol table.  */
4180                       /* ??? People shouldn't be doing non-pic code in
4181                          shared libraries.  Hork.  */
4182                       (*_bfd_error_handler)
4183                         (_("%s: linking non-pic code in a position independent executable"),
4184                          bfd_archive_filename (input_bfd));
4185                       ret_val = FALSE;
4186                       continue;
4187                     }
4188                   dynindx = 0;
4189                   addend = value;
4190                   dyn_r_type = r_type + R_IA64_REL64LSB - R_IA64_FPTR64LSB;
4191                 }
4192               else if (h)
4193                 {
4194                   if (h->dynindx != -1)
4195                     dynindx = h->dynindx;
4196                   else
4197                     dynindx = (_bfd_elf_link_lookup_local_dynindx
4198                                (info, h->root.u.def.section->owner,
4199                                 global_sym_index (h)));
4200                   value = 0;
4201                 }
4202               else
4203                 {
4204                   dynindx = (_bfd_elf_link_lookup_local_dynindx
4205                              (info, input_bfd, (long) r_symndx));
4206                   value = 0;
4207                 }
4208
4209               elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4210                                             srel, rel->r_offset, dyn_r_type,
4211                                             dynindx, addend);
4212             }
4213
4214           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4215           break;
4216
4217         case R_IA64_LTOFF_FPTR22:
4218         case R_IA64_LTOFF_FPTR64I:
4219         case R_IA64_LTOFF_FPTR32MSB:
4220         case R_IA64_LTOFF_FPTR32LSB:
4221         case R_IA64_LTOFF_FPTR64MSB:
4222         case R_IA64_LTOFF_FPTR64LSB:
4223           {
4224             long dynindx;
4225
4226             dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4227             if (dyn_i->want_fptr)
4228               {
4229                 BFD_ASSERT (h == NULL || h->dynindx == -1)
4230                 if (!undef_weak_ref)
4231                   value = set_fptr_entry (output_bfd, info, dyn_i, value);
4232                 dynindx = -1;
4233               }
4234             else
4235               {
4236                 /* Otherwise, we expect the dynamic linker to create
4237                    the entry.  */
4238                 if (h)
4239                   {
4240                     if (h->dynindx != -1)
4241                       dynindx = h->dynindx;
4242                     else
4243                       dynindx = (_bfd_elf_link_lookup_local_dynindx
4244                                  (info, h->root.u.def.section->owner,
4245                                   global_sym_index (h)));
4246                   }
4247                 else
4248                   dynindx = (_bfd_elf_link_lookup_local_dynindx
4249                              (info, input_bfd, (long) r_symndx));
4250                 value = 0;
4251               }
4252
4253             value = set_got_entry (output_bfd, info, dyn_i, dynindx,
4254                                    rel->r_addend, value, R_IA64_FPTR64LSB);
4255             value -= gp_val;
4256             r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4257           }
4258           break;
4259
4260         case R_IA64_PCREL32MSB:
4261         case R_IA64_PCREL32LSB:
4262         case R_IA64_PCREL64MSB:
4263         case R_IA64_PCREL64LSB:
4264           /* Install a dynamic relocation for this reloc.  */
4265           if (dynamic_symbol_p && r_symndx != 0)
4266             {
4267               BFD_ASSERT (srel != NULL);
4268
4269               elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4270                                             srel, rel->r_offset, r_type,
4271                                             h->dynindx, rel->r_addend);
4272             }
4273           goto finish_pcrel;
4274
4275         case R_IA64_PCREL21B:
4276         case R_IA64_PCREL60B:
4277           /* We should have created a PLT entry for any dynamic symbol.  */
4278           dyn_i = NULL;
4279           if (h)
4280             dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE);
4281
4282           if (dyn_i && dyn_i->want_plt2)
4283             {
4284               /* Should have caught this earlier.  */
4285               BFD_ASSERT (rel->r_addend == 0);
4286
4287               value = (ia64_info->plt_sec->output_section->vma
4288                        + ia64_info->plt_sec->output_offset
4289                        + dyn_i->plt2_offset);
4290             }
4291           else
4292             {
4293               /* Since there's no PLT entry, Validate that this is
4294                  locally defined.  */
4295               BFD_ASSERT (undef_weak_ref || sym_sec->output_section != NULL);
4296
4297               /* If the symbol is undef_weak, we shouldn't be trying
4298                  to call it.  There's every chance that we'd wind up
4299                  with an out-of-range fixup here.  Don't bother setting
4300                  any value at all.  */
4301               if (undef_weak_ref)
4302                 continue;
4303             }
4304           goto finish_pcrel;
4305
4306         case R_IA64_PCREL21BI:
4307         case R_IA64_PCREL21F:
4308         case R_IA64_PCREL21M:
4309         case R_IA64_PCREL22:
4310         case R_IA64_PCREL64I:
4311           /* The PCREL21BI reloc is specifically not intended for use with
4312              dynamic relocs.  PCREL21F and PCREL21M are used for speculation
4313              fixup code, and thus probably ought not be dynamic.  The
4314              PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs.  */
4315           if (dynamic_symbol_p)
4316             {
4317               const char *msg;
4318
4319               if (r_type == R_IA64_PCREL21BI)
4320                 msg = _("%s: @internal branch to dynamic symbol %s");
4321               else if (r_type == R_IA64_PCREL21F || r_type == R_IA64_PCREL21M)
4322                 msg = _("%s: speculation fixup to dynamic symbol %s");
4323               else
4324                 msg = _("%s: @pcrel relocation against dynamic symbol %s");
4325               (*_bfd_error_handler) (msg, bfd_archive_filename (input_bfd),
4326                                      h->root.root.string);
4327               ret_val = FALSE;
4328               continue;
4329             }
4330           goto finish_pcrel;
4331
4332         finish_pcrel:
4333           /* Make pc-relative.  */
4334           value -= (input_section->output_section->vma
4335                     + input_section->output_offset
4336                     + rel->r_offset) & ~ (bfd_vma) 0x3;
4337           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4338           break;
4339
4340         case R_IA64_SEGREL32MSB:
4341         case R_IA64_SEGREL32LSB:
4342         case R_IA64_SEGREL64MSB:
4343         case R_IA64_SEGREL64LSB:
4344           if (r_symndx == 0)
4345             {
4346               /* If the input section was discarded from the output, then
4347                  do nothing.  */
4348               r = bfd_reloc_ok;
4349             }
4350           else
4351             {
4352               struct elf_segment_map *m;
4353               Elf_Internal_Phdr *p;
4354
4355               /* Find the segment that contains the output_section.  */
4356               for (m = elf_tdata (output_bfd)->segment_map,
4357                      p = elf_tdata (output_bfd)->phdr;
4358                    m != NULL;
4359                    m = m->next, p++)
4360                 {
4361                   int i;
4362                   for (i = m->count - 1; i >= 0; i--)
4363                     if (m->sections[i] == input_section->output_section)
4364                       break;
4365                   if (i >= 0)
4366                     break;
4367                 }
4368
4369               if (m == NULL)
4370                 {
4371                   r = bfd_reloc_notsupported;
4372                 }
4373               else
4374                 {
4375                   /* The VMA of the segment is the vaddr of the associated
4376                      program header.  */
4377                   if (value > p->p_vaddr)
4378                     value -= p->p_vaddr;
4379                   else
4380                     value = 0;
4381                   r = elfNN_ia64_install_value (output_bfd, hit_addr, value,
4382                                                 r_type);
4383                 }
4384               break;
4385             }
4386
4387         case R_IA64_SECREL32MSB:
4388         case R_IA64_SECREL32LSB:
4389         case R_IA64_SECREL64MSB:
4390         case R_IA64_SECREL64LSB:
4391           /* Make output-section relative.  */
4392           if (value > input_section->output_section->vma)
4393             value -= input_section->output_section->vma;
4394           else
4395             value = 0;
4396           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4397           break;
4398
4399         case R_IA64_IPLTMSB:
4400         case R_IA64_IPLTLSB:
4401           /* Install a dynamic relocation for this reloc.  */
4402           if ((dynamic_symbol_p || info->shared)
4403               && (input_section->flags & SEC_ALLOC) != 0)
4404             {
4405               BFD_ASSERT (srel != NULL);
4406
4407               /* If we don't need dynamic symbol lookup, install two
4408                  RELATIVE relocations.  */
4409               if (!dynamic_symbol_p)
4410                 {
4411                   unsigned int dyn_r_type;
4412
4413                   if (r_type == R_IA64_IPLTMSB)
4414                     dyn_r_type = R_IA64_REL64MSB;
4415                   else
4416                     dyn_r_type = R_IA64_REL64LSB;
4417
4418                   elfNN_ia64_install_dyn_reloc (output_bfd, info,
4419                                                 input_section,
4420                                                 srel, rel->r_offset,
4421                                                 dyn_r_type, 0, value);
4422                   elfNN_ia64_install_dyn_reloc (output_bfd, info,
4423                                                 input_section,
4424                                                 srel, rel->r_offset + 8,
4425                                                 dyn_r_type, 0, gp_val);
4426                 }
4427               else
4428                 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4429                                               srel, rel->r_offset, r_type,
4430                                               h->dynindx, rel->r_addend);
4431             }
4432
4433           if (r_type == R_IA64_IPLTMSB)
4434             r_type = R_IA64_DIR64MSB;
4435           else
4436             r_type = R_IA64_DIR64LSB;
4437           elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4438           r = elfNN_ia64_install_value (output_bfd, hit_addr + 8, gp_val,
4439                                         r_type);
4440           break;
4441
4442         case R_IA64_TPREL14:
4443         case R_IA64_TPREL22:
4444         case R_IA64_TPREL64I:
4445           value -= elfNN_ia64_tprel_base (info);
4446           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4447           break;
4448
4449         case R_IA64_DTPREL14:
4450         case R_IA64_DTPREL22:
4451         case R_IA64_DTPREL64I:
4452         case R_IA64_DTPREL64LSB:
4453         case R_IA64_DTPREL64MSB:
4454           value -= elfNN_ia64_dtprel_base (info);
4455           r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4456           break;
4457
4458         case R_IA64_LTOFF_TPREL22:
4459         case R_IA64_LTOFF_DTPMOD22:
4460         case R_IA64_LTOFF_DTPREL22:
4461           {
4462             int got_r_type;
4463             long dynindx = h ? h->dynindx : -1;
4464             bfd_vma r_addend = rel->r_addend;
4465
4466             switch (r_type)
4467               {
4468               default:
4469               case R_IA64_LTOFF_TPREL22:
4470                 if (!dynamic_symbol_p)
4471                   {
4472                     if (!info->shared)
4473                       value -= elfNN_ia64_tprel_base (info);
4474                     else
4475                       {
4476                         r_addend += value - elfNN_ia64_dtprel_base (info);
4477                         dynindx = 0;
4478                       }
4479                   }
4480                 got_r_type = R_IA64_TPREL64LSB;
4481                 break;
4482               case R_IA64_LTOFF_DTPMOD22:
4483                 if (!dynamic_symbol_p && !info->shared)
4484                   value = 1;
4485                 got_r_type = R_IA64_DTPMOD64LSB;
4486                 break;
4487               case R_IA64_LTOFF_DTPREL22:
4488                 if (!dynamic_symbol_p)
4489                   value -= elfNN_ia64_dtprel_base (info);
4490                 got_r_type = R_IA64_DTPREL64LSB;
4491                 break;
4492               }
4493             dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4494             value = set_got_entry (input_bfd, info, dyn_i, dynindx, r_addend,
4495                                    value, got_r_type);
4496             value -= gp_val;
4497             r = elfNN_ia64_install_value (output_bfd, hit_addr, value,
4498                                           r_type);
4499           }
4500           break;
4501
4502         default:
4503           r = bfd_reloc_notsupported;
4504           break;
4505         }
4506
4507       switch (r)
4508         {
4509         case bfd_reloc_ok:
4510           break;
4511
4512         case bfd_reloc_undefined:
4513           /* This can happen for global table relative relocs if
4514              __gp is undefined.  This is a panic situation so we
4515              don't try to continue.  */
4516           (*info->callbacks->undefined_symbol)
4517             (info, "__gp", input_bfd, input_section, rel->r_offset, 1);
4518           return FALSE;
4519
4520         case bfd_reloc_notsupported:
4521           {
4522             const char *name;
4523
4524             if (h)
4525               name = h->root.root.string;
4526             else
4527               {
4528                 name = bfd_elf_string_from_elf_section (input_bfd,
4529                                                         symtab_hdr->sh_link,
4530                                                         sym->st_name);
4531                 if (name == NULL)
4532                   return FALSE;
4533                 if (*name == '\0')
4534                   name = bfd_section_name (input_bfd, input_section);
4535               }
4536             if (!(*info->callbacks->warning) (info, _("unsupported reloc"),
4537                                               name, input_bfd,
4538                                               input_section, rel->r_offset))
4539               return FALSE;
4540             ret_val = FALSE;
4541           }
4542           break;
4543
4544         case bfd_reloc_dangerous:
4545         case bfd_reloc_outofrange:
4546         case bfd_reloc_overflow:
4547         default:
4548           {
4549             const char *name;
4550
4551             if (h)
4552               name = h->root.root.string;
4553             else
4554               {
4555                 name = bfd_elf_string_from_elf_section (input_bfd,
4556                                                         symtab_hdr->sh_link,
4557                                                         sym->st_name);
4558                 if (name == NULL)
4559                   return FALSE;
4560                 if (*name == '\0')
4561                   name = bfd_section_name (input_bfd, input_section);
4562               }
4563             if (!(*info->callbacks->reloc_overflow) (info, name,
4564                                                      howto->name,
4565                                                      (bfd_vma) 0,
4566                                                      input_bfd,
4567                                                      input_section,
4568                                                      rel->r_offset))
4569               return FALSE;
4570             ret_val = FALSE;
4571           }
4572           break;
4573         }
4574     }
4575
4576   return ret_val;
4577 }
4578
4579 static bfd_boolean
4580 elfNN_ia64_finish_dynamic_symbol (output_bfd, info, h, sym)
4581      bfd *output_bfd;
4582      struct bfd_link_info *info;
4583      struct elf_link_hash_entry *h;
4584      Elf_Internal_Sym *sym;
4585 {
4586   struct elfNN_ia64_link_hash_table *ia64_info;
4587   struct elfNN_ia64_dyn_sym_info *dyn_i;
4588
4589   ia64_info = elfNN_ia64_hash_table (info);
4590   dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE);
4591
4592   /* Fill in the PLT data, if required.  */
4593   if (dyn_i && dyn_i->want_plt)
4594     {
4595       Elf_Internal_Rela outrel;
4596       bfd_byte *loc;
4597       asection *plt_sec;
4598       bfd_vma plt_addr, pltoff_addr, gp_val, index;
4599
4600       gp_val = _bfd_get_gp_value (output_bfd);
4601
4602       /* Initialize the minimal PLT entry.  */
4603
4604       index = (dyn_i->plt_offset - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
4605       plt_sec = ia64_info->plt_sec;
4606       loc = plt_sec->contents + dyn_i->plt_offset;
4607
4608       memcpy (loc, plt_min_entry, PLT_MIN_ENTRY_SIZE);
4609       elfNN_ia64_install_value (output_bfd, loc, index, R_IA64_IMM22);
4610       elfNN_ia64_install_value (output_bfd, loc+2, -dyn_i->plt_offset,
4611                                 R_IA64_PCREL21B);
4612
4613       plt_addr = (plt_sec->output_section->vma
4614                   + plt_sec->output_offset
4615                   + dyn_i->plt_offset);
4616       pltoff_addr = set_pltoff_entry (output_bfd, info, dyn_i, plt_addr, TRUE);
4617
4618       /* Initialize the FULL PLT entry, if needed.  */
4619       if (dyn_i->want_plt2)
4620         {
4621           loc = plt_sec->contents + dyn_i->plt2_offset;
4622
4623           memcpy (loc, plt_full_entry, PLT_FULL_ENTRY_SIZE);
4624           elfNN_ia64_install_value (output_bfd, loc, pltoff_addr - gp_val,
4625                                     R_IA64_IMM22);
4626
4627           /* Mark the symbol as undefined, rather than as defined in the
4628              plt section.  Leave the value alone.  */
4629           /* ??? We didn't redefine it in adjust_dynamic_symbol in the
4630              first place.  But perhaps elflink.c did some for us.  */
4631           if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4632             sym->st_shndx = SHN_UNDEF;
4633         }
4634
4635       /* Create the dynamic relocation.  */
4636       outrel.r_offset = pltoff_addr;
4637       if (bfd_little_endian (output_bfd))
4638         outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTLSB);
4639       else
4640         outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTMSB);
4641       outrel.r_addend = 0;
4642
4643       /* This is fun.  In the .IA_64.pltoff section, we've got entries
4644          that correspond both to real PLT entries, and those that
4645          happened to resolve to local symbols but need to be created
4646          to satisfy @pltoff relocations.  The .rela.IA_64.pltoff
4647          relocations for the real PLT should come at the end of the
4648          section, so that they can be indexed by plt entry at runtime.
4649
4650          We emitted all of the relocations for the non-PLT @pltoff
4651          entries during relocate_section.  So we can consider the
4652          existing sec->reloc_count to be the base of the array of
4653          PLT relocations.  */
4654
4655       loc = ia64_info->rel_pltoff_sec->contents;
4656       loc += ((ia64_info->rel_pltoff_sec->reloc_count + index)
4657               * sizeof (ElfNN_External_Rela));
4658       bfd_elfNN_swap_reloca_out (output_bfd, &outrel, loc);
4659     }
4660
4661   /* Mark some specially defined symbols as absolute.  */
4662   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
4663       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
4664       || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
4665     sym->st_shndx = SHN_ABS;
4666
4667   return TRUE;
4668 }
4669
4670 static bfd_boolean
4671 elfNN_ia64_finish_dynamic_sections (abfd, info)
4672      bfd *abfd;
4673      struct bfd_link_info *info;
4674 {
4675   struct elfNN_ia64_link_hash_table *ia64_info;
4676   bfd *dynobj;
4677
4678   ia64_info = elfNN_ia64_hash_table (info);
4679   dynobj = ia64_info->root.dynobj;
4680
4681   if (elf_hash_table (info)->dynamic_sections_created)
4682     {
4683       ElfNN_External_Dyn *dyncon, *dynconend;
4684       asection *sdyn, *sgotplt;
4685       bfd_vma gp_val;
4686
4687       sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4688       sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
4689       BFD_ASSERT (sdyn != NULL);
4690       dyncon = (ElfNN_External_Dyn *) sdyn->contents;
4691       dynconend = (ElfNN_External_Dyn *) (sdyn->contents + sdyn->size);
4692
4693       gp_val = _bfd_get_gp_value (abfd);
4694
4695       for (; dyncon < dynconend; dyncon++)
4696         {
4697           Elf_Internal_Dyn dyn;
4698
4699           bfd_elfNN_swap_dyn_in (dynobj, dyncon, &dyn);
4700
4701           switch (dyn.d_tag)
4702             {
4703             case DT_PLTGOT:
4704               dyn.d_un.d_ptr = gp_val;
4705               break;
4706
4707             case DT_PLTRELSZ:
4708               dyn.d_un.d_val = (ia64_info->minplt_entries
4709                                 * sizeof (ElfNN_External_Rela));
4710               break;
4711
4712             case DT_JMPREL:
4713               /* See the comment above in finish_dynamic_symbol.  */
4714               dyn.d_un.d_ptr = (ia64_info->rel_pltoff_sec->output_section->vma
4715                                 + ia64_info->rel_pltoff_sec->output_offset
4716                                 + (ia64_info->rel_pltoff_sec->reloc_count
4717                                    * sizeof (ElfNN_External_Rela)));
4718               break;
4719
4720             case DT_IA_64_PLT_RESERVE:
4721               dyn.d_un.d_ptr = (sgotplt->output_section->vma
4722                                 + sgotplt->output_offset);
4723               break;
4724
4725             case DT_RELASZ:
4726               /* Do not have RELASZ include JMPREL.  This makes things
4727                  easier on ld.so.  This is not what the rest of BFD set up.  */
4728               dyn.d_un.d_val -= (ia64_info->minplt_entries
4729                                  * sizeof (ElfNN_External_Rela));
4730               break;
4731             }
4732
4733           bfd_elfNN_swap_dyn_out (abfd, &dyn, dyncon);
4734         }
4735
4736       /* Initialize the PLT0 entry.  */
4737       if (ia64_info->plt_sec)
4738         {
4739           bfd_byte *loc = ia64_info->plt_sec->contents;
4740           bfd_vma pltres;
4741
4742           memcpy (loc, plt_header, PLT_HEADER_SIZE);
4743
4744           pltres = (sgotplt->output_section->vma
4745                     + sgotplt->output_offset
4746                     - gp_val);
4747
4748           elfNN_ia64_install_value (abfd, loc+1, pltres, R_IA64_GPREL22);
4749         }
4750     }
4751
4752   return TRUE;
4753 }
4754 \f
4755 /* ELF file flag handling:  */
4756
4757 /* Function to keep IA-64 specific file flags.  */
4758 static bfd_boolean
4759 elfNN_ia64_set_private_flags (abfd, flags)
4760      bfd *abfd;
4761      flagword flags;
4762 {
4763   BFD_ASSERT (!elf_flags_init (abfd)
4764               || elf_elfheader (abfd)->e_flags == flags);
4765
4766   elf_elfheader (abfd)->e_flags = flags;
4767   elf_flags_init (abfd) = TRUE;
4768   return TRUE;
4769 }
4770
4771 /* Merge backend specific data from an object file to the output
4772    object file when linking.  */
4773 static bfd_boolean
4774 elfNN_ia64_merge_private_bfd_data (ibfd, obfd)
4775      bfd *ibfd, *obfd;
4776 {
4777   flagword out_flags;
4778   flagword in_flags;
4779   bfd_boolean ok = TRUE;
4780
4781   /* Don't even pretend to support mixed-format linking.  */
4782   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4783       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4784     return FALSE;
4785
4786   in_flags  = elf_elfheader (ibfd)->e_flags;
4787   out_flags = elf_elfheader (obfd)->e_flags;
4788
4789   if (! elf_flags_init (obfd))
4790     {
4791       elf_flags_init (obfd) = TRUE;
4792       elf_elfheader (obfd)->e_flags = in_flags;
4793
4794       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
4795           && bfd_get_arch_info (obfd)->the_default)
4796         {
4797           return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
4798                                     bfd_get_mach (ibfd));
4799         }
4800
4801       return TRUE;
4802     }
4803
4804   /* Check flag compatibility.  */
4805   if (in_flags == out_flags)
4806     return TRUE;
4807
4808   /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set.  */
4809   if (!(in_flags & EF_IA_64_REDUCEDFP) && (out_flags & EF_IA_64_REDUCEDFP))
4810     elf_elfheader (obfd)->e_flags &= ~EF_IA_64_REDUCEDFP;
4811
4812   if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL))
4813     {
4814       (*_bfd_error_handler)
4815         (_("%s: linking trap-on-NULL-dereference with non-trapping files"),
4816          bfd_archive_filename (ibfd));
4817
4818       bfd_set_error (bfd_error_bad_value);
4819       ok = FALSE;
4820     }
4821   if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE))
4822     {
4823       (*_bfd_error_handler)
4824         (_("%s: linking big-endian files with little-endian files"),
4825          bfd_archive_filename (ibfd));
4826
4827       bfd_set_error (bfd_error_bad_value);
4828       ok = FALSE;
4829     }
4830   if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64))
4831     {
4832       (*_bfd_error_handler)
4833         (_("%s: linking 64-bit files with 32-bit files"),
4834          bfd_archive_filename (ibfd));
4835
4836       bfd_set_error (bfd_error_bad_value);
4837       ok = FALSE;
4838     }
4839   if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP))
4840     {
4841       (*_bfd_error_handler)
4842         (_("%s: linking constant-gp files with non-constant-gp files"),
4843          bfd_archive_filename (ibfd));
4844
4845       bfd_set_error (bfd_error_bad_value);
4846       ok = FALSE;
4847     }
4848   if ((in_flags & EF_IA_64_NOFUNCDESC_CONS_GP)
4849       != (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
4850     {
4851       (*_bfd_error_handler)
4852         (_("%s: linking auto-pic files with non-auto-pic files"),
4853          bfd_archive_filename (ibfd));
4854
4855       bfd_set_error (bfd_error_bad_value);
4856       ok = FALSE;
4857     }
4858
4859   return ok;
4860 }
4861
4862 static bfd_boolean
4863 elfNN_ia64_print_private_bfd_data (abfd, ptr)
4864      bfd *abfd;
4865      PTR ptr;
4866 {
4867   FILE *file = (FILE *) ptr;
4868   flagword flags = elf_elfheader (abfd)->e_flags;
4869
4870   BFD_ASSERT (abfd != NULL && ptr != NULL);
4871
4872   fprintf (file, "private flags = %s%s%s%s%s%s%s%s\n",
4873            (flags & EF_IA_64_TRAPNIL) ? "TRAPNIL, " : "",
4874            (flags & EF_IA_64_EXT) ? "EXT, " : "",
4875            (flags & EF_IA_64_BE) ? "BE, " : "LE, ",
4876            (flags & EF_IA_64_REDUCEDFP) ? "REDUCEDFP, " : "",
4877            (flags & EF_IA_64_CONS_GP) ? "CONS_GP, " : "",
4878            (flags & EF_IA_64_NOFUNCDESC_CONS_GP) ? "NOFUNCDESC_CONS_GP, " : "",
4879            (flags & EF_IA_64_ABSOLUTE) ? "ABSOLUTE, " : "",
4880            (flags & EF_IA_64_ABI64) ? "ABI64" : "ABI32");
4881
4882   _bfd_elf_print_private_bfd_data (abfd, ptr);
4883   return TRUE;
4884 }
4885
4886 static enum elf_reloc_type_class
4887 elfNN_ia64_reloc_type_class (rela)
4888      const Elf_Internal_Rela *rela;
4889 {
4890   switch ((int) ELFNN_R_TYPE (rela->r_info))
4891     {
4892     case R_IA64_REL32MSB:
4893     case R_IA64_REL32LSB:
4894     case R_IA64_REL64MSB:
4895     case R_IA64_REL64LSB:
4896       return reloc_class_relative;
4897     case R_IA64_IPLTMSB:
4898     case R_IA64_IPLTLSB:
4899       return reloc_class_plt;
4900     case R_IA64_COPY:
4901       return reloc_class_copy;
4902     default:
4903       return reloc_class_normal;
4904     }
4905 }
4906
4907 static struct bfd_elf_special_section const elfNN_ia64_special_sections[]=
4908 {
4909   { ".sbss",  5, -1, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
4910   { ".sdata", 6, -1, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
4911   { NULL,     0,  0, 0,            0 }
4912 };
4913
4914 static bfd_boolean
4915 elfNN_ia64_hpux_vec (const bfd_target *vec)
4916 {
4917   extern const bfd_target bfd_elfNN_ia64_hpux_big_vec;
4918   return (vec == & bfd_elfNN_ia64_hpux_big_vec);
4919 }
4920
4921 static void
4922 elfNN_hpux_post_process_headers (abfd, info)
4923         bfd *abfd;
4924         struct bfd_link_info *info ATTRIBUTE_UNUSED;
4925 {
4926   Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
4927
4928   i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_HPUX;
4929   i_ehdrp->e_ident[EI_ABIVERSION] = 1;
4930 }
4931
4932 bfd_boolean
4933 elfNN_hpux_backend_section_from_bfd_section (abfd, sec, retval)
4934         bfd *abfd ATTRIBUTE_UNUSED;
4935         asection *sec;
4936         int *retval;
4937 {
4938   if (bfd_is_com_section (sec))
4939     {
4940       *retval = SHN_IA_64_ANSI_COMMON;
4941       return TRUE;
4942     }
4943   return FALSE;
4944 }
4945
4946 static void
4947 elfNN_hpux_backend_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
4948                                       asymbol *asym)
4949 {
4950   elf_symbol_type *elfsym = (elf_symbol_type *) asym;;
4951
4952   switch (elfsym->internal_elf_sym.st_shndx)
4953     {
4954     case SHN_IA_64_ANSI_COMMON:
4955       asym->section = bfd_com_section_ptr;
4956       asym->value = elfsym->internal_elf_sym.st_size;
4957       asym->flags &= ~BSF_GLOBAL;
4958       break;
4959     }
4960 }
4961
4962 \f
4963 #define TARGET_LITTLE_SYM               bfd_elfNN_ia64_little_vec
4964 #define TARGET_LITTLE_NAME              "elfNN-ia64-little"
4965 #define TARGET_BIG_SYM                  bfd_elfNN_ia64_big_vec
4966 #define TARGET_BIG_NAME                 "elfNN-ia64-big"
4967 #define ELF_ARCH                        bfd_arch_ia64
4968 #define ELF_MACHINE_CODE                EM_IA_64
4969 #define ELF_MACHINE_ALT1                1999    /* EAS2.3 */
4970 #define ELF_MACHINE_ALT2                1998    /* EAS2.2 */
4971 #define ELF_MAXPAGESIZE                 0x10000 /* 64KB */
4972
4973 #define elf_backend_section_from_shdr \
4974         elfNN_ia64_section_from_shdr
4975 #define elf_backend_section_flags \
4976         elfNN_ia64_section_flags
4977 #define elf_backend_fake_sections \
4978         elfNN_ia64_fake_sections
4979 #define elf_backend_final_write_processing \
4980         elfNN_ia64_final_write_processing
4981 #define elf_backend_add_symbol_hook \
4982         elfNN_ia64_add_symbol_hook
4983 #define elf_backend_additional_program_headers \
4984         elfNN_ia64_additional_program_headers
4985 #define elf_backend_modify_segment_map \
4986         elfNN_ia64_modify_segment_map
4987 #define elf_info_to_howto \
4988         elfNN_ia64_info_to_howto
4989
4990 #define bfd_elfNN_bfd_reloc_type_lookup \
4991         elfNN_ia64_reloc_type_lookup
4992 #define bfd_elfNN_bfd_is_local_label_name \
4993         elfNN_ia64_is_local_label_name
4994 #define bfd_elfNN_bfd_relax_section \
4995         elfNN_ia64_relax_section
4996
4997 /* Stuff for the BFD linker: */
4998 #define bfd_elfNN_bfd_link_hash_table_create \
4999         elfNN_ia64_hash_table_create
5000 #define bfd_elfNN_bfd_link_hash_table_free \
5001         elfNN_ia64_hash_table_free
5002 #define elf_backend_create_dynamic_sections \
5003         elfNN_ia64_create_dynamic_sections
5004 #define elf_backend_check_relocs \
5005         elfNN_ia64_check_relocs
5006 #define elf_backend_adjust_dynamic_symbol \
5007         elfNN_ia64_adjust_dynamic_symbol
5008 #define elf_backend_size_dynamic_sections \
5009         elfNN_ia64_size_dynamic_sections
5010 #define elf_backend_relocate_section \
5011         elfNN_ia64_relocate_section
5012 #define elf_backend_finish_dynamic_symbol \
5013         elfNN_ia64_finish_dynamic_symbol
5014 #define elf_backend_finish_dynamic_sections \
5015         elfNN_ia64_finish_dynamic_sections
5016 #define bfd_elfNN_bfd_final_link \
5017         elfNN_ia64_final_link
5018
5019 #define bfd_elfNN_bfd_merge_private_bfd_data \
5020         elfNN_ia64_merge_private_bfd_data
5021 #define bfd_elfNN_bfd_set_private_flags \
5022         elfNN_ia64_set_private_flags
5023 #define bfd_elfNN_bfd_print_private_bfd_data \
5024         elfNN_ia64_print_private_bfd_data
5025
5026 #define elf_backend_plt_readonly        1
5027 #define elf_backend_want_plt_sym        0
5028 #define elf_backend_plt_alignment       5
5029 #define elf_backend_got_header_size     0
5030 #define elf_backend_want_got_plt        1
5031 #define elf_backend_may_use_rel_p       1
5032 #define elf_backend_may_use_rela_p      1
5033 #define elf_backend_default_use_rela_p  1
5034 #define elf_backend_want_dynbss         0
5035 #define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect
5036 #define elf_backend_hide_symbol         elfNN_ia64_hash_hide_symbol
5037 #define elf_backend_reloc_type_class    elfNN_ia64_reloc_type_class
5038 #define elf_backend_rela_normal         1
5039 #define elf_backend_special_sections    elfNN_ia64_special_sections
5040
5041 #include "elfNN-target.h"
5042
5043 /* HPUX-specific vectors.  */
5044
5045 #undef  TARGET_LITTLE_SYM
5046 #undef  TARGET_LITTLE_NAME
5047 #undef  TARGET_BIG_SYM
5048 #define TARGET_BIG_SYM                  bfd_elfNN_ia64_hpux_big_vec
5049 #undef  TARGET_BIG_NAME
5050 #define TARGET_BIG_NAME                 "elfNN-ia64-hpux-big"
5051
5052 /* These are HP-UX specific functions.  */
5053
5054 #undef  elf_backend_post_process_headers
5055 #define elf_backend_post_process_headers elfNN_hpux_post_process_headers
5056
5057 #undef  elf_backend_section_from_bfd_section
5058 #define elf_backend_section_from_bfd_section elfNN_hpux_backend_section_from_bfd_section
5059
5060 #undef elf_backend_symbol_processing
5061 #define elf_backend_symbol_processing elfNN_hpux_backend_symbol_processing
5062
5063 #undef  elf_backend_want_p_paddr_set_to_zero
5064 #define elf_backend_want_p_paddr_set_to_zero 1
5065
5066 #undef  ELF_MAXPAGESIZE
5067 #define ELF_MAXPAGESIZE                 0x1000  /* 1K */
5068
5069 #undef  elfNN_bed
5070 #define elfNN_bed elfNN_ia64_hpux_bed
5071
5072 #include "elfNN-target.h"
5073
5074 #undef  elf_backend_want_p_paddr_set_to_zero