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