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