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