1 /* IA-64 support for 64-bit ELF
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004
3 Free Software Foundation, Inc.
4 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
5
6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
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.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21
22 #include "bfd.h"
23 #include "sysdep.h"
24 #include "libbfd.h"
25 #include "elf-bfd.h"
26 #include "opcode/ia64.h"
27 #include "elf/ia64.h"
28 #include "objalloc.h"
29 #include "hashtab.h"
30
toQList() const31 /* THE RULES for all the stuff the linker creates --
32
33 GOT Entries created in response to LTOFF or LTOFF_FPTR
34 relocations. Dynamic relocs created for dynamic
35 symbols in an application; REL relocs for locals
36 in a shared library.
37
38 FPTR The canonical function descriptor. Created for local
39 symbols in applications. Descriptors for dynamic symbols
40 and local symbols in shared libraries are created by
41 ld.so. Thus there are no dynamic relocs against these
42 objects. The FPTR relocs for such _are_ passed through
43 to the dynamic relocation tables.
44
45 FULL_PLT Created for a PCREL21B relocation against a dynamic symbol.
46 Requires the creation of a PLTOFF entry. This does not
47 require any dynamic relocations.
48
49 PLTOFF Created by PLTOFF relocations. For local symbols, this
50 is an alternate function descriptor, and in shared libraries
51 requires two REL relocations. Note that this cannot be
52 transformed into an FPTR relocation, since it must be in
53 range of the GP. For dynamic symbols, this is a function
54 descriptor for a MIN_PLT entry, and requires one IPLT reloc.
55
56 MIN_PLT Created by PLTOFF entries against dynamic symbols. This
57 does not require dynamic relocations. */
58
59 #define NELEMS(a) ((int) (sizeof (a) / sizeof ((a)[0])))
60
61 typedef struct bfd_hash_entry *(*new_hash_entry_func)
62 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
63
64 /* In dynamically (linker-) created sections, we generally need to keep track
65 of the place a symbol or expression got allocated to. This is done via hash
66 tables that store entries of the following type. */
67
toQList() const68 struct elfNN_ia64_dyn_sym_info
69 {
70 /* The addend for which this entry is relevant. */
71 bfd_vma addend;
72
73 /* Next addend in the list. */
74 struct elfNN_ia64_dyn_sym_info *next;
75
76 bfd_vma got_offset;
77 bfd_vma fptr_offset;
78 bfd_vma pltoff_offset;
79 bfd_vma plt_offset;
80 bfd_vma plt2_offset;
81 bfd_vma tprel_offset;
82 bfd_vma dtpmod_offset;
83 bfd_vma dtprel_offset;
84
85 /* The symbol table entry, if any, that this was derived from. */
86 struct elf_link_hash_entry *h;
87
88 /* Used to count non-got, non-plt relocations for delayed sizing
89 of relocation sections. */
90 struct elfNN_ia64_dyn_reloc_entry
91 {
92 struct elfNN_ia64_dyn_reloc_entry *next;
93 asection *srel;
94 int type;
95 int count;
96
97 /* Is this reloc against readonly section? */
98 bfd_boolean reltext;
99 } *reloc_entries;
100
101 /* TRUE when the section contents have been updated. */
102 unsigned got_done : 1;
103 unsigned fptr_done : 1;
104 unsigned pltoff_done : 1;
105 unsigned tprel_done : 1;
106 unsigned dtpmod_done : 1;
107 unsigned dtprel_done : 1;
108
109 /* TRUE for the different kinds of linker data we want created. */
110 unsigned want_got : 1;
111 unsigned want_gotx : 1;
112 unsigned want_fptr : 1;
113 unsigned want_ltoff_fptr : 1;
114 unsigned want_plt : 1;
115 unsigned want_plt2 : 1;
116 unsigned want_pltoff : 1;
117 unsigned want_tprel : 1;
118 unsigned want_dtpmod : 1;
119 unsigned want_dtprel : 1;
120 };
121
122 struct elfNN_ia64_local_hash_entry
123 {
124 int id;
125 unsigned int r_sym;
126 struct elfNN_ia64_dyn_sym_info *info;
127
128 /* TRUE if this hash entry's addends was translated for
129 SHF_MERGE optimization. */
130 unsigned sec_merge_done : 1;
131 };
132
133 struct elfNN_ia64_link_hash_entry
134 {
135 struct elf_link_hash_entry root;
136 struct elfNN_ia64_dyn_sym_info *info;
137 };
138
139 struct elfNN_ia64_link_hash_table
140 {
141 /* The main hash table. */
142 struct elf_link_hash_table root;
143
144 asection *got_sec; /* the linkage table section (or NULL) */
145 asection *rel_got_sec; /* dynamic relocation section for same */
146 asection *fptr_sec; /* function descriptor table (or NULL) */
147 asection *rel_fptr_sec; /* dynamic relocation section for same */
148 asection *plt_sec; /* the primary plt section (or NULL) */
149 asection *pltoff_sec; /* private descriptors for plt (or NULL) */
150 asection *rel_pltoff_sec; /* dynamic relocation section for same */
151
152 bfd_size_type minplt_entries; /* number of minplt entries */
153 unsigned reltext : 1; /* are there relocs against readonly sections? */
154 unsigned self_dtpmod_done : 1;/* has self DTPMOD entry been finished? */
155 bfd_vma self_dtpmod_offset; /* .got offset to self DTPMOD entry */
156
157 htab_t loc_hash_table;
158 void *loc_hash_memory;
159 };
160
161 struct elfNN_ia64_allocate_data
162 {
163 struct bfd_link_info *info;
164 bfd_size_type ofs;
165 };
166
167 #define elfNN_ia64_hash_table(p) \
168 ((struct elfNN_ia64_link_hash_table *) ((p)->hash))
169
170 static bfd_reloc_status_type elfNN_ia64_reloc
171 PARAMS ((bfd *abfd, arelent *reloc, asymbol *sym, PTR data,
172 asection *input_section, bfd *output_bfd, char **error_message));
173 static reloc_howto_type * lookup_howto
174 PARAMS ((unsigned int rtype));
175 static reloc_howto_type *elfNN_ia64_reloc_type_lookup
176 PARAMS ((bfd *abfd, bfd_reloc_code_real_type bfd_code));
177 static void elfNN_ia64_info_to_howto
178 PARAMS ((bfd *abfd, arelent *bfd_reloc, Elf_Internal_Rela *elf_reloc));
179 static bfd_boolean elfNN_ia64_relax_section
180 PARAMS((bfd *abfd, asection *sec, struct bfd_link_info *link_info,
181 bfd_boolean *again));
182 static void elfNN_ia64_relax_ldxmov
183 PARAMS((bfd *abfd, bfd_byte *contents, bfd_vma off));
184 static bfd_boolean is_unwind_section_name
185 PARAMS ((bfd *abfd, const char *));
186 static bfd_boolean elfNN_ia64_section_from_shdr
187 PARAMS ((bfd *, Elf_Internal_Shdr *, const char *));
188 static bfd_boolean elfNN_ia64_section_flags
189 PARAMS ((flagword *, Elf_Internal_Shdr *));
190 static bfd_boolean elfNN_ia64_fake_sections
191 PARAMS ((bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec));
192 static void elfNN_ia64_final_write_processing
193 PARAMS ((bfd *abfd, bfd_boolean linker));
194 static bfd_boolean elfNN_ia64_add_symbol_hook
195 PARAMS ((bfd *abfd, struct bfd_link_info *info, Elf_Internal_Sym *sym,
196 const char **namep, flagword *flagsp, asection **secp,
197 bfd_vma *valp));
198 static int elfNN_ia64_additional_program_headers
199 PARAMS ((bfd *abfd));
200 static bfd_boolean elfNN_ia64_modify_segment_map
201 PARAMS ((bfd *, struct bfd_link_info *));
202 static bfd_boolean elfNN_ia64_is_local_label_name
203 PARAMS ((bfd *abfd, const char *name));
204 static bfd_boolean elfNN_ia64_dynamic_symbol_p
205 PARAMS ((struct elf_link_hash_entry *h, struct bfd_link_info *info, int));
206 static struct bfd_hash_entry *elfNN_ia64_new_elf_hash_entry
207 PARAMS ((struct bfd_hash_entry *entry, struct bfd_hash_table *table,
208 const char *string));
209 static void elfNN_ia64_hash_copy_indirect
210 PARAMS ((const struct elf_backend_data *, struct elf_link_hash_entry *,
211 struct elf_link_hash_entry *));
212 static void elfNN_ia64_hash_hide_symbol
213 PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean));
214 static hashval_t elfNN_ia64_local_htab_hash PARAMS ((const void *));
215 static int elfNN_ia64_local_htab_eq PARAMS ((const void *ptr1,
216 const void *ptr2));
217 static struct bfd_link_hash_table *elfNN_ia64_hash_table_create
218 PARAMS ((bfd *abfd));
219 static void elfNN_ia64_hash_table_free
220 PARAMS ((struct bfd_link_hash_table *hash));
221 static bfd_boolean elfNN_ia64_global_dyn_sym_thunk
222 PARAMS ((struct bfd_hash_entry *, PTR));
223 static int elfNN_ia64_local_dyn_sym_thunk
224 PARAMS ((void **, PTR));
225 static void elfNN_ia64_dyn_sym_traverse
226 PARAMS ((struct elfNN_ia64_link_hash_table *ia64_info,
227 bfd_boolean (*func) (struct elfNN_ia64_dyn_sym_info *, PTR),
228 PTR info));
229 static bfd_boolean elfNN_ia64_create_dynamic_sections
230 PARAMS ((bfd *abfd, struct bfd_link_info *info));
231 static struct elfNN_ia64_local_hash_entry * get_local_sym_hash
232 PARAMS ((struct elfNN_ia64_link_hash_table *ia64_info,
233 bfd *abfd, const Elf_Internal_Rela *rel, bfd_boolean create));
234 static struct elfNN_ia64_dyn_sym_info * get_dyn_sym_info
235 PARAMS ((struct elfNN_ia64_link_hash_table *ia64_info,
236 struct elf_link_hash_entry *h,
237 bfd *abfd, const Elf_Internal_Rela *rel, bfd_boolean create));
238 static asection *get_got
239 PARAMS ((bfd *abfd, struct bfd_link_info *info,
240 struct elfNN_ia64_link_hash_table *ia64_info));
241 static asection *get_fptr
242 PARAMS ((bfd *abfd, struct bfd_link_info *info,
243 struct elfNN_ia64_link_hash_table *ia64_info));
244 static asection *get_pltoff
245 PARAMS ((bfd *abfd, struct bfd_link_info *info,
246 struct elfNN_ia64_link_hash_table *ia64_info));
247 static asection *get_reloc_section
248 PARAMS ((bfd *abfd, struct elfNN_ia64_link_hash_table *ia64_info,
249 asection *sec, bfd_boolean create));
250 static bfd_boolean elfNN_ia64_check_relocs
251 PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *sec,
252 const Elf_Internal_Rela *relocs));
253 static bfd_boolean elfNN_ia64_adjust_dynamic_symbol
254 PARAMS ((struct bfd_link_info *info, struct elf_link_hash_entry *h));
255 static long global_sym_index
256 PARAMS ((struct elf_link_hash_entry *h));
257 static bfd_boolean allocate_fptr
258 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
259 static bfd_boolean allocate_global_data_got
260 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
261 static bfd_boolean allocate_global_fptr_got
262 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
263 static bfd_boolean allocate_local_got
264 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
265 static bfd_boolean allocate_pltoff_entries
266 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
267 static bfd_boolean allocate_plt_entries
268 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
269 static bfd_boolean allocate_plt2_entries
270 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
271 static bfd_boolean allocate_dynrel_entries
272 PARAMS ((struct elfNN_ia64_dyn_sym_info *dyn_i, PTR data));
273 static bfd_boolean elfNN_ia64_size_dynamic_sections
274 PARAMS ((bfd *output_bfd, struct bfd_link_info *info));
275 static bfd_reloc_status_type elfNN_ia64_install_value
276 PARAMS ((bfd *abfd, bfd_byte *hit_addr, bfd_vma val, unsigned int r_type));
277 static void elfNN_ia64_install_dyn_reloc
278 PARAMS ((bfd *abfd, struct bfd_link_info *info, asection *sec,
279 asection *srel, bfd_vma offset, unsigned int type,
280 long dynindx, bfd_vma addend));
281 static bfd_vma set_got_entry
282 PARAMS ((bfd *abfd, struct bfd_link_info *info,
283 struct elfNN_ia64_dyn_sym_info *dyn_i, long dynindx,
284 bfd_vma addend, bfd_vma value, unsigned int dyn_r_type));
285 static bfd_vma set_fptr_entry
286 PARAMS ((bfd *abfd, struct bfd_link_info *info,
287 struct elfNN_ia64_dyn_sym_info *dyn_i,
288 bfd_vma value));
289 static bfd_vma set_pltoff_entry
290 PARAMS ((bfd *abfd, struct bfd_link_info *info,
291 struct elfNN_ia64_dyn_sym_info *dyn_i,
292 bfd_vma value, bfd_boolean));
293 static bfd_vma elfNN_ia64_tprel_base
294 PARAMS ((struct bfd_link_info *info));
295 static bfd_vma elfNN_ia64_dtprel_base
296 PARAMS ((struct bfd_link_info *info));
297 static int elfNN_ia64_unwind_entry_compare
298 PARAMS ((const PTR, const PTR));
299 static bfd_boolean elfNN_ia64_choose_gp
300 PARAMS ((bfd *abfd, struct bfd_link_info *info));
301 static bfd_boolean elfNN_ia64_final_link
302 PARAMS ((bfd *abfd, struct bfd_link_info *info));
303 static bfd_boolean elfNN_ia64_relocate_section
304 PARAMS ((bfd *output_bfd, struct bfd_link_info *info, bfd *input_bfd,
305 asection *input_section, bfd_byte *contents,
306 Elf_Internal_Rela *relocs, Elf_Internal_Sym *local_syms,
307 asection **local_sections));
308 static bfd_boolean elfNN_ia64_finish_dynamic_symbol
309 PARAMS ((bfd *output_bfd, struct bfd_link_info *info,
310 struct elf_link_hash_entry *h, Elf_Internal_Sym *sym));
311 static bfd_boolean elfNN_ia64_finish_dynamic_sections
312 PARAMS ((bfd *abfd, struct bfd_link_info *info));
313 static bfd_boolean elfNN_ia64_set_private_flags
314 PARAMS ((bfd *abfd, flagword flags));
315 static bfd_boolean elfNN_ia64_merge_private_bfd_data
316 PARAMS ((bfd *ibfd, bfd *obfd));
317 static bfd_boolean elfNN_ia64_print_private_bfd_data
318 PARAMS ((bfd *abfd, PTR ptr));
319 static enum elf_reloc_type_class elfNN_ia64_reloc_type_class
320 PARAMS ((const Elf_Internal_Rela *));
321 static bfd_boolean elfNN_ia64_hpux_vec
322 PARAMS ((const bfd_target *vec));
323 static void elfNN_hpux_post_process_headers
324 PARAMS ((bfd *abfd, struct bfd_link_info *info));
325 bfd_boolean elfNN_hpux_backend_section_from_bfd_section
326 PARAMS ((bfd *abfd, asection *sec, int *retval));
327
328 /* ia64-specific relocation. */
329
330 /* Perform a relocation. Not much to do here as all the hard work is
331 done in elfNN_ia64_final_link_relocate. */
332 static bfd_reloc_status_type
333 elfNN_ia64_reloc (abfd, reloc, sym, data, input_section,
334 output_bfd, error_message)
335 bfd *abfd ATTRIBUTE_UNUSED;
336 arelent *reloc;
337 asymbol *sym ATTRIBUTE_UNUSED;
338 PTR data ATTRIBUTE_UNUSED;
339 asection *input_section;
340 bfd *output_bfd;
341 char **error_message;
342 {
343 if (output_bfd)
344 {
345 reloc->address += input_section->output_offset;
346 return bfd_reloc_ok;
347 }
348
349 if (input_section->flags & SEC_DEBUGGING)
350 return bfd_reloc_continue;
351
352 *error_message = "Unsupported call to elfNN_ia64_reloc";
353 return bfd_reloc_notsupported;
354 }
355
356 #define IA64_HOWTO(TYPE, NAME, SIZE, PCREL, IN) \
357 HOWTO (TYPE, 0, SIZE, 0, PCREL, 0, complain_overflow_signed, \
358 elfNN_ia64_reloc, NAME, FALSE, 0, -1, IN)
359
360 /* This table has to be sorted according to increasing number of the
361 TYPE field. */
362 static reloc_howto_type ia64_howto_table[] =
363 {
364 IA64_HOWTO (R_IA64_NONE, "NONE", 0, FALSE, TRUE),
365
366 IA64_HOWTO (R_IA64_IMM14, "IMM14", 0, FALSE, TRUE),
367 IA64_HOWTO (R_IA64_IMM22, "IMM22", 0, FALSE, TRUE),
368 IA64_HOWTO (R_IA64_IMM64, "IMM64", 0, FALSE, TRUE),
369 IA64_HOWTO (R_IA64_DIR32MSB, "DIR32MSB", 2, FALSE, TRUE),
370 IA64_HOWTO (R_IA64_DIR32LSB, "DIR32LSB", 2, FALSE, TRUE),
371 IA64_HOWTO (R_IA64_DIR64MSB, "DIR64MSB", 4, FALSE, TRUE),
372 IA64_HOWTO (R_IA64_DIR64LSB, "DIR64LSB", 4, FALSE, TRUE),
373
374 IA64_HOWTO (R_IA64_GPREL22, "GPREL22", 0, FALSE, TRUE),
375 IA64_HOWTO (R_IA64_GPREL64I, "GPREL64I", 0, FALSE, TRUE),
376 IA64_HOWTO (R_IA64_GPREL32MSB, "GPREL32MSB", 2, FALSE, TRUE),
377 IA64_HOWTO (R_IA64_GPREL32LSB, "GPREL32LSB", 2, FALSE, TRUE),
378 IA64_HOWTO (R_IA64_GPREL64MSB, "GPREL64MSB", 4, FALSE, TRUE),
379 IA64_HOWTO (R_IA64_GPREL64LSB, "GPREL64LSB", 4, FALSE, TRUE),
380
381 IA64_HOWTO (R_IA64_LTOFF22, "LTOFF22", 0, FALSE, TRUE),
382 IA64_HOWTO (R_IA64_LTOFF64I, "LTOFF64I", 0, FALSE, TRUE),
383
384 IA64_HOWTO (R_IA64_PLTOFF22, "PLTOFF22", 0, FALSE, TRUE),
385 IA64_HOWTO (R_IA64_PLTOFF64I, "PLTOFF64I", 0, FALSE, TRUE),
386 IA64_HOWTO (R_IA64_PLTOFF64MSB, "PLTOFF64MSB", 4, FALSE, TRUE),
387 IA64_HOWTO (R_IA64_PLTOFF64LSB, "PLTOFF64LSB", 4, FALSE, TRUE),
388
389 IA64_HOWTO (R_IA64_FPTR64I, "FPTR64I", 0, FALSE, TRUE),
390 IA64_HOWTO (R_IA64_FPTR32MSB, "FPTR32MSB", 2, FALSE, TRUE),
391 IA64_HOWTO (R_IA64_FPTR32LSB, "FPTR32LSB", 2, FALSE, TRUE),
392 IA64_HOWTO (R_IA64_FPTR64MSB, "FPTR64MSB", 4, FALSE, TRUE),
393 IA64_HOWTO (R_IA64_FPTR64LSB, "FPTR64LSB", 4, FALSE, TRUE),
394
395 IA64_HOWTO (R_IA64_PCREL60B, "PCREL60B", 0, TRUE, TRUE),
396 IA64_HOWTO (R_IA64_PCREL21B, "PCREL21B", 0, TRUE, TRUE),
397 IA64_HOWTO (R_IA64_PCREL21M, "PCREL21M", 0, TRUE, TRUE),
398 IA64_HOWTO (R_IA64_PCREL21F, "PCREL21F", 0, TRUE, TRUE),
399 IA64_HOWTO (R_IA64_PCREL32MSB, "PCREL32MSB", 2, TRUE, TRUE),
400 IA64_HOWTO (R_IA64_PCREL32LSB, "PCREL32LSB", 2, TRUE, TRUE),
401 IA64_HOWTO (R_IA64_PCREL64MSB, "PCREL64MSB", 4, TRUE, TRUE),
402 IA64_HOWTO (R_IA64_PCREL64LSB, "PCREL64LSB", 4, TRUE, TRUE),
403
404 IA64_HOWTO (R_IA64_LTOFF_FPTR22, "LTOFF_FPTR22", 0, FALSE, TRUE),
405 IA64_HOWTO (R_IA64_LTOFF_FPTR64I, "LTOFF_FPTR64I", 0, FALSE, TRUE),
406 IA64_HOWTO (R_IA64_LTOFF_FPTR32MSB, "LTOFF_FPTR32MSB", 2, FALSE, TRUE),
407 IA64_HOWTO (R_IA64_LTOFF_FPTR32LSB, "LTOFF_FPTR32LSB", 2, FALSE, TRUE),
408 IA64_HOWTO (R_IA64_LTOFF_FPTR64MSB, "LTOFF_FPTR64MSB", 4, FALSE, TRUE),
409 IA64_HOWTO (R_IA64_LTOFF_FPTR64LSB, "LTOFF_FPTR64LSB", 4, FALSE, TRUE),
410
411 IA64_HOWTO (R_IA64_SEGREL32MSB, "SEGREL32MSB", 2, FALSE, TRUE),
412 IA64_HOWTO (R_IA64_SEGREL32LSB, "SEGREL32LSB", 2, FALSE, TRUE),
413 IA64_HOWTO (R_IA64_SEGREL64MSB, "SEGREL64MSB", 4, FALSE, TRUE),
414 IA64_HOWTO (R_IA64_SEGREL64LSB, "SEGREL64LSB", 4, FALSE, TRUE),
415
416 IA64_HOWTO (R_IA64_SECREL32MSB, "SECREL32MSB", 2, FALSE, TRUE),
417 IA64_HOWTO (R_IA64_SECREL32LSB, "SECREL32LSB", 2, FALSE, TRUE),
418 IA64_HOWTO (R_IA64_SECREL64MSB, "SECREL64MSB", 4, FALSE, TRUE),
419 IA64_HOWTO (R_IA64_SECREL64LSB, "SECREL64LSB", 4, FALSE, TRUE),
420
421 IA64_HOWTO (R_IA64_REL32MSB, "REL32MSB", 2, FALSE, TRUE),
422 IA64_HOWTO (R_IA64_REL32LSB, "REL32LSB", 2, FALSE, TRUE),
423 IA64_HOWTO (R_IA64_REL64MSB, "REL64MSB", 4, FALSE, TRUE),
424 IA64_HOWTO (R_IA64_REL64LSB, "REL64LSB", 4, FALSE, TRUE),
425
426 IA64_HOWTO (R_IA64_LTV32MSB, "LTV32MSB", 2, FALSE, TRUE),
427 IA64_HOWTO (R_IA64_LTV32LSB, "LTV32LSB", 2, FALSE, TRUE),
428 IA64_HOWTO (R_IA64_LTV64MSB, "LTV64MSB", 4, FALSE, TRUE),
429 IA64_HOWTO (R_IA64_LTV64LSB, "LTV64LSB", 4, FALSE, TRUE),
430
431 IA64_HOWTO (R_IA64_PCREL21BI, "PCREL21BI", 0, TRUE, TRUE),
432 IA64_HOWTO (R_IA64_PCREL22, "PCREL22", 0, TRUE, TRUE),
433 IA64_HOWTO (R_IA64_PCREL64I, "PCREL64I", 0, TRUE, TRUE),
434
435 IA64_HOWTO (R_IA64_IPLTMSB, "IPLTMSB", 4, FALSE, TRUE),
436 IA64_HOWTO (R_IA64_IPLTLSB, "IPLTLSB", 4, FALSE, TRUE),
437 IA64_HOWTO (R_IA64_COPY, "COPY", 4, FALSE, TRUE),
438 IA64_HOWTO (R_IA64_LTOFF22X, "LTOFF22X", 0, FALSE, TRUE),
439 IA64_HOWTO (R_IA64_LDXMOV, "LDXMOV", 0, FALSE, TRUE),
440
441 IA64_HOWTO (R_IA64_TPREL14, "TPREL14", 0, FALSE, FALSE),
442 IA64_HOWTO (R_IA64_TPREL22, "TPREL22", 0, FALSE, FALSE),
443 IA64_HOWTO (R_IA64_TPREL64I, "TPREL64I", 0, FALSE, FALSE),
444 IA64_HOWTO (R_IA64_TPREL64MSB, "TPREL64MSB", 4, FALSE, FALSE),
445 IA64_HOWTO (R_IA64_TPREL64LSB, "TPREL64LSB", 4, FALSE, FALSE),
446 IA64_HOWTO (R_IA64_LTOFF_TPREL22, "LTOFF_TPREL22", 0, FALSE, FALSE),
447
448 IA64_HOWTO (R_IA64_DTPMOD64MSB, "TPREL64MSB", 4, FALSE, FALSE),
449 IA64_HOWTO (R_IA64_DTPMOD64LSB, "TPREL64LSB", 4, FALSE, FALSE),
450 IA64_HOWTO (R_IA64_LTOFF_DTPMOD22, "LTOFF_DTPMOD22", 0, FALSE, FALSE),
451
452 IA64_HOWTO (R_IA64_DTPREL14, "DTPREL14", 0, FALSE, FALSE),
453 IA64_HOWTO (R_IA64_DTPREL22, "DTPREL22", 0, FALSE, FALSE),
454 IA64_HOWTO (R_IA64_DTPREL64I, "DTPREL64I", 0, FALSE, FALSE),
455 IA64_HOWTO (R_IA64_DTPREL32MSB, "DTPREL32MSB", 2, FALSE, FALSE),
456 IA64_HOWTO (R_IA64_DTPREL32LSB, "DTPREL32LSB", 2, FALSE, FALSE),
457 IA64_HOWTO (R_IA64_DTPREL64MSB, "DTPREL64MSB", 4, FALSE, FALSE),
458 IA64_HOWTO (R_IA64_DTPREL64LSB, "DTPREL64LSB", 4, FALSE, FALSE),
459 IA64_HOWTO (R_IA64_LTOFF_DTPREL22, "LTOFF_DTPREL22", 0, FALSE, FALSE),
460 };
461
462 static unsigned char elf_code_to_howto_index[R_IA64_MAX_RELOC_CODE + 1];
463
464 /* Given a BFD reloc type, return the matching HOWTO structure. */
465
466 static reloc_howto_type *
467 lookup_howto (rtype)
468 unsigned int rtype;
469 {
470 static int inited = 0;
471 int i;
472
473 if (!inited)
474 {
475 inited = 1;
476
477 memset (elf_code_to_howto_index, 0xff, sizeof (elf_code_to_howto_index));
478 for (i = 0; i < NELEMS (ia64_howto_table); ++i)
479 elf_code_to_howto_index[ia64_howto_table[i].type] = i;
480 }
481
482 BFD_ASSERT (rtype <= R_IA64_MAX_RELOC_CODE);
483 i = elf_code_to_howto_index[rtype];
484 if (i >= NELEMS (ia64_howto_table))
485 return 0;
486 return ia64_howto_table + i;
487 }
488
489 static reloc_howto_type*
490 elfNN_ia64_reloc_type_lookup (abfd, bfd_code)
491 bfd *abfd ATTRIBUTE_UNUSED;
492 bfd_reloc_code_real_type bfd_code;
493 {
494 unsigned int rtype;
495
496 switch (bfd_code)
497 {
498 case BFD_RELOC_NONE: rtype = R_IA64_NONE; break;
499
500 case BFD_RELOC_IA64_IMM14: rtype = R_IA64_IMM14; break;
501 case BFD_RELOC_IA64_IMM22: rtype = R_IA64_IMM22; break;
502 case BFD_RELOC_IA64_IMM64: rtype = R_IA64_IMM64; break;
503
504 case BFD_RELOC_IA64_DIR32MSB: rtype = R_IA64_DIR32MSB; break;
505 case BFD_RELOC_IA64_DIR32LSB: rtype = R_IA64_DIR32LSB; break;
506 case BFD_RELOC_IA64_DIR64MSB: rtype = R_IA64_DIR64MSB; break;
507 case BFD_RELOC_IA64_DIR64LSB: rtype = R_IA64_DIR64LSB; break;
508
509 case BFD_RELOC_IA64_GPREL22: rtype = R_IA64_GPREL22; break;
510 case BFD_RELOC_IA64_GPREL64I: rtype = R_IA64_GPREL64I; break;
511 case BFD_RELOC_IA64_GPREL32MSB: rtype = R_IA64_GPREL32MSB; break;
512 case BFD_RELOC_IA64_GPREL32LSB: rtype = R_IA64_GPREL32LSB; break;
513 case BFD_RELOC_IA64_GPREL64MSB: rtype = R_IA64_GPREL64MSB; break;
514 case BFD_RELOC_IA64_GPREL64LSB: rtype = R_IA64_GPREL64LSB; break;
515
516 case BFD_RELOC_IA64_LTOFF22: rtype = R_IA64_LTOFF22; break;
517 case BFD_RELOC_IA64_LTOFF64I: rtype = R_IA64_LTOFF64I; break;
518
519 case BFD_RELOC_IA64_PLTOFF22: rtype = R_IA64_PLTOFF22; break;
520 case BFD_RELOC_IA64_PLTOFF64I: rtype = R_IA64_PLTOFF64I; break;
521 case BFD_RELOC_IA64_PLTOFF64MSB: rtype = R_IA64_PLTOFF64MSB; break;
522 case BFD_RELOC_IA64_PLTOFF64LSB: rtype = R_IA64_PLTOFF64LSB; break;
523 case BFD_RELOC_IA64_FPTR64I: rtype = R_IA64_FPTR64I; break;
524 case BFD_RELOC_IA64_FPTR32MSB: rtype = R_IA64_FPTR32MSB; break;
525 case BFD_RELOC_IA64_FPTR32LSB: rtype = R_IA64_FPTR32LSB; break;
526 case BFD_RELOC_IA64_FPTR64MSB: rtype = R_IA64_FPTR64MSB; break;
527 case BFD_RELOC_IA64_FPTR64LSB: rtype = R_IA64_FPTR64LSB; break;
528
529 case BFD_RELOC_IA64_PCREL21B: rtype = R_IA64_PCREL21B; break;
530 case BFD_RELOC_IA64_PCREL21BI: rtype = R_IA64_PCREL21BI; break;
531 case BFD_RELOC_IA64_PCREL21M: rtype = R_IA64_PCREL21M; break;
532 case BFD_RELOC_IA64_PCREL21F: rtype = R_IA64_PCREL21F; break;
533 case BFD_RELOC_IA64_PCREL22: rtype = R_IA64_PCREL22; break;
534 case BFD_RELOC_IA64_PCREL60B: rtype = R_IA64_PCREL60B; break;
535 case BFD_RELOC_IA64_PCREL64I: rtype = R_IA64_PCREL64I; break;
536 case BFD_RELOC_IA64_PCREL32MSB: rtype = R_IA64_PCREL32MSB; break;
537 case BFD_RELOC_IA64_PCREL32LSB: rtype = R_IA64_PCREL32LSB; break;
538 case BFD_RELOC_IA64_PCREL64MSB: rtype = R_IA64_PCREL64MSB; break;
539 case BFD_RELOC_IA64_PCREL64LSB: rtype = R_IA64_PCREL64LSB; break;
540
541 case BFD_RELOC_IA64_LTOFF_FPTR22: rtype = R_IA64_LTOFF_FPTR22; break;
542 case BFD_RELOC_IA64_LTOFF_FPTR64I: rtype = R_IA64_LTOFF_FPTR64I; break;
543 case BFD_RELOC_IA64_LTOFF_FPTR32MSB: rtype = R_IA64_LTOFF_FPTR32MSB; break;
544 case BFD_RELOC_IA64_LTOFF_FPTR32LSB: rtype = R_IA64_LTOFF_FPTR32LSB; break;
545 case BFD_RELOC_IA64_LTOFF_FPTR64MSB: rtype = R_IA64_LTOFF_FPTR64MSB; break;
546 case BFD_RELOC_IA64_LTOFF_FPTR64LSB: rtype = R_IA64_LTOFF_FPTR64LSB; break;
547
548 case BFD_RELOC_IA64_SEGREL32MSB: rtype = R_IA64_SEGREL32MSB; break;
549 case BFD_RELOC_IA64_SEGREL32LSB: rtype = R_IA64_SEGREL32LSB; break;
550 case BFD_RELOC_IA64_SEGREL64MSB: rtype = R_IA64_SEGREL64MSB; break;
551 case BFD_RELOC_IA64_SEGREL64LSB: rtype = R_IA64_SEGREL64LSB; break;
552
553 case BFD_RELOC_IA64_SECREL32MSB: rtype = R_IA64_SECREL32MSB; break;
554 case BFD_RELOC_IA64_SECREL32LSB: rtype = R_IA64_SECREL32LSB; break;
555 case BFD_RELOC_IA64_SECREL64MSB: rtype = R_IA64_SECREL64MSB; break;
556 case BFD_RELOC_IA64_SECREL64LSB: rtype = R_IA64_SECREL64LSB; break;
557
558 case BFD_RELOC_IA64_REL32MSB: rtype = R_IA64_REL32MSB; break;
559 case BFD_RELOC_IA64_REL32LSB: rtype = R_IA64_REL32LSB; break;
560 case BFD_RELOC_IA64_REL64MSB: rtype = R_IA64_REL64MSB; break;
561 case BFD_RELOC_IA64_REL64LSB: rtype = R_IA64_REL64LSB; break;
562
563 case BFD_RELOC_IA64_LTV32MSB: rtype = R_IA64_LTV32MSB; break;
564 case BFD_RELOC_IA64_LTV32LSB: rtype = R_IA64_LTV32LSB; break;
565 case BFD_RELOC_IA64_LTV64MSB: rtype = R_IA64_LTV64MSB; break;
566 case BFD_RELOC_IA64_LTV64LSB: rtype = R_IA64_LTV64LSB; break;
567
568 case BFD_RELOC_IA64_IPLTMSB: rtype = R_IA64_IPLTMSB; break;
569 case BFD_RELOC_IA64_IPLTLSB: rtype = R_IA64_IPLTLSB; break;
570 case BFD_RELOC_IA64_COPY: rtype = R_IA64_COPY; break;
571 case BFD_RELOC_IA64_LTOFF22X: rtype = R_IA64_LTOFF22X; break;
572 case BFD_RELOC_IA64_LDXMOV: rtype = R_IA64_LDXMOV; break;
573
574 case BFD_RELOC_IA64_TPREL14: rtype = R_IA64_TPREL14; break;
575 case BFD_RELOC_IA64_TPREL22: rtype = R_IA64_TPREL22; break;
576 case BFD_RELOC_IA64_TPREL64I: rtype = R_IA64_TPREL64I; break;
577 case BFD_RELOC_IA64_TPREL64MSB: rtype = R_IA64_TPREL64MSB; break;
578 case BFD_RELOC_IA64_TPREL64LSB: rtype = R_IA64_TPREL64LSB; break;
579 case BFD_RELOC_IA64_LTOFF_TPREL22: rtype = R_IA64_LTOFF_TPREL22; break;
580
581 case BFD_RELOC_IA64_DTPMOD64MSB: rtype = R_IA64_DTPMOD64MSB; break;
582 case BFD_RELOC_IA64_DTPMOD64LSB: rtype = R_IA64_DTPMOD64LSB; break;
583 case BFD_RELOC_IA64_LTOFF_DTPMOD22: rtype = R_IA64_LTOFF_DTPMOD22; break;
584
585 case BFD_RELOC_IA64_DTPREL14: rtype = R_IA64_DTPREL14; break;
586 case BFD_RELOC_IA64_DTPREL22: rtype = R_IA64_DTPREL22; break;
587 case BFD_RELOC_IA64_DTPREL64I: rtype = R_IA64_DTPREL64I; break;
588 case BFD_RELOC_IA64_DTPREL32MSB: rtype = R_IA64_DTPREL32MSB; break;
589 case BFD_RELOC_IA64_DTPREL32LSB: rtype = R_IA64_DTPREL32LSB; break;
590 case BFD_RELOC_IA64_DTPREL64MSB: rtype = R_IA64_DTPREL64MSB; break;
591 case BFD_RELOC_IA64_DTPREL64LSB: rtype = R_IA64_DTPREL64LSB; break;
592 case BFD_RELOC_IA64_LTOFF_DTPREL22: rtype = R_IA64_LTOFF_DTPREL22; break;
593
594 default: return 0;
595 }
596 return lookup_howto (rtype);
597 }
598
599 /* Given a ELF reloc, return the matching HOWTO structure. */
600
601 static void
602 elfNN_ia64_info_to_howto (abfd, bfd_reloc, elf_reloc)
603 bfd *abfd ATTRIBUTE_UNUSED;
604 arelent *bfd_reloc;
605 Elf_Internal_Rela *elf_reloc;
606 {
607 bfd_reloc->howto
608 = lookup_howto ((unsigned int) ELFNN_R_TYPE (elf_reloc->r_info));
609 }
610
611 #define PLT_HEADER_SIZE (3 * 16)
612 #define PLT_MIN_ENTRY_SIZE (1 * 16)
613 #define PLT_FULL_ENTRY_SIZE (2 * 16)
614 #define PLT_RESERVED_WORDS 3
615
616 static const bfd_byte plt_header[PLT_HEADER_SIZE] =
617 {
618 0x0b, 0x10, 0x00, 0x1c, 0x00, 0x21, /* [MMI] mov r2=r14;; */
619 0xe0, 0x00, 0x08, 0x00, 0x48, 0x00, /* addl r14=0,r2 */
620 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
621 0x0b, 0x80, 0x20, 0x1c, 0x18, 0x14, /* [MMI] ld8 r16=[r14],8;; */
622 0x10, 0x41, 0x38, 0x30, 0x28, 0x00, /* ld8 r17=[r14],8 */
623 0x00, 0x00, 0x04, 0x00, /* nop.i 0x0;; */
624 0x11, 0x08, 0x00, 0x1c, 0x18, 0x10, /* [MIB] ld8 r1=[r14] */
625 0x60, 0x88, 0x04, 0x80, 0x03, 0x00, /* mov b6=r17 */
626 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
627 };
628
629 static const bfd_byte plt_min_entry[PLT_MIN_ENTRY_SIZE] =
630 {
631 0x11, 0x78, 0x00, 0x00, 0x00, 0x24, /* [MIB] mov r15=0 */
632 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, /* nop.i 0x0 */
633 0x00, 0x00, 0x00, 0x40 /* br.few 0 <PLT0>;; */
634 };
635
636 static const bfd_byte plt_full_entry[PLT_FULL_ENTRY_SIZE] =
637 {
638 0x0b, 0x78, 0x00, 0x02, 0x00, 0x24, /* [MMI] addl r15=0,r1;; */
639 0x00, 0x41, 0x3c, 0x70, 0x29, 0xc0, /* ld8.acq r16=[r15],8*/
640 0x01, 0x08, 0x00, 0x84, /* mov r14=r1;; */
641 0x11, 0x08, 0x00, 0x1e, 0x18, 0x10, /* [MIB] ld8 r1=[r15] */
642 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
643 0x60, 0x00, 0x80, 0x00 /* br.few b6;; */
644 };
645
646 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
647
648 static const bfd_byte oor_brl[16] =
649 {
650 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
651 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;; */
652 0x00, 0x00, 0x00, 0xc0
653 };
654
655 static const bfd_byte oor_ip[48] =
656 {
657 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
658 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, /* movl r15=0 */
659 0x01, 0x00, 0x00, 0x60,
660 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MII] nop.m 0 */
661 0x00, 0x01, 0x00, 0x60, 0x00, 0x00, /* mov r16=ip;; */
662 0xf2, 0x80, 0x00, 0x80, /* add r16=r15,r16;; */
663 0x11, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MIB] nop.m 0 */
664 0x60, 0x80, 0x04, 0x80, 0x03, 0x00, /* mov b6=r16 */
665 0x60, 0x00, 0x80, 0x00 /* br b6;; */
666 };
667
668 static size_t oor_branch_size = sizeof (oor_brl);
669
670 void
671 bfd_elfNN_ia64_after_parse (int itanium)
672 {
673 oor_branch_size = itanium ? sizeof (oor_ip) : sizeof (oor_brl);
674 }
675
676 static void
677 elfNN_ia64_relax_brl (bfd *abfd, bfd_byte *contents, bfd_vma off)
678 {
679 int template;
680 bfd_byte *hit_addr;
681 bfd_vma t0, t1, i0, i1, i2;
682
683 hit_addr = (bfd_byte *) (contents + off);
684 hit_addr -= (long) hit_addr & 0x3;
685 t0 = bfd_get_64 (abfd, hit_addr);
686 t1 = bfd_get_64 (abfd, hit_addr + 8);
687
688 /* Keep the instruction in slot 0. */
689 i0 = (t0 >> 5) & 0x1ffffffffffLL;
690 /* Use nop.b for slot 1. */
691 i1 = 0x4000000000LL;
692 /* For slot 2, turn brl into br by masking out bit 40. */
693 i2 = (t1 >> 23) & 0x0ffffffffffLL;
694
695 /* Turn a MLX bundle into a MBB bundle with the same stop-bit
696 variety. */
697 template = 0x12;
698 if ((t0 & 0x1fLL) == 5)
699 template += 1;
700 t0 = (i1 << 46) | (i0 << 5) | template;
701 t1 = (i2 << 23) | (i1 >> 18);
702
703 bfd_put_64 (abfd, t0, hit_addr);
704 bfd_put_64 (abfd, t1, hit_addr + 8);
705 }
706
707 /* These functions do relaxation for IA-64 ELF. */
708
709 static bfd_boolean
710 elfNN_ia64_relax_section (abfd, sec, link_info, again)
711 bfd *abfd;
712 asection *sec;
713 struct bfd_link_info *link_info;
714 bfd_boolean *again;
715 {
716 struct one_fixup
717 {
718 struct one_fixup *next;
719 asection *tsec;
720 bfd_vma toff;
721 bfd_vma trampoff;
722 };
723
724 Elf_Internal_Shdr *symtab_hdr;
725 Elf_Internal_Rela *internal_relocs;
726 Elf_Internal_Rela *irel, *irelend;
727 bfd_byte *contents;
728 Elf_Internal_Sym *isymbuf = NULL;
729 struct elfNN_ia64_link_hash_table *ia64_info;
730 struct one_fixup *fixups = NULL;
731 bfd_boolean changed_contents = FALSE;
732 bfd_boolean changed_relocs = FALSE;
733 bfd_boolean changed_got = FALSE;
734 bfd_vma gp = 0;
735
736 /* Assume we're not going to change any sizes, and we'll only need
737 one pass. */
738 *again = FALSE;
739
740 /* Don't even try to relax for non-ELF outputs. */
741 if (!is_elf_hash_table (link_info->hash))
742 return FALSE;
743
744 /* Nothing to do if there are no relocations or there is no need for
745 the relax finalize pass. */
746 if ((sec->flags & SEC_RELOC) == 0
747 || sec->reloc_count == 0
748 || (!link_info->need_relax_finalize
749 && sec->need_finalize_relax == 0))
750 return TRUE;
751
752 /* If this is the first time we have been called for this section,
753 initialize the cooked size. */
754 if (sec->_cooked_size == 0)
755 sec->_cooked_size = sec->_raw_size;
756
757 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
758
759 /* Load the relocations for this section. */
760 internal_relocs = (_bfd_elf_link_read_relocs
761 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
762 link_info->keep_memory));
763 if (internal_relocs == NULL)
764 return FALSE;
765
766 ia64_info = elfNN_ia64_hash_table (link_info);
767 irelend = internal_relocs + sec->reloc_count;
768
769 /* Get the section contents. */
770 if (elf_section_data (sec)->this_hdr.contents != NULL)
771 contents = elf_section_data (sec)->this_hdr.contents;
772 else
773 {
774 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
775 if (contents == NULL)
776 goto error_return;
777
778 if (! bfd_get_section_contents (abfd, sec, contents,
779 (file_ptr) 0, sec->_raw_size))
780 goto error_return;
781 }
782
783 for (irel = internal_relocs; irel < irelend; irel++)
784 {
785 unsigned long r_type = ELFNN_R_TYPE (irel->r_info);
786 bfd_vma symaddr, reladdr, trampoff, toff, roff;
787 asection *tsec;
788 struct one_fixup *f;
789 bfd_size_type amt;
790 bfd_boolean is_branch;
791 struct elfNN_ia64_dyn_sym_info *dyn_i;
792
793 switch (r_type)
794 {
795 case R_IA64_PCREL21B:
796 case R_IA64_PCREL21BI:
797 case R_IA64_PCREL21M:
798 case R_IA64_PCREL21F:
799 /* In the finalize pass, all br relaxations are done. We can
800 skip it. */
801 if (!link_info->need_relax_finalize)
802 continue;
803 is_branch = TRUE;
804 break;
805
806 case R_IA64_PCREL60B:
807 /* We can't optimize brl to br before the finalize pass since
808 br relaxations will increase the code size. Defer it to
809 the finalize pass. */
810 if (link_info->need_relax_finalize)
811 {
812 sec->need_finalize_relax = 1;
813 continue;
814 }
815 is_branch = TRUE;
816 break;
817
818 case R_IA64_LTOFF22X:
819 case R_IA64_LDXMOV:
820 /* We can't relax ldx/mov before the finalize pass since
821 br relaxations will increase the code size. Defer it to
822 the finalize pass. */
823 if (link_info->need_relax_finalize)
824 {
825 sec->need_finalize_relax = 1;
826 continue;
827 }
828 is_branch = FALSE;
829 break;
830
831 default:
832 continue;
833 }
834
835 /* Get the value of the symbol referred to by the reloc. */
836 if (ELFNN_R_SYM (irel->r_info) < symtab_hdr->sh_info)
837 {
838 /* A local symbol. */
839 Elf_Internal_Sym *isym;
840
841 /* Read this BFD's local symbols. */
842 if (isymbuf == NULL)
843 {
844 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
845 if (isymbuf == NULL)
846 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
847 symtab_hdr->sh_info, 0,
848 NULL, NULL, NULL);
849 if (isymbuf == 0)
850 goto error_return;
851 }
852
853 isym = isymbuf + ELFNN_R_SYM (irel->r_info);
854 if (isym->st_shndx == SHN_UNDEF)
855 continue; /* We can't do anything with undefined symbols. */
856 else if (isym->st_shndx == SHN_ABS)
857 tsec = bfd_abs_section_ptr;
858 else if (isym->st_shndx == SHN_COMMON)
859 tsec = bfd_com_section_ptr;
860 else if (isym->st_shndx == SHN_IA_64_ANSI_COMMON)
861 tsec = bfd_com_section_ptr;
862 else
863 tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
864
865 toff = isym->st_value;
866 dyn_i = get_dyn_sym_info (ia64_info, NULL, abfd, irel, FALSE);
867 }
868 else
869 {
870 unsigned long indx;
871 struct elf_link_hash_entry *h;
872
873 indx = ELFNN_R_SYM (irel->r_info) - symtab_hdr->sh_info;
874 h = elf_sym_hashes (abfd)[indx];
875 BFD_ASSERT (h != NULL);
876
877 while (h->root.type == bfd_link_hash_indirect
878 || h->root.type == bfd_link_hash_warning)
879 h = (struct elf_link_hash_entry *) h->root.u.i.link;
880
881 dyn_i = get_dyn_sym_info (ia64_info, h, abfd, irel, FALSE);
882
883 /* For branches to dynamic symbols, we're interested instead
884 in a branch to the PLT entry. */
885 if (is_branch && dyn_i && dyn_i->want_plt2)
886 {
887 /* Internal branches shouldn't be sent to the PLT.
888 Leave this for now and we'll give an error later. */
889 if (r_type != R_IA64_PCREL21B)
890 continue;
891
892 tsec = ia64_info->plt_sec;
893 toff = dyn_i->plt2_offset;
894 BFD_ASSERT (irel->r_addend == 0);
895 }
896
897 /* Can't do anything else with dynamic symbols. */
898 else if (elfNN_ia64_dynamic_symbol_p (h, link_info, r_type))
899 continue;
900
901 else
902 {
903 /* We can't do anything with undefined symbols. */
904 if (h->root.type == bfd_link_hash_undefined
905 || h->root.type == bfd_link_hash_undefweak)
906 continue;
907
908 tsec = h->root.u.def.section;
909 toff = h->root.u.def.value;
910 }
911 }
912
913 if (tsec->sec_info_type == ELF_INFO_TYPE_MERGE)
914 toff = _bfd_merged_section_offset (abfd, &tsec,
915 elf_section_data (tsec)->sec_info,
916 toff + irel->r_addend,
917 (bfd_vma) 0);
918 else
919 toff += irel->r_addend;
920
921 symaddr = tsec->output_section->vma + tsec->output_offset + toff;
922
923 roff = irel->r_offset;
924
925 if (is_branch)
926 {
927 bfd_signed_vma offset;
928
929 reladdr = (sec->output_section->vma
930 + sec->output_offset
931 + roff) & (bfd_vma) -4;
932
933 /* If the branch is in range, no need to do anything. */
934 if ((bfd_signed_vma) (symaddr - reladdr) >= -0x1000000
935 && (bfd_signed_vma) (symaddr - reladdr) <= 0x0FFFFF0)
936 {
937 /* If the 60-bit branch is in 21-bit range, optimize it. */
938 if (r_type == R_IA64_PCREL60B)
939 {
940 elfNN_ia64_relax_brl (abfd, contents, roff);
941
942 irel->r_info
943 = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
944 R_IA64_PCREL21B);
945
946 /* If the original relocation offset points to slot
947 1, change it to slot 2. */
948 if ((irel->r_offset & 3) == 1)
949 irel->r_offset += 1;
950 }
951
952 continue;
953 }
954 else if (r_type == R_IA64_PCREL60B)
955 continue;
956
957 /* If the branch and target are in the same section, you've
958 got one honking big section and we can't help you. You'll
959 get an error message later. */
960 if (tsec == sec)
961 continue;
962
963 /* Look for an existing fixup to this address. */
964 for (f = fixups; f ; f = f->next)
965 if (f->tsec == tsec && f->toff == toff)
966 break;
967
968 if (f == NULL)
969 {
970 /* Two alternatives: If it's a branch to a PLT entry, we can
971 make a copy of the FULL_PLT entry. Otherwise, we'll have
972 to use a `brl' insn to get where we're going. */
973
974 size_t size;
975
976 if (tsec == ia64_info->plt_sec)
977 size = sizeof (plt_full_entry);
978 else
979 size = oor_branch_size;
980
981 /* Resize the current section to make room for the new branch. */
982 trampoff = (sec->_cooked_size + 15) & (bfd_vma) -16;
983
984 /* If trampoline is out of range, there is nothing we
985 can do. */
986 offset = trampoff - (roff & (bfd_vma) -4);
987 if (offset < -0x1000000 || offset > 0x0FFFFF0)
988 continue;
989
990 amt = trampoff + size;
991 contents = (bfd_byte *) bfd_realloc (contents, amt);
992 if (contents == NULL)
993 goto error_return;
994 sec->_cooked_size = amt;
995
996 if (tsec == ia64_info->plt_sec)
997 {
998 memcpy (contents + trampoff, plt_full_entry, size);
999
1000 /* Hijack the old relocation for use as the PLTOFF reloc. */
1001 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
1002 R_IA64_PLTOFF22);
1003 irel->r_offset = trampoff;
1004 }
1005 else
1006 {
1007 if (size == sizeof (oor_ip))
1008 {
1009 memcpy (contents + trampoff, oor_ip, size);
1010 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
1011 R_IA64_PCREL64I);
1012 irel->r_addend -= 16;
1013 irel->r_offset = trampoff + 2;
1014 }
1015 else
1016 {
1017 memcpy (contents + trampoff, oor_brl, size);
1018 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
1019 R_IA64_PCREL60B);
1020 irel->r_offset = trampoff + 2;
1021 }
1022
1023 }
1024
1025 /* Record the fixup so we don't do it again this section. */
1026 f = (struct one_fixup *)
1027 bfd_malloc ((bfd_size_type) sizeof (*f));
1028 f->next = fixups;
1029 f->tsec = tsec;
1030 f->toff = toff;
1031 f->trampoff = trampoff;
1032 fixups = f;
1033 }
1034 else
1035 {
1036 /* If trampoline is out of range, there is nothing we
1037 can do. */
1038 offset = f->trampoff - (roff & (bfd_vma) -4);
1039 if (offset < -0x1000000 || offset > 0x0FFFFF0)
1040 continue;
1041
1042 /* Nop out the reloc, since we're finalizing things here. */
1043 irel->r_info = ELFNN_R_INFO (0, R_IA64_NONE);
1044 }
1045
1046 /* Fix up the existing branch to hit the trampoline. */
1047 if (elfNN_ia64_install_value (abfd, contents + roff, offset,
1048 r_type) != bfd_reloc_ok)
1049 goto error_return;
1050
1051 changed_contents = TRUE;
1052 changed_relocs = TRUE;
1053 }
1054 else
1055 {
1056 /* Fetch the gp. */
1057 if (gp == 0)
1058 {
1059 bfd *obfd = sec->output_section->owner;
1060 gp = _bfd_get_gp_value (obfd);
1061 if (gp == 0)
1062 {
1063 if (!elfNN_ia64_choose_gp (obfd, link_info))
1064 goto error_return;
1065 gp = _bfd_get_gp_value (obfd);
1066 }
1067 }
1068
1069 /* If the data is out of range, do nothing. */
1070 if ((bfd_signed_vma) (symaddr - gp) >= 0x200000
1071 ||(bfd_signed_vma) (symaddr - gp) < -0x200000)
1072 continue;
1073
1074 if (r_type == R_IA64_LTOFF22X)
1075 {
1076 irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
1077 R_IA64_GPREL22);
1078 changed_relocs = TRUE;
1079 if (dyn_i->want_gotx)
1080 {
1081 dyn_i->want_gotx = 0;
1082 changed_got |= !dyn_i->want_got;
1083 }
1084 }
1085 else
1086 {
1087 elfNN_ia64_relax_ldxmov (abfd, contents, roff);
1088 irel->r_info = ELFNN_R_INFO (0, R_IA64_NONE);
1089 changed_contents = TRUE;
1090 changed_relocs = TRUE;
1091 }
1092 }
1093 }
1094
1095 /* ??? If we created fixups, this may push the code segment large
1096 enough that the data segment moves, which will change the GP.
1097 Reset the GP so that we re-calculate next round. We need to
1098 do this at the _beginning_ of the next round; now will not do. */
1099
1100 /* Clean up and go home. */
1101 while (fixups)
1102 {
1103 struct one_fixup *f = fixups;
1104 fixups = fixups->next;
1105 free (f);
1106 }
1107
1108 if (isymbuf != NULL
1109 && symtab_hdr->contents != (unsigned char *) isymbuf)
1110 {
1111 if (! link_info->keep_memory)
1112 free (isymbuf);
1113 else
1114 {
1115 /* Cache the symbols for elf_link_input_bfd. */
1116 symtab_hdr->contents = (unsigned char *) isymbuf;
1117 }
1118 }
1119
1120 if (contents != NULL
1121 && elf_section_data (sec)->this_hdr.contents != contents)
1122 {
1123 if (!changed_contents && !link_info->keep_memory)
1124 free (contents);
1125 else
1126 {
1127 /* Cache the section contents for elf_link_input_bfd. */
1128 elf_section_data (sec)->this_hdr.contents = contents;
1129 }
1130 }
1131
1132 if (elf_section_data (sec)->relocs != internal_relocs)
1133 {
1134 if (!changed_relocs)
1135 free (internal_relocs);
1136 else
1137 elf_section_data (sec)->relocs = internal_relocs;
1138 }
1139
1140 if (changed_got)
1141 {
1142 struct elfNN_ia64_allocate_data data;
1143 data.info = link_info;
1144 data.ofs = 0;
1145 ia64_info->self_dtpmod_offset = (bfd_vma) -1;
1146
1147 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data);
1148 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data);
1149 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data);
1150 ia64_info->got_sec->_raw_size = data.ofs;
1151 ia64_info->got_sec->_cooked_size = data.ofs;
1152
1153 /* ??? Resize .rela.got too. */
1154 }
1155
1156 if (!link_info->need_relax_finalize)
1157 sec->need_finalize_relax = 0;
1158
1159 *again = changed_contents || changed_relocs;
1160 return TRUE;
1161
1162 error_return:
1163 if (isymbuf != NULL && (unsigned char *) isymbuf != symtab_hdr->contents)
1164 free (isymbuf);
1165 if (contents != NULL
1166 && elf_section_data (sec)->this_hdr.contents != contents)
1167 free (contents);
1168 if (internal_relocs != NULL
1169 && elf_section_data (sec)->relocs != internal_relocs)
1170 free (internal_relocs);
1171 return FALSE;
1172 }
1173
1174 static void
1175 elfNN_ia64_relax_ldxmov (abfd, contents, off)
1176 bfd *abfd;
1177 bfd_byte *contents;
1178 bfd_vma off;
1179 {
1180 int shift, r1, r3;
1181 bfd_vma dword, insn;
1182
1183 switch ((int)off & 0x3)
1184 {
1185 case 0: shift = 5; break;
1186 case 1: shift = 14; off += 3; break;
1187 case 2: shift = 23; off += 6; break;
1188 default:
1189 abort ();
1190 }
1191
1192 dword = bfd_get_64 (abfd, contents + off);
1193 insn = (dword >> shift) & 0x1ffffffffffLL;
1194
1195 r1 = (insn >> 6) & 127;
1196 r3 = (insn >> 20) & 127;
1197 if (r1 == r3)
1198 insn = 0x8000000; /* nop */
1199 else
1200 insn = (insn & 0x7f01fff) | 0x10800000000LL; /* (qp) mov r1 = r3 */
1201
1202 dword &= ~(0x1ffffffffffLL << shift);
1203 dword |= (insn << shift);
1204 bfd_put_64 (abfd, dword, contents + off);
1205 }
1206
1207 /* Return TRUE if NAME is an unwind table section name. */
1208
1209 static inline bfd_boolean
1210 is_unwind_section_name (abfd, name)
1211 bfd *abfd;
1212 const char *name;
1213 {
1214 size_t len1, len2, len3;
1215
1216 if (elfNN_ia64_hpux_vec (abfd->xvec)
1217 && !strcmp (name, ELF_STRING_ia64_unwind_hdr))
1218 return FALSE;
1219
1220 len1 = sizeof (ELF_STRING_ia64_unwind) - 1;
1221 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
1222 len3 = sizeof (ELF_STRING_ia64_unwind_once) - 1;
1223 return ((strncmp (name, ELF_STRING_ia64_unwind, len1) == 0
1224 && strncmp (name, ELF_STRING_ia64_unwind_info, len2) != 0)
1225 || strncmp (name, ELF_STRING_ia64_unwind_once, len3) == 0);
1226 }
1227
1228 /* Handle an IA-64 specific section when reading an object file. This
1229 is called when elfcode.h finds a section with an unknown type. */
1230
1231 static bfd_boolean
1232 elfNN_ia64_section_from_shdr (abfd, hdr, name)
1233 bfd *abfd;
1234 Elf_Internal_Shdr *hdr;
1235 const char *name;
1236 {
1237 asection *newsect;
1238
1239 /* There ought to be a place to keep ELF backend specific flags, but
1240 at the moment there isn't one. We just keep track of the
1241 sections by their name, instead. Fortunately, the ABI gives
1242 suggested names for all the MIPS specific sections, so we will
1243 probably get away with this. */
1244 switch (hdr->sh_type)
1245 {
1246 case SHT_IA_64_UNWIND:
1247 case SHT_IA_64_HP_OPT_ANOT:
1248 break;
1249
1250 case SHT_IA_64_EXT:
1251 if (strcmp (name, ELF_STRING_ia64_archext) != 0)
1252 return FALSE;
1253 break;
1254
1255 default:
1256 return FALSE;
1257 }
1258
1259 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
1260 return FALSE;
1261 newsect = hdr->bfd_section;
1262
1263 return TRUE;
1264 }
1265
1266 /* Convert IA-64 specific section flags to bfd internal section flags. */
1267
1268 /* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
1269 flag. */
1270
1271 static bfd_boolean
1272 elfNN_ia64_section_flags (flags, hdr)
1273 flagword *flags;
1274 Elf_Internal_Shdr *hdr;
1275 {
1276 if (hdr->sh_flags & SHF_IA_64_SHORT)
1277 *flags |= SEC_SMALL_DATA;
1278
1279 return TRUE;
1280 }
1281
1282 /* Set the correct type for an IA-64 ELF section. We do this by the
1283 section name, which is a hack, but ought to work. */
1284
1285 static bfd_boolean
1286 elfNN_ia64_fake_sections (abfd, hdr, sec)
1287 bfd *abfd ATTRIBUTE_UNUSED;
1288 Elf_Internal_Shdr *hdr;
1289 asection *sec;
1290 {
1291 register const char *name;
1292
1293 name = bfd_get_section_name (abfd, sec);
1294
1295 if (is_unwind_section_name (abfd, name))
1296 {
1297 /* We don't have the sections numbered at this point, so sh_info
1298 is set later, in elfNN_ia64_final_write_processing. */
1299 hdr->sh_type = SHT_IA_64_UNWIND;
1300 hdr->sh_flags |= SHF_LINK_ORDER;
1301 }
1302 else if (strcmp (name, ELF_STRING_ia64_archext) == 0)
1303 hdr->sh_type = SHT_IA_64_EXT;
1304 else if (strcmp (name, ".HP.opt_annot") == 0)
1305 hdr->sh_type = SHT_IA_64_HP_OPT_ANOT;
1306 else if (strcmp (name, ".reloc") == 0)
1307 /* This is an ugly, but unfortunately necessary hack that is
1308 needed when producing EFI binaries on IA-64. It tells
1309 elf.c:elf_fake_sections() not to consider ".reloc" as a section
1310 containing ELF relocation info. We need this hack in order to
1311 be able to generate ELF binaries that can be translated into
1312 EFI applications (which are essentially COFF objects). Those
1313 files contain a COFF ".reloc" section inside an ELFNN object,
1314 which would normally cause BFD to segfault because it would
1315 attempt to interpret this section as containing relocation
1316 entries for section "oc". With this hack enabled, ".reloc"
1317 will be treated as a normal data section, which will avoid the
1318 segfault. However, you won't be able to create an ELFNN binary
1319 with a section named "oc" that needs relocations, but that's
1320 the kind of ugly side-effects you get when detecting section
1321 types based on their names... In practice, this limitation is
1322 unlikely to bite. */
1323 hdr->sh_type = SHT_PROGBITS;
1324
1325 if (sec->flags & SEC_SMALL_DATA)
1326 hdr->sh_flags |= SHF_IA_64_SHORT;
1327
1328 return TRUE;
1329 }
1330
1331 /* The final processing done just before writing out an IA-64 ELF
1332 object file. */
1333
1334 static void
1335 elfNN_ia64_final_write_processing (abfd, linker)
1336 bfd *abfd;
1337 bfd_boolean linker ATTRIBUTE_UNUSED;
1338 {
1339 Elf_Internal_Shdr *hdr;
1340 const char *sname;
1341 asection *text_sect, *s;
1342 size_t len;
1343
1344 for (s = abfd->sections; s; s = s->next)
1345 {
1346 hdr = &elf_section_data (s)->this_hdr;
1347 switch (hdr->sh_type)
1348 {
1349 case SHT_IA_64_UNWIND:
1350 /* See comments in gas/config/tc-ia64.c:dot_endp on why we
1351 have to do this. */
1352 sname = bfd_get_section_name (abfd, s);
1353 len = sizeof (ELF_STRING_ia64_unwind) - 1;
1354 if (sname && strncmp (sname, ELF_STRING_ia64_unwind, len) == 0)
1355 {
1356 sname += len;
1357
1358 if (sname[0] == '\0')
1359 /* .IA_64.unwind -> .text */
1360 text_sect = bfd_get_section_by_name (abfd, ".text");
1361 else
1362 /* .IA_64.unwindFOO -> FOO */
1363 text_sect = bfd_get_section_by_name (abfd, sname);
1364 }
1365 else if (sname
1366 && (len = sizeof (ELF_STRING_ia64_unwind_once) - 1,
1367 strncmp (sname, ELF_STRING_ia64_unwind_once, len)) == 0)
1368 {
1369 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.t.FOO */
1370 size_t len2 = sizeof (".gnu.linkonce.t.") - 1;
1371 char *once_name = bfd_malloc (len2 + strlen (sname + len) + 1);
1372
1373 if (once_name != NULL)
1374 {
1375 memcpy (once_name, ".gnu.linkonce.t.", len2);
1376 strcpy (once_name + len2, sname + len);
1377 text_sect = bfd_get_section_by_name (abfd, once_name);
1378 free (once_name);
1379 }
1380 else
1381 /* Should only happen if we run out of memory, in
1382 which case we're probably toast anyway. Try to
1383 cope by finding the section the slow way. */
1384 for (text_sect = abfd->sections;
1385 text_sect != NULL;
1386 text_sect = text_sect->next)
1387 {
1388 if (strncmp (bfd_section_name (abfd, text_sect),
1389 ".gnu.linkonce.t.", len2) == 0
1390 && strcmp (bfd_section_name (abfd, text_sect) + len2,
1391 sname + len) == 0)
1392 break;
1393 }
1394 }
1395 else
1396 /* last resort: fall back on .text */
1397 text_sect = bfd_get_section_by_name (abfd, ".text");
1398
1399 if (text_sect)
1400 {
1401 /* The IA-64 processor-specific ABI requires setting
1402 sh_link to the unwind section, whereas HP-UX requires
1403 sh_info to do so. For maximum compatibility, we'll
1404 set both for now... */
1405 hdr->sh_link = elf_section_data (text_sect)->this_idx;
1406 hdr->sh_info = elf_section_data (text_sect)->this_idx;
1407 }
1408 break;
1409 }
1410 }
1411
1412 if (! elf_flags_init (abfd))
1413 {
1414 unsigned long flags = 0;
1415
1416 if (abfd->xvec->byteorder == BFD_ENDIAN_BIG)
1417 flags |= EF_IA_64_BE;
1418 if (bfd_get_mach (abfd) == bfd_mach_ia64_elf64)
1419 flags |= EF_IA_64_ABI64;
1420
1421 elf_elfheader(abfd)->e_flags = flags;
1422 elf_flags_init (abfd) = TRUE;
1423 }
1424 }
1425
1426 /* Hook called by the linker routine which adds symbols from an object
1427 file. We use it to put .comm items in .sbss, and not .bss. */
1428
1429 static bfd_boolean
1430 elfNN_ia64_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
1431 bfd *abfd;
1432 struct bfd_link_info *info;
1433 Elf_Internal_Sym *sym;
1434 const char **namep ATTRIBUTE_UNUSED;
1435 flagword *flagsp ATTRIBUTE_UNUSED;
1436 asection **secp;
1437 bfd_vma *valp;
1438 {
1439 if (sym->st_shndx == SHN_COMMON
1440 && !info->relocatable
1441 && sym->st_size <= elf_gp_size (abfd))
1442 {
1443 /* Common symbols less than or equal to -G nn bytes are
1444 automatically put into .sbss. */
1445
1446 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1447
1448 if (scomm == NULL)
1449 {
1450 scomm = bfd_make_section (abfd, ".scommon");
1451 if (scomm == NULL
1452 || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
1453 | SEC_IS_COMMON
1454 | SEC_LINKER_CREATED)))
1455 return FALSE;
1456 }
1457
1458 *secp = scomm;
1459 *valp = sym->st_size;
1460 }
1461
1462 return TRUE;
1463 }
1464
1465 /* Return the number of additional phdrs we will need. */
1466
1467 static int
1468 elfNN_ia64_additional_program_headers (abfd)
1469 bfd *abfd;
1470 {
1471 asection *s;
1472 int ret = 0;
1473
1474 /* See if we need a PT_IA_64_ARCHEXT segment. */
1475 s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_archext);
1476 if (s && (s->flags & SEC_LOAD))
1477 ++ret;
1478
1479 /* Count how many PT_IA_64_UNWIND segments we need. */
1480 for (s = abfd->sections; s; s = s->next)
1481 if (is_unwind_section_name (abfd, s->name) && (s->flags & SEC_LOAD))
1482 ++ret;
1483
1484 return ret;
1485 }
1486
1487 static bfd_boolean
1488 elfNN_ia64_modify_segment_map (abfd, info)
1489 bfd *abfd;
1490 struct bfd_link_info *info ATTRIBUTE_UNUSED;
1491 {
1492 struct elf_segment_map *m, **pm;
1493 Elf_Internal_Shdr *hdr;
1494 asection *s;
1495
1496 /* If we need a PT_IA_64_ARCHEXT segment, it must come before
1497 all PT_LOAD segments. */
1498 s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_archext);
1499 if (s && (s->flags & SEC_LOAD))
1500 {
1501 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
1502 if (m->p_type == PT_IA_64_ARCHEXT)
1503 break;
1504 if (m == NULL)
1505 {
1506 m = ((struct elf_segment_map *)
1507 bfd_zalloc (abfd, (bfd_size_type) sizeof *m));
1508 if (m == NULL)
1509 return FALSE;
1510
1511 m->p_type = PT_IA_64_ARCHEXT;
1512 m->count = 1;
1513 m->sections[0] = s;
1514
1515 /* We want to put it after the PHDR and INTERP segments. */
1516 pm = &elf_tdata (abfd)->segment_map;
1517 while (*pm != NULL
1518 && ((*pm)->p_type == PT_PHDR
1519 || (*pm)->p_type == PT_INTERP))
1520 pm = &(*pm)->next;
1521
1522 m->next = *pm;
1523 *pm = m;
1524 }
1525 }
1526
1527 /* Install PT_IA_64_UNWIND segments, if needed. */
1528 for (s = abfd->sections; s; s = s->next)
1529 {
1530 hdr = &elf_section_data (s)->this_hdr;
1531 if (hdr->sh_type != SHT_IA_64_UNWIND)
1532 continue;
1533
1534 if (s && (s->flags & SEC_LOAD))
1535 {
1536 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
1537 if (m->p_type == PT_IA_64_UNWIND)
1538 {
1539 int i;
1540
1541 /* Look through all sections in the unwind segment
1542 for a match since there may be multiple sections
1543 to a segment. */
1544 for (i = m->count - 1; i >= 0; --i)
1545 if (m->sections[i] == s)
1546 break;
1547
1548 if (i >= 0)
1549 break;
1550 }
1551
1552 if (m == NULL)
1553 {
1554 m = ((struct elf_segment_map *)
1555 bfd_zalloc (abfd, (bfd_size_type) sizeof *m));
1556 if (m == NULL)
1557 return FALSE;
1558
1559 m->p_type = PT_IA_64_UNWIND;
1560 m->count = 1;
1561 m->sections[0] = s;
1562 m->next = NULL;
1563
1564 /* We want to put it last. */
1565 pm = &elf_tdata (abfd)->segment_map;
1566 while (*pm != NULL)
1567 pm = &(*pm)->next;
1568 *pm = m;
1569 }
1570 }
1571 }
1572
1573 /* Turn on PF_IA_64_NORECOV if needed. This involves traversing all of
1574 the input sections for each output section in the segment and testing
1575 for SHF_IA_64_NORECOV on each. */
1576 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
1577 if (m->p_type == PT_LOAD)
1578 {
1579 int i;
1580 for (i = m->count - 1; i >= 0; --i)
1581 {
1582 struct bfd_link_order *order = m->sections[i]->link_order_head;
1583 while (order)
1584 {
1585 if (order->type == bfd_indirect_link_order)
1586 {
1587 asection *is = order->u.indirect.section;
1588 bfd_vma flags = elf_section_data(is)->this_hdr.sh_flags;
1589 if (flags & SHF_IA_64_NORECOV)
1590 {
1591 m->p_flags |= PF_IA_64_NORECOV;
1592 goto found;
1593 }
1594 }
1595 order = order->next;
1596 }
1597 }
1598 found:;
1599 }
1600
1601 return TRUE;
1602 }
1603
1604 /* According to the Tahoe assembler spec, all labels starting with a
1605 '.' are local. */
1606
1607 static bfd_boolean
1608 elfNN_ia64_is_local_label_name (abfd, name)
1609 bfd *abfd ATTRIBUTE_UNUSED;
1610 const char *name;
1611 {
1612 return name[0] == '.';
1613 }
1614
1615 /* Should we do dynamic things to this symbol? */
1616
1617 static bfd_boolean
1618 elfNN_ia64_dynamic_symbol_p (h, info, r_type)
1619 struct elf_link_hash_entry *h;
1620 struct bfd_link_info *info;
1621 int r_type;
1622 {
1623 bfd_boolean ignore_protected
1624 = ((r_type & 0xf8) == 0x40 /* FPTR relocs */
1625 || (r_type & 0xf8) == 0x50); /* LTOFF_FPTR relocs */
1626
1627 return _bfd_elf_dynamic_symbol_p (h, info, ignore_protected);
1628 }
1629
1630 static struct bfd_hash_entry*
1631 elfNN_ia64_new_elf_hash_entry (entry, table, string)
1632 struct bfd_hash_entry *entry;
1633 struct bfd_hash_table *table;
1634 const char *string;
1635 {
1636 struct elfNN_ia64_link_hash_entry *ret;
1637 ret = (struct elfNN_ia64_link_hash_entry *) entry;
1638
1639 /* Allocate the structure if it has not already been allocated by a
1640 subclass. */
1641 if (!ret)
1642 ret = bfd_hash_allocate (table, sizeof (*ret));
1643
1644 if (!ret)
1645 return 0;
1646
1647 /* Initialize our local data. All zeros, and definitely easier
1648 than setting a handful of bit fields. */
1649 memset (ret, 0, sizeof (*ret));
1650
1651 /* Call the allocation method of the superclass. */
1652 ret = ((struct elfNN_ia64_link_hash_entry *)
1653 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1654 table, string));
1655
1656 return (struct bfd_hash_entry *) ret;
1657 }
1658
1659 static void
1660 elfNN_ia64_hash_copy_indirect (bed, xdir, xind)
1661 const struct elf_backend_data *bed ATTRIBUTE_UNUSED;
1662 struct elf_link_hash_entry *xdir, *xind;
1663 {
1664 struct elfNN_ia64_link_hash_entry *dir, *ind;
1665
1666 dir = (struct elfNN_ia64_link_hash_entry *) xdir;
1667 ind = (struct elfNN_ia64_link_hash_entry *) xind;
1668
1669 /* Copy down any references that we may have already seen to the
1670 symbol which just became indirect. */
1671
1672 dir->root.elf_link_hash_flags |=
1673 (ind->root.elf_link_hash_flags
1674 & (ELF_LINK_HASH_REF_DYNAMIC
1675 | ELF_LINK_HASH_REF_REGULAR
1676 | ELF_LINK_HASH_REF_REGULAR_NONWEAK
1677 | ELF_LINK_HASH_NEEDS_PLT));
1678
1679 if (ind->root.root.type != bfd_link_hash_indirect)
1680 return;
1681
1682 /* Copy over the got and plt data. This would have been done
1683 by check_relocs. */
1684
1685 if (dir->info == NULL)
1686 {
1687 struct elfNN_ia64_dyn_sym_info *dyn_i;
1688
1689 dir->info = dyn_i = ind->info;
1690 ind->info = NULL;
1691
1692 /* Fix up the dyn_sym_info pointers to the global symbol. */
1693 for (; dyn_i; dyn_i = dyn_i->next)
1694 dyn_i->h = &dir->root;
1695 }
1696 BFD_ASSERT (ind->info == NULL);
1697
1698 /* Copy over the dynindx. */
1699
1700 if (dir->root.dynindx == -1)
1701 {
1702 dir->root.dynindx = ind->root.dynindx;
1703 dir->root.dynstr_index = ind->root.dynstr_index;
1704 ind->root.dynindx = -1;
1705 ind->root.dynstr_index = 0;
1706 }
1707 BFD_ASSERT (ind->root.dynindx == -1);
1708 }
1709
1710 static void
1711 elfNN_ia64_hash_hide_symbol (info, xh, force_local)
1712 struct bfd_link_info *info;
1713 struct elf_link_hash_entry *xh;
1714 bfd_boolean force_local;
1715 {
1716 struct elfNN_ia64_link_hash_entry *h;
1717 struct elfNN_ia64_dyn_sym_info *dyn_i;
1718
1719 h = (struct elfNN_ia64_link_hash_entry *)xh;
1720
1721 _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local);
1722
1723 for (dyn_i = h->info; dyn_i; dyn_i = dyn_i->next)
1724 {
1725 dyn_i->want_plt2 = 0;
1726 dyn_i->want_plt = 0;
1727 }
1728 }
1729
1730 /* Compute a hash of a local hash entry. */
1731
1732 static hashval_t
1733 elfNN_ia64_local_htab_hash (ptr)
1734 const void *ptr;
1735 {
1736 struct elfNN_ia64_local_hash_entry *entry
1737 = (struct elfNN_ia64_local_hash_entry *) ptr;
1738
1739 return (((entry->id & 0xff) << 24) | ((entry->id & 0xff00) << 8))
1740 ^ entry->r_sym ^ (entry->id >> 16);
1741 }
1742
1743 /* Compare local hash entries. */
1744
1745 static int
1746 elfNN_ia64_local_htab_eq (ptr1, ptr2)
1747 const void *ptr1, *ptr2;
1748 {
1749 struct elfNN_ia64_local_hash_entry *entry1
1750 = (struct elfNN_ia64_local_hash_entry *) ptr1;
1751 struct elfNN_ia64_local_hash_entry *entry2
1752 = (struct elfNN_ia64_local_hash_entry *) ptr2;
1753
1754 return entry1->id == entry2->id && entry1->r_sym == entry2->r_sym;
1755 }
1756
1757 /* Create the derived linker hash table. The IA-64 ELF port uses this
1758 derived hash table to keep information specific to the IA-64 ElF
1759 linker (without using static variables). */
1760
1761 static struct bfd_link_hash_table*
1762 elfNN_ia64_hash_table_create (abfd)
1763 bfd *abfd;
1764 {
1765 struct elfNN_ia64_link_hash_table *ret;
1766
1767 ret = bfd_zmalloc ((bfd_size_type) sizeof (*ret));
1768 if (!ret)
1769 return 0;
1770
1771 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
1772 elfNN_ia64_new_elf_hash_entry))
1773 {
1774 free (ret);
1775 return 0;
1776 }
1777
1778 ret->loc_hash_table = htab_try_create (1024, elfNN_ia64_local_htab_hash,
1779 elfNN_ia64_local_htab_eq, NULL);
1780 ret->loc_hash_memory = objalloc_create ();
1781 if (!ret->loc_hash_table || !ret->loc_hash_memory)
1782 {
1783 free (ret);
1784 return 0;
1785 }
1786
1787 return &ret->root.root;
1788 }
1789
1790 /* Destroy IA-64 linker hash table. */
1791
1792 static void
1793 elfNN_ia64_hash_table_free (hash)
1794 struct bfd_link_hash_table *hash;
1795 {
1796 struct elfNN_ia64_link_hash_table *ia64_info
1797 = (struct elfNN_ia64_link_hash_table *) hash;
1798 if (ia64_info->loc_hash_table)
1799 htab_delete (ia64_info->loc_hash_table);
1800 if (ia64_info->loc_hash_memory)
1801 objalloc_free ((struct objalloc *) ia64_info->loc_hash_memory);
1802 _bfd_generic_link_hash_table_free (hash);
1803 }
1804
1805 /* Traverse both local and global hash tables. */
1806
1807 struct elfNN_ia64_dyn_sym_traverse_data
1808 {
1809 bfd_boolean (*func) PARAMS ((struct elfNN_ia64_dyn_sym_info *, PTR));
1810 PTR data;
1811 };
1812
1813 static bfd_boolean
1814 elfNN_ia64_global_dyn_sym_thunk (xentry, xdata)
1815 struct bfd_hash_entry *xentry;
1816 PTR xdata;
1817 {
1818 struct elfNN_ia64_link_hash_entry *entry
1819 = (struct elfNN_ia64_link_hash_entry *) xentry;
1820 struct elfNN_ia64_dyn_sym_traverse_data *data
1821 = (struct elfNN_ia64_dyn_sym_traverse_data *) xdata;
1822 struct elfNN_ia64_dyn_sym_info *dyn_i;
1823
1824 if (entry->root.root.type == bfd_link_hash_warning)
1825 entry = (struct elfNN_ia64_link_hash_entry *) entry->root.root.u.i.link;
1826
1827 for (dyn_i = entry->info; dyn_i; dyn_i = dyn_i->next)
1828 if (! (*data->func) (dyn_i, data->data))
1829 return FALSE;
1830 return TRUE;
1831 }
1832
1833 static bfd_boolean
1834 elfNN_ia64_local_dyn_sym_thunk (slot, xdata)
1835 void **slot;
1836 PTR xdata;
1837 {
1838 struct elfNN_ia64_local_hash_entry *entry
1839 = (struct elfNN_ia64_local_hash_entry *) *slot;
1840 struct elfNN_ia64_dyn_sym_traverse_data *data
1841 = (struct elfNN_ia64_dyn_sym_traverse_data *) xdata;
1842 struct elfNN_ia64_dyn_sym_info *dyn_i;
1843
1844 for (dyn_i = entry->info; dyn_i; dyn_i = dyn_i->next)
1845 if (! (*data->func) (dyn_i, data->data))
1846 return 0;
1847 return 1;
1848 }
1849
1850 static void
1851 elfNN_ia64_dyn_sym_traverse (ia64_info, func, data)
1852 struct elfNN_ia64_link_hash_table *ia64_info;
1853 bfd_boolean (*func) PARAMS ((struct elfNN_ia64_dyn_sym_info *, PTR));
1854 PTR data;
1855 {
1856 struct elfNN_ia64_dyn_sym_traverse_data xdata;
1857
1858 xdata.func = func;
1859 xdata.data = data;
1860
1861 elf_link_hash_traverse (&ia64_info->root,
1862 elfNN_ia64_global_dyn_sym_thunk, &xdata);
1863 htab_traverse (ia64_info->loc_hash_table,
1864 elfNN_ia64_local_dyn_sym_thunk, &xdata);
1865 }
1866
1867 static bfd_boolean
1868 elfNN_ia64_create_dynamic_sections (abfd, info)
1869 bfd *abfd;
1870 struct bfd_link_info *info;
1871 {
1872 struct elfNN_ia64_link_hash_table *ia64_info;
1873 asection *s;
1874
1875 if (! _bfd_elf_create_dynamic_sections (abfd, info))
1876 return FALSE;
1877
1878 ia64_info = elfNN_ia64_hash_table (info);
1879
1880 ia64_info->plt_sec = bfd_get_section_by_name (abfd, ".plt");
1881 ia64_info->got_sec = bfd_get_section_by_name (abfd, ".got");
1882
1883 {
1884 flagword flags = bfd_get_section_flags (abfd, ia64_info->got_sec);
1885 bfd_set_section_flags (abfd, ia64_info->got_sec, SEC_SMALL_DATA | flags);
1886 /* The .got section is always aligned at 8 bytes. */
1887 bfd_set_section_alignment (abfd, ia64_info->got_sec, 3);
1888 }
1889
1890 if (!get_pltoff (abfd, info, ia64_info))
1891 return FALSE;
1892
1893 s = bfd_make_section(abfd, ".rela.IA_64.pltoff");
1894 if (s == NULL
1895 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1896 | SEC_HAS_CONTENTS
1897 | SEC_IN_MEMORY
1898 | SEC_LINKER_CREATED
1899 | SEC_READONLY))
1900 || !bfd_set_section_alignment (abfd, s, 3))
1901 return FALSE;
1902 ia64_info->rel_pltoff_sec = s;
1903
1904 s = bfd_make_section(abfd, ".rela.got");
1905 if (s == NULL
1906 || !bfd_set_section_flags (abfd, s, (SEC_ALLOC | SEC_LOAD
1907 | SEC_HAS_CONTENTS
1908 | SEC_IN_MEMORY
1909 | SEC_LINKER_CREATED
1910 | SEC_READONLY))
1911 || !bfd_set_section_alignment (abfd, s, 3))
1912 return FALSE;
1913 ia64_info->rel_got_sec = s;
1914
1915 return TRUE;
1916 }
1917
1918 /* Find and/or create a hash entry for local symbol. */
1919 static struct elfNN_ia64_local_hash_entry *
1920 get_local_sym_hash (ia64_info, abfd, rel, create)
1921 struct elfNN_ia64_link_hash_table *ia64_info;
1922 bfd *abfd;
1923 const Elf_Internal_Rela *rel;
1924 bfd_boolean create;
1925 {
1926 struct elfNN_ia64_local_hash_entry e, *ret;
1927 asection *sec = abfd->sections;
1928 hashval_t h = (((sec->id & 0xff) << 24) | ((sec->id & 0xff00) << 8))
1929 ^ ELFNN_R_SYM (rel->r_info) ^ (sec->id >> 16);
1930 void **slot;
1931
1932 e.id = sec->id;
1933 e.r_sym = ELFNN_R_SYM (rel->r_info);
1934 slot = htab_find_slot_with_hash (ia64_info->loc_hash_table, &e, h,
1935 create ? INSERT : NO_INSERT);
1936
1937 if (!slot)
1938 return NULL;
1939
1940 if (*slot)
1941 return (struct elfNN_ia64_local_hash_entry *) *slot;
1942
1943 ret = (struct elfNN_ia64_local_hash_entry *)
1944 objalloc_alloc ((struct objalloc *) ia64_info->loc_hash_memory,
1945 sizeof (struct elfNN_ia64_local_hash_entry));
1946 if (ret)
1947 {
1948 memset (ret, 0, sizeof (*ret));
1949 ret->id = sec->id;
1950 ret->r_sym = ELFNN_R_SYM (rel->r_info);
1951 *slot = ret;
1952 }
1953 return ret;
1954 }
1955
1956 /* Find and/or create a descriptor for dynamic symbol info. This will
1957 vary based on global or local symbol, and the addend to the reloc. */
1958
1959 static struct elfNN_ia64_dyn_sym_info *
1960 get_dyn_sym_info (ia64_info, h, abfd, rel, create)
1961 struct elfNN_ia64_link_hash_table *ia64_info;
1962 struct elf_link_hash_entry *h;
1963 bfd *abfd;
1964 const Elf_Internal_Rela *rel;
1965 bfd_boolean create;
1966 {
1967 struct elfNN_ia64_dyn_sym_info **pp;
1968 struct elfNN_ia64_dyn_sym_info *dyn_i;
1969 bfd_vma addend = rel ? rel->r_addend : 0;
1970
1971 if (h)
1972 pp = &((struct elfNN_ia64_link_hash_entry *)h)->info;
1973 else
1974 {
1975 struct elfNN_ia64_local_hash_entry *loc_h;
1976
1977 loc_h = get_local_sym_hash (ia64_info, abfd, rel, create);
1978 if (!loc_h)
1979 {
1980 BFD_ASSERT (!create);
1981 return NULL;
1982 }
1983
1984 pp = &loc_h->info;
1985 }
1986
1987 for (dyn_i = *pp; dyn_i && dyn_i->addend != addend; dyn_i = *pp)
1988 pp = &dyn_i->next;
1989
1990 if (dyn_i == NULL && create)
1991 {
1992 dyn_i = ((struct elfNN_ia64_dyn_sym_info *)
1993 bfd_zalloc (abfd, (bfd_size_type) sizeof *dyn_i));
1994 *pp = dyn_i;
1995 dyn_i->addend = addend;
1996 }
1997
1998 return dyn_i;
1999 }
2000
2001 static asection *
2002 get_got (abfd, info, ia64_info)
2003 bfd *abfd;
2004 struct bfd_link_info *info;
2005 struct elfNN_ia64_link_hash_table *ia64_info;
2006 {
2007 asection *got;
2008 bfd *dynobj;
2009
2010 got = ia64_info->got_sec;
2011 if (!got)
2012 {
2013 flagword flags;
2014
2015 dynobj = ia64_info->root.dynobj;
2016 if (!dynobj)
2017 ia64_info->root.dynobj = dynobj = abfd;
2018 if (!_bfd_elf_create_got_section (dynobj, info))
2019 return 0;
2020
2021 got = bfd_get_section_by_name (dynobj, ".got");
2022 BFD_ASSERT (got);
2023 ia64_info->got_sec = got;
2024
2025 /* The .got section is always aligned at 8 bytes. */
2026 if (!bfd_set_section_alignment (abfd, got, 3))
2027 return 0;
2028
2029 flags = bfd_get_section_flags (abfd, got);
2030 bfd_set_section_flags (abfd, got, SEC_SMALL_DATA | flags);
2031 }
2032
2033 return got;
2034 }
2035
2036 /* Create function descriptor section (.opd). This section is called .opd
2037 because it contains "official procedure descriptors". The "official"
2038 refers to the fact that these descriptors are used when taking the address
2039 of a procedure, thus ensuring a unique address for each procedure. */
2040
2041 static asection *
2042 get_fptr (abfd, info, ia64_info)
2043 bfd *abfd;
2044 struct bfd_link_info *info;
2045 struct elfNN_ia64_link_hash_table *ia64_info;
2046 {
2047 asection *fptr;
2048 bfd *dynobj;
2049
2050 fptr = ia64_info->fptr_sec;
2051 if (!fptr)
2052 {
2053 dynobj = ia64_info->root.dynobj;
2054 if (!dynobj)
2055 ia64_info->root.dynobj = dynobj = abfd;
2056
2057 fptr = bfd_make_section (dynobj, ".opd");
2058 if (!fptr
2059 || !bfd_set_section_flags (dynobj, fptr,
2060 (SEC_ALLOC
2061 | SEC_LOAD
2062 | SEC_HAS_CONTENTS
2063 | SEC_IN_MEMORY
2064 | (info->pie ? 0 : SEC_READONLY)
2065 | SEC_LINKER_CREATED))
2066 || !bfd_set_section_alignment (abfd, fptr, 4))
2067 {
2068 BFD_ASSERT (0);
2069 return NULL;
2070 }
2071
2072 ia64_info->fptr_sec = fptr;
2073
2074 if (info->pie)
2075 {
2076 asection *fptr_rel;
2077 fptr_rel = bfd_make_section(dynobj, ".rela.opd");
2078 if (fptr_rel == NULL
2079 || !bfd_set_section_flags (dynobj, fptr_rel,
2080 (SEC_ALLOC | SEC_LOAD
2081 | SEC_HAS_CONTENTS
2082 | SEC_IN_MEMORY
2083 | SEC_LINKER_CREATED
2084 | SEC_READONLY))
2085 || !bfd_set_section_alignment (abfd, fptr_rel, 3))
2086 {
2087 BFD_ASSERT (0);
2088 return NULL;
2089 }
2090
2091 ia64_info->rel_fptr_sec = fptr_rel;
2092 }
2093 }
2094
2095 return fptr;
2096 }
2097
2098 static asection *
2099 get_pltoff (abfd, info, ia64_info)
2100 bfd *abfd;
2101 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2102 struct elfNN_ia64_link_hash_table *ia64_info;
2103 {
2104 asection *pltoff;
2105 bfd *dynobj;
2106
2107 pltoff = ia64_info->pltoff_sec;
2108 if (!pltoff)
2109 {
2110 dynobj = ia64_info->root.dynobj;
2111 if (!dynobj)
2112 ia64_info->root.dynobj = dynobj = abfd;
2113
2114 pltoff = bfd_make_section (dynobj, ELF_STRING_ia64_pltoff);
2115 if (!pltoff
2116 || !bfd_set_section_flags (dynobj, pltoff,
2117 (SEC_ALLOC
2118 | SEC_LOAD
2119 | SEC_HAS_CONTENTS
2120 | SEC_IN_MEMORY
2121 | SEC_SMALL_DATA
2122 | SEC_LINKER_CREATED))
2123 || !bfd_set_section_alignment (abfd, pltoff, 4))
2124 {
2125 BFD_ASSERT (0);
2126 return NULL;
2127 }
2128
2129 ia64_info->pltoff_sec = pltoff;
2130 }
2131
2132 return pltoff;
2133 }
2134
2135 static asection *
2136 get_reloc_section (abfd, ia64_info, sec, create)
2137 bfd *abfd;
2138 struct elfNN_ia64_link_hash_table *ia64_info;
2139 asection *sec;
2140 bfd_boolean create;
2141 {
2142 const char *srel_name;
2143 asection *srel;
2144 bfd *dynobj;
2145
2146 srel_name = (bfd_elf_string_from_elf_section
2147 (abfd, elf_elfheader(abfd)->e_shstrndx,
2148 elf_section_data(sec)->rel_hdr.sh_name));
2149 if (srel_name == NULL)
2150 return NULL;
2151
2152 BFD_ASSERT ((strncmp (srel_name, ".rela", 5) == 0
2153 && strcmp (bfd_get_section_name (abfd, sec),
2154 srel_name+5) == 0)
2155 || (strncmp (srel_name, ".rel", 4) == 0
2156 && strcmp (bfd_get_section_name (abfd, sec),
2157 srel_name+4) == 0));
2158
2159 dynobj = ia64_info->root.dynobj;
2160 if (!dynobj)
2161 ia64_info->root.dynobj = dynobj = abfd;
2162
2163 srel = bfd_get_section_by_name (dynobj, srel_name);
2164 if (srel == NULL && create)
2165 {
2166 srel = bfd_make_section (dynobj, srel_name);
2167 if (srel == NULL
2168 || !bfd_set_section_flags (dynobj, srel,
2169 (SEC_ALLOC
2170 | SEC_LOAD
2171 | SEC_HAS_CONTENTS
2172 | SEC_IN_MEMORY
2173 | SEC_LINKER_CREATED
2174 | SEC_READONLY))
2175 || !bfd_set_section_alignment (dynobj, srel, 3))
2176 return NULL;
2177 }
2178
2179 return srel;
2180 }
2181
2182 static bfd_boolean
2183 count_dyn_reloc (bfd *abfd, struct elfNN_ia64_dyn_sym_info *dyn_i,
2184 asection *srel, int type, bfd_boolean reltext)
2185 {
2186 struct elfNN_ia64_dyn_reloc_entry *rent;
2187
2188 for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
2189 if (rent->srel == srel && rent->type == type)
2190 break;
2191
2192 if (!rent)
2193 {
2194 rent = ((struct elfNN_ia64_dyn_reloc_entry *)
2195 bfd_alloc (abfd, (bfd_size_type) sizeof (*rent)));
2196 if (!rent)
2197 return FALSE;
2198
2199 rent->next = dyn_i->reloc_entries;
2200 rent->srel = srel;
2201 rent->type = type;
2202 rent->count = 0;
2203 dyn_i->reloc_entries = rent;
2204 }
2205 rent->reltext = reltext;
2206 rent->count++;
2207
2208 return TRUE;
2209 }
2210
2211 static bfd_boolean
2212 elfNN_ia64_check_relocs (abfd, info, sec, relocs)
2213 bfd *abfd;
2214 struct bfd_link_info *info;
2215 asection *sec;
2216 const Elf_Internal_Rela *relocs;
2217 {
2218 struct elfNN_ia64_link_hash_table *ia64_info;
2219 const Elf_Internal_Rela *relend;
2220 Elf_Internal_Shdr *symtab_hdr;
2221 const Elf_Internal_Rela *rel;
2222 asection *got, *fptr, *srel;
2223
2224 if (info->relocatable)
2225 return TRUE;
2226
2227 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2228 ia64_info = elfNN_ia64_hash_table (info);
2229
2230 got = fptr = srel = NULL;
2231
2232 relend = relocs + sec->reloc_count;
2233 for (rel = relocs; rel < relend; ++rel)
2234 {
2235 enum {
2236 NEED_GOT = 1,
2237 NEED_GOTX = 2,
2238 NEED_FPTR = 4,
2239 NEED_PLTOFF = 8,
2240 NEED_MIN_PLT = 16,
2241 NEED_FULL_PLT = 32,
2242 NEED_DYNREL = 64,
2243 NEED_LTOFF_FPTR = 128,
2244 NEED_TPREL = 256,
2245 NEED_DTPMOD = 512,
2246 NEED_DTPREL = 1024
2247 };
2248
2249 struct elf_link_hash_entry *h = NULL;
2250 unsigned long r_symndx = ELFNN_R_SYM (rel->r_info);
2251 struct elfNN_ia64_dyn_sym_info *dyn_i;
2252 int need_entry;
2253 bfd_boolean maybe_dynamic;
2254 int dynrel_type = R_IA64_NONE;
2255
2256 if (r_symndx >= symtab_hdr->sh_info)
2257 {
2258 /* We're dealing with a global symbol -- find its hash entry
2259 and mark it as being referenced. */
2260 long indx = r_symndx - symtab_hdr->sh_info;
2261 h = elf_sym_hashes (abfd)[indx];
2262 while (h->root.type == bfd_link_hash_indirect
2263 || h->root.type == bfd_link_hash_warning)
2264 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2265
2266 h->elf_link_hash_flags |= ELF_LINK_HASH_REF_REGULAR;
2267 }
2268
2269 /* We can only get preliminary data on whether a symbol is
2270 locally or externally defined, as not all of the input files
2271 have yet been processed. Do something with what we know, as
2272 this may help reduce memory usage and processing time later. */
2273 maybe_dynamic = FALSE;
2274 if (h && ((!info->executable
2275 && (!info->symbolic || info->unresolved_syms_in_shared_libs == RM_IGNORE))
2276 || ! (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)
2277 || h->root.type == bfd_link_hash_defweak))
2278 maybe_dynamic = TRUE;
2279
2280 need_entry = 0;
2281 switch (ELFNN_R_TYPE (rel->r_info))
2282 {
2283 case R_IA64_TPREL64MSB:
2284 case R_IA64_TPREL64LSB:
2285 if (info->shared || maybe_dynamic)
2286 need_entry = NEED_DYNREL;
2287 dynrel_type = R_IA64_TPREL64LSB;
2288 if (info->shared)
2289 info->flags |= DF_STATIC_TLS;
2290 break;
2291
2292 case R_IA64_LTOFF_TPREL22:
2293 need_entry = NEED_TPREL;
2294 if (info->shared)
2295 info->flags |= DF_STATIC_TLS;
2296 break;
2297
2298 case R_IA64_DTPREL64MSB:
2299 case R_IA64_DTPREL64LSB:
2300 if (info->shared || maybe_dynamic)
2301 need_entry = NEED_DYNREL;
2302 dynrel_type = R_IA64_DTPREL64LSB;
2303 break;
2304
2305 case R_IA64_LTOFF_DTPREL22:
2306 need_entry = NEED_DTPREL;
2307 break;
2308
2309 case R_IA64_DTPMOD64MSB:
2310 case R_IA64_DTPMOD64LSB:
2311 if (info->shared || maybe_dynamic)
2312 need_entry = NEED_DYNREL;
2313 dynrel_type = R_IA64_DTPMOD64LSB;
2314 break;
2315
2316 case R_IA64_LTOFF_DTPMOD22:
2317 need_entry = NEED_DTPMOD;
2318 break;
2319
2320 case R_IA64_LTOFF_FPTR22:
2321 case R_IA64_LTOFF_FPTR64I:
2322 case R_IA64_LTOFF_FPTR32MSB:
2323 case R_IA64_LTOFF_FPTR32LSB:
2324 case R_IA64_LTOFF_FPTR64MSB:
2325 case R_IA64_LTOFF_FPTR64LSB:
2326 need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR;
2327 break;
2328
2329 case R_IA64_FPTR64I:
2330 case R_IA64_FPTR32MSB:
2331 case R_IA64_FPTR32LSB:
2332 case R_IA64_FPTR64MSB:
2333 case R_IA64_FPTR64LSB:
2334 if (info->shared || h)
2335 need_entry = NEED_FPTR | NEED_DYNREL;
2336 else
2337 need_entry = NEED_FPTR;
2338 dynrel_type = R_IA64_FPTR64LSB;
2339 break;
2340
2341 case R_IA64_LTOFF22:
2342 case R_IA64_LTOFF64I:
2343 need_entry = NEED_GOT;
2344 break;
2345
2346 case R_IA64_LTOFF22X:
2347 need_entry = NEED_GOTX;
2348 break;
2349
2350 case R_IA64_PLTOFF22:
2351 case R_IA64_PLTOFF64I:
2352 case R_IA64_PLTOFF64MSB:
2353 case R_IA64_PLTOFF64LSB:
2354 need_entry = NEED_PLTOFF;
2355 if (h)
2356 {
2357 if (maybe_dynamic)
2358 need_entry |= NEED_MIN_PLT;
2359 }
2360 else
2361 {
2362 (*info->callbacks->warning)
2363 (info, _("@pltoff reloc against local symbol"), 0,
2364 abfd, 0, (bfd_vma) 0);
2365 }
2366 break;
2367
2368 case R_IA64_PCREL21B:
2369 case R_IA64_PCREL60B:
2370 /* Depending on where this symbol is defined, we may or may not
2371 need a full plt entry. Only skip if we know we'll not need
2372 the entry -- static or symbolic, and the symbol definition
2373 has already been seen. */
2374 if (maybe_dynamic && rel->r_addend == 0)
2375 need_entry = NEED_FULL_PLT;
2376 break;
2377
2378 case R_IA64_IMM14:
2379 case R_IA64_IMM22:
2380 case R_IA64_IMM64:
2381 case R_IA64_DIR32MSB:
2382 case R_IA64_DIR32LSB:
2383 case R_IA64_DIR64MSB:
2384 case R_IA64_DIR64LSB:
2385 /* Shared objects will always need at least a REL relocation. */
2386 if (info->shared || maybe_dynamic)
2387 need_entry = NEED_DYNREL;
2388 dynrel_type = R_IA64_DIR64LSB;
2389 break;
2390
2391 case R_IA64_IPLTMSB:
2392 case R_IA64_IPLTLSB:
2393 /* Shared objects will always need at least a REL relocation. */
2394 if (info->shared || maybe_dynamic)
2395 need_entry = NEED_DYNREL;
2396 dynrel_type = R_IA64_IPLTLSB;
2397 break;
2398
2399 case R_IA64_PCREL22:
2400 case R_IA64_PCREL64I:
2401 case R_IA64_PCREL32MSB:
2402 case R_IA64_PCREL32LSB:
2403 case R_IA64_PCREL64MSB:
2404 case R_IA64_PCREL64LSB:
2405 if (maybe_dynamic)
2406 need_entry = NEED_DYNREL;
2407 dynrel_type = R_IA64_PCREL64LSB;
2408 break;
2409 }
2410
2411 if (!need_entry)
2412 continue;
2413
2414 if ((need_entry & NEED_FPTR) != 0
2415 && rel->r_addend)
2416 {
2417 (*info->callbacks->warning)
2418 (info, _("non-zero addend in @fptr reloc"), 0,
2419 abfd, 0, (bfd_vma) 0);
2420 }
2421
2422 dyn_i = get_dyn_sym_info (ia64_info, h, abfd, rel, TRUE);
2423
2424 /* Record whether or not this is a local symbol. */
2425 dyn_i->h = h;
2426
2427 /* Create what's needed. */
2428 if (need_entry & (NEED_GOT | NEED_GOTX | NEED_TPREL
2429 | NEED_DTPMOD | NEED_DTPREL))
2430 {
2431 if (!got)
2432 {
2433 got = get_got (abfd, info, ia64_info);
2434 if (!got)
2435 return FALSE;
2436 }
2437 if (need_entry & NEED_GOT)
2438 dyn_i->want_got = 1;
2439 if (need_entry & NEED_GOTX)
2440 dyn_i->want_gotx = 1;
2441 if (need_entry & NEED_TPREL)
2442 dyn_i->want_tprel = 1;
2443 if (need_entry & NEED_DTPMOD)
2444 dyn_i->want_dtpmod = 1;
2445 if (need_entry & NEED_DTPREL)
2446 dyn_i->want_dtprel = 1;
2447 }
2448 if (need_entry & NEED_FPTR)
2449 {
2450 if (!fptr)
2451 {
2452 fptr = get_fptr (abfd, info, ia64_info);
2453 if (!fptr)
2454 return FALSE;
2455 }
2456
2457 /* FPTRs for shared libraries are allocated by the dynamic
2458 linker. Make sure this local symbol will appear in the
2459 dynamic symbol table. */
2460 if (!h && info->shared)
2461 {
2462 if (! (bfd_elf_link_record_local_dynamic_symbol
2463 (info, abfd, (long) r_symndx)))
2464 return FALSE;
2465 }
2466
2467 dyn_i->want_fptr = 1;
2468 }
2469 if (need_entry & NEED_LTOFF_FPTR)
2470 dyn_i->want_ltoff_fptr = 1;
2471 if (need_entry & (NEED_MIN_PLT | NEED_FULL_PLT))
2472 {
2473 if (!ia64_info->root.dynobj)
2474 ia64_info->root.dynobj = abfd;
2475 h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2476 dyn_i->want_plt = 1;
2477 }
2478 if (need_entry & NEED_FULL_PLT)
2479 dyn_i->want_plt2 = 1;
2480 if (need_entry & NEED_PLTOFF)
2481 dyn_i->want_pltoff = 1;
2482 if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC))
2483 {
2484 if (!srel)
2485 {
2486 srel = get_reloc_section (abfd, ia64_info, sec, TRUE);
2487 if (!srel)
2488 return FALSE;
2489 }
2490 if (!count_dyn_reloc (abfd, dyn_i, srel, dynrel_type,
2491 (sec->flags & SEC_READONLY) != 0))
2492 return FALSE;
2493 }
2494 }
2495
2496 return TRUE;
2497 }
2498
2499 /* For cleanliness, and potentially faster dynamic loading, allocate
2500 external GOT entries first. */
2501
2502 static bfd_boolean
2503 allocate_global_data_got (dyn_i, data)
2504 struct elfNN_ia64_dyn_sym_info *dyn_i;
2505 PTR data;
2506 {
2507 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2508
2509 if ((dyn_i->want_got || dyn_i->want_gotx)
2510 && ! dyn_i->want_fptr
2511 && elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
2512 {
2513 dyn_i->got_offset = x->ofs;
2514 x->ofs += 8;
2515 }
2516 if (dyn_i->want_tprel)
2517 {
2518 dyn_i->tprel_offset = x->ofs;
2519 x->ofs += 8;
2520 }
2521 if (dyn_i->want_dtpmod)
2522 {
2523 if (elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
2524 {
2525 dyn_i->dtpmod_offset = x->ofs;
2526 x->ofs += 8;
2527 }
2528 else
2529 {
2530 struct elfNN_ia64_link_hash_table *ia64_info;
2531
2532 ia64_info = elfNN_ia64_hash_table (x->info);
2533 if (ia64_info->self_dtpmod_offset == (bfd_vma) -1)
2534 {
2535 ia64_info->self_dtpmod_offset = x->ofs;
2536 x->ofs += 8;
2537 }
2538 dyn_i->dtpmod_offset = ia64_info->self_dtpmod_offset;
2539 }
2540 }
2541 if (dyn_i->want_dtprel)
2542 {
2543 dyn_i->dtprel_offset = x->ofs;
2544 x->ofs += 8;
2545 }
2546 return TRUE;
2547 }
2548
2549 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
2550
2551 static bfd_boolean
2552 allocate_global_fptr_got (dyn_i, data)
2553 struct elfNN_ia64_dyn_sym_info *dyn_i;
2554 PTR data;
2555 {
2556 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2557
2558 if (dyn_i->want_got
2559 && dyn_i->want_fptr
2560 && elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, R_IA64_FPTR64LSB))
2561 {
2562 dyn_i->got_offset = x->ofs;
2563 x->ofs += 8;
2564 }
2565 return TRUE;
2566 }
2567
2568 /* Lastly, allocate all the GOT entries for local data. */
2569
2570 static bfd_boolean
2571 allocate_local_got (dyn_i, data)
2572 struct elfNN_ia64_dyn_sym_info *dyn_i;
2573 PTR data;
2574 {
2575 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2576
2577 if ((dyn_i->want_got || dyn_i->want_gotx)
2578 && !elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
2579 {
2580 dyn_i->got_offset = x->ofs;
2581 x->ofs += 8;
2582 }
2583 return TRUE;
2584 }
2585
2586 /* Search for the index of a global symbol in it's defining object file. */
2587
2588 static long
2589 global_sym_index (h)
2590 struct elf_link_hash_entry *h;
2591 {
2592 struct elf_link_hash_entry **p;
2593 bfd *obj;
2594
2595 BFD_ASSERT (h->root.type == bfd_link_hash_defined
2596 || h->root.type == bfd_link_hash_defweak);
2597
2598 obj = h->root.u.def.section->owner;
2599 for (p = elf_sym_hashes (obj); *p != h; ++p)
2600 continue;
2601
2602 return p - elf_sym_hashes (obj) + elf_tdata (obj)->symtab_hdr.sh_info;
2603 }
2604
2605 /* Allocate function descriptors. We can do these for every function
2606 in a main executable that is not exported. */
2607
2608 static bfd_boolean
2609 allocate_fptr (dyn_i, data)
2610 struct elfNN_ia64_dyn_sym_info *dyn_i;
2611 PTR data;
2612 {
2613 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2614
2615 if (dyn_i->want_fptr)
2616 {
2617 struct elf_link_hash_entry *h = dyn_i->h;
2618
2619 if (h)
2620 while (h->root.type == bfd_link_hash_indirect
2621 || h->root.type == bfd_link_hash_warning)
2622 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2623
2624 if (!x->info->executable
2625 && (!h
2626 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2627 || h->root.type != bfd_link_hash_undefweak))
2628 {
2629 if (h && h->dynindx == -1)
2630 {
2631 BFD_ASSERT ((h->root.type == bfd_link_hash_defined)
2632 || (h->root.type == bfd_link_hash_defweak));
2633
2634 if (!bfd_elf_link_record_local_dynamic_symbol
2635 (x->info, h->root.u.def.section->owner,
2636 global_sym_index (h)))
2637 return FALSE;
2638 }
2639
2640 dyn_i->want_fptr = 0;
2641 }
2642 else if (h == NULL || h->dynindx == -1)
2643 {
2644 dyn_i->fptr_offset = x->ofs;
2645 x->ofs += 16;
2646 }
2647 else
2648 dyn_i->want_fptr = 0;
2649 }
2650 return TRUE;
2651 }
2652
2653 /* Allocate all the minimal PLT entries. */
2654
2655 static bfd_boolean
2656 allocate_plt_entries (dyn_i, data)
2657 struct elfNN_ia64_dyn_sym_info *dyn_i;
2658 PTR data;
2659 {
2660 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2661
2662 if (dyn_i->want_plt)
2663 {
2664 struct elf_link_hash_entry *h = dyn_i->h;
2665
2666 if (h)
2667 while (h->root.type == bfd_link_hash_indirect
2668 || h->root.type == bfd_link_hash_warning)
2669 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2670
2671 /* ??? Versioned symbols seem to lose ELF_LINK_HASH_NEEDS_PLT. */
2672 if (elfNN_ia64_dynamic_symbol_p (h, x->info, 0))
2673 {
2674 bfd_size_type offset = x->ofs;
2675 if (offset == 0)
2676 offset = PLT_HEADER_SIZE;
2677 dyn_i->plt_offset = offset;
2678 x->ofs = offset + PLT_MIN_ENTRY_SIZE;
2679
2680 dyn_i->want_pltoff = 1;
2681 }
2682 else
2683 {
2684 dyn_i->want_plt = 0;
2685 dyn_i->want_plt2 = 0;
2686 }
2687 }
2688 return TRUE;
2689 }
2690
2691 /* Allocate all the full PLT entries. */
2692
2693 static bfd_boolean
2694 allocate_plt2_entries (dyn_i, data)
2695 struct elfNN_ia64_dyn_sym_info *dyn_i;
2696 PTR data;
2697 {
2698 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2699
2700 if (dyn_i->want_plt2)
2701 {
2702 struct elf_link_hash_entry *h = dyn_i->h;
2703 bfd_size_type ofs = x->ofs;
2704
2705 dyn_i->plt2_offset = ofs;
2706 x->ofs = ofs + PLT_FULL_ENTRY_SIZE;
2707
2708 while (h->root.type == bfd_link_hash_indirect
2709 || h->root.type == bfd_link_hash_warning)
2710 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2711 dyn_i->h->plt.offset = ofs;
2712 }
2713 return TRUE;
2714 }
2715
2716 /* Allocate all the PLTOFF entries requested by relocations and
2717 plt entries. We can't share space with allocated FPTR entries,
2718 because the latter are not necessarily addressable by the GP.
2719 ??? Relaxation might be able to determine that they are. */
2720
2721 static bfd_boolean
2722 allocate_pltoff_entries (dyn_i, data)
2723 struct elfNN_ia64_dyn_sym_info *dyn_i;
2724 PTR data;
2725 {
2726 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2727
2728 if (dyn_i->want_pltoff)
2729 {
2730 dyn_i->pltoff_offset = x->ofs;
2731 x->ofs += 16;
2732 }
2733 return TRUE;
2734 }
2735
2736 /* Allocate dynamic relocations for those symbols that turned out
2737 to be dynamic. */
2738
2739 static bfd_boolean
2740 allocate_dynrel_entries (dyn_i, data)
2741 struct elfNN_ia64_dyn_sym_info *dyn_i;
2742 PTR data;
2743 {
2744 struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2745 struct elfNN_ia64_link_hash_table *ia64_info;
2746 struct elfNN_ia64_dyn_reloc_entry *rent;
2747 bfd_boolean dynamic_symbol, shared, resolved_zero;
2748
2749 ia64_info = elfNN_ia64_hash_table (x->info);
2750
2751 /* Note that this can't be used in relation to FPTR relocs below. */
2752 dynamic_symbol = elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0);
2753
2754 shared = x->info->shared;
2755 resolved_zero = (dyn_i->h
2756 && ELF_ST_VISIBILITY (dyn_i->h->other)
2757 && dyn_i->h->root.type == bfd_link_hash_undefweak);
2758
2759 /* Take care of the normal data relocations. */
2760
2761 for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
2762 {
2763 int count = rent->count;
2764
2765 switch (rent->type)
2766 {
2767 case R_IA64_FPTR64LSB:
2768 /* Allocate one iff !want_fptr and not PIE, which by this point
2769 will be true only if we're actually allocating one statically
2770 in the main executable. Position independent executables
2771 need a relative reloc. */
2772 if (dyn_i->want_fptr && !x->info->pie)
2773 continue;
2774 break;
2775 case R_IA64_PCREL64LSB:
2776 if (!dynamic_symbol)
2777 continue;
2778 break;
2779 case R_IA64_DIR64LSB:
2780 if (!dynamic_symbol && !shared)
2781 continue;
2782 break;
2783 case R_IA64_IPLTLSB:
2784 if (!dynamic_symbol && !shared)
2785 continue;
2786 /* Use two REL relocations for IPLT relocations
2787 against local symbols. */
2788 if (!dynamic_symbol)
2789 count *= 2;
2790 break;
2791 case R_IA64_TPREL64LSB:
2792 case R_IA64_DTPREL64LSB:
2793 case R_IA64_DTPMOD64LSB:
2794 break;
2795 default:
2796 abort ();
2797 }
2798 if (rent->reltext)
2799 ia64_info->reltext = 1;
2800 rent->srel->_raw_size += sizeof (ElfNN_External_Rela) * count;
2801 }
2802
2803 /* Take care of the GOT and PLT relocations. */
2804
2805 if ((!resolved_zero
2806 && (dynamic_symbol || shared)
2807 && (dyn_i->want_got || dyn_i->want_gotx))
2808 || (dyn_i->want_ltoff_fptr
2809 && dyn_i->h
2810 && dyn_i->h->dynindx != -1))
2811 {
2812 if (!dyn_i->want_ltoff_fptr
2813 || !x->info->pie
2814 || dyn_i->h == NULL
2815 || dyn_i->h->root.type != bfd_link_hash_undefweak)
2816 ia64_info->rel_got_sec->_raw_size += sizeof (ElfNN_External_Rela);
2817 }
2818 if ((dynamic_symbol || shared) && dyn_i->want_tprel)
2819 ia64_info->rel_got_sec->_raw_size += sizeof (ElfNN_External_Rela);
2820 if (dynamic_symbol && dyn_i->want_dtpmod)
2821 ia64_info->rel_got_sec->_raw_size += sizeof (ElfNN_External_Rela);
2822 if (dynamic_symbol && dyn_i->want_dtprel)
2823 ia64_info->rel_got_sec->_raw_size += sizeof (ElfNN_External_Rela);
2824 if (ia64_info->rel_fptr_sec && dyn_i->want_fptr)
2825 {
2826 if (dyn_i->h == NULL || dyn_i->h->root.type != bfd_link_hash_undefweak)
2827 ia64_info->rel_fptr_sec->_raw_size += sizeof (ElfNN_External_Rela);
2828 }
2829
2830 if (!resolved_zero && dyn_i->want_pltoff)
2831 {
2832 bfd_size_type t = 0;
2833
2834 /* Dynamic symbols get one IPLT relocation. Local symbols in
2835 shared libraries get two REL relocations. Local symbols in
2836 main applications get nothing. */
2837 if (dynamic_symbol)
2838 t = sizeof (ElfNN_External_Rela);
2839 else if (shared)
2840 t = 2 * sizeof (ElfNN_External_Rela);
2841
2842 ia64_info->rel_pltoff_sec->_raw_size += t;
2843 }
2844
2845 return TRUE;
2846 }
2847
2848 static bfd_boolean
2849 elfNN_ia64_adjust_dynamic_symbol (info, h)
2850 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2851 struct elf_link_hash_entry *h;
2852 {
2853 /* ??? Undefined symbols with PLT entries should be re-defined
2854 to be the PLT entry. */
2855
2856 /* If this is a weak symbol, and there is a real definition, the
2857 processor independent code will have arranged for us to see the
2858 real definition first, and we can just use the same value. */
2859 if (h->weakdef != NULL)
2860 {
2861 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2862 || h->weakdef->root.type == bfd_link_hash_defweak);
2863 h->root.u.def.section = h->weakdef->root.u.def.section;
2864 h->root.u.def.value = h->weakdef->root.u.def.value;
2865 return TRUE;
2866 }
2867
2868 /* If this is a reference to a symbol defined by a dynamic object which
2869 is not a function, we might allocate the symbol in our .dynbss section
2870 and allocate a COPY dynamic relocation.
2871
2872 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2873 of hackery. */
2874
2875 return TRUE;
2876 }
2877
2878 static bfd_boolean
2879 elfNN_ia64_size_dynamic_sections (output_bfd, info)
2880 bfd *output_bfd ATTRIBUTE_UNUSED;
2881 struct bfd_link_info *info;
2882 {
2883 struct elfNN_ia64_allocate_data data;
2884 struct elfNN_ia64_link_hash_table *ia64_info;
2885 asection *sec;
2886 bfd *dynobj;
2887 bfd_boolean relplt = FALSE;
2888
2889 dynobj = elf_hash_table(info)->dynobj;
2890 ia64_info = elfNN_ia64_hash_table (info);
2891 ia64_info->self_dtpmod_offset = (bfd_vma) -1;
2892 BFD_ASSERT(dynobj != NULL);
2893 data.info = info;
2894
2895 /* Set the contents of the .interp section to the interpreter. */
2896 if (ia64_info->root.dynamic_sections_created
2897 && info->executable)
2898 {
2899 sec = bfd_get_section_by_name (dynobj, ".interp");
2900 BFD_ASSERT (sec != NULL);
2901 sec->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
2902 sec->_raw_size = strlen (ELF_DYNAMIC_INTERPRETER) + 1;
2903 }
2904
2905 /* Allocate the GOT entries. */
2906
2907 if (ia64_info->got_sec)
2908 {
2909 data.ofs = 0;
2910 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data);
2911 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data);
2912 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data);
2913 ia64_info->got_sec->_raw_size = data.ofs;
2914 }
2915
2916 /* Allocate the FPTR entries. */
2917
2918 if (ia64_info->fptr_sec)
2919 {
2920 data.ofs = 0;
2921 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_fptr, &data);
2922 ia64_info->fptr_sec->_raw_size = data.ofs;
2923 }
2924
2925 /* Now that we've seen all of the input files, we can decide which
2926 symbols need plt entries. Allocate the minimal PLT entries first.
2927 We do this even though dynamic_sections_created may be FALSE, because
2928 this has the side-effect of clearing want_plt and want_plt2. */
2929
2930 data.ofs = 0;
2931 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_plt_entries, &data);
2932
2933 ia64_info->minplt_entries = 0;
2934 if (data.ofs)
2935 {
2936 ia64_info->minplt_entries
2937 = (data.ofs - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
2938 }
2939
2940 /* Align the pointer for the plt2 entries. */
2941 data.ofs = (data.ofs + 31) & (bfd_vma) -32;
2942
2943 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_plt2_entries, &data);
2944 if (data.ofs != 0 || ia64_info->root.dynamic_sections_created)
2945 {
2946 /* FIXME: we always reserve the memory for dynamic linker even if
2947 there are no PLT entries since dynamic linker may assume the
2948 reserved memory always exists. */
2949
2950 BFD_ASSERT (ia64_info->root.dynamic_sections_created);
2951
2952 ia64_info->plt_sec->_raw_size = data.ofs;
2953
2954 /* If we've got a .plt, we need some extra memory for the dynamic
2955 linker. We stuff these in .got.plt. */
2956 sec = bfd_get_section_by_name (dynobj, ".got.plt");
2957 sec->_raw_size = 8 * PLT_RESERVED_WORDS;
2958 }
2959
2960 /* Allocate the PLTOFF entries. */
2961
2962 if (ia64_info->pltoff_sec)
2963 {
2964 data.ofs = 0;
2965 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_pltoff_entries, &data);
2966 ia64_info->pltoff_sec->_raw_size = data.ofs;
2967 }
2968
2969 if (ia64_info->root.dynamic_sections_created)
2970 {
2971 /* Allocate space for the dynamic relocations that turned out to be
2972 required. */
2973
2974 if (info->shared && ia64_info->self_dtpmod_offset != (bfd_vma) -1)
2975 ia64_info->rel_got_sec->_raw_size += sizeof (ElfNN_External_Rela);
2976 elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries, &data);
2977 }
2978
2979 /* We have now determined the sizes of the various dynamic sections.
2980 Allocate memory for them. */
2981 for (sec = dynobj->sections; sec != NULL; sec = sec->next)
2982 {
2983 bfd_boolean strip;
2984
2985 if (!(sec->flags & SEC_LINKER_CREATED))
2986 continue;
2987
2988 /* If we don't need this section, strip it from the output file.
2989 There were several sections primarily related to dynamic
2990 linking that must be create before the linker maps input
2991 sections to output sections. The linker does that before
2992 bfd_elf_size_dynamic_sections is called, and it is that
2993 function which decides whether anything needs to go into
2994 these sections. */
2995
2996 strip = (sec->_raw_size == 0);
2997
2998 if (sec == ia64_info->got_sec)
2999 strip = FALSE;
3000 else if (sec == ia64_info->rel_got_sec)
3001 {
3002 if (strip)
3003 ia64_info->rel_got_sec = NULL;
3004 else
3005 /* We use the reloc_count field as a counter if we need to
3006 copy relocs into the output file. */
3007 sec->reloc_count = 0;
3008 }
3009 else if (sec == ia64_info->fptr_sec)
3010 {
3011 if (strip)
3012 ia64_info->fptr_sec = NULL;
3013 }
3014 else if (sec == ia64_info->rel_fptr_sec)
3015 {
3016 if (strip)
3017 ia64_info->rel_fptr_sec = NULL;
3018 else
3019 /* We use the reloc_count field as a counter if we need to
3020 copy relocs into the output file. */
3021 sec->reloc_count = 0;
3022 }
3023 else if (sec == ia64_info->plt_sec)
3024 {
3025 if (strip)
3026 ia64_info->plt_sec = NULL;
3027 }
3028 else if (sec == ia64_info->pltoff_sec)
3029 {
3030 if (strip)
3031 ia64_info->pltoff_sec = NULL;
3032 }
3033 else if (sec == ia64_info->rel_pltoff_sec)
3034 {
3035 if (strip)
3036 ia64_info->rel_pltoff_sec = NULL;
3037 else
3038 {
3039 relplt = TRUE;
3040 /* We use the reloc_count field as a counter if we need to
3041 copy relocs into the output file. */
3042 sec->reloc_count = 0;
3043 }
3044 }
3045 else
3046 {
3047 const char *name;
3048
3049 /* It's OK to base decisions on the section name, because none
3050 of the dynobj section names depend upon the input files. */
3051 name = bfd_get_section_name (dynobj, sec);
3052
3053 if (strcmp (name, ".got.plt") == 0)
3054 strip = FALSE;
3055 else if (strncmp (name, ".rel", 4) == 0)
3056 {
3057 if (!strip)
3058 {
3059 /* We use the reloc_count field as a counter if we need to
3060 copy relocs into the output file. */
3061 sec->reloc_count = 0;
3062 }
3063 }
3064 else
3065 continue;
3066 }
3067
3068 if (strip)
3069 _bfd_strip_section_from_output (info, sec);
3070 else
3071 {
3072 /* Allocate memory for the section contents. */
3073 sec->contents = (bfd_byte *) bfd_zalloc (dynobj, sec->_raw_size);
3074 if (sec->contents == NULL && sec->_raw_size != 0)
3075 return FALSE;
3076 }
3077 }
3078
3079 if (elf_hash_table (info)->dynamic_sections_created)
3080 {
3081 /* Add some entries to the .dynamic section. We fill in the values
3082 later (in finish_dynamic_sections) but we must add the entries now
3083 so that we get the correct size for the .dynamic section. */
3084
3085 if (info->executable)
3086 {
3087 /* The DT_DEBUG entry is filled in by the dynamic linker and used
3088 by the debugger. */
3089 #define add_dynamic_entry(TAG, VAL) \
3090 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3091
3092 if (!add_dynamic_entry (DT_DEBUG, 0))
3093 return FALSE;
3094 }
3095
3096 if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE, 0))
3097 return FALSE;
3098 if (!add_dynamic_entry (DT_PLTGOT, 0))
3099 return FALSE;
3100
3101 if (relplt)
3102 {
3103 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3104 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3105 || !add_dynamic_entry (DT_JMPREL, 0))
3106 return FALSE;
3107 }
3108
3109 if (!add_dynamic_entry (DT_RELA, 0)
3110 || !add_dynamic_entry (DT_RELASZ, 0)
3111 || !add_dynamic_entry (DT_RELAENT, sizeof (ElfNN_External_Rela)))
3112 return FALSE;
3113
3114 if (ia64_info->reltext)
3115 {
3116 if (!add_dynamic_entry (DT_TEXTREL, 0))
3117 return FALSE;
3118 info->flags |= DF_TEXTREL;
3119 }
3120 }
3121
3122 /* ??? Perhaps force __gp local. */
3123
3124 return TRUE;
3125 }
3126
3127 static bfd_reloc_status_type
3128 elfNN_ia64_install_value (abfd, hit_addr, v, r_type)
3129 bfd *abfd;
3130 bfd_byte *hit_addr;
3131 bfd_vma v;
3132 unsigned int r_type;
3133 {
3134 const struct ia64_operand *op;
3135 int bigendian = 0, shift = 0;
3136 bfd_vma t0, t1, insn, dword;
3137 enum ia64_opnd opnd;
3138 const char *err;
3139 size_t size = 8;
3140 #ifdef BFD_HOST_U_64_BIT
3141 BFD_HOST_U_64_BIT val = (BFD_HOST_U_64_BIT) v;
3142 #else
3143 bfd_vma val = v;
3144 #endif
3145
3146 opnd = IA64_OPND_NIL;
3147 switch (r_type)
3148 {
3149 case R_IA64_NONE:
3150 case R_IA64_LDXMOV:
3151 return bfd_reloc_ok;
3152
3153 /* Instruction relocations. */
3154
3155 case R_IA64_IMM14:
3156 case R_IA64_TPREL14:
3157 case R_IA64_DTPREL14:
3158 opnd = IA64_OPND_IMM14;
3159 break;
3160
3161 case R_IA64_PCREL21F: opnd = IA64_OPND_TGT25; break;
3162 case R_IA64_PCREL21M: opnd = IA64_OPND_TGT25b; break;
3163 case R_IA64_PCREL60B: opnd = IA64_OPND_TGT64; break;
3164 case R_IA64_PCREL21B:
3165 case R_IA64_PCREL21BI:
3166 opnd = IA64_OPND_TGT25c;
3167 break;
3168
3169 case R_IA64_IMM22:
3170 case R_IA64_GPREL22:
3171 case R_IA64_LTOFF22:
3172 case R_IA64_LTOFF22X:
3173 case R_IA64_PLTOFF22:
3174 case R_IA64_PCREL22:
3175 case R_IA64_LTOFF_FPTR22:
3176 case R_IA64_TPREL22:
3177 case R_IA64_DTPREL22:
3178 case R_IA64_LTOFF_TPREL22:
3179 case R_IA64_LTOFF_DTPMOD22:
3180 case R_IA64_LTOFF_DTPREL22:
3181 opnd = IA64_OPND_IMM22;
3182 break;
3183
3184 case R_IA64_IMM64:
3185 case R_IA64_GPREL64I:
3186 case R_IA64_LTOFF64I:
3187 case R_IA64_PLTOFF64I:
3188 case R_IA64_PCREL64I:
3189 case R_IA64_FPTR64I:
3190 case R_IA64_LTOFF_FPTR64I:
3191 case R_IA64_TPREL64I:
3192 case R_IA64_DTPREL64I:
3193 opnd = IA64_OPND_IMMU64;
3194 break;
3195
3196 /* Data relocations. */
3197
3198 case R_IA64_DIR32MSB:
3199 case R_IA64_GPREL32MSB:
3200 case R_IA64_FPTR32MSB:
3201 case R_IA64_PCREL32MSB:
3202 case R_IA64_LTOFF_FPTR32MSB:
3203 case R_IA64_SEGREL32MSB:
3204 case R_IA64_SECREL32MSB:
3205 case R_IA64_LTV32MSB:
3206 case R_IA64_DTPREL32MSB:
3207 size = 4; bigendian = 1;
3208 break;
3209
3210 case R_IA64_DIR32LSB:
3211 case R_IA64_GPREL32LSB:
3212 case R_IA64_FPTR32LSB:
3213 case R_IA64_PCREL32LSB:
3214 case R_IA64_LTOFF_FPTR32LSB:
3215 case R_IA64_SEGREL32LSB:
3216 case R_IA64_SECREL32LSB:
3217 case R_IA64_LTV32LSB:
3218 case R_IA64_DTPREL32LSB:
3219 size = 4; bigendian = 0;
3220 break;
3221
3222 case R_IA64_DIR64MSB:
3223 case R_IA64_GPREL64MSB:
3224 case R_IA64_PLTOFF64MSB:
3225 case R_IA64_FPTR64MSB:
3226 case R_IA64_PCREL64MSB:
3227 case R_IA64_LTOFF_FPTR64MSB:
3228 case R_IA64_SEGREL64MSB:
3229 case R_IA64_SECREL64MSB:
3230 case R_IA64_LTV64MSB:
3231 case R_IA64_TPREL64MSB:
3232 case R_IA64_DTPMOD64MSB:
3233 case R_IA64_DTPREL64MSB:
3234 size = 8; bigendian = 1;
3235 break;
3236
3237 case R_IA64_DIR64LSB:
3238 case R_IA64_GPREL64LSB:
3239 case R_IA64_PLTOFF64LSB:
3240 case R_IA64_FPTR64LSB:
3241 case R_IA64_PCREL64LSB:
3242 case R_IA64_LTOFF_FPTR64LSB:
3243 case R_IA64_SEGREL64LSB:
3244 case R_IA64_SECREL64LSB:
3245 case R_IA64_LTV64LSB:
3246 case R_IA64_TPREL64LSB:
3247 case R_IA64_DTPMOD64LSB:
3248 case R_IA64_DTPREL64LSB:
3249 size = 8; bigendian = 0;
3250 break;
3251
3252 /* Unsupported / Dynamic relocations. */
3253 default:
3254 return bfd_reloc_notsupported;
3255 }
3256
3257 switch (opnd)
3258 {
3259 case IA64_OPND_IMMU64:
3260 hit_addr -= (long) hit_addr & 0x3;
3261 t0 = bfd_get_64 (abfd, hit_addr);
3262 t1 = bfd_get_64 (abfd, hit_addr + 8);
3263
3264 /* tmpl/s: bits 0.. 5 in t0
3265 slot 0: bits 5..45 in t0
3266 slot 1: bits 46..63 in t0, bits 0..22 in t1
3267 slot 2: bits 23..63 in t1 */
3268
3269 /* First, clear the bits that form the 64 bit constant. */
3270 t0 &= ~(0x3ffffLL << 46);
3271 t1 &= ~(0x7fffffLL
3272 | (( (0x07fLL << 13) | (0x1ffLL << 27)
3273 | (0x01fLL << 22) | (0x001LL << 21)
3274 | (0x001LL << 36)) << 23));
3275
3276 t0 |= ((val >> 22) & 0x03ffffLL) << 46; /* 18 lsbs of imm41 */
3277 t1 |= ((val >> 40) & 0x7fffffLL) << 0; /* 23 msbs of imm41 */
3278 t1 |= ( (((val >> 0) & 0x07f) << 13) /* imm7b */
3279 | (((val >> 7) & 0x1ff) << 27) /* imm9d */
3280 | (((val >> 16) & 0x01f) << 22) /* imm5c */
3281 | (((val >> 21) & 0x001) << 21) /* ic */
3282 | (((val >> 63) & 0x001) << 36)) << 23; /* i */
3283
3284 bfd_put_64 (abfd, t0, hit_addr);
3285 bfd_put_64 (abfd, t1, hit_addr + 8);
3286 break;
3287
3288 case IA64_OPND_TGT64:
3289 hit_addr -= (long) hit_addr & 0x3;
3290 t0 = bfd_get_64 (abfd, hit_addr);
3291 t1 = bfd_get_64 (abfd, hit_addr + 8);
3292
3293 /* tmpl/s: bits 0.. 5 in t0
3294 slot 0: bits 5..45 in t0
3295 slot 1: bits 46..63 in t0, bits 0..22 in t1
3296 slot 2: bits 23..63 in t1 */
3297
3298 /* First, clear the bits that form the 64 bit constant. */
3299 t0 &= ~(0x3ffffLL << 46);
3300 t1 &= ~(0x7fffffLL
3301 | ((1LL << 36 | 0xfffffLL << 13) << 23));
3302
3303 val >>= 4;
3304 t0 |= ((val >> 20) & 0xffffLL) << 2 << 46; /* 16 lsbs of imm39 */
3305 t1 |= ((val >> 36) & 0x7fffffLL) << 0; /* 23 msbs of imm39 */
3306 t1 |= ((((val >> 0) & 0xfffffLL) << 13) /* imm20b */
3307 | (((val >> 59) & 0x1LL) << 36)) << 23; /* i */
3308
3309 bfd_put_64 (abfd, t0, hit_addr);
3310 bfd_put_64 (abfd, t1, hit_addr + 8);
3311 break;
3312
3313 default:
3314 switch ((long) hit_addr & 0x3)
3315 {
3316 case 0: shift = 5; break;
3317 case 1: shift = 14; hit_addr += 3; break;
3318 case 2: shift = 23; hit_addr += 6; break;
3319 case 3: return bfd_reloc_notsupported; /* shouldn't happen... */
3320 }
3321 dword = bfd_get_64 (abfd, hit_addr);
3322 insn = (dword >> shift) & 0x1ffffffffffLL;
3323
3324 op = elf64_ia64_operands + opnd;
3325 err = (*op->insert) (op, val, (ia64_insn *)& insn);
3326 if (err)
3327 return bfd_reloc_overflow;
3328
3329 dword &= ~(0x1ffffffffffLL << shift);
3330 dword |= (insn << shift);
3331 bfd_put_64 (abfd, dword, hit_addr);
3332 break;
3333
3334 case IA64_OPND_NIL:
3335 /* A data relocation. */
3336 if (bigendian)
3337 if (size == 4)
3338 bfd_putb32 (val, hit_addr);
3339 else
3340 bfd_putb64 (val, hit_addr);
3341 else
3342 if (size == 4)
3343 bfd_putl32 (val, hit_addr);
3344 else
3345 bfd_putl64 (val, hit_addr);
3346 break;
3347 }
3348
3349 return bfd_reloc_ok;
3350 }
3351
3352 static void
3353 elfNN_ia64_install_dyn_reloc (abfd, info, sec, srel, offset, type,
3354 dynindx, addend)
3355 bfd *abfd;
3356 struct bfd_link_info *info;
3357 asection *sec;
3358 asection *srel;
3359 bfd_vma offset;
3360 unsigned int type;
3361 long dynindx;
3362 bfd_vma addend;
3363 {
3364 Elf_Internal_Rela outrel;
3365 bfd_byte *loc;
3366
3367 BFD_ASSERT (dynindx != -1);
3368 outrel.r_info = ELFNN_R_INFO (dynindx, type);
3369 outrel.r_addend = addend;
3370 outrel.r_offset = _bfd_elf_section_offset (abfd, info, sec, offset);
3371 if (outrel.r_offset >= (bfd_vma) -2)
3372 {
3373 /* Run for the hills. We shouldn't be outputting a relocation
3374 for this. So do what everyone else does and output a no-op. */
3375 outrel.r_info = ELFNN_R_INFO (0, R_IA64_NONE);
3376 outrel.r_addend = 0;
3377 outrel.r_offset = 0;
3378 }
3379 else
3380 outrel.r_offset += sec->output_section->vma + sec->output_offset;
3381
3382 loc = srel->contents;
3383 loc += srel->reloc_count++ * sizeof (ElfNN_External_Rela);
3384 bfd_elfNN_swap_reloca_out (abfd, &outrel, loc);
3385 BFD_ASSERT (sizeof (ElfNN_External_Rela) * srel->reloc_count
3386 <= srel->_cooked_size);
3387 }
3388
3389 /* Store an entry for target address TARGET_ADDR in the linkage table
3390 and return the gp-relative address of the linkage table entry. */
3391
3392 static bfd_vma
3393 set_got_entry (abfd, info, dyn_i, dynindx, addend, value, dyn_r_type)
3394 bfd *abfd;
3395 struct bfd_link_info *info;
3396 struct elfNN_ia64_dyn_sym_info *dyn_i;
3397 long dynindx;
3398 bfd_vma addend;
3399 bfd_vma value;
3400 unsigned int dyn_r_type;
3401 {
3402 struct elfNN_ia64_link_hash_table *ia64_info;
3403 asection *got_sec;
3404 bfd_boolean done;
3405 bfd_vma got_offset;
3406
3407 ia64_info = elfNN_ia64_hash_table (info);
3408 got_sec = ia64_info->got_sec;
3409
3410 switch (dyn_r_type)
3411 {
3412 case R_IA64_TPREL64LSB:
3413 done = dyn_i->tprel_done;
3414 dyn_i->tprel_done = TRUE;
3415 got_offset = dyn_i->tprel_offset;
3416 break;
3417 case R_IA64_DTPMOD64LSB:
3418 if (dyn_i->dtpmod_offset != ia64_info->self_dtpmod_offset)
3419 {
3420 done = dyn_i->dtpmod_done;
3421 dyn_i->dtpmod_done = TRUE;
3422 }
3423 else
3424 {
3425 done = ia64_info->self_dtpmod_done;
3426 ia64_info->self_dtpmod_done = TRUE;
3427 dynindx = 0;
3428 }
3429 got_offset = dyn_i->dtpmod_offset;
3430 break;
3431 case R_IA64_DTPREL64LSB:
3432 done = dyn_i->dtprel_done;
3433 dyn_i->dtprel_done = TRUE;
3434 got_offset = dyn_i->dtprel_offset;
3435 break;
3436 default:
3437 done = dyn_i->got_done;
3438 dyn_i->got_done = TRUE;
3439 got_offset = dyn_i->got_offset;
3440 break;
3441 }
3442
3443 BFD_ASSERT ((got_offset & 7) == 0);
3444
3445 if (! done)
3446 {
3447 /* Store the target address in the linkage table entry. */
3448 bfd_put_64 (abfd, value, got_sec->contents + got_offset);
3449
3450 /* Install a dynamic relocation if needed. */
3451 if (((info->shared
3452 && (!dyn_i->h
3453 || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
3454 || dyn_i->h->root.type != bfd_link_hash_undefweak)
3455 && dyn_r_type != R_IA64_DTPREL64LSB)
3456 || elfNN_ia64_dynamic_symbol_p (dyn_i->h, info, dyn_r_type)
3457 || (dynindx != -1 && dyn_r_type == R_IA64_FPTR64LSB))
3458 && (!dyn_i->want_ltoff_fptr
3459 || !info->pie
3460 || !dyn_i->h
3461 || dyn_i->h->root.type != bfd_link_hash_undefweak))
3462 {
3463 if (dynindx == -1
3464 && dyn_r_type != R_IA64_TPREL64LSB
3465 && dyn_r_type != R_IA64_DTPMOD64LSB
3466 && dyn_r_type != R_IA64_DTPREL64LSB)
3467 {
3468 dyn_r_type = R_IA64_REL64LSB;
3469 dynindx = 0;
3470 addend = value;
3471 }
3472
3473 if (bfd_big_endian (abfd))
3474 {
3475 switch (dyn_r_type)
3476 {
3477 case R_IA64_REL64LSB:
3478 dyn_r_type = R_IA64_REL64MSB;
3479 break;
3480 case R_IA64_DIR64LSB:
3481 dyn_r_type = R_IA64_DIR64MSB;
3482 break;
3483 case R_IA64_FPTR64LSB:
3484 dyn_r_type = R_IA64_FPTR64MSB;
3485 break;
3486 case R_IA64_TPREL64LSB:
3487 dyn_r_type = R_IA64_TPREL64MSB;
3488 break;
3489 case R_IA64_DTPMOD64LSB:
3490 dyn_r_type = R_IA64_DTPMOD64MSB;
3491 break;
3492 case R_IA64_DTPREL64LSB:
3493 dyn_r_type = R_IA64_DTPREL64MSB;
3494 break;
3495 default:
3496 BFD_ASSERT (FALSE);
3497 break;
3498 }
3499 }
3500
3501 elfNN_ia64_install_dyn_reloc (abfd, NULL, got_sec,
3502 ia64_info->rel_got_sec,
3503 got_offset, dyn_r_type,
3504 dynindx, addend);
3505 }
3506 }
3507
3508 /* Return the address of the linkage table entry. */
3509 value = (got_sec->output_section->vma
3510 + got_sec->output_offset
3511 + got_offset);
3512
3513 return value;
3514 }
3515
3516 /* Fill in a function descriptor consisting of the function's code
3517 address and its global pointer. Return the descriptor's address. */
3518
3519 static bfd_vma
3520 set_fptr_entry (abfd, info, dyn_i, value)
3521 bfd *abfd;
3522 struct bfd_link_info *info;
3523 struct elfNN_ia64_dyn_sym_info *dyn_i;
3524 bfd_vma value;
3525 {
3526 struct elfNN_ia64_link_hash_table *ia64_info;
3527 asection *fptr_sec;
3528
3529 ia64_info = elfNN_ia64_hash_table (info);
3530 fptr_sec = ia64_info->fptr_sec;
3531
3532 if (!dyn_i->fptr_done)
3533 {
3534 dyn_i->fptr_done = 1;
3535
3536 /* Fill in the function descriptor. */
3537 bfd_put_64 (abfd, value, fptr_sec->contents + dyn_i->fptr_offset);
3538 bfd_put_64 (abfd, _bfd_get_gp_value (abfd),
3539 fptr_sec->contents + dyn_i->fptr_offset + 8);
3540 if (ia64_info->rel_fptr_sec)
3541 {
3542 Elf_Internal_Rela outrel;
3543 bfd_byte *loc;
3544
3545 if (bfd_little_endian (abfd))
3546 outrel.r_info = ELFNN_R_INFO (0, R_IA64_IPLTLSB);
3547 else
3548 outrel.r_info = ELFNN_R_INFO (0, R_IA64_IPLTMSB);
3549 outrel.r_addend = value;
3550 outrel.r_offset = (fptr_sec->output_section->vma
3551 + fptr_sec->output_offset
3552 + dyn_i->fptr_offset);
3553 loc = ia64_info->rel_fptr_sec->contents;
3554 loc += ia64_info->rel_fptr_sec->reloc_count++
3555 * sizeof (ElfNN_External_Rela);
3556 bfd_elfNN_swap_reloca_out (abfd, &outrel, loc);
3557 }
3558 }
3559
3560 /* Return the descriptor's address. */
3561 value = (fptr_sec->output_section->vma
3562 + fptr_sec->output_offset
3563 + dyn_i->fptr_offset);
3564
3565 return value;
3566 }
3567
3568 /* Fill in a PLTOFF entry consisting of the function's code address
3569 and its global pointer. Return the descriptor's address. */
3570
3571 static bfd_vma
3572 set_pltoff_entry (abfd, info, dyn_i, value, is_plt)
3573 bfd *abfd;
3574 struct bfd_link_info *info;
3575 struct elfNN_ia64_dyn_sym_info *dyn_i;
3576 bfd_vma value;
3577 bfd_boolean is_plt;
3578 {
3579 struct elfNN_ia64_link_hash_table *ia64_info;
3580 asection *pltoff_sec;
3581
3582 ia64_info = elfNN_ia64_hash_table (info);
3583 pltoff_sec = ia64_info->pltoff_sec;
3584
3585 /* Don't do anything if this symbol uses a real PLT entry. In
3586 that case, we'll fill this in during finish_dynamic_symbol. */
3587 if ((! dyn_i->want_plt || is_plt)
3588 && !dyn_i->pltoff_done)
3589 {
3590 bfd_vma gp = _bfd_get_gp_value (abfd);
3591
3592 /* Fill in the function descriptor. */
3593 bfd_put_64 (abfd, value, pltoff_sec->contents + dyn_i->pltoff_offset);
3594 bfd_put_64 (abfd, gp, pltoff_sec->contents + dyn_i->pltoff_offset + 8);
3595
3596 /* Install dynamic relocations if needed. */
3597 if (!is_plt
3598 && info->shared
3599 && (!dyn_i->h
3600 || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
3601 || dyn_i->h->root.type != bfd_link_hash_undefweak))
3602 {
3603 unsigned int dyn_r_type;
3604
3605 if (bfd_big_endian (abfd))
3606 dyn_r_type = R_IA64_REL64MSB;
3607 else
3608 dyn_r_type = R_IA64_REL64LSB;
3609
3610 elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
3611 ia64_info->rel_pltoff_sec,
3612 dyn_i->pltoff_offset,
3613 dyn_r_type, 0, value);
3614 elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
3615 ia64_info->rel_pltoff_sec,
3616 dyn_i->pltoff_offset + 8,
3617 dyn_r_type, 0, gp);
3618 }
3619
3620 dyn_i->pltoff_done = 1;
3621 }
3622
3623 /* Return the descriptor's address. */
3624 value = (pltoff_sec->output_section->vma
3625 + pltoff_sec->output_offset
3626 + dyn_i->pltoff_offset);
3627
3628 return value;
3629 }
3630
3631 /* Return the base VMA address which should be subtracted from real addresses
3632 when resolving @tprel() relocation.
3633 Main program TLS (whose template starts at PT_TLS p_vaddr)
3634 is assigned offset round(16, PT_TLS p_align). */
3635
3636 static bfd_vma
3637 elfNN_ia64_tprel_base (info)
3638 struct bfd_link_info *info;
3639 {
3640 asection *tls_sec = elf_hash_table (info)->tls_sec;
3641
3642 BFD_ASSERT (tls_sec != NULL);
3643 return tls_sec->vma - align_power ((bfd_vma) 16, tls_sec->alignment_power);
3644 }
3645
3646 /* Return the base VMA address which should be subtracted from real addresses
3647 when resolving @dtprel() relocation.
3648 This is PT_TLS segment p_vaddr. */
3649
3650 static bfd_vma
3651 elfNN_ia64_dtprel_base (info)
3652 struct bfd_link_info *info;
3653 {
3654 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
3655 return elf_hash_table (info)->tls_sec->vma;
3656 }
3657
3658 /* Called through qsort to sort the .IA_64.unwind section during a
3659 non-relocatable link. Set elfNN_ia64_unwind_entry_compare_bfd
3660 to the output bfd so we can do proper endianness frobbing. */
3661
3662 static bfd *elfNN_ia64_unwind_entry_compare_bfd;
3663
3664 static int
3665 elfNN_ia64_unwind_entry_compare (a, b)
3666 const PTR a;
3667 const PTR b;
3668 {
3669 bfd_vma av, bv;
3670
3671 av = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, a);
3672 bv = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, b);
3673
3674 return (av < bv ? -1 : av > bv ? 1 : 0);
3675 }
3676
3677 /* Make sure we've got ourselves a nice fat __gp value. */
3678 static bfd_boolean
3679 elfNN_ia64_choose_gp (abfd, info)
3680 bfd *abfd;
3681 struct bfd_link_info *info;
3682 {
3683 bfd_vma min_vma = (bfd_vma) -1, max_vma = 0;
3684 bfd_vma min_short_vma = min_vma, max_short_vma = 0;
3685 struct elf_link_hash_entry *gp;
3686 bfd_vma gp_val;
3687 asection *os;
3688 struct elfNN_ia64_link_hash_table *ia64_info;
3689
3690 ia64_info = elfNN_ia64_hash_table (info);
3691
3692 /* Find the min and max vma of all sections marked short. Also collect
3693 min and max vma of any type, for use in selecting a nice gp. */
3694 for (os = abfd->sections; os ; os = os->next)
3695 {
3696 bfd_vma lo, hi;
3697
3698 if ((os->flags & SEC_ALLOC) == 0)
3699 continue;
3700
3701 lo = os->vma;
3702 hi = os->vma + os->_raw_size;
3703 if (hi < lo)
3704 hi = (bfd_vma) -1;
3705
3706 if (min_vma > lo)
3707 min_vma = lo;
3708 if (max_vma < hi)
3709 max_vma = hi;
3710 if (os->flags & SEC_SMALL_DATA)
3711 {
3712 if (min_short_vma > lo)
3713 min_short_vma = lo;
3714 if (max_short_vma < hi)
3715 max_short_vma = hi;
3716 }
3717 }
3718
3719 /* See if the user wants to force a value. */
3720 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
3721 FALSE, FALSE);
3722
3723 if (gp
3724 && (gp->root.type == bfd_link_hash_defined
3725 || gp->root.type == bfd_link_hash_defweak))
3726 {
3727 asection *gp_sec = gp->root.u.def.section;
3728 gp_val = (gp->root.u.def.value
3729 + gp_sec->output_section->vma
3730 + gp_sec->output_offset);
3731 }
3732 else
3733 {
3734 /* Pick a sensible value. */
3735
3736 asection *got_sec = ia64_info->got_sec;
3737
3738 /* Start with just the address of the .got. */
3739 if (got_sec)
3740 gp_val = got_sec->output_section->vma;
3741 else if (max_short_vma != 0)
3742 gp_val = min_short_vma;
3743 else
3744 gp_val = min_vma;
3745
3746 /* If it is possible to address the entire image, but we
3747 don't with the choice above, adjust. */
3748 if (max_vma - min_vma < 0x400000
3749 && max_vma - gp_val <= 0x200000
3750 && gp_val - min_vma > 0x200000)
3751 gp_val = min_vma + 0x200000;
3752 else if (max_short_vma != 0)
3753 {
3754 /* If we don't cover all the short data, adjust. */
3755 if (max_short_vma - gp_val >= 0x200000)
3756 gp_val = min_short_vma + 0x200000;
3757
3758 /* If we're addressing stuff past the end, adjust back. */
3759 if (gp_val > max_vma)
3760 gp_val = max_vma - 0x200000 + 8;
3761 }
3762 }
3763
3764 /* Validate whether all SHF_IA_64_SHORT sections are within
3765 range of the chosen GP. */
3766
3767 if (max_short_vma != 0)
3768 {
3769 if (max_short_vma - min_short_vma >= 0x400000)
3770 {
3771 (*_bfd_error_handler)
3772 (_("%s: short data segment overflowed (0x%lx >= 0x400000)"),
3773 bfd_get_filename (abfd),
3774 (unsigned long) (max_short_vma - min_short_vma));
3775 return FALSE;
3776 }
3777 else if ((gp_val > min_short_vma
3778 && gp_val - min_short_vma > 0x200000)
3779 || (gp_val < max_short_vma
3780 && max_short_vma - gp_val >= 0x200000))
3781 {
3782 (*_bfd_error_handler)
3783 (_("%s: __gp does not cover short data segment"),
3784 bfd_get_filename (abfd));
3785 return FALSE;
3786 }
3787 }
3788
3789 _bfd_set_gp_value (abfd, gp_val);
3790
3791 return TRUE;
3792 }
3793
3794 static bfd_boolean
3795 elfNN_ia64_final_link (abfd, info)
3796 bfd *abfd;
3797 struct bfd_link_info *info;
3798 {
3799 struct elfNN_ia64_link_hash_table *ia64_info;
3800 asection *unwind_output_sec;
3801
3802 ia64_info = elfNN_ia64_hash_table (info);
3803
3804 /* Make sure we've got ourselves a nice fat __gp value. */
3805 if (!info->relocatable)
3806 {
3807 bfd_vma gp_val = _bfd_get_gp_value (abfd);
3808 struct elf_link_hash_entry *gp;
3809
3810 if (gp_val == 0)
3811 {
3812 if (! elfNN_ia64_choose_gp (abfd, info))
3813 return FALSE;
3814 gp_val = _bfd_get_gp_value (abfd);
3815 }
3816
3817 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
3818 FALSE, FALSE);
3819 if (gp)
3820 {
3821 gp->root.type = bfd_link_hash_defined;
3822 gp->root.u.def.value = gp_val;
3823 gp->root.u.def.section = bfd_abs_section_ptr;
3824 }
3825 }
3826
3827 /* If we're producing a final executable, we need to sort the contents
3828 of the .IA_64.unwind section. Force this section to be relocated
3829 into memory rather than written immediately to the output file. */
3830 unwind_output_sec = NULL;
3831 if (!info->relocatable)
3832 {
3833 asection *s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind);
3834 if (s)
3835 {
3836 unwind_output_sec = s->output_section;
3837 unwind_output_sec->contents
3838 = bfd_malloc (unwind_output_sec->_raw_size);
3839 if (unwind_output_sec->contents == NULL)
3840 return FALSE;
3841 }
3842 }
3843
3844 /* Invoke the regular ELF backend linker to do all the work. */
3845 if (!bfd_elf_final_link (abfd, info))
3846 return FALSE;
3847
3848 if (unwind_output_sec)
3849 {
3850 elfNN_ia64_unwind_entry_compare_bfd = abfd;
3851 qsort (unwind_output_sec->contents,
3852 (size_t) (unwind_output_sec->_raw_size / 24),
3853 24,
3854 elfNN_ia64_unwind_entry_compare);
3855
3856 if (! bfd_set_section_contents (abfd, unwind_output_sec,
3857 unwind_output_sec->contents, (bfd_vma) 0,
3858 unwind_output_sec->_raw_size))
3859 return FALSE;
3860 }
3861
3862 return TRUE;
3863 }
3864
3865 static bfd_boolean
3866 elfNN_ia64_relocate_section (output_bfd, info, input_bfd, input_section,
3867 contents, relocs, local_syms, local_sections)
3868 bfd *output_bfd;
3869 struct bfd_link_info *info;
3870 bfd *input_bfd;
3871 asection *input_section;
3872 bfd_byte *contents;
3873 Elf_Internal_Rela *relocs;
3874 Elf_Internal_Sym *local_syms;
3875 asection **local_sections;
3876 {
3877 struct elfNN_ia64_link_hash_table *ia64_info;
3878 Elf_Internal_Shdr *symtab_hdr;
3879 Elf_Internal_Rela *rel;
3880 Elf_Internal_Rela *relend;
3881 asection *srel;
3882 bfd_boolean ret_val = TRUE; /* for non-fatal errors */
3883 bfd_vma gp_val;
3884
3885 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3886 ia64_info = elfNN_ia64_hash_table (info);
3887
3888 /* Infect various flags from the input section to the output section. */
3889 if (info->relocatable)
3890 {
3891 bfd_vma flags;
3892
3893 flags = elf_section_data(input_section)->this_hdr.sh_flags;
3894 flags &= SHF_IA_64_NORECOV;
3895
3896 elf_section_data(input_section->output_section)
3897 ->this_hdr.sh_flags |= flags;
3898 return TRUE;
3899 }
3900
3901 gp_val = _bfd_get_gp_value (output_bfd);
3902 srel = get_reloc_section (input_bfd, ia64_info, input_section, FALSE);
3903
3904 rel = relocs;
3905 relend = relocs + input_section->reloc_count;
3906 for (; rel < relend; ++rel)
3907 {
3908 struct elf_link_hash_entry *h;
3909 struct elfNN_ia64_dyn_sym_info *dyn_i;
3910 bfd_reloc_status_type r;
3911 reloc_howto_type *howto;
3912 unsigned long r_symndx;
3913 Elf_Internal_Sym *sym;
3914 unsigned int r_type;
3915 bfd_vma value;
3916 asection *sym_sec;
3917 bfd_byte *hit_addr;
3918 bfd_boolean dynamic_symbol_p;
3919 bfd_boolean undef_weak_ref;
3920
3921 r_type = ELFNN_R_TYPE (rel->r_info);
3922 if (r_type > R_IA64_MAX_RELOC_CODE)
3923 {
3924 (*_bfd_error_handler)
3925 (_("%s: unknown relocation type %d"),
3926 bfd_archive_filename (input_bfd), (int)r_type);
3927 bfd_set_error (bfd_error_bad_value);
3928 ret_val = FALSE;
3929 continue;
3930 }
3931
3932 howto = lookup_howto (r_type);
3933 r_symndx = ELFNN_R_SYM (rel->r_info);
3934 h = NULL;
3935 sym = NULL;
3936 sym_sec = NULL;
3937 undef_weak_ref = FALSE;
3938
3939 if (r_symndx < symtab_hdr->sh_info)
3940 {
3941 /* Reloc against local symbol. */
3942 asection *msec;
3943 sym = local_syms + r_symndx;
3944 sym_sec = local_sections[r_symndx];
3945 msec = sym_sec;
3946 value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
3947 if ((sym_sec->flags & SEC_MERGE)
3948 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
3949 && sym_sec->sec_info_type == ELF_INFO_TYPE_MERGE)
3950 {
3951 struct elfNN_ia64_local_hash_entry *loc_h;
3952
3953 loc_h = get_local_sym_hash (ia64_info, input_bfd, rel, FALSE);
3954 if (loc_h && ! loc_h->sec_merge_done)
3955 {
3956 struct elfNN_ia64_dyn_sym_info *dynent;
3957
3958 for (dynent = loc_h->info; dynent; dynent = dynent->next)
3959 {
3960 msec = sym_sec;
3961 dynent->addend =
3962 _bfd_merged_section_offset (output_bfd, &msec,
3963 elf_section_data (msec)->
3964 sec_info,
3965 sym->st_value
3966 + dynent->addend,
3967 (bfd_vma) 0);
3968 dynent->addend -= sym->st_value;
3969 dynent->addend += msec->output_section->vma
3970 + msec->output_offset
3971 - sym_sec->output_section->vma
3972 - sym_sec->output_offset;
3973 }
3974 loc_h->sec_merge_done = 1;
3975 }
3976 }
3977 }
3978 else
3979 {
3980 bfd_boolean unresolved_reloc;
3981 bfd_boolean warned;
3982 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
3983
3984 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3985 r_symndx, symtab_hdr, sym_hashes,
3986 h, sym_sec, value,
3987 unresolved_reloc, warned);
3988
3989 if (h->root.type == bfd_link_hash_undefweak)
3990 undef_weak_ref = TRUE;
3991 else if (warned)
3992 continue;
3993 }
3994
3995 hit_addr = contents + rel->r_offset;
3996 value += rel->r_addend;
3997 dynamic_symbol_p = elfNN_ia64_dynamic_symbol_p (h, info, r_type);
3998
3999 switch (r_type)
4000 {
4001 case R_IA64_NONE:
4002 case R_IA64_LDXMOV:
4003 continue;
4004
4005 case R_IA64_IMM14:
4006 case R_IA64_IMM22:
4007 case R_IA64_IMM64:
4008 case R_IA64_DIR32MSB:
4009 case R_IA64_DIR32LSB:
4010 case R_IA64_DIR64MSB:
4011 case R_IA64_DIR64LSB:
4012 /* Install a dynamic relocation for this reloc. */
4013 if ((dynamic_symbol_p || info->shared)
4014 && r_symndx != 0
4015 && (input_section->flags & SEC_ALLOC) != 0)
4016 {
4017 unsigned int dyn_r_type;
4018 long dynindx;
4019 bfd_vma addend;
4020
4021 BFD_ASSERT (srel != NULL);
4022
4023 switch (r_type)
4024 {
4025 case R_IA64_IMM14:
4026 case R_IA64_IMM22:
4027 case R_IA64_IMM64:
4028 /* ??? People shouldn't be doing non-pic code in
4029 shared libraries nor dynamic executables. */
4030 (*_bfd_error_handler)
4031 (_("%s: non-pic code with imm relocation against dynamic symbol `%s'"),
4032 bfd_archive_filename (input_bfd),
4033 h->root.root.string);
4034 ret_val = FALSE;
4035 continue;
4036
4037 default:
4038 break;
4039 }
4040
4041 /* If we don't need dynamic symbol lookup, find a
4042 matching RELATIVE relocation. */
4043 dyn_r_type = r_type;
4044 if (dynamic_symbol_p)
4045 {
4046 dynindx = h->dynindx;
4047 addend = rel->r_addend;
4048 value = 0;
4049 }
4050 else
4051 {
4052 switch (r_type)
4053 {
4054 case R_IA64_DIR32MSB:
4055 dyn_r_type = R_IA64_REL32MSB;
4056 break;
4057 case R_IA64_DIR32LSB:
4058 dyn_r_type = R_IA64_REL32LSB;
4059 break;
4060 case R_IA64_DIR64MSB:
4061 dyn_r_type = R_IA64_REL64MSB;
4062 break;
4063 case R_IA64_DIR64LSB:
4064 dyn_r_type = R_IA64_REL64LSB;
4065 break;
4066
4067 default:
4068 break;
4069 }
4070 dynindx = 0;
4071 addend = value;
4072 }
4073
4074 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4075 srel, rel->r_offset, dyn_r_type,
4076 dynindx, addend);
4077 }
4078 /* Fall through. */
4079
4080 case R_IA64_LTV32MSB:
4081 case R_IA64_LTV32LSB:
4082 case R_IA64_LTV64MSB:
4083 case R_IA64_LTV64LSB:
4084 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4085 break;
4086
4087 case R_IA64_GPREL22:
4088 case R_IA64_GPREL64I:
4089 case R_IA64_GPREL32MSB:
4090 case R_IA64_GPREL32LSB:
4091 case R_IA64_GPREL64MSB:
4092 case R_IA64_GPREL64LSB:
4093 if (dynamic_symbol_p)
4094 {
4095 (*_bfd_error_handler)
4096 (_("%s: @gprel relocation against dynamic symbol %s"),
4097 bfd_archive_filename (input_bfd), h->root.root.string);
4098 ret_val = FALSE;
4099 continue;
4100 }
4101 value -= gp_val;
4102 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4103 break;
4104
4105 case R_IA64_LTOFF22:
4106 case R_IA64_LTOFF22X:
4107 case R_IA64_LTOFF64I:
4108 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4109 value = set_got_entry (input_bfd, info, dyn_i, (h ? h->dynindx : -1),
4110 rel->r_addend, value, R_IA64_DIR64LSB);
4111 value -= gp_val;
4112 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4113 break;
4114
4115 case R_IA64_PLTOFF22:
4116 case R_IA64_PLTOFF64I:
4117 case R_IA64_PLTOFF64MSB:
4118 case R_IA64_PLTOFF64LSB:
4119 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4120 value = set_pltoff_entry (output_bfd, info, dyn_i, value, FALSE);
4121 value -= gp_val;
4122 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4123 break;
4124
4125 case R_IA64_FPTR64I:
4126 case R_IA64_FPTR32MSB:
4127 case R_IA64_FPTR32LSB:
4128 case R_IA64_FPTR64MSB:
4129 case R_IA64_FPTR64LSB:
4130 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4131 if (dyn_i->want_fptr)
4132 {
4133 if (!undef_weak_ref)
4134 value = set_fptr_entry (output_bfd, info, dyn_i, value);
4135 }
4136 if (!dyn_i->want_fptr || info->pie)
4137 {
4138 long dynindx;
4139 unsigned int dyn_r_type = r_type;
4140 bfd_vma addend = rel->r_addend;
4141
4142 /* Otherwise, we expect the dynamic linker to create
4143 the entry. */
4144
4145 if (dyn_i->want_fptr)
4146 {
4147 if (r_type == R_IA64_FPTR64I)
4148 {
4149 /* We can't represent this without a dynamic symbol.
4150 Adjust the relocation to be against an output
4151 section symbol, which are always present in the
4152 dynamic symbol table. */
4153 /* ??? People shouldn't be doing non-pic code in
4154 shared libraries. Hork. */
4155 (*_bfd_error_handler)
4156 (_("%s: linking non-pic code in a position independent executable"),
4157 bfd_archive_filename (input_bfd));
4158 ret_val = FALSE;
4159 continue;
4160 }
4161 dynindx = 0;
4162 addend = value;
4163 dyn_r_type = r_type + R_IA64_REL64LSB - R_IA64_FPTR64LSB;
4164 }
4165 else if (h)
4166 {
4167 if (h->dynindx != -1)
4168 dynindx = h->dynindx;
4169 else
4170 dynindx = (_bfd_elf_link_lookup_local_dynindx
4171 (info, h->root.u.def.section->owner,
4172 global_sym_index (h)));
4173 value = 0;
4174 }
4175 else
4176 {
4177 dynindx = (_bfd_elf_link_lookup_local_dynindx
4178 (info, input_bfd, (long) r_symndx));
4179 value = 0;
4180 }
4181
4182 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4183 srel, rel->r_offset, dyn_r_type,
4184 dynindx, addend);
4185 }
4186
4187 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4188 break;
4189
4190 case R_IA64_LTOFF_FPTR22:
4191 case R_IA64_LTOFF_FPTR64I:
4192 case R_IA64_LTOFF_FPTR32MSB:
4193 case R_IA64_LTOFF_FPTR32LSB:
4194 case R_IA64_LTOFF_FPTR64MSB:
4195 case R_IA64_LTOFF_FPTR64LSB:
4196 {
4197 long dynindx;
4198
4199 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4200 if (dyn_i->want_fptr)
4201 {
4202 BFD_ASSERT (h == NULL || h->dynindx == -1)
4203 if (!undef_weak_ref)
4204 value = set_fptr_entry (output_bfd, info, dyn_i, value);
4205 dynindx = -1;
4206 }
4207 else
4208 {
4209 /* Otherwise, we expect the dynamic linker to create
4210 the entry. */
4211 if (h)
4212 {
4213 if (h->dynindx != -1)
4214 dynindx = h->dynindx;
4215 else
4216 dynindx = (_bfd_elf_link_lookup_local_dynindx
4217 (info, h->root.u.def.section->owner,
4218 global_sym_index (h)));
4219 }
4220 else
4221 dynindx = (_bfd_elf_link_lookup_local_dynindx
4222 (info, input_bfd, (long) r_symndx));
4223 value = 0;
4224 }
4225
4226 value = set_got_entry (output_bfd, info, dyn_i, dynindx,
4227 rel->r_addend, value, R_IA64_FPTR64LSB);
4228 value -= gp_val;
4229 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4230 }
4231 break;
4232
4233 case R_IA64_PCREL32MSB:
4234 case R_IA64_PCREL32LSB:
4235 case R_IA64_PCREL64MSB:
4236 case R_IA64_PCREL64LSB:
4237 /* Install a dynamic relocation for this reloc. */
4238 if (dynamic_symbol_p && r_symndx != 0)
4239 {
4240 BFD_ASSERT (srel != NULL);
4241
4242 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4243 srel, rel->r_offset, r_type,
4244 h->dynindx, rel->r_addend);
4245 }
4246 goto finish_pcrel;
4247
4248 case R_IA64_PCREL21B:
4249 case R_IA64_PCREL60B:
4250 /* We should have created a PLT entry for any dynamic symbol. */
4251 dyn_i = NULL;
4252 if (h)
4253 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE);
4254
4255 if (dyn_i && dyn_i->want_plt2)
4256 {
4257 /* Should have caught this earlier. */
4258 BFD_ASSERT (rel->r_addend == 0);
4259
4260 value = (ia64_info->plt_sec->output_section->vma
4261 + ia64_info->plt_sec->output_offset
4262 + dyn_i->plt2_offset);
4263 }
4264 else
4265 {
4266 /* Since there's no PLT entry, Validate that this is
4267 locally defined. */
4268 BFD_ASSERT (undef_weak_ref || sym_sec->output_section != NULL);
4269
4270 /* If the symbol is undef_weak, we shouldn't be trying
4271 to call it. There's every chance that we'd wind up
4272 with an out-of-range fixup here. Don't bother setting
4273 any value at all. */
4274 if (undef_weak_ref)
4275 continue;
4276 }
4277 goto finish_pcrel;
4278
4279 case R_IA64_PCREL21BI:
4280 case R_IA64_PCREL21F:
4281 case R_IA64_PCREL21M:
4282 case R_IA64_PCREL22:
4283 case R_IA64_PCREL64I:
4284 /* The PCREL21BI reloc is specifically not intended for use with
4285 dynamic relocs. PCREL21F and PCREL21M are used for speculation
4286 fixup code, and thus probably ought not be dynamic. The
4287 PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs. */
4288 if (dynamic_symbol_p)
4289 {
4290 const char *msg;
4291
4292 if (r_type == R_IA64_PCREL21BI)
4293 msg = _("%s: @internal branch to dynamic symbol %s");
4294 else if (r_type == R_IA64_PCREL21F || r_type == R_IA64_PCREL21M)
4295 msg = _("%s: speculation fixup to dynamic symbol %s");
4296 else
4297 msg = _("%s: @pcrel relocation against dynamic symbol %s");
4298 (*_bfd_error_handler) (msg, bfd_archive_filename (input_bfd),
4299 h->root.root.string);
4300 ret_val = FALSE;
4301 continue;
4302 }
4303 goto finish_pcrel;
4304
4305 finish_pcrel:
4306 /* Make pc-relative. */
4307 value -= (input_section->output_section->vma
4308 + input_section->output_offset
4309 + rel->r_offset) & ~ (bfd_vma) 0x3;
4310 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4311 break;
4312
4313 case R_IA64_SEGREL32MSB:
4314 case R_IA64_SEGREL32LSB:
4315 case R_IA64_SEGREL64MSB:
4316 case R_IA64_SEGREL64LSB:
4317 if (r_symndx == 0)
4318 {
4319 /* If the input section was discarded from the output, then
4320 do nothing. */
4321 r = bfd_reloc_ok;
4322 }
4323 else
4324 {
4325 struct elf_segment_map *m;
4326 Elf_Internal_Phdr *p;
4327
4328 /* Find the segment that contains the output_section. */
4329 for (m = elf_tdata (output_bfd)->segment_map,
4330 p = elf_tdata (output_bfd)->phdr;
4331 m != NULL;
4332 m = m->next, p++)
4333 {
4334 int i;
4335 for (i = m->count - 1; i >= 0; i--)
4336 if (m->sections[i] == input_section->output_section)
4337 break;
4338 if (i >= 0)
4339 break;
4340 }
4341
4342 if (m == NULL)
4343 {
4344 r = bfd_reloc_notsupported;
4345 }
4346 else
4347 {
4348 /* The VMA of the segment is the vaddr of the associated
4349 program header. */
4350 if (value > p->p_vaddr)
4351 value -= p->p_vaddr;
4352 else
4353 value = 0;
4354 r = elfNN_ia64_install_value (output_bfd, hit_addr, value,
4355 r_type);
4356 }
4357 break;
4358 }
4359
4360 case R_IA64_SECREL32MSB:
4361 case R_IA64_SECREL32LSB:
4362 case R_IA64_SECREL64MSB:
4363 case R_IA64_SECREL64LSB:
4364 /* Make output-section relative. */
4365 if (value > input_section->output_section->vma)
4366 value -= input_section->output_section->vma;
4367 else
4368 value = 0;
4369 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4370 break;
4371
4372 case R_IA64_IPLTMSB:
4373 case R_IA64_IPLTLSB:
4374 /* Install a dynamic relocation for this reloc. */
4375 if ((dynamic_symbol_p || info->shared)
4376 && (input_section->flags & SEC_ALLOC) != 0)
4377 {
4378 BFD_ASSERT (srel != NULL);
4379
4380 /* If we don't need dynamic symbol lookup, install two
4381 RELATIVE relocations. */
4382 if (!dynamic_symbol_p)
4383 {
4384 unsigned int dyn_r_type;
4385
4386 if (r_type == R_IA64_IPLTMSB)
4387 dyn_r_type = R_IA64_REL64MSB;
4388 else
4389 dyn_r_type = R_IA64_REL64LSB;
4390
4391 elfNN_ia64_install_dyn_reloc (output_bfd, info,
4392 input_section,
4393 srel, rel->r_offset,
4394 dyn_r_type, 0, value);
4395 elfNN_ia64_install_dyn_reloc (output_bfd, info,
4396 input_section,
4397 srel, rel->r_offset + 8,
4398 dyn_r_type, 0, gp_val);
4399 }
4400 else
4401 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4402 srel, rel->r_offset, r_type,
4403 h->dynindx, rel->r_addend);
4404 }
4405
4406 if (r_type == R_IA64_IPLTMSB)
4407 r_type = R_IA64_DIR64MSB;
4408 else
4409 r_type = R_IA64_DIR64LSB;
4410 elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4411 r = elfNN_ia64_install_value (output_bfd, hit_addr + 8, gp_val,
4412 r_type);
4413 break;
4414
4415 case R_IA64_TPREL14:
4416 case R_IA64_TPREL22:
4417 case R_IA64_TPREL64I:
4418 value -= elfNN_ia64_tprel_base (info);
4419 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4420 break;
4421
4422 case R_IA64_DTPREL14:
4423 case R_IA64_DTPREL22:
4424 case R_IA64_DTPREL64I:
4425 case R_IA64_DTPREL64LSB:
4426 case R_IA64_DTPREL64MSB:
4427 value -= elfNN_ia64_dtprel_base (info);
4428 r = elfNN_ia64_install_value (output_bfd, hit_addr, value, r_type);
4429 break;
4430
4431 case R_IA64_LTOFF_TPREL22:
4432 case R_IA64_LTOFF_DTPMOD22:
4433 case R_IA64_LTOFF_DTPREL22:
4434 {
4435 int got_r_type;
4436 long dynindx = h ? h->dynindx : -1;
4437 bfd_vma r_addend = rel->r_addend;
4438
4439 switch (r_type)
4440 {
4441 default:
4442 case R_IA64_LTOFF_TPREL22:
4443 if (!dynamic_symbol_p)
4444 {
4445 if (!info->shared)
4446 value -= elfNN_ia64_tprel_base (info);
4447 else
4448 {
4449 r_addend += value - elfNN_ia64_dtprel_base (info);
4450 dynindx = 0;
4451 }
4452 }
4453 got_r_type = R_IA64_TPREL64LSB;
4454 break;
4455 case R_IA64_LTOFF_DTPMOD22:
4456 if (!dynamic_symbol_p && !info->shared)
4457 value = 1;
4458 got_r_type = R_IA64_DTPMOD64LSB;
4459 break;
4460 case R_IA64_LTOFF_DTPREL22:
4461 if (!dynamic_symbol_p)
4462 value -= elfNN_ia64_dtprel_base (info);
4463 got_r_type = R_IA64_DTPREL64LSB;
4464 break;
4465 }
4466 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4467 value = set_got_entry (input_bfd, info, dyn_i, dynindx, r_addend,
4468 value, got_r_type);
4469 value -= gp_val;
4470 r = elfNN_ia64_install_value (output_bfd, hit_addr, value,
4471 r_type);
4472 }
4473 break;
4474
4475 default:
4476 r = bfd_reloc_notsupported;
4477 break;
4478 }
4479
4480 switch (r)
4481 {
4482 case bfd_reloc_ok:
4483 break;
4484
4485 case bfd_reloc_undefined:
4486 /* This can happen for global table relative relocs if
4487 __gp is undefined. This is a panic situation so we
4488 don't try to continue. */
4489 (*info->callbacks->undefined_symbol)
4490 (info, "__gp", input_bfd, input_section, rel->r_offset, 1);
4491 return FALSE;
4492
4493 case bfd_reloc_notsupported:
4494 {
4495 const char *name;
4496
4497 if (h)
4498 name = h->root.root.string;
4499 else
4500 {
4501 name = bfd_elf_string_from_elf_section (input_bfd,
4502 symtab_hdr->sh_link,
4503 sym->st_name);
4504 if (name == NULL)
4505 return FALSE;
4506 if (*name == '\0')
4507 name = bfd_section_name (input_bfd, input_section);
4508 }
4509 if (!(*info->callbacks->warning) (info, _("unsupported reloc"),
4510 name, input_bfd,
4511 input_section, rel->r_offset))
4512 return FALSE;
4513 ret_val = FALSE;
4514 }
4515 break;
4516
4517 case bfd_reloc_dangerous:
4518 case bfd_reloc_outofrange:
4519 case bfd_reloc_overflow:
4520 default:
4521 {
4522 const char *name;
4523
4524 if (h)
4525 name = h->root.root.string;
4526 else
4527 {
4528 name = bfd_elf_string_from_elf_section (input_bfd,
4529 symtab_hdr->sh_link,
4530 sym->st_name);
4531 if (name == NULL)
4532 return FALSE;
4533 if (*name == '\0')
4534 name = bfd_section_name (input_bfd, input_section);
4535 }
4536 if (!(*info->callbacks->reloc_overflow) (info, name,
4537 howto->name,
4538 (bfd_vma) 0,
4539 input_bfd,
4540 input_section,
4541 rel->r_offset))
4542 return FALSE;
4543 ret_val = FALSE;
4544 }
4545 break;
4546 }
4547 }
4548
4549 return ret_val;
4550 }
4551
4552 static bfd_boolean
4553 elfNN_ia64_finish_dynamic_symbol (output_bfd, info, h, sym)
4554 bfd *output_bfd;
4555 struct bfd_link_info *info;
4556 struct elf_link_hash_entry *h;
4557 Elf_Internal_Sym *sym;
4558 {
4559 struct elfNN_ia64_link_hash_table *ia64_info;
4560 struct elfNN_ia64_dyn_sym_info *dyn_i;
4561
4562 ia64_info = elfNN_ia64_hash_table (info);
4563 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE);
4564
4565 /* Fill in the PLT data, if required. */
4566 if (dyn_i && dyn_i->want_plt)
4567 {
4568 Elf_Internal_Rela outrel;
4569 bfd_byte *loc;
4570 asection *plt_sec;
4571 bfd_vma plt_addr, pltoff_addr, gp_val, index;
4572
4573 gp_val = _bfd_get_gp_value (output_bfd);
4574
4575 /* Initialize the minimal PLT entry. */
4576
4577 index = (dyn_i->plt_offset - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
4578 plt_sec = ia64_info->plt_sec;
4579 loc = plt_sec->contents + dyn_i->plt_offset;
4580
4581 memcpy (loc, plt_min_entry, PLT_MIN_ENTRY_SIZE);
4582 elfNN_ia64_install_value (output_bfd, loc, index, R_IA64_IMM22);
4583 elfNN_ia64_install_value (output_bfd, loc+2, -dyn_i->plt_offset,
4584 R_IA64_PCREL21B);
4585
4586 plt_addr = (plt_sec->output_section->vma
4587 + plt_sec->output_offset
4588 + dyn_i->plt_offset);
4589 pltoff_addr = set_pltoff_entry (output_bfd, info, dyn_i, plt_addr, TRUE);
4590
4591 /* Initialize the FULL PLT entry, if needed. */
4592 if (dyn_i->want_plt2)
4593 {
4594 loc = plt_sec->contents + dyn_i->plt2_offset;
4595
4596 memcpy (loc, plt_full_entry, PLT_FULL_ENTRY_SIZE);
4597 elfNN_ia64_install_value (output_bfd, loc, pltoff_addr - gp_val,
4598 R_IA64_IMM22);
4599
4600 /* Mark the symbol as undefined, rather than as defined in the
4601 plt section. Leave the value alone. */
4602 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
4603 first place. But perhaps elflink.c did some for us. */
4604 if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
4605 sym->st_shndx = SHN_UNDEF;
4606 }
4607
4608 /* Create the dynamic relocation. */
4609 outrel.r_offset = pltoff_addr;
4610 if (bfd_little_endian (output_bfd))
4611 outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTLSB);
4612 else
4613 outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTMSB);
4614 outrel.r_addend = 0;
4615
4616 /* This is fun. In the .IA_64.pltoff section, we've got entries
4617 that correspond both to real PLT entries, and those that
4618 happened to resolve to local symbols but need to be created
4619 to satisfy @pltoff relocations. The .rela.IA_64.pltoff
4620 relocations for the real PLT should come at the end of the
4621 section, so that they can be indexed by plt entry at runtime.
4622
4623 We emitted all of the relocations for the non-PLT @pltoff
4624 entries during relocate_section. So we can consider the
4625 existing sec->reloc_count to be the base of the array of
4626 PLT relocations. */
4627
4628 loc = ia64_info->rel_pltoff_sec->contents;
4629 loc += ((ia64_info->rel_pltoff_sec->reloc_count + index)
4630 * sizeof (ElfNN_External_Rela));
4631 bfd_elfNN_swap_reloca_out (output_bfd, &outrel, loc);
4632 }
4633
4634 /* Mark some specially defined symbols as absolute. */
4635 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
4636 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
4637 || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
4638 sym->st_shndx = SHN_ABS;
4639
4640 return TRUE;
4641 }
4642
4643 static bfd_boolean
4644 elfNN_ia64_finish_dynamic_sections (abfd, info)
4645 bfd *abfd;
4646 struct bfd_link_info *info;
4647 {
4648 struct elfNN_ia64_link_hash_table *ia64_info;
4649 bfd *dynobj;
4650
4651 ia64_info = elfNN_ia64_hash_table (info);
4652 dynobj = ia64_info->root.dynobj;
4653
4654 if (elf_hash_table (info)->dynamic_sections_created)
4655 {
4656 ElfNN_External_Dyn *dyncon, *dynconend;
4657 asection *sdyn, *sgotplt;
4658 bfd_vma gp_val;
4659
4660 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4661 sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
4662 BFD_ASSERT (sdyn != NULL);
4663 dyncon = (ElfNN_External_Dyn *) sdyn->contents;
4664 dynconend = (ElfNN_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
4665
4666 gp_val = _bfd_get_gp_value (abfd);
4667
4668 for (; dyncon < dynconend; dyncon++)
4669 {
4670 Elf_Internal_Dyn dyn;
4671
4672 bfd_elfNN_swap_dyn_in (dynobj, dyncon, &dyn);
4673
4674 switch (dyn.d_tag)
4675 {
4676 case DT_PLTGOT:
4677 dyn.d_un.d_ptr = gp_val;
4678 break;
4679
4680 case DT_PLTRELSZ:
4681 dyn.d_un.d_val = (ia64_info->minplt_entries
4682 * sizeof (ElfNN_External_Rela));
4683 break;
4684
4685 case DT_JMPREL:
4686 /* See the comment above in finish_dynamic_symbol. */
4687 dyn.d_un.d_ptr = (ia64_info->rel_pltoff_sec->output_section->vma
4688 + ia64_info->rel_pltoff_sec->output_offset
4689 + (ia64_info->rel_pltoff_sec->reloc_count
4690 * sizeof (ElfNN_External_Rela)));
4691 break;
4692
4693 case DT_IA_64_PLT_RESERVE:
4694 dyn.d_un.d_ptr = (sgotplt->output_section->vma
4695 + sgotplt->output_offset);
4696 break;
4697
4698 case DT_RELASZ:
4699 /* Do not have RELASZ include JMPREL. This makes things
4700 easier on ld.so. This is not what the rest of BFD set up. */
4701 dyn.d_un.d_val -= (ia64_info->minplt_entries
4702 * sizeof (ElfNN_External_Rela));
4703 break;
4704 }
4705
4706 bfd_elfNN_swap_dyn_out (abfd, &dyn, dyncon);
4707 }
4708
4709 /* Initialize the PLT0 entry. */
4710 if (ia64_info->plt_sec)
4711 {
4712 bfd_byte *loc = ia64_info->plt_sec->contents;
4713 bfd_vma pltres;
4714
4715 memcpy (loc, plt_header, PLT_HEADER_SIZE);
4716
4717 pltres = (sgotplt->output_section->vma
4718 + sgotplt->output_offset
4719 - gp_val);
4720
4721 elfNN_ia64_install_value (abfd, loc+1, pltres, R_IA64_GPREL22);
4722 }
4723 }
4724
4725 return TRUE;
4726 }
4727
4728 /* ELF file flag handling: */
4729
4730 /* Function to keep IA-64 specific file flags. */
4731 static bfd_boolean
4732 elfNN_ia64_set_private_flags (abfd, flags)
4733 bfd *abfd;
4734 flagword flags;
4735 {
4736 BFD_ASSERT (!elf_flags_init (abfd)
4737 || elf_elfheader (abfd)->e_flags == flags);
4738
4739 elf_elfheader (abfd)->e_flags = flags;
4740 elf_flags_init (abfd) = TRUE;
4741 return TRUE;
4742 }
4743
4744 /* Merge backend specific data from an object file to the output
4745 object file when linking. */
4746 static bfd_boolean
4747 elfNN_ia64_merge_private_bfd_data (ibfd, obfd)
4748 bfd *ibfd, *obfd;
4749 {
4750 flagword out_flags;
4751 flagword in_flags;
4752 bfd_boolean ok = TRUE;
4753
4754 /* Don't even pretend to support mixed-format linking. */
4755 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4756 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4757 return FALSE;
4758
4759 in_flags = elf_elfheader (ibfd)->e_flags;
4760 out_flags = elf_elfheader (obfd)->e_flags;
4761
4762 if (! elf_flags_init (obfd))
4763 {
4764 elf_flags_init (obfd) = TRUE;
4765 elf_elfheader (obfd)->e_flags = in_flags;
4766
4767 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
4768 && bfd_get_arch_info (obfd)->the_default)
4769 {
4770 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
4771 bfd_get_mach (ibfd));
4772 }
4773
4774 return TRUE;
4775 }
4776
4777 /* Check flag compatibility. */
4778 if (in_flags == out_flags)
4779 return TRUE;
4780
4781 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
4782 if (!(in_flags & EF_IA_64_REDUCEDFP) && (out_flags & EF_IA_64_REDUCEDFP))
4783 elf_elfheader (obfd)->e_flags &= ~EF_IA_64_REDUCEDFP;
4784
4785 if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL))
4786 {
4787 (*_bfd_error_handler)
4788 (_("%s: linking trap-on-NULL-dereference with non-trapping files"),
4789 bfd_archive_filename (ibfd));
4790
4791 bfd_set_error (bfd_error_bad_value);
4792 ok = FALSE;
4793 }
4794 if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE))
4795 {
4796 (*_bfd_error_handler)
4797 (_("%s: linking big-endian files with little-endian files"),
4798 bfd_archive_filename (ibfd));
4799
4800 bfd_set_error (bfd_error_bad_value);
4801 ok = FALSE;
4802 }
4803 if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64))
4804 {
4805 (*_bfd_error_handler)
4806 (_("%s: linking 64-bit files with 32-bit files"),
4807 bfd_archive_filename (ibfd));
4808
4809 bfd_set_error (bfd_error_bad_value);
4810 ok = FALSE;
4811 }
4812 if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP))
4813 {
4814 (*_bfd_error_handler)
4815 (_("%s: linking constant-gp files with non-constant-gp files"),
4816 bfd_archive_filename (ibfd));
4817
4818 bfd_set_error (bfd_error_bad_value);
4819 ok = FALSE;
4820 }
4821 if ((in_flags & EF_IA_64_NOFUNCDESC_CONS_GP)
4822 != (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
4823 {
4824 (*_bfd_error_handler)
4825 (_("%s: linking auto-pic files with non-auto-pic files"),
4826 bfd_archive_filename (ibfd));
4827
4828 bfd_set_error (bfd_error_bad_value);
4829 ok = FALSE;
4830 }
4831
4832 return ok;
4833 }
4834
4835 static bfd_boolean
4836 elfNN_ia64_print_private_bfd_data (abfd, ptr)
4837 bfd *abfd;
4838 PTR ptr;
4839 {
4840 FILE *file = (FILE *) ptr;
4841 flagword flags = elf_elfheader (abfd)->e_flags;
4842
4843 BFD_ASSERT (abfd != NULL && ptr != NULL);
4844
4845 fprintf (file, "private flags = %s%s%s%s%s%s%s%s\n",
4846 (flags & EF_IA_64_TRAPNIL) ? "TRAPNIL, " : "",
4847 (flags & EF_IA_64_EXT) ? "EXT, " : "",
4848 (flags & EF_IA_64_BE) ? "BE, " : "LE, ",
4849 (flags & EF_IA_64_REDUCEDFP) ? "REDUCEDFP, " : "",
4850 (flags & EF_IA_64_CONS_GP) ? "CONS_GP, " : "",
4851 (flags & EF_IA_64_NOFUNCDESC_CONS_GP) ? "NOFUNCDESC_CONS_GP, " : "",
4852 (flags & EF_IA_64_ABSOLUTE) ? "ABSOLUTE, " : "",
4853 (flags & EF_IA_64_ABI64) ? "ABI64" : "ABI32");
4854
4855 _bfd_elf_print_private_bfd_data (abfd, ptr);
4856 return TRUE;
4857 }
4858
4859 static enum elf_reloc_type_class
4860 elfNN_ia64_reloc_type_class (rela)
4861 const Elf_Internal_Rela *rela;
4862 {
4863 switch ((int) ELFNN_R_TYPE (rela->r_info))
4864 {
4865 case R_IA64_REL32MSB:
4866 case R_IA64_REL32LSB:
4867 case R_IA64_REL64MSB:
4868 case R_IA64_REL64LSB:
4869 return reloc_class_relative;
4870 case R_IA64_IPLTMSB:
4871 case R_IA64_IPLTLSB:
4872 return reloc_class_plt;
4873 case R_IA64_COPY:
4874 return reloc_class_copy;
4875 default:
4876 return reloc_class_normal;
4877 }
4878 }
4879
4880 static struct bfd_elf_special_section const elfNN_ia64_special_sections[]=
4881 {
4882 { ".sbss", 5, -1, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
4883 { ".sdata", 6, -1, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
4884 { NULL, 0, 0, 0, 0 }
4885 };
4886
4887 static bfd_boolean
4888 elfNN_ia64_hpux_vec (const bfd_target *vec)
4889 {
4890 extern const bfd_target bfd_elfNN_ia64_hpux_big_vec;
4891 return (vec == & bfd_elfNN_ia64_hpux_big_vec);
4892 }
4893
4894 static void
4895 elfNN_hpux_post_process_headers (abfd, info)
4896 bfd *abfd;
4897 struct bfd_link_info *info ATTRIBUTE_UNUSED;
4898 {
4899 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
4900
4901 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_HPUX;
4902 i_ehdrp->e_ident[EI_ABIVERSION] = 1;
4903 }
4904
4905 bfd_boolean
4906 elfNN_hpux_backend_section_from_bfd_section (abfd, sec, retval)
4907 bfd *abfd ATTRIBUTE_UNUSED;
4908 asection *sec;
4909 int *retval;
4910 {
4911 if (bfd_is_com_section (sec))
4912 {
4913 *retval = SHN_IA_64_ANSI_COMMON;
4914 return TRUE;
4915 }
4916 return FALSE;
4917 }
4918
4919 static void
4920 elfNN_hpux_backend_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
4921 asymbol *asym)
4922 {
4923 elf_symbol_type *elfsym = (elf_symbol_type *) asym;;
4924
4925 switch (elfsym->internal_elf_sym.st_shndx)
4926 {
4927 case SHN_IA_64_ANSI_COMMON:
4928 asym->section = bfd_com_section_ptr;
4929 asym->value = elfsym->internal_elf_sym.st_size;
4930 asym->flags &= ~BSF_GLOBAL;
4931 break;
4932 }
4933 }
4934
4935
4936 #define TARGET_LITTLE_SYM bfd_elfNN_ia64_little_vec
4937 #define TARGET_LITTLE_NAME "elfNN-ia64-little"
4938 #define TARGET_BIG_SYM bfd_elfNN_ia64_big_vec
4939 #define TARGET_BIG_NAME "elfNN-ia64-big"
4940 #define ELF_ARCH bfd_arch_ia64
4941 #define ELF_MACHINE_CODE EM_IA_64
4942 #define ELF_MACHINE_ALT1 1999 /* EAS2.3 */
4943 #define ELF_MACHINE_ALT2 1998 /* EAS2.2 */
4944 #define ELF_MAXPAGESIZE 0x10000 /* 64KB */
4945
4946 #define elf_backend_section_from_shdr \
4947 elfNN_ia64_section_from_shdr
4948 #define elf_backend_section_flags \
4949 elfNN_ia64_section_flags
4950 #define elf_backend_fake_sections \
4951 elfNN_ia64_fake_sections
4952 #define elf_backend_final_write_processing \
4953 elfNN_ia64_final_write_processing
4954 #define elf_backend_add_symbol_hook \
4955 elfNN_ia64_add_symbol_hook
4956 #define elf_backend_additional_program_headers \
4957 elfNN_ia64_additional_program_headers
4958 #define elf_backend_modify_segment_map \
4959 elfNN_ia64_modify_segment_map
4960 #define elf_info_to_howto \
4961 elfNN_ia64_info_to_howto
4962
4963 #define bfd_elfNN_bfd_reloc_type_lookup \
4964 elfNN_ia64_reloc_type_lookup
4965 #define bfd_elfNN_bfd_is_local_label_name \
4966 elfNN_ia64_is_local_label_name
4967 #define bfd_elfNN_bfd_relax_section \
4968 elfNN_ia64_relax_section
4969
4970 /* Stuff for the BFD linker: */
4971 #define bfd_elfNN_bfd_link_hash_table_create \
4972 elfNN_ia64_hash_table_create
4973 #define bfd_elfNN_bfd_link_hash_table_free \
4974 elfNN_ia64_hash_table_free
4975 #define elf_backend_create_dynamic_sections \
4976 elfNN_ia64_create_dynamic_sections
4977 #define elf_backend_check_relocs \
4978 elfNN_ia64_check_relocs
4979 #define elf_backend_adjust_dynamic_symbol \
4980 elfNN_ia64_adjust_dynamic_symbol
4981 #define elf_backend_size_dynamic_sections \
4982 elfNN_ia64_size_dynamic_sections
4983 #define elf_backend_relocate_section \
4984 elfNN_ia64_relocate_section
4985 #define elf_backend_finish_dynamic_symbol \
4986 elfNN_ia64_finish_dynamic_symbol
4987 #define elf_backend_finish_dynamic_sections \
4988 elfNN_ia64_finish_dynamic_sections
4989 #define bfd_elfNN_bfd_final_link \
4990 elfNN_ia64_final_link
4991
4992 #define bfd_elfNN_bfd_merge_private_bfd_data \
4993 elfNN_ia64_merge_private_bfd_data
4994 #define bfd_elfNN_bfd_set_private_flags \
4995 elfNN_ia64_set_private_flags
4996 #define bfd_elfNN_bfd_print_private_bfd_data \
4997 elfNN_ia64_print_private_bfd_data
4998
4999 #define elf_backend_plt_readonly 1
5000 #define elf_backend_want_plt_sym 0
5001 #define elf_backend_plt_alignment 5
5002 #define elf_backend_got_header_size 0
5003 #define elf_backend_want_got_plt 1
5004 #define elf_backend_may_use_rel_p 1
5005 #define elf_backend_may_use_rela_p 1
5006 #define elf_backend_default_use_rela_p 1
5007 #define elf_backend_want_dynbss 0
5008 #define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect
5009 #define elf_backend_hide_symbol elfNN_ia64_hash_hide_symbol
5010 #define elf_backend_reloc_type_class elfNN_ia64_reloc_type_class
5011 #define elf_backend_rela_normal 1
5012 #define elf_backend_special_sections elfNN_ia64_special_sections
5013
5014 #include "elfNN-target.h"
5015
5016 /* HPUX-specific vectors. */
5017
5018 #undef TARGET_LITTLE_SYM
5019 #undef TARGET_LITTLE_NAME
5020 #undef TARGET_BIG_SYM
5021 #define TARGET_BIG_SYM bfd_elfNN_ia64_hpux_big_vec
5022 #undef TARGET_BIG_NAME
5023 #define TARGET_BIG_NAME "elfNN-ia64-hpux-big"
5024
5025 /* These are HP-UX specific functions. */
5026
5027 #undef elf_backend_post_process_headers
5028 #define elf_backend_post_process_headers elfNN_hpux_post_process_headers
5029
5030 #undef elf_backend_section_from_bfd_section
5031 #define elf_backend_section_from_bfd_section elfNN_hpux_backend_section_from_bfd_section
5032
5033 #undef elf_backend_symbol_processing
5034 #define elf_backend_symbol_processing elfNN_hpux_backend_symbol_processing
5035
5036 #undef elf_backend_want_p_paddr_set_to_zero
5037 #define elf_backend_want_p_paddr_set_to_zero 1
5038
5039 #undef ELF_MAXPAGESIZE
5040 #define ELF_MAXPAGESIZE 0x1000 /* 1K */
5041
5042 #undef elfNN_bed
5043 #define elfNN_bed elfNN_ia64_hpux_bed
5044
5045 #include "elfNN-target.h"
5046
5047 #undef elf_backend_want_p_paddr_set_to_zero
5048