projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Use %A and %B in more error messages
[deliverable/binutils-gdb.git] / bfd / elf64-ia64-vms.c
CommitLineData
202e2356 1/* IA-64 support for OpenVMS
2571583a 2 Copyright (C) 1998-2017 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{
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;; */
263};
264
265static const bfd_byte oor_brl[16] =
266{
267 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, /* [MLX] nop.m 0 */
268 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* brl.sptk.few tgt;;*/
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),
558 R_IA64_PCREL21B);
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),
573 R_IA64_PCREL60B);
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 */
c08bb8dd
AM		 587 (_("%B: Can't relax br at 0x%lx in section `%A'."
588 " Please use brl or indirect branch."),
589 sec->owner, (unsigned long) 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 {
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;
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 {
706 /* Can't deal yet correctly with ABS symbols. */
707 if (bfd_is_abs_section (tsec))
708 continue;
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,
1148 unsigned int time_hi, unsigned int time_lo)
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",
1327 (SEC_LINKER_CREATED
1328 | SEC_HAS_CONTENTS
1329 | SEC_IN_MEMORY
1330 | SEC_READONLY));
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,
1616 except in the previously sorted section if one exists, and
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
NC		 1729 if (got == NULL
1730 || !bfd_set_section_alignment (dynobj, got, 3))
1731 return NULL;
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:
1980 abort ();
1981 break;
1982
1983 case R_IA64_IPLTMSB:
1984 case R_IA64_IPLTLSB:
1985 break;
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:
2035 case R_IA64_PCREL60B:
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. */
2102 h->root.non_ir_ref = 1;
202e2356
NC		 2103 h->ref_regular = 1;
2104 }
2105 else
2106 h = NULL;
2107
2108 /* We can only get preliminary data on whether a symbol is
2109 locally or externally defined, as not all of the input files
2110 have yet been processed. Do something with what we know, as
2111 this may help reduce memory usage and processing time later. */
0e1862bb 2112 maybe_dynamic = (h && ((!bfd_link_executable (info)
202e2356
NC		 2113 && (!SYMBOLIC_BIND (info, h)
2114 || info->unresolved_syms_in_shared_libs == RM_IGNORE))
2115 || !h->def_regular
2116 || h->root.type == bfd_link_hash_defweak));
2117
2118 need_entry = 0;
2119 switch (ELF64_R_TYPE (rel->r_info))
2120 {
2121 case R_IA64_TPREL64MSB:
2122 case R_IA64_TPREL64LSB:
2123 case R_IA64_LTOFF_TPREL22:
2124 case R_IA64_DTPREL32MSB:
2125 case R_IA64_DTPREL32LSB:
2126 case R_IA64_DTPREL64MSB:
2127 case R_IA64_DTPREL64LSB:
2128 case R_IA64_LTOFF_DTPREL22:
2129 case R_IA64_DTPMOD64MSB:
2130 case R_IA64_DTPMOD64LSB:
2131 case R_IA64_LTOFF_DTPMOD22:
2132 abort ();
2133 break;
2134
2135 case R_IA64_LTOFF_FPTR22:
2136 case R_IA64_LTOFF_FPTR64I:
2137 case R_IA64_LTOFF_FPTR32MSB:
2138 case R_IA64_LTOFF_FPTR32LSB:
2139 case R_IA64_LTOFF_FPTR64MSB:
2140 case R_IA64_LTOFF_FPTR64LSB:
2141 need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR;
2142 break;
2143
2144 case R_IA64_FPTR64I:
2145 case R_IA64_FPTR32MSB:
2146 case R_IA64_FPTR32LSB:
2147 case R_IA64_FPTR64MSB:
2148 case R_IA64_FPTR64LSB:
0e1862bb 2149 if (bfd_link_pic (info) || h)
202e2356
NC		 2150 need_entry = NEED_FPTR | NEED_DYNREL;
2151 else
2152 need_entry = NEED_FPTR;
2153 dynrel_type = R_IA64_FPTR64LSB;
2154 break;
2155
2156 case R_IA64_LTOFF22:
2157 case R_IA64_LTOFF64I:
2158 need_entry = NEED_GOT;
2159 break;
2160
2161 case R_IA64_LTOFF22X:
2162 need_entry = NEED_GOTX;
2163 break;
2164
2165 case R_IA64_PLTOFF22:
2166 case R_IA64_PLTOFF64I:
2167 case R_IA64_PLTOFF64MSB:
2168 case R_IA64_PLTOFF64LSB:
2169 need_entry = NEED_PLTOFF;
2170 if (h)
2171 {
2172 if (maybe_dynamic)
2173 need_entry |= NEED_MIN_PLT;
2174 }
2175 break;
2176
2177 case R_IA64_PCREL21B:
2178 case R_IA64_PCREL60B:
2179 /* Depending on where this symbol is defined, we may or may not
2180 need a full plt entry. Only skip if we know we'll not need
2181 the entry -- static or symbolic, and the symbol definition
2182 has already been seen. */
2183 if (maybe_dynamic && rel->r_addend == 0)
2184 need_entry = NEED_FULL_PLT;
2185 break;
2186
2187 case R_IA64_IMM14:
2188 case R_IA64_IMM22:
2189 case R_IA64_IMM64:
2190 case R_IA64_DIR32MSB:
2191 case R_IA64_DIR32LSB:
2192 case R_IA64_DIR64MSB:
2193 case R_IA64_DIR64LSB:
2194 /* Shared objects will always need at least a REL relocation. */
0e1862bb 2195 if (bfd_link_pic (info) || maybe_dynamic)
202e2356
NC		 2196 need_entry = NEED_DYNREL;
2197 dynrel_type = R_IA64_DIR64LSB;
2198 break;
2199
2200 case R_IA64_IPLTMSB:
2201 case R_IA64_IPLTLSB:
2202 break;
2203
2204 case R_IA64_PCREL22:
2205 case R_IA64_PCREL64I:
2206 case R_IA64_PCREL32MSB:
2207 case R_IA64_PCREL32LSB:
2208 case R_IA64_PCREL64MSB:
2209 case R_IA64_PCREL64LSB:
2210 if (maybe_dynamic)
2211 need_entry = NEED_DYNREL;
2212 dynrel_type = R_IA64_PCREL64LSB;
2213 break;
2214 }
2215
2216 if (!need_entry)
2217 continue;
2218
2219 dyn_i = get_dyn_sym_info (ia64_info, h, abfd, rel, FALSE);
2220
2221 /* Record whether or not this is a local symbol. */
2222 dyn_i->h = h;
2223
2224 /* Create what's needed. */
2225 if (need_entry & (NEED_GOT | NEED_GOTX))
2226 {
2227 if (!got)
2228 {
2229 got = get_got (abfd, ia64_info);
2230 if (!got)
2231 return FALSE;
2232 }
2233 if (need_entry & NEED_GOT)
2234 dyn_i->want_got = 1;
2235 if (need_entry & NEED_GOTX)
2236 dyn_i->want_gotx = 1;
2237 }
2238 if (need_entry & NEED_FPTR)
2239 {
2240 /* Create the .opd section. */
2241 if (!fptr)
2242 {
2243 fptr = get_fptr (abfd, info, ia64_info);
2244 if (!fptr)
2245 return FALSE;
2246 }
2247 dyn_i->want_fptr = 1;
2248 }
2249 if (need_entry & NEED_LTOFF_FPTR)
2250 dyn_i->want_ltoff_fptr = 1;
2251 if (need_entry & (NEED_MIN_PLT | NEED_FULL_PLT))
2252 {
2253 if (!ia64_info->root.dynobj)
2254 ia64_info->root.dynobj = abfd;
2255 h->needs_plt = 1;
2256 dyn_i->want_plt = 1;
2257 }
2258 if (need_entry & NEED_FULL_PLT)
2259 dyn_i->want_plt2 = 1;
2260 if (need_entry & NEED_PLTOFF)
2261 {
2262 /* This is needed here, in case @pltoff is used in a non-shared
2263 link. */
2264 if (!pltoff)
2265 {
2266 pltoff = get_pltoff (abfd, ia64_info);
2267 if (!pltoff)
2268 return FALSE;
2269 }
2270
2271 dyn_i->want_pltoff = 1;
2272 }
2273 if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC))
2274 {
2275 if (!srel)
2276 {
2277 srel = get_reloc_section (abfd, ia64_info, sec, TRUE);
2278 if (!srel)
2279 return FALSE;
2280 }
2281 if (!count_dyn_reloc (abfd, dyn_i, srel, dynrel_type))
2282 return FALSE;
2283 }
2284 }
2285
2286 return TRUE;
2287}
2288
2289/* For cleanliness, and potentially faster dynamic loading, allocate
2290 external GOT entries first. */
2291
2292static bfd_boolean
2293allocate_global_data_got (struct elf64_ia64_dyn_sym_info *dyn_i,
2294 void * data)
2295{
2296 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2297
2298 if ((dyn_i->want_got || dyn_i->want_gotx)
2299 && ! dyn_i->want_fptr
2300 && elf64_ia64_dynamic_symbol_p (dyn_i->h))
2301 {
2302 /* GOT entry with FPTR is done by allocate_global_fptr_got. */
2303 dyn_i->got_offset = x->ofs;
2304 x->ofs += 8;
2305 }
2306 return TRUE;
2307}
2308
2309/* Next, allocate all the GOT entries used by LTOFF_FPTR relocs. */
2310
2311static bfd_boolean
2312allocate_global_fptr_got (struct elf64_ia64_dyn_sym_info *dyn_i,
2313 void * data)
2314{
2315 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2316
2317 if (dyn_i->want_got
2318 && dyn_i->want_fptr
2319 && elf64_ia64_dynamic_symbol_p (dyn_i->h))
2320 {
2321 dyn_i->got_offset = x->ofs;
2322 x->ofs += 8;
2323 }
2324 return TRUE;
2325}
2326
2327/* Lastly, allocate all the GOT entries for local data. */
2328
2329static bfd_boolean
2330allocate_local_got (struct elf64_ia64_dyn_sym_info *dyn_i,
2331 void * data)
2332{
2333 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *) data;
2334
2335 if ((dyn_i->want_got || dyn_i->want_gotx)
2336 && !elf64_ia64_dynamic_symbol_p (dyn_i->h))
2337 {
2338 dyn_i->got_offset = x->ofs;
2339 x->ofs += 8;
2340 }
2341 return TRUE;
2342}
2343
2344/* Allocate function descriptors. We can do these for every function
2345 in a main executable that is not exported. */
2346
2347static bfd_boolean
2348allocate_fptr (struct elf64_ia64_dyn_sym_info *dyn_i, void * data)
2349{
2350 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *) data;
2351
2352 if (dyn_i->want_fptr)
2353 {
2354 struct elf_link_hash_entry *h = dyn_i->h;
2355
2356 if (h)
2357 while (h->root.type == bfd_link_hash_indirect
2358 || h->root.type == bfd_link_hash_warning)
2359 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2360
2361 if (h == NULL || !h->def_dynamic)
2362 {
2363 /* A non dynamic symbol. */
2364 dyn_i->fptr_offset = x->ofs;
2365 x->ofs += 16;
2366 }
2367 else
2368 dyn_i->want_fptr = 0;
2369 }
2370 return TRUE;
2371}
2372
2373/* Allocate all the minimal PLT entries. */
2374
2375static bfd_boolean
2376allocate_plt_entries (struct elf64_ia64_dyn_sym_info *dyn_i,
2377 void * data ATTRIBUTE_UNUSED)
2378{
2379 if (dyn_i->want_plt)
2380 {
2381 struct elf_link_hash_entry *h = dyn_i->h;
2382
2383 if (h)
2384 while (h->root.type == bfd_link_hash_indirect
2385 || h->root.type == bfd_link_hash_warning)
2386 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2387
2388 /* ??? Versioned symbols seem to lose NEEDS_PLT. */
2389 if (elf64_ia64_dynamic_symbol_p (h))
2390 {
2391 dyn_i->want_pltoff = 1;
2392 }
2393 else
2394 {
2395 dyn_i->want_plt = 0;
2396 dyn_i->want_plt2 = 0;
2397 }
2398 }
2399 return TRUE;
2400}
2401
2402/* Allocate all the full PLT entries. */
2403
2404static bfd_boolean
2405allocate_plt2_entries (struct elf64_ia64_dyn_sym_info *dyn_i,
2406 void * data)
2407{
2408 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2409
2410 if (dyn_i->want_plt2)
2411 {
2412 struct elf_link_hash_entry *h = dyn_i->h;
2413 bfd_size_type ofs = x->ofs;
2414
2415 dyn_i->plt2_offset = ofs;
2416 x->ofs = ofs + PLT_FULL_ENTRY_SIZE;
2417
2418 while (h->root.type == bfd_link_hash_indirect
2419 || h->root.type == bfd_link_hash_warning)
2420 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2421 dyn_i->h->plt.offset = ofs;
2422 }
2423 return TRUE;
2424}
2425
2426/* Allocate all the PLTOFF entries requested by relocations and
2427 plt entries. We can't share space with allocated FPTR entries,
2428 because the latter are not necessarily addressable by the GP.
2429 ??? Relaxation might be able to determine that they are. */
2430
2431static bfd_boolean
2432allocate_pltoff_entries (struct elf64_ia64_dyn_sym_info *dyn_i,
2433 void * data)
2434{
2435 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2436
2437 if (dyn_i->want_pltoff)
2438 {
2439 dyn_i->pltoff_offset = x->ofs;
2440 x->ofs += 16;
2441 }
2442 return TRUE;
2443}
2444
2445/* Allocate dynamic relocations for those symbols that turned out
2446 to be dynamic. */
2447
2448static bfd_boolean
2449allocate_dynrel_entries (struct elf64_ia64_dyn_sym_info *dyn_i,
2450 void * data)
2451{
2452 struct elf64_ia64_allocate_data *x = (struct elf64_ia64_allocate_data *)data;
2453 struct elf64_ia64_link_hash_table *ia64_info;
2454 struct elf64_ia64_dyn_reloc_entry *rent;
2455 bfd_boolean dynamic_symbol, shared, resolved_zero;
2456 struct elf64_ia64_link_hash_entry *h_ia64;
2457
2458 ia64_info = elf64_ia64_hash_table (x->info);
2459 if (ia64_info == NULL)
2460 return FALSE;
2461
2462 /* Note that this can't be used in relation to FPTR relocs below. */
2463 dynamic_symbol = elf64_ia64_dynamic_symbol_p (dyn_i->h);
2464
0e1862bb 2465 shared = bfd_link_pic (x->info);
202e2356
NC		 2466 resolved_zero = (dyn_i->h
2467 && ELF_ST_VISIBILITY (dyn_i->h->other)
2468 && dyn_i->h->root.type == bfd_link_hash_undefweak);
2469
2470 /* Take care of the GOT and PLT relocations. */
2471
2472 if ((!resolved_zero
2473 && (dynamic_symbol || shared)
2474 && (dyn_i->want_got || dyn_i->want_gotx))
2475 || (dyn_i->want_ltoff_fptr
2476 && dyn_i->h
2477 && dyn_i->h->def_dynamic))
2478 {
2479 /* VMS: FIX64. */
2480 if (dyn_i->h != NULL && dyn_i->h->def_dynamic)
2481 {
2482 h_ia64 = (struct elf64_ia64_link_hash_entry *) dyn_i->h;
2483 elf_ia64_vms_tdata (h_ia64->shl)->fixups_off +=
2484 sizeof (Elf64_External_VMS_IMAGE_FIXUP);
2485 ia64_info->fixups_sec->size +=
2486 sizeof (Elf64_External_VMS_IMAGE_FIXUP);
2487 }
2488 }
2489
2490 if (ia64_info->rel_fptr_sec && dyn_i->want_fptr)
2491 {
2492 /* VMS: only image reloc. */
2493 if (dyn_i->h == NULL || dyn_i->h->root.type != bfd_link_hash_undefweak)
2494 ia64_info->rel_fptr_sec->size += sizeof (Elf64_External_Rela);
2495 }
2496
2497 if (!resolved_zero && dyn_i->want_pltoff)
2498 {
2499 /* VMS: FIXFD. */
2500 if (dyn_i->h != NULL && dyn_i->h->def_dynamic)
2501 {
2502 h_ia64 = (struct elf64_ia64_link_hash_entry *) dyn_i->h;
2503 elf_ia64_vms_tdata (h_ia64->shl)->fixups_off +=
2504 sizeof (Elf64_External_VMS_IMAGE_FIXUP);
2505 ia64_info->fixups_sec->size +=
2506 sizeof (Elf64_External_VMS_IMAGE_FIXUP);
2507 }
2508 }
2509
2510 /* Take care of the normal data relocations. */
2511
2512 for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
2513 {
2514 int count = rent->count;
2515
2516 switch (rent->type)
2517 {
2518 case R_IA64_FPTR32LSB:
2519 case R_IA64_FPTR64LSB:
2520 /* Allocate one iff !want_fptr and not PIE, which by this point
2521 will be true only if we're actually allocating one statically
2522 in the main executable. Position independent executables
2523 need a relative reloc. */
0e1862bb 2524 if (dyn_i->want_fptr && !bfd_link_pie (x->info))
202e2356
NC		 2525 continue;
2526 break;
2527 case R_IA64_PCREL32LSB:
2528 case R_IA64_PCREL64LSB:
2529 if (!dynamic_symbol)
2530 continue;
2531 break;
2532 case R_IA64_DIR32LSB:
2533 case R_IA64_DIR64LSB:
2534 if (!dynamic_symbol && !shared)
2535 continue;
2536 break;
2537 case R_IA64_IPLTLSB:
2538 if (!dynamic_symbol && !shared)
2539 continue;
2540 /* Use two REL relocations for IPLT relocations
2541 against local symbols. */
2542 if (!dynamic_symbol)
2543 count *= 2;
2544 break;
2545 case R_IA64_DTPREL32LSB:
2546 case R_IA64_TPREL64LSB:
2547 case R_IA64_DTPREL64LSB:
2548 case R_IA64_DTPMOD64LSB:
2549 break;
2550 default:
2551 abort ();
2552 }
2553
2554 /* Add a fixup. */
2555 if (!dynamic_symbol)
2556 abort ();
2557
2558 h_ia64 = (struct elf64_ia64_link_hash_entry *) dyn_i->h;
2559 elf_ia64_vms_tdata (h_ia64->shl)->fixups_off +=
2560 sizeof (Elf64_External_VMS_IMAGE_FIXUP);
2561 ia64_info->fixups_sec->size +=
2562 sizeof (Elf64_External_VMS_IMAGE_FIXUP);
2563 }
2564
2565 return TRUE;
2566}
2567
2568static bfd_boolean
2569elf64_ia64_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
2570 struct elf_link_hash_entry *h)
2571{
2572 /* ??? Undefined symbols with PLT entries should be re-defined
2573 to be the PLT entry. */
2574
2575 /* If this is a weak symbol, and there is a real definition, the
2576 processor independent code will have arranged for us to see the
2577 real definition first, and we can just use the same value. */
2578 if (h->u.weakdef != NULL)
2579 {
2580 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2581 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2582 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2583 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2584 return TRUE;
2585 }
2586
2587 /* If this is a reference to a symbol defined by a dynamic object which
2588 is not a function, we might allocate the symbol in our .dynbss section
2589 and allocate a COPY dynamic relocation.
2590
2591 But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2592 of hackery. */
2593
2594 return TRUE;
2595}
2596
2597static bfd_boolean
2598elf64_ia64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2599 struct bfd_link_info *info)
2600{
2601 struct elf64_ia64_allocate_data data;
2602 struct elf64_ia64_link_hash_table *ia64_info;
2603 asection *sec;
2604 bfd *dynobj;
2605 struct elf_link_hash_table *hash_table;
2606
2607 hash_table = elf_hash_table (info);
2608 dynobj = hash_table->dynobj;
2609 ia64_info = elf64_ia64_hash_table (info);
2610 if (ia64_info == NULL)
2611 return FALSE;
2612 BFD_ASSERT(dynobj != NULL);
2613 data.info = info;
2614
2615 /* Allocate the GOT entries. */
2616
2617 if (ia64_info->root.sgot)
2618 {
2619 data.ofs = 0;
2620 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data);
2621 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data);
2622 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data);
2623 ia64_info->root.sgot->size = data.ofs;
2624 }
2625
2626 /* Allocate the FPTR entries. */
2627
2628 if (ia64_info->fptr_sec)
2629 {
2630 data.ofs = 0;
2631 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_fptr, &data);
2632 ia64_info->fptr_sec->size = data.ofs;
2633 }
2634
2635 /* Now that we've seen all of the input files, we can decide which
2636 symbols need plt entries. Allocate the minimal PLT entries first.
2637 We do this even though dynamic_sections_created may be FALSE, because
2638 this has the side-effect of clearing want_plt and want_plt2. */
2639
2640 data.ofs = 0;
2641 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_plt_entries, &data);
2642
2643 /* Align the pointer for the plt2 entries. */
2644 data.ofs = (data.ofs + 31) & (bfd_vma) -32;
2645
2646 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_plt2_entries, &data);
2647 if (data.ofs != 0 || ia64_info->root.dynamic_sections_created)
2648 {
2649 /* FIXME: we always reserve the memory for dynamic linker even if
2650 there are no PLT entries since dynamic linker may assume the
2651 reserved memory always exists. */
2652
2653 BFD_ASSERT (ia64_info->root.dynamic_sections_created);
2654
2655 ia64_info->root.splt->size = data.ofs;
2656 }
2657
2658 /* Allocate the PLTOFF entries. */
2659
2660 if (ia64_info->pltoff_sec)
2661 {
2662 data.ofs = 0;
2663 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_pltoff_entries, &data);
2664 ia64_info->pltoff_sec->size = data.ofs;
2665 }
2666
2667 if (ia64_info->root.dynamic_sections_created)
2668 {
2669 /* Allocate space for the dynamic relocations that turned out to be
2670 required. */
2671 elf64_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries, &data);
2672 }
2673
2674 /* We have now determined the sizes of the various dynamic sections.
2675 Allocate memory for them. */
2676 for (sec = dynobj->sections; sec != NULL; sec = sec->next)
2677 {
2678 bfd_boolean strip;
2679
2680 if (!(sec->flags & SEC_LINKER_CREATED))
2681 continue;
2682
2683 /* If we don't need this section, strip it from the output file.
2684 There were several sections primarily related to dynamic
2685 linking that must be create before the linker maps input
2686 sections to output sections. The linker does that before
2687 bfd_elf_size_dynamic_sections is called, and it is that
2688 function which decides whether anything needs to go into
2689 these sections. */
2690
2691 strip = (sec->size == 0);
2692
2693 if (sec == ia64_info->root.sgot)
2694 strip = FALSE;
2695 else if (sec == ia64_info->root.srelgot)
2696 {
2697 if (strip)
2698 ia64_info->root.srelgot = NULL;
2699 else
2700 /* We use the reloc_count field as a counter if we need to
2701 copy relocs into the output file. */
2702 sec->reloc_count = 0;
2703 }
2704 else if (sec == ia64_info->fptr_sec)
2705 {
2706 if (strip)
2707 ia64_info->fptr_sec = NULL;
2708 }
2709 else if (sec == ia64_info->rel_fptr_sec)
2710 {
2711 if (strip)
2712 ia64_info->rel_fptr_sec = NULL;
2713 else
2714 /* We use the reloc_count field as a counter if we need to
2715 copy relocs into the output file. */
2716 sec->reloc_count = 0;
2717 }
2718 else if (sec == ia64_info->root.splt)
2719 {
2720 if (strip)
2721 ia64_info->root.splt = NULL;
2722 }
2723 else if (sec == ia64_info->pltoff_sec)
2724 {
2725 if (strip)
2726 ia64_info->pltoff_sec = NULL;
2727 }
2728 else if (sec == ia64_info->fixups_sec)
2729 {
2730 if (strip)
2731 ia64_info->fixups_sec = NULL;
2732 }
2733 else if (sec == ia64_info->transfer_sec)
2734 {
2735 ;
2736 }
2737 else
2738 {
2739 const char *name;
2740
2741 /* It's OK to base decisions on the section name, because none
2742 of the dynobj section names depend upon the input files. */
2743 name = bfd_get_section_name (dynobj, sec);
2744
2745 if (strcmp (name, ".got.plt") == 0)
2746 strip = FALSE;
2747 else if (CONST_STRNEQ (name, ".rel"))
2748 {
2749 if (!strip)
2750 {
2751 /* We use the reloc_count field as a counter if we need to
2752 copy relocs into the output file. */
2753 sec->reloc_count = 0;
2754 }
2755 }
2756 else
2757 continue;
2758 }
2759
2760 if (strip)
2761 sec->flags |= SEC_EXCLUDE;
2762 else
2763 {
2764 /* Allocate memory for the section contents. */
2765 sec->contents = (bfd_byte *) bfd_zalloc (dynobj, sec->size);
2766 if (sec->contents == NULL && sec->size != 0)
2767 return FALSE;
2768 }
2769 }
2770
2771 if (elf_hash_table (info)->dynamic_sections_created)
2772 {
2773 bfd *abfd;
2774 asection *dynsec;
2775 asection *dynstrsec;
2776 Elf_Internal_Dyn dyn;
2777 const struct elf_backend_data *bed;
2778 unsigned int shl_num = 0;
2779 bfd_vma fixups_off = 0;
2780 bfd_vma strdyn_off;
2781 unsigned int time_hi, time_lo;
2782
2783 /* The .dynamic section must exist and be empty. */
3d4d4302 2784 dynsec = bfd_get_linker_section (hash_table->dynobj, ".dynamic");
202e2356
NC		 2785 BFD_ASSERT (dynsec != NULL);
2786 BFD_ASSERT (dynsec->size == 0);
2787
3d4d4302 2788 dynstrsec = bfd_get_linker_section (hash_table->dynobj, ".vmsdynstr");
202e2356
NC		 2789 BFD_ASSERT (dynstrsec != NULL);
2790 BFD_ASSERT (dynstrsec->size == 0);
2791 dynstrsec->size = 1; /* Initial blank. */
2792
2793 /* Ident + link time. */
2794 vms_get_time (&time_hi, &time_lo);
2795
2796 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_IDENT, 0))
2797 return FALSE;
2798 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_LINKTIME,
2799 (((bfd_uint64_t)time_hi) << 32)
2800 + time_lo))
2801 return FALSE;
2802
2803 /* Strtab. */
2804 strdyn_off = dynsec->size;
2805 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_STRTAB_OFFSET, 0))
2806 return FALSE;
2807 if (!_bfd_elf_add_dynamic_entry (info, DT_STRSZ, 0))
2808 return FALSE;
2809
2810 /* PLTGOT */
2811 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_PLTGOT_SEG, 0))
2812 return FALSE;
2813 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_PLTGOT_OFFSET, 0))
2814 return FALSE;
2815
2816 /* Misc. */
2817 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_FPMODE, 0x9800000))
2818 return FALSE;
2819 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_LNKFLAGS,
2820 VMS_LF_IMGSTA | VMS_LF_MAIN))
2821 return FALSE;
2822
2823 /* Add entries for shared libraries. */
c72f2fb2 2824 for (abfd = info->input_bfds; abfd; abfd = abfd->link.next)
202e2356
NC		 2825 {
2826 char *soname;
2827 size_t soname_len;
2828 bfd_size_type strindex;
2829 bfd_byte *newcontents;
2830 bfd_vma fixups_shl_off;
2831
2832 if (!(abfd->flags & DYNAMIC))
2833 continue;
2834 BFD_ASSERT (abfd->xvec == output_bfd->xvec);
2835
2836 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_NEEDED_IDENT,
2837 elf_ia64_vms_ident (abfd)))
2838 return FALSE;
2839
2840 soname = vms_get_module_name (abfd->filename, TRUE);
2841 if (soname == NULL)
2842 return FALSE;
2843 strindex = dynstrsec->size;
2844 soname_len = strlen (soname) + 1;
2845 newcontents = (bfd_byte *) bfd_realloc (dynstrsec->contents,
2846 strindex + soname_len);
2847 if (newcontents == NULL)
2848 return FALSE;
2849 memcpy (newcontents + strindex, soname, soname_len);
2850 dynstrsec->size += soname_len;
2851 dynstrsec->contents = newcontents;
2852
2853 if (!_bfd_elf_add_dynamic_entry (info, DT_NEEDED, strindex))
2854 return FALSE;
2855
2856 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_FIXUP_NEEDED,
2857 shl_num))
2858 return FALSE;
2859 shl_num++;
2860
2861 /* The fixups_off was in fact containing the size of the fixup
2862 section. Remap into the offset. */
2863 fixups_shl_off = elf_ia64_vms_tdata (abfd)->fixups_off;
2864 elf_ia64_vms_tdata (abfd)->fixups_off = fixups_off;
2865
2866 if (!_bfd_elf_add_dynamic_entry
2867 (info, DT_IA_64_VMS_FIXUP_RELA_CNT,
2868 fixups_shl_off / sizeof (Elf64_External_VMS_IMAGE_FIXUP)))
2869 return FALSE;
2870 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_FIXUP_RELA_OFF,
2871 fixups_off))
2872 return FALSE;
2873 fixups_off += fixups_shl_off;
2874 }
2875
2876 /* Unwind. */
2877 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWINDSZ, 0))
2878 return FALSE;
2879 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWIND_CODSEG, 0))
2880 return FALSE;
2881 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWIND_INFOSEG, 0))
2882 return FALSE;
2883 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWIND_OFFSET, 0))
2884 return FALSE;
2885 if (!_bfd_elf_add_dynamic_entry (info, DT_IA_64_VMS_UNWIND_SEG, 0))
2886 return FALSE;
2887
2888 if (!_bfd_elf_add_dynamic_entry (info, DT_NULL, 0xdead))
2889 return FALSE;
2890
2891 /* Fix the strtab entries. */
2892 bed = get_elf_backend_data (hash_table->dynobj);
2893
2894 if (dynstrsec->size > 1)
2895 dynstrsec->contents[0] = 0;
2896 else
2897 dynstrsec->size = 0;
2898
2899 /* Note: one 'spare' (ie DT_NULL) entry is added by
2900 bfd_elf_size_dynsym_hash_dynstr. */
2901 dyn.d_tag = DT_IA_64_VMS_STRTAB_OFFSET;
2902 dyn.d_un.d_val = dynsec->size /* + sizeof (Elf64_External_Dyn) */;
2903 bed->s->swap_dyn_out (hash_table->dynobj, &dyn,
2904 dynsec->contents + strdyn_off);
2905
2906 dyn.d_tag = DT_STRSZ;
2907 dyn.d_un.d_val = dynstrsec->size;
2908 bed->s->swap_dyn_out (hash_table->dynobj, &dyn,
2909 dynsec->contents + strdyn_off + bed->s->sizeof_dyn);
2910
2911 elf_ia64_vms_tdata (output_bfd)->needed_count = shl_num;
2912
2913 /* Note section. */
2914 if (!create_ia64_vms_notes (output_bfd, info, time_hi, time_lo))
2915 return FALSE;
2916 }
2917
2918 /* ??? Perhaps force __gp local. */
2919
2920 return TRUE;
2921}
2922
2923static void
2924elf64_ia64_install_fixup (bfd *output_bfd,
2925 struct elf64_ia64_link_hash_table *ia64_info,
2926 struct elf_link_hash_entry *h,
2927 unsigned int type, asection *sec, bfd_vma offset,
2928 bfd_vma addend)
2929{
2930 asection *relsec;
2931 Elf64_External_VMS_IMAGE_FIXUP *fixup;
2932 struct elf64_ia64_link_hash_entry *h_ia64;
2933 bfd_vma fixoff;
2934 Elf_Internal_Phdr *phdr;
2935
2936 if (h == NULL || !h->def_dynamic)
2937 abort ();
2938
2939 h_ia64 = (struct elf64_ia64_link_hash_entry *) h;
2940 fixoff = elf_ia64_vms_tdata (h_ia64->shl)->fixups_off;
2941 elf_ia64_vms_tdata (h_ia64->shl)->fixups_off +=
2942 sizeof (Elf64_External_VMS_IMAGE_FIXUP);
2943 relsec = ia64_info->fixups_sec;
2944
2945 fixup = (Elf64_External_VMS_IMAGE_FIXUP *)(relsec->contents + fixoff);
2946 offset += sec->output_section->vma + sec->output_offset;
2947
2948 /* FIXME: this is slow. We should cache the last one used, or create a
2949 map. */
2950 phdr = _bfd_elf_find_segment_containing_section
2951 (output_bfd, sec->output_section);
2952 BFD_ASSERT (phdr != NULL);
2953
2954 bfd_putl64 (offset - phdr->p_vaddr, fixup->fixup_offset);
2955 bfd_putl32 (type, fixup->type);
2956 bfd_putl32 (phdr - elf_tdata (output_bfd)->phdr, fixup->fixup_seg);
2957 bfd_putl64 (addend, fixup->addend);
2958 bfd_putl32 (h->root.u.def.value, fixup->symvec_index);
2959 bfd_putl32 (2, fixup->data_type);
2960}
2961
2962/* Store an entry for target address TARGET_ADDR in the linkage table
2963 and return the gp-relative address of the linkage table entry. */
2964
2965static bfd_vma
2966set_got_entry (bfd *abfd, struct bfd_link_info *info,
2967 struct elf64_ia64_dyn_sym_info *dyn_i,
2968 bfd_vma addend, bfd_vma value, unsigned int dyn_r_type)
2969{
2970 struct elf64_ia64_link_hash_table *ia64_info;
2971 asection *got_sec;
2972 bfd_boolean done;
2973 bfd_vma got_offset;
2974
2975 ia64_info = elf64_ia64_hash_table (info);
2976 if (ia64_info == NULL)
2977 return 0;
2978
2979 got_sec = ia64_info->root.sgot;
2980
2981 switch (dyn_r_type)
2982 {
2983 case R_IA64_TPREL64LSB:
2984 case R_IA64_DTPMOD64LSB:
2985 case R_IA64_DTPREL32LSB:
2986 case R_IA64_DTPREL64LSB:
2987 abort ();
2988 break;
2989 default:
2990 done = dyn_i->got_done;
2991 dyn_i->got_done = TRUE;
2992 got_offset = dyn_i->got_offset;
2993 break;
2994 }
2995
2996 BFD_ASSERT ((got_offset & 7) == 0);
2997
2998 if (! done)
2999 {
3000 /* Store the target address in the linkage table entry. */
3001 bfd_put_64 (abfd, value, got_sec->contents + got_offset);
3002
3003 /* Install a dynamic relocation if needed. */
0e1862bb 3004 if (((bfd_link_pic (info)
202e2356
NC		 3005 && (!dyn_i->h
3006 || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
3007 || dyn_i->h->root.type != bfd_link_hash_undefweak))
3008 || elf64_ia64_dynamic_symbol_p (dyn_i->h))
3009 && (!dyn_i->want_ltoff_fptr
0e1862bb 3010 || !bfd_link_pie (info)
202e2356
NC		 3011 || !dyn_i->h
3012 || dyn_i->h->root.type != bfd_link_hash_undefweak))
3013 {
3014 if (!dyn_i->h || !dyn_i->h->def_dynamic)
3015 {
3016 dyn_r_type = R_IA64_REL64LSB;
3017 addend = value;
3018 }
3019
3020 /* VMS: install a FIX32 or FIX64. */
3021 switch (dyn_r_type)
3022 {
3023 case R_IA64_DIR32LSB:
3024 case R_IA64_FPTR32LSB:
3025 dyn_r_type = R_IA64_VMS_FIX32;
3026 break;
3027 case R_IA64_DIR64LSB:
3028 case R_IA64_FPTR64LSB:
3029 dyn_r_type = R_IA64_VMS_FIX64;
3030 break;
3031 default:
3032 BFD_ASSERT (FALSE);
3033 break;
3034 }
3035 elf64_ia64_install_fixup
3036 (info->output_bfd, ia64_info, dyn_i->h,
3037 dyn_r_type, got_sec, got_offset, addend);
3038 }
3039 }
3040
3041 /* Return the address of the linkage table entry. */
3042 value = (got_sec->output_section->vma
3043 + got_sec->output_offset
3044 + got_offset);
3045
3046 return value;
3047}
3048
3049/* Fill in a function descriptor consisting of the function's code
3050 address and its global pointer. Return the descriptor's address. */
3051
3052static bfd_vma
3053set_fptr_entry (bfd *abfd, struct bfd_link_info *info,
3054 struct elf64_ia64_dyn_sym_info *dyn_i,
3055 bfd_vma value)
3056{
3057 struct elf64_ia64_link_hash_table *ia64_info;
3058 asection *fptr_sec;
3059
3060 ia64_info = elf64_ia64_hash_table (info);
3061 if (ia64_info == NULL)
3062 return 0;
3063
3064 fptr_sec = ia64_info->fptr_sec;
3065
3066 if (!dyn_i->fptr_done)
3067 {
3068 dyn_i->fptr_done = 1;
3069
3070 /* Fill in the function descriptor. */
3071 bfd_put_64 (abfd, value, fptr_sec->contents + dyn_i->fptr_offset);
3072 bfd_put_64 (abfd, _bfd_get_gp_value (abfd),
3073 fptr_sec->contents + dyn_i->fptr_offset + 8);
3074 }
3075
3076 /* Return the descriptor's address. */
3077 value = (fptr_sec->output_section->vma
3078 + fptr_sec->output_offset
3079 + dyn_i->fptr_offset);
3080
3081 return value;
3082}
3083
3084/* Fill in a PLTOFF entry consisting of the function's code address
3085 and its global pointer. Return the descriptor's address. */
3086
3087static bfd_vma
3088set_pltoff_entry (bfd *abfd, struct bfd_link_info *info,
3089 struct elf64_ia64_dyn_sym_info *dyn_i,
3090 bfd_vma value, bfd_boolean is_plt)
3091{
3092 struct elf64_ia64_link_hash_table *ia64_info;
3093 asection *pltoff_sec;
3094
3095 ia64_info = elf64_ia64_hash_table (info);
3096 if (ia64_info == NULL)
3097 return 0;
3098
3099 pltoff_sec = ia64_info->pltoff_sec;
3100
3101 /* Don't do anything if this symbol uses a real PLT entry. In
3102 that case, we'll fill this in during finish_dynamic_symbol. */
3103 if ((! dyn_i->want_plt || is_plt)
3104 && !dyn_i->pltoff_done)
3105 {
3106 bfd_vma gp = _bfd_get_gp_value (abfd);
3107
3108 /* Fill in the function descriptor. */
3109 bfd_put_64 (abfd, value, pltoff_sec->contents + dyn_i->pltoff_offset);
3110 bfd_put_64 (abfd, gp, pltoff_sec->contents + dyn_i->pltoff_offset + 8);
3111
3112 /* Install dynamic relocations if needed. */
3113 if (!is_plt
0e1862bb 3114 && bfd_link_pic (info)
202e2356
NC		 3115 && (!dyn_i->h
3116 || ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
3117 || dyn_i->h->root.type != bfd_link_hash_undefweak))
3118 {
3119 /* VMS: */
3120 abort ();
3121 }
3122
3123 dyn_i->pltoff_done = 1;
3124 }
3125
3126 /* Return the descriptor's address. */
3127 value = (pltoff_sec->output_section->vma
3128 + pltoff_sec->output_offset
3129 + dyn_i->pltoff_offset);
3130
3131 return value;
3132}
3133
3134/* Called through qsort to sort the .IA_64.unwind section during a
3135 non-relocatable link. Set elf64_ia64_unwind_entry_compare_bfd
3136 to the output bfd so we can do proper endianness frobbing. */
3137
3138static bfd *elf64_ia64_unwind_entry_compare_bfd;
3139
3140static int
3141elf64_ia64_unwind_entry_compare (const void * a, const void * b)
3142{
3143 bfd_vma av, bv;
3144
3145 av = bfd_get_64 (elf64_ia64_unwind_entry_compare_bfd, a);
3146 bv = bfd_get_64 (elf64_ia64_unwind_entry_compare_bfd, b);
3147
3148 return (av < bv ? -1 : av > bv ? 1 : 0);
3149}
3150
3151/* Make sure we've got ourselves a nice fat __gp value. */
3152static bfd_boolean
3153elf64_ia64_choose_gp (bfd *abfd, struct bfd_link_info *info, bfd_boolean final)
3154{
3155 bfd_vma min_vma = (bfd_vma) -1, max_vma = 0;
3156 bfd_vma min_short_vma = min_vma, max_short_vma = 0;
3157 struct elf_link_hash_entry *gp;
3158 bfd_vma gp_val;
3159 asection *os;
3160 struct elf64_ia64_link_hash_table *ia64_info;
3161
3162 ia64_info = elf64_ia64_hash_table (info);
3163 if (ia64_info == NULL)
3164 return FALSE;
3165
3166 /* Find the min and max vma of all sections marked short. Also collect
3167 min and max vma of any type, for use in selecting a nice gp. */
3168 for (os = abfd->sections; os ; os = os->next)
3169 {
3170 bfd_vma lo, hi;
3171
3172 if ((os->flags & SEC_ALLOC) == 0)
3173 continue;
3174
3175 lo = os->vma;
3176 /* When this function is called from elfNN_ia64_final_link
3177 the correct value to use is os->size. When called from
3178 elfNN_ia64_relax_section we are in the middle of section
3179 sizing; some sections will already have os->size set, others
3180 will have os->size zero and os->rawsize the previous size. */
3181 hi = os->vma + (!final && os->rawsize ? os->rawsize : os->size);
3182 if (hi < lo)
3183 hi = (bfd_vma) -1;
3184
3185 if (min_vma > lo)
3186 min_vma = lo;
3187 if (max_vma < hi)
3188 max_vma = hi;
3189 if (os->flags & SEC_SMALL_DATA)
3190 {
3191 if (min_short_vma > lo)
3192 min_short_vma = lo;
3193 if (max_short_vma < hi)
3194 max_short_vma = hi;
3195 }
3196 }
3197
3198 if (ia64_info->min_short_sec)
3199 {
3200 if (min_short_vma
3201 > (ia64_info->min_short_sec->vma
3202 + ia64_info->min_short_offset))
3203 min_short_vma = (ia64_info->min_short_sec->vma
3204 + ia64_info->min_short_offset);
3205 if (max_short_vma
3206 < (ia64_info->max_short_sec->vma
3207 + ia64_info->max_short_offset))
3208 max_short_vma = (ia64_info->max_short_sec->vma
3209 + ia64_info->max_short_offset);
3210 }
3211
3212 /* See if the user wants to force a value. */
3213 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
3214 FALSE, FALSE);
3215
3216 if (gp
3217 && (gp->root.type == bfd_link_hash_defined
3218 || gp->root.type == bfd_link_hash_defweak))
3219 {
3220 asection *gp_sec = gp->root.u.def.section;
3221 gp_val = (gp->root.u.def.value
3222 + gp_sec->output_section->vma
3223 + gp_sec->output_offset);
3224 }
3225 else
3226 {
3227 /* Pick a sensible value. */
3228
3229 if (ia64_info->min_short_sec)
3230 {
3231 bfd_vma short_range = max_short_vma - min_short_vma;
3232
3233 /* If min_short_sec is set, pick one in the middle bewteen
3234 min_short_vma and max_short_vma. */
3235 if (short_range >= 0x400000)
3236 goto overflow;
3237 gp_val = min_short_vma + short_range / 2;
3238 }
3239 else
3240 {
3241 asection *got_sec = ia64_info->root.sgot;
3242
3243 /* Start with just the address of the .got. */
3244 if (got_sec)
3245 gp_val = got_sec->output_section->vma;
3246 else if (max_short_vma != 0)
3247 gp_val = min_short_vma;
3248 else if (max_vma - min_vma < 0x200000)
3249 gp_val = min_vma;
3250 else
3251 gp_val = max_vma - 0x200000 + 8;
3252 }
3253
3254 /* If it is possible to address the entire image, but we
3255 don't with the choice above, adjust. */
3256 if (max_vma - min_vma < 0x400000
3257 && (max_vma - gp_val >= 0x200000
3258 || gp_val - min_vma > 0x200000))
3259 gp_val = min_vma + 0x200000;
3260 else if (max_short_vma != 0)
3261 {
3262 /* If we don't cover all the short data, adjust. */
3263 if (max_short_vma - gp_val >= 0x200000)
3264 gp_val = min_short_vma + 0x200000;
3265
3266 /* If we're addressing stuff past the end, adjust back. */
3267 if (gp_val > max_vma)
3268 gp_val = max_vma - 0x200000 + 8;
3269 }
3270 }
3271
3272 /* Validate whether all SHF_IA_64_SHORT sections are within
3273 range of the chosen GP. */
3274
3275 if (max_short_vma != 0)
3276 {
3277 if (max_short_vma - min_short_vma >= 0x400000)
3278 {
3279overflow:
4eca0228 3280 _bfd_error_handler
695344c0 3281 /* xgettext:c-format */
dae82561
AM		 3282 (_("%B: short data segment overflowed (0x%lx >= 0x400000)"),
3283 abfd, (unsigned long) (max_short_vma - min_short_vma));
202e2356
NC		 3284 return FALSE;
3285 }
3286 else if ((gp_val > min_short_vma
3287 && gp_val - min_short_vma > 0x200000)
3288 || (gp_val < max_short_vma
3289 && max_short_vma - gp_val >= 0x200000))
3290 {
4eca0228 3291 _bfd_error_handler
dae82561 3292 (_("%B: __gp does not cover short data segment"), abfd);
202e2356
NC		 3293 return FALSE;
3294 }
3295 }
3296
3297 _bfd_set_gp_value (abfd, gp_val);
3298
3299 return TRUE;
3300}
3301
3302static bfd_boolean
3303elf64_ia64_final_link (bfd *abfd, struct bfd_link_info *info)
3304{
3305 struct elf64_ia64_link_hash_table *ia64_info;
3306 asection *unwind_output_sec;
3307
3308 ia64_info = elf64_ia64_hash_table (info);
3309 if (ia64_info == NULL)
3310 return FALSE;
3311
3312 /* Make sure we've got ourselves a nice fat __gp value. */
0e1862bb 3313 if (!bfd_link_relocatable (info))
202e2356
NC		 3314 {
3315 bfd_vma gp_val;
3316 struct elf_link_hash_entry *gp;
3317
3318 /* We assume after gp is set, section size will only decrease. We
3319 need to adjust gp for it. */
3320 _bfd_set_gp_value (abfd, 0);
3321 if (! elf64_ia64_choose_gp (abfd, info, TRUE))
3322 return FALSE;
3323 gp_val = _bfd_get_gp_value (abfd);
3324
3325 gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
3326 FALSE, FALSE);
3327 if (gp)
3328 {
3329 gp->root.type = bfd_link_hash_defined;
3330 gp->root.u.def.value = gp_val;
3331 gp->root.u.def.section = bfd_abs_section_ptr;
3332 }
3333 }
3334
3335 /* If we're producing a final executable, we need to sort the contents
3336 of the .IA_64.unwind section. Force this section to be relocated
3337 into memory rather than written immediately to the output file. */
3338 unwind_output_sec = NULL;
0e1862bb 3339 if (!bfd_link_relocatable (info))
202e2356
NC		 3340 {
3341 asection *s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind);
3342 if (s)
3343 {
3344 unwind_output_sec = s->output_section;
3345 unwind_output_sec->contents
3346 = bfd_malloc (unwind_output_sec->size);
3347 if (unwind_output_sec->contents == NULL)
3348 return FALSE;
3349 }
3350 }
3351
3352 /* Invoke the regular ELF backend linker to do all the work. */
3353 if (!bfd_elf_final_link (abfd, info))
3354 return FALSE;
3355
3356 if (unwind_output_sec)
3357 {
3358 elf64_ia64_unwind_entry_compare_bfd = abfd;
3359 qsort (unwind_output_sec->contents,
3360 (size_t) (unwind_output_sec->size / 24),
3361 24,
3362 elf64_ia64_unwind_entry_compare);
3363
3364 if (! bfd_set_section_contents (abfd, unwind_output_sec,
3365 unwind_output_sec->contents, (bfd_vma) 0,
3366 unwind_output_sec->size))
3367 return FALSE;
3368 }
3369
3370 return TRUE;
3371}
3372
3373static bfd_boolean
3374elf64_ia64_relocate_section (bfd *output_bfd,
3375 struct bfd_link_info *info,
3376 bfd *input_bfd,
3377 asection *input_section,
3378 bfd_byte *contents,
3379 Elf_Internal_Rela *relocs,
3380 Elf_Internal_Sym *local_syms,
3381 asection **local_sections)
3382{
3383 struct elf64_ia64_link_hash_table *ia64_info;
3384 Elf_Internal_Shdr *symtab_hdr;
3385 Elf_Internal_Rela *rel;
3386 Elf_Internal_Rela *relend;
3387 bfd_boolean ret_val = TRUE; /* for non-fatal errors */
3388 bfd_vma gp_val;
3389
3390 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3391 ia64_info = elf64_ia64_hash_table (info);
3392 if (ia64_info == NULL)
3393 return FALSE;
3394
3395 /* Infect various flags from the input section to the output section. */
0e1862bb 3396 if (bfd_link_relocatable (info))
202e2356
NC		 3397 {
3398 bfd_vma flags;
3399
3400 flags = elf_section_data(input_section)->this_hdr.sh_flags;
3401 flags &= SHF_IA_64_NORECOV;
3402
3403 elf_section_data(input_section->output_section)
3404 ->this_hdr.sh_flags |= flags;
3405 }
3406
3407 gp_val = _bfd_get_gp_value (output_bfd);
3408
3409 rel = relocs;
3410 relend = relocs + input_section->reloc_count;
3411 for (; rel < relend; ++rel)
3412 {
3413 struct elf_link_hash_entry *h;
3414 struct elf64_ia64_dyn_sym_info *dyn_i;
3415 bfd_reloc_status_type r;
3416 reloc_howto_type *howto;
3417 unsigned long r_symndx;
3418 Elf_Internal_Sym *sym;
3419 unsigned int r_type;
3420 bfd_vma value;
3421 asection *sym_sec;
3422 bfd_byte *hit_addr;
3423 bfd_boolean dynamic_symbol_p;
3424 bfd_boolean undef_weak_ref;
3425
3426 r_type = ELF64_R_TYPE (rel->r_info);
3427 if (r_type > R_IA64_MAX_RELOC_CODE)
3428 {
4eca0228 3429 _bfd_error_handler
695344c0 3430 /* xgettext:c-format */
202e2356
NC		 3431 (_("%B: unknown relocation type %d"),
3432 input_bfd, (int) r_type);
3433 bfd_set_error (bfd_error_bad_value);
3434 ret_val = FALSE;
3435 continue;
3436 }
3437
3438 howto = ia64_elf_lookup_howto (r_type);
3439 r_symndx = ELF64_R_SYM (rel->r_info);
3440 h = NULL;
3441 sym = NULL;
3442 sym_sec = NULL;
3443 undef_weak_ref = FALSE;
3444
3445 if (r_symndx < symtab_hdr->sh_info)
3446 {
3447 /* Reloc against local symbol. */
3448 asection *msec;
3449 sym = local_syms + r_symndx;
3450 sym_sec = local_sections[r_symndx];
3451 msec = sym_sec;
3452 value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
0e1862bb 3453 if (!bfd_link_relocatable (info)
202e2356
NC		 3454 && (sym_sec->flags & SEC_MERGE) != 0
3455 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
dbaa2011 3456 && sym_sec->sec_info_type == SEC_INFO_TYPE_MERGE)
202e2356
NC		 3457 {
3458 struct elf64_ia64_local_hash_entry *loc_h;
3459
3460 loc_h = get_local_sym_hash (ia64_info, input_bfd, rel, FALSE);
3461 if (loc_h && ! loc_h->sec_merge_done)
3462 {
3463 struct elf64_ia64_dyn_sym_info *dynent;
3464 unsigned int count;
3465
3466 for (count = loc_h->count, dynent = loc_h->info;
3467 count != 0;
3468 count--, dynent++)
3469 {
3470 msec = sym_sec;
3471 dynent->addend =
3472 _bfd_merged_section_offset (output_bfd, &msec,
3473 elf_section_data (msec)->
3474 sec_info,
3475 sym->st_value
3476 + dynent->addend);
3477 dynent->addend -= sym->st_value;
3478 dynent->addend += msec->output_section->vma
3479 + msec->output_offset
3480 - sym_sec->output_section->vma
3481 - sym_sec->output_offset;
3482 }
3483
3484 /* We may have introduced duplicated entries. We need
3485 to remove them properly. */
3486 count = sort_dyn_sym_info (loc_h->info, loc_h->count);
3487 if (count != loc_h->count)
3488 {
3489 loc_h->count = count;
3490 loc_h->sorted_count = count;
3491 }
3492
3493 loc_h->sec_merge_done = 1;
3494 }
3495 }
3496 }
3497 else
3498 {
3499 bfd_boolean unresolved_reloc;
62d887d4 3500 bfd_boolean warned, ignored;
202e2356
NC		 3501 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
3502
3503 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3504 r_symndx, symtab_hdr, sym_hashes,
3505 h, sym_sec, value,
62d887d4 3506 unresolved_reloc, warned, ignored);
202e2356
NC		 3507
3508 if (h->root.type == bfd_link_hash_undefweak)
3509 undef_weak_ref = TRUE;
3510 else if (warned)
3511 continue;
3512 }
3513
3514 /* For relocs against symbols from removed linkonce sections,
3515 or sections discarded by a linker script, we just want the
3516 section contents zeroed. Avoid any special processing. */
dbaa2011 3517 if (sym_sec != NULL && discarded_section (sym_sec))
202e2356 3518 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2de5d135 3519 rel, 1, relend, howto, 0, contents);
202e2356 3520
0e1862bb 3521 if (bfd_link_relocatable (info))
202e2356
NC		 3522 continue;
3523
3524 hit_addr = contents + rel->r_offset;
3525 value += rel->r_addend;
3526 dynamic_symbol_p = elf64_ia64_dynamic_symbol_p (h);
3527
3528 switch (r_type)
3529 {
3530 case R_IA64_NONE:
3531 case R_IA64_LDXMOV:
3532 continue;
3533
3534 case R_IA64_IMM14:
3535 case R_IA64_IMM22:
3536 case R_IA64_IMM64:
3537 case R_IA64_DIR32MSB:
3538 case R_IA64_DIR32LSB:
3539 case R_IA64_DIR64MSB:
3540 case R_IA64_DIR64LSB:
3541 /* Install a dynamic relocation for this reloc. */
0e1862bb 3542 if ((dynamic_symbol_p || bfd_link_pic (info))
202e2356
NC		 3543 && r_symndx != 0
3544 && (input_section->flags & SEC_ALLOC) != 0)
3545 {
3546 unsigned int dyn_r_type;
3547 bfd_vma addend;
3548
3549 switch (r_type)
3550 {
3551 case R_IA64_IMM14:
3552 case R_IA64_IMM22:
3553 case R_IA64_IMM64:
3554 /* ??? People shouldn't be doing non-pic code in
3555 shared libraries nor dynamic executables. */
4eca0228 3556 _bfd_error_handler
695344c0 3557 /* xgettext:c-format */
202e2356
NC		 3558 (_("%B: non-pic code with imm relocation against dynamic symbol `%s'"),
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
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;
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 */
202e2356
NC		 3621 (_("%B: @gprel relocation against dynamic symbol %s"),
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:
3636 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
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:
3647 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
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:
3658 dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
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
202e2356
NC		 3680 (_("%B: linking non-pic code in a position independent executable"),
3681 input_bfd);
3682 ret_val = FALSE;
3683 continue;
3684 }
3685 }
3686 else
3687 {
3688 value = 0;
3689 }
3690
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;
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:
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);
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 {
3731 /* VMS: doesn't exist ??? */
3732 abort ();
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 */
202e2356
NC		 3782 msg = _("%B: @internal branch to dynamic symbol %s");
3783 else if (r_type == R_IA64_PCREL21F || r_type == R_IA64_PCREL21M)
695344c0 3784 /* xgettext:c-format */
202e2356
NC		 3785 msg = _("%B: speculation fixup to dynamic symbol %s");
3786 else
695344c0 3787 /* xgettext:c-format */
202e2356 3788 msg = _("%B: @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 {
3851 /* VMS: FIXFD ?? */
3852 abort ();
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 */
c08bb8dd
AM		 3949 (_("%B: missing TLS section for relocation %s against `%s'"
3950 " at 0x%lx in section `%A'."),
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 */
c08bb8dd
AM		 3966 (_("%B: Can't relax br (%s) to `%s' at 0x%lx in section"
3967 " `%A' with size 0x%lx (> 0x1000000)."),
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
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);
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
4087 (info->output_bfd, ia64_info->pltoff_sec->output_section);
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)
4095 {
4096 asection *code_sec;
4097
4098 phdr = _bfd_elf_find_segment_containing_section (abfd, unwind_sec);
4099 BFD_ASSERT (phdr != NULL);
4100 unwind_seg = phdr - base_phdr;
4101
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 }
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 {
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;
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
4171 + tfr_sec->output_offset
4172 + 6 * 8, tfr->tfradr3);
4173
4174 tfr3 = elf_link_hash_lookup (elf_hash_table (info), "ELF$TFRADR", FALSE,
4175 FALSE, FALSE);
4176
4177 if (tfr3
4178 && (tfr3->root.type == bfd_link_hash_defined
4179 || tfr3->root.type == bfd_link_hash_defweak))
4180 {
4181 asection *tfr3_sec = tfr3->root.u.def.section;
4182 bfd_vma tfr3_val;
4183
4184 tfr3_val = (tfr3->root.u.def.value
4185 + tfr3_sec->output_section->vma
4186 + tfr3_sec->output_offset);
4187
4188 bfd_putl64 (tfr3_val, tfr->tfr3_func);
4189 bfd_putl64 (_bfd_get_gp_value (info->output_bfd), tfr->tfr3_gp);
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
202e2356
NC		 4257 (_("%B: linking trap-on-NULL-dereference with non-trapping files"),
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
202e2356
NC		 4266 (_("%B: linking big-endian files with little-endian files"),
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
202e2356
NC		 4275 (_("%B: linking 64-bit files with 32-bit files"),
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
202e2356
NC		 4284 (_("%B: linking constant-gp files with non-constant-gp files"),
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
202e2356
NC		 4294 (_("%B: linking auto-pic files with non-auto-pic files"),
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{
4350 { STRING_COMMA_LEN (".sbss"), -1, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
4351 { STRING_COMMA_LEN (".sdata"), -1, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
4352 { NULL, 0, 0, 0, 0 }
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
4489 (abfd, newsect, bfd_get_section_flags (abfd, newsect) | secflags))
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. */
4666 hdr->sh_info = unwind_info_sect_idx;
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);
4714 bfd_uint64_t pad = 0;
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))
4798 goto error_return;
4799
4800 s = bfd_get_section_by_name (abfd, ".dynamic");
4801 if (s == NULL)
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 }
4829
4830 /* Extract IDENT. */
4831 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
4832 {
4833error_free_dyn:
4834 free (dynbuf);
4835 goto error_return;
4836 }
4837
4838 for (extdyn = dynbuf;
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 }
4852 if (extdyn >= dynbuf + s->size)
4853 {
4854 /* Ident not found. */
4855 goto error_free_dyn;
4856 }
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 ?
4869 This should be harmless and shouldn't happen in practice. */
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))
5013 h = elf_link_hash_lookup (htab, name, TRUE, FALSE, FALSE);
5014 else
5015 h = ((struct elf_link_hash_entry *) bfd_wrapped_link_hash_lookup
5016 (abfd, info, name, TRUE, FALSE, FALSE));
5017 if (h == NULL)
5018 goto error_free_sym;
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:
5040 if (abfd->selective_search)
5041 continue;
5042 /* Fall-through. */
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 */
202e2356
NC		 5137 (_("Warning: alignment %u of common symbol `%s' in %B"
5138 " is greater than the alignment (%u) of its section %A"),
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 */
202e2356
NC		 5144 (_("Warning: alignment %u of symbol `%s' in %B"
5145 " is smaller than %u in %B"),
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
NC		 5160 (_("Warning: size of symbol `%s' changed"
5161 " from %lu in %B to %lu in %B"),
c08bb8dd
AM		 5162 name, (unsigned long) h->size, old_bfd,
5163 (unsigned long) isym->st_size, abfd);
202e2356
NC		 5164
5165 h->size = isym->st_size;
5166 }
5167
5168 /* If this is a common symbol, then we always want H->SIZE
5169 to be the size of the common symbol. The code just above
5170 won't fix the size if a common symbol becomes larger. We
5171 don't warn about a size change here, because that is
5172 covered by --warn-common. Allow changed between different
5173 function types. */
5174 if (h->root.type == bfd_link_hash_common)
5175 h->size = h->root.u.c.size;
5176
5177 if (ELF_ST_TYPE (isym->st_info) != STT_NOTYPE
5178 && (definition || h->type == STT_NOTYPE))
5179 {
5180 unsigned int type = ELF_ST_TYPE (isym->st_info);
5181
5182 if (h->type != type)
5183 {
5184 if (h->type != STT_NOTYPE && ! type_change_ok)
4eca0228 5185 _bfd_error_handler
695344c0 5186 /* xgettext:c-format */
202e2356
NC		 5187 (_("Warning: type of symbol `%s' changed"
5188 " from %d to %d in %B"),
c08bb8dd 5189 name, h->type, type, abfd);
202e2356
NC		 5190
5191 h->type = type;
5192 }
5193 }
5194
5195 /* Set a flag in the hash table entry indicating the type of
5196 reference or definition we just found. Keep a count of
5197 the number of dynamic symbols we find. A dynamic symbol
5198 is one which is referenced or defined by both a regular
5199 object and a shared object. */
5200 if (! dynamic)
5201 {
5202 if (! definition)
5203 {
5204 h->ref_regular = 1;
5205 if (bind != STB_WEAK)
5206 h->ref_regular_nonweak = 1;
5207 }
5208 else
5209 {
5210 BFD_ASSERT (!h->def_dynamic);
5211 h->def_regular = 1;
5212 }
5213 }
5214 else
5215 {
5216 BFD_ASSERT (definition);
5217 h->def_dynamic = 1;
5218 h->dynindx = -2;
5219 ((struct elf64_ia64_link_hash_entry *)h)->shl = abfd;
5220 }
5221 }
5222 }
5223
5224 if (isymbuf != NULL)
5225 {
5226 free (isymbuf);
5227 isymbuf = NULL;
5228 }
5229
5230 /* If this object is the same format as the output object, and it is
5231 not a shared library, then let the backend look through the
5232 relocs.
5233
5234 This is required to build global offset table entries and to
5235 arrange for dynamic relocs. It is not required for the
5236 particular common case of linking non PIC code, even when linking
5237 against shared libraries, but unfortunately there is no way of
5238 knowing whether an object file has been compiled PIC or not.
5239 Looking through the relocs is not particularly time consuming.
5240 The problem is that we must either (1) keep the relocs in memory,
5241 which causes the linker to require additional runtime memory or
5242 (2) read the relocs twice from the input file, which wastes time.
5243 This would be a good case for using mmap.
5244
5245 I have no idea how to handle linking PIC code into a file of a
5246 different format. It probably can't be done. */
5247 if (! dynamic
5248 && is_elf_hash_table (htab)
5249 && bed->check_relocs != NULL
5250 && (*bed->relocs_compatible) (abfd->xvec, info->output_bfd->xvec))
5251 {
5252 asection *o;
5253
5254 for (o = abfd->sections; o != NULL; o = o->next)
5255 {
5256 Elf_Internal_Rela *internal_relocs;
5257 bfd_boolean ok;
5258
5259 if ((o->flags & SEC_RELOC) == 0
5260 || o->reloc_count == 0
5261 || ((info->strip == strip_all || info->strip == strip_debugger)
5262 && (o->flags & SEC_DEBUGGING) != 0)
5263 || bfd_is_abs_section (o->output_section))
5264 continue;
5265
5266 internal_relocs = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL,
5267 info->keep_memory);
5268 if (internal_relocs == NULL)
5269 goto error_return;
5270
5271 ok = (*bed->check_relocs) (abfd, info, o, internal_relocs);
5272
5273 if (elf_section_data (o)->relocs != internal_relocs)
5274 free (internal_relocs);
5275
5276 if (! ok)
5277 goto error_return;
5278 }
5279 }
5280
5281 return TRUE;
5282
5283 error_free_vers:
5284 error_free_sym:
5285 if (isymbuf != NULL)
5286 free (isymbuf);
5287 error_return:
5288 return FALSE;
5289}
5290
5291static bfd_boolean
5292elf64_vms_link_add_archive_symbols (bfd *abfd, struct bfd_link_info *info)
5293{
5294 int pass;
5295 struct bfd_link_hash_entry **pundef;
5296 struct bfd_link_hash_entry **next_pundef;
5297
5298 /* We only accept VMS libraries. */
5299 if (info->output_bfd->xvec != abfd->xvec)
5300 {
5301 bfd_set_error (bfd_error_wrong_format);
5302 return FALSE;
5303 }
5304
5305 /* The archive_pass field in the archive itself is used to
5306 initialize PASS, since we may search the same archive multiple
5307 times. */
5308 pass = ++abfd->archive_pass;
5309
5310 /* Look through the list of undefined symbols. */
5311 for (pundef = &info->hash->undefs; *pundef != NULL; pundef = next_pundef)
5312 {
5313 struct bfd_link_hash_entry *h;
5314 symindex symidx;
5315 bfd *element;
5316 bfd *orig_element;
5317
5318 h = *pundef;
5319 next_pundef = &(*pundef)->u.undef.next;
5320
5321 /* When a symbol is defined, it is not necessarily removed from
5322 the list. */
5323 if (h->type != bfd_link_hash_undefined
5324 && h->type != bfd_link_hash_common)
5325 {
5326 /* Remove this entry from the list, for general cleanliness
5327 and because we are going to look through the list again
5328 if we search any more libraries. We can't remove the
5329 entry if it is the tail, because that would lose any
5330 entries we add to the list later on. */
5331 if (*pundef != info->hash->undefs_tail)
5332 {
5333 *pundef = *next_pundef;
5334 next_pundef = pundef;
5335 }
5336 continue;
5337 }
5338
5339 /* Look for this symbol in the archive hash table. */
5340 symidx = _bfd_vms_lib_find_symbol (abfd, h->root.string);
5341 if (symidx == BFD_NO_MORE_SYMBOLS)
5342 {
5343 /* Nothing in this slot. */
5344 continue;
5345 }
5346
5347 element = bfd_get_elt_at_index (abfd, symidx);
5348 if (element == NULL)
5349 return FALSE;
5350
5351 if (element->archive_pass == -1 || element->archive_pass == pass)
5352 {
5353 /* Next symbol if this archive is wrong or already handled. */
5354 continue;
5355 }
5356
5357 orig_element = element;
5358 if (bfd_is_thin_archive (abfd))
5359 {
5360 element = _bfd_vms_lib_get_imagelib_file (element);
5361 if (element == NULL || !bfd_check_format (element, bfd_object))
5362 {
5363 orig_element->archive_pass = -1;
5364 return FALSE;
5365 }
5366 }
5367 else if (! bfd_check_format (element, bfd_object))
5368 {
5369 element->archive_pass = -1;
5370 return FALSE;
5371 }
5372
5373 /* Unlike the generic linker, we know that this element provides
5374 a definition for an undefined symbol and we know that we want
5375 to include it. We don't need to check anything. */
5376 if (! (*info->callbacks->add_archive_element) (info, element,
5377 h->root.string, &element))
b95a0a31 5378 continue;
202e2356
NC		 5379 if (! elf64_vms_link_add_object_symbols (element, info))
5380 return FALSE;
5381
5382 orig_element->archive_pass = pass;
5383 }
5384
5385 return TRUE;
5386}
5387
5388static bfd_boolean
5389elf64_vms_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
5390{
5391 switch (bfd_get_format (abfd))
5392 {
5393 case bfd_object:
5394 return elf64_vms_link_add_object_symbols (abfd, info);
5395 break;
5396 case bfd_archive:
5397 return elf64_vms_link_add_archive_symbols (abfd, info);
5398 break;
5399 default:
5400 bfd_set_error (bfd_error_wrong_format);
5401 return FALSE;
5402 }
5403}
5404
5405static bfd_boolean
5406elf64_ia64_vms_mkobject (bfd *abfd)
5407{
5408 return bfd_elf_allocate_object
5409 (abfd, sizeof (struct elf64_ia64_vms_obj_tdata), IA64_ELF_DATA);
5410}
5411
5412
5413/* Size-dependent data and functions. */
5414static const struct elf_size_info elf64_ia64_vms_size_info = {
5415 sizeof (Elf64_External_VMS_Ehdr),
5416 sizeof (Elf64_External_Phdr),
5417 sizeof (Elf64_External_Shdr),
5418 sizeof (Elf64_External_Rel),
5419 sizeof (Elf64_External_Rela),
5420 sizeof (Elf64_External_Sym),
5421 sizeof (Elf64_External_Dyn),
5422 sizeof (Elf_External_Note),
5423 4,
5424 1,
5425 64, 3, /* ARCH_SIZE, LOG_FILE_ALIGN */
5426 ELFCLASS64, EV_CURRENT,
5427 bfd_elf64_write_out_phdrs,
5428 elf64_vms_write_shdrs_and_ehdr,
5429 bfd_elf64_checksum_contents,
5430 bfd_elf64_write_relocs,
5431 bfd_elf64_swap_symbol_in,
5432 bfd_elf64_swap_symbol_out,
5433 bfd_elf64_slurp_reloc_table,
5434 bfd_elf64_slurp_symbol_table,
5435 bfd_elf64_swap_dyn_in,
5436 bfd_elf64_swap_dyn_out,
5437 bfd_elf64_swap_reloc_in,
5438 bfd_elf64_swap_reloc_out,
5439 bfd_elf64_swap_reloca_in,
5440 bfd_elf64_swap_reloca_out
5441};
5442
5443#define ELF_ARCH bfd_arch_ia64
5444#define ELF_MACHINE_CODE EM_IA_64
5445#define ELF_MAXPAGESIZE 0x10000 /* 64KB */
5446#define ELF_COMMONPAGESIZE 0x200 /* 16KB */
5447
5448#define elf_backend_section_from_shdr \
5449 elf64_ia64_section_from_shdr
5450#define elf_backend_section_flags \
5451 elf64_ia64_section_flags
5452#define elf_backend_fake_sections \
5453 elf64_ia64_fake_sections
5454#define elf_backend_final_write_processing \
5455 elf64_ia64_final_write_processing
5456#define elf_backend_add_symbol_hook \
5457 elf64_ia64_add_symbol_hook
5458#define elf_info_to_howto \
5459 elf64_ia64_info_to_howto
5460
5461#define bfd_elf64_bfd_reloc_type_lookup \
5462 ia64_elf_reloc_type_lookup
5463#define bfd_elf64_bfd_reloc_name_lookup \
5464 ia64_elf_reloc_name_lookup
5465#define bfd_elf64_bfd_is_local_label_name \
5466 elf64_ia64_is_local_label_name
5467#define bfd_elf64_bfd_relax_section \
5468 elf64_ia64_relax_section
5469
5470#define elf_backend_object_p \
5471 elf64_ia64_object_p
5472
5473/* Stuff for the BFD linker: */
5474#define bfd_elf64_bfd_link_hash_table_create \
5475 elf64_ia64_hash_table_create
202e2356
NC		 5476#define elf_backend_create_dynamic_sections \
5477 elf64_ia64_create_dynamic_sections
5478#define elf_backend_check_relocs \
5479 elf64_ia64_check_relocs
5480#define elf_backend_adjust_dynamic_symbol \
5481 elf64_ia64_adjust_dynamic_symbol
5482#define elf_backend_size_dynamic_sections \
5483 elf64_ia64_size_dynamic_sections
5484#define elf_backend_omit_section_dynsym \
5485 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5486#define elf_backend_relocate_section \
5487 elf64_ia64_relocate_section
5488#define elf_backend_finish_dynamic_symbol \
5489 elf64_ia64_finish_dynamic_symbol
5490#define elf_backend_finish_dynamic_sections \
5491 elf64_ia64_finish_dynamic_sections
5492#define bfd_elf64_bfd_final_link \
5493 elf64_ia64_final_link
5494
5495#define bfd_elf64_bfd_merge_private_bfd_data \
5496 elf64_ia64_merge_private_bfd_data
5497#define bfd_elf64_bfd_set_private_flags \
5498 elf64_ia64_set_private_flags
5499#define bfd_elf64_bfd_print_private_bfd_data \
5500 elf64_ia64_print_private_bfd_data
5501
5502#define elf_backend_plt_readonly 1
5503#define elf_backend_want_plt_sym 0
5504#define elf_backend_plt_alignment 5
5505#define elf_backend_got_header_size 0
5506#define elf_backend_want_got_plt 1
5507#define elf_backend_may_use_rel_p 1
5508#define elf_backend_may_use_rela_p 1
5509#define elf_backend_default_use_rela_p 1
5510#define elf_backend_want_dynbss 0
5511#define elf_backend_hide_symbol elf64_ia64_hash_hide_symbol
5512#define elf_backend_fixup_symbol _bfd_elf_link_hash_fixup_symbol
5513#define elf_backend_reloc_type_class elf64_ia64_reloc_type_class
5514#define elf_backend_rela_normal 1
5515#define elf_backend_special_sections elf64_ia64_special_sections
5516#define elf_backend_default_execstack 0
5517
5518/* FIXME: PR 290: The Intel C compiler generates SHT_IA_64_UNWIND with
5519 SHF_LINK_ORDER. But it doesn't set the sh_link or sh_info fields.
5520 We don't want to flood users with so many error messages. We turn
5521 off the warning for now. It will be turned on later when the Intel
5522 compiler is fixed. */
5523#define elf_backend_link_order_error_handler NULL
5524
5525/* VMS-specific vectors. */
5526
5527#undef TARGET_LITTLE_SYM
6d00b590 5528#define TARGET_LITTLE_SYM ia64_elf64_vms_vec
202e2356
NC		 5529#undef TARGET_LITTLE_NAME
5530#define TARGET_LITTLE_NAME "elf64-ia64-vms"
5531#undef TARGET_BIG_SYM
5532#undef TARGET_BIG_NAME
5533
5534/* These are VMS specific functions. */
5535
5536#undef elf_backend_object_p
5537#define elf_backend_object_p elf64_vms_object_p
5538
5539#undef elf_backend_section_from_shdr
5540#define elf_backend_section_from_shdr elf64_vms_section_from_shdr
5541
5542#undef elf_backend_post_process_headers
5543#define elf_backend_post_process_headers elf64_vms_post_process_headers
5544
5545#undef elf_backend_section_processing
5546#define elf_backend_section_processing elf64_vms_section_processing
5547
5548#undef elf_backend_final_write_processing
5549#define elf_backend_final_write_processing elf64_vms_final_write_processing
5550
5551#undef bfd_elf64_close_and_cleanup
5552#define bfd_elf64_close_and_cleanup elf64_vms_close_and_cleanup
5553
5554#undef elf_backend_section_from_bfd_section
5555
5556#undef elf_backend_symbol_processing
5557
5558#undef elf_backend_want_p_paddr_set_to_zero
5559
5560#undef ELF_OSABI
5561#define ELF_OSABI ELFOSABI_OPENVMS
5562
5563#undef ELF_MAXPAGESIZE
5564#define ELF_MAXPAGESIZE 0x10000 /* 64KB */
5565
5566#undef elf64_bed
5567#define elf64_bed elf64_ia64_vms_bed
5568
5569#define elf_backend_size_info elf64_ia64_vms_size_info
5570
5571/* Use VMS-style archives (in particular, don't use the standard coff
5572 archive format). */
5573#define bfd_elf64_archive_functions
5574
5575#undef bfd_elf64_archive_p
5576#define bfd_elf64_archive_p _bfd_vms_lib_ia64_archive_p
5577#undef bfd_elf64_write_archive_contents
5578#define bfd_elf64_write_archive_contents _bfd_vms_lib_write_archive_contents
5579#undef bfd_elf64_mkarchive
5580#define bfd_elf64_mkarchive _bfd_vms_lib_ia64_mkarchive
5581
5582#define bfd_elf64_archive_slurp_armap \
5583 _bfd_vms_lib_slurp_armap
5584#define bfd_elf64_archive_slurp_extended_name_table \
5585 _bfd_vms_lib_slurp_extended_name_table
5586#define bfd_elf64_archive_construct_extended_name_table \
5587 _bfd_vms_lib_construct_extended_name_table
5588#define bfd_elf64_archive_truncate_arname \
5589 _bfd_vms_lib_truncate_arname
5590#define bfd_elf64_archive_write_armap \
5591 _bfd_vms_lib_write_armap
5592#define bfd_elf64_archive_read_ar_hdr \
5593 _bfd_vms_lib_read_ar_hdr
5594#define bfd_elf64_archive_write_ar_hdr \
5595 _bfd_vms_lib_write_ar_hdr
5596#define bfd_elf64_archive_openr_next_archived_file \
5597 _bfd_vms_lib_openr_next_archived_file
5598#define bfd_elf64_archive_get_elt_at_index \
5599 _bfd_vms_lib_get_elt_at_index
5600#define bfd_elf64_archive_generic_stat_arch_elt \
5601 _bfd_vms_lib_generic_stat_arch_elt
5602#define bfd_elf64_archive_update_armap_timestamp \
5603 _bfd_vms_lib_update_armap_timestamp
5604
5605/* VMS link methods. */
5606#undef bfd_elf64_bfd_link_add_symbols
5607#define bfd_elf64_bfd_link_add_symbols elf64_vms_bfd_link_add_symbols
5608
5609#undef elf_backend_want_got_sym
5610#define elf_backend_want_got_sym 0
5611
5612#undef bfd_elf64_mkobject
5613#define bfd_elf64_mkobject elf64_ia64_vms_mkobject
5614
5615/* Redefine to align segments on block size. */
5616#undef ELF_MAXPAGESIZE
5617#define ELF_MAXPAGESIZE 0x200 /* 512B */
5618
5619#undef elf_backend_want_got_plt
5620#define elf_backend_want_got_plt 0
5621
5622#include "elf64-target.h"
GDB Binutils - Deliverables
This page took 0.472306 seconds and 4 git commands to generate.