1 /* IA-64 support for 64-bit ELF
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008, 2009 Free Software Foundation, Inc.
4 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
27 #include "opcode/ia64.h"
35 #define LOG_SECTION_ALIGN 3
39 #define LOG_SECTION_ALIGN 2
42 /* THE RULES for all the stuff the linker creates --
44 GOT Entries created in response to LTOFF or LTOFF_FPTR
45 relocations. Dynamic relocs created for dynamic
46 symbols in an application; REL relocs for locals
49 FPTR The canonical function descriptor. Created for local
50 symbols in applications. Descriptors for dynamic symbols
51 and local symbols in shared libraries are created by
52 ld.so. Thus there are no dynamic relocs against these
53 objects. The FPTR relocs for such _are_ passed through
54 to the dynamic relocation tables.
56 FULL_PLT Created for a PCREL21B relocation against a dynamic symbol.
57 Requires the creation of a PLTOFF entry. This does not
58 require any dynamic relocations.
60 PLTOFF Created by PLTOFF relocations. For local symbols, this
61 is an alternate function descriptor, and in shared libraries
62 requires two REL relocations. Note that this cannot be
63 transformed into an FPTR relocation, since it must be in
64 range of the GP. For dynamic symbols, this is a function
65 descriptor for a MIN_PLT entry, and requires one IPLT reloc.
67 MIN_PLT Created by PLTOFF entries against dynamic symbols. This
68 does not require dynamic relocations. */
70 #define NELEMS(a) ((int) (sizeof (a) / sizeof ((a)[0])))
72 typedef struct bfd_hash_entry
*(*new_hash_entry_func
)
73 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
75 /* In dynamically (linker-) created sections, we generally need to keep track
76 of the place a symbol or expression got allocated to. This is done via hash
77 tables that store entries of the following type. */
79 struct elfNN_ia64_dyn_sym_info
81 /* The addend for which this entry is relevant. */
86 bfd_vma pltoff_offset
;
90 bfd_vma dtpmod_offset
;
91 bfd_vma dtprel_offset
;
93 /* The symbol table entry, if any, that this was derived from. */
94 struct elf_link_hash_entry
*h
;
96 /* Used to count non-got, non-plt relocations for delayed sizing
97 of relocation sections. */
98 struct elfNN_ia64_dyn_reloc_entry
100 struct elfNN_ia64_dyn_reloc_entry
*next
;
105 /* Is this reloc against readonly section? */
109 /* TRUE when the section contents have been updated. */
110 unsigned got_done
: 1;
111 unsigned fptr_done
: 1;
112 unsigned pltoff_done
: 1;
113 unsigned tprel_done
: 1;
114 unsigned dtpmod_done
: 1;
115 unsigned dtprel_done
: 1;
117 /* TRUE for the different kinds of linker data we want created. */
118 unsigned want_got
: 1;
119 unsigned want_gotx
: 1;
120 unsigned want_fptr
: 1;
121 unsigned want_ltoff_fptr
: 1;
122 unsigned want_plt
: 1;
123 unsigned want_plt2
: 1;
124 unsigned want_pltoff
: 1;
125 unsigned want_tprel
: 1;
126 unsigned want_dtpmod
: 1;
127 unsigned want_dtprel
: 1;
130 struct elfNN_ia64_local_hash_entry
134 /* The number of elements in elfNN_ia64_dyn_sym_info array. */
136 /* The number of sorted elements in elfNN_ia64_dyn_sym_info array. */
137 unsigned int sorted_count
;
138 /* The size of elfNN_ia64_dyn_sym_info array. */
140 /* The array of elfNN_ia64_dyn_sym_info. */
141 struct elfNN_ia64_dyn_sym_info
*info
;
143 /* TRUE if this hash entry's addends was translated for
144 SHF_MERGE optimization. */
145 unsigned sec_merge_done
: 1;
148 struct elfNN_ia64_link_hash_entry
150 struct elf_link_hash_entry root
;
151 /* The number of elements in elfNN_ia64_dyn_sym_info array. */
153 /* The number of sorted elements in elfNN_ia64_dyn_sym_info array. */
154 unsigned int sorted_count
;
155 /* The size of elfNN_ia64_dyn_sym_info array. */
157 /* The array of elfNN_ia64_dyn_sym_info. */
158 struct elfNN_ia64_dyn_sym_info
*info
;
161 struct elfNN_ia64_link_hash_table
163 /* The main hash table. */
164 struct elf_link_hash_table root
;
166 asection
*fptr_sec
; /* function descriptor table (or NULL) */
167 asection
*rel_fptr_sec
; /* dynamic relocation section for same */
168 asection
*pltoff_sec
; /* private descriptors for plt (or NULL) */
169 asection
*rel_pltoff_sec
; /* dynamic relocation section for same */
171 bfd_size_type minplt_entries
; /* number of minplt entries */
172 unsigned reltext
: 1; /* are there relocs against readonly sections? */
173 unsigned self_dtpmod_done
: 1;/* has self DTPMOD entry been finished? */
174 bfd_vma self_dtpmod_offset
; /* .got offset to self DTPMOD entry */
175 /* There are maybe R_IA64_GPREL22 relocations, including those
176 optimized from R_IA64_LTOFF22X, against non-SHF_IA_64_SHORT
177 sections. We need to record those sections so that we can choose
178 a proper GP to cover all R_IA64_GPREL22 relocations. */
179 asection
*max_short_sec
; /* maximum short section */
180 bfd_vma max_short_offset
; /* maximum short offset */
181 asection
*min_short_sec
; /* minimum short section */
182 bfd_vma min_short_offset
; /* minimum short offset */
184 htab_t loc_hash_table
;
185 void *loc_hash_memory
;
188 struct elfNN_ia64_allocate_data
190 struct bfd_link_info
*info
;
192 bfd_boolean only_got
;
195 #define elfNN_ia64_hash_table(p) \
196 ((struct elfNN_ia64_link_hash_table *) ((p)->hash))
198 static struct elfNN_ia64_dyn_sym_info
* get_dyn_sym_info
199 (struct elfNN_ia64_link_hash_table
*ia64_info
,
200 struct elf_link_hash_entry
*h
,
201 bfd
*abfd
, const Elf_Internal_Rela
*rel
, bfd_boolean create
);
202 static bfd_boolean elfNN_ia64_dynamic_symbol_p
203 (struct elf_link_hash_entry
*h
, struct bfd_link_info
*info
, int);
204 static bfd_reloc_status_type elfNN_ia64_install_value
205 (bfd_byte
*hit_addr
, bfd_vma val
, unsigned int r_type
);
206 static bfd_boolean elfNN_ia64_choose_gp
207 (bfd
*abfd
, struct bfd_link_info
*info
);
208 static void elfNN_ia64_relax_ldxmov
209 (bfd_byte
*contents
, bfd_vma off
);
210 static void elfNN_ia64_dyn_sym_traverse
211 (struct elfNN_ia64_link_hash_table
*ia64_info
,
212 bfd_boolean (*func
) (struct elfNN_ia64_dyn_sym_info
*, PTR
),
214 static bfd_boolean allocate_global_data_got
215 (struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
);
216 static bfd_boolean allocate_global_fptr_got
217 (struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
);
218 static bfd_boolean allocate_local_got
219 (struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
);
220 static bfd_boolean elfNN_ia64_hpux_vec
221 (const bfd_target
*vec
);
222 static bfd_boolean allocate_dynrel_entries
223 (struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
);
224 static asection
*get_pltoff
225 (bfd
*abfd
, struct bfd_link_info
*info
,
226 struct elfNN_ia64_link_hash_table
*ia64_info
);
228 /* ia64-specific relocation. */
230 /* Perform a relocation. Not much to do here as all the hard work is
231 done in elfNN_ia64_final_link_relocate. */
232 static bfd_reloc_status_type
233 elfNN_ia64_reloc (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*reloc
,
234 asymbol
*sym ATTRIBUTE_UNUSED
,
235 PTR data ATTRIBUTE_UNUSED
, asection
*input_section
,
236 bfd
*output_bfd
, char **error_message
)
240 reloc
->address
+= input_section
->output_offset
;
244 if (input_section
->flags
& SEC_DEBUGGING
)
245 return bfd_reloc_continue
;
247 *error_message
= "Unsupported call to elfNN_ia64_reloc";
248 return bfd_reloc_notsupported
;
251 #define IA64_HOWTO(TYPE, NAME, SIZE, PCREL, IN) \
252 HOWTO (TYPE, 0, SIZE, 0, PCREL, 0, complain_overflow_signed, \
253 elfNN_ia64_reloc, NAME, FALSE, 0, -1, IN)
255 /* This table has to be sorted according to increasing number of the
257 static reloc_howto_type ia64_howto_table
[] =
259 IA64_HOWTO (R_IA64_NONE
, "NONE", 0, FALSE
, TRUE
),
261 IA64_HOWTO (R_IA64_IMM14
, "IMM14", 0, FALSE
, TRUE
),
262 IA64_HOWTO (R_IA64_IMM22
, "IMM22", 0, FALSE
, TRUE
),
263 IA64_HOWTO (R_IA64_IMM64
, "IMM64", 0, FALSE
, TRUE
),
264 IA64_HOWTO (R_IA64_DIR32MSB
, "DIR32MSB", 2, FALSE
, TRUE
),
265 IA64_HOWTO (R_IA64_DIR32LSB
, "DIR32LSB", 2, FALSE
, TRUE
),
266 IA64_HOWTO (R_IA64_DIR64MSB
, "DIR64MSB", 4, FALSE
, TRUE
),
267 IA64_HOWTO (R_IA64_DIR64LSB
, "DIR64LSB", 4, FALSE
, TRUE
),
269 IA64_HOWTO (R_IA64_GPREL22
, "GPREL22", 0, FALSE
, TRUE
),
270 IA64_HOWTO (R_IA64_GPREL64I
, "GPREL64I", 0, FALSE
, TRUE
),
271 IA64_HOWTO (R_IA64_GPREL32MSB
, "GPREL32MSB", 2, FALSE
, TRUE
),
272 IA64_HOWTO (R_IA64_GPREL32LSB
, "GPREL32LSB", 2, FALSE
, TRUE
),
273 IA64_HOWTO (R_IA64_GPREL64MSB
, "GPREL64MSB", 4, FALSE
, TRUE
),
274 IA64_HOWTO (R_IA64_GPREL64LSB
, "GPREL64LSB", 4, FALSE
, TRUE
),
276 IA64_HOWTO (R_IA64_LTOFF22
, "LTOFF22", 0, FALSE
, TRUE
),
277 IA64_HOWTO (R_IA64_LTOFF64I
, "LTOFF64I", 0, FALSE
, TRUE
),
279 IA64_HOWTO (R_IA64_PLTOFF22
, "PLTOFF22", 0, FALSE
, TRUE
),
280 IA64_HOWTO (R_IA64_PLTOFF64I
, "PLTOFF64I", 0, FALSE
, TRUE
),
281 IA64_HOWTO (R_IA64_PLTOFF64MSB
, "PLTOFF64MSB", 4, FALSE
, TRUE
),
282 IA64_HOWTO (R_IA64_PLTOFF64LSB
, "PLTOFF64LSB", 4, FALSE
, TRUE
),
284 IA64_HOWTO (R_IA64_FPTR64I
, "FPTR64I", 0, FALSE
, TRUE
),
285 IA64_HOWTO (R_IA64_FPTR32MSB
, "FPTR32MSB", 2, FALSE
, TRUE
),
286 IA64_HOWTO (R_IA64_FPTR32LSB
, "FPTR32LSB", 2, FALSE
, TRUE
),
287 IA64_HOWTO (R_IA64_FPTR64MSB
, "FPTR64MSB", 4, FALSE
, TRUE
),
288 IA64_HOWTO (R_IA64_FPTR64LSB
, "FPTR64LSB", 4, FALSE
, TRUE
),
290 IA64_HOWTO (R_IA64_PCREL60B
, "PCREL60B", 0, TRUE
, TRUE
),
291 IA64_HOWTO (R_IA64_PCREL21B
, "PCREL21B", 0, TRUE
, TRUE
),
292 IA64_HOWTO (R_IA64_PCREL21M
, "PCREL21M", 0, TRUE
, TRUE
),
293 IA64_HOWTO (R_IA64_PCREL21F
, "PCREL21F", 0, TRUE
, TRUE
),
294 IA64_HOWTO (R_IA64_PCREL32MSB
, "PCREL32MSB", 2, TRUE
, TRUE
),
295 IA64_HOWTO (R_IA64_PCREL32LSB
, "PCREL32LSB", 2, TRUE
, TRUE
),
296 IA64_HOWTO (R_IA64_PCREL64MSB
, "PCREL64MSB", 4, TRUE
, TRUE
),
297 IA64_HOWTO (R_IA64_PCREL64LSB
, "PCREL64LSB", 4, TRUE
, TRUE
),
299 IA64_HOWTO (R_IA64_LTOFF_FPTR22
, "LTOFF_FPTR22", 0, FALSE
, TRUE
),
300 IA64_HOWTO (R_IA64_LTOFF_FPTR64I
, "LTOFF_FPTR64I", 0, FALSE
, TRUE
),
301 IA64_HOWTO (R_IA64_LTOFF_FPTR32MSB
, "LTOFF_FPTR32MSB", 2, FALSE
, TRUE
),
302 IA64_HOWTO (R_IA64_LTOFF_FPTR32LSB
, "LTOFF_FPTR32LSB", 2, FALSE
, TRUE
),
303 IA64_HOWTO (R_IA64_LTOFF_FPTR64MSB
, "LTOFF_FPTR64MSB", 4, FALSE
, TRUE
),
304 IA64_HOWTO (R_IA64_LTOFF_FPTR64LSB
, "LTOFF_FPTR64LSB", 4, FALSE
, TRUE
),
306 IA64_HOWTO (R_IA64_SEGREL32MSB
, "SEGREL32MSB", 2, FALSE
, TRUE
),
307 IA64_HOWTO (R_IA64_SEGREL32LSB
, "SEGREL32LSB", 2, FALSE
, TRUE
),
308 IA64_HOWTO (R_IA64_SEGREL64MSB
, "SEGREL64MSB", 4, FALSE
, TRUE
),
309 IA64_HOWTO (R_IA64_SEGREL64LSB
, "SEGREL64LSB", 4, FALSE
, TRUE
),
311 IA64_HOWTO (R_IA64_SECREL32MSB
, "SECREL32MSB", 2, FALSE
, TRUE
),
312 IA64_HOWTO (R_IA64_SECREL32LSB
, "SECREL32LSB", 2, FALSE
, TRUE
),
313 IA64_HOWTO (R_IA64_SECREL64MSB
, "SECREL64MSB", 4, FALSE
, TRUE
),
314 IA64_HOWTO (R_IA64_SECREL64LSB
, "SECREL64LSB", 4, FALSE
, TRUE
),
316 IA64_HOWTO (R_IA64_REL32MSB
, "REL32MSB", 2, FALSE
, TRUE
),
317 IA64_HOWTO (R_IA64_REL32LSB
, "REL32LSB", 2, FALSE
, TRUE
),
318 IA64_HOWTO (R_IA64_REL64MSB
, "REL64MSB", 4, FALSE
, TRUE
),
319 IA64_HOWTO (R_IA64_REL64LSB
, "REL64LSB", 4, FALSE
, TRUE
),
321 IA64_HOWTO (R_IA64_LTV32MSB
, "LTV32MSB", 2, FALSE
, TRUE
),
322 IA64_HOWTO (R_IA64_LTV32LSB
, "LTV32LSB", 2, FALSE
, TRUE
),
323 IA64_HOWTO (R_IA64_LTV64MSB
, "LTV64MSB", 4, FALSE
, TRUE
),
324 IA64_HOWTO (R_IA64_LTV64LSB
, "LTV64LSB", 4, FALSE
, TRUE
),
326 IA64_HOWTO (R_IA64_PCREL21BI
, "PCREL21BI", 0, TRUE
, TRUE
),
327 IA64_HOWTO (R_IA64_PCREL22
, "PCREL22", 0, TRUE
, TRUE
),
328 IA64_HOWTO (R_IA64_PCREL64I
, "PCREL64I", 0, TRUE
, TRUE
),
330 IA64_HOWTO (R_IA64_IPLTMSB
, "IPLTMSB", 4, FALSE
, TRUE
),
331 IA64_HOWTO (R_IA64_IPLTLSB
, "IPLTLSB", 4, FALSE
, TRUE
),
332 IA64_HOWTO (R_IA64_COPY
, "COPY", 4, FALSE
, TRUE
),
333 IA64_HOWTO (R_IA64_LTOFF22X
, "LTOFF22X", 0, FALSE
, TRUE
),
334 IA64_HOWTO (R_IA64_LDXMOV
, "LDXMOV", 0, FALSE
, TRUE
),
336 IA64_HOWTO (R_IA64_TPREL14
, "TPREL14", 0, FALSE
, FALSE
),
337 IA64_HOWTO (R_IA64_TPREL22
, "TPREL22", 0, FALSE
, FALSE
),
338 IA64_HOWTO (R_IA64_TPREL64I
, "TPREL64I", 0, FALSE
, FALSE
),
339 IA64_HOWTO (R_IA64_TPREL64MSB
, "TPREL64MSB", 4, FALSE
, FALSE
),
340 IA64_HOWTO (R_IA64_TPREL64LSB
, "TPREL64LSB", 4, FALSE
, FALSE
),
341 IA64_HOWTO (R_IA64_LTOFF_TPREL22
, "LTOFF_TPREL22", 0, FALSE
, FALSE
),
343 IA64_HOWTO (R_IA64_DTPMOD64MSB
, "DTPMOD64MSB", 4, FALSE
, FALSE
),
344 IA64_HOWTO (R_IA64_DTPMOD64LSB
, "DTPMOD64LSB", 4, FALSE
, FALSE
),
345 IA64_HOWTO (R_IA64_LTOFF_DTPMOD22
, "LTOFF_DTPMOD22", 0, FALSE
, FALSE
),
347 IA64_HOWTO (R_IA64_DTPREL14
, "DTPREL14", 0, FALSE
, FALSE
),
348 IA64_HOWTO (R_IA64_DTPREL22
, "DTPREL22", 0, FALSE
, FALSE
),
349 IA64_HOWTO (R_IA64_DTPREL64I
, "DTPREL64I", 0, FALSE
, FALSE
),
350 IA64_HOWTO (R_IA64_DTPREL32MSB
, "DTPREL32MSB", 2, FALSE
, FALSE
),
351 IA64_HOWTO (R_IA64_DTPREL32LSB
, "DTPREL32LSB", 2, FALSE
, FALSE
),
352 IA64_HOWTO (R_IA64_DTPREL64MSB
, "DTPREL64MSB", 4, FALSE
, FALSE
),
353 IA64_HOWTO (R_IA64_DTPREL64LSB
, "DTPREL64LSB", 4, FALSE
, FALSE
),
354 IA64_HOWTO (R_IA64_LTOFF_DTPREL22
, "LTOFF_DTPREL22", 0, FALSE
, FALSE
),
357 static unsigned char elf_code_to_howto_index
[R_IA64_MAX_RELOC_CODE
+ 1];
359 /* Given a BFD reloc type, return the matching HOWTO structure. */
361 static reloc_howto_type
*
362 lookup_howto (unsigned int rtype
)
364 static int inited
= 0;
371 memset (elf_code_to_howto_index
, 0xff, sizeof (elf_code_to_howto_index
));
372 for (i
= 0; i
< NELEMS (ia64_howto_table
); ++i
)
373 elf_code_to_howto_index
[ia64_howto_table
[i
].type
] = i
;
376 if (rtype
> R_IA64_MAX_RELOC_CODE
)
378 i
= elf_code_to_howto_index
[rtype
];
379 if (i
>= NELEMS (ia64_howto_table
))
381 return ia64_howto_table
+ i
;
384 static reloc_howto_type
*
385 elfNN_ia64_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
386 bfd_reloc_code_real_type bfd_code
)
392 case BFD_RELOC_NONE
: rtype
= R_IA64_NONE
; break;
394 case BFD_RELOC_IA64_IMM14
: rtype
= R_IA64_IMM14
; break;
395 case BFD_RELOC_IA64_IMM22
: rtype
= R_IA64_IMM22
; break;
396 case BFD_RELOC_IA64_IMM64
: rtype
= R_IA64_IMM64
; break;
398 case BFD_RELOC_IA64_DIR32MSB
: rtype
= R_IA64_DIR32MSB
; break;
399 case BFD_RELOC_IA64_DIR32LSB
: rtype
= R_IA64_DIR32LSB
; break;
400 case BFD_RELOC_IA64_DIR64MSB
: rtype
= R_IA64_DIR64MSB
; break;
401 case BFD_RELOC_IA64_DIR64LSB
: rtype
= R_IA64_DIR64LSB
; break;
403 case BFD_RELOC_IA64_GPREL22
: rtype
= R_IA64_GPREL22
; break;
404 case BFD_RELOC_IA64_GPREL64I
: rtype
= R_IA64_GPREL64I
; break;
405 case BFD_RELOC_IA64_GPREL32MSB
: rtype
= R_IA64_GPREL32MSB
; break;
406 case BFD_RELOC_IA64_GPREL32LSB
: rtype
= R_IA64_GPREL32LSB
; break;
407 case BFD_RELOC_IA64_GPREL64MSB
: rtype
= R_IA64_GPREL64MSB
; break;
408 case BFD_RELOC_IA64_GPREL64LSB
: rtype
= R_IA64_GPREL64LSB
; break;
410 case BFD_RELOC_IA64_LTOFF22
: rtype
= R_IA64_LTOFF22
; break;
411 case BFD_RELOC_IA64_LTOFF64I
: rtype
= R_IA64_LTOFF64I
; break;
413 case BFD_RELOC_IA64_PLTOFF22
: rtype
= R_IA64_PLTOFF22
; break;
414 case BFD_RELOC_IA64_PLTOFF64I
: rtype
= R_IA64_PLTOFF64I
; break;
415 case BFD_RELOC_IA64_PLTOFF64MSB
: rtype
= R_IA64_PLTOFF64MSB
; break;
416 case BFD_RELOC_IA64_PLTOFF64LSB
: rtype
= R_IA64_PLTOFF64LSB
; break;
417 case BFD_RELOC_IA64_FPTR64I
: rtype
= R_IA64_FPTR64I
; break;
418 case BFD_RELOC_IA64_FPTR32MSB
: rtype
= R_IA64_FPTR32MSB
; break;
419 case BFD_RELOC_IA64_FPTR32LSB
: rtype
= R_IA64_FPTR32LSB
; break;
420 case BFD_RELOC_IA64_FPTR64MSB
: rtype
= R_IA64_FPTR64MSB
; break;
421 case BFD_RELOC_IA64_FPTR64LSB
: rtype
= R_IA64_FPTR64LSB
; break;
423 case BFD_RELOC_IA64_PCREL21B
: rtype
= R_IA64_PCREL21B
; break;
424 case BFD_RELOC_IA64_PCREL21BI
: rtype
= R_IA64_PCREL21BI
; break;
425 case BFD_RELOC_IA64_PCREL21M
: rtype
= R_IA64_PCREL21M
; break;
426 case BFD_RELOC_IA64_PCREL21F
: rtype
= R_IA64_PCREL21F
; break;
427 case BFD_RELOC_IA64_PCREL22
: rtype
= R_IA64_PCREL22
; break;
428 case BFD_RELOC_IA64_PCREL60B
: rtype
= R_IA64_PCREL60B
; break;
429 case BFD_RELOC_IA64_PCREL64I
: rtype
= R_IA64_PCREL64I
; break;
430 case BFD_RELOC_IA64_PCREL32MSB
: rtype
= R_IA64_PCREL32MSB
; break;
431 case BFD_RELOC_IA64_PCREL32LSB
: rtype
= R_IA64_PCREL32LSB
; break;
432 case BFD_RELOC_IA64_PCREL64MSB
: rtype
= R_IA64_PCREL64MSB
; break;
433 case BFD_RELOC_IA64_PCREL64LSB
: rtype
= R_IA64_PCREL64LSB
; break;
435 case BFD_RELOC_IA64_LTOFF_FPTR22
: rtype
= R_IA64_LTOFF_FPTR22
; break;
436 case BFD_RELOC_IA64_LTOFF_FPTR64I
: rtype
= R_IA64_LTOFF_FPTR64I
; break;
437 case BFD_RELOC_IA64_LTOFF_FPTR32MSB
: rtype
= R_IA64_LTOFF_FPTR32MSB
; break;
438 case BFD_RELOC_IA64_LTOFF_FPTR32LSB
: rtype
= R_IA64_LTOFF_FPTR32LSB
; break;
439 case BFD_RELOC_IA64_LTOFF_FPTR64MSB
: rtype
= R_IA64_LTOFF_FPTR64MSB
; break;
440 case BFD_RELOC_IA64_LTOFF_FPTR64LSB
: rtype
= R_IA64_LTOFF_FPTR64LSB
; break;
442 case BFD_RELOC_IA64_SEGREL32MSB
: rtype
= R_IA64_SEGREL32MSB
; break;
443 case BFD_RELOC_IA64_SEGREL32LSB
: rtype
= R_IA64_SEGREL32LSB
; break;
444 case BFD_RELOC_IA64_SEGREL64MSB
: rtype
= R_IA64_SEGREL64MSB
; break;
445 case BFD_RELOC_IA64_SEGREL64LSB
: rtype
= R_IA64_SEGREL64LSB
; break;
447 case BFD_RELOC_IA64_SECREL32MSB
: rtype
= R_IA64_SECREL32MSB
; break;
448 case BFD_RELOC_IA64_SECREL32LSB
: rtype
= R_IA64_SECREL32LSB
; break;
449 case BFD_RELOC_IA64_SECREL64MSB
: rtype
= R_IA64_SECREL64MSB
; break;
450 case BFD_RELOC_IA64_SECREL64LSB
: rtype
= R_IA64_SECREL64LSB
; break;
452 case BFD_RELOC_IA64_REL32MSB
: rtype
= R_IA64_REL32MSB
; break;
453 case BFD_RELOC_IA64_REL32LSB
: rtype
= R_IA64_REL32LSB
; break;
454 case BFD_RELOC_IA64_REL64MSB
: rtype
= R_IA64_REL64MSB
; break;
455 case BFD_RELOC_IA64_REL64LSB
: rtype
= R_IA64_REL64LSB
; break;
457 case BFD_RELOC_IA64_LTV32MSB
: rtype
= R_IA64_LTV32MSB
; break;
458 case BFD_RELOC_IA64_LTV32LSB
: rtype
= R_IA64_LTV32LSB
; break;
459 case BFD_RELOC_IA64_LTV64MSB
: rtype
= R_IA64_LTV64MSB
; break;
460 case BFD_RELOC_IA64_LTV64LSB
: rtype
= R_IA64_LTV64LSB
; break;
462 case BFD_RELOC_IA64_IPLTMSB
: rtype
= R_IA64_IPLTMSB
; break;
463 case BFD_RELOC_IA64_IPLTLSB
: rtype
= R_IA64_IPLTLSB
; break;
464 case BFD_RELOC_IA64_COPY
: rtype
= R_IA64_COPY
; break;
465 case BFD_RELOC_IA64_LTOFF22X
: rtype
= R_IA64_LTOFF22X
; break;
466 case BFD_RELOC_IA64_LDXMOV
: rtype
= R_IA64_LDXMOV
; break;
468 case BFD_RELOC_IA64_TPREL14
: rtype
= R_IA64_TPREL14
; break;
469 case BFD_RELOC_IA64_TPREL22
: rtype
= R_IA64_TPREL22
; break;
470 case BFD_RELOC_IA64_TPREL64I
: rtype
= R_IA64_TPREL64I
; break;
471 case BFD_RELOC_IA64_TPREL64MSB
: rtype
= R_IA64_TPREL64MSB
; break;
472 case BFD_RELOC_IA64_TPREL64LSB
: rtype
= R_IA64_TPREL64LSB
; break;
473 case BFD_RELOC_IA64_LTOFF_TPREL22
: rtype
= R_IA64_LTOFF_TPREL22
; break;
475 case BFD_RELOC_IA64_DTPMOD64MSB
: rtype
= R_IA64_DTPMOD64MSB
; break;
476 case BFD_RELOC_IA64_DTPMOD64LSB
: rtype
= R_IA64_DTPMOD64LSB
; break;
477 case BFD_RELOC_IA64_LTOFF_DTPMOD22
: rtype
= R_IA64_LTOFF_DTPMOD22
; break;
479 case BFD_RELOC_IA64_DTPREL14
: rtype
= R_IA64_DTPREL14
; break;
480 case BFD_RELOC_IA64_DTPREL22
: rtype
= R_IA64_DTPREL22
; break;
481 case BFD_RELOC_IA64_DTPREL64I
: rtype
= R_IA64_DTPREL64I
; break;
482 case BFD_RELOC_IA64_DTPREL32MSB
: rtype
= R_IA64_DTPREL32MSB
; break;
483 case BFD_RELOC_IA64_DTPREL32LSB
: rtype
= R_IA64_DTPREL32LSB
; break;
484 case BFD_RELOC_IA64_DTPREL64MSB
: rtype
= R_IA64_DTPREL64MSB
; break;
485 case BFD_RELOC_IA64_DTPREL64LSB
: rtype
= R_IA64_DTPREL64LSB
; break;
486 case BFD_RELOC_IA64_LTOFF_DTPREL22
: rtype
= R_IA64_LTOFF_DTPREL22
; break;
490 return lookup_howto (rtype
);
493 static reloc_howto_type
*
494 elfNN_ia64_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
500 i
< sizeof (ia64_howto_table
) / sizeof (ia64_howto_table
[0]);
502 if (ia64_howto_table
[i
].name
!= NULL
503 && strcasecmp (ia64_howto_table
[i
].name
, r_name
) == 0)
504 return &ia64_howto_table
[i
];
509 /* Given a ELF reloc, return the matching HOWTO structure. */
512 elfNN_ia64_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
514 Elf_Internal_Rela
*elf_reloc
)
517 = lookup_howto ((unsigned int) ELFNN_R_TYPE (elf_reloc
->r_info
));
520 #define PLT_HEADER_SIZE (3 * 16)
521 #define PLT_MIN_ENTRY_SIZE (1 * 16)
522 #define PLT_FULL_ENTRY_SIZE (2 * 16)
523 #define PLT_RESERVED_WORDS 3
525 static const bfd_byte plt_header
[PLT_HEADER_SIZE
] =
527 0x0b, 0x10, 0x00, 0x1c, 0x00, 0x21, /* [MMI] mov r2=r14;; */
528 0xe0, 0x00, 0x08, 0x00, 0x48, 0x00, /* addl r14=0,r2 */
529 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
530 0x0b, 0x80, 0x20, 0x1c, 0x18, 0x14, /* [MMI] ld8 r16=[r14],8;; */
531 0x10, 0x41, 0x38, 0x30, 0x28, 0x00, /* ld8 r17=[r14],8 */
532 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
533 0x11, 0x08, 0x00, 0x1c, 0x18, 0x10, /* [MIB] ld8 r1=[r14] */
534 0x60, 0x88, 0x04, 0x80, 0x03, 0x00, /* mov b6=r17 */
535 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
538 static const bfd_byte plt_min_entry
[PLT_MIN_ENTRY_SIZE
] =
540 0x11, 0x78, 0x00, 0x00, 0x00, 0x24, /* [MIB] mov r15=0 */
541 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, /* nop.i 0x0 */
542 0x00, 0x00, 0x00, 0x40 /* br.few 0 <PLT0>;; */
545 static const bfd_byte plt_full_entry
[PLT_FULL_ENTRY_SIZE
] =
547 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
548 0x00, 0x41, 0x3c, 0x70, 0x29, 0xc0, /* ld8.acq r16=[r15],8*/
549 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
550 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
551 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
552 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
555 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
557 static const bfd_byte oor_brl
[16] =
559 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
560 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;; */
561 0x00, 0x00, 0x00, 0xc0
564 static const bfd_byte oor_ip
[48] =
566 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
567 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, /* movl r15=0 */
568 0x01, 0x00, 0x00, 0x60,
569 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MII] nop.m 0 */
570 0x00, 0x01, 0x00, 0x60, 0x00, 0x00, /* mov r16=ip;; */
571 0xf2, 0x80, 0x00, 0x80, /* add r16=r15,r16;; */
572 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MIB] nop.m 0 */
573 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
574 0x60, 0x00, 0x80, 0x00 /* br b6;; */
577 static size_t oor_branch_size
= sizeof (oor_brl
);
580 bfd_elfNN_ia64_after_parse (int itanium
)
582 oor_branch_size
= itanium
? sizeof (oor_ip
) : sizeof (oor_brl
);
585 #define BTYPE_SHIFT 6
592 #define OPCODE_SHIFT 37
594 #define OPCODE_BITS (0xfLL << OPCODE_SHIFT)
595 #define X6_BITS (0x3fLL << X6_SHIFT)
596 #define X4_BITS (0xfLL << X4_SHIFT)
597 #define X3_BITS (0x7LL << X3_SHIFT)
598 #define X2_BITS (0x3LL << X2_SHIFT)
599 #define X_BITS (0x1LL << X_SHIFT)
600 #define Y_BITS (0x1LL << Y_SHIFT)
601 #define BTYPE_BITS (0x7LL << BTYPE_SHIFT)
602 #define PREDICATE_BITS (0x3fLL)
604 #define IS_NOP_B(i) \
605 (((i) & (OPCODE_BITS | X6_BITS)) == (2LL << OPCODE_SHIFT))
606 #define IS_NOP_F(i) \
607 (((i) & (OPCODE_BITS | X_BITS | X6_BITS | Y_BITS)) \
608 == (0x1LL << X6_SHIFT))
609 #define IS_NOP_I(i) \
610 (((i) & (OPCODE_BITS | X3_BITS | X6_BITS | Y_BITS)) \
611 == (0x1LL << X6_SHIFT))
612 #define IS_NOP_M(i) \
613 (((i) & (OPCODE_BITS | X3_BITS | X2_BITS | X4_BITS | Y_BITS)) \
614 == (0x1LL << X4_SHIFT))
615 #define IS_BR_COND(i) \
616 (((i) & (OPCODE_BITS | BTYPE_BITS)) == (0x4LL << OPCODE_SHIFT))
617 #define IS_BR_CALL(i) \
618 (((i) & OPCODE_BITS) == (0x5LL << OPCODE_SHIFT))
621 elfNN_ia64_relax_br (bfd_byte
*contents
, bfd_vma off
)
623 unsigned int template_val
, mlx
;
624 bfd_vma t0
, t1
, s0
, s1
, s2
, br_code
;
628 hit_addr
= (bfd_byte
*) (contents
+ off
);
629 br_slot
= (long) hit_addr
& 0x3;
631 t0
= bfd_getl64 (hit_addr
+ 0);
632 t1
= bfd_getl64 (hit_addr
+ 8);
634 /* Check if we can turn br into brl. A label is always at the start
635 of the bundle. Even if there are predicates on NOPs, we still
636 perform this optimization. */
637 template_val
= t0
& 0x1e;
638 s0
= (t0
>> 5) & 0x1ffffffffffLL
;
639 s1
= ((t0
>> 46) | (t1
<< 18)) & 0x1ffffffffffLL
;
640 s2
= (t1
>> 23) & 0x1ffffffffffLL
;
644 /* Check if slot 1 and slot 2 are NOPs. Possible template is
645 BBB. We only need to check nop.b. */
646 if (!(IS_NOP_B (s1
) && IS_NOP_B (s2
)))
651 /* Check if slot 2 is NOP. Possible templates are MBB and BBB.
652 For BBB, slot 0 also has to be nop.b. */
653 if (!((template_val
== 0x12 /* MBB */
655 || (template_val
== 0x16 /* BBB */
662 /* Check if slot 1 is NOP. Possible templates are MIB, MBB, BBB,
663 MMB and MFB. For BBB, slot 0 also has to be nop.b. */
664 if (!((template_val
== 0x10 /* MIB */
666 || (template_val
== 0x12 /* MBB */
668 || (template_val
== 0x16 /* BBB */
671 || (template_val
== 0x18 /* MMB */
673 || (template_val
== 0x1c /* MFB */
679 /* It should never happen. */
683 /* We can turn br.cond/br.call into brl.cond/brl.call. */
684 if (!(IS_BR_COND (br_code
) || IS_BR_CALL (br_code
)))
687 /* Turn br into brl by setting bit 40. */
688 br_code
|= 0x1LL
<< 40;
690 /* Turn the old bundle into a MLX bundle with the same stop-bit
697 if (template_val
== 0x16)
699 /* For BBB, we need to put nop.m in slot 0. We keep the original
700 predicate only if slot 0 isn't br. */
704 t0
&= PREDICATE_BITS
<< 5;
705 t0
|= 0x1LL
<< (X4_SHIFT
+ 5);
709 /* Keep the original instruction in slot 0. */
710 t0
&= 0x1ffffffffffLL
<< 5;
715 /* Put brl in slot 1. */
718 bfd_putl64 (t0
, hit_addr
);
719 bfd_putl64 (t1
, hit_addr
+ 8);
724 elfNN_ia64_relax_brl (bfd_byte
*contents
, bfd_vma off
)
728 bfd_vma t0
, t1
, i0
, i1
, i2
;
730 hit_addr
= (bfd_byte
*) (contents
+ off
);
731 hit_addr
-= (long) hit_addr
& 0x3;
732 t0
= bfd_getl64 (hit_addr
);
733 t1
= bfd_getl64 (hit_addr
+ 8);
735 /* Keep the instruction in slot 0. */
736 i0
= (t0
>> 5) & 0x1ffffffffffLL
;
737 /* Use nop.b for slot 1. */
739 /* For slot 2, turn brl into br by masking out bit 40. */
740 i2
= (t1
>> 23) & 0x0ffffffffffLL
;
742 /* Turn a MLX bundle into a MBB bundle with the same stop-bit
748 t0
= (i1
<< 46) | (i0
<< 5) | template_val
;
749 t1
= (i2
<< 23) | (i1
>> 18);
751 bfd_putl64 (t0
, hit_addr
);
752 bfd_putl64 (t1
, hit_addr
+ 8);
755 /* Rename some of the generic section flags to better document how they
757 #define skip_relax_pass_0 need_finalize_relax
758 #define skip_relax_pass_1 has_gp_reloc
761 /* These functions do relaxation for IA-64 ELF. */
764 elfNN_ia64_update_short_info (asection
*sec
, bfd_vma offset
,
765 struct elfNN_ia64_link_hash_table
*ia64_info
)
767 /* Skip SHF_IA_64_SHORT sections. */
768 if (sec
->flags
& SEC_SMALL_DATA
)
771 if (!ia64_info
->min_short_sec
)
773 ia64_info
->max_short_sec
= sec
;
774 ia64_info
->max_short_offset
= offset
;
775 ia64_info
->min_short_sec
= sec
;
776 ia64_info
->min_short_offset
= offset
;
778 else if (sec
== ia64_info
->max_short_sec
779 && offset
> ia64_info
->max_short_offset
)
780 ia64_info
->max_short_offset
= offset
;
781 else if (sec
== ia64_info
->min_short_sec
782 && offset
< ia64_info
->min_short_offset
)
783 ia64_info
->min_short_offset
= offset
;
784 else if (sec
->output_section
->vma
785 > ia64_info
->max_short_sec
->output_section
->vma
)
787 ia64_info
->max_short_sec
= sec
;
788 ia64_info
->max_short_offset
= offset
;
790 else if (sec
->output_section
->vma
791 < ia64_info
->min_short_sec
->output_section
->vma
)
793 ia64_info
->min_short_sec
= sec
;
794 ia64_info
->min_short_offset
= offset
;
799 elfNN_ia64_relax_section (bfd
*abfd
, asection
*sec
,
800 struct bfd_link_info
*link_info
,
805 struct one_fixup
*next
;
811 Elf_Internal_Shdr
*symtab_hdr
;
812 Elf_Internal_Rela
*internal_relocs
;
813 Elf_Internal_Rela
*irel
, *irelend
;
815 Elf_Internal_Sym
*isymbuf
= NULL
;
816 struct elfNN_ia64_link_hash_table
*ia64_info
;
817 struct one_fixup
*fixups
= NULL
;
818 bfd_boolean changed_contents
= FALSE
;
819 bfd_boolean changed_relocs
= FALSE
;
820 bfd_boolean changed_got
= FALSE
;
821 bfd_boolean skip_relax_pass_0
= TRUE
;
822 bfd_boolean skip_relax_pass_1
= TRUE
;
825 /* Assume we're not going to change any sizes, and we'll only need
829 if (link_info
->relocatable
)
830 (*link_info
->callbacks
->einfo
)
831 (_("%P%F: --relax and -r may not be used together\n"));
833 /* Don't even try to relax for non-ELF outputs. */
834 if (!is_elf_hash_table (link_info
->hash
))
837 /* Nothing to do if there are no relocations or there is no need for
839 if ((sec
->flags
& SEC_RELOC
) == 0
840 || sec
->reloc_count
== 0
841 || (link_info
->relax_pass
== 0 && sec
->skip_relax_pass_0
)
842 || (link_info
->relax_pass
== 1 && sec
->skip_relax_pass_1
))
845 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
847 /* Load the relocations for this section. */
848 internal_relocs
= (_bfd_elf_link_read_relocs
849 (abfd
, sec
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
850 link_info
->keep_memory
));
851 if (internal_relocs
== NULL
)
854 ia64_info
= elfNN_ia64_hash_table (link_info
);
855 irelend
= internal_relocs
+ sec
->reloc_count
;
857 /* Get the section contents. */
858 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
859 contents
= elf_section_data (sec
)->this_hdr
.contents
;
862 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
866 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
868 unsigned long r_type
= ELFNN_R_TYPE (irel
->r_info
);
869 bfd_vma symaddr
, reladdr
, trampoff
, toff
, roff
;
873 bfd_boolean is_branch
;
874 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
879 case R_IA64_PCREL21B
:
880 case R_IA64_PCREL21BI
:
881 case R_IA64_PCREL21M
:
882 case R_IA64_PCREL21F
:
883 /* In pass 1, all br relaxations are done. We can skip it. */
884 if (link_info
->relax_pass
== 1)
886 skip_relax_pass_0
= FALSE
;
890 case R_IA64_PCREL60B
:
891 /* We can't optimize brl to br in pass 0 since br relaxations
892 will increase the code size. Defer it to pass 1. */
893 if (link_info
->relax_pass
== 0)
895 skip_relax_pass_1
= FALSE
;
902 /* Update max_short_sec/min_short_sec. */
904 case R_IA64_LTOFF22X
:
906 /* We can't relax ldx/mov in pass 0 since br relaxations will
907 increase the code size. Defer it to pass 1. */
908 if (link_info
->relax_pass
== 0)
910 skip_relax_pass_1
= FALSE
;
920 /* Get the value of the symbol referred to by the reloc. */
921 if (ELFNN_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
923 /* A local symbol. */
924 Elf_Internal_Sym
*isym
;
926 /* Read this BFD's local symbols. */
929 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
931 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
932 symtab_hdr
->sh_info
, 0,
938 isym
= isymbuf
+ ELFNN_R_SYM (irel
->r_info
);
939 if (isym
->st_shndx
== SHN_UNDEF
)
940 continue; /* We can't do anything with undefined symbols. */
941 else if (isym
->st_shndx
== SHN_ABS
)
942 tsec
= bfd_abs_section_ptr
;
943 else if (isym
->st_shndx
== SHN_COMMON
)
944 tsec
= bfd_com_section_ptr
;
945 else if (isym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
946 tsec
= bfd_com_section_ptr
;
948 tsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
950 toff
= isym
->st_value
;
951 dyn_i
= get_dyn_sym_info (ia64_info
, NULL
, abfd
, irel
, FALSE
);
952 symtype
= ELF_ST_TYPE (isym
->st_info
);
957 struct elf_link_hash_entry
*h
;
959 indx
= ELFNN_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
960 h
= elf_sym_hashes (abfd
)[indx
];
961 BFD_ASSERT (h
!= NULL
);
963 while (h
->root
.type
== bfd_link_hash_indirect
964 || h
->root
.type
== bfd_link_hash_warning
)
965 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
967 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, irel
, FALSE
);
969 /* For branches to dynamic symbols, we're interested instead
970 in a branch to the PLT entry. */
971 if (is_branch
&& dyn_i
&& dyn_i
->want_plt2
)
973 /* Internal branches shouldn't be sent to the PLT.
974 Leave this for now and we'll give an error later. */
975 if (r_type
!= R_IA64_PCREL21B
)
978 tsec
= ia64_info
->root
.splt
;
979 toff
= dyn_i
->plt2_offset
;
980 BFD_ASSERT (irel
->r_addend
== 0);
983 /* Can't do anything else with dynamic symbols. */
984 else if (elfNN_ia64_dynamic_symbol_p (h
, link_info
, r_type
))
989 /* We can't do anything with undefined symbols. */
990 if (h
->root
.type
== bfd_link_hash_undefined
991 || h
->root
.type
== bfd_link_hash_undefweak
)
994 tsec
= h
->root
.u
.def
.section
;
995 toff
= h
->root
.u
.def
.value
;
1001 if (tsec
->sec_info_type
== ELF_INFO_TYPE_MERGE
)
1003 /* At this stage in linking, no SEC_MERGE symbol has been
1004 adjusted, so all references to such symbols need to be
1005 passed through _bfd_merged_section_offset. (Later, in
1006 relocate_section, all SEC_MERGE symbols *except* for
1007 section symbols have been adjusted.)
1009 gas may reduce relocations against symbols in SEC_MERGE
1010 sections to a relocation against the section symbol when
1011 the original addend was zero. When the reloc is against
1012 a section symbol we should include the addend in the
1013 offset passed to _bfd_merged_section_offset, since the
1014 location of interest is the original symbol. On the
1015 other hand, an access to "sym+addend" where "sym" is not
1016 a section symbol should not include the addend; Such an
1017 access is presumed to be an offset from "sym"; The
1018 location of interest is just "sym". */
1019 if (symtype
== STT_SECTION
)
1020 toff
+= irel
->r_addend
;
1022 toff
= _bfd_merged_section_offset (abfd
, &tsec
,
1023 elf_section_data (tsec
)->sec_info
,
1026 if (symtype
!= STT_SECTION
)
1027 toff
+= irel
->r_addend
;
1030 toff
+= irel
->r_addend
;
1032 symaddr
= tsec
->output_section
->vma
+ tsec
->output_offset
+ toff
;
1034 roff
= irel
->r_offset
;
1038 bfd_signed_vma offset
;
1040 reladdr
= (sec
->output_section
->vma
1041 + sec
->output_offset
1042 + roff
) & (bfd_vma
) -4;
1044 /* The .plt section is aligned at 32byte and the .text section
1045 is aligned at 64byte. The .text section is right after the
1046 .plt section. After the first relaxation pass, linker may
1047 increase the gap between the .plt and .text sections up
1048 to 32byte. We assume linker will always insert 32byte
1049 between the .plt and .text sections after the the first
1051 if (tsec
== ia64_info
->root
.splt
)
1052 offset
= -0x1000000 + 32;
1054 offset
= -0x1000000;
1056 /* If the branch is in range, no need to do anything. */
1057 if ((bfd_signed_vma
) (symaddr
- reladdr
) >= offset
1058 && (bfd_signed_vma
) (symaddr
- reladdr
) <= 0x0FFFFF0)
1060 /* If the 60-bit branch is in 21-bit range, optimize it. */
1061 if (r_type
== R_IA64_PCREL60B
)
1063 elfNN_ia64_relax_brl (contents
, roff
);
1066 = ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
1069 /* If the original relocation offset points to slot
1070 1, change it to slot 2. */
1071 if ((irel
->r_offset
& 3) == 1)
1072 irel
->r_offset
+= 1;
1077 else if (r_type
== R_IA64_PCREL60B
)
1079 else if (elfNN_ia64_relax_br (contents
, roff
))
1082 = ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
1085 /* Make the relocation offset point to slot 1. */
1086 irel
->r_offset
= (irel
->r_offset
& ~((bfd_vma
) 0x3)) + 1;
1090 /* We can't put a trampoline in a .init/.fini section. Issue
1092 if (strcmp (sec
->output_section
->name
, ".init") == 0
1093 || strcmp (sec
->output_section
->name
, ".fini") == 0)
1095 (*_bfd_error_handler
)
1096 (_("%B: Can't relax br at 0x%lx in section `%A'. Please use brl or indirect branch."),
1097 sec
->owner
, sec
, (unsigned long) roff
);
1098 bfd_set_error (bfd_error_bad_value
);
1102 /* If the branch and target are in the same section, you've
1103 got one honking big section and we can't help you unless
1104 you are branching backwards. You'll get an error message
1106 if (tsec
== sec
&& toff
> roff
)
1109 /* Look for an existing fixup to this address. */
1110 for (f
= fixups
; f
; f
= f
->next
)
1111 if (f
->tsec
== tsec
&& f
->toff
== toff
)
1116 /* Two alternatives: If it's a branch to a PLT entry, we can
1117 make a copy of the FULL_PLT entry. Otherwise, we'll have
1118 to use a `brl' insn to get where we're going. */
1122 if (tsec
== ia64_info
->root
.splt
)
1123 size
= sizeof (plt_full_entry
);
1125 size
= oor_branch_size
;
1127 /* Resize the current section to make room for the new branch. */
1128 trampoff
= (sec
->size
+ 15) & (bfd_vma
) -16;
1130 /* If trampoline is out of range, there is nothing we
1132 offset
= trampoff
- (roff
& (bfd_vma
) -4);
1133 if (offset
< -0x1000000 || offset
> 0x0FFFFF0)
1136 amt
= trampoff
+ size
;
1137 contents
= (bfd_byte
*) bfd_realloc (contents
, amt
);
1138 if (contents
== NULL
)
1142 if (tsec
== ia64_info
->root
.splt
)
1144 memcpy (contents
+ trampoff
, plt_full_entry
, size
);
1146 /* Hijack the old relocation for use as the PLTOFF reloc. */
1147 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
1149 irel
->r_offset
= trampoff
;
1153 if (size
== sizeof (oor_ip
))
1155 memcpy (contents
+ trampoff
, oor_ip
, size
);
1156 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
1158 irel
->r_addend
-= 16;
1159 irel
->r_offset
= trampoff
+ 2;
1163 memcpy (contents
+ trampoff
, oor_brl
, size
);
1164 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
1166 irel
->r_offset
= trampoff
+ 2;
1171 /* Record the fixup so we don't do it again this section. */
1172 f
= (struct one_fixup
*)
1173 bfd_malloc ((bfd_size_type
) sizeof (*f
));
1177 f
->trampoff
= trampoff
;
1182 /* If trampoline is out of range, there is nothing we
1184 offset
= f
->trampoff
- (roff
& (bfd_vma
) -4);
1185 if (offset
< -0x1000000 || offset
> 0x0FFFFF0)
1188 /* Nop out the reloc, since we're finalizing things here. */
1189 irel
->r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
1192 /* Fix up the existing branch to hit the trampoline. */
1193 if (elfNN_ia64_install_value (contents
+ roff
, offset
, r_type
)
1197 changed_contents
= TRUE
;
1198 changed_relocs
= TRUE
;
1205 bfd
*obfd
= sec
->output_section
->owner
;
1206 gp
= _bfd_get_gp_value (obfd
);
1209 if (!elfNN_ia64_choose_gp (obfd
, link_info
))
1211 gp
= _bfd_get_gp_value (obfd
);
1215 /* If the data is out of range, do nothing. */
1216 if ((bfd_signed_vma
) (symaddr
- gp
) >= 0x200000
1217 ||(bfd_signed_vma
) (symaddr
- gp
) < -0x200000)
1220 if (r_type
== R_IA64_GPREL22
)
1221 elfNN_ia64_update_short_info (tsec
,
1222 tsec
->output_offset
+ toff
,
1224 else if (r_type
== R_IA64_LTOFF22X
)
1226 irel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (irel
->r_info
),
1228 changed_relocs
= TRUE
;
1229 if (dyn_i
->want_gotx
)
1231 dyn_i
->want_gotx
= 0;
1232 changed_got
|= !dyn_i
->want_got
;
1235 elfNN_ia64_update_short_info (tsec
,
1236 tsec
->output_offset
+ toff
,
1241 elfNN_ia64_relax_ldxmov (contents
, roff
);
1242 irel
->r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
1243 changed_contents
= TRUE
;
1244 changed_relocs
= TRUE
;
1249 /* ??? If we created fixups, this may push the code segment large
1250 enough that the data segment moves, which will change the GP.
1251 Reset the GP so that we re-calculate next round. We need to
1252 do this at the _beginning_ of the next round; now will not do. */
1254 /* Clean up and go home. */
1257 struct one_fixup
*f
= fixups
;
1258 fixups
= fixups
->next
;
1263 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1265 if (! link_info
->keep_memory
)
1269 /* Cache the symbols for elf_link_input_bfd. */
1270 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1274 if (contents
!= NULL
1275 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
1277 if (!changed_contents
&& !link_info
->keep_memory
)
1281 /* Cache the section contents for elf_link_input_bfd. */
1282 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1286 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
1288 if (!changed_relocs
)
1289 free (internal_relocs
);
1291 elf_section_data (sec
)->relocs
= internal_relocs
;
1296 struct elfNN_ia64_allocate_data data
;
1297 data
.info
= link_info
;
1299 ia64_info
->self_dtpmod_offset
= (bfd_vma
) -1;
1301 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_data_got
, &data
);
1302 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_fptr_got
, &data
);
1303 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_local_got
, &data
);
1304 ia64_info
->root
.sgot
->size
= data
.ofs
;
1306 if (ia64_info
->root
.dynamic_sections_created
1307 && ia64_info
->root
.srelgot
!= NULL
)
1309 /* Resize .rela.got. */
1310 ia64_info
->root
.srelgot
->size
= 0;
1311 if (link_info
->shared
1312 && ia64_info
->self_dtpmod_offset
!= (bfd_vma
) -1)
1313 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
1314 data
.only_got
= TRUE
;
1315 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_dynrel_entries
,
1320 if (link_info
->relax_pass
== 0)
1322 /* Pass 0 is only needed to relax br. */
1323 sec
->skip_relax_pass_0
= skip_relax_pass_0
;
1324 sec
->skip_relax_pass_1
= skip_relax_pass_1
;
1327 *again
= changed_contents
|| changed_relocs
;
1331 if (isymbuf
!= NULL
&& (unsigned char *) isymbuf
!= symtab_hdr
->contents
)
1333 if (contents
!= NULL
1334 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
1336 if (internal_relocs
!= NULL
1337 && elf_section_data (sec
)->relocs
!= internal_relocs
)
1338 free (internal_relocs
);
1341 #undef skip_relax_pass_0
1342 #undef skip_relax_pass_1
1345 elfNN_ia64_relax_ldxmov (bfd_byte
*contents
, bfd_vma off
)
1348 bfd_vma dword
, insn
;
1350 switch ((int)off
& 0x3)
1352 case 0: shift
= 5; break;
1353 case 1: shift
= 14; off
+= 3; break;
1354 case 2: shift
= 23; off
+= 6; break;
1359 dword
= bfd_getl64 (contents
+ off
);
1360 insn
= (dword
>> shift
) & 0x1ffffffffffLL
;
1362 r1
= (insn
>> 6) & 127;
1363 r3
= (insn
>> 20) & 127;
1365 insn
= 0x8000000; /* nop */
1367 insn
= (insn
& 0x7f01fff) | 0x10800000000LL
; /* (qp) mov r1 = r3 */
1369 dword
&= ~(0x1ffffffffffLL
<< shift
);
1370 dword
|= (insn
<< shift
);
1371 bfd_putl64 (dword
, contents
+ off
);
1374 /* Return TRUE if NAME is an unwind table section name. */
1376 static inline bfd_boolean
1377 is_unwind_section_name (bfd
*abfd
, const char *name
)
1379 if (elfNN_ia64_hpux_vec (abfd
->xvec
)
1380 && !strcmp (name
, ELF_STRING_ia64_unwind_hdr
))
1383 return ((CONST_STRNEQ (name
, ELF_STRING_ia64_unwind
)
1384 && ! CONST_STRNEQ (name
, ELF_STRING_ia64_unwind_info
))
1385 || CONST_STRNEQ (name
, ELF_STRING_ia64_unwind_once
));
1388 /* Handle an IA-64 specific section when reading an object file. This
1389 is called when bfd_section_from_shdr finds a section with an unknown
1393 elfNN_ia64_section_from_shdr (bfd
*abfd
,
1394 Elf_Internal_Shdr
*hdr
,
1400 /* There ought to be a place to keep ELF backend specific flags, but
1401 at the moment there isn't one. We just keep track of the
1402 sections by their name, instead. Fortunately, the ABI gives
1403 suggested names for all the MIPS specific sections, so we will
1404 probably get away with this. */
1405 switch (hdr
->sh_type
)
1407 case SHT_IA_64_UNWIND
:
1408 case SHT_IA_64_HP_OPT_ANOT
:
1412 if (strcmp (name
, ELF_STRING_ia64_archext
) != 0)
1420 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
1422 newsect
= hdr
->bfd_section
;
1427 /* Convert IA-64 specific section flags to bfd internal section flags. */
1429 /* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
1433 elfNN_ia64_section_flags (flagword
*flags
,
1434 const Elf_Internal_Shdr
*hdr
)
1436 if (hdr
->sh_flags
& SHF_IA_64_SHORT
)
1437 *flags
|= SEC_SMALL_DATA
;
1442 /* Set the correct type for an IA-64 ELF section. We do this by the
1443 section name, which is a hack, but ought to work. */
1446 elfNN_ia64_fake_sections (bfd
*abfd
, Elf_Internal_Shdr
*hdr
,
1449 register const char *name
;
1451 name
= bfd_get_section_name (abfd
, sec
);
1453 if (is_unwind_section_name (abfd
, name
))
1455 /* We don't have the sections numbered at this point, so sh_info
1456 is set later, in elfNN_ia64_final_write_processing. */
1457 hdr
->sh_type
= SHT_IA_64_UNWIND
;
1458 hdr
->sh_flags
|= SHF_LINK_ORDER
;
1460 else if (strcmp (name
, ELF_STRING_ia64_archext
) == 0)
1461 hdr
->sh_type
= SHT_IA_64_EXT
;
1462 else if (strcmp (name
, ".HP.opt_annot") == 0)
1463 hdr
->sh_type
= SHT_IA_64_HP_OPT_ANOT
;
1464 else if (strcmp (name
, ".reloc") == 0)
1465 /* This is an ugly, but unfortunately necessary hack that is
1466 needed when producing EFI binaries on IA-64. It tells
1467 elf.c:elf_fake_sections() not to consider ".reloc" as a section
1468 containing ELF relocation info. We need this hack in order to
1469 be able to generate ELF binaries that can be translated into
1470 EFI applications (which are essentially COFF objects). Those
1471 files contain a COFF ".reloc" section inside an ELFNN object,
1472 which would normally cause BFD to segfault because it would
1473 attempt to interpret this section as containing relocation
1474 entries for section "oc". With this hack enabled, ".reloc"
1475 will be treated as a normal data section, which will avoid the
1476 segfault. However, you won't be able to create an ELFNN binary
1477 with a section named "oc" that needs relocations, but that's
1478 the kind of ugly side-effects you get when detecting section
1479 types based on their names... In practice, this limitation is
1480 unlikely to bite. */
1481 hdr
->sh_type
= SHT_PROGBITS
;
1483 if (sec
->flags
& SEC_SMALL_DATA
)
1484 hdr
->sh_flags
|= SHF_IA_64_SHORT
;
1486 /* Some HP linkers look for the SHF_IA_64_HP_TLS flag instead of SHF_TLS. */
1488 if (elfNN_ia64_hpux_vec (abfd
->xvec
) && (sec
->flags
& SHF_TLS
))
1489 hdr
->sh_flags
|= SHF_IA_64_HP_TLS
;
1494 /* The final processing done just before writing out an IA-64 ELF
1498 elfNN_ia64_final_write_processing (bfd
*abfd
,
1499 bfd_boolean linker ATTRIBUTE_UNUSED
)
1501 Elf_Internal_Shdr
*hdr
;
1504 for (s
= abfd
->sections
; s
; s
= s
->next
)
1506 hdr
= &elf_section_data (s
)->this_hdr
;
1507 switch (hdr
->sh_type
)
1509 case SHT_IA_64_UNWIND
:
1510 /* The IA-64 processor-specific ABI requires setting sh_link
1511 to the unwind section, whereas HP-UX requires sh_info to
1512 do so. For maximum compatibility, we'll set both for
1514 hdr
->sh_info
= hdr
->sh_link
;
1519 if (! elf_flags_init (abfd
))
1521 unsigned long flags
= 0;
1523 if (abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
)
1524 flags
|= EF_IA_64_BE
;
1525 if (bfd_get_mach (abfd
) == bfd_mach_ia64_elf64
)
1526 flags
|= EF_IA_64_ABI64
;
1528 elf_elfheader(abfd
)->e_flags
= flags
;
1529 elf_flags_init (abfd
) = TRUE
;
1533 /* Hook called by the linker routine which adds symbols from an object
1534 file. We use it to put .comm items in .sbss, and not .bss. */
1537 elfNN_ia64_add_symbol_hook (bfd
*abfd
,
1538 struct bfd_link_info
*info
,
1539 Elf_Internal_Sym
*sym
,
1540 const char **namep ATTRIBUTE_UNUSED
,
1541 flagword
*flagsp ATTRIBUTE_UNUSED
,
1545 if (sym
->st_shndx
== SHN_COMMON
1546 && !info
->relocatable
1547 && sym
->st_size
<= elf_gp_size (abfd
))
1549 /* Common symbols less than or equal to -G nn bytes are
1550 automatically put into .sbss. */
1552 asection
*scomm
= bfd_get_section_by_name (abfd
, ".scommon");
1556 scomm
= bfd_make_section_with_flags (abfd
, ".scommon",
1559 | SEC_LINKER_CREATED
));
1565 *valp
= sym
->st_size
;
1571 /* Return the number of additional phdrs we will need. */
1574 elfNN_ia64_additional_program_headers (bfd
*abfd
,
1575 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1580 /* See if we need a PT_IA_64_ARCHEXT segment. */
1581 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_archext
);
1582 if (s
&& (s
->flags
& SEC_LOAD
))
1585 /* Count how many PT_IA_64_UNWIND segments we need. */
1586 for (s
= abfd
->sections
; s
; s
= s
->next
)
1587 if (is_unwind_section_name (abfd
, s
->name
) && (s
->flags
& SEC_LOAD
))
1594 elfNN_ia64_modify_segment_map (bfd
*abfd
,
1595 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1597 struct elf_segment_map
*m
, **pm
;
1598 Elf_Internal_Shdr
*hdr
;
1601 /* If we need a PT_IA_64_ARCHEXT segment, it must come before
1602 all PT_LOAD segments. */
1603 s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_archext
);
1604 if (s
&& (s
->flags
& SEC_LOAD
))
1606 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1607 if (m
->p_type
== PT_IA_64_ARCHEXT
)
1611 m
= ((struct elf_segment_map
*)
1612 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *m
));
1616 m
->p_type
= PT_IA_64_ARCHEXT
;
1620 /* We want to put it after the PHDR and INTERP segments. */
1621 pm
= &elf_tdata (abfd
)->segment_map
;
1623 && ((*pm
)->p_type
== PT_PHDR
1624 || (*pm
)->p_type
== PT_INTERP
))
1632 /* Install PT_IA_64_UNWIND segments, if needed. */
1633 for (s
= abfd
->sections
; s
; s
= s
->next
)
1635 hdr
= &elf_section_data (s
)->this_hdr
;
1636 if (hdr
->sh_type
!= SHT_IA_64_UNWIND
)
1639 if (s
&& (s
->flags
& SEC_LOAD
))
1641 for (m
= elf_tdata (abfd
)->segment_map
; m
!= NULL
; m
= m
->next
)
1642 if (m
->p_type
== PT_IA_64_UNWIND
)
1646 /* Look through all sections in the unwind segment
1647 for a match since there may be multiple sections
1649 for (i
= m
->count
- 1; i
>= 0; --i
)
1650 if (m
->sections
[i
] == s
)
1659 m
= ((struct elf_segment_map
*)
1660 bfd_zalloc (abfd
, (bfd_size_type
) sizeof *m
));
1664 m
->p_type
= PT_IA_64_UNWIND
;
1669 /* We want to put it last. */
1670 pm
= &elf_tdata (abfd
)->segment_map
;
1681 /* Turn on PF_IA_64_NORECOV if needed. This involves traversing all of
1682 the input sections for each output section in the segment and testing
1683 for SHF_IA_64_NORECOV on each. */
1686 elfNN_ia64_modify_program_headers (bfd
*abfd
,
1687 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
1689 struct elf_obj_tdata
*tdata
= elf_tdata (abfd
);
1690 struct elf_segment_map
*m
;
1691 Elf_Internal_Phdr
*p
;
1693 for (p
= tdata
->phdr
, m
= tdata
->segment_map
; m
!= NULL
; m
= m
->next
, p
++)
1694 if (m
->p_type
== PT_LOAD
)
1697 for (i
= m
->count
- 1; i
>= 0; --i
)
1699 struct bfd_link_order
*order
= m
->sections
[i
]->map_head
.link_order
;
1701 while (order
!= NULL
)
1703 if (order
->type
== bfd_indirect_link_order
)
1705 asection
*is
= order
->u
.indirect
.section
;
1706 bfd_vma flags
= elf_section_data(is
)->this_hdr
.sh_flags
;
1707 if (flags
& SHF_IA_64_NORECOV
)
1709 p
->p_flags
|= PF_IA_64_NORECOV
;
1713 order
= order
->next
;
1722 /* According to the Tahoe assembler spec, all labels starting with a
1726 elfNN_ia64_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
1729 return name
[0] == '.';
1732 /* Should we do dynamic things to this symbol? */
1735 elfNN_ia64_dynamic_symbol_p (struct elf_link_hash_entry
*h
,
1736 struct bfd_link_info
*info
, int r_type
)
1738 bfd_boolean ignore_protected
1739 = ((r_type
& 0xf8) == 0x40 /* FPTR relocs */
1740 || (r_type
& 0xf8) == 0x50); /* LTOFF_FPTR relocs */
1742 return _bfd_elf_dynamic_symbol_p (h
, info
, ignore_protected
);
1745 static struct bfd_hash_entry
*
1746 elfNN_ia64_new_elf_hash_entry (struct bfd_hash_entry
*entry
,
1747 struct bfd_hash_table
*table
,
1750 struct elfNN_ia64_link_hash_entry
*ret
;
1751 ret
= (struct elfNN_ia64_link_hash_entry
*) entry
;
1753 /* Allocate the structure if it has not already been allocated by a
1756 ret
= bfd_hash_allocate (table
, sizeof (*ret
));
1761 /* Call the allocation method of the superclass. */
1762 ret
= ((struct elfNN_ia64_link_hash_entry
*)
1763 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
1768 ret
->sorted_count
= 0;
1770 return (struct bfd_hash_entry
*) ret
;
1774 elfNN_ia64_hash_copy_indirect (struct bfd_link_info
*info
,
1775 struct elf_link_hash_entry
*xdir
,
1776 struct elf_link_hash_entry
*xind
)
1778 struct elfNN_ia64_link_hash_entry
*dir
, *ind
;
1780 dir
= (struct elfNN_ia64_link_hash_entry
*) xdir
;
1781 ind
= (struct elfNN_ia64_link_hash_entry
*) xind
;
1783 /* Copy down any references that we may have already seen to the
1784 symbol which just became indirect. */
1786 dir
->root
.ref_dynamic
|= ind
->root
.ref_dynamic
;
1787 dir
->root
.ref_regular
|= ind
->root
.ref_regular
;
1788 dir
->root
.ref_regular_nonweak
|= ind
->root
.ref_regular_nonweak
;
1789 dir
->root
.needs_plt
|= ind
->root
.needs_plt
;
1791 if (ind
->root
.root
.type
!= bfd_link_hash_indirect
)
1794 /* Copy over the got and plt data. This would have been done
1797 if (ind
->info
!= NULL
)
1799 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1805 dir
->info
= ind
->info
;
1806 dir
->count
= ind
->count
;
1807 dir
->sorted_count
= ind
->sorted_count
;
1808 dir
->size
= ind
->size
;
1812 ind
->sorted_count
= 0;
1815 /* Fix up the dyn_sym_info pointers to the global symbol. */
1816 for (count
= dir
->count
, dyn_i
= dir
->info
;
1819 dyn_i
->h
= &dir
->root
;
1822 /* Copy over the dynindx. */
1824 if (ind
->root
.dynindx
!= -1)
1826 if (dir
->root
.dynindx
!= -1)
1827 _bfd_elf_strtab_delref (elf_hash_table (info
)->dynstr
,
1828 dir
->root
.dynstr_index
);
1829 dir
->root
.dynindx
= ind
->root
.dynindx
;
1830 dir
->root
.dynstr_index
= ind
->root
.dynstr_index
;
1831 ind
->root
.dynindx
= -1;
1832 ind
->root
.dynstr_index
= 0;
1837 elfNN_ia64_hash_hide_symbol (struct bfd_link_info
*info
,
1838 struct elf_link_hash_entry
*xh
,
1839 bfd_boolean force_local
)
1841 struct elfNN_ia64_link_hash_entry
*h
;
1842 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1845 h
= (struct elfNN_ia64_link_hash_entry
*)xh
;
1847 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
1849 for (count
= h
->count
, dyn_i
= h
->info
;
1853 dyn_i
->want_plt2
= 0;
1854 dyn_i
->want_plt
= 0;
1858 /* Compute a hash of a local hash entry. */
1861 elfNN_ia64_local_htab_hash (const void *ptr
)
1863 struct elfNN_ia64_local_hash_entry
*entry
1864 = (struct elfNN_ia64_local_hash_entry
*) ptr
;
1866 return ELF_LOCAL_SYMBOL_HASH (entry
->id
, entry
->r_sym
);
1869 /* Compare local hash entries. */
1872 elfNN_ia64_local_htab_eq (const void *ptr1
, const void *ptr2
)
1874 struct elfNN_ia64_local_hash_entry
*entry1
1875 = (struct elfNN_ia64_local_hash_entry
*) ptr1
;
1876 struct elfNN_ia64_local_hash_entry
*entry2
1877 = (struct elfNN_ia64_local_hash_entry
*) ptr2
;
1879 return entry1
->id
== entry2
->id
&& entry1
->r_sym
== entry2
->r_sym
;
1882 /* Create the derived linker hash table. The IA-64 ELF port uses this
1883 derived hash table to keep information specific to the IA-64 ElF
1884 linker (without using static variables). */
1886 static struct bfd_link_hash_table
*
1887 elfNN_ia64_hash_table_create (bfd
*abfd
)
1889 struct elfNN_ia64_link_hash_table
*ret
;
1891 ret
= bfd_zmalloc ((bfd_size_type
) sizeof (*ret
));
1895 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
1896 elfNN_ia64_new_elf_hash_entry
,
1897 sizeof (struct elfNN_ia64_link_hash_entry
)))
1903 ret
->loc_hash_table
= htab_try_create (1024, elfNN_ia64_local_htab_hash
,
1904 elfNN_ia64_local_htab_eq
, NULL
);
1905 ret
->loc_hash_memory
= objalloc_create ();
1906 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
1912 return &ret
->root
.root
;
1915 /* Free the global elfNN_ia64_dyn_sym_info array. */
1918 elfNN_ia64_global_dyn_info_free (void **xentry
,
1919 PTR unused ATTRIBUTE_UNUSED
)
1921 struct elfNN_ia64_link_hash_entry
*entry
1922 = (struct elfNN_ia64_link_hash_entry
*) xentry
;
1924 if (entry
->root
.root
.type
== bfd_link_hash_warning
)
1925 entry
= (struct elfNN_ia64_link_hash_entry
*) entry
->root
.root
.u
.i
.link
;
1932 entry
->sorted_count
= 0;
1939 /* Free the local elfNN_ia64_dyn_sym_info array. */
1942 elfNN_ia64_local_dyn_info_free (void **slot
,
1943 PTR unused ATTRIBUTE_UNUSED
)
1945 struct elfNN_ia64_local_hash_entry
*entry
1946 = (struct elfNN_ia64_local_hash_entry
*) *slot
;
1953 entry
->sorted_count
= 0;
1960 /* Destroy IA-64 linker hash table. */
1963 elfNN_ia64_hash_table_free (struct bfd_link_hash_table
*hash
)
1965 struct elfNN_ia64_link_hash_table
*ia64_info
1966 = (struct elfNN_ia64_link_hash_table
*) hash
;
1967 if (ia64_info
->loc_hash_table
)
1969 htab_traverse (ia64_info
->loc_hash_table
,
1970 elfNN_ia64_local_dyn_info_free
, NULL
);
1971 htab_delete (ia64_info
->loc_hash_table
);
1973 if (ia64_info
->loc_hash_memory
)
1974 objalloc_free ((struct objalloc
*) ia64_info
->loc_hash_memory
);
1975 elf_link_hash_traverse (&ia64_info
->root
,
1976 elfNN_ia64_global_dyn_info_free
, NULL
);
1977 _bfd_generic_link_hash_table_free (hash
);
1980 /* Traverse both local and global hash tables. */
1982 struct elfNN_ia64_dyn_sym_traverse_data
1984 bfd_boolean (*func
) (struct elfNN_ia64_dyn_sym_info
*, PTR
);
1989 elfNN_ia64_global_dyn_sym_thunk (struct bfd_hash_entry
*xentry
,
1992 struct elfNN_ia64_link_hash_entry
*entry
1993 = (struct elfNN_ia64_link_hash_entry
*) xentry
;
1994 struct elfNN_ia64_dyn_sym_traverse_data
*data
1995 = (struct elfNN_ia64_dyn_sym_traverse_data
*) xdata
;
1996 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
1999 if (entry
->root
.root
.type
== bfd_link_hash_warning
)
2000 entry
= (struct elfNN_ia64_link_hash_entry
*) entry
->root
.root
.u
.i
.link
;
2002 for (count
= entry
->count
, dyn_i
= entry
->info
;
2005 if (! (*data
->func
) (dyn_i
, data
->data
))
2011 elfNN_ia64_local_dyn_sym_thunk (void **slot
, PTR xdata
)
2013 struct elfNN_ia64_local_hash_entry
*entry
2014 = (struct elfNN_ia64_local_hash_entry
*) *slot
;
2015 struct elfNN_ia64_dyn_sym_traverse_data
*data
2016 = (struct elfNN_ia64_dyn_sym_traverse_data
*) xdata
;
2017 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2020 for (count
= entry
->count
, dyn_i
= entry
->info
;
2023 if (! (*data
->func
) (dyn_i
, data
->data
))
2029 elfNN_ia64_dyn_sym_traverse (struct elfNN_ia64_link_hash_table
*ia64_info
,
2030 bfd_boolean (*func
) (struct elfNN_ia64_dyn_sym_info
*, PTR
),
2033 struct elfNN_ia64_dyn_sym_traverse_data xdata
;
2038 elf_link_hash_traverse (&ia64_info
->root
,
2039 elfNN_ia64_global_dyn_sym_thunk
, &xdata
);
2040 htab_traverse (ia64_info
->loc_hash_table
,
2041 elfNN_ia64_local_dyn_sym_thunk
, &xdata
);
2045 elfNN_ia64_create_dynamic_sections (bfd
*abfd
,
2046 struct bfd_link_info
*info
)
2048 struct elfNN_ia64_link_hash_table
*ia64_info
;
2051 if (! _bfd_elf_create_dynamic_sections (abfd
, info
))
2054 ia64_info
= elfNN_ia64_hash_table (info
);
2057 flagword flags
= bfd_get_section_flags (abfd
, ia64_info
->root
.sgot
);
2058 bfd_set_section_flags (abfd
, ia64_info
->root
.sgot
,
2059 SEC_SMALL_DATA
| flags
);
2060 /* The .got section is always aligned at 8 bytes. */
2061 bfd_set_section_alignment (abfd
, ia64_info
->root
.sgot
, 3);
2064 if (!get_pltoff (abfd
, info
, ia64_info
))
2067 s
= bfd_make_section_with_flags (abfd
, ".rela.IA_64.pltoff",
2068 (SEC_ALLOC
| SEC_LOAD
2071 | SEC_LINKER_CREATED
2074 || !bfd_set_section_alignment (abfd
, s
, LOG_SECTION_ALIGN
))
2076 ia64_info
->rel_pltoff_sec
= s
;
2081 /* Find and/or create a hash entry for local symbol. */
2082 static struct elfNN_ia64_local_hash_entry
*
2083 get_local_sym_hash (struct elfNN_ia64_link_hash_table
*ia64_info
,
2084 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
2087 struct elfNN_ia64_local_hash_entry e
, *ret
;
2088 asection
*sec
= abfd
->sections
;
2089 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
2090 ELFNN_R_SYM (rel
->r_info
));
2094 e
.r_sym
= ELFNN_R_SYM (rel
->r_info
);
2095 slot
= htab_find_slot_with_hash (ia64_info
->loc_hash_table
, &e
, h
,
2096 create
? INSERT
: NO_INSERT
);
2102 return (struct elfNN_ia64_local_hash_entry
*) *slot
;
2104 ret
= (struct elfNN_ia64_local_hash_entry
*)
2105 objalloc_alloc ((struct objalloc
*) ia64_info
->loc_hash_memory
,
2106 sizeof (struct elfNN_ia64_local_hash_entry
));
2109 memset (ret
, 0, sizeof (*ret
));
2111 ret
->r_sym
= ELFNN_R_SYM (rel
->r_info
);
2117 /* Used to sort elfNN_ia64_dyn_sym_info array. */
2120 addend_compare (const void *xp
, const void *yp
)
2122 const struct elfNN_ia64_dyn_sym_info
*x
2123 = (const struct elfNN_ia64_dyn_sym_info
*) xp
;
2124 const struct elfNN_ia64_dyn_sym_info
*y
2125 = (const struct elfNN_ia64_dyn_sym_info
*) yp
;
2127 return x
->addend
< y
->addend
? -1 : x
->addend
> y
->addend
? 1 : 0;
2130 /* Sort elfNN_ia64_dyn_sym_info array and remove duplicates. */
2133 sort_dyn_sym_info (struct elfNN_ia64_dyn_sym_info
*info
,
2136 bfd_vma curr
, prev
, got_offset
;
2137 unsigned int i
, kept
, dup
, diff
, dest
, src
, len
;
2139 qsort (info
, count
, sizeof (*info
), addend_compare
);
2141 /* Find the first duplicate. */
2142 prev
= info
[0].addend
;
2143 got_offset
= info
[0].got_offset
;
2144 for (i
= 1; i
< count
; i
++)
2146 curr
= info
[i
].addend
;
2149 /* For duplicates, make sure that GOT_OFFSET is valid. */
2150 if (got_offset
== (bfd_vma
) -1)
2151 got_offset
= info
[i
].got_offset
;
2154 got_offset
= info
[i
].got_offset
;
2158 /* We may move a block of elements to here. */
2161 /* Remove duplicates. */
2166 /* For duplicates, make sure that the kept one has a valid
2169 if (got_offset
!= (bfd_vma
) -1)
2170 info
[kept
].got_offset
= got_offset
;
2172 curr
= info
[i
].addend
;
2173 got_offset
= info
[i
].got_offset
;
2175 /* Move a block of elements whose first one is different from
2179 for (src
= i
+ 1; src
< count
; src
++)
2181 if (info
[src
].addend
!= curr
)
2183 /* For duplicates, make sure that GOT_OFFSET is
2185 if (got_offset
== (bfd_vma
) -1)
2186 got_offset
= info
[src
].got_offset
;
2189 /* Make sure that the kept one has a valid got_offset. */
2190 if (got_offset
!= (bfd_vma
) -1)
2191 info
[kept
].got_offset
= got_offset
;
2199 /* Find the next duplicate. SRC will be kept. */
2200 prev
= info
[src
].addend
;
2201 got_offset
= info
[src
].got_offset
;
2202 for (dup
= src
+ 1; dup
< count
; dup
++)
2204 curr
= info
[dup
].addend
;
2207 /* Make sure that got_offset is valid. */
2208 if (got_offset
== (bfd_vma
) -1)
2209 got_offset
= info
[dup
].got_offset
;
2211 /* For duplicates, make sure that the kept one has
2212 a valid got_offset. */
2213 if (got_offset
!= (bfd_vma
) -1)
2214 info
[dup
- 1].got_offset
= got_offset
;
2217 got_offset
= info
[dup
].got_offset
;
2221 /* How much to move. */
2225 if (len
== 1 && dup
< count
)
2227 /* If we only move 1 element, we combine it with the next
2228 one. There must be at least a duplicate. Find the
2229 next different one. */
2230 for (diff
= dup
+ 1, src
++; diff
< count
; diff
++, src
++)
2232 if (info
[diff
].addend
!= curr
)
2234 /* Make sure that got_offset is valid. */
2235 if (got_offset
== (bfd_vma
) -1)
2236 got_offset
= info
[diff
].got_offset
;
2239 /* Makre sure that the last duplicated one has an valid
2241 BFD_ASSERT (curr
== prev
);
2242 if (got_offset
!= (bfd_vma
) -1)
2243 info
[diff
- 1].got_offset
= got_offset
;
2247 /* Find the next duplicate. Track the current valid
2249 prev
= info
[diff
].addend
;
2250 got_offset
= info
[diff
].got_offset
;
2251 for (dup
= diff
+ 1; dup
< count
; dup
++)
2253 curr
= info
[dup
].addend
;
2256 /* For duplicates, make sure that GOT_OFFSET
2258 if (got_offset
== (bfd_vma
) -1)
2259 got_offset
= info
[dup
].got_offset
;
2262 got_offset
= info
[dup
].got_offset
;
2267 len
= diff
- src
+ 1;
2272 memmove (&info
[dest
], &info
[src
], len
* sizeof (*info
));
2281 /* When we get here, either there is no duplicate at all or
2282 the only duplicate is the last element. */
2285 /* If the last element is a duplicate, make sure that the
2286 kept one has a valid got_offset. We also update count. */
2287 if (got_offset
!= (bfd_vma
) -1)
2288 info
[dest
- 1].got_offset
= got_offset
;
2296 /* Find and/or create a descriptor for dynamic symbol info. This will
2297 vary based on global or local symbol, and the addend to the reloc.
2299 We don't sort when inserting. Also, we sort and eliminate
2300 duplicates if there is an unsorted section. Typically, this will
2301 only happen once, because we do all insertions before lookups. We
2302 then use bsearch to do a lookup. This also allows lookups to be
2303 fast. So we have fast insertion (O(log N) due to duplicate check),
2304 fast lookup (O(log N)) and one sort (O(N log N) expected time).
2305 Previously, all lookups were O(N) because of the use of the linked
2306 list and also all insertions were O(N) because of the check for
2307 duplicates. There are some complications here because the array
2308 size grows occasionally, which may add an O(N) factor, but this
2309 should be rare. Also, we free the excess array allocation, which
2310 requires a copy which is O(N), but this only happens once. */
2312 static struct elfNN_ia64_dyn_sym_info
*
2313 get_dyn_sym_info (struct elfNN_ia64_link_hash_table
*ia64_info
,
2314 struct elf_link_hash_entry
*h
, bfd
*abfd
,
2315 const Elf_Internal_Rela
*rel
, bfd_boolean create
)
2317 struct elfNN_ia64_dyn_sym_info
**info_p
, *info
, *dyn_i
, key
;
2318 unsigned int *count_p
, *sorted_count_p
, *size_p
;
2319 unsigned int count
, sorted_count
, size
;
2320 bfd_vma addend
= rel
? rel
->r_addend
: 0;
2325 struct elfNN_ia64_link_hash_entry
*global_h
;
2327 global_h
= (struct elfNN_ia64_link_hash_entry
*) h
;
2328 info_p
= &global_h
->info
;
2329 count_p
= &global_h
->count
;
2330 sorted_count_p
= &global_h
->sorted_count
;
2331 size_p
= &global_h
->size
;
2335 struct elfNN_ia64_local_hash_entry
*loc_h
;
2337 loc_h
= get_local_sym_hash (ia64_info
, abfd
, rel
, create
);
2340 BFD_ASSERT (!create
);
2344 info_p
= &loc_h
->info
;
2345 count_p
= &loc_h
->count
;
2346 sorted_count_p
= &loc_h
->sorted_count
;
2347 size_p
= &loc_h
->size
;
2351 sorted_count
= *sorted_count_p
;
2356 /* When we create the array, we don't check for duplicates,
2357 except in the previously sorted section if one exists, and
2358 against the last inserted entry. This allows insertions to
2364 /* Try bsearch first on the sorted section. */
2365 key
.addend
= addend
;
2366 dyn_i
= bsearch (&key
, info
, sorted_count
,
2367 sizeof (*info
), addend_compare
);
2375 /* Do a quick check for the last inserted entry. */
2376 dyn_i
= info
+ count
- 1;
2377 if (dyn_i
->addend
== addend
)
2385 /* It is the very first element. We create the array of size
2388 amt
= size
* sizeof (*info
);
2389 info
= bfd_malloc (amt
);
2391 else if (size
<= count
)
2393 /* We double the array size every time when we reach the
2396 amt
= size
* sizeof (*info
);
2397 info
= bfd_realloc (info
, amt
);
2408 /* Append the new one to the array. */
2409 dyn_i
= info
+ count
;
2410 memset (dyn_i
, 0, sizeof (*dyn_i
));
2411 dyn_i
->got_offset
= (bfd_vma
) -1;
2412 dyn_i
->addend
= addend
;
2414 /* We increment count only since the new ones are unsorted and
2415 may have duplicate. */
2420 /* It is a lookup without insertion. Sort array if part of the
2421 array isn't sorted. */
2422 if (count
!= sorted_count
)
2424 count
= sort_dyn_sym_info (info
, count
);
2426 *sorted_count_p
= count
;
2429 /* Free unused memory. */
2432 amt
= count
* sizeof (*info
);
2433 info
= bfd_malloc (amt
);
2436 memcpy (info
, *info_p
, amt
);
2443 key
.addend
= addend
;
2444 dyn_i
= bsearch (&key
, info
, count
,
2445 sizeof (*info
), addend_compare
);
2452 get_got (bfd
*abfd
, struct bfd_link_info
*info
,
2453 struct elfNN_ia64_link_hash_table
*ia64_info
)
2458 got
= ia64_info
->root
.sgot
;
2463 dynobj
= ia64_info
->root
.dynobj
;
2465 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2466 if (!_bfd_elf_create_got_section (dynobj
, info
))
2469 got
= ia64_info
->root
.sgot
;
2471 /* The .got section is always aligned at 8 bytes. */
2472 if (!bfd_set_section_alignment (abfd
, got
, 3))
2475 flags
= bfd_get_section_flags (abfd
, got
);
2476 bfd_set_section_flags (abfd
, got
, SEC_SMALL_DATA
| flags
);
2482 /* Create function descriptor section (.opd). This section is called .opd
2483 because it contains "official procedure descriptors". The "official"
2484 refers to the fact that these descriptors are used when taking the address
2485 of a procedure, thus ensuring a unique address for each procedure. */
2488 get_fptr (bfd
*abfd
, struct bfd_link_info
*info
,
2489 struct elfNN_ia64_link_hash_table
*ia64_info
)
2494 fptr
= ia64_info
->fptr_sec
;
2497 dynobj
= ia64_info
->root
.dynobj
;
2499 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2501 fptr
= bfd_make_section_with_flags (dynobj
, ".opd",
2506 | (info
->pie
? 0 : SEC_READONLY
)
2507 | SEC_LINKER_CREATED
));
2509 || !bfd_set_section_alignment (abfd
, fptr
, 4))
2515 ia64_info
->fptr_sec
= fptr
;
2520 fptr_rel
= bfd_make_section_with_flags (dynobj
, ".rela.opd",
2521 (SEC_ALLOC
| SEC_LOAD
2524 | SEC_LINKER_CREATED
2526 if (fptr_rel
== NULL
2527 || !bfd_set_section_alignment (abfd
, fptr_rel
,
2534 ia64_info
->rel_fptr_sec
= fptr_rel
;
2542 get_pltoff (bfd
*abfd
, struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2543 struct elfNN_ia64_link_hash_table
*ia64_info
)
2548 pltoff
= ia64_info
->pltoff_sec
;
2551 dynobj
= ia64_info
->root
.dynobj
;
2553 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2555 pltoff
= bfd_make_section_with_flags (dynobj
,
2556 ELF_STRING_ia64_pltoff
,
2562 | SEC_LINKER_CREATED
));
2564 || !bfd_set_section_alignment (abfd
, pltoff
, 4))
2570 ia64_info
->pltoff_sec
= pltoff
;
2577 get_reloc_section (bfd
*abfd
,
2578 struct elfNN_ia64_link_hash_table
*ia64_info
,
2579 asection
*sec
, bfd_boolean create
)
2581 const char *srel_name
;
2585 srel_name
= (bfd_elf_string_from_elf_section
2586 (abfd
, elf_elfheader(abfd
)->e_shstrndx
,
2587 elf_section_data(sec
)->rel_hdr
.sh_name
));
2588 if (srel_name
== NULL
)
2591 BFD_ASSERT ((CONST_STRNEQ (srel_name
, ".rela")
2592 && strcmp (bfd_get_section_name (abfd
, sec
),
2594 || (CONST_STRNEQ (srel_name
, ".rel")
2595 && strcmp (bfd_get_section_name (abfd
, sec
),
2596 srel_name
+4) == 0));
2598 dynobj
= ia64_info
->root
.dynobj
;
2600 ia64_info
->root
.dynobj
= dynobj
= abfd
;
2602 srel
= bfd_get_section_by_name (dynobj
, srel_name
);
2603 if (srel
== NULL
&& create
)
2605 srel
= bfd_make_section_with_flags (dynobj
, srel_name
,
2606 (SEC_ALLOC
| SEC_LOAD
2609 | SEC_LINKER_CREATED
2612 || !bfd_set_section_alignment (dynobj
, srel
,
2621 count_dyn_reloc (bfd
*abfd
, struct elfNN_ia64_dyn_sym_info
*dyn_i
,
2622 asection
*srel
, int type
, bfd_boolean reltext
)
2624 struct elfNN_ia64_dyn_reloc_entry
*rent
;
2626 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
2627 if (rent
->srel
== srel
&& rent
->type
== type
)
2632 rent
= ((struct elfNN_ia64_dyn_reloc_entry
*)
2633 bfd_alloc (abfd
, (bfd_size_type
) sizeof (*rent
)));
2637 rent
->next
= dyn_i
->reloc_entries
;
2641 dyn_i
->reloc_entries
= rent
;
2643 rent
->reltext
= reltext
;
2650 elfNN_ia64_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
2652 const Elf_Internal_Rela
*relocs
)
2654 struct elfNN_ia64_link_hash_table
*ia64_info
;
2655 const Elf_Internal_Rela
*relend
;
2656 Elf_Internal_Shdr
*symtab_hdr
;
2657 const Elf_Internal_Rela
*rel
;
2658 asection
*got
, *fptr
, *srel
, *pltoff
;
2667 NEED_LTOFF_FPTR
= 128,
2673 struct elf_link_hash_entry
*h
;
2674 unsigned long r_symndx
;
2675 bfd_boolean maybe_dynamic
;
2677 if (info
->relocatable
)
2680 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2681 ia64_info
= elfNN_ia64_hash_table (info
);
2683 got
= fptr
= srel
= pltoff
= NULL
;
2685 relend
= relocs
+ sec
->reloc_count
;
2687 /* We scan relocations first to create dynamic relocation arrays. We
2688 modified get_dyn_sym_info to allow fast insertion and support fast
2689 lookup in the next loop. */
2690 for (rel
= relocs
; rel
< relend
; ++rel
)
2692 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
2693 if (r_symndx
>= symtab_hdr
->sh_info
)
2695 long indx
= r_symndx
- symtab_hdr
->sh_info
;
2696 h
= elf_sym_hashes (abfd
)[indx
];
2697 while (h
->root
.type
== bfd_link_hash_indirect
2698 || h
->root
.type
== bfd_link_hash_warning
)
2699 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2704 /* We can only get preliminary data on whether a symbol is
2705 locally or externally defined, as not all of the input files
2706 have yet been processed. Do something with what we know, as
2707 this may help reduce memory usage and processing time later. */
2708 maybe_dynamic
= (h
&& ((!info
->executable
2709 && (!SYMBOLIC_BIND (info
, h
)
2710 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
2712 || h
->root
.type
== bfd_link_hash_defweak
));
2715 switch (ELFNN_R_TYPE (rel
->r_info
))
2717 case R_IA64_TPREL64MSB
:
2718 case R_IA64_TPREL64LSB
:
2719 if (info
->shared
|| maybe_dynamic
)
2720 need_entry
= NEED_DYNREL
;
2723 case R_IA64_LTOFF_TPREL22
:
2724 need_entry
= NEED_TPREL
;
2726 info
->flags
|= DF_STATIC_TLS
;
2729 case R_IA64_DTPREL32MSB
:
2730 case R_IA64_DTPREL32LSB
:
2731 case R_IA64_DTPREL64MSB
:
2732 case R_IA64_DTPREL64LSB
:
2733 if (info
->shared
|| maybe_dynamic
)
2734 need_entry
= NEED_DYNREL
;
2737 case R_IA64_LTOFF_DTPREL22
:
2738 need_entry
= NEED_DTPREL
;
2741 case R_IA64_DTPMOD64MSB
:
2742 case R_IA64_DTPMOD64LSB
:
2743 if (info
->shared
|| maybe_dynamic
)
2744 need_entry
= NEED_DYNREL
;
2747 case R_IA64_LTOFF_DTPMOD22
:
2748 need_entry
= NEED_DTPMOD
;
2751 case R_IA64_LTOFF_FPTR22
:
2752 case R_IA64_LTOFF_FPTR64I
:
2753 case R_IA64_LTOFF_FPTR32MSB
:
2754 case R_IA64_LTOFF_FPTR32LSB
:
2755 case R_IA64_LTOFF_FPTR64MSB
:
2756 case R_IA64_LTOFF_FPTR64LSB
:
2757 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
2760 case R_IA64_FPTR64I
:
2761 case R_IA64_FPTR32MSB
:
2762 case R_IA64_FPTR32LSB
:
2763 case R_IA64_FPTR64MSB
:
2764 case R_IA64_FPTR64LSB
:
2765 if (info
->shared
|| h
)
2766 need_entry
= NEED_FPTR
| NEED_DYNREL
;
2768 need_entry
= NEED_FPTR
;
2771 case R_IA64_LTOFF22
:
2772 case R_IA64_LTOFF64I
:
2773 need_entry
= NEED_GOT
;
2776 case R_IA64_LTOFF22X
:
2777 need_entry
= NEED_GOTX
;
2780 case R_IA64_PLTOFF22
:
2781 case R_IA64_PLTOFF64I
:
2782 case R_IA64_PLTOFF64MSB
:
2783 case R_IA64_PLTOFF64LSB
:
2784 need_entry
= NEED_PLTOFF
;
2788 need_entry
|= NEED_MIN_PLT
;
2792 (*info
->callbacks
->warning
)
2793 (info
, _("@pltoff reloc against local symbol"), 0,
2794 abfd
, 0, (bfd_vma
) 0);
2798 case R_IA64_PCREL21B
:
2799 case R_IA64_PCREL60B
:
2800 /* Depending on where this symbol is defined, we may or may not
2801 need a full plt entry. Only skip if we know we'll not need
2802 the entry -- static or symbolic, and the symbol definition
2803 has already been seen. */
2804 if (maybe_dynamic
&& rel
->r_addend
== 0)
2805 need_entry
= NEED_FULL_PLT
;
2811 case R_IA64_DIR32MSB
:
2812 case R_IA64_DIR32LSB
:
2813 case R_IA64_DIR64MSB
:
2814 case R_IA64_DIR64LSB
:
2815 /* Shared objects will always need at least a REL relocation. */
2816 if (info
->shared
|| maybe_dynamic
)
2817 need_entry
= NEED_DYNREL
;
2820 case R_IA64_IPLTMSB
:
2821 case R_IA64_IPLTLSB
:
2822 /* Shared objects will always need at least a REL relocation. */
2823 if (info
->shared
|| maybe_dynamic
)
2824 need_entry
= NEED_DYNREL
;
2827 case R_IA64_PCREL22
:
2828 case R_IA64_PCREL64I
:
2829 case R_IA64_PCREL32MSB
:
2830 case R_IA64_PCREL32LSB
:
2831 case R_IA64_PCREL64MSB
:
2832 case R_IA64_PCREL64LSB
:
2834 need_entry
= NEED_DYNREL
;
2841 if ((need_entry
& NEED_FPTR
) != 0
2844 (*info
->callbacks
->warning
)
2845 (info
, _("non-zero addend in @fptr reloc"), 0,
2846 abfd
, 0, (bfd_vma
) 0);
2849 if (get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, TRUE
) == NULL
)
2853 /* Now, we only do lookup without insertion, which is very fast
2854 with the modified get_dyn_sym_info. */
2855 for (rel
= relocs
; rel
< relend
; ++rel
)
2857 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
2858 int dynrel_type
= R_IA64_NONE
;
2860 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
2861 if (r_symndx
>= symtab_hdr
->sh_info
)
2863 /* We're dealing with a global symbol -- find its hash entry
2864 and mark it as being referenced. */
2865 long indx
= r_symndx
- symtab_hdr
->sh_info
;
2866 h
= elf_sym_hashes (abfd
)[indx
];
2867 while (h
->root
.type
== bfd_link_hash_indirect
2868 || h
->root
.type
== bfd_link_hash_warning
)
2869 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2876 /* We can only get preliminary data on whether a symbol is
2877 locally or externally defined, as not all of the input files
2878 have yet been processed. Do something with what we know, as
2879 this may help reduce memory usage and processing time later. */
2880 maybe_dynamic
= (h
&& ((!info
->executable
2881 && (!SYMBOLIC_BIND (info
, h
)
2882 || info
->unresolved_syms_in_shared_libs
== RM_IGNORE
))
2884 || h
->root
.type
== bfd_link_hash_defweak
));
2887 switch (ELFNN_R_TYPE (rel
->r_info
))
2889 case R_IA64_TPREL64MSB
:
2890 case R_IA64_TPREL64LSB
:
2891 if (info
->shared
|| maybe_dynamic
)
2892 need_entry
= NEED_DYNREL
;
2893 dynrel_type
= R_IA64_TPREL64LSB
;
2895 info
->flags
|= DF_STATIC_TLS
;
2898 case R_IA64_LTOFF_TPREL22
:
2899 need_entry
= NEED_TPREL
;
2901 info
->flags
|= DF_STATIC_TLS
;
2904 case R_IA64_DTPREL32MSB
:
2905 case R_IA64_DTPREL32LSB
:
2906 case R_IA64_DTPREL64MSB
:
2907 case R_IA64_DTPREL64LSB
:
2908 if (info
->shared
|| maybe_dynamic
)
2909 need_entry
= NEED_DYNREL
;
2910 dynrel_type
= R_IA64_DTPRELNNLSB
;
2913 case R_IA64_LTOFF_DTPREL22
:
2914 need_entry
= NEED_DTPREL
;
2917 case R_IA64_DTPMOD64MSB
:
2918 case R_IA64_DTPMOD64LSB
:
2919 if (info
->shared
|| maybe_dynamic
)
2920 need_entry
= NEED_DYNREL
;
2921 dynrel_type
= R_IA64_DTPMOD64LSB
;
2924 case R_IA64_LTOFF_DTPMOD22
:
2925 need_entry
= NEED_DTPMOD
;
2928 case R_IA64_LTOFF_FPTR22
:
2929 case R_IA64_LTOFF_FPTR64I
:
2930 case R_IA64_LTOFF_FPTR32MSB
:
2931 case R_IA64_LTOFF_FPTR32LSB
:
2932 case R_IA64_LTOFF_FPTR64MSB
:
2933 case R_IA64_LTOFF_FPTR64LSB
:
2934 need_entry
= NEED_FPTR
| NEED_GOT
| NEED_LTOFF_FPTR
;
2937 case R_IA64_FPTR64I
:
2938 case R_IA64_FPTR32MSB
:
2939 case R_IA64_FPTR32LSB
:
2940 case R_IA64_FPTR64MSB
:
2941 case R_IA64_FPTR64LSB
:
2942 if (info
->shared
|| h
)
2943 need_entry
= NEED_FPTR
| NEED_DYNREL
;
2945 need_entry
= NEED_FPTR
;
2946 dynrel_type
= R_IA64_FPTRNNLSB
;
2949 case R_IA64_LTOFF22
:
2950 case R_IA64_LTOFF64I
:
2951 need_entry
= NEED_GOT
;
2954 case R_IA64_LTOFF22X
:
2955 need_entry
= NEED_GOTX
;
2958 case R_IA64_PLTOFF22
:
2959 case R_IA64_PLTOFF64I
:
2960 case R_IA64_PLTOFF64MSB
:
2961 case R_IA64_PLTOFF64LSB
:
2962 need_entry
= NEED_PLTOFF
;
2966 need_entry
|= NEED_MIN_PLT
;
2970 case R_IA64_PCREL21B
:
2971 case R_IA64_PCREL60B
:
2972 /* Depending on where this symbol is defined, we may or may not
2973 need a full plt entry. Only skip if we know we'll not need
2974 the entry -- static or symbolic, and the symbol definition
2975 has already been seen. */
2976 if (maybe_dynamic
&& rel
->r_addend
== 0)
2977 need_entry
= NEED_FULL_PLT
;
2983 case R_IA64_DIR32MSB
:
2984 case R_IA64_DIR32LSB
:
2985 case R_IA64_DIR64MSB
:
2986 case R_IA64_DIR64LSB
:
2987 /* Shared objects will always need at least a REL relocation. */
2988 if (info
->shared
|| maybe_dynamic
)
2989 need_entry
= NEED_DYNREL
;
2990 dynrel_type
= R_IA64_DIRNNLSB
;
2993 case R_IA64_IPLTMSB
:
2994 case R_IA64_IPLTLSB
:
2995 /* Shared objects will always need at least a REL relocation. */
2996 if (info
->shared
|| maybe_dynamic
)
2997 need_entry
= NEED_DYNREL
;
2998 dynrel_type
= R_IA64_IPLTLSB
;
3001 case R_IA64_PCREL22
:
3002 case R_IA64_PCREL64I
:
3003 case R_IA64_PCREL32MSB
:
3004 case R_IA64_PCREL32LSB
:
3005 case R_IA64_PCREL64MSB
:
3006 case R_IA64_PCREL64LSB
:
3008 need_entry
= NEED_DYNREL
;
3009 dynrel_type
= R_IA64_PCRELNNLSB
;
3016 dyn_i
= get_dyn_sym_info (ia64_info
, h
, abfd
, rel
, FALSE
);
3018 /* Record whether or not this is a local symbol. */
3021 /* Create what's needed. */
3022 if (need_entry
& (NEED_GOT
| NEED_GOTX
| NEED_TPREL
3023 | NEED_DTPMOD
| NEED_DTPREL
))
3027 got
= get_got (abfd
, info
, ia64_info
);
3031 if (need_entry
& NEED_GOT
)
3032 dyn_i
->want_got
= 1;
3033 if (need_entry
& NEED_GOTX
)
3034 dyn_i
->want_gotx
= 1;
3035 if (need_entry
& NEED_TPREL
)
3036 dyn_i
->want_tprel
= 1;
3037 if (need_entry
& NEED_DTPMOD
)
3038 dyn_i
->want_dtpmod
= 1;
3039 if (need_entry
& NEED_DTPREL
)
3040 dyn_i
->want_dtprel
= 1;
3042 if (need_entry
& NEED_FPTR
)
3046 fptr
= get_fptr (abfd
, info
, ia64_info
);
3051 /* FPTRs for shared libraries are allocated by the dynamic
3052 linker. Make sure this local symbol will appear in the
3053 dynamic symbol table. */
3054 if (!h
&& info
->shared
)
3056 if (! (bfd_elf_link_record_local_dynamic_symbol
3057 (info
, abfd
, (long) r_symndx
)))
3061 dyn_i
->want_fptr
= 1;
3063 if (need_entry
& NEED_LTOFF_FPTR
)
3064 dyn_i
->want_ltoff_fptr
= 1;
3065 if (need_entry
& (NEED_MIN_PLT
| NEED_FULL_PLT
))
3067 if (!ia64_info
->root
.dynobj
)
3068 ia64_info
->root
.dynobj
= abfd
;
3070 dyn_i
->want_plt
= 1;
3072 if (need_entry
& NEED_FULL_PLT
)
3073 dyn_i
->want_plt2
= 1;
3074 if (need_entry
& NEED_PLTOFF
)
3076 /* This is needed here, in case @pltoff is used in a non-shared
3080 pltoff
= get_pltoff (abfd
, info
, ia64_info
);
3085 dyn_i
->want_pltoff
= 1;
3087 if ((need_entry
& NEED_DYNREL
) && (sec
->flags
& SEC_ALLOC
))
3091 srel
= get_reloc_section (abfd
, ia64_info
, sec
, TRUE
);
3095 if (!count_dyn_reloc (abfd
, dyn_i
, srel
, dynrel_type
,
3096 (sec
->flags
& SEC_READONLY
) != 0))
3104 /* For cleanliness, and potentially faster dynamic loading, allocate
3105 external GOT entries first. */
3108 allocate_global_data_got (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3111 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
3113 if ((dyn_i
->want_got
|| dyn_i
->want_gotx
)
3114 && ! dyn_i
->want_fptr
3115 && elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0))
3117 dyn_i
->got_offset
= x
->ofs
;
3120 if (dyn_i
->want_tprel
)
3122 dyn_i
->tprel_offset
= x
->ofs
;
3125 if (dyn_i
->want_dtpmod
)
3127 if (elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0))
3129 dyn_i
->dtpmod_offset
= x
->ofs
;
3134 struct elfNN_ia64_link_hash_table
*ia64_info
;
3136 ia64_info
= elfNN_ia64_hash_table (x
->info
);
3137 if (ia64_info
->self_dtpmod_offset
== (bfd_vma
) -1)
3139 ia64_info
->self_dtpmod_offset
= x
->ofs
;
3142 dyn_i
->dtpmod_offset
= ia64_info
->self_dtpmod_offset
;
3145 if (dyn_i
->want_dtprel
)
3147 dyn_i
->dtprel_offset
= x
->ofs
;
3153 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
3156 allocate_global_fptr_got (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3159 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
3163 && elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, R_IA64_FPTRNNLSB
))
3165 dyn_i
->got_offset
= x
->ofs
;
3171 /* Lastly, allocate all the GOT entries for local data. */
3174 allocate_local_got (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3177 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
3179 if ((dyn_i
->want_got
|| dyn_i
->want_gotx
)
3180 && !elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0))
3182 dyn_i
->got_offset
= x
->ofs
;
3188 /* Search for the index of a global symbol in it's defining object file. */
3191 global_sym_index (struct elf_link_hash_entry
*h
)
3193 struct elf_link_hash_entry
**p
;
3196 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
3197 || h
->root
.type
== bfd_link_hash_defweak
);
3199 obj
= h
->root
.u
.def
.section
->owner
;
3200 for (p
= elf_sym_hashes (obj
); *p
!= h
; ++p
)
3203 return p
- elf_sym_hashes (obj
) + elf_tdata (obj
)->symtab_hdr
.sh_info
;
3206 /* Allocate function descriptors. We can do these for every function
3207 in a main executable that is not exported. */
3210 allocate_fptr (struct elfNN_ia64_dyn_sym_info
*dyn_i
, PTR data
)
3212 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
3214 if (dyn_i
->want_fptr
)
3216 struct elf_link_hash_entry
*h
= dyn_i
->h
;
3219 while (h
->root
.type
== bfd_link_hash_indirect
3220 || h
->root
.type
== bfd_link_hash_warning
)
3221 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3223 if (!x
->info
->executable
3225 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
3226 || (h
->root
.type
!= bfd_link_hash_undefweak
3227 && h
->root
.type
!= bfd_link_hash_undefined
)))
3229 if (h
&& h
->dynindx
== -1)
3231 BFD_ASSERT ((h
->root
.type
== bfd_link_hash_defined
)
3232 || (h
->root
.type
== bfd_link_hash_defweak
));
3234 if (!bfd_elf_link_record_local_dynamic_symbol
3235 (x
->info
, h
->root
.u
.def
.section
->owner
,
3236 global_sym_index (h
)))
3240 dyn_i
->want_fptr
= 0;
3242 else if (h
== NULL
|| h
->dynindx
== -1)
3244 dyn_i
->fptr_offset
= x
->ofs
;
3248 dyn_i
->want_fptr
= 0;
3253 /* Allocate all the minimal PLT entries. */
3256 allocate_plt_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3259 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
3261 if (dyn_i
->want_plt
)
3263 struct elf_link_hash_entry
*h
= dyn_i
->h
;
3266 while (h
->root
.type
== bfd_link_hash_indirect
3267 || h
->root
.type
== bfd_link_hash_warning
)
3268 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3270 /* ??? Versioned symbols seem to lose NEEDS_PLT. */
3271 if (elfNN_ia64_dynamic_symbol_p (h
, x
->info
, 0))
3273 bfd_size_type offset
= x
->ofs
;
3275 offset
= PLT_HEADER_SIZE
;
3276 dyn_i
->plt_offset
= offset
;
3277 x
->ofs
= offset
+ PLT_MIN_ENTRY_SIZE
;
3279 dyn_i
->want_pltoff
= 1;
3283 dyn_i
->want_plt
= 0;
3284 dyn_i
->want_plt2
= 0;
3290 /* Allocate all the full PLT entries. */
3293 allocate_plt2_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3296 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
3298 if (dyn_i
->want_plt2
)
3300 struct elf_link_hash_entry
*h
= dyn_i
->h
;
3301 bfd_size_type ofs
= x
->ofs
;
3303 dyn_i
->plt2_offset
= ofs
;
3304 x
->ofs
= ofs
+ PLT_FULL_ENTRY_SIZE
;
3306 while (h
->root
.type
== bfd_link_hash_indirect
3307 || h
->root
.type
== bfd_link_hash_warning
)
3308 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3309 dyn_i
->h
->plt
.offset
= ofs
;
3314 /* Allocate all the PLTOFF entries requested by relocations and
3315 plt entries. We can't share space with allocated FPTR entries,
3316 because the latter are not necessarily addressable by the GP.
3317 ??? Relaxation might be able to determine that they are. */
3320 allocate_pltoff_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3323 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
3325 if (dyn_i
->want_pltoff
)
3327 dyn_i
->pltoff_offset
= x
->ofs
;
3333 /* Allocate dynamic relocations for those symbols that turned out
3337 allocate_dynrel_entries (struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3340 struct elfNN_ia64_allocate_data
*x
= (struct elfNN_ia64_allocate_data
*)data
;
3341 struct elfNN_ia64_link_hash_table
*ia64_info
;
3342 struct elfNN_ia64_dyn_reloc_entry
*rent
;
3343 bfd_boolean dynamic_symbol
, shared
, resolved_zero
;
3345 ia64_info
= elfNN_ia64_hash_table (x
->info
);
3347 /* Note that this can't be used in relation to FPTR relocs below. */
3348 dynamic_symbol
= elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, x
->info
, 0);
3350 shared
= x
->info
->shared
;
3351 resolved_zero
= (dyn_i
->h
3352 && ELF_ST_VISIBILITY (dyn_i
->h
->other
)
3353 && dyn_i
->h
->root
.type
== bfd_link_hash_undefweak
);
3355 /* Take care of the GOT and PLT relocations. */
3358 && (dynamic_symbol
|| shared
)
3359 && (dyn_i
->want_got
|| dyn_i
->want_gotx
))
3360 || (dyn_i
->want_ltoff_fptr
3362 && dyn_i
->h
->dynindx
!= -1))
3364 if (!dyn_i
->want_ltoff_fptr
3367 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
3368 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
3370 if ((dynamic_symbol
|| shared
) && dyn_i
->want_tprel
)
3371 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
3372 if (dynamic_symbol
&& dyn_i
->want_dtpmod
)
3373 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
3374 if (dynamic_symbol
&& dyn_i
->want_dtprel
)
3375 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
3380 if (ia64_info
->rel_fptr_sec
&& dyn_i
->want_fptr
)
3382 if (dyn_i
->h
== NULL
|| dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
3383 ia64_info
->rel_fptr_sec
->size
+= sizeof (ElfNN_External_Rela
);
3386 if (!resolved_zero
&& dyn_i
->want_pltoff
)
3388 bfd_size_type t
= 0;
3390 /* Dynamic symbols get one IPLT relocation. Local symbols in
3391 shared libraries get two REL relocations. Local symbols in
3392 main applications get nothing. */
3394 t
= sizeof (ElfNN_External_Rela
);
3396 t
= 2 * sizeof (ElfNN_External_Rela
);
3398 ia64_info
->rel_pltoff_sec
->size
+= t
;
3401 /* Take care of the normal data relocations. */
3403 for (rent
= dyn_i
->reloc_entries
; rent
; rent
= rent
->next
)
3405 int count
= rent
->count
;
3409 case R_IA64_FPTR32LSB
:
3410 case R_IA64_FPTR64LSB
:
3411 /* Allocate one iff !want_fptr and not PIE, which by this point
3412 will be true only if we're actually allocating one statically
3413 in the main executable. Position independent executables
3414 need a relative reloc. */
3415 if (dyn_i
->want_fptr
&& !x
->info
->pie
)
3418 case R_IA64_PCREL32LSB
:
3419 case R_IA64_PCREL64LSB
:
3420 if (!dynamic_symbol
)
3423 case R_IA64_DIR32LSB
:
3424 case R_IA64_DIR64LSB
:
3425 if (!dynamic_symbol
&& !shared
)
3428 case R_IA64_IPLTLSB
:
3429 if (!dynamic_symbol
&& !shared
)
3431 /* Use two REL relocations for IPLT relocations
3432 against local symbols. */
3433 if (!dynamic_symbol
)
3436 case R_IA64_DTPREL32LSB
:
3437 case R_IA64_TPREL64LSB
:
3438 case R_IA64_DTPREL64LSB
:
3439 case R_IA64_DTPMOD64LSB
:
3445 ia64_info
->reltext
= 1;
3446 rent
->srel
->size
+= sizeof (ElfNN_External_Rela
) * count
;
3453 elfNN_ia64_adjust_dynamic_symbol (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3454 struct elf_link_hash_entry
*h
)
3456 /* ??? Undefined symbols with PLT entries should be re-defined
3457 to be the PLT entry. */
3459 /* If this is a weak symbol, and there is a real definition, the
3460 processor independent code will have arranged for us to see the
3461 real definition first, and we can just use the same value. */
3462 if (h
->u
.weakdef
!= NULL
)
3464 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
3465 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
3466 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
3467 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
3471 /* If this is a reference to a symbol defined by a dynamic object which
3472 is not a function, we might allocate the symbol in our .dynbss section
3473 and allocate a COPY dynamic relocation.
3475 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
3482 elfNN_ia64_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
3483 struct bfd_link_info
*info
)
3485 struct elfNN_ia64_allocate_data data
;
3486 struct elfNN_ia64_link_hash_table
*ia64_info
;
3489 bfd_boolean relplt
= FALSE
;
3491 dynobj
= elf_hash_table(info
)->dynobj
;
3492 ia64_info
= elfNN_ia64_hash_table (info
);
3493 ia64_info
->self_dtpmod_offset
= (bfd_vma
) -1;
3494 BFD_ASSERT(dynobj
!= NULL
);
3497 /* Set the contents of the .interp section to the interpreter. */
3498 if (ia64_info
->root
.dynamic_sections_created
3499 && info
->executable
)
3501 sec
= bfd_get_section_by_name (dynobj
, ".interp");
3502 BFD_ASSERT (sec
!= NULL
);
3503 sec
->contents
= (bfd_byte
*) ELF_DYNAMIC_INTERPRETER
;
3504 sec
->size
= strlen (ELF_DYNAMIC_INTERPRETER
) + 1;
3507 /* Allocate the GOT entries. */
3509 if (ia64_info
->root
.sgot
)
3512 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_data_got
, &data
);
3513 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_global_fptr_got
, &data
);
3514 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_local_got
, &data
);
3515 ia64_info
->root
.sgot
->size
= data
.ofs
;
3518 /* Allocate the FPTR entries. */
3520 if (ia64_info
->fptr_sec
)
3523 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_fptr
, &data
);
3524 ia64_info
->fptr_sec
->size
= data
.ofs
;
3527 /* Now that we've seen all of the input files, we can decide which
3528 symbols need plt entries. Allocate the minimal PLT entries first.
3529 We do this even though dynamic_sections_created may be FALSE, because
3530 this has the side-effect of clearing want_plt and want_plt2. */
3533 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_plt_entries
, &data
);
3535 ia64_info
->minplt_entries
= 0;
3538 ia64_info
->minplt_entries
3539 = (data
.ofs
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
3542 /* Align the pointer for the plt2 entries. */
3543 data
.ofs
= (data
.ofs
+ 31) & (bfd_vma
) -32;
3545 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_plt2_entries
, &data
);
3546 if (data
.ofs
!= 0 || ia64_info
->root
.dynamic_sections_created
)
3548 /* FIXME: we always reserve the memory for dynamic linker even if
3549 there are no PLT entries since dynamic linker may assume the
3550 reserved memory always exists. */
3552 BFD_ASSERT (ia64_info
->root
.dynamic_sections_created
);
3554 ia64_info
->root
.splt
->size
= data
.ofs
;
3556 /* If we've got a .plt, we need some extra memory for the dynamic
3557 linker. We stuff these in .got.plt. */
3558 sec
= bfd_get_section_by_name (dynobj
, ".got.plt");
3559 sec
->size
= 8 * PLT_RESERVED_WORDS
;
3562 /* Allocate the PLTOFF entries. */
3564 if (ia64_info
->pltoff_sec
)
3567 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_pltoff_entries
, &data
);
3568 ia64_info
->pltoff_sec
->size
= data
.ofs
;
3571 if (ia64_info
->root
.dynamic_sections_created
)
3573 /* Allocate space for the dynamic relocations that turned out to be
3576 if (info
->shared
&& ia64_info
->self_dtpmod_offset
!= (bfd_vma
) -1)
3577 ia64_info
->root
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
3578 data
.only_got
= FALSE
;
3579 elfNN_ia64_dyn_sym_traverse (ia64_info
, allocate_dynrel_entries
, &data
);
3582 /* We have now determined the sizes of the various dynamic sections.
3583 Allocate memory for them. */
3584 for (sec
= dynobj
->sections
; sec
!= NULL
; sec
= sec
->next
)
3588 if (!(sec
->flags
& SEC_LINKER_CREATED
))
3591 /* If we don't need this section, strip it from the output file.
3592 There were several sections primarily related to dynamic
3593 linking that must be create before the linker maps input
3594 sections to output sections. The linker does that before
3595 bfd_elf_size_dynamic_sections is called, and it is that
3596 function which decides whether anything needs to go into
3599 strip
= (sec
->size
== 0);
3601 if (sec
== ia64_info
->root
.sgot
)
3603 else if (sec
== ia64_info
->root
.srelgot
)
3606 ia64_info
->root
.srelgot
= NULL
;
3608 /* We use the reloc_count field as a counter if we need to
3609 copy relocs into the output file. */
3610 sec
->reloc_count
= 0;
3612 else if (sec
== ia64_info
->fptr_sec
)
3615 ia64_info
->fptr_sec
= NULL
;
3617 else if (sec
== ia64_info
->rel_fptr_sec
)
3620 ia64_info
->rel_fptr_sec
= NULL
;
3622 /* We use the reloc_count field as a counter if we need to
3623 copy relocs into the output file. */
3624 sec
->reloc_count
= 0;
3626 else if (sec
== ia64_info
->root
.splt
)
3629 ia64_info
->root
.splt
= NULL
;
3631 else if (sec
== ia64_info
->pltoff_sec
)
3634 ia64_info
->pltoff_sec
= NULL
;
3636 else if (sec
== ia64_info
->rel_pltoff_sec
)
3639 ia64_info
->rel_pltoff_sec
= NULL
;
3643 /* We use the reloc_count field as a counter if we need to
3644 copy relocs into the output file. */
3645 sec
->reloc_count
= 0;
3652 /* It's OK to base decisions on the section name, because none
3653 of the dynobj section names depend upon the input files. */
3654 name
= bfd_get_section_name (dynobj
, sec
);
3656 if (strcmp (name
, ".got.plt") == 0)
3658 else if (CONST_STRNEQ (name
, ".rel"))
3662 /* We use the reloc_count field as a counter if we need to
3663 copy relocs into the output file. */
3664 sec
->reloc_count
= 0;
3672 sec
->flags
|= SEC_EXCLUDE
;
3675 /* Allocate memory for the section contents. */
3676 sec
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, sec
->size
);
3677 if (sec
->contents
== NULL
&& sec
->size
!= 0)
3682 if (elf_hash_table (info
)->dynamic_sections_created
)
3684 /* Add some entries to the .dynamic section. We fill in the values
3685 later (in finish_dynamic_sections) but we must add the entries now
3686 so that we get the correct size for the .dynamic section. */
3688 if (info
->executable
)
3690 /* The DT_DEBUG entry is filled in by the dynamic linker and used
3692 #define add_dynamic_entry(TAG, VAL) \
3693 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3695 if (!add_dynamic_entry (DT_DEBUG
, 0))
3699 if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE
, 0))
3701 if (!add_dynamic_entry (DT_PLTGOT
, 0))
3706 if (!add_dynamic_entry (DT_PLTRELSZ
, 0)
3707 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
3708 || !add_dynamic_entry (DT_JMPREL
, 0))
3712 if (!add_dynamic_entry (DT_RELA
, 0)
3713 || !add_dynamic_entry (DT_RELASZ
, 0)
3714 || !add_dynamic_entry (DT_RELAENT
, sizeof (ElfNN_External_Rela
)))
3717 if (ia64_info
->reltext
)
3719 if (!add_dynamic_entry (DT_TEXTREL
, 0))
3721 info
->flags
|= DF_TEXTREL
;
3725 /* ??? Perhaps force __gp local. */
3730 static bfd_reloc_status_type
3731 elfNN_ia64_install_value (bfd_byte
*hit_addr
, bfd_vma v
,
3732 unsigned int r_type
)
3734 const struct ia64_operand
*op
;
3735 int bigendian
= 0, shift
= 0;
3736 bfd_vma t0
, t1
, dword
;
3738 enum ia64_opnd opnd
;
3741 #ifdef BFD_HOST_U_64_BIT
3742 BFD_HOST_U_64_BIT val
= (BFD_HOST_U_64_BIT
) v
;
3747 opnd
= IA64_OPND_NIL
;
3752 return bfd_reloc_ok
;
3754 /* Instruction relocations. */
3757 case R_IA64_TPREL14
:
3758 case R_IA64_DTPREL14
:
3759 opnd
= IA64_OPND_IMM14
;
3762 case R_IA64_PCREL21F
: opnd
= IA64_OPND_TGT25
; break;
3763 case R_IA64_PCREL21M
: opnd
= IA64_OPND_TGT25b
; break;
3764 case R_IA64_PCREL60B
: opnd
= IA64_OPND_TGT64
; break;
3765 case R_IA64_PCREL21B
:
3766 case R_IA64_PCREL21BI
:
3767 opnd
= IA64_OPND_TGT25c
;
3771 case R_IA64_GPREL22
:
3772 case R_IA64_LTOFF22
:
3773 case R_IA64_LTOFF22X
:
3774 case R_IA64_PLTOFF22
:
3775 case R_IA64_PCREL22
:
3776 case R_IA64_LTOFF_FPTR22
:
3777 case R_IA64_TPREL22
:
3778 case R_IA64_DTPREL22
:
3779 case R_IA64_LTOFF_TPREL22
:
3780 case R_IA64_LTOFF_DTPMOD22
:
3781 case R_IA64_LTOFF_DTPREL22
:
3782 opnd
= IA64_OPND_IMM22
;
3786 case R_IA64_GPREL64I
:
3787 case R_IA64_LTOFF64I
:
3788 case R_IA64_PLTOFF64I
:
3789 case R_IA64_PCREL64I
:
3790 case R_IA64_FPTR64I
:
3791 case R_IA64_LTOFF_FPTR64I
:
3792 case R_IA64_TPREL64I
:
3793 case R_IA64_DTPREL64I
:
3794 opnd
= IA64_OPND_IMMU64
;
3797 /* Data relocations. */
3799 case R_IA64_DIR32MSB
:
3800 case R_IA64_GPREL32MSB
:
3801 case R_IA64_FPTR32MSB
:
3802 case R_IA64_PCREL32MSB
:
3803 case R_IA64_LTOFF_FPTR32MSB
:
3804 case R_IA64_SEGREL32MSB
:
3805 case R_IA64_SECREL32MSB
:
3806 case R_IA64_LTV32MSB
:
3807 case R_IA64_DTPREL32MSB
:
3808 size
= 4; bigendian
= 1;
3811 case R_IA64_DIR32LSB
:
3812 case R_IA64_GPREL32LSB
:
3813 case R_IA64_FPTR32LSB
:
3814 case R_IA64_PCREL32LSB
:
3815 case R_IA64_LTOFF_FPTR32LSB
:
3816 case R_IA64_SEGREL32LSB
:
3817 case R_IA64_SECREL32LSB
:
3818 case R_IA64_LTV32LSB
:
3819 case R_IA64_DTPREL32LSB
:
3820 size
= 4; bigendian
= 0;
3823 case R_IA64_DIR64MSB
:
3824 case R_IA64_GPREL64MSB
:
3825 case R_IA64_PLTOFF64MSB
:
3826 case R_IA64_FPTR64MSB
:
3827 case R_IA64_PCREL64MSB
:
3828 case R_IA64_LTOFF_FPTR64MSB
:
3829 case R_IA64_SEGREL64MSB
:
3830 case R_IA64_SECREL64MSB
:
3831 case R_IA64_LTV64MSB
:
3832 case R_IA64_TPREL64MSB
:
3833 case R_IA64_DTPMOD64MSB
:
3834 case R_IA64_DTPREL64MSB
:
3835 size
= 8; bigendian
= 1;
3838 case R_IA64_DIR64LSB
:
3839 case R_IA64_GPREL64LSB
:
3840 case R_IA64_PLTOFF64LSB
:
3841 case R_IA64_FPTR64LSB
:
3842 case R_IA64_PCREL64LSB
:
3843 case R_IA64_LTOFF_FPTR64LSB
:
3844 case R_IA64_SEGREL64LSB
:
3845 case R_IA64_SECREL64LSB
:
3846 case R_IA64_LTV64LSB
:
3847 case R_IA64_TPREL64LSB
:
3848 case R_IA64_DTPMOD64LSB
:
3849 case R_IA64_DTPREL64LSB
:
3850 size
= 8; bigendian
= 0;
3853 /* Unsupported / Dynamic relocations. */
3855 return bfd_reloc_notsupported
;
3860 case IA64_OPND_IMMU64
:
3861 hit_addr
-= (long) hit_addr
& 0x3;
3862 t0
= bfd_getl64 (hit_addr
);
3863 t1
= bfd_getl64 (hit_addr
+ 8);
3865 /* tmpl/s: bits 0.. 5 in t0
3866 slot 0: bits 5..45 in t0
3867 slot 1: bits 46..63 in t0, bits 0..22 in t1
3868 slot 2: bits 23..63 in t1 */
3870 /* First, clear the bits that form the 64 bit constant. */
3871 t0
&= ~(0x3ffffLL
<< 46);
3873 | (( (0x07fLL
<< 13) | (0x1ffLL
<< 27)
3874 | (0x01fLL
<< 22) | (0x001LL
<< 21)
3875 | (0x001LL
<< 36)) << 23));
3877 t0
|= ((val
>> 22) & 0x03ffffLL
) << 46; /* 18 lsbs of imm41 */
3878 t1
|= ((val
>> 40) & 0x7fffffLL
) << 0; /* 23 msbs of imm41 */
3879 t1
|= ( (((val
>> 0) & 0x07f) << 13) /* imm7b */
3880 | (((val
>> 7) & 0x1ff) << 27) /* imm9d */
3881 | (((val
>> 16) & 0x01f) << 22) /* imm5c */
3882 | (((val
>> 21) & 0x001) << 21) /* ic */
3883 | (((val
>> 63) & 0x001) << 36)) << 23; /* i */
3885 bfd_putl64 (t0
, hit_addr
);
3886 bfd_putl64 (t1
, hit_addr
+ 8);
3889 case IA64_OPND_TGT64
:
3890 hit_addr
-= (long) hit_addr
& 0x3;
3891 t0
= bfd_getl64 (hit_addr
);
3892 t1
= bfd_getl64 (hit_addr
+ 8);
3894 /* tmpl/s: bits 0.. 5 in t0
3895 slot 0: bits 5..45 in t0
3896 slot 1: bits 46..63 in t0, bits 0..22 in t1
3897 slot 2: bits 23..63 in t1 */
3899 /* First, clear the bits that form the 64 bit constant. */
3900 t0
&= ~(0x3ffffLL
<< 46);
3902 | ((1LL << 36 | 0xfffffLL
<< 13) << 23));
3905 t0
|= ((val
>> 20) & 0xffffLL
) << 2 << 46; /* 16 lsbs of imm39 */
3906 t1
|= ((val
>> 36) & 0x7fffffLL
) << 0; /* 23 msbs of imm39 */
3907 t1
|= ((((val
>> 0) & 0xfffffLL
) << 13) /* imm20b */
3908 | (((val
>> 59) & 0x1LL
) << 36)) << 23; /* i */
3910 bfd_putl64 (t0
, hit_addr
);
3911 bfd_putl64 (t1
, hit_addr
+ 8);
3915 switch ((long) hit_addr
& 0x3)
3917 case 0: shift
= 5; break;
3918 case 1: shift
= 14; hit_addr
+= 3; break;
3919 case 2: shift
= 23; hit_addr
+= 6; break;
3920 case 3: return bfd_reloc_notsupported
; /* shouldn't happen... */
3922 dword
= bfd_getl64 (hit_addr
);
3923 insn
= (dword
>> shift
) & 0x1ffffffffffLL
;
3925 op
= elf64_ia64_operands
+ opnd
;
3926 err
= (*op
->insert
) (op
, val
, &insn
);
3928 return bfd_reloc_overflow
;
3930 dword
&= ~(0x1ffffffffffLL
<< shift
);
3931 dword
|= (insn
<< shift
);
3932 bfd_putl64 (dword
, hit_addr
);
3936 /* A data relocation. */
3939 bfd_putb32 (val
, hit_addr
);
3941 bfd_putb64 (val
, hit_addr
);
3944 bfd_putl32 (val
, hit_addr
);
3946 bfd_putl64 (val
, hit_addr
);
3950 return bfd_reloc_ok
;
3954 elfNN_ia64_install_dyn_reloc (bfd
*abfd
, struct bfd_link_info
*info
,
3955 asection
*sec
, asection
*srel
,
3956 bfd_vma offset
, unsigned int type
,
3957 long dynindx
, bfd_vma addend
)
3959 Elf_Internal_Rela outrel
;
3962 BFD_ASSERT (dynindx
!= -1);
3963 outrel
.r_info
= ELFNN_R_INFO (dynindx
, type
);
3964 outrel
.r_addend
= addend
;
3965 outrel
.r_offset
= _bfd_elf_section_offset (abfd
, info
, sec
, offset
);
3966 if (outrel
.r_offset
>= (bfd_vma
) -2)
3968 /* Run for the hills. We shouldn't be outputting a relocation
3969 for this. So do what everyone else does and output a no-op. */
3970 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_NONE
);
3971 outrel
.r_addend
= 0;
3972 outrel
.r_offset
= 0;
3975 outrel
.r_offset
+= sec
->output_section
->vma
+ sec
->output_offset
;
3977 loc
= srel
->contents
;
3978 loc
+= srel
->reloc_count
++ * sizeof (ElfNN_External_Rela
);
3979 bfd_elfNN_swap_reloca_out (abfd
, &outrel
, loc
);
3980 BFD_ASSERT (sizeof (ElfNN_External_Rela
) * srel
->reloc_count
<= srel
->size
);
3983 /* Store an entry for target address TARGET_ADDR in the linkage table
3984 and return the gp-relative address of the linkage table entry. */
3987 set_got_entry (bfd
*abfd
, struct bfd_link_info
*info
,
3988 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
3989 long dynindx
, bfd_vma addend
, bfd_vma value
,
3990 unsigned int dyn_r_type
)
3992 struct elfNN_ia64_link_hash_table
*ia64_info
;
3997 ia64_info
= elfNN_ia64_hash_table (info
);
3998 got_sec
= ia64_info
->root
.sgot
;
4002 case R_IA64_TPREL64LSB
:
4003 done
= dyn_i
->tprel_done
;
4004 dyn_i
->tprel_done
= TRUE
;
4005 got_offset
= dyn_i
->tprel_offset
;
4007 case R_IA64_DTPMOD64LSB
:
4008 if (dyn_i
->dtpmod_offset
!= ia64_info
->self_dtpmod_offset
)
4010 done
= dyn_i
->dtpmod_done
;
4011 dyn_i
->dtpmod_done
= TRUE
;
4015 done
= ia64_info
->self_dtpmod_done
;
4016 ia64_info
->self_dtpmod_done
= TRUE
;
4019 got_offset
= dyn_i
->dtpmod_offset
;
4021 case R_IA64_DTPREL32LSB
:
4022 case R_IA64_DTPREL64LSB
:
4023 done
= dyn_i
->dtprel_done
;
4024 dyn_i
->dtprel_done
= TRUE
;
4025 got_offset
= dyn_i
->dtprel_offset
;
4028 done
= dyn_i
->got_done
;
4029 dyn_i
->got_done
= TRUE
;
4030 got_offset
= dyn_i
->got_offset
;
4034 BFD_ASSERT ((got_offset
& 7) == 0);
4038 /* Store the target address in the linkage table entry. */
4039 bfd_put_64 (abfd
, value
, got_sec
->contents
+ got_offset
);
4041 /* Install a dynamic relocation if needed. */
4044 || ELF_ST_VISIBILITY (dyn_i
->h
->other
) == STV_DEFAULT
4045 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
)
4046 && dyn_r_type
!= R_IA64_DTPREL32LSB
4047 && dyn_r_type
!= R_IA64_DTPREL64LSB
)
4048 || elfNN_ia64_dynamic_symbol_p (dyn_i
->h
, info
, dyn_r_type
)
4050 && (dyn_r_type
== R_IA64_FPTR32LSB
4051 || dyn_r_type
== R_IA64_FPTR64LSB
)))
4052 && (!dyn_i
->want_ltoff_fptr
4055 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
4058 && dyn_r_type
!= R_IA64_TPREL64LSB
4059 && dyn_r_type
!= R_IA64_DTPMOD64LSB
4060 && dyn_r_type
!= R_IA64_DTPREL32LSB
4061 && dyn_r_type
!= R_IA64_DTPREL64LSB
)
4063 dyn_r_type
= R_IA64_RELNNLSB
;
4068 if (bfd_big_endian (abfd
))
4072 case R_IA64_REL32LSB
:
4073 dyn_r_type
= R_IA64_REL32MSB
;
4075 case R_IA64_DIR32LSB
:
4076 dyn_r_type
= R_IA64_DIR32MSB
;
4078 case R_IA64_FPTR32LSB
:
4079 dyn_r_type
= R_IA64_FPTR32MSB
;
4081 case R_IA64_DTPREL32LSB
:
4082 dyn_r_type
= R_IA64_DTPREL32MSB
;
4084 case R_IA64_REL64LSB
:
4085 dyn_r_type
= R_IA64_REL64MSB
;
4087 case R_IA64_DIR64LSB
:
4088 dyn_r_type
= R_IA64_DIR64MSB
;
4090 case R_IA64_FPTR64LSB
:
4091 dyn_r_type
= R_IA64_FPTR64MSB
;
4093 case R_IA64_TPREL64LSB
:
4094 dyn_r_type
= R_IA64_TPREL64MSB
;
4096 case R_IA64_DTPMOD64LSB
:
4097 dyn_r_type
= R_IA64_DTPMOD64MSB
;
4099 case R_IA64_DTPREL64LSB
:
4100 dyn_r_type
= R_IA64_DTPREL64MSB
;
4108 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, got_sec
,
4109 ia64_info
->root
.srelgot
,
4110 got_offset
, dyn_r_type
,
4115 /* Return the address of the linkage table entry. */
4116 value
= (got_sec
->output_section
->vma
4117 + got_sec
->output_offset
4123 /* Fill in a function descriptor consisting of the function's code
4124 address and its global pointer. Return the descriptor's address. */
4127 set_fptr_entry (bfd
*abfd
, struct bfd_link_info
*info
,
4128 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
4131 struct elfNN_ia64_link_hash_table
*ia64_info
;
4134 ia64_info
= elfNN_ia64_hash_table (info
);
4135 fptr_sec
= ia64_info
->fptr_sec
;
4137 if (!dyn_i
->fptr_done
)
4139 dyn_i
->fptr_done
= 1;
4141 /* Fill in the function descriptor. */
4142 bfd_put_64 (abfd
, value
, fptr_sec
->contents
+ dyn_i
->fptr_offset
);
4143 bfd_put_64 (abfd
, _bfd_get_gp_value (abfd
),
4144 fptr_sec
->contents
+ dyn_i
->fptr_offset
+ 8);
4145 if (ia64_info
->rel_fptr_sec
)
4147 Elf_Internal_Rela outrel
;
4150 if (bfd_little_endian (abfd
))
4151 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_IPLTLSB
);
4153 outrel
.r_info
= ELFNN_R_INFO (0, R_IA64_IPLTMSB
);
4154 outrel
.r_addend
= value
;
4155 outrel
.r_offset
= (fptr_sec
->output_section
->vma
4156 + fptr_sec
->output_offset
4157 + dyn_i
->fptr_offset
);
4158 loc
= ia64_info
->rel_fptr_sec
->contents
;
4159 loc
+= ia64_info
->rel_fptr_sec
->reloc_count
++
4160 * sizeof (ElfNN_External_Rela
);
4161 bfd_elfNN_swap_reloca_out (abfd
, &outrel
, loc
);
4165 /* Return the descriptor's address. */
4166 value
= (fptr_sec
->output_section
->vma
4167 + fptr_sec
->output_offset
4168 + dyn_i
->fptr_offset
);
4173 /* Fill in a PLTOFF entry consisting of the function's code address
4174 and its global pointer. Return the descriptor's address. */
4177 set_pltoff_entry (bfd
*abfd
, struct bfd_link_info
*info
,
4178 struct elfNN_ia64_dyn_sym_info
*dyn_i
,
4179 bfd_vma value
, bfd_boolean is_plt
)
4181 struct elfNN_ia64_link_hash_table
*ia64_info
;
4182 asection
*pltoff_sec
;
4184 ia64_info
= elfNN_ia64_hash_table (info
);
4185 pltoff_sec
= ia64_info
->pltoff_sec
;
4187 /* Don't do anything if this symbol uses a real PLT entry. In
4188 that case, we'll fill this in during finish_dynamic_symbol. */
4189 if ((! dyn_i
->want_plt
|| is_plt
)
4190 && !dyn_i
->pltoff_done
)
4192 bfd_vma gp
= _bfd_get_gp_value (abfd
);
4194 /* Fill in the function descriptor. */
4195 bfd_put_64 (abfd
, value
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
);
4196 bfd_put_64 (abfd
, gp
, pltoff_sec
->contents
+ dyn_i
->pltoff_offset
+ 8);
4198 /* Install dynamic relocations if needed. */
4202 || ELF_ST_VISIBILITY (dyn_i
->h
->other
) == STV_DEFAULT
4203 || dyn_i
->h
->root
.type
!= bfd_link_hash_undefweak
))
4205 unsigned int dyn_r_type
;
4207 if (bfd_big_endian (abfd
))
4208 dyn_r_type
= R_IA64_RELNNMSB
;
4210 dyn_r_type
= R_IA64_RELNNLSB
;
4212 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
4213 ia64_info
->rel_pltoff_sec
,
4214 dyn_i
->pltoff_offset
,
4215 dyn_r_type
, 0, value
);
4216 elfNN_ia64_install_dyn_reloc (abfd
, NULL
, pltoff_sec
,
4217 ia64_info
->rel_pltoff_sec
,
4218 dyn_i
->pltoff_offset
+ ARCH_SIZE
/ 8,
4222 dyn_i
->pltoff_done
= 1;
4225 /* Return the descriptor's address. */
4226 value
= (pltoff_sec
->output_section
->vma
4227 + pltoff_sec
->output_offset
4228 + dyn_i
->pltoff_offset
);
4233 /* Return the base VMA address which should be subtracted from real addresses
4234 when resolving @tprel() relocation.
4235 Main program TLS (whose template starts at PT_TLS p_vaddr)
4236 is assigned offset round(2 * size of pointer, PT_TLS p_align). */
4239 elfNN_ia64_tprel_base (struct bfd_link_info
*info
)
4241 asection
*tls_sec
= elf_hash_table (info
)->tls_sec
;
4242 return tls_sec
->vma
- align_power ((bfd_vma
) ARCH_SIZE
/ 4,
4243 tls_sec
->alignment_power
);
4246 /* Return the base VMA address which should be subtracted from real addresses
4247 when resolving @dtprel() relocation.
4248 This is PT_TLS segment p_vaddr. */
4251 elfNN_ia64_dtprel_base (struct bfd_link_info
*info
)
4253 return elf_hash_table (info
)->tls_sec
->vma
;
4256 /* Called through qsort to sort the .IA_64.unwind section during a
4257 non-relocatable link. Set elfNN_ia64_unwind_entry_compare_bfd
4258 to the output bfd so we can do proper endianness frobbing. */
4260 static bfd
*elfNN_ia64_unwind_entry_compare_bfd
;
4263 elfNN_ia64_unwind_entry_compare (const PTR a
, const PTR b
)
4267 av
= bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd
, a
);
4268 bv
= bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd
, b
);
4270 return (av
< bv
? -1 : av
> bv
? 1 : 0);
4273 /* Make sure we've got ourselves a nice fat __gp value. */
4275 elfNN_ia64_choose_gp (bfd
*abfd
, struct bfd_link_info
*info
)
4277 bfd_vma min_vma
= (bfd_vma
) -1, max_vma
= 0;
4278 bfd_vma min_short_vma
= min_vma
, max_short_vma
= 0;
4279 struct elf_link_hash_entry
*gp
;
4282 struct elfNN_ia64_link_hash_table
*ia64_info
;
4284 ia64_info
= elfNN_ia64_hash_table (info
);
4286 /* Find the min and max vma of all sections marked short. Also collect
4287 min and max vma of any type, for use in selecting a nice gp. */
4288 for (os
= abfd
->sections
; os
; os
= os
->next
)
4292 if ((os
->flags
& SEC_ALLOC
) == 0)
4296 hi
= os
->vma
+ (os
->rawsize
? os
->rawsize
: os
->size
);
4304 if (os
->flags
& SEC_SMALL_DATA
)
4306 if (min_short_vma
> lo
)
4308 if (max_short_vma
< hi
)
4313 if (ia64_info
->min_short_sec
)
4316 > (ia64_info
->min_short_sec
->output_section
->vma
4317 + ia64_info
->min_short_offset
))
4318 min_short_vma
= (ia64_info
->min_short_sec
->output_section
->vma
4319 + ia64_info
->min_short_offset
);
4321 < (ia64_info
->max_short_sec
->output_section
->vma
4322 + ia64_info
->max_short_offset
))
4323 max_short_vma
= (ia64_info
->max_short_sec
->output_section
->vma
4324 + ia64_info
->max_short_offset
);
4327 /* See if the user wants to force a value. */
4328 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
4332 && (gp
->root
.type
== bfd_link_hash_defined
4333 || gp
->root
.type
== bfd_link_hash_defweak
))
4335 asection
*gp_sec
= gp
->root
.u
.def
.section
;
4336 gp_val
= (gp
->root
.u
.def
.value
4337 + gp_sec
->output_section
->vma
4338 + gp_sec
->output_offset
);
4342 /* Pick a sensible value. */
4344 if (ia64_info
->min_short_sec
)
4346 bfd_vma short_range
= max_short_vma
- min_short_vma
;
4348 /* If min_short_sec is set, pick one in the middle bewteen
4349 min_short_vma and max_short_vma. */
4350 if (short_range
>= 0x400000)
4352 gp_val
= min_short_vma
+ short_range
/ 2;
4356 asection
*got_sec
= ia64_info
->root
.sgot
;
4358 /* Start with just the address of the .got. */
4360 gp_val
= got_sec
->output_section
->vma
;
4361 else if (max_short_vma
!= 0)
4362 gp_val
= min_short_vma
;
4363 else if (max_vma
- min_vma
< 0x200000)
4366 gp_val
= max_vma
- 0x200000 + 8;
4369 /* If it is possible to address the entire image, but we
4370 don't with the choice above, adjust. */
4371 if (max_vma
- min_vma
< 0x400000
4372 && (max_vma
- gp_val
>= 0x200000
4373 || gp_val
- min_vma
> 0x200000))
4374 gp_val
= min_vma
+ 0x200000;
4375 else if (max_short_vma
!= 0)
4377 /* If we don't cover all the short data, adjust. */
4378 if (max_short_vma
- gp_val
>= 0x200000)
4379 gp_val
= min_short_vma
+ 0x200000;
4381 /* If we're addressing stuff past the end, adjust back. */
4382 if (gp_val
> max_vma
)
4383 gp_val
= max_vma
- 0x200000 + 8;
4387 /* Validate whether all SHF_IA_64_SHORT sections are within
4388 range of the chosen GP. */
4390 if (max_short_vma
!= 0)
4392 if (max_short_vma
- min_short_vma
>= 0x400000)
4395 (*_bfd_error_handler
)
4396 (_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
4397 bfd_get_filename (abfd
),
4398 (unsigned long) (max_short_vma
- min_short_vma
));
4401 else if ((gp_val
> min_short_vma
4402 && gp_val
- min_short_vma
> 0x200000)
4403 || (gp_val
< max_short_vma
4404 && max_short_vma
- gp_val
>= 0x200000))
4406 (*_bfd_error_handler
)
4407 (_("%s: __gp does not cover short data segment"),
4408 bfd_get_filename (abfd
));
4413 _bfd_set_gp_value (abfd
, gp_val
);
4419 elfNN_ia64_final_link (bfd
*abfd
, struct bfd_link_info
*info
)
4421 struct elfNN_ia64_link_hash_table
*ia64_info
;
4422 asection
*unwind_output_sec
;
4424 ia64_info
= elfNN_ia64_hash_table (info
);
4426 /* Make sure we've got ourselves a nice fat __gp value. */
4427 if (!info
->relocatable
)
4430 struct elf_link_hash_entry
*gp
;
4432 /* We assume after gp is set, section size will only decrease. We
4433 need to adjust gp for it. */
4434 _bfd_set_gp_value (abfd
, 0);
4435 if (! elfNN_ia64_choose_gp (abfd
, info
))
4437 gp_val
= _bfd_get_gp_value (abfd
);
4439 gp
= elf_link_hash_lookup (elf_hash_table (info
), "__gp", FALSE
,
4443 gp
->root
.type
= bfd_link_hash_defined
;
4444 gp
->root
.u
.def
.value
= gp_val
;
4445 gp
->root
.u
.def
.section
= bfd_abs_section_ptr
;
4449 /* If we're producing a final executable, we need to sort the contents
4450 of the .IA_64.unwind section. Force this section to be relocated
4451 into memory rather than written immediately to the output file. */
4452 unwind_output_sec
= NULL
;
4453 if (!info
->relocatable
)
4455 asection
*s
= bfd_get_section_by_name (abfd
, ELF_STRING_ia64_unwind
);
4458 unwind_output_sec
= s
->output_section
;
4459 unwind_output_sec
->contents
4460 = bfd_malloc (unwind_output_sec
->size
);
4461 if (unwind_output_sec
->contents
== NULL
)
4466 /* Invoke the regular ELF backend linker to do all the work. */
4467 if (!bfd_elf_final_link (abfd
, info
))
4470 if (unwind_output_sec
)
4472 elfNN_ia64_unwind_entry_compare_bfd
= abfd
;
4473 qsort (unwind_output_sec
->contents
,
4474 (size_t) (unwind_output_sec
->size
/ 24),
4476 elfNN_ia64_unwind_entry_compare
);
4478 if (! bfd_set_section_contents (abfd
, unwind_output_sec
,
4479 unwind_output_sec
->contents
, (bfd_vma
) 0,
4480 unwind_output_sec
->size
))
4488 elfNN_ia64_relocate_section (bfd
*output_bfd
,
4489 struct bfd_link_info
*info
,
4491 asection
*input_section
,
4493 Elf_Internal_Rela
*relocs
,
4494 Elf_Internal_Sym
*local_syms
,
4495 asection
**local_sections
)
4497 struct elfNN_ia64_link_hash_table
*ia64_info
;
4498 Elf_Internal_Shdr
*symtab_hdr
;
4499 Elf_Internal_Rela
*rel
;
4500 Elf_Internal_Rela
*relend
;
4502 bfd_boolean ret_val
= TRUE
; /* for non-fatal errors */
4505 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
4506 ia64_info
= elfNN_ia64_hash_table (info
);
4508 /* Infect various flags from the input section to the output section. */
4509 if (info
->relocatable
)
4513 flags
= elf_section_data(input_section
)->this_hdr
.sh_flags
;
4514 flags
&= SHF_IA_64_NORECOV
;
4516 elf_section_data(input_section
->output_section
)
4517 ->this_hdr
.sh_flags
|= flags
;
4520 gp_val
= _bfd_get_gp_value (output_bfd
);
4521 srel
= get_reloc_section (input_bfd
, ia64_info
, input_section
, FALSE
);
4524 relend
= relocs
+ input_section
->reloc_count
;
4525 for (; rel
< relend
; ++rel
)
4527 struct elf_link_hash_entry
*h
;
4528 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
4529 bfd_reloc_status_type r
;
4530 reloc_howto_type
*howto
;
4531 unsigned long r_symndx
;
4532 Elf_Internal_Sym
*sym
;
4533 unsigned int r_type
;
4537 bfd_boolean dynamic_symbol_p
;
4538 bfd_boolean undef_weak_ref
;
4540 r_type
= ELFNN_R_TYPE (rel
->r_info
);
4541 if (r_type
> R_IA64_MAX_RELOC_CODE
)
4543 (*_bfd_error_handler
)
4544 (_("%B: unknown relocation type %d"),
4545 input_bfd
, (int) r_type
);
4546 bfd_set_error (bfd_error_bad_value
);
4551 howto
= lookup_howto (r_type
);
4552 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
4556 undef_weak_ref
= FALSE
;
4558 if (r_symndx
< symtab_hdr
->sh_info
)
4560 /* Reloc against local symbol. */
4562 sym
= local_syms
+ r_symndx
;
4563 sym_sec
= local_sections
[r_symndx
];
4565 value
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &msec
, rel
);
4566 if (!info
->relocatable
4567 && (sym_sec
->flags
& SEC_MERGE
) != 0
4568 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
4569 && sym_sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
)
4571 struct elfNN_ia64_local_hash_entry
*loc_h
;
4573 loc_h
= get_local_sym_hash (ia64_info
, input_bfd
, rel
, FALSE
);
4574 if (loc_h
&& ! loc_h
->sec_merge_done
)
4576 struct elfNN_ia64_dyn_sym_info
*dynent
;
4579 for (count
= loc_h
->count
, dynent
= loc_h
->info
;
4585 _bfd_merged_section_offset (output_bfd
, &msec
,
4586 elf_section_data (msec
)->
4590 dynent
->addend
-= sym
->st_value
;
4591 dynent
->addend
+= msec
->output_section
->vma
4592 + msec
->output_offset
4593 - sym_sec
->output_section
->vma
4594 - sym_sec
->output_offset
;
4597 /* We may have introduced duplicated entries. We need
4598 to remove them properly. */
4599 count
= sort_dyn_sym_info (loc_h
->info
, loc_h
->count
);
4600 if (count
!= loc_h
->count
)
4602 loc_h
->count
= count
;
4603 loc_h
->sorted_count
= count
;
4606 loc_h
->sec_merge_done
= 1;
4612 bfd_boolean unresolved_reloc
;
4614 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
4616 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
4617 r_symndx
, symtab_hdr
, sym_hashes
,
4619 unresolved_reloc
, warned
);
4621 if (h
->root
.type
== bfd_link_hash_undefweak
)
4622 undef_weak_ref
= TRUE
;
4627 /* For relocs against symbols from removed linkonce sections,
4628 or sections discarded by a linker script, we just want the
4629 section contents zeroed. Avoid any special processing. */
4630 if (sym_sec
!= NULL
&& elf_discarded_section (sym_sec
))
4632 _bfd_clear_contents (howto
, input_bfd
, contents
+ rel
->r_offset
);
4638 if (info
->relocatable
)
4641 hit_addr
= contents
+ rel
->r_offset
;
4642 value
+= rel
->r_addend
;
4643 dynamic_symbol_p
= elfNN_ia64_dynamic_symbol_p (h
, info
, r_type
);
4654 case R_IA64_DIR32MSB
:
4655 case R_IA64_DIR32LSB
:
4656 case R_IA64_DIR64MSB
:
4657 case R_IA64_DIR64LSB
:
4658 /* Install a dynamic relocation for this reloc. */
4659 if ((dynamic_symbol_p
|| info
->shared
)
4661 && (input_section
->flags
& SEC_ALLOC
) != 0)
4663 unsigned int dyn_r_type
;
4667 BFD_ASSERT (srel
!= NULL
);
4674 /* ??? People shouldn't be doing non-pic code in
4675 shared libraries nor dynamic executables. */
4676 (*_bfd_error_handler
)
4677 (_("%B: non-pic code with imm relocation against dynamic symbol `%s'"),
4679 h
? h
->root
.root
.string
4680 : bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4689 /* If we don't need dynamic symbol lookup, find a
4690 matching RELATIVE relocation. */
4691 dyn_r_type
= r_type
;
4692 if (dynamic_symbol_p
)
4694 dynindx
= h
->dynindx
;
4695 addend
= rel
->r_addend
;
4702 case R_IA64_DIR32MSB
:
4703 dyn_r_type
= R_IA64_REL32MSB
;
4705 case R_IA64_DIR32LSB
:
4706 dyn_r_type
= R_IA64_REL32LSB
;
4708 case R_IA64_DIR64MSB
:
4709 dyn_r_type
= R_IA64_REL64MSB
;
4711 case R_IA64_DIR64LSB
:
4712 dyn_r_type
= R_IA64_REL64LSB
;
4722 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4723 srel
, rel
->r_offset
, dyn_r_type
,
4728 case R_IA64_LTV32MSB
:
4729 case R_IA64_LTV32LSB
:
4730 case R_IA64_LTV64MSB
:
4731 case R_IA64_LTV64LSB
:
4732 r
= elfNN_ia64_install_value (hit_addr
, value
, r_type
);
4735 case R_IA64_GPREL22
:
4736 case R_IA64_GPREL64I
:
4737 case R_IA64_GPREL32MSB
:
4738 case R_IA64_GPREL32LSB
:
4739 case R_IA64_GPREL64MSB
:
4740 case R_IA64_GPREL64LSB
:
4741 if (dynamic_symbol_p
)
4743 (*_bfd_error_handler
)
4744 (_("%B: @gprel relocation against dynamic symbol %s"),
4746 h
? h
->root
.root
.string
4747 : bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
4753 r
= elfNN_ia64_install_value (hit_addr
, value
, r_type
);
4756 case R_IA64_LTOFF22
:
4757 case R_IA64_LTOFF22X
:
4758 case R_IA64_LTOFF64I
:
4759 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4760 value
= set_got_entry (input_bfd
, info
, dyn_i
, (h
? h
->dynindx
: -1),
4761 rel
->r_addend
, value
, R_IA64_DIRNNLSB
);
4763 r
= elfNN_ia64_install_value (hit_addr
, value
, r_type
);
4766 case R_IA64_PLTOFF22
:
4767 case R_IA64_PLTOFF64I
:
4768 case R_IA64_PLTOFF64MSB
:
4769 case R_IA64_PLTOFF64LSB
:
4770 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4771 value
= set_pltoff_entry (output_bfd
, info
, dyn_i
, value
, FALSE
);
4773 r
= elfNN_ia64_install_value (hit_addr
, value
, r_type
);
4776 case R_IA64_FPTR64I
:
4777 case R_IA64_FPTR32MSB
:
4778 case R_IA64_FPTR32LSB
:
4779 case R_IA64_FPTR64MSB
:
4780 case R_IA64_FPTR64LSB
:
4781 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4782 if (dyn_i
->want_fptr
)
4784 if (!undef_weak_ref
)
4785 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
4787 if (!dyn_i
->want_fptr
|| info
->pie
)
4790 unsigned int dyn_r_type
= r_type
;
4791 bfd_vma addend
= rel
->r_addend
;
4793 /* Otherwise, we expect the dynamic linker to create
4796 if (dyn_i
->want_fptr
)
4798 if (r_type
== R_IA64_FPTR64I
)
4800 /* We can't represent this without a dynamic symbol.
4801 Adjust the relocation to be against an output
4802 section symbol, which are always present in the
4803 dynamic symbol table. */
4804 /* ??? People shouldn't be doing non-pic code in
4805 shared libraries. Hork. */
4806 (*_bfd_error_handler
)
4807 (_("%B: linking non-pic code in a position independent executable"),
4814 dyn_r_type
= r_type
+ R_IA64_RELNNLSB
- R_IA64_FPTRNNLSB
;
4818 if (h
->dynindx
!= -1)
4819 dynindx
= h
->dynindx
;
4821 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4822 (info
, h
->root
.u
.def
.section
->owner
,
4823 global_sym_index (h
)));
4828 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4829 (info
, input_bfd
, (long) r_symndx
));
4833 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4834 srel
, rel
->r_offset
, dyn_r_type
,
4838 r
= elfNN_ia64_install_value (hit_addr
, value
, r_type
);
4841 case R_IA64_LTOFF_FPTR22
:
4842 case R_IA64_LTOFF_FPTR64I
:
4843 case R_IA64_LTOFF_FPTR32MSB
:
4844 case R_IA64_LTOFF_FPTR32LSB
:
4845 case R_IA64_LTOFF_FPTR64MSB
:
4846 case R_IA64_LTOFF_FPTR64LSB
:
4850 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
4851 if (dyn_i
->want_fptr
)
4853 BFD_ASSERT (h
== NULL
|| h
->dynindx
== -1);
4854 if (!undef_weak_ref
)
4855 value
= set_fptr_entry (output_bfd
, info
, dyn_i
, value
);
4860 /* Otherwise, we expect the dynamic linker to create
4864 if (h
->dynindx
!= -1)
4865 dynindx
= h
->dynindx
;
4867 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4868 (info
, h
->root
.u
.def
.section
->owner
,
4869 global_sym_index (h
)));
4872 dynindx
= (_bfd_elf_link_lookup_local_dynindx
4873 (info
, input_bfd
, (long) r_symndx
));
4877 value
= set_got_entry (output_bfd
, info
, dyn_i
, dynindx
,
4878 rel
->r_addend
, value
, R_IA64_FPTRNNLSB
);
4880 r
= elfNN_ia64_install_value (hit_addr
, value
, r_type
);
4884 case R_IA64_PCREL32MSB
:
4885 case R_IA64_PCREL32LSB
:
4886 case R_IA64_PCREL64MSB
:
4887 case R_IA64_PCREL64LSB
:
4888 /* Install a dynamic relocation for this reloc. */
4889 if (dynamic_symbol_p
&& r_symndx
!= 0)
4891 BFD_ASSERT (srel
!= NULL
);
4893 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
4894 srel
, rel
->r_offset
, r_type
,
4895 h
->dynindx
, rel
->r_addend
);
4899 case R_IA64_PCREL21B
:
4900 case R_IA64_PCREL60B
:
4901 /* We should have created a PLT entry for any dynamic symbol. */
4904 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, FALSE
);
4906 if (dyn_i
&& dyn_i
->want_plt2
)
4908 /* Should have caught this earlier. */
4909 BFD_ASSERT (rel
->r_addend
== 0);
4911 value
= (ia64_info
->root
.splt
->output_section
->vma
4912 + ia64_info
->root
.splt
->output_offset
4913 + dyn_i
->plt2_offset
);
4917 /* Since there's no PLT entry, Validate that this is
4919 BFD_ASSERT (undef_weak_ref
|| sym_sec
->output_section
!= NULL
);
4921 /* If the symbol is undef_weak, we shouldn't be trying
4922 to call it. There's every chance that we'd wind up
4923 with an out-of-range fixup here. Don't bother setting
4924 any value at all. */
4930 case R_IA64_PCREL21BI
:
4931 case R_IA64_PCREL21F
:
4932 case R_IA64_PCREL21M
:
4933 case R_IA64_PCREL22
:
4934 case R_IA64_PCREL64I
:
4935 /* The PCREL21BI reloc is specifically not intended for use with
4936 dynamic relocs. PCREL21F and PCREL21M are used for speculation
4937 fixup code, and thus probably ought not be dynamic. The
4938 PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs. */
4939 if (dynamic_symbol_p
)
4943 if (r_type
== R_IA64_PCREL21BI
)
4944 msg
= _("%B: @internal branch to dynamic symbol %s");
4945 else if (r_type
== R_IA64_PCREL21F
|| r_type
== R_IA64_PCREL21M
)
4946 msg
= _("%B: speculation fixup to dynamic symbol %s");
4948 msg
= _("%B: @pcrel relocation against dynamic symbol %s");
4949 (*_bfd_error_handler
) (msg
, input_bfd
,
4950 h
? h
->root
.root
.string
4951 : bfd_elf_sym_name (input_bfd
,
4961 /* Make pc-relative. */
4962 value
-= (input_section
->output_section
->vma
4963 + input_section
->output_offset
4964 + rel
->r_offset
) & ~ (bfd_vma
) 0x3;
4965 r
= elfNN_ia64_install_value (hit_addr
, value
, r_type
);
4968 case R_IA64_SEGREL32MSB
:
4969 case R_IA64_SEGREL32LSB
:
4970 case R_IA64_SEGREL64MSB
:
4971 case R_IA64_SEGREL64LSB
:
4973 /* Find the segment that contains the output_section. */
4974 Elf_Internal_Phdr
*p
= _bfd_elf_find_segment_containing_section
4975 (output_bfd
, input_section
->output_section
);
4979 r
= bfd_reloc_notsupported
;
4983 /* The VMA of the segment is the vaddr of the associated
4985 if (value
> p
->p_vaddr
)
4986 value
-= p
->p_vaddr
;
4989 r
= elfNN_ia64_install_value (hit_addr
, value
, r_type
);
4994 case R_IA64_SECREL32MSB
:
4995 case R_IA64_SECREL32LSB
:
4996 case R_IA64_SECREL64MSB
:
4997 case R_IA64_SECREL64LSB
:
4998 /* Make output-section relative to section where the symbol
4999 is defined. PR 475 */
5001 value
-= sym_sec
->output_section
->vma
;
5002 r
= elfNN_ia64_install_value (hit_addr
, value
, r_type
);
5005 case R_IA64_IPLTMSB
:
5006 case R_IA64_IPLTLSB
:
5007 /* Install a dynamic relocation for this reloc. */
5008 if ((dynamic_symbol_p
|| info
->shared
)
5009 && (input_section
->flags
& SEC_ALLOC
) != 0)
5011 BFD_ASSERT (srel
!= NULL
);
5013 /* If we don't need dynamic symbol lookup, install two
5014 RELATIVE relocations. */
5015 if (!dynamic_symbol_p
)
5017 unsigned int dyn_r_type
;
5019 if (r_type
== R_IA64_IPLTMSB
)
5020 dyn_r_type
= R_IA64_REL64MSB
;
5022 dyn_r_type
= R_IA64_REL64LSB
;
5024 elfNN_ia64_install_dyn_reloc (output_bfd
, info
,
5026 srel
, rel
->r_offset
,
5027 dyn_r_type
, 0, value
);
5028 elfNN_ia64_install_dyn_reloc (output_bfd
, info
,
5030 srel
, rel
->r_offset
+ 8,
5031 dyn_r_type
, 0, gp_val
);
5034 elfNN_ia64_install_dyn_reloc (output_bfd
, info
, input_section
,
5035 srel
, rel
->r_offset
, r_type
,
5036 h
->dynindx
, rel
->r_addend
);
5039 if (r_type
== R_IA64_IPLTMSB
)
5040 r_type
= R_IA64_DIR64MSB
;
5042 r_type
= R_IA64_DIR64LSB
;
5043 elfNN_ia64_install_value (hit_addr
, value
, r_type
);
5044 r
= elfNN_ia64_install_value (hit_addr
+ 8, gp_val
, r_type
);
5047 case R_IA64_TPREL14
:
5048 case R_IA64_TPREL22
:
5049 case R_IA64_TPREL64I
:
5050 if (elf_hash_table (info
)->tls_sec
== NULL
)
5051 goto missing_tls_sec
;
5052 value
-= elfNN_ia64_tprel_base (info
);
5053 r
= elfNN_ia64_install_value (hit_addr
, value
, r_type
);
5056 case R_IA64_DTPREL14
:
5057 case R_IA64_DTPREL22
:
5058 case R_IA64_DTPREL64I
:
5059 case R_IA64_DTPREL32LSB
:
5060 case R_IA64_DTPREL32MSB
:
5061 case R_IA64_DTPREL64LSB
:
5062 case R_IA64_DTPREL64MSB
:
5063 if (elf_hash_table (info
)->tls_sec
== NULL
)
5064 goto missing_tls_sec
;
5065 value
-= elfNN_ia64_dtprel_base (info
);
5066 r
= elfNN_ia64_install_value (hit_addr
, value
, r_type
);
5069 case R_IA64_LTOFF_TPREL22
:
5070 case R_IA64_LTOFF_DTPMOD22
:
5071 case R_IA64_LTOFF_DTPREL22
:
5074 long dynindx
= h
? h
->dynindx
: -1;
5075 bfd_vma r_addend
= rel
->r_addend
;
5080 case R_IA64_LTOFF_TPREL22
:
5081 if (!dynamic_symbol_p
)
5083 if (elf_hash_table (info
)->tls_sec
== NULL
)
5084 goto missing_tls_sec
;
5086 value
-= elfNN_ia64_tprel_base (info
);
5089 r_addend
+= value
- elfNN_ia64_dtprel_base (info
);
5093 got_r_type
= R_IA64_TPREL64LSB
;
5095 case R_IA64_LTOFF_DTPMOD22
:
5096 if (!dynamic_symbol_p
&& !info
->shared
)
5098 got_r_type
= R_IA64_DTPMOD64LSB
;
5100 case R_IA64_LTOFF_DTPREL22
:
5101 if (!dynamic_symbol_p
)
5103 if (elf_hash_table (info
)->tls_sec
== NULL
)
5104 goto missing_tls_sec
;
5105 value
-= elfNN_ia64_dtprel_base (info
);
5107 got_r_type
= R_IA64_DTPRELNNLSB
;
5110 dyn_i
= get_dyn_sym_info (ia64_info
, h
, input_bfd
, rel
, FALSE
);
5111 value
= set_got_entry (input_bfd
, info
, dyn_i
, dynindx
, r_addend
,
5114 r
= elfNN_ia64_install_value (hit_addr
, value
, r_type
);
5119 r
= bfd_reloc_notsupported
;
5128 case bfd_reloc_undefined
:
5129 /* This can happen for global table relative relocs if
5130 __gp is undefined. This is a panic situation so we
5131 don't try to continue. */
5132 (*info
->callbacks
->undefined_symbol
)
5133 (info
, "__gp", input_bfd
, input_section
, rel
->r_offset
, 1);
5136 case bfd_reloc_notsupported
:
5141 name
= h
->root
.root
.string
;
5143 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
5145 if (!(*info
->callbacks
->warning
) (info
, _("unsupported reloc"),
5147 input_section
, rel
->r_offset
))
5153 case bfd_reloc_dangerous
:
5154 case bfd_reloc_outofrange
:
5155 case bfd_reloc_overflow
:
5162 name
= h
->root
.root
.string
;
5164 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
,
5169 case R_IA64_TPREL14
:
5170 case R_IA64_TPREL22
:
5171 case R_IA64_TPREL64I
:
5172 case R_IA64_DTPREL14
:
5173 case R_IA64_DTPREL22
:
5174 case R_IA64_DTPREL64I
:
5175 case R_IA64_DTPREL32LSB
:
5176 case R_IA64_DTPREL32MSB
:
5177 case R_IA64_DTPREL64LSB
:
5178 case R_IA64_DTPREL64MSB
:
5179 case R_IA64_LTOFF_TPREL22
:
5180 case R_IA64_LTOFF_DTPMOD22
:
5181 case R_IA64_LTOFF_DTPREL22
:
5182 (*_bfd_error_handler
)
5183 (_("%B: missing TLS section for relocation %s against `%s' at 0x%lx in section `%A'."),
5184 input_bfd
, input_section
, howto
->name
, name
,
5188 case R_IA64_PCREL21B
:
5189 case R_IA64_PCREL21BI
:
5190 case R_IA64_PCREL21M
:
5191 case R_IA64_PCREL21F
:
5192 if (is_elf_hash_table (info
->hash
))
5194 /* Relaxtion is always performed for ELF output.
5195 Overflow failures for those relocations mean
5196 that the section is too big to relax. */
5197 (*_bfd_error_handler
)
5198 (_("%B: Can't relax br (%s) to `%s' at 0x%lx in section `%A' with size 0x%lx (> 0x1000000)."),
5199 input_bfd
, input_section
, howto
->name
, name
,
5200 rel
->r_offset
, input_section
->size
);
5204 if (!(*info
->callbacks
->reloc_overflow
) (info
,
5226 elfNN_ia64_finish_dynamic_symbol (bfd
*output_bfd
,
5227 struct bfd_link_info
*info
,
5228 struct elf_link_hash_entry
*h
,
5229 Elf_Internal_Sym
*sym
)
5231 struct elfNN_ia64_link_hash_table
*ia64_info
;
5232 struct elfNN_ia64_dyn_sym_info
*dyn_i
;
5234 ia64_info
= elfNN_ia64_hash_table (info
);
5235 dyn_i
= get_dyn_sym_info (ia64_info
, h
, NULL
, NULL
, FALSE
);
5237 /* Fill in the PLT data, if required. */
5238 if (dyn_i
&& dyn_i
->want_plt
)
5240 Elf_Internal_Rela outrel
;
5243 bfd_vma plt_addr
, pltoff_addr
, gp_val
, index
;
5245 gp_val
= _bfd_get_gp_value (output_bfd
);
5247 /* Initialize the minimal PLT entry. */
5249 index
= (dyn_i
->plt_offset
- PLT_HEADER_SIZE
) / PLT_MIN_ENTRY_SIZE
;
5250 plt_sec
= ia64_info
->root
.splt
;
5251 loc
= plt_sec
->contents
+ dyn_i
->plt_offset
;
5253 memcpy (loc
, plt_min_entry
, PLT_MIN_ENTRY_SIZE
);
5254 elfNN_ia64_install_value (loc
, index
, R_IA64_IMM22
);
5255 elfNN_ia64_install_value (loc
+2, -dyn_i
->plt_offset
, R_IA64_PCREL21B
);
5257 plt_addr
= (plt_sec
->output_section
->vma
5258 + plt_sec
->output_offset
5259 + dyn_i
->plt_offset
);
5260 pltoff_addr
= set_pltoff_entry (output_bfd
, info
, dyn_i
, plt_addr
, TRUE
);
5262 /* Initialize the FULL PLT entry, if needed. */
5263 if (dyn_i
->want_plt2
)
5265 loc
= plt_sec
->contents
+ dyn_i
->plt2_offset
;
5267 memcpy (loc
, plt_full_entry
, PLT_FULL_ENTRY_SIZE
);
5268 elfNN_ia64_install_value (loc
, pltoff_addr
- gp_val
, R_IA64_IMM22
);
5270 /* Mark the symbol as undefined, rather than as defined in the
5271 plt section. Leave the value alone. */
5272 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
5273 first place. But perhaps elflink.c did some for us. */
5274 if (!h
->def_regular
)
5275 sym
->st_shndx
= SHN_UNDEF
;
5278 /* Create the dynamic relocation. */
5279 outrel
.r_offset
= pltoff_addr
;
5280 if (bfd_little_endian (output_bfd
))
5281 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_IA64_IPLTLSB
);
5283 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_IA64_IPLTMSB
);
5284 outrel
.r_addend
= 0;
5286 /* This is fun. In the .IA_64.pltoff section, we've got entries
5287 that correspond both to real PLT entries, and those that
5288 happened to resolve to local symbols but need to be created
5289 to satisfy @pltoff relocations. The .rela.IA_64.pltoff
5290 relocations for the real PLT should come at the end of the
5291 section, so that they can be indexed by plt entry at runtime.
5293 We emitted all of the relocations for the non-PLT @pltoff
5294 entries during relocate_section. So we can consider the
5295 existing sec->reloc_count to be the base of the array of
5298 loc
= ia64_info
->rel_pltoff_sec
->contents
;
5299 loc
+= ((ia64_info
->rel_pltoff_sec
->reloc_count
+ index
)
5300 * sizeof (ElfNN_External_Rela
));
5301 bfd_elfNN_swap_reloca_out (output_bfd
, &outrel
, loc
);
5304 /* Mark some specially defined symbols as absolute. */
5305 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
5306 || h
== ia64_info
->root
.hgot
5307 || h
== ia64_info
->root
.hplt
)
5308 sym
->st_shndx
= SHN_ABS
;
5314 elfNN_ia64_finish_dynamic_sections (bfd
*abfd
,
5315 struct bfd_link_info
*info
)
5317 struct elfNN_ia64_link_hash_table
*ia64_info
;
5320 ia64_info
= elfNN_ia64_hash_table (info
);
5321 dynobj
= ia64_info
->root
.dynobj
;
5323 if (elf_hash_table (info
)->dynamic_sections_created
)
5325 ElfNN_External_Dyn
*dyncon
, *dynconend
;
5326 asection
*sdyn
, *sgotplt
;
5329 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
5330 sgotplt
= bfd_get_section_by_name (dynobj
, ".got.plt");
5331 BFD_ASSERT (sdyn
!= NULL
);
5332 dyncon
= (ElfNN_External_Dyn
*) sdyn
->contents
;
5333 dynconend
= (ElfNN_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
5335 gp_val
= _bfd_get_gp_value (abfd
);
5337 for (; dyncon
< dynconend
; dyncon
++)
5339 Elf_Internal_Dyn dyn
;
5341 bfd_elfNN_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5346 dyn
.d_un
.d_ptr
= gp_val
;
5350 dyn
.d_un
.d_val
= (ia64_info
->minplt_entries
5351 * sizeof (ElfNN_External_Rela
));
5355 /* See the comment above in finish_dynamic_symbol. */
5356 dyn
.d_un
.d_ptr
= (ia64_info
->rel_pltoff_sec
->output_section
->vma
5357 + ia64_info
->rel_pltoff_sec
->output_offset
5358 + (ia64_info
->rel_pltoff_sec
->reloc_count
5359 * sizeof (ElfNN_External_Rela
)));
5362 case DT_IA_64_PLT_RESERVE
:
5363 dyn
.d_un
.d_ptr
= (sgotplt
->output_section
->vma
5364 + sgotplt
->output_offset
);
5368 /* Do not have RELASZ include JMPREL. This makes things
5369 easier on ld.so. This is not what the rest of BFD set up. */
5370 dyn
.d_un
.d_val
-= (ia64_info
->minplt_entries
5371 * sizeof (ElfNN_External_Rela
));
5375 bfd_elfNN_swap_dyn_out (abfd
, &dyn
, dyncon
);
5378 /* Initialize the PLT0 entry. */
5379 if (ia64_info
->root
.splt
)
5381 bfd_byte
*loc
= ia64_info
->root
.splt
->contents
;
5384 memcpy (loc
, plt_header
, PLT_HEADER_SIZE
);
5386 pltres
= (sgotplt
->output_section
->vma
5387 + sgotplt
->output_offset
5390 elfNN_ia64_install_value (loc
+1, pltres
, R_IA64_GPREL22
);
5397 /* ELF file flag handling: */
5399 /* Function to keep IA-64 specific file flags. */
5401 elfNN_ia64_set_private_flags (bfd
*abfd
, flagword flags
)
5403 BFD_ASSERT (!elf_flags_init (abfd
)
5404 || elf_elfheader (abfd
)->e_flags
== flags
);
5406 elf_elfheader (abfd
)->e_flags
= flags
;
5407 elf_flags_init (abfd
) = TRUE
;
5411 /* Merge backend specific data from an object file to the output
5412 object file when linking. */
5414 elfNN_ia64_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
5418 bfd_boolean ok
= TRUE
;
5420 /* Don't even pretend to support mixed-format linking. */
5421 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
5422 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
5425 in_flags
= elf_elfheader (ibfd
)->e_flags
;
5426 out_flags
= elf_elfheader (obfd
)->e_flags
;
5428 if (! elf_flags_init (obfd
))
5430 elf_flags_init (obfd
) = TRUE
;
5431 elf_elfheader (obfd
)->e_flags
= in_flags
;
5433 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
5434 && bfd_get_arch_info (obfd
)->the_default
)
5436 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
5437 bfd_get_mach (ibfd
));
5443 /* Check flag compatibility. */
5444 if (in_flags
== out_flags
)
5447 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
5448 if (!(in_flags
& EF_IA_64_REDUCEDFP
) && (out_flags
& EF_IA_64_REDUCEDFP
))
5449 elf_elfheader (obfd
)->e_flags
&= ~EF_IA_64_REDUCEDFP
;
5451 if ((in_flags
& EF_IA_64_TRAPNIL
) != (out_flags
& EF_IA_64_TRAPNIL
))
5453 (*_bfd_error_handler
)
5454 (_("%B: linking trap-on-NULL-dereference with non-trapping files"),
5457 bfd_set_error (bfd_error_bad_value
);
5460 if ((in_flags
& EF_IA_64_BE
) != (out_flags
& EF_IA_64_BE
))
5462 (*_bfd_error_handler
)
5463 (_("%B: linking big-endian files with little-endian files"),
5466 bfd_set_error (bfd_error_bad_value
);
5469 if ((in_flags
& EF_IA_64_ABI64
) != (out_flags
& EF_IA_64_ABI64
))
5471 (*_bfd_error_handler
)
5472 (_("%B: linking 64-bit files with 32-bit files"),
5475 bfd_set_error (bfd_error_bad_value
);
5478 if ((in_flags
& EF_IA_64_CONS_GP
) != (out_flags
& EF_IA_64_CONS_GP
))
5480 (*_bfd_error_handler
)
5481 (_("%B: linking constant-gp files with non-constant-gp files"),
5484 bfd_set_error (bfd_error_bad_value
);
5487 if ((in_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
)
5488 != (out_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
5490 (*_bfd_error_handler
)
5491 (_("%B: linking auto-pic files with non-auto-pic files"),
5494 bfd_set_error (bfd_error_bad_value
);
5502 elfNN_ia64_print_private_bfd_data (bfd
*abfd
, PTR ptr
)
5504 FILE *file
= (FILE *) ptr
;
5505 flagword flags
= elf_elfheader (abfd
)->e_flags
;
5507 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
5509 fprintf (file
, "private flags = %s%s%s%s%s%s%s%s\n",
5510 (flags
& EF_IA_64_TRAPNIL
) ? "TRAPNIL, " : "",
5511 (flags
& EF_IA_64_EXT
) ? "EXT, " : "",
5512 (flags
& EF_IA_64_BE
) ? "BE, " : "LE, ",
5513 (flags
& EF_IA_64_REDUCEDFP
) ? "REDUCEDFP, " : "",
5514 (flags
& EF_IA_64_CONS_GP
) ? "CONS_GP, " : "",
5515 (flags
& EF_IA_64_NOFUNCDESC_CONS_GP
) ? "NOFUNCDESC_CONS_GP, " : "",
5516 (flags
& EF_IA_64_ABSOLUTE
) ? "ABSOLUTE, " : "",
5517 (flags
& EF_IA_64_ABI64
) ? "ABI64" : "ABI32");
5519 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
5523 static enum elf_reloc_type_class
5524 elfNN_ia64_reloc_type_class (const Elf_Internal_Rela
*rela
)
5526 switch ((int) ELFNN_R_TYPE (rela
->r_info
))
5528 case R_IA64_REL32MSB
:
5529 case R_IA64_REL32LSB
:
5530 case R_IA64_REL64MSB
:
5531 case R_IA64_REL64LSB
:
5532 return reloc_class_relative
;
5533 case R_IA64_IPLTMSB
:
5534 case R_IA64_IPLTLSB
:
5535 return reloc_class_plt
;
5537 return reloc_class_copy
;
5539 return reloc_class_normal
;
5543 static const struct bfd_elf_special_section elfNN_ia64_special_sections
[] =
5545 { STRING_COMMA_LEN (".sbss"), -1, SHT_NOBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_IA_64_SHORT
},
5546 { STRING_COMMA_LEN (".sdata"), -1, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
+ SHF_IA_64_SHORT
},
5547 { NULL
, 0, 0, 0, 0 }
5551 elfNN_ia64_object_p (bfd
*abfd
)
5554 asection
*group
, *unwi
, *unw
;
5557 char *unwi_name
, *unw_name
;
5560 if (abfd
->flags
& DYNAMIC
)
5563 /* Flags for fake group section. */
5564 flags
= (SEC_LINKER_CREATED
| SEC_GROUP
| SEC_LINK_ONCE
5567 /* We add a fake section group for each .gnu.linkonce.t.* section,
5568 which isn't in a section group, and its unwind sections. */
5569 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
5571 if (elf_sec_group (sec
) == NULL
5572 && ((sec
->flags
& (SEC_LINK_ONCE
| SEC_CODE
| SEC_GROUP
))
5573 == (SEC_LINK_ONCE
| SEC_CODE
))
5574 && CONST_STRNEQ (sec
->name
, ".gnu.linkonce.t."))
5576 name
= sec
->name
+ 16;
5578 amt
= strlen (name
) + sizeof (".gnu.linkonce.ia64unwi.");
5579 unwi_name
= bfd_alloc (abfd
, amt
);
5583 strcpy (stpcpy (unwi_name
, ".gnu.linkonce.ia64unwi."), name
);
5584 unwi
= bfd_get_section_by_name (abfd
, unwi_name
);
5586 amt
= strlen (name
) + sizeof (".gnu.linkonce.ia64unw.");
5587 unw_name
= bfd_alloc (abfd
, amt
);
5591 strcpy (stpcpy (unw_name
, ".gnu.linkonce.ia64unw."), name
);
5592 unw
= bfd_get_section_by_name (abfd
, unw_name
);
5594 /* We need to create a fake group section for it and its
5596 group
= bfd_make_section_anyway_with_flags (abfd
, name
,
5601 /* Move the fake group section to the beginning. */
5602 bfd_section_list_remove (abfd
, group
);
5603 bfd_section_list_prepend (abfd
, group
);
5605 elf_next_in_group (group
) = sec
;
5607 elf_group_name (sec
) = name
;
5608 elf_next_in_group (sec
) = sec
;
5609 elf_sec_group (sec
) = group
;
5613 elf_group_name (unwi
) = name
;
5614 elf_next_in_group (unwi
) = sec
;
5615 elf_next_in_group (sec
) = unwi
;
5616 elf_sec_group (unwi
) = group
;
5621 elf_group_name (unw
) = name
;
5624 elf_next_in_group (unw
) = elf_next_in_group (unwi
);
5625 elf_next_in_group (unwi
) = unw
;
5629 elf_next_in_group (unw
) = sec
;
5630 elf_next_in_group (sec
) = unw
;
5632 elf_sec_group (unw
) = group
;
5635 /* Fake SHT_GROUP section header. */
5636 elf_section_data (group
)->this_hdr
.bfd_section
= group
;
5637 elf_section_data (group
)->this_hdr
.sh_type
= SHT_GROUP
;
5644 elfNN_ia64_hpux_vec (const bfd_target
*vec
)
5646 extern const bfd_target bfd_elfNN_ia64_hpux_big_vec
;
5647 return (vec
== & bfd_elfNN_ia64_hpux_big_vec
);
5651 elfNN_hpux_post_process_headers (bfd
*abfd
,
5652 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
5654 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
5656 i_ehdrp
->e_ident
[EI_OSABI
] = get_elf_backend_data (abfd
)->elf_osabi
;
5657 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 1;
5661 elfNN_hpux_backend_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
5662 asection
*sec
, int *retval
)
5664 if (bfd_is_com_section (sec
))
5666 *retval
= SHN_IA_64_ANSI_COMMON
;
5673 elfNN_hpux_backend_symbol_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
5676 elf_symbol_type
*elfsym
= (elf_symbol_type
*) asym
;
5678 switch (elfsym
->internal_elf_sym
.st_shndx
)
5680 case SHN_IA_64_ANSI_COMMON
:
5681 asym
->section
= bfd_com_section_ptr
;
5682 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
5683 asym
->flags
&= ~BSF_GLOBAL
;
5689 elfNN_vms_section_from_shdr (bfd
*abfd
,
5690 Elf_Internal_Shdr
*hdr
,
5696 switch (hdr
->sh_type
)
5698 case SHT_IA_64_VMS_TRACE
:
5699 case SHT_IA_64_VMS_DEBUG
:
5700 case SHT_IA_64_VMS_DEBUG_STR
:
5704 return elfNN_ia64_section_from_shdr (abfd
, hdr
, name
, shindex
);
5707 if (! _bfd_elf_make_section_from_shdr (abfd
, hdr
, name
, shindex
))
5709 newsect
= hdr
->bfd_section
;
5715 elfNN_vms_object_p (bfd
*abfd
)
5717 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
5718 Elf_Internal_Phdr
*i_phdr
= elf_tdata (abfd
)->phdr
;
5720 unsigned int num_text
= 0;
5721 unsigned int num_data
= 0;
5722 unsigned int num_rodata
= 0;
5725 if (!elfNN_ia64_object_p (abfd
))
5728 for (i
= 0; i
< i_ehdrp
->e_phnum
; i
++, i_phdr
++)
5730 /* Is there a section for this segment? */
5731 bfd_vma base_vma
= i_phdr
->p_vaddr
;
5732 bfd_vma limit_vma
= base_vma
+ i_phdr
->p_filesz
;
5734 if (i_phdr
->p_type
!= PT_LOAD
)
5738 while (base_vma
< limit_vma
)
5740 bfd_vma next_vma
= limit_vma
;
5746 /* Find a section covering base_vma. */
5747 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
5749 if ((sec
->flags
& (SEC_ALLOC
| SEC_LOAD
)) == 0)
5751 if (sec
->vma
<= base_vma
&& sec
->vma
+ sec
->size
> base_vma
)
5753 base_vma
= sec
->vma
+ sec
->size
;
5756 if (sec
->vma
< next_vma
&& sec
->vma
+ sec
->size
>= base_vma
)
5757 next_vma
= sec
->vma
;
5760 /* No section covering [base_vma; next_vma). Create a fake one. */
5761 flags
= SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
;
5762 if (i_phdr
->p_flags
& PF_X
)
5765 if (num_text
++ == 0)
5768 sprintf (name
, ".text$%u", num_text
);
5770 else if ((i_phdr
->p_flags
& (PF_R
| PF_W
)) == PF_R
)
5772 flags
|= SEC_READONLY
;
5773 sprintf (name
, ".rodata$%u", num_rodata
++);
5778 sprintf (name
, ".data$%u", num_data
++);
5781 /* Allocate name. */
5784 size_t name_len
= strlen (name
) + 1;
5785 nname
= bfd_alloc (abfd
, name_len
);
5788 memcpy (nname
, name
, name_len
);
5791 /* Create and fill new section. */
5792 nsec
= bfd_make_section_anyway_with_flags (abfd
, nname
, flags
);
5795 nsec
->vma
= base_vma
;
5796 nsec
->size
= next_vma
- base_vma
;
5797 nsec
->filepos
= i_phdr
->p_offset
+ (base_vma
- i_phdr
->p_vaddr
);
5799 base_vma
= next_vma
;
5806 elfNN_vms_post_process_headers (bfd
*abfd
,
5807 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
5809 Elf_Internal_Ehdr
*i_ehdrp
= elf_elfheader (abfd
);
5811 i_ehdrp
->e_ident
[EI_OSABI
] = ELFOSABI_OPENVMS
;
5812 i_ehdrp
->e_ident
[EI_ABIVERSION
] = 2;
5816 elfNN_vms_section_processing (bfd
*abfd ATTRIBUTE_UNUSED
,
5817 Elf_Internal_Shdr
*hdr
)
5819 if (hdr
->bfd_section
!= NULL
)
5821 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
5823 if (strcmp (name
, ".text") == 0)
5824 hdr
->sh_flags
|= SHF_IA_64_VMS_SHARED
;
5825 else if ((strcmp (name
, ".debug") == 0)
5826 || (strcmp (name
, ".debug_abbrev") == 0)
5827 || (strcmp (name
, ".debug_aranges") == 0)
5828 || (strcmp (name
, ".debug_frame") == 0)
5829 || (strcmp (name
, ".debug_info") == 0)
5830 || (strcmp (name
, ".debug_loc") == 0)
5831 || (strcmp (name
, ".debug_macinfo") == 0)
5832 || (strcmp (name
, ".debug_pubnames") == 0)
5833 || (strcmp (name
, ".debug_pubtypes") == 0))
5834 hdr
->sh_type
= SHT_IA_64_VMS_DEBUG
;
5835 else if ((strcmp (name
, ".debug_line") == 0)
5836 || (strcmp (name
, ".debug_ranges") == 0))
5837 hdr
->sh_type
= SHT_IA_64_VMS_TRACE
;
5838 else if (strcmp (name
, ".debug_str") == 0)
5839 hdr
->sh_type
= SHT_IA_64_VMS_DEBUG_STR
;
5840 else if (strcmp (name
, ".vms_display_name_info") == 0)
5844 struct elf_obj_tdata
*t
= elf_tdata (abfd
);
5846 int demangler_sym_idx
= -1;
5848 symcount
= bfd_get_symcount (abfd
);
5849 syms
= bfd_get_outsymbols (abfd
);
5850 for (idx
= 0; idx
< symcount
; idx
++)
5854 if ((sym
->flags
& (BSF_DEBUGGING
| BSF_DYNAMIC
))
5855 && strchr (sym
->name
, '@')
5856 && (strcmp (sym
->section
->name
, BFD_ABS_SECTION_NAME
) == 0))
5858 demangler_sym_idx
= sym
->udata
.i
;
5863 hdr
->sh_type
= SHT_IA_64_VMS_DISPLAY_NAME_INFO
;
5864 hdr
->sh_entsize
= 4;
5865 hdr
->sh_addralign
= 0;
5866 hdr
->sh_link
= t
->symtab_section
;
5868 /* Find symtab index of demangler routine and stuff it in
5869 the second long word of section data. */
5871 if (demangler_sym_idx
> -1)
5873 bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
);
5874 bfd_bread (buf
, hdr
->sh_size
, abfd
);
5875 buf
[1] = demangler_sym_idx
;
5876 bfd_seek (abfd
, hdr
->sh_offset
, SEEK_SET
);
5877 bfd_bwrite (buf
, hdr
->sh_size
, abfd
);
5885 /* The final processing done just before writing out a VMS IA-64 ELF
5889 elfNN_vms_final_write_processing (bfd
*abfd
,
5890 bfd_boolean linker ATTRIBUTE_UNUSED
)
5892 Elf_Internal_Shdr
*hdr
;
5894 int unwind_info_sect_idx
= 0;
5896 for (s
= abfd
->sections
; s
; s
= s
->next
)
5898 hdr
= &elf_section_data (s
)->this_hdr
;
5900 if (strcmp (bfd_get_section_name (abfd
, hdr
->bfd_section
),
5901 ".IA_64.unwind_info") == 0)
5902 unwind_info_sect_idx
= elf_section_data (s
)->this_idx
;
5904 switch (hdr
->sh_type
)
5906 case SHT_IA_64_UNWIND
:
5907 /* VMS requires sh_info to point to the unwind info section. */
5908 hdr
->sh_info
= unwind_info_sect_idx
;
5913 if (! elf_flags_init (abfd
))
5915 unsigned long flags
= 0;
5917 if (abfd
->xvec
->byteorder
== BFD_ENDIAN_BIG
)
5918 flags
|= EF_IA_64_BE
;
5919 if (bfd_get_mach (abfd
) == bfd_mach_ia64_elf64
)
5920 flags
|= EF_IA_64_ABI64
;
5922 elf_elfheader(abfd
)->e_flags
= flags
;
5923 elf_flags_init (abfd
) = TRUE
;
5928 elfNN_vms_close_and_cleanup (bfd
*abfd
)
5930 if (bfd_get_format (abfd
) == bfd_object
)
5934 if (elf_shstrtab (abfd
) != NULL
)
5935 _bfd_elf_strtab_free (elf_shstrtab (abfd
));
5937 /* Pad to 8 byte boundary for IPF/VMS. */
5938 isize
= bfd_get_size (abfd
);
5939 if ((irsize
= isize
/8*8) < isize
)
5941 int ishort
= (irsize
+ 8) - isize
;
5942 bfd_seek (abfd
, isize
, SEEK_SET
);
5943 bfd_bwrite (bfd_zmalloc (ishort
), ishort
, abfd
);
5947 return _bfd_generic_close_and_cleanup (abfd
);
5950 #define TARGET_LITTLE_SYM bfd_elfNN_ia64_little_vec
5951 #define TARGET_LITTLE_NAME "elfNN-ia64-little"
5952 #define TARGET_BIG_SYM bfd_elfNN_ia64_big_vec
5953 #define TARGET_BIG_NAME "elfNN-ia64-big"
5954 #define ELF_ARCH bfd_arch_ia64
5955 #define ELF_MACHINE_CODE EM_IA_64
5956 #define ELF_MACHINE_ALT1 1999 /* EAS2.3 */
5957 #define ELF_MACHINE_ALT2 1998 /* EAS2.2 */
5958 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
5959 #define ELF_COMMONPAGESIZE 0x4000 /* 16KB */
5961 #define elf_backend_section_from_shdr \
5962 elfNN_ia64_section_from_shdr
5963 #define elf_backend_section_flags \
5964 elfNN_ia64_section_flags
5965 #define elf_backend_fake_sections \
5966 elfNN_ia64_fake_sections
5967 #define elf_backend_final_write_processing \
5968 elfNN_ia64_final_write_processing
5969 #define elf_backend_add_symbol_hook \
5970 elfNN_ia64_add_symbol_hook
5971 #define elf_backend_additional_program_headers \
5972 elfNN_ia64_additional_program_headers
5973 #define elf_backend_modify_segment_map \
5974 elfNN_ia64_modify_segment_map
5975 #define elf_backend_modify_program_headers \
5976 elfNN_ia64_modify_program_headers
5977 #define elf_info_to_howto \
5978 elfNN_ia64_info_to_howto
5980 #define bfd_elfNN_bfd_reloc_type_lookup \
5981 elfNN_ia64_reloc_type_lookup
5982 #define bfd_elfNN_bfd_reloc_name_lookup \
5983 elfNN_ia64_reloc_name_lookup
5984 #define bfd_elfNN_bfd_is_local_label_name \
5985 elfNN_ia64_is_local_label_name
5986 #define bfd_elfNN_bfd_relax_section \
5987 elfNN_ia64_relax_section
5989 #define elf_backend_object_p \
5992 /* Stuff for the BFD linker: */
5993 #define bfd_elfNN_bfd_link_hash_table_create \
5994 elfNN_ia64_hash_table_create
5995 #define bfd_elfNN_bfd_link_hash_table_free \
5996 elfNN_ia64_hash_table_free
5997 #define elf_backend_create_dynamic_sections \
5998 elfNN_ia64_create_dynamic_sections
5999 #define elf_backend_check_relocs \
6000 elfNN_ia64_check_relocs
6001 #define elf_backend_adjust_dynamic_symbol \
6002 elfNN_ia64_adjust_dynamic_symbol
6003 #define elf_backend_size_dynamic_sections \
6004 elfNN_ia64_size_dynamic_sections
6005 #define elf_backend_omit_section_dynsym \
6006 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
6007 #define elf_backend_relocate_section \
6008 elfNN_ia64_relocate_section
6009 #define elf_backend_finish_dynamic_symbol \
6010 elfNN_ia64_finish_dynamic_symbol
6011 #define elf_backend_finish_dynamic_sections \
6012 elfNN_ia64_finish_dynamic_sections
6013 #define bfd_elfNN_bfd_final_link \
6014 elfNN_ia64_final_link
6016 #define bfd_elfNN_bfd_merge_private_bfd_data \
6017 elfNN_ia64_merge_private_bfd_data
6018 #define bfd_elfNN_bfd_set_private_flags \
6019 elfNN_ia64_set_private_flags
6020 #define bfd_elfNN_bfd_print_private_bfd_data \
6021 elfNN_ia64_print_private_bfd_data
6023 #define elf_backend_plt_readonly 1
6024 #define elf_backend_want_plt_sym 0
6025 #define elf_backend_plt_alignment 5
6026 #define elf_backend_got_header_size 0
6027 #define elf_backend_want_got_plt 1
6028 #define elf_backend_may_use_rel_p 1
6029 #define elf_backend_may_use_rela_p 1
6030 #define elf_backend_default_use_rela_p 1
6031 #define elf_backend_want_dynbss 0
6032 #define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect
6033 #define elf_backend_hide_symbol elfNN_ia64_hash_hide_symbol
6034 #define elf_backend_fixup_symbol _bfd_elf_link_hash_fixup_symbol
6035 #define elf_backend_reloc_type_class elfNN_ia64_reloc_type_class
6036 #define elf_backend_rela_normal 1
6037 #define elf_backend_special_sections elfNN_ia64_special_sections
6038 #define elf_backend_default_execstack 0
6040 /* FIXME: PR 290: The Intel C compiler generates SHT_IA_64_UNWIND with
6041 SHF_LINK_ORDER. But it doesn't set the sh_link or sh_info fields.
6042 We don't want to flood users with so many error messages. We turn
6043 off the warning for now. It will be turned on later when the Intel
6044 compiler is fixed. */
6045 #define elf_backend_link_order_error_handler NULL
6047 #include "elfNN-target.h"
6049 /* HPUX-specific vectors. */
6051 #undef TARGET_LITTLE_SYM
6052 #undef TARGET_LITTLE_NAME
6053 #undef TARGET_BIG_SYM
6054 #define TARGET_BIG_SYM bfd_elfNN_ia64_hpux_big_vec
6055 #undef TARGET_BIG_NAME
6056 #define TARGET_BIG_NAME "elfNN-ia64-hpux-big"
6058 /* These are HP-UX specific functions. */
6060 #undef elf_backend_post_process_headers
6061 #define elf_backend_post_process_headers elfNN_hpux_post_process_headers
6063 #undef elf_backend_section_from_bfd_section
6064 #define elf_backend_section_from_bfd_section elfNN_hpux_backend_section_from_bfd_section
6066 #undef elf_backend_symbol_processing
6067 #define elf_backend_symbol_processing elfNN_hpux_backend_symbol_processing
6069 #undef elf_backend_want_p_paddr_set_to_zero
6070 #define elf_backend_want_p_paddr_set_to_zero 1
6072 #undef ELF_COMMONPAGESIZE
6074 #define ELF_OSABI ELFOSABI_HPUX
6077 #define elfNN_bed elfNN_ia64_hpux_bed
6079 #include "elfNN-target.h"
6081 /* VMS-specific vectors. */
6083 #undef TARGET_LITTLE_SYM
6084 #define TARGET_LITTLE_SYM bfd_elfNN_ia64_vms_vec
6085 #undef TARGET_LITTLE_NAME
6086 #define TARGET_LITTLE_NAME "elfNN-ia64-vms"
6087 #undef TARGET_BIG_SYM
6088 #undef TARGET_BIG_NAME
6090 /* These are VMS specific functions. */
6092 #undef elf_backend_object_p
6093 #define elf_backend_object_p elfNN_vms_object_p
6095 #undef elf_backend_section_from_shdr
6096 #define elf_backend_section_from_shdr elfNN_vms_section_from_shdr
6098 #undef elf_backend_post_process_headers
6099 #define elf_backend_post_process_headers elfNN_vms_post_process_headers
6101 #undef elf_backend_section_processing
6102 #define elf_backend_section_processing elfNN_vms_section_processing
6104 #undef elf_backend_final_write_processing
6105 #define elf_backend_final_write_processing elfNN_vms_final_write_processing
6107 #undef bfd_elfNN_close_and_cleanup
6108 #define bfd_elfNN_close_and_cleanup elfNN_vms_close_and_cleanup
6110 #undef elf_backend_section_from_bfd_section
6112 #undef elf_backend_symbol_processing
6114 #undef elf_backend_want_p_paddr_set_to_zero
6117 #define ELF_OSABI ELFOSABI_OPENVMS
6119 #undef ELF_MAXPAGESIZE
6120 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
6123 #define elfNN_bed elfNN_ia64_vms_bed
6125 #include "elfNN-target.h"