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