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"
28 /* THE RULES for all the stuff the linker creates --
30 GOT Entries created in response to LTOFF or LTOFF_FPTR
31 relocations. Dynamic relocs created for dynamic
32 symbols in an application; REL relocs for locals
35 FPTR The canonical function descriptor. Created for local
36 symbols in applications. Descriptors for dynamic symbols
37 and local symbols in shared libraries are created by
38 ld.so. Thus there are no dynamic relocs against these
39 objects. The FPTR relocs for such _are_ passed through
40 to the dynamic relocation tables.
42 FULL_PLT Created for a PCREL21B relocation against a dynamic symbol.
43 Requires the creation of a PLTOFF entry. This does not
44 require any dynamic relocations.
46 PLTOFF Created by PLTOFF relocations. For local symbols, this
47 is an alternate function descriptor, and in shared libraries
48 requires two REL relocations. Note that this cannot be
49 transformed into an FPTR relocation, since it must be in
50 range of the GP. For dynamic symbols, this is a function
51 descriptor for a MIN_PLT entry, and requires one IPLT reloc.
53 MIN_PLT Created by PLTOFF entries against dynamic symbols. This
54 does not reqire dynamic relocations. */
56 #define NELEMS(a) ((int) (sizeof (a) / sizeof ((a)[0])))
58 typedef struct bfd_hash_entry
*(*new_hash_entry_func
)
59 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
61 /* In dynamically (linker-) created sections, we generally need to keep track
62 of the place a symbol or expression got allocated to. This is done via hash
63 tables that store entries of the following type. */
65 struct elfNN_ia64_dyn_sym_info
67 /* The addend for which this entry is relevant. */
70 /* Next addend in the list. */
71 struct elfNN_ia64_dyn_sym_info
*next
;
75 bfd_vma pltoff_offset
;
79 bfd_vma dtpmod_offset
;
80 bfd_vma dtprel_offset
;
82 /* The symbol table entry, if any, that this was derrived from. */
83 struct elf_link_hash_entry
*h
;
85 /* Used to count non-got, non-plt relocations for delayed sizing
86 of relocation sections. */
87 struct elfNN_ia64_dyn_reloc_entry
89 struct elfNN_ia64_dyn_reloc_entry
*next
;
95 /* TRUE when the section contents have been updated. */
96 unsigned got_done
: 1;
97 unsigned fptr_done
: 1;
98 unsigned pltoff_done
: 1;
99 unsigned tprel_done
: 1;
100 unsigned dtpmod_done
: 1;
101 unsigned dtprel_done
: 1;
103 /* TRUE for the different kinds of linker data we want created. */
104 unsigned want_got
: 1;
105 unsigned want_fptr
: 1;
106 unsigned want_ltoff_fptr
: 1;
107 unsigned want_plt
: 1;
108 unsigned want_plt2
: 1;
109 unsigned want_pltoff
: 1;
110 unsigned want_tprel
: 1;
111 unsigned want_dtpmod
: 1;
112 unsigned want_dtprel
: 1;
115 struct elfNN_ia64_local_hash_entry
117 struct bfd_hash_entry root
;
118 struct elfNN_ia64_dyn_sym_info
*info
;
120 /* TRUE if this hash entry's addends was translated for
121 SHF_MERGE optimization. */
122 unsigned sec_merge_done
: 1;
125 struct elfNN_ia64_local_hash_table
127 struct bfd_hash_table root
;
128 /* No additional fields for now. */
131 struct elfNN_ia64_link_hash_entry
133 struct elf_link_hash_entry root
;
134 struct elfNN_ia64_dyn_sym_info
*info
;
137 struct elfNN_ia64_link_hash_table
139 /* The main hash table. */
140 struct elf_link_hash_table root
;
142 asection
*got_sec
; /* the linkage table section (or NULL) */
143 asection
*rel_got_sec
; /* dynamic relocation section for same */
144 asection
*fptr_sec
; /* function descriptor table (or NULL) */
145 asection
*plt_sec
; /* the primary plt section (or NULL) */
146 asection
*pltoff_sec
; /* private descriptors for plt (or NULL) */
147 asection
*rel_pltoff_sec
; /* dynamic relocation section for same */
149 bfd_size_type minplt_entries
; /* number of minplt entries */
150 unsigned reltext
: 1; /* are there relocs against readonly sections? */
152 struct elfNN_ia64_local_hash_table loc_hash_table
;
155 #define elfNN_ia64_hash_table(p) \
156 ((struct elfNN_ia64_link_hash_table *) ((p)->hash))
158 static bfd_reloc_status_type elfNN_ia64_reloc
159 PARAMS ((bfd
*abfd
, arelent
*reloc
, asymbol
*sym
, PTR data
,
160 asection
*input_section
, bfd
*output_bfd
, char **error_message
));
161 static reloc_howto_type
* lookup_howto
162 PARAMS ((unsigned int rtype
));
163 static reloc_howto_type
*elfNN_ia64_reloc_type_lookup
164 PARAMS ((bfd
*abfd
, bfd_reloc_code_real_type bfd_code
));
165 static void elfNN_ia64_info_to_howto
166 PARAMS ((bfd
*abfd
, arelent
*bfd_reloc
, Elf_Internal_Rela
*elf_reloc
));
167 static bfd_boolean elfNN_ia64_relax_section
168 PARAMS((bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
,
169 bfd_boolean
*again
));
170 static bfd_boolean is_unwind_section_name
171 PARAMS ((bfd
*abfd
, const char *));
172 static bfd_boolean elfNN_ia64_section_from_shdr
173 PARAMS ((bfd
*, Elf_Internal_Shdr
*, const char *));
174 static bfd_boolean elfNN_ia64_section_flags
175 PARAMS ((flagword
*, Elf_Internal_Shdr
*));
176 static bfd_boolean elfNN_ia64_fake_sections
177 PARAMS ((bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*sec
));
178 static void elfNN_ia64_final_write_processing
179 PARAMS ((bfd
*abfd
, bfd_boolean linker
));
180 static bfd_boolean elfNN_ia64_add_symbol_hook
181 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, const Elf_Internal_Sym
*sym
,
182 const char **namep
, flagword
*flagsp
, asection
**secp
,
184 static bfd_boolean elfNN_ia64_aix_vec
185 PARAMS ((const bfd_target
*vec
));
186 static bfd_boolean elfNN_ia64_aix_add_symbol_hook
187 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, const Elf_Internal_Sym
*sym
,
188 const char **namep
, flagword
*flagsp
, asection
**secp
,
190 static bfd_boolean elfNN_ia64_aix_link_add_symbols
191 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
192 static int elfNN_ia64_additional_program_headers
193 PARAMS ((bfd
*abfd
));
194 static bfd_boolean elfNN_ia64_modify_segment_map
196 static bfd_boolean elfNN_ia64_is_local_label_name
197 PARAMS ((bfd
*abfd
, const char *name
));
198 static bfd_boolean elfNN_ia64_dynamic_symbol_p
199 PARAMS ((struct elf_link_hash_entry
*h
, struct bfd_link_info
*info
));
200 static bfd_boolean elfNN_ia64_local_hash_table_init
201 PARAMS ((struct elfNN_ia64_local_hash_table
*ht
, bfd
*abfd
,
202 new_hash_entry_func
new));
203 static struct bfd_hash_entry
*elfNN_ia64_new_loc_hash_entry
204 PARAMS ((struct bfd_hash_entry
*entry
, struct bfd_hash_table
*table
,
205 const char *string
));
206 static struct bfd_hash_entry
*elfNN_ia64_new_elf_hash_entry
207 PARAMS ((struct bfd_hash_entry
*entry
, struct bfd_hash_table
*table
,
208 const char *string
));
209 static void elfNN_ia64_hash_copy_indirect
210 PARAMS ((struct elf_backend_data
*, struct elf_link_hash_entry
*,
211 struct elf_link_hash_entry
*));
212 static void elfNN_ia64_hash_hide_symbol
213 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*, bfd_boolean
));
214 static struct bfd_link_hash_table
*elfNN_ia64_hash_table_create
215 PARAMS ((bfd
*abfd
));
216 static struct elfNN_ia64_local_hash_entry
*elfNN_ia64_local_hash_lookup
217 PARAMS ((struct elfNN_ia64_local_hash_table
*table
, const char *string
,
218 bfd_boolean create
, bfd_boolean copy
));
219 static bfd_boolean elfNN_ia64_global_dyn_sym_thunk
220 PARAMS ((struct bfd_hash_entry
*, PTR
));
221 static bfd_boolean elfNN_ia64_local_dyn_sym_thunk
222 PARAMS ((struct bfd_hash_entry
*, PTR
));
223 static void elfNN_ia64_dyn_sym_traverse
224 PARAMS ((struct elfNN_ia64_link_hash_table
*ia64_info
,
225 bfd_boolean (*func
) (struct elfNN_ia64_dyn_sym_info
*, PTR
),
227 static bfd_boolean elfNN_ia64_create_dynamic_sections
228 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
229 static struct elfNN_ia64_local_hash_entry
* get_local_sym_hash
230 PARAMS ((struct elfNN_ia64_link_hash_table
*ia64_info
,
231 bfd
*abfd
, const Elf_Internal_Rela
*rel
, bfd_boolean create
));
232 static struct elfNN_ia64_dyn_sym_info
* get_dyn_sym_info
233 PARAMS ((struct elfNN_ia64_link_hash_table
*ia64_info
,
234 struct elf_link_hash_entry
*h
,
235 bfd
*abfd
, const Elf_Internal_Rela
*rel
, bfd_boolean create
));
236 static asection
*get_got
237 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
238 struct elfNN_ia64_link_hash_table
*ia64_info
));
239 static asection
*get_fptr
240 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
241 struct elfNN_ia64_link_hash_table
*ia64_info
));
242 static asection
*get_pltoff
243 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
244 struct elfNN_ia64_link_hash_table
*ia64_info
));
245 static asection
*get_reloc_section
246 PARAMS ((bfd
*abfd
, struct elfNN_ia64_link_hash_table
*ia64_info
,
247 asection
*sec
, bfd_boolean create
));
248 static bfd_boolean count_dyn_reloc
249 PARAMS ((bfd
*abfd
, struct elfNN_ia64_dyn_sym_info
*dyn_i
,
250 asection
*srel
, int type
));
251 static bfd_boolean elfNN_ia64_check_relocs
252 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
253 const Elf_Internal_Rela
*relocs
));
254 static bfd_boolean elfNN_ia64_adjust_dynamic_symbol
255 PARAMS ((struct bfd_link_info
*info
, struct elf_link_hash_entry
*h
));
256 static long global_sym_index
257 PARAMS ((struct elf_link_hash_entry
*h
));
258 static bfd_boolean allocate_fptr
259 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
260 static bfd_boolean allocate_global_data_got
261 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
262 static bfd_boolean allocate_global_fptr_got
263 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
264 static bfd_boolean allocate_local_got
265 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
266 static bfd_boolean allocate_pltoff_entries
267 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
268 static bfd_boolean allocate_plt_entries
269 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
270 static bfd_boolean allocate_plt2_entries
271 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
272 static bfd_boolean allocate_dynrel_entries
273 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
274 static bfd_boolean elfNN_ia64_size_dynamic_sections
275 PARAMS ((bfd
*output_bfd
, struct bfd_link_info
*info
));
276 static bfd_reloc_status_type elfNN_ia64_install_value
277 PARAMS ((bfd
*abfd
, bfd_byte
*hit_addr
, bfd_vma val
, unsigned int r_type
));
278 static void elfNN_ia64_install_dyn_reloc
279 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
280 asection
*srel
, bfd_vma offset
, unsigned int type
,
281 long dynindx
, bfd_vma addend
));
282 static bfd_vma set_got_entry
283 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
284 struct elfNN_ia64_dyn_sym_info
*dyn_i
, long dynindx
,
285 bfd_vma addend
, bfd_vma value
, unsigned int dyn_r_type
));
286 static bfd_vma set_fptr_entry
287 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
288 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
290 static bfd_vma set_pltoff_entry
291 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
292 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
293 bfd_vma value
, bfd_boolean
));
294 static bfd_vma elfNN_ia64_tprel_base
295 PARAMS ((struct bfd_link_info
*info
));
296 static bfd_vma elfNN_ia64_dtprel_base
297 PARAMS ((struct bfd_link_info
*info
));
298 static int elfNN_ia64_unwind_entry_compare
299 PARAMS ((const PTR
, const PTR
));
300 static bfd_boolean elfNN_ia64_final_link
301 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
302 static bfd_boolean elfNN_ia64_relocate_section
303 PARAMS ((bfd
*output_bfd
, struct bfd_link_info
*info
, bfd
*input_bfd
,
304 asection
*input_section
, bfd_byte
*contents
,
305 Elf_Internal_Rela
*relocs
, Elf_Internal_Sym
*local_syms
,
306 asection
**local_sections
));
307 static bfd_boolean elfNN_ia64_finish_dynamic_symbol
308 PARAMS ((bfd
*output_bfd
, struct bfd_link_info
*info
,
309 struct elf_link_hash_entry
*h
, Elf_Internal_Sym
*sym
));
310 static bfd_boolean elfNN_ia64_finish_dynamic_sections
311 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
312 static bfd_boolean elfNN_ia64_set_private_flags
313 PARAMS ((bfd
*abfd
, flagword flags
));
314 static bfd_boolean elfNN_ia64_merge_private_bfd_data
315 PARAMS ((bfd
*ibfd
, bfd
*obfd
));
316 static bfd_boolean elfNN_ia64_print_private_bfd_data
317 PARAMS ((bfd
*abfd
, PTR ptr
));
318 static enum elf_reloc_type_class elfNN_ia64_reloc_type_class
319 PARAMS ((const Elf_Internal_Rela
*));
320 static bfd_boolean elfNN_ia64_hpux_vec
321 PARAMS ((const bfd_target
*vec
));
322 static void elfNN_hpux_post_process_headers
323 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
324 bfd_boolean elfNN_hpux_backend_section_from_bfd_section
325 PARAMS ((bfd
*abfd
, asection
*sec
, int *retval
));
327 /* ia64-specific relocation. */
329 /* Perform a relocation. Not much to do here as all the hard work is
330 done in elfNN_ia64_final_link_relocate. */
331 static bfd_reloc_status_type
332 elfNN_ia64_reloc (abfd
, reloc
, sym
, data
, input_section
,
333 output_bfd
, error_message
)
334 bfd
*abfd ATTRIBUTE_UNUSED
;
336 asymbol
*sym ATTRIBUTE_UNUSED
;
337 PTR data ATTRIBUTE_UNUSED
;
338 asection
*input_section
;
340 char **error_message
;
344 reloc
->address
+= input_section
->output_offset
;
347 *error_message
= "Unsupported call to elfNN_ia64_reloc";
348 return bfd_reloc_notsupported
;
351 #define IA64_HOWTO(TYPE, NAME, SIZE, PCREL, IN) \
352 HOWTO (TYPE, 0, SIZE, 0, PCREL, 0, complain_overflow_signed, \
353 elfNN_ia64_reloc, NAME, FALSE, 0, 0, IN)
355 /* This table has to be sorted according to increasing number of the
357 static reloc_howto_type ia64_howto_table
[] =
359 IA64_HOWTO (R_IA64_NONE
, "NONE", 0, FALSE
, TRUE
),
361 IA64_HOWTO (R_IA64_IMM14
, "IMM14", 0, FALSE
, TRUE
),
362 IA64_HOWTO (R_IA64_IMM22
, "IMM22", 0, FALSE
, TRUE
),
363 IA64_HOWTO (R_IA64_IMM64
, "IMM64", 0, FALSE
, TRUE
),
364 IA64_HOWTO (R_IA64_DIR32MSB
, "DIR32MSB", 2, FALSE
, TRUE
),
365 IA64_HOWTO (R_IA64_DIR32LSB
, "DIR32LSB", 2, FALSE
, TRUE
),
366 IA64_HOWTO (R_IA64_DIR64MSB
, "DIR64MSB", 4, FALSE
, TRUE
),
367 IA64_HOWTO (R_IA64_DIR64LSB
, "DIR64LSB", 4, FALSE
, TRUE
),
369 IA64_HOWTO (R_IA64_GPREL22
, "GPREL22", 0, FALSE
, TRUE
),
370 IA64_HOWTO (R_IA64_GPREL64I
, "GPREL64I", 0, FALSE
, TRUE
),
371 IA64_HOWTO (R_IA64_GPREL32MSB
, "GPREL32MSB", 2, FALSE
, TRUE
),
372 IA64_HOWTO (R_IA64_GPREL32LSB
, "GPREL32LSB", 2, FALSE
, TRUE
),
373 IA64_HOWTO (R_IA64_GPREL64MSB
, "GPREL64MSB", 4, FALSE
, TRUE
),
374 IA64_HOWTO (R_IA64_GPREL64LSB
, "GPREL64LSB", 4, FALSE
, TRUE
),
376 IA64_HOWTO (R_IA64_LTOFF22
, "LTOFF22", 0, FALSE
, TRUE
),
377 IA64_HOWTO (R_IA64_LTOFF64I
, "LTOFF64I", 0, FALSE
, TRUE
),
379 IA64_HOWTO (R_IA64_PLTOFF22
, "PLTOFF22", 0, FALSE
, TRUE
),
380 IA64_HOWTO (R_IA64_PLTOFF64I
, "PLTOFF64I", 0, FALSE
, TRUE
),
381 IA64_HOWTO (R_IA64_PLTOFF64MSB
, "PLTOFF64MSB", 4, FALSE
, TRUE
),
382 IA64_HOWTO (R_IA64_PLTOFF64LSB
, "PLTOFF64LSB", 4, FALSE
, TRUE
),
384 IA64_HOWTO (R_IA64_FPTR64I
, "FPTR64I", 0, FALSE
, TRUE
),
385 IA64_HOWTO (R_IA64_FPTR32MSB
, "FPTR32MSB", 2, FALSE
, TRUE
),
386 IA64_HOWTO (R_IA64_FPTR32LSB
, "FPTR32LSB", 2, FALSE
, TRUE
),
387 IA64_HOWTO (R_IA64_FPTR64MSB
, "FPTR64MSB", 4, FALSE
, TRUE
),
388 IA64_HOWTO (R_IA64_FPTR64LSB
, "FPTR64LSB", 4, FALSE
, TRUE
),
390 IA64_HOWTO (R_IA64_PCREL60B
, "PCREL60B", 0, TRUE
, TRUE
),
391 IA64_HOWTO (R_IA64_PCREL21B
, "PCREL21B", 0, TRUE
, TRUE
),
392 IA64_HOWTO (R_IA64_PCREL21M
, "PCREL21M", 0, TRUE
, TRUE
),
393 IA64_HOWTO (R_IA64_PCREL21F
, "PCREL21F", 0, TRUE
, TRUE
),
394 IA64_HOWTO (R_IA64_PCREL32MSB
, "PCREL32MSB", 2, TRUE
, TRUE
),
395 IA64_HOWTO (R_IA64_PCREL32LSB
, "PCREL32LSB", 2, TRUE
, TRUE
),
396 IA64_HOWTO (R_IA64_PCREL64MSB
, "PCREL64MSB", 4, TRUE
, TRUE
),
397 IA64_HOWTO (R_IA64_PCREL64LSB
, "PCREL64LSB", 4, TRUE
, TRUE
),
399 IA64_HOWTO (R_IA64_LTOFF_FPTR22
, "LTOFF_FPTR22", 0, FALSE
, TRUE
),
400 IA64_HOWTO (R_IA64_LTOFF_FPTR64I
, "LTOFF_FPTR64I", 0, FALSE
, TRUE
),
401 IA64_HOWTO (R_IA64_LTOFF_FPTR32MSB
, "LTOFF_FPTR32MSB", 2, FALSE
, TRUE
),
402 IA64_HOWTO (R_IA64_LTOFF_FPTR32LSB
, "LTOFF_FPTR32LSB", 2, FALSE
, TRUE
),
403 IA64_HOWTO (R_IA64_LTOFF_FPTR64MSB
, "LTOFF_FPTR64MSB", 4, FALSE
, TRUE
),
404 IA64_HOWTO (R_IA64_LTOFF_FPTR64LSB
, "LTOFF_FPTR64LSB", 4, FALSE
, TRUE
),
406 IA64_HOWTO (R_IA64_SEGREL32MSB
, "SEGREL32MSB", 2, FALSE
, TRUE
),
407 IA64_HOWTO (R_IA64_SEGREL32LSB
, "SEGREL32LSB", 2, FALSE
, TRUE
),
408 IA64_HOWTO (R_IA64_SEGREL64MSB
, "SEGREL64MSB", 4, FALSE
, TRUE
),
409 IA64_HOWTO (R_IA64_SEGREL64LSB
, "SEGREL64LSB", 4, FALSE
, TRUE
),
411 IA64_HOWTO (R_IA64_SECREL32MSB
, "SECREL32MSB", 2, FALSE
, TRUE
),
412 IA64_HOWTO (R_IA64_SECREL32LSB
, "SECREL32LSB", 2, FALSE
, TRUE
),
413 IA64_HOWTO (R_IA64_SECREL64MSB
, "SECREL64MSB", 4, FALSE
, TRUE
),
414 IA64_HOWTO (R_IA64_SECREL64LSB
, "SECREL64LSB", 4, FALSE
, TRUE
),
416 IA64_HOWTO (R_IA64_REL32MSB
, "REL32MSB", 2, FALSE
, TRUE
),
417 IA64_HOWTO (R_IA64_REL32LSB
, "REL32LSB", 2, FALSE
, TRUE
),
418 IA64_HOWTO (R_IA64_REL64MSB
, "REL64MSB", 4, FALSE
, TRUE
),
419 IA64_HOWTO (R_IA64_REL64LSB
, "REL64LSB", 4, FALSE
, TRUE
),
421 IA64_HOWTO (R_IA64_LTV32MSB
, "LTV32MSB", 2, FALSE
, TRUE
),
422 IA64_HOWTO (R_IA64_LTV32LSB
, "LTV32LSB", 2, FALSE
, TRUE
),
423 IA64_HOWTO (R_IA64_LTV64MSB
, "LTV64MSB", 4, FALSE
, TRUE
),
424 IA64_HOWTO (R_IA64_LTV64LSB
, "LTV64LSB", 4, FALSE
, TRUE
),
426 IA64_HOWTO (R_IA64_PCREL21BI
, "PCREL21BI", 0, TRUE
, TRUE
),
427 IA64_HOWTO (R_IA64_PCREL22
, "PCREL22", 0, TRUE
, TRUE
),
428 IA64_HOWTO (R_IA64_PCREL64I
, "PCREL64I", 0, TRUE
, TRUE
),
430 IA64_HOWTO (R_IA64_IPLTMSB
, "IPLTMSB", 4, FALSE
, TRUE
),
431 IA64_HOWTO (R_IA64_IPLTLSB
, "IPLTLSB", 4, FALSE
, TRUE
),
432 IA64_HOWTO (R_IA64_COPY
, "COPY", 4, FALSE
, TRUE
),
433 IA64_HOWTO (R_IA64_LTOFF22X
, "LTOFF22X", 0, FALSE
, TRUE
),
434 IA64_HOWTO (R_IA64_LDXMOV
, "LDXMOV", 0, FALSE
, TRUE
),
436 IA64_HOWTO (R_IA64_TPREL14
, "TPREL14", 0, FALSE
, FALSE
),
437 IA64_HOWTO (R_IA64_TPREL22
, "TPREL22", 0, FALSE
, FALSE
),
438 IA64_HOWTO (R_IA64_TPREL64I
, "TPREL64I", 0, FALSE
, FALSE
),
439 IA64_HOWTO (R_IA64_TPREL64MSB
, "TPREL64MSB", 8, FALSE
, FALSE
),
440 IA64_HOWTO (R_IA64_TPREL64LSB
, "TPREL64LSB", 8, FALSE
, FALSE
),
441 IA64_HOWTO (R_IA64_LTOFF_TPREL22
, "LTOFF_TPREL22", 0, FALSE
, FALSE
),
443 IA64_HOWTO (R_IA64_DTPMOD64MSB
, "TPREL64MSB", 8, FALSE
, FALSE
),
444 IA64_HOWTO (R_IA64_DTPMOD64LSB
, "TPREL64LSB", 8, FALSE
, FALSE
),
445 IA64_HOWTO (R_IA64_LTOFF_DTPMOD22
, "LTOFF_DTPMOD22", 0, FALSE
, FALSE
),
447 IA64_HOWTO (R_IA64_DTPREL14
, "DTPREL14", 0, FALSE
, FALSE
),
448 IA64_HOWTO (R_IA64_DTPREL22
, "DTPREL22", 0, FALSE
, FALSE
),
449 IA64_HOWTO (R_IA64_DTPREL64I
, "DTPREL64I", 0, FALSE
, FALSE
),
450 IA64_HOWTO (R_IA64_DTPREL32MSB
, "DTPREL32MSB", 4, FALSE
, FALSE
),
451 IA64_HOWTO (R_IA64_DTPREL32LSB
, "DTPREL32LSB", 4, FALSE
, FALSE
),
452 IA64_HOWTO (R_IA64_DTPREL64MSB
, "DTPREL64MSB", 8, FALSE
, FALSE
),
453 IA64_HOWTO (R_IA64_DTPREL64LSB
, "DTPREL64LSB", 8, FALSE
, FALSE
),
454 IA64_HOWTO (R_IA64_LTOFF_DTPREL22
, "LTOFF_DTPREL22", 0, FALSE
, FALSE
),
457 static unsigned char elf_code_to_howto_index
[R_IA64_MAX_RELOC_CODE
+ 1];
459 /* Given a BFD reloc type, return the matching HOWTO structure. */
461 static reloc_howto_type
*
465 static int inited
= 0;
472 memset (elf_code_to_howto_index
, 0xff, sizeof (elf_code_to_howto_index
));
473 for (i
= 0; i
< NELEMS (ia64_howto_table
); ++i
)
474 elf_code_to_howto_index
[ia64_howto_table
[i
].type
] = i
;
477 BFD_ASSERT (rtype
<= R_IA64_MAX_RELOC_CODE
);
478 i
= elf_code_to_howto_index
[rtype
];
479 if (i
>= NELEMS (ia64_howto_table
))
481 return ia64_howto_table
+ i
;
484 static reloc_howto_type
*
485 elfNN_ia64_reloc_type_lookup (abfd
, bfd_code
)
486 bfd
*abfd ATTRIBUTE_UNUSED
;
487 bfd_reloc_code_real_type bfd_code
;
493 case BFD_RELOC_NONE
: rtype
= R_IA64_NONE
; break;
495 case BFD_RELOC_IA64_IMM14
: rtype
= R_IA64_IMM14
; break;
496 case BFD_RELOC_IA64_IMM22
: rtype
= R_IA64_IMM22
; break;
497 case BFD_RELOC_IA64_IMM64
: rtype
= R_IA64_IMM64
; break;
499 case BFD_RELOC_IA64_DIR32MSB
: rtype
= R_IA64_DIR32MSB
; break;
500 case BFD_RELOC_IA64_DIR32LSB
: rtype
= R_IA64_DIR32LSB
; break;
501 case BFD_RELOC_IA64_DIR64MSB
: rtype
= R_IA64_DIR64MSB
; break;
502 case BFD_RELOC_IA64_DIR64LSB
: rtype
= R_IA64_DIR64LSB
; break;
504 case BFD_RELOC_IA64_GPREL22
: rtype
= R_IA64_GPREL22
; break;
505 case BFD_RELOC_IA64_GPREL64I
: rtype
= R_IA64_GPREL64I
; break;
506 case BFD_RELOC_IA64_GPREL32MSB
: rtype
= R_IA64_GPREL32MSB
; break;
507 case BFD_RELOC_IA64_GPREL32LSB
: rtype
= R_IA64_GPREL32LSB
; break;
508 case BFD_RELOC_IA64_GPREL64MSB
: rtype
= R_IA64_GPREL64MSB
; break;
509 case BFD_RELOC_IA64_GPREL64LSB
: rtype
= R_IA64_GPREL64LSB
; break;
511 case BFD_RELOC_IA64_LTOFF22
: rtype
= R_IA64_LTOFF22
; break;
512 case BFD_RELOC_IA64_LTOFF64I
: rtype
= R_IA64_LTOFF64I
; break;
514 case BFD_RELOC_IA64_PLTOFF22
: rtype
= R_IA64_PLTOFF22
; break;
515 case BFD_RELOC_IA64_PLTOFF64I
: rtype
= R_IA64_PLTOFF64I
; break;
516 case BFD_RELOC_IA64_PLTOFF64MSB
: rtype
= R_IA64_PLTOFF64MSB
; break;
517 case BFD_RELOC_IA64_PLTOFF64LSB
: rtype
= R_IA64_PLTOFF64LSB
; break;
518 case BFD_RELOC_IA64_FPTR64I
: rtype
= R_IA64_FPTR64I
; break;
519 case BFD_RELOC_IA64_FPTR32MSB
: rtype
= R_IA64_FPTR32MSB
; break;
520 case BFD_RELOC_IA64_FPTR32LSB
: rtype
= R_IA64_FPTR32LSB
; break;
521 case BFD_RELOC_IA64_FPTR64MSB
: rtype
= R_IA64_FPTR64MSB
; break;
522 case BFD_RELOC_IA64_FPTR64LSB
: rtype
= R_IA64_FPTR64LSB
; break;
524 case BFD_RELOC_IA64_PCREL21B
: rtype
= R_IA64_PCREL21B
; break;
525 case BFD_RELOC_IA64_PCREL21BI
: rtype
= R_IA64_PCREL21BI
; break;
526 case BFD_RELOC_IA64_PCREL21M
: rtype
= R_IA64_PCREL21M
; break;
527 case BFD_RELOC_IA64_PCREL21F
: rtype
= R_IA64_PCREL21F
; break;
528 case BFD_RELOC_IA64_PCREL22
: rtype
= R_IA64_PCREL22
; break;
529 case BFD_RELOC_IA64_PCREL60B
: rtype
= R_IA64_PCREL60B
; break;
530 case BFD_RELOC_IA64_PCREL64I
: rtype
= R_IA64_PCREL64I
; break;
531 case BFD_RELOC_IA64_PCREL32MSB
: rtype
= R_IA64_PCREL32MSB
; break;
532 case BFD_RELOC_IA64_PCREL32LSB
: rtype
= R_IA64_PCREL32LSB
; break;
533 case BFD_RELOC_IA64_PCREL64MSB
: rtype
= R_IA64_PCREL64MSB
; break;
534 case BFD_RELOC_IA64_PCREL64LSB
: rtype
= R_IA64_PCREL64LSB
; break;
536 case BFD_RELOC_IA64_LTOFF_FPTR22
: rtype
= R_IA64_LTOFF_FPTR22
; break;
537 case BFD_RELOC_IA64_LTOFF_FPTR64I
: rtype
= R_IA64_LTOFF_FPTR64I
; break;
538 case BFD_RELOC_IA64_LTOFF_FPTR32MSB
: rtype
= R_IA64_LTOFF_FPTR32MSB
; break;
539 case BFD_RELOC_IA64_LTOFF_FPTR32LSB
: rtype
= R_IA64_LTOFF_FPTR32LSB
; break;
540 case BFD_RELOC_IA64_LTOFF_FPTR64MSB
: rtype
= R_IA64_LTOFF_FPTR64MSB
; break;
541 case BFD_RELOC_IA64_LTOFF_FPTR64LSB
: rtype
= R_IA64_LTOFF_FPTR64LSB
; break;
543 case BFD_RELOC_IA64_SEGREL32MSB
: rtype
= R_IA64_SEGREL32MSB
; break;
544 case BFD_RELOC_IA64_SEGREL32LSB
: rtype
= R_IA64_SEGREL32LSB
; break;
545 case BFD_RELOC_IA64_SEGREL64MSB
: rtype
= R_IA64_SEGREL64MSB
; break;
546 case BFD_RELOC_IA64_SEGREL64LSB
: rtype
= R_IA64_SEGREL64LSB
; break;
548 case BFD_RELOC_IA64_SECREL32MSB
: rtype
= R_IA64_SECREL32MSB
; break;
549 case BFD_RELOC_IA64_SECREL32LSB
: rtype
= R_IA64_SECREL32LSB
; break;
550 case BFD_RELOC_IA64_SECREL64MSB
: rtype
= R_IA64_SECREL64MSB
; break;
551 case BFD_RELOC_IA64_SECREL64LSB
: rtype
= R_IA64_SECREL64LSB
; break;
553 case BFD_RELOC_IA64_REL32MSB
: rtype
= R_IA64_REL32MSB
; break;
554 case BFD_RELOC_IA64_REL32LSB
: rtype
= R_IA64_REL32LSB
; break;
555 case BFD_RELOC_IA64_REL64MSB
: rtype
= R_IA64_REL64MSB
; break;
556 case BFD_RELOC_IA64_REL64LSB
: rtype
= R_IA64_REL64LSB
; break;
558 case BFD_RELOC_IA64_LTV32MSB
: rtype
= R_IA64_LTV32MSB
; break;
559 case BFD_RELOC_IA64_LTV32LSB
: rtype
= R_IA64_LTV32LSB
; break;
560 case BFD_RELOC_IA64_LTV64MSB
: rtype
= R_IA64_LTV64MSB
; break;
561 case BFD_RELOC_IA64_LTV64LSB
: rtype
= R_IA64_LTV64LSB
; break;
563 case BFD_RELOC_IA64_IPLTMSB
: rtype
= R_IA64_IPLTMSB
; break;
564 case BFD_RELOC_IA64_IPLTLSB
: rtype
= R_IA64_IPLTLSB
; break;
565 case BFD_RELOC_IA64_COPY
: rtype
= R_IA64_COPY
; break;
566 case BFD_RELOC_IA64_LTOFF22X
: rtype
= R_IA64_LTOFF22X
; break;
567 case BFD_RELOC_IA64_LDXMOV
: rtype
= R_IA64_LDXMOV
; break;
569 case BFD_RELOC_IA64_TPREL14
: rtype
= R_IA64_TPREL14
; break;
570 case BFD_RELOC_IA64_TPREL22
: rtype
= R_IA64_TPREL22
; break;
571 case BFD_RELOC_IA64_TPREL64I
: rtype
= R_IA64_TPREL64I
; break;
572 case BFD_RELOC_IA64_TPREL64MSB
: rtype
= R_IA64_TPREL64MSB
; break;
573 case BFD_RELOC_IA64_TPREL64LSB
: rtype
= R_IA64_TPREL64LSB
; break;
574 case BFD_RELOC_IA64_LTOFF_TPREL22
: rtype
= R_IA64_LTOFF_TPREL22
; break;
576 case BFD_RELOC_IA64_DTPMOD64MSB
: rtype
= R_IA64_DTPMOD64MSB
; break;
577 case BFD_RELOC_IA64_DTPMOD64LSB
: rtype
= R_IA64_DTPMOD64LSB
; break;
578 case BFD_RELOC_IA64_LTOFF_DTPMOD22
: rtype
= R_IA64_LTOFF_DTPMOD22
; break;
580 case BFD_RELOC_IA64_DTPREL14
: rtype
= R_IA64_DTPREL14
; break;
581 case BFD_RELOC_IA64_DTPREL22
: rtype
= R_IA64_DTPREL22
; break;
582 case BFD_RELOC_IA64_DTPREL64I
: rtype
= R_IA64_DTPREL64I
; break;
583 case BFD_RELOC_IA64_DTPREL32MSB
: rtype
= R_IA64_DTPREL32MSB
; break;
584 case BFD_RELOC_IA64_DTPREL32LSB
: rtype
= R_IA64_DTPREL32LSB
; break;
585 case BFD_RELOC_IA64_DTPREL64MSB
: rtype
= R_IA64_DTPREL64MSB
; break;
586 case BFD_RELOC_IA64_DTPREL64LSB
: rtype
= R_IA64_DTPREL64LSB
; break;
587 case BFD_RELOC_IA64_LTOFF_DTPREL22
: rtype
= R_IA64_LTOFF_DTPREL22
; break;
591 return lookup_howto (rtype
);
594 /* Given a ELF reloc, return the matching HOWTO structure. */
597 elfNN_ia64_info_to_howto (abfd
, bfd_reloc
, elf_reloc
)
598 bfd
*abfd ATTRIBUTE_UNUSED
;
600 Elf_Internal_Rela
*elf_reloc
;
603 = lookup_howto ((unsigned int) ELFNN_R_TYPE (elf_reloc
->r_info
));
606 #define PLT_HEADER_SIZE (3 * 16)
607 #define PLT_MIN_ENTRY_SIZE (1 * 16)
608 #define PLT_FULL_ENTRY_SIZE (2 * 16)
609 #define PLT_RESERVED_WORDS 3
611 static const bfd_byte plt_header
[PLT_HEADER_SIZE
] =
613 0x0b, 0x10, 0x00, 0x1c, 0x00, 0x21, /* [MMI] mov r2=r14;; */
614 0xe0, 0x00, 0x08, 0x00, 0x48, 0x00, /* addl r14=0,r2 */
615 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
616 0x0b, 0x80, 0x20, 0x1c, 0x18, 0x14, /* [MMI] ld8 r16=[r14],8;; */
617 0x10, 0x41, 0x38, 0x30, 0x28, 0x00, /* ld8 r17=[r14],8 */
618 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
619 0x11, 0x08, 0x00, 0x1c, 0x18, 0x10, /* [MIB] ld8 r1=[r14] */
620 0x60, 0x88, 0x04, 0x80, 0x03, 0x00, /* mov b6=r17 */
621 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
624 static const bfd_byte plt_min_entry
[PLT_MIN_ENTRY_SIZE
] =
626 0x11, 0x78, 0x00, 0x00, 0x00, 0x24, /* [MIB] mov r15=0 */
627 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, /* nop.i 0x0 */
628 0x00, 0x00, 0x00, 0x40 /* br.few 0 <PLT0>;; */
631 static const bfd_byte plt_full_entry
[PLT_FULL_ENTRY_SIZE
] =
633 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
634 0x00, 0x41, 0x3c, 0x30, 0x28, 0xc0, /* ld8 r16=[r15],8 */
635 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
636 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
637 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
638 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
641 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
642 #define AIX_DYNAMIC_INTERPRETER "/usr/lib/ia64l64/libc.so.1"
643 #define DYNAMIC_INTERPRETER(abfd) \
644 (elfNN_ia64_aix_vec (abfd->xvec) ? AIX_DYNAMIC_INTERPRETER : ELF_DYNAMIC_INTERPRETER)
646 /* Select out of range branch fixup type. Note that Itanium does
647 not support brl, and so it gets emulated by the kernel. */
651 static const bfd_byte oor_brl
[16] =
653 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
654 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;; */
655 0x00, 0x00, 0x00, 0xc0
658 static const bfd_byte oor_ip
[48] =
660 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
661 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, /* movl r15=0 */
662 0x01, 0x00, 0x00, 0x60,
663 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MII] nop.m 0 */
664 0x00, 0x01, 0x00, 0x60, 0x00, 0x00, /* mov r16=ip;; */
665 0xf2, 0x80, 0x00, 0x80, /* add r16=r15,r16;; */
666 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MIB] nop.m 0 */
667 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
668 0x60, 0x00, 0x80, 0x00 /* br b6;; */
672 /* These functions do relaxation for IA-64 ELF.
674 This is primarily to support branches to targets out of range;
675 relaxation of R_IA64_LTOFF22X and R_IA64_LDXMOV not yet supported. */
678 elfNN_ia64_relax_section (abfd
, sec
, link_info
, again
)
681 struct bfd_link_info
*link_info
;
686 struct one_fixup
*next
;
692 Elf_Internal_Shdr
*symtab_hdr
;
693 Elf_Internal_Rela
*internal_relocs
;
694 Elf_Internal_Rela
*irel
, *irelend
;
696 Elf_Internal_Sym
*isymbuf
= NULL
;
697 struct elfNN_ia64_link_hash_table
*ia64_info
;
698 struct one_fixup
*fixups
= NULL
;
699 bfd_boolean changed_contents
= FALSE
;
700 bfd_boolean changed_relocs
= FALSE
;
702 /* Assume we're not going to change any sizes, and we'll only need
706 /* Nothing to do if there are no relocations. */
707 if ((sec
->flags
& SEC_RELOC
) == 0
708 || sec
->reloc_count
== 0)
711 /* If this is the first time we have been called for this section,
712 initialize the cooked size. */
713 if (sec
->_cooked_size
== 0)
714 sec
->_cooked_size
= sec
->_raw_size
;
716 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
718 /* Load the relocations for this section. */
719 internal_relocs
= (_bfd_elfNN_link_read_relocs
720 (abfd
, sec
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
721 link_info
->keep_memory
));
722 if (internal_relocs
== NULL
)
725 ia64_info
= elfNN_ia64_hash_table (link_info
);
726 irelend
= internal_relocs
+ sec
->reloc_count
;
728 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
729 if (ELFNN_R_TYPE (irel
->r_info
) == (int) R_IA64_PCREL21B
730 || ELFNN_R_TYPE (irel
->r_info
) == (int) R_IA64_PCREL21M
731 || ELFNN_R_TYPE (irel
->r_info
) == (int) R_IA64_PCREL21F
)
734 /* No branch-type relocations. */
737 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
738 free (internal_relocs
);
742 /* Get the section contents. */
743 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
744 contents
= elf_section_data (sec
)->this_hdr
.contents
;
747 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
748 if (contents
== NULL
)
751 if (! bfd_get_section_contents (abfd
, sec
, contents
,
752 (file_ptr
) 0, sec
->_raw_size
))
756 for (; irel
< irelend
; irel
++)
758 bfd_vma symaddr
, reladdr
, trampoff
, toff
, roff
;
763 if (ELFNN_R_TYPE (irel
->r_info
) != (int) R_IA64_PCREL21B
764 && ELFNN_R_TYPE (irel
->r_info
) != (int) R_IA64_PCREL21M
765 && ELFNN_R_TYPE (irel
->r_info
) != (int) R_IA64_PCREL21F
)
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 bfd_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 Elf_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 Elf_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 Elf_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)
1093 /* This is an ugly, but unfortunately necessary hack that is
1094 needed when producing EFI binaries on IA-64. It tells
1095 elf.c:elf_fake_sections() not to consider ".reloc" as a section
1096 containing ELF relocation info. We need this hack in order to
1097 be able to generate ELF binaries that can be translated into
1098 EFI applications (which are essentially COFF objects). Those
1099 files contain a COFF ".reloc" section inside an ELFNN object,
1100 which would normally cause BFD to segfault because it would
1101 attempt to interpret this section as containing relocation
1102 entries for section "oc". With this hack enabled, ".reloc"
1103 will be treated as a normal data section, which will avoid the
1104 segfault. However, you won't be able to create an ELFNN binary
1105 with a section named "oc" that needs relocations, but that's
1106 the kind of ugly side-effects you get when detecting section
1107 types based on their names... In practice, this limitation is
1108 unlikely to bite. */
1109 hdr
->sh_type
= SHT_PROGBITS
;
1111 if (sec
->flags
& SEC_SMALL_DATA
)
1112 hdr
->sh_flags
|= SHF_IA_64_SHORT
;
1117 /* The final processing done just before writing out an IA-64 ELF
1121 elfNN_ia64_final_write_processing (abfd
, linker
)
1123 bfd_boolean linker ATTRIBUTE_UNUSED
;
1125 Elf_Internal_Shdr
*hdr
;
1127 asection
*text_sect
, *s
;
1130 for (s
= abfd
->sections
; s
; s
= s
->next
)
1132 hdr
= &elf_section_data (s
)->this_hdr
;
1133 switch (hdr
->sh_type
)
1135 case SHT_IA_64_UNWIND
:
1136 /* See comments in gas/config/tc-ia64.c:dot_endp on why we
1138 sname
= bfd_get_section_name (abfd
, s
);
1139 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
1140 if (sname
&& strncmp (sname
, ELF_STRING_ia64_unwind
, len
) == 0)
1144 if (sname
[0] == '\0')
1145 /* .IA_64.unwind -> .text */
1146 text_sect
= bfd_get_section_by_name (abfd
, ".text");
1148 /* .IA_64.unwindFOO -> FOO */
1149 text_sect
= bfd_get_section_by_name (abfd
, sname
);
1152 && (len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1,
1153 strncmp (sname
, ELF_STRING_ia64_unwind_once
, len
)) == 0)
1155 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.t.FOO */
1156 size_t len2
= sizeof (".gnu.linkonce.t.") - 1;
1157 char *once_name
= bfd_malloc (len2
+ strlen (sname
+ len
) + 1);
1159 if (once_name
!= NULL
)
1161 memcpy (once_name
, ".gnu.linkonce.t.", len2
);
1162 strcpy (once_name
+ len2
, sname
+ len
);
1163 text_sect
= bfd_get_section_by_name (abfd
, once_name
);
1167 /* Should only happen if we run out of memory, in
1168 which case we're probably toast anyway. Try to
1169 cope by finding the section the slow way. */
1170 for (text_sect
= abfd
->sections
;
1172 text_sect
= text_sect
->next
)
1174 if (strncmp (bfd_section_name (abfd
, text_sect
),
1175 ".gnu.linkonce.t.", len2
) == 0
1176 && strcmp (bfd_section_name (abfd
, text_sect
) + len2
,
1182 /* last resort: fall back on .text */
1183 text_sect
= bfd_get_section_by_name (abfd
, ".text");
1187 /* The IA-64 processor-specific ABI requires setting
1188 sh_link to the unwind section, whereas HP-UX requires
1189 sh_info to do so. For maximum compatibility, we'll
1190 set both for now... */
1191 hdr
->sh_link
= elf_section_data (text_sect
)->this_idx
;
1192 hdr
->sh_info
= elf_section_data (text_sect
)->this_idx
;
1198 if (! elf_flags_init (abfd
))
1200 unsigned long flags
= 0;
1202 if (abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
)
1203 flags
|= EF_IA_64_BE
;
1204 if (bfd_get_mach (abfd
) == bfd_mach_ia64_elf64
)
1205 flags
|= EF_IA_64_ABI64
;
1207 elf_elfheader(abfd
)->e_flags
= flags
;
1208 elf_flags_init (abfd
) = TRUE
;
1212 /* Hook called by the linker routine which adds symbols from an object
1213 file. We use it to put .comm items in .sbss, and not .bss. */
1216 elfNN_ia64_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
1218 struct bfd_link_info
*info
;
1219 const Elf_Internal_Sym
*sym
;
1220 const char **namep ATTRIBUTE_UNUSED
;
1221 flagword
*flagsp ATTRIBUTE_UNUSED
;
1225 if (sym
->st_shndx
== SHN_COMMON
1226 && !info
->relocateable
1227 && sym
->st_size
<= elf_gp_size (abfd
))
1229 /* Common symbols less than or equal to -G nn bytes are
1230 automatically put into .sbss. */
1232 asection
*scomm
= bfd_get_section_by_name (abfd
, ".scommon");
1236 scomm
= bfd_make_section (abfd
, ".scommon");
1238 || !bfd_set_section_flags (abfd
, scomm
, (SEC_ALLOC
1240 | SEC_LINKER_CREATED
)))
1245 *valp
= sym
->st_size
;
1252 elfNN_ia64_aix_vec (const bfd_target
*vec
)
1254 extern const bfd_target bfd_elfNN_ia64_aix_little_vec
;
1255 extern const bfd_target bfd_elfNN_ia64_aix_big_vec
;
1257 return (/**/vec
== & bfd_elfNN_ia64_aix_little_vec
1258 || vec
== & bfd_elfNN_ia64_aix_big_vec
);
1261 /* Hook called by the linker routine which adds symbols from an object
1262 file. We use it to handle OS-specific symbols. */
1265 elfNN_ia64_aix_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
1267 struct bfd_link_info
*info
;
1268 const Elf_Internal_Sym
*sym
;
1274 if (strcmp (*namep
, "__GLOB_DATA_PTR") == 0)
1276 /* Define __GLOB_DATA_PTR when it is encountered. This is expected to
1277 be a linker-defined symbol by the Aix C runtime startup code. IBM sez
1278 no one else should use it b/c it is undocumented. */
1279 struct elf_link_hash_entry
*h
;
1281 h
= elf_link_hash_lookup (elf_hash_table (info
), *namep
,
1282 FALSE
, FALSE
, FALSE
);
1285 struct elf_backend_data
*bed
;
1286 struct elfNN_ia64_link_hash_table
*ia64_info
;
1287 struct bfd_link_hash_entry
*bh
= NULL
;
1289 bed
= get_elf_backend_data (abfd
);
1290 ia64_info
= elfNN_ia64_hash_table (info
);
1292 if (!(_bfd_generic_link_add_one_symbol
1293 (info
, abfd
, *namep
, BSF_GLOBAL
,
1294 bfd_get_section_by_name (abfd
, ".bss"),
1295 bed
->got_symbol_offset
, (const char *) NULL
, FALSE
,
1296 bed
->collect
, &bh
)))
1299 h
= (struct elf_link_hash_entry
*) bh
;
1300 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1301 h
->type
= STT_OBJECT
;
1303 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1309 else if (sym
->st_shndx
== SHN_LOOS
)
1313 /* SHN_AIX_SYSCALL: Treat this as any other symbol. The special symbol
1314 is only relevant when compiling code for extended system calls.
1315 Replace the "special" section with .text, if possible.
1316 Note that these symbols are always assumed to be in .text. */
1317 for (i
= 1; i
< elf_numsections (abfd
); i
++)
1319 asection
* sec
= bfd_section_from_elf_index (abfd
, i
);
1321 if (sec
&& strcmp (sec
->name
, ".text") == 0)
1329 *secp
= bfd_abs_section_ptr
;
1331 *valp
= sym
->st_size
;
1337 return elfNN_ia64_add_symbol_hook (abfd
, info
, sym
,
1338 namep
, flagsp
, secp
, valp
);
1343 elfNN_ia64_aix_link_add_symbols (abfd
, info
)
1345 struct bfd_link_info
*info
;
1347 /* Make sure dynamic sections are always created. */
1348 if (! elf_hash_table (info
)->dynamic_sections_created
1349 && abfd
->xvec
== info
->hash
->creator
)
1351 if (! bfd_elfNN_link_create_dynamic_sections (abfd
, info
))
1355 /* Now do the standard call. */
1356 return bfd_elfNN_bfd_link_add_symbols (abfd
, info
);
1359 /* Return the number of additional phdrs we will need. */
1362 elfNN_ia64_additional_program_headers (abfd
)
1368 /* See if we need a PT_IA_64_ARCHEXT segment. */
1369 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_archext
);
1370 if (s
&& (s
->flags
& SEC_LOAD
))
1373 /* Count how many PT_IA_64_UNWIND segments we need. */
1374 for (s
= abfd
->sections
; s
; s
= s
->next
)
1375 if (is_unwind_section_name (abfd
, s
->name
) && (s
->flags
& SEC_LOAD
))
1382 elfNN_ia64_modify_segment_map (abfd
)
1385 struct elf_segment_map
*m
, **pm
;
1386 Elf_Internal_Shdr
*hdr
;
1389 /* If we need a PT_IA_64_ARCHEXT segment, it must come before
1390 all PT_LOAD segments. */
1391 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_archext
);
1392 if (s
&& (s
->flags
& SEC_LOAD
))
1394 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1395 if (m
->p_type
== PT_IA_64_ARCHEXT
)
1399 m
= ((struct elf_segment_map
*)
1400 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *m
));
1404 m
->p_type
= PT_IA_64_ARCHEXT
;
1408 /* We want to put it after the PHDR and INTERP segments. */
1409 pm
= &elf_tdata (abfd
)->segment_map
;
1411 && ((*pm
)->p_type
== PT_PHDR
1412 || (*pm
)->p_type
== PT_INTERP
))
1420 /* Install PT_IA_64_UNWIND segments, if needed. */
1421 for (s
= abfd
->sections
; s
; s
= s
->next
)
1423 hdr
= &elf_section_data (s
)->this_hdr
;
1424 if (hdr
->sh_type
!= SHT_IA_64_UNWIND
)
1427 if (s
&& (s
->flags
& SEC_LOAD
))
1429 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1430 if (m
->p_type
== PT_IA_64_UNWIND
)
1434 /* Look through all sections in the unwind segment
1435 for a match since there may be multiple sections
1437 for (i
= m
->count
- 1; i
>= 0; --i
)
1438 if (m
->sections
[i
] == s
)
1447 m
= ((struct elf_segment_map
*)
1448 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *m
));
1452 m
->p_type
= PT_IA_64_UNWIND
;
1457 /* We want to put it last. */
1458 pm
= &elf_tdata (abfd
)->segment_map
;
1466 /* Turn on PF_IA_64_NORECOV if needed. This involves traversing all of
1467 the input sections for each output section in the segment and testing
1468 for SHF_IA_64_NORECOV on each. */
1469 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1470 if (m
->p_type
== PT_LOAD
)
1473 for (i
= m
->count
- 1; i
>= 0; --i
)
1475 struct bfd_link_order
*order
= m
->sections
[i
]->link_order_head
;
1478 if (order
->type
== bfd_indirect_link_order
)
1480 asection
*is
= order
->u
.indirect
.section
;
1481 bfd_vma flags
= elf_section_data(is
)->this_hdr
.sh_flags
;
1482 if (flags
& SHF_IA_64_NORECOV
)
1484 m
->p_flags
|= PF_IA_64_NORECOV
;
1488 order
= order
->next
;
1497 /* According to the Tahoe assembler spec, all labels starting with a
1501 elfNN_ia64_is_local_label_name (abfd
, name
)
1502 bfd
*abfd ATTRIBUTE_UNUSED
;
1505 return name
[0] == '.';
1508 /* Should we do dynamic things to this symbol? */
1511 elfNN_ia64_dynamic_symbol_p (h
, info
)
1512 struct elf_link_hash_entry
*h
;
1513 struct bfd_link_info
*info
;
1518 while (h
->root
.type
== bfd_link_hash_indirect
1519 || h
->root
.type
== bfd_link_hash_warning
)
1520 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1522 if (h
->dynindx
== -1)
1524 switch (ELF_ST_VISIBILITY (h
->other
))
1533 if (h
->root
.type
== bfd_link_hash_undefweak
1534 || h
->root
.type
== bfd_link_hash_defweak
)
1537 if ((info
->shared
&& (!info
->symbolic
|| info
->allow_shlib_undefined
))
1538 || ((h
->elf_link_hash_flags
1539 & (ELF_LINK_HASH_DEF_DYNAMIC
| ELF_LINK_HASH_REF_REGULAR
))
1540 == (ELF_LINK_HASH_DEF_DYNAMIC
| ELF_LINK_HASH_REF_REGULAR
)))
1547 elfNN_ia64_local_hash_table_init (ht
, abfd
, new)
1548 struct elfNN_ia64_local_hash_table
*ht
;
1549 bfd
*abfd ATTRIBUTE_UNUSED
;
1550 new_hash_entry_func
new;
1552 memset (ht
, 0, sizeof (*ht
));
1553 return bfd_hash_table_init (&ht
->root
, new);
1556 static struct bfd_hash_entry
*
1557 elfNN_ia64_new_loc_hash_entry (entry
, table
, string
)
1558 struct bfd_hash_entry
*entry
;
1559 struct bfd_hash_table
*table
;
1562 struct elfNN_ia64_local_hash_entry
*ret
;
1563 ret
= (struct elfNN_ia64_local_hash_entry
*) entry
;
1565 /* Allocate the structure if it has not already been allocated by a
1568 ret
= bfd_hash_allocate (table
, sizeof (*ret
));
1573 /* Initialize our local data. All zeros, and definitely easier
1574 than setting a handful of bit fields. */
1575 memset (ret
, 0, sizeof (*ret
));
1577 /* Call the allocation method of the superclass. */
1578 ret
= ((struct elfNN_ia64_local_hash_entry
*)
1579 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
1581 return (struct bfd_hash_entry
*) ret
;
1584 static struct bfd_hash_entry
*
1585 elfNN_ia64_new_elf_hash_entry (entry
, table
, string
)
1586 struct bfd_hash_entry
*entry
;
1587 struct bfd_hash_table
*table
;
1590 struct elfNN_ia64_link_hash_entry
*ret
;
1591 ret
= (struct elfNN_ia64_link_hash_entry
*) entry
;
1593 /* Allocate the structure if it has not already been allocated by a
1596 ret
= bfd_hash_allocate (table
, sizeof (*ret
));
1601 /* Initialize our local data. All zeros, and definitely easier
1602 than setting a handful of bit fields. */
1603 memset (ret
, 0, sizeof (*ret
));
1605 /* Call the allocation method of the superclass. */
1606 ret
= ((struct elfNN_ia64_link_hash_entry
*)
1607 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
1610 return (struct bfd_hash_entry
*) ret
;
1614 elfNN_ia64_hash_copy_indirect (bed
, xdir
, xind
)
1615 struct elf_backend_data
*bed ATTRIBUTE_UNUSED
;
1616 struct elf_link_hash_entry
*xdir
, *xind
;
1618 struct elfNN_ia64_link_hash_entry
*dir
, *ind
;
1620 dir
= (struct elfNN_ia64_link_hash_entry
*) xdir
;
1621 ind
= (struct elfNN_ia64_link_hash_entry
*) xind
;
1623 /* Copy down any references that we may have already seen to the
1624 symbol which just became indirect. */
1626 dir
->root
.elf_link_hash_flags
|=
1627 (ind
->root
.elf_link_hash_flags
1628 & (ELF_LINK_HASH_REF_DYNAMIC
1629 | ELF_LINK_HASH_REF_REGULAR
1630 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
));
1632 if (ind
->root
.root
.type
!= bfd_link_hash_indirect
)
1635 /* Copy over the got and plt data. This would have been done
1638 if (dir
->info
== NULL
)
1640 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1642 dir
->info
= dyn_i
= ind
->info
;
1645 /* Fix up the dyn_sym_info pointers to the global symbol. */
1646 for (; dyn_i
; dyn_i
= dyn_i
->next
)
1647 dyn_i
->h
= &dir
->root
;
1649 BFD_ASSERT (ind
->info
== NULL
);
1651 /* Copy over the dynindx. */
1653 if (dir
->root
.dynindx
== -1)
1655 dir
->root
.dynindx
= ind
->root
.dynindx
;
1656 dir
->root
.dynstr_index
= ind
->root
.dynstr_index
;
1657 ind
->root
.dynindx
= -1;
1658 ind
->root
.dynstr_index
= 0;
1660 BFD_ASSERT (ind
->root
.dynindx
== -1);
1664 elfNN_ia64_hash_hide_symbol (info
, xh
, force_local
)
1665 struct bfd_link_info
*info
;
1666 struct elf_link_hash_entry
*xh
;
1667 bfd_boolean force_local
;
1669 struct elfNN_ia64_link_hash_entry
*h
;
1670 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1672 h
= (struct elfNN_ia64_link_hash_entry
*)xh
;
1674 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
1676 for (dyn_i
= h
->info
; dyn_i
; dyn_i
= dyn_i
->next
)
1677 dyn_i
->want_plt2
= 0;
1680 /* Create the derived linker hash table. The IA-64 ELF port uses this
1681 derived hash table to keep information specific to the IA-64 ElF
1682 linker (without using static variables). */
1684 static struct bfd_link_hash_table
*
1685 elfNN_ia64_hash_table_create (abfd
)
1688 struct elfNN_ia64_link_hash_table
*ret
;
1690 ret
= bfd_zalloc (abfd
, (bfd_size_type
) sizeof (*ret
));
1693 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
1694 elfNN_ia64_new_elf_hash_entry
))
1696 bfd_release (abfd
, ret
);
1700 if (!elfNN_ia64_local_hash_table_init (&ret
->loc_hash_table
, abfd
,
1701 elfNN_ia64_new_loc_hash_entry
))
1703 return &ret
->root
.root
;
1706 /* Look up an entry in a Alpha ELF linker hash table. */
1708 static INLINE
struct elfNN_ia64_local_hash_entry
*
1709 elfNN_ia64_local_hash_lookup(table
, string
, create
, copy
)
1710 struct elfNN_ia64_local_hash_table
*table
;
1712 bfd_boolean create
, copy
;
1714 return ((struct elfNN_ia64_local_hash_entry
*)
1715 bfd_hash_lookup (&table
->root
, string
, create
, copy
));
1718 /* Traverse both local and global hash tables. */
1720 struct elfNN_ia64_dyn_sym_traverse_data
1722 bfd_boolean (*func
) PARAMS ((struct elfNN_ia64_dyn_sym_info
*, PTR
));
1727 elfNN_ia64_global_dyn_sym_thunk (xentry
, xdata
)
1728 struct bfd_hash_entry
*xentry
;
1731 struct elfNN_ia64_link_hash_entry
*entry
1732 = (struct elfNN_ia64_link_hash_entry
*) xentry
;
1733 struct elfNN_ia64_dyn_sym_traverse_data
*data
1734 = (struct elfNN_ia64_dyn_sym_traverse_data
*) xdata
;
1735 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1737 if (entry
->root
.root
.type
== bfd_link_hash_warning
)
1738 entry
= (struct elfNN_ia64_link_hash_entry
*) entry
->root
.root
.u
.i
.link
;
1740 for (dyn_i
= entry
->info
; dyn_i
; dyn_i
= dyn_i
->next
)
1741 if (! (*data
->func
) (dyn_i
, data
->data
))
1747 elfNN_ia64_local_dyn_sym_thunk (xentry
, xdata
)
1748 struct bfd_hash_entry
*xentry
;
1751 struct elfNN_ia64_local_hash_entry
*entry
1752 = (struct elfNN_ia64_local_hash_entry
*) xentry
;
1753 struct elfNN_ia64_dyn_sym_traverse_data
*data
1754 = (struct elfNN_ia64_dyn_sym_traverse_data
*) xdata
;
1755 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1757 for (dyn_i
= entry
->info
; dyn_i
; dyn_i
= dyn_i
->next
)
1758 if (! (*data
->func
) (dyn_i
, data
->data
))
1764 elfNN_ia64_dyn_sym_traverse (ia64_info
, func
, data
)
1765 struct elfNN_ia64_link_hash_table
*ia64_info
;
1766 bfd_boolean (*func
) PARAMS ((struct elfNN_ia64_dyn_sym_info
*, PTR
));
1769 struct elfNN_ia64_dyn_sym_traverse_data xdata
;
1774 elf_link_hash_traverse (&ia64_info
->root
,
1775 elfNN_ia64_global_dyn_sym_thunk
, &xdata
);
1776 bfd_hash_traverse (&ia64_info
->loc_hash_table
.root
,
1777 elfNN_ia64_local_dyn_sym_thunk
, &xdata
);
1781 elfNN_ia64_create_dynamic_sections (abfd
, info
)
1783 struct bfd_link_info
*info
;
1785 struct elfNN_ia64_link_hash_table
*ia64_info
;
1788 if (! _bfd_elf_create_dynamic_sections (abfd
, info
))
1791 ia64_info
= elfNN_ia64_hash_table (info
);
1793 ia64_info
->plt_sec
= bfd_get_section_by_name (abfd
, ".plt");
1794 ia64_info
->got_sec
= bfd_get_section_by_name (abfd
, ".got");
1797 flagword flags
= bfd_get_section_flags (abfd
, ia64_info
->got_sec
);
1798 bfd_set_section_flags (abfd
, ia64_info
->got_sec
, SEC_SMALL_DATA
| flags
);
1801 if (!get_pltoff (abfd
, info
, ia64_info
))
1804 s
= bfd_make_section(abfd
, ".rela.IA_64.pltoff");
1806 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
1809 | SEC_LINKER_CREATED
1811 || !bfd_set_section_alignment (abfd
, s
, 3))
1813 ia64_info
->rel_pltoff_sec
= s
;
1815 s
= bfd_make_section(abfd
, ".rela.got");
1817 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
1820 | SEC_LINKER_CREATED
1822 || !bfd_set_section_alignment (abfd
, s
, 3))
1824 ia64_info
->rel_got_sec
= s
;
1829 /* Find and/or create a hash entry for local symbol. */
1830 static struct elfNN_ia64_local_hash_entry
*
1831 get_local_sym_hash (ia64_info
, abfd
, rel
, create
)
1832 struct elfNN_ia64_link_hash_table
*ia64_info
;
1834 const Elf_Internal_Rela
*rel
;
1837 struct elfNN_ia64_local_hash_entry
*ret
;
1838 asection
*sec
= abfd
->sections
;
1839 char addr_name
[34];
1841 BFD_ASSERT ((sizeof (sec
->id
)*2 + 1 + sizeof (unsigned long)*2 + 1) <= 34);
1844 /* Construct a string for use in the elfNN_ia64_local_hash_table.
1845 name describes what was once anonymous memory. */
1847 sprintf (addr_name
, "%x:%lx",
1848 sec
->id
, (unsigned long) ELFNN_R_SYM (rel
->r_info
));
1850 /* Collect the canonical entry data for this address. */
1851 ret
= elfNN_ia64_local_hash_lookup (&ia64_info
->loc_hash_table
,
1852 addr_name
, create
, create
);
1856 /* Find and/or create a descriptor for dynamic symbol info. This will
1857 vary based on global or local symbol, and the addend to the reloc. */
1859 static struct elfNN_ia64_dyn_sym_info
*
1860 get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, create
)
1861 struct elfNN_ia64_link_hash_table
*ia64_info
;
1862 struct elf_link_hash_entry
*h
;
1864 const Elf_Internal_Rela
*rel
;
1867 struct elfNN_ia64_dyn_sym_info
**pp
;
1868 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1869 bfd_vma addend
= rel
? rel
->r_addend
: 0;
1872 pp
= &((struct elfNN_ia64_link_hash_entry
*)h
)->info
;
1875 struct elfNN_ia64_local_hash_entry
*loc_h
;
1877 loc_h
= get_local_sym_hash (ia64_info
, abfd
, rel
, create
);
1883 for (dyn_i
= *pp
; dyn_i
&& dyn_i
->addend
!= addend
; dyn_i
= *pp
)
1886 if (dyn_i
== NULL
&& create
)
1888 dyn_i
= ((struct elfNN_ia64_dyn_sym_info
*)
1889 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *dyn_i
));
1891 dyn_i
->addend
= addend
;
1898 get_got (abfd
, info
, ia64_info
)
1900 struct bfd_link_info
*info
;
1901 struct elfNN_ia64_link_hash_table
*ia64_info
;
1906 got
= ia64_info
->got_sec
;
1911 dynobj
= ia64_info
->root
.dynobj
;
1913 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1914 if (!_bfd_elf_create_got_section (dynobj
, info
))
1917 got
= bfd_get_section_by_name (dynobj
, ".got");
1919 ia64_info
->got_sec
= got
;
1921 flags
= bfd_get_section_flags (abfd
, got
);
1922 bfd_set_section_flags (abfd
, got
, SEC_SMALL_DATA
| flags
);
1928 /* Create function descriptor section (.opd). This section is called .opd
1929 because it contains "official prodecure descriptors". The "official"
1930 refers to the fact that these descriptors are used when taking the address
1931 of a procedure, thus ensuring a unique address for each procedure. */
1934 get_fptr (abfd
, info
, ia64_info
)
1936 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1937 struct elfNN_ia64_link_hash_table
*ia64_info
;
1942 fptr
= ia64_info
->fptr_sec
;
1945 dynobj
= ia64_info
->root
.dynobj
;
1947 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1949 fptr
= bfd_make_section (dynobj
, ".opd");
1951 || !bfd_set_section_flags (dynobj
, fptr
,
1957 | SEC_LINKER_CREATED
))
1958 || !bfd_set_section_alignment (abfd
, fptr
, 4))
1964 ia64_info
->fptr_sec
= fptr
;
1971 get_pltoff (abfd
, info
, ia64_info
)
1973 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1974 struct elfNN_ia64_link_hash_table
*ia64_info
;
1979 pltoff
= ia64_info
->pltoff_sec
;
1982 dynobj
= ia64_info
->root
.dynobj
;
1984 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1986 pltoff
= bfd_make_section (dynobj
, ELF_STRING_ia64_pltoff
);
1988 || !bfd_set_section_flags (dynobj
, pltoff
,
1994 | SEC_LINKER_CREATED
))
1995 || !bfd_set_section_alignment (abfd
, pltoff
, 4))
2001 ia64_info
->pltoff_sec
= pltoff
;
2008 get_reloc_section (abfd
, ia64_info
, sec
, create
)
2010 struct elfNN_ia64_link_hash_table
*ia64_info
;
2014 const char *srel_name
;
2018 srel_name
= (bfd_elf_string_from_elf_section
2019 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
2020 elf_section_data(sec
)->rel_hdr
.sh_name
));
2021 if (srel_name
== NULL
)
2024 BFD_ASSERT ((strncmp (srel_name
, ".rela", 5) == 0
2025 && strcmp (bfd_get_section_name (abfd
, sec
),
2027 || (strncmp (srel_name
, ".rel", 4) == 0
2028 && strcmp (bfd_get_section_name (abfd
, sec
),
2029 srel_name
+4) == 0));
2031 dynobj
= ia64_info
->root
.dynobj
;
2033 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2035 srel
= bfd_get_section_by_name (dynobj
, srel_name
);
2036 if (srel
== NULL
&& create
)
2038 srel
= bfd_make_section (dynobj
, srel_name
);
2040 || !bfd_set_section_flags (dynobj
, srel
,
2045 | SEC_LINKER_CREATED
2047 || !bfd_set_section_alignment (dynobj
, srel
, 3))
2051 if (sec
->flags
& SEC_READONLY
)
2052 ia64_info
->reltext
= 1;
2058 count_dyn_reloc (abfd
, dyn_i
, srel
, type
)
2060 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2064 struct elfNN_ia64_dyn_reloc_entry
*rent
;
2066 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2067 if (rent
->srel
== srel
&& rent
->type
== type
)
2072 rent
= ((struct elfNN_ia64_dyn_reloc_entry
*)
2073 bfd_alloc (abfd
, (bfd_size_type
) sizeof (*rent
)));
2077 rent
->next
= dyn_i
->reloc_entries
;
2081 dyn_i
->reloc_entries
= rent
;
2089 elfNN_ia64_check_relocs (abfd
, info
, sec
, relocs
)
2091 struct bfd_link_info
*info
;
2093 const Elf_Internal_Rela
*relocs
;
2095 struct elfNN_ia64_link_hash_table
*ia64_info
;
2096 const Elf_Internal_Rela
*relend
;
2097 Elf_Internal_Shdr
*symtab_hdr
;
2098 const Elf_Internal_Rela
*rel
;
2099 asection
*got
, *fptr
, *srel
;
2101 if (info
->relocateable
)
2104 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2105 ia64_info
= elfNN_ia64_hash_table (info
);
2107 got
= fptr
= srel
= NULL
;
2109 relend
= relocs
+ sec
->reloc_count
;
2110 for (rel
= relocs
; rel
< relend
; ++rel
)
2119 NEED_LTOFF_FPTR
= 64,
2125 struct elf_link_hash_entry
*h
= NULL
;
2126 unsigned long r_symndx
= ELFNN_R_SYM (rel
->r_info
);
2127 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2129 bfd_boolean maybe_dynamic
;
2130 int dynrel_type
= R_IA64_NONE
;
2132 if (r_symndx
>= symtab_hdr
->sh_info
)
2134 /* We're dealing with a global symbol -- find its hash entry
2135 and mark it as being referenced. */
2136 long indx
= r_symndx
- symtab_hdr
->sh_info
;
2137 h
= elf_sym_hashes (abfd
)[indx
];
2138 while (h
->root
.type
== bfd_link_hash_indirect
2139 || h
->root
.type
== bfd_link_hash_warning
)
2140 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2142 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
2145 /* We can only get preliminary data on whether a symbol is
2146 locally or externally defined, as not all of the input files
2147 have yet been processed. Do something with what we know, as
2148 this may help reduce memory usage and processing time later. */
2149 maybe_dynamic
= FALSE
;
2150 if (h
&& ((info
->shared
2151 && (!info
->symbolic
|| info
->allow_shlib_undefined
))
2152 || ! (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)
2153 || h
->root
.type
== bfd_link_hash_defweak
2154 || elfNN_ia64_aix_vec (abfd
->xvec
)))
2155 maybe_dynamic
= TRUE
;
2158 switch (ELFNN_R_TYPE (rel
->r_info
))
2160 case R_IA64_TPREL64MSB
:
2161 case R_IA64_TPREL64LSB
:
2162 if (info
->shared
|| maybe_dynamic
)
2163 need_entry
= NEED_DYNREL
;
2164 dynrel_type
= R_IA64_TPREL64LSB
;
2166 info
->flags
|= DF_STATIC_TLS
;
2169 case R_IA64_LTOFF_TPREL22
:
2170 need_entry
= NEED_TPREL
;
2172 info
->flags
|= DF_STATIC_TLS
;
2175 case R_IA64_DTPREL64MSB
:
2176 case R_IA64_DTPREL64LSB
:
2177 if (info
->shared
|| maybe_dynamic
)
2178 need_entry
= NEED_DYNREL
;
2179 dynrel_type
= R_IA64_DTPREL64LSB
;
2182 case R_IA64_LTOFF_DTPREL22
:
2183 need_entry
= NEED_DTPREL
;
2186 case R_IA64_DTPMOD64MSB
:
2187 case R_IA64_DTPMOD64LSB
:
2188 if (info
->shared
|| maybe_dynamic
)
2189 need_entry
= NEED_DYNREL
;
2190 dynrel_type
= R_IA64_DTPMOD64LSB
;
2193 case R_IA64_LTOFF_DTPMOD22
:
2194 need_entry
= NEED_DTPMOD
;
2197 case R_IA64_LTOFF_FPTR22
:
2198 case R_IA64_LTOFF_FPTR64I
:
2199 case R_IA64_LTOFF_FPTR32MSB
:
2200 case R_IA64_LTOFF_FPTR32LSB
:
2201 case R_IA64_LTOFF_FPTR64MSB
:
2202 case R_IA64_LTOFF_FPTR64LSB
:
2203 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
2206 case R_IA64_FPTR64I
:
2207 case R_IA64_FPTR32MSB
:
2208 case R_IA64_FPTR32LSB
:
2209 case R_IA64_FPTR64MSB
:
2210 case R_IA64_FPTR64LSB
:
2211 if (info
->shared
|| h
|| elfNN_ia64_aix_vec (abfd
->xvec
))
2212 need_entry
= NEED_FPTR
| NEED_DYNREL
;
2214 need_entry
= NEED_FPTR
;
2215 dynrel_type
= R_IA64_FPTR64LSB
;
2218 case R_IA64_LTOFF22
:
2219 case R_IA64_LTOFF22X
:
2220 case R_IA64_LTOFF64I
:
2221 need_entry
= NEED_GOT
;
2224 case R_IA64_PLTOFF22
:
2225 case R_IA64_PLTOFF64I
:
2226 case R_IA64_PLTOFF64MSB
:
2227 case R_IA64_PLTOFF64LSB
:
2228 need_entry
= NEED_PLTOFF
;
2232 need_entry
|= NEED_MIN_PLT
;
2236 (*info
->callbacks
->warning
)
2237 (info
, _("@pltoff reloc against local symbol"), 0,
2238 abfd
, 0, (bfd_vma
) 0);
2242 case R_IA64_PCREL21B
:
2243 case R_IA64_PCREL60B
:
2244 /* Depending on where this symbol is defined, we may or may not
2245 need a full plt entry. Only skip if we know we'll not need
2246 the entry -- static or symbolic, and the symbol definition
2247 has already been seen. */
2248 if (maybe_dynamic
&& rel
->r_addend
== 0)
2249 need_entry
= NEED_FULL_PLT
;
2255 case R_IA64_DIR32MSB
:
2256 case R_IA64_DIR32LSB
:
2257 case R_IA64_DIR64MSB
:
2258 case R_IA64_DIR64LSB
:
2259 /* Shared objects will always need at least a REL relocation. */
2260 if (info
->shared
|| maybe_dynamic
2261 || (elfNN_ia64_aix_vec (abfd
->xvec
)
2262 && (!h
|| strcmp (h
->root
.root
.string
,
2263 "__GLOB_DATA_PTR") != 0)))
2264 need_entry
= NEED_DYNREL
;
2265 dynrel_type
= R_IA64_DIR64LSB
;
2268 case R_IA64_IPLTMSB
:
2269 case R_IA64_IPLTLSB
:
2270 /* Shared objects will always need at least a REL relocation. */
2271 if (info
->shared
|| maybe_dynamic
)
2272 need_entry
= NEED_DYNREL
;
2273 dynrel_type
= R_IA64_IPLTLSB
;
2276 case R_IA64_PCREL22
:
2277 case R_IA64_PCREL64I
:
2278 case R_IA64_PCREL32MSB
:
2279 case R_IA64_PCREL32LSB
:
2280 case R_IA64_PCREL64MSB
:
2281 case R_IA64_PCREL64LSB
:
2283 need_entry
= NEED_DYNREL
;
2284 dynrel_type
= R_IA64_PCREL64LSB
;
2291 if ((need_entry
& NEED_FPTR
) != 0
2294 (*info
->callbacks
->warning
)
2295 (info
, _("non-zero addend in @fptr reloc"), 0,
2296 abfd
, 0, (bfd_vma
) 0);
2299 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, TRUE
);
2301 /* Record whether or not this is a local symbol. */
2304 /* Create what's needed. */
2305 if (need_entry
& (NEED_GOT
| NEED_TPREL
| NEED_DTPMOD
| NEED_DTPREL
))
2309 got
= get_got (abfd
, info
, ia64_info
);
2313 if (need_entry
& NEED_GOT
)
2314 dyn_i
->want_got
= 1;
2315 if (need_entry
& NEED_TPREL
)
2316 dyn_i
->want_tprel
= 1;
2317 if (need_entry
& NEED_DTPMOD
)
2318 dyn_i
->want_dtpmod
= 1;
2319 if (need_entry
& NEED_DTPREL
)
2320 dyn_i
->want_dtprel
= 1;
2322 if (need_entry
& NEED_FPTR
)
2326 fptr
= get_fptr (abfd
, info
, ia64_info
);
2331 /* FPTRs for shared libraries are allocated by the dynamic
2332 linker. Make sure this local symbol will appear in the
2333 dynamic symbol table. */
2334 if (!h
&& (info
->shared
2335 /* AIX also needs one */
2336 || elfNN_ia64_aix_vec (abfd
->xvec
)))
2338 if (! (_bfd_elfNN_link_record_local_dynamic_symbol
2339 (info
, abfd
, (long) r_symndx
)))
2343 dyn_i
->want_fptr
= 1;
2345 if (need_entry
& NEED_LTOFF_FPTR
)
2346 dyn_i
->want_ltoff_fptr
= 1;
2347 if (need_entry
& (NEED_MIN_PLT
| NEED_FULL_PLT
))
2349 if (!ia64_info
->root
.dynobj
)
2350 ia64_info
->root
.dynobj
= abfd
;
2351 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2352 dyn_i
->want_plt
= 1;
2354 if (need_entry
& NEED_FULL_PLT
)
2355 dyn_i
->want_plt2
= 1;
2356 if (need_entry
& NEED_PLTOFF
)
2357 dyn_i
->want_pltoff
= 1;
2358 if ((need_entry
& NEED_DYNREL
) && (sec
->flags
& SEC_ALLOC
))
2362 srel
= get_reloc_section (abfd
, ia64_info
, sec
, TRUE
);
2366 if (!count_dyn_reloc (abfd
, dyn_i
, srel
, dynrel_type
))
2374 struct elfNN_ia64_allocate_data
2376 struct bfd_link_info
*info
;
2380 /* For cleanliness, and potentially faster dynamic loading, allocate
2381 external GOT entries first. */
2384 allocate_global_data_got (dyn_i
, data
)
2385 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2388 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2391 && ! dyn_i
->want_fptr
2392 && (elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
)
2393 || (elfNN_ia64_aix_vec (x
->info
->hash
->creator
)
2394 && (!dyn_i
->h
|| strcmp (dyn_i
->h
->root
.root
.string
,
2395 "__GLOB_DATA_PTR") != 0))))
2397 dyn_i
->got_offset
= x
->ofs
;
2400 if (dyn_i
->want_tprel
)
2402 dyn_i
->tprel_offset
= x
->ofs
;
2405 if (dyn_i
->want_dtpmod
)
2407 dyn_i
->dtpmod_offset
= x
->ofs
;
2410 if (dyn_i
->want_dtprel
)
2412 dyn_i
->dtprel_offset
= x
->ofs
;
2418 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
2421 allocate_global_fptr_got (dyn_i
, data
)
2422 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2425 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2429 && (elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
)
2430 || elfNN_ia64_aix_vec (x
->info
->hash
->creator
)))
2432 dyn_i
->got_offset
= x
->ofs
;
2438 /* Lastly, allocate all the GOT entries for local data. */
2441 allocate_local_got (dyn_i
, data
)
2442 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2445 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2448 && ! (elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
)
2449 || elfNN_ia64_aix_vec (x
->info
->hash
->creator
)))
2451 dyn_i
->got_offset
= x
->ofs
;
2457 /* Search for the index of a global symbol in it's defining object file. */
2460 global_sym_index (h
)
2461 struct elf_link_hash_entry
*h
;
2463 struct elf_link_hash_entry
**p
;
2466 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
2467 || h
->root
.type
== bfd_link_hash_defweak
);
2469 obj
= h
->root
.u
.def
.section
->owner
;
2470 for (p
= elf_sym_hashes (obj
); *p
!= h
; ++p
)
2473 return p
- elf_sym_hashes (obj
) + elf_tdata (obj
)->symtab_hdr
.sh_info
;
2476 /* Allocate function descriptors. We can do these for every function
2477 in a main executable that is not exported. */
2480 allocate_fptr (dyn_i
, data
)
2481 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2484 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2486 if (dyn_i
->want_fptr
)
2488 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2491 while (h
->root
.type
== bfd_link_hash_indirect
2492 || h
->root
.type
== bfd_link_hash_warning
)
2493 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2496 /* AIX needs an FPTR in this case. */
2497 || (elfNN_ia64_aix_vec (x
->info
->hash
->creator
)
2499 || h
->root
.type
== bfd_link_hash_defined
2500 || h
->root
.type
== bfd_link_hash_defweak
)))
2502 if (h
&& h
->dynindx
== -1)
2504 BFD_ASSERT ((h
->root
.type
== bfd_link_hash_defined
)
2505 || (h
->root
.type
== bfd_link_hash_defweak
));
2507 if (!_bfd_elfNN_link_record_local_dynamic_symbol
2508 (x
->info
, h
->root
.u
.def
.section
->owner
,
2509 global_sym_index (h
)))
2513 dyn_i
->want_fptr
= 0;
2515 else if (h
== NULL
|| h
->dynindx
== -1)
2517 dyn_i
->fptr_offset
= x
->ofs
;
2521 dyn_i
->want_fptr
= 0;
2526 /* Allocate all the minimal PLT entries. */
2529 allocate_plt_entries (dyn_i
, data
)
2530 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2533 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2535 if (dyn_i
->want_plt
)
2537 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2540 while (h
->root
.type
== bfd_link_hash_indirect
2541 || h
->root
.type
== bfd_link_hash_warning
)
2542 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2544 /* ??? Versioned symbols seem to lose ELF_LINK_HASH_NEEDS_PLT. */
2545 if (elfNN_ia64_dynamic_symbol_p (h
, x
->info
))
2547 bfd_size_type offset
= x
->ofs
;
2549 offset
= PLT_HEADER_SIZE
;
2550 dyn_i
->plt_offset
= offset
;
2551 x
->ofs
= offset
+ PLT_MIN_ENTRY_SIZE
;
2553 dyn_i
->want_pltoff
= 1;
2557 dyn_i
->want_plt
= 0;
2558 dyn_i
->want_plt2
= 0;
2564 /* Allocate all the full PLT entries. */
2567 allocate_plt2_entries (dyn_i
, data
)
2568 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2571 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2573 if (dyn_i
->want_plt2
)
2575 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2576 bfd_size_type ofs
= x
->ofs
;
2578 dyn_i
->plt2_offset
= ofs
;
2579 x
->ofs
= ofs
+ PLT_FULL_ENTRY_SIZE
;
2581 while (h
->root
.type
== bfd_link_hash_indirect
2582 || h
->root
.type
== bfd_link_hash_warning
)
2583 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2584 dyn_i
->h
->plt
.offset
= ofs
;
2589 /* Allocate all the PLTOFF entries requested by relocations and
2590 plt entries. We can't share space with allocated FPTR entries,
2591 because the latter are not necessarily addressable by the GP.
2592 ??? Relaxation might be able to determine that they are. */
2595 allocate_pltoff_entries (dyn_i
, data
)
2596 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2599 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2601 if (dyn_i
->want_pltoff
)
2603 dyn_i
->pltoff_offset
= x
->ofs
;
2609 /* Allocate dynamic relocations for those symbols that turned out
2613 allocate_dynrel_entries (dyn_i
, data
)
2614 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2617 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2618 struct elfNN_ia64_link_hash_table
*ia64_info
;
2619 struct elfNN_ia64_dyn_reloc_entry
*rent
;
2620 bfd_boolean dynamic_symbol
, shared
;
2622 ia64_info
= elfNN_ia64_hash_table (x
->info
);
2623 dynamic_symbol
= elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
)
2624 || (elfNN_ia64_aix_vec (x
->info
->hash
->creator
)
2625 /* Don't allocate an entry for __GLOB_DATA_PTR */
2626 && (!dyn_i
->h
|| strcmp (dyn_i
->h
->root
.root
.string
,
2627 "__GLOB_DATA_PTR") != 0));
2628 shared
= x
->info
->shared
;
2630 /* Take care of the normal data relocations. */
2632 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2634 int count
= rent
->count
;
2638 case R_IA64_FPTR64LSB
:
2639 /* Allocate one iff !want_fptr, which by this point will
2640 be true only if we're actually allocating one statically
2641 in the main executable. */
2642 if (dyn_i
->want_fptr
)
2645 case R_IA64_PCREL64LSB
:
2646 if (!dynamic_symbol
)
2649 case R_IA64_DIR64LSB
:
2650 if (!dynamic_symbol
&& !shared
)
2653 case R_IA64_IPLTLSB
:
2654 if (!dynamic_symbol
&& !shared
)
2656 /* Use two REL relocations for IPLT relocations
2657 against local symbols. */
2658 if (!dynamic_symbol
)
2661 case R_IA64_TPREL64LSB
:
2662 case R_IA64_DTPREL64LSB
:
2663 case R_IA64_DTPMOD64LSB
:
2668 rent
->srel
->_raw_size
+= sizeof (ElfNN_External_Rela
) * count
;
2671 /* Take care of the GOT and PLT relocations. */
2673 if (((dynamic_symbol
|| shared
) && dyn_i
->want_got
)
2674 || (dyn_i
->want_ltoff_fptr
&& dyn_i
->h
&& dyn_i
->h
->dynindx
!= -1))
2675 ia64_info
->rel_got_sec
->_raw_size
+= sizeof (ElfNN_External_Rela
);
2676 if ((dynamic_symbol
|| shared
) && dyn_i
->want_tprel
)
2677 ia64_info
->rel_got_sec
->_raw_size
+= sizeof (ElfNN_External_Rela
);
2678 if ((dynamic_symbol
|| shared
) && dyn_i
->want_dtpmod
)
2679 ia64_info
->rel_got_sec
->_raw_size
+= sizeof (ElfNN_External_Rela
);
2680 if (dynamic_symbol
&& dyn_i
->want_dtprel
)
2681 ia64_info
->rel_got_sec
->_raw_size
+= sizeof (ElfNN_External_Rela
);
2683 if (dyn_i
->want_pltoff
)
2685 bfd_size_type t
= 0;
2687 /* Dynamic symbols get one IPLT relocation. Local symbols in
2688 shared libraries get two REL relocations. Local symbols in
2689 main applications get nothing. */
2691 t
= sizeof (ElfNN_External_Rela
);
2693 t
= 2 * sizeof (ElfNN_External_Rela
);
2695 ia64_info
->rel_pltoff_sec
->_raw_size
+= t
;
2702 elfNN_ia64_adjust_dynamic_symbol (info
, h
)
2703 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2704 struct elf_link_hash_entry
*h
;
2706 /* ??? Undefined symbols with PLT entries should be re-defined
2707 to be the PLT entry. */
2709 /* If this is a weak symbol, and there is a real definition, the
2710 processor independent code will have arranged for us to see the
2711 real definition first, and we can just use the same value. */
2712 if (h
->weakdef
!= NULL
)
2714 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
2715 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
2716 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
2717 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
2721 /* If this is a reference to a symbol defined by a dynamic object which
2722 is not a function, we might allocate the symbol in our .dynbss section
2723 and allocate a COPY dynamic relocation.
2725 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2732 elfNN_ia64_size_dynamic_sections (output_bfd
, info
)
2734 struct bfd_link_info
*info
;
2736 struct elfNN_ia64_allocate_data data
;
2737 struct elfNN_ia64_link_hash_table
*ia64_info
;
2740 bfd_boolean relplt
= FALSE
;
2742 dynobj
= elf_hash_table(info
)->dynobj
;
2743 ia64_info
= elfNN_ia64_hash_table (info
);
2744 BFD_ASSERT(dynobj
!= NULL
);
2747 /* Set the contents of the .interp section to the interpreter. */
2748 if (ia64_info
->root
.dynamic_sections_created
2751 sec
= bfd_get_section_by_name (dynobj
, ".interp");
2752 BFD_ASSERT (sec
!= NULL
);
2753 sec
->contents
= (bfd_byte
*) DYNAMIC_INTERPRETER (output_bfd
);
2754 sec
->_raw_size
= strlen (DYNAMIC_INTERPRETER (output_bfd
)) + 1;
2757 /* Allocate the GOT entries. */
2759 if (ia64_info
->got_sec
)
2762 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_data_got
, &data
);
2763 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_fptr_got
, &data
);
2764 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_local_got
, &data
);
2765 ia64_info
->got_sec
->_raw_size
= data
.ofs
;
2768 /* Allocate the FPTR entries. */
2770 if (ia64_info
->fptr_sec
)
2773 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_fptr
, &data
);
2774 ia64_info
->fptr_sec
->_raw_size
= data
.ofs
;
2777 /* Now that we've seen all of the input files, we can decide which
2778 symbols need plt entries. Allocate the minimal PLT entries first.
2779 We do this even though dynamic_sections_created may be FALSE, because
2780 this has the side-effect of clearing want_plt and want_plt2. */
2783 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_plt_entries
, &data
);
2785 ia64_info
->minplt_entries
= 0;
2788 ia64_info
->minplt_entries
2789 = (data
.ofs
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
2792 /* Align the pointer for the plt2 entries. */
2793 data
.ofs
= (data
.ofs
+ 31) & (bfd_vma
) -32;
2795 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_plt2_entries
, &data
);
2798 BFD_ASSERT (ia64_info
->root
.dynamic_sections_created
);
2800 ia64_info
->plt_sec
->_raw_size
= data
.ofs
;
2802 /* If we've got a .plt, we need some extra memory for the dynamic
2803 linker. We stuff these in .got.plt. */
2804 sec
= bfd_get_section_by_name (dynobj
, ".got.plt");
2805 sec
->_raw_size
= 8 * PLT_RESERVED_WORDS
;
2808 /* Allocate the PLTOFF entries. */
2810 if (ia64_info
->pltoff_sec
)
2813 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_pltoff_entries
, &data
);
2814 ia64_info
->pltoff_sec
->_raw_size
= data
.ofs
;
2817 if (ia64_info
->root
.dynamic_sections_created
)
2819 /* Allocate space for the dynamic relocations that turned out to be
2822 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_dynrel_entries
, &data
);
2825 /* We have now determined the sizes of the various dynamic sections.
2826 Allocate memory for them. */
2827 for (sec
= dynobj
->sections
; sec
!= NULL
; sec
= sec
->next
)
2831 if (!(sec
->flags
& SEC_LINKER_CREATED
))
2834 /* If we don't need this section, strip it from the output file.
2835 There were several sections primarily related to dynamic
2836 linking that must be create before the linker maps input
2837 sections to output sections. The linker does that before
2838 bfd_elf_size_dynamic_sections is called, and it is that
2839 function which decides whether anything needs to go into
2842 strip
= (sec
->_raw_size
== 0);
2844 if (sec
== ia64_info
->got_sec
)
2846 else if (sec
== ia64_info
->rel_got_sec
)
2849 ia64_info
->rel_got_sec
= NULL
;
2851 /* We use the reloc_count field as a counter if we need to
2852 copy relocs into the output file. */
2853 sec
->reloc_count
= 0;
2855 else if (sec
== ia64_info
->fptr_sec
)
2858 ia64_info
->fptr_sec
= NULL
;
2860 else if (sec
== ia64_info
->plt_sec
)
2863 ia64_info
->plt_sec
= NULL
;
2865 else if (sec
== ia64_info
->pltoff_sec
)
2868 ia64_info
->pltoff_sec
= NULL
;
2870 else if (sec
== ia64_info
->rel_pltoff_sec
)
2873 ia64_info
->rel_pltoff_sec
= NULL
;
2877 /* We use the reloc_count field as a counter if we need to
2878 copy relocs into the output file. */
2879 sec
->reloc_count
= 0;
2886 /* It's OK to base decisions on the section name, because none
2887 of the dynobj section names depend upon the input files. */
2888 name
= bfd_get_section_name (dynobj
, sec
);
2890 if (strcmp (name
, ".got.plt") == 0)
2892 else if (strncmp (name
, ".rel", 4) == 0)
2896 /* We use the reloc_count field as a counter if we need to
2897 copy relocs into the output file. */
2898 sec
->reloc_count
= 0;
2906 _bfd_strip_section_from_output (info
, sec
);
2909 /* Allocate memory for the section contents. */
2910 sec
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, sec
->_raw_size
);
2911 if (sec
->contents
== NULL
&& sec
->_raw_size
!= 0)
2916 if (elf_hash_table (info
)->dynamic_sections_created
)
2918 /* Add some entries to the .dynamic section. We fill in the values
2919 later (in finish_dynamic_sections) but we must add the entries now
2920 so that we get the correct size for the .dynamic section. */
2924 /* The DT_DEBUG entry is filled in by the dynamic linker and used
2926 #define add_dynamic_entry(TAG, VAL) \
2927 bfd_elfNN_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
2929 if (!add_dynamic_entry (DT_DEBUG
, 0))
2933 if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE
, 0))
2935 if (!add_dynamic_entry (DT_PLTGOT
, 0))
2940 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
2941 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
2942 || !add_dynamic_entry (DT_JMPREL
, 0))
2946 if (!add_dynamic_entry (DT_RELA
, 0)
2947 || !add_dynamic_entry (DT_RELASZ
, 0)
2948 || !add_dynamic_entry (DT_RELAENT
, sizeof (ElfNN_External_Rela
)))
2951 if (ia64_info
->reltext
)
2953 if (!add_dynamic_entry (DT_TEXTREL
, 0))
2955 info
->flags
|= DF_TEXTREL
;
2959 /* ??? Perhaps force __gp local. */
2964 static bfd_reloc_status_type
2965 elfNN_ia64_install_value (abfd
, hit_addr
, v
, r_type
)
2969 unsigned int r_type
;
2971 const struct ia64_operand
*op
;
2972 int bigendian
= 0, shift
= 0;
2973 bfd_vma t0
, t1
, insn
, dword
;
2974 enum ia64_opnd opnd
;
2977 #ifdef BFD_HOST_U_64_BIT
2978 BFD_HOST_U_64_BIT val
= (BFD_HOST_U_64_BIT
) v
;
2983 opnd
= IA64_OPND_NIL
;
2988 return bfd_reloc_ok
;
2990 /* Instruction relocations. */
2993 case R_IA64_TPREL14
:
2994 case R_IA64_DTPREL14
:
2995 opnd
= IA64_OPND_IMM14
;
2998 case R_IA64_PCREL21F
: opnd
= IA64_OPND_TGT25
; break;
2999 case R_IA64_PCREL21M
: opnd
= IA64_OPND_TGT25b
; break;
3000 case R_IA64_PCREL60B
: opnd
= IA64_OPND_TGT64
; break;
3001 case R_IA64_PCREL21B
:
3002 case R_IA64_PCREL21BI
:
3003 opnd
= IA64_OPND_TGT25c
;
3007 case R_IA64_GPREL22
:
3008 case R_IA64_LTOFF22
:
3009 case R_IA64_LTOFF22X
:
3010 case R_IA64_PLTOFF22
:
3011 case R_IA64_PCREL22
:
3012 case R_IA64_LTOFF_FPTR22
:
3013 case R_IA64_TPREL22
:
3014 case R_IA64_DTPREL22
:
3015 case R_IA64_LTOFF_TPREL22
:
3016 case R_IA64_LTOFF_DTPMOD22
:
3017 case R_IA64_LTOFF_DTPREL22
:
3018 opnd
= IA64_OPND_IMM22
;
3022 case R_IA64_GPREL64I
:
3023 case R_IA64_LTOFF64I
:
3024 case R_IA64_PLTOFF64I
:
3025 case R_IA64_PCREL64I
:
3026 case R_IA64_FPTR64I
:
3027 case R_IA64_LTOFF_FPTR64I
:
3028 case R_IA64_TPREL64I
:
3029 case R_IA64_DTPREL64I
:
3030 opnd
= IA64_OPND_IMMU64
;
3033 /* Data relocations. */
3035 case R_IA64_DIR32MSB
:
3036 case R_IA64_GPREL32MSB
:
3037 case R_IA64_FPTR32MSB
:
3038 case R_IA64_PCREL32MSB
:
3039 case R_IA64_LTOFF_FPTR32MSB
:
3040 case R_IA64_SEGREL32MSB
:
3041 case R_IA64_SECREL32MSB
:
3042 case R_IA64_LTV32MSB
:
3043 case R_IA64_DTPREL32MSB
:
3044 size
= 4; bigendian
= 1;
3047 case R_IA64_DIR32LSB
:
3048 case R_IA64_GPREL32LSB
:
3049 case R_IA64_FPTR32LSB
:
3050 case R_IA64_PCREL32LSB
:
3051 case R_IA64_LTOFF_FPTR32LSB
:
3052 case R_IA64_SEGREL32LSB
:
3053 case R_IA64_SECREL32LSB
:
3054 case R_IA64_LTV32LSB
:
3055 case R_IA64_DTPREL32LSB
:
3056 size
= 4; bigendian
= 0;
3059 case R_IA64_DIR64MSB
:
3060 case R_IA64_GPREL64MSB
:
3061 case R_IA64_PLTOFF64MSB
:
3062 case R_IA64_FPTR64MSB
:
3063 case R_IA64_PCREL64MSB
:
3064 case R_IA64_LTOFF_FPTR64MSB
:
3065 case R_IA64_SEGREL64MSB
:
3066 case R_IA64_SECREL64MSB
:
3067 case R_IA64_LTV64MSB
:
3068 case R_IA64_TPREL64MSB
:
3069 case R_IA64_DTPMOD64MSB
:
3070 case R_IA64_DTPREL64MSB
:
3071 size
= 8; bigendian
= 1;
3074 case R_IA64_DIR64LSB
:
3075 case R_IA64_GPREL64LSB
:
3076 case R_IA64_PLTOFF64LSB
:
3077 case R_IA64_FPTR64LSB
:
3078 case R_IA64_PCREL64LSB
:
3079 case R_IA64_LTOFF_FPTR64LSB
:
3080 case R_IA64_SEGREL64LSB
:
3081 case R_IA64_SECREL64LSB
:
3082 case R_IA64_LTV64LSB
:
3083 case R_IA64_TPREL64LSB
:
3084 case R_IA64_DTPMOD64LSB
:
3085 case R_IA64_DTPREL64LSB
:
3086 size
= 8; bigendian
= 0;
3089 /* Unsupported / Dynamic relocations. */
3091 return bfd_reloc_notsupported
;
3096 case IA64_OPND_IMMU64
:
3097 hit_addr
-= (long) hit_addr
& 0x3;
3098 t0
= bfd_get_64 (abfd
, hit_addr
);
3099 t1
= bfd_get_64 (abfd
, hit_addr
+ 8);
3101 /* tmpl/s: bits 0.. 5 in t0
3102 slot 0: bits 5..45 in t0
3103 slot 1: bits 46..63 in t0, bits 0..22 in t1
3104 slot 2: bits 23..63 in t1 */
3106 /* First, clear the bits that form the 64 bit constant. */
3107 t0
&= ~(0x3ffffLL
<< 46);
3109 | (( (0x07fLL
<< 13) | (0x1ffLL
<< 27)
3110 | (0x01fLL
<< 22) | (0x001LL
<< 21)
3111 | (0x001LL
<< 36)) << 23));
3113 t0
|= ((val
>> 22) & 0x03ffffLL
) << 46; /* 18 lsbs of imm41 */
3114 t1
|= ((val
>> 40) & 0x7fffffLL
) << 0; /* 23 msbs of imm41 */
3115 t1
|= ( (((val
>> 0) & 0x07f) << 13) /* imm7b */
3116 | (((val
>> 7) & 0x1ff) << 27) /* imm9d */
3117 | (((val
>> 16) & 0x01f) << 22) /* imm5c */
3118 | (((val
>> 21) & 0x001) << 21) /* ic */
3119 | (((val
>> 63) & 0x001) << 36)) << 23; /* i */
3121 bfd_put_64 (abfd
, t0
, hit_addr
);
3122 bfd_put_64 (abfd
, t1
, hit_addr
+ 8);
3125 case IA64_OPND_TGT64
:
3126 hit_addr
-= (long) hit_addr
& 0x3;
3127 t0
= bfd_get_64 (abfd
, hit_addr
);
3128 t1
= bfd_get_64 (abfd
, hit_addr
+ 8);
3130 /* tmpl/s: bits 0.. 5 in t0
3131 slot 0: bits 5..45 in t0
3132 slot 1: bits 46..63 in t0, bits 0..22 in t1
3133 slot 2: bits 23..63 in t1 */
3135 /* First, clear the bits that form the 64 bit constant. */
3136 t0
&= ~(0x3ffffLL
<< 46);
3138 | ((1LL << 36 | 0xfffffLL
<< 13) << 23));
3141 t0
|= ((val
>> 20) & 0xffffLL
) << 2 << 46; /* 16 lsbs of imm39 */
3142 t1
|= ((val
>> 36) & 0x7fffffLL
) << 0; /* 23 msbs of imm39 */
3143 t1
|= ((((val
>> 0) & 0xfffffLL
) << 13) /* imm20b */
3144 | (((val
>> 59) & 0x1LL
) << 36)) << 23; /* i */
3146 bfd_put_64 (abfd
, t0
, hit_addr
);
3147 bfd_put_64 (abfd
, t1
, hit_addr
+ 8);
3151 switch ((long) hit_addr
& 0x3)
3153 case 0: shift
= 5; break;
3154 case 1: shift
= 14; hit_addr
+= 3; break;
3155 case 2: shift
= 23; hit_addr
+= 6; break;
3156 case 3: return bfd_reloc_notsupported
; /* shouldn't happen... */
3158 dword
= bfd_get_64 (abfd
, hit_addr
);
3159 insn
= (dword
>> shift
) & 0x1ffffffffffLL
;
3161 op
= elf64_ia64_operands
+ opnd
;
3162 err
= (*op
->insert
) (op
, val
, (ia64_insn
*)& insn
);
3164 return bfd_reloc_overflow
;
3166 dword
&= ~(0x1ffffffffffLL
<< shift
);
3167 dword
|= (insn
<< shift
);
3168 bfd_put_64 (abfd
, dword
, hit_addr
);
3172 /* A data relocation. */
3175 bfd_putb32 (val
, hit_addr
);
3177 bfd_putb64 (val
, hit_addr
);
3180 bfd_putl32 (val
, hit_addr
);
3182 bfd_putl64 (val
, hit_addr
);
3186 return bfd_reloc_ok
;
3190 elfNN_ia64_install_dyn_reloc (abfd
, info
, sec
, srel
, offset
, type
,
3193 struct bfd_link_info
*info
;
3201 Elf_Internal_Rela outrel
;
3204 BFD_ASSERT (dynindx
!= -1);
3205 outrel
.r_info
= ELFNN_R_INFO (dynindx
, type
);
3206 outrel
.r_addend
= addend
;
3207 outrel
.r_offset
= _bfd_elf_section_offset (abfd
, info
, sec
, offset
);
3208 if (outrel
.r_offset
>= (bfd_vma
) -2)
3210 /* Run for the hills. We shouldn't be outputting a relocation
3211 for this. So do what everyone else does and output a no-op. */
3212 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
3213 outrel
.r_addend
= 0;
3214 outrel
.r_offset
= 0;
3217 outrel
.r_offset
+= sec
->output_section
->vma
+ sec
->output_offset
;
3219 loc
= srel
->contents
;
3220 loc
+= srel
->reloc_count
++ * sizeof (ElfNN_External_Rela
);
3221 bfd_elfNN_swap_reloca_out (abfd
, &outrel
, loc
);
3222 BFD_ASSERT (sizeof (ElfNN_External_Rela
) * srel
->reloc_count
3223 <= srel
->_cooked_size
);
3226 /* Store an entry for target address TARGET_ADDR in the linkage table
3227 and return the gp-relative address of the linkage table entry. */
3230 set_got_entry (abfd
, info
, dyn_i
, dynindx
, addend
, value
, dyn_r_type
)
3232 struct bfd_link_info
*info
;
3233 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3237 unsigned int dyn_r_type
;
3239 struct elfNN_ia64_link_hash_table
*ia64_info
;
3244 ia64_info
= elfNN_ia64_hash_table (info
);
3245 got_sec
= ia64_info
->got_sec
;
3249 case R_IA64_TPREL64LSB
:
3250 done
= dyn_i
->tprel_done
;
3251 dyn_i
->tprel_done
= TRUE
;
3252 got_offset
= dyn_i
->tprel_offset
;
3254 case R_IA64_DTPMOD64LSB
:
3255 done
= dyn_i
->dtpmod_done
;
3256 dyn_i
->dtpmod_done
= TRUE
;
3257 got_offset
= dyn_i
->dtpmod_offset
;
3259 case R_IA64_DTPREL64LSB
:
3260 done
= dyn_i
->dtprel_done
;
3261 dyn_i
->dtprel_done
= TRUE
;
3262 got_offset
= dyn_i
->dtprel_offset
;
3265 done
= dyn_i
->got_done
;
3266 dyn_i
->got_done
= TRUE
;
3267 got_offset
= dyn_i
->got_offset
;
3271 BFD_ASSERT ((got_offset
& 7) == 0);
3275 /* Store the target address in the linkage table entry. */
3276 bfd_put_64 (abfd
, value
, got_sec
->contents
+ got_offset
);
3278 /* Install a dynamic relocation if needed. */
3279 if ((info
->shared
&& dyn_r_type
!= R_IA64_DTPREL64LSB
)
3280 || elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, info
)
3281 || elfNN_ia64_aix_vec (abfd
->xvec
)
3282 || (dynindx
!= -1 && dyn_r_type
== R_IA64_FPTR64LSB
))
3285 && dyn_r_type
!= R_IA64_TPREL64LSB
3286 && dyn_r_type
!= R_IA64_DTPMOD64LSB
3287 && dyn_r_type
!= R_IA64_DTPREL64LSB
)
3289 dyn_r_type
= R_IA64_REL64LSB
;
3294 if (bfd_big_endian (abfd
))
3298 case R_IA64_REL64LSB
:
3299 dyn_r_type
= R_IA64_REL64MSB
;
3301 case R_IA64_DIR64LSB
:
3302 dyn_r_type
= R_IA64_DIR64MSB
;
3304 case R_IA64_FPTR64LSB
:
3305 dyn_r_type
= R_IA64_FPTR64MSB
;
3307 case R_IA64_TPREL64LSB
:
3308 dyn_r_type
= R_IA64_TPREL64MSB
;
3310 case R_IA64_DTPMOD64LSB
:
3311 dyn_r_type
= R_IA64_DTPMOD64MSB
;
3313 case R_IA64_DTPREL64LSB
:
3314 dyn_r_type
= R_IA64_DTPREL64MSB
;
3322 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, got_sec
,
3323 ia64_info
->rel_got_sec
,
3324 got_offset
, dyn_r_type
,
3329 /* Return the address of the linkage table entry. */
3330 value
= (got_sec
->output_section
->vma
3331 + got_sec
->output_offset
3337 /* Fill in a function descriptor consisting of the function's code
3338 address and its global pointer. Return the descriptor's address. */
3341 set_fptr_entry (abfd
, info
, dyn_i
, value
)
3343 struct bfd_link_info
*info
;
3344 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3347 struct elfNN_ia64_link_hash_table
*ia64_info
;
3350 ia64_info
= elfNN_ia64_hash_table (info
);
3351 fptr_sec
= ia64_info
->fptr_sec
;
3353 if (!dyn_i
->fptr_done
)
3355 dyn_i
->fptr_done
= 1;
3357 /* Fill in the function descriptor. */
3358 bfd_put_64 (abfd
, value
, fptr_sec
->contents
+ dyn_i
->fptr_offset
);
3359 bfd_put_64 (abfd
, _bfd_get_gp_value (abfd
),
3360 fptr_sec
->contents
+ dyn_i
->fptr_offset
+ 8);
3363 /* Return the descriptor's address. */
3364 value
= (fptr_sec
->output_section
->vma
3365 + fptr_sec
->output_offset
3366 + dyn_i
->fptr_offset
);
3371 /* Fill in a PLTOFF entry consisting of the function's code address
3372 and its global pointer. Return the descriptor's address. */
3375 set_pltoff_entry (abfd
, info
, dyn_i
, value
, is_plt
)
3377 struct bfd_link_info
*info
;
3378 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3382 struct elfNN_ia64_link_hash_table
*ia64_info
;
3383 asection
*pltoff_sec
;
3385 ia64_info
= elfNN_ia64_hash_table (info
);
3386 pltoff_sec
= ia64_info
->pltoff_sec
;
3388 /* Don't do anything if this symbol uses a real PLT entry. In
3389 that case, we'll fill this in during finish_dynamic_symbol. */
3390 if ((! dyn_i
->want_plt
|| is_plt
)
3391 && !dyn_i
->pltoff_done
)
3393 bfd_vma gp
= _bfd_get_gp_value (abfd
);
3395 /* Fill in the function descriptor. */
3396 bfd_put_64 (abfd
, value
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
);
3397 bfd_put_64 (abfd
, gp
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
+ 8);
3399 /* Install dynamic relocations if needed. */
3400 if (!is_plt
&& info
->shared
)
3402 unsigned int dyn_r_type
;
3404 if (bfd_big_endian (abfd
))
3405 dyn_r_type
= R_IA64_REL64MSB
;
3407 dyn_r_type
= R_IA64_REL64LSB
;
3409 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
3410 ia64_info
->rel_pltoff_sec
,
3411 dyn_i
->pltoff_offset
,
3412 dyn_r_type
, 0, value
);
3413 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
3414 ia64_info
->rel_pltoff_sec
,
3415 dyn_i
->pltoff_offset
+ 8,
3419 dyn_i
->pltoff_done
= 1;
3422 /* Return the descriptor's address. */
3423 value
= (pltoff_sec
->output_section
->vma
3424 + pltoff_sec
->output_offset
3425 + dyn_i
->pltoff_offset
);
3430 /* Return the base VMA address which should be subtracted from real addresses
3431 when resolving @tprel() relocation.
3432 Main program TLS (whose template starts at PT_TLS p_vaddr)
3433 is assigned offset round(16, PT_TLS p_align). */
3436 elfNN_ia64_tprel_base (info
)
3437 struct bfd_link_info
*info
;
3439 struct elf_link_tls_segment
*tls_segment
3440 = elf_hash_table (info
)->tls_segment
;
3442 BFD_ASSERT (tls_segment
!= NULL
);
3443 return (tls_segment
->start
3444 - align_power ((bfd_vma
) 16, tls_segment
->align
));
3447 /* Return the base VMA address which should be subtracted from real addresses
3448 when resolving @dtprel() relocation.
3449 This is PT_TLS segment p_vaddr. */
3452 elfNN_ia64_dtprel_base (info
)
3453 struct bfd_link_info
*info
;
3455 BFD_ASSERT (elf_hash_table (info
)->tls_segment
!= NULL
);
3456 return elf_hash_table (info
)->tls_segment
->start
;
3459 /* Called through qsort to sort the .IA_64.unwind section during a
3460 non-relocatable link. Set elfNN_ia64_unwind_entry_compare_bfd
3461 to the output bfd so we can do proper endianness frobbing. */
3463 static bfd
*elfNN_ia64_unwind_entry_compare_bfd
;
3466 elfNN_ia64_unwind_entry_compare (a
, b
)
3472 av
= bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd
, a
);
3473 bv
= bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd
, b
);
3475 return (av
< bv
? -1 : av
> bv
? 1 : 0);
3479 elfNN_ia64_final_link (abfd
, info
)
3481 struct bfd_link_info
*info
;
3483 struct elfNN_ia64_link_hash_table
*ia64_info
;
3484 asection
*unwind_output_sec
;
3486 ia64_info
= elfNN_ia64_hash_table (info
);
3488 /* Make sure we've got ourselves a nice fat __gp value. */
3489 if (!info
->relocateable
)
3491 bfd_vma min_vma
= (bfd_vma
) -1, max_vma
= 0;
3492 bfd_vma min_short_vma
= min_vma
, max_short_vma
= 0;
3493 struct elf_link_hash_entry
*gp
;
3497 /* Find the min and max vma of all sections marked short. Also
3498 collect min and max vma of any type, for use in selecting a
3500 for (os
= abfd
->sections
; os
; os
= os
->next
)
3504 if ((os
->flags
& SEC_ALLOC
) == 0)
3508 hi
= os
->vma
+ os
->_raw_size
;
3516 if (os
->flags
& SEC_SMALL_DATA
)
3518 if (min_short_vma
> lo
)
3520 if (max_short_vma
< hi
)
3525 /* See if the user wants to force a value. */
3526 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
3530 && (gp
->root
.type
== bfd_link_hash_defined
3531 || gp
->root
.type
== bfd_link_hash_defweak
))
3533 asection
*gp_sec
= gp
->root
.u
.def
.section
;
3534 gp_val
= (gp
->root
.u
.def
.value
3535 + gp_sec
->output_section
->vma
3536 + gp_sec
->output_offset
);
3540 /* Pick a sensible value. */
3542 asection
*got_sec
= ia64_info
->got_sec
;
3544 /* Start with just the address of the .got. */
3546 gp_val
= got_sec
->output_section
->vma
;
3547 else if (max_short_vma
!= 0)
3548 gp_val
= min_short_vma
;
3552 /* If it is possible to address the entire image, but we
3553 don't with the choice above, adjust. */
3554 if (max_vma
- min_vma
< 0x400000
3555 && max_vma
- gp_val
<= 0x200000
3556 && gp_val
- min_vma
> 0x200000)
3557 gp_val
= min_vma
+ 0x200000;
3558 else if (max_short_vma
!= 0)
3560 /* If we don't cover all the short data, adjust. */
3561 if (max_short_vma
- gp_val
>= 0x200000)
3562 gp_val
= min_short_vma
+ 0x200000;
3564 /* If we're addressing stuff past the end, adjust back. */
3565 if (gp_val
> max_vma
)
3566 gp_val
= max_vma
- 0x200000 + 8;
3570 /* Validate whether all SHF_IA_64_SHORT sections are within
3571 range of the chosen GP. */
3573 if (max_short_vma
!= 0)
3575 if (max_short_vma
- min_short_vma
>= 0x400000)
3577 (*_bfd_error_handler
)
3578 (_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
3579 bfd_get_filename (abfd
),
3580 (unsigned long) (max_short_vma
- min_short_vma
));
3583 else if ((gp_val
> min_short_vma
3584 && gp_val
- min_short_vma
> 0x200000)
3585 || (gp_val
< max_short_vma
3586 && max_short_vma
- gp_val
>= 0x200000))
3588 (*_bfd_error_handler
)
3589 (_("%s: __gp does not cover short data segment"),
3590 bfd_get_filename (abfd
));
3595 _bfd_set_gp_value (abfd
, gp_val
);
3599 gp
->root
.type
= bfd_link_hash_defined
;
3600 gp
->root
.u
.def
.value
= gp_val
;
3601 gp
->root
.u
.def
.section
= bfd_abs_section_ptr
;
3605 /* If we're producing a final executable, we need to sort the contents
3606 of the .IA_64.unwind section. Force this section to be relocated
3607 into memory rather than written immediately to the output file. */
3608 unwind_output_sec
= NULL
;
3609 if (!info
->relocateable
)
3611 asection
*s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_unwind
);
3614 unwind_output_sec
= s
->output_section
;
3615 unwind_output_sec
->contents
3616 = bfd_malloc (unwind_output_sec
->_raw_size
);
3617 if (unwind_output_sec
->contents
== NULL
)
3622 /* Invoke the regular ELF backend linker to do all the work. */
3623 if (!bfd_elfNN_bfd_final_link (abfd
, info
))
3626 if (unwind_output_sec
)
3628 elfNN_ia64_unwind_entry_compare_bfd
= abfd
;
3629 qsort (unwind_output_sec
->contents
,
3630 (size_t) (unwind_output_sec
->_raw_size
/ 24),
3632 elfNN_ia64_unwind_entry_compare
);
3634 if (! bfd_set_section_contents (abfd
, unwind_output_sec
,
3635 unwind_output_sec
->contents
, (bfd_vma
) 0,
3636 unwind_output_sec
->_raw_size
))
3644 elfNN_ia64_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
3645 contents
, relocs
, local_syms
, local_sections
)
3647 struct bfd_link_info
*info
;
3649 asection
*input_section
;
3651 Elf_Internal_Rela
*relocs
;
3652 Elf_Internal_Sym
*local_syms
;
3653 asection
**local_sections
;
3655 struct elfNN_ia64_link_hash_table
*ia64_info
;
3656 Elf_Internal_Shdr
*symtab_hdr
;
3657 Elf_Internal_Rela
*rel
;
3658 Elf_Internal_Rela
*relend
;
3660 bfd_boolean ret_val
= TRUE
; /* for non-fatal errors */
3663 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3664 ia64_info
= elfNN_ia64_hash_table (info
);
3666 /* Infect various flags from the input section to the output section. */
3667 if (info
->relocateable
)
3671 flags
= elf_section_data(input_section
)->this_hdr
.sh_flags
;
3672 flags
&= SHF_IA_64_NORECOV
;
3674 elf_section_data(input_section
->output_section
)
3675 ->this_hdr
.sh_flags
|= flags
;
3679 gp_val
= _bfd_get_gp_value (output_bfd
);
3680 srel
= get_reloc_section (input_bfd
, ia64_info
, input_section
, FALSE
);
3683 relend
= relocs
+ input_section
->reloc_count
;
3684 for (; rel
< relend
; ++rel
)
3686 struct elf_link_hash_entry
*h
;
3687 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3688 bfd_reloc_status_type r
;
3689 reloc_howto_type
*howto
;
3690 unsigned long r_symndx
;
3691 Elf_Internal_Sym
*sym
;
3692 unsigned int r_type
;
3696 bfd_boolean dynamic_symbol_p
;
3697 bfd_boolean undef_weak_ref
;
3699 r_type
= ELFNN_R_TYPE (rel
->r_info
);
3700 if (r_type
> R_IA64_MAX_RELOC_CODE
)
3702 (*_bfd_error_handler
)
3703 (_("%s: unknown relocation type %d"),
3704 bfd_archive_filename (input_bfd
), (int)r_type
);
3705 bfd_set_error (bfd_error_bad_value
);
3710 howto
= lookup_howto (r_type
);
3711 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
3715 undef_weak_ref
= FALSE
;
3717 if (r_symndx
< symtab_hdr
->sh_info
)
3719 /* Reloc against local symbol. */
3720 sym
= local_syms
+ r_symndx
;
3721 sym_sec
= local_sections
[r_symndx
];
3722 value
= _bfd_elf_rela_local_sym (output_bfd
, sym
, sym_sec
, rel
);
3723 if ((sym_sec
->flags
& SEC_MERGE
)
3724 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3725 && (elf_section_data (sym_sec
)->sec_info_type
3726 == ELF_INFO_TYPE_MERGE
))
3728 struct elfNN_ia64_local_hash_entry
*loc_h
;
3730 loc_h
= get_local_sym_hash (ia64_info
, input_bfd
, rel
, FALSE
);
3731 if (loc_h
&& ! loc_h
->sec_merge_done
)
3733 struct elfNN_ia64_dyn_sym_info
*dynent
;
3736 for (dynent
= loc_h
->info
; dynent
; dynent
= dynent
->next
)
3740 _bfd_merged_section_offset (output_bfd
, &msec
,
3741 elf_section_data (msec
)->
3746 dynent
->addend
-= sym
->st_value
;
3747 dynent
->addend
+= msec
->output_section
->vma
3748 + msec
->output_offset
3749 - sym_sec
->output_section
->vma
3750 - sym_sec
->output_offset
;
3752 loc_h
->sec_merge_done
= 1;
3760 /* Reloc against global symbol. */
3761 indx
= r_symndx
- symtab_hdr
->sh_info
;
3762 h
= elf_sym_hashes (input_bfd
)[indx
];
3763 while (h
->root
.type
== bfd_link_hash_indirect
3764 || h
->root
.type
== bfd_link_hash_warning
)
3765 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3768 if (h
->root
.type
== bfd_link_hash_defined
3769 || h
->root
.type
== bfd_link_hash_defweak
)
3771 sym_sec
= h
->root
.u
.def
.section
;
3773 /* Detect the cases that sym_sec->output_section is
3774 expected to be NULL -- all cases in which the symbol
3775 is defined in another shared module. This includes
3776 PLT relocs for which we've created a PLT entry and
3777 other relocs for which we're prepared to create
3778 dynamic relocations. */
3779 /* ??? Just accept it NULL and continue. */
3781 if (sym_sec
->output_section
!= NULL
)
3783 value
= (h
->root
.u
.def
.value
3784 + sym_sec
->output_section
->vma
3785 + sym_sec
->output_offset
);
3788 else if (h
->root
.type
== bfd_link_hash_undefweak
)
3789 undef_weak_ref
= TRUE
;
3790 else if (info
->shared
3791 && (!info
->symbolic
|| info
->allow_shlib_undefined
)
3792 && !info
->no_undefined
3793 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
3797 if (! ((*info
->callbacks
->undefined_symbol
)
3798 (info
, h
->root
.root
.string
, input_bfd
,
3799 input_section
, rel
->r_offset
,
3800 (!info
->shared
|| info
->no_undefined
3801 || ELF_ST_VISIBILITY (h
->other
)))))
3808 hit_addr
= contents
+ rel
->r_offset
;
3809 value
+= rel
->r_addend
;
3810 dynamic_symbol_p
= elfNN_ia64_dynamic_symbol_p (h
, info
);
3821 case R_IA64_DIR32MSB
:
3822 case R_IA64_DIR32LSB
:
3823 case R_IA64_DIR64MSB
:
3824 case R_IA64_DIR64LSB
:
3825 /* Install a dynamic relocation for this reloc. */
3826 if ((dynamic_symbol_p
|| info
->shared
3827 || (elfNN_ia64_aix_vec (info
->hash
->creator
)
3828 /* Don't emit relocs for __GLOB_DATA_PTR on AIX. */
3829 && (!h
|| strcmp (h
->root
.root
.string
,
3830 "__GLOB_DATA_PTR") != 0)))
3832 && (input_section
->flags
& SEC_ALLOC
) != 0)
3834 unsigned int dyn_r_type
;
3838 BFD_ASSERT (srel
!= NULL
);
3840 /* If we don't need dynamic symbol lookup, find a
3841 matching RELATIVE relocation. */
3842 dyn_r_type
= r_type
;
3843 if (dynamic_symbol_p
)
3845 dynindx
= h
->dynindx
;
3846 addend
= rel
->r_addend
;
3853 case R_IA64_DIR32MSB
:
3854 dyn_r_type
= R_IA64_REL32MSB
;
3856 case R_IA64_DIR32LSB
:
3857 dyn_r_type
= R_IA64_REL32LSB
;
3859 case R_IA64_DIR64MSB
:
3860 dyn_r_type
= R_IA64_REL64MSB
;
3862 case R_IA64_DIR64LSB
:
3863 dyn_r_type
= R_IA64_REL64LSB
;
3867 /* We can't represent this without a dynamic symbol.
3868 Adjust the relocation to be against an output
3869 section symbol, which are always present in the
3870 dynamic symbol table. */
3871 /* ??? People shouldn't be doing non-pic code in
3872 shared libraries. Hork. */
3873 (*_bfd_error_handler
)
3874 (_("%s: linking non-pic code in a shared library"),
3875 bfd_archive_filename (input_bfd
));
3883 if (elfNN_ia64_aix_vec (info
->hash
->creator
))
3884 rel
->r_addend
= value
;
3885 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
3886 srel
, rel
->r_offset
, dyn_r_type
,
3891 case R_IA64_LTV32MSB
:
3892 case R_IA64_LTV32LSB
:
3893 case R_IA64_LTV64MSB
:
3894 case R_IA64_LTV64LSB
:
3895 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3898 case R_IA64_GPREL22
:
3899 case R_IA64_GPREL64I
:
3900 case R_IA64_GPREL32MSB
:
3901 case R_IA64_GPREL32LSB
:
3902 case R_IA64_GPREL64MSB
:
3903 case R_IA64_GPREL64LSB
:
3904 if (dynamic_symbol_p
)
3906 (*_bfd_error_handler
)
3907 (_("%s: @gprel relocation against dynamic symbol %s"),
3908 bfd_archive_filename (input_bfd
), h
->root
.root
.string
);
3913 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3916 case R_IA64_LTOFF22
:
3917 case R_IA64_LTOFF22X
:
3918 case R_IA64_LTOFF64I
:
3919 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
3920 value
= set_got_entry (input_bfd
, info
, dyn_i
, (h
? h
->dynindx
: -1),
3921 rel
->r_addend
, value
, R_IA64_DIR64LSB
);
3923 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3926 case R_IA64_PLTOFF22
:
3927 case R_IA64_PLTOFF64I
:
3928 case R_IA64_PLTOFF64MSB
:
3929 case R_IA64_PLTOFF64LSB
:
3930 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
3931 value
= set_pltoff_entry (output_bfd
, info
, dyn_i
, value
, FALSE
);
3933 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3936 case R_IA64_FPTR64I
:
3937 case R_IA64_FPTR32MSB
:
3938 case R_IA64_FPTR32LSB
:
3939 case R_IA64_FPTR64MSB
:
3940 case R_IA64_FPTR64LSB
:
3941 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
3942 if (dyn_i
->want_fptr
)
3944 if (!undef_weak_ref
)
3945 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
3951 /* Otherwise, we expect the dynamic linker to create
3956 if (h
->dynindx
!= -1)
3957 dynindx
= h
->dynindx
;
3959 dynindx
= (_bfd_elf_link_lookup_local_dynindx
3960 (info
, h
->root
.u
.def
.section
->owner
,
3961 global_sym_index (h
)));
3965 dynindx
= (_bfd_elf_link_lookup_local_dynindx
3966 (info
, input_bfd
, (long) r_symndx
));
3969 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
3970 srel
, rel
->r_offset
, r_type
,
3971 dynindx
, rel
->r_addend
);
3975 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3978 case R_IA64_LTOFF_FPTR22
:
3979 case R_IA64_LTOFF_FPTR64I
:
3980 case R_IA64_LTOFF_FPTR32MSB
:
3981 case R_IA64_LTOFF_FPTR32LSB
:
3982 case R_IA64_LTOFF_FPTR64MSB
:
3983 case R_IA64_LTOFF_FPTR64LSB
:
3987 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
3988 if (dyn_i
->want_fptr
)
3990 BFD_ASSERT (h
== NULL
|| h
->dynindx
== -1)
3991 if (!undef_weak_ref
)
3992 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
3997 /* Otherwise, we expect the dynamic linker to create
4001 if (h
->dynindx
!= -1)
4002 dynindx
= h
->dynindx
;
4004 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4005 (info
, h
->root
.u
.def
.section
->owner
,
4006 global_sym_index (h
)));
4009 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4010 (info
, input_bfd
, (long) r_symndx
));
4014 value
= set_got_entry (output_bfd
, info
, dyn_i
, dynindx
,
4015 rel
->r_addend
, value
, R_IA64_FPTR64LSB
);
4017 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4021 case R_IA64_PCREL32MSB
:
4022 case R_IA64_PCREL32LSB
:
4023 case R_IA64_PCREL64MSB
:
4024 case R_IA64_PCREL64LSB
:
4025 /* Install a dynamic relocation for this reloc. */
4026 if ((dynamic_symbol_p
4027 || elfNN_ia64_aix_vec (info
->hash
->creator
))
4030 BFD_ASSERT (srel
!= NULL
);
4032 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4033 srel
, rel
->r_offset
, r_type
,
4034 h
->dynindx
, rel
->r_addend
);
4038 case R_IA64_PCREL21BI
:
4039 case R_IA64_PCREL21F
:
4040 case R_IA64_PCREL21M
:
4041 /* ??? These two are only used for speculation fixup code.
4042 They should never be dynamic. */
4043 if (dynamic_symbol_p
)
4045 (*_bfd_error_handler
)
4046 (_("%s: dynamic relocation against speculation fixup"),
4047 bfd_archive_filename (input_bfd
));
4053 (*_bfd_error_handler
)
4054 (_("%s: speculation fixup against undefined weak symbol"),
4055 bfd_archive_filename (input_bfd
));
4061 case R_IA64_PCREL21B
:
4062 case R_IA64_PCREL60B
:
4063 /* We should have created a PLT entry for any dynamic symbol. */
4066 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, FALSE
);
4068 if (dyn_i
&& dyn_i
->want_plt2
)
4070 /* Should have caught this earlier. */
4071 BFD_ASSERT (rel
->r_addend
== 0);
4073 value
= (ia64_info
->plt_sec
->output_section
->vma
4074 + ia64_info
->plt_sec
->output_offset
4075 + dyn_i
->plt2_offset
);
4079 /* Since there's no PLT entry, Validate that this is
4081 BFD_ASSERT (undef_weak_ref
|| sym_sec
->output_section
!= NULL
);
4083 /* If the symbol is undef_weak, we shouldn't be trying
4084 to call it. There's every chance that we'd wind up
4085 with an out-of-range fixup here. Don't bother setting
4086 any value at all. */
4092 case R_IA64_PCREL22
:
4093 case R_IA64_PCREL64I
:
4095 /* Make pc-relative. */
4096 value
-= (input_section
->output_section
->vma
4097 + input_section
->output_offset
4098 + rel
->r_offset
) & ~ (bfd_vma
) 0x3;
4099 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4102 case R_IA64_SEGREL32MSB
:
4103 case R_IA64_SEGREL32LSB
:
4104 case R_IA64_SEGREL64MSB
:
4105 case R_IA64_SEGREL64LSB
:
4108 /* If the input section was discarded from the output, then
4114 struct elf_segment_map
*m
;
4115 Elf_Internal_Phdr
*p
;
4117 /* Find the segment that contains the output_section. */
4118 for (m
= elf_tdata (output_bfd
)->segment_map
,
4119 p
= elf_tdata (output_bfd
)->phdr
;
4124 for (i
= m
->count
- 1; i
>= 0; i
--)
4125 if (m
->sections
[i
] == sym_sec
->output_section
)
4133 r
= bfd_reloc_notsupported
;
4137 /* The VMA of the segment is the vaddr of the associated
4139 if (value
> p
->p_vaddr
)
4140 value
-= p
->p_vaddr
;
4143 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
,
4149 case R_IA64_SECREL32MSB
:
4150 case R_IA64_SECREL32LSB
:
4151 case R_IA64_SECREL64MSB
:
4152 case R_IA64_SECREL64LSB
:
4153 /* Make output-section relative. */
4154 if (value
> input_section
->output_section
->vma
)
4155 value
-= input_section
->output_section
->vma
;
4158 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4161 case R_IA64_IPLTMSB
:
4162 case R_IA64_IPLTLSB
:
4163 /* Install a dynamic relocation for this reloc. */
4164 if ((dynamic_symbol_p
|| info
->shared
)
4165 && (input_section
->flags
& SEC_ALLOC
) != 0)
4167 BFD_ASSERT (srel
!= NULL
);
4169 /* If we don't need dynamic symbol lookup, install two
4170 RELATIVE relocations. */
4171 if (! dynamic_symbol_p
)
4173 unsigned int dyn_r_type
;
4175 if (r_type
== R_IA64_IPLTMSB
)
4176 dyn_r_type
= R_IA64_REL64MSB
;
4178 dyn_r_type
= R_IA64_REL64LSB
;
4180 elfNN_ia64_install_dyn_reloc (output_bfd
, info
,
4182 srel
, rel
->r_offset
,
4183 dyn_r_type
, 0, value
);
4184 elfNN_ia64_install_dyn_reloc (output_bfd
, info
,
4186 srel
, rel
->r_offset
+ 8,
4187 dyn_r_type
, 0, gp_val
);
4190 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4191 srel
, rel
->r_offset
, r_type
,
4192 h
->dynindx
, rel
->r_addend
);
4195 if (r_type
== R_IA64_IPLTMSB
)
4196 r_type
= R_IA64_DIR64MSB
;
4198 r_type
= R_IA64_DIR64LSB
;
4199 elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4200 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
+ 8, gp_val
,
4204 case R_IA64_TPREL14
:
4205 case R_IA64_TPREL22
:
4206 case R_IA64_TPREL64I
:
4207 value
-= elfNN_ia64_tprel_base (info
);
4208 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4211 case R_IA64_DTPREL14
:
4212 case R_IA64_DTPREL22
:
4213 case R_IA64_DTPREL64I
:
4214 value
-= elfNN_ia64_dtprel_base (info
);
4215 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4218 case R_IA64_LTOFF_TPREL22
:
4219 case R_IA64_LTOFF_DTPMOD22
:
4220 case R_IA64_LTOFF_DTPREL22
:
4227 case R_IA64_LTOFF_TPREL22
:
4228 if (!dynamic_symbol_p
&& !info
->shared
)
4229 value
-= elfNN_ia64_tprel_base (info
);
4230 got_r_type
= R_IA64_TPREL64LSB
;
4232 case R_IA64_LTOFF_DTPMOD22
:
4233 if (!dynamic_symbol_p
&& !info
->shared
)
4235 got_r_type
= R_IA64_DTPMOD64LSB
;
4237 case R_IA64_LTOFF_DTPREL22
:
4238 if (!dynamic_symbol_p
)
4239 value
-= elfNN_ia64_dtprel_base (info
);
4240 got_r_type
= R_IA64_DTPREL64LSB
;
4243 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4244 value
= set_got_entry (input_bfd
, info
, dyn_i
,
4245 (h
? h
->dynindx
: -1), rel
->r_addend
,
4248 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
,
4254 r
= bfd_reloc_notsupported
;
4263 case bfd_reloc_undefined
:
4264 /* This can happen for global table relative relocs if
4265 __gp is undefined. This is a panic situation so we
4266 don't try to continue. */
4267 (*info
->callbacks
->undefined_symbol
)
4268 (info
, "__gp", input_bfd
, input_section
, rel
->r_offset
, 1);
4271 case bfd_reloc_notsupported
:
4276 name
= h
->root
.root
.string
;
4279 name
= bfd_elf_string_from_elf_section (input_bfd
,
4280 symtab_hdr
->sh_link
,
4285 name
= bfd_section_name (input_bfd
, input_section
);
4287 if (!(*info
->callbacks
->warning
) (info
, _("unsupported reloc"),
4289 input_section
, rel
->r_offset
))
4295 case bfd_reloc_dangerous
:
4296 case bfd_reloc_outofrange
:
4297 case bfd_reloc_overflow
:
4303 name
= h
->root
.root
.string
;
4306 name
= bfd_elf_string_from_elf_section (input_bfd
,
4307 symtab_hdr
->sh_link
,
4312 name
= bfd_section_name (input_bfd
, input_section
);
4314 if (!(*info
->callbacks
->reloc_overflow
) (info
, name
,
4331 elfNN_ia64_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
4333 struct bfd_link_info
*info
;
4334 struct elf_link_hash_entry
*h
;
4335 Elf_Internal_Sym
*sym
;
4337 struct elfNN_ia64_link_hash_table
*ia64_info
;
4338 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
4340 ia64_info
= elfNN_ia64_hash_table (info
);
4341 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, FALSE
);
4343 /* Fill in the PLT data, if required. */
4344 if (dyn_i
&& dyn_i
->want_plt
)
4346 Elf_Internal_Rela outrel
;
4349 bfd_vma plt_addr
, pltoff_addr
, gp_val
, index
;
4351 gp_val
= _bfd_get_gp_value (output_bfd
);
4353 /* Initialize the minimal PLT entry. */
4355 index
= (dyn_i
->plt_offset
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
4356 plt_sec
= ia64_info
->plt_sec
;
4357 loc
= plt_sec
->contents
+ dyn_i
->plt_offset
;
4359 memcpy (loc
, plt_min_entry
, PLT_MIN_ENTRY_SIZE
);
4360 elfNN_ia64_install_value (output_bfd
, loc
, index
, R_IA64_IMM22
);
4361 elfNN_ia64_install_value (output_bfd
, loc
+2, -dyn_i
->plt_offset
,
4364 plt_addr
= (plt_sec
->output_section
->vma
4365 + plt_sec
->output_offset
4366 + dyn_i
->plt_offset
);
4367 pltoff_addr
= set_pltoff_entry (output_bfd
, info
, dyn_i
, plt_addr
, TRUE
);
4369 /* Initialize the FULL PLT entry, if needed. */
4370 if (dyn_i
->want_plt2
)
4372 loc
= plt_sec
->contents
+ dyn_i
->plt2_offset
;
4374 memcpy (loc
, plt_full_entry
, PLT_FULL_ENTRY_SIZE
);
4375 elfNN_ia64_install_value (output_bfd
, loc
, pltoff_addr
- gp_val
,
4378 /* Mark the symbol as undefined, rather than as defined in the
4379 plt section. Leave the value alone. */
4380 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
4381 first place. But perhaps elflink.h did some for us. */
4382 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
4383 sym
->st_shndx
= SHN_UNDEF
;
4386 /* Create the dynamic relocation. */
4387 outrel
.r_offset
= pltoff_addr
;
4388 if (bfd_little_endian (output_bfd
))
4389 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_IA64_IPLTLSB
);
4391 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_IA64_IPLTMSB
);
4392 outrel
.r_addend
= 0;
4394 /* This is fun. In the .IA_64.pltoff section, we've got entries
4395 that correspond both to real PLT entries, and those that
4396 happened to resolve to local symbols but need to be created
4397 to satisfy @pltoff relocations. The .rela.IA_64.pltoff
4398 relocations for the real PLT should come at the end of the
4399 section, so that they can be indexed by plt entry at runtime.
4401 We emitted all of the relocations for the non-PLT @pltoff
4402 entries during relocate_section. So we can consider the
4403 existing sec->reloc_count to be the base of the array of
4406 loc
= ia64_info
->rel_pltoff_sec
->contents
;
4407 loc
+= ((ia64_info
->rel_pltoff_sec
->reloc_count
+ index
)
4408 * sizeof (Elf64_External_Rela
));
4409 bfd_elfNN_swap_reloca_out (output_bfd
, &outrel
, loc
);
4412 /* Mark some specially defined symbols as absolute. */
4413 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
4414 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
4415 || strcmp (h
->root
.root
.string
, "_PROCEDURE_LINKAGE_TABLE_") == 0)
4416 sym
->st_shndx
= SHN_ABS
;
4422 elfNN_ia64_finish_dynamic_sections (abfd
, info
)
4424 struct bfd_link_info
*info
;
4426 struct elfNN_ia64_link_hash_table
*ia64_info
;
4429 ia64_info
= elfNN_ia64_hash_table (info
);
4430 dynobj
= ia64_info
->root
.dynobj
;
4432 if (elf_hash_table (info
)->dynamic_sections_created
)
4434 ElfNN_External_Dyn
*dyncon
, *dynconend
;
4435 asection
*sdyn
, *sgotplt
;
4438 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
4439 sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
4440 BFD_ASSERT (sdyn
!= NULL
);
4441 dyncon
= (ElfNN_External_Dyn
*) sdyn
->contents
;
4442 dynconend
= (ElfNN_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
4444 gp_val
= _bfd_get_gp_value (abfd
);
4446 for (; dyncon
< dynconend
; dyncon
++)
4448 Elf_Internal_Dyn dyn
;
4450 bfd_elfNN_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4455 dyn
.d_un
.d_ptr
= gp_val
;
4459 dyn
.d_un
.d_val
= (ia64_info
->minplt_entries
4460 * sizeof (ElfNN_External_Rela
));
4464 /* See the comment above in finish_dynamic_symbol. */
4465 dyn
.d_un
.d_ptr
= (ia64_info
->rel_pltoff_sec
->output_section
->vma
4466 + ia64_info
->rel_pltoff_sec
->output_offset
4467 + (ia64_info
->rel_pltoff_sec
->reloc_count
4468 * sizeof (ElfNN_External_Rela
)));
4471 case DT_IA_64_PLT_RESERVE
:
4472 dyn
.d_un
.d_ptr
= (sgotplt
->output_section
->vma
4473 + sgotplt
->output_offset
);
4477 /* Do not have RELASZ include JMPREL. This makes things
4478 easier on ld.so. This is not what the rest of BFD set up. */
4479 dyn
.d_un
.d_val
-= (ia64_info
->minplt_entries
4480 * sizeof (ElfNN_External_Rela
));
4484 bfd_elfNN_swap_dyn_out (abfd
, &dyn
, dyncon
);
4487 /* Initialize the PLT0 entry */
4488 if (ia64_info
->plt_sec
)
4490 bfd_byte
*loc
= ia64_info
->plt_sec
->contents
;
4493 memcpy (loc
, plt_header
, PLT_HEADER_SIZE
);
4495 pltres
= (sgotplt
->output_section
->vma
4496 + sgotplt
->output_offset
4499 elfNN_ia64_install_value (abfd
, loc
+1, pltres
, R_IA64_GPREL22
);
4506 /* ELF file flag handling: */
4508 /* Function to keep IA-64 specific file flags. */
4510 elfNN_ia64_set_private_flags (abfd
, flags
)
4514 BFD_ASSERT (!elf_flags_init (abfd
)
4515 || elf_elfheader (abfd
)->e_flags
== flags
);
4517 elf_elfheader (abfd
)->e_flags
= flags
;
4518 elf_flags_init (abfd
) = TRUE
;
4522 /* Merge backend specific data from an object file to the output
4523 object file when linking. */
4525 elfNN_ia64_merge_private_bfd_data (ibfd
, obfd
)
4530 bfd_boolean ok
= TRUE
;
4532 /* Don't even pretend to support mixed-format linking. */
4533 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4534 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4537 in_flags
= elf_elfheader (ibfd
)->e_flags
;
4538 out_flags
= elf_elfheader (obfd
)->e_flags
;
4540 if (! elf_flags_init (obfd
))
4542 elf_flags_init (obfd
) = TRUE
;
4543 elf_elfheader (obfd
)->e_flags
= in_flags
;
4545 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
4546 && bfd_get_arch_info (obfd
)->the_default
)
4548 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
4549 bfd_get_mach (ibfd
));
4555 /* Check flag compatibility. */
4556 if (in_flags
== out_flags
)
4559 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
4560 if (!(in_flags
& EF_IA_64_REDUCEDFP
) && (out_flags
& EF_IA_64_REDUCEDFP
))
4561 elf_elfheader (obfd
)->e_flags
&= ~EF_IA_64_REDUCEDFP
;
4563 if ((in_flags
& EF_IA_64_TRAPNIL
) != (out_flags
& EF_IA_64_TRAPNIL
))
4565 (*_bfd_error_handler
)
4566 (_("%s: linking trap-on-NULL-dereference with non-trapping files"),
4567 bfd_archive_filename (ibfd
));
4569 bfd_set_error (bfd_error_bad_value
);
4572 if ((in_flags
& EF_IA_64_BE
) != (out_flags
& EF_IA_64_BE
))
4574 (*_bfd_error_handler
)
4575 (_("%s: linking big-endian files with little-endian files"),
4576 bfd_archive_filename (ibfd
));
4578 bfd_set_error (bfd_error_bad_value
);
4581 if ((in_flags
& EF_IA_64_ABI64
) != (out_flags
& EF_IA_64_ABI64
))
4583 (*_bfd_error_handler
)
4584 (_("%s: linking 64-bit files with 32-bit files"),
4585 bfd_archive_filename (ibfd
));
4587 bfd_set_error (bfd_error_bad_value
);
4590 if ((in_flags
& EF_IA_64_CONS_GP
) != (out_flags
& EF_IA_64_CONS_GP
))
4592 (*_bfd_error_handler
)
4593 (_("%s: linking constant-gp files with non-constant-gp files"),
4594 bfd_archive_filename (ibfd
));
4596 bfd_set_error (bfd_error_bad_value
);
4599 if ((in_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
)
4600 != (out_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
4602 (*_bfd_error_handler
)
4603 (_("%s: linking auto-pic files with non-auto-pic files"),
4604 bfd_archive_filename (ibfd
));
4606 bfd_set_error (bfd_error_bad_value
);
4614 elfNN_ia64_print_private_bfd_data (abfd
, ptr
)
4618 FILE *file
= (FILE *) ptr
;
4619 flagword flags
= elf_elfheader (abfd
)->e_flags
;
4621 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
4623 fprintf (file
, "private flags = %s%s%s%s%s%s%s%s\n",
4624 (flags
& EF_IA_64_TRAPNIL
) ? "TRAPNIL, " : "",
4625 (flags
& EF_IA_64_EXT
) ? "EXT, " : "",
4626 (flags
& EF_IA_64_BE
) ? "BE, " : "LE, ",
4627 (flags
& EF_IA_64_REDUCEDFP
) ? "REDUCEDFP, " : "",
4628 (flags
& EF_IA_64_CONS_GP
) ? "CONS_GP, " : "",
4629 (flags
& EF_IA_64_NOFUNCDESC_CONS_GP
) ? "NOFUNCDESC_CONS_GP, " : "",
4630 (flags
& EF_IA_64_ABSOLUTE
) ? "ABSOLUTE, " : "",
4631 (flags
& EF_IA_64_ABI64
) ? "ABI64" : "ABI32");
4633 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
4637 static enum elf_reloc_type_class
4638 elfNN_ia64_reloc_type_class (rela
)
4639 const Elf_Internal_Rela
*rela
;
4641 switch ((int) ELFNN_R_TYPE (rela
->r_info
))
4643 case R_IA64_REL32MSB
:
4644 case R_IA64_REL32LSB
:
4645 case R_IA64_REL64MSB
:
4646 case R_IA64_REL64LSB
:
4647 return reloc_class_relative
;
4648 case R_IA64_IPLTMSB
:
4649 case R_IA64_IPLTLSB
:
4650 return reloc_class_plt
;
4652 return reloc_class_copy
;
4654 return reloc_class_normal
;
4659 elfNN_ia64_hpux_vec (const bfd_target
*vec
)
4661 extern const bfd_target bfd_elfNN_ia64_hpux_big_vec
;
4662 return (vec
== & bfd_elfNN_ia64_hpux_big_vec
);
4666 elfNN_hpux_post_process_headers (abfd
, info
)
4668 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
4670 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
4672 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_HPUX
;
4673 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 1;
4677 elfNN_hpux_backend_section_from_bfd_section (abfd
, sec
, retval
)
4678 bfd
*abfd ATTRIBUTE_UNUSED
;
4682 if (bfd_is_com_section (sec
))
4684 *retval
= SHN_IA_64_ANSI_COMMON
;
4690 #define TARGET_LITTLE_SYM bfd_elfNN_ia64_little_vec
4691 #define TARGET_LITTLE_NAME "elfNN-ia64-little"
4692 #define TARGET_BIG_SYM bfd_elfNN_ia64_big_vec
4693 #define TARGET_BIG_NAME "elfNN-ia64-big"
4694 #define ELF_ARCH bfd_arch_ia64
4695 #define ELF_MACHINE_CODE EM_IA_64
4696 #define ELF_MACHINE_ALT1 1999 /* EAS2.3 */
4697 #define ELF_MACHINE_ALT2 1998 /* EAS2.2 */
4698 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
4700 #define elf_backend_section_from_shdr \
4701 elfNN_ia64_section_from_shdr
4702 #define elf_backend_section_flags \
4703 elfNN_ia64_section_flags
4704 #define elf_backend_fake_sections \
4705 elfNN_ia64_fake_sections
4706 #define elf_backend_final_write_processing \
4707 elfNN_ia64_final_write_processing
4708 #define elf_backend_add_symbol_hook \
4709 elfNN_ia64_add_symbol_hook
4710 #define elf_backend_additional_program_headers \
4711 elfNN_ia64_additional_program_headers
4712 #define elf_backend_modify_segment_map \
4713 elfNN_ia64_modify_segment_map
4714 #define elf_info_to_howto \
4715 elfNN_ia64_info_to_howto
4717 #define bfd_elfNN_bfd_reloc_type_lookup \
4718 elfNN_ia64_reloc_type_lookup
4719 #define bfd_elfNN_bfd_is_local_label_name \
4720 elfNN_ia64_is_local_label_name
4721 #define bfd_elfNN_bfd_relax_section \
4722 elfNN_ia64_relax_section
4724 /* Stuff for the BFD linker: */
4725 #define bfd_elfNN_bfd_link_hash_table_create \
4726 elfNN_ia64_hash_table_create
4727 #define elf_backend_create_dynamic_sections \
4728 elfNN_ia64_create_dynamic_sections
4729 #define elf_backend_check_relocs \
4730 elfNN_ia64_check_relocs
4731 #define elf_backend_adjust_dynamic_symbol \
4732 elfNN_ia64_adjust_dynamic_symbol
4733 #define elf_backend_size_dynamic_sections \
4734 elfNN_ia64_size_dynamic_sections
4735 #define elf_backend_relocate_section \
4736 elfNN_ia64_relocate_section
4737 #define elf_backend_finish_dynamic_symbol \
4738 elfNN_ia64_finish_dynamic_symbol
4739 #define elf_backend_finish_dynamic_sections \
4740 elfNN_ia64_finish_dynamic_sections
4741 #define bfd_elfNN_bfd_final_link \
4742 elfNN_ia64_final_link
4744 #define bfd_elfNN_bfd_merge_private_bfd_data \
4745 elfNN_ia64_merge_private_bfd_data
4746 #define bfd_elfNN_bfd_set_private_flags \
4747 elfNN_ia64_set_private_flags
4748 #define bfd_elfNN_bfd_print_private_bfd_data \
4749 elfNN_ia64_print_private_bfd_data
4751 #define elf_backend_plt_readonly 1
4752 #define elf_backend_want_plt_sym 0
4753 #define elf_backend_plt_alignment 5
4754 #define elf_backend_got_header_size 0
4755 #define elf_backend_plt_header_size PLT_HEADER_SIZE
4756 #define elf_backend_want_got_plt 1
4757 #define elf_backend_may_use_rel_p 1
4758 #define elf_backend_may_use_rela_p 1
4759 #define elf_backend_default_use_rela_p 1
4760 #define elf_backend_want_dynbss 0
4761 #define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect
4762 #define elf_backend_hide_symbol elfNN_ia64_hash_hide_symbol
4763 #define elf_backend_reloc_type_class elfNN_ia64_reloc_type_class
4764 #define elf_backend_rela_normal 1
4766 #include "elfNN-target.h"
4768 /* AIX-specific vectors. */
4770 #undef TARGET_LITTLE_SYM
4771 #define TARGET_LITTLE_SYM bfd_elfNN_ia64_aix_little_vec
4772 #undef TARGET_LITTLE_NAME
4773 #define TARGET_LITTLE_NAME "elfNN-ia64-aix-little"
4774 #undef TARGET_BIG_SYM
4775 #define TARGET_BIG_SYM bfd_elfNN_ia64_aix_big_vec
4776 #undef TARGET_BIG_NAME
4777 #define TARGET_BIG_NAME "elfNN-ia64-aix-big"
4779 #undef elf_backend_add_symbol_hook
4780 #define elf_backend_add_symbol_hook elfNN_ia64_aix_add_symbol_hook
4782 #undef bfd_elfNN_bfd_link_add_symbols
4783 #define bfd_elfNN_bfd_link_add_symbols elfNN_ia64_aix_link_add_symbols
4785 #define elfNN_bed elfNN_ia64_aix_bed
4787 #include "elfNN-target.h"
4789 /* HPUX-specific vectors. */
4791 #undef TARGET_LITTLE_SYM
4792 #undef TARGET_LITTLE_NAME
4793 #undef TARGET_BIG_SYM
4794 #define TARGET_BIG_SYM bfd_elfNN_ia64_hpux_big_vec
4795 #undef TARGET_BIG_NAME
4796 #define TARGET_BIG_NAME "elfNN-ia64-hpux-big"
4798 /* We need to undo the AIX specific functions. */
4800 #undef elf_backend_add_symbol_hook
4801 #define elf_backend_add_symbol_hook elfNN_ia64_add_symbol_hook
4803 #undef bfd_elfNN_bfd_link_add_symbols
4804 #define bfd_elfNN_bfd_link_add_symbols _bfd_generic_link_add_symbols
4806 /* These are HP-UX specific functions. */
4808 #undef elf_backend_post_process_headers
4809 #define elf_backend_post_process_headers elfNN_hpux_post_process_headers
4811 #undef elf_backend_section_from_bfd_section
4812 #define elf_backend_section_from_bfd_section elfNN_hpux_backend_section_from_bfd_section
4814 #undef elf_backend_want_p_paddr_set_to_zero
4815 #define elf_backend_want_p_paddr_set_to_zero 1
4817 #undef ELF_MAXPAGESIZE
4818 #define ELF_MAXPAGESIZE 0x1000 /* 1K */
4821 #define elfNN_bed elfNN_ia64_hpux_bed
4823 #include "elfNN-target.h"
4825 #undef elf_backend_want_p_paddr_set_to_zero