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