projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* elfxx-target.h: Remove PTR cast.
[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
9c5bfbb7 214 PARAMS ((const struct elf_backend_data *, struct elf_link_hash_entry *,
b48fa14c 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 1591elfNN_ia64_hash_copy_indirect (bed, xdir, xind)
9c5bfbb7 1592 const 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
8651fcf9
L		 1910 /* The .got section is always aligned at 8 bytes. */
1911 if (!bfd_set_section_alignment (abfd, got, 3))
1912 return 0;
1913
800eeca4
JW		 1914 flags = bfd_get_section_flags (abfd, got);
1915 bfd_set_section_flags (abfd, got, SEC_SMALL_DATA | flags);
1916 }
1917
1918 return got;
1919}
1920
1921/* Create function descriptor section (.opd). This section is called .opd
1922 because it contains "official prodecure descriptors". The "official"
1923 refers to the fact that these descriptors are used when taking the address
1924 of a procedure, thus ensuring a unique address for each procedure. */
1925
1926static asection *
1927get_fptr (abfd, info, ia64_info)
1928 bfd *abfd;
9203ba99 1929 struct bfd_link_info *info;
bbe66d08 1930 struct elfNN_ia64_link_hash_table *ia64_info;
800eeca4
JW		 1931{
1932 asection *fptr;
1933 bfd *dynobj;
1934
1935 fptr = ia64_info->fptr_sec;
1936 if (!fptr)
1937 {
1938 dynobj = ia64_info->root.dynobj;
1939 if (!dynobj)
1940 ia64_info->root.dynobj = dynobj = abfd;
1941
1942 fptr = bfd_make_section (dynobj, ".opd");
1943 if (!fptr
1944 || !bfd_set_section_flags (dynobj, fptr,
1945 (SEC_ALLOC
1946 | SEC_LOAD
1947 | SEC_HAS_CONTENTS
1948 | SEC_IN_MEMORY
9203ba99 1949 | (info->pie ? 0 : SEC_READONLY)
800eeca4
JW		 1950 | SEC_LINKER_CREATED))
1951 || !bfd_set_section_alignment (abfd, fptr, 4))
1952 {
1953 BFD_ASSERT (0);
1954 return NULL;
1955 }
1956
1957 ia64_info->fptr_sec = fptr;
9203ba99
JJ		 1958
1959 if (info->pie)
1960 {
1961 asection *fptr_rel;
1962 fptr_rel = bfd_make_section(abfd, ".rela.opd");
1963 if (fptr_rel == NULL
1964 || !bfd_set_section_flags (abfd, fptr_rel,
1965 (SEC_ALLOC | SEC_LOAD
1966 | SEC_HAS_CONTENTS
1967 | SEC_IN_MEMORY
1968 | SEC_LINKER_CREATED
1969 | SEC_READONLY))
1970 || !bfd_set_section_alignment (abfd, fptr_rel, 3))
1971 {
1972 BFD_ASSERT (0);
1973 return NULL;
1974 }
1975
1976 ia64_info->rel_fptr_sec = fptr_rel;
1977 }
800eeca4
JW		 1978 }
1979
1980 return fptr;
1981}
1982
1983static asection *
1984get_pltoff (abfd, info, ia64_info)
1985 bfd *abfd;
64bf6ae6 1986 struct bfd_link_info *info ATTRIBUTE_UNUSED;
bbe66d08 1987 struct elfNN_ia64_link_hash_table *ia64_info;
800eeca4
JW		 1988{
1989 asection *pltoff;
1990 bfd *dynobj;
1991
1992 pltoff = ia64_info->pltoff_sec;
1993 if (!pltoff)
1994 {
1995 dynobj = ia64_info->root.dynobj;
1996 if (!dynobj)
1997 ia64_info->root.dynobj = dynobj = abfd;
1998
1999 pltoff = bfd_make_section (dynobj, ELF_STRING_ia64_pltoff);
2000 if (!pltoff
2001 || !bfd_set_section_flags (dynobj, pltoff,
2002 (SEC_ALLOC
2003 | SEC_LOAD
2004 | SEC_HAS_CONTENTS
2005 | SEC_IN_MEMORY
2006 | SEC_SMALL_DATA
2007 | SEC_LINKER_CREATED))
2008 || !bfd_set_section_alignment (abfd, pltoff, 4))
2009 {
2010 BFD_ASSERT (0);
2011 return NULL;
2012 }
2013
2014 ia64_info->pltoff_sec = pltoff;
2015 }
2016
2017 return pltoff;
2018}
2019
2020static asection *
2021get_reloc_section (abfd, ia64_info, sec, create)
2022 bfd *abfd;
bbe66d08 2023 struct elfNN_ia64_link_hash_table *ia64_info;
800eeca4 2024 asection *sec;
b34976b6 2025 bfd_boolean create;
800eeca4
JW		 2026{
2027 const char *srel_name;
2028 asection *srel;
2029 bfd *dynobj;
2030
2031 srel_name = (bfd_elf_string_from_elf_section
2032 (abfd, elf_elfheader(abfd)->e_shstrndx,
2033 elf_section_data(sec)->rel_hdr.sh_name));
2034 if (srel_name == NULL)
2035 return NULL;
2036
2037 BFD_ASSERT ((strncmp (srel_name, ".rela", 5) == 0
2038 && strcmp (bfd_get_section_name (abfd, sec),
2039 srel_name+5) == 0)
2040 || (strncmp (srel_name, ".rel", 4) == 0
2041 && strcmp (bfd_get_section_name (abfd, sec),
2042 srel_name+4) == 0));
2043
2044 dynobj = ia64_info->root.dynobj;
2045 if (!dynobj)
2046 ia64_info->root.dynobj = dynobj = abfd;
2047
2048 srel = bfd_get_section_by_name (dynobj, srel_name);
2049 if (srel == NULL && create)
2050 {
2051 srel = bfd_make_section (dynobj, srel_name);
2052 if (srel == NULL
2053 || !bfd_set_section_flags (dynobj, srel,
2054 (SEC_ALLOC
2055 | SEC_LOAD
2056 | SEC_HAS_CONTENTS
2057 | SEC_IN_MEMORY
2058 | SEC_LINKER_CREATED
2059 | SEC_READONLY))
2060 || !bfd_set_section_alignment (dynobj, srel, 3))
2061 return NULL;
2062 }
2063
db6751f2
JJ		 2064 if (sec->flags & SEC_READONLY)
2065 ia64_info->reltext = 1;
2066
800eeca4
JW		 2067 return srel;
2068}
2069
b34976b6 2070static bfd_boolean
800eeca4
JW		 2071count_dyn_reloc (abfd, dyn_i, srel, type)
2072 bfd *abfd;
bbe66d08 2073 struct elfNN_ia64_dyn_sym_info *dyn_i;
800eeca4
JW		 2074 asection *srel;
2075 int type;
2076{
bbe66d08 2077 struct elfNN_ia64_dyn_reloc_entry *rent;
800eeca4
JW		 2078
2079 for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
2080 if (rent->srel == srel && rent->type == type)
2081 break;
2082
2083 if (!rent)
2084 {
dc810e39
AM		 2085 rent = ((struct elfNN_ia64_dyn_reloc_entry *)
2086 bfd_alloc (abfd, (bfd_size_type) sizeof (*rent)));
800eeca4 2087 if (!rent)
b34976b6 2088 return FALSE;
800eeca4
JW		 2089
2090 rent->next = dyn_i->reloc_entries;
2091 rent->srel = srel;
2092 rent->type = type;
2093 rent->count = 0;
2094 dyn_i->reloc_entries = rent;
2095 }
2096 rent->count++;
2097
b34976b6 2098 return TRUE;
800eeca4
JW		 2099}
2100
b34976b6 2101static bfd_boolean
bbe66d08 2102elfNN_ia64_check_relocs (abfd, info, sec, relocs)
800eeca4
JW		 2103 bfd *abfd;
2104 struct bfd_link_info *info;
2105 asection *sec;
2106 const Elf_Internal_Rela *relocs;
2107{
bbe66d08 2108 struct elfNN_ia64_link_hash_table *ia64_info;
800eeca4
JW		 2109 const Elf_Internal_Rela *relend;
2110 Elf_Internal_Shdr *symtab_hdr;
2111 const Elf_Internal_Rela *rel;
2112 asection *got, *fptr, *srel;
2113
1049f94e 2114 if (info->relocatable)
b34976b6 2115 return TRUE;
800eeca4
JW		 2116
2117 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
bbe66d08 2118 ia64_info = elfNN_ia64_hash_table (info);
800eeca4
JW		 2119
2120 got = fptr = srel = NULL;
2121
2122 relend = relocs + sec->reloc_count;
2123 for (rel = relocs; rel < relend; ++rel)
2124 {
2125 enum {
2126 NEED_GOT = 1,
2c4c2bc0
RH		 2127 NEED_GOTX = 2,
2128 NEED_FPTR = 4,
2129 NEED_PLTOFF = 8,
2130 NEED_MIN_PLT = 16,
2131 NEED_FULL_PLT = 32,
2132 NEED_DYNREL = 64,
2133 NEED_LTOFF_FPTR = 128,
2134 NEED_TPREL = 256,
2135 NEED_DTPMOD = 512,
2136 NEED_DTPREL = 1024
800eeca4
JW		 2137 };
2138
2139 struct elf_link_hash_entry *h = NULL;
bbe66d08
JW		 2140 unsigned long r_symndx = ELFNN_R_SYM (rel->r_info);
2141 struct elfNN_ia64_dyn_sym_info *dyn_i;
800eeca4 2142 int need_entry;
b34976b6 2143 bfd_boolean maybe_dynamic;
64bf6ae6 2144 int dynrel_type = R_IA64_NONE;
800eeca4
JW		 2145
2146 if (r_symndx >= symtab_hdr->sh_info)
2147 {
2148 /* We're dealing with a global symbol -- find its hash entry
2149 and mark it as being referenced. */
2150 long indx = r_symndx - symtab_hdr->sh_info;
2151 h = elf_sym_hashes (abfd)[indx];
2152 while (h->root.type == bfd_link_hash_indirect
2153 || h->root.type == bfd_link_hash_warning)
2154 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2155
2156 h->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
2157 }
2158
2159 /* We can only get preliminary data on whether a symbol is
2160 locally or externally defined, as not all of the input files
2161 have yet been processed. Do something with what we know, as
2162 this may help reduce memory usage and processing time later. */
b34976b6 2163 maybe_dynamic = FALSE;
9203ba99 2164 if (h && ((!info->executable
671bae9c 2165 && (!info->symbolic || info->allow_shlib_undefined))
800eeca4 2166 || ! (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
02e6ad56 2167 || h->root.type == bfd_link_hash_defweak))
b34976b6 2168 maybe_dynamic = TRUE;
800eeca4
JW		 2169
2170 need_entry = 0;
bbe66d08 2171 switch (ELFNN_R_TYPE (rel->r_info))
800eeca4 2172 {
800eeca4
JW		 2173 case R_IA64_TPREL64MSB:
2174 case R_IA64_TPREL64LSB:
13ae64f3
JJ		 2175 if (info->shared || maybe_dynamic)
2176 need_entry = NEED_DYNREL;
2177 dynrel_type = R_IA64_TPREL64LSB;
2178 if (info->shared)
2179 info->flags |= DF_STATIC_TLS;
2180 break;
2181
2182 case R_IA64_LTOFF_TPREL22:
2183 need_entry = NEED_TPREL;
2184 if (info->shared)
2185 info->flags |= DF_STATIC_TLS;
2186 break;
2187
2188 case R_IA64_DTPREL64MSB:
2189 case R_IA64_DTPREL64LSB:
2190 if (info->shared || maybe_dynamic)
2191 need_entry = NEED_DYNREL;
2192 dynrel_type = R_IA64_DTPREL64LSB;
2193 break;
2194
2195 case R_IA64_LTOFF_DTPREL22:
2196 need_entry = NEED_DTPREL;
2197 break;
2198
2199 case R_IA64_DTPMOD64MSB:
2200 case R_IA64_DTPMOD64LSB:
2201 if (info->shared || maybe_dynamic)
2202 need_entry = NEED_DYNREL;
2203 dynrel_type = R_IA64_DTPMOD64LSB;
2204 break;
2205
2206 case R_IA64_LTOFF_DTPMOD22:
2207 need_entry = NEED_DTPMOD;
2208 break;
800eeca4
JW		 2209
2210 case R_IA64_LTOFF_FPTR22:
2211 case R_IA64_LTOFF_FPTR64I:
a4bd8390
JW		 2212 case R_IA64_LTOFF_FPTR32MSB:
2213 case R_IA64_LTOFF_FPTR32LSB:
800eeca4
JW		 2214 case R_IA64_LTOFF_FPTR64MSB:
2215 case R_IA64_LTOFF_FPTR64LSB:
2216 need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR;
2217 break;
2218
2219 case R_IA64_FPTR64I:
2220 case R_IA64_FPTR32MSB:
2221 case R_IA64_FPTR32LSB:
2222 case R_IA64_FPTR64MSB:
2223 case R_IA64_FPTR64LSB:
02e6ad56 2224 if (info->shared || h)
800eeca4
JW		 2225 need_entry = NEED_FPTR | NEED_DYNREL;
2226 else
2227 need_entry = NEED_FPTR;
2228 dynrel_type = R_IA64_FPTR64LSB;
2229 break;
2230
2231 case R_IA64_LTOFF22:
800eeca4
JW		 2232 case R_IA64_LTOFF64I:
2233 need_entry = NEED_GOT;
2234 break;
2235
2c4c2bc0
RH		 2236 case R_IA64_LTOFF22X:
2237 need_entry = NEED_GOTX;
2238 break;
2239
800eeca4
JW		 2240 case R_IA64_PLTOFF22:
2241 case R_IA64_PLTOFF64I:
2242 case R_IA64_PLTOFF64MSB:
2243 case R_IA64_PLTOFF64LSB:
2244 need_entry = NEED_PLTOFF;
2245 if (h)
2246 {
2247 if (maybe_dynamic)
2248 need_entry |= NEED_MIN_PLT;
2249 }
2250 else
2251 {
2252 (*info->callbacks->warning)
2253 (info, _("@pltoff reloc against local symbol"), 0,
dc810e39 2254 abfd, 0, (bfd_vma) 0);
800eeca4
JW		 2255 }
2256 break;
2257
2258 case R_IA64_PCREL21B:
748abff6 2259 case R_IA64_PCREL60B:
800eeca4
JW		 2260 /* Depending on where this symbol is defined, we may or may not
2261 need a full plt entry. Only skip if we know we'll not need
2262 the entry -- static or symbolic, and the symbol definition
2263 has already been seen. */
2264 if (maybe_dynamic && rel->r_addend == 0)
2265 need_entry = NEED_FULL_PLT;
2266 break;
2267
2268 case R_IA64_IMM14:
2269 case R_IA64_IMM22:
2270 case R_IA64_IMM64:
2271 case R_IA64_DIR32MSB:
2272 case R_IA64_DIR32LSB:
2273 case R_IA64_DIR64MSB:
2274 case R_IA64_DIR64LSB:
2275 /* Shared objects will always need at least a REL relocation. */
02e6ad56 2276 if (info->shared || maybe_dynamic)
800eeca4
JW		 2277 need_entry = NEED_DYNREL;
2278 dynrel_type = R_IA64_DIR64LSB;
2279 break;
2280
18b27f17
RH		 2281 case R_IA64_IPLTMSB:
2282 case R_IA64_IPLTLSB:
2283 /* Shared objects will always need at least a REL relocation. */
2284 if (info->shared || maybe_dynamic)
2285 need_entry = NEED_DYNREL;
2286 dynrel_type = R_IA64_IPLTLSB;
2287 break;
2288
748abff6
RH		 2289 case R_IA64_PCREL22:
2290 case R_IA64_PCREL64I:
800eeca4
JW		 2291 case R_IA64_PCREL32MSB:
2292 case R_IA64_PCREL32LSB:
2293 case R_IA64_PCREL64MSB:
2294 case R_IA64_PCREL64LSB:
2295 if (maybe_dynamic)
2296 need_entry = NEED_DYNREL;
2297 dynrel_type = R_IA64_PCREL64LSB;
2298 break;
2299 }
2300
2301 if (!need_entry)
2302 continue;
2303
2304 if ((need_entry & NEED_FPTR) != 0
2305 && rel->r_addend)
2306 {
2307 (*info->callbacks->warning)
2308 (info, _("non-zero addend in @fptr reloc"), 0,
dc810e39 2309 abfd, 0, (bfd_vma) 0);
800eeca4
JW		 2310 }
2311
b34976b6 2312 dyn_i = get_dyn_sym_info (ia64_info, h, abfd, rel, TRUE);
800eeca4
JW		 2313
2314 /* Record whether or not this is a local symbol. */
2315 dyn_i->h = h;
2316
2317 /* Create what's needed. */
2c4c2bc0
RH		 2318 if (need_entry & (NEED_GOT | NEED_GOTX | NEED_TPREL
2319 | NEED_DTPMOD | NEED_DTPREL))
800eeca4
JW		 2320 {
2321 if (!got)
2322 {
2323 got = get_got (abfd, info, ia64_info);
2324 if (!got)
b34976b6 2325 return FALSE;
800eeca4 2326 }
13ae64f3
JJ		 2327 if (need_entry & NEED_GOT)
2328 dyn_i->want_got = 1;
2c4c2bc0
RH		 2329 if (need_entry & NEED_GOTX)
2330 dyn_i->want_gotx = 1;
13ae64f3
JJ		 2331 if (need_entry & NEED_TPREL)
2332 dyn_i->want_tprel = 1;
2333 if (need_entry & NEED_DTPMOD)
2334 dyn_i->want_dtpmod = 1;
2335 if (need_entry & NEED_DTPREL)
2336 dyn_i->want_dtprel = 1;
800eeca4
JW		 2337 }
2338 if (need_entry & NEED_FPTR)
2339 {
2340 if (!fptr)
2341 {
2342 fptr = get_fptr (abfd, info, ia64_info);
2343 if (!fptr)
b34976b6 2344 return FALSE;
800eeca4
JW		 2345 }
2346
2347 /* FPTRs for shared libraries are allocated by the dynamic
2348 linker. Make sure this local symbol will appear in the
2349 dynamic symbol table. */
02e6ad56 2350 if (!h && info->shared)
800eeca4 2351 {
bbe66d08 2352 if (! (_bfd_elfNN_link_record_local_dynamic_symbol
dc810e39 2353 (info, abfd, (long) r_symndx)))
b34976b6 2354 return FALSE;
800eeca4
JW		 2355 }
2356
2357 dyn_i->want_fptr = 1;
2358 }
2359 if (need_entry & NEED_LTOFF_FPTR)
2360 dyn_i->want_ltoff_fptr = 1;
2361 if (need_entry & (NEED_MIN_PLT | NEED_FULL_PLT))
2362 {
2363 if (!ia64_info->root.dynobj)
2364 ia64_info->root.dynobj = abfd;
2365 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2366 dyn_i->want_plt = 1;
2367 }
2368 if (need_entry & NEED_FULL_PLT)
2369 dyn_i->want_plt2 = 1;
2370 if (need_entry & NEED_PLTOFF)
2371 dyn_i->want_pltoff = 1;
2372 if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC))
2373 {
2374 if (!srel)
2375 {
b34976b6 2376 srel = get_reloc_section (abfd, ia64_info, sec, TRUE);
800eeca4 2377 if (!srel)
b34976b6 2378 return FALSE;
800eeca4
JW		 2379 }
2380 if (!count_dyn_reloc (abfd, dyn_i, srel, dynrel_type))
b34976b6 2381 return FALSE;
800eeca4
JW		 2382 }
2383 }
2384
b34976b6 2385 return TRUE;
800eeca4
JW		 2386}
2387
800eeca4
JW		 2388/* For cleanliness, and potentially faster dynamic loading, allocate
2389 external GOT entries first. */
2390
b34976b6 2391static bfd_boolean
800eeca4 2392allocate_global_data_got (dyn_i, data)
bbe66d08 2393 struct elfNN_ia64_dyn_sym_info *dyn_i;
800eeca4
JW		 2394 PTR data;
2395{
bbe66d08 2396 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
800eeca4 2397
2c4c2bc0 2398 if ((dyn_i->want_got || dyn_i->want_gotx)
800eeca4 2399 && ! dyn_i->want_fptr
986a241f 2400 && elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
800eeca4
JW		 2401 {
2402 dyn_i->got_offset = x->ofs;
2403 x->ofs += 8;
2404 }
13ae64f3
JJ		 2405 if (dyn_i->want_tprel)
2406 {
2407 dyn_i->tprel_offset = x->ofs;
2408 x->ofs += 8;
2409 }
2410 if (dyn_i->want_dtpmod)
2411 {
986a241f 2412 if (elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
b3dfd7fe
JJ		 2413 {
2414 dyn_i->dtpmod_offset = x->ofs;
2415 x->ofs += 8;
2416 }
2417 else
2418 {
2419 struct elfNN_ia64_link_hash_table *ia64_info;
2420
2421 ia64_info = elfNN_ia64_hash_table (x->info);
2422 if (ia64_info->self_dtpmod_offset == (bfd_vma) -1)
2423 {
2424 ia64_info->self_dtpmod_offset = x->ofs;
2425 x->ofs += 8;
2426 }
2427 dyn_i->dtpmod_offset = ia64_info->self_dtpmod_offset;
2428 }
13ae64f3
JJ		 2429 }
2430 if (dyn_i->want_dtprel)
2431 {
2432 dyn_i->dtprel_offset = x->ofs;
2433 x->ofs += 8;
2434 }
b34976b6 2435 return TRUE;
800eeca4
JW		 2436}
2437
2438/* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
2439
b34976b6 2440static bfd_boolean
800eeca4 2441allocate_global_fptr_got (dyn_i, data)
bbe66d08 2442 struct elfNN_ia64_dyn_sym_info *dyn_i;
800eeca4
JW		 2443 PTR data;
2444{
bbe66d08 2445 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
800eeca4
JW		 2446
2447 if (dyn_i->want_got
2448 && dyn_i->want_fptr
986a241f 2449 && elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, R_IA64_FPTR64LSB))
800eeca4
JW		 2450 {
2451 dyn_i->got_offset = x->ofs;
2452 x->ofs += 8;
2453 }
b34976b6 2454 return TRUE;
800eeca4
JW		 2455}
2456
2457/* Lastly, allocate all the GOT entries for local data. */
2458
b34976b6 2459static bfd_boolean
800eeca4 2460allocate_local_got (dyn_i, data)
bbe66d08 2461 struct elfNN_ia64_dyn_sym_info *dyn_i;
800eeca4
JW		 2462 PTR data;
2463{
bbe66d08 2464 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
800eeca4 2465
2c4c2bc0 2466 if ((dyn_i->want_got || dyn_i->want_gotx)
986a241f 2467 && !elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
800eeca4
JW		 2468 {
2469 dyn_i->got_offset = x->ofs;
2470 x->ofs += 8;
2471 }
b34976b6 2472 return TRUE;
800eeca4
JW		 2473}
2474
2475/* Search for the index of a global symbol in it's defining object file. */
2476
dc810e39 2477static long
800eeca4
JW		 2478global_sym_index (h)
2479 struct elf_link_hash_entry *h;
2480{
2481 struct elf_link_hash_entry **p;
2482 bfd *obj;
2483
2484 BFD_ASSERT (h->root.type == bfd_link_hash_defined
2485 || h->root.type == bfd_link_hash_defweak);
2486
2487 obj = h->root.u.def.section->owner;
2488 for (p = elf_sym_hashes (obj); *p != h; ++p)
2489 continue;
2490
2491 return p - elf_sym_hashes (obj) + elf_tdata (obj)->symtab_hdr.sh_info;
2492}
2493
2494/* Allocate function descriptors. We can do these for every function
2495 in a main executable that is not exported. */
2496
b34976b6 2497static bfd_boolean
800eeca4 2498allocate_fptr (dyn_i, data)
bbe66d08 2499 struct elfNN_ia64_dyn_sym_info *dyn_i;
800eeca4
JW		 2500 PTR data;
2501{
bbe66d08 2502 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
800eeca4
JW		 2503
2504 if (dyn_i->want_fptr)
2505 {
2506 struct elf_link_hash_entry *h = dyn_i->h;
3e932841 2507
800eeca4
JW		 2508 if (h)
2509 while (h->root.type == bfd_link_hash_indirect
2510 || h->root.type == bfd_link_hash_warning)
2511 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2512
02e6ad56
RH		 2513 if (!x->info->executable
2514 && (!h
2515 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2516 || h->root.type != bfd_link_hash_undefweak))
800eeca4
JW		 2517 {
2518 if (h && h->dynindx == -1)
2519 {
2520 BFD_ASSERT ((h->root.type == bfd_link_hash_defined)
2521 || (h->root.type == bfd_link_hash_defweak));
2522
bbe66d08 2523 if (!_bfd_elfNN_link_record_local_dynamic_symbol
800eeca4
JW		 2524 (x->info, h->root.u.def.section->owner,
2525 global_sym_index (h)))
b34976b6 2526 return FALSE;
800eeca4
JW		 2527 }
2528
2529 dyn_i->want_fptr = 0;
2530 }
2531 else if (h == NULL || h->dynindx == -1)
2532 {
2533 dyn_i->fptr_offset = x->ofs;
2534 x->ofs += 16;
2535 }
2536 else
2537 dyn_i->want_fptr = 0;
2538 }
b34976b6 2539 return TRUE;
800eeca4
JW		 2540}
2541
2542/* Allocate all the minimal PLT entries. */
2543
b34976b6 2544static bfd_boolean
800eeca4 2545allocate_plt_entries (dyn_i, data)
bbe66d08 2546 struct elfNN_ia64_dyn_sym_info *dyn_i;
800eeca4
JW		 2547 PTR data;
2548{
bbe66d08 2549 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
800eeca4
JW		 2550
2551 if (dyn_i->want_plt)
2552 {
2553 struct elf_link_hash_entry *h = dyn_i->h;
2554
2555 if (h)
2556 while (h->root.type == bfd_link_hash_indirect
2557 || h->root.type == bfd_link_hash_warning)
2558 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2559
2560 /* ??? Versioned symbols seem to lose ELF_LINK_HASH_NEEDS_PLT. */
986a241f 2561 if (elfNN_ia64_dynamic_symbol_p (h, x->info, 0))
800eeca4
JW		 2562 {
2563 bfd_size_type offset = x->ofs;
2564 if (offset == 0)
2565 offset = PLT_HEADER_SIZE;
2566 dyn_i->plt_offset = offset;
2567 x->ofs = offset + PLT_MIN_ENTRY_SIZE;
2568
2569 dyn_i->want_pltoff = 1;
2570 }
2571 else
2572 {
2573 dyn_i->want_plt = 0;
2574 dyn_i->want_plt2 = 0;
2575 }
2576 }
b34976b6 2577 return TRUE;
800eeca4
JW		 2578}
2579
2580/* Allocate all the full PLT entries. */
2581
b34976b6 2582static bfd_boolean
800eeca4 2583allocate_plt2_entries (dyn_i, data)
bbe66d08 2584 struct elfNN_ia64_dyn_sym_info *dyn_i;
800eeca4
JW		 2585 PTR data;
2586{
bbe66d08 2587 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
800eeca4
JW		 2588
2589 if (dyn_i->want_plt2)
2590 {
2591 struct elf_link_hash_entry *h = dyn_i->h;
2592 bfd_size_type ofs = x->ofs;
2593
2594 dyn_i->plt2_offset = ofs;
2595 x->ofs = ofs + PLT_FULL_ENTRY_SIZE;
2596
2597 while (h->root.type == bfd_link_hash_indirect
2598 || h->root.type == bfd_link_hash_warning)
2599 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2600 dyn_i->h->plt.offset = ofs;
2601 }
b34976b6 2602 return TRUE;
800eeca4
JW		 2603}
2604
2605/* Allocate all the PLTOFF entries requested by relocations and
2606 plt entries. We can't share space with allocated FPTR entries,
2607 because the latter are not necessarily addressable by the GP.
2608 ??? Relaxation might be able to determine that they are. */
2609
b34976b6 2610static bfd_boolean
800eeca4 2611allocate_pltoff_entries (dyn_i, data)
bbe66d08 2612 struct elfNN_ia64_dyn_sym_info *dyn_i;
800eeca4
JW		 2613 PTR data;
2614{
bbe66d08 2615 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
800eeca4
JW		 2616
2617 if (dyn_i->want_pltoff)
2618 {
2619 dyn_i->pltoff_offset = x->ofs;
2620 x->ofs += 16;
2621 }
b34976b6 2622 return TRUE;
800eeca4
JW		 2623}
2624
2625/* Allocate dynamic relocations for those symbols that turned out
2626 to be dynamic. */
2627
b34976b6 2628static bfd_boolean
800eeca4 2629allocate_dynrel_entries (dyn_i, data)
bbe66d08 2630 struct elfNN_ia64_dyn_sym_info *dyn_i;
800eeca4
JW		 2631 PTR data;
2632{
bbe66d08
JW		 2633 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2634 struct elfNN_ia64_link_hash_table *ia64_info;
2635 struct elfNN_ia64_dyn_reloc_entry *rent;
ef5aade5 2636 bfd_boolean dynamic_symbol, shared, resolved_zero;
800eeca4 2637
bbe66d08 2638 ia64_info = elfNN_ia64_hash_table (x->info);
986a241f
RH		 2639
2640 /* Note that this can't be used in relation to FPTR relocs below. */
2641 dynamic_symbol = elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0);
2642
800eeca4 2643 shared = x->info->shared;
ef5aade5
L		 2644 resolved_zero = (dyn_i->h
2645 && ELF_ST_VISIBILITY (dyn_i->h->other)
2646 && dyn_i->h->root.type == bfd_link_hash_undefweak);
800eeca4
JW		 2647
2648 /* Take care of the normal data relocations. */
2649
2650 for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
2651 {
18b27f17
RH		 2652 int count = rent->count;
2653
800eeca4
JW		 2654 switch (rent->type)
2655 {
2656 case R_IA64_FPTR64LSB:
9203ba99
JJ		 2657 /* Allocate one iff !want_fptr and not PIE, which by this point
2658 will be true only if we're actually allocating one statically
2659 in the main executable. Position independent executables
2660 need a relative reloc. */
2661 if (dyn_i->want_fptr && !x->info->pie)
800eeca4
JW		 2662 continue;
2663 break;
2664 case R_IA64_PCREL64LSB:
2665 if (!dynamic_symbol)
2666 continue;
2667 break;
2668 case R_IA64_DIR64LSB:
2669 if (!dynamic_symbol && !shared)
2670 continue;
2671 break;
18b27f17
RH		 2672 case R_IA64_IPLTLSB:
2673 if (!dynamic_symbol && !shared)
2674 continue;
2675 /* Use two REL relocations for IPLT relocations
2676 against local symbols. */
2677 if (!dynamic_symbol)
2678 count *= 2;
2679 break;
13ae64f3
JJ		 2680 case R_IA64_TPREL64LSB:
2681 case R_IA64_DTPREL64LSB:
2682 case R_IA64_DTPMOD64LSB:
2683 break;
18b27f17
RH		 2684 default:
2685 abort ();
800eeca4 2686 }
18b27f17 2687 rent->srel->_raw_size += sizeof (ElfNN_External_Rela) * count;
800eeca4
JW		 2688 }
2689
2690 /* Take care of the GOT and PLT relocations. */
2691
ef5aade5
L		 2692 if ((!resolved_zero
2693 && (dynamic_symbol || shared)
2694 && (dyn_i->want_got || dyn_i->want_gotx))
2695 || (dyn_i->want_ltoff_fptr
2696 && dyn_i->h
2697 && dyn_i->h->dynindx != -1))
9203ba99
JJ		 2698 {
2699 if (!dyn_i->want_ltoff_fptr
2700 || !x->info->pie
2701 || dyn_i->h == NULL
2702 || dyn_i->h->root.type != bfd_link_hash_undefweak)
2703 ia64_info->rel_got_sec->_raw_size += sizeof (ElfNN_External_Rela);
2704 }
13ae64f3
JJ		 2705 if ((dynamic_symbol || shared) && dyn_i->want_tprel)
2706 ia64_info->rel_got_sec->_raw_size += sizeof (ElfNN_External_Rela);
b3dfd7fe 2707 if (dynamic_symbol && dyn_i->want_dtpmod)
13ae64f3
JJ		 2708 ia64_info->rel_got_sec->_raw_size += sizeof (ElfNN_External_Rela);
2709 if (dynamic_symbol && dyn_i->want_dtprel)
2710 ia64_info->rel_got_sec->_raw_size += sizeof (ElfNN_External_Rela);
9203ba99
JJ		 2711 if (ia64_info->rel_fptr_sec && dyn_i->want_fptr)
2712 {
2713 if (dyn_i->h == NULL || dyn_i->h->root.type != bfd_link_hash_undefweak)
2714 ia64_info->rel_fptr_sec->_raw_size += sizeof (ElfNN_External_Rela);
2715 }
800eeca4 2716
ef5aade5 2717 if (!resolved_zero && dyn_i->want_pltoff)
800eeca4
JW		 2718 {
2719 bfd_size_type t = 0;
2720
2721 /* Dynamic symbols get one IPLT relocation. Local symbols in
2722 shared libraries get two REL relocations. Local symbols in
2723 main applications get nothing. */
2724 if (dynamic_symbol)
bbe66d08 2725 t = sizeof (ElfNN_External_Rela);
800eeca4 2726 else if (shared)
bbe66d08 2727 t = 2 * sizeof (ElfNN_External_Rela);
800eeca4
JW		 2728
2729 ia64_info->rel_pltoff_sec->_raw_size += t;
2730 }
2731
b34976b6 2732 return TRUE;
800eeca4
JW		 2733}
2734
b34976b6 2735static bfd_boolean
bbe66d08 2736elfNN_ia64_adjust_dynamic_symbol (info, h)
64bf6ae6 2737 struct bfd_link_info *info ATTRIBUTE_UNUSED;
800eeca4
JW		 2738 struct elf_link_hash_entry *h;
2739{
2740 /* ??? Undefined symbols with PLT entries should be re-defined
2741 to be the PLT entry. */
2742
2743 /* If this is a weak symbol, and there is a real definition, the
2744 processor independent code will have arranged for us to see the
2745 real definition first, and we can just use the same value. */
2746 if (h->weakdef != NULL)
2747 {
2748 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2749 || h->weakdef->root.type == bfd_link_hash_defweak);
2750 h->root.u.def.section = h->weakdef->root.u.def.section;
2751 h->root.u.def.value = h->weakdef->root.u.def.value;
b34976b6 2752 return TRUE;
800eeca4
JW		 2753 }
2754
2755 /* If this is a reference to a symbol defined by a dynamic object which
2756 is not a function, we might allocate the symbol in our .dynbss section
2757 and allocate a COPY dynamic relocation.
2758
2759 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2760 of hackery. */
2761
b34976b6 2762 return TRUE;
800eeca4
JW		 2763}
2764
b34976b6 2765static bfd_boolean
bbe66d08 2766elfNN_ia64_size_dynamic_sections (output_bfd, info)
bb32e54f 2767 bfd *output_bfd ATTRIBUTE_UNUSED;
800eeca4
JW		 2768 struct bfd_link_info *info;
2769{
bbe66d08
JW		 2770 struct elfNN_ia64_allocate_data data;
2771 struct elfNN_ia64_link_hash_table *ia64_info;
800eeca4
JW		 2772 asection *sec;
2773 bfd *dynobj;
b34976b6 2774 bfd_boolean relplt = FALSE;
800eeca4
JW		 2775
2776 dynobj = elf_hash_table(info)->dynobj;
bbe66d08 2777 ia64_info = elfNN_ia64_hash_table (info);
b3dfd7fe 2778 ia64_info->self_dtpmod_offset = (bfd_vma) -1;
800eeca4
JW		 2779 BFD_ASSERT(dynobj != NULL);
2780 data.info = info;
2781
2782 /* Set the contents of the .interp section to the interpreter. */
2783 if (ia64_info->root.dynamic_sections_created
36af4a4e 2784 && info->executable)
800eeca4
JW		 2785 {
2786 sec = bfd_get_section_by_name (dynobj, ".interp");
2787 BFD_ASSERT (sec != NULL);
02e6ad56
RH		 2788 sec->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
2789 sec->_raw_size = strlen (ELF_DYNAMIC_INTERPRETER) + 1;
800eeca4
JW		 2790 }
2791
800eeca4
JW		 2792 /* Allocate the GOT entries. */
2793
2794 if (ia64_info->got_sec)
2795 {
2796 data.ofs = 0;
bbe66d08
JW		 2797 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data);
2798 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data);
2799 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data);
800eeca4
JW		 2800 ia64_info->got_sec->_raw_size = data.ofs;
2801 }
2802
2803 /* Allocate the FPTR entries. */
2804
2805 if (ia64_info->fptr_sec)
2806 {
2807 data.ofs = 0;
bbe66d08 2808 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_fptr, &data);
800eeca4
JW		 2809 ia64_info->fptr_sec->_raw_size = data.ofs;
2810 }
2811
2812 /* Now that we've seen all of the input files, we can decide which
2813 symbols need plt entries. Allocate the minimal PLT entries first.
b34976b6 2814 We do this even though dynamic_sections_created may be FALSE, because
800eeca4
JW		 2815 this has the side-effect of clearing want_plt and want_plt2. */
2816
2817 data.ofs = 0;
bbe66d08 2818 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_plt_entries, &data);
800eeca4
JW		 2819
2820 ia64_info->minplt_entries = 0;
2821 if (data.ofs)
2822 {
2823 ia64_info->minplt_entries
2824 = (data.ofs - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
2825 }
2826
2827 /* Align the pointer for the plt2 entries. */
dc810e39 2828 data.ofs = (data.ofs + 31) & (bfd_vma) -32;
800eeca4 2829
bbe66d08 2830 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_plt2_entries, &data);
800eeca4
JW		 2831 if (data.ofs != 0)
2832 {
2833 BFD_ASSERT (ia64_info->root.dynamic_sections_created);
2834
2835 ia64_info->plt_sec->_raw_size = data.ofs;
2836
2837 /* If we've got a .plt, we need some extra memory for the dynamic
2838 linker. We stuff these in .got.plt. */
2839 sec = bfd_get_section_by_name (dynobj, ".got.plt");
2840 sec->_raw_size = 8 * PLT_RESERVED_WORDS;
2841 }
2842
2843 /* Allocate the PLTOFF entries. */
2844
2845 if (ia64_info->pltoff_sec)
2846 {
2847 data.ofs = 0;
bbe66d08 2848 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_pltoff_entries, &data);
800eeca4
JW		 2849 ia64_info->pltoff_sec->_raw_size = data.ofs;
2850 }
2851
2852 if (ia64_info->root.dynamic_sections_created)
2853 {
2854 /* Allocate space for the dynamic relocations that turned out to be
2855 required. */
2856
b3dfd7fe
JJ		 2857 if (info->shared && ia64_info->self_dtpmod_offset != (bfd_vma) -1)
2858 ia64_info->rel_got_sec->_raw_size += sizeof (ElfNN_External_Rela);
bbe66d08 2859 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries, &data);
800eeca4
JW		 2860 }
2861
2862 /* We have now determined the sizes of the various dynamic sections.
2863 Allocate memory for them. */
2864 for (sec = dynobj->sections; sec != NULL; sec = sec->next)
2865 {
b34976b6 2866 bfd_boolean strip;
800eeca4
JW		 2867
2868 if (!(sec->flags & SEC_LINKER_CREATED))
2869 continue;
2870
2871 /* If we don't need this section, strip it from the output file.
2872 There were several sections primarily related to dynamic
2873 linking that must be create before the linker maps input
2874 sections to output sections. The linker does that before
2875 bfd_elf_size_dynamic_sections is called, and it is that
2876 function which decides whether anything needs to go into
2877 these sections. */
2878
2879 strip = (sec->_raw_size == 0);
2880
2881 if (sec == ia64_info->got_sec)
b34976b6 2882 strip = FALSE;
800eeca4
JW		 2883 else if (sec == ia64_info->rel_got_sec)
2884 {
2885 if (strip)
2886 ia64_info->rel_got_sec = NULL;
2887 else
2888 /* We use the reloc_count field as a counter if we need to
2889 copy relocs into the output file. */
2890 sec->reloc_count = 0;
2891 }
2892 else if (sec == ia64_info->fptr_sec)
2893 {
2894 if (strip)
2895 ia64_info->fptr_sec = NULL;
2896 }
2897 else if (sec == ia64_info->plt_sec)
2898 {
2899 if (strip)
2900 ia64_info->plt_sec = NULL;
2901 }
2902 else if (sec == ia64_info->pltoff_sec)
2903 {
2904 if (strip)
2905 ia64_info->pltoff_sec = NULL;
2906 }
2907 else if (sec == ia64_info->rel_pltoff_sec)
2908 {
2909 if (strip)
2910 ia64_info->rel_pltoff_sec = NULL;
2911 else
2912 {
b34976b6 2913 relplt = TRUE;
800eeca4
JW		 2914 /* We use the reloc_count field as a counter if we need to
2915 copy relocs into the output file. */
2916 sec->reloc_count = 0;
2917 }
2918 }
2919 else
2920 {
2921 const char *name;
2922
2923 /* It's OK to base decisions on the section name, because none
2924 of the dynobj section names depend upon the input files. */
2925 name = bfd_get_section_name (dynobj, sec);
2926
2927 if (strcmp (name, ".got.plt") == 0)
b34976b6 2928 strip = FALSE;
800eeca4
JW		 2929 else if (strncmp (name, ".rel", 4) == 0)
2930 {
2931 if (!strip)
2932 {
800eeca4
JW		 2933 /* We use the reloc_count field as a counter if we need to
2934 copy relocs into the output file. */
2935 sec->reloc_count = 0;
2936 }
2937 }
2938 else
2939 continue;
2940 }
2941
2942 if (strip)
2943 _bfd_strip_section_from_output (info, sec);
2944 else
2945 {
2946 /* Allocate memory for the section contents. */
dc810e39 2947 sec->contents = (bfd_byte *) bfd_zalloc (dynobj, sec->_raw_size);
800eeca4 2948 if (sec->contents == NULL && sec->_raw_size != 0)
b34976b6 2949 return FALSE;
800eeca4
JW		 2950 }
2951 }
2952
2953 if (elf_hash_table (info)->dynamic_sections_created)
2954 {
2955 /* Add some entries to the .dynamic section. We fill in the values
2956 later (in finish_dynamic_sections) but we must add the entries now
2957 so that we get the correct size for the .dynamic section. */
2958
36af4a4e 2959 if (info->executable)
800eeca4
JW		 2960 {
2961 /* The DT_DEBUG entry is filled in by the dynamic linker and used
2962 by the debugger. */
dc810e39
AM		 2963#define add_dynamic_entry(TAG, VAL) \
2964 bfd_elfNN_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
2965
2966 if (!add_dynamic_entry (DT_DEBUG, 0))
b34976b6 2967 return FALSE;
800eeca4
JW		 2968 }
2969
dc810e39 2970 if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE, 0))
b34976b6 2971 return FALSE;
dc810e39 2972 if (!add_dynamic_entry (DT_PLTGOT, 0))
b34976b6 2973 return FALSE;
800eeca4
JW		 2974
2975 if (relplt)
2976 {
dc810e39
AM		 2977 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
2978 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2979 || !add_dynamic_entry (DT_JMPREL, 0))
b34976b6 2980 return FALSE;
800eeca4
JW		 2981 }
2982
dc810e39
AM		 2983 if (!add_dynamic_entry (DT_RELA, 0)
2984 || !add_dynamic_entry (DT_RELASZ, 0)
2985 || !add_dynamic_entry (DT_RELAENT, sizeof (ElfNN_External_Rela)))
b34976b6 2986 return FALSE;
800eeca4 2987
db6751f2 2988 if (ia64_info->reltext)
800eeca4 2989 {
dc810e39 2990 if (!add_dynamic_entry (DT_TEXTREL, 0))
b34976b6 2991 return FALSE;
d6cf2879 2992 info->flags |= DF_TEXTREL;
800eeca4
JW		 2993 }
2994 }
2995
2996 /* ??? Perhaps force __gp local. */
2997
b34976b6 2998 return TRUE;
800eeca4
JW		 2999}
3000
3001static bfd_reloc_status_type
1e738b87 3002elfNN_ia64_install_value (abfd, hit_addr, v, r_type)
800eeca4
JW		 3003 bfd *abfd;
3004 bfd_byte *hit_addr;
1e738b87 3005 bfd_vma v;
800eeca4
JW		 3006 unsigned int r_type;
3007{
3008 const struct ia64_operand *op;
3009 int bigendian = 0, shift = 0;
3010 bfd_vma t0, t1, insn, dword;
3011 enum ia64_opnd opnd;
3012 const char *err;
3013 size_t size = 8;
1e738b87
NC		 3014#ifdef BFD_HOST_U_64_BIT
3015 BFD_HOST_U_64_BIT val = (BFD_HOST_U_64_BIT) v;
3016#else
3017 bfd_vma val = v;
3018#endif
800eeca4
JW		 3019
3020 opnd = IA64_OPND_NIL;
3021 switch (r_type)
3022 {
3023 case R_IA64_NONE:
3024 case R_IA64_LDXMOV:
3025 return bfd_reloc_ok;
3026
3e932841 3027 /* Instruction relocations. */
800eeca4 3028
13ae64f3
JJ		 3029 case R_IA64_IMM14:
3030 case R_IA64_TPREL14:
3031 case R_IA64_DTPREL14:
3032 opnd = IA64_OPND_IMM14;
3033 break;
748abff6 3034
800eeca4
JW		 3035 case R_IA64_PCREL21F: opnd = IA64_OPND_TGT25; break;
3036 case R_IA64_PCREL21M: opnd = IA64_OPND_TGT25b; break;
748abff6
RH		 3037 case R_IA64_PCREL60B: opnd = IA64_OPND_TGT64; break;
3038 case R_IA64_PCREL21B:
3039 case R_IA64_PCREL21BI:
3040 opnd = IA64_OPND_TGT25c;
3041 break;
800eeca4
JW		 3042
3043 case R_IA64_IMM22:
3044 case R_IA64_GPREL22:
3045 case R_IA64_LTOFF22:
3046 case R_IA64_LTOFF22X:
3047 case R_IA64_PLTOFF22:
748abff6 3048 case R_IA64_PCREL22:
800eeca4 3049 case R_IA64_LTOFF_FPTR22:
13ae64f3
JJ		 3050 case R_IA64_TPREL22:
3051 case R_IA64_DTPREL22:
3052 case R_IA64_LTOFF_TPREL22:
3053 case R_IA64_LTOFF_DTPMOD22:
3054 case R_IA64_LTOFF_DTPREL22:
800eeca4
JW		 3055 opnd = IA64_OPND_IMM22;
3056 break;
3057
3058 case R_IA64_IMM64:
3059 case R_IA64_GPREL64I:
3060 case R_IA64_LTOFF64I:
3061 case R_IA64_PLTOFF64I:
748abff6 3062 case R_IA64_PCREL64I:
800eeca4
JW		 3063 case R_IA64_FPTR64I:
3064 case R_IA64_LTOFF_FPTR64I:
13ae64f3
JJ		 3065 case R_IA64_TPREL64I:
3066 case R_IA64_DTPREL64I:
800eeca4
JW		 3067 opnd = IA64_OPND_IMMU64;
3068 break;
3069
3070 /* Data relocations. */
3071
3072 case R_IA64_DIR32MSB:
3073 case R_IA64_GPREL32MSB:
3074 case R_IA64_FPTR32MSB:
3075 case R_IA64_PCREL32MSB:
a4bd8390 3076 case R_IA64_LTOFF_FPTR32MSB:
800eeca4
JW		 3077 case R_IA64_SEGREL32MSB:
3078 case R_IA64_SECREL32MSB:
3079 case R_IA64_LTV32MSB:
13ae64f3 3080 case R_IA64_DTPREL32MSB:
800eeca4
JW		 3081 size = 4; bigendian = 1;
3082 break;
3083
3084 case R_IA64_DIR32LSB:
3085 case R_IA64_GPREL32LSB:
3086 case R_IA64_FPTR32LSB:
3087 case R_IA64_PCREL32LSB:
a4bd8390 3088 case R_IA64_LTOFF_FPTR32LSB:
800eeca4
JW		 3089 case R_IA64_SEGREL32LSB:
3090 case R_IA64_SECREL32LSB:
3091 case R_IA64_LTV32LSB:
13ae64f3 3092 case R_IA64_DTPREL32LSB:
800eeca4
JW		 3093 size = 4; bigendian = 0;
3094 break;
3095
3096 case R_IA64_DIR64MSB:
3097 case R_IA64_GPREL64MSB:
3098 case R_IA64_PLTOFF64MSB:
3099 case R_IA64_FPTR64MSB:
3100 case R_IA64_PCREL64MSB:
3101 case R_IA64_LTOFF_FPTR64MSB:
3102 case R_IA64_SEGREL64MSB:
3103 case R_IA64_SECREL64MSB:
3104 case R_IA64_LTV64MSB:
13ae64f3
JJ		 3105 case R_IA64_TPREL64MSB:
3106 case R_IA64_DTPMOD64MSB:
3107 case R_IA64_DTPREL64MSB:
800eeca4
JW		 3108 size = 8; bigendian = 1;
3109 break;
3110
3111 case R_IA64_DIR64LSB:
3112 case R_IA64_GPREL64LSB:
3113 case R_IA64_PLTOFF64LSB:
3114 case R_IA64_FPTR64LSB:
3115 case R_IA64_PCREL64LSB:
3116 case R_IA64_LTOFF_FPTR64LSB:
3117 case R_IA64_SEGREL64LSB:
3118 case R_IA64_SECREL64LSB:
3119 case R_IA64_LTV64LSB:
13ae64f3
JJ		 3120 case R_IA64_TPREL64LSB:
3121 case R_IA64_DTPMOD64LSB:
3122 case R_IA64_DTPREL64LSB:
800eeca4
JW		 3123 size = 8; bigendian = 0;
3124 break;
3125
3126 /* Unsupported / Dynamic relocations. */
800eeca4
JW		 3127 default:
3128 return bfd_reloc_notsupported;
3129 }
3130
3131 switch (opnd)
3132 {
3133 case IA64_OPND_IMMU64:
3134 hit_addr -= (long) hit_addr & 0x3;
3135 t0 = bfd_get_64 (abfd, hit_addr);
3136 t1 = bfd_get_64 (abfd, hit_addr + 8);
3137
3138 /* tmpl/s: bits 0.. 5 in t0
3139 slot 0: bits 5..45 in t0
3140 slot 1: bits 46..63 in t0, bits 0..22 in t1
3141 slot 2: bits 23..63 in t1 */
3142
3143 /* First, clear the bits that form the 64 bit constant. */
3144 t0 &= ~(0x3ffffLL << 46);
3145 t1 &= ~(0x7fffffLL
3146 | (( (0x07fLL << 13) | (0x1ffLL << 27)
3147 | (0x01fLL << 22) | (0x001LL << 21)
3148 | (0x001LL << 36)) << 23));
3149
3150 t0 |= ((val >> 22) & 0x03ffffLL) << 46; /* 18 lsbs of imm41 */
3151 t1 |= ((val >> 40) & 0x7fffffLL) << 0; /* 23 msbs of imm41 */
3152 t1 |= ( (((val >> 0) & 0x07f) << 13) /* imm7b */
3153 | (((val >> 7) & 0x1ff) << 27) /* imm9d */
3154 | (((val >> 16) & 0x01f) << 22) /* imm5c */
3155 | (((val >> 21) & 0x001) << 21) /* ic */
3156 | (((val >> 63) & 0x001) << 36)) << 23; /* i */
3157
3158 bfd_put_64 (abfd, t0, hit_addr);
3159 bfd_put_64 (abfd, t1, hit_addr + 8);
3160 break;
3161
748abff6
RH		 3162 case IA64_OPND_TGT64:
3163 hit_addr -= (long) hit_addr & 0x3;
3164 t0 = bfd_get_64 (abfd, hit_addr);
3165 t1 = bfd_get_64 (abfd, hit_addr + 8);
3166
3167 /* tmpl/s: bits 0.. 5 in t0
3168 slot 0: bits 5..45 in t0
3169 slot 1: bits 46..63 in t0, bits 0..22 in t1
3170 slot 2: bits 23..63 in t1 */
3171
3172 /* First, clear the bits that form the 64 bit constant. */
3173 t0 &= ~(0x3ffffLL << 46);
3174 t1 &= ~(0x7fffffLL
3175 | ((1LL << 36 | 0xfffffLL << 13) << 23));
3176
3177 val >>= 4;
3178 t0 |= ((val >> 20) & 0xffffLL) << 2 << 46; /* 16 lsbs of imm39 */
3179 t1 |= ((val >> 36) & 0x7fffffLL) << 0; /* 23 msbs of imm39 */
3180 t1 |= ((((val >> 0) & 0xfffffLL) << 13) /* imm20b */
3181 | (((val >> 59) & 0x1LL) << 36)) << 23; /* i */
3182
3183 bfd_put_64 (abfd, t0, hit_addr);
3184 bfd_put_64 (abfd, t1, hit_addr + 8);
3185 break;
3186
800eeca4
JW		 3187 default:
3188 switch ((long) hit_addr & 0x3)
3189 {
3190 case 0: shift = 5; break;
3191 case 1: shift = 14; hit_addr += 3; break;
3192 case 2: shift = 23; hit_addr += 6; break;
3e932841 3193 case 3: return bfd_reloc_notsupported; /* shouldn't happen... */
800eeca4
JW		 3194 }
3195 dword = bfd_get_64 (abfd, hit_addr);
3196 insn = (dword >> shift) & 0x1ffffffffffLL;
3197
3198 op = elf64_ia64_operands + opnd;
1e738b87 3199 err = (*op->insert) (op, val, (ia64_insn *)& insn);
800eeca4
JW		 3200 if (err)
3201 return bfd_reloc_overflow;
3202
3203 dword &= ~(0x1ffffffffffLL << shift);
3204 dword |= (insn << shift);
3205 bfd_put_64 (abfd, dword, hit_addr);
3206 break;
3207
3208 case IA64_OPND_NIL:
3209 /* A data relocation. */
3210 if (bigendian)
3211 if (size == 4)
3212 bfd_putb32 (val, hit_addr);
3213 else
3214 bfd_putb64 (val, hit_addr);
3215 else
3216 if (size == 4)
3217 bfd_putl32 (val, hit_addr);
3218 else
3219 bfd_putl64 (val, hit_addr);
3220 break;
3221 }
3222
3223 return bfd_reloc_ok;
3224}
3225
3226static void
bbe66d08 3227elfNN_ia64_install_dyn_reloc (abfd, info, sec, srel, offset, type,
800eeca4
JW		 3228 dynindx, addend)
3229 bfd *abfd;
3230 struct bfd_link_info *info;
3231 asection *sec;
3232 asection *srel;
3233 bfd_vma offset;
3234 unsigned int type;
3235 long dynindx;
3236 bfd_vma addend;
3237{
3238 Elf_Internal_Rela outrel;
947216bf 3239 bfd_byte *loc;
800eeca4 3240
800eeca4 3241 BFD_ASSERT (dynindx != -1);
bbe66d08 3242 outrel.r_info = ELFNN_R_INFO (dynindx, type);
800eeca4 3243 outrel.r_addend = addend;
c629eae0 3244 outrel.r_offset = _bfd_elf_section_offset (abfd, info, sec, offset);
99eb2ac8 3245 if (outrel.r_offset >= (bfd_vma) -2)
800eeca4 3246 {
c629eae0
JJ		 3247 /* Run for the hills. We shouldn't be outputting a relocation
3248 for this. So do what everyone else does and output a no-op. */
3249 outrel.r_info = ELFNN_R_INFO (0, R_IA64_NONE);
3250 outrel.r_addend = 0;
3251 outrel.r_offset = 0;
800eeca4 3252 }
99eb2ac8
AM		 3253 else
3254 outrel.r_offset += sec->output_section->vma + sec->output_offset;
800eeca4 3255
947216bf
AM		 3256 loc = srel->contents;
3257 loc += srel->reloc_count++ * sizeof (ElfNN_External_Rela);
3258 bfd_elfNN_swap_reloca_out (abfd, &outrel, loc);
3e932841 3259 BFD_ASSERT (sizeof (ElfNN_External_Rela) * srel->reloc_count
800eeca4
JW		 3260 <= srel->_cooked_size);
3261}
3262
3263/* Store an entry for target address TARGET_ADDR in the linkage table
3264 and return the gp-relative address of the linkage table entry. */
3265
3266static bfd_vma
3267set_got_entry (abfd, info, dyn_i, dynindx, addend, value, dyn_r_type)
3268 bfd *abfd;
3269 struct bfd_link_info *info;
bbe66d08 3270 struct elfNN_ia64_dyn_sym_info *dyn_i;
800eeca4
JW		 3271 long dynindx;
3272 bfd_vma addend;
3273 bfd_vma value;
3274 unsigned int dyn_r_type;
3275{
bbe66d08 3276 struct elfNN_ia64_link_hash_table *ia64_info;
800eeca4 3277 asection *got_sec;
b34976b6 3278 bfd_boolean done;
13ae64f3 3279 bfd_vma got_offset;
800eeca4 3280
bbe66d08 3281 ia64_info = elfNN_ia64_hash_table (info);
800eeca4
JW		 3282 got_sec = ia64_info->got_sec;
3283
13ae64f3 3284 switch (dyn_r_type)
800eeca4 3285 {
13ae64f3
JJ		 3286 case R_IA64_TPREL64LSB:
3287 done = dyn_i->tprel_done;
b34976b6 3288 dyn_i->tprel_done = TRUE;
13ae64f3
JJ		 3289 got_offset = dyn_i->tprel_offset;
3290 break;
3291 case R_IA64_DTPMOD64LSB:
b3dfd7fe
JJ		 3292 if (dyn_i->dtpmod_offset != ia64_info->self_dtpmod_offset)
3293 {
3294 done = dyn_i->dtpmod_done;
3295 dyn_i->dtpmod_done = TRUE;
3296 }
3297 else
3298 {
3299 done = ia64_info->self_dtpmod_done;
3300 ia64_info->self_dtpmod_done = TRUE;
3301 dynindx = 0;
3302 }
13ae64f3
JJ		 3303 got_offset = dyn_i->dtpmod_offset;
3304 break;
3305 case R_IA64_DTPREL64LSB:
3306 done = dyn_i->dtprel_done;
b34976b6 3307 dyn_i->dtprel_done = TRUE;
13ae64f3
JJ		 3308 got_offset = dyn_i->dtprel_offset;
3309 break;
3310 default:
3311 done = dyn_i->got_done;
b34976b6 3312 dyn_i->got_done = TRUE;
13ae64f3
JJ		 3313 got_offset = dyn_i->got_offset;
3314 break;
3315 }
800eeca4 3316
13ae64f3
JJ		 3317 BFD_ASSERT ((got_offset & 7) == 0);
3318
3319 if (! done)
3320 {
800eeca4 3321 /* Store the target address in the linkage table entry. */
13ae64f3 3322 bfd_put_64 (abfd, value, got_sec->contents + got_offset);
800eeca4
JW		 3323
3324 /* Install a dynamic relocation if needed. */
9203ba99
JJ		 3325 if (((info->shared
3326 && (!dyn_i->h
3327 || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
3328 || dyn_i->h->root.type != bfd_link_hash_undefweak)
3329 && dyn_r_type != R_IA64_DTPREL64LSB)
986a241f 3330 || elfNN_ia64_dynamic_symbol_p (dyn_i->h, info, dyn_r_type)
9203ba99
JJ		 3331 || (dynindx != -1 && dyn_r_type == R_IA64_FPTR64LSB))
3332 && (!dyn_i->want_ltoff_fptr
3333 || !info->pie
3334 || !dyn_i->h
3335 || dyn_i->h->root.type != bfd_link_hash_undefweak))
800eeca4 3336 {
13ae64f3
JJ		 3337 if (dynindx == -1
3338 && dyn_r_type != R_IA64_TPREL64LSB
3339 && dyn_r_type != R_IA64_DTPMOD64LSB
3340 && dyn_r_type != R_IA64_DTPREL64LSB)
800eeca4
JW		 3341 {
3342 dyn_r_type = R_IA64_REL64LSB;
3343 dynindx = 0;
3344 addend = value;
3345 }
3346
3347 if (bfd_big_endian (abfd))
3348 {
3349 switch (dyn_r_type)
3350 {
3351 case R_IA64_REL64LSB:
3352 dyn_r_type = R_IA64_REL64MSB;
3353 break;
3354 case R_IA64_DIR64LSB:
3355 dyn_r_type = R_IA64_DIR64MSB;
3356 break;
3357 case R_IA64_FPTR64LSB:
3358 dyn_r_type = R_IA64_FPTR64MSB;
3359 break;
13ae64f3
JJ		 3360 case R_IA64_TPREL64LSB:
3361 dyn_r_type = R_IA64_TPREL64MSB;
3362 break;
3363 case R_IA64_DTPMOD64LSB:
3364 dyn_r_type = R_IA64_DTPMOD64MSB;
3365 break;
3366 case R_IA64_DTPREL64LSB:
3367 dyn_r_type = R_IA64_DTPREL64MSB;
3368 break;
800eeca4 3369 default:
b34976b6 3370 BFD_ASSERT (FALSE);
800eeca4
JW		 3371 break;
3372 }
3373 }
3374
bbe66d08 3375 elfNN_ia64_install_dyn_reloc (abfd, NULL, got_sec,
800eeca4 3376 ia64_info->rel_got_sec,
13ae64f3 3377 got_offset, dyn_r_type,
800eeca4
JW		 3378 dynindx, addend);
3379 }
3380 }
3381
3382 /* Return the address of the linkage table entry. */
3383 value = (got_sec->output_section->vma
3384 + got_sec->output_offset
13ae64f3 3385 + got_offset);
800eeca4
JW		 3386
3387 return value;
3388}
3389
3390/* Fill in a function descriptor consisting of the function's code
3391 address and its global pointer. Return the descriptor's address. */
3392
3393static bfd_vma
3394set_fptr_entry (abfd, info, dyn_i, value)
3395 bfd *abfd;
3396 struct bfd_link_info *info;
bbe66d08 3397 struct elfNN_ia64_dyn_sym_info *dyn_i;
800eeca4
JW		 3398 bfd_vma value;
3399{
bbe66d08 3400 struct elfNN_ia64_link_hash_table *ia64_info;
800eeca4
JW		 3401 asection *fptr_sec;
3402
bbe66d08 3403 ia64_info = elfNN_ia64_hash_table (info);
800eeca4
JW		 3404 fptr_sec = ia64_info->fptr_sec;
3405
3406 if (!dyn_i->fptr_done)
3407 {
3408 dyn_i->fptr_done = 1;
3409
3410 /* Fill in the function descriptor. */
3411 bfd_put_64 (abfd, value, fptr_sec->contents + dyn_i->fptr_offset);
3412 bfd_put_64 (abfd, _bfd_get_gp_value (abfd),
3413 fptr_sec->contents + dyn_i->fptr_offset + 8);
9203ba99
JJ		 3414 if (ia64_info->rel_fptr_sec)
3415 {
3416 Elf_Internal_Rela outrel;
3417 bfd_byte *loc;
3418
3419 if (bfd_little_endian (abfd))
3420 outrel.r_info = ELFNN_R_INFO (0, R_IA64_IPLTLSB);
3421 else
3422 outrel.r_info = ELFNN_R_INFO (0, R_IA64_IPLTMSB);
3423 outrel.r_addend = value;
3424 outrel.r_offset = (fptr_sec->output_section->vma
3425 + fptr_sec->output_offset
3426 + dyn_i->fptr_offset);
3427 loc = ia64_info->rel_fptr_sec->contents;
3428 loc += ia64_info->rel_fptr_sec->reloc_count++
3429 * sizeof (ElfNN_External_Rela);
3430 bfd_elfNN_swap_reloca_out (abfd, &outrel, loc);
3431 }
800eeca4
JW		 3432 }
3433
3434 /* Return the descriptor's address. */
3435 value = (fptr_sec->output_section->vma
3436 + fptr_sec->output_offset
3437 + dyn_i->fptr_offset);
3438
3439 return value;
3440}
3441
3442/* Fill in a PLTOFF entry consisting of the function's code address
3443 and its global pointer. Return the descriptor's address. */
3444
3445static bfd_vma
3446set_pltoff_entry (abfd, info, dyn_i, value, is_plt)
3447 bfd *abfd;
3448 struct bfd_link_info *info;
bbe66d08 3449 struct elfNN_ia64_dyn_sym_info *dyn_i;
800eeca4 3450 bfd_vma value;
b34976b6 3451 bfd_boolean is_plt;
800eeca4 3452{
bbe66d08 3453 struct elfNN_ia64_link_hash_table *ia64_info;
800eeca4
JW		 3454 asection *pltoff_sec;
3455
bbe66d08 3456 ia64_info = elfNN_ia64_hash_table (info);
800eeca4
JW		 3457 pltoff_sec = ia64_info->pltoff_sec;
3458
3459 /* Don't do anything if this symbol uses a real PLT entry. In
3460 that case, we'll fill this in during finish_dynamic_symbol. */
3461 if ((! dyn_i->want_plt || is_plt)
3462 && !dyn_i->pltoff_done)
3463 {
18b27f17
RH		 3464 bfd_vma gp = _bfd_get_gp_value (abfd);
3465
800eeca4
JW		 3466 /* Fill in the function descriptor. */
3467 bfd_put_64 (abfd, value, pltoff_sec->contents + dyn_i->pltoff_offset);
18b27f17 3468 bfd_put_64 (abfd, gp, pltoff_sec->contents + dyn_i->pltoff_offset + 8);
800eeca4
JW		 3469
3470 /* Install dynamic relocations if needed. */
ef5aade5
L		 3471 if (!is_plt
3472 && info->shared
3473 && (!dyn_i->h
3474 || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
3475 || dyn_i->h->root.type != bfd_link_hash_undefweak))
800eeca4
JW		 3476 {
3477 unsigned int dyn_r_type;
3478
3479 if (bfd_big_endian (abfd))
3480 dyn_r_type = R_IA64_REL64MSB;
3481 else
3482 dyn_r_type = R_IA64_REL64LSB;
3483
bbe66d08 3484 elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
800eeca4
JW		 3485 ia64_info->rel_pltoff_sec,
3486 dyn_i->pltoff_offset,
18b27f17 3487 dyn_r_type, 0, value);
bbe66d08 3488 elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
800eeca4
JW		 3489 ia64_info->rel_pltoff_sec,
3490 dyn_i->pltoff_offset + 8,
18b27f17 3491 dyn_r_type, 0, gp);
800eeca4
JW		 3492 }
3493
3494 dyn_i->pltoff_done = 1;
3495 }
3496
3497 /* Return the descriptor's address. */
3498 value = (pltoff_sec->output_section->vma
3499 + pltoff_sec->output_offset
3500 + dyn_i->pltoff_offset);
3501
3502 return value;
3503}
3504
13ae64f3
JJ		 3505/* Return the base VMA address which should be subtracted from real addresses
3506 when resolving @tprel() relocation.
3507 Main program TLS (whose template starts at PT_TLS p_vaddr)
3508 is assigned offset round(16, PT_TLS p_align). */
3509
3510static bfd_vma
3511elfNN_ia64_tprel_base (info)
3512 struct bfd_link_info *info;
3513{
3514 struct elf_link_tls_segment *tls_segment
3515 = elf_hash_table (info)->tls_segment;
3516
3517 BFD_ASSERT (tls_segment != NULL);
3518 return (tls_segment->start
3519 - align_power ((bfd_vma) 16, tls_segment->align));
3520}
3521
3522/* Return the base VMA address which should be subtracted from real addresses
3523 when resolving @dtprel() relocation.
3524 This is PT_TLS segment p_vaddr. */
3525
3526static bfd_vma
3527elfNN_ia64_dtprel_base (info)
3528 struct bfd_link_info *info;
3529{
3530 BFD_ASSERT (elf_hash_table (info)->tls_segment != NULL);
3531 return elf_hash_table (info)->tls_segment->start;
3532}
3533
f3b6f7c3 3534/* Called through qsort to sort the .IA_64.unwind section during a
bbe66d08 3535 non-relocatable link. Set elfNN_ia64_unwind_entry_compare_bfd
f3b6f7c3
RH		 3536 to the output bfd so we can do proper endianness frobbing. */
3537
bbe66d08 3538static bfd *elfNN_ia64_unwind_entry_compare_bfd;
f3b6f7c3
RH		 3539
3540static int
bbe66d08 3541elfNN_ia64_unwind_entry_compare (a, b)
cea4409c
AM		 3542 const PTR a;
3543 const PTR b;
f3b6f7c3
RH		 3544{
3545 bfd_vma av, bv;
3546
bbe66d08
JW		 3547 av = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, a);
3548 bv = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, b);
f3b6f7c3
RH		 3549
3550 return (av < bv ? -1 : av > bv ? 1 : 0);
3551}
3552
2c4c2bc0 3553/* Make sure we've got ourselves a nice fat __gp value. */
b34976b6 3554static bfd_boolean
2c4c2bc0 3555elfNN_ia64_choose_gp (abfd, info)
800eeca4
JW		 3556 bfd *abfd;
3557 struct bfd_link_info *info;
3558{
2c4c2bc0
RH		 3559 bfd_vma min_vma = (bfd_vma) -1, max_vma = 0;
3560 bfd_vma min_short_vma = min_vma, max_short_vma = 0;
3561 struct elf_link_hash_entry *gp;
3562 bfd_vma gp_val;
3563 asection *os;
bbe66d08 3564 struct elfNN_ia64_link_hash_table *ia64_info;
9a951beb 3565
bbe66d08 3566 ia64_info = elfNN_ia64_hash_table (info);
800eeca4 3567
2c4c2bc0
RH		 3568 /* Find the min and max vma of all sections marked short. Also collect
3569 min and max vma of any type, for use in selecting a nice gp. */
3570 for (os = abfd->sections; os ; os = os->next)
800eeca4 3571 {
2c4c2bc0 3572 bfd_vma lo, hi;
800eeca4 3573
2c4c2bc0
RH		 3574 if ((os->flags & SEC_ALLOC) == 0)
3575 continue;
3576
3577 lo = os->vma;
3578 hi = os->vma + os->_raw_size;
3579 if (hi < lo)
3580 hi = (bfd_vma) -1;
3581
3582 if (min_vma > lo)
3583 min_vma = lo;
3584 if (max_vma < hi)
3585 max_vma = hi;
3586 if (os->flags & SEC_SMALL_DATA)
800eeca4 3587 {
2c4c2bc0
RH		 3588 if (min_short_vma > lo)
3589 min_short_vma = lo;
3590 if (max_short_vma < hi)
3591 max_short_vma = hi;
3592 }
3593 }
800eeca4 3594
2c4c2bc0
RH		 3595 /* See if the user wants to force a value. */
3596 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
3597 FALSE, FALSE);
800eeca4 3598
2c4c2bc0
RH		 3599 if (gp
3600 && (gp->root.type == bfd_link_hash_defined
3601 || gp->root.type == bfd_link_hash_defweak))
3602 {
3603 asection *gp_sec = gp->root.u.def.section;
3604 gp_val = (gp->root.u.def.value
3605 + gp_sec->output_section->vma
3606 + gp_sec->output_offset);
3607 }
3608 else
3609 {
3610 /* Pick a sensible value. */
800eeca4 3611
2c4c2bc0
RH		 3612 asection *got_sec = ia64_info->got_sec;
3613
3614 /* Start with just the address of the .got. */
3615 if (got_sec)
3616 gp_val = got_sec->output_section->vma;
3617 else if (max_short_vma != 0)
3618 gp_val = min_short_vma;
3619 else
3620 gp_val = min_vma;
3621
3622 /* If it is possible to address the entire image, but we
3623 don't with the choice above, adjust. */
3624 if (max_vma - min_vma < 0x400000
3625 && max_vma - gp_val <= 0x200000
3626 && gp_val - min_vma > 0x200000)
3627 gp_val = min_vma + 0x200000;
3628 else if (max_short_vma != 0)
3629 {
3630 /* If we don't cover all the short data, adjust. */
3631 if (max_short_vma - gp_val >= 0x200000)
3632 gp_val = min_short_vma + 0x200000;
3633
3634 /* If we're addressing stuff past the end, adjust back. */
3635 if (gp_val > max_vma)
3636 gp_val = max_vma - 0x200000 + 8;
800eeca4 3637 }
2c4c2bc0 3638 }
800eeca4 3639
2c4c2bc0
RH		 3640 /* Validate whether all SHF_IA_64_SHORT sections are within
3641 range of the chosen GP. */
800eeca4 3642
2c4c2bc0
RH		 3643 if (max_short_vma != 0)
3644 {
3645 if (max_short_vma - min_short_vma >= 0x400000)
800eeca4 3646 {
2c4c2bc0
RH		 3647 (*_bfd_error_handler)
3648 (_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
3649 bfd_get_filename (abfd),
3650 (unsigned long) (max_short_vma - min_short_vma));
3651 return FALSE;
800eeca4 3652 }
2c4c2bc0
RH		 3653 else if ((gp_val > min_short_vma
3654 && gp_val - min_short_vma > 0x200000)
3655 || (gp_val < max_short_vma
3656 && max_short_vma - gp_val >= 0x200000))
800eeca4 3657 {
2c4c2bc0
RH		 3658 (*_bfd_error_handler)
3659 (_("%s: __gp does not cover short data segment"),
3660 bfd_get_filename (abfd));
3661 return FALSE;
3662 }
3663 }
800eeca4 3664
2c4c2bc0 3665 _bfd_set_gp_value (abfd, gp_val);
800eeca4 3666
2c4c2bc0
RH		 3667 return TRUE;
3668}
800eeca4 3669
2c4c2bc0
RH		 3670static bfd_boolean
3671elfNN_ia64_final_link (abfd, info)
3672 bfd *abfd;
3673 struct bfd_link_info *info;
3674{
3675 struct elfNN_ia64_link_hash_table *ia64_info;
3676 asection *unwind_output_sec;
800eeca4 3677
2c4c2bc0 3678 ia64_info = elfNN_ia64_hash_table (info);
800eeca4 3679
2c4c2bc0 3680 /* Make sure we've got ourselves a nice fat __gp value. */
1049f94e 3681 if (!info->relocatable)
2c4c2bc0
RH		 3682 {
3683 bfd_vma gp_val = _bfd_get_gp_value (abfd);
3684 struct elf_link_hash_entry *gp;
3685
3686 if (gp_val == 0)
800eeca4 3687 {
2c4c2bc0
RH		 3688 if (! elfNN_ia64_choose_gp (abfd, info))
3689 return FALSE;
3690 gp_val = _bfd_get_gp_value (abfd);
800eeca4
JW		 3691 }
3692
2c4c2bc0
RH		 3693 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
3694 FALSE, FALSE);
b4adccfd
RH		 3695 if (gp)
3696 {
3697 gp->root.type = bfd_link_hash_defined;
3698 gp->root.u.def.value = gp_val;
3699 gp->root.u.def.section = bfd_abs_section_ptr;
3700 }
800eeca4
JW		 3701 }
3702
f3b6f7c3 3703 /* If we're producing a final executable, we need to sort the contents
9a951beb
RH		 3704 of the .IA_64.unwind section. Force this section to be relocated
3705 into memory rather than written immediately to the output file. */
3706 unwind_output_sec = NULL;
1049f94e 3707 if (!info->relocatable)
f3b6f7c3
RH		 3708 {
3709 asection *s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind);
3710 if (s)
3711 {
9a951beb
RH		 3712 unwind_output_sec = s->output_section;
3713 unwind_output_sec->contents
3714 = bfd_malloc (unwind_output_sec->_raw_size);
3715 if (unwind_output_sec->contents == NULL)
b34976b6 3716 return FALSE;
9a951beb
RH		 3717 }
3718 }
f3b6f7c3 3719
9a951beb
RH		 3720 /* Invoke the regular ELF backend linker to do all the work. */
3721 if (!bfd_elfNN_bfd_final_link (abfd, info))
b34976b6 3722 return FALSE;
f3b6f7c3 3723
9a951beb
RH		 3724 if (unwind_output_sec)
3725 {
3726 elfNN_ia64_unwind_entry_compare_bfd = abfd;
dc810e39
AM		 3727 qsort (unwind_output_sec->contents,
3728 (size_t) (unwind_output_sec->_raw_size / 24),
3729 24,
3730 elfNN_ia64_unwind_entry_compare);
9a951beb
RH		 3731
3732 if (! bfd_set_section_contents (abfd, unwind_output_sec,
dc810e39 3733 unwind_output_sec->contents, (bfd_vma) 0,
9a951beb 3734 unwind_output_sec->_raw_size))
b34976b6 3735 return FALSE;
f3b6f7c3
RH		 3736 }
3737
b34976b6 3738 return TRUE;
800eeca4
JW		 3739}
3740
b34976b6 3741static bfd_boolean
bbe66d08 3742elfNN_ia64_relocate_section (output_bfd, info, input_bfd, input_section,
800eeca4
JW		 3743 contents, relocs, local_syms, local_sections)
3744 bfd *output_bfd;
3745 struct bfd_link_info *info;
3746 bfd *input_bfd;
3747 asection *input_section;
3748 bfd_byte *contents;
3749 Elf_Internal_Rela *relocs;
3750 Elf_Internal_Sym *local_syms;
3751 asection **local_sections;
3752{
bbe66d08 3753 struct elfNN_ia64_link_hash_table *ia64_info;
800eeca4
JW		 3754 Elf_Internal_Shdr *symtab_hdr;
3755 Elf_Internal_Rela *rel;
3756 Elf_Internal_Rela *relend;
3757 asection *srel;
b34976b6 3758 bfd_boolean ret_val = TRUE; /* for non-fatal errors */
800eeca4
JW		 3759 bfd_vma gp_val;
3760
3761 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
bbe66d08 3762 ia64_info = elfNN_ia64_hash_table (info);
800eeca4
JW		 3763
3764 /* Infect various flags from the input section to the output section. */
1049f94e 3765 if (info->relocatable)
800eeca4
JW		 3766 {
3767 bfd_vma flags;
3768
3769 flags = elf_section_data(input_section)->this_hdr.sh_flags;
3770 flags &= SHF_IA_64_NORECOV;
3771
3772 elf_section_data(input_section->output_section)
3773 ->this_hdr.sh_flags |= flags;
b34976b6 3774 return TRUE;
800eeca4
JW		 3775 }
3776
3777 gp_val = _bfd_get_gp_value (output_bfd);
b34976b6 3778 srel = get_reloc_section (input_bfd, ia64_info, input_section, FALSE);
800eeca4
JW		 3779
3780 rel = relocs;
3781 relend = relocs + input_section->reloc_count;
3782 for (; rel < relend; ++rel)
3783 {
3784 struct elf_link_hash_entry *h;
bbe66d08 3785 struct elfNN_ia64_dyn_sym_info *dyn_i;
800eeca4
JW		 3786 bfd_reloc_status_type r;
3787 reloc_howto_type *howto;
3788 unsigned long r_symndx;
3789 Elf_Internal_Sym *sym;
3790 unsigned int r_type;
3791 bfd_vma value;
3792 asection *sym_sec;
3793 bfd_byte *hit_addr;
b34976b6
AM		 3794 bfd_boolean dynamic_symbol_p;
3795 bfd_boolean undef_weak_ref;
800eeca4 3796
bbe66d08 3797 r_type = ELFNN_R_TYPE (rel->r_info);
800eeca4
JW		 3798 if (r_type > R_IA64_MAX_RELOC_CODE)
3799 {
3800 (*_bfd_error_handler)
3801 (_("%s: unknown relocation type %d"),
8f615d07 3802 bfd_archive_filename (input_bfd), (int)r_type);
800eeca4 3803 bfd_set_error (bfd_error_bad_value);
b34976b6 3804 ret_val = FALSE;
800eeca4
JW		 3805 continue;
3806 }
b491616a 3807
800eeca4 3808 howto = lookup_howto (r_type);
bbe66d08 3809 r_symndx = ELFNN_R_SYM (rel->r_info);
800eeca4
JW		 3810 h = NULL;
3811 sym = NULL;
3812 sym_sec = NULL;
b34976b6 3813 undef_weak_ref = FALSE;
800eeca4
JW		 3814
3815 if (r_symndx < symtab_hdr->sh_info)
3816 {
3817 /* Reloc against local symbol. */
3818 sym = local_syms + r_symndx;
3819 sym_sec = local_sections[r_symndx];
f8df10f4 3820 value = _bfd_elf_rela_local_sym (output_bfd, sym, sym_sec, rel);
f7460f5f
JJ		 3821 if ((sym_sec->flags & SEC_MERGE)
3822 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
68bfbfcc 3823 && sym_sec->sec_info_type == ELF_INFO_TYPE_MERGE)
f7460f5f
JJ		 3824 {
3825 struct elfNN_ia64_local_hash_entry *loc_h;
b34976b6
AM		 3826
3827 loc_h = get_local_sym_hash (ia64_info, input_bfd, rel, FALSE);
f7460f5f
JJ		 3828 if (loc_h && ! loc_h->sec_merge_done)
3829 {
3830 struct elfNN_ia64_dyn_sym_info *dynent;
3831 asection *msec;
3832
3833 for (dynent = loc_h->info; dynent; dynent = dynent->next)
3834 {
3835 msec = sym_sec;
3836 dynent->addend =
3837 _bfd_merged_section_offset (output_bfd, &msec,
3838 elf_section_data (msec)->
65765700 3839 sec_info,
f7460f5f
JJ		 3840 sym->st_value
3841 + dynent->addend,
3842 (bfd_vma) 0);
3843 dynent->addend -= sym->st_value;
3844 dynent->addend += msec->output_section->vma
3845 + msec->output_offset
3846 - sym_sec->output_section->vma
3847 - sym_sec->output_offset;
3848 }
3849 loc_h->sec_merge_done = 1;
3850 }
3851 }
800eeca4
JW		 3852 }
3853 else
3854 {
3855 long indx;
3856
3857 /* Reloc against global symbol. */
3858 indx = r_symndx - symtab_hdr->sh_info;
3859 h = elf_sym_hashes (input_bfd)[indx];
3860 while (h->root.type == bfd_link_hash_indirect
3861 || h->root.type == bfd_link_hash_warning)
3862 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3863
3864 value = 0;
3865 if (h->root.type == bfd_link_hash_defined
3866 || h->root.type == bfd_link_hash_defweak)
3867 {
3868 sym_sec = h->root.u.def.section;
3869
3870 /* Detect the cases that sym_sec->output_section is
3871 expected to be NULL -- all cases in which the symbol
3872 is defined in another shared module. This includes
3873 PLT relocs for which we've created a PLT entry and
3874 other relocs for which we're prepared to create
3875 dynamic relocations. */
3876 /* ??? Just accept it NULL and continue. */
3877
3878 if (sym_sec->output_section != NULL)
3879 {
3880 value = (h->root.u.def.value
3881 + sym_sec->output_section->vma
3882 + sym_sec->output_offset);
3883 }
3884 }
3885 else if (h->root.type == bfd_link_hash_undefweak)
b34976b6 3886 undef_weak_ref = TRUE;
9203ba99 3887 else if (! info->executable
3a27a730
L		 3888 && !info->no_undefined
3889 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
800eeca4
JW		 3890 ;
3891 else
3892 {
3893 if (! ((*info->callbacks->undefined_symbol)
3894 (info, h->root.root.string, input_bfd,
3895 input_section, rel->r_offset,
3a27a730
L		 3896 (!info->shared || info->no_undefined
3897 || ELF_ST_VISIBILITY (h->other)))))
b34976b6 3898 return FALSE;
800eeca4
JW		 3899 continue;
3900 }
3901 }
3902
3903 hit_addr = contents + rel->r_offset;
3904 value += rel->r_addend;
986a241f 3905 dynamic_symbol_p = elfNN_ia64_dynamic_symbol_p (h, info, r_type);
800eeca4
JW		 3906
3907 switch (r_type)
3908 {
3909 case R_IA64_NONE:
3910 case R_IA64_LDXMOV:
3911 continue;
3912
3913 case R_IA64_IMM14:
3914 case R_IA64_IMM22:
3915 case R_IA64_IMM64:
3916 case R_IA64_DIR32MSB:
3917 case R_IA64_DIR32LSB:
3918 case R_IA64_DIR64MSB:
3919 case R_IA64_DIR64LSB:
3920 /* Install a dynamic relocation for this reloc. */
02e6ad56 3921 if ((dynamic_symbol_p || info->shared)
ec338859 3922 && r_symndx != 0
800eeca4
JW		 3923 && (input_section->flags & SEC_ALLOC) != 0)
3924 {
3925 unsigned int dyn_r_type;
3926 long dynindx;
18b27f17 3927 bfd_vma addend;
800eeca4
JW		 3928
3929 BFD_ASSERT (srel != NULL);
3930
3931 /* If we don't need dynamic symbol lookup, find a
3932 matching RELATIVE relocation. */
3933 dyn_r_type = r_type;
986a241f 3934 if (dynamic_symbol_p)
18b27f17
RH		 3935 {
3936 dynindx = h->dynindx;
3937 addend = rel->r_addend;
3938 value = 0;
3939 }
800eeca4
JW		 3940 else
3941 {
3942 switch (r_type)
3943 {
3944 case R_IA64_DIR32MSB:
3945 dyn_r_type = R_IA64_REL32MSB;
3946 break;
3947 case R_IA64_DIR32LSB:
3948 dyn_r_type = R_IA64_REL32LSB;
3949 break;
3950 case R_IA64_DIR64MSB:
3951 dyn_r_type = R_IA64_REL64MSB;
3952 break;
3953 case R_IA64_DIR64LSB:
3954 dyn_r_type = R_IA64_REL64LSB;
3955 break;
3956
3957 default:
3958 /* We can't represent this without a dynamic symbol.
3959 Adjust the relocation to be against an output
3960 section symbol, which are always present in the
3961 dynamic symbol table. */
3962 /* ??? People shouldn't be doing non-pic code in
3963 shared libraries. Hork. */
3964 (*_bfd_error_handler)
3965 (_("%s: linking non-pic code in a shared library"),
8f615d07 3966 bfd_archive_filename (input_bfd));
b34976b6 3967 ret_val = FALSE;
800eeca4
JW		 3968 continue;
3969 }
3970 dynindx = 0;
18b27f17 3971 addend = value;
800eeca4
JW		 3972 }
3973
bbe66d08 3974 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
800eeca4 3975 srel, rel->r_offset, dyn_r_type,
18b27f17 3976 dynindx, addend);
800eeca4 3977 }
ae9a127f 3978 /* Fall through. */
800eeca4
JW		 3979
3980 case R_IA64_LTV32MSB:
3981 case R_IA64_LTV32LSB:
3982 case R_IA64_LTV64MSB:
3983 case R_IA64_LTV64LSB:
bbe66d08 3984 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
800eeca4
JW		 3985 break;
3986
3987 case R_IA64_GPREL22:
3988 case R_IA64_GPREL64I:
3989 case R_IA64_GPREL32MSB:
3990 case R_IA64_GPREL32LSB:
3991 case R_IA64_GPREL64MSB:
3992 case R_IA64_GPREL64LSB:
3993 if (dynamic_symbol_p)
3994 {
3995 (*_bfd_error_handler)
3996 (_("%s: @gprel relocation against dynamic symbol %s"),
8f615d07 3997 bfd_archive_filename (input_bfd), h->root.root.string);
b34976b6 3998 ret_val = FALSE;
800eeca4
JW		 3999 continue;
4000 }
4001 value -= gp_val;
bbe66d08 4002 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
800eeca4
JW		 4003 break;
4004
4005 case R_IA64_LTOFF22:
4006 case R_IA64_LTOFF22X:
4007 case R_IA64_LTOFF64I:
b34976b6 4008 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
800eeca4
JW		 4009 value = set_got_entry (input_bfd, info, dyn_i, (h ? h->dynindx : -1),
4010 rel->r_addend, value, R_IA64_DIR64LSB);
4011 value -= gp_val;
bbe66d08 4012 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
800eeca4
JW		 4013 break;
4014
4015 case R_IA64_PLTOFF22:
4016 case R_IA64_PLTOFF64I:
4017 case R_IA64_PLTOFF64MSB:
4018 case R_IA64_PLTOFF64LSB:
b34976b6
AM		 4019 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4020 value = set_pltoff_entry (output_bfd, info, dyn_i, value, FALSE);
800eeca4 4021 value -= gp_val;
bbe66d08 4022 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
800eeca4
JW		 4023 break;
4024
4025 case R_IA64_FPTR64I:
4026 case R_IA64_FPTR32MSB:
4027 case R_IA64_FPTR32LSB:
4028 case R_IA64_FPTR64MSB:
4029 case R_IA64_FPTR64LSB:
b34976b6 4030 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
800eeca4
JW		 4031 if (dyn_i->want_fptr)
4032 {
4033 if (!undef_weak_ref)
4034 value = set_fptr_entry (output_bfd, info, dyn_i, value);
4035 }
9203ba99 4036 if (!dyn_i->want_fptr || info->pie)
800eeca4
JW		 4037 {
4038 long dynindx;
9203ba99
JJ		 4039 unsigned int dyn_r_type = r_type;
4040 bfd_vma addend = rel->r_addend;
800eeca4
JW		 4041
4042 /* Otherwise, we expect the dynamic linker to create
4043 the entry. */
4044
9203ba99
JJ		 4045 if (dyn_i->want_fptr)
4046 {
4047 if (r_type == R_IA64_FPTR64I)
4048 {
4049 /* We can't represent this without a dynamic symbol.
4050 Adjust the relocation to be against an output
4051 section symbol, which are always present in the
4052 dynamic symbol table. */
4053 /* ??? People shouldn't be doing non-pic code in
4054 shared libraries. Hork. */
4055 (*_bfd_error_handler)
4056 (_("%s: linking non-pic code in a position independent executable"),
4057 bfd_archive_filename (input_bfd));
4058 ret_val = FALSE;
4059 continue;
4060 }
4061 dynindx = 0;
4062 addend = value;
4063 dyn_r_type = r_type + R_IA64_REL64LSB - R_IA64_FPTR64LSB;
4064 }
4065 else if (h)
800eeca4
JW		 4066 {
4067 if (h->dynindx != -1)
4068 dynindx = h->dynindx;
4069 else
4070 dynindx = (_bfd_elf_link_lookup_local_dynindx
4071 (info, h->root.u.def.section->owner,
4072 global_sym_index (h)));
9203ba99 4073 value = 0;
800eeca4
JW		 4074 }
4075 else
4076 {
4077 dynindx = (_bfd_elf_link_lookup_local_dynindx
dc810e39 4078 (info, input_bfd, (long) r_symndx));
9203ba99 4079 value = 0;
800eeca4
JW		 4080 }
4081
bbe66d08 4082 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
9203ba99
JJ		 4083 srel, rel->r_offset, dyn_r_type,
4084 dynindx, addend);
800eeca4
JW		 4085 }
4086
bbe66d08 4087 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
800eeca4
JW		 4088 break;
4089
4090 case R_IA64_LTOFF_FPTR22:
4091 case R_IA64_LTOFF_FPTR64I:
a4bd8390
JW		 4092 case R_IA64_LTOFF_FPTR32MSB:
4093 case R_IA64_LTOFF_FPTR32LSB:
800eeca4
JW		 4094 case R_IA64_LTOFF_FPTR64MSB:
4095 case R_IA64_LTOFF_FPTR64LSB:
4096 {
4097 long dynindx;
4098
b34976b6 4099 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
800eeca4
JW		 4100 if (dyn_i->want_fptr)
4101 {
4102 BFD_ASSERT (h == NULL || h->dynindx == -1)
4103 if (!undef_weak_ref)
4104 value = set_fptr_entry (output_bfd, info, dyn_i, value);
4105 dynindx = -1;
4106 }
4107 else
4108 {
4109 /* Otherwise, we expect the dynamic linker to create
4110 the entry. */
4111 if (h)
4112 {
4113 if (h->dynindx != -1)
4114 dynindx = h->dynindx;
4115 else
4116 dynindx = (_bfd_elf_link_lookup_local_dynindx
4117 (info, h->root.u.def.section->owner,
4118 global_sym_index (h)));
4119 }
4120 else
4121 dynindx = (_bfd_elf_link_lookup_local_dynindx
dc810e39 4122 (info, input_bfd, (long) r_symndx));
800eeca4
JW		 4123 value = 0;
4124 }
4125
4126 value = set_got_entry (output_bfd, info, dyn_i, dynindx,
4127 rel->r_addend, value, R_IA64_FPTR64LSB);
4128 value -= gp_val;
bbe66d08 4129 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
800eeca4
JW		 4130 }
4131 break;
4132
4133 case R_IA64_PCREL32MSB:
4134 case R_IA64_PCREL32LSB:
4135 case R_IA64_PCREL64MSB:
4136 case R_IA64_PCREL64LSB:
4137 /* Install a dynamic relocation for this reloc. */
02e6ad56 4138 if (dynamic_symbol_p && r_symndx != 0)
800eeca4
JW		 4139 {
4140 BFD_ASSERT (srel != NULL);
4141
bbe66d08 4142 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
800eeca4
JW		 4143 srel, rel->r_offset, r_type,
4144 h->dynindx, rel->r_addend);
4145 }
4146 goto finish_pcrel;
4147
800eeca4 4148 case R_IA64_PCREL21B:
748abff6 4149 case R_IA64_PCREL60B:
800eeca4 4150 /* We should have created a PLT entry for any dynamic symbol. */
800eeca4
JW		 4151 dyn_i = NULL;
4152 if (h)
b34976b6 4153 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE);
800eeca4
JW		 4154
4155 if (dyn_i && dyn_i->want_plt2)
4156 {
4157 /* Should have caught this earlier. */
4158 BFD_ASSERT (rel->r_addend == 0);
4159
4160 value = (ia64_info->plt_sec->output_section->vma
4161 + ia64_info->plt_sec->output_offset
4162 + dyn_i->plt2_offset);
4163 }
4164 else
4165 {
4166 /* Since there's no PLT entry, Validate that this is
4167 locally defined. */
4168 BFD_ASSERT (undef_weak_ref || sym_sec->output_section != NULL);
4169
4170 /* If the symbol is undef_weak, we shouldn't be trying
4171 to call it. There's every chance that we'd wind up
4172 with an out-of-range fixup here. Don't bother setting
4173 any value at all. */
4174 if (undef_weak_ref)
4175 continue;
4176 }
4177 goto finish_pcrel;
4178
2f9bd3f6
RH		 4179 case R_IA64_PCREL21BI:
4180 case R_IA64_PCREL21F:
4181 case R_IA64_PCREL21M:
748abff6
RH		 4182 case R_IA64_PCREL22:
4183 case R_IA64_PCREL64I:
2f9bd3f6
RH		 4184 /* The PCREL21BI reloc is specifically not intended for use with
4185 dynamic relocs. PCREL21F and PCREL21M are used for speculation
4186 fixup code, and thus probably ought not be dynamic. The
4187 PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs. */
4188 if (dynamic_symbol_p)
4189 {
4190 const char *msg;
4191
4192 if (r_type == R_IA64_PCREL21BI)
4193 msg = _("%s: @internal branch to dynamic symbol %s");
4194 else if (r_type == R_IA64_PCREL21F || r_type == R_IA64_PCREL21M)
4195 msg = _("%s: speculation fixup to dynamic symbol %s");
4196 else
4197 msg = _("%s: @pcrel relocation against dynamic symbol %s");
4198 (*_bfd_error_handler) (msg, bfd_archive_filename (input_bfd),
4199 h->root.root.string);
4200 ret_val = FALSE;
4201 continue;
4202 }
4203 goto finish_pcrel;
4204
800eeca4
JW		 4205 finish_pcrel:
4206 /* Make pc-relative. */
4207 value -= (input_section->output_section->vma
4208 + input_section->output_offset
4209 + rel->r_offset) & ~ (bfd_vma) 0x3;
bbe66d08 4210 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
800eeca4
JW		 4211 break;
4212
4213 case R_IA64_SEGREL32MSB:
4214 case R_IA64_SEGREL32LSB:
4215 case R_IA64_SEGREL64MSB:
4216 case R_IA64_SEGREL64LSB:
d7458677
AM		 4217 if (r_symndx == 0)
4218 {
4219 /* If the input section was discarded from the output, then
4220 do nothing. */
4221 r = bfd_reloc_ok;
4222 }
4223 else
4224 {
4225 struct elf_segment_map *m;
4226 Elf_Internal_Phdr *p;
4227
4228 /* Find the segment that contains the output_section. */
4229 for (m = elf_tdata (output_bfd)->segment_map,
4230 p = elf_tdata (output_bfd)->phdr;
4231 m != NULL;
4232 m = m->next, p++)
4233 {
4234 int i;
4235 for (i = m->count - 1; i >= 0; i--)
9f1c3a0a 4236 if (m->sections[i] == input_section->output_section)
d7458677
AM		 4237 break;
4238 if (i >= 0)
800eeca4 4239 break;
d7458677 4240 }
800eeca4 4241
d7458677
AM		 4242 if (m == NULL)
4243 {
800eeca4 4244 r = bfd_reloc_notsupported;
d7458677
AM		 4245 }
4246 else
4247 {
4248 /* The VMA of the segment is the vaddr of the associated
4249 program header. */
4250 if (value > p->p_vaddr)
4251 value -= p->p_vaddr;
4252 else
4253 value = 0;
4254 r = elfNN_ia64_install_value (output_bfd, hit_addr, value,
4255 r_type);
4256 }
4257 break;
4258 }
800eeca4
JW		 4259
4260 case R_IA64_SECREL32MSB:
4261 case R_IA64_SECREL32LSB:
4262 case R_IA64_SECREL64MSB:
4263 case R_IA64_SECREL64LSB:
4264 /* Make output-section relative. */
4265 if (value > input_section->output_section->vma)
4266 value -= input_section->output_section->vma;
4267 else
4268 value = 0;
bbe66d08 4269 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
800eeca4
JW		 4270 break;
4271
800eeca4
JW		 4272 case R_IA64_IPLTMSB:
4273 case R_IA64_IPLTLSB:
18b27f17
RH		 4274 /* Install a dynamic relocation for this reloc. */
4275 if ((dynamic_symbol_p || info->shared)
4276 && (input_section->flags & SEC_ALLOC) != 0)
4277 {
18b27f17
RH		 4278 BFD_ASSERT (srel != NULL);
4279
4280 /* If we don't need dynamic symbol lookup, install two
4281 RELATIVE relocations. */
986a241f 4282 if (!dynamic_symbol_p)
18b27f17
RH		 4283 {
4284 unsigned int dyn_r_type;
3e932841 4285
18b27f17
RH		 4286 if (r_type == R_IA64_IPLTMSB)
4287 dyn_r_type = R_IA64_REL64MSB;
4288 else
4289 dyn_r_type = R_IA64_REL64LSB;
4290
4291 elfNN_ia64_install_dyn_reloc (output_bfd, info,
4292 input_section,
4293 srel, rel->r_offset,
4294 dyn_r_type, 0, value);
4295 elfNN_ia64_install_dyn_reloc (output_bfd, info,
4296 input_section,
4297 srel, rel->r_offset + 8,
4298 dyn_r_type, 0, gp_val);
4299 }
4300 else
4301 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4302 srel, rel->r_offset, r_type,
4303 h->dynindx, rel->r_addend);
4304 }
4305
4306 if (r_type == R_IA64_IPLTMSB)
4307 r_type = R_IA64_DIR64MSB;
4308 else
4309 r_type = R_IA64_DIR64LSB;
4310 elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4311 r = elfNN_ia64_install_value (output_bfd, hit_addr + 8, gp_val,
4312 r_type);
4313 break;
800eeca4 4314
13ae64f3
JJ		 4315 case R_IA64_TPREL14:
4316 case R_IA64_TPREL22:
4317 case R_IA64_TPREL64I:
4318 value -= elfNN_ia64_tprel_base (info);
4319 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4320 break;
4321
4322 case R_IA64_DTPREL14:
4323 case R_IA64_DTPREL22:
4324 case R_IA64_DTPREL64I:
b3dfd7fe
JJ		 4325 case R_IA64_DTPREL64LSB:
4326 case R_IA64_DTPREL64MSB:
13ae64f3
JJ		 4327 value -= elfNN_ia64_dtprel_base (info);
4328 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4329 break;
4330
4331 case R_IA64_LTOFF_TPREL22:
4332 case R_IA64_LTOFF_DTPMOD22:
4333 case R_IA64_LTOFF_DTPREL22:
4334 {
4335 int got_r_type;
a823975a
JJ		 4336 long dynindx = h ? h->dynindx : -1;
4337 bfd_vma r_addend = rel->r_addend;
13ae64f3
JJ		 4338
4339 switch (r_type)
4340 {
4341 default:
4342 case R_IA64_LTOFF_TPREL22:
a823975a
JJ		 4343 if (!dynamic_symbol_p)
4344 {
4345 if (!info->shared)
4346 value -= elfNN_ia64_tprel_base (info);
4347 else
4348 {
4349 r_addend += value - elfNN_ia64_dtprel_base (info);
4350 dynindx = 0;
4351 }
4352 }
13ae64f3
JJ		 4353 got_r_type = R_IA64_TPREL64LSB;
4354 break;
4355 case R_IA64_LTOFF_DTPMOD22:
4356 if (!dynamic_symbol_p && !info->shared)
4357 value = 1;
4358 got_r_type = R_IA64_DTPMOD64LSB;
4359 break;
4360 case R_IA64_LTOFF_DTPREL22:
4361 if (!dynamic_symbol_p)
4362 value -= elfNN_ia64_dtprel_base (info);
4363 got_r_type = R_IA64_DTPREL64LSB;
4364 break;
4365 }
b34976b6 4366 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
a823975a 4367 value = set_got_entry (input_bfd, info, dyn_i, dynindx, r_addend,
13ae64f3
JJ		 4368 value, got_r_type);
4369 value -= gp_val;
4370 r = elfNN_ia64_install_value (output_bfd, hit_addr, value,
4371 r_type);
4372 }
4373 break;
4374
800eeca4
JW		 4375 default:
4376 r = bfd_reloc_notsupported;
4377 break;
4378 }
4379
4380 switch (r)
4381 {
4382 case bfd_reloc_ok:
4383 break;
4384
4385 case bfd_reloc_undefined:
4386 /* This can happen for global table relative relocs if
4387 __gp is undefined. This is a panic situation so we
4388 don't try to continue. */
4389 (*info->callbacks->undefined_symbol)
4390 (info, "__gp", input_bfd, input_section, rel->r_offset, 1);
b34976b6 4391 return FALSE;
800eeca4
JW		 4392
4393 case bfd_reloc_notsupported:
4394 {
4395 const char *name;
4396
4397 if (h)
4398 name = h->root.root.string;
4399 else
4400 {
4401 name = bfd_elf_string_from_elf_section (input_bfd,
4402 symtab_hdr->sh_link,
4403 sym->st_name);
4404 if (name == NULL)
b34976b6 4405 return FALSE;
800eeca4
JW		 4406 if (*name == '\0')
4407 name = bfd_section_name (input_bfd, input_section);
4408 }
4409 if (!(*info->callbacks->warning) (info, _("unsupported reloc"),
4410 name, input_bfd,
4411 input_section, rel->r_offset))
b34976b6
AM		 4412 return FALSE;
4413 ret_val = FALSE;
800eeca4
JW		 4414 }
4415 break;
4416
4417 case bfd_reloc_dangerous:
4418 case bfd_reloc_outofrange:
4419 case bfd_reloc_overflow:
4420 default:
4421 {
4422 const char *name;
4423
4424 if (h)
4425 name = h->root.root.string;
4426 else
4427 {
4428 name = bfd_elf_string_from_elf_section (input_bfd,
4429 symtab_hdr->sh_link,
4430 sym->st_name);
4431 if (name == NULL)
b34976b6 4432 return FALSE;
800eeca4
JW		 4433 if (*name == '\0')
4434 name = bfd_section_name (input_bfd, input_section);
4435 }
4436 if (!(*info->callbacks->reloc_overflow) (info, name,
dc810e39
AM		 4437 howto->name,
4438 (bfd_vma) 0,
800eeca4
JW		 4439 input_bfd,
4440 input_section,
4441 rel->r_offset))
b34976b6
AM		 4442 return FALSE;
4443 ret_val = FALSE;
800eeca4
JW		 4444 }
4445 break;
4446 }
4447 }
4448
4449 return ret_val;
4450}
4451
b34976b6 4452static bfd_boolean
bbe66d08 4453elfNN_ia64_finish_dynamic_symbol (output_bfd, info, h, sym)
800eeca4
JW		 4454 bfd *output_bfd;
4455 struct bfd_link_info *info;
4456 struct elf_link_hash_entry *h;
4457 Elf_Internal_Sym *sym;
4458{
bbe66d08
JW		 4459 struct elfNN_ia64_link_hash_table *ia64_info;
4460 struct elfNN_ia64_dyn_sym_info *dyn_i;
800eeca4 4461
bbe66d08 4462 ia64_info = elfNN_ia64_hash_table (info);
b34976b6 4463 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE);
800eeca4
JW		 4464
4465 /* Fill in the PLT data, if required. */
4466 if (dyn_i && dyn_i->want_plt)
4467 {
4468 Elf_Internal_Rela outrel;
4469 bfd_byte *loc;
4470 asection *plt_sec;
4471 bfd_vma plt_addr, pltoff_addr, gp_val, index;
800eeca4
JW		 4472
4473 gp_val = _bfd_get_gp_value (output_bfd);
4474
4475 /* Initialize the minimal PLT entry. */
4476
4477 index = (dyn_i->plt_offset - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
4478 plt_sec = ia64_info->plt_sec;
4479 loc = plt_sec->contents + dyn_i->plt_offset;
4480
4481 memcpy (loc, plt_min_entry, PLT_MIN_ENTRY_SIZE);
bbe66d08
JW		 4482 elfNN_ia64_install_value (output_bfd, loc, index, R_IA64_IMM22);
4483 elfNN_ia64_install_value (output_bfd, loc+2, -dyn_i->plt_offset,
800eeca4
JW		 4484 R_IA64_PCREL21B);
4485
4486 plt_addr = (plt_sec->output_section->vma
4487 + plt_sec->output_offset
4488 + dyn_i->plt_offset);
b34976b6 4489 pltoff_addr = set_pltoff_entry (output_bfd, info, dyn_i, plt_addr, TRUE);
800eeca4
JW		 4490
4491 /* Initialize the FULL PLT entry, if needed. */
4492 if (dyn_i->want_plt2)
4493 {
4494 loc = plt_sec->contents + dyn_i->plt2_offset;
4495
4496 memcpy (loc, plt_full_entry, PLT_FULL_ENTRY_SIZE);
bbe66d08 4497 elfNN_ia64_install_value (output_bfd, loc, pltoff_addr - gp_val,
800eeca4
JW		 4498 R_IA64_IMM22);
4499
4500 /* Mark the symbol as undefined, rather than as defined in the
4501 plt section. Leave the value alone. */
4502 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
4503 first place. But perhaps elflink.h did some for us. */
4504 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4505 sym->st_shndx = SHN_UNDEF;
4506 }
4507
4508 /* Create the dynamic relocation. */
4509 outrel.r_offset = pltoff_addr;
4510 if (bfd_little_endian (output_bfd))
bbe66d08 4511 outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTLSB);
800eeca4 4512 else
bbe66d08 4513 outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTMSB);
800eeca4
JW		 4514 outrel.r_addend = 0;
4515
4516 /* This is fun. In the .IA_64.pltoff section, we've got entries
4517 that correspond both to real PLT entries, and those that
4518 happened to resolve to local symbols but need to be created
4519 to satisfy @pltoff relocations. The .rela.IA_64.pltoff
4520 relocations for the real PLT should come at the end of the
4521 section, so that they can be indexed by plt entry at runtime.
4522
4523 We emitted all of the relocations for the non-PLT @pltoff
4524 entries during relocate_section. So we can consider the
4525 existing sec->reloc_count to be the base of the array of
4526 PLT relocations. */
4527
947216bf
AM		 4528 loc = ia64_info->rel_pltoff_sec->contents;
4529 loc += ((ia64_info->rel_pltoff_sec->reloc_count + index)
37cd2629 4530 * sizeof (ElfNN_External_Rela));
947216bf 4531 bfd_elfNN_swap_reloca_out (output_bfd, &outrel, loc);
800eeca4
JW		 4532 }
4533
4534 /* Mark some specially defined symbols as absolute. */
4535 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
4536 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
4537 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
4538 sym->st_shndx = SHN_ABS;
4539
b34976b6 4540 return TRUE;
800eeca4
JW		 4541}
4542
b34976b6 4543static bfd_boolean
bbe66d08 4544elfNN_ia64_finish_dynamic_sections (abfd, info)
800eeca4
JW		 4545 bfd *abfd;
4546 struct bfd_link_info *info;
4547{
bbe66d08 4548 struct elfNN_ia64_link_hash_table *ia64_info;
800eeca4
JW		 4549 bfd *dynobj;
4550
bbe66d08 4551 ia64_info = elfNN_ia64_hash_table (info);
800eeca4
JW		 4552 dynobj = ia64_info->root.dynobj;
4553
4554 if (elf_hash_table (info)->dynamic_sections_created)
4555 {
bbe66d08 4556 ElfNN_External_Dyn *dyncon, *dynconend;
800eeca4
JW		 4557 asection *sdyn, *sgotplt;
4558 bfd_vma gp_val;
4559
4560 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4561 sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
4562 BFD_ASSERT (sdyn != NULL);
bbe66d08
JW		 4563 dyncon = (ElfNN_External_Dyn *) sdyn->contents;
4564 dynconend = (ElfNN_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
800eeca4
JW		 4565
4566 gp_val = _bfd_get_gp_value (abfd);
4567
4568 for (; dyncon < dynconend; dyncon++)
4569 {
4570 Elf_Internal_Dyn dyn;
800eeca4 4571
bbe66d08 4572 bfd_elfNN_swap_dyn_in (dynobj, dyncon, &dyn);
800eeca4
JW		 4573
4574 switch (dyn.d_tag)
4575 {
4576 case DT_PLTGOT:
4577 dyn.d_un.d_ptr = gp_val;
4578 break;
4579
4580 case DT_PLTRELSZ:
4581 dyn.d_un.d_val = (ia64_info->minplt_entries
bbe66d08 4582 * sizeof (ElfNN_External_Rela));
800eeca4
JW		 4583 break;
4584
4585 case DT_JMPREL:
4586 /* See the comment above in finish_dynamic_symbol. */
4587 dyn.d_un.d_ptr = (ia64_info->rel_pltoff_sec->output_section->vma
4588 + ia64_info->rel_pltoff_sec->output_offset
4589 + (ia64_info->rel_pltoff_sec->reloc_count
bbe66d08 4590 * sizeof (ElfNN_External_Rela)));
800eeca4
JW		 4591 break;
4592
4593 case DT_IA_64_PLT_RESERVE:
4594 dyn.d_un.d_ptr = (sgotplt->output_section->vma
4595 + sgotplt->output_offset);
4596 break;
4597
4598 case DT_RELASZ:
4599 /* Do not have RELASZ include JMPREL. This makes things
3e932841 4600 easier on ld.so. This is not what the rest of BFD set up. */
800eeca4 4601 dyn.d_un.d_val -= (ia64_info->minplt_entries
bbe66d08 4602 * sizeof (ElfNN_External_Rela));
800eeca4 4603 break;
800eeca4
JW		 4604 }
4605
bbe66d08 4606 bfd_elfNN_swap_dyn_out (abfd, &dyn, dyncon);
800eeca4
JW		 4607 }
4608
ae9a127f 4609 /* Initialize the PLT0 entry. */
800eeca4
JW		 4610 if (ia64_info->plt_sec)
4611 {
4612 bfd_byte *loc = ia64_info->plt_sec->contents;
4613 bfd_vma pltres;
4614
4615 memcpy (loc, plt_header, PLT_HEADER_SIZE);
4616
4617 pltres = (sgotplt->output_section->vma
4618 + sgotplt->output_offset
4619 - gp_val);
4620
bbe66d08 4621 elfNN_ia64_install_value (abfd, loc+1, pltres, R_IA64_GPREL22);
800eeca4
JW		 4622 }
4623 }
4624
b34976b6 4625 return TRUE;
800eeca4
JW		 4626}
4627\f
ae9a127f 4628/* ELF file flag handling: */
800eeca4 4629
3e932841 4630/* Function to keep IA-64 specific file flags. */
b34976b6 4631static bfd_boolean
bbe66d08 4632elfNN_ia64_set_private_flags (abfd, flags)
800eeca4
JW		 4633 bfd *abfd;
4634 flagword flags;
4635{
4636 BFD_ASSERT (!elf_flags_init (abfd)
4637 || elf_elfheader (abfd)->e_flags == flags);
4638
4639 elf_elfheader (abfd)->e_flags = flags;
b34976b6
AM		 4640 elf_flags_init (abfd) = TRUE;
4641 return TRUE;
800eeca4
JW		 4642}
4643
800eeca4
JW		 4644/* Merge backend specific data from an object file to the output
4645 object file when linking. */
b34976b6 4646static bfd_boolean
bbe66d08 4647elfNN_ia64_merge_private_bfd_data (ibfd, obfd)
800eeca4
JW		 4648 bfd *ibfd, *obfd;
4649{
4650 flagword out_flags;
4651 flagword in_flags;
b34976b6 4652 bfd_boolean ok = TRUE;
800eeca4
JW		 4653
4654 /* Don't even pretend to support mixed-format linking. */
4655 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4656 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
b34976b6 4657 return FALSE;
800eeca4
JW		 4658
4659 in_flags = elf_elfheader (ibfd)->e_flags;
4660 out_flags = elf_elfheader (obfd)->e_flags;
4661
4662 if (! elf_flags_init (obfd))
4663 {
b34976b6 4664 elf_flags_init (obfd) = TRUE;
800eeca4
JW		 4665 elf_elfheader (obfd)->e_flags = in_flags;
4666
4667 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
4668 && bfd_get_arch_info (obfd)->the_default)
4669 {
4670 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
4671 bfd_get_mach (ibfd));
4672 }
4673
b34976b6 4674 return TRUE;
800eeca4
JW		 4675 }
4676
4677 /* Check flag compatibility. */
4678 if (in_flags == out_flags)
b34976b6 4679 return TRUE;
800eeca4 4680
c43c2cc5
JW		 4681 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
4682 if (!(in_flags & EF_IA_64_REDUCEDFP) && (out_flags & EF_IA_64_REDUCEDFP))
4683 elf_elfheader (obfd)->e_flags &= ~EF_IA_64_REDUCEDFP;
4684
800eeca4
JW		 4685 if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL))
4686 {
4687 (*_bfd_error_handler)
4688 (_("%s: linking trap-on-NULL-dereference with non-trapping files"),
8f615d07 4689 bfd_archive_filename (ibfd));
800eeca4
JW		 4690
4691 bfd_set_error (bfd_error_bad_value);
b34976b6 4692 ok = FALSE;
800eeca4
JW		 4693 }
4694 if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE))
4695 {
4696 (*_bfd_error_handler)
4697 (_("%s: linking big-endian files with little-endian files"),
8f615d07 4698 bfd_archive_filename (ibfd));
800eeca4
JW		 4699
4700 bfd_set_error (bfd_error_bad_value);
b34976b6 4701 ok = FALSE;
800eeca4
JW		 4702 }
4703 if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64))
4704 {
4705 (*_bfd_error_handler)
4706 (_("%s: linking 64-bit files with 32-bit files"),
8f615d07 4707 bfd_archive_filename (ibfd));
800eeca4
JW		 4708
4709 bfd_set_error (bfd_error_bad_value);
b34976b6 4710 ok = FALSE;
800eeca4 4711 }
c43c2cc5
JW		 4712 if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP))
4713 {
4714 (*_bfd_error_handler)
4715 (_("%s: linking constant-gp files with non-constant-gp files"),
8f615d07 4716 bfd_archive_filename (ibfd));
c43c2cc5
JW		 4717
4718 bfd_set_error (bfd_error_bad_value);
b34976b6 4719 ok = FALSE;
c43c2cc5
JW		 4720 }
4721 if ((in_flags & EF_IA_64_NOFUNCDESC_CONS_GP)
4722 != (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
4723 {
4724 (*_bfd_error_handler)
4725 (_("%s: linking auto-pic files with non-auto-pic files"),
8f615d07 4726 bfd_archive_filename (ibfd));
c43c2cc5
JW		 4727
4728 bfd_set_error (bfd_error_bad_value);
b34976b6 4729 ok = FALSE;
c43c2cc5 4730 }
800eeca4
JW		 4731
4732 return ok;
4733}
4734
b34976b6 4735static bfd_boolean
bbe66d08 4736elfNN_ia64_print_private_bfd_data (abfd, ptr)
800eeca4
JW		 4737 bfd *abfd;
4738 PTR ptr;
4739{
4740 FILE *file = (FILE *) ptr;
4741 flagword flags = elf_elfheader (abfd)->e_flags;
4742
4743 BFD_ASSERT (abfd != NULL && ptr != NULL);
4744
c43c2cc5 4745 fprintf (file, "private flags = %s%s%s%s%s%s%s%s\n",
800eeca4
JW		 4746 (flags & EF_IA_64_TRAPNIL) ? "TRAPNIL, " : "",
4747 (flags & EF_IA_64_EXT) ? "EXT, " : "",
4748 (flags & EF_IA_64_BE) ? "BE, " : "LE, ",
c43c2cc5
JW		 4749 (flags & EF_IA_64_REDUCEDFP) ? "REDUCEDFP, " : "",
4750 (flags & EF_IA_64_CONS_GP) ? "CONS_GP, " : "",
4751 (flags & EF_IA_64_NOFUNCDESC_CONS_GP) ? "NOFUNCDESC_CONS_GP, " : "",
4752 (flags & EF_IA_64_ABSOLUTE) ? "ABSOLUTE, " : "",
800eeca4 4753 (flags & EF_IA_64_ABI64) ? "ABI64" : "ABI32");
3e932841 4754
800eeca4 4755 _bfd_elf_print_private_bfd_data (abfd, ptr);
b34976b6 4756 return TRUE;
800eeca4 4757}
db6751f2
JJ		 4758
4759static enum elf_reloc_type_class
f51e552e
AM		 4760elfNN_ia64_reloc_type_class (rela)
4761 const Elf_Internal_Rela *rela;
db6751f2 4762{
f51e552e 4763 switch ((int) ELFNN_R_TYPE (rela->r_info))
db6751f2
JJ		 4764 {
4765 case R_IA64_REL32MSB:
4766 case R_IA64_REL32LSB:
4767 case R_IA64_REL64MSB:
4768 case R_IA64_REL64LSB:
4769 return reloc_class_relative;
4770 case R_IA64_IPLTMSB:
4771 case R_IA64_IPLTLSB:
4772 return reloc_class_plt;
4773 case R_IA64_COPY:
4774 return reloc_class_copy;
4775 default:
4776 return reloc_class_normal;
4777 }
4778}
fcf12726 4779
2f89ff8d
L		 4780static struct bfd_elf_special_section const elfNN_ia64_special_sections[]=
4781{
4782 { ".sbss", 0, NULL, 0,
4783 SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
4784 { ".sdata", 0, NULL, 0,
4785 SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
4786 { NULL, 0, NULL, 0,
4787 0, 0 }
4788};
4789
b34976b6 4790static bfd_boolean
d9cf1b54
AM		 4791elfNN_ia64_hpux_vec (const bfd_target *vec)
4792{
4793 extern const bfd_target bfd_elfNN_ia64_hpux_big_vec;
4794 return (vec == & bfd_elfNN_ia64_hpux_big_vec);
4795}
4796
fcf12726
AM		 4797static void
4798elfNN_hpux_post_process_headers (abfd, info)
4799 bfd *abfd;
4800 struct bfd_link_info *info ATTRIBUTE_UNUSED;
4801{
4802 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
4803
4804 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_HPUX;
4805 i_ehdrp->e_ident[EI_ABIVERSION] = 1;
4806}
d9cf1b54 4807
b34976b6 4808bfd_boolean
af746e92 4809elfNN_hpux_backend_section_from_bfd_section (abfd, sec, retval)
d9cf1b54 4810 bfd *abfd ATTRIBUTE_UNUSED;
d9cf1b54
AM		 4811 asection *sec;
4812 int *retval;
4813{
4814 if (bfd_is_com_section (sec))
4815 {
4816 *retval = SHN_IA_64_ANSI_COMMON;
b34976b6 4817 return TRUE;
d9cf1b54 4818 }
b34976b6 4819 return FALSE;
d9cf1b54 4820}
800eeca4 4821\f
bbe66d08
JW		 4822#define TARGET_LITTLE_SYM bfd_elfNN_ia64_little_vec
4823#define TARGET_LITTLE_NAME "elfNN-ia64-little"
4824#define TARGET_BIG_SYM bfd_elfNN_ia64_big_vec
4825#define TARGET_BIG_NAME "elfNN-ia64-big"
800eeca4
JW		 4826#define ELF_ARCH bfd_arch_ia64
4827#define ELF_MACHINE_CODE EM_IA_64
4828#define ELF_MACHINE_ALT1 1999 /* EAS2.3 */
4829#define ELF_MACHINE_ALT2 1998 /* EAS2.2 */
4830#define ELF_MAXPAGESIZE 0x10000 /* 64KB */
4831
4832#define elf_backend_section_from_shdr \
bbe66d08 4833 elfNN_ia64_section_from_shdr
fa152c49 4834#define elf_backend_section_flags \
bbe66d08 4835 elfNN_ia64_section_flags
800eeca4 4836#define elf_backend_fake_sections \
bbe66d08 4837 elfNN_ia64_fake_sections
81545d45
RH		 4838#define elf_backend_final_write_processing \
4839 elfNN_ia64_final_write_processing
800eeca4 4840#define elf_backend_add_symbol_hook \
bbe66d08 4841 elfNN_ia64_add_symbol_hook
800eeca4 4842#define elf_backend_additional_program_headers \
bbe66d08 4843 elfNN_ia64_additional_program_headers
800eeca4 4844#define elf_backend_modify_segment_map \
bbe66d08 4845 elfNN_ia64_modify_segment_map
800eeca4 4846#define elf_info_to_howto \
bbe66d08 4847 elfNN_ia64_info_to_howto
800eeca4 4848
bbe66d08
JW		 4849#define bfd_elfNN_bfd_reloc_type_lookup \
4850 elfNN_ia64_reloc_type_lookup
4851#define bfd_elfNN_bfd_is_local_label_name \
4852 elfNN_ia64_is_local_label_name
4853#define bfd_elfNN_bfd_relax_section \
4854 elfNN_ia64_relax_section
800eeca4
JW		 4855
4856/* Stuff for the BFD linker: */
bbe66d08
JW		 4857#define bfd_elfNN_bfd_link_hash_table_create \
4858 elfNN_ia64_hash_table_create
800eeca4 4859#define elf_backend_create_dynamic_sections \
bbe66d08 4860 elfNN_ia64_create_dynamic_sections
800eeca4 4861#define elf_backend_check_relocs \
bbe66d08 4862 elfNN_ia64_check_relocs
800eeca4 4863#define elf_backend_adjust_dynamic_symbol \
bbe66d08 4864 elfNN_ia64_adjust_dynamic_symbol
800eeca4 4865#define elf_backend_size_dynamic_sections \
bbe66d08 4866 elfNN_ia64_size_dynamic_sections
800eeca4 4867#define elf_backend_relocate_section \
bbe66d08 4868 elfNN_ia64_relocate_section
800eeca4 4869#define elf_backend_finish_dynamic_symbol \
bbe66d08 4870 elfNN_ia64_finish_dynamic_symbol
800eeca4 4871#define elf_backend_finish_dynamic_sections \
bbe66d08
JW		 4872 elfNN_ia64_finish_dynamic_sections
4873#define bfd_elfNN_bfd_final_link \
4874 elfNN_ia64_final_link
4875
bbe66d08
JW		 4876#define bfd_elfNN_bfd_merge_private_bfd_data \
4877 elfNN_ia64_merge_private_bfd_data
4878#define bfd_elfNN_bfd_set_private_flags \
4879 elfNN_ia64_set_private_flags
4880#define bfd_elfNN_bfd_print_private_bfd_data \
4881 elfNN_ia64_print_private_bfd_data
800eeca4
JW		 4882
4883#define elf_backend_plt_readonly 1
4884#define elf_backend_want_plt_sym 0
4885#define elf_backend_plt_alignment 5
4886#define elf_backend_got_header_size 0
4887#define elf_backend_plt_header_size PLT_HEADER_SIZE
4888#define elf_backend_want_got_plt 1
4889#define elf_backend_may_use_rel_p 1
4890#define elf_backend_may_use_rela_p 1
4891#define elf_backend_default_use_rela_p 1
4892#define elf_backend_want_dynbss 0
bbe66d08
JW		 4893#define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect
4894#define elf_backend_hide_symbol elfNN_ia64_hash_hide_symbol
db6751f2 4895#define elf_backend_reloc_type_class elfNN_ia64_reloc_type_class
b491616a 4896#define elf_backend_rela_normal 1
2f89ff8d 4897#define elf_backend_special_sections elfNN_ia64_special_sections
800eeca4 4898
bbe66d08 4899#include "elfNN-target.h"
7b6dab7f 4900
fcf12726
AM		 4901/* HPUX-specific vectors. */
4902
4903#undef TARGET_LITTLE_SYM
4904#undef TARGET_LITTLE_NAME
4905#undef TARGET_BIG_SYM
4906#define TARGET_BIG_SYM bfd_elfNN_ia64_hpux_big_vec
4907#undef TARGET_BIG_NAME
4908#define TARGET_BIG_NAME "elfNN-ia64-hpux-big"
4909
254ed743
NC		 4910/* These are HP-UX specific functions. */
4911
fcf12726
AM		 4912#undef elf_backend_post_process_headers
4913#define elf_backend_post_process_headers elfNN_hpux_post_process_headers
4914
d9cf1b54
AM		 4915#undef elf_backend_section_from_bfd_section
4916#define elf_backend_section_from_bfd_section elfNN_hpux_backend_section_from_bfd_section
4917
5e8d7549
NC		 4918#undef elf_backend_want_p_paddr_set_to_zero
4919#define elf_backend_want_p_paddr_set_to_zero 1
4920
fcf12726
AM		 4921#undef ELF_MAXPAGESIZE
4922#define ELF_MAXPAGESIZE 0x1000 /* 1K */
4923
4924#undef elfNN_bed
4925#define elfNN_bed elfNN_ia64_hpux_bed
4926
4927#include "elfNN-target.h"
5e8d7549
NC		 4928
4929#undef elf_backend_want_p_paddr_set_to_zero
GDB Binutils - Deliverables
This page took 0.723856 seconds and 4 git commands to generate.