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