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