projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Automatic date update in version.in
[deliverable/binutils-gdb.git] / bfd / elf64-ia64-vms.c
CommitLineData
202e2356 1/* IA-64 support for OpenVMS
82704155 2 Copyright (C) 1998-2019 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
843 name = bfd_get_section_name (abfd, sec);
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
NC		 1288 if (s == NULL
1289 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
1290 return FALSE;
1291
3d4d4302 1292 s = bfd_make_section_anyway_with_flags (abfd, ".plt", flags | SEC_READONLY);
202e2356
NC		 1293 if (s == NULL
1294 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
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
NC		 1309 if (s == NULL
1310 || !bfd_set_section_alignment (abfd, s, 0))
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
NC		 1319 if (s == NULL
1320 || !bfd_set_section_alignment (abfd, s, 3))
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
NC		 1330 if (s == NULL
1331 || !bfd_set_section_alignment (abfd, s, 3))
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
NC		 1342 if (s == NULL
1343 || !bfd_set_section_alignment (abfd, s, 3))
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
07d6d2b8
AM		 1741 || !bfd_set_section_alignment (dynobj, got, 3))
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
NC		 1776 if (!fptr
1777 || !bfd_set_section_alignment (dynobj, fptr, 4))
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
NC		 1794 if (fptr_rel == NULL
1795 || !bfd_set_section_alignment (dynobj, fptr_rel, 3))
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
NC		 1829 if (!pltoff
1830 || !bfd_set_section_alignment (dynobj, pltoff, 4))
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")
1858 && strcmp (bfd_get_section_name (abfd, sec),
1859 srel_name+5) == 0)
1860 || (CONST_STRNEQ (srel_name, ".rel")
1861 && strcmp (bfd_get_section_name (abfd, sec),
1862 srel_name+4) == 0));
1863
1864 dynobj = ia64_info->root.dynobj;
1865 if (!dynobj)
1866 ia64_info->root.dynobj = dynobj = abfd;
1867
3d4d4302 1868 srel = bfd_get_linker_section (dynobj, srel_name);
202e2356
NC		 1869 if (srel == NULL && create)
1870 {
3d4d4302
AM		 1871 srel = bfd_make_section_anyway_with_flags (dynobj, srel_name,
1872 (SEC_ALLOC | SEC_LOAD
1873 | SEC_HAS_CONTENTS
1874 | SEC_IN_MEMORY
1875 | SEC_LINKER_CREATED
1876 | SEC_READONLY));
202e2356
NC		 1877 if (srel == NULL
1878 || !bfd_set_section_alignment (dynobj, srel, 3))
1879 return NULL;
1880 }
1881
1882 return srel;
1883}
1884
1885static bfd_boolean
1886count_dyn_reloc (bfd *abfd, struct elf64_ia64_dyn_sym_info *dyn_i,
1887 asection *srel, int type)
1888{
1889 struct elf64_ia64_dyn_reloc_entry *rent;
1890
1891 for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
1892 if (rent->srel == srel && rent->type == type)
1893 break;
1894
1895 if (!rent)
1896 {
1897 rent = ((struct elf64_ia64_dyn_reloc_entry *)
1898 bfd_alloc (abfd, (bfd_size_type) sizeof (*rent)));
1899 if (!rent)
1900 return FALSE;
1901
1902 rent->next = dyn_i->reloc_entries;
1903 rent->srel = srel;
1904 rent->type = type;
1905 rent->count = 0;
1906 dyn_i->reloc_entries = rent;
1907 }
1908 rent->count++;
1909
1910 return TRUE;
1911}
1912
1913static bfd_boolean
1914elf64_ia64_check_relocs (bfd *abfd, struct bfd_link_info *info,
1915 asection *sec,
1916 const Elf_Internal_Rela *relocs)
1917{
1918 struct elf64_ia64_link_hash_table *ia64_info;
1919 const Elf_Internal_Rela *relend;
1920 Elf_Internal_Shdr *symtab_hdr;
1921 const Elf_Internal_Rela *rel;
1922 asection *got, *fptr, *srel, *pltoff;
1923 enum {
1924 NEED_GOT = 1,
1925 NEED_GOTX = 2,
1926 NEED_FPTR = 4,
1927 NEED_PLTOFF = 8,
1928 NEED_MIN_PLT = 16,
1929 NEED_FULL_PLT = 32,
1930 NEED_DYNREL = 64,
1931 NEED_LTOFF_FPTR = 128
1932 };
1933 int need_entry;
1934 struct elf_link_hash_entry *h;
1935 unsigned long r_symndx;
1936 bfd_boolean maybe_dynamic;
1937
0e1862bb 1938 if (bfd_link_relocatable (info))
202e2356
NC		 1939 return TRUE;
1940
1941 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1942 ia64_info = elf64_ia64_hash_table (info);
1943 if (ia64_info == NULL)
1944 return FALSE;
1945
1946 got = fptr = srel = pltoff = NULL;
1947
1948 relend = relocs + sec->reloc_count;
1949
1950 /* We scan relocations first to create dynamic relocation arrays. We
1951 modified get_dyn_sym_info to allow fast insertion and support fast
1952 lookup in the next loop. */
1953 for (rel = relocs; rel < relend; ++rel)
1954 {
1955 r_symndx = ELF64_R_SYM (rel->r_info);
1956 if (r_symndx >= symtab_hdr->sh_info)
1957 {
1958 long indx = r_symndx - symtab_hdr->sh_info;
1959 h = elf_sym_hashes (abfd)[indx];
1960 while (h->root.type == bfd_link_hash_indirect
1961 || h->root.type == bfd_link_hash_warning)
1962 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1963 }
1964 else
1965 h = NULL;
1966
1967 /* We can only get preliminary data on whether a symbol is
1968 locally or externally defined, as not all of the input files
1969 have yet been processed. Do something with what we know, as
1970 this may help reduce memory usage and processing time later. */
0e1862bb 1971 maybe_dynamic = (h && ((!bfd_link_executable (info)
202e2356
NC		 1972 && (!SYMBOLIC_BIND (info, h)
1973 || info->unresolved_syms_in_shared_libs == RM_IGNORE))
1974 || !h->def_regular
1975 || h->root.type == bfd_link_hash_defweak));
1976
1977 need_entry = 0;
1978 switch (ELF64_R_TYPE (rel->r_info))
1979 {
1980 case R_IA64_TPREL64MSB:
1981 case R_IA64_TPREL64LSB:
1982 case R_IA64_LTOFF_TPREL22:
1983 case R_IA64_DTPREL32MSB:
1984 case R_IA64_DTPREL32LSB:
1985 case R_IA64_DTPREL64MSB:
1986 case R_IA64_DTPREL64LSB:
1987 case R_IA64_LTOFF_DTPREL22:
1988 case R_IA64_DTPMOD64MSB:
1989 case R_IA64_DTPMOD64LSB:
1990 case R_IA64_LTOFF_DTPMOD22:
07d6d2b8 1991 abort ();
202e2356
NC		 1992 break;
1993
1994 case R_IA64_IPLTMSB:
1995 case R_IA64_IPLTLSB:
07d6d2b8 1996 break;
202e2356
NC		 1997
1998 case R_IA64_LTOFF_FPTR22:
1999 case R_IA64_LTOFF_FPTR64I:
2000 case R_IA64_LTOFF_FPTR32MSB:
2001 case R_IA64_LTOFF_FPTR32LSB:
2002 case R_IA64_LTOFF_FPTR64MSB:
2003 case R_IA64_LTOFF_FPTR64LSB:
2004 need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR;
2005 break;
2006
2007 case R_IA64_FPTR64I:
2008 case R_IA64_FPTR32MSB:
2009 case R_IA64_FPTR32LSB:
2010 case R_IA64_FPTR64MSB:
2011 case R_IA64_FPTR64LSB:
0e1862bb 2012 if (bfd_link_pic (info) || h)
202e2356
NC		 2013 need_entry = NEED_FPTR | NEED_DYNREL;
2014 else
2015 need_entry = NEED_FPTR;
2016 break;
2017
2018 case R_IA64_LTOFF22:
2019 case R_IA64_LTOFF64I:
2020 need_entry = NEED_GOT;
2021 break;
2022
2023 case R_IA64_LTOFF22X:
2024 need_entry = NEED_GOTX;
2025 break;
2026
2027 case R_IA64_PLTOFF22:
2028 case R_IA64_PLTOFF64I:
2029 case R_IA64_PLTOFF64MSB:
2030 case R_IA64_PLTOFF64LSB:
2031 need_entry = NEED_PLTOFF;
2032 if (h)
2033 {
2034 if (maybe_dynamic)
2035 need_entry |= NEED_MIN_PLT;
2036 }
2037 else
2038 {
2039 (*info->callbacks->warning)
2040 (info, _("@pltoff reloc against local symbol"), 0,
2041 abfd, 0, (bfd_vma) 0);
2042 }
2043 break;
2044
2045 case R_IA64_PCREL21B:
07d6d2b8 2046 case R_IA64_PCREL60B:
202e2356
NC		 2047 /* Depending on where this symbol is defined, we may or may not
2048 need a full plt entry. Only skip if we know we'll not need
2049 the entry -- static or symbolic, and the symbol definition
2050 has already been seen. */
2051 if (maybe_dynamic && rel->r_addend == 0)
2052 need_entry = NEED_FULL_PLT;
2053 break;
2054
2055 case R_IA64_IMM14:
2056 case R_IA64_IMM22:
2057 case R_IA64_IMM64:
2058 case R_IA64_DIR32MSB:
2059 case R_IA64_DIR32LSB:
2060 case R_IA64_DIR64MSB:
2061 case R_IA64_DIR64LSB:
2062 /* Shared objects will always need at least a REL relocation. */
0e1862bb 2063 if (bfd_link_pic (info) || maybe_dynamic)
202e2356
NC		 2064 need_entry = NEED_DYNREL;
2065 break;
2066
2067 case R_IA64_PCREL22:
2068 case R_IA64_PCREL64I:
2069 case R_IA64_PCREL32MSB:
2070 case R_IA64_PCREL32LSB:
2071 case R_IA64_PCREL64MSB:
2072 case R_IA64_PCREL64LSB:
2073 if (maybe_dynamic)
2074 need_entry = NEED_DYNREL;
2075 break;
2076 }
2077
2078 if (!need_entry)
2079 continue;
2080
2081 if ((need_entry & NEED_FPTR) != 0
2082 && rel->r_addend)
2083 {
2084 (*info->callbacks->warning)
2085 (info, _("non-zero addend in @fptr reloc"), 0,
2086 abfd, 0, (bfd_vma) 0);
2087 }
2088
2089 if (get_dyn_sym_info (ia64_info, h, abfd, rel, TRUE) == NULL)
2090 return FALSE;
2091 }
2092
2093 /* Now, we only do lookup without insertion, which is very fast
2094 with the modified get_dyn_sym_info. */
2095 for (rel = relocs; rel < relend; ++rel)
2096 {
2097 struct elf64_ia64_dyn_sym_info *dyn_i;
2098 int dynrel_type = R_IA64_NONE;
2099
2100 r_symndx = ELF64_R_SYM (rel->r_info);
2101 if (r_symndx >= symtab_hdr->sh_info)
2102 {
2103 /* We're dealing with a global symbol -- find its hash entry
2104 and mark it as being referenced. */
2105 long indx = r_symndx - symtab_hdr->sh_info;
2106 h = elf_sym_hashes (abfd)[indx];
2107 while (h->root.type == bfd_link_hash_indirect
2108 || h->root.type == bfd_link_hash_warning)
2109 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2110
81fbe831
AM		 2111 /* PR15323, ref flags aren't set for references in the same
2112 object. */
202e2356
NC		 2113 h->ref_regular = 1;
2114 }
2115 else
2116 h = NULL;
2117
2118 /* We can only get preliminary data on whether a symbol is
2119 locally or externally defined, as not all of the input files
2120 have yet been processed. Do something with what we know, as
2121 this may help reduce memory usage and processing time later. */
0e1862bb 2122 maybe_dynamic = (h && ((!bfd_link_executable (info)
202e2356
NC		 2123 && (!SYMBOLIC_BIND (info, h)
2124 || info->unresolved_syms_in_shared_libs == RM_IGNORE))
2125 || !h->def_regular
2126 || h->root.type == bfd_link_hash_defweak));
2127
2128 need_entry = 0;
2129 switch (ELF64_R_TYPE (rel->r_info))
2130 {
2131 case R_IA64_TPREL64MSB:
2132 case R_IA64_TPREL64LSB:
2133 case R_IA64_LTOFF_TPREL22:
2134 case R_IA64_DTPREL32MSB:
2135 case R_IA64_DTPREL32LSB:
2136 case R_IA64_DTPREL64MSB:
2137 case R_IA64_DTPREL64LSB:
2138 case R_IA64_LTOFF_DTPREL22:
2139 case R_IA64_DTPMOD64MSB:
2140 case R_IA64_DTPMOD64LSB:
2141 case R_IA64_LTOFF_DTPMOD22:
07d6d2b8 2142 abort ();
202e2356
NC		 2143 break;
2144
2145 case R_IA64_LTOFF_FPTR22:
2146 case R_IA64_LTOFF_FPTR64I:
2147 case R_IA64_LTOFF_FPTR32MSB:
2148 case R_IA64_LTOFF_FPTR32LSB:
2149 case R_IA64_LTOFF_FPTR64MSB:
2150 case R_IA64_LTOFF_FPTR64LSB:
2151 need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR;
2152 break;
2153
2154 case R_IA64_FPTR64I:
2155 case R_IA64_FPTR32MSB:
2156 case R_IA64_FPTR32LSB:
2157 case R_IA64_FPTR64MSB:
2158 case R_IA64_FPTR64LSB:
0e1862bb 2159 if (bfd_link_pic (info) || h)
202e2356
NC		 2160 need_entry = NEED_FPTR | NEED_DYNREL;
2161 else
2162 need_entry = NEED_FPTR;
2163 dynrel_type = R_IA64_FPTR64LSB;
2164 break;
2165
2166 case R_IA64_LTOFF22:
2167 case R_IA64_LTOFF64I:
2168 need_entry = NEED_GOT;
2169 break;
2170
2171 case R_IA64_LTOFF22X:
2172 need_entry = NEED_GOTX;
2173 break;
2174
2175 case R_IA64_PLTOFF22:
2176 case R_IA64_PLTOFF64I:
2177 case R_IA64_PLTOFF64MSB:
2178 case R_IA64_PLTOFF64LSB:
2179 need_entry = NEED_PLTOFF;
2180 if (h)
2181 {
2182 if (maybe_dynamic)
2183 need_entry |= NEED_MIN_PLT;
2184 }
2185 break;
2186
2187 case R_IA64_PCREL21B:
07d6d2b8 2188 case R_IA64_PCREL60B:
202e2356
NC		 2189 /* Depending on where this symbol is defined, we may or may not
2190 need a full plt entry. Only skip if we know we'll not need
2191 the entry -- static or symbolic, and the symbol definition
2192 has already been seen. */
2193 if (maybe_dynamic && rel->r_addend == 0)
2194 need_entry = NEED_FULL_PLT;
2195 break;
2196
2197 case R_IA64_IMM14:
2198 case R_IA64_IMM22:
2199 case R_IA64_IMM64:
2200 case R_IA64_DIR32MSB:
2201 case R_IA64_DIR32LSB:
2202 case R_IA64_DIR64MSB:
2203 case R_IA64_DIR64LSB:
2204 /* Shared objects will always need at least a REL relocation. */
0e1862bb 2205 if (bfd_link_pic (info) || maybe_dynamic)
202e2356
NC		 2206 need_entry = NEED_DYNREL;
2207 dynrel_type = R_IA64_DIR64LSB;
2208 break;
2209
2210 case R_IA64_IPLTMSB:
2211 case R_IA64_IPLTLSB:
2212 break;
2213
2214 case R_IA64_PCREL22:
2215 case R_IA64_PCREL64I:
2216 case R_IA64_PCREL32MSB:
2217 case R_IA64_PCREL32LSB:
2218 case R_IA64_PCREL64MSB:
2219 case R_IA64_PCREL64LSB:
2220 if (maybe_dynamic)
2221 need_entry = NEED_DYNREL;
2222 dynrel_type = R_IA64_PCREL64LSB;
2223 break;
2224 }
2225
2226 if (!need_entry)
2227 continue;
2228
2229 dyn_i = get_dyn_sym_info (ia64_info, h, abfd, rel, FALSE);
2230
2231 /* Record whether or not this is a local symbol. */
2232 dyn_i->h = h;
2233
2234 /* Create what's needed. */
2235 if (need_entry & (NEED_GOT | NEED_GOTX))
2236 {
2237 if (!got)
2238 {
2239 got = get_got (abfd, ia64_info);
2240 if (!got)
2241 return FALSE;
2242 }
2243 if (need_entry & NEED_GOT)
2244 dyn_i->want_got = 1;
2245 if (need_entry & NEED_GOTX)
2246 dyn_i->want_gotx = 1;
2247 }
2248 if (need_entry & NEED_FPTR)
2249 {
07d6d2b8 2250 /* Create the .opd section. */
202e2356
NC		 2251 if (!fptr)
2252 {
2253 fptr = get_fptr (abfd, info, ia64_info);
2254 if (!fptr)
2255 return FALSE;
2256 }
2257 dyn_i->want_fptr = 1;
2258 }
2259 if (need_entry & NEED_LTOFF_FPTR)
2260 dyn_i->want_ltoff_fptr = 1;
2261 if (need_entry & (NEED_MIN_PLT | NEED_FULL_PLT))
2262 {
07d6d2b8 2263 if (!ia64_info->root.dynobj)
202e2356
NC		 2264 ia64_info->root.dynobj = abfd;
2265 h->needs_plt = 1;
2266 dyn_i->want_plt = 1;
2267 }
2268 if (need_entry & NEED_FULL_PLT)
2269 dyn_i->want_plt2 = 1;
2270 if (need_entry & NEED_PLTOFF)
2271 {
2272 /* This is needed here, in case @pltoff is used in a non-shared
2273 link. */
2274 if (!pltoff)
2275 {
2276 pltoff = get_pltoff (abfd, ia64_info);
2277 if (!pltoff)
2278 return FALSE;
2279 }
2280
2281 dyn_i->want_pltoff = 1;
2282 }
2283 if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC))
2284 {
2285 if (!srel)
2286 {
2287 srel = get_reloc_section (abfd, ia64_info, sec, TRUE);
2288 if (!srel)
2289 return FALSE;
2290 }
2291 if (!count_dyn_reloc (abfd, dyn_i, srel, dynrel_type))
2292 return FALSE;
2293 }
2294 }
2295
2296 return TRUE;
2297}
2298
2299/* For cleanliness, and potentially faster dynamic loading, allocate
2300 external GOT entries first. */
2301
2302static bfd_boolean
2303allocate_global_data_got (struct elf64_ia64_dyn_sym_info *dyn_i,
2304 void * data)
2305{
2306 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2307
2308 if ((dyn_i->want_got || dyn_i->want_gotx)
2309 && ! dyn_i->want_fptr
2310 && elf64_ia64_dynamic_symbol_p (dyn_i->h))
2311 {
2312 /* GOT entry with FPTR is done by allocate_global_fptr_got. */
2313 dyn_i->got_offset = x->ofs;
2314 x->ofs += 8;
2315 }
2316 return TRUE;
2317}
2318
2319/* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
2320
2321static bfd_boolean
2322allocate_global_fptr_got (struct elf64_ia64_dyn_sym_info *dyn_i,
2323 void * data)
2324{
2325 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2326
2327 if (dyn_i->want_got
2328 && dyn_i->want_fptr
2329 && elf64_ia64_dynamic_symbol_p (dyn_i->h))
2330 {
2331 dyn_i->got_offset = x->ofs;
2332 x->ofs += 8;
2333 }
2334 return TRUE;
2335}
2336
2337/* Lastly, allocate all the GOT entries for local data. */
2338
2339static bfd_boolean
2340allocate_local_got (struct elf64_ia64_dyn_sym_info *dyn_i,
2341 void * data)
2342{
2343 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *) data;
2344
2345 if ((dyn_i->want_got || dyn_i->want_gotx)
2346 && !elf64_ia64_dynamic_symbol_p (dyn_i->h))
2347 {
2348 dyn_i->got_offset = x->ofs;
2349 x->ofs += 8;
2350 }
2351 return TRUE;
2352}
2353
2354/* Allocate function descriptors. We can do these for every function
2355 in a main executable that is not exported. */
2356
2357static bfd_boolean
2358allocate_fptr (struct elf64_ia64_dyn_sym_info *dyn_i, void * data)
2359{
2360 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *) data;
2361
2362 if (dyn_i->want_fptr)
2363 {
2364 struct elf_link_hash_entry *h = dyn_i->h;
2365
2366 if (h)
2367 while (h->root.type == bfd_link_hash_indirect
2368 || h->root.type == bfd_link_hash_warning)
2369 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2370
2371 if (h == NULL || !h->def_dynamic)
2372 {
07d6d2b8 2373 /* A non dynamic symbol. */
202e2356
NC		 2374 dyn_i->fptr_offset = x->ofs;
2375 x->ofs += 16;
2376 }
2377 else
2378 dyn_i->want_fptr = 0;
2379 }
2380 return TRUE;
2381}
2382
2383/* Allocate all the minimal PLT entries. */
2384
2385static bfd_boolean
2386allocate_plt_entries (struct elf64_ia64_dyn_sym_info *dyn_i,
2387 void * data ATTRIBUTE_UNUSED)
2388{
2389 if (dyn_i->want_plt)
2390 {
2391 struct elf_link_hash_entry *h = dyn_i->h;
2392
2393 if (h)
2394 while (h->root.type == bfd_link_hash_indirect
2395 || h->root.type == bfd_link_hash_warning)
2396 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2397
2398 /* ??? Versioned symbols seem to lose NEEDS_PLT. */
2399 if (elf64_ia64_dynamic_symbol_p (h))
2400 {
2401 dyn_i->want_pltoff = 1;
2402 }
2403 else
2404 {
2405 dyn_i->want_plt = 0;
2406 dyn_i->want_plt2 = 0;
2407 }
2408 }
2409 return TRUE;
2410}
2411
2412/* Allocate all the full PLT entries. */
2413
2414static bfd_boolean
2415allocate_plt2_entries (struct elf64_ia64_dyn_sym_info *dyn_i,
2416 void * data)
2417{
2418 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2419
2420 if (dyn_i->want_plt2)
2421 {
2422 struct elf_link_hash_entry *h = dyn_i->h;
2423 bfd_size_type ofs = x->ofs;
2424
2425 dyn_i->plt2_offset = ofs;
2426 x->ofs = ofs + PLT_FULL_ENTRY_SIZE;
2427
2428 while (h->root.type == bfd_link_hash_indirect
2429 || h->root.type == bfd_link_hash_warning)
2430 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2431 dyn_i->h->plt.offset = ofs;
2432 }
2433 return TRUE;
2434}
2435
2436/* Allocate all the PLTOFF entries requested by relocations and
2437 plt entries. We can't share space with allocated FPTR entries,
2438 because the latter are not necessarily addressable by the GP.
2439 ??? Relaxation might be able to determine that they are. */
2440
2441static bfd_boolean
2442allocate_pltoff_entries (struct elf64_ia64_dyn_sym_info *dyn_i,
2443 void * data)
2444{
2445 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2446
2447 if (dyn_i->want_pltoff)
2448 {
2449 dyn_i->pltoff_offset = x->ofs;
2450 x->ofs += 16;
2451 }
2452 return TRUE;
2453}
2454
2455/* Allocate dynamic relocations for those symbols that turned out
2456 to be dynamic. */
2457
2458static bfd_boolean
2459allocate_dynrel_entries (struct elf64_ia64_dyn_sym_info *dyn_i,
2460 void * data)
2461{
2462 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2463 struct elf64_ia64_link_hash_table *ia64_info;
2464 struct elf64_ia64_dyn_reloc_entry *rent;
2465 bfd_boolean dynamic_symbol, shared, resolved_zero;
2466 struct elf64_ia64_link_hash_entry *h_ia64;
2467
2468 ia64_info = elf64_ia64_hash_table (x->info);
2469 if (ia64_info == NULL)
2470 return FALSE;
2471
2472 /* Note that this can't be used in relation to FPTR relocs below. */
2473 dynamic_symbol = elf64_ia64_dynamic_symbol_p (dyn_i->h);
2474
0e1862bb 2475 shared = bfd_link_pic (x->info);
202e2356
NC		 2476 resolved_zero = (dyn_i->h
2477 && ELF_ST_VISIBILITY (dyn_i->h->other)
2478 && dyn_i->h->root.type == bfd_link_hash_undefweak);
2479
2480 /* Take care of the GOT and PLT relocations. */
2481
2482 if ((!resolved_zero
2483 && (dynamic_symbol || shared)
2484 && (dyn_i->want_got || dyn_i->want_gotx))
2485 || (dyn_i->want_ltoff_fptr
2486 && dyn_i->h
2487 && dyn_i->h->def_dynamic))
2488 {
2489 /* VMS: FIX64. */
2490 if (dyn_i->h != NULL && dyn_i->h->def_dynamic)
07d6d2b8
AM		 2491 {
2492 h_ia64 = (struct elf64_ia64_link_hash_entry *) dyn_i->h;
2493 elf_ia64_vms_tdata (h_ia64->shl)->fixups_off +=
2494 sizeof (Elf64_External_VMS_IMAGE_FIXUP);
2495 ia64_info->fixups_sec->size +=
2496 sizeof (Elf64_External_VMS_IMAGE_FIXUP);
2497 }
202e2356
NC		 2498 }
2499
2500 if (ia64_info->rel_fptr_sec && dyn_i->want_fptr)
2501 {
2502 /* VMS: only image reloc. */
2503 if (dyn_i->h == NULL || dyn_i->h->root.type != bfd_link_hash_undefweak)
2504 ia64_info->rel_fptr_sec->size += sizeof (Elf64_External_Rela);
2505 }
2506
2507 if (!resolved_zero && dyn_i->want_pltoff)
2508 {
2509 /* VMS: FIXFD. */
2510 if (dyn_i->h != NULL && dyn_i->h->def_dynamic)
07d6d2b8
AM		 2511 {
2512 h_ia64 = (struct elf64_ia64_link_hash_entry *) dyn_i->h;
2513 elf_ia64_vms_tdata (h_ia64->shl)->fixups_off +=
2514 sizeof (Elf64_External_VMS_IMAGE_FIXUP);
2515 ia64_info->fixups_sec->size +=
2516 sizeof (Elf64_External_VMS_IMAGE_FIXUP);
2517 }
202e2356
NC		 2518 }
2519
2520 /* Take care of the normal data relocations. */
2521
2522 for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
2523 {
2524 int count = rent->count;
2525
2526 switch (rent->type)
2527 {
2528 case R_IA64_FPTR32LSB:
2529 case R_IA64_FPTR64LSB:
2530 /* Allocate one iff !want_fptr and not PIE, which by this point
2531 will be true only if we're actually allocating one statically
2532 in the main executable. Position independent executables
2533 need a relative reloc. */
0e1862bb 2534 if (dyn_i->want_fptr && !bfd_link_pie (x->info))
202e2356
NC		 2535 continue;
2536 break;
2537 case R_IA64_PCREL32LSB:
2538 case R_IA64_PCREL64LSB:
2539 if (!dynamic_symbol)
2540 continue;
2541 break;
2542 case R_IA64_DIR32LSB:
2543 case R_IA64_DIR64LSB:
2544 if (!dynamic_symbol && !shared)
2545 continue;
2546 break;
2547 case R_IA64_IPLTLSB:
2548 if (!dynamic_symbol && !shared)
2549 continue;
2550 /* Use two REL relocations for IPLT relocations
2551 against local symbols. */
2552 if (!dynamic_symbol)
2553 count *= 2;
2554 break;
2555 case R_IA64_DTPREL32LSB:
2556 case R_IA64_TPREL64LSB:
2557 case R_IA64_DTPREL64LSB:
2558 case R_IA64_DTPMOD64LSB:
2559 break;
2560 default:
2561 abort ();
2562 }
2563
2564 /* Add a fixup. */
2565 if (!dynamic_symbol)
07d6d2b8 2566 abort ();
202e2356
NC		 2567
2568 h_ia64 = (struct elf64_ia64_link_hash_entry *) dyn_i->h;
2569 elf_ia64_vms_tdata (h_ia64->shl)->fixups_off +=
07d6d2b8 2570 sizeof (Elf64_External_VMS_IMAGE_FIXUP);
202e2356 2571 ia64_info->fixups_sec->size +=
07d6d2b8 2572 sizeof (Elf64_External_VMS_IMAGE_FIXUP);
202e2356
NC		 2573 }
2574
2575 return TRUE;
2576}
2577
2578static bfd_boolean
2579elf64_ia64_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
2580 struct elf_link_hash_entry *h)
2581{
2582 /* ??? Undefined symbols with PLT entries should be re-defined
2583 to be the PLT entry. */
2584
2585 /* If this is a weak symbol, and there is a real definition, the
2586 processor independent code will have arranged for us to see the
2587 real definition first, and we can just use the same value. */
60d67dc8 2588 if (h->is_weakalias)
202e2356 2589 {
60d67dc8
AM		 2590 struct elf_link_hash_entry *def = weakdef (h);
2591 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
2592 h->root.u.def.section = def->root.u.def.section;
2593 h->root.u.def.value = def->root.u.def.value;
202e2356
NC		 2594 return TRUE;
2595 }
2596
2597 /* If this is a reference to a symbol defined by a dynamic object which
2598 is not a function, we might allocate the symbol in our .dynbss section
2599 and allocate a COPY dynamic relocation.
2600
2601 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2602 of hackery. */
2603
2604 return TRUE;
2605}
2606
2607static bfd_boolean
2608elf64_ia64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2609 struct bfd_link_info *info)
2610{
2611 struct elf64_ia64_allocate_data data;
2612 struct elf64_ia64_link_hash_table *ia64_info;
2613 asection *sec;
2614 bfd *dynobj;
2615 struct elf_link_hash_table *hash_table;
2616
2617 hash_table = elf_hash_table (info);
2618 dynobj = hash_table->dynobj;
2619 ia64_info = elf64_ia64_hash_table (info);
2620 if (ia64_info == NULL)
2621 return FALSE;
2622 BFD_ASSERT(dynobj != NULL);
2623 data.info = info;
2624
2625 /* Allocate the GOT entries. */
2626
2627 if (ia64_info->root.sgot)
2628 {
2629 data.ofs = 0;
2630 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data);
2631 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data);
2632 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data);
2633 ia64_info->root.sgot->size = data.ofs;
2634 }
2635
2636 /* Allocate the FPTR entries. */
2637
2638 if (ia64_info->fptr_sec)
2639 {
2640 data.ofs = 0;
2641 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_fptr, &data);
2642 ia64_info->fptr_sec->size = data.ofs;
2643 }
2644
2645 /* Now that we've seen all of the input files, we can decide which
2646 symbols need plt entries. Allocate the minimal PLT entries first.
2647 We do this even though dynamic_sections_created may be FALSE, because
2648 this has the side-effect of clearing want_plt and want_plt2. */
2649
2650 data.ofs = 0;
2651 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_plt_entries, &data);
2652
2653 /* Align the pointer for the plt2 entries. */
2654 data.ofs = (data.ofs + 31) & (bfd_vma) -32;
2655
2656 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_plt2_entries, &data);
2657 if (data.ofs != 0 || ia64_info->root.dynamic_sections_created)
2658 {
2659 /* FIXME: we always reserve the memory for dynamic linker even if
2660 there are no PLT entries since dynamic linker may assume the
2661 reserved memory always exists. */
2662
2663 BFD_ASSERT (ia64_info->root.dynamic_sections_created);
2664
2665 ia64_info->root.splt->size = data.ofs;
2666 }
2667
2668 /* Allocate the PLTOFF entries. */
2669
2670 if (ia64_info->pltoff_sec)
2671 {
2672 data.ofs = 0;
2673 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_pltoff_entries, &data);
2674 ia64_info->pltoff_sec->size = data.ofs;
2675 }
2676
2677 if (ia64_info->root.dynamic_sections_created)
2678 {
2679 /* Allocate space for the dynamic relocations that turned out to be
2680 required. */
2681 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries, &data);
2682 }
2683
2684 /* We have now determined the sizes of the various dynamic sections.
2685 Allocate memory for them. */
2686 for (sec = dynobj->sections; sec != NULL; sec = sec->next)
2687 {
2688 bfd_boolean strip;
2689
2690 if (!(sec->flags & SEC_LINKER_CREATED))
2691 continue;
2692
2693 /* If we don't need this section, strip it from the output file.
2694 There were several sections primarily related to dynamic
2695 linking that must be create before the linker maps input
2696 sections to output sections. The linker does that before
2697 bfd_elf_size_dynamic_sections is called, and it is that
2698 function which decides whether anything needs to go into
2699 these sections. */
2700
2701 strip = (sec->size == 0);
2702
2703 if (sec == ia64_info->root.sgot)
2704 strip = FALSE;
2705 else if (sec == ia64_info->root.srelgot)
2706 {
2707 if (strip)
2708 ia64_info->root.srelgot = NULL;
2709 else
2710 /* We use the reloc_count field as a counter if we need to
2711 copy relocs into the output file. */
2712 sec->reloc_count = 0;
2713 }
2714 else if (sec == ia64_info->fptr_sec)
2715 {
2716 if (strip)
2717 ia64_info->fptr_sec = NULL;
2718 }
2719 else if (sec == ia64_info->rel_fptr_sec)
2720 {
2721 if (strip)
2722 ia64_info->rel_fptr_sec = NULL;
2723 else
2724 /* We use the reloc_count field as a counter if we need to
2725 copy relocs into the output file. */
2726 sec->reloc_count = 0;
2727 }
2728 else if (sec == ia64_info->root.splt)
2729 {
2730 if (strip)
2731 ia64_info->root.splt = NULL;
2732 }
2733 else if (sec == ia64_info->pltoff_sec)
2734 {
2735 if (strip)
2736 ia64_info->pltoff_sec = NULL;
2737 }
2738 else if (sec == ia64_info->fixups_sec)
2739 {
07d6d2b8
AM		 2740 if (strip)
2741 ia64_info->fixups_sec = NULL;
202e2356
NC		 2742 }
2743 else if (sec == ia64_info->transfer_sec)
07d6d2b8
AM		 2744 {
2745 ;
2746 }
202e2356
NC		 2747 else
2748 {
2749 const char *name;
2750
2751 /* It's OK to base decisions on the section name, because none
2752 of the dynobj section names depend upon the input files. */
2753 name = bfd_get_section_name (dynobj, sec);
2754
2755 if (strcmp (name, ".got.plt") == 0)
2756 strip = FALSE;
2757 else if (CONST_STRNEQ (name, ".rel"))
2758 {
2759 if (!strip)
2760 {
2761 /* We use the reloc_count field as a counter if we need to
2762 copy relocs into the output file. */
2763 sec->reloc_count = 0;
2764 }
2765 }
2766 else
2767 continue;
2768 }
2769
2770 if (strip)
2771 sec->flags |= SEC_EXCLUDE;
2772 else
2773 {
2774 /* Allocate memory for the section contents. */
2775 sec->contents = (bfd_byte *) bfd_zalloc (dynobj, sec->size);
2776 if (sec->contents == NULL && sec->size != 0)
2777 return FALSE;
2778 }
2779 }
2780
2781 if (elf_hash_table (info)->dynamic_sections_created)
2782 {
2783 bfd *abfd;
2784 asection *dynsec;
2785 asection *dynstrsec;
2786 Elf_Internal_Dyn dyn;
2787 const struct elf_backend_data *bed;
2788 unsigned int shl_num = 0;
2789 bfd_vma fixups_off = 0;
2790 bfd_vma strdyn_off;
2791 unsigned int time_hi, time_lo;
2792
2793 /* The .dynamic section must exist and be empty. */
3d4d4302 2794 dynsec = bfd_get_linker_section (hash_table->dynobj, ".dynamic");
202e2356
NC		 2795 BFD_ASSERT (dynsec != NULL);
2796 BFD_ASSERT (dynsec->size == 0);
2797
3d4d4302 2798 dynstrsec = bfd_get_linker_section (hash_table->dynobj, ".vmsdynstr");
202e2356
NC		 2799 BFD_ASSERT (dynstrsec != NULL);
2800 BFD_ASSERT (dynstrsec->size == 0);
2801 dynstrsec->size = 1; /* Initial blank. */
2802
2803 /* Ident + link time. */
2804 vms_get_time (&time_hi, &time_lo);
2805
2806 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_IDENT, 0))
07d6d2b8 2807 return FALSE;
202e2356 2808 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_LINKTIME,
07d6d2b8
AM		 2809 (((bfd_uint64_t)time_hi) << 32)
2810 + time_lo))
2811 return FALSE;
202e2356
NC		 2812
2813 /* Strtab. */
2814 strdyn_off = dynsec->size;
2815 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_STRTAB_OFFSET, 0))
07d6d2b8 2816 return FALSE;
202e2356 2817 if (!_bfd_elf_add_dynamic_entry (info, DT_STRSZ, 0))
07d6d2b8 2818 return FALSE;
202e2356
NC		 2819
2820 /* PLTGOT */
2821 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_PLTGOT_SEG, 0))
07d6d2b8 2822 return FALSE;
202e2356 2823 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_PLTGOT_OFFSET, 0))
07d6d2b8 2824 return FALSE;
202e2356
NC		 2825
2826 /* Misc. */
2827 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_FPMODE, 0x9800000))
07d6d2b8 2828 return FALSE;
202e2356 2829 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_LNKFLAGS,
07d6d2b8
AM		 2830 VMS_LF_IMGSTA | VMS_LF_MAIN))
2831 return FALSE;
202e2356
NC		 2832
2833 /* Add entries for shared libraries. */
c72f2fb2 2834 for (abfd = info->input_bfds; abfd; abfd = abfd->link.next)
07d6d2b8
AM		 2835 {
2836 char *soname;
2837 size_t soname_len;
2838 bfd_size_type strindex;
2839 bfd_byte *newcontents;
2840 bfd_vma fixups_shl_off;
2841
2842 if (!(abfd->flags & DYNAMIC))
2843 continue;
2844 BFD_ASSERT (abfd->xvec == output_bfd->xvec);
2845
2846 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_NEEDED_IDENT,
2847 elf_ia64_vms_ident (abfd)))
2848 return FALSE;
2849
2850 soname = vms_get_module_name (abfd->filename, TRUE);
2851 if (soname == NULL)
2852 return FALSE;
2853 strindex = dynstrsec->size;
2854 soname_len = strlen (soname) + 1;
2855 newcontents = (bfd_byte *) bfd_realloc (dynstrsec->contents,
2856 strindex + soname_len);
2857 if (newcontents == NULL)
2858 return FALSE;
2859 memcpy (newcontents + strindex, soname, soname_len);
2860 dynstrsec->size += soname_len;
2861 dynstrsec->contents = newcontents;
2862
2863 if (!_bfd_elf_add_dynamic_entry (info, DT_NEEDED, strindex))
2864 return FALSE;
2865
2866 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_FIXUP_NEEDED,
2867 shl_num))
2868 return FALSE;
2869 shl_num++;
2870
2871 /* The fixups_off was in fact containing the size of the fixup
2872 section. Remap into the offset. */
2873 fixups_shl_off = elf_ia64_vms_tdata (abfd)->fixups_off;
2874 elf_ia64_vms_tdata (abfd)->fixups_off = fixups_off;
2875
2876 if (!_bfd_elf_add_dynamic_entry
2877 (info, DT_IA_64_VMS_FIXUP_RELA_CNT,
2878 fixups_shl_off / sizeof (Elf64_External_VMS_IMAGE_FIXUP)))
2879 return FALSE;
2880 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_FIXUP_RELA_OFF,
2881 fixups_off))
2882 return FALSE;
2883 fixups_off += fixups_shl_off;
2884 }
202e2356
NC		 2885
2886 /* Unwind. */
2887 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWINDSZ, 0))
07d6d2b8 2888 return FALSE;
202e2356 2889 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWIND_CODSEG, 0))
07d6d2b8 2890 return FALSE;
202e2356 2891 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWIND_INFOSEG, 0))
07d6d2b8 2892 return FALSE;
202e2356 2893 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWIND_OFFSET, 0))
07d6d2b8 2894 return FALSE;
202e2356 2895 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWIND_SEG, 0))
07d6d2b8 2896 return FALSE;
202e2356
NC		 2897
2898 if (!_bfd_elf_add_dynamic_entry (info, DT_NULL, 0xdead))
07d6d2b8 2899 return FALSE;
202e2356
NC		 2900
2901 /* Fix the strtab entries. */
2902 bed = get_elf_backend_data (hash_table->dynobj);
2903
2904 if (dynstrsec->size > 1)
07d6d2b8 2905 dynstrsec->contents[0] = 0;
202e2356 2906 else
07d6d2b8 2907 dynstrsec->size = 0;
202e2356
NC		 2908
2909 /* Note: one 'spare' (ie DT_NULL) entry is added by
07d6d2b8 2910 bfd_elf_size_dynsym_hash_dynstr. */
202e2356
NC		 2911 dyn.d_tag = DT_IA_64_VMS_STRTAB_OFFSET;
2912 dyn.d_un.d_val = dynsec->size /* + sizeof (Elf64_External_Dyn) */;
2913 bed->s->swap_dyn_out (hash_table->dynobj, &dyn,
07d6d2b8 2914 dynsec->contents + strdyn_off);
202e2356
NC		 2915
2916 dyn.d_tag = DT_STRSZ;
2917 dyn.d_un.d_val = dynstrsec->size;
2918 bed->s->swap_dyn_out (hash_table->dynobj, &dyn,
07d6d2b8 2919 dynsec->contents + strdyn_off + bed->s->sizeof_dyn);
202e2356
NC		 2920
2921 elf_ia64_vms_tdata (output_bfd)->needed_count = shl_num;
2922
2923 /* Note section. */
2924 if (!create_ia64_vms_notes (output_bfd, info, time_hi, time_lo))
07d6d2b8 2925 return FALSE;
202e2356
NC		 2926 }
2927
2928 /* ??? Perhaps force __gp local. */
2929
2930 return TRUE;
2931}
2932
2933static void
2934elf64_ia64_install_fixup (bfd *output_bfd,
07d6d2b8
AM		 2935 struct elf64_ia64_link_hash_table *ia64_info,
2936 struct elf_link_hash_entry *h,
2937 unsigned int type, asection *sec, bfd_vma offset,
2938 bfd_vma addend)
202e2356
NC		 2939{
2940 asection *relsec;
2941 Elf64_External_VMS_IMAGE_FIXUP *fixup;
2942 struct elf64_ia64_link_hash_entry *h_ia64;
2943 bfd_vma fixoff;
2944 Elf_Internal_Phdr *phdr;
2945
2946 if (h == NULL || !h->def_dynamic)
2947 abort ();
2948
2949 h_ia64 = (struct elf64_ia64_link_hash_entry *) h;
2950 fixoff = elf_ia64_vms_tdata (h_ia64->shl)->fixups_off;
2951 elf_ia64_vms_tdata (h_ia64->shl)->fixups_off +=
2952 sizeof (Elf64_External_VMS_IMAGE_FIXUP);
2953 relsec = ia64_info->fixups_sec;
2954
2955 fixup = (Elf64_External_VMS_IMAGE_FIXUP *)(relsec->contents + fixoff);
2956 offset += sec->output_section->vma + sec->output_offset;
2957
2958 /* FIXME: this is slow. We should cache the last one used, or create a
2959 map. */
2960 phdr = _bfd_elf_find_segment_containing_section
2961 (output_bfd, sec->output_section);
2962 BFD_ASSERT (phdr != NULL);
2963
2964 bfd_putl64 (offset - phdr->p_vaddr, fixup->fixup_offset);
2965 bfd_putl32 (type, fixup->type);
2966 bfd_putl32 (phdr - elf_tdata (output_bfd)->phdr, fixup->fixup_seg);
2967 bfd_putl64 (addend, fixup->addend);
2968 bfd_putl32 (h->root.u.def.value, fixup->symvec_index);
2969 bfd_putl32 (2, fixup->data_type);
2970}
2971
2972/* Store an entry for target address TARGET_ADDR in the linkage table
2973 and return the gp-relative address of the linkage table entry. */
2974
2975static bfd_vma
2976set_got_entry (bfd *abfd, struct bfd_link_info *info,
2977 struct elf64_ia64_dyn_sym_info *dyn_i,
2978 bfd_vma addend, bfd_vma value, unsigned int dyn_r_type)
2979{
2980 struct elf64_ia64_link_hash_table *ia64_info;
2981 asection *got_sec;
2982 bfd_boolean done;
2983 bfd_vma got_offset;
2984
2985 ia64_info = elf64_ia64_hash_table (info);
2986 if (ia64_info == NULL)
2987 return 0;
2988
2989 got_sec = ia64_info->root.sgot;
2990
2991 switch (dyn_r_type)
2992 {
2993 case R_IA64_TPREL64LSB:
2994 case R_IA64_DTPMOD64LSB:
2995 case R_IA64_DTPREL32LSB:
2996 case R_IA64_DTPREL64LSB:
2997 abort ();
2998 break;
2999 default:
3000 done = dyn_i->got_done;
3001 dyn_i->got_done = TRUE;
3002 got_offset = dyn_i->got_offset;
3003 break;
3004 }
3005
3006 BFD_ASSERT ((got_offset & 7) == 0);
3007
3008 if (! done)
3009 {
3010 /* Store the target address in the linkage table entry. */
3011 bfd_put_64 (abfd, value, got_sec->contents + got_offset);
3012
3013 /* Install a dynamic relocation if needed. */
0e1862bb 3014 if (((bfd_link_pic (info)
202e2356
NC		 3015 && (!dyn_i->h
3016 || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
3017 || dyn_i->h->root.type != bfd_link_hash_undefweak))
07d6d2b8 3018 || elf64_ia64_dynamic_symbol_p (dyn_i->h))
202e2356 3019 && (!dyn_i->want_ltoff_fptr
0e1862bb 3020 || !bfd_link_pie (info)
202e2356
NC		 3021 || !dyn_i->h
3022 || dyn_i->h->root.type != bfd_link_hash_undefweak))
3023 {
3024 if (!dyn_i->h || !dyn_i->h->def_dynamic)
3025 {
3026 dyn_r_type = R_IA64_REL64LSB;
3027 addend = value;
3028 }
3029
07d6d2b8
AM		 3030 /* VMS: install a FIX32 or FIX64. */
3031 switch (dyn_r_type)
3032 {
3033 case R_IA64_DIR32LSB:
3034 case R_IA64_FPTR32LSB:
3035 dyn_r_type = R_IA64_VMS_FIX32;
3036 break;
3037 case R_IA64_DIR64LSB:
3038 case R_IA64_FPTR64LSB:
3039 dyn_r_type = R_IA64_VMS_FIX64;
3040 break;
3041 default:
3042 BFD_ASSERT (FALSE);
3043 break;
3044 }
3045 elf64_ia64_install_fixup
3046 (info->output_bfd, ia64_info, dyn_i->h,
3047 dyn_r_type, got_sec, got_offset, addend);
3048 }
202e2356
NC		 3049 }
3050
3051 /* Return the address of the linkage table entry. */
3052 value = (got_sec->output_section->vma
3053 + got_sec->output_offset
3054 + got_offset);
3055
3056 return value;
3057}
3058
3059/* Fill in a function descriptor consisting of the function's code
3060 address and its global pointer. Return the descriptor's address. */
3061
3062static bfd_vma
3063set_fptr_entry (bfd *abfd, struct bfd_link_info *info,
3064 struct elf64_ia64_dyn_sym_info *dyn_i,
3065 bfd_vma value)
3066{
3067 struct elf64_ia64_link_hash_table *ia64_info;
3068 asection *fptr_sec;
3069
3070 ia64_info = elf64_ia64_hash_table (info);
3071 if (ia64_info == NULL)
3072 return 0;
3073
3074 fptr_sec = ia64_info->fptr_sec;
3075
3076 if (!dyn_i->fptr_done)
3077 {
3078 dyn_i->fptr_done = 1;
3079
3080 /* Fill in the function descriptor. */
3081 bfd_put_64 (abfd, value, fptr_sec->contents + dyn_i->fptr_offset);
3082 bfd_put_64 (abfd, _bfd_get_gp_value (abfd),
3083 fptr_sec->contents + dyn_i->fptr_offset + 8);
3084 }
3085
3086 /* Return the descriptor's address. */
3087 value = (fptr_sec->output_section->vma
3088 + fptr_sec->output_offset
3089 + dyn_i->fptr_offset);
3090
3091 return value;
3092}
3093
3094/* Fill in a PLTOFF entry consisting of the function's code address
3095 and its global pointer. Return the descriptor's address. */
3096
3097static bfd_vma
3098set_pltoff_entry (bfd *abfd, struct bfd_link_info *info,
3099 struct elf64_ia64_dyn_sym_info *dyn_i,
3100 bfd_vma value, bfd_boolean is_plt)
3101{
3102 struct elf64_ia64_link_hash_table *ia64_info;
3103 asection *pltoff_sec;
3104
3105 ia64_info = elf64_ia64_hash_table (info);
3106 if (ia64_info == NULL)
3107 return 0;
3108
3109 pltoff_sec = ia64_info->pltoff_sec;
3110
3111 /* Don't do anything if this symbol uses a real PLT entry. In
3112 that case, we'll fill this in during finish_dynamic_symbol. */
3113 if ((! dyn_i->want_plt || is_plt)
3114 && !dyn_i->pltoff_done)
3115 {
3116 bfd_vma gp = _bfd_get_gp_value (abfd);
3117
3118 /* Fill in the function descriptor. */
3119 bfd_put_64 (abfd, value, pltoff_sec->contents + dyn_i->pltoff_offset);
3120 bfd_put_64 (abfd, gp, pltoff_sec->contents + dyn_i->pltoff_offset + 8);
3121
3122 /* Install dynamic relocations if needed. */
3123 if (!is_plt
0e1862bb 3124 && bfd_link_pic (info)
202e2356
NC		 3125 && (!dyn_i->h
3126 || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
3127 || dyn_i->h->root.type != bfd_link_hash_undefweak))
3128 {
07d6d2b8
AM		 3129 /* VMS: */
3130 abort ();
202e2356
NC		 3131 }
3132
3133 dyn_i->pltoff_done = 1;
3134 }
3135
3136 /* Return the descriptor's address. */
3137 value = (pltoff_sec->output_section->vma
3138 + pltoff_sec->output_offset
3139 + dyn_i->pltoff_offset);
3140
3141 return value;
3142}
3143
3144/* Called through qsort to sort the .IA_64.unwind section during a
3145 non-relocatable link. Set elf64_ia64_unwind_entry_compare_bfd
3146 to the output bfd so we can do proper endianness frobbing. */
3147
3148static bfd *elf64_ia64_unwind_entry_compare_bfd;
3149
3150static int
3151elf64_ia64_unwind_entry_compare (const void * a, const void * b)
3152{
3153 bfd_vma av, bv;
3154
3155 av = bfd_get_64 (elf64_ia64_unwind_entry_compare_bfd, a);
3156 bv = bfd_get_64 (elf64_ia64_unwind_entry_compare_bfd, b);
3157
3158 return (av < bv ? -1 : av > bv ? 1 : 0);
3159}
3160
3161/* Make sure we've got ourselves a nice fat __gp value. */
3162static bfd_boolean
3163elf64_ia64_choose_gp (bfd *abfd, struct bfd_link_info *info, bfd_boolean final)
3164{
3165 bfd_vma min_vma = (bfd_vma) -1, max_vma = 0;
3166 bfd_vma min_short_vma = min_vma, max_short_vma = 0;
3167 struct elf_link_hash_entry *gp;
3168 bfd_vma gp_val;
3169 asection *os;
3170 struct elf64_ia64_link_hash_table *ia64_info;
3171
3172 ia64_info = elf64_ia64_hash_table (info);
3173 if (ia64_info == NULL)
3174 return FALSE;
3175
3176 /* Find the min and max vma of all sections marked short. Also collect
3177 min and max vma of any type, for use in selecting a nice gp. */
3178 for (os = abfd->sections; os ; os = os->next)
3179 {
3180 bfd_vma lo, hi;
3181
3182 if ((os->flags & SEC_ALLOC) == 0)
3183 continue;
3184
3185 lo = os->vma;
3186 /* When this function is called from elfNN_ia64_final_link
3187 the correct value to use is os->size. When called from
3188 elfNN_ia64_relax_section we are in the middle of section
3189 sizing; some sections will already have os->size set, others
3190 will have os->size zero and os->rawsize the previous size. */
3191 hi = os->vma + (!final && os->rawsize ? os->rawsize : os->size);
3192 if (hi < lo)
3193 hi = (bfd_vma) -1;
3194
3195 if (min_vma > lo)
3196 min_vma = lo;
3197 if (max_vma < hi)
3198 max_vma = hi;
3199 if (os->flags & SEC_SMALL_DATA)
3200 {
3201 if (min_short_vma > lo)
3202 min_short_vma = lo;
3203 if (max_short_vma < hi)
3204 max_short_vma = hi;
3205 }
3206 }
3207
3208 if (ia64_info->min_short_sec)
3209 {
3210 if (min_short_vma
3211 > (ia64_info->min_short_sec->vma
3212 + ia64_info->min_short_offset))
3213 min_short_vma = (ia64_info->min_short_sec->vma
3214 + ia64_info->min_short_offset);
3215 if (max_short_vma
3216 < (ia64_info->max_short_sec->vma
3217 + ia64_info->max_short_offset))
3218 max_short_vma = (ia64_info->max_short_sec->vma
3219 + ia64_info->max_short_offset);
3220 }
3221
3222 /* See if the user wants to force a value. */
3223 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
3224 FALSE, FALSE);
3225
3226 if (gp
3227 && (gp->root.type == bfd_link_hash_defined
3228 || gp->root.type == bfd_link_hash_defweak))
3229 {
3230 asection *gp_sec = gp->root.u.def.section;
3231 gp_val = (gp->root.u.def.value
3232 + gp_sec->output_section->vma
3233 + gp_sec->output_offset);
3234 }
3235 else
3236 {
3237 /* Pick a sensible value. */
3238
3239 if (ia64_info->min_short_sec)
3240 {
3241 bfd_vma short_range = max_short_vma - min_short_vma;
3242
3243 /* If min_short_sec is set, pick one in the middle bewteen
3244 min_short_vma and max_short_vma. */
3245 if (short_range >= 0x400000)
3246 goto overflow;
3247 gp_val = min_short_vma + short_range / 2;
3248 }
3249 else
3250 {
3251 asection *got_sec = ia64_info->root.sgot;
3252
3253 /* Start with just the address of the .got. */
3254 if (got_sec)
3255 gp_val = got_sec->output_section->vma;
3256 else if (max_short_vma != 0)
3257 gp_val = min_short_vma;
3258 else if (max_vma - min_vma < 0x200000)
3259 gp_val = min_vma;
3260 else
3261 gp_val = max_vma - 0x200000 + 8;
3262 }
3263
3264 /* If it is possible to address the entire image, but we
3265 don't with the choice above, adjust. */
3266 if (max_vma - min_vma < 0x400000
3267 && (max_vma - gp_val >= 0x200000
3268 || gp_val - min_vma > 0x200000))
3269 gp_val = min_vma + 0x200000;
3270 else if (max_short_vma != 0)
3271 {
3272 /* If we don't cover all the short data, adjust. */
3273 if (max_short_vma - gp_val >= 0x200000)
3274 gp_val = min_short_vma + 0x200000;
3275
3276 /* If we're addressing stuff past the end, adjust back. */
3277 if (gp_val > max_vma)
3278 gp_val = max_vma - 0x200000 + 8;
3279 }
3280 }
3281
3282 /* Validate whether all SHF_IA_64_SHORT sections are within
3283 range of the chosen GP. */
3284
3285 if (max_short_vma != 0)
3286 {
3287 if (max_short_vma - min_short_vma >= 0x400000)
3288 {
3289overflow:
4eca0228 3290 _bfd_error_handler
695344c0 3291 /* xgettext:c-format */
2dcf00ce
AM		 3292 (_("%pB: short data segment overflowed (%#" PRIx64 " >= 0x400000)"),
3293 abfd, (uint64_t) (max_short_vma - min_short_vma));
202e2356
NC		 3294 return FALSE;
3295 }
3296 else if ((gp_val > min_short_vma
3297 && gp_val - min_short_vma > 0x200000)
3298 || (gp_val < max_short_vma
3299 && max_short_vma - gp_val >= 0x200000))
3300 {
4eca0228 3301 _bfd_error_handler
871b3ab2 3302 (_("%pB: __gp does not cover short data segment"), abfd);
202e2356
NC		 3303 return FALSE;
3304 }
3305 }
3306
3307 _bfd_set_gp_value (abfd, gp_val);
3308
3309 return TRUE;
3310}
3311
3312static bfd_boolean
3313elf64_ia64_final_link (bfd *abfd, struct bfd_link_info *info)
3314{
3315 struct elf64_ia64_link_hash_table *ia64_info;
3316 asection *unwind_output_sec;
3317
3318 ia64_info = elf64_ia64_hash_table (info);
3319 if (ia64_info == NULL)
3320 return FALSE;
3321
3322 /* Make sure we've got ourselves a nice fat __gp value. */
0e1862bb 3323 if (!bfd_link_relocatable (info))
202e2356
NC		 3324 {
3325 bfd_vma gp_val;
3326 struct elf_link_hash_entry *gp;
3327
3328 /* We assume after gp is set, section size will only decrease. We
3329 need to adjust gp for it. */
3330 _bfd_set_gp_value (abfd, 0);
3331 if (! elf64_ia64_choose_gp (abfd, info, TRUE))
3332 return FALSE;
3333 gp_val = _bfd_get_gp_value (abfd);
3334
3335 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
07d6d2b8 3336 FALSE, FALSE);
202e2356
NC		 3337 if (gp)
3338 {
3339 gp->root.type = bfd_link_hash_defined;
3340 gp->root.u.def.value = gp_val;
3341 gp->root.u.def.section = bfd_abs_section_ptr;
3342 }
3343 }
3344
3345 /* If we're producing a final executable, we need to sort the contents
3346 of the .IA_64.unwind section. Force this section to be relocated
3347 into memory rather than written immediately to the output file. */
3348 unwind_output_sec = NULL;
0e1862bb 3349 if (!bfd_link_relocatable (info))
202e2356
NC		 3350 {
3351 asection *s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind);
3352 if (s)
3353 {
3354 unwind_output_sec = s->output_section;
3355 unwind_output_sec->contents
3356 = bfd_malloc (unwind_output_sec->size);
3357 if (unwind_output_sec->contents == NULL)
3358 return FALSE;
3359 }
3360 }
3361
3362 /* Invoke the regular ELF backend linker to do all the work. */
3363 if (!bfd_elf_final_link (abfd, info))
3364 return FALSE;
3365
3366 if (unwind_output_sec)
3367 {
3368 elf64_ia64_unwind_entry_compare_bfd = abfd;
3369 qsort (unwind_output_sec->contents,
3370 (size_t) (unwind_output_sec->size / 24),
3371 24,
3372 elf64_ia64_unwind_entry_compare);
3373
3374 if (! bfd_set_section_contents (abfd, unwind_output_sec,
3375 unwind_output_sec->contents, (bfd_vma) 0,
3376 unwind_output_sec->size))
3377 return FALSE;
3378 }
3379
3380 return TRUE;
3381}
3382
3383static bfd_boolean
3384elf64_ia64_relocate_section (bfd *output_bfd,
3385 struct bfd_link_info *info,
3386 bfd *input_bfd,
3387 asection *input_section,
3388 bfd_byte *contents,
3389 Elf_Internal_Rela *relocs,
3390 Elf_Internal_Sym *local_syms,
3391 asection **local_sections)
3392{
3393 struct elf64_ia64_link_hash_table *ia64_info;
3394 Elf_Internal_Shdr *symtab_hdr;
3395 Elf_Internal_Rela *rel;
3396 Elf_Internal_Rela *relend;
3397 bfd_boolean ret_val = TRUE; /* for non-fatal errors */
3398 bfd_vma gp_val;
3399
3400 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3401 ia64_info = elf64_ia64_hash_table (info);
3402 if (ia64_info == NULL)
3403 return FALSE;
3404
3405 /* Infect various flags from the input section to the output section. */
0e1862bb 3406 if (bfd_link_relocatable (info))
202e2356
NC		 3407 {
3408 bfd_vma flags;
3409
3410 flags = elf_section_data(input_section)->this_hdr.sh_flags;
3411 flags &= SHF_IA_64_NORECOV;
3412
3413 elf_section_data(input_section->output_section)
3414 ->this_hdr.sh_flags |= flags;
3415 }
3416
3417 gp_val = _bfd_get_gp_value (output_bfd);
3418
3419 rel = relocs;
3420 relend = relocs + input_section->reloc_count;
3421 for (; rel < relend; ++rel)
3422 {
3423 struct elf_link_hash_entry *h;
3424 struct elf64_ia64_dyn_sym_info *dyn_i;
3425 bfd_reloc_status_type r;
3426 reloc_howto_type *howto;
3427 unsigned long r_symndx;
3428 Elf_Internal_Sym *sym;
3429 unsigned int r_type;
3430 bfd_vma value;
3431 asection *sym_sec;
3432 bfd_byte *hit_addr;
3433 bfd_boolean dynamic_symbol_p;
3434 bfd_boolean undef_weak_ref;
3435
3436 r_type = ELF64_R_TYPE (rel->r_info);
3437 if (r_type > R_IA64_MAX_RELOC_CODE)
3438 {
0aa13fee
AM		 3439 /* xgettext:c-format */
3440 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
3441 input_bfd, (int) r_type);
202e2356
NC		 3442 bfd_set_error (bfd_error_bad_value);
3443 ret_val = FALSE;
3444 continue;
3445 }
3446
3447 howto = ia64_elf_lookup_howto (r_type);
f3185997
NC		 3448 if (howto == NULL)
3449 {
3450 ret_val = FALSE;
3451 continue;
3452 }
202e2356
NC		 3453 r_symndx = ELF64_R_SYM (rel->r_info);
3454 h = NULL;
3455 sym = NULL;
3456 sym_sec = NULL;
3457 undef_weak_ref = FALSE;
3458
3459 if (r_symndx < symtab_hdr->sh_info)
3460 {
3461 /* Reloc against local symbol. */
3462 asection *msec;
3463 sym = local_syms + r_symndx;
3464 sym_sec = local_sections[r_symndx];
3465 msec = sym_sec;
3466 value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
0e1862bb 3467 if (!bfd_link_relocatable (info)
202e2356
NC		 3468 && (sym_sec->flags & SEC_MERGE) != 0
3469 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
dbaa2011 3470 && sym_sec->sec_info_type == SEC_INFO_TYPE_MERGE)
202e2356
NC		 3471 {
3472 struct elf64_ia64_local_hash_entry *loc_h;
3473
3474 loc_h = get_local_sym_hash (ia64_info, input_bfd, rel, FALSE);
3475 if (loc_h && ! loc_h->sec_merge_done)
3476 {
3477 struct elf64_ia64_dyn_sym_info *dynent;
3478 unsigned int count;
3479
3480 for (count = loc_h->count, dynent = loc_h->info;
3481 count != 0;
3482 count--, dynent++)
3483 {
3484 msec = sym_sec;
3485 dynent->addend =
3486 _bfd_merged_section_offset (output_bfd, &msec,
3487 elf_section_data (msec)->
3488 sec_info,
3489 sym->st_value
3490 + dynent->addend);
3491 dynent->addend -= sym->st_value;
3492 dynent->addend += msec->output_section->vma
3493 + msec->output_offset
3494 - sym_sec->output_section->vma
3495 - sym_sec->output_offset;
3496 }
3497
3498 /* We may have introduced duplicated entries. We need
3499 to remove them properly. */
3500 count = sort_dyn_sym_info (loc_h->info, loc_h->count);
3501 if (count != loc_h->count)
3502 {
3503 loc_h->count = count;
3504 loc_h->sorted_count = count;
3505 }
3506
3507 loc_h->sec_merge_done = 1;
3508 }
3509 }
3510 }
3511 else
3512 {
3513 bfd_boolean unresolved_reloc;
62d887d4 3514 bfd_boolean warned, ignored;
202e2356
NC		 3515 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
3516
3517 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3518 r_symndx, symtab_hdr, sym_hashes,
3519 h, sym_sec, value,
62d887d4 3520 unresolved_reloc, warned, ignored);
202e2356
NC		 3521
3522 if (h->root.type == bfd_link_hash_undefweak)
3523 undef_weak_ref = TRUE;
3524 else if (warned)
3525 continue;
3526 }
3527
3528 /* For relocs against symbols from removed linkonce sections,
3529 or sections discarded by a linker script, we just want the
3530 section contents zeroed. Avoid any special processing. */
dbaa2011 3531 if (sym_sec != NULL && discarded_section (sym_sec))
202e2356 3532 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2de5d135 3533 rel, 1, relend, howto, 0, contents);
202e2356 3534
0e1862bb 3535 if (bfd_link_relocatable (info))
202e2356
NC		 3536 continue;
3537
3538 hit_addr = contents + rel->r_offset;
3539 value += rel->r_addend;
3540 dynamic_symbol_p = elf64_ia64_dynamic_symbol_p (h);
3541
3542 switch (r_type)
3543 {
3544 case R_IA64_NONE:
3545 case R_IA64_LDXMOV:
3546 continue;
3547
3548 case R_IA64_IMM14:
3549 case R_IA64_IMM22:
3550 case R_IA64_IMM64:
3551 case R_IA64_DIR32MSB:
3552 case R_IA64_DIR32LSB:
3553 case R_IA64_DIR64MSB:
3554 case R_IA64_DIR64LSB:
3555 /* Install a dynamic relocation for this reloc. */
0e1862bb 3556 if ((dynamic_symbol_p || bfd_link_pic (info))
202e2356
NC		 3557 && r_symndx != 0
3558 && (input_section->flags & SEC_ALLOC) != 0)
3559 {
3560 unsigned int dyn_r_type;
3561 bfd_vma addend;
3562
3563 switch (r_type)
3564 {
3565 case R_IA64_IMM14:
3566 case R_IA64_IMM22:
3567 case R_IA64_IMM64:
3568 /* ??? People shouldn't be doing non-pic code in
3569 shared libraries nor dynamic executables. */
4eca0228 3570 _bfd_error_handler
695344c0 3571 /* xgettext:c-format */
871b3ab2 3572 (_("%pB: non-pic code with imm relocation against"
63a5468a 3573 " dynamic symbol `%s'"),
202e2356
NC		 3574 input_bfd,
3575 h ? h->root.root.string
3576 : bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3577 sym_sec));
3578 ret_val = FALSE;
3579 continue;
3580
3581 default:
3582 break;
3583 }
3584
3585 /* If we don't need dynamic symbol lookup, find a
3586 matching RELATIVE relocation. */
3587 dyn_r_type = r_type;
3588 if (dynamic_symbol_p)
3589 {
3590 addend = rel->r_addend;
3591 value = 0;
3592 }
3593 else
3594 {
3595 addend = value;
3596 }
3597
07d6d2b8
AM		 3598 /* VMS: install a FIX64. */
3599 switch (dyn_r_type)
3600 {
3601 case R_IA64_DIR32LSB:
3602 dyn_r_type = R_IA64_VMS_FIX32;
3603 break;
3604 case R_IA64_DIR64LSB:
3605 dyn_r_type = R_IA64_VMS_FIX64;
3606 break;
3607 default:
3608 BFD_ASSERT (FALSE);
3609 break;
3610 }
3611 elf64_ia64_install_fixup
3612 (output_bfd, ia64_info, h,
3613 dyn_r_type, input_section, rel->r_offset, addend);
3614 r = bfd_reloc_ok;
3615 break;
202e2356
NC		 3616 }
3617 /* Fall through. */
3618
3619 case R_IA64_LTV32MSB:
3620 case R_IA64_LTV32LSB:
3621 case R_IA64_LTV64MSB:
3622 case R_IA64_LTV64LSB:
3623 r = ia64_elf_install_value (hit_addr, value, r_type);
3624 break;
3625
3626 case R_IA64_GPREL22:
3627 case R_IA64_GPREL64I:
3628 case R_IA64_GPREL32MSB:
3629 case R_IA64_GPREL32LSB:
3630 case R_IA64_GPREL64MSB:
3631 case R_IA64_GPREL64LSB:
3632 if (dynamic_symbol_p)
3633 {
4eca0228 3634 _bfd_error_handler
695344c0 3635 /* xgettext:c-format */
871b3ab2 3636 (_("%pB: @gprel relocation against dynamic symbol %s"),
202e2356
NC		 3637 input_bfd,
3638 h ? h->root.root.string
3639 : bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3640 sym_sec));
3641 ret_val = FALSE;
3642 continue;
3643 }
3644 value -= gp_val;
3645 r = ia64_elf_install_value (hit_addr, value, r_type);
3646 break;
3647
3648 case R_IA64_LTOFF22:
3649 case R_IA64_LTOFF22X:
3650 case R_IA64_LTOFF64I:
07d6d2b8 3651 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
202e2356
NC		 3652 value = set_got_entry (input_bfd, info, dyn_i,
3653 rel->r_addend, value, R_IA64_DIR64LSB);
3654 value -= gp_val;
3655 r = ia64_elf_install_value (hit_addr, value, r_type);
3656 break;
3657
3658 case R_IA64_PLTOFF22:
3659 case R_IA64_PLTOFF64I:
3660 case R_IA64_PLTOFF64MSB:
3661 case R_IA64_PLTOFF64LSB:
07d6d2b8 3662 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
202e2356
NC		 3663 value = set_pltoff_entry (output_bfd, info, dyn_i, value, FALSE);
3664 value -= gp_val;
3665 r = ia64_elf_install_value (hit_addr, value, r_type);
3666 break;
3667
3668 case R_IA64_FPTR64I:
3669 case R_IA64_FPTR32MSB:
3670 case R_IA64_FPTR32LSB:
3671 case R_IA64_FPTR64MSB:
3672 case R_IA64_FPTR64LSB:
07d6d2b8 3673 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
202e2356
NC		 3674 if (dyn_i->want_fptr)
3675 {
3676 if (!undef_weak_ref)
3677 value = set_fptr_entry (output_bfd, info, dyn_i, value);
3678 }
0e1862bb 3679 if (!dyn_i->want_fptr || bfd_link_pie (info))
202e2356
NC		 3680 {
3681 /* Otherwise, we expect the dynamic linker to create
3682 the entry. */
3683
3684 if (dyn_i->want_fptr)
3685 {
3686 if (r_type == R_IA64_FPTR64I)
3687 {
3688 /* We can't represent this without a dynamic symbol.
3689 Adjust the relocation to be against an output
3690 section symbol, which are always present in the
3691 dynamic symbol table. */
3692 /* ??? People shouldn't be doing non-pic code in
3693 shared libraries. Hork. */
4eca0228 3694 _bfd_error_handler
871b3ab2 3695 (_("%pB: linking non-pic code in a position independent executable"),
202e2356
NC		 3696 input_bfd);
3697 ret_val = FALSE;
3698 continue;
3699 }
3700 }
3701 else
3702 {
3703 value = 0;
3704 }
3705
07d6d2b8
AM		 3706 /* VMS: FIXFD. */
3707 elf64_ia64_install_fixup
3708 (output_bfd, ia64_info, h, R_IA64_VMS_FIXFD,
3709 input_section, rel->r_offset, 0);
3710 r = bfd_reloc_ok;
3711 break;
202e2356
NC		 3712 }
3713
3714 r = ia64_elf_install_value (hit_addr, value, r_type);
3715 break;
3716
3717 case R_IA64_LTOFF_FPTR22:
3718 case R_IA64_LTOFF_FPTR64I:
3719 case R_IA64_LTOFF_FPTR32MSB:
3720 case R_IA64_LTOFF_FPTR32LSB:
3721 case R_IA64_LTOFF_FPTR64MSB:
3722 case R_IA64_LTOFF_FPTR64LSB:
07d6d2b8
AM		 3723 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
3724 if (dyn_i->want_fptr)
3725 {
3726 BFD_ASSERT (h == NULL || !h->def_dynamic);
3727 if (!undef_weak_ref)
3728 value = set_fptr_entry (output_bfd, info, dyn_i, value);
3729 }
3730 else
3731 value = 0;
3732
3733 value = set_got_entry (output_bfd, info, dyn_i,
3734 rel->r_addend, value, R_IA64_FPTR64LSB);
3735 value -= gp_val;
3736 r = ia64_elf_install_value (hit_addr, value, r_type);
202e2356
NC		 3737 break;
3738
3739 case R_IA64_PCREL32MSB:
3740 case R_IA64_PCREL32LSB:
3741 case R_IA64_PCREL64MSB:
3742 case R_IA64_PCREL64LSB:
3743 /* Install a dynamic relocation for this reloc. */
3744 if (dynamic_symbol_p && r_symndx != 0)
3745 {
07d6d2b8
AM		 3746 /* VMS: doesn't exist ??? */
3747 abort ();
202e2356
NC		 3748 }
3749 goto finish_pcrel;
3750
3751 case R_IA64_PCREL21B:
3752 case R_IA64_PCREL60B:
3753 /* We should have created a PLT entry for any dynamic symbol. */
3754 dyn_i = NULL;
3755 if (h)
3756 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE);
3757
3758 if (dyn_i && dyn_i->want_plt2)
3759 {
3760 /* Should have caught this earlier. */
3761 BFD_ASSERT (rel->r_addend == 0);
3762
3763 value = (ia64_info->root.splt->output_section->vma
3764 + ia64_info->root.splt->output_offset
3765 + dyn_i->plt2_offset);
3766 }
3767 else
3768 {
3769 /* Since there's no PLT entry, Validate that this is
3770 locally defined. */
3771 BFD_ASSERT (undef_weak_ref || sym_sec->output_section != NULL);
3772
3773 /* If the symbol is undef_weak, we shouldn't be trying
3774 to call it. There's every chance that we'd wind up
3775 with an out-of-range fixup here. Don't bother setting
3776 any value at all. */
3777 if (undef_weak_ref)
3778 continue;
3779 }
3780 goto finish_pcrel;
3781
3782 case R_IA64_PCREL21BI:
3783 case R_IA64_PCREL21F:
3784 case R_IA64_PCREL21M:
3785 case R_IA64_PCREL22:
3786 case R_IA64_PCREL64I:
3787 /* The PCREL21BI reloc is specifically not intended for use with
3788 dynamic relocs. PCREL21F and PCREL21M are used for speculation
3789 fixup code, and thus probably ought not be dynamic. The
3790 PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs. */
3791 if (dynamic_symbol_p)
3792 {
3793 const char *msg;
3794
3795 if (r_type == R_IA64_PCREL21BI)
695344c0 3796 /* xgettext:c-format */
871b3ab2 3797 msg = _("%pB: @internal branch to dynamic symbol %s");
202e2356 3798 else if (r_type == R_IA64_PCREL21F || r_type == R_IA64_PCREL21M)
695344c0 3799 /* xgettext:c-format */
871b3ab2 3800 msg = _("%pB: speculation fixup to dynamic symbol %s");
202e2356 3801 else
695344c0 3802 /* xgettext:c-format */
871b3ab2 3803 msg = _("%pB: @pcrel relocation against dynamic symbol %s");
4eca0228
AM		 3804 _bfd_error_handler (msg, input_bfd,
3805 h ? h->root.root.string
3806 : bfd_elf_sym_name (input_bfd,
3807 symtab_hdr,
3808 sym,
3809 sym_sec));
202e2356
NC		 3810 ret_val = FALSE;
3811 continue;
3812 }
3813 goto finish_pcrel;
3814
3815 finish_pcrel:
3816 /* Make pc-relative. */
3817 value -= (input_section->output_section->vma
3818 + input_section->output_offset
3819 + rel->r_offset) & ~ (bfd_vma) 0x3;
3820 r = ia64_elf_install_value (hit_addr, value, r_type);
3821 break;
3822
3823 case R_IA64_SEGREL32MSB:
3824 case R_IA64_SEGREL32LSB:
3825 case R_IA64_SEGREL64MSB:
3826 case R_IA64_SEGREL64LSB:
3827 {
3828 /* Find the segment that contains the output_section. */
3829 Elf_Internal_Phdr *p = _bfd_elf_find_segment_containing_section
3830 (output_bfd, sym_sec->output_section);
3831
3832 if (p == NULL)
3833 {
3834 r = bfd_reloc_notsupported;
3835 }
3836 else
3837 {
3838 /* The VMA of the segment is the vaddr of the associated
3839 program header. */
3840 if (value > p->p_vaddr)
3841 value -= p->p_vaddr;
3842 else
3843 value = 0;
3844 r = ia64_elf_install_value (hit_addr, value, r_type);
3845 }
3846 break;
3847 }
3848
3849 case R_IA64_SECREL32MSB:
3850 case R_IA64_SECREL32LSB:
3851 case R_IA64_SECREL64MSB:
3852 case R_IA64_SECREL64LSB:
3853 /* Make output-section relative to section where the symbol
3854 is defined. PR 475 */
3855 if (sym_sec)
3856 value -= sym_sec->output_section->vma;
3857 r = ia64_elf_install_value (hit_addr, value, r_type);
3858 break;
3859
3860 case R_IA64_IPLTMSB:
3861 case R_IA64_IPLTLSB:
3862 /* Install a dynamic relocation for this reloc. */
0e1862bb 3863 if ((dynamic_symbol_p || bfd_link_pic (info))
202e2356
NC		 3864 && (input_section->flags & SEC_ALLOC) != 0)
3865 {
07d6d2b8
AM		 3866 /* VMS: FIXFD ?? */
3867 abort ();
202e2356
NC		 3868 }
3869
3870 if (r_type == R_IA64_IPLTMSB)
3871 r_type = R_IA64_DIR64MSB;
3872 else
3873 r_type = R_IA64_DIR64LSB;
3874 ia64_elf_install_value (hit_addr, value, r_type);
3875 r = ia64_elf_install_value (hit_addr + 8, gp_val, r_type);
3876 break;
3877
3878 case R_IA64_TPREL14:
3879 case R_IA64_TPREL22:
3880 case R_IA64_TPREL64I:
3881 r = bfd_reloc_notsupported;
3882 break;
3883
3884 case R_IA64_DTPREL14:
3885 case R_IA64_DTPREL22:
3886 case R_IA64_DTPREL64I:
3887 case R_IA64_DTPREL32LSB:
3888 case R_IA64_DTPREL32MSB:
3889 case R_IA64_DTPREL64LSB:
3890 case R_IA64_DTPREL64MSB:
3891 r = bfd_reloc_notsupported;
3892 break;
3893
3894 case R_IA64_LTOFF_TPREL22:
3895 case R_IA64_LTOFF_DTPMOD22:
3896 case R_IA64_LTOFF_DTPREL22:
3897 r = bfd_reloc_notsupported;
3898 break;
3899
3900 default:
3901 r = bfd_reloc_notsupported;
3902 break;
3903 }
3904
3905 switch (r)
3906 {
3907 case bfd_reloc_ok:
3908 break;
3909
3910 case bfd_reloc_undefined:
3911 /* This can happen for global table relative relocs if
3912 __gp is undefined. This is a panic situation so we
3913 don't try to continue. */
3914 (*info->callbacks->undefined_symbol)
3915 (info, "__gp", input_bfd, input_section, rel->r_offset, 1);
3916 return FALSE;
3917
3918 case bfd_reloc_notsupported:
3919 {
3920 const char *name;
3921
3922 if (h)
3923 name = h->root.root.string;
3924 else
3925 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3926 sym_sec);
1a72702b
AM		 3927 (*info->callbacks->warning) (info, _("unsupported reloc"),
3928 name, input_bfd,
3929 input_section, rel->r_offset);
202e2356
NC		 3930 ret_val = FALSE;
3931 }
3932 break;
3933
3934 case bfd_reloc_dangerous:
3935 case bfd_reloc_outofrange:
3936 case bfd_reloc_overflow:
3937 default:
3938 {
3939 const char *name;
3940
3941 if (h)
3942 name = h->root.root.string;
3943 else
3944 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
3945 sym_sec);
3946
3947 switch (r_type)
3948 {
3949 case R_IA64_TPREL14:
3950 case R_IA64_TPREL22:
3951 case R_IA64_TPREL64I:
3952 case R_IA64_DTPREL14:
3953 case R_IA64_DTPREL22:
3954 case R_IA64_DTPREL64I:
3955 case R_IA64_DTPREL32LSB:
3956 case R_IA64_DTPREL32MSB:
3957 case R_IA64_DTPREL64LSB:
3958 case R_IA64_DTPREL64MSB:
3959 case R_IA64_LTOFF_TPREL22:
3960 case R_IA64_LTOFF_DTPMOD22:
3961 case R_IA64_LTOFF_DTPREL22:
4eca0228 3962 _bfd_error_handler
695344c0 3963 /* xgettext:c-format */
871b3ab2 3964 (_("%pB: missing TLS section for relocation %s against `%s'"
2dcf00ce 3965 " at %#" PRIx64 " in section `%pA'."),
c08bb8dd 3966 input_bfd, howto->name, name,
2dcf00ce 3967 (uint64_t) rel->r_offset, input_section);
202e2356
NC		 3968 break;
3969
3970 case R_IA64_PCREL21B:
3971 case R_IA64_PCREL21BI:
3972 case R_IA64_PCREL21M:
3973 case R_IA64_PCREL21F:
3974 if (is_elf_hash_table (info->hash))
3975 {
3976 /* Relaxtion is always performed for ELF output.
3977 Overflow failures for those relocations mean
3978 that the section is too big to relax. */
4eca0228 3979 _bfd_error_handler
695344c0 3980 /* xgettext:c-format */
2dcf00ce
AM		 3981 (_("%pB: Can't relax br (%s) to `%s' "
3982 "at %#" PRIx64 " in section `%pA' "
3983 "with size %#" PRIx64 " (> 0x1000000)."),
3984 input_bfd, howto->name, name, (uint64_t) rel->r_offset,
3985 input_section, (uint64_t) input_section->size);
202e2356
NC		 3986 break;
3987 }
1a0670f3 3988 /* Fall through. */
202e2356 3989 default:
1a72702b
AM		 3990 (*info->callbacks->reloc_overflow) (info,
3991 &h->root,
3992 name,
3993 howto->name,
3994 (bfd_vma) 0,
3995 input_bfd,
3996 input_section,
3997 rel->r_offset);
202e2356
NC		 3998 break;
3999 }
4000
4001 ret_val = FALSE;
4002 }
4003 break;
4004 }
4005 }
4006
4007 return ret_val;
4008}
4009
4010static bfd_boolean
4011elf64_ia64_finish_dynamic_symbol (bfd *output_bfd,
4012 struct bfd_link_info *info,
4013 struct elf_link_hash_entry *h,
4014 Elf_Internal_Sym *sym)
4015{
4016 struct elf64_ia64_link_hash_table *ia64_info;
4017 struct elf64_ia64_dyn_sym_info *dyn_i;
4018
4019 ia64_info = elf64_ia64_hash_table (info);
4020 if (ia64_info == NULL)
4021 return FALSE;
4022
4023 dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE);
4024
4025 /* Fill in the PLT data, if required. */
4026 if (dyn_i && dyn_i->want_plt)
4027 {
4028 bfd_byte *loc;
4029 asection *plt_sec;
4030 bfd_vma plt_addr, pltoff_addr, gp_val;
4031
4032 gp_val = _bfd_get_gp_value (output_bfd);
4033
4034 plt_sec = ia64_info->root.splt;
4035 plt_addr = 0; /* Not used as overriden by FIXUPs. */
4036 pltoff_addr = set_pltoff_entry (output_bfd, info, dyn_i, plt_addr, TRUE);
4037
4038 /* Initialize the FULL PLT entry, if needed. */
4039 if (dyn_i->want_plt2)
4040 {
4041 loc = plt_sec->contents + dyn_i->plt2_offset;
4042
4043 memcpy (loc, plt_full_entry, PLT_FULL_ENTRY_SIZE);
4044 ia64_elf_install_value (loc, pltoff_addr - gp_val, R_IA64_IMM22);
4045
4046 /* Mark the symbol as undefined, rather than as defined in the
4047 plt section. Leave the value alone. */
4048 /* ??? We didn't redefine it in adjust_dynamic_symbol in the
4049 first place. But perhaps elflink.c did some for us. */
4050 if (!h->def_regular)
4051 sym->st_shndx = SHN_UNDEF;
4052 }
4053
4054 /* VMS: FIXFD. */
4055 elf64_ia64_install_fixup
07d6d2b8
AM		 4056 (output_bfd, ia64_info, h, R_IA64_VMS_FIXFD, ia64_info->pltoff_sec,
4057 pltoff_addr - (ia64_info->pltoff_sec->output_section->vma
4058 + ia64_info->pltoff_sec->output_offset), 0);
202e2356
NC		 4059 }
4060
4061 /* Mark some specially defined symbols as absolute. */
9637f6ef 4062 if (h == ia64_info->root.hdynamic
202e2356
NC		 4063 || h == ia64_info->root.hgot
4064 || h == ia64_info->root.hplt)
4065 sym->st_shndx = SHN_ABS;
4066
4067 return TRUE;
4068}
4069
4070static bfd_boolean
4071elf64_ia64_finish_dynamic_sections (bfd *abfd,
4072 struct bfd_link_info *info)
4073{
4074 struct elf64_ia64_link_hash_table *ia64_info;
4075 bfd *dynobj;
4076
4077 ia64_info = elf64_ia64_hash_table (info);
4078 if (ia64_info == NULL)
4079 return FALSE;
4080
4081 dynobj = ia64_info->root.dynobj;
4082
4083 if (elf_hash_table (info)->dynamic_sections_created)
4084 {
4085 Elf64_External_Dyn *dyncon, *dynconend;
4086 asection *sdyn;
4087 asection *unwind_sec;
4088 bfd_vma gp_val;
4089 unsigned int gp_seg;
4090 bfd_vma gp_off;
4091 Elf_Internal_Phdr *phdr;
4092 Elf_Internal_Phdr *base_phdr;
4093 unsigned int unwind_seg = 0;
4094 unsigned int code_seg = 0;
4095
3d4d4302 4096 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
202e2356
NC		 4097 BFD_ASSERT (sdyn != NULL);
4098 dyncon = (Elf64_External_Dyn *) sdyn->contents;
4099 dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
4100
4101 gp_val = _bfd_get_gp_value (abfd);
4102 phdr = _bfd_elf_find_segment_containing_section
07d6d2b8 4103 (info->output_bfd, ia64_info->pltoff_sec->output_section);
202e2356
NC		 4104 BFD_ASSERT (phdr != NULL);
4105 base_phdr = elf_tdata (info->output_bfd)->phdr;
4106 gp_seg = phdr - base_phdr;
4107 gp_off = gp_val - phdr->p_vaddr;
4108
4109 unwind_sec = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind);
4110 if (unwind_sec != NULL)
07d6d2b8
AM		 4111 {
4112 asection *code_sec;
202e2356 4113
07d6d2b8
AM		 4114 phdr = _bfd_elf_find_segment_containing_section (abfd, unwind_sec);
4115 BFD_ASSERT (phdr != NULL);
4116 unwind_seg = phdr - base_phdr;
202e2356 4117
07d6d2b8
AM		 4118 code_sec = bfd_get_section_by_name (abfd, "$CODE$");
4119 phdr = _bfd_elf_find_segment_containing_section (abfd, code_sec);
4120 BFD_ASSERT (phdr != NULL);
4121 code_seg = phdr - base_phdr;
4122 }
202e2356
NC		 4123
4124 for (; dyncon < dynconend; dyncon++)
4125 {
4126 Elf_Internal_Dyn dyn;
4127
4128 bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
4129
4130 switch (dyn.d_tag)
4131 {
07d6d2b8
AM		 4132 case DT_IA_64_VMS_FIXUP_RELA_OFF:
4133 dyn.d_un.d_val +=
4134 (ia64_info->fixups_sec->output_section->vma
4135 + ia64_info->fixups_sec->output_offset)
4136 - (sdyn->output_section->vma + sdyn->output_offset);
4137 break;
4138
4139 case DT_IA_64_VMS_PLTGOT_OFFSET:
4140 dyn.d_un.d_val = gp_off;
4141 break;
4142
4143 case DT_IA_64_VMS_PLTGOT_SEG:
4144 dyn.d_un.d_val = gp_seg;
4145 break;
4146
4147 case DT_IA_64_VMS_UNWINDSZ:
4148 if (unwind_sec == NULL)
4149 {
4150 dyn.d_tag = DT_NULL;
4151 dyn.d_un.d_val = 0xdead;
4152 }
4153 else
4154 dyn.d_un.d_val = unwind_sec->size;
4155 break;
4156
4157 case DT_IA_64_VMS_UNWIND_CODSEG:
4158 dyn.d_un.d_val = code_seg;
4159 break;
4160
4161 case DT_IA_64_VMS_UNWIND_INFOSEG:
4162 case DT_IA_64_VMS_UNWIND_SEG:
4163 dyn.d_un.d_val = unwind_seg;
4164 break;
4165
4166 case DT_IA_64_VMS_UNWIND_OFFSET:
4167 break;
4168
4169 default:
4170 /* No need to rewrite the entry. */
4171 continue;
202e2356
NC		 4172 }
4173
4174 bfd_elf64_swap_dyn_out (abfd, &dyn, dyncon);
4175 }
4176 }
4177
4178 /* Handle transfer addresses. */
4179 {
4180 asection *tfr_sec = ia64_info->transfer_sec;
4181 struct elf64_vms_transfer *tfr;
4182 struct elf_link_hash_entry *tfr3;
4183
4184 tfr = (struct elf64_vms_transfer *)tfr_sec->contents;
4185 bfd_putl32 (6 * 8, tfr->size);
4186 bfd_putl64 (tfr_sec->output_section->vma
07d6d2b8
AM		 4187 + tfr_sec->output_offset
4188 + 6 * 8, tfr->tfradr3);
202e2356
NC		 4189
4190 tfr3 = elf_link_hash_lookup (elf_hash_table (info), "ELF$TFRADR", FALSE,
07d6d2b8 4191 FALSE, FALSE);
202e2356
NC		 4192
4193 if (tfr3
07d6d2b8
AM		 4194 && (tfr3->root.type == bfd_link_hash_defined
4195 || tfr3->root.type == bfd_link_hash_defweak))
202e2356 4196 {
07d6d2b8
AM		 4197 asection *tfr3_sec = tfr3->root.u.def.section;
4198 bfd_vma tfr3_val;
202e2356 4199
07d6d2b8
AM		 4200 tfr3_val = (tfr3->root.u.def.value
4201 + tfr3_sec->output_section->vma
4202 + tfr3_sec->output_offset);
202e2356 4203
07d6d2b8
AM		 4204 bfd_putl64 (tfr3_val, tfr->tfr3_func);
4205 bfd_putl64 (_bfd_get_gp_value (info->output_bfd), tfr->tfr3_gp);
202e2356
NC		 4206 }
4207
4208 /* FIXME: set linker flags,
4209 handle lib$initialize. */
4210 }
4211
4212 return TRUE;
4213}
4214
4215/* ELF file flag handling: */
4216
4217/* Function to keep IA-64 specific file flags. */
4218static bfd_boolean
4219elf64_ia64_set_private_flags (bfd *abfd, flagword flags)
4220{
4221 BFD_ASSERT (!elf_flags_init (abfd)
4222 || elf_elfheader (abfd)->e_flags == flags);
4223
4224 elf_elfheader (abfd)->e_flags = flags;
4225 elf_flags_init (abfd) = TRUE;
4226 return TRUE;
4227}
4228
4229/* Merge backend specific data from an object file to the output
4230 object file when linking. */
4231static bfd_boolean
50e03d47 4232elf64_ia64_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
202e2356 4233{
50e03d47 4234 bfd *obfd = info->output_bfd;
202e2356
NC		 4235 flagword out_flags;
4236 flagword in_flags;
4237 bfd_boolean ok = TRUE;
4238
4239 /* Don't even pretend to support mixed-format linking. */
4240 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4241 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4242 return FALSE;
4243
4244 in_flags = elf_elfheader (ibfd)->e_flags;
4245 out_flags = elf_elfheader (obfd)->e_flags;
4246
4247 if (! elf_flags_init (obfd))
4248 {
4249 elf_flags_init (obfd) = TRUE;
4250 elf_elfheader (obfd)->e_flags = in_flags;
4251
4252 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
4253 && bfd_get_arch_info (obfd)->the_default)
4254 {
4255 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
4256 bfd_get_mach (ibfd));
4257 }
4258
4259 return TRUE;
4260 }
4261
4262 /* Check flag compatibility. */
4263 if (in_flags == out_flags)
4264 return TRUE;
4265
4266 /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set. */
4267 if (!(in_flags & EF_IA_64_REDUCEDFP) && (out_flags & EF_IA_64_REDUCEDFP))
4268 elf_elfheader (obfd)->e_flags &= ~EF_IA_64_REDUCEDFP;
4269
4270 if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL))
4271 {
4eca0228 4272 _bfd_error_handler
871b3ab2 4273 (_("%pB: linking trap-on-NULL-dereference with non-trapping files"),
202e2356
NC		 4274 ibfd);
4275
4276 bfd_set_error (bfd_error_bad_value);
4277 ok = FALSE;
4278 }
4279 if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE))
4280 {
4eca0228 4281 _bfd_error_handler
871b3ab2 4282 (_("%pB: linking big-endian files with little-endian files"),
202e2356
NC		 4283 ibfd);
4284
4285 bfd_set_error (bfd_error_bad_value);
4286 ok = FALSE;
4287 }
4288 if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64))
4289 {
4eca0228 4290 _bfd_error_handler
871b3ab2 4291 (_("%pB: linking 64-bit files with 32-bit files"),
202e2356
NC		 4292 ibfd);
4293
4294 bfd_set_error (bfd_error_bad_value);
4295 ok = FALSE;
4296 }
4297 if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP))
4298 {
4eca0228 4299 _bfd_error_handler
871b3ab2 4300 (_("%pB: linking constant-gp files with non-constant-gp files"),
202e2356
NC		 4301 ibfd);
4302
4303 bfd_set_error (bfd_error_bad_value);
4304 ok = FALSE;
4305 }
4306 if ((in_flags & EF_IA_64_NOFUNCDESC_CONS_GP)
4307 != (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
4308 {
4eca0228 4309 _bfd_error_handler
871b3ab2 4310 (_("%pB: linking auto-pic files with non-auto-pic files"),
202e2356
NC		 4311 ibfd);
4312
4313 bfd_set_error (bfd_error_bad_value);
4314 ok = FALSE;
4315 }
4316
4317 return ok;
4318}
4319
4320static bfd_boolean
4321elf64_ia64_print_private_bfd_data (bfd *abfd, void * ptr)
4322{
4323 FILE *file = (FILE *) ptr;
4324 flagword flags = elf_elfheader (abfd)->e_flags;
4325
4326 BFD_ASSERT (abfd != NULL && ptr != NULL);
4327
4328 fprintf (file, "private flags = %s%s%s%s%s%s%s%s\n",
4329 (flags & EF_IA_64_TRAPNIL) ? "TRAPNIL, " : "",
4330 (flags & EF_IA_64_EXT) ? "EXT, " : "",
4331 (flags & EF_IA_64_BE) ? "BE, " : "LE, ",
4332 (flags & EF_IA_64_REDUCEDFP) ? "REDUCEDFP, " : "",
4333 (flags & EF_IA_64_CONS_GP) ? "CONS_GP, " : "",
4334 (flags & EF_IA_64_NOFUNCDESC_CONS_GP) ? "NOFUNCDESC_CONS_GP, " : "",
4335 (flags & EF_IA_64_ABSOLUTE) ? "ABSOLUTE, " : "",
4336 (flags & EF_IA_64_ABI64) ? "ABI64" : "ABI32");
4337
4338 _bfd_elf_print_private_bfd_data (abfd, ptr);
4339 return TRUE;
4340}
4341
4342static enum elf_reloc_type_class
7e612e98
AM		 4343elf64_ia64_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
4344 const asection *rel_sec ATTRIBUTE_UNUSED,
4345 const Elf_Internal_Rela *rela)
202e2356
NC		 4346{
4347 switch ((int) ELF64_R_TYPE (rela->r_info))
4348 {
4349 case R_IA64_REL32MSB:
4350 case R_IA64_REL32LSB:
4351 case R_IA64_REL64MSB:
4352 case R_IA64_REL64LSB:
4353 return reloc_class_relative;
4354 case R_IA64_IPLTMSB:
4355 case R_IA64_IPLTLSB:
4356 return reloc_class_plt;
4357 case R_IA64_COPY:
4358 return reloc_class_copy;
4359 default:
4360 return reloc_class_normal;
4361 }
4362}
4363
4364static const struct bfd_elf_special_section elf64_ia64_special_sections[] =
4365{
07d6d2b8 4366 { STRING_COMMA_LEN (".sbss"), -1, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
202e2356 4367 { STRING_COMMA_LEN (".sdata"), -1, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
07d6d2b8 4368 { NULL, 0, 0, 0, 0 }
202e2356
NC		 4369};
4370
4371static bfd_boolean
4372elf64_ia64_object_p (bfd *abfd)
4373{
4374 asection *sec;
4375 asection *group, *unwi, *unw;
4376 flagword flags;
4377 const char *name;
4378 char *unwi_name, *unw_name;
4379 bfd_size_type amt;
4380
4381 if (abfd->flags & DYNAMIC)
4382 return TRUE;
4383
4384 /* Flags for fake group section. */
4385 flags = (SEC_LINKER_CREATED | SEC_GROUP | SEC_LINK_ONCE
4386 | SEC_EXCLUDE);
4387
4388 /* We add a fake section group for each .gnu.linkonce.t.* section,
4389 which isn't in a section group, and its unwind sections. */
4390 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4391 {
4392 if (elf_sec_group (sec) == NULL
4393 && ((sec->flags & (SEC_LINK_ONCE | SEC_CODE | SEC_GROUP))
4394 == (SEC_LINK_ONCE | SEC_CODE))
4395 && CONST_STRNEQ (sec->name, ".gnu.linkonce.t."))
4396 {
4397 name = sec->name + 16;
4398
4399 amt = strlen (name) + sizeof (".gnu.linkonce.ia64unwi.");
4400 unwi_name = bfd_alloc (abfd, amt);
4401 if (!unwi_name)
4402 return FALSE;
4403
4404 strcpy (stpcpy (unwi_name, ".gnu.linkonce.ia64unwi."), name);
4405 unwi = bfd_get_section_by_name (abfd, unwi_name);
4406
4407 amt = strlen (name) + sizeof (".gnu.linkonce.ia64unw.");
4408 unw_name = bfd_alloc (abfd, amt);
4409 if (!unw_name)
4410 return FALSE;
4411
4412 strcpy (stpcpy (unw_name, ".gnu.linkonce.ia64unw."), name);
4413 unw = bfd_get_section_by_name (abfd, unw_name);
4414
4415 /* We need to create a fake group section for it and its
4416 unwind sections. */
4417 group = bfd_make_section_anyway_with_flags (abfd, name,
4418 flags);
4419 if (group == NULL)
4420 return FALSE;
4421
4422 /* Move the fake group section to the beginning. */
4423 bfd_section_list_remove (abfd, group);
4424 bfd_section_list_prepend (abfd, group);
4425
4426 elf_next_in_group (group) = sec;
4427
4428 elf_group_name (sec) = name;
4429 elf_next_in_group (sec) = sec;
4430 elf_sec_group (sec) = group;
4431
4432 if (unwi)
4433 {
4434 elf_group_name (unwi) = name;
4435 elf_next_in_group (unwi) = sec;
4436 elf_next_in_group (sec) = unwi;
4437 elf_sec_group (unwi) = group;
4438 }
4439
4440 if (unw)
4441 {
4442 elf_group_name (unw) = name;
4443 if (unwi)
4444 {
4445 elf_next_in_group (unw) = elf_next_in_group (unwi);
4446 elf_next_in_group (unwi) = unw;
4447 }
4448 else
4449 {
4450 elf_next_in_group (unw) = sec;
4451 elf_next_in_group (sec) = unw;
4452 }
4453 elf_sec_group (unw) = group;
4454 }
4455
4456 /* Fake SHT_GROUP section header. */
4457 elf_section_data (group)->this_hdr.bfd_section = group;
4458 elf_section_data (group)->this_hdr.sh_type = SHT_GROUP;
4459 }
4460 }
4461 return TRUE;
4462}
4463
4464/* Handle an IA-64 specific section when reading an object file. This
4465 is called when bfd_section_from_shdr finds a section with an unknown
4466 type. */
4467
4468static bfd_boolean
4469elf64_vms_section_from_shdr (bfd *abfd,
4470 Elf_Internal_Shdr *hdr,
4471 const char *name,
4472 int shindex)
4473{
4474 flagword secflags = 0;
4475
4476 switch (hdr->sh_type)
4477 {
4478 case SHT_IA_64_VMS_TRACE:
4479 case SHT_IA_64_VMS_DEBUG:
4480 case SHT_IA_64_VMS_DEBUG_STR:
4481 secflags = SEC_DEBUGGING;
4482 break;
4483
4484 case SHT_IA_64_UNWIND:
4485 case SHT_IA_64_HP_OPT_ANOT:
4486 break;
4487
4488 case SHT_IA_64_EXT:
4489 if (strcmp (name, ELF_STRING_ia64_archext) != 0)
4490 return FALSE;
4491 break;
4492
4493 default:
4494 return FALSE;
4495 }
4496
4497 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
4498 return FALSE;
4499
4500 if (secflags != 0)
4501 {
4502 asection *newsect = hdr->bfd_section;
4503
4504 if (! bfd_set_section_flags
07d6d2b8 4505 (abfd, newsect, bfd_get_section_flags (abfd, newsect) | secflags))
202e2356
NC		 4506 return FALSE;
4507 }
4508
4509 return TRUE;
4510}
4511
4512static bfd_boolean
4513elf64_vms_object_p (bfd *abfd)
4514{
4515 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
4516 Elf_Internal_Phdr *i_phdr = elf_tdata (abfd)->phdr;
4517 unsigned int i;
4518 unsigned int num_text = 0;
4519 unsigned int num_data = 0;
4520 unsigned int num_rodata = 0;
4521 char name[16];
4522
4523 if (!elf64_ia64_object_p (abfd))
4524 return FALSE;
4525
4526 /* Many VMS compilers do not generate sections for the corresponding
4527 segment. This is boring as binutils tools won't be able to disassemble
4528 the code. So we simply create all the missing sections. */
4529 for (i = 0; i < i_ehdrp->e_phnum; i++, i_phdr++)
4530 {
4531 /* Is there a section for this segment? */
4532 bfd_vma base_vma = i_phdr->p_vaddr;
4533 bfd_vma limit_vma = base_vma + i_phdr->p_filesz;
4534
4535 if (i_phdr->p_type != PT_LOAD)
4536 continue;
4537
4538 /* We need to cover from base_vms to limit_vma. */
4539 again:
4540 while (base_vma < limit_vma)
4541 {
4542 bfd_vma next_vma = limit_vma;
4543 asection *nsec;
4544 asection *sec;
4545 flagword flags;
4546 char *nname = NULL;
4547
4548 /* Find a section covering [base_vma;limit_vma) */
4549 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4550 {
4551 /* Skip uninteresting sections (either not in memory or
4552 below base_vma. */
4553 if ((sec->flags & (SEC_ALLOC | SEC_LOAD)) == 0
4554 || sec->vma + sec->size <= base_vma)
4555 continue;
4556 if (sec->vma <= base_vma)
4557 {
4558 /* This section covers (maybe partially) the beginning
4559 of the range. */
4560 base_vma = sec->vma + sec->size;
4561 goto again;
4562 }
4563 if (sec->vma < next_vma)
4564 {
4565 /* This section partially covers the end of the range.
4566 Used to compute the size of the hole. */
4567 next_vma = sec->vma;
4568 }
4569 }
4570
4571 /* No section covering [base_vma; next_vma). Create a fake one. */
4572 flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS;
4573 if (i_phdr->p_flags & PF_X)
4574 {
4575 flags |= SEC_CODE;
4576 if (num_text++ == 0)
4577 nname = ".text";
4578 else
4579 sprintf (name, ".text$%u", num_text);
4580 }
4581 else if ((i_phdr->p_flags & (PF_R | PF_W)) == PF_R)
4582 {
4583 flags |= SEC_READONLY;
4584 sprintf (name, ".rodata$%u", num_rodata++);
4585 }
4586 else
4587 {
4588 flags |= SEC_DATA;
4589 sprintf (name, ".data$%u", num_data++);
4590 }
4591
4592 /* Allocate name. */
4593 if (nname == NULL)
4594 {
4595 size_t name_len = strlen (name) + 1;
4596 nname = bfd_alloc (abfd, name_len);
4597 if (nname == NULL)
4598 return FALSE;
4599 memcpy (nname, name, name_len);
4600 }
4601
4602 /* Create and fill new section. */
4603 nsec = bfd_make_section_anyway_with_flags (abfd, nname, flags);
4604 if (nsec == NULL)
4605 return FALSE;
4606 nsec->vma = base_vma;
4607 nsec->size = next_vma - base_vma;
4608 nsec->filepos = i_phdr->p_offset + (base_vma - i_phdr->p_vaddr);
4609
4610 base_vma = next_vma;
4611 }
4612 }
4613 return TRUE;
4614}
4615
4616static void
4617elf64_vms_post_process_headers (bfd *abfd,
4618 struct bfd_link_info *info ATTRIBUTE_UNUSED)
4619{
4620 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
4621
4622 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_OPENVMS;
4623 i_ehdrp->e_ident[EI_ABIVERSION] = 2;
4624}
4625
4626static bfd_boolean
4627elf64_vms_section_processing (bfd *abfd ATTRIBUTE_UNUSED,
4628 Elf_Internal_Shdr *hdr)
4629{
4630 if (hdr->bfd_section != NULL)
4631 {
4632 const char *name = bfd_get_section_name (abfd, hdr->bfd_section);
4633
4634 if (strcmp (name, ".text") == 0)
4635 hdr->sh_flags |= SHF_IA_64_VMS_SHARED;
4636 else if ((strcmp (name, ".debug") == 0)
4637 || (strcmp (name, ".debug_abbrev") == 0)
4638 || (strcmp (name, ".debug_aranges") == 0)
4639 || (strcmp (name, ".debug_frame") == 0)
4640 || (strcmp (name, ".debug_info") == 0)
4641 || (strcmp (name, ".debug_loc") == 0)
4642 || (strcmp (name, ".debug_macinfo") == 0)
4643 || (strcmp (name, ".debug_pubnames") == 0)
4644 || (strcmp (name, ".debug_pubtypes") == 0))
4645 hdr->sh_type = SHT_IA_64_VMS_DEBUG;
4646 else if ((strcmp (name, ".debug_line") == 0)
4647 || (strcmp (name, ".debug_ranges") == 0)
4648 || (strcmp (name, ".trace_info") == 0)
4649 || (strcmp (name, ".trace_abbrev") == 0)
4650 || (strcmp (name, ".trace_aranges") == 0))
4651 hdr->sh_type = SHT_IA_64_VMS_TRACE;
4652 else if (strcmp (name, ".debug_str") == 0)
4653 hdr->sh_type = SHT_IA_64_VMS_DEBUG_STR;
4654 }
4655
4656 return TRUE;
4657}
4658
4659/* The final processing done just before writing out a VMS IA-64 ELF
4660 object file. */
4661
cc364be6
AM		 4662static bfd_boolean
4663elf64_vms_final_write_processing (bfd *abfd)
202e2356
NC		 4664{
4665 Elf_Internal_Shdr *hdr;
4666 asection *s;
4667 int unwind_info_sect_idx = 0;
4668
4669 for (s = abfd->sections; s; s = s->next)
4670 {
4671 hdr = &elf_section_data (s)->this_hdr;
4672
4673 if (strcmp (bfd_get_section_name (abfd, hdr->bfd_section),
4674 ".IA_64.unwind_info") == 0)
4675 unwind_info_sect_idx = elf_section_data (s)->this_idx;
4676
4677 switch (hdr->sh_type)
4678 {
4679 case SHT_IA_64_UNWIND:
4680 /* VMS requires sh_info to point to the unwind info section. */
07d6d2b8 4681 hdr->sh_info = unwind_info_sect_idx;
202e2356
NC		 4682 break;
4683 }
4684 }
4685
4686 if (! elf_flags_init (abfd))
4687 {
4688 unsigned long flags = 0;
4689
4690 if (abfd->xvec->byteorder == BFD_ENDIAN_BIG)
4691 flags |= EF_IA_64_BE;
4692 if (bfd_get_mach (abfd) == bfd_mach_ia64_elf64)
4693 flags |= EF_IA_64_ABI64;
4694
4695 elf_elfheader (abfd)->e_flags = flags;
4696 elf_flags_init (abfd) = TRUE;
4697 }
cc364be6 4698 return _bfd_elf_final_write_processing (abfd);
202e2356
NC		 4699}
4700
4701static bfd_boolean
4702elf64_vms_write_shdrs_and_ehdr (bfd *abfd)
4703{
4704 unsigned char needed_count[8];
4705
4706 if (!bfd_elf64_write_shdrs_and_ehdr (abfd))
4707 return FALSE;
4708
4709 bfd_putl64 (elf_ia64_vms_tdata (abfd)->needed_count, needed_count);
4710
4711 if (bfd_seek (abfd, sizeof (Elf64_External_Ehdr), SEEK_SET) != 0
4712 || bfd_bwrite (needed_count, 8, abfd) != 8)
4713 return FALSE;
4714
4715 return TRUE;
4716}
4717
4718static bfd_boolean
4719elf64_vms_close_and_cleanup (bfd *abfd)
4720{
4721 if (bfd_get_format (abfd) == bfd_object)
4722 {
4723 long isize;
4724
4725 /* Pad to 8 byte boundary for IPF/VMS. */
4726 isize = bfd_get_size (abfd);
4727 if ((isize & 7) != 0)
4728 {
4729 int ishort = 8 - (isize & 7);
07d6d2b8 4730 bfd_uint64_t pad = 0;
202e2356
NC		 4731
4732 bfd_seek (abfd, isize, SEEK_SET);
4733 bfd_bwrite (&pad, ishort, abfd);
4734 }
4735 }
4736
4737 return _bfd_elf_close_and_cleanup (abfd);
4738}
4739
4740/* Add symbols from an ELF object file to the linker hash table. */
4741
4742static bfd_boolean
4743elf64_vms_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
4744{
4745 Elf_Internal_Shdr *hdr;
4746 bfd_size_type symcount;
4747 bfd_size_type extsymcount;
4748 bfd_size_type extsymoff;
4749 struct elf_link_hash_entry **sym_hash;
4750 bfd_boolean dynamic;
4751 Elf_Internal_Sym *isymbuf = NULL;
4752 Elf_Internal_Sym *isym;
4753 Elf_Internal_Sym *isymend;
4754 const struct elf_backend_data *bed;
4755 struct elf_link_hash_table *htab;
4756 bfd_size_type amt;
4757
4758 htab = elf_hash_table (info);
4759 bed = get_elf_backend_data (abfd);
4760
4761 if ((abfd->flags & DYNAMIC) == 0)
4762 dynamic = FALSE;
4763 else
4764 {
4765 dynamic = TRUE;
4766
4767 /* You can't use -r against a dynamic object. Also, there's no
4768 hope of using a dynamic object which does not exactly match
4769 the format of the output file. */
0e1862bb 4770 if (bfd_link_relocatable (info)
202e2356
NC		 4771 || !is_elf_hash_table (htab)
4772 || info->output_bfd->xvec != abfd->xvec)
4773 {
0e1862bb 4774 if (bfd_link_relocatable (info))
202e2356
NC		 4775 bfd_set_error (bfd_error_invalid_operation);
4776 else
4777 bfd_set_error (bfd_error_wrong_format);
4778 goto error_return;
4779 }
4780 }
4781
4782 if (! dynamic)
4783 {
4784 /* If we are creating a shared library, create all the dynamic
4785 sections immediately. We need to attach them to something,
4786 so we attach them to this BFD, provided it is the right
4787 format. FIXME: If there are no input BFD's of the same
4788 format as the output, we can't make a shared library. */
0e1862bb 4789 if (bfd_link_pic (info)
202e2356
NC		 4790 && is_elf_hash_table (htab)
4791 && info->output_bfd->xvec == abfd->xvec
4792 && !htab->dynamic_sections_created)
4793 {
4794 if (! elf64_ia64_create_dynamic_sections (abfd, info))
4795 goto error_return;
4796 }
4797 }
4798 else if (!is_elf_hash_table (htab))
4799 goto error_return;
4800 else
4801 {
4802 asection *s;
4803 bfd_byte *dynbuf;
4804 bfd_byte *extdyn;
4805
4806 /* ld --just-symbols and dynamic objects don't mix very well.
4807 ld shouldn't allow it. */
4808 if ((s = abfd->sections) != NULL
dbaa2011 4809 && s->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
202e2356
NC		 4810 abort ();
4811
4812 /* Be sure there are dynamic sections. */
4813 if (! elf64_ia64_create_dynamic_sections (htab->dynobj, info))
07d6d2b8 4814 goto error_return;
202e2356
NC		 4815
4816 s = bfd_get_section_by_name (abfd, ".dynamic");
4817 if (s == NULL)
07d6d2b8
AM		 4818 {
4819 /* VMS libraries do not have dynamic sections. Create one from
4820 the segment. */
4821 Elf_Internal_Phdr *phdr;
4822 unsigned int i, phnum;
4823
4824 phdr = elf_tdata (abfd)->phdr;
4825 if (phdr == NULL)
4826 goto error_return;
4827 phnum = elf_elfheader (abfd)->e_phnum;
4828 for (i = 0; i < phnum; phdr++)
4829 if (phdr->p_type == PT_DYNAMIC)
4830 {
4831 s = bfd_make_section (abfd, ".dynamic");
4832 if (s == NULL)
4833 goto error_return;
4834 s->vma = phdr->p_vaddr;
4835 s->lma = phdr->p_paddr;
4836 s->size = phdr->p_filesz;
4837 s->filepos = phdr->p_offset;
4838 s->flags |= SEC_HAS_CONTENTS;
4839 s->alignment_power = bfd_log2 (phdr->p_align);
4840 break;
4841 }
4842 if (s == NULL)
4843 goto error_return;
4844 }
202e2356
NC		 4845
4846 /* Extract IDENT. */
4847 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
07d6d2b8 4848 {
202e2356 4849error_free_dyn:
07d6d2b8
AM		 4850 free (dynbuf);
4851 goto error_return;
4852 }
202e2356
NC		 4853
4854 for (extdyn = dynbuf;
07d6d2b8
AM		 4855 extdyn < dynbuf + s->size;
4856 extdyn += bed->s->sizeof_dyn)
4857 {
4858 Elf_Internal_Dyn dyn;
4859
4860 bed->s->swap_dyn_in (abfd, extdyn, &dyn);
4861 if (dyn.d_tag == DT_IA_64_VMS_IDENT)
4862 {
4863 bfd_uint64_t tagv = dyn.d_un.d_val;
4864 elf_ia64_vms_ident (abfd) = tagv;
4865 break;
4866 }
4867 }
202e2356 4868 if (extdyn >= dynbuf + s->size)
07d6d2b8
AM		 4869 {
4870 /* Ident not found. */
4871 goto error_free_dyn;
4872 }
202e2356
NC		 4873 free (dynbuf);
4874
4875 /* We do not want to include any of the sections in a dynamic
4876 object in the output file. We hack by simply clobbering the
4877 list of sections in the BFD. This could be handled more
4878 cleanly by, say, a new section flag; the existing
4879 SEC_NEVER_LOAD flag is not the one we want, because that one
4880 still implies that the section takes up space in the output
4881 file. */
4882 bfd_section_list_clear (abfd);
4883
4884 /* FIXME: should we detect if this library is already included ?
07d6d2b8 4885 This should be harmless and shouldn't happen in practice. */
202e2356
NC		 4886 }
4887
4888 hdr = &elf_tdata (abfd)->symtab_hdr;
4889 symcount = hdr->sh_size / bed->s->sizeof_sym;
4890
4891 /* The sh_info field of the symtab header tells us where the
4892 external symbols start. We don't care about the local symbols at
4893 this point. */
4894 extsymcount = symcount - hdr->sh_info;
4895 extsymoff = hdr->sh_info;
4896
4897 sym_hash = NULL;
4898 if (extsymcount != 0)
4899 {
4900 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, extsymcount, extsymoff,
4901 NULL, NULL, NULL);
4902 if (isymbuf == NULL)
4903 goto error_return;
4904
4905 /* We store a pointer to the hash table entry for each external
4906 symbol. */
4907 amt = extsymcount * sizeof (struct elf_link_hash_entry *);
4908 sym_hash = (struct elf_link_hash_entry **) bfd_alloc (abfd, amt);
4909 if (sym_hash == NULL)
4910 goto error_free_sym;
4911 elf_sym_hashes (abfd) = sym_hash;
4912 }
4913
4914 for (isym = isymbuf, isymend = isymbuf + extsymcount;
4915 isym < isymend;
4916 isym++, sym_hash++)
4917 {
4918 int bind;
4919 bfd_vma value;
4920 asection *sec, *new_sec;
4921 flagword flags;
4922 const char *name;
4923 struct elf_link_hash_entry *h;
4924 bfd_boolean definition;
4925 bfd_boolean size_change_ok;
4926 bfd_boolean type_change_ok;
4927 bfd_boolean common;
4928 unsigned int old_alignment;
4929 bfd *old_bfd;
4930
4931 flags = BSF_NO_FLAGS;
4932 sec = NULL;
4933 value = isym->st_value;
4934 *sym_hash = NULL;
4935 common = bed->common_definition (isym);
4936
4937 bind = ELF_ST_BIND (isym->st_info);
4938 switch (bind)
4939 {
4940 case STB_LOCAL:
4941 /* This should be impossible, since ELF requires that all
4942 global symbols follow all local symbols, and that sh_info
4943 point to the first global symbol. Unfortunately, Irix 5
4944 screws this up. */
4945 continue;
4946
4947 case STB_GLOBAL:
4948 if (isym->st_shndx != SHN_UNDEF && !common)
4949 flags = BSF_GLOBAL;
4950 break;
4951
4952 case STB_WEAK:
4953 flags = BSF_WEAK;
4954 break;
4955
4956 case STB_GNU_UNIQUE:
4957 flags = BSF_GNU_UNIQUE;
4958 break;
4959
4960 default:
4961 /* Leave it up to the processor backend. */
4962 break;
4963 }
4964
4965 if (isym->st_shndx == SHN_UNDEF)
4966 sec = bfd_und_section_ptr;
4967 else if (isym->st_shndx == SHN_ABS)
4968 sec = bfd_abs_section_ptr;
4969 else if (isym->st_shndx == SHN_COMMON)
4970 {
4971 sec = bfd_com_section_ptr;
4972 /* What ELF calls the size we call the value. What ELF
4973 calls the value we call the alignment. */
4974 value = isym->st_size;
4975 }
4976 else
4977 {
4978 sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
4979 if (sec == NULL)
4980 sec = bfd_abs_section_ptr;
4981 else if (sec->kept_section)
4982 {
4983 /* Symbols from discarded section are undefined. We keep
4984 its visibility. */
4985 sec = bfd_und_section_ptr;
4986 isym->st_shndx = SHN_UNDEF;
4987 }
4988 else if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
4989 value -= sec->vma;
4990 }
4991
4992 name = bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
4993 isym->st_name);
4994 if (name == NULL)
4995 goto error_free_vers;
4996
4997 if (bed->elf_add_symbol_hook)
4998 {
4999 if (! (*bed->elf_add_symbol_hook) (abfd, info, isym, &name, &flags,
5000 &sec, &value))
5001 goto error_free_vers;
5002
5003 /* The hook function sets the name to NULL if this symbol
5004 should be skipped for some reason. */
5005 if (name == NULL)
5006 continue;
5007 }
5008
5009 /* Sanity check that all possibilities were handled. */
5010 if (sec == NULL)
5011 {
5012 bfd_set_error (bfd_error_bad_value);
5013 goto error_free_vers;
5014 }
5015
5016 if (bfd_is_und_section (sec)
5017 || bfd_is_com_section (sec))
5018 definition = FALSE;
5019 else
5020 definition = TRUE;
5021
5022 size_change_ok = FALSE;
5023 type_change_ok = bed->type_change_ok;
5024 old_alignment = 0;
5025 old_bfd = NULL;
5026 new_sec = sec;
5027
5028 if (! bfd_is_und_section (sec))
07d6d2b8 5029 h = elf_link_hash_lookup (htab, name, TRUE, FALSE, FALSE);
202e2356 5030 else
07d6d2b8
AM		 5031 h = ((struct elf_link_hash_entry *) bfd_wrapped_link_hash_lookup
5032 (abfd, info, name, TRUE, FALSE, FALSE));
202e2356 5033 if (h == NULL)
07d6d2b8 5034 goto error_free_sym;
202e2356
NC		 5035
5036 *sym_hash = h;
5037
5038 if (is_elf_hash_table (htab))
5039 {
5040 while (h->root.type == bfd_link_hash_indirect
5041 || h->root.type == bfd_link_hash_warning)
5042 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5043
5044 /* Remember the old alignment if this is a common symbol, so
5045 that we don't reduce the alignment later on. We can't
5046 check later, because _bfd_generic_link_add_one_symbol
5047 will set a default for the alignment which we want to
5048 override. We also remember the old bfd where the existing
5049 definition comes from. */
5050 switch (h->root.type)
5051 {
5052 default:
5053 break;
5054
5055 case bfd_link_hash_defined:
07d6d2b8
AM		 5056 if (abfd->selective_search)
5057 continue;
5058 /* Fall-through. */
202e2356
NC		 5059 case bfd_link_hash_defweak:
5060 old_bfd = h->root.u.def.section->owner;
5061 break;
5062
5063 case bfd_link_hash_common:
5064 old_bfd = h->root.u.c.p->section->owner;
5065 old_alignment = h->root.u.c.p->alignment_power;
5066 break;
5067 }
5068 }
5069
5070 if (! (_bfd_generic_link_add_one_symbol
5071 (info, abfd, name, flags, sec, value, NULL, FALSE, bed->collect,
5072 (struct bfd_link_hash_entry **) sym_hash)))
5073 goto error_free_vers;
5074
5075 h = *sym_hash;
5076 while (h->root.type == bfd_link_hash_indirect
5077 || h->root.type == bfd_link_hash_warning)
5078 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5079
5080 *sym_hash = h;
35399224
L		 5081 if (definition)
5082 h->unique_global = (flags & BSF_GNU_UNIQUE) != 0;
202e2356
NC		 5083
5084 /* Set the alignment of a common symbol. */
5085 if ((common || bfd_is_com_section (sec))
5086 && h->root.type == bfd_link_hash_common)
5087 {
5088 unsigned int align;
5089
5090 if (common)
5091 align = bfd_log2 (isym->st_value);
5092 else
5093 {
5094 /* The new symbol is a common symbol in a shared object.
5095 We need to get the alignment from the section. */
5096 align = new_sec->alignment_power;
5097 }
5098 if (align > old_alignment
5099 /* Permit an alignment power of zero if an alignment of one
5100 is specified and no other alignments have been specified. */
5101 || (isym->st_value == 1 && old_alignment == 0))
5102 h->root.u.c.p->alignment_power = align;
5103 else
5104 h->root.u.c.p->alignment_power = old_alignment;
5105 }
5106
5107 if (is_elf_hash_table (htab))
5108 {
5109 /* Check the alignment when a common symbol is involved. This
5110 can change when a common symbol is overridden by a normal
5111 definition or a common symbol is ignored due to the old
5112 normal definition. We need to make sure the maximum
5113 alignment is maintained. */
5114 if ((old_alignment || common)
5115 && h->root.type != bfd_link_hash_common)
5116 {
5117 unsigned int common_align;
5118 unsigned int normal_align;
5119 unsigned int symbol_align;
5120 bfd *normal_bfd;
5121 bfd *common_bfd;
5122
5123 symbol_align = ffs (h->root.u.def.value) - 1;
5124 if (h->root.u.def.section->owner != NULL
5125 && (h->root.u.def.section->owner->flags & DYNAMIC) == 0)
5126 {
5127 normal_align = h->root.u.def.section->alignment_power;
5128 if (normal_align > symbol_align)
5129 normal_align = symbol_align;
5130 }
5131 else
5132 normal_align = symbol_align;
5133
5134 if (old_alignment)
5135 {
5136 common_align = old_alignment;
5137 common_bfd = old_bfd;
5138 normal_bfd = abfd;
5139 }
5140 else
5141 {
5142 common_align = bfd_log2 (isym->st_value);
5143 common_bfd = abfd;
5144 normal_bfd = old_bfd;
5145 }
5146
5147 if (normal_align < common_align)
5148 {
5149 /* PR binutils/2735 */
5150 if (normal_bfd == NULL)
4eca0228 5151 _bfd_error_handler
695344c0 5152 /* xgettext:c-format */
38f14ab8 5153 (_("warning: alignment %u of common symbol `%s' in %pB"
871b3ab2 5154 " is greater than the alignment (%u) of its section %pA"),
c08bb8dd
AM		 5155 1 << common_align, name, common_bfd,
5156 1 << normal_align, h->root.u.def.section);
202e2356 5157 else
4eca0228 5158 _bfd_error_handler
695344c0 5159 /* xgettext:c-format */
38f14ab8 5160 (_("warning: alignment %u of symbol `%s' in %pB"
871b3ab2 5161 " is smaller than %u in %pB"),
c08bb8dd
AM		 5162 1 << normal_align, name, normal_bfd,
5163 1 << common_align, common_bfd);
202e2356
NC		 5164 }
5165 }
5166
5167 /* Remember the symbol size if it isn't undefined. */
5168 if ((isym->st_size != 0 && isym->st_shndx != SHN_UNDEF)
5169 && (definition || h->size == 0))
5170 {
5171 if (h->size != 0
5172 && h->size != isym->st_size
5173 && ! size_change_ok)
4eca0228 5174 _bfd_error_handler
695344c0 5175 /* xgettext:c-format */
38f14ab8 5176 (_("warning: size of symbol `%s' changed"
2dcf00ce
AM		 5177 " from %" PRIu64 " in %pB to %" PRIu64 " in %pB"),
5178 name, (uint64_t) h->size, old_bfd,
5179 (uint64_t) isym->st_size, abfd);
202e2356
NC		 5180
5181 h->size = isym->st_size;
5182 }
5183
5184 /* If this is a common symbol, then we always want H->SIZE
5185 to be the size of the common symbol. The code just above
5186 won't fix the size if a common symbol becomes larger. We
5187 don't warn about a size change here, because that is
5188 covered by --warn-common. Allow changed between different
5189 function types. */
5190 if (h->root.type == bfd_link_hash_common)
5191 h->size = h->root.u.c.size;
5192
5193 if (ELF_ST_TYPE (isym->st_info) != STT_NOTYPE
5194 && (definition || h->type == STT_NOTYPE))
5195 {
5196 unsigned int type = ELF_ST_TYPE (isym->st_info);
5197
5198 if (h->type != type)
5199 {
5200 if (h->type != STT_NOTYPE && ! type_change_ok)
4eca0228 5201 _bfd_error_handler
695344c0 5202 /* xgettext:c-format */
38f14ab8 5203 (_("warning: type of symbol `%s' changed"
871b3ab2 5204 " from %d to %d in %pB"),
c08bb8dd 5205 name, h->type, type, abfd);
202e2356
NC		 5206
5207 h->type = type;
5208 }
5209 }
5210
5211 /* Set a flag in the hash table entry indicating the type of
5212 reference or definition we just found. Keep a count of
5213 the number of dynamic symbols we find. A dynamic symbol
5214 is one which is referenced or defined by both a regular
5215 object and a shared object. */
5216 if (! dynamic)
5217 {
5218 if (! definition)
5219 {
5220 h->ref_regular = 1;
5221 if (bind != STB_WEAK)
5222 h->ref_regular_nonweak = 1;
5223 }
5224 else
5225 {
07d6d2b8 5226 BFD_ASSERT (!h->def_dynamic);
202e2356
NC		 5227 h->def_regular = 1;
5228 }
5229 }
5230 else
5231 {
5232 BFD_ASSERT (definition);
07d6d2b8
AM		 5233 h->def_dynamic = 1;
5234 h->dynindx = -2;
5235 ((struct elf64_ia64_link_hash_entry *)h)->shl = abfd;
202e2356
NC		 5236 }
5237 }
5238 }
5239
5240 if (isymbuf != NULL)
5241 {
5242 free (isymbuf);
5243 isymbuf = NULL;
5244 }
5245
5246 /* If this object is the same format as the output object, and it is
5247 not a shared library, then let the backend look through the
5248 relocs.
5249
5250 This is required to build global offset table entries and to
5251 arrange for dynamic relocs. It is not required for the
5252 particular common case of linking non PIC code, even when linking
5253 against shared libraries, but unfortunately there is no way of
5254 knowing whether an object file has been compiled PIC or not.
5255 Looking through the relocs is not particularly time consuming.
5256 The problem is that we must either (1) keep the relocs in memory,
5257 which causes the linker to require additional runtime memory or
5258 (2) read the relocs twice from the input file, which wastes time.
5259 This would be a good case for using mmap.
5260
5261 I have no idea how to handle linking PIC code into a file of a
5262 different format. It probably can't be done. */
5263 if (! dynamic
5264 && is_elf_hash_table (htab)
5265 && bed->check_relocs != NULL
5266 && (*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
5267 {
5268 asection *o;
5269
5270 for (o = abfd->sections; o != NULL; o = o->next)
5271 {
5272 Elf_Internal_Rela *internal_relocs;
5273 bfd_boolean ok;
5274
5275 if ((o->flags & SEC_RELOC) == 0
5276 || o->reloc_count == 0
5277 || ((info->strip == strip_all || info->strip == strip_debugger)
5278 && (o->flags & SEC_DEBUGGING) != 0)
5279 || bfd_is_abs_section (o->output_section))
5280 continue;
5281
5282 internal_relocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
5283 info->keep_memory);
5284 if (internal_relocs == NULL)
5285 goto error_return;
5286
5287 ok = (*bed->check_relocs) (abfd, info, o, internal_relocs);
5288
5289 if (elf_section_data (o)->relocs != internal_relocs)
5290 free (internal_relocs);
5291
5292 if (! ok)
5293 goto error_return;
5294 }
5295 }
5296
5297 return TRUE;
5298
5299 error_free_vers:
5300 error_free_sym:
5301 if (isymbuf != NULL)
5302 free (isymbuf);
5303 error_return:
5304 return FALSE;
5305}
5306
5307static bfd_boolean
5308elf64_vms_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
5309{
5310 int pass;
5311 struct bfd_link_hash_entry **pundef;
5312 struct bfd_link_hash_entry **next_pundef;
5313
5314 /* We only accept VMS libraries. */
5315 if (info->output_bfd->xvec != abfd->xvec)
5316 {
5317 bfd_set_error (bfd_error_wrong_format);
5318 return FALSE;
5319 }
5320
5321 /* The archive_pass field in the archive itself is used to
5322 initialize PASS, since we may search the same archive multiple
5323 times. */
5324 pass = ++abfd->archive_pass;
5325
5326 /* Look through the list of undefined symbols. */
5327 for (pundef = &info->hash->undefs; *pundef != NULL; pundef = next_pundef)
5328 {
5329 struct bfd_link_hash_entry *h;
5330 symindex symidx;
5331 bfd *element;
5332 bfd *orig_element;
5333
5334 h = *pundef;
5335 next_pundef = &(*pundef)->u.undef.next;
5336
5337 /* When a symbol is defined, it is not necessarily removed from
5338 the list. */
5339 if (h->type != bfd_link_hash_undefined
5340 && h->type != bfd_link_hash_common)
5341 {
5342 /* Remove this entry from the list, for general cleanliness
5343 and because we are going to look through the list again
5344 if we search any more libraries. We can't remove the
5345 entry if it is the tail, because that would lose any
5346 entries we add to the list later on. */
5347 if (*pundef != info->hash->undefs_tail)
07d6d2b8
AM		 5348 {
5349 *pundef = *next_pundef;
5350 next_pundef = pundef;
5351 }
202e2356
NC		 5352 continue;
5353 }
5354
5355 /* Look for this symbol in the archive hash table. */
5356 symidx = _bfd_vms_lib_find_symbol (abfd, h->root.string);
5357 if (symidx == BFD_NO_MORE_SYMBOLS)
5358 {
5359 /* Nothing in this slot. */
5360 continue;
5361 }
5362
5363 element = bfd_get_elt_at_index (abfd, symidx);
5364 if (element == NULL)
5365 return FALSE;
5366
5367 if (element->archive_pass == -1 || element->archive_pass == pass)
07d6d2b8
AM		 5368 {
5369 /* Next symbol if this archive is wrong or already handled. */
5370 continue;
5371 }
202e2356
NC		 5372
5373 orig_element = element;
5374 if (bfd_is_thin_archive (abfd))
07d6d2b8
AM		 5375 {
5376 element = _bfd_vms_lib_get_imagelib_file (element);
5377 if (element == NULL || !bfd_check_format (element, bfd_object))
5378 {
5379 orig_element->archive_pass = -1;
5380 return FALSE;
5381 }
5382 }
202e2356 5383 else if (! bfd_check_format (element, bfd_object))
07d6d2b8
AM		 5384 {
5385 element->archive_pass = -1;
5386 return FALSE;
5387 }
202e2356
NC		 5388
5389 /* Unlike the generic linker, we know that this element provides
5390 a definition for an undefined symbol and we know that we want
5391 to include it. We don't need to check anything. */
5392 if (! (*info->callbacks->add_archive_element) (info, element,
07d6d2b8 5393 h->root.string, &element))
b95a0a31 5394 continue;
202e2356
NC		 5395 if (! elf64_vms_link_add_object_symbols (element, info))
5396 return FALSE;
5397
5398 orig_element->archive_pass = pass;
5399 }
5400
5401 return TRUE;
5402}
5403
5404static bfd_boolean
5405elf64_vms_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
5406{
5407 switch (bfd_get_format (abfd))
5408 {
5409 case bfd_object:
5410 return elf64_vms_link_add_object_symbols (abfd, info);
5411 break;
5412 case bfd_archive:
5413 return elf64_vms_link_add_archive_symbols (abfd, info);
5414 break;
5415 default:
5416 bfd_set_error (bfd_error_wrong_format);
5417 return FALSE;
5418 }
5419}
5420
5421static bfd_boolean
5422elf64_ia64_vms_mkobject (bfd *abfd)
5423{
5424 return bfd_elf_allocate_object
5425 (abfd, sizeof (struct elf64_ia64_vms_obj_tdata), IA64_ELF_DATA);
5426}
5427
5428
5429/* Size-dependent data and functions. */
5430static const struct elf_size_info elf64_ia64_vms_size_info = {
5431 sizeof (Elf64_External_VMS_Ehdr),
5432 sizeof (Elf64_External_Phdr),
5433 sizeof (Elf64_External_Shdr),
5434 sizeof (Elf64_External_Rel),
5435 sizeof (Elf64_External_Rela),
5436 sizeof (Elf64_External_Sym),
5437 sizeof (Elf64_External_Dyn),
5438 sizeof (Elf_External_Note),
5439 4,
5440 1,
5441 64, 3, /* ARCH_SIZE, LOG_FILE_ALIGN */
5442 ELFCLASS64, EV_CURRENT,
5443 bfd_elf64_write_out_phdrs,
5444 elf64_vms_write_shdrs_and_ehdr,
5445 bfd_elf64_checksum_contents,
5446 bfd_elf64_write_relocs,
5447 bfd_elf64_swap_symbol_in,
5448 bfd_elf64_swap_symbol_out,
5449 bfd_elf64_slurp_reloc_table,
5450 bfd_elf64_slurp_symbol_table,
5451 bfd_elf64_swap_dyn_in,
5452 bfd_elf64_swap_dyn_out,
5453 bfd_elf64_swap_reloc_in,
5454 bfd_elf64_swap_reloc_out,
5455 bfd_elf64_swap_reloca_in,
5456 bfd_elf64_swap_reloca_out
5457};
5458
5459#define ELF_ARCH bfd_arch_ia64
5460#define ELF_MACHINE_CODE EM_IA_64
5461#define ELF_MAXPAGESIZE 0x10000 /* 64KB */
5462#define ELF_COMMONPAGESIZE 0x200 /* 16KB */
5463
5464#define elf_backend_section_from_shdr \
5465 elf64_ia64_section_from_shdr
5466#define elf_backend_section_flags \
5467 elf64_ia64_section_flags
5468#define elf_backend_fake_sections \
5469 elf64_ia64_fake_sections
5470#define elf_backend_final_write_processing \
5471 elf64_ia64_final_write_processing
5472#define elf_backend_add_symbol_hook \
5473 elf64_ia64_add_symbol_hook
5474#define elf_info_to_howto \
5475 elf64_ia64_info_to_howto
5476
5477#define bfd_elf64_bfd_reloc_type_lookup \
5478 ia64_elf_reloc_type_lookup
5479#define bfd_elf64_bfd_reloc_name_lookup \
5480 ia64_elf_reloc_name_lookup
5481#define bfd_elf64_bfd_is_local_label_name \
5482 elf64_ia64_is_local_label_name
5483#define bfd_elf64_bfd_relax_section \
5484 elf64_ia64_relax_section
5485
5486#define elf_backend_object_p \
5487 elf64_ia64_object_p
5488
5489/* Stuff for the BFD linker: */
5490#define bfd_elf64_bfd_link_hash_table_create \
5491 elf64_ia64_hash_table_create
202e2356
NC		 5492#define elf_backend_create_dynamic_sections \
5493 elf64_ia64_create_dynamic_sections
5494#define elf_backend_check_relocs \
5495 elf64_ia64_check_relocs
5496#define elf_backend_adjust_dynamic_symbol \
5497 elf64_ia64_adjust_dynamic_symbol
5498#define elf_backend_size_dynamic_sections \
5499 elf64_ia64_size_dynamic_sections
5500#define elf_backend_omit_section_dynsym \
d00dd7dc 5501 _bfd_elf_omit_section_dynsym_all
202e2356
NC		 5502#define elf_backend_relocate_section \
5503 elf64_ia64_relocate_section
5504#define elf_backend_finish_dynamic_symbol \
5505 elf64_ia64_finish_dynamic_symbol
5506#define elf_backend_finish_dynamic_sections \
5507 elf64_ia64_finish_dynamic_sections
5508#define bfd_elf64_bfd_final_link \
5509 elf64_ia64_final_link
5510
5511#define bfd_elf64_bfd_merge_private_bfd_data \
5512 elf64_ia64_merge_private_bfd_data
5513#define bfd_elf64_bfd_set_private_flags \
5514 elf64_ia64_set_private_flags
5515#define bfd_elf64_bfd_print_private_bfd_data \
5516 elf64_ia64_print_private_bfd_data
5517
5518#define elf_backend_plt_readonly 1
5519#define elf_backend_want_plt_sym 0
5520#define elf_backend_plt_alignment 5
5521#define elf_backend_got_header_size 0
5522#define elf_backend_want_got_plt 1
5523#define elf_backend_may_use_rel_p 1
5524#define elf_backend_may_use_rela_p 1
5525#define elf_backend_default_use_rela_p 1
5526#define elf_backend_want_dynbss 0
5527#define elf_backend_hide_symbol elf64_ia64_hash_hide_symbol
5528#define elf_backend_fixup_symbol _bfd_elf_link_hash_fixup_symbol
5529#define elf_backend_reloc_type_class elf64_ia64_reloc_type_class
5530#define elf_backend_rela_normal 1
5531#define elf_backend_special_sections elf64_ia64_special_sections
5532#define elf_backend_default_execstack 0
5533
5534/* FIXME: PR 290: The Intel C compiler generates SHT_IA_64_UNWIND with
5535 SHF_LINK_ORDER. But it doesn't set the sh_link or sh_info fields.
5536 We don't want to flood users with so many error messages. We turn
5537 off the warning for now. It will be turned on later when the Intel
5538 compiler is fixed. */
5539#define elf_backend_link_order_error_handler NULL
5540
5541/* VMS-specific vectors. */
5542
5543#undef TARGET_LITTLE_SYM
6d00b590 5544#define TARGET_LITTLE_SYM ia64_elf64_vms_vec
202e2356
NC		 5545#undef TARGET_LITTLE_NAME
5546#define TARGET_LITTLE_NAME "elf64-ia64-vms"
5547#undef TARGET_BIG_SYM
5548#undef TARGET_BIG_NAME
5549
5550/* These are VMS specific functions. */
5551
5552#undef elf_backend_object_p
5553#define elf_backend_object_p elf64_vms_object_p
5554
5555#undef elf_backend_section_from_shdr
5556#define elf_backend_section_from_shdr elf64_vms_section_from_shdr
5557
5558#undef elf_backend_post_process_headers
5559#define elf_backend_post_process_headers elf64_vms_post_process_headers
5560
5561#undef elf_backend_section_processing
5562#define elf_backend_section_processing elf64_vms_section_processing
5563
5564#undef elf_backend_final_write_processing
5565#define elf_backend_final_write_processing elf64_vms_final_write_processing
5566
5567#undef bfd_elf64_close_and_cleanup
5568#define bfd_elf64_close_and_cleanup elf64_vms_close_and_cleanup
5569
5570#undef elf_backend_section_from_bfd_section
5571
5572#undef elf_backend_symbol_processing
5573
5574#undef elf_backend_want_p_paddr_set_to_zero
5575
5576#undef ELF_OSABI
5577#define ELF_OSABI ELFOSABI_OPENVMS
5578
5579#undef ELF_MAXPAGESIZE
5580#define ELF_MAXPAGESIZE 0x10000 /* 64KB */
5581
5582#undef elf64_bed
5583#define elf64_bed elf64_ia64_vms_bed
5584
5585#define elf_backend_size_info elf64_ia64_vms_size_info
5586
5587/* Use VMS-style archives (in particular, don't use the standard coff
5588 archive format). */
5589#define bfd_elf64_archive_functions
5590
5591#undef bfd_elf64_archive_p
5592#define bfd_elf64_archive_p _bfd_vms_lib_ia64_archive_p
5593#undef bfd_elf64_write_archive_contents
5594#define bfd_elf64_write_archive_contents _bfd_vms_lib_write_archive_contents
5595#undef bfd_elf64_mkarchive
5596#define bfd_elf64_mkarchive _bfd_vms_lib_ia64_mkarchive
5597
5598#define bfd_elf64_archive_slurp_armap \
5599 _bfd_vms_lib_slurp_armap
5600#define bfd_elf64_archive_slurp_extended_name_table \
5601 _bfd_vms_lib_slurp_extended_name_table
5602#define bfd_elf64_archive_construct_extended_name_table \
5603 _bfd_vms_lib_construct_extended_name_table
5604#define bfd_elf64_archive_truncate_arname \
5605 _bfd_vms_lib_truncate_arname
5606#define bfd_elf64_archive_write_armap \
5607 _bfd_vms_lib_write_armap
5608#define bfd_elf64_archive_read_ar_hdr \
5609 _bfd_vms_lib_read_ar_hdr
5610#define bfd_elf64_archive_write_ar_hdr \
5611 _bfd_vms_lib_write_ar_hdr
5612#define bfd_elf64_archive_openr_next_archived_file \
5613 _bfd_vms_lib_openr_next_archived_file
5614#define bfd_elf64_archive_get_elt_at_index \
5615 _bfd_vms_lib_get_elt_at_index
5616#define bfd_elf64_archive_generic_stat_arch_elt \
5617 _bfd_vms_lib_generic_stat_arch_elt
5618#define bfd_elf64_archive_update_armap_timestamp \
5619 _bfd_vms_lib_update_armap_timestamp
5620
5621/* VMS link methods. */
5622#undef bfd_elf64_bfd_link_add_symbols
07d6d2b8 5623#define bfd_elf64_bfd_link_add_symbols elf64_vms_bfd_link_add_symbols
202e2356
NC		 5624
5625#undef elf_backend_want_got_sym
07d6d2b8 5626#define elf_backend_want_got_sym 0
202e2356
NC		 5627
5628#undef bfd_elf64_mkobject
5629#define bfd_elf64_mkobject elf64_ia64_vms_mkobject
5630
5631/* Redefine to align segments on block size. */
5632#undef ELF_MAXPAGESIZE
5633#define ELF_MAXPAGESIZE 0x200 /* 512B */
5634
5635#undef elf_backend_want_got_plt
5636#define elf_backend_want_got_plt 0
5637
5638#include "elf64-target.h"
GDB Binutils - Deliverables
This page took 0.720653 seconds and 4 git commands to generate.