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