Automatic date update in version.in
[external/binutils.git] / bfd / elfnn-ia64.c
1 /* IA-64 support for 64-bit ELF
2    Copyright (C) 1998-2019 Free Software Foundation, Inc.
3    Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
4
5    This file is part of BFD, the Binary File Descriptor library.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20    MA 02110-1301, USA.  */
21
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "libbfd.h"
25 #include "elf-bfd.h"
26 #include "opcode/ia64.h"
27 #include "elf/ia64.h"
28 #include "objalloc.h"
29 #include "hashtab.h"
30 #include "elfxx-ia64.h"
31
32 #define ARCH_SIZE       NN
33
34 #if ARCH_SIZE == 64
35 #define LOG_SECTION_ALIGN       3
36 #endif
37
38 #if ARCH_SIZE == 32
39 #define LOG_SECTION_ALIGN       2
40 #endif
41
42 typedef struct bfd_hash_entry *(*new_hash_entry_func)
43   (struct bfd_hash_entry *, struct bfd_hash_table *, const char *);
44
45 /* In dynamically (linker-) created sections, we generally need to keep track
46    of the place a symbol or expression got allocated to. This is done via hash
47    tables that store entries of the following type.  */
48
49 struct elfNN_ia64_dyn_sym_info
50 {
51   /* The addend for which this entry is relevant.  */
52   bfd_vma addend;
53
54   bfd_vma got_offset;
55   bfd_vma fptr_offset;
56   bfd_vma pltoff_offset;
57   bfd_vma plt_offset;
58   bfd_vma plt2_offset;
59   bfd_vma tprel_offset;
60   bfd_vma dtpmod_offset;
61   bfd_vma dtprel_offset;
62
63   /* The symbol table entry, if any, that this was derived from.  */
64   struct elf_link_hash_entry *h;
65
66   /* Used to count non-got, non-plt relocations for delayed sizing
67      of relocation sections.  */
68   struct elfNN_ia64_dyn_reloc_entry
69   {
70     struct elfNN_ia64_dyn_reloc_entry *next;
71     asection *srel;
72     int type;
73     int count;
74
75     /* Is this reloc against readonly section? */
76     bfd_boolean reltext;
77   } *reloc_entries;
78
79   /* TRUE when the section contents have been updated.  */
80   unsigned got_done : 1;
81   unsigned fptr_done : 1;
82   unsigned pltoff_done : 1;
83   unsigned tprel_done : 1;
84   unsigned dtpmod_done : 1;
85   unsigned dtprel_done : 1;
86
87   /* TRUE for the different kinds of linker data we want created.  */
88   unsigned want_got : 1;
89   unsigned want_gotx : 1;
90   unsigned want_fptr : 1;
91   unsigned want_ltoff_fptr : 1;
92   unsigned want_plt : 1;
93   unsigned want_plt2 : 1;
94   unsigned want_pltoff : 1;
95   unsigned want_tprel : 1;
96   unsigned want_dtpmod : 1;
97   unsigned want_dtprel : 1;
98 };
99
100 struct elfNN_ia64_local_hash_entry
101 {
102   int id;
103   unsigned int r_sym;
104   /* The number of elements in elfNN_ia64_dyn_sym_info array.  */
105   unsigned int count;
106   /* The number of sorted elements in elfNN_ia64_dyn_sym_info array.  */
107   unsigned int sorted_count;
108   /* The size of elfNN_ia64_dyn_sym_info array.  */
109   unsigned int size;
110   /* The array of elfNN_ia64_dyn_sym_info.  */
111   struct elfNN_ia64_dyn_sym_info *info;
112
113   /* TRUE if this hash entry's addends was translated for
114      SHF_MERGE optimization.  */
115   unsigned sec_merge_done : 1;
116 };
117
118 struct elfNN_ia64_link_hash_entry
119 {
120   struct elf_link_hash_entry root;
121   /* The number of elements in elfNN_ia64_dyn_sym_info array.  */
122   unsigned int count;
123   /* The number of sorted elements in elfNN_ia64_dyn_sym_info array.  */
124   unsigned int sorted_count;
125   /* The size of elfNN_ia64_dyn_sym_info array.  */
126   unsigned int size;
127   /* The array of elfNN_ia64_dyn_sym_info.  */
128   struct elfNN_ia64_dyn_sym_info *info;
129 };
130
131 struct elfNN_ia64_link_hash_table
132 {
133   /* The main hash table.  */
134   struct elf_link_hash_table root;
135
136   asection *fptr_sec;           /* Function descriptor table (or NULL).  */
137   asection *rel_fptr_sec;       /* Dynamic relocation section for same.  */
138   asection *pltoff_sec;         /* Private descriptors for plt (or NULL).  */
139   asection *rel_pltoff_sec;     /* Dynamic relocation section for same.  */
140
141   bfd_size_type minplt_entries; /* Number of minplt entries.  */
142   unsigned reltext : 1;         /* Are there relocs against readonly sections?  */
143   unsigned self_dtpmod_done : 1;/* Has self DTPMOD entry been finished?  */
144   bfd_vma self_dtpmod_offset;   /* .got offset to self DTPMOD entry.  */
145   /* There are maybe R_IA64_GPREL22 relocations, including those
146      optimized from R_IA64_LTOFF22X, against non-SHF_IA_64_SHORT
147      sections.  We need to record those sections so that we can choose
148      a proper GP to cover all R_IA64_GPREL22 relocations.  */
149   asection *max_short_sec;      /* Maximum short output section.  */
150   bfd_vma max_short_offset;     /* Maximum short offset.  */
151   asection *min_short_sec;      /* Minimum short output section.  */
152   bfd_vma min_short_offset;     /* Minimum short offset.  */
153
154   htab_t loc_hash_table;
155   void *loc_hash_memory;
156 };
157
158 struct elfNN_ia64_allocate_data
159 {
160   struct bfd_link_info *info;
161   bfd_size_type ofs;
162   bfd_boolean only_got;
163 };
164
165 #define elfNN_ia64_hash_table(p) \
166   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
167   == IA64_ELF_DATA ? ((struct elfNN_ia64_link_hash_table *) ((p)->hash)) : NULL)
168
169 static struct elfNN_ia64_dyn_sym_info * get_dyn_sym_info
170   (struct elfNN_ia64_link_hash_table *ia64_info,
171    struct elf_link_hash_entry *h,
172    bfd *abfd, const Elf_Internal_Rela *rel, bfd_boolean create);
173 static bfd_boolean elfNN_ia64_dynamic_symbol_p
174   (struct elf_link_hash_entry *h, struct bfd_link_info *info, int);
175 static bfd_boolean elfNN_ia64_choose_gp
176   (bfd *abfd, struct bfd_link_info *info, bfd_boolean final);
177 static void elfNN_ia64_dyn_sym_traverse
178   (struct elfNN_ia64_link_hash_table *ia64_info,
179    bfd_boolean (*func) (struct elfNN_ia64_dyn_sym_info *, void *),
180    void * info);
181 static bfd_boolean allocate_global_data_got
182   (struct elfNN_ia64_dyn_sym_info *dyn_i, void * data);
183 static bfd_boolean allocate_global_fptr_got
184   (struct elfNN_ia64_dyn_sym_info *dyn_i, void * data);
185 static bfd_boolean allocate_local_got
186   (struct elfNN_ia64_dyn_sym_info *dyn_i, void * data);
187 static bfd_boolean elfNN_ia64_hpux_vec
188   (const bfd_target *vec);
189 static bfd_boolean allocate_dynrel_entries
190   (struct elfNN_ia64_dyn_sym_info *dyn_i, void * data);
191 static asection *get_pltoff
192   (bfd *abfd, struct bfd_link_info *info,
193    struct elfNN_ia64_link_hash_table *ia64_info);
194 \f
195 /* ia64-specific relocation.  */
196
197 /* Given a ELF reloc, return the matching HOWTO structure.  */
198
199 static bfd_boolean
200 elfNN_ia64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
201                           arelent *bfd_reloc,
202                           Elf_Internal_Rela *elf_reloc)
203 {
204   unsigned int r_type = ELF32_R_TYPE (elf_reloc->r_info);
205
206   bfd_reloc->howto = ia64_elf_lookup_howto (r_type);
207   if (bfd_reloc->howto == NULL)
208     {
209       /* xgettext:c-format */
210       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
211                           abfd, r_type);
212       bfd_set_error (bfd_error_bad_value);
213       return FALSE;
214     }
215
216   return TRUE;
217 }
218 \f
219 #define PLT_HEADER_SIZE         (3 * 16)
220 #define PLT_MIN_ENTRY_SIZE      (1 * 16)
221 #define PLT_FULL_ENTRY_SIZE     (2 * 16)
222 #define PLT_RESERVED_WORDS      3
223
224 static const bfd_byte plt_header[PLT_HEADER_SIZE] =
225 {
226   0x0b, 0x10, 0x00, 0x1c, 0x00, 0x21,  /*   [MMI]       mov r2=r14;;       */
227   0xe0, 0x00, 0x08, 0x00, 0x48, 0x00,  /*               addl r14=0,r2      */
228   0x00, 0x00, 0x04, 0x00,              /*               nop.i 0x0;;        */
229   0x0b, 0x80, 0x20, 0x1c, 0x18, 0x14,  /*   [MMI]       ld8 r16=[r14],8;;  */
230   0x10, 0x41, 0x38, 0x30, 0x28, 0x00,  /*               ld8 r17=[r14],8    */
231   0x00, 0x00, 0x04, 0x00,              /*               nop.i 0x0;;        */
232   0x11, 0x08, 0x00, 0x1c, 0x18, 0x10,  /*   [MIB]       ld8 r1=[r14]       */
233   0x60, 0x88, 0x04, 0x80, 0x03, 0x00,  /*               mov b6=r17         */
234   0x60, 0x00, 0x80, 0x00               /*               br.few b6;;        */
235 };
236
237 static const bfd_byte plt_min_entry[PLT_MIN_ENTRY_SIZE] =
238 {
239   0x11, 0x78, 0x00, 0x00, 0x00, 0x24,  /*   [MIB]       mov r15=0          */
240   0x00, 0x00, 0x00, 0x02, 0x00, 0x00,  /*               nop.i 0x0          */
241   0x00, 0x00, 0x00, 0x40               /*               br.few 0 <PLT0>;;  */
242 };
243
244 static const bfd_byte plt_full_entry[PLT_FULL_ENTRY_SIZE] =
245 {
246   0x0b, 0x78, 0x00, 0x02, 0x00, 0x24,  /*   [MMI]       addl r15=0,r1;;    */
247   0x00, 0x41, 0x3c, 0x70, 0x29, 0xc0,  /*               ld8.acq r16=[r15],8*/
248   0x01, 0x08, 0x00, 0x84,              /*               mov r14=r1;;       */
249   0x11, 0x08, 0x00, 0x1e, 0x18, 0x10,  /*   [MIB]       ld8 r1=[r15]       */
250   0x60, 0x80, 0x04, 0x80, 0x03, 0x00,  /*               mov b6=r16         */
251   0x60, 0x00, 0x80, 0x00               /*               br.few b6;;        */
252 };
253
254 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
255
256 static const bfd_byte oor_brl[16] =
257 {
258   0x05, 0x00, 0x00, 0x00, 0x01, 0x00,  /*  [MLX]        nop.m 0            */
259   0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  /*               brl.sptk.few tgt;; */
260   0x00, 0x00, 0x00, 0xc0
261 };
262
263 static const bfd_byte oor_ip[48] =
264 {
265   0x04, 0x00, 0x00, 0x00, 0x01, 0x00,  /*  [MLX]        nop.m 0            */
266   0x00, 0x00, 0x00, 0x00, 0x00, 0xe0,  /*               movl r15=0         */
267   0x01, 0x00, 0x00, 0x60,
268   0x03, 0x00, 0x00, 0x00, 0x01, 0x00,  /*  [MII]        nop.m 0            */
269   0x00, 0x01, 0x00, 0x60, 0x00, 0x00,  /*               mov r16=ip;;       */
270   0xf2, 0x80, 0x00, 0x80,              /*               add r16=r15,r16;;  */
271   0x11, 0x00, 0x00, 0x00, 0x01, 0x00,  /*  [MIB]        nop.m 0            */
272   0x60, 0x80, 0x04, 0x80, 0x03, 0x00,  /*               mov b6=r16         */
273   0x60, 0x00, 0x80, 0x00               /*               br b6;;            */
274 };
275
276 static size_t oor_branch_size = sizeof (oor_brl);
277
278 void
279 bfd_elfNN_ia64_after_parse (int itanium)
280 {
281   oor_branch_size = itanium ? sizeof (oor_ip) : sizeof (oor_brl);
282 }
283 \f
284
285 /* Rename some of the generic section flags to better document how they
286    are used here.  */
287 #define skip_relax_pass_0 sec_flg0
288 #define skip_relax_pass_1 sec_flg1
289
290 /* These functions do relaxation for IA-64 ELF.  */
291
292 static void
293 elfNN_ia64_update_short_info (asection *sec, bfd_vma offset,
294                               struct elfNN_ia64_link_hash_table *ia64_info)
295 {
296   /* Skip ABS and SHF_IA_64_SHORT sections.  */
297   if (sec == bfd_abs_section_ptr
298       || (sec->flags & SEC_SMALL_DATA) != 0)
299     return;
300
301   if (!ia64_info->min_short_sec)
302     {
303       ia64_info->max_short_sec = sec;
304       ia64_info->max_short_offset = offset;
305       ia64_info->min_short_sec = sec;
306       ia64_info->min_short_offset = offset;
307     }
308   else if (sec == ia64_info->max_short_sec
309            && offset > ia64_info->max_short_offset)
310     ia64_info->max_short_offset = offset;
311   else if (sec == ia64_info->min_short_sec
312            && offset < ia64_info->min_short_offset)
313     ia64_info->min_short_offset = offset;
314   else if (sec->output_section->vma
315            > ia64_info->max_short_sec->vma)
316     {
317       ia64_info->max_short_sec = sec;
318       ia64_info->max_short_offset = offset;
319     }
320   else if (sec->output_section->vma
321            < ia64_info->min_short_sec->vma)
322     {
323       ia64_info->min_short_sec = sec;
324       ia64_info->min_short_offset = offset;
325     }
326 }
327
328 static bfd_boolean
329 elfNN_ia64_relax_section (bfd *abfd, asection *sec,
330                           struct bfd_link_info *link_info,
331                           bfd_boolean *again)
332 {
333   struct one_fixup
334     {
335       struct one_fixup *next;
336       asection *tsec;
337       bfd_vma toff;
338       bfd_vma trampoff;
339     };
340
341   Elf_Internal_Shdr *symtab_hdr;
342   Elf_Internal_Rela *internal_relocs;
343   Elf_Internal_Rela *irel, *irelend;
344   bfd_byte *contents;
345   Elf_Internal_Sym *isymbuf = NULL;
346   struct elfNN_ia64_link_hash_table *ia64_info;
347   struct one_fixup *fixups = NULL;
348   bfd_boolean changed_contents = FALSE;
349   bfd_boolean changed_relocs = FALSE;
350   bfd_boolean changed_got = FALSE;
351   bfd_boolean skip_relax_pass_0 = TRUE;
352   bfd_boolean skip_relax_pass_1 = TRUE;
353   bfd_vma gp = 0;
354
355   /* Assume we're not going to change any sizes, and we'll only need
356      one pass.  */
357   *again = FALSE;
358
359   if (bfd_link_relocatable (link_info))
360     (*link_info->callbacks->einfo)
361       (_("%P%F: --relax and -r may not be used together\n"));
362
363   /* Don't even try to relax for non-ELF outputs.  */
364   if (!is_elf_hash_table (link_info->hash))
365     return FALSE;
366
367   /* Nothing to do if there are no relocations or there is no need for
368      the current pass.  */
369   if ((sec->flags & SEC_RELOC) == 0
370       || sec->reloc_count == 0
371       || (link_info->relax_pass == 0 && sec->skip_relax_pass_0)
372       || (link_info->relax_pass == 1 && sec->skip_relax_pass_1))
373     return TRUE;
374
375   ia64_info = elfNN_ia64_hash_table (link_info);
376   if (ia64_info == NULL)
377     return FALSE;
378
379   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
380
381   /* Load the relocations for this section.  */
382   internal_relocs = (_bfd_elf_link_read_relocs
383                      (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
384                       link_info->keep_memory));
385   if (internal_relocs == NULL)
386     return FALSE;
387
388   irelend = internal_relocs + sec->reloc_count;
389
390   /* Get the section contents.  */
391   if (elf_section_data (sec)->this_hdr.contents != NULL)
392     contents = elf_section_data (sec)->this_hdr.contents;
393   else
394     {
395       if (!bfd_malloc_and_get_section (abfd, sec, &contents))
396         goto error_return;
397     }
398
399   for (irel = internal_relocs; irel < irelend; irel++)
400     {
401       unsigned long r_type = ELFNN_R_TYPE (irel->r_info);
402       bfd_vma symaddr, reladdr, trampoff, toff, roff;
403       asection *tsec;
404       struct one_fixup *f;
405       bfd_size_type amt;
406       bfd_boolean is_branch;
407       struct elfNN_ia64_dyn_sym_info *dyn_i;
408       char symtype;
409
410       switch (r_type)
411         {
412         case R_IA64_PCREL21B:
413         case R_IA64_PCREL21BI:
414         case R_IA64_PCREL21M:
415         case R_IA64_PCREL21F:
416           /* In pass 1, all br relaxations are done. We can skip it. */
417           if (link_info->relax_pass == 1)
418             continue;
419           skip_relax_pass_0 = FALSE;
420           is_branch = TRUE;
421           break;
422
423         case R_IA64_PCREL60B:
424           /* We can't optimize brl to br in pass 0 since br relaxations
425              will increase the code size. Defer it to pass 1.  */
426           if (link_info->relax_pass == 0)
427             {
428               skip_relax_pass_1 = FALSE;
429               continue;
430             }
431           is_branch = TRUE;
432           break;
433
434         case R_IA64_GPREL22:
435           /* Update max_short_sec/min_short_sec.  */
436
437         case R_IA64_LTOFF22X:
438         case R_IA64_LDXMOV:
439           /* We can't relax ldx/mov in pass 0 since br relaxations will
440              increase the code size. Defer it to pass 1.  */
441           if (link_info->relax_pass == 0)
442             {
443               skip_relax_pass_1 = FALSE;
444               continue;
445             }
446           is_branch = FALSE;
447           break;
448
449         default:
450           continue;
451         }
452
453       /* Get the value of the symbol referred to by the reloc.  */
454       if (ELFNN_R_SYM (irel->r_info) < symtab_hdr->sh_info)
455         {
456           /* A local symbol.  */
457           Elf_Internal_Sym *isym;
458
459           /* Read this BFD's local symbols.  */
460           if (isymbuf == NULL)
461             {
462               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
463               if (isymbuf == NULL)
464                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
465                                                 symtab_hdr->sh_info, 0,
466                                                 NULL, NULL, NULL);
467               if (isymbuf == 0)
468                 goto error_return;
469             }
470
471           isym = isymbuf + ELFNN_R_SYM (irel->r_info);
472           if (isym->st_shndx == SHN_UNDEF)
473             continue;   /* We can't do anything with undefined symbols.  */
474           else if (isym->st_shndx == SHN_ABS)
475             tsec = bfd_abs_section_ptr;
476           else if (isym->st_shndx == SHN_COMMON)
477             tsec = bfd_com_section_ptr;
478           else if (isym->st_shndx == SHN_IA_64_ANSI_COMMON)
479             tsec = bfd_com_section_ptr;
480           else
481             tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
482
483           toff = isym->st_value;
484           dyn_i = get_dyn_sym_info (ia64_info, NULL, abfd, irel, FALSE);
485           symtype = ELF_ST_TYPE (isym->st_info);
486         }
487       else
488         {
489           unsigned long indx;
490           struct elf_link_hash_entry *h;
491
492           indx = ELFNN_R_SYM (irel->r_info) - symtab_hdr->sh_info;
493           h = elf_sym_hashes (abfd)[indx];
494           BFD_ASSERT (h != NULL);
495
496           while (h->root.type == bfd_link_hash_indirect
497                  || h->root.type == bfd_link_hash_warning)
498             h = (struct elf_link_hash_entry *) h->root.u.i.link;
499
500           dyn_i = get_dyn_sym_info (ia64_info, h, abfd, irel, FALSE);
501
502           /* For branches to dynamic symbols, we're interested instead
503              in a branch to the PLT entry.  */
504           if (is_branch && dyn_i && dyn_i->want_plt2)
505             {
506               /* Internal branches shouldn't be sent to the PLT.
507                  Leave this for now and we'll give an error later.  */
508               if (r_type != R_IA64_PCREL21B)
509                 continue;
510
511               tsec = ia64_info->root.splt;
512               toff = dyn_i->plt2_offset;
513               BFD_ASSERT (irel->r_addend == 0);
514             }
515
516           /* Can't do anything else with dynamic symbols.  */
517           else if (elfNN_ia64_dynamic_symbol_p (h, link_info, r_type))
518             continue;
519
520           else
521             {
522               /* We can't do anything with undefined symbols.  */
523               if (h->root.type == bfd_link_hash_undefined
524                   || h->root.type == bfd_link_hash_undefweak)
525                 continue;
526
527               tsec = h->root.u.def.section;
528               toff = h->root.u.def.value;
529             }
530
531           symtype = h->type;
532         }
533
534       if (tsec->sec_info_type == SEC_INFO_TYPE_MERGE)
535         {
536           /* At this stage in linking, no SEC_MERGE symbol has been
537              adjusted, so all references to such symbols need to be
538              passed through _bfd_merged_section_offset.  (Later, in
539              relocate_section, all SEC_MERGE symbols *except* for
540              section symbols have been adjusted.)
541
542              gas may reduce relocations against symbols in SEC_MERGE
543              sections to a relocation against the section symbol when
544              the original addend was zero.  When the reloc is against
545              a section symbol we should include the addend in the
546              offset passed to _bfd_merged_section_offset, since the
547              location of interest is the original symbol.  On the
548              other hand, an access to "sym+addend" where "sym" is not
549              a section symbol should not include the addend;  Such an
550              access is presumed to be an offset from "sym";  The
551              location of interest is just "sym".  */
552            if (symtype == STT_SECTION)
553              toff += irel->r_addend;
554
555            toff = _bfd_merged_section_offset (abfd, &tsec,
556                                               elf_section_data (tsec)->sec_info,
557                                               toff);
558
559            if (symtype != STT_SECTION)
560              toff += irel->r_addend;
561         }
562       else
563         toff += irel->r_addend;
564
565       symaddr = tsec->output_section->vma + tsec->output_offset + toff;
566
567       roff = irel->r_offset;
568
569       if (is_branch)
570         {
571           bfd_signed_vma offset;
572
573           reladdr = (sec->output_section->vma
574                      + sec->output_offset
575                      + roff) & (bfd_vma) -4;
576
577           /* The .plt section is aligned at 32byte and the .text section
578              is aligned at 64byte. The .text section is right after the
579              .plt section.  After the first relaxation pass, linker may
580              increase the gap between the .plt and .text sections up
581              to 32byte.  We assume linker will always insert 32byte
582              between the .plt and .text sections after the first
583              relaxation pass.  */
584           if (tsec == ia64_info->root.splt)
585             offset = -0x1000000 + 32;
586           else
587             offset = -0x1000000;
588
589           /* If the branch is in range, no need to do anything.  */
590           if ((bfd_signed_vma) (symaddr - reladdr) >= offset
591               && (bfd_signed_vma) (symaddr - reladdr) <= 0x0FFFFF0)
592             {
593               /* If the 60-bit branch is in 21-bit range, optimize it. */
594               if (r_type == R_IA64_PCREL60B)
595                 {
596                   ia64_elf_relax_brl (contents, roff);
597
598                   irel->r_info
599                     = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
600                                     R_IA64_PCREL21B);
601
602                   /* If the original relocation offset points to slot
603                      1, change it to slot 2.  */
604                   if ((irel->r_offset & 3) == 1)
605                     irel->r_offset += 1;
606
607                   changed_contents = TRUE;
608                   changed_relocs = TRUE;
609                 }
610
611               continue;
612             }
613           else if (r_type == R_IA64_PCREL60B)
614             continue;
615           else if (ia64_elf_relax_br (contents, roff))
616             {
617               irel->r_info
618                 = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
619                                 R_IA64_PCREL60B);
620
621               /* Make the relocation offset point to slot 1.  */
622               irel->r_offset = (irel->r_offset & ~((bfd_vma) 0x3)) + 1;
623
624               changed_contents = TRUE;
625               changed_relocs = TRUE;
626               continue;
627             }
628
629           /* We can't put a trampoline in a .init/.fini section. Issue
630              an error.  */
631           if (strcmp (sec->output_section->name, ".init") == 0
632               || strcmp (sec->output_section->name, ".fini") == 0)
633             {
634               _bfd_error_handler
635                 /* xgettext:c-format */
636                 (_("%pB: can't relax br at %#" PRIx64 " in section `%pA';"
637                    " please use brl or indirect branch"),
638                  sec->owner, (uint64_t) roff, sec);
639               bfd_set_error (bfd_error_bad_value);
640               goto error_return;
641             }
642
643           /* If the branch and target are in the same section, you've
644              got one honking big section and we can't help you unless
645              you are branching backwards.  You'll get an error message
646              later.  */
647           if (tsec == sec && toff > roff)
648             continue;
649
650           /* Look for an existing fixup to this address.  */
651           for (f = fixups; f ; f = f->next)
652             if (f->tsec == tsec && f->toff == toff)
653               break;
654
655           if (f == NULL)
656             {
657               /* Two alternatives: If it's a branch to a PLT entry, we can
658                  make a copy of the FULL_PLT entry.  Otherwise, we'll have
659                  to use a `brl' insn to get where we're going.  */
660
661               size_t size;
662
663               if (tsec == ia64_info->root.splt)
664                 size = sizeof (plt_full_entry);
665               else
666                 size = oor_branch_size;
667
668               /* Resize the current section to make room for the new branch. */
669               trampoff = (sec->size + 15) & (bfd_vma) -16;
670
671               /* If trampoline is out of range, there is nothing we
672                  can do.  */
673               offset = trampoff - (roff & (bfd_vma) -4);
674               if (offset < -0x1000000 || offset > 0x0FFFFF0)
675                 continue;
676
677               amt = trampoff + size;
678               contents = (bfd_byte *) bfd_realloc (contents, amt);
679               if (contents == NULL)
680                 goto error_return;
681               sec->size = amt;
682
683               if (tsec == ia64_info->root.splt)
684                 {
685                   memcpy (contents + trampoff, plt_full_entry, size);
686
687                   /* Hijack the old relocation for use as the PLTOFF reloc.  */
688                   irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
689                                                R_IA64_PLTOFF22);
690                   irel->r_offset = trampoff;
691                 }
692               else
693                 {
694                   if (size == sizeof (oor_ip))
695                     {
696                       memcpy (contents + trampoff, oor_ip, size);
697                       irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
698                                                    R_IA64_PCREL64I);
699                       irel->r_addend -= 16;
700                       irel->r_offset = trampoff + 2;
701                     }
702                   else
703                     {
704                       memcpy (contents + trampoff, oor_brl, size);
705                       irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
706                                                    R_IA64_PCREL60B);
707                       irel->r_offset = trampoff + 2;
708                     }
709
710                 }
711
712               /* Record the fixup so we don't do it again this section.  */
713               f = (struct one_fixup *)
714                 bfd_malloc ((bfd_size_type) sizeof (*f));
715               f->next = fixups;
716               f->tsec = tsec;
717               f->toff = toff;
718               f->trampoff = trampoff;
719               fixups = f;
720             }
721           else
722             {
723               /* If trampoline is out of range, there is nothing we
724                  can do.  */
725               offset = f->trampoff - (roff & (bfd_vma) -4);
726               if (offset < -0x1000000 || offset > 0x0FFFFF0)
727                 continue;
728
729               /* Nop out the reloc, since we're finalizing things here.  */
730               irel->r_info = ELFNN_R_INFO (0, R_IA64_NONE);
731             }
732
733           /* Fix up the existing branch to hit the trampoline.  */
734           if (ia64_elf_install_value (contents + roff, offset, r_type)
735               != bfd_reloc_ok)
736             goto error_return;
737
738           changed_contents = TRUE;
739           changed_relocs = TRUE;
740         }
741       else
742         {
743           /* Fetch the gp.  */
744           if (gp == 0)
745             {
746               bfd *obfd = sec->output_section->owner;
747               gp = _bfd_get_gp_value (obfd);
748               if (gp == 0)
749                 {
750                   if (!elfNN_ia64_choose_gp (obfd, link_info, FALSE))
751                     goto error_return;
752                   gp = _bfd_get_gp_value (obfd);
753                 }
754             }
755
756           /* If the data is out of range, do nothing.  */
757           if ((bfd_signed_vma) (symaddr - gp) >= 0x200000
758               ||(bfd_signed_vma) (symaddr - gp) < -0x200000)
759             continue;
760
761           if (r_type == R_IA64_GPREL22)
762             elfNN_ia64_update_short_info (tsec->output_section,
763                                           tsec->output_offset + toff,
764                                           ia64_info);
765           else if (r_type == R_IA64_LTOFF22X)
766             {
767               irel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (irel->r_info),
768                                            R_IA64_GPREL22);
769               changed_relocs = TRUE;
770               if (dyn_i->want_gotx)
771                 {
772                   dyn_i->want_gotx = 0;
773                   changed_got |= !dyn_i->want_got;
774                 }
775
776               elfNN_ia64_update_short_info (tsec->output_section,
777                                             tsec->output_offset + toff,
778                                             ia64_info);
779             }
780           else
781             {
782               ia64_elf_relax_ldxmov (contents, roff);
783               irel->r_info = ELFNN_R_INFO (0, R_IA64_NONE);
784               changed_contents = TRUE;
785               changed_relocs = TRUE;
786             }
787         }
788     }
789
790   /* ??? If we created fixups, this may push the code segment large
791      enough that the data segment moves, which will change the GP.
792      Reset the GP so that we re-calculate next round.  We need to
793      do this at the _beginning_ of the next round; now will not do.  */
794
795   /* Clean up and go home.  */
796   while (fixups)
797     {
798       struct one_fixup *f = fixups;
799       fixups = fixups->next;
800       free (f);
801     }
802
803   if (isymbuf != NULL
804       && symtab_hdr->contents != (unsigned char *) isymbuf)
805     {
806       if (! link_info->keep_memory)
807         free (isymbuf);
808       else
809         {
810           /* Cache the symbols for elf_link_input_bfd.  */
811           symtab_hdr->contents = (unsigned char *) isymbuf;
812         }
813     }
814
815   if (contents != NULL
816       && elf_section_data (sec)->this_hdr.contents != contents)
817     {
818       if (!changed_contents && !link_info->keep_memory)
819         free (contents);
820       else
821         {
822           /* Cache the section contents for elf_link_input_bfd.  */
823           elf_section_data (sec)->this_hdr.contents = contents;
824         }
825     }
826
827   if (elf_section_data (sec)->relocs != internal_relocs)
828     {
829       if (!changed_relocs)
830         free (internal_relocs);
831       else
832         elf_section_data (sec)->relocs = internal_relocs;
833     }
834
835   if (changed_got)
836     {
837       struct elfNN_ia64_allocate_data data;
838       data.info = link_info;
839       data.ofs = 0;
840       ia64_info->self_dtpmod_offset = (bfd_vma) -1;
841
842       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data);
843       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data);
844       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data);
845       ia64_info->root.sgot->size = data.ofs;
846
847       if (ia64_info->root.dynamic_sections_created
848           && ia64_info->root.srelgot != NULL)
849         {
850           /* Resize .rela.got.  */
851           ia64_info->root.srelgot->size = 0;
852           if (bfd_link_pic (link_info)
853               && ia64_info->self_dtpmod_offset != (bfd_vma) -1)
854             ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela);
855           data.only_got = TRUE;
856           elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries,
857                                        &data);
858         }
859     }
860
861   if (link_info->relax_pass == 0)
862     {
863       /* Pass 0 is only needed to relax br.  */
864       sec->skip_relax_pass_0 = skip_relax_pass_0;
865       sec->skip_relax_pass_1 = skip_relax_pass_1;
866     }
867
868   *again = changed_contents || changed_relocs;
869   return TRUE;
870
871  error_return:
872   if (isymbuf != NULL && (unsigned char *) isymbuf != symtab_hdr->contents)
873     free (isymbuf);
874   if (contents != NULL
875       && elf_section_data (sec)->this_hdr.contents != contents)
876     free (contents);
877   if (internal_relocs != NULL
878       && elf_section_data (sec)->relocs != internal_relocs)
879     free (internal_relocs);
880   return FALSE;
881 }
882 #undef skip_relax_pass_0
883 #undef skip_relax_pass_1
884 \f
885 /* Return TRUE if NAME is an unwind table section name.  */
886
887 static inline bfd_boolean
888 is_unwind_section_name (bfd *abfd, const char *name)
889 {
890   if (elfNN_ia64_hpux_vec (abfd->xvec)
891       && !strcmp (name, ELF_STRING_ia64_unwind_hdr))
892     return FALSE;
893
894   return ((CONST_STRNEQ (name, ELF_STRING_ia64_unwind)
895            && ! CONST_STRNEQ (name, ELF_STRING_ia64_unwind_info))
896           || CONST_STRNEQ (name, ELF_STRING_ia64_unwind_once));
897 }
898
899 /* Handle an IA-64 specific section when reading an object file.  This
900    is called when bfd_section_from_shdr finds a section with an unknown
901    type.  */
902
903 static bfd_boolean
904 elfNN_ia64_section_from_shdr (bfd *abfd,
905                               Elf_Internal_Shdr *hdr,
906                               const char *name,
907                               int shindex)
908 {
909   /* There ought to be a place to keep ELF backend specific flags, but
910      at the moment there isn't one.  We just keep track of the
911      sections by their name, instead.  Fortunately, the ABI gives
912      suggested names for all the MIPS specific sections, so we will
913      probably get away with this.  */
914   switch (hdr->sh_type)
915     {
916     case SHT_IA_64_UNWIND:
917     case SHT_IA_64_HP_OPT_ANOT:
918       break;
919
920     case SHT_IA_64_EXT:
921       if (strcmp (name, ELF_STRING_ia64_archext) != 0)
922         return FALSE;
923       break;
924
925     default:
926       return FALSE;
927     }
928
929   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
930     return FALSE;
931
932   return TRUE;
933 }
934
935 /* Convert IA-64 specific section flags to bfd internal section flags.  */
936
937 /* ??? There is no bfd internal flag equivalent to the SHF_IA_64_NORECOV
938    flag.  */
939
940 static bfd_boolean
941 elfNN_ia64_section_flags (flagword *flags,
942                           const Elf_Internal_Shdr *hdr)
943 {
944   if (hdr->sh_flags & SHF_IA_64_SHORT)
945     *flags |= SEC_SMALL_DATA;
946
947   return TRUE;
948 }
949
950 /* Set the correct type for an IA-64 ELF section.  We do this by the
951    section name, which is a hack, but ought to work.  */
952
953 static bfd_boolean
954 elfNN_ia64_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr,
955                           asection *sec)
956 {
957   const char *name;
958
959   name = bfd_get_section_name (abfd, sec);
960
961   if (is_unwind_section_name (abfd, name))
962     {
963       /* We don't have the sections numbered at this point, so sh_info
964          is set later, in elfNN_ia64_final_write_processing.  */
965       hdr->sh_type = SHT_IA_64_UNWIND;
966       hdr->sh_flags |= SHF_LINK_ORDER;
967     }
968   else if (strcmp (name, ELF_STRING_ia64_archext) == 0)
969     hdr->sh_type = SHT_IA_64_EXT;
970   else if (strcmp (name, ".HP.opt_annot") == 0)
971     hdr->sh_type = SHT_IA_64_HP_OPT_ANOT;
972   else if (strcmp (name, ".reloc") == 0)
973     /* This is an ugly, but unfortunately necessary hack that is
974        needed when producing EFI binaries on IA-64. It tells
975        elf.c:elf_fake_sections() not to consider ".reloc" as a section
976        containing ELF relocation info.  We need this hack in order to
977        be able to generate ELF binaries that can be translated into
978        EFI applications (which are essentially COFF objects).  Those
979        files contain a COFF ".reloc" section inside an ELFNN object,
980        which would normally cause BFD to segfault because it would
981        attempt to interpret this section as containing relocation
982        entries for section "oc".  With this hack enabled, ".reloc"
983        will be treated as a normal data section, which will avoid the
984        segfault.  However, you won't be able to create an ELFNN binary
985        with a section named "oc" that needs relocations, but that's
986        the kind of ugly side-effects you get when detecting section
987        types based on their names...  In practice, this limitation is
988        unlikely to bite.  */
989     hdr->sh_type = SHT_PROGBITS;
990
991   if (sec->flags & SEC_SMALL_DATA)
992     hdr->sh_flags |= SHF_IA_64_SHORT;
993
994   /* Some HP linkers look for the SHF_IA_64_HP_TLS flag instead of SHF_TLS. */
995
996   if (elfNN_ia64_hpux_vec (abfd->xvec) && (sec->flags & SHF_TLS))
997     hdr->sh_flags |= SHF_IA_64_HP_TLS;
998
999   return TRUE;
1000 }
1001
1002 /* The final processing done just before writing out an IA-64 ELF
1003    object file.  */
1004
1005 static void
1006 elfNN_ia64_final_write_processing (bfd *abfd,
1007                                    bfd_boolean linker ATTRIBUTE_UNUSED)
1008 {
1009   Elf_Internal_Shdr *hdr;
1010   asection *s;
1011
1012   for (s = abfd->sections; s; s = s->next)
1013     {
1014       hdr = &elf_section_data (s)->this_hdr;
1015       switch (hdr->sh_type)
1016         {
1017         case SHT_IA_64_UNWIND:
1018           /* The IA-64 processor-specific ABI requires setting sh_link
1019              to the unwind section, whereas HP-UX requires sh_info to
1020              do so.  For maximum compatibility, we'll set both for
1021              now... */
1022           hdr->sh_info = hdr->sh_link;
1023           break;
1024         }
1025     }
1026
1027   if (! elf_flags_init (abfd))
1028     {
1029       unsigned long flags = 0;
1030
1031       if (abfd->xvec->byteorder == BFD_ENDIAN_BIG)
1032         flags |= EF_IA_64_BE;
1033       if (bfd_get_mach (abfd) == bfd_mach_ia64_elf64)
1034         flags |= EF_IA_64_ABI64;
1035
1036       elf_elfheader(abfd)->e_flags = flags;
1037       elf_flags_init (abfd) = TRUE;
1038     }
1039 }
1040
1041 /* Hook called by the linker routine which adds symbols from an object
1042    file.  We use it to put .comm items in .sbss, and not .bss.  */
1043
1044 static bfd_boolean
1045 elfNN_ia64_add_symbol_hook (bfd *abfd,
1046                             struct bfd_link_info *info,
1047                             Elf_Internal_Sym *sym,
1048                             const char **namep ATTRIBUTE_UNUSED,
1049                             flagword *flagsp ATTRIBUTE_UNUSED,
1050                             asection **secp,
1051                             bfd_vma *valp)
1052 {
1053   if (sym->st_shndx == SHN_COMMON
1054       && !bfd_link_relocatable (info)
1055       && sym->st_size <= elf_gp_size (abfd))
1056     {
1057       /* Common symbols less than or equal to -G nn bytes are
1058          automatically put into .sbss.  */
1059
1060       asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1061
1062       if (scomm == NULL)
1063         {
1064           scomm = bfd_make_section_with_flags (abfd, ".scommon",
1065                                                (SEC_ALLOC
1066                                                 | SEC_IS_COMMON
1067                                                 | SEC_LINKER_CREATED));
1068           if (scomm == NULL)
1069             return FALSE;
1070         }
1071
1072       *secp = scomm;
1073       *valp = sym->st_size;
1074     }
1075
1076   return TRUE;
1077 }
1078
1079 /* Return the number of additional phdrs we will need.  */
1080
1081 static int
1082 elfNN_ia64_additional_program_headers (bfd *abfd,
1083                                        struct bfd_link_info *info ATTRIBUTE_UNUSED)
1084 {
1085   asection *s;
1086   int ret = 0;
1087
1088   /* See if we need a PT_IA_64_ARCHEXT segment.  */
1089   s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_archext);
1090   if (s && (s->flags & SEC_LOAD))
1091     ++ret;
1092
1093   /* Count how many PT_IA_64_UNWIND segments we need.  */
1094   for (s = abfd->sections; s; s = s->next)
1095     if (is_unwind_section_name (abfd, s->name) && (s->flags & SEC_LOAD))
1096       ++ret;
1097
1098   return ret;
1099 }
1100
1101 static bfd_boolean
1102 elfNN_ia64_modify_segment_map (bfd *abfd,
1103                                struct bfd_link_info *info ATTRIBUTE_UNUSED)
1104 {
1105   struct elf_segment_map *m, **pm;
1106   Elf_Internal_Shdr *hdr;
1107   asection *s;
1108
1109   /* If we need a PT_IA_64_ARCHEXT segment, it must come before
1110      all PT_LOAD segments.  */
1111   s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_archext);
1112   if (s && (s->flags & SEC_LOAD))
1113     {
1114       for (m = elf_seg_map (abfd); m != NULL; m = m->next)
1115         if (m->p_type == PT_IA_64_ARCHEXT)
1116           break;
1117       if (m == NULL)
1118         {
1119           m = ((struct elf_segment_map *)
1120                bfd_zalloc (abfd, (bfd_size_type) sizeof *m));
1121           if (m == NULL)
1122             return FALSE;
1123
1124           m->p_type = PT_IA_64_ARCHEXT;
1125           m->count = 1;
1126           m->sections[0] = s;
1127
1128           /* We want to put it after the PHDR and INTERP segments.  */
1129           pm = &elf_seg_map (abfd);
1130           while (*pm != NULL
1131                  && ((*pm)->p_type == PT_PHDR
1132                      || (*pm)->p_type == PT_INTERP))
1133             pm = &(*pm)->next;
1134
1135           m->next = *pm;
1136           *pm = m;
1137         }
1138     }
1139
1140   /* Install PT_IA_64_UNWIND segments, if needed.  */
1141   for (s = abfd->sections; s; s = s->next)
1142     {
1143       hdr = &elf_section_data (s)->this_hdr;
1144       if (hdr->sh_type != SHT_IA_64_UNWIND)
1145         continue;
1146
1147       if (s && (s->flags & SEC_LOAD))
1148         {
1149           for (m = elf_seg_map (abfd); m != NULL; m = m->next)
1150             if (m->p_type == PT_IA_64_UNWIND)
1151               {
1152                 int i;
1153
1154                 /* Look through all sections in the unwind segment
1155                    for a match since there may be multiple sections
1156                    to a segment.  */
1157                 for (i = m->count - 1; i >= 0; --i)
1158                   if (m->sections[i] == s)
1159                     break;
1160
1161                 if (i >= 0)
1162                   break;
1163               }
1164
1165           if (m == NULL)
1166             {
1167               m = ((struct elf_segment_map *)
1168                    bfd_zalloc (abfd, (bfd_size_type) sizeof *m));
1169               if (m == NULL)
1170                 return FALSE;
1171
1172               m->p_type = PT_IA_64_UNWIND;
1173               m->count = 1;
1174               m->sections[0] = s;
1175               m->next = NULL;
1176
1177               /* We want to put it last.  */
1178               pm = &elf_seg_map (abfd);
1179               while (*pm != NULL)
1180                 pm = &(*pm)->next;
1181               *pm = m;
1182             }
1183         }
1184     }
1185
1186   return TRUE;
1187 }
1188
1189 /* Turn on PF_IA_64_NORECOV if needed.  This involves traversing all of
1190    the input sections for each output section in the segment and testing
1191    for SHF_IA_64_NORECOV on each.  */
1192
1193 static bfd_boolean
1194 elfNN_ia64_modify_program_headers (bfd *abfd,
1195                                    struct bfd_link_info *info ATTRIBUTE_UNUSED)
1196 {
1197   struct elf_obj_tdata *tdata = elf_tdata (abfd);
1198   struct elf_segment_map *m;
1199   Elf_Internal_Phdr *p;
1200
1201   for (p = tdata->phdr, m = elf_seg_map (abfd); m != NULL; m = m->next, p++)
1202     if (m->p_type == PT_LOAD)
1203       {
1204         int i;
1205         for (i = m->count - 1; i >= 0; --i)
1206           {
1207             struct bfd_link_order *order = m->sections[i]->map_head.link_order;
1208
1209             while (order != NULL)
1210               {
1211                 if (order->type == bfd_indirect_link_order)
1212                   {
1213                     asection *is = order->u.indirect.section;
1214                     bfd_vma flags = elf_section_data(is)->this_hdr.sh_flags;
1215                     if (flags & SHF_IA_64_NORECOV)
1216                       {
1217                         p->p_flags |= PF_IA_64_NORECOV;
1218                         goto found;
1219                       }
1220                   }
1221                 order = order->next;
1222               }
1223           }
1224       found:;
1225       }
1226
1227   return TRUE;
1228 }
1229
1230 /* According to the Tahoe assembler spec, all labels starting with a
1231    '.' are local.  */
1232
1233 static bfd_boolean
1234 elfNN_ia64_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
1235                                 const char *name)
1236 {
1237   return name[0] == '.';
1238 }
1239
1240 /* Should we do dynamic things to this symbol?  */
1241
1242 static bfd_boolean
1243 elfNN_ia64_dynamic_symbol_p (struct elf_link_hash_entry *h,
1244                              struct bfd_link_info *info, int r_type)
1245 {
1246   bfd_boolean ignore_protected
1247     = ((r_type & 0xf8) == 0x40          /* FPTR relocs */
1248        || (r_type & 0xf8) == 0x50);     /* LTOFF_FPTR relocs */
1249
1250   return _bfd_elf_dynamic_symbol_p (h, info, ignore_protected);
1251 }
1252 \f
1253 static struct bfd_hash_entry*
1254 elfNN_ia64_new_elf_hash_entry (struct bfd_hash_entry *entry,
1255                                struct bfd_hash_table *table,
1256                                const char *string)
1257 {
1258   struct elfNN_ia64_link_hash_entry *ret;
1259   ret = (struct elfNN_ia64_link_hash_entry *) entry;
1260
1261   /* Allocate the structure if it has not already been allocated by a
1262      subclass.  */
1263   if (!ret)
1264     ret = bfd_hash_allocate (table, sizeof (*ret));
1265
1266   if (!ret)
1267     return 0;
1268
1269   /* Call the allocation method of the superclass.  */
1270   ret = ((struct elfNN_ia64_link_hash_entry *)
1271          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1272                                      table, string));
1273
1274   ret->info = NULL;
1275   ret->count = 0;
1276   ret->sorted_count = 0;
1277   ret->size = 0;
1278   return (struct bfd_hash_entry *) ret;
1279 }
1280
1281 static void
1282 elfNN_ia64_hash_copy_indirect (struct bfd_link_info *info,
1283                                struct elf_link_hash_entry *xdir,
1284                                struct elf_link_hash_entry *xind)
1285 {
1286   struct elfNN_ia64_link_hash_entry *dir, *ind;
1287
1288   dir = (struct elfNN_ia64_link_hash_entry *) xdir;
1289   ind = (struct elfNN_ia64_link_hash_entry *) xind;
1290
1291   /* Copy down any references that we may have already seen to the
1292      symbol which just became indirect.  */
1293
1294   if (dir->root.versioned != versioned_hidden)
1295     dir->root.ref_dynamic |= ind->root.ref_dynamic;
1296   dir->root.ref_regular |= ind->root.ref_regular;
1297   dir->root.ref_regular_nonweak |= ind->root.ref_regular_nonweak;
1298   dir->root.needs_plt |= ind->root.needs_plt;
1299
1300   if (ind->root.root.type != bfd_link_hash_indirect)
1301     return;
1302
1303   /* Copy over the got and plt data.  This would have been done
1304      by check_relocs.  */
1305
1306   if (ind->info != NULL)
1307     {
1308       struct elfNN_ia64_dyn_sym_info *dyn_i;
1309       unsigned int count;
1310
1311       if (dir->info)
1312         free (dir->info);
1313
1314       dir->info = ind->info;
1315       dir->count = ind->count;
1316       dir->sorted_count = ind->sorted_count;
1317       dir->size = ind->size;
1318
1319       ind->info = NULL;
1320       ind->count = 0;
1321       ind->sorted_count = 0;
1322       ind->size = 0;
1323
1324       /* Fix up the dyn_sym_info pointers to the global symbol.  */
1325       for (count = dir->count, dyn_i = dir->info;
1326            count != 0;
1327            count--, dyn_i++)
1328         dyn_i->h = &dir->root;
1329     }
1330
1331   /* Copy over the dynindx.  */
1332
1333   if (ind->root.dynindx != -1)
1334     {
1335       if (dir->root.dynindx != -1)
1336         _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
1337                                 dir->root.dynstr_index);
1338       dir->root.dynindx = ind->root.dynindx;
1339       dir->root.dynstr_index = ind->root.dynstr_index;
1340       ind->root.dynindx = -1;
1341       ind->root.dynstr_index = 0;
1342     }
1343 }
1344
1345 static void
1346 elfNN_ia64_hash_hide_symbol (struct bfd_link_info *info,
1347                              struct elf_link_hash_entry *xh,
1348                              bfd_boolean force_local)
1349 {
1350   struct elfNN_ia64_link_hash_entry *h;
1351   struct elfNN_ia64_dyn_sym_info *dyn_i;
1352   unsigned int count;
1353
1354   h = (struct elfNN_ia64_link_hash_entry *)xh;
1355
1356   _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local);
1357
1358   for (count = h->count, dyn_i = h->info;
1359        count != 0;
1360        count--, dyn_i++)
1361     {
1362       dyn_i->want_plt2 = 0;
1363       dyn_i->want_plt = 0;
1364     }
1365 }
1366
1367 /* Compute a hash of a local hash entry.  */
1368
1369 static hashval_t
1370 elfNN_ia64_local_htab_hash (const void *ptr)
1371 {
1372   struct elfNN_ia64_local_hash_entry *entry
1373     = (struct elfNN_ia64_local_hash_entry *) ptr;
1374
1375   return ELF_LOCAL_SYMBOL_HASH (entry->id, entry->r_sym);
1376 }
1377
1378 /* Compare local hash entries.  */
1379
1380 static int
1381 elfNN_ia64_local_htab_eq (const void *ptr1, const void *ptr2)
1382 {
1383   struct elfNN_ia64_local_hash_entry *entry1
1384     = (struct elfNN_ia64_local_hash_entry *) ptr1;
1385   struct elfNN_ia64_local_hash_entry *entry2
1386     = (struct elfNN_ia64_local_hash_entry *) ptr2;
1387
1388   return entry1->id == entry2->id && entry1->r_sym == entry2->r_sym;
1389 }
1390
1391 /* Free the global elfNN_ia64_dyn_sym_info array.  */
1392
1393 static bfd_boolean
1394 elfNN_ia64_global_dyn_info_free (void **xentry,
1395                                  void * unused ATTRIBUTE_UNUSED)
1396 {
1397   struct elfNN_ia64_link_hash_entry *entry
1398     = (struct elfNN_ia64_link_hash_entry *) xentry;
1399
1400   if (entry->info)
1401     {
1402       free (entry->info);
1403       entry->info = NULL;
1404       entry->count = 0;
1405       entry->sorted_count = 0;
1406       entry->size = 0;
1407     }
1408
1409   return TRUE;
1410 }
1411
1412 /* Free the local elfNN_ia64_dyn_sym_info array.  */
1413
1414 static bfd_boolean
1415 elfNN_ia64_local_dyn_info_free (void **slot,
1416                                 void * unused ATTRIBUTE_UNUSED)
1417 {
1418   struct elfNN_ia64_local_hash_entry *entry
1419     = (struct elfNN_ia64_local_hash_entry *) *slot;
1420
1421   if (entry->info)
1422     {
1423       free (entry->info);
1424       entry->info = NULL;
1425       entry->count = 0;
1426       entry->sorted_count = 0;
1427       entry->size = 0;
1428     }
1429
1430   return TRUE;
1431 }
1432
1433 /* Destroy IA-64 linker hash table.  */
1434
1435 static void
1436 elfNN_ia64_link_hash_table_free (bfd *obfd)
1437 {
1438   struct elfNN_ia64_link_hash_table *ia64_info
1439     = (struct elfNN_ia64_link_hash_table *) obfd->link.hash;
1440   if (ia64_info->loc_hash_table)
1441     {
1442       htab_traverse (ia64_info->loc_hash_table,
1443                      elfNN_ia64_local_dyn_info_free, NULL);
1444       htab_delete (ia64_info->loc_hash_table);
1445     }
1446   if (ia64_info->loc_hash_memory)
1447     objalloc_free ((struct objalloc *) ia64_info->loc_hash_memory);
1448   elf_link_hash_traverse (&ia64_info->root,
1449                           elfNN_ia64_global_dyn_info_free, NULL);
1450   _bfd_elf_link_hash_table_free (obfd);
1451 }
1452
1453 /* Create the derived linker hash table.  The IA-64 ELF port uses this
1454    derived hash table to keep information specific to the IA-64 ElF
1455    linker (without using static variables).  */
1456
1457 static struct bfd_link_hash_table *
1458 elfNN_ia64_hash_table_create (bfd *abfd)
1459 {
1460   struct elfNN_ia64_link_hash_table *ret;
1461
1462   ret = bfd_zmalloc ((bfd_size_type) sizeof (*ret));
1463   if (!ret)
1464     return NULL;
1465
1466   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
1467                                       elfNN_ia64_new_elf_hash_entry,
1468                                       sizeof (struct elfNN_ia64_link_hash_entry),
1469                                       IA64_ELF_DATA))
1470     {
1471       free (ret);
1472       return NULL;
1473     }
1474
1475   ret->loc_hash_table = htab_try_create (1024, elfNN_ia64_local_htab_hash,
1476                                          elfNN_ia64_local_htab_eq, NULL);
1477   ret->loc_hash_memory = objalloc_create ();
1478   if (!ret->loc_hash_table || !ret->loc_hash_memory)
1479     {
1480       elfNN_ia64_link_hash_table_free (abfd);
1481       return NULL;
1482     }
1483   ret->root.root.hash_table_free = elfNN_ia64_link_hash_table_free;
1484
1485   return &ret->root.root;
1486 }
1487
1488 /* Traverse both local and global hash tables.  */
1489
1490 struct elfNN_ia64_dyn_sym_traverse_data
1491 {
1492   bfd_boolean (*func) (struct elfNN_ia64_dyn_sym_info *, void *);
1493   void * data;
1494 };
1495
1496 static bfd_boolean
1497 elfNN_ia64_global_dyn_sym_thunk (struct bfd_hash_entry *xentry,
1498                                  void * xdata)
1499 {
1500   struct elfNN_ia64_link_hash_entry *entry
1501     = (struct elfNN_ia64_link_hash_entry *) xentry;
1502   struct elfNN_ia64_dyn_sym_traverse_data *data
1503     = (struct elfNN_ia64_dyn_sym_traverse_data *) xdata;
1504   struct elfNN_ia64_dyn_sym_info *dyn_i;
1505   unsigned int count;
1506
1507   for (count = entry->count, dyn_i = entry->info;
1508        count != 0;
1509        count--, dyn_i++)
1510     if (! (*data->func) (dyn_i, data->data))
1511       return FALSE;
1512   return TRUE;
1513 }
1514
1515 static bfd_boolean
1516 elfNN_ia64_local_dyn_sym_thunk (void **slot, void * xdata)
1517 {
1518   struct elfNN_ia64_local_hash_entry *entry
1519     = (struct elfNN_ia64_local_hash_entry *) *slot;
1520   struct elfNN_ia64_dyn_sym_traverse_data *data
1521     = (struct elfNN_ia64_dyn_sym_traverse_data *) xdata;
1522   struct elfNN_ia64_dyn_sym_info *dyn_i;
1523   unsigned int count;
1524
1525   for (count = entry->count, dyn_i = entry->info;
1526        count != 0;
1527        count--, dyn_i++)
1528     if (! (*data->func) (dyn_i, data->data))
1529       return FALSE;
1530   return TRUE;
1531 }
1532
1533 static void
1534 elfNN_ia64_dyn_sym_traverse (struct elfNN_ia64_link_hash_table *ia64_info,
1535                              bfd_boolean (*func) (struct elfNN_ia64_dyn_sym_info *, void *),
1536                              void * data)
1537 {
1538   struct elfNN_ia64_dyn_sym_traverse_data xdata;
1539
1540   xdata.func = func;
1541   xdata.data = data;
1542
1543   elf_link_hash_traverse (&ia64_info->root,
1544                           elfNN_ia64_global_dyn_sym_thunk, &xdata);
1545   htab_traverse (ia64_info->loc_hash_table,
1546                  elfNN_ia64_local_dyn_sym_thunk, &xdata);
1547 }
1548 \f
1549 static bfd_boolean
1550 elfNN_ia64_create_dynamic_sections (bfd *abfd,
1551                                     struct bfd_link_info *info)
1552 {
1553   struct elfNN_ia64_link_hash_table *ia64_info;
1554   asection *s;
1555
1556   if (! _bfd_elf_create_dynamic_sections (abfd, info))
1557     return FALSE;
1558
1559   ia64_info = elfNN_ia64_hash_table (info);
1560   if (ia64_info == NULL)
1561     return FALSE;
1562
1563   {
1564     flagword flags = bfd_get_section_flags (abfd, ia64_info->root.sgot);
1565     bfd_set_section_flags (abfd, ia64_info->root.sgot,
1566                            SEC_SMALL_DATA | flags);
1567     /* The .got section is always aligned at 8 bytes.  */
1568     if (! bfd_set_section_alignment (abfd, ia64_info->root.sgot, 3))
1569       return FALSE;
1570   }
1571
1572   if (!get_pltoff (abfd, info, ia64_info))
1573     return FALSE;
1574
1575   s = bfd_make_section_anyway_with_flags (abfd, ".rela.IA_64.pltoff",
1576                                           (SEC_ALLOC | SEC_LOAD
1577                                            | SEC_HAS_CONTENTS
1578                                            | SEC_IN_MEMORY
1579                                            | SEC_LINKER_CREATED
1580                                            | SEC_READONLY));
1581   if (s == NULL
1582       || !bfd_set_section_alignment (abfd, s, LOG_SECTION_ALIGN))
1583     return FALSE;
1584   ia64_info->rel_pltoff_sec = s;
1585
1586   return TRUE;
1587 }
1588
1589 /* Find and/or create a hash entry for local symbol.  */
1590 static struct elfNN_ia64_local_hash_entry *
1591 get_local_sym_hash (struct elfNN_ia64_link_hash_table *ia64_info,
1592                     bfd *abfd, const Elf_Internal_Rela *rel,
1593                     bfd_boolean create)
1594 {
1595   struct elfNN_ia64_local_hash_entry e, *ret;
1596   asection *sec = abfd->sections;
1597   hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
1598                                        ELFNN_R_SYM (rel->r_info));
1599   void **slot;
1600
1601   e.id = sec->id;
1602   e.r_sym = ELFNN_R_SYM (rel->r_info);
1603   slot = htab_find_slot_with_hash (ia64_info->loc_hash_table, &e, h,
1604                                    create ? INSERT : NO_INSERT);
1605
1606   if (!slot)
1607     return NULL;
1608
1609   if (*slot)
1610     return (struct elfNN_ia64_local_hash_entry *) *slot;
1611
1612   ret = (struct elfNN_ia64_local_hash_entry *)
1613         objalloc_alloc ((struct objalloc *) ia64_info->loc_hash_memory,
1614                         sizeof (struct elfNN_ia64_local_hash_entry));
1615   if (ret)
1616     {
1617       memset (ret, 0, sizeof (*ret));
1618       ret->id = sec->id;
1619       ret->r_sym = ELFNN_R_SYM (rel->r_info);
1620       *slot = ret;
1621     }
1622   return ret;
1623 }
1624
1625 /* Used to sort elfNN_ia64_dyn_sym_info array.  */
1626
1627 static int
1628 addend_compare (const void *xp, const void *yp)
1629 {
1630   const struct elfNN_ia64_dyn_sym_info *x
1631     = (const struct elfNN_ia64_dyn_sym_info *) xp;
1632   const struct elfNN_ia64_dyn_sym_info *y
1633     = (const struct elfNN_ia64_dyn_sym_info *) yp;
1634
1635   return x->addend < y->addend ? -1 : x->addend > y->addend ? 1 : 0;
1636 }
1637
1638 /* Sort elfNN_ia64_dyn_sym_info array and remove duplicates.  */
1639
1640 static unsigned int
1641 sort_dyn_sym_info (struct elfNN_ia64_dyn_sym_info *info,
1642                    unsigned int count)
1643 {
1644   bfd_vma curr, prev, got_offset;
1645   unsigned int i, kept, dupes, diff, dest, src, len;
1646
1647   qsort (info, count, sizeof (*info), addend_compare);
1648
1649   /* Find the first duplicate.  */
1650   prev = info [0].addend;
1651   got_offset = info [0].got_offset;
1652   for (i = 1; i < count; i++)
1653     {
1654       curr = info [i].addend;
1655       if (curr == prev)
1656         {
1657           /* For duplicates, make sure that GOT_OFFSET is valid.  */
1658           if (got_offset == (bfd_vma) -1)
1659             got_offset = info [i].got_offset;
1660           break;
1661         }
1662       got_offset = info [i].got_offset;
1663       prev = curr;
1664     }
1665
1666   /* We may move a block of elements to here.  */
1667   dest = i++;
1668
1669   /* Remove duplicates.  */
1670   if (i < count)
1671     {
1672       while (i < count)
1673         {
1674           /* For duplicates, make sure that the kept one has a valid
1675              got_offset.  */
1676           kept = dest - 1;
1677           if (got_offset != (bfd_vma) -1)
1678             info [kept].got_offset = got_offset;
1679
1680           curr = info [i].addend;
1681           got_offset = info [i].got_offset;
1682
1683           /* Move a block of elements whose first one is different from
1684              the previous.  */
1685           if (curr == prev)
1686             {
1687               for (src = i + 1; src < count; src++)
1688                 {
1689                   if (info [src].addend != curr)
1690                     break;
1691                   /* For duplicates, make sure that GOT_OFFSET is
1692                      valid.  */
1693                   if (got_offset == (bfd_vma) -1)
1694                     got_offset = info [src].got_offset;
1695                 }
1696
1697               /* Make sure that the kept one has a valid got_offset.  */
1698               if (got_offset != (bfd_vma) -1)
1699                 info [kept].got_offset = got_offset;
1700             }
1701           else
1702             src = i;
1703
1704           if (src >= count)
1705             break;
1706
1707           /* Find the next duplicate.  SRC will be kept.  */
1708           prev = info [src].addend;
1709           got_offset = info [src].got_offset;
1710           for (dupes = src + 1; dupes < count; dupes ++)
1711             {
1712               curr = info [dupes].addend;
1713               if (curr == prev)
1714                 {
1715                   /* Make sure that got_offset is valid.  */
1716                   if (got_offset == (bfd_vma) -1)
1717                     got_offset = info [dupes].got_offset;
1718
1719                   /* For duplicates, make sure that the kept one has
1720                      a valid got_offset.  */
1721                   if (got_offset != (bfd_vma) -1)
1722                     info [dupes - 1].got_offset = got_offset;
1723                   break;
1724                 }
1725               got_offset = info [dupes].got_offset;
1726               prev = curr;
1727             }
1728
1729           /* How much to move.  */
1730           len = dupes - src;
1731           i = dupes + 1;
1732
1733           if (len == 1 && dupes < count)
1734             {
1735               /* If we only move 1 element, we combine it with the next
1736                  one.  There must be at least a duplicate.  Find the
1737                  next different one.  */
1738               for (diff = dupes + 1, src++; diff < count; diff++, src++)
1739                 {
1740                   if (info [diff].addend != curr)
1741                     break;
1742                   /* Make sure that got_offset is valid.  */
1743                   if (got_offset == (bfd_vma) -1)
1744                     got_offset = info [diff].got_offset;
1745                 }
1746
1747               /* Makre sure that the last duplicated one has an valid
1748                  offset.  */
1749               BFD_ASSERT (curr == prev);
1750               if (got_offset != (bfd_vma) -1)
1751                 info [diff - 1].got_offset = got_offset;
1752
1753               if (diff < count)
1754                 {
1755                   /* Find the next duplicate.  Track the current valid
1756                      offset.  */
1757                   prev = info [diff].addend;
1758                   got_offset = info [diff].got_offset;
1759                   for (dupes = diff + 1; dupes < count; dupes ++)
1760                     {
1761                       curr = info [dupes].addend;
1762                       if (curr == prev)
1763                         {
1764                           /* For duplicates, make sure that GOT_OFFSET
1765                              is valid.  */
1766                           if (got_offset == (bfd_vma) -1)
1767                             got_offset = info [dupes].got_offset;
1768                           break;
1769                         }
1770                       got_offset = info [dupes].got_offset;
1771                       prev = curr;
1772                       diff++;
1773                     }
1774
1775                   len = diff - src + 1;
1776                   i = diff + 1;
1777                 }
1778             }
1779
1780           memmove (&info [dest], &info [src], len * sizeof (*info));
1781
1782           dest += len;
1783         }
1784
1785       count = dest;
1786     }
1787   else
1788     {
1789       /* When we get here, either there is no duplicate at all or
1790          the only duplicate is the last element.  */
1791       if (dest < count)
1792         {
1793           /* If the last element is a duplicate, make sure that the
1794              kept one has a valid got_offset.  We also update count.  */
1795           if (got_offset != (bfd_vma) -1)
1796             info [dest - 1].got_offset = got_offset;
1797           count = dest;
1798         }
1799     }
1800
1801   return count;
1802 }
1803
1804 /* Find and/or create a descriptor for dynamic symbol info.  This will
1805    vary based on global or local symbol, and the addend to the reloc.
1806
1807    We don't sort when inserting.  Also, we sort and eliminate
1808    duplicates if there is an unsorted section.  Typically, this will
1809    only happen once, because we do all insertions before lookups.  We
1810    then use bsearch to do a lookup.  This also allows lookups to be
1811    fast.  So we have fast insertion (O(log N) due to duplicate check),
1812    fast lookup (O(log N)) and one sort (O(N log N) expected time).
1813    Previously, all lookups were O(N) because of the use of the linked
1814    list and also all insertions were O(N) because of the check for
1815    duplicates.  There are some complications here because the array
1816    size grows occasionally, which may add an O(N) factor, but this
1817    should be rare.  Also,  we free the excess array allocation, which
1818    requires a copy which is O(N), but this only happens once.  */
1819
1820 static struct elfNN_ia64_dyn_sym_info *
1821 get_dyn_sym_info (struct elfNN_ia64_link_hash_table *ia64_info,
1822                   struct elf_link_hash_entry *h, bfd *abfd,
1823                   const Elf_Internal_Rela *rel, bfd_boolean create)
1824 {
1825   struct elfNN_ia64_dyn_sym_info **info_p, *info, *dyn_i, key;
1826   unsigned int *count_p, *sorted_count_p, *size_p;
1827   unsigned int count, sorted_count, size;
1828   bfd_vma addend = rel ? rel->r_addend : 0;
1829   bfd_size_type amt;
1830
1831   if (h)
1832     {
1833       struct elfNN_ia64_link_hash_entry *global_h;
1834
1835       global_h = (struct elfNN_ia64_link_hash_entry *) h;
1836       info_p = &global_h->info;
1837       count_p = &global_h->count;
1838       sorted_count_p = &global_h->sorted_count;
1839       size_p = &global_h->size;
1840     }
1841   else
1842     {
1843       struct elfNN_ia64_local_hash_entry *loc_h;
1844
1845       loc_h = get_local_sym_hash (ia64_info, abfd, rel, create);
1846       if (!loc_h)
1847         {
1848           BFD_ASSERT (!create);
1849           return NULL;
1850         }
1851
1852       info_p = &loc_h->info;
1853       count_p = &loc_h->count;
1854       sorted_count_p = &loc_h->sorted_count;
1855       size_p = &loc_h->size;
1856     }
1857
1858   count = *count_p;
1859   sorted_count = *sorted_count_p;
1860   size = *size_p;
1861   info = *info_p;
1862   if (create)
1863     {
1864       /* When we create the array, we don't check for duplicates,
1865          except in the previously sorted section if one exists, and
1866          against the last inserted entry.  This allows insertions to
1867          be fast.  */
1868       if (info)
1869         {
1870           if (sorted_count)
1871             {
1872               /* Try bsearch first on the sorted section.  */
1873               key.addend = addend;
1874               dyn_i = bsearch (&key, info, sorted_count,
1875                                sizeof (*info), addend_compare);
1876
1877               if (dyn_i)
1878                 {
1879                   return dyn_i;
1880                 }
1881             }
1882
1883           /* Do a quick check for the last inserted entry.  */
1884           dyn_i = info + count - 1;
1885           if (dyn_i->addend == addend)
1886             {
1887               return dyn_i;
1888             }
1889         }
1890
1891       if (size == 0)
1892         {
1893           /* It is the very first element. We create the array of size
1894              1.  */
1895           size = 1;
1896           amt = size * sizeof (*info);
1897           info = bfd_malloc (amt);
1898         }
1899       else if (size <= count)
1900         {
1901           /* We double the array size every time when we reach the
1902              size limit.  */
1903           size += size;
1904           amt = size * sizeof (*info);
1905           info = bfd_realloc (info, amt);
1906         }
1907       else
1908         goto has_space;
1909
1910       if (info == NULL)
1911         return NULL;
1912       *size_p = size;
1913       *info_p = info;
1914
1915 has_space:
1916       /* Append the new one to the array.  */
1917       dyn_i = info + count;
1918       memset (dyn_i, 0, sizeof (*dyn_i));
1919       dyn_i->got_offset = (bfd_vma) -1;
1920       dyn_i->addend = addend;
1921
1922       /* We increment count only since the new ones are unsorted and
1923          may have duplicate.  */
1924       (*count_p)++;
1925     }
1926   else
1927     {
1928       /* It is a lookup without insertion.  Sort array if part of the
1929          array isn't sorted.  */
1930       if (count != sorted_count)
1931         {
1932           count = sort_dyn_sym_info (info, count);
1933           *count_p = count;
1934           *sorted_count_p = count;
1935         }
1936
1937       /* Free unused memory.  */
1938       if (size != count)
1939         {
1940           amt = count * sizeof (*info);
1941           info = bfd_malloc (amt);
1942           if (info != NULL)
1943             {
1944               memcpy (info, *info_p, amt);
1945               free (*info_p);
1946               *size_p = count;
1947               *info_p = info;
1948             }
1949         }
1950
1951       key.addend = addend;
1952       dyn_i = bsearch (&key, info, count,
1953                        sizeof (*info), addend_compare);
1954     }
1955
1956   return dyn_i;
1957 }
1958
1959 static asection *
1960 get_got (bfd *abfd, struct bfd_link_info *info,
1961          struct elfNN_ia64_link_hash_table *ia64_info)
1962 {
1963   asection *got;
1964   bfd *dynobj;
1965
1966   got = ia64_info->root.sgot;
1967   if (!got)
1968     {
1969       flagword flags;
1970
1971       dynobj = ia64_info->root.dynobj;
1972       if (!dynobj)
1973         ia64_info->root.dynobj = dynobj = abfd;
1974       if (!_bfd_elf_create_got_section (dynobj, info))
1975         return NULL;
1976
1977       got = ia64_info->root.sgot;
1978
1979       /* The .got section is always aligned at 8 bytes.  */
1980       if (!bfd_set_section_alignment (abfd, got, 3))
1981         return NULL;
1982
1983       flags = bfd_get_section_flags (abfd, got);
1984       if (! bfd_set_section_flags (abfd, got, SEC_SMALL_DATA | flags))
1985         return NULL;
1986     }
1987
1988   return got;
1989 }
1990
1991 /* Create function descriptor section (.opd).  This section is called .opd
1992    because it contains "official procedure descriptors".  The "official"
1993    refers to the fact that these descriptors are used when taking the address
1994    of a procedure, thus ensuring a unique address for each procedure.  */
1995
1996 static asection *
1997 get_fptr (bfd *abfd, struct bfd_link_info *info,
1998           struct elfNN_ia64_link_hash_table *ia64_info)
1999 {
2000   asection *fptr;
2001   bfd *dynobj;
2002
2003   fptr = ia64_info->fptr_sec;
2004   if (!fptr)
2005     {
2006       dynobj = ia64_info->root.dynobj;
2007       if (!dynobj)
2008         ia64_info->root.dynobj = dynobj = abfd;
2009
2010       fptr = bfd_make_section_anyway_with_flags (dynobj, ".opd",
2011                                                  (SEC_ALLOC
2012                                                   | SEC_LOAD
2013                                                   | SEC_HAS_CONTENTS
2014                                                   | SEC_IN_MEMORY
2015                                                   | (bfd_link_pie (info)
2016                                                      ? 0 : SEC_READONLY)
2017                                                   | SEC_LINKER_CREATED));
2018       if (!fptr
2019           || !bfd_set_section_alignment (abfd, fptr, 4))
2020         {
2021           BFD_ASSERT (0);
2022           return NULL;
2023         }
2024
2025       ia64_info->fptr_sec = fptr;
2026
2027       if (bfd_link_pie (info))
2028         {
2029           asection *fptr_rel;
2030           fptr_rel = bfd_make_section_anyway_with_flags (dynobj, ".rela.opd",
2031                                                          (SEC_ALLOC | SEC_LOAD
2032                                                           | SEC_HAS_CONTENTS
2033                                                           | SEC_IN_MEMORY
2034                                                           | SEC_LINKER_CREATED
2035                                                           | SEC_READONLY));
2036           if (fptr_rel == NULL
2037               || !bfd_set_section_alignment (abfd, fptr_rel,
2038                                              LOG_SECTION_ALIGN))
2039             {
2040               BFD_ASSERT (0);
2041               return NULL;
2042             }
2043
2044           ia64_info->rel_fptr_sec = fptr_rel;
2045         }
2046     }
2047
2048   return fptr;
2049 }
2050
2051 static asection *
2052 get_pltoff (bfd *abfd, struct bfd_link_info *info ATTRIBUTE_UNUSED,
2053             struct elfNN_ia64_link_hash_table *ia64_info)
2054 {
2055   asection *pltoff;
2056   bfd *dynobj;
2057
2058   pltoff = ia64_info->pltoff_sec;
2059   if (!pltoff)
2060     {
2061       dynobj = ia64_info->root.dynobj;
2062       if (!dynobj)
2063         ia64_info->root.dynobj = dynobj = abfd;
2064
2065       pltoff = bfd_make_section_anyway_with_flags (dynobj,
2066                                                    ELF_STRING_ia64_pltoff,
2067                                                    (SEC_ALLOC
2068                                                     | SEC_LOAD
2069                                                     | SEC_HAS_CONTENTS
2070                                                     | SEC_IN_MEMORY
2071                                                     | SEC_SMALL_DATA
2072                                                     | SEC_LINKER_CREATED));
2073       if (!pltoff
2074           || !bfd_set_section_alignment (abfd, pltoff, 4))
2075         {
2076           BFD_ASSERT (0);
2077           return NULL;
2078         }
2079
2080       ia64_info->pltoff_sec = pltoff;
2081     }
2082
2083   return pltoff;
2084 }
2085
2086 static asection *
2087 get_reloc_section (bfd *abfd,
2088                    struct elfNN_ia64_link_hash_table *ia64_info,
2089                    asection *sec, bfd_boolean create)
2090 {
2091   const char *srel_name;
2092   asection *srel;
2093   bfd *dynobj;
2094
2095   srel_name = (bfd_elf_string_from_elf_section
2096                (abfd, elf_elfheader(abfd)->e_shstrndx,
2097                 _bfd_elf_single_rel_hdr (sec)->sh_name));
2098   if (srel_name == NULL)
2099     return NULL;
2100
2101   dynobj = ia64_info->root.dynobj;
2102   if (!dynobj)
2103     ia64_info->root.dynobj = dynobj = abfd;
2104
2105   srel = bfd_get_linker_section (dynobj, srel_name);
2106   if (srel == NULL && create)
2107     {
2108       srel = bfd_make_section_anyway_with_flags (dynobj, srel_name,
2109                                                  (SEC_ALLOC | SEC_LOAD
2110                                                   | SEC_HAS_CONTENTS
2111                                                   | SEC_IN_MEMORY
2112                                                   | SEC_LINKER_CREATED
2113                                                   | SEC_READONLY));
2114       if (srel == NULL
2115           || !bfd_set_section_alignment (dynobj, srel,
2116                                          LOG_SECTION_ALIGN))
2117         return NULL;
2118     }
2119
2120   return srel;
2121 }
2122
2123 static bfd_boolean
2124 count_dyn_reloc (bfd *abfd, struct elfNN_ia64_dyn_sym_info *dyn_i,
2125                  asection *srel, int type, bfd_boolean reltext)
2126 {
2127   struct elfNN_ia64_dyn_reloc_entry *rent;
2128
2129   for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
2130     if (rent->srel == srel && rent->type == type)
2131       break;
2132
2133   if (!rent)
2134     {
2135       rent = ((struct elfNN_ia64_dyn_reloc_entry *)
2136               bfd_alloc (abfd, (bfd_size_type) sizeof (*rent)));
2137       if (!rent)
2138         return FALSE;
2139
2140       rent->next = dyn_i->reloc_entries;
2141       rent->srel = srel;
2142       rent->type = type;
2143       rent->count = 0;
2144       dyn_i->reloc_entries = rent;
2145     }
2146   rent->reltext = reltext;
2147   rent->count++;
2148
2149   return TRUE;
2150 }
2151
2152 static bfd_boolean
2153 elfNN_ia64_check_relocs (bfd *abfd, struct bfd_link_info *info,
2154                          asection *sec,
2155                          const Elf_Internal_Rela *relocs)
2156 {
2157   struct elfNN_ia64_link_hash_table *ia64_info;
2158   const Elf_Internal_Rela *relend;
2159   Elf_Internal_Shdr *symtab_hdr;
2160   const Elf_Internal_Rela *rel;
2161   asection *got, *fptr, *srel, *pltoff;
2162   enum {
2163     NEED_GOT = 1,
2164     NEED_GOTX = 2,
2165     NEED_FPTR = 4,
2166     NEED_PLTOFF = 8,
2167     NEED_MIN_PLT = 16,
2168     NEED_FULL_PLT = 32,
2169     NEED_DYNREL = 64,
2170     NEED_LTOFF_FPTR = 128,
2171     NEED_TPREL = 256,
2172     NEED_DTPMOD = 512,
2173     NEED_DTPREL = 1024
2174   };
2175   int need_entry;
2176   struct elf_link_hash_entry *h;
2177   unsigned long r_symndx;
2178   bfd_boolean maybe_dynamic;
2179
2180   if (bfd_link_relocatable (info))
2181     return TRUE;
2182
2183   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2184   ia64_info = elfNN_ia64_hash_table (info);
2185   if (ia64_info == NULL)
2186     return FALSE;
2187
2188   got = fptr = srel = pltoff = NULL;
2189
2190   relend = relocs + sec->reloc_count;
2191
2192   /* We scan relocations first to create dynamic relocation arrays.  We
2193      modified get_dyn_sym_info to allow fast insertion and support fast
2194      lookup in the next loop.  */
2195   for (rel = relocs; rel < relend; ++rel)
2196     {
2197       r_symndx = ELFNN_R_SYM (rel->r_info);
2198       if (r_symndx >= symtab_hdr->sh_info)
2199         {
2200           long indx = r_symndx - symtab_hdr->sh_info;
2201           h = elf_sym_hashes (abfd)[indx];
2202           while (h->root.type == bfd_link_hash_indirect
2203                  || h->root.type == bfd_link_hash_warning)
2204             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2205         }
2206       else
2207         h = NULL;
2208
2209       if (h && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
2210         continue;
2211
2212       /* We can only get preliminary data on whether a symbol is
2213          locally or externally defined, as not all of the input files
2214          have yet been processed.  Do something with what we know, as
2215          this may help reduce memory usage and processing time later.  */
2216       maybe_dynamic = (h && ((!bfd_link_executable (info)
2217                               && (!SYMBOLIC_BIND (info, h)
2218                                   || info->unresolved_syms_in_shared_libs == RM_IGNORE))
2219                              || !h->def_regular
2220                              || h->root.type == bfd_link_hash_defweak));
2221
2222       need_entry = 0;
2223       switch (ELFNN_R_TYPE (rel->r_info))
2224         {
2225         case R_IA64_TPREL64MSB:
2226         case R_IA64_TPREL64LSB:
2227           if (bfd_link_pic (info) || maybe_dynamic)
2228             need_entry = NEED_DYNREL;
2229           break;
2230
2231         case R_IA64_LTOFF_TPREL22:
2232           need_entry = NEED_TPREL;
2233           if (bfd_link_pic (info))
2234             info->flags |= DF_STATIC_TLS;
2235           break;
2236
2237         case R_IA64_DTPREL32MSB:
2238         case R_IA64_DTPREL32LSB:
2239         case R_IA64_DTPREL64MSB:
2240         case R_IA64_DTPREL64LSB:
2241           if (bfd_link_pic (info) || maybe_dynamic)
2242             need_entry = NEED_DYNREL;
2243           break;
2244
2245         case R_IA64_LTOFF_DTPREL22:
2246           need_entry = NEED_DTPREL;
2247           break;
2248
2249         case R_IA64_DTPMOD64MSB:
2250         case R_IA64_DTPMOD64LSB:
2251           if (bfd_link_pic (info) || maybe_dynamic)
2252             need_entry = NEED_DYNREL;
2253           break;
2254
2255         case R_IA64_LTOFF_DTPMOD22:
2256           need_entry = NEED_DTPMOD;
2257           break;
2258
2259         case R_IA64_LTOFF_FPTR22:
2260         case R_IA64_LTOFF_FPTR64I:
2261         case R_IA64_LTOFF_FPTR32MSB:
2262         case R_IA64_LTOFF_FPTR32LSB:
2263         case R_IA64_LTOFF_FPTR64MSB:
2264         case R_IA64_LTOFF_FPTR64LSB:
2265           need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR;
2266           break;
2267
2268         case R_IA64_FPTR64I:
2269         case R_IA64_FPTR32MSB:
2270         case R_IA64_FPTR32LSB:
2271         case R_IA64_FPTR64MSB:
2272         case R_IA64_FPTR64LSB:
2273           if (bfd_link_pic (info) || h)
2274             need_entry = NEED_FPTR | NEED_DYNREL;
2275           else
2276             need_entry = NEED_FPTR;
2277           break;
2278
2279         case R_IA64_LTOFF22:
2280         case R_IA64_LTOFF64I:
2281           need_entry = NEED_GOT;
2282           break;
2283
2284         case R_IA64_LTOFF22X:
2285           need_entry = NEED_GOTX;
2286           break;
2287
2288         case R_IA64_PLTOFF22:
2289         case R_IA64_PLTOFF64I:
2290         case R_IA64_PLTOFF64MSB:
2291         case R_IA64_PLTOFF64LSB:
2292           need_entry = NEED_PLTOFF;
2293           if (h)
2294             {
2295               if (maybe_dynamic)
2296                 need_entry |= NEED_MIN_PLT;
2297             }
2298           else
2299             {
2300               (*info->callbacks->warning)
2301                 (info, _("@pltoff reloc against local symbol"), 0,
2302                  abfd, 0, (bfd_vma) 0);
2303             }
2304           break;
2305
2306         case R_IA64_PCREL21B:
2307         case R_IA64_PCREL60B:
2308           /* Depending on where this symbol is defined, we may or may not
2309              need a full plt entry.  Only skip if we know we'll not need
2310              the entry -- static or symbolic, and the symbol definition
2311              has already been seen.  */
2312           if (maybe_dynamic && rel->r_addend == 0)
2313             need_entry = NEED_FULL_PLT;
2314           break;
2315
2316         case R_IA64_IMM14:
2317         case R_IA64_IMM22:
2318         case R_IA64_IMM64:
2319         case R_IA64_DIR32MSB:
2320         case R_IA64_DIR32LSB:
2321         case R_IA64_DIR64MSB:
2322         case R_IA64_DIR64LSB:
2323           /* Shared objects will always need at least a REL relocation.  */
2324           if (bfd_link_pic (info) || maybe_dynamic)
2325             need_entry = NEED_DYNREL;
2326           break;
2327
2328         case R_IA64_IPLTMSB:
2329         case R_IA64_IPLTLSB:
2330           /* Shared objects will always need at least a REL relocation.  */
2331           if (bfd_link_pic (info) || maybe_dynamic)
2332             need_entry = NEED_DYNREL;
2333           break;
2334
2335         case R_IA64_PCREL22:
2336         case R_IA64_PCREL64I:
2337         case R_IA64_PCREL32MSB:
2338         case R_IA64_PCREL32LSB:
2339         case R_IA64_PCREL64MSB:
2340         case R_IA64_PCREL64LSB:
2341           if (maybe_dynamic)
2342             need_entry = NEED_DYNREL;
2343           break;
2344         }
2345
2346       if (!need_entry)
2347         continue;
2348
2349       if ((need_entry & NEED_FPTR) != 0
2350           && rel->r_addend)
2351         {
2352           (*info->callbacks->warning)
2353             (info, _("non-zero addend in @fptr reloc"), 0,
2354              abfd, 0, (bfd_vma) 0);
2355         }
2356
2357       if (get_dyn_sym_info (ia64_info, h, abfd, rel, TRUE) == NULL)
2358         return FALSE;
2359     }
2360
2361   /* Now, we only do lookup without insertion, which is very fast
2362      with the modified get_dyn_sym_info.  */
2363   for (rel = relocs; rel < relend; ++rel)
2364     {
2365       struct elfNN_ia64_dyn_sym_info *dyn_i;
2366       int dynrel_type = R_IA64_NONE;
2367
2368       r_symndx = ELFNN_R_SYM (rel->r_info);
2369       if (r_symndx >= symtab_hdr->sh_info)
2370         {
2371           /* We're dealing with a global symbol -- find its hash entry
2372              and mark it as being referenced.  */
2373           long indx = r_symndx - symtab_hdr->sh_info;
2374           h = elf_sym_hashes (abfd)[indx];
2375           while (h->root.type == bfd_link_hash_indirect
2376                  || h->root.type == bfd_link_hash_warning)
2377             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2378
2379           /* PR15323, ref flags aren't set for references in the same
2380              object.  */
2381           h->ref_regular = 1;
2382         }
2383       else
2384         h = NULL;
2385
2386       if (h && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
2387         continue;
2388
2389       /* We can only get preliminary data on whether a symbol is
2390          locally or externally defined, as not all of the input files
2391          have yet been processed.  Do something with what we know, as
2392          this may help reduce memory usage and processing time later.  */
2393       maybe_dynamic = (h && ((!bfd_link_executable (info)
2394                               && (!SYMBOLIC_BIND (info, h)
2395                                   || info->unresolved_syms_in_shared_libs == RM_IGNORE))
2396                              || !h->def_regular
2397                              || h->root.type == bfd_link_hash_defweak));
2398
2399       need_entry = 0;
2400       switch (ELFNN_R_TYPE (rel->r_info))
2401         {
2402         case R_IA64_TPREL64MSB:
2403         case R_IA64_TPREL64LSB:
2404           if (bfd_link_pic (info) || maybe_dynamic)
2405             need_entry = NEED_DYNREL;
2406           dynrel_type = R_IA64_TPREL64LSB;
2407           if (bfd_link_pic (info))
2408             info->flags |= DF_STATIC_TLS;
2409           break;
2410
2411         case R_IA64_LTOFF_TPREL22:
2412           need_entry = NEED_TPREL;
2413           if (bfd_link_pic (info))
2414             info->flags |= DF_STATIC_TLS;
2415           break;
2416
2417         case R_IA64_DTPREL32MSB:
2418         case R_IA64_DTPREL32LSB:
2419         case R_IA64_DTPREL64MSB:
2420         case R_IA64_DTPREL64LSB:
2421           if (bfd_link_pic (info) || maybe_dynamic)
2422             need_entry = NEED_DYNREL;
2423           dynrel_type = R_IA64_DTPRELNNLSB;
2424           break;
2425
2426         case R_IA64_LTOFF_DTPREL22:
2427           need_entry = NEED_DTPREL;
2428           break;
2429
2430         case R_IA64_DTPMOD64MSB:
2431         case R_IA64_DTPMOD64LSB:
2432           if (bfd_link_pic (info) || maybe_dynamic)
2433             need_entry = NEED_DYNREL;
2434           dynrel_type = R_IA64_DTPMOD64LSB;
2435           break;
2436
2437         case R_IA64_LTOFF_DTPMOD22:
2438           need_entry = NEED_DTPMOD;
2439           break;
2440
2441         case R_IA64_LTOFF_FPTR22:
2442         case R_IA64_LTOFF_FPTR64I:
2443         case R_IA64_LTOFF_FPTR32MSB:
2444         case R_IA64_LTOFF_FPTR32LSB:
2445         case R_IA64_LTOFF_FPTR64MSB:
2446         case R_IA64_LTOFF_FPTR64LSB:
2447           need_entry = NEED_FPTR | NEED_GOT | NEED_LTOFF_FPTR;
2448           break;
2449
2450         case R_IA64_FPTR64I:
2451         case R_IA64_FPTR32MSB:
2452         case R_IA64_FPTR32LSB:
2453         case R_IA64_FPTR64MSB:
2454         case R_IA64_FPTR64LSB:
2455           if (bfd_link_pic (info) || h)
2456             need_entry = NEED_FPTR | NEED_DYNREL;
2457           else
2458             need_entry = NEED_FPTR;
2459           dynrel_type = R_IA64_FPTRNNLSB;
2460           break;
2461
2462         case R_IA64_LTOFF22:
2463         case R_IA64_LTOFF64I:
2464           need_entry = NEED_GOT;
2465           break;
2466
2467         case R_IA64_LTOFF22X:
2468           need_entry = NEED_GOTX;
2469           break;
2470
2471         case R_IA64_PLTOFF22:
2472         case R_IA64_PLTOFF64I:
2473         case R_IA64_PLTOFF64MSB:
2474         case R_IA64_PLTOFF64LSB:
2475           need_entry = NEED_PLTOFF;
2476           if (h)
2477             {
2478               if (maybe_dynamic)
2479                 need_entry |= NEED_MIN_PLT;
2480             }
2481           break;
2482
2483         case R_IA64_PCREL21B:
2484         case R_IA64_PCREL60B:
2485           /* Depending on where this symbol is defined, we may or may not
2486              need a full plt entry.  Only skip if we know we'll not need
2487              the entry -- static or symbolic, and the symbol definition
2488              has already been seen.  */
2489           if (maybe_dynamic && rel->r_addend == 0)
2490             need_entry = NEED_FULL_PLT;
2491           break;
2492
2493         case R_IA64_IMM14:
2494         case R_IA64_IMM22:
2495         case R_IA64_IMM64:
2496         case R_IA64_DIR32MSB:
2497         case R_IA64_DIR32LSB:
2498         case R_IA64_DIR64MSB:
2499         case R_IA64_DIR64LSB:
2500           /* Shared objects will always need at least a REL relocation.  */
2501           if (bfd_link_pic (info) || maybe_dynamic)
2502             need_entry = NEED_DYNREL;
2503           dynrel_type = R_IA64_DIRNNLSB;
2504           break;
2505
2506         case R_IA64_IPLTMSB:
2507         case R_IA64_IPLTLSB:
2508           /* Shared objects will always need at least a REL relocation.  */
2509           if (bfd_link_pic (info) || maybe_dynamic)
2510             need_entry = NEED_DYNREL;
2511           dynrel_type = R_IA64_IPLTLSB;
2512           break;
2513
2514         case R_IA64_PCREL22:
2515         case R_IA64_PCREL64I:
2516         case R_IA64_PCREL32MSB:
2517         case R_IA64_PCREL32LSB:
2518         case R_IA64_PCREL64MSB:
2519         case R_IA64_PCREL64LSB:
2520           if (maybe_dynamic)
2521             need_entry = NEED_DYNREL;
2522           dynrel_type = R_IA64_PCRELNNLSB;
2523           break;
2524         }
2525
2526       if (!need_entry)
2527         continue;
2528
2529       dyn_i = get_dyn_sym_info (ia64_info, h, abfd, rel, FALSE);
2530
2531       /* Record whether or not this is a local symbol.  */
2532       dyn_i->h = h;
2533
2534       /* Create what's needed.  */
2535       if (need_entry & (NEED_GOT | NEED_GOTX | NEED_TPREL
2536                         | NEED_DTPMOD | NEED_DTPREL))
2537         {
2538           if (!got)
2539             {
2540               got = get_got (abfd, info, ia64_info);
2541               if (!got)
2542                 return FALSE;
2543             }
2544           if (need_entry & NEED_GOT)
2545             dyn_i->want_got = 1;
2546           if (need_entry & NEED_GOTX)
2547             dyn_i->want_gotx = 1;
2548           if (need_entry & NEED_TPREL)
2549             dyn_i->want_tprel = 1;
2550           if (need_entry & NEED_DTPMOD)
2551             dyn_i->want_dtpmod = 1;
2552           if (need_entry & NEED_DTPREL)
2553             dyn_i->want_dtprel = 1;
2554         }
2555       if (need_entry & NEED_FPTR)
2556         {
2557           if (!fptr)
2558             {
2559               fptr = get_fptr (abfd, info, ia64_info);
2560               if (!fptr)
2561                 return FALSE;
2562             }
2563
2564           /* FPTRs for shared libraries are allocated by the dynamic
2565              linker.  Make sure this local symbol will appear in the
2566              dynamic symbol table.  */
2567           if (!h && bfd_link_pic (info))
2568             {
2569               if (! (bfd_elf_link_record_local_dynamic_symbol
2570                      (info, abfd, (long) r_symndx)))
2571                 return FALSE;
2572             }
2573
2574           dyn_i->want_fptr = 1;
2575         }
2576       if (need_entry & NEED_LTOFF_FPTR)
2577         dyn_i->want_ltoff_fptr = 1;
2578       if (need_entry & (NEED_MIN_PLT | NEED_FULL_PLT))
2579         {
2580           if (!ia64_info->root.dynobj)
2581             ia64_info->root.dynobj = abfd;
2582           h->needs_plt = 1;
2583           dyn_i->want_plt = 1;
2584         }
2585       if (need_entry & NEED_FULL_PLT)
2586         dyn_i->want_plt2 = 1;
2587       if (need_entry & NEED_PLTOFF)
2588         {
2589           /* This is needed here, in case @pltoff is used in a non-shared
2590              link.  */
2591           if (!pltoff)
2592             {
2593               pltoff = get_pltoff (abfd, info, ia64_info);
2594               if (!pltoff)
2595                 return FALSE;
2596             }
2597
2598           dyn_i->want_pltoff = 1;
2599         }
2600       if ((need_entry & NEED_DYNREL) && (sec->flags & SEC_ALLOC))
2601         {
2602           if (!srel)
2603             {
2604               srel = get_reloc_section (abfd, ia64_info, sec, TRUE);
2605               if (!srel)
2606                 return FALSE;
2607             }
2608           if (!count_dyn_reloc (abfd, dyn_i, srel, dynrel_type,
2609                                 (sec->flags & SEC_READONLY) != 0))
2610             return FALSE;
2611         }
2612     }
2613
2614   return TRUE;
2615 }
2616
2617 /* For cleanliness, and potentially faster dynamic loading, allocate
2618    external GOT entries first.  */
2619
2620 static bfd_boolean
2621 allocate_global_data_got (struct elfNN_ia64_dyn_sym_info *dyn_i,
2622                           void * data)
2623 {
2624   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2625
2626   if ((dyn_i->want_got || dyn_i->want_gotx)
2627       && ! dyn_i->want_fptr
2628       && elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
2629      {
2630        dyn_i->got_offset = x->ofs;
2631        x->ofs += 8;
2632      }
2633   if (dyn_i->want_tprel)
2634     {
2635       dyn_i->tprel_offset = x->ofs;
2636       x->ofs += 8;
2637     }
2638   if (dyn_i->want_dtpmod)
2639     {
2640       if (elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
2641         {
2642           dyn_i->dtpmod_offset = x->ofs;
2643           x->ofs += 8;
2644         }
2645       else
2646         {
2647           struct elfNN_ia64_link_hash_table *ia64_info;
2648
2649           ia64_info = elfNN_ia64_hash_table (x->info);
2650           if (ia64_info == NULL)
2651             return FALSE;
2652
2653           if (ia64_info->self_dtpmod_offset == (bfd_vma) -1)
2654             {
2655               ia64_info->self_dtpmod_offset = x->ofs;
2656               x->ofs += 8;
2657             }
2658           dyn_i->dtpmod_offset = ia64_info->self_dtpmod_offset;
2659         }
2660     }
2661   if (dyn_i->want_dtprel)
2662     {
2663       dyn_i->dtprel_offset = x->ofs;
2664       x->ofs += 8;
2665     }
2666   return TRUE;
2667 }
2668
2669 /* Next, allocate all the GOT entries used by LTOFF_FPTR relocs.  */
2670
2671 static bfd_boolean
2672 allocate_global_fptr_got (struct elfNN_ia64_dyn_sym_info *dyn_i,
2673                           void * data)
2674 {
2675   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2676
2677   if (dyn_i->want_got
2678       && dyn_i->want_fptr
2679       && elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, R_IA64_FPTRNNLSB))
2680     {
2681       dyn_i->got_offset = x->ofs;
2682       x->ofs += 8;
2683     }
2684   return TRUE;
2685 }
2686
2687 /* Lastly, allocate all the GOT entries for local data.  */
2688
2689 static bfd_boolean
2690 allocate_local_got (struct elfNN_ia64_dyn_sym_info *dyn_i,
2691                     void * data)
2692 {
2693   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2694
2695   if ((dyn_i->want_got || dyn_i->want_gotx)
2696       && !elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0))
2697     {
2698       dyn_i->got_offset = x->ofs;
2699       x->ofs += 8;
2700     }
2701   return TRUE;
2702 }
2703
2704 /* Search for the index of a global symbol in it's defining object file.  */
2705
2706 static long
2707 global_sym_index (struct elf_link_hash_entry *h)
2708 {
2709   struct elf_link_hash_entry **p;
2710   bfd *obj;
2711
2712   BFD_ASSERT (h->root.type == bfd_link_hash_defined
2713               || h->root.type == bfd_link_hash_defweak);
2714
2715   obj = h->root.u.def.section->owner;
2716   for (p = elf_sym_hashes (obj); *p != h; ++p)
2717     continue;
2718
2719   return p - elf_sym_hashes (obj) + elf_tdata (obj)->symtab_hdr.sh_info;
2720 }
2721
2722 /* Allocate function descriptors.  We can do these for every function
2723    in a main executable that is not exported.  */
2724
2725 static bfd_boolean
2726 allocate_fptr (struct elfNN_ia64_dyn_sym_info *dyn_i, void * data)
2727 {
2728   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2729
2730   if (dyn_i->want_fptr)
2731     {
2732       struct elf_link_hash_entry *h = dyn_i->h;
2733
2734       if (h)
2735         while (h->root.type == bfd_link_hash_indirect
2736                || h->root.type == bfd_link_hash_warning)
2737           h = (struct elf_link_hash_entry *) h->root.u.i.link;
2738
2739       if (!bfd_link_executable (x->info)
2740           && (!h
2741               || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2742                   && !UNDEFWEAK_NO_DYNAMIC_RELOC (x->info, h))
2743               || (h->root.type != bfd_link_hash_undefweak
2744                   && h->root.type != bfd_link_hash_undefined)))
2745         {
2746           if (h && h->dynindx == -1)
2747             {
2748               BFD_ASSERT ((h->root.type == bfd_link_hash_defined)
2749                           || (h->root.type == bfd_link_hash_defweak));
2750
2751               if (!bfd_elf_link_record_local_dynamic_symbol
2752                     (x->info, h->root.u.def.section->owner,
2753                      global_sym_index (h)))
2754                 return FALSE;
2755             }
2756
2757           dyn_i->want_fptr = 0;
2758         }
2759       else if (h == NULL || h->dynindx == -1)
2760         {
2761           dyn_i->fptr_offset = x->ofs;
2762           x->ofs += 16;
2763         }
2764       else
2765         dyn_i->want_fptr = 0;
2766     }
2767   return TRUE;
2768 }
2769
2770 /* Allocate all the minimal PLT entries.  */
2771
2772 static bfd_boolean
2773 allocate_plt_entries (struct elfNN_ia64_dyn_sym_info *dyn_i,
2774                       void * data)
2775 {
2776   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2777
2778   if (dyn_i->want_plt)
2779     {
2780       struct elf_link_hash_entry *h = dyn_i->h;
2781
2782       if (h)
2783         while (h->root.type == bfd_link_hash_indirect
2784                || h->root.type == bfd_link_hash_warning)
2785           h = (struct elf_link_hash_entry *) h->root.u.i.link;
2786
2787       /* ??? Versioned symbols seem to lose NEEDS_PLT.  */
2788       if (elfNN_ia64_dynamic_symbol_p (h, x->info, 0))
2789         {
2790           bfd_size_type offset = x->ofs;
2791           if (offset == 0)
2792             offset = PLT_HEADER_SIZE;
2793           dyn_i->plt_offset = offset;
2794           x->ofs = offset + PLT_MIN_ENTRY_SIZE;
2795
2796           dyn_i->want_pltoff = 1;
2797         }
2798       else
2799         {
2800           dyn_i->want_plt = 0;
2801           dyn_i->want_plt2 = 0;
2802         }
2803     }
2804   return TRUE;
2805 }
2806
2807 /* Allocate all the full PLT entries.  */
2808
2809 static bfd_boolean
2810 allocate_plt2_entries (struct elfNN_ia64_dyn_sym_info *dyn_i,
2811                        void * data)
2812 {
2813   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2814
2815   if (dyn_i->want_plt2)
2816     {
2817       struct elf_link_hash_entry *h = dyn_i->h;
2818       bfd_size_type ofs = x->ofs;
2819
2820       dyn_i->plt2_offset = ofs;
2821       x->ofs = ofs + PLT_FULL_ENTRY_SIZE;
2822
2823       while (h->root.type == bfd_link_hash_indirect
2824              || h->root.type == bfd_link_hash_warning)
2825         h = (struct elf_link_hash_entry *) h->root.u.i.link;
2826       dyn_i->h->plt.offset = ofs;
2827     }
2828   return TRUE;
2829 }
2830
2831 /* Allocate all the PLTOFF entries requested by relocations and
2832    plt entries.  We can't share space with allocated FPTR entries,
2833    because the latter are not necessarily addressable by the GP.
2834    ??? Relaxation might be able to determine that they are.  */
2835
2836 static bfd_boolean
2837 allocate_pltoff_entries (struct elfNN_ia64_dyn_sym_info *dyn_i,
2838                          void * data)
2839 {
2840   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2841
2842   if (dyn_i->want_pltoff)
2843     {
2844       dyn_i->pltoff_offset = x->ofs;
2845       x->ofs += 16;
2846     }
2847   return TRUE;
2848 }
2849
2850 /* Allocate dynamic relocations for those symbols that turned out
2851    to be dynamic.  */
2852
2853 static bfd_boolean
2854 allocate_dynrel_entries (struct elfNN_ia64_dyn_sym_info *dyn_i,
2855                          void * data)
2856 {
2857   struct elfNN_ia64_allocate_data *x = (struct elfNN_ia64_allocate_data *)data;
2858   struct elfNN_ia64_link_hash_table *ia64_info;
2859   struct elfNN_ia64_dyn_reloc_entry *rent;
2860   bfd_boolean dynamic_symbol, shared, resolved_zero;
2861
2862   ia64_info = elfNN_ia64_hash_table (x->info);
2863   if (ia64_info == NULL)
2864     return FALSE;
2865
2866   /* Note that this can't be used in relation to FPTR relocs below.  */
2867   dynamic_symbol = elfNN_ia64_dynamic_symbol_p (dyn_i->h, x->info, 0);
2868
2869   shared = bfd_link_pic (x->info);
2870   resolved_zero = (dyn_i->h
2871                    && UNDEFWEAK_NO_DYNAMIC_RELOC (x->info,
2872                                                        dyn_i->h));
2873
2874   /* Take care of the GOT and PLT relocations.  */
2875
2876   if ((!resolved_zero
2877        && (dynamic_symbol || shared)
2878        && (dyn_i->want_got || dyn_i->want_gotx))
2879       || (dyn_i->want_ltoff_fptr
2880           && dyn_i->h
2881           && dyn_i->h->dynindx != -1))
2882     {
2883       if (!dyn_i->want_ltoff_fptr
2884           || !bfd_link_pie (x->info)
2885           || dyn_i->h == NULL
2886           || dyn_i->h->root.type != bfd_link_hash_undefweak)
2887         ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela);
2888     }
2889   if ((dynamic_symbol || shared) && dyn_i->want_tprel)
2890     ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela);
2891   if (dynamic_symbol && dyn_i->want_dtpmod)
2892     ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela);
2893   if (dynamic_symbol && dyn_i->want_dtprel)
2894     ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela);
2895
2896   if (x->only_got)
2897     return TRUE;
2898
2899   if (ia64_info->rel_fptr_sec && dyn_i->want_fptr)
2900     {
2901       if (dyn_i->h == NULL || dyn_i->h->root.type != bfd_link_hash_undefweak)
2902         ia64_info->rel_fptr_sec->size += sizeof (ElfNN_External_Rela);
2903     }
2904
2905   if (!resolved_zero && dyn_i->want_pltoff)
2906     {
2907       bfd_size_type t = 0;
2908
2909       /* Dynamic symbols get one IPLT relocation.  Local symbols in
2910          shared libraries get two REL relocations.  Local symbols in
2911          main applications get nothing.  */
2912       if (dynamic_symbol)
2913         t = sizeof (ElfNN_External_Rela);
2914       else if (shared)
2915         t = 2 * sizeof (ElfNN_External_Rela);
2916
2917       ia64_info->rel_pltoff_sec->size += t;
2918     }
2919
2920   /* Take care of the normal data relocations.  */
2921
2922   for (rent = dyn_i->reloc_entries; rent; rent = rent->next)
2923     {
2924       int count = rent->count;
2925
2926       switch (rent->type)
2927         {
2928         case R_IA64_FPTR32LSB:
2929         case R_IA64_FPTR64LSB:
2930           /* Allocate one iff !want_fptr and not PIE, which by this point
2931              will be true only if we're actually allocating one statically
2932              in the main executable.  Position independent executables
2933              need a relative reloc.  */
2934           if (dyn_i->want_fptr && !bfd_link_pie (x->info))
2935             continue;
2936           break;
2937         case R_IA64_PCREL32LSB:
2938         case R_IA64_PCREL64LSB:
2939           if (!dynamic_symbol)
2940             continue;
2941           break;
2942         case R_IA64_DIR32LSB:
2943         case R_IA64_DIR64LSB:
2944           if (!dynamic_symbol && !shared)
2945             continue;
2946           break;
2947         case R_IA64_IPLTLSB:
2948           if (!dynamic_symbol && !shared)
2949             continue;
2950           /* Use two REL relocations for IPLT relocations
2951              against local symbols.  */
2952           if (!dynamic_symbol)
2953             count *= 2;
2954           break;
2955         case R_IA64_DTPREL32LSB:
2956         case R_IA64_TPREL64LSB:
2957         case R_IA64_DTPREL64LSB:
2958         case R_IA64_DTPMOD64LSB:
2959           break;
2960         default:
2961           abort ();
2962         }
2963       if (rent->reltext)
2964         ia64_info->reltext = 1;
2965       rent->srel->size += sizeof (ElfNN_External_Rela) * count;
2966     }
2967
2968   return TRUE;
2969 }
2970
2971 static bfd_boolean
2972 elfNN_ia64_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
2973                                   struct elf_link_hash_entry *h)
2974 {
2975   /* ??? Undefined symbols with PLT entries should be re-defined
2976      to be the PLT entry.  */
2977
2978   /* If this is a weak symbol, and there is a real definition, the
2979      processor independent code will have arranged for us to see the
2980      real definition first, and we can just use the same value.  */
2981   if (h->is_weakalias)
2982     {
2983       struct elf_link_hash_entry *def = weakdef (h);
2984       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
2985       h->root.u.def.section = def->root.u.def.section;
2986       h->root.u.def.value = def->root.u.def.value;
2987       return TRUE;
2988     }
2989
2990   /* If this is a reference to a symbol defined by a dynamic object which
2991      is not a function, we might allocate the symbol in our .dynbss section
2992      and allocate a COPY dynamic relocation.
2993
2994      But IA-64 code is canonically PIC, so as a rule we can avoid this sort
2995      of hackery.  */
2996
2997   return TRUE;
2998 }
2999
3000 static bfd_boolean
3001 elfNN_ia64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
3002                                   struct bfd_link_info *info)
3003 {
3004   struct elfNN_ia64_allocate_data data;
3005   struct elfNN_ia64_link_hash_table *ia64_info;
3006   asection *sec;
3007   bfd *dynobj;
3008   bfd_boolean relplt = FALSE;
3009
3010   ia64_info = elfNN_ia64_hash_table (info);
3011   if (ia64_info == NULL)
3012     return FALSE;
3013   dynobj = ia64_info->root.dynobj;
3014   ia64_info->self_dtpmod_offset = (bfd_vma) -1;
3015   BFD_ASSERT(dynobj != NULL);
3016   data.info = info;
3017
3018   /* Set the contents of the .interp section to the interpreter.  */
3019   if (ia64_info->root.dynamic_sections_created
3020       && bfd_link_executable (info) && !info->nointerp)
3021     {
3022       sec = bfd_get_linker_section (dynobj, ".interp");
3023       BFD_ASSERT (sec != NULL);
3024       sec->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
3025       sec->size = strlen (ELF_DYNAMIC_INTERPRETER) + 1;
3026     }
3027
3028   /* Allocate the GOT entries.  */
3029
3030   if (ia64_info->root.sgot)
3031     {
3032       data.ofs = 0;
3033       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_data_got, &data);
3034       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_global_fptr_got, &data);
3035       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_local_got, &data);
3036       ia64_info->root.sgot->size = data.ofs;
3037     }
3038
3039   /* Allocate the FPTR entries.  */
3040
3041   if (ia64_info->fptr_sec)
3042     {
3043       data.ofs = 0;
3044       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_fptr, &data);
3045       ia64_info->fptr_sec->size = data.ofs;
3046     }
3047
3048   /* Now that we've seen all of the input files, we can decide which
3049      symbols need plt entries.  Allocate the minimal PLT entries first.
3050      We do this even though dynamic_sections_created may be FALSE, because
3051      this has the side-effect of clearing want_plt and want_plt2.  */
3052
3053   data.ofs = 0;
3054   elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_plt_entries, &data);
3055
3056   ia64_info->minplt_entries = 0;
3057   if (data.ofs)
3058     {
3059       ia64_info->minplt_entries
3060         = (data.ofs - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
3061     }
3062
3063   /* Align the pointer for the plt2 entries.  */
3064   data.ofs = (data.ofs + 31) & (bfd_vma) -32;
3065
3066   elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_plt2_entries, &data);
3067   if (data.ofs != 0 || ia64_info->root.dynamic_sections_created)
3068     {
3069       /* FIXME: we always reserve the memory for dynamic linker even if
3070          there are no PLT entries since dynamic linker may assume the
3071          reserved memory always exists.  */
3072
3073       BFD_ASSERT (ia64_info->root.dynamic_sections_created);
3074
3075       ia64_info->root.splt->size = data.ofs;
3076
3077       /* If we've got a .plt, we need some extra memory for the dynamic
3078          linker.  We stuff these in .got.plt.  */
3079       ia64_info->root.sgotplt->size = 8 * PLT_RESERVED_WORDS;
3080     }
3081
3082   /* Allocate the PLTOFF entries.  */
3083
3084   if (ia64_info->pltoff_sec)
3085     {
3086       data.ofs = 0;
3087       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_pltoff_entries, &data);
3088       ia64_info->pltoff_sec->size = data.ofs;
3089     }
3090
3091   if (ia64_info->root.dynamic_sections_created)
3092     {
3093       /* Allocate space for the dynamic relocations that turned out to be
3094          required.  */
3095
3096       if (bfd_link_pic (info) && ia64_info->self_dtpmod_offset != (bfd_vma) -1)
3097         ia64_info->root.srelgot->size += sizeof (ElfNN_External_Rela);
3098       data.only_got = FALSE;
3099       elfNN_ia64_dyn_sym_traverse (ia64_info, allocate_dynrel_entries, &data);
3100     }
3101
3102   /* We have now determined the sizes of the various dynamic sections.
3103      Allocate memory for them.  */
3104   for (sec = dynobj->sections; sec != NULL; sec = sec->next)
3105     {
3106       bfd_boolean strip;
3107
3108       if (!(sec->flags & SEC_LINKER_CREATED))
3109         continue;
3110
3111       /* If we don't need this section, strip it from the output file.
3112          There were several sections primarily related to dynamic
3113          linking that must be create before the linker maps input
3114          sections to output sections.  The linker does that before
3115          bfd_elf_size_dynamic_sections is called, and it is that
3116          function which decides whether anything needs to go into
3117          these sections.  */
3118
3119       strip = (sec->size == 0);
3120
3121       if (sec == ia64_info->root.sgot)
3122         strip = FALSE;
3123       else if (sec == ia64_info->root.srelgot)
3124         {
3125           if (strip)
3126             ia64_info->root.srelgot = NULL;
3127           else
3128             /* We use the reloc_count field as a counter if we need to
3129                copy relocs into the output file.  */
3130             sec->reloc_count = 0;
3131         }
3132       else if (sec == ia64_info->fptr_sec)
3133         {
3134           if (strip)
3135             ia64_info->fptr_sec = NULL;
3136         }
3137       else if (sec == ia64_info->rel_fptr_sec)
3138         {
3139           if (strip)
3140             ia64_info->rel_fptr_sec = NULL;
3141           else
3142             /* We use the reloc_count field as a counter if we need to
3143                copy relocs into the output file.  */
3144             sec->reloc_count = 0;
3145         }
3146       else if (sec == ia64_info->root.splt)
3147         {
3148           if (strip)
3149             ia64_info->root.splt = NULL;
3150         }
3151       else if (sec == ia64_info->pltoff_sec)
3152         {
3153           if (strip)
3154             ia64_info->pltoff_sec = NULL;
3155         }
3156       else if (sec == ia64_info->rel_pltoff_sec)
3157         {
3158           if (strip)
3159             ia64_info->rel_pltoff_sec = NULL;
3160           else
3161             {
3162               relplt = TRUE;
3163               /* We use the reloc_count field as a counter if we need to
3164                  copy relocs into the output file.  */
3165               sec->reloc_count = 0;
3166             }
3167         }
3168       else
3169         {
3170           const char *name;
3171
3172           /* It's OK to base decisions on the section name, because none
3173              of the dynobj section names depend upon the input files.  */
3174           name = bfd_get_section_name (dynobj, sec);
3175
3176           if (strcmp (name, ".got.plt") == 0)
3177             strip = FALSE;
3178           else if (CONST_STRNEQ (name, ".rel"))
3179             {
3180               if (!strip)
3181                 {
3182                   /* We use the reloc_count field as a counter if we need to
3183                      copy relocs into the output file.  */
3184                   sec->reloc_count = 0;
3185                 }
3186             }
3187           else
3188             continue;
3189         }
3190
3191       if (strip)
3192         sec->flags |= SEC_EXCLUDE;
3193       else
3194         {
3195           /* Allocate memory for the section contents.  */
3196           sec->contents = (bfd_byte *) bfd_zalloc (dynobj, sec->size);
3197           if (sec->contents == NULL && sec->size != 0)
3198             return FALSE;
3199         }
3200     }
3201
3202   if (ia64_info->root.dynamic_sections_created)
3203     {
3204       /* Add some entries to the .dynamic section.  We fill in the values
3205          later (in finish_dynamic_sections) but we must add the entries now
3206          so that we get the correct size for the .dynamic section.  */
3207
3208       if (bfd_link_executable (info))
3209         {
3210           /* The DT_DEBUG entry is filled in by the dynamic linker and used
3211              by the debugger.  */
3212 #define add_dynamic_entry(TAG, VAL) \
3213   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3214
3215           if (!add_dynamic_entry (DT_DEBUG, 0))
3216             return FALSE;
3217         }
3218
3219       if (!add_dynamic_entry (DT_IA_64_PLT_RESERVE, 0))
3220         return FALSE;
3221       if (!add_dynamic_entry (DT_PLTGOT, 0))
3222         return FALSE;
3223
3224       if (relplt)
3225         {
3226           if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3227               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3228               || !add_dynamic_entry (DT_JMPREL, 0))
3229             return FALSE;
3230         }
3231
3232       if (!add_dynamic_entry (DT_RELA, 0)
3233           || !add_dynamic_entry (DT_RELASZ, 0)
3234           || !add_dynamic_entry (DT_RELAENT, sizeof (ElfNN_External_Rela)))
3235         return FALSE;
3236
3237       if (ia64_info->reltext)
3238         {
3239           if (!add_dynamic_entry (DT_TEXTREL, 0))
3240             return FALSE;
3241           info->flags |= DF_TEXTREL;
3242         }
3243     }
3244
3245   /* ??? Perhaps force __gp local.  */
3246
3247   return TRUE;
3248 }
3249
3250 static void
3251 elfNN_ia64_install_dyn_reloc (bfd *abfd, struct bfd_link_info *info,
3252                               asection *sec, asection *srel,
3253                               bfd_vma offset, unsigned int type,
3254                               long dynindx, bfd_vma addend)
3255 {
3256   Elf_Internal_Rela outrel;
3257   bfd_byte *loc;
3258
3259   BFD_ASSERT (dynindx != -1);
3260   outrel.r_info = ELFNN_R_INFO (dynindx, type);
3261   outrel.r_addend = addend;
3262   outrel.r_offset = _bfd_elf_section_offset (abfd, info, sec, offset);
3263   if (outrel.r_offset >= (bfd_vma) -2)
3264     {
3265       /* Run for the hills.  We shouldn't be outputting a relocation
3266          for this.  So do what everyone else does and output a no-op.  */
3267       outrel.r_info = ELFNN_R_INFO (0, R_IA64_NONE);
3268       outrel.r_addend = 0;
3269       outrel.r_offset = 0;
3270     }
3271   else
3272     outrel.r_offset += sec->output_section->vma + sec->output_offset;
3273
3274   loc = srel->contents;
3275   loc += srel->reloc_count++ * sizeof (ElfNN_External_Rela);
3276   bfd_elfNN_swap_reloca_out (abfd, &outrel, loc);
3277   BFD_ASSERT (sizeof (ElfNN_External_Rela) * srel->reloc_count <= srel->size);
3278 }
3279
3280 /* Store an entry for target address TARGET_ADDR in the linkage table
3281    and return the gp-relative address of the linkage table entry.  */
3282
3283 static bfd_vma
3284 set_got_entry (bfd *abfd, struct bfd_link_info *info,
3285                struct elfNN_ia64_dyn_sym_info *dyn_i,
3286                long dynindx, bfd_vma addend, bfd_vma value,
3287                unsigned int dyn_r_type)
3288 {
3289   struct elfNN_ia64_link_hash_table *ia64_info;
3290   asection *got_sec;
3291   bfd_boolean done;
3292   bfd_vma got_offset;
3293
3294   ia64_info = elfNN_ia64_hash_table (info);
3295   if (ia64_info == NULL)
3296     return 0;
3297
3298   got_sec = ia64_info->root.sgot;
3299
3300   switch (dyn_r_type)
3301     {
3302     case R_IA64_TPREL64LSB:
3303       done = dyn_i->tprel_done;
3304       dyn_i->tprel_done = TRUE;
3305       got_offset = dyn_i->tprel_offset;
3306       break;
3307     case R_IA64_DTPMOD64LSB:
3308       if (dyn_i->dtpmod_offset != ia64_info->self_dtpmod_offset)
3309         {
3310           done = dyn_i->dtpmod_done;
3311           dyn_i->dtpmod_done = TRUE;
3312         }
3313       else
3314         {
3315           done = ia64_info->self_dtpmod_done;
3316           ia64_info->self_dtpmod_done = TRUE;
3317           dynindx = 0;
3318         }
3319       got_offset = dyn_i->dtpmod_offset;
3320       break;
3321     case R_IA64_DTPREL32LSB:
3322     case R_IA64_DTPREL64LSB:
3323       done = dyn_i->dtprel_done;
3324       dyn_i->dtprel_done = TRUE;
3325       got_offset = dyn_i->dtprel_offset;
3326       break;
3327     default:
3328       done = dyn_i->got_done;
3329       dyn_i->got_done = TRUE;
3330       got_offset = dyn_i->got_offset;
3331       break;
3332     }
3333
3334   BFD_ASSERT ((got_offset & 7) == 0);
3335
3336   if (! done)
3337     {
3338       /* Store the target address in the linkage table entry.  */
3339       bfd_put_64 (abfd, value, got_sec->contents + got_offset);
3340
3341       /* Install a dynamic relocation if needed.  */
3342       if (((bfd_link_pic (info)
3343             && (!dyn_i->h
3344                 || (ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
3345                     && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, dyn_i->h))
3346                 || dyn_i->h->root.type != bfd_link_hash_undefweak)
3347             && dyn_r_type != R_IA64_DTPREL32LSB
3348             && dyn_r_type != R_IA64_DTPREL64LSB)
3349            || elfNN_ia64_dynamic_symbol_p (dyn_i->h, info, dyn_r_type)
3350            || (dynindx != -1
3351                && (dyn_r_type == R_IA64_FPTR32LSB
3352                    || dyn_r_type == R_IA64_FPTR64LSB)))
3353           && (!dyn_i->want_ltoff_fptr
3354               || !bfd_link_pie (info)
3355               || !dyn_i->h
3356               || dyn_i->h->root.type != bfd_link_hash_undefweak))
3357         {
3358           if (dynindx == -1
3359               && dyn_r_type != R_IA64_TPREL64LSB
3360               && dyn_r_type != R_IA64_DTPMOD64LSB
3361               && dyn_r_type != R_IA64_DTPREL32LSB
3362               && dyn_r_type != R_IA64_DTPREL64LSB)
3363             {
3364               dyn_r_type = R_IA64_RELNNLSB;
3365               dynindx = 0;
3366               addend = value;
3367             }
3368
3369           if (bfd_big_endian (abfd))
3370             {
3371               switch (dyn_r_type)
3372                 {
3373                 case R_IA64_REL32LSB:
3374                   dyn_r_type = R_IA64_REL32MSB;
3375                   break;
3376                 case R_IA64_DIR32LSB:
3377                   dyn_r_type = R_IA64_DIR32MSB;
3378                   break;
3379                 case R_IA64_FPTR32LSB:
3380                   dyn_r_type = R_IA64_FPTR32MSB;
3381                   break;
3382                 case R_IA64_DTPREL32LSB:
3383                   dyn_r_type = R_IA64_DTPREL32MSB;
3384                   break;
3385                 case R_IA64_REL64LSB:
3386                   dyn_r_type = R_IA64_REL64MSB;
3387                   break;
3388                 case R_IA64_DIR64LSB:
3389                   dyn_r_type = R_IA64_DIR64MSB;
3390                   break;
3391                 case R_IA64_FPTR64LSB:
3392                   dyn_r_type = R_IA64_FPTR64MSB;
3393                   break;
3394                 case R_IA64_TPREL64LSB:
3395                   dyn_r_type = R_IA64_TPREL64MSB;
3396                   break;
3397                 case R_IA64_DTPMOD64LSB:
3398                   dyn_r_type = R_IA64_DTPMOD64MSB;
3399                   break;
3400                 case R_IA64_DTPREL64LSB:
3401                   dyn_r_type = R_IA64_DTPREL64MSB;
3402                   break;
3403                 default:
3404                   BFD_ASSERT (FALSE);
3405                   break;
3406                 }
3407             }
3408
3409           elfNN_ia64_install_dyn_reloc (abfd, NULL, got_sec,
3410                                         ia64_info->root.srelgot,
3411                                         got_offset, dyn_r_type,
3412                                         dynindx, addend);
3413         }
3414     }
3415
3416   /* Return the address of the linkage table entry.  */
3417   value = (got_sec->output_section->vma
3418            + got_sec->output_offset
3419            + got_offset);
3420
3421   return value;
3422 }
3423
3424 /* Fill in a function descriptor consisting of the function's code
3425    address and its global pointer.  Return the descriptor's address.  */
3426
3427 static bfd_vma
3428 set_fptr_entry (bfd *abfd, struct bfd_link_info *info,
3429                 struct elfNN_ia64_dyn_sym_info *dyn_i,
3430                 bfd_vma value)
3431 {
3432   struct elfNN_ia64_link_hash_table *ia64_info;
3433   asection *fptr_sec;
3434
3435   ia64_info = elfNN_ia64_hash_table (info);
3436   if (ia64_info == NULL)
3437     return 0;
3438
3439   fptr_sec = ia64_info->fptr_sec;
3440
3441   if (!dyn_i->fptr_done)
3442     {
3443       dyn_i->fptr_done = 1;
3444
3445       /* Fill in the function descriptor.  */
3446       bfd_put_64 (abfd, value, fptr_sec->contents + dyn_i->fptr_offset);
3447       bfd_put_64 (abfd, _bfd_get_gp_value (abfd),
3448                   fptr_sec->contents + dyn_i->fptr_offset + 8);
3449       if (ia64_info->rel_fptr_sec)
3450         {
3451           Elf_Internal_Rela outrel;
3452           bfd_byte *loc;
3453
3454           if (bfd_little_endian (abfd))
3455             outrel.r_info = ELFNN_R_INFO (0, R_IA64_IPLTLSB);
3456           else
3457             outrel.r_info = ELFNN_R_INFO (0, R_IA64_IPLTMSB);
3458           outrel.r_addend = value;
3459           outrel.r_offset = (fptr_sec->output_section->vma
3460                              + fptr_sec->output_offset
3461                              + dyn_i->fptr_offset);
3462           loc = ia64_info->rel_fptr_sec->contents;
3463           loc += ia64_info->rel_fptr_sec->reloc_count++
3464                  * sizeof (ElfNN_External_Rela);
3465           bfd_elfNN_swap_reloca_out (abfd, &outrel, loc);
3466         }
3467     }
3468
3469   /* Return the descriptor's address.  */
3470   value = (fptr_sec->output_section->vma
3471            + fptr_sec->output_offset
3472            + dyn_i->fptr_offset);
3473
3474   return value;
3475 }
3476
3477 /* Fill in a PLTOFF entry consisting of the function's code address
3478    and its global pointer.  Return the descriptor's address.  */
3479
3480 static bfd_vma
3481 set_pltoff_entry (bfd *abfd, struct bfd_link_info *info,
3482                   struct elfNN_ia64_dyn_sym_info *dyn_i,
3483                   bfd_vma value, bfd_boolean is_plt)
3484 {
3485   struct elfNN_ia64_link_hash_table *ia64_info;
3486   asection *pltoff_sec;
3487
3488   ia64_info = elfNN_ia64_hash_table (info);
3489   if (ia64_info == NULL)
3490     return 0;
3491
3492   pltoff_sec = ia64_info->pltoff_sec;
3493
3494   /* Don't do anything if this symbol uses a real PLT entry.  In
3495      that case, we'll fill this in during finish_dynamic_symbol.  */
3496   if ((! dyn_i->want_plt || is_plt)
3497       && !dyn_i->pltoff_done)
3498     {
3499       bfd_vma gp = _bfd_get_gp_value (abfd);
3500
3501       /* Fill in the function descriptor.  */
3502       bfd_put_64 (abfd, value, pltoff_sec->contents + dyn_i->pltoff_offset);
3503       bfd_put_64 (abfd, gp, pltoff_sec->contents + dyn_i->pltoff_offset + 8);
3504
3505       /* Install dynamic relocations if needed.  */
3506       if (!is_plt
3507           && bfd_link_pic (info)
3508           && (!dyn_i->h
3509               || (ELF_ST_VISIBILITY (dyn_i->h->other) == STV_DEFAULT
3510                   && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, dyn_i->h))
3511               || dyn_i->h->root.type != bfd_link_hash_undefweak))
3512         {
3513           unsigned int dyn_r_type;
3514
3515           if (bfd_big_endian (abfd))
3516             dyn_r_type = R_IA64_RELNNMSB;
3517           else
3518             dyn_r_type = R_IA64_RELNNLSB;
3519
3520           elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
3521                                         ia64_info->rel_pltoff_sec,
3522                                         dyn_i->pltoff_offset,
3523                                         dyn_r_type, 0, value);
3524           elfNN_ia64_install_dyn_reloc (abfd, NULL, pltoff_sec,
3525                                         ia64_info->rel_pltoff_sec,
3526                                         dyn_i->pltoff_offset + ARCH_SIZE / 8,
3527                                         dyn_r_type, 0, gp);
3528         }
3529
3530       dyn_i->pltoff_done = 1;
3531     }
3532
3533   /* Return the descriptor's address.  */
3534   value = (pltoff_sec->output_section->vma
3535            + pltoff_sec->output_offset
3536            + dyn_i->pltoff_offset);
3537
3538   return value;
3539 }
3540
3541 /* Return the base VMA address which should be subtracted from real addresses
3542    when resolving @tprel() relocation.
3543    Main program TLS (whose template starts at PT_TLS p_vaddr)
3544    is assigned offset round(2 * size of pointer, PT_TLS p_align).  */
3545
3546 static bfd_vma
3547 elfNN_ia64_tprel_base (struct bfd_link_info *info)
3548 {
3549   asection *tls_sec = elf_hash_table (info)->tls_sec;
3550   return tls_sec->vma - align_power ((bfd_vma) ARCH_SIZE / 4,
3551                                      tls_sec->alignment_power);
3552 }
3553
3554 /* Return the base VMA address which should be subtracted from real addresses
3555    when resolving @dtprel() relocation.
3556    This is PT_TLS segment p_vaddr.  */
3557
3558 static bfd_vma
3559 elfNN_ia64_dtprel_base (struct bfd_link_info *info)
3560 {
3561   return elf_hash_table (info)->tls_sec->vma;
3562 }
3563
3564 /* Called through qsort to sort the .IA_64.unwind section during a
3565    non-relocatable link.  Set elfNN_ia64_unwind_entry_compare_bfd
3566    to the output bfd so we can do proper endianness frobbing.  */
3567
3568 static bfd *elfNN_ia64_unwind_entry_compare_bfd;
3569
3570 static int
3571 elfNN_ia64_unwind_entry_compare (const void * a, const void * b)
3572 {
3573   bfd_vma av, bv;
3574
3575   av = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, a);
3576   bv = bfd_get_64 (elfNN_ia64_unwind_entry_compare_bfd, b);
3577
3578   return (av < bv ? -1 : av > bv ? 1 : 0);
3579 }
3580
3581 /* Make sure we've got ourselves a nice fat __gp value.  */
3582 static bfd_boolean
3583 elfNN_ia64_choose_gp (bfd *abfd, struct bfd_link_info *info, bfd_boolean final)
3584 {
3585   bfd_vma min_vma = (bfd_vma) -1, max_vma = 0;
3586   bfd_vma min_short_vma = min_vma, max_short_vma = 0;
3587   struct elf_link_hash_entry *gp;
3588   bfd_vma gp_val;
3589   asection *os;
3590   struct elfNN_ia64_link_hash_table *ia64_info;
3591
3592   ia64_info = elfNN_ia64_hash_table (info);
3593   if (ia64_info == NULL)
3594     return FALSE;
3595
3596   /* Find the min and max vma of all sections marked short.  Also collect
3597      min and max vma of any type, for use in selecting a nice gp.  */
3598   for (os = abfd->sections; os ; os = os->next)
3599     {
3600       bfd_vma lo, hi;
3601
3602       if ((os->flags & SEC_ALLOC) == 0)
3603         continue;
3604
3605       lo = os->vma;
3606       /* When this function is called from elfNN_ia64_final_link
3607          the correct value to use is os->size.  When called from
3608          elfNN_ia64_relax_section we are in the middle of section
3609          sizing; some sections will already have os->size set, others
3610          will have os->size zero and os->rawsize the previous size.  */
3611       hi = os->vma + (!final && os->rawsize ? os->rawsize : os->size);
3612       if (hi < lo)
3613         hi = (bfd_vma) -1;
3614
3615       if (min_vma > lo)
3616         min_vma = lo;
3617       if (max_vma < hi)
3618         max_vma = hi;
3619       if (os->flags & SEC_SMALL_DATA)
3620         {
3621           if (min_short_vma > lo)
3622             min_short_vma = lo;
3623           if (max_short_vma < hi)
3624             max_short_vma = hi;
3625         }
3626     }
3627
3628   if (ia64_info->min_short_sec)
3629     {
3630       if (min_short_vma
3631           > (ia64_info->min_short_sec->vma
3632              + ia64_info->min_short_offset))
3633         min_short_vma = (ia64_info->min_short_sec->vma
3634                          + ia64_info->min_short_offset);
3635       if (max_short_vma
3636           < (ia64_info->max_short_sec->vma
3637              + ia64_info->max_short_offset))
3638         max_short_vma = (ia64_info->max_short_sec->vma
3639                          + ia64_info->max_short_offset);
3640     }
3641
3642   /* See if the user wants to force a value.  */
3643   gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
3644                              FALSE, FALSE);
3645
3646   if (gp
3647       && (gp->root.type == bfd_link_hash_defined
3648           || gp->root.type == bfd_link_hash_defweak))
3649     {
3650       asection *gp_sec = gp->root.u.def.section;
3651       gp_val = (gp->root.u.def.value
3652                 + gp_sec->output_section->vma
3653                 + gp_sec->output_offset);
3654     }
3655   else
3656     {
3657       /* Pick a sensible value.  */
3658
3659       if (ia64_info->min_short_sec)
3660         {
3661           bfd_vma short_range = max_short_vma - min_short_vma;
3662
3663           /* If min_short_sec is set, pick one in the middle bewteen
3664              min_short_vma and max_short_vma.  */
3665           if (short_range >= 0x400000)
3666             goto overflow;
3667           gp_val = min_short_vma + short_range / 2;
3668         }
3669       else
3670         {
3671           asection *got_sec = ia64_info->root.sgot;
3672
3673           /* Start with just the address of the .got.  */
3674           if (got_sec)
3675             gp_val = got_sec->output_section->vma;
3676           else if (max_short_vma != 0)
3677             gp_val = min_short_vma;
3678           else if (max_vma - min_vma < 0x200000)
3679             gp_val = min_vma;
3680           else
3681             gp_val = max_vma - 0x200000 + 8;
3682         }
3683
3684       /* If it is possible to address the entire image, but we
3685          don't with the choice above, adjust.  */
3686       if (max_vma - min_vma < 0x400000
3687           && (max_vma - gp_val >= 0x200000
3688               || gp_val - min_vma > 0x200000))
3689         gp_val = min_vma + 0x200000;
3690       else if (max_short_vma != 0)
3691         {
3692           /* If we don't cover all the short data, adjust.  */
3693           if (max_short_vma - gp_val >= 0x200000)
3694             gp_val = min_short_vma + 0x200000;
3695
3696           /* If we're addressing stuff past the end, adjust back.  */
3697           if (gp_val > max_vma)
3698             gp_val = max_vma - 0x200000 + 8;
3699         }
3700     }
3701
3702   /* Validate whether all SHF_IA_64_SHORT sections are within
3703      range of the chosen GP.  */
3704
3705   if (max_short_vma != 0)
3706     {
3707       if (max_short_vma - min_short_vma >= 0x400000)
3708         {
3709 overflow:
3710           _bfd_error_handler
3711             /* xgettext:c-format */
3712             (_("%pB: short data segment overflowed (%#" PRIx64 " >= 0x400000)"),
3713              abfd, (uint64_t) (max_short_vma - min_short_vma));
3714           return FALSE;
3715         }
3716       else if ((gp_val > min_short_vma
3717                 && gp_val - min_short_vma > 0x200000)
3718                || (gp_val < max_short_vma
3719                    && max_short_vma - gp_val >= 0x200000))
3720         {
3721           _bfd_error_handler
3722             (_("%pB: __gp does not cover short data segment"), abfd);
3723           return FALSE;
3724         }
3725     }
3726
3727   _bfd_set_gp_value (abfd, gp_val);
3728
3729   return TRUE;
3730 }
3731
3732 static bfd_boolean
3733 elfNN_ia64_final_link (bfd *abfd, struct bfd_link_info *info)
3734 {
3735   struct elfNN_ia64_link_hash_table *ia64_info;
3736   asection *unwind_output_sec;
3737
3738   ia64_info = elfNN_ia64_hash_table (info);
3739   if (ia64_info == NULL)
3740     return FALSE;
3741
3742   /* Make sure we've got ourselves a nice fat __gp value.  */
3743   if (!bfd_link_relocatable (info))
3744     {
3745       bfd_vma gp_val;
3746       struct elf_link_hash_entry *gp;
3747
3748       /* We assume after gp is set, section size will only decrease. We
3749          need to adjust gp for it.  */
3750       _bfd_set_gp_value (abfd, 0);
3751       if (! elfNN_ia64_choose_gp (abfd, info, TRUE))
3752         return FALSE;
3753       gp_val = _bfd_get_gp_value (abfd);
3754
3755       gp = elf_link_hash_lookup (elf_hash_table (info), "__gp", FALSE,
3756                                  FALSE, FALSE);
3757       if (gp)
3758         {
3759           gp->root.type = bfd_link_hash_defined;
3760           gp->root.u.def.value = gp_val;
3761           gp->root.u.def.section = bfd_abs_section_ptr;
3762         }
3763     }
3764
3765   /* If we're producing a final executable, we need to sort the contents
3766      of the .IA_64.unwind section.  Force this section to be relocated
3767      into memory rather than written immediately to the output file.  */
3768   unwind_output_sec = NULL;
3769   if (!bfd_link_relocatable (info))
3770     {
3771       asection *s = bfd_get_section_by_name (abfd, ELF_STRING_ia64_unwind);
3772       if (s)
3773         {
3774           unwind_output_sec = s->output_section;
3775           unwind_output_sec->contents
3776             = bfd_malloc (unwind_output_sec->size);
3777           if (unwind_output_sec->contents == NULL)
3778             return FALSE;
3779         }
3780     }
3781
3782   /* Invoke the regular ELF backend linker to do all the work.  */
3783   if (!bfd_elf_final_link (abfd, info))
3784     return FALSE;
3785
3786   if (unwind_output_sec)
3787     {
3788       elfNN_ia64_unwind_entry_compare_bfd = abfd;
3789       qsort (unwind_output_sec->contents,
3790              (size_t) (unwind_output_sec->size / 24),
3791              24,
3792              elfNN_ia64_unwind_entry_compare);
3793
3794       if (! bfd_set_section_contents (abfd, unwind_output_sec,
3795                                       unwind_output_sec->contents, (bfd_vma) 0,
3796                                       unwind_output_sec->size))
3797         return FALSE;
3798     }
3799
3800   return TRUE;
3801 }
3802
3803 static bfd_boolean
3804 elfNN_ia64_relocate_section (bfd *output_bfd,
3805                              struct bfd_link_info *info,
3806                              bfd *input_bfd,
3807                              asection *input_section,
3808                              bfd_byte *contents,
3809                              Elf_Internal_Rela *relocs,
3810                              Elf_Internal_Sym *local_syms,
3811                              asection **local_sections)
3812 {
3813   struct elfNN_ia64_link_hash_table *ia64_info;
3814   Elf_Internal_Shdr *symtab_hdr;
3815   Elf_Internal_Rela *rel;
3816   Elf_Internal_Rela *relend;
3817   asection *srel;
3818   bfd_boolean ret_val = TRUE;   /* for non-fatal errors */
3819   bfd_vma gp_val;
3820
3821   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3822   ia64_info = elfNN_ia64_hash_table (info);
3823   if (ia64_info == NULL)
3824     return FALSE;
3825
3826   /* Infect various flags from the input section to the output section.  */
3827   if (bfd_link_relocatable (info))
3828     {
3829       bfd_vma flags;
3830
3831       flags = elf_section_data(input_section)->this_hdr.sh_flags;
3832       flags &= SHF_IA_64_NORECOV;
3833
3834       elf_section_data(input_section->output_section)
3835         ->this_hdr.sh_flags |= flags;
3836     }
3837
3838   gp_val = _bfd_get_gp_value (output_bfd);
3839   srel = get_reloc_section (input_bfd, ia64_info, input_section, FALSE);
3840
3841   rel = relocs;
3842   relend = relocs + input_section->reloc_count;
3843   for (; rel < relend; ++rel)
3844     {
3845       struct elf_link_hash_entry *h;
3846       struct elfNN_ia64_dyn_sym_info *dyn_i;
3847       bfd_reloc_status_type r;
3848       reloc_howto_type *howto;
3849       unsigned long r_symndx;
3850       Elf_Internal_Sym *sym;
3851       unsigned int r_type;
3852       bfd_vma value;
3853       asection *sym_sec;
3854       bfd_byte *hit_addr;
3855       bfd_boolean dynamic_symbol_p;
3856       bfd_boolean undef_weak_ref;
3857
3858       r_type = ELFNN_R_TYPE (rel->r_info);
3859       if (r_type > R_IA64_MAX_RELOC_CODE)
3860         {
3861           /* xgettext:c-format */
3862           _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
3863                               input_bfd, (int) r_type);
3864           bfd_set_error (bfd_error_bad_value);
3865           ret_val = FALSE;
3866           continue;
3867         }
3868
3869       howto = ia64_elf_lookup_howto (r_type);
3870       if (howto == NULL)
3871         {
3872           ret_val = FALSE;
3873           continue;
3874         }
3875       
3876       r_symndx = ELFNN_R_SYM (rel->r_info);
3877       h = NULL;
3878       sym = NULL;
3879       sym_sec = NULL;
3880       undef_weak_ref = FALSE;
3881
3882       if (r_symndx < symtab_hdr->sh_info)
3883         {
3884           /* Reloc against local symbol.  */
3885           asection *msec;
3886           sym = local_syms + r_symndx;
3887           sym_sec = local_sections[r_symndx];
3888           msec = sym_sec;
3889           value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
3890           if (!bfd_link_relocatable (info)
3891               && (sym_sec->flags & SEC_MERGE) != 0
3892               && ELF_ST_TYPE (sym->st_info) == STT_SECTION
3893               && sym_sec->sec_info_type == SEC_INFO_TYPE_MERGE)
3894             {
3895               struct elfNN_ia64_local_hash_entry *loc_h;
3896
3897               loc_h = get_local_sym_hash (ia64_info, input_bfd, rel, FALSE);
3898               if (loc_h && ! loc_h->sec_merge_done)
3899                 {
3900                   struct elfNN_ia64_dyn_sym_info *dynent;
3901                   unsigned int count;
3902
3903                   for (count = loc_h->count, dynent = loc_h->info;
3904                        count != 0;
3905                        count--, dynent++)
3906                     {
3907                       msec = sym_sec;
3908                       dynent->addend =
3909                         _bfd_merged_section_offset (output_bfd, &msec,
3910                                                     elf_section_data (msec)->
3911                                                     sec_info,
3912                                                     sym->st_value
3913                                                     + dynent->addend);
3914                       dynent->addend -= sym->st_value;
3915                       dynent->addend += msec->output_section->vma
3916                                         + msec->output_offset
3917                                         - sym_sec->output_section->vma
3918                                         - sym_sec->output_offset;
3919                     }
3920
3921                   /* We may have introduced duplicated entries. We need
3922                      to remove them properly.  */
3923                   count = sort_dyn_sym_info (loc_h->info, loc_h->count);
3924                   if (count != loc_h->count)
3925                     {
3926                       loc_h->count = count;
3927                       loc_h->sorted_count = count;
3928                     }
3929
3930                   loc_h->sec_merge_done = 1;
3931                 }
3932             }
3933         }
3934       else
3935         {
3936           bfd_boolean unresolved_reloc;
3937           bfd_boolean warned, ignored;
3938           struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
3939
3940           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3941                                    r_symndx, symtab_hdr, sym_hashes,
3942                                    h, sym_sec, value,
3943                                    unresolved_reloc, warned, ignored);
3944
3945           if (h->root.type == bfd_link_hash_undefweak)
3946             undef_weak_ref = TRUE;
3947           else if (warned || (ignored && bfd_link_executable (info)))
3948             continue;
3949         }
3950
3951       if (sym_sec != NULL && discarded_section (sym_sec))
3952         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3953                                          rel, 1, relend, howto, 0, contents);
3954
3955       if (bfd_link_relocatable (info))
3956         continue;
3957
3958       hit_addr = contents + rel->r_offset;
3959       value += rel->r_addend;
3960       dynamic_symbol_p = elfNN_ia64_dynamic_symbol_p (h, info, r_type);
3961
3962       switch (r_type)
3963         {
3964         case R_IA64_NONE:
3965         case R_IA64_LDXMOV:
3966           continue;
3967
3968         case R_IA64_IMM14:
3969         case R_IA64_IMM22:
3970         case R_IA64_IMM64:
3971         case R_IA64_DIR32MSB:
3972         case R_IA64_DIR32LSB:
3973         case R_IA64_DIR64MSB:
3974         case R_IA64_DIR64LSB:
3975           /* Install a dynamic relocation for this reloc.  */
3976           if ((dynamic_symbol_p || bfd_link_pic (info))
3977               && !(h && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
3978               && r_symndx != STN_UNDEF
3979               && (input_section->flags & SEC_ALLOC) != 0)
3980             {
3981               unsigned int dyn_r_type;
3982               long dynindx;
3983               bfd_vma addend;
3984
3985               BFD_ASSERT (srel != NULL);
3986
3987               switch (r_type)
3988                 {
3989                 case R_IA64_IMM14:
3990                 case R_IA64_IMM22:
3991                 case R_IA64_IMM64:
3992                   /* ??? People shouldn't be doing non-pic code in
3993                      shared libraries nor dynamic executables.  */
3994                   _bfd_error_handler
3995                     /* xgettext:c-format */
3996                     (_("%pB: non-pic code with imm relocation against dynamic symbol `%s'"),
3997                      input_bfd,
3998                      h ? h->root.root.string
3999                        : bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4000                                            sym_sec));
4001                   ret_val = FALSE;
4002                   continue;
4003
4004                 default:
4005                   break;
4006                 }
4007
4008               /* If we don't need dynamic symbol lookup, find a
4009                  matching RELATIVE relocation.  */
4010               dyn_r_type = r_type;
4011               if (dynamic_symbol_p)
4012                 {
4013                   dynindx = h->dynindx;
4014                   addend = rel->r_addend;
4015                   value = 0;
4016                 }
4017               else
4018                 {
4019                   switch (r_type)
4020                     {
4021                     case R_IA64_DIR32MSB:
4022                       dyn_r_type = R_IA64_REL32MSB;
4023                       break;
4024                     case R_IA64_DIR32LSB:
4025                       dyn_r_type = R_IA64_REL32LSB;
4026                       break;
4027                     case R_IA64_DIR64MSB:
4028                       dyn_r_type = R_IA64_REL64MSB;
4029                       break;
4030                     case R_IA64_DIR64LSB:
4031                       dyn_r_type = R_IA64_REL64LSB;
4032                       break;
4033
4034                     default:
4035                       break;
4036                     }
4037                   dynindx = 0;
4038                   addend = value;
4039                 }
4040
4041               elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4042                                             srel, rel->r_offset, dyn_r_type,
4043                                             dynindx, addend);
4044             }
4045           /* Fall through.  */
4046
4047         case R_IA64_LTV32MSB:
4048         case R_IA64_LTV32LSB:
4049         case R_IA64_LTV64MSB:
4050         case R_IA64_LTV64LSB:
4051           r = ia64_elf_install_value (hit_addr, value, r_type);
4052           break;
4053
4054         case R_IA64_GPREL22:
4055         case R_IA64_GPREL64I:
4056         case R_IA64_GPREL32MSB:
4057         case R_IA64_GPREL32LSB:
4058         case R_IA64_GPREL64MSB:
4059         case R_IA64_GPREL64LSB:
4060           if (dynamic_symbol_p)
4061             {
4062               _bfd_error_handler
4063                 /* xgettext:c-format */
4064                 (_("%pB: @gprel relocation against dynamic symbol %s"),
4065                  input_bfd,
4066                  h ? h->root.root.string
4067                    : bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4068                                        sym_sec));
4069               ret_val = FALSE;
4070               continue;
4071             }
4072           value -= gp_val;
4073           r = ia64_elf_install_value (hit_addr, value, r_type);
4074           break;
4075
4076         case R_IA64_LTOFF22:
4077         case R_IA64_LTOFF22X:
4078         case R_IA64_LTOFF64I:
4079           dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4080           value = set_got_entry (input_bfd, info, dyn_i, (h ? h->dynindx : -1),
4081                                  rel->r_addend, value, R_IA64_DIRNNLSB);
4082           value -= gp_val;
4083           r = ia64_elf_install_value (hit_addr, value, r_type);
4084           break;
4085
4086         case R_IA64_PLTOFF22:
4087         case R_IA64_PLTOFF64I:
4088         case R_IA64_PLTOFF64MSB:
4089         case R_IA64_PLTOFF64LSB:
4090           dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4091           value = set_pltoff_entry (output_bfd, info, dyn_i, value, FALSE);
4092           value -= gp_val;
4093           r = ia64_elf_install_value (hit_addr, value, r_type);
4094           break;
4095
4096         case R_IA64_FPTR64I:
4097         case R_IA64_FPTR32MSB:
4098         case R_IA64_FPTR32LSB:
4099         case R_IA64_FPTR64MSB:
4100         case R_IA64_FPTR64LSB:
4101           dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4102           if (dyn_i->want_fptr)
4103             {
4104               if (!undef_weak_ref)
4105                 value = set_fptr_entry (output_bfd, info, dyn_i, value);
4106             }
4107           if (!dyn_i->want_fptr || bfd_link_pie (info))
4108             {
4109               long dynindx;
4110               unsigned int dyn_r_type = r_type;
4111               bfd_vma addend = rel->r_addend;
4112
4113               /* Otherwise, we expect the dynamic linker to create
4114                  the entry.  */
4115
4116               if (dyn_i->want_fptr)
4117                 {
4118                   if (r_type == R_IA64_FPTR64I)
4119                     {
4120                       /* We can't represent this without a dynamic symbol.
4121                          Adjust the relocation to be against an output
4122                          section symbol, which are always present in the
4123                          dynamic symbol table.  */
4124                       /* ??? People shouldn't be doing non-pic code in
4125                          shared libraries.  Hork.  */
4126                       _bfd_error_handler
4127                         (_("%pB: linking non-pic code in a position independent executable"),
4128                          input_bfd);
4129                       ret_val = FALSE;
4130                       continue;
4131                     }
4132                   dynindx = 0;
4133                   addend = value;
4134                   dyn_r_type = r_type + R_IA64_RELNNLSB - R_IA64_FPTRNNLSB;
4135                 }
4136               else if (h)
4137                 {
4138                   if (h->dynindx != -1)
4139                     dynindx = h->dynindx;
4140                   else
4141                     dynindx = (_bfd_elf_link_lookup_local_dynindx
4142                                (info, h->root.u.def.section->owner,
4143                                 global_sym_index (h)));
4144                   value = 0;
4145                 }
4146               else
4147                 {
4148                   dynindx = (_bfd_elf_link_lookup_local_dynindx
4149                              (info, input_bfd, (long) r_symndx));
4150                   value = 0;
4151                 }
4152
4153               elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4154                                             srel, rel->r_offset, dyn_r_type,
4155                                             dynindx, addend);
4156             }
4157
4158           r = ia64_elf_install_value (hit_addr, value, r_type);
4159           break;
4160
4161         case R_IA64_LTOFF_FPTR22:
4162         case R_IA64_LTOFF_FPTR64I:
4163         case R_IA64_LTOFF_FPTR32MSB:
4164         case R_IA64_LTOFF_FPTR32LSB:
4165         case R_IA64_LTOFF_FPTR64MSB:
4166         case R_IA64_LTOFF_FPTR64LSB:
4167           {
4168             long dynindx;
4169
4170             dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4171             if (dyn_i->want_fptr)
4172               {
4173                 BFD_ASSERT (h == NULL || h->dynindx == -1);
4174                 if (!undef_weak_ref)
4175                   value = set_fptr_entry (output_bfd, info, dyn_i, value);
4176                 dynindx = -1;
4177               }
4178             else
4179               {
4180                 /* Otherwise, we expect the dynamic linker to create
4181                    the entry.  */
4182                 if (h)
4183                   {
4184                     if (h->dynindx != -1)
4185                       dynindx = h->dynindx;
4186                     else
4187                       dynindx = (_bfd_elf_link_lookup_local_dynindx
4188                                  (info, h->root.u.def.section->owner,
4189                                   global_sym_index (h)));
4190                   }
4191                 else
4192                   dynindx = (_bfd_elf_link_lookup_local_dynindx
4193                              (info, input_bfd, (long) r_symndx));
4194                 value = 0;
4195               }
4196
4197             value = set_got_entry (output_bfd, info, dyn_i, dynindx,
4198                                    rel->r_addend, value, R_IA64_FPTRNNLSB);
4199             value -= gp_val;
4200             r = ia64_elf_install_value (hit_addr, value, r_type);
4201           }
4202           break;
4203
4204         case R_IA64_PCREL32MSB:
4205         case R_IA64_PCREL32LSB:
4206         case R_IA64_PCREL64MSB:
4207         case R_IA64_PCREL64LSB:
4208           /* Install a dynamic relocation for this reloc.  */
4209           if (dynamic_symbol_p && r_symndx != STN_UNDEF)
4210             {
4211               BFD_ASSERT (srel != NULL);
4212
4213               elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4214                                             srel, rel->r_offset, r_type,
4215                                             h->dynindx, rel->r_addend);
4216             }
4217           goto finish_pcrel;
4218
4219         case R_IA64_PCREL21B:
4220         case R_IA64_PCREL60B:
4221           /* We should have created a PLT entry for any dynamic symbol.  */
4222           dyn_i = NULL;
4223           if (h)
4224             dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE);
4225
4226           if (dyn_i && dyn_i->want_plt2)
4227             {
4228               /* Should have caught this earlier.  */
4229               BFD_ASSERT (rel->r_addend == 0);
4230
4231               value = (ia64_info->root.splt->output_section->vma
4232                        + ia64_info->root.splt->output_offset
4233                        + dyn_i->plt2_offset);
4234             }
4235           else
4236             {
4237               /* Since there's no PLT entry, Validate that this is
4238                  locally defined.  */
4239               BFD_ASSERT (undef_weak_ref || sym_sec->output_section != NULL);
4240
4241               /* If the symbol is undef_weak, we shouldn't be trying
4242                  to call it.  There's every chance that we'd wind up
4243                  with an out-of-range fixup here.  Don't bother setting
4244                  any value at all.  */
4245               if (undef_weak_ref)
4246                 continue;
4247             }
4248           goto finish_pcrel;
4249
4250         case R_IA64_PCREL21BI:
4251         case R_IA64_PCREL21F:
4252         case R_IA64_PCREL21M:
4253         case R_IA64_PCREL22:
4254         case R_IA64_PCREL64I:
4255           /* The PCREL21BI reloc is specifically not intended for use with
4256              dynamic relocs.  PCREL21F and PCREL21M are used for speculation
4257              fixup code, and thus probably ought not be dynamic.  The
4258              PCREL22 and PCREL64I relocs aren't emitted as dynamic relocs.  */
4259           if (dynamic_symbol_p)
4260             {
4261               const char *msg;
4262
4263               if (r_type == R_IA64_PCREL21BI)
4264                 /* xgettext:c-format */
4265                 msg = _("%pB: @internal branch to dynamic symbol %s");
4266               else if (r_type == R_IA64_PCREL21F || r_type == R_IA64_PCREL21M)
4267                 /* xgettext:c-format */
4268                 msg = _("%pB: speculation fixup to dynamic symbol %s");
4269               else
4270                 /* xgettext:c-format */
4271                 msg = _("%pB: @pcrel relocation against dynamic symbol %s");
4272               _bfd_error_handler (msg, input_bfd,
4273                                   h ? h->root.root.string
4274                                   : bfd_elf_sym_name (input_bfd,
4275                                                       symtab_hdr,
4276                                                       sym,
4277                                                       sym_sec));
4278               ret_val = FALSE;
4279               continue;
4280             }
4281           goto finish_pcrel;
4282
4283         finish_pcrel:
4284           /* Make pc-relative.  */
4285           value -= (input_section->output_section->vma
4286                     + input_section->output_offset
4287                     + rel->r_offset) & ~ (bfd_vma) 0x3;
4288           r = ia64_elf_install_value (hit_addr, value, r_type);
4289           break;
4290
4291         case R_IA64_SEGREL32MSB:
4292         case R_IA64_SEGREL32LSB:
4293         case R_IA64_SEGREL64MSB:
4294         case R_IA64_SEGREL64LSB:
4295             {
4296               /* Find the segment that contains the output_section.  */
4297               Elf_Internal_Phdr *p = _bfd_elf_find_segment_containing_section
4298                 (output_bfd, input_section->output_section);
4299
4300               if (p == NULL)
4301                 {
4302                   r = bfd_reloc_notsupported;
4303                 }
4304               else
4305                 {
4306                   /* The VMA of the segment is the vaddr of the associated
4307                      program header.  */
4308                   if (value > p->p_vaddr)
4309                     value -= p->p_vaddr;
4310                   else
4311                     value = 0;
4312                   r = ia64_elf_install_value (hit_addr, value, r_type);
4313                 }
4314               break;
4315             }
4316
4317         case R_IA64_SECREL32MSB:
4318         case R_IA64_SECREL32LSB:
4319         case R_IA64_SECREL64MSB:
4320         case R_IA64_SECREL64LSB:
4321           /* Make output-section relative to section where the symbol
4322              is defined. PR 475  */
4323           if (sym_sec)
4324             value -= sym_sec->output_section->vma;
4325           r = ia64_elf_install_value (hit_addr, value, r_type);
4326           break;
4327
4328         case R_IA64_IPLTMSB:
4329         case R_IA64_IPLTLSB:
4330           /* Install a dynamic relocation for this reloc.  */
4331           if ((dynamic_symbol_p || bfd_link_pic (info))
4332               && (input_section->flags & SEC_ALLOC) != 0)
4333             {
4334               BFD_ASSERT (srel != NULL);
4335
4336               /* If we don't need dynamic symbol lookup, install two
4337                  RELATIVE relocations.  */
4338               if (!dynamic_symbol_p)
4339                 {
4340                   unsigned int dyn_r_type;
4341
4342                   if (r_type == R_IA64_IPLTMSB)
4343                     dyn_r_type = R_IA64_REL64MSB;
4344                   else
4345                     dyn_r_type = R_IA64_REL64LSB;
4346
4347                   elfNN_ia64_install_dyn_reloc (output_bfd, info,
4348                                                 input_section,
4349                                                 srel, rel->r_offset,
4350                                                 dyn_r_type, 0, value);
4351                   elfNN_ia64_install_dyn_reloc (output_bfd, info,
4352                                                 input_section,
4353                                                 srel, rel->r_offset + 8,
4354                                                 dyn_r_type, 0, gp_val);
4355                 }
4356               else
4357                 elfNN_ia64_install_dyn_reloc (output_bfd, info, input_section,
4358                                               srel, rel->r_offset, r_type,
4359                                               h->dynindx, rel->r_addend);
4360             }
4361
4362           if (r_type == R_IA64_IPLTMSB)
4363             r_type = R_IA64_DIR64MSB;
4364           else
4365             r_type = R_IA64_DIR64LSB;
4366           ia64_elf_install_value (hit_addr, value, r_type);
4367           r = ia64_elf_install_value (hit_addr + 8, gp_val, r_type);
4368           break;
4369
4370         case R_IA64_TPREL14:
4371         case R_IA64_TPREL22:
4372         case R_IA64_TPREL64I:
4373           if (elf_hash_table (info)->tls_sec == NULL)
4374             goto missing_tls_sec;
4375           value -= elfNN_ia64_tprel_base (info);
4376           r = ia64_elf_install_value (hit_addr, value, r_type);
4377           break;
4378
4379         case R_IA64_DTPREL14:
4380         case R_IA64_DTPREL22:
4381         case R_IA64_DTPREL64I:
4382         case R_IA64_DTPREL32LSB:
4383         case R_IA64_DTPREL32MSB:
4384         case R_IA64_DTPREL64LSB:
4385         case R_IA64_DTPREL64MSB:
4386           if (elf_hash_table (info)->tls_sec == NULL)
4387             goto missing_tls_sec;
4388           value -= elfNN_ia64_dtprel_base (info);
4389           r = ia64_elf_install_value (hit_addr, value, r_type);
4390           break;
4391
4392         case R_IA64_LTOFF_TPREL22:
4393         case R_IA64_LTOFF_DTPMOD22:
4394         case R_IA64_LTOFF_DTPREL22:
4395           {
4396             int got_r_type;
4397             long dynindx = h ? h->dynindx : -1;
4398             bfd_vma r_addend = rel->r_addend;
4399
4400             switch (r_type)
4401               {
4402               default:
4403               case R_IA64_LTOFF_TPREL22:
4404                 if (!dynamic_symbol_p)
4405                   {
4406                     if (elf_hash_table (info)->tls_sec == NULL)
4407                       goto missing_tls_sec;
4408                     if (!bfd_link_pic (info))
4409                       value -= elfNN_ia64_tprel_base (info);
4410                     else
4411                       {
4412                         r_addend += value - elfNN_ia64_dtprel_base (info);
4413                         dynindx = 0;
4414                       }
4415                   }
4416                 got_r_type = R_IA64_TPREL64LSB;
4417                 break;
4418               case R_IA64_LTOFF_DTPMOD22:
4419                 if (!dynamic_symbol_p && !bfd_link_pic (info))
4420                   value = 1;
4421                 got_r_type = R_IA64_DTPMOD64LSB;
4422                 break;
4423               case R_IA64_LTOFF_DTPREL22:
4424                 if (!dynamic_symbol_p)
4425                   {
4426                     if (elf_hash_table (info)->tls_sec == NULL)
4427                       goto missing_tls_sec;
4428                     value -= elfNN_ia64_dtprel_base (info);
4429                   }
4430                 got_r_type = R_IA64_DTPRELNNLSB;
4431                 break;
4432               }
4433             dyn_i = get_dyn_sym_info (ia64_info, h, input_bfd, rel, FALSE);
4434             value = set_got_entry (input_bfd, info, dyn_i, dynindx, r_addend,
4435                                    value, got_r_type);
4436             value -= gp_val;
4437             r = ia64_elf_install_value (hit_addr, value, r_type);
4438           }
4439           break;
4440
4441         default:
4442           r = bfd_reloc_notsupported;
4443           break;
4444         }
4445
4446       switch (r)
4447         {
4448         case bfd_reloc_ok:
4449           break;
4450
4451         case bfd_reloc_undefined:
4452           /* This can happen for global table relative relocs if
4453              __gp is undefined.  This is a panic situation so we
4454              don't try to continue.  */
4455           (*info->callbacks->undefined_symbol)
4456             (info, "__gp", input_bfd, input_section, rel->r_offset, 1);
4457           return FALSE;
4458
4459         case bfd_reloc_notsupported:
4460           {
4461             const char *name;
4462
4463             if (h)
4464               name = h->root.root.string;
4465             else
4466               name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4467                                        sym_sec);
4468             (*info->callbacks->warning) (info, _("unsupported reloc"),
4469                                          name, input_bfd,
4470                                          input_section, rel->r_offset);
4471             ret_val = FALSE;
4472           }
4473           break;
4474
4475         case bfd_reloc_dangerous:
4476         case bfd_reloc_outofrange:
4477         case bfd_reloc_overflow:
4478         default:
4479 missing_tls_sec:
4480           {
4481             const char *name;
4482
4483             if (h)
4484               name = h->root.root.string;
4485             else
4486               name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4487                                        sym_sec);
4488
4489             switch (r_type)
4490               {
4491               case R_IA64_TPREL14:
4492               case R_IA64_TPREL22:
4493               case R_IA64_TPREL64I:
4494               case R_IA64_DTPREL14:
4495               case R_IA64_DTPREL22:
4496               case R_IA64_DTPREL64I:
4497               case R_IA64_DTPREL32LSB:
4498               case R_IA64_DTPREL32MSB:
4499               case R_IA64_DTPREL64LSB:
4500               case R_IA64_DTPREL64MSB:
4501               case R_IA64_LTOFF_TPREL22:
4502               case R_IA64_LTOFF_DTPMOD22:
4503               case R_IA64_LTOFF_DTPREL22:
4504                 _bfd_error_handler
4505                   /* xgettext:c-format */
4506                   (_("%pB: missing TLS section for relocation %s against `%s'"
4507                      " at %#" PRIx64 " in section `%pA'."),
4508                    input_bfd, howto->name, name,
4509                    (uint64_t) rel->r_offset, input_section);
4510                 break;
4511
4512               case R_IA64_PCREL21B:
4513               case R_IA64_PCREL21BI:
4514               case R_IA64_PCREL21M:
4515               case R_IA64_PCREL21F:
4516                 if (is_elf_hash_table (info->hash))
4517                   {
4518                     /* Relaxtion is always performed for ELF output.
4519                        Overflow failures for those relocations mean
4520                        that the section is too big to relax.  */
4521                     _bfd_error_handler
4522                       /* xgettext:c-format */
4523                       (_("%pB: Can't relax br (%s) to `%s' at %#" PRIx64
4524                          " in section `%pA' with size %#" PRIx64
4525                          " (> 0x1000000)."),
4526                        input_bfd, howto->name, name, (uint64_t) rel->r_offset,
4527                        input_section, (uint64_t) input_section->size);
4528                     break;
4529                   }
4530                 /* Fall through.  */
4531               default:
4532                 (*info->callbacks->reloc_overflow) (info,
4533                                                     &h->root,
4534                                                     name,
4535                                                     howto->name,
4536                                                     (bfd_vma) 0,
4537                                                     input_bfd,
4538                                                     input_section,
4539                                                     rel->r_offset);
4540                 break;
4541               }
4542
4543             ret_val = FALSE;
4544           }
4545           break;
4546         }
4547     }
4548
4549   return ret_val;
4550 }
4551
4552 static bfd_boolean
4553 elfNN_ia64_finish_dynamic_symbol (bfd *output_bfd,
4554                                   struct bfd_link_info *info,
4555                                   struct elf_link_hash_entry *h,
4556                                   Elf_Internal_Sym *sym)
4557 {
4558   struct elfNN_ia64_link_hash_table *ia64_info;
4559   struct elfNN_ia64_dyn_sym_info *dyn_i;
4560
4561   ia64_info = elfNN_ia64_hash_table (info);
4562   if (ia64_info == NULL)
4563     return FALSE;
4564
4565   dyn_i = get_dyn_sym_info (ia64_info, h, NULL, NULL, FALSE);
4566
4567   /* Fill in the PLT data, if required.  */
4568   if (dyn_i && dyn_i->want_plt)
4569     {
4570       Elf_Internal_Rela outrel;
4571       bfd_byte *loc;
4572       asection *plt_sec;
4573       bfd_vma plt_addr, pltoff_addr, gp_val, plt_index;
4574
4575       gp_val = _bfd_get_gp_value (output_bfd);
4576
4577       /* Initialize the minimal PLT entry.  */
4578
4579       plt_index = (dyn_i->plt_offset - PLT_HEADER_SIZE) / PLT_MIN_ENTRY_SIZE;
4580       plt_sec = ia64_info->root.splt;
4581       loc = plt_sec->contents + dyn_i->plt_offset;
4582
4583       memcpy (loc, plt_min_entry, PLT_MIN_ENTRY_SIZE);
4584       ia64_elf_install_value (loc, plt_index, R_IA64_IMM22);
4585       ia64_elf_install_value (loc+2, -dyn_i->plt_offset, R_IA64_PCREL21B);
4586
4587       plt_addr = (plt_sec->output_section->vma
4588                   + plt_sec->output_offset
4589                   + dyn_i->plt_offset);
4590       pltoff_addr = set_pltoff_entry (output_bfd, info, dyn_i, plt_addr, TRUE);
4591
4592       /* Initialize the FULL PLT entry, if needed.  */
4593       if (dyn_i->want_plt2)
4594         {
4595           loc = plt_sec->contents + dyn_i->plt2_offset;
4596
4597           memcpy (loc, plt_full_entry, PLT_FULL_ENTRY_SIZE);
4598           ia64_elf_install_value (loc, pltoff_addr - gp_val, R_IA64_IMM22);
4599
4600           /* Mark the symbol as undefined, rather than as defined in the
4601              plt section.  Leave the value alone.  */
4602           /* ??? We didn't redefine it in adjust_dynamic_symbol in the
4603              first place.  But perhaps elflink.c did some for us.  */
4604           if (!h->def_regular)
4605             sym->st_shndx = SHN_UNDEF;
4606         }
4607
4608       /* Create the dynamic relocation.  */
4609       outrel.r_offset = pltoff_addr;
4610       if (bfd_little_endian (output_bfd))
4611         outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTLSB);
4612       else
4613         outrel.r_info = ELFNN_R_INFO (h->dynindx, R_IA64_IPLTMSB);
4614       outrel.r_addend = 0;
4615
4616       /* This is fun.  In the .IA_64.pltoff section, we've got entries
4617          that correspond both to real PLT entries, and those that
4618          happened to resolve to local symbols but need to be created
4619          to satisfy @pltoff relocations.  The .rela.IA_64.pltoff
4620          relocations for the real PLT should come at the end of the
4621          section, so that they can be indexed by plt entry at runtime.
4622
4623          We emitted all of the relocations for the non-PLT @pltoff
4624          entries during relocate_section.  So we can consider the
4625          existing sec->reloc_count to be the base of the array of
4626          PLT relocations.  */
4627
4628       loc = ia64_info->rel_pltoff_sec->contents;
4629       loc += ((ia64_info->rel_pltoff_sec->reloc_count + plt_index)
4630               * sizeof (ElfNN_External_Rela));
4631       bfd_elfNN_swap_reloca_out (output_bfd, &outrel, loc);
4632     }
4633
4634   /* Mark some specially defined symbols as absolute.  */
4635   if (h == ia64_info->root.hdynamic
4636       || h == ia64_info->root.hgot
4637       || h == ia64_info->root.hplt)
4638     sym->st_shndx = SHN_ABS;
4639
4640   return TRUE;
4641 }
4642
4643 static bfd_boolean
4644 elfNN_ia64_finish_dynamic_sections (bfd *abfd,
4645                                     struct bfd_link_info *info)
4646 {
4647   struct elfNN_ia64_link_hash_table *ia64_info;
4648   bfd *dynobj;
4649
4650   ia64_info = elfNN_ia64_hash_table (info);
4651   if (ia64_info == NULL)
4652     return FALSE;
4653
4654   dynobj = ia64_info->root.dynobj;
4655
4656   if (ia64_info->root.dynamic_sections_created)
4657     {
4658       ElfNN_External_Dyn *dyncon, *dynconend;
4659       asection *sdyn, *sgotplt;
4660       bfd_vma gp_val;
4661
4662       sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4663       sgotplt = ia64_info->root.sgotplt;
4664       BFD_ASSERT (sdyn != NULL);
4665       dyncon = (ElfNN_External_Dyn *) sdyn->contents;
4666       dynconend = (ElfNN_External_Dyn *) (sdyn->contents + sdyn->size);
4667
4668       gp_val = _bfd_get_gp_value (abfd);
4669
4670       for (; dyncon < dynconend; dyncon++)
4671         {
4672           Elf_Internal_Dyn dyn;
4673
4674           bfd_elfNN_swap_dyn_in (dynobj, dyncon, &dyn);
4675
4676           switch (dyn.d_tag)
4677             {
4678             case DT_PLTGOT:
4679               dyn.d_un.d_ptr = gp_val;
4680               break;
4681
4682             case DT_PLTRELSZ:
4683               dyn.d_un.d_val = (ia64_info->minplt_entries
4684                                 * sizeof (ElfNN_External_Rela));
4685               break;
4686
4687             case DT_JMPREL:
4688               /* See the comment above in finish_dynamic_symbol.  */
4689               dyn.d_un.d_ptr = (ia64_info->rel_pltoff_sec->output_section->vma
4690                                 + ia64_info->rel_pltoff_sec->output_offset
4691                                 + (ia64_info->rel_pltoff_sec->reloc_count
4692                                    * sizeof (ElfNN_External_Rela)));
4693               break;
4694
4695             case DT_IA_64_PLT_RESERVE:
4696               dyn.d_un.d_ptr = (sgotplt->output_section->vma
4697                                 + sgotplt->output_offset);
4698               break;
4699             }
4700
4701           bfd_elfNN_swap_dyn_out (abfd, &dyn, dyncon);
4702         }
4703
4704       /* Initialize the PLT0 entry.  */
4705       if (ia64_info->root.splt)
4706         {
4707           bfd_byte *loc = ia64_info->root.splt->contents;
4708           bfd_vma pltres;
4709
4710           memcpy (loc, plt_header, PLT_HEADER_SIZE);
4711
4712           pltres = (sgotplt->output_section->vma
4713                     + sgotplt->output_offset
4714                     - gp_val);
4715
4716           ia64_elf_install_value (loc+1, pltres, R_IA64_GPREL22);
4717         }
4718     }
4719
4720   return TRUE;
4721 }
4722 \f
4723 /* ELF file flag handling:  */
4724
4725 /* Function to keep IA-64 specific file flags.  */
4726 static bfd_boolean
4727 elfNN_ia64_set_private_flags (bfd *abfd, flagword flags)
4728 {
4729   BFD_ASSERT (!elf_flags_init (abfd)
4730               || elf_elfheader (abfd)->e_flags == flags);
4731
4732   elf_elfheader (abfd)->e_flags = flags;
4733   elf_flags_init (abfd) = TRUE;
4734   return TRUE;
4735 }
4736
4737 /* Merge backend specific data from an object file to the output
4738    object file when linking.  */
4739 static bfd_boolean
4740 elfNN_ia64_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
4741 {
4742   bfd *obfd = info->output_bfd;
4743   flagword out_flags;
4744   flagword in_flags;
4745   bfd_boolean ok = TRUE;
4746
4747   /* Don't even pretend to support mixed-format linking.  */
4748   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4749       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4750     return FALSE;
4751
4752   in_flags  = elf_elfheader (ibfd)->e_flags;
4753   out_flags = elf_elfheader (obfd)->e_flags;
4754
4755   if (! elf_flags_init (obfd))
4756     {
4757       elf_flags_init (obfd) = TRUE;
4758       elf_elfheader (obfd)->e_flags = in_flags;
4759
4760       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
4761           && bfd_get_arch_info (obfd)->the_default)
4762         {
4763           return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
4764                                     bfd_get_mach (ibfd));
4765         }
4766
4767       return TRUE;
4768     }
4769
4770   /* Check flag compatibility.  */
4771   if (in_flags == out_flags)
4772     return TRUE;
4773
4774   /* Output has EF_IA_64_REDUCEDFP set only if all inputs have it set.  */
4775   if (!(in_flags & EF_IA_64_REDUCEDFP) && (out_flags & EF_IA_64_REDUCEDFP))
4776     elf_elfheader (obfd)->e_flags &= ~EF_IA_64_REDUCEDFP;
4777
4778   if ((in_flags & EF_IA_64_TRAPNIL) != (out_flags & EF_IA_64_TRAPNIL))
4779     {
4780       _bfd_error_handler
4781         (_("%pB: linking trap-on-NULL-dereference with non-trapping files"),
4782          ibfd);
4783
4784       bfd_set_error (bfd_error_bad_value);
4785       ok = FALSE;
4786     }
4787   if ((in_flags & EF_IA_64_BE) != (out_flags & EF_IA_64_BE))
4788     {
4789       _bfd_error_handler
4790         (_("%pB: linking big-endian files with little-endian files"),
4791          ibfd);
4792
4793       bfd_set_error (bfd_error_bad_value);
4794       ok = FALSE;
4795     }
4796   if ((in_flags & EF_IA_64_ABI64) != (out_flags & EF_IA_64_ABI64))
4797     {
4798       _bfd_error_handler
4799         (_("%pB: linking 64-bit files with 32-bit files"),
4800          ibfd);
4801
4802       bfd_set_error (bfd_error_bad_value);
4803       ok = FALSE;
4804     }
4805   if ((in_flags & EF_IA_64_CONS_GP) != (out_flags & EF_IA_64_CONS_GP))
4806     {
4807       _bfd_error_handler
4808         (_("%pB: linking constant-gp files with non-constant-gp files"),
4809          ibfd);
4810
4811       bfd_set_error (bfd_error_bad_value);
4812       ok = FALSE;
4813     }
4814   if ((in_flags & EF_IA_64_NOFUNCDESC_CONS_GP)
4815       != (out_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
4816     {
4817       _bfd_error_handler
4818         (_("%pB: linking auto-pic files with non-auto-pic files"),
4819          ibfd);
4820
4821       bfd_set_error (bfd_error_bad_value);
4822       ok = FALSE;
4823     }
4824
4825   return ok;
4826 }
4827
4828 static bfd_boolean
4829 elfNN_ia64_print_private_bfd_data (bfd *abfd, void * ptr)
4830 {
4831   FILE *file = (FILE *) ptr;
4832   flagword flags = elf_elfheader (abfd)->e_flags;
4833
4834   BFD_ASSERT (abfd != NULL && ptr != NULL);
4835
4836   fprintf (file, "private flags = %s%s%s%s%s%s%s%s\n",
4837            (flags & EF_IA_64_TRAPNIL) ? "TRAPNIL, " : "",
4838            (flags & EF_IA_64_EXT) ? "EXT, " : "",
4839            (flags & EF_IA_64_BE) ? "BE, " : "LE, ",
4840            (flags & EF_IA_64_REDUCEDFP) ? "REDUCEDFP, " : "",
4841            (flags & EF_IA_64_CONS_GP) ? "CONS_GP, " : "",
4842            (flags & EF_IA_64_NOFUNCDESC_CONS_GP) ? "NOFUNCDESC_CONS_GP, " : "",
4843            (flags & EF_IA_64_ABSOLUTE) ? "ABSOLUTE, " : "",
4844            (flags & EF_IA_64_ABI64) ? "ABI64" : "ABI32");
4845
4846   _bfd_elf_print_private_bfd_data (abfd, ptr);
4847   return TRUE;
4848 }
4849
4850 static enum elf_reloc_type_class
4851 elfNN_ia64_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
4852                              const asection *rel_sec ATTRIBUTE_UNUSED,
4853                              const Elf_Internal_Rela *rela)
4854 {
4855   switch ((int) ELFNN_R_TYPE (rela->r_info))
4856     {
4857     case R_IA64_REL32MSB:
4858     case R_IA64_REL32LSB:
4859     case R_IA64_REL64MSB:
4860     case R_IA64_REL64LSB:
4861       return reloc_class_relative;
4862     case R_IA64_IPLTMSB:
4863     case R_IA64_IPLTLSB:
4864       return reloc_class_plt;
4865     case R_IA64_COPY:
4866       return reloc_class_copy;
4867     default:
4868       return reloc_class_normal;
4869     }
4870 }
4871
4872 static const struct bfd_elf_special_section elfNN_ia64_special_sections[] =
4873 {
4874   { STRING_COMMA_LEN (".sbss"),  -1, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
4875   { STRING_COMMA_LEN (".sdata"), -1, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_IA_64_SHORT },
4876   { NULL,                    0,   0, 0,            0 }
4877 };
4878
4879 static bfd_boolean
4880 elfNN_ia64_object_p (bfd *abfd)
4881 {
4882   asection *sec;
4883   asection *group, *unwi, *unw;
4884   flagword flags;
4885   const char *name;
4886   char *unwi_name, *unw_name;
4887   bfd_size_type amt;
4888
4889   if (abfd->flags & DYNAMIC)
4890     return TRUE;
4891
4892   /* Flags for fake group section.  */
4893   flags = (SEC_LINKER_CREATED | SEC_GROUP | SEC_LINK_ONCE
4894            | SEC_EXCLUDE);
4895
4896   /* We add a fake section group for each .gnu.linkonce.t.* section,
4897      which isn't in a section group, and its unwind sections.  */
4898   for (sec = abfd->sections; sec != NULL; sec = sec->next)
4899     {
4900       if (elf_sec_group (sec) == NULL
4901           && ((sec->flags & (SEC_LINK_ONCE | SEC_CODE | SEC_GROUP))
4902               == (SEC_LINK_ONCE | SEC_CODE))
4903           && CONST_STRNEQ (sec->name, ".gnu.linkonce.t."))
4904         {
4905           name = sec->name + 16;
4906
4907           amt = strlen (name) + sizeof (".gnu.linkonce.ia64unwi.");
4908           unwi_name = bfd_alloc (abfd, amt);
4909           if (!unwi_name)
4910             return FALSE;
4911
4912           strcpy (stpcpy (unwi_name, ".gnu.linkonce.ia64unwi."), name);
4913           unwi = bfd_get_section_by_name (abfd, unwi_name);
4914
4915           amt = strlen (name) + sizeof (".gnu.linkonce.ia64unw.");
4916           unw_name = bfd_alloc (abfd, amt);
4917           if (!unw_name)
4918             return FALSE;
4919
4920           strcpy (stpcpy (unw_name, ".gnu.linkonce.ia64unw."), name);
4921           unw = bfd_get_section_by_name (abfd, unw_name);
4922
4923           /* We need to create a fake group section for it and its
4924              unwind sections.  */
4925           group = bfd_make_section_anyway_with_flags (abfd, name,
4926                                                       flags);
4927           if (group == NULL)
4928             return FALSE;
4929
4930           /* Move the fake group section to the beginning.  */
4931           bfd_section_list_remove (abfd, group);
4932           bfd_section_list_prepend (abfd, group);
4933
4934           elf_next_in_group (group) = sec;
4935
4936           elf_group_name (sec) = name;
4937           elf_next_in_group (sec) = sec;
4938           elf_sec_group (sec) = group;
4939
4940           if (unwi)
4941             {
4942               elf_group_name (unwi) = name;
4943               elf_next_in_group (unwi) = sec;
4944               elf_next_in_group (sec) = unwi;
4945               elf_sec_group (unwi) = group;
4946             }
4947
4948            if (unw)
4949              {
4950                elf_group_name (unw) = name;
4951                if (unwi)
4952                  {
4953                    elf_next_in_group (unw) = elf_next_in_group (unwi);
4954                    elf_next_in_group (unwi) = unw;
4955                  }
4956                else
4957                  {
4958                    elf_next_in_group (unw) = sec;
4959                    elf_next_in_group (sec) = unw;
4960                  }
4961                elf_sec_group (unw) = group;
4962              }
4963
4964            /* Fake SHT_GROUP section header.  */
4965           elf_section_data (group)->this_hdr.bfd_section = group;
4966           elf_section_data (group)->this_hdr.sh_type = SHT_GROUP;
4967         }
4968     }
4969   return TRUE;
4970 }
4971
4972 static bfd_boolean
4973 elfNN_ia64_hpux_vec (const bfd_target *vec)
4974 {
4975   extern const bfd_target ia64_elfNN_hpux_be_vec;
4976   return (vec == &ia64_elfNN_hpux_be_vec);
4977 }
4978
4979 static void
4980 elfNN_hpux_post_process_headers (bfd *abfd,
4981                                  struct bfd_link_info *info ATTRIBUTE_UNUSED)
4982 {
4983   Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
4984
4985   i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
4986   i_ehdrp->e_ident[EI_ABIVERSION] = 1;
4987 }
4988
4989 static bfd_boolean
4990 elfNN_hpux_backend_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
4991                                              asection *sec, int *retval)
4992 {
4993   if (bfd_is_com_section (sec))
4994     {
4995       *retval = SHN_IA_64_ANSI_COMMON;
4996       return TRUE;
4997     }
4998   return FALSE;
4999 }
5000
5001 static void
5002 elfNN_hpux_backend_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
5003                                       asymbol *asym)
5004 {
5005   elf_symbol_type *elfsym = (elf_symbol_type *) asym;
5006
5007   switch (elfsym->internal_elf_sym.st_shndx)
5008     {
5009     case SHN_IA_64_ANSI_COMMON:
5010       asym->section = bfd_com_section_ptr;
5011       asym->value = elfsym->internal_elf_sym.st_size;
5012       asym->flags &= ~BSF_GLOBAL;
5013       break;
5014     }
5015 }
5016 \f
5017 #define TARGET_LITTLE_SYM               ia64_elfNN_le_vec
5018 #define TARGET_LITTLE_NAME              "elfNN-ia64-little"
5019 #define TARGET_BIG_SYM                  ia64_elfNN_be_vec
5020 #define TARGET_BIG_NAME                 "elfNN-ia64-big"
5021 #define ELF_ARCH                        bfd_arch_ia64
5022 #define ELF_TARGET_ID                   IA64_ELF_DATA
5023 #define ELF_MACHINE_CODE                EM_IA_64
5024 #define ELF_MACHINE_ALT1                1999    /* EAS2.3 */
5025 #define ELF_MACHINE_ALT2                1998    /* EAS2.2 */
5026 #define ELF_MAXPAGESIZE                 0x10000 /* 64KB */
5027 #define ELF_COMMONPAGESIZE              0x4000  /* 16KB */
5028
5029 #define elf_backend_section_from_shdr \
5030         elfNN_ia64_section_from_shdr
5031 #define elf_backend_section_flags \
5032         elfNN_ia64_section_flags
5033 #define elf_backend_fake_sections \
5034         elfNN_ia64_fake_sections
5035 #define elf_backend_final_write_processing \
5036         elfNN_ia64_final_write_processing
5037 #define elf_backend_add_symbol_hook \
5038         elfNN_ia64_add_symbol_hook
5039 #define elf_backend_additional_program_headers \
5040         elfNN_ia64_additional_program_headers
5041 #define elf_backend_modify_segment_map \
5042         elfNN_ia64_modify_segment_map
5043 #define elf_backend_modify_program_headers \
5044         elfNN_ia64_modify_program_headers
5045 #define elf_info_to_howto \
5046         elfNN_ia64_info_to_howto
5047
5048 #define bfd_elfNN_bfd_reloc_type_lookup \
5049         ia64_elf_reloc_type_lookup
5050 #define bfd_elfNN_bfd_reloc_name_lookup \
5051         ia64_elf_reloc_name_lookup
5052 #define bfd_elfNN_bfd_is_local_label_name \
5053         elfNN_ia64_is_local_label_name
5054 #define bfd_elfNN_bfd_relax_section \
5055         elfNN_ia64_relax_section
5056
5057 #define elf_backend_object_p \
5058         elfNN_ia64_object_p
5059
5060 /* Stuff for the BFD linker: */
5061 #define bfd_elfNN_bfd_link_hash_table_create \
5062         elfNN_ia64_hash_table_create
5063 #define elf_backend_create_dynamic_sections \
5064         elfNN_ia64_create_dynamic_sections
5065 #define elf_backend_check_relocs \
5066         elfNN_ia64_check_relocs
5067 #define elf_backend_adjust_dynamic_symbol \
5068         elfNN_ia64_adjust_dynamic_symbol
5069 #define elf_backend_size_dynamic_sections \
5070         elfNN_ia64_size_dynamic_sections
5071 #define elf_backend_omit_section_dynsym \
5072         _bfd_elf_omit_section_dynsym_all
5073 #define elf_backend_relocate_section \
5074         elfNN_ia64_relocate_section
5075 #define elf_backend_finish_dynamic_symbol \
5076         elfNN_ia64_finish_dynamic_symbol
5077 #define elf_backend_finish_dynamic_sections \
5078         elfNN_ia64_finish_dynamic_sections
5079 #define bfd_elfNN_bfd_final_link \
5080         elfNN_ia64_final_link
5081
5082 #define bfd_elfNN_bfd_merge_private_bfd_data \
5083         elfNN_ia64_merge_private_bfd_data
5084 #define bfd_elfNN_bfd_set_private_flags \
5085         elfNN_ia64_set_private_flags
5086 #define bfd_elfNN_bfd_print_private_bfd_data \
5087         elfNN_ia64_print_private_bfd_data
5088
5089 #define elf_backend_plt_readonly        1
5090 #define elf_backend_can_gc_sections     1
5091 #define elf_backend_want_plt_sym        0
5092 #define elf_backend_plt_alignment       5
5093 #define elf_backend_got_header_size     0
5094 #define elf_backend_want_got_plt        1
5095 #define elf_backend_may_use_rel_p       1
5096 #define elf_backend_may_use_rela_p      1
5097 #define elf_backend_default_use_rela_p  1
5098 #define elf_backend_want_dynbss         0
5099 #define elf_backend_copy_indirect_symbol elfNN_ia64_hash_copy_indirect
5100 #define elf_backend_hide_symbol         elfNN_ia64_hash_hide_symbol
5101 #define elf_backend_fixup_symbol        _bfd_elf_link_hash_fixup_symbol
5102 #define elf_backend_reloc_type_class    elfNN_ia64_reloc_type_class
5103 #define elf_backend_rela_normal         1
5104 #define elf_backend_dtrel_excludes_plt  1
5105 #define elf_backend_special_sections    elfNN_ia64_special_sections
5106 #define elf_backend_default_execstack   0
5107
5108 /* FIXME: PR 290: The Intel C compiler generates SHT_IA_64_UNWIND with
5109    SHF_LINK_ORDER. But it doesn't set the sh_link or sh_info fields.
5110    We don't want to flood users with so many error messages. We turn
5111    off the warning for now. It will be turned on later when the Intel
5112    compiler is fixed.   */
5113 #define elf_backend_link_order_error_handler NULL
5114
5115 #include "elfNN-target.h"
5116
5117 /* HPUX-specific vectors.  */
5118
5119 #undef  TARGET_LITTLE_SYM
5120 #undef  TARGET_LITTLE_NAME
5121 #undef  TARGET_BIG_SYM
5122 #define TARGET_BIG_SYM                  ia64_elfNN_hpux_be_vec
5123 #undef  TARGET_BIG_NAME
5124 #define TARGET_BIG_NAME                 "elfNN-ia64-hpux-big"
5125
5126 /* These are HP-UX specific functions.  */
5127
5128 #undef  elf_backend_post_process_headers
5129 #define elf_backend_post_process_headers elfNN_hpux_post_process_headers
5130
5131 #undef  elf_backend_section_from_bfd_section
5132 #define elf_backend_section_from_bfd_section elfNN_hpux_backend_section_from_bfd_section
5133
5134 #undef elf_backend_symbol_processing
5135 #define elf_backend_symbol_processing elfNN_hpux_backend_symbol_processing
5136
5137 #undef  elf_backend_want_p_paddr_set_to_zero
5138 #define elf_backend_want_p_paddr_set_to_zero 1
5139
5140 #undef ELF_COMMONPAGESIZE
5141 #undef ELF_OSABI
5142 #define ELF_OSABI                       ELFOSABI_HPUX
5143
5144 #undef  elfNN_bed
5145 #define elfNN_bed elfNN_ia64_hpux_bed
5146
5147 #include "elfNN-target.h"