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