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