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