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