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