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