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