bfd/elfxx-ia64.c

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