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