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