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