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