1 /* IA-64 support for 64-bit ELF
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004
3 Free Software Foundation, Inc.
4 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26 #include "opcode/ia64.h"
31 /* THE RULES for all the stuff the linker creates --
33 GOT Entries created in response to LTOFF or LTOFF_FPTR
34 relocations. Dynamic relocs created for dynamic
35 symbols in an application; REL relocs for locals
38 FPTR The canonical function descriptor. Created for local
39 symbols in applications. Descriptors for dynamic symbols
40 and local symbols in shared libraries are created by
41 ld.so. Thus there are no dynamic relocs against these
42 objects. The FPTR relocs for such _are_ passed through
43 to the dynamic relocation tables.
45 FULL_PLT Created for a PCREL21B relocation against a dynamic symbol.
46 Requires the creation of a PLTOFF entry. This does not
47 require any dynamic relocations.
49 PLTOFF Created by PLTOFF relocations. For local symbols, this
50 is an alternate function descriptor, and in shared libraries
51 requires two REL relocations. Note that this cannot be
52 transformed into an FPTR relocation, since it must be in
53 range of the GP. For dynamic symbols, this is a function
54 descriptor for a MIN_PLT entry, and requires one IPLT reloc.
56 MIN_PLT Created by PLTOFF entries against dynamic symbols. This
57 does not require dynamic relocations. */
59 #define NELEMS(a) ((int) (sizeof (a) / sizeof ((a)[0])))
61 typedef struct bfd_hash_entry
*(*new_hash_entry_func
)
62 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
64 /* In dynamically (linker-) created sections, we generally need to keep track
65 of the place a symbol or expression got allocated to. This is done via hash
66 tables that store entries of the following type. */
68 struct elfNN_ia64_dyn_sym_info
70 /* The addend for which this entry is relevant. */
73 /* Next addend in the list. */
74 struct elfNN_ia64_dyn_sym_info
*next
;
78 bfd_vma pltoff_offset
;
82 bfd_vma dtpmod_offset
;
83 bfd_vma dtprel_offset
;
85 /* The symbol table entry, if any, that this was derived from. */
86 struct elf_link_hash_entry
*h
;
88 /* Used to count non-got, non-plt relocations for delayed sizing
89 of relocation sections. */
90 struct elfNN_ia64_dyn_reloc_entry
92 struct elfNN_ia64_dyn_reloc_entry
*next
;
97 /* Is this reloc against readonly section? */
101 /* TRUE when the section contents have been updated. */
102 unsigned got_done
: 1;
103 unsigned fptr_done
: 1;
104 unsigned pltoff_done
: 1;
105 unsigned tprel_done
: 1;
106 unsigned dtpmod_done
: 1;
107 unsigned dtprel_done
: 1;
109 /* TRUE for the different kinds of linker data we want created. */
110 unsigned want_got
: 1;
111 unsigned want_gotx
: 1;
112 unsigned want_fptr
: 1;
113 unsigned want_ltoff_fptr
: 1;
114 unsigned want_plt
: 1;
115 unsigned want_plt2
: 1;
116 unsigned want_pltoff
: 1;
117 unsigned want_tprel
: 1;
118 unsigned want_dtpmod
: 1;
119 unsigned want_dtprel
: 1;
122 struct elfNN_ia64_local_hash_entry
126 struct elfNN_ia64_dyn_sym_info
*info
;
128 /* TRUE if this hash entry's addends was translated for
129 SHF_MERGE optimization. */
130 unsigned sec_merge_done
: 1;
133 struct elfNN_ia64_link_hash_entry
135 struct elf_link_hash_entry root
;
136 struct elfNN_ia64_dyn_sym_info
*info
;
139 struct elfNN_ia64_link_hash_table
141 /* The main hash table. */
142 struct elf_link_hash_table root
;
144 asection
*got_sec
; /* the linkage table section (or NULL) */
145 asection
*rel_got_sec
; /* dynamic relocation section for same */
146 asection
*fptr_sec
; /* function descriptor table (or NULL) */
147 asection
*rel_fptr_sec
; /* dynamic relocation section for same */
148 asection
*plt_sec
; /* the primary plt section (or NULL) */
149 asection
*pltoff_sec
; /* private descriptors for plt (or NULL) */
150 asection
*rel_pltoff_sec
; /* dynamic relocation section for same */
152 bfd_size_type minplt_entries
; /* number of minplt entries */
153 unsigned reltext
: 1; /* are there relocs against readonly sections? */
154 unsigned self_dtpmod_done
: 1;/* has self DTPMOD entry been finished? */
155 bfd_vma self_dtpmod_offset
; /* .got offset to self DTPMOD entry */
157 htab_t loc_hash_table
;
158 void *loc_hash_memory
;
161 struct elfNN_ia64_allocate_data
163 struct bfd_link_info
*info
;
167 #define elfNN_ia64_hash_table(p) \
168 ((struct elfNN_ia64_link_hash_table *) ((p)->hash))
170 static bfd_reloc_status_type elfNN_ia64_reloc
171 PARAMS ((bfd
*abfd
, arelent
*reloc
, asymbol
*sym
, PTR data
,
172 asection
*input_section
, bfd
*output_bfd
, char **error_message
));
173 static reloc_howto_type
* lookup_howto
174 PARAMS ((unsigned int rtype
));
175 static reloc_howto_type
*elfNN_ia64_reloc_type_lookup
176 PARAMS ((bfd
*abfd
, bfd_reloc_code_real_type bfd_code
));
177 static void elfNN_ia64_info_to_howto
178 PARAMS ((bfd
*abfd
, arelent
*bfd_reloc
, Elf_Internal_Rela
*elf_reloc
));
179 static bfd_boolean elfNN_ia64_relax_section
180 PARAMS((bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
,
181 bfd_boolean
*again
));
182 static void elfNN_ia64_relax_ldxmov
183 PARAMS((bfd
*abfd
, bfd_byte
*contents
, bfd_vma off
));
184 static bfd_boolean is_unwind_section_name
185 PARAMS ((bfd
*abfd
, const char *));
186 static bfd_boolean elfNN_ia64_section_from_shdr
187 PARAMS ((bfd
*, Elf_Internal_Shdr
*, const char *));
188 static bfd_boolean elfNN_ia64_section_flags
189 PARAMS ((flagword
*, const Elf_Internal_Shdr
*));
190 static bfd_boolean elfNN_ia64_fake_sections
191 PARAMS ((bfd
*abfd
, Elf_Internal_Shdr
*hdr
, asection
*sec
));
192 static void elfNN_ia64_final_write_processing
193 PARAMS ((bfd
*abfd
, bfd_boolean linker
));
194 static bfd_boolean elfNN_ia64_add_symbol_hook
195 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, Elf_Internal_Sym
*sym
,
196 const char **namep
, flagword
*flagsp
, asection
**secp
,
198 static int elfNN_ia64_additional_program_headers
199 PARAMS ((bfd
*abfd
));
200 static bfd_boolean elfNN_ia64_modify_segment_map
201 PARAMS ((bfd
*, struct bfd_link_info
*));
202 static bfd_boolean elfNN_ia64_is_local_label_name
203 PARAMS ((bfd
*abfd
, const char *name
));
204 static bfd_boolean elfNN_ia64_dynamic_symbol_p
205 PARAMS ((struct elf_link_hash_entry
*h
, struct bfd_link_info
*info
, int));
206 static struct bfd_hash_entry
*elfNN_ia64_new_elf_hash_entry
207 PARAMS ((struct bfd_hash_entry
*entry
, struct bfd_hash_table
*table
,
208 const char *string
));
209 static void elfNN_ia64_hash_copy_indirect
210 PARAMS ((const struct elf_backend_data
*, struct elf_link_hash_entry
*,
211 struct elf_link_hash_entry
*));
212 static void elfNN_ia64_hash_hide_symbol
213 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*, bfd_boolean
));
214 static hashval_t elfNN_ia64_local_htab_hash
PARAMS ((const void *));
215 static int elfNN_ia64_local_htab_eq
PARAMS ((const void *ptr1
,
217 static struct bfd_link_hash_table
*elfNN_ia64_hash_table_create
218 PARAMS ((bfd
*abfd
));
219 static void elfNN_ia64_hash_table_free
220 PARAMS ((struct bfd_link_hash_table
*hash
));
221 static bfd_boolean elfNN_ia64_global_dyn_sym_thunk
222 PARAMS ((struct bfd_hash_entry
*, PTR
));
223 static int elfNN_ia64_local_dyn_sym_thunk
224 PARAMS ((void **, PTR
));
225 static void elfNN_ia64_dyn_sym_traverse
226 PARAMS ((struct elfNN_ia64_link_hash_table
*ia64_info
,
227 bfd_boolean (*func
) (struct elfNN_ia64_dyn_sym_info
*, PTR
),
229 static bfd_boolean elfNN_ia64_create_dynamic_sections
230 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
231 static struct elfNN_ia64_local_hash_entry
* get_local_sym_hash
232 PARAMS ((struct elfNN_ia64_link_hash_table
*ia64_info
,
233 bfd
*abfd
, const Elf_Internal_Rela
*rel
, bfd_boolean create
));
234 static struct elfNN_ia64_dyn_sym_info
* get_dyn_sym_info
235 PARAMS ((struct elfNN_ia64_link_hash_table
*ia64_info
,
236 struct elf_link_hash_entry
*h
,
237 bfd
*abfd
, const Elf_Internal_Rela
*rel
, bfd_boolean create
));
238 static asection
*get_got
239 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
240 struct elfNN_ia64_link_hash_table
*ia64_info
));
241 static asection
*get_fptr
242 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
243 struct elfNN_ia64_link_hash_table
*ia64_info
));
244 static asection
*get_pltoff
245 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
246 struct elfNN_ia64_link_hash_table
*ia64_info
));
247 static asection
*get_reloc_section
248 PARAMS ((bfd
*abfd
, struct elfNN_ia64_link_hash_table
*ia64_info
,
249 asection
*sec
, bfd_boolean create
));
250 static bfd_boolean elfNN_ia64_check_relocs
251 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
252 const Elf_Internal_Rela
*relocs
));
253 static bfd_boolean elfNN_ia64_adjust_dynamic_symbol
254 PARAMS ((struct bfd_link_info
*info
, struct elf_link_hash_entry
*h
));
255 static long global_sym_index
256 PARAMS ((struct elf_link_hash_entry
*h
));
257 static bfd_boolean allocate_fptr
258 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
259 static bfd_boolean allocate_global_data_got
260 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
261 static bfd_boolean allocate_global_fptr_got
262 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
263 static bfd_boolean allocate_local_got
264 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
265 static bfd_boolean allocate_pltoff_entries
266 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
267 static bfd_boolean allocate_plt_entries
268 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
269 static bfd_boolean allocate_plt2_entries
270 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
271 static bfd_boolean allocate_dynrel_entries
272 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
273 static bfd_boolean elfNN_ia64_size_dynamic_sections
274 PARAMS ((bfd
*output_bfd
, struct bfd_link_info
*info
));
275 static bfd_reloc_status_type elfNN_ia64_install_value
276 PARAMS ((bfd
*abfd
, bfd_byte
*hit_addr
, bfd_vma val
, unsigned int r_type
));
277 static void elfNN_ia64_install_dyn_reloc
278 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
279 asection
*srel
, bfd_vma offset
, unsigned int type
,
280 long dynindx
, bfd_vma addend
));
281 static bfd_vma set_got_entry
282 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
283 struct elfNN_ia64_dyn_sym_info
*dyn_i
, long dynindx
,
284 bfd_vma addend
, bfd_vma value
, unsigned int dyn_r_type
));
285 static bfd_vma set_fptr_entry
286 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
287 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
289 static bfd_vma set_pltoff_entry
290 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
291 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
292 bfd_vma value
, bfd_boolean
));
293 static bfd_vma elfNN_ia64_tprel_base
294 PARAMS ((struct bfd_link_info
*info
));
295 static bfd_vma elfNN_ia64_dtprel_base
296 PARAMS ((struct bfd_link_info
*info
));
297 static int elfNN_ia64_unwind_entry_compare
298 PARAMS ((const PTR
, const PTR
));
299 static bfd_boolean elfNN_ia64_choose_gp
300 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
301 static bfd_boolean elfNN_ia64_final_link
302 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
303 static bfd_boolean elfNN_ia64_relocate_section
304 PARAMS ((bfd
*output_bfd
, struct bfd_link_info
*info
, bfd
*input_bfd
,
305 asection
*input_section
, bfd_byte
*contents
,
306 Elf_Internal_Rela
*relocs
, Elf_Internal_Sym
*local_syms
,
307 asection
**local_sections
));
308 static bfd_boolean elfNN_ia64_finish_dynamic_symbol
309 PARAMS ((bfd
*output_bfd
, struct bfd_link_info
*info
,
310 struct elf_link_hash_entry
*h
, Elf_Internal_Sym
*sym
));
311 static bfd_boolean elfNN_ia64_finish_dynamic_sections
312 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
313 static bfd_boolean elfNN_ia64_set_private_flags
314 PARAMS ((bfd
*abfd
, flagword flags
));
315 static bfd_boolean elfNN_ia64_merge_private_bfd_data
316 PARAMS ((bfd
*ibfd
, bfd
*obfd
));
317 static bfd_boolean elfNN_ia64_print_private_bfd_data
318 PARAMS ((bfd
*abfd
, PTR ptr
));
319 static enum elf_reloc_type_class elfNN_ia64_reloc_type_class
320 PARAMS ((const Elf_Internal_Rela
*));
321 static bfd_boolean elfNN_ia64_hpux_vec
322 PARAMS ((const bfd_target
*vec
));
323 static void elfNN_hpux_post_process_headers
324 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
325 bfd_boolean elfNN_hpux_backend_section_from_bfd_section
326 PARAMS ((bfd
*abfd
, asection
*sec
, int *retval
));
328 /* ia64-specific relocation. */
330 /* Perform a relocation. Not much to do here as all the hard work is
331 done in elfNN_ia64_final_link_relocate. */
332 static bfd_reloc_status_type
333 elfNN_ia64_reloc (abfd
, reloc
, sym
, data
, input_section
,
334 output_bfd
, error_message
)
335 bfd
*abfd ATTRIBUTE_UNUSED
;
337 asymbol
*sym ATTRIBUTE_UNUSED
;
338 PTR data ATTRIBUTE_UNUSED
;
339 asection
*input_section
;
341 char **error_message
;
345 reloc
->address
+= input_section
->output_offset
;
349 if (input_section
->flags
& SEC_DEBUGGING
)
350 return bfd_reloc_continue
;
352 *error_message
= "Unsupported call to elfNN_ia64_reloc";
353 return bfd_reloc_notsupported
;
356 #define IA64_HOWTO(TYPE, NAME, SIZE, PCREL, IN) \
357 HOWTO (TYPE, 0, SIZE, 0, PCREL, 0, complain_overflow_signed, \
358 elfNN_ia64_reloc, NAME, FALSE, 0, -1, IN)
360 /* This table has to be sorted according to increasing number of the
362 static reloc_howto_type ia64_howto_table
[] =
364 IA64_HOWTO (R_IA64_NONE
, "NONE", 0, FALSE
, TRUE
),
366 IA64_HOWTO (R_IA64_IMM14
, "IMM14", 0, FALSE
, TRUE
),
367 IA64_HOWTO (R_IA64_IMM22
, "IMM22", 0, FALSE
, TRUE
),
368 IA64_HOWTO (R_IA64_IMM64
, "IMM64", 0, FALSE
, TRUE
),
369 IA64_HOWTO (R_IA64_DIR32MSB
, "DIR32MSB", 2, FALSE
, TRUE
),
370 IA64_HOWTO (R_IA64_DIR32LSB
, "DIR32LSB", 2, FALSE
, TRUE
),
371 IA64_HOWTO (R_IA64_DIR64MSB
, "DIR64MSB", 4, FALSE
, TRUE
),
372 IA64_HOWTO (R_IA64_DIR64LSB
, "DIR64LSB", 4, FALSE
, TRUE
),
374 IA64_HOWTO (R_IA64_GPREL22
, "GPREL22", 0, FALSE
, TRUE
),
375 IA64_HOWTO (R_IA64_GPREL64I
, "GPREL64I", 0, FALSE
, TRUE
),
376 IA64_HOWTO (R_IA64_GPREL32MSB
, "GPREL32MSB", 2, FALSE
, TRUE
),
377 IA64_HOWTO (R_IA64_GPREL32LSB
, "GPREL32LSB", 2, FALSE
, TRUE
),
378 IA64_HOWTO (R_IA64_GPREL64MSB
, "GPREL64MSB", 4, FALSE
, TRUE
),
379 IA64_HOWTO (R_IA64_GPREL64LSB
, "GPREL64LSB", 4, FALSE
, TRUE
),
381 IA64_HOWTO (R_IA64_LTOFF22
, "LTOFF22", 0, FALSE
, TRUE
),
382 IA64_HOWTO (R_IA64_LTOFF64I
, "LTOFF64I", 0, FALSE
, TRUE
),
384 IA64_HOWTO (R_IA64_PLTOFF22
, "PLTOFF22", 0, FALSE
, TRUE
),
385 IA64_HOWTO (R_IA64_PLTOFF64I
, "PLTOFF64I", 0, FALSE
, TRUE
),
386 IA64_HOWTO (R_IA64_PLTOFF64MSB
, "PLTOFF64MSB", 4, FALSE
, TRUE
),
387 IA64_HOWTO (R_IA64_PLTOFF64LSB
, "PLTOFF64LSB", 4, FALSE
, TRUE
),
389 IA64_HOWTO (R_IA64_FPTR64I
, "FPTR64I", 0, FALSE
, TRUE
),
390 IA64_HOWTO (R_IA64_FPTR32MSB
, "FPTR32MSB", 2, FALSE
, TRUE
),
391 IA64_HOWTO (R_IA64_FPTR32LSB
, "FPTR32LSB", 2, FALSE
, TRUE
),
392 IA64_HOWTO (R_IA64_FPTR64MSB
, "FPTR64MSB", 4, FALSE
, TRUE
),
393 IA64_HOWTO (R_IA64_FPTR64LSB
, "FPTR64LSB", 4, FALSE
, TRUE
),
395 IA64_HOWTO (R_IA64_PCREL60B
, "PCREL60B", 0, TRUE
, TRUE
),
396 IA64_HOWTO (R_IA64_PCREL21B
, "PCREL21B", 0, TRUE
, TRUE
),
397 IA64_HOWTO (R_IA64_PCREL21M
, "PCREL21M", 0, TRUE
, TRUE
),
398 IA64_HOWTO (R_IA64_PCREL21F
, "PCREL21F", 0, TRUE
, TRUE
),
399 IA64_HOWTO (R_IA64_PCREL32MSB
, "PCREL32MSB", 2, TRUE
, TRUE
),
400 IA64_HOWTO (R_IA64_PCREL32LSB
, "PCREL32LSB", 2, TRUE
, TRUE
),
401 IA64_HOWTO (R_IA64_PCREL64MSB
, "PCREL64MSB", 4, TRUE
, TRUE
),
402 IA64_HOWTO (R_IA64_PCREL64LSB
, "PCREL64LSB", 4, TRUE
, TRUE
),
404 IA64_HOWTO (R_IA64_LTOFF_FPTR22
, "LTOFF_FPTR22", 0, FALSE
, TRUE
),
405 IA64_HOWTO (R_IA64_LTOFF_FPTR64I
, "LTOFF_FPTR64I", 0, FALSE
, TRUE
),
406 IA64_HOWTO (R_IA64_LTOFF_FPTR32MSB
, "LTOFF_FPTR32MSB", 2, FALSE
, TRUE
),
407 IA64_HOWTO (R_IA64_LTOFF_FPTR32LSB
, "LTOFF_FPTR32LSB", 2, FALSE
, TRUE
),
408 IA64_HOWTO (R_IA64_LTOFF_FPTR64MSB
, "LTOFF_FPTR64MSB", 4, FALSE
, TRUE
),
409 IA64_HOWTO (R_IA64_LTOFF_FPTR64LSB
, "LTOFF_FPTR64LSB", 4, FALSE
, TRUE
),
411 IA64_HOWTO (R_IA64_SEGREL32MSB
, "SEGREL32MSB", 2, FALSE
, TRUE
),
412 IA64_HOWTO (R_IA64_SEGREL32LSB
, "SEGREL32LSB", 2, FALSE
, TRUE
),
413 IA64_HOWTO (R_IA64_SEGREL64MSB
, "SEGREL64MSB", 4, FALSE
, TRUE
),
414 IA64_HOWTO (R_IA64_SEGREL64LSB
, "SEGREL64LSB", 4, FALSE
, TRUE
),
416 IA64_HOWTO (R_IA64_SECREL32MSB
, "SECREL32MSB", 2, FALSE
, TRUE
),
417 IA64_HOWTO (R_IA64_SECREL32LSB
, "SECREL32LSB", 2, FALSE
, TRUE
),
418 IA64_HOWTO (R_IA64_SECREL64MSB
, "SECREL64MSB", 4, FALSE
, TRUE
),
419 IA64_HOWTO (R_IA64_SECREL64LSB
, "SECREL64LSB", 4, FALSE
, TRUE
),
421 IA64_HOWTO (R_IA64_REL32MSB
, "REL32MSB", 2, FALSE
, TRUE
),
422 IA64_HOWTO (R_IA64_REL32LSB
, "REL32LSB", 2, FALSE
, TRUE
),
423 IA64_HOWTO (R_IA64_REL64MSB
, "REL64MSB", 4, FALSE
, TRUE
),
424 IA64_HOWTO (R_IA64_REL64LSB
, "REL64LSB", 4, FALSE
, TRUE
),
426 IA64_HOWTO (R_IA64_LTV32MSB
, "LTV32MSB", 2, FALSE
, TRUE
),
427 IA64_HOWTO (R_IA64_LTV32LSB
, "LTV32LSB", 2, FALSE
, TRUE
),
428 IA64_HOWTO (R_IA64_LTV64MSB
, "LTV64MSB", 4, FALSE
, TRUE
),
429 IA64_HOWTO (R_IA64_LTV64LSB
, "LTV64LSB", 4, FALSE
, TRUE
),
431 IA64_HOWTO (R_IA64_PCREL21BI
, "PCREL21BI", 0, TRUE
, TRUE
),
432 IA64_HOWTO (R_IA64_PCREL22
, "PCREL22", 0, TRUE
, TRUE
),
433 IA64_HOWTO (R_IA64_PCREL64I
, "PCREL64I", 0, TRUE
, TRUE
),
435 IA64_HOWTO (R_IA64_IPLTMSB
, "IPLTMSB", 4, FALSE
, TRUE
),
436 IA64_HOWTO (R_IA64_IPLTLSB
, "IPLTLSB", 4, FALSE
, TRUE
),
437 IA64_HOWTO (R_IA64_COPY
, "COPY", 4, FALSE
, TRUE
),
438 IA64_HOWTO (R_IA64_LTOFF22X
, "LTOFF22X", 0, FALSE
, TRUE
),
439 IA64_HOWTO (R_IA64_LDXMOV
, "LDXMOV", 0, FALSE
, TRUE
),
441 IA64_HOWTO (R_IA64_TPREL14
, "TPREL14", 0, FALSE
, FALSE
),
442 IA64_HOWTO (R_IA64_TPREL22
, "TPREL22", 0, FALSE
, FALSE
),
443 IA64_HOWTO (R_IA64_TPREL64I
, "TPREL64I", 0, FALSE
, FALSE
),
444 IA64_HOWTO (R_IA64_TPREL64MSB
, "TPREL64MSB", 4, FALSE
, FALSE
),
445 IA64_HOWTO (R_IA64_TPREL64LSB
, "TPREL64LSB", 4, FALSE
, FALSE
),
446 IA64_HOWTO (R_IA64_LTOFF_TPREL22
, "LTOFF_TPREL22", 0, FALSE
, FALSE
),
448 IA64_HOWTO (R_IA64_DTPMOD64MSB
, "TPREL64MSB", 4, FALSE
, FALSE
),
449 IA64_HOWTO (R_IA64_DTPMOD64LSB
, "TPREL64LSB", 4, FALSE
, FALSE
),
450 IA64_HOWTO (R_IA64_LTOFF_DTPMOD22
, "LTOFF_DTPMOD22", 0, FALSE
, FALSE
),
452 IA64_HOWTO (R_IA64_DTPREL14
, "DTPREL14", 0, FALSE
, FALSE
),
453 IA64_HOWTO (R_IA64_DTPREL22
, "DTPREL22", 0, FALSE
, FALSE
),
454 IA64_HOWTO (R_IA64_DTPREL64I
, "DTPREL64I", 0, FALSE
, FALSE
),
455 IA64_HOWTO (R_IA64_DTPREL32MSB
, "DTPREL32MSB", 2, FALSE
, FALSE
),
456 IA64_HOWTO (R_IA64_DTPREL32LSB
, "DTPREL32LSB", 2, FALSE
, FALSE
),
457 IA64_HOWTO (R_IA64_DTPREL64MSB
, "DTPREL64MSB", 4, FALSE
, FALSE
),
458 IA64_HOWTO (R_IA64_DTPREL64LSB
, "DTPREL64LSB", 4, FALSE
, FALSE
),
459 IA64_HOWTO (R_IA64_LTOFF_DTPREL22
, "LTOFF_DTPREL22", 0, FALSE
, FALSE
),
462 static unsigned char elf_code_to_howto_index
[R_IA64_MAX_RELOC_CODE
+ 1];
464 /* Given a BFD reloc type, return the matching HOWTO structure. */
466 static reloc_howto_type
*
470 static int inited
= 0;
477 memset (elf_code_to_howto_index
, 0xff, sizeof (elf_code_to_howto_index
));
478 for (i
= 0; i
< NELEMS (ia64_howto_table
); ++i
)
479 elf_code_to_howto_index
[ia64_howto_table
[i
].type
] = i
;
482 BFD_ASSERT (rtype
<= R_IA64_MAX_RELOC_CODE
);
483 i
= elf_code_to_howto_index
[rtype
];
484 if (i
>= NELEMS (ia64_howto_table
))
486 return ia64_howto_table
+ i
;
489 static reloc_howto_type
*
490 elfNN_ia64_reloc_type_lookup (abfd
, bfd_code
)
491 bfd
*abfd ATTRIBUTE_UNUSED
;
492 bfd_reloc_code_real_type bfd_code
;
498 case BFD_RELOC_NONE
: rtype
= R_IA64_NONE
; break;
500 case BFD_RELOC_IA64_IMM14
: rtype
= R_IA64_IMM14
; break;
501 case BFD_RELOC_IA64_IMM22
: rtype
= R_IA64_IMM22
; break;
502 case BFD_RELOC_IA64_IMM64
: rtype
= R_IA64_IMM64
; break;
504 case BFD_RELOC_IA64_DIR32MSB
: rtype
= R_IA64_DIR32MSB
; break;
505 case BFD_RELOC_IA64_DIR32LSB
: rtype
= R_IA64_DIR32LSB
; break;
506 case BFD_RELOC_IA64_DIR64MSB
: rtype
= R_IA64_DIR64MSB
; break;
507 case BFD_RELOC_IA64_DIR64LSB
: rtype
= R_IA64_DIR64LSB
; break;
509 case BFD_RELOC_IA64_GPREL22
: rtype
= R_IA64_GPREL22
; break;
510 case BFD_RELOC_IA64_GPREL64I
: rtype
= R_IA64_GPREL64I
; break;
511 case BFD_RELOC_IA64_GPREL32MSB
: rtype
= R_IA64_GPREL32MSB
; break;
512 case BFD_RELOC_IA64_GPREL32LSB
: rtype
= R_IA64_GPREL32LSB
; break;
513 case BFD_RELOC_IA64_GPREL64MSB
: rtype
= R_IA64_GPREL64MSB
; break;
514 case BFD_RELOC_IA64_GPREL64LSB
: rtype
= R_IA64_GPREL64LSB
; break;
516 case BFD_RELOC_IA64_LTOFF22
: rtype
= R_IA64_LTOFF22
; break;
517 case BFD_RELOC_IA64_LTOFF64I
: rtype
= R_IA64_LTOFF64I
; break;
519 case BFD_RELOC_IA64_PLTOFF22
: rtype
= R_IA64_PLTOFF22
; break;
520 case BFD_RELOC_IA64_PLTOFF64I
: rtype
= R_IA64_PLTOFF64I
; break;
521 case BFD_RELOC_IA64_PLTOFF64MSB
: rtype
= R_IA64_PLTOFF64MSB
; break;
522 case BFD_RELOC_IA64_PLTOFF64LSB
: rtype
= R_IA64_PLTOFF64LSB
; break;
523 case BFD_RELOC_IA64_FPTR64I
: rtype
= R_IA64_FPTR64I
; break;
524 case BFD_RELOC_IA64_FPTR32MSB
: rtype
= R_IA64_FPTR32MSB
; break;
525 case BFD_RELOC_IA64_FPTR32LSB
: rtype
= R_IA64_FPTR32LSB
; break;
526 case BFD_RELOC_IA64_FPTR64MSB
: rtype
= R_IA64_FPTR64MSB
; break;
527 case BFD_RELOC_IA64_FPTR64LSB
: rtype
= R_IA64_FPTR64LSB
; break;
529 case BFD_RELOC_IA64_PCREL21B
: rtype
= R_IA64_PCREL21B
; break;
530 case BFD_RELOC_IA64_PCREL21BI
: rtype
= R_IA64_PCREL21BI
; break;
531 case BFD_RELOC_IA64_PCREL21M
: rtype
= R_IA64_PCREL21M
; break;
532 case BFD_RELOC_IA64_PCREL21F
: rtype
= R_IA64_PCREL21F
; break;
533 case BFD_RELOC_IA64_PCREL22
: rtype
= R_IA64_PCREL22
; break;
534 case BFD_RELOC_IA64_PCREL60B
: rtype
= R_IA64_PCREL60B
; break;
535 case BFD_RELOC_IA64_PCREL64I
: rtype
= R_IA64_PCREL64I
; break;
536 case BFD_RELOC_IA64_PCREL32MSB
: rtype
= R_IA64_PCREL32MSB
; break;
537 case BFD_RELOC_IA64_PCREL32LSB
: rtype
= R_IA64_PCREL32LSB
; break;
538 case BFD_RELOC_IA64_PCREL64MSB
: rtype
= R_IA64_PCREL64MSB
; break;
539 case BFD_RELOC_IA64_PCREL64LSB
: rtype
= R_IA64_PCREL64LSB
; break;
541 case BFD_RELOC_IA64_LTOFF_FPTR22
: rtype
= R_IA64_LTOFF_FPTR22
; break;
542 case BFD_RELOC_IA64_LTOFF_FPTR64I
: rtype
= R_IA64_LTOFF_FPTR64I
; break;
543 case BFD_RELOC_IA64_LTOFF_FPTR32MSB
: rtype
= R_IA64_LTOFF_FPTR32MSB
; break;
544 case BFD_RELOC_IA64_LTOFF_FPTR32LSB
: rtype
= R_IA64_LTOFF_FPTR32LSB
; break;
545 case BFD_RELOC_IA64_LTOFF_FPTR64MSB
: rtype
= R_IA64_LTOFF_FPTR64MSB
; break;
546 case BFD_RELOC_IA64_LTOFF_FPTR64LSB
: rtype
= R_IA64_LTOFF_FPTR64LSB
; break;
548 case BFD_RELOC_IA64_SEGREL32MSB
: rtype
= R_IA64_SEGREL32MSB
; break;
549 case BFD_RELOC_IA64_SEGREL32LSB
: rtype
= R_IA64_SEGREL32LSB
; break;
550 case BFD_RELOC_IA64_SEGREL64MSB
: rtype
= R_IA64_SEGREL64MSB
; break;
551 case BFD_RELOC_IA64_SEGREL64LSB
: rtype
= R_IA64_SEGREL64LSB
; break;
553 case BFD_RELOC_IA64_SECREL32MSB
: rtype
= R_IA64_SECREL32MSB
; break;
554 case BFD_RELOC_IA64_SECREL32LSB
: rtype
= R_IA64_SECREL32LSB
; break;
555 case BFD_RELOC_IA64_SECREL64MSB
: rtype
= R_IA64_SECREL64MSB
; break;
556 case BFD_RELOC_IA64_SECREL64LSB
: rtype
= R_IA64_SECREL64LSB
; break;
558 case BFD_RELOC_IA64_REL32MSB
: rtype
= R_IA64_REL32MSB
; break;
559 case BFD_RELOC_IA64_REL32LSB
: rtype
= R_IA64_REL32LSB
; break;
560 case BFD_RELOC_IA64_REL64MSB
: rtype
= R_IA64_REL64MSB
; break;
561 case BFD_RELOC_IA64_REL64LSB
: rtype
= R_IA64_REL64LSB
; break;
563 case BFD_RELOC_IA64_LTV32MSB
: rtype
= R_IA64_LTV32MSB
; break;
564 case BFD_RELOC_IA64_LTV32LSB
: rtype
= R_IA64_LTV32LSB
; break;
565 case BFD_RELOC_IA64_LTV64MSB
: rtype
= R_IA64_LTV64MSB
; break;
566 case BFD_RELOC_IA64_LTV64LSB
: rtype
= R_IA64_LTV64LSB
; break;
568 case BFD_RELOC_IA64_IPLTMSB
: rtype
= R_IA64_IPLTMSB
; break;
569 case BFD_RELOC_IA64_IPLTLSB
: rtype
= R_IA64_IPLTLSB
; break;
570 case BFD_RELOC_IA64_COPY
: rtype
= R_IA64_COPY
; break;
571 case BFD_RELOC_IA64_LTOFF22X
: rtype
= R_IA64_LTOFF22X
; break;
572 case BFD_RELOC_IA64_LDXMOV
: rtype
= R_IA64_LDXMOV
; break;
574 case BFD_RELOC_IA64_TPREL14
: rtype
= R_IA64_TPREL14
; break;
575 case BFD_RELOC_IA64_TPREL22
: rtype
= R_IA64_TPREL22
; break;
576 case BFD_RELOC_IA64_TPREL64I
: rtype
= R_IA64_TPREL64I
; break;
577 case BFD_RELOC_IA64_TPREL64MSB
: rtype
= R_IA64_TPREL64MSB
; break;
578 case BFD_RELOC_IA64_TPREL64LSB
: rtype
= R_IA64_TPREL64LSB
; break;
579 case BFD_RELOC_IA64_LTOFF_TPREL22
: rtype
= R_IA64_LTOFF_TPREL22
; break;
581 case BFD_RELOC_IA64_DTPMOD64MSB
: rtype
= R_IA64_DTPMOD64MSB
; break;
582 case BFD_RELOC_IA64_DTPMOD64LSB
: rtype
= R_IA64_DTPMOD64LSB
; break;
583 case BFD_RELOC_IA64_LTOFF_DTPMOD22
: rtype
= R_IA64_LTOFF_DTPMOD22
; break;
585 case BFD_RELOC_IA64_DTPREL14
: rtype
= R_IA64_DTPREL14
; break;
586 case BFD_RELOC_IA64_DTPREL22
: rtype
= R_IA64_DTPREL22
; break;
587 case BFD_RELOC_IA64_DTPREL64I
: rtype
= R_IA64_DTPREL64I
; break;
588 case BFD_RELOC_IA64_DTPREL32MSB
: rtype
= R_IA64_DTPREL32MSB
; break;
589 case BFD_RELOC_IA64_DTPREL32LSB
: rtype
= R_IA64_DTPREL32LSB
; break;
590 case BFD_RELOC_IA64_DTPREL64MSB
: rtype
= R_IA64_DTPREL64MSB
; break;
591 case BFD_RELOC_IA64_DTPREL64LSB
: rtype
= R_IA64_DTPREL64LSB
; break;
592 case BFD_RELOC_IA64_LTOFF_DTPREL22
: rtype
= R_IA64_LTOFF_DTPREL22
; break;
596 return lookup_howto (rtype
);
599 /* Given a ELF reloc, return the matching HOWTO structure. */
602 elfNN_ia64_info_to_howto (abfd
, bfd_reloc
, elf_reloc
)
603 bfd
*abfd ATTRIBUTE_UNUSED
;
605 Elf_Internal_Rela
*elf_reloc
;
608 = lookup_howto ((unsigned int) ELFNN_R_TYPE (elf_reloc
->r_info
));
611 #define PLT_HEADER_SIZE (3 * 16)
612 #define PLT_MIN_ENTRY_SIZE (1 * 16)
613 #define PLT_FULL_ENTRY_SIZE (2 * 16)
614 #define PLT_RESERVED_WORDS 3
616 static const bfd_byte plt_header
[PLT_HEADER_SIZE
] =
618 0x0b, 0x10, 0x00, 0x1c, 0x00, 0x21, /* [MMI] mov r2=r14;; */
619 0xe0, 0x00, 0x08, 0x00, 0x48, 0x00, /* addl r14=0,r2 */
620 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
621 0x0b, 0x80, 0x20, 0x1c, 0x18, 0x14, /* [MMI] ld8 r16=[r14],8;; */
622 0x10, 0x41, 0x38, 0x30, 0x28, 0x00, /* ld8 r17=[r14],8 */
623 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
624 0x11, 0x08, 0x00, 0x1c, 0x18, 0x10, /* [MIB] ld8 r1=[r14] */
625 0x60, 0x88, 0x04, 0x80, 0x03, 0x00, /* mov b6=r17 */
626 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
629 static const bfd_byte plt_min_entry
[PLT_MIN_ENTRY_SIZE
] =
631 0x11, 0x78, 0x00, 0x00, 0x00, 0x24, /* [MIB] mov r15=0 */
632 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, /* nop.i 0x0 */
633 0x00, 0x00, 0x00, 0x40 /* br.few 0 <PLT0>;; */
636 static const bfd_byte plt_full_entry
[PLT_FULL_ENTRY_SIZE
] =
638 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
639 0x00, 0x41, 0x3c, 0x70, 0x29, 0xc0, /* ld8.acq r16=[r15],8*/
640 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
641 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
642 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
643 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
646 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
648 static const bfd_byte oor_brl
[16] =
650 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
651 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;; */
652 0x00, 0x00, 0x00, 0xc0
655 static const bfd_byte oor_ip
[48] =
657 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
658 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, /* movl r15=0 */
659 0x01, 0x00, 0x00, 0x60,
660 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MII] nop.m 0 */
661 0x00, 0x01, 0x00, 0x60, 0x00, 0x00, /* mov r16=ip;; */
662 0xf2, 0x80, 0x00, 0x80, /* add r16=r15,r16;; */
663 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MIB] nop.m 0 */
664 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
665 0x60, 0x00, 0x80, 0x00 /* br b6;; */
668 static size_t oor_branch_size
= sizeof (oor_brl
);
671 bfd_elfNN_ia64_after_parse (int itanium
)
673 oor_branch_size
= itanium
? sizeof (oor_ip
) : sizeof (oor_brl
);
677 elfNN_ia64_relax_brl (bfd
*abfd
, bfd_byte
*contents
, bfd_vma off
)
681 bfd_vma t0
, t1
, i0
, i1
, i2
;
683 hit_addr
= (bfd_byte
*) (contents
+ off
);
684 hit_addr
-= (long) hit_addr
& 0x3;
685 t0
= bfd_get_64 (abfd
, hit_addr
);
686 t1
= bfd_get_64 (abfd
, hit_addr
+ 8);
688 /* Keep the instruction in slot 0. */
689 i0
= (t0
>> 5) & 0x1ffffffffffLL
;
690 /* Use nop.b for slot 1. */
692 /* For slot 2, turn brl into br by masking out bit 40. */
693 i2
= (t1
>> 23) & 0x0ffffffffffLL
;
695 /* Turn a MLX bundle into a MBB bundle with the same stop-bit
698 if ((t0
& 0x1fLL
) == 5)
700 t0
= (i1
<< 46) | (i0
<< 5) | template;
701 t1
= (i2
<< 23) | (i1
>> 18);
703 bfd_put_64 (abfd
, t0
, hit_addr
);
704 bfd_put_64 (abfd
, t1
, hit_addr
+ 8);
707 /* These functions do relaxation for IA-64 ELF. */
710 elfNN_ia64_relax_section (abfd
, sec
, link_info
, again
)
713 struct bfd_link_info
*link_info
;
718 struct one_fixup
*next
;
724 Elf_Internal_Shdr
*symtab_hdr
;
725 Elf_Internal_Rela
*internal_relocs
;
726 Elf_Internal_Rela
*irel
, *irelend
;
728 Elf_Internal_Sym
*isymbuf
= NULL
;
729 struct elfNN_ia64_link_hash_table
*ia64_info
;
730 struct one_fixup
*fixups
= NULL
;
731 bfd_boolean changed_contents
= FALSE
;
732 bfd_boolean changed_relocs
= FALSE
;
733 bfd_boolean changed_got
= FALSE
;
736 /* Assume we're not going to change any sizes, and we'll only need
740 /* Don't even try to relax for non-ELF outputs. */
741 if (!is_elf_hash_table (link_info
->hash
))
744 /* Nothing to do if there are no relocations or there is no need for
745 the relax finalize pass. */
746 if ((sec
->flags
& SEC_RELOC
) == 0
747 || sec
->reloc_count
== 0
748 || (!link_info
->need_relax_finalize
749 && sec
->need_finalize_relax
== 0))
752 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
754 /* Load the relocations for this section. */
755 internal_relocs
= (_bfd_elf_link_read_relocs
756 (abfd
, sec
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
757 link_info
->keep_memory
));
758 if (internal_relocs
== NULL
)
761 ia64_info
= elfNN_ia64_hash_table (link_info
);
762 irelend
= internal_relocs
+ sec
->reloc_count
;
764 /* Get the section contents. */
765 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
766 contents
= elf_section_data (sec
)->this_hdr
.contents
;
769 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
773 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
775 unsigned long r_type
= ELFNN_R_TYPE (irel
->r_info
);
776 bfd_vma symaddr
, reladdr
, trampoff
, toff
, roff
;
780 bfd_boolean is_branch
;
781 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
786 case R_IA64_PCREL21B
:
787 case R_IA64_PCREL21BI
:
788 case R_IA64_PCREL21M
:
789 case R_IA64_PCREL21F
:
790 /* In the finalize pass, all br relaxations are done. We can
792 if (!link_info
->need_relax_finalize
)
797 case R_IA64_PCREL60B
:
798 /* We can't optimize brl to br before the finalize pass since
799 br relaxations will increase the code size. Defer it to
800 the finalize pass. */
801 if (link_info
->need_relax_finalize
)
803 sec
->need_finalize_relax
= 1;
809 case R_IA64_LTOFF22X
:
811 /* We can't relax ldx/mov before the finalize pass since
812 br relaxations will increase the code size. Defer it to
813 the finalize pass. */
814 if (link_info
->need_relax_finalize
)
816 sec
->need_finalize_relax
= 1;
826 /* Get the value of the symbol referred to by the reloc. */
827 if (ELFNN_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
829 /* A local symbol. */
830 Elf_Internal_Sym
*isym
;
832 /* Read this BFD's local symbols. */
835 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
837 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
838 symtab_hdr
->sh_info
, 0,
844 isym
= isymbuf
+ ELFNN_R_SYM (irel
->r_info
);
845 if (isym
->st_shndx
== SHN_UNDEF
)
846 continue; /* We can't do anything with undefined symbols. */
847 else if (isym
->st_shndx
== SHN_ABS
)
848 tsec
= bfd_abs_section_ptr
;
849 else if (isym
->st_shndx
== SHN_COMMON
)
850 tsec
= bfd_com_section_ptr
;
851 else if (isym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
852 tsec
= bfd_com_section_ptr
;
854 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
856 toff
= isym
->st_value
;
857 dyn_i
= get_dyn_sym_info (ia64_info
, NULL
, abfd
, irel
, FALSE
);
858 symtype
= ELF_ST_TYPE (isym
->st_info
);
863 struct elf_link_hash_entry
*h
;
865 indx
= ELFNN_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
866 h
= elf_sym_hashes (abfd
)[indx
];
867 BFD_ASSERT (h
!= NULL
);
869 while (h
->root
.type
== bfd_link_hash_indirect
870 || h
->root
.type
== bfd_link_hash_warning
)
871 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
873 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, irel
, FALSE
);
875 /* For branches to dynamic symbols, we're interested instead
876 in a branch to the PLT entry. */
877 if (is_branch
&& dyn_i
&& dyn_i
->want_plt2
)
879 /* Internal branches shouldn't be sent to the PLT.
880 Leave this for now and we'll give an error later. */
881 if (r_type
!= R_IA64_PCREL21B
)
884 tsec
= ia64_info
->plt_sec
;
885 toff
= dyn_i
->plt2_offset
;
886 BFD_ASSERT (irel
->r_addend
== 0);
889 /* Can't do anything else with dynamic symbols. */
890 else if (elfNN_ia64_dynamic_symbol_p (h
, link_info
, r_type
))
895 /* We can't do anything with undefined symbols. */
896 if (h
->root
.type
== bfd_link_hash_undefined
897 || h
->root
.type
== bfd_link_hash_undefweak
)
900 tsec
= h
->root
.u
.def
.section
;
901 toff
= h
->root
.u
.def
.value
;
907 if (tsec
->sec_info_type
== ELF_INFO_TYPE_MERGE
)
909 /* At this stage in linking, no SEC_MERGE symbol has been
910 adjusted, so all references to such symbols need to be
911 passed through _bfd_merged_section_offset. (Later, in
912 relocate_section, all SEC_MERGE symbols *except* for
913 section symbols have been adjusted.)
915 gas may reduce relocations against symbols in SEC_MERGE
916 sections to a relocation against the section symbol when
917 the original addend was zero. When the reloc is against
918 a section symbol we should include the addend in the
919 offset passed to _bfd_merged_section_offset, since the
920 location of interest is the original symbol. On the
921 other hand, an access to "sym+addend" where "sym" is not
922 a section symbol should not include the addend; Such an
923 access is presumed to be an offset from "sym"; The
924 location of interest is just "sym". */
925 if (symtype
== STT_SECTION
)
926 toff
+= irel
->r_addend
;
928 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
929 elf_section_data (tsec
)->sec_info
,
932 if (symtype
!= STT_SECTION
)
933 toff
+= irel
->r_addend
;
936 toff
+= irel
->r_addend
;
938 symaddr
= tsec
->output_section
->vma
+ tsec
->output_offset
+ toff
;
940 roff
= irel
->r_offset
;
944 bfd_signed_vma offset
;
946 reladdr
= (sec
->output_section
->vma
948 + roff
) & (bfd_vma
) -4;
950 /* If the branch is in range, no need to do anything. */
951 if ((bfd_signed_vma
) (symaddr
- reladdr
) >= -0x1000000
952 && (bfd_signed_vma
) (symaddr
- reladdr
) <= 0x0FFFFF0)
954 /* If the 60-bit branch is in 21-bit range, optimize it. */
955 if (r_type
== R_IA64_PCREL60B
)
957 elfNN_ia64_relax_brl (abfd
, contents
, roff
);
960 = ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
963 /* If the original relocation offset points to slot
964 1, change it to slot 2. */
965 if ((irel
->r_offset
& 3) == 1)
971 else if (r_type
== R_IA64_PCREL60B
)
974 /* If the branch and target are in the same section, you've
975 got one honking big section and we can't help you. You'll
976 get an error message later. */
980 /* Look for an existing fixup to this address. */
981 for (f
= fixups
; f
; f
= f
->next
)
982 if (f
->tsec
== tsec
&& f
->toff
== toff
)
987 /* Two alternatives: If it's a branch to a PLT entry, we can
988 make a copy of the FULL_PLT entry. Otherwise, we'll have
989 to use a `brl' insn to get where we're going. */
993 if (tsec
== ia64_info
->plt_sec
)
994 size
= sizeof (plt_full_entry
);
996 size
= oor_branch_size
;
998 /* Resize the current section to make room for the new branch. */
999 trampoff
= (sec
->size
+ 15) & (bfd_vma
) -16;
1001 /* If trampoline is out of range, there is nothing we
1003 offset
= trampoff
- (roff
& (bfd_vma
) -4);
1004 if (offset
< -0x1000000 || offset
> 0x0FFFFF0)
1007 amt
= trampoff
+ size
;
1008 contents
= (bfd_byte
*) bfd_realloc (contents
, amt
);
1009 if (contents
== NULL
)
1013 if (tsec
== ia64_info
->plt_sec
)
1015 memcpy (contents
+ trampoff
, plt_full_entry
, size
);
1017 /* Hijack the old relocation for use as the PLTOFF reloc. */
1018 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
1020 irel
->r_offset
= trampoff
;
1024 if (size
== sizeof (oor_ip
))
1026 memcpy (contents
+ trampoff
, oor_ip
, size
);
1027 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
1029 irel
->r_addend
-= 16;
1030 irel
->r_offset
= trampoff
+ 2;
1034 memcpy (contents
+ trampoff
, oor_brl
, size
);
1035 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
1037 irel
->r_offset
= trampoff
+ 2;
1042 /* Record the fixup so we don't do it again this section. */
1043 f
= (struct one_fixup
*)
1044 bfd_malloc ((bfd_size_type
) sizeof (*f
));
1048 f
->trampoff
= trampoff
;
1053 /* If trampoline is out of range, there is nothing we
1055 offset
= f
->trampoff
- (roff
& (bfd_vma
) -4);
1056 if (offset
< -0x1000000 || offset
> 0x0FFFFF0)
1059 /* Nop out the reloc, since we're finalizing things here. */
1060 irel
->r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
1063 /* Fix up the existing branch to hit the trampoline. */
1064 if (elfNN_ia64_install_value (abfd
, contents
+ roff
, offset
,
1065 r_type
) != bfd_reloc_ok
)
1068 changed_contents
= TRUE
;
1069 changed_relocs
= TRUE
;
1076 bfd
*obfd
= sec
->output_section
->owner
;
1077 gp
= _bfd_get_gp_value (obfd
);
1080 if (!elfNN_ia64_choose_gp (obfd
, link_info
))
1082 gp
= _bfd_get_gp_value (obfd
);
1086 /* If the data is out of range, do nothing. */
1087 if ((bfd_signed_vma
) (symaddr
- gp
) >= 0x200000
1088 ||(bfd_signed_vma
) (symaddr
- gp
) < -0x200000)
1091 if (r_type
== R_IA64_LTOFF22X
)
1093 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
1095 changed_relocs
= TRUE
;
1096 if (dyn_i
->want_gotx
)
1098 dyn_i
->want_gotx
= 0;
1099 changed_got
|= !dyn_i
->want_got
;
1104 elfNN_ia64_relax_ldxmov (abfd
, contents
, roff
);
1105 irel
->r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
1106 changed_contents
= TRUE
;
1107 changed_relocs
= TRUE
;
1112 /* ??? If we created fixups, this may push the code segment large
1113 enough that the data segment moves, which will change the GP.
1114 Reset the GP so that we re-calculate next round. We need to
1115 do this at the _beginning_ of the next round; now will not do. */
1117 /* Clean up and go home. */
1120 struct one_fixup
*f
= fixups
;
1121 fixups
= fixups
->next
;
1126 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1128 if (! link_info
->keep_memory
)
1132 /* Cache the symbols for elf_link_input_bfd. */
1133 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1137 if (contents
!= NULL
1138 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
1140 if (!changed_contents
&& !link_info
->keep_memory
)
1144 /* Cache the section contents for elf_link_input_bfd. */
1145 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1149 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
1151 if (!changed_relocs
)
1152 free (internal_relocs
);
1154 elf_section_data (sec
)->relocs
= internal_relocs
;
1159 struct elfNN_ia64_allocate_data data
;
1160 data
.info
= link_info
;
1162 ia64_info
->self_dtpmod_offset
= (bfd_vma
) -1;
1164 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_data_got
, &data
);
1165 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_fptr_got
, &data
);
1166 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_local_got
, &data
);
1167 ia64_info
->got_sec
->size
= data
.ofs
;
1169 /* ??? Resize .rela.got too. */
1172 if (!link_info
->need_relax_finalize
)
1173 sec
->need_finalize_relax
= 0;
1175 *again
= changed_contents
|| changed_relocs
;
1179 if (isymbuf
!= NULL
&& (unsigned char *) isymbuf
!= symtab_hdr
->contents
)
1181 if (contents
!= NULL
1182 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
1184 if (internal_relocs
!= NULL
1185 && elf_section_data (sec
)->relocs
!= internal_relocs
)
1186 free (internal_relocs
);
1191 elfNN_ia64_relax_ldxmov (abfd
, contents
, off
)
1197 bfd_vma dword
, insn
;
1199 switch ((int)off
& 0x3)
1201 case 0: shift
= 5; break;
1202 case 1: shift
= 14; off
+= 3; break;
1203 case 2: shift
= 23; off
+= 6; break;
1208 dword
= bfd_get_64 (abfd
, contents
+ off
);
1209 insn
= (dword
>> shift
) & 0x1ffffffffffLL
;
1211 r1
= (insn
>> 6) & 127;
1212 r3
= (insn
>> 20) & 127;
1214 insn
= 0x8000000; /* nop */
1216 insn
= (insn
& 0x7f01fff) | 0x10800000000LL
; /* (qp) mov r1 = r3 */
1218 dword
&= ~(0x1ffffffffffLL
<< shift
);
1219 dword
|= (insn
<< shift
);
1220 bfd_put_64 (abfd
, dword
, contents
+ off
);
1223 /* Return TRUE if NAME is an unwind table section name. */
1225 static inline bfd_boolean
1226 is_unwind_section_name (abfd
, name
)
1230 size_t len1
, len2
, len3
;
1232 if (elfNN_ia64_hpux_vec (abfd
->xvec
)
1233 && !strcmp (name
, ELF_STRING_ia64_unwind_hdr
))
1236 len1
= sizeof (ELF_STRING_ia64_unwind
) - 1;
1237 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
1238 len3
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
1239 return ((strncmp (name
, ELF_STRING_ia64_unwind
, len1
) == 0
1240 && strncmp (name
, ELF_STRING_ia64_unwind_info
, len2
) != 0)
1241 || strncmp (name
, ELF_STRING_ia64_unwind_once
, len3
) == 0);
1244 /* Handle an IA-64 specific section when reading an object file. This
1245 is called when elfcode.h finds a section with an unknown type. */
1248 elfNN_ia64_section_from_shdr (abfd
, hdr
, name
)
1250 Elf_Internal_Shdr
*hdr
;
1255 /* There ought to be a place to keep ELF backend specific flags, but
1256 at the moment there isn't one. We just keep track of the
1257 sections by their name, instead. Fortunately, the ABI gives
1258 suggested names for all the MIPS specific sections, so we will
1259 probably get away with this. */
1260 switch (hdr
->sh_type
)
1262 case SHT_IA_64_UNWIND
:
1263 case SHT_IA_64_HP_OPT_ANOT
:
1267 if (strcmp (name
, ELF_STRING_ia64_archext
) != 0)
1275 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1277 newsect
= hdr
->bfd_section
;
1282 /* Convert IA-64 specific section flags to bfd internal section flags. */
1284 /* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
1288 elfNN_ia64_section_flags (flags
, hdr
)
1290 const Elf_Internal_Shdr
*hdr
;
1292 if (hdr
->sh_flags
& SHF_IA_64_SHORT
)
1293 *flags
|= SEC_SMALL_DATA
;
1298 /* Set the correct type for an IA-64 ELF section. We do this by the
1299 section name, which is a hack, but ought to work. */
1302 elfNN_ia64_fake_sections (abfd
, hdr
, sec
)
1303 bfd
*abfd ATTRIBUTE_UNUSED
;
1304 Elf_Internal_Shdr
*hdr
;
1307 register const char *name
;
1309 name
= bfd_get_section_name (abfd
, sec
);
1311 if (is_unwind_section_name (abfd
, name
))
1313 /* We don't have the sections numbered at this point, so sh_info
1314 is set later, in elfNN_ia64_final_write_processing. */
1315 hdr
->sh_type
= SHT_IA_64_UNWIND
;
1316 hdr
->sh_flags
|= SHF_LINK_ORDER
;
1318 else if (strcmp (name
, ELF_STRING_ia64_archext
) == 0)
1319 hdr
->sh_type
= SHT_IA_64_EXT
;
1320 else if (strcmp (name
, ".HP.opt_annot") == 0)
1321 hdr
->sh_type
= SHT_IA_64_HP_OPT_ANOT
;
1322 else if (strcmp (name
, ".reloc") == 0)
1323 /* This is an ugly, but unfortunately necessary hack that is
1324 needed when producing EFI binaries on IA-64. It tells
1325 elf.c:elf_fake_sections() not to consider ".reloc" as a section
1326 containing ELF relocation info. We need this hack in order to
1327 be able to generate ELF binaries that can be translated into
1328 EFI applications (which are essentially COFF objects). Those
1329 files contain a COFF ".reloc" section inside an ELFNN object,
1330 which would normally cause BFD to segfault because it would
1331 attempt to interpret this section as containing relocation
1332 entries for section "oc". With this hack enabled, ".reloc"
1333 will be treated as a normal data section, which will avoid the
1334 segfault. However, you won't be able to create an ELFNN binary
1335 with a section named "oc" that needs relocations, but that's
1336 the kind of ugly side-effects you get when detecting section
1337 types based on their names... In practice, this limitation is
1338 unlikely to bite. */
1339 hdr
->sh_type
= SHT_PROGBITS
;
1341 if (sec
->flags
& SEC_SMALL_DATA
)
1342 hdr
->sh_flags
|= SHF_IA_64_SHORT
;
1347 /* The final processing done just before writing out an IA-64 ELF
1351 elfNN_ia64_final_write_processing (abfd
, linker
)
1353 bfd_boolean linker ATTRIBUTE_UNUSED
;
1355 Elf_Internal_Shdr
*hdr
;
1357 asection
*text_sect
, *s
;
1360 for (s
= abfd
->sections
; s
; s
= s
->next
)
1362 hdr
= &elf_section_data (s
)->this_hdr
;
1363 switch (hdr
->sh_type
)
1365 case SHT_IA_64_UNWIND
:
1366 /* See comments in gas/config/tc-ia64.c:dot_endp on why we
1368 sname
= bfd_get_section_name (abfd
, s
);
1369 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
1370 if (sname
&& strncmp (sname
, ELF_STRING_ia64_unwind
, len
) == 0)
1374 if (sname
[0] == '\0')
1375 /* .IA_64.unwind -> .text */
1376 text_sect
= bfd_get_section_by_name (abfd
, ".text");
1378 /* .IA_64.unwindFOO -> FOO */
1379 text_sect
= bfd_get_section_by_name (abfd
, sname
);
1382 && (len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1,
1383 strncmp (sname
, ELF_STRING_ia64_unwind_once
, len
)) == 0)
1385 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.t.FOO */
1386 size_t len2
= sizeof (".gnu.linkonce.t.") - 1;
1387 char *once_name
= bfd_malloc (len2
+ strlen (sname
+ len
) + 1);
1389 if (once_name
!= NULL
)
1391 memcpy (once_name
, ".gnu.linkonce.t.", len2
);
1392 strcpy (once_name
+ len2
, sname
+ len
);
1393 text_sect
= bfd_get_section_by_name (abfd
, once_name
);
1397 /* Should only happen if we run out of memory, in
1398 which case we're probably toast anyway. Try to
1399 cope by finding the section the slow way. */
1400 for (text_sect
= abfd
->sections
;
1402 text_sect
= text_sect
->next
)
1404 if (strncmp (bfd_section_name (abfd
, text_sect
),
1405 ".gnu.linkonce.t.", len2
) == 0
1406 && strcmp (bfd_section_name (abfd
, text_sect
) + len2
,
1412 /* last resort: fall back on .text */
1413 text_sect
= bfd_get_section_by_name (abfd
, ".text");
1417 /* The IA-64 processor-specific ABI requires setting
1418 sh_link to the unwind section, whereas HP-UX requires
1419 sh_info to do so. For maximum compatibility, we'll
1420 set both for now... */
1421 hdr
->sh_link
= elf_section_data (text_sect
)->this_idx
;
1422 hdr
->sh_info
= elf_section_data (text_sect
)->this_idx
;
1428 if (! elf_flags_init (abfd
))
1430 unsigned long flags
= 0;
1432 if (abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
)
1433 flags
|= EF_IA_64_BE
;
1434 if (bfd_get_mach (abfd
) == bfd_mach_ia64_elf64
)
1435 flags
|= EF_IA_64_ABI64
;
1437 elf_elfheader(abfd
)->e_flags
= flags
;
1438 elf_flags_init (abfd
) = TRUE
;
1442 /* Hook called by the linker routine which adds symbols from an object
1443 file. We use it to put .comm items in .sbss, and not .bss. */
1446 elfNN_ia64_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
1448 struct bfd_link_info
*info
;
1449 Elf_Internal_Sym
*sym
;
1450 const char **namep ATTRIBUTE_UNUSED
;
1451 flagword
*flagsp ATTRIBUTE_UNUSED
;
1455 if (sym
->st_shndx
== SHN_COMMON
1456 && !info
->relocatable
1457 && sym
->st_size
<= elf_gp_size (abfd
))
1459 /* Common symbols less than or equal to -G nn bytes are
1460 automatically put into .sbss. */
1462 asection
*scomm
= bfd_get_section_by_name (abfd
, ".scommon");
1466 scomm
= bfd_make_section (abfd
, ".scommon");
1468 || !bfd_set_section_flags (abfd
, scomm
, (SEC_ALLOC
1470 | SEC_LINKER_CREATED
)))
1475 *valp
= sym
->st_size
;
1481 /* Return the number of additional phdrs we will need. */
1484 elfNN_ia64_additional_program_headers (abfd
)
1490 /* See if we need a PT_IA_64_ARCHEXT segment. */
1491 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_archext
);
1492 if (s
&& (s
->flags
& SEC_LOAD
))
1495 /* Count how many PT_IA_64_UNWIND segments we need. */
1496 for (s
= abfd
->sections
; s
; s
= s
->next
)
1497 if (is_unwind_section_name (abfd
, s
->name
) && (s
->flags
& SEC_LOAD
))
1504 elfNN_ia64_modify_segment_map (abfd
, info
)
1506 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1508 struct elf_segment_map
*m
, **pm
;
1509 Elf_Internal_Shdr
*hdr
;
1512 /* If we need a PT_IA_64_ARCHEXT segment, it must come before
1513 all PT_LOAD segments. */
1514 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_archext
);
1515 if (s
&& (s
->flags
& SEC_LOAD
))
1517 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1518 if (m
->p_type
== PT_IA_64_ARCHEXT
)
1522 m
= ((struct elf_segment_map
*)
1523 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *m
));
1527 m
->p_type
= PT_IA_64_ARCHEXT
;
1531 /* We want to put it after the PHDR and INTERP segments. */
1532 pm
= &elf_tdata (abfd
)->segment_map
;
1534 && ((*pm
)->p_type
== PT_PHDR
1535 || (*pm
)->p_type
== PT_INTERP
))
1543 /* Install PT_IA_64_UNWIND segments, if needed. */
1544 for (s
= abfd
->sections
; s
; s
= s
->next
)
1546 hdr
= &elf_section_data (s
)->this_hdr
;
1547 if (hdr
->sh_type
!= SHT_IA_64_UNWIND
)
1550 if (s
&& (s
->flags
& SEC_LOAD
))
1552 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1553 if (m
->p_type
== PT_IA_64_UNWIND
)
1557 /* Look through all sections in the unwind segment
1558 for a match since there may be multiple sections
1560 for (i
= m
->count
- 1; i
>= 0; --i
)
1561 if (m
->sections
[i
] == s
)
1570 m
= ((struct elf_segment_map
*)
1571 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *m
));
1575 m
->p_type
= PT_IA_64_UNWIND
;
1580 /* We want to put it last. */
1581 pm
= &elf_tdata (abfd
)->segment_map
;
1589 /* Turn on PF_IA_64_NORECOV if needed. This involves traversing all of
1590 the input sections for each output section in the segment and testing
1591 for SHF_IA_64_NORECOV on each. */
1592 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1593 if (m
->p_type
== PT_LOAD
)
1596 for (i
= m
->count
- 1; i
>= 0; --i
)
1598 struct bfd_link_order
*order
= m
->sections
[i
]->link_order_head
;
1601 if (order
->type
== bfd_indirect_link_order
)
1603 asection
*is
= order
->u
.indirect
.section
;
1604 bfd_vma flags
= elf_section_data(is
)->this_hdr
.sh_flags
;
1605 if (flags
& SHF_IA_64_NORECOV
)
1607 m
->p_flags
|= PF_IA_64_NORECOV
;
1611 order
= order
->next
;
1620 /* According to the Tahoe assembler spec, all labels starting with a
1624 elfNN_ia64_is_local_label_name (abfd
, name
)
1625 bfd
*abfd ATTRIBUTE_UNUSED
;
1628 return name
[0] == '.';
1631 /* Should we do dynamic things to this symbol? */
1634 elfNN_ia64_dynamic_symbol_p (h
, info
, r_type
)
1635 struct elf_link_hash_entry
*h
;
1636 struct bfd_link_info
*info
;
1639 bfd_boolean ignore_protected
1640 = ((r_type
& 0xf8) == 0x40 /* FPTR relocs */
1641 || (r_type
& 0xf8) == 0x50); /* LTOFF_FPTR relocs */
1643 return _bfd_elf_dynamic_symbol_p (h
, info
, ignore_protected
);
1646 static struct bfd_hash_entry
*
1647 elfNN_ia64_new_elf_hash_entry (entry
, table
, string
)
1648 struct bfd_hash_entry
*entry
;
1649 struct bfd_hash_table
*table
;
1652 struct elfNN_ia64_link_hash_entry
*ret
;
1653 ret
= (struct elfNN_ia64_link_hash_entry
*) entry
;
1655 /* Allocate the structure if it has not already been allocated by a
1658 ret
= bfd_hash_allocate (table
, sizeof (*ret
));
1663 /* Initialize our local data. All zeros, and definitely easier
1664 than setting a handful of bit fields. */
1665 memset (ret
, 0, sizeof (*ret
));
1667 /* Call the allocation method of the superclass. */
1668 ret
= ((struct elfNN_ia64_link_hash_entry
*)
1669 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
1672 return (struct bfd_hash_entry
*) ret
;
1676 elfNN_ia64_hash_copy_indirect (bed
, xdir
, xind
)
1677 const struct elf_backend_data
*bed ATTRIBUTE_UNUSED
;
1678 struct elf_link_hash_entry
*xdir
, *xind
;
1680 struct elfNN_ia64_link_hash_entry
*dir
, *ind
;
1682 dir
= (struct elfNN_ia64_link_hash_entry
*) xdir
;
1683 ind
= (struct elfNN_ia64_link_hash_entry
*) xind
;
1685 /* Copy down any references that we may have already seen to the
1686 symbol which just became indirect. */
1688 dir
->root
.elf_link_hash_flags
|=
1689 (ind
->root
.elf_link_hash_flags
1690 & (ELF_LINK_HASH_REF_DYNAMIC
1691 | ELF_LINK_HASH_REF_REGULAR
1692 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
1693 | ELF_LINK_HASH_NEEDS_PLT
));
1695 if (ind
->root
.root
.type
!= bfd_link_hash_indirect
)
1698 /* Copy over the got and plt data. This would have been done
1701 if (dir
->info
== NULL
)
1703 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1705 dir
->info
= dyn_i
= ind
->info
;
1708 /* Fix up the dyn_sym_info pointers to the global symbol. */
1709 for (; dyn_i
; dyn_i
= dyn_i
->next
)
1710 dyn_i
->h
= &dir
->root
;
1712 BFD_ASSERT (ind
->info
== NULL
);
1714 /* Copy over the dynindx. */
1716 if (dir
->root
.dynindx
== -1)
1718 dir
->root
.dynindx
= ind
->root
.dynindx
;
1719 dir
->root
.dynstr_index
= ind
->root
.dynstr_index
;
1720 ind
->root
.dynindx
= -1;
1721 ind
->root
.dynstr_index
= 0;
1723 BFD_ASSERT (ind
->root
.dynindx
== -1);
1727 elfNN_ia64_hash_hide_symbol (info
, xh
, force_local
)
1728 struct bfd_link_info
*info
;
1729 struct elf_link_hash_entry
*xh
;
1730 bfd_boolean force_local
;
1732 struct elfNN_ia64_link_hash_entry
*h
;
1733 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1735 h
= (struct elfNN_ia64_link_hash_entry
*)xh
;
1737 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
1739 for (dyn_i
= h
->info
; dyn_i
; dyn_i
= dyn_i
->next
)
1741 dyn_i
->want_plt2
= 0;
1742 dyn_i
->want_plt
= 0;
1746 /* Compute a hash of a local hash entry. */
1749 elfNN_ia64_local_htab_hash (ptr
)
1752 struct elfNN_ia64_local_hash_entry
*entry
1753 = (struct elfNN_ia64_local_hash_entry
*) ptr
;
1755 return (((entry
->id
& 0xff) << 24) | ((entry
->id
& 0xff00) << 8))
1756 ^ entry
->r_sym
^ (entry
->id
>> 16);
1759 /* Compare local hash entries. */
1762 elfNN_ia64_local_htab_eq (ptr1
, ptr2
)
1763 const void *ptr1
, *ptr2
;
1765 struct elfNN_ia64_local_hash_entry
*entry1
1766 = (struct elfNN_ia64_local_hash_entry
*) ptr1
;
1767 struct elfNN_ia64_local_hash_entry
*entry2
1768 = (struct elfNN_ia64_local_hash_entry
*) ptr2
;
1770 return entry1
->id
== entry2
->id
&& entry1
->r_sym
== entry2
->r_sym
;
1773 /* Create the derived linker hash table. The IA-64 ELF port uses this
1774 derived hash table to keep information specific to the IA-64 ElF
1775 linker (without using static variables). */
1777 static struct bfd_link_hash_table
*
1778 elfNN_ia64_hash_table_create (abfd
)
1781 struct elfNN_ia64_link_hash_table
*ret
;
1783 ret
= bfd_zmalloc ((bfd_size_type
) sizeof (*ret
));
1787 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
1788 elfNN_ia64_new_elf_hash_entry
))
1794 ret
->loc_hash_table
= htab_try_create (1024, elfNN_ia64_local_htab_hash
,
1795 elfNN_ia64_local_htab_eq
, NULL
);
1796 ret
->loc_hash_memory
= objalloc_create ();
1797 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1803 return &ret
->root
.root
;
1806 /* Destroy IA-64 linker hash table. */
1809 elfNN_ia64_hash_table_free (hash
)
1810 struct bfd_link_hash_table
*hash
;
1812 struct elfNN_ia64_link_hash_table
*ia64_info
1813 = (struct elfNN_ia64_link_hash_table
*) hash
;
1814 if (ia64_info
->loc_hash_table
)
1815 htab_delete (ia64_info
->loc_hash_table
);
1816 if (ia64_info
->loc_hash_memory
)
1817 objalloc_free ((struct objalloc
*) ia64_info
->loc_hash_memory
);
1818 _bfd_generic_link_hash_table_free (hash
);
1821 /* Traverse both local and global hash tables. */
1823 struct elfNN_ia64_dyn_sym_traverse_data
1825 bfd_boolean (*func
) PARAMS ((struct elfNN_ia64_dyn_sym_info
*, PTR
));
1830 elfNN_ia64_global_dyn_sym_thunk (xentry
, xdata
)
1831 struct bfd_hash_entry
*xentry
;
1834 struct elfNN_ia64_link_hash_entry
*entry
1835 = (struct elfNN_ia64_link_hash_entry
*) xentry
;
1836 struct elfNN_ia64_dyn_sym_traverse_data
*data
1837 = (struct elfNN_ia64_dyn_sym_traverse_data
*) xdata
;
1838 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1840 if (entry
->root
.root
.type
== bfd_link_hash_warning
)
1841 entry
= (struct elfNN_ia64_link_hash_entry
*) entry
->root
.root
.u
.i
.link
;
1843 for (dyn_i
= entry
->info
; dyn_i
; dyn_i
= dyn_i
->next
)
1844 if (! (*data
->func
) (dyn_i
, data
->data
))
1850 elfNN_ia64_local_dyn_sym_thunk (slot
, xdata
)
1854 struct elfNN_ia64_local_hash_entry
*entry
1855 = (struct elfNN_ia64_local_hash_entry
*) *slot
;
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 for (dyn_i
= entry
->info
; dyn_i
; dyn_i
= dyn_i
->next
)
1861 if (! (*data
->func
) (dyn_i
, data
->data
))
1867 elfNN_ia64_dyn_sym_traverse (ia64_info
, func
, data
)
1868 struct elfNN_ia64_link_hash_table
*ia64_info
;
1869 bfd_boolean (*func
) PARAMS ((struct elfNN_ia64_dyn_sym_info
*, PTR
));
1872 struct elfNN_ia64_dyn_sym_traverse_data xdata
;
1877 elf_link_hash_traverse (&ia64_info
->root
,
1878 elfNN_ia64_global_dyn_sym_thunk
, &xdata
);
1879 htab_traverse (ia64_info
->loc_hash_table
,
1880 elfNN_ia64_local_dyn_sym_thunk
, &xdata
);
1884 elfNN_ia64_create_dynamic_sections (abfd
, info
)
1886 struct bfd_link_info
*info
;
1888 struct elfNN_ia64_link_hash_table
*ia64_info
;
1891 if (! _bfd_elf_create_dynamic_sections (abfd
, info
))
1894 ia64_info
= elfNN_ia64_hash_table (info
);
1896 ia64_info
->plt_sec
= bfd_get_section_by_name (abfd
, ".plt");
1897 ia64_info
->got_sec
= bfd_get_section_by_name (abfd
, ".got");
1900 flagword flags
= bfd_get_section_flags (abfd
, ia64_info
->got_sec
);
1901 bfd_set_section_flags (abfd
, ia64_info
->got_sec
, SEC_SMALL_DATA
| flags
);
1902 /* The .got section is always aligned at 8 bytes. */
1903 bfd_set_section_alignment (abfd
, ia64_info
->got_sec
, 3);
1906 if (!get_pltoff (abfd
, info
, ia64_info
))
1909 s
= bfd_make_section(abfd
, ".rela.IA_64.pltoff");
1911 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
1914 | SEC_LINKER_CREATED
1916 || !bfd_set_section_alignment (abfd
, s
, 3))
1918 ia64_info
->rel_pltoff_sec
= s
;
1920 s
= bfd_make_section(abfd
, ".rela.got");
1922 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
1925 | SEC_LINKER_CREATED
1927 || !bfd_set_section_alignment (abfd
, s
, 3))
1929 ia64_info
->rel_got_sec
= s
;
1934 /* Find and/or create a hash entry for local symbol. */
1935 static struct elfNN_ia64_local_hash_entry
*
1936 get_local_sym_hash (ia64_info
, abfd
, rel
, create
)
1937 struct elfNN_ia64_link_hash_table
*ia64_info
;
1939 const Elf_Internal_Rela
*rel
;
1942 struct elfNN_ia64_local_hash_entry e
, *ret
;
1943 asection
*sec
= abfd
->sections
;
1944 hashval_t h
= (((sec
->id
& 0xff) << 24) | ((sec
->id
& 0xff00) << 8))
1945 ^ ELFNN_R_SYM (rel
->r_info
) ^ (sec
->id
>> 16);
1949 e
.r_sym
= ELFNN_R_SYM (rel
->r_info
);
1950 slot
= htab_find_slot_with_hash (ia64_info
->loc_hash_table
, &e
, h
,
1951 create
? INSERT
: NO_INSERT
);
1957 return (struct elfNN_ia64_local_hash_entry
*) *slot
;
1959 ret
= (struct elfNN_ia64_local_hash_entry
*)
1960 objalloc_alloc ((struct objalloc
*) ia64_info
->loc_hash_memory
,
1961 sizeof (struct elfNN_ia64_local_hash_entry
));
1964 memset (ret
, 0, sizeof (*ret
));
1966 ret
->r_sym
= ELFNN_R_SYM (rel
->r_info
);
1972 /* Find and/or create a descriptor for dynamic symbol info. This will
1973 vary based on global or local symbol, and the addend to the reloc. */
1975 static struct elfNN_ia64_dyn_sym_info
*
1976 get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, create
)
1977 struct elfNN_ia64_link_hash_table
*ia64_info
;
1978 struct elf_link_hash_entry
*h
;
1980 const Elf_Internal_Rela
*rel
;
1983 struct elfNN_ia64_dyn_sym_info
**pp
;
1984 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1985 bfd_vma addend
= rel
? rel
->r_addend
: 0;
1988 pp
= &((struct elfNN_ia64_link_hash_entry
*)h
)->info
;
1991 struct elfNN_ia64_local_hash_entry
*loc_h
;
1993 loc_h
= get_local_sym_hash (ia64_info
, abfd
, rel
, create
);
1996 BFD_ASSERT (!create
);
2003 for (dyn_i
= *pp
; dyn_i
&& dyn_i
->addend
!= addend
; dyn_i
= *pp
)
2006 if (dyn_i
== NULL
&& create
)
2008 dyn_i
= ((struct elfNN_ia64_dyn_sym_info
*)
2009 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *dyn_i
));
2011 dyn_i
->addend
= addend
;
2018 get_got (abfd
, info
, ia64_info
)
2020 struct bfd_link_info
*info
;
2021 struct elfNN_ia64_link_hash_table
*ia64_info
;
2026 got
= ia64_info
->got_sec
;
2031 dynobj
= ia64_info
->root
.dynobj
;
2033 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2034 if (!_bfd_elf_create_got_section (dynobj
, info
))
2037 got
= bfd_get_section_by_name (dynobj
, ".got");
2039 ia64_info
->got_sec
= got
;
2041 /* The .got section is always aligned at 8 bytes. */
2042 if (!bfd_set_section_alignment (abfd
, got
, 3))
2045 flags
= bfd_get_section_flags (abfd
, got
);
2046 bfd_set_section_flags (abfd
, got
, SEC_SMALL_DATA
| flags
);
2052 /* Create function descriptor section (.opd). This section is called .opd
2053 because it contains "official procedure descriptors". The "official"
2054 refers to the fact that these descriptors are used when taking the address
2055 of a procedure, thus ensuring a unique address for each procedure. */
2058 get_fptr (abfd
, info
, ia64_info
)
2060 struct bfd_link_info
*info
;
2061 struct elfNN_ia64_link_hash_table
*ia64_info
;
2066 fptr
= ia64_info
->fptr_sec
;
2069 dynobj
= ia64_info
->root
.dynobj
;
2071 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2073 fptr
= bfd_make_section (dynobj
, ".opd");
2075 || !bfd_set_section_flags (dynobj
, fptr
,
2080 | (info
->pie
? 0 : SEC_READONLY
)
2081 | SEC_LINKER_CREATED
))
2082 || !bfd_set_section_alignment (abfd
, fptr
, 4))
2088 ia64_info
->fptr_sec
= fptr
;
2093 fptr_rel
= bfd_make_section(dynobj
, ".rela.opd");
2094 if (fptr_rel
== NULL
2095 || !bfd_set_section_flags (dynobj
, fptr_rel
,
2096 (SEC_ALLOC
| SEC_LOAD
2099 | SEC_LINKER_CREATED
2101 || !bfd_set_section_alignment (abfd
, fptr_rel
, 3))
2107 ia64_info
->rel_fptr_sec
= fptr_rel
;
2115 get_pltoff (abfd
, info
, ia64_info
)
2117 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2118 struct elfNN_ia64_link_hash_table
*ia64_info
;
2123 pltoff
= ia64_info
->pltoff_sec
;
2126 dynobj
= ia64_info
->root
.dynobj
;
2128 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2130 pltoff
= bfd_make_section (dynobj
, ELF_STRING_ia64_pltoff
);
2132 || !bfd_set_section_flags (dynobj
, pltoff
,
2138 | SEC_LINKER_CREATED
))
2139 || !bfd_set_section_alignment (abfd
, pltoff
, 4))
2145 ia64_info
->pltoff_sec
= pltoff
;
2152 get_reloc_section (abfd
, ia64_info
, sec
, create
)
2154 struct elfNN_ia64_link_hash_table
*ia64_info
;
2158 const char *srel_name
;
2162 srel_name
= (bfd_elf_string_from_elf_section
2163 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
2164 elf_section_data(sec
)->rel_hdr
.sh_name
));
2165 if (srel_name
== NULL
)
2168 BFD_ASSERT ((strncmp (srel_name
, ".rela", 5) == 0
2169 && strcmp (bfd_get_section_name (abfd
, sec
),
2171 || (strncmp (srel_name
, ".rel", 4) == 0
2172 && strcmp (bfd_get_section_name (abfd
, sec
),
2173 srel_name
+4) == 0));
2175 dynobj
= ia64_info
->root
.dynobj
;
2177 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2179 srel
= bfd_get_section_by_name (dynobj
, srel_name
);
2180 if (srel
== NULL
&& create
)
2182 srel
= bfd_make_section (dynobj
, srel_name
);
2184 || !bfd_set_section_flags (dynobj
, srel
,
2189 | SEC_LINKER_CREATED
2191 || !bfd_set_section_alignment (dynobj
, srel
, 3))
2199 count_dyn_reloc (bfd
*abfd
, struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2200 asection
*srel
, int type
, bfd_boolean reltext
)
2202 struct elfNN_ia64_dyn_reloc_entry
*rent
;
2204 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2205 if (rent
->srel
== srel
&& rent
->type
== type
)
2210 rent
= ((struct elfNN_ia64_dyn_reloc_entry
*)
2211 bfd_alloc (abfd
, (bfd_size_type
) sizeof (*rent
)));
2215 rent
->next
= dyn_i
->reloc_entries
;
2219 dyn_i
->reloc_entries
= rent
;
2221 rent
->reltext
= reltext
;
2228 elfNN_ia64_check_relocs (abfd
, info
, sec
, relocs
)
2230 struct bfd_link_info
*info
;
2232 const Elf_Internal_Rela
*relocs
;
2234 struct elfNN_ia64_link_hash_table
*ia64_info
;
2235 const Elf_Internal_Rela
*relend
;
2236 Elf_Internal_Shdr
*symtab_hdr
;
2237 const Elf_Internal_Rela
*rel
;
2238 asection
*got
, *fptr
, *srel
;
2240 if (info
->relocatable
)
2243 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2244 ia64_info
= elfNN_ia64_hash_table (info
);
2246 got
= fptr
= srel
= NULL
;
2248 relend
= relocs
+ sec
->reloc_count
;
2249 for (rel
= relocs
; rel
< relend
; ++rel
)
2259 NEED_LTOFF_FPTR
= 128,
2265 struct elf_link_hash_entry
*h
= NULL
;
2266 unsigned long r_symndx
= ELFNN_R_SYM (rel
->r_info
);
2267 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2269 bfd_boolean maybe_dynamic
;
2270 int dynrel_type
= R_IA64_NONE
;
2272 if (r_symndx
>= symtab_hdr
->sh_info
)
2274 /* We're dealing with a global symbol -- find its hash entry
2275 and mark it as being referenced. */
2276 long indx
= r_symndx
- symtab_hdr
->sh_info
;
2277 h
= elf_sym_hashes (abfd
)[indx
];
2278 while (h
->root
.type
== bfd_link_hash_indirect
2279 || h
->root
.type
== bfd_link_hash_warning
)
2280 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2282 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
2285 /* We can only get preliminary data on whether a symbol is
2286 locally or externally defined, as not all of the input files
2287 have yet been processed. Do something with what we know, as
2288 this may help reduce memory usage and processing time later. */
2289 maybe_dynamic
= FALSE
;
2290 if (h
&& ((!info
->executable
2291 && (!info
->symbolic
|| info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
2292 || ! (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)
2293 || h
->root
.type
== bfd_link_hash_defweak
))
2294 maybe_dynamic
= TRUE
;
2297 switch (ELFNN_R_TYPE (rel
->r_info
))
2299 case R_IA64_TPREL64MSB
:
2300 case R_IA64_TPREL64LSB
:
2301 if (info
->shared
|| maybe_dynamic
)
2302 need_entry
= NEED_DYNREL
;
2303 dynrel_type
= R_IA64_TPREL64LSB
;
2305 info
->flags
|= DF_STATIC_TLS
;
2308 case R_IA64_LTOFF_TPREL22
:
2309 need_entry
= NEED_TPREL
;
2311 info
->flags
|= DF_STATIC_TLS
;
2314 case R_IA64_DTPREL64MSB
:
2315 case R_IA64_DTPREL64LSB
:
2316 if (info
->shared
|| maybe_dynamic
)
2317 need_entry
= NEED_DYNREL
;
2318 dynrel_type
= R_IA64_DTPREL64LSB
;
2321 case R_IA64_LTOFF_DTPREL22
:
2322 need_entry
= NEED_DTPREL
;
2325 case R_IA64_DTPMOD64MSB
:
2326 case R_IA64_DTPMOD64LSB
:
2327 if (info
->shared
|| maybe_dynamic
)
2328 need_entry
= NEED_DYNREL
;
2329 dynrel_type
= R_IA64_DTPMOD64LSB
;
2332 case R_IA64_LTOFF_DTPMOD22
:
2333 need_entry
= NEED_DTPMOD
;
2336 case R_IA64_LTOFF_FPTR22
:
2337 case R_IA64_LTOFF_FPTR64I
:
2338 case R_IA64_LTOFF_FPTR32MSB
:
2339 case R_IA64_LTOFF_FPTR32LSB
:
2340 case R_IA64_LTOFF_FPTR64MSB
:
2341 case R_IA64_LTOFF_FPTR64LSB
:
2342 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
2345 case R_IA64_FPTR64I
:
2346 case R_IA64_FPTR32MSB
:
2347 case R_IA64_FPTR32LSB
:
2348 case R_IA64_FPTR64MSB
:
2349 case R_IA64_FPTR64LSB
:
2350 if (info
->shared
|| h
)
2351 need_entry
= NEED_FPTR
| NEED_DYNREL
;
2353 need_entry
= NEED_FPTR
;
2354 dynrel_type
= R_IA64_FPTR64LSB
;
2357 case R_IA64_LTOFF22
:
2358 case R_IA64_LTOFF64I
:
2359 need_entry
= NEED_GOT
;
2362 case R_IA64_LTOFF22X
:
2363 need_entry
= NEED_GOTX
;
2366 case R_IA64_PLTOFF22
:
2367 case R_IA64_PLTOFF64I
:
2368 case R_IA64_PLTOFF64MSB
:
2369 case R_IA64_PLTOFF64LSB
:
2370 need_entry
= NEED_PLTOFF
;
2374 need_entry
|= NEED_MIN_PLT
;
2378 (*info
->callbacks
->warning
)
2379 (info
, _("@pltoff reloc against local symbol"), 0,
2380 abfd
, 0, (bfd_vma
) 0);
2384 case R_IA64_PCREL21B
:
2385 case R_IA64_PCREL60B
:
2386 /* Depending on where this symbol is defined, we may or may not
2387 need a full plt entry. Only skip if we know we'll not need
2388 the entry -- static or symbolic, and the symbol definition
2389 has already been seen. */
2390 if (maybe_dynamic
&& rel
->r_addend
== 0)
2391 need_entry
= NEED_FULL_PLT
;
2397 case R_IA64_DIR32MSB
:
2398 case R_IA64_DIR32LSB
:
2399 case R_IA64_DIR64MSB
:
2400 case R_IA64_DIR64LSB
:
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_DIR64LSB
;
2407 case R_IA64_IPLTMSB
:
2408 case R_IA64_IPLTLSB
:
2409 /* Shared objects will always need at least a REL relocation. */
2410 if (info
->shared
|| maybe_dynamic
)
2411 need_entry
= NEED_DYNREL
;
2412 dynrel_type
= R_IA64_IPLTLSB
;
2415 case R_IA64_PCREL22
:
2416 case R_IA64_PCREL64I
:
2417 case R_IA64_PCREL32MSB
:
2418 case R_IA64_PCREL32LSB
:
2419 case R_IA64_PCREL64MSB
:
2420 case R_IA64_PCREL64LSB
:
2422 need_entry
= NEED_DYNREL
;
2423 dynrel_type
= R_IA64_PCREL64LSB
;
2430 if ((need_entry
& NEED_FPTR
) != 0
2433 (*info
->callbacks
->warning
)
2434 (info
, _("non-zero addend in @fptr reloc"), 0,
2435 abfd
, 0, (bfd_vma
) 0);
2438 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, TRUE
);
2440 /* Record whether or not this is a local symbol. */
2443 /* Create what's needed. */
2444 if (need_entry
& (NEED_GOT
| NEED_GOTX
| NEED_TPREL
2445 | NEED_DTPMOD
| NEED_DTPREL
))
2449 got
= get_got (abfd
, info
, ia64_info
);
2453 if (need_entry
& NEED_GOT
)
2454 dyn_i
->want_got
= 1;
2455 if (need_entry
& NEED_GOTX
)
2456 dyn_i
->want_gotx
= 1;
2457 if (need_entry
& NEED_TPREL
)
2458 dyn_i
->want_tprel
= 1;
2459 if (need_entry
& NEED_DTPMOD
)
2460 dyn_i
->want_dtpmod
= 1;
2461 if (need_entry
& NEED_DTPREL
)
2462 dyn_i
->want_dtprel
= 1;
2464 if (need_entry
& NEED_FPTR
)
2468 fptr
= get_fptr (abfd
, info
, ia64_info
);
2473 /* FPTRs for shared libraries are allocated by the dynamic
2474 linker. Make sure this local symbol will appear in the
2475 dynamic symbol table. */
2476 if (!h
&& info
->shared
)
2478 if (! (bfd_elf_link_record_local_dynamic_symbol
2479 (info
, abfd
, (long) r_symndx
)))
2483 dyn_i
->want_fptr
= 1;
2485 if (need_entry
& NEED_LTOFF_FPTR
)
2486 dyn_i
->want_ltoff_fptr
= 1;
2487 if (need_entry
& (NEED_MIN_PLT
| NEED_FULL_PLT
))
2489 if (!ia64_info
->root
.dynobj
)
2490 ia64_info
->root
.dynobj
= abfd
;
2491 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2492 dyn_i
->want_plt
= 1;
2494 if (need_entry
& NEED_FULL_PLT
)
2495 dyn_i
->want_plt2
= 1;
2496 if (need_entry
& NEED_PLTOFF
)
2497 dyn_i
->want_pltoff
= 1;
2498 if ((need_entry
& NEED_DYNREL
) && (sec
->flags
& SEC_ALLOC
))
2502 srel
= get_reloc_section (abfd
, ia64_info
, sec
, TRUE
);
2506 if (!count_dyn_reloc (abfd
, dyn_i
, srel
, dynrel_type
,
2507 (sec
->flags
& SEC_READONLY
) != 0))
2515 /* For cleanliness, and potentially faster dynamic loading, allocate
2516 external GOT entries first. */
2519 allocate_global_data_got (dyn_i
, data
)
2520 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2523 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2525 if ((dyn_i
->want_got
|| dyn_i
->want_gotx
)
2526 && ! dyn_i
->want_fptr
2527 && elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0))
2529 dyn_i
->got_offset
= x
->ofs
;
2532 if (dyn_i
->want_tprel
)
2534 dyn_i
->tprel_offset
= x
->ofs
;
2537 if (dyn_i
->want_dtpmod
)
2539 if (elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0))
2541 dyn_i
->dtpmod_offset
= x
->ofs
;
2546 struct elfNN_ia64_link_hash_table
*ia64_info
;
2548 ia64_info
= elfNN_ia64_hash_table (x
->info
);
2549 if (ia64_info
->self_dtpmod_offset
== (bfd_vma
) -1)
2551 ia64_info
->self_dtpmod_offset
= x
->ofs
;
2554 dyn_i
->dtpmod_offset
= ia64_info
->self_dtpmod_offset
;
2557 if (dyn_i
->want_dtprel
)
2559 dyn_i
->dtprel_offset
= x
->ofs
;
2565 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
2568 allocate_global_fptr_got (dyn_i
, data
)
2569 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2572 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2576 && elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, R_IA64_FPTR64LSB
))
2578 dyn_i
->got_offset
= x
->ofs
;
2584 /* Lastly, allocate all the GOT entries for local data. */
2587 allocate_local_got (dyn_i
, data
)
2588 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2591 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2593 if ((dyn_i
->want_got
|| dyn_i
->want_gotx
)
2594 && !elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0))
2596 dyn_i
->got_offset
= x
->ofs
;
2602 /* Search for the index of a global symbol in it's defining object file. */
2605 global_sym_index (h
)
2606 struct elf_link_hash_entry
*h
;
2608 struct elf_link_hash_entry
**p
;
2611 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
2612 || h
->root
.type
== bfd_link_hash_defweak
);
2614 obj
= h
->root
.u
.def
.section
->owner
;
2615 for (p
= elf_sym_hashes (obj
); *p
!= h
; ++p
)
2618 return p
- elf_sym_hashes (obj
) + elf_tdata (obj
)->symtab_hdr
.sh_info
;
2621 /* Allocate function descriptors. We can do these for every function
2622 in a main executable that is not exported. */
2625 allocate_fptr (dyn_i
, data
)
2626 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2629 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2631 if (dyn_i
->want_fptr
)
2633 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2636 while (h
->root
.type
== bfd_link_hash_indirect
2637 || h
->root
.type
== bfd_link_hash_warning
)
2638 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2640 if (!x
->info
->executable
2642 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2643 || h
->root
.type
!= bfd_link_hash_undefweak
))
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_elf_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
, 0))
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
, resolved_zero
;
2765 ia64_info
= elfNN_ia64_hash_table (x
->info
);
2767 /* Note that this can't be used in relation to FPTR relocs below. */
2768 dynamic_symbol
= elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0);
2770 shared
= x
->info
->shared
;
2771 resolved_zero
= (dyn_i
->h
2772 && ELF_ST_VISIBILITY (dyn_i
->h
->other
)
2773 && dyn_i
->h
->root
.type
== bfd_link_hash_undefweak
);
2775 /* Take care of the normal data relocations. */
2777 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2779 int count
= rent
->count
;
2783 case R_IA64_FPTR64LSB
:
2784 /* Allocate one iff !want_fptr and not PIE, which by this point
2785 will be true only if we're actually allocating one statically
2786 in the main executable. Position independent executables
2787 need a relative reloc. */
2788 if (dyn_i
->want_fptr
&& !x
->info
->pie
)
2791 case R_IA64_PCREL64LSB
:
2792 if (!dynamic_symbol
)
2795 case R_IA64_DIR64LSB
:
2796 if (!dynamic_symbol
&& !shared
)
2799 case R_IA64_IPLTLSB
:
2800 if (!dynamic_symbol
&& !shared
)
2802 /* Use two REL relocations for IPLT relocations
2803 against local symbols. */
2804 if (!dynamic_symbol
)
2807 case R_IA64_TPREL64LSB
:
2808 case R_IA64_DTPREL64LSB
:
2809 case R_IA64_DTPMOD64LSB
:
2815 ia64_info
->reltext
= 1;
2816 rent
->srel
->size
+= sizeof (ElfNN_External_Rela
) * count
;
2819 /* Take care of the GOT and PLT relocations. */
2822 && (dynamic_symbol
|| shared
)
2823 && (dyn_i
->want_got
|| dyn_i
->want_gotx
))
2824 || (dyn_i
->want_ltoff_fptr
2826 && dyn_i
->h
->dynindx
!= -1))
2828 if (!dyn_i
->want_ltoff_fptr
2831 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
2832 ia64_info
->rel_got_sec
->size
+= sizeof (ElfNN_External_Rela
);
2834 if ((dynamic_symbol
|| shared
) && dyn_i
->want_tprel
)
2835 ia64_info
->rel_got_sec
->size
+= sizeof (ElfNN_External_Rela
);
2836 if (dynamic_symbol
&& dyn_i
->want_dtpmod
)
2837 ia64_info
->rel_got_sec
->size
+= sizeof (ElfNN_External_Rela
);
2838 if (dynamic_symbol
&& dyn_i
->want_dtprel
)
2839 ia64_info
->rel_got_sec
->size
+= sizeof (ElfNN_External_Rela
);
2840 if (ia64_info
->rel_fptr_sec
&& dyn_i
->want_fptr
)
2842 if (dyn_i
->h
== NULL
|| dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
2843 ia64_info
->rel_fptr_sec
->size
+= sizeof (ElfNN_External_Rela
);
2846 if (!resolved_zero
&& dyn_i
->want_pltoff
)
2848 bfd_size_type t
= 0;
2850 /* Dynamic symbols get one IPLT relocation. Local symbols in
2851 shared libraries get two REL relocations. Local symbols in
2852 main applications get nothing. */
2854 t
= sizeof (ElfNN_External_Rela
);
2856 t
= 2 * sizeof (ElfNN_External_Rela
);
2858 ia64_info
->rel_pltoff_sec
->size
+= t
;
2865 elfNN_ia64_adjust_dynamic_symbol (info
, h
)
2866 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2867 struct elf_link_hash_entry
*h
;
2869 /* ??? Undefined symbols with PLT entries should be re-defined
2870 to be the PLT entry. */
2872 /* If this is a weak symbol, and there is a real definition, the
2873 processor independent code will have arranged for us to see the
2874 real definition first, and we can just use the same value. */
2875 if (h
->weakdef
!= NULL
)
2877 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
2878 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
2879 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
2880 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
2884 /* If this is a reference to a symbol defined by a dynamic object which
2885 is not a function, we might allocate the symbol in our .dynbss section
2886 and allocate a COPY dynamic relocation.
2888 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2895 elfNN_ia64_size_dynamic_sections (output_bfd
, info
)
2896 bfd
*output_bfd ATTRIBUTE_UNUSED
;
2897 struct bfd_link_info
*info
;
2899 struct elfNN_ia64_allocate_data data
;
2900 struct elfNN_ia64_link_hash_table
*ia64_info
;
2903 bfd_boolean relplt
= FALSE
;
2905 dynobj
= elf_hash_table(info
)->dynobj
;
2906 ia64_info
= elfNN_ia64_hash_table (info
);
2907 ia64_info
->self_dtpmod_offset
= (bfd_vma
) -1;
2908 BFD_ASSERT(dynobj
!= NULL
);
2911 /* Set the contents of the .interp section to the interpreter. */
2912 if (ia64_info
->root
.dynamic_sections_created
2913 && info
->executable
)
2915 sec
= bfd_get_section_by_name (dynobj
, ".interp");
2916 BFD_ASSERT (sec
!= NULL
);
2917 sec
->contents
= (bfd_byte
*) ELF_DYNAMIC_INTERPRETER
;
2918 sec
->size
= strlen (ELF_DYNAMIC_INTERPRETER
) + 1;
2921 /* Allocate the GOT entries. */
2923 if (ia64_info
->got_sec
)
2926 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_data_got
, &data
);
2927 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_fptr_got
, &data
);
2928 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_local_got
, &data
);
2929 ia64_info
->got_sec
->size
= data
.ofs
;
2932 /* Allocate the FPTR entries. */
2934 if (ia64_info
->fptr_sec
)
2937 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_fptr
, &data
);
2938 ia64_info
->fptr_sec
->size
= data
.ofs
;
2941 /* Now that we've seen all of the input files, we can decide which
2942 symbols need plt entries. Allocate the minimal PLT entries first.
2943 We do this even though dynamic_sections_created may be FALSE, because
2944 this has the side-effect of clearing want_plt and want_plt2. */
2947 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_plt_entries
, &data
);
2949 ia64_info
->minplt_entries
= 0;
2952 ia64_info
->minplt_entries
2953 = (data
.ofs
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
2956 /* Align the pointer for the plt2 entries. */
2957 data
.ofs
= (data
.ofs
+ 31) & (bfd_vma
) -32;
2959 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_plt2_entries
, &data
);
2960 if (data
.ofs
!= 0 || ia64_info
->root
.dynamic_sections_created
)
2962 /* FIXME: we always reserve the memory for dynamic linker even if
2963 there are no PLT entries since dynamic linker may assume the
2964 reserved memory always exists. */
2966 BFD_ASSERT (ia64_info
->root
.dynamic_sections_created
);
2968 ia64_info
->plt_sec
->size
= data
.ofs
;
2970 /* If we've got a .plt, we need some extra memory for the dynamic
2971 linker. We stuff these in .got.plt. */
2972 sec
= bfd_get_section_by_name (dynobj
, ".got.plt");
2973 sec
->size
= 8 * PLT_RESERVED_WORDS
;
2976 /* Allocate the PLTOFF entries. */
2978 if (ia64_info
->pltoff_sec
)
2981 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_pltoff_entries
, &data
);
2982 ia64_info
->pltoff_sec
->size
= data
.ofs
;
2985 if (ia64_info
->root
.dynamic_sections_created
)
2987 /* Allocate space for the dynamic relocations that turned out to be
2990 if (info
->shared
&& ia64_info
->self_dtpmod_offset
!= (bfd_vma
) -1)
2991 ia64_info
->rel_got_sec
->size
+= sizeof (ElfNN_External_Rela
);
2992 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_dynrel_entries
, &data
);
2995 /* We have now determined the sizes of the various dynamic sections.
2996 Allocate memory for them. */
2997 for (sec
= dynobj
->sections
; sec
!= NULL
; sec
= sec
->next
)
3001 if (!(sec
->flags
& SEC_LINKER_CREATED
))
3004 /* If we don't need this section, strip it from the output file.
3005 There were several sections primarily related to dynamic
3006 linking that must be create before the linker maps input
3007 sections to output sections. The linker does that before
3008 bfd_elf_size_dynamic_sections is called, and it is that
3009 function which decides whether anything needs to go into
3012 strip
= (sec
->size
== 0);
3014 if (sec
== ia64_info
->got_sec
)
3016 else if (sec
== ia64_info
->rel_got_sec
)
3019 ia64_info
->rel_got_sec
= NULL
;
3021 /* We use the reloc_count field as a counter if we need to
3022 copy relocs into the output file. */
3023 sec
->reloc_count
= 0;
3025 else if (sec
== ia64_info
->fptr_sec
)
3028 ia64_info
->fptr_sec
= NULL
;
3030 else if (sec
== ia64_info
->rel_fptr_sec
)
3033 ia64_info
->rel_fptr_sec
= NULL
;
3035 /* We use the reloc_count field as a counter if we need to
3036 copy relocs into the output file. */
3037 sec
->reloc_count
= 0;
3039 else if (sec
== ia64_info
->plt_sec
)
3042 ia64_info
->plt_sec
= NULL
;
3044 else if (sec
== ia64_info
->pltoff_sec
)
3047 ia64_info
->pltoff_sec
= NULL
;
3049 else if (sec
== ia64_info
->rel_pltoff_sec
)
3052 ia64_info
->rel_pltoff_sec
= NULL
;
3056 /* We use the reloc_count field as a counter if we need to
3057 copy relocs into the output file. */
3058 sec
->reloc_count
= 0;
3065 /* It's OK to base decisions on the section name, because none
3066 of the dynobj section names depend upon the input files. */
3067 name
= bfd_get_section_name (dynobj
, sec
);
3069 if (strcmp (name
, ".got.plt") == 0)
3071 else if (strncmp (name
, ".rel", 4) == 0)
3075 /* We use the reloc_count field as a counter if we need to
3076 copy relocs into the output file. */
3077 sec
->reloc_count
= 0;
3085 _bfd_strip_section_from_output (info
, sec
);
3088 /* Allocate memory for the section contents. */
3089 sec
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, sec
->size
);
3090 if (sec
->contents
== NULL
&& sec
->size
!= 0)
3095 if (elf_hash_table (info
)->dynamic_sections_created
)
3097 /* Add some entries to the .dynamic section. We fill in the values
3098 later (in finish_dynamic_sections) but we must add the entries now
3099 so that we get the correct size for the .dynamic section. */
3101 if (info
->executable
)
3103 /* The DT_DEBUG entry is filled in by the dynamic linker and used
3105 #define add_dynamic_entry(TAG, VAL) \
3106 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3108 if (!add_dynamic_entry (DT_DEBUG
, 0))
3112 if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE
, 0))
3114 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3119 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3120 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3121 || !add_dynamic_entry (DT_JMPREL
, 0))
3125 if (!add_dynamic_entry (DT_RELA
, 0)
3126 || !add_dynamic_entry (DT_RELASZ
, 0)
3127 || !add_dynamic_entry (DT_RELAENT
, sizeof (ElfNN_External_Rela
)))
3130 if (ia64_info
->reltext
)
3132 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3134 info
->flags
|= DF_TEXTREL
;
3138 /* ??? Perhaps force __gp local. */
3143 static bfd_reloc_status_type
3144 elfNN_ia64_install_value (abfd
, hit_addr
, v
, r_type
)
3148 unsigned int r_type
;
3150 const struct ia64_operand
*op
;
3151 int bigendian
= 0, shift
= 0;
3152 bfd_vma t0
, t1
, insn
, dword
;
3153 enum ia64_opnd opnd
;
3156 #ifdef BFD_HOST_U_64_BIT
3157 BFD_HOST_U_64_BIT val
= (BFD_HOST_U_64_BIT
) v
;
3162 opnd
= IA64_OPND_NIL
;
3167 return bfd_reloc_ok
;
3169 /* Instruction relocations. */
3172 case R_IA64_TPREL14
:
3173 case R_IA64_DTPREL14
:
3174 opnd
= IA64_OPND_IMM14
;
3177 case R_IA64_PCREL21F
: opnd
= IA64_OPND_TGT25
; break;
3178 case R_IA64_PCREL21M
: opnd
= IA64_OPND_TGT25b
; break;
3179 case R_IA64_PCREL60B
: opnd
= IA64_OPND_TGT64
; break;
3180 case R_IA64_PCREL21B
:
3181 case R_IA64_PCREL21BI
:
3182 opnd
= IA64_OPND_TGT25c
;
3186 case R_IA64_GPREL22
:
3187 case R_IA64_LTOFF22
:
3188 case R_IA64_LTOFF22X
:
3189 case R_IA64_PLTOFF22
:
3190 case R_IA64_PCREL22
:
3191 case R_IA64_LTOFF_FPTR22
:
3192 case R_IA64_TPREL22
:
3193 case R_IA64_DTPREL22
:
3194 case R_IA64_LTOFF_TPREL22
:
3195 case R_IA64_LTOFF_DTPMOD22
:
3196 case R_IA64_LTOFF_DTPREL22
:
3197 opnd
= IA64_OPND_IMM22
;
3201 case R_IA64_GPREL64I
:
3202 case R_IA64_LTOFF64I
:
3203 case R_IA64_PLTOFF64I
:
3204 case R_IA64_PCREL64I
:
3205 case R_IA64_FPTR64I
:
3206 case R_IA64_LTOFF_FPTR64I
:
3207 case R_IA64_TPREL64I
:
3208 case R_IA64_DTPREL64I
:
3209 opnd
= IA64_OPND_IMMU64
;
3212 /* Data relocations. */
3214 case R_IA64_DIR32MSB
:
3215 case R_IA64_GPREL32MSB
:
3216 case R_IA64_FPTR32MSB
:
3217 case R_IA64_PCREL32MSB
:
3218 case R_IA64_LTOFF_FPTR32MSB
:
3219 case R_IA64_SEGREL32MSB
:
3220 case R_IA64_SECREL32MSB
:
3221 case R_IA64_LTV32MSB
:
3222 case R_IA64_DTPREL32MSB
:
3223 size
= 4; bigendian
= 1;
3226 case R_IA64_DIR32LSB
:
3227 case R_IA64_GPREL32LSB
:
3228 case R_IA64_FPTR32LSB
:
3229 case R_IA64_PCREL32LSB
:
3230 case R_IA64_LTOFF_FPTR32LSB
:
3231 case R_IA64_SEGREL32LSB
:
3232 case R_IA64_SECREL32LSB
:
3233 case R_IA64_LTV32LSB
:
3234 case R_IA64_DTPREL32LSB
:
3235 size
= 4; bigendian
= 0;
3238 case R_IA64_DIR64MSB
:
3239 case R_IA64_GPREL64MSB
:
3240 case R_IA64_PLTOFF64MSB
:
3241 case R_IA64_FPTR64MSB
:
3242 case R_IA64_PCREL64MSB
:
3243 case R_IA64_LTOFF_FPTR64MSB
:
3244 case R_IA64_SEGREL64MSB
:
3245 case R_IA64_SECREL64MSB
:
3246 case R_IA64_LTV64MSB
:
3247 case R_IA64_TPREL64MSB
:
3248 case R_IA64_DTPMOD64MSB
:
3249 case R_IA64_DTPREL64MSB
:
3250 size
= 8; bigendian
= 1;
3253 case R_IA64_DIR64LSB
:
3254 case R_IA64_GPREL64LSB
:
3255 case R_IA64_PLTOFF64LSB
:
3256 case R_IA64_FPTR64LSB
:
3257 case R_IA64_PCREL64LSB
:
3258 case R_IA64_LTOFF_FPTR64LSB
:
3259 case R_IA64_SEGREL64LSB
:
3260 case R_IA64_SECREL64LSB
:
3261 case R_IA64_LTV64LSB
:
3262 case R_IA64_TPREL64LSB
:
3263 case R_IA64_DTPMOD64LSB
:
3264 case R_IA64_DTPREL64LSB
:
3265 size
= 8; bigendian
= 0;
3268 /* Unsupported / Dynamic relocations. */
3270 return bfd_reloc_notsupported
;
3275 case IA64_OPND_IMMU64
:
3276 hit_addr
-= (long) hit_addr
& 0x3;
3277 t0
= bfd_get_64 (abfd
, hit_addr
);
3278 t1
= bfd_get_64 (abfd
, hit_addr
+ 8);
3280 /* tmpl/s: bits 0.. 5 in t0
3281 slot 0: bits 5..45 in t0
3282 slot 1: bits 46..63 in t0, bits 0..22 in t1
3283 slot 2: bits 23..63 in t1 */
3285 /* First, clear the bits that form the 64 bit constant. */
3286 t0
&= ~(0x3ffffLL
<< 46);
3288 | (( (0x07fLL
<< 13) | (0x1ffLL
<< 27)
3289 | (0x01fLL
<< 22) | (0x001LL
<< 21)
3290 | (0x001LL
<< 36)) << 23));
3292 t0
|= ((val
>> 22) & 0x03ffffLL
) << 46; /* 18 lsbs of imm41 */
3293 t1
|= ((val
>> 40) & 0x7fffffLL
) << 0; /* 23 msbs of imm41 */
3294 t1
|= ( (((val
>> 0) & 0x07f) << 13) /* imm7b */
3295 | (((val
>> 7) & 0x1ff) << 27) /* imm9d */
3296 | (((val
>> 16) & 0x01f) << 22) /* imm5c */
3297 | (((val
>> 21) & 0x001) << 21) /* ic */
3298 | (((val
>> 63) & 0x001) << 36)) << 23; /* i */
3300 bfd_put_64 (abfd
, t0
, hit_addr
);
3301 bfd_put_64 (abfd
, t1
, hit_addr
+ 8);
3304 case IA64_OPND_TGT64
:
3305 hit_addr
-= (long) hit_addr
& 0x3;
3306 t0
= bfd_get_64 (abfd
, hit_addr
);
3307 t1
= bfd_get_64 (abfd
, hit_addr
+ 8);
3309 /* tmpl/s: bits 0.. 5 in t0
3310 slot 0: bits 5..45 in t0
3311 slot 1: bits 46..63 in t0, bits 0..22 in t1
3312 slot 2: bits 23..63 in t1 */
3314 /* First, clear the bits that form the 64 bit constant. */
3315 t0
&= ~(0x3ffffLL
<< 46);
3317 | ((1LL << 36 | 0xfffffLL
<< 13) << 23));
3320 t0
|= ((val
>> 20) & 0xffffLL
) << 2 << 46; /* 16 lsbs of imm39 */
3321 t1
|= ((val
>> 36) & 0x7fffffLL
) << 0; /* 23 msbs of imm39 */
3322 t1
|= ((((val
>> 0) & 0xfffffLL
) << 13) /* imm20b */
3323 | (((val
>> 59) & 0x1LL
) << 36)) << 23; /* i */
3325 bfd_put_64 (abfd
, t0
, hit_addr
);
3326 bfd_put_64 (abfd
, t1
, hit_addr
+ 8);
3330 switch ((long) hit_addr
& 0x3)
3332 case 0: shift
= 5; break;
3333 case 1: shift
= 14; hit_addr
+= 3; break;
3334 case 2: shift
= 23; hit_addr
+= 6; break;
3335 case 3: return bfd_reloc_notsupported
; /* shouldn't happen... */
3337 dword
= bfd_get_64 (abfd
, hit_addr
);
3338 insn
= (dword
>> shift
) & 0x1ffffffffffLL
;
3340 op
= elf64_ia64_operands
+ opnd
;
3341 err
= (*op
->insert
) (op
, val
, (ia64_insn
*)& insn
);
3343 return bfd_reloc_overflow
;
3345 dword
&= ~(0x1ffffffffffLL
<< shift
);
3346 dword
|= (insn
<< shift
);
3347 bfd_put_64 (abfd
, dword
, hit_addr
);
3351 /* A data relocation. */
3354 bfd_putb32 (val
, hit_addr
);
3356 bfd_putb64 (val
, hit_addr
);
3359 bfd_putl32 (val
, hit_addr
);
3361 bfd_putl64 (val
, hit_addr
);
3365 return bfd_reloc_ok
;
3369 elfNN_ia64_install_dyn_reloc (abfd
, info
, sec
, srel
, offset
, type
,
3372 struct bfd_link_info
*info
;
3380 Elf_Internal_Rela outrel
;
3383 BFD_ASSERT (dynindx
!= -1);
3384 outrel
.r_info
= ELFNN_R_INFO (dynindx
, type
);
3385 outrel
.r_addend
= addend
;
3386 outrel
.r_offset
= _bfd_elf_section_offset (abfd
, info
, sec
, offset
);
3387 if (outrel
.r_offset
>= (bfd_vma
) -2)
3389 /* Run for the hills. We shouldn't be outputting a relocation
3390 for this. So do what everyone else does and output a no-op. */
3391 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
3392 outrel
.r_addend
= 0;
3393 outrel
.r_offset
= 0;
3396 outrel
.r_offset
+= sec
->output_section
->vma
+ sec
->output_offset
;
3398 loc
= srel
->contents
;
3399 loc
+= srel
->reloc_count
++ * sizeof (ElfNN_External_Rela
);
3400 bfd_elfNN_swap_reloca_out (abfd
, &outrel
, loc
);
3401 BFD_ASSERT (sizeof (ElfNN_External_Rela
) * srel
->reloc_count
<= srel
->size
);
3404 /* Store an entry for target address TARGET_ADDR in the linkage table
3405 and return the gp-relative address of the linkage table entry. */
3408 set_got_entry (abfd
, info
, dyn_i
, dynindx
, addend
, value
, dyn_r_type
)
3410 struct bfd_link_info
*info
;
3411 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3415 unsigned int dyn_r_type
;
3417 struct elfNN_ia64_link_hash_table
*ia64_info
;
3422 ia64_info
= elfNN_ia64_hash_table (info
);
3423 got_sec
= ia64_info
->got_sec
;
3427 case R_IA64_TPREL64LSB
:
3428 done
= dyn_i
->tprel_done
;
3429 dyn_i
->tprel_done
= TRUE
;
3430 got_offset
= dyn_i
->tprel_offset
;
3432 case R_IA64_DTPMOD64LSB
:
3433 if (dyn_i
->dtpmod_offset
!= ia64_info
->self_dtpmod_offset
)
3435 done
= dyn_i
->dtpmod_done
;
3436 dyn_i
->dtpmod_done
= TRUE
;
3440 done
= ia64_info
->self_dtpmod_done
;
3441 ia64_info
->self_dtpmod_done
= TRUE
;
3444 got_offset
= dyn_i
->dtpmod_offset
;
3446 case R_IA64_DTPREL64LSB
:
3447 done
= dyn_i
->dtprel_done
;
3448 dyn_i
->dtprel_done
= TRUE
;
3449 got_offset
= dyn_i
->dtprel_offset
;
3452 done
= dyn_i
->got_done
;
3453 dyn_i
->got_done
= TRUE
;
3454 got_offset
= dyn_i
->got_offset
;
3458 BFD_ASSERT ((got_offset
& 7) == 0);
3462 /* Store the target address in the linkage table entry. */
3463 bfd_put_64 (abfd
, value
, got_sec
->contents
+ got_offset
);
3465 /* Install a dynamic relocation if needed. */
3468 || ELF_ST_VISIBILITY (dyn_i
->h
->other
) == STV_DEFAULT
3469 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
3470 && dyn_r_type
!= R_IA64_DTPREL64LSB
)
3471 || elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, info
, dyn_r_type
)
3472 || (dynindx
!= -1 && dyn_r_type
== R_IA64_FPTR64LSB
))
3473 && (!dyn_i
->want_ltoff_fptr
3476 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
3479 && dyn_r_type
!= R_IA64_TPREL64LSB
3480 && dyn_r_type
!= R_IA64_DTPMOD64LSB
3481 && dyn_r_type
!= R_IA64_DTPREL64LSB
)
3483 dyn_r_type
= R_IA64_REL64LSB
;
3488 if (bfd_big_endian (abfd
))
3492 case R_IA64_REL64LSB
:
3493 dyn_r_type
= R_IA64_REL64MSB
;
3495 case R_IA64_DIR64LSB
:
3496 dyn_r_type
= R_IA64_DIR64MSB
;
3498 case R_IA64_FPTR64LSB
:
3499 dyn_r_type
= R_IA64_FPTR64MSB
;
3501 case R_IA64_TPREL64LSB
:
3502 dyn_r_type
= R_IA64_TPREL64MSB
;
3504 case R_IA64_DTPMOD64LSB
:
3505 dyn_r_type
= R_IA64_DTPMOD64MSB
;
3507 case R_IA64_DTPREL64LSB
:
3508 dyn_r_type
= R_IA64_DTPREL64MSB
;
3516 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, got_sec
,
3517 ia64_info
->rel_got_sec
,
3518 got_offset
, dyn_r_type
,
3523 /* Return the address of the linkage table entry. */
3524 value
= (got_sec
->output_section
->vma
3525 + got_sec
->output_offset
3531 /* Fill in a function descriptor consisting of the function's code
3532 address and its global pointer. Return the descriptor's address. */
3535 set_fptr_entry (abfd
, info
, dyn_i
, value
)
3537 struct bfd_link_info
*info
;
3538 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3541 struct elfNN_ia64_link_hash_table
*ia64_info
;
3544 ia64_info
= elfNN_ia64_hash_table (info
);
3545 fptr_sec
= ia64_info
->fptr_sec
;
3547 if (!dyn_i
->fptr_done
)
3549 dyn_i
->fptr_done
= 1;
3551 /* Fill in the function descriptor. */
3552 bfd_put_64 (abfd
, value
, fptr_sec
->contents
+ dyn_i
->fptr_offset
);
3553 bfd_put_64 (abfd
, _bfd_get_gp_value (abfd
),
3554 fptr_sec
->contents
+ dyn_i
->fptr_offset
+ 8);
3555 if (ia64_info
->rel_fptr_sec
)
3557 Elf_Internal_Rela outrel
;
3560 if (bfd_little_endian (abfd
))
3561 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_IPLTLSB
);
3563 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_IPLTMSB
);
3564 outrel
.r_addend
= value
;
3565 outrel
.r_offset
= (fptr_sec
->output_section
->vma
3566 + fptr_sec
->output_offset
3567 + dyn_i
->fptr_offset
);
3568 loc
= ia64_info
->rel_fptr_sec
->contents
;
3569 loc
+= ia64_info
->rel_fptr_sec
->reloc_count
++
3570 * sizeof (ElfNN_External_Rela
);
3571 bfd_elfNN_swap_reloca_out (abfd
, &outrel
, loc
);
3575 /* Return the descriptor's address. */
3576 value
= (fptr_sec
->output_section
->vma
3577 + fptr_sec
->output_offset
3578 + dyn_i
->fptr_offset
);
3583 /* Fill in a PLTOFF entry consisting of the function's code address
3584 and its global pointer. Return the descriptor's address. */
3587 set_pltoff_entry (abfd
, info
, dyn_i
, value
, is_plt
)
3589 struct bfd_link_info
*info
;
3590 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3594 struct elfNN_ia64_link_hash_table
*ia64_info
;
3595 asection
*pltoff_sec
;
3597 ia64_info
= elfNN_ia64_hash_table (info
);
3598 pltoff_sec
= ia64_info
->pltoff_sec
;
3600 /* Don't do anything if this symbol uses a real PLT entry. In
3601 that case, we'll fill this in during finish_dynamic_symbol. */
3602 if ((! dyn_i
->want_plt
|| is_plt
)
3603 && !dyn_i
->pltoff_done
)
3605 bfd_vma gp
= _bfd_get_gp_value (abfd
);
3607 /* Fill in the function descriptor. */
3608 bfd_put_64 (abfd
, value
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
);
3609 bfd_put_64 (abfd
, gp
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
+ 8);
3611 /* Install dynamic relocations if needed. */
3615 || ELF_ST_VISIBILITY (dyn_i
->h
->other
) == STV_DEFAULT
3616 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
3618 unsigned int dyn_r_type
;
3620 if (bfd_big_endian (abfd
))
3621 dyn_r_type
= R_IA64_REL64MSB
;
3623 dyn_r_type
= R_IA64_REL64LSB
;
3625 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
3626 ia64_info
->rel_pltoff_sec
,
3627 dyn_i
->pltoff_offset
,
3628 dyn_r_type
, 0, value
);
3629 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
3630 ia64_info
->rel_pltoff_sec
,
3631 dyn_i
->pltoff_offset
+ 8,
3635 dyn_i
->pltoff_done
= 1;
3638 /* Return the descriptor's address. */
3639 value
= (pltoff_sec
->output_section
->vma
3640 + pltoff_sec
->output_offset
3641 + dyn_i
->pltoff_offset
);
3646 /* Return the base VMA address which should be subtracted from real addresses
3647 when resolving @tprel() relocation.
3648 Main program TLS (whose template starts at PT_TLS p_vaddr)
3649 is assigned offset round(16, PT_TLS p_align). */
3652 elfNN_ia64_tprel_base (info
)
3653 struct bfd_link_info
*info
;
3655 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
3657 BFD_ASSERT (tls_sec
!= NULL
);
3658 return tls_sec
->vma
- align_power ((bfd_vma
) 16, tls_sec
->alignment_power
);
3661 /* Return the base VMA address which should be subtracted from real addresses
3662 when resolving @dtprel() relocation.
3663 This is PT_TLS segment p_vaddr. */
3666 elfNN_ia64_dtprel_base (info
)
3667 struct bfd_link_info
*info
;
3669 BFD_ASSERT (elf_hash_table (info
)->tls_sec
!= NULL
);
3670 return elf_hash_table (info
)->tls_sec
->vma
;
3673 /* Called through qsort to sort the .IA_64.unwind section during a
3674 non-relocatable link. Set elfNN_ia64_unwind_entry_compare_bfd
3675 to the output bfd so we can do proper endianness frobbing. */
3677 static bfd
*elfNN_ia64_unwind_entry_compare_bfd
;
3680 elfNN_ia64_unwind_entry_compare (a
, b
)
3686 av
= bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd
, a
);
3687 bv
= bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd
, b
);
3689 return (av
< bv
? -1 : av
> bv
? 1 : 0);
3692 /* Make sure we've got ourselves a nice fat __gp value. */
3694 elfNN_ia64_choose_gp (abfd
, info
)
3696 struct bfd_link_info
*info
;
3698 bfd_vma min_vma
= (bfd_vma
) -1, max_vma
= 0;
3699 bfd_vma min_short_vma
= min_vma
, max_short_vma
= 0;
3700 struct elf_link_hash_entry
*gp
;
3703 struct elfNN_ia64_link_hash_table
*ia64_info
;
3705 ia64_info
= elfNN_ia64_hash_table (info
);
3707 /* Find the min and max vma of all sections marked short. Also collect
3708 min and max vma of any type, for use in selecting a nice gp. */
3709 for (os
= abfd
->sections
; os
; os
= os
->next
)
3713 if ((os
->flags
& SEC_ALLOC
) == 0)
3717 hi
= os
->vma
+ os
->size
;
3725 if (os
->flags
& SEC_SMALL_DATA
)
3727 if (min_short_vma
> lo
)
3729 if (max_short_vma
< hi
)
3734 /* See if the user wants to force a value. */
3735 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
3739 && (gp
->root
.type
== bfd_link_hash_defined
3740 || gp
->root
.type
== bfd_link_hash_defweak
))
3742 asection
*gp_sec
= gp
->root
.u
.def
.section
;
3743 gp_val
= (gp
->root
.u
.def
.value
3744 + gp_sec
->output_section
->vma
3745 + gp_sec
->output_offset
);
3749 /* Pick a sensible value. */
3751 asection
*got_sec
= ia64_info
->got_sec
;
3753 /* Start with just the address of the .got. */
3755 gp_val
= got_sec
->output_section
->vma
;
3756 else if (max_short_vma
!= 0)
3757 gp_val
= min_short_vma
;
3761 /* If it is possible to address the entire image, but we
3762 don't with the choice above, adjust. */
3763 if (max_vma
- min_vma
< 0x400000
3764 && max_vma
- gp_val
<= 0x200000
3765 && gp_val
- min_vma
> 0x200000)
3766 gp_val
= min_vma
+ 0x200000;
3767 else if (max_short_vma
!= 0)
3769 /* If we don't cover all the short data, adjust. */
3770 if (max_short_vma
- gp_val
>= 0x200000)
3771 gp_val
= min_short_vma
+ 0x200000;
3773 /* If we're addressing stuff past the end, adjust back. */
3774 if (gp_val
> max_vma
)
3775 gp_val
= max_vma
- 0x200000 + 8;
3779 /* Validate whether all SHF_IA_64_SHORT sections are within
3780 range of the chosen GP. */
3782 if (max_short_vma
!= 0)
3784 if (max_short_vma
- min_short_vma
>= 0x400000)
3786 (*_bfd_error_handler
)
3787 (_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
3788 bfd_get_filename (abfd
),
3789 (unsigned long) (max_short_vma
- min_short_vma
));
3792 else if ((gp_val
> min_short_vma
3793 && gp_val
- min_short_vma
> 0x200000)
3794 || (gp_val
< max_short_vma
3795 && max_short_vma
- gp_val
>= 0x200000))
3797 (*_bfd_error_handler
)
3798 (_("%s: __gp does not cover short data segment"),
3799 bfd_get_filename (abfd
));
3804 _bfd_set_gp_value (abfd
, gp_val
);
3810 elfNN_ia64_final_link (abfd
, info
)
3812 struct bfd_link_info
*info
;
3814 struct elfNN_ia64_link_hash_table
*ia64_info
;
3815 asection
*unwind_output_sec
;
3817 ia64_info
= elfNN_ia64_hash_table (info
);
3819 /* Make sure we've got ourselves a nice fat __gp value. */
3820 if (!info
->relocatable
)
3822 bfd_vma gp_val
= _bfd_get_gp_value (abfd
);
3823 struct elf_link_hash_entry
*gp
;
3827 if (! elfNN_ia64_choose_gp (abfd
, info
))
3829 gp_val
= _bfd_get_gp_value (abfd
);
3832 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
3836 gp
->root
.type
= bfd_link_hash_defined
;
3837 gp
->root
.u
.def
.value
= gp_val
;
3838 gp
->root
.u
.def
.section
= bfd_abs_section_ptr
;
3842 /* If we're producing a final executable, we need to sort the contents
3843 of the .IA_64.unwind section. Force this section to be relocated
3844 into memory rather than written immediately to the output file. */
3845 unwind_output_sec
= NULL
;
3846 if (!info
->relocatable
)
3848 asection
*s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_unwind
);
3851 unwind_output_sec
= s
->output_section
;
3852 unwind_output_sec
->contents
3853 = bfd_malloc (unwind_output_sec
->size
);
3854 if (unwind_output_sec
->contents
== NULL
)
3859 /* Invoke the regular ELF backend linker to do all the work. */
3860 if (!bfd_elf_final_link (abfd
, info
))
3863 if (unwind_output_sec
)
3865 elfNN_ia64_unwind_entry_compare_bfd
= abfd
;
3866 qsort (unwind_output_sec
->contents
,
3867 (size_t) (unwind_output_sec
->size
/ 24),
3869 elfNN_ia64_unwind_entry_compare
);
3871 if (! bfd_set_section_contents (abfd
, unwind_output_sec
,
3872 unwind_output_sec
->contents
, (bfd_vma
) 0,
3873 unwind_output_sec
->size
))
3881 elfNN_ia64_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
3882 contents
, relocs
, local_syms
, local_sections
)
3884 struct bfd_link_info
*info
;
3886 asection
*input_section
;
3888 Elf_Internal_Rela
*relocs
;
3889 Elf_Internal_Sym
*local_syms
;
3890 asection
**local_sections
;
3892 struct elfNN_ia64_link_hash_table
*ia64_info
;
3893 Elf_Internal_Shdr
*symtab_hdr
;
3894 Elf_Internal_Rela
*rel
;
3895 Elf_Internal_Rela
*relend
;
3897 bfd_boolean ret_val
= TRUE
; /* for non-fatal errors */
3900 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3901 ia64_info
= elfNN_ia64_hash_table (info
);
3903 /* Infect various flags from the input section to the output section. */
3904 if (info
->relocatable
)
3908 flags
= elf_section_data(input_section
)->this_hdr
.sh_flags
;
3909 flags
&= SHF_IA_64_NORECOV
;
3911 elf_section_data(input_section
->output_section
)
3912 ->this_hdr
.sh_flags
|= flags
;
3916 gp_val
= _bfd_get_gp_value (output_bfd
);
3917 srel
= get_reloc_section (input_bfd
, ia64_info
, input_section
, FALSE
);
3920 relend
= relocs
+ input_section
->reloc_count
;
3921 for (; rel
< relend
; ++rel
)
3923 struct elf_link_hash_entry
*h
;
3924 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3925 bfd_reloc_status_type r
;
3926 reloc_howto_type
*howto
;
3927 unsigned long r_symndx
;
3928 Elf_Internal_Sym
*sym
;
3929 unsigned int r_type
;
3933 bfd_boolean dynamic_symbol_p
;
3934 bfd_boolean undef_weak_ref
;
3936 r_type
= ELFNN_R_TYPE (rel
->r_info
);
3937 if (r_type
> R_IA64_MAX_RELOC_CODE
)
3939 (*_bfd_error_handler
)
3940 (_("%s: unknown relocation type %d"),
3941 bfd_archive_filename (input_bfd
), (int)r_type
);
3942 bfd_set_error (bfd_error_bad_value
);
3947 howto
= lookup_howto (r_type
);
3948 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
3952 undef_weak_ref
= FALSE
;
3954 if (r_symndx
< symtab_hdr
->sh_info
)
3956 /* Reloc against local symbol. */
3958 sym
= local_syms
+ r_symndx
;
3959 sym_sec
= local_sections
[r_symndx
];
3961 value
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &msec
, rel
);
3962 if ((sym_sec
->flags
& SEC_MERGE
)
3963 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3964 && sym_sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
)
3966 struct elfNN_ia64_local_hash_entry
*loc_h
;
3968 loc_h
= get_local_sym_hash (ia64_info
, input_bfd
, rel
, FALSE
);
3969 if (loc_h
&& ! loc_h
->sec_merge_done
)
3971 struct elfNN_ia64_dyn_sym_info
*dynent
;
3973 for (dynent
= loc_h
->info
; dynent
; dynent
= dynent
->next
)
3977 _bfd_merged_section_offset (output_bfd
, &msec
,
3978 elf_section_data (msec
)->
3982 dynent
->addend
-= sym
->st_value
;
3983 dynent
->addend
+= msec
->output_section
->vma
3984 + msec
->output_offset
3985 - sym_sec
->output_section
->vma
3986 - sym_sec
->output_offset
;
3988 loc_h
->sec_merge_done
= 1;
3994 bfd_boolean unresolved_reloc
;
3996 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
3998 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
3999 r_symndx
, symtab_hdr
, sym_hashes
,
4001 unresolved_reloc
, warned
);
4003 if (h
->root
.type
== bfd_link_hash_undefweak
)
4004 undef_weak_ref
= TRUE
;
4009 hit_addr
= contents
+ rel
->r_offset
;
4010 value
+= rel
->r_addend
;
4011 dynamic_symbol_p
= elfNN_ia64_dynamic_symbol_p (h
, info
, r_type
);
4022 case R_IA64_DIR32MSB
:
4023 case R_IA64_DIR32LSB
:
4024 case R_IA64_DIR64MSB
:
4025 case R_IA64_DIR64LSB
:
4026 /* Install a dynamic relocation for this reloc. */
4027 if ((dynamic_symbol_p
|| info
->shared
)
4029 && (input_section
->flags
& SEC_ALLOC
) != 0)
4031 unsigned int dyn_r_type
;
4035 BFD_ASSERT (srel
!= NULL
);
4042 /* ??? People shouldn't be doing non-pic code in
4043 shared libraries nor dynamic executables. */
4044 (*_bfd_error_handler
)
4045 (_("%s: non-pic code with imm relocation against dynamic symbol `%s'"),
4046 bfd_archive_filename (input_bfd
),
4047 h
->root
.root
.string
);
4055 /* If we don't need dynamic symbol lookup, find a
4056 matching RELATIVE relocation. */
4057 dyn_r_type
= r_type
;
4058 if (dynamic_symbol_p
)
4060 dynindx
= h
->dynindx
;
4061 addend
= rel
->r_addend
;
4068 case R_IA64_DIR32MSB
:
4069 dyn_r_type
= R_IA64_REL32MSB
;
4071 case R_IA64_DIR32LSB
:
4072 dyn_r_type
= R_IA64_REL32LSB
;
4074 case R_IA64_DIR64MSB
:
4075 dyn_r_type
= R_IA64_REL64MSB
;
4077 case R_IA64_DIR64LSB
:
4078 dyn_r_type
= R_IA64_REL64LSB
;
4088 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4089 srel
, rel
->r_offset
, dyn_r_type
,
4094 case R_IA64_LTV32MSB
:
4095 case R_IA64_LTV32LSB
:
4096 case R_IA64_LTV64MSB
:
4097 case R_IA64_LTV64LSB
:
4098 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4101 case R_IA64_GPREL22
:
4102 case R_IA64_GPREL64I
:
4103 case R_IA64_GPREL32MSB
:
4104 case R_IA64_GPREL32LSB
:
4105 case R_IA64_GPREL64MSB
:
4106 case R_IA64_GPREL64LSB
:
4107 if (dynamic_symbol_p
)
4109 (*_bfd_error_handler
)
4110 (_("%s: @gprel relocation against dynamic symbol %s"),
4111 bfd_archive_filename (input_bfd
), h
->root
.root
.string
);
4116 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4119 case R_IA64_LTOFF22
:
4120 case R_IA64_LTOFF22X
:
4121 case R_IA64_LTOFF64I
:
4122 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4123 value
= set_got_entry (input_bfd
, info
, dyn_i
, (h
? h
->dynindx
: -1),
4124 rel
->r_addend
, value
, R_IA64_DIR64LSB
);
4126 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4129 case R_IA64_PLTOFF22
:
4130 case R_IA64_PLTOFF64I
:
4131 case R_IA64_PLTOFF64MSB
:
4132 case R_IA64_PLTOFF64LSB
:
4133 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4134 value
= set_pltoff_entry (output_bfd
, info
, dyn_i
, value
, FALSE
);
4136 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4139 case R_IA64_FPTR64I
:
4140 case R_IA64_FPTR32MSB
:
4141 case R_IA64_FPTR32LSB
:
4142 case R_IA64_FPTR64MSB
:
4143 case R_IA64_FPTR64LSB
:
4144 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4145 if (dyn_i
->want_fptr
)
4147 if (!undef_weak_ref
)
4148 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
4150 if (!dyn_i
->want_fptr
|| info
->pie
)
4153 unsigned int dyn_r_type
= r_type
;
4154 bfd_vma addend
= rel
->r_addend
;
4156 /* Otherwise, we expect the dynamic linker to create
4159 if (dyn_i
->want_fptr
)
4161 if (r_type
== R_IA64_FPTR64I
)
4163 /* We can't represent this without a dynamic symbol.
4164 Adjust the relocation to be against an output
4165 section symbol, which are always present in the
4166 dynamic symbol table. */
4167 /* ??? People shouldn't be doing non-pic code in
4168 shared libraries. Hork. */
4169 (*_bfd_error_handler
)
4170 (_("%s: linking non-pic code in a position independent executable"),
4171 bfd_archive_filename (input_bfd
));
4177 dyn_r_type
= r_type
+ R_IA64_REL64LSB
- R_IA64_FPTR64LSB
;
4181 if (h
->dynindx
!= -1)
4182 dynindx
= h
->dynindx
;
4184 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4185 (info
, h
->root
.u
.def
.section
->owner
,
4186 global_sym_index (h
)));
4191 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4192 (info
, input_bfd
, (long) r_symndx
));
4196 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4197 srel
, rel
->r_offset
, dyn_r_type
,
4201 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4204 case R_IA64_LTOFF_FPTR22
:
4205 case R_IA64_LTOFF_FPTR64I
:
4206 case R_IA64_LTOFF_FPTR32MSB
:
4207 case R_IA64_LTOFF_FPTR32LSB
:
4208 case R_IA64_LTOFF_FPTR64MSB
:
4209 case R_IA64_LTOFF_FPTR64LSB
:
4213 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4214 if (dyn_i
->want_fptr
)
4216 BFD_ASSERT (h
== NULL
|| h
->dynindx
== -1)
4217 if (!undef_weak_ref
)
4218 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
4223 /* Otherwise, we expect the dynamic linker to create
4227 if (h
->dynindx
!= -1)
4228 dynindx
= h
->dynindx
;
4230 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4231 (info
, h
->root
.u
.def
.section
->owner
,
4232 global_sym_index (h
)));
4235 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4236 (info
, input_bfd
, (long) r_symndx
));
4240 value
= set_got_entry (output_bfd
, info
, dyn_i
, dynindx
,
4241 rel
->r_addend
, value
, R_IA64_FPTR64LSB
);
4243 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4247 case R_IA64_PCREL32MSB
:
4248 case R_IA64_PCREL32LSB
:
4249 case R_IA64_PCREL64MSB
:
4250 case R_IA64_PCREL64LSB
:
4251 /* Install a dynamic relocation for this reloc. */
4252 if (dynamic_symbol_p
&& r_symndx
!= 0)
4254 BFD_ASSERT (srel
!= NULL
);
4256 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4257 srel
, rel
->r_offset
, r_type
,
4258 h
->dynindx
, rel
->r_addend
);
4262 case R_IA64_PCREL21B
:
4263 case R_IA64_PCREL60B
:
4264 /* We should have created a PLT entry for any dynamic symbol. */
4267 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, FALSE
);
4269 if (dyn_i
&& dyn_i
->want_plt2
)
4271 /* Should have caught this earlier. */
4272 BFD_ASSERT (rel
->r_addend
== 0);
4274 value
= (ia64_info
->plt_sec
->output_section
->vma
4275 + ia64_info
->plt_sec
->output_offset
4276 + dyn_i
->plt2_offset
);
4280 /* Since there's no PLT entry, Validate that this is
4282 BFD_ASSERT (undef_weak_ref
|| sym_sec
->output_section
!= NULL
);
4284 /* If the symbol is undef_weak, we shouldn't be trying
4285 to call it. There's every chance that we'd wind up
4286 with an out-of-range fixup here. Don't bother setting
4287 any value at all. */
4293 case R_IA64_PCREL21BI
:
4294 case R_IA64_PCREL21F
:
4295 case R_IA64_PCREL21M
:
4296 case R_IA64_PCREL22
:
4297 case R_IA64_PCREL64I
:
4298 /* The PCREL21BI reloc is specifically not intended for use with
4299 dynamic relocs. PCREL21F and PCREL21M are used for speculation
4300 fixup code, and thus probably ought not be dynamic. The
4301 PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs. */
4302 if (dynamic_symbol_p
)
4306 if (r_type
== R_IA64_PCREL21BI
)
4307 msg
= _("%s: @internal branch to dynamic symbol %s");
4308 else if (r_type
== R_IA64_PCREL21F
|| r_type
== R_IA64_PCREL21M
)
4309 msg
= _("%s: speculation fixup to dynamic symbol %s");
4311 msg
= _("%s: @pcrel relocation against dynamic symbol %s");
4312 (*_bfd_error_handler
) (msg
, bfd_archive_filename (input_bfd
),
4313 h
->root
.root
.string
);
4320 /* Make pc-relative. */
4321 value
-= (input_section
->output_section
->vma
4322 + input_section
->output_offset
4323 + rel
->r_offset
) & ~ (bfd_vma
) 0x3;
4324 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4327 case R_IA64_SEGREL32MSB
:
4328 case R_IA64_SEGREL32LSB
:
4329 case R_IA64_SEGREL64MSB
:
4330 case R_IA64_SEGREL64LSB
:
4333 /* If the input section was discarded from the output, then
4339 struct elf_segment_map
*m
;
4340 Elf_Internal_Phdr
*p
;
4342 /* Find the segment that contains the output_section. */
4343 for (m
= elf_tdata (output_bfd
)->segment_map
,
4344 p
= elf_tdata (output_bfd
)->phdr
;
4349 for (i
= m
->count
- 1; i
>= 0; i
--)
4350 if (m
->sections
[i
] == input_section
->output_section
)
4358 r
= bfd_reloc_notsupported
;
4362 /* The VMA of the segment is the vaddr of the associated
4364 if (value
> p
->p_vaddr
)
4365 value
-= p
->p_vaddr
;
4368 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
,
4374 case R_IA64_SECREL32MSB
:
4375 case R_IA64_SECREL32LSB
:
4376 case R_IA64_SECREL64MSB
:
4377 case R_IA64_SECREL64LSB
:
4378 /* Make output-section relative. */
4379 if (value
> input_section
->output_section
->vma
)
4380 value
-= input_section
->output_section
->vma
;
4383 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4386 case R_IA64_IPLTMSB
:
4387 case R_IA64_IPLTLSB
:
4388 /* Install a dynamic relocation for this reloc. */
4389 if ((dynamic_symbol_p
|| info
->shared
)
4390 && (input_section
->flags
& SEC_ALLOC
) != 0)
4392 BFD_ASSERT (srel
!= NULL
);
4394 /* If we don't need dynamic symbol lookup, install two
4395 RELATIVE relocations. */
4396 if (!dynamic_symbol_p
)
4398 unsigned int dyn_r_type
;
4400 if (r_type
== R_IA64_IPLTMSB
)
4401 dyn_r_type
= R_IA64_REL64MSB
;
4403 dyn_r_type
= R_IA64_REL64LSB
;
4405 elfNN_ia64_install_dyn_reloc (output_bfd
, info
,
4407 srel
, rel
->r_offset
,
4408 dyn_r_type
, 0, value
);
4409 elfNN_ia64_install_dyn_reloc (output_bfd
, info
,
4411 srel
, rel
->r_offset
+ 8,
4412 dyn_r_type
, 0, gp_val
);
4415 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4416 srel
, rel
->r_offset
, r_type
,
4417 h
->dynindx
, rel
->r_addend
);
4420 if (r_type
== R_IA64_IPLTMSB
)
4421 r_type
= R_IA64_DIR64MSB
;
4423 r_type
= R_IA64_DIR64LSB
;
4424 elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4425 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
+ 8, gp_val
,
4429 case R_IA64_TPREL14
:
4430 case R_IA64_TPREL22
:
4431 case R_IA64_TPREL64I
:
4432 value
-= elfNN_ia64_tprel_base (info
);
4433 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4436 case R_IA64_DTPREL14
:
4437 case R_IA64_DTPREL22
:
4438 case R_IA64_DTPREL64I
:
4439 case R_IA64_DTPREL64LSB
:
4440 case R_IA64_DTPREL64MSB
:
4441 value
-= elfNN_ia64_dtprel_base (info
);
4442 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4445 case R_IA64_LTOFF_TPREL22
:
4446 case R_IA64_LTOFF_DTPMOD22
:
4447 case R_IA64_LTOFF_DTPREL22
:
4450 long dynindx
= h
? h
->dynindx
: -1;
4451 bfd_vma r_addend
= rel
->r_addend
;
4456 case R_IA64_LTOFF_TPREL22
:
4457 if (!dynamic_symbol_p
)
4460 value
-= elfNN_ia64_tprel_base (info
);
4463 r_addend
+= value
- elfNN_ia64_dtprel_base (info
);
4467 got_r_type
= R_IA64_TPREL64LSB
;
4469 case R_IA64_LTOFF_DTPMOD22
:
4470 if (!dynamic_symbol_p
&& !info
->shared
)
4472 got_r_type
= R_IA64_DTPMOD64LSB
;
4474 case R_IA64_LTOFF_DTPREL22
:
4475 if (!dynamic_symbol_p
)
4476 value
-= elfNN_ia64_dtprel_base (info
);
4477 got_r_type
= R_IA64_DTPREL64LSB
;
4480 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4481 value
= set_got_entry (input_bfd
, info
, dyn_i
, dynindx
, r_addend
,
4484 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
,
4490 r
= bfd_reloc_notsupported
;
4499 case bfd_reloc_undefined
:
4500 /* This can happen for global table relative relocs if
4501 __gp is undefined. This is a panic situation so we
4502 don't try to continue. */
4503 (*info
->callbacks
->undefined_symbol
)
4504 (info
, "__gp", input_bfd
, input_section
, rel
->r_offset
, 1);
4507 case bfd_reloc_notsupported
:
4512 name
= h
->root
.root
.string
;
4515 name
= bfd_elf_string_from_elf_section (input_bfd
,
4516 symtab_hdr
->sh_link
,
4521 name
= bfd_section_name (input_bfd
, input_section
);
4523 if (!(*info
->callbacks
->warning
) (info
, _("unsupported reloc"),
4525 input_section
, rel
->r_offset
))
4531 case bfd_reloc_dangerous
:
4532 case bfd_reloc_outofrange
:
4533 case bfd_reloc_overflow
:
4539 name
= h
->root
.root
.string
;
4542 name
= bfd_elf_string_from_elf_section (input_bfd
,
4543 symtab_hdr
->sh_link
,
4548 name
= bfd_section_name (input_bfd
, input_section
);
4550 if (!(*info
->callbacks
->reloc_overflow
) (info
, name
,
4567 elfNN_ia64_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
4569 struct bfd_link_info
*info
;
4570 struct elf_link_hash_entry
*h
;
4571 Elf_Internal_Sym
*sym
;
4573 struct elfNN_ia64_link_hash_table
*ia64_info
;
4574 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
4576 ia64_info
= elfNN_ia64_hash_table (info
);
4577 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, FALSE
);
4579 /* Fill in the PLT data, if required. */
4580 if (dyn_i
&& dyn_i
->want_plt
)
4582 Elf_Internal_Rela outrel
;
4585 bfd_vma plt_addr
, pltoff_addr
, gp_val
, index
;
4587 gp_val
= _bfd_get_gp_value (output_bfd
);
4589 /* Initialize the minimal PLT entry. */
4591 index
= (dyn_i
->plt_offset
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
4592 plt_sec
= ia64_info
->plt_sec
;
4593 loc
= plt_sec
->contents
+ dyn_i
->plt_offset
;
4595 memcpy (loc
, plt_min_entry
, PLT_MIN_ENTRY_SIZE
);
4596 elfNN_ia64_install_value (output_bfd
, loc
, index
, R_IA64_IMM22
);
4597 elfNN_ia64_install_value (output_bfd
, loc
+2, -dyn_i
->plt_offset
,
4600 plt_addr
= (plt_sec
->output_section
->vma
4601 + plt_sec
->output_offset
4602 + dyn_i
->plt_offset
);
4603 pltoff_addr
= set_pltoff_entry (output_bfd
, info
, dyn_i
, plt_addr
, TRUE
);
4605 /* Initialize the FULL PLT entry, if needed. */
4606 if (dyn_i
->want_plt2
)
4608 loc
= plt_sec
->contents
+ dyn_i
->plt2_offset
;
4610 memcpy (loc
, plt_full_entry
, PLT_FULL_ENTRY_SIZE
);
4611 elfNN_ia64_install_value (output_bfd
, loc
, pltoff_addr
- gp_val
,
4614 /* Mark the symbol as undefined, rather than as defined in the
4615 plt section. Leave the value alone. */
4616 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
4617 first place. But perhaps elflink.c did some for us. */
4618 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
4619 sym
->st_shndx
= SHN_UNDEF
;
4622 /* Create the dynamic relocation. */
4623 outrel
.r_offset
= pltoff_addr
;
4624 if (bfd_little_endian (output_bfd
))
4625 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_IA64_IPLTLSB
);
4627 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_IA64_IPLTMSB
);
4628 outrel
.r_addend
= 0;
4630 /* This is fun. In the .IA_64.pltoff section, we've got entries
4631 that correspond both to real PLT entries, and those that
4632 happened to resolve to local symbols but need to be created
4633 to satisfy @pltoff relocations. The .rela.IA_64.pltoff
4634 relocations for the real PLT should come at the end of the
4635 section, so that they can be indexed by plt entry at runtime.
4637 We emitted all of the relocations for the non-PLT @pltoff
4638 entries during relocate_section. So we can consider the
4639 existing sec->reloc_count to be the base of the array of
4642 loc
= ia64_info
->rel_pltoff_sec
->contents
;
4643 loc
+= ((ia64_info
->rel_pltoff_sec
->reloc_count
+ index
)
4644 * sizeof (ElfNN_External_Rela
));
4645 bfd_elfNN_swap_reloca_out (output_bfd
, &outrel
, loc
);
4648 /* Mark some specially defined symbols as absolute. */
4649 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
4650 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
4651 || strcmp (h
->root
.root
.string
, "_PROCEDURE_LINKAGE_TABLE_") == 0)
4652 sym
->st_shndx
= SHN_ABS
;
4658 elfNN_ia64_finish_dynamic_sections (abfd
, info
)
4660 struct bfd_link_info
*info
;
4662 struct elfNN_ia64_link_hash_table
*ia64_info
;
4665 ia64_info
= elfNN_ia64_hash_table (info
);
4666 dynobj
= ia64_info
->root
.dynobj
;
4668 if (elf_hash_table (info
)->dynamic_sections_created
)
4670 ElfNN_External_Dyn
*dyncon
, *dynconend
;
4671 asection
*sdyn
, *sgotplt
;
4674 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
4675 sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
4676 BFD_ASSERT (sdyn
!= NULL
);
4677 dyncon
= (ElfNN_External_Dyn
*) sdyn
->contents
;
4678 dynconend
= (ElfNN_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4680 gp_val
= _bfd_get_gp_value (abfd
);
4682 for (; dyncon
< dynconend
; dyncon
++)
4684 Elf_Internal_Dyn dyn
;
4686 bfd_elfNN_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4691 dyn
.d_un
.d_ptr
= gp_val
;
4695 dyn
.d_un
.d_val
= (ia64_info
->minplt_entries
4696 * sizeof (ElfNN_External_Rela
));
4700 /* See the comment above in finish_dynamic_symbol. */
4701 dyn
.d_un
.d_ptr
= (ia64_info
->rel_pltoff_sec
->output_section
->vma
4702 + ia64_info
->rel_pltoff_sec
->output_offset
4703 + (ia64_info
->rel_pltoff_sec
->reloc_count
4704 * sizeof (ElfNN_External_Rela
)));
4707 case DT_IA_64_PLT_RESERVE
:
4708 dyn
.d_un
.d_ptr
= (sgotplt
->output_section
->vma
4709 + sgotplt
->output_offset
);
4713 /* Do not have RELASZ include JMPREL. This makes things
4714 easier on ld.so. This is not what the rest of BFD set up. */
4715 dyn
.d_un
.d_val
-= (ia64_info
->minplt_entries
4716 * sizeof (ElfNN_External_Rela
));
4720 bfd_elfNN_swap_dyn_out (abfd
, &dyn
, dyncon
);
4723 /* Initialize the PLT0 entry. */
4724 if (ia64_info
->plt_sec
)
4726 bfd_byte
*loc
= ia64_info
->plt_sec
->contents
;
4729 memcpy (loc
, plt_header
, PLT_HEADER_SIZE
);
4731 pltres
= (sgotplt
->output_section
->vma
4732 + sgotplt
->output_offset
4735 elfNN_ia64_install_value (abfd
, loc
+1, pltres
, R_IA64_GPREL22
);
4742 /* ELF file flag handling: */
4744 /* Function to keep IA-64 specific file flags. */
4746 elfNN_ia64_set_private_flags (abfd
, flags
)
4750 BFD_ASSERT (!elf_flags_init (abfd
)
4751 || elf_elfheader (abfd
)->e_flags
== flags
);
4753 elf_elfheader (abfd
)->e_flags
= flags
;
4754 elf_flags_init (abfd
) = TRUE
;
4758 /* Merge backend specific data from an object file to the output
4759 object file when linking. */
4761 elfNN_ia64_merge_private_bfd_data (ibfd
, obfd
)
4766 bfd_boolean ok
= TRUE
;
4768 /* Don't even pretend to support mixed-format linking. */
4769 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4770 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4773 in_flags
= elf_elfheader (ibfd
)->e_flags
;
4774 out_flags
= elf_elfheader (obfd
)->e_flags
;
4776 if (! elf_flags_init (obfd
))
4778 elf_flags_init (obfd
) = TRUE
;
4779 elf_elfheader (obfd
)->e_flags
= in_flags
;
4781 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
4782 && bfd_get_arch_info (obfd
)->the_default
)
4784 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
4785 bfd_get_mach (ibfd
));
4791 /* Check flag compatibility. */
4792 if (in_flags
== out_flags
)
4795 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
4796 if (!(in_flags
& EF_IA_64_REDUCEDFP
) && (out_flags
& EF_IA_64_REDUCEDFP
))
4797 elf_elfheader (obfd
)->e_flags
&= ~EF_IA_64_REDUCEDFP
;
4799 if ((in_flags
& EF_IA_64_TRAPNIL
) != (out_flags
& EF_IA_64_TRAPNIL
))
4801 (*_bfd_error_handler
)
4802 (_("%s: linking trap-on-NULL-dereference with non-trapping files"),
4803 bfd_archive_filename (ibfd
));
4805 bfd_set_error (bfd_error_bad_value
);
4808 if ((in_flags
& EF_IA_64_BE
) != (out_flags
& EF_IA_64_BE
))
4810 (*_bfd_error_handler
)
4811 (_("%s: linking big-endian files with little-endian files"),
4812 bfd_archive_filename (ibfd
));
4814 bfd_set_error (bfd_error_bad_value
);
4817 if ((in_flags
& EF_IA_64_ABI64
) != (out_flags
& EF_IA_64_ABI64
))
4819 (*_bfd_error_handler
)
4820 (_("%s: linking 64-bit files with 32-bit files"),
4821 bfd_archive_filename (ibfd
));
4823 bfd_set_error (bfd_error_bad_value
);
4826 if ((in_flags
& EF_IA_64_CONS_GP
) != (out_flags
& EF_IA_64_CONS_GP
))
4828 (*_bfd_error_handler
)
4829 (_("%s: linking constant-gp files with non-constant-gp files"),
4830 bfd_archive_filename (ibfd
));
4832 bfd_set_error (bfd_error_bad_value
);
4835 if ((in_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
)
4836 != (out_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
4838 (*_bfd_error_handler
)
4839 (_("%s: linking auto-pic files with non-auto-pic files"),
4840 bfd_archive_filename (ibfd
));
4842 bfd_set_error (bfd_error_bad_value
);
4850 elfNN_ia64_print_private_bfd_data (abfd
, ptr
)
4854 FILE *file
= (FILE *) ptr
;
4855 flagword flags
= elf_elfheader (abfd
)->e_flags
;
4857 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
4859 fprintf (file
, "private flags = %s%s%s%s%s%s%s%s\n",
4860 (flags
& EF_IA_64_TRAPNIL
) ? "TRAPNIL, " : "",
4861 (flags
& EF_IA_64_EXT
) ? "EXT, " : "",
4862 (flags
& EF_IA_64_BE
) ? "BE, " : "LE, ",
4863 (flags
& EF_IA_64_REDUCEDFP
) ? "REDUCEDFP, " : "",
4864 (flags
& EF_IA_64_CONS_GP
) ? "CONS_GP, " : "",
4865 (flags
& EF_IA_64_NOFUNCDESC_CONS_GP
) ? "NOFUNCDESC_CONS_GP, " : "",
4866 (flags
& EF_IA_64_ABSOLUTE
) ? "ABSOLUTE, " : "",
4867 (flags
& EF_IA_64_ABI64
) ? "ABI64" : "ABI32");
4869 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
4873 static enum elf_reloc_type_class
4874 elfNN_ia64_reloc_type_class (rela
)
4875 const Elf_Internal_Rela
*rela
;
4877 switch ((int) ELFNN_R_TYPE (rela
->r_info
))
4879 case R_IA64_REL32MSB
:
4880 case R_IA64_REL32LSB
:
4881 case R_IA64_REL64MSB
:
4882 case R_IA64_REL64LSB
:
4883 return reloc_class_relative
;
4884 case R_IA64_IPLTMSB
:
4885 case R_IA64_IPLTLSB
:
4886 return reloc_class_plt
;
4888 return reloc_class_copy
;
4890 return reloc_class_normal
;
4894 static struct bfd_elf_special_section
const elfNN_ia64_special_sections
[]=
4896 { ".sbss", 5, -1, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_IA_64_SHORT
},
4897 { ".sdata", 6, -1, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_IA_64_SHORT
},
4898 { NULL
, 0, 0, 0, 0 }
4902 elfNN_ia64_hpux_vec (const bfd_target
*vec
)
4904 extern const bfd_target bfd_elfNN_ia64_hpux_big_vec
;
4905 return (vec
== & bfd_elfNN_ia64_hpux_big_vec
);
4909 elfNN_hpux_post_process_headers (abfd
, info
)
4911 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
4913 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
4915 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_HPUX
;
4916 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 1;
4920 elfNN_hpux_backend_section_from_bfd_section (abfd
, sec
, retval
)
4921 bfd
*abfd ATTRIBUTE_UNUSED
;
4925 if (bfd_is_com_section (sec
))
4927 *retval
= SHN_IA_64_ANSI_COMMON
;
4934 elfNN_hpux_backend_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
4937 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;;
4939 switch (elfsym
->internal_elf_sym
.st_shndx
)
4941 case SHN_IA_64_ANSI_COMMON
:
4942 asym
->section
= bfd_com_section_ptr
;
4943 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
4944 asym
->flags
&= ~BSF_GLOBAL
;
4950 #define TARGET_LITTLE_SYM bfd_elfNN_ia64_little_vec
4951 #define TARGET_LITTLE_NAME "elfNN-ia64-little"
4952 #define TARGET_BIG_SYM bfd_elfNN_ia64_big_vec
4953 #define TARGET_BIG_NAME "elfNN-ia64-big"
4954 #define ELF_ARCH bfd_arch_ia64
4955 #define ELF_MACHINE_CODE EM_IA_64
4956 #define ELF_MACHINE_ALT1 1999 /* EAS2.3 */
4957 #define ELF_MACHINE_ALT2 1998 /* EAS2.2 */
4958 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
4960 #define elf_backend_section_from_shdr \
4961 elfNN_ia64_section_from_shdr
4962 #define elf_backend_section_flags \
4963 elfNN_ia64_section_flags
4964 #define elf_backend_fake_sections \
4965 elfNN_ia64_fake_sections
4966 #define elf_backend_final_write_processing \
4967 elfNN_ia64_final_write_processing
4968 #define elf_backend_add_symbol_hook \
4969 elfNN_ia64_add_symbol_hook
4970 #define elf_backend_additional_program_headers \
4971 elfNN_ia64_additional_program_headers
4972 #define elf_backend_modify_segment_map \
4973 elfNN_ia64_modify_segment_map
4974 #define elf_info_to_howto \
4975 elfNN_ia64_info_to_howto
4977 #define bfd_elfNN_bfd_reloc_type_lookup \
4978 elfNN_ia64_reloc_type_lookup
4979 #define bfd_elfNN_bfd_is_local_label_name \
4980 elfNN_ia64_is_local_label_name
4981 #define bfd_elfNN_bfd_relax_section \
4982 elfNN_ia64_relax_section
4984 /* Stuff for the BFD linker: */
4985 #define bfd_elfNN_bfd_link_hash_table_create \
4986 elfNN_ia64_hash_table_create
4987 #define bfd_elfNN_bfd_link_hash_table_free \
4988 elfNN_ia64_hash_table_free
4989 #define elf_backend_create_dynamic_sections \
4990 elfNN_ia64_create_dynamic_sections
4991 #define elf_backend_check_relocs \
4992 elfNN_ia64_check_relocs
4993 #define elf_backend_adjust_dynamic_symbol \
4994 elfNN_ia64_adjust_dynamic_symbol
4995 #define elf_backend_size_dynamic_sections \
4996 elfNN_ia64_size_dynamic_sections
4997 #define elf_backend_relocate_section \
4998 elfNN_ia64_relocate_section
4999 #define elf_backend_finish_dynamic_symbol \
5000 elfNN_ia64_finish_dynamic_symbol
5001 #define elf_backend_finish_dynamic_sections \
5002 elfNN_ia64_finish_dynamic_sections
5003 #define bfd_elfNN_bfd_final_link \
5004 elfNN_ia64_final_link
5006 #define bfd_elfNN_bfd_merge_private_bfd_data \
5007 elfNN_ia64_merge_private_bfd_data
5008 #define bfd_elfNN_bfd_set_private_flags \
5009 elfNN_ia64_set_private_flags
5010 #define bfd_elfNN_bfd_print_private_bfd_data \
5011 elfNN_ia64_print_private_bfd_data
5013 #define elf_backend_plt_readonly 1
5014 #define elf_backend_want_plt_sym 0
5015 #define elf_backend_plt_alignment 5
5016 #define elf_backend_got_header_size 0
5017 #define elf_backend_want_got_plt 1
5018 #define elf_backend_may_use_rel_p 1
5019 #define elf_backend_may_use_rela_p 1
5020 #define elf_backend_default_use_rela_p 1
5021 #define elf_backend_want_dynbss 0
5022 #define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect
5023 #define elf_backend_hide_symbol elfNN_ia64_hash_hide_symbol
5024 #define elf_backend_reloc_type_class elfNN_ia64_reloc_type_class
5025 #define elf_backend_rela_normal 1
5026 #define elf_backend_special_sections elfNN_ia64_special_sections
5028 #include "elfNN-target.h"
5030 /* HPUX-specific vectors. */
5032 #undef TARGET_LITTLE_SYM
5033 #undef TARGET_LITTLE_NAME
5034 #undef TARGET_BIG_SYM
5035 #define TARGET_BIG_SYM bfd_elfNN_ia64_hpux_big_vec
5036 #undef TARGET_BIG_NAME
5037 #define TARGET_BIG_NAME "elfNN-ia64-hpux-big"
5039 /* These are HP-UX specific functions. */
5041 #undef elf_backend_post_process_headers
5042 #define elf_backend_post_process_headers elfNN_hpux_post_process_headers
5044 #undef elf_backend_section_from_bfd_section
5045 #define elf_backend_section_from_bfd_section elfNN_hpux_backend_section_from_bfd_section
5047 #undef elf_backend_symbol_processing
5048 #define elf_backend_symbol_processing elfNN_hpux_backend_symbol_processing
5050 #undef elf_backend_want_p_paddr_set_to_zero
5051 #define elf_backend_want_p_paddr_set_to_zero 1
5053 #undef ELF_MAXPAGESIZE
5054 #define ELF_MAXPAGESIZE 0x1000 /* 1K */
5057 #define elfNN_bed elfNN_ia64_hpux_bed
5059 #include "elfNN-target.h"
5061 #undef elf_backend_want_p_paddr_set_to_zero