1 /* IA-64 support for 64-bit ELF
2 Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
3 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 #include "opcode/ia64.h"
29 * THE RULES for all the stuff the linker creates --
31 * GOT Entries created in response to LTOFF or LTOFF_FPTR
32 * relocations. Dynamic relocs created for dynamic
33 * symbols in an application; REL relocs for locals
34 * in a shared library.
36 * FPTR The canonical function descriptor. Created for local
37 * symbols in applications. Descriptors for dynamic symbols
38 * and local symbols in shared libraries are created by
39 * ld.so. Thus there are no dynamic relocs against these
40 * objects. The FPTR relocs for such _are_ passed through
41 * to the dynamic relocation tables.
43 * FULL_PLT Created for a PCREL21B relocation against a dynamic symbol.
44 * Requires the creation of a PLTOFF entry. This does not
45 * require any dynamic relocations.
47 * PLTOFF Created by PLTOFF relocations. For local symbols, this
48 * is an alternate function descriptor, and in shared libraries
49 * requires two REL relocations. Note that this cannot be
50 * transformed into an FPTR relocation, since it must be in
51 * range of the GP. For dynamic symbols, this is a function
52 * descriptor for a MIN_PLT entry, and requires one IPLT reloc.
54 * MIN_PLT Created by PLTOFF entries against dynamic symbols. This
55 * does not reqire dynamic relocations.
58 #define USE_RELA /* we want RELA relocs, not REL */
60 #define NELEMS(a) ((int) (sizeof (a) / sizeof ((a)[0])))
62 typedef struct bfd_hash_entry *(*new_hash_entry_func)
63 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
65 /* In dynamically (linker-) created sections, we generally need to keep track
66 of the place a symbol or expression got allocated to. This is done via hash
67 tables that store entries of the following type. */
69 struct elfNN_ia64_dyn_sym_info
71 /* The addend for which this entry is relevant. */
74 /* Next addend in the list. */
75 struct elfNN_ia64_dyn_sym_info *next;
79 bfd_vma pltoff_offset;
83 bfd_vma dtpmod_offset;
84 bfd_vma dtprel_offset;
86 /* The symbol table entry, if any, that this was derrived from. */
87 struct elf_link_hash_entry *h;
89 /* Used to count non-got, non-plt relocations for delayed sizing
90 of relocation sections. */
91 struct elfNN_ia64_dyn_reloc_entry
93 struct elfNN_ia64_dyn_reloc_entry *next;
99 /* True when the section contents have been updated. */
100 unsigned got_done : 1;
101 unsigned fptr_done : 1;
102 unsigned pltoff_done : 1;
103 unsigned tprel_done : 1;
104 unsigned dtpmod_done : 1;
105 unsigned dtprel_done : 1;
107 /* True for the different kinds of linker data we want created. */
108 unsigned want_got : 1;
109 unsigned want_fptr : 1;
110 unsigned want_ltoff_fptr : 1;
111 unsigned want_plt : 1;
112 unsigned want_plt2 : 1;
113 unsigned want_pltoff : 1;
114 unsigned want_tprel : 1;
115 unsigned want_dtpmod : 1;
116 unsigned want_dtprel : 1;
119 struct elfNN_ia64_local_hash_entry
121 struct bfd_hash_entry root;
122 struct elfNN_ia64_dyn_sym_info *info;
124 /* True if this hash entry's addends was translated for
125 SHF_MERGE optimization. */
126 unsigned sec_merge_done : 1;
129 struct elfNN_ia64_local_hash_table
131 struct bfd_hash_table root;
132 /* No additional fields for now. */
135 struct elfNN_ia64_link_hash_entry
137 struct elf_link_hash_entry root;
138 struct elfNN_ia64_dyn_sym_info *info;
141 struct elfNN_ia64_link_hash_table
143 /* The main hash table */
144 struct elf_link_hash_table root;
146 asection *got_sec; /* the linkage table section (or NULL) */
147 asection *rel_got_sec; /* dynamic relocation section for same */
148 asection *fptr_sec; /* function descriptor table (or NULL) */
149 asection *plt_sec; /* the primary plt section (or NULL) */
150 asection *pltoff_sec; /* private descriptors for plt (or NULL) */
151 asection *rel_pltoff_sec; /* dynamic relocation section for same */
153 bfd_size_type minplt_entries; /* number of minplt entries */
154 unsigned reltext : 1; /* are there relocs against readonly sections? */
156 struct elfNN_ia64_local_hash_table loc_hash_table;
159 #define elfNN_ia64_hash_table(p) \
160 ((struct elfNN_ia64_link_hash_table *) ((p)->hash))
162 static bfd_reloc_status_type elfNN_ia64_reloc
163 PARAMS ((bfd *abfd, arelent *reloc, asymbol *sym, PTR data,
164 asection *input_section, bfd *output_bfd, char **error_message));
165 static reloc_howto_type * lookup_howto
166 PARAMS ((unsigned int rtype));
167 static reloc_howto_type *elfNN_ia64_reloc_type_lookup
168 PARAMS ((bfd *abfd, bfd_reloc_code_real_type bfd_code));
169 static void elfNN_ia64_info_to_howto
170 PARAMS ((bfd *abfd, arelent *bfd_reloc, ElfNN_Internal_Rela *elf_reloc));
171 static boolean elfNN_ia64_relax_section
172 PARAMS((bfd *abfd, asection *sec, struct bfd_link_info *link_info,
174 static boolean is_unwind_section_name
175 PARAMS ((bfd *abfd, const char *));
176 static boolean elfNN_ia64_section_from_shdr
177 PARAMS ((bfd *, ElfNN_Internal_Shdr *, const char *));
178 static boolean elfNN_ia64_section_flags
179 PARAMS ((flagword *, ElfNN_Internal_Shdr *));
180 static boolean elfNN_ia64_fake_sections
181 PARAMS ((bfd *abfd, ElfNN_Internal_Shdr *hdr, asection *sec));
182 static void elfNN_ia64_final_write_processing
183 PARAMS ((bfd *abfd, boolean linker));
184 static boolean elfNN_ia64_add_symbol_hook
185 PARAMS ((bfd *abfd, struct bfd_link_info *info, const Elf_Internal_Sym *sym,
186 const char **namep, flagword *flagsp, asection **secp,
188 static boolean elfNN_ia64_aix_vec
189 PARAMS ((const bfd_target *vec));
190 static boolean elfNN_ia64_aix_add_symbol_hook
191 PARAMS ((bfd *abfd, struct bfd_link_info *info, const Elf_Internal_Sym *sym,
192 const char **namep, flagword *flagsp, asection **secp,
194 static boolean elfNN_ia64_aix_link_add_symbols
195 PARAMS ((bfd *abfd, struct bfd_link_info *info));
196 static int elfNN_ia64_additional_program_headers
197 PARAMS ((bfd *abfd));
198 static boolean elfNN_ia64_modify_segment_map
200 static boolean elfNN_ia64_is_local_label_name
201 PARAMS ((bfd *abfd, const char *name));
202 static boolean elfNN_ia64_dynamic_symbol_p
203 PARAMS ((struct elf_link_hash_entry *h, struct bfd_link_info *info));
204 static boolean elfNN_ia64_local_hash_table_init
205 PARAMS ((struct elfNN_ia64_local_hash_table *ht, bfd *abfd,
206 new_hash_entry_func new));
207 static struct bfd_hash_entry *elfNN_ia64_new_loc_hash_entry
208 PARAMS ((struct bfd_hash_entry *entry, struct bfd_hash_table *table,
209 const char *string));
210 static struct bfd_hash_entry *elfNN_ia64_new_elf_hash_entry
211 PARAMS ((struct bfd_hash_entry *entry, struct bfd_hash_table *table,
212 const char *string));
213 static void elfNN_ia64_hash_copy_indirect
214 PARAMS ((struct elf_backend_data *, struct elf_link_hash_entry *,
215 struct elf_link_hash_entry *));
216 static void elfNN_ia64_hash_hide_symbol
217 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, boolean));
218 static struct bfd_link_hash_table *elfNN_ia64_hash_table_create
219 PARAMS ((bfd *abfd));
220 static struct elfNN_ia64_local_hash_entry *elfNN_ia64_local_hash_lookup
221 PARAMS ((struct elfNN_ia64_local_hash_table *table, const char *string,
222 boolean create, boolean copy));
223 static boolean elfNN_ia64_global_dyn_sym_thunk
224 PARAMS ((struct bfd_hash_entry *, PTR));
225 static boolean elfNN_ia64_local_dyn_sym_thunk
226 PARAMS ((struct bfd_hash_entry *, PTR));
227 static void elfNN_ia64_dyn_sym_traverse
228 PARAMS ((struct elfNN_ia64_link_hash_table *ia64_info,
229 boolean (*func) (struct elfNN_ia64_dyn_sym_info *, PTR),
231 static boolean elfNN_ia64_create_dynamic_sections
232 PARAMS ((bfd *abfd, struct bfd_link_info *info));
233 static struct elfNN_ia64_local_hash_entry * get_local_sym_hash
234 PARAMS ((struct elfNN_ia64_link_hash_table *ia64_info,
235 bfd *abfd, const Elf_Internal_Rela *rel, boolean create));
236 static struct elfNN_ia64_dyn_sym_info * get_dyn_sym_info
237 PARAMS ((struct elfNN_ia64_link_hash_table *ia64_info,
238 struct elf_link_hash_entry *h,
239 bfd *abfd, const Elf_Internal_Rela *rel, boolean create));
240 static asection *get_got
241 PARAMS ((bfd *abfd, struct bfd_link_info *info,
242 struct elfNN_ia64_link_hash_table *ia64_info));
243 static asection *get_fptr
244 PARAMS ((bfd *abfd, struct bfd_link_info *info,
245 struct elfNN_ia64_link_hash_table *ia64_info));
246 static asection *get_pltoff
247 PARAMS ((bfd *abfd, struct bfd_link_info *info,
248 struct elfNN_ia64_link_hash_table *ia64_info));
249 static asection *get_reloc_section
250 PARAMS ((bfd *abfd, struct elfNN_ia64_link_hash_table *ia64_info,
251 asection *sec, boolean create));
252 static boolean count_dyn_reloc
253 PARAMS ((bfd *abfd, struct elfNN_ia64_dyn_sym_info *dyn_i,
254 asection *srel, int type));
255 static boolean elfNN_ia64_check_relocs
256 PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *sec,
257 const Elf_Internal_Rela *relocs));
258 static boolean elfNN_ia64_adjust_dynamic_symbol
259 PARAMS ((struct bfd_link_info *info, struct elf_link_hash_entry *h));
260 static long global_sym_index
261 PARAMS ((struct elf_link_hash_entry *h));
262 static boolean allocate_fptr
263 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
264 static boolean allocate_global_data_got
265 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
266 static boolean allocate_global_fptr_got
267 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
268 static boolean allocate_local_got
269 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
270 static boolean allocate_pltoff_entries
271 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
272 static boolean allocate_plt_entries
273 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
274 static boolean allocate_plt2_entries
275 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
276 static boolean allocate_dynrel_entries
277 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
278 static boolean elfNN_ia64_size_dynamic_sections
279 PARAMS ((bfd *output_bfd, struct bfd_link_info *info));
280 static bfd_reloc_status_type elfNN_ia64_install_value
281 PARAMS ((bfd *abfd, bfd_byte *hit_addr, bfd_vma val, unsigned int r_type));
282 static void elfNN_ia64_install_dyn_reloc
283 PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *sec,
284 asection *srel, bfd_vma offset, unsigned int type,
285 long dynindx, bfd_vma addend));
286 static bfd_vma set_got_entry
287 PARAMS ((bfd *abfd, struct bfd_link_info *info,
288 struct elfNN_ia64_dyn_sym_info *dyn_i, long dynindx,
289 bfd_vma addend, bfd_vma value, unsigned int dyn_r_type));
290 static bfd_vma set_fptr_entry
291 PARAMS ((bfd *abfd, struct bfd_link_info *info,
292 struct elfNN_ia64_dyn_sym_info *dyn_i,
294 static bfd_vma set_pltoff_entry
295 PARAMS ((bfd *abfd, struct bfd_link_info *info,
296 struct elfNN_ia64_dyn_sym_info *dyn_i,
297 bfd_vma value, boolean));
298 static bfd_vma elfNN_ia64_tprel_base
299 PARAMS ((struct bfd_link_info *info));
300 static bfd_vma elfNN_ia64_dtprel_base
301 PARAMS ((struct bfd_link_info *info));
302 static int elfNN_ia64_unwind_entry_compare
303 PARAMS ((const PTR, const PTR));
304 static boolean elfNN_ia64_final_link
305 PARAMS ((bfd *abfd, struct bfd_link_info *info));
306 static boolean elfNN_ia64_relocate_section
307 PARAMS ((bfd *output_bfd, struct bfd_link_info *info, bfd *input_bfd,
308 asection *input_section, bfd_byte *contents,
309 Elf_Internal_Rela *relocs, Elf_Internal_Sym *local_syms,
310 asection **local_sections));
311 static boolean elfNN_ia64_finish_dynamic_symbol
312 PARAMS ((bfd *output_bfd, struct bfd_link_info *info,
313 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym));
314 static boolean elfNN_ia64_finish_dynamic_sections
315 PARAMS ((bfd *abfd, struct bfd_link_info *info));
316 static boolean elfNN_ia64_set_private_flags
317 PARAMS ((bfd *abfd, flagword flags));
318 static boolean elfNN_ia64_merge_private_bfd_data
319 PARAMS ((bfd *ibfd, bfd *obfd));
320 static boolean elfNN_ia64_print_private_bfd_data
321 PARAMS ((bfd *abfd, PTR ptr));
322 static enum elf_reloc_type_class elfNN_ia64_reloc_type_class
323 PARAMS ((const Elf_Internal_Rela *));
324 static boolean elfNN_ia64_hpux_vec
325 PARAMS ((const bfd_target *vec));
326 static void elfNN_hpux_post_process_headers
327 PARAMS ((bfd *abfd, struct bfd_link_info *info));
328 boolean elfNN_hpux_backend_section_from_bfd_section
329 PARAMS ((bfd *abfd, asection *sec, int *retval));
331 /* ia64-specific relocation */
333 /* Perform a relocation. Not much to do here as all the hard work is
334 done in elfNN_ia64_final_link_relocate. */
335 static bfd_reloc_status_type
336 elfNN_ia64_reloc (abfd, reloc, sym, data, input_section,
337 output_bfd, error_message)
338 bfd *abfd ATTRIBUTE_UNUSED;
340 asymbol *sym ATTRIBUTE_UNUSED;
341 PTR data ATTRIBUTE_UNUSED;
342 asection *input_section;
344 char **error_message;
348 reloc->address += input_section->output_offset;
351 *error_message = "Unsupported call to elfNN_ia64_reloc";
352 return bfd_reloc_notsupported;
355 #define IA64_HOWTO(TYPE, NAME, SIZE, PCREL, IN) \
356 HOWTO (TYPE, 0, SIZE, 0, PCREL, 0, complain_overflow_signed, \
357 elfNN_ia64_reloc, NAME, false, 0, 0, IN)
359 /* This table has to be sorted according to increasing number of the
361 static reloc_howto_type ia64_howto_table[] =
363 IA64_HOWTO (R_IA64_NONE, "NONE", 0, false, true),
365 IA64_HOWTO (R_IA64_IMM14, "IMM14", 0, false, true),
366 IA64_HOWTO (R_IA64_IMM22, "IMM22", 0, false, true),
367 IA64_HOWTO (R_IA64_IMM64, "IMM64", 0, false, true),
368 IA64_HOWTO (R_IA64_DIR32MSB, "DIR32MSB", 2, false, true),
369 IA64_HOWTO (R_IA64_DIR32LSB, "DIR32LSB", 2, false, true),
370 IA64_HOWTO (R_IA64_DIR64MSB, "DIR64MSB", 4, false, true),
371 IA64_HOWTO (R_IA64_DIR64LSB, "DIR64LSB", 4, false, true),
373 IA64_HOWTO (R_IA64_GPREL22, "GPREL22", 0, false, true),
374 IA64_HOWTO (R_IA64_GPREL64I, "GPREL64I", 0, false, true),
375 IA64_HOWTO (R_IA64_GPREL32MSB, "GPREL32MSB", 2, false, true),
376 IA64_HOWTO (R_IA64_GPREL32LSB, "GPREL32LSB", 2, false, true),
377 IA64_HOWTO (R_IA64_GPREL64MSB, "GPREL64MSB", 4, false, true),
378 IA64_HOWTO (R_IA64_GPREL64LSB, "GPREL64LSB", 4, false, true),
380 IA64_HOWTO (R_IA64_LTOFF22, "LTOFF22", 0, false, true),
381 IA64_HOWTO (R_IA64_LTOFF64I, "LTOFF64I", 0, false, true),
383 IA64_HOWTO (R_IA64_PLTOFF22, "PLTOFF22", 0, false, true),
384 IA64_HOWTO (R_IA64_PLTOFF64I, "PLTOFF64I", 0, false, true),
385 IA64_HOWTO (R_IA64_PLTOFF64MSB, "PLTOFF64MSB", 4, false, true),
386 IA64_HOWTO (R_IA64_PLTOFF64LSB, "PLTOFF64LSB", 4, false, true),
388 IA64_HOWTO (R_IA64_FPTR64I, "FPTR64I", 0, false, true),
389 IA64_HOWTO (R_IA64_FPTR32MSB, "FPTR32MSB", 2, false, true),
390 IA64_HOWTO (R_IA64_FPTR32LSB, "FPTR32LSB", 2, false, true),
391 IA64_HOWTO (R_IA64_FPTR64MSB, "FPTR64MSB", 4, false, true),
392 IA64_HOWTO (R_IA64_FPTR64LSB, "FPTR64LSB", 4, false, true),
394 IA64_HOWTO (R_IA64_PCREL60B, "PCREL60B", 0, true, true),
395 IA64_HOWTO (R_IA64_PCREL21B, "PCREL21B", 0, true, true),
396 IA64_HOWTO (R_IA64_PCREL21M, "PCREL21M", 0, true, true),
397 IA64_HOWTO (R_IA64_PCREL21F, "PCREL21F", 0, true, true),
398 IA64_HOWTO (R_IA64_PCREL32MSB, "PCREL32MSB", 2, true, true),
399 IA64_HOWTO (R_IA64_PCREL32LSB, "PCREL32LSB", 2, true, true),
400 IA64_HOWTO (R_IA64_PCREL64MSB, "PCREL64MSB", 4, true, true),
401 IA64_HOWTO (R_IA64_PCREL64LSB, "PCREL64LSB", 4, true, true),
403 IA64_HOWTO (R_IA64_LTOFF_FPTR22, "LTOFF_FPTR22", 0, false, true),
404 IA64_HOWTO (R_IA64_LTOFF_FPTR64I, "LTOFF_FPTR64I", 0, false, true),
405 IA64_HOWTO (R_IA64_LTOFF_FPTR32MSB, "LTOFF_FPTR32MSB", 2, false, true),
406 IA64_HOWTO (R_IA64_LTOFF_FPTR32LSB, "LTOFF_FPTR32LSB", 2, false, true),
407 IA64_HOWTO (R_IA64_LTOFF_FPTR64MSB, "LTOFF_FPTR64MSB", 4, false, true),
408 IA64_HOWTO (R_IA64_LTOFF_FPTR64LSB, "LTOFF_FPTR64LSB", 4, false, true),
410 IA64_HOWTO (R_IA64_SEGREL32MSB, "SEGREL32MSB", 2, false, true),
411 IA64_HOWTO (R_IA64_SEGREL32LSB, "SEGREL32LSB", 2, false, true),
412 IA64_HOWTO (R_IA64_SEGREL64MSB, "SEGREL64MSB", 4, false, true),
413 IA64_HOWTO (R_IA64_SEGREL64LSB, "SEGREL64LSB", 4, false, true),
415 IA64_HOWTO (R_IA64_SECREL32MSB, "SECREL32MSB", 2, false, true),
416 IA64_HOWTO (R_IA64_SECREL32LSB, "SECREL32LSB", 2, false, true),
417 IA64_HOWTO (R_IA64_SECREL64MSB, "SECREL64MSB", 4, false, true),
418 IA64_HOWTO (R_IA64_SECREL64LSB, "SECREL64LSB", 4, false, true),
420 IA64_HOWTO (R_IA64_REL32MSB, "REL32MSB", 2, false, true),
421 IA64_HOWTO (R_IA64_REL32LSB, "REL32LSB", 2, false, true),
422 IA64_HOWTO (R_IA64_REL64MSB, "REL64MSB", 4, false, true),
423 IA64_HOWTO (R_IA64_REL64LSB, "REL64LSB", 4, false, true),
425 IA64_HOWTO (R_IA64_LTV32MSB, "LTV32MSB", 2, false, true),
426 IA64_HOWTO (R_IA64_LTV32LSB, "LTV32LSB", 2, false, true),
427 IA64_HOWTO (R_IA64_LTV64MSB, "LTV64MSB", 4, false, true),
428 IA64_HOWTO (R_IA64_LTV64LSB, "LTV64LSB", 4, false, true),
430 IA64_HOWTO (R_IA64_PCREL21BI, "PCREL21BI", 0, true, true),
431 IA64_HOWTO (R_IA64_PCREL22, "PCREL22", 0, true, true),
432 IA64_HOWTO (R_IA64_PCREL64I, "PCREL64I", 0, true, true),
434 IA64_HOWTO (R_IA64_IPLTMSB, "IPLTMSB", 4, false, true),
435 IA64_HOWTO (R_IA64_IPLTLSB, "IPLTLSB", 4, false, true),
436 IA64_HOWTO (R_IA64_COPY, "COPY", 4, false, true),
437 IA64_HOWTO (R_IA64_LTOFF22X, "LTOFF22X", 0, false, true),
438 IA64_HOWTO (R_IA64_LDXMOV, "LDXMOV", 0, false, true),
440 IA64_HOWTO (R_IA64_TPREL14, "TPREL14", 0, false, false),
441 IA64_HOWTO (R_IA64_TPREL22, "TPREL22", 0, false, false),
442 IA64_HOWTO (R_IA64_TPREL64I, "TPREL64I", 0, false, false),
443 IA64_HOWTO (R_IA64_TPREL64MSB, "TPREL64MSB", 8, false, false),
444 IA64_HOWTO (R_IA64_TPREL64LSB, "TPREL64LSB", 8, false, false),
445 IA64_HOWTO (R_IA64_LTOFF_TPREL22, "LTOFF_TPREL22", 0, false, false),
447 IA64_HOWTO (R_IA64_DTPMOD64MSB, "TPREL64MSB", 8, false, false),
448 IA64_HOWTO (R_IA64_DTPMOD64LSB, "TPREL64LSB", 8, false, false),
449 IA64_HOWTO (R_IA64_LTOFF_DTPMOD22, "LTOFF_DTPMOD22", 0, false, false),
451 IA64_HOWTO (R_IA64_DTPREL14, "DTPREL14", 0, false, false),
452 IA64_HOWTO (R_IA64_DTPREL22, "DTPREL22", 0, false, false),
453 IA64_HOWTO (R_IA64_DTPREL64I, "DTPREL64I", 0, false, false),
454 IA64_HOWTO (R_IA64_DTPREL32MSB, "DTPREL32MSB", 4, false, false),
455 IA64_HOWTO (R_IA64_DTPREL32LSB, "DTPREL32LSB", 4, false, false),
456 IA64_HOWTO (R_IA64_DTPREL64MSB, "DTPREL64MSB", 8, false, false),
457 IA64_HOWTO (R_IA64_DTPREL64LSB, "DTPREL64LSB", 8, false, false),
458 IA64_HOWTO (R_IA64_LTOFF_DTPREL22, "LTOFF_DTPREL22", 0, false, false),
461 static unsigned char elf_code_to_howto_index[R_IA64_MAX_RELOC_CODE + 1];
463 /* Given a BFD reloc type, return the matching HOWTO structure. */
465 static reloc_howto_type*
469 static int inited = 0;
476 memset (elf_code_to_howto_index, 0xff, sizeof (elf_code_to_howto_index));
477 for (i = 0; i < NELEMS (ia64_howto_table); ++i)
478 elf_code_to_howto_index[ia64_howto_table[i].type] = i;
481 BFD_ASSERT (rtype <= R_IA64_MAX_RELOC_CODE);
482 i = elf_code_to_howto_index[rtype];
483 if (i >= NELEMS (ia64_howto_table))
485 return ia64_howto_table + i;
488 static reloc_howto_type*
489 elfNN_ia64_reloc_type_lookup (abfd, bfd_code)
490 bfd *abfd ATTRIBUTE_UNUSED;
491 bfd_reloc_code_real_type bfd_code;
497 case BFD_RELOC_NONE: rtype = R_IA64_NONE; break;
499 case BFD_RELOC_IA64_IMM14: rtype = R_IA64_IMM14; break;
500 case BFD_RELOC_IA64_IMM22: rtype = R_IA64_IMM22; break;
501 case BFD_RELOC_IA64_IMM64: rtype = R_IA64_IMM64; break;
503 case BFD_RELOC_IA64_DIR32MSB: rtype = R_IA64_DIR32MSB; break;
504 case BFD_RELOC_IA64_DIR32LSB: rtype = R_IA64_DIR32LSB; break;
505 case BFD_RELOC_IA64_DIR64MSB: rtype = R_IA64_DIR64MSB; break;
506 case BFD_RELOC_IA64_DIR64LSB: rtype = R_IA64_DIR64LSB; break;
508 case BFD_RELOC_IA64_GPREL22: rtype = R_IA64_GPREL22; break;
509 case BFD_RELOC_IA64_GPREL64I: rtype = R_IA64_GPREL64I; break;
510 case BFD_RELOC_IA64_GPREL32MSB: rtype = R_IA64_GPREL32MSB; break;
511 case BFD_RELOC_IA64_GPREL32LSB: rtype = R_IA64_GPREL32LSB; break;
512 case BFD_RELOC_IA64_GPREL64MSB: rtype = R_IA64_GPREL64MSB; break;
513 case BFD_RELOC_IA64_GPREL64LSB: rtype = R_IA64_GPREL64LSB; break;
515 case BFD_RELOC_IA64_LTOFF22: rtype = R_IA64_LTOFF22; break;
516 case BFD_RELOC_IA64_LTOFF64I: rtype = R_IA64_LTOFF64I; break;
518 case BFD_RELOC_IA64_PLTOFF22: rtype = R_IA64_PLTOFF22; break;
519 case BFD_RELOC_IA64_PLTOFF64I: rtype = R_IA64_PLTOFF64I; break;
520 case BFD_RELOC_IA64_PLTOFF64MSB: rtype = R_IA64_PLTOFF64MSB; break;
521 case BFD_RELOC_IA64_PLTOFF64LSB: rtype = R_IA64_PLTOFF64LSB; break;
522 case BFD_RELOC_IA64_FPTR64I: rtype = R_IA64_FPTR64I; break;
523 case BFD_RELOC_IA64_FPTR32MSB: rtype = R_IA64_FPTR32MSB; break;
524 case BFD_RELOC_IA64_FPTR32LSB: rtype = R_IA64_FPTR32LSB; break;
525 case BFD_RELOC_IA64_FPTR64MSB: rtype = R_IA64_FPTR64MSB; break;
526 case BFD_RELOC_IA64_FPTR64LSB: rtype = R_IA64_FPTR64LSB; break;
528 case BFD_RELOC_IA64_PCREL21B: rtype = R_IA64_PCREL21B; break;
529 case BFD_RELOC_IA64_PCREL21BI: rtype = R_IA64_PCREL21BI; break;
530 case BFD_RELOC_IA64_PCREL21M: rtype = R_IA64_PCREL21M; break;
531 case BFD_RELOC_IA64_PCREL21F: rtype = R_IA64_PCREL21F; break;
532 case BFD_RELOC_IA64_PCREL22: rtype = R_IA64_PCREL22; break;
533 case BFD_RELOC_IA64_PCREL60B: rtype = R_IA64_PCREL60B; break;
534 case BFD_RELOC_IA64_PCREL64I: rtype = R_IA64_PCREL64I; break;
535 case BFD_RELOC_IA64_PCREL32MSB: rtype = R_IA64_PCREL32MSB; break;
536 case BFD_RELOC_IA64_PCREL32LSB: rtype = R_IA64_PCREL32LSB; break;
537 case BFD_RELOC_IA64_PCREL64MSB: rtype = R_IA64_PCREL64MSB; break;
538 case BFD_RELOC_IA64_PCREL64LSB: rtype = R_IA64_PCREL64LSB; break;
540 case BFD_RELOC_IA64_LTOFF_FPTR22: rtype = R_IA64_LTOFF_FPTR22; break;
541 case BFD_RELOC_IA64_LTOFF_FPTR64I: rtype = R_IA64_LTOFF_FPTR64I; break;
542 case BFD_RELOC_IA64_LTOFF_FPTR32MSB: rtype = R_IA64_LTOFF_FPTR32MSB; break;
543 case BFD_RELOC_IA64_LTOFF_FPTR32LSB: rtype = R_IA64_LTOFF_FPTR32LSB; break;
544 case BFD_RELOC_IA64_LTOFF_FPTR64MSB: rtype = R_IA64_LTOFF_FPTR64MSB; break;
545 case BFD_RELOC_IA64_LTOFF_FPTR64LSB: rtype = R_IA64_LTOFF_FPTR64LSB; break;
547 case BFD_RELOC_IA64_SEGREL32MSB: rtype = R_IA64_SEGREL32MSB; break;
548 case BFD_RELOC_IA64_SEGREL32LSB: rtype = R_IA64_SEGREL32LSB; break;
549 case BFD_RELOC_IA64_SEGREL64MSB: rtype = R_IA64_SEGREL64MSB; break;
550 case BFD_RELOC_IA64_SEGREL64LSB: rtype = R_IA64_SEGREL64LSB; break;
552 case BFD_RELOC_IA64_SECREL32MSB: rtype = R_IA64_SECREL32MSB; break;
553 case BFD_RELOC_IA64_SECREL32LSB: rtype = R_IA64_SECREL32LSB; break;
554 case BFD_RELOC_IA64_SECREL64MSB: rtype = R_IA64_SECREL64MSB; break;
555 case BFD_RELOC_IA64_SECREL64LSB: rtype = R_IA64_SECREL64LSB; break;
557 case BFD_RELOC_IA64_REL32MSB: rtype = R_IA64_REL32MSB; break;
558 case BFD_RELOC_IA64_REL32LSB: rtype = R_IA64_REL32LSB; break;
559 case BFD_RELOC_IA64_REL64MSB: rtype = R_IA64_REL64MSB; break;
560 case BFD_RELOC_IA64_REL64LSB: rtype = R_IA64_REL64LSB; break;
562 case BFD_RELOC_IA64_LTV32MSB: rtype = R_IA64_LTV32MSB; break;
563 case BFD_RELOC_IA64_LTV32LSB: rtype = R_IA64_LTV32LSB; break;
564 case BFD_RELOC_IA64_LTV64MSB: rtype = R_IA64_LTV64MSB; break;
565 case BFD_RELOC_IA64_LTV64LSB: rtype = R_IA64_LTV64LSB; break;
567 case BFD_RELOC_IA64_IPLTMSB: rtype = R_IA64_IPLTMSB; break;
568 case BFD_RELOC_IA64_IPLTLSB: rtype = R_IA64_IPLTLSB; break;
569 case BFD_RELOC_IA64_COPY: rtype = R_IA64_COPY; break;
570 case BFD_RELOC_IA64_LTOFF22X: rtype = R_IA64_LTOFF22X; break;
571 case BFD_RELOC_IA64_LDXMOV: rtype = R_IA64_LDXMOV; break;
573 case BFD_RELOC_IA64_TPREL14: rtype = R_IA64_TPREL14; break;
574 case BFD_RELOC_IA64_TPREL22: rtype = R_IA64_TPREL22; break;
575 case BFD_RELOC_IA64_TPREL64I: rtype = R_IA64_TPREL64I; break;
576 case BFD_RELOC_IA64_TPREL64MSB: rtype = R_IA64_TPREL64MSB; break;
577 case BFD_RELOC_IA64_TPREL64LSB: rtype = R_IA64_TPREL64LSB; break;
578 case BFD_RELOC_IA64_LTOFF_TPREL22: rtype = R_IA64_LTOFF_TPREL22; break;
580 case BFD_RELOC_IA64_DTPMOD64MSB: rtype = R_IA64_DTPMOD64MSB; break;
581 case BFD_RELOC_IA64_DTPMOD64LSB: rtype = R_IA64_DTPMOD64LSB; break;
582 case BFD_RELOC_IA64_LTOFF_DTPMOD22: rtype = R_IA64_LTOFF_DTPMOD22; break;
584 case BFD_RELOC_IA64_DTPREL14: rtype = R_IA64_DTPREL14; break;
585 case BFD_RELOC_IA64_DTPREL22: rtype = R_IA64_DTPREL22; break;
586 case BFD_RELOC_IA64_DTPREL64I: rtype = R_IA64_DTPREL64I; break;
587 case BFD_RELOC_IA64_DTPREL32MSB: rtype = R_IA64_DTPREL32MSB; break;
588 case BFD_RELOC_IA64_DTPREL32LSB: rtype = R_IA64_DTPREL32LSB; break;
589 case BFD_RELOC_IA64_DTPREL64MSB: rtype = R_IA64_DTPREL64MSB; break;
590 case BFD_RELOC_IA64_DTPREL64LSB: rtype = R_IA64_DTPREL64LSB; break;
591 case BFD_RELOC_IA64_LTOFF_DTPREL22: rtype = R_IA64_LTOFF_DTPREL22; break;
595 return lookup_howto (rtype);
598 /* Given a ELF reloc, return the matching HOWTO structure. */
601 elfNN_ia64_info_to_howto (abfd, bfd_reloc, elf_reloc)
602 bfd *abfd ATTRIBUTE_UNUSED;
604 ElfNN_Internal_Rela *elf_reloc;
607 = lookup_howto ((unsigned int) ELFNN_R_TYPE (elf_reloc->r_info));
610 #define PLT_HEADER_SIZE (3 * 16)
611 #define PLT_MIN_ENTRY_SIZE (1 * 16)
612 #define PLT_FULL_ENTRY_SIZE (2 * 16)
613 #define PLT_RESERVED_WORDS 3
615 static const bfd_byte plt_header[PLT_HEADER_SIZE] =
617 0x0b, 0x10, 0x00, 0x1c, 0x00, 0x21, /* [MMI] mov r2=r14;; */
618 0xe0, 0x00, 0x08, 0x00, 0x48, 0x00, /* addl r14=0,r2 */
619 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
620 0x0b, 0x80, 0x20, 0x1c, 0x18, 0x14, /* [MMI] ld8 r16=[r14],8;; */
621 0x10, 0x41, 0x38, 0x30, 0x28, 0x00, /* ld8 r17=[r14],8 */
622 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
623 0x11, 0x08, 0x00, 0x1c, 0x18, 0x10, /* [MIB] ld8 r1=[r14] */
624 0x60, 0x88, 0x04, 0x80, 0x03, 0x00, /* mov b6=r17 */
625 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
628 static const bfd_byte plt_min_entry[PLT_MIN_ENTRY_SIZE] =
630 0x11, 0x78, 0x00, 0x00, 0x00, 0x24, /* [MIB] mov r15=0 */
631 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, /* nop.i 0x0 */
632 0x00, 0x00, 0x00, 0x40 /* br.few 0 <PLT0>;; */
635 static const bfd_byte plt_full_entry[PLT_FULL_ENTRY_SIZE] =
637 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
638 0x00, 0x41, 0x3c, 0x30, 0x28, 0xc0, /* ld8 r16=[r15],8 */
639 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
640 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
641 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
642 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
645 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
646 #define AIX_DYNAMIC_INTERPRETER "/usr/lib/ia64l64/libc.so.1"
647 #define DYNAMIC_INTERPRETER(abfd) \
648 (elfNN_ia64_aix_vec (abfd->xvec) ? AIX_DYNAMIC_INTERPRETER : ELF_DYNAMIC_INTERPRETER)
650 /* Select out of range branch fixup type. Note that Itanium does
651 not support brl, and so it gets emulated by the kernel. */
655 static const bfd_byte oor_brl[16] =
657 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
658 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;; */
659 0x00, 0x00, 0x00, 0xc0
662 static const bfd_byte oor_ip[48] =
664 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
665 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, /* movl r15=0 */
666 0x01, 0x00, 0x00, 0x60,
667 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MII] nop.m 0 */
668 0x00, 0x01, 0x00, 0x60, 0x00, 0x00, /* mov r16=ip;; */
669 0xf2, 0x80, 0x00, 0x80, /* add r16=r15,r16;; */
670 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MIB] nop.m 0 */
671 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
672 0x60, 0x00, 0x80, 0x00 /* br b6;; */
676 /* These functions do relaxation for IA-64 ELF.
678 This is primarily to support branches to targets out of range;
679 relaxation of R_IA64_LTOFF22X and R_IA64_LDXMOV not yet supported. */
682 elfNN_ia64_relax_section (abfd, sec, link_info, again)
685 struct bfd_link_info *link_info;
690 struct one_fixup *next;
696 Elf_Internal_Shdr *symtab_hdr;
697 Elf_Internal_Rela *internal_relocs;
698 Elf_Internal_Rela *irel, *irelend;
700 Elf_Internal_Sym *isymbuf = NULL;
701 struct elfNN_ia64_link_hash_table *ia64_info;
702 struct one_fixup *fixups = NULL;
703 boolean changed_contents = false;
704 boolean changed_relocs = false;
706 /* Assume we're not going to change any sizes, and we'll only need
710 /* Nothing to do if there are no relocations. */
711 if ((sec->flags & SEC_RELOC) == 0
712 || sec->reloc_count == 0)
715 /* If this is the first time we have been called for this section,
716 initialize the cooked size. */
717 if (sec->_cooked_size == 0)
718 sec->_cooked_size = sec->_raw_size;
720 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
722 /* Load the relocations for this section. */
723 internal_relocs = (_bfd_elfNN_link_read_relocs
724 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
725 link_info->keep_memory));
726 if (internal_relocs == NULL)
729 ia64_info = elfNN_ia64_hash_table (link_info);
730 irelend = internal_relocs + sec->reloc_count;
732 for (irel = internal_relocs; irel < irelend; irel++)
733 if (ELFNN_R_TYPE (irel->r_info) == (int) R_IA64_PCREL21B)
736 /* No branch-type relocations. */
739 if (elf_section_data (sec)->relocs != internal_relocs)
740 free (internal_relocs);
744 /* Get the section contents. */
745 if (elf_section_data (sec)->this_hdr.contents != NULL)
746 contents = elf_section_data (sec)->this_hdr.contents;
749 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
750 if (contents == NULL)
753 if (! bfd_get_section_contents (abfd, sec, contents,
754 (file_ptr) 0, sec->_raw_size))
758 for (; irel < irelend; irel++)
760 bfd_vma symaddr, reladdr, trampoff, toff, roff;
765 if (ELFNN_R_TYPE (irel->r_info) != (int) R_IA64_PCREL21B)
768 /* Get the value of the symbol referred to by the reloc. */
769 if (ELFNN_R_SYM (irel->r_info) < symtab_hdr->sh_info)
771 /* A local symbol. */
772 Elf_Internal_Sym *isym;
774 /* Read this BFD's local symbols. */
777 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
779 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
780 symtab_hdr->sh_info, 0,
786 isym = isymbuf + ELF64_R_SYM (irel->r_info);
787 if (isym->st_shndx == SHN_UNDEF)
788 continue; /* We can't do anthing with undefined symbols. */
789 else if (isym->st_shndx == SHN_ABS)
790 tsec = bfd_abs_section_ptr;
791 else if (isym->st_shndx == SHN_COMMON)
792 tsec = bfd_com_section_ptr;
793 else if (isym->st_shndx == SHN_IA_64_ANSI_COMMON)
794 tsec = bfd_com_section_ptr;
796 tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
798 toff = isym->st_value;
803 struct elf_link_hash_entry *h;
804 struct elfNN_ia64_dyn_sym_info *dyn_i;
806 indx = ELFNN_R_SYM (irel->r_info) - symtab_hdr->sh_info;
807 h = elf_sym_hashes (abfd)[indx];
808 BFD_ASSERT (h != NULL);
810 while (h->root.type == bfd_link_hash_indirect
811 || h->root.type == bfd_link_hash_warning)
812 h = (struct elf_link_hash_entry *) h->root.u.i.link;
814 dyn_i = get_dyn_sym_info (ia64_info, h, abfd, irel, false);
816 /* For branches to dynamic symbols, we're interested instead
817 in a branch to the PLT entry. */
818 if (dyn_i && dyn_i->want_plt2)
820 tsec = ia64_info->plt_sec;
821 toff = dyn_i->plt2_offset;
825 /* We can't do anthing with undefined symbols. */
826 if (h->root.type == bfd_link_hash_undefined
827 || h->root.type == bfd_link_hash_undefweak)
830 tsec = h->root.u.def.section;
831 toff = h->root.u.def.value;
835 symaddr = (tsec->output_section->vma
836 + tsec->output_offset
840 roff = irel->r_offset;
841 reladdr = (sec->output_section->vma
843 + roff) & (bfd_vma) -4;
845 /* If the branch is in range, no need to do anything. */
846 if ((bfd_signed_vma) (symaddr - reladdr) >= -0x1000000
847 && (bfd_signed_vma) (symaddr - reladdr) <= 0x0FFFFF0)
850 /* If the branch and target are in the same section, you've
851 got one honking big section and we can't help you. You'll
852 get an error message later. */
856 /* Look for an existing fixup to this address. */
857 for (f = fixups; f ; f = f->next)
858 if (f->tsec == tsec && f->toff == toff)
863 /* Two alternatives: If it's a branch to a PLT entry, we can
864 make a copy of the FULL_PLT entry. Otherwise, we'll have
865 to use a `brl' insn to get where we're going. */
869 if (tsec == ia64_info->plt_sec)
870 size = sizeof (plt_full_entry);
874 size = sizeof (oor_brl);
876 size = sizeof (oor_ip);
880 /* Resize the current section to make room for the new branch. */
881 trampoff = (sec->_cooked_size + 15) & (bfd_vma) -16;
882 amt = trampoff + size;
883 contents = (bfd_byte *) bfd_realloc (contents, amt);
884 if (contents == NULL)
886 sec->_cooked_size = amt;
888 if (tsec == ia64_info->plt_sec)
890 memcpy (contents + trampoff, plt_full_entry, size);
892 /* Hijack the old relocation for use as the PLTOFF reloc. */
893 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
895 irel->r_offset = trampoff;
900 memcpy (contents + trampoff, oor_brl, size);
901 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
903 irel->r_offset = trampoff + 2;
905 memcpy (contents + trampoff, oor_ip, size);
906 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
908 irel->r_addend -= 16;
909 irel->r_offset = trampoff + 2;
913 /* Record the fixup so we don't do it again this section. */
914 f = (struct one_fixup *) bfd_malloc ((bfd_size_type) sizeof (*f));
918 f->trampoff = trampoff;
923 /* Nop out the reloc, since we're finalizing things here. */
924 irel->r_info = ELFNN_R_INFO (0, R_IA64_NONE);
927 /* Fix up the existing branch to hit the trampoline. Hope like
928 hell this doesn't overflow too. */
929 if (elfNN_ia64_install_value (abfd, contents + roff,
930 f->trampoff - (roff & (bfd_vma) -4),
931 R_IA64_PCREL21B) != bfd_reloc_ok)
934 changed_contents = true;
935 changed_relocs = true;
938 /* Clean up and go home. */
941 struct one_fixup *f = fixups;
942 fixups = fixups->next;
947 && symtab_hdr->contents != (unsigned char *) isymbuf)
949 if (! link_info->keep_memory)
953 /* Cache the symbols for elf_link_input_bfd. */
954 symtab_hdr->contents = (unsigned char *) isymbuf;
959 && elf_section_data (sec)->this_hdr.contents != contents)
961 if (!changed_contents && !link_info->keep_memory)
965 /* Cache the section contents for elf_link_input_bfd. */
966 elf_section_data (sec)->this_hdr.contents = contents;
970 if (elf_section_data (sec)->relocs != internal_relocs)
973 free (internal_relocs);
975 elf_section_data (sec)->relocs = internal_relocs;
978 *again = changed_contents || changed_relocs;
982 if (isymbuf != NULL && (unsigned char *) isymbuf != symtab_hdr->contents)
985 && elf_section_data (sec)->this_hdr.contents != contents)
987 if (internal_relocs != NULL
988 && elf_section_data (sec)->relocs != internal_relocs)
989 free (internal_relocs);
993 /* Return true if NAME is an unwind table section name. */
995 static inline boolean
996 is_unwind_section_name (abfd, name)
1000 size_t len1, len2, len3;
1002 if (elfNN_ia64_hpux_vec (abfd->xvec)
1003 && !strcmp (name, ELF_STRING_ia64_unwind_hdr))
1006 len1 = sizeof (ELF_STRING_ia64_unwind) - 1;
1007 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
1008 len3 = sizeof (ELF_STRING_ia64_unwind_once) - 1;
1009 return ((strncmp (name, ELF_STRING_ia64_unwind, len1) == 0
1010 && strncmp (name, ELF_STRING_ia64_unwind_info, len2) != 0)
1011 || strncmp (name, ELF_STRING_ia64_unwind_once, len3) == 0);
1014 /* Handle an IA-64 specific section when reading an object file. This
1015 is called when elfcode.h finds a section with an unknown type. */
1018 elfNN_ia64_section_from_shdr (abfd, hdr, name)
1020 ElfNN_Internal_Shdr *hdr;
1025 /* There ought to be a place to keep ELF backend specific flags, but
1026 at the moment there isn't one. We just keep track of the
1027 sections by their name, instead. Fortunately, the ABI gives
1028 suggested names for all the MIPS specific sections, so we will
1029 probably get away with this. */
1030 switch (hdr->sh_type)
1032 case SHT_IA_64_UNWIND:
1033 case SHT_IA_64_HP_OPT_ANOT:
1037 if (strcmp (name, ELF_STRING_ia64_archext) != 0)
1045 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1047 newsect = hdr->bfd_section;
1052 /* Convert IA-64 specific section flags to bfd internal section flags. */
1054 /* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
1058 elfNN_ia64_section_flags (flags, hdr)
1060 ElfNN_Internal_Shdr *hdr;
1062 if (hdr->sh_flags & SHF_IA_64_SHORT)
1063 *flags |= SEC_SMALL_DATA;
1068 /* Set the correct type for an IA-64 ELF section. We do this by the
1069 section name, which is a hack, but ought to work. */
1072 elfNN_ia64_fake_sections (abfd, hdr, sec)
1073 bfd *abfd ATTRIBUTE_UNUSED;
1074 ElfNN_Internal_Shdr *hdr;
1077 register const char *name;
1079 name = bfd_get_section_name (abfd, sec);
1081 if (is_unwind_section_name (abfd, name))
1083 /* We don't have the sections numbered at this point, so sh_info
1084 is set later, in elfNN_ia64_final_write_processing. */
1085 hdr->sh_type = SHT_IA_64_UNWIND;
1086 hdr->sh_flags |= SHF_LINK_ORDER;
1088 else if (strcmp (name, ELF_STRING_ia64_archext) == 0)
1089 hdr->sh_type = SHT_IA_64_EXT;
1090 else if (strcmp (name, ".HP.opt_annot") == 0)
1091 hdr->sh_type = SHT_IA_64_HP_OPT_ANOT;
1092 else if (strcmp (name, ".reloc") == 0)
1094 * This is an ugly, but unfortunately necessary hack that is
1095 * needed when producing EFI binaries on IA-64. It tells
1096 * elf.c:elf_fake_sections() not to consider ".reloc" as a section
1097 * containing ELF relocation info. We need this hack in order to
1098 * be able to generate ELF binaries that can be translated into
1099 * EFI applications (which are essentially COFF objects). Those
1100 * files contain a COFF ".reloc" section inside an ELFNN object,
1101 * which would normally cause BFD to segfault because it would
1102 * attempt to interpret this section as containing relocation
1103 * entries for section "oc". With this hack enabled, ".reloc"
1104 * will be treated as a normal data section, which will avoid the
1105 * segfault. However, you won't be able to create an ELFNN binary
1106 * with a section named "oc" that needs relocations, but that's
1107 * the kind of ugly side-effects you get when detecting section
1108 * types based on their names... In practice, this limitation is
1111 hdr->sh_type = SHT_PROGBITS;
1113 if (sec->flags & SEC_SMALL_DATA)
1114 hdr->sh_flags |= SHF_IA_64_SHORT;
1119 /* The final processing done just before writing out an IA-64 ELF
1123 elfNN_ia64_final_write_processing (abfd, linker)
1125 boolean linker ATTRIBUTE_UNUSED;
1127 Elf_Internal_Shdr *hdr;
1129 asection *text_sect, *s;
1132 for (s = abfd->sections; s; s = s->next)
1134 hdr = &elf_section_data (s)->this_hdr;
1135 switch (hdr->sh_type)
1137 case SHT_IA_64_UNWIND:
1138 /* See comments in gas/config/tc-ia64.c:dot_endp on why we
1140 sname = bfd_get_section_name (abfd, s);
1141 len = sizeof (ELF_STRING_ia64_unwind) - 1;
1142 if (sname && strncmp (sname, ELF_STRING_ia64_unwind, len) == 0)
1146 if (sname[0] == '\0')
1147 /* .IA_64.unwind -> .text */
1148 text_sect = bfd_get_section_by_name (abfd, ".text");
1150 /* .IA_64.unwindFOO -> FOO */
1151 text_sect = bfd_get_section_by_name (abfd, sname);
1154 && (len = sizeof (ELF_STRING_ia64_unwind_once) - 1,
1155 strncmp (sname, ELF_STRING_ia64_unwind_once, len)) == 0)
1157 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.t.FOO */
1158 size_t len2 = sizeof (".gnu.linkonce.t.") - 1;
1159 char *once_name = bfd_malloc (len2 + strlen (sname + len) + 1);
1161 if (once_name != NULL)
1163 memcpy (once_name, ".gnu.linkonce.t.", len2);
1164 strcpy (once_name + len2, sname + len);
1165 text_sect = bfd_get_section_by_name (abfd, once_name);
1169 /* Should only happen if we run out of memory, in
1170 which case we're probably toast anyway. Try to
1171 cope by finding the section the slow way. */
1172 for (text_sect = abfd->sections;
1174 text_sect = text_sect->next)
1176 if (strncmp (bfd_section_name (abfd, text_sect),
1177 ".gnu.linkonce.t.", len2) == 0
1178 && strcmp (bfd_section_name (abfd, text_sect) + len2,
1184 /* last resort: fall back on .text */
1185 text_sect = bfd_get_section_by_name (abfd, ".text");
1189 /* The IA-64 processor-specific ABI requires setting
1190 sh_link to the unwind section, whereas HP-UX requires
1191 sh_info to do so. For maximum compatibility, we'll
1192 set both for now... */
1193 hdr->sh_link = elf_section_data (text_sect)->this_idx;
1194 hdr->sh_info = elf_section_data (text_sect)->this_idx;
1201 /* Hook called by the linker routine which adds symbols from an object
1202 file. We use it to put .comm items in .sbss, and not .bss. */
1205 elfNN_ia64_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1207 struct bfd_link_info *info;
1208 const Elf_Internal_Sym *sym;
1209 const char **namep ATTRIBUTE_UNUSED;
1210 flagword *flagsp ATTRIBUTE_UNUSED;
1214 if (sym->st_shndx == SHN_COMMON
1215 && !info->relocateable
1216 && sym->st_size <= elf_gp_size (abfd))
1218 /* Common symbols less than or equal to -G nn bytes are
1219 automatically put into .sbss. */
1221 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1225 scomm = bfd_make_section (abfd, ".scommon");
1227 || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
1229 | SEC_LINKER_CREATED)))
1234 *valp = sym->st_size;
1241 elfNN_ia64_aix_vec (const bfd_target *vec)
1243 extern const bfd_target bfd_elfNN_ia64_aix_little_vec;
1244 extern const bfd_target bfd_elfNN_ia64_aix_big_vec;
1246 return (/**/vec == & bfd_elfNN_ia64_aix_little_vec
1247 || vec == & bfd_elfNN_ia64_aix_big_vec);
1250 /* Hook called by the linker routine which adds symbols from an object
1251 file. We use it to handle OS-specific symbols. */
1254 elfNN_ia64_aix_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1256 struct bfd_link_info *info;
1257 const Elf_Internal_Sym *sym;
1263 if (strcmp (*namep, "__GLOB_DATA_PTR") == 0)
1265 /* Define __GLOB_DATA_PTR when it is encountered. This is expected to
1266 be a linker-defined symbol by the Aix C runtime startup code. IBM sez
1267 no one else should use it b/c it is undocumented. */
1268 struct elf_link_hash_entry *h;
1270 h = elf_link_hash_lookup (elf_hash_table (info), *namep,
1271 false, false, false);
1274 struct elf_backend_data *bed;
1275 struct elfNN_ia64_link_hash_table *ia64_info;
1276 struct bfd_link_hash_entry *bh = NULL;
1278 bed = get_elf_backend_data (abfd);
1279 ia64_info = elfNN_ia64_hash_table (info);
1281 if (!(_bfd_generic_link_add_one_symbol
1282 (info, abfd, *namep, BSF_GLOBAL,
1283 bfd_get_section_by_name (abfd, ".bss"),
1284 bed->got_symbol_offset, (const char *) NULL, false,
1285 bed->collect, &bh)))
1288 h = (struct elf_link_hash_entry *) bh;
1289 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
1290 h->type = STT_OBJECT;
1292 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
1298 else if (sym->st_shndx == SHN_LOOS)
1302 /* SHN_AIX_SYSCALL: Treat this as any other symbol. The special symbol
1303 is only relevant when compiling code for extended system calls.
1304 Replace the "special" section with .text, if possible.
1305 Note that these symbols are always assumed to be in .text. */
1306 for (i = 1; i < elf_numsections (abfd); i++)
1308 asection * sec = bfd_section_from_elf_index (abfd, i);
1310 if (sec && strcmp (sec->name, ".text") == 0)
1318 *secp = bfd_abs_section_ptr;
1320 *valp = sym->st_size;
1326 return elfNN_ia64_add_symbol_hook (abfd, info, sym,
1327 namep, flagsp, secp, valp);
1332 elfNN_ia64_aix_link_add_symbols (abfd, info)
1334 struct bfd_link_info *info;
1336 /* Make sure dynamic sections are always created. */
1337 if (! elf_hash_table (info)->dynamic_sections_created
1338 && abfd->xvec == info->hash->creator)
1340 if (! bfd_elfNN_link_create_dynamic_sections (abfd, info))
1344 /* Now do the standard call. */
1345 return bfd_elfNN_bfd_link_add_symbols (abfd, info);
1348 /* Return the number of additional phdrs we will need. */
1351 elfNN_ia64_additional_program_headers (abfd)
1357 /* See if we need a PT_IA_64_ARCHEXT segment. */
1358 s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_archext);
1359 if (s && (s->flags & SEC_LOAD))
1362 /* Count how many PT_IA_64_UNWIND segments we need. */
1363 for (s = abfd->sections; s; s = s->next)
1364 if (is_unwind_section_name (abfd, s->name) && (s->flags & SEC_LOAD))
1371 elfNN_ia64_modify_segment_map (abfd)
1374 struct elf_segment_map *m, **pm;
1375 Elf_Internal_Shdr *hdr;
1378 /* If we need a PT_IA_64_ARCHEXT segment, it must come before
1379 all PT_LOAD segments. */
1380 s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_archext);
1381 if (s && (s->flags & SEC_LOAD))
1383 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
1384 if (m->p_type == PT_IA_64_ARCHEXT)
1388 m = ((struct elf_segment_map *)
1389 bfd_zalloc (abfd, (bfd_size_type) sizeof *m));
1393 m->p_type = PT_IA_64_ARCHEXT;
1397 /* We want to put it after the PHDR and INTERP segments. */
1398 pm = &elf_tdata (abfd)->segment_map;
1400 && ((*pm)->p_type == PT_PHDR
1401 || (*pm)->p_type == PT_INTERP))
1409 /* Install PT_IA_64_UNWIND segments, if needed. */
1410 for (s = abfd->sections; s; s = s->next)
1412 hdr = &elf_section_data (s)->this_hdr;
1413 if (hdr->sh_type != SHT_IA_64_UNWIND)
1416 if (s && (s->flags & SEC_LOAD))
1418 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
1419 if (m->p_type == PT_IA_64_UNWIND)
1423 /* Look through all sections in the unwind segment
1424 for a match since there may be multiple sections
1426 for (i = m->count - 1; i >= 0; --i)
1427 if (m->sections[i] == s)
1436 m = ((struct elf_segment_map *)
1437 bfd_zalloc (abfd, (bfd_size_type) sizeof *m));
1441 m->p_type = PT_IA_64_UNWIND;
1446 /* We want to put it last. */
1447 pm = &elf_tdata (abfd)->segment_map;
1455 /* Turn on PF_IA_64_NORECOV if needed. This involves traversing all of
1456 the input sections for each output section in the segment and testing
1457 for SHF_IA_64_NORECOV on each. */
1458 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
1459 if (m->p_type == PT_LOAD)
1462 for (i = m->count - 1; i >= 0; --i)
1464 struct bfd_link_order *order = m->sections[i]->link_order_head;
1467 if (order->type == bfd_indirect_link_order)
1469 asection *is = order->u.indirect.section;
1470 bfd_vma flags = elf_section_data(is)->this_hdr.sh_flags;
1471 if (flags & SHF_IA_64_NORECOV)
1473 m->p_flags |= PF_IA_64_NORECOV;
1477 order = order->next;
1486 /* According to the Tahoe assembler spec, all labels starting with a
1490 elfNN_ia64_is_local_label_name (abfd, name)
1491 bfd *abfd ATTRIBUTE_UNUSED;
1494 return name[0] == '.';
1497 /* Should we do dynamic things to this symbol? */
1500 elfNN_ia64_dynamic_symbol_p (h, info)
1501 struct elf_link_hash_entry *h;
1502 struct bfd_link_info *info;
1507 while (h->root.type == bfd_link_hash_indirect
1508 || h->root.type == bfd_link_hash_warning)
1509 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1511 if (h->dynindx == -1)
1513 switch (ELF_ST_VISIBILITY (h->other))
1520 if (h->root.type == bfd_link_hash_undefweak
1521 || h->root.type == bfd_link_hash_defweak)
1524 if ((info->shared && (!info->symbolic || info->allow_shlib_undefined))
1525 || ((h->elf_link_hash_flags
1526 & (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR))
1527 == (ELF_LINK_HASH_DEF_DYNAMIC | ELF_LINK_HASH_REF_REGULAR)))
1534 elfNN_ia64_local_hash_table_init (ht, abfd, new)
1535 struct elfNN_ia64_local_hash_table *ht;
1536 bfd *abfd ATTRIBUTE_UNUSED;
1537 new_hash_entry_func new;
1539 memset (ht, 0, sizeof (*ht));
1540 return bfd_hash_table_init (&ht->root, new);
1543 static struct bfd_hash_entry*
1544 elfNN_ia64_new_loc_hash_entry (entry, table, string)
1545 struct bfd_hash_entry *entry;
1546 struct bfd_hash_table *table;
1549 struct elfNN_ia64_local_hash_entry *ret;
1550 ret = (struct elfNN_ia64_local_hash_entry *) entry;
1552 /* Allocate the structure if it has not already been allocated by a
1555 ret = bfd_hash_allocate (table, sizeof (*ret));
1560 /* Initialize our local data. All zeros, and definitely easier
1561 than setting a handful of bit fields. */
1562 memset (ret, 0, sizeof (*ret));
1564 /* Call the allocation method of the superclass. */
1565 ret = ((struct elfNN_ia64_local_hash_entry *)
1566 bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
1568 return (struct bfd_hash_entry *) ret;
1571 static struct bfd_hash_entry*
1572 elfNN_ia64_new_elf_hash_entry (entry, table, string)
1573 struct bfd_hash_entry *entry;
1574 struct bfd_hash_table *table;
1577 struct elfNN_ia64_link_hash_entry *ret;
1578 ret = (struct elfNN_ia64_link_hash_entry *) entry;
1580 /* Allocate the structure if it has not already been allocated by a
1583 ret = bfd_hash_allocate (table, sizeof (*ret));
1588 /* Initialize our local data. All zeros, and definitely easier
1589 than setting a handful of bit fields. */
1590 memset (ret, 0, sizeof (*ret));
1592 /* Call the allocation method of the superclass. */
1593 ret = ((struct elfNN_ia64_link_hash_entry *)
1594 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1597 return (struct bfd_hash_entry *) ret;
1601 elfNN_ia64_hash_copy_indirect (bed, xdir, xind)
1602 struct elf_backend_data *bed ATTRIBUTE_UNUSED;
1603 struct elf_link_hash_entry *xdir, *xind;
1605 struct elfNN_ia64_link_hash_entry *dir, *ind;
1607 dir = (struct elfNN_ia64_link_hash_entry *) xdir;
1608 ind = (struct elfNN_ia64_link_hash_entry *) xind;
1610 /* Copy down any references that we may have already seen to the
1611 symbol which just became indirect. */
1613 dir->root.elf_link_hash_flags |=
1614 (ind->root.elf_link_hash_flags
1615 & (ELF_LINK_HASH_REF_DYNAMIC
1616 | ELF_LINK_HASH_REF_REGULAR
1617 | ELF_LINK_HASH_REF_REGULAR_NONWEAK));
1619 if (ind->root.root.type != bfd_link_hash_indirect)
1622 /* Copy over the got and plt data. This would have been done
1625 if (dir->info == NULL)
1627 struct elfNN_ia64_dyn_sym_info *dyn_i;
1629 dir->info = dyn_i = ind->info;
1632 /* Fix up the dyn_sym_info pointers to the global symbol. */
1633 for (; dyn_i; dyn_i = dyn_i->next)
1634 dyn_i->h = &dir->root;
1636 BFD_ASSERT (ind->info == NULL);
1638 /* Copy over the dynindx. */
1640 if (dir->root.dynindx == -1)
1642 dir->root.dynindx = ind->root.dynindx;
1643 dir->root.dynstr_index = ind->root.dynstr_index;
1644 ind->root.dynindx = -1;
1645 ind->root.dynstr_index = 0;
1647 BFD_ASSERT (ind->root.dynindx == -1);
1651 elfNN_ia64_hash_hide_symbol (info, xh, force_local)
1652 struct bfd_link_info *info;
1653 struct elf_link_hash_entry *xh;
1654 boolean force_local;
1656 struct elfNN_ia64_link_hash_entry *h;
1657 struct elfNN_ia64_dyn_sym_info *dyn_i;
1659 h = (struct elfNN_ia64_link_hash_entry *)xh;
1661 _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local);
1663 for (dyn_i = h->info; dyn_i; dyn_i = dyn_i->next)
1664 dyn_i->want_plt2 = 0;
1667 /* Create the derived linker hash table. The IA-64 ELF port uses this
1668 derived hash table to keep information specific to the IA-64 ElF
1669 linker (without using static variables). */
1671 static struct bfd_link_hash_table*
1672 elfNN_ia64_hash_table_create (abfd)
1675 struct elfNN_ia64_link_hash_table *ret;
1677 ret = bfd_zalloc (abfd, (bfd_size_type) sizeof (*ret));
1680 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
1681 elfNN_ia64_new_elf_hash_entry))
1683 bfd_release (abfd, ret);
1687 if (!elfNN_ia64_local_hash_table_init (&ret->loc_hash_table, abfd,
1688 elfNN_ia64_new_loc_hash_entry))
1690 return &ret->root.root;
1693 /* Look up an entry in a Alpha ELF linker hash table. */
1695 static INLINE struct elfNN_ia64_local_hash_entry *
1696 elfNN_ia64_local_hash_lookup(table, string, create, copy)
1697 struct elfNN_ia64_local_hash_table *table;
1699 boolean create, copy;
1701 return ((struct elfNN_ia64_local_hash_entry *)
1702 bfd_hash_lookup (&table->root, string, create, copy));
1705 /* Traverse both local and global hash tables. */
1707 struct elfNN_ia64_dyn_sym_traverse_data
1709 boolean (*func) PARAMS ((struct elfNN_ia64_dyn_sym_info *, PTR));
1714 elfNN_ia64_global_dyn_sym_thunk (xentry, xdata)
1715 struct bfd_hash_entry *xentry;
1718 struct elfNN_ia64_link_hash_entry *entry
1719 = (struct elfNN_ia64_link_hash_entry *) xentry;
1720 struct elfNN_ia64_dyn_sym_traverse_data *data
1721 = (struct elfNN_ia64_dyn_sym_traverse_data *) xdata;
1722 struct elfNN_ia64_dyn_sym_info *dyn_i;
1724 if (entry->root.root.type == bfd_link_hash_warning)
1725 entry = (struct elfNN_ia64_link_hash_entry *) entry->root.root.u.i.link;
1727 for (dyn_i = entry->info; dyn_i; dyn_i = dyn_i->next)
1728 if (! (*data->func) (dyn_i, data->data))
1734 elfNN_ia64_local_dyn_sym_thunk (xentry, xdata)
1735 struct bfd_hash_entry *xentry;
1738 struct elfNN_ia64_local_hash_entry *entry
1739 = (struct elfNN_ia64_local_hash_entry *) xentry;
1740 struct elfNN_ia64_dyn_sym_traverse_data *data
1741 = (struct elfNN_ia64_dyn_sym_traverse_data *) xdata;
1742 struct elfNN_ia64_dyn_sym_info *dyn_i;
1744 for (dyn_i = entry->info; dyn_i; dyn_i = dyn_i->next)
1745 if (! (*data->func) (dyn_i, data->data))
1751 elfNN_ia64_dyn_sym_traverse (ia64_info, func, data)
1752 struct elfNN_ia64_link_hash_table *ia64_info;
1753 boolean (*func) PARAMS ((struct elfNN_ia64_dyn_sym_info *, PTR));
1756 struct elfNN_ia64_dyn_sym_traverse_data xdata;
1761 elf_link_hash_traverse (&ia64_info->root,
1762 elfNN_ia64_global_dyn_sym_thunk, &xdata);
1763 bfd_hash_traverse (&ia64_info->loc_hash_table.root,
1764 elfNN_ia64_local_dyn_sym_thunk, &xdata);
1768 elfNN_ia64_create_dynamic_sections (abfd, info)
1770 struct bfd_link_info *info;
1772 struct elfNN_ia64_link_hash_table *ia64_info;
1775 if (! _bfd_elf_create_dynamic_sections (abfd, info))
1778 ia64_info = elfNN_ia64_hash_table (info);
1780 ia64_info->plt_sec = bfd_get_section_by_name (abfd, ".plt");
1781 ia64_info->got_sec = bfd_get_section_by_name (abfd, ".got");
1784 flagword flags = bfd_get_section_flags (abfd, ia64_info->got_sec);
1785 bfd_set_section_flags (abfd, ia64_info->got_sec, SEC_SMALL_DATA | flags);
1788 if (!get_pltoff (abfd, info, ia64_info))
1791 s = bfd_make_section(abfd, ".rela.IA_64.pltoff");
1793 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1796 | SEC_LINKER_CREATED
1798 || !bfd_set_section_alignment (abfd, s, 3))
1800 ia64_info->rel_pltoff_sec = s;
1802 s = bfd_make_section(abfd, ".rela.got");
1804 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1807 | SEC_LINKER_CREATED
1809 || !bfd_set_section_alignment (abfd, s, 3))
1811 ia64_info->rel_got_sec = s;
1816 /* Find and/or create a hash entry for local symbol. */
1817 static struct elfNN_ia64_local_hash_entry *
1818 get_local_sym_hash (ia64_info, abfd, rel, create)
1819 struct elfNN_ia64_link_hash_table *ia64_info;
1821 const Elf_Internal_Rela *rel;
1826 struct elfNN_ia64_local_hash_entry *ret;
1828 /* Construct a string for use in the elfNN_ia64_local_hash_table.
1829 name describes what was once anonymous memory. */
1831 len = sizeof (void*)*2 + 1 + sizeof (bfd_vma)*4 + 1 + 1;
1832 len += 10; /* %p slop */
1834 addr_name = bfd_malloc (len);
1835 if (addr_name == NULL)
1837 sprintf (addr_name, "%p:%lx",
1838 (void *) abfd, (unsigned long) ELFNN_R_SYM (rel->r_info));
1840 /* Collect the canonical entry data for this address. */
1841 ret = elfNN_ia64_local_hash_lookup (&ia64_info->loc_hash_table,
1842 addr_name, create, create);
1847 /* Find and/or create a descriptor for dynamic symbol info. This will
1848 vary based on global or local symbol, and the addend to the reloc. */
1850 static struct elfNN_ia64_dyn_sym_info *
1851 get_dyn_sym_info (ia64_info, h, abfd, rel, create)
1852 struct elfNN_ia64_link_hash_table *ia64_info;
1853 struct elf_link_hash_entry *h;
1855 const Elf_Internal_Rela *rel;
1858 struct elfNN_ia64_dyn_sym_info **pp;
1859 struct elfNN_ia64_dyn_sym_info *dyn_i;
1860 bfd_vma addend = rel ? rel->r_addend : 0;
1863 pp = &((struct elfNN_ia64_link_hash_entry *)h)->info;
1866 struct elfNN_ia64_local_hash_entry *loc_h;
1868 loc_h = get_local_sym_hash (ia64_info, abfd, rel, create);
1874 for (dyn_i = *pp; dyn_i && dyn_i->addend != addend; dyn_i = *pp)
1877 if (dyn_i == NULL && create)
1879 dyn_i = ((struct elfNN_ia64_dyn_sym_info *)
1880 bfd_zalloc (abfd, (bfd_size_type) sizeof *dyn_i));
1882 dyn_i->addend = addend;
1889 get_got (abfd, info, ia64_info)
1891 struct bfd_link_info *info;
1892 struct elfNN_ia64_link_hash_table *ia64_info;
1897 got = ia64_info->got_sec;
1902 dynobj = ia64_info->root.dynobj;
1904 ia64_info->root.dynobj = dynobj = abfd;
1905 if (!_bfd_elf_create_got_section (dynobj, info))
1908 got = bfd_get_section_by_name (dynobj, ".got");
1910 ia64_info->got_sec = got;
1912 flags = bfd_get_section_flags (abfd, got);
1913 bfd_set_section_flags (abfd, got, SEC_SMALL_DATA | flags);
1919 /* Create function descriptor section (.opd). This section is called .opd
1920 because it contains "official prodecure descriptors". The "official"
1921 refers to the fact that these descriptors are used when taking the address
1922 of a procedure, thus ensuring a unique address for each procedure. */
1925 get_fptr (abfd, info, ia64_info)
1927 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1928 struct elfNN_ia64_link_hash_table *ia64_info;
1933 fptr = ia64_info->fptr_sec;
1936 dynobj = ia64_info->root.dynobj;
1938 ia64_info->root.dynobj = dynobj = abfd;
1940 fptr = bfd_make_section (dynobj, ".opd");
1942 || !bfd_set_section_flags (dynobj, fptr,
1948 | SEC_LINKER_CREATED))
1949 || !bfd_set_section_alignment (abfd, fptr, 4))
1955 ia64_info->fptr_sec = fptr;
1962 get_pltoff (abfd, info, ia64_info)
1964 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1965 struct elfNN_ia64_link_hash_table *ia64_info;
1970 pltoff = ia64_info->pltoff_sec;
1973 dynobj = ia64_info->root.dynobj;
1975 ia64_info->root.dynobj = dynobj = abfd;
1977 pltoff = bfd_make_section (dynobj, ELF_STRING_ia64_pltoff);
1979 || !bfd_set_section_flags (dynobj, pltoff,
1985 | SEC_LINKER_CREATED))
1986 || !bfd_set_section_alignment (abfd, pltoff, 4))
1992 ia64_info->pltoff_sec = pltoff;
1999 get_reloc_section (abfd, ia64_info, sec, create)
2001 struct elfNN_ia64_link_hash_table *ia64_info;
2005 const char *srel_name;
2009 srel_name = (bfd_elf_string_from_elf_section
2010 (abfd, elf_elfheader(abfd)->e_shstrndx,
2011 elf_section_data(sec)->rel_hdr.sh_name));
2012 if (srel_name == NULL)
2015 BFD_ASSERT ((strncmp (srel_name, ".rela", 5) == 0
2016 && strcmp (bfd_get_section_name (abfd, sec),
2018 || (strncmp (srel_name, ".rel", 4) == 0
2019 && strcmp (bfd_get_section_name (abfd, sec),
2020 srel_name+4) == 0));
2022 dynobj = ia64_info->root.dynobj;
2024 ia64_info->root.dynobj = dynobj = abfd;
2026 srel = bfd_get_section_by_name (dynobj, srel_name);
2027 if (srel == NULL && create)
2029 srel = bfd_make_section (dynobj, srel_name);
2031 || !bfd_set_section_flags (dynobj, srel,
2036 | SEC_LINKER_CREATED
2038 || !bfd_set_section_alignment (dynobj, srel, 3))
2042 if (sec->flags & SEC_READONLY)
2043 ia64_info->reltext = 1;
2049 count_dyn_reloc (abfd, dyn_i, srel, type)
2051 struct elfNN_ia64_dyn_sym_info *dyn_i;
2055 struct elfNN_ia64_dyn_reloc_entry *rent;
2057 for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
2058 if (rent->srel == srel && rent->type == type)
2063 rent = ((struct elfNN_ia64_dyn_reloc_entry *)
2064 bfd_alloc (abfd, (bfd_size_type) sizeof (*rent)));
2068 rent->next = dyn_i->reloc_entries;
2072 dyn_i->reloc_entries = rent;
2080 elfNN_ia64_check_relocs (abfd, info, sec, relocs)
2082 struct bfd_link_info *info;
2084 const Elf_Internal_Rela *relocs;
2086 struct elfNN_ia64_link_hash_table *ia64_info;
2087 const Elf_Internal_Rela *relend;
2088 Elf_Internal_Shdr *symtab_hdr;
2089 const Elf_Internal_Rela *rel;
2090 asection *got, *fptr, *srel;
2092 if (info->relocateable)
2095 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2096 ia64_info = elfNN_ia64_hash_table (info);
2098 got = fptr = srel = NULL;
2100 relend = relocs + sec->reloc_count;
2101 for (rel = relocs; rel < relend; ++rel)
2110 NEED_LTOFF_FPTR = 64,
2116 struct elf_link_hash_entry *h = NULL;
2117 unsigned long r_symndx = ELFNN_R_SYM (rel->r_info);
2118 struct elfNN_ia64_dyn_sym_info *dyn_i;
2120 boolean maybe_dynamic;
2121 int dynrel_type = R_IA64_NONE;
2123 if (r_symndx >= symtab_hdr->sh_info)
2125 /* We're dealing with a global symbol -- find its hash entry
2126 and mark it as being referenced. */
2127 long indx = r_symndx - symtab_hdr->sh_info;
2128 h = elf_sym_hashes (abfd)[indx];
2129 while (h->root.type == bfd_link_hash_indirect
2130 || h->root.type == bfd_link_hash_warning)
2131 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2133 h->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
2136 /* We can only get preliminary data on whether a symbol is
2137 locally or externally defined, as not all of the input files
2138 have yet been processed. Do something with what we know, as
2139 this may help reduce memory usage and processing time later. */
2140 maybe_dynamic = false;
2141 if (h && ((info->shared
2142 && (!info->symbolic || info->allow_shlib_undefined))
2143 || ! (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
2144 || h->root.type == bfd_link_hash_defweak
2145 || elfNN_ia64_aix_vec (abfd->xvec)))
2146 maybe_dynamic = true;
2149 switch (ELFNN_R_TYPE (rel->r_info))
2151 case R_IA64_TPREL64MSB:
2152 case R_IA64_TPREL64LSB:
2153 if (info->shared || maybe_dynamic)
2154 need_entry = NEED_DYNREL;
2155 dynrel_type = R_IA64_TPREL64LSB;
2157 info->flags |= DF_STATIC_TLS;
2160 case R_IA64_LTOFF_TPREL22:
2161 need_entry = NEED_TPREL;
2163 info->flags |= DF_STATIC_TLS;
2166 case R_IA64_DTPREL64MSB:
2167 case R_IA64_DTPREL64LSB:
2168 if (info->shared || maybe_dynamic)
2169 need_entry = NEED_DYNREL;
2170 dynrel_type = R_IA64_DTPREL64LSB;
2173 case R_IA64_LTOFF_DTPREL22:
2174 need_entry = NEED_DTPREL;
2177 case R_IA64_DTPMOD64MSB:
2178 case R_IA64_DTPMOD64LSB:
2179 if (info->shared || maybe_dynamic)
2180 need_entry = NEED_DYNREL;
2181 dynrel_type = R_IA64_DTPMOD64LSB;
2184 case R_IA64_LTOFF_DTPMOD22:
2185 need_entry = NEED_DTPMOD;
2188 case R_IA64_LTOFF_FPTR22:
2189 case R_IA64_LTOFF_FPTR64I:
2190 case R_IA64_LTOFF_FPTR32MSB:
2191 case R_IA64_LTOFF_FPTR32LSB:
2192 case R_IA64_LTOFF_FPTR64MSB:
2193 case R_IA64_LTOFF_FPTR64LSB:
2194 need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR;
2197 case R_IA64_FPTR64I:
2198 case R_IA64_FPTR32MSB:
2199 case R_IA64_FPTR32LSB:
2200 case R_IA64_FPTR64MSB:
2201 case R_IA64_FPTR64LSB:
2202 if (info->shared || h || elfNN_ia64_aix_vec (abfd->xvec))
2203 need_entry = NEED_FPTR | NEED_DYNREL;
2205 need_entry = NEED_FPTR;
2206 dynrel_type = R_IA64_FPTR64LSB;
2209 case R_IA64_LTOFF22:
2210 case R_IA64_LTOFF22X:
2211 case R_IA64_LTOFF64I:
2212 need_entry = NEED_GOT;
2215 case R_IA64_PLTOFF22:
2216 case R_IA64_PLTOFF64I:
2217 case R_IA64_PLTOFF64MSB:
2218 case R_IA64_PLTOFF64LSB:
2219 need_entry = NEED_PLTOFF;
2223 need_entry |= NEED_MIN_PLT;
2227 (*info->callbacks->warning)
2228 (info, _("@pltoff reloc against local symbol"), 0,
2229 abfd, 0, (bfd_vma) 0);
2233 case R_IA64_PCREL21B:
2234 case R_IA64_PCREL60B:
2235 /* Depending on where this symbol is defined, we may or may not
2236 need a full plt entry. Only skip if we know we'll not need
2237 the entry -- static or symbolic, and the symbol definition
2238 has already been seen. */
2239 if (maybe_dynamic && rel->r_addend == 0)
2240 need_entry = NEED_FULL_PLT;
2246 case R_IA64_DIR32MSB:
2247 case R_IA64_DIR32LSB:
2248 case R_IA64_DIR64MSB:
2249 case R_IA64_DIR64LSB:
2250 /* Shared objects will always need at least a REL relocation. */
2251 if (info->shared || maybe_dynamic
2252 || (elfNN_ia64_aix_vec (abfd->xvec)
2253 && (!h || strcmp (h->root.root.string,
2254 "__GLOB_DATA_PTR") != 0)))
2255 need_entry = NEED_DYNREL;
2256 dynrel_type = R_IA64_DIR64LSB;
2259 case R_IA64_IPLTMSB:
2260 case R_IA64_IPLTLSB:
2261 /* Shared objects will always need at least a REL relocation. */
2262 if (info->shared || maybe_dynamic)
2263 need_entry = NEED_DYNREL;
2264 dynrel_type = R_IA64_IPLTLSB;
2267 case R_IA64_PCREL22:
2268 case R_IA64_PCREL64I:
2269 case R_IA64_PCREL32MSB:
2270 case R_IA64_PCREL32LSB:
2271 case R_IA64_PCREL64MSB:
2272 case R_IA64_PCREL64LSB:
2274 need_entry = NEED_DYNREL;
2275 dynrel_type = R_IA64_PCREL64LSB;
2282 if ((need_entry & NEED_FPTR) != 0
2285 (*info->callbacks->warning)
2286 (info, _("non-zero addend in @fptr reloc"), 0,
2287 abfd, 0, (bfd_vma) 0);
2290 dyn_i = get_dyn_sym_info (ia64_info, h, abfd, rel, true);
2292 /* Record whether or not this is a local symbol. */
2295 /* Create what's needed. */
2296 if (need_entry & (NEED_GOT | NEED_TPREL | NEED_DTPMOD | NEED_DTPREL))
2300 got = get_got (abfd, info, ia64_info);
2304 if (need_entry & NEED_GOT)
2305 dyn_i->want_got = 1;
2306 if (need_entry & NEED_TPREL)
2307 dyn_i->want_tprel = 1;
2308 if (need_entry & NEED_DTPMOD)
2309 dyn_i->want_dtpmod = 1;
2310 if (need_entry & NEED_DTPREL)
2311 dyn_i->want_dtprel = 1;
2313 if (need_entry & NEED_FPTR)
2317 fptr = get_fptr (abfd, info, ia64_info);
2322 /* FPTRs for shared libraries are allocated by the dynamic
2323 linker. Make sure this local symbol will appear in the
2324 dynamic symbol table. */
2325 if (!h && (info->shared
2326 /* AIX also needs one */
2327 || elfNN_ia64_aix_vec (abfd->xvec)))
2329 if (! (_bfd_elfNN_link_record_local_dynamic_symbol
2330 (info, abfd, (long) r_symndx)))
2334 dyn_i->want_fptr = 1;
2336 if (need_entry & NEED_LTOFF_FPTR)
2337 dyn_i->want_ltoff_fptr = 1;
2338 if (need_entry & (NEED_MIN_PLT | NEED_FULL_PLT))
2340 if (!ia64_info->root.dynobj)
2341 ia64_info->root.dynobj = abfd;
2342 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2343 dyn_i->want_plt = 1;
2345 if (need_entry & NEED_FULL_PLT)
2346 dyn_i->want_plt2 = 1;
2347 if (need_entry & NEED_PLTOFF)
2348 dyn_i->want_pltoff = 1;
2349 if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC))
2353 srel = get_reloc_section (abfd, ia64_info, sec, true);
2357 if (!count_dyn_reloc (abfd, dyn_i, srel, dynrel_type))
2365 struct elfNN_ia64_allocate_data
2367 struct bfd_link_info *info;
2371 /* For cleanliness, and potentially faster dynamic loading, allocate
2372 external GOT entries first. */
2375 allocate_global_data_got (dyn_i, data)
2376 struct elfNN_ia64_dyn_sym_info *dyn_i;
2379 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2382 && ! dyn_i->want_fptr
2383 && (elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info)
2384 || (elfNN_ia64_aix_vec (x->info->hash->creator)
2385 && (!dyn_i->h || strcmp (dyn_i->h->root.root.string,
2386 "__GLOB_DATA_PTR") != 0))))
2388 dyn_i->got_offset = x->ofs;
2391 if (dyn_i->want_tprel)
2393 dyn_i->tprel_offset = x->ofs;
2396 if (dyn_i->want_dtpmod)
2398 dyn_i->dtpmod_offset = x->ofs;
2401 if (dyn_i->want_dtprel)
2403 dyn_i->dtprel_offset = x->ofs;
2409 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
2412 allocate_global_fptr_got (dyn_i, data)
2413 struct elfNN_ia64_dyn_sym_info *dyn_i;
2416 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2420 && (elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info)
2421 || elfNN_ia64_aix_vec (x->info->hash->creator)))
2423 dyn_i->got_offset = x->ofs;
2429 /* Lastly, allocate all the GOT entries for local data. */
2432 allocate_local_got (dyn_i, data)
2433 struct elfNN_ia64_dyn_sym_info *dyn_i;
2436 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2439 && ! (elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info)
2440 || elfNN_ia64_aix_vec (x->info->hash->creator)))
2442 dyn_i->got_offset = x->ofs;
2448 /* Search for the index of a global symbol in it's defining object file. */
2451 global_sym_index (h)
2452 struct elf_link_hash_entry *h;
2454 struct elf_link_hash_entry **p;
2457 BFD_ASSERT (h->root.type == bfd_link_hash_defined
2458 || h->root.type == bfd_link_hash_defweak);
2460 obj = h->root.u.def.section->owner;
2461 for (p = elf_sym_hashes (obj); *p != h; ++p)
2464 return p - elf_sym_hashes (obj) + elf_tdata (obj)->symtab_hdr.sh_info;
2467 /* Allocate function descriptors. We can do these for every function
2468 in a main executable that is not exported. */
2471 allocate_fptr (dyn_i, data)
2472 struct elfNN_ia64_dyn_sym_info *dyn_i;
2475 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2477 if (dyn_i->want_fptr)
2479 struct elf_link_hash_entry *h = dyn_i->h;
2482 while (h->root.type == bfd_link_hash_indirect
2483 || h->root.type == bfd_link_hash_warning)
2484 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2487 /* AIX needs an FPTR in this case. */
2488 || (elfNN_ia64_aix_vec (x->info->hash->creator)
2490 || h->root.type == bfd_link_hash_defined
2491 || h->root.type == bfd_link_hash_defweak)))
2493 if (h && h->dynindx == -1)
2495 BFD_ASSERT ((h->root.type == bfd_link_hash_defined)
2496 || (h->root.type == bfd_link_hash_defweak));
2498 if (!_bfd_elfNN_link_record_local_dynamic_symbol
2499 (x->info, h->root.u.def.section->owner,
2500 global_sym_index (h)))
2504 dyn_i->want_fptr = 0;
2506 else if (h == NULL || h->dynindx == -1)
2508 dyn_i->fptr_offset = x->ofs;
2512 dyn_i->want_fptr = 0;
2517 /* Allocate all the minimal PLT entries. */
2520 allocate_plt_entries (dyn_i, data)
2521 struct elfNN_ia64_dyn_sym_info *dyn_i;
2524 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2526 if (dyn_i->want_plt)
2528 struct elf_link_hash_entry *h = dyn_i->h;
2531 while (h->root.type == bfd_link_hash_indirect
2532 || h->root.type == bfd_link_hash_warning)
2533 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2535 /* ??? Versioned symbols seem to lose ELF_LINK_HASH_NEEDS_PLT. */
2536 if (elfNN_ia64_dynamic_symbol_p (h, x->info))
2538 bfd_size_type offset = x->ofs;
2540 offset = PLT_HEADER_SIZE;
2541 dyn_i->plt_offset = offset;
2542 x->ofs = offset + PLT_MIN_ENTRY_SIZE;
2544 dyn_i->want_pltoff = 1;
2548 dyn_i->want_plt = 0;
2549 dyn_i->want_plt2 = 0;
2555 /* Allocate all the full PLT entries. */
2558 allocate_plt2_entries (dyn_i, data)
2559 struct elfNN_ia64_dyn_sym_info *dyn_i;
2562 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2564 if (dyn_i->want_plt2)
2566 struct elf_link_hash_entry *h = dyn_i->h;
2567 bfd_size_type ofs = x->ofs;
2569 dyn_i->plt2_offset = ofs;
2570 x->ofs = ofs + PLT_FULL_ENTRY_SIZE;
2572 while (h->root.type == bfd_link_hash_indirect
2573 || h->root.type == bfd_link_hash_warning)
2574 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2575 dyn_i->h->plt.offset = ofs;
2580 /* Allocate all the PLTOFF entries requested by relocations and
2581 plt entries. We can't share space with allocated FPTR entries,
2582 because the latter are not necessarily addressable by the GP.
2583 ??? Relaxation might be able to determine that they are. */
2586 allocate_pltoff_entries (dyn_i, data)
2587 struct elfNN_ia64_dyn_sym_info *dyn_i;
2590 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2592 if (dyn_i->want_pltoff)
2594 dyn_i->pltoff_offset = x->ofs;
2600 /* Allocate dynamic relocations for those symbols that turned out
2604 allocate_dynrel_entries (dyn_i, data)
2605 struct elfNN_ia64_dyn_sym_info *dyn_i;
2608 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2609 struct elfNN_ia64_link_hash_table *ia64_info;
2610 struct elfNN_ia64_dyn_reloc_entry *rent;
2611 boolean dynamic_symbol, shared;
2613 ia64_info = elfNN_ia64_hash_table (x->info);
2614 dynamic_symbol = elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info)
2615 || (elfNN_ia64_aix_vec (x->info->hash->creator)
2616 /* Don't allocate an entry for __GLOB_DATA_PTR */
2617 && (!dyn_i->h || strcmp (dyn_i->h->root.root.string,
2618 "__GLOB_DATA_PTR") != 0));
2619 shared = x->info->shared;
2621 /* Take care of the normal data relocations. */
2623 for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
2625 int count = rent->count;
2629 case R_IA64_FPTR64LSB:
2630 /* Allocate one iff !want_fptr, which by this point will
2631 be true only if we're actually allocating one statically
2632 in the main executable. */
2633 if (dyn_i->want_fptr)
2636 case R_IA64_PCREL64LSB:
2637 if (!dynamic_symbol)
2640 case R_IA64_DIR64LSB:
2641 if (!dynamic_symbol && !shared)
2644 case R_IA64_IPLTLSB:
2645 if (!dynamic_symbol && !shared)
2647 /* Use two REL relocations for IPLT relocations
2648 against local symbols. */
2649 if (!dynamic_symbol)
2652 case R_IA64_TPREL64LSB:
2653 case R_IA64_DTPREL64LSB:
2654 case R_IA64_DTPMOD64LSB:
2659 rent->srel->_raw_size += sizeof (ElfNN_External_Rela) * count;
2662 /* Take care of the GOT and PLT relocations. */
2664 if (((dynamic_symbol || shared) && dyn_i->want_got)
2665 || (dyn_i->want_ltoff_fptr && dyn_i->h && dyn_i->h->dynindx != -1))
2666 ia64_info->rel_got_sec->_raw_size += sizeof (ElfNN_External_Rela);
2667 if ((dynamic_symbol || shared) && dyn_i->want_tprel)
2668 ia64_info->rel_got_sec->_raw_size += sizeof (ElfNN_External_Rela);
2669 if ((dynamic_symbol || shared) && dyn_i->want_dtpmod)
2670 ia64_info->rel_got_sec->_raw_size += sizeof (ElfNN_External_Rela);
2671 if (dynamic_symbol && dyn_i->want_dtprel)
2672 ia64_info->rel_got_sec->_raw_size += sizeof (ElfNN_External_Rela);
2674 if (dyn_i->want_pltoff)
2676 bfd_size_type t = 0;
2678 /* Dynamic symbols get one IPLT relocation. Local symbols in
2679 shared libraries get two REL relocations. Local symbols in
2680 main applications get nothing. */
2682 t = sizeof (ElfNN_External_Rela);
2684 t = 2 * sizeof (ElfNN_External_Rela);
2686 ia64_info->rel_pltoff_sec->_raw_size += t;
2693 elfNN_ia64_adjust_dynamic_symbol (info, h)
2694 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2695 struct elf_link_hash_entry *h;
2697 /* ??? Undefined symbols with PLT entries should be re-defined
2698 to be the PLT entry. */
2700 /* If this is a weak symbol, and there is a real definition, the
2701 processor independent code will have arranged for us to see the
2702 real definition first, and we can just use the same value. */
2703 if (h->weakdef != NULL)
2705 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2706 || h->weakdef->root.type == bfd_link_hash_defweak);
2707 h->root.u.def.section = h->weakdef->root.u.def.section;
2708 h->root.u.def.value = h->weakdef->root.u.def.value;
2712 /* If this is a reference to a symbol defined by a dynamic object which
2713 is not a function, we might allocate the symbol in our .dynbss section
2714 and allocate a COPY dynamic relocation.
2716 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2723 elfNN_ia64_size_dynamic_sections (output_bfd, info)
2725 struct bfd_link_info *info;
2727 struct elfNN_ia64_allocate_data data;
2728 struct elfNN_ia64_link_hash_table *ia64_info;
2731 boolean relplt = false;
2733 dynobj = elf_hash_table(info)->dynobj;
2734 ia64_info = elfNN_ia64_hash_table (info);
2735 BFD_ASSERT(dynobj != NULL);
2738 /* Set the contents of the .interp section to the interpreter. */
2739 if (ia64_info->root.dynamic_sections_created
2742 sec = bfd_get_section_by_name (dynobj, ".interp");
2743 BFD_ASSERT (sec != NULL);
2744 sec->contents = (bfd_byte *) DYNAMIC_INTERPRETER (output_bfd);
2745 sec->_raw_size = strlen (DYNAMIC_INTERPRETER (output_bfd)) + 1;
2748 /* Allocate the GOT entries. */
2750 if (ia64_info->got_sec)
2753 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data);
2754 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data);
2755 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data);
2756 ia64_info->got_sec->_raw_size = data.ofs;
2759 /* Allocate the FPTR entries. */
2761 if (ia64_info->fptr_sec)
2764 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_fptr, &data);
2765 ia64_info->fptr_sec->_raw_size = data.ofs;
2768 /* Now that we've seen all of the input files, we can decide which
2769 symbols need plt entries. Allocate the minimal PLT entries first.
2770 We do this even though dynamic_sections_created may be false, because
2771 this has the side-effect of clearing want_plt and want_plt2. */
2774 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_plt_entries, &data);
2776 ia64_info->minplt_entries = 0;
2779 ia64_info->minplt_entries
2780 = (data.ofs - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
2783 /* Align the pointer for the plt2 entries. */
2784 data.ofs = (data.ofs + 31) & (bfd_vma) -32;
2786 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_plt2_entries, &data);
2789 BFD_ASSERT (ia64_info->root.dynamic_sections_created);
2791 ia64_info->plt_sec->_raw_size = data.ofs;
2793 /* If we've got a .plt, we need some extra memory for the dynamic
2794 linker. We stuff these in .got.plt. */
2795 sec = bfd_get_section_by_name (dynobj, ".got.plt");
2796 sec->_raw_size = 8 * PLT_RESERVED_WORDS;
2799 /* Allocate the PLTOFF entries. */
2801 if (ia64_info->pltoff_sec)
2804 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_pltoff_entries, &data);
2805 ia64_info->pltoff_sec->_raw_size = data.ofs;
2808 if (ia64_info->root.dynamic_sections_created)
2810 /* Allocate space for the dynamic relocations that turned out to be
2813 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries, &data);
2816 /* We have now determined the sizes of the various dynamic sections.
2817 Allocate memory for them. */
2818 for (sec = dynobj->sections; sec != NULL; sec = sec->next)
2822 if (!(sec->flags & SEC_LINKER_CREATED))
2825 /* If we don't need this section, strip it from the output file.
2826 There were several sections primarily related to dynamic
2827 linking that must be create before the linker maps input
2828 sections to output sections. The linker does that before
2829 bfd_elf_size_dynamic_sections is called, and it is that
2830 function which decides whether anything needs to go into
2833 strip = (sec->_raw_size == 0);
2835 if (sec == ia64_info->got_sec)
2837 else if (sec == ia64_info->rel_got_sec)
2840 ia64_info->rel_got_sec = NULL;
2842 /* We use the reloc_count field as a counter if we need to
2843 copy relocs into the output file. */
2844 sec->reloc_count = 0;
2846 else if (sec == ia64_info->fptr_sec)
2849 ia64_info->fptr_sec = NULL;
2851 else if (sec == ia64_info->plt_sec)
2854 ia64_info->plt_sec = NULL;
2856 else if (sec == ia64_info->pltoff_sec)
2859 ia64_info->pltoff_sec = NULL;
2861 else if (sec == ia64_info->rel_pltoff_sec)
2864 ia64_info->rel_pltoff_sec = NULL;
2868 /* We use the reloc_count field as a counter if we need to
2869 copy relocs into the output file. */
2870 sec->reloc_count = 0;
2877 /* It's OK to base decisions on the section name, because none
2878 of the dynobj section names depend upon the input files. */
2879 name = bfd_get_section_name (dynobj, sec);
2881 if (strcmp (name, ".got.plt") == 0)
2883 else if (strncmp (name, ".rel", 4) == 0)
2887 /* We use the reloc_count field as a counter if we need to
2888 copy relocs into the output file. */
2889 sec->reloc_count = 0;
2897 _bfd_strip_section_from_output (info, sec);
2900 /* Allocate memory for the section contents. */
2901 sec->contents = (bfd_byte *) bfd_zalloc (dynobj, sec->_raw_size);
2902 if (sec->contents == NULL && sec->_raw_size != 0)
2907 if (elf_hash_table (info)->dynamic_sections_created)
2909 /* Add some entries to the .dynamic section. We fill in the values
2910 later (in finish_dynamic_sections) but we must add the entries now
2911 so that we get the correct size for the .dynamic section. */
2915 /* The DT_DEBUG entry is filled in by the dynamic linker and used
2917 #define add_dynamic_entry(TAG, VAL) \
2918 bfd_elfNN_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
2920 if (!add_dynamic_entry (DT_DEBUG, 0))
2924 if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE, 0))
2926 if (!add_dynamic_entry (DT_PLTGOT, 0))
2931 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
2932 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2933 || !add_dynamic_entry (DT_JMPREL, 0))
2937 if (!add_dynamic_entry (DT_RELA, 0)
2938 || !add_dynamic_entry (DT_RELASZ, 0)
2939 || !add_dynamic_entry (DT_RELAENT, sizeof (ElfNN_External_Rela)))
2942 if (ia64_info->reltext)
2944 if (!add_dynamic_entry (DT_TEXTREL, 0))
2946 info->flags |= DF_TEXTREL;
2950 /* ??? Perhaps force __gp local. */
2955 static bfd_reloc_status_type
2956 elfNN_ia64_install_value (abfd, hit_addr, v, r_type)
2960 unsigned int r_type;
2962 const struct ia64_operand *op;
2963 int bigendian = 0, shift = 0;
2964 bfd_vma t0, t1, insn, dword;
2965 enum ia64_opnd opnd;
2968 #ifdef BFD_HOST_U_64_BIT
2969 BFD_HOST_U_64_BIT val = (BFD_HOST_U_64_BIT) v;
2974 opnd = IA64_OPND_NIL;
2979 return bfd_reloc_ok;
2981 /* Instruction relocations. */
2984 case R_IA64_TPREL14:
2985 case R_IA64_DTPREL14:
2986 opnd = IA64_OPND_IMM14;
2989 case R_IA64_PCREL21F: opnd = IA64_OPND_TGT25; break;
2990 case R_IA64_PCREL21M: opnd = IA64_OPND_TGT25b; break;
2991 case R_IA64_PCREL60B: opnd = IA64_OPND_TGT64; break;
2992 case R_IA64_PCREL21B:
2993 case R_IA64_PCREL21BI:
2994 opnd = IA64_OPND_TGT25c;
2998 case R_IA64_GPREL22:
2999 case R_IA64_LTOFF22:
3000 case R_IA64_LTOFF22X:
3001 case R_IA64_PLTOFF22:
3002 case R_IA64_PCREL22:
3003 case R_IA64_LTOFF_FPTR22:
3004 case R_IA64_TPREL22:
3005 case R_IA64_DTPREL22:
3006 case R_IA64_LTOFF_TPREL22:
3007 case R_IA64_LTOFF_DTPMOD22:
3008 case R_IA64_LTOFF_DTPREL22:
3009 opnd = IA64_OPND_IMM22;
3013 case R_IA64_GPREL64I:
3014 case R_IA64_LTOFF64I:
3015 case R_IA64_PLTOFF64I:
3016 case R_IA64_PCREL64I:
3017 case R_IA64_FPTR64I:
3018 case R_IA64_LTOFF_FPTR64I:
3019 case R_IA64_TPREL64I:
3020 case R_IA64_DTPREL64I:
3021 opnd = IA64_OPND_IMMU64;
3024 /* Data relocations. */
3026 case R_IA64_DIR32MSB:
3027 case R_IA64_GPREL32MSB:
3028 case R_IA64_FPTR32MSB:
3029 case R_IA64_PCREL32MSB:
3030 case R_IA64_LTOFF_FPTR32MSB:
3031 case R_IA64_SEGREL32MSB:
3032 case R_IA64_SECREL32MSB:
3033 case R_IA64_LTV32MSB:
3034 case R_IA64_DTPREL32MSB:
3035 size = 4; bigendian = 1;
3038 case R_IA64_DIR32LSB:
3039 case R_IA64_GPREL32LSB:
3040 case R_IA64_FPTR32LSB:
3041 case R_IA64_PCREL32LSB:
3042 case R_IA64_LTOFF_FPTR32LSB:
3043 case R_IA64_SEGREL32LSB:
3044 case R_IA64_SECREL32LSB:
3045 case R_IA64_LTV32LSB:
3046 case R_IA64_DTPREL32LSB:
3047 size = 4; bigendian = 0;
3050 case R_IA64_DIR64MSB:
3051 case R_IA64_GPREL64MSB:
3052 case R_IA64_PLTOFF64MSB:
3053 case R_IA64_FPTR64MSB:
3054 case R_IA64_PCREL64MSB:
3055 case R_IA64_LTOFF_FPTR64MSB:
3056 case R_IA64_SEGREL64MSB:
3057 case R_IA64_SECREL64MSB:
3058 case R_IA64_LTV64MSB:
3059 case R_IA64_TPREL64MSB:
3060 case R_IA64_DTPMOD64MSB:
3061 case R_IA64_DTPREL64MSB:
3062 size = 8; bigendian = 1;
3065 case R_IA64_DIR64LSB:
3066 case R_IA64_GPREL64LSB:
3067 case R_IA64_PLTOFF64LSB:
3068 case R_IA64_FPTR64LSB:
3069 case R_IA64_PCREL64LSB:
3070 case R_IA64_LTOFF_FPTR64LSB:
3071 case R_IA64_SEGREL64LSB:
3072 case R_IA64_SECREL64LSB:
3073 case R_IA64_LTV64LSB:
3074 case R_IA64_TPREL64LSB:
3075 case R_IA64_DTPMOD64LSB:
3076 case R_IA64_DTPREL64LSB:
3077 size = 8; bigendian = 0;
3080 /* Unsupported / Dynamic relocations. */
3082 return bfd_reloc_notsupported;
3087 case IA64_OPND_IMMU64:
3088 hit_addr -= (long) hit_addr & 0x3;
3089 t0 = bfd_get_64 (abfd, hit_addr);
3090 t1 = bfd_get_64 (abfd, hit_addr + 8);
3092 /* tmpl/s: bits 0.. 5 in t0
3093 slot 0: bits 5..45 in t0
3094 slot 1: bits 46..63 in t0, bits 0..22 in t1
3095 slot 2: bits 23..63 in t1 */
3097 /* First, clear the bits that form the 64 bit constant. */
3098 t0 &= ~(0x3ffffLL << 46);
3100 | (( (0x07fLL << 13) | (0x1ffLL << 27)
3101 | (0x01fLL << 22) | (0x001LL << 21)
3102 | (0x001LL << 36)) << 23));
3104 t0 |= ((val >> 22) & 0x03ffffLL) << 46; /* 18 lsbs of imm41 */
3105 t1 |= ((val >> 40) & 0x7fffffLL) << 0; /* 23 msbs of imm41 */
3106 t1 |= ( (((val >> 0) & 0x07f) << 13) /* imm7b */
3107 | (((val >> 7) & 0x1ff) << 27) /* imm9d */
3108 | (((val >> 16) & 0x01f) << 22) /* imm5c */
3109 | (((val >> 21) & 0x001) << 21) /* ic */
3110 | (((val >> 63) & 0x001) << 36)) << 23; /* i */
3112 bfd_put_64 (abfd, t0, hit_addr);
3113 bfd_put_64 (abfd, t1, hit_addr + 8);
3116 case IA64_OPND_TGT64:
3117 hit_addr -= (long) hit_addr & 0x3;
3118 t0 = bfd_get_64 (abfd, hit_addr);
3119 t1 = bfd_get_64 (abfd, hit_addr + 8);
3121 /* tmpl/s: bits 0.. 5 in t0
3122 slot 0: bits 5..45 in t0
3123 slot 1: bits 46..63 in t0, bits 0..22 in t1
3124 slot 2: bits 23..63 in t1 */
3126 /* First, clear the bits that form the 64 bit constant. */
3127 t0 &= ~(0x3ffffLL << 46);
3129 | ((1LL << 36 | 0xfffffLL << 13) << 23));
3132 t0 |= ((val >> 20) & 0xffffLL) << 2 << 46; /* 16 lsbs of imm39 */
3133 t1 |= ((val >> 36) & 0x7fffffLL) << 0; /* 23 msbs of imm39 */
3134 t1 |= ((((val >> 0) & 0xfffffLL) << 13) /* imm20b */
3135 | (((val >> 59) & 0x1LL) << 36)) << 23; /* i */
3137 bfd_put_64 (abfd, t0, hit_addr);
3138 bfd_put_64 (abfd, t1, hit_addr + 8);
3142 switch ((long) hit_addr & 0x3)
3144 case 0: shift = 5; break;
3145 case 1: shift = 14; hit_addr += 3; break;
3146 case 2: shift = 23; hit_addr += 6; break;
3147 case 3: return bfd_reloc_notsupported; /* shouldn't happen... */
3149 dword = bfd_get_64 (abfd, hit_addr);
3150 insn = (dword >> shift) & 0x1ffffffffffLL;
3152 op = elf64_ia64_operands + opnd;
3153 err = (*op->insert) (op, val, (ia64_insn *)& insn);
3155 return bfd_reloc_overflow;
3157 dword &= ~(0x1ffffffffffLL << shift);
3158 dword |= (insn << shift);
3159 bfd_put_64 (abfd, dword, hit_addr);
3163 /* A data relocation. */
3166 bfd_putb32 (val, hit_addr);
3168 bfd_putb64 (val, hit_addr);
3171 bfd_putl32 (val, hit_addr);
3173 bfd_putl64 (val, hit_addr);
3177 return bfd_reloc_ok;
3181 elfNN_ia64_install_dyn_reloc (abfd, info, sec, srel, offset, type,
3184 struct bfd_link_info *info;
3192 Elf_Internal_Rela outrel;
3194 offset += sec->output_section->vma + sec->output_offset;
3196 BFD_ASSERT (dynindx != -1);
3197 outrel.r_info = ELFNN_R_INFO (dynindx, type);
3198 outrel.r_addend = addend;
3199 outrel.r_offset = _bfd_elf_section_offset (abfd, info, sec, offset);
3200 if ((outrel.r_offset | 1) == (bfd_vma) -1)
3202 /* Run for the hills. We shouldn't be outputting a relocation
3203 for this. So do what everyone else does and output a no-op. */
3204 outrel.r_info = ELFNN_R_INFO (0, R_IA64_NONE);
3205 outrel.r_addend = 0;
3206 outrel.r_offset = 0;
3209 bfd_elfNN_swap_reloca_out (abfd, &outrel,
3210 ((ElfNN_External_Rela *) srel->contents
3211 + srel->reloc_count++));
3212 BFD_ASSERT (sizeof (ElfNN_External_Rela) * srel->reloc_count
3213 <= srel->_cooked_size);
3216 /* Store an entry for target address TARGET_ADDR in the linkage table
3217 and return the gp-relative address of the linkage table entry. */
3220 set_got_entry (abfd, info, dyn_i, dynindx, addend, value, dyn_r_type)
3222 struct bfd_link_info *info;
3223 struct elfNN_ia64_dyn_sym_info *dyn_i;
3227 unsigned int dyn_r_type;
3229 struct elfNN_ia64_link_hash_table *ia64_info;
3234 ia64_info = elfNN_ia64_hash_table (info);
3235 got_sec = ia64_info->got_sec;
3239 case R_IA64_TPREL64LSB:
3240 done = dyn_i->tprel_done;
3241 dyn_i->tprel_done = true;
3242 got_offset = dyn_i->tprel_offset;
3244 case R_IA64_DTPMOD64LSB:
3245 done = dyn_i->dtpmod_done;
3246 dyn_i->dtpmod_done = true;
3247 got_offset = dyn_i->dtpmod_offset;
3249 case R_IA64_DTPREL64LSB:
3250 done = dyn_i->dtprel_done;
3251 dyn_i->dtprel_done = true;
3252 got_offset = dyn_i->dtprel_offset;
3255 done = dyn_i->got_done;
3256 dyn_i->got_done = true;
3257 got_offset = dyn_i->got_offset;
3261 BFD_ASSERT ((got_offset & 7) == 0);
3265 /* Store the target address in the linkage table entry. */
3266 bfd_put_64 (abfd, value, got_sec->contents + got_offset);
3268 /* Install a dynamic relocation if needed. */
3269 if ((info->shared && dyn_r_type != R_IA64_DTPREL64LSB)
3270 || elfNN_ia64_dynamic_symbol_p (dyn_i->h, info)
3271 || elfNN_ia64_aix_vec (abfd->xvec)
3272 || (dynindx != -1 && dyn_r_type == R_IA64_FPTR64LSB))
3275 && dyn_r_type != R_IA64_TPREL64LSB
3276 && dyn_r_type != R_IA64_DTPMOD64LSB
3277 && dyn_r_type != R_IA64_DTPREL64LSB)
3279 dyn_r_type = R_IA64_REL64LSB;
3284 if (bfd_big_endian (abfd))
3288 case R_IA64_REL64LSB:
3289 dyn_r_type = R_IA64_REL64MSB;
3291 case R_IA64_DIR64LSB:
3292 dyn_r_type = R_IA64_DIR64MSB;
3294 case R_IA64_FPTR64LSB:
3295 dyn_r_type = R_IA64_FPTR64MSB;
3297 case R_IA64_TPREL64LSB:
3298 dyn_r_type = R_IA64_TPREL64MSB;
3300 case R_IA64_DTPMOD64LSB:
3301 dyn_r_type = R_IA64_DTPMOD64MSB;
3303 case R_IA64_DTPREL64LSB:
3304 dyn_r_type = R_IA64_DTPREL64MSB;
3312 elfNN_ia64_install_dyn_reloc (abfd, NULL, got_sec,
3313 ia64_info->rel_got_sec,
3314 got_offset, dyn_r_type,
3319 /* Return the address of the linkage table entry. */
3320 value = (got_sec->output_section->vma
3321 + got_sec->output_offset
3327 /* Fill in a function descriptor consisting of the function's code
3328 address and its global pointer. Return the descriptor's address. */
3331 set_fptr_entry (abfd, info, dyn_i, value)
3333 struct bfd_link_info *info;
3334 struct elfNN_ia64_dyn_sym_info *dyn_i;
3337 struct elfNN_ia64_link_hash_table *ia64_info;
3340 ia64_info = elfNN_ia64_hash_table (info);
3341 fptr_sec = ia64_info->fptr_sec;
3343 if (!dyn_i->fptr_done)
3345 dyn_i->fptr_done = 1;
3347 /* Fill in the function descriptor. */
3348 bfd_put_64 (abfd, value, fptr_sec->contents + dyn_i->fptr_offset);
3349 bfd_put_64 (abfd, _bfd_get_gp_value (abfd),
3350 fptr_sec->contents + dyn_i->fptr_offset + 8);
3353 /* Return the descriptor's address. */
3354 value = (fptr_sec->output_section->vma
3355 + fptr_sec->output_offset
3356 + dyn_i->fptr_offset);
3361 /* Fill in a PLTOFF entry consisting of the function's code address
3362 and its global pointer. Return the descriptor's address. */
3365 set_pltoff_entry (abfd, info, dyn_i, value, is_plt)
3367 struct bfd_link_info *info;
3368 struct elfNN_ia64_dyn_sym_info *dyn_i;
3372 struct elfNN_ia64_link_hash_table *ia64_info;
3373 asection *pltoff_sec;
3375 ia64_info = elfNN_ia64_hash_table (info);
3376 pltoff_sec = ia64_info->pltoff_sec;
3378 /* Don't do anything if this symbol uses a real PLT entry. In
3379 that case, we'll fill this in during finish_dynamic_symbol. */
3380 if ((! dyn_i->want_plt || is_plt)
3381 && !dyn_i->pltoff_done)
3383 bfd_vma gp = _bfd_get_gp_value (abfd);
3385 /* Fill in the function descriptor. */
3386 bfd_put_64 (abfd, value, pltoff_sec->contents + dyn_i->pltoff_offset);
3387 bfd_put_64 (abfd, gp, pltoff_sec->contents + dyn_i->pltoff_offset + 8);
3389 /* Install dynamic relocations if needed. */
3390 if (!is_plt && info->shared)
3392 unsigned int dyn_r_type;
3394 if (bfd_big_endian (abfd))
3395 dyn_r_type = R_IA64_REL64MSB;
3397 dyn_r_type = R_IA64_REL64LSB;
3399 elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
3400 ia64_info->rel_pltoff_sec,
3401 dyn_i->pltoff_offset,
3402 dyn_r_type, 0, value);
3403 elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
3404 ia64_info->rel_pltoff_sec,
3405 dyn_i->pltoff_offset + 8,
3409 dyn_i->pltoff_done = 1;
3412 /* Return the descriptor's address. */
3413 value = (pltoff_sec->output_section->vma
3414 + pltoff_sec->output_offset
3415 + dyn_i->pltoff_offset);
3420 /* Return the base VMA address which should be subtracted from real addresses
3421 when resolving @tprel() relocation.
3422 Main program TLS (whose template starts at PT_TLS p_vaddr)
3423 is assigned offset round(16, PT_TLS p_align). */
3426 elfNN_ia64_tprel_base (info)
3427 struct bfd_link_info *info;
3429 struct elf_link_tls_segment *tls_segment
3430 = elf_hash_table (info)->tls_segment;
3432 BFD_ASSERT (tls_segment != NULL);
3433 return (tls_segment->start
3434 - align_power ((bfd_vma) 16, tls_segment->align));
3437 /* Return the base VMA address which should be subtracted from real addresses
3438 when resolving @dtprel() relocation.
3439 This is PT_TLS segment p_vaddr. */
3442 elfNN_ia64_dtprel_base (info)
3443 struct bfd_link_info *info;
3445 BFD_ASSERT (elf_hash_table (info)->tls_segment != NULL);
3446 return elf_hash_table (info)->tls_segment->start;
3449 /* Called through qsort to sort the .IA_64.unwind section during a
3450 non-relocatable link. Set elfNN_ia64_unwind_entry_compare_bfd
3451 to the output bfd so we can do proper endianness frobbing. */
3453 static bfd *elfNN_ia64_unwind_entry_compare_bfd;
3456 elfNN_ia64_unwind_entry_compare (a, b)
3462 av = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, a);
3463 bv = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, b);
3465 return (av < bv ? -1 : av > bv ? 1 : 0);
3469 elfNN_ia64_final_link (abfd, info)
3471 struct bfd_link_info *info;
3473 struct elfNN_ia64_link_hash_table *ia64_info;
3474 asection *unwind_output_sec;
3476 ia64_info = elfNN_ia64_hash_table (info);
3478 /* Make sure we've got ourselves a nice fat __gp value. */
3479 if (!info->relocateable)
3481 bfd_vma min_vma = (bfd_vma) -1, max_vma = 0;
3482 bfd_vma min_short_vma = min_vma, max_short_vma = 0;
3483 struct elf_link_hash_entry *gp;
3487 /* Find the min and max vma of all sections marked short. Also
3488 collect min and max vma of any type, for use in selecting a
3490 for (os = abfd->sections; os ; os = os->next)
3494 if ((os->flags & SEC_ALLOC) == 0)
3498 hi = os->vma + os->_raw_size;
3506 if (os->flags & SEC_SMALL_DATA)
3508 if (min_short_vma > lo)
3510 if (max_short_vma < hi)
3515 /* See if the user wants to force a value. */
3516 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", false,
3520 && (gp->root.type == bfd_link_hash_defined
3521 || gp->root.type == bfd_link_hash_defweak))
3523 asection *gp_sec = gp->root.u.def.section;
3524 gp_val = (gp->root.u.def.value
3525 + gp_sec->output_section->vma
3526 + gp_sec->output_offset);
3530 /* Pick a sensible value. */
3532 asection *got_sec = ia64_info->got_sec;
3534 /* Start with just the address of the .got. */
3536 gp_val = got_sec->output_section->vma;
3537 else if (max_short_vma != 0)
3538 gp_val = min_short_vma;
3542 /* If it is possible to address the entire image, but we
3543 don't with the choice above, adjust. */
3544 if (max_vma - min_vma < 0x400000
3545 && max_vma - gp_val <= 0x200000
3546 && gp_val - min_vma > 0x200000)
3547 gp_val = min_vma + 0x200000;
3548 else if (max_short_vma != 0)
3550 /* If we don't cover all the short data, adjust. */
3551 if (max_short_vma - gp_val >= 0x200000)
3552 gp_val = min_short_vma + 0x200000;
3554 /* If we're addressing stuff past the end, adjust back. */
3555 if (gp_val > max_vma)
3556 gp_val = max_vma - 0x200000 + 8;
3560 /* Validate whether all SHF_IA_64_SHORT sections are within
3561 range of the chosen GP. */
3563 if (max_short_vma != 0)
3565 if (max_short_vma - min_short_vma >= 0x400000)
3567 (*_bfd_error_handler)
3568 (_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
3569 bfd_get_filename (abfd),
3570 (unsigned long) (max_short_vma - min_short_vma));
3573 else if ((gp_val > min_short_vma
3574 && gp_val - min_short_vma > 0x200000)
3575 || (gp_val < max_short_vma
3576 && max_short_vma - gp_val >= 0x200000))
3578 (*_bfd_error_handler)
3579 (_("%s: __gp does not cover short data segment"),
3580 bfd_get_filename (abfd));
3585 _bfd_set_gp_value (abfd, gp_val);
3589 gp->root.type = bfd_link_hash_defined;
3590 gp->root.u.def.value = gp_val;
3591 gp->root.u.def.section = bfd_abs_section_ptr;
3595 /* If we're producing a final executable, we need to sort the contents
3596 of the .IA_64.unwind section. Force this section to be relocated
3597 into memory rather than written immediately to the output file. */
3598 unwind_output_sec = NULL;
3599 if (!info->relocateable)
3601 asection *s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind);
3604 unwind_output_sec = s->output_section;
3605 unwind_output_sec->contents
3606 = bfd_malloc (unwind_output_sec->_raw_size);
3607 if (unwind_output_sec->contents == NULL)
3612 /* Invoke the regular ELF backend linker to do all the work. */
3613 if (!bfd_elfNN_bfd_final_link (abfd, info))
3616 if (unwind_output_sec)
3618 elfNN_ia64_unwind_entry_compare_bfd = abfd;
3619 qsort (unwind_output_sec->contents,
3620 (size_t) (unwind_output_sec->_raw_size / 24),
3622 elfNN_ia64_unwind_entry_compare);
3624 if (! bfd_set_section_contents (abfd, unwind_output_sec,
3625 unwind_output_sec->contents, (bfd_vma) 0,
3626 unwind_output_sec->_raw_size))
3634 elfNN_ia64_relocate_section (output_bfd, info, input_bfd, input_section,
3635 contents, relocs, local_syms, local_sections)
3637 struct bfd_link_info *info;
3639 asection *input_section;
3641 Elf_Internal_Rela *relocs;
3642 Elf_Internal_Sym *local_syms;
3643 asection **local_sections;
3645 struct elfNN_ia64_link_hash_table *ia64_info;
3646 Elf_Internal_Shdr *symtab_hdr;
3647 Elf_Internal_Rela *rel;
3648 Elf_Internal_Rela *relend;
3650 boolean ret_val = true; /* for non-fatal errors */
3653 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3654 ia64_info = elfNN_ia64_hash_table (info);
3656 /* Infect various flags from the input section to the output section. */
3657 if (info->relocateable)
3661 flags = elf_section_data(input_section)->this_hdr.sh_flags;
3662 flags &= SHF_IA_64_NORECOV;
3664 elf_section_data(input_section->output_section)
3665 ->this_hdr.sh_flags |= flags;
3669 gp_val = _bfd_get_gp_value (output_bfd);
3670 srel = get_reloc_section (input_bfd, ia64_info, input_section, false);
3673 relend = relocs + input_section->reloc_count;
3674 for (; rel < relend; ++rel)
3676 struct elf_link_hash_entry *h;
3677 struct elfNN_ia64_dyn_sym_info *dyn_i;
3678 bfd_reloc_status_type r;
3679 reloc_howto_type *howto;
3680 unsigned long r_symndx;
3681 Elf_Internal_Sym *sym;
3682 unsigned int r_type;
3686 boolean dynamic_symbol_p;
3687 boolean undef_weak_ref;
3689 r_type = ELFNN_R_TYPE (rel->r_info);
3690 if (r_type > R_IA64_MAX_RELOC_CODE)
3692 (*_bfd_error_handler)
3693 (_("%s: unknown relocation type %d"),
3694 bfd_archive_filename (input_bfd), (int)r_type);
3695 bfd_set_error (bfd_error_bad_value);
3700 howto = lookup_howto (r_type);
3701 r_symndx = ELFNN_R_SYM (rel->r_info);
3705 undef_weak_ref = false;
3707 if (r_symndx < symtab_hdr->sh_info)
3709 /* Reloc against local symbol. */
3710 sym = local_syms + r_symndx;
3711 sym_sec = local_sections[r_symndx];
3712 value = _bfd_elf_rela_local_sym (output_bfd, sym, sym_sec, rel);
3713 if ((sym_sec->flags & SEC_MERGE)
3714 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
3715 && (elf_section_data (sym_sec)->sec_info_type
3716 == ELF_INFO_TYPE_MERGE))
3718 struct elfNN_ia64_local_hash_entry *loc_h;
3720 loc_h = get_local_sym_hash (ia64_info, input_bfd, rel, false);
3721 if (loc_h && ! loc_h->sec_merge_done)
3723 struct elfNN_ia64_dyn_sym_info *dynent;
3726 for (dynent = loc_h->info; dynent; dynent = dynent->next)
3730 _bfd_merged_section_offset (output_bfd, &msec,
3731 elf_section_data (msec)->
3736 dynent->addend -= sym->st_value;
3737 dynent->addend += msec->output_section->vma
3738 + msec->output_offset
3739 - sym_sec->output_section->vma
3740 - sym_sec->output_offset;
3742 loc_h->sec_merge_done = 1;
3750 /* Reloc against global symbol. */
3751 indx = r_symndx - symtab_hdr->sh_info;
3752 h = elf_sym_hashes (input_bfd)[indx];
3753 while (h->root.type == bfd_link_hash_indirect
3754 || h->root.type == bfd_link_hash_warning)
3755 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3758 if (h->root.type == bfd_link_hash_defined
3759 || h->root.type == bfd_link_hash_defweak)
3761 sym_sec = h->root.u.def.section;
3763 /* Detect the cases that sym_sec->output_section is
3764 expected to be NULL -- all cases in which the symbol
3765 is defined in another shared module. This includes
3766 PLT relocs for which we've created a PLT entry and
3767 other relocs for which we're prepared to create
3768 dynamic relocations. */
3769 /* ??? Just accept it NULL and continue. */
3771 if (sym_sec->output_section != NULL)
3773 value = (h->root.u.def.value
3774 + sym_sec->output_section->vma
3775 + sym_sec->output_offset);
3778 else if (h->root.type == bfd_link_hash_undefweak)
3779 undef_weak_ref = true;
3780 else if (info->shared
3781 && (!info->symbolic || info->allow_shlib_undefined)
3782 && !info->no_undefined
3783 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
3787 if (! ((*info->callbacks->undefined_symbol)
3788 (info, h->root.root.string, input_bfd,
3789 input_section, rel->r_offset,
3790 (!info->shared || info->no_undefined
3791 || ELF_ST_VISIBILITY (h->other)))))
3798 hit_addr = contents + rel->r_offset;
3799 value += rel->r_addend;
3800 dynamic_symbol_p = elfNN_ia64_dynamic_symbol_p (h, info);
3811 case R_IA64_DIR32MSB:
3812 case R_IA64_DIR32LSB:
3813 case R_IA64_DIR64MSB:
3814 case R_IA64_DIR64LSB:
3815 /* Install a dynamic relocation for this reloc. */
3816 if ((dynamic_symbol_p || info->shared
3817 || (elfNN_ia64_aix_vec (info->hash->creator)
3818 /* Don't emit relocs for __GLOB_DATA_PTR on AIX. */
3819 && (!h || strcmp (h->root.root.string,
3820 "__GLOB_DATA_PTR") != 0)))
3822 && (input_section->flags & SEC_ALLOC) != 0)
3824 unsigned int dyn_r_type;
3828 BFD_ASSERT (srel != NULL);
3830 /* If we don't need dynamic symbol lookup, find a
3831 matching RELATIVE relocation. */
3832 dyn_r_type = r_type;
3833 if (dynamic_symbol_p)
3835 dynindx = h->dynindx;
3836 addend = rel->r_addend;
3843 case R_IA64_DIR32MSB:
3844 dyn_r_type = R_IA64_REL32MSB;
3846 case R_IA64_DIR32LSB:
3847 dyn_r_type = R_IA64_REL32LSB;
3849 case R_IA64_DIR64MSB:
3850 dyn_r_type = R_IA64_REL64MSB;
3852 case R_IA64_DIR64LSB:
3853 dyn_r_type = R_IA64_REL64LSB;
3857 /* We can't represent this without a dynamic symbol.
3858 Adjust the relocation to be against an output
3859 section symbol, which are always present in the
3860 dynamic symbol table. */
3861 /* ??? People shouldn't be doing non-pic code in
3862 shared libraries. Hork. */
3863 (*_bfd_error_handler)
3864 (_("%s: linking non-pic code in a shared library"),
3865 bfd_archive_filename (input_bfd));
3873 if (elfNN_ia64_aix_vec (info->hash->creator))
3874 rel->r_addend = value;
3875 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
3876 srel, rel->r_offset, dyn_r_type,
3881 case R_IA64_LTV32MSB:
3882 case R_IA64_LTV32LSB:
3883 case R_IA64_LTV64MSB:
3884 case R_IA64_LTV64LSB:
3885 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
3888 case R_IA64_GPREL22:
3889 case R_IA64_GPREL64I:
3890 case R_IA64_GPREL32MSB:
3891 case R_IA64_GPREL32LSB:
3892 case R_IA64_GPREL64MSB:
3893 case R_IA64_GPREL64LSB:
3894 if (dynamic_symbol_p)
3896 (*_bfd_error_handler)
3897 (_("%s: @gprel relocation against dynamic symbol %s"),
3898 bfd_archive_filename (input_bfd), h->root.root.string);
3903 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
3906 case R_IA64_LTOFF22:
3907 case R_IA64_LTOFF22X:
3908 case R_IA64_LTOFF64I:
3909 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
3910 value = set_got_entry (input_bfd, info, dyn_i, (h ? h->dynindx : -1),
3911 rel->r_addend, value, R_IA64_DIR64LSB);
3913 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
3916 case R_IA64_PLTOFF22:
3917 case R_IA64_PLTOFF64I:
3918 case R_IA64_PLTOFF64MSB:
3919 case R_IA64_PLTOFF64LSB:
3920 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
3921 value = set_pltoff_entry (output_bfd, info, dyn_i, value, false);
3923 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
3926 case R_IA64_FPTR64I:
3927 case R_IA64_FPTR32MSB:
3928 case R_IA64_FPTR32LSB:
3929 case R_IA64_FPTR64MSB:
3930 case R_IA64_FPTR64LSB:
3931 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
3932 if (dyn_i->want_fptr)
3934 if (!undef_weak_ref)
3935 value = set_fptr_entry (output_bfd, info, dyn_i, value);
3941 /* Otherwise, we expect the dynamic linker to create
3946 if (h->dynindx != -1)
3947 dynindx = h->dynindx;
3949 dynindx = (_bfd_elf_link_lookup_local_dynindx
3950 (info, h->root.u.def.section->owner,
3951 global_sym_index (h)));
3955 dynindx = (_bfd_elf_link_lookup_local_dynindx
3956 (info, input_bfd, (long) r_symndx));
3959 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
3960 srel, rel->r_offset, r_type,
3961 dynindx, rel->r_addend);
3965 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
3968 case R_IA64_LTOFF_FPTR22:
3969 case R_IA64_LTOFF_FPTR64I:
3970 case R_IA64_LTOFF_FPTR32MSB:
3971 case R_IA64_LTOFF_FPTR32LSB:
3972 case R_IA64_LTOFF_FPTR64MSB:
3973 case R_IA64_LTOFF_FPTR64LSB:
3977 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
3978 if (dyn_i->want_fptr)
3980 BFD_ASSERT (h == NULL || h->dynindx == -1)
3981 if (!undef_weak_ref)
3982 value = set_fptr_entry (output_bfd, info, dyn_i, value);
3987 /* Otherwise, we expect the dynamic linker to create
3991 if (h->dynindx != -1)
3992 dynindx = h->dynindx;
3994 dynindx = (_bfd_elf_link_lookup_local_dynindx
3995 (info, h->root.u.def.section->owner,
3996 global_sym_index (h)));
3999 dynindx = (_bfd_elf_link_lookup_local_dynindx
4000 (info, input_bfd, (long) r_symndx));
4004 value = set_got_entry (output_bfd, info, dyn_i, dynindx,
4005 rel->r_addend, value, R_IA64_FPTR64LSB);
4007 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4011 case R_IA64_PCREL32MSB:
4012 case R_IA64_PCREL32LSB:
4013 case R_IA64_PCREL64MSB:
4014 case R_IA64_PCREL64LSB:
4015 /* Install a dynamic relocation for this reloc. */
4016 if ((dynamic_symbol_p
4017 || elfNN_ia64_aix_vec (info->hash->creator))
4020 BFD_ASSERT (srel != NULL);
4022 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4023 srel, rel->r_offset, r_type,
4024 h->dynindx, rel->r_addend);
4028 case R_IA64_PCREL21BI:
4029 case R_IA64_PCREL21F:
4030 case R_IA64_PCREL21M:
4031 /* ??? These two are only used for speculation fixup code.
4032 They should never be dynamic. */
4033 if (dynamic_symbol_p)
4035 (*_bfd_error_handler)
4036 (_("%s: dynamic relocation against speculation fixup"),
4037 bfd_archive_filename (input_bfd));
4043 (*_bfd_error_handler)
4044 (_("%s: speculation fixup against undefined weak symbol"),
4045 bfd_archive_filename (input_bfd));
4051 case R_IA64_PCREL21B:
4052 case R_IA64_PCREL60B:
4053 /* We should have created a PLT entry for any dynamic symbol. */
4056 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, false);
4058 if (dyn_i && dyn_i->want_plt2)
4060 /* Should have caught this earlier. */
4061 BFD_ASSERT (rel->r_addend == 0);
4063 value = (ia64_info->plt_sec->output_section->vma
4064 + ia64_info->plt_sec->output_offset
4065 + dyn_i->plt2_offset);
4069 /* Since there's no PLT entry, Validate that this is
4071 BFD_ASSERT (undef_weak_ref || sym_sec->output_section != NULL);
4073 /* If the symbol is undef_weak, we shouldn't be trying
4074 to call it. There's every chance that we'd wind up
4075 with an out-of-range fixup here. Don't bother setting
4076 any value at all. */
4082 case R_IA64_PCREL22:
4083 case R_IA64_PCREL64I:
4085 /* Make pc-relative. */
4086 value -= (input_section->output_section->vma
4087 + input_section->output_offset
4088 + rel->r_offset) & ~ (bfd_vma) 0x3;
4089 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4092 case R_IA64_SEGREL32MSB:
4093 case R_IA64_SEGREL32LSB:
4094 case R_IA64_SEGREL64MSB:
4095 case R_IA64_SEGREL64LSB:
4098 /* If the input section was discarded from the output, then
4104 struct elf_segment_map *m;
4105 Elf_Internal_Phdr *p;
4107 /* Find the segment that contains the output_section. */
4108 for (m = elf_tdata (output_bfd)->segment_map,
4109 p = elf_tdata (output_bfd)->phdr;
4114 for (i = m->count - 1; i >= 0; i--)
4115 if (m->sections[i] == sym_sec->output_section)
4123 r = bfd_reloc_notsupported;
4127 /* The VMA of the segment is the vaddr of the associated
4129 if (value > p->p_vaddr)
4130 value -= p->p_vaddr;
4133 r = elfNN_ia64_install_value (output_bfd, hit_addr, value,
4139 case R_IA64_SECREL32MSB:
4140 case R_IA64_SECREL32LSB:
4141 case R_IA64_SECREL64MSB:
4142 case R_IA64_SECREL64LSB:
4143 /* Make output-section relative. */
4144 if (value > input_section->output_section->vma)
4145 value -= input_section->output_section->vma;
4148 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4151 case R_IA64_IPLTMSB:
4152 case R_IA64_IPLTLSB:
4153 /* Install a dynamic relocation for this reloc. */
4154 if ((dynamic_symbol_p || info->shared)
4155 && (input_section->flags & SEC_ALLOC) != 0)
4157 BFD_ASSERT (srel != NULL);
4159 /* If we don't need dynamic symbol lookup, install two
4160 RELATIVE relocations. */
4161 if (! dynamic_symbol_p)
4163 unsigned int dyn_r_type;
4165 if (r_type == R_IA64_IPLTMSB)
4166 dyn_r_type = R_IA64_REL64MSB;
4168 dyn_r_type = R_IA64_REL64LSB;
4170 elfNN_ia64_install_dyn_reloc (output_bfd, info,
4172 srel, rel->r_offset,
4173 dyn_r_type, 0, value);
4174 elfNN_ia64_install_dyn_reloc (output_bfd, info,
4176 srel, rel->r_offset + 8,
4177 dyn_r_type, 0, gp_val);
4180 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4181 srel, rel->r_offset, r_type,
4182 h->dynindx, rel->r_addend);
4185 if (r_type == R_IA64_IPLTMSB)
4186 r_type = R_IA64_DIR64MSB;
4188 r_type = R_IA64_DIR64LSB;
4189 elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4190 r = elfNN_ia64_install_value (output_bfd, hit_addr + 8, gp_val,
4194 case R_IA64_TPREL14:
4195 case R_IA64_TPREL22:
4196 case R_IA64_TPREL64I:
4197 value -= elfNN_ia64_tprel_base (info);
4198 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4201 case R_IA64_DTPREL14:
4202 case R_IA64_DTPREL22:
4203 case R_IA64_DTPREL64I:
4204 value -= elfNN_ia64_dtprel_base (info);
4205 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4208 case R_IA64_LTOFF_TPREL22:
4209 case R_IA64_LTOFF_DTPMOD22:
4210 case R_IA64_LTOFF_DTPREL22:
4217 case R_IA64_LTOFF_TPREL22:
4218 if (!dynamic_symbol_p && !info->shared)
4219 value -= elfNN_ia64_tprel_base (info);
4220 got_r_type = R_IA64_TPREL64LSB;
4222 case R_IA64_LTOFF_DTPMOD22:
4223 if (!dynamic_symbol_p && !info->shared)
4225 got_r_type = R_IA64_DTPMOD64LSB;
4227 case R_IA64_LTOFF_DTPREL22:
4228 if (!dynamic_symbol_p)
4229 value -= elfNN_ia64_dtprel_base (info);
4230 got_r_type = R_IA64_DTPREL64LSB;
4233 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, false);
4234 value = set_got_entry (input_bfd, info, dyn_i,
4235 (h ? h->dynindx : -1), rel->r_addend,
4238 r = elfNN_ia64_install_value (output_bfd, hit_addr, value,
4244 r = bfd_reloc_notsupported;
4253 case bfd_reloc_undefined:
4254 /* This can happen for global table relative relocs if
4255 __gp is undefined. This is a panic situation so we
4256 don't try to continue. */
4257 (*info->callbacks->undefined_symbol)
4258 (info, "__gp", input_bfd, input_section, rel->r_offset, 1);
4261 case bfd_reloc_notsupported:
4266 name = h->root.root.string;
4269 name = bfd_elf_string_from_elf_section (input_bfd,
4270 symtab_hdr->sh_link,
4275 name = bfd_section_name (input_bfd, input_section);
4277 if (!(*info->callbacks->warning) (info, _("unsupported reloc"),
4279 input_section, rel->r_offset))
4285 case bfd_reloc_dangerous:
4286 case bfd_reloc_outofrange:
4287 case bfd_reloc_overflow:
4293 name = h->root.root.string;
4296 name = bfd_elf_string_from_elf_section (input_bfd,
4297 symtab_hdr->sh_link,
4302 name = bfd_section_name (input_bfd, input_section);
4304 if (!(*info->callbacks->reloc_overflow) (info, name,
4321 elfNN_ia64_finish_dynamic_symbol (output_bfd, info, h, sym)
4323 struct bfd_link_info *info;
4324 struct elf_link_hash_entry *h;
4325 Elf_Internal_Sym *sym;
4327 struct elfNN_ia64_link_hash_table *ia64_info;
4328 struct elfNN_ia64_dyn_sym_info *dyn_i;
4330 ia64_info = elfNN_ia64_hash_table (info);
4331 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, false);
4333 /* Fill in the PLT data, if required. */
4334 if (dyn_i && dyn_i->want_plt)
4336 Elf_Internal_Rela outrel;
4339 bfd_vma plt_addr, pltoff_addr, gp_val, index;
4340 ElfNN_External_Rela *rel;
4342 gp_val = _bfd_get_gp_value (output_bfd);
4344 /* Initialize the minimal PLT entry. */
4346 index = (dyn_i->plt_offset - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
4347 plt_sec = ia64_info->plt_sec;
4348 loc = plt_sec->contents + dyn_i->plt_offset;
4350 memcpy (loc, plt_min_entry, PLT_MIN_ENTRY_SIZE);
4351 elfNN_ia64_install_value (output_bfd, loc, index, R_IA64_IMM22);
4352 elfNN_ia64_install_value (output_bfd, loc+2, -dyn_i->plt_offset,
4355 plt_addr = (plt_sec->output_section->vma
4356 + plt_sec->output_offset
4357 + dyn_i->plt_offset);
4358 pltoff_addr = set_pltoff_entry (output_bfd, info, dyn_i, plt_addr, true);
4360 /* Initialize the FULL PLT entry, if needed. */
4361 if (dyn_i->want_plt2)
4363 loc = plt_sec->contents + dyn_i->plt2_offset;
4365 memcpy (loc, plt_full_entry, PLT_FULL_ENTRY_SIZE);
4366 elfNN_ia64_install_value (output_bfd, loc, pltoff_addr - gp_val,
4369 /* Mark the symbol as undefined, rather than as defined in the
4370 plt section. Leave the value alone. */
4371 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
4372 first place. But perhaps elflink.h did some for us. */
4373 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4374 sym->st_shndx = SHN_UNDEF;
4377 /* Create the dynamic relocation. */
4378 outrel.r_offset = pltoff_addr;
4379 if (bfd_little_endian (output_bfd))
4380 outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTLSB);
4382 outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTMSB);
4383 outrel.r_addend = 0;
4385 /* This is fun. In the .IA_64.pltoff section, we've got entries
4386 that correspond both to real PLT entries, and those that
4387 happened to resolve to local symbols but need to be created
4388 to satisfy @pltoff relocations. The .rela.IA_64.pltoff
4389 relocations for the real PLT should come at the end of the
4390 section, so that they can be indexed by plt entry at runtime.
4392 We emitted all of the relocations for the non-PLT @pltoff
4393 entries during relocate_section. So we can consider the
4394 existing sec->reloc_count to be the base of the array of
4397 rel = (ElfNN_External_Rela *)ia64_info->rel_pltoff_sec->contents;
4398 rel += ia64_info->rel_pltoff_sec->reloc_count;
4400 bfd_elfNN_swap_reloca_out (output_bfd, &outrel, rel + index);
4403 /* Mark some specially defined symbols as absolute. */
4404 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
4405 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
4406 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
4407 sym->st_shndx = SHN_ABS;
4413 elfNN_ia64_finish_dynamic_sections (abfd, info)
4415 struct bfd_link_info *info;
4417 struct elfNN_ia64_link_hash_table *ia64_info;
4420 ia64_info = elfNN_ia64_hash_table (info);
4421 dynobj = ia64_info->root.dynobj;
4423 if (elf_hash_table (info)->dynamic_sections_created)
4425 ElfNN_External_Dyn *dyncon, *dynconend;
4426 asection *sdyn, *sgotplt;
4429 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4430 sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
4431 BFD_ASSERT (sdyn != NULL);
4432 dyncon = (ElfNN_External_Dyn *) sdyn->contents;
4433 dynconend = (ElfNN_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
4435 gp_val = _bfd_get_gp_value (abfd);
4437 for (; dyncon < dynconend; dyncon++)
4439 Elf_Internal_Dyn dyn;
4441 bfd_elfNN_swap_dyn_in (dynobj, dyncon, &dyn);
4446 dyn.d_un.d_ptr = gp_val;
4450 dyn.d_un.d_val = (ia64_info->minplt_entries
4451 * sizeof (ElfNN_External_Rela));
4455 /* See the comment above in finish_dynamic_symbol. */
4456 dyn.d_un.d_ptr = (ia64_info->rel_pltoff_sec->output_section->vma
4457 + ia64_info->rel_pltoff_sec->output_offset
4458 + (ia64_info->rel_pltoff_sec->reloc_count
4459 * sizeof (ElfNN_External_Rela)));
4462 case DT_IA_64_PLT_RESERVE:
4463 dyn.d_un.d_ptr = (sgotplt->output_section->vma
4464 + sgotplt->output_offset);
4468 /* Do not have RELASZ include JMPREL. This makes things
4469 easier on ld.so. This is not what the rest of BFD set up. */
4470 dyn.d_un.d_val -= (ia64_info->minplt_entries
4471 * sizeof (ElfNN_External_Rela));
4475 bfd_elfNN_swap_dyn_out (abfd, &dyn, dyncon);
4478 /* Initialize the PLT0 entry */
4479 if (ia64_info->plt_sec)
4481 bfd_byte *loc = ia64_info->plt_sec->contents;
4484 memcpy (loc, plt_header, PLT_HEADER_SIZE);
4486 pltres = (sgotplt->output_section->vma
4487 + sgotplt->output_offset
4490 elfNN_ia64_install_value (abfd, loc+1, pltres, R_IA64_GPREL22);
4497 /* ELF file flag handling: */
4499 /* Function to keep IA-64 specific file flags. */
4501 elfNN_ia64_set_private_flags (abfd, flags)
4505 BFD_ASSERT (!elf_flags_init (abfd)
4506 || elf_elfheader (abfd)->e_flags == flags);
4508 elf_elfheader (abfd)->e_flags = flags;
4509 elf_flags_init (abfd) = true;
4513 /* Merge backend specific data from an object file to the output
4514 object file when linking. */
4516 elfNN_ia64_merge_private_bfd_data (ibfd, obfd)
4523 /* Don't even pretend to support mixed-format linking. */
4524 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4525 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4528 in_flags = elf_elfheader (ibfd)->e_flags;
4529 out_flags = elf_elfheader (obfd)->e_flags;
4531 if (! elf_flags_init (obfd))
4533 elf_flags_init (obfd) = true;
4534 elf_elfheader (obfd)->e_flags = in_flags;
4536 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
4537 && bfd_get_arch_info (obfd)->the_default)
4539 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
4540 bfd_get_mach (ibfd));
4546 /* Check flag compatibility. */
4547 if (in_flags == out_flags)
4550 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
4551 if (!(in_flags & EF_IA_64_REDUCEDFP) && (out_flags & EF_IA_64_REDUCEDFP))
4552 elf_elfheader (obfd)->e_flags &= ~EF_IA_64_REDUCEDFP;
4554 if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL))
4556 (*_bfd_error_handler)
4557 (_("%s: linking trap-on-NULL-dereference with non-trapping files"),
4558 bfd_archive_filename (ibfd));
4560 bfd_set_error (bfd_error_bad_value);
4563 if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE))
4565 (*_bfd_error_handler)
4566 (_("%s: linking big-endian files with little-endian files"),
4567 bfd_archive_filename (ibfd));
4569 bfd_set_error (bfd_error_bad_value);
4572 if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64))
4574 (*_bfd_error_handler)
4575 (_("%s: linking 64-bit files with 32-bit files"),
4576 bfd_archive_filename (ibfd));
4578 bfd_set_error (bfd_error_bad_value);
4581 if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP))
4583 (*_bfd_error_handler)
4584 (_("%s: linking constant-gp files with non-constant-gp files"),
4585 bfd_archive_filename (ibfd));
4587 bfd_set_error (bfd_error_bad_value);
4590 if ((in_flags & EF_IA_64_NOFUNCDESC_CONS_GP)
4591 != (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
4593 (*_bfd_error_handler)
4594 (_("%s: linking auto-pic files with non-auto-pic files"),
4595 bfd_archive_filename (ibfd));
4597 bfd_set_error (bfd_error_bad_value);
4605 elfNN_ia64_print_private_bfd_data (abfd, ptr)
4609 FILE *file = (FILE *) ptr;
4610 flagword flags = elf_elfheader (abfd)->e_flags;
4612 BFD_ASSERT (abfd != NULL && ptr != NULL);
4614 fprintf (file, "private flags = %s%s%s%s%s%s%s%s\n",
4615 (flags & EF_IA_64_TRAPNIL) ? "TRAPNIL, " : "",
4616 (flags & EF_IA_64_EXT) ? "EXT, " : "",
4617 (flags & EF_IA_64_BE) ? "BE, " : "LE, ",
4618 (flags & EF_IA_64_REDUCEDFP) ? "REDUCEDFP, " : "",
4619 (flags & EF_IA_64_CONS_GP) ? "CONS_GP, " : "",
4620 (flags & EF_IA_64_NOFUNCDESC_CONS_GP) ? "NOFUNCDESC_CONS_GP, " : "",
4621 (flags & EF_IA_64_ABSOLUTE) ? "ABSOLUTE, " : "",
4622 (flags & EF_IA_64_ABI64) ? "ABI64" : "ABI32");
4624 _bfd_elf_print_private_bfd_data (abfd, ptr);
4628 static enum elf_reloc_type_class
4629 elfNN_ia64_reloc_type_class (rela)
4630 const Elf_Internal_Rela *rela;
4632 switch ((int) ELFNN_R_TYPE (rela->r_info))
4634 case R_IA64_REL32MSB:
4635 case R_IA64_REL32LSB:
4636 case R_IA64_REL64MSB:
4637 case R_IA64_REL64LSB:
4638 return reloc_class_relative;
4639 case R_IA64_IPLTMSB:
4640 case R_IA64_IPLTLSB:
4641 return reloc_class_plt;
4643 return reloc_class_copy;
4645 return reloc_class_normal;
4650 elfNN_ia64_hpux_vec (const bfd_target *vec)
4652 extern const bfd_target bfd_elfNN_ia64_hpux_big_vec;
4653 return (vec == & bfd_elfNN_ia64_hpux_big_vec);
4657 elfNN_hpux_post_process_headers (abfd, info)
4659 struct bfd_link_info *info ATTRIBUTE_UNUSED;
4661 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
4663 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_HPUX;
4664 i_ehdrp->e_ident[EI_ABIVERSION] = 1;
4668 elfNN_hpux_backend_section_from_bfd_section (abfd, sec, retval)
4669 bfd *abfd ATTRIBUTE_UNUSED;
4673 if (bfd_is_com_section (sec))
4675 *retval = SHN_IA_64_ANSI_COMMON;
4681 #define TARGET_LITTLE_SYM bfd_elfNN_ia64_little_vec
4682 #define TARGET_LITTLE_NAME "elfNN-ia64-little"
4683 #define TARGET_BIG_SYM bfd_elfNN_ia64_big_vec
4684 #define TARGET_BIG_NAME "elfNN-ia64-big"
4685 #define ELF_ARCH bfd_arch_ia64
4686 #define ELF_MACHINE_CODE EM_IA_64
4687 #define ELF_MACHINE_ALT1 1999 /* EAS2.3 */
4688 #define ELF_MACHINE_ALT2 1998 /* EAS2.2 */
4689 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
4691 #define elf_backend_section_from_shdr \
4692 elfNN_ia64_section_from_shdr
4693 #define elf_backend_section_flags \
4694 elfNN_ia64_section_flags
4695 #define elf_backend_fake_sections \
4696 elfNN_ia64_fake_sections
4697 #define elf_backend_final_write_processing \
4698 elfNN_ia64_final_write_processing
4699 #define elf_backend_add_symbol_hook \
4700 elfNN_ia64_add_symbol_hook
4701 #define elf_backend_additional_program_headers \
4702 elfNN_ia64_additional_program_headers
4703 #define elf_backend_modify_segment_map \
4704 elfNN_ia64_modify_segment_map
4705 #define elf_info_to_howto \
4706 elfNN_ia64_info_to_howto
4708 #define bfd_elfNN_bfd_reloc_type_lookup \
4709 elfNN_ia64_reloc_type_lookup
4710 #define bfd_elfNN_bfd_is_local_label_name \
4711 elfNN_ia64_is_local_label_name
4712 #define bfd_elfNN_bfd_relax_section \
4713 elfNN_ia64_relax_section
4715 /* Stuff for the BFD linker: */
4716 #define bfd_elfNN_bfd_link_hash_table_create \
4717 elfNN_ia64_hash_table_create
4718 #define elf_backend_create_dynamic_sections \
4719 elfNN_ia64_create_dynamic_sections
4720 #define elf_backend_check_relocs \
4721 elfNN_ia64_check_relocs
4722 #define elf_backend_adjust_dynamic_symbol \
4723 elfNN_ia64_adjust_dynamic_symbol
4724 #define elf_backend_size_dynamic_sections \
4725 elfNN_ia64_size_dynamic_sections
4726 #define elf_backend_relocate_section \
4727 elfNN_ia64_relocate_section
4728 #define elf_backend_finish_dynamic_symbol \
4729 elfNN_ia64_finish_dynamic_symbol
4730 #define elf_backend_finish_dynamic_sections \
4731 elfNN_ia64_finish_dynamic_sections
4732 #define bfd_elfNN_bfd_final_link \
4733 elfNN_ia64_final_link
4735 #define bfd_elfNN_bfd_merge_private_bfd_data \
4736 elfNN_ia64_merge_private_bfd_data
4737 #define bfd_elfNN_bfd_set_private_flags \
4738 elfNN_ia64_set_private_flags
4739 #define bfd_elfNN_bfd_print_private_bfd_data \
4740 elfNN_ia64_print_private_bfd_data
4742 #define elf_backend_plt_readonly 1
4743 #define elf_backend_want_plt_sym 0
4744 #define elf_backend_plt_alignment 5
4745 #define elf_backend_got_header_size 0
4746 #define elf_backend_plt_header_size PLT_HEADER_SIZE
4747 #define elf_backend_want_got_plt 1
4748 #define elf_backend_may_use_rel_p 1
4749 #define elf_backend_may_use_rela_p 1
4750 #define elf_backend_default_use_rela_p 1
4751 #define elf_backend_want_dynbss 0
4752 #define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect
4753 #define elf_backend_hide_symbol elfNN_ia64_hash_hide_symbol
4754 #define elf_backend_reloc_type_class elfNN_ia64_reloc_type_class
4755 #define elf_backend_rela_normal 1
4757 #include "elfNN-target.h"
4759 /* AIX-specific vectors. */
4761 #undef TARGET_LITTLE_SYM
4762 #define TARGET_LITTLE_SYM bfd_elfNN_ia64_aix_little_vec
4763 #undef TARGET_LITTLE_NAME
4764 #define TARGET_LITTLE_NAME "elfNN-ia64-aix-little"
4765 #undef TARGET_BIG_SYM
4766 #define TARGET_BIG_SYM bfd_elfNN_ia64_aix_big_vec
4767 #undef TARGET_BIG_NAME
4768 #define TARGET_BIG_NAME "elfNN-ia64-aix-big"
4770 #undef elf_backend_add_symbol_hook
4771 #define elf_backend_add_symbol_hook elfNN_ia64_aix_add_symbol_hook
4773 #undef bfd_elfNN_bfd_link_add_symbols
4774 #define bfd_elfNN_bfd_link_add_symbols elfNN_ia64_aix_link_add_symbols
4776 #define elfNN_bed elfNN_ia64_aix_bed
4778 #include "elfNN-target.h"
4780 /* HPUX-specific vectors. */
4782 #undef TARGET_LITTLE_SYM
4783 #undef TARGET_LITTLE_NAME
4784 #undef TARGET_BIG_SYM
4785 #define TARGET_BIG_SYM bfd_elfNN_ia64_hpux_big_vec
4786 #undef TARGET_BIG_NAME
4787 #define TARGET_BIG_NAME "elfNN-ia64-hpux-big"
4789 /* We need to undo the AIX specific functions. */
4791 #undef elf_backend_add_symbol_hook
4792 #define elf_backend_add_symbol_hook elfNN_ia64_add_symbol_hook
4794 #undef bfd_elfNN_bfd_link_add_symbols
4795 #define bfd_elfNN_bfd_link_add_symbols _bfd_generic_link_add_symbols
4797 /* These are HP-UX specific functions. */
4799 #undef elf_backend_post_process_headers
4800 #define elf_backend_post_process_headers elfNN_hpux_post_process_headers
4802 #undef elf_backend_section_from_bfd_section
4803 #define elf_backend_section_from_bfd_section elfNN_hpux_backend_section_from_bfd_section
4805 #undef elf_backend_want_p_paddr_set_to_zero
4806 #define elf_backend_want_p_paddr_set_to_zero 1
4808 #undef ELF_MAXPAGESIZE
4809 #define ELF_MAXPAGESIZE 0x1000 /* 1K */
4812 #define elfNN_bed elfNN_ia64_hpux_bed
4814 #include "elfNN-target.h"
4816 #undef elf_backend_want_p_paddr_set_to_zero