1 /* IA-64 support for 64-bit ELF
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
3 Free Software Foundation, Inc.
4 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
26 #include "opcode/ia64.h"
34 #define LOG_SECTION_ALIGN 3
38 #define LOG_SECTION_ALIGN 2
41 /* THE RULES for all the stuff the linker creates --
43 GOT Entries created in response to LTOFF or LTOFF_FPTR
44 relocations. Dynamic relocs created for dynamic
45 symbols in an application; REL relocs for locals
48 FPTR The canonical function descriptor. Created for local
49 symbols in applications. Descriptors for dynamic symbols
50 and local symbols in shared libraries are created by
51 ld.so. Thus there are no dynamic relocs against these
52 objects. The FPTR relocs for such _are_ passed through
53 to the dynamic relocation tables.
55 FULL_PLT Created for a PCREL21B relocation against a dynamic symbol.
56 Requires the creation of a PLTOFF entry. This does not
57 require any dynamic relocations.
59 PLTOFF Created by PLTOFF relocations. For local symbols, this
60 is an alternate function descriptor, and in shared libraries
61 requires two REL relocations. Note that this cannot be
62 transformed into an FPTR relocation, since it must be in
63 range of the GP. For dynamic symbols, this is a function
64 descriptor for a MIN_PLT entry, and requires one IPLT reloc.
66 MIN_PLT Created by PLTOFF entries against dynamic symbols. This
67 does not require dynamic relocations. */
69 #define NELEMS(a) ((int) (sizeof (a) / sizeof ((a)[0])))
71 typedef struct bfd_hash_entry *(*new_hash_entry_func)
72 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
74 /* In dynamically (linker-) created sections, we generally need to keep track
75 of the place a symbol or expression got allocated to. This is done via hash
76 tables that store entries of the following type. */
78 struct elfNN_ia64_dyn_sym_info
80 /* The addend for which this entry is relevant. */
85 bfd_vma pltoff_offset;
89 bfd_vma dtpmod_offset;
90 bfd_vma dtprel_offset;
92 /* The symbol table entry, if any, that this was derived from. */
93 struct elf_link_hash_entry *h;
95 /* Used to count non-got, non-plt relocations for delayed sizing
96 of relocation sections. */
97 struct elfNN_ia64_dyn_reloc_entry
99 struct elfNN_ia64_dyn_reloc_entry *next;
104 /* Is this reloc against readonly section? */
108 /* TRUE when the section contents have been updated. */
109 unsigned got_done : 1;
110 unsigned fptr_done : 1;
111 unsigned pltoff_done : 1;
112 unsigned tprel_done : 1;
113 unsigned dtpmod_done : 1;
114 unsigned dtprel_done : 1;
116 /* TRUE for the different kinds of linker data we want created. */
117 unsigned want_got : 1;
118 unsigned want_gotx : 1;
119 unsigned want_fptr : 1;
120 unsigned want_ltoff_fptr : 1;
121 unsigned want_plt : 1;
122 unsigned want_plt2 : 1;
123 unsigned want_pltoff : 1;
124 unsigned want_tprel : 1;
125 unsigned want_dtpmod : 1;
126 unsigned want_dtprel : 1;
129 struct elfNN_ia64_local_hash_entry
133 /* The number of elements in elfNN_ia64_dyn_sym_info array. */
135 /* The number of sorted elements in elfNN_ia64_dyn_sym_info array. */
136 unsigned int sorted_count;
137 /* The size of elfNN_ia64_dyn_sym_info array. */
139 /* The array of elfNN_ia64_dyn_sym_info. */
140 struct elfNN_ia64_dyn_sym_info *info;
142 /* TRUE if this hash entry's addends was translated for
143 SHF_MERGE optimization. */
144 unsigned sec_merge_done : 1;
147 struct elfNN_ia64_link_hash_entry
149 struct elf_link_hash_entry root;
150 /* The number of elements in elfNN_ia64_dyn_sym_info array. */
152 /* The number of sorted elements in elfNN_ia64_dyn_sym_info array. */
153 unsigned int sorted_count;
154 /* The size of elfNN_ia64_dyn_sym_info array. */
156 /* The array of elfNN_ia64_dyn_sym_info. */
157 struct elfNN_ia64_dyn_sym_info *info;
160 struct elfNN_ia64_link_hash_table
162 /* The main hash table. */
163 struct elf_link_hash_table root;
165 asection *got_sec; /* the linkage table section (or NULL) */
166 asection *rel_got_sec; /* dynamic relocation section for same */
167 asection *fptr_sec; /* function descriptor table (or NULL) */
168 asection *rel_fptr_sec; /* dynamic relocation section for same */
169 asection *plt_sec; /* the primary plt section (or NULL) */
170 asection *pltoff_sec; /* private descriptors for plt (or NULL) */
171 asection *rel_pltoff_sec; /* dynamic relocation section for same */
173 bfd_size_type minplt_entries; /* number of minplt entries */
174 unsigned reltext : 1; /* are there relocs against readonly sections? */
175 unsigned self_dtpmod_done : 1;/* has self DTPMOD entry been finished? */
176 bfd_vma self_dtpmod_offset; /* .got offset to self DTPMOD entry */
178 htab_t loc_hash_table;
179 void *loc_hash_memory;
182 struct elfNN_ia64_allocate_data
184 struct bfd_link_info *info;
186 bfd_boolean only_got;
189 #define elfNN_ia64_hash_table(p) \
190 ((struct elfNN_ia64_link_hash_table *) ((p)->hash))
192 static bfd_reloc_status_type elfNN_ia64_reloc
193 PARAMS ((bfd *abfd, arelent *reloc, asymbol *sym, PTR data,
194 asection *input_section, bfd *output_bfd, char **error_message));
195 static reloc_howto_type * lookup_howto
196 PARAMS ((unsigned int rtype));
197 static reloc_howto_type *elfNN_ia64_reloc_type_lookup
198 PARAMS ((bfd *abfd, bfd_reloc_code_real_type bfd_code));
199 static void elfNN_ia64_info_to_howto
200 PARAMS ((bfd *abfd, arelent *bfd_reloc, Elf_Internal_Rela *elf_reloc));
201 static bfd_boolean elfNN_ia64_relax_section
202 PARAMS((bfd *abfd, asection *sec, struct bfd_link_info *link_info,
203 bfd_boolean *again));
204 static void elfNN_ia64_relax_ldxmov
205 PARAMS((bfd_byte *contents, bfd_vma off));
206 static bfd_boolean is_unwind_section_name
207 PARAMS ((bfd *abfd, const char *));
208 static bfd_boolean elfNN_ia64_section_flags
209 PARAMS ((flagword *, const Elf_Internal_Shdr *));
210 static bfd_boolean elfNN_ia64_fake_sections
211 PARAMS ((bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec));
212 static void elfNN_ia64_final_write_processing
213 PARAMS ((bfd *abfd, bfd_boolean linker));
214 static bfd_boolean elfNN_ia64_add_symbol_hook
215 PARAMS ((bfd *abfd, struct bfd_link_info *info, Elf_Internal_Sym *sym,
216 const char **namep, flagword *flagsp, asection **secp,
218 static bfd_boolean elfNN_ia64_is_local_label_name
219 PARAMS ((bfd *abfd, const char *name));
220 static bfd_boolean elfNN_ia64_dynamic_symbol_p
221 PARAMS ((struct elf_link_hash_entry *h, struct bfd_link_info *info, int));
222 static struct bfd_hash_entry *elfNN_ia64_new_elf_hash_entry
223 PARAMS ((struct bfd_hash_entry *entry, struct bfd_hash_table *table,
224 const char *string));
225 static void elfNN_ia64_hash_copy_indirect
226 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *,
227 struct elf_link_hash_entry *));
228 static void elfNN_ia64_hash_hide_symbol
229 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean));
230 static hashval_t elfNN_ia64_local_htab_hash PARAMS ((const void *));
231 static int elfNN_ia64_local_htab_eq PARAMS ((const void *ptr1,
233 static struct bfd_link_hash_table *elfNN_ia64_hash_table_create
234 PARAMS ((bfd *abfd));
235 static void elfNN_ia64_hash_table_free
236 PARAMS ((struct bfd_link_hash_table *hash));
237 static bfd_boolean elfNN_ia64_global_dyn_sym_thunk
238 PARAMS ((struct bfd_hash_entry *, PTR));
239 static int elfNN_ia64_local_dyn_sym_thunk
240 PARAMS ((void **, PTR));
241 static void elfNN_ia64_dyn_sym_traverse
242 PARAMS ((struct elfNN_ia64_link_hash_table *ia64_info,
243 bfd_boolean (*func) (struct elfNN_ia64_dyn_sym_info *, PTR),
245 static bfd_boolean elfNN_ia64_create_dynamic_sections
246 PARAMS ((bfd *abfd, struct bfd_link_info *info));
247 static struct elfNN_ia64_local_hash_entry * get_local_sym_hash
248 PARAMS ((struct elfNN_ia64_link_hash_table *ia64_info,
249 bfd *abfd, const Elf_Internal_Rela *rel, bfd_boolean create));
250 static struct elfNN_ia64_dyn_sym_info * get_dyn_sym_info
251 PARAMS ((struct elfNN_ia64_link_hash_table *ia64_info,
252 struct elf_link_hash_entry *h,
253 bfd *abfd, const Elf_Internal_Rela *rel, bfd_boolean create));
254 static asection *get_got
255 PARAMS ((bfd *abfd, struct bfd_link_info *info,
256 struct elfNN_ia64_link_hash_table *ia64_info));
257 static asection *get_fptr
258 PARAMS ((bfd *abfd, struct bfd_link_info *info,
259 struct elfNN_ia64_link_hash_table *ia64_info));
260 static asection *get_pltoff
261 PARAMS ((bfd *abfd, struct bfd_link_info *info,
262 struct elfNN_ia64_link_hash_table *ia64_info));
263 static asection *get_reloc_section
264 PARAMS ((bfd *abfd, struct elfNN_ia64_link_hash_table *ia64_info,
265 asection *sec, bfd_boolean create));
266 static bfd_boolean elfNN_ia64_check_relocs
267 PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *sec,
268 const Elf_Internal_Rela *relocs));
269 static bfd_boolean elfNN_ia64_adjust_dynamic_symbol
270 PARAMS ((struct bfd_link_info *info, struct elf_link_hash_entry *h));
271 static long global_sym_index
272 PARAMS ((struct elf_link_hash_entry *h));
273 static bfd_boolean allocate_fptr
274 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
275 static bfd_boolean allocate_global_data_got
276 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
277 static bfd_boolean allocate_global_fptr_got
278 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
279 static bfd_boolean allocate_local_got
280 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
281 static bfd_boolean allocate_pltoff_entries
282 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
283 static bfd_boolean allocate_plt_entries
284 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
285 static bfd_boolean allocate_plt2_entries
286 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
287 static bfd_boolean allocate_dynrel_entries
288 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
289 static bfd_boolean elfNN_ia64_size_dynamic_sections
290 PARAMS ((bfd *output_bfd, struct bfd_link_info *info));
291 static bfd_reloc_status_type elfNN_ia64_install_value
292 PARAMS ((bfd_byte *hit_addr, bfd_vma val, unsigned int r_type));
293 static void elfNN_ia64_install_dyn_reloc
294 PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *sec,
295 asection *srel, bfd_vma offset, unsigned int type,
296 long dynindx, bfd_vma addend));
297 static bfd_vma set_got_entry
298 PARAMS ((bfd *abfd, struct bfd_link_info *info,
299 struct elfNN_ia64_dyn_sym_info *dyn_i, long dynindx,
300 bfd_vma addend, bfd_vma value, unsigned int dyn_r_type));
301 static bfd_vma set_fptr_entry
302 PARAMS ((bfd *abfd, struct bfd_link_info *info,
303 struct elfNN_ia64_dyn_sym_info *dyn_i,
305 static bfd_vma set_pltoff_entry
306 PARAMS ((bfd *abfd, struct bfd_link_info *info,
307 struct elfNN_ia64_dyn_sym_info *dyn_i,
308 bfd_vma value, bfd_boolean));
309 static bfd_vma elfNN_ia64_tprel_base
310 PARAMS ((struct bfd_link_info *info));
311 static bfd_vma elfNN_ia64_dtprel_base
312 PARAMS ((struct bfd_link_info *info));
313 static int elfNN_ia64_unwind_entry_compare
314 PARAMS ((const PTR, const PTR));
315 static bfd_boolean elfNN_ia64_choose_gp
316 PARAMS ((bfd *abfd, struct bfd_link_info *info));
317 static bfd_boolean elfNN_ia64_final_link
318 PARAMS ((bfd *abfd, struct bfd_link_info *info));
319 static bfd_boolean elfNN_ia64_relocate_section
320 PARAMS ((bfd *output_bfd, struct bfd_link_info *info, bfd *input_bfd,
321 asection *input_section, bfd_byte *contents,
322 Elf_Internal_Rela *relocs, Elf_Internal_Sym *local_syms,
323 asection **local_sections));
324 static bfd_boolean elfNN_ia64_finish_dynamic_symbol
325 PARAMS ((bfd *output_bfd, struct bfd_link_info *info,
326 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym));
327 static bfd_boolean elfNN_ia64_finish_dynamic_sections
328 PARAMS ((bfd *abfd, struct bfd_link_info *info));
329 static bfd_boolean elfNN_ia64_set_private_flags
330 PARAMS ((bfd *abfd, flagword flags));
331 static bfd_boolean elfNN_ia64_merge_private_bfd_data
332 PARAMS ((bfd *ibfd, bfd *obfd));
333 static bfd_boolean elfNN_ia64_print_private_bfd_data
334 PARAMS ((bfd *abfd, PTR ptr));
335 static enum elf_reloc_type_class elfNN_ia64_reloc_type_class
336 PARAMS ((const Elf_Internal_Rela *));
337 static bfd_boolean elfNN_ia64_hpux_vec
338 PARAMS ((const bfd_target *vec));
339 static void elfNN_hpux_post_process_headers
340 PARAMS ((bfd *abfd, struct bfd_link_info *info));
341 bfd_boolean elfNN_hpux_backend_section_from_bfd_section
342 PARAMS ((bfd *abfd, asection *sec, int *retval));
344 /* ia64-specific relocation. */
346 /* Perform a relocation. Not much to do here as all the hard work is
347 done in elfNN_ia64_final_link_relocate. */
348 static bfd_reloc_status_type
349 elfNN_ia64_reloc (abfd, reloc, sym, data, input_section,
350 output_bfd, error_message)
351 bfd *abfd ATTRIBUTE_UNUSED;
353 asymbol *sym ATTRIBUTE_UNUSED;
354 PTR data ATTRIBUTE_UNUSED;
355 asection *input_section;
357 char **error_message;
361 reloc->address += input_section->output_offset;
365 if (input_section->flags & SEC_DEBUGGING)
366 return bfd_reloc_continue;
368 *error_message = "Unsupported call to elfNN_ia64_reloc";
369 return bfd_reloc_notsupported;
372 #define IA64_HOWTO(TYPE, NAME, SIZE, PCREL, IN) \
373 HOWTO (TYPE, 0, SIZE, 0, PCREL, 0, complain_overflow_signed, \
374 elfNN_ia64_reloc, NAME, FALSE, 0, -1, IN)
376 /* This table has to be sorted according to increasing number of the
378 static reloc_howto_type ia64_howto_table[] =
380 IA64_HOWTO (R_IA64_NONE, "NONE", 0, FALSE, TRUE),
382 IA64_HOWTO (R_IA64_IMM14, "IMM14", 0, FALSE, TRUE),
383 IA64_HOWTO (R_IA64_IMM22, "IMM22", 0, FALSE, TRUE),
384 IA64_HOWTO (R_IA64_IMM64, "IMM64", 0, FALSE, TRUE),
385 IA64_HOWTO (R_IA64_DIR32MSB, "DIR32MSB", 2, FALSE, TRUE),
386 IA64_HOWTO (R_IA64_DIR32LSB, "DIR32LSB", 2, FALSE, TRUE),
387 IA64_HOWTO (R_IA64_DIR64MSB, "DIR64MSB", 4, FALSE, TRUE),
388 IA64_HOWTO (R_IA64_DIR64LSB, "DIR64LSB", 4, FALSE, TRUE),
390 IA64_HOWTO (R_IA64_GPREL22, "GPREL22", 0, FALSE, TRUE),
391 IA64_HOWTO (R_IA64_GPREL64I, "GPREL64I", 0, FALSE, TRUE),
392 IA64_HOWTO (R_IA64_GPREL32MSB, "GPREL32MSB", 2, FALSE, TRUE),
393 IA64_HOWTO (R_IA64_GPREL32LSB, "GPREL32LSB", 2, FALSE, TRUE),
394 IA64_HOWTO (R_IA64_GPREL64MSB, "GPREL64MSB", 4, FALSE, TRUE),
395 IA64_HOWTO (R_IA64_GPREL64LSB, "GPREL64LSB", 4, FALSE, TRUE),
397 IA64_HOWTO (R_IA64_LTOFF22, "LTOFF22", 0, FALSE, TRUE),
398 IA64_HOWTO (R_IA64_LTOFF64I, "LTOFF64I", 0, FALSE, TRUE),
400 IA64_HOWTO (R_IA64_PLTOFF22, "PLTOFF22", 0, FALSE, TRUE),
401 IA64_HOWTO (R_IA64_PLTOFF64I, "PLTOFF64I", 0, FALSE, TRUE),
402 IA64_HOWTO (R_IA64_PLTOFF64MSB, "PLTOFF64MSB", 4, FALSE, TRUE),
403 IA64_HOWTO (R_IA64_PLTOFF64LSB, "PLTOFF64LSB", 4, FALSE, TRUE),
405 IA64_HOWTO (R_IA64_FPTR64I, "FPTR64I", 0, FALSE, TRUE),
406 IA64_HOWTO (R_IA64_FPTR32MSB, "FPTR32MSB", 2, FALSE, TRUE),
407 IA64_HOWTO (R_IA64_FPTR32LSB, "FPTR32LSB", 2, FALSE, TRUE),
408 IA64_HOWTO (R_IA64_FPTR64MSB, "FPTR64MSB", 4, FALSE, TRUE),
409 IA64_HOWTO (R_IA64_FPTR64LSB, "FPTR64LSB", 4, FALSE, TRUE),
411 IA64_HOWTO (R_IA64_PCREL60B, "PCREL60B", 0, TRUE, TRUE),
412 IA64_HOWTO (R_IA64_PCREL21B, "PCREL21B", 0, TRUE, TRUE),
413 IA64_HOWTO (R_IA64_PCREL21M, "PCREL21M", 0, TRUE, TRUE),
414 IA64_HOWTO (R_IA64_PCREL21F, "PCREL21F", 0, TRUE, TRUE),
415 IA64_HOWTO (R_IA64_PCREL32MSB, "PCREL32MSB", 2, TRUE, TRUE),
416 IA64_HOWTO (R_IA64_PCREL32LSB, "PCREL32LSB", 2, TRUE, TRUE),
417 IA64_HOWTO (R_IA64_PCREL64MSB, "PCREL64MSB", 4, TRUE, TRUE),
418 IA64_HOWTO (R_IA64_PCREL64LSB, "PCREL64LSB", 4, TRUE, TRUE),
420 IA64_HOWTO (R_IA64_LTOFF_FPTR22, "LTOFF_FPTR22", 0, FALSE, TRUE),
421 IA64_HOWTO (R_IA64_LTOFF_FPTR64I, "LTOFF_FPTR64I", 0, FALSE, TRUE),
422 IA64_HOWTO (R_IA64_LTOFF_FPTR32MSB, "LTOFF_FPTR32MSB", 2, FALSE, TRUE),
423 IA64_HOWTO (R_IA64_LTOFF_FPTR32LSB, "LTOFF_FPTR32LSB", 2, FALSE, TRUE),
424 IA64_HOWTO (R_IA64_LTOFF_FPTR64MSB, "LTOFF_FPTR64MSB", 4, FALSE, TRUE),
425 IA64_HOWTO (R_IA64_LTOFF_FPTR64LSB, "LTOFF_FPTR64LSB", 4, FALSE, TRUE),
427 IA64_HOWTO (R_IA64_SEGREL32MSB, "SEGREL32MSB", 2, FALSE, TRUE),
428 IA64_HOWTO (R_IA64_SEGREL32LSB, "SEGREL32LSB", 2, FALSE, TRUE),
429 IA64_HOWTO (R_IA64_SEGREL64MSB, "SEGREL64MSB", 4, FALSE, TRUE),
430 IA64_HOWTO (R_IA64_SEGREL64LSB, "SEGREL64LSB", 4, FALSE, TRUE),
432 IA64_HOWTO (R_IA64_SECREL32MSB, "SECREL32MSB", 2, FALSE, TRUE),
433 IA64_HOWTO (R_IA64_SECREL32LSB, "SECREL32LSB", 2, FALSE, TRUE),
434 IA64_HOWTO (R_IA64_SECREL64MSB, "SECREL64MSB", 4, FALSE, TRUE),
435 IA64_HOWTO (R_IA64_SECREL64LSB, "SECREL64LSB", 4, FALSE, TRUE),
437 IA64_HOWTO (R_IA64_REL32MSB, "REL32MSB", 2, FALSE, TRUE),
438 IA64_HOWTO (R_IA64_REL32LSB, "REL32LSB", 2, FALSE, TRUE),
439 IA64_HOWTO (R_IA64_REL64MSB, "REL64MSB", 4, FALSE, TRUE),
440 IA64_HOWTO (R_IA64_REL64LSB, "REL64LSB", 4, FALSE, TRUE),
442 IA64_HOWTO (R_IA64_LTV32MSB, "LTV32MSB", 2, FALSE, TRUE),
443 IA64_HOWTO (R_IA64_LTV32LSB, "LTV32LSB", 2, FALSE, TRUE),
444 IA64_HOWTO (R_IA64_LTV64MSB, "LTV64MSB", 4, FALSE, TRUE),
445 IA64_HOWTO (R_IA64_LTV64LSB, "LTV64LSB", 4, FALSE, TRUE),
447 IA64_HOWTO (R_IA64_PCREL21BI, "PCREL21BI", 0, TRUE, TRUE),
448 IA64_HOWTO (R_IA64_PCREL22, "PCREL22", 0, TRUE, TRUE),
449 IA64_HOWTO (R_IA64_PCREL64I, "PCREL64I", 0, TRUE, TRUE),
451 IA64_HOWTO (R_IA64_IPLTMSB, "IPLTMSB", 4, FALSE, TRUE),
452 IA64_HOWTO (R_IA64_IPLTLSB, "IPLTLSB", 4, FALSE, TRUE),
453 IA64_HOWTO (R_IA64_COPY, "COPY", 4, FALSE, TRUE),
454 IA64_HOWTO (R_IA64_LTOFF22X, "LTOFF22X", 0, FALSE, TRUE),
455 IA64_HOWTO (R_IA64_LDXMOV, "LDXMOV", 0, FALSE, TRUE),
457 IA64_HOWTO (R_IA64_TPREL14, "TPREL14", 0, FALSE, FALSE),
458 IA64_HOWTO (R_IA64_TPREL22, "TPREL22", 0, FALSE, FALSE),
459 IA64_HOWTO (R_IA64_TPREL64I, "TPREL64I", 0, FALSE, FALSE),
460 IA64_HOWTO (R_IA64_TPREL64MSB, "TPREL64MSB", 4, FALSE, FALSE),
461 IA64_HOWTO (R_IA64_TPREL64LSB, "TPREL64LSB", 4, FALSE, FALSE),
462 IA64_HOWTO (R_IA64_LTOFF_TPREL22, "LTOFF_TPREL22", 0, FALSE, FALSE),
464 IA64_HOWTO (R_IA64_DTPMOD64MSB, "DTPMOD64MSB", 4, FALSE, FALSE),
465 IA64_HOWTO (R_IA64_DTPMOD64LSB, "DTPMOD64LSB", 4, FALSE, FALSE),
466 IA64_HOWTO (R_IA64_LTOFF_DTPMOD22, "LTOFF_DTPMOD22", 0, FALSE, FALSE),
468 IA64_HOWTO (R_IA64_DTPREL14, "DTPREL14", 0, FALSE, FALSE),
469 IA64_HOWTO (R_IA64_DTPREL22, "DTPREL22", 0, FALSE, FALSE),
470 IA64_HOWTO (R_IA64_DTPREL64I, "DTPREL64I", 0, FALSE, FALSE),
471 IA64_HOWTO (R_IA64_DTPREL32MSB, "DTPREL32MSB", 2, FALSE, FALSE),
472 IA64_HOWTO (R_IA64_DTPREL32LSB, "DTPREL32LSB", 2, FALSE, FALSE),
473 IA64_HOWTO (R_IA64_DTPREL64MSB, "DTPREL64MSB", 4, FALSE, FALSE),
474 IA64_HOWTO (R_IA64_DTPREL64LSB, "DTPREL64LSB", 4, FALSE, FALSE),
475 IA64_HOWTO (R_IA64_LTOFF_DTPREL22, "LTOFF_DTPREL22", 0, FALSE, FALSE),
478 static unsigned char elf_code_to_howto_index[R_IA64_MAX_RELOC_CODE + 1];
480 /* Given a BFD reloc type, return the matching HOWTO structure. */
482 static reloc_howto_type *
486 static int inited = 0;
493 memset (elf_code_to_howto_index, 0xff, sizeof (elf_code_to_howto_index));
494 for (i = 0; i < NELEMS (ia64_howto_table); ++i)
495 elf_code_to_howto_index[ia64_howto_table[i].type] = i;
498 if (rtype > R_IA64_MAX_RELOC_CODE)
500 i = elf_code_to_howto_index[rtype];
501 if (i >= NELEMS (ia64_howto_table))
503 return ia64_howto_table + i;
506 static reloc_howto_type*
507 elfNN_ia64_reloc_type_lookup (abfd, bfd_code)
508 bfd *abfd ATTRIBUTE_UNUSED;
509 bfd_reloc_code_real_type bfd_code;
515 case BFD_RELOC_NONE: rtype = R_IA64_NONE; break;
517 case BFD_RELOC_IA64_IMM14: rtype = R_IA64_IMM14; break;
518 case BFD_RELOC_IA64_IMM22: rtype = R_IA64_IMM22; break;
519 case BFD_RELOC_IA64_IMM64: rtype = R_IA64_IMM64; break;
521 case BFD_RELOC_IA64_DIR32MSB: rtype = R_IA64_DIR32MSB; break;
522 case BFD_RELOC_IA64_DIR32LSB: rtype = R_IA64_DIR32LSB; break;
523 case BFD_RELOC_IA64_DIR64MSB: rtype = R_IA64_DIR64MSB; break;
524 case BFD_RELOC_IA64_DIR64LSB: rtype = R_IA64_DIR64LSB; break;
526 case BFD_RELOC_IA64_GPREL22: rtype = R_IA64_GPREL22; break;
527 case BFD_RELOC_IA64_GPREL64I: rtype = R_IA64_GPREL64I; break;
528 case BFD_RELOC_IA64_GPREL32MSB: rtype = R_IA64_GPREL32MSB; break;
529 case BFD_RELOC_IA64_GPREL32LSB: rtype = R_IA64_GPREL32LSB; break;
530 case BFD_RELOC_IA64_GPREL64MSB: rtype = R_IA64_GPREL64MSB; break;
531 case BFD_RELOC_IA64_GPREL64LSB: rtype = R_IA64_GPREL64LSB; break;
533 case BFD_RELOC_IA64_LTOFF22: rtype = R_IA64_LTOFF22; break;
534 case BFD_RELOC_IA64_LTOFF64I: rtype = R_IA64_LTOFF64I; break;
536 case BFD_RELOC_IA64_PLTOFF22: rtype = R_IA64_PLTOFF22; break;
537 case BFD_RELOC_IA64_PLTOFF64I: rtype = R_IA64_PLTOFF64I; break;
538 case BFD_RELOC_IA64_PLTOFF64MSB: rtype = R_IA64_PLTOFF64MSB; break;
539 case BFD_RELOC_IA64_PLTOFF64LSB: rtype = R_IA64_PLTOFF64LSB; break;
540 case BFD_RELOC_IA64_FPTR64I: rtype = R_IA64_FPTR64I; break;
541 case BFD_RELOC_IA64_FPTR32MSB: rtype = R_IA64_FPTR32MSB; break;
542 case BFD_RELOC_IA64_FPTR32LSB: rtype = R_IA64_FPTR32LSB; break;
543 case BFD_RELOC_IA64_FPTR64MSB: rtype = R_IA64_FPTR64MSB; break;
544 case BFD_RELOC_IA64_FPTR64LSB: rtype = R_IA64_FPTR64LSB; break;
546 case BFD_RELOC_IA64_PCREL21B: rtype = R_IA64_PCREL21B; break;
547 case BFD_RELOC_IA64_PCREL21BI: rtype = R_IA64_PCREL21BI; break;
548 case BFD_RELOC_IA64_PCREL21M: rtype = R_IA64_PCREL21M; break;
549 case BFD_RELOC_IA64_PCREL21F: rtype = R_IA64_PCREL21F; break;
550 case BFD_RELOC_IA64_PCREL22: rtype = R_IA64_PCREL22; break;
551 case BFD_RELOC_IA64_PCREL60B: rtype = R_IA64_PCREL60B; break;
552 case BFD_RELOC_IA64_PCREL64I: rtype = R_IA64_PCREL64I; break;
553 case BFD_RELOC_IA64_PCREL32MSB: rtype = R_IA64_PCREL32MSB; break;
554 case BFD_RELOC_IA64_PCREL32LSB: rtype = R_IA64_PCREL32LSB; break;
555 case BFD_RELOC_IA64_PCREL64MSB: rtype = R_IA64_PCREL64MSB; break;
556 case BFD_RELOC_IA64_PCREL64LSB: rtype = R_IA64_PCREL64LSB; break;
558 case BFD_RELOC_IA64_LTOFF_FPTR22: rtype = R_IA64_LTOFF_FPTR22; break;
559 case BFD_RELOC_IA64_LTOFF_FPTR64I: rtype = R_IA64_LTOFF_FPTR64I; break;
560 case BFD_RELOC_IA64_LTOFF_FPTR32MSB: rtype = R_IA64_LTOFF_FPTR32MSB; break;
561 case BFD_RELOC_IA64_LTOFF_FPTR32LSB: rtype = R_IA64_LTOFF_FPTR32LSB; break;
562 case BFD_RELOC_IA64_LTOFF_FPTR64MSB: rtype = R_IA64_LTOFF_FPTR64MSB; break;
563 case BFD_RELOC_IA64_LTOFF_FPTR64LSB: rtype = R_IA64_LTOFF_FPTR64LSB; break;
565 case BFD_RELOC_IA64_SEGREL32MSB: rtype = R_IA64_SEGREL32MSB; break;
566 case BFD_RELOC_IA64_SEGREL32LSB: rtype = R_IA64_SEGREL32LSB; break;
567 case BFD_RELOC_IA64_SEGREL64MSB: rtype = R_IA64_SEGREL64MSB; break;
568 case BFD_RELOC_IA64_SEGREL64LSB: rtype = R_IA64_SEGREL64LSB; break;
570 case BFD_RELOC_IA64_SECREL32MSB: rtype = R_IA64_SECREL32MSB; break;
571 case BFD_RELOC_IA64_SECREL32LSB: rtype = R_IA64_SECREL32LSB; break;
572 case BFD_RELOC_IA64_SECREL64MSB: rtype = R_IA64_SECREL64MSB; break;
573 case BFD_RELOC_IA64_SECREL64LSB: rtype = R_IA64_SECREL64LSB; break;
575 case BFD_RELOC_IA64_REL32MSB: rtype = R_IA64_REL32MSB; break;
576 case BFD_RELOC_IA64_REL32LSB: rtype = R_IA64_REL32LSB; break;
577 case BFD_RELOC_IA64_REL64MSB: rtype = R_IA64_REL64MSB; break;
578 case BFD_RELOC_IA64_REL64LSB: rtype = R_IA64_REL64LSB; break;
580 case BFD_RELOC_IA64_LTV32MSB: rtype = R_IA64_LTV32MSB; break;
581 case BFD_RELOC_IA64_LTV32LSB: rtype = R_IA64_LTV32LSB; break;
582 case BFD_RELOC_IA64_LTV64MSB: rtype = R_IA64_LTV64MSB; break;
583 case BFD_RELOC_IA64_LTV64LSB: rtype = R_IA64_LTV64LSB; break;
585 case BFD_RELOC_IA64_IPLTMSB: rtype = R_IA64_IPLTMSB; break;
586 case BFD_RELOC_IA64_IPLTLSB: rtype = R_IA64_IPLTLSB; break;
587 case BFD_RELOC_IA64_COPY: rtype = R_IA64_COPY; break;
588 case BFD_RELOC_IA64_LTOFF22X: rtype = R_IA64_LTOFF22X; break;
589 case BFD_RELOC_IA64_LDXMOV: rtype = R_IA64_LDXMOV; break;
591 case BFD_RELOC_IA64_TPREL14: rtype = R_IA64_TPREL14; break;
592 case BFD_RELOC_IA64_TPREL22: rtype = R_IA64_TPREL22; break;
593 case BFD_RELOC_IA64_TPREL64I: rtype = R_IA64_TPREL64I; break;
594 case BFD_RELOC_IA64_TPREL64MSB: rtype = R_IA64_TPREL64MSB; break;
595 case BFD_RELOC_IA64_TPREL64LSB: rtype = R_IA64_TPREL64LSB; break;
596 case BFD_RELOC_IA64_LTOFF_TPREL22: rtype = R_IA64_LTOFF_TPREL22; break;
598 case BFD_RELOC_IA64_DTPMOD64MSB: rtype = R_IA64_DTPMOD64MSB; break;
599 case BFD_RELOC_IA64_DTPMOD64LSB: rtype = R_IA64_DTPMOD64LSB; break;
600 case BFD_RELOC_IA64_LTOFF_DTPMOD22: rtype = R_IA64_LTOFF_DTPMOD22; break;
602 case BFD_RELOC_IA64_DTPREL14: rtype = R_IA64_DTPREL14; break;
603 case BFD_RELOC_IA64_DTPREL22: rtype = R_IA64_DTPREL22; break;
604 case BFD_RELOC_IA64_DTPREL64I: rtype = R_IA64_DTPREL64I; break;
605 case BFD_RELOC_IA64_DTPREL32MSB: rtype = R_IA64_DTPREL32MSB; break;
606 case BFD_RELOC_IA64_DTPREL32LSB: rtype = R_IA64_DTPREL32LSB; break;
607 case BFD_RELOC_IA64_DTPREL64MSB: rtype = R_IA64_DTPREL64MSB; break;
608 case BFD_RELOC_IA64_DTPREL64LSB: rtype = R_IA64_DTPREL64LSB; break;
609 case BFD_RELOC_IA64_LTOFF_DTPREL22: rtype = R_IA64_LTOFF_DTPREL22; break;
613 return lookup_howto (rtype);
616 /* Given a ELF reloc, return the matching HOWTO structure. */
619 elfNN_ia64_info_to_howto (abfd, bfd_reloc, elf_reloc)
620 bfd *abfd ATTRIBUTE_UNUSED;
622 Elf_Internal_Rela *elf_reloc;
625 = lookup_howto ((unsigned int) ELFNN_R_TYPE (elf_reloc->r_info));
628 #define PLT_HEADER_SIZE (3 * 16)
629 #define PLT_MIN_ENTRY_SIZE (1 * 16)
630 #define PLT_FULL_ENTRY_SIZE (2 * 16)
631 #define PLT_RESERVED_WORDS 3
633 static const bfd_byte plt_header[PLT_HEADER_SIZE] =
635 0x0b, 0x10, 0x00, 0x1c, 0x00, 0x21, /* [MMI] mov r2=r14;; */
636 0xe0, 0x00, 0x08, 0x00, 0x48, 0x00, /* addl r14=0,r2 */
637 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
638 0x0b, 0x80, 0x20, 0x1c, 0x18, 0x14, /* [MMI] ld8 r16=[r14],8;; */
639 0x10, 0x41, 0x38, 0x30, 0x28, 0x00, /* ld8 r17=[r14],8 */
640 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
641 0x11, 0x08, 0x00, 0x1c, 0x18, 0x10, /* [MIB] ld8 r1=[r14] */
642 0x60, 0x88, 0x04, 0x80, 0x03, 0x00, /* mov b6=r17 */
643 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
646 static const bfd_byte plt_min_entry[PLT_MIN_ENTRY_SIZE] =
648 0x11, 0x78, 0x00, 0x00, 0x00, 0x24, /* [MIB] mov r15=0 */
649 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, /* nop.i 0x0 */
650 0x00, 0x00, 0x00, 0x40 /* br.few 0 <PLT0>;; */
653 static const bfd_byte plt_full_entry[PLT_FULL_ENTRY_SIZE] =
655 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
656 0x00, 0x41, 0x3c, 0x70, 0x29, 0xc0, /* ld8.acq r16=[r15],8*/
657 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
658 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
659 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
660 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
663 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
665 static const bfd_byte oor_brl[16] =
667 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
668 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;; */
669 0x00, 0x00, 0x00, 0xc0
672 static const bfd_byte oor_ip[48] =
674 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
675 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, /* movl r15=0 */
676 0x01, 0x00, 0x00, 0x60,
677 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MII] nop.m 0 */
678 0x00, 0x01, 0x00, 0x60, 0x00, 0x00, /* mov r16=ip;; */
679 0xf2, 0x80, 0x00, 0x80, /* add r16=r15,r16;; */
680 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MIB] nop.m 0 */
681 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
682 0x60, 0x00, 0x80, 0x00 /* br b6;; */
685 static size_t oor_branch_size = sizeof (oor_brl);
688 bfd_elfNN_ia64_after_parse (int itanium)
690 oor_branch_size = itanium ? sizeof (oor_ip) : sizeof (oor_brl);
693 #define BTYPE_SHIFT 6
700 #define OPCODE_SHIFT 37
702 #define OPCODE_BITS (0xfLL << OPCODE_SHIFT)
703 #define X6_BITS (0x3fLL << X6_SHIFT)
704 #define X4_BITS (0xfLL << X4_SHIFT)
705 #define X3_BITS (0x7LL << X3_SHIFT)
706 #define X2_BITS (0x3LL << X2_SHIFT)
707 #define X_BITS (0x1LL << X_SHIFT)
708 #define Y_BITS (0x1LL << Y_SHIFT)
709 #define BTYPE_BITS (0x7LL << BTYPE_SHIFT)
710 #define PREDICATE_BITS (0x3fLL)
712 #define IS_NOP_B(i) \
713 (((i) & (OPCODE_BITS | X6_BITS)) == (2LL << OPCODE_SHIFT))
714 #define IS_NOP_F(i) \
715 (((i) & (OPCODE_BITS | X_BITS | X6_BITS | Y_BITS)) \
716 == (0x1LL << X6_SHIFT))
717 #define IS_NOP_I(i) \
718 (((i) & (OPCODE_BITS | X3_BITS | X6_BITS | Y_BITS)) \
719 == (0x1LL << X6_SHIFT))
720 #define IS_NOP_M(i) \
721 (((i) & (OPCODE_BITS | X3_BITS | X2_BITS | X4_BITS | Y_BITS)) \
722 == (0x1LL << X4_SHIFT))
723 #define IS_BR_COND(i) \
724 (((i) & (OPCODE_BITS | BTYPE_BITS)) == (0x4LL << OPCODE_SHIFT))
725 #define IS_BR_CALL(i) \
726 (((i) & OPCODE_BITS) == (0x5LL << OPCODE_SHIFT))
729 elfNN_ia64_relax_br (bfd_byte *contents, bfd_vma off)
731 unsigned int template, mlx;
732 bfd_vma t0, t1, s0, s1, s2, br_code;
736 hit_addr = (bfd_byte *) (contents + off);
737 br_slot = (long) hit_addr & 0x3;
739 t0 = bfd_getl64 (hit_addr + 0);
740 t1 = bfd_getl64 (hit_addr + 8);
742 /* Check if we can turn br into brl. A label is always at the start
743 of the bundle. Even if there are predicates on NOPs, we still
744 perform this optimization. */
745 template = t0 & 0x1e;
746 s0 = (t0 >> 5) & 0x1ffffffffffLL;
747 s1 = ((t0 >> 46) | (t1 << 18)) & 0x1ffffffffffLL;
748 s2 = (t1 >> 23) & 0x1ffffffffffLL;
752 /* Check if slot 1 and slot 2 are NOPs. Possible template is
753 BBB. We only need to check nop.b. */
754 if (!(IS_NOP_B (s1) && IS_NOP_B (s2)))
759 /* Check if slot 2 is NOP. Possible templates are MBB and BBB.
760 For BBB, slot 0 also has to be nop.b. */
761 if (!((template == 0x12 /* MBB */
763 || (template == 0x16 /* BBB */
770 /* Check if slot 1 is NOP. Possible templates are MIB, MBB, BBB,
771 MMB and MFB. For BBB, slot 0 also has to be nop.b. */
772 if (!((template == 0x10 /* MIB */
774 || (template == 0x12 /* MBB */
776 || (template == 0x16 /* BBB */
779 || (template == 0x18 /* MMB */
781 || (template == 0x1c /* MFB */
787 /* It should never happen. */
791 /* We can turn br.cond/br.call into brl.cond/brl.call. */
792 if (!(IS_BR_COND (br_code) || IS_BR_CALL (br_code)))
795 /* Turn br into brl by setting bit 40. */
796 br_code |= 0x1LL << 40;
798 /* Turn the old bundle into a MLX bundle with the same stop-bit
805 if (template == 0x16)
807 /* For BBB, we need to put nop.m in slot 0. We keep the original
808 predicate only if slot 0 isn't br. */
812 t0 &= PREDICATE_BITS << 5;
813 t0 |= 0x1LL << (X4_SHIFT + 5);
817 /* Keep the original instruction in slot 0. */
818 t0 &= 0x1ffffffffffLL << 5;
823 /* Put brl in slot 1. */
826 bfd_putl64 (t0, hit_addr);
827 bfd_putl64 (t1, hit_addr + 8);
832 elfNN_ia64_relax_brl (bfd_byte *contents, bfd_vma off)
836 bfd_vma t0, t1, i0, i1, i2;
838 hit_addr = (bfd_byte *) (contents + off);
839 hit_addr -= (long) hit_addr & 0x3;
840 t0 = bfd_getl64 (hit_addr);
841 t1 = bfd_getl64 (hit_addr + 8);
843 /* Keep the instruction in slot 0. */
844 i0 = (t0 >> 5) & 0x1ffffffffffLL;
845 /* Use nop.b for slot 1. */
847 /* For slot 2, turn brl into br by masking out bit 40. */
848 i2 = (t1 >> 23) & 0x0ffffffffffLL;
850 /* Turn a MLX bundle into a MBB bundle with the same stop-bit
856 t0 = (i1 << 46) | (i0 << 5) | template;
857 t1 = (i2 << 23) | (i1 >> 18);
859 bfd_putl64 (t0, hit_addr);
860 bfd_putl64 (t1, hit_addr + 8);
863 /* Rename some of the generic section flags to better document how they
865 #define skip_relax_pass_0 need_finalize_relax
866 #define skip_relax_pass_1 has_gp_reloc
869 /* These functions do relaxation for IA-64 ELF. */
872 elfNN_ia64_relax_section (abfd, sec, link_info, again)
875 struct bfd_link_info *link_info;
880 struct one_fixup *next;
886 Elf_Internal_Shdr *symtab_hdr;
887 Elf_Internal_Rela *internal_relocs;
888 Elf_Internal_Rela *irel, *irelend;
890 Elf_Internal_Sym *isymbuf = NULL;
891 struct elfNN_ia64_link_hash_table *ia64_info;
892 struct one_fixup *fixups = NULL;
893 bfd_boolean changed_contents = FALSE;
894 bfd_boolean changed_relocs = FALSE;
895 bfd_boolean changed_got = FALSE;
896 bfd_boolean skip_relax_pass_0 = TRUE;
897 bfd_boolean skip_relax_pass_1 = TRUE;
900 /* Assume we're not going to change any sizes, and we'll only need
904 /* Don't even try to relax for non-ELF outputs. */
905 if (!is_elf_hash_table (link_info->hash))
908 /* Nothing to do if there are no relocations or there is no need for
910 if ((sec->flags & SEC_RELOC) == 0
911 || sec->reloc_count == 0
912 || (link_info->relax_pass == 0 && sec->skip_relax_pass_0)
913 || (link_info->relax_pass == 1 && sec->skip_relax_pass_1))
916 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
918 /* Load the relocations for this section. */
919 internal_relocs = (_bfd_elf_link_read_relocs
920 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
921 link_info->keep_memory));
922 if (internal_relocs == NULL)
925 ia64_info = elfNN_ia64_hash_table (link_info);
926 irelend = internal_relocs + sec->reloc_count;
928 /* Get the section contents. */
929 if (elf_section_data (sec)->this_hdr.contents != NULL)
930 contents = elf_section_data (sec)->this_hdr.contents;
933 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
937 for (irel = internal_relocs; irel < irelend; irel++)
939 unsigned long r_type = ELFNN_R_TYPE (irel->r_info);
940 bfd_vma symaddr, reladdr, trampoff, toff, roff;
944 bfd_boolean is_branch;
945 struct elfNN_ia64_dyn_sym_info *dyn_i;
950 case R_IA64_PCREL21B:
951 case R_IA64_PCREL21BI:
952 case R_IA64_PCREL21M:
953 case R_IA64_PCREL21F:
954 /* In pass 1, all br relaxations are done. We can skip it. */
955 if (link_info->relax_pass == 1)
957 skip_relax_pass_0 = FALSE;
961 case R_IA64_PCREL60B:
962 /* We can't optimize brl to br in pass 0 since br relaxations
963 will increase the code size. Defer it to pass 1. */
964 if (link_info->relax_pass == 0)
966 skip_relax_pass_1 = FALSE;
972 case R_IA64_LTOFF22X:
974 /* We can't relax ldx/mov in pass 0 since br relaxations will
975 increase the code size. Defer it to pass 1. */
976 if (link_info->relax_pass == 0)
978 skip_relax_pass_1 = FALSE;
988 /* Get the value of the symbol referred to by the reloc. */
989 if (ELFNN_R_SYM (irel->r_info) < symtab_hdr->sh_info)
991 /* A local symbol. */
992 Elf_Internal_Sym *isym;
994 /* Read this BFD's local symbols. */
997 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
999 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1000 symtab_hdr->sh_info, 0,
1006 isym = isymbuf + ELFNN_R_SYM (irel->r_info);
1007 if (isym->st_shndx == SHN_UNDEF)
1008 continue; /* We can't do anything with undefined symbols. */
1009 else if (isym->st_shndx == SHN_ABS)
1010 tsec = bfd_abs_section_ptr;
1011 else if (isym->st_shndx == SHN_COMMON)
1012 tsec = bfd_com_section_ptr;
1013 else if (isym->st_shndx == SHN_IA_64_ANSI_COMMON)
1014 tsec = bfd_com_section_ptr;
1016 tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1018 toff = isym->st_value;
1019 dyn_i = get_dyn_sym_info (ia64_info, NULL, abfd, irel, FALSE);
1020 symtype = ELF_ST_TYPE (isym->st_info);
1025 struct elf_link_hash_entry *h;
1027 indx = ELFNN_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1028 h = elf_sym_hashes (abfd)[indx];
1029 BFD_ASSERT (h != NULL);
1031 while (h->root.type == bfd_link_hash_indirect
1032 || h->root.type == bfd_link_hash_warning)
1033 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1035 dyn_i = get_dyn_sym_info (ia64_info, h, abfd, irel, FALSE);
1037 /* For branches to dynamic symbols, we're interested instead
1038 in a branch to the PLT entry. */
1039 if (is_branch && dyn_i && dyn_i->want_plt2)
1041 /* Internal branches shouldn't be sent to the PLT.
1042 Leave this for now and we'll give an error later. */
1043 if (r_type != R_IA64_PCREL21B)
1046 tsec = ia64_info->plt_sec;
1047 toff = dyn_i->plt2_offset;
1048 BFD_ASSERT (irel->r_addend == 0);
1051 /* Can't do anything else with dynamic symbols. */
1052 else if (elfNN_ia64_dynamic_symbol_p (h, link_info, r_type))
1057 /* We can't do anything with undefined symbols. */
1058 if (h->root.type == bfd_link_hash_undefined
1059 || h->root.type == bfd_link_hash_undefweak)
1062 tsec = h->root.u.def.section;
1063 toff = h->root.u.def.value;
1069 if (tsec->sec_info_type == ELF_INFO_TYPE_MERGE)
1071 /* At this stage in linking, no SEC_MERGE symbol has been
1072 adjusted, so all references to such symbols need to be
1073 passed through _bfd_merged_section_offset. (Later, in
1074 relocate_section, all SEC_MERGE symbols *except* for
1075 section symbols have been adjusted.)
1077 gas may reduce relocations against symbols in SEC_MERGE
1078 sections to a relocation against the section symbol when
1079 the original addend was zero. When the reloc is against
1080 a section symbol we should include the addend in the
1081 offset passed to _bfd_merged_section_offset, since the
1082 location of interest is the original symbol. On the
1083 other hand, an access to "sym+addend" where "sym" is not
1084 a section symbol should not include the addend; Such an
1085 access is presumed to be an offset from "sym"; The
1086 location of interest is just "sym". */
1087 if (symtype == STT_SECTION)
1088 toff += irel->r_addend;
1090 toff = _bfd_merged_section_offset (abfd, &tsec,
1091 elf_section_data (tsec)->sec_info,
1094 if (symtype != STT_SECTION)
1095 toff += irel->r_addend;
1098 toff += irel->r_addend;
1100 symaddr = tsec->output_section->vma + tsec->output_offset + toff;
1102 roff = irel->r_offset;
1106 bfd_signed_vma offset;
1108 reladdr = (sec->output_section->vma
1109 + sec->output_offset
1110 + roff) & (bfd_vma) -4;
1112 /* If the branch is in range, no need to do anything. */
1113 if ((bfd_signed_vma) (symaddr - reladdr) >= -0x1000000
1114 && (bfd_signed_vma) (symaddr - reladdr) <= 0x0FFFFF0)
1116 /* If the 60-bit branch is in 21-bit range, optimize it. */
1117 if (r_type == R_IA64_PCREL60B)
1119 elfNN_ia64_relax_brl (contents, roff);
1122 = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
1125 /* If the original relocation offset points to slot
1126 1, change it to slot 2. */
1127 if ((irel->r_offset & 3) == 1)
1128 irel->r_offset += 1;
1133 else if (r_type == R_IA64_PCREL60B)
1135 else if (elfNN_ia64_relax_br (contents, roff))
1138 = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
1141 /* Make the relocation offset point to slot 1. */
1142 irel->r_offset = (irel->r_offset & ~((bfd_vma) 0x3)) + 1;
1146 /* We can't put a trampoline in a .init/.fini section. Issue
1148 if (strcmp (sec->output_section->name, ".init") == 0
1149 || strcmp (sec->output_section->name, ".fini") == 0)
1151 (*_bfd_error_handler)
1152 (_("%B: Can't relax br at 0x%lx in section `%A'. Please use brl or indirect branch."),
1153 sec->owner, sec, (unsigned long) roff);
1154 bfd_set_error (bfd_error_bad_value);
1158 /* If the branch and target are in the same section, you've
1159 got one honking big section and we can't help you unless
1160 you are branching backwards. You'll get an error message
1162 if (tsec == sec && toff > roff)
1165 /* Look for an existing fixup to this address. */
1166 for (f = fixups; f ; f = f->next)
1167 if (f->tsec == tsec && f->toff == toff)
1172 /* Two alternatives: If it's a branch to a PLT entry, we can
1173 make a copy of the FULL_PLT entry. Otherwise, we'll have
1174 to use a `brl' insn to get where we're going. */
1178 if (tsec == ia64_info->plt_sec)
1179 size = sizeof (plt_full_entry);
1181 size = oor_branch_size;
1183 /* Resize the current section to make room for the new branch. */
1184 trampoff = (sec->size + 15) & (bfd_vma) -16;
1186 /* If trampoline is out of range, there is nothing we
1188 offset = trampoff - (roff & (bfd_vma) -4);
1189 if (offset < -0x1000000 || offset > 0x0FFFFF0)
1192 amt = trampoff + size;
1193 contents = (bfd_byte *) bfd_realloc (contents, amt);
1194 if (contents == NULL)
1198 if (tsec == ia64_info->plt_sec)
1200 memcpy (contents + trampoff, plt_full_entry, size);
1202 /* Hijack the old relocation for use as the PLTOFF reloc. */
1203 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
1205 irel->r_offset = trampoff;
1209 if (size == sizeof (oor_ip))
1211 memcpy (contents + trampoff, oor_ip, size);
1212 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
1214 irel->r_addend -= 16;
1215 irel->r_offset = trampoff + 2;
1219 memcpy (contents + trampoff, oor_brl, size);
1220 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
1222 irel->r_offset = trampoff + 2;
1227 /* Record the fixup so we don't do it again this section. */
1228 f = (struct one_fixup *)
1229 bfd_malloc ((bfd_size_type) sizeof (*f));
1233 f->trampoff = trampoff;
1238 /* If trampoline is out of range, there is nothing we
1240 offset = f->trampoff - (roff & (bfd_vma) -4);
1241 if (offset < -0x1000000 || offset > 0x0FFFFF0)
1244 /* Nop out the reloc, since we're finalizing things here. */
1245 irel->r_info = ELFNN_R_INFO (0, R_IA64_NONE);
1248 /* Fix up the existing branch to hit the trampoline. */
1249 if (elfNN_ia64_install_value (contents + roff, offset, r_type)
1253 changed_contents = TRUE;
1254 changed_relocs = TRUE;
1261 bfd *obfd = sec->output_section->owner;
1262 gp = _bfd_get_gp_value (obfd);
1265 if (!elfNN_ia64_choose_gp (obfd, link_info))
1267 gp = _bfd_get_gp_value (obfd);
1271 /* If the data is out of range, do nothing. */
1272 if ((bfd_signed_vma) (symaddr - gp) >= 0x200000
1273 ||(bfd_signed_vma) (symaddr - gp) < -0x200000)
1276 if (r_type == R_IA64_LTOFF22X)
1278 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
1280 changed_relocs = TRUE;
1281 if (dyn_i->want_gotx)
1283 dyn_i->want_gotx = 0;
1284 changed_got |= !dyn_i->want_got;
1289 elfNN_ia64_relax_ldxmov (contents, roff);
1290 irel->r_info = ELFNN_R_INFO (0, R_IA64_NONE);
1291 changed_contents = TRUE;
1292 changed_relocs = TRUE;
1297 /* ??? If we created fixups, this may push the code segment large
1298 enough that the data segment moves, which will change the GP.
1299 Reset the GP so that we re-calculate next round. We need to
1300 do this at the _beginning_ of the next round; now will not do. */
1302 /* Clean up and go home. */
1305 struct one_fixup *f = fixups;
1306 fixups = fixups->next;
1311 && symtab_hdr->contents != (unsigned char *) isymbuf)
1313 if (! link_info->keep_memory)
1317 /* Cache the symbols for elf_link_input_bfd. */
1318 symtab_hdr->contents = (unsigned char *) isymbuf;
1322 if (contents != NULL
1323 && elf_section_data (sec)->this_hdr.contents != contents)
1325 if (!changed_contents && !link_info->keep_memory)
1329 /* Cache the section contents for elf_link_input_bfd. */
1330 elf_section_data (sec)->this_hdr.contents = contents;
1334 if (elf_section_data (sec)->relocs != internal_relocs)
1336 if (!changed_relocs)
1337 free (internal_relocs);
1339 elf_section_data (sec)->relocs = internal_relocs;
1344 struct elfNN_ia64_allocate_data data;
1345 data.info = link_info;
1347 ia64_info->self_dtpmod_offset = (bfd_vma) -1;
1349 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data);
1350 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data);
1351 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data);
1352 ia64_info->got_sec->size = data.ofs;
1354 if (ia64_info->root.dynamic_sections_created
1355 && ia64_info->rel_got_sec != NULL)
1357 /* Resize .rela.got. */
1358 ia64_info->rel_got_sec->size = 0;
1359 if (link_info->shared
1360 && ia64_info->self_dtpmod_offset != (bfd_vma) -1)
1361 ia64_info->rel_got_sec->size += sizeof (ElfNN_External_Rela);
1362 data.only_got = TRUE;
1363 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries,
1368 if (link_info->relax_pass == 0)
1370 /* Pass 0 is only needed to relax br. */
1371 sec->skip_relax_pass_0 = skip_relax_pass_0;
1372 sec->skip_relax_pass_1 = skip_relax_pass_1;
1375 *again = changed_contents || changed_relocs;
1379 if (isymbuf != NULL && (unsigned char *) isymbuf != symtab_hdr->contents)
1381 if (contents != NULL
1382 && elf_section_data (sec)->this_hdr.contents != contents)
1384 if (internal_relocs != NULL
1385 && elf_section_data (sec)->relocs != internal_relocs)
1386 free (internal_relocs);
1389 #undef skip_relax_pass_0
1390 #undef skip_relax_pass_1
1393 elfNN_ia64_relax_ldxmov (contents, off)
1398 bfd_vma dword, insn;
1400 switch ((int)off & 0x3)
1402 case 0: shift = 5; break;
1403 case 1: shift = 14; off += 3; break;
1404 case 2: shift = 23; off += 6; break;
1409 dword = bfd_getl64 (contents + off);
1410 insn = (dword >> shift) & 0x1ffffffffffLL;
1412 r1 = (insn >> 6) & 127;
1413 r3 = (insn >> 20) & 127;
1415 insn = 0x8000000; /* nop */
1417 insn = (insn & 0x7f01fff) | 0x10800000000LL; /* (qp) mov r1 = r3 */
1419 dword &= ~(0x1ffffffffffLL << shift);
1420 dword |= (insn << shift);
1421 bfd_putl64 (dword, contents + off);
1424 /* Return TRUE if NAME is an unwind table section name. */
1426 static inline bfd_boolean
1427 is_unwind_section_name (bfd *abfd, const char *name)
1429 if (elfNN_ia64_hpux_vec (abfd->xvec)
1430 && !strcmp (name, ELF_STRING_ia64_unwind_hdr))
1433 return ((CONST_STRNEQ (name, ELF_STRING_ia64_unwind)
1434 && ! CONST_STRNEQ (name, ELF_STRING_ia64_unwind_info))
1435 || CONST_STRNEQ (name, ELF_STRING_ia64_unwind_once));
1438 /* Handle an IA-64 specific section when reading an object file. This
1439 is called when bfd_section_from_shdr finds a section with an unknown
1443 elfNN_ia64_section_from_shdr (bfd *abfd,
1444 Elf_Internal_Shdr *hdr,
1450 /* There ought to be a place to keep ELF backend specific flags, but
1451 at the moment there isn't one. We just keep track of the
1452 sections by their name, instead. Fortunately, the ABI gives
1453 suggested names for all the MIPS specific sections, so we will
1454 probably get away with this. */
1455 switch (hdr->sh_type)
1457 case SHT_IA_64_UNWIND:
1458 case SHT_IA_64_HP_OPT_ANOT:
1462 if (strcmp (name, ELF_STRING_ia64_archext) != 0)
1470 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1472 newsect = hdr->bfd_section;
1477 /* Convert IA-64 specific section flags to bfd internal section flags. */
1479 /* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
1483 elfNN_ia64_section_flags (flags, hdr)
1485 const Elf_Internal_Shdr *hdr;
1487 if (hdr->sh_flags & SHF_IA_64_SHORT)
1488 *flags |= SEC_SMALL_DATA;
1493 /* Set the correct type for an IA-64 ELF section. We do this by the
1494 section name, which is a hack, but ought to work. */
1497 elfNN_ia64_fake_sections (abfd, hdr, sec)
1498 bfd *abfd ATTRIBUTE_UNUSED;
1499 Elf_Internal_Shdr *hdr;
1502 register const char *name;
1504 name = bfd_get_section_name (abfd, sec);
1506 if (is_unwind_section_name (abfd, name))
1508 /* We don't have the sections numbered at this point, so sh_info
1509 is set later, in elfNN_ia64_final_write_processing. */
1510 hdr->sh_type = SHT_IA_64_UNWIND;
1511 hdr->sh_flags |= SHF_LINK_ORDER;
1513 else if (strcmp (name, ELF_STRING_ia64_archext) == 0)
1514 hdr->sh_type = SHT_IA_64_EXT;
1515 else if (strcmp (name, ".HP.opt_annot") == 0)
1516 hdr->sh_type = SHT_IA_64_HP_OPT_ANOT;
1517 else if (strcmp (name, ".reloc") == 0)
1518 /* This is an ugly, but unfortunately necessary hack that is
1519 needed when producing EFI binaries on IA-64. It tells
1520 elf.c:elf_fake_sections() not to consider ".reloc" as a section
1521 containing ELF relocation info. We need this hack in order to
1522 be able to generate ELF binaries that can be translated into
1523 EFI applications (which are essentially COFF objects). Those
1524 files contain a COFF ".reloc" section inside an ELFNN object,
1525 which would normally cause BFD to segfault because it would
1526 attempt to interpret this section as containing relocation
1527 entries for section "oc". With this hack enabled, ".reloc"
1528 will be treated as a normal data section, which will avoid the
1529 segfault. However, you won't be able to create an ELFNN binary
1530 with a section named "oc" that needs relocations, but that's
1531 the kind of ugly side-effects you get when detecting section
1532 types based on their names... In practice, this limitation is
1533 unlikely to bite. */
1534 hdr->sh_type = SHT_PROGBITS;
1536 if (sec->flags & SEC_SMALL_DATA)
1537 hdr->sh_flags |= SHF_IA_64_SHORT;
1539 /* Some HP linkers look for the SHF_IA_64_HP_TLS flag instead of SHF_TLS. */
1541 if (elfNN_ia64_hpux_vec (abfd->xvec) && (sec->flags & SHF_TLS))
1542 hdr->sh_flags |= SHF_IA_64_HP_TLS;
1547 /* The final processing done just before writing out an IA-64 ELF
1551 elfNN_ia64_final_write_processing (abfd, linker)
1553 bfd_boolean linker ATTRIBUTE_UNUSED;
1555 Elf_Internal_Shdr *hdr;
1558 for (s = abfd->sections; s; s = s->next)
1560 hdr = &elf_section_data (s)->this_hdr;
1561 switch (hdr->sh_type)
1563 case SHT_IA_64_UNWIND:
1564 /* The IA-64 processor-specific ABI requires setting sh_link
1565 to the unwind section, whereas HP-UX requires sh_info to
1566 do so. For maximum compatibility, we'll set both for
1568 hdr->sh_info = hdr->sh_link;
1573 if (! elf_flags_init (abfd))
1575 unsigned long flags = 0;
1577 if (abfd->xvec->byteorder == BFD_ENDIAN_BIG)
1578 flags |= EF_IA_64_BE;
1579 if (bfd_get_mach (abfd) == bfd_mach_ia64_elf64)
1580 flags |= EF_IA_64_ABI64;
1582 elf_elfheader(abfd)->e_flags = flags;
1583 elf_flags_init (abfd) = TRUE;
1587 /* Hook called by the linker routine which adds symbols from an object
1588 file. We use it to put .comm items in .sbss, and not .bss. */
1591 elfNN_ia64_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1593 struct bfd_link_info *info;
1594 Elf_Internal_Sym *sym;
1595 const char **namep ATTRIBUTE_UNUSED;
1596 flagword *flagsp ATTRIBUTE_UNUSED;
1600 if (sym->st_shndx == SHN_COMMON
1601 && !info->relocatable
1602 && sym->st_size <= elf_gp_size (abfd))
1604 /* Common symbols less than or equal to -G nn bytes are
1605 automatically put into .sbss. */
1607 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1611 scomm = bfd_make_section_with_flags (abfd, ".scommon",
1614 | SEC_LINKER_CREATED));
1620 *valp = sym->st_size;
1626 /* Return the number of additional phdrs we will need. */
1629 elfNN_ia64_additional_program_headers (bfd *abfd,
1630 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1635 /* See if we need a PT_IA_64_ARCHEXT segment. */
1636 s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_archext);
1637 if (s && (s->flags & SEC_LOAD))
1640 /* Count how many PT_IA_64_UNWIND segments we need. */
1641 for (s = abfd->sections; s; s = s->next)
1642 if (is_unwind_section_name (abfd, s->name) && (s->flags & SEC_LOAD))
1649 elfNN_ia64_modify_segment_map (bfd *abfd,
1650 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1652 struct elf_segment_map *m, **pm;
1653 Elf_Internal_Shdr *hdr;
1656 /* If we need a PT_IA_64_ARCHEXT segment, it must come before
1657 all PT_LOAD segments. */
1658 s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_archext);
1659 if (s && (s->flags & SEC_LOAD))
1661 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
1662 if (m->p_type == PT_IA_64_ARCHEXT)
1666 m = ((struct elf_segment_map *)
1667 bfd_zalloc (abfd, (bfd_size_type) sizeof *m));
1671 m->p_type = PT_IA_64_ARCHEXT;
1675 /* We want to put it after the PHDR and INTERP segments. */
1676 pm = &elf_tdata (abfd)->segment_map;
1678 && ((*pm)->p_type == PT_PHDR
1679 || (*pm)->p_type == PT_INTERP))
1687 /* Install PT_IA_64_UNWIND segments, if needed. */
1688 for (s = abfd->sections; s; s = s->next)
1690 hdr = &elf_section_data (s)->this_hdr;
1691 if (hdr->sh_type != SHT_IA_64_UNWIND)
1694 if (s && (s->flags & SEC_LOAD))
1696 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
1697 if (m->p_type == PT_IA_64_UNWIND)
1701 /* Look through all sections in the unwind segment
1702 for a match since there may be multiple sections
1704 for (i = m->count - 1; i >= 0; --i)
1705 if (m->sections[i] == s)
1714 m = ((struct elf_segment_map *)
1715 bfd_zalloc (abfd, (bfd_size_type) sizeof *m));
1719 m->p_type = PT_IA_64_UNWIND;
1724 /* We want to put it last. */
1725 pm = &elf_tdata (abfd)->segment_map;
1736 /* Turn on PF_IA_64_NORECOV if needed. This involves traversing all of
1737 the input sections for each output section in the segment and testing
1738 for SHF_IA_64_NORECOV on each. */
1741 elfNN_ia64_modify_program_headers (bfd *abfd,
1742 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1744 struct elf_obj_tdata *tdata = elf_tdata (abfd);
1745 struct elf_segment_map *m;
1746 Elf_Internal_Phdr *p;
1748 for (p = tdata->phdr, m = tdata->segment_map; m != NULL; m = m->next, p++)
1749 if (m->p_type == PT_LOAD)
1752 for (i = m->count - 1; i >= 0; --i)
1754 struct bfd_link_order *order = m->sections[i]->map_head.link_order;
1756 while (order != NULL)
1758 if (order->type == bfd_indirect_link_order)
1760 asection *is = order->u.indirect.section;
1761 bfd_vma flags = elf_section_data(is)->this_hdr.sh_flags;
1762 if (flags & SHF_IA_64_NORECOV)
1764 p->p_flags |= PF_IA_64_NORECOV;
1768 order = order->next;
1777 /* According to the Tahoe assembler spec, all labels starting with a
1781 elfNN_ia64_is_local_label_name (abfd, name)
1782 bfd *abfd ATTRIBUTE_UNUSED;
1785 return name[0] == '.';
1788 /* Should we do dynamic things to this symbol? */
1791 elfNN_ia64_dynamic_symbol_p (h, info, r_type)
1792 struct elf_link_hash_entry *h;
1793 struct bfd_link_info *info;
1796 bfd_boolean ignore_protected
1797 = ((r_type & 0xf8) == 0x40 /* FPTR relocs */
1798 || (r_type & 0xf8) == 0x50); /* LTOFF_FPTR relocs */
1800 return _bfd_elf_dynamic_symbol_p (h, info, ignore_protected);
1803 static struct bfd_hash_entry*
1804 elfNN_ia64_new_elf_hash_entry (entry, table, string)
1805 struct bfd_hash_entry *entry;
1806 struct bfd_hash_table *table;
1809 struct elfNN_ia64_link_hash_entry *ret;
1810 ret = (struct elfNN_ia64_link_hash_entry *) entry;
1812 /* Allocate the structure if it has not already been allocated by a
1815 ret = bfd_hash_allocate (table, sizeof (*ret));
1820 /* Call the allocation method of the superclass. */
1821 ret = ((struct elfNN_ia64_link_hash_entry *)
1822 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1827 ret->sorted_count = 0;
1829 return (struct bfd_hash_entry *) ret;
1833 elfNN_ia64_hash_copy_indirect (info, xdir, xind)
1834 struct bfd_link_info *info;
1835 struct elf_link_hash_entry *xdir, *xind;
1837 struct elfNN_ia64_link_hash_entry *dir, *ind;
1839 dir = (struct elfNN_ia64_link_hash_entry *) xdir;
1840 ind = (struct elfNN_ia64_link_hash_entry *) xind;
1842 /* Copy down any references that we may have already seen to the
1843 symbol which just became indirect. */
1845 dir->root.ref_dynamic |= ind->root.ref_dynamic;
1846 dir->root.ref_regular |= ind->root.ref_regular;
1847 dir->root.ref_regular_nonweak |= ind->root.ref_regular_nonweak;
1848 dir->root.needs_plt |= ind->root.needs_plt;
1850 if (ind->root.root.type != bfd_link_hash_indirect)
1853 /* Copy over the got and plt data. This would have been done
1856 if (ind->info != NULL)
1858 struct elfNN_ia64_dyn_sym_info *dyn_i;
1864 dir->info = ind->info;
1865 dir->count = ind->count;
1866 dir->sorted_count = ind->sorted_count;
1867 dir->size = ind->size;
1871 ind->sorted_count = 0;
1874 /* Fix up the dyn_sym_info pointers to the global symbol. */
1875 for (count = dir->count, dyn_i = dir->info;
1878 dyn_i->h = &dir->root;
1881 /* Copy over the dynindx. */
1883 if (ind->root.dynindx != -1)
1885 if (dir->root.dynindx != -1)
1886 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1887 dir->root.dynstr_index);
1888 dir->root.dynindx = ind->root.dynindx;
1889 dir->root.dynstr_index = ind->root.dynstr_index;
1890 ind->root.dynindx = -1;
1891 ind->root.dynstr_index = 0;
1896 elfNN_ia64_hash_hide_symbol (info, xh, force_local)
1897 struct bfd_link_info *info;
1898 struct elf_link_hash_entry *xh;
1899 bfd_boolean force_local;
1901 struct elfNN_ia64_link_hash_entry *h;
1902 struct elfNN_ia64_dyn_sym_info *dyn_i;
1905 h = (struct elfNN_ia64_link_hash_entry *)xh;
1907 _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local);
1909 for (count = h->count, dyn_i = h->info;
1913 dyn_i->want_plt2 = 0;
1914 dyn_i->want_plt = 0;
1918 /* Compute a hash of a local hash entry. */
1921 elfNN_ia64_local_htab_hash (ptr)
1924 struct elfNN_ia64_local_hash_entry *entry
1925 = (struct elfNN_ia64_local_hash_entry *) ptr;
1927 return (((entry->id & 0xff) << 24) | ((entry->id & 0xff00) << 8))
1928 ^ entry->r_sym ^ (entry->id >> 16);
1931 /* Compare local hash entries. */
1934 elfNN_ia64_local_htab_eq (ptr1, ptr2)
1935 const void *ptr1, *ptr2;
1937 struct elfNN_ia64_local_hash_entry *entry1
1938 = (struct elfNN_ia64_local_hash_entry *) ptr1;
1939 struct elfNN_ia64_local_hash_entry *entry2
1940 = (struct elfNN_ia64_local_hash_entry *) ptr2;
1942 return entry1->id == entry2->id && entry1->r_sym == entry2->r_sym;
1945 /* Create the derived linker hash table. The IA-64 ELF port uses this
1946 derived hash table to keep information specific to the IA-64 ElF
1947 linker (without using static variables). */
1949 static struct bfd_link_hash_table*
1950 elfNN_ia64_hash_table_create (abfd)
1953 struct elfNN_ia64_link_hash_table *ret;
1955 ret = bfd_zmalloc ((bfd_size_type) sizeof (*ret));
1959 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
1960 elfNN_ia64_new_elf_hash_entry,
1961 sizeof (struct elfNN_ia64_link_hash_entry)))
1967 ret->loc_hash_table = htab_try_create (1024, elfNN_ia64_local_htab_hash,
1968 elfNN_ia64_local_htab_eq, NULL);
1969 ret->loc_hash_memory = objalloc_create ();
1970 if (!ret->loc_hash_table || !ret->loc_hash_memory)
1976 return &ret->root.root;
1979 /* Free the global elfNN_ia64_dyn_sym_info array. */
1982 elfNN_ia64_global_dyn_info_free (void **xentry,
1983 PTR unused ATTRIBUTE_UNUSED)
1985 struct elfNN_ia64_link_hash_entry *entry
1986 = (struct elfNN_ia64_link_hash_entry *) xentry;
1988 if (entry->root.root.type == bfd_link_hash_warning)
1989 entry = (struct elfNN_ia64_link_hash_entry *) entry->root.root.u.i.link;
1996 entry->sorted_count = 0;
2003 /* Free the local elfNN_ia64_dyn_sym_info array. */
2006 elfNN_ia64_local_dyn_info_free (void **slot,
2007 PTR unused ATTRIBUTE_UNUSED)
2009 struct elfNN_ia64_local_hash_entry *entry
2010 = (struct elfNN_ia64_local_hash_entry *) *slot;
2017 entry->sorted_count = 0;
2024 /* Destroy IA-64 linker hash table. */
2027 elfNN_ia64_hash_table_free (hash)
2028 struct bfd_link_hash_table *hash;
2030 struct elfNN_ia64_link_hash_table *ia64_info
2031 = (struct elfNN_ia64_link_hash_table *) hash;
2032 if (ia64_info->loc_hash_table)
2034 htab_traverse (ia64_info->loc_hash_table,
2035 elfNN_ia64_local_dyn_info_free, NULL);
2036 htab_delete (ia64_info->loc_hash_table);
2038 if (ia64_info->loc_hash_memory)
2039 objalloc_free ((struct objalloc *) ia64_info->loc_hash_memory);
2040 elf_link_hash_traverse (&ia64_info->root,
2041 elfNN_ia64_global_dyn_info_free, NULL);
2042 _bfd_generic_link_hash_table_free (hash);
2045 /* Traverse both local and global hash tables. */
2047 struct elfNN_ia64_dyn_sym_traverse_data
2049 bfd_boolean (*func) PARAMS ((struct elfNN_ia64_dyn_sym_info *, PTR));
2054 elfNN_ia64_global_dyn_sym_thunk (xentry, xdata)
2055 struct bfd_hash_entry *xentry;
2058 struct elfNN_ia64_link_hash_entry *entry
2059 = (struct elfNN_ia64_link_hash_entry *) xentry;
2060 struct elfNN_ia64_dyn_sym_traverse_data *data
2061 = (struct elfNN_ia64_dyn_sym_traverse_data *) xdata;
2062 struct elfNN_ia64_dyn_sym_info *dyn_i;
2065 if (entry->root.root.type == bfd_link_hash_warning)
2066 entry = (struct elfNN_ia64_link_hash_entry *) entry->root.root.u.i.link;
2068 for (count = entry->count, dyn_i = entry->info;
2071 if (! (*data->func) (dyn_i, data->data))
2077 elfNN_ia64_local_dyn_sym_thunk (slot, xdata)
2081 struct elfNN_ia64_local_hash_entry *entry
2082 = (struct elfNN_ia64_local_hash_entry *) *slot;
2083 struct elfNN_ia64_dyn_sym_traverse_data *data
2084 = (struct elfNN_ia64_dyn_sym_traverse_data *) xdata;
2085 struct elfNN_ia64_dyn_sym_info *dyn_i;
2088 for (count = entry->count, dyn_i = entry->info;
2091 if (! (*data->func) (dyn_i, data->data))
2097 elfNN_ia64_dyn_sym_traverse (ia64_info, func, data)
2098 struct elfNN_ia64_link_hash_table *ia64_info;
2099 bfd_boolean (*func) PARAMS ((struct elfNN_ia64_dyn_sym_info *, PTR));
2102 struct elfNN_ia64_dyn_sym_traverse_data xdata;
2107 elf_link_hash_traverse (&ia64_info->root,
2108 elfNN_ia64_global_dyn_sym_thunk, &xdata);
2109 htab_traverse (ia64_info->loc_hash_table,
2110 elfNN_ia64_local_dyn_sym_thunk, &xdata);
2114 elfNN_ia64_create_dynamic_sections (abfd, info)
2116 struct bfd_link_info *info;
2118 struct elfNN_ia64_link_hash_table *ia64_info;
2121 if (! _bfd_elf_create_dynamic_sections (abfd, info))
2124 ia64_info = elfNN_ia64_hash_table (info);
2126 ia64_info->plt_sec = bfd_get_section_by_name (abfd, ".plt");
2127 ia64_info->got_sec = bfd_get_section_by_name (abfd, ".got");
2130 flagword flags = bfd_get_section_flags (abfd, ia64_info->got_sec);
2131 bfd_set_section_flags (abfd, ia64_info->got_sec, SEC_SMALL_DATA | flags);
2132 /* The .got section is always aligned at 8 bytes. */
2133 bfd_set_section_alignment (abfd, ia64_info->got_sec, 3);
2136 if (!get_pltoff (abfd, info, ia64_info))
2139 s = bfd_make_section_with_flags (abfd, ".rela.IA_64.pltoff",
2140 (SEC_ALLOC | SEC_LOAD
2143 | SEC_LINKER_CREATED
2146 || !bfd_set_section_alignment (abfd, s, LOG_SECTION_ALIGN))
2148 ia64_info->rel_pltoff_sec = s;
2150 s = bfd_make_section_with_flags (abfd, ".rela.got",
2151 (SEC_ALLOC | SEC_LOAD
2154 | SEC_LINKER_CREATED
2157 || !bfd_set_section_alignment (abfd, s, LOG_SECTION_ALIGN))
2159 ia64_info->rel_got_sec = s;
2164 /* Find and/or create a hash entry for local symbol. */
2165 static struct elfNN_ia64_local_hash_entry *
2166 get_local_sym_hash (ia64_info, abfd, rel, create)
2167 struct elfNN_ia64_link_hash_table *ia64_info;
2169 const Elf_Internal_Rela *rel;
2172 struct elfNN_ia64_local_hash_entry e, *ret;
2173 asection *sec = abfd->sections;
2174 hashval_t h = (((sec->id & 0xff) << 24) | ((sec->id & 0xff00) << 8))
2175 ^ ELFNN_R_SYM (rel->r_info) ^ (sec->id >> 16);
2179 e.r_sym = ELFNN_R_SYM (rel->r_info);
2180 slot = htab_find_slot_with_hash (ia64_info->loc_hash_table, &e, h,
2181 create ? INSERT : NO_INSERT);
2187 return (struct elfNN_ia64_local_hash_entry *) *slot;
2189 ret = (struct elfNN_ia64_local_hash_entry *)
2190 objalloc_alloc ((struct objalloc *) ia64_info->loc_hash_memory,
2191 sizeof (struct elfNN_ia64_local_hash_entry));
2194 memset (ret, 0, sizeof (*ret));
2196 ret->r_sym = ELFNN_R_SYM (rel->r_info);
2202 /* Used to sort elfNN_ia64_dyn_sym_info array. */
2205 addend_compare (const void *xp, const void *yp)
2207 const struct elfNN_ia64_dyn_sym_info *x
2208 = (const struct elfNN_ia64_dyn_sym_info *) xp;
2209 const struct elfNN_ia64_dyn_sym_info *y
2210 = (const struct elfNN_ia64_dyn_sym_info *) yp;
2212 return x->addend < y->addend ? -1 : x->addend > y->addend ? 1 : 0;
2215 /* Sort elfNN_ia64_dyn_sym_info array and remove duplicates. */
2218 sort_dyn_sym_info (struct elfNN_ia64_dyn_sym_info *info,
2222 unsigned int i, dup, diff, dest, src, len;
2224 qsort (info, count, sizeof (*info), addend_compare);
2226 /* Find the first duplicate. */
2227 prev = info [0].addend;
2228 for (i = 1; i < count; i++)
2230 curr = info [i].addend;
2236 /* Remove duplicates. */
2239 /* We need to move a block of elements to here. */
2243 curr = info [i].addend;
2245 /* Move a block of elements whose first one is different from
2249 for (src = i + 1; src < count; src++)
2250 if (info [src].addend != curr)
2259 /* Find the next duplicate. */
2260 prev = info [src].addend;
2261 for (dup = src + 1; dup < count; dup++)
2263 curr = info [dup].addend;
2269 /* How much to move. */
2273 if (len == 1 && dup < count)
2275 /* If we only move 1 element, we combine it with the next
2276 one. Find the next different one. */
2277 for (diff = dup + 1, src++; diff < count; diff++, src++)
2278 if (info [diff].addend != curr)
2283 /* Find the next duplicate. */
2284 prev = info [diff].addend;
2285 for (dup = diff + 1; dup < count; dup++)
2287 curr = info [dup].addend;
2294 len = diff - src + 1;
2299 memmove (&info [dest], &info [src], len * sizeof (*info));
2310 /* Find and/or create a descriptor for dynamic symbol info. This will
2311 vary based on global or local symbol, and the addend to the reloc.
2313 We don't sort when inserting. Also, we sort and eliminate
2314 duplicates if there is an unsorted section. Typically, this will
2315 only happen once, because we do all insertions before lookups. We
2316 then use bsearch to do a lookup. This also allows lookups to be
2317 fast. So we have fast insertion (O(log N) due to duplicate check),
2318 fast lookup (O(log N)) and one sort (O(N log N) expected time).
2319 Previously, all lookups were O(N) because of the use of the linked
2320 list and also all insertions were O(N) because of the check for
2321 duplicates. There are some complications here because the array
2322 size grows occasionally, which may add an O(N) factor, but this
2323 should be rare. Also, we free the excess array allocation, which
2324 requires a copy which is O(N), but this only happens once. */
2326 static struct elfNN_ia64_dyn_sym_info *
2327 get_dyn_sym_info (ia64_info, h, abfd, rel, create)
2328 struct elfNN_ia64_link_hash_table *ia64_info;
2329 struct elf_link_hash_entry *h;
2331 const Elf_Internal_Rela *rel;
2334 struct elfNN_ia64_dyn_sym_info **info_p, *info, *dyn_i, key;
2335 unsigned int *count_p, *sorted_count_p, *size_p;
2336 unsigned int count, sorted_count, size;
2337 bfd_vma addend = rel ? rel->r_addend : 0;
2342 struct elfNN_ia64_link_hash_entry *global_h;
2344 global_h = (struct elfNN_ia64_link_hash_entry *) h;
2345 info_p = &global_h->info;
2346 count_p = &global_h->count;
2347 sorted_count_p = &global_h->sorted_count;
2348 size_p = &global_h->size;
2352 struct elfNN_ia64_local_hash_entry *loc_h;
2354 loc_h = get_local_sym_hash (ia64_info, abfd, rel, create);
2357 BFD_ASSERT (!create);
2361 info_p = &loc_h->info;
2362 count_p = &loc_h->count;
2363 sorted_count_p = &loc_h->sorted_count;
2364 size_p = &loc_h->size;
2368 sorted_count = *sorted_count_p;
2373 /* When we create the array, we don't check for duplicates,
2374 except in the previously sorted section if one exists, and
2375 against the last inserted entry. This allows insertions to
2381 /* Try bsearch first on the sorted section. */
2382 key.addend = addend;
2383 dyn_i = bsearch (&key, info, sorted_count,
2384 sizeof (*info), addend_compare);
2392 /* Do a quick check for the last inserted entry. */
2393 dyn_i = info + count - 1;
2394 if (dyn_i->addend == addend)
2402 /* It is the very first element. We create the array of size
2405 amt = size * sizeof (*info);
2406 info = bfd_malloc (amt);
2408 else if (size <= count)
2410 /* We double the array size every time when we reach the
2413 amt = size * sizeof (*info);
2414 info = bfd_realloc (info, amt);
2425 /* Append the new one to the array. */
2426 dyn_i = info + count;
2427 memset (dyn_i, 0, sizeof (*dyn_i));
2428 dyn_i->addend = addend;
2430 /* We increment count only since the new ones are unsorted and
2431 may have duplicate. */
2436 /* It is a lookup without insertion. Sort array if part of the
2437 array isn't sorted. */
2438 if (count != sorted_count)
2440 count = sort_dyn_sym_info (info, count);
2442 *sorted_count_p = count;
2445 /* Free unused memory. */
2448 amt = count * sizeof (*info);
2449 info = bfd_malloc (amt);
2452 memcpy (info, *info_p, amt);
2459 key.addend = addend;
2460 dyn_i = bsearch (&key, info, count,
2461 sizeof (*info), addend_compare);
2468 get_got (abfd, info, ia64_info)
2470 struct bfd_link_info *info;
2471 struct elfNN_ia64_link_hash_table *ia64_info;
2476 got = ia64_info->got_sec;
2481 dynobj = ia64_info->root.dynobj;
2483 ia64_info->root.dynobj = dynobj = abfd;
2484 if (!_bfd_elf_create_got_section (dynobj, info))
2487 got = bfd_get_section_by_name (dynobj, ".got");
2489 ia64_info->got_sec = got;
2491 /* The .got section is always aligned at 8 bytes. */
2492 if (!bfd_set_section_alignment (abfd, got, 3))
2495 flags = bfd_get_section_flags (abfd, got);
2496 bfd_set_section_flags (abfd, got, SEC_SMALL_DATA | flags);
2502 /* Create function descriptor section (.opd). This section is called .opd
2503 because it contains "official procedure descriptors". The "official"
2504 refers to the fact that these descriptors are used when taking the address
2505 of a procedure, thus ensuring a unique address for each procedure. */
2508 get_fptr (abfd, info, ia64_info)
2510 struct bfd_link_info *info;
2511 struct elfNN_ia64_link_hash_table *ia64_info;
2516 fptr = ia64_info->fptr_sec;
2519 dynobj = ia64_info->root.dynobj;
2521 ia64_info->root.dynobj = dynobj = abfd;
2523 fptr = bfd_make_section_with_flags (dynobj, ".opd",
2528 | (info->pie ? 0 : SEC_READONLY)
2529 | SEC_LINKER_CREATED));
2531 || !bfd_set_section_alignment (abfd, fptr, 4))
2537 ia64_info->fptr_sec = fptr;
2542 fptr_rel = bfd_make_section_with_flags (dynobj, ".rela.opd",
2543 (SEC_ALLOC | SEC_LOAD
2546 | SEC_LINKER_CREATED
2548 if (fptr_rel == NULL
2549 || !bfd_set_section_alignment (abfd, fptr_rel,
2556 ia64_info->rel_fptr_sec = fptr_rel;
2564 get_pltoff (abfd, info, ia64_info)
2566 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2567 struct elfNN_ia64_link_hash_table *ia64_info;
2572 pltoff = ia64_info->pltoff_sec;
2575 dynobj = ia64_info->root.dynobj;
2577 ia64_info->root.dynobj = dynobj = abfd;
2579 pltoff = bfd_make_section_with_flags (dynobj,
2580 ELF_STRING_ia64_pltoff,
2586 | SEC_LINKER_CREATED));
2588 || !bfd_set_section_alignment (abfd, pltoff, 4))
2594 ia64_info->pltoff_sec = pltoff;
2601 get_reloc_section (abfd, ia64_info, sec, create)
2603 struct elfNN_ia64_link_hash_table *ia64_info;
2607 const char *srel_name;
2611 srel_name = (bfd_elf_string_from_elf_section
2612 (abfd, elf_elfheader(abfd)->e_shstrndx,
2613 elf_section_data(sec)->rel_hdr.sh_name));
2614 if (srel_name == NULL)
2617 BFD_ASSERT ((CONST_STRNEQ (srel_name, ".rela")
2618 && strcmp (bfd_get_section_name (abfd, sec),
2620 || (CONST_STRNEQ (srel_name, ".rel")
2621 && strcmp (bfd_get_section_name (abfd, sec),
2622 srel_name+4) == 0));
2624 dynobj = ia64_info->root.dynobj;
2626 ia64_info->root.dynobj = dynobj = abfd;
2628 srel = bfd_get_section_by_name (dynobj, srel_name);
2629 if (srel == NULL && create)
2631 srel = bfd_make_section_with_flags (dynobj, srel_name,
2632 (SEC_ALLOC | SEC_LOAD
2635 | SEC_LINKER_CREATED
2638 || !bfd_set_section_alignment (dynobj, srel,
2647 count_dyn_reloc (bfd *abfd, struct elfNN_ia64_dyn_sym_info *dyn_i,
2648 asection *srel, int type, bfd_boolean reltext)
2650 struct elfNN_ia64_dyn_reloc_entry *rent;
2652 for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
2653 if (rent->srel == srel && rent->type == type)
2658 rent = ((struct elfNN_ia64_dyn_reloc_entry *)
2659 bfd_alloc (abfd, (bfd_size_type) sizeof (*rent)));
2663 rent->next = dyn_i->reloc_entries;
2667 dyn_i->reloc_entries = rent;
2669 rent->reltext = reltext;
2676 elfNN_ia64_check_relocs (abfd, info, sec, relocs)
2678 struct bfd_link_info *info;
2680 const Elf_Internal_Rela *relocs;
2682 struct elfNN_ia64_link_hash_table *ia64_info;
2683 const Elf_Internal_Rela *relend;
2684 Elf_Internal_Shdr *symtab_hdr;
2685 const Elf_Internal_Rela *rel;
2686 asection *got, *fptr, *srel, *pltoff;
2695 NEED_LTOFF_FPTR = 128,
2701 struct elf_link_hash_entry *h;
2702 unsigned long r_symndx;
2703 bfd_boolean maybe_dynamic;
2705 if (info->relocatable)
2708 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2709 ia64_info = elfNN_ia64_hash_table (info);
2711 got = fptr = srel = pltoff = NULL;
2713 relend = relocs + sec->reloc_count;
2715 /* We scan relocations first to create dynamic relocation arrays. We
2716 modified get_dyn_sym_info to allow fast insertion and support fast
2717 lookup in the next loop. */
2718 for (rel = relocs; rel < relend; ++rel)
2720 r_symndx = ELFNN_R_SYM (rel->r_info);
2721 if (r_symndx >= symtab_hdr->sh_info)
2723 long indx = r_symndx - symtab_hdr->sh_info;
2724 h = elf_sym_hashes (abfd)[indx];
2725 while (h->root.type == bfd_link_hash_indirect
2726 || h->root.type == bfd_link_hash_warning)
2727 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2732 /* We can only get preliminary data on whether a symbol is
2733 locally or externally defined, as not all of the input files
2734 have yet been processed. Do something with what we know, as
2735 this may help reduce memory usage and processing time later. */
2736 maybe_dynamic = (h && ((!info->executable
2737 && (!SYMBOLIC_BIND (info, h)
2738 || info->unresolved_syms_in_shared_libs == RM_IGNORE))
2740 || h->root.type == bfd_link_hash_defweak));
2743 switch (ELFNN_R_TYPE (rel->r_info))
2745 case R_IA64_TPREL64MSB:
2746 case R_IA64_TPREL64LSB:
2747 if (info->shared || maybe_dynamic)
2748 need_entry = NEED_DYNREL;
2751 case R_IA64_LTOFF_TPREL22:
2752 need_entry = NEED_TPREL;
2754 info->flags |= DF_STATIC_TLS;
2757 case R_IA64_DTPREL32MSB:
2758 case R_IA64_DTPREL32LSB:
2759 case R_IA64_DTPREL64MSB:
2760 case R_IA64_DTPREL64LSB:
2761 if (info->shared || maybe_dynamic)
2762 need_entry = NEED_DYNREL;
2765 case R_IA64_LTOFF_DTPREL22:
2766 need_entry = NEED_DTPREL;
2769 case R_IA64_DTPMOD64MSB:
2770 case R_IA64_DTPMOD64LSB:
2771 if (info->shared || maybe_dynamic)
2772 need_entry = NEED_DYNREL;
2775 case R_IA64_LTOFF_DTPMOD22:
2776 need_entry = NEED_DTPMOD;
2779 case R_IA64_LTOFF_FPTR22:
2780 case R_IA64_LTOFF_FPTR64I:
2781 case R_IA64_LTOFF_FPTR32MSB:
2782 case R_IA64_LTOFF_FPTR32LSB:
2783 case R_IA64_LTOFF_FPTR64MSB:
2784 case R_IA64_LTOFF_FPTR64LSB:
2785 need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR;
2788 case R_IA64_FPTR64I:
2789 case R_IA64_FPTR32MSB:
2790 case R_IA64_FPTR32LSB:
2791 case R_IA64_FPTR64MSB:
2792 case R_IA64_FPTR64LSB:
2793 if (info->shared || h)
2794 need_entry = NEED_FPTR | NEED_DYNREL;
2796 need_entry = NEED_FPTR;
2799 case R_IA64_LTOFF22:
2800 case R_IA64_LTOFF64I:
2801 need_entry = NEED_GOT;
2804 case R_IA64_LTOFF22X:
2805 need_entry = NEED_GOTX;
2808 case R_IA64_PLTOFF22:
2809 case R_IA64_PLTOFF64I:
2810 case R_IA64_PLTOFF64MSB:
2811 case R_IA64_PLTOFF64LSB:
2812 need_entry = NEED_PLTOFF;
2816 need_entry |= NEED_MIN_PLT;
2820 (*info->callbacks->warning)
2821 (info, _("@pltoff reloc against local symbol"), 0,
2822 abfd, 0, (bfd_vma) 0);
2826 case R_IA64_PCREL21B:
2827 case R_IA64_PCREL60B:
2828 /* Depending on where this symbol is defined, we may or may not
2829 need a full plt entry. Only skip if we know we'll not need
2830 the entry -- static or symbolic, and the symbol definition
2831 has already been seen. */
2832 if (maybe_dynamic && rel->r_addend == 0)
2833 need_entry = NEED_FULL_PLT;
2839 case R_IA64_DIR32MSB:
2840 case R_IA64_DIR32LSB:
2841 case R_IA64_DIR64MSB:
2842 case R_IA64_DIR64LSB:
2843 /* Shared objects will always need at least a REL relocation. */
2844 if (info->shared || maybe_dynamic)
2845 need_entry = NEED_DYNREL;
2848 case R_IA64_IPLTMSB:
2849 case R_IA64_IPLTLSB:
2850 /* Shared objects will always need at least a REL relocation. */
2851 if (info->shared || maybe_dynamic)
2852 need_entry = NEED_DYNREL;
2855 case R_IA64_PCREL22:
2856 case R_IA64_PCREL64I:
2857 case R_IA64_PCREL32MSB:
2858 case R_IA64_PCREL32LSB:
2859 case R_IA64_PCREL64MSB:
2860 case R_IA64_PCREL64LSB:
2862 need_entry = NEED_DYNREL;
2869 if ((need_entry & NEED_FPTR) != 0
2872 (*info->callbacks->warning)
2873 (info, _("non-zero addend in @fptr reloc"), 0,
2874 abfd, 0, (bfd_vma) 0);
2877 if (get_dyn_sym_info (ia64_info, h, abfd, rel, TRUE) == NULL)
2881 /* Now, we only do lookup without insertion, which is very fast
2882 with the modified get_dyn_sym_info. */
2883 for (rel = relocs; rel < relend; ++rel)
2885 struct elfNN_ia64_dyn_sym_info *dyn_i;
2886 int dynrel_type = R_IA64_NONE;
2888 r_symndx = ELFNN_R_SYM (rel->r_info);
2889 if (r_symndx >= symtab_hdr->sh_info)
2891 /* We're dealing with a global symbol -- find its hash entry
2892 and mark it as being referenced. */
2893 long indx = r_symndx - symtab_hdr->sh_info;
2894 h = elf_sym_hashes (abfd)[indx];
2895 while (h->root.type == bfd_link_hash_indirect
2896 || h->root.type == bfd_link_hash_warning)
2897 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2904 /* We can only get preliminary data on whether a symbol is
2905 locally or externally defined, as not all of the input files
2906 have yet been processed. Do something with what we know, as
2907 this may help reduce memory usage and processing time later. */
2908 maybe_dynamic = (h && ((!info->executable
2909 && (!SYMBOLIC_BIND (info, h)
2910 || info->unresolved_syms_in_shared_libs == RM_IGNORE))
2912 || h->root.type == bfd_link_hash_defweak));
2915 switch (ELFNN_R_TYPE (rel->r_info))
2917 case R_IA64_TPREL64MSB:
2918 case R_IA64_TPREL64LSB:
2919 if (info->shared || maybe_dynamic)
2920 need_entry = NEED_DYNREL;
2921 dynrel_type = R_IA64_TPREL64LSB;
2923 info->flags |= DF_STATIC_TLS;
2926 case R_IA64_LTOFF_TPREL22:
2927 need_entry = NEED_TPREL;
2929 info->flags |= DF_STATIC_TLS;
2932 case R_IA64_DTPREL32MSB:
2933 case R_IA64_DTPREL32LSB:
2934 case R_IA64_DTPREL64MSB:
2935 case R_IA64_DTPREL64LSB:
2936 if (info->shared || maybe_dynamic)
2937 need_entry = NEED_DYNREL;
2938 dynrel_type = R_IA64_DTPRELNNLSB;
2941 case R_IA64_LTOFF_DTPREL22:
2942 need_entry = NEED_DTPREL;
2945 case R_IA64_DTPMOD64MSB:
2946 case R_IA64_DTPMOD64LSB:
2947 if (info->shared || maybe_dynamic)
2948 need_entry = NEED_DYNREL;
2949 dynrel_type = R_IA64_DTPMOD64LSB;
2952 case R_IA64_LTOFF_DTPMOD22:
2953 need_entry = NEED_DTPMOD;
2956 case R_IA64_LTOFF_FPTR22:
2957 case R_IA64_LTOFF_FPTR64I:
2958 case R_IA64_LTOFF_FPTR32MSB:
2959 case R_IA64_LTOFF_FPTR32LSB:
2960 case R_IA64_LTOFF_FPTR64MSB:
2961 case R_IA64_LTOFF_FPTR64LSB:
2962 need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR;
2965 case R_IA64_FPTR64I:
2966 case R_IA64_FPTR32MSB:
2967 case R_IA64_FPTR32LSB:
2968 case R_IA64_FPTR64MSB:
2969 case R_IA64_FPTR64LSB:
2970 if (info->shared || h)
2971 need_entry = NEED_FPTR | NEED_DYNREL;
2973 need_entry = NEED_FPTR;
2974 dynrel_type = R_IA64_FPTRNNLSB;
2977 case R_IA64_LTOFF22:
2978 case R_IA64_LTOFF64I:
2979 need_entry = NEED_GOT;
2982 case R_IA64_LTOFF22X:
2983 need_entry = NEED_GOTX;
2986 case R_IA64_PLTOFF22:
2987 case R_IA64_PLTOFF64I:
2988 case R_IA64_PLTOFF64MSB:
2989 case R_IA64_PLTOFF64LSB:
2990 need_entry = NEED_PLTOFF;
2994 need_entry |= NEED_MIN_PLT;
2998 case R_IA64_PCREL21B:
2999 case R_IA64_PCREL60B:
3000 /* Depending on where this symbol is defined, we may or may not
3001 need a full plt entry. Only skip if we know we'll not need
3002 the entry -- static or symbolic, and the symbol definition
3003 has already been seen. */
3004 if (maybe_dynamic && rel->r_addend == 0)
3005 need_entry = NEED_FULL_PLT;
3011 case R_IA64_DIR32MSB:
3012 case R_IA64_DIR32LSB:
3013 case R_IA64_DIR64MSB:
3014 case R_IA64_DIR64LSB:
3015 /* Shared objects will always need at least a REL relocation. */
3016 if (info->shared || maybe_dynamic)
3017 need_entry = NEED_DYNREL;
3018 dynrel_type = R_IA64_DIRNNLSB;
3021 case R_IA64_IPLTMSB:
3022 case R_IA64_IPLTLSB:
3023 /* Shared objects will always need at least a REL relocation. */
3024 if (info->shared || maybe_dynamic)
3025 need_entry = NEED_DYNREL;
3026 dynrel_type = R_IA64_IPLTLSB;
3029 case R_IA64_PCREL22:
3030 case R_IA64_PCREL64I:
3031 case R_IA64_PCREL32MSB:
3032 case R_IA64_PCREL32LSB:
3033 case R_IA64_PCREL64MSB:
3034 case R_IA64_PCREL64LSB:
3036 need_entry = NEED_DYNREL;
3037 dynrel_type = R_IA64_PCRELNNLSB;
3044 dyn_i = get_dyn_sym_info (ia64_info, h, abfd, rel, FALSE);
3046 /* Record whether or not this is a local symbol. */
3049 /* Create what's needed. */
3050 if (need_entry & (NEED_GOT | NEED_GOTX | NEED_TPREL
3051 | NEED_DTPMOD | NEED_DTPREL))
3055 got = get_got (abfd, info, ia64_info);
3059 if (need_entry & NEED_GOT)
3060 dyn_i->want_got = 1;
3061 if (need_entry & NEED_GOTX)
3062 dyn_i->want_gotx = 1;
3063 if (need_entry & NEED_TPREL)
3064 dyn_i->want_tprel = 1;
3065 if (need_entry & NEED_DTPMOD)
3066 dyn_i->want_dtpmod = 1;
3067 if (need_entry & NEED_DTPREL)
3068 dyn_i->want_dtprel = 1;
3070 if (need_entry & NEED_FPTR)
3074 fptr = get_fptr (abfd, info, ia64_info);
3079 /* FPTRs for shared libraries are allocated by the dynamic
3080 linker. Make sure this local symbol will appear in the
3081 dynamic symbol table. */
3082 if (!h && info->shared)
3084 if (! (bfd_elf_link_record_local_dynamic_symbol
3085 (info, abfd, (long) r_symndx)))
3089 dyn_i->want_fptr = 1;
3091 if (need_entry & NEED_LTOFF_FPTR)
3092 dyn_i->want_ltoff_fptr = 1;
3093 if (need_entry & (NEED_MIN_PLT | NEED_FULL_PLT))
3095 if (!ia64_info->root.dynobj)
3096 ia64_info->root.dynobj = abfd;
3098 dyn_i->want_plt = 1;
3100 if (need_entry & NEED_FULL_PLT)
3101 dyn_i->want_plt2 = 1;
3102 if (need_entry & NEED_PLTOFF)
3104 /* This is needed here, in case @pltoff is used in a non-shared
3108 pltoff = get_pltoff (abfd, info, ia64_info);
3113 dyn_i->want_pltoff = 1;
3115 if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC))
3119 srel = get_reloc_section (abfd, ia64_info, sec, TRUE);
3123 if (!count_dyn_reloc (abfd, dyn_i, srel, dynrel_type,
3124 (sec->flags & SEC_READONLY) != 0))
3132 /* For cleanliness, and potentially faster dynamic loading, allocate
3133 external GOT entries first. */
3136 allocate_global_data_got (dyn_i, data)
3137 struct elfNN_ia64_dyn_sym_info *dyn_i;
3140 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
3142 if ((dyn_i->want_got || dyn_i->want_gotx)
3143 && ! dyn_i->want_fptr
3144 && elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
3146 dyn_i->got_offset = x->ofs;
3149 if (dyn_i->want_tprel)
3151 dyn_i->tprel_offset = x->ofs;
3154 if (dyn_i->want_dtpmod)
3156 if (elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
3158 dyn_i->dtpmod_offset = x->ofs;
3163 struct elfNN_ia64_link_hash_table *ia64_info;
3165 ia64_info = elfNN_ia64_hash_table (x->info);
3166 if (ia64_info->self_dtpmod_offset == (bfd_vma) -1)
3168 ia64_info->self_dtpmod_offset = x->ofs;
3171 dyn_i->dtpmod_offset = ia64_info->self_dtpmod_offset;
3174 if (dyn_i->want_dtprel)
3176 dyn_i->dtprel_offset = x->ofs;
3182 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
3185 allocate_global_fptr_got (dyn_i, data)
3186 struct elfNN_ia64_dyn_sym_info *dyn_i;
3189 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
3193 && elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, R_IA64_FPTRNNLSB))
3195 dyn_i->got_offset = x->ofs;
3201 /* Lastly, allocate all the GOT entries for local data. */
3204 allocate_local_got (dyn_i, data)
3205 struct elfNN_ia64_dyn_sym_info *dyn_i;
3208 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
3210 if ((dyn_i->want_got || dyn_i->want_gotx)
3211 && !elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
3213 dyn_i->got_offset = x->ofs;
3219 /* Search for the index of a global symbol in it's defining object file. */
3222 global_sym_index (h)
3223 struct elf_link_hash_entry *h;
3225 struct elf_link_hash_entry **p;
3228 BFD_ASSERT (h->root.type == bfd_link_hash_defined
3229 || h->root.type == bfd_link_hash_defweak);
3231 obj = h->root.u.def.section->owner;
3232 for (p = elf_sym_hashes (obj); *p != h; ++p)
3235 return p - elf_sym_hashes (obj) + elf_tdata (obj)->symtab_hdr.sh_info;
3238 /* Allocate function descriptors. We can do these for every function
3239 in a main executable that is not exported. */
3242 allocate_fptr (dyn_i, data)
3243 struct elfNN_ia64_dyn_sym_info *dyn_i;
3246 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
3248 if (dyn_i->want_fptr)
3250 struct elf_link_hash_entry *h = dyn_i->h;
3253 while (h->root.type == bfd_link_hash_indirect
3254 || h->root.type == bfd_link_hash_warning)
3255 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3257 if (!x->info->executable
3259 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3260 || (h->root.type != bfd_link_hash_undefweak
3261 && h->root.type != bfd_link_hash_undefined)))
3263 if (h && h->dynindx == -1)
3265 BFD_ASSERT ((h->root.type == bfd_link_hash_defined)
3266 || (h->root.type == bfd_link_hash_defweak));
3268 if (!bfd_elf_link_record_local_dynamic_symbol
3269 (x->info, h->root.u.def.section->owner,
3270 global_sym_index (h)))
3274 dyn_i->want_fptr = 0;
3276 else if (h == NULL || h->dynindx == -1)
3278 dyn_i->fptr_offset = x->ofs;
3282 dyn_i->want_fptr = 0;
3287 /* Allocate all the minimal PLT entries. */
3290 allocate_plt_entries (dyn_i, data)
3291 struct elfNN_ia64_dyn_sym_info *dyn_i;
3294 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
3296 if (dyn_i->want_plt)
3298 struct elf_link_hash_entry *h = dyn_i->h;
3301 while (h->root.type == bfd_link_hash_indirect
3302 || h->root.type == bfd_link_hash_warning)
3303 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3305 /* ??? Versioned symbols seem to lose NEEDS_PLT. */
3306 if (elfNN_ia64_dynamic_symbol_p (h, x->info, 0))
3308 bfd_size_type offset = x->ofs;
3310 offset = PLT_HEADER_SIZE;
3311 dyn_i->plt_offset = offset;
3312 x->ofs = offset + PLT_MIN_ENTRY_SIZE;
3314 dyn_i->want_pltoff = 1;
3318 dyn_i->want_plt = 0;
3319 dyn_i->want_plt2 = 0;
3325 /* Allocate all the full PLT entries. */
3328 allocate_plt2_entries (dyn_i, data)
3329 struct elfNN_ia64_dyn_sym_info *dyn_i;
3332 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
3334 if (dyn_i->want_plt2)
3336 struct elf_link_hash_entry *h = dyn_i->h;
3337 bfd_size_type ofs = x->ofs;
3339 dyn_i->plt2_offset = ofs;
3340 x->ofs = ofs + PLT_FULL_ENTRY_SIZE;
3342 while (h->root.type == bfd_link_hash_indirect
3343 || h->root.type == bfd_link_hash_warning)
3344 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3345 dyn_i->h->plt.offset = ofs;
3350 /* Allocate all the PLTOFF entries requested by relocations and
3351 plt entries. We can't share space with allocated FPTR entries,
3352 because the latter are not necessarily addressable by the GP.
3353 ??? Relaxation might be able to determine that they are. */
3356 allocate_pltoff_entries (dyn_i, data)
3357 struct elfNN_ia64_dyn_sym_info *dyn_i;
3360 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
3362 if (dyn_i->want_pltoff)
3364 dyn_i->pltoff_offset = x->ofs;
3370 /* Allocate dynamic relocations for those symbols that turned out
3374 allocate_dynrel_entries (dyn_i, data)
3375 struct elfNN_ia64_dyn_sym_info *dyn_i;
3378 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
3379 struct elfNN_ia64_link_hash_table *ia64_info;
3380 struct elfNN_ia64_dyn_reloc_entry *rent;
3381 bfd_boolean dynamic_symbol, shared, resolved_zero;
3383 ia64_info = elfNN_ia64_hash_table (x->info);
3385 /* Note that this can't be used in relation to FPTR relocs below. */
3386 dynamic_symbol = elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0);
3388 shared = x->info->shared;
3389 resolved_zero = (dyn_i->h
3390 && ELF_ST_VISIBILITY (dyn_i->h->other)
3391 && dyn_i->h->root.type == bfd_link_hash_undefweak);
3393 /* Take care of the GOT and PLT relocations. */
3396 && (dynamic_symbol || shared)
3397 && (dyn_i->want_got || dyn_i->want_gotx))
3398 || (dyn_i->want_ltoff_fptr
3400 && dyn_i->h->dynindx != -1))
3402 if (!dyn_i->want_ltoff_fptr
3405 || dyn_i->h->root.type != bfd_link_hash_undefweak)
3406 ia64_info->rel_got_sec->size += sizeof (ElfNN_External_Rela);
3408 if ((dynamic_symbol || shared) && dyn_i->want_tprel)
3409 ia64_info->rel_got_sec->size += sizeof (ElfNN_External_Rela);
3410 if (dynamic_symbol && dyn_i->want_dtpmod)
3411 ia64_info->rel_got_sec->size += sizeof (ElfNN_External_Rela);
3412 if (dynamic_symbol && dyn_i->want_dtprel)
3413 ia64_info->rel_got_sec->size += sizeof (ElfNN_External_Rela);
3418 if (ia64_info->rel_fptr_sec && dyn_i->want_fptr)
3420 if (dyn_i->h == NULL || dyn_i->h->root.type != bfd_link_hash_undefweak)
3421 ia64_info->rel_fptr_sec->size += sizeof (ElfNN_External_Rela);
3424 if (!resolved_zero && dyn_i->want_pltoff)
3426 bfd_size_type t = 0;
3428 /* Dynamic symbols get one IPLT relocation. Local symbols in
3429 shared libraries get two REL relocations. Local symbols in
3430 main applications get nothing. */
3432 t = sizeof (ElfNN_External_Rela);
3434 t = 2 * sizeof (ElfNN_External_Rela);
3436 ia64_info->rel_pltoff_sec->size += t;
3439 /* Take care of the normal data relocations. */
3441 for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
3443 int count = rent->count;
3447 case R_IA64_FPTR32LSB:
3448 case R_IA64_FPTR64LSB:
3449 /* Allocate one iff !want_fptr and not PIE, which by this point
3450 will be true only if we're actually allocating one statically
3451 in the main executable. Position independent executables
3452 need a relative reloc. */
3453 if (dyn_i->want_fptr && !x->info->pie)
3456 case R_IA64_PCREL32LSB:
3457 case R_IA64_PCREL64LSB:
3458 if (!dynamic_symbol)
3461 case R_IA64_DIR32LSB:
3462 case R_IA64_DIR64LSB:
3463 if (!dynamic_symbol && !shared)
3466 case R_IA64_IPLTLSB:
3467 if (!dynamic_symbol && !shared)
3469 /* Use two REL relocations for IPLT relocations
3470 against local symbols. */
3471 if (!dynamic_symbol)
3474 case R_IA64_DTPREL32LSB:
3475 case R_IA64_TPREL64LSB:
3476 case R_IA64_DTPREL64LSB:
3477 case R_IA64_DTPMOD64LSB:
3483 ia64_info->reltext = 1;
3484 rent->srel->size += sizeof (ElfNN_External_Rela) * count;
3491 elfNN_ia64_adjust_dynamic_symbol (info, h)
3492 struct bfd_link_info *info ATTRIBUTE_UNUSED;
3493 struct elf_link_hash_entry *h;
3495 /* ??? Undefined symbols with PLT entries should be re-defined
3496 to be the PLT entry. */
3498 /* If this is a weak symbol, and there is a real definition, the
3499 processor independent code will have arranged for us to see the
3500 real definition first, and we can just use the same value. */
3501 if (h->u.weakdef != NULL)
3503 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
3504 || h->u.weakdef->root.type == bfd_link_hash_defweak);
3505 h->root.u.def.section = h->u.weakdef->root.u.def.section;
3506 h->root.u.def.value = h->u.weakdef->root.u.def.value;
3510 /* If this is a reference to a symbol defined by a dynamic object which
3511 is not a function, we might allocate the symbol in our .dynbss section
3512 and allocate a COPY dynamic relocation.
3514 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
3521 elfNN_ia64_size_dynamic_sections (output_bfd, info)
3522 bfd *output_bfd ATTRIBUTE_UNUSED;
3523 struct bfd_link_info *info;
3525 struct elfNN_ia64_allocate_data data;
3526 struct elfNN_ia64_link_hash_table *ia64_info;
3529 bfd_boolean relplt = FALSE;
3531 dynobj = elf_hash_table(info)->dynobj;
3532 ia64_info = elfNN_ia64_hash_table (info);
3533 ia64_info->self_dtpmod_offset = (bfd_vma) -1;
3534 BFD_ASSERT(dynobj != NULL);
3537 /* Set the contents of the .interp section to the interpreter. */
3538 if (ia64_info->root.dynamic_sections_created
3539 && info->executable)
3541 sec = bfd_get_section_by_name (dynobj, ".interp");
3542 BFD_ASSERT (sec != NULL);
3543 sec->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
3544 sec->size = strlen (ELF_DYNAMIC_INTERPRETER) + 1;
3547 /* Allocate the GOT entries. */
3549 if (ia64_info->got_sec)
3552 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data);
3553 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data);
3554 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data);
3555 ia64_info->got_sec->size = data.ofs;
3558 /* Allocate the FPTR entries. */
3560 if (ia64_info->fptr_sec)
3563 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_fptr, &data);
3564 ia64_info->fptr_sec->size = data.ofs;
3567 /* Now that we've seen all of the input files, we can decide which
3568 symbols need plt entries. Allocate the minimal PLT entries first.
3569 We do this even though dynamic_sections_created may be FALSE, because
3570 this has the side-effect of clearing want_plt and want_plt2. */
3573 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_plt_entries, &data);
3575 ia64_info->minplt_entries = 0;
3578 ia64_info->minplt_entries
3579 = (data.ofs - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
3582 /* Align the pointer for the plt2 entries. */
3583 data.ofs = (data.ofs + 31) & (bfd_vma) -32;
3585 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_plt2_entries, &data);
3586 if (data.ofs != 0 || ia64_info->root.dynamic_sections_created)
3588 /* FIXME: we always reserve the memory for dynamic linker even if
3589 there are no PLT entries since dynamic linker may assume the
3590 reserved memory always exists. */
3592 BFD_ASSERT (ia64_info->root.dynamic_sections_created);
3594 ia64_info->plt_sec->size = data.ofs;
3596 /* If we've got a .plt, we need some extra memory for the dynamic
3597 linker. We stuff these in .got.plt. */
3598 sec = bfd_get_section_by_name (dynobj, ".got.plt");
3599 sec->size = 8 * PLT_RESERVED_WORDS;
3602 /* Allocate the PLTOFF entries. */
3604 if (ia64_info->pltoff_sec)
3607 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_pltoff_entries, &data);
3608 ia64_info->pltoff_sec->size = data.ofs;
3611 if (ia64_info->root.dynamic_sections_created)
3613 /* Allocate space for the dynamic relocations that turned out to be
3616 if (info->shared && ia64_info->self_dtpmod_offset != (bfd_vma) -1)
3617 ia64_info->rel_got_sec->size += sizeof (ElfNN_External_Rela);
3618 data.only_got = FALSE;
3619 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries, &data);
3622 /* We have now determined the sizes of the various dynamic sections.
3623 Allocate memory for them. */
3624 for (sec = dynobj->sections; sec != NULL; sec = sec->next)
3628 if (!(sec->flags & SEC_LINKER_CREATED))
3631 /* If we don't need this section, strip it from the output file.
3632 There were several sections primarily related to dynamic
3633 linking that must be create before the linker maps input
3634 sections to output sections. The linker does that before
3635 bfd_elf_size_dynamic_sections is called, and it is that
3636 function which decides whether anything needs to go into
3639 strip = (sec->size == 0);
3641 if (sec == ia64_info->got_sec)
3643 else if (sec == ia64_info->rel_got_sec)
3646 ia64_info->rel_got_sec = NULL;
3648 /* We use the reloc_count field as a counter if we need to
3649 copy relocs into the output file. */
3650 sec->reloc_count = 0;
3652 else if (sec == ia64_info->fptr_sec)
3655 ia64_info->fptr_sec = NULL;
3657 else if (sec == ia64_info->rel_fptr_sec)
3660 ia64_info->rel_fptr_sec = NULL;
3662 /* We use the reloc_count field as a counter if we need to
3663 copy relocs into the output file. */
3664 sec->reloc_count = 0;
3666 else if (sec == ia64_info->plt_sec)
3669 ia64_info->plt_sec = NULL;
3671 else if (sec == ia64_info->pltoff_sec)
3674 ia64_info->pltoff_sec = NULL;
3676 else if (sec == ia64_info->rel_pltoff_sec)
3679 ia64_info->rel_pltoff_sec = NULL;
3683 /* We use the reloc_count field as a counter if we need to
3684 copy relocs into the output file. */
3685 sec->reloc_count = 0;
3692 /* It's OK to base decisions on the section name, because none
3693 of the dynobj section names depend upon the input files. */
3694 name = bfd_get_section_name (dynobj, sec);
3696 if (strcmp (name, ".got.plt") == 0)
3698 else if (CONST_STRNEQ (name, ".rel"))
3702 /* We use the reloc_count field as a counter if we need to
3703 copy relocs into the output file. */
3704 sec->reloc_count = 0;
3712 sec->flags |= SEC_EXCLUDE;
3715 /* Allocate memory for the section contents. */
3716 sec->contents = (bfd_byte *) bfd_zalloc (dynobj, sec->size);
3717 if (sec->contents == NULL && sec->size != 0)
3722 if (elf_hash_table (info)->dynamic_sections_created)
3724 /* Add some entries to the .dynamic section. We fill in the values
3725 later (in finish_dynamic_sections) but we must add the entries now
3726 so that we get the correct size for the .dynamic section. */
3728 if (info->executable)
3730 /* The DT_DEBUG entry is filled in by the dynamic linker and used
3732 #define add_dynamic_entry(TAG, VAL) \
3733 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3735 if (!add_dynamic_entry (DT_DEBUG, 0))
3739 if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE, 0))
3741 if (!add_dynamic_entry (DT_PLTGOT, 0))
3746 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3747 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3748 || !add_dynamic_entry (DT_JMPREL, 0))
3752 if (!add_dynamic_entry (DT_RELA, 0)
3753 || !add_dynamic_entry (DT_RELASZ, 0)
3754 || !add_dynamic_entry (DT_RELAENT, sizeof (ElfNN_External_Rela)))
3757 if (ia64_info->reltext)
3759 if (!add_dynamic_entry (DT_TEXTREL, 0))
3761 info->flags |= DF_TEXTREL;
3765 /* ??? Perhaps force __gp local. */
3770 static bfd_reloc_status_type
3771 elfNN_ia64_install_value (hit_addr, v, r_type)
3774 unsigned int r_type;
3776 const struct ia64_operand *op;
3777 int bigendian = 0, shift = 0;
3778 bfd_vma t0, t1, dword;
3780 enum ia64_opnd opnd;
3783 #ifdef BFD_HOST_U_64_BIT
3784 BFD_HOST_U_64_BIT val = (BFD_HOST_U_64_BIT) v;
3789 opnd = IA64_OPND_NIL;
3794 return bfd_reloc_ok;
3796 /* Instruction relocations. */
3799 case R_IA64_TPREL14:
3800 case R_IA64_DTPREL14:
3801 opnd = IA64_OPND_IMM14;
3804 case R_IA64_PCREL21F: opnd = IA64_OPND_TGT25; break;
3805 case R_IA64_PCREL21M: opnd = IA64_OPND_TGT25b; break;
3806 case R_IA64_PCREL60B: opnd = IA64_OPND_TGT64; break;
3807 case R_IA64_PCREL21B:
3808 case R_IA64_PCREL21BI:
3809 opnd = IA64_OPND_TGT25c;
3813 case R_IA64_GPREL22:
3814 case R_IA64_LTOFF22:
3815 case R_IA64_LTOFF22X:
3816 case R_IA64_PLTOFF22:
3817 case R_IA64_PCREL22:
3818 case R_IA64_LTOFF_FPTR22:
3819 case R_IA64_TPREL22:
3820 case R_IA64_DTPREL22:
3821 case R_IA64_LTOFF_TPREL22:
3822 case R_IA64_LTOFF_DTPMOD22:
3823 case R_IA64_LTOFF_DTPREL22:
3824 opnd = IA64_OPND_IMM22;
3828 case R_IA64_GPREL64I:
3829 case R_IA64_LTOFF64I:
3830 case R_IA64_PLTOFF64I:
3831 case R_IA64_PCREL64I:
3832 case R_IA64_FPTR64I:
3833 case R_IA64_LTOFF_FPTR64I:
3834 case R_IA64_TPREL64I:
3835 case R_IA64_DTPREL64I:
3836 opnd = IA64_OPND_IMMU64;
3839 /* Data relocations. */
3841 case R_IA64_DIR32MSB:
3842 case R_IA64_GPREL32MSB:
3843 case R_IA64_FPTR32MSB:
3844 case R_IA64_PCREL32MSB:
3845 case R_IA64_LTOFF_FPTR32MSB:
3846 case R_IA64_SEGREL32MSB:
3847 case R_IA64_SECREL32MSB:
3848 case R_IA64_LTV32MSB:
3849 case R_IA64_DTPREL32MSB:
3850 size = 4; bigendian = 1;
3853 case R_IA64_DIR32LSB:
3854 case R_IA64_GPREL32LSB:
3855 case R_IA64_FPTR32LSB:
3856 case R_IA64_PCREL32LSB:
3857 case R_IA64_LTOFF_FPTR32LSB:
3858 case R_IA64_SEGREL32LSB:
3859 case R_IA64_SECREL32LSB:
3860 case R_IA64_LTV32LSB:
3861 case R_IA64_DTPREL32LSB:
3862 size = 4; bigendian = 0;
3865 case R_IA64_DIR64MSB:
3866 case R_IA64_GPREL64MSB:
3867 case R_IA64_PLTOFF64MSB:
3868 case R_IA64_FPTR64MSB:
3869 case R_IA64_PCREL64MSB:
3870 case R_IA64_LTOFF_FPTR64MSB:
3871 case R_IA64_SEGREL64MSB:
3872 case R_IA64_SECREL64MSB:
3873 case R_IA64_LTV64MSB:
3874 case R_IA64_TPREL64MSB:
3875 case R_IA64_DTPMOD64MSB:
3876 case R_IA64_DTPREL64MSB:
3877 size = 8; bigendian = 1;
3880 case R_IA64_DIR64LSB:
3881 case R_IA64_GPREL64LSB:
3882 case R_IA64_PLTOFF64LSB:
3883 case R_IA64_FPTR64LSB:
3884 case R_IA64_PCREL64LSB:
3885 case R_IA64_LTOFF_FPTR64LSB:
3886 case R_IA64_SEGREL64LSB:
3887 case R_IA64_SECREL64LSB:
3888 case R_IA64_LTV64LSB:
3889 case R_IA64_TPREL64LSB:
3890 case R_IA64_DTPMOD64LSB:
3891 case R_IA64_DTPREL64LSB:
3892 size = 8; bigendian = 0;
3895 /* Unsupported / Dynamic relocations. */
3897 return bfd_reloc_notsupported;
3902 case IA64_OPND_IMMU64:
3903 hit_addr -= (long) hit_addr & 0x3;
3904 t0 = bfd_getl64 (hit_addr);
3905 t1 = bfd_getl64 (hit_addr + 8);
3907 /* tmpl/s: bits 0.. 5 in t0
3908 slot 0: bits 5..45 in t0
3909 slot 1: bits 46..63 in t0, bits 0..22 in t1
3910 slot 2: bits 23..63 in t1 */
3912 /* First, clear the bits that form the 64 bit constant. */
3913 t0 &= ~(0x3ffffLL << 46);
3915 | (( (0x07fLL << 13) | (0x1ffLL << 27)
3916 | (0x01fLL << 22) | (0x001LL << 21)
3917 | (0x001LL << 36)) << 23));
3919 t0 |= ((val >> 22) & 0x03ffffLL) << 46; /* 18 lsbs of imm41 */
3920 t1 |= ((val >> 40) & 0x7fffffLL) << 0; /* 23 msbs of imm41 */
3921 t1 |= ( (((val >> 0) & 0x07f) << 13) /* imm7b */
3922 | (((val >> 7) & 0x1ff) << 27) /* imm9d */
3923 | (((val >> 16) & 0x01f) << 22) /* imm5c */
3924 | (((val >> 21) & 0x001) << 21) /* ic */
3925 | (((val >> 63) & 0x001) << 36)) << 23; /* i */
3927 bfd_putl64 (t0, hit_addr);
3928 bfd_putl64 (t1, hit_addr + 8);
3931 case IA64_OPND_TGT64:
3932 hit_addr -= (long) hit_addr & 0x3;
3933 t0 = bfd_getl64 (hit_addr);
3934 t1 = bfd_getl64 (hit_addr + 8);
3936 /* tmpl/s: bits 0.. 5 in t0
3937 slot 0: bits 5..45 in t0
3938 slot 1: bits 46..63 in t0, bits 0..22 in t1
3939 slot 2: bits 23..63 in t1 */
3941 /* First, clear the bits that form the 64 bit constant. */
3942 t0 &= ~(0x3ffffLL << 46);
3944 | ((1LL << 36 | 0xfffffLL << 13) << 23));
3947 t0 |= ((val >> 20) & 0xffffLL) << 2 << 46; /* 16 lsbs of imm39 */
3948 t1 |= ((val >> 36) & 0x7fffffLL) << 0; /* 23 msbs of imm39 */
3949 t1 |= ((((val >> 0) & 0xfffffLL) << 13) /* imm20b */
3950 | (((val >> 59) & 0x1LL) << 36)) << 23; /* i */
3952 bfd_putl64 (t0, hit_addr);
3953 bfd_putl64 (t1, hit_addr + 8);
3957 switch ((long) hit_addr & 0x3)
3959 case 0: shift = 5; break;
3960 case 1: shift = 14; hit_addr += 3; break;
3961 case 2: shift = 23; hit_addr += 6; break;
3962 case 3: return bfd_reloc_notsupported; /* shouldn't happen... */
3964 dword = bfd_getl64 (hit_addr);
3965 insn = (dword >> shift) & 0x1ffffffffffLL;
3967 op = elf64_ia64_operands + opnd;
3968 err = (*op->insert) (op, val, &insn);
3970 return bfd_reloc_overflow;
3972 dword &= ~(0x1ffffffffffLL << shift);
3973 dword |= (insn << shift);
3974 bfd_putl64 (dword, hit_addr);
3978 /* A data relocation. */
3981 bfd_putb32 (val, hit_addr);
3983 bfd_putb64 (val, hit_addr);
3986 bfd_putl32 (val, hit_addr);
3988 bfd_putl64 (val, hit_addr);
3992 return bfd_reloc_ok;
3996 elfNN_ia64_install_dyn_reloc (abfd, info, sec, srel, offset, type,
3999 struct bfd_link_info *info;
4007 Elf_Internal_Rela outrel;
4010 BFD_ASSERT (dynindx != -1);
4011 outrel.r_info = ELFNN_R_INFO (dynindx, type);
4012 outrel.r_addend = addend;
4013 outrel.r_offset = _bfd_elf_section_offset (abfd, info, sec, offset);
4014 if (outrel.r_offset >= (bfd_vma) -2)
4016 /* Run for the hills. We shouldn't be outputting a relocation
4017 for this. So do what everyone else does and output a no-op. */
4018 outrel.r_info = ELFNN_R_INFO (0, R_IA64_NONE);
4019 outrel.r_addend = 0;
4020 outrel.r_offset = 0;
4023 outrel.r_offset += sec->output_section->vma + sec->output_offset;
4025 loc = srel->contents;
4026 loc += srel->reloc_count++ * sizeof (ElfNN_External_Rela);
4027 bfd_elfNN_swap_reloca_out (abfd, &outrel, loc);
4028 BFD_ASSERT (sizeof (ElfNN_External_Rela) * srel->reloc_count <= srel->size);
4031 /* Store an entry for target address TARGET_ADDR in the linkage table
4032 and return the gp-relative address of the linkage table entry. */
4035 set_got_entry (abfd, info, dyn_i, dynindx, addend, value, dyn_r_type)
4037 struct bfd_link_info *info;
4038 struct elfNN_ia64_dyn_sym_info *dyn_i;
4042 unsigned int dyn_r_type;
4044 struct elfNN_ia64_link_hash_table *ia64_info;
4049 ia64_info = elfNN_ia64_hash_table (info);
4050 got_sec = ia64_info->got_sec;
4054 case R_IA64_TPREL64LSB:
4055 done = dyn_i->tprel_done;
4056 dyn_i->tprel_done = TRUE;
4057 got_offset = dyn_i->tprel_offset;
4059 case R_IA64_DTPMOD64LSB:
4060 if (dyn_i->dtpmod_offset != ia64_info->self_dtpmod_offset)
4062 done = dyn_i->dtpmod_done;
4063 dyn_i->dtpmod_done = TRUE;
4067 done = ia64_info->self_dtpmod_done;
4068 ia64_info->self_dtpmod_done = TRUE;
4071 got_offset = dyn_i->dtpmod_offset;
4073 case R_IA64_DTPREL32LSB:
4074 case R_IA64_DTPREL64LSB:
4075 done = dyn_i->dtprel_done;
4076 dyn_i->dtprel_done = TRUE;
4077 got_offset = dyn_i->dtprel_offset;
4080 done = dyn_i->got_done;
4081 dyn_i->got_done = TRUE;
4082 got_offset = dyn_i->got_offset;
4086 BFD_ASSERT ((got_offset & 7) == 0);
4090 /* Store the target address in the linkage table entry. */
4091 bfd_put_64 (abfd, value, got_sec->contents + got_offset);
4093 /* Install a dynamic relocation if needed. */
4096 || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
4097 || dyn_i->h->root.type != bfd_link_hash_undefweak)
4098 && dyn_r_type != R_IA64_DTPREL32LSB
4099 && dyn_r_type != R_IA64_DTPREL64LSB)
4100 || elfNN_ia64_dynamic_symbol_p (dyn_i->h, info, dyn_r_type)
4102 && (dyn_r_type == R_IA64_FPTR32LSB
4103 || dyn_r_type == R_IA64_FPTR64LSB)))
4104 && (!dyn_i->want_ltoff_fptr
4107 || dyn_i->h->root.type != bfd_link_hash_undefweak))
4110 && dyn_r_type != R_IA64_TPREL64LSB
4111 && dyn_r_type != R_IA64_DTPMOD64LSB
4112 && dyn_r_type != R_IA64_DTPREL32LSB
4113 && dyn_r_type != R_IA64_DTPREL64LSB)
4115 dyn_r_type = R_IA64_RELNNLSB;
4120 if (bfd_big_endian (abfd))
4124 case R_IA64_REL32LSB:
4125 dyn_r_type = R_IA64_REL32MSB;
4127 case R_IA64_DIR32LSB:
4128 dyn_r_type = R_IA64_DIR32MSB;
4130 case R_IA64_FPTR32LSB:
4131 dyn_r_type = R_IA64_FPTR32MSB;
4133 case R_IA64_DTPREL32LSB:
4134 dyn_r_type = R_IA64_DTPREL32MSB;
4136 case R_IA64_REL64LSB:
4137 dyn_r_type = R_IA64_REL64MSB;
4139 case R_IA64_DIR64LSB:
4140 dyn_r_type = R_IA64_DIR64MSB;
4142 case R_IA64_FPTR64LSB:
4143 dyn_r_type = R_IA64_FPTR64MSB;
4145 case R_IA64_TPREL64LSB:
4146 dyn_r_type = R_IA64_TPREL64MSB;
4148 case R_IA64_DTPMOD64LSB:
4149 dyn_r_type = R_IA64_DTPMOD64MSB;
4151 case R_IA64_DTPREL64LSB:
4152 dyn_r_type = R_IA64_DTPREL64MSB;
4160 elfNN_ia64_install_dyn_reloc (abfd, NULL, got_sec,
4161 ia64_info->rel_got_sec,
4162 got_offset, dyn_r_type,
4167 /* Return the address of the linkage table entry. */
4168 value = (got_sec->output_section->vma
4169 + got_sec->output_offset
4175 /* Fill in a function descriptor consisting of the function's code
4176 address and its global pointer. Return the descriptor's address. */
4179 set_fptr_entry (abfd, info, dyn_i, value)
4181 struct bfd_link_info *info;
4182 struct elfNN_ia64_dyn_sym_info *dyn_i;
4185 struct elfNN_ia64_link_hash_table *ia64_info;
4188 ia64_info = elfNN_ia64_hash_table (info);
4189 fptr_sec = ia64_info->fptr_sec;
4191 if (!dyn_i->fptr_done)
4193 dyn_i->fptr_done = 1;
4195 /* Fill in the function descriptor. */
4196 bfd_put_64 (abfd, value, fptr_sec->contents + dyn_i->fptr_offset);
4197 bfd_put_64 (abfd, _bfd_get_gp_value (abfd),
4198 fptr_sec->contents + dyn_i->fptr_offset + 8);
4199 if (ia64_info->rel_fptr_sec)
4201 Elf_Internal_Rela outrel;
4204 if (bfd_little_endian (abfd))
4205 outrel.r_info = ELFNN_R_INFO (0, R_IA64_IPLTLSB);
4207 outrel.r_info = ELFNN_R_INFO (0, R_IA64_IPLTMSB);
4208 outrel.r_addend = value;
4209 outrel.r_offset = (fptr_sec->output_section->vma
4210 + fptr_sec->output_offset
4211 + dyn_i->fptr_offset);
4212 loc = ia64_info->rel_fptr_sec->contents;
4213 loc += ia64_info->rel_fptr_sec->reloc_count++
4214 * sizeof (ElfNN_External_Rela);
4215 bfd_elfNN_swap_reloca_out (abfd, &outrel, loc);
4219 /* Return the descriptor's address. */
4220 value = (fptr_sec->output_section->vma
4221 + fptr_sec->output_offset
4222 + dyn_i->fptr_offset);
4227 /* Fill in a PLTOFF entry consisting of the function's code address
4228 and its global pointer. Return the descriptor's address. */
4231 set_pltoff_entry (abfd, info, dyn_i, value, is_plt)
4233 struct bfd_link_info *info;
4234 struct elfNN_ia64_dyn_sym_info *dyn_i;
4238 struct elfNN_ia64_link_hash_table *ia64_info;
4239 asection *pltoff_sec;
4241 ia64_info = elfNN_ia64_hash_table (info);
4242 pltoff_sec = ia64_info->pltoff_sec;
4244 /* Don't do anything if this symbol uses a real PLT entry. In
4245 that case, we'll fill this in during finish_dynamic_symbol. */
4246 if ((! dyn_i->want_plt || is_plt)
4247 && !dyn_i->pltoff_done)
4249 bfd_vma gp = _bfd_get_gp_value (abfd);
4251 /* Fill in the function descriptor. */
4252 bfd_put_64 (abfd, value, pltoff_sec->contents + dyn_i->pltoff_offset);
4253 bfd_put_64 (abfd, gp, pltoff_sec->contents + dyn_i->pltoff_offset + 8);
4255 /* Install dynamic relocations if needed. */
4259 || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
4260 || dyn_i->h->root.type != bfd_link_hash_undefweak))
4262 unsigned int dyn_r_type;
4264 if (bfd_big_endian (abfd))
4265 dyn_r_type = R_IA64_RELNNMSB;
4267 dyn_r_type = R_IA64_RELNNLSB;
4269 elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
4270 ia64_info->rel_pltoff_sec,
4271 dyn_i->pltoff_offset,
4272 dyn_r_type, 0, value);
4273 elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
4274 ia64_info->rel_pltoff_sec,
4275 dyn_i->pltoff_offset + ARCH_SIZE / 8,
4279 dyn_i->pltoff_done = 1;
4282 /* Return the descriptor's address. */
4283 value = (pltoff_sec->output_section->vma
4284 + pltoff_sec->output_offset
4285 + dyn_i->pltoff_offset);
4290 /* Return the base VMA address which should be subtracted from real addresses
4291 when resolving @tprel() relocation.
4292 Main program TLS (whose template starts at PT_TLS p_vaddr)
4293 is assigned offset round(2 * size of pointer, PT_TLS p_align). */
4296 elfNN_ia64_tprel_base (info)
4297 struct bfd_link_info *info;
4299 asection *tls_sec = elf_hash_table (info)->tls_sec;
4301 BFD_ASSERT (tls_sec != NULL);
4302 return tls_sec->vma - align_power ((bfd_vma) ARCH_SIZE / 4,
4303 tls_sec->alignment_power);
4306 /* Return the base VMA address which should be subtracted from real addresses
4307 when resolving @dtprel() relocation.
4308 This is PT_TLS segment p_vaddr. */
4311 elfNN_ia64_dtprel_base (info)
4312 struct bfd_link_info *info;
4314 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4315 return elf_hash_table (info)->tls_sec->vma;
4318 /* Called through qsort to sort the .IA_64.unwind section during a
4319 non-relocatable link. Set elfNN_ia64_unwind_entry_compare_bfd
4320 to the output bfd so we can do proper endianness frobbing. */
4322 static bfd *elfNN_ia64_unwind_entry_compare_bfd;
4325 elfNN_ia64_unwind_entry_compare (a, b)
4331 av = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, a);
4332 bv = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, b);
4334 return (av < bv ? -1 : av > bv ? 1 : 0);
4337 /* Make sure we've got ourselves a nice fat __gp value. */
4339 elfNN_ia64_choose_gp (abfd, info)
4341 struct bfd_link_info *info;
4343 bfd_vma min_vma = (bfd_vma) -1, max_vma = 0;
4344 bfd_vma min_short_vma = min_vma, max_short_vma = 0;
4345 struct elf_link_hash_entry *gp;
4348 struct elfNN_ia64_link_hash_table *ia64_info;
4350 ia64_info = elfNN_ia64_hash_table (info);
4352 /* Find the min and max vma of all sections marked short. Also collect
4353 min and max vma of any type, for use in selecting a nice gp. */
4354 for (os = abfd->sections; os ; os = os->next)
4358 if ((os->flags & SEC_ALLOC) == 0)
4362 hi = os->vma + (os->rawsize ? os->rawsize : os->size);
4370 if (os->flags & SEC_SMALL_DATA)
4372 if (min_short_vma > lo)
4374 if (max_short_vma < hi)
4379 /* See if the user wants to force a value. */
4380 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
4384 && (gp->root.type == bfd_link_hash_defined
4385 || gp->root.type == bfd_link_hash_defweak))
4387 asection *gp_sec = gp->root.u.def.section;
4388 gp_val = (gp->root.u.def.value
4389 + gp_sec->output_section->vma
4390 + gp_sec->output_offset);
4394 /* Pick a sensible value. */
4396 asection *got_sec = ia64_info->got_sec;
4398 /* Start with just the address of the .got. */
4400 gp_val = got_sec->output_section->vma;
4401 else if (max_short_vma != 0)
4402 gp_val = min_short_vma;
4403 else if (max_vma - min_vma < 0x200000)
4406 gp_val = max_vma - 0x200000 + 8;
4408 /* If it is possible to address the entire image, but we
4409 don't with the choice above, adjust. */
4410 if (max_vma - min_vma < 0x400000
4411 && (max_vma - gp_val >= 0x200000
4412 || gp_val - min_vma > 0x200000))
4413 gp_val = min_vma + 0x200000;
4414 else if (max_short_vma != 0)
4416 /* If we don't cover all the short data, adjust. */
4417 if (max_short_vma - gp_val >= 0x200000)
4418 gp_val = min_short_vma + 0x200000;
4420 /* If we're addressing stuff past the end, adjust back. */
4421 if (gp_val > max_vma)
4422 gp_val = max_vma - 0x200000 + 8;
4426 /* Validate whether all SHF_IA_64_SHORT sections are within
4427 range of the chosen GP. */
4429 if (max_short_vma != 0)
4431 if (max_short_vma - min_short_vma >= 0x400000)
4433 (*_bfd_error_handler)
4434 (_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
4435 bfd_get_filename (abfd),
4436 (unsigned long) (max_short_vma - min_short_vma));
4439 else if ((gp_val > min_short_vma
4440 && gp_val - min_short_vma > 0x200000)
4441 || (gp_val < max_short_vma
4442 && max_short_vma - gp_val >= 0x200000))
4444 (*_bfd_error_handler)
4445 (_("%s: __gp does not cover short data segment"),
4446 bfd_get_filename (abfd));
4451 _bfd_set_gp_value (abfd, gp_val);
4457 elfNN_ia64_final_link (abfd, info)
4459 struct bfd_link_info *info;
4461 struct elfNN_ia64_link_hash_table *ia64_info;
4462 asection *unwind_output_sec;
4464 ia64_info = elfNN_ia64_hash_table (info);
4466 /* Make sure we've got ourselves a nice fat __gp value. */
4467 if (!info->relocatable)
4470 struct elf_link_hash_entry *gp;
4472 /* We assume after gp is set, section size will only decrease. We
4473 need to adjust gp for it. */
4474 _bfd_set_gp_value (abfd, 0);
4475 if (! elfNN_ia64_choose_gp (abfd, info))
4477 gp_val = _bfd_get_gp_value (abfd);
4479 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
4483 gp->root.type = bfd_link_hash_defined;
4484 gp->root.u.def.value = gp_val;
4485 gp->root.u.def.section = bfd_abs_section_ptr;
4489 /* If we're producing a final executable, we need to sort the contents
4490 of the .IA_64.unwind section. Force this section to be relocated
4491 into memory rather than written immediately to the output file. */
4492 unwind_output_sec = NULL;
4493 if (!info->relocatable)
4495 asection *s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind);
4498 unwind_output_sec = s->output_section;
4499 unwind_output_sec->contents
4500 = bfd_malloc (unwind_output_sec->size);
4501 if (unwind_output_sec->contents == NULL)
4506 /* Invoke the regular ELF backend linker to do all the work. */
4507 if (!bfd_elf_final_link (abfd, info))
4510 if (unwind_output_sec)
4512 elfNN_ia64_unwind_entry_compare_bfd = abfd;
4513 qsort (unwind_output_sec->contents,
4514 (size_t) (unwind_output_sec->size / 24),
4516 elfNN_ia64_unwind_entry_compare);
4518 if (! bfd_set_section_contents (abfd, unwind_output_sec,
4519 unwind_output_sec->contents, (bfd_vma) 0,
4520 unwind_output_sec->size))
4528 elfNN_ia64_relocate_section (output_bfd, info, input_bfd, input_section,
4529 contents, relocs, local_syms, local_sections)
4531 struct bfd_link_info *info;
4533 asection *input_section;
4535 Elf_Internal_Rela *relocs;
4536 Elf_Internal_Sym *local_syms;
4537 asection **local_sections;
4539 struct elfNN_ia64_link_hash_table *ia64_info;
4540 Elf_Internal_Shdr *symtab_hdr;
4541 Elf_Internal_Rela *rel;
4542 Elf_Internal_Rela *relend;
4544 bfd_boolean ret_val = TRUE; /* for non-fatal errors */
4547 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4548 ia64_info = elfNN_ia64_hash_table (info);
4550 /* Infect various flags from the input section to the output section. */
4551 if (info->relocatable)
4555 flags = elf_section_data(input_section)->this_hdr.sh_flags;
4556 flags &= SHF_IA_64_NORECOV;
4558 elf_section_data(input_section->output_section)
4559 ->this_hdr.sh_flags |= flags;
4562 gp_val = _bfd_get_gp_value (output_bfd);
4563 srel = get_reloc_section (input_bfd, ia64_info, input_section, FALSE);
4566 relend = relocs + input_section->reloc_count;
4567 for (; rel < relend; ++rel)
4569 struct elf_link_hash_entry *h;
4570 struct elfNN_ia64_dyn_sym_info *dyn_i;
4571 bfd_reloc_status_type r;
4572 reloc_howto_type *howto;
4573 unsigned long r_symndx;
4574 Elf_Internal_Sym *sym;
4575 unsigned int r_type;
4579 bfd_boolean dynamic_symbol_p;
4580 bfd_boolean undef_weak_ref;
4582 r_type = ELFNN_R_TYPE (rel->r_info);
4583 if (r_type > R_IA64_MAX_RELOC_CODE)
4585 (*_bfd_error_handler)
4586 (_("%B: unknown relocation type %d"),
4587 input_bfd, (int) r_type);
4588 bfd_set_error (bfd_error_bad_value);
4593 howto = lookup_howto (r_type);
4594 r_symndx = ELFNN_R_SYM (rel->r_info);
4598 undef_weak_ref = FALSE;
4600 if (r_symndx < symtab_hdr->sh_info)
4602 /* Reloc against local symbol. */
4604 sym = local_syms + r_symndx;
4605 sym_sec = local_sections[r_symndx];
4607 value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
4608 if (!info->relocatable
4609 && (sym_sec->flags & SEC_MERGE) != 0
4610 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
4611 && sym_sec->sec_info_type == ELF_INFO_TYPE_MERGE)
4613 struct elfNN_ia64_local_hash_entry *loc_h;
4615 loc_h = get_local_sym_hash (ia64_info, input_bfd, rel, FALSE);
4616 if (loc_h && ! loc_h->sec_merge_done)
4618 struct elfNN_ia64_dyn_sym_info *dynent;
4621 for (count = loc_h->count, dynent = loc_h->info;
4627 _bfd_merged_section_offset (output_bfd, &msec,
4628 elf_section_data (msec)->
4632 dynent->addend -= sym->st_value;
4633 dynent->addend += msec->output_section->vma
4634 + msec->output_offset
4635 - sym_sec->output_section->vma
4636 - sym_sec->output_offset;
4639 qsort (loc_h->info, loc_h->count,
4640 sizeof (*loc_h->info), addend_compare);
4642 loc_h->sec_merge_done = 1;
4648 bfd_boolean unresolved_reloc;
4650 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
4652 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4653 r_symndx, symtab_hdr, sym_hashes,
4655 unresolved_reloc, warned);
4657 if (h->root.type == bfd_link_hash_undefweak)
4658 undef_weak_ref = TRUE;
4663 /* For relocs against symbols from removed linkonce sections,
4664 or sections discarded by a linker script, we just want the
4665 section contents zeroed. Avoid any special processing. */
4666 if (sym_sec != NULL && elf_discarded_section (sym_sec))
4668 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
4674 if (info->relocatable)
4677 hit_addr = contents + rel->r_offset;
4678 value += rel->r_addend;
4679 dynamic_symbol_p = elfNN_ia64_dynamic_symbol_p (h, info, r_type);
4690 case R_IA64_DIR32MSB:
4691 case R_IA64_DIR32LSB:
4692 case R_IA64_DIR64MSB:
4693 case R_IA64_DIR64LSB:
4694 /* Install a dynamic relocation for this reloc. */
4695 if ((dynamic_symbol_p || info->shared)
4697 && (input_section->flags & SEC_ALLOC) != 0)
4699 unsigned int dyn_r_type;
4703 BFD_ASSERT (srel != NULL);
4710 /* ??? People shouldn't be doing non-pic code in
4711 shared libraries nor dynamic executables. */
4712 (*_bfd_error_handler)
4713 (_("%B: non-pic code with imm relocation against dynamic symbol `%s'"),
4715 h ? h->root.root.string
4716 : bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4725 /* If we don't need dynamic symbol lookup, find a
4726 matching RELATIVE relocation. */
4727 dyn_r_type = r_type;
4728 if (dynamic_symbol_p)
4730 dynindx = h->dynindx;
4731 addend = rel->r_addend;
4738 case R_IA64_DIR32MSB:
4739 dyn_r_type = R_IA64_REL32MSB;
4741 case R_IA64_DIR32LSB:
4742 dyn_r_type = R_IA64_REL32LSB;
4744 case R_IA64_DIR64MSB:
4745 dyn_r_type = R_IA64_REL64MSB;
4747 case R_IA64_DIR64LSB:
4748 dyn_r_type = R_IA64_REL64LSB;
4758 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4759 srel, rel->r_offset, dyn_r_type,
4764 case R_IA64_LTV32MSB:
4765 case R_IA64_LTV32LSB:
4766 case R_IA64_LTV64MSB:
4767 case R_IA64_LTV64LSB:
4768 r = elfNN_ia64_install_value (hit_addr, value, r_type);
4771 case R_IA64_GPREL22:
4772 case R_IA64_GPREL64I:
4773 case R_IA64_GPREL32MSB:
4774 case R_IA64_GPREL32LSB:
4775 case R_IA64_GPREL64MSB:
4776 case R_IA64_GPREL64LSB:
4777 if (dynamic_symbol_p)
4779 (*_bfd_error_handler)
4780 (_("%B: @gprel relocation against dynamic symbol %s"),
4782 h ? h->root.root.string
4783 : bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4789 r = elfNN_ia64_install_value (hit_addr, value, r_type);
4792 case R_IA64_LTOFF22:
4793 case R_IA64_LTOFF22X:
4794 case R_IA64_LTOFF64I:
4795 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4796 value = set_got_entry (input_bfd, info, dyn_i, (h ? h->dynindx : -1),
4797 rel->r_addend, value, R_IA64_DIRNNLSB);
4799 r = elfNN_ia64_install_value (hit_addr, value, r_type);
4802 case R_IA64_PLTOFF22:
4803 case R_IA64_PLTOFF64I:
4804 case R_IA64_PLTOFF64MSB:
4805 case R_IA64_PLTOFF64LSB:
4806 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4807 value = set_pltoff_entry (output_bfd, info, dyn_i, value, FALSE);
4809 r = elfNN_ia64_install_value (hit_addr, value, r_type);
4812 case R_IA64_FPTR64I:
4813 case R_IA64_FPTR32MSB:
4814 case R_IA64_FPTR32LSB:
4815 case R_IA64_FPTR64MSB:
4816 case R_IA64_FPTR64LSB:
4817 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4818 if (dyn_i->want_fptr)
4820 if (!undef_weak_ref)
4821 value = set_fptr_entry (output_bfd, info, dyn_i, value);
4823 if (!dyn_i->want_fptr || info->pie)
4826 unsigned int dyn_r_type = r_type;
4827 bfd_vma addend = rel->r_addend;
4829 /* Otherwise, we expect the dynamic linker to create
4832 if (dyn_i->want_fptr)
4834 if (r_type == R_IA64_FPTR64I)
4836 /* We can't represent this without a dynamic symbol.
4837 Adjust the relocation to be against an output
4838 section symbol, which are always present in the
4839 dynamic symbol table. */
4840 /* ??? People shouldn't be doing non-pic code in
4841 shared libraries. Hork. */
4842 (*_bfd_error_handler)
4843 (_("%B: linking non-pic code in a position independent executable"),
4850 dyn_r_type = r_type + R_IA64_RELNNLSB - R_IA64_FPTRNNLSB;
4854 if (h->dynindx != -1)
4855 dynindx = h->dynindx;
4857 dynindx = (_bfd_elf_link_lookup_local_dynindx
4858 (info, h->root.u.def.section->owner,
4859 global_sym_index (h)));
4864 dynindx = (_bfd_elf_link_lookup_local_dynindx
4865 (info, input_bfd, (long) r_symndx));
4869 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4870 srel, rel->r_offset, dyn_r_type,
4874 r = elfNN_ia64_install_value (hit_addr, value, r_type);
4877 case R_IA64_LTOFF_FPTR22:
4878 case R_IA64_LTOFF_FPTR64I:
4879 case R_IA64_LTOFF_FPTR32MSB:
4880 case R_IA64_LTOFF_FPTR32LSB:
4881 case R_IA64_LTOFF_FPTR64MSB:
4882 case R_IA64_LTOFF_FPTR64LSB:
4886 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4887 if (dyn_i->want_fptr)
4889 BFD_ASSERT (h == NULL || h->dynindx == -1);
4890 if (!undef_weak_ref)
4891 value = set_fptr_entry (output_bfd, info, dyn_i, value);
4896 /* Otherwise, we expect the dynamic linker to create
4900 if (h->dynindx != -1)
4901 dynindx = h->dynindx;
4903 dynindx = (_bfd_elf_link_lookup_local_dynindx
4904 (info, h->root.u.def.section->owner,
4905 global_sym_index (h)));
4908 dynindx = (_bfd_elf_link_lookup_local_dynindx
4909 (info, input_bfd, (long) r_symndx));
4913 value = set_got_entry (output_bfd, info, dyn_i, dynindx,
4914 rel->r_addend, value, R_IA64_FPTRNNLSB);
4916 r = elfNN_ia64_install_value (hit_addr, value, r_type);
4920 case R_IA64_PCREL32MSB:
4921 case R_IA64_PCREL32LSB:
4922 case R_IA64_PCREL64MSB:
4923 case R_IA64_PCREL64LSB:
4924 /* Install a dynamic relocation for this reloc. */
4925 if (dynamic_symbol_p && r_symndx != 0)
4927 BFD_ASSERT (srel != NULL);
4929 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4930 srel, rel->r_offset, r_type,
4931 h->dynindx, rel->r_addend);
4935 case R_IA64_PCREL21B:
4936 case R_IA64_PCREL60B:
4937 /* We should have created a PLT entry for any dynamic symbol. */
4940 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE);
4942 if (dyn_i && dyn_i->want_plt2)
4944 /* Should have caught this earlier. */
4945 BFD_ASSERT (rel->r_addend == 0);
4947 value = (ia64_info->plt_sec->output_section->vma
4948 + ia64_info->plt_sec->output_offset
4949 + dyn_i->plt2_offset);
4953 /* Since there's no PLT entry, Validate that this is
4955 BFD_ASSERT (undef_weak_ref || sym_sec->output_section != NULL);
4957 /* If the symbol is undef_weak, we shouldn't be trying
4958 to call it. There's every chance that we'd wind up
4959 with an out-of-range fixup here. Don't bother setting
4960 any value at all. */
4966 case R_IA64_PCREL21BI:
4967 case R_IA64_PCREL21F:
4968 case R_IA64_PCREL21M:
4969 case R_IA64_PCREL22:
4970 case R_IA64_PCREL64I:
4971 /* The PCREL21BI reloc is specifically not intended for use with
4972 dynamic relocs. PCREL21F and PCREL21M are used for speculation
4973 fixup code, and thus probably ought not be dynamic. The
4974 PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs. */
4975 if (dynamic_symbol_p)
4979 if (r_type == R_IA64_PCREL21BI)
4980 msg = _("%B: @internal branch to dynamic symbol %s");
4981 else if (r_type == R_IA64_PCREL21F || r_type == R_IA64_PCREL21M)
4982 msg = _("%B: speculation fixup to dynamic symbol %s");
4984 msg = _("%B: @pcrel relocation against dynamic symbol %s");
4985 (*_bfd_error_handler) (msg, input_bfd,
4986 h ? h->root.root.string
4987 : bfd_elf_sym_name (input_bfd,
4997 /* Make pc-relative. */
4998 value -= (input_section->output_section->vma
4999 + input_section->output_offset
5000 + rel->r_offset) & ~ (bfd_vma) 0x3;
5001 r = elfNN_ia64_install_value (hit_addr, value, r_type);
5004 case R_IA64_SEGREL32MSB:
5005 case R_IA64_SEGREL32LSB:
5006 case R_IA64_SEGREL64MSB:
5007 case R_IA64_SEGREL64LSB:
5009 struct elf_segment_map *m;
5010 Elf_Internal_Phdr *p;
5012 /* Find the segment that contains the output_section. */
5013 for (m = elf_tdata (output_bfd)->segment_map,
5014 p = elf_tdata (output_bfd)->phdr;
5019 for (i = m->count - 1; i >= 0; i--)
5020 if (m->sections[i] == input_section->output_section)
5028 r = bfd_reloc_notsupported;
5032 /* The VMA of the segment is the vaddr of the associated
5034 if (value > p->p_vaddr)
5035 value -= p->p_vaddr;
5038 r = elfNN_ia64_install_value (hit_addr, value, r_type);
5043 case R_IA64_SECREL32MSB:
5044 case R_IA64_SECREL32LSB:
5045 case R_IA64_SECREL64MSB:
5046 case R_IA64_SECREL64LSB:
5047 /* Make output-section relative to section where the symbol
5048 is defined. PR 475 */
5050 value -= sym_sec->output_section->vma;
5051 r = elfNN_ia64_install_value (hit_addr, value, r_type);
5054 case R_IA64_IPLTMSB:
5055 case R_IA64_IPLTLSB:
5056 /* Install a dynamic relocation for this reloc. */
5057 if ((dynamic_symbol_p || info->shared)
5058 && (input_section->flags & SEC_ALLOC) != 0)
5060 BFD_ASSERT (srel != NULL);
5062 /* If we don't need dynamic symbol lookup, install two
5063 RELATIVE relocations. */
5064 if (!dynamic_symbol_p)
5066 unsigned int dyn_r_type;
5068 if (r_type == R_IA64_IPLTMSB)
5069 dyn_r_type = R_IA64_REL64MSB;
5071 dyn_r_type = R_IA64_REL64LSB;
5073 elfNN_ia64_install_dyn_reloc (output_bfd, info,
5075 srel, rel->r_offset,
5076 dyn_r_type, 0, value);
5077 elfNN_ia64_install_dyn_reloc (output_bfd, info,
5079 srel, rel->r_offset + 8,
5080 dyn_r_type, 0, gp_val);
5083 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
5084 srel, rel->r_offset, r_type,
5085 h->dynindx, rel->r_addend);
5088 if (r_type == R_IA64_IPLTMSB)
5089 r_type = R_IA64_DIR64MSB;
5091 r_type = R_IA64_DIR64LSB;
5092 elfNN_ia64_install_value (hit_addr, value, r_type);
5093 r = elfNN_ia64_install_value (hit_addr + 8, gp_val, r_type);
5096 case R_IA64_TPREL14:
5097 case R_IA64_TPREL22:
5098 case R_IA64_TPREL64I:
5099 value -= elfNN_ia64_tprel_base (info);
5100 r = elfNN_ia64_install_value (hit_addr, value, r_type);
5103 case R_IA64_DTPREL14:
5104 case R_IA64_DTPREL22:
5105 case R_IA64_DTPREL64I:
5106 case R_IA64_DTPREL32LSB:
5107 case R_IA64_DTPREL32MSB:
5108 case R_IA64_DTPREL64LSB:
5109 case R_IA64_DTPREL64MSB:
5110 value -= elfNN_ia64_dtprel_base (info);
5111 r = elfNN_ia64_install_value (hit_addr, value, r_type);
5114 case R_IA64_LTOFF_TPREL22:
5115 case R_IA64_LTOFF_DTPMOD22:
5116 case R_IA64_LTOFF_DTPREL22:
5119 long dynindx = h ? h->dynindx : -1;
5120 bfd_vma r_addend = rel->r_addend;
5125 case R_IA64_LTOFF_TPREL22:
5126 if (!dynamic_symbol_p)
5129 value -= elfNN_ia64_tprel_base (info);
5132 r_addend += value - elfNN_ia64_dtprel_base (info);
5136 got_r_type = R_IA64_TPREL64LSB;
5138 case R_IA64_LTOFF_DTPMOD22:
5139 if (!dynamic_symbol_p && !info->shared)
5141 got_r_type = R_IA64_DTPMOD64LSB;
5143 case R_IA64_LTOFF_DTPREL22:
5144 if (!dynamic_symbol_p)
5145 value -= elfNN_ia64_dtprel_base (info);
5146 got_r_type = R_IA64_DTPRELNNLSB;
5149 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
5150 value = set_got_entry (input_bfd, info, dyn_i, dynindx, r_addend,
5153 r = elfNN_ia64_install_value (hit_addr, value, r_type);
5158 r = bfd_reloc_notsupported;
5167 case bfd_reloc_undefined:
5168 /* This can happen for global table relative relocs if
5169 __gp is undefined. This is a panic situation so we
5170 don't try to continue. */
5171 (*info->callbacks->undefined_symbol)
5172 (info, "__gp", input_bfd, input_section, rel->r_offset, 1);
5175 case bfd_reloc_notsupported:
5180 name = h->root.root.string;
5182 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
5184 if (!(*info->callbacks->warning) (info, _("unsupported reloc"),
5186 input_section, rel->r_offset))
5192 case bfd_reloc_dangerous:
5193 case bfd_reloc_outofrange:
5194 case bfd_reloc_overflow:
5200 name = h->root.root.string;
5202 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
5207 case R_IA64_PCREL21B:
5208 case R_IA64_PCREL21BI:
5209 case R_IA64_PCREL21M:
5210 case R_IA64_PCREL21F:
5211 if (is_elf_hash_table (info->hash))
5213 /* Relaxtion is always performed for ELF output.
5214 Overflow failures for those relocations mean
5215 that the section is too big to relax. */
5216 (*_bfd_error_handler)
5217 (_("%B: Can't relax br (%s) to `%s' at 0x%lx in section `%A' with size 0x%lx (> 0x1000000)."),
5218 input_bfd, input_section, howto->name, name,
5219 rel->r_offset, input_section->size);
5223 if (!(*info->callbacks->reloc_overflow) (info,
5245 elfNN_ia64_finish_dynamic_symbol (output_bfd, info, h, sym)
5247 struct bfd_link_info *info;
5248 struct elf_link_hash_entry *h;
5249 Elf_Internal_Sym *sym;
5251 struct elfNN_ia64_link_hash_table *ia64_info;
5252 struct elfNN_ia64_dyn_sym_info *dyn_i;
5254 ia64_info = elfNN_ia64_hash_table (info);
5255 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE);
5257 /* Fill in the PLT data, if required. */
5258 if (dyn_i && dyn_i->want_plt)
5260 Elf_Internal_Rela outrel;
5263 bfd_vma plt_addr, pltoff_addr, gp_val, index;
5265 gp_val = _bfd_get_gp_value (output_bfd);
5267 /* Initialize the minimal PLT entry. */
5269 index = (dyn_i->plt_offset - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
5270 plt_sec = ia64_info->plt_sec;
5271 loc = plt_sec->contents + dyn_i->plt_offset;
5273 memcpy (loc, plt_min_entry, PLT_MIN_ENTRY_SIZE);
5274 elfNN_ia64_install_value (loc, index, R_IA64_IMM22);
5275 elfNN_ia64_install_value (loc+2, -dyn_i->plt_offset, R_IA64_PCREL21B);
5277 plt_addr = (plt_sec->output_section->vma
5278 + plt_sec->output_offset
5279 + dyn_i->plt_offset);
5280 pltoff_addr = set_pltoff_entry (output_bfd, info, dyn_i, plt_addr, TRUE);
5282 /* Initialize the FULL PLT entry, if needed. */
5283 if (dyn_i->want_plt2)
5285 loc = plt_sec->contents + dyn_i->plt2_offset;
5287 memcpy (loc, plt_full_entry, PLT_FULL_ENTRY_SIZE);
5288 elfNN_ia64_install_value (loc, pltoff_addr - gp_val, R_IA64_IMM22);
5290 /* Mark the symbol as undefined, rather than as defined in the
5291 plt section. Leave the value alone. */
5292 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
5293 first place. But perhaps elflink.c did some for us. */
5294 if (!h->def_regular)
5295 sym->st_shndx = SHN_UNDEF;
5298 /* Create the dynamic relocation. */
5299 outrel.r_offset = pltoff_addr;
5300 if (bfd_little_endian (output_bfd))
5301 outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTLSB);
5303 outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTMSB);
5304 outrel.r_addend = 0;
5306 /* This is fun. In the .IA_64.pltoff section, we've got entries
5307 that correspond both to real PLT entries, and those that
5308 happened to resolve to local symbols but need to be created
5309 to satisfy @pltoff relocations. The .rela.IA_64.pltoff
5310 relocations for the real PLT should come at the end of the
5311 section, so that they can be indexed by plt entry at runtime.
5313 We emitted all of the relocations for the non-PLT @pltoff
5314 entries during relocate_section. So we can consider the
5315 existing sec->reloc_count to be the base of the array of
5318 loc = ia64_info->rel_pltoff_sec->contents;
5319 loc += ((ia64_info->rel_pltoff_sec->reloc_count + index)
5320 * sizeof (ElfNN_External_Rela));
5321 bfd_elfNN_swap_reloca_out (output_bfd, &outrel, loc);
5324 /* Mark some specially defined symbols as absolute. */
5325 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
5326 || h == ia64_info->root.hgot
5327 || h == ia64_info->root.hplt)
5328 sym->st_shndx = SHN_ABS;
5334 elfNN_ia64_finish_dynamic_sections (abfd, info)
5336 struct bfd_link_info *info;
5338 struct elfNN_ia64_link_hash_table *ia64_info;
5341 ia64_info = elfNN_ia64_hash_table (info);
5342 dynobj = ia64_info->root.dynobj;
5344 if (elf_hash_table (info)->dynamic_sections_created)
5346 ElfNN_External_Dyn *dyncon, *dynconend;
5347 asection *sdyn, *sgotplt;
5350 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5351 sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
5352 BFD_ASSERT (sdyn != NULL);
5353 dyncon = (ElfNN_External_Dyn *) sdyn->contents;
5354 dynconend = (ElfNN_External_Dyn *) (sdyn->contents + sdyn->size);
5356 gp_val = _bfd_get_gp_value (abfd);
5358 for (; dyncon < dynconend; dyncon++)
5360 Elf_Internal_Dyn dyn;
5362 bfd_elfNN_swap_dyn_in (dynobj, dyncon, &dyn);
5367 dyn.d_un.d_ptr = gp_val;
5371 dyn.d_un.d_val = (ia64_info->minplt_entries
5372 * sizeof (ElfNN_External_Rela));
5376 /* See the comment above in finish_dynamic_symbol. */
5377 dyn.d_un.d_ptr = (ia64_info->rel_pltoff_sec->output_section->vma
5378 + ia64_info->rel_pltoff_sec->output_offset
5379 + (ia64_info->rel_pltoff_sec->reloc_count
5380 * sizeof (ElfNN_External_Rela)));
5383 case DT_IA_64_PLT_RESERVE:
5384 dyn.d_un.d_ptr = (sgotplt->output_section->vma
5385 + sgotplt->output_offset);
5389 /* Do not have RELASZ include JMPREL. This makes things
5390 easier on ld.so. This is not what the rest of BFD set up. */
5391 dyn.d_un.d_val -= (ia64_info->minplt_entries
5392 * sizeof (ElfNN_External_Rela));
5396 bfd_elfNN_swap_dyn_out (abfd, &dyn, dyncon);
5399 /* Initialize the PLT0 entry. */
5400 if (ia64_info->plt_sec)
5402 bfd_byte *loc = ia64_info->plt_sec->contents;
5405 memcpy (loc, plt_header, PLT_HEADER_SIZE);
5407 pltres = (sgotplt->output_section->vma
5408 + sgotplt->output_offset
5411 elfNN_ia64_install_value (loc+1, pltres, R_IA64_GPREL22);
5418 /* ELF file flag handling: */
5420 /* Function to keep IA-64 specific file flags. */
5422 elfNN_ia64_set_private_flags (abfd, flags)
5426 BFD_ASSERT (!elf_flags_init (abfd)
5427 || elf_elfheader (abfd)->e_flags == flags);
5429 elf_elfheader (abfd)->e_flags = flags;
5430 elf_flags_init (abfd) = TRUE;
5434 /* Merge backend specific data from an object file to the output
5435 object file when linking. */
5437 elfNN_ia64_merge_private_bfd_data (ibfd, obfd)
5442 bfd_boolean ok = TRUE;
5444 /* Don't even pretend to support mixed-format linking. */
5445 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5446 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5449 in_flags = elf_elfheader (ibfd)->e_flags;
5450 out_flags = elf_elfheader (obfd)->e_flags;
5452 if (! elf_flags_init (obfd))
5454 elf_flags_init (obfd) = TRUE;
5455 elf_elfheader (obfd)->e_flags = in_flags;
5457 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
5458 && bfd_get_arch_info (obfd)->the_default)
5460 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
5461 bfd_get_mach (ibfd));
5467 /* Check flag compatibility. */
5468 if (in_flags == out_flags)
5471 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
5472 if (!(in_flags & EF_IA_64_REDUCEDFP) && (out_flags & EF_IA_64_REDUCEDFP))
5473 elf_elfheader (obfd)->e_flags &= ~EF_IA_64_REDUCEDFP;
5475 if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL))
5477 (*_bfd_error_handler)
5478 (_("%B: linking trap-on-NULL-dereference with non-trapping files"),
5481 bfd_set_error (bfd_error_bad_value);
5484 if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE))
5486 (*_bfd_error_handler)
5487 (_("%B: linking big-endian files with little-endian files"),
5490 bfd_set_error (bfd_error_bad_value);
5493 if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64))
5495 (*_bfd_error_handler)
5496 (_("%B: linking 64-bit files with 32-bit files"),
5499 bfd_set_error (bfd_error_bad_value);
5502 if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP))
5504 (*_bfd_error_handler)
5505 (_("%B: linking constant-gp files with non-constant-gp files"),
5508 bfd_set_error (bfd_error_bad_value);
5511 if ((in_flags & EF_IA_64_NOFUNCDESC_CONS_GP)
5512 != (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
5514 (*_bfd_error_handler)
5515 (_("%B: linking auto-pic files with non-auto-pic files"),
5518 bfd_set_error (bfd_error_bad_value);
5526 elfNN_ia64_print_private_bfd_data (abfd, ptr)
5530 FILE *file = (FILE *) ptr;
5531 flagword flags = elf_elfheader (abfd)->e_flags;
5533 BFD_ASSERT (abfd != NULL && ptr != NULL);
5535 fprintf (file, "private flags = %s%s%s%s%s%s%s%s\n",
5536 (flags & EF_IA_64_TRAPNIL) ? "TRAPNIL, " : "",
5537 (flags & EF_IA_64_EXT) ? "EXT, " : "",
5538 (flags & EF_IA_64_BE) ? "BE, " : "LE, ",
5539 (flags & EF_IA_64_REDUCEDFP) ? "REDUCEDFP, " : "",
5540 (flags & EF_IA_64_CONS_GP) ? "CONS_GP, " : "",
5541 (flags & EF_IA_64_NOFUNCDESC_CONS_GP) ? "NOFUNCDESC_CONS_GP, " : "",
5542 (flags & EF_IA_64_ABSOLUTE) ? "ABSOLUTE, " : "",
5543 (flags & EF_IA_64_ABI64) ? "ABI64" : "ABI32");
5545 _bfd_elf_print_private_bfd_data (abfd, ptr);
5549 static enum elf_reloc_type_class
5550 elfNN_ia64_reloc_type_class (rela)
5551 const Elf_Internal_Rela *rela;
5553 switch ((int) ELFNN_R_TYPE (rela->r_info))
5555 case R_IA64_REL32MSB:
5556 case R_IA64_REL32LSB:
5557 case R_IA64_REL64MSB:
5558 case R_IA64_REL64LSB:
5559 return reloc_class_relative;
5560 case R_IA64_IPLTMSB:
5561 case R_IA64_IPLTLSB:
5562 return reloc_class_plt;
5564 return reloc_class_copy;
5566 return reloc_class_normal;
5570 static const struct bfd_elf_special_section elfNN_ia64_special_sections[] =
5572 { STRING_COMMA_LEN (".sbss"), -1, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
5573 { STRING_COMMA_LEN (".sdata"), -1, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
5574 { NULL, 0, 0, 0, 0 }
5578 elfNN_ia64_object_p (bfd *abfd)
5581 asection *group, *unwi, *unw;
5584 char *unwi_name, *unw_name;
5587 if (abfd->flags & DYNAMIC)
5590 /* Flags for fake group section. */
5591 flags = (SEC_LINKER_CREATED | SEC_GROUP | SEC_LINK_ONCE
5594 /* We add a fake section group for each .gnu.linkonce.t.* section,
5595 which isn't in a section group, and its unwind sections. */
5596 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5598 if (elf_sec_group (sec) == NULL
5599 && ((sec->flags & (SEC_LINK_ONCE | SEC_CODE | SEC_GROUP))
5600 == (SEC_LINK_ONCE | SEC_CODE))
5601 && CONST_STRNEQ (sec->name, ".gnu.linkonce.t."))
5603 name = sec->name + 16;
5605 amt = strlen (name) + sizeof (".gnu.linkonce.ia64unwi.");
5606 unwi_name = bfd_alloc (abfd, amt);
5610 strcpy (stpcpy (unwi_name, ".gnu.linkonce.ia64unwi."), name);
5611 unwi = bfd_get_section_by_name (abfd, unwi_name);
5613 amt = strlen (name) + sizeof (".gnu.linkonce.ia64unw.");
5614 unw_name = bfd_alloc (abfd, amt);
5618 strcpy (stpcpy (unw_name, ".gnu.linkonce.ia64unw."), name);
5619 unw = bfd_get_section_by_name (abfd, unw_name);
5621 /* We need to create a fake group section for it and its
5623 group = bfd_make_section_anyway_with_flags (abfd, name,
5628 /* Move the fake group section to the beginning. */
5629 bfd_section_list_remove (abfd, group);
5630 bfd_section_list_prepend (abfd, group);
5632 elf_next_in_group (group) = sec;
5634 elf_group_name (sec) = name;
5635 elf_next_in_group (sec) = sec;
5636 elf_sec_group (sec) = group;
5640 elf_group_name (unwi) = name;
5641 elf_next_in_group (unwi) = sec;
5642 elf_next_in_group (sec) = unwi;
5643 elf_sec_group (unwi) = group;
5648 elf_group_name (unw) = name;
5651 elf_next_in_group (unw) = elf_next_in_group (unwi);
5652 elf_next_in_group (unwi) = unw;
5656 elf_next_in_group (unw) = sec;
5657 elf_next_in_group (sec) = unw;
5659 elf_sec_group (unw) = group;
5662 /* Fake SHT_GROUP section header. */
5663 elf_section_data (group)->this_hdr.bfd_section = group;
5664 elf_section_data (group)->this_hdr.sh_type = SHT_GROUP;
5671 elfNN_ia64_hpux_vec (const bfd_target *vec)
5673 extern const bfd_target bfd_elfNN_ia64_hpux_big_vec;
5674 return (vec == & bfd_elfNN_ia64_hpux_big_vec);
5678 elfNN_hpux_post_process_headers (abfd, info)
5680 struct bfd_link_info *info ATTRIBUTE_UNUSED;
5682 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
5684 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
5685 i_ehdrp->e_ident[EI_ABIVERSION] = 1;
5689 elfNN_hpux_backend_section_from_bfd_section (abfd, sec, retval)
5690 bfd *abfd ATTRIBUTE_UNUSED;
5694 if (bfd_is_com_section (sec))
5696 *retval = SHN_IA_64_ANSI_COMMON;
5703 elfNN_hpux_backend_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
5706 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
5708 switch (elfsym->internal_elf_sym.st_shndx)
5710 case SHN_IA_64_ANSI_COMMON:
5711 asym->section = bfd_com_section_ptr;
5712 asym->value = elfsym->internal_elf_sym.st_size;
5713 asym->flags &= ~BSF_GLOBAL;
5719 #define TARGET_LITTLE_SYM bfd_elfNN_ia64_little_vec
5720 #define TARGET_LITTLE_NAME "elfNN-ia64-little"
5721 #define TARGET_BIG_SYM bfd_elfNN_ia64_big_vec
5722 #define TARGET_BIG_NAME "elfNN-ia64-big"
5723 #define ELF_ARCH bfd_arch_ia64
5724 #define ELF_MACHINE_CODE EM_IA_64
5725 #define ELF_MACHINE_ALT1 1999 /* EAS2.3 */
5726 #define ELF_MACHINE_ALT2 1998 /* EAS2.2 */
5727 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
5728 #define ELF_COMMONPAGESIZE 0x4000 /* 16KB */
5730 #define elf_backend_section_from_shdr \
5731 elfNN_ia64_section_from_shdr
5732 #define elf_backend_section_flags \
5733 elfNN_ia64_section_flags
5734 #define elf_backend_fake_sections \
5735 elfNN_ia64_fake_sections
5736 #define elf_backend_final_write_processing \
5737 elfNN_ia64_final_write_processing
5738 #define elf_backend_add_symbol_hook \
5739 elfNN_ia64_add_symbol_hook
5740 #define elf_backend_additional_program_headers \
5741 elfNN_ia64_additional_program_headers
5742 #define elf_backend_modify_segment_map \
5743 elfNN_ia64_modify_segment_map
5744 #define elf_backend_modify_program_headers \
5745 elfNN_ia64_modify_program_headers
5746 #define elf_info_to_howto \
5747 elfNN_ia64_info_to_howto
5749 #define bfd_elfNN_bfd_reloc_type_lookup \
5750 elfNN_ia64_reloc_type_lookup
5751 #define bfd_elfNN_bfd_is_local_label_name \
5752 elfNN_ia64_is_local_label_name
5753 #define bfd_elfNN_bfd_relax_section \
5754 elfNN_ia64_relax_section
5756 #define elf_backend_object_p \
5759 /* Stuff for the BFD linker: */
5760 #define bfd_elfNN_bfd_link_hash_table_create \
5761 elfNN_ia64_hash_table_create
5762 #define bfd_elfNN_bfd_link_hash_table_free \
5763 elfNN_ia64_hash_table_free
5764 #define elf_backend_create_dynamic_sections \
5765 elfNN_ia64_create_dynamic_sections
5766 #define elf_backend_check_relocs \
5767 elfNN_ia64_check_relocs
5768 #define elf_backend_adjust_dynamic_symbol \
5769 elfNN_ia64_adjust_dynamic_symbol
5770 #define elf_backend_size_dynamic_sections \
5771 elfNN_ia64_size_dynamic_sections
5772 #define elf_backend_omit_section_dynsym \
5773 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5774 #define elf_backend_relocate_section \
5775 elfNN_ia64_relocate_section
5776 #define elf_backend_finish_dynamic_symbol \
5777 elfNN_ia64_finish_dynamic_symbol
5778 #define elf_backend_finish_dynamic_sections \
5779 elfNN_ia64_finish_dynamic_sections
5780 #define bfd_elfNN_bfd_final_link \
5781 elfNN_ia64_final_link
5783 #define bfd_elfNN_bfd_merge_private_bfd_data \
5784 elfNN_ia64_merge_private_bfd_data
5785 #define bfd_elfNN_bfd_set_private_flags \
5786 elfNN_ia64_set_private_flags
5787 #define bfd_elfNN_bfd_print_private_bfd_data \
5788 elfNN_ia64_print_private_bfd_data
5790 #define elf_backend_plt_readonly 1
5791 #define elf_backend_want_plt_sym 0
5792 #define elf_backend_plt_alignment 5
5793 #define elf_backend_got_header_size 0
5794 #define elf_backend_want_got_plt 1
5795 #define elf_backend_may_use_rel_p 1
5796 #define elf_backend_may_use_rela_p 1
5797 #define elf_backend_default_use_rela_p 1
5798 #define elf_backend_want_dynbss 0
5799 #define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect
5800 #define elf_backend_hide_symbol elfNN_ia64_hash_hide_symbol
5801 #define elf_backend_fixup_symbol _bfd_elf_link_hash_fixup_symbol
5802 #define elf_backend_reloc_type_class elfNN_ia64_reloc_type_class
5803 #define elf_backend_rela_normal 1
5804 #define elf_backend_special_sections elfNN_ia64_special_sections
5806 /* FIXME: PR 290: The Intel C compiler generates SHT_IA_64_UNWIND with
5807 SHF_LINK_ORDER. But it doesn't set the sh_link or sh_info fields.
5808 We don't want to flood users with so many error messages. We turn
5809 off the warning for now. It will be turned on later when the Intel
5810 compiler is fixed. */
5811 #define elf_backend_link_order_error_handler NULL
5813 #include "elfNN-target.h"
5815 /* HPUX-specific vectors. */
5817 #undef TARGET_LITTLE_SYM
5818 #undef TARGET_LITTLE_NAME
5819 #undef TARGET_BIG_SYM
5820 #define TARGET_BIG_SYM bfd_elfNN_ia64_hpux_big_vec
5821 #undef TARGET_BIG_NAME
5822 #define TARGET_BIG_NAME "elfNN-ia64-hpux-big"
5824 /* These are HP-UX specific functions. */
5826 #undef elf_backend_post_process_headers
5827 #define elf_backend_post_process_headers elfNN_hpux_post_process_headers
5829 #undef elf_backend_section_from_bfd_section
5830 #define elf_backend_section_from_bfd_section elfNN_hpux_backend_section_from_bfd_section
5832 #undef elf_backend_symbol_processing
5833 #define elf_backend_symbol_processing elfNN_hpux_backend_symbol_processing
5835 #undef elf_backend_want_p_paddr_set_to_zero
5836 #define elf_backend_want_p_paddr_set_to_zero 1
5838 #undef ELF_MAXPAGESIZE
5839 #define ELF_MAXPAGESIZE 0x1000 /* 4K */
5840 #undef ELF_COMMONPAGESIZE
5842 #define ELF_OSABI ELFOSABI_HPUX
5845 #define elfNN_bed elfNN_ia64_hpux_bed
5847 #include "elfNN-target.h"
5849 #undef elf_backend_want_p_paddr_set_to_zero