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