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