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