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