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