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