1 /* IA-64 support for 64-bit ELF
2 Copyright 1998, 1999, 2000 Free Software Foundation, Inc.
3 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 #include "opcode/ia64.h"
30 * THE RULES for all the stuff the linker creates --
32 * GOT Entries created in response to LTOFF or LTOFF_FPTR
33 * relocations. Dynamic relocs created for dynamic
34 * symbols in an application; REL relocs for locals
35 * in a shared library.
37 * FPTR The canonical function descriptor. Created for local
38 * symbols in applications. Descriptors for dynamic symbols
39 * and local symbols in shared libraries are created by
40 * ld.so. Thus there are no dynamic relocs against these
41 * objects. The FPTR relocs for such _are_ passed through
42 * to the dynamic relocation tables.
44 * FULL_PLT Created for a PCREL21B relocation against a dynamic symbol.
45 * Requires the creation of a PLTOFF entry. This does not
46 * require any dynamic relocations.
48 * PLTOFF Created by PLTOFF relocations. For local symbols, this
49 * is an alternate function descriptor, and in shared libraries
50 * requires two REL relocations. Note that this cannot be
51 * transformed into an FPTR relocation, since it must be in
52 * range of the GP. For dynamic symbols, this is a function
53 * descriptor for a MIN_PLT entry, and requires one IPLT reloc.
55 * MIN_PLT Created by PLTOFF entries against dynamic symbols. This
56 * does not reqire dynamic relocations.
59 #define USE_RELA /* we want RELA relocs, not REL */
61 #define NELEMS(a) ((int) (sizeof (a) / sizeof ((a)[0])))
63 typedef struct bfd_hash_entry
*(*new_hash_entry_func
)
64 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
66 /* In dynamically (linker-) created sections, we generally need to keep track
67 of the place a symbol or expression got allocated to. This is done via hash
68 tables that store entries of the following type. */
70 struct elfNN_ia64_dyn_sym_info
72 /* The addend for which this entry is relevant. */
75 /* Next addend in the list. */
76 struct elfNN_ia64_dyn_sym_info
*next
;
80 bfd_vma pltoff_offset
;
84 /* The symbol table entry, if any, that this was derrived from. */
85 struct elf_link_hash_entry
*h
;
87 /* Used to count non-got, non-plt relocations for delayed sizing
88 of relocation sections. */
89 struct elfNN_ia64_dyn_reloc_entry
91 struct elfNN_ia64_dyn_reloc_entry
*next
;
97 /* True when the section contents have been updated. */
98 unsigned got_done
: 1;
99 unsigned fptr_done
: 1;
100 unsigned pltoff_done
: 1;
102 /* True for the different kinds of linker data we want created. */
103 unsigned want_got
: 1;
104 unsigned want_fptr
: 1;
105 unsigned want_ltoff_fptr
: 1;
106 unsigned want_plt
: 1;
107 unsigned want_plt2
: 1;
108 unsigned want_pltoff
: 1;
111 struct elfNN_ia64_local_hash_entry
113 struct bfd_hash_entry root
;
114 struct elfNN_ia64_dyn_sym_info
*info
;
117 struct elfNN_ia64_local_hash_table
119 struct bfd_hash_table root
;
120 /* No additional fields for now. */
123 struct elfNN_ia64_link_hash_entry
125 struct elf_link_hash_entry root
;
126 struct elfNN_ia64_dyn_sym_info
*info
;
129 struct elfNN_ia64_link_hash_table
131 /* The main hash table */
132 struct elf_link_hash_table root
;
134 asection
*got_sec
; /* the linkage table section (or NULL) */
135 asection
*rel_got_sec
; /* dynamic relocation section for same */
136 asection
*fptr_sec
; /* function descriptor table (or NULL) */
137 asection
*plt_sec
; /* the primary plt section (or NULL) */
138 asection
*pltoff_sec
; /* private descriptors for plt (or NULL) */
139 asection
*rel_pltoff_sec
; /* dynamic relocation section for same */
141 bfd_size_type minplt_entries
; /* number of minplt entries */
143 struct elfNN_ia64_local_hash_table loc_hash_table
;
146 #define elfNN_ia64_hash_table(p) \
147 ((struct elfNN_ia64_link_hash_table *) ((p)->hash))
149 static bfd_reloc_status_type elfNN_ia64_reloc
150 PARAMS ((bfd
*abfd
, arelent
*reloc
, asymbol
*sym
, PTR data
,
151 asection
*input_section
, bfd
*output_bfd
, char **error_message
));
152 static reloc_howto_type
* lookup_howto
153 PARAMS ((unsigned int rtype
));
154 static reloc_howto_type
*elfNN_ia64_reloc_type_lookup
155 PARAMS ((bfd
*abfd
, bfd_reloc_code_real_type bfd_code
));
156 static void elfNN_ia64_info_to_howto
157 PARAMS ((bfd
*abfd
, arelent
*bfd_reloc
, ElfNN_Internal_Rela
*elf_reloc
));
158 static boolean elfNN_ia64_relax_section
159 PARAMS((bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
,
161 static boolean elfNN_ia64_section_from_shdr
162 PARAMS ((bfd
*, ElfNN_Internal_Shdr
*, char *));
163 static boolean elfNN_ia64_fake_sections
164 PARAMS ((bfd
*abfd
, ElfNN_Internal_Shdr
*hdr
, asection
*sec
));
165 static boolean elfNN_ia64_add_symbol_hook
166 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, const Elf_Internal_Sym
*sym
,
167 const char **namep
, flagword
*flagsp
, asection
**secp
,
169 static int elfNN_ia64_additional_program_headers
170 PARAMS ((bfd
*abfd
));
171 static boolean elfNN_ia64_is_local_label_name
172 PARAMS ((bfd
*abfd
, const char *name
));
173 static boolean elfNN_ia64_dynamic_symbol_p
174 PARAMS ((struct elf_link_hash_entry
*h
, struct bfd_link_info
*info
));
175 static boolean elfNN_ia64_local_hash_table_init
176 PARAMS ((struct elfNN_ia64_local_hash_table
*ht
, bfd
*abfd
,
177 new_hash_entry_func
new));
178 static struct bfd_hash_entry
*elfNN_ia64_new_loc_hash_entry
179 PARAMS ((struct bfd_hash_entry
*entry
, struct bfd_hash_table
*table
,
180 const char *string
));
181 static struct bfd_hash_entry
*elfNN_ia64_new_elf_hash_entry
182 PARAMS ((struct bfd_hash_entry
*entry
, struct bfd_hash_table
*table
,
183 const char *string
));
184 static struct bfd_link_hash_table
*elfNN_ia64_hash_table_create
185 PARAMS ((bfd
*abfd
));
186 static struct elfNN_ia64_local_hash_entry
*elfNN_ia64_local_hash_lookup
187 PARAMS ((struct elfNN_ia64_local_hash_table
*table
, const char *string
,
188 boolean create
, boolean copy
));
189 static void elfNN_ia64_dyn_sym_traverse
190 PARAMS ((struct elfNN_ia64_link_hash_table
*ia64_info
,
191 boolean (*func
)(struct elfNN_ia64_dyn_sym_info
*, PTR
),
193 static boolean elfNN_ia64_create_dynamic_sections
194 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
195 static struct elfNN_ia64_dyn_sym_info
* get_dyn_sym_info
196 PARAMS ((struct elfNN_ia64_link_hash_table
*ia64_info
,
197 struct elf_link_hash_entry
*h
,
198 bfd
*abfd
, const Elf_Internal_Rela
*rel
, boolean create
));
199 static asection
*get_got
200 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
201 struct elfNN_ia64_link_hash_table
*ia64_info
));
202 static asection
*get_fptr
203 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
204 struct elfNN_ia64_link_hash_table
*ia64_info
));
205 static asection
*get_pltoff
206 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
207 struct elfNN_ia64_link_hash_table
*ia64_info
));
208 static asection
*get_reloc_section
209 PARAMS ((bfd
*abfd
, struct elfNN_ia64_link_hash_table
*ia64_info
,
210 asection
*sec
, boolean create
));
211 static boolean count_dyn_reloc
212 PARAMS ((bfd
*abfd
, struct elfNN_ia64_dyn_sym_info
*dyn_i
,
213 asection
*srel
, int type
));
214 static boolean elfNN_ia64_check_relocs
215 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
216 const Elf_Internal_Rela
*relocs
));
217 static boolean elfNN_ia64_adjust_dynamic_symbol
218 PARAMS ((struct bfd_link_info
*info
, struct elf_link_hash_entry
*h
));
219 static unsigned long global_sym_index
220 PARAMS ((struct elf_link_hash_entry
*h
));
221 static boolean allocate_fptr
222 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
223 static boolean allocate_global_data_got
224 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
225 static boolean allocate_global_fptr_got
226 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
227 static boolean allocate_local_got
228 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
229 static boolean allocate_pltoff_entries
230 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
231 static boolean allocate_plt_entries
232 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
233 static boolean allocate_plt2_entries
234 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
235 static boolean allocate_dynrel_entries
236 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
237 static boolean elfNN_ia64_size_dynamic_sections
238 PARAMS ((bfd
*output_bfd
, struct bfd_link_info
*info
));
239 static bfd_reloc_status_type elfNN_ia64_install_value
240 PARAMS ((bfd
*abfd
, bfd_byte
*hit_addr
, bfd_vma val
, unsigned int r_type
));
241 static void elfNN_ia64_install_dyn_reloc
242 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
243 asection
*srel
, bfd_vma offset
, unsigned int type
,
244 long dynindx
, bfd_vma addend
));
245 static bfd_vma set_got_entry
246 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
247 struct elfNN_ia64_dyn_sym_info
*dyn_i
, long dynindx
,
248 bfd_vma addend
, bfd_vma value
, unsigned int dyn_r_type
));
249 static bfd_vma set_fptr_entry
250 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
251 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
253 static bfd_vma set_pltoff_entry
254 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
255 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
256 bfd_vma value
, boolean
));
257 static boolean elfNN_ia64_final_link
258 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
259 static boolean elfNN_ia64_relocate_section
260 PARAMS ((bfd
*output_bfd
, struct bfd_link_info
*info
, bfd
*input_bfd
,
261 asection
*input_section
, bfd_byte
*contents
,
262 Elf_Internal_Rela
*relocs
, Elf_Internal_Sym
*local_syms
,
263 asection
**local_sections
));
264 static boolean elfNN_ia64_finish_dynamic_symbol
265 PARAMS ((bfd
*output_bfd
, struct bfd_link_info
*info
,
266 struct elf_link_hash_entry
*h
, Elf_Internal_Sym
*sym
));
267 static boolean elfNN_ia64_finish_dynamic_sections
268 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
269 static boolean elfNN_ia64_set_private_flags
270 PARAMS ((bfd
*abfd
, flagword flags
));
271 static boolean elfNN_ia64_copy_private_bfd_data
272 PARAMS ((bfd
*ibfd
, bfd
*obfd
));
273 static boolean elfNN_ia64_merge_private_bfd_data
274 PARAMS ((bfd
*ibfd
, bfd
*obfd
));
275 static boolean elfNN_ia64_print_private_bfd_data
276 PARAMS ((bfd
*abfd
, PTR ptr
));
279 /* ia64-specific relocation */
281 /* Perform a relocation. Not much to do here as all the hard work is
282 done in elfNN_ia64_final_link_relocate. */
283 static bfd_reloc_status_type
284 elfNN_ia64_reloc (abfd
, reloc
, sym
, data
, input_section
,
285 output_bfd
, error_message
)
290 asection
*input_section
;
292 char **error_message
;
296 reloc
->address
+= input_section
->output_offset
;
299 *error_message
= "Unsupported call to elfNN_ia64_reloc";
300 return bfd_reloc_notsupported
;
303 #define IA64_HOWTO(TYPE, NAME, SIZE, PCREL, IN) \
304 HOWTO (TYPE, 0, SIZE, 0, PCREL, 0, complain_overflow_signed, \
305 elfNN_ia64_reloc, NAME, false, 0, 0, IN)
307 /* This table has to be sorted according to increasing number of the
309 static reloc_howto_type ia64_howto_table
[] =
311 IA64_HOWTO (R_IA64_NONE
, "NONE", 0, false, true),
313 IA64_HOWTO (R_IA64_IMM14
, "IMM14", 0, false, true),
314 IA64_HOWTO (R_IA64_IMM22
, "IMM22", 0, false, true),
315 IA64_HOWTO (R_IA64_IMM64
, "IMM64", 0, false, true),
316 IA64_HOWTO (R_IA64_DIR32MSB
, "DIR32MSB", 2, false, true),
317 IA64_HOWTO (R_IA64_DIR32LSB
, "DIR32LSB", 2, false, true),
318 IA64_HOWTO (R_IA64_DIR64MSB
, "DIR64MSB", 4, false, true),
319 IA64_HOWTO (R_IA64_DIR64LSB
, "DIR64LSB", 4, false, true),
321 IA64_HOWTO (R_IA64_GPREL22
, "GPREL22", 0, false, true),
322 IA64_HOWTO (R_IA64_GPREL64I
, "GPREL64I", 0, false, true),
323 IA64_HOWTO (R_IA64_GPREL32MSB
, "GPREL32MSB", 2, false, true),
324 IA64_HOWTO (R_IA64_GPREL32LSB
, "GPREL32LSB", 2, false, true),
325 IA64_HOWTO (R_IA64_GPREL64MSB
, "GPREL64MSB", 4, false, true),
326 IA64_HOWTO (R_IA64_GPREL64LSB
, "GPREL64LSB", 4, false, true),
328 IA64_HOWTO (R_IA64_LTOFF22
, "LTOFF22", 0, false, true),
329 IA64_HOWTO (R_IA64_LTOFF64I
, "LTOFF64I", 0, false, true),
331 IA64_HOWTO (R_IA64_PLTOFF22
, "PLTOFF22", 0, false, true),
332 IA64_HOWTO (R_IA64_PLTOFF64I
, "PLTOFF64I", 0, false, true),
333 IA64_HOWTO (R_IA64_PLTOFF64MSB
, "PLTOFF64MSB", 4, false, true),
334 IA64_HOWTO (R_IA64_PLTOFF64LSB
, "PLTOFF64LSB", 4, false, true),
336 IA64_HOWTO (R_IA64_FPTR64I
, "FPTR64I", 0, false, true),
337 IA64_HOWTO (R_IA64_FPTR32MSB
, "FPTR32MSB", 2, false, true),
338 IA64_HOWTO (R_IA64_FPTR32LSB
, "FPTR32LSB", 2, false, true),
339 IA64_HOWTO (R_IA64_FPTR64MSB
, "FPTR64MSB", 4, false, true),
340 IA64_HOWTO (R_IA64_FPTR64LSB
, "FPTR64LSB", 4, false, true),
342 IA64_HOWTO (R_IA64_PCREL60B
, "PCREL60B", 0, true, true),
343 IA64_HOWTO (R_IA64_PCREL21B
, "PCREL21B", 0, true, true),
344 IA64_HOWTO (R_IA64_PCREL21M
, "PCREL21M", 0, true, true),
345 IA64_HOWTO (R_IA64_PCREL21F
, "PCREL21F", 0, true, true),
346 IA64_HOWTO (R_IA64_PCREL32MSB
, "PCREL32MSB", 2, true, true),
347 IA64_HOWTO (R_IA64_PCREL32LSB
, "PCREL32LSB", 2, true, true),
348 IA64_HOWTO (R_IA64_PCREL64MSB
, "PCREL64MSB", 4, true, true),
349 IA64_HOWTO (R_IA64_PCREL64LSB
, "PCREL64LSB", 4, true, true),
351 IA64_HOWTO (R_IA64_LTOFF_FPTR22
, "LTOFF_FPTR22", 0, false, true),
352 IA64_HOWTO (R_IA64_LTOFF_FPTR64I
, "LTOFF_FPTR64I", 0, false, true),
353 IA64_HOWTO (R_IA64_LTOFF_FPTR64MSB
, "LTOFF_FPTR64MSB", 4, false, true),
354 IA64_HOWTO (R_IA64_LTOFF_FPTR64LSB
, "LTOFF_FPTR64LSB", 4, false, true),
356 IA64_HOWTO (R_IA64_SEGREL32MSB
, "SEGREL32MSB", 2, false, true),
357 IA64_HOWTO (R_IA64_SEGREL32LSB
, "SEGREL32LSB", 2, false, true),
358 IA64_HOWTO (R_IA64_SEGREL64MSB
, "SEGREL64MSB", 4, false, true),
359 IA64_HOWTO (R_IA64_SEGREL64LSB
, "SEGREL64LSB", 4, false, true),
361 IA64_HOWTO (R_IA64_SECREL32MSB
, "SECREL32MSB", 2, false, true),
362 IA64_HOWTO (R_IA64_SECREL32LSB
, "SECREL32LSB", 2, false, true),
363 IA64_HOWTO (R_IA64_SECREL64MSB
, "SECREL64MSB", 4, false, true),
364 IA64_HOWTO (R_IA64_SECREL64LSB
, "SECREL64LSB", 4, false, true),
366 IA64_HOWTO (R_IA64_REL32MSB
, "REL32MSB", 2, false, true),
367 IA64_HOWTO (R_IA64_REL32LSB
, "REL32LSB", 2, false, true),
368 IA64_HOWTO (R_IA64_REL64MSB
, "REL64MSB", 4, false, true),
369 IA64_HOWTO (R_IA64_REL64LSB
, "REL64LSB", 4, false, true),
371 IA64_HOWTO (R_IA64_LTV32MSB
, "LTV32MSB", 2, false, true),
372 IA64_HOWTO (R_IA64_LTV32LSB
, "LTV32LSB", 2, false, true),
373 IA64_HOWTO (R_IA64_LTV64MSB
, "LTV64MSB", 4, false, true),
374 IA64_HOWTO (R_IA64_LTV64LSB
, "LTV64LSB", 4, false, true),
376 IA64_HOWTO (R_IA64_PCREL21BI
, "PCREL21BI", 0, true, true),
377 IA64_HOWTO (R_IA64_PCREL22
, "PCREL22", 0, true, true),
378 IA64_HOWTO (R_IA64_PCREL64I
, "PCREL64I", 0, true, true),
380 IA64_HOWTO (R_IA64_IPLTMSB
, "IPLTMSB", 4, false, true),
381 IA64_HOWTO (R_IA64_IPLTLSB
, "IPLTLSB", 4, false, true),
382 IA64_HOWTO (R_IA64_COPY
, "COPY", 4, false, true),
383 IA64_HOWTO (R_IA64_LTOFF22X
, "LTOFF22X", 0, false, true),
384 IA64_HOWTO (R_IA64_LDXMOV
, "LDXMOV", 0, false, true),
386 IA64_HOWTO (R_IA64_TPREL22
, "TPREL22", 0, false, false),
387 IA64_HOWTO (R_IA64_TPREL64MSB
, "TPREL64MSB", 8, false, false),
388 IA64_HOWTO (R_IA64_TPREL64LSB
, "TPREL64LSB", 8, false, false),
389 IA64_HOWTO (R_IA64_LTOFF_TP22
, "LTOFF_TP22", 0, false, false),
392 static unsigned char elf_code_to_howto_index
[R_IA64_MAX_RELOC_CODE
+ 1];
394 /* Given a BFD reloc type, return the matching HOWTO structure. */
396 static reloc_howto_type
*
400 static int inited
= 0;
407 memset (elf_code_to_howto_index
, 0xff, sizeof (elf_code_to_howto_index
));
408 for (i
= 0; i
< NELEMS (ia64_howto_table
); ++i
)
409 elf_code_to_howto_index
[ia64_howto_table
[i
].type
] = i
;
412 BFD_ASSERT (rtype
<= R_IA64_MAX_RELOC_CODE
);
413 i
= elf_code_to_howto_index
[rtype
];
414 if (i
>= NELEMS (ia64_howto_table
))
416 return ia64_howto_table
+ i
;
419 static reloc_howto_type
*
420 elfNN_ia64_reloc_type_lookup (abfd
, bfd_code
)
422 bfd_reloc_code_real_type bfd_code
;
428 case BFD_RELOC_NONE
: rtype
= R_IA64_NONE
; break;
430 case BFD_RELOC_IA64_IMM14
: rtype
= R_IA64_IMM14
; break;
431 case BFD_RELOC_IA64_IMM22
: rtype
= R_IA64_IMM22
; break;
432 case BFD_RELOC_IA64_IMM64
: rtype
= R_IA64_IMM64
; break;
434 case BFD_RELOC_IA64_DIR32MSB
: rtype
= R_IA64_DIR32MSB
; break;
435 case BFD_RELOC_IA64_DIR32LSB
: rtype
= R_IA64_DIR32LSB
; break;
436 case BFD_RELOC_IA64_DIR64MSB
: rtype
= R_IA64_DIR64MSB
; break;
437 case BFD_RELOC_IA64_DIR64LSB
: rtype
= R_IA64_DIR64LSB
; break;
439 case BFD_RELOC_IA64_GPREL22
: rtype
= R_IA64_GPREL22
; break;
440 case BFD_RELOC_IA64_GPREL64I
: rtype
= R_IA64_GPREL64I
; break;
441 case BFD_RELOC_IA64_GPREL32MSB
: rtype
= R_IA64_GPREL32MSB
; break;
442 case BFD_RELOC_IA64_GPREL32LSB
: rtype
= R_IA64_GPREL32LSB
; break;
443 case BFD_RELOC_IA64_GPREL64MSB
: rtype
= R_IA64_GPREL64MSB
; break;
444 case BFD_RELOC_IA64_GPREL64LSB
: rtype
= R_IA64_GPREL64LSB
; break;
446 case BFD_RELOC_IA64_LTOFF22
: rtype
= R_IA64_LTOFF22
; break;
447 case BFD_RELOC_IA64_LTOFF64I
: rtype
= R_IA64_LTOFF64I
; break;
449 case BFD_RELOC_IA64_PLTOFF22
: rtype
= R_IA64_PLTOFF22
; break;
450 case BFD_RELOC_IA64_PLTOFF64I
: rtype
= R_IA64_PLTOFF64I
; break;
451 case BFD_RELOC_IA64_PLTOFF64MSB
: rtype
= R_IA64_PLTOFF64MSB
; break;
452 case BFD_RELOC_IA64_PLTOFF64LSB
: rtype
= R_IA64_PLTOFF64LSB
; break;
453 case BFD_RELOC_IA64_FPTR64I
: rtype
= R_IA64_FPTR64I
; break;
454 case BFD_RELOC_IA64_FPTR32MSB
: rtype
= R_IA64_FPTR32MSB
; break;
455 case BFD_RELOC_IA64_FPTR32LSB
: rtype
= R_IA64_FPTR32LSB
; break;
456 case BFD_RELOC_IA64_FPTR64MSB
: rtype
= R_IA64_FPTR64MSB
; break;
457 case BFD_RELOC_IA64_FPTR64LSB
: rtype
= R_IA64_FPTR64LSB
; break;
459 case BFD_RELOC_IA64_PCREL21B
: rtype
= R_IA64_PCREL21B
; break;
460 case BFD_RELOC_IA64_PCREL21BI
: rtype
= R_IA64_PCREL21BI
; break;
461 case BFD_RELOC_IA64_PCREL21M
: rtype
= R_IA64_PCREL21M
; break;
462 case BFD_RELOC_IA64_PCREL21F
: rtype
= R_IA64_PCREL21F
; break;
463 case BFD_RELOC_IA64_PCREL22
: rtype
= R_IA64_PCREL22
; break;
464 case BFD_RELOC_IA64_PCREL60B
: rtype
= R_IA64_PCREL60B
; break;
465 case BFD_RELOC_IA64_PCREL64I
: rtype
= R_IA64_PCREL64I
; break;
466 case BFD_RELOC_IA64_PCREL32MSB
: rtype
= R_IA64_PCREL32MSB
; break;
467 case BFD_RELOC_IA64_PCREL32LSB
: rtype
= R_IA64_PCREL32LSB
; break;
468 case BFD_RELOC_IA64_PCREL64MSB
: rtype
= R_IA64_PCREL64MSB
; break;
469 case BFD_RELOC_IA64_PCREL64LSB
: rtype
= R_IA64_PCREL64LSB
; break;
471 case BFD_RELOC_IA64_LTOFF_FPTR22
: rtype
= R_IA64_LTOFF_FPTR22
; break;
472 case BFD_RELOC_IA64_LTOFF_FPTR64I
: rtype
= R_IA64_LTOFF_FPTR64I
; break;
473 case BFD_RELOC_IA64_LTOFF_FPTR64MSB
: rtype
= R_IA64_LTOFF_FPTR64MSB
; break;
474 case BFD_RELOC_IA64_LTOFF_FPTR64LSB
: rtype
= R_IA64_LTOFF_FPTR64LSB
; break;
476 case BFD_RELOC_IA64_SEGREL32MSB
: rtype
= R_IA64_SEGREL32MSB
; break;
477 case BFD_RELOC_IA64_SEGREL32LSB
: rtype
= R_IA64_SEGREL32LSB
; break;
478 case BFD_RELOC_IA64_SEGREL64MSB
: rtype
= R_IA64_SEGREL64MSB
; break;
479 case BFD_RELOC_IA64_SEGREL64LSB
: rtype
= R_IA64_SEGREL64LSB
; break;
481 case BFD_RELOC_IA64_SECREL32MSB
: rtype
= R_IA64_SECREL32MSB
; break;
482 case BFD_RELOC_IA64_SECREL32LSB
: rtype
= R_IA64_SECREL32LSB
; break;
483 case BFD_RELOC_IA64_SECREL64MSB
: rtype
= R_IA64_SECREL64MSB
; break;
484 case BFD_RELOC_IA64_SECREL64LSB
: rtype
= R_IA64_SECREL64LSB
; break;
486 case BFD_RELOC_IA64_REL32MSB
: rtype
= R_IA64_REL32MSB
; break;
487 case BFD_RELOC_IA64_REL32LSB
: rtype
= R_IA64_REL32LSB
; break;
488 case BFD_RELOC_IA64_REL64MSB
: rtype
= R_IA64_REL64MSB
; break;
489 case BFD_RELOC_IA64_REL64LSB
: rtype
= R_IA64_REL64LSB
; break;
491 case BFD_RELOC_IA64_LTV32MSB
: rtype
= R_IA64_LTV32MSB
; break;
492 case BFD_RELOC_IA64_LTV32LSB
: rtype
= R_IA64_LTV32LSB
; break;
493 case BFD_RELOC_IA64_LTV64MSB
: rtype
= R_IA64_LTV64MSB
; break;
494 case BFD_RELOC_IA64_LTV64LSB
: rtype
= R_IA64_LTV64LSB
; break;
496 case BFD_RELOC_IA64_IPLTMSB
: rtype
= R_IA64_IPLTMSB
; break;
497 case BFD_RELOC_IA64_IPLTLSB
: rtype
= R_IA64_IPLTLSB
; break;
498 case BFD_RELOC_IA64_COPY
: rtype
= R_IA64_COPY
; break;
499 case BFD_RELOC_IA64_LTOFF22X
: rtype
= R_IA64_LTOFF22X
; break;
500 case BFD_RELOC_IA64_LDXMOV
: rtype
= R_IA64_LDXMOV
; break;
502 case BFD_RELOC_IA64_TPREL22
: rtype
= R_IA64_TPREL22
; break;
503 case BFD_RELOC_IA64_TPREL64MSB
: rtype
= R_IA64_TPREL64MSB
; break;
504 case BFD_RELOC_IA64_TPREL64LSB
: rtype
= R_IA64_TPREL64LSB
; break;
505 case BFD_RELOC_IA64_LTOFF_TP22
: rtype
= R_IA64_LTOFF_TP22
; break;
509 return lookup_howto (rtype
);
512 /* Given a ELF reloc, return the matching HOWTO structure. */
515 elfNN_ia64_info_to_howto (abfd
, bfd_reloc
, elf_reloc
)
518 ElfNN_Internal_Rela
*elf_reloc
;
520 bfd_reloc
->howto
= lookup_howto (ELFNN_R_TYPE (elf_reloc
->r_info
));
523 #define PLT_HEADER_SIZE (3 * 16)
524 #define PLT_MIN_ENTRY_SIZE (1 * 16)
525 #define PLT_FULL_ENTRY_SIZE (2 * 16)
526 #define PLT_RESERVED_WORDS 3
528 static const bfd_byte plt_header
[PLT_HEADER_SIZE
] =
530 0x0b, 0x10, 0x00, 0x1c, 0x00, 0x21, /* [MMI] mov r2=r14;; */
531 0xe0, 0x00, 0x08, 0x00, 0x48, 0x00, /* addl r14=0,r2 */
532 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
533 0x0b, 0x80, 0x20, 0x1c, 0x18, 0x14, /* [MMI] ld8 r16=[r14],8;; */
534 0x10, 0x41, 0x38, 0x30, 0x28, 0x00, /* ld8 r17=[r14],8 */
535 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
536 0x11, 0x08, 0x00, 0x1c, 0x18, 0x10, /* [MIB] ld8 r1=[r14] */
537 0x60, 0x88, 0x04, 0x80, 0x03, 0x00, /* mov b6=r17 */
538 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
541 static const bfd_byte plt_min_entry
[PLT_MIN_ENTRY_SIZE
] =
543 0x11, 0x78, 0x00, 0x00, 0x00, 0x24, /* [MIB] mov r15=0 */
544 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, /* nop.i 0x0 */
545 0x00, 0x00, 0x00, 0x40 /* br.few 0 <PLT0>;; */
548 static const bfd_byte plt_full_entry
[PLT_FULL_ENTRY_SIZE
] =
550 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
551 0x00, 0x41, 0x3c, 0x30, 0x28, 0xc0, /* ld8 r16=[r15],8 */
552 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
553 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
554 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
555 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
558 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
560 /* Select out of range branch fixup type. Note that Itanium does
561 not support brl, and so it gets emulated by the kernel. */
564 static const bfd_byte oor_brl
[16] =
566 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
567 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;; */
568 0x00, 0x00, 0x00, 0xc0
571 static const bfd_byte oor_ip
[48] =
573 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
574 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, /* movl r15=0 */
575 0x01, 0x00, 0x00, 0x60,
576 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MII] nop.m 0 */
577 0x00, 0x01, 0x00, 0x60, 0x00, 0x00, /* mov r16=ip;; */
578 0xf2, 0x80, 0x00, 0x80, /* add r16=r15,r16;; */
579 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MIB] nop.m 0 */
580 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
581 0x60, 0x00, 0x80, 0x00 /* br b6;; */
584 /* These functions do relaxation for IA-64 ELF.
586 This is primarily to support branches to targets out of range;
587 relaxation of R_IA64_LTOFF22X and R_IA64_LDXMOV not yet supported. */
590 elfNN_ia64_relax_section (abfd
, sec
, link_info
, again
)
593 struct bfd_link_info
*link_info
;
598 struct one_fixup
*next
;
604 Elf_Internal_Shdr
*symtab_hdr
;
605 Elf_Internal_Rela
*internal_relocs
;
606 Elf_Internal_Rela
*free_relocs
;
607 Elf_Internal_Rela
*irel
, *irelend
;
609 bfd_byte
*free_contents
;
610 ElfNN_External_Sym
*extsyms
;
611 ElfNN_External_Sym
*free_extsyms
;
612 struct elfNN_ia64_link_hash_table
*ia64_info
;
613 struct one_fixup
*fixups
= NULL
;
614 boolean changed_contents
= false;
615 boolean changed_relocs
= false;
617 /* Assume we're not going to change any sizes, and we'll only need
621 /* Nothing to do if there are no relocations. */
622 if ((sec
->flags
& SEC_RELOC
) == 0
623 || sec
->reloc_count
== 0)
626 /* If this is the first time we have been called for this section,
627 initialize the cooked size. */
628 if (sec
->_cooked_size
== 0)
629 sec
->_cooked_size
= sec
->_raw_size
;
631 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
633 /* Load the relocations for this section. */
634 internal_relocs
= (_bfd_elfNN_link_read_relocs
635 (abfd
, sec
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
636 link_info
->keep_memory
));
637 if (internal_relocs
== NULL
)
640 if (! link_info
->keep_memory
)
641 free_relocs
= internal_relocs
;
643 ia64_info
= elfNN_ia64_hash_table (link_info
);
644 irelend
= internal_relocs
+ sec
->reloc_count
;
646 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
647 if (ELFNN_R_TYPE (irel
->r_info
) == (int) R_IA64_PCREL21B
)
650 /* No branch-type relocations. */
653 if (free_relocs
!= NULL
)
658 /* Get the section contents. */
659 free_contents
= NULL
;
660 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
661 contents
= elf_section_data (sec
)->this_hdr
.contents
;
664 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
665 if (contents
== NULL
)
667 free_contents
= contents
;
669 if (! bfd_get_section_contents (abfd
, sec
, contents
,
670 (file_ptr
) 0, sec
->_raw_size
))
674 /* Read this BFD's symbols. */
676 if (symtab_hdr
->contents
!= NULL
)
677 extsyms
= (ElfNN_External_Sym
*) symtab_hdr
->contents
;
680 extsyms
= (ElfNN_External_Sym
*) bfd_malloc (symtab_hdr
->sh_size
);
683 free_extsyms
= extsyms
;
684 if (bfd_seek (abfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
685 || (bfd_read (extsyms
, 1, symtab_hdr
->sh_size
, abfd
)
686 != symtab_hdr
->sh_size
))
690 for (; irel
< irelend
; irel
++)
692 bfd_vma symaddr
, reladdr
, trampoff
, toff
, roff
;
693 Elf_Internal_Sym isym
;
697 if (ELFNN_R_TYPE (irel
->r_info
) != (int) R_IA64_PCREL21B
)
700 /* Get the value of the symbol referred to by the reloc. */
701 if (ELFNN_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
703 /* A local symbol. */
704 bfd_elfNN_swap_symbol_in (abfd
,
705 extsyms
+ ELFNN_R_SYM (irel
->r_info
),
707 if (isym
.st_shndx
== SHN_UNDEF
)
708 continue; /* We can't do anthing with undefined symbols. */
709 else if (isym
.st_shndx
== SHN_ABS
)
710 tsec
= bfd_abs_section_ptr
;
711 else if (isym
.st_shndx
== SHN_COMMON
)
712 tsec
= bfd_com_section_ptr
;
713 else if (isym
.st_shndx
> 0 && isym
.st_shndx
< SHN_LORESERVE
)
714 tsec
= bfd_section_from_elf_index (abfd
, isym
.st_shndx
);
716 continue; /* who knows. */
718 toff
= isym
.st_value
;
723 struct elf_link_hash_entry
*h
;
724 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
726 indx
= ELFNN_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
727 h
= elf_sym_hashes (abfd
)[indx
];
728 BFD_ASSERT (h
!= NULL
);
730 while (h
->root
.type
== bfd_link_hash_indirect
731 || h
->root
.type
== bfd_link_hash_warning
)
732 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
734 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, irel
, false);
736 /* For branches to dynamic symbols, we're interested instead
737 in a branch to the PLT entry. */
738 if (dyn_i
&& dyn_i
->want_plt2
)
740 tsec
= ia64_info
->plt_sec
;
741 toff
= dyn_i
->plt2_offset
;
745 /* We can't do anthing with undefined symbols. */
746 if (h
->root
.type
== bfd_link_hash_undefined
747 || h
->root
.type
== bfd_link_hash_undefweak
)
750 tsec
= h
->root
.u
.def
.section
;
751 toff
= h
->root
.u
.def
.value
;
755 symaddr
= (tsec
->output_section
->vma
756 + tsec
->output_offset
760 roff
= irel
->r_offset
;
761 reladdr
= (sec
->output_section
->vma
765 /* If the branch is in range, no need to do anything. */
766 if ((bfd_signed_vma
) (symaddr
- reladdr
) >= -0x1000000
767 && (bfd_signed_vma
) (symaddr
- reladdr
) <= 0x0FFFFF0)
770 /* If the branch and target are in the same section, you've
771 got one honking big section and we can't help you. You'll
772 get an error message later. */
776 /* Look for an existing fixup to this address. */
777 for (f
= fixups
; f
; f
= f
->next
)
778 if (f
->tsec
== tsec
&& f
->toff
== toff
)
783 /* Two alternatives: If it's a branch to a PLT entry, we can
784 make a copy of the FULL_PLT entry. Otherwise, we'll have
785 to use a `brl' insn to get where we're going. */
789 if (tsec
== ia64_info
->plt_sec
)
790 size
= sizeof (plt_full_entry
);
794 size
= sizeof (oor_brl
);
796 size
= sizeof (oor_ip
);
800 /* Resize the current section to make room for the new branch. */
801 trampoff
= (sec
->_cooked_size
+ 15) & -16;
802 contents
= (bfd_byte
*) bfd_realloc (contents
, trampoff
+ size
);
803 if (contents
== NULL
)
805 sec
->_cooked_size
= trampoff
+ size
;
807 if (tsec
== ia64_info
->plt_sec
)
809 memcpy (contents
+ trampoff
, plt_full_entry
, size
);
811 /* Hijack the old relocation for use as the PLTOFF reloc. */
812 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
814 irel
->r_offset
= trampoff
;
819 memcpy (contents
+ trampoff
, oor_brl
, size
);
820 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
822 irel
->r_offset
= trampoff
+ 2;
824 memcpy (contents
+ trampoff
, oor_ip
, size
);
825 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
827 irel
->r_addend
-= 16;
828 irel
->r_offset
= trampoff
+ 2;
832 /* Record the fixup so we don't do it again this section. */
833 f
= (struct one_fixup
*) bfd_malloc (sizeof (*f
));
837 f
->trampoff
= trampoff
;
842 /* Nop out the reloc, since we're finalizing things here. */
843 irel
->r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
846 /* Fix up the existing branch to hit the trampoline. Hope like
847 hell this doesn't overflow too. */
848 if (elfNN_ia64_install_value (abfd
, contents
+ roff
,
849 f
->trampoff
- (roff
& -4),
850 R_IA64_PCREL21B
) != bfd_reloc_ok
)
853 changed_contents
= true;
854 changed_relocs
= true;
857 /* Clean up and go home. */
860 struct one_fixup
*f
= fixups
;
861 fixups
= fixups
->next
;
866 elf_section_data (sec
)->relocs
= internal_relocs
;
867 else if (free_relocs
!= NULL
)
870 if (changed_contents
)
871 elf_section_data (sec
)->this_hdr
.contents
= contents
;
872 else if (free_contents
!= NULL
)
874 if (! link_info
->keep_memory
)
875 free (free_contents
);
878 /* Cache the section contents for elf_link_input_bfd. */
879 elf_section_data (sec
)->this_hdr
.contents
= contents
;
883 if (free_extsyms
!= NULL
)
885 if (! link_info
->keep_memory
)
889 /* Cache the symbols for elf_link_input_bfd. */
890 symtab_hdr
->contents
= extsyms
;
894 *again
= changed_contents
|| changed_relocs
;
898 if (free_relocs
!= NULL
)
900 if (free_contents
!= NULL
)
901 free (free_contents
);
902 if (free_extsyms
!= NULL
)
907 /* Handle an IA-64 specific section when reading an object file. This
908 is called when elfcode.h finds a section with an unknown type. */
911 elfNN_ia64_section_from_shdr (abfd
, hdr
, name
)
913 ElfNN_Internal_Shdr
*hdr
;
918 /* There ought to be a place to keep ELF backend specific flags, but
919 at the moment there isn't one. We just keep track of the
920 sections by their name, instead. Fortunately, the ABI gives
921 suggested names for all the MIPS specific sections, so we will
922 probably get away with this. */
923 switch (hdr
->sh_type
)
925 case SHT_IA_64_UNWIND
:
926 if (strcmp (name
, ELF_STRING_ia64_unwind
) != 0)
931 if (strcmp (name
, ELF_STRING_ia64_archext
) != 0)
939 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
941 newsect
= hdr
->bfd_section
;
946 /* Convert IA-64 specific section flags to bfd internal section flags. */
948 /* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
952 elfNN_ia64_section_flags (flags
, hdr
)
954 ElfNN_Internal_Shdr
*hdr
;
956 if (hdr
->sh_flags
& SHF_IA_64_SHORT
)
957 *flags
|= SEC_SMALL_DATA
;
962 /* Set the correct type for an IA-64 ELF section. We do this by the
963 section name, which is a hack, but ought to work. */
966 elfNN_ia64_fake_sections (abfd
, hdr
, sec
)
968 ElfNN_Internal_Shdr
*hdr
;
971 register const char *name
;
973 name
= bfd_get_section_name (abfd
, sec
);
975 if (strcmp (name
, ELF_STRING_ia64_unwind
) == 0)
976 hdr
->sh_type
= SHT_IA_64_UNWIND
;
977 else if (strcmp (name
, ELF_STRING_ia64_archext
) == 0)
978 hdr
->sh_type
= SHT_IA_64_EXT
;
979 else if (strcmp (name
, ".reloc") == 0)
981 * This is an ugly, but unfortunately necessary hack that is
982 * needed when producing EFI binaries on IA-64. It tells
983 * elf.c:elf_fake_sections() not to consider ".reloc" as a section
984 * containing ELF relocation info. We need this hack in order to
985 * be able to generate ELF binaries that can be translated into
986 * EFI applications (which are essentially COFF objects). Those
987 * files contain a COFF ".reloc" section inside an ELFNN object,
988 * which would normally cause BFD to segfault because it would
989 * attempt to interpret this section as containing relocation
990 * entries for section "oc". With this hack enabled, ".reloc"
991 * will be treated as a normal data section, which will avoid the
992 * segfault. However, you won't be able to create an ELFNN binary
993 * with a section named "oc" that needs relocations, but that's
994 * the kind of ugly side-effects you get when detecting section
995 * types based on their names... In practice, this limitation is
998 hdr
->sh_type
= SHT_PROGBITS
;
1000 if (sec
->flags
& SEC_SMALL_DATA
)
1001 hdr
->sh_flags
|= SHF_IA_64_SHORT
;
1006 /* Hook called by the linker routine which adds symbols from an object
1007 file. We use it to put .comm items in .sbss, and not .bss. */
1010 elfNN_ia64_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
1012 struct bfd_link_info
*info
;
1013 const Elf_Internal_Sym
*sym
;
1019 if (sym
->st_shndx
== SHN_COMMON
1020 && !info
->relocateable
1021 && sym
->st_size
<= bfd_get_gp_size (abfd
))
1023 /* Common symbols less than or equal to -G nn bytes are
1024 automatically put into .sbss. */
1026 asection
*scomm
= bfd_get_section_by_name (abfd
, ".scommon");
1030 scomm
= bfd_make_section (abfd
, ".scommon");
1032 || !bfd_set_section_flags (abfd
, scomm
, (SEC_ALLOC
1034 | SEC_LINKER_CREATED
)))
1039 *valp
= sym
->st_size
;
1045 /* Return the number of additional phdrs we will need. */
1048 elfNN_ia64_additional_program_headers (abfd
)
1054 /* See if we need a PT_IA_64_ARCHEXT segment. */
1055 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_archext
);
1056 if (s
&& (s
->flags
& SEC_LOAD
))
1059 /* See if we need a PT_IA_64_UNWIND segment. */
1060 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_unwind
);
1061 if (s
&& (s
->flags
& SEC_LOAD
))
1068 elfNN_ia64_modify_segment_map (abfd
)
1071 struct elf_segment_map
*m
, **pm
;
1074 /* If we need a PT_IA_64_ARCHEXT segment, it must come before
1075 all PT_LOAD segments. */
1076 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_archext
);
1077 if (s
&& (s
->flags
& SEC_LOAD
))
1079 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1080 if (m
->p_type
== PT_IA_64_ARCHEXT
)
1084 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, sizeof *m
);
1088 m
->p_type
= PT_IA_64_ARCHEXT
;
1092 /* We want to put it after the PHDR and INTERP segments. */
1093 pm
= &elf_tdata (abfd
)->segment_map
;
1095 && ((*pm
)->p_type
== PT_PHDR
1096 || (*pm
)->p_type
== PT_INTERP
))
1104 /* Install the PT_IA_64_UNWIND segment, if needed. */
1105 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_unwind
);
1106 if (s
&& (s
->flags
& SEC_LOAD
))
1108 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1109 if (m
->p_type
== PT_IA_64_UNWIND
)
1113 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, sizeof *m
);
1117 m
->p_type
= PT_IA_64_UNWIND
;
1122 /* We want to put it last. */
1123 pm
= &elf_tdata (abfd
)->segment_map
;
1130 /* Turn on PF_IA_64_NORECOV if needed. This involves traversing all of
1131 the input sections for each output section in the segment and testing
1132 for SHF_IA_64_NORECOV on each. */
1133 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1134 if (m
->p_type
== PT_LOAD
)
1137 for (i
= m
->count
- 1; i
>= 0; --i
)
1139 struct bfd_link_order
*order
= m
->sections
[i
]->link_order_head
;
1142 if (order
->type
== bfd_indirect_link_order
)
1144 asection
*is
= order
->u
.indirect
.section
;
1145 bfd_vma flags
= elf_section_data(is
)->this_hdr
.sh_flags
;
1146 if (flags
& SHF_IA_64_NORECOV
)
1148 m
->p_flags
|= PF_IA_64_NORECOV
;
1152 order
= order
->next
;
1162 /* According to the Tahoe assembler spec, all labels starting with a
1166 elfNN_ia64_is_local_label_name (abfd
, name
)
1170 return name
[0] == '.';
1173 /* Should we do dynamic things to this symbol? */
1176 elfNN_ia64_dynamic_symbol_p (h
, info
)
1177 struct elf_link_hash_entry
*h
;
1178 struct bfd_link_info
*info
;
1183 while (h
->root
.type
== bfd_link_hash_indirect
1184 || h
->root
.type
== bfd_link_hash_warning
)
1185 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1187 if (h
->dynindx
== -1)
1190 if (h
->root
.type
== bfd_link_hash_undefweak
1191 || h
->root
.type
== bfd_link_hash_defweak
)
1194 if ((info
->shared
&& !info
->symbolic
)
1195 || ((h
->elf_link_hash_flags
1196 & (ELF_LINK_HASH_DEF_DYNAMIC
| ELF_LINK_HASH_REF_REGULAR
))
1197 == (ELF_LINK_HASH_DEF_DYNAMIC
| ELF_LINK_HASH_REF_REGULAR
)))
1204 elfNN_ia64_local_hash_table_init (ht
, abfd
, new)
1205 struct elfNN_ia64_local_hash_table
*ht
;
1207 new_hash_entry_func
new;
1209 memset (ht
, 0, sizeof(*ht
));
1210 return bfd_hash_table_init (&ht
->root
, new);
1213 static struct bfd_hash_entry
*
1214 elfNN_ia64_new_loc_hash_entry (entry
, table
, string
)
1215 struct bfd_hash_entry
*entry
;
1216 struct bfd_hash_table
*table
;
1219 struct elfNN_ia64_local_hash_entry
*ret
;
1220 ret
= (struct elfNN_ia64_local_hash_entry
*) entry
;
1222 /* Allocate the structure if it has not already been allocated by a
1225 ret
= bfd_hash_allocate (table
, sizeof (*ret
));
1230 /* Initialize our local data. All zeros, and definitely easier
1231 than setting a handful of bit fields. */
1232 memset (ret
, 0, sizeof(*ret
));
1234 /* Call the allocation method of the superclass. */
1235 ret
= ((struct elfNN_ia64_local_hash_entry
*)
1236 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
1238 return (struct bfd_hash_entry
*) ret
;
1241 static struct bfd_hash_entry
*
1242 elfNN_ia64_new_elf_hash_entry (entry
, table
, string
)
1243 struct bfd_hash_entry
*entry
;
1244 struct bfd_hash_table
*table
;
1247 struct elfNN_ia64_link_hash_entry
*ret
;
1248 ret
= (struct elfNN_ia64_link_hash_entry
*) entry
;
1250 /* Allocate the structure if it has not already been allocated by a
1253 ret
= bfd_hash_allocate (table
, sizeof (*ret
));
1258 /* Initialize our local data. All zeros, and definitely easier
1259 than setting a handful of bit fields. */
1260 memset (ret
, 0, sizeof(*ret
));
1262 /* Call the allocation method of the superclass. */
1263 ret
= ((struct elfNN_ia64_link_hash_entry
*)
1264 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
1267 return (struct bfd_hash_entry
*) ret
;
1271 elfNN_ia64_hash_copy_indirect (xdir
, xind
)
1272 struct elf_link_hash_entry
*xdir
, *xind
;
1274 struct elfNN_ia64_link_hash_entry
*dir
, *ind
;
1276 dir
= (struct elfNN_ia64_link_hash_entry
*)xdir
;
1277 ind
= (struct elfNN_ia64_link_hash_entry
*)xind
;
1279 /* Copy down any references that we may have already seen to the
1280 symbol which just became indirect. */
1282 dir
->root
.elf_link_hash_flags
|=
1283 (ind
->root
.elf_link_hash_flags
1284 & (ELF_LINK_HASH_REF_DYNAMIC
1285 | ELF_LINK_HASH_REF_REGULAR
1286 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
));
1288 /* Copy over the got and plt data. This would have been done
1291 if (dir
->info
== NULL
)
1293 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1295 dir
->info
= dyn_i
= ind
->info
;
1298 /* Fix up the dyn_sym_info pointers to the global symbol. */
1299 for (; dyn_i
; dyn_i
= dyn_i
->next
)
1300 dyn_i
->h
= &dir
->root
;
1302 BFD_ASSERT (ind
->info
== NULL
);
1304 /* Copy over the dynindx. */
1306 if (dir
->root
.dynindx
== -1)
1308 dir
->root
.dynindx
= ind
->root
.dynindx
;
1309 dir
->root
.dynstr_index
= ind
->root
.dynstr_index
;
1310 ind
->root
.dynindx
= -1;
1311 ind
->root
.dynstr_index
= 0;
1313 BFD_ASSERT (ind
->root
.dynindx
== -1);
1317 elfNN_ia64_hash_hide_symbol (info
, xh
)
1318 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1319 struct elf_link_hash_entry
*xh
;
1321 struct elfNN_ia64_link_hash_entry
*h
;
1322 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1324 h
= (struct elfNN_ia64_link_hash_entry
*)xh
;
1326 h
->root
.elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1327 h
->root
.dynindx
= -1;
1329 for (dyn_i
= h
->info
; dyn_i
; dyn_i
= dyn_i
->next
)
1330 dyn_i
->want_plt2
= 0;
1333 /* Create the derived linker hash table. The IA-64 ELF port uses this
1334 derived hash table to keep information specific to the IA-64 ElF
1335 linker (without using static variables). */
1337 static struct bfd_link_hash_table
*
1338 elfNN_ia64_hash_table_create (abfd
)
1341 struct elfNN_ia64_link_hash_table
*ret
;
1343 ret
= bfd_alloc (abfd
, sizeof (*ret
));
1346 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
1347 elfNN_ia64_new_elf_hash_entry
))
1349 bfd_release (abfd
, ret
);
1353 if (!elfNN_ia64_local_hash_table_init (&ret
->loc_hash_table
, abfd
,
1354 elfNN_ia64_new_loc_hash_entry
))
1356 return &ret
->root
.root
;
1359 /* Look up an entry in a Alpha ELF linker hash table. */
1361 static INLINE
struct elfNN_ia64_local_hash_entry
*
1362 elfNN_ia64_local_hash_lookup(table
, string
, create
, copy
)
1363 struct elfNN_ia64_local_hash_table
*table
;
1365 boolean create
, copy
;
1367 return ((struct elfNN_ia64_local_hash_entry
*)
1368 bfd_hash_lookup (&table
->root
, string
, create
, copy
));
1371 /* Traverse both local and global hash tables. */
1373 struct elfNN_ia64_dyn_sym_traverse_data
1375 boolean (*func
) PARAMS ((struct elfNN_ia64_dyn_sym_info
*, PTR
));
1380 elfNN_ia64_global_dyn_sym_thunk (xentry
, xdata
)
1381 struct bfd_hash_entry
*xentry
;
1384 struct elfNN_ia64_link_hash_entry
*entry
1385 = (struct elfNN_ia64_link_hash_entry
*) xentry
;
1386 struct elfNN_ia64_dyn_sym_traverse_data
*data
1387 = (struct elfNN_ia64_dyn_sym_traverse_data
*) xdata
;
1388 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1390 for (dyn_i
= entry
->info
; dyn_i
; dyn_i
= dyn_i
->next
)
1391 if (! (*data
->func
) (dyn_i
, data
->data
))
1397 elfNN_ia64_local_dyn_sym_thunk (xentry
, xdata
)
1398 struct bfd_hash_entry
*xentry
;
1401 struct elfNN_ia64_local_hash_entry
*entry
1402 = (struct elfNN_ia64_local_hash_entry
*) xentry
;
1403 struct elfNN_ia64_dyn_sym_traverse_data
*data
1404 = (struct elfNN_ia64_dyn_sym_traverse_data
*) xdata
;
1405 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1407 for (dyn_i
= entry
->info
; dyn_i
; dyn_i
= dyn_i
->next
)
1408 if (! (*data
->func
) (dyn_i
, data
->data
))
1414 elfNN_ia64_dyn_sym_traverse (ia64_info
, func
, data
)
1415 struct elfNN_ia64_link_hash_table
*ia64_info
;
1416 boolean (*func
) PARAMS ((struct elfNN_ia64_dyn_sym_info
*, PTR
));
1419 struct elfNN_ia64_dyn_sym_traverse_data xdata
;
1424 elf_link_hash_traverse (&ia64_info
->root
,
1425 elfNN_ia64_global_dyn_sym_thunk
, &xdata
);
1426 bfd_hash_traverse (&ia64_info
->loc_hash_table
.root
,
1427 elfNN_ia64_local_dyn_sym_thunk
, &xdata
);
1431 elfNN_ia64_create_dynamic_sections (abfd
, info
)
1433 struct bfd_link_info
*info
;
1435 struct elfNN_ia64_link_hash_table
*ia64_info
;
1436 struct elf_link_hash_entry
*h
;
1439 if (! _bfd_elf_create_dynamic_sections (abfd
, info
))
1442 ia64_info
= elfNN_ia64_hash_table (info
);
1444 ia64_info
->plt_sec
= bfd_get_section_by_name (abfd
, ".plt");
1445 ia64_info
->got_sec
= bfd_get_section_by_name (abfd
, ".got");
1448 flagword flags
= bfd_get_section_flags (abfd
, ia64_info
->got_sec
);
1449 bfd_set_section_flags (abfd
, ia64_info
->got_sec
, SEC_SMALL_DATA
| flags
);
1452 if (!get_pltoff (abfd
, info
, ia64_info
))
1455 s
= bfd_make_section(abfd
, ".rela.IA_64.pltoff");
1457 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
1460 | SEC_LINKER_CREATED
1462 || !bfd_set_section_alignment (abfd
, s
, 3))
1464 ia64_info
->rel_pltoff_sec
= s
;
1466 s
= bfd_make_section(abfd
, ".rela.got");
1468 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
1471 | SEC_LINKER_CREATED
1473 || !bfd_set_section_alignment (abfd
, s
, 3))
1475 ia64_info
->rel_got_sec
= s
;
1480 /* Find and/or create a descriptor for dynamic symbol info. This will
1481 vary based on global or local symbol, and the addend to the reloc. */
1483 static struct elfNN_ia64_dyn_sym_info
*
1484 get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, create
)
1485 struct elfNN_ia64_link_hash_table
*ia64_info
;
1486 struct elf_link_hash_entry
*h
;
1488 const Elf_Internal_Rela
*rel
;
1491 struct elfNN_ia64_dyn_sym_info
**pp
;
1492 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1493 bfd_vma addend
= rel
? rel
->r_addend
: 0;
1496 pp
= &((struct elfNN_ia64_link_hash_entry
*)h
)->info
;
1499 struct elfNN_ia64_local_hash_entry
*loc_h
;
1503 /* Construct a string for use in the elfNN_ia64_local_hash_table.
1504 The name describes what was once anonymous memory. */
1506 len
= sizeof(void*)*2 + 1 + sizeof(bfd_vma
)*4 + 1 + 1;
1507 len
+= 10; /* %p slop */
1509 addr_name
= alloca (len
);
1510 sprintf (addr_name
, "%p:%lx", abfd
, ELFNN_R_SYM (rel
->r_info
));
1512 /* Collect the canonical entry data for this address. */
1513 loc_h
= elfNN_ia64_local_hash_lookup (&ia64_info
->loc_hash_table
,
1514 addr_name
, create
, create
);
1520 for (dyn_i
= *pp
; dyn_i
&& dyn_i
->addend
!= addend
; dyn_i
= *pp
)
1523 if (dyn_i
== NULL
&& create
)
1525 dyn_i
= (struct elfNN_ia64_dyn_sym_info
*)
1526 bfd_zalloc (abfd
, sizeof *dyn_i
);
1528 dyn_i
->addend
= addend
;
1535 get_got (abfd
, info
, ia64_info
)
1537 struct bfd_link_info
*info
;
1538 struct elfNN_ia64_link_hash_table
*ia64_info
;
1540 asection
*got
, *srel
;
1543 got
= ia64_info
->got_sec
;
1548 dynobj
= ia64_info
->root
.dynobj
;
1550 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1551 if (!_bfd_elf_create_got_section (dynobj
, info
))
1554 got
= bfd_get_section_by_name (dynobj
, ".got");
1556 ia64_info
->got_sec
= got
;
1558 flags
= bfd_get_section_flags (abfd
, got
);
1559 bfd_set_section_flags (abfd
, got
, SEC_SMALL_DATA
| flags
);
1565 /* Create function descriptor section (.opd). This section is called .opd
1566 because it contains "official prodecure descriptors". The "official"
1567 refers to the fact that these descriptors are used when taking the address
1568 of a procedure, thus ensuring a unique address for each procedure. */
1571 get_fptr (abfd
, info
, ia64_info
)
1573 struct bfd_link_info
*info
;
1574 struct elfNN_ia64_link_hash_table
*ia64_info
;
1579 fptr
= ia64_info
->fptr_sec
;
1582 dynobj
= ia64_info
->root
.dynobj
;
1584 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1586 fptr
= bfd_make_section (dynobj
, ".opd");
1588 || !bfd_set_section_flags (dynobj
, fptr
,
1594 | SEC_LINKER_CREATED
))
1595 || !bfd_set_section_alignment (abfd
, fptr
, 4))
1601 ia64_info
->fptr_sec
= fptr
;
1608 get_pltoff (abfd
, info
, ia64_info
)
1610 struct bfd_link_info
*info
;
1611 struct elfNN_ia64_link_hash_table
*ia64_info
;
1616 pltoff
= ia64_info
->pltoff_sec
;
1619 dynobj
= ia64_info
->root
.dynobj
;
1621 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1623 pltoff
= bfd_make_section (dynobj
, ELF_STRING_ia64_pltoff
);
1625 || !bfd_set_section_flags (dynobj
, pltoff
,
1631 | SEC_LINKER_CREATED
))
1632 || !bfd_set_section_alignment (abfd
, pltoff
, 4))
1638 ia64_info
->pltoff_sec
= pltoff
;
1645 get_reloc_section (abfd
, ia64_info
, sec
, create
)
1647 struct elfNN_ia64_link_hash_table
*ia64_info
;
1651 const char *srel_name
;
1655 srel_name
= (bfd_elf_string_from_elf_section
1656 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
1657 elf_section_data(sec
)->rel_hdr
.sh_name
));
1658 if (srel_name
== NULL
)
1661 BFD_ASSERT ((strncmp (srel_name
, ".rela", 5) == 0
1662 && strcmp (bfd_get_section_name (abfd
, sec
),
1664 || (strncmp (srel_name
, ".rel", 4) == 0
1665 && strcmp (bfd_get_section_name (abfd
, sec
),
1666 srel_name
+4) == 0));
1668 dynobj
= ia64_info
->root
.dynobj
;
1670 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1672 srel
= bfd_get_section_by_name (dynobj
, srel_name
);
1673 if (srel
== NULL
&& create
)
1675 srel
= bfd_make_section (dynobj
, srel_name
);
1677 || !bfd_set_section_flags (dynobj
, srel
,
1682 | SEC_LINKER_CREATED
1684 || !bfd_set_section_alignment (dynobj
, srel
, 3))
1692 count_dyn_reloc (abfd
, dyn_i
, srel
, type
)
1694 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1698 struct elfNN_ia64_dyn_reloc_entry
*rent
;
1700 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
1701 if (rent
->srel
== srel
&& rent
->type
== type
)
1706 rent
= (struct elfNN_ia64_dyn_reloc_entry
*)
1707 bfd_alloc (abfd
, sizeof (*rent
));
1711 rent
->next
= dyn_i
->reloc_entries
;
1715 dyn_i
->reloc_entries
= rent
;
1723 elfNN_ia64_check_relocs (abfd
, info
, sec
, relocs
)
1725 struct bfd_link_info
*info
;
1727 const Elf_Internal_Rela
*relocs
;
1729 struct elfNN_ia64_link_hash_table
*ia64_info
;
1730 const Elf_Internal_Rela
*relend
;
1731 Elf_Internal_Shdr
*symtab_hdr
;
1732 const Elf_Internal_Rela
*rel
;
1733 asection
*got
, *fptr
, *srel
;
1735 if (info
->relocateable
)
1738 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1739 ia64_info
= elfNN_ia64_hash_table (info
);
1741 got
= fptr
= srel
= NULL
;
1743 relend
= relocs
+ sec
->reloc_count
;
1744 for (rel
= relocs
; rel
< relend
; ++rel
)
1753 NEED_LTOFF_FPTR
= 64,
1756 struct elf_link_hash_entry
*h
= NULL
;
1757 unsigned long r_symndx
= ELFNN_R_SYM (rel
->r_info
);
1758 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1760 boolean maybe_dynamic
;
1763 if (r_symndx
>= symtab_hdr
->sh_info
)
1765 /* We're dealing with a global symbol -- find its hash entry
1766 and mark it as being referenced. */
1767 long indx
= r_symndx
- symtab_hdr
->sh_info
;
1768 h
= elf_sym_hashes (abfd
)[indx
];
1769 while (h
->root
.type
== bfd_link_hash_indirect
1770 || h
->root
.type
== bfd_link_hash_warning
)
1771 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1773 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1776 /* We can only get preliminary data on whether a symbol is
1777 locally or externally defined, as not all of the input files
1778 have yet been processed. Do something with what we know, as
1779 this may help reduce memory usage and processing time later. */
1780 maybe_dynamic
= false;
1781 if (h
&& ((info
->shared
&& ! info
->symbolic
)
1782 || ! (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)
1783 || h
->root
.type
== bfd_link_hash_defweak
))
1784 maybe_dynamic
= true;
1787 switch (ELFNN_R_TYPE (rel
->r_info
))
1789 case R_IA64_TPREL22
:
1790 case R_IA64_TPREL64MSB
:
1791 case R_IA64_TPREL64LSB
:
1792 case R_IA64_LTOFF_TP22
:
1795 case R_IA64_LTOFF_FPTR22
:
1796 case R_IA64_LTOFF_FPTR64I
:
1797 case R_IA64_LTOFF_FPTR64MSB
:
1798 case R_IA64_LTOFF_FPTR64LSB
:
1799 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
1802 case R_IA64_FPTR64I
:
1803 case R_IA64_FPTR32MSB
:
1804 case R_IA64_FPTR32LSB
:
1805 case R_IA64_FPTR64MSB
:
1806 case R_IA64_FPTR64LSB
:
1807 if (info
->shared
|| h
)
1808 need_entry
= NEED_FPTR
| NEED_DYNREL
;
1810 need_entry
= NEED_FPTR
;
1811 dynrel_type
= R_IA64_FPTR64LSB
;
1814 case R_IA64_LTOFF22
:
1815 case R_IA64_LTOFF22X
:
1816 case R_IA64_LTOFF64I
:
1817 need_entry
= NEED_GOT
;
1820 case R_IA64_PLTOFF22
:
1821 case R_IA64_PLTOFF64I
:
1822 case R_IA64_PLTOFF64MSB
:
1823 case R_IA64_PLTOFF64LSB
:
1824 need_entry
= NEED_PLTOFF
;
1828 need_entry
|= NEED_MIN_PLT
;
1832 (*info
->callbacks
->warning
)
1833 (info
, _("@pltoff reloc against local symbol"), 0,
1838 case R_IA64_PCREL21B
:
1839 case R_IA64_PCREL60B
:
1840 /* Depending on where this symbol is defined, we may or may not
1841 need a full plt entry. Only skip if we know we'll not need
1842 the entry -- static or symbolic, and the symbol definition
1843 has already been seen. */
1844 if (maybe_dynamic
&& rel
->r_addend
== 0)
1845 need_entry
= NEED_FULL_PLT
;
1851 case R_IA64_DIR32MSB
:
1852 case R_IA64_DIR32LSB
:
1853 case R_IA64_DIR64MSB
:
1854 case R_IA64_DIR64LSB
:
1855 /* Shared objects will always need at least a REL relocation. */
1856 if (info
->shared
|| maybe_dynamic
)
1857 need_entry
= NEED_DYNREL
;
1858 dynrel_type
= R_IA64_DIR64LSB
;
1861 case R_IA64_IPLTMSB
:
1862 case R_IA64_IPLTLSB
:
1863 /* Shared objects will always need at least a REL relocation. */
1864 if (info
->shared
|| maybe_dynamic
)
1865 need_entry
= NEED_DYNREL
;
1866 dynrel_type
= R_IA64_IPLTLSB
;
1869 case R_IA64_PCREL22
:
1870 case R_IA64_PCREL64I
:
1871 case R_IA64_PCREL32MSB
:
1872 case R_IA64_PCREL32LSB
:
1873 case R_IA64_PCREL64MSB
:
1874 case R_IA64_PCREL64LSB
:
1876 need_entry
= NEED_DYNREL
;
1877 dynrel_type
= R_IA64_PCREL64LSB
;
1884 if ((need_entry
& NEED_FPTR
) != 0
1887 (*info
->callbacks
->warning
)
1888 (info
, _("non-zero addend in @fptr reloc"), 0,
1892 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, true);
1894 /* Record whether or not this is a local symbol. */
1897 /* Create what's needed. */
1898 if (need_entry
& NEED_GOT
)
1902 got
= get_got (abfd
, info
, ia64_info
);
1906 dyn_i
->want_got
= 1;
1908 if (need_entry
& NEED_FPTR
)
1912 fptr
= get_fptr (abfd
, info
, ia64_info
);
1917 /* FPTRs for shared libraries are allocated by the dynamic
1918 linker. Make sure this local symbol will appear in the
1919 dynamic symbol table. */
1920 if (!h
&& info
->shared
)
1922 if (! (_bfd_elfNN_link_record_local_dynamic_symbol
1923 (info
, abfd
, r_symndx
)))
1927 dyn_i
->want_fptr
= 1;
1929 if (need_entry
& NEED_LTOFF_FPTR
)
1930 dyn_i
->want_ltoff_fptr
= 1;
1931 if (need_entry
& (NEED_MIN_PLT
| NEED_FULL_PLT
))
1933 if (!ia64_info
->root
.dynobj
)
1934 ia64_info
->root
.dynobj
= abfd
;
1935 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
1936 dyn_i
->want_plt
= 1;
1938 if (need_entry
& NEED_FULL_PLT
)
1939 dyn_i
->want_plt2
= 1;
1940 if (need_entry
& NEED_PLTOFF
)
1941 dyn_i
->want_pltoff
= 1;
1942 if ((need_entry
& NEED_DYNREL
) && (sec
->flags
& SEC_ALLOC
))
1946 srel
= get_reloc_section (abfd
, ia64_info
, sec
, true);
1950 if (!count_dyn_reloc (abfd
, dyn_i
, srel
, dynrel_type
))
1958 struct elfNN_ia64_allocate_data
1960 struct bfd_link_info
*info
;
1964 /* For cleanliness, and potentially faster dynamic loading, allocate
1965 external GOT entries first. */
1968 allocate_global_data_got (dyn_i
, data
)
1969 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1972 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
1975 && ! dyn_i
->want_fptr
1976 && elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
))
1978 dyn_i
->got_offset
= x
->ofs
;
1984 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
1987 allocate_global_fptr_got (dyn_i
, data
)
1988 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1991 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
1995 && elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
))
1997 dyn_i
->got_offset
= x
->ofs
;
2003 /* Lastly, allocate all the GOT entries for local data. */
2006 allocate_local_got (dyn_i
, data
)
2007 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2010 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2013 && ! elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
))
2015 dyn_i
->got_offset
= x
->ofs
;
2021 /* Search for the index of a global symbol in it's defining object file. */
2023 static unsigned long
2024 global_sym_index (h
)
2025 struct elf_link_hash_entry
*h
;
2027 struct elf_link_hash_entry
**p
;
2030 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
2031 || h
->root
.type
== bfd_link_hash_defweak
);
2033 obj
= h
->root
.u
.def
.section
->owner
;
2034 for (p
= elf_sym_hashes (obj
); *p
!= h
; ++p
)
2037 return p
- elf_sym_hashes (obj
) + elf_tdata (obj
)->symtab_hdr
.sh_info
;
2040 /* Allocate function descriptors. We can do these for every function
2041 in a main executable that is not exported. */
2044 allocate_fptr (dyn_i
, data
)
2045 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2048 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2050 if (dyn_i
->want_fptr
)
2052 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2055 while (h
->root
.type
== bfd_link_hash_indirect
2056 || h
->root
.type
== bfd_link_hash_warning
)
2057 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2059 if (x
->info
->shared
)
2061 if (h
&& h
->dynindx
== -1)
2063 BFD_ASSERT ((h
->root
.type
== bfd_link_hash_defined
)
2064 || (h
->root
.type
== bfd_link_hash_defweak
));
2066 if (!_bfd_elfNN_link_record_local_dynamic_symbol
2067 (x
->info
, h
->root
.u
.def
.section
->owner
,
2068 global_sym_index (h
)))
2072 dyn_i
->want_fptr
= 0;
2074 else if (h
== NULL
|| h
->dynindx
== -1)
2076 dyn_i
->fptr_offset
= x
->ofs
;
2080 dyn_i
->want_fptr
= 0;
2085 /* Allocate all the minimal PLT entries. */
2088 allocate_plt_entries (dyn_i
, data
)
2089 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2092 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2094 if (dyn_i
->want_plt
)
2096 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2099 while (h
->root
.type
== bfd_link_hash_indirect
2100 || h
->root
.type
== bfd_link_hash_warning
)
2101 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2103 /* ??? Versioned symbols seem to lose ELF_LINK_HASH_NEEDS_PLT. */
2104 if (elfNN_ia64_dynamic_symbol_p (h
, x
->info
))
2106 bfd_size_type offset
= x
->ofs
;
2108 offset
= PLT_HEADER_SIZE
;
2109 dyn_i
->plt_offset
= offset
;
2110 x
->ofs
= offset
+ PLT_MIN_ENTRY_SIZE
;
2112 dyn_i
->want_pltoff
= 1;
2116 dyn_i
->want_plt
= 0;
2117 dyn_i
->want_plt2
= 0;
2123 /* Allocate all the full PLT entries. */
2126 allocate_plt2_entries (dyn_i
, data
)
2127 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2130 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2132 if (dyn_i
->want_plt2
)
2134 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2135 bfd_size_type ofs
= x
->ofs
;
2137 dyn_i
->plt2_offset
= ofs
;
2138 x
->ofs
= ofs
+ PLT_FULL_ENTRY_SIZE
;
2140 while (h
->root
.type
== bfd_link_hash_indirect
2141 || h
->root
.type
== bfd_link_hash_warning
)
2142 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2143 dyn_i
->h
->plt
.offset
= ofs
;
2148 /* Allocate all the PLTOFF entries requested by relocations and
2149 plt entries. We can't share space with allocated FPTR entries,
2150 because the latter are not necessarily addressable by the GP.
2151 ??? Relaxation might be able to determine that they are. */
2154 allocate_pltoff_entries (dyn_i
, data
)
2155 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2158 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2160 if (dyn_i
->want_pltoff
)
2162 dyn_i
->pltoff_offset
= x
->ofs
;
2168 /* Allocate dynamic relocations for those symbols that turned out
2172 allocate_dynrel_entries (dyn_i
, data
)
2173 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2176 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2177 struct elfNN_ia64_link_hash_table
*ia64_info
;
2178 struct elfNN_ia64_dyn_reloc_entry
*rent
;
2179 boolean dynamic_symbol
, shared
;
2181 ia64_info
= elfNN_ia64_hash_table (x
->info
);
2182 dynamic_symbol
= elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
);
2183 shared
= x
->info
->shared
;
2185 /* Take care of the normal data relocations. */
2187 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2189 int count
= rent
->count
;
2193 case R_IA64_FPTR64LSB
:
2194 /* Allocate one iff !want_fptr, which by this point will
2195 be true only if we're actually allocating one statically
2196 in the main executable. */
2197 if (dyn_i
->want_fptr
)
2200 case R_IA64_PCREL64LSB
:
2201 if (!dynamic_symbol
)
2204 case R_IA64_DIR64LSB
:
2205 if (!dynamic_symbol
&& !shared
)
2208 case R_IA64_IPLTLSB
:
2209 if (!dynamic_symbol
&& !shared
)
2211 /* Use two REL relocations for IPLT relocations
2212 against local symbols. */
2213 if (!dynamic_symbol
)
2219 rent
->srel
->_raw_size
+= sizeof (ElfNN_External_Rela
) * count
;
2222 /* Take care of the GOT and PLT relocations. */
2224 if (((dynamic_symbol
|| shared
) && dyn_i
->want_got
)
2225 || (dyn_i
->want_ltoff_fptr
&& dyn_i
->h
&& dyn_i
->h
->dynindx
!= -1))
2226 ia64_info
->rel_got_sec
->_raw_size
+= sizeof (ElfNN_External_Rela
);
2228 if (dyn_i
->want_pltoff
)
2230 bfd_size_type t
= 0;
2232 /* Dynamic symbols get one IPLT relocation. Local symbols in
2233 shared libraries get two REL relocations. Local symbols in
2234 main applications get nothing. */
2236 t
= sizeof (ElfNN_External_Rela
);
2238 t
= 2 * sizeof (ElfNN_External_Rela
);
2240 ia64_info
->rel_pltoff_sec
->_raw_size
+= t
;
2247 elfNN_ia64_adjust_dynamic_symbol (info
, h
)
2248 struct bfd_link_info
*info
;
2249 struct elf_link_hash_entry
*h
;
2251 /* ??? Undefined symbols with PLT entries should be re-defined
2252 to be the PLT entry. */
2254 /* If this is a weak symbol, and there is a real definition, the
2255 processor independent code will have arranged for us to see the
2256 real definition first, and we can just use the same value. */
2257 if (h
->weakdef
!= NULL
)
2259 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
2260 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
2261 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
2262 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
2266 /* If this is a reference to a symbol defined by a dynamic object which
2267 is not a function, we might allocate the symbol in our .dynbss section
2268 and allocate a COPY dynamic relocation.
2270 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2277 elfNN_ia64_size_dynamic_sections (output_bfd
, info
)
2279 struct bfd_link_info
*info
;
2281 struct elfNN_ia64_allocate_data data
;
2282 struct elfNN_ia64_link_hash_table
*ia64_info
;
2285 boolean reltext
= false;
2286 boolean relplt
= false;
2288 dynobj
= elf_hash_table(info
)->dynobj
;
2289 ia64_info
= elfNN_ia64_hash_table (info
);
2290 BFD_ASSERT(dynobj
!= NULL
);
2293 /* Set the contents of the .interp section to the interpreter. */
2294 if (ia64_info
->root
.dynamic_sections_created
2297 sec
= bfd_get_section_by_name (dynobj
, ".interp");
2298 BFD_ASSERT (sec
!= NULL
);
2299 sec
->contents
= (bfd_byte
*) ELF_DYNAMIC_INTERPRETER
;
2300 sec
->_raw_size
= strlen (ELF_DYNAMIC_INTERPRETER
) + 1;
2303 /* DT_INIT and DT_FINI get function descriptors not raw code addresses.
2304 Force their symbols to have pltoff entries so we can use those. */
2305 if (ia64_info
->root
.dynamic_sections_created
)
2307 struct elf_link_hash_entry
*h
;
2308 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2310 if (info
->init_function
2311 && (h
= elf_link_hash_lookup (elf_hash_table (info
),
2312 info
->init_function
, false,
2314 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
2315 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
2317 dyn_i
= get_dyn_sym_info (ia64_info
, h
, output_bfd
, NULL
, true);
2318 dyn_i
->want_pltoff
= 1;
2321 if (info
->fini_function
2322 && (h
= elf_link_hash_lookup (elf_hash_table (info
),
2323 info
->fini_function
, false,
2325 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
2326 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
2328 dyn_i
= get_dyn_sym_info (ia64_info
, h
, output_bfd
, NULL
, true);
2329 dyn_i
->want_pltoff
= 1;
2333 /* Allocate the GOT entries. */
2335 if (ia64_info
->got_sec
)
2338 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_data_got
, &data
);
2339 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_fptr_got
, &data
);
2340 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_local_got
, &data
);
2341 ia64_info
->got_sec
->_raw_size
= data
.ofs
;
2344 /* Allocate the FPTR entries. */
2346 if (ia64_info
->fptr_sec
)
2349 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_fptr
, &data
);
2350 ia64_info
->fptr_sec
->_raw_size
= data
.ofs
;
2353 /* Now that we've seen all of the input files, we can decide which
2354 symbols need plt entries. Allocate the minimal PLT entries first.
2355 We do this even though dynamic_sections_created may be false, because
2356 this has the side-effect of clearing want_plt and want_plt2. */
2359 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_plt_entries
, &data
);
2361 ia64_info
->minplt_entries
= 0;
2364 ia64_info
->minplt_entries
2365 = (data
.ofs
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
2368 /* Align the pointer for the plt2 entries. */
2369 data
.ofs
= (data
.ofs
+ 31) & -32;
2371 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_plt2_entries
, &data
);
2374 BFD_ASSERT (ia64_info
->root
.dynamic_sections_created
);
2376 ia64_info
->plt_sec
->_raw_size
= data
.ofs
;
2378 /* If we've got a .plt, we need some extra memory for the dynamic
2379 linker. We stuff these in .got.plt. */
2380 sec
= bfd_get_section_by_name (dynobj
, ".got.plt");
2381 sec
->_raw_size
= 8 * PLT_RESERVED_WORDS
;
2384 /* Allocate the PLTOFF entries. */
2386 if (ia64_info
->pltoff_sec
)
2389 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_pltoff_entries
, &data
);
2390 ia64_info
->pltoff_sec
->_raw_size
= data
.ofs
;
2393 if (ia64_info
->root
.dynamic_sections_created
)
2395 /* Allocate space for the dynamic relocations that turned out to be
2398 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_dynrel_entries
, &data
);
2401 /* We have now determined the sizes of the various dynamic sections.
2402 Allocate memory for them. */
2403 for (sec
= dynobj
->sections
; sec
!= NULL
; sec
= sec
->next
)
2407 if (!(sec
->flags
& SEC_LINKER_CREATED
))
2410 /* If we don't need this section, strip it from the output file.
2411 There were several sections primarily related to dynamic
2412 linking that must be create before the linker maps input
2413 sections to output sections. The linker does that before
2414 bfd_elf_size_dynamic_sections is called, and it is that
2415 function which decides whether anything needs to go into
2418 strip
= (sec
->_raw_size
== 0);
2420 if (sec
== ia64_info
->got_sec
)
2422 else if (sec
== ia64_info
->rel_got_sec
)
2425 ia64_info
->rel_got_sec
= NULL
;
2427 /* We use the reloc_count field as a counter if we need to
2428 copy relocs into the output file. */
2429 sec
->reloc_count
= 0;
2431 else if (sec
== ia64_info
->fptr_sec
)
2434 ia64_info
->fptr_sec
= NULL
;
2436 else if (sec
== ia64_info
->plt_sec
)
2439 ia64_info
->plt_sec
= NULL
;
2441 else if (sec
== ia64_info
->pltoff_sec
)
2444 ia64_info
->pltoff_sec
= NULL
;
2446 else if (sec
== ia64_info
->rel_pltoff_sec
)
2449 ia64_info
->rel_pltoff_sec
= NULL
;
2453 /* We use the reloc_count field as a counter if we need to
2454 copy relocs into the output file. */
2455 sec
->reloc_count
= 0;
2462 /* It's OK to base decisions on the section name, because none
2463 of the dynobj section names depend upon the input files. */
2464 name
= bfd_get_section_name (dynobj
, sec
);
2466 if (strcmp (name
, ".got.plt") == 0)
2468 else if (strncmp (name
, ".rel", 4) == 0)
2472 const char *outname
;
2475 /* If this relocation section applies to a read only
2476 section, then we probably need a DT_TEXTREL entry. */
2477 outname
= bfd_get_section_name (output_bfd
,
2478 sec
->output_section
);
2479 if (outname
[4] == 'a')
2484 target
= bfd_get_section_by_name (output_bfd
, outname
);
2486 && (target
->flags
& SEC_READONLY
) != 0
2487 && (target
->flags
& SEC_ALLOC
) != 0)
2490 /* We use the reloc_count field as a counter if we need to
2491 copy relocs into the output file. */
2492 sec
->reloc_count
= 0;
2500 _bfd_strip_section_from_output (info
, sec
);
2503 /* Allocate memory for the section contents. */
2504 sec
->contents
= (bfd_byte
*) bfd_zalloc(dynobj
, sec
->_raw_size
);
2505 if (sec
->contents
== NULL
&& sec
->_raw_size
!= 0)
2510 if (elf_hash_table (info
)->dynamic_sections_created
)
2512 /* Add some entries to the .dynamic section. We fill in the values
2513 later (in finish_dynamic_sections) but we must add the entries now
2514 so that we get the correct size for the .dynamic section. */
2518 /* The DT_DEBUG entry is filled in by the dynamic linker and used
2520 if (!bfd_elfNN_add_dynamic_entry (info
, DT_DEBUG
, 0))
2524 if (! bfd_elfNN_add_dynamic_entry (info
, DT_IA_64_PLT_RESERVE
, 0))
2526 if (! bfd_elfNN_add_dynamic_entry (info
, DT_PLTGOT
, 0))
2531 if (! bfd_elfNN_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2532 || ! bfd_elfNN_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
2533 || ! bfd_elfNN_add_dynamic_entry (info
, DT_JMPREL
, 0))
2537 if (! bfd_elfNN_add_dynamic_entry (info
, DT_RELA
, 0)
2538 || ! bfd_elfNN_add_dynamic_entry (info
, DT_RELASZ
, 0)
2539 || ! bfd_elfNN_add_dynamic_entry (info
, DT_RELAENT
,
2540 sizeof(ElfNN_External_Rela
)))
2545 if (! bfd_elfNN_add_dynamic_entry (info
, DT_TEXTREL
, 0))
2547 info
->flags
|= DF_TEXTREL
;
2551 /* ??? Perhaps force __gp local. */
2556 static bfd_reloc_status_type
2557 elfNN_ia64_install_value (abfd
, hit_addr
, val
, r_type
)
2561 unsigned int r_type
;
2563 const struct ia64_operand
*op
;
2564 int bigendian
= 0, shift
= 0;
2565 bfd_vma t0
, t1
, insn
, dword
;
2566 enum ia64_opnd opnd
;
2570 opnd
= IA64_OPND_NIL
;
2575 return bfd_reloc_ok
;
2577 /* Instruction relocations. */
2579 case R_IA64_IMM14
: opnd
= IA64_OPND_IMM14
; break;
2581 case R_IA64_PCREL21F
: opnd
= IA64_OPND_TGT25
; break;
2582 case R_IA64_PCREL21M
: opnd
= IA64_OPND_TGT25b
; break;
2583 case R_IA64_PCREL60B
: opnd
= IA64_OPND_TGT64
; break;
2584 case R_IA64_PCREL21B
:
2585 case R_IA64_PCREL21BI
:
2586 opnd
= IA64_OPND_TGT25c
;
2590 case R_IA64_GPREL22
:
2591 case R_IA64_LTOFF22
:
2592 case R_IA64_LTOFF22X
:
2593 case R_IA64_PLTOFF22
:
2594 case R_IA64_PCREL22
:
2595 case R_IA64_LTOFF_FPTR22
:
2596 opnd
= IA64_OPND_IMM22
;
2600 case R_IA64_GPREL64I
:
2601 case R_IA64_LTOFF64I
:
2602 case R_IA64_PLTOFF64I
:
2603 case R_IA64_PCREL64I
:
2604 case R_IA64_FPTR64I
:
2605 case R_IA64_LTOFF_FPTR64I
:
2606 opnd
= IA64_OPND_IMMU64
;
2609 /* Data relocations. */
2611 case R_IA64_DIR32MSB
:
2612 case R_IA64_GPREL32MSB
:
2613 case R_IA64_FPTR32MSB
:
2614 case R_IA64_PCREL32MSB
:
2615 case R_IA64_SEGREL32MSB
:
2616 case R_IA64_SECREL32MSB
:
2617 case R_IA64_LTV32MSB
:
2618 size
= 4; bigendian
= 1;
2621 case R_IA64_DIR32LSB
:
2622 case R_IA64_GPREL32LSB
:
2623 case R_IA64_FPTR32LSB
:
2624 case R_IA64_PCREL32LSB
:
2625 case R_IA64_SEGREL32LSB
:
2626 case R_IA64_SECREL32LSB
:
2627 case R_IA64_LTV32LSB
:
2628 size
= 4; bigendian
= 0;
2631 case R_IA64_DIR64MSB
:
2632 case R_IA64_GPREL64MSB
:
2633 case R_IA64_PLTOFF64MSB
:
2634 case R_IA64_FPTR64MSB
:
2635 case R_IA64_PCREL64MSB
:
2636 case R_IA64_LTOFF_FPTR64MSB
:
2637 case R_IA64_SEGREL64MSB
:
2638 case R_IA64_SECREL64MSB
:
2639 case R_IA64_LTV64MSB
:
2640 size
= 8; bigendian
= 1;
2643 case R_IA64_DIR64LSB
:
2644 case R_IA64_GPREL64LSB
:
2645 case R_IA64_PLTOFF64LSB
:
2646 case R_IA64_FPTR64LSB
:
2647 case R_IA64_PCREL64LSB
:
2648 case R_IA64_LTOFF_FPTR64LSB
:
2649 case R_IA64_SEGREL64LSB
:
2650 case R_IA64_SECREL64LSB
:
2651 case R_IA64_LTV64LSB
:
2652 size
= 8; bigendian
= 0;
2655 /* Unsupported / Dynamic relocations. */
2657 return bfd_reloc_notsupported
;
2662 case IA64_OPND_IMMU64
:
2663 hit_addr
-= (long) hit_addr
& 0x3;
2664 t0
= bfd_get_64 (abfd
, hit_addr
);
2665 t1
= bfd_get_64 (abfd
, hit_addr
+ 8);
2667 /* tmpl/s: bits 0.. 5 in t0
2668 slot 0: bits 5..45 in t0
2669 slot 1: bits 46..63 in t0, bits 0..22 in t1
2670 slot 2: bits 23..63 in t1 */
2672 /* First, clear the bits that form the 64 bit constant. */
2673 t0
&= ~(0x3ffffLL
<< 46);
2675 | (( (0x07fLL
<< 13) | (0x1ffLL
<< 27)
2676 | (0x01fLL
<< 22) | (0x001LL
<< 21)
2677 | (0x001LL
<< 36)) << 23));
2679 t0
|= ((val
>> 22) & 0x03ffffLL
) << 46; /* 18 lsbs of imm41 */
2680 t1
|= ((val
>> 40) & 0x7fffffLL
) << 0; /* 23 msbs of imm41 */
2681 t1
|= ( (((val
>> 0) & 0x07f) << 13) /* imm7b */
2682 | (((val
>> 7) & 0x1ff) << 27) /* imm9d */
2683 | (((val
>> 16) & 0x01f) << 22) /* imm5c */
2684 | (((val
>> 21) & 0x001) << 21) /* ic */
2685 | (((val
>> 63) & 0x001) << 36)) << 23; /* i */
2687 bfd_put_64 (abfd
, t0
, hit_addr
);
2688 bfd_put_64 (abfd
, t1
, hit_addr
+ 8);
2691 case IA64_OPND_TGT64
:
2692 hit_addr
-= (long) hit_addr
& 0x3;
2693 t0
= bfd_get_64 (abfd
, hit_addr
);
2694 t1
= bfd_get_64 (abfd
, hit_addr
+ 8);
2696 /* tmpl/s: bits 0.. 5 in t0
2697 slot 0: bits 5..45 in t0
2698 slot 1: bits 46..63 in t0, bits 0..22 in t1
2699 slot 2: bits 23..63 in t1 */
2701 /* First, clear the bits that form the 64 bit constant. */
2702 t0
&= ~(0x3ffffLL
<< 46);
2704 | ((1LL << 36 | 0xfffffLL
<< 13) << 23));
2707 t0
|= ((val
>> 20) & 0xffffLL
) << 2 << 46; /* 16 lsbs of imm39 */
2708 t1
|= ((val
>> 36) & 0x7fffffLL
) << 0; /* 23 msbs of imm39 */
2709 t1
|= ((((val
>> 0) & 0xfffffLL
) << 13) /* imm20b */
2710 | (((val
>> 59) & 0x1LL
) << 36)) << 23; /* i */
2712 bfd_put_64 (abfd
, t0
, hit_addr
);
2713 bfd_put_64 (abfd
, t1
, hit_addr
+ 8);
2717 switch ((long) hit_addr
& 0x3)
2719 case 0: shift
= 5; break;
2720 case 1: shift
= 14; hit_addr
+= 3; break;
2721 case 2: shift
= 23; hit_addr
+= 6; break;
2722 case 3: return bfd_reloc_notsupported
; /* shouldn't happen... */
2724 dword
= bfd_get_64 (abfd
, hit_addr
);
2725 insn
= (dword
>> shift
) & 0x1ffffffffffLL
;
2727 op
= elf64_ia64_operands
+ opnd
;
2728 err
= (*op
->insert
) (op
, val
, &insn
);
2730 return bfd_reloc_overflow
;
2732 dword
&= ~(0x1ffffffffffLL
<< shift
);
2733 dword
|= (insn
<< shift
);
2734 bfd_put_64 (abfd
, dword
, hit_addr
);
2738 /* A data relocation. */
2741 bfd_putb32 (val
, hit_addr
);
2743 bfd_putb64 (val
, hit_addr
);
2746 bfd_putl32 (val
, hit_addr
);
2748 bfd_putl64 (val
, hit_addr
);
2752 return bfd_reloc_ok
;
2756 elfNN_ia64_install_dyn_reloc (abfd
, info
, sec
, srel
, offset
, type
,
2759 struct bfd_link_info
*info
;
2767 Elf_Internal_Rela outrel
;
2769 outrel
.r_offset
= (sec
->output_section
->vma
2770 + sec
->output_offset
2773 BFD_ASSERT (dynindx
!= -1);
2774 outrel
.r_info
= ELFNN_R_INFO (dynindx
, type
);
2775 outrel
.r_addend
= addend
;
2777 if (elf_section_data (sec
)->stab_info
!= NULL
)
2779 /* This may be NULL for linker-generated relocations, as it is
2780 inconvenient to pass all the bits around. And this shouldn't
2782 BFD_ASSERT (info
!= NULL
);
2784 offset
= (_bfd_stab_section_offset
2785 (abfd
, &elf_hash_table (info
)->stab_info
, sec
,
2786 &elf_section_data (sec
)->stab_info
, offset
));
2787 if (offset
== (bfd_vma
) -1)
2789 /* Run for the hills. We shouldn't be outputting a relocation
2790 for this. So do what everyone else does and output a no-op. */
2791 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
2792 outrel
.r_addend
= 0;
2795 outrel
.r_offset
= offset
;
2798 bfd_elfNN_swap_reloca_out (abfd
, &outrel
,
2799 ((ElfNN_External_Rela
*) srel
->contents
2800 + srel
->reloc_count
++));
2801 BFD_ASSERT (sizeof(ElfNN_External_Rela
) * srel
->reloc_count
2802 <= srel
->_cooked_size
);
2805 /* Store an entry for target address TARGET_ADDR in the linkage table
2806 and return the gp-relative address of the linkage table entry. */
2809 set_got_entry (abfd
, info
, dyn_i
, dynindx
, addend
, value
, dyn_r_type
)
2811 struct bfd_link_info
*info
;
2812 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2816 unsigned int dyn_r_type
;
2818 struct elfNN_ia64_link_hash_table
*ia64_info
;
2821 ia64_info
= elfNN_ia64_hash_table (info
);
2822 got_sec
= ia64_info
->got_sec
;
2824 BFD_ASSERT ((dyn_i
->got_offset
& 7) == 0);
2826 if (! dyn_i
->got_done
)
2828 dyn_i
->got_done
= true;
2830 /* Store the target address in the linkage table entry. */
2831 bfd_put_64 (abfd
, value
, got_sec
->contents
+ dyn_i
->got_offset
);
2833 /* Install a dynamic relocation if needed. */
2835 || elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, info
)
2836 || (dynindx
!= -1 && dyn_r_type
== R_IA64_FPTR64LSB
))
2840 dyn_r_type
= R_IA64_REL64LSB
;
2845 if (bfd_big_endian (abfd
))
2849 case R_IA64_REL64LSB
:
2850 dyn_r_type
= R_IA64_REL64MSB
;
2852 case R_IA64_DIR64LSB
:
2853 dyn_r_type
= R_IA64_DIR64MSB
;
2855 case R_IA64_FPTR64LSB
:
2856 dyn_r_type
= R_IA64_FPTR64MSB
;
2864 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, got_sec
,
2865 ia64_info
->rel_got_sec
,
2866 dyn_i
->got_offset
, dyn_r_type
,
2871 /* Return the address of the linkage table entry. */
2872 value
= (got_sec
->output_section
->vma
2873 + got_sec
->output_offset
2874 + dyn_i
->got_offset
);
2879 /* Fill in a function descriptor consisting of the function's code
2880 address and its global pointer. Return the descriptor's address. */
2883 set_fptr_entry (abfd
, info
, dyn_i
, value
)
2885 struct bfd_link_info
*info
;
2886 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2889 struct elfNN_ia64_link_hash_table
*ia64_info
;
2892 ia64_info
= elfNN_ia64_hash_table (info
);
2893 fptr_sec
= ia64_info
->fptr_sec
;
2895 if (!dyn_i
->fptr_done
)
2897 dyn_i
->fptr_done
= 1;
2899 /* Fill in the function descriptor. */
2900 bfd_put_64 (abfd
, value
, fptr_sec
->contents
+ dyn_i
->fptr_offset
);
2901 bfd_put_64 (abfd
, _bfd_get_gp_value (abfd
),
2902 fptr_sec
->contents
+ dyn_i
->fptr_offset
+ 8);
2905 /* Return the descriptor's address. */
2906 value
= (fptr_sec
->output_section
->vma
2907 + fptr_sec
->output_offset
2908 + dyn_i
->fptr_offset
);
2913 /* Fill in a PLTOFF entry consisting of the function's code address
2914 and its global pointer. Return the descriptor's address. */
2917 set_pltoff_entry (abfd
, info
, dyn_i
, value
, is_plt
)
2919 struct bfd_link_info
*info
;
2920 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2924 struct elfNN_ia64_link_hash_table
*ia64_info
;
2925 asection
*pltoff_sec
;
2927 ia64_info
= elfNN_ia64_hash_table (info
);
2928 pltoff_sec
= ia64_info
->pltoff_sec
;
2930 /* Don't do anything if this symbol uses a real PLT entry. In
2931 that case, we'll fill this in during finish_dynamic_symbol. */
2932 if ((! dyn_i
->want_plt
|| is_plt
)
2933 && !dyn_i
->pltoff_done
)
2935 bfd_vma gp
= _bfd_get_gp_value (abfd
);
2937 /* Fill in the function descriptor. */
2938 bfd_put_64 (abfd
, value
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
);
2939 bfd_put_64 (abfd
, gp
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
+ 8);
2941 /* Install dynamic relocations if needed. */
2942 if (!is_plt
&& info
->shared
)
2944 unsigned int dyn_r_type
;
2946 if (bfd_big_endian (abfd
))
2947 dyn_r_type
= R_IA64_REL64MSB
;
2949 dyn_r_type
= R_IA64_REL64LSB
;
2951 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
2952 ia64_info
->rel_pltoff_sec
,
2953 dyn_i
->pltoff_offset
,
2954 dyn_r_type
, 0, value
);
2955 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
2956 ia64_info
->rel_pltoff_sec
,
2957 dyn_i
->pltoff_offset
+ 8,
2961 dyn_i
->pltoff_done
= 1;
2964 /* Return the descriptor's address. */
2965 value
= (pltoff_sec
->output_section
->vma
2966 + pltoff_sec
->output_offset
2967 + dyn_i
->pltoff_offset
);
2972 /* Called through qsort to sort the .IA_64.unwind section during a
2973 non-relocatable link. Set elfNN_ia64_unwind_entry_compare_bfd
2974 to the output bfd so we can do proper endianness frobbing. */
2976 static bfd
*elfNN_ia64_unwind_entry_compare_bfd
;
2979 elfNN_ia64_unwind_entry_compare (a
, b
)
2985 av
= bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd
, a
);
2986 bv
= bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd
, b
);
2988 return (av
< bv
? -1 : av
> bv
? 1 : 0);
2992 elfNN_ia64_final_link (abfd
, info
)
2994 struct bfd_link_info
*info
;
2996 struct elfNN_ia64_link_hash_table
*ia64_info
;
2997 asection
*unwind_output_sec
;
2999 ia64_info
= elfNN_ia64_hash_table (info
);
3001 /* Make sure we've got ourselves a nice fat __gp value. */
3002 if (!info
->relocateable
)
3004 bfd_vma min_vma
= (bfd_vma
) -1, max_vma
= 0;
3005 bfd_vma min_short_vma
= min_vma
, max_short_vma
= 0;
3006 struct elf_link_hash_entry
*gp
;
3010 /* Find the min and max vma of all sections marked short. Also
3011 collect min and max vma of any type, for use in selecting a
3013 for (os
= abfd
->sections
; os
; os
= os
->next
)
3017 if ((os
->flags
& SEC_ALLOC
) == 0)
3021 hi
= os
->vma
+ os
->_raw_size
;
3029 if (os
->flags
& SEC_SMALL_DATA
)
3031 if (min_short_vma
> lo
)
3033 if (max_short_vma
< hi
)
3038 /* See if the user wants to force a value. */
3039 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", false,
3043 && (gp
->root
.type
== bfd_link_hash_defined
3044 || gp
->root
.type
== bfd_link_hash_defweak
))
3046 asection
*gp_sec
= gp
->root
.u
.def
.section
;
3047 gp_val
= (gp
->root
.u
.def
.value
3048 + gp_sec
->output_section
->vma
3049 + gp_sec
->output_offset
);
3053 /* Pick a sensible value. */
3055 asection
*got_sec
= ia64_info
->got_sec
;
3057 /* Start with just the address of the .got. */
3059 gp_val
= got_sec
->output_section
->vma
;
3060 else if (max_short_vma
!= 0)
3061 gp_val
= min_short_vma
;
3065 /* If it is possible to address the entire image, but we
3066 don't with the choice above, adjust. */
3067 if (max_vma
- min_vma
< 0x400000
3068 && max_vma
- gp_val
<= 0x200000
3069 && gp_val
- min_vma
> 0x200000)
3070 gp_val
= min_vma
+ 0x200000;
3071 else if (max_short_vma
!= 0)
3073 /* If we don't cover all the short data, adjust. */
3074 if (max_short_vma
- gp_val
>= 0x200000)
3075 gp_val
= min_short_vma
+ 0x200000;
3077 /* If we're addressing stuff past the end, adjust back. */
3078 if (gp_val
> max_vma
)
3079 gp_val
= max_vma
- 0x200000 + 8;
3083 /* Validate whether all SHF_IA_64_SHORT sections are within
3084 range of the chosen GP. */
3086 if (max_short_vma
!= 0)
3088 if (max_short_vma
- min_short_vma
>= 0x400000)
3090 (*_bfd_error_handler
)
3091 (_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
3092 bfd_get_filename (abfd
),
3093 (unsigned long)(max_short_vma
- min_short_vma
));
3096 else if ((gp_val
> min_short_vma
3097 && gp_val
- min_short_vma
> 0x200000)
3098 || (gp_val
< max_short_vma
3099 && max_short_vma
- gp_val
>= 0x200000))
3101 (*_bfd_error_handler
)
3102 (_("%s: __gp does not cover short data segment"),
3103 bfd_get_filename (abfd
));
3108 _bfd_set_gp_value (abfd
, gp_val
);
3111 /* Tricky bits. DT_INIT and DT_FINI use a pltoff entry, which is
3112 normally initialized in finish_dynamic_sections. Except that
3113 we need all non-plt pltoff entries to be initialized before
3114 finish_dynamic_symbols. This because the array of relocations
3115 used for plt entries (aka DT_JMPREL) begins after all the
3116 non-plt pltoff relocations. If the order gets confused, we
3117 munge either the array or the array base. */
3118 if (ia64_info
->root
.dynamic_sections_created
)
3120 struct elf_link_hash_entry
*h
;
3121 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3124 if (info
->init_function
3125 && (h
= elf_link_hash_lookup (elf_hash_table (info
),
3126 info
->init_function
, false,
3128 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
3129 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
3131 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, false);
3132 addr
= (h
->root
.u
.def
.section
->output_section
->vma
3133 + h
->root
.u
.def
.section
->output_offset
3134 + h
->root
.u
.def
.value
);
3135 (void) set_pltoff_entry (abfd
, info
, dyn_i
, addr
, false);
3138 if (info
->fini_function
3139 && (h
= elf_link_hash_lookup (elf_hash_table (info
),
3140 info
->fini_function
, false,
3142 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
3143 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
3145 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, false);
3146 addr
= (h
->root
.u
.def
.section
->output_section
->vma
3147 + h
->root
.u
.def
.section
->output_offset
3148 + h
->root
.u
.def
.value
);
3149 (void) set_pltoff_entry (abfd
, info
, dyn_i
, addr
, false);
3153 /* If we're producing a final executable, we need to sort the contents
3154 of the .IA_64.unwind section. Force this section to be relocated
3155 into memory rather than written immediately to the output file. */
3156 unwind_output_sec
= NULL
;
3157 if (!info
->relocateable
)
3159 asection
*s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_unwind
);
3162 unwind_output_sec
= s
->output_section
;
3163 unwind_output_sec
->contents
3164 = bfd_malloc (unwind_output_sec
->_raw_size
);
3165 if (unwind_output_sec
->contents
== NULL
)
3170 /* Invoke the regular ELF backend linker to do all the work. */
3171 if (!bfd_elfNN_bfd_final_link (abfd
, info
))
3174 if (unwind_output_sec
)
3176 elfNN_ia64_unwind_entry_compare_bfd
= abfd
;
3177 qsort (unwind_output_sec
->contents
, unwind_output_sec
->_raw_size
/ 24,
3178 24, elfNN_ia64_unwind_entry_compare
);
3180 if (! bfd_set_section_contents (abfd
, unwind_output_sec
,
3181 unwind_output_sec
->contents
, 0,
3182 unwind_output_sec
->_raw_size
))
3190 elfNN_ia64_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
3191 contents
, relocs
, local_syms
, local_sections
)
3193 struct bfd_link_info
*info
;
3195 asection
*input_section
;
3197 Elf_Internal_Rela
*relocs
;
3198 Elf_Internal_Sym
*local_syms
;
3199 asection
**local_sections
;
3201 struct elfNN_ia64_link_hash_table
*ia64_info
;
3202 Elf_Internal_Shdr
*symtab_hdr
;
3203 Elf_Internal_Rela
*rel
;
3204 Elf_Internal_Rela
*relend
;
3206 boolean ret_val
= true; /* for non-fatal errors */
3209 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3210 ia64_info
= elfNN_ia64_hash_table (info
);
3212 /* Infect various flags from the input section to the output section. */
3213 if (info
->relocateable
)
3217 flags
= elf_section_data(input_section
)->this_hdr
.sh_flags
;
3218 flags
&= SHF_IA_64_NORECOV
;
3220 elf_section_data(input_section
->output_section
)
3221 ->this_hdr
.sh_flags
|= flags
;
3224 gp_val
= _bfd_get_gp_value (output_bfd
);
3225 srel
= get_reloc_section (input_bfd
, ia64_info
, input_section
, false);
3228 relend
= relocs
+ input_section
->reloc_count
;
3229 for (; rel
< relend
; ++rel
)
3231 struct elf_link_hash_entry
*h
;
3232 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3233 bfd_reloc_status_type r
;
3234 reloc_howto_type
*howto
;
3235 unsigned long r_symndx
;
3236 Elf_Internal_Sym
*sym
;
3237 unsigned int r_type
;
3241 boolean dynamic_symbol_p
;
3242 boolean undef_weak_ref
;
3244 r_type
= ELFNN_R_TYPE (rel
->r_info
);
3245 if (r_type
> R_IA64_MAX_RELOC_CODE
)
3247 (*_bfd_error_handler
)
3248 (_("%s: unknown relocation type %d"),
3249 bfd_get_filename (input_bfd
), (int)r_type
);
3250 bfd_set_error (bfd_error_bad_value
);
3254 howto
= lookup_howto (r_type
);
3255 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
3257 if (info
->relocateable
)
3259 /* This is a relocateable link. We don't have to change
3260 anything, unless the reloc is against a section symbol,
3261 in which case we have to adjust according to where the
3262 section symbol winds up in the output section. */
3263 if (r_symndx
< symtab_hdr
->sh_info
)
3265 sym
= local_syms
+ r_symndx
;
3266 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3268 sym_sec
= local_sections
[r_symndx
];
3269 rel
->r_addend
+= sym_sec
->output_offset
;
3275 /* This is a final link. */
3280 undef_weak_ref
= false;
3282 if (r_symndx
< symtab_hdr
->sh_info
)
3284 /* Reloc against local symbol. */
3285 sym
= local_syms
+ r_symndx
;
3286 sym_sec
= local_sections
[r_symndx
];
3287 value
= (sym_sec
->output_section
->vma
3288 + sym_sec
->output_offset
3295 /* Reloc against global symbol. */
3296 indx
= r_symndx
- symtab_hdr
->sh_info
;
3297 h
= elf_sym_hashes (input_bfd
)[indx
];
3298 while (h
->root
.type
== bfd_link_hash_indirect
3299 || h
->root
.type
== bfd_link_hash_warning
)
3300 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3303 if (h
->root
.type
== bfd_link_hash_defined
3304 || h
->root
.type
== bfd_link_hash_defweak
)
3306 sym_sec
= h
->root
.u
.def
.section
;
3308 /* Detect the cases that sym_sec->output_section is
3309 expected to be NULL -- all cases in which the symbol
3310 is defined in another shared module. This includes
3311 PLT relocs for which we've created a PLT entry and
3312 other relocs for which we're prepared to create
3313 dynamic relocations. */
3314 /* ??? Just accept it NULL and continue. */
3316 if (sym_sec
->output_section
!= NULL
)
3318 value
= (h
->root
.u
.def
.value
3319 + sym_sec
->output_section
->vma
3320 + sym_sec
->output_offset
);
3323 else if (h
->root
.type
== bfd_link_hash_undefweak
)
3324 undef_weak_ref
= true;
3325 else if (info
->shared
&& !info
->symbolic
3326 && !info
->no_undefined
3327 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
3331 if (! ((*info
->callbacks
->undefined_symbol
)
3332 (info
, h
->root
.root
.string
, input_bfd
,
3333 input_section
, rel
->r_offset
,
3334 (!info
->shared
|| info
->no_undefined
3335 || ELF_ST_VISIBILITY (h
->other
)))))
3342 hit_addr
= contents
+ rel
->r_offset
;
3343 value
+= rel
->r_addend
;
3344 dynamic_symbol_p
= elfNN_ia64_dynamic_symbol_p (h
, info
);
3355 case R_IA64_DIR32MSB
:
3356 case R_IA64_DIR32LSB
:
3357 case R_IA64_DIR64MSB
:
3358 case R_IA64_DIR64LSB
:
3359 /* Install a dynamic relocation for this reloc. */
3360 if ((dynamic_symbol_p
|| info
->shared
)
3361 && (input_section
->flags
& SEC_ALLOC
) != 0)
3363 unsigned int dyn_r_type
;
3367 BFD_ASSERT (srel
!= NULL
);
3369 /* If we don't need dynamic symbol lookup, find a
3370 matching RELATIVE relocation. */
3371 dyn_r_type
= r_type
;
3372 if (dynamic_symbol_p
)
3374 dynindx
= h
->dynindx
;
3375 addend
= rel
->r_addend
;
3382 case R_IA64_DIR32MSB
:
3383 dyn_r_type
= R_IA64_REL32MSB
;
3385 case R_IA64_DIR32LSB
:
3386 dyn_r_type
= R_IA64_REL32LSB
;
3388 case R_IA64_DIR64MSB
:
3389 dyn_r_type
= R_IA64_REL64MSB
;
3391 case R_IA64_DIR64LSB
:
3392 dyn_r_type
= R_IA64_REL64LSB
;
3396 /* We can't represent this without a dynamic symbol.
3397 Adjust the relocation to be against an output
3398 section symbol, which are always present in the
3399 dynamic symbol table. */
3400 /* ??? People shouldn't be doing non-pic code in
3401 shared libraries. Hork. */
3402 (*_bfd_error_handler
)
3403 (_("%s: linking non-pic code in a shared library"),
3404 bfd_get_filename (input_bfd
));
3412 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
3413 srel
, rel
->r_offset
, dyn_r_type
,
3418 case R_IA64_LTV32MSB
:
3419 case R_IA64_LTV32LSB
:
3420 case R_IA64_LTV64MSB
:
3421 case R_IA64_LTV64LSB
:
3422 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3425 case R_IA64_GPREL22
:
3426 case R_IA64_GPREL64I
:
3427 case R_IA64_GPREL32MSB
:
3428 case R_IA64_GPREL32LSB
:
3429 case R_IA64_GPREL64MSB
:
3430 case R_IA64_GPREL64LSB
:
3431 if (dynamic_symbol_p
)
3433 (*_bfd_error_handler
)
3434 (_("%s: @gprel relocation against dynamic symbol %s"),
3435 bfd_get_filename (input_bfd
), h
->root
.root
.string
);
3440 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3443 case R_IA64_LTOFF22
:
3444 case R_IA64_LTOFF22X
:
3445 case R_IA64_LTOFF64I
:
3446 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, false);
3447 value
= set_got_entry (input_bfd
, info
, dyn_i
, (h
? h
->dynindx
: -1),
3448 rel
->r_addend
, value
, R_IA64_DIR64LSB
);
3450 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3453 case R_IA64_PLTOFF22
:
3454 case R_IA64_PLTOFF64I
:
3455 case R_IA64_PLTOFF64MSB
:
3456 case R_IA64_PLTOFF64LSB
:
3457 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, false);
3458 value
= set_pltoff_entry (output_bfd
, info
, dyn_i
, value
, false);
3460 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3463 case R_IA64_FPTR64I
:
3464 case R_IA64_FPTR32MSB
:
3465 case R_IA64_FPTR32LSB
:
3466 case R_IA64_FPTR64MSB
:
3467 case R_IA64_FPTR64LSB
:
3468 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, false);
3469 if (dyn_i
->want_fptr
)
3471 if (!undef_weak_ref
)
3472 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
3478 /* Otherwise, we expect the dynamic linker to create
3483 if (h
->dynindx
!= -1)
3484 dynindx
= h
->dynindx
;
3486 dynindx
= (_bfd_elf_link_lookup_local_dynindx
3487 (info
, h
->root
.u
.def
.section
->owner
,
3488 global_sym_index (h
)));
3492 dynindx
= (_bfd_elf_link_lookup_local_dynindx
3493 (info
, input_bfd
, r_symndx
));
3496 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
3497 srel
, rel
->r_offset
, r_type
,
3498 dynindx
, rel
->r_addend
);
3502 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3505 case R_IA64_LTOFF_FPTR22
:
3506 case R_IA64_LTOFF_FPTR64I
:
3507 case R_IA64_LTOFF_FPTR64MSB
:
3508 case R_IA64_LTOFF_FPTR64LSB
:
3512 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, false);
3513 if (dyn_i
->want_fptr
)
3515 BFD_ASSERT (h
== NULL
|| h
->dynindx
== -1)
3516 if (!undef_weak_ref
)
3517 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
3522 /* Otherwise, we expect the dynamic linker to create
3526 if (h
->dynindx
!= -1)
3527 dynindx
= h
->dynindx
;
3529 dynindx
= (_bfd_elf_link_lookup_local_dynindx
3530 (info
, h
->root
.u
.def
.section
->owner
,
3531 global_sym_index (h
)));
3534 dynindx
= (_bfd_elf_link_lookup_local_dynindx
3535 (info
, input_bfd
, r_symndx
));
3539 value
= set_got_entry (output_bfd
, info
, dyn_i
, dynindx
,
3540 rel
->r_addend
, value
, R_IA64_FPTR64LSB
);
3542 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3546 case R_IA64_PCREL32MSB
:
3547 case R_IA64_PCREL32LSB
:
3548 case R_IA64_PCREL64MSB
:
3549 case R_IA64_PCREL64LSB
:
3550 /* Install a dynamic relocation for this reloc. */
3551 if (dynamic_symbol_p
)
3553 BFD_ASSERT (srel
!= NULL
);
3555 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
3556 srel
, rel
->r_offset
, r_type
,
3557 h
->dynindx
, rel
->r_addend
);
3561 case R_IA64_PCREL21BI
:
3562 case R_IA64_PCREL21F
:
3563 case R_IA64_PCREL21M
:
3564 /* ??? These two are only used for speculation fixup code.
3565 They should never be dynamic. */
3566 if (dynamic_symbol_p
)
3568 (*_bfd_error_handler
)
3569 (_("%s: dynamic relocation against speculation fixup"),
3570 bfd_get_filename (input_bfd
));
3576 (*_bfd_error_handler
)
3577 (_("%s: speculation fixup against undefined weak symbol"),
3578 bfd_get_filename (input_bfd
));
3584 case R_IA64_PCREL21B
:
3585 case R_IA64_PCREL60B
:
3586 /* We should have created a PLT entry for any dynamic symbol. */
3589 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, false);
3591 if (dyn_i
&& dyn_i
->want_plt2
)
3593 /* Should have caught this earlier. */
3594 BFD_ASSERT (rel
->r_addend
== 0);
3596 value
= (ia64_info
->plt_sec
->output_section
->vma
3597 + ia64_info
->plt_sec
->output_offset
3598 + dyn_i
->plt2_offset
);
3602 /* Since there's no PLT entry, Validate that this is
3604 BFD_ASSERT (undef_weak_ref
|| sym_sec
->output_section
!= NULL
);
3606 /* If the symbol is undef_weak, we shouldn't be trying
3607 to call it. There's every chance that we'd wind up
3608 with an out-of-range fixup here. Don't bother setting
3609 any value at all. */
3615 case R_IA64_PCREL22
:
3616 case R_IA64_PCREL64I
:
3618 /* Make pc-relative. */
3619 value
-= (input_section
->output_section
->vma
3620 + input_section
->output_offset
3621 + rel
->r_offset
) & ~ (bfd_vma
) 0x3;
3622 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3625 case R_IA64_SEGREL32MSB
:
3626 case R_IA64_SEGREL32LSB
:
3627 case R_IA64_SEGREL64MSB
:
3628 case R_IA64_SEGREL64LSB
:
3630 struct elf_segment_map
*m
;
3631 Elf_Internal_Phdr
*p
;
3633 /* Find the segment that contains the output_section. */
3634 for (m
= elf_tdata (output_bfd
)->segment_map
,
3635 p
= elf_tdata (output_bfd
)->phdr
;
3640 for (i
= m
->count
- 1; i
>= 0; i
--)
3641 if (m
->sections
[i
] == sym_sec
->output_section
)
3649 /* If the input section was discarded from the output, then
3652 if (bfd_is_abs_section (sym_sec
->output_section
))
3655 r
= bfd_reloc_notsupported
;
3659 /* The VMA of the segment is the vaddr of the associated
3661 if (value
> p
->p_vaddr
)
3662 value
-= p
->p_vaddr
;
3665 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
,
3671 case R_IA64_SECREL32MSB
:
3672 case R_IA64_SECREL32LSB
:
3673 case R_IA64_SECREL64MSB
:
3674 case R_IA64_SECREL64LSB
:
3675 /* Make output-section relative. */
3676 if (value
> input_section
->output_section
->vma
)
3677 value
-= input_section
->output_section
->vma
;
3680 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3683 case R_IA64_IPLTMSB
:
3684 case R_IA64_IPLTLSB
:
3685 /* Install a dynamic relocation for this reloc. */
3686 if ((dynamic_symbol_p
|| info
->shared
)
3687 && (input_section
->flags
& SEC_ALLOC
) != 0)
3691 BFD_ASSERT (srel
!= NULL
);
3693 /* If we don't need dynamic symbol lookup, install two
3694 RELATIVE relocations. */
3695 if (! dynamic_symbol_p
)
3697 unsigned int dyn_r_type
;
3699 if (r_type
== R_IA64_IPLTMSB
)
3700 dyn_r_type
= R_IA64_REL64MSB
;
3702 dyn_r_type
= R_IA64_REL64LSB
;
3704 elfNN_ia64_install_dyn_reloc (output_bfd
, info
,
3706 srel
, rel
->r_offset
,
3707 dyn_r_type
, 0, value
);
3708 elfNN_ia64_install_dyn_reloc (output_bfd
, info
,
3710 srel
, rel
->r_offset
+ 8,
3711 dyn_r_type
, 0, gp_val
);
3714 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
3715 srel
, rel
->r_offset
, r_type
,
3716 h
->dynindx
, rel
->r_addend
);
3719 if (r_type
== R_IA64_IPLTMSB
)
3720 r_type
= R_IA64_DIR64MSB
;
3722 r_type
= R_IA64_DIR64LSB
;
3723 elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3724 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
+ 8, gp_val
,
3729 r
= bfd_reloc_notsupported
;
3738 case bfd_reloc_undefined
:
3739 /* This can happen for global table relative relocs if
3740 __gp is undefined. This is a panic situation so we
3741 don't try to continue. */
3742 (*info
->callbacks
->undefined_symbol
)
3743 (info
, "__gp", input_bfd
, input_section
, rel
->r_offset
, 1);
3746 case bfd_reloc_notsupported
:
3751 name
= h
->root
.root
.string
;
3754 name
= bfd_elf_string_from_elf_section (input_bfd
,
3755 symtab_hdr
->sh_link
,
3760 name
= bfd_section_name (input_bfd
, input_section
);
3762 if (!(*info
->callbacks
->warning
) (info
, _("unsupported reloc"),
3764 input_section
, rel
->r_offset
))
3770 case bfd_reloc_dangerous
:
3771 case bfd_reloc_outofrange
:
3772 case bfd_reloc_overflow
:
3778 name
= h
->root
.root
.string
;
3781 name
= bfd_elf_string_from_elf_section (input_bfd
,
3782 symtab_hdr
->sh_link
,
3787 name
= bfd_section_name (input_bfd
, input_section
);
3789 if (!(*info
->callbacks
->reloc_overflow
) (info
, name
,
3805 elfNN_ia64_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
3807 struct bfd_link_info
*info
;
3808 struct elf_link_hash_entry
*h
;
3809 Elf_Internal_Sym
*sym
;
3811 struct elfNN_ia64_link_hash_table
*ia64_info
;
3812 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3814 ia64_info
= elfNN_ia64_hash_table (info
);
3815 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, false);
3817 /* Fill in the PLT data, if required. */
3818 if (dyn_i
&& dyn_i
->want_plt
)
3820 Elf_Internal_Rela outrel
;
3823 bfd_vma plt_addr
, pltoff_addr
, gp_val
, index
;
3824 ElfNN_External_Rela
*rel
;
3826 gp_val
= _bfd_get_gp_value (output_bfd
);
3828 /* Initialize the minimal PLT entry. */
3830 index
= (dyn_i
->plt_offset
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
3831 plt_sec
= ia64_info
->plt_sec
;
3832 loc
= plt_sec
->contents
+ dyn_i
->plt_offset
;
3834 memcpy (loc
, plt_min_entry
, PLT_MIN_ENTRY_SIZE
);
3835 elfNN_ia64_install_value (output_bfd
, loc
, index
, R_IA64_IMM22
);
3836 elfNN_ia64_install_value (output_bfd
, loc
+2, -dyn_i
->plt_offset
,
3839 plt_addr
= (plt_sec
->output_section
->vma
3840 + plt_sec
->output_offset
3841 + dyn_i
->plt_offset
);
3842 pltoff_addr
= set_pltoff_entry (output_bfd
, info
, dyn_i
, plt_addr
, true);
3844 /* Initialize the FULL PLT entry, if needed. */
3845 if (dyn_i
->want_plt2
)
3847 loc
= plt_sec
->contents
+ dyn_i
->plt2_offset
;
3849 memcpy (loc
, plt_full_entry
, PLT_FULL_ENTRY_SIZE
);
3850 elfNN_ia64_install_value (output_bfd
, loc
, pltoff_addr
- gp_val
,
3853 /* Mark the symbol as undefined, rather than as defined in the
3854 plt section. Leave the value alone. */
3855 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
3856 first place. But perhaps elflink.h did some for us. */
3857 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3858 sym
->st_shndx
= SHN_UNDEF
;
3861 /* Create the dynamic relocation. */
3862 outrel
.r_offset
= pltoff_addr
;
3863 if (bfd_little_endian (output_bfd
))
3864 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_IA64_IPLTLSB
);
3866 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_IA64_IPLTMSB
);
3867 outrel
.r_addend
= 0;
3869 /* This is fun. In the .IA_64.pltoff section, we've got entries
3870 that correspond both to real PLT entries, and those that
3871 happened to resolve to local symbols but need to be created
3872 to satisfy @pltoff relocations. The .rela.IA_64.pltoff
3873 relocations for the real PLT should come at the end of the
3874 section, so that they can be indexed by plt entry at runtime.
3876 We emitted all of the relocations for the non-PLT @pltoff
3877 entries during relocate_section. So we can consider the
3878 existing sec->reloc_count to be the base of the array of
3881 rel
= (ElfNN_External_Rela
*)ia64_info
->rel_pltoff_sec
->contents
;
3882 rel
+= ia64_info
->rel_pltoff_sec
->reloc_count
;
3884 bfd_elfNN_swap_reloca_out (output_bfd
, &outrel
, rel
+ index
);
3887 /* Mark some specially defined symbols as absolute. */
3888 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3889 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
3890 || strcmp (h
->root
.root
.string
, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3891 sym
->st_shndx
= SHN_ABS
;
3897 elfNN_ia64_finish_dynamic_sections (abfd
, info
)
3899 struct bfd_link_info
*info
;
3901 struct elfNN_ia64_link_hash_table
*ia64_info
;
3904 ia64_info
= elfNN_ia64_hash_table (info
);
3905 dynobj
= ia64_info
->root
.dynobj
;
3907 if (elf_hash_table (info
)->dynamic_sections_created
)
3909 ElfNN_External_Dyn
*dyncon
, *dynconend
;
3910 asection
*sdyn
, *sgotplt
;
3913 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3914 sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
3915 BFD_ASSERT (sdyn
!= NULL
);
3916 dyncon
= (ElfNN_External_Dyn
*) sdyn
->contents
;
3917 dynconend
= (ElfNN_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
3919 gp_val
= _bfd_get_gp_value (abfd
);
3921 for (; dyncon
< dynconend
; dyncon
++)
3923 Elf_Internal_Dyn dyn
;
3925 bfd_elfNN_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3930 dyn
.d_un
.d_ptr
= gp_val
;
3934 dyn
.d_un
.d_val
= (ia64_info
->minplt_entries
3935 * sizeof (ElfNN_External_Rela
));
3939 /* See the comment above in finish_dynamic_symbol. */
3940 dyn
.d_un
.d_ptr
= (ia64_info
->rel_pltoff_sec
->output_section
->vma
3941 + ia64_info
->rel_pltoff_sec
->output_offset
3942 + (ia64_info
->rel_pltoff_sec
->reloc_count
3943 * sizeof (ElfNN_External_Rela
)));
3946 case DT_IA_64_PLT_RESERVE
:
3947 dyn
.d_un
.d_ptr
= (sgotplt
->output_section
->vma
3948 + sgotplt
->output_offset
);
3952 /* Do not have RELASZ include JMPREL. This makes things
3953 easier on ld.so. This is not what the rest of BFD set up. */
3954 dyn
.d_un
.d_val
-= (ia64_info
->minplt_entries
3955 * sizeof (ElfNN_External_Rela
));
3961 struct elf_link_hash_entry
*h
;
3962 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3965 if (dyn
.d_tag
== DT_INIT
)
3966 which
= info
->init_function
;
3968 which
= info
->fini_function
;
3970 h
= elf_link_hash_lookup (elf_hash_table (info
), which
,
3971 false, false, false);
3972 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, false);
3973 dyn
.d_un
.d_ptr
= set_pltoff_entry (abfd
, info
, dyn_i
,
3978 bfd_elfNN_swap_dyn_out (abfd
, &dyn
, dyncon
);
3981 /* Initialize the PLT0 entry */
3982 if (ia64_info
->plt_sec
)
3984 bfd_byte
*loc
= ia64_info
->plt_sec
->contents
;
3987 memcpy (loc
, plt_header
, PLT_HEADER_SIZE
);
3989 pltres
= (sgotplt
->output_section
->vma
3990 + sgotplt
->output_offset
3993 elfNN_ia64_install_value (abfd
, loc
+1, pltres
, R_IA64_GPREL22
);
4000 /* ELF file flag handling: */
4002 /* Function to keep IA-64 specific file flags. */
4004 elfNN_ia64_set_private_flags (abfd
, flags
)
4008 BFD_ASSERT (!elf_flags_init (abfd
)
4009 || elf_elfheader (abfd
)->e_flags
== flags
);
4011 elf_elfheader (abfd
)->e_flags
= flags
;
4012 elf_flags_init (abfd
) = true;
4016 /* Copy backend specific data from one object module to another */
4018 elfNN_ia64_copy_private_bfd_data (ibfd
, obfd
)
4021 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4022 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4025 BFD_ASSERT (!elf_flags_init (obfd
)
4026 || (elf_elfheader (obfd
)->e_flags
4027 == elf_elfheader (ibfd
)->e_flags
));
4029 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
4030 elf_flags_init (obfd
) = true;
4034 /* Merge backend specific data from an object file to the output
4035 object file when linking. */
4037 elfNN_ia64_merge_private_bfd_data (ibfd
, obfd
)
4044 /* Don't even pretend to support mixed-format linking. */
4045 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4046 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4049 in_flags
= elf_elfheader (ibfd
)->e_flags
;
4050 out_flags
= elf_elfheader (obfd
)->e_flags
;
4052 if (! elf_flags_init (obfd
))
4054 elf_flags_init (obfd
) = true;
4055 elf_elfheader (obfd
)->e_flags
= in_flags
;
4057 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
4058 && bfd_get_arch_info (obfd
)->the_default
)
4060 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
4061 bfd_get_mach (ibfd
));
4067 /* Check flag compatibility. */
4068 if (in_flags
== out_flags
)
4071 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
4072 if (!(in_flags
& EF_IA_64_REDUCEDFP
) && (out_flags
& EF_IA_64_REDUCEDFP
))
4073 elf_elfheader (obfd
)->e_flags
&= ~EF_IA_64_REDUCEDFP
;
4075 if ((in_flags
& EF_IA_64_TRAPNIL
) != (out_flags
& EF_IA_64_TRAPNIL
))
4077 (*_bfd_error_handler
)
4078 (_("%s: linking trap-on-NULL-dereference with non-trapping files"),
4079 bfd_get_filename (ibfd
));
4081 bfd_set_error (bfd_error_bad_value
);
4084 if ((in_flags
& EF_IA_64_BE
) != (out_flags
& EF_IA_64_BE
))
4086 (*_bfd_error_handler
)
4087 (_("%s: linking big-endian files with little-endian files"),
4088 bfd_get_filename (ibfd
));
4090 bfd_set_error (bfd_error_bad_value
);
4093 if ((in_flags
& EF_IA_64_ABI64
) != (out_flags
& EF_IA_64_ABI64
))
4095 (*_bfd_error_handler
)
4096 (_("%s: linking 64-bit files with 32-bit files"),
4097 bfd_get_filename (ibfd
));
4099 bfd_set_error (bfd_error_bad_value
);
4102 if ((in_flags
& EF_IA_64_CONS_GP
) != (out_flags
& EF_IA_64_CONS_GP
))
4104 (*_bfd_error_handler
)
4105 (_("%s: linking constant-gp files with non-constant-gp files"),
4106 bfd_get_filename (ibfd
));
4108 bfd_set_error (bfd_error_bad_value
);
4111 if ((in_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
)
4112 != (out_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
4114 (*_bfd_error_handler
)
4115 (_("%s: linking auto-pic files with non-auto-pic files"),
4116 bfd_get_filename (ibfd
));
4118 bfd_set_error (bfd_error_bad_value
);
4126 elfNN_ia64_print_private_bfd_data (abfd
, ptr
)
4130 FILE *file
= (FILE *) ptr
;
4131 flagword flags
= elf_elfheader (abfd
)->e_flags
;
4133 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
4135 fprintf (file
, "private flags = %s%s%s%s%s%s%s%s\n",
4136 (flags
& EF_IA_64_TRAPNIL
) ? "TRAPNIL, " : "",
4137 (flags
& EF_IA_64_EXT
) ? "EXT, " : "",
4138 (flags
& EF_IA_64_BE
) ? "BE, " : "LE, ",
4139 (flags
& EF_IA_64_REDUCEDFP
) ? "REDUCEDFP, " : "",
4140 (flags
& EF_IA_64_CONS_GP
) ? "CONS_GP, " : "",
4141 (flags
& EF_IA_64_NOFUNCDESC_CONS_GP
) ? "NOFUNCDESC_CONS_GP, " : "",
4142 (flags
& EF_IA_64_ABSOLUTE
) ? "ABSOLUTE, " : "",
4143 (flags
& EF_IA_64_ABI64
) ? "ABI64" : "ABI32");
4145 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
4149 #define TARGET_LITTLE_SYM bfd_elfNN_ia64_little_vec
4150 #define TARGET_LITTLE_NAME "elfNN-ia64-little"
4151 #define TARGET_BIG_SYM bfd_elfNN_ia64_big_vec
4152 #define TARGET_BIG_NAME "elfNN-ia64-big"
4153 #define ELF_ARCH bfd_arch_ia64
4154 #define ELF_MACHINE_CODE EM_IA_64
4155 #define ELF_MACHINE_ALT1 1999 /* EAS2.3 */
4156 #define ELF_MACHINE_ALT2 1998 /* EAS2.2 */
4157 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
4159 #define elf_backend_section_from_shdr \
4160 elfNN_ia64_section_from_shdr
4161 #define elf_backend_section_flags \
4162 elfNN_ia64_section_flags
4163 #define elf_backend_fake_sections \
4164 elfNN_ia64_fake_sections
4165 #define elf_backend_add_symbol_hook \
4166 elfNN_ia64_add_symbol_hook
4167 #define elf_backend_additional_program_headers \
4168 elfNN_ia64_additional_program_headers
4169 #define elf_backend_modify_segment_map \
4170 elfNN_ia64_modify_segment_map
4171 #define elf_info_to_howto \
4172 elfNN_ia64_info_to_howto
4174 #define bfd_elfNN_bfd_reloc_type_lookup \
4175 elfNN_ia64_reloc_type_lookup
4176 #define bfd_elfNN_bfd_is_local_label_name \
4177 elfNN_ia64_is_local_label_name
4178 #define bfd_elfNN_bfd_relax_section \
4179 elfNN_ia64_relax_section
4181 /* Stuff for the BFD linker: */
4182 #define bfd_elfNN_bfd_link_hash_table_create \
4183 elfNN_ia64_hash_table_create
4184 #define elf_backend_create_dynamic_sections \
4185 elfNN_ia64_create_dynamic_sections
4186 #define elf_backend_check_relocs \
4187 elfNN_ia64_check_relocs
4188 #define elf_backend_adjust_dynamic_symbol \
4189 elfNN_ia64_adjust_dynamic_symbol
4190 #define elf_backend_size_dynamic_sections \
4191 elfNN_ia64_size_dynamic_sections
4192 #define elf_backend_relocate_section \
4193 elfNN_ia64_relocate_section
4194 #define elf_backend_finish_dynamic_symbol \
4195 elfNN_ia64_finish_dynamic_symbol
4196 #define elf_backend_finish_dynamic_sections \
4197 elfNN_ia64_finish_dynamic_sections
4198 #define bfd_elfNN_bfd_final_link \
4199 elfNN_ia64_final_link
4201 #define bfd_elfNN_bfd_copy_private_bfd_data \
4202 elfNN_ia64_copy_private_bfd_data
4203 #define bfd_elfNN_bfd_merge_private_bfd_data \
4204 elfNN_ia64_merge_private_bfd_data
4205 #define bfd_elfNN_bfd_set_private_flags \
4206 elfNN_ia64_set_private_flags
4207 #define bfd_elfNN_bfd_print_private_bfd_data \
4208 elfNN_ia64_print_private_bfd_data
4210 #define elf_backend_plt_readonly 1
4211 #define elf_backend_want_plt_sym 0
4212 #define elf_backend_plt_alignment 5
4213 #define elf_backend_got_header_size 0
4214 #define elf_backend_plt_header_size PLT_HEADER_SIZE
4215 #define elf_backend_want_got_plt 1
4216 #define elf_backend_may_use_rel_p 1
4217 #define elf_backend_may_use_rela_p 1
4218 #define elf_backend_default_use_rela_p 1
4219 #define elf_backend_want_dynbss 0
4220 #define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect
4221 #define elf_backend_hide_symbol elfNN_ia64_hash_hide_symbol
4223 #include "elfNN-target.h"