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