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 elf64_ia64_dyn_sym_info
72 /* The addend for which this entry is relevant. */
75 /* Next addend in the list. */
76 struct elf64_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 elf64_ia64_dyn_reloc_entry
91 struct elf64_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 elf64_ia64_local_hash_entry
113 struct bfd_hash_entry root
;
114 struct elf64_ia64_dyn_sym_info
*info
;
117 struct elf64_ia64_local_hash_table
119 struct bfd_hash_table root
;
120 /* No additional fields for now. */
123 struct elf64_ia64_link_hash_entry
125 struct elf_link_hash_entry root
;
126 struct elf64_ia64_dyn_sym_info
*info
;
129 struct elf64_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 elf64_ia64_local_hash_table loc_hash_table
;
146 #define elf64_ia64_hash_table(p) \
147 ((struct elf64_ia64_link_hash_table *) ((p)->hash))
149 static bfd_reloc_status_type elf64_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
*elf64_ia64_reloc_type_lookup
155 PARAMS ((bfd
*abfd
, bfd_reloc_code_real_type bfd_code
));
156 static void elf64_ia64_info_to_howto
157 PARAMS ((bfd
*abfd
, arelent
*bfd_reloc
, Elf64_Internal_Rela
*elf_reloc
));
158 static boolean elf64_ia64_relax_section
159 PARAMS((bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
,
161 static boolean elf64_ia64_section_from_shdr
162 PARAMS ((bfd
*, Elf64_Internal_Shdr
*, char *));
163 static boolean elf64_ia64_fake_sections
164 PARAMS ((bfd
*abfd
, Elf64_Internal_Shdr
*hdr
, asection
*sec
));
165 static boolean elf64_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 elf64_ia64_additional_program_headers
170 PARAMS ((bfd
*abfd
));
171 static boolean elf64_ia64_is_local_label_name
172 PARAMS ((bfd
*abfd
, const char *name
));
173 static boolean elf64_ia64_dynamic_symbol_p
174 PARAMS ((struct elf_link_hash_entry
*h
, struct bfd_link_info
*info
));
175 static boolean elf64_ia64_local_hash_table_init
176 PARAMS ((struct elf64_ia64_local_hash_table
*ht
, bfd
*abfd
,
177 new_hash_entry_func
new));
178 static struct bfd_hash_entry
*elf64_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
*elf64_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
*elf64_ia64_hash_table_create
185 PARAMS ((bfd
*abfd
));
186 static struct elf64_ia64_local_hash_entry
*elf64_ia64_local_hash_lookup
187 PARAMS ((struct elf64_ia64_local_hash_table
*table
, const char *string
,
188 boolean create
, boolean copy
));
189 static void elf64_ia64_dyn_sym_traverse
190 PARAMS ((struct elf64_ia64_link_hash_table
*ia64_info
,
191 boolean (*func
)(struct elf64_ia64_dyn_sym_info
*, PTR
),
193 static boolean elf64_ia64_create_dynamic_sections
194 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
195 static struct elf64_ia64_dyn_sym_info
* get_dyn_sym_info
196 PARAMS ((struct elf64_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 elf64_ia64_link_hash_table
*ia64_info
));
202 static asection
*get_fptr
203 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
204 struct elf64_ia64_link_hash_table
*ia64_info
));
205 static asection
*get_pltoff
206 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
207 struct elf64_ia64_link_hash_table
*ia64_info
));
208 static asection
*get_reloc_section
209 PARAMS ((bfd
*abfd
, struct elf64_ia64_link_hash_table
*ia64_info
,
210 asection
*sec
, boolean create
));
211 static boolean count_dyn_reloc
212 PARAMS ((bfd
*abfd
, struct elf64_ia64_dyn_sym_info
*dyn_i
,
213 asection
*srel
, int type
));
214 static boolean elf64_ia64_check_relocs
215 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
216 const Elf_Internal_Rela
*relocs
));
217 static boolean elf64_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 elf64_ia64_dyn_sym_info
*dyn_i
, PTR data
));
223 static boolean allocate_global_data_got
224 PARAMS ((struct elf64_ia64_dyn_sym_info
*dyn_i
, PTR data
));
225 static boolean allocate_global_fptr_got
226 PARAMS ((struct elf64_ia64_dyn_sym_info
*dyn_i
, PTR data
));
227 static boolean allocate_local_got
228 PARAMS ((struct elf64_ia64_dyn_sym_info
*dyn_i
, PTR data
));
229 static boolean allocate_pltoff_entries
230 PARAMS ((struct elf64_ia64_dyn_sym_info
*dyn_i
, PTR data
));
231 static boolean allocate_plt_entries
232 PARAMS ((struct elf64_ia64_dyn_sym_info
*dyn_i
, PTR data
));
233 static boolean allocate_plt2_entries
234 PARAMS ((struct elf64_ia64_dyn_sym_info
*dyn_i
, PTR data
));
235 static boolean allocate_dynrel_entries
236 PARAMS ((struct elf64_ia64_dyn_sym_info
*dyn_i
, PTR data
));
237 static boolean elf64_ia64_size_dynamic_sections
238 PARAMS ((bfd
*output_bfd
, struct bfd_link_info
*info
));
239 static bfd_reloc_status_type elf64_ia64_install_value
240 PARAMS ((bfd
*abfd
, bfd_byte
*hit_addr
, bfd_vma val
, unsigned int r_type
));
241 static void elf64_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 elf64_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 elf64_ia64_dyn_sym_info
*dyn_i
,
253 static bfd_vma set_pltoff_entry
254 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
255 struct elf64_ia64_dyn_sym_info
*dyn_i
,
256 bfd_vma value
, boolean
));
257 static boolean elf64_ia64_final_link
258 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
259 static boolean elf64_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 elf64_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 elf64_ia64_finish_dynamic_sections
268 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
269 static boolean elf64_ia64_set_private_flags
270 PARAMS ((bfd
*abfd
, flagword flags
));
271 static boolean elf64_ia64_copy_private_bfd_data
272 PARAMS ((bfd
*ibfd
, bfd
*obfd
));
273 static boolean elf64_ia64_merge_private_bfd_data
274 PARAMS ((bfd
*ibfd
, bfd
*obfd
));
275 static boolean elf64_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 elf64_ia64_final_link_relocate. */
283 static bfd_reloc_status_type
284 elf64_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 elf64_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 elf64_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_SEGBASE
, "SEGBASE", 4, false, true),
357 IA64_HOWTO (R_IA64_SEGREL32MSB
, "SEGREL32MSB", 2, false, true),
358 IA64_HOWTO (R_IA64_SEGREL32LSB
, "SEGREL32LSB", 2, false, true),
359 IA64_HOWTO (R_IA64_SEGREL64MSB
, "SEGREL64MSB", 4, false, true),
360 IA64_HOWTO (R_IA64_SEGREL64LSB
, "SEGREL64LSB", 4, false, true),
362 IA64_HOWTO (R_IA64_SECREL32MSB
, "SECREL32MSB", 2, false, true),
363 IA64_HOWTO (R_IA64_SECREL32LSB
, "SECREL32LSB", 2, false, true),
364 IA64_HOWTO (R_IA64_SECREL64MSB
, "SECREL64MSB", 4, false, true),
365 IA64_HOWTO (R_IA64_SECREL64LSB
, "SECREL64LSB", 4, false, true),
367 IA64_HOWTO (R_IA64_REL32MSB
, "REL32MSB", 2, false, true),
368 IA64_HOWTO (R_IA64_REL32LSB
, "REL32LSB", 2, false, true),
369 IA64_HOWTO (R_IA64_REL64MSB
, "REL64MSB", 4, false, true),
370 IA64_HOWTO (R_IA64_REL64LSB
, "REL64LSB", 4, false, true),
372 IA64_HOWTO (R_IA64_LTV32MSB
, "LTV32MSB", 2, false, true),
373 IA64_HOWTO (R_IA64_LTV32LSB
, "LTV32LSB", 2, false, true),
374 IA64_HOWTO (R_IA64_LTV64MSB
, "LTV64MSB", 4, false, true),
375 IA64_HOWTO (R_IA64_LTV64LSB
, "LTV64LSB", 4, false, true),
377 IA64_HOWTO (R_IA64_PCREL21BI
, "PCREL21BI", 0, true, true),
378 IA64_HOWTO (R_IA64_PCREL22
, "PCREL22", 0, true, true),
379 IA64_HOWTO (R_IA64_PCREL64I
, "PCREL64I", 0, true, true),
381 IA64_HOWTO (R_IA64_IPLTMSB
, "IPLTMSB", 4, false, true),
382 IA64_HOWTO (R_IA64_IPLTLSB
, "IPLTLSB", 4, false, true),
383 IA64_HOWTO (R_IA64_EPLTMSB
, "EPLTMSB", 4, false, true),
384 IA64_HOWTO (R_IA64_EPLTLSB
, "EPLTLSB", 4, false, true),
385 IA64_HOWTO (R_IA64_COPY
, "COPY", 4, false, true),
386 IA64_HOWTO (R_IA64_LTOFF22X
, "LTOFF22X", 0, false, true),
387 IA64_HOWTO (R_IA64_LDXMOV
, "LDXMOV", 0, false, true),
389 IA64_HOWTO (R_IA64_TPREL22
, "TPREL22", 0, false, false),
390 IA64_HOWTO (R_IA64_TPREL64MSB
, "TPREL64MSB", 8, false, false),
391 IA64_HOWTO (R_IA64_TPREL64LSB
, "TPREL64LSB", 8, false, false),
392 IA64_HOWTO (R_IA64_LTOFF_TP22
, "LTOFF_TP22", 0, false, false),
395 static unsigned char elf_code_to_howto_index
[R_IA64_MAX_RELOC_CODE
+ 1];
397 /* Given a BFD reloc type, return the matching HOWTO structure. */
399 static reloc_howto_type
*
403 static int inited
= 0;
410 memset (elf_code_to_howto_index
, 0xff, sizeof (elf_code_to_howto_index
));
411 for (i
= 0; i
< NELEMS (ia64_howto_table
); ++i
)
412 elf_code_to_howto_index
[ia64_howto_table
[i
].type
] = i
;
415 BFD_ASSERT (rtype
<= R_IA64_MAX_RELOC_CODE
);
416 i
= elf_code_to_howto_index
[rtype
];
417 if (i
>= NELEMS (ia64_howto_table
))
419 return ia64_howto_table
+ i
;
422 static reloc_howto_type
*
423 elf64_ia64_reloc_type_lookup (abfd
, bfd_code
)
425 bfd_reloc_code_real_type bfd_code
;
431 case BFD_RELOC_NONE
: rtype
= R_IA64_NONE
; break;
433 case BFD_RELOC_IA64_IMM14
: rtype
= R_IA64_IMM14
; break;
434 case BFD_RELOC_IA64_IMM22
: rtype
= R_IA64_IMM22
; break;
435 case BFD_RELOC_IA64_IMM64
: rtype
= R_IA64_IMM64
; break;
437 case BFD_RELOC_IA64_DIR32MSB
: rtype
= R_IA64_DIR32MSB
; break;
438 case BFD_RELOC_IA64_DIR32LSB
: rtype
= R_IA64_DIR32LSB
; break;
439 case BFD_RELOC_IA64_DIR64MSB
: rtype
= R_IA64_DIR64MSB
; break;
440 case BFD_RELOC_IA64_DIR64LSB
: rtype
= R_IA64_DIR64LSB
; break;
442 case BFD_RELOC_IA64_GPREL22
: rtype
= R_IA64_GPREL22
; break;
443 case BFD_RELOC_IA64_GPREL64I
: rtype
= R_IA64_GPREL64I
; break;
444 case BFD_RELOC_IA64_GPREL32MSB
: rtype
= R_IA64_GPREL32MSB
; break;
445 case BFD_RELOC_IA64_GPREL32LSB
: rtype
= R_IA64_GPREL32LSB
; break;
446 case BFD_RELOC_IA64_GPREL64MSB
: rtype
= R_IA64_GPREL64MSB
; break;
447 case BFD_RELOC_IA64_GPREL64LSB
: rtype
= R_IA64_GPREL64LSB
; break;
449 case BFD_RELOC_IA64_LTOFF22
: rtype
= R_IA64_LTOFF22
; break;
450 case BFD_RELOC_IA64_LTOFF64I
: rtype
= R_IA64_LTOFF64I
; break;
452 case BFD_RELOC_IA64_PLTOFF22
: rtype
= R_IA64_PLTOFF22
; break;
453 case BFD_RELOC_IA64_PLTOFF64I
: rtype
= R_IA64_PLTOFF64I
; break;
454 case BFD_RELOC_IA64_PLTOFF64MSB
: rtype
= R_IA64_PLTOFF64MSB
; break;
455 case BFD_RELOC_IA64_PLTOFF64LSB
: rtype
= R_IA64_PLTOFF64LSB
; break;
456 case BFD_RELOC_IA64_FPTR64I
: rtype
= R_IA64_FPTR64I
; break;
457 case BFD_RELOC_IA64_FPTR32MSB
: rtype
= R_IA64_FPTR32MSB
; break;
458 case BFD_RELOC_IA64_FPTR32LSB
: rtype
= R_IA64_FPTR32LSB
; break;
459 case BFD_RELOC_IA64_FPTR64MSB
: rtype
= R_IA64_FPTR64MSB
; break;
460 case BFD_RELOC_IA64_FPTR64LSB
: rtype
= R_IA64_FPTR64LSB
; break;
462 case BFD_RELOC_IA64_PCREL21B
: rtype
= R_IA64_PCREL21B
; break;
463 case BFD_RELOC_IA64_PCREL21BI
: rtype
= R_IA64_PCREL21BI
; break;
464 case BFD_RELOC_IA64_PCREL21M
: rtype
= R_IA64_PCREL21M
; break;
465 case BFD_RELOC_IA64_PCREL21F
: rtype
= R_IA64_PCREL21F
; break;
466 case BFD_RELOC_IA64_PCREL22
: rtype
= R_IA64_PCREL22
; break;
467 case BFD_RELOC_IA64_PCREL60B
: rtype
= R_IA64_PCREL60B
; break;
468 case BFD_RELOC_IA64_PCREL64I
: rtype
= R_IA64_PCREL64I
; break;
469 case BFD_RELOC_IA64_PCREL32MSB
: rtype
= R_IA64_PCREL32MSB
; break;
470 case BFD_RELOC_IA64_PCREL32LSB
: rtype
= R_IA64_PCREL32LSB
; break;
471 case BFD_RELOC_IA64_PCREL64MSB
: rtype
= R_IA64_PCREL64MSB
; break;
472 case BFD_RELOC_IA64_PCREL64LSB
: rtype
= R_IA64_PCREL64LSB
; break;
474 case BFD_RELOC_IA64_LTOFF_FPTR22
: rtype
= R_IA64_LTOFF_FPTR22
; break;
475 case BFD_RELOC_IA64_LTOFF_FPTR64I
: rtype
= R_IA64_LTOFF_FPTR64I
; break;
476 case BFD_RELOC_IA64_LTOFF_FPTR64MSB
: rtype
= R_IA64_LTOFF_FPTR64MSB
; break;
477 case BFD_RELOC_IA64_LTOFF_FPTR64LSB
: rtype
= R_IA64_LTOFF_FPTR64LSB
; break;
479 case BFD_RELOC_IA64_SEGBASE
: rtype
= R_IA64_SEGBASE
; break;
480 case BFD_RELOC_IA64_SEGREL32MSB
: rtype
= R_IA64_SEGREL32MSB
; break;
481 case BFD_RELOC_IA64_SEGREL32LSB
: rtype
= R_IA64_SEGREL32LSB
; break;
482 case BFD_RELOC_IA64_SEGREL64MSB
: rtype
= R_IA64_SEGREL64MSB
; break;
483 case BFD_RELOC_IA64_SEGREL64LSB
: rtype
= R_IA64_SEGREL64LSB
; break;
485 case BFD_RELOC_IA64_SECREL32MSB
: rtype
= R_IA64_SECREL32MSB
; break;
486 case BFD_RELOC_IA64_SECREL32LSB
: rtype
= R_IA64_SECREL32LSB
; break;
487 case BFD_RELOC_IA64_SECREL64MSB
: rtype
= R_IA64_SECREL64MSB
; break;
488 case BFD_RELOC_IA64_SECREL64LSB
: rtype
= R_IA64_SECREL64LSB
; break;
490 case BFD_RELOC_IA64_REL32MSB
: rtype
= R_IA64_REL32MSB
; break;
491 case BFD_RELOC_IA64_REL32LSB
: rtype
= R_IA64_REL32LSB
; break;
492 case BFD_RELOC_IA64_REL64MSB
: rtype
= R_IA64_REL64MSB
; break;
493 case BFD_RELOC_IA64_REL64LSB
: rtype
= R_IA64_REL64LSB
; break;
495 case BFD_RELOC_IA64_LTV32MSB
: rtype
= R_IA64_LTV32MSB
; break;
496 case BFD_RELOC_IA64_LTV32LSB
: rtype
= R_IA64_LTV32LSB
; break;
497 case BFD_RELOC_IA64_LTV64MSB
: rtype
= R_IA64_LTV64MSB
; break;
498 case BFD_RELOC_IA64_LTV64LSB
: rtype
= R_IA64_LTV64LSB
; break;
500 case BFD_RELOC_IA64_IPLTMSB
: rtype
= R_IA64_IPLTMSB
; break;
501 case BFD_RELOC_IA64_IPLTLSB
: rtype
= R_IA64_IPLTLSB
; break;
502 case BFD_RELOC_IA64_EPLTMSB
: rtype
= R_IA64_EPLTMSB
; break;
503 case BFD_RELOC_IA64_EPLTLSB
: rtype
= R_IA64_EPLTLSB
; break;
504 case BFD_RELOC_IA64_COPY
: rtype
= R_IA64_COPY
; break;
505 case BFD_RELOC_IA64_LTOFF22X
: rtype
= R_IA64_LTOFF22X
; break;
506 case BFD_RELOC_IA64_LDXMOV
: rtype
= R_IA64_LDXMOV
; break;
508 case BFD_RELOC_IA64_TPREL22
: rtype
= R_IA64_TPREL22
; break;
509 case BFD_RELOC_IA64_TPREL64MSB
: rtype
= R_IA64_TPREL64MSB
; break;
510 case BFD_RELOC_IA64_TPREL64LSB
: rtype
= R_IA64_TPREL64LSB
; break;
511 case BFD_RELOC_IA64_LTOFF_TP22
: rtype
= R_IA64_LTOFF_TP22
; break;
515 return lookup_howto (rtype
);
518 /* Given a ELF reloc, return the matching HOWTO structure. */
521 elf64_ia64_info_to_howto (abfd
, bfd_reloc
, elf_reloc
)
524 Elf64_Internal_Rela
*elf_reloc
;
526 bfd_reloc
->howto
= lookup_howto (ELF64_R_TYPE (elf_reloc
->r_info
));
529 #define PLT_HEADER_SIZE (3 * 16)
530 #define PLT_MIN_ENTRY_SIZE (1 * 16)
531 #define PLT_FULL_ENTRY_SIZE (2 * 16)
532 #define PLT_RESERVED_WORDS 3
534 static const bfd_byte plt_header
[PLT_HEADER_SIZE
] =
536 0x0b, 0x10, 0x00, 0x1c, 0x00, 0x21, /* [MMI] mov r2=r14;; */
537 0xe0, 0x00, 0x08, 0x00, 0x48, 0x00, /* addl r14=0,r2 */
538 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
539 0x0b, 0x80, 0x20, 0x1c, 0x18, 0x14, /* [MMI] ld8 r16=[r14],8;; */
540 0x10, 0x41, 0x38, 0x30, 0x28, 0x00, /* ld8 r17=[r14],8 */
541 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
542 0x11, 0x08, 0x00, 0x1c, 0x18, 0x10, /* [MIB] ld8 r1=[r14] */
543 0x60, 0x88, 0x04, 0x80, 0x03, 0x00, /* mov b6=r17 */
544 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
547 static const bfd_byte plt_min_entry
[PLT_MIN_ENTRY_SIZE
] =
549 0x11, 0x78, 0x00, 0x00, 0x00, 0x24, /* [MIB] mov r15=0 */
550 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, /* nop.i 0x0 */
551 0x00, 0x00, 0x00, 0x40 /* br.few 0 <PLT0>;; */
554 static const bfd_byte plt_full_entry
[PLT_FULL_ENTRY_SIZE
] =
556 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
557 0x00, 0x41, 0x3c, 0x30, 0x28, 0xc0, /* ld8 r16=[r15],8 */
558 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
559 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
560 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
561 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
564 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
566 /* Select out of range branch fixup type. Note that Itanium does
567 not support brl, and so it gets emulated by the kernel. */
570 static const bfd_byte oor_brl
[16] =
572 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
573 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;; */
574 0x00, 0x00, 0x00, 0xc0
577 static const bfd_byte oor_ip
[48] =
579 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
580 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, /* movl r15=0 */
581 0x01, 0x00, 0x00, 0x60,
582 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MII] nop.m 0 */
583 0x00, 0x01, 0x00, 0x60, 0x00, 0x00, /* mov r16=ip;; */
584 0xf2, 0x80, 0x00, 0x80, /* add r16=r15,r16;; */
585 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MIB] nop.m 0 */
586 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
587 0x60, 0x00, 0x80, 0x00 /* br b6;; */
590 /* These functions do relaxation for IA-64 ELF.
592 This is primarily to support branches to targets out of range;
593 relaxation of R_IA64_LTOFF22X and R_IA64_LDXMOV not yet supported. */
596 elf64_ia64_relax_section (abfd
, sec
, link_info
, again
)
599 struct bfd_link_info
*link_info
;
604 struct one_fixup
*next
;
610 Elf_Internal_Shdr
*symtab_hdr
;
611 Elf_Internal_Rela
*internal_relocs
;
612 Elf_Internal_Rela
*free_relocs
;
613 Elf_Internal_Rela
*irel
, *irelend
;
615 bfd_byte
*free_contents
;
616 Elf64_External_Sym
*extsyms
;
617 Elf64_External_Sym
*free_extsyms
;
618 struct elf64_ia64_link_hash_table
*ia64_info
;
619 struct one_fixup
*fixups
= NULL
;
620 boolean changed_contents
= false;
621 boolean changed_relocs
= false;
623 /* Assume we're not going to change any sizes, and we'll only need
627 /* Nothing to do if there are no relocations. */
628 if ((sec
->flags
& SEC_RELOC
) == 0
629 || sec
->reloc_count
== 0)
632 /* If this is the first time we have been called for this section,
633 initialize the cooked size. */
634 if (sec
->_cooked_size
== 0)
635 sec
->_cooked_size
= sec
->_raw_size
;
637 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
639 /* Load the relocations for this section. */
640 internal_relocs
= (_bfd_elf64_link_read_relocs
641 (abfd
, sec
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
642 link_info
->keep_memory
));
643 if (internal_relocs
== NULL
)
646 if (! link_info
->keep_memory
)
647 free_relocs
= internal_relocs
;
649 ia64_info
= elf64_ia64_hash_table (link_info
);
650 irelend
= internal_relocs
+ sec
->reloc_count
;
652 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
653 if (ELF64_R_TYPE (irel
->r_info
) == (int) R_IA64_PCREL21B
)
656 /* No branch-type relocations. */
659 if (free_relocs
!= NULL
)
664 /* Get the section contents. */
665 free_contents
= NULL
;
666 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
667 contents
= elf_section_data (sec
)->this_hdr
.contents
;
670 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
671 if (contents
== NULL
)
673 free_contents
= contents
;
675 if (! bfd_get_section_contents (abfd
, sec
, contents
,
676 (file_ptr
) 0, sec
->_raw_size
))
680 /* Read this BFD's symbols. */
682 if (symtab_hdr
->contents
!= NULL
)
683 extsyms
= (Elf64_External_Sym
*) symtab_hdr
->contents
;
686 extsyms
= (Elf64_External_Sym
*) bfd_malloc (symtab_hdr
->sh_size
);
689 free_extsyms
= extsyms
;
690 if (bfd_seek (abfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
691 || (bfd_read (extsyms
, 1, symtab_hdr
->sh_size
, abfd
)
692 != symtab_hdr
->sh_size
))
696 for (; irel
< irelend
; irel
++)
698 bfd_vma symaddr
, reladdr
, trampoff
, toff
, roff
;
699 Elf_Internal_Sym isym
;
703 if (ELF64_R_TYPE (irel
->r_info
) != (int) R_IA64_PCREL21B
)
706 /* Get the value of the symbol referred to by the reloc. */
707 if (ELF64_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
709 /* A local symbol. */
710 bfd_elf64_swap_symbol_in (abfd
,
711 extsyms
+ ELF64_R_SYM (irel
->r_info
),
713 if (isym
.st_shndx
== SHN_UNDEF
)
714 continue; /* We can't do anthing with undefined symbols. */
715 else if (isym
.st_shndx
== SHN_ABS
)
716 tsec
= bfd_abs_section_ptr
;
717 else if (isym
.st_shndx
== SHN_COMMON
)
718 tsec
= bfd_com_section_ptr
;
719 else if (isym
.st_shndx
> 0 && isym
.st_shndx
< SHN_LORESERVE
)
720 tsec
= bfd_section_from_elf_index (abfd
, isym
.st_shndx
);
722 continue; /* who knows. */
724 toff
= isym
.st_value
;
729 struct elf_link_hash_entry
*h
;
730 struct elf64_ia64_dyn_sym_info
*dyn_i
;
732 indx
= ELF64_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
733 h
= elf_sym_hashes (abfd
)[indx
];
734 BFD_ASSERT (h
!= NULL
);
736 while (h
->root
.type
== bfd_link_hash_indirect
737 || h
->root
.type
== bfd_link_hash_warning
)
738 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
740 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, irel
, false);
742 /* For branches to dynamic symbols, we're interested instead
743 in a branch to the PLT entry. */
744 if (dyn_i
&& dyn_i
->want_plt2
)
746 tsec
= ia64_info
->plt_sec
;
747 toff
= dyn_i
->plt2_offset
;
751 /* We can't do anthing with undefined symbols. */
752 if (h
->root
.type
== bfd_link_hash_undefined
753 || h
->root
.type
== bfd_link_hash_undefweak
)
756 tsec
= h
->root
.u
.def
.section
;
757 toff
= h
->root
.u
.def
.value
;
761 symaddr
= (tsec
->output_section
->vma
762 + tsec
->output_offset
766 roff
= irel
->r_offset
;
767 reladdr
= (sec
->output_section
->vma
771 /* If the branch is in range, no need to do anything. */
772 if ((bfd_signed_vma
) (symaddr
- reladdr
) >= -0x1000000
773 && (bfd_signed_vma
) (symaddr
- reladdr
) <= 0x0FFFFF0)
776 /* If the branch and target are in the same section, you've
777 got one honking big section and we can't help you. You'll
778 get an error message later. */
782 /* Look for an existing fixup to this address. */
783 for (f
= fixups
; f
; f
= f
->next
)
784 if (f
->tsec
== tsec
&& f
->toff
== toff
)
789 /* Two alternatives: If it's a branch to a PLT entry, we can
790 make a copy of the FULL_PLT entry. Otherwise, we'll have
791 to use a `brl' insn to get where we're going. */
795 if (tsec
== ia64_info
->plt_sec
)
796 size
= sizeof (plt_full_entry
);
800 size
= sizeof (oor_brl
);
802 size
= sizeof (oor_ip
);
806 /* Resize the current section to make room for the new branch. */
807 trampoff
= (sec
->_cooked_size
+ 15) & -16;
808 contents
= (bfd_byte
*) bfd_realloc (contents
, trampoff
+ size
);
809 if (contents
== NULL
)
811 sec
->_cooked_size
= trampoff
+ size
;
813 if (tsec
== ia64_info
->plt_sec
)
815 memcpy (contents
+ trampoff
, plt_full_entry
, size
);
817 /* Hijack the old relocation for use as the PLTOFF reloc. */
818 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
820 irel
->r_offset
= trampoff
;
825 memcpy (contents
+ trampoff
, oor_brl
, size
);
826 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
828 irel
->r_offset
= trampoff
+ 2;
830 memcpy (contents
+ trampoff
, oor_ip
, size
);
831 irel
->r_info
= ELF64_R_INFO (ELF64_R_SYM (irel
->r_info
),
833 irel
->r_addend
-= 16;
834 irel
->r_offset
= trampoff
+ 2;
838 /* Record the fixup so we don't do it again this section. */
839 f
= (struct one_fixup
*) bfd_malloc (sizeof (*f
));
843 f
->trampoff
= trampoff
;
848 /* Nop out the reloc, since we're finalizing things here. */
849 irel
->r_info
= ELF64_R_INFO (0, R_IA64_NONE
);
852 /* Fix up the existing branch to hit the trampoline. Hope like
853 hell this doesn't overflow too. */
854 if (elf64_ia64_install_value (abfd
, contents
+ roff
,
855 f
->trampoff
- (roff
& -4),
856 R_IA64_PCREL21B
) != bfd_reloc_ok
)
859 changed_contents
= true;
860 changed_relocs
= true;
863 /* Clean up and go home. */
866 struct one_fixup
*f
= fixups
;
867 fixups
= fixups
->next
;
872 elf_section_data (sec
)->relocs
= internal_relocs
;
873 else if (free_relocs
!= NULL
)
876 if (changed_contents
)
877 elf_section_data (sec
)->this_hdr
.contents
= contents
;
878 else if (free_contents
!= NULL
)
880 if (! link_info
->keep_memory
)
881 free (free_contents
);
884 /* Cache the section contents for elf_link_input_bfd. */
885 elf_section_data (sec
)->this_hdr
.contents
= contents
;
889 if (free_extsyms
!= NULL
)
891 if (! link_info
->keep_memory
)
895 /* Cache the symbols for elf_link_input_bfd. */
896 symtab_hdr
->contents
= extsyms
;
900 *again
= changed_contents
|| changed_relocs
;
904 if (free_relocs
!= NULL
)
906 if (free_contents
!= NULL
)
907 free (free_contents
);
908 if (free_extsyms
!= NULL
)
913 /* Handle an IA-64 specific section when reading an object file. This
914 is called when elfcode.h finds a section with an unknown type. */
917 elf64_ia64_section_from_shdr (abfd
, hdr
, name
)
919 Elf64_Internal_Shdr
*hdr
;
924 /* There ought to be a place to keep ELF backend specific flags, but
925 at the moment there isn't one. We just keep track of the
926 sections by their name, instead. Fortunately, the ABI gives
927 suggested names for all the MIPS specific sections, so we will
928 probably get away with this. */
929 switch (hdr
->sh_type
)
931 case SHT_IA_64_UNWIND
:
932 if (strcmp (name
, ELF_STRING_ia64_unwind
) != 0)
937 if (strcmp (name
, ELF_STRING_ia64_archext
) != 0)
945 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
947 newsect
= hdr
->bfd_section
;
952 /* Convert IA-64 specific section flags to bfd internal section flags. */
954 /* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
958 elf64_ia64_section_flags (flags
, hdr
)
960 Elf64_Internal_Shdr
*hdr
;
962 if (hdr
->sh_flags
& SHF_IA_64_SHORT
)
963 *flags
|= SEC_SMALL_DATA
;
968 /* Set the correct type for an IA-64 ELF section. We do this by the
969 section name, which is a hack, but ought to work. */
972 elf64_ia64_fake_sections (abfd
, hdr
, sec
)
974 Elf64_Internal_Shdr
*hdr
;
977 register const char *name
;
979 name
= bfd_get_section_name (abfd
, sec
);
981 if (strcmp (name
, ELF_STRING_ia64_unwind
) == 0)
982 hdr
->sh_type
= SHT_IA_64_UNWIND
;
983 else if (strcmp (name
, ELF_STRING_ia64_archext
) == 0)
984 hdr
->sh_type
= SHT_IA_64_EXT
;
985 else if (strcmp (name
, ".reloc") == 0)
987 * This is an ugly, but unfortunately necessary hack that is
988 * needed when producing EFI binaries on IA-64. It tells
989 * elf.c:elf_fake_sections() not to consider ".reloc" as a section
990 * containing ELF relocation info. We need this hack in order to
991 * be able to generate ELF binaries that can be translated into
992 * EFI applications (which are essentially COFF objects). Those
993 * files contain a COFF ".reloc" section inside an ELF64 object,
994 * which would normally cause BFD to segfault because it would
995 * attempt to interpret this section as containing relocation
996 * entries for section "oc". With this hack enabled, ".reloc"
997 * will be treated as a normal data section, which will avoid the
998 * segfault. However, you won't be able to create an ELF64 binary
999 * with a section named "oc" that needs relocations, but that's
1000 * the kind of ugly side-effects you get when detecting section
1001 * types based on their names... In practice, this limitation is
1004 hdr
->sh_type
= SHT_PROGBITS
;
1006 if (sec
->flags
& SEC_SMALL_DATA
)
1007 hdr
->sh_flags
|= SHF_IA_64_SHORT
;
1012 /* Hook called by the linker routine which adds symbols from an object
1013 file. We use it to put .comm items in .sbss, and not .bss. */
1016 elf64_ia64_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
1018 struct bfd_link_info
*info
;
1019 const Elf_Internal_Sym
*sym
;
1025 if (sym
->st_shndx
== SHN_COMMON
1026 && !info
->relocateable
1027 && sym
->st_size
<= bfd_get_gp_size (abfd
))
1029 /* Common symbols less than or equal to -G nn bytes are
1030 automatically put into .sbss. */
1032 asection
*scomm
= bfd_get_section_by_name (abfd
, ".scommon");
1036 scomm
= bfd_make_section (abfd
, ".scommon");
1038 || !bfd_set_section_flags (abfd
, scomm
, (SEC_ALLOC
1040 | SEC_LINKER_CREATED
)))
1045 *valp
= sym
->st_size
;
1051 /* Return the number of additional phdrs we will need. */
1054 elf64_ia64_additional_program_headers (abfd
)
1060 /* See if we need a PT_IA_64_ARCHEXT segment. */
1061 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_archext
);
1062 if (s
&& (s
->flags
& SEC_LOAD
))
1065 /* See if we need a PT_IA_64_UNWIND segment. */
1066 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_unwind
);
1067 if (s
&& (s
->flags
& SEC_LOAD
))
1074 elf64_ia64_modify_segment_map (abfd
)
1077 struct elf_segment_map
*m
, **pm
;
1080 /* If we need a PT_IA_64_ARCHEXT segment, it must come before
1081 all PT_LOAD segments. */
1082 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_archext
);
1083 if (s
&& (s
->flags
& SEC_LOAD
))
1085 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1086 if (m
->p_type
== PT_IA_64_ARCHEXT
)
1090 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, sizeof *m
);
1094 m
->p_type
= PT_IA_64_ARCHEXT
;
1098 /* We want to put it after the PHDR and INTERP segments. */
1099 pm
= &elf_tdata (abfd
)->segment_map
;
1101 && ((*pm
)->p_type
== PT_PHDR
1102 || (*pm
)->p_type
== PT_INTERP
))
1110 /* Install the PT_IA_64_UNWIND segment, if needed. */
1111 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_unwind
);
1112 if (s
&& (s
->flags
& SEC_LOAD
))
1114 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1115 if (m
->p_type
== PT_IA_64_UNWIND
)
1119 m
= (struct elf_segment_map
*) bfd_zalloc (abfd
, sizeof *m
);
1123 m
->p_type
= PT_IA_64_UNWIND
;
1128 /* We want to put it last. */
1129 pm
= &elf_tdata (abfd
)->segment_map
;
1136 /* Turn on PF_IA_64_NORECOV if needed. This involves traversing all of
1137 the input sections for each output section in the segment and testing
1138 for SHF_IA_64_NORECOV on each. */
1139 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1140 if (m
->p_type
== PT_LOAD
)
1143 for (i
= m
->count
- 1; i
>= 0; --i
)
1145 struct bfd_link_order
*order
= m
->sections
[i
]->link_order_head
;
1148 if (order
->type
== bfd_indirect_link_order
)
1150 asection
*is
= order
->u
.indirect
.section
;
1151 bfd_vma flags
= elf_section_data(is
)->this_hdr
.sh_flags
;
1152 if (flags
& SHF_IA_64_NORECOV
)
1154 m
->p_flags
|= PF_IA_64_NORECOV
;
1158 order
= order
->next
;
1168 /* According to the Tahoe assembler spec, all labels starting with a
1172 elf64_ia64_is_local_label_name (abfd
, name
)
1176 return name
[0] == '.';
1179 /* Should we do dynamic things to this symbol? */
1182 elf64_ia64_dynamic_symbol_p (h
, info
)
1183 struct elf_link_hash_entry
*h
;
1184 struct bfd_link_info
*info
;
1189 while (h
->root
.type
== bfd_link_hash_indirect
1190 || h
->root
.type
== bfd_link_hash_warning
)
1191 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1193 if (h
->dynindx
== -1)
1196 if (h
->root
.type
== bfd_link_hash_undefweak
1197 || h
->root
.type
== bfd_link_hash_defweak
)
1200 if ((info
->shared
&& !info
->symbolic
)
1201 || ((h
->elf_link_hash_flags
1202 & (ELF_LINK_HASH_DEF_DYNAMIC
| ELF_LINK_HASH_REF_REGULAR
))
1203 == (ELF_LINK_HASH_DEF_DYNAMIC
| ELF_LINK_HASH_REF_REGULAR
)))
1210 elf64_ia64_local_hash_table_init (ht
, abfd
, new)
1211 struct elf64_ia64_local_hash_table
*ht
;
1213 new_hash_entry_func
new;
1215 memset (ht
, 0, sizeof(*ht
));
1216 return bfd_hash_table_init (&ht
->root
, new);
1219 static struct bfd_hash_entry
*
1220 elf64_ia64_new_loc_hash_entry (entry
, table
, string
)
1221 struct bfd_hash_entry
*entry
;
1222 struct bfd_hash_table
*table
;
1225 struct elf64_ia64_local_hash_entry
*ret
;
1226 ret
= (struct elf64_ia64_local_hash_entry
*) entry
;
1228 /* Allocate the structure if it has not already been allocated by a
1231 ret
= bfd_hash_allocate (table
, sizeof (*ret
));
1236 /* Initialize our local data. All zeros, and definitely easier
1237 than setting a handful of bit fields. */
1238 memset (ret
, 0, sizeof(*ret
));
1240 /* Call the allocation method of the superclass. */
1241 ret
= ((struct elf64_ia64_local_hash_entry
*)
1242 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
1244 return (struct bfd_hash_entry
*) ret
;
1247 static struct bfd_hash_entry
*
1248 elf64_ia64_new_elf_hash_entry (entry
, table
, string
)
1249 struct bfd_hash_entry
*entry
;
1250 struct bfd_hash_table
*table
;
1253 struct elf64_ia64_link_hash_entry
*ret
;
1254 ret
= (struct elf64_ia64_link_hash_entry
*) entry
;
1256 /* Allocate the structure if it has not already been allocated by a
1259 ret
= bfd_hash_allocate (table
, sizeof (*ret
));
1264 /* Initialize our local data. All zeros, and definitely easier
1265 than setting a handful of bit fields. */
1266 memset (ret
, 0, sizeof(*ret
));
1268 /* Call the allocation method of the superclass. */
1269 ret
= ((struct elf64_ia64_link_hash_entry
*)
1270 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
1273 return (struct bfd_hash_entry
*) ret
;
1277 elf64_ia64_hash_copy_indirect (xdir
, xind
)
1278 struct elf_link_hash_entry
*xdir
, *xind
;
1280 struct elf64_ia64_link_hash_entry
*dir
, *ind
;
1282 dir
= (struct elf64_ia64_link_hash_entry
*)xdir
;
1283 ind
= (struct elf64_ia64_link_hash_entry
*)xind
;
1285 /* Copy down any references that we may have already seen to the
1286 symbol which just became indirect. */
1288 dir
->root
.elf_link_hash_flags
|=
1289 (ind
->root
.elf_link_hash_flags
1290 & (ELF_LINK_HASH_REF_DYNAMIC
1291 | ELF_LINK_HASH_REF_REGULAR
1292 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
));
1294 /* Copy over the got and plt data. This would have been done
1297 if (dir
->info
== NULL
)
1299 struct elf64_ia64_dyn_sym_info
*dyn_i
;
1301 dir
->info
= dyn_i
= ind
->info
;
1304 /* Fix up the dyn_sym_info pointers to the global symbol. */
1305 for (; dyn_i
; dyn_i
= dyn_i
->next
)
1306 dyn_i
->h
= &dir
->root
;
1308 BFD_ASSERT (ind
->info
== NULL
);
1310 /* Copy over the dynindx. */
1312 if (dir
->root
.dynindx
== -1)
1314 dir
->root
.dynindx
= ind
->root
.dynindx
;
1315 dir
->root
.dynstr_index
= ind
->root
.dynstr_index
;
1316 ind
->root
.dynindx
= -1;
1317 ind
->root
.dynstr_index
= 0;
1319 BFD_ASSERT (ind
->root
.dynindx
== -1);
1323 elf64_ia64_hash_hide_symbol (info
, xh
)
1324 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1325 struct elf_link_hash_entry
*xh
;
1327 struct elf64_ia64_link_hash_entry
*h
;
1328 struct elf64_ia64_dyn_sym_info
*dyn_i
;
1330 h
= (struct elf64_ia64_link_hash_entry
*)xh
;
1332 h
->root
.elf_link_hash_flags
&= ~ELF_LINK_HASH_NEEDS_PLT
;
1333 h
->root
.dynindx
= -1;
1335 for (dyn_i
= h
->info
; dyn_i
; dyn_i
= dyn_i
->next
)
1336 dyn_i
->want_plt2
= 0;
1339 /* Create the derived linker hash table. The IA-64 ELF port uses this
1340 derived hash table to keep information specific to the IA-64 ElF
1341 linker (without using static variables). */
1343 static struct bfd_link_hash_table
*
1344 elf64_ia64_hash_table_create (abfd
)
1347 struct elf64_ia64_link_hash_table
*ret
;
1349 ret
= bfd_alloc (abfd
, sizeof (*ret
));
1352 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
1353 elf64_ia64_new_elf_hash_entry
))
1355 bfd_release (abfd
, ret
);
1359 if (!elf64_ia64_local_hash_table_init (&ret
->loc_hash_table
, abfd
,
1360 elf64_ia64_new_loc_hash_entry
))
1362 return &ret
->root
.root
;
1365 /* Look up an entry in a Alpha ELF linker hash table. */
1367 static INLINE
struct elf64_ia64_local_hash_entry
*
1368 elf64_ia64_local_hash_lookup(table
, string
, create
, copy
)
1369 struct elf64_ia64_local_hash_table
*table
;
1371 boolean create
, copy
;
1373 return ((struct elf64_ia64_local_hash_entry
*)
1374 bfd_hash_lookup (&table
->root
, string
, create
, copy
));
1377 /* Traverse both local and global hash tables. */
1379 struct elf64_ia64_dyn_sym_traverse_data
1381 boolean (*func
) PARAMS ((struct elf64_ia64_dyn_sym_info
*, PTR
));
1386 elf64_ia64_global_dyn_sym_thunk (xentry
, xdata
)
1387 struct bfd_hash_entry
*xentry
;
1390 struct elf64_ia64_link_hash_entry
*entry
1391 = (struct elf64_ia64_link_hash_entry
*) xentry
;
1392 struct elf64_ia64_dyn_sym_traverse_data
*data
1393 = (struct elf64_ia64_dyn_sym_traverse_data
*) xdata
;
1394 struct elf64_ia64_dyn_sym_info
*dyn_i
;
1396 for (dyn_i
= entry
->info
; dyn_i
; dyn_i
= dyn_i
->next
)
1397 if (! (*data
->func
) (dyn_i
, data
->data
))
1403 elf64_ia64_local_dyn_sym_thunk (xentry
, xdata
)
1404 struct bfd_hash_entry
*xentry
;
1407 struct elf64_ia64_local_hash_entry
*entry
1408 = (struct elf64_ia64_local_hash_entry
*) xentry
;
1409 struct elf64_ia64_dyn_sym_traverse_data
*data
1410 = (struct elf64_ia64_dyn_sym_traverse_data
*) xdata
;
1411 struct elf64_ia64_dyn_sym_info
*dyn_i
;
1413 for (dyn_i
= entry
->info
; dyn_i
; dyn_i
= dyn_i
->next
)
1414 if (! (*data
->func
) (dyn_i
, data
->data
))
1420 elf64_ia64_dyn_sym_traverse (ia64_info
, func
, data
)
1421 struct elf64_ia64_link_hash_table
*ia64_info
;
1422 boolean (*func
) PARAMS ((struct elf64_ia64_dyn_sym_info
*, PTR
));
1425 struct elf64_ia64_dyn_sym_traverse_data xdata
;
1430 elf_link_hash_traverse (&ia64_info
->root
,
1431 elf64_ia64_global_dyn_sym_thunk
, &xdata
);
1432 bfd_hash_traverse (&ia64_info
->loc_hash_table
.root
,
1433 elf64_ia64_local_dyn_sym_thunk
, &xdata
);
1437 elf64_ia64_create_dynamic_sections (abfd
, info
)
1439 struct bfd_link_info
*info
;
1441 struct elf64_ia64_link_hash_table
*ia64_info
;
1442 struct elf_link_hash_entry
*h
;
1445 if (! _bfd_elf_create_dynamic_sections (abfd
, info
))
1448 ia64_info
= elf64_ia64_hash_table (info
);
1450 ia64_info
->plt_sec
= bfd_get_section_by_name (abfd
, ".plt");
1451 ia64_info
->got_sec
= bfd_get_section_by_name (abfd
, ".got");
1454 flagword flags
= bfd_get_section_flags (abfd
, ia64_info
->got_sec
);
1455 bfd_set_section_flags (abfd
, ia64_info
->got_sec
, SEC_SMALL_DATA
| flags
);
1458 if (!get_pltoff (abfd
, info
, ia64_info
))
1461 s
= bfd_make_section(abfd
, ".rela.IA_64.pltoff");
1463 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
1466 | SEC_LINKER_CREATED
1468 || !bfd_set_section_alignment (abfd
, s
, 3))
1470 ia64_info
->rel_pltoff_sec
= s
;
1472 s
= bfd_make_section(abfd
, ".rela.got");
1474 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
1477 | SEC_LINKER_CREATED
1479 || !bfd_set_section_alignment (abfd
, s
, 3))
1481 ia64_info
->rel_got_sec
= s
;
1486 /* Find and/or create a descriptor for dynamic symbol info. This will
1487 vary based on global or local symbol, and the addend to the reloc. */
1489 static struct elf64_ia64_dyn_sym_info
*
1490 get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, create
)
1491 struct elf64_ia64_link_hash_table
*ia64_info
;
1492 struct elf_link_hash_entry
*h
;
1494 const Elf_Internal_Rela
*rel
;
1497 struct elf64_ia64_dyn_sym_info
**pp
;
1498 struct elf64_ia64_dyn_sym_info
*dyn_i
;
1499 bfd_vma addend
= rel
? rel
->r_addend
: 0;
1502 pp
= &((struct elf64_ia64_link_hash_entry
*)h
)->info
;
1505 struct elf64_ia64_local_hash_entry
*loc_h
;
1509 /* Construct a string for use in the elf64_ia64_local_hash_table.
1510 The name describes what was once anonymous memory. */
1512 len
= sizeof(void*)*2 + 1 + sizeof(bfd_vma
)*4 + 1 + 1;
1513 len
+= 10; /* %p slop */
1515 addr_name
= alloca (len
);
1516 sprintf (addr_name
, "%p:%lx", abfd
, ELF64_R_SYM (rel
->r_info
));
1518 /* Collect the canonical entry data for this address. */
1519 loc_h
= elf64_ia64_local_hash_lookup (&ia64_info
->loc_hash_table
,
1520 addr_name
, create
, create
);
1526 for (dyn_i
= *pp
; dyn_i
&& dyn_i
->addend
!= addend
; dyn_i
= *pp
)
1529 if (dyn_i
== NULL
&& create
)
1531 dyn_i
= (struct elf64_ia64_dyn_sym_info
*)
1532 bfd_zalloc (abfd
, sizeof *dyn_i
);
1534 dyn_i
->addend
= addend
;
1541 get_got (abfd
, info
, ia64_info
)
1543 struct bfd_link_info
*info
;
1544 struct elf64_ia64_link_hash_table
*ia64_info
;
1546 asection
*got
, *srel
;
1549 got
= ia64_info
->got_sec
;
1554 dynobj
= ia64_info
->root
.dynobj
;
1556 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1557 if (!_bfd_elf_create_got_section (dynobj
, info
))
1560 got
= bfd_get_section_by_name (dynobj
, ".got");
1562 ia64_info
->got_sec
= got
;
1564 flags
= bfd_get_section_flags (abfd
, got
);
1565 bfd_set_section_flags (abfd
, got
, SEC_SMALL_DATA
| flags
);
1571 /* Create function descriptor section (.opd). This section is called .opd
1572 because it contains "official prodecure descriptors". The "official"
1573 refers to the fact that these descriptors are used when taking the address
1574 of a procedure, thus ensuring a unique address for each procedure. */
1577 get_fptr (abfd
, info
, ia64_info
)
1579 struct bfd_link_info
*info
;
1580 struct elf64_ia64_link_hash_table
*ia64_info
;
1585 fptr
= ia64_info
->fptr_sec
;
1588 dynobj
= ia64_info
->root
.dynobj
;
1590 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1592 fptr
= bfd_make_section (dynobj
, ".opd");
1594 || !bfd_set_section_flags (dynobj
, fptr
,
1600 | SEC_LINKER_CREATED
))
1601 || !bfd_set_section_alignment (abfd
, fptr
, 4))
1607 ia64_info
->fptr_sec
= fptr
;
1614 get_pltoff (abfd
, info
, ia64_info
)
1616 struct bfd_link_info
*info
;
1617 struct elf64_ia64_link_hash_table
*ia64_info
;
1622 pltoff
= ia64_info
->pltoff_sec
;
1625 dynobj
= ia64_info
->root
.dynobj
;
1627 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1629 pltoff
= bfd_make_section (dynobj
, ELF_STRING_ia64_pltoff
);
1631 || !bfd_set_section_flags (dynobj
, pltoff
,
1637 | SEC_LINKER_CREATED
))
1638 || !bfd_set_section_alignment (abfd
, pltoff
, 4))
1644 ia64_info
->pltoff_sec
= pltoff
;
1651 get_reloc_section (abfd
, ia64_info
, sec
, create
)
1653 struct elf64_ia64_link_hash_table
*ia64_info
;
1657 const char *srel_name
;
1661 srel_name
= (bfd_elf_string_from_elf_section
1662 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
1663 elf_section_data(sec
)->rel_hdr
.sh_name
));
1664 if (srel_name
== NULL
)
1667 BFD_ASSERT ((strncmp (srel_name
, ".rela", 5) == 0
1668 && strcmp (bfd_get_section_name (abfd
, sec
),
1670 || (strncmp (srel_name
, ".rel", 4) == 0
1671 && strcmp (bfd_get_section_name (abfd
, sec
),
1672 srel_name
+4) == 0));
1674 dynobj
= ia64_info
->root
.dynobj
;
1676 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1678 srel
= bfd_get_section_by_name (dynobj
, srel_name
);
1679 if (srel
== NULL
&& create
)
1681 srel
= bfd_make_section (dynobj
, srel_name
);
1683 || !bfd_set_section_flags (dynobj
, srel
,
1688 | SEC_LINKER_CREATED
1690 || !bfd_set_section_alignment (dynobj
, srel
, 3))
1698 count_dyn_reloc (abfd
, dyn_i
, srel
, type
)
1700 struct elf64_ia64_dyn_sym_info
*dyn_i
;
1704 struct elf64_ia64_dyn_reloc_entry
*rent
;
1706 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
1707 if (rent
->srel
== srel
&& rent
->type
== type
)
1712 rent
= (struct elf64_ia64_dyn_reloc_entry
*)
1713 bfd_alloc (abfd
, sizeof (*rent
));
1717 rent
->next
= dyn_i
->reloc_entries
;
1721 dyn_i
->reloc_entries
= rent
;
1729 elf64_ia64_check_relocs (abfd
, info
, sec
, relocs
)
1731 struct bfd_link_info
*info
;
1733 const Elf_Internal_Rela
*relocs
;
1735 struct elf64_ia64_link_hash_table
*ia64_info
;
1736 const Elf_Internal_Rela
*relend
;
1737 Elf_Internal_Shdr
*symtab_hdr
;
1738 const Elf_Internal_Rela
*rel
;
1739 asection
*got
, *fptr
, *srel
;
1741 if (info
->relocateable
)
1744 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1745 ia64_info
= elf64_ia64_hash_table (info
);
1747 got
= fptr
= srel
= NULL
;
1749 relend
= relocs
+ sec
->reloc_count
;
1750 for (rel
= relocs
; rel
< relend
; ++rel
)
1759 NEED_LTOFF_FPTR
= 64,
1762 struct elf_link_hash_entry
*h
= NULL
;
1763 unsigned long r_symndx
= ELF64_R_SYM (rel
->r_info
);
1764 struct elf64_ia64_dyn_sym_info
*dyn_i
;
1766 boolean maybe_dynamic
;
1769 if (r_symndx
>= symtab_hdr
->sh_info
)
1771 /* We're dealing with a global symbol -- find its hash entry
1772 and mark it as being referenced. */
1773 long indx
= r_symndx
- symtab_hdr
->sh_info
;
1774 h
= elf_sym_hashes (abfd
)[indx
];
1775 while (h
->root
.type
== bfd_link_hash_indirect
1776 || h
->root
.type
== bfd_link_hash_warning
)
1777 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1779 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
1782 /* We can only get preliminary data on whether a symbol is
1783 locally or externally defined, as not all of the input files
1784 have yet been processed. Do something with what we know, as
1785 this may help reduce memory usage and processing time later. */
1786 maybe_dynamic
= false;
1787 if (h
&& ((info
->shared
&& ! info
->symbolic
)
1788 || ! (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)
1789 || h
->root
.type
== bfd_link_hash_defweak
))
1790 maybe_dynamic
= true;
1793 switch (ELF64_R_TYPE (rel
->r_info
))
1795 case R_IA64_TPREL22
:
1796 case R_IA64_TPREL64MSB
:
1797 case R_IA64_TPREL64LSB
:
1798 case R_IA64_LTOFF_TP22
:
1801 case R_IA64_LTOFF_FPTR22
:
1802 case R_IA64_LTOFF_FPTR64I
:
1803 case R_IA64_LTOFF_FPTR64MSB
:
1804 case R_IA64_LTOFF_FPTR64LSB
:
1805 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
1808 case R_IA64_FPTR64I
:
1809 case R_IA64_FPTR32MSB
:
1810 case R_IA64_FPTR32LSB
:
1811 case R_IA64_FPTR64MSB
:
1812 case R_IA64_FPTR64LSB
:
1813 if (info
->shared
|| h
)
1814 need_entry
= NEED_FPTR
| NEED_DYNREL
;
1816 need_entry
= NEED_FPTR
;
1817 dynrel_type
= R_IA64_FPTR64LSB
;
1820 case R_IA64_LTOFF22
:
1821 case R_IA64_LTOFF22X
:
1822 case R_IA64_LTOFF64I
:
1823 need_entry
= NEED_GOT
;
1826 case R_IA64_PLTOFF22
:
1827 case R_IA64_PLTOFF64I
:
1828 case R_IA64_PLTOFF64MSB
:
1829 case R_IA64_PLTOFF64LSB
:
1830 need_entry
= NEED_PLTOFF
;
1834 need_entry
|= NEED_MIN_PLT
;
1838 (*info
->callbacks
->warning
)
1839 (info
, _("@pltoff reloc against local symbol"), 0,
1844 case R_IA64_PCREL21B
:
1845 case R_IA64_PCREL60B
:
1846 /* Depending on where this symbol is defined, we may or may not
1847 need a full plt entry. Only skip if we know we'll not need
1848 the entry -- static or symbolic, and the symbol definition
1849 has already been seen. */
1850 if (maybe_dynamic
&& rel
->r_addend
== 0)
1851 need_entry
= NEED_FULL_PLT
;
1857 case R_IA64_DIR32MSB
:
1858 case R_IA64_DIR32LSB
:
1859 case R_IA64_DIR64MSB
:
1860 case R_IA64_DIR64LSB
:
1861 /* Shared objects will always need at least a REL relocation. */
1862 if (info
->shared
|| maybe_dynamic
)
1863 need_entry
= NEED_DYNREL
;
1864 dynrel_type
= R_IA64_DIR64LSB
;
1867 case R_IA64_PCREL22
:
1868 case R_IA64_PCREL64I
:
1869 case R_IA64_PCREL32MSB
:
1870 case R_IA64_PCREL32LSB
:
1871 case R_IA64_PCREL64MSB
:
1872 case R_IA64_PCREL64LSB
:
1874 need_entry
= NEED_DYNREL
;
1875 dynrel_type
= R_IA64_PCREL64LSB
;
1882 if ((need_entry
& NEED_FPTR
) != 0
1885 (*info
->callbacks
->warning
)
1886 (info
, _("non-zero addend in @fptr reloc"), 0,
1890 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, true);
1892 /* Record whether or not this is a local symbol. */
1895 /* Create what's needed. */
1896 if (need_entry
& NEED_GOT
)
1900 got
= get_got (abfd
, info
, ia64_info
);
1904 dyn_i
->want_got
= 1;
1906 if (need_entry
& NEED_FPTR
)
1910 fptr
= get_fptr (abfd
, info
, ia64_info
);
1915 /* FPTRs for shared libraries are allocated by the dynamic
1916 linker. Make sure this local symbol will appear in the
1917 dynamic symbol table. */
1918 if (!h
&& info
->shared
)
1920 if (! (_bfd_elf64_link_record_local_dynamic_symbol
1921 (info
, abfd
, r_symndx
)))
1925 dyn_i
->want_fptr
= 1;
1927 if (need_entry
& NEED_LTOFF_FPTR
)
1928 dyn_i
->want_ltoff_fptr
= 1;
1929 if (need_entry
& (NEED_MIN_PLT
| NEED_FULL_PLT
))
1931 if (!ia64_info
->root
.dynobj
)
1932 ia64_info
->root
.dynobj
= abfd
;
1933 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
1934 dyn_i
->want_plt
= 1;
1936 if (need_entry
& NEED_FULL_PLT
)
1937 dyn_i
->want_plt2
= 1;
1938 if (need_entry
& NEED_PLTOFF
)
1939 dyn_i
->want_pltoff
= 1;
1940 if ((need_entry
& NEED_DYNREL
) && (sec
->flags
& SEC_ALLOC
))
1944 srel
= get_reloc_section (abfd
, ia64_info
, sec
, true);
1948 if (!count_dyn_reloc (abfd
, dyn_i
, srel
, dynrel_type
))
1956 struct elf64_ia64_allocate_data
1958 struct bfd_link_info
*info
;
1962 /* For cleanliness, and potentially faster dynamic loading, allocate
1963 external GOT entries first. */
1966 allocate_global_data_got (dyn_i
, data
)
1967 struct elf64_ia64_dyn_sym_info
*dyn_i
;
1970 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*)data
;
1973 && ! dyn_i
->want_fptr
1974 && elf64_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
))
1976 dyn_i
->got_offset
= x
->ofs
;
1982 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
1985 allocate_global_fptr_got (dyn_i
, data
)
1986 struct elf64_ia64_dyn_sym_info
*dyn_i
;
1989 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*)data
;
1993 && elf64_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
))
1995 dyn_i
->got_offset
= x
->ofs
;
2001 /* Lastly, allocate all the GOT entries for local data. */
2004 allocate_local_got (dyn_i
, data
)
2005 struct elf64_ia64_dyn_sym_info
*dyn_i
;
2008 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*)data
;
2011 && ! elf64_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
))
2013 dyn_i
->got_offset
= x
->ofs
;
2019 /* Search for the index of a global symbol in it's defining object file. */
2021 static unsigned long
2022 global_sym_index (h
)
2023 struct elf_link_hash_entry
*h
;
2025 struct elf_link_hash_entry
**p
;
2028 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
2029 || h
->root
.type
== bfd_link_hash_defweak
);
2031 obj
= h
->root
.u
.def
.section
->owner
;
2032 for (p
= elf_sym_hashes (obj
); *p
!= h
; ++p
)
2035 return p
- elf_sym_hashes (obj
) + elf_tdata (obj
)->symtab_hdr
.sh_info
;
2038 /* Allocate function descriptors. We can do these for every function
2039 in a main executable that is not exported. */
2042 allocate_fptr (dyn_i
, data
)
2043 struct elf64_ia64_dyn_sym_info
*dyn_i
;
2046 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*)data
;
2048 if (dyn_i
->want_fptr
)
2050 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2053 while (h
->root
.type
== bfd_link_hash_indirect
2054 || h
->root
.type
== bfd_link_hash_warning
)
2055 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2057 if (x
->info
->shared
)
2059 if (h
&& h
->dynindx
== -1)
2061 BFD_ASSERT ((h
->root
.type
== bfd_link_hash_defined
)
2062 || (h
->root
.type
== bfd_link_hash_defweak
));
2064 if (!_bfd_elf64_link_record_local_dynamic_symbol
2065 (x
->info
, h
->root
.u
.def
.section
->owner
,
2066 global_sym_index (h
)))
2070 dyn_i
->want_fptr
= 0;
2072 else if (h
== NULL
|| h
->dynindx
== -1)
2074 dyn_i
->fptr_offset
= x
->ofs
;
2078 dyn_i
->want_fptr
= 0;
2083 /* Allocate all the minimal PLT entries. */
2086 allocate_plt_entries (dyn_i
, data
)
2087 struct elf64_ia64_dyn_sym_info
*dyn_i
;
2090 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*)data
;
2092 if (dyn_i
->want_plt
)
2094 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2097 while (h
->root
.type
== bfd_link_hash_indirect
2098 || h
->root
.type
== bfd_link_hash_warning
)
2099 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2101 /* ??? Versioned symbols seem to lose ELF_LINK_HASH_NEEDS_PLT. */
2102 if (elf64_ia64_dynamic_symbol_p (h
, x
->info
))
2104 bfd_size_type offset
= x
->ofs
;
2106 offset
= PLT_HEADER_SIZE
;
2107 dyn_i
->plt_offset
= offset
;
2108 x
->ofs
= offset
+ PLT_MIN_ENTRY_SIZE
;
2110 dyn_i
->want_pltoff
= 1;
2114 dyn_i
->want_plt
= 0;
2115 dyn_i
->want_plt2
= 0;
2121 /* Allocate all the full PLT entries. */
2124 allocate_plt2_entries (dyn_i
, data
)
2125 struct elf64_ia64_dyn_sym_info
*dyn_i
;
2128 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*)data
;
2130 if (dyn_i
->want_plt2
)
2132 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2133 bfd_size_type ofs
= x
->ofs
;
2135 dyn_i
->plt2_offset
= ofs
;
2136 x
->ofs
= ofs
+ PLT_FULL_ENTRY_SIZE
;
2138 while (h
->root
.type
== bfd_link_hash_indirect
2139 || h
->root
.type
== bfd_link_hash_warning
)
2140 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2141 dyn_i
->h
->plt
.offset
= ofs
;
2146 /* Allocate all the PLTOFF entries requested by relocations and
2147 plt entries. We can't share space with allocated FPTR entries,
2148 because the latter are not necessarily addressable by the GP.
2149 ??? Relaxation might be able to determine that they are. */
2152 allocate_pltoff_entries (dyn_i
, data
)
2153 struct elf64_ia64_dyn_sym_info
*dyn_i
;
2156 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*)data
;
2158 if (dyn_i
->want_pltoff
)
2160 dyn_i
->pltoff_offset
= x
->ofs
;
2166 /* Allocate dynamic relocations for those symbols that turned out
2170 allocate_dynrel_entries (dyn_i
, data
)
2171 struct elf64_ia64_dyn_sym_info
*dyn_i
;
2174 struct elf64_ia64_allocate_data
*x
= (struct elf64_ia64_allocate_data
*)data
;
2175 struct elf64_ia64_link_hash_table
*ia64_info
;
2176 struct elf64_ia64_dyn_reloc_entry
*rent
;
2177 boolean dynamic_symbol
, shared
;
2179 ia64_info
= elf64_ia64_hash_table (x
->info
);
2180 dynamic_symbol
= elf64_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
);
2181 shared
= x
->info
->shared
;
2183 /* Take care of the normal data relocations. */
2185 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2189 case R_IA64_FPTR64LSB
:
2190 /* Allocate one iff !want_fptr, which by this point will
2191 be true only if we're actually allocating one statically
2192 in the main executable. */
2193 if (dyn_i
->want_fptr
)
2196 case R_IA64_PCREL64LSB
:
2197 if (!dynamic_symbol
)
2200 case R_IA64_DIR64LSB
:
2201 if (!dynamic_symbol
&& !shared
)
2205 rent
->srel
->_raw_size
+= sizeof (Elf64_External_Rela
) * rent
->count
;
2208 /* Take care of the GOT and PLT relocations. */
2210 if (((dynamic_symbol
|| shared
) && dyn_i
->want_got
)
2211 || (dyn_i
->want_ltoff_fptr
&& dyn_i
->h
&& dyn_i
->h
->dynindx
!= -1))
2212 ia64_info
->rel_got_sec
->_raw_size
+= sizeof (Elf64_External_Rela
);
2214 if (dyn_i
->want_pltoff
)
2216 bfd_size_type t
= 0;
2218 /* Dynamic symbols get one IPLT relocation. Local symbols in
2219 shared libraries get two REL relocations. Local symbols in
2220 main applications get nothing. */
2222 t
= sizeof (Elf64_External_Rela
);
2224 t
= 2 * sizeof (Elf64_External_Rela
);
2226 ia64_info
->rel_pltoff_sec
->_raw_size
+= t
;
2233 elf64_ia64_adjust_dynamic_symbol (info
, h
)
2234 struct bfd_link_info
*info
;
2235 struct elf_link_hash_entry
*h
;
2237 /* ??? Undefined symbols with PLT entries should be re-defined
2238 to be the PLT entry. */
2240 /* If this is a weak symbol, and there is a real definition, the
2241 processor independent code will have arranged for us to see the
2242 real definition first, and we can just use the same value. */
2243 if (h
->weakdef
!= NULL
)
2245 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
2246 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
2247 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
2248 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
2252 /* If this is a reference to a symbol defined by a dynamic object which
2253 is not a function, we might allocate the symbol in our .dynbss section
2254 and allocate a COPY dynamic relocation.
2256 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2263 elf64_ia64_size_dynamic_sections (output_bfd
, info
)
2265 struct bfd_link_info
*info
;
2267 struct elf64_ia64_allocate_data data
;
2268 struct elf64_ia64_link_hash_table
*ia64_info
;
2271 boolean reltext
= false;
2272 boolean relplt
= false;
2274 dynobj
= elf_hash_table(info
)->dynobj
;
2275 ia64_info
= elf64_ia64_hash_table (info
);
2276 BFD_ASSERT(dynobj
!= NULL
);
2279 /* Set the contents of the .interp section to the interpreter. */
2280 if (ia64_info
->root
.dynamic_sections_created
2283 sec
= bfd_get_section_by_name (dynobj
, ".interp");
2284 BFD_ASSERT (sec
!= NULL
);
2285 sec
->contents
= (bfd_byte
*) ELF_DYNAMIC_INTERPRETER
;
2286 sec
->_raw_size
= strlen (ELF_DYNAMIC_INTERPRETER
) + 1;
2289 /* DT_INIT and DT_FINI get function descriptors not raw code addresses.
2290 Force their symbols to have pltoff entries so we can use those. */
2291 if (ia64_info
->root
.dynamic_sections_created
)
2293 struct elf_link_hash_entry
*h
;
2294 struct elf64_ia64_dyn_sym_info
*dyn_i
;
2296 if (info
->init_function
2297 && (h
= elf_link_hash_lookup (elf_hash_table (info
),
2298 info
->init_function
, false,
2300 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
2301 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
2303 dyn_i
= get_dyn_sym_info (ia64_info
, h
, output_bfd
, NULL
, true);
2304 dyn_i
->want_pltoff
= 1;
2307 if (info
->fini_function
2308 && (h
= elf_link_hash_lookup (elf_hash_table (info
),
2309 info
->fini_function
, false,
2311 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
2312 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
2314 dyn_i
= get_dyn_sym_info (ia64_info
, h
, output_bfd
, NULL
, true);
2315 dyn_i
->want_pltoff
= 1;
2319 /* Allocate the GOT entries. */
2321 if (ia64_info
->got_sec
)
2324 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_global_data_got
, &data
);
2325 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_global_fptr_got
, &data
);
2326 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_local_got
, &data
);
2327 ia64_info
->got_sec
->_raw_size
= data
.ofs
;
2330 /* Allocate the FPTR entries. */
2332 if (ia64_info
->fptr_sec
)
2335 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_fptr
, &data
);
2336 ia64_info
->fptr_sec
->_raw_size
= data
.ofs
;
2339 /* Now that we've seen all of the input files, we can decide which
2340 symbols need plt entries. Allocate the minimal PLT entries first.
2341 We do this even though dynamic_sections_created may be false, because
2342 this has the side-effect of clearing want_plt and want_plt2. */
2345 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_plt_entries
, &data
);
2347 ia64_info
->minplt_entries
= 0;
2350 ia64_info
->minplt_entries
2351 = (data
.ofs
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
2354 /* Align the pointer for the plt2 entries. */
2355 data
.ofs
= (data
.ofs
+ 31) & -32;
2357 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_plt2_entries
, &data
);
2360 BFD_ASSERT (ia64_info
->root
.dynamic_sections_created
);
2362 ia64_info
->plt_sec
->_raw_size
= data
.ofs
;
2364 /* If we've got a .plt, we need some extra memory for the dynamic
2365 linker. We stuff these in .got.plt. */
2366 sec
= bfd_get_section_by_name (dynobj
, ".got.plt");
2367 sec
->_raw_size
= 8 * PLT_RESERVED_WORDS
;
2370 /* Allocate the PLTOFF entries. */
2372 if (ia64_info
->pltoff_sec
)
2375 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_pltoff_entries
, &data
);
2376 ia64_info
->pltoff_sec
->_raw_size
= data
.ofs
;
2379 if (ia64_info
->root
.dynamic_sections_created
)
2381 /* Allocate space for the dynamic relocations that turned out to be
2384 elf64_ia64_dyn_sym_traverse (ia64_info
, allocate_dynrel_entries
, &data
);
2387 /* We have now determined the sizes of the various dynamic sections.
2388 Allocate memory for them. */
2389 for (sec
= dynobj
->sections
; sec
!= NULL
; sec
= sec
->next
)
2393 if (!(sec
->flags
& SEC_LINKER_CREATED
))
2396 /* If we don't need this section, strip it from the output file.
2397 There were several sections primarily related to dynamic
2398 linking that must be create before the linker maps input
2399 sections to output sections. The linker does that before
2400 bfd_elf_size_dynamic_sections is called, and it is that
2401 function which decides whether anything needs to go into
2404 strip
= (sec
->_raw_size
== 0);
2406 if (sec
== ia64_info
->got_sec
)
2408 else if (sec
== ia64_info
->rel_got_sec
)
2411 ia64_info
->rel_got_sec
= NULL
;
2413 /* We use the reloc_count field as a counter if we need to
2414 copy relocs into the output file. */
2415 sec
->reloc_count
= 0;
2417 else if (sec
== ia64_info
->fptr_sec
)
2420 ia64_info
->fptr_sec
= NULL
;
2422 else if (sec
== ia64_info
->plt_sec
)
2425 ia64_info
->plt_sec
= NULL
;
2427 else if (sec
== ia64_info
->pltoff_sec
)
2430 ia64_info
->pltoff_sec
= NULL
;
2432 else if (sec
== ia64_info
->rel_pltoff_sec
)
2435 ia64_info
->rel_pltoff_sec
= NULL
;
2439 /* We use the reloc_count field as a counter if we need to
2440 copy relocs into the output file. */
2441 sec
->reloc_count
= 0;
2448 /* It's OK to base decisions on the section name, because none
2449 of the dynobj section names depend upon the input files. */
2450 name
= bfd_get_section_name (dynobj
, sec
);
2452 if (strcmp (name
, ".got.plt") == 0)
2454 else if (strncmp (name
, ".rel", 4) == 0)
2458 const char *outname
;
2461 /* If this relocation section applies to a read only
2462 section, then we probably need a DT_TEXTREL entry. */
2463 outname
= bfd_get_section_name (output_bfd
,
2464 sec
->output_section
);
2465 if (outname
[4] == 'a')
2470 target
= bfd_get_section_by_name (output_bfd
, outname
);
2472 && (target
->flags
& SEC_READONLY
) != 0
2473 && (target
->flags
& SEC_ALLOC
) != 0)
2476 /* We use the reloc_count field as a counter if we need to
2477 copy relocs into the output file. */
2478 sec
->reloc_count
= 0;
2486 _bfd_strip_section_from_output (info
, sec
);
2489 /* Allocate memory for the section contents. */
2490 sec
->contents
= (bfd_byte
*) bfd_zalloc(dynobj
, sec
->_raw_size
);
2491 if (sec
->contents
== NULL
&& sec
->_raw_size
!= 0)
2496 if (elf_hash_table (info
)->dynamic_sections_created
)
2498 /* Add some entries to the .dynamic section. We fill in the values
2499 later (in finish_dynamic_sections) but we must add the entries now
2500 so that we get the correct size for the .dynamic section. */
2504 /* The DT_DEBUG entry is filled in by the dynamic linker and used
2506 if (!bfd_elf64_add_dynamic_entry (info
, DT_DEBUG
, 0))
2510 if (! bfd_elf64_add_dynamic_entry (info
, DT_IA_64_PLT_RESERVE
, 0))
2512 if (! bfd_elf64_add_dynamic_entry (info
, DT_PLTGOT
, 0))
2517 if (! bfd_elf64_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2518 || ! bfd_elf64_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
2519 || ! bfd_elf64_add_dynamic_entry (info
, DT_JMPREL
, 0))
2523 if (! bfd_elf64_add_dynamic_entry (info
, DT_RELA
, 0)
2524 || ! bfd_elf64_add_dynamic_entry (info
, DT_RELASZ
, 0)
2525 || ! bfd_elf64_add_dynamic_entry (info
, DT_RELAENT
,
2526 sizeof(Elf64_External_Rela
)))
2531 if (! bfd_elf64_add_dynamic_entry (info
, DT_TEXTREL
, 0))
2533 info
->flags
|= DF_TEXTREL
;
2537 /* ??? Perhaps force __gp local. */
2542 static bfd_reloc_status_type
2543 elf64_ia64_install_value (abfd
, hit_addr
, val
, r_type
)
2547 unsigned int r_type
;
2549 const struct ia64_operand
*op
;
2550 int bigendian
= 0, shift
= 0;
2551 bfd_vma t0
, t1
, insn
, dword
;
2552 enum ia64_opnd opnd
;
2556 opnd
= IA64_OPND_NIL
;
2561 return bfd_reloc_ok
;
2563 /* Instruction relocations. */
2565 case R_IA64_IMM14
: opnd
= IA64_OPND_IMM14
; break;
2567 case R_IA64_PCREL21F
: opnd
= IA64_OPND_TGT25
; break;
2568 case R_IA64_PCREL21M
: opnd
= IA64_OPND_TGT25b
; break;
2569 case R_IA64_PCREL60B
: opnd
= IA64_OPND_TGT64
; break;
2570 case R_IA64_PCREL21B
:
2571 case R_IA64_PCREL21BI
:
2572 opnd
= IA64_OPND_TGT25c
;
2576 case R_IA64_GPREL22
:
2577 case R_IA64_LTOFF22
:
2578 case R_IA64_LTOFF22X
:
2579 case R_IA64_PLTOFF22
:
2580 case R_IA64_PCREL22
:
2581 case R_IA64_LTOFF_FPTR22
:
2582 opnd
= IA64_OPND_IMM22
;
2586 case R_IA64_GPREL64I
:
2587 case R_IA64_LTOFF64I
:
2588 case R_IA64_PLTOFF64I
:
2589 case R_IA64_PCREL64I
:
2590 case R_IA64_FPTR64I
:
2591 case R_IA64_LTOFF_FPTR64I
:
2592 opnd
= IA64_OPND_IMMU64
;
2595 /* Data relocations. */
2597 case R_IA64_DIR32MSB
:
2598 case R_IA64_GPREL32MSB
:
2599 case R_IA64_FPTR32MSB
:
2600 case R_IA64_PCREL32MSB
:
2601 case R_IA64_SEGREL32MSB
:
2602 case R_IA64_SECREL32MSB
:
2603 case R_IA64_LTV32MSB
:
2604 size
= 4; bigendian
= 1;
2607 case R_IA64_DIR32LSB
:
2608 case R_IA64_GPREL32LSB
:
2609 case R_IA64_FPTR32LSB
:
2610 case R_IA64_PCREL32LSB
:
2611 case R_IA64_SEGREL32LSB
:
2612 case R_IA64_SECREL32LSB
:
2613 case R_IA64_LTV32LSB
:
2614 size
= 4; bigendian
= 0;
2617 case R_IA64_DIR64MSB
:
2618 case R_IA64_GPREL64MSB
:
2619 case R_IA64_PLTOFF64MSB
:
2620 case R_IA64_FPTR64MSB
:
2621 case R_IA64_PCREL64MSB
:
2622 case R_IA64_LTOFF_FPTR64MSB
:
2623 case R_IA64_SEGREL64MSB
:
2624 case R_IA64_SECREL64MSB
:
2625 case R_IA64_LTV64MSB
:
2626 size
= 8; bigendian
= 1;
2629 case R_IA64_DIR64LSB
:
2630 case R_IA64_GPREL64LSB
:
2631 case R_IA64_PLTOFF64LSB
:
2632 case R_IA64_FPTR64LSB
:
2633 case R_IA64_PCREL64LSB
:
2634 case R_IA64_LTOFF_FPTR64LSB
:
2635 case R_IA64_SEGREL64LSB
:
2636 case R_IA64_SECREL64LSB
:
2637 case R_IA64_LTV64LSB
:
2638 size
= 8; bigendian
= 0;
2641 /* Unsupported / Dynamic relocations. */
2643 case R_IA64_REL32MSB
:
2644 case R_IA64_REL32LSB
:
2645 case R_IA64_REL64MSB
:
2646 case R_IA64_REL64LSB
:
2648 case R_IA64_IPLTMSB
:
2649 case R_IA64_IPLTLSB
:
2650 case R_IA64_EPLTMSB
:
2651 case R_IA64_EPLTLSB
:
2654 case R_IA64_SEGBASE
:
2656 case R_IA64_TPREL22
:
2657 case R_IA64_TPREL64MSB
:
2658 case R_IA64_TPREL64LSB
:
2659 case R_IA64_LTOFF_TP22
:
2662 return bfd_reloc_notsupported
;
2667 case IA64_OPND_IMMU64
:
2668 hit_addr
-= (long) hit_addr
& 0x3;
2669 t0
= bfd_get_64 (abfd
, hit_addr
);
2670 t1
= bfd_get_64 (abfd
, hit_addr
+ 8);
2672 /* tmpl/s: bits 0.. 5 in t0
2673 slot 0: bits 5..45 in t0
2674 slot 1: bits 46..63 in t0, bits 0..22 in t1
2675 slot 2: bits 23..63 in t1 */
2677 /* First, clear the bits that form the 64 bit constant. */
2678 t0
&= ~(0x3ffffLL
<< 46);
2680 | (( (0x07fLL
<< 13) | (0x1ffLL
<< 27)
2681 | (0x01fLL
<< 22) | (0x001LL
<< 21)
2682 | (0x001LL
<< 36)) << 23));
2684 t0
|= ((val
>> 22) & 0x03ffffLL
) << 46; /* 18 lsbs of imm41 */
2685 t1
|= ((val
>> 40) & 0x7fffffLL
) << 0; /* 23 msbs of imm41 */
2686 t1
|= ( (((val
>> 0) & 0x07f) << 13) /* imm7b */
2687 | (((val
>> 7) & 0x1ff) << 27) /* imm9d */
2688 | (((val
>> 16) & 0x01f) << 22) /* imm5c */
2689 | (((val
>> 21) & 0x001) << 21) /* ic */
2690 | (((val
>> 63) & 0x001) << 36)) << 23; /* i */
2692 bfd_put_64 (abfd
, t0
, hit_addr
);
2693 bfd_put_64 (abfd
, t1
, hit_addr
+ 8);
2696 case IA64_OPND_TGT64
:
2697 hit_addr
-= (long) hit_addr
& 0x3;
2698 t0
= bfd_get_64 (abfd
, hit_addr
);
2699 t1
= bfd_get_64 (abfd
, hit_addr
+ 8);
2701 /* tmpl/s: bits 0.. 5 in t0
2702 slot 0: bits 5..45 in t0
2703 slot 1: bits 46..63 in t0, bits 0..22 in t1
2704 slot 2: bits 23..63 in t1 */
2706 /* First, clear the bits that form the 64 bit constant. */
2707 t0
&= ~(0x3ffffLL
<< 46);
2709 | ((1LL << 36 | 0xfffffLL
<< 13) << 23));
2712 t0
|= ((val
>> 20) & 0xffffLL
) << 2 << 46; /* 16 lsbs of imm39 */
2713 t1
|= ((val
>> 36) & 0x7fffffLL
) << 0; /* 23 msbs of imm39 */
2714 t1
|= ((((val
>> 0) & 0xfffffLL
) << 13) /* imm20b */
2715 | (((val
>> 59) & 0x1LL
) << 36)) << 23; /* i */
2717 bfd_put_64 (abfd
, t0
, hit_addr
);
2718 bfd_put_64 (abfd
, t1
, hit_addr
+ 8);
2722 switch ((long) hit_addr
& 0x3)
2724 case 0: shift
= 5; break;
2725 case 1: shift
= 14; hit_addr
+= 3; break;
2726 case 2: shift
= 23; hit_addr
+= 6; break;
2727 case 3: return bfd_reloc_notsupported
; /* shouldn't happen... */
2729 dword
= bfd_get_64 (abfd
, hit_addr
);
2730 insn
= (dword
>> shift
) & 0x1ffffffffffLL
;
2732 op
= elf64_ia64_operands
+ opnd
;
2733 err
= (*op
->insert
) (op
, val
, &insn
);
2735 return bfd_reloc_overflow
;
2737 dword
&= ~(0x1ffffffffffLL
<< shift
);
2738 dword
|= (insn
<< shift
);
2739 bfd_put_64 (abfd
, dword
, hit_addr
);
2743 /* A data relocation. */
2746 bfd_putb32 (val
, hit_addr
);
2748 bfd_putb64 (val
, hit_addr
);
2751 bfd_putl32 (val
, hit_addr
);
2753 bfd_putl64 (val
, hit_addr
);
2757 return bfd_reloc_ok
;
2761 elf64_ia64_install_dyn_reloc (abfd
, info
, sec
, srel
, offset
, type
,
2764 struct bfd_link_info
*info
;
2772 Elf_Internal_Rela outrel
;
2774 outrel
.r_offset
= (sec
->output_section
->vma
2775 + sec
->output_offset
2778 BFD_ASSERT (dynindx
!= -1);
2779 outrel
.r_info
= ELF64_R_INFO (dynindx
, type
);
2780 outrel
.r_addend
= addend
;
2782 if (elf_section_data (sec
)->stab_info
!= NULL
)
2784 /* This may be NULL for linker-generated relocations, as it is
2785 inconvenient to pass all the bits around. And this shouldn't
2787 BFD_ASSERT (info
!= NULL
);
2789 offset
= (_bfd_stab_section_offset
2790 (abfd
, &elf_hash_table (info
)->stab_info
, sec
,
2791 &elf_section_data (sec
)->stab_info
, offset
));
2792 if (offset
== (bfd_vma
) -1)
2794 /* Run for the hills. We shouldn't be outputting a relocation
2795 for this. So do what everyone else does and output a no-op. */
2796 outrel
.r_info
= ELF64_R_INFO (0, R_IA64_NONE
);
2797 outrel
.r_addend
= 0;
2800 outrel
.r_offset
= offset
;
2803 bfd_elf64_swap_reloca_out (abfd
, &outrel
,
2804 ((Elf64_External_Rela
*) srel
->contents
2805 + srel
->reloc_count
++));
2806 BFD_ASSERT (sizeof(Elf64_External_Rela
) * srel
->reloc_count
2807 <= srel
->_cooked_size
);
2810 /* Store an entry for target address TARGET_ADDR in the linkage table
2811 and return the gp-relative address of the linkage table entry. */
2814 set_got_entry (abfd
, info
, dyn_i
, dynindx
, addend
, value
, dyn_r_type
)
2816 struct bfd_link_info
*info
;
2817 struct elf64_ia64_dyn_sym_info
*dyn_i
;
2821 unsigned int dyn_r_type
;
2823 struct elf64_ia64_link_hash_table
*ia64_info
;
2826 ia64_info
= elf64_ia64_hash_table (info
);
2827 got_sec
= ia64_info
->got_sec
;
2829 BFD_ASSERT ((dyn_i
->got_offset
& 7) == 0);
2831 if (! dyn_i
->got_done
)
2833 dyn_i
->got_done
= true;
2835 /* Store the target address in the linkage table entry. */
2836 bfd_put_64 (abfd
, value
, got_sec
->contents
+ dyn_i
->got_offset
);
2838 /* Install a dynamic relocation if needed. */
2840 || elf64_ia64_dynamic_symbol_p (dyn_i
->h
, info
)
2841 || (dynindx
!= -1 && dyn_r_type
== R_IA64_FPTR64LSB
))
2845 dyn_r_type
= R_IA64_REL64LSB
;
2850 if (bfd_big_endian (abfd
))
2854 case R_IA64_REL64LSB
:
2855 dyn_r_type
= R_IA64_REL64MSB
;
2857 case R_IA64_DIR64LSB
:
2858 dyn_r_type
= R_IA64_DIR64MSB
;
2860 case R_IA64_FPTR64LSB
:
2861 dyn_r_type
= R_IA64_FPTR64MSB
;
2869 elf64_ia64_install_dyn_reloc (abfd
, NULL
, got_sec
,
2870 ia64_info
->rel_got_sec
,
2871 dyn_i
->got_offset
, dyn_r_type
,
2876 /* Return the address of the linkage table entry. */
2877 value
= (got_sec
->output_section
->vma
2878 + got_sec
->output_offset
2879 + dyn_i
->got_offset
);
2884 /* Fill in a function descriptor consisting of the function's code
2885 address and its global pointer. Return the descriptor's address. */
2888 set_fptr_entry (abfd
, info
, dyn_i
, value
)
2890 struct bfd_link_info
*info
;
2891 struct elf64_ia64_dyn_sym_info
*dyn_i
;
2894 struct elf64_ia64_link_hash_table
*ia64_info
;
2897 ia64_info
= elf64_ia64_hash_table (info
);
2898 fptr_sec
= ia64_info
->fptr_sec
;
2900 if (!dyn_i
->fptr_done
)
2902 dyn_i
->fptr_done
= 1;
2904 /* Fill in the function descriptor. */
2905 bfd_put_64 (abfd
, value
, fptr_sec
->contents
+ dyn_i
->fptr_offset
);
2906 bfd_put_64 (abfd
, _bfd_get_gp_value (abfd
),
2907 fptr_sec
->contents
+ dyn_i
->fptr_offset
+ 8);
2910 /* Return the descriptor's address. */
2911 value
= (fptr_sec
->output_section
->vma
2912 + fptr_sec
->output_offset
2913 + dyn_i
->fptr_offset
);
2918 /* Fill in a PLTOFF entry consisting of the function's code address
2919 and its global pointer. Return the descriptor's address. */
2922 set_pltoff_entry (abfd
, info
, dyn_i
, value
, is_plt
)
2924 struct bfd_link_info
*info
;
2925 struct elf64_ia64_dyn_sym_info
*dyn_i
;
2929 struct elf64_ia64_link_hash_table
*ia64_info
;
2930 asection
*pltoff_sec
;
2932 ia64_info
= elf64_ia64_hash_table (info
);
2933 pltoff_sec
= ia64_info
->pltoff_sec
;
2935 /* Don't do anything if this symbol uses a real PLT entry. In
2936 that case, we'll fill this in during finish_dynamic_symbol. */
2937 if ((! dyn_i
->want_plt
|| is_plt
)
2938 && !dyn_i
->pltoff_done
)
2940 /* Fill in the function descriptor. */
2941 bfd_put_64 (abfd
, value
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
);
2942 bfd_put_64 (abfd
, _bfd_get_gp_value (abfd
),
2943 pltoff_sec
->contents
+ dyn_i
->pltoff_offset
+ 8);
2945 /* Install dynamic relocations if needed. */
2946 if (!is_plt
&& info
->shared
)
2948 unsigned int dyn_r_type
;
2950 if (bfd_big_endian (abfd
))
2951 dyn_r_type
= R_IA64_REL64MSB
;
2953 dyn_r_type
= R_IA64_REL64LSB
;
2955 elf64_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
2956 ia64_info
->rel_pltoff_sec
,
2957 dyn_i
->pltoff_offset
,
2959 elf64_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
2960 ia64_info
->rel_pltoff_sec
,
2961 dyn_i
->pltoff_offset
+ 8,
2965 dyn_i
->pltoff_done
= 1;
2968 /* Return the descriptor's address. */
2969 value
= (pltoff_sec
->output_section
->vma
2970 + pltoff_sec
->output_offset
2971 + dyn_i
->pltoff_offset
);
2976 /* Called through qsort to sort the .IA_64.unwind section during a
2977 non-relocatable link. Set elf64_ia64_unwind_entry_compare_bfd
2978 to the output bfd so we can do proper endianness frobbing. */
2980 static bfd
*elf64_ia64_unwind_entry_compare_bfd
;
2983 elf64_ia64_unwind_entry_compare (a
, b
)
2989 av
= bfd_get_64 (elf64_ia64_unwind_entry_compare_bfd
, a
);
2990 bv
= bfd_get_64 (elf64_ia64_unwind_entry_compare_bfd
, b
);
2992 return (av
< bv
? -1 : av
> bv
? 1 : 0);
2996 elf64_ia64_final_link (abfd
, info
)
2998 struct bfd_link_info
*info
;
3000 struct elf64_ia64_link_hash_table
*ia64_info
;
3001 ia64_info
= elf64_ia64_hash_table (info
);
3003 /* Make sure we've got ourselves a nice fat __gp value. */
3004 if (!info
->relocateable
)
3006 bfd_vma min_vma
= (bfd_vma
) -1, max_vma
= 0;
3007 bfd_vma min_short_vma
= min_vma
, max_short_vma
= 0;
3008 struct elf_link_hash_entry
*gp
;
3012 /* Find the min and max vma of all sections marked short. Also
3013 collect min and max vma of any type, for use in selecting a
3015 for (os
= abfd
->sections
; os
; os
= os
->next
)
3019 if ((os
->flags
& SEC_ALLOC
) == 0)
3023 hi
= os
->vma
+ os
->_raw_size
;
3031 if (os
->flags
& SEC_SMALL_DATA
)
3033 if (min_short_vma
> lo
)
3035 if (max_short_vma
< hi
)
3040 /* See if the user wants to force a value. */
3041 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", false,
3045 && (gp
->root
.type
== bfd_link_hash_defined
3046 || gp
->root
.type
== bfd_link_hash_defweak
))
3048 asection
*gp_sec
= gp
->root
.u
.def
.section
;
3049 gp_val
= (gp
->root
.u
.def
.value
3050 + gp_sec
->output_section
->vma
3051 + gp_sec
->output_offset
);
3055 /* Pick a sensible value. */
3057 asection
*got_sec
= ia64_info
->got_sec
;
3059 /* Start with just the address of the .got. */
3061 gp_val
= got_sec
->output_section
->vma
;
3062 else if (max_short_vma
!= 0)
3063 gp_val
= min_short_vma
;
3067 /* If it is possible to address the entire image, but we
3068 don't with the choice above, adjust. */
3069 if (max_vma
- min_vma
< 0x400000
3070 && max_vma
- gp_val
<= 0x200000
3071 && gp_val
- min_vma
> 0x200000)
3072 gp_val
= min_vma
+ 0x200000;
3073 else if (max_short_vma
!= 0)
3075 /* If we don't cover all the short data, adjust. */
3076 if (max_short_vma
- gp_val
>= 0x200000)
3077 gp_val
= min_short_vma
+ 0x200000;
3079 /* If we're addressing stuff past the end, adjust back. */
3080 if (gp_val
> max_vma
)
3081 gp_val
= max_vma
- 0x200000 + 8;
3085 /* Validate whether all SHF_IA_64_SHORT sections are within
3086 range of the chosen GP. */
3088 if (max_short_vma
!= 0)
3090 if (max_short_vma
- min_short_vma
>= 0x400000)
3092 (*_bfd_error_handler
)
3093 (_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
3094 bfd_get_filename (abfd
),
3095 (unsigned long)(max_short_vma
- min_short_vma
));
3098 else if ((gp_val
> min_short_vma
3099 && gp_val
- min_short_vma
> 0x200000)
3100 || (gp_val
< max_short_vma
3101 && max_short_vma
- gp_val
>= 0x200000))
3103 (*_bfd_error_handler
)
3104 (_("%s: __gp does not cover short data segment"),
3105 bfd_get_filename (abfd
));
3110 _bfd_set_gp_value (abfd
, gp_val
);
3113 /* Tricky bits. DT_INIT and DT_FINI use a pltoff entry, which is
3114 normally initialized in finish_dynamic_sections. Except that
3115 we need all non-plt pltoff entries to be initialized before
3116 finish_dynamic_symbols. This because the array of relocations
3117 used for plt entries (aka DT_JMPREL) begins after all the
3118 non-plt pltoff relocations. If the order gets confused, we
3119 munge either the array or the array base. */
3120 if (ia64_info
->root
.dynamic_sections_created
)
3122 struct elf_link_hash_entry
*h
;
3123 struct elf64_ia64_dyn_sym_info
*dyn_i
;
3126 if (info
->init_function
3127 && (h
= elf_link_hash_lookup (elf_hash_table (info
),
3128 info
->init_function
, false,
3130 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
3131 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
3133 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, false);
3134 addr
= (h
->root
.u
.def
.section
->output_section
->vma
3135 + h
->root
.u
.def
.section
->output_offset
3136 + h
->root
.u
.def
.value
);
3137 (void) set_pltoff_entry (abfd
, info
, dyn_i
, addr
, false);
3140 if (info
->fini_function
3141 && (h
= elf_link_hash_lookup (elf_hash_table (info
),
3142 info
->fini_function
, false,
3144 && (h
->elf_link_hash_flags
& (ELF_LINK_HASH_REF_REGULAR
3145 | ELF_LINK_HASH_DEF_REGULAR
)) != 0)
3147 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, false);
3148 addr
= (h
->root
.u
.def
.section
->output_section
->vma
3149 + h
->root
.u
.def
.section
->output_offset
3150 + h
->root
.u
.def
.value
);
3151 (void) set_pltoff_entry (abfd
, info
, dyn_i
, addr
, false);
3155 /* Invoke the regular ELF backend linker to do all the work. */
3156 if (!bfd_elf64_bfd_final_link (abfd
, info
))
3159 /* If we're producing a final executable, we need to sort the contents
3160 of the .IA_64.unwind section. */
3161 if (!info
->relocateable
)
3163 asection
*s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_unwind
);
3166 bfd_size_type size
= s
->output_section
->_raw_size
;
3167 char *contents
= bfd_malloc (size
);
3169 if (contents
== NULL
)
3171 if (! bfd_get_section_contents (abfd
, s
->output_section
,
3172 contents
, (file_ptr
) 0, size
))
3175 elf64_ia64_unwind_entry_compare_bfd
= abfd
;
3176 qsort (contents
, size
/ 24, 24, elf64_ia64_unwind_entry_compare
);
3178 if (! bfd_set_section_contents (abfd
, s
->output_section
,
3179 contents
, (file_ptr
) 0, size
))
3188 elf64_ia64_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
3189 contents
, relocs
, local_syms
, local_sections
)
3191 struct bfd_link_info
*info
;
3193 asection
*input_section
;
3195 Elf_Internal_Rela
*relocs
;
3196 Elf_Internal_Sym
*local_syms
;
3197 asection
**local_sections
;
3199 struct elf64_ia64_link_hash_table
*ia64_info
;
3200 Elf_Internal_Shdr
*symtab_hdr
;
3201 Elf_Internal_Rela
*rel
;
3202 Elf_Internal_Rela
*relend
;
3204 boolean ret_val
= true; /* for non-fatal errors */
3207 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3208 ia64_info
= elf64_ia64_hash_table (info
);
3210 /* Infect various flags from the input section to the output section. */
3211 if (info
->relocateable
)
3215 flags
= elf_section_data(input_section
)->this_hdr
.sh_flags
;
3216 flags
&= SHF_IA_64_NORECOV
;
3218 elf_section_data(input_section
->output_section
)
3219 ->this_hdr
.sh_flags
|= flags
;
3222 gp_val
= _bfd_get_gp_value (output_bfd
);
3223 srel
= get_reloc_section (input_bfd
, ia64_info
, input_section
, false);
3226 relend
= relocs
+ input_section
->reloc_count
;
3227 for (; rel
< relend
; ++rel
)
3229 struct elf_link_hash_entry
*h
;
3230 struct elf64_ia64_dyn_sym_info
*dyn_i
;
3231 bfd_reloc_status_type r
;
3232 reloc_howto_type
*howto
;
3233 unsigned long r_symndx
;
3234 Elf_Internal_Sym
*sym
;
3235 unsigned int r_type
;
3239 boolean dynamic_symbol_p
;
3240 boolean undef_weak_ref
;
3242 r_type
= ELF64_R_TYPE (rel
->r_info
);
3243 if (r_type
> R_IA64_MAX_RELOC_CODE
)
3245 (*_bfd_error_handler
)
3246 (_("%s: unknown relocation type %d"),
3247 bfd_get_filename (input_bfd
), (int)r_type
);
3248 bfd_set_error (bfd_error_bad_value
);
3252 howto
= lookup_howto (r_type
);
3253 r_symndx
= ELF64_R_SYM (rel
->r_info
);
3255 if (info
->relocateable
)
3257 /* This is a relocateable link. We don't have to change
3258 anything, unless the reloc is against a section symbol,
3259 in which case we have to adjust according to where the
3260 section symbol winds up in the output section. */
3261 if (r_symndx
< symtab_hdr
->sh_info
)
3263 sym
= local_syms
+ r_symndx
;
3264 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
3266 sym_sec
= local_sections
[r_symndx
];
3267 rel
->r_addend
+= sym_sec
->output_offset
;
3273 /* This is a final link. */
3278 undef_weak_ref
= false;
3280 if (r_symndx
< symtab_hdr
->sh_info
)
3282 /* Reloc against local symbol. */
3283 sym
= local_syms
+ r_symndx
;
3284 sym_sec
= local_sections
[r_symndx
];
3285 value
= (sym_sec
->output_section
->vma
3286 + sym_sec
->output_offset
3293 /* Reloc against global symbol. */
3294 indx
= r_symndx
- symtab_hdr
->sh_info
;
3295 h
= elf_sym_hashes (input_bfd
)[indx
];
3296 while (h
->root
.type
== bfd_link_hash_indirect
3297 || h
->root
.type
== bfd_link_hash_warning
)
3298 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3301 if (h
->root
.type
== bfd_link_hash_defined
3302 || h
->root
.type
== bfd_link_hash_defweak
)
3304 sym_sec
= h
->root
.u
.def
.section
;
3306 /* Detect the cases that sym_sec->output_section is
3307 expected to be NULL -- all cases in which the symbol
3308 is defined in another shared module. This includes
3309 PLT relocs for which we've created a PLT entry and
3310 other relocs for which we're prepared to create
3311 dynamic relocations. */
3312 /* ??? Just accept it NULL and continue. */
3314 if (sym_sec
->output_section
!= NULL
)
3316 value
= (h
->root
.u
.def
.value
3317 + sym_sec
->output_section
->vma
3318 + sym_sec
->output_offset
);
3321 else if (h
->root
.type
== bfd_link_hash_undefweak
)
3322 undef_weak_ref
= true;
3323 else if (info
->shared
&& !info
->symbolic
3324 && !info
->no_undefined
3325 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
3329 if (! ((*info
->callbacks
->undefined_symbol
)
3330 (info
, h
->root
.root
.string
, input_bfd
,
3331 input_section
, rel
->r_offset
,
3332 (!info
->shared
|| info
->no_undefined
3333 || ELF_ST_VISIBILITY (h
->other
)))))
3340 hit_addr
= contents
+ rel
->r_offset
;
3341 value
+= rel
->r_addend
;
3342 dynamic_symbol_p
= elf64_ia64_dynamic_symbol_p (h
, info
);
3353 case R_IA64_DIR32MSB
:
3354 case R_IA64_DIR32LSB
:
3355 case R_IA64_DIR64MSB
:
3356 case R_IA64_DIR64LSB
:
3357 /* Install a dynamic relocation for this reloc. */
3358 if ((dynamic_symbol_p
|| info
->shared
)
3359 && (input_section
->flags
& SEC_ALLOC
) != 0)
3361 unsigned int dyn_r_type
;
3364 BFD_ASSERT (srel
!= NULL
);
3366 /* If we don't need dynamic symbol lookup, find a
3367 matching RELATIVE relocation. */
3368 dyn_r_type
= r_type
;
3369 if (dynamic_symbol_p
)
3370 dynindx
= h
->dynindx
;
3375 case R_IA64_DIR32MSB
:
3376 dyn_r_type
= R_IA64_REL32MSB
;
3378 case R_IA64_DIR32LSB
:
3379 dyn_r_type
= R_IA64_REL32LSB
;
3381 case R_IA64_DIR64MSB
:
3382 dyn_r_type
= R_IA64_REL64MSB
;
3384 case R_IA64_DIR64LSB
:
3385 dyn_r_type
= R_IA64_REL64LSB
;
3389 /* We can't represent this without a dynamic symbol.
3390 Adjust the relocation to be against an output
3391 section symbol, which are always present in the
3392 dynamic symbol table. */
3393 /* ??? People shouldn't be doing non-pic code in
3394 shared libraries. Hork. */
3395 (*_bfd_error_handler
)
3396 (_("%s: linking non-pic code in a shared library"),
3397 bfd_get_filename (input_bfd
));
3404 elf64_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
3405 srel
, rel
->r_offset
, dyn_r_type
,
3406 dynindx
, rel
->r_addend
);
3410 case R_IA64_LTV32MSB
:
3411 case R_IA64_LTV32LSB
:
3412 case R_IA64_LTV64MSB
:
3413 case R_IA64_LTV64LSB
:
3414 r
= elf64_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3417 case R_IA64_GPREL22
:
3418 case R_IA64_GPREL64I
:
3419 case R_IA64_GPREL32MSB
:
3420 case R_IA64_GPREL32LSB
:
3421 case R_IA64_GPREL64MSB
:
3422 case R_IA64_GPREL64LSB
:
3423 if (dynamic_symbol_p
)
3425 (*_bfd_error_handler
)
3426 (_("%s: @gprel relocation against dynamic symbol %s"),
3427 bfd_get_filename (input_bfd
), h
->root
.root
.string
);
3432 r
= elf64_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3435 case R_IA64_LTOFF22
:
3436 case R_IA64_LTOFF22X
:
3437 case R_IA64_LTOFF64I
:
3438 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, false);
3439 value
= set_got_entry (input_bfd
, info
, dyn_i
, (h
? h
->dynindx
: -1),
3440 rel
->r_addend
, value
, R_IA64_DIR64LSB
);
3442 r
= elf64_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3445 case R_IA64_PLTOFF22
:
3446 case R_IA64_PLTOFF64I
:
3447 case R_IA64_PLTOFF64MSB
:
3448 case R_IA64_PLTOFF64LSB
:
3449 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, false);
3450 value
= set_pltoff_entry (output_bfd
, info
, dyn_i
, value
, false);
3452 r
= elf64_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3455 case R_IA64_FPTR64I
:
3456 case R_IA64_FPTR32MSB
:
3457 case R_IA64_FPTR32LSB
:
3458 case R_IA64_FPTR64MSB
:
3459 case R_IA64_FPTR64LSB
:
3460 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, false);
3461 if (dyn_i
->want_fptr
)
3463 if (!undef_weak_ref
)
3464 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
3470 /* Otherwise, we expect the dynamic linker to create
3475 if (h
->dynindx
!= -1)
3476 dynindx
= h
->dynindx
;
3478 dynindx
= (_bfd_elf_link_lookup_local_dynindx
3479 (info
, h
->root
.u
.def
.section
->owner
,
3480 global_sym_index (h
)));
3484 dynindx
= (_bfd_elf_link_lookup_local_dynindx
3485 (info
, input_bfd
, r_symndx
));
3488 elf64_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
3489 srel
, rel
->r_offset
, r_type
,
3490 dynindx
, rel
->r_addend
);
3494 r
= elf64_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3497 case R_IA64_LTOFF_FPTR22
:
3498 case R_IA64_LTOFF_FPTR64I
:
3499 case R_IA64_LTOFF_FPTR64MSB
:
3500 case R_IA64_LTOFF_FPTR64LSB
:
3504 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, false);
3505 if (dyn_i
->want_fptr
)
3507 BFD_ASSERT (h
== NULL
|| h
->dynindx
== -1)
3508 if (!undef_weak_ref
)
3509 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
3514 /* Otherwise, we expect the dynamic linker to create
3518 if (h
->dynindx
!= -1)
3519 dynindx
= h
->dynindx
;
3521 dynindx
= (_bfd_elf_link_lookup_local_dynindx
3522 (info
, h
->root
.u
.def
.section
->owner
,
3523 global_sym_index (h
)));
3526 dynindx
= (_bfd_elf_link_lookup_local_dynindx
3527 (info
, input_bfd
, r_symndx
));
3531 value
= set_got_entry (output_bfd
, info
, dyn_i
, dynindx
,
3532 rel
->r_addend
, value
, R_IA64_FPTR64LSB
);
3534 r
= elf64_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3538 case R_IA64_PCREL32MSB
:
3539 case R_IA64_PCREL32LSB
:
3540 case R_IA64_PCREL64MSB
:
3541 case R_IA64_PCREL64LSB
:
3542 /* Install a dynamic relocation for this reloc. */
3543 if (dynamic_symbol_p
)
3545 BFD_ASSERT (srel
!= NULL
);
3547 elf64_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
3548 srel
, rel
->r_offset
, r_type
,
3549 h
->dynindx
, rel
->r_addend
);
3553 case R_IA64_PCREL21BI
:
3554 case R_IA64_PCREL21F
:
3555 case R_IA64_PCREL21M
:
3556 /* ??? These two are only used for speculation fixup code.
3557 They should never be dynamic. */
3558 if (dynamic_symbol_p
)
3560 (*_bfd_error_handler
)
3561 (_("%s: dynamic relocation against speculation fixup"),
3562 bfd_get_filename (input_bfd
));
3568 (*_bfd_error_handler
)
3569 (_("%s: speculation fixup against undefined weak symbol"),
3570 bfd_get_filename (input_bfd
));
3576 case R_IA64_PCREL21B
:
3577 case R_IA64_PCREL60B
:
3578 /* We should have created a PLT entry for any dynamic symbol. */
3581 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, false);
3583 if (dyn_i
&& dyn_i
->want_plt2
)
3585 /* Should have caught this earlier. */
3586 BFD_ASSERT (rel
->r_addend
== 0);
3588 value
= (ia64_info
->plt_sec
->output_section
->vma
3589 + ia64_info
->plt_sec
->output_offset
3590 + dyn_i
->plt2_offset
);
3594 /* Since there's no PLT entry, Validate that this is
3596 BFD_ASSERT (undef_weak_ref
|| sym_sec
->output_section
!= NULL
);
3598 /* If the symbol is undef_weak, we shouldn't be trying
3599 to call it. There's every chance that we'd wind up
3600 with an out-of-range fixup here. Don't bother setting
3601 any value at all. */
3607 case R_IA64_PCREL22
:
3608 case R_IA64_PCREL64I
:
3610 /* Make pc-relative. */
3611 value
-= (input_section
->output_section
->vma
3612 + input_section
->output_offset
3613 + rel
->r_offset
) & ~ (bfd_vma
) 0x3;
3614 r
= elf64_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3617 case R_IA64_SEGREL32MSB
:
3618 case R_IA64_SEGREL32LSB
:
3619 case R_IA64_SEGREL64MSB
:
3620 case R_IA64_SEGREL64LSB
:
3622 struct elf_segment_map
*m
;
3623 Elf_Internal_Phdr
*p
;
3625 /* Find the segment that contains the output_section. */
3626 for (m
= elf_tdata (output_bfd
)->segment_map
,
3627 p
= elf_tdata (output_bfd
)->phdr
;
3632 for (i
= m
->count
- 1; i
>= 0; i
--)
3633 if (m
->sections
[i
] == sym_sec
->output_section
)
3641 /* If the input section was discarded from the output, then
3644 if (bfd_is_abs_section (sym_sec
->output_section
))
3647 r
= bfd_reloc_notsupported
;
3651 /* The VMA of the segment is the vaddr of the associated
3653 if (value
> p
->p_vaddr
)
3654 value
-= p
->p_vaddr
;
3657 r
= elf64_ia64_install_value (output_bfd
, hit_addr
, value
,
3663 case R_IA64_SECREL32MSB
:
3664 case R_IA64_SECREL32LSB
:
3665 case R_IA64_SECREL64MSB
:
3666 case R_IA64_SECREL64LSB
:
3667 /* Make output-section relative. */
3668 if (value
> input_section
->output_section
->vma
)
3669 value
-= input_section
->output_section
->vma
;
3672 r
= elf64_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3675 case R_IA64_SEGBASE
:
3677 case R_IA64_REL32MSB
:
3678 case R_IA64_REL32LSB
:
3679 case R_IA64_REL64MSB
:
3680 case R_IA64_REL64LSB
:
3682 case R_IA64_IPLTMSB
:
3683 case R_IA64_IPLTLSB
:
3684 case R_IA64_EPLTMSB
:
3685 case R_IA64_EPLTLSB
:
3688 case R_IA64_TPREL22
:
3689 case R_IA64_TPREL64MSB
:
3690 case R_IA64_TPREL64LSB
:
3691 case R_IA64_LTOFF_TP22
:
3693 r
= bfd_reloc_notsupported
;
3702 case bfd_reloc_undefined
:
3703 /* This can happen for global table relative relocs if
3704 __gp is undefined. This is a panic situation so we
3705 don't try to continue. */
3706 (*info
->callbacks
->undefined_symbol
)
3707 (info
, "__gp", input_bfd
, input_section
, rel
->r_offset
, 1);
3710 case bfd_reloc_notsupported
:
3715 name
= h
->root
.root
.string
;
3718 name
= bfd_elf_string_from_elf_section (input_bfd
,
3719 symtab_hdr
->sh_link
,
3724 name
= bfd_section_name (input_bfd
, input_section
);
3726 if (!(*info
->callbacks
->warning
) (info
, _("unsupported reloc"),
3728 input_section
, rel
->r_offset
))
3734 case bfd_reloc_dangerous
:
3735 case bfd_reloc_outofrange
:
3736 case bfd_reloc_overflow
:
3742 name
= h
->root
.root
.string
;
3745 name
= bfd_elf_string_from_elf_section (input_bfd
,
3746 symtab_hdr
->sh_link
,
3751 name
= bfd_section_name (input_bfd
, input_section
);
3753 if (!(*info
->callbacks
->reloc_overflow
) (info
, name
,
3769 elf64_ia64_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
3771 struct bfd_link_info
*info
;
3772 struct elf_link_hash_entry
*h
;
3773 Elf_Internal_Sym
*sym
;
3775 struct elf64_ia64_link_hash_table
*ia64_info
;
3776 struct elf64_ia64_dyn_sym_info
*dyn_i
;
3778 ia64_info
= elf64_ia64_hash_table (info
);
3779 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, false);
3781 /* Fill in the PLT data, if required. */
3782 if (dyn_i
&& dyn_i
->want_plt
)
3784 Elf_Internal_Rela outrel
;
3787 bfd_vma plt_addr
, pltoff_addr
, gp_val
, index
;
3788 Elf64_External_Rela
*rel
;
3790 gp_val
= _bfd_get_gp_value (output_bfd
);
3792 /* Initialize the minimal PLT entry. */
3794 index
= (dyn_i
->plt_offset
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
3795 plt_sec
= ia64_info
->plt_sec
;
3796 loc
= plt_sec
->contents
+ dyn_i
->plt_offset
;
3798 memcpy (loc
, plt_min_entry
, PLT_MIN_ENTRY_SIZE
);
3799 elf64_ia64_install_value (output_bfd
, loc
, index
, R_IA64_IMM22
);
3800 elf64_ia64_install_value (output_bfd
, loc
+2, -dyn_i
->plt_offset
,
3803 plt_addr
= (plt_sec
->output_section
->vma
3804 + plt_sec
->output_offset
3805 + dyn_i
->plt_offset
);
3806 pltoff_addr
= set_pltoff_entry (output_bfd
, info
, dyn_i
, plt_addr
, true);
3808 /* Initialize the FULL PLT entry, if needed. */
3809 if (dyn_i
->want_plt2
)
3811 loc
= plt_sec
->contents
+ dyn_i
->plt2_offset
;
3813 memcpy (loc
, plt_full_entry
, PLT_FULL_ENTRY_SIZE
);
3814 elf64_ia64_install_value (output_bfd
, loc
, pltoff_addr
- gp_val
,
3817 /* Mark the symbol as undefined, rather than as defined in the
3818 plt section. Leave the value alone. */
3819 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
3820 first place. But perhaps elflink.h did some for us. */
3821 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
3822 sym
->st_shndx
= SHN_UNDEF
;
3825 /* Create the dynamic relocation. */
3826 outrel
.r_offset
= pltoff_addr
;
3827 if (bfd_little_endian (output_bfd
))
3828 outrel
.r_info
= ELF64_R_INFO (h
->dynindx
, R_IA64_IPLTLSB
);
3830 outrel
.r_info
= ELF64_R_INFO (h
->dynindx
, R_IA64_IPLTMSB
);
3831 outrel
.r_addend
= 0;
3833 /* This is fun. In the .IA_64.pltoff section, we've got entries
3834 that correspond both to real PLT entries, and those that
3835 happened to resolve to local symbols but need to be created
3836 to satisfy @pltoff relocations. The .rela.IA_64.pltoff
3837 relocations for the real PLT should come at the end of the
3838 section, so that they can be indexed by plt entry at runtime.
3840 We emitted all of the relocations for the non-PLT @pltoff
3841 entries during relocate_section. So we can consider the
3842 existing sec->reloc_count to be the base of the array of
3845 rel
= (Elf64_External_Rela
*)ia64_info
->rel_pltoff_sec
->contents
;
3846 rel
+= ia64_info
->rel_pltoff_sec
->reloc_count
;
3848 bfd_elf64_swap_reloca_out (output_bfd
, &outrel
, rel
+ index
);
3851 /* Mark some specially defined symbols as absolute. */
3852 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
3853 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
3854 || strcmp (h
->root
.root
.string
, "_PROCEDURE_LINKAGE_TABLE_") == 0)
3855 sym
->st_shndx
= SHN_ABS
;
3861 elf64_ia64_finish_dynamic_sections (abfd
, info
)
3863 struct bfd_link_info
*info
;
3865 struct elf64_ia64_link_hash_table
*ia64_info
;
3868 ia64_info
= elf64_ia64_hash_table (info
);
3869 dynobj
= ia64_info
->root
.dynobj
;
3871 if (elf_hash_table (info
)->dynamic_sections_created
)
3873 Elf64_External_Dyn
*dyncon
, *dynconend
;
3874 asection
*sdyn
, *sgotplt
;
3877 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3878 sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
3879 BFD_ASSERT (sdyn
!= NULL
);
3880 dyncon
= (Elf64_External_Dyn
*) sdyn
->contents
;
3881 dynconend
= (Elf64_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
3883 gp_val
= _bfd_get_gp_value (abfd
);
3885 for (; dyncon
< dynconend
; dyncon
++)
3887 Elf_Internal_Dyn dyn
;
3891 bfd_elf64_swap_dyn_in (dynobj
, dyncon
, &dyn
);
3896 dyn
.d_un
.d_ptr
= gp_val
;
3900 dyn
.d_un
.d_val
= (ia64_info
->minplt_entries
3901 * sizeof (Elf64_External_Rela
));
3905 /* See the comment above in finish_dynamic_symbol. */
3906 dyn
.d_un
.d_ptr
= (ia64_info
->rel_pltoff_sec
->output_section
->vma
3907 + ia64_info
->rel_pltoff_sec
->output_offset
3908 + (ia64_info
->rel_pltoff_sec
->reloc_count
3909 * sizeof (Elf64_External_Rela
)));
3912 case DT_IA_64_PLT_RESERVE
:
3913 dyn
.d_un
.d_ptr
= (sgotplt
->output_section
->vma
3914 + sgotplt
->output_offset
);
3918 /* Do not have RELASZ include JMPREL. This makes things
3919 easier on ld.so. This is not what the rest of BFD set up. */
3920 dyn
.d_un
.d_val
-= (ia64_info
->minplt_entries
3921 * sizeof (Elf64_External_Rela
));
3927 struct elf_link_hash_entry
*h
;
3928 struct elf64_ia64_dyn_sym_info
*dyn_i
;
3931 if (dyn
.d_tag
== DT_INIT
)
3932 which
= info
->init_function
;
3934 which
= info
->fini_function
;
3936 h
= elf_link_hash_lookup (elf_hash_table (info
), which
,
3937 false, false, false);
3938 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, false);
3939 dyn
.d_un
.d_ptr
= set_pltoff_entry (abfd
, info
, dyn_i
,
3944 bfd_elf64_swap_dyn_out (abfd
, &dyn
, dyncon
);
3947 /* Initialize the PLT0 entry */
3948 if (ia64_info
->plt_sec
)
3950 bfd_byte
*loc
= ia64_info
->plt_sec
->contents
;
3953 memcpy (loc
, plt_header
, PLT_HEADER_SIZE
);
3955 pltres
= (sgotplt
->output_section
->vma
3956 + sgotplt
->output_offset
3959 elf64_ia64_install_value (abfd
, loc
+1, pltres
, R_IA64_GPREL22
);
3966 /* ELF file flag handling: */
3968 /* Function to keep IA-64 specific file flags. */
3970 elf64_ia64_set_private_flags (abfd
, flags
)
3974 BFD_ASSERT (!elf_flags_init (abfd
)
3975 || elf_elfheader (abfd
)->e_flags
== flags
);
3977 elf_elfheader (abfd
)->e_flags
= flags
;
3978 elf_flags_init (abfd
) = true;
3982 /* Copy backend specific data from one object module to another */
3984 elf64_ia64_copy_private_bfd_data (ibfd
, obfd
)
3987 if ( bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3988 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3991 BFD_ASSERT (!elf_flags_init (obfd
)
3992 || (elf_elfheader (obfd
)->e_flags
3993 == elf_elfheader (ibfd
)->e_flags
));
3995 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
3996 elf_flags_init (obfd
) = true;
4000 /* Merge backend specific data from an object file to the output
4001 object file when linking. */
4003 elf64_ia64_merge_private_bfd_data (ibfd
, obfd
)
4010 /* Don't even pretend to support mixed-format linking. */
4011 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4012 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4015 in_flags
= elf_elfheader (ibfd
)->e_flags
;
4016 out_flags
= elf_elfheader (obfd
)->e_flags
;
4018 if (! elf_flags_init (obfd
))
4020 elf_flags_init (obfd
) = true;
4021 elf_elfheader (obfd
)->e_flags
= in_flags
;
4023 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
4024 && bfd_get_arch_info (obfd
)->the_default
)
4026 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
4027 bfd_get_mach (ibfd
));
4033 /* Check flag compatibility. */
4034 if (in_flags
== out_flags
)
4037 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
4038 if (!(in_flags
& EF_IA_64_REDUCEDFP
) && (out_flags
& EF_IA_64_REDUCEDFP
))
4039 elf_elfheader (obfd
)->e_flags
&= ~EF_IA_64_REDUCEDFP
;
4041 if ((in_flags
& EF_IA_64_TRAPNIL
) != (out_flags
& EF_IA_64_TRAPNIL
))
4043 (*_bfd_error_handler
)
4044 (_("%s: linking trap-on-NULL-dereference with non-trapping files"),
4045 bfd_get_filename (ibfd
));
4047 bfd_set_error (bfd_error_bad_value
);
4050 if ((in_flags
& EF_IA_64_BE
) != (out_flags
& EF_IA_64_BE
))
4052 (*_bfd_error_handler
)
4053 (_("%s: linking big-endian files with little-endian files"),
4054 bfd_get_filename (ibfd
));
4056 bfd_set_error (bfd_error_bad_value
);
4059 if ((in_flags
& EF_IA_64_ABI64
) != (out_flags
& EF_IA_64_ABI64
))
4061 (*_bfd_error_handler
)
4062 (_("%s: linking 64-bit files with 32-bit files"),
4063 bfd_get_filename (ibfd
));
4065 bfd_set_error (bfd_error_bad_value
);
4068 if ((in_flags
& EF_IA_64_CONS_GP
) != (out_flags
& EF_IA_64_CONS_GP
))
4070 (*_bfd_error_handler
)
4071 (_("%s: linking constant-gp files with non-constant-gp files"),
4072 bfd_get_filename (ibfd
));
4074 bfd_set_error (bfd_error_bad_value
);
4077 if ((in_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
)
4078 != (out_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
4080 (*_bfd_error_handler
)
4081 (_("%s: linking auto-pic files with non-auto-pic files"),
4082 bfd_get_filename (ibfd
));
4084 bfd_set_error (bfd_error_bad_value
);
4092 elf64_ia64_print_private_bfd_data (abfd
, ptr
)
4096 FILE *file
= (FILE *) ptr
;
4097 flagword flags
= elf_elfheader (abfd
)->e_flags
;
4099 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
4101 fprintf (file
, "private flags = %s%s%s%s%s%s%s%s\n",
4102 (flags
& EF_IA_64_TRAPNIL
) ? "TRAPNIL, " : "",
4103 (flags
& EF_IA_64_EXT
) ? "EXT, " : "",
4104 (flags
& EF_IA_64_BE
) ? "BE, " : "LE, ",
4105 (flags
& EF_IA_64_REDUCEDFP
) ? "REDUCEDFP, " : "",
4106 (flags
& EF_IA_64_CONS_GP
) ? "CONS_GP, " : "",
4107 (flags
& EF_IA_64_NOFUNCDESC_CONS_GP
) ? "NOFUNCDESC_CONS_GP, " : "",
4108 (flags
& EF_IA_64_ABSOLUTE
) ? "ABSOLUTE, " : "",
4109 (flags
& EF_IA_64_ABI64
) ? "ABI64" : "ABI32");
4111 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
4115 #define TARGET_LITTLE_SYM bfd_elf64_ia64_little_vec
4116 #define TARGET_LITTLE_NAME "elf64-ia64-little"
4117 #define TARGET_BIG_SYM bfd_elf64_ia64_big_vec
4118 #define TARGET_BIG_NAME "elf64-ia64-big"
4119 #define ELF_ARCH bfd_arch_ia64
4120 #define ELF_MACHINE_CODE EM_IA_64
4121 #define ELF_MACHINE_ALT1 1999 /* EAS2.3 */
4122 #define ELF_MACHINE_ALT2 1998 /* EAS2.2 */
4123 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
4125 #define elf_backend_section_from_shdr \
4126 elf64_ia64_section_from_shdr
4127 #define elf_backend_section_flags \
4128 elf64_ia64_section_flags
4129 #define elf_backend_fake_sections \
4130 elf64_ia64_fake_sections
4131 #define elf_backend_add_symbol_hook \
4132 elf64_ia64_add_symbol_hook
4133 #define elf_backend_additional_program_headers \
4134 elf64_ia64_additional_program_headers
4135 #define elf_backend_modify_segment_map \
4136 elf64_ia64_modify_segment_map
4137 #define elf_info_to_howto \
4138 elf64_ia64_info_to_howto
4140 #define bfd_elf64_bfd_reloc_type_lookup \
4141 elf64_ia64_reloc_type_lookup
4142 #define bfd_elf64_bfd_is_local_label_name \
4143 elf64_ia64_is_local_label_name
4144 #define bfd_elf64_bfd_relax_section \
4145 elf64_ia64_relax_section
4147 /* Stuff for the BFD linker: */
4148 #define bfd_elf64_bfd_link_hash_table_create \
4149 elf64_ia64_hash_table_create
4150 #define elf_backend_create_dynamic_sections \
4151 elf64_ia64_create_dynamic_sections
4152 #define elf_backend_check_relocs \
4153 elf64_ia64_check_relocs
4154 #define elf_backend_adjust_dynamic_symbol \
4155 elf64_ia64_adjust_dynamic_symbol
4156 #define elf_backend_size_dynamic_sections \
4157 elf64_ia64_size_dynamic_sections
4158 #define elf_backend_relocate_section \
4159 elf64_ia64_relocate_section
4160 #define elf_backend_finish_dynamic_symbol \
4161 elf64_ia64_finish_dynamic_symbol
4162 #define elf_backend_finish_dynamic_sections \
4163 elf64_ia64_finish_dynamic_sections
4164 #define bfd_elf64_bfd_final_link \
4165 elf64_ia64_final_link
4167 #define bfd_elf64_bfd_copy_private_bfd_data \
4168 elf64_ia64_copy_private_bfd_data
4169 #define bfd_elf64_bfd_merge_private_bfd_data \
4170 elf64_ia64_merge_private_bfd_data
4171 #define bfd_elf64_bfd_set_private_flags \
4172 elf64_ia64_set_private_flags
4173 #define bfd_elf64_bfd_print_private_bfd_data \
4174 elf64_ia64_print_private_bfd_data
4176 #define elf_backend_plt_readonly 1
4177 #define elf_backend_want_plt_sym 0
4178 #define elf_backend_plt_alignment 5
4179 #define elf_backend_got_header_size 0
4180 #define elf_backend_plt_header_size PLT_HEADER_SIZE
4181 #define elf_backend_want_got_plt 1
4182 #define elf_backend_may_use_rel_p 1
4183 #define elf_backend_may_use_rela_p 1
4184 #define elf_backend_default_use_rela_p 1
4185 #define elf_backend_want_dynbss 0
4186 #define elf_backend_copy_indirect_symbol elf64_ia64_hash_copy_indirect
4187 #define elf_backend_hide_symbol elf64_ia64_hash_hide_symbol
4189 #include "elf64-target.h"