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