1 /* IA-64 support for 64-bit ELF
2 Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
3 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 #include "opcode/ia64.h"
29 * THE RULES for all the stuff the linker creates --
31 * GOT Entries created in response to LTOFF or LTOFF_FPTR
32 * relocations. Dynamic relocs created for dynamic
33 * symbols in an application; REL relocs for locals
34 * in a shared library.
36 * FPTR The canonical function descriptor. Created for local
37 * symbols in applications. Descriptors for dynamic symbols
38 * and local symbols in shared libraries are created by
39 * ld.so. Thus there are no dynamic relocs against these
40 * objects. The FPTR relocs for such _are_ passed through
41 * to the dynamic relocation tables.
43 * FULL_PLT Created for a PCREL21B relocation against a dynamic symbol.
44 * Requires the creation of a PLTOFF entry. This does not
45 * require any dynamic relocations.
47 * PLTOFF Created by PLTOFF relocations. For local symbols, this
48 * is an alternate function descriptor, and in shared libraries
49 * requires two REL relocations. Note that this cannot be
50 * transformed into an FPTR relocation, since it must be in
51 * range of the GP. For dynamic symbols, this is a function
52 * descriptor for a MIN_PLT entry, and requires one IPLT reloc.
54 * MIN_PLT Created by PLTOFF entries against dynamic symbols. This
55 * does not reqire dynamic relocations.
58 #define USE_RELA /* we want RELA relocs, not REL */
60 #define NELEMS(a) ((int) (sizeof (a) / sizeof ((a)[0])))
62 typedef struct bfd_hash_entry
*(*new_hash_entry_func
)
63 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
65 /* In dynamically (linker-) created sections, we generally need to keep track
66 of the place a symbol or expression got allocated to. This is done via hash
67 tables that store entries of the following type. */
69 struct elfNN_ia64_dyn_sym_info
71 /* The addend for which this entry is relevant. */
74 /* Next addend in the list. */
75 struct elfNN_ia64_dyn_sym_info
*next
;
79 bfd_vma pltoff_offset
;
83 /* The symbol table entry, if any, that this was derrived from. */
84 struct elf_link_hash_entry
*h
;
86 /* Used to count non-got, non-plt relocations for delayed sizing
87 of relocation sections. */
88 struct elfNN_ia64_dyn_reloc_entry
90 struct elfNN_ia64_dyn_reloc_entry
*next
;
96 /* True when the section contents have been updated. */
97 unsigned got_done
: 1;
98 unsigned fptr_done
: 1;
99 unsigned pltoff_done
: 1;
101 /* True for the different kinds of linker data we want created. */
102 unsigned want_got
: 1;
103 unsigned want_fptr
: 1;
104 unsigned want_ltoff_fptr
: 1;
105 unsigned want_plt
: 1;
106 unsigned want_plt2
: 1;
107 unsigned want_pltoff
: 1;
110 struct elfNN_ia64_local_hash_entry
112 struct bfd_hash_entry root
;
113 struct elfNN_ia64_dyn_sym_info
*info
;
115 /* True if this hash entry's addends was translated for
116 SHF_MERGE optimization. */
117 unsigned sec_merge_done
: 1;
120 struct elfNN_ia64_local_hash_table
122 struct bfd_hash_table root
;
123 /* No additional fields for now. */
126 struct elfNN_ia64_link_hash_entry
128 struct elf_link_hash_entry root
;
129 struct elfNN_ia64_dyn_sym_info
*info
;
132 struct elfNN_ia64_link_hash_table
134 /* The main hash table */
135 struct elf_link_hash_table root
;
137 asection
*got_sec
; /* the linkage table section (or NULL) */
138 asection
*rel_got_sec
; /* dynamic relocation section for same */
139 asection
*fptr_sec
; /* function descriptor table (or NULL) */
140 asection
*plt_sec
; /* the primary plt section (or NULL) */
141 asection
*pltoff_sec
; /* private descriptors for plt (or NULL) */
142 asection
*rel_pltoff_sec
; /* dynamic relocation section for same */
144 bfd_size_type minplt_entries
; /* number of minplt entries */
145 unsigned reltext
: 1; /* are there relocs against readonly sections? */
147 struct elfNN_ia64_local_hash_table loc_hash_table
;
150 #define elfNN_ia64_hash_table(p) \
151 ((struct elfNN_ia64_link_hash_table *) ((p)->hash))
153 static bfd_reloc_status_type elfNN_ia64_reloc
154 PARAMS ((bfd
*abfd
, arelent
*reloc
, asymbol
*sym
, PTR data
,
155 asection
*input_section
, bfd
*output_bfd
, char **error_message
));
156 static reloc_howto_type
* lookup_howto
157 PARAMS ((unsigned int rtype
));
158 static reloc_howto_type
*elfNN_ia64_reloc_type_lookup
159 PARAMS ((bfd
*abfd
, bfd_reloc_code_real_type bfd_code
));
160 static void elfNN_ia64_info_to_howto
161 PARAMS ((bfd
*abfd
, arelent
*bfd_reloc
, ElfNN_Internal_Rela
*elf_reloc
));
162 static boolean elfNN_ia64_relax_section
163 PARAMS((bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
,
165 static boolean is_unwind_section_name
166 PARAMS ((bfd
*abfd
, const char *));
167 static boolean elfNN_ia64_section_from_shdr
168 PARAMS ((bfd
*, ElfNN_Internal_Shdr
*, char *));
169 static boolean elfNN_ia64_section_flags
170 PARAMS ((flagword
*, ElfNN_Internal_Shdr
*));
171 static boolean elfNN_ia64_fake_sections
172 PARAMS ((bfd
*abfd
, ElfNN_Internal_Shdr
*hdr
, asection
*sec
));
173 static void elfNN_ia64_final_write_processing
174 PARAMS ((bfd
*abfd
, boolean linker
));
175 static boolean elfNN_ia64_add_symbol_hook
176 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, const Elf_Internal_Sym
*sym
,
177 const char **namep
, flagword
*flagsp
, asection
**secp
,
179 static boolean elfNN_ia64_aix_vec
180 PARAMS ((const bfd_target
*vec
));
181 static boolean elfNN_ia64_aix_add_symbol_hook
182 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, const Elf_Internal_Sym
*sym
,
183 const char **namep
, flagword
*flagsp
, asection
**secp
,
185 static boolean elfNN_ia64_aix_link_add_symbols
186 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
187 static int elfNN_ia64_additional_program_headers
188 PARAMS ((bfd
*abfd
));
189 static boolean elfNN_ia64_modify_segment_map
191 static boolean elfNN_ia64_is_local_label_name
192 PARAMS ((bfd
*abfd
, const char *name
));
193 static boolean elfNN_ia64_dynamic_symbol_p
194 PARAMS ((struct elf_link_hash_entry
*h
, struct bfd_link_info
*info
));
195 static boolean elfNN_ia64_local_hash_table_init
196 PARAMS ((struct elfNN_ia64_local_hash_table
*ht
, bfd
*abfd
,
197 new_hash_entry_func
new));
198 static struct bfd_hash_entry
*elfNN_ia64_new_loc_hash_entry
199 PARAMS ((struct bfd_hash_entry
*entry
, struct bfd_hash_table
*table
,
200 const char *string
));
201 static struct bfd_hash_entry
*elfNN_ia64_new_elf_hash_entry
202 PARAMS ((struct bfd_hash_entry
*entry
, struct bfd_hash_table
*table
,
203 const char *string
));
204 static void elfNN_ia64_hash_copy_indirect
205 PARAMS ((struct elf_link_hash_entry
*, struct elf_link_hash_entry
*));
206 static void elfNN_ia64_hash_hide_symbol
207 PARAMS ((struct bfd_link_info
*, struct elf_link_hash_entry
*, boolean
));
208 static struct bfd_link_hash_table
*elfNN_ia64_hash_table_create
209 PARAMS ((bfd
*abfd
));
210 static struct elfNN_ia64_local_hash_entry
*elfNN_ia64_local_hash_lookup
211 PARAMS ((struct elfNN_ia64_local_hash_table
*table
, const char *string
,
212 boolean create
, boolean copy
));
213 static boolean elfNN_ia64_global_dyn_sym_thunk
214 PARAMS ((struct bfd_hash_entry
*, PTR
));
215 static boolean elfNN_ia64_local_dyn_sym_thunk
216 PARAMS ((struct bfd_hash_entry
*, PTR
));
217 static void elfNN_ia64_dyn_sym_traverse
218 PARAMS ((struct elfNN_ia64_link_hash_table
*ia64_info
,
219 boolean (*func
) (struct elfNN_ia64_dyn_sym_info
*, PTR
),
221 static boolean elfNN_ia64_create_dynamic_sections
222 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
223 static struct elfNN_ia64_local_hash_entry
* get_local_sym_hash
224 PARAMS ((struct elfNN_ia64_link_hash_table
*ia64_info
,
225 bfd
*abfd
, const Elf_Internal_Rela
*rel
, boolean create
));
226 static struct elfNN_ia64_dyn_sym_info
* get_dyn_sym_info
227 PARAMS ((struct elfNN_ia64_link_hash_table
*ia64_info
,
228 struct elf_link_hash_entry
*h
,
229 bfd
*abfd
, const Elf_Internal_Rela
*rel
, boolean create
));
230 static asection
*get_got
231 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
232 struct elfNN_ia64_link_hash_table
*ia64_info
));
233 static asection
*get_fptr
234 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
235 struct elfNN_ia64_link_hash_table
*ia64_info
));
236 static asection
*get_pltoff
237 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
238 struct elfNN_ia64_link_hash_table
*ia64_info
));
239 static asection
*get_reloc_section
240 PARAMS ((bfd
*abfd
, struct elfNN_ia64_link_hash_table
*ia64_info
,
241 asection
*sec
, boolean create
));
242 static boolean count_dyn_reloc
243 PARAMS ((bfd
*abfd
, struct elfNN_ia64_dyn_sym_info
*dyn_i
,
244 asection
*srel
, int type
));
245 static boolean elfNN_ia64_check_relocs
246 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
247 const Elf_Internal_Rela
*relocs
));
248 static boolean elfNN_ia64_adjust_dynamic_symbol
249 PARAMS ((struct bfd_link_info
*info
, struct elf_link_hash_entry
*h
));
250 static long global_sym_index
251 PARAMS ((struct elf_link_hash_entry
*h
));
252 static boolean allocate_fptr
253 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
254 static boolean allocate_global_data_got
255 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
256 static boolean allocate_global_fptr_got
257 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
258 static boolean allocate_local_got
259 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
260 static boolean allocate_pltoff_entries
261 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
262 static boolean allocate_plt_entries
263 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
264 static boolean allocate_plt2_entries
265 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
266 static boolean allocate_dynrel_entries
267 PARAMS ((struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
));
268 static boolean elfNN_ia64_size_dynamic_sections
269 PARAMS ((bfd
*output_bfd
, struct bfd_link_info
*info
));
270 static bfd_reloc_status_type elfNN_ia64_install_value
271 PARAMS ((bfd
*abfd
, bfd_byte
*hit_addr
, bfd_vma val
, unsigned int r_type
));
272 static void elfNN_ia64_install_dyn_reloc
273 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
274 asection
*srel
, bfd_vma offset
, unsigned int type
,
275 long dynindx
, bfd_vma addend
));
276 static bfd_vma set_got_entry
277 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
278 struct elfNN_ia64_dyn_sym_info
*dyn_i
, long dynindx
,
279 bfd_vma addend
, bfd_vma value
, unsigned int dyn_r_type
));
280 static bfd_vma set_fptr_entry
281 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
282 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
284 static bfd_vma set_pltoff_entry
285 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
,
286 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
287 bfd_vma value
, boolean
));
288 static int elfNN_ia64_unwind_entry_compare
289 PARAMS ((const PTR
, const PTR
));
290 static boolean elfNN_ia64_final_link
291 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
292 static boolean elfNN_ia64_relocate_section
293 PARAMS ((bfd
*output_bfd
, struct bfd_link_info
*info
, bfd
*input_bfd
,
294 asection
*input_section
, bfd_byte
*contents
,
295 Elf_Internal_Rela
*relocs
, Elf_Internal_Sym
*local_syms
,
296 asection
**local_sections
));
297 static boolean elfNN_ia64_finish_dynamic_symbol
298 PARAMS ((bfd
*output_bfd
, struct bfd_link_info
*info
,
299 struct elf_link_hash_entry
*h
, Elf_Internal_Sym
*sym
));
300 static boolean elfNN_ia64_finish_dynamic_sections
301 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
302 static boolean elfNN_ia64_set_private_flags
303 PARAMS ((bfd
*abfd
, flagword flags
));
304 static boolean elfNN_ia64_merge_private_bfd_data
305 PARAMS ((bfd
*ibfd
, bfd
*obfd
));
306 static boolean elfNN_ia64_print_private_bfd_data
307 PARAMS ((bfd
*abfd
, PTR ptr
));
308 static enum elf_reloc_type_class elfNN_ia64_reloc_type_class
309 PARAMS ((const Elf_Internal_Rela
*));
310 static boolean elfNN_ia64_hpux_vec
311 PARAMS ((const bfd_target
*vec
));
312 static void elfNN_hpux_post_process_headers
313 PARAMS ((bfd
*abfd
, struct bfd_link_info
*info
));
314 boolean elfNN_hpux_backend_section_from_bfd_section
315 PARAMS ((bfd
*abfd
, asection
*sec
, int *retval
));
317 /* ia64-specific relocation */
319 /* Perform a relocation. Not much to do here as all the hard work is
320 done in elfNN_ia64_final_link_relocate. */
321 static bfd_reloc_status_type
322 elfNN_ia64_reloc (abfd
, reloc
, sym
, data
, input_section
,
323 output_bfd
, error_message
)
324 bfd
*abfd ATTRIBUTE_UNUSED
;
326 asymbol
*sym ATTRIBUTE_UNUSED
;
327 PTR data ATTRIBUTE_UNUSED
;
328 asection
*input_section
;
330 char **error_message
;
334 reloc
->address
+= input_section
->output_offset
;
337 *error_message
= "Unsupported call to elfNN_ia64_reloc";
338 return bfd_reloc_notsupported
;
341 #define IA64_HOWTO(TYPE, NAME, SIZE, PCREL, IN) \
342 HOWTO (TYPE, 0, SIZE, 0, PCREL, 0, complain_overflow_signed, \
343 elfNN_ia64_reloc, NAME, false, 0, 0, IN)
345 /* This table has to be sorted according to increasing number of the
347 static reloc_howto_type ia64_howto_table
[] =
349 IA64_HOWTO (R_IA64_NONE
, "NONE", 0, false, true),
351 IA64_HOWTO (R_IA64_IMM14
, "IMM14", 0, false, true),
352 IA64_HOWTO (R_IA64_IMM22
, "IMM22", 0, false, true),
353 IA64_HOWTO (R_IA64_IMM64
, "IMM64", 0, false, true),
354 IA64_HOWTO (R_IA64_DIR32MSB
, "DIR32MSB", 2, false, true),
355 IA64_HOWTO (R_IA64_DIR32LSB
, "DIR32LSB", 2, false, true),
356 IA64_HOWTO (R_IA64_DIR64MSB
, "DIR64MSB", 4, false, true),
357 IA64_HOWTO (R_IA64_DIR64LSB
, "DIR64LSB", 4, false, true),
359 IA64_HOWTO (R_IA64_GPREL22
, "GPREL22", 0, false, true),
360 IA64_HOWTO (R_IA64_GPREL64I
, "GPREL64I", 0, false, true),
361 IA64_HOWTO (R_IA64_GPREL32MSB
, "GPREL32MSB", 2, false, true),
362 IA64_HOWTO (R_IA64_GPREL32LSB
, "GPREL32LSB", 2, false, true),
363 IA64_HOWTO (R_IA64_GPREL64MSB
, "GPREL64MSB", 4, false, true),
364 IA64_HOWTO (R_IA64_GPREL64LSB
, "GPREL64LSB", 4, false, true),
366 IA64_HOWTO (R_IA64_LTOFF22
, "LTOFF22", 0, false, true),
367 IA64_HOWTO (R_IA64_LTOFF64I
, "LTOFF64I", 0, false, true),
369 IA64_HOWTO (R_IA64_PLTOFF22
, "PLTOFF22", 0, false, true),
370 IA64_HOWTO (R_IA64_PLTOFF64I
, "PLTOFF64I", 0, false, true),
371 IA64_HOWTO (R_IA64_PLTOFF64MSB
, "PLTOFF64MSB", 4, false, true),
372 IA64_HOWTO (R_IA64_PLTOFF64LSB
, "PLTOFF64LSB", 4, false, true),
374 IA64_HOWTO (R_IA64_FPTR64I
, "FPTR64I", 0, false, true),
375 IA64_HOWTO (R_IA64_FPTR32MSB
, "FPTR32MSB", 2, false, true),
376 IA64_HOWTO (R_IA64_FPTR32LSB
, "FPTR32LSB", 2, false, true),
377 IA64_HOWTO (R_IA64_FPTR64MSB
, "FPTR64MSB", 4, false, true),
378 IA64_HOWTO (R_IA64_FPTR64LSB
, "FPTR64LSB", 4, false, true),
380 IA64_HOWTO (R_IA64_PCREL60B
, "PCREL60B", 0, true, true),
381 IA64_HOWTO (R_IA64_PCREL21B
, "PCREL21B", 0, true, true),
382 IA64_HOWTO (R_IA64_PCREL21M
, "PCREL21M", 0, true, true),
383 IA64_HOWTO (R_IA64_PCREL21F
, "PCREL21F", 0, true, true),
384 IA64_HOWTO (R_IA64_PCREL32MSB
, "PCREL32MSB", 2, true, true),
385 IA64_HOWTO (R_IA64_PCREL32LSB
, "PCREL32LSB", 2, true, true),
386 IA64_HOWTO (R_IA64_PCREL64MSB
, "PCREL64MSB", 4, true, true),
387 IA64_HOWTO (R_IA64_PCREL64LSB
, "PCREL64LSB", 4, true, true),
389 IA64_HOWTO (R_IA64_LTOFF_FPTR22
, "LTOFF_FPTR22", 0, false, true),
390 IA64_HOWTO (R_IA64_LTOFF_FPTR64I
, "LTOFF_FPTR64I", 0, false, true),
391 IA64_HOWTO (R_IA64_LTOFF_FPTR32MSB
, "LTOFF_FPTR32MSB", 2, false, true),
392 IA64_HOWTO (R_IA64_LTOFF_FPTR32LSB
, "LTOFF_FPTR32LSB", 2, false, true),
393 IA64_HOWTO (R_IA64_LTOFF_FPTR64MSB
, "LTOFF_FPTR64MSB", 4, false, true),
394 IA64_HOWTO (R_IA64_LTOFF_FPTR64LSB
, "LTOFF_FPTR64LSB", 4, false, true),
396 IA64_HOWTO (R_IA64_SEGREL32MSB
, "SEGREL32MSB", 2, false, true),
397 IA64_HOWTO (R_IA64_SEGREL32LSB
, "SEGREL32LSB", 2, false, true),
398 IA64_HOWTO (R_IA64_SEGREL64MSB
, "SEGREL64MSB", 4, false, true),
399 IA64_HOWTO (R_IA64_SEGREL64LSB
, "SEGREL64LSB", 4, false, true),
401 IA64_HOWTO (R_IA64_SECREL32MSB
, "SECREL32MSB", 2, false, true),
402 IA64_HOWTO (R_IA64_SECREL32LSB
, "SECREL32LSB", 2, false, true),
403 IA64_HOWTO (R_IA64_SECREL64MSB
, "SECREL64MSB", 4, false, true),
404 IA64_HOWTO (R_IA64_SECREL64LSB
, "SECREL64LSB", 4, false, true),
406 IA64_HOWTO (R_IA64_REL32MSB
, "REL32MSB", 2, false, true),
407 IA64_HOWTO (R_IA64_REL32LSB
, "REL32LSB", 2, false, true),
408 IA64_HOWTO (R_IA64_REL64MSB
, "REL64MSB", 4, false, true),
409 IA64_HOWTO (R_IA64_REL64LSB
, "REL64LSB", 4, false, true),
411 IA64_HOWTO (R_IA64_LTV32MSB
, "LTV32MSB", 2, false, true),
412 IA64_HOWTO (R_IA64_LTV32LSB
, "LTV32LSB", 2, false, true),
413 IA64_HOWTO (R_IA64_LTV64MSB
, "LTV64MSB", 4, false, true),
414 IA64_HOWTO (R_IA64_LTV64LSB
, "LTV64LSB", 4, false, true),
416 IA64_HOWTO (R_IA64_PCREL21BI
, "PCREL21BI", 0, true, true),
417 IA64_HOWTO (R_IA64_PCREL22
, "PCREL22", 0, true, true),
418 IA64_HOWTO (R_IA64_PCREL64I
, "PCREL64I", 0, true, true),
420 IA64_HOWTO (R_IA64_IPLTMSB
, "IPLTMSB", 4, false, true),
421 IA64_HOWTO (R_IA64_IPLTLSB
, "IPLTLSB", 4, false, true),
422 IA64_HOWTO (R_IA64_COPY
, "COPY", 4, false, true),
423 IA64_HOWTO (R_IA64_LTOFF22X
, "LTOFF22X", 0, false, true),
424 IA64_HOWTO (R_IA64_LDXMOV
, "LDXMOV", 0, false, true),
426 IA64_HOWTO (R_IA64_TPREL22
, "TPREL22", 0, false, false),
427 IA64_HOWTO (R_IA64_TPREL64MSB
, "TPREL64MSB", 8, false, false),
428 IA64_HOWTO (R_IA64_TPREL64LSB
, "TPREL64LSB", 8, false, false),
429 IA64_HOWTO (R_IA64_LTOFF_TP22
, "LTOFF_TP22", 0, false, false),
432 static unsigned char elf_code_to_howto_index
[R_IA64_MAX_RELOC_CODE
+ 1];
434 /* Given a BFD reloc type, return the matching HOWTO structure. */
436 static reloc_howto_type
*
440 static int inited
= 0;
447 memset (elf_code_to_howto_index
, 0xff, sizeof (elf_code_to_howto_index
));
448 for (i
= 0; i
< NELEMS (ia64_howto_table
); ++i
)
449 elf_code_to_howto_index
[ia64_howto_table
[i
].type
] = i
;
452 BFD_ASSERT (rtype
<= R_IA64_MAX_RELOC_CODE
);
453 i
= elf_code_to_howto_index
[rtype
];
454 if (i
>= NELEMS (ia64_howto_table
))
456 return ia64_howto_table
+ i
;
459 static reloc_howto_type
*
460 elfNN_ia64_reloc_type_lookup (abfd
, bfd_code
)
461 bfd
*abfd ATTRIBUTE_UNUSED
;
462 bfd_reloc_code_real_type bfd_code
;
468 case BFD_RELOC_NONE
: rtype
= R_IA64_NONE
; break;
470 case BFD_RELOC_IA64_IMM14
: rtype
= R_IA64_IMM14
; break;
471 case BFD_RELOC_IA64_IMM22
: rtype
= R_IA64_IMM22
; break;
472 case BFD_RELOC_IA64_IMM64
: rtype
= R_IA64_IMM64
; break;
474 case BFD_RELOC_IA64_DIR32MSB
: rtype
= R_IA64_DIR32MSB
; break;
475 case BFD_RELOC_IA64_DIR32LSB
: rtype
= R_IA64_DIR32LSB
; break;
476 case BFD_RELOC_IA64_DIR64MSB
: rtype
= R_IA64_DIR64MSB
; break;
477 case BFD_RELOC_IA64_DIR64LSB
: rtype
= R_IA64_DIR64LSB
; break;
479 case BFD_RELOC_IA64_GPREL22
: rtype
= R_IA64_GPREL22
; break;
480 case BFD_RELOC_IA64_GPREL64I
: rtype
= R_IA64_GPREL64I
; break;
481 case BFD_RELOC_IA64_GPREL32MSB
: rtype
= R_IA64_GPREL32MSB
; break;
482 case BFD_RELOC_IA64_GPREL32LSB
: rtype
= R_IA64_GPREL32LSB
; break;
483 case BFD_RELOC_IA64_GPREL64MSB
: rtype
= R_IA64_GPREL64MSB
; break;
484 case BFD_RELOC_IA64_GPREL64LSB
: rtype
= R_IA64_GPREL64LSB
; break;
486 case BFD_RELOC_IA64_LTOFF22
: rtype
= R_IA64_LTOFF22
; break;
487 case BFD_RELOC_IA64_LTOFF64I
: rtype
= R_IA64_LTOFF64I
; break;
489 case BFD_RELOC_IA64_PLTOFF22
: rtype
= R_IA64_PLTOFF22
; break;
490 case BFD_RELOC_IA64_PLTOFF64I
: rtype
= R_IA64_PLTOFF64I
; break;
491 case BFD_RELOC_IA64_PLTOFF64MSB
: rtype
= R_IA64_PLTOFF64MSB
; break;
492 case BFD_RELOC_IA64_PLTOFF64LSB
: rtype
= R_IA64_PLTOFF64LSB
; break;
493 case BFD_RELOC_IA64_FPTR64I
: rtype
= R_IA64_FPTR64I
; break;
494 case BFD_RELOC_IA64_FPTR32MSB
: rtype
= R_IA64_FPTR32MSB
; break;
495 case BFD_RELOC_IA64_FPTR32LSB
: rtype
= R_IA64_FPTR32LSB
; break;
496 case BFD_RELOC_IA64_FPTR64MSB
: rtype
= R_IA64_FPTR64MSB
; break;
497 case BFD_RELOC_IA64_FPTR64LSB
: rtype
= R_IA64_FPTR64LSB
; break;
499 case BFD_RELOC_IA64_PCREL21B
: rtype
= R_IA64_PCREL21B
; break;
500 case BFD_RELOC_IA64_PCREL21BI
: rtype
= R_IA64_PCREL21BI
; break;
501 case BFD_RELOC_IA64_PCREL21M
: rtype
= R_IA64_PCREL21M
; break;
502 case BFD_RELOC_IA64_PCREL21F
: rtype
= R_IA64_PCREL21F
; break;
503 case BFD_RELOC_IA64_PCREL22
: rtype
= R_IA64_PCREL22
; break;
504 case BFD_RELOC_IA64_PCREL60B
: rtype
= R_IA64_PCREL60B
; break;
505 case BFD_RELOC_IA64_PCREL64I
: rtype
= R_IA64_PCREL64I
; break;
506 case BFD_RELOC_IA64_PCREL32MSB
: rtype
= R_IA64_PCREL32MSB
; break;
507 case BFD_RELOC_IA64_PCREL32LSB
: rtype
= R_IA64_PCREL32LSB
; break;
508 case BFD_RELOC_IA64_PCREL64MSB
: rtype
= R_IA64_PCREL64MSB
; break;
509 case BFD_RELOC_IA64_PCREL64LSB
: rtype
= R_IA64_PCREL64LSB
; break;
511 case BFD_RELOC_IA64_LTOFF_FPTR22
: rtype
= R_IA64_LTOFF_FPTR22
; break;
512 case BFD_RELOC_IA64_LTOFF_FPTR64I
: rtype
= R_IA64_LTOFF_FPTR64I
; break;
513 case BFD_RELOC_IA64_LTOFF_FPTR32MSB
: rtype
= R_IA64_LTOFF_FPTR32MSB
; break;
514 case BFD_RELOC_IA64_LTOFF_FPTR32LSB
: rtype
= R_IA64_LTOFF_FPTR32LSB
; break;
515 case BFD_RELOC_IA64_LTOFF_FPTR64MSB
: rtype
= R_IA64_LTOFF_FPTR64MSB
; break;
516 case BFD_RELOC_IA64_LTOFF_FPTR64LSB
: rtype
= R_IA64_LTOFF_FPTR64LSB
; break;
518 case BFD_RELOC_IA64_SEGREL32MSB
: rtype
= R_IA64_SEGREL32MSB
; break;
519 case BFD_RELOC_IA64_SEGREL32LSB
: rtype
= R_IA64_SEGREL32LSB
; break;
520 case BFD_RELOC_IA64_SEGREL64MSB
: rtype
= R_IA64_SEGREL64MSB
; break;
521 case BFD_RELOC_IA64_SEGREL64LSB
: rtype
= R_IA64_SEGREL64LSB
; break;
523 case BFD_RELOC_IA64_SECREL32MSB
: rtype
= R_IA64_SECREL32MSB
; break;
524 case BFD_RELOC_IA64_SECREL32LSB
: rtype
= R_IA64_SECREL32LSB
; break;
525 case BFD_RELOC_IA64_SECREL64MSB
: rtype
= R_IA64_SECREL64MSB
; break;
526 case BFD_RELOC_IA64_SECREL64LSB
: rtype
= R_IA64_SECREL64LSB
; break;
528 case BFD_RELOC_IA64_REL32MSB
: rtype
= R_IA64_REL32MSB
; break;
529 case BFD_RELOC_IA64_REL32LSB
: rtype
= R_IA64_REL32LSB
; break;
530 case BFD_RELOC_IA64_REL64MSB
: rtype
= R_IA64_REL64MSB
; break;
531 case BFD_RELOC_IA64_REL64LSB
: rtype
= R_IA64_REL64LSB
; break;
533 case BFD_RELOC_IA64_LTV32MSB
: rtype
= R_IA64_LTV32MSB
; break;
534 case BFD_RELOC_IA64_LTV32LSB
: rtype
= R_IA64_LTV32LSB
; break;
535 case BFD_RELOC_IA64_LTV64MSB
: rtype
= R_IA64_LTV64MSB
; break;
536 case BFD_RELOC_IA64_LTV64LSB
: rtype
= R_IA64_LTV64LSB
; break;
538 case BFD_RELOC_IA64_IPLTMSB
: rtype
= R_IA64_IPLTMSB
; break;
539 case BFD_RELOC_IA64_IPLTLSB
: rtype
= R_IA64_IPLTLSB
; break;
540 case BFD_RELOC_IA64_COPY
: rtype
= R_IA64_COPY
; break;
541 case BFD_RELOC_IA64_LTOFF22X
: rtype
= R_IA64_LTOFF22X
; break;
542 case BFD_RELOC_IA64_LDXMOV
: rtype
= R_IA64_LDXMOV
; break;
544 case BFD_RELOC_IA64_TPREL22
: rtype
= R_IA64_TPREL22
; break;
545 case BFD_RELOC_IA64_TPREL64MSB
: rtype
= R_IA64_TPREL64MSB
; break;
546 case BFD_RELOC_IA64_TPREL64LSB
: rtype
= R_IA64_TPREL64LSB
; break;
547 case BFD_RELOC_IA64_LTOFF_TP22
: rtype
= R_IA64_LTOFF_TP22
; break;
551 return lookup_howto (rtype
);
554 /* Given a ELF reloc, return the matching HOWTO structure. */
557 elfNN_ia64_info_to_howto (abfd
, bfd_reloc
, elf_reloc
)
558 bfd
*abfd ATTRIBUTE_UNUSED
;
560 ElfNN_Internal_Rela
*elf_reloc
;
563 = lookup_howto ((unsigned int) ELFNN_R_TYPE (elf_reloc
->r_info
));
566 #define PLT_HEADER_SIZE (3 * 16)
567 #define PLT_MIN_ENTRY_SIZE (1 * 16)
568 #define PLT_FULL_ENTRY_SIZE (2 * 16)
569 #define PLT_RESERVED_WORDS 3
571 static const bfd_byte plt_header
[PLT_HEADER_SIZE
] =
573 0x0b, 0x10, 0x00, 0x1c, 0x00, 0x21, /* [MMI] mov r2=r14;; */
574 0xe0, 0x00, 0x08, 0x00, 0x48, 0x00, /* addl r14=0,r2 */
575 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
576 0x0b, 0x80, 0x20, 0x1c, 0x18, 0x14, /* [MMI] ld8 r16=[r14],8;; */
577 0x10, 0x41, 0x38, 0x30, 0x28, 0x00, /* ld8 r17=[r14],8 */
578 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
579 0x11, 0x08, 0x00, 0x1c, 0x18, 0x10, /* [MIB] ld8 r1=[r14] */
580 0x60, 0x88, 0x04, 0x80, 0x03, 0x00, /* mov b6=r17 */
581 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
584 static const bfd_byte plt_min_entry
[PLT_MIN_ENTRY_SIZE
] =
586 0x11, 0x78, 0x00, 0x00, 0x00, 0x24, /* [MIB] mov r15=0 */
587 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, /* nop.i 0x0 */
588 0x00, 0x00, 0x00, 0x40 /* br.few 0 <PLT0>;; */
591 static const bfd_byte plt_full_entry
[PLT_FULL_ENTRY_SIZE
] =
593 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
594 0x00, 0x41, 0x3c, 0x30, 0x28, 0xc0, /* ld8 r16=[r15],8 */
595 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
596 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
597 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
598 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
601 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
602 #define AIX_DYNAMIC_INTERPRETER "/usr/lib/ia64l64/libc.so.1"
603 #define DYNAMIC_INTERPRETER(abfd) \
604 (elfNN_ia64_aix_vec (abfd->xvec) ? AIX_DYNAMIC_INTERPRETER : ELF_DYNAMIC_INTERPRETER)
606 /* Select out of range branch fixup type. Note that Itanium does
607 not support brl, and so it gets emulated by the kernel. */
610 static const bfd_byte oor_brl
[16] =
612 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
613 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;; */
614 0x00, 0x00, 0x00, 0xc0
617 static const bfd_byte oor_ip
[48] =
619 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
620 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, /* movl r15=0 */
621 0x01, 0x00, 0x00, 0x60,
622 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MII] nop.m 0 */
623 0x00, 0x01, 0x00, 0x60, 0x00, 0x00, /* mov r16=ip;; */
624 0xf2, 0x80, 0x00, 0x80, /* add r16=r15,r16;; */
625 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MIB] nop.m 0 */
626 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
627 0x60, 0x00, 0x80, 0x00 /* br b6;; */
630 /* These functions do relaxation for IA-64 ELF.
632 This is primarily to support branches to targets out of range;
633 relaxation of R_IA64_LTOFF22X and R_IA64_LDXMOV not yet supported. */
636 elfNN_ia64_relax_section (abfd
, sec
, link_info
, again
)
639 struct bfd_link_info
*link_info
;
644 struct one_fixup
*next
;
650 Elf_Internal_Shdr
*symtab_hdr
;
651 Elf_Internal_Shdr
*shndx_hdr
;
652 Elf_Internal_Rela
*internal_relocs
;
653 Elf_Internal_Rela
*free_relocs
= NULL
;
654 Elf_Internal_Rela
*irel
, *irelend
;
656 bfd_byte
*free_contents
= NULL
;
657 ElfNN_External_Sym
*extsyms
;
658 ElfNN_External_Sym
*free_extsyms
= NULL
;
659 Elf_External_Sym_Shndx
*shndx_buf
= NULL
;
660 struct elfNN_ia64_link_hash_table
*ia64_info
;
661 struct one_fixup
*fixups
= NULL
;
662 boolean changed_contents
= false;
663 boolean changed_relocs
= false;
665 /* Assume we're not going to change any sizes, and we'll only need
669 /* Nothing to do if there are no relocations. */
670 if ((sec
->flags
& SEC_RELOC
) == 0
671 || sec
->reloc_count
== 0)
674 /* If this is the first time we have been called for this section,
675 initialize the cooked size. */
676 if (sec
->_cooked_size
== 0)
677 sec
->_cooked_size
= sec
->_raw_size
;
679 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
681 /* Load the relocations for this section. */
682 internal_relocs
= (_bfd_elfNN_link_read_relocs
683 (abfd
, sec
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
684 link_info
->keep_memory
));
685 if (internal_relocs
== NULL
)
688 if (! link_info
->keep_memory
)
689 free_relocs
= internal_relocs
;
691 ia64_info
= elfNN_ia64_hash_table (link_info
);
692 irelend
= internal_relocs
+ sec
->reloc_count
;
694 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
695 if (ELFNN_R_TYPE (irel
->r_info
) == (int) R_IA64_PCREL21B
)
698 /* No branch-type relocations. */
701 if (free_relocs
!= NULL
)
706 /* Get the section contents. */
707 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
708 contents
= elf_section_data (sec
)->this_hdr
.contents
;
711 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
712 if (contents
== NULL
)
714 free_contents
= contents
;
716 if (! bfd_get_section_contents (abfd
, sec
, contents
,
717 (file_ptr
) 0, sec
->_raw_size
))
721 /* Read this BFD's local symbols. */
722 if (symtab_hdr
->contents
!= NULL
)
723 extsyms
= (ElfNN_External_Sym
*) symtab_hdr
->contents
;
728 amt
= symtab_hdr
->sh_info
* sizeof (ElfNN_External_Sym
);
729 extsyms
= (ElfNN_External_Sym
*) bfd_malloc (amt
);
732 free_extsyms
= extsyms
;
733 if (bfd_seek (abfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
734 || bfd_bread (extsyms
, amt
, abfd
) != amt
)
738 shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
739 if (shndx_hdr
->sh_size
!= 0)
743 amt
= symtab_hdr
->sh_info
* sizeof (Elf_External_Sym_Shndx
);
744 shndx_buf
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
745 if (shndx_buf
== NULL
)
747 if (bfd_seek (abfd
, shndx_hdr
->sh_offset
, SEEK_SET
) != 0
748 || bfd_bread (shndx_buf
, amt
, abfd
) != amt
)
752 for (; irel
< irelend
; irel
++)
754 bfd_vma symaddr
, reladdr
, trampoff
, toff
, roff
;
755 Elf_Internal_Sym isym
;
760 if (ELFNN_R_TYPE (irel
->r_info
) != (int) R_IA64_PCREL21B
)
763 /* Get the value of the symbol referred to by the reloc. */
764 if (ELFNN_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
766 ElfNN_External_Sym
*esym
;
767 Elf_External_Sym_Shndx
*shndx
;
769 /* A local symbol. */
770 esym
= extsyms
+ ELFNN_R_SYM (irel
->r_info
);
771 shndx
= shndx_buf
+ (shndx_buf
? ELFNN_R_SYM (irel
->r_info
) : 0);
772 bfd_elfNN_swap_symbol_in (abfd
, esym
, shndx
, &isym
);
773 if (isym
.st_shndx
== SHN_UNDEF
)
774 continue; /* We can't do anthing with undefined symbols. */
775 else if (isym
.st_shndx
== SHN_ABS
)
776 tsec
= bfd_abs_section_ptr
;
777 else if (isym
.st_shndx
== SHN_COMMON
)
778 tsec
= bfd_com_section_ptr
;
779 else if (isym
.st_shndx
== SHN_IA_64_ANSI_COMMON
)
780 tsec
= bfd_com_section_ptr
;
782 tsec
= bfd_section_from_elf_index (abfd
, isym
.st_shndx
);
784 toff
= isym
.st_value
;
789 struct elf_link_hash_entry
*h
;
790 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
792 indx
= ELFNN_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
793 h
= elf_sym_hashes (abfd
)[indx
];
794 BFD_ASSERT (h
!= NULL
);
796 while (h
->root
.type
== bfd_link_hash_indirect
797 || h
->root
.type
== bfd_link_hash_warning
)
798 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
800 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, irel
, false);
802 /* For branches to dynamic symbols, we're interested instead
803 in a branch to the PLT entry. */
804 if (dyn_i
&& dyn_i
->want_plt2
)
806 tsec
= ia64_info
->plt_sec
;
807 toff
= dyn_i
->plt2_offset
;
811 /* We can't do anthing with undefined symbols. */
812 if (h
->root
.type
== bfd_link_hash_undefined
813 || h
->root
.type
== bfd_link_hash_undefweak
)
816 tsec
= h
->root
.u
.def
.section
;
817 toff
= h
->root
.u
.def
.value
;
821 symaddr
= (tsec
->output_section
->vma
822 + tsec
->output_offset
826 roff
= irel
->r_offset
;
827 reladdr
= (sec
->output_section
->vma
829 + roff
) & (bfd_vma
) -4;
831 /* If the branch is in range, no need to do anything. */
832 if ((bfd_signed_vma
) (symaddr
- reladdr
) >= -0x1000000
833 && (bfd_signed_vma
) (symaddr
- reladdr
) <= 0x0FFFFF0)
836 /* If the branch and target are in the same section, you've
837 got one honking big section and we can't help you. You'll
838 get an error message later. */
842 /* Look for an existing fixup to this address. */
843 for (f
= fixups
; f
; f
= f
->next
)
844 if (f
->tsec
== tsec
&& f
->toff
== toff
)
849 /* Two alternatives: If it's a branch to a PLT entry, we can
850 make a copy of the FULL_PLT entry. Otherwise, we'll have
851 to use a `brl' insn to get where we're going. */
855 if (tsec
== ia64_info
->plt_sec
)
856 size
= sizeof (plt_full_entry
);
860 size
= sizeof (oor_brl
);
862 size
= sizeof (oor_ip
);
866 /* Resize the current section to make room for the new branch. */
867 trampoff
= (sec
->_cooked_size
+ 15) & (bfd_vma
) -16;
868 amt
= trampoff
+ size
;
869 contents
= (bfd_byte
*) bfd_realloc (contents
, amt
);
870 if (contents
== NULL
)
872 sec
->_cooked_size
= amt
;
874 if (tsec
== ia64_info
->plt_sec
)
876 memcpy (contents
+ trampoff
, plt_full_entry
, size
);
878 /* Hijack the old relocation for use as the PLTOFF reloc. */
879 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
881 irel
->r_offset
= trampoff
;
886 memcpy (contents
+ trampoff
, oor_brl
, size
);
887 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
889 irel
->r_offset
= trampoff
+ 2;
891 memcpy (contents
+ trampoff
, oor_ip
, size
);
892 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
894 irel
->r_addend
-= 16;
895 irel
->r_offset
= trampoff
+ 2;
899 /* Record the fixup so we don't do it again this section. */
900 f
= (struct one_fixup
*) bfd_malloc ((bfd_size_type
) sizeof (*f
));
904 f
->trampoff
= trampoff
;
909 /* Nop out the reloc, since we're finalizing things here. */
910 irel
->r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
913 /* Fix up the existing branch to hit the trampoline. Hope like
914 hell this doesn't overflow too. */
915 if (elfNN_ia64_install_value (abfd
, contents
+ roff
,
916 f
->trampoff
- (roff
& (bfd_vma
) -4),
917 R_IA64_PCREL21B
) != bfd_reloc_ok
)
920 changed_contents
= true;
921 changed_relocs
= true;
924 /* Clean up and go home. */
927 struct one_fixup
*f
= fixups
;
928 fixups
= fixups
->next
;
933 elf_section_data (sec
)->relocs
= internal_relocs
;
934 else if (free_relocs
!= NULL
)
937 if (changed_contents
)
938 elf_section_data (sec
)->this_hdr
.contents
= contents
;
939 else if (free_contents
!= NULL
)
941 if (! link_info
->keep_memory
)
942 free (free_contents
);
945 /* Cache the section contents for elf_link_input_bfd. */
946 elf_section_data (sec
)->this_hdr
.contents
= contents
;
950 if (shndx_buf
!= NULL
)
953 if (free_extsyms
!= NULL
)
955 if (! link_info
->keep_memory
)
959 /* Cache the symbols for elf_link_input_bfd. */
960 symtab_hdr
->contents
= (unsigned char *) extsyms
;
964 *again
= changed_contents
|| changed_relocs
;
968 if (free_relocs
!= NULL
)
970 if (free_contents
!= NULL
)
971 free (free_contents
);
972 if (shndx_buf
!= NULL
)
974 if (free_extsyms
!= NULL
)
979 /* Return true if NAME is an unwind table section name. */
981 static inline boolean
982 is_unwind_section_name (abfd
, name
)
986 size_t len1
, len2
, len3
;
988 if (elfNN_ia64_hpux_vec (abfd
->xvec
)
989 && !strcmp (name
, ELF_STRING_ia64_unwind_hdr
))
992 len1
= sizeof (ELF_STRING_ia64_unwind
) - 1;
993 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
994 len3
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
995 return ((strncmp (name
, ELF_STRING_ia64_unwind
, len1
) == 0
996 && strncmp (name
, ELF_STRING_ia64_unwind_info
, len2
) != 0)
997 || strncmp (name
, ELF_STRING_ia64_unwind_once
, len3
) == 0);
1000 /* Handle an IA-64 specific section when reading an object file. This
1001 is called when elfcode.h finds a section with an unknown type. */
1004 elfNN_ia64_section_from_shdr (abfd
, hdr
, name
)
1006 ElfNN_Internal_Shdr
*hdr
;
1011 /* There ought to be a place to keep ELF backend specific flags, but
1012 at the moment there isn't one. We just keep track of the
1013 sections by their name, instead. Fortunately, the ABI gives
1014 suggested names for all the MIPS specific sections, so we will
1015 probably get away with this. */
1016 switch (hdr
->sh_type
)
1018 case SHT_IA_64_UNWIND
:
1019 case SHT_IA_64_HP_OPT_ANOT
:
1023 if (strcmp (name
, ELF_STRING_ia64_archext
) != 0)
1031 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
))
1033 newsect
= hdr
->bfd_section
;
1038 /* Convert IA-64 specific section flags to bfd internal section flags. */
1040 /* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
1044 elfNN_ia64_section_flags (flags
, hdr
)
1046 ElfNN_Internal_Shdr
*hdr
;
1048 if (hdr
->sh_flags
& SHF_IA_64_SHORT
)
1049 *flags
|= SEC_SMALL_DATA
;
1054 /* Set the correct type for an IA-64 ELF section. We do this by the
1055 section name, which is a hack, but ought to work. */
1058 elfNN_ia64_fake_sections (abfd
, hdr
, sec
)
1059 bfd
*abfd ATTRIBUTE_UNUSED
;
1060 ElfNN_Internal_Shdr
*hdr
;
1063 register const char *name
;
1065 name
= bfd_get_section_name (abfd
, sec
);
1067 if (is_unwind_section_name (abfd
, name
))
1069 /* We don't have the sections numbered at this point, so sh_info
1070 is set later, in elfNN_ia64_final_write_processing. */
1071 hdr
->sh_type
= SHT_IA_64_UNWIND
;
1072 hdr
->sh_flags
|= SHF_LINK_ORDER
;
1074 else if (strcmp (name
, ELF_STRING_ia64_archext
) == 0)
1075 hdr
->sh_type
= SHT_IA_64_EXT
;
1076 else if (strcmp (name
, ".HP.opt_annot") == 0)
1077 hdr
->sh_type
= SHT_IA_64_HP_OPT_ANOT
;
1078 else if (strcmp (name
, ".reloc") == 0)
1080 * This is an ugly, but unfortunately necessary hack that is
1081 * needed when producing EFI binaries on IA-64. It tells
1082 * elf.c:elf_fake_sections() not to consider ".reloc" as a section
1083 * containing ELF relocation info. We need this hack in order to
1084 * be able to generate ELF binaries that can be translated into
1085 * EFI applications (which are essentially COFF objects). Those
1086 * files contain a COFF ".reloc" section inside an ELFNN object,
1087 * which would normally cause BFD to segfault because it would
1088 * attempt to interpret this section as containing relocation
1089 * entries for section "oc". With this hack enabled, ".reloc"
1090 * will be treated as a normal data section, which will avoid the
1091 * segfault. However, you won't be able to create an ELFNN binary
1092 * with a section named "oc" that needs relocations, but that's
1093 * the kind of ugly side-effects you get when detecting section
1094 * types based on their names... In practice, this limitation is
1097 hdr
->sh_type
= SHT_PROGBITS
;
1099 if (sec
->flags
& SEC_SMALL_DATA
)
1100 hdr
->sh_flags
|= SHF_IA_64_SHORT
;
1105 /* The final processing done just before writing out an IA-64 ELF
1109 elfNN_ia64_final_write_processing (abfd
, linker
)
1111 boolean linker ATTRIBUTE_UNUSED
;
1113 Elf_Internal_Shdr
*hdr
;
1115 asection
*text_sect
, *s
;
1118 for (s
= abfd
->sections
; s
; s
= s
->next
)
1120 hdr
= &elf_section_data (s
)->this_hdr
;
1121 switch (hdr
->sh_type
)
1123 case SHT_IA_64_UNWIND
:
1124 /* See comments in gas/config/tc-ia64.c:dot_endp on why we
1126 sname
= bfd_get_section_name (abfd
, s
);
1127 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
1128 if (sname
&& strncmp (sname
, ELF_STRING_ia64_unwind
, len
) == 0)
1132 if (sname
[0] == '\0')
1133 /* .IA_64.unwind -> .text */
1134 text_sect
= bfd_get_section_by_name (abfd
, ".text");
1136 /* .IA_64.unwindFOO -> FOO */
1137 text_sect
= bfd_get_section_by_name (abfd
, sname
);
1140 && (len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1,
1141 strncmp (sname
, ELF_STRING_ia64_unwind_once
, len
)) == 0)
1143 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.t.FOO */
1144 size_t len2
= sizeof (".gnu.linkonce.t.") - 1;
1145 char *once_name
= bfd_malloc (len2
+ strlen (sname
+ len
) + 1);
1147 if (once_name
!= NULL
)
1149 memcpy (once_name
, ".gnu.linkonce.t.", len2
);
1150 strcpy (once_name
+ len2
, sname
+ len
);
1151 text_sect
= bfd_get_section_by_name (abfd
, once_name
);
1155 /* Should only happen if we run out of memory, in
1156 which case we're probably toast anyway. Try to
1157 cope by finding the section the slow way. */
1158 for (text_sect
= abfd
->sections
;
1160 text_sect
= text_sect
->next
)
1162 if (strncmp (bfd_section_name (abfd
, text_sect
),
1163 ".gnu.linkonce.t.", len2
) == 0
1164 && strcmp (bfd_section_name (abfd
, text_sect
) + len2
,
1170 /* last resort: fall back on .text */
1171 text_sect
= bfd_get_section_by_name (abfd
, ".text");
1175 /* The IA-64 processor-specific ABI requires setting
1176 sh_link to the unwind section, whereas HP-UX requires
1177 sh_info to do so. For maximum compatibility, we'll
1178 set both for now... */
1179 hdr
->sh_link
= elf_section_data (text_sect
)->this_idx
;
1180 hdr
->sh_info
= elf_section_data (text_sect
)->this_idx
;
1187 /* Hook called by the linker routine which adds symbols from an object
1188 file. We use it to put .comm items in .sbss, and not .bss. */
1191 elfNN_ia64_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
1193 struct bfd_link_info
*info
;
1194 const Elf_Internal_Sym
*sym
;
1195 const char **namep ATTRIBUTE_UNUSED
;
1196 flagword
*flagsp ATTRIBUTE_UNUSED
;
1200 if (sym
->st_shndx
== SHN_COMMON
1201 && !info
->relocateable
1202 && sym
->st_size
<= elf_gp_size (abfd
))
1204 /* Common symbols less than or equal to -G nn bytes are
1205 automatically put into .sbss. */
1207 asection
*scomm
= bfd_get_section_by_name (abfd
, ".scommon");
1211 scomm
= bfd_make_section (abfd
, ".scommon");
1213 || !bfd_set_section_flags (abfd
, scomm
, (SEC_ALLOC
1215 | SEC_LINKER_CREATED
)))
1220 *valp
= sym
->st_size
;
1227 elfNN_ia64_aix_vec (const bfd_target
*vec
)
1229 extern const bfd_target bfd_elfNN_ia64_aix_little_vec
;
1230 extern const bfd_target bfd_elfNN_ia64_aix_big_vec
;
1232 return (/**/vec
== & bfd_elfNN_ia64_aix_little_vec
1233 || vec
== & bfd_elfNN_ia64_aix_big_vec
);
1236 /* Hook called by the linker routine which adds symbols from an object
1237 file. We use it to handle OS-specific symbols. */
1240 elfNN_ia64_aix_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
, secp
, valp
)
1242 struct bfd_link_info
*info
;
1243 const Elf_Internal_Sym
*sym
;
1249 if (strcmp (*namep
, "__GLOB_DATA_PTR") == 0)
1251 /* Define __GLOB_DATA_PTR when it is encountered. This is expected to
1252 be a linker-defined symbol by the Aix C runtime startup code. IBM sez
1253 no one else should use it b/c it is undocumented. */
1254 struct elf_link_hash_entry
*h
;
1256 h
= elf_link_hash_lookup (elf_hash_table (info
), *namep
,
1257 false, false, false);
1260 struct elf_backend_data
*bed
;
1261 struct elfNN_ia64_link_hash_table
*ia64_info
;
1263 bed
= get_elf_backend_data (abfd
);
1264 ia64_info
= elfNN_ia64_hash_table (info
);
1266 if (!(_bfd_generic_link_add_one_symbol
1267 (info
, abfd
, *namep
, BSF_GLOBAL
,
1268 bfd_get_section_by_name (abfd
, ".bss"),
1269 bed
->got_symbol_offset
, (const char *) NULL
, false,
1270 bed
->collect
, (struct bfd_link_hash_entry
**) &h
)))
1273 h
->elf_link_hash_flags
|= ELF_LINK_HASH_DEF_REGULAR
;
1274 h
->type
= STT_OBJECT
;
1276 if (! _bfd_elf_link_record_dynamic_symbol (info
, h
))
1282 else if (sym
->st_shndx
== SHN_LOOS
)
1286 /* SHN_AIX_SYSCALL: Treat this as any other symbol. The special symbol
1287 is only relevant when compiling code for extended system calls.
1288 Replace the "special" section with .text, if possible.
1289 Note that these symbols are always assumed to be in .text. */
1290 for (i
= 1; i
< elf_numsections (abfd
); i
++)
1292 asection
* sec
= bfd_section_from_elf_index (abfd
, i
);
1294 if (sec
&& strcmp (sec
->name
, ".text") == 0)
1302 *secp
= bfd_abs_section_ptr
;
1304 *valp
= sym
->st_size
;
1310 return elfNN_ia64_add_symbol_hook (abfd
, info
, sym
,
1311 namep
, flagsp
, secp
, valp
);
1316 elfNN_ia64_aix_link_add_symbols (abfd
, info
)
1318 struct bfd_link_info
*info
;
1320 /* Make sure dynamic sections are always created. */
1321 if (! elf_hash_table (info
)->dynamic_sections_created
1322 && abfd
->xvec
== info
->hash
->creator
)
1324 if (! bfd_elfNN_link_create_dynamic_sections (abfd
, info
))
1328 /* Now do the standard call. */
1329 return bfd_elfNN_bfd_link_add_symbols (abfd
, info
);
1332 /* Return the number of additional phdrs we will need. */
1335 elfNN_ia64_additional_program_headers (abfd
)
1341 /* See if we need a PT_IA_64_ARCHEXT segment. */
1342 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_archext
);
1343 if (s
&& (s
->flags
& SEC_LOAD
))
1346 /* Count how many PT_IA_64_UNWIND segments we need. */
1347 for (s
= abfd
->sections
; s
; s
= s
->next
)
1348 if (is_unwind_section_name (abfd
, s
->name
) && (s
->flags
& SEC_LOAD
))
1355 elfNN_ia64_modify_segment_map (abfd
)
1358 struct elf_segment_map
*m
, **pm
;
1359 Elf_Internal_Shdr
*hdr
;
1361 boolean unwind_found
;
1362 asection
*unwind_sec
;
1364 /* If we need a PT_IA_64_ARCHEXT segment, it must come before
1365 all PT_LOAD segments. */
1366 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_archext
);
1367 if (s
&& (s
->flags
& SEC_LOAD
))
1369 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1370 if (m
->p_type
== PT_IA_64_ARCHEXT
)
1374 m
= ((struct elf_segment_map
*)
1375 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *m
));
1379 m
->p_type
= PT_IA_64_ARCHEXT
;
1383 /* We want to put it after the PHDR and INTERP segments. */
1384 pm
= &elf_tdata (abfd
)->segment_map
;
1386 && ((*pm
)->p_type
== PT_PHDR
1387 || (*pm
)->p_type
== PT_INTERP
))
1395 /* Install PT_IA_64_UNWIND segments, if needed. */
1396 for (s
= abfd
->sections
; s
; s
= s
->next
)
1398 hdr
= &elf_section_data (s
)->this_hdr
;
1399 if (hdr
->sh_type
!= SHT_IA_64_UNWIND
)
1402 if (s
&& (s
->flags
& SEC_LOAD
))
1404 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1405 if (m
->p_type
== PT_IA_64_UNWIND
)
1407 /* Look through all sections in the unwind segment
1408 for a match since there may be multiple sections
1411 unwind_sec
= m
->sections
[0];
1412 unwind_found
= false;
1413 while (unwind_sec
!= NULL
&& !unwind_found
)
1415 if (unwind_sec
== s
)
1416 unwind_found
= true;
1418 unwind_sec
= unwind_sec
-> next
;
1426 m
= ((struct elf_segment_map
*)
1427 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *m
));
1431 m
->p_type
= PT_IA_64_UNWIND
;
1436 /* We want to put it last. */
1437 pm
= &elf_tdata (abfd
)->segment_map
;
1445 /* Turn on PF_IA_64_NORECOV if needed. This involves traversing all of
1446 the input sections for each output section in the segment and testing
1447 for SHF_IA_64_NORECOV on each. */
1448 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1449 if (m
->p_type
== PT_LOAD
)
1452 for (i
= m
->count
- 1; i
>= 0; --i
)
1454 struct bfd_link_order
*order
= m
->sections
[i
]->link_order_head
;
1457 if (order
->type
== bfd_indirect_link_order
)
1459 asection
*is
= order
->u
.indirect
.section
;
1460 bfd_vma flags
= elf_section_data(is
)->this_hdr
.sh_flags
;
1461 if (flags
& SHF_IA_64_NORECOV
)
1463 m
->p_flags
|= PF_IA_64_NORECOV
;
1467 order
= order
->next
;
1476 /* According to the Tahoe assembler spec, all labels starting with a
1480 elfNN_ia64_is_local_label_name (abfd
, name
)
1481 bfd
*abfd ATTRIBUTE_UNUSED
;
1484 return name
[0] == '.';
1487 /* Should we do dynamic things to this symbol? */
1490 elfNN_ia64_dynamic_symbol_p (h
, info
)
1491 struct elf_link_hash_entry
*h
;
1492 struct bfd_link_info
*info
;
1497 while (h
->root
.type
== bfd_link_hash_indirect
1498 || h
->root
.type
== bfd_link_hash_warning
)
1499 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1501 if (h
->dynindx
== -1)
1503 switch (ELF_ST_VISIBILITY (h
->other
))
1510 if (h
->root
.type
== bfd_link_hash_undefweak
1511 || h
->root
.type
== bfd_link_hash_defweak
)
1514 if ((info
->shared
&& (!info
->symbolic
|| info
->allow_shlib_undefined
))
1515 || ((h
->elf_link_hash_flags
1516 & (ELF_LINK_HASH_DEF_DYNAMIC
| ELF_LINK_HASH_REF_REGULAR
))
1517 == (ELF_LINK_HASH_DEF_DYNAMIC
| ELF_LINK_HASH_REF_REGULAR
)))
1524 elfNN_ia64_local_hash_table_init (ht
, abfd
, new)
1525 struct elfNN_ia64_local_hash_table
*ht
;
1526 bfd
*abfd ATTRIBUTE_UNUSED
;
1527 new_hash_entry_func
new;
1529 memset (ht
, 0, sizeof (*ht
));
1530 return bfd_hash_table_init (&ht
->root
, new);
1533 static struct bfd_hash_entry
*
1534 elfNN_ia64_new_loc_hash_entry (entry
, table
, string
)
1535 struct bfd_hash_entry
*entry
;
1536 struct bfd_hash_table
*table
;
1539 struct elfNN_ia64_local_hash_entry
*ret
;
1540 ret
= (struct elfNN_ia64_local_hash_entry
*) entry
;
1542 /* Allocate the structure if it has not already been allocated by a
1545 ret
= bfd_hash_allocate (table
, sizeof (*ret
));
1550 /* Initialize our local data. All zeros, and definitely easier
1551 than setting a handful of bit fields. */
1552 memset (ret
, 0, sizeof (*ret
));
1554 /* Call the allocation method of the superclass. */
1555 ret
= ((struct elfNN_ia64_local_hash_entry
*)
1556 bfd_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
1558 return (struct bfd_hash_entry
*) ret
;
1561 static struct bfd_hash_entry
*
1562 elfNN_ia64_new_elf_hash_entry (entry
, table
, string
)
1563 struct bfd_hash_entry
*entry
;
1564 struct bfd_hash_table
*table
;
1567 struct elfNN_ia64_link_hash_entry
*ret
;
1568 ret
= (struct elfNN_ia64_link_hash_entry
*) entry
;
1570 /* Allocate the structure if it has not already been allocated by a
1573 ret
= bfd_hash_allocate (table
, sizeof (*ret
));
1578 /* Initialize our local data. All zeros, and definitely easier
1579 than setting a handful of bit fields. */
1580 memset (ret
, 0, sizeof (*ret
));
1582 /* Call the allocation method of the superclass. */
1583 ret
= ((struct elfNN_ia64_link_hash_entry
*)
1584 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
1587 return (struct bfd_hash_entry
*) ret
;
1591 elfNN_ia64_hash_copy_indirect (xdir
, xind
)
1592 struct elf_link_hash_entry
*xdir
, *xind
;
1594 struct elfNN_ia64_link_hash_entry
*dir
, *ind
;
1596 dir
= (struct elfNN_ia64_link_hash_entry
*) xdir
;
1597 ind
= (struct elfNN_ia64_link_hash_entry
*) xind
;
1599 /* Copy down any references that we may have already seen to the
1600 symbol which just became indirect. */
1602 dir
->root
.elf_link_hash_flags
|=
1603 (ind
->root
.elf_link_hash_flags
1604 & (ELF_LINK_HASH_REF_DYNAMIC
1605 | ELF_LINK_HASH_REF_REGULAR
1606 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
));
1608 if (ind
->root
.root
.type
!= bfd_link_hash_indirect
)
1611 /* Copy over the got and plt data. This would have been done
1614 if (dir
->info
== NULL
)
1616 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1618 dir
->info
= dyn_i
= ind
->info
;
1621 /* Fix up the dyn_sym_info pointers to the global symbol. */
1622 for (; dyn_i
; dyn_i
= dyn_i
->next
)
1623 dyn_i
->h
= &dir
->root
;
1625 BFD_ASSERT (ind
->info
== NULL
);
1627 /* Copy over the dynindx. */
1629 if (dir
->root
.dynindx
== -1)
1631 dir
->root
.dynindx
= ind
->root
.dynindx
;
1632 dir
->root
.dynstr_index
= ind
->root
.dynstr_index
;
1633 ind
->root
.dynindx
= -1;
1634 ind
->root
.dynstr_index
= 0;
1636 BFD_ASSERT (ind
->root
.dynindx
== -1);
1640 elfNN_ia64_hash_hide_symbol (info
, xh
, force_local
)
1641 struct bfd_link_info
*info
;
1642 struct elf_link_hash_entry
*xh
;
1643 boolean force_local
;
1645 struct elfNN_ia64_link_hash_entry
*h
;
1646 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1648 h
= (struct elfNN_ia64_link_hash_entry
*)xh
;
1650 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
1652 for (dyn_i
= h
->info
; dyn_i
; dyn_i
= dyn_i
->next
)
1653 dyn_i
->want_plt2
= 0;
1656 /* Create the derived linker hash table. The IA-64 ELF port uses this
1657 derived hash table to keep information specific to the IA-64 ElF
1658 linker (without using static variables). */
1660 static struct bfd_link_hash_table
*
1661 elfNN_ia64_hash_table_create (abfd
)
1664 struct elfNN_ia64_link_hash_table
*ret
;
1666 ret
= bfd_zalloc (abfd
, (bfd_size_type
) sizeof (*ret
));
1669 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
1670 elfNN_ia64_new_elf_hash_entry
))
1672 bfd_release (abfd
, ret
);
1676 if (!elfNN_ia64_local_hash_table_init (&ret
->loc_hash_table
, abfd
,
1677 elfNN_ia64_new_loc_hash_entry
))
1679 return &ret
->root
.root
;
1682 /* Look up an entry in a Alpha ELF linker hash table. */
1684 static INLINE
struct elfNN_ia64_local_hash_entry
*
1685 elfNN_ia64_local_hash_lookup(table
, string
, create
, copy
)
1686 struct elfNN_ia64_local_hash_table
*table
;
1688 boolean create
, copy
;
1690 return ((struct elfNN_ia64_local_hash_entry
*)
1691 bfd_hash_lookup (&table
->root
, string
, create
, copy
));
1694 /* Traverse both local and global hash tables. */
1696 struct elfNN_ia64_dyn_sym_traverse_data
1698 boolean (*func
) PARAMS ((struct elfNN_ia64_dyn_sym_info
*, PTR
));
1703 elfNN_ia64_global_dyn_sym_thunk (xentry
, xdata
)
1704 struct bfd_hash_entry
*xentry
;
1707 struct elfNN_ia64_link_hash_entry
*entry
1708 = (struct elfNN_ia64_link_hash_entry
*) xentry
;
1709 struct elfNN_ia64_dyn_sym_traverse_data
*data
1710 = (struct elfNN_ia64_dyn_sym_traverse_data
*) xdata
;
1711 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1713 if (entry
->root
.root
.type
== bfd_link_hash_warning
)
1714 entry
= (struct elfNN_ia64_link_hash_entry
*) entry
->root
.root
.u
.i
.link
;
1716 for (dyn_i
= entry
->info
; dyn_i
; dyn_i
= dyn_i
->next
)
1717 if (! (*data
->func
) (dyn_i
, data
->data
))
1723 elfNN_ia64_local_dyn_sym_thunk (xentry
, xdata
)
1724 struct bfd_hash_entry
*xentry
;
1727 struct elfNN_ia64_local_hash_entry
*entry
1728 = (struct elfNN_ia64_local_hash_entry
*) xentry
;
1729 struct elfNN_ia64_dyn_sym_traverse_data
*data
1730 = (struct elfNN_ia64_dyn_sym_traverse_data
*) xdata
;
1731 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1733 for (dyn_i
= entry
->info
; dyn_i
; dyn_i
= dyn_i
->next
)
1734 if (! (*data
->func
) (dyn_i
, data
->data
))
1740 elfNN_ia64_dyn_sym_traverse (ia64_info
, func
, data
)
1741 struct elfNN_ia64_link_hash_table
*ia64_info
;
1742 boolean (*func
) PARAMS ((struct elfNN_ia64_dyn_sym_info
*, PTR
));
1745 struct elfNN_ia64_dyn_sym_traverse_data xdata
;
1750 elf_link_hash_traverse (&ia64_info
->root
,
1751 elfNN_ia64_global_dyn_sym_thunk
, &xdata
);
1752 bfd_hash_traverse (&ia64_info
->loc_hash_table
.root
,
1753 elfNN_ia64_local_dyn_sym_thunk
, &xdata
);
1757 elfNN_ia64_create_dynamic_sections (abfd
, info
)
1759 struct bfd_link_info
*info
;
1761 struct elfNN_ia64_link_hash_table
*ia64_info
;
1764 if (! _bfd_elf_create_dynamic_sections (abfd
, info
))
1767 ia64_info
= elfNN_ia64_hash_table (info
);
1769 ia64_info
->plt_sec
= bfd_get_section_by_name (abfd
, ".plt");
1770 ia64_info
->got_sec
= bfd_get_section_by_name (abfd
, ".got");
1773 flagword flags
= bfd_get_section_flags (abfd
, ia64_info
->got_sec
);
1774 bfd_set_section_flags (abfd
, ia64_info
->got_sec
, SEC_SMALL_DATA
| flags
);
1777 if (!get_pltoff (abfd
, info
, ia64_info
))
1780 s
= bfd_make_section(abfd
, ".rela.IA_64.pltoff");
1782 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
1785 | SEC_LINKER_CREATED
1787 || !bfd_set_section_alignment (abfd
, s
, 3))
1789 ia64_info
->rel_pltoff_sec
= s
;
1791 s
= bfd_make_section(abfd
, ".rela.got");
1793 || !bfd_set_section_flags (abfd
, s
, (SEC_ALLOC
| SEC_LOAD
1796 | SEC_LINKER_CREATED
1798 || !bfd_set_section_alignment (abfd
, s
, 3))
1800 ia64_info
->rel_got_sec
= s
;
1805 /* Find and/or create a hash entry for local symbol. */
1806 static struct elfNN_ia64_local_hash_entry
*
1807 get_local_sym_hash (ia64_info
, abfd
, rel
, create
)
1808 struct elfNN_ia64_link_hash_table
*ia64_info
;
1810 const Elf_Internal_Rela
*rel
;
1815 struct elfNN_ia64_local_hash_entry
*ret
;
1817 /* Construct a string for use in the elfNN_ia64_local_hash_table.
1818 name describes what was once anonymous memory. */
1820 len
= sizeof (void*)*2 + 1 + sizeof (bfd_vma
)*4 + 1 + 1;
1821 len
+= 10; /* %p slop */
1823 addr_name
= bfd_malloc (len
);
1824 if (addr_name
== NULL
)
1826 sprintf (addr_name
, "%p:%lx",
1827 (void *) abfd
, (unsigned long) ELFNN_R_SYM (rel
->r_info
));
1829 /* Collect the canonical entry data for this address. */
1830 ret
= elfNN_ia64_local_hash_lookup (&ia64_info
->loc_hash_table
,
1831 addr_name
, create
, create
);
1836 /* Find and/or create a descriptor for dynamic symbol info. This will
1837 vary based on global or local symbol, and the addend to the reloc. */
1839 static struct elfNN_ia64_dyn_sym_info
*
1840 get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, create
)
1841 struct elfNN_ia64_link_hash_table
*ia64_info
;
1842 struct elf_link_hash_entry
*h
;
1844 const Elf_Internal_Rela
*rel
;
1847 struct elfNN_ia64_dyn_sym_info
**pp
;
1848 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1849 bfd_vma addend
= rel
? rel
->r_addend
: 0;
1852 pp
= &((struct elfNN_ia64_link_hash_entry
*)h
)->info
;
1855 struct elfNN_ia64_local_hash_entry
*loc_h
;
1857 loc_h
= get_local_sym_hash (ia64_info
, abfd
, rel
, create
);
1863 for (dyn_i
= *pp
; dyn_i
&& dyn_i
->addend
!= addend
; dyn_i
= *pp
)
1866 if (dyn_i
== NULL
&& create
)
1868 dyn_i
= ((struct elfNN_ia64_dyn_sym_info
*)
1869 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *dyn_i
));
1871 dyn_i
->addend
= addend
;
1878 get_got (abfd
, info
, ia64_info
)
1880 struct bfd_link_info
*info
;
1881 struct elfNN_ia64_link_hash_table
*ia64_info
;
1886 got
= ia64_info
->got_sec
;
1891 dynobj
= ia64_info
->root
.dynobj
;
1893 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1894 if (!_bfd_elf_create_got_section (dynobj
, info
))
1897 got
= bfd_get_section_by_name (dynobj
, ".got");
1899 ia64_info
->got_sec
= got
;
1901 flags
= bfd_get_section_flags (abfd
, got
);
1902 bfd_set_section_flags (abfd
, got
, SEC_SMALL_DATA
| flags
);
1908 /* Create function descriptor section (.opd). This section is called .opd
1909 because it contains "official prodecure descriptors". The "official"
1910 refers to the fact that these descriptors are used when taking the address
1911 of a procedure, thus ensuring a unique address for each procedure. */
1914 get_fptr (abfd
, info
, ia64_info
)
1916 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1917 struct elfNN_ia64_link_hash_table
*ia64_info
;
1922 fptr
= ia64_info
->fptr_sec
;
1925 dynobj
= ia64_info
->root
.dynobj
;
1927 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1929 fptr
= bfd_make_section (dynobj
, ".opd");
1931 || !bfd_set_section_flags (dynobj
, fptr
,
1937 | SEC_LINKER_CREATED
))
1938 || !bfd_set_section_alignment (abfd
, fptr
, 4))
1944 ia64_info
->fptr_sec
= fptr
;
1951 get_pltoff (abfd
, info
, ia64_info
)
1953 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
1954 struct elfNN_ia64_link_hash_table
*ia64_info
;
1959 pltoff
= ia64_info
->pltoff_sec
;
1962 dynobj
= ia64_info
->root
.dynobj
;
1964 ia64_info
->root
.dynobj
= dynobj
= abfd
;
1966 pltoff
= bfd_make_section (dynobj
, ELF_STRING_ia64_pltoff
);
1968 || !bfd_set_section_flags (dynobj
, pltoff
,
1974 | SEC_LINKER_CREATED
))
1975 || !bfd_set_section_alignment (abfd
, pltoff
, 4))
1981 ia64_info
->pltoff_sec
= pltoff
;
1988 get_reloc_section (abfd
, ia64_info
, sec
, create
)
1990 struct elfNN_ia64_link_hash_table
*ia64_info
;
1994 const char *srel_name
;
1998 srel_name
= (bfd_elf_string_from_elf_section
1999 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
2000 elf_section_data(sec
)->rel_hdr
.sh_name
));
2001 if (srel_name
== NULL
)
2004 BFD_ASSERT ((strncmp (srel_name
, ".rela", 5) == 0
2005 && strcmp (bfd_get_section_name (abfd
, sec
),
2007 || (strncmp (srel_name
, ".rel", 4) == 0
2008 && strcmp (bfd_get_section_name (abfd
, sec
),
2009 srel_name
+4) == 0));
2011 dynobj
= ia64_info
->root
.dynobj
;
2013 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2015 srel
= bfd_get_section_by_name (dynobj
, srel_name
);
2016 if (srel
== NULL
&& create
)
2018 srel
= bfd_make_section (dynobj
, srel_name
);
2020 || !bfd_set_section_flags (dynobj
, srel
,
2025 | SEC_LINKER_CREATED
2027 || !bfd_set_section_alignment (dynobj
, srel
, 3))
2031 if (sec
->flags
& SEC_READONLY
)
2032 ia64_info
->reltext
= 1;
2038 count_dyn_reloc (abfd
, dyn_i
, srel
, type
)
2040 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2044 struct elfNN_ia64_dyn_reloc_entry
*rent
;
2046 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2047 if (rent
->srel
== srel
&& rent
->type
== type
)
2052 rent
= ((struct elfNN_ia64_dyn_reloc_entry
*)
2053 bfd_alloc (abfd
, (bfd_size_type
) sizeof (*rent
)));
2057 rent
->next
= dyn_i
->reloc_entries
;
2061 dyn_i
->reloc_entries
= rent
;
2069 elfNN_ia64_check_relocs (abfd
, info
, sec
, relocs
)
2071 struct bfd_link_info
*info
;
2073 const Elf_Internal_Rela
*relocs
;
2075 struct elfNN_ia64_link_hash_table
*ia64_info
;
2076 const Elf_Internal_Rela
*relend
;
2077 Elf_Internal_Shdr
*symtab_hdr
;
2078 const Elf_Internal_Rela
*rel
;
2079 asection
*got
, *fptr
, *srel
;
2081 if (info
->relocateable
)
2084 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2085 ia64_info
= elfNN_ia64_hash_table (info
);
2087 got
= fptr
= srel
= NULL
;
2089 relend
= relocs
+ sec
->reloc_count
;
2090 for (rel
= relocs
; rel
< relend
; ++rel
)
2099 NEED_LTOFF_FPTR
= 64,
2102 struct elf_link_hash_entry
*h
= NULL
;
2103 unsigned long r_symndx
= ELFNN_R_SYM (rel
->r_info
);
2104 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2106 boolean maybe_dynamic
;
2107 int dynrel_type
= R_IA64_NONE
;
2109 if (r_symndx
>= symtab_hdr
->sh_info
)
2111 /* We're dealing with a global symbol -- find its hash entry
2112 and mark it as being referenced. */
2113 long indx
= r_symndx
- symtab_hdr
->sh_info
;
2114 h
= elf_sym_hashes (abfd
)[indx
];
2115 while (h
->root
.type
== bfd_link_hash_indirect
2116 || h
->root
.type
== bfd_link_hash_warning
)
2117 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2119 h
->elf_link_hash_flags
|= ELF_LINK_HASH_REF_REGULAR
;
2122 /* We can only get preliminary data on whether a symbol is
2123 locally or externally defined, as not all of the input files
2124 have yet been processed. Do something with what we know, as
2125 this may help reduce memory usage and processing time later. */
2126 maybe_dynamic
= false;
2127 if (h
&& ((info
->shared
2128 && (!info
->symbolic
|| info
->allow_shlib_undefined
))
2129 || ! (h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
)
2130 || h
->root
.type
== bfd_link_hash_defweak
2131 || elfNN_ia64_aix_vec (abfd
->xvec
)))
2132 maybe_dynamic
= true;
2135 switch (ELFNN_R_TYPE (rel
->r_info
))
2137 case R_IA64_TPREL22
:
2138 case R_IA64_TPREL64MSB
:
2139 case R_IA64_TPREL64LSB
:
2140 case R_IA64_LTOFF_TP22
:
2143 case R_IA64_LTOFF_FPTR22
:
2144 case R_IA64_LTOFF_FPTR64I
:
2145 case R_IA64_LTOFF_FPTR32MSB
:
2146 case R_IA64_LTOFF_FPTR32LSB
:
2147 case R_IA64_LTOFF_FPTR64MSB
:
2148 case R_IA64_LTOFF_FPTR64LSB
:
2149 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
2152 case R_IA64_FPTR64I
:
2153 case R_IA64_FPTR32MSB
:
2154 case R_IA64_FPTR32LSB
:
2155 case R_IA64_FPTR64MSB
:
2156 case R_IA64_FPTR64LSB
:
2157 if (info
->shared
|| h
|| elfNN_ia64_aix_vec (abfd
->xvec
))
2158 need_entry
= NEED_FPTR
| NEED_DYNREL
;
2160 need_entry
= NEED_FPTR
;
2161 dynrel_type
= R_IA64_FPTR64LSB
;
2164 case R_IA64_LTOFF22
:
2165 case R_IA64_LTOFF22X
:
2166 case R_IA64_LTOFF64I
:
2167 need_entry
= NEED_GOT
;
2170 case R_IA64_PLTOFF22
:
2171 case R_IA64_PLTOFF64I
:
2172 case R_IA64_PLTOFF64MSB
:
2173 case R_IA64_PLTOFF64LSB
:
2174 need_entry
= NEED_PLTOFF
;
2178 need_entry
|= NEED_MIN_PLT
;
2182 (*info
->callbacks
->warning
)
2183 (info
, _("@pltoff reloc against local symbol"), 0,
2184 abfd
, 0, (bfd_vma
) 0);
2188 case R_IA64_PCREL21B
:
2189 case R_IA64_PCREL60B
:
2190 /* Depending on where this symbol is defined, we may or may not
2191 need a full plt entry. Only skip if we know we'll not need
2192 the entry -- static or symbolic, and the symbol definition
2193 has already been seen. */
2194 if (maybe_dynamic
&& rel
->r_addend
== 0)
2195 need_entry
= NEED_FULL_PLT
;
2201 case R_IA64_DIR32MSB
:
2202 case R_IA64_DIR32LSB
:
2203 case R_IA64_DIR64MSB
:
2204 case R_IA64_DIR64LSB
:
2205 /* Shared objects will always need at least a REL relocation. */
2206 if (info
->shared
|| maybe_dynamic
2207 || (elfNN_ia64_aix_vec (abfd
->xvec
)
2208 && (!h
|| strcmp (h
->root
.root
.string
,
2209 "__GLOB_DATA_PTR") != 0)))
2210 need_entry
= NEED_DYNREL
;
2211 dynrel_type
= R_IA64_DIR64LSB
;
2214 case R_IA64_IPLTMSB
:
2215 case R_IA64_IPLTLSB
:
2216 /* Shared objects will always need at least a REL relocation. */
2217 if (info
->shared
|| maybe_dynamic
)
2218 need_entry
= NEED_DYNREL
;
2219 dynrel_type
= R_IA64_IPLTLSB
;
2222 case R_IA64_PCREL22
:
2223 case R_IA64_PCREL64I
:
2224 case R_IA64_PCREL32MSB
:
2225 case R_IA64_PCREL32LSB
:
2226 case R_IA64_PCREL64MSB
:
2227 case R_IA64_PCREL64LSB
:
2229 need_entry
= NEED_DYNREL
;
2230 dynrel_type
= R_IA64_PCREL64LSB
;
2237 if ((need_entry
& NEED_FPTR
) != 0
2240 (*info
->callbacks
->warning
)
2241 (info
, _("non-zero addend in @fptr reloc"), 0,
2242 abfd
, 0, (bfd_vma
) 0);
2245 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, true);
2247 /* Record whether or not this is a local symbol. */
2250 /* Create what's needed. */
2251 if (need_entry
& NEED_GOT
)
2255 got
= get_got (abfd
, info
, ia64_info
);
2259 dyn_i
->want_got
= 1;
2261 if (need_entry
& NEED_FPTR
)
2265 fptr
= get_fptr (abfd
, info
, ia64_info
);
2270 /* FPTRs for shared libraries are allocated by the dynamic
2271 linker. Make sure this local symbol will appear in the
2272 dynamic symbol table. */
2273 if (!h
&& (info
->shared
2274 /* AIX also needs one */
2275 || elfNN_ia64_aix_vec (abfd
->xvec
)))
2277 if (! (_bfd_elfNN_link_record_local_dynamic_symbol
2278 (info
, abfd
, (long) r_symndx
)))
2282 dyn_i
->want_fptr
= 1;
2284 if (need_entry
& NEED_LTOFF_FPTR
)
2285 dyn_i
->want_ltoff_fptr
= 1;
2286 if (need_entry
& (NEED_MIN_PLT
| NEED_FULL_PLT
))
2288 if (!ia64_info
->root
.dynobj
)
2289 ia64_info
->root
.dynobj
= abfd
;
2290 h
->elf_link_hash_flags
|= ELF_LINK_HASH_NEEDS_PLT
;
2291 dyn_i
->want_plt
= 1;
2293 if (need_entry
& NEED_FULL_PLT
)
2294 dyn_i
->want_plt2
= 1;
2295 if (need_entry
& NEED_PLTOFF
)
2296 dyn_i
->want_pltoff
= 1;
2297 if ((need_entry
& NEED_DYNREL
) && (sec
->flags
& SEC_ALLOC
))
2301 srel
= get_reloc_section (abfd
, ia64_info
, sec
, true);
2305 if (!count_dyn_reloc (abfd
, dyn_i
, srel
, dynrel_type
))
2313 struct elfNN_ia64_allocate_data
2315 struct bfd_link_info
*info
;
2319 /* For cleanliness, and potentially faster dynamic loading, allocate
2320 external GOT entries first. */
2323 allocate_global_data_got (dyn_i
, data
)
2324 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2327 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2330 && ! dyn_i
->want_fptr
2331 && (elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
)
2332 || (elfNN_ia64_aix_vec (x
->info
->hash
->creator
)
2333 && (!dyn_i
->h
|| strcmp (dyn_i
->h
->root
.root
.string
,
2334 "__GLOB_DATA_PTR") != 0))))
2336 dyn_i
->got_offset
= x
->ofs
;
2342 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
2345 allocate_global_fptr_got (dyn_i
, data
)
2346 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2349 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2353 && (elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
)
2354 || elfNN_ia64_aix_vec (x
->info
->hash
->creator
)))
2356 dyn_i
->got_offset
= x
->ofs
;
2362 /* Lastly, allocate all the GOT entries for local data. */
2365 allocate_local_got (dyn_i
, data
)
2366 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2369 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2372 && ! (elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
)
2373 || elfNN_ia64_aix_vec (x
->info
->hash
->creator
)))
2375 dyn_i
->got_offset
= x
->ofs
;
2381 /* Search for the index of a global symbol in it's defining object file. */
2384 global_sym_index (h
)
2385 struct elf_link_hash_entry
*h
;
2387 struct elf_link_hash_entry
**p
;
2390 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
2391 || h
->root
.type
== bfd_link_hash_defweak
);
2393 obj
= h
->root
.u
.def
.section
->owner
;
2394 for (p
= elf_sym_hashes (obj
); *p
!= h
; ++p
)
2397 return p
- elf_sym_hashes (obj
) + elf_tdata (obj
)->symtab_hdr
.sh_info
;
2400 /* Allocate function descriptors. We can do these for every function
2401 in a main executable that is not exported. */
2404 allocate_fptr (dyn_i
, data
)
2405 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2408 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2410 if (dyn_i
->want_fptr
)
2412 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2415 while (h
->root
.type
== bfd_link_hash_indirect
2416 || h
->root
.type
== bfd_link_hash_warning
)
2417 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2420 /* AIX needs an FPTR in this case. */
2421 || (elfNN_ia64_aix_vec (x
->info
->hash
->creator
)
2423 || h
->root
.type
== bfd_link_hash_defined
2424 || h
->root
.type
== bfd_link_hash_defweak
)))
2426 if (h
&& h
->dynindx
== -1)
2428 BFD_ASSERT ((h
->root
.type
== bfd_link_hash_defined
)
2429 || (h
->root
.type
== bfd_link_hash_defweak
));
2431 if (!_bfd_elfNN_link_record_local_dynamic_symbol
2432 (x
->info
, h
->root
.u
.def
.section
->owner
,
2433 global_sym_index (h
)))
2437 dyn_i
->want_fptr
= 0;
2439 else if (h
== NULL
|| h
->dynindx
== -1)
2441 dyn_i
->fptr_offset
= x
->ofs
;
2445 dyn_i
->want_fptr
= 0;
2450 /* Allocate all the minimal PLT entries. */
2453 allocate_plt_entries (dyn_i
, data
)
2454 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2457 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2459 if (dyn_i
->want_plt
)
2461 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2464 while (h
->root
.type
== bfd_link_hash_indirect
2465 || h
->root
.type
== bfd_link_hash_warning
)
2466 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2468 /* ??? Versioned symbols seem to lose ELF_LINK_HASH_NEEDS_PLT. */
2469 if (elfNN_ia64_dynamic_symbol_p (h
, x
->info
))
2471 bfd_size_type offset
= x
->ofs
;
2473 offset
= PLT_HEADER_SIZE
;
2474 dyn_i
->plt_offset
= offset
;
2475 x
->ofs
= offset
+ PLT_MIN_ENTRY_SIZE
;
2477 dyn_i
->want_pltoff
= 1;
2481 dyn_i
->want_plt
= 0;
2482 dyn_i
->want_plt2
= 0;
2488 /* Allocate all the full PLT entries. */
2491 allocate_plt2_entries (dyn_i
, data
)
2492 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2495 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2497 if (dyn_i
->want_plt2
)
2499 struct elf_link_hash_entry
*h
= dyn_i
->h
;
2500 bfd_size_type ofs
= x
->ofs
;
2502 dyn_i
->plt2_offset
= ofs
;
2503 x
->ofs
= ofs
+ PLT_FULL_ENTRY_SIZE
;
2505 while (h
->root
.type
== bfd_link_hash_indirect
2506 || h
->root
.type
== bfd_link_hash_warning
)
2507 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2508 dyn_i
->h
->plt
.offset
= ofs
;
2513 /* Allocate all the PLTOFF entries requested by relocations and
2514 plt entries. We can't share space with allocated FPTR entries,
2515 because the latter are not necessarily addressable by the GP.
2516 ??? Relaxation might be able to determine that they are. */
2519 allocate_pltoff_entries (dyn_i
, data
)
2520 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2523 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2525 if (dyn_i
->want_pltoff
)
2527 dyn_i
->pltoff_offset
= x
->ofs
;
2533 /* Allocate dynamic relocations for those symbols that turned out
2537 allocate_dynrel_entries (dyn_i
, data
)
2538 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2541 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
2542 struct elfNN_ia64_link_hash_table
*ia64_info
;
2543 struct elfNN_ia64_dyn_reloc_entry
*rent
;
2544 boolean dynamic_symbol
, shared
;
2546 ia64_info
= elfNN_ia64_hash_table (x
->info
);
2547 dynamic_symbol
= elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
)
2548 || (elfNN_ia64_aix_vec (x
->info
->hash
->creator
)
2549 /* Don't allocate an entry for __GLOB_DATA_PTR */
2550 && (!dyn_i
->h
|| strcmp (dyn_i
->h
->root
.root
.string
,
2551 "__GLOB_DATA_PTR") != 0));
2552 shared
= x
->info
->shared
;
2554 /* Take care of the normal data relocations. */
2556 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2558 int count
= rent
->count
;
2562 case R_IA64_FPTR64LSB
:
2563 /* Allocate one iff !want_fptr, which by this point will
2564 be true only if we're actually allocating one statically
2565 in the main executable. */
2566 if (dyn_i
->want_fptr
)
2569 case R_IA64_PCREL64LSB
:
2570 if (!dynamic_symbol
)
2573 case R_IA64_DIR64LSB
:
2574 if (!dynamic_symbol
&& !shared
)
2577 case R_IA64_IPLTLSB
:
2578 if (!dynamic_symbol
&& !shared
)
2580 /* Use two REL relocations for IPLT relocations
2581 against local symbols. */
2582 if (!dynamic_symbol
)
2588 rent
->srel
->_raw_size
+= sizeof (ElfNN_External_Rela
) * count
;
2591 /* Take care of the GOT and PLT relocations. */
2593 if (((dynamic_symbol
|| shared
) && dyn_i
->want_got
)
2594 || (dyn_i
->want_ltoff_fptr
&& dyn_i
->h
&& dyn_i
->h
->dynindx
!= -1))
2595 ia64_info
->rel_got_sec
->_raw_size
+= sizeof (ElfNN_External_Rela
);
2597 if (dyn_i
->want_pltoff
)
2599 bfd_size_type t
= 0;
2601 /* Dynamic symbols get one IPLT relocation. Local symbols in
2602 shared libraries get two REL relocations. Local symbols in
2603 main applications get nothing. */
2605 t
= sizeof (ElfNN_External_Rela
);
2607 t
= 2 * sizeof (ElfNN_External_Rela
);
2609 ia64_info
->rel_pltoff_sec
->_raw_size
+= t
;
2616 elfNN_ia64_adjust_dynamic_symbol (info
, h
)
2617 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
2618 struct elf_link_hash_entry
*h
;
2620 /* ??? Undefined symbols with PLT entries should be re-defined
2621 to be the PLT entry. */
2623 /* If this is a weak symbol, and there is a real definition, the
2624 processor independent code will have arranged for us to see the
2625 real definition first, and we can just use the same value. */
2626 if (h
->weakdef
!= NULL
)
2628 BFD_ASSERT (h
->weakdef
->root
.type
== bfd_link_hash_defined
2629 || h
->weakdef
->root
.type
== bfd_link_hash_defweak
);
2630 h
->root
.u
.def
.section
= h
->weakdef
->root
.u
.def
.section
;
2631 h
->root
.u
.def
.value
= h
->weakdef
->root
.u
.def
.value
;
2635 /* If this is a reference to a symbol defined by a dynamic object which
2636 is not a function, we might allocate the symbol in our .dynbss section
2637 and allocate a COPY dynamic relocation.
2639 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2646 elfNN_ia64_size_dynamic_sections (output_bfd
, info
)
2648 struct bfd_link_info
*info
;
2650 struct elfNN_ia64_allocate_data data
;
2651 struct elfNN_ia64_link_hash_table
*ia64_info
;
2654 boolean relplt
= false;
2656 dynobj
= elf_hash_table(info
)->dynobj
;
2657 ia64_info
= elfNN_ia64_hash_table (info
);
2658 BFD_ASSERT(dynobj
!= NULL
);
2661 /* Set the contents of the .interp section to the interpreter. */
2662 if (ia64_info
->root
.dynamic_sections_created
2665 sec
= bfd_get_section_by_name (dynobj
, ".interp");
2666 BFD_ASSERT (sec
!= NULL
);
2667 sec
->contents
= (bfd_byte
*) DYNAMIC_INTERPRETER (output_bfd
);
2668 sec
->_raw_size
= strlen (DYNAMIC_INTERPRETER (output_bfd
)) + 1;
2671 /* Allocate the GOT entries. */
2673 if (ia64_info
->got_sec
)
2676 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_data_got
, &data
);
2677 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_fptr_got
, &data
);
2678 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_local_got
, &data
);
2679 ia64_info
->got_sec
->_raw_size
= data
.ofs
;
2682 /* Allocate the FPTR entries. */
2684 if (ia64_info
->fptr_sec
)
2687 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_fptr
, &data
);
2688 ia64_info
->fptr_sec
->_raw_size
= data
.ofs
;
2691 /* Now that we've seen all of the input files, we can decide which
2692 symbols need plt entries. Allocate the minimal PLT entries first.
2693 We do this even though dynamic_sections_created may be false, because
2694 this has the side-effect of clearing want_plt and want_plt2. */
2697 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_plt_entries
, &data
);
2699 ia64_info
->minplt_entries
= 0;
2702 ia64_info
->minplt_entries
2703 = (data
.ofs
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
2706 /* Align the pointer for the plt2 entries. */
2707 data
.ofs
= (data
.ofs
+ 31) & (bfd_vma
) -32;
2709 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_plt2_entries
, &data
);
2712 BFD_ASSERT (ia64_info
->root
.dynamic_sections_created
);
2714 ia64_info
->plt_sec
->_raw_size
= data
.ofs
;
2716 /* If we've got a .plt, we need some extra memory for the dynamic
2717 linker. We stuff these in .got.plt. */
2718 sec
= bfd_get_section_by_name (dynobj
, ".got.plt");
2719 sec
->_raw_size
= 8 * PLT_RESERVED_WORDS
;
2722 /* Allocate the PLTOFF entries. */
2724 if (ia64_info
->pltoff_sec
)
2727 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_pltoff_entries
, &data
);
2728 ia64_info
->pltoff_sec
->_raw_size
= data
.ofs
;
2731 if (ia64_info
->root
.dynamic_sections_created
)
2733 /* Allocate space for the dynamic relocations that turned out to be
2736 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_dynrel_entries
, &data
);
2739 /* We have now determined the sizes of the various dynamic sections.
2740 Allocate memory for them. */
2741 for (sec
= dynobj
->sections
; sec
!= NULL
; sec
= sec
->next
)
2745 if (!(sec
->flags
& SEC_LINKER_CREATED
))
2748 /* If we don't need this section, strip it from the output file.
2749 There were several sections primarily related to dynamic
2750 linking that must be create before the linker maps input
2751 sections to output sections. The linker does that before
2752 bfd_elf_size_dynamic_sections is called, and it is that
2753 function which decides whether anything needs to go into
2756 strip
= (sec
->_raw_size
== 0);
2758 if (sec
== ia64_info
->got_sec
)
2760 else if (sec
== ia64_info
->rel_got_sec
)
2763 ia64_info
->rel_got_sec
= NULL
;
2765 /* We use the reloc_count field as a counter if we need to
2766 copy relocs into the output file. */
2767 sec
->reloc_count
= 0;
2769 else if (sec
== ia64_info
->fptr_sec
)
2772 ia64_info
->fptr_sec
= NULL
;
2774 else if (sec
== ia64_info
->plt_sec
)
2777 ia64_info
->plt_sec
= NULL
;
2779 else if (sec
== ia64_info
->pltoff_sec
)
2782 ia64_info
->pltoff_sec
= NULL
;
2784 else if (sec
== ia64_info
->rel_pltoff_sec
)
2787 ia64_info
->rel_pltoff_sec
= NULL
;
2791 /* We use the reloc_count field as a counter if we need to
2792 copy relocs into the output file. */
2793 sec
->reloc_count
= 0;
2800 /* It's OK to base decisions on the section name, because none
2801 of the dynobj section names depend upon the input files. */
2802 name
= bfd_get_section_name (dynobj
, sec
);
2804 if (strcmp (name
, ".got.plt") == 0)
2806 else if (strncmp (name
, ".rel", 4) == 0)
2810 /* We use the reloc_count field as a counter if we need to
2811 copy relocs into the output file. */
2812 sec
->reloc_count
= 0;
2820 _bfd_strip_section_from_output (info
, sec
);
2823 /* Allocate memory for the section contents. */
2824 sec
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, sec
->_raw_size
);
2825 if (sec
->contents
== NULL
&& sec
->_raw_size
!= 0)
2830 if (elf_hash_table (info
)->dynamic_sections_created
)
2832 /* Add some entries to the .dynamic section. We fill in the values
2833 later (in finish_dynamic_sections) but we must add the entries now
2834 so that we get the correct size for the .dynamic section. */
2838 /* The DT_DEBUG entry is filled in by the dynamic linker and used
2840 #define add_dynamic_entry(TAG, VAL) \
2841 bfd_elfNN_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
2843 if (!add_dynamic_entry (DT_DEBUG
, 0))
2847 if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE
, 0))
2849 if (!add_dynamic_entry (DT_PLTGOT
, 0))
2854 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
2855 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
2856 || !add_dynamic_entry (DT_JMPREL
, 0))
2860 if (!add_dynamic_entry (DT_RELA
, 0)
2861 || !add_dynamic_entry (DT_RELASZ
, 0)
2862 || !add_dynamic_entry (DT_RELAENT
, sizeof (ElfNN_External_Rela
)))
2865 if (ia64_info
->reltext
)
2867 if (!add_dynamic_entry (DT_TEXTREL
, 0))
2869 info
->flags
|= DF_TEXTREL
;
2873 /* ??? Perhaps force __gp local. */
2878 static bfd_reloc_status_type
2879 elfNN_ia64_install_value (abfd
, hit_addr
, v
, r_type
)
2883 unsigned int r_type
;
2885 const struct ia64_operand
*op
;
2886 int bigendian
= 0, shift
= 0;
2887 bfd_vma t0
, t1
, insn
, dword
;
2888 enum ia64_opnd opnd
;
2891 #ifdef BFD_HOST_U_64_BIT
2892 BFD_HOST_U_64_BIT val
= (BFD_HOST_U_64_BIT
) v
;
2897 opnd
= IA64_OPND_NIL
;
2902 return bfd_reloc_ok
;
2904 /* Instruction relocations. */
2906 case R_IA64_IMM14
: opnd
= IA64_OPND_IMM14
; break;
2908 case R_IA64_PCREL21F
: opnd
= IA64_OPND_TGT25
; break;
2909 case R_IA64_PCREL21M
: opnd
= IA64_OPND_TGT25b
; break;
2910 case R_IA64_PCREL60B
: opnd
= IA64_OPND_TGT64
; break;
2911 case R_IA64_PCREL21B
:
2912 case R_IA64_PCREL21BI
:
2913 opnd
= IA64_OPND_TGT25c
;
2917 case R_IA64_GPREL22
:
2918 case R_IA64_LTOFF22
:
2919 case R_IA64_LTOFF22X
:
2920 case R_IA64_PLTOFF22
:
2921 case R_IA64_PCREL22
:
2922 case R_IA64_LTOFF_FPTR22
:
2923 opnd
= IA64_OPND_IMM22
;
2927 case R_IA64_GPREL64I
:
2928 case R_IA64_LTOFF64I
:
2929 case R_IA64_PLTOFF64I
:
2930 case R_IA64_PCREL64I
:
2931 case R_IA64_FPTR64I
:
2932 case R_IA64_LTOFF_FPTR64I
:
2933 opnd
= IA64_OPND_IMMU64
;
2936 /* Data relocations. */
2938 case R_IA64_DIR32MSB
:
2939 case R_IA64_GPREL32MSB
:
2940 case R_IA64_FPTR32MSB
:
2941 case R_IA64_PCREL32MSB
:
2942 case R_IA64_LTOFF_FPTR32MSB
:
2943 case R_IA64_SEGREL32MSB
:
2944 case R_IA64_SECREL32MSB
:
2945 case R_IA64_LTV32MSB
:
2946 size
= 4; bigendian
= 1;
2949 case R_IA64_DIR32LSB
:
2950 case R_IA64_GPREL32LSB
:
2951 case R_IA64_FPTR32LSB
:
2952 case R_IA64_PCREL32LSB
:
2953 case R_IA64_LTOFF_FPTR32LSB
:
2954 case R_IA64_SEGREL32LSB
:
2955 case R_IA64_SECREL32LSB
:
2956 case R_IA64_LTV32LSB
:
2957 size
= 4; bigendian
= 0;
2960 case R_IA64_DIR64MSB
:
2961 case R_IA64_GPREL64MSB
:
2962 case R_IA64_PLTOFF64MSB
:
2963 case R_IA64_FPTR64MSB
:
2964 case R_IA64_PCREL64MSB
:
2965 case R_IA64_LTOFF_FPTR64MSB
:
2966 case R_IA64_SEGREL64MSB
:
2967 case R_IA64_SECREL64MSB
:
2968 case R_IA64_LTV64MSB
:
2969 size
= 8; bigendian
= 1;
2972 case R_IA64_DIR64LSB
:
2973 case R_IA64_GPREL64LSB
:
2974 case R_IA64_PLTOFF64LSB
:
2975 case R_IA64_FPTR64LSB
:
2976 case R_IA64_PCREL64LSB
:
2977 case R_IA64_LTOFF_FPTR64LSB
:
2978 case R_IA64_SEGREL64LSB
:
2979 case R_IA64_SECREL64LSB
:
2980 case R_IA64_LTV64LSB
:
2981 size
= 8; bigendian
= 0;
2984 /* Unsupported / Dynamic relocations. */
2986 return bfd_reloc_notsupported
;
2991 case IA64_OPND_IMMU64
:
2992 hit_addr
-= (long) hit_addr
& 0x3;
2993 t0
= bfd_get_64 (abfd
, hit_addr
);
2994 t1
= bfd_get_64 (abfd
, hit_addr
+ 8);
2996 /* tmpl/s: bits 0.. 5 in t0
2997 slot 0: bits 5..45 in t0
2998 slot 1: bits 46..63 in t0, bits 0..22 in t1
2999 slot 2: bits 23..63 in t1 */
3001 /* First, clear the bits that form the 64 bit constant. */
3002 t0
&= ~(0x3ffffLL
<< 46);
3004 | (( (0x07fLL
<< 13) | (0x1ffLL
<< 27)
3005 | (0x01fLL
<< 22) | (0x001LL
<< 21)
3006 | (0x001LL
<< 36)) << 23));
3008 t0
|= ((val
>> 22) & 0x03ffffLL
) << 46; /* 18 lsbs of imm41 */
3009 t1
|= ((val
>> 40) & 0x7fffffLL
) << 0; /* 23 msbs of imm41 */
3010 t1
|= ( (((val
>> 0) & 0x07f) << 13) /* imm7b */
3011 | (((val
>> 7) & 0x1ff) << 27) /* imm9d */
3012 | (((val
>> 16) & 0x01f) << 22) /* imm5c */
3013 | (((val
>> 21) & 0x001) << 21) /* ic */
3014 | (((val
>> 63) & 0x001) << 36)) << 23; /* i */
3016 bfd_put_64 (abfd
, t0
, hit_addr
);
3017 bfd_put_64 (abfd
, t1
, hit_addr
+ 8);
3020 case IA64_OPND_TGT64
:
3021 hit_addr
-= (long) hit_addr
& 0x3;
3022 t0
= bfd_get_64 (abfd
, hit_addr
);
3023 t1
= bfd_get_64 (abfd
, hit_addr
+ 8);
3025 /* tmpl/s: bits 0.. 5 in t0
3026 slot 0: bits 5..45 in t0
3027 slot 1: bits 46..63 in t0, bits 0..22 in t1
3028 slot 2: bits 23..63 in t1 */
3030 /* First, clear the bits that form the 64 bit constant. */
3031 t0
&= ~(0x3ffffLL
<< 46);
3033 | ((1LL << 36 | 0xfffffLL
<< 13) << 23));
3036 t0
|= ((val
>> 20) & 0xffffLL
) << 2 << 46; /* 16 lsbs of imm39 */
3037 t1
|= ((val
>> 36) & 0x7fffffLL
) << 0; /* 23 msbs of imm39 */
3038 t1
|= ((((val
>> 0) & 0xfffffLL
) << 13) /* imm20b */
3039 | (((val
>> 59) & 0x1LL
) << 36)) << 23; /* i */
3041 bfd_put_64 (abfd
, t0
, hit_addr
);
3042 bfd_put_64 (abfd
, t1
, hit_addr
+ 8);
3046 switch ((long) hit_addr
& 0x3)
3048 case 0: shift
= 5; break;
3049 case 1: shift
= 14; hit_addr
+= 3; break;
3050 case 2: shift
= 23; hit_addr
+= 6; break;
3051 case 3: return bfd_reloc_notsupported
; /* shouldn't happen... */
3053 dword
= bfd_get_64 (abfd
, hit_addr
);
3054 insn
= (dword
>> shift
) & 0x1ffffffffffLL
;
3056 op
= elf64_ia64_operands
+ opnd
;
3057 err
= (*op
->insert
) (op
, val
, (ia64_insn
*)& insn
);
3059 return bfd_reloc_overflow
;
3061 dword
&= ~(0x1ffffffffffLL
<< shift
);
3062 dword
|= (insn
<< shift
);
3063 bfd_put_64 (abfd
, dword
, hit_addr
);
3067 /* A data relocation. */
3070 bfd_putb32 (val
, hit_addr
);
3072 bfd_putb64 (val
, hit_addr
);
3075 bfd_putl32 (val
, hit_addr
);
3077 bfd_putl64 (val
, hit_addr
);
3081 return bfd_reloc_ok
;
3085 elfNN_ia64_install_dyn_reloc (abfd
, info
, sec
, srel
, offset
, type
,
3088 struct bfd_link_info
*info
;
3096 Elf_Internal_Rela outrel
;
3098 offset
+= sec
->output_section
->vma
+ sec
->output_offset
;
3100 BFD_ASSERT (dynindx
!= -1);
3101 outrel
.r_info
= ELFNN_R_INFO (dynindx
, type
);
3102 outrel
.r_addend
= addend
;
3103 outrel
.r_offset
= _bfd_elf_section_offset (abfd
, info
, sec
, offset
);
3104 if ((outrel
.r_offset
| 1) == (bfd_vma
) -1)
3106 /* Run for the hills. We shouldn't be outputting a relocation
3107 for this. So do what everyone else does and output a no-op. */
3108 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
3109 outrel
.r_addend
= 0;
3110 outrel
.r_offset
= 0;
3113 bfd_elfNN_swap_reloca_out (abfd
, &outrel
,
3114 ((ElfNN_External_Rela
*) srel
->contents
3115 + srel
->reloc_count
++));
3116 BFD_ASSERT (sizeof (ElfNN_External_Rela
) * srel
->reloc_count
3117 <= srel
->_cooked_size
);
3120 /* Store an entry for target address TARGET_ADDR in the linkage table
3121 and return the gp-relative address of the linkage table entry. */
3124 set_got_entry (abfd
, info
, dyn_i
, dynindx
, addend
, value
, dyn_r_type
)
3126 struct bfd_link_info
*info
;
3127 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3131 unsigned int dyn_r_type
;
3133 struct elfNN_ia64_link_hash_table
*ia64_info
;
3136 ia64_info
= elfNN_ia64_hash_table (info
);
3137 got_sec
= ia64_info
->got_sec
;
3139 BFD_ASSERT ((dyn_i
->got_offset
& 7) == 0);
3141 if (! dyn_i
->got_done
)
3143 dyn_i
->got_done
= true;
3145 /* Store the target address in the linkage table entry. */
3146 bfd_put_64 (abfd
, value
, got_sec
->contents
+ dyn_i
->got_offset
);
3148 /* Install a dynamic relocation if needed. */
3150 || elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, info
)
3151 || elfNN_ia64_aix_vec (abfd
->xvec
)
3152 || (dynindx
!= -1 && dyn_r_type
== R_IA64_FPTR64LSB
))
3156 dyn_r_type
= R_IA64_REL64LSB
;
3161 if (bfd_big_endian (abfd
))
3165 case R_IA64_REL64LSB
:
3166 dyn_r_type
= R_IA64_REL64MSB
;
3168 case R_IA64_DIR64LSB
:
3169 dyn_r_type
= R_IA64_DIR64MSB
;
3171 case R_IA64_FPTR64LSB
:
3172 dyn_r_type
= R_IA64_FPTR64MSB
;
3180 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, got_sec
,
3181 ia64_info
->rel_got_sec
,
3182 dyn_i
->got_offset
, dyn_r_type
,
3187 /* Return the address of the linkage table entry. */
3188 value
= (got_sec
->output_section
->vma
3189 + got_sec
->output_offset
3190 + dyn_i
->got_offset
);
3195 /* Fill in a function descriptor consisting of the function's code
3196 address and its global pointer. Return the descriptor's address. */
3199 set_fptr_entry (abfd
, info
, dyn_i
, value
)
3201 struct bfd_link_info
*info
;
3202 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3205 struct elfNN_ia64_link_hash_table
*ia64_info
;
3208 ia64_info
= elfNN_ia64_hash_table (info
);
3209 fptr_sec
= ia64_info
->fptr_sec
;
3211 if (!dyn_i
->fptr_done
)
3213 dyn_i
->fptr_done
= 1;
3215 /* Fill in the function descriptor. */
3216 bfd_put_64 (abfd
, value
, fptr_sec
->contents
+ dyn_i
->fptr_offset
);
3217 bfd_put_64 (abfd
, _bfd_get_gp_value (abfd
),
3218 fptr_sec
->contents
+ dyn_i
->fptr_offset
+ 8);
3221 /* Return the descriptor's address. */
3222 value
= (fptr_sec
->output_section
->vma
3223 + fptr_sec
->output_offset
3224 + dyn_i
->fptr_offset
);
3229 /* Fill in a PLTOFF entry consisting of the function's code address
3230 and its global pointer. Return the descriptor's address. */
3233 set_pltoff_entry (abfd
, info
, dyn_i
, value
, is_plt
)
3235 struct bfd_link_info
*info
;
3236 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3240 struct elfNN_ia64_link_hash_table
*ia64_info
;
3241 asection
*pltoff_sec
;
3243 ia64_info
= elfNN_ia64_hash_table (info
);
3244 pltoff_sec
= ia64_info
->pltoff_sec
;
3246 /* Don't do anything if this symbol uses a real PLT entry. In
3247 that case, we'll fill this in during finish_dynamic_symbol. */
3248 if ((! dyn_i
->want_plt
|| is_plt
)
3249 && !dyn_i
->pltoff_done
)
3251 bfd_vma gp
= _bfd_get_gp_value (abfd
);
3253 /* Fill in the function descriptor. */
3254 bfd_put_64 (abfd
, value
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
);
3255 bfd_put_64 (abfd
, gp
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
+ 8);
3257 /* Install dynamic relocations if needed. */
3258 if (!is_plt
&& info
->shared
)
3260 unsigned int dyn_r_type
;
3262 if (bfd_big_endian (abfd
))
3263 dyn_r_type
= R_IA64_REL64MSB
;
3265 dyn_r_type
= R_IA64_REL64LSB
;
3267 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
3268 ia64_info
->rel_pltoff_sec
,
3269 dyn_i
->pltoff_offset
,
3270 dyn_r_type
, 0, value
);
3271 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
3272 ia64_info
->rel_pltoff_sec
,
3273 dyn_i
->pltoff_offset
+ 8,
3277 dyn_i
->pltoff_done
= 1;
3280 /* Return the descriptor's address. */
3281 value
= (pltoff_sec
->output_section
->vma
3282 + pltoff_sec
->output_offset
3283 + dyn_i
->pltoff_offset
);
3288 /* Called through qsort to sort the .IA_64.unwind section during a
3289 non-relocatable link. Set elfNN_ia64_unwind_entry_compare_bfd
3290 to the output bfd so we can do proper endianness frobbing. */
3292 static bfd
*elfNN_ia64_unwind_entry_compare_bfd
;
3295 elfNN_ia64_unwind_entry_compare (a
, b
)
3301 av
= bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd
, a
);
3302 bv
= bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd
, b
);
3304 return (av
< bv
? -1 : av
> bv
? 1 : 0);
3308 elfNN_ia64_final_link (abfd
, info
)
3310 struct bfd_link_info
*info
;
3312 struct elfNN_ia64_link_hash_table
*ia64_info
;
3313 asection
*unwind_output_sec
;
3315 ia64_info
= elfNN_ia64_hash_table (info
);
3317 /* Make sure we've got ourselves a nice fat __gp value. */
3318 if (!info
->relocateable
)
3320 bfd_vma min_vma
= (bfd_vma
) -1, max_vma
= 0;
3321 bfd_vma min_short_vma
= min_vma
, max_short_vma
= 0;
3322 struct elf_link_hash_entry
*gp
;
3326 /* Find the min and max vma of all sections marked short. Also
3327 collect min and max vma of any type, for use in selecting a
3329 for (os
= abfd
->sections
; os
; os
= os
->next
)
3333 if ((os
->flags
& SEC_ALLOC
) == 0)
3337 hi
= os
->vma
+ os
->_raw_size
;
3345 if (os
->flags
& SEC_SMALL_DATA
)
3347 if (min_short_vma
> lo
)
3349 if (max_short_vma
< hi
)
3354 /* See if the user wants to force a value. */
3355 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", false,
3359 && (gp
->root
.type
== bfd_link_hash_defined
3360 || gp
->root
.type
== bfd_link_hash_defweak
))
3362 asection
*gp_sec
= gp
->root
.u
.def
.section
;
3363 gp_val
= (gp
->root
.u
.def
.value
3364 + gp_sec
->output_section
->vma
3365 + gp_sec
->output_offset
);
3369 /* Pick a sensible value. */
3371 asection
*got_sec
= ia64_info
->got_sec
;
3373 /* Start with just the address of the .got. */
3375 gp_val
= got_sec
->output_section
->vma
;
3376 else if (max_short_vma
!= 0)
3377 gp_val
= min_short_vma
;
3381 /* If it is possible to address the entire image, but we
3382 don't with the choice above, adjust. */
3383 if (max_vma
- min_vma
< 0x400000
3384 && max_vma
- gp_val
<= 0x200000
3385 && gp_val
- min_vma
> 0x200000)
3386 gp_val
= min_vma
+ 0x200000;
3387 else if (max_short_vma
!= 0)
3389 /* If we don't cover all the short data, adjust. */
3390 if (max_short_vma
- gp_val
>= 0x200000)
3391 gp_val
= min_short_vma
+ 0x200000;
3393 /* If we're addressing stuff past the end, adjust back. */
3394 if (gp_val
> max_vma
)
3395 gp_val
= max_vma
- 0x200000 + 8;
3399 /* Validate whether all SHF_IA_64_SHORT sections are within
3400 range of the chosen GP. */
3402 if (max_short_vma
!= 0)
3404 if (max_short_vma
- min_short_vma
>= 0x400000)
3406 (*_bfd_error_handler
)
3407 (_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
3408 bfd_get_filename (abfd
),
3409 (unsigned long) (max_short_vma
- min_short_vma
));
3412 else if ((gp_val
> min_short_vma
3413 && gp_val
- min_short_vma
> 0x200000)
3414 || (gp_val
< max_short_vma
3415 && max_short_vma
- gp_val
>= 0x200000))
3417 (*_bfd_error_handler
)
3418 (_("%s: __gp does not cover short data segment"),
3419 bfd_get_filename (abfd
));
3424 _bfd_set_gp_value (abfd
, gp_val
);
3428 gp
->root
.type
= bfd_link_hash_defined
;
3429 gp
->root
.u
.def
.value
= gp_val
;
3430 gp
->root
.u
.def
.section
= bfd_abs_section_ptr
;
3434 /* If we're producing a final executable, we need to sort the contents
3435 of the .IA_64.unwind section. Force this section to be relocated
3436 into memory rather than written immediately to the output file. */
3437 unwind_output_sec
= NULL
;
3438 if (!info
->relocateable
)
3440 asection
*s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_unwind
);
3443 unwind_output_sec
= s
->output_section
;
3444 unwind_output_sec
->contents
3445 = bfd_malloc (unwind_output_sec
->_raw_size
);
3446 if (unwind_output_sec
->contents
== NULL
)
3451 /* Invoke the regular ELF backend linker to do all the work. */
3452 if (!bfd_elfNN_bfd_final_link (abfd
, info
))
3455 if (unwind_output_sec
)
3457 elfNN_ia64_unwind_entry_compare_bfd
= abfd
;
3458 qsort (unwind_output_sec
->contents
,
3459 (size_t) (unwind_output_sec
->_raw_size
/ 24),
3461 elfNN_ia64_unwind_entry_compare
);
3463 if (! bfd_set_section_contents (abfd
, unwind_output_sec
,
3464 unwind_output_sec
->contents
, (bfd_vma
) 0,
3465 unwind_output_sec
->_raw_size
))
3473 elfNN_ia64_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
3474 contents
, relocs
, local_syms
, local_sections
)
3476 struct bfd_link_info
*info
;
3478 asection
*input_section
;
3480 Elf_Internal_Rela
*relocs
;
3481 Elf_Internal_Sym
*local_syms
;
3482 asection
**local_sections
;
3484 struct elfNN_ia64_link_hash_table
*ia64_info
;
3485 Elf_Internal_Shdr
*symtab_hdr
;
3486 Elf_Internal_Rela
*rel
;
3487 Elf_Internal_Rela
*relend
;
3489 boolean ret_val
= true; /* for non-fatal errors */
3492 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3493 ia64_info
= elfNN_ia64_hash_table (info
);
3495 /* Infect various flags from the input section to the output section. */
3496 if (info
->relocateable
)
3500 flags
= elf_section_data(input_section
)->this_hdr
.sh_flags
;
3501 flags
&= SHF_IA_64_NORECOV
;
3503 elf_section_data(input_section
->output_section
)
3504 ->this_hdr
.sh_flags
|= flags
;
3508 gp_val
= _bfd_get_gp_value (output_bfd
);
3509 srel
= get_reloc_section (input_bfd
, ia64_info
, input_section
, false);
3512 relend
= relocs
+ input_section
->reloc_count
;
3513 for (; rel
< relend
; ++rel
)
3515 struct elf_link_hash_entry
*h
;
3516 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
3517 bfd_reloc_status_type r
;
3518 reloc_howto_type
*howto
;
3519 unsigned long r_symndx
;
3520 Elf_Internal_Sym
*sym
;
3521 unsigned int r_type
;
3525 boolean dynamic_symbol_p
;
3526 boolean undef_weak_ref
;
3528 r_type
= ELFNN_R_TYPE (rel
->r_info
);
3529 if (r_type
> R_IA64_MAX_RELOC_CODE
)
3531 (*_bfd_error_handler
)
3532 (_("%s: unknown relocation type %d"),
3533 bfd_archive_filename (input_bfd
), (int)r_type
);
3534 bfd_set_error (bfd_error_bad_value
);
3539 howto
= lookup_howto (r_type
);
3540 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
3544 undef_weak_ref
= false;
3546 if (r_symndx
< symtab_hdr
->sh_info
)
3548 /* Reloc against local symbol. */
3549 sym
= local_syms
+ r_symndx
;
3550 sym_sec
= local_sections
[r_symndx
];
3551 value
= _bfd_elf_rela_local_sym (output_bfd
, sym
, sym_sec
, rel
);
3552 if ((sym_sec
->flags
& SEC_MERGE
)
3553 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
3554 && (elf_section_data (sym_sec
)->sec_info_type
3555 == ELF_INFO_TYPE_MERGE
))
3557 struct elfNN_ia64_local_hash_entry
*loc_h
;
3559 loc_h
= get_local_sym_hash (ia64_info
, input_bfd
, rel
, false);
3560 if (loc_h
&& ! loc_h
->sec_merge_done
)
3562 struct elfNN_ia64_dyn_sym_info
*dynent
;
3565 for (dynent
= loc_h
->info
; dynent
; dynent
= dynent
->next
)
3569 _bfd_merged_section_offset (output_bfd
, &msec
,
3570 elf_section_data (msec
)->
3575 dynent
->addend
-= sym
->st_value
;
3576 dynent
->addend
+= msec
->output_section
->vma
3577 + msec
->output_offset
3578 - sym_sec
->output_section
->vma
3579 - sym_sec
->output_offset
;
3581 loc_h
->sec_merge_done
= 1;
3589 /* Reloc against global symbol. */
3590 indx
= r_symndx
- symtab_hdr
->sh_info
;
3591 h
= elf_sym_hashes (input_bfd
)[indx
];
3592 while (h
->root
.type
== bfd_link_hash_indirect
3593 || h
->root
.type
== bfd_link_hash_warning
)
3594 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3597 if (h
->root
.type
== bfd_link_hash_defined
3598 || h
->root
.type
== bfd_link_hash_defweak
)
3600 sym_sec
= h
->root
.u
.def
.section
;
3602 /* Detect the cases that sym_sec->output_section is
3603 expected to be NULL -- all cases in which the symbol
3604 is defined in another shared module. This includes
3605 PLT relocs for which we've created a PLT entry and
3606 other relocs for which we're prepared to create
3607 dynamic relocations. */
3608 /* ??? Just accept it NULL and continue. */
3610 if (sym_sec
->output_section
!= NULL
)
3612 value
= (h
->root
.u
.def
.value
3613 + sym_sec
->output_section
->vma
3614 + sym_sec
->output_offset
);
3617 else if (h
->root
.type
== bfd_link_hash_undefweak
)
3618 undef_weak_ref
= true;
3619 else if (info
->shared
3620 && (!info
->symbolic
|| info
->allow_shlib_undefined
)
3621 && !info
->no_undefined
3622 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
3626 if (! ((*info
->callbacks
->undefined_symbol
)
3627 (info
, h
->root
.root
.string
, input_bfd
,
3628 input_section
, rel
->r_offset
,
3629 (!info
->shared
|| info
->no_undefined
3630 || ELF_ST_VISIBILITY (h
->other
)))))
3637 hit_addr
= contents
+ rel
->r_offset
;
3638 value
+= rel
->r_addend
;
3639 dynamic_symbol_p
= elfNN_ia64_dynamic_symbol_p (h
, info
);
3650 case R_IA64_DIR32MSB
:
3651 case R_IA64_DIR32LSB
:
3652 case R_IA64_DIR64MSB
:
3653 case R_IA64_DIR64LSB
:
3654 /* Install a dynamic relocation for this reloc. */
3655 if ((dynamic_symbol_p
|| info
->shared
3656 || (elfNN_ia64_aix_vec (info
->hash
->creator
)
3657 /* Don't emit relocs for __GLOB_DATA_PTR on AIX. */
3658 && (!h
|| strcmp (h
->root
.root
.string
,
3659 "__GLOB_DATA_PTR") != 0)))
3661 && (input_section
->flags
& SEC_ALLOC
) != 0)
3663 unsigned int dyn_r_type
;
3667 BFD_ASSERT (srel
!= NULL
);
3669 /* If we don't need dynamic symbol lookup, find a
3670 matching RELATIVE relocation. */
3671 dyn_r_type
= r_type
;
3672 if (dynamic_symbol_p
)
3674 dynindx
= h
->dynindx
;
3675 addend
= rel
->r_addend
;
3682 case R_IA64_DIR32MSB
:
3683 dyn_r_type
= R_IA64_REL32MSB
;
3685 case R_IA64_DIR32LSB
:
3686 dyn_r_type
= R_IA64_REL32LSB
;
3688 case R_IA64_DIR64MSB
:
3689 dyn_r_type
= R_IA64_REL64MSB
;
3691 case R_IA64_DIR64LSB
:
3692 dyn_r_type
= R_IA64_REL64LSB
;
3696 /* We can't represent this without a dynamic symbol.
3697 Adjust the relocation to be against an output
3698 section symbol, which are always present in the
3699 dynamic symbol table. */
3700 /* ??? People shouldn't be doing non-pic code in
3701 shared libraries. Hork. */
3702 (*_bfd_error_handler
)
3703 (_("%s: linking non-pic code in a shared library"),
3704 bfd_archive_filename (input_bfd
));
3712 if (elfNN_ia64_aix_vec (info
->hash
->creator
))
3713 rel
->r_addend
= value
;
3714 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
3715 srel
, rel
->r_offset
, dyn_r_type
,
3720 case R_IA64_LTV32MSB
:
3721 case R_IA64_LTV32LSB
:
3722 case R_IA64_LTV64MSB
:
3723 case R_IA64_LTV64LSB
:
3724 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3727 case R_IA64_GPREL22
:
3728 case R_IA64_GPREL64I
:
3729 case R_IA64_GPREL32MSB
:
3730 case R_IA64_GPREL32LSB
:
3731 case R_IA64_GPREL64MSB
:
3732 case R_IA64_GPREL64LSB
:
3733 if (dynamic_symbol_p
)
3735 (*_bfd_error_handler
)
3736 (_("%s: @gprel relocation against dynamic symbol %s"),
3737 bfd_archive_filename (input_bfd
), h
->root
.root
.string
);
3742 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3745 case R_IA64_LTOFF22
:
3746 case R_IA64_LTOFF22X
:
3747 case R_IA64_LTOFF64I
:
3748 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, false);
3749 value
= set_got_entry (input_bfd
, info
, dyn_i
, (h
? h
->dynindx
: -1),
3750 rel
->r_addend
, value
, R_IA64_DIR64LSB
);
3752 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3755 case R_IA64_PLTOFF22
:
3756 case R_IA64_PLTOFF64I
:
3757 case R_IA64_PLTOFF64MSB
:
3758 case R_IA64_PLTOFF64LSB
:
3759 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, false);
3760 value
= set_pltoff_entry (output_bfd
, info
, dyn_i
, value
, false);
3762 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3765 case R_IA64_FPTR64I
:
3766 case R_IA64_FPTR32MSB
:
3767 case R_IA64_FPTR32LSB
:
3768 case R_IA64_FPTR64MSB
:
3769 case R_IA64_FPTR64LSB
:
3770 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, false);
3771 if (dyn_i
->want_fptr
)
3773 if (!undef_weak_ref
)
3774 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
3780 /* Otherwise, we expect the dynamic linker to create
3785 if (h
->dynindx
!= -1)
3786 dynindx
= h
->dynindx
;
3788 dynindx
= (_bfd_elf_link_lookup_local_dynindx
3789 (info
, h
->root
.u
.def
.section
->owner
,
3790 global_sym_index (h
)));
3794 dynindx
= (_bfd_elf_link_lookup_local_dynindx
3795 (info
, input_bfd
, (long) r_symndx
));
3798 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
3799 srel
, rel
->r_offset
, r_type
,
3800 dynindx
, rel
->r_addend
);
3804 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3807 case R_IA64_LTOFF_FPTR22
:
3808 case R_IA64_LTOFF_FPTR64I
:
3809 case R_IA64_LTOFF_FPTR32MSB
:
3810 case R_IA64_LTOFF_FPTR32LSB
:
3811 case R_IA64_LTOFF_FPTR64MSB
:
3812 case R_IA64_LTOFF_FPTR64LSB
:
3816 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, false);
3817 if (dyn_i
->want_fptr
)
3819 BFD_ASSERT (h
== NULL
|| h
->dynindx
== -1)
3820 if (!undef_weak_ref
)
3821 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
3826 /* Otherwise, we expect the dynamic linker to create
3830 if (h
->dynindx
!= -1)
3831 dynindx
= h
->dynindx
;
3833 dynindx
= (_bfd_elf_link_lookup_local_dynindx
3834 (info
, h
->root
.u
.def
.section
->owner
,
3835 global_sym_index (h
)));
3838 dynindx
= (_bfd_elf_link_lookup_local_dynindx
3839 (info
, input_bfd
, (long) r_symndx
));
3843 value
= set_got_entry (output_bfd
, info
, dyn_i
, dynindx
,
3844 rel
->r_addend
, value
, R_IA64_FPTR64LSB
);
3846 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3850 case R_IA64_PCREL32MSB
:
3851 case R_IA64_PCREL32LSB
:
3852 case R_IA64_PCREL64MSB
:
3853 case R_IA64_PCREL64LSB
:
3854 /* Install a dynamic relocation for this reloc. */
3855 if ((dynamic_symbol_p
3856 || elfNN_ia64_aix_vec (info
->hash
->creator
))
3859 BFD_ASSERT (srel
!= NULL
);
3861 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
3862 srel
, rel
->r_offset
, r_type
,
3863 h
->dynindx
, rel
->r_addend
);
3867 case R_IA64_PCREL21BI
:
3868 case R_IA64_PCREL21F
:
3869 case R_IA64_PCREL21M
:
3870 /* ??? These two are only used for speculation fixup code.
3871 They should never be dynamic. */
3872 if (dynamic_symbol_p
)
3874 (*_bfd_error_handler
)
3875 (_("%s: dynamic relocation against speculation fixup"),
3876 bfd_archive_filename (input_bfd
));
3882 (*_bfd_error_handler
)
3883 (_("%s: speculation fixup against undefined weak symbol"),
3884 bfd_archive_filename (input_bfd
));
3890 case R_IA64_PCREL21B
:
3891 case R_IA64_PCREL60B
:
3892 /* We should have created a PLT entry for any dynamic symbol. */
3895 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, false);
3897 if (dyn_i
&& dyn_i
->want_plt2
)
3899 /* Should have caught this earlier. */
3900 BFD_ASSERT (rel
->r_addend
== 0);
3902 value
= (ia64_info
->plt_sec
->output_section
->vma
3903 + ia64_info
->plt_sec
->output_offset
3904 + dyn_i
->plt2_offset
);
3908 /* Since there's no PLT entry, Validate that this is
3910 BFD_ASSERT (undef_weak_ref
|| sym_sec
->output_section
!= NULL
);
3912 /* If the symbol is undef_weak, we shouldn't be trying
3913 to call it. There's every chance that we'd wind up
3914 with an out-of-range fixup here. Don't bother setting
3915 any value at all. */
3921 case R_IA64_PCREL22
:
3922 case R_IA64_PCREL64I
:
3924 /* Make pc-relative. */
3925 value
-= (input_section
->output_section
->vma
3926 + input_section
->output_offset
3927 + rel
->r_offset
) & ~ (bfd_vma
) 0x3;
3928 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3931 case R_IA64_SEGREL32MSB
:
3932 case R_IA64_SEGREL32LSB
:
3933 case R_IA64_SEGREL64MSB
:
3934 case R_IA64_SEGREL64LSB
:
3937 /* If the input section was discarded from the output, then
3943 struct elf_segment_map
*m
;
3944 Elf_Internal_Phdr
*p
;
3946 /* Find the segment that contains the output_section. */
3947 for (m
= elf_tdata (output_bfd
)->segment_map
,
3948 p
= elf_tdata (output_bfd
)->phdr
;
3953 for (i
= m
->count
- 1; i
>= 0; i
--)
3954 if (m
->sections
[i
] == sym_sec
->output_section
)
3962 r
= bfd_reloc_notsupported
;
3966 /* The VMA of the segment is the vaddr of the associated
3968 if (value
> p
->p_vaddr
)
3969 value
-= p
->p_vaddr
;
3972 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
,
3978 case R_IA64_SECREL32MSB
:
3979 case R_IA64_SECREL32LSB
:
3980 case R_IA64_SECREL64MSB
:
3981 case R_IA64_SECREL64LSB
:
3982 /* Make output-section relative. */
3983 if (value
> input_section
->output_section
->vma
)
3984 value
-= input_section
->output_section
->vma
;
3987 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
3990 case R_IA64_IPLTMSB
:
3991 case R_IA64_IPLTLSB
:
3992 /* Install a dynamic relocation for this reloc. */
3993 if ((dynamic_symbol_p
|| info
->shared
)
3994 && (input_section
->flags
& SEC_ALLOC
) != 0)
3996 BFD_ASSERT (srel
!= NULL
);
3998 /* If we don't need dynamic symbol lookup, install two
3999 RELATIVE relocations. */
4000 if (! dynamic_symbol_p
)
4002 unsigned int dyn_r_type
;
4004 if (r_type
== R_IA64_IPLTMSB
)
4005 dyn_r_type
= R_IA64_REL64MSB
;
4007 dyn_r_type
= R_IA64_REL64LSB
;
4009 elfNN_ia64_install_dyn_reloc (output_bfd
, info
,
4011 srel
, rel
->r_offset
,
4012 dyn_r_type
, 0, value
);
4013 elfNN_ia64_install_dyn_reloc (output_bfd
, info
,
4015 srel
, rel
->r_offset
+ 8,
4016 dyn_r_type
, 0, gp_val
);
4019 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4020 srel
, rel
->r_offset
, r_type
,
4021 h
->dynindx
, rel
->r_addend
);
4024 if (r_type
== R_IA64_IPLTMSB
)
4025 r_type
= R_IA64_DIR64MSB
;
4027 r_type
= R_IA64_DIR64LSB
;
4028 elfNN_ia64_install_value (output_bfd
, hit_addr
, value
, r_type
);
4029 r
= elfNN_ia64_install_value (output_bfd
, hit_addr
+ 8, gp_val
,
4034 r
= bfd_reloc_notsupported
;
4043 case bfd_reloc_undefined
:
4044 /* This can happen for global table relative relocs if
4045 __gp is undefined. This is a panic situation so we
4046 don't try to continue. */
4047 (*info
->callbacks
->undefined_symbol
)
4048 (info
, "__gp", input_bfd
, input_section
, rel
->r_offset
, 1);
4051 case bfd_reloc_notsupported
:
4056 name
= h
->root
.root
.string
;
4059 name
= bfd_elf_string_from_elf_section (input_bfd
,
4060 symtab_hdr
->sh_link
,
4065 name
= bfd_section_name (input_bfd
, input_section
);
4067 if (!(*info
->callbacks
->warning
) (info
, _("unsupported reloc"),
4069 input_section
, rel
->r_offset
))
4075 case bfd_reloc_dangerous
:
4076 case bfd_reloc_outofrange
:
4077 case bfd_reloc_overflow
:
4083 name
= h
->root
.root
.string
;
4086 name
= bfd_elf_string_from_elf_section (input_bfd
,
4087 symtab_hdr
->sh_link
,
4092 name
= bfd_section_name (input_bfd
, input_section
);
4094 if (!(*info
->callbacks
->reloc_overflow
) (info
, name
,
4111 elfNN_ia64_finish_dynamic_symbol (output_bfd
, info
, h
, sym
)
4113 struct bfd_link_info
*info
;
4114 struct elf_link_hash_entry
*h
;
4115 Elf_Internal_Sym
*sym
;
4117 struct elfNN_ia64_link_hash_table
*ia64_info
;
4118 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
4120 ia64_info
= elfNN_ia64_hash_table (info
);
4121 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, false);
4123 /* Fill in the PLT data, if required. */
4124 if (dyn_i
&& dyn_i
->want_plt
)
4126 Elf_Internal_Rela outrel
;
4129 bfd_vma plt_addr
, pltoff_addr
, gp_val
, index
;
4130 ElfNN_External_Rela
*rel
;
4132 gp_val
= _bfd_get_gp_value (output_bfd
);
4134 /* Initialize the minimal PLT entry. */
4136 index
= (dyn_i
->plt_offset
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
4137 plt_sec
= ia64_info
->plt_sec
;
4138 loc
= plt_sec
->contents
+ dyn_i
->plt_offset
;
4140 memcpy (loc
, plt_min_entry
, PLT_MIN_ENTRY_SIZE
);
4141 elfNN_ia64_install_value (output_bfd
, loc
, index
, R_IA64_IMM22
);
4142 elfNN_ia64_install_value (output_bfd
, loc
+2, -dyn_i
->plt_offset
,
4145 plt_addr
= (plt_sec
->output_section
->vma
4146 + plt_sec
->output_offset
4147 + dyn_i
->plt_offset
);
4148 pltoff_addr
= set_pltoff_entry (output_bfd
, info
, dyn_i
, plt_addr
, true);
4150 /* Initialize the FULL PLT entry, if needed. */
4151 if (dyn_i
->want_plt2
)
4153 loc
= plt_sec
->contents
+ dyn_i
->plt2_offset
;
4155 memcpy (loc
, plt_full_entry
, PLT_FULL_ENTRY_SIZE
);
4156 elfNN_ia64_install_value (output_bfd
, loc
, pltoff_addr
- gp_val
,
4159 /* Mark the symbol as undefined, rather than as defined in the
4160 plt section. Leave the value alone. */
4161 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
4162 first place. But perhaps elflink.h did some for us. */
4163 if ((h
->elf_link_hash_flags
& ELF_LINK_HASH_DEF_REGULAR
) == 0)
4164 sym
->st_shndx
= SHN_UNDEF
;
4167 /* Create the dynamic relocation. */
4168 outrel
.r_offset
= pltoff_addr
;
4169 if (bfd_little_endian (output_bfd
))
4170 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_IA64_IPLTLSB
);
4172 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_IA64_IPLTMSB
);
4173 outrel
.r_addend
= 0;
4175 /* This is fun. In the .IA_64.pltoff section, we've got entries
4176 that correspond both to real PLT entries, and those that
4177 happened to resolve to local symbols but need to be created
4178 to satisfy @pltoff relocations. The .rela.IA_64.pltoff
4179 relocations for the real PLT should come at the end of the
4180 section, so that they can be indexed by plt entry at runtime.
4182 We emitted all of the relocations for the non-PLT @pltoff
4183 entries during relocate_section. So we can consider the
4184 existing sec->reloc_count to be the base of the array of
4187 rel
= (ElfNN_External_Rela
*)ia64_info
->rel_pltoff_sec
->contents
;
4188 rel
+= ia64_info
->rel_pltoff_sec
->reloc_count
;
4190 bfd_elfNN_swap_reloca_out (output_bfd
, &outrel
, rel
+ index
);
4193 /* Mark some specially defined symbols as absolute. */
4194 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
4195 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0
4196 || strcmp (h
->root
.root
.string
, "_PROCEDURE_LINKAGE_TABLE_") == 0)
4197 sym
->st_shndx
= SHN_ABS
;
4203 elfNN_ia64_finish_dynamic_sections (abfd
, info
)
4205 struct bfd_link_info
*info
;
4207 struct elfNN_ia64_link_hash_table
*ia64_info
;
4210 ia64_info
= elfNN_ia64_hash_table (info
);
4211 dynobj
= ia64_info
->root
.dynobj
;
4213 if (elf_hash_table (info
)->dynamic_sections_created
)
4215 ElfNN_External_Dyn
*dyncon
, *dynconend
;
4216 asection
*sdyn
, *sgotplt
;
4219 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
4220 sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
4221 BFD_ASSERT (sdyn
!= NULL
);
4222 dyncon
= (ElfNN_External_Dyn
*) sdyn
->contents
;
4223 dynconend
= (ElfNN_External_Dyn
*) (sdyn
->contents
+ sdyn
->_raw_size
);
4225 gp_val
= _bfd_get_gp_value (abfd
);
4227 for (; dyncon
< dynconend
; dyncon
++)
4229 Elf_Internal_Dyn dyn
;
4231 bfd_elfNN_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4236 dyn
.d_un
.d_ptr
= gp_val
;
4240 dyn
.d_un
.d_val
= (ia64_info
->minplt_entries
4241 * sizeof (ElfNN_External_Rela
));
4245 /* See the comment above in finish_dynamic_symbol. */
4246 dyn
.d_un
.d_ptr
= (ia64_info
->rel_pltoff_sec
->output_section
->vma
4247 + ia64_info
->rel_pltoff_sec
->output_offset
4248 + (ia64_info
->rel_pltoff_sec
->reloc_count
4249 * sizeof (ElfNN_External_Rela
)));
4252 case DT_IA_64_PLT_RESERVE
:
4253 dyn
.d_un
.d_ptr
= (sgotplt
->output_section
->vma
4254 + sgotplt
->output_offset
);
4258 /* Do not have RELASZ include JMPREL. This makes things
4259 easier on ld.so. This is not what the rest of BFD set up. */
4260 dyn
.d_un
.d_val
-= (ia64_info
->minplt_entries
4261 * sizeof (ElfNN_External_Rela
));
4265 bfd_elfNN_swap_dyn_out (abfd
, &dyn
, dyncon
);
4268 /* Initialize the PLT0 entry */
4269 if (ia64_info
->plt_sec
)
4271 bfd_byte
*loc
= ia64_info
->plt_sec
->contents
;
4274 memcpy (loc
, plt_header
, PLT_HEADER_SIZE
);
4276 pltres
= (sgotplt
->output_section
->vma
4277 + sgotplt
->output_offset
4280 elfNN_ia64_install_value (abfd
, loc
+1, pltres
, R_IA64_GPREL22
);
4287 /* ELF file flag handling: */
4289 /* Function to keep IA-64 specific file flags. */
4291 elfNN_ia64_set_private_flags (abfd
, flags
)
4295 BFD_ASSERT (!elf_flags_init (abfd
)
4296 || elf_elfheader (abfd
)->e_flags
== flags
);
4298 elf_elfheader (abfd
)->e_flags
= flags
;
4299 elf_flags_init (abfd
) = true;
4303 /* Merge backend specific data from an object file to the output
4304 object file when linking. */
4306 elfNN_ia64_merge_private_bfd_data (ibfd
, obfd
)
4313 /* Don't even pretend to support mixed-format linking. */
4314 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4315 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4318 in_flags
= elf_elfheader (ibfd
)->e_flags
;
4319 out_flags
= elf_elfheader (obfd
)->e_flags
;
4321 if (! elf_flags_init (obfd
))
4323 elf_flags_init (obfd
) = true;
4324 elf_elfheader (obfd
)->e_flags
= in_flags
;
4326 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
4327 && bfd_get_arch_info (obfd
)->the_default
)
4329 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
4330 bfd_get_mach (ibfd
));
4336 /* Check flag compatibility. */
4337 if (in_flags
== out_flags
)
4340 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
4341 if (!(in_flags
& EF_IA_64_REDUCEDFP
) && (out_flags
& EF_IA_64_REDUCEDFP
))
4342 elf_elfheader (obfd
)->e_flags
&= ~EF_IA_64_REDUCEDFP
;
4344 if ((in_flags
& EF_IA_64_TRAPNIL
) != (out_flags
& EF_IA_64_TRAPNIL
))
4346 (*_bfd_error_handler
)
4347 (_("%s: linking trap-on-NULL-dereference with non-trapping files"),
4348 bfd_archive_filename (ibfd
));
4350 bfd_set_error (bfd_error_bad_value
);
4353 if ((in_flags
& EF_IA_64_BE
) != (out_flags
& EF_IA_64_BE
))
4355 (*_bfd_error_handler
)
4356 (_("%s: linking big-endian files with little-endian files"),
4357 bfd_archive_filename (ibfd
));
4359 bfd_set_error (bfd_error_bad_value
);
4362 if ((in_flags
& EF_IA_64_ABI64
) != (out_flags
& EF_IA_64_ABI64
))
4364 (*_bfd_error_handler
)
4365 (_("%s: linking 64-bit files with 32-bit files"),
4366 bfd_archive_filename (ibfd
));
4368 bfd_set_error (bfd_error_bad_value
);
4371 if ((in_flags
& EF_IA_64_CONS_GP
) != (out_flags
& EF_IA_64_CONS_GP
))
4373 (*_bfd_error_handler
)
4374 (_("%s: linking constant-gp files with non-constant-gp files"),
4375 bfd_archive_filename (ibfd
));
4377 bfd_set_error (bfd_error_bad_value
);
4380 if ((in_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
)
4381 != (out_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
4383 (*_bfd_error_handler
)
4384 (_("%s: linking auto-pic files with non-auto-pic files"),
4385 bfd_archive_filename (ibfd
));
4387 bfd_set_error (bfd_error_bad_value
);
4395 elfNN_ia64_print_private_bfd_data (abfd
, ptr
)
4399 FILE *file
= (FILE *) ptr
;
4400 flagword flags
= elf_elfheader (abfd
)->e_flags
;
4402 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
4404 fprintf (file
, "private flags = %s%s%s%s%s%s%s%s\n",
4405 (flags
& EF_IA_64_TRAPNIL
) ? "TRAPNIL, " : "",
4406 (flags
& EF_IA_64_EXT
) ? "EXT, " : "",
4407 (flags
& EF_IA_64_BE
) ? "BE, " : "LE, ",
4408 (flags
& EF_IA_64_REDUCEDFP
) ? "REDUCEDFP, " : "",
4409 (flags
& EF_IA_64_CONS_GP
) ? "CONS_GP, " : "",
4410 (flags
& EF_IA_64_NOFUNCDESC_CONS_GP
) ? "NOFUNCDESC_CONS_GP, " : "",
4411 (flags
& EF_IA_64_ABSOLUTE
) ? "ABSOLUTE, " : "",
4412 (flags
& EF_IA_64_ABI64
) ? "ABI64" : "ABI32");
4414 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
4418 static enum elf_reloc_type_class
4419 elfNN_ia64_reloc_type_class (rela
)
4420 const Elf_Internal_Rela
*rela
;
4422 switch ((int) ELFNN_R_TYPE (rela
->r_info
))
4424 case R_IA64_REL32MSB
:
4425 case R_IA64_REL32LSB
:
4426 case R_IA64_REL64MSB
:
4427 case R_IA64_REL64LSB
:
4428 return reloc_class_relative
;
4429 case R_IA64_IPLTMSB
:
4430 case R_IA64_IPLTLSB
:
4431 return reloc_class_plt
;
4433 return reloc_class_copy
;
4435 return reloc_class_normal
;
4440 elfNN_ia64_hpux_vec (const bfd_target
*vec
)
4442 extern const bfd_target bfd_elfNN_ia64_hpux_big_vec
;
4443 return (vec
== & bfd_elfNN_ia64_hpux_big_vec
);
4447 elfNN_hpux_post_process_headers (abfd
, info
)
4449 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
4451 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
4453 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_HPUX
;
4454 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 1;
4458 elfNN_hpux_backend_section_from_bfd_section (abfd
, sec
, retval
)
4459 bfd
*abfd ATTRIBUTE_UNUSED
;
4463 if (bfd_is_com_section (sec
))
4465 *retval
= SHN_IA_64_ANSI_COMMON
;
4471 #define TARGET_LITTLE_SYM bfd_elfNN_ia64_little_vec
4472 #define TARGET_LITTLE_NAME "elfNN-ia64-little"
4473 #define TARGET_BIG_SYM bfd_elfNN_ia64_big_vec
4474 #define TARGET_BIG_NAME "elfNN-ia64-big"
4475 #define ELF_ARCH bfd_arch_ia64
4476 #define ELF_MACHINE_CODE EM_IA_64
4477 #define ELF_MACHINE_ALT1 1999 /* EAS2.3 */
4478 #define ELF_MACHINE_ALT2 1998 /* EAS2.2 */
4479 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
4481 #define elf_backend_section_from_shdr \
4482 elfNN_ia64_section_from_shdr
4483 #define elf_backend_section_flags \
4484 elfNN_ia64_section_flags
4485 #define elf_backend_fake_sections \
4486 elfNN_ia64_fake_sections
4487 #define elf_backend_final_write_processing \
4488 elfNN_ia64_final_write_processing
4489 #define elf_backend_add_symbol_hook \
4490 elfNN_ia64_add_symbol_hook
4491 #define elf_backend_additional_program_headers \
4492 elfNN_ia64_additional_program_headers
4493 #define elf_backend_modify_segment_map \
4494 elfNN_ia64_modify_segment_map
4495 #define elf_info_to_howto \
4496 elfNN_ia64_info_to_howto
4498 #define bfd_elfNN_bfd_reloc_type_lookup \
4499 elfNN_ia64_reloc_type_lookup
4500 #define bfd_elfNN_bfd_is_local_label_name \
4501 elfNN_ia64_is_local_label_name
4502 #define bfd_elfNN_bfd_relax_section \
4503 elfNN_ia64_relax_section
4505 /* Stuff for the BFD linker: */
4506 #define bfd_elfNN_bfd_link_hash_table_create \
4507 elfNN_ia64_hash_table_create
4508 #define elf_backend_create_dynamic_sections \
4509 elfNN_ia64_create_dynamic_sections
4510 #define elf_backend_check_relocs \
4511 elfNN_ia64_check_relocs
4512 #define elf_backend_adjust_dynamic_symbol \
4513 elfNN_ia64_adjust_dynamic_symbol
4514 #define elf_backend_size_dynamic_sections \
4515 elfNN_ia64_size_dynamic_sections
4516 #define elf_backend_relocate_section \
4517 elfNN_ia64_relocate_section
4518 #define elf_backend_finish_dynamic_symbol \
4519 elfNN_ia64_finish_dynamic_symbol
4520 #define elf_backend_finish_dynamic_sections \
4521 elfNN_ia64_finish_dynamic_sections
4522 #define bfd_elfNN_bfd_final_link \
4523 elfNN_ia64_final_link
4525 #define bfd_elfNN_bfd_merge_private_bfd_data \
4526 elfNN_ia64_merge_private_bfd_data
4527 #define bfd_elfNN_bfd_set_private_flags \
4528 elfNN_ia64_set_private_flags
4529 #define bfd_elfNN_bfd_print_private_bfd_data \
4530 elfNN_ia64_print_private_bfd_data
4532 #define elf_backend_plt_readonly 1
4533 #define elf_backend_want_plt_sym 0
4534 #define elf_backend_plt_alignment 5
4535 #define elf_backend_got_header_size 0
4536 #define elf_backend_plt_header_size PLT_HEADER_SIZE
4537 #define elf_backend_want_got_plt 1
4538 #define elf_backend_may_use_rel_p 1
4539 #define elf_backend_may_use_rela_p 1
4540 #define elf_backend_default_use_rela_p 1
4541 #define elf_backend_want_dynbss 0
4542 #define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect
4543 #define elf_backend_hide_symbol elfNN_ia64_hash_hide_symbol
4544 #define elf_backend_reloc_type_class elfNN_ia64_reloc_type_class
4545 #define elf_backend_rela_normal 1
4547 #include "elfNN-target.h"
4549 /* AIX-specific vectors. */
4551 #undef TARGET_LITTLE_SYM
4552 #define TARGET_LITTLE_SYM bfd_elfNN_ia64_aix_little_vec
4553 #undef TARGET_LITTLE_NAME
4554 #define TARGET_LITTLE_NAME "elfNN-ia64-aix-little"
4555 #undef TARGET_BIG_SYM
4556 #define TARGET_BIG_SYM bfd_elfNN_ia64_aix_big_vec
4557 #undef TARGET_BIG_NAME
4558 #define TARGET_BIG_NAME "elfNN-ia64-aix-big"
4560 #undef elf_backend_add_symbol_hook
4561 #define elf_backend_add_symbol_hook elfNN_ia64_aix_add_symbol_hook
4563 #undef bfd_elfNN_bfd_link_add_symbols
4564 #define bfd_elfNN_bfd_link_add_symbols elfNN_ia64_aix_link_add_symbols
4566 #define elfNN_bed elfNN_ia64_aix_bed
4568 #include "elfNN-target.h"
4570 /* HPUX-specific vectors. */
4572 #undef TARGET_LITTLE_SYM
4573 #undef TARGET_LITTLE_NAME
4574 #undef TARGET_BIG_SYM
4575 #define TARGET_BIG_SYM bfd_elfNN_ia64_hpux_big_vec
4576 #undef TARGET_BIG_NAME
4577 #define TARGET_BIG_NAME "elfNN-ia64-hpux-big"
4579 /* We need to undo the AIX specific functions. */
4581 #undef elf_backend_add_symbol_hook
4582 #define elf_backend_add_symbol_hook elfNN_ia64_add_symbol_hook
4584 #undef bfd_elfNN_bfd_link_add_symbols
4585 #define bfd_elfNN_bfd_link_add_symbols _bfd_generic_link_add_symbols
4587 /* These are HP-UX specific functions. */
4589 #undef elf_backend_post_process_headers
4590 #define elf_backend_post_process_headers elfNN_hpux_post_process_headers
4592 #undef elf_backend_section_from_bfd_section
4593 #define elf_backend_section_from_bfd_section elfNN_hpux_backend_section_from_bfd_section
4595 #undef ELF_MAXPAGESIZE
4596 #define ELF_MAXPAGESIZE 0x1000 /* 1K */
4599 #define elfNN_bed elfNN_ia64_hpux_bed
4601 #include "elfNN-target.h"