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