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