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