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