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