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