1 /* IA-64 support for 64-bit ELF
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003 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_gotx
: 1;
106 unsigned want_fptr
: 1;
107 unsigned want_ltoff_fptr
: 1;
108 unsigned want_plt
: 1;
109 unsigned want_plt2
: 1;
110 unsigned want_pltoff
: 1;
111 unsigned want_tprel
: 1;
112 unsigned want_dtpmod
: 1;
113 unsigned want_dtprel
: 1;
116 struct elfNN_ia64_local_hash_entry
118 struct bfd_hash_entry root
;
119 struct elfNN_ia64_dyn_sym_info
*info
;
121 /* TRUE if this hash entry's addends was translated for
122 SHF_MERGE optimization. */
123 unsigned sec_merge_done
: 1;
126 struct elfNN_ia64_local_hash_table
128 struct bfd_hash_table root
;
129 /* No additional fields for now. */
132 struct elfNN_ia64_link_hash_entry
134 struct elf_link_hash_entry root
;
135 struct elfNN_ia64_dyn_sym_info
*info
;
138 struct elfNN_ia64_link_hash_table
140 /* The main hash table. */
141 struct elf_link_hash_table root
;
143 asection
*got_sec
; /* the linkage table section (or NULL) */
144 asection
*rel_got_sec
; /* dynamic relocation section for same */
145 asection
*fptr_sec
; /* function descriptor table (or NULL) */
146 asection
*plt_sec
; /* the primary plt section (or NULL) */
147 asection
*pltoff_sec
; /* private descriptors for plt (or NULL) */
148 asection
*rel_pltoff_sec
; /* dynamic relocation section for same */
150 bfd_size_type minplt_entries
; /* number of minplt entries */
151 unsigned reltext
: 1; /* are there relocs against readonly sections? */
152 unsigned self_dtpmod_done
: 1;/* has self DTPMOD entry been finished? */
153 bfd_vma self_dtpmod_offset
; /* .got offset to self DTPMOD entry */
155 struct elfNN_ia64_local_hash_table loc_hash_table
;
158 struct elfNN_ia64_allocate_data
160 struct bfd_link_info
*info
;
164 #define elfNN_ia64_hash_table(p) \
165 ((struct elfNN_ia64_link_hash_table *) ((p)->hash))
167 static bfd_reloc_status_type elfNN_ia64_reloc
168 PARAMS ((bfd
*abfd
, arelent
*reloc
, asymbol
*sym
, PTR data
,
169 asection
*input_section
, bfd
*output_bfd
, char **error_message
));
170 static reloc_howto_type
* lookup_howto
171 PARAMS ((unsigned int rtype
));
172 static reloc_howto_type
*elfNN_ia64_reloc_type_lookup
173 PARAMS ((bfd
*abfd
, bfd_reloc_code_real_type bfd_code
));
174 static void elfNN_ia64_info_to_howto
175 PARAMS ((bfd
*abfd
, arelent
*bfd_reloc
, Elf_Internal_Rela
*elf_reloc
));
176 static bfd_boolean elfNN_ia64_relax_section
177 PARAMS((bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
,
178 bfd_boolean
*again
));
179 static void elfNN_ia64_relax_ldxmov
180 PARAMS((bfd
*abfd
, bfd_byte
*contents
, bfd_vma off
));
181 static bfd_boolean is_unwind_section_name
182 PARAMS ((bfd
*abfd
, const char *));
183 static bfd_boolean elfNN_ia64_section_from_shdr
184 PARAMS ((bfd
*, Elf_Internal_Shdr
*, const char *));
185 static bfd_boolean elfNN_ia64_section_flags
186 PARAMS ((flagword
*, Elf_Internal_Shdr
*));
187 static bfd_boolean elfNN_ia64_fake_sections
188 PARAMS ((bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*sec
));
189 static void elfNN_ia64_final_write_processing
190 PARAMS ((bfd
*abfd
, bfd_boolean linker
));
191 static bfd_boolean elfNN_ia64_add_symbol_hook
192 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, const Elf_Internal_Sym
*sym
,
193 const char **namep
, flagword
*flagsp
, asection
**secp
,
195 static bfd_boolean elfNN_ia64_aix_vec
196 PARAMS ((const bfd_target
*vec
));
197 static bfd_boolean elfNN_ia64_aix_add_symbol_hook
198 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, const Elf_Internal_Sym
*sym
,
199 const char **namep
, flagword
*flagsp
, asection
**secp
,
201 static bfd_boolean elfNN_ia64_aix_link_add_symbols
202 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
203 static int elfNN_ia64_additional_program_headers
204 PARAMS ((bfd
*abfd
));
205 static bfd_boolean elfNN_ia64_modify_segment_map
207 static bfd_boolean elfNN_ia64_is_local_label_name
208 PARAMS ((bfd
*abfd
, const char *name
));
209 static bfd_boolean elfNN_ia64_dynamic_symbol_p
210 PARAMS ((struct elf_link_hash_entry
*h
, struct bfd_link_info
*info
));
211 static bfd_boolean elfNN_ia64_local_hash_table_init
212 PARAMS ((struct elfNN_ia64_local_hash_table
*ht
, bfd
*abfd
,
213 new_hash_entry_func
new));
214 static struct bfd_hash_entry
*elfNN_ia64_new_loc_hash_entry
215 PARAMS ((struct bfd_hash_entry
*entry
, struct bfd_hash_table
*table
,
216 const char *string
));
217 static struct bfd_hash_entry
*elfNN_ia64_new_elf_hash_entry
218 PARAMS ((struct bfd_hash_entry
*entry
, struct bfd_hash_table
*table
,
219 const char *string
));
220 static void elfNN_ia64_hash_copy_indirect
221 PARAMS ((struct elf_backend_data
*, struct elf_link_hash_entry
*,
222 struct elf_link_hash_entry
*));
223 static void elfNN_ia64_hash_hide_symbol
224 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*, bfd_boolean
));
225 static struct bfd_link_hash_table
*elfNN_ia64_hash_table_create
226 PARAMS ((bfd
*abfd
));
227 static struct elfNN_ia64_local_hash_entry
*elfNN_ia64_local_hash_lookup
228 PARAMS ((struct elfNN_ia64_local_hash_table
*table
, const char *string
,
229 bfd_boolean create
, bfd_boolean copy
));
230 static bfd_boolean elfNN_ia64_global_dyn_sym_thunk
231 PARAMS ((struct bfd_hash_entry
*, PTR
));
232 static bfd_boolean elfNN_ia64_local_dyn_sym_thunk
233 PARAMS ((struct bfd_hash_entry
*, PTR
));
234 static void elfNN_ia64_dyn_sym_traverse
235 PARAMS ((struct elfNN_ia64_link_hash_table
*ia64_info
,
236 bfd_boolean (*func
) (struct elfNN_ia64_dyn_sym_info
*, PTR
),
238 static bfd_boolean elfNN_ia64_create_dynamic_sections
239 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
240 static struct elfNN_ia64_local_hash_entry
* get_local_sym_hash
241 PARAMS ((struct elfNN_ia64_link_hash_table
*ia64_info
,
242 bfd
*abfd
, const Elf_Internal_Rela
*rel
, bfd_boolean create
));
243 static struct elfNN_ia64_dyn_sym_info
* get_dyn_sym_info
244 PARAMS ((struct elfNN_ia64_link_hash_table
*ia64_info
,
245 struct elf_link_hash_entry
*h
,
246 bfd
*abfd
, const Elf_Internal_Rela
*rel
, bfd_boolean create
));
247 static asection
*get_got
248 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
249 struct elfNN_ia64_link_hash_table
*ia64_info
));
250 static asection
*get_fptr
251 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
252 struct elfNN_ia64_link_hash_table
*ia64_info
));
253 static asection
*get_pltoff
254 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
255 struct elfNN_ia64_link_hash_table
*ia64_info
));
256 static asection
*get_reloc_section
257 PARAMS ((bfd
*abfd
, struct elfNN_ia64_link_hash_table
*ia64_info
,
258 asection
*sec
, bfd_boolean create
));
259 static bfd_boolean count_dyn_reloc
260 PARAMS ((bfd
*abfd
, struct elfNN_ia64_dyn_sym_info
*dyn_i
,
261 asection
*srel
, int type
));
262 static bfd_boolean elfNN_ia64_check_relocs
263 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
264 const Elf_Internal_Rela
*relocs
));
265 static bfd_boolean elfNN_ia64_adjust_dynamic_symbol
266 PARAMS ((struct bfd_link_info
*info
, struct elf_link_hash_entry
*h
));
267 static long global_sym_index
268 PARAMS ((struct elf_link_hash_entry
*h
));
269 static bfd_boolean allocate_fptr
270 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
271 static bfd_boolean allocate_global_data_got
272 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
273 static bfd_boolean allocate_global_fptr_got
274 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
275 static bfd_boolean allocate_local_got
276 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
277 static bfd_boolean allocate_pltoff_entries
278 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
279 static bfd_boolean allocate_plt_entries
280 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
281 static bfd_boolean allocate_plt2_entries
282 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
283 static bfd_boolean allocate_dynrel_entries
284 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
285 static bfd_boolean elfNN_ia64_size_dynamic_sections
286 PARAMS ((bfd
*output_bfd
, struct bfd_link_info
*info
));
287 static bfd_reloc_status_type elfNN_ia64_install_value
288 PARAMS ((bfd
*abfd
, bfd_byte
*hit_addr
, bfd_vma val
, unsigned int r_type
));
289 static void elfNN_ia64_install_dyn_reloc
290 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
291 asection
*srel
, bfd_vma offset
, unsigned int type
,
292 long dynindx
, bfd_vma addend
));
293 static bfd_vma set_got_entry
294 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
295 struct elfNN_ia64_dyn_sym_info
*dyn_i
, long dynindx
,
296 bfd_vma addend
, bfd_vma value
, unsigned int dyn_r_type
));
297 static bfd_vma set_fptr_entry
298 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
299 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
301 static bfd_vma set_pltoff_entry
302 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
303 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
304 bfd_vma value
, bfd_boolean
));
305 static bfd_vma elfNN_ia64_tprel_base
306 PARAMS ((struct bfd_link_info
*info
));
307 static bfd_vma elfNN_ia64_dtprel_base
308 PARAMS ((struct bfd_link_info
*info
));
309 static int elfNN_ia64_unwind_entry_compare
310 PARAMS ((const PTR
, const PTR
));
311 static bfd_boolean elfNN_ia64_choose_gp
312 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
313 static bfd_boolean elfNN_ia64_final_link
314 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
315 static bfd_boolean elfNN_ia64_relocate_section
316 PARAMS ((bfd
*output_bfd
, struct bfd_link_info
*info
, bfd
*input_bfd
,
317 asection
*input_section
, bfd_byte
*contents
,
318 Elf_Internal_Rela
*relocs
, Elf_Internal_Sym
*local_syms
,
319 asection
**local_sections
));
320 static bfd_boolean elfNN_ia64_finish_dynamic_symbol
321 PARAMS ((bfd
*output_bfd
, struct bfd_link_info
*info
,
322 struct elf_link_hash_entry
*h
, Elf_Internal_Sym
*sym
));
323 static bfd_boolean elfNN_ia64_finish_dynamic_sections
324 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
325 static bfd_boolean elfNN_ia64_set_private_flags
326 PARAMS ((bfd
*abfd
, flagword flags
));
327 static bfd_boolean elfNN_ia64_merge_private_bfd_data
328 PARAMS ((bfd
*ibfd
, bfd
*obfd
));
329 static bfd_boolean elfNN_ia64_print_private_bfd_data
330 PARAMS ((bfd
*abfd
, PTR ptr
));
331 static enum elf_reloc_type_class elfNN_ia64_reloc_type_class
332 PARAMS ((const Elf_Internal_Rela
*));
333 static bfd_boolean elfNN_ia64_hpux_vec
334 PARAMS ((const bfd_target
*vec
));
335 static void elfNN_hpux_post_process_headers
336 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
337 bfd_boolean elfNN_hpux_backend_section_from_bfd_section
338 PARAMS ((bfd
*abfd
, asection
*sec
, int *retval
));
340 /* ia64-specific relocation. */
342 /* Perform a relocation. Not much to do here as all the hard work is
343 done in elfNN_ia64_final_link_relocate. */
344 static bfd_reloc_status_type
345 elfNN_ia64_reloc (abfd
, reloc
, sym
, data
, input_section
,
346 output_bfd
, error_message
)
347 bfd
*abfd ATTRIBUTE_UNUSED
;
349 asymbol
*sym ATTRIBUTE_UNUSED
;
350 PTR data ATTRIBUTE_UNUSED
;
351 asection
*input_section
;
353 char **error_message
;
357 reloc
->address
+= input_section
->output_offset
;
361 if (input_section
->flags
& SEC_DEBUGGING
)
362 return bfd_reloc_continue
;
364 *error_message
= "Unsupported call to elfNN_ia64_reloc";
365 return bfd_reloc_notsupported
;
368 #define IA64_HOWTO(TYPE, NAME, SIZE, PCREL, IN) \
369 HOWTO (TYPE, 0, SIZE, 0, PCREL, 0, complain_overflow_signed, \
370 elfNN_ia64_reloc, NAME, FALSE, 0, 0, IN)
372 /* This table has to be sorted according to increasing number of the
374 static reloc_howto_type ia64_howto_table
[] =
376 IA64_HOWTO (R_IA64_NONE
, "NONE", 0, FALSE
, TRUE
),
378 IA64_HOWTO (R_IA64_IMM14
, "IMM14", 0, FALSE
, TRUE
),
379 IA64_HOWTO (R_IA64_IMM22
, "IMM22", 0, FALSE
, TRUE
),
380 IA64_HOWTO (R_IA64_IMM64
, "IMM64", 0, FALSE
, TRUE
),
381 IA64_HOWTO (R_IA64_DIR32MSB
, "DIR32MSB", 2, FALSE
, TRUE
),
382 IA64_HOWTO (R_IA64_DIR32LSB
, "DIR32LSB", 2, FALSE
, TRUE
),
383 IA64_HOWTO (R_IA64_DIR64MSB
, "DIR64MSB", 4, FALSE
, TRUE
),
384 IA64_HOWTO (R_IA64_DIR64LSB
, "DIR64LSB", 4, FALSE
, TRUE
),
386 IA64_HOWTO (R_IA64_GPREL22
, "GPREL22", 0, FALSE
, TRUE
),
387 IA64_HOWTO (R_IA64_GPREL64I
, "GPREL64I", 0, FALSE
, TRUE
),
388 IA64_HOWTO (R_IA64_GPREL32MSB
, "GPREL32MSB", 2, FALSE
, TRUE
),
389 IA64_HOWTO (R_IA64_GPREL32LSB
, "GPREL32LSB", 2, FALSE
, TRUE
),
390 IA64_HOWTO (R_IA64_GPREL64MSB
, "GPREL64MSB", 4, FALSE
, TRUE
),
391 IA64_HOWTO (R_IA64_GPREL64LSB
, "GPREL64LSB", 4, FALSE
, TRUE
),
393 IA64_HOWTO (R_IA64_LTOFF22
, "LTOFF22", 0, FALSE
, TRUE
),
394 IA64_HOWTO (R_IA64_LTOFF64I
, "LTOFF64I", 0, FALSE
, TRUE
),
396 IA64_HOWTO (R_IA64_PLTOFF22
, "PLTOFF22", 0, FALSE
, TRUE
),
397 IA64_HOWTO (R_IA64_PLTOFF64I
, "PLTOFF64I", 0, FALSE
, TRUE
),
398 IA64_HOWTO (R_IA64_PLTOFF64MSB
, "PLTOFF64MSB", 4, FALSE
, TRUE
),
399 IA64_HOWTO (R_IA64_PLTOFF64LSB
, "PLTOFF64LSB", 4, FALSE
, TRUE
),
401 IA64_HOWTO (R_IA64_FPTR64I
, "FPTR64I", 0, FALSE
, TRUE
),
402 IA64_HOWTO (R_IA64_FPTR32MSB
, "FPTR32MSB", 2, FALSE
, TRUE
),
403 IA64_HOWTO (R_IA64_FPTR32LSB
, "FPTR32LSB", 2, FALSE
, TRUE
),
404 IA64_HOWTO (R_IA64_FPTR64MSB
, "FPTR64MSB", 4, FALSE
, TRUE
),
405 IA64_HOWTO (R_IA64_FPTR64LSB
, "FPTR64LSB", 4, FALSE
, TRUE
),
407 IA64_HOWTO (R_IA64_PCREL60B
, "PCREL60B", 0, TRUE
, TRUE
),
408 IA64_HOWTO (R_IA64_PCREL21B
, "PCREL21B", 0, TRUE
, TRUE
),
409 IA64_HOWTO (R_IA64_PCREL21M
, "PCREL21M", 0, TRUE
, TRUE
),
410 IA64_HOWTO (R_IA64_PCREL21F
, "PCREL21F", 0, TRUE
, TRUE
),
411 IA64_HOWTO (R_IA64_PCREL32MSB
, "PCREL32MSB", 2, TRUE
, TRUE
),
412 IA64_HOWTO (R_IA64_PCREL32LSB
, "PCREL32LSB", 2, TRUE
, TRUE
),
413 IA64_HOWTO (R_IA64_PCREL64MSB
, "PCREL64MSB", 4, TRUE
, TRUE
),
414 IA64_HOWTO (R_IA64_PCREL64LSB
, "PCREL64LSB", 4, TRUE
, TRUE
),
416 IA64_HOWTO (R_IA64_LTOFF_FPTR22
, "LTOFF_FPTR22", 0, FALSE
, TRUE
),
417 IA64_HOWTO (R_IA64_LTOFF_FPTR64I
, "LTOFF_FPTR64I", 0, FALSE
, TRUE
),
418 IA64_HOWTO (R_IA64_LTOFF_FPTR32MSB
, "LTOFF_FPTR32MSB", 2, FALSE
, TRUE
),
419 IA64_HOWTO (R_IA64_LTOFF_FPTR32LSB
, "LTOFF_FPTR32LSB", 2, FALSE
, TRUE
),
420 IA64_HOWTO (R_IA64_LTOFF_FPTR64MSB
, "LTOFF_FPTR64MSB", 4, FALSE
, TRUE
),
421 IA64_HOWTO (R_IA64_LTOFF_FPTR64LSB
, "LTOFF_FPTR64LSB", 4, FALSE
, TRUE
),
423 IA64_HOWTO (R_IA64_SEGREL32MSB
, "SEGREL32MSB", 2, FALSE
, TRUE
),
424 IA64_HOWTO (R_IA64_SEGREL32LSB
, "SEGREL32LSB", 2, FALSE
, TRUE
),
425 IA64_HOWTO (R_IA64_SEGREL64MSB
, "SEGREL64MSB", 4, FALSE
, TRUE
),
426 IA64_HOWTO (R_IA64_SEGREL64LSB
, "SEGREL64LSB", 4, FALSE
, TRUE
),
428 IA64_HOWTO (R_IA64_SECREL32MSB
, "SECREL32MSB", 2, FALSE
, TRUE
),
429 IA64_HOWTO (R_IA64_SECREL32LSB
, "SECREL32LSB", 2, FALSE
, TRUE
),
430 IA64_HOWTO (R_IA64_SECREL64MSB
, "SECREL64MSB", 4, FALSE
, TRUE
),
431 IA64_HOWTO (R_IA64_SECREL64LSB
, "SECREL64LSB", 4, FALSE
, TRUE
),
433 IA64_HOWTO (R_IA64_REL32MSB
, "REL32MSB", 2, FALSE
, TRUE
),
434 IA64_HOWTO (R_IA64_REL32LSB
, "REL32LSB", 2, FALSE
, TRUE
),
435 IA64_HOWTO (R_IA64_REL64MSB
, "REL64MSB", 4, FALSE
, TRUE
),
436 IA64_HOWTO (R_IA64_REL64LSB
, "REL64LSB", 4, FALSE
, TRUE
),
438 IA64_HOWTO (R_IA64_LTV32MSB
, "LTV32MSB", 2, FALSE
, TRUE
),
439 IA64_HOWTO (R_IA64_LTV32LSB
, "LTV32LSB", 2, FALSE
, TRUE
),
440 IA64_HOWTO (R_IA64_LTV64MSB
, "LTV64MSB", 4, FALSE
, TRUE
),
441 IA64_HOWTO (R_IA64_LTV64LSB
, "LTV64LSB", 4, FALSE
, TRUE
),
443 IA64_HOWTO (R_IA64_PCREL21BI
, "PCREL21BI", 0, TRUE
, TRUE
),
444 IA64_HOWTO (R_IA64_PCREL22
, "PCREL22", 0, TRUE
, TRUE
),
445 IA64_HOWTO (R_IA64_PCREL64I
, "PCREL64I", 0, TRUE
, TRUE
),
447 IA64_HOWTO (R_IA64_IPLTMSB
, "IPLTMSB", 4, FALSE
, TRUE
),
448 IA64_HOWTO (R_IA64_IPLTLSB
, "IPLTLSB", 4, FALSE
, TRUE
),
449 IA64_HOWTO (R_IA64_COPY
, "COPY", 4, FALSE
, TRUE
),
450 IA64_HOWTO (R_IA64_LTOFF22X
, "LTOFF22X", 0, FALSE
, TRUE
),
451 IA64_HOWTO (R_IA64_LDXMOV
, "LDXMOV", 0, FALSE
, TRUE
),
453 IA64_HOWTO (R_IA64_TPREL14
, "TPREL14", 0, FALSE
, FALSE
),
454 IA64_HOWTO (R_IA64_TPREL22
, "TPREL22", 0, FALSE
, FALSE
),
455 IA64_HOWTO (R_IA64_TPREL64I
, "TPREL64I", 0, FALSE
, FALSE
),
456 IA64_HOWTO (R_IA64_TPREL64MSB
, "TPREL64MSB", 8, FALSE
, FALSE
),
457 IA64_HOWTO (R_IA64_TPREL64LSB
, "TPREL64LSB", 8, FALSE
, FALSE
),
458 IA64_HOWTO (R_IA64_LTOFF_TPREL22
, "LTOFF_TPREL22", 0, FALSE
, FALSE
),
460 IA64_HOWTO (R_IA64_DTPMOD64MSB
, "TPREL64MSB", 8, FALSE
, FALSE
),
461 IA64_HOWTO (R_IA64_DTPMOD64LSB
, "TPREL64LSB", 8, FALSE
, FALSE
),
462 IA64_HOWTO (R_IA64_LTOFF_DTPMOD22
, "LTOFF_DTPMOD22", 0, FALSE
, FALSE
),
464 IA64_HOWTO (R_IA64_DTPREL14
, "DTPREL14", 0, FALSE
, FALSE
),
465 IA64_HOWTO (R_IA64_DTPREL22
, "DTPREL22", 0, FALSE
, FALSE
),
466 IA64_HOWTO (R_IA64_DTPREL64I
, "DTPREL64I", 0, FALSE
, FALSE
),
467 IA64_HOWTO (R_IA64_DTPREL32MSB
, "DTPREL32MSB", 4, FALSE
, FALSE
),
468 IA64_HOWTO (R_IA64_DTPREL32LSB
, "DTPREL32LSB", 4, FALSE
, FALSE
),
469 IA64_HOWTO (R_IA64_DTPREL64MSB
, "DTPREL64MSB", 8, FALSE
, FALSE
),
470 IA64_HOWTO (R_IA64_DTPREL64LSB
, "DTPREL64LSB", 8, FALSE
, FALSE
),
471 IA64_HOWTO (R_IA64_LTOFF_DTPREL22
, "LTOFF_DTPREL22", 0, FALSE
, FALSE
),
474 static unsigned char elf_code_to_howto_index
[R_IA64_MAX_RELOC_CODE
+ 1];
476 /* Given a BFD reloc type, return the matching HOWTO structure. */
478 static reloc_howto_type
*
482 static int inited
= 0;
489 memset (elf_code_to_howto_index
, 0xff, sizeof (elf_code_to_howto_index
));
490 for (i
= 0; i
< NELEMS (ia64_howto_table
); ++i
)
491 elf_code_to_howto_index
[ia64_howto_table
[i
].type
] = i
;
494 BFD_ASSERT (rtype
<= R_IA64_MAX_RELOC_CODE
);
495 i
= elf_code_to_howto_index
[rtype
];
496 if (i
>= NELEMS (ia64_howto_table
))
498 return ia64_howto_table
+ i
;
501 static reloc_howto_type
*
502 elfNN_ia64_reloc_type_lookup (abfd
, bfd_code
)
503 bfd
*abfd ATTRIBUTE_UNUSED
;
504 bfd_reloc_code_real_type bfd_code
;
510 case BFD_RELOC_NONE
: rtype
= R_IA64_NONE
; break;
512 case BFD_RELOC_IA64_IMM14
: rtype
= R_IA64_IMM14
; break;
513 case BFD_RELOC_IA64_IMM22
: rtype
= R_IA64_IMM22
; break;
514 case BFD_RELOC_IA64_IMM64
: rtype
= R_IA64_IMM64
; break;
516 case BFD_RELOC_IA64_DIR32MSB
: rtype
= R_IA64_DIR32MSB
; break;
517 case BFD_RELOC_IA64_DIR32LSB
: rtype
= R_IA64_DIR32LSB
; break;
518 case BFD_RELOC_IA64_DIR64MSB
: rtype
= R_IA64_DIR64MSB
; break;
519 case BFD_RELOC_IA64_DIR64LSB
: rtype
= R_IA64_DIR64LSB
; break;
521 case BFD_RELOC_IA64_GPREL22
: rtype
= R_IA64_GPREL22
; break;
522 case BFD_RELOC_IA64_GPREL64I
: rtype
= R_IA64_GPREL64I
; break;
523 case BFD_RELOC_IA64_GPREL32MSB
: rtype
= R_IA64_GPREL32MSB
; break;
524 case BFD_RELOC_IA64_GPREL32LSB
: rtype
= R_IA64_GPREL32LSB
; break;
525 case BFD_RELOC_IA64_GPREL64MSB
: rtype
= R_IA64_GPREL64MSB
; break;
526 case BFD_RELOC_IA64_GPREL64LSB
: rtype
= R_IA64_GPREL64LSB
; break;
528 case BFD_RELOC_IA64_LTOFF22
: rtype
= R_IA64_LTOFF22
; break;
529 case BFD_RELOC_IA64_LTOFF64I
: rtype
= R_IA64_LTOFF64I
; break;
531 case BFD_RELOC_IA64_PLTOFF22
: rtype
= R_IA64_PLTOFF22
; break;
532 case BFD_RELOC_IA64_PLTOFF64I
: rtype
= R_IA64_PLTOFF64I
; break;
533 case BFD_RELOC_IA64_PLTOFF64MSB
: rtype
= R_IA64_PLTOFF64MSB
; break;
534 case BFD_RELOC_IA64_PLTOFF64LSB
: rtype
= R_IA64_PLTOFF64LSB
; break;
535 case BFD_RELOC_IA64_FPTR64I
: rtype
= R_IA64_FPTR64I
; break;
536 case BFD_RELOC_IA64_FPTR32MSB
: rtype
= R_IA64_FPTR32MSB
; break;
537 case BFD_RELOC_IA64_FPTR32LSB
: rtype
= R_IA64_FPTR32LSB
; break;
538 case BFD_RELOC_IA64_FPTR64MSB
: rtype
= R_IA64_FPTR64MSB
; break;
539 case BFD_RELOC_IA64_FPTR64LSB
: rtype
= R_IA64_FPTR64LSB
; break;
541 case BFD_RELOC_IA64_PCREL21B
: rtype
= R_IA64_PCREL21B
; break;
542 case BFD_RELOC_IA64_PCREL21BI
: rtype
= R_IA64_PCREL21BI
; break;
543 case BFD_RELOC_IA64_PCREL21M
: rtype
= R_IA64_PCREL21M
; break;
544 case BFD_RELOC_IA64_PCREL21F
: rtype
= R_IA64_PCREL21F
; break;
545 case BFD_RELOC_IA64_PCREL22
: rtype
= R_IA64_PCREL22
; break;
546 case BFD_RELOC_IA64_PCREL60B
: rtype
= R_IA64_PCREL60B
; break;
547 case BFD_RELOC_IA64_PCREL64I
: rtype
= R_IA64_PCREL64I
; break;
548 case BFD_RELOC_IA64_PCREL32MSB
: rtype
= R_IA64_PCREL32MSB
; break;
549 case BFD_RELOC_IA64_PCREL32LSB
: rtype
= R_IA64_PCREL32LSB
; break;
550 case BFD_RELOC_IA64_PCREL64MSB
: rtype
= R_IA64_PCREL64MSB
; break;
551 case BFD_RELOC_IA64_PCREL64LSB
: rtype
= R_IA64_PCREL64LSB
; break;
553 case BFD_RELOC_IA64_LTOFF_FPTR22
: rtype
= R_IA64_LTOFF_FPTR22
; break;
554 case BFD_RELOC_IA64_LTOFF_FPTR64I
: rtype
= R_IA64_LTOFF_FPTR64I
; break;
555 case BFD_RELOC_IA64_LTOFF_FPTR32MSB
: rtype
= R_IA64_LTOFF_FPTR32MSB
; break;
556 case BFD_RELOC_IA64_LTOFF_FPTR32LSB
: rtype
= R_IA64_LTOFF_FPTR32LSB
; break;
557 case BFD_RELOC_IA64_LTOFF_FPTR64MSB
: rtype
= R_IA64_LTOFF_FPTR64MSB
; break;
558 case BFD_RELOC_IA64_LTOFF_FPTR64LSB
: rtype
= R_IA64_LTOFF_FPTR64LSB
; break;
560 case BFD_RELOC_IA64_SEGREL32MSB
: rtype
= R_IA64_SEGREL32MSB
; break;
561 case BFD_RELOC_IA64_SEGREL32LSB
: rtype
= R_IA64_SEGREL32LSB
; break;
562 case BFD_RELOC_IA64_SEGREL64MSB
: rtype
= R_IA64_SEGREL64MSB
; break;
563 case BFD_RELOC_IA64_SEGREL64LSB
: rtype
= R_IA64_SEGREL64LSB
; break;
565 case BFD_RELOC_IA64_SECREL32MSB
: rtype
= R_IA64_SECREL32MSB
; break;
566 case BFD_RELOC_IA64_SECREL32LSB
: rtype
= R_IA64_SECREL32LSB
; break;
567 case BFD_RELOC_IA64_SECREL64MSB
: rtype
= R_IA64_SECREL64MSB
; break;
568 case BFD_RELOC_IA64_SECREL64LSB
: rtype
= R_IA64_SECREL64LSB
; break;
570 case BFD_RELOC_IA64_REL32MSB
: rtype
= R_IA64_REL32MSB
; break;
571 case BFD_RELOC_IA64_REL32LSB
: rtype
= R_IA64_REL32LSB
; break;
572 case BFD_RELOC_IA64_REL64MSB
: rtype
= R_IA64_REL64MSB
; break;
573 case BFD_RELOC_IA64_REL64LSB
: rtype
= R_IA64_REL64LSB
; break;
575 case BFD_RELOC_IA64_LTV32MSB
: rtype
= R_IA64_LTV32MSB
; break;
576 case BFD_RELOC_IA64_LTV32LSB
: rtype
= R_IA64_LTV32LSB
; break;
577 case BFD_RELOC_IA64_LTV64MSB
: rtype
= R_IA64_LTV64MSB
; break;
578 case BFD_RELOC_IA64_LTV64LSB
: rtype
= R_IA64_LTV64LSB
; break;
580 case BFD_RELOC_IA64_IPLTMSB
: rtype
= R_IA64_IPLTMSB
; break;
581 case BFD_RELOC_IA64_IPLTLSB
: rtype
= R_IA64_IPLTLSB
; break;
582 case BFD_RELOC_IA64_COPY
: rtype
= R_IA64_COPY
; break;
583 case BFD_RELOC_IA64_LTOFF22X
: rtype
= R_IA64_LTOFF22X
; break;
584 case BFD_RELOC_IA64_LDXMOV
: rtype
= R_IA64_LDXMOV
; break;
586 case BFD_RELOC_IA64_TPREL14
: rtype
= R_IA64_TPREL14
; break;
587 case BFD_RELOC_IA64_TPREL22
: rtype
= R_IA64_TPREL22
; break;
588 case BFD_RELOC_IA64_TPREL64I
: rtype
= R_IA64_TPREL64I
; break;
589 case BFD_RELOC_IA64_TPREL64MSB
: rtype
= R_IA64_TPREL64MSB
; break;
590 case BFD_RELOC_IA64_TPREL64LSB
: rtype
= R_IA64_TPREL64LSB
; break;
591 case BFD_RELOC_IA64_LTOFF_TPREL22
: rtype
= R_IA64_LTOFF_TPREL22
; break;
593 case BFD_RELOC_IA64_DTPMOD64MSB
: rtype
= R_IA64_DTPMOD64MSB
; break;
594 case BFD_RELOC_IA64_DTPMOD64LSB
: rtype
= R_IA64_DTPMOD64LSB
; break;
595 case BFD_RELOC_IA64_LTOFF_DTPMOD22
: rtype
= R_IA64_LTOFF_DTPMOD22
; break;
597 case BFD_RELOC_IA64_DTPREL14
: rtype
= R_IA64_DTPREL14
; break;
598 case BFD_RELOC_IA64_DTPREL22
: rtype
= R_IA64_DTPREL22
; break;
599 case BFD_RELOC_IA64_DTPREL64I
: rtype
= R_IA64_DTPREL64I
; break;
600 case BFD_RELOC_IA64_DTPREL32MSB
: rtype
= R_IA64_DTPREL32MSB
; break;
601 case BFD_RELOC_IA64_DTPREL32LSB
: rtype
= R_IA64_DTPREL32LSB
; break;
602 case BFD_RELOC_IA64_DTPREL64MSB
: rtype
= R_IA64_DTPREL64MSB
; break;
603 case BFD_RELOC_IA64_DTPREL64LSB
: rtype
= R_IA64_DTPREL64LSB
; break;
604 case BFD_RELOC_IA64_LTOFF_DTPREL22
: rtype
= R_IA64_LTOFF_DTPREL22
; break;
608 return lookup_howto (rtype
);
611 /* Given a ELF reloc, return the matching HOWTO structure. */
614 elfNN_ia64_info_to_howto (abfd
, bfd_reloc
, elf_reloc
)
615 bfd
*abfd ATTRIBUTE_UNUSED
;
617 Elf_Internal_Rela
*elf_reloc
;
620 = lookup_howto ((unsigned int) ELFNN_R_TYPE (elf_reloc
->r_info
));
623 #define PLT_HEADER_SIZE (3 * 16)
624 #define PLT_MIN_ENTRY_SIZE (1 * 16)
625 #define PLT_FULL_ENTRY_SIZE (2 * 16)
626 #define PLT_RESERVED_WORDS 3
628 static const bfd_byte plt_header
[PLT_HEADER_SIZE
] =
630 0x0b, 0x10, 0x00, 0x1c, 0x00, 0x21, /* [MMI] mov r2=r14;; */
631 0xe0, 0x00, 0x08, 0x00, 0x48, 0x00, /* addl r14=0,r2 */
632 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
633 0x0b, 0x80, 0x20, 0x1c, 0x18, 0x14, /* [MMI] ld8 r16=[r14],8;; */
634 0x10, 0x41, 0x38, 0x30, 0x28, 0x00, /* ld8 r17=[r14],8 */
635 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
636 0x11, 0x08, 0x00, 0x1c, 0x18, 0x10, /* [MIB] ld8 r1=[r14] */
637 0x60, 0x88, 0x04, 0x80, 0x03, 0x00, /* mov b6=r17 */
638 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
641 static const bfd_byte plt_min_entry
[PLT_MIN_ENTRY_SIZE
] =
643 0x11, 0x78, 0x00, 0x00, 0x00, 0x24, /* [MIB] mov r15=0 */
644 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, /* nop.i 0x0 */
645 0x00, 0x00, 0x00, 0x40 /* br.few 0 <PLT0>;; */
648 static const bfd_byte plt_full_entry
[PLT_FULL_ENTRY_SIZE
] =
650 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
651 0x00, 0x41, 0x3c, 0x30, 0x28, 0xc0, /* ld8 r16=[r15],8 */
652 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
653 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
654 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
655 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
658 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
659 #define AIX_DYNAMIC_INTERPRETER "/usr/lib/ia64l64/libc.so.1"
660 #define DYNAMIC_INTERPRETER(abfd) \
661 (elfNN_ia64_aix_vec (abfd->xvec) ? AIX_DYNAMIC_INTERPRETER : ELF_DYNAMIC_INTERPRETER)
663 static const bfd_byte oor_brl
[16] =
665 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
666 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;; */
667 0x00, 0x00, 0x00, 0xc0
670 /* These functions do relaxation for IA-64 ELF. */
673 elfNN_ia64_relax_section (abfd
, sec
, link_info
, again
)
676 struct bfd_link_info
*link_info
;
681 struct one_fixup
*next
;
687 Elf_Internal_Shdr
*symtab_hdr
;
688 Elf_Internal_Rela
*internal_relocs
;
689 Elf_Internal_Rela
*irel
, *irelend
;
691 Elf_Internal_Sym
*isymbuf
= NULL
;
692 struct elfNN_ia64_link_hash_table
*ia64_info
;
693 struct one_fixup
*fixups
= NULL
;
694 bfd_boolean changed_contents
= FALSE
;
695 bfd_boolean changed_relocs
= FALSE
;
696 bfd_boolean changed_got
= FALSE
;
699 /* Assume we're not going to change any sizes, and we'll only need
703 /* Don't even try to relax for non-ELF outputs. */
704 if (link_info
->hash
->creator
->flavour
!= bfd_target_elf_flavour
)
707 /* Nothing to do if there are no relocations or there is no need for
708 the relax finalize pass. */
709 if ((sec
->flags
& SEC_RELOC
) == 0
710 || sec
->reloc_count
== 0
711 || (link_info
->relax_finalizing
712 && sec
->need_finalize_relax
== 0))
715 /* If this is the first time we have been called for this section,
716 initialize the cooked size. */
717 if (sec
->_cooked_size
== 0)
718 sec
->_cooked_size
= sec
->_raw_size
;
720 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
722 /* Load the relocations for this section. */
723 internal_relocs
= (_bfd_elfNN_link_read_relocs
724 (abfd
, sec
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
725 link_info
->keep_memory
));
726 if (internal_relocs
== NULL
)
729 ia64_info
= elfNN_ia64_hash_table (link_info
);
730 irelend
= internal_relocs
+ sec
->reloc_count
;
732 /* Get the section contents. */
733 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
734 contents
= elf_section_data (sec
)->this_hdr
.contents
;
737 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
738 if (contents
== NULL
)
741 if (! bfd_get_section_contents (abfd
, sec
, contents
,
742 (file_ptr
) 0, sec
->_raw_size
))
746 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
748 unsigned long r_type
= ELFNN_R_TYPE (irel
->r_info
);
749 bfd_vma symaddr
, reladdr
, trampoff
, toff
, roff
;
753 bfd_boolean is_branch
;
754 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
758 case R_IA64_PCREL21B
:
759 case R_IA64_PCREL21BI
:
760 case R_IA64_PCREL21M
:
761 case R_IA64_PCREL21F
:
762 if (link_info
->relax_finalizing
)
767 case R_IA64_LTOFF22X
:
769 if (!link_info
->relax_finalizing
)
771 sec
->need_finalize_relax
= 1;
781 /* Get the value of the symbol referred to by the reloc. */
782 if (ELFNN_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
784 /* A local symbol. */
785 Elf_Internal_Sym
*isym
;
787 /* Read this BFD's local symbols. */
790 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
792 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
793 symtab_hdr
->sh_info
, 0,
799 isym
= isymbuf
+ ELF64_R_SYM (irel
->r_info
);
800 if (isym
->st_shndx
== SHN_UNDEF
)
801 continue; /* We can't do anthing with undefined symbols. */
802 else if (isym
->st_shndx
== SHN_ABS
)
803 tsec
= bfd_abs_section_ptr
;
804 else if (isym
->st_shndx
== SHN_COMMON
)
805 tsec
= bfd_com_section_ptr
;
806 else if (isym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
807 tsec
= bfd_com_section_ptr
;
809 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
811 toff
= isym
->st_value
;
812 dyn_i
= get_dyn_sym_info (ia64_info
, NULL
, abfd
, irel
, FALSE
);
817 struct elf_link_hash_entry
*h
;
819 indx
= ELFNN_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
820 h
= elf_sym_hashes (abfd
)[indx
];
821 BFD_ASSERT (h
!= NULL
);
823 while (h
->root
.type
== bfd_link_hash_indirect
824 || h
->root
.type
== bfd_link_hash_warning
)
825 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
827 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, irel
, FALSE
);
829 /* For branches to dynamic symbols, we're interested instead
830 in a branch to the PLT entry. */
831 if (is_branch
&& dyn_i
&& dyn_i
->want_plt2
)
833 /* Internal branches shouldn't be sent to the PLT.
834 Leave this for now and we'll give an error later. */
835 if (r_type
!= R_IA64_PCREL21B
)
838 tsec
= ia64_info
->plt_sec
;
839 toff
= dyn_i
->plt2_offset
;
840 BFD_ASSERT (irel
->r_addend
== 0);
843 /* Can't do anything else with dynamic symbols. */
844 else if (elfNN_ia64_dynamic_symbol_p (h
, link_info
))
849 /* We can't do anthing with undefined symbols. */
850 if (h
->root
.type
== bfd_link_hash_undefined
851 || h
->root
.type
== bfd_link_hash_undefweak
)
854 tsec
= h
->root
.u
.def
.section
;
855 toff
= h
->root
.u
.def
.value
;
859 if (tsec
->sec_info_type
== ELF_INFO_TYPE_MERGE
)
860 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
861 elf_section_data (tsec
)->sec_info
,
862 toff
+ irel
->r_addend
,
865 toff
+= irel
->r_addend
;
867 symaddr
= tsec
->output_section
->vma
+ tsec
->output_offset
+ toff
;
869 roff
= irel
->r_offset
;
873 reladdr
= (sec
->output_section
->vma
875 + roff
) & (bfd_vma
) -4;
877 /* If the branch is in range, no need to do anything. */
878 if ((bfd_signed_vma
) (symaddr
- reladdr
) >= -0x1000000
879 && (bfd_signed_vma
) (symaddr
- reladdr
) <= 0x0FFFFF0)
882 /* If the branch and target are in the same section, you've
883 got one honking big section and we can't help you. You'll
884 get an error message later. */
888 /* Look for an existing fixup to this address. */
889 for (f
= fixups
; f
; f
= f
->next
)
890 if (f
->tsec
== tsec
&& f
->toff
== toff
)
895 /* Two alternatives: If it's a branch to a PLT entry, we can
896 make a copy of the FULL_PLT entry. Otherwise, we'll have
897 to use a `brl' insn to get where we're going. */
901 if (tsec
== ia64_info
->plt_sec
)
902 size
= sizeof (plt_full_entry
);
905 size
= sizeof (oor_brl
);
908 /* Resize the current section to make room for the new branch. */
909 trampoff
= (sec
->_cooked_size
+ 15) & (bfd_vma
) -16;
910 amt
= trampoff
+ size
;
911 contents
= (bfd_byte
*) bfd_realloc (contents
, amt
);
912 if (contents
== NULL
)
914 sec
->_cooked_size
= amt
;
916 if (tsec
== ia64_info
->plt_sec
)
918 memcpy (contents
+ trampoff
, plt_full_entry
, size
);
920 /* Hijack the old relocation for use as the PLTOFF reloc. */
921 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
923 irel
->r_offset
= trampoff
;
927 memcpy (contents
+ trampoff
, oor_brl
, size
);
928 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
930 irel
->r_offset
= trampoff
+ 2;
933 /* Record the fixup so we don't do it again this section. */
934 f
= (struct one_fixup
*)
935 bfd_malloc ((bfd_size_type
) sizeof (*f
));
939 f
->trampoff
= trampoff
;
944 /* Nop out the reloc, since we're finalizing things here. */
945 irel
->r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
948 /* Fix up the existing branch to hit the trampoline. Hope like
949 hell this doesn't overflow too. */
950 if (elfNN_ia64_install_value (abfd
, contents
+ roff
,
951 f
->trampoff
- (roff
& (bfd_vma
) -4),
952 r_type
) != bfd_reloc_ok
)
955 changed_contents
= TRUE
;
956 changed_relocs
= TRUE
;
963 bfd
*obfd
= sec
->output_section
->owner
;
964 gp
= _bfd_get_gp_value (obfd
);
967 if (!elfNN_ia64_choose_gp (obfd
, link_info
))
969 gp
= _bfd_get_gp_value (obfd
);
973 /* If the data is out of range, do nothing. */
974 if ((bfd_signed_vma
) (symaddr
- gp
) >= 0x200000
975 ||(bfd_signed_vma
) (symaddr
- gp
) < -0x200000)
978 if (r_type
== R_IA64_LTOFF22X
)
980 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
982 changed_relocs
= TRUE
;
983 if (dyn_i
->want_gotx
)
985 dyn_i
->want_gotx
= 0;
986 changed_got
|= !dyn_i
->want_got
;
991 elfNN_ia64_relax_ldxmov (abfd
, contents
, roff
);
992 irel
->r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
993 changed_contents
= TRUE
;
994 changed_relocs
= TRUE
;
999 /* ??? If we created fixups, this may push the code segment large
1000 enough that the data segment moves, which will change the GP.
1001 Reset the GP so that we re-calculate next round. We need to
1002 do this at the _beginning_ of the next round; now will not do. */
1004 /* Clean up and go home. */
1007 struct one_fixup
*f
= fixups
;
1008 fixups
= fixups
->next
;
1013 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1015 if (! link_info
->keep_memory
)
1019 /* Cache the symbols for elf_link_input_bfd. */
1020 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1024 if (contents
!= NULL
1025 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
1027 if (!changed_contents
&& !link_info
->keep_memory
)
1031 /* Cache the section contents for elf_link_input_bfd. */
1032 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1036 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
1038 if (!changed_relocs
)
1039 free (internal_relocs
);
1041 elf_section_data (sec
)->relocs
= internal_relocs
;
1046 struct elfNN_ia64_allocate_data data
;
1047 data
.info
= link_info
;
1049 ia64_info
->self_dtpmod_offset
= (bfd_vma
) -1;
1051 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_data_got
, &data
);
1052 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_fptr_got
, &data
);
1053 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_local_got
, &data
);
1054 ia64_info
->got_sec
->_raw_size
= data
.ofs
;
1055 ia64_info
->got_sec
->_cooked_size
= data
.ofs
;
1057 /* ??? Resize .rela.got too. */
1060 if (link_info
->relax_finalizing
)
1061 sec
->need_finalize_relax
= 0;
1063 *again
= changed_contents
|| changed_relocs
;
1067 if (isymbuf
!= NULL
&& (unsigned char *) isymbuf
!= symtab_hdr
->contents
)
1069 if (contents
!= NULL
1070 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
1072 if (internal_relocs
!= NULL
1073 && elf_section_data (sec
)->relocs
!= internal_relocs
)
1074 free (internal_relocs
);
1079 elfNN_ia64_relax_ldxmov (abfd
, contents
, off
)
1085 bfd_vma dword
, insn
;
1087 switch ((int)off
& 0x3)
1089 case 0: shift
= 5; break;
1090 case 1: shift
= 14; off
+= 3; break;
1091 case 2: shift
= 23; off
+= 6; break;
1096 dword
= bfd_get_64 (abfd
, contents
+ off
);
1097 insn
= (dword
>> shift
) & 0x1ffffffffffLL
;
1099 r1
= (insn
>> 6) & 127;
1100 r3
= (insn
>> 20) & 127;
1102 insn
= 0x8000000; /* nop */
1104 insn
= (insn
& 0x7f01fff) | 0x10800000000LL
; /* (qp) mov r1 = r3 */
1106 dword
&= ~(0x1ffffffffffLL
<< shift
);
1107 dword
|= (insn
<< shift
);
1108 bfd_put_64 (abfd
, dword
, contents
+ off
);
1111 /* Return TRUE if NAME is an unwind table section name. */
1113 static inline bfd_boolean
1114 is_unwind_section_name (abfd
, name
)
1118 size_t len1
, len2
, len3
;
1120 if (elfNN_ia64_hpux_vec (abfd
->xvec
)
1121 && !strcmp (name
, ELF_STRING_ia64_unwind_hdr
))
1124 len1
= sizeof (ELF_STRING_ia64_unwind
) - 1;
1125 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
1126 len3
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
1127 return ((strncmp (name
, ELF_STRING_ia64_unwind
, len1
) == 0
1128 && strncmp (name
, ELF_STRING_ia64_unwind_info
, len2
) != 0)
1129 || strncmp (name
, ELF_STRING_ia64_unwind_once
, len3
) == 0);
1132 /* Handle an IA-64 specific section when reading an object file. This
1133 is called when elfcode.h finds a section with an unknown type. */
1136 elfNN_ia64_section_from_shdr (abfd
, hdr
, name
)
1138 Elf_Internal_Shdr
*hdr
;
1143 /* There ought to be a place to keep ELF backend specific flags, but
1144 at the moment there isn't one. We just keep track of the
1145 sections by their name, instead. Fortunately, the ABI gives
1146 suggested names for all the MIPS specific sections, so we will
1147 probably get away with this. */
1148 switch (hdr
->sh_type
)
1150 case SHT_IA_64_UNWIND
:
1151 case SHT_IA_64_HP_OPT_ANOT
:
1155 if (strcmp (name
, ELF_STRING_ia64_archext
) != 0)
1163 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1165 newsect
= hdr
->bfd_section
;
1170 /* Convert IA-64 specific section flags to bfd internal section flags. */
1172 /* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
1176 elfNN_ia64_section_flags (flags
, hdr
)
1178 Elf_Internal_Shdr
*hdr
;
1180 if (hdr
->sh_flags
& SHF_IA_64_SHORT
)
1181 *flags
|= SEC_SMALL_DATA
;
1186 /* Set the correct type for an IA-64 ELF section. We do this by the
1187 section name, which is a hack, but ought to work. */
1190 elfNN_ia64_fake_sections (abfd
, hdr
, sec
)
1191 bfd
*abfd ATTRIBUTE_UNUSED
;
1192 Elf_Internal_Shdr
*hdr
;
1195 register const char *name
;
1197 name
= bfd_get_section_name (abfd
, sec
);
1199 if (is_unwind_section_name (abfd
, name
))
1201 /* We don't have the sections numbered at this point, so sh_info
1202 is set later, in elfNN_ia64_final_write_processing. */
1203 hdr
->sh_type
= SHT_IA_64_UNWIND
;
1204 hdr
->sh_flags
|= SHF_LINK_ORDER
;
1206 else if (strcmp (name
, ELF_STRING_ia64_archext
) == 0)
1207 hdr
->sh_type
= SHT_IA_64_EXT
;
1208 else if (strcmp (name
, ".HP.opt_annot") == 0)
1209 hdr
->sh_type
= SHT_IA_64_HP_OPT_ANOT
;
1210 else if (strcmp (name
, ".reloc") == 0)
1211 /* This is an ugly, but unfortunately necessary hack that is
1212 needed when producing EFI binaries on IA-64. It tells
1213 elf.c:elf_fake_sections() not to consider ".reloc" as a section
1214 containing ELF relocation info. We need this hack in order to
1215 be able to generate ELF binaries that can be translated into
1216 EFI applications (which are essentially COFF objects). Those
1217 files contain a COFF ".reloc" section inside an ELFNN object,
1218 which would normally cause BFD to segfault because it would
1219 attempt to interpret this section as containing relocation
1220 entries for section "oc". With this hack enabled, ".reloc"
1221 will be treated as a normal data section, which will avoid the
1222 segfault. However, you won't be able to create an ELFNN binary
1223 with a section named "oc" that needs relocations, but that's
1224 the kind of ugly side-effects you get when detecting section
1225 types based on their names... In practice, this limitation is
1226 unlikely to bite. */
1227 hdr
->sh_type
= SHT_PROGBITS
;
1229 if (sec
->flags
& SEC_SMALL_DATA
)
1230 hdr
->sh_flags
|= SHF_IA_64_SHORT
;
1235 /* The final processing done just before writing out an IA-64 ELF
1239 elfNN_ia64_final_write_processing (abfd
, linker
)
1241 bfd_boolean linker ATTRIBUTE_UNUSED
;
1243 Elf_Internal_Shdr
*hdr
;
1245 asection
*text_sect
, *s
;
1248 for (s
= abfd
->sections
; s
; s
= s
->next
)
1250 hdr
= &elf_section_data (s
)->this_hdr
;
1251 switch (hdr
->sh_type
)
1253 case SHT_IA_64_UNWIND
:
1254 /* See comments in gas/config/tc-ia64.c:dot_endp on why we
1256 sname
= bfd_get_section_name (abfd
, s
);
1257 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
1258 if (sname
&& strncmp (sname
, ELF_STRING_ia64_unwind
, len
) == 0)
1262 if (sname
[0] == '\0')
1263 /* .IA_64.unwind -> .text */
1264 text_sect
= bfd_get_section_by_name (abfd
, ".text");
1266 /* .IA_64.unwindFOO -> FOO */
1267 text_sect
= bfd_get_section_by_name (abfd
, sname
);
1270 && (len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1,
1271 strncmp (sname
, ELF_STRING_ia64_unwind_once
, len
)) == 0)
1273 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.t.FOO */
1274 size_t len2
= sizeof (".gnu.linkonce.t.") - 1;
1275 char *once_name
= bfd_malloc (len2
+ strlen (sname
+ len
) + 1);
1277 if (once_name
!= NULL
)
1279 memcpy (once_name
, ".gnu.linkonce.t.", len2
);
1280 strcpy (once_name
+ len2
, sname
+ len
);
1281 text_sect
= bfd_get_section_by_name (abfd
, once_name
);
1285 /* Should only happen if we run out of memory, in
1286 which case we're probably toast anyway. Try to
1287 cope by finding the section the slow way. */
1288 for (text_sect
= abfd
->sections
;
1290 text_sect
= text_sect
->next
)
1292 if (strncmp (bfd_section_name (abfd
, text_sect
),
1293 ".gnu.linkonce.t.", len2
) == 0
1294 && strcmp (bfd_section_name (abfd
, text_sect
) + len2
,
1300 /* last resort: fall back on .text */
1301 text_sect
= bfd_get_section_by_name (abfd
, ".text");
1305 /* The IA-64 processor-specific ABI requires setting
1306 sh_link to the unwind section, whereas HP-UX requires
1307 sh_info to do so. For maximum compatibility, we'll
1308 set both for now... */
1309 hdr
->sh_link
= elf_section_data (text_sect
)->this_idx
;
1310 hdr
->sh_info
= elf_section_data (text_sect
)->this_idx
;
1316 if (! elf_flags_init (abfd
))
1318 unsigned long flags
= 0;
1320 if (abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
)
1321 flags
|= EF_IA_64_BE
;
1322 if (bfd_get_mach (abfd
) == bfd_mach_ia64_elf64
)
1323 flags
|= EF_IA_64_ABI64
;
1325 elf_elfheader(abfd
)->e_flags
= flags
;
1326 elf_flags_init (abfd
) = TRUE
;
1330 /* Hook called by the linker routine which adds symbols from an object
1331 file. We use it to put .comm items in .sbss, and not .bss. */
1334 elfNN_ia64_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
1336 struct bfd_link_info
*info
;
1337 const Elf_Internal_Sym
*sym
;
1338 const char **namep ATTRIBUTE_UNUSED
;
1339 flagword
*flagsp ATTRIBUTE_UNUSED
;
1343 if (sym
->st_shndx
== SHN_COMMON
1344 && !info
->relocateable
1345 && sym
->st_size
<= elf_gp_size (abfd
))
1347 /* Common symbols less than or equal to -G nn bytes are
1348 automatically put into .sbss. */
1350 asection
*scomm
= bfd_get_section_by_name (abfd
, ".scommon");
1354 scomm
= bfd_make_section (abfd
, ".scommon");
1356 || !bfd_set_section_flags (abfd
, scomm
, (SEC_ALLOC
1358 | SEC_LINKER_CREATED
)))
1363 *valp
= sym
->st_size
;
1370 elfNN_ia64_aix_vec (const bfd_target
*vec
)
1372 extern const bfd_target bfd_elfNN_ia64_aix_little_vec
;
1373 extern const bfd_target bfd_elfNN_ia64_aix_big_vec
;
1375 return (/**/vec
== & bfd_elfNN_ia64_aix_little_vec
1376 || vec
== & bfd_elfNN_ia64_aix_big_vec
);
1379 /* Hook called by the linker routine which adds symbols from an object
1380 file. We use it to handle OS-specific symbols. */
1383 elfNN_ia64_aix_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
1385 struct bfd_link_info
*info
;
1386 const Elf_Internal_Sym
*sym
;
1392 if (strcmp (*namep
, "__GLOB_DATA_PTR") == 0)
1394 /* Define __GLOB_DATA_PTR when it is encountered. This is expected to
1395 be a linker-defined symbol by the Aix C runtime startup code. IBM sez
1396 no one else should use it b/c it is undocumented. */
1397 struct elf_link_hash_entry
*h
;
1399 h
= elf_link_hash_lookup (elf_hash_table (info
), *namep
,
1400 FALSE
, FALSE
, FALSE
);
1403 struct elf_backend_data
*bed
;
1404 struct elfNN_ia64_link_hash_table
*ia64_info
;
1405 struct bfd_link_hash_entry
*bh
= NULL
;
1407 bed
= get_elf_backend_data (abfd
);
1408 ia64_info
= elfNN_ia64_hash_table (info
);
1410 if (!(_bfd_generic_link_add_one_symbol
1411 (info
, abfd
, *namep
, BSF_GLOBAL
,
1412 bfd_get_section_by_name (abfd
, ".bss"),
1413 bed
->got_symbol_offset
, (const char *) NULL
, FALSE
,
1414 bed
->collect
, &bh
)))
1417 h
= (struct elf_link_hash_entry
*) bh
;
1418 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1419 h
->type
= STT_OBJECT
;
1421 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1427 else if (sym
->st_shndx
== SHN_LOOS
)
1431 /* SHN_AIX_SYSCALL: Treat this as any other symbol. The special symbol
1432 is only relevant when compiling code for extended system calls.
1433 Replace the "special" section with .text, if possible.
1434 Note that these symbols are always assumed to be in .text. */
1435 for (i
= 1; i
< elf_numsections (abfd
); i
++)
1437 asection
* sec
= bfd_section_from_elf_index (abfd
, i
);
1439 if (sec
&& strcmp (sec
->name
, ".text") == 0)
1447 *secp
= bfd_abs_section_ptr
;
1449 *valp
= sym
->st_size
;
1455 return elfNN_ia64_add_symbol_hook (abfd
, info
, sym
,
1456 namep
, flagsp
, secp
, valp
);
1461 elfNN_ia64_aix_link_add_symbols (abfd
, info
)
1463 struct bfd_link_info
*info
;
1465 /* Make sure dynamic sections are always created. */
1466 if (! elf_hash_table (info
)->dynamic_sections_created
1467 && abfd
->xvec
== info
->hash
->creator
)
1469 if (! bfd_elfNN_link_create_dynamic_sections (abfd
, info
))
1473 /* Now do the standard call. */
1474 return bfd_elfNN_bfd_link_add_symbols (abfd
, info
);
1477 /* Return the number of additional phdrs we will need. */
1480 elfNN_ia64_additional_program_headers (abfd
)
1486 /* See if we need a PT_IA_64_ARCHEXT segment. */
1487 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_archext
);
1488 if (s
&& (s
->flags
& SEC_LOAD
))
1491 /* Count how many PT_IA_64_UNWIND segments we need. */
1492 for (s
= abfd
->sections
; s
; s
= s
->next
)
1493 if (is_unwind_section_name (abfd
, s
->name
) && (s
->flags
& SEC_LOAD
))
1500 elfNN_ia64_modify_segment_map (abfd
)
1503 struct elf_segment_map
*m
, **pm
;
1504 Elf_Internal_Shdr
*hdr
;
1507 /* If we need a PT_IA_64_ARCHEXT segment, it must come before
1508 all PT_LOAD segments. */
1509 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_archext
);
1510 if (s
&& (s
->flags
& SEC_LOAD
))
1512 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1513 if (m
->p_type
== PT_IA_64_ARCHEXT
)
1517 m
= ((struct elf_segment_map
*)
1518 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *m
));
1522 m
->p_type
= PT_IA_64_ARCHEXT
;
1526 /* We want to put it after the PHDR and INTERP segments. */
1527 pm
= &elf_tdata (abfd
)->segment_map
;
1529 && ((*pm
)->p_type
== PT_PHDR
1530 || (*pm
)->p_type
== PT_INTERP
))
1538 /* Install PT_IA_64_UNWIND segments, if needed. */
1539 for (s
= abfd
->sections
; s
; s
= s
->next
)
1541 hdr
= &elf_section_data (s
)->this_hdr
;
1542 if (hdr
->sh_type
!= SHT_IA_64_UNWIND
)
1545 if (s
&& (s
->flags
& SEC_LOAD
))
1547 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1548 if (m
->p_type
== PT_IA_64_UNWIND
)
1552 /* Look through all sections in the unwind segment
1553 for a match since there may be multiple sections
1555 for (i
= m
->count
- 1; i
>= 0; --i
)
1556 if (m
->sections
[i
] == s
)
1565 m
= ((struct elf_segment_map
*)
1566 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *m
));
1570 m
->p_type
= PT_IA_64_UNWIND
;
1575 /* We want to put it last. */
1576 pm
= &elf_tdata (abfd
)->segment_map
;
1584 /* Turn on PF_IA_64_NORECOV if needed. This involves traversing all of
1585 the input sections for each output section in the segment and testing
1586 for SHF_IA_64_NORECOV on each. */
1587 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1588 if (m
->p_type
== PT_LOAD
)
1591 for (i
= m
->count
- 1; i
>= 0; --i
)
1593 struct bfd_link_order
*order
= m
->sections
[i
]->link_order_head
;
1596 if (order
->type
== bfd_indirect_link_order
)
1598 asection
*is
= order
->u
.indirect
.section
;
1599 bfd_vma flags
= elf_section_data(is
)->this_hdr
.sh_flags
;
1600 if (flags
& SHF_IA_64_NORECOV
)
1602 m
->p_flags
|= PF_IA_64_NORECOV
;
1606 order
= order
->next
;
1615 /* According to the Tahoe assembler spec, all labels starting with a
1619 elfNN_ia64_is_local_label_name (abfd
, name
)
1620 bfd
*abfd ATTRIBUTE_UNUSED
;
1623 return name
[0] == '.';
1626 /* Should we do dynamic things to this symbol? */
1629 elfNN_ia64_dynamic_symbol_p (h
, info
)
1630 struct elf_link_hash_entry
*h
;
1631 struct bfd_link_info
*info
;
1636 while (h
->root
.type
== bfd_link_hash_indirect
1637 || h
->root
.type
== bfd_link_hash_warning
)
1638 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1640 if (h
->dynindx
== -1)
1642 switch (ELF_ST_VISIBILITY (h
->other
))
1651 if (h
->root
.type
== bfd_link_hash_undefweak
1652 || h
->root
.type
== bfd_link_hash_defweak
)
1655 if ((info
->shared
&& (!info
->symbolic
|| info
->allow_shlib_undefined
))
1656 || ((h
->elf_link_hash_flags
1657 & (ELF_LINK_HASH_DEF_DYNAMIC
| ELF_LINK_HASH_REF_REGULAR
))
1658 == (ELF_LINK_HASH_DEF_DYNAMIC
| ELF_LINK_HASH_REF_REGULAR
)))
1665 elfNN_ia64_local_hash_table_init (ht
, abfd
, new)
1666 struct elfNN_ia64_local_hash_table
*ht
;
1667 bfd
*abfd ATTRIBUTE_UNUSED
;
1668 new_hash_entry_func
new;
1670 memset (ht
, 0, sizeof (*ht
));
1671 return bfd_hash_table_init (&ht
->root
, new);
1674 static struct bfd_hash_entry
*
1675 elfNN_ia64_new_loc_hash_entry (entry
, table
, string
)
1676 struct bfd_hash_entry
*entry
;
1677 struct bfd_hash_table
*table
;
1680 struct elfNN_ia64_local_hash_entry
*ret
;
1681 ret
= (struct elfNN_ia64_local_hash_entry
*) entry
;
1683 /* Allocate the structure if it has not already been allocated by a
1686 ret
= bfd_hash_allocate (table
, sizeof (*ret
));
1691 /* Initialize our local data. All zeros, and definitely easier
1692 than setting a handful of bit fields. */
1693 memset (ret
, 0, sizeof (*ret
));
1695 /* Call the allocation method of the superclass. */
1696 ret
= ((struct elfNN_ia64_local_hash_entry
*)
1697 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
1699 return (struct bfd_hash_entry
*) ret
;
1702 static struct bfd_hash_entry
*
1703 elfNN_ia64_new_elf_hash_entry (entry
, table
, string
)
1704 struct bfd_hash_entry
*entry
;
1705 struct bfd_hash_table
*table
;
1708 struct elfNN_ia64_link_hash_entry
*ret
;
1709 ret
= (struct elfNN_ia64_link_hash_entry
*) entry
;
1711 /* Allocate the structure if it has not already been allocated by a
1714 ret
= bfd_hash_allocate (table
, sizeof (*ret
));
1719 /* Initialize our local data. All zeros, and definitely easier
1720 than setting a handful of bit fields. */
1721 memset (ret
, 0, sizeof (*ret
));
1723 /* Call the allocation method of the superclass. */
1724 ret
= ((struct elfNN_ia64_link_hash_entry
*)
1725 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
1728 return (struct bfd_hash_entry
*) ret
;
1732 elfNN_ia64_hash_copy_indirect (bed
, xdir
, xind
)
1733 struct elf_backend_data
*bed ATTRIBUTE_UNUSED
;
1734 struct elf_link_hash_entry
*xdir
, *xind
;
1736 struct elfNN_ia64_link_hash_entry
*dir
, *ind
;
1738 dir
= (struct elfNN_ia64_link_hash_entry
*) xdir
;
1739 ind
= (struct elfNN_ia64_link_hash_entry
*) xind
;
1741 /* Copy down any references that we may have already seen to the
1742 symbol which just became indirect. */
1744 dir
->root
.elf_link_hash_flags
|=
1745 (ind
->root
.elf_link_hash_flags
1746 & (ELF_LINK_HASH_REF_DYNAMIC
1747 | ELF_LINK_HASH_REF_REGULAR
1748 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
));
1750 if (ind
->root
.root
.type
!= bfd_link_hash_indirect
)
1753 /* Copy over the got and plt data. This would have been done
1756 if (dir
->info
== NULL
)
1758 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1760 dir
->info
= dyn_i
= ind
->info
;
1763 /* Fix up the dyn_sym_info pointers to the global symbol. */
1764 for (; dyn_i
; dyn_i
= dyn_i
->next
)
1765 dyn_i
->h
= &dir
->root
;
1767 BFD_ASSERT (ind
->info
== NULL
);
1769 /* Copy over the dynindx. */
1771 if (dir
->root
.dynindx
== -1)
1773 dir
->root
.dynindx
= ind
->root
.dynindx
;
1774 dir
->root
.dynstr_index
= ind
->root
.dynstr_index
;
1775 ind
->root
.dynindx
= -1;
1776 ind
->root
.dynstr_index
= 0;
1778 BFD_ASSERT (ind
->root
.dynindx
== -1);
1782 elfNN_ia64_hash_hide_symbol (info
, xh
, force_local
)
1783 struct bfd_link_info
*info
;
1784 struct elf_link_hash_entry
*xh
;
1785 bfd_boolean force_local
;
1787 struct elfNN_ia64_link_hash_entry
*h
;
1788 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1790 h
= (struct elfNN_ia64_link_hash_entry
*)xh
;
1792 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
1794 for (dyn_i
= h
->info
; dyn_i
; dyn_i
= dyn_i
->next
)
1795 dyn_i
->want_plt2
= 0;
1798 /* Create the derived linker hash table. The IA-64 ELF port uses this
1799 derived hash table to keep information specific to the IA-64 ElF
1800 linker (without using static variables). */
1802 static struct bfd_link_hash_table
*
1803 elfNN_ia64_hash_table_create (abfd
)
1806 struct elfNN_ia64_link_hash_table
*ret
;
1808 ret
= bfd_zmalloc ((bfd_size_type
) sizeof (*ret
));
1812 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
1813 elfNN_ia64_new_elf_hash_entry
))
1819 if (!elfNN_ia64_local_hash_table_init (&ret
->loc_hash_table
, abfd
,
1820 elfNN_ia64_new_loc_hash_entry
))
1826 return &ret
->root
.root
;
1829 /* Look up an entry in a Alpha ELF linker hash table. */
1831 static INLINE
struct elfNN_ia64_local_hash_entry
*
1832 elfNN_ia64_local_hash_lookup(table
, string
, create
, copy
)
1833 struct elfNN_ia64_local_hash_table
*table
;
1835 bfd_boolean create
, copy
;
1837 return ((struct elfNN_ia64_local_hash_entry
*)
1838 bfd_hash_lookup (&table
->root
, string
, create
, copy
));
1841 /* Traverse both local and global hash tables. */
1843 struct elfNN_ia64_dyn_sym_traverse_data
1845 bfd_boolean (*func
) PARAMS ((struct elfNN_ia64_dyn_sym_info
*, PTR
));
1850 elfNN_ia64_global_dyn_sym_thunk (xentry
, xdata
)
1851 struct bfd_hash_entry
*xentry
;
1854 struct elfNN_ia64_link_hash_entry
*entry
1855 = (struct elfNN_ia64_link_hash_entry
*) xentry
;
1856 struct elfNN_ia64_dyn_sym_traverse_data
*data
1857 = (struct elfNN_ia64_dyn_sym_traverse_data
*) xdata
;
1858 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1860 if (entry
->root
.root
.type
== bfd_link_hash_warning
)
1861 entry
= (struct elfNN_ia64_link_hash_entry
*) entry
->root
.root
.u
.i
.link
;
1863 for (dyn_i
= entry
->info
; dyn_i
; dyn_i
= dyn_i
->next
)
1864 if (! (*data
->func
) (dyn_i
, data
->data
))
1870 elfNN_ia64_local_dyn_sym_thunk (xentry
, xdata
)
1871 struct bfd_hash_entry
*xentry
;
1874 struct elfNN_ia64_local_hash_entry
*entry
1875 = (struct elfNN_ia64_local_hash_entry
*) xentry
;
1876 struct elfNN_ia64_dyn_sym_traverse_data
*data
1877 = (struct elfNN_ia64_dyn_sym_traverse_data
*) xdata
;
1878 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1880 for (dyn_i
= entry
->info
; dyn_i
; dyn_i
= dyn_i
->next
)
1881 if (! (*data
->func
) (dyn_i
, data
->data
))
1887 elfNN_ia64_dyn_sym_traverse (ia64_info
, func
, data
)
1888 struct elfNN_ia64_link_hash_table
*ia64_info
;
1889 bfd_boolean (*func
) PARAMS ((struct elfNN_ia64_dyn_sym_info
*, PTR
));
1892 struct elfNN_ia64_dyn_sym_traverse_data xdata
;
1897 elf_link_hash_traverse (&ia64_info
->root
,
1898 elfNN_ia64_global_dyn_sym_thunk
, &xdata
);
1899 bfd_hash_traverse (&ia64_info
->loc_hash_table
.root
,
1900 elfNN_ia64_local_dyn_sym_thunk
, &xdata
);
1904 elfNN_ia64_create_dynamic_sections (abfd
, info
)
1906 struct bfd_link_info
*info
;
1908 struct elfNN_ia64_link_hash_table
*ia64_info
;
1911 if (! _bfd_elf_create_dynamic_sections (abfd
, info
))
1914 ia64_info
= elfNN_ia64_hash_table (info
);
1916 ia64_info
->plt_sec
= bfd_get_section_by_name (abfd
, ".plt");
1917 ia64_info
->got_sec
= bfd_get_section_by_name (abfd
, ".got");
1920 flagword flags
= bfd_get_section_flags (abfd
, ia64_info
->got_sec
);
1921 bfd_set_section_flags (abfd
, ia64_info
->got_sec
, SEC_SMALL_DATA
| flags
);
1924 if (!get_pltoff (abfd
, info
, ia64_info
))
1927 s
= bfd_make_section(abfd
, ".rela.IA_64.pltoff");
1929 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
1932 | SEC_LINKER_CREATED
1934 || !bfd_set_section_alignment (abfd
, s
, 3))
1936 ia64_info
->rel_pltoff_sec
= s
;
1938 s
= bfd_make_section(abfd
, ".rela.got");
1940 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
1943 | SEC_LINKER_CREATED
1945 || !bfd_set_section_alignment (abfd
, s
, 3))
1947 ia64_info
->rel_got_sec
= s
;
1952 /* Find and/or create a hash entry for local symbol. */
1953 static struct elfNN_ia64_local_hash_entry
*
1954 get_local_sym_hash (ia64_info
, abfd
, rel
, create
)
1955 struct elfNN_ia64_link_hash_table
*ia64_info
;
1957 const Elf_Internal_Rela
*rel
;
1960 struct elfNN_ia64_local_hash_entry
*ret
;
1961 asection
*sec
= abfd
->sections
;
1962 char addr_name
[34];
1964 BFD_ASSERT ((sizeof (sec
->id
)*2 + 1 + sizeof (unsigned long)*2 + 1) <= 34);
1967 /* Construct a string for use in the elfNN_ia64_local_hash_table.
1968 name describes what was once anonymous memory. */
1970 sprintf (addr_name
, "%x:%lx",
1971 sec
->id
, (unsigned long) ELFNN_R_SYM (rel
->r_info
));
1973 /* Collect the canonical entry data for this address. */
1974 ret
= elfNN_ia64_local_hash_lookup (&ia64_info
->loc_hash_table
,
1975 addr_name
, create
, create
);
1979 /* Find and/or create a descriptor for dynamic symbol info. This will
1980 vary based on global or local symbol, and the addend to the reloc. */
1982 static struct elfNN_ia64_dyn_sym_info
*
1983 get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, create
)
1984 struct elfNN_ia64_link_hash_table
*ia64_info
;
1985 struct elf_link_hash_entry
*h
;
1987 const Elf_Internal_Rela
*rel
;
1990 struct elfNN_ia64_dyn_sym_info
**pp
;
1991 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1992 bfd_vma addend
= rel
? rel
->r_addend
: 0;
1995 pp
= &((struct elfNN_ia64_link_hash_entry
*)h
)->info
;
1998 struct elfNN_ia64_local_hash_entry
*loc_h
;
2000 loc_h
= get_local_sym_hash (ia64_info
, abfd
, rel
, create
);
2003 BFD_ASSERT (!create
);
2010 for (dyn_i
= *pp
; dyn_i
&& dyn_i
->addend
!= addend
; dyn_i
= *pp
)
2013 if (dyn_i
== NULL
&& create
)
2015 dyn_i
= ((struct elfNN_ia64_dyn_sym_info
*)
2016 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *dyn_i
));
2018 dyn_i
->addend
= addend
;
2025 get_got (abfd
, info
, ia64_info
)
2027 struct bfd_link_info
*info
;
2028 struct elfNN_ia64_link_hash_table
*ia64_info
;
2033 got
= ia64_info
->got_sec
;
2038 dynobj
= ia64_info
->root
.dynobj
;
2040 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2041 if (!_bfd_elf_create_got_section (dynobj
, info
))
2044 got
= bfd_get_section_by_name (dynobj
, ".got");
2046 ia64_info
->got_sec
= got
;
2048 flags
= bfd_get_section_flags (abfd
, got
);
2049 bfd_set_section_flags (abfd
, got
, SEC_SMALL_DATA
| flags
);
2055 /* Create function descriptor section (.opd). This section is called .opd
2056 because it contains "official prodecure descriptors". The "official"
2057 refers to the fact that these descriptors are used when taking the address
2058 of a procedure, thus ensuring a unique address for each procedure. */
2061 get_fptr (abfd
, info
, ia64_info
)
2063 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2064 struct elfNN_ia64_link_hash_table
*ia64_info
;
2069 fptr
= ia64_info
->fptr_sec
;
2072 dynobj
= ia64_info
->root
.dynobj
;
2074 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2076 fptr
= bfd_make_section (dynobj
, ".opd");
2078 || !bfd_set_section_flags (dynobj
, fptr
,
2084 | SEC_LINKER_CREATED
))
2085 || !bfd_set_section_alignment (abfd
, fptr
, 4))
2091 ia64_info
->fptr_sec
= fptr
;
2098 get_pltoff (abfd
, info
, ia64_info
)
2100 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2101 struct elfNN_ia64_link_hash_table
*ia64_info
;
2106 pltoff
= ia64_info
->pltoff_sec
;
2109 dynobj
= ia64_info
->root
.dynobj
;
2111 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2113 pltoff
= bfd_make_section (dynobj
, ELF_STRING_ia64_pltoff
);
2115 || !bfd_set_section_flags (dynobj
, pltoff
,
2121 | SEC_LINKER_CREATED
))
2122 || !bfd_set_section_alignment (abfd
, pltoff
, 4))
2128 ia64_info
->pltoff_sec
= pltoff
;
2135 get_reloc_section (abfd
, ia64_info
, sec
, create
)
2137 struct elfNN_ia64_link_hash_table
*ia64_info
;
2141 const char *srel_name
;
2145 srel_name
= (bfd_elf_string_from_elf_section
2146 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
2147 elf_section_data(sec
)->rel_hdr
.sh_name
));
2148 if (srel_name
== NULL
)
2151 BFD_ASSERT ((strncmp (srel_name
, ".rela", 5) == 0
2152 && strcmp (bfd_get_section_name (abfd
, sec
),
2154 || (strncmp (srel_name
, ".rel", 4) == 0
2155 && strcmp (bfd_get_section_name (abfd
, sec
),
2156 srel_name
+4) == 0));
2158 dynobj
= ia64_info
->root
.dynobj
;
2160 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2162 srel
= bfd_get_section_by_name (dynobj
, srel_name
);
2163 if (srel
== NULL
&& create
)
2165 srel
= bfd_make_section (dynobj
, srel_name
);
2167 || !bfd_set_section_flags (dynobj
, srel
,
2172 | SEC_LINKER_CREATED
2174 || !bfd_set_section_alignment (dynobj
, srel
, 3))
2178 if (sec
->flags
& SEC_READONLY
)
2179 ia64_info
->reltext
= 1;
2185 count_dyn_reloc (abfd
, dyn_i
, srel
, type
)
2187 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2191 struct elfNN_ia64_dyn_reloc_entry
*rent
;
2193 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2194 if (rent
->srel
== srel
&& rent
->type
== type
)
2199 rent
= ((struct elfNN_ia64_dyn_reloc_entry
*)
2200 bfd_alloc (abfd
, (bfd_size_type
) sizeof (*rent
)));
2204 rent
->next
= dyn_i
->reloc_entries
;
2208 dyn_i
->reloc_entries
= rent
;
2216 elfNN_ia64_check_relocs (abfd
, info
, sec
, relocs
)
2218 struct bfd_link_info
*info
;
2220 const Elf_Internal_Rela
*relocs
;
2222 struct elfNN_ia64_link_hash_table
*ia64_info
;
2223 const Elf_Internal_Rela
*relend
;
2224 Elf_Internal_Shdr
*symtab_hdr
;
2225 const Elf_Internal_Rela
*rel
;
2226 asection
*got
, *fptr
, *srel
;
2228 if (info
->relocateable
)
2231 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2232 ia64_info
= elfNN_ia64_hash_table (info
);
2234 got
= fptr
= srel
= NULL
;
2236 relend
= relocs
+ sec
->reloc_count
;
2237 for (rel
= relocs
; rel
< relend
; ++rel
)
2247 NEED_LTOFF_FPTR
= 128,
2253 struct elf_link_hash_entry
*h
= NULL
;
2254 unsigned long r_symndx
= ELFNN_R_SYM (rel
->r_info
);
2255 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2257 bfd_boolean maybe_dynamic
;
2258 int dynrel_type
= R_IA64_NONE
;
2260 if (r_symndx
>= symtab_hdr
->sh_info
)
2262 /* We're dealing with a global symbol -- find its hash entry
2263 and mark it as being referenced. */
2264 long indx
= r_symndx
- symtab_hdr
->sh_info
;
2265 h
= elf_sym_hashes (abfd
)[indx
];
2266 while (h
->root
.type
== bfd_link_hash_indirect
2267 || h
->root
.type
== bfd_link_hash_warning
)
2268 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2270 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
2273 /* We can only get preliminary data on whether a symbol is
2274 locally or externally defined, as not all of the input files
2275 have yet been processed. Do something with what we know, as
2276 this may help reduce memory usage and processing time later. */
2277 maybe_dynamic
= FALSE
;
2278 if (h
&& ((info
->shared
2279 && (!info
->symbolic
|| info
->allow_shlib_undefined
))
2280 || ! (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)
2281 || h
->root
.type
== bfd_link_hash_defweak
2282 || elfNN_ia64_aix_vec (abfd
->xvec
)))
2283 maybe_dynamic
= TRUE
;
2286 switch (ELFNN_R_TYPE (rel
->r_info
))
2288 case R_IA64_TPREL64MSB
:
2289 case R_IA64_TPREL64LSB
:
2290 if (info
->shared
|| maybe_dynamic
)
2291 need_entry
= NEED_DYNREL
;
2292 dynrel_type
= R_IA64_TPREL64LSB
;
2294 info
->flags
|= DF_STATIC_TLS
;
2297 case R_IA64_LTOFF_TPREL22
:
2298 need_entry
= NEED_TPREL
;
2300 info
->flags
|= DF_STATIC_TLS
;
2303 case R_IA64_DTPREL64MSB
:
2304 case R_IA64_DTPREL64LSB
:
2305 if (info
->shared
|| maybe_dynamic
)
2306 need_entry
= NEED_DYNREL
;
2307 dynrel_type
= R_IA64_DTPREL64LSB
;
2310 case R_IA64_LTOFF_DTPREL22
:
2311 need_entry
= NEED_DTPREL
;
2314 case R_IA64_DTPMOD64MSB
:
2315 case R_IA64_DTPMOD64LSB
:
2316 if (info
->shared
|| maybe_dynamic
)
2317 need_entry
= NEED_DYNREL
;
2318 dynrel_type
= R_IA64_DTPMOD64LSB
;
2321 case R_IA64_LTOFF_DTPMOD22
:
2322 need_entry
= NEED_DTPMOD
;
2325 case R_IA64_LTOFF_FPTR22
:
2326 case R_IA64_LTOFF_FPTR64I
:
2327 case R_IA64_LTOFF_FPTR32MSB
:
2328 case R_IA64_LTOFF_FPTR32LSB
:
2329 case R_IA64_LTOFF_FPTR64MSB
:
2330 case R_IA64_LTOFF_FPTR64LSB
:
2331 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
2334 case R_IA64_FPTR64I
:
2335 case R_IA64_FPTR32MSB
:
2336 case R_IA64_FPTR32LSB
:
2337 case R_IA64_FPTR64MSB
:
2338 case R_IA64_FPTR64LSB
:
2339 if (info
->shared
|| h
|| elfNN_ia64_aix_vec (abfd
->xvec
))
2340 need_entry
= NEED_FPTR
| NEED_DYNREL
;
2342 need_entry
= NEED_FPTR
;
2343 dynrel_type
= R_IA64_FPTR64LSB
;
2346 case R_IA64_LTOFF22
:
2347 case R_IA64_LTOFF64I
:
2348 need_entry
= NEED_GOT
;
2351 case R_IA64_LTOFF22X
:
2352 need_entry
= NEED_GOTX
;
2355 case R_IA64_PLTOFF22
:
2356 case R_IA64_PLTOFF64I
:
2357 case R_IA64_PLTOFF64MSB
:
2358 case R_IA64_PLTOFF64LSB
:
2359 need_entry
= NEED_PLTOFF
;
2363 need_entry
|= NEED_MIN_PLT
;
2367 (*info
->callbacks
->warning
)
2368 (info
, _("@pltoff reloc against local symbol"), 0,
2369 abfd
, 0, (bfd_vma
) 0);
2373 case R_IA64_PCREL21B
:
2374 case R_IA64_PCREL60B
:
2375 /* Depending on where this symbol is defined, we may or may not
2376 need a full plt entry. Only skip if we know we'll not need
2377 the entry -- static or symbolic, and the symbol definition
2378 has already been seen. */
2379 if (maybe_dynamic
&& rel
->r_addend
== 0)
2380 need_entry
= NEED_FULL_PLT
;
2386 case R_IA64_DIR32MSB
:
2387 case R_IA64_DIR32LSB
:
2388 case R_IA64_DIR64MSB
:
2389 case R_IA64_DIR64LSB
:
2390 /* Shared objects will always need at least a REL relocation. */
2391 if (info
->shared
|| maybe_dynamic
2392 || (elfNN_ia64_aix_vec (abfd
->xvec
)
2393 && (!h
|| strcmp (h
->root
.root
.string
,
2394 "__GLOB_DATA_PTR") != 0)))
2395 need_entry
= NEED_DYNREL
;
2396 dynrel_type
= R_IA64_DIR64LSB
;
2399 case R_IA64_IPLTMSB
:
2400 case R_IA64_IPLTLSB
:
2401 /* Shared objects will always need at least a REL relocation. */
2402 if (info
->shared
|| maybe_dynamic
)
2403 need_entry
= NEED_DYNREL
;
2404 dynrel_type
= R_IA64_IPLTLSB
;
2407 case R_IA64_PCREL22
:
2408 case R_IA64_PCREL64I
:
2409 case R_IA64_PCREL32MSB
:
2410 case R_IA64_PCREL32LSB
:
2411 case R_IA64_PCREL64MSB
:
2412 case R_IA64_PCREL64LSB
:
2414 need_entry
= NEED_DYNREL
;
2415 dynrel_type
= R_IA64_PCREL64LSB
;
2422 if ((need_entry
& NEED_FPTR
) != 0
2425 (*info
->callbacks
->warning
)
2426 (info
, _("non-zero addend in @fptr reloc"), 0,
2427 abfd
, 0, (bfd_vma
) 0);
2430 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, TRUE
);
2432 /* Record whether or not this is a local symbol. */
2435 /* Create what's needed. */
2436 if (need_entry
& (NEED_GOT
| NEED_GOTX
| NEED_TPREL
2437 | NEED_DTPMOD
| NEED_DTPREL
))
2441 got
= get_got (abfd
, info
, ia64_info
);
2445 if (need_entry
& NEED_GOT
)
2446 dyn_i
->want_got
= 1;
2447 if (need_entry
& NEED_GOTX
)
2448 dyn_i
->want_gotx
= 1;
2449 if (need_entry
& NEED_TPREL
)
2450 dyn_i
->want_tprel
= 1;
2451 if (need_entry
& NEED_DTPMOD
)
2452 dyn_i
->want_dtpmod
= 1;
2453 if (need_entry
& NEED_DTPREL
)
2454 dyn_i
->want_dtprel
= 1;
2456 if (need_entry
& NEED_FPTR
)
2460 fptr
= get_fptr (abfd
, info
, ia64_info
);
2465 /* FPTRs for shared libraries are allocated by the dynamic
2466 linker. Make sure this local symbol will appear in the
2467 dynamic symbol table. */
2468 if (!h
&& (info
->shared
2469 /* AIX also needs one */
2470 || elfNN_ia64_aix_vec (abfd
->xvec
)))
2472 if (! (_bfd_elfNN_link_record_local_dynamic_symbol
2473 (info
, abfd
, (long) r_symndx
)))
2477 dyn_i
->want_fptr
= 1;
2479 if (need_entry
& NEED_LTOFF_FPTR
)
2480 dyn_i
->want_ltoff_fptr
= 1;
2481 if (need_entry
& (NEED_MIN_PLT
| NEED_FULL_PLT
))
2483 if (!ia64_info
->root
.dynobj
)
2484 ia64_info
->root
.dynobj
= abfd
;
2485 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2486 dyn_i
->want_plt
= 1;
2488 if (need_entry
& NEED_FULL_PLT
)
2489 dyn_i
->want_plt2
= 1;
2490 if (need_entry
& NEED_PLTOFF
)
2491 dyn_i
->want_pltoff
= 1;
2492 if ((need_entry
& NEED_DYNREL
) && (sec
->flags
& SEC_ALLOC
))
2496 srel
= get_reloc_section (abfd
, ia64_info
, sec
, TRUE
);
2500 if (!count_dyn_reloc (abfd
, dyn_i
, srel
, dynrel_type
))
2508 /* For cleanliness, and potentially faster dynamic loading, allocate
2509 external GOT entries first. */
2512 allocate_global_data_got (dyn_i
, data
)
2513 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2516 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2518 if ((dyn_i
->want_got
|| dyn_i
->want_gotx
)
2519 && ! dyn_i
->want_fptr
2520 && (elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
)
2521 || (elfNN_ia64_aix_vec (x
->info
->hash
->creator
)
2522 && (!dyn_i
->h
|| strcmp (dyn_i
->h
->root
.root
.string
,
2523 "__GLOB_DATA_PTR") != 0))))
2525 dyn_i
->got_offset
= x
->ofs
;
2528 if (dyn_i
->want_tprel
)
2530 dyn_i
->tprel_offset
= x
->ofs
;
2533 if (dyn_i
->want_dtpmod
)
2535 if (elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
))
2537 dyn_i
->dtpmod_offset
= x
->ofs
;
2542 struct elfNN_ia64_link_hash_table
*ia64_info
;
2544 ia64_info
= elfNN_ia64_hash_table (x
->info
);
2545 if (ia64_info
->self_dtpmod_offset
== (bfd_vma
) -1)
2547 ia64_info
->self_dtpmod_offset
= x
->ofs
;
2550 dyn_i
->dtpmod_offset
= ia64_info
->self_dtpmod_offset
;
2553 if (dyn_i
->want_dtprel
)
2555 dyn_i
->dtprel_offset
= x
->ofs
;
2561 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
2564 allocate_global_fptr_got (dyn_i
, data
)
2565 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2568 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2572 && (elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
)
2573 || elfNN_ia64_aix_vec (x
->info
->hash
->creator
)))
2575 dyn_i
->got_offset
= x
->ofs
;
2581 /* Lastly, allocate all the GOT entries for local data. */
2584 allocate_local_got (dyn_i
, data
)
2585 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2588 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2590 if ((dyn_i
->want_got
|| dyn_i
->want_gotx
)
2591 && ! (elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
)
2592 || elfNN_ia64_aix_vec (x
->info
->hash
->creator
)))
2594 dyn_i
->got_offset
= x
->ofs
;
2600 /* Search for the index of a global symbol in it's defining object file. */
2603 global_sym_index (h
)
2604 struct elf_link_hash_entry
*h
;
2606 struct elf_link_hash_entry
**p
;
2609 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
2610 || h
->root
.type
== bfd_link_hash_defweak
);
2612 obj
= h
->root
.u
.def
.section
->owner
;
2613 for (p
= elf_sym_hashes (obj
); *p
!= h
; ++p
)
2616 return p
- elf_sym_hashes (obj
) + elf_tdata (obj
)->symtab_hdr
.sh_info
;
2619 /* Allocate function descriptors. We can do these for every function
2620 in a main executable that is not exported. */
2623 allocate_fptr (dyn_i
, data
)
2624 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2627 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2629 if (dyn_i
->want_fptr
)
2631 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2634 while (h
->root
.type
== bfd_link_hash_indirect
2635 || h
->root
.type
== bfd_link_hash_warning
)
2636 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2639 /* AIX needs an FPTR in this case. */
2640 || (elfNN_ia64_aix_vec (x
->info
->hash
->creator
)
2642 || h
->root
.type
== bfd_link_hash_defined
2643 || h
->root
.type
== bfd_link_hash_defweak
)))
2645 if (h
&& h
->dynindx
== -1)
2647 BFD_ASSERT ((h
->root
.type
== bfd_link_hash_defined
)
2648 || (h
->root
.type
== bfd_link_hash_defweak
));
2650 if (!_bfd_elfNN_link_record_local_dynamic_symbol
2651 (x
->info
, h
->root
.u
.def
.section
->owner
,
2652 global_sym_index (h
)))
2656 dyn_i
->want_fptr
= 0;
2658 else if (h
== NULL
|| h
->dynindx
== -1)
2660 dyn_i
->fptr_offset
= x
->ofs
;
2664 dyn_i
->want_fptr
= 0;
2669 /* Allocate all the minimal PLT entries. */
2672 allocate_plt_entries (dyn_i
, data
)
2673 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2676 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2678 if (dyn_i
->want_plt
)
2680 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2683 while (h
->root
.type
== bfd_link_hash_indirect
2684 || h
->root
.type
== bfd_link_hash_warning
)
2685 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2687 /* ??? Versioned symbols seem to lose ELF_LINK_HASH_NEEDS_PLT. */
2688 if (elfNN_ia64_dynamic_symbol_p (h
, x
->info
))
2690 bfd_size_type offset
= x
->ofs
;
2692 offset
= PLT_HEADER_SIZE
;
2693 dyn_i
->plt_offset
= offset
;
2694 x
->ofs
= offset
+ PLT_MIN_ENTRY_SIZE
;
2696 dyn_i
->want_pltoff
= 1;
2700 dyn_i
->want_plt
= 0;
2701 dyn_i
->want_plt2
= 0;
2707 /* Allocate all the full PLT entries. */
2710 allocate_plt2_entries (dyn_i
, data
)
2711 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2714 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2716 if (dyn_i
->want_plt2
)
2718 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2719 bfd_size_type ofs
= x
->ofs
;
2721 dyn_i
->plt2_offset
= ofs
;
2722 x
->ofs
= ofs
+ PLT_FULL_ENTRY_SIZE
;
2724 while (h
->root
.type
== bfd_link_hash_indirect
2725 || h
->root
.type
== bfd_link_hash_warning
)
2726 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2727 dyn_i
->h
->plt
.offset
= ofs
;
2732 /* Allocate all the PLTOFF entries requested by relocations and
2733 plt entries. We can't share space with allocated FPTR entries,
2734 because the latter are not necessarily addressable by the GP.
2735 ??? Relaxation might be able to determine that they are. */
2738 allocate_pltoff_entries (dyn_i
, data
)
2739 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2742 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2744 if (dyn_i
->want_pltoff
)
2746 dyn_i
->pltoff_offset
= x
->ofs
;
2752 /* Allocate dynamic relocations for those symbols that turned out
2756 allocate_dynrel_entries (dyn_i
, data
)
2757 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2760 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2761 struct elfNN_ia64_link_hash_table
*ia64_info
;
2762 struct elfNN_ia64_dyn_reloc_entry
*rent
;
2763 bfd_boolean dynamic_symbol
, shared
;
2765 ia64_info
= elfNN_ia64_hash_table (x
->info
);
2766 dynamic_symbol
= elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
)
2767 || (elfNN_ia64_aix_vec (x
->info
->hash
->creator
)
2768 /* Don't allocate an entry for __GLOB_DATA_PTR */
2769 && (!dyn_i
->h
|| strcmp (dyn_i
->h
->root
.root
.string
,
2770 "__GLOB_DATA_PTR") != 0));
2771 shared
= x
->info
->shared
;
2773 /* Take care of the normal data relocations. */
2775 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2777 int count
= rent
->count
;
2781 case R_IA64_FPTR64LSB
:
2782 /* Allocate one iff !want_fptr, which by this point will
2783 be true only if we're actually allocating one statically
2784 in the main executable. */
2785 if (dyn_i
->want_fptr
)
2788 case R_IA64_PCREL64LSB
:
2789 if (!dynamic_symbol
)
2792 case R_IA64_DIR64LSB
:
2793 if (!dynamic_symbol
&& !shared
)
2796 case R_IA64_IPLTLSB
:
2797 if (!dynamic_symbol
&& !shared
)
2799 /* Use two REL relocations for IPLT relocations
2800 against local symbols. */
2801 if (!dynamic_symbol
)
2804 case R_IA64_TPREL64LSB
:
2805 case R_IA64_DTPREL64LSB
:
2806 case R_IA64_DTPMOD64LSB
:
2811 rent
->srel
->_raw_size
+= sizeof (ElfNN_External_Rela
) * count
;
2814 /* Take care of the GOT and PLT relocations. */
2816 if (((dynamic_symbol
|| shared
) && (dyn_i
->want_got
|| dyn_i
->want_gotx
))
2817 || (dyn_i
->want_ltoff_fptr
&& dyn_i
->h
&& dyn_i
->h
->dynindx
!= -1))
2818 ia64_info
->rel_got_sec
->_raw_size
+= sizeof (ElfNN_External_Rela
);
2819 if ((dynamic_symbol
|| shared
) && dyn_i
->want_tprel
)
2820 ia64_info
->rel_got_sec
->_raw_size
+= sizeof (ElfNN_External_Rela
);
2821 if (dynamic_symbol
&& dyn_i
->want_dtpmod
)
2822 ia64_info
->rel_got_sec
->_raw_size
+= sizeof (ElfNN_External_Rela
);
2823 if (dynamic_symbol
&& dyn_i
->want_dtprel
)
2824 ia64_info
->rel_got_sec
->_raw_size
+= sizeof (ElfNN_External_Rela
);
2826 if (dyn_i
->want_pltoff
)
2828 bfd_size_type t
= 0;
2830 /* Dynamic symbols get one IPLT relocation. Local symbols in
2831 shared libraries get two REL relocations. Local symbols in
2832 main applications get nothing. */
2834 t
= sizeof (ElfNN_External_Rela
);
2836 t
= 2 * sizeof (ElfNN_External_Rela
);
2838 ia64_info
->rel_pltoff_sec
->_raw_size
+= t
;
2845 elfNN_ia64_adjust_dynamic_symbol (info
, h
)
2846 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2847 struct elf_link_hash_entry
*h
;
2849 /* ??? Undefined symbols with PLT entries should be re-defined
2850 to be the PLT entry. */
2852 /* If this is a weak symbol, and there is a real definition, the
2853 processor independent code will have arranged for us to see the
2854 real definition first, and we can just use the same value. */
2855 if (h
->weakdef
!= NULL
)
2857 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
2858 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
2859 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
2860 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
2864 /* If this is a reference to a symbol defined by a dynamic object which
2865 is not a function, we might allocate the symbol in our .dynbss section
2866 and allocate a COPY dynamic relocation.
2868 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2875 elfNN_ia64_size_dynamic_sections (output_bfd
, info
)
2877 struct bfd_link_info
*info
;
2879 struct elfNN_ia64_allocate_data data
;
2880 struct elfNN_ia64_link_hash_table
*ia64_info
;
2883 bfd_boolean relplt
= FALSE
;
2885 dynobj
= elf_hash_table(info
)->dynobj
;
2886 ia64_info
= elfNN_ia64_hash_table (info
);
2887 ia64_info
->self_dtpmod_offset
= (bfd_vma
) -1;
2888 BFD_ASSERT(dynobj
!= NULL
);
2891 /* Set the contents of the .interp section to the interpreter. */
2892 if (ia64_info
->root
.dynamic_sections_created
2895 sec
= bfd_get_section_by_name (dynobj
, ".interp");
2896 BFD_ASSERT (sec
!= NULL
);
2897 sec
->contents
= (bfd_byte
*) DYNAMIC_INTERPRETER (output_bfd
);
2898 sec
->_raw_size
= strlen (DYNAMIC_INTERPRETER (output_bfd
)) + 1;
2901 /* Allocate the GOT entries. */
2903 if (ia64_info
->got_sec
)
2906 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_data_got
, &data
);
2907 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_fptr_got
, &data
);
2908 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_local_got
, &data
);
2909 ia64_info
->got_sec
->_raw_size
= data
.ofs
;
2912 /* Allocate the FPTR entries. */
2914 if (ia64_info
->fptr_sec
)
2917 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_fptr
, &data
);
2918 ia64_info
->fptr_sec
->_raw_size
= data
.ofs
;
2921 /* Now that we've seen all of the input files, we can decide which
2922 symbols need plt entries. Allocate the minimal PLT entries first.
2923 We do this even though dynamic_sections_created may be FALSE, because
2924 this has the side-effect of clearing want_plt and want_plt2. */
2927 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_plt_entries
, &data
);
2929 ia64_info
->minplt_entries
= 0;
2932 ia64_info
->minplt_entries
2933 = (data
.ofs
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
2936 /* Align the pointer for the plt2 entries. */
2937 data
.ofs
= (data
.ofs
+ 31) & (bfd_vma
) -32;
2939 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_plt2_entries
, &data
);
2942 BFD_ASSERT (ia64_info
->root
.dynamic_sections_created
);
2944 ia64_info
->plt_sec
->_raw_size
= data
.ofs
;
2946 /* If we've got a .plt, we need some extra memory for the dynamic
2947 linker. We stuff these in .got.plt. */
2948 sec
= bfd_get_section_by_name (dynobj
, ".got.plt");
2949 sec
->_raw_size
= 8 * PLT_RESERVED_WORDS
;
2952 /* Allocate the PLTOFF entries. */
2954 if (ia64_info
->pltoff_sec
)
2957 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_pltoff_entries
, &data
);
2958 ia64_info
->pltoff_sec
->_raw_size
= data
.ofs
;
2961 if (ia64_info
->root
.dynamic_sections_created
)
2963 /* Allocate space for the dynamic relocations that turned out to be
2966 if (info
->shared
&& ia64_info
->self_dtpmod_offset
!= (bfd_vma
) -1)
2967 ia64_info
->rel_got_sec
->_raw_size
+= sizeof (ElfNN_External_Rela
);
2968 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_dynrel_entries
, &data
);
2971 /* We have now determined the sizes of the various dynamic sections.
2972 Allocate memory for them. */
2973 for (sec
= dynobj
->sections
; sec
!= NULL
; sec
= sec
->next
)
2977 if (!(sec
->flags
& SEC_LINKER_CREATED
))
2980 /* If we don't need this section, strip it from the output file.
2981 There were several sections primarily related to dynamic
2982 linking that must be create before the linker maps input
2983 sections to output sections. The linker does that before
2984 bfd_elf_size_dynamic_sections is called, and it is that
2985 function which decides whether anything needs to go into
2988 strip
= (sec
->_raw_size
== 0);
2990 if (sec
== ia64_info
->got_sec
)
2992 else if (sec
== ia64_info
->rel_got_sec
)
2995 ia64_info
->rel_got_sec
= NULL
;
2997 /* We use the reloc_count field as a counter if we need to
2998 copy relocs into the output file. */
2999 sec
->reloc_count
= 0;
3001 else if (sec
== ia64_info
->fptr_sec
)
3004 ia64_info
->fptr_sec
= NULL
;
3006 else if (sec
== ia64_info
->plt_sec
)
3009 ia64_info
->plt_sec
= NULL
;
3011 else if (sec
== ia64_info
->pltoff_sec
)
3014 ia64_info
->pltoff_sec
= NULL
;
3016 else if (sec
== ia64_info
->rel_pltoff_sec
)
3019 ia64_info
->rel_pltoff_sec
= NULL
;
3023 /* We use the reloc_count field as a counter if we need to
3024 copy relocs into the output file. */
3025 sec
->reloc_count
= 0;
3032 /* It's OK to base decisions on the section name, because none
3033 of the dynobj section names depend upon the input files. */
3034 name
= bfd_get_section_name (dynobj
, sec
);
3036 if (strcmp (name
, ".got.plt") == 0)
3038 else if (strncmp (name
, ".rel", 4) == 0)
3042 /* We use the reloc_count field as a counter if we need to
3043 copy relocs into the output file. */
3044 sec
->reloc_count
= 0;
3052 _bfd_strip_section_from_output (info
, sec
);
3055 /* Allocate memory for the section contents. */
3056 sec
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, sec
->_raw_size
);
3057 if (sec
->contents
== NULL
&& sec
->_raw_size
!= 0)
3062 if (elf_hash_table (info
)->dynamic_sections_created
)
3064 /* Add some entries to the .dynamic section. We fill in the values
3065 later (in finish_dynamic_sections) but we must add the entries now
3066 so that we get the correct size for the .dynamic section. */
3070 /* The DT_DEBUG entry is filled in by the dynamic linker and used
3072 #define add_dynamic_entry(TAG, VAL) \
3073 bfd_elfNN_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3075 if (!add_dynamic_entry (DT_DEBUG
, 0))
3079 if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE
, 0))
3081 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3086 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3087 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3088 || !add_dynamic_entry (DT_JMPREL
, 0))
3092 if (!add_dynamic_entry (DT_RELA
, 0)
3093 || !add_dynamic_entry (DT_RELASZ
, 0)
3094 || !add_dynamic_entry (DT_RELAENT
, sizeof (ElfNN_External_Rela
)))
3097 if (ia64_info
->reltext
)
3099 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3101 info
->flags
|= DF_TEXTREL
;
3105 /* ??? Perhaps force __gp local. */
3110 static bfd_reloc_status_type
3111 elfNN_ia64_install_value (abfd
, hit_addr
, v
, r_type
)
3115 unsigned int r_type
;
3117 const struct ia64_operand
*op
;
3118 int bigendian
= 0, shift
= 0;
3119 bfd_vma t0
, t1
, insn
, dword
;
3120 enum ia64_opnd opnd
;
3123 #ifdef BFD_HOST_U_64_BIT
3124 BFD_HOST_U_64_BIT val
= (BFD_HOST_U_64_BIT
) v
;
3129 opnd
= IA64_OPND_NIL
;
3134 return bfd_reloc_ok
;
3136 /* Instruction relocations. */
3139 case R_IA64_TPREL14
:
3140 case R_IA64_DTPREL14
:
3141 opnd
= IA64_OPND_IMM14
;
3144 case R_IA64_PCREL21F
: opnd
= IA64_OPND_TGT25
; break;
3145 case R_IA64_PCREL21M
: opnd
= IA64_OPND_TGT25b
; break;
3146 case R_IA64_PCREL60B
: opnd
= IA64_OPND_TGT64
; break;
3147 case R_IA64_PCREL21B
:
3148 case R_IA64_PCREL21BI
:
3149 opnd
= IA64_OPND_TGT25c
;
3153 case R_IA64_GPREL22
:
3154 case R_IA64_LTOFF22
:
3155 case R_IA64_LTOFF22X
:
3156 case R_IA64_PLTOFF22
:
3157 case R_IA64_PCREL22
:
3158 case R_IA64_LTOFF_FPTR22
:
3159 case R_IA64_TPREL22
:
3160 case R_IA64_DTPREL22
:
3161 case R_IA64_LTOFF_TPREL22
:
3162 case R_IA64_LTOFF_DTPMOD22
:
3163 case R_IA64_LTOFF_DTPREL22
:
3164 opnd
= IA64_OPND_IMM22
;
3168 case R_IA64_GPREL64I
:
3169 case R_IA64_LTOFF64I
:
3170 case R_IA64_PLTOFF64I
:
3171 case R_IA64_PCREL64I
:
3172 case R_IA64_FPTR64I
:
3173 case R_IA64_LTOFF_FPTR64I
:
3174 case R_IA64_TPREL64I
:
3175 case R_IA64_DTPREL64I
:
3176 opnd
= IA64_OPND_IMMU64
;
3179 /* Data relocations. */
3181 case R_IA64_DIR32MSB
:
3182 case R_IA64_GPREL32MSB
:
3183 case R_IA64_FPTR32MSB
:
3184 case R_IA64_PCREL32MSB
:
3185 case R_IA64_LTOFF_FPTR32MSB
:
3186 case R_IA64_SEGREL32MSB
:
3187 case R_IA64_SECREL32MSB
:
3188 case R_IA64_LTV32MSB
:
3189 case R_IA64_DTPREL32MSB
:
3190 size
= 4; bigendian
= 1;
3193 case R_IA64_DIR32LSB
:
3194 case R_IA64_GPREL32LSB
:
3195 case R_IA64_FPTR32LSB
:
3196 case R_IA64_PCREL32LSB
:
3197 case R_IA64_LTOFF_FPTR32LSB
:
3198 case R_IA64_SEGREL32LSB
:
3199 case R_IA64_SECREL32LSB
:
3200 case R_IA64_LTV32LSB
:
3201 case R_IA64_DTPREL32LSB
:
3202 size
= 4; bigendian
= 0;
3205 case R_IA64_DIR64MSB
:
3206 case R_IA64_GPREL64MSB
:
3207 case R_IA64_PLTOFF64MSB
:
3208 case R_IA64_FPTR64MSB
:
3209 case R_IA64_PCREL64MSB
:
3210 case R_IA64_LTOFF_FPTR64MSB
:
3211 case R_IA64_SEGREL64MSB
:
3212 case R_IA64_SECREL64MSB
:
3213 case R_IA64_LTV64MSB
:
3214 case R_IA64_TPREL64MSB
:
3215 case R_IA64_DTPMOD64MSB
:
3216 case R_IA64_DTPREL64MSB
:
3217 size
= 8; bigendian
= 1;
3220 case R_IA64_DIR64LSB
:
3221 case R_IA64_GPREL64LSB
:
3222 case R_IA64_PLTOFF64LSB
:
3223 case R_IA64_FPTR64LSB
:
3224 case R_IA64_PCREL64LSB
:
3225 case R_IA64_LTOFF_FPTR64LSB
:
3226 case R_IA64_SEGREL64LSB
:
3227 case R_IA64_SECREL64LSB
:
3228 case R_IA64_LTV64LSB
:
3229 case R_IA64_TPREL64LSB
:
3230 case R_IA64_DTPMOD64LSB
:
3231 case R_IA64_DTPREL64LSB
:
3232 size
= 8; bigendian
= 0;
3235 /* Unsupported / Dynamic relocations. */
3237 return bfd_reloc_notsupported
;
3242 case IA64_OPND_IMMU64
:
3243 hit_addr
-= (long) hit_addr
& 0x3;
3244 t0
= bfd_get_64 (abfd
, hit_addr
);
3245 t1
= bfd_get_64 (abfd
, hit_addr
+ 8);
3247 /* tmpl/s: bits 0.. 5 in t0
3248 slot 0: bits 5..45 in t0
3249 slot 1: bits 46..63 in t0, bits 0..22 in t1
3250 slot 2: bits 23..63 in t1 */
3252 /* First, clear the bits that form the 64 bit constant. */
3253 t0
&= ~(0x3ffffLL
<< 46);
3255 | (( (0x07fLL
<< 13) | (0x1ffLL
<< 27)
3256 | (0x01fLL
<< 22) | (0x001LL
<< 21)
3257 | (0x001LL
<< 36)) << 23));
3259 t0
|= ((val
>> 22) & 0x03ffffLL
) << 46; /* 18 lsbs of imm41 */
3260 t1
|= ((val
>> 40) & 0x7fffffLL
) << 0; /* 23 msbs of imm41 */
3261 t1
|= ( (((val
>> 0) & 0x07f) << 13) /* imm7b */
3262 | (((val
>> 7) & 0x1ff) << 27) /* imm9d */
3263 | (((val
>> 16) & 0x01f) << 22) /* imm5c */
3264 | (((val
>> 21) & 0x001) << 21) /* ic */
3265 | (((val
>> 63) & 0x001) << 36)) << 23; /* i */
3267 bfd_put_64 (abfd
, t0
, hit_addr
);
3268 bfd_put_64 (abfd
, t1
, hit_addr
+ 8);
3271 case IA64_OPND_TGT64
:
3272 hit_addr
-= (long) hit_addr
& 0x3;
3273 t0
= bfd_get_64 (abfd
, hit_addr
);
3274 t1
= bfd_get_64 (abfd
, hit_addr
+ 8);
3276 /* tmpl/s: bits 0.. 5 in t0
3277 slot 0: bits 5..45 in t0
3278 slot 1: bits 46..63 in t0, bits 0..22 in t1
3279 slot 2: bits 23..63 in t1 */
3281 /* First, clear the bits that form the 64 bit constant. */
3282 t0
&= ~(0x3ffffLL
<< 46);
3284 | ((1LL << 36 | 0xfffffLL
<< 13) << 23));
3287 t0
|= ((val
>> 20) & 0xffffLL
) << 2 << 46; /* 16 lsbs of imm39 */
3288 t1
|= ((val
>> 36) & 0x7fffffLL
) << 0; /* 23 msbs of imm39 */
3289 t1
|= ((((val
>> 0) & 0xfffffLL
) << 13) /* imm20b */
3290 | (((val
>> 59) & 0x1LL
) << 36)) << 23; /* i */
3292 bfd_put_64 (abfd
, t0
, hit_addr
);
3293 bfd_put_64 (abfd
, t1
, hit_addr
+ 8);
3297 switch ((long) hit_addr
& 0x3)
3299 case 0: shift
= 5; break;
3300 case 1: shift
= 14; hit_addr
+= 3; break;
3301 case 2: shift
= 23; hit_addr
+= 6; break;
3302 case 3: return bfd_reloc_notsupported
; /* shouldn't happen... */
3304 dword
= bfd_get_64 (abfd
, hit_addr
);
3305 insn
= (dword
>> shift
) & 0x1ffffffffffLL
;
3307 op
= elf64_ia64_operands
+ opnd
;
3308 err
= (*op
->insert
) (op
, val
, (ia64_insn
*)& insn
);
3310 return bfd_reloc_overflow
;
3312 dword
&= ~(0x1ffffffffffLL
<< shift
);
3313 dword
|= (insn
<< shift
);
3314 bfd_put_64 (abfd
, dword
, hit_addr
);
3318 /* A data relocation. */
3321 bfd_putb32 (val
, hit_addr
);
3323 bfd_putb64 (val
, hit_addr
);
3326 bfd_putl32 (val
, hit_addr
);
3328 bfd_putl64 (val
, hit_addr
);
3332 return bfd_reloc_ok
;
3336 elfNN_ia64_install_dyn_reloc (abfd
, info
, sec
, srel
, offset
, type
,
3339 struct bfd_link_info
*info
;
3347 Elf_Internal_Rela outrel
;
3350 BFD_ASSERT (dynindx
!= -1);
3351 outrel
.r_info
= ELFNN_R_INFO (dynindx
, type
);
3352 outrel
.r_addend
= addend
;
3353 outrel
.r_offset
= _bfd_elf_section_offset (abfd
, info
, sec
, offset
);
3354 if (outrel
.r_offset
>= (bfd_vma
) -2)
3356 /* Run for the hills. We shouldn't be outputting a relocation
3357 for this. So do what everyone else does and output a no-op. */
3358 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
3359 outrel
.r_addend
= 0;
3360 outrel
.r_offset
= 0;
3363 outrel
.r_offset
+= sec
->output_section
->vma
+ sec
->output_offset
;
3365 loc
= srel
->contents
;
3366 loc
+= srel
->reloc_count
++ * sizeof (ElfNN_External_Rela
);
3367 bfd_elfNN_swap_reloca_out (abfd
, &outrel
, loc
);
3368 BFD_ASSERT (sizeof (ElfNN_External_Rela
) * srel
->reloc_count
3369 <= srel
->_cooked_size
);
3372 /* Store an entry for target address TARGET_ADDR in the linkage table
3373 and return the gp-relative address of the linkage table entry. */
3376 set_got_entry (abfd
, info
, dyn_i
, dynindx
, addend
, value
, dyn_r_type
)
3378 struct bfd_link_info
*info
;
3379 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3383 unsigned int dyn_r_type
;
3385 struct elfNN_ia64_link_hash_table
*ia64_info
;
3390 ia64_info
= elfNN_ia64_hash_table (info
);
3391 got_sec
= ia64_info
->got_sec
;
3395 case R_IA64_TPREL64LSB
:
3396 done
= dyn_i
->tprel_done
;
3397 dyn_i
->tprel_done
= TRUE
;
3398 got_offset
= dyn_i
->tprel_offset
;
3400 case R_IA64_DTPMOD64LSB
:
3401 if (dyn_i
->dtpmod_offset
!= ia64_info
->self_dtpmod_offset
)
3403 done
= dyn_i
->dtpmod_done
;
3404 dyn_i
->dtpmod_done
= TRUE
;
3408 done
= ia64_info
->self_dtpmod_done
;
3409 ia64_info
->self_dtpmod_done
= TRUE
;
3412 got_offset
= dyn_i
->dtpmod_offset
;
3414 case R_IA64_DTPREL64LSB
:
3415 done
= dyn_i
->dtprel_done
;
3416 dyn_i
->dtprel_done
= TRUE
;
3417 got_offset
= dyn_i
->dtprel_offset
;
3420 done
= dyn_i
->got_done
;
3421 dyn_i
->got_done
= TRUE
;
3422 got_offset
= dyn_i
->got_offset
;
3426 BFD_ASSERT ((got_offset
& 7) == 0);
3430 /* Store the target address in the linkage table entry. */
3431 bfd_put_64 (abfd
, value
, got_sec
->contents
+ got_offset
);
3433 /* Install a dynamic relocation if needed. */
3434 if ((info
->shared
&& dyn_r_type
!= R_IA64_DTPREL64LSB
)
3435 || elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, info
)
3436 || elfNN_ia64_aix_vec (abfd
->xvec
)
3437 || (dynindx
!= -1 && dyn_r_type
== R_IA64_FPTR64LSB
))
3440 && dyn_r_type
!= R_IA64_TPREL64LSB
3441 && dyn_r_type
!= R_IA64_DTPMOD64LSB
3442 && dyn_r_type
!= R_IA64_DTPREL64LSB
)
3444 dyn_r_type
= R_IA64_REL64LSB
;
3449 if (bfd_big_endian (abfd
))
3453 case R_IA64_REL64LSB
:
3454 dyn_r_type
= R_IA64_REL64MSB
;
3456 case R_IA64_DIR64LSB
:
3457 dyn_r_type
= R_IA64_DIR64MSB
;
3459 case R_IA64_FPTR64LSB
:
3460 dyn_r_type
= R_IA64_FPTR64MSB
;
3462 case R_IA64_TPREL64LSB
:
3463 dyn_r_type
= R_IA64_TPREL64MSB
;
3465 case R_IA64_DTPMOD64LSB
:
3466 dyn_r_type
= R_IA64_DTPMOD64MSB
;
3468 case R_IA64_DTPREL64LSB
:
3469 dyn_r_type
= R_IA64_DTPREL64MSB
;
3477 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, got_sec
,
3478 ia64_info
->rel_got_sec
,
3479 got_offset
, dyn_r_type
,
3484 /* Return the address of the linkage table entry. */
3485 value
= (got_sec
->output_section
->vma
3486 + got_sec
->output_offset
3492 /* Fill in a function descriptor consisting of the function's code
3493 address and its global pointer. Return the descriptor's address. */
3496 set_fptr_entry (abfd
, info
, dyn_i
, value
)
3498 struct bfd_link_info
*info
;
3499 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3502 struct elfNN_ia64_link_hash_table
*ia64_info
;
3505 ia64_info
= elfNN_ia64_hash_table (info
);
3506 fptr_sec
= ia64_info
->fptr_sec
;
3508 if (!dyn_i
->fptr_done
)
3510 dyn_i
->fptr_done
= 1;
3512 /* Fill in the function descriptor. */
3513 bfd_put_64 (abfd
, value
, fptr_sec
->contents
+ dyn_i
->fptr_offset
);
3514 bfd_put_64 (abfd
, _bfd_get_gp_value (abfd
),
3515 fptr_sec
->contents
+ dyn_i
->fptr_offset
+ 8);
3518 /* Return the descriptor's address. */
3519 value
= (fptr_sec
->output_section
->vma
3520 + fptr_sec
->output_offset
3521 + dyn_i
->fptr_offset
);
3526 /* Fill in a PLTOFF entry consisting of the function's code address
3527 and its global pointer. Return the descriptor's address. */
3530 set_pltoff_entry (abfd
, info
, dyn_i
, value
, is_plt
)
3532 struct bfd_link_info
*info
;
3533 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3537 struct elfNN_ia64_link_hash_table
*ia64_info
;
3538 asection
*pltoff_sec
;
3540 ia64_info
= elfNN_ia64_hash_table (info
);
3541 pltoff_sec
= ia64_info
->pltoff_sec
;
3543 /* Don't do anything if this symbol uses a real PLT entry. In
3544 that case, we'll fill this in during finish_dynamic_symbol. */
3545 if ((! dyn_i
->want_plt
|| is_plt
)
3546 && !dyn_i
->pltoff_done
)
3548 bfd_vma gp
= _bfd_get_gp_value (abfd
);
3550 /* Fill in the function descriptor. */
3551 bfd_put_64 (abfd
, value
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
);
3552 bfd_put_64 (abfd
, gp
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
+ 8);
3554 /* Install dynamic relocations if needed. */
3555 if (!is_plt
&& info
->shared
)
3557 unsigned int dyn_r_type
;
3559 if (bfd_big_endian (abfd
))
3560 dyn_r_type
= R_IA64_REL64MSB
;
3562 dyn_r_type
= R_IA64_REL64LSB
;
3564 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
3565 ia64_info
->rel_pltoff_sec
,
3566 dyn_i
->pltoff_offset
,
3567 dyn_r_type
, 0, value
);
3568 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
3569 ia64_info
->rel_pltoff_sec
,
3570 dyn_i
->pltoff_offset
+ 8,
3574 dyn_i
->pltoff_done
= 1;
3577 /* Return the descriptor's address. */
3578 value
= (pltoff_sec
->output_section
->vma
3579 + pltoff_sec
->output_offset
3580 + dyn_i
->pltoff_offset
);
3585 /* Return the base VMA address which should be subtracted from real addresses
3586 when resolving @tprel() relocation.
3587 Main program TLS (whose template starts at PT_TLS p_vaddr)
3588 is assigned offset round(16, PT_TLS p_align). */
3591 elfNN_ia64_tprel_base (info
)
3592 struct bfd_link_info
*info
;
3594 struct elf_link_tls_segment
*tls_segment
3595 = elf_hash_table (info
)->tls_segment
;
3597 BFD_ASSERT (tls_segment
!= NULL
);
3598 return (tls_segment
->start
3599 - align_power ((bfd_vma
) 16, tls_segment
->align
));
3602 /* Return the base VMA address which should be subtracted from real addresses
3603 when resolving @dtprel() relocation.
3604 This is PT_TLS segment p_vaddr. */
3607 elfNN_ia64_dtprel_base (info
)
3608 struct bfd_link_info
*info
;
3610 BFD_ASSERT (elf_hash_table (info
)->tls_segment
!= NULL
);
3611 return elf_hash_table (info
)->tls_segment
->start
;
3614 /* Called through qsort to sort the .IA_64.unwind section during a
3615 non-relocatable link. Set elfNN_ia64_unwind_entry_compare_bfd
3616 to the output bfd so we can do proper endianness frobbing. */
3618 static bfd
*elfNN_ia64_unwind_entry_compare_bfd
;
3621 elfNN_ia64_unwind_entry_compare (a
, b
)
3627 av
= bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd
, a
);
3628 bv
= bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd
, b
);
3630 return (av
< bv
? -1 : av
> bv
? 1 : 0);
3633 /* Make sure we've got ourselves a nice fat __gp value. */
3635 elfNN_ia64_choose_gp (abfd
, info
)
3637 struct bfd_link_info
*info
;
3639 bfd_vma min_vma
= (bfd_vma
) -1, max_vma
= 0;
3640 bfd_vma min_short_vma
= min_vma
, max_short_vma
= 0;
3641 struct elf_link_hash_entry
*gp
;
3644 struct elfNN_ia64_link_hash_table
*ia64_info
;
3646 ia64_info
= elfNN_ia64_hash_table (info
);
3648 /* Find the min and max vma of all sections marked short. Also collect
3649 min and max vma of any type, for use in selecting a nice gp. */
3650 for (os
= abfd
->sections
; os
; os
= os
->next
)
3654 if ((os
->flags
& SEC_ALLOC
) == 0)
3658 hi
= os
->vma
+ os
->_raw_size
;
3666 if (os
->flags
& SEC_SMALL_DATA
)
3668 if (min_short_vma
> lo
)
3670 if (max_short_vma
< hi
)
3675 /* See if the user wants to force a value. */
3676 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
3680 && (gp
->root
.type
== bfd_link_hash_defined
3681 || gp
->root
.type
== bfd_link_hash_defweak
))
3683 asection
*gp_sec
= gp
->root
.u
.def
.section
;
3684 gp_val
= (gp
->root
.u
.def
.value
3685 + gp_sec
->output_section
->vma
3686 + gp_sec
->output_offset
);
3690 /* Pick a sensible value. */
3692 asection
*got_sec
= ia64_info
->got_sec
;
3694 /* Start with just the address of the .got. */
3696 gp_val
= got_sec
->output_section
->vma
;
3697 else if (max_short_vma
!= 0)
3698 gp_val
= min_short_vma
;
3702 /* If it is possible to address the entire image, but we
3703 don't with the choice above, adjust. */
3704 if (max_vma
- min_vma
< 0x400000
3705 && max_vma
- gp_val
<= 0x200000
3706 && gp_val
- min_vma
> 0x200000)
3707 gp_val
= min_vma
+ 0x200000;
3708 else if (max_short_vma
!= 0)
3710 /* If we don't cover all the short data, adjust. */
3711 if (max_short_vma
- gp_val
>= 0x200000)
3712 gp_val
= min_short_vma
+ 0x200000;
3714 /* If we're addressing stuff past the end, adjust back. */
3715 if (gp_val
> max_vma
)
3716 gp_val
= max_vma
- 0x200000 + 8;
3720 /* Validate whether all SHF_IA_64_SHORT sections are within
3721 range of the chosen GP. */
3723 if (max_short_vma
!= 0)
3725 if (max_short_vma
- min_short_vma
>= 0x400000)
3727 (*_bfd_error_handler
)
3728 (_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
3729 bfd_get_filename (abfd
),
3730 (unsigned long) (max_short_vma
- min_short_vma
));
3733 else if ((gp_val
> min_short_vma
3734 && gp_val
- min_short_vma
> 0x200000)
3735 || (gp_val
< max_short_vma
3736 && max_short_vma
- gp_val
>= 0x200000))
3738 (*_bfd_error_handler
)
3739 (_("%s: __gp does not cover short data segment"),
3740 bfd_get_filename (abfd
));
3745 _bfd_set_gp_value (abfd
, gp_val
);
3751 elfNN_ia64_final_link (abfd
, info
)
3753 struct bfd_link_info
*info
;
3755 struct elfNN_ia64_link_hash_table
*ia64_info
;
3756 asection
*unwind_output_sec
;
3758 ia64_info
= elfNN_ia64_hash_table (info
);
3760 /* Make sure we've got ourselves a nice fat __gp value. */
3761 if (!info
->relocateable
)
3763 bfd_vma gp_val
= _bfd_get_gp_value (abfd
);
3764 struct elf_link_hash_entry
*gp
;
3768 if (! elfNN_ia64_choose_gp (abfd
, info
))
3770 gp_val
= _bfd_get_gp_value (abfd
);
3773 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
3777 gp
->root
.type
= bfd_link_hash_defined
;
3778 gp
->root
.u
.def
.value
= gp_val
;
3779 gp
->root
.u
.def
.section
= bfd_abs_section_ptr
;
3783 /* If we're producing a final executable, we need to sort the contents
3784 of the .IA_64.unwind section. Force this section to be relocated
3785 into memory rather than written immediately to the output file. */
3786 unwind_output_sec
= NULL
;
3787 if (!info
->relocateable
)
3789 asection
*s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_unwind
);
3792 unwind_output_sec
= s
->output_section
;
3793 unwind_output_sec
->contents
3794 = bfd_malloc (unwind_output_sec
->_raw_size
);
3795 if (unwind_output_sec
->contents
== NULL
)
3800 /* Invoke the regular ELF backend linker to do all the work. */
3801 if (!bfd_elfNN_bfd_final_link (abfd
, info
))
3804 if (unwind_output_sec
)
3806 elfNN_ia64_unwind_entry_compare_bfd
= abfd
;
3807 qsort (unwind_output_sec
->contents
,
3808 (size_t) (unwind_output_sec
->_raw_size
/ 24),
3810 elfNN_ia64_unwind_entry_compare
);
3812 if (! bfd_set_section_contents (abfd
, unwind_output_sec
,
3813 unwind_output_sec
->contents
, (bfd_vma
) 0,
3814 unwind_output_sec
->_raw_size
))
3822 elfNN_ia64_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
3823 contents
, relocs
, local_syms
, local_sections
)
3825 struct bfd_link_info
*info
;
3827 asection
*input_section
;
3829 Elf_Internal_Rela
*relocs
;
3830 Elf_Internal_Sym
*local_syms
;
3831 asection
**local_sections
;
3833 struct elfNN_ia64_link_hash_table
*ia64_info
;
3834 Elf_Internal_Shdr
*symtab_hdr
;
3835 Elf_Internal_Rela
*rel
;
3836 Elf_Internal_Rela
*relend
;
3838 bfd_boolean ret_val
= TRUE
; /* for non-fatal errors */
3841 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3842 ia64_info
= elfNN_ia64_hash_table (info
);
3844 /* Infect various flags from the input section to the output section. */
3845 if (info
->relocateable
)
3849 flags
= elf_section_data(input_section
)->this_hdr
.sh_flags
;
3850 flags
&= SHF_IA_64_NORECOV
;
3852 elf_section_data(input_section
->output_section
)
3853 ->this_hdr
.sh_flags
|= flags
;
3857 gp_val
= _bfd_get_gp_value (output_bfd
);
3858 srel
= get_reloc_section (input_bfd
, ia64_info
, input_section
, FALSE
);
3861 relend
= relocs
+ input_section
->reloc_count
;
3862 for (; rel
< relend
; ++rel
)
3864 struct elf_link_hash_entry
*h
;
3865 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3866 bfd_reloc_status_type r
;
3867 reloc_howto_type
*howto
;
3868 unsigned long r_symndx
;
3869 Elf_Internal_Sym
*sym
;
3870 unsigned int r_type
;
3874 bfd_boolean dynamic_symbol_p
;
3875 bfd_boolean undef_weak_ref
;
3877 r_type
= ELFNN_R_TYPE (rel
->r_info
);
3878 if (r_type
> R_IA64_MAX_RELOC_CODE
)
3880 (*_bfd_error_handler
)
3881 (_("%s: unknown relocation type %d"),
3882 bfd_archive_filename (input_bfd
), (int)r_type
);
3883 bfd_set_error (bfd_error_bad_value
);
3888 howto
= lookup_howto (r_type
);
3889 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
3893 undef_weak_ref
= FALSE
;
3895 if (r_symndx
< symtab_hdr
->sh_info
)
3897 /* Reloc against local symbol. */
3898 sym
= local_syms
+ r_symndx
;
3899 sym_sec
= local_sections
[r_symndx
];
3900 value
= _bfd_elf_rela_local_sym (output_bfd
, sym
, sym_sec
, rel
);
3901 if ((sym_sec
->flags
& SEC_MERGE
)
3902 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3903 && sym_sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
)
3905 struct elfNN_ia64_local_hash_entry
*loc_h
;
3907 loc_h
= get_local_sym_hash (ia64_info
, input_bfd
, rel
, FALSE
);
3908 if (loc_h
&& ! loc_h
->sec_merge_done
)
3910 struct elfNN_ia64_dyn_sym_info
*dynent
;
3913 for (dynent
= loc_h
->info
; dynent
; dynent
= dynent
->next
)
3917 _bfd_merged_section_offset (output_bfd
, &msec
,
3918 elf_section_data (msec
)->
3923 dynent
->addend
-= sym
->st_value
;
3924 dynent
->addend
+= msec
->output_section
->vma
3925 + msec
->output_offset
3926 - sym_sec
->output_section
->vma
3927 - sym_sec
->output_offset
;
3929 loc_h
->sec_merge_done
= 1;
3937 /* Reloc against global symbol. */
3938 indx
= r_symndx
- symtab_hdr
->sh_info
;
3939 h
= elf_sym_hashes (input_bfd
)[indx
];
3940 while (h
->root
.type
== bfd_link_hash_indirect
3941 || h
->root
.type
== bfd_link_hash_warning
)
3942 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3945 if (h
->root
.type
== bfd_link_hash_defined
3946 || h
->root
.type
== bfd_link_hash_defweak
)
3948 sym_sec
= h
->root
.u
.def
.section
;
3950 /* Detect the cases that sym_sec->output_section is
3951 expected to be NULL -- all cases in which the symbol
3952 is defined in another shared module. This includes
3953 PLT relocs for which we've created a PLT entry and
3954 other relocs for which we're prepared to create
3955 dynamic relocations. */
3956 /* ??? Just accept it NULL and continue. */
3958 if (sym_sec
->output_section
!= NULL
)
3960 value
= (h
->root
.u
.def
.value
3961 + sym_sec
->output_section
->vma
3962 + sym_sec
->output_offset
);
3965 else if (h
->root
.type
== bfd_link_hash_undefweak
)
3966 undef_weak_ref
= TRUE
;
3967 else if (info
->shared
3968 && !info
->no_undefined
3969 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
3973 if (! ((*info
->callbacks
->undefined_symbol
)
3974 (info
, h
->root
.root
.string
, input_bfd
,
3975 input_section
, rel
->r_offset
,
3976 (!info
->shared
|| info
->no_undefined
3977 || ELF_ST_VISIBILITY (h
->other
)))))
3983 hit_addr
= contents
+ rel
->r_offset
;
3984 value
+= rel
->r_addend
;
3985 dynamic_symbol_p
= elfNN_ia64_dynamic_symbol_p (h
, info
);
3996 case R_IA64_DIR32MSB
:
3997 case R_IA64_DIR32LSB
:
3998 case R_IA64_DIR64MSB
:
3999 case R_IA64_DIR64LSB
:
4000 /* Install a dynamic relocation for this reloc. */
4001 if ((dynamic_symbol_p
|| info
->shared
4002 || (elfNN_ia64_aix_vec (info
->hash
->creator
)
4003 /* Don't emit relocs for __GLOB_DATA_PTR on AIX. */
4004 && (!h
|| strcmp (h
->root
.root
.string
,
4005 "__GLOB_DATA_PTR") != 0)))
4007 && (input_section
->flags
& SEC_ALLOC
) != 0)
4009 unsigned int dyn_r_type
;
4013 BFD_ASSERT (srel
!= NULL
);
4015 /* If we don't need dynamic symbol lookup, find a
4016 matching RELATIVE relocation. */
4017 dyn_r_type
= r_type
;
4018 if (dynamic_symbol_p
)
4020 dynindx
= h
->dynindx
;
4021 addend
= rel
->r_addend
;
4028 case R_IA64_DIR32MSB
:
4029 dyn_r_type
= R_IA64_REL32MSB
;
4031 case R_IA64_DIR32LSB
:
4032 dyn_r_type
= R_IA64_REL32LSB
;
4034 case R_IA64_DIR64MSB
:
4035 dyn_r_type
= R_IA64_REL64MSB
;
4037 case R_IA64_DIR64LSB
:
4038 dyn_r_type
= R_IA64_REL64LSB
;
4042 /* We can't represent this without a dynamic symbol.
4043 Adjust the relocation to be against an output
4044 section symbol, which are always present in the
4045 dynamic symbol table. */
4046 /* ??? People shouldn't be doing non-pic code in
4047 shared libraries. Hork. */
4048 (*_bfd_error_handler
)
4049 (_("%s: linking non-pic code in a shared library"),
4050 bfd_archive_filename (input_bfd
));
4058 if (elfNN_ia64_aix_vec (info
->hash
->creator
))
4059 rel
->r_addend
= value
;
4060 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4061 srel
, rel
->r_offset
, dyn_r_type
,
4066 case R_IA64_LTV32MSB
:
4067 case R_IA64_LTV32LSB
:
4068 case R_IA64_LTV64MSB
:
4069 case R_IA64_LTV64LSB
:
4070 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4073 case R_IA64_GPREL22
:
4074 case R_IA64_GPREL64I
:
4075 case R_IA64_GPREL32MSB
:
4076 case R_IA64_GPREL32LSB
:
4077 case R_IA64_GPREL64MSB
:
4078 case R_IA64_GPREL64LSB
:
4079 if (dynamic_symbol_p
)
4081 (*_bfd_error_handler
)
4082 (_("%s: @gprel relocation against dynamic symbol %s"),
4083 bfd_archive_filename (input_bfd
), h
->root
.root
.string
);
4088 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4091 case R_IA64_LTOFF22
:
4092 case R_IA64_LTOFF22X
:
4093 case R_IA64_LTOFF64I
:
4094 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4095 value
= set_got_entry (input_bfd
, info
, dyn_i
, (h
? h
->dynindx
: -1),
4096 rel
->r_addend
, value
, R_IA64_DIR64LSB
);
4098 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4101 case R_IA64_PLTOFF22
:
4102 case R_IA64_PLTOFF64I
:
4103 case R_IA64_PLTOFF64MSB
:
4104 case R_IA64_PLTOFF64LSB
:
4105 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4106 value
= set_pltoff_entry (output_bfd
, info
, dyn_i
, value
, FALSE
);
4108 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4111 case R_IA64_FPTR64I
:
4112 case R_IA64_FPTR32MSB
:
4113 case R_IA64_FPTR32LSB
:
4114 case R_IA64_FPTR64MSB
:
4115 case R_IA64_FPTR64LSB
:
4116 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4117 if (dyn_i
->want_fptr
)
4119 if (!undef_weak_ref
)
4120 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
4126 /* Otherwise, we expect the dynamic linker to create
4131 if (h
->dynindx
!= -1)
4132 dynindx
= h
->dynindx
;
4134 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4135 (info
, h
->root
.u
.def
.section
->owner
,
4136 global_sym_index (h
)));
4140 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4141 (info
, input_bfd
, (long) r_symndx
));
4144 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4145 srel
, rel
->r_offset
, r_type
,
4146 dynindx
, rel
->r_addend
);
4150 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4153 case R_IA64_LTOFF_FPTR22
:
4154 case R_IA64_LTOFF_FPTR64I
:
4155 case R_IA64_LTOFF_FPTR32MSB
:
4156 case R_IA64_LTOFF_FPTR32LSB
:
4157 case R_IA64_LTOFF_FPTR64MSB
:
4158 case R_IA64_LTOFF_FPTR64LSB
:
4162 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4163 if (dyn_i
->want_fptr
)
4165 BFD_ASSERT (h
== NULL
|| h
->dynindx
== -1)
4166 if (!undef_weak_ref
)
4167 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
4172 /* Otherwise, we expect the dynamic linker to create
4176 if (h
->dynindx
!= -1)
4177 dynindx
= h
->dynindx
;
4179 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4180 (info
, h
->root
.u
.def
.section
->owner
,
4181 global_sym_index (h
)));
4184 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4185 (info
, input_bfd
, (long) r_symndx
));
4189 value
= set_got_entry (output_bfd
, info
, dyn_i
, dynindx
,
4190 rel
->r_addend
, value
, R_IA64_FPTR64LSB
);
4192 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4196 case R_IA64_PCREL32MSB
:
4197 case R_IA64_PCREL32LSB
:
4198 case R_IA64_PCREL64MSB
:
4199 case R_IA64_PCREL64LSB
:
4200 /* Install a dynamic relocation for this reloc. */
4201 if ((dynamic_symbol_p
4202 || elfNN_ia64_aix_vec (info
->hash
->creator
))
4205 BFD_ASSERT (srel
!= NULL
);
4207 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4208 srel
, rel
->r_offset
, r_type
,
4209 h
->dynindx
, rel
->r_addend
);
4213 case R_IA64_PCREL21B
:
4214 case R_IA64_PCREL60B
:
4215 /* We should have created a PLT entry for any dynamic symbol. */
4218 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, FALSE
);
4220 if (dyn_i
&& dyn_i
->want_plt2
)
4222 /* Should have caught this earlier. */
4223 BFD_ASSERT (rel
->r_addend
== 0);
4225 value
= (ia64_info
->plt_sec
->output_section
->vma
4226 + ia64_info
->plt_sec
->output_offset
4227 + dyn_i
->plt2_offset
);
4231 /* Since there's no PLT entry, Validate that this is
4233 BFD_ASSERT (undef_weak_ref
|| sym_sec
->output_section
!= NULL
);
4235 /* If the symbol is undef_weak, we shouldn't be trying
4236 to call it. There's every chance that we'd wind up
4237 with an out-of-range fixup here. Don't bother setting
4238 any value at all. */
4244 case R_IA64_PCREL21BI
:
4245 case R_IA64_PCREL21F
:
4246 case R_IA64_PCREL21M
:
4247 case R_IA64_PCREL22
:
4248 case R_IA64_PCREL64I
:
4249 /* The PCREL21BI reloc is specifically not intended for use with
4250 dynamic relocs. PCREL21F and PCREL21M are used for speculation
4251 fixup code, and thus probably ought not be dynamic. The
4252 PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs. */
4253 if (dynamic_symbol_p
)
4257 if (r_type
== R_IA64_PCREL21BI
)
4258 msg
= _("%s: @internal branch to dynamic symbol %s");
4259 else if (r_type
== R_IA64_PCREL21F
|| r_type
== R_IA64_PCREL21M
)
4260 msg
= _("%s: speculation fixup to dynamic symbol %s");
4262 msg
= _("%s: @pcrel relocation against dynamic symbol %s");
4263 (*_bfd_error_handler
) (msg
, bfd_archive_filename (input_bfd
),
4264 h
->root
.root
.string
);
4271 /* Make pc-relative. */
4272 value
-= (input_section
->output_section
->vma
4273 + input_section
->output_offset
4274 + rel
->r_offset
) & ~ (bfd_vma
) 0x3;
4275 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4278 case R_IA64_SEGREL32MSB
:
4279 case R_IA64_SEGREL32LSB
:
4280 case R_IA64_SEGREL64MSB
:
4281 case R_IA64_SEGREL64LSB
:
4284 /* If the input section was discarded from the output, then
4290 struct elf_segment_map
*m
;
4291 Elf_Internal_Phdr
*p
;
4293 /* Find the segment that contains the output_section. */
4294 for (m
= elf_tdata (output_bfd
)->segment_map
,
4295 p
= elf_tdata (output_bfd
)->phdr
;
4300 for (i
= m
->count
- 1; i
>= 0; i
--)
4301 if (m
->sections
[i
] == sym_sec
->output_section
)
4309 r
= bfd_reloc_notsupported
;
4313 /* The VMA of the segment is the vaddr of the associated
4315 if (value
> p
->p_vaddr
)
4316 value
-= p
->p_vaddr
;
4319 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
,
4325 case R_IA64_SECREL32MSB
:
4326 case R_IA64_SECREL32LSB
:
4327 case R_IA64_SECREL64MSB
:
4328 case R_IA64_SECREL64LSB
:
4329 /* Make output-section relative. */
4330 if (value
> input_section
->output_section
->vma
)
4331 value
-= input_section
->output_section
->vma
;
4334 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4337 case R_IA64_IPLTMSB
:
4338 case R_IA64_IPLTLSB
:
4339 /* Install a dynamic relocation for this reloc. */
4340 if ((dynamic_symbol_p
|| info
->shared
)
4341 && (input_section
->flags
& SEC_ALLOC
) != 0)
4343 BFD_ASSERT (srel
!= NULL
);
4345 /* If we don't need dynamic symbol lookup, install two
4346 RELATIVE relocations. */
4347 if (! dynamic_symbol_p
)
4349 unsigned int dyn_r_type
;
4351 if (r_type
== R_IA64_IPLTMSB
)
4352 dyn_r_type
= R_IA64_REL64MSB
;
4354 dyn_r_type
= R_IA64_REL64LSB
;
4356 elfNN_ia64_install_dyn_reloc (output_bfd
, info
,
4358 srel
, rel
->r_offset
,
4359 dyn_r_type
, 0, value
);
4360 elfNN_ia64_install_dyn_reloc (output_bfd
, info
,
4362 srel
, rel
->r_offset
+ 8,
4363 dyn_r_type
, 0, gp_val
);
4366 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4367 srel
, rel
->r_offset
, r_type
,
4368 h
->dynindx
, rel
->r_addend
);
4371 if (r_type
== R_IA64_IPLTMSB
)
4372 r_type
= R_IA64_DIR64MSB
;
4374 r_type
= R_IA64_DIR64LSB
;
4375 elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4376 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
+ 8, gp_val
,
4380 case R_IA64_TPREL14
:
4381 case R_IA64_TPREL22
:
4382 case R_IA64_TPREL64I
:
4383 value
-= elfNN_ia64_tprel_base (info
);
4384 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4387 case R_IA64_DTPREL14
:
4388 case R_IA64_DTPREL22
:
4389 case R_IA64_DTPREL64I
:
4390 case R_IA64_DTPREL64LSB
:
4391 case R_IA64_DTPREL64MSB
:
4392 value
-= elfNN_ia64_dtprel_base (info
);
4393 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4396 case R_IA64_LTOFF_TPREL22
:
4397 case R_IA64_LTOFF_DTPMOD22
:
4398 case R_IA64_LTOFF_DTPREL22
:
4401 long dynindx
= h
? h
->dynindx
: -1;
4402 bfd_vma r_addend
= rel
->r_addend
;
4407 case R_IA64_LTOFF_TPREL22
:
4408 if (!dynamic_symbol_p
)
4411 value
-= elfNN_ia64_tprel_base (info
);
4414 r_addend
+= value
- elfNN_ia64_dtprel_base (info
);
4418 got_r_type
= R_IA64_TPREL64LSB
;
4420 case R_IA64_LTOFF_DTPMOD22
:
4421 if (!dynamic_symbol_p
&& !info
->shared
)
4423 got_r_type
= R_IA64_DTPMOD64LSB
;
4425 case R_IA64_LTOFF_DTPREL22
:
4426 if (!dynamic_symbol_p
)
4427 value
-= elfNN_ia64_dtprel_base (info
);
4428 got_r_type
= R_IA64_DTPREL64LSB
;
4431 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4432 value
= set_got_entry (input_bfd
, info
, dyn_i
, dynindx
, r_addend
,
4435 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
,
4441 r
= bfd_reloc_notsupported
;
4450 case bfd_reloc_undefined
:
4451 /* This can happen for global table relative relocs if
4452 __gp is undefined. This is a panic situation so we
4453 don't try to continue. */
4454 (*info
->callbacks
->undefined_symbol
)
4455 (info
, "__gp", input_bfd
, input_section
, rel
->r_offset
, 1);
4458 case bfd_reloc_notsupported
:
4463 name
= h
->root
.root
.string
;
4466 name
= bfd_elf_string_from_elf_section (input_bfd
,
4467 symtab_hdr
->sh_link
,
4472 name
= bfd_section_name (input_bfd
, input_section
);
4474 if (!(*info
->callbacks
->warning
) (info
, _("unsupported reloc"),
4476 input_section
, rel
->r_offset
))
4482 case bfd_reloc_dangerous
:
4483 case bfd_reloc_outofrange
:
4484 case bfd_reloc_overflow
:
4490 name
= h
->root
.root
.string
;
4493 name
= bfd_elf_string_from_elf_section (input_bfd
,
4494 symtab_hdr
->sh_link
,
4499 name
= bfd_section_name (input_bfd
, input_section
);
4501 if (!(*info
->callbacks
->reloc_overflow
) (info
, name
,
4518 elfNN_ia64_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
4520 struct bfd_link_info
*info
;
4521 struct elf_link_hash_entry
*h
;
4522 Elf_Internal_Sym
*sym
;
4524 struct elfNN_ia64_link_hash_table
*ia64_info
;
4525 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
4527 ia64_info
= elfNN_ia64_hash_table (info
);
4528 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, FALSE
);
4530 /* Fill in the PLT data, if required. */
4531 if (dyn_i
&& dyn_i
->want_plt
)
4533 Elf_Internal_Rela outrel
;
4536 bfd_vma plt_addr
, pltoff_addr
, gp_val
, index
;
4538 gp_val
= _bfd_get_gp_value (output_bfd
);
4540 /* Initialize the minimal PLT entry. */
4542 index
= (dyn_i
->plt_offset
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
4543 plt_sec
= ia64_info
->plt_sec
;
4544 loc
= plt_sec
->contents
+ dyn_i
->plt_offset
;
4546 memcpy (loc
, plt_min_entry
, PLT_MIN_ENTRY_SIZE
);
4547 elfNN_ia64_install_value (output_bfd
, loc
, index
, R_IA64_IMM22
);
4548 elfNN_ia64_install_value (output_bfd
, loc
+2, -dyn_i
->plt_offset
,
4551 plt_addr
= (plt_sec
->output_section
->vma
4552 + plt_sec
->output_offset
4553 + dyn_i
->plt_offset
);
4554 pltoff_addr
= set_pltoff_entry (output_bfd
, info
, dyn_i
, plt_addr
, TRUE
);
4556 /* Initialize the FULL PLT entry, if needed. */
4557 if (dyn_i
->want_plt2
)
4559 loc
= plt_sec
->contents
+ dyn_i
->plt2_offset
;
4561 memcpy (loc
, plt_full_entry
, PLT_FULL_ENTRY_SIZE
);
4562 elfNN_ia64_install_value (output_bfd
, loc
, pltoff_addr
- gp_val
,
4565 /* Mark the symbol as undefined, rather than as defined in the
4566 plt section. Leave the value alone. */
4567 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
4568 first place. But perhaps elflink.h did some for us. */
4569 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
4570 sym
->st_shndx
= SHN_UNDEF
;
4573 /* Create the dynamic relocation. */
4574 outrel
.r_offset
= pltoff_addr
;
4575 if (bfd_little_endian (output_bfd
))
4576 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_IA64_IPLTLSB
);
4578 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_IA64_IPLTMSB
);
4579 outrel
.r_addend
= 0;
4581 /* This is fun. In the .IA_64.pltoff section, we've got entries
4582 that correspond both to real PLT entries, and those that
4583 happened to resolve to local symbols but need to be created
4584 to satisfy @pltoff relocations. The .rela.IA_64.pltoff
4585 relocations for the real PLT should come at the end of the
4586 section, so that they can be indexed by plt entry at runtime.
4588 We emitted all of the relocations for the non-PLT @pltoff
4589 entries during relocate_section. So we can consider the
4590 existing sec->reloc_count to be the base of the array of
4593 loc
= ia64_info
->rel_pltoff_sec
->contents
;
4594 loc
+= ((ia64_info
->rel_pltoff_sec
->reloc_count
+ index
)
4595 * sizeof (Elf64_External_Rela
));
4596 bfd_elfNN_swap_reloca_out (output_bfd
, &outrel
, loc
);
4599 /* Mark some specially defined symbols as absolute. */
4600 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
4601 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
4602 || strcmp (h
->root
.root
.string
, "_PROCEDURE_LINKAGE_TABLE_") == 0)
4603 sym
->st_shndx
= SHN_ABS
;
4609 elfNN_ia64_finish_dynamic_sections (abfd
, info
)
4611 struct bfd_link_info
*info
;
4613 struct elfNN_ia64_link_hash_table
*ia64_info
;
4616 ia64_info
= elfNN_ia64_hash_table (info
);
4617 dynobj
= ia64_info
->root
.dynobj
;
4619 if (elf_hash_table (info
)->dynamic_sections_created
)
4621 ElfNN_External_Dyn
*dyncon
, *dynconend
;
4622 asection
*sdyn
, *sgotplt
;
4625 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
4626 sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
4627 BFD_ASSERT (sdyn
!= NULL
);
4628 dyncon
= (ElfNN_External_Dyn
*) sdyn
->contents
;
4629 dynconend
= (ElfNN_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
4631 gp_val
= _bfd_get_gp_value (abfd
);
4633 for (; dyncon
< dynconend
; dyncon
++)
4635 Elf_Internal_Dyn dyn
;
4637 bfd_elfNN_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4642 dyn
.d_un
.d_ptr
= gp_val
;
4646 dyn
.d_un
.d_val
= (ia64_info
->minplt_entries
4647 * sizeof (ElfNN_External_Rela
));
4651 /* See the comment above in finish_dynamic_symbol. */
4652 dyn
.d_un
.d_ptr
= (ia64_info
->rel_pltoff_sec
->output_section
->vma
4653 + ia64_info
->rel_pltoff_sec
->output_offset
4654 + (ia64_info
->rel_pltoff_sec
->reloc_count
4655 * sizeof (ElfNN_External_Rela
)));
4658 case DT_IA_64_PLT_RESERVE
:
4659 dyn
.d_un
.d_ptr
= (sgotplt
->output_section
->vma
4660 + sgotplt
->output_offset
);
4664 /* Do not have RELASZ include JMPREL. This makes things
4665 easier on ld.so. This is not what the rest of BFD set up. */
4666 dyn
.d_un
.d_val
-= (ia64_info
->minplt_entries
4667 * sizeof (ElfNN_External_Rela
));
4671 bfd_elfNN_swap_dyn_out (abfd
, &dyn
, dyncon
);
4674 /* Initialize the PLT0 entry. */
4675 if (ia64_info
->plt_sec
)
4677 bfd_byte
*loc
= ia64_info
->plt_sec
->contents
;
4680 memcpy (loc
, plt_header
, PLT_HEADER_SIZE
);
4682 pltres
= (sgotplt
->output_section
->vma
4683 + sgotplt
->output_offset
4686 elfNN_ia64_install_value (abfd
, loc
+1, pltres
, R_IA64_GPREL22
);
4693 /* ELF file flag handling: */
4695 /* Function to keep IA-64 specific file flags. */
4697 elfNN_ia64_set_private_flags (abfd
, flags
)
4701 BFD_ASSERT (!elf_flags_init (abfd
)
4702 || elf_elfheader (abfd
)->e_flags
== flags
);
4704 elf_elfheader (abfd
)->e_flags
= flags
;
4705 elf_flags_init (abfd
) = TRUE
;
4709 /* Merge backend specific data from an object file to the output
4710 object file when linking. */
4712 elfNN_ia64_merge_private_bfd_data (ibfd
, obfd
)
4717 bfd_boolean ok
= TRUE
;
4719 /* Don't even pretend to support mixed-format linking. */
4720 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4721 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4724 in_flags
= elf_elfheader (ibfd
)->e_flags
;
4725 out_flags
= elf_elfheader (obfd
)->e_flags
;
4727 if (! elf_flags_init (obfd
))
4729 elf_flags_init (obfd
) = TRUE
;
4730 elf_elfheader (obfd
)->e_flags
= in_flags
;
4732 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
4733 && bfd_get_arch_info (obfd
)->the_default
)
4735 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
4736 bfd_get_mach (ibfd
));
4742 /* Check flag compatibility. */
4743 if (in_flags
== out_flags
)
4746 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
4747 if (!(in_flags
& EF_IA_64_REDUCEDFP
) && (out_flags
& EF_IA_64_REDUCEDFP
))
4748 elf_elfheader (obfd
)->e_flags
&= ~EF_IA_64_REDUCEDFP
;
4750 if ((in_flags
& EF_IA_64_TRAPNIL
) != (out_flags
& EF_IA_64_TRAPNIL
))
4752 (*_bfd_error_handler
)
4753 (_("%s: linking trap-on-NULL-dereference with non-trapping files"),
4754 bfd_archive_filename (ibfd
));
4756 bfd_set_error (bfd_error_bad_value
);
4759 if ((in_flags
& EF_IA_64_BE
) != (out_flags
& EF_IA_64_BE
))
4761 (*_bfd_error_handler
)
4762 (_("%s: linking big-endian files with little-endian files"),
4763 bfd_archive_filename (ibfd
));
4765 bfd_set_error (bfd_error_bad_value
);
4768 if ((in_flags
& EF_IA_64_ABI64
) != (out_flags
& EF_IA_64_ABI64
))
4770 (*_bfd_error_handler
)
4771 (_("%s: linking 64-bit files with 32-bit files"),
4772 bfd_archive_filename (ibfd
));
4774 bfd_set_error (bfd_error_bad_value
);
4777 if ((in_flags
& EF_IA_64_CONS_GP
) != (out_flags
& EF_IA_64_CONS_GP
))
4779 (*_bfd_error_handler
)
4780 (_("%s: linking constant-gp files with non-constant-gp files"),
4781 bfd_archive_filename (ibfd
));
4783 bfd_set_error (bfd_error_bad_value
);
4786 if ((in_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
)
4787 != (out_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
4789 (*_bfd_error_handler
)
4790 (_("%s: linking auto-pic files with non-auto-pic files"),
4791 bfd_archive_filename (ibfd
));
4793 bfd_set_error (bfd_error_bad_value
);
4801 elfNN_ia64_print_private_bfd_data (abfd
, ptr
)
4805 FILE *file
= (FILE *) ptr
;
4806 flagword flags
= elf_elfheader (abfd
)->e_flags
;
4808 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
4810 fprintf (file
, "private flags = %s%s%s%s%s%s%s%s\n",
4811 (flags
& EF_IA_64_TRAPNIL
) ? "TRAPNIL, " : "",
4812 (flags
& EF_IA_64_EXT
) ? "EXT, " : "",
4813 (flags
& EF_IA_64_BE
) ? "BE, " : "LE, ",
4814 (flags
& EF_IA_64_REDUCEDFP
) ? "REDUCEDFP, " : "",
4815 (flags
& EF_IA_64_CONS_GP
) ? "CONS_GP, " : "",
4816 (flags
& EF_IA_64_NOFUNCDESC_CONS_GP
) ? "NOFUNCDESC_CONS_GP, " : "",
4817 (flags
& EF_IA_64_ABSOLUTE
) ? "ABSOLUTE, " : "",
4818 (flags
& EF_IA_64_ABI64
) ? "ABI64" : "ABI32");
4820 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
4824 static enum elf_reloc_type_class
4825 elfNN_ia64_reloc_type_class (rela
)
4826 const Elf_Internal_Rela
*rela
;
4828 switch ((int) ELFNN_R_TYPE (rela
->r_info
))
4830 case R_IA64_REL32MSB
:
4831 case R_IA64_REL32LSB
:
4832 case R_IA64_REL64MSB
:
4833 case R_IA64_REL64LSB
:
4834 return reloc_class_relative
;
4835 case R_IA64_IPLTMSB
:
4836 case R_IA64_IPLTLSB
:
4837 return reloc_class_plt
;
4839 return reloc_class_copy
;
4841 return reloc_class_normal
;
4846 elfNN_ia64_hpux_vec (const bfd_target
*vec
)
4848 extern const bfd_target bfd_elfNN_ia64_hpux_big_vec
;
4849 return (vec
== & bfd_elfNN_ia64_hpux_big_vec
);
4853 elfNN_hpux_post_process_headers (abfd
, info
)
4855 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
4857 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
4859 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_HPUX
;
4860 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 1;
4864 elfNN_hpux_backend_section_from_bfd_section (abfd
, sec
, retval
)
4865 bfd
*abfd ATTRIBUTE_UNUSED
;
4869 if (bfd_is_com_section (sec
))
4871 *retval
= SHN_IA_64_ANSI_COMMON
;
4877 #define TARGET_LITTLE_SYM bfd_elfNN_ia64_little_vec
4878 #define TARGET_LITTLE_NAME "elfNN-ia64-little"
4879 #define TARGET_BIG_SYM bfd_elfNN_ia64_big_vec
4880 #define TARGET_BIG_NAME "elfNN-ia64-big"
4881 #define ELF_ARCH bfd_arch_ia64
4882 #define ELF_MACHINE_CODE EM_IA_64
4883 #define ELF_MACHINE_ALT1 1999 /* EAS2.3 */
4884 #define ELF_MACHINE_ALT2 1998 /* EAS2.2 */
4885 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
4887 #define elf_backend_section_from_shdr \
4888 elfNN_ia64_section_from_shdr
4889 #define elf_backend_section_flags \
4890 elfNN_ia64_section_flags
4891 #define elf_backend_fake_sections \
4892 elfNN_ia64_fake_sections
4893 #define elf_backend_final_write_processing \
4894 elfNN_ia64_final_write_processing
4895 #define elf_backend_add_symbol_hook \
4896 elfNN_ia64_add_symbol_hook
4897 #define elf_backend_additional_program_headers \
4898 elfNN_ia64_additional_program_headers
4899 #define elf_backend_modify_segment_map \
4900 elfNN_ia64_modify_segment_map
4901 #define elf_info_to_howto \
4902 elfNN_ia64_info_to_howto
4904 #define bfd_elfNN_bfd_reloc_type_lookup \
4905 elfNN_ia64_reloc_type_lookup
4906 #define bfd_elfNN_bfd_is_local_label_name \
4907 elfNN_ia64_is_local_label_name
4908 #define bfd_elfNN_bfd_relax_section \
4909 elfNN_ia64_relax_section
4911 /* Stuff for the BFD linker: */
4912 #define bfd_elfNN_bfd_link_hash_table_create \
4913 elfNN_ia64_hash_table_create
4914 #define elf_backend_create_dynamic_sections \
4915 elfNN_ia64_create_dynamic_sections
4916 #define elf_backend_check_relocs \
4917 elfNN_ia64_check_relocs
4918 #define elf_backend_adjust_dynamic_symbol \
4919 elfNN_ia64_adjust_dynamic_symbol
4920 #define elf_backend_size_dynamic_sections \
4921 elfNN_ia64_size_dynamic_sections
4922 #define elf_backend_relocate_section \
4923 elfNN_ia64_relocate_section
4924 #define elf_backend_finish_dynamic_symbol \
4925 elfNN_ia64_finish_dynamic_symbol
4926 #define elf_backend_finish_dynamic_sections \
4927 elfNN_ia64_finish_dynamic_sections
4928 #define bfd_elfNN_bfd_final_link \
4929 elfNN_ia64_final_link
4931 #define bfd_elfNN_bfd_merge_private_bfd_data \
4932 elfNN_ia64_merge_private_bfd_data
4933 #define bfd_elfNN_bfd_set_private_flags \
4934 elfNN_ia64_set_private_flags
4935 #define bfd_elfNN_bfd_print_private_bfd_data \
4936 elfNN_ia64_print_private_bfd_data
4938 #define elf_backend_plt_readonly 1
4939 #define elf_backend_want_plt_sym 0
4940 #define elf_backend_plt_alignment 5
4941 #define elf_backend_got_header_size 0
4942 #define elf_backend_plt_header_size PLT_HEADER_SIZE
4943 #define elf_backend_want_got_plt 1
4944 #define elf_backend_may_use_rel_p 1
4945 #define elf_backend_may_use_rela_p 1
4946 #define elf_backend_default_use_rela_p 1
4947 #define elf_backend_want_dynbss 0
4948 #define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect
4949 #define elf_backend_hide_symbol elfNN_ia64_hash_hide_symbol
4950 #define elf_backend_reloc_type_class elfNN_ia64_reloc_type_class
4951 #define elf_backend_rela_normal 1
4953 #include "elfNN-target.h"
4955 /* AIX-specific vectors. */
4957 #undef TARGET_LITTLE_SYM
4958 #define TARGET_LITTLE_SYM bfd_elfNN_ia64_aix_little_vec
4959 #undef TARGET_LITTLE_NAME
4960 #define TARGET_LITTLE_NAME "elfNN-ia64-aix-little"
4961 #undef TARGET_BIG_SYM
4962 #define TARGET_BIG_SYM bfd_elfNN_ia64_aix_big_vec
4963 #undef TARGET_BIG_NAME
4964 #define TARGET_BIG_NAME "elfNN-ia64-aix-big"
4966 #undef elf_backend_add_symbol_hook
4967 #define elf_backend_add_symbol_hook elfNN_ia64_aix_add_symbol_hook
4969 #undef bfd_elfNN_bfd_link_add_symbols
4970 #define bfd_elfNN_bfd_link_add_symbols elfNN_ia64_aix_link_add_symbols
4972 #define elfNN_bed elfNN_ia64_aix_bed
4974 #include "elfNN-target.h"
4976 /* HPUX-specific vectors. */
4978 #undef TARGET_LITTLE_SYM
4979 #undef TARGET_LITTLE_NAME
4980 #undef TARGET_BIG_SYM
4981 #define TARGET_BIG_SYM bfd_elfNN_ia64_hpux_big_vec
4982 #undef TARGET_BIG_NAME
4983 #define TARGET_BIG_NAME "elfNN-ia64-hpux-big"
4985 /* We need to undo the AIX specific functions. */
4987 #undef elf_backend_add_symbol_hook
4988 #define elf_backend_add_symbol_hook elfNN_ia64_add_symbol_hook
4990 #undef bfd_elfNN_bfd_link_add_symbols
4991 #define bfd_elfNN_bfd_link_add_symbols _bfd_generic_link_add_symbols
4993 /* These are HP-UX specific functions. */
4995 #undef elf_backend_post_process_headers
4996 #define elf_backend_post_process_headers elfNN_hpux_post_process_headers
4998 #undef elf_backend_section_from_bfd_section
4999 #define elf_backend_section_from_bfd_section elfNN_hpux_backend_section_from_bfd_section
5001 #undef elf_backend_want_p_paddr_set_to_zero
5002 #define elf_backend_want_p_paddr_set_to_zero 1
5004 #undef ELF_MAXPAGESIZE
5005 #define ELF_MAXPAGESIZE 0x1000 /* 1K */
5008 #define elfNN_bed elfNN_ia64_hpux_bed
5010 #include "elfNN-target.h"
5012 #undef elf_backend_want_p_paddr_set_to_zero