1 /* IA-64 support for 64-bit ELF
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
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_modify_segment_map
219 PARAMS ((bfd *, struct bfd_link_info *));
220 static bfd_boolean elfNN_ia64_is_local_label_name
221 PARAMS ((bfd *abfd, const char *name));
222 static bfd_boolean elfNN_ia64_dynamic_symbol_p
223 PARAMS ((struct elf_link_hash_entry *h, struct bfd_link_info *info, int));
224 static struct bfd_hash_entry *elfNN_ia64_new_elf_hash_entry
225 PARAMS ((struct bfd_hash_entry *entry, struct bfd_hash_table *table,
226 const char *string));
227 static void elfNN_ia64_hash_copy_indirect
228 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *,
229 struct elf_link_hash_entry *));
230 static void elfNN_ia64_hash_hide_symbol
231 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean));
232 static hashval_t elfNN_ia64_local_htab_hash PARAMS ((const void *));
233 static int elfNN_ia64_local_htab_eq PARAMS ((const void *ptr1,
235 static struct bfd_link_hash_table *elfNN_ia64_hash_table_create
236 PARAMS ((bfd *abfd));
237 static void elfNN_ia64_hash_table_free
238 PARAMS ((struct bfd_link_hash_table *hash));
239 static bfd_boolean elfNN_ia64_global_dyn_sym_thunk
240 PARAMS ((struct bfd_hash_entry *, PTR));
241 static int elfNN_ia64_local_dyn_sym_thunk
242 PARAMS ((void **, PTR));
243 static void elfNN_ia64_dyn_sym_traverse
244 PARAMS ((struct elfNN_ia64_link_hash_table *ia64_info,
245 bfd_boolean (*func) (struct elfNN_ia64_dyn_sym_info *, PTR),
247 static bfd_boolean elfNN_ia64_create_dynamic_sections
248 PARAMS ((bfd *abfd, struct bfd_link_info *info));
249 static struct elfNN_ia64_local_hash_entry * get_local_sym_hash
250 PARAMS ((struct elfNN_ia64_link_hash_table *ia64_info,
251 bfd *abfd, const Elf_Internal_Rela *rel, bfd_boolean create));
252 static struct elfNN_ia64_dyn_sym_info * get_dyn_sym_info
253 PARAMS ((struct elfNN_ia64_link_hash_table *ia64_info,
254 struct elf_link_hash_entry *h,
255 bfd *abfd, const Elf_Internal_Rela *rel, bfd_boolean create));
256 static asection *get_got
257 PARAMS ((bfd *abfd, struct bfd_link_info *info,
258 struct elfNN_ia64_link_hash_table *ia64_info));
259 static asection *get_fptr
260 PARAMS ((bfd *abfd, struct bfd_link_info *info,
261 struct elfNN_ia64_link_hash_table *ia64_info));
262 static asection *get_pltoff
263 PARAMS ((bfd *abfd, struct bfd_link_info *info,
264 struct elfNN_ia64_link_hash_table *ia64_info));
265 static asection *get_reloc_section
266 PARAMS ((bfd *abfd, struct elfNN_ia64_link_hash_table *ia64_info,
267 asection *sec, bfd_boolean create));
268 static bfd_boolean elfNN_ia64_check_relocs
269 PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *sec,
270 const Elf_Internal_Rela *relocs));
271 static bfd_boolean elfNN_ia64_adjust_dynamic_symbol
272 PARAMS ((struct bfd_link_info *info, struct elf_link_hash_entry *h));
273 static long global_sym_index
274 PARAMS ((struct elf_link_hash_entry *h));
275 static bfd_boolean allocate_fptr
276 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
277 static bfd_boolean allocate_global_data_got
278 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
279 static bfd_boolean allocate_global_fptr_got
280 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
281 static bfd_boolean allocate_local_got
282 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
283 static bfd_boolean allocate_pltoff_entries
284 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
285 static bfd_boolean allocate_plt_entries
286 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
287 static bfd_boolean allocate_plt2_entries
288 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
289 static bfd_boolean allocate_dynrel_entries
290 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
291 static bfd_boolean elfNN_ia64_size_dynamic_sections
292 PARAMS ((bfd *output_bfd, struct bfd_link_info *info));
293 static bfd_reloc_status_type elfNN_ia64_install_value
294 PARAMS ((bfd_byte *hit_addr, bfd_vma val, unsigned int r_type));
295 static void elfNN_ia64_install_dyn_reloc
296 PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *sec,
297 asection *srel, bfd_vma offset, unsigned int type,
298 long dynindx, bfd_vma addend));
299 static bfd_vma set_got_entry
300 PARAMS ((bfd *abfd, struct bfd_link_info *info,
301 struct elfNN_ia64_dyn_sym_info *dyn_i, long dynindx,
302 bfd_vma addend, bfd_vma value, unsigned int dyn_r_type));
303 static bfd_vma set_fptr_entry
304 PARAMS ((bfd *abfd, struct bfd_link_info *info,
305 struct elfNN_ia64_dyn_sym_info *dyn_i,
307 static bfd_vma set_pltoff_entry
308 PARAMS ((bfd *abfd, struct bfd_link_info *info,
309 struct elfNN_ia64_dyn_sym_info *dyn_i,
310 bfd_vma value, bfd_boolean));
311 static bfd_vma elfNN_ia64_tprel_base
312 PARAMS ((struct bfd_link_info *info));
313 static bfd_vma elfNN_ia64_dtprel_base
314 PARAMS ((struct bfd_link_info *info));
315 static int elfNN_ia64_unwind_entry_compare
316 PARAMS ((const PTR, const PTR));
317 static bfd_boolean elfNN_ia64_choose_gp
318 PARAMS ((bfd *abfd, struct bfd_link_info *info));
319 static bfd_boolean elfNN_ia64_final_link
320 PARAMS ((bfd *abfd, struct bfd_link_info *info));
321 static bfd_boolean elfNN_ia64_relocate_section
322 PARAMS ((bfd *output_bfd, struct bfd_link_info *info, bfd *input_bfd,
323 asection *input_section, bfd_byte *contents,
324 Elf_Internal_Rela *relocs, Elf_Internal_Sym *local_syms,
325 asection **local_sections));
326 static bfd_boolean elfNN_ia64_finish_dynamic_symbol
327 PARAMS ((bfd *output_bfd, struct bfd_link_info *info,
328 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym));
329 static bfd_boolean elfNN_ia64_finish_dynamic_sections
330 PARAMS ((bfd *abfd, struct bfd_link_info *info));
331 static bfd_boolean elfNN_ia64_set_private_flags
332 PARAMS ((bfd *abfd, flagword flags));
333 static bfd_boolean elfNN_ia64_merge_private_bfd_data
334 PARAMS ((bfd *ibfd, bfd *obfd));
335 static bfd_boolean elfNN_ia64_print_private_bfd_data
336 PARAMS ((bfd *abfd, PTR ptr));
337 static enum elf_reloc_type_class elfNN_ia64_reloc_type_class
338 PARAMS ((const Elf_Internal_Rela *));
339 static bfd_boolean elfNN_ia64_hpux_vec
340 PARAMS ((const bfd_target *vec));
341 static void elfNN_hpux_post_process_headers
342 PARAMS ((bfd *abfd, struct bfd_link_info *info));
343 bfd_boolean elfNN_hpux_backend_section_from_bfd_section
344 PARAMS ((bfd *abfd, asection *sec, int *retval));
346 /* ia64-specific relocation. */
348 /* Perform a relocation. Not much to do here as all the hard work is
349 done in elfNN_ia64_final_link_relocate. */
350 static bfd_reloc_status_type
351 elfNN_ia64_reloc (abfd, reloc, sym, data, input_section,
352 output_bfd, error_message)
353 bfd *abfd ATTRIBUTE_UNUSED;
355 asymbol *sym ATTRIBUTE_UNUSED;
356 PTR data ATTRIBUTE_UNUSED;
357 asection *input_section;
359 char **error_message;
363 reloc->address += input_section->output_offset;
367 if (input_section->flags & SEC_DEBUGGING)
368 return bfd_reloc_continue;
370 *error_message = "Unsupported call to elfNN_ia64_reloc";
371 return bfd_reloc_notsupported;
374 #define IA64_HOWTO(TYPE, NAME, SIZE, PCREL, IN) \
375 HOWTO (TYPE, 0, SIZE, 0, PCREL, 0, complain_overflow_signed, \
376 elfNN_ia64_reloc, NAME, FALSE, 0, -1, IN)
378 /* This table has to be sorted according to increasing number of the
380 static reloc_howto_type ia64_howto_table[] =
382 IA64_HOWTO (R_IA64_NONE, "NONE", 0, FALSE, TRUE),
384 IA64_HOWTO (R_IA64_IMM14, "IMM14", 0, FALSE, TRUE),
385 IA64_HOWTO (R_IA64_IMM22, "IMM22", 0, FALSE, TRUE),
386 IA64_HOWTO (R_IA64_IMM64, "IMM64", 0, FALSE, TRUE),
387 IA64_HOWTO (R_IA64_DIR32MSB, "DIR32MSB", 2, FALSE, TRUE),
388 IA64_HOWTO (R_IA64_DIR32LSB, "DIR32LSB", 2, FALSE, TRUE),
389 IA64_HOWTO (R_IA64_DIR64MSB, "DIR64MSB", 4, FALSE, TRUE),
390 IA64_HOWTO (R_IA64_DIR64LSB, "DIR64LSB", 4, FALSE, TRUE),
392 IA64_HOWTO (R_IA64_GPREL22, "GPREL22", 0, FALSE, TRUE),
393 IA64_HOWTO (R_IA64_GPREL64I, "GPREL64I", 0, FALSE, TRUE),
394 IA64_HOWTO (R_IA64_GPREL32MSB, "GPREL32MSB", 2, FALSE, TRUE),
395 IA64_HOWTO (R_IA64_GPREL32LSB, "GPREL32LSB", 2, FALSE, TRUE),
396 IA64_HOWTO (R_IA64_GPREL64MSB, "GPREL64MSB", 4, FALSE, TRUE),
397 IA64_HOWTO (R_IA64_GPREL64LSB, "GPREL64LSB", 4, FALSE, TRUE),
399 IA64_HOWTO (R_IA64_LTOFF22, "LTOFF22", 0, FALSE, TRUE),
400 IA64_HOWTO (R_IA64_LTOFF64I, "LTOFF64I", 0, FALSE, TRUE),
402 IA64_HOWTO (R_IA64_PLTOFF22, "PLTOFF22", 0, FALSE, TRUE),
403 IA64_HOWTO (R_IA64_PLTOFF64I, "PLTOFF64I", 0, FALSE, TRUE),
404 IA64_HOWTO (R_IA64_PLTOFF64MSB, "PLTOFF64MSB", 4, FALSE, TRUE),
405 IA64_HOWTO (R_IA64_PLTOFF64LSB, "PLTOFF64LSB", 4, FALSE, TRUE),
407 IA64_HOWTO (R_IA64_FPTR64I, "FPTR64I", 0, FALSE, TRUE),
408 IA64_HOWTO (R_IA64_FPTR32MSB, "FPTR32MSB", 2, FALSE, TRUE),
409 IA64_HOWTO (R_IA64_FPTR32LSB, "FPTR32LSB", 2, FALSE, TRUE),
410 IA64_HOWTO (R_IA64_FPTR64MSB, "FPTR64MSB", 4, FALSE, TRUE),
411 IA64_HOWTO (R_IA64_FPTR64LSB, "FPTR64LSB", 4, FALSE, TRUE),
413 IA64_HOWTO (R_IA64_PCREL60B, "PCREL60B", 0, TRUE, TRUE),
414 IA64_HOWTO (R_IA64_PCREL21B, "PCREL21B", 0, TRUE, TRUE),
415 IA64_HOWTO (R_IA64_PCREL21M, "PCREL21M", 0, TRUE, TRUE),
416 IA64_HOWTO (R_IA64_PCREL21F, "PCREL21F", 0, TRUE, TRUE),
417 IA64_HOWTO (R_IA64_PCREL32MSB, "PCREL32MSB", 2, TRUE, TRUE),
418 IA64_HOWTO (R_IA64_PCREL32LSB, "PCREL32LSB", 2, TRUE, TRUE),
419 IA64_HOWTO (R_IA64_PCREL64MSB, "PCREL64MSB", 4, TRUE, TRUE),
420 IA64_HOWTO (R_IA64_PCREL64LSB, "PCREL64LSB", 4, TRUE, TRUE),
422 IA64_HOWTO (R_IA64_LTOFF_FPTR22, "LTOFF_FPTR22", 0, FALSE, TRUE),
423 IA64_HOWTO (R_IA64_LTOFF_FPTR64I, "LTOFF_FPTR64I", 0, FALSE, TRUE),
424 IA64_HOWTO (R_IA64_LTOFF_FPTR32MSB, "LTOFF_FPTR32MSB", 2, FALSE, TRUE),
425 IA64_HOWTO (R_IA64_LTOFF_FPTR32LSB, "LTOFF_FPTR32LSB", 2, FALSE, TRUE),
426 IA64_HOWTO (R_IA64_LTOFF_FPTR64MSB, "LTOFF_FPTR64MSB", 4, FALSE, TRUE),
427 IA64_HOWTO (R_IA64_LTOFF_FPTR64LSB, "LTOFF_FPTR64LSB", 4, FALSE, TRUE),
429 IA64_HOWTO (R_IA64_SEGREL32MSB, "SEGREL32MSB", 2, FALSE, TRUE),
430 IA64_HOWTO (R_IA64_SEGREL32LSB, "SEGREL32LSB", 2, FALSE, TRUE),
431 IA64_HOWTO (R_IA64_SEGREL64MSB, "SEGREL64MSB", 4, FALSE, TRUE),
432 IA64_HOWTO (R_IA64_SEGREL64LSB, "SEGREL64LSB", 4, FALSE, TRUE),
434 IA64_HOWTO (R_IA64_SECREL32MSB, "SECREL32MSB", 2, FALSE, TRUE),
435 IA64_HOWTO (R_IA64_SECREL32LSB, "SECREL32LSB", 2, FALSE, TRUE),
436 IA64_HOWTO (R_IA64_SECREL64MSB, "SECREL64MSB", 4, FALSE, TRUE),
437 IA64_HOWTO (R_IA64_SECREL64LSB, "SECREL64LSB", 4, FALSE, TRUE),
439 IA64_HOWTO (R_IA64_REL32MSB, "REL32MSB", 2, FALSE, TRUE),
440 IA64_HOWTO (R_IA64_REL32LSB, "REL32LSB", 2, FALSE, TRUE),
441 IA64_HOWTO (R_IA64_REL64MSB, "REL64MSB", 4, FALSE, TRUE),
442 IA64_HOWTO (R_IA64_REL64LSB, "REL64LSB", 4, FALSE, TRUE),
444 IA64_HOWTO (R_IA64_LTV32MSB, "LTV32MSB", 2, FALSE, TRUE),
445 IA64_HOWTO (R_IA64_LTV32LSB, "LTV32LSB", 2, FALSE, TRUE),
446 IA64_HOWTO (R_IA64_LTV64MSB, "LTV64MSB", 4, FALSE, TRUE),
447 IA64_HOWTO (R_IA64_LTV64LSB, "LTV64LSB", 4, FALSE, TRUE),
449 IA64_HOWTO (R_IA64_PCREL21BI, "PCREL21BI", 0, TRUE, TRUE),
450 IA64_HOWTO (R_IA64_PCREL22, "PCREL22", 0, TRUE, TRUE),
451 IA64_HOWTO (R_IA64_PCREL64I, "PCREL64I", 0, TRUE, TRUE),
453 IA64_HOWTO (R_IA64_IPLTMSB, "IPLTMSB", 4, FALSE, TRUE),
454 IA64_HOWTO (R_IA64_IPLTLSB, "IPLTLSB", 4, FALSE, TRUE),
455 IA64_HOWTO (R_IA64_COPY, "COPY", 4, FALSE, TRUE),
456 IA64_HOWTO (R_IA64_LTOFF22X, "LTOFF22X", 0, FALSE, TRUE),
457 IA64_HOWTO (R_IA64_LDXMOV, "LDXMOV", 0, FALSE, TRUE),
459 IA64_HOWTO (R_IA64_TPREL14, "TPREL14", 0, FALSE, FALSE),
460 IA64_HOWTO (R_IA64_TPREL22, "TPREL22", 0, FALSE, FALSE),
461 IA64_HOWTO (R_IA64_TPREL64I, "TPREL64I", 0, FALSE, FALSE),
462 IA64_HOWTO (R_IA64_TPREL64MSB, "TPREL64MSB", 4, FALSE, FALSE),
463 IA64_HOWTO (R_IA64_TPREL64LSB, "TPREL64LSB", 4, FALSE, FALSE),
464 IA64_HOWTO (R_IA64_LTOFF_TPREL22, "LTOFF_TPREL22", 0, FALSE, FALSE),
466 IA64_HOWTO (R_IA64_DTPMOD64MSB, "DTPMOD64MSB", 4, FALSE, FALSE),
467 IA64_HOWTO (R_IA64_DTPMOD64LSB, "DTPMOD64LSB", 4, FALSE, FALSE),
468 IA64_HOWTO (R_IA64_LTOFF_DTPMOD22, "LTOFF_DTPMOD22", 0, FALSE, FALSE),
470 IA64_HOWTO (R_IA64_DTPREL14, "DTPREL14", 0, FALSE, FALSE),
471 IA64_HOWTO (R_IA64_DTPREL22, "DTPREL22", 0, FALSE, FALSE),
472 IA64_HOWTO (R_IA64_DTPREL64I, "DTPREL64I", 0, FALSE, FALSE),
473 IA64_HOWTO (R_IA64_DTPREL32MSB, "DTPREL32MSB", 2, FALSE, FALSE),
474 IA64_HOWTO (R_IA64_DTPREL32LSB, "DTPREL32LSB", 2, FALSE, FALSE),
475 IA64_HOWTO (R_IA64_DTPREL64MSB, "DTPREL64MSB", 4, FALSE, FALSE),
476 IA64_HOWTO (R_IA64_DTPREL64LSB, "DTPREL64LSB", 4, FALSE, FALSE),
477 IA64_HOWTO (R_IA64_LTOFF_DTPREL22, "LTOFF_DTPREL22", 0, FALSE, FALSE),
480 static unsigned char elf_code_to_howto_index[R_IA64_MAX_RELOC_CODE + 1];
482 /* Given a BFD reloc type, return the matching HOWTO structure. */
484 static reloc_howto_type *
488 static int inited = 0;
495 memset (elf_code_to_howto_index, 0xff, sizeof (elf_code_to_howto_index));
496 for (i = 0; i < NELEMS (ia64_howto_table); ++i)
497 elf_code_to_howto_index[ia64_howto_table[i].type] = i;
500 if (rtype > R_IA64_MAX_RELOC_CODE)
502 i = elf_code_to_howto_index[rtype];
503 if (i >= NELEMS (ia64_howto_table))
505 return ia64_howto_table + i;
508 static reloc_howto_type*
509 elfNN_ia64_reloc_type_lookup (abfd, bfd_code)
510 bfd *abfd ATTRIBUTE_UNUSED;
511 bfd_reloc_code_real_type bfd_code;
517 case BFD_RELOC_NONE: rtype = R_IA64_NONE; break;
519 case BFD_RELOC_IA64_IMM14: rtype = R_IA64_IMM14; break;
520 case BFD_RELOC_IA64_IMM22: rtype = R_IA64_IMM22; break;
521 case BFD_RELOC_IA64_IMM64: rtype = R_IA64_IMM64; break;
523 case BFD_RELOC_IA64_DIR32MSB: rtype = R_IA64_DIR32MSB; break;
524 case BFD_RELOC_IA64_DIR32LSB: rtype = R_IA64_DIR32LSB; break;
525 case BFD_RELOC_IA64_DIR64MSB: rtype = R_IA64_DIR64MSB; break;
526 case BFD_RELOC_IA64_DIR64LSB: rtype = R_IA64_DIR64LSB; break;
528 case BFD_RELOC_IA64_GPREL22: rtype = R_IA64_GPREL22; break;
529 case BFD_RELOC_IA64_GPREL64I: rtype = R_IA64_GPREL64I; break;
530 case BFD_RELOC_IA64_GPREL32MSB: rtype = R_IA64_GPREL32MSB; break;
531 case BFD_RELOC_IA64_GPREL32LSB: rtype = R_IA64_GPREL32LSB; break;
532 case BFD_RELOC_IA64_GPREL64MSB: rtype = R_IA64_GPREL64MSB; break;
533 case BFD_RELOC_IA64_GPREL64LSB: rtype = R_IA64_GPREL64LSB; break;
535 case BFD_RELOC_IA64_LTOFF22: rtype = R_IA64_LTOFF22; break;
536 case BFD_RELOC_IA64_LTOFF64I: rtype = R_IA64_LTOFF64I; break;
538 case BFD_RELOC_IA64_PLTOFF22: rtype = R_IA64_PLTOFF22; break;
539 case BFD_RELOC_IA64_PLTOFF64I: rtype = R_IA64_PLTOFF64I; break;
540 case BFD_RELOC_IA64_PLTOFF64MSB: rtype = R_IA64_PLTOFF64MSB; break;
541 case BFD_RELOC_IA64_PLTOFF64LSB: rtype = R_IA64_PLTOFF64LSB; break;
542 case BFD_RELOC_IA64_FPTR64I: rtype = R_IA64_FPTR64I; break;
543 case BFD_RELOC_IA64_FPTR32MSB: rtype = R_IA64_FPTR32MSB; break;
544 case BFD_RELOC_IA64_FPTR32LSB: rtype = R_IA64_FPTR32LSB; break;
545 case BFD_RELOC_IA64_FPTR64MSB: rtype = R_IA64_FPTR64MSB; break;
546 case BFD_RELOC_IA64_FPTR64LSB: rtype = R_IA64_FPTR64LSB; break;
548 case BFD_RELOC_IA64_PCREL21B: rtype = R_IA64_PCREL21B; break;
549 case BFD_RELOC_IA64_PCREL21BI: rtype = R_IA64_PCREL21BI; break;
550 case BFD_RELOC_IA64_PCREL21M: rtype = R_IA64_PCREL21M; break;
551 case BFD_RELOC_IA64_PCREL21F: rtype = R_IA64_PCREL21F; break;
552 case BFD_RELOC_IA64_PCREL22: rtype = R_IA64_PCREL22; break;
553 case BFD_RELOC_IA64_PCREL60B: rtype = R_IA64_PCREL60B; break;
554 case BFD_RELOC_IA64_PCREL64I: rtype = R_IA64_PCREL64I; break;
555 case BFD_RELOC_IA64_PCREL32MSB: rtype = R_IA64_PCREL32MSB; break;
556 case BFD_RELOC_IA64_PCREL32LSB: rtype = R_IA64_PCREL32LSB; break;
557 case BFD_RELOC_IA64_PCREL64MSB: rtype = R_IA64_PCREL64MSB; break;
558 case BFD_RELOC_IA64_PCREL64LSB: rtype = R_IA64_PCREL64LSB; break;
560 case BFD_RELOC_IA64_LTOFF_FPTR22: rtype = R_IA64_LTOFF_FPTR22; break;
561 case BFD_RELOC_IA64_LTOFF_FPTR64I: rtype = R_IA64_LTOFF_FPTR64I; break;
562 case BFD_RELOC_IA64_LTOFF_FPTR32MSB: rtype = R_IA64_LTOFF_FPTR32MSB; break;
563 case BFD_RELOC_IA64_LTOFF_FPTR32LSB: rtype = R_IA64_LTOFF_FPTR32LSB; break;
564 case BFD_RELOC_IA64_LTOFF_FPTR64MSB: rtype = R_IA64_LTOFF_FPTR64MSB; break;
565 case BFD_RELOC_IA64_LTOFF_FPTR64LSB: rtype = R_IA64_LTOFF_FPTR64LSB; break;
567 case BFD_RELOC_IA64_SEGREL32MSB: rtype = R_IA64_SEGREL32MSB; break;
568 case BFD_RELOC_IA64_SEGREL32LSB: rtype = R_IA64_SEGREL32LSB; break;
569 case BFD_RELOC_IA64_SEGREL64MSB: rtype = R_IA64_SEGREL64MSB; break;
570 case BFD_RELOC_IA64_SEGREL64LSB: rtype = R_IA64_SEGREL64LSB; break;
572 case BFD_RELOC_IA64_SECREL32MSB: rtype = R_IA64_SECREL32MSB; break;
573 case BFD_RELOC_IA64_SECREL32LSB: rtype = R_IA64_SECREL32LSB; break;
574 case BFD_RELOC_IA64_SECREL64MSB: rtype = R_IA64_SECREL64MSB; break;
575 case BFD_RELOC_IA64_SECREL64LSB: rtype = R_IA64_SECREL64LSB; break;
577 case BFD_RELOC_IA64_REL32MSB: rtype = R_IA64_REL32MSB; break;
578 case BFD_RELOC_IA64_REL32LSB: rtype = R_IA64_REL32LSB; break;
579 case BFD_RELOC_IA64_REL64MSB: rtype = R_IA64_REL64MSB; break;
580 case BFD_RELOC_IA64_REL64LSB: rtype = R_IA64_REL64LSB; break;
582 case BFD_RELOC_IA64_LTV32MSB: rtype = R_IA64_LTV32MSB; break;
583 case BFD_RELOC_IA64_LTV32LSB: rtype = R_IA64_LTV32LSB; break;
584 case BFD_RELOC_IA64_LTV64MSB: rtype = R_IA64_LTV64MSB; break;
585 case BFD_RELOC_IA64_LTV64LSB: rtype = R_IA64_LTV64LSB; break;
587 case BFD_RELOC_IA64_IPLTMSB: rtype = R_IA64_IPLTMSB; break;
588 case BFD_RELOC_IA64_IPLTLSB: rtype = R_IA64_IPLTLSB; break;
589 case BFD_RELOC_IA64_COPY: rtype = R_IA64_COPY; break;
590 case BFD_RELOC_IA64_LTOFF22X: rtype = R_IA64_LTOFF22X; break;
591 case BFD_RELOC_IA64_LDXMOV: rtype = R_IA64_LDXMOV; break;
593 case BFD_RELOC_IA64_TPREL14: rtype = R_IA64_TPREL14; break;
594 case BFD_RELOC_IA64_TPREL22: rtype = R_IA64_TPREL22; break;
595 case BFD_RELOC_IA64_TPREL64I: rtype = R_IA64_TPREL64I; break;
596 case BFD_RELOC_IA64_TPREL64MSB: rtype = R_IA64_TPREL64MSB; break;
597 case BFD_RELOC_IA64_TPREL64LSB: rtype = R_IA64_TPREL64LSB; break;
598 case BFD_RELOC_IA64_LTOFF_TPREL22: rtype = R_IA64_LTOFF_TPREL22; break;
600 case BFD_RELOC_IA64_DTPMOD64MSB: rtype = R_IA64_DTPMOD64MSB; break;
601 case BFD_RELOC_IA64_DTPMOD64LSB: rtype = R_IA64_DTPMOD64LSB; break;
602 case BFD_RELOC_IA64_LTOFF_DTPMOD22: rtype = R_IA64_LTOFF_DTPMOD22; break;
604 case BFD_RELOC_IA64_DTPREL14: rtype = R_IA64_DTPREL14; break;
605 case BFD_RELOC_IA64_DTPREL22: rtype = R_IA64_DTPREL22; break;
606 case BFD_RELOC_IA64_DTPREL64I: rtype = R_IA64_DTPREL64I; break;
607 case BFD_RELOC_IA64_DTPREL32MSB: rtype = R_IA64_DTPREL32MSB; break;
608 case BFD_RELOC_IA64_DTPREL32LSB: rtype = R_IA64_DTPREL32LSB; break;
609 case BFD_RELOC_IA64_DTPREL64MSB: rtype = R_IA64_DTPREL64MSB; break;
610 case BFD_RELOC_IA64_DTPREL64LSB: rtype = R_IA64_DTPREL64LSB; break;
611 case BFD_RELOC_IA64_LTOFF_DTPREL22: rtype = R_IA64_LTOFF_DTPREL22; break;
615 return lookup_howto (rtype);
618 /* Given a ELF reloc, return the matching HOWTO structure. */
621 elfNN_ia64_info_to_howto (abfd, bfd_reloc, elf_reloc)
622 bfd *abfd ATTRIBUTE_UNUSED;
624 Elf_Internal_Rela *elf_reloc;
627 = lookup_howto ((unsigned int) ELFNN_R_TYPE (elf_reloc->r_info));
630 #define PLT_HEADER_SIZE (3 * 16)
631 #define PLT_MIN_ENTRY_SIZE (1 * 16)
632 #define PLT_FULL_ENTRY_SIZE (2 * 16)
633 #define PLT_RESERVED_WORDS 3
635 static const bfd_byte plt_header[PLT_HEADER_SIZE] =
637 0x0b, 0x10, 0x00, 0x1c, 0x00, 0x21, /* [MMI] mov r2=r14;; */
638 0xe0, 0x00, 0x08, 0x00, 0x48, 0x00, /* addl r14=0,r2 */
639 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
640 0x0b, 0x80, 0x20, 0x1c, 0x18, 0x14, /* [MMI] ld8 r16=[r14],8;; */
641 0x10, 0x41, 0x38, 0x30, 0x28, 0x00, /* ld8 r17=[r14],8 */
642 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
643 0x11, 0x08, 0x00, 0x1c, 0x18, 0x10, /* [MIB] ld8 r1=[r14] */
644 0x60, 0x88, 0x04, 0x80, 0x03, 0x00, /* mov b6=r17 */
645 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
648 static const bfd_byte plt_min_entry[PLT_MIN_ENTRY_SIZE] =
650 0x11, 0x78, 0x00, 0x00, 0x00, 0x24, /* [MIB] mov r15=0 */
651 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, /* nop.i 0x0 */
652 0x00, 0x00, 0x00, 0x40 /* br.few 0 <PLT0>;; */
655 static const bfd_byte plt_full_entry[PLT_FULL_ENTRY_SIZE] =
657 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
658 0x00, 0x41, 0x3c, 0x70, 0x29, 0xc0, /* ld8.acq r16=[r15],8*/
659 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
660 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
661 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
662 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
665 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
667 static const bfd_byte oor_brl[16] =
669 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
670 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;; */
671 0x00, 0x00, 0x00, 0xc0
674 static const bfd_byte oor_ip[48] =
676 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
677 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, /* movl r15=0 */
678 0x01, 0x00, 0x00, 0x60,
679 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MII] nop.m 0 */
680 0x00, 0x01, 0x00, 0x60, 0x00, 0x00, /* mov r16=ip;; */
681 0xf2, 0x80, 0x00, 0x80, /* add r16=r15,r16;; */
682 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MIB] nop.m 0 */
683 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
684 0x60, 0x00, 0x80, 0x00 /* br b6;; */
687 static size_t oor_branch_size = sizeof (oor_brl);
690 bfd_elfNN_ia64_after_parse (int itanium)
692 oor_branch_size = itanium ? sizeof (oor_ip) : sizeof (oor_brl);
695 #define BTYPE_SHIFT 6
702 #define OPCODE_SHIFT 37
704 #define OPCODE_BITS (0xfLL << OPCODE_SHIFT)
705 #define X6_BITS (0x3fLL << X6_SHIFT)
706 #define X4_BITS (0xfLL << X4_SHIFT)
707 #define X3_BITS (0x7LL << X3_SHIFT)
708 #define X2_BITS (0x3LL << X2_SHIFT)
709 #define X_BITS (0x1LL << X_SHIFT)
710 #define Y_BITS (0x1LL << Y_SHIFT)
711 #define BTYPE_BITS (0x7LL << BTYPE_SHIFT)
712 #define PREDICATE_BITS (0x3fLL)
714 #define IS_NOP_B(i) \
715 (((i) & (OPCODE_BITS | X6_BITS)) == (2LL << OPCODE_SHIFT))
716 #define IS_NOP_F(i) \
717 (((i) & (OPCODE_BITS | X_BITS | X6_BITS | Y_BITS)) \
718 == (0x1LL << X6_SHIFT))
719 #define IS_NOP_I(i) \
720 (((i) & (OPCODE_BITS | X3_BITS | X6_BITS | Y_BITS)) \
721 == (0x1LL << X6_SHIFT))
722 #define IS_NOP_M(i) \
723 (((i) & (OPCODE_BITS | X3_BITS | X2_BITS | X4_BITS | Y_BITS)) \
724 == (0x1LL << X4_SHIFT))
725 #define IS_BR_COND(i) \
726 (((i) & (OPCODE_BITS | BTYPE_BITS)) == (0x4LL << OPCODE_SHIFT))
727 #define IS_BR_CALL(i) \
728 (((i) & OPCODE_BITS) == (0x5LL << OPCODE_SHIFT))
731 elfNN_ia64_relax_br (bfd_byte *contents, bfd_vma off)
733 unsigned int template, mlx;
734 bfd_vma t0, t1, s0, s1, s2, br_code;
738 hit_addr = (bfd_byte *) (contents + off);
739 br_slot = (long) hit_addr & 0x3;
741 t0 = bfd_getl64 (hit_addr + 0);
742 t1 = bfd_getl64 (hit_addr + 8);
744 /* Check if we can turn br into brl. A label is always at the start
745 of the bundle. Even if there are predicates on NOPs, we still
746 perform this optimization. */
747 template = t0 & 0x1e;
748 s0 = (t0 >> 5) & 0x1ffffffffffLL;
749 s1 = ((t0 >> 46) | (t1 << 18)) & 0x1ffffffffffLL;
750 s2 = (t1 >> 23) & 0x1ffffffffffLL;
754 /* Check if slot 1 and slot 2 are NOPs. Possible template is
755 BBB. We only need to check nop.b. */
756 if (!(IS_NOP_B (s1) && IS_NOP_B (s2)))
761 /* Check if slot 2 is NOP. Possible templates are MBB and BBB.
762 For BBB, slot 0 also has to be nop.b. */
763 if (!((template == 0x12 /* MBB */
765 || (template == 0x16 /* BBB */
772 /* Check if slot 1 is NOP. Possible templates are MIB, MBB, BBB,
773 MMB and MFB. For BBB, slot 0 also has to be nop.b. */
774 if (!((template == 0x10 /* MIB */
776 || (template == 0x12 /* MBB */
778 || (template == 0x16 /* BBB */
781 || (template == 0x18 /* MMB */
783 || (template == 0x1c /* MFB */
789 /* It should never happen. */
793 /* We can turn br.cond/br.call into brl.cond/brl.call. */
794 if (!(IS_BR_COND (br_code) || IS_BR_CALL (br_code)))
797 /* Turn br into brl by setting bit 40. */
798 br_code |= 0x1LL << 40;
800 /* Turn the old bundle into a MLX bundle with the same stop-bit
807 if (template == 0x16)
809 /* For BBB, we need to put nop.m in slot 0. We keep the original
810 predicate only if slot 0 isn't br. */
814 t0 &= PREDICATE_BITS << 5;
815 t0 |= 0x1LL << (X4_SHIFT + 5);
819 /* Keep the original instruction in slot 0. */
820 t0 &= 0x1ffffffffffLL << 5;
825 /* Put brl in slot 1. */
828 bfd_putl64 (t0, hit_addr);
829 bfd_putl64 (t1, hit_addr + 8);
834 elfNN_ia64_relax_brl (bfd_byte *contents, bfd_vma off)
838 bfd_vma t0, t1, i0, i1, i2;
840 hit_addr = (bfd_byte *) (contents + off);
841 hit_addr -= (long) hit_addr & 0x3;
842 t0 = bfd_getl64 (hit_addr);
843 t1 = bfd_getl64 (hit_addr + 8);
845 /* Keep the instruction in slot 0. */
846 i0 = (t0 >> 5) & 0x1ffffffffffLL;
847 /* Use nop.b for slot 1. */
849 /* For slot 2, turn brl into br by masking out bit 40. */
850 i2 = (t1 >> 23) & 0x0ffffffffffLL;
852 /* Turn a MLX bundle into a MBB bundle with the same stop-bit
858 t0 = (i1 << 46) | (i0 << 5) | template;
859 t1 = (i2 << 23) | (i1 >> 18);
861 bfd_putl64 (t0, hit_addr);
862 bfd_putl64 (t1, hit_addr + 8);
865 /* Rename some of the generic section flags to better document how they
867 #define skip_relax_pass_0 need_finalize_relax
868 #define skip_relax_pass_1 has_gp_reloc
871 /* These functions do relaxation for IA-64 ELF. */
874 elfNN_ia64_relax_section (abfd, sec, link_info, again)
877 struct bfd_link_info *link_info;
882 struct one_fixup *next;
888 Elf_Internal_Shdr *symtab_hdr;
889 Elf_Internal_Rela *internal_relocs;
890 Elf_Internal_Rela *irel, *irelend;
892 Elf_Internal_Sym *isymbuf = NULL;
893 struct elfNN_ia64_link_hash_table *ia64_info;
894 struct one_fixup *fixups = NULL;
895 bfd_boolean changed_contents = FALSE;
896 bfd_boolean changed_relocs = FALSE;
897 bfd_boolean changed_got = FALSE;
898 bfd_boolean skip_relax_pass_0 = TRUE;
899 bfd_boolean skip_relax_pass_1 = TRUE;
902 /* Assume we're not going to change any sizes, and we'll only need
906 /* Don't even try to relax for non-ELF outputs. */
907 if (!is_elf_hash_table (link_info->hash))
910 /* Nothing to do if there are no relocations or there is no need for
912 if ((sec->flags & SEC_RELOC) == 0
913 || sec->reloc_count == 0
914 || (link_info->relax_pass == 0 && sec->skip_relax_pass_0)
915 || (link_info->relax_pass == 1 && sec->skip_relax_pass_1))
918 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
920 /* Load the relocations for this section. */
921 internal_relocs = (_bfd_elf_link_read_relocs
922 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
923 link_info->keep_memory));
924 if (internal_relocs == NULL)
927 ia64_info = elfNN_ia64_hash_table (link_info);
928 irelend = internal_relocs + sec->reloc_count;
930 /* Get the section contents. */
931 if (elf_section_data (sec)->this_hdr.contents != NULL)
932 contents = elf_section_data (sec)->this_hdr.contents;
935 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
939 for (irel = internal_relocs; irel < irelend; irel++)
941 unsigned long r_type = ELFNN_R_TYPE (irel->r_info);
942 bfd_vma symaddr, reladdr, trampoff, toff, roff;
946 bfd_boolean is_branch;
947 struct elfNN_ia64_dyn_sym_info *dyn_i;
952 case R_IA64_PCREL21B:
953 case R_IA64_PCREL21BI:
954 case R_IA64_PCREL21M:
955 case R_IA64_PCREL21F:
956 /* In pass 1, all br relaxations are done. We can skip it. */
957 if (link_info->relax_pass == 1)
959 skip_relax_pass_0 = FALSE;
963 case R_IA64_PCREL60B:
964 /* We can't optimize brl to br in pass 0 since br relaxations
965 will increase the code size. Defer it to pass 1. */
966 if (link_info->relax_pass == 0)
968 skip_relax_pass_1 = FALSE;
974 case R_IA64_LTOFF22X:
976 /* We can't relax ldx/mov in pass 0 since br relaxations will
977 increase the code size. Defer it to pass 1. */
978 if (link_info->relax_pass == 0)
980 skip_relax_pass_1 = FALSE;
990 /* Get the value of the symbol referred to by the reloc. */
991 if (ELFNN_R_SYM (irel->r_info) < symtab_hdr->sh_info)
993 /* A local symbol. */
994 Elf_Internal_Sym *isym;
996 /* Read this BFD's local symbols. */
999 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1000 if (isymbuf == NULL)
1001 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1002 symtab_hdr->sh_info, 0,
1008 isym = isymbuf + ELFNN_R_SYM (irel->r_info);
1009 if (isym->st_shndx == SHN_UNDEF)
1010 continue; /* We can't do anything with undefined symbols. */
1011 else if (isym->st_shndx == SHN_ABS)
1012 tsec = bfd_abs_section_ptr;
1013 else if (isym->st_shndx == SHN_COMMON)
1014 tsec = bfd_com_section_ptr;
1015 else if (isym->st_shndx == SHN_IA_64_ANSI_COMMON)
1016 tsec = bfd_com_section_ptr;
1018 tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1020 toff = isym->st_value;
1021 dyn_i = get_dyn_sym_info (ia64_info, NULL, abfd, irel, FALSE);
1022 symtype = ELF_ST_TYPE (isym->st_info);
1027 struct elf_link_hash_entry *h;
1029 indx = ELFNN_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1030 h = elf_sym_hashes (abfd)[indx];
1031 BFD_ASSERT (h != NULL);
1033 while (h->root.type == bfd_link_hash_indirect
1034 || h->root.type == bfd_link_hash_warning)
1035 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1037 dyn_i = get_dyn_sym_info (ia64_info, h, abfd, irel, FALSE);
1039 /* For branches to dynamic symbols, we're interested instead
1040 in a branch to the PLT entry. */
1041 if (is_branch && dyn_i && dyn_i->want_plt2)
1043 /* Internal branches shouldn't be sent to the PLT.
1044 Leave this for now and we'll give an error later. */
1045 if (r_type != R_IA64_PCREL21B)
1048 tsec = ia64_info->plt_sec;
1049 toff = dyn_i->plt2_offset;
1050 BFD_ASSERT (irel->r_addend == 0);
1053 /* Can't do anything else with dynamic symbols. */
1054 else if (elfNN_ia64_dynamic_symbol_p (h, link_info, r_type))
1059 /* We can't do anything with undefined symbols. */
1060 if (h->root.type == bfd_link_hash_undefined
1061 || h->root.type == bfd_link_hash_undefweak)
1064 tsec = h->root.u.def.section;
1065 toff = h->root.u.def.value;
1071 if (tsec->sec_info_type == ELF_INFO_TYPE_MERGE)
1073 /* At this stage in linking, no SEC_MERGE symbol has been
1074 adjusted, so all references to such symbols need to be
1075 passed through _bfd_merged_section_offset. (Later, in
1076 relocate_section, all SEC_MERGE symbols *except* for
1077 section symbols have been adjusted.)
1079 gas may reduce relocations against symbols in SEC_MERGE
1080 sections to a relocation against the section symbol when
1081 the original addend was zero. When the reloc is against
1082 a section symbol we should include the addend in the
1083 offset passed to _bfd_merged_section_offset, since the
1084 location of interest is the original symbol. On the
1085 other hand, an access to "sym+addend" where "sym" is not
1086 a section symbol should not include the addend; Such an
1087 access is presumed to be an offset from "sym"; The
1088 location of interest is just "sym". */
1089 if (symtype == STT_SECTION)
1090 toff += irel->r_addend;
1092 toff = _bfd_merged_section_offset (abfd, &tsec,
1093 elf_section_data (tsec)->sec_info,
1096 if (symtype != STT_SECTION)
1097 toff += irel->r_addend;
1100 toff += irel->r_addend;
1102 symaddr = tsec->output_section->vma + tsec->output_offset + toff;
1104 roff = irel->r_offset;
1108 bfd_signed_vma offset;
1110 reladdr = (sec->output_section->vma
1111 + sec->output_offset
1112 + roff) & (bfd_vma) -4;
1114 /* If the branch is in range, no need to do anything. */
1115 if ((bfd_signed_vma) (symaddr - reladdr) >= -0x1000000
1116 && (bfd_signed_vma) (symaddr - reladdr) <= 0x0FFFFF0)
1118 /* If the 60-bit branch is in 21-bit range, optimize it. */
1119 if (r_type == R_IA64_PCREL60B)
1121 elfNN_ia64_relax_brl (contents, roff);
1124 = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
1127 /* If the original relocation offset points to slot
1128 1, change it to slot 2. */
1129 if ((irel->r_offset & 3) == 1)
1130 irel->r_offset += 1;
1135 else if (r_type == R_IA64_PCREL60B)
1137 else if (elfNN_ia64_relax_br (contents, roff))
1140 = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
1143 /* Make the relocation offset point to slot 1. */
1144 irel->r_offset = (irel->r_offset & ~((bfd_vma) 0x3)) + 1;
1148 /* We can't put a trampoline in a .init/.fini section. Issue
1150 if (strcmp (sec->output_section->name, ".init") == 0
1151 || strcmp (sec->output_section->name, ".fini") == 0)
1153 (*_bfd_error_handler)
1154 (_("%B: Can't relax br at 0x%lx in section `%A'. Please use brl or indirect branch."),
1155 sec->owner, sec, (unsigned long) roff);
1156 bfd_set_error (bfd_error_bad_value);
1160 /* If the branch and target are in the same section, you've
1161 got one honking big section and we can't help you unless
1162 you are branching backwards. You'll get an error message
1164 if (tsec == sec && toff > roff)
1167 /* Look for an existing fixup to this address. */
1168 for (f = fixups; f ; f = f->next)
1169 if (f->tsec == tsec && f->toff == toff)
1174 /* Two alternatives: If it's a branch to a PLT entry, we can
1175 make a copy of the FULL_PLT entry. Otherwise, we'll have
1176 to use a `brl' insn to get where we're going. */
1180 if (tsec == ia64_info->plt_sec)
1181 size = sizeof (plt_full_entry);
1183 size = oor_branch_size;
1185 /* Resize the current section to make room for the new branch. */
1186 trampoff = (sec->size + 15) & (bfd_vma) -16;
1188 /* If trampoline is out of range, there is nothing we
1190 offset = trampoff - (roff & (bfd_vma) -4);
1191 if (offset < -0x1000000 || offset > 0x0FFFFF0)
1194 amt = trampoff + size;
1195 contents = (bfd_byte *) bfd_realloc (contents, amt);
1196 if (contents == NULL)
1200 if (tsec == ia64_info->plt_sec)
1202 memcpy (contents + trampoff, plt_full_entry, size);
1204 /* Hijack the old relocation for use as the PLTOFF reloc. */
1205 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
1207 irel->r_offset = trampoff;
1211 if (size == sizeof (oor_ip))
1213 memcpy (contents + trampoff, oor_ip, size);
1214 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
1216 irel->r_addend -= 16;
1217 irel->r_offset = trampoff + 2;
1221 memcpy (contents + trampoff, oor_brl, size);
1222 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
1224 irel->r_offset = trampoff + 2;
1229 /* Record the fixup so we don't do it again this section. */
1230 f = (struct one_fixup *)
1231 bfd_malloc ((bfd_size_type) sizeof (*f));
1235 f->trampoff = trampoff;
1240 /* If trampoline is out of range, there is nothing we
1242 offset = f->trampoff - (roff & (bfd_vma) -4);
1243 if (offset < -0x1000000 || offset > 0x0FFFFF0)
1246 /* Nop out the reloc, since we're finalizing things here. */
1247 irel->r_info = ELFNN_R_INFO (0, R_IA64_NONE);
1250 /* Fix up the existing branch to hit the trampoline. */
1251 if (elfNN_ia64_install_value (contents + roff, offset, r_type)
1255 changed_contents = TRUE;
1256 changed_relocs = TRUE;
1263 bfd *obfd = sec->output_section->owner;
1264 gp = _bfd_get_gp_value (obfd);
1267 if (!elfNN_ia64_choose_gp (obfd, link_info))
1269 gp = _bfd_get_gp_value (obfd);
1273 /* If the data is out of range, do nothing. */
1274 if ((bfd_signed_vma) (symaddr - gp) >= 0x200000
1275 ||(bfd_signed_vma) (symaddr - gp) < -0x200000)
1278 if (r_type == R_IA64_LTOFF22X)
1280 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
1282 changed_relocs = TRUE;
1283 if (dyn_i->want_gotx)
1285 dyn_i->want_gotx = 0;
1286 changed_got |= !dyn_i->want_got;
1291 elfNN_ia64_relax_ldxmov (contents, roff);
1292 irel->r_info = ELFNN_R_INFO (0, R_IA64_NONE);
1293 changed_contents = TRUE;
1294 changed_relocs = TRUE;
1299 /* ??? If we created fixups, this may push the code segment large
1300 enough that the data segment moves, which will change the GP.
1301 Reset the GP so that we re-calculate next round. We need to
1302 do this at the _beginning_ of the next round; now will not do. */
1304 /* Clean up and go home. */
1307 struct one_fixup *f = fixups;
1308 fixups = fixups->next;
1313 && symtab_hdr->contents != (unsigned char *) isymbuf)
1315 if (! link_info->keep_memory)
1319 /* Cache the symbols for elf_link_input_bfd. */
1320 symtab_hdr->contents = (unsigned char *) isymbuf;
1324 if (contents != NULL
1325 && elf_section_data (sec)->this_hdr.contents != contents)
1327 if (!changed_contents && !link_info->keep_memory)
1331 /* Cache the section contents for elf_link_input_bfd. */
1332 elf_section_data (sec)->this_hdr.contents = contents;
1336 if (elf_section_data (sec)->relocs != internal_relocs)
1338 if (!changed_relocs)
1339 free (internal_relocs);
1341 elf_section_data (sec)->relocs = internal_relocs;
1346 struct elfNN_ia64_allocate_data data;
1347 data.info = link_info;
1349 ia64_info->self_dtpmod_offset = (bfd_vma) -1;
1351 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data);
1352 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data);
1353 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data);
1354 ia64_info->got_sec->size = data.ofs;
1356 if (ia64_info->root.dynamic_sections_created
1357 && ia64_info->rel_got_sec != NULL)
1359 /* Resize .rela.got. */
1360 ia64_info->rel_got_sec->size = 0;
1361 if (link_info->shared
1362 && ia64_info->self_dtpmod_offset != (bfd_vma) -1)
1363 ia64_info->rel_got_sec->size += sizeof (ElfNN_External_Rela);
1364 data.only_got = TRUE;
1365 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries,
1370 if (link_info->relax_pass == 0)
1372 /* Pass 0 is only needed to relax br. */
1373 sec->skip_relax_pass_0 = skip_relax_pass_0;
1374 sec->skip_relax_pass_1 = skip_relax_pass_1;
1377 *again = changed_contents || changed_relocs;
1381 if (isymbuf != NULL && (unsigned char *) isymbuf != symtab_hdr->contents)
1383 if (contents != NULL
1384 && elf_section_data (sec)->this_hdr.contents != contents)
1386 if (internal_relocs != NULL
1387 && elf_section_data (sec)->relocs != internal_relocs)
1388 free (internal_relocs);
1391 #undef skip_relax_pass_0
1392 #undef skip_relax_pass_1
1395 elfNN_ia64_relax_ldxmov (contents, off)
1400 bfd_vma dword, insn;
1402 switch ((int)off & 0x3)
1404 case 0: shift = 5; break;
1405 case 1: shift = 14; off += 3; break;
1406 case 2: shift = 23; off += 6; break;
1411 dword = bfd_getl64 (contents + off);
1412 insn = (dword >> shift) & 0x1ffffffffffLL;
1414 r1 = (insn >> 6) & 127;
1415 r3 = (insn >> 20) & 127;
1417 insn = 0x8000000; /* nop */
1419 insn = (insn & 0x7f01fff) | 0x10800000000LL; /* (qp) mov r1 = r3 */
1421 dword &= ~(0x1ffffffffffLL << shift);
1422 dword |= (insn << shift);
1423 bfd_putl64 (dword, contents + off);
1426 /* Return TRUE if NAME is an unwind table section name. */
1428 static inline bfd_boolean
1429 is_unwind_section_name (abfd, name)
1433 size_t len1, len2, len3;
1435 if (elfNN_ia64_hpux_vec (abfd->xvec)
1436 && !strcmp (name, ELF_STRING_ia64_unwind_hdr))
1439 len1 = sizeof (ELF_STRING_ia64_unwind) - 1;
1440 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
1441 len3 = sizeof (ELF_STRING_ia64_unwind_once) - 1;
1442 return ((strncmp (name, ELF_STRING_ia64_unwind, len1) == 0
1443 && strncmp (name, ELF_STRING_ia64_unwind_info, len2) != 0)
1444 || strncmp (name, ELF_STRING_ia64_unwind_once, len3) == 0);
1447 /* Handle an IA-64 specific section when reading an object file. This
1448 is called when bfd_section_from_shdr finds a section with an unknown
1452 elfNN_ia64_section_from_shdr (bfd *abfd,
1453 Elf_Internal_Shdr *hdr,
1459 /* There ought to be a place to keep ELF backend specific flags, but
1460 at the moment there isn't one. We just keep track of the
1461 sections by their name, instead. Fortunately, the ABI gives
1462 suggested names for all the MIPS specific sections, so we will
1463 probably get away with this. */
1464 switch (hdr->sh_type)
1466 case SHT_IA_64_UNWIND:
1467 case SHT_IA_64_HP_OPT_ANOT:
1471 if (strcmp (name, ELF_STRING_ia64_archext) != 0)
1479 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1481 newsect = hdr->bfd_section;
1486 /* Convert IA-64 specific section flags to bfd internal section flags. */
1488 /* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
1492 elfNN_ia64_section_flags (flags, hdr)
1494 const Elf_Internal_Shdr *hdr;
1496 if (hdr->sh_flags & SHF_IA_64_SHORT)
1497 *flags |= SEC_SMALL_DATA;
1502 /* Set the correct type for an IA-64 ELF section. We do this by the
1503 section name, which is a hack, but ought to work. */
1506 elfNN_ia64_fake_sections (abfd, hdr, sec)
1507 bfd *abfd ATTRIBUTE_UNUSED;
1508 Elf_Internal_Shdr *hdr;
1511 register const char *name;
1513 name = bfd_get_section_name (abfd, sec);
1515 if (is_unwind_section_name (abfd, name))
1517 /* We don't have the sections numbered at this point, so sh_info
1518 is set later, in elfNN_ia64_final_write_processing. */
1519 hdr->sh_type = SHT_IA_64_UNWIND;
1520 hdr->sh_flags |= SHF_LINK_ORDER;
1522 else if (strcmp (name, ELF_STRING_ia64_archext) == 0)
1523 hdr->sh_type = SHT_IA_64_EXT;
1524 else if (strcmp (name, ".HP.opt_annot") == 0)
1525 hdr->sh_type = SHT_IA_64_HP_OPT_ANOT;
1526 else if (strcmp (name, ".reloc") == 0)
1527 /* This is an ugly, but unfortunately necessary hack that is
1528 needed when producing EFI binaries on IA-64. It tells
1529 elf.c:elf_fake_sections() not to consider ".reloc" as a section
1530 containing ELF relocation info. We need this hack in order to
1531 be able to generate ELF binaries that can be translated into
1532 EFI applications (which are essentially COFF objects). Those
1533 files contain a COFF ".reloc" section inside an ELFNN object,
1534 which would normally cause BFD to segfault because it would
1535 attempt to interpret this section as containing relocation
1536 entries for section "oc". With this hack enabled, ".reloc"
1537 will be treated as a normal data section, which will avoid the
1538 segfault. However, you won't be able to create an ELFNN binary
1539 with a section named "oc" that needs relocations, but that's
1540 the kind of ugly side-effects you get when detecting section
1541 types based on their names... In practice, this limitation is
1542 unlikely to bite. */
1543 hdr->sh_type = SHT_PROGBITS;
1545 if (sec->flags & SEC_SMALL_DATA)
1546 hdr->sh_flags |= SHF_IA_64_SHORT;
1548 /* Some HP linkers look for the SHF_IA_64_HP_TLS flag instead of SHF_TLS. */
1550 if (elfNN_ia64_hpux_vec (abfd->xvec) && (sec->flags & SHF_TLS))
1551 hdr->sh_flags |= SHF_IA_64_HP_TLS;
1556 /* The final processing done just before writing out an IA-64 ELF
1560 elfNN_ia64_final_write_processing (abfd, linker)
1562 bfd_boolean linker ATTRIBUTE_UNUSED;
1564 Elf_Internal_Shdr *hdr;
1567 for (s = abfd->sections; s; s = s->next)
1569 hdr = &elf_section_data (s)->this_hdr;
1570 switch (hdr->sh_type)
1572 case SHT_IA_64_UNWIND:
1573 /* The IA-64 processor-specific ABI requires setting sh_link
1574 to the unwind section, whereas HP-UX requires sh_info to
1575 do so. For maximum compatibility, we'll set both for
1577 hdr->sh_info = hdr->sh_link;
1582 if (! elf_flags_init (abfd))
1584 unsigned long flags = 0;
1586 if (abfd->xvec->byteorder == BFD_ENDIAN_BIG)
1587 flags |= EF_IA_64_BE;
1588 if (bfd_get_mach (abfd) == bfd_mach_ia64_elf64)
1589 flags |= EF_IA_64_ABI64;
1591 elf_elfheader(abfd)->e_flags = flags;
1592 elf_flags_init (abfd) = TRUE;
1596 /* Hook called by the linker routine which adds symbols from an object
1597 file. We use it to put .comm items in .sbss, and not .bss. */
1600 elfNN_ia64_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1602 struct bfd_link_info *info;
1603 Elf_Internal_Sym *sym;
1604 const char **namep ATTRIBUTE_UNUSED;
1605 flagword *flagsp ATTRIBUTE_UNUSED;
1609 if (sym->st_shndx == SHN_COMMON
1610 && !info->relocatable
1611 && sym->st_size <= elf_gp_size (abfd))
1613 /* Common symbols less than or equal to -G nn bytes are
1614 automatically put into .sbss. */
1616 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1620 scomm = bfd_make_section_with_flags (abfd, ".scommon",
1623 | SEC_LINKER_CREATED));
1629 *valp = sym->st_size;
1635 /* Return the number of additional phdrs we will need. */
1638 elfNN_ia64_additional_program_headers (bfd *abfd,
1639 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1644 /* See if we need a PT_IA_64_ARCHEXT segment. */
1645 s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_archext);
1646 if (s && (s->flags & SEC_LOAD))
1649 /* Count how many PT_IA_64_UNWIND segments we need. */
1650 for (s = abfd->sections; s; s = s->next)
1651 if (is_unwind_section_name (abfd, s->name) && (s->flags & SEC_LOAD))
1658 elfNN_ia64_modify_segment_map (abfd, info)
1660 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1662 struct elf_segment_map *m, **pm;
1663 Elf_Internal_Shdr *hdr;
1666 /* If we need a PT_IA_64_ARCHEXT segment, it must come before
1667 all PT_LOAD segments. */
1668 s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_archext);
1669 if (s && (s->flags & SEC_LOAD))
1671 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
1672 if (m->p_type == PT_IA_64_ARCHEXT)
1676 m = ((struct elf_segment_map *)
1677 bfd_zalloc (abfd, (bfd_size_type) sizeof *m));
1681 m->p_type = PT_IA_64_ARCHEXT;
1685 /* We want to put it after the PHDR and INTERP segments. */
1686 pm = &elf_tdata (abfd)->segment_map;
1688 && ((*pm)->p_type == PT_PHDR
1689 || (*pm)->p_type == PT_INTERP))
1697 /* Install PT_IA_64_UNWIND segments, if needed. */
1698 for (s = abfd->sections; s; s = s->next)
1700 hdr = &elf_section_data (s)->this_hdr;
1701 if (hdr->sh_type != SHT_IA_64_UNWIND)
1704 if (s && (s->flags & SEC_LOAD))
1706 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
1707 if (m->p_type == PT_IA_64_UNWIND)
1711 /* Look through all sections in the unwind segment
1712 for a match since there may be multiple sections
1714 for (i = m->count - 1; i >= 0; --i)
1715 if (m->sections[i] == s)
1724 m = ((struct elf_segment_map *)
1725 bfd_zalloc (abfd, (bfd_size_type) sizeof *m));
1729 m->p_type = PT_IA_64_UNWIND;
1734 /* We want to put it last. */
1735 pm = &elf_tdata (abfd)->segment_map;
1743 /* Turn on PF_IA_64_NORECOV if needed. This involves traversing all of
1744 the input sections for each output section in the segment and testing
1745 for SHF_IA_64_NORECOV on each. */
1746 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
1747 if (m->p_type == PT_LOAD)
1750 for (i = m->count - 1; i >= 0; --i)
1752 struct bfd_link_order *order = m->sections[i]->map_head.link_order;
1755 if (order->type == bfd_indirect_link_order)
1757 asection *is = order->u.indirect.section;
1758 bfd_vma flags = elf_section_data(is)->this_hdr.sh_flags;
1759 if (flags & SHF_IA_64_NORECOV)
1761 m->p_flags |= PF_IA_64_NORECOV;
1765 order = order->next;
1774 /* According to the Tahoe assembler spec, all labels starting with a
1778 elfNN_ia64_is_local_label_name (abfd, name)
1779 bfd *abfd ATTRIBUTE_UNUSED;
1782 return name[0] == '.';
1785 /* Should we do dynamic things to this symbol? */
1788 elfNN_ia64_dynamic_symbol_p (h, info, r_type)
1789 struct elf_link_hash_entry *h;
1790 struct bfd_link_info *info;
1793 bfd_boolean ignore_protected
1794 = ((r_type & 0xf8) == 0x40 /* FPTR relocs */
1795 || (r_type & 0xf8) == 0x50); /* LTOFF_FPTR relocs */
1797 return _bfd_elf_dynamic_symbol_p (h, info, ignore_protected);
1800 static struct bfd_hash_entry*
1801 elfNN_ia64_new_elf_hash_entry (entry, table, string)
1802 struct bfd_hash_entry *entry;
1803 struct bfd_hash_table *table;
1806 struct elfNN_ia64_link_hash_entry *ret;
1807 ret = (struct elfNN_ia64_link_hash_entry *) entry;
1809 /* Allocate the structure if it has not already been allocated by a
1812 ret = bfd_hash_allocate (table, sizeof (*ret));
1817 /* Call the allocation method of the superclass. */
1818 ret = ((struct elfNN_ia64_link_hash_entry *)
1819 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1824 ret->sorted_count = 0;
1826 return (struct bfd_hash_entry *) ret;
1830 elfNN_ia64_hash_copy_indirect (info, xdir, xind)
1831 struct bfd_link_info *info;
1832 struct elf_link_hash_entry *xdir, *xind;
1834 struct elfNN_ia64_link_hash_entry *dir, *ind;
1836 dir = (struct elfNN_ia64_link_hash_entry *) xdir;
1837 ind = (struct elfNN_ia64_link_hash_entry *) xind;
1839 /* Copy down any references that we may have already seen to the
1840 symbol which just became indirect. */
1842 dir->root.ref_dynamic |= ind->root.ref_dynamic;
1843 dir->root.ref_regular |= ind->root.ref_regular;
1844 dir->root.ref_regular_nonweak |= ind->root.ref_regular_nonweak;
1845 dir->root.needs_plt |= ind->root.needs_plt;
1847 if (ind->root.root.type != bfd_link_hash_indirect)
1850 /* Copy over the got and plt data. This would have been done
1853 if (ind->info != NULL)
1855 struct elfNN_ia64_dyn_sym_info *dyn_i;
1861 dir->info = ind->info;
1862 dir->count = ind->count;
1863 dir->sorted_count = ind->sorted_count;
1864 dir->size = ind->size;
1868 ind->sorted_count = 0;
1871 /* Fix up the dyn_sym_info pointers to the global symbol. */
1872 for (count = dir->count, dyn_i = dir->info;
1875 dyn_i->h = &dir->root;
1878 /* Copy over the dynindx. */
1880 if (ind->root.dynindx != -1)
1882 if (dir->root.dynindx != -1)
1883 _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1884 dir->root.dynstr_index);
1885 dir->root.dynindx = ind->root.dynindx;
1886 dir->root.dynstr_index = ind->root.dynstr_index;
1887 ind->root.dynindx = -1;
1888 ind->root.dynstr_index = 0;
1893 elfNN_ia64_hash_hide_symbol (info, xh, force_local)
1894 struct bfd_link_info *info;
1895 struct elf_link_hash_entry *xh;
1896 bfd_boolean force_local;
1898 struct elfNN_ia64_link_hash_entry *h;
1899 struct elfNN_ia64_dyn_sym_info *dyn_i;
1902 h = (struct elfNN_ia64_link_hash_entry *)xh;
1904 _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local);
1906 for (count = h->count, dyn_i = h->info;
1910 dyn_i->want_plt2 = 0;
1911 dyn_i->want_plt = 0;
1915 /* Compute a hash of a local hash entry. */
1918 elfNN_ia64_local_htab_hash (ptr)
1921 struct elfNN_ia64_local_hash_entry *entry
1922 = (struct elfNN_ia64_local_hash_entry *) ptr;
1924 return (((entry->id & 0xff) << 24) | ((entry->id & 0xff00) << 8))
1925 ^ entry->r_sym ^ (entry->id >> 16);
1928 /* Compare local hash entries. */
1931 elfNN_ia64_local_htab_eq (ptr1, ptr2)
1932 const void *ptr1, *ptr2;
1934 struct elfNN_ia64_local_hash_entry *entry1
1935 = (struct elfNN_ia64_local_hash_entry *) ptr1;
1936 struct elfNN_ia64_local_hash_entry *entry2
1937 = (struct elfNN_ia64_local_hash_entry *) ptr2;
1939 return entry1->id == entry2->id && entry1->r_sym == entry2->r_sym;
1942 /* Create the derived linker hash table. The IA-64 ELF port uses this
1943 derived hash table to keep information specific to the IA-64 ElF
1944 linker (without using static variables). */
1946 static struct bfd_link_hash_table*
1947 elfNN_ia64_hash_table_create (abfd)
1950 struct elfNN_ia64_link_hash_table *ret;
1952 ret = bfd_zmalloc ((bfd_size_type) sizeof (*ret));
1956 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
1957 elfNN_ia64_new_elf_hash_entry,
1958 sizeof (struct elfNN_ia64_link_hash_entry)))
1964 ret->loc_hash_table = htab_try_create (1024, elfNN_ia64_local_htab_hash,
1965 elfNN_ia64_local_htab_eq, NULL);
1966 ret->loc_hash_memory = objalloc_create ();
1967 if (!ret->loc_hash_table || !ret->loc_hash_memory)
1973 return &ret->root.root;
1976 /* Free the global elfNN_ia64_dyn_sym_info array. */
1979 elfNN_ia64_global_dyn_info_free (void **xentry,
1980 PTR unused ATTRIBUTE_UNUSED)
1982 struct elfNN_ia64_link_hash_entry *entry
1983 = (struct elfNN_ia64_link_hash_entry *) xentry;
1985 if (entry->root.root.type == bfd_link_hash_warning)
1986 entry = (struct elfNN_ia64_link_hash_entry *) entry->root.root.u.i.link;
1993 entry->sorted_count = 0;
2000 /* Free the local elfNN_ia64_dyn_sym_info array. */
2003 elfNN_ia64_local_dyn_info_free (void **slot,
2004 PTR unused ATTRIBUTE_UNUSED)
2006 struct elfNN_ia64_local_hash_entry *entry
2007 = (struct elfNN_ia64_local_hash_entry *) *slot;
2014 entry->sorted_count = 0;
2021 /* Destroy IA-64 linker hash table. */
2024 elfNN_ia64_hash_table_free (hash)
2025 struct bfd_link_hash_table *hash;
2027 struct elfNN_ia64_link_hash_table *ia64_info
2028 = (struct elfNN_ia64_link_hash_table *) hash;
2029 if (ia64_info->loc_hash_table)
2031 htab_traverse (ia64_info->loc_hash_table,
2032 elfNN_ia64_local_dyn_info_free, NULL);
2033 htab_delete (ia64_info->loc_hash_table);
2035 if (ia64_info->loc_hash_memory)
2036 objalloc_free ((struct objalloc *) ia64_info->loc_hash_memory);
2037 elf_link_hash_traverse (&ia64_info->root,
2038 elfNN_ia64_global_dyn_info_free, NULL);
2039 _bfd_generic_link_hash_table_free (hash);
2042 /* Traverse both local and global hash tables. */
2044 struct elfNN_ia64_dyn_sym_traverse_data
2046 bfd_boolean (*func) PARAMS ((struct elfNN_ia64_dyn_sym_info *, PTR));
2051 elfNN_ia64_global_dyn_sym_thunk (xentry, xdata)
2052 struct bfd_hash_entry *xentry;
2055 struct elfNN_ia64_link_hash_entry *entry
2056 = (struct elfNN_ia64_link_hash_entry *) xentry;
2057 struct elfNN_ia64_dyn_sym_traverse_data *data
2058 = (struct elfNN_ia64_dyn_sym_traverse_data *) xdata;
2059 struct elfNN_ia64_dyn_sym_info *dyn_i;
2062 if (entry->root.root.type == bfd_link_hash_warning)
2063 entry = (struct elfNN_ia64_link_hash_entry *) entry->root.root.u.i.link;
2065 for (count = entry->count, dyn_i = entry->info;
2068 if (! (*data->func) (dyn_i, data->data))
2074 elfNN_ia64_local_dyn_sym_thunk (slot, xdata)
2078 struct elfNN_ia64_local_hash_entry *entry
2079 = (struct elfNN_ia64_local_hash_entry *) *slot;
2080 struct elfNN_ia64_dyn_sym_traverse_data *data
2081 = (struct elfNN_ia64_dyn_sym_traverse_data *) xdata;
2082 struct elfNN_ia64_dyn_sym_info *dyn_i;
2085 for (count = entry->count, dyn_i = entry->info;
2088 if (! (*data->func) (dyn_i, data->data))
2094 elfNN_ia64_dyn_sym_traverse (ia64_info, func, data)
2095 struct elfNN_ia64_link_hash_table *ia64_info;
2096 bfd_boolean (*func) PARAMS ((struct elfNN_ia64_dyn_sym_info *, PTR));
2099 struct elfNN_ia64_dyn_sym_traverse_data xdata;
2104 elf_link_hash_traverse (&ia64_info->root,
2105 elfNN_ia64_global_dyn_sym_thunk, &xdata);
2106 htab_traverse (ia64_info->loc_hash_table,
2107 elfNN_ia64_local_dyn_sym_thunk, &xdata);
2111 elfNN_ia64_create_dynamic_sections (abfd, info)
2113 struct bfd_link_info *info;
2115 struct elfNN_ia64_link_hash_table *ia64_info;
2118 if (! _bfd_elf_create_dynamic_sections (abfd, info))
2121 ia64_info = elfNN_ia64_hash_table (info);
2123 ia64_info->plt_sec = bfd_get_section_by_name (abfd, ".plt");
2124 ia64_info->got_sec = bfd_get_section_by_name (abfd, ".got");
2127 flagword flags = bfd_get_section_flags (abfd, ia64_info->got_sec);
2128 bfd_set_section_flags (abfd, ia64_info->got_sec, SEC_SMALL_DATA | flags);
2129 /* The .got section is always aligned at 8 bytes. */
2130 bfd_set_section_alignment (abfd, ia64_info->got_sec, 3);
2133 if (!get_pltoff (abfd, info, ia64_info))
2136 s = bfd_make_section_with_flags (abfd, ".rela.IA_64.pltoff",
2137 (SEC_ALLOC | SEC_LOAD
2140 | SEC_LINKER_CREATED
2143 || !bfd_set_section_alignment (abfd, s, LOG_SECTION_ALIGN))
2145 ia64_info->rel_pltoff_sec = s;
2147 s = bfd_make_section_with_flags (abfd, ".rela.got",
2148 (SEC_ALLOC | SEC_LOAD
2151 | SEC_LINKER_CREATED
2154 || !bfd_set_section_alignment (abfd, s, LOG_SECTION_ALIGN))
2156 ia64_info->rel_got_sec = s;
2161 /* Find and/or create a hash entry for local symbol. */
2162 static struct elfNN_ia64_local_hash_entry *
2163 get_local_sym_hash (ia64_info, abfd, rel, create)
2164 struct elfNN_ia64_link_hash_table *ia64_info;
2166 const Elf_Internal_Rela *rel;
2169 struct elfNN_ia64_local_hash_entry e, *ret;
2170 asection *sec = abfd->sections;
2171 hashval_t h = (((sec->id & 0xff) << 24) | ((sec->id & 0xff00) << 8))
2172 ^ ELFNN_R_SYM (rel->r_info) ^ (sec->id >> 16);
2176 e.r_sym = ELFNN_R_SYM (rel->r_info);
2177 slot = htab_find_slot_with_hash (ia64_info->loc_hash_table, &e, h,
2178 create ? INSERT : NO_INSERT);
2184 return (struct elfNN_ia64_local_hash_entry *) *slot;
2186 ret = (struct elfNN_ia64_local_hash_entry *)
2187 objalloc_alloc ((struct objalloc *) ia64_info->loc_hash_memory,
2188 sizeof (struct elfNN_ia64_local_hash_entry));
2191 memset (ret, 0, sizeof (*ret));
2193 ret->r_sym = ELFNN_R_SYM (rel->r_info);
2199 /* Used to sort elfNN_ia64_dyn_sym_info array. */
2202 addend_compare (const void *xp, const void *yp)
2204 const struct elfNN_ia64_dyn_sym_info *x
2205 = (const struct elfNN_ia64_dyn_sym_info *) xp;
2206 const struct elfNN_ia64_dyn_sym_info *y
2207 = (const struct elfNN_ia64_dyn_sym_info *) yp;
2209 return x->addend - y->addend;
2212 /* Sort elfNN_ia64_dyn_sym_info array and remove duplicates. */
2215 sort_dyn_sym_info (struct elfNN_ia64_dyn_sym_info *info,
2219 unsigned int i, dup, diff, dest, src, len;
2221 qsort (info, count, sizeof (*info), addend_compare);
2223 /* Find the first duplicate. */
2224 prev = info [0].addend;
2225 for (i = 1; i < count; i++)
2227 curr = info [i].addend;
2233 /* Remove duplicates. */
2236 /* We need to move a block of elements to here. */
2240 curr = info [i].addend;
2242 /* Move a block of elements whose first one is different from
2246 for (src = i + 1; src < count; src++)
2247 if (info [src].addend != curr)
2256 /* Find the next duplicate. */
2257 prev = info [src].addend;
2258 for (dup = src + 1; dup < count; dup++)
2260 curr = info [dup].addend;
2266 /* How much to move. */
2270 if (len == 1 && dup < count)
2272 /* If we only move 1 element, we combine it with the next
2273 one. Find the next different one. */
2274 for (diff = dup + 1, src++; diff < count; diff++, src++)
2275 if (info [diff].addend != curr)
2280 /* Find the next duplicate. */
2281 prev = info [diff].addend;
2282 for (dup = diff + 1; dup < count; dup++)
2284 curr = info [dup].addend;
2291 len = diff - src + 1;
2296 memmove (&info [dest], &info [src], len * sizeof (*info));
2307 /* Find and/or create a descriptor for dynamic symbol info. This will
2308 vary based on global or local symbol, and the addend to the reloc.
2310 We don't sort when inserting. Also, we sort and eliminate
2311 duplicates if there is an unsorted section. Typically, this will
2312 only happen once, because we do all insertions before lookups. We
2313 then use bsearch to do a lookup. This also allows lookups to be
2314 fast. So we have fast insertion (O(log N) due to duplicate check),
2315 fast lookup (O(log N)) and one sort (O(N log N) expected time).
2316 Previously, all lookups were O(N) because of the use of the linked
2317 list and also all insertions were O(N) because of the check for
2318 duplicates. There are some complications here because the array
2319 size grows occasionally, which may add an O(N) factor, but this
2320 should be rare. Also, we free the excess array allocation, which
2321 requires a copy which is O(N), but this only happens once. */
2323 static struct elfNN_ia64_dyn_sym_info *
2324 get_dyn_sym_info (ia64_info, h, abfd, rel, create)
2325 struct elfNN_ia64_link_hash_table *ia64_info;
2326 struct elf_link_hash_entry *h;
2328 const Elf_Internal_Rela *rel;
2331 struct elfNN_ia64_dyn_sym_info **info_p, *info, *dyn_i, key;
2332 unsigned int *count_p, *sorted_count_p, *size_p;
2333 unsigned int count, sorted_count, size;
2334 bfd_vma addend = rel ? rel->r_addend : 0;
2339 struct elfNN_ia64_link_hash_entry *global_h;
2341 global_h = (struct elfNN_ia64_link_hash_entry *) h;
2342 info_p = &global_h->info;
2343 count_p = &global_h->count;
2344 sorted_count_p = &global_h->sorted_count;
2345 size_p = &global_h->size;
2349 struct elfNN_ia64_local_hash_entry *loc_h;
2351 loc_h = get_local_sym_hash (ia64_info, abfd, rel, create);
2354 BFD_ASSERT (!create);
2358 info_p = &loc_h->info;
2359 count_p = &loc_h->count;
2360 sorted_count_p = &loc_h->sorted_count;
2361 size_p = &loc_h->size;
2365 sorted_count = *sorted_count_p;
2370 /* When we create the array, we don't check for duplicates,
2371 except in the previously sorted section if one exists, and
2372 against the last inserted entry. This allows insertions to
2378 /* Try bsearch first on the sorted section. */
2379 key.addend = addend;
2380 dyn_i = bsearch (&key, info, sorted_count,
2381 sizeof (*info), addend_compare);
2389 /* Do a quick check for the last inserted entry. */
2390 dyn_i = info + count - 1;
2391 if (dyn_i->addend == addend)
2399 /* It is the very first element. We create the array of size
2402 amt = size * sizeof (*info);
2403 info = bfd_malloc (amt);
2405 else if (size <= count)
2407 /* We double the array size every time when we reach the
2410 amt = size * sizeof (*info);
2411 info = bfd_realloc (info, amt);
2422 /* Append the new one to the array. */
2423 dyn_i = info + count;
2424 memset (dyn_i, 0, sizeof (*dyn_i));
2425 dyn_i->addend = addend;
2427 /* We increment count only since the new ones are unsorted and
2428 may have duplicate. */
2433 /* It is a lookup without insertion. Sort array if part of the
2434 array isn't sorted. */
2435 if (count != sorted_count)
2437 count = sort_dyn_sym_info (info, count);
2439 *sorted_count_p = count;
2442 /* Free unused memory. */
2445 amt = count * sizeof (*info);
2446 info = bfd_malloc (amt);
2449 memcpy (info, *info_p, amt);
2456 key.addend = addend;
2457 dyn_i = bsearch (&key, info, count,
2458 sizeof (*info), addend_compare);
2465 get_got (abfd, info, ia64_info)
2467 struct bfd_link_info *info;
2468 struct elfNN_ia64_link_hash_table *ia64_info;
2473 got = ia64_info->got_sec;
2478 dynobj = ia64_info->root.dynobj;
2480 ia64_info->root.dynobj = dynobj = abfd;
2481 if (!_bfd_elf_create_got_section (dynobj, info))
2484 got = bfd_get_section_by_name (dynobj, ".got");
2486 ia64_info->got_sec = got;
2488 /* The .got section is always aligned at 8 bytes. */
2489 if (!bfd_set_section_alignment (abfd, got, 3))
2492 flags = bfd_get_section_flags (abfd, got);
2493 bfd_set_section_flags (abfd, got, SEC_SMALL_DATA | flags);
2499 /* Create function descriptor section (.opd). This section is called .opd
2500 because it contains "official procedure descriptors". The "official"
2501 refers to the fact that these descriptors are used when taking the address
2502 of a procedure, thus ensuring a unique address for each procedure. */
2505 get_fptr (abfd, info, ia64_info)
2507 struct bfd_link_info *info;
2508 struct elfNN_ia64_link_hash_table *ia64_info;
2513 fptr = ia64_info->fptr_sec;
2516 dynobj = ia64_info->root.dynobj;
2518 ia64_info->root.dynobj = dynobj = abfd;
2520 fptr = bfd_make_section_with_flags (dynobj, ".opd",
2525 | (info->pie ? 0 : SEC_READONLY)
2526 | SEC_LINKER_CREATED));
2528 || !bfd_set_section_alignment (abfd, fptr, 4))
2534 ia64_info->fptr_sec = fptr;
2539 fptr_rel = bfd_make_section_with_flags (dynobj, ".rela.opd",
2540 (SEC_ALLOC | SEC_LOAD
2543 | SEC_LINKER_CREATED
2545 if (fptr_rel == NULL
2546 || !bfd_set_section_alignment (abfd, fptr_rel,
2553 ia64_info->rel_fptr_sec = fptr_rel;
2561 get_pltoff (abfd, info, ia64_info)
2563 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2564 struct elfNN_ia64_link_hash_table *ia64_info;
2569 pltoff = ia64_info->pltoff_sec;
2572 dynobj = ia64_info->root.dynobj;
2574 ia64_info->root.dynobj = dynobj = abfd;
2576 pltoff = bfd_make_section_with_flags (dynobj,
2577 ELF_STRING_ia64_pltoff,
2583 | SEC_LINKER_CREATED));
2585 || !bfd_set_section_alignment (abfd, pltoff, 4))
2591 ia64_info->pltoff_sec = pltoff;
2598 get_reloc_section (abfd, ia64_info, sec, create)
2600 struct elfNN_ia64_link_hash_table *ia64_info;
2604 const char *srel_name;
2608 srel_name = (bfd_elf_string_from_elf_section
2609 (abfd, elf_elfheader(abfd)->e_shstrndx,
2610 elf_section_data(sec)->rel_hdr.sh_name));
2611 if (srel_name == NULL)
2614 BFD_ASSERT ((strncmp (srel_name, ".rela", 5) == 0
2615 && strcmp (bfd_get_section_name (abfd, sec),
2617 || (strncmp (srel_name, ".rel", 4) == 0
2618 && strcmp (bfd_get_section_name (abfd, sec),
2619 srel_name+4) == 0));
2621 dynobj = ia64_info->root.dynobj;
2623 ia64_info->root.dynobj = dynobj = abfd;
2625 srel = bfd_get_section_by_name (dynobj, srel_name);
2626 if (srel == NULL && create)
2628 srel = bfd_make_section_with_flags (dynobj, srel_name,
2629 (SEC_ALLOC | SEC_LOAD
2632 | SEC_LINKER_CREATED
2635 || !bfd_set_section_alignment (dynobj, srel,
2644 count_dyn_reloc (bfd *abfd, struct elfNN_ia64_dyn_sym_info *dyn_i,
2645 asection *srel, int type, bfd_boolean reltext)
2647 struct elfNN_ia64_dyn_reloc_entry *rent;
2649 for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
2650 if (rent->srel == srel && rent->type == type)
2655 rent = ((struct elfNN_ia64_dyn_reloc_entry *)
2656 bfd_alloc (abfd, (bfd_size_type) sizeof (*rent)));
2660 rent->next = dyn_i->reloc_entries;
2664 dyn_i->reloc_entries = rent;
2666 rent->reltext = reltext;
2673 elfNN_ia64_check_relocs (abfd, info, sec, relocs)
2675 struct bfd_link_info *info;
2677 const Elf_Internal_Rela *relocs;
2679 struct elfNN_ia64_link_hash_table *ia64_info;
2680 const Elf_Internal_Rela *relend;
2681 Elf_Internal_Shdr *symtab_hdr;
2682 const Elf_Internal_Rela *rel;
2683 asection *got, *fptr, *srel, *pltoff;
2692 NEED_LTOFF_FPTR = 128,
2698 struct elf_link_hash_entry *h;
2699 unsigned long r_symndx;
2700 bfd_boolean maybe_dynamic;
2702 if (info->relocatable)
2705 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2706 ia64_info = elfNN_ia64_hash_table (info);
2708 got = fptr = srel = pltoff = NULL;
2710 relend = relocs + sec->reloc_count;
2712 /* We scan relocations first to create dynamic relocation arrays. We
2713 modified get_dyn_sym_info to allow fast insertion and support fast
2714 lookup in the next loop. */
2715 for (rel = relocs; rel < relend; ++rel)
2717 r_symndx = ELFNN_R_SYM (rel->r_info);
2718 if (r_symndx >= symtab_hdr->sh_info)
2720 long indx = r_symndx - symtab_hdr->sh_info;
2721 h = elf_sym_hashes (abfd)[indx];
2722 while (h->root.type == bfd_link_hash_indirect
2723 || h->root.type == bfd_link_hash_warning)
2724 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2729 /* We can only get preliminary data on whether a symbol is
2730 locally or externally defined, as not all of the input files
2731 have yet been processed. Do something with what we know, as
2732 this may help reduce memory usage and processing time later. */
2733 maybe_dynamic = (h && ((!info->executable
2735 || info->unresolved_syms_in_shared_libs == RM_IGNORE))
2737 || h->root.type == bfd_link_hash_defweak));
2740 switch (ELFNN_R_TYPE (rel->r_info))
2742 case R_IA64_TPREL64MSB:
2743 case R_IA64_TPREL64LSB:
2744 if (info->shared || maybe_dynamic)
2745 need_entry = NEED_DYNREL;
2748 case R_IA64_LTOFF_TPREL22:
2749 need_entry = NEED_TPREL;
2751 info->flags |= DF_STATIC_TLS;
2754 case R_IA64_DTPREL32MSB:
2755 case R_IA64_DTPREL32LSB:
2756 case R_IA64_DTPREL64MSB:
2757 case R_IA64_DTPREL64LSB:
2758 if (info->shared || maybe_dynamic)
2759 need_entry = NEED_DYNREL;
2762 case R_IA64_LTOFF_DTPREL22:
2763 need_entry = NEED_DTPREL;
2766 case R_IA64_DTPMOD64MSB:
2767 case R_IA64_DTPMOD64LSB:
2768 if (info->shared || maybe_dynamic)
2769 need_entry = NEED_DYNREL;
2772 case R_IA64_LTOFF_DTPMOD22:
2773 need_entry = NEED_DTPMOD;
2776 case R_IA64_LTOFF_FPTR22:
2777 case R_IA64_LTOFF_FPTR64I:
2778 case R_IA64_LTOFF_FPTR32MSB:
2779 case R_IA64_LTOFF_FPTR32LSB:
2780 case R_IA64_LTOFF_FPTR64MSB:
2781 case R_IA64_LTOFF_FPTR64LSB:
2782 need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR;
2785 case R_IA64_FPTR64I:
2786 case R_IA64_FPTR32MSB:
2787 case R_IA64_FPTR32LSB:
2788 case R_IA64_FPTR64MSB:
2789 case R_IA64_FPTR64LSB:
2790 if (info->shared || h)
2791 need_entry = NEED_FPTR | NEED_DYNREL;
2793 need_entry = NEED_FPTR;
2796 case R_IA64_LTOFF22:
2797 case R_IA64_LTOFF64I:
2798 need_entry = NEED_GOT;
2801 case R_IA64_LTOFF22X:
2802 need_entry = NEED_GOTX;
2805 case R_IA64_PLTOFF22:
2806 case R_IA64_PLTOFF64I:
2807 case R_IA64_PLTOFF64MSB:
2808 case R_IA64_PLTOFF64LSB:
2809 need_entry = NEED_PLTOFF;
2813 need_entry |= NEED_MIN_PLT;
2817 (*info->callbacks->warning)
2818 (info, _("@pltoff reloc against local symbol"), 0,
2819 abfd, 0, (bfd_vma) 0);
2823 case R_IA64_PCREL21B:
2824 case R_IA64_PCREL60B:
2825 /* Depending on where this symbol is defined, we may or may not
2826 need a full plt entry. Only skip if we know we'll not need
2827 the entry -- static or symbolic, and the symbol definition
2828 has already been seen. */
2829 if (maybe_dynamic && rel->r_addend == 0)
2830 need_entry = NEED_FULL_PLT;
2836 case R_IA64_DIR32MSB:
2837 case R_IA64_DIR32LSB:
2838 case R_IA64_DIR64MSB:
2839 case R_IA64_DIR64LSB:
2840 /* Shared objects will always need at least a REL relocation. */
2841 if (info->shared || maybe_dynamic)
2842 need_entry = NEED_DYNREL;
2845 case R_IA64_IPLTMSB:
2846 case R_IA64_IPLTLSB:
2847 /* Shared objects will always need at least a REL relocation. */
2848 if (info->shared || maybe_dynamic)
2849 need_entry = NEED_DYNREL;
2852 case R_IA64_PCREL22:
2853 case R_IA64_PCREL64I:
2854 case R_IA64_PCREL32MSB:
2855 case R_IA64_PCREL32LSB:
2856 case R_IA64_PCREL64MSB:
2857 case R_IA64_PCREL64LSB:
2859 need_entry = NEED_DYNREL;
2866 if ((need_entry & NEED_FPTR) != 0
2869 (*info->callbacks->warning)
2870 (info, _("non-zero addend in @fptr reloc"), 0,
2871 abfd, 0, (bfd_vma) 0);
2874 if (get_dyn_sym_info (ia64_info, h, abfd, rel, TRUE) == NULL)
2878 /* Now, we only do lookup without insertion, which is very fast
2879 with the modified get_dyn_sym_info. */
2880 for (rel = relocs; rel < relend; ++rel)
2882 struct elfNN_ia64_dyn_sym_info *dyn_i;
2883 int dynrel_type = R_IA64_NONE;
2885 r_symndx = ELFNN_R_SYM (rel->r_info);
2886 if (r_symndx >= symtab_hdr->sh_info)
2888 /* We're dealing with a global symbol -- find its hash entry
2889 and mark it as being referenced. */
2890 long indx = r_symndx - symtab_hdr->sh_info;
2891 h = elf_sym_hashes (abfd)[indx];
2892 while (h->root.type == bfd_link_hash_indirect
2893 || h->root.type == bfd_link_hash_warning)
2894 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2901 /* We can only get preliminary data on whether a symbol is
2902 locally or externally defined, as not all of the input files
2903 have yet been processed. Do something with what we know, as
2904 this may help reduce memory usage and processing time later. */
2905 maybe_dynamic = (h && ((!info->executable
2907 || info->unresolved_syms_in_shared_libs == RM_IGNORE))
2909 || h->root.type == bfd_link_hash_defweak));
2912 switch (ELFNN_R_TYPE (rel->r_info))
2914 case R_IA64_TPREL64MSB:
2915 case R_IA64_TPREL64LSB:
2916 if (info->shared || maybe_dynamic)
2917 need_entry = NEED_DYNREL;
2918 dynrel_type = R_IA64_TPREL64LSB;
2920 info->flags |= DF_STATIC_TLS;
2923 case R_IA64_LTOFF_TPREL22:
2924 need_entry = NEED_TPREL;
2926 info->flags |= DF_STATIC_TLS;
2929 case R_IA64_DTPREL32MSB:
2930 case R_IA64_DTPREL32LSB:
2931 case R_IA64_DTPREL64MSB:
2932 case R_IA64_DTPREL64LSB:
2933 if (info->shared || maybe_dynamic)
2934 need_entry = NEED_DYNREL;
2935 dynrel_type = R_IA64_DTPRELNNLSB;
2938 case R_IA64_LTOFF_DTPREL22:
2939 need_entry = NEED_DTPREL;
2942 case R_IA64_DTPMOD64MSB:
2943 case R_IA64_DTPMOD64LSB:
2944 if (info->shared || maybe_dynamic)
2945 need_entry = NEED_DYNREL;
2946 dynrel_type = R_IA64_DTPMOD64LSB;
2949 case R_IA64_LTOFF_DTPMOD22:
2950 need_entry = NEED_DTPMOD;
2953 case R_IA64_LTOFF_FPTR22:
2954 case R_IA64_LTOFF_FPTR64I:
2955 case R_IA64_LTOFF_FPTR32MSB:
2956 case R_IA64_LTOFF_FPTR32LSB:
2957 case R_IA64_LTOFF_FPTR64MSB:
2958 case R_IA64_LTOFF_FPTR64LSB:
2959 need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR;
2962 case R_IA64_FPTR64I:
2963 case R_IA64_FPTR32MSB:
2964 case R_IA64_FPTR32LSB:
2965 case R_IA64_FPTR64MSB:
2966 case R_IA64_FPTR64LSB:
2967 if (info->shared || h)
2968 need_entry = NEED_FPTR | NEED_DYNREL;
2970 need_entry = NEED_FPTR;
2971 dynrel_type = R_IA64_FPTRNNLSB;
2974 case R_IA64_LTOFF22:
2975 case R_IA64_LTOFF64I:
2976 need_entry = NEED_GOT;
2979 case R_IA64_LTOFF22X:
2980 need_entry = NEED_GOTX;
2983 case R_IA64_PLTOFF22:
2984 case R_IA64_PLTOFF64I:
2985 case R_IA64_PLTOFF64MSB:
2986 case R_IA64_PLTOFF64LSB:
2987 need_entry = NEED_PLTOFF;
2991 need_entry |= NEED_MIN_PLT;
2995 case R_IA64_PCREL21B:
2996 case R_IA64_PCREL60B:
2997 /* Depending on where this symbol is defined, we may or may not
2998 need a full plt entry. Only skip if we know we'll not need
2999 the entry -- static or symbolic, and the symbol definition
3000 has already been seen. */
3001 if (maybe_dynamic && rel->r_addend == 0)
3002 need_entry = NEED_FULL_PLT;
3008 case R_IA64_DIR32MSB:
3009 case R_IA64_DIR32LSB:
3010 case R_IA64_DIR64MSB:
3011 case R_IA64_DIR64LSB:
3012 /* Shared objects will always need at least a REL relocation. */
3013 if (info->shared || maybe_dynamic)
3014 need_entry = NEED_DYNREL;
3015 dynrel_type = R_IA64_DIRNNLSB;
3018 case R_IA64_IPLTMSB:
3019 case R_IA64_IPLTLSB:
3020 /* Shared objects will always need at least a REL relocation. */
3021 if (info->shared || maybe_dynamic)
3022 need_entry = NEED_DYNREL;
3023 dynrel_type = R_IA64_IPLTLSB;
3026 case R_IA64_PCREL22:
3027 case R_IA64_PCREL64I:
3028 case R_IA64_PCREL32MSB:
3029 case R_IA64_PCREL32LSB:
3030 case R_IA64_PCREL64MSB:
3031 case R_IA64_PCREL64LSB:
3033 need_entry = NEED_DYNREL;
3034 dynrel_type = R_IA64_PCRELNNLSB;
3041 dyn_i = get_dyn_sym_info (ia64_info, h, abfd, rel, FALSE);
3043 /* Record whether or not this is a local symbol. */
3046 /* Create what's needed. */
3047 if (need_entry & (NEED_GOT | NEED_GOTX | NEED_TPREL
3048 | NEED_DTPMOD | NEED_DTPREL))
3052 got = get_got (abfd, info, ia64_info);
3056 if (need_entry & NEED_GOT)
3057 dyn_i->want_got = 1;
3058 if (need_entry & NEED_GOTX)
3059 dyn_i->want_gotx = 1;
3060 if (need_entry & NEED_TPREL)
3061 dyn_i->want_tprel = 1;
3062 if (need_entry & NEED_DTPMOD)
3063 dyn_i->want_dtpmod = 1;
3064 if (need_entry & NEED_DTPREL)
3065 dyn_i->want_dtprel = 1;
3067 if (need_entry & NEED_FPTR)
3071 fptr = get_fptr (abfd, info, ia64_info);
3076 /* FPTRs for shared libraries are allocated by the dynamic
3077 linker. Make sure this local symbol will appear in the
3078 dynamic symbol table. */
3079 if (!h && info->shared)
3081 if (! (bfd_elf_link_record_local_dynamic_symbol
3082 (info, abfd, (long) r_symndx)))
3086 dyn_i->want_fptr = 1;
3088 if (need_entry & NEED_LTOFF_FPTR)
3089 dyn_i->want_ltoff_fptr = 1;
3090 if (need_entry & (NEED_MIN_PLT | NEED_FULL_PLT))
3092 if (!ia64_info->root.dynobj)
3093 ia64_info->root.dynobj = abfd;
3095 dyn_i->want_plt = 1;
3097 if (need_entry & NEED_FULL_PLT)
3098 dyn_i->want_plt2 = 1;
3099 if (need_entry & NEED_PLTOFF)
3101 /* This is needed here, in case @pltoff is used in a non-shared
3105 pltoff = get_pltoff (abfd, info, ia64_info);
3110 dyn_i->want_pltoff = 1;
3112 if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC))
3116 srel = get_reloc_section (abfd, ia64_info, sec, TRUE);
3120 if (!count_dyn_reloc (abfd, dyn_i, srel, dynrel_type,
3121 (sec->flags & SEC_READONLY) != 0))
3129 /* For cleanliness, and potentially faster dynamic loading, allocate
3130 external GOT entries first. */
3133 allocate_global_data_got (dyn_i, data)
3134 struct elfNN_ia64_dyn_sym_info *dyn_i;
3137 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
3139 if ((dyn_i->want_got || dyn_i->want_gotx)
3140 && ! dyn_i->want_fptr
3141 && elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
3143 dyn_i->got_offset = x->ofs;
3146 if (dyn_i->want_tprel)
3148 dyn_i->tprel_offset = x->ofs;
3151 if (dyn_i->want_dtpmod)
3153 if (elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
3155 dyn_i->dtpmod_offset = x->ofs;
3160 struct elfNN_ia64_link_hash_table *ia64_info;
3162 ia64_info = elfNN_ia64_hash_table (x->info);
3163 if (ia64_info->self_dtpmod_offset == (bfd_vma) -1)
3165 ia64_info->self_dtpmod_offset = x->ofs;
3168 dyn_i->dtpmod_offset = ia64_info->self_dtpmod_offset;
3171 if (dyn_i->want_dtprel)
3173 dyn_i->dtprel_offset = x->ofs;
3179 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
3182 allocate_global_fptr_got (dyn_i, data)
3183 struct elfNN_ia64_dyn_sym_info *dyn_i;
3186 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
3190 && elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, R_IA64_FPTRNNLSB))
3192 dyn_i->got_offset = x->ofs;
3198 /* Lastly, allocate all the GOT entries for local data. */
3201 allocate_local_got (dyn_i, data)
3202 struct elfNN_ia64_dyn_sym_info *dyn_i;
3205 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
3207 if ((dyn_i->want_got || dyn_i->want_gotx)
3208 && !elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
3210 dyn_i->got_offset = x->ofs;
3216 /* Search for the index of a global symbol in it's defining object file. */
3219 global_sym_index (h)
3220 struct elf_link_hash_entry *h;
3222 struct elf_link_hash_entry **p;
3225 BFD_ASSERT (h->root.type == bfd_link_hash_defined
3226 || h->root.type == bfd_link_hash_defweak);
3228 obj = h->root.u.def.section->owner;
3229 for (p = elf_sym_hashes (obj); *p != h; ++p)
3232 return p - elf_sym_hashes (obj) + elf_tdata (obj)->symtab_hdr.sh_info;
3235 /* Allocate function descriptors. We can do these for every function
3236 in a main executable that is not exported. */
3239 allocate_fptr (dyn_i, data)
3240 struct elfNN_ia64_dyn_sym_info *dyn_i;
3243 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
3245 if (dyn_i->want_fptr)
3247 struct elf_link_hash_entry *h = dyn_i->h;
3250 while (h->root.type == bfd_link_hash_indirect
3251 || h->root.type == bfd_link_hash_warning)
3252 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3254 if (!x->info->executable
3256 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3257 || (h->root.type != bfd_link_hash_undefweak
3258 && h->root.type != bfd_link_hash_undefined)))
3260 if (h && h->dynindx == -1)
3262 BFD_ASSERT ((h->root.type == bfd_link_hash_defined)
3263 || (h->root.type == bfd_link_hash_defweak));
3265 if (!bfd_elf_link_record_local_dynamic_symbol
3266 (x->info, h->root.u.def.section->owner,
3267 global_sym_index (h)))
3271 dyn_i->want_fptr = 0;
3273 else if (h == NULL || h->dynindx == -1)
3275 dyn_i->fptr_offset = x->ofs;
3279 dyn_i->want_fptr = 0;
3284 /* Allocate all the minimal PLT entries. */
3287 allocate_plt_entries (dyn_i, data)
3288 struct elfNN_ia64_dyn_sym_info *dyn_i;
3291 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
3293 if (dyn_i->want_plt)
3295 struct elf_link_hash_entry *h = dyn_i->h;
3298 while (h->root.type == bfd_link_hash_indirect
3299 || h->root.type == bfd_link_hash_warning)
3300 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3302 /* ??? Versioned symbols seem to lose NEEDS_PLT. */
3303 if (elfNN_ia64_dynamic_symbol_p (h, x->info, 0))
3305 bfd_size_type offset = x->ofs;
3307 offset = PLT_HEADER_SIZE;
3308 dyn_i->plt_offset = offset;
3309 x->ofs = offset + PLT_MIN_ENTRY_SIZE;
3311 dyn_i->want_pltoff = 1;
3315 dyn_i->want_plt = 0;
3316 dyn_i->want_plt2 = 0;
3322 /* Allocate all the full PLT entries. */
3325 allocate_plt2_entries (dyn_i, data)
3326 struct elfNN_ia64_dyn_sym_info *dyn_i;
3329 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
3331 if (dyn_i->want_plt2)
3333 struct elf_link_hash_entry *h = dyn_i->h;
3334 bfd_size_type ofs = x->ofs;
3336 dyn_i->plt2_offset = ofs;
3337 x->ofs = ofs + PLT_FULL_ENTRY_SIZE;
3339 while (h->root.type == bfd_link_hash_indirect
3340 || h->root.type == bfd_link_hash_warning)
3341 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3342 dyn_i->h->plt.offset = ofs;
3347 /* Allocate all the PLTOFF entries requested by relocations and
3348 plt entries. We can't share space with allocated FPTR entries,
3349 because the latter are not necessarily addressable by the GP.
3350 ??? Relaxation might be able to determine that they are. */
3353 allocate_pltoff_entries (dyn_i, data)
3354 struct elfNN_ia64_dyn_sym_info *dyn_i;
3357 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
3359 if (dyn_i->want_pltoff)
3361 dyn_i->pltoff_offset = x->ofs;
3367 /* Allocate dynamic relocations for those symbols that turned out
3371 allocate_dynrel_entries (dyn_i, data)
3372 struct elfNN_ia64_dyn_sym_info *dyn_i;
3375 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
3376 struct elfNN_ia64_link_hash_table *ia64_info;
3377 struct elfNN_ia64_dyn_reloc_entry *rent;
3378 bfd_boolean dynamic_symbol, shared, resolved_zero;
3380 ia64_info = elfNN_ia64_hash_table (x->info);
3382 /* Note that this can't be used in relation to FPTR relocs below. */
3383 dynamic_symbol = elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0);
3385 shared = x->info->shared;
3386 resolved_zero = (dyn_i->h
3387 && ELF_ST_VISIBILITY (dyn_i->h->other)
3388 && dyn_i->h->root.type == bfd_link_hash_undefweak);
3390 /* Take care of the GOT and PLT relocations. */
3393 && (dynamic_symbol || shared)
3394 && (dyn_i->want_got || dyn_i->want_gotx))
3395 || (dyn_i->want_ltoff_fptr
3397 && dyn_i->h->dynindx != -1))
3399 if (!dyn_i->want_ltoff_fptr
3402 || dyn_i->h->root.type != bfd_link_hash_undefweak)
3403 ia64_info->rel_got_sec->size += sizeof (ElfNN_External_Rela);
3405 if ((dynamic_symbol || shared) && dyn_i->want_tprel)
3406 ia64_info->rel_got_sec->size += sizeof (ElfNN_External_Rela);
3407 if (dynamic_symbol && dyn_i->want_dtpmod)
3408 ia64_info->rel_got_sec->size += sizeof (ElfNN_External_Rela);
3409 if (dynamic_symbol && dyn_i->want_dtprel)
3410 ia64_info->rel_got_sec->size += sizeof (ElfNN_External_Rela);
3415 if (ia64_info->rel_fptr_sec && dyn_i->want_fptr)
3417 if (dyn_i->h == NULL || dyn_i->h->root.type != bfd_link_hash_undefweak)
3418 ia64_info->rel_fptr_sec->size += sizeof (ElfNN_External_Rela);
3421 if (!resolved_zero && dyn_i->want_pltoff)
3423 bfd_size_type t = 0;
3425 /* Dynamic symbols get one IPLT relocation. Local symbols in
3426 shared libraries get two REL relocations. Local symbols in
3427 main applications get nothing. */
3429 t = sizeof (ElfNN_External_Rela);
3431 t = 2 * sizeof (ElfNN_External_Rela);
3433 ia64_info->rel_pltoff_sec->size += t;
3436 /* Take care of the normal data relocations. */
3438 for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
3440 int count = rent->count;
3444 case R_IA64_FPTR32LSB:
3445 case R_IA64_FPTR64LSB:
3446 /* Allocate one iff !want_fptr and not PIE, which by this point
3447 will be true only if we're actually allocating one statically
3448 in the main executable. Position independent executables
3449 need a relative reloc. */
3450 if (dyn_i->want_fptr && !x->info->pie)
3453 case R_IA64_PCREL32LSB:
3454 case R_IA64_PCREL64LSB:
3455 if (!dynamic_symbol)
3458 case R_IA64_DIR32LSB:
3459 case R_IA64_DIR64LSB:
3460 if (!dynamic_symbol && !shared)
3463 case R_IA64_IPLTLSB:
3464 if (!dynamic_symbol && !shared)
3466 /* Use two REL relocations for IPLT relocations
3467 against local symbols. */
3468 if (!dynamic_symbol)
3471 case R_IA64_DTPREL32LSB:
3472 case R_IA64_TPREL64LSB:
3473 case R_IA64_DTPREL64LSB:
3474 case R_IA64_DTPMOD64LSB:
3480 ia64_info->reltext = 1;
3481 rent->srel->size += sizeof (ElfNN_External_Rela) * count;
3488 elfNN_ia64_adjust_dynamic_symbol (info, h)
3489 struct bfd_link_info *info ATTRIBUTE_UNUSED;
3490 struct elf_link_hash_entry *h;
3492 /* ??? Undefined symbols with PLT entries should be re-defined
3493 to be the PLT entry. */
3495 /* If this is a weak symbol, and there is a real definition, the
3496 processor independent code will have arranged for us to see the
3497 real definition first, and we can just use the same value. */
3498 if (h->u.weakdef != NULL)
3500 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
3501 || h->u.weakdef->root.type == bfd_link_hash_defweak);
3502 h->root.u.def.section = h->u.weakdef->root.u.def.section;
3503 h->root.u.def.value = h->u.weakdef->root.u.def.value;
3507 /* If this is a reference to a symbol defined by a dynamic object which
3508 is not a function, we might allocate the symbol in our .dynbss section
3509 and allocate a COPY dynamic relocation.
3511 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
3518 elfNN_ia64_size_dynamic_sections (output_bfd, info)
3519 bfd *output_bfd ATTRIBUTE_UNUSED;
3520 struct bfd_link_info *info;
3522 struct elfNN_ia64_allocate_data data;
3523 struct elfNN_ia64_link_hash_table *ia64_info;
3526 bfd_boolean relplt = FALSE;
3528 dynobj = elf_hash_table(info)->dynobj;
3529 ia64_info = elfNN_ia64_hash_table (info);
3530 ia64_info->self_dtpmod_offset = (bfd_vma) -1;
3531 BFD_ASSERT(dynobj != NULL);
3534 /* Set the contents of the .interp section to the interpreter. */
3535 if (ia64_info->root.dynamic_sections_created
3536 && info->executable)
3538 sec = bfd_get_section_by_name (dynobj, ".interp");
3539 BFD_ASSERT (sec != NULL);
3540 sec->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
3541 sec->size = strlen (ELF_DYNAMIC_INTERPRETER) + 1;
3544 /* Allocate the GOT entries. */
3546 if (ia64_info->got_sec)
3549 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data);
3550 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data);
3551 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data);
3552 ia64_info->got_sec->size = data.ofs;
3555 /* Allocate the FPTR entries. */
3557 if (ia64_info->fptr_sec)
3560 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_fptr, &data);
3561 ia64_info->fptr_sec->size = data.ofs;
3564 /* Now that we've seen all of the input files, we can decide which
3565 symbols need plt entries. Allocate the minimal PLT entries first.
3566 We do this even though dynamic_sections_created may be FALSE, because
3567 this has the side-effect of clearing want_plt and want_plt2. */
3570 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_plt_entries, &data);
3572 ia64_info->minplt_entries = 0;
3575 ia64_info->minplt_entries
3576 = (data.ofs - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
3579 /* Align the pointer for the plt2 entries. */
3580 data.ofs = (data.ofs + 31) & (bfd_vma) -32;
3582 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_plt2_entries, &data);
3583 if (data.ofs != 0 || ia64_info->root.dynamic_sections_created)
3585 /* FIXME: we always reserve the memory for dynamic linker even if
3586 there are no PLT entries since dynamic linker may assume the
3587 reserved memory always exists. */
3589 BFD_ASSERT (ia64_info->root.dynamic_sections_created);
3591 ia64_info->plt_sec->size = data.ofs;
3593 /* If we've got a .plt, we need some extra memory for the dynamic
3594 linker. We stuff these in .got.plt. */
3595 sec = bfd_get_section_by_name (dynobj, ".got.plt");
3596 sec->size = 8 * PLT_RESERVED_WORDS;
3599 /* Allocate the PLTOFF entries. */
3601 if (ia64_info->pltoff_sec)
3604 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_pltoff_entries, &data);
3605 ia64_info->pltoff_sec->size = data.ofs;
3608 if (ia64_info->root.dynamic_sections_created)
3610 /* Allocate space for the dynamic relocations that turned out to be
3613 if (info->shared && ia64_info->self_dtpmod_offset != (bfd_vma) -1)
3614 ia64_info->rel_got_sec->size += sizeof (ElfNN_External_Rela);
3615 data.only_got = FALSE;
3616 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries, &data);
3619 /* We have now determined the sizes of the various dynamic sections.
3620 Allocate memory for them. */
3621 for (sec = dynobj->sections; sec != NULL; sec = sec->next)
3625 if (!(sec->flags & SEC_LINKER_CREATED))
3628 /* If we don't need this section, strip it from the output file.
3629 There were several sections primarily related to dynamic
3630 linking that must be create before the linker maps input
3631 sections to output sections. The linker does that before
3632 bfd_elf_size_dynamic_sections is called, and it is that
3633 function which decides whether anything needs to go into
3636 strip = (sec->size == 0);
3638 if (sec == ia64_info->got_sec)
3640 else if (sec == ia64_info->rel_got_sec)
3643 ia64_info->rel_got_sec = NULL;
3645 /* We use the reloc_count field as a counter if we need to
3646 copy relocs into the output file. */
3647 sec->reloc_count = 0;
3649 else if (sec == ia64_info->fptr_sec)
3652 ia64_info->fptr_sec = NULL;
3654 else if (sec == ia64_info->rel_fptr_sec)
3657 ia64_info->rel_fptr_sec = NULL;
3659 /* We use the reloc_count field as a counter if we need to
3660 copy relocs into the output file. */
3661 sec->reloc_count = 0;
3663 else if (sec == ia64_info->plt_sec)
3666 ia64_info->plt_sec = NULL;
3668 else if (sec == ia64_info->pltoff_sec)
3671 ia64_info->pltoff_sec = NULL;
3673 else if (sec == ia64_info->rel_pltoff_sec)
3676 ia64_info->rel_pltoff_sec = NULL;
3680 /* We use the reloc_count field as a counter if we need to
3681 copy relocs into the output file. */
3682 sec->reloc_count = 0;
3689 /* It's OK to base decisions on the section name, because none
3690 of the dynobj section names depend upon the input files. */
3691 name = bfd_get_section_name (dynobj, sec);
3693 if (strcmp (name, ".got.plt") == 0)
3695 else if (strncmp (name, ".rel", 4) == 0)
3699 /* We use the reloc_count field as a counter if we need to
3700 copy relocs into the output file. */
3701 sec->reloc_count = 0;
3709 sec->flags |= SEC_EXCLUDE;
3712 /* Allocate memory for the section contents. */
3713 sec->contents = (bfd_byte *) bfd_zalloc (dynobj, sec->size);
3714 if (sec->contents == NULL && sec->size != 0)
3719 if (elf_hash_table (info)->dynamic_sections_created)
3721 /* Add some entries to the .dynamic section. We fill in the values
3722 later (in finish_dynamic_sections) but we must add the entries now
3723 so that we get the correct size for the .dynamic section. */
3725 if (info->executable)
3727 /* The DT_DEBUG entry is filled in by the dynamic linker and used
3729 #define add_dynamic_entry(TAG, VAL) \
3730 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3732 if (!add_dynamic_entry (DT_DEBUG, 0))
3736 if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE, 0))
3738 if (!add_dynamic_entry (DT_PLTGOT, 0))
3743 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3744 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3745 || !add_dynamic_entry (DT_JMPREL, 0))
3749 if (!add_dynamic_entry (DT_RELA, 0)
3750 || !add_dynamic_entry (DT_RELASZ, 0)
3751 || !add_dynamic_entry (DT_RELAENT, sizeof (ElfNN_External_Rela)))
3754 if (ia64_info->reltext)
3756 if (!add_dynamic_entry (DT_TEXTREL, 0))
3758 info->flags |= DF_TEXTREL;
3762 /* ??? Perhaps force __gp local. */
3767 static bfd_reloc_status_type
3768 elfNN_ia64_install_value (hit_addr, v, r_type)
3771 unsigned int r_type;
3773 const struct ia64_operand *op;
3774 int bigendian = 0, shift = 0;
3775 bfd_vma t0, t1, dword;
3777 enum ia64_opnd opnd;
3780 #ifdef BFD_HOST_U_64_BIT
3781 BFD_HOST_U_64_BIT val = (BFD_HOST_U_64_BIT) v;
3786 opnd = IA64_OPND_NIL;
3791 return bfd_reloc_ok;
3793 /* Instruction relocations. */
3796 case R_IA64_TPREL14:
3797 case R_IA64_DTPREL14:
3798 opnd = IA64_OPND_IMM14;
3801 case R_IA64_PCREL21F: opnd = IA64_OPND_TGT25; break;
3802 case R_IA64_PCREL21M: opnd = IA64_OPND_TGT25b; break;
3803 case R_IA64_PCREL60B: opnd = IA64_OPND_TGT64; break;
3804 case R_IA64_PCREL21B:
3805 case R_IA64_PCREL21BI:
3806 opnd = IA64_OPND_TGT25c;
3810 case R_IA64_GPREL22:
3811 case R_IA64_LTOFF22:
3812 case R_IA64_LTOFF22X:
3813 case R_IA64_PLTOFF22:
3814 case R_IA64_PCREL22:
3815 case R_IA64_LTOFF_FPTR22:
3816 case R_IA64_TPREL22:
3817 case R_IA64_DTPREL22:
3818 case R_IA64_LTOFF_TPREL22:
3819 case R_IA64_LTOFF_DTPMOD22:
3820 case R_IA64_LTOFF_DTPREL22:
3821 opnd = IA64_OPND_IMM22;
3825 case R_IA64_GPREL64I:
3826 case R_IA64_LTOFF64I:
3827 case R_IA64_PLTOFF64I:
3828 case R_IA64_PCREL64I:
3829 case R_IA64_FPTR64I:
3830 case R_IA64_LTOFF_FPTR64I:
3831 case R_IA64_TPREL64I:
3832 case R_IA64_DTPREL64I:
3833 opnd = IA64_OPND_IMMU64;
3836 /* Data relocations. */
3838 case R_IA64_DIR32MSB:
3839 case R_IA64_GPREL32MSB:
3840 case R_IA64_FPTR32MSB:
3841 case R_IA64_PCREL32MSB:
3842 case R_IA64_LTOFF_FPTR32MSB:
3843 case R_IA64_SEGREL32MSB:
3844 case R_IA64_SECREL32MSB:
3845 case R_IA64_LTV32MSB:
3846 case R_IA64_DTPREL32MSB:
3847 size = 4; bigendian = 1;
3850 case R_IA64_DIR32LSB:
3851 case R_IA64_GPREL32LSB:
3852 case R_IA64_FPTR32LSB:
3853 case R_IA64_PCREL32LSB:
3854 case R_IA64_LTOFF_FPTR32LSB:
3855 case R_IA64_SEGREL32LSB:
3856 case R_IA64_SECREL32LSB:
3857 case R_IA64_LTV32LSB:
3858 case R_IA64_DTPREL32LSB:
3859 size = 4; bigendian = 0;
3862 case R_IA64_DIR64MSB:
3863 case R_IA64_GPREL64MSB:
3864 case R_IA64_PLTOFF64MSB:
3865 case R_IA64_FPTR64MSB:
3866 case R_IA64_PCREL64MSB:
3867 case R_IA64_LTOFF_FPTR64MSB:
3868 case R_IA64_SEGREL64MSB:
3869 case R_IA64_SECREL64MSB:
3870 case R_IA64_LTV64MSB:
3871 case R_IA64_TPREL64MSB:
3872 case R_IA64_DTPMOD64MSB:
3873 case R_IA64_DTPREL64MSB:
3874 size = 8; bigendian = 1;
3877 case R_IA64_DIR64LSB:
3878 case R_IA64_GPREL64LSB:
3879 case R_IA64_PLTOFF64LSB:
3880 case R_IA64_FPTR64LSB:
3881 case R_IA64_PCREL64LSB:
3882 case R_IA64_LTOFF_FPTR64LSB:
3883 case R_IA64_SEGREL64LSB:
3884 case R_IA64_SECREL64LSB:
3885 case R_IA64_LTV64LSB:
3886 case R_IA64_TPREL64LSB:
3887 case R_IA64_DTPMOD64LSB:
3888 case R_IA64_DTPREL64LSB:
3889 size = 8; bigendian = 0;
3892 /* Unsupported / Dynamic relocations. */
3894 return bfd_reloc_notsupported;
3899 case IA64_OPND_IMMU64:
3900 hit_addr -= (long) hit_addr & 0x3;
3901 t0 = bfd_getl64 (hit_addr);
3902 t1 = bfd_getl64 (hit_addr + 8);
3904 /* tmpl/s: bits 0.. 5 in t0
3905 slot 0: bits 5..45 in t0
3906 slot 1: bits 46..63 in t0, bits 0..22 in t1
3907 slot 2: bits 23..63 in t1 */
3909 /* First, clear the bits that form the 64 bit constant. */
3910 t0 &= ~(0x3ffffLL << 46);
3912 | (( (0x07fLL << 13) | (0x1ffLL << 27)
3913 | (0x01fLL << 22) | (0x001LL << 21)
3914 | (0x001LL << 36)) << 23));
3916 t0 |= ((val >> 22) & 0x03ffffLL) << 46; /* 18 lsbs of imm41 */
3917 t1 |= ((val >> 40) & 0x7fffffLL) << 0; /* 23 msbs of imm41 */
3918 t1 |= ( (((val >> 0) & 0x07f) << 13) /* imm7b */
3919 | (((val >> 7) & 0x1ff) << 27) /* imm9d */
3920 | (((val >> 16) & 0x01f) << 22) /* imm5c */
3921 | (((val >> 21) & 0x001) << 21) /* ic */
3922 | (((val >> 63) & 0x001) << 36)) << 23; /* i */
3924 bfd_putl64 (t0, hit_addr);
3925 bfd_putl64 (t1, hit_addr + 8);
3928 case IA64_OPND_TGT64:
3929 hit_addr -= (long) hit_addr & 0x3;
3930 t0 = bfd_getl64 (hit_addr);
3931 t1 = bfd_getl64 (hit_addr + 8);
3933 /* tmpl/s: bits 0.. 5 in t0
3934 slot 0: bits 5..45 in t0
3935 slot 1: bits 46..63 in t0, bits 0..22 in t1
3936 slot 2: bits 23..63 in t1 */
3938 /* First, clear the bits that form the 64 bit constant. */
3939 t0 &= ~(0x3ffffLL << 46);
3941 | ((1LL << 36 | 0xfffffLL << 13) << 23));
3944 t0 |= ((val >> 20) & 0xffffLL) << 2 << 46; /* 16 lsbs of imm39 */
3945 t1 |= ((val >> 36) & 0x7fffffLL) << 0; /* 23 msbs of imm39 */
3946 t1 |= ((((val >> 0) & 0xfffffLL) << 13) /* imm20b */
3947 | (((val >> 59) & 0x1LL) << 36)) << 23; /* i */
3949 bfd_putl64 (t0, hit_addr);
3950 bfd_putl64 (t1, hit_addr + 8);
3954 switch ((long) hit_addr & 0x3)
3956 case 0: shift = 5; break;
3957 case 1: shift = 14; hit_addr += 3; break;
3958 case 2: shift = 23; hit_addr += 6; break;
3959 case 3: return bfd_reloc_notsupported; /* shouldn't happen... */
3961 dword = bfd_getl64 (hit_addr);
3962 insn = (dword >> shift) & 0x1ffffffffffLL;
3964 op = elf64_ia64_operands + opnd;
3965 err = (*op->insert) (op, val, &insn);
3967 return bfd_reloc_overflow;
3969 dword &= ~(0x1ffffffffffLL << shift);
3970 dword |= (insn << shift);
3971 bfd_putl64 (dword, hit_addr);
3975 /* A data relocation. */
3978 bfd_putb32 (val, hit_addr);
3980 bfd_putb64 (val, hit_addr);
3983 bfd_putl32 (val, hit_addr);
3985 bfd_putl64 (val, hit_addr);
3989 return bfd_reloc_ok;
3993 elfNN_ia64_install_dyn_reloc (abfd, info, sec, srel, offset, type,
3996 struct bfd_link_info *info;
4004 Elf_Internal_Rela outrel;
4007 BFD_ASSERT (dynindx != -1);
4008 outrel.r_info = ELFNN_R_INFO (dynindx, type);
4009 outrel.r_addend = addend;
4010 outrel.r_offset = _bfd_elf_section_offset (abfd, info, sec, offset);
4011 if (outrel.r_offset >= (bfd_vma) -2)
4013 /* Run for the hills. We shouldn't be outputting a relocation
4014 for this. So do what everyone else does and output a no-op. */
4015 outrel.r_info = ELFNN_R_INFO (0, R_IA64_NONE);
4016 outrel.r_addend = 0;
4017 outrel.r_offset = 0;
4020 outrel.r_offset += sec->output_section->vma + sec->output_offset;
4022 loc = srel->contents;
4023 loc += srel->reloc_count++ * sizeof (ElfNN_External_Rela);
4024 bfd_elfNN_swap_reloca_out (abfd, &outrel, loc);
4025 BFD_ASSERT (sizeof (ElfNN_External_Rela) * srel->reloc_count <= srel->size);
4028 /* Store an entry for target address TARGET_ADDR in the linkage table
4029 and return the gp-relative address of the linkage table entry. */
4032 set_got_entry (abfd, info, dyn_i, dynindx, addend, value, dyn_r_type)
4034 struct bfd_link_info *info;
4035 struct elfNN_ia64_dyn_sym_info *dyn_i;
4039 unsigned int dyn_r_type;
4041 struct elfNN_ia64_link_hash_table *ia64_info;
4046 ia64_info = elfNN_ia64_hash_table (info);
4047 got_sec = ia64_info->got_sec;
4051 case R_IA64_TPREL64LSB:
4052 done = dyn_i->tprel_done;
4053 dyn_i->tprel_done = TRUE;
4054 got_offset = dyn_i->tprel_offset;
4056 case R_IA64_DTPMOD64LSB:
4057 if (dyn_i->dtpmod_offset != ia64_info->self_dtpmod_offset)
4059 done = dyn_i->dtpmod_done;
4060 dyn_i->dtpmod_done = TRUE;
4064 done = ia64_info->self_dtpmod_done;
4065 ia64_info->self_dtpmod_done = TRUE;
4068 got_offset = dyn_i->dtpmod_offset;
4070 case R_IA64_DTPREL32LSB:
4071 case R_IA64_DTPREL64LSB:
4072 done = dyn_i->dtprel_done;
4073 dyn_i->dtprel_done = TRUE;
4074 got_offset = dyn_i->dtprel_offset;
4077 done = dyn_i->got_done;
4078 dyn_i->got_done = TRUE;
4079 got_offset = dyn_i->got_offset;
4083 BFD_ASSERT ((got_offset & 7) == 0);
4087 /* Store the target address in the linkage table entry. */
4088 bfd_put_64 (abfd, value, got_sec->contents + got_offset);
4090 /* Install a dynamic relocation if needed. */
4093 || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
4094 || dyn_i->h->root.type != bfd_link_hash_undefweak)
4095 && dyn_r_type != R_IA64_DTPREL32LSB
4096 && dyn_r_type != R_IA64_DTPREL64LSB)
4097 || elfNN_ia64_dynamic_symbol_p (dyn_i->h, info, dyn_r_type)
4099 && (dyn_r_type == R_IA64_FPTR32LSB
4100 || dyn_r_type == R_IA64_FPTR64LSB)))
4101 && (!dyn_i->want_ltoff_fptr
4104 || dyn_i->h->root.type != bfd_link_hash_undefweak))
4107 && dyn_r_type != R_IA64_TPREL64LSB
4108 && dyn_r_type != R_IA64_DTPMOD64LSB
4109 && dyn_r_type != R_IA64_DTPREL32LSB
4110 && dyn_r_type != R_IA64_DTPREL64LSB)
4112 dyn_r_type = R_IA64_RELNNLSB;
4117 if (bfd_big_endian (abfd))
4121 case R_IA64_REL32LSB:
4122 dyn_r_type = R_IA64_REL32MSB;
4124 case R_IA64_DIR32LSB:
4125 dyn_r_type = R_IA64_DIR32MSB;
4127 case R_IA64_FPTR32LSB:
4128 dyn_r_type = R_IA64_FPTR32MSB;
4130 case R_IA64_DTPREL32LSB:
4131 dyn_r_type = R_IA64_DTPREL32MSB;
4133 case R_IA64_REL64LSB:
4134 dyn_r_type = R_IA64_REL64MSB;
4136 case R_IA64_DIR64LSB:
4137 dyn_r_type = R_IA64_DIR64MSB;
4139 case R_IA64_FPTR64LSB:
4140 dyn_r_type = R_IA64_FPTR64MSB;
4142 case R_IA64_TPREL64LSB:
4143 dyn_r_type = R_IA64_TPREL64MSB;
4145 case R_IA64_DTPMOD64LSB:
4146 dyn_r_type = R_IA64_DTPMOD64MSB;
4148 case R_IA64_DTPREL64LSB:
4149 dyn_r_type = R_IA64_DTPREL64MSB;
4157 elfNN_ia64_install_dyn_reloc (abfd, NULL, got_sec,
4158 ia64_info->rel_got_sec,
4159 got_offset, dyn_r_type,
4164 /* Return the address of the linkage table entry. */
4165 value = (got_sec->output_section->vma
4166 + got_sec->output_offset
4172 /* Fill in a function descriptor consisting of the function's code
4173 address and its global pointer. Return the descriptor's address. */
4176 set_fptr_entry (abfd, info, dyn_i, value)
4178 struct bfd_link_info *info;
4179 struct elfNN_ia64_dyn_sym_info *dyn_i;
4182 struct elfNN_ia64_link_hash_table *ia64_info;
4185 ia64_info = elfNN_ia64_hash_table (info);
4186 fptr_sec = ia64_info->fptr_sec;
4188 if (!dyn_i->fptr_done)
4190 dyn_i->fptr_done = 1;
4192 /* Fill in the function descriptor. */
4193 bfd_put_64 (abfd, value, fptr_sec->contents + dyn_i->fptr_offset);
4194 bfd_put_64 (abfd, _bfd_get_gp_value (abfd),
4195 fptr_sec->contents + dyn_i->fptr_offset + 8);
4196 if (ia64_info->rel_fptr_sec)
4198 Elf_Internal_Rela outrel;
4201 if (bfd_little_endian (abfd))
4202 outrel.r_info = ELFNN_R_INFO (0, R_IA64_IPLTLSB);
4204 outrel.r_info = ELFNN_R_INFO (0, R_IA64_IPLTMSB);
4205 outrel.r_addend = value;
4206 outrel.r_offset = (fptr_sec->output_section->vma
4207 + fptr_sec->output_offset
4208 + dyn_i->fptr_offset);
4209 loc = ia64_info->rel_fptr_sec->contents;
4210 loc += ia64_info->rel_fptr_sec->reloc_count++
4211 * sizeof (ElfNN_External_Rela);
4212 bfd_elfNN_swap_reloca_out (abfd, &outrel, loc);
4216 /* Return the descriptor's address. */
4217 value = (fptr_sec->output_section->vma
4218 + fptr_sec->output_offset
4219 + dyn_i->fptr_offset);
4224 /* Fill in a PLTOFF entry consisting of the function's code address
4225 and its global pointer. Return the descriptor's address. */
4228 set_pltoff_entry (abfd, info, dyn_i, value, is_plt)
4230 struct bfd_link_info *info;
4231 struct elfNN_ia64_dyn_sym_info *dyn_i;
4235 struct elfNN_ia64_link_hash_table *ia64_info;
4236 asection *pltoff_sec;
4238 ia64_info = elfNN_ia64_hash_table (info);
4239 pltoff_sec = ia64_info->pltoff_sec;
4241 /* Don't do anything if this symbol uses a real PLT entry. In
4242 that case, we'll fill this in during finish_dynamic_symbol. */
4243 if ((! dyn_i->want_plt || is_plt)
4244 && !dyn_i->pltoff_done)
4246 bfd_vma gp = _bfd_get_gp_value (abfd);
4248 /* Fill in the function descriptor. */
4249 bfd_put_64 (abfd, value, pltoff_sec->contents + dyn_i->pltoff_offset);
4250 bfd_put_64 (abfd, gp, pltoff_sec->contents + dyn_i->pltoff_offset + 8);
4252 /* Install dynamic relocations if needed. */
4256 || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
4257 || dyn_i->h->root.type != bfd_link_hash_undefweak))
4259 unsigned int dyn_r_type;
4261 if (bfd_big_endian (abfd))
4262 dyn_r_type = R_IA64_RELNNMSB;
4264 dyn_r_type = R_IA64_RELNNLSB;
4266 elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
4267 ia64_info->rel_pltoff_sec,
4268 dyn_i->pltoff_offset,
4269 dyn_r_type, 0, value);
4270 elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
4271 ia64_info->rel_pltoff_sec,
4272 dyn_i->pltoff_offset + ARCH_SIZE / 8,
4276 dyn_i->pltoff_done = 1;
4279 /* Return the descriptor's address. */
4280 value = (pltoff_sec->output_section->vma
4281 + pltoff_sec->output_offset
4282 + dyn_i->pltoff_offset);
4287 /* Return the base VMA address which should be subtracted from real addresses
4288 when resolving @tprel() relocation.
4289 Main program TLS (whose template starts at PT_TLS p_vaddr)
4290 is assigned offset round(2 * size of pointer, PT_TLS p_align). */
4293 elfNN_ia64_tprel_base (info)
4294 struct bfd_link_info *info;
4296 asection *tls_sec = elf_hash_table (info)->tls_sec;
4298 BFD_ASSERT (tls_sec != NULL);
4299 return tls_sec->vma - align_power ((bfd_vma) ARCH_SIZE / 4,
4300 tls_sec->alignment_power);
4303 /* Return the base VMA address which should be subtracted from real addresses
4304 when resolving @dtprel() relocation.
4305 This is PT_TLS segment p_vaddr. */
4308 elfNN_ia64_dtprel_base (info)
4309 struct bfd_link_info *info;
4311 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4312 return elf_hash_table (info)->tls_sec->vma;
4315 /* Called through qsort to sort the .IA_64.unwind section during a
4316 non-relocatable link. Set elfNN_ia64_unwind_entry_compare_bfd
4317 to the output bfd so we can do proper endianness frobbing. */
4319 static bfd *elfNN_ia64_unwind_entry_compare_bfd;
4322 elfNN_ia64_unwind_entry_compare (a, b)
4328 av = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, a);
4329 bv = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, b);
4331 return (av < bv ? -1 : av > bv ? 1 : 0);
4334 /* Make sure we've got ourselves a nice fat __gp value. */
4336 elfNN_ia64_choose_gp (abfd, info)
4338 struct bfd_link_info *info;
4340 bfd_vma min_vma = (bfd_vma) -1, max_vma = 0;
4341 bfd_vma min_short_vma = min_vma, max_short_vma = 0;
4342 struct elf_link_hash_entry *gp;
4345 struct elfNN_ia64_link_hash_table *ia64_info;
4347 ia64_info = elfNN_ia64_hash_table (info);
4349 /* Find the min and max vma of all sections marked short. Also collect
4350 min and max vma of any type, for use in selecting a nice gp. */
4351 for (os = abfd->sections; os ; os = os->next)
4355 if ((os->flags & SEC_ALLOC) == 0)
4359 hi = os->vma + os->size;
4367 if (os->flags & SEC_SMALL_DATA)
4369 if (min_short_vma > lo)
4371 if (max_short_vma < hi)
4376 /* See if the user wants to force a value. */
4377 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
4381 && (gp->root.type == bfd_link_hash_defined
4382 || gp->root.type == bfd_link_hash_defweak))
4384 asection *gp_sec = gp->root.u.def.section;
4385 gp_val = (gp->root.u.def.value
4386 + gp_sec->output_section->vma
4387 + gp_sec->output_offset);
4391 /* Pick a sensible value. */
4393 asection *got_sec = ia64_info->got_sec;
4395 /* Start with just the address of the .got. */
4397 gp_val = got_sec->output_section->vma;
4398 else if (max_short_vma != 0)
4399 gp_val = min_short_vma;
4400 else if (max_vma - min_vma < 0x200000)
4403 gp_val = max_vma - 0x200000 + 8;
4405 /* If it is possible to address the entire image, but we
4406 don't with the choice above, adjust. */
4407 if (max_vma - min_vma < 0x400000
4408 && (max_vma - gp_val >= 0x200000
4409 || gp_val - min_vma > 0x200000))
4410 gp_val = min_vma + 0x200000;
4411 else if (max_short_vma != 0)
4413 /* If we don't cover all the short data, adjust. */
4414 if (max_short_vma - gp_val >= 0x200000)
4415 gp_val = min_short_vma + 0x200000;
4417 /* If we're addressing stuff past the end, adjust back. */
4418 if (gp_val > max_vma)
4419 gp_val = max_vma - 0x200000 + 8;
4423 /* Validate whether all SHF_IA_64_SHORT sections are within
4424 range of the chosen GP. */
4426 if (max_short_vma != 0)
4428 if (max_short_vma - min_short_vma >= 0x400000)
4430 (*_bfd_error_handler)
4431 (_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
4432 bfd_get_filename (abfd),
4433 (unsigned long) (max_short_vma - min_short_vma));
4436 else if ((gp_val > min_short_vma
4437 && gp_val - min_short_vma > 0x200000)
4438 || (gp_val < max_short_vma
4439 && max_short_vma - gp_val >= 0x200000))
4441 (*_bfd_error_handler)
4442 (_("%s: __gp does not cover short data segment"),
4443 bfd_get_filename (abfd));
4448 _bfd_set_gp_value (abfd, gp_val);
4454 elfNN_ia64_final_link (abfd, info)
4456 struct bfd_link_info *info;
4458 struct elfNN_ia64_link_hash_table *ia64_info;
4459 asection *unwind_output_sec;
4461 ia64_info = elfNN_ia64_hash_table (info);
4463 /* Make sure we've got ourselves a nice fat __gp value. */
4464 if (!info->relocatable)
4467 struct elf_link_hash_entry *gp;
4469 /* We assume after gp is set, section size will only decrease. We
4470 need to adjust gp for it. */
4471 _bfd_set_gp_value (abfd, 0);
4472 if (! elfNN_ia64_choose_gp (abfd, info))
4474 gp_val = _bfd_get_gp_value (abfd);
4476 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
4480 gp->root.type = bfd_link_hash_defined;
4481 gp->root.u.def.value = gp_val;
4482 gp->root.u.def.section = bfd_abs_section_ptr;
4486 /* If we're producing a final executable, we need to sort the contents
4487 of the .IA_64.unwind section. Force this section to be relocated
4488 into memory rather than written immediately to the output file. */
4489 unwind_output_sec = NULL;
4490 if (!info->relocatable)
4492 asection *s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind);
4495 unwind_output_sec = s->output_section;
4496 unwind_output_sec->contents
4497 = bfd_malloc (unwind_output_sec->size);
4498 if (unwind_output_sec->contents == NULL)
4503 /* Invoke the regular ELF backend linker to do all the work. */
4504 if (!bfd_elf_final_link (abfd, info))
4507 if (unwind_output_sec)
4509 elfNN_ia64_unwind_entry_compare_bfd = abfd;
4510 qsort (unwind_output_sec->contents,
4511 (size_t) (unwind_output_sec->size / 24),
4513 elfNN_ia64_unwind_entry_compare);
4515 if (! bfd_set_section_contents (abfd, unwind_output_sec,
4516 unwind_output_sec->contents, (bfd_vma) 0,
4517 unwind_output_sec->size))
4525 elfNN_ia64_relocate_section (output_bfd, info, input_bfd, input_section,
4526 contents, relocs, local_syms, local_sections)
4528 struct bfd_link_info *info;
4530 asection *input_section;
4532 Elf_Internal_Rela *relocs;
4533 Elf_Internal_Sym *local_syms;
4534 asection **local_sections;
4536 struct elfNN_ia64_link_hash_table *ia64_info;
4537 Elf_Internal_Shdr *symtab_hdr;
4538 Elf_Internal_Rela *rel;
4539 Elf_Internal_Rela *relend;
4541 bfd_boolean ret_val = TRUE; /* for non-fatal errors */
4544 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4545 ia64_info = elfNN_ia64_hash_table (info);
4547 /* Infect various flags from the input section to the output section. */
4548 if (info->relocatable)
4552 flags = elf_section_data(input_section)->this_hdr.sh_flags;
4553 flags &= SHF_IA_64_NORECOV;
4555 elf_section_data(input_section->output_section)
4556 ->this_hdr.sh_flags |= flags;
4560 gp_val = _bfd_get_gp_value (output_bfd);
4561 srel = get_reloc_section (input_bfd, ia64_info, input_section, FALSE);
4564 relend = relocs + input_section->reloc_count;
4565 for (; rel < relend; ++rel)
4567 struct elf_link_hash_entry *h;
4568 struct elfNN_ia64_dyn_sym_info *dyn_i;
4569 bfd_reloc_status_type r;
4570 reloc_howto_type *howto;
4571 unsigned long r_symndx;
4572 Elf_Internal_Sym *sym;
4573 unsigned int r_type;
4577 bfd_boolean dynamic_symbol_p;
4578 bfd_boolean undef_weak_ref;
4580 r_type = ELFNN_R_TYPE (rel->r_info);
4581 if (r_type > R_IA64_MAX_RELOC_CODE)
4583 (*_bfd_error_handler)
4584 (_("%B: unknown relocation type %d"),
4585 input_bfd, (int) r_type);
4586 bfd_set_error (bfd_error_bad_value);
4591 howto = lookup_howto (r_type);
4592 r_symndx = ELFNN_R_SYM (rel->r_info);
4596 undef_weak_ref = FALSE;
4598 if (r_symndx < symtab_hdr->sh_info)
4600 /* Reloc against local symbol. */
4602 sym = local_syms + r_symndx;
4603 sym_sec = local_sections[r_symndx];
4605 value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
4606 if ((sym_sec->flags & SEC_MERGE)
4607 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
4608 && sym_sec->sec_info_type == ELF_INFO_TYPE_MERGE)
4610 struct elfNN_ia64_local_hash_entry *loc_h;
4612 loc_h = get_local_sym_hash (ia64_info, input_bfd, rel, FALSE);
4613 if (loc_h && ! loc_h->sec_merge_done)
4615 struct elfNN_ia64_dyn_sym_info *dynent;
4618 for (count = loc_h->count, dynent = loc_h->info;
4624 _bfd_merged_section_offset (output_bfd, &msec,
4625 elf_section_data (msec)->
4629 dynent->addend -= sym->st_value;
4630 dynent->addend += msec->output_section->vma
4631 + msec->output_offset
4632 - sym_sec->output_section->vma
4633 - sym_sec->output_offset;
4636 qsort (loc_h->info, loc_h->count,
4637 sizeof (*loc_h->info), addend_compare);
4639 loc_h->sec_merge_done = 1;
4645 bfd_boolean unresolved_reloc;
4647 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
4649 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4650 r_symndx, symtab_hdr, sym_hashes,
4652 unresolved_reloc, warned);
4654 if (h->root.type == bfd_link_hash_undefweak)
4655 undef_weak_ref = TRUE;
4660 hit_addr = contents + rel->r_offset;
4661 value += rel->r_addend;
4662 dynamic_symbol_p = elfNN_ia64_dynamic_symbol_p (h, info, r_type);
4673 case R_IA64_DIR32MSB:
4674 case R_IA64_DIR32LSB:
4675 case R_IA64_DIR64MSB:
4676 case R_IA64_DIR64LSB:
4677 /* Install a dynamic relocation for this reloc. */
4678 if ((dynamic_symbol_p || info->shared)
4680 && (input_section->flags & SEC_ALLOC) != 0)
4682 unsigned int dyn_r_type;
4686 BFD_ASSERT (srel != NULL);
4693 /* ??? People shouldn't be doing non-pic code in
4694 shared libraries nor dynamic executables. */
4695 (*_bfd_error_handler)
4696 (_("%B: non-pic code with imm relocation against dynamic symbol `%s'"),
4698 h ? h->root.root.string
4699 : bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4708 /* If we don't need dynamic symbol lookup, find a
4709 matching RELATIVE relocation. */
4710 dyn_r_type = r_type;
4711 if (dynamic_symbol_p)
4713 dynindx = h->dynindx;
4714 addend = rel->r_addend;
4721 case R_IA64_DIR32MSB:
4722 dyn_r_type = R_IA64_REL32MSB;
4724 case R_IA64_DIR32LSB:
4725 dyn_r_type = R_IA64_REL32LSB;
4727 case R_IA64_DIR64MSB:
4728 dyn_r_type = R_IA64_REL64MSB;
4730 case R_IA64_DIR64LSB:
4731 dyn_r_type = R_IA64_REL64LSB;
4741 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4742 srel, rel->r_offset, dyn_r_type,
4747 case R_IA64_LTV32MSB:
4748 case R_IA64_LTV32LSB:
4749 case R_IA64_LTV64MSB:
4750 case R_IA64_LTV64LSB:
4751 r = elfNN_ia64_install_value (hit_addr, value, r_type);
4754 case R_IA64_GPREL22:
4755 case R_IA64_GPREL64I:
4756 case R_IA64_GPREL32MSB:
4757 case R_IA64_GPREL32LSB:
4758 case R_IA64_GPREL64MSB:
4759 case R_IA64_GPREL64LSB:
4760 if (dynamic_symbol_p)
4762 (*_bfd_error_handler)
4763 (_("%B: @gprel relocation against dynamic symbol %s"),
4765 h ? h->root.root.string
4766 : bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4772 r = elfNN_ia64_install_value (hit_addr, value, r_type);
4775 case R_IA64_LTOFF22:
4776 case R_IA64_LTOFF22X:
4777 case R_IA64_LTOFF64I:
4778 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4779 value = set_got_entry (input_bfd, info, dyn_i, (h ? h->dynindx : -1),
4780 rel->r_addend, value, R_IA64_DIRNNLSB);
4782 r = elfNN_ia64_install_value (hit_addr, value, r_type);
4785 case R_IA64_PLTOFF22:
4786 case R_IA64_PLTOFF64I:
4787 case R_IA64_PLTOFF64MSB:
4788 case R_IA64_PLTOFF64LSB:
4789 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4790 value = set_pltoff_entry (output_bfd, info, dyn_i, value, FALSE);
4792 r = elfNN_ia64_install_value (hit_addr, value, r_type);
4795 case R_IA64_FPTR64I:
4796 case R_IA64_FPTR32MSB:
4797 case R_IA64_FPTR32LSB:
4798 case R_IA64_FPTR64MSB:
4799 case R_IA64_FPTR64LSB:
4800 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4801 if (dyn_i->want_fptr)
4803 if (!undef_weak_ref)
4804 value = set_fptr_entry (output_bfd, info, dyn_i, value);
4806 if (!dyn_i->want_fptr || info->pie)
4809 unsigned int dyn_r_type = r_type;
4810 bfd_vma addend = rel->r_addend;
4812 /* Otherwise, we expect the dynamic linker to create
4815 if (dyn_i->want_fptr)
4817 if (r_type == R_IA64_FPTR64I)
4819 /* We can't represent this without a dynamic symbol.
4820 Adjust the relocation to be against an output
4821 section symbol, which are always present in the
4822 dynamic symbol table. */
4823 /* ??? People shouldn't be doing non-pic code in
4824 shared libraries. Hork. */
4825 (*_bfd_error_handler)
4826 (_("%B: linking non-pic code in a position independent executable"),
4833 dyn_r_type = r_type + R_IA64_RELNNLSB - R_IA64_FPTRNNLSB;
4837 if (h->dynindx != -1)
4838 dynindx = h->dynindx;
4840 dynindx = (_bfd_elf_link_lookup_local_dynindx
4841 (info, h->root.u.def.section->owner,
4842 global_sym_index (h)));
4847 dynindx = (_bfd_elf_link_lookup_local_dynindx
4848 (info, input_bfd, (long) r_symndx));
4852 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4853 srel, rel->r_offset, dyn_r_type,
4857 r = elfNN_ia64_install_value (hit_addr, value, r_type);
4860 case R_IA64_LTOFF_FPTR22:
4861 case R_IA64_LTOFF_FPTR64I:
4862 case R_IA64_LTOFF_FPTR32MSB:
4863 case R_IA64_LTOFF_FPTR32LSB:
4864 case R_IA64_LTOFF_FPTR64MSB:
4865 case R_IA64_LTOFF_FPTR64LSB:
4869 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4870 if (dyn_i->want_fptr)
4872 BFD_ASSERT (h == NULL || h->dynindx == -1);
4873 if (!undef_weak_ref)
4874 value = set_fptr_entry (output_bfd, info, dyn_i, value);
4879 /* Otherwise, we expect the dynamic linker to create
4883 if (h->dynindx != -1)
4884 dynindx = h->dynindx;
4886 dynindx = (_bfd_elf_link_lookup_local_dynindx
4887 (info, h->root.u.def.section->owner,
4888 global_sym_index (h)));
4891 dynindx = (_bfd_elf_link_lookup_local_dynindx
4892 (info, input_bfd, (long) r_symndx));
4896 value = set_got_entry (output_bfd, info, dyn_i, dynindx,
4897 rel->r_addend, value, R_IA64_FPTRNNLSB);
4899 r = elfNN_ia64_install_value (hit_addr, value, r_type);
4903 case R_IA64_PCREL32MSB:
4904 case R_IA64_PCREL32LSB:
4905 case R_IA64_PCREL64MSB:
4906 case R_IA64_PCREL64LSB:
4907 /* Install a dynamic relocation for this reloc. */
4908 if (dynamic_symbol_p && r_symndx != 0)
4910 BFD_ASSERT (srel != NULL);
4912 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4913 srel, rel->r_offset, r_type,
4914 h->dynindx, rel->r_addend);
4918 case R_IA64_PCREL21B:
4919 case R_IA64_PCREL60B:
4920 /* We should have created a PLT entry for any dynamic symbol. */
4923 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE);
4925 if (dyn_i && dyn_i->want_plt2)
4927 /* Should have caught this earlier. */
4928 BFD_ASSERT (rel->r_addend == 0);
4930 value = (ia64_info->plt_sec->output_section->vma
4931 + ia64_info->plt_sec->output_offset
4932 + dyn_i->plt2_offset);
4936 /* Since there's no PLT entry, Validate that this is
4938 BFD_ASSERT (undef_weak_ref || sym_sec->output_section != NULL);
4940 /* If the symbol is undef_weak, we shouldn't be trying
4941 to call it. There's every chance that we'd wind up
4942 with an out-of-range fixup here. Don't bother setting
4943 any value at all. */
4949 case R_IA64_PCREL21BI:
4950 case R_IA64_PCREL21F:
4951 case R_IA64_PCREL21M:
4952 case R_IA64_PCREL22:
4953 case R_IA64_PCREL64I:
4954 /* The PCREL21BI reloc is specifically not intended for use with
4955 dynamic relocs. PCREL21F and PCREL21M are used for speculation
4956 fixup code, and thus probably ought not be dynamic. The
4957 PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs. */
4958 if (dynamic_symbol_p)
4962 if (r_type == R_IA64_PCREL21BI)
4963 msg = _("%B: @internal branch to dynamic symbol %s");
4964 else if (r_type == R_IA64_PCREL21F || r_type == R_IA64_PCREL21M)
4965 msg = _("%B: speculation fixup to dynamic symbol %s");
4967 msg = _("%B: @pcrel relocation against dynamic symbol %s");
4968 (*_bfd_error_handler) (msg, input_bfd,
4969 h ? h->root.root.string
4970 : bfd_elf_sym_name (input_bfd,
4980 /* Make pc-relative. */
4981 value -= (input_section->output_section->vma
4982 + input_section->output_offset
4983 + rel->r_offset) & ~ (bfd_vma) 0x3;
4984 r = elfNN_ia64_install_value (hit_addr, value, r_type);
4987 case R_IA64_SEGREL32MSB:
4988 case R_IA64_SEGREL32LSB:
4989 case R_IA64_SEGREL64MSB:
4990 case R_IA64_SEGREL64LSB:
4993 /* If the input section was discarded from the output, then
4999 struct elf_segment_map *m;
5000 Elf_Internal_Phdr *p;
5002 /* Find the segment that contains the output_section. */
5003 for (m = elf_tdata (output_bfd)->segment_map,
5004 p = elf_tdata (output_bfd)->phdr;
5009 for (i = m->count - 1; i >= 0; i--)
5010 if (m->sections[i] == input_section->output_section)
5018 r = bfd_reloc_notsupported;
5022 /* The VMA of the segment is the vaddr of the associated
5024 if (value > p->p_vaddr)
5025 value -= p->p_vaddr;
5028 r = elfNN_ia64_install_value (hit_addr, value, r_type);
5033 case R_IA64_SECREL32MSB:
5034 case R_IA64_SECREL32LSB:
5035 case R_IA64_SECREL64MSB:
5036 case R_IA64_SECREL64LSB:
5037 /* Make output-section relative to section where the symbol
5038 is defined. PR 475 */
5040 value -= sym_sec->output_section->vma;
5041 r = elfNN_ia64_install_value (hit_addr, value, r_type);
5044 case R_IA64_IPLTMSB:
5045 case R_IA64_IPLTLSB:
5046 /* Install a dynamic relocation for this reloc. */
5047 if ((dynamic_symbol_p || info->shared)
5048 && (input_section->flags & SEC_ALLOC) != 0)
5050 BFD_ASSERT (srel != NULL);
5052 /* If we don't need dynamic symbol lookup, install two
5053 RELATIVE relocations. */
5054 if (!dynamic_symbol_p)
5056 unsigned int dyn_r_type;
5058 if (r_type == R_IA64_IPLTMSB)
5059 dyn_r_type = R_IA64_REL64MSB;
5061 dyn_r_type = R_IA64_REL64LSB;
5063 elfNN_ia64_install_dyn_reloc (output_bfd, info,
5065 srel, rel->r_offset,
5066 dyn_r_type, 0, value);
5067 elfNN_ia64_install_dyn_reloc (output_bfd, info,
5069 srel, rel->r_offset + 8,
5070 dyn_r_type, 0, gp_val);
5073 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
5074 srel, rel->r_offset, r_type,
5075 h->dynindx, rel->r_addend);
5078 if (r_type == R_IA64_IPLTMSB)
5079 r_type = R_IA64_DIR64MSB;
5081 r_type = R_IA64_DIR64LSB;
5082 elfNN_ia64_install_value (hit_addr, value, r_type);
5083 r = elfNN_ia64_install_value (hit_addr + 8, gp_val, r_type);
5086 case R_IA64_TPREL14:
5087 case R_IA64_TPREL22:
5088 case R_IA64_TPREL64I:
5089 value -= elfNN_ia64_tprel_base (info);
5090 r = elfNN_ia64_install_value (hit_addr, value, r_type);
5093 case R_IA64_DTPREL14:
5094 case R_IA64_DTPREL22:
5095 case R_IA64_DTPREL64I:
5096 case R_IA64_DTPREL32LSB:
5097 case R_IA64_DTPREL32MSB:
5098 case R_IA64_DTPREL64LSB:
5099 case R_IA64_DTPREL64MSB:
5100 value -= elfNN_ia64_dtprel_base (info);
5101 r = elfNN_ia64_install_value (hit_addr, value, r_type);
5104 case R_IA64_LTOFF_TPREL22:
5105 case R_IA64_LTOFF_DTPMOD22:
5106 case R_IA64_LTOFF_DTPREL22:
5109 long dynindx = h ? h->dynindx : -1;
5110 bfd_vma r_addend = rel->r_addend;
5115 case R_IA64_LTOFF_TPREL22:
5116 if (!dynamic_symbol_p)
5119 value -= elfNN_ia64_tprel_base (info);
5122 r_addend += value - elfNN_ia64_dtprel_base (info);
5126 got_r_type = R_IA64_TPREL64LSB;
5128 case R_IA64_LTOFF_DTPMOD22:
5129 if (!dynamic_symbol_p && !info->shared)
5131 got_r_type = R_IA64_DTPMOD64LSB;
5133 case R_IA64_LTOFF_DTPREL22:
5134 if (!dynamic_symbol_p)
5135 value -= elfNN_ia64_dtprel_base (info);
5136 got_r_type = R_IA64_DTPRELNNLSB;
5139 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
5140 value = set_got_entry (input_bfd, info, dyn_i, dynindx, r_addend,
5143 r = elfNN_ia64_install_value (hit_addr, value, r_type);
5148 r = bfd_reloc_notsupported;
5157 case bfd_reloc_undefined:
5158 /* This can happen for global table relative relocs if
5159 __gp is undefined. This is a panic situation so we
5160 don't try to continue. */
5161 (*info->callbacks->undefined_symbol)
5162 (info, "__gp", input_bfd, input_section, rel->r_offset, 1);
5165 case bfd_reloc_notsupported:
5170 name = h->root.root.string;
5172 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
5174 if (!(*info->callbacks->warning) (info, _("unsupported reloc"),
5176 input_section, rel->r_offset))
5182 case bfd_reloc_dangerous:
5183 case bfd_reloc_outofrange:
5184 case bfd_reloc_overflow:
5190 name = h->root.root.string;
5192 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
5197 case R_IA64_PCREL21B:
5198 case R_IA64_PCREL21BI:
5199 case R_IA64_PCREL21M:
5200 case R_IA64_PCREL21F:
5201 if (is_elf_hash_table (info->hash))
5203 /* Relaxtion is always performed for ELF output.
5204 Overflow failures for those relocations mean
5205 that the section is too big to relax. */
5206 (*_bfd_error_handler)
5207 (_("%B: Can't relax br (%s) to `%s' at 0x%lx in section `%A' with size 0x%lx (> 0x1000000)."),
5208 input_bfd, input_section, howto->name, name,
5209 rel->r_offset, input_section->size);
5213 if (!(*info->callbacks->reloc_overflow) (info,
5235 elfNN_ia64_finish_dynamic_symbol (output_bfd, info, h, sym)
5237 struct bfd_link_info *info;
5238 struct elf_link_hash_entry *h;
5239 Elf_Internal_Sym *sym;
5241 struct elfNN_ia64_link_hash_table *ia64_info;
5242 struct elfNN_ia64_dyn_sym_info *dyn_i;
5244 ia64_info = elfNN_ia64_hash_table (info);
5245 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE);
5247 /* Fill in the PLT data, if required. */
5248 if (dyn_i && dyn_i->want_plt)
5250 Elf_Internal_Rela outrel;
5253 bfd_vma plt_addr, pltoff_addr, gp_val, index;
5255 gp_val = _bfd_get_gp_value (output_bfd);
5257 /* Initialize the minimal PLT entry. */
5259 index = (dyn_i->plt_offset - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
5260 plt_sec = ia64_info->plt_sec;
5261 loc = plt_sec->contents + dyn_i->plt_offset;
5263 memcpy (loc, plt_min_entry, PLT_MIN_ENTRY_SIZE);
5264 elfNN_ia64_install_value (loc, index, R_IA64_IMM22);
5265 elfNN_ia64_install_value (loc+2, -dyn_i->plt_offset, R_IA64_PCREL21B);
5267 plt_addr = (plt_sec->output_section->vma
5268 + plt_sec->output_offset
5269 + dyn_i->plt_offset);
5270 pltoff_addr = set_pltoff_entry (output_bfd, info, dyn_i, plt_addr, TRUE);
5272 /* Initialize the FULL PLT entry, if needed. */
5273 if (dyn_i->want_plt2)
5275 loc = plt_sec->contents + dyn_i->plt2_offset;
5277 memcpy (loc, plt_full_entry, PLT_FULL_ENTRY_SIZE);
5278 elfNN_ia64_install_value (loc, pltoff_addr - gp_val, R_IA64_IMM22);
5280 /* Mark the symbol as undefined, rather than as defined in the
5281 plt section. Leave the value alone. */
5282 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
5283 first place. But perhaps elflink.c did some for us. */
5284 if (!h->def_regular)
5285 sym->st_shndx = SHN_UNDEF;
5288 /* Create the dynamic relocation. */
5289 outrel.r_offset = pltoff_addr;
5290 if (bfd_little_endian (output_bfd))
5291 outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTLSB);
5293 outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTMSB);
5294 outrel.r_addend = 0;
5296 /* This is fun. In the .IA_64.pltoff section, we've got entries
5297 that correspond both to real PLT entries, and those that
5298 happened to resolve to local symbols but need to be created
5299 to satisfy @pltoff relocations. The .rela.IA_64.pltoff
5300 relocations for the real PLT should come at the end of the
5301 section, so that they can be indexed by plt entry at runtime.
5303 We emitted all of the relocations for the non-PLT @pltoff
5304 entries during relocate_section. So we can consider the
5305 existing sec->reloc_count to be the base of the array of
5308 loc = ia64_info->rel_pltoff_sec->contents;
5309 loc += ((ia64_info->rel_pltoff_sec->reloc_count + index)
5310 * sizeof (ElfNN_External_Rela));
5311 bfd_elfNN_swap_reloca_out (output_bfd, &outrel, loc);
5314 /* Mark some specially defined symbols as absolute. */
5315 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
5316 || h == ia64_info->root.hgot
5317 || h == ia64_info->root.hplt)
5318 sym->st_shndx = SHN_ABS;
5324 elfNN_ia64_finish_dynamic_sections (abfd, info)
5326 struct bfd_link_info *info;
5328 struct elfNN_ia64_link_hash_table *ia64_info;
5331 ia64_info = elfNN_ia64_hash_table (info);
5332 dynobj = ia64_info->root.dynobj;
5334 if (elf_hash_table (info)->dynamic_sections_created)
5336 ElfNN_External_Dyn *dyncon, *dynconend;
5337 asection *sdyn, *sgotplt;
5340 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5341 sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
5342 BFD_ASSERT (sdyn != NULL);
5343 dyncon = (ElfNN_External_Dyn *) sdyn->contents;
5344 dynconend = (ElfNN_External_Dyn *) (sdyn->contents + sdyn->size);
5346 gp_val = _bfd_get_gp_value (abfd);
5348 for (; dyncon < dynconend; dyncon++)
5350 Elf_Internal_Dyn dyn;
5352 bfd_elfNN_swap_dyn_in (dynobj, dyncon, &dyn);
5357 dyn.d_un.d_ptr = gp_val;
5361 dyn.d_un.d_val = (ia64_info->minplt_entries
5362 * sizeof (ElfNN_External_Rela));
5366 /* See the comment above in finish_dynamic_symbol. */
5367 dyn.d_un.d_ptr = (ia64_info->rel_pltoff_sec->output_section->vma
5368 + ia64_info->rel_pltoff_sec->output_offset
5369 + (ia64_info->rel_pltoff_sec->reloc_count
5370 * sizeof (ElfNN_External_Rela)));
5373 case DT_IA_64_PLT_RESERVE:
5374 dyn.d_un.d_ptr = (sgotplt->output_section->vma
5375 + sgotplt->output_offset);
5379 /* Do not have RELASZ include JMPREL. This makes things
5380 easier on ld.so. This is not what the rest of BFD set up. */
5381 dyn.d_un.d_val -= (ia64_info->minplt_entries
5382 * sizeof (ElfNN_External_Rela));
5386 bfd_elfNN_swap_dyn_out (abfd, &dyn, dyncon);
5389 /* Initialize the PLT0 entry. */
5390 if (ia64_info->plt_sec)
5392 bfd_byte *loc = ia64_info->plt_sec->contents;
5395 memcpy (loc, plt_header, PLT_HEADER_SIZE);
5397 pltres = (sgotplt->output_section->vma
5398 + sgotplt->output_offset
5401 elfNN_ia64_install_value (loc+1, pltres, R_IA64_GPREL22);
5408 /* ELF file flag handling: */
5410 /* Function to keep IA-64 specific file flags. */
5412 elfNN_ia64_set_private_flags (abfd, flags)
5416 BFD_ASSERT (!elf_flags_init (abfd)
5417 || elf_elfheader (abfd)->e_flags == flags);
5419 elf_elfheader (abfd)->e_flags = flags;
5420 elf_flags_init (abfd) = TRUE;
5424 /* Merge backend specific data from an object file to the output
5425 object file when linking. */
5427 elfNN_ia64_merge_private_bfd_data (ibfd, obfd)
5432 bfd_boolean ok = TRUE;
5434 /* Don't even pretend to support mixed-format linking. */
5435 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5436 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5439 in_flags = elf_elfheader (ibfd)->e_flags;
5440 out_flags = elf_elfheader (obfd)->e_flags;
5442 if (! elf_flags_init (obfd))
5444 elf_flags_init (obfd) = TRUE;
5445 elf_elfheader (obfd)->e_flags = in_flags;
5447 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
5448 && bfd_get_arch_info (obfd)->the_default)
5450 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
5451 bfd_get_mach (ibfd));
5457 /* Check flag compatibility. */
5458 if (in_flags == out_flags)
5461 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
5462 if (!(in_flags & EF_IA_64_REDUCEDFP) && (out_flags & EF_IA_64_REDUCEDFP))
5463 elf_elfheader (obfd)->e_flags &= ~EF_IA_64_REDUCEDFP;
5465 if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL))
5467 (*_bfd_error_handler)
5468 (_("%B: linking trap-on-NULL-dereference with non-trapping files"),
5471 bfd_set_error (bfd_error_bad_value);
5474 if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE))
5476 (*_bfd_error_handler)
5477 (_("%B: linking big-endian files with little-endian files"),
5480 bfd_set_error (bfd_error_bad_value);
5483 if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64))
5485 (*_bfd_error_handler)
5486 (_("%B: linking 64-bit files with 32-bit files"),
5489 bfd_set_error (bfd_error_bad_value);
5492 if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP))
5494 (*_bfd_error_handler)
5495 (_("%B: linking constant-gp files with non-constant-gp files"),
5498 bfd_set_error (bfd_error_bad_value);
5501 if ((in_flags & EF_IA_64_NOFUNCDESC_CONS_GP)
5502 != (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
5504 (*_bfd_error_handler)
5505 (_("%B: linking auto-pic files with non-auto-pic files"),
5508 bfd_set_error (bfd_error_bad_value);
5516 elfNN_ia64_print_private_bfd_data (abfd, ptr)
5520 FILE *file = (FILE *) ptr;
5521 flagword flags = elf_elfheader (abfd)->e_flags;
5523 BFD_ASSERT (abfd != NULL && ptr != NULL);
5525 fprintf (file, "private flags = %s%s%s%s%s%s%s%s\n",
5526 (flags & EF_IA_64_TRAPNIL) ? "TRAPNIL, " : "",
5527 (flags & EF_IA_64_EXT) ? "EXT, " : "",
5528 (flags & EF_IA_64_BE) ? "BE, " : "LE, ",
5529 (flags & EF_IA_64_REDUCEDFP) ? "REDUCEDFP, " : "",
5530 (flags & EF_IA_64_CONS_GP) ? "CONS_GP, " : "",
5531 (flags & EF_IA_64_NOFUNCDESC_CONS_GP) ? "NOFUNCDESC_CONS_GP, " : "",
5532 (flags & EF_IA_64_ABSOLUTE) ? "ABSOLUTE, " : "",
5533 (flags & EF_IA_64_ABI64) ? "ABI64" : "ABI32");
5535 _bfd_elf_print_private_bfd_data (abfd, ptr);
5539 static enum elf_reloc_type_class
5540 elfNN_ia64_reloc_type_class (rela)
5541 const Elf_Internal_Rela *rela;
5543 switch ((int) ELFNN_R_TYPE (rela->r_info))
5545 case R_IA64_REL32MSB:
5546 case R_IA64_REL32LSB:
5547 case R_IA64_REL64MSB:
5548 case R_IA64_REL64LSB:
5549 return reloc_class_relative;
5550 case R_IA64_IPLTMSB:
5551 case R_IA64_IPLTLSB:
5552 return reloc_class_plt;
5554 return reloc_class_copy;
5556 return reloc_class_normal;
5560 static const struct bfd_elf_special_section elfNN_ia64_special_sections[] =
5562 { ".sbss", 5, -1, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
5563 { ".sdata", 6, -1, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
5564 { NULL, 0, 0, 0, 0 }
5568 elfNN_ia64_object_p (bfd *abfd)
5571 asection *group, *unwi, *unw;
5574 char *unwi_name, *unw_name;
5577 if (abfd->flags & DYNAMIC)
5580 /* Flags for fake group section. */
5581 flags = (SEC_LINKER_CREATED | SEC_GROUP | SEC_LINK_ONCE
5584 /* We add a fake section group for each .gnu.linkonce.t.* section,
5585 which isn't in a section group, and its unwind sections. */
5586 for (sec = abfd->sections; sec != NULL; sec = sec->next)
5588 if (elf_sec_group (sec) == NULL
5589 && ((sec->flags & (SEC_LINK_ONCE | SEC_CODE | SEC_GROUP))
5590 == (SEC_LINK_ONCE | SEC_CODE))
5591 && strncmp (sec->name, ".gnu.linkonce.t.", 16) == 0)
5593 name = sec->name + 16;
5595 amt = strlen (name) + sizeof (".gnu.linkonce.ia64unwi.");
5596 unwi_name = bfd_alloc (abfd, amt);
5600 strcpy (stpcpy (unwi_name, ".gnu.linkonce.ia64unwi."), name);
5601 unwi = bfd_get_section_by_name (abfd, unwi_name);
5603 amt = strlen (name) + sizeof (".gnu.linkonce.ia64unw.");
5604 unw_name = bfd_alloc (abfd, amt);
5608 strcpy (stpcpy (unw_name, ".gnu.linkonce.ia64unw."), name);
5609 unw = bfd_get_section_by_name (abfd, unw_name);
5611 /* We need to create a fake group section for it and its
5613 group = bfd_make_section_anyway_with_flags (abfd, name,
5618 /* Move the fake group section to the beginning. */
5619 bfd_section_list_remove (abfd, group);
5620 bfd_section_list_prepend (abfd, group);
5622 elf_next_in_group (group) = sec;
5624 elf_group_name (sec) = name;
5625 elf_next_in_group (sec) = sec;
5626 elf_sec_group (sec) = group;
5630 elf_group_name (unwi) = name;
5631 elf_next_in_group (unwi) = sec;
5632 elf_next_in_group (sec) = unwi;
5633 elf_sec_group (unwi) = group;
5638 elf_group_name (unw) = name;
5641 elf_next_in_group (unw) = elf_next_in_group (unwi);
5642 elf_next_in_group (unwi) = unw;
5646 elf_next_in_group (unw) = sec;
5647 elf_next_in_group (sec) = unw;
5649 elf_sec_group (unw) = group;
5652 /* Fake SHT_GROUP section header. */
5653 elf_section_data (group)->this_hdr.bfd_section = group;
5654 elf_section_data (group)->this_hdr.sh_type = SHT_GROUP;
5661 elfNN_ia64_hpux_vec (const bfd_target *vec)
5663 extern const bfd_target bfd_elfNN_ia64_hpux_big_vec;
5664 return (vec == & bfd_elfNN_ia64_hpux_big_vec);
5668 elfNN_hpux_post_process_headers (abfd, info)
5670 struct bfd_link_info *info ATTRIBUTE_UNUSED;
5672 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
5674 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_HPUX;
5675 i_ehdrp->e_ident[EI_ABIVERSION] = 1;
5679 elfNN_hpux_backend_section_from_bfd_section (abfd, sec, retval)
5680 bfd *abfd ATTRIBUTE_UNUSED;
5684 if (bfd_is_com_section (sec))
5686 *retval = SHN_IA_64_ANSI_COMMON;
5693 elfNN_hpux_backend_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
5696 elf_symbol_type *elfsym = (elf_symbol_type *) asym;
5698 switch (elfsym->internal_elf_sym.st_shndx)
5700 case SHN_IA_64_ANSI_COMMON:
5701 asym->section = bfd_com_section_ptr;
5702 asym->value = elfsym->internal_elf_sym.st_size;
5703 asym->flags &= ~BSF_GLOBAL;
5709 #define TARGET_LITTLE_SYM bfd_elfNN_ia64_little_vec
5710 #define TARGET_LITTLE_NAME "elfNN-ia64-little"
5711 #define TARGET_BIG_SYM bfd_elfNN_ia64_big_vec
5712 #define TARGET_BIG_NAME "elfNN-ia64-big"
5713 #define ELF_ARCH bfd_arch_ia64
5714 #define ELF_MACHINE_CODE EM_IA_64
5715 #define ELF_MACHINE_ALT1 1999 /* EAS2.3 */
5716 #define ELF_MACHINE_ALT2 1998 /* EAS2.2 */
5717 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
5718 #define ELF_COMMONPAGESIZE 0x4000 /* 16KB */
5720 #define elf_backend_section_from_shdr \
5721 elfNN_ia64_section_from_shdr
5722 #define elf_backend_section_flags \
5723 elfNN_ia64_section_flags
5724 #define elf_backend_fake_sections \
5725 elfNN_ia64_fake_sections
5726 #define elf_backend_final_write_processing \
5727 elfNN_ia64_final_write_processing
5728 #define elf_backend_add_symbol_hook \
5729 elfNN_ia64_add_symbol_hook
5730 #define elf_backend_additional_program_headers \
5731 elfNN_ia64_additional_program_headers
5732 #define elf_backend_modify_segment_map \
5733 elfNN_ia64_modify_segment_map
5734 #define elf_info_to_howto \
5735 elfNN_ia64_info_to_howto
5737 #define bfd_elfNN_bfd_reloc_type_lookup \
5738 elfNN_ia64_reloc_type_lookup
5739 #define bfd_elfNN_bfd_is_local_label_name \
5740 elfNN_ia64_is_local_label_name
5741 #define bfd_elfNN_bfd_relax_section \
5742 elfNN_ia64_relax_section
5744 #define elf_backend_object_p \
5747 /* Stuff for the BFD linker: */
5748 #define bfd_elfNN_bfd_link_hash_table_create \
5749 elfNN_ia64_hash_table_create
5750 #define bfd_elfNN_bfd_link_hash_table_free \
5751 elfNN_ia64_hash_table_free
5752 #define elf_backend_create_dynamic_sections \
5753 elfNN_ia64_create_dynamic_sections
5754 #define elf_backend_check_relocs \
5755 elfNN_ia64_check_relocs
5756 #define elf_backend_adjust_dynamic_symbol \
5757 elfNN_ia64_adjust_dynamic_symbol
5758 #define elf_backend_size_dynamic_sections \
5759 elfNN_ia64_size_dynamic_sections
5760 #define elf_backend_relocate_section \
5761 elfNN_ia64_relocate_section
5762 #define elf_backend_finish_dynamic_symbol \
5763 elfNN_ia64_finish_dynamic_symbol
5764 #define elf_backend_finish_dynamic_sections \
5765 elfNN_ia64_finish_dynamic_sections
5766 #define bfd_elfNN_bfd_final_link \
5767 elfNN_ia64_final_link
5769 #define bfd_elfNN_bfd_merge_private_bfd_data \
5770 elfNN_ia64_merge_private_bfd_data
5771 #define bfd_elfNN_bfd_set_private_flags \
5772 elfNN_ia64_set_private_flags
5773 #define bfd_elfNN_bfd_print_private_bfd_data \
5774 elfNN_ia64_print_private_bfd_data
5776 #define elf_backend_plt_readonly 1
5777 #define elf_backend_want_plt_sym 0
5778 #define elf_backend_plt_alignment 5
5779 #define elf_backend_got_header_size 0
5780 #define elf_backend_want_got_plt 1
5781 #define elf_backend_may_use_rel_p 1
5782 #define elf_backend_may_use_rela_p 1
5783 #define elf_backend_default_use_rela_p 1
5784 #define elf_backend_want_dynbss 0
5785 #define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect
5786 #define elf_backend_hide_symbol elfNN_ia64_hash_hide_symbol
5787 #define elf_backend_fixup_symbol _bfd_elf_link_hash_fixup_symbol
5788 #define elf_backend_reloc_type_class elfNN_ia64_reloc_type_class
5789 #define elf_backend_rela_normal 1
5790 #define elf_backend_special_sections elfNN_ia64_special_sections
5792 /* FIXME: PR 290: The Intel C compiler generates SHT_IA_64_UNWIND with
5793 SHF_LINK_ORDER. But it doesn't set the sh_link or sh_info fields.
5794 We don't want to flood users with so many error messages. We turn
5795 off the warning for now. It will be turned on later when the Intel
5796 compiler is fixed. */
5797 #define elf_backend_link_order_error_handler NULL
5799 #include "elfNN-target.h"
5801 /* HPUX-specific vectors. */
5803 #undef TARGET_LITTLE_SYM
5804 #undef TARGET_LITTLE_NAME
5805 #undef TARGET_BIG_SYM
5806 #define TARGET_BIG_SYM bfd_elfNN_ia64_hpux_big_vec
5807 #undef TARGET_BIG_NAME
5808 #define TARGET_BIG_NAME "elfNN-ia64-hpux-big"
5810 /* These are HP-UX specific functions. */
5812 #undef elf_backend_post_process_headers
5813 #define elf_backend_post_process_headers elfNN_hpux_post_process_headers
5815 #undef elf_backend_section_from_bfd_section
5816 #define elf_backend_section_from_bfd_section elfNN_hpux_backend_section_from_bfd_section
5818 #undef elf_backend_symbol_processing
5819 #define elf_backend_symbol_processing elfNN_hpux_backend_symbol_processing
5821 #undef elf_backend_want_p_paddr_set_to_zero
5822 #define elf_backend_want_p_paddr_set_to_zero 1
5824 #undef ELF_MAXPAGESIZE
5825 #define ELF_MAXPAGESIZE 0x1000 /* 4K */
5826 #undef ELF_COMMONPAGESIZE
5829 #define elfNN_bed elfNN_ia64_hpux_bed
5831 #include "elfNN-target.h"
5833 #undef elf_backend_want_p_paddr_set_to_zero