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