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