Automatic date update in version.in
[external/binutils.git] / bfd / elf64-alpha.c
1 /* Alpha specific support for 64-bit ELF
2    Copyright (C) 1996-2018 Free Software Foundation, Inc.
3    Contributed by Richard Henderson <rth@tamu.edu>.
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
23 /* We need a published ABI spec for this.  Until one comes out, don't
24    assume this'll remain unchanged forever.  */
25
26 #include "sysdep.h"
27 #include "bfd.h"
28 #include "libbfd.h"
29 #include "elf-bfd.h"
30
31 #include "elf/alpha.h"
32
33 #define ALPHAECOFF
34
35 #define NO_COFF_RELOCS
36 #define NO_COFF_SYMBOLS
37 #define NO_COFF_LINENOS
38
39 /* Get the ECOFF swapping routines.  Needed for the debug information.  */
40 #include "coff/internal.h"
41 #include "coff/sym.h"
42 #include "coff/symconst.h"
43 #include "coff/ecoff.h"
44 #include "coff/alpha.h"
45 #include "aout/ar.h"
46 #include "libcoff.h"
47 #include "libecoff.h"
48 #define ECOFF_64
49 #include "ecoffswap.h"
50
51 \f
52 /* Instruction data for plt generation and relaxation.  */
53
54 #define OP_LDA          0x08
55 #define OP_LDAH         0x09
56 #define OP_LDQ          0x29
57 #define OP_BR           0x30
58 #define OP_BSR          0x34
59
60 #define INSN_LDA        (OP_LDA << 26)
61 #define INSN_LDAH       (OP_LDAH << 26)
62 #define INSN_LDQ        (OP_LDQ << 26)
63 #define INSN_BR         (OP_BR << 26)
64
65 #define INSN_ADDQ       0x40000400
66 #define INSN_RDUNIQ     0x0000009e
67 #define INSN_SUBQ       0x40000520
68 #define INSN_S4SUBQ     0x40000560
69 #define INSN_UNOP       0x2ffe0000
70
71 #define INSN_JSR        0x68004000
72 #define INSN_JMP        0x68000000
73 #define INSN_JSR_MASK   0xfc00c000
74
75 #define INSN_A(I,A)             (I | (A << 21))
76 #define INSN_AB(I,A,B)          (I | (A << 21) | (B << 16))
77 #define INSN_ABC(I,A,B,C)       (I | (A << 21) | (B << 16) | C)
78 #define INSN_ABO(I,A,B,O)       (I | (A << 21) | (B << 16) | ((O) & 0xffff))
79 #define INSN_AD(I,A,D)          (I | (A << 21) | (((D) >> 2) & 0x1fffff))
80
81 /* PLT/GOT Stuff */
82
83 /* Set by ld emulation.  Putting this into the link_info or hash structure
84    is simply working too hard.  */
85 #ifdef USE_SECUREPLT
86 bfd_boolean elf64_alpha_use_secureplt = TRUE;
87 #else
88 bfd_boolean elf64_alpha_use_secureplt = FALSE;
89 #endif
90
91 #define OLD_PLT_HEADER_SIZE     32
92 #define OLD_PLT_ENTRY_SIZE      12
93 #define NEW_PLT_HEADER_SIZE     36
94 #define NEW_PLT_ENTRY_SIZE      4
95
96 #define PLT_HEADER_SIZE \
97   (elf64_alpha_use_secureplt ? NEW_PLT_HEADER_SIZE : OLD_PLT_HEADER_SIZE)
98 #define PLT_ENTRY_SIZE \
99   (elf64_alpha_use_secureplt ? NEW_PLT_ENTRY_SIZE : OLD_PLT_ENTRY_SIZE)
100
101 #define MAX_GOT_SIZE            (64*1024)
102
103 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so"
104 \f
105
106 /* Used to implement multiple .got subsections.  */
107 struct alpha_elf_got_entry
108 {
109   struct alpha_elf_got_entry *next;
110
111   /* Which .got subsection?  */
112   bfd *gotobj;
113
114   /* The addend in effect for this entry.  */
115   bfd_vma addend;
116
117   /* The .got offset for this entry.  */
118   int got_offset;
119
120   /* The .plt offset for this entry.  */
121   int plt_offset;
122
123   /* How many references to this entry?  */
124   int use_count;
125
126   /* The relocation type of this entry.  */
127   unsigned char reloc_type;
128
129   /* How a LITERAL is used.  */
130   unsigned char flags;
131
132   /* Have we initialized the dynamic relocation for this entry?  */
133   unsigned char reloc_done;
134
135   /* Have we adjusted this entry for SEC_MERGE?  */
136   unsigned char reloc_xlated;
137 };
138
139 struct alpha_elf_reloc_entry
140 {
141   struct alpha_elf_reloc_entry *next;
142
143   /* Which .reloc section? */
144   asection *srel;
145
146   /* What kind of relocation? */
147   unsigned int rtype;
148
149   /* Is this against read-only section? */
150   unsigned int reltext : 1;
151
152   /* How many did we find?  */
153   unsigned long count;
154 };
155
156 struct alpha_elf_link_hash_entry
157 {
158   struct elf_link_hash_entry root;
159
160   /* External symbol information.  */
161   EXTR esym;
162
163   /* Cumulative flags for all the .got entries.  */
164   int flags;
165
166   /* Contexts in which a literal was referenced.  */
167 #define ALPHA_ELF_LINK_HASH_LU_ADDR      0x01
168 #define ALPHA_ELF_LINK_HASH_LU_MEM       0x02
169 #define ALPHA_ELF_LINK_HASH_LU_BYTE      0x04
170 #define ALPHA_ELF_LINK_HASH_LU_JSR       0x08
171 #define ALPHA_ELF_LINK_HASH_LU_TLSGD     0x10
172 #define ALPHA_ELF_LINK_HASH_LU_TLSLDM    0x20
173 #define ALPHA_ELF_LINK_HASH_LU_JSRDIRECT 0x40
174 #define ALPHA_ELF_LINK_HASH_LU_PLT       0x38
175 #define ALPHA_ELF_LINK_HASH_TLS_IE       0x80
176
177   /* Used to implement multiple .got subsections.  */
178   struct alpha_elf_got_entry *got_entries;
179
180   /* Used to count non-got, non-plt relocations for delayed sizing
181      of relocation sections.  */
182   struct alpha_elf_reloc_entry *reloc_entries;
183 };
184
185 /* Alpha ELF linker hash table.  */
186
187 struct alpha_elf_link_hash_table
188 {
189   struct elf_link_hash_table root;
190
191   /* The head of a list of .got subsections linked through
192      alpha_elf_tdata(abfd)->got_link_next.  */
193   bfd *got_list;
194
195   /* The most recent relax pass that we've seen.  The GOTs
196      should be regenerated if this doesn't match.  */
197   int relax_trip;
198 };
199
200 /* Look up an entry in a Alpha ELF linker hash table.  */
201
202 #define alpha_elf_link_hash_lookup(table, string, create, copy, follow) \
203   ((struct alpha_elf_link_hash_entry *)                                 \
204    elf_link_hash_lookup (&(table)->root, (string), (create),            \
205                          (copy), (follow)))
206
207 /* Traverse a Alpha ELF linker hash table.  */
208
209 #define alpha_elf_link_hash_traverse(table, func, info)                 \
210   (elf_link_hash_traverse                                               \
211    (&(table)->root,                                                     \
212     (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func),    \
213     (info)))
214
215 /* Get the Alpha ELF linker hash table from a link_info structure.  */
216
217 #define alpha_elf_hash_table(p) \
218   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
219   == ALPHA_ELF_DATA ? ((struct alpha_elf_link_hash_table *) ((p)->hash)) : NULL)
220
221 /* Get the object's symbols as our own entry type.  */
222
223 #define alpha_elf_sym_hashes(abfd) \
224   ((struct alpha_elf_link_hash_entry **)elf_sym_hashes(abfd))
225
226 /* Should we do dynamic things to this symbol?  This differs from the
227    generic version in that we never need to consider function pointer
228    equality wrt PLT entries -- we don't create a PLT entry if a symbol's
229    address is ever taken.  */
230
231 static inline bfd_boolean
232 alpha_elf_dynamic_symbol_p (struct elf_link_hash_entry *h,
233                             struct bfd_link_info *info)
234 {
235   return _bfd_elf_dynamic_symbol_p (h, info, 0);
236 }
237
238 /* Create an entry in a Alpha ELF linker hash table.  */
239
240 static struct bfd_hash_entry *
241 elf64_alpha_link_hash_newfunc (struct bfd_hash_entry *entry,
242                                struct bfd_hash_table *table,
243                                const char *string)
244 {
245   struct alpha_elf_link_hash_entry *ret =
246     (struct alpha_elf_link_hash_entry *) entry;
247
248   /* Allocate the structure if it has not already been allocated by a
249      subclass.  */
250   if (ret == (struct alpha_elf_link_hash_entry *) NULL)
251     ret = ((struct alpha_elf_link_hash_entry *)
252            bfd_hash_allocate (table,
253                               sizeof (struct alpha_elf_link_hash_entry)));
254   if (ret == (struct alpha_elf_link_hash_entry *) NULL)
255     return (struct bfd_hash_entry *) ret;
256
257   /* Call the allocation method of the superclass.  */
258   ret = ((struct alpha_elf_link_hash_entry *)
259          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
260                                      table, string));
261   if (ret != (struct alpha_elf_link_hash_entry *) NULL)
262     {
263       /* Set local fields.  */
264       memset (&ret->esym, 0, sizeof (EXTR));
265       /* We use -2 as a marker to indicate that the information has
266          not been set.  -1 means there is no associated ifd.  */
267       ret->esym.ifd = -2;
268       ret->flags = 0;
269       ret->got_entries = NULL;
270       ret->reloc_entries = NULL;
271     }
272
273   return (struct bfd_hash_entry *) ret;
274 }
275
276 /* Create a Alpha ELF linker hash table.  */
277
278 static struct bfd_link_hash_table *
279 elf64_alpha_bfd_link_hash_table_create (bfd *abfd)
280 {
281   struct alpha_elf_link_hash_table *ret;
282   bfd_size_type amt = sizeof (struct alpha_elf_link_hash_table);
283
284   ret = (struct alpha_elf_link_hash_table *) bfd_zmalloc (amt);
285   if (ret == (struct alpha_elf_link_hash_table *) NULL)
286     return NULL;
287
288   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
289                                       elf64_alpha_link_hash_newfunc,
290                                       sizeof (struct alpha_elf_link_hash_entry),
291                                       ALPHA_ELF_DATA))
292     {
293       free (ret);
294       return NULL;
295     }
296
297   return &ret->root.root;
298 }
299 \f
300 /* Alpha ELF follows MIPS ELF in using a special find_nearest_line
301    routine in order to handle the ECOFF debugging information.  */
302
303 struct alpha_elf_find_line
304 {
305   struct ecoff_debug_info d;
306   struct ecoff_find_line i;
307 };
308
309 /* We have some private fields hanging off of the elf_tdata structure.  */
310
311 struct alpha_elf_obj_tdata
312 {
313   struct elf_obj_tdata root;
314
315   /* For every input file, these are the got entries for that object's
316      local symbols.  */
317   struct alpha_elf_got_entry ** local_got_entries;
318
319   /* For every input file, this is the object that owns the got that
320      this input file uses.  */
321   bfd *gotobj;
322
323   /* For every got, this is a linked list through the objects using this got */
324   bfd *in_got_link_next;
325
326   /* For every got, this is a link to the next got subsegment.  */
327   bfd *got_link_next;
328
329   /* For every got, this is the section.  */
330   asection *got;
331
332   /* For every got, this is it's total number of words.  */
333   int total_got_size;
334
335   /* For every got, this is the sum of the number of words required
336      to hold all of the member object's local got.  */
337   int local_got_size;
338
339   /* Used by elf64_alpha_find_nearest_line entry point.  */
340   struct alpha_elf_find_line *find_line_info;
341
342 };
343
344 #define alpha_elf_tdata(abfd) \
345   ((struct alpha_elf_obj_tdata *) (abfd)->tdata.any)
346
347 #define is_alpha_elf(bfd) \
348   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
349    && elf_tdata (bfd) != NULL \
350    && elf_object_id (bfd) == ALPHA_ELF_DATA)
351
352 static bfd_boolean
353 elf64_alpha_mkobject (bfd *abfd)
354 {
355   return bfd_elf_allocate_object (abfd, sizeof (struct alpha_elf_obj_tdata),
356                                   ALPHA_ELF_DATA);
357 }
358
359 static bfd_boolean
360 elf64_alpha_object_p (bfd *abfd)
361 {
362   /* Set the right machine number for an Alpha ELF file.  */
363   return bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0);
364 }
365 \f
366 /* A relocation function which doesn't do anything.  */
367
368 static bfd_reloc_status_type
369 elf64_alpha_reloc_nil (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc,
370                        asymbol *sym ATTRIBUTE_UNUSED,
371                        void * data ATTRIBUTE_UNUSED, asection *sec,
372                        bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
373 {
374   if (output_bfd)
375     reloc->address += sec->output_offset;
376   return bfd_reloc_ok;
377 }
378
379 /* A relocation function used for an unsupported reloc.  */
380
381 static bfd_reloc_status_type
382 elf64_alpha_reloc_bad (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc,
383                        asymbol *sym ATTRIBUTE_UNUSED,
384                        void * data ATTRIBUTE_UNUSED, asection *sec,
385                        bfd *output_bfd, char **error_message ATTRIBUTE_UNUSED)
386 {
387   if (output_bfd)
388     reloc->address += sec->output_offset;
389   return bfd_reloc_notsupported;
390 }
391
392 /* Do the work of the GPDISP relocation.  */
393
394 static bfd_reloc_status_type
395 elf64_alpha_do_reloc_gpdisp (bfd *abfd, bfd_vma gpdisp, bfd_byte *p_ldah,
396                              bfd_byte *p_lda)
397 {
398   bfd_reloc_status_type ret = bfd_reloc_ok;
399   bfd_vma addend;
400   unsigned long i_ldah, i_lda;
401
402   i_ldah = bfd_get_32 (abfd, p_ldah);
403   i_lda = bfd_get_32 (abfd, p_lda);
404
405   /* Complain if the instructions are not correct.  */
406   if (((i_ldah >> 26) & 0x3f) != 0x09
407       || ((i_lda >> 26) & 0x3f) != 0x08)
408     ret = bfd_reloc_dangerous;
409
410   /* Extract the user-supplied offset, mirroring the sign extensions
411      that the instructions perform.  */
412   addend = ((i_ldah & 0xffff) << 16) | (i_lda & 0xffff);
413   addend = (addend ^ 0x80008000) - 0x80008000;
414
415   gpdisp += addend;
416
417   if ((bfd_signed_vma) gpdisp < -(bfd_signed_vma) 0x80000000
418       || (bfd_signed_vma) gpdisp >= (bfd_signed_vma) 0x7fff8000)
419     ret = bfd_reloc_overflow;
420
421   /* compensate for the sign extension again.  */
422   i_ldah = ((i_ldah & 0xffff0000)
423             | (((gpdisp >> 16) + ((gpdisp >> 15) & 1)) & 0xffff));
424   i_lda = (i_lda & 0xffff0000) | (gpdisp & 0xffff);
425
426   bfd_put_32 (abfd, (bfd_vma) i_ldah, p_ldah);
427   bfd_put_32 (abfd, (bfd_vma) i_lda, p_lda);
428
429   return ret;
430 }
431
432 /* The special function for the GPDISP reloc.  */
433
434 static bfd_reloc_status_type
435 elf64_alpha_reloc_gpdisp (bfd *abfd, arelent *reloc_entry,
436                           asymbol *sym ATTRIBUTE_UNUSED, void * data,
437                           asection *input_section, bfd *output_bfd,
438                           char **err_msg)
439 {
440   bfd_reloc_status_type ret;
441   bfd_vma gp, relocation;
442   bfd_vma high_address;
443   bfd_byte *p_ldah, *p_lda;
444
445   /* Don't do anything if we're not doing a final link.  */
446   if (output_bfd)
447     {
448       reloc_entry->address += input_section->output_offset;
449       return bfd_reloc_ok;
450     }
451
452   high_address = bfd_get_section_limit (abfd, input_section);
453   if (reloc_entry->address > high_address
454       || reloc_entry->address + reloc_entry->addend > high_address)
455     return bfd_reloc_outofrange;
456
457   /* The gp used in the portion of the output object to which this
458      input object belongs is cached on the input bfd.  */
459   gp = _bfd_get_gp_value (abfd);
460
461   relocation = (input_section->output_section->vma
462                 + input_section->output_offset
463                 + reloc_entry->address);
464
465   p_ldah = (bfd_byte *) data + reloc_entry->address;
466   p_lda = p_ldah + reloc_entry->addend;
467
468   ret = elf64_alpha_do_reloc_gpdisp (abfd, gp - relocation, p_ldah, p_lda);
469
470   /* Complain if the instructions are not correct.  */
471   if (ret == bfd_reloc_dangerous)
472     *err_msg = _("GPDISP relocation did not find ldah and lda instructions");
473
474   return ret;
475 }
476
477 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
478    from smaller values.  Start with zero, widen, *then* decrement.  */
479 #define MINUS_ONE       (((bfd_vma)0) - 1)
480
481
482 #define SKIP_HOWTO(N) \
483   HOWTO(N, 0, 0, 0, 0, 0, complain_overflow_dont, elf64_alpha_reloc_bad, 0, 0, 0, 0, 0)
484
485 static reloc_howto_type elf64_alpha_howto_table[] =
486 {
487   HOWTO (R_ALPHA_NONE,          /* type */
488          0,                     /* rightshift */
489          3,                     /* size (0 = byte, 1 = short, 2 = long) */
490          0,                     /* bitsize */
491          TRUE,                  /* pc_relative */
492          0,                     /* bitpos */
493          complain_overflow_dont, /* complain_on_overflow */
494          elf64_alpha_reloc_nil, /* special_function */
495          "NONE",                /* name */
496          FALSE,                 /* partial_inplace */
497          0,                     /* src_mask */
498          0,                     /* dst_mask */
499          TRUE),                 /* pcrel_offset */
500
501   /* A 32 bit reference to a symbol.  */
502   HOWTO (R_ALPHA_REFLONG,       /* type */
503          0,                     /* rightshift */
504          2,                     /* size (0 = byte, 1 = short, 2 = long) */
505          32,                    /* bitsize */
506          FALSE,                 /* pc_relative */
507          0,                     /* bitpos */
508          complain_overflow_bitfield, /* complain_on_overflow */
509          bfd_elf_generic_reloc, /* special_function */
510          "REFLONG",             /* name */
511          FALSE,                 /* partial_inplace */
512          0xffffffff,            /* src_mask */
513          0xffffffff,            /* dst_mask */
514          FALSE),                /* pcrel_offset */
515
516   /* A 64 bit reference to a symbol.  */
517   HOWTO (R_ALPHA_REFQUAD,       /* type */
518          0,                     /* rightshift */
519          4,                     /* size (0 = byte, 1 = short, 2 = long) */
520          64,                    /* bitsize */
521          FALSE,                 /* pc_relative */
522          0,                     /* bitpos */
523          complain_overflow_bitfield, /* complain_on_overflow */
524          bfd_elf_generic_reloc, /* special_function */
525          "REFQUAD",             /* name */
526          FALSE,                 /* partial_inplace */
527          MINUS_ONE,             /* src_mask */
528          MINUS_ONE,             /* dst_mask */
529          FALSE),                /* pcrel_offset */
530
531   /* A 32 bit GP relative offset.  This is just like REFLONG except
532      that when the value is used the value of the gp register will be
533      added in.  */
534   HOWTO (R_ALPHA_GPREL32,       /* type */
535          0,                     /* rightshift */
536          2,                     /* size (0 = byte, 1 = short, 2 = long) */
537          32,                    /* bitsize */
538          FALSE,                 /* pc_relative */
539          0,                     /* bitpos */
540          complain_overflow_bitfield, /* complain_on_overflow */
541          bfd_elf_generic_reloc, /* special_function */
542          "GPREL32",             /* name */
543          FALSE,                 /* partial_inplace */
544          0xffffffff,            /* src_mask */
545          0xffffffff,            /* dst_mask */
546          FALSE),                /* pcrel_offset */
547
548   /* Used for an instruction that refers to memory off the GP register.  */
549   HOWTO (R_ALPHA_LITERAL,       /* type */
550          0,                     /* rightshift */
551          1,                     /* size (0 = byte, 1 = short, 2 = long) */
552          16,                    /* bitsize */
553          FALSE,                 /* pc_relative */
554          0,                     /* bitpos */
555          complain_overflow_signed, /* complain_on_overflow */
556          bfd_elf_generic_reloc, /* special_function */
557          "ELF_LITERAL",         /* name */
558          FALSE,                 /* partial_inplace */
559          0xffff,                /* src_mask */
560          0xffff,                /* dst_mask */
561          FALSE),                /* pcrel_offset */
562
563   /* This reloc only appears immediately following an ELF_LITERAL reloc.
564      It identifies a use of the literal.  The symbol index is special:
565      1 means the literal address is in the base register of a memory
566      format instruction; 2 means the literal address is in the byte
567      offset register of a byte-manipulation instruction; 3 means the
568      literal address is in the target register of a jsr instruction.
569      This does not actually do any relocation.  */
570   HOWTO (R_ALPHA_LITUSE,        /* type */
571          0,                     /* rightshift */
572          1,                     /* size (0 = byte, 1 = short, 2 = long) */
573          32,                    /* bitsize */
574          FALSE,                 /* pc_relative */
575          0,                     /* bitpos */
576          complain_overflow_dont, /* complain_on_overflow */
577          elf64_alpha_reloc_nil, /* special_function */
578          "LITUSE",              /* name */
579          FALSE,                 /* partial_inplace */
580          0,                     /* src_mask */
581          0,                     /* dst_mask */
582          FALSE),                /* pcrel_offset */
583
584   /* Load the gp register.  This is always used for a ldah instruction
585      which loads the upper 16 bits of the gp register.  The symbol
586      index of the GPDISP instruction is an offset in bytes to the lda
587      instruction that loads the lower 16 bits.  The value to use for
588      the relocation is the difference between the GP value and the
589      current location; the load will always be done against a register
590      holding the current address.
591
592      NOTE: Unlike ECOFF, partial in-place relocation is not done.  If
593      any offset is present in the instructions, it is an offset from
594      the register to the ldah instruction.  This lets us avoid any
595      stupid hackery like inventing a gp value to do partial relocation
596      against.  Also unlike ECOFF, we do the whole relocation off of
597      the GPDISP rather than a GPDISP_HI16/GPDISP_LO16 pair.  An odd,
598      space consuming bit, that, since all the information was present
599      in the GPDISP_HI16 reloc.  */
600   HOWTO (R_ALPHA_GPDISP,        /* type */
601          16,                    /* rightshift */
602          2,                     /* size (0 = byte, 1 = short, 2 = long) */
603          16,                    /* bitsize */
604          FALSE,                 /* pc_relative */
605          0,                     /* bitpos */
606          complain_overflow_dont, /* complain_on_overflow */
607          elf64_alpha_reloc_gpdisp, /* special_function */
608          "GPDISP",              /* name */
609          FALSE,                 /* partial_inplace */
610          0xffff,                /* src_mask */
611          0xffff,                /* dst_mask */
612          TRUE),                 /* pcrel_offset */
613
614   /* A 21 bit branch.  */
615   HOWTO (R_ALPHA_BRADDR,        /* type */
616          2,                     /* rightshift */
617          2,                     /* size (0 = byte, 1 = short, 2 = long) */
618          21,                    /* bitsize */
619          TRUE,                  /* pc_relative */
620          0,                     /* bitpos */
621          complain_overflow_signed, /* complain_on_overflow */
622          bfd_elf_generic_reloc, /* special_function */
623          "BRADDR",              /* name */
624          FALSE,                 /* partial_inplace */
625          0x1fffff,              /* src_mask */
626          0x1fffff,              /* dst_mask */
627          TRUE),                 /* pcrel_offset */
628
629   /* A hint for a jump to a register.  */
630   HOWTO (R_ALPHA_HINT,          /* type */
631          2,                     /* rightshift */
632          1,                     /* size (0 = byte, 1 = short, 2 = long) */
633          14,                    /* bitsize */
634          TRUE,                  /* pc_relative */
635          0,                     /* bitpos */
636          complain_overflow_dont, /* complain_on_overflow */
637          bfd_elf_generic_reloc, /* special_function */
638          "HINT",                /* name */
639          FALSE,                 /* partial_inplace */
640          0x3fff,                /* src_mask */
641          0x3fff,                /* dst_mask */
642          TRUE),                 /* pcrel_offset */
643
644   /* 16 bit PC relative offset.  */
645   HOWTO (R_ALPHA_SREL16,        /* type */
646          0,                     /* rightshift */
647          1,                     /* size (0 = byte, 1 = short, 2 = long) */
648          16,                    /* bitsize */
649          TRUE,                  /* pc_relative */
650          0,                     /* bitpos */
651          complain_overflow_signed, /* complain_on_overflow */
652          bfd_elf_generic_reloc, /* special_function */
653          "SREL16",              /* name */
654          FALSE,                 /* partial_inplace */
655          0xffff,                /* src_mask */
656          0xffff,                /* dst_mask */
657          TRUE),                 /* pcrel_offset */
658
659   /* 32 bit PC relative offset.  */
660   HOWTO (R_ALPHA_SREL32,        /* type */
661          0,                     /* rightshift */
662          2,                     /* size (0 = byte, 1 = short, 2 = long) */
663          32,                    /* bitsize */
664          TRUE,                  /* pc_relative */
665          0,                     /* bitpos */
666          complain_overflow_signed, /* complain_on_overflow */
667          bfd_elf_generic_reloc, /* special_function */
668          "SREL32",              /* name */
669          FALSE,                 /* partial_inplace */
670          0xffffffff,            /* src_mask */
671          0xffffffff,            /* dst_mask */
672          TRUE),                 /* pcrel_offset */
673
674   /* A 64 bit PC relative offset.  */
675   HOWTO (R_ALPHA_SREL64,        /* type */
676          0,                     /* rightshift */
677          4,                     /* size (0 = byte, 1 = short, 2 = long) */
678          64,                    /* bitsize */
679          TRUE,                  /* pc_relative */
680          0,                     /* bitpos */
681          complain_overflow_signed, /* complain_on_overflow */
682          bfd_elf_generic_reloc, /* special_function */
683          "SREL64",              /* name */
684          FALSE,                 /* partial_inplace */
685          MINUS_ONE,             /* src_mask */
686          MINUS_ONE,             /* dst_mask */
687          TRUE),                 /* pcrel_offset */
688
689   /* Skip 12 - 16; deprecated ECOFF relocs.  */
690   SKIP_HOWTO (12),
691   SKIP_HOWTO (13),
692   SKIP_HOWTO (14),
693   SKIP_HOWTO (15),
694   SKIP_HOWTO (16),
695
696   /* The high 16 bits of the displacement from GP to the target.  */
697   HOWTO (R_ALPHA_GPRELHIGH,
698          0,                     /* rightshift */
699          1,                     /* size (0 = byte, 1 = short, 2 = long) */
700          16,                    /* bitsize */
701          FALSE,                 /* pc_relative */
702          0,                     /* bitpos */
703          complain_overflow_signed, /* complain_on_overflow */
704          bfd_elf_generic_reloc, /* special_function */
705          "GPRELHIGH",           /* name */
706          FALSE,                 /* partial_inplace */
707          0xffff,                /* src_mask */
708          0xffff,                /* dst_mask */
709          FALSE),                /* pcrel_offset */
710
711   /* The low 16 bits of the displacement from GP to the target.  */
712   HOWTO (R_ALPHA_GPRELLOW,
713          0,                     /* rightshift */
714          1,                     /* size (0 = byte, 1 = short, 2 = long) */
715          16,                    /* bitsize */
716          FALSE,                 /* pc_relative */
717          0,                     /* bitpos */
718          complain_overflow_dont, /* complain_on_overflow */
719          bfd_elf_generic_reloc, /* special_function */
720          "GPRELLOW",            /* name */
721          FALSE,                 /* partial_inplace */
722          0xffff,                /* src_mask */
723          0xffff,                /* dst_mask */
724          FALSE),                /* pcrel_offset */
725
726   /* A 16-bit displacement from the GP to the target.  */
727   HOWTO (R_ALPHA_GPREL16,
728          0,                     /* rightshift */
729          1,                     /* size (0 = byte, 1 = short, 2 = long) */
730          16,                    /* bitsize */
731          FALSE,                 /* pc_relative */
732          0,                     /* bitpos */
733          complain_overflow_signed, /* complain_on_overflow */
734          bfd_elf_generic_reloc, /* special_function */
735          "GPREL16",             /* name */
736          FALSE,                 /* partial_inplace */
737          0xffff,                /* src_mask */
738          0xffff,                /* dst_mask */
739          FALSE),                /* pcrel_offset */
740
741   /* Skip 20 - 23; deprecated ECOFF relocs.  */
742   SKIP_HOWTO (20),
743   SKIP_HOWTO (21),
744   SKIP_HOWTO (22),
745   SKIP_HOWTO (23),
746
747   /* Misc ELF relocations.  */
748
749   /* A dynamic relocation to copy the target into our .dynbss section.  */
750   /* Not generated, as all Alpha objects use PIC, so it is not needed.  It
751      is present because every other ELF has one, but should not be used
752      because .dynbss is an ugly thing.  */
753   HOWTO (R_ALPHA_COPY,
754          0,
755          0,
756          0,
757          FALSE,
758          0,
759          complain_overflow_dont,
760          bfd_elf_generic_reloc,
761          "COPY",
762          FALSE,
763          0,
764          0,
765          TRUE),
766
767   /* A dynamic relocation for a .got entry.  */
768   HOWTO (R_ALPHA_GLOB_DAT,
769          0,
770          0,
771          0,
772          FALSE,
773          0,
774          complain_overflow_dont,
775          bfd_elf_generic_reloc,
776          "GLOB_DAT",
777          FALSE,
778          0,
779          0,
780          TRUE),
781
782   /* A dynamic relocation for a .plt entry.  */
783   HOWTO (R_ALPHA_JMP_SLOT,
784          0,
785          0,
786          0,
787          FALSE,
788          0,
789          complain_overflow_dont,
790          bfd_elf_generic_reloc,
791          "JMP_SLOT",
792          FALSE,
793          0,
794          0,
795          TRUE),
796
797   /* A dynamic relocation to add the base of the DSO to a 64-bit field.  */
798   HOWTO (R_ALPHA_RELATIVE,
799          0,
800          0,
801          0,
802          FALSE,
803          0,
804          complain_overflow_dont,
805          bfd_elf_generic_reloc,
806          "RELATIVE",
807          FALSE,
808          0,
809          0,
810          TRUE),
811
812   /* A 21 bit branch that adjusts for gp loads.  */
813   HOWTO (R_ALPHA_BRSGP,         /* type */
814          2,                     /* rightshift */
815          2,                     /* size (0 = byte, 1 = short, 2 = long) */
816          21,                    /* bitsize */
817          TRUE,                  /* pc_relative */
818          0,                     /* bitpos */
819          complain_overflow_signed, /* complain_on_overflow */
820          bfd_elf_generic_reloc, /* special_function */
821          "BRSGP",               /* name */
822          FALSE,                 /* partial_inplace */
823          0x1fffff,              /* src_mask */
824          0x1fffff,              /* dst_mask */
825          TRUE),                 /* pcrel_offset */
826
827   /* Creates a tls_index for the symbol in the got.  */
828   HOWTO (R_ALPHA_TLSGD,         /* type */
829          0,                     /* rightshift */
830          1,                     /* size (0 = byte, 1 = short, 2 = long) */
831          16,                    /* bitsize */
832          FALSE,                 /* pc_relative */
833          0,                     /* bitpos */
834          complain_overflow_signed, /* complain_on_overflow */
835          bfd_elf_generic_reloc, /* special_function */
836          "TLSGD",               /* name */
837          FALSE,                 /* partial_inplace */
838          0xffff,                /* src_mask */
839          0xffff,                /* dst_mask */
840          FALSE),                /* pcrel_offset */
841
842   /* Creates a tls_index for the (current) module in the got.  */
843   HOWTO (R_ALPHA_TLSLDM,        /* type */
844          0,                     /* rightshift */
845          1,                     /* size (0 = byte, 1 = short, 2 = long) */
846          16,                    /* bitsize */
847          FALSE,                 /* pc_relative */
848          0,                     /* bitpos */
849          complain_overflow_signed, /* complain_on_overflow */
850          bfd_elf_generic_reloc, /* special_function */
851          "TLSLDM",              /* name */
852          FALSE,                 /* partial_inplace */
853          0xffff,                /* src_mask */
854          0xffff,                /* dst_mask */
855          FALSE),                /* pcrel_offset */
856
857   /* A dynamic relocation for a DTP module entry.  */
858   HOWTO (R_ALPHA_DTPMOD64,      /* type */
859          0,                     /* rightshift */
860          4,                     /* size (0 = byte, 1 = short, 2 = long) */
861          64,                    /* bitsize */
862          FALSE,                 /* pc_relative */
863          0,                     /* bitpos */
864          complain_overflow_bitfield, /* complain_on_overflow */
865          bfd_elf_generic_reloc, /* special_function */
866          "DTPMOD64",            /* name */
867          FALSE,                 /* partial_inplace */
868          MINUS_ONE,             /* src_mask */
869          MINUS_ONE,             /* dst_mask */
870          FALSE),                /* pcrel_offset */
871
872   /* Creates a 64-bit offset in the got for the displacement
873      from DTP to the target.  */
874   HOWTO (R_ALPHA_GOTDTPREL,     /* type */
875          0,                     /* rightshift */
876          1,                     /* size (0 = byte, 1 = short, 2 = long) */
877          16,                    /* bitsize */
878          FALSE,                 /* pc_relative */
879          0,                     /* bitpos */
880          complain_overflow_signed, /* complain_on_overflow */
881          bfd_elf_generic_reloc, /* special_function */
882          "GOTDTPREL",           /* name */
883          FALSE,                 /* partial_inplace */
884          0xffff,                /* src_mask */
885          0xffff,                /* dst_mask */
886          FALSE),                /* pcrel_offset */
887
888   /* A dynamic relocation for a displacement from DTP to the target.  */
889   HOWTO (R_ALPHA_DTPREL64,      /* type */
890          0,                     /* rightshift */
891          4,                     /* size (0 = byte, 1 = short, 2 = long) */
892          64,                    /* bitsize */
893          FALSE,                 /* pc_relative */
894          0,                     /* bitpos */
895          complain_overflow_bitfield, /* complain_on_overflow */
896          bfd_elf_generic_reloc, /* special_function */
897          "DTPREL64",            /* name */
898          FALSE,                 /* partial_inplace */
899          MINUS_ONE,             /* src_mask */
900          MINUS_ONE,             /* dst_mask */
901          FALSE),                /* pcrel_offset */
902
903   /* The high 16 bits of the displacement from DTP to the target.  */
904   HOWTO (R_ALPHA_DTPRELHI,      /* type */
905          0,                     /* rightshift */
906          1,                     /* size (0 = byte, 1 = short, 2 = long) */
907          16,                    /* bitsize */
908          FALSE,                 /* pc_relative */
909          0,                     /* bitpos */
910          complain_overflow_signed, /* complain_on_overflow */
911          bfd_elf_generic_reloc, /* special_function */
912          "DTPRELHI",            /* name */
913          FALSE,                 /* partial_inplace */
914          0xffff,                /* src_mask */
915          0xffff,                /* dst_mask */
916          FALSE),                /* pcrel_offset */
917
918   /* The low 16 bits of the displacement from DTP to the target.  */
919   HOWTO (R_ALPHA_DTPRELLO,      /* type */
920          0,                     /* rightshift */
921          1,                     /* size (0 = byte, 1 = short, 2 = long) */
922          16,                    /* bitsize */
923          FALSE,                 /* pc_relative */
924          0,                     /* bitpos */
925          complain_overflow_dont, /* complain_on_overflow */
926          bfd_elf_generic_reloc, /* special_function */
927          "DTPRELLO",            /* name */
928          FALSE,                 /* partial_inplace */
929          0xffff,                /* src_mask */
930          0xffff,                /* dst_mask */
931          FALSE),                /* pcrel_offset */
932
933   /* A 16-bit displacement from DTP to the target.  */
934   HOWTO (R_ALPHA_DTPREL16,      /* type */
935          0,                     /* rightshift */
936          1,                     /* size (0 = byte, 1 = short, 2 = long) */
937          16,                    /* bitsize */
938          FALSE,                 /* pc_relative */
939          0,                     /* bitpos */
940          complain_overflow_signed, /* complain_on_overflow */
941          bfd_elf_generic_reloc, /* special_function */
942          "DTPREL16",            /* name */
943          FALSE,                 /* partial_inplace */
944          0xffff,                /* src_mask */
945          0xffff,                /* dst_mask */
946          FALSE),                /* pcrel_offset */
947
948   /* Creates a 64-bit offset in the got for the displacement
949      from TP to the target.  */
950   HOWTO (R_ALPHA_GOTTPREL,      /* type */
951          0,                     /* rightshift */
952          1,                     /* size (0 = byte, 1 = short, 2 = long) */
953          16,                    /* bitsize */
954          FALSE,                 /* pc_relative */
955          0,                     /* bitpos */
956          complain_overflow_signed, /* complain_on_overflow */
957          bfd_elf_generic_reloc, /* special_function */
958          "GOTTPREL",            /* name */
959          FALSE,                 /* partial_inplace */
960          0xffff,                /* src_mask */
961          0xffff,                /* dst_mask */
962          FALSE),                /* pcrel_offset */
963
964   /* A dynamic relocation for a displacement from TP to the target.  */
965   HOWTO (R_ALPHA_TPREL64,       /* type */
966          0,                     /* rightshift */
967          4,                     /* size (0 = byte, 1 = short, 2 = long) */
968          64,                    /* bitsize */
969          FALSE,                 /* pc_relative */
970          0,                     /* bitpos */
971          complain_overflow_bitfield, /* complain_on_overflow */
972          bfd_elf_generic_reloc, /* special_function */
973          "TPREL64",             /* name */
974          FALSE,                 /* partial_inplace */
975          MINUS_ONE,             /* src_mask */
976          MINUS_ONE,             /* dst_mask */
977          FALSE),                /* pcrel_offset */
978
979   /* The high 16 bits of the displacement from TP to the target.  */
980   HOWTO (R_ALPHA_TPRELHI,       /* type */
981          0,                     /* rightshift */
982          1,                     /* size (0 = byte, 1 = short, 2 = long) */
983          16,                    /* bitsize */
984          FALSE,                 /* pc_relative */
985          0,                     /* bitpos */
986          complain_overflow_signed, /* complain_on_overflow */
987          bfd_elf_generic_reloc, /* special_function */
988          "TPRELHI",             /* name */
989          FALSE,                 /* partial_inplace */
990          0xffff,                /* src_mask */
991          0xffff,                /* dst_mask */
992          FALSE),                /* pcrel_offset */
993
994   /* The low 16 bits of the displacement from TP to the target.  */
995   HOWTO (R_ALPHA_TPRELLO,       /* type */
996          0,                     /* rightshift */
997          1,                     /* size (0 = byte, 1 = short, 2 = long) */
998          16,                    /* bitsize */
999          FALSE,                 /* pc_relative */
1000          0,                     /* bitpos */
1001          complain_overflow_dont, /* complain_on_overflow */
1002          bfd_elf_generic_reloc, /* special_function */
1003          "TPRELLO",             /* name */
1004          FALSE,                 /* partial_inplace */
1005          0xffff,                /* src_mask */
1006          0xffff,                /* dst_mask */
1007          FALSE),                /* pcrel_offset */
1008
1009   /* A 16-bit displacement from TP to the target.  */
1010   HOWTO (R_ALPHA_TPREL16,       /* type */
1011          0,                     /* rightshift */
1012          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1013          16,                    /* bitsize */
1014          FALSE,                 /* pc_relative */
1015          0,                     /* bitpos */
1016          complain_overflow_signed, /* complain_on_overflow */
1017          bfd_elf_generic_reloc, /* special_function */
1018          "TPREL16",             /* name */
1019          FALSE,                 /* partial_inplace */
1020          0xffff,                /* src_mask */
1021          0xffff,                /* dst_mask */
1022          FALSE),                /* pcrel_offset */
1023 };
1024
1025 /* A mapping from BFD reloc types to Alpha ELF reloc types.  */
1026
1027 struct elf_reloc_map
1028 {
1029   bfd_reloc_code_real_type bfd_reloc_val;
1030   int elf_reloc_val;
1031 };
1032
1033 static const struct elf_reloc_map elf64_alpha_reloc_map[] =
1034 {
1035   {BFD_RELOC_NONE,                      R_ALPHA_NONE},
1036   {BFD_RELOC_32,                        R_ALPHA_REFLONG},
1037   {BFD_RELOC_64,                        R_ALPHA_REFQUAD},
1038   {BFD_RELOC_CTOR,                      R_ALPHA_REFQUAD},
1039   {BFD_RELOC_GPREL32,                   R_ALPHA_GPREL32},
1040   {BFD_RELOC_ALPHA_ELF_LITERAL,         R_ALPHA_LITERAL},
1041   {BFD_RELOC_ALPHA_LITUSE,              R_ALPHA_LITUSE},
1042   {BFD_RELOC_ALPHA_GPDISP,              R_ALPHA_GPDISP},
1043   {BFD_RELOC_23_PCREL_S2,               R_ALPHA_BRADDR},
1044   {BFD_RELOC_ALPHA_HINT,                R_ALPHA_HINT},
1045   {BFD_RELOC_16_PCREL,                  R_ALPHA_SREL16},
1046   {BFD_RELOC_32_PCREL,                  R_ALPHA_SREL32},
1047   {BFD_RELOC_64_PCREL,                  R_ALPHA_SREL64},
1048   {BFD_RELOC_ALPHA_GPREL_HI16,          R_ALPHA_GPRELHIGH},
1049   {BFD_RELOC_ALPHA_GPREL_LO16,          R_ALPHA_GPRELLOW},
1050   {BFD_RELOC_GPREL16,                   R_ALPHA_GPREL16},
1051   {BFD_RELOC_ALPHA_BRSGP,               R_ALPHA_BRSGP},
1052   {BFD_RELOC_ALPHA_TLSGD,               R_ALPHA_TLSGD},
1053   {BFD_RELOC_ALPHA_TLSLDM,              R_ALPHA_TLSLDM},
1054   {BFD_RELOC_ALPHA_DTPMOD64,            R_ALPHA_DTPMOD64},
1055   {BFD_RELOC_ALPHA_GOTDTPREL16,         R_ALPHA_GOTDTPREL},
1056   {BFD_RELOC_ALPHA_DTPREL64,            R_ALPHA_DTPREL64},
1057   {BFD_RELOC_ALPHA_DTPREL_HI16,         R_ALPHA_DTPRELHI},
1058   {BFD_RELOC_ALPHA_DTPREL_LO16,         R_ALPHA_DTPRELLO},
1059   {BFD_RELOC_ALPHA_DTPREL16,            R_ALPHA_DTPREL16},
1060   {BFD_RELOC_ALPHA_GOTTPREL16,          R_ALPHA_GOTTPREL},
1061   {BFD_RELOC_ALPHA_TPREL64,             R_ALPHA_TPREL64},
1062   {BFD_RELOC_ALPHA_TPREL_HI16,          R_ALPHA_TPRELHI},
1063   {BFD_RELOC_ALPHA_TPREL_LO16,          R_ALPHA_TPRELLO},
1064   {BFD_RELOC_ALPHA_TPREL16,             R_ALPHA_TPREL16},
1065 };
1066
1067 /* Given a BFD reloc type, return a HOWTO structure.  */
1068
1069 static reloc_howto_type *
1070 elf64_alpha_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1071                                    bfd_reloc_code_real_type code)
1072 {
1073   const struct elf_reloc_map *i, *e;
1074   i = e = elf64_alpha_reloc_map;
1075   e += sizeof (elf64_alpha_reloc_map) / sizeof (struct elf_reloc_map);
1076   for (; i != e; ++i)
1077     {
1078       if (i->bfd_reloc_val == code)
1079         return &elf64_alpha_howto_table[i->elf_reloc_val];
1080     }
1081   return 0;
1082 }
1083
1084 static reloc_howto_type *
1085 elf64_alpha_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1086                                    const char *r_name)
1087 {
1088   unsigned int i;
1089
1090   for (i = 0;
1091        i < (sizeof (elf64_alpha_howto_table)
1092             / sizeof (elf64_alpha_howto_table[0]));
1093        i++)
1094     if (elf64_alpha_howto_table[i].name != NULL
1095         && strcasecmp (elf64_alpha_howto_table[i].name, r_name) == 0)
1096       return &elf64_alpha_howto_table[i];
1097
1098   return NULL;
1099 }
1100
1101 /* Given an Alpha ELF reloc type, fill in an arelent structure.  */
1102
1103 static bfd_boolean
1104 elf64_alpha_info_to_howto (bfd *abfd, arelent *cache_ptr,
1105                            Elf_Internal_Rela *dst)
1106 {
1107   unsigned r_type = ELF64_R_TYPE(dst->r_info);
1108
1109   if (r_type >= R_ALPHA_max)
1110     {
1111       /* xgettext:c-format */
1112       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1113                           abfd, r_type);
1114       bfd_set_error (bfd_error_bad_value);
1115       return FALSE;
1116     }
1117   cache_ptr->howto = &elf64_alpha_howto_table[r_type];
1118   return TRUE;
1119 }
1120
1121 /* These two relocations create a two-word entry in the got.  */
1122 #define alpha_got_entry_size(r_type) \
1123   (r_type == R_ALPHA_TLSGD || r_type == R_ALPHA_TLSLDM ? 16 : 8)
1124
1125 /* This is PT_TLS segment p_vaddr.  */
1126 #define alpha_get_dtprel_base(info) \
1127   (elf_hash_table (info)->tls_sec->vma)
1128
1129 /* Main program TLS (whose template starts at PT_TLS p_vaddr)
1130    is assigned offset round(16, PT_TLS p_align).  */
1131 #define alpha_get_tprel_base(info) \
1132   (elf_hash_table (info)->tls_sec->vma                                  \
1133    - align_power ((bfd_vma) 16,                                         \
1134                   elf_hash_table (info)->tls_sec->alignment_power))
1135 \f
1136 /* Handle an Alpha specific section when reading an object file.  This
1137    is called when bfd_section_from_shdr finds a section with an unknown
1138    type.
1139    FIXME: We need to handle the SHF_ALPHA_GPREL flag, but I'm not sure
1140    how to.  */
1141
1142 static bfd_boolean
1143 elf64_alpha_section_from_shdr (bfd *abfd,
1144                                Elf_Internal_Shdr *hdr,
1145                                const char *name,
1146                                int shindex)
1147 {
1148   asection *newsect;
1149
1150   /* There ought to be a place to keep ELF backend specific flags, but
1151      at the moment there isn't one.  We just keep track of the
1152      sections by their name, instead.  Fortunately, the ABI gives
1153      suggested names for all the MIPS specific sections, so we will
1154      probably get away with this.  */
1155   switch (hdr->sh_type)
1156     {
1157     case SHT_ALPHA_DEBUG:
1158       if (strcmp (name, ".mdebug") != 0)
1159         return FALSE;
1160       break;
1161     default:
1162       return FALSE;
1163     }
1164
1165   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1166     return FALSE;
1167   newsect = hdr->bfd_section;
1168
1169   if (hdr->sh_type == SHT_ALPHA_DEBUG)
1170     {
1171       if (! bfd_set_section_flags (abfd, newsect,
1172                                    (bfd_get_section_flags (abfd, newsect)
1173                                     | SEC_DEBUGGING)))
1174         return FALSE;
1175     }
1176
1177   return TRUE;
1178 }
1179
1180 /* Convert Alpha specific section flags to bfd internal section flags.  */
1181
1182 static bfd_boolean
1183 elf64_alpha_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
1184 {
1185   if (hdr->sh_flags & SHF_ALPHA_GPREL)
1186     *flags |= SEC_SMALL_DATA;
1187
1188   return TRUE;
1189 }
1190
1191 /* Set the correct type for an Alpha ELF section.  We do this by the
1192    section name, which is a hack, but ought to work.  */
1193
1194 static bfd_boolean
1195 elf64_alpha_fake_sections (bfd *abfd, Elf_Internal_Shdr *hdr, asection *sec)
1196 {
1197   register const char *name;
1198
1199   name = bfd_get_section_name (abfd, sec);
1200
1201   if (strcmp (name, ".mdebug") == 0)
1202     {
1203       hdr->sh_type = SHT_ALPHA_DEBUG;
1204       /* In a shared object on Irix 5.3, the .mdebug section has an
1205          entsize of 0.  FIXME: Does this matter?  */
1206       if ((abfd->flags & DYNAMIC) != 0 )
1207         hdr->sh_entsize = 0;
1208       else
1209         hdr->sh_entsize = 1;
1210     }
1211   else if ((sec->flags & SEC_SMALL_DATA)
1212            || strcmp (name, ".sdata") == 0
1213            || strcmp (name, ".sbss") == 0
1214            || strcmp (name, ".lit4") == 0
1215            || strcmp (name, ".lit8") == 0)
1216     hdr->sh_flags |= SHF_ALPHA_GPREL;
1217
1218   return TRUE;
1219 }
1220
1221 /* Hook called by the linker routine which adds symbols from an object
1222    file.  We use it to put .comm items in .sbss, and not .bss.  */
1223
1224 static bfd_boolean
1225 elf64_alpha_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
1226                              Elf_Internal_Sym *sym,
1227                              const char **namep ATTRIBUTE_UNUSED,
1228                              flagword *flagsp ATTRIBUTE_UNUSED,
1229                              asection **secp, bfd_vma *valp)
1230 {
1231   if (sym->st_shndx == SHN_COMMON
1232       && !bfd_link_relocatable (info)
1233       && sym->st_size <= elf_gp_size (abfd))
1234     {
1235       /* Common symbols less than or equal to -G nn bytes are
1236          automatically put into .sbss.  */
1237
1238       asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
1239
1240       if (scomm == NULL)
1241         {
1242           scomm = bfd_make_section_with_flags (abfd, ".scommon",
1243                                                (SEC_ALLOC
1244                                                 | SEC_IS_COMMON
1245                                                 | SEC_LINKER_CREATED));
1246           if (scomm == NULL)
1247             return FALSE;
1248         }
1249
1250       *secp = scomm;
1251       *valp = sym->st_size;
1252     }
1253
1254   return TRUE;
1255 }
1256
1257 /* Create the .got section.  */
1258
1259 static bfd_boolean
1260 elf64_alpha_create_got_section (bfd *abfd,
1261                                 struct bfd_link_info *info ATTRIBUTE_UNUSED)
1262 {
1263   flagword flags;
1264   asection *s;
1265
1266   if (! is_alpha_elf (abfd))
1267     return FALSE;
1268
1269   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1270            | SEC_LINKER_CREATED);
1271   s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
1272   if (s == NULL
1273       || !bfd_set_section_alignment (abfd, s, 3))
1274     return FALSE;
1275
1276   alpha_elf_tdata (abfd)->got = s;
1277
1278   /* Make sure the object's gotobj is set to itself so that we default
1279      to every object with its own .got.  We'll merge .gots later once
1280      we've collected each object's info.  */
1281   alpha_elf_tdata (abfd)->gotobj = abfd;
1282
1283   return TRUE;
1284 }
1285
1286 /* Create all the dynamic sections.  */
1287
1288 static bfd_boolean
1289 elf64_alpha_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
1290 {
1291   asection *s;
1292   flagword flags;
1293   struct elf_link_hash_entry *h;
1294
1295   if (! is_alpha_elf (abfd))
1296     return FALSE;
1297
1298   /* We need to create .plt, .rela.plt, .got, and .rela.got sections.  */
1299
1300   flags = (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1301            | SEC_LINKER_CREATED
1302            | (elf64_alpha_use_secureplt ? SEC_READONLY : 0));
1303   s = bfd_make_section_anyway_with_flags (abfd, ".plt", flags);
1304   elf_hash_table (info)->splt = s;
1305   if (s == NULL || ! bfd_set_section_alignment (abfd, s, 4))
1306     return FALSE;
1307
1308   /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1309      .plt section.  */
1310   h = _bfd_elf_define_linkage_sym (abfd, info, s,
1311                                    "_PROCEDURE_LINKAGE_TABLE_");
1312   elf_hash_table (info)->hplt = h;
1313   if (h == NULL)
1314     return FALSE;
1315
1316   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1317            | SEC_LINKER_CREATED | SEC_READONLY);
1318   s = bfd_make_section_anyway_with_flags (abfd, ".rela.plt", flags);
1319   elf_hash_table (info)->srelplt = s;
1320   if (s == NULL || ! bfd_set_section_alignment (abfd, s, 3))
1321     return FALSE;
1322
1323   if (elf64_alpha_use_secureplt)
1324     {
1325       flags = SEC_ALLOC | SEC_LINKER_CREATED;
1326       s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
1327       elf_hash_table (info)->sgotplt = s;
1328       if (s == NULL || ! bfd_set_section_alignment (abfd, s, 3))
1329         return FALSE;
1330     }
1331
1332   /* We may or may not have created a .got section for this object, but
1333      we definitely havn't done the rest of the work.  */
1334
1335   if (alpha_elf_tdata(abfd)->gotobj == NULL)
1336     {
1337       if (!elf64_alpha_create_got_section (abfd, info))
1338         return FALSE;
1339     }
1340
1341   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1342            | SEC_LINKER_CREATED | SEC_READONLY);
1343   s = bfd_make_section_anyway_with_flags (abfd, ".rela.got", flags);
1344   elf_hash_table (info)->srelgot = s;
1345   if (s == NULL
1346       || !bfd_set_section_alignment (abfd, s, 3))
1347     return FALSE;
1348
1349   /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the
1350      dynobj's .got section.  We don't do this in the linker script
1351      because we don't want to define the symbol if we are not creating
1352      a global offset table.  */
1353   h = _bfd_elf_define_linkage_sym (abfd, info, alpha_elf_tdata(abfd)->got,
1354                                    "_GLOBAL_OFFSET_TABLE_");
1355   elf_hash_table (info)->hgot = h;
1356   if (h == NULL)
1357     return FALSE;
1358
1359   return TRUE;
1360 }
1361 \f
1362 /* Read ECOFF debugging information from a .mdebug section into a
1363    ecoff_debug_info structure.  */
1364
1365 static bfd_boolean
1366 elf64_alpha_read_ecoff_info (bfd *abfd, asection *section,
1367                              struct ecoff_debug_info *debug)
1368 {
1369   HDRR *symhdr;
1370   const struct ecoff_debug_swap *swap;
1371   char *ext_hdr = NULL;
1372
1373   swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1374   memset (debug, 0, sizeof (*debug));
1375
1376   ext_hdr = (char *) bfd_malloc (swap->external_hdr_size);
1377   if (ext_hdr == NULL && swap->external_hdr_size != 0)
1378     goto error_return;
1379
1380   if (! bfd_get_section_contents (abfd, section, ext_hdr, (file_ptr) 0,
1381                                   swap->external_hdr_size))
1382     goto error_return;
1383
1384   symhdr = &debug->symbolic_header;
1385   (*swap->swap_hdr_in) (abfd, ext_hdr, symhdr);
1386
1387   /* The symbolic header contains absolute file offsets and sizes to
1388      read.  */
1389 #define READ(ptr, offset, count, size, type)                            \
1390   if (symhdr->count == 0)                                               \
1391     debug->ptr = NULL;                                                  \
1392   else                                                                  \
1393     {                                                                   \
1394       bfd_size_type amt = (bfd_size_type) size * symhdr->count;         \
1395       debug->ptr = (type) bfd_malloc (amt);                             \
1396       if (debug->ptr == NULL)                                           \
1397         goto error_return;                                              \
1398       if (bfd_seek (abfd, (file_ptr) symhdr->offset, SEEK_SET) != 0     \
1399           || bfd_bread (debug->ptr, amt, abfd) != amt)                  \
1400         goto error_return;                                              \
1401     }
1402
1403   READ (line, cbLineOffset, cbLine, sizeof (unsigned char), unsigned char *);
1404   READ (external_dnr, cbDnOffset, idnMax, swap->external_dnr_size, void *);
1405   READ (external_pdr, cbPdOffset, ipdMax, swap->external_pdr_size, void *);
1406   READ (external_sym, cbSymOffset, isymMax, swap->external_sym_size, void *);
1407   READ (external_opt, cbOptOffset, ioptMax, swap->external_opt_size, void *);
1408   READ (external_aux, cbAuxOffset, iauxMax, sizeof (union aux_ext),
1409         union aux_ext *);
1410   READ (ss, cbSsOffset, issMax, sizeof (char), char *);
1411   READ (ssext, cbSsExtOffset, issExtMax, sizeof (char), char *);
1412   READ (external_fdr, cbFdOffset, ifdMax, swap->external_fdr_size, void *);
1413   READ (external_rfd, cbRfdOffset, crfd, swap->external_rfd_size, void *);
1414   READ (external_ext, cbExtOffset, iextMax, swap->external_ext_size, void *);
1415 #undef READ
1416
1417   debug->fdr = NULL;
1418
1419   return TRUE;
1420
1421  error_return:
1422   if (ext_hdr != NULL)
1423     free (ext_hdr);
1424   if (debug->line != NULL)
1425     free (debug->line);
1426   if (debug->external_dnr != NULL)
1427     free (debug->external_dnr);
1428   if (debug->external_pdr != NULL)
1429     free (debug->external_pdr);
1430   if (debug->external_sym != NULL)
1431     free (debug->external_sym);
1432   if (debug->external_opt != NULL)
1433     free (debug->external_opt);
1434   if (debug->external_aux != NULL)
1435     free (debug->external_aux);
1436   if (debug->ss != NULL)
1437     free (debug->ss);
1438   if (debug->ssext != NULL)
1439     free (debug->ssext);
1440   if (debug->external_fdr != NULL)
1441     free (debug->external_fdr);
1442   if (debug->external_rfd != NULL)
1443     free (debug->external_rfd);
1444   if (debug->external_ext != NULL)
1445     free (debug->external_ext);
1446   return FALSE;
1447 }
1448
1449 /* Alpha ELF local labels start with '$'.  */
1450
1451 static bfd_boolean
1452 elf64_alpha_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, const char *name)
1453 {
1454   return name[0] == '$';
1455 }
1456
1457 static bfd_boolean
1458 elf64_alpha_find_nearest_line (bfd *abfd, asymbol **symbols,
1459                                asection *section, bfd_vma offset,
1460                                const char **filename_ptr,
1461                                const char **functionname_ptr,
1462                                unsigned int *line_ptr,
1463                                unsigned int *discriminator_ptr)
1464 {
1465   asection *msec;
1466
1467   if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
1468                                      filename_ptr, functionname_ptr,
1469                                      line_ptr, discriminator_ptr,
1470                                      dwarf_debug_sections, 0,
1471                                      &elf_tdata (abfd)->dwarf2_find_line_info))
1472     return TRUE;
1473
1474   msec = bfd_get_section_by_name (abfd, ".mdebug");
1475   if (msec != NULL)
1476     {
1477       flagword origflags;
1478       struct alpha_elf_find_line *fi;
1479       const struct ecoff_debug_swap * const swap =
1480         get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1481
1482       /* If we are called during a link, alpha_elf_final_link may have
1483          cleared the SEC_HAS_CONTENTS field.  We force it back on here
1484          if appropriate (which it normally will be).  */
1485       origflags = msec->flags;
1486       if (elf_section_data (msec)->this_hdr.sh_type != SHT_NOBITS)
1487         msec->flags |= SEC_HAS_CONTENTS;
1488
1489       fi = alpha_elf_tdata (abfd)->find_line_info;
1490       if (fi == NULL)
1491         {
1492           bfd_size_type external_fdr_size;
1493           char *fraw_src;
1494           char *fraw_end;
1495           struct fdr *fdr_ptr;
1496           bfd_size_type amt = sizeof (struct alpha_elf_find_line);
1497
1498           fi = (struct alpha_elf_find_line *) bfd_zalloc (abfd, amt);
1499           if (fi == NULL)
1500             {
1501               msec->flags = origflags;
1502               return FALSE;
1503             }
1504
1505           if (!elf64_alpha_read_ecoff_info (abfd, msec, &fi->d))
1506             {
1507               msec->flags = origflags;
1508               return FALSE;
1509             }
1510
1511           /* Swap in the FDR information.  */
1512           amt = fi->d.symbolic_header.ifdMax * sizeof (struct fdr);
1513           fi->d.fdr = (struct fdr *) bfd_alloc (abfd, amt);
1514           if (fi->d.fdr == NULL)
1515             {
1516               msec->flags = origflags;
1517               return FALSE;
1518             }
1519           external_fdr_size = swap->external_fdr_size;
1520           fdr_ptr = fi->d.fdr;
1521           fraw_src = (char *) fi->d.external_fdr;
1522           fraw_end = (fraw_src
1523                       + fi->d.symbolic_header.ifdMax * external_fdr_size);
1524           for (; fraw_src < fraw_end; fraw_src += external_fdr_size, fdr_ptr++)
1525             (*swap->swap_fdr_in) (abfd, fraw_src, fdr_ptr);
1526
1527           alpha_elf_tdata (abfd)->find_line_info = fi;
1528
1529           /* Note that we don't bother to ever free this information.
1530              find_nearest_line is either called all the time, as in
1531              objdump -l, so the information should be saved, or it is
1532              rarely called, as in ld error messages, so the memory
1533              wasted is unimportant.  Still, it would probably be a
1534              good idea for free_cached_info to throw it away.  */
1535         }
1536
1537       if (_bfd_ecoff_locate_line (abfd, section, offset, &fi->d, swap,
1538                                   &fi->i, filename_ptr, functionname_ptr,
1539                                   line_ptr))
1540         {
1541           msec->flags = origflags;
1542           return TRUE;
1543         }
1544
1545       msec->flags = origflags;
1546     }
1547
1548   /* Fall back on the generic ELF find_nearest_line routine.  */
1549
1550   return _bfd_elf_find_nearest_line (abfd, symbols, section, offset,
1551                                      filename_ptr, functionname_ptr,
1552                                      line_ptr, discriminator_ptr);
1553 }
1554 \f
1555 /* Structure used to pass information to alpha_elf_output_extsym.  */
1556
1557 struct extsym_info
1558 {
1559   bfd *abfd;
1560   struct bfd_link_info *info;
1561   struct ecoff_debug_info *debug;
1562   const struct ecoff_debug_swap *swap;
1563   bfd_boolean failed;
1564 };
1565
1566 static bfd_boolean
1567 elf64_alpha_output_extsym (struct alpha_elf_link_hash_entry *h, void * data)
1568 {
1569   struct extsym_info *einfo = (struct extsym_info *) data;
1570   bfd_boolean strip;
1571   asection *sec, *output_section;
1572
1573   if (h->root.indx == -2)
1574     strip = FALSE;
1575   else if ((h->root.def_dynamic
1576             || h->root.ref_dynamic
1577             || h->root.root.type == bfd_link_hash_new)
1578            && !h->root.def_regular
1579            && !h->root.ref_regular)
1580     strip = TRUE;
1581   else if (einfo->info->strip == strip_all
1582            || (einfo->info->strip == strip_some
1583                && bfd_hash_lookup (einfo->info->keep_hash,
1584                                    h->root.root.root.string,
1585                                    FALSE, FALSE) == NULL))
1586     strip = TRUE;
1587   else
1588     strip = FALSE;
1589
1590   if (strip)
1591     return TRUE;
1592
1593   if (h->esym.ifd == -2)
1594     {
1595       h->esym.jmptbl = 0;
1596       h->esym.cobol_main = 0;
1597       h->esym.weakext = 0;
1598       h->esym.reserved = 0;
1599       h->esym.ifd = ifdNil;
1600       h->esym.asym.value = 0;
1601       h->esym.asym.st = stGlobal;
1602
1603       if (h->root.root.type != bfd_link_hash_defined
1604           && h->root.root.type != bfd_link_hash_defweak)
1605         h->esym.asym.sc = scAbs;
1606       else
1607         {
1608           const char *name;
1609
1610           sec = h->root.root.u.def.section;
1611           output_section = sec->output_section;
1612
1613           /* When making a shared library and symbol h is the one from
1614              the another shared library, OUTPUT_SECTION may be null.  */
1615           if (output_section == NULL)
1616             h->esym.asym.sc = scUndefined;
1617           else
1618             {
1619               name = bfd_section_name (output_section->owner, output_section);
1620
1621               if (strcmp (name, ".text") == 0)
1622                 h->esym.asym.sc = scText;
1623               else if (strcmp (name, ".data") == 0)
1624                 h->esym.asym.sc = scData;
1625               else if (strcmp (name, ".sdata") == 0)
1626                 h->esym.asym.sc = scSData;
1627               else if (strcmp (name, ".rodata") == 0
1628                        || strcmp (name, ".rdata") == 0)
1629                 h->esym.asym.sc = scRData;
1630               else if (strcmp (name, ".bss") == 0)
1631                 h->esym.asym.sc = scBss;
1632               else if (strcmp (name, ".sbss") == 0)
1633                 h->esym.asym.sc = scSBss;
1634               else if (strcmp (name, ".init") == 0)
1635                 h->esym.asym.sc = scInit;
1636               else if (strcmp (name, ".fini") == 0)
1637                 h->esym.asym.sc = scFini;
1638               else
1639                 h->esym.asym.sc = scAbs;
1640             }
1641         }
1642
1643       h->esym.asym.reserved = 0;
1644       h->esym.asym.index = indexNil;
1645     }
1646
1647   if (h->root.root.type == bfd_link_hash_common)
1648     h->esym.asym.value = h->root.root.u.c.size;
1649   else if (h->root.root.type == bfd_link_hash_defined
1650            || h->root.root.type == bfd_link_hash_defweak)
1651     {
1652       if (h->esym.asym.sc == scCommon)
1653         h->esym.asym.sc = scBss;
1654       else if (h->esym.asym.sc == scSCommon)
1655         h->esym.asym.sc = scSBss;
1656
1657       sec = h->root.root.u.def.section;
1658       output_section = sec->output_section;
1659       if (output_section != NULL)
1660         h->esym.asym.value = (h->root.root.u.def.value
1661                               + sec->output_offset
1662                               + output_section->vma);
1663       else
1664         h->esym.asym.value = 0;
1665     }
1666
1667   if (! bfd_ecoff_debug_one_external (einfo->abfd, einfo->debug, einfo->swap,
1668                                       h->root.root.root.string,
1669                                       &h->esym))
1670     {
1671       einfo->failed = TRUE;
1672       return FALSE;
1673     }
1674
1675   return TRUE;
1676 }
1677 \f
1678 /* Search for and possibly create a got entry.  */
1679
1680 static struct alpha_elf_got_entry *
1681 get_got_entry (bfd *abfd, struct alpha_elf_link_hash_entry *h,
1682                unsigned long r_type, unsigned long r_symndx,
1683                bfd_vma r_addend)
1684 {
1685   struct alpha_elf_got_entry *gotent;
1686   struct alpha_elf_got_entry **slot;
1687
1688   if (h)
1689     slot = &h->got_entries;
1690   else
1691     {
1692       /* This is a local .got entry -- record for merge.  */
1693
1694       struct alpha_elf_got_entry **local_got_entries;
1695
1696       local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
1697       if (!local_got_entries)
1698         {
1699           bfd_size_type size;
1700           Elf_Internal_Shdr *symtab_hdr;
1701
1702           symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
1703           size = symtab_hdr->sh_info;
1704           size *= sizeof (struct alpha_elf_got_entry *);
1705
1706           local_got_entries
1707             = (struct alpha_elf_got_entry **) bfd_zalloc (abfd, size);
1708           if (!local_got_entries)
1709             return NULL;
1710
1711           alpha_elf_tdata (abfd)->local_got_entries = local_got_entries;
1712         }
1713
1714       slot = &local_got_entries[r_symndx];
1715     }
1716
1717   for (gotent = *slot; gotent ; gotent = gotent->next)
1718     if (gotent->gotobj == abfd
1719         && gotent->reloc_type == r_type
1720         && gotent->addend == r_addend)
1721       break;
1722
1723   if (!gotent)
1724     {
1725       int entry_size;
1726       bfd_size_type amt;
1727
1728       amt = sizeof (struct alpha_elf_got_entry);
1729       gotent = (struct alpha_elf_got_entry *) bfd_alloc (abfd, amt);
1730       if (!gotent)
1731         return NULL;
1732
1733       gotent->gotobj = abfd;
1734       gotent->addend = r_addend;
1735       gotent->got_offset = -1;
1736       gotent->plt_offset = -1;
1737       gotent->use_count = 1;
1738       gotent->reloc_type = r_type;
1739       gotent->reloc_done = 0;
1740       gotent->reloc_xlated = 0;
1741
1742       gotent->next = *slot;
1743       *slot = gotent;
1744
1745       entry_size = alpha_got_entry_size (r_type);
1746       alpha_elf_tdata (abfd)->total_got_size += entry_size;
1747       if (!h)
1748         alpha_elf_tdata(abfd)->local_got_size += entry_size;
1749     }
1750   else
1751     gotent->use_count += 1;
1752
1753   return gotent;
1754 }
1755
1756 static bfd_boolean
1757 elf64_alpha_want_plt (struct alpha_elf_link_hash_entry *ah)
1758 {
1759   return ((ah->root.type == STT_FUNC
1760           || ah->root.root.type == bfd_link_hash_undefweak
1761           || ah->root.root.type == bfd_link_hash_undefined)
1762           && (ah->flags & ALPHA_ELF_LINK_HASH_LU_PLT) != 0
1763           && (ah->flags & ~ALPHA_ELF_LINK_HASH_LU_PLT) == 0);
1764 }
1765
1766 /* Whether to sort relocs output by ld -r or ld --emit-relocs, by r_offset.
1767    Don't do so for code sections.  We want to keep ordering of LITERAL/LITUSE
1768    as is.  On the other hand, elf-eh-frame.c processing requires .eh_frame
1769    relocs to be sorted.  */
1770
1771 static bfd_boolean
1772 elf64_alpha_sort_relocs_p (asection *sec)
1773 {
1774   return (sec->flags & SEC_CODE) == 0;
1775 }
1776
1777
1778 /* Handle dynamic relocations when doing an Alpha ELF link.  */
1779
1780 static bfd_boolean
1781 elf64_alpha_check_relocs (bfd *abfd, struct bfd_link_info *info,
1782                           asection *sec, const Elf_Internal_Rela *relocs)
1783 {
1784   bfd *dynobj;
1785   asection *sreloc;
1786   Elf_Internal_Shdr *symtab_hdr;
1787   struct alpha_elf_link_hash_entry **sym_hashes;
1788   const Elf_Internal_Rela *rel, *relend;
1789   bfd_size_type amt;
1790
1791   if (bfd_link_relocatable (info))
1792     return TRUE;
1793
1794   /* Don't do anything special with non-loaded, non-alloced sections.
1795      In particular, any relocs in such sections should not affect GOT
1796      and PLT reference counting (ie. we don't allow them to create GOT
1797      or PLT entries), there's no possibility or desire to optimize TLS
1798      relocs, and there's not much point in propagating relocs to shared
1799      libs that the dynamic linker won't relocate.  */
1800   if ((sec->flags & SEC_ALLOC) == 0)
1801     return TRUE;
1802
1803   BFD_ASSERT (is_alpha_elf (abfd));
1804
1805   dynobj = elf_hash_table (info)->dynobj;
1806   if (dynobj == NULL)
1807     elf_hash_table (info)->dynobj = dynobj = abfd;
1808
1809   sreloc = NULL;
1810   symtab_hdr = &elf_symtab_hdr (abfd);
1811   sym_hashes = alpha_elf_sym_hashes (abfd);
1812
1813   relend = relocs + sec->reloc_count;
1814   for (rel = relocs; rel < relend; ++rel)
1815     {
1816       enum {
1817         NEED_GOT = 1,
1818         NEED_GOT_ENTRY = 2,
1819         NEED_DYNREL = 4
1820       };
1821
1822       unsigned long r_symndx, r_type;
1823       struct alpha_elf_link_hash_entry *h;
1824       unsigned int gotent_flags;
1825       bfd_boolean maybe_dynamic;
1826       unsigned int need;
1827       bfd_vma addend;
1828
1829       r_symndx = ELF64_R_SYM (rel->r_info);
1830       if (r_symndx < symtab_hdr->sh_info)
1831         h = NULL;
1832       else
1833         {
1834           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1835
1836           while (h->root.root.type == bfd_link_hash_indirect
1837                  || h->root.root.type == bfd_link_hash_warning)
1838             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
1839
1840           /* PR15323, ref flags aren't set for references in the same
1841              object.  */
1842           h->root.ref_regular = 1;
1843         }
1844
1845       /* We can only get preliminary data on whether a symbol is
1846          locally or externally defined, as not all of the input files
1847          have yet been processed.  Do something with what we know, as
1848          this may help reduce memory usage and processing time later.  */
1849       maybe_dynamic = FALSE;
1850       if (h && ((bfd_link_pic (info)
1851                  && (!info->symbolic
1852                      || info->unresolved_syms_in_shared_libs == RM_IGNORE))
1853                 || !h->root.def_regular
1854                 || h->root.root.type == bfd_link_hash_defweak))
1855         maybe_dynamic = TRUE;
1856
1857       need = 0;
1858       gotent_flags = 0;
1859       r_type = ELF64_R_TYPE (rel->r_info);
1860       addend = rel->r_addend;
1861
1862       switch (r_type)
1863         {
1864         case R_ALPHA_LITERAL:
1865           need = NEED_GOT | NEED_GOT_ENTRY;
1866
1867           /* Remember how this literal is used from its LITUSEs.
1868              This will be important when it comes to decide if we can
1869              create a .plt entry for a function symbol.  */
1870           while (++rel < relend && ELF64_R_TYPE (rel->r_info) == R_ALPHA_LITUSE)
1871             if (rel->r_addend >= 1 && rel->r_addend <= 6)
1872               gotent_flags |= 1 << rel->r_addend;
1873           --rel;
1874
1875           /* No LITUSEs -- presumably the address is used somehow.  */
1876           if (gotent_flags == 0)
1877             gotent_flags = ALPHA_ELF_LINK_HASH_LU_ADDR;
1878           break;
1879
1880         case R_ALPHA_GPDISP:
1881         case R_ALPHA_GPREL16:
1882         case R_ALPHA_GPREL32:
1883         case R_ALPHA_GPRELHIGH:
1884         case R_ALPHA_GPRELLOW:
1885         case R_ALPHA_BRSGP:
1886           need = NEED_GOT;
1887           break;
1888
1889         case R_ALPHA_REFLONG:
1890         case R_ALPHA_REFQUAD:
1891           if (bfd_link_pic (info) || maybe_dynamic)
1892             need = NEED_DYNREL;
1893           break;
1894
1895         case R_ALPHA_TLSLDM:
1896           /* The symbol for a TLSLDM reloc is ignored.  Collapse the
1897              reloc to the STN_UNDEF (0) symbol so that they all match.  */
1898           r_symndx = STN_UNDEF;
1899           h = 0;
1900           maybe_dynamic = FALSE;
1901           /* FALLTHRU */
1902
1903         case R_ALPHA_TLSGD:
1904         case R_ALPHA_GOTDTPREL:
1905           need = NEED_GOT | NEED_GOT_ENTRY;
1906           break;
1907
1908         case R_ALPHA_GOTTPREL:
1909           need = NEED_GOT | NEED_GOT_ENTRY;
1910           gotent_flags = ALPHA_ELF_LINK_HASH_TLS_IE;
1911           if (bfd_link_pic (info))
1912             info->flags |= DF_STATIC_TLS;
1913           break;
1914
1915         case R_ALPHA_TPREL64:
1916           if (bfd_link_dll (info))
1917             {
1918               info->flags |= DF_STATIC_TLS;
1919               need = NEED_DYNREL;
1920             }
1921           else if (maybe_dynamic)
1922             need = NEED_DYNREL;
1923           break;
1924         }
1925
1926       if (need & NEED_GOT)
1927         {
1928           if (alpha_elf_tdata(abfd)->gotobj == NULL)
1929             {
1930               if (!elf64_alpha_create_got_section (abfd, info))
1931                 return FALSE;
1932             }
1933         }
1934
1935       if (need & NEED_GOT_ENTRY)
1936         {
1937           struct alpha_elf_got_entry *gotent;
1938
1939           gotent = get_got_entry (abfd, h, r_type, r_symndx, addend);
1940           if (!gotent)
1941             return FALSE;
1942
1943           if (gotent_flags)
1944             {
1945               gotent->flags |= gotent_flags;
1946               if (h)
1947                 {
1948                   gotent_flags |= h->flags;
1949                   h->flags = gotent_flags;
1950
1951                   /* Make a guess as to whether a .plt entry is needed.  */
1952                   /* ??? It appears that we won't make it into
1953                      adjust_dynamic_symbol for symbols that remain
1954                      totally undefined.  Copying this check here means
1955                      we can create a plt entry for them too.  */
1956                   h->root.needs_plt
1957                     = (maybe_dynamic && elf64_alpha_want_plt (h));
1958                 }
1959             }
1960         }
1961
1962       if (need & NEED_DYNREL)
1963         {
1964           /* We need to create the section here now whether we eventually
1965              use it or not so that it gets mapped to an output section by
1966              the linker.  If not used, we'll kill it in size_dynamic_sections.  */
1967           if (sreloc == NULL)
1968             {
1969               sreloc = _bfd_elf_make_dynamic_reloc_section
1970                 (sec, dynobj, 3, abfd, /*rela?*/ TRUE);
1971
1972               if (sreloc == NULL)
1973                 return FALSE;
1974             }
1975
1976           if (h)
1977             {
1978               /* Since we havn't seen all of the input symbols yet, we
1979                  don't know whether we'll actually need a dynamic relocation
1980                  entry for this reloc.  So make a record of it.  Once we
1981                  find out if this thing needs dynamic relocation we'll
1982                  expand the relocation sections by the appropriate amount.  */
1983
1984               struct alpha_elf_reloc_entry *rent;
1985
1986               for (rent = h->reloc_entries; rent; rent = rent->next)
1987                 if (rent->rtype == r_type && rent->srel == sreloc)
1988                   break;
1989
1990               if (!rent)
1991                 {
1992                   amt = sizeof (struct alpha_elf_reloc_entry);
1993                   rent = (struct alpha_elf_reloc_entry *) bfd_alloc (abfd, amt);
1994                   if (!rent)
1995                     return FALSE;
1996
1997                   rent->srel = sreloc;
1998                   rent->rtype = r_type;
1999                   rent->count = 1;
2000                   rent->reltext = (sec->flags & SEC_READONLY) != 0;
2001
2002                   rent->next = h->reloc_entries;
2003                   h->reloc_entries = rent;
2004                 }
2005               else
2006                 rent->count++;
2007             }
2008           else if (bfd_link_pic (info))
2009             {
2010               /* If this is a shared library, and the section is to be
2011                  loaded into memory, we need a RELATIVE reloc.  */
2012               sreloc->size += sizeof (Elf64_External_Rela);
2013               if (sec->flags & SEC_READONLY)
2014                 info->flags |= DF_TEXTREL;
2015             }
2016         }
2017     }
2018
2019   return TRUE;
2020 }
2021
2022 /* Return the section that should be marked against GC for a given
2023    relocation.  */
2024
2025 static asection *
2026 elf64_alpha_gc_mark_hook (asection *sec, struct bfd_link_info *info,
2027                           Elf_Internal_Rela *rel,
2028                           struct elf_link_hash_entry *h, Elf_Internal_Sym *sym)
2029 {
2030   /* These relocations don't really reference a symbol.  Instead we store
2031      extra data in their addend slot.  Ignore the symbol.  */
2032   switch (ELF64_R_TYPE (rel->r_info))
2033     {
2034     case R_ALPHA_LITUSE:
2035     case R_ALPHA_GPDISP:
2036     case R_ALPHA_HINT:
2037       return NULL;
2038     }
2039
2040   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2041 }
2042
2043 /* Adjust a symbol defined by a dynamic object and referenced by a
2044    regular object.  The current definition is in some section of the
2045    dynamic object, but we're not including those sections.  We have to
2046    change the definition to something the rest of the link can
2047    understand.  */
2048
2049 static bfd_boolean
2050 elf64_alpha_adjust_dynamic_symbol (struct bfd_link_info *info,
2051                                    struct elf_link_hash_entry *h)
2052 {
2053   bfd *dynobj;
2054   asection *s;
2055   struct alpha_elf_link_hash_entry *ah;
2056
2057   dynobj = elf_hash_table(info)->dynobj;
2058   ah = (struct alpha_elf_link_hash_entry *)h;
2059
2060   /* Now that we've seen all of the input symbols, finalize our decision
2061      about whether this symbol should get a .plt entry.  Irritatingly, it
2062      is common for folk to leave undefined symbols in shared libraries,
2063      and they still expect lazy binding; accept undefined symbols in lieu
2064      of STT_FUNC.  */
2065   if (alpha_elf_dynamic_symbol_p (h, info) && elf64_alpha_want_plt (ah))
2066     {
2067       h->needs_plt = TRUE;
2068
2069       s = elf_hash_table(info)->splt;
2070       if (!s && !elf64_alpha_create_dynamic_sections (dynobj, info))
2071         return FALSE;
2072
2073       /* We need one plt entry per got subsection.  Delay allocation of
2074          the actual plt entries until size_plt_section, called from
2075          size_dynamic_sections or during relaxation.  */
2076
2077       return TRUE;
2078     }
2079   else
2080     h->needs_plt = FALSE;
2081
2082   /* If this is a weak symbol, and there is a real definition, the
2083      processor independent code will have arranged for us to see the
2084      real definition first, and we can just use the same value.  */
2085   if (h->is_weakalias)
2086     {
2087       struct elf_link_hash_entry *def = weakdef (h);
2088       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
2089       h->root.u.def.section = def->root.u.def.section;
2090       h->root.u.def.value = def->root.u.def.value;
2091       return TRUE;
2092     }
2093
2094   /* This is a reference to a symbol defined by a dynamic object which
2095      is not a function.  The Alpha, since it uses .got entries for all
2096      symbols even in regular objects, does not need the hackery of a
2097      .dynbss section and COPY dynamic relocations.  */
2098
2099   return TRUE;
2100 }
2101
2102 /* Record STO_ALPHA_NOPV and STO_ALPHA_STD_GPLOAD.  */
2103
2104 static void
2105 elf64_alpha_merge_symbol_attribute (struct elf_link_hash_entry *h,
2106                                     const Elf_Internal_Sym *isym,
2107                                     bfd_boolean definition,
2108                                     bfd_boolean dynamic)
2109 {
2110   if (!dynamic && definition)
2111     h->other = ((h->other & ELF_ST_VISIBILITY (-1))
2112                 | (isym->st_other & ~ELF_ST_VISIBILITY (-1)));
2113 }
2114
2115 /* Symbol versioning can create new symbols, and make our old symbols
2116    indirect to the new ones.  Consolidate the got and reloc information
2117    in these situations.  */
2118
2119 static void
2120 elf64_alpha_copy_indirect_symbol (struct bfd_link_info *info,
2121                                   struct elf_link_hash_entry *dir,
2122                                   struct elf_link_hash_entry *ind)
2123 {
2124   struct alpha_elf_link_hash_entry *hi
2125     = (struct alpha_elf_link_hash_entry *) ind;
2126   struct alpha_elf_link_hash_entry *hs
2127     = (struct alpha_elf_link_hash_entry *) dir;
2128
2129   /* Do the merging in the superclass.  */
2130   _bfd_elf_link_hash_copy_indirect(info, dir, ind);
2131
2132   /* Merge the flags.  Whee.  */
2133   hs->flags |= hi->flags;
2134
2135   /* ??? It's unclear to me what's really supposed to happen when
2136      "merging" defweak and defined symbols, given that we don't
2137      actually throw away the defweak.  This more-or-less copies
2138      the logic related to got and plt entries in the superclass.  */
2139   if (ind->root.type != bfd_link_hash_indirect)
2140     return;
2141
2142   /* Merge the .got entries.  Cannibalize the old symbol's list in
2143      doing so, since we don't need it anymore.  */
2144
2145   if (hs->got_entries == NULL)
2146     hs->got_entries = hi->got_entries;
2147   else
2148     {
2149       struct alpha_elf_got_entry *gi, *gs, *gin, *gsh;
2150
2151       gsh = hs->got_entries;
2152       for (gi = hi->got_entries; gi ; gi = gin)
2153         {
2154           gin = gi->next;
2155           for (gs = gsh; gs ; gs = gs->next)
2156             if (gi->gotobj == gs->gotobj
2157                 && gi->reloc_type == gs->reloc_type
2158                 && gi->addend == gs->addend)
2159               {
2160                 gs->use_count += gi->use_count;
2161                 goto got_found;
2162               }
2163           gi->next = hs->got_entries;
2164           hs->got_entries = gi;
2165         got_found:;
2166         }
2167     }
2168   hi->got_entries = NULL;
2169
2170   /* And similar for the reloc entries.  */
2171
2172   if (hs->reloc_entries == NULL)
2173     hs->reloc_entries = hi->reloc_entries;
2174   else
2175     {
2176       struct alpha_elf_reloc_entry *ri, *rs, *rin, *rsh;
2177
2178       rsh = hs->reloc_entries;
2179       for (ri = hi->reloc_entries; ri ; ri = rin)
2180         {
2181           rin = ri->next;
2182           for (rs = rsh; rs ; rs = rs->next)
2183             if (ri->rtype == rs->rtype && ri->srel == rs->srel)
2184               {
2185                 rs->count += ri->count;
2186                 goto found_reloc;
2187               }
2188           ri->next = hs->reloc_entries;
2189           hs->reloc_entries = ri;
2190         found_reloc:;
2191         }
2192     }
2193   hi->reloc_entries = NULL;
2194 }
2195
2196 /* Is it possible to merge two object file's .got tables?  */
2197
2198 static bfd_boolean
2199 elf64_alpha_can_merge_gots (bfd *a, bfd *b)
2200 {
2201   int total = alpha_elf_tdata (a)->total_got_size;
2202   bfd *bsub;
2203
2204   /* Trivial quick fallout test.  */
2205   if (total + alpha_elf_tdata (b)->total_got_size <= MAX_GOT_SIZE)
2206     return TRUE;
2207
2208   /* By their nature, local .got entries cannot be merged.  */
2209   if ((total += alpha_elf_tdata (b)->local_got_size) > MAX_GOT_SIZE)
2210     return FALSE;
2211
2212   /* Failing the common trivial comparison, we must effectively
2213      perform the merge.  Not actually performing the merge means that
2214      we don't have to store undo information in case we fail.  */
2215   for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2216     {
2217       struct alpha_elf_link_hash_entry **hashes = alpha_elf_sym_hashes (bsub);
2218       Elf_Internal_Shdr *symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2219       int i, n;
2220
2221       n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2222       for (i = 0; i < n; ++i)
2223         {
2224           struct alpha_elf_got_entry *ae, *be;
2225           struct alpha_elf_link_hash_entry *h;
2226
2227           h = hashes[i];
2228           while (h->root.root.type == bfd_link_hash_indirect
2229                  || h->root.root.type == bfd_link_hash_warning)
2230             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2231
2232           for (be = h->got_entries; be ; be = be->next)
2233             {
2234               if (be->use_count == 0)
2235                 continue;
2236               if (be->gotobj != b)
2237                 continue;
2238
2239               for (ae = h->got_entries; ae ; ae = ae->next)
2240                 if (ae->gotobj == a
2241                     && ae->reloc_type == be->reloc_type
2242                     && ae->addend == be->addend)
2243                   goto global_found;
2244
2245               total += alpha_got_entry_size (be->reloc_type);
2246               if (total > MAX_GOT_SIZE)
2247                 return FALSE;
2248             global_found:;
2249             }
2250         }
2251     }
2252
2253   return TRUE;
2254 }
2255
2256 /* Actually merge two .got tables.  */
2257
2258 static void
2259 elf64_alpha_merge_gots (bfd *a, bfd *b)
2260 {
2261   int total = alpha_elf_tdata (a)->total_got_size;
2262   bfd *bsub;
2263
2264   /* Remember local expansion.  */
2265   {
2266     int e = alpha_elf_tdata (b)->local_got_size;
2267     total += e;
2268     alpha_elf_tdata (a)->local_got_size += e;
2269   }
2270
2271   for (bsub = b; bsub ; bsub = alpha_elf_tdata (bsub)->in_got_link_next)
2272     {
2273       struct alpha_elf_got_entry **local_got_entries;
2274       struct alpha_elf_link_hash_entry **hashes;
2275       Elf_Internal_Shdr *symtab_hdr;
2276       int i, n;
2277
2278       /* Let the local .got entries know they are part of a new subsegment.  */
2279       local_got_entries = alpha_elf_tdata (bsub)->local_got_entries;
2280       if (local_got_entries)
2281         {
2282           n = elf_tdata (bsub)->symtab_hdr.sh_info;
2283           for (i = 0; i < n; ++i)
2284             {
2285               struct alpha_elf_got_entry *ent;
2286               for (ent = local_got_entries[i]; ent; ent = ent->next)
2287                 ent->gotobj = a;
2288             }
2289         }
2290
2291       /* Merge the global .got entries.  */
2292       hashes = alpha_elf_sym_hashes (bsub);
2293       symtab_hdr = &elf_tdata (bsub)->symtab_hdr;
2294
2295       n = NUM_SHDR_ENTRIES (symtab_hdr) - symtab_hdr->sh_info;
2296       for (i = 0; i < n; ++i)
2297         {
2298           struct alpha_elf_got_entry *ae, *be, **pbe, **start;
2299           struct alpha_elf_link_hash_entry *h;
2300
2301           h = hashes[i];
2302           while (h->root.root.type == bfd_link_hash_indirect
2303                  || h->root.root.type == bfd_link_hash_warning)
2304             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
2305
2306           pbe = start = &h->got_entries;
2307           while ((be = *pbe) != NULL)
2308             {
2309               if (be->use_count == 0)
2310                 {
2311                   *pbe = be->next;
2312                   memset (be, 0xa5, sizeof (*be));
2313                   goto kill;
2314                 }
2315               if (be->gotobj != b)
2316                 goto next;
2317
2318               for (ae = *start; ae ; ae = ae->next)
2319                 if (ae->gotobj == a
2320                     && ae->reloc_type == be->reloc_type
2321                     && ae->addend == be->addend)
2322                   {
2323                     ae->flags |= be->flags;
2324                     ae->use_count += be->use_count;
2325                     *pbe = be->next;
2326                     memset (be, 0xa5, sizeof (*be));
2327                     goto kill;
2328                   }
2329               be->gotobj = a;
2330               total += alpha_got_entry_size (be->reloc_type);
2331
2332             next:;
2333               pbe = &be->next;
2334             kill:;
2335             }
2336         }
2337
2338       alpha_elf_tdata (bsub)->gotobj = a;
2339     }
2340   alpha_elf_tdata (a)->total_got_size = total;
2341
2342   /* Merge the two in_got chains.  */
2343   {
2344     bfd *next;
2345
2346     bsub = a;
2347     while ((next = alpha_elf_tdata (bsub)->in_got_link_next) != NULL)
2348       bsub = next;
2349
2350     alpha_elf_tdata (bsub)->in_got_link_next = b;
2351   }
2352 }
2353
2354 /* Calculate the offsets for the got entries.  */
2355
2356 static bfd_boolean
2357 elf64_alpha_calc_got_offsets_for_symbol (struct alpha_elf_link_hash_entry *h,
2358                                          void * arg ATTRIBUTE_UNUSED)
2359 {
2360   struct alpha_elf_got_entry *gotent;
2361
2362   for (gotent = h->got_entries; gotent; gotent = gotent->next)
2363     if (gotent->use_count > 0)
2364       {
2365         struct alpha_elf_obj_tdata *td;
2366         bfd_size_type *plge;
2367
2368         td = alpha_elf_tdata (gotent->gotobj);
2369         plge = &td->got->size;
2370         gotent->got_offset = *plge;
2371         *plge += alpha_got_entry_size (gotent->reloc_type);
2372       }
2373
2374   return TRUE;
2375 }
2376
2377 static void
2378 elf64_alpha_calc_got_offsets (struct bfd_link_info *info)
2379 {
2380   bfd *i, *got_list;
2381   struct alpha_elf_link_hash_table * htab;
2382
2383   htab = alpha_elf_hash_table (info);
2384   if (htab == NULL)
2385     return;
2386   got_list = htab->got_list;
2387
2388   /* First, zero out the .got sizes, as we may be recalculating the
2389      .got after optimizing it.  */
2390   for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2391     alpha_elf_tdata(i)->got->size = 0;
2392
2393   /* Next, fill in the offsets for all the global entries.  */
2394   alpha_elf_link_hash_traverse (htab,
2395                                 elf64_alpha_calc_got_offsets_for_symbol,
2396                                 NULL);
2397
2398   /* Finally, fill in the offsets for the local entries.  */
2399   for (i = got_list; i ; i = alpha_elf_tdata(i)->got_link_next)
2400     {
2401       bfd_size_type got_offset = alpha_elf_tdata(i)->got->size;
2402       bfd *j;
2403
2404       for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2405         {
2406           struct alpha_elf_got_entry **local_got_entries, *gotent;
2407           int k, n;
2408
2409           local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2410           if (!local_got_entries)
2411             continue;
2412
2413           for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2414             for (gotent = local_got_entries[k]; gotent; gotent = gotent->next)
2415               if (gotent->use_count > 0)
2416                 {
2417                   gotent->got_offset = got_offset;
2418                   got_offset += alpha_got_entry_size (gotent->reloc_type);
2419                 }
2420         }
2421
2422       alpha_elf_tdata(i)->got->size = got_offset;
2423     }
2424 }
2425
2426 /* Constructs the gots.  */
2427
2428 static bfd_boolean
2429 elf64_alpha_size_got_sections (struct bfd_link_info *info,
2430                                bfd_boolean may_merge)
2431 {
2432   bfd *i, *got_list, *cur_got_obj = NULL;
2433   struct alpha_elf_link_hash_table * htab;
2434
2435   htab = alpha_elf_hash_table (info);
2436   if (htab == NULL)
2437     return FALSE;
2438   got_list = htab->got_list;
2439
2440   /* On the first time through, pretend we have an existing got list
2441      consisting of all of the input files.  */
2442   if (got_list == NULL)
2443     {
2444       for (i = info->input_bfds; i ; i = i->link.next)
2445         {
2446           bfd *this_got;
2447
2448           if (! is_alpha_elf (i))
2449             continue;
2450
2451           this_got = alpha_elf_tdata (i)->gotobj;
2452           if (this_got == NULL)
2453             continue;
2454
2455           /* We are assuming no merging has yet occurred.  */
2456           BFD_ASSERT (this_got == i);
2457
2458           if (alpha_elf_tdata (this_got)->total_got_size > MAX_GOT_SIZE)
2459             {
2460               /* Yikes! A single object file has too many entries.  */
2461               _bfd_error_handler
2462                 /* xgettext:c-format */
2463                 (_("%pB: .got subsegment exceeds 64K (size %d)"),
2464                  i, alpha_elf_tdata (this_got)->total_got_size);
2465               return FALSE;
2466             }
2467
2468           if (got_list == NULL)
2469             got_list = this_got;
2470           else
2471             alpha_elf_tdata(cur_got_obj)->got_link_next = this_got;
2472           cur_got_obj = this_got;
2473         }
2474
2475       /* Strange degenerate case of no got references.  */
2476       if (got_list == NULL)
2477         return TRUE;
2478
2479       htab->got_list = got_list;
2480     }
2481
2482   cur_got_obj = got_list;
2483   if (cur_got_obj == NULL)
2484     return FALSE;
2485
2486   if (may_merge)
2487     {
2488       i = alpha_elf_tdata(cur_got_obj)->got_link_next;
2489       while (i != NULL)
2490         {
2491           if (elf64_alpha_can_merge_gots (cur_got_obj, i))
2492             {
2493               elf64_alpha_merge_gots (cur_got_obj, i);
2494
2495               alpha_elf_tdata(i)->got->size = 0;
2496               i = alpha_elf_tdata(i)->got_link_next;
2497               alpha_elf_tdata(cur_got_obj)->got_link_next = i;
2498             }
2499           else
2500             {
2501               cur_got_obj = i;
2502               i = alpha_elf_tdata(i)->got_link_next;
2503             }
2504         }
2505     }
2506
2507   /* Once the gots have been merged, fill in the got offsets for
2508      everything therein.  */
2509   elf64_alpha_calc_got_offsets (info);
2510
2511   return TRUE;
2512 }
2513
2514 static bfd_boolean
2515 elf64_alpha_size_plt_section_1 (struct alpha_elf_link_hash_entry *h,
2516                                 void * data)
2517 {
2518   asection *splt = (asection *) data;
2519   struct alpha_elf_got_entry *gotent;
2520   bfd_boolean saw_one = FALSE;
2521
2522   /* If we didn't need an entry before, we still don't.  */
2523   if (!h->root.needs_plt)
2524     return TRUE;
2525
2526   /* For each LITERAL got entry still in use, allocate a plt entry.  */
2527   for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2528     if (gotent->reloc_type == R_ALPHA_LITERAL
2529         && gotent->use_count > 0)
2530       {
2531         if (splt->size == 0)
2532           splt->size = PLT_HEADER_SIZE;
2533         gotent->plt_offset = splt->size;
2534         splt->size += PLT_ENTRY_SIZE;
2535         saw_one = TRUE;
2536       }
2537
2538   /* If there weren't any, there's no longer a need for the PLT entry.  */
2539   if (!saw_one)
2540     h->root.needs_plt = FALSE;
2541
2542   return TRUE;
2543 }
2544
2545 /* Called from relax_section to rebuild the PLT in light of potential changes
2546    in the function's status.  */
2547
2548 static void
2549 elf64_alpha_size_plt_section (struct bfd_link_info *info)
2550 {
2551   asection *splt, *spltrel, *sgotplt;
2552   unsigned long entries;
2553   struct alpha_elf_link_hash_table * htab;
2554
2555   htab = alpha_elf_hash_table (info);
2556   if (htab == NULL)
2557     return;
2558
2559   splt = elf_hash_table(info)->splt;
2560   if (splt == NULL)
2561     return;
2562
2563   splt->size = 0;
2564
2565   alpha_elf_link_hash_traverse (htab,
2566                                 elf64_alpha_size_plt_section_1, splt);
2567
2568   /* Every plt entry requires a JMP_SLOT relocation.  */
2569   spltrel = elf_hash_table(info)->srelplt;
2570   entries = 0;
2571   if (splt->size)
2572     {
2573       if (elf64_alpha_use_secureplt)
2574         entries = (splt->size - NEW_PLT_HEADER_SIZE) / NEW_PLT_ENTRY_SIZE;
2575       else
2576         entries = (splt->size - OLD_PLT_HEADER_SIZE) / OLD_PLT_ENTRY_SIZE;
2577     }
2578   spltrel->size = entries * sizeof (Elf64_External_Rela);
2579
2580   /* When using the secureplt, we need two words somewhere in the data
2581      segment for the dynamic linker to tell us where to go.  This is the
2582      entire contents of the .got.plt section.  */
2583   if (elf64_alpha_use_secureplt)
2584     {
2585       sgotplt = elf_hash_table(info)->sgotplt;
2586       sgotplt->size = entries ? 16 : 0;
2587     }
2588 }
2589
2590 static bfd_boolean
2591 elf64_alpha_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2592                                   struct bfd_link_info *info)
2593 {
2594   bfd *i;
2595   struct alpha_elf_link_hash_table * htab;
2596
2597   if (bfd_link_relocatable (info))
2598     return TRUE;
2599
2600   htab = alpha_elf_hash_table (info);
2601   if (htab == NULL)
2602     return FALSE;
2603
2604   if (!elf64_alpha_size_got_sections (info, TRUE))
2605     return FALSE;
2606
2607   /* Allocate space for all of the .got subsections.  */
2608   i = htab->got_list;
2609   for ( ; i ; i = alpha_elf_tdata(i)->got_link_next)
2610     {
2611       asection *s = alpha_elf_tdata(i)->got;
2612       if (s->size > 0)
2613         {
2614           s->contents = (bfd_byte *) bfd_zalloc (i, s->size);
2615           if (s->contents == NULL)
2616             return FALSE;
2617         }
2618     }
2619
2620   return TRUE;
2621 }
2622
2623 /* The number of dynamic relocations required by a static relocation.  */
2624
2625 static int
2626 alpha_dynamic_entries_for_reloc (int r_type, int dynamic, int shared, int pie)
2627 {
2628   switch (r_type)
2629     {
2630     /* May appear in GOT entries.  */
2631     case R_ALPHA_TLSGD:
2632       return (dynamic ? 2 : shared ? 1 : 0);
2633     case R_ALPHA_TLSLDM:
2634       return shared;
2635     case R_ALPHA_LITERAL:
2636       return dynamic || shared;
2637     case R_ALPHA_GOTTPREL:
2638       return dynamic || (shared && !pie);
2639     case R_ALPHA_GOTDTPREL:
2640       return dynamic;
2641
2642     /* May appear in data sections.  */
2643     case R_ALPHA_REFLONG:
2644     case R_ALPHA_REFQUAD:
2645       return dynamic || shared;
2646     case R_ALPHA_TPREL64:
2647       return dynamic || (shared && !pie);
2648
2649     /* Everything else is illegal.  We'll issue an error during
2650        relocate_section.  */
2651     default:
2652       return 0;
2653     }
2654 }
2655
2656 /* Work out the sizes of the dynamic relocation entries.  */
2657
2658 static bfd_boolean
2659 elf64_alpha_calc_dynrel_sizes (struct alpha_elf_link_hash_entry *h,
2660                                struct bfd_link_info *info)
2661 {
2662   bfd_boolean dynamic;
2663   struct alpha_elf_reloc_entry *relent;
2664   unsigned long entries;
2665
2666   /* If the symbol was defined as a common symbol in a regular object
2667      file, and there was no definition in any dynamic object, then the
2668      linker will have allocated space for the symbol in a common
2669      section but the ELF_LINK_HASH_DEF_REGULAR flag will not have been
2670      set.  This is done for dynamic symbols in
2671      elf_adjust_dynamic_symbol but this is not done for non-dynamic
2672      symbols, somehow.  */
2673   if (!h->root.def_regular
2674       && h->root.ref_regular
2675       && !h->root.def_dynamic
2676       && (h->root.root.type == bfd_link_hash_defined
2677           || h->root.root.type == bfd_link_hash_defweak)
2678       && !(h->root.root.u.def.section->owner->flags & DYNAMIC))
2679     h->root.def_regular = 1;
2680
2681   /* If the symbol is dynamic, we'll need all the relocations in their
2682      natural form.  If this is a shared object, and it has been forced
2683      local, we'll need the same number of RELATIVE relocations.  */
2684   dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
2685
2686   /* If the symbol is a hidden undefined weak, then we never have any
2687      relocations.  Avoid the loop which may want to add RELATIVE relocs
2688      based on bfd_link_pic (info).  */
2689   if (h->root.root.type == bfd_link_hash_undefweak && !dynamic)
2690     return TRUE;
2691
2692   for (relent = h->reloc_entries; relent; relent = relent->next)
2693     {
2694       entries = alpha_dynamic_entries_for_reloc (relent->rtype, dynamic,
2695                                                  bfd_link_pic (info),
2696                                                  bfd_link_pie (info));
2697       if (entries)
2698         {
2699           relent->srel->size +=
2700             entries * sizeof (Elf64_External_Rela) * relent->count;
2701           if (relent->reltext)
2702             info->flags |= DT_TEXTREL;
2703         }
2704     }
2705
2706   return TRUE;
2707 }
2708
2709 /* Subroutine of elf64_alpha_size_rela_got_section for doing the
2710    global symbols.  */
2711
2712 static bfd_boolean
2713 elf64_alpha_size_rela_got_1 (struct alpha_elf_link_hash_entry *h,
2714                              struct bfd_link_info *info)
2715 {
2716   bfd_boolean dynamic;
2717   struct alpha_elf_got_entry *gotent;
2718   unsigned long entries;
2719
2720   /* If we're using a plt for this symbol, then all of its relocations
2721      for its got entries go into .rela.plt.  */
2722   if (h->root.needs_plt)
2723     return TRUE;
2724
2725   /* If the symbol is dynamic, we'll need all the relocations in their
2726      natural form.  If this is a shared object, and it has been forced
2727      local, we'll need the same number of RELATIVE relocations.  */
2728   dynamic = alpha_elf_dynamic_symbol_p (&h->root, info);
2729
2730   /* If the symbol is a hidden undefined weak, then we never have any
2731      relocations.  Avoid the loop which may want to add RELATIVE relocs
2732      based on bfd_link_pic (info).  */
2733   if (h->root.root.type == bfd_link_hash_undefweak && !dynamic)
2734     return TRUE;
2735
2736   entries = 0;
2737   for (gotent = h->got_entries; gotent ; gotent = gotent->next)
2738     if (gotent->use_count > 0)
2739       entries += alpha_dynamic_entries_for_reloc (gotent->reloc_type, dynamic,
2740                                                   bfd_link_pic (info),
2741                                                   bfd_link_pie (info));
2742
2743   if (entries > 0)
2744     {
2745       asection *srel = elf_hash_table(info)->srelgot;
2746       BFD_ASSERT (srel != NULL);
2747       srel->size += sizeof (Elf64_External_Rela) * entries;
2748     }
2749
2750   return TRUE;
2751 }
2752
2753 /* Set the sizes of the dynamic relocation sections.  */
2754
2755 static void
2756 elf64_alpha_size_rela_got_section (struct bfd_link_info *info)
2757 {
2758   unsigned long entries;
2759   bfd *i;
2760   asection *srel;
2761   struct alpha_elf_link_hash_table * htab;
2762
2763   htab = alpha_elf_hash_table (info);
2764   if (htab == NULL)
2765     return;
2766
2767   /* Shared libraries often require RELATIVE relocs, and some relocs
2768      require attention for the main application as well.  */
2769
2770   entries = 0;
2771   for (i = htab->got_list;
2772        i ; i = alpha_elf_tdata(i)->got_link_next)
2773     {
2774       bfd *j;
2775
2776       for (j = i; j ; j = alpha_elf_tdata(j)->in_got_link_next)
2777         {
2778           struct alpha_elf_got_entry **local_got_entries, *gotent;
2779           int k, n;
2780
2781           local_got_entries = alpha_elf_tdata(j)->local_got_entries;
2782           if (!local_got_entries)
2783             continue;
2784
2785           for (k = 0, n = elf_tdata(j)->symtab_hdr.sh_info; k < n; ++k)
2786             for (gotent = local_got_entries[k];
2787                  gotent ; gotent = gotent->next)
2788               if (gotent->use_count > 0)
2789                 entries += (alpha_dynamic_entries_for_reloc
2790                             (gotent->reloc_type, 0, bfd_link_pic (info),
2791                              bfd_link_pie (info)));
2792         }
2793     }
2794
2795   srel = elf_hash_table(info)->srelgot;
2796   if (!srel)
2797     {
2798       BFD_ASSERT (entries == 0);
2799       return;
2800     }
2801   srel->size = sizeof (Elf64_External_Rela) * entries;
2802
2803   /* Now do the non-local symbols.  */
2804   alpha_elf_link_hash_traverse (htab,
2805                                 elf64_alpha_size_rela_got_1, info);
2806 }
2807
2808 /* Set the sizes of the dynamic sections.  */
2809
2810 static bfd_boolean
2811 elf64_alpha_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2812                                    struct bfd_link_info *info)
2813 {
2814   bfd *dynobj;
2815   asection *s;
2816   bfd_boolean relplt, relocs;
2817   struct alpha_elf_link_hash_table * htab;
2818
2819   htab = alpha_elf_hash_table (info);
2820   if (htab == NULL)
2821     return FALSE;
2822
2823   dynobj = elf_hash_table(info)->dynobj;
2824   BFD_ASSERT(dynobj != NULL);
2825
2826   if (elf_hash_table (info)->dynamic_sections_created)
2827     {
2828       /* Set the contents of the .interp section to the interpreter.  */
2829       if (bfd_link_executable (info) && !info->nointerp)
2830         {
2831           s = bfd_get_linker_section (dynobj, ".interp");
2832           BFD_ASSERT (s != NULL);
2833           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2834           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2835         }
2836
2837       /* Now that we've seen all of the input files, we can decide which
2838          symbols need dynamic relocation entries and which don't.  We've
2839          collected information in check_relocs that we can now apply to
2840          size the dynamic relocation sections.  */
2841       alpha_elf_link_hash_traverse (htab,
2842                                     elf64_alpha_calc_dynrel_sizes, info);
2843
2844       elf64_alpha_size_rela_got_section (info);
2845       elf64_alpha_size_plt_section (info);
2846     }
2847   /* else we're not dynamic and by definition we don't need such things.  */
2848
2849   /* The check_relocs and adjust_dynamic_symbol entry points have
2850      determined the sizes of the various dynamic sections.  Allocate
2851      memory for them.  */
2852   relplt = FALSE;
2853   relocs = FALSE;
2854   for (s = dynobj->sections; s != NULL; s = s->next)
2855     {
2856       const char *name;
2857
2858       if (!(s->flags & SEC_LINKER_CREATED))
2859         continue;
2860
2861       /* It's OK to base decisions on the section name, because none
2862          of the dynobj section names depend upon the input files.  */
2863       name = bfd_get_section_name (dynobj, s);
2864
2865       if (CONST_STRNEQ (name, ".rela"))
2866         {
2867           if (s->size != 0)
2868             {
2869               if (strcmp (name, ".rela.plt") == 0)
2870                 relplt = TRUE;
2871               else
2872                 relocs = TRUE;
2873
2874               /* We use the reloc_count field as a counter if we need
2875                  to copy relocs into the output file.  */
2876               s->reloc_count = 0;
2877             }
2878         }
2879       else if (! CONST_STRNEQ (name, ".got")
2880                && strcmp (name, ".plt") != 0
2881                && strcmp (name, ".dynbss") != 0)
2882         {
2883           /* It's not one of our dynamic sections, so don't allocate space.  */
2884           continue;
2885         }
2886
2887       if (s->size == 0)
2888         {
2889           /* If we don't need this section, strip it from the output file.
2890              This is to handle .rela.bss and .rela.plt.  We must create it
2891              in create_dynamic_sections, because it must be created before
2892              the linker maps input sections to output sections.  The
2893              linker does that before adjust_dynamic_symbol is called, and
2894              it is that function which decides whether anything needs to
2895              go into these sections.  */
2896           if (!CONST_STRNEQ (name, ".got"))
2897             s->flags |= SEC_EXCLUDE;
2898         }
2899       else if ((s->flags & SEC_HAS_CONTENTS) != 0)
2900         {
2901           /* Allocate memory for the section contents.  */
2902           s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
2903           if (s->contents == NULL)
2904             return FALSE;
2905         }
2906     }
2907
2908   if (elf_hash_table (info)->dynamic_sections_created)
2909     {
2910       /* Add some entries to the .dynamic section.  We fill in the
2911          values later, in elf64_alpha_finish_dynamic_sections, but we
2912          must add the entries now so that we get the correct size for
2913          the .dynamic section.  The DT_DEBUG entry is filled in by the
2914          dynamic linker and used by the debugger.  */
2915 #define add_dynamic_entry(TAG, VAL) \
2916   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2917
2918       if (bfd_link_executable (info))
2919         {
2920           if (!add_dynamic_entry (DT_DEBUG, 0))
2921             return FALSE;
2922         }
2923
2924       if (relplt)
2925         {
2926           if (!add_dynamic_entry (DT_PLTGOT, 0)
2927               || !add_dynamic_entry (DT_PLTRELSZ, 0)
2928               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
2929               || !add_dynamic_entry (DT_JMPREL, 0))
2930             return FALSE;
2931
2932           if (elf64_alpha_use_secureplt
2933               && !add_dynamic_entry (DT_ALPHA_PLTRO, 1))
2934             return FALSE;
2935         }
2936
2937       if (relocs)
2938         {
2939           if (!add_dynamic_entry (DT_RELA, 0)
2940               || !add_dynamic_entry (DT_RELASZ, 0)
2941               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf64_External_Rela)))
2942             return FALSE;
2943
2944           if (info->flags & DF_TEXTREL)
2945             {
2946               if (!add_dynamic_entry (DT_TEXTREL, 0))
2947                 return FALSE;
2948             }
2949         }
2950     }
2951 #undef add_dynamic_entry
2952
2953   return TRUE;
2954 }
2955 \f
2956 /* These functions do relaxation for Alpha ELF.
2957
2958    Currently I'm only handling what I can do with existing compiler
2959    and assembler support, which means no instructions are removed,
2960    though some may be nopped.  At this time GCC does not emit enough
2961    information to do all of the relaxing that is possible.  It will
2962    take some not small amount of work for that to happen.
2963
2964    There are a couple of interesting papers that I once read on this
2965    subject, that I cannot find references to at the moment, that
2966    related to Alpha in particular.  They are by David Wall, then of
2967    DEC WRL.  */
2968
2969 struct alpha_relax_info
2970 {
2971   bfd *abfd;
2972   asection *sec;
2973   bfd_byte *contents;
2974   Elf_Internal_Shdr *symtab_hdr;
2975   Elf_Internal_Rela *relocs, *relend;
2976   struct bfd_link_info *link_info;
2977   bfd_vma gp;
2978   bfd *gotobj;
2979   asection *tsec;
2980   struct alpha_elf_link_hash_entry *h;
2981   struct alpha_elf_got_entry **first_gotent;
2982   struct alpha_elf_got_entry *gotent;
2983   bfd_boolean changed_contents;
2984   bfd_boolean changed_relocs;
2985   unsigned char other;
2986 };
2987
2988 static Elf_Internal_Rela *
2989 elf64_alpha_find_reloc_at_ofs (Elf_Internal_Rela *rel,
2990                                Elf_Internal_Rela *relend,
2991                                bfd_vma offset, int type)
2992 {
2993   while (rel < relend)
2994     {
2995       if (rel->r_offset == offset
2996           && ELF64_R_TYPE (rel->r_info) == (unsigned int) type)
2997         return rel;
2998       ++rel;
2999     }
3000   return NULL;
3001 }
3002
3003 static bfd_boolean
3004 elf64_alpha_relax_got_load (struct alpha_relax_info *info, bfd_vma symval,
3005                             Elf_Internal_Rela *irel, unsigned long r_type)
3006 {
3007   unsigned int insn;
3008   bfd_signed_vma disp;
3009
3010   /* Get the instruction.  */
3011   insn = bfd_get_32 (info->abfd, info->contents + irel->r_offset);
3012
3013   if (insn >> 26 != OP_LDQ)
3014     {
3015       reloc_howto_type *howto = elf64_alpha_howto_table + r_type;
3016       _bfd_error_handler
3017         /* xgettext:c-format */
3018         (_("%pB: %pA+%#" PRIx64 ": warning: "
3019            "%s relocation against unexpected insn"),
3020          info->abfd, info->sec, (uint64_t) irel->r_offset, howto->name);
3021       return TRUE;
3022     }
3023
3024   /* Can't relax dynamic symbols.  */
3025   if (alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info))
3026     return TRUE;
3027
3028   /* Can't use local-exec relocations in shared libraries.  */
3029   if (r_type == R_ALPHA_GOTTPREL
3030       && bfd_link_dll (info->link_info))
3031     return TRUE;
3032
3033   if (r_type == R_ALPHA_LITERAL)
3034     {
3035       /* Look for nice constant addresses.  This includes the not-uncommon
3036          special case of 0 for undefweak symbols.  */
3037       if ((info->h && info->h->root.root.type == bfd_link_hash_undefweak)
3038           || (!bfd_link_pic (info->link_info)
3039               && (symval >= (bfd_vma)-0x8000 || symval < 0x8000)))
3040         {
3041           disp = 0;
3042           insn = (OP_LDA << 26) | (insn & (31 << 21)) | (31 << 16);
3043           insn |= (symval & 0xffff);
3044           r_type = R_ALPHA_NONE;
3045         }
3046       else
3047         {
3048           /* We may only create GPREL relocs during the second pass.  */
3049           if (info->link_info->relax_pass == 0)
3050             return TRUE;
3051
3052           disp = symval - info->gp;
3053           insn = (OP_LDA << 26) | (insn & 0x03ff0000);
3054           r_type = R_ALPHA_GPREL16;
3055         }
3056     }
3057   else
3058     {
3059       bfd_vma dtp_base, tp_base;
3060
3061       BFD_ASSERT (elf_hash_table (info->link_info)->tls_sec != NULL);
3062       dtp_base = alpha_get_dtprel_base (info->link_info);
3063       tp_base = alpha_get_tprel_base (info->link_info);
3064       disp = symval - (r_type == R_ALPHA_GOTDTPREL ? dtp_base : tp_base);
3065
3066       insn = (OP_LDA << 26) | (insn & (31 << 21)) | (31 << 16);
3067
3068       switch (r_type)
3069         {
3070         case R_ALPHA_GOTDTPREL:
3071           r_type = R_ALPHA_DTPREL16;
3072           break;
3073         case R_ALPHA_GOTTPREL:
3074           r_type = R_ALPHA_TPREL16;
3075           break;
3076         default:
3077           BFD_ASSERT (0);
3078           return FALSE;
3079         }
3080     }
3081
3082   if (disp < -0x8000 || disp >= 0x8000)
3083     return TRUE;
3084
3085   bfd_put_32 (info->abfd, (bfd_vma) insn, info->contents + irel->r_offset);
3086   info->changed_contents = TRUE;
3087
3088   /* Reduce the use count on this got entry by one, possibly
3089      eliminating it.  */
3090   if (--info->gotent->use_count == 0)
3091     {
3092       int sz = alpha_got_entry_size (r_type);
3093       alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3094       if (!info->h)
3095         alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
3096     }
3097
3098   /* Smash the existing GOT relocation for its 16-bit immediate pair.  */
3099   irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info), r_type);
3100   info->changed_relocs = TRUE;
3101
3102   /* ??? Search forward through this basic block looking for insns
3103      that use the target register.  Stop after an insn modifying the
3104      register is seen, or after a branch or call.
3105
3106      Any such memory load insn may be substituted by a load directly
3107      off the GP.  This allows the memory load insn to be issued before
3108      the calculated GP register would otherwise be ready.
3109
3110      Any such jsr insn can be replaced by a bsr if it is in range.
3111
3112      This would mean that we'd have to _add_ relocations, the pain of
3113      which gives one pause.  */
3114
3115   return TRUE;
3116 }
3117
3118 static bfd_vma
3119 elf64_alpha_relax_opt_call (struct alpha_relax_info *info, bfd_vma symval)
3120 {
3121   /* If the function has the same gp, and we can identify that the
3122      function does not use its function pointer, we can eliminate the
3123      address load.  */
3124
3125   /* If the symbol is marked NOPV, we are being told the function never
3126      needs its procedure value.  */
3127   if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_NOPV)
3128     return symval;
3129
3130   /* If the symbol is marked STD_GP, we are being told the function does
3131      a normal ldgp in the first two words.  */
3132   else if ((info->other & STO_ALPHA_STD_GPLOAD) == STO_ALPHA_STD_GPLOAD)
3133     ;
3134
3135   /* Otherwise, we may be able to identify a GP load in the first two
3136      words, which we can then skip.  */
3137   else
3138     {
3139       Elf_Internal_Rela *tsec_relocs, *tsec_relend, *tsec_free, *gpdisp;
3140       bfd_vma ofs;
3141
3142       /* Load the relocations from the section that the target symbol is in.  */
3143       if (info->sec == info->tsec)
3144         {
3145           tsec_relocs = info->relocs;
3146           tsec_relend = info->relend;
3147           tsec_free = NULL;
3148         }
3149       else
3150         {
3151           tsec_relocs = (_bfd_elf_link_read_relocs
3152                          (info->abfd, info->tsec, NULL,
3153                          (Elf_Internal_Rela *) NULL,
3154                          info->link_info->keep_memory));
3155           if (tsec_relocs == NULL)
3156             return 0;
3157           tsec_relend = tsec_relocs + info->tsec->reloc_count;
3158           tsec_free = (elf_section_data (info->tsec)->relocs == tsec_relocs
3159                        ? NULL
3160                        : tsec_relocs);
3161         }
3162
3163       /* Recover the symbol's offset within the section.  */
3164       ofs = (symval - info->tsec->output_section->vma
3165              - info->tsec->output_offset);
3166
3167       /* Look for a GPDISP reloc.  */
3168       gpdisp = (elf64_alpha_find_reloc_at_ofs
3169                 (tsec_relocs, tsec_relend, ofs, R_ALPHA_GPDISP));
3170
3171       if (!gpdisp || gpdisp->r_addend != 4)
3172         {
3173           if (tsec_free)
3174             free (tsec_free);
3175           return 0;
3176         }
3177       if (tsec_free)
3178         free (tsec_free);
3179     }
3180
3181   /* We've now determined that we can skip an initial gp load.  Verify
3182      that the call and the target use the same gp.   */
3183   if (info->link_info->output_bfd->xvec != info->tsec->owner->xvec
3184       || info->gotobj != alpha_elf_tdata (info->tsec->owner)->gotobj)
3185     return 0;
3186
3187   return symval + 8;
3188 }
3189
3190 static bfd_boolean
3191 elf64_alpha_relax_with_lituse (struct alpha_relax_info *info,
3192                                bfd_vma symval, Elf_Internal_Rela *irel)
3193 {
3194   Elf_Internal_Rela *urel, *erel, *irelend = info->relend;
3195   int flags;
3196   bfd_signed_vma disp;
3197   bfd_boolean fits16;
3198   bfd_boolean fits32;
3199   bfd_boolean lit_reused = FALSE;
3200   bfd_boolean all_optimized = TRUE;
3201   bfd_boolean changed_contents;
3202   bfd_boolean changed_relocs;
3203   bfd_byte *contents = info->contents;
3204   bfd *abfd = info->abfd;
3205   bfd_vma sec_output_vma;
3206   unsigned int lit_insn;
3207   int relax_pass;
3208
3209   lit_insn = bfd_get_32 (abfd, contents + irel->r_offset);
3210   if (lit_insn >> 26 != OP_LDQ)
3211     {
3212       _bfd_error_handler
3213         /* xgettext:c-format */
3214         (_("%pB: %pA+%#" PRIx64 ": warning: "
3215            "%s relocation against unexpected insn"),
3216          abfd, info->sec, (uint64_t) irel->r_offset, "LITERAL");
3217       return TRUE;
3218     }
3219
3220   /* Can't relax dynamic symbols.  */
3221   if (alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info))
3222     return TRUE;
3223
3224   changed_contents = info->changed_contents;
3225   changed_relocs = info->changed_relocs;
3226   sec_output_vma = info->sec->output_section->vma + info->sec->output_offset;
3227   relax_pass = info->link_info->relax_pass;
3228
3229   /* Summarize how this particular LITERAL is used.  */
3230   for (erel = irel+1, flags = 0; erel < irelend; ++erel)
3231     {
3232       if (ELF64_R_TYPE (erel->r_info) != R_ALPHA_LITUSE)
3233         break;
3234       if (erel->r_addend <= 6)
3235         flags |= 1 << erel->r_addend;
3236     }
3237
3238   /* A little preparation for the loop...  */
3239   disp = symval - info->gp;
3240
3241   for (urel = irel+1; urel < erel; ++urel)
3242     {
3243       bfd_vma urel_r_offset = urel->r_offset;
3244       unsigned int insn;
3245       int insn_disp;
3246       bfd_signed_vma xdisp;
3247       Elf_Internal_Rela nrel;
3248
3249       insn = bfd_get_32 (abfd, contents + urel_r_offset);
3250
3251       switch (urel->r_addend)
3252         {
3253         case LITUSE_ALPHA_ADDR:
3254         default:
3255           /* This type is really just a placeholder to note that all
3256              uses cannot be optimized, but to still allow some.  */
3257           all_optimized = FALSE;
3258           break;
3259
3260         case LITUSE_ALPHA_BASE:
3261           /* We may only create GPREL relocs during the second pass.  */
3262           if (relax_pass == 0)
3263             {
3264               all_optimized = FALSE;
3265               break;
3266             }
3267
3268           /* We can always optimize 16-bit displacements.  */
3269
3270           /* Extract the displacement from the instruction, sign-extending
3271              it if necessary, then test whether it is within 16 or 32 bits
3272              displacement from GP.  */
3273           insn_disp = ((insn & 0xffff) ^ 0x8000) - 0x8000;
3274
3275           xdisp = disp + insn_disp;
3276           fits16 = (xdisp >= - (bfd_signed_vma) 0x8000 && xdisp < 0x8000);
3277           fits32 = (xdisp >= - (bfd_signed_vma) 0x80000000
3278                     && xdisp < 0x7fff8000);
3279
3280           if (fits16)
3281             {
3282               /* Take the op code and dest from this insn, take the base
3283                  register from the literal insn.  Leave the offset alone.  */
3284               insn = (insn & 0xffe0ffff) | (lit_insn & 0x001f0000);
3285               bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset);
3286               changed_contents = TRUE;
3287
3288               nrel = *urel;
3289               nrel.r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3290                                           R_ALPHA_GPREL16);
3291               nrel.r_addend = irel->r_addend;
3292
3293               /* As we adjust, move the reloc to the end so that we don't
3294                  break the LITERAL+LITUSE chain.  */
3295               if (urel < --erel)
3296                 *urel-- = *erel;
3297               *erel = nrel;
3298               changed_relocs = TRUE;
3299             }
3300
3301           /* If all mem+byte, we can optimize 32-bit mem displacements.  */
3302           else if (fits32 && !(flags & ~6))
3303             {
3304               /* FIXME: sanity check that lit insn Ra is mem insn Rb.  */
3305
3306               irel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3307                                            R_ALPHA_GPRELHIGH);
3308               lit_insn = (OP_LDAH << 26) | (lit_insn & 0x03ff0000);
3309               bfd_put_32 (abfd, (bfd_vma) lit_insn, contents + irel->r_offset);
3310               lit_reused = TRUE;
3311               changed_contents = TRUE;
3312
3313               /* Since all relocs must be optimized, don't bother swapping
3314                  this relocation to the end.  */
3315               urel->r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3316                                            R_ALPHA_GPRELLOW);
3317               urel->r_addend = irel->r_addend;
3318               changed_relocs = TRUE;
3319             }
3320           else
3321             all_optimized = FALSE;
3322           break;
3323
3324         case LITUSE_ALPHA_BYTOFF:
3325           /* We can always optimize byte instructions.  */
3326
3327           /* FIXME: sanity check the insn for byte op.  Check that the
3328              literal dest reg is indeed Rb in the byte insn.  */
3329
3330           insn &= ~ (unsigned) 0x001ff000;
3331           insn |= ((symval & 7) << 13) | 0x1000;
3332           bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset);
3333           changed_contents = TRUE;
3334
3335           nrel = *urel;
3336           nrel.r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3337           nrel.r_addend = 0;
3338
3339           /* As we adjust, move the reloc to the end so that we don't
3340              break the LITERAL+LITUSE chain.  */
3341           if (urel < --erel)
3342             *urel-- = *erel;
3343           *erel = nrel;
3344           changed_relocs = TRUE;
3345           break;
3346
3347         case LITUSE_ALPHA_JSR:
3348         case LITUSE_ALPHA_TLSGD:
3349         case LITUSE_ALPHA_TLSLDM:
3350         case LITUSE_ALPHA_JSRDIRECT:
3351           {
3352             bfd_vma optdest, org;
3353             bfd_signed_vma odisp;
3354
3355             /* For undefined weak symbols, we're mostly interested in getting
3356                rid of the got entry whenever possible, so optimize this to a
3357                use of the zero register.  */
3358             if (info->h && info->h->root.root.type == bfd_link_hash_undefweak)
3359               {
3360                 insn |= 31 << 16;
3361                 bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset);
3362
3363                 changed_contents = TRUE;
3364                 break;
3365               }
3366
3367             /* If not zero, place to jump without needing pv.  */
3368             optdest = elf64_alpha_relax_opt_call (info, symval);
3369             org = sec_output_vma + urel_r_offset + 4;
3370             odisp = (optdest ? optdest : symval) - org;
3371
3372             if (odisp >= -0x400000 && odisp < 0x400000)
3373               {
3374                 Elf_Internal_Rela *xrel;
3375
3376                 /* Preserve branch prediction call stack when possible.  */
3377                 if ((insn & INSN_JSR_MASK) == INSN_JSR)
3378                   insn = (OP_BSR << 26) | (insn & 0x03e00000);
3379                 else
3380                   insn = (OP_BR << 26) | (insn & 0x03e00000);
3381                 bfd_put_32 (abfd, (bfd_vma) insn, contents + urel_r_offset);
3382                 changed_contents = TRUE;
3383
3384                 nrel = *urel;
3385                 nrel.r_info = ELF64_R_INFO (ELF64_R_SYM (irel->r_info),
3386                                             R_ALPHA_BRADDR);
3387                 nrel.r_addend = irel->r_addend;
3388
3389                 if (optdest)
3390                   nrel.r_addend += optdest - symval;
3391                 else
3392                   all_optimized = FALSE;
3393
3394                 /* Kill any HINT reloc that might exist for this insn.  */
3395                 xrel = (elf64_alpha_find_reloc_at_ofs
3396                         (info->relocs, info->relend, urel_r_offset,
3397                          R_ALPHA_HINT));
3398                 if (xrel)
3399                   xrel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3400
3401                 /* As we adjust, move the reloc to the end so that we don't
3402                    break the LITERAL+LITUSE chain.  */
3403                 if (urel < --erel)
3404                   *urel-- = *erel;
3405                 *erel = nrel;
3406
3407                 info->changed_relocs = TRUE;
3408               }
3409             else
3410               all_optimized = FALSE;
3411
3412             /* Even if the target is not in range for a direct branch,
3413                if we share a GP, we can eliminate the gp reload.  */
3414             if (optdest)
3415               {
3416                 Elf_Internal_Rela *gpdisp
3417                   = (elf64_alpha_find_reloc_at_ofs
3418                      (info->relocs, irelend, urel_r_offset + 4,
3419                       R_ALPHA_GPDISP));
3420                 if (gpdisp)
3421                   {
3422                     bfd_byte *p_ldah = contents + gpdisp->r_offset;
3423                     bfd_byte *p_lda = p_ldah + gpdisp->r_addend;
3424                     unsigned int ldah = bfd_get_32 (abfd, p_ldah);
3425                     unsigned int lda = bfd_get_32 (abfd, p_lda);
3426
3427                     /* Verify that the instruction is "ldah $29,0($26)".
3428                        Consider a function that ends in a noreturn call,
3429                        and that the next function begins with an ldgp,
3430                        and that by accident there is no padding between.
3431                        In that case the insn would use $27 as the base.  */
3432                     if (ldah == 0x27ba0000 && lda == 0x23bd0000)
3433                       {
3434                         bfd_put_32 (abfd, (bfd_vma) INSN_UNOP, p_ldah);
3435                         bfd_put_32 (abfd, (bfd_vma) INSN_UNOP, p_lda);
3436
3437                         gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3438                         changed_contents = TRUE;
3439                         changed_relocs = TRUE;
3440                       }
3441                   }
3442               }
3443           }
3444           break;
3445         }
3446     }
3447
3448   /* If we reused the literal instruction, we must have optimized all.  */
3449   BFD_ASSERT(!lit_reused || all_optimized);
3450
3451   /* If all cases were optimized, we can reduce the use count on this
3452      got entry by one, possibly eliminating it.  */
3453   if (all_optimized)
3454     {
3455       if (--info->gotent->use_count == 0)
3456         {
3457           int sz = alpha_got_entry_size (R_ALPHA_LITERAL);
3458           alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3459           if (!info->h)
3460             alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
3461         }
3462
3463       /* If the literal instruction is no longer needed (it may have been
3464          reused.  We can eliminate it.  */
3465       /* ??? For now, I don't want to deal with compacting the section,
3466          so just nop it out.  */
3467       if (!lit_reused)
3468         {
3469           irel->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3470           changed_relocs = TRUE;
3471
3472           bfd_put_32 (abfd, (bfd_vma) INSN_UNOP, contents + irel->r_offset);
3473           changed_contents = TRUE;
3474         }
3475     }
3476
3477   info->changed_contents = changed_contents;
3478   info->changed_relocs = changed_relocs;
3479
3480   if (all_optimized || relax_pass == 0)
3481     return TRUE;
3482   return elf64_alpha_relax_got_load (info, symval, irel, R_ALPHA_LITERAL);
3483 }
3484
3485 static bfd_boolean
3486 elf64_alpha_relax_tls_get_addr (struct alpha_relax_info *info, bfd_vma symval,
3487                                 Elf_Internal_Rela *irel, bfd_boolean is_gd)
3488 {
3489   bfd_byte *pos[5];
3490   unsigned int insn, tlsgd_reg;
3491   Elf_Internal_Rela *gpdisp, *hint;
3492   bfd_boolean dynamic, use_gottprel;
3493   unsigned long new_symndx;
3494
3495   dynamic = alpha_elf_dynamic_symbol_p (&info->h->root, info->link_info);
3496
3497   /* If a TLS symbol is accessed using IE at least once, there is no point
3498      to use dynamic model for it.  */
3499   if (is_gd && info->h && (info->h->flags & ALPHA_ELF_LINK_HASH_TLS_IE))
3500     ;
3501
3502   /* If the symbol is local, and we've already committed to DF_STATIC_TLS,
3503      then we might as well relax to IE.  */
3504   else if (bfd_link_pic (info->link_info) && !dynamic
3505            && (info->link_info->flags & DF_STATIC_TLS))
3506     ;
3507
3508   /* Otherwise we must be building an executable to do anything.  */
3509   else if (bfd_link_pic (info->link_info))
3510     return TRUE;
3511
3512   /* The TLSGD/TLSLDM relocation must be followed by a LITERAL and
3513      the matching LITUSE_TLS relocations.  */
3514   if (irel + 2 >= info->relend)
3515     return TRUE;
3516   if (ELF64_R_TYPE (irel[1].r_info) != R_ALPHA_LITERAL
3517       || ELF64_R_TYPE (irel[2].r_info) != R_ALPHA_LITUSE
3518       || irel[2].r_addend != (is_gd ? LITUSE_ALPHA_TLSGD : LITUSE_ALPHA_TLSLDM))
3519     return TRUE;
3520
3521   /* There must be a GPDISP relocation positioned immediately after the
3522      LITUSE relocation.  */
3523   gpdisp = elf64_alpha_find_reloc_at_ofs (info->relocs, info->relend,
3524                                           irel[2].r_offset + 4, R_ALPHA_GPDISP);
3525   if (!gpdisp)
3526     return TRUE;
3527
3528   pos[0] = info->contents + irel[0].r_offset;
3529   pos[1] = info->contents + irel[1].r_offset;
3530   pos[2] = info->contents + irel[2].r_offset;
3531   pos[3] = info->contents + gpdisp->r_offset;
3532   pos[4] = pos[3] + gpdisp->r_addend;
3533
3534   /* Beware of the compiler hoisting part of the sequence out a loop
3535      and adjusting the destination register for the TLSGD insn.  If this
3536      happens, there will be a move into $16 before the JSR insn, so only
3537      transformations of the first insn pair should use this register.  */
3538   tlsgd_reg = bfd_get_32 (info->abfd, pos[0]);
3539   tlsgd_reg = (tlsgd_reg >> 21) & 31;
3540
3541   /* Generally, the positions are not allowed to be out of order, lest the
3542      modified insn sequence have different register lifetimes.  We can make
3543      an exception when pos 1 is adjacent to pos 0.  */
3544   if (pos[1] + 4 == pos[0])
3545     {
3546       bfd_byte *tmp = pos[0];
3547       pos[0] = pos[1];
3548       pos[1] = tmp;
3549     }
3550   if (pos[1] >= pos[2] || pos[2] >= pos[3])
3551     return TRUE;
3552
3553   /* Reduce the use count on the LITERAL relocation.  Do this before we
3554      smash the symndx when we adjust the relocations below.  */
3555   {
3556     struct alpha_elf_got_entry *lit_gotent;
3557     struct alpha_elf_link_hash_entry *lit_h;
3558     unsigned long indx;
3559
3560     BFD_ASSERT (ELF64_R_SYM (irel[1].r_info) >= info->symtab_hdr->sh_info);
3561     indx = ELF64_R_SYM (irel[1].r_info) - info->symtab_hdr->sh_info;
3562     lit_h = alpha_elf_sym_hashes (info->abfd)[indx];
3563
3564     while (lit_h->root.root.type == bfd_link_hash_indirect
3565            || lit_h->root.root.type == bfd_link_hash_warning)
3566       lit_h = (struct alpha_elf_link_hash_entry *) lit_h->root.root.u.i.link;
3567
3568     for (lit_gotent = lit_h->got_entries; lit_gotent ;
3569          lit_gotent = lit_gotent->next)
3570       if (lit_gotent->gotobj == info->gotobj
3571           && lit_gotent->reloc_type == R_ALPHA_LITERAL
3572           && lit_gotent->addend == irel[1].r_addend)
3573         break;
3574     BFD_ASSERT (lit_gotent);
3575
3576     if (--lit_gotent->use_count == 0)
3577       {
3578         int sz = alpha_got_entry_size (R_ALPHA_LITERAL);
3579         alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3580       }
3581   }
3582
3583   /* Change
3584
3585         lda     $16,x($gp)                      !tlsgd!1
3586         ldq     $27,__tls_get_addr($gp)         !literal!1
3587         jsr     $26,($27),__tls_get_addr        !lituse_tlsgd!1
3588         ldah    $29,0($26)                      !gpdisp!2
3589         lda     $29,0($29)                      !gpdisp!2
3590      to
3591         ldq     $16,x($gp)                      !gottprel
3592         unop
3593         call_pal rduniq
3594         addq    $16,$0,$0
3595         unop
3596      or the first pair to
3597         lda     $16,x($gp)                      !tprel
3598         unop
3599      or
3600         ldah    $16,x($gp)                      !tprelhi
3601         lda     $16,x($16)                      !tprello
3602
3603      as appropriate.  */
3604
3605   use_gottprel = FALSE;
3606   new_symndx = is_gd ? ELF64_R_SYM (irel->r_info) : STN_UNDEF;
3607
3608   /* Some compilers warn about a Boolean-looking expression being
3609      used in a switch.  The explicit cast silences them.  */
3610   switch ((int) (!dynamic && !bfd_link_pic (info->link_info)))
3611     {
3612     case 1:
3613       {
3614         bfd_vma tp_base;
3615         bfd_signed_vma disp;
3616
3617         BFD_ASSERT (elf_hash_table (info->link_info)->tls_sec != NULL);
3618         tp_base = alpha_get_tprel_base (info->link_info);
3619         disp = symval - tp_base;
3620
3621         if (disp >= -0x8000 && disp < 0x8000)
3622           {
3623             insn = (OP_LDA << 26) | (tlsgd_reg << 21) | (31 << 16);
3624             bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
3625             bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[1]);
3626
3627             irel[0].r_offset = pos[0] - info->contents;
3628             irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPREL16);
3629             irel[1].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3630             break;
3631           }
3632         else if (disp >= -(bfd_signed_vma) 0x80000000
3633                  && disp < (bfd_signed_vma) 0x7fff8000
3634                  && pos[0] + 4 == pos[1])
3635           {
3636             insn = (OP_LDAH << 26) | (tlsgd_reg << 21) | (31 << 16);
3637             bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
3638             insn = (OP_LDA << 26) | (tlsgd_reg << 21) | (tlsgd_reg << 16);
3639             bfd_put_32 (info->abfd, (bfd_vma) insn, pos[1]);
3640
3641             irel[0].r_offset = pos[0] - info->contents;
3642             irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPRELHI);
3643             irel[1].r_offset = pos[1] - info->contents;
3644             irel[1].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_TPRELLO);
3645             break;
3646           }
3647       }
3648       /* FALLTHRU */
3649
3650     default:
3651       use_gottprel = TRUE;
3652
3653       insn = (OP_LDQ << 26) | (tlsgd_reg << 21) | (29 << 16);
3654       bfd_put_32 (info->abfd, (bfd_vma) insn, pos[0]);
3655       bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[1]);
3656
3657       irel[0].r_offset = pos[0] - info->contents;
3658       irel[0].r_info = ELF64_R_INFO (new_symndx, R_ALPHA_GOTTPREL);
3659       irel[1].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3660       break;
3661     }
3662
3663   bfd_put_32 (info->abfd, (bfd_vma) INSN_RDUNIQ, pos[2]);
3664
3665   insn = INSN_ADDQ | (16 << 21) | (0 << 16) | (0 << 0);
3666   bfd_put_32 (info->abfd, (bfd_vma) insn, pos[3]);
3667
3668   bfd_put_32 (info->abfd, (bfd_vma) INSN_UNOP, pos[4]);
3669
3670   irel[2].r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3671   gpdisp->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3672
3673   hint = elf64_alpha_find_reloc_at_ofs (info->relocs, info->relend,
3674                                         irel[2].r_offset, R_ALPHA_HINT);
3675   if (hint)
3676     hint->r_info = ELF64_R_INFO (0, R_ALPHA_NONE);
3677
3678   info->changed_contents = TRUE;
3679   info->changed_relocs = TRUE;
3680
3681   /* Reduce the use count on the TLSGD/TLSLDM relocation.  */
3682   if (--info->gotent->use_count == 0)
3683     {
3684       int sz = alpha_got_entry_size (info->gotent->reloc_type);
3685       alpha_elf_tdata (info->gotobj)->total_got_size -= sz;
3686       if (!info->h)
3687         alpha_elf_tdata (info->gotobj)->local_got_size -= sz;
3688     }
3689
3690   /* If we've switched to a GOTTPREL relocation, increment the reference
3691      count on that got entry.  */
3692   if (use_gottprel)
3693     {
3694       struct alpha_elf_got_entry *tprel_gotent;
3695
3696       for (tprel_gotent = *info->first_gotent; tprel_gotent ;
3697            tprel_gotent = tprel_gotent->next)
3698         if (tprel_gotent->gotobj == info->gotobj
3699             && tprel_gotent->reloc_type == R_ALPHA_GOTTPREL
3700             && tprel_gotent->addend == irel->r_addend)
3701           break;
3702       if (tprel_gotent)
3703         tprel_gotent->use_count++;
3704       else
3705         {
3706           if (info->gotent->use_count == 0)
3707             tprel_gotent = info->gotent;
3708           else
3709             {
3710               tprel_gotent = (struct alpha_elf_got_entry *)
3711                 bfd_alloc (info->abfd, sizeof (struct alpha_elf_got_entry));
3712               if (!tprel_gotent)
3713                 return FALSE;
3714
3715               tprel_gotent->next = *info->first_gotent;
3716               *info->first_gotent = tprel_gotent;
3717
3718               tprel_gotent->gotobj = info->gotobj;
3719               tprel_gotent->addend = irel->r_addend;
3720               tprel_gotent->got_offset = -1;
3721               tprel_gotent->reloc_done = 0;
3722               tprel_gotent->reloc_xlated = 0;
3723             }
3724
3725           tprel_gotent->use_count = 1;
3726           tprel_gotent->reloc_type = R_ALPHA_GOTTPREL;
3727         }
3728     }
3729
3730   return TRUE;
3731 }
3732
3733 static bfd_boolean
3734 elf64_alpha_relax_section (bfd *abfd, asection *sec,
3735                            struct bfd_link_info *link_info, bfd_boolean *again)
3736 {
3737   Elf_Internal_Shdr *symtab_hdr;
3738   Elf_Internal_Rela *internal_relocs;
3739   Elf_Internal_Rela *irel, *irelend;
3740   Elf_Internal_Sym *isymbuf = NULL;
3741   struct alpha_elf_got_entry **local_got_entries;
3742   struct alpha_relax_info info;
3743   struct alpha_elf_link_hash_table * htab;
3744   int relax_pass;
3745
3746   htab = alpha_elf_hash_table (link_info);
3747   if (htab == NULL)
3748     return FALSE;
3749
3750   /* There's nothing to change, yet.  */
3751   *again = FALSE;
3752
3753   if (bfd_link_relocatable (link_info)
3754       || ((sec->flags & (SEC_CODE | SEC_RELOC | SEC_ALLOC))
3755           != (SEC_CODE | SEC_RELOC | SEC_ALLOC))
3756       || sec->reloc_count == 0)
3757     return TRUE;
3758
3759   BFD_ASSERT (is_alpha_elf (abfd));
3760   relax_pass = link_info->relax_pass;
3761
3762   /* Make sure our GOT and PLT tables are up-to-date.  */
3763   if (htab->relax_trip != link_info->relax_trip)
3764     {
3765       htab->relax_trip = link_info->relax_trip;
3766
3767       /* This should never fail after the initial round, since the only error
3768          is GOT overflow, and relaxation only shrinks the table.  However, we
3769          may only merge got sections during the first pass.  If we merge
3770          sections after we've created GPREL relocs, the GP for the merged
3771          section backs up which may put the relocs out of range.  */
3772       if (!elf64_alpha_size_got_sections (link_info, relax_pass == 0))
3773         abort ();
3774       if (elf_hash_table (link_info)->dynamic_sections_created)
3775         {
3776           elf64_alpha_size_plt_section (link_info);
3777           elf64_alpha_size_rela_got_section (link_info);
3778         }
3779     }
3780
3781   symtab_hdr = &elf_symtab_hdr (abfd);
3782   local_got_entries = alpha_elf_tdata(abfd)->local_got_entries;
3783
3784   /* Load the relocations for this section.  */
3785   internal_relocs = (_bfd_elf_link_read_relocs
3786                      (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
3787                       link_info->keep_memory));
3788   if (internal_relocs == NULL)
3789     return FALSE;
3790
3791   memset(&info, 0, sizeof (info));
3792   info.abfd = abfd;
3793   info.sec = sec;
3794   info.link_info = link_info;
3795   info.symtab_hdr = symtab_hdr;
3796   info.relocs = internal_relocs;
3797   info.relend = irelend = internal_relocs + sec->reloc_count;
3798
3799   /* Find the GP for this object.  Do not store the result back via
3800      _bfd_set_gp_value, since this could change again before final.  */
3801   info.gotobj = alpha_elf_tdata (abfd)->gotobj;
3802   if (info.gotobj)
3803     {
3804       asection *sgot = alpha_elf_tdata (info.gotobj)->got;
3805       info.gp = (sgot->output_section->vma
3806                  + sgot->output_offset
3807                  + 0x8000);
3808     }
3809
3810   /* Get the section contents.  */
3811   if (elf_section_data (sec)->this_hdr.contents != NULL)
3812     info.contents = elf_section_data (sec)->this_hdr.contents;
3813   else
3814     {
3815       if (!bfd_malloc_and_get_section (abfd, sec, &info.contents))
3816         goto error_return;
3817     }
3818
3819   for (irel = internal_relocs; irel < irelend; irel++)
3820     {
3821       bfd_vma symval;
3822       struct alpha_elf_got_entry *gotent;
3823       unsigned long r_type = ELF64_R_TYPE (irel->r_info);
3824       unsigned long r_symndx = ELF64_R_SYM (irel->r_info);
3825
3826       /* Early exit for unhandled or unrelaxable relocations.  */
3827       if (r_type != R_ALPHA_LITERAL)
3828         {
3829           /* We complete everything except LITERAL in the first pass.  */
3830           if (relax_pass != 0)
3831             continue;
3832           if (r_type == R_ALPHA_TLSLDM)
3833             {
3834               /* The symbol for a TLSLDM reloc is ignored.  Collapse the
3835                  reloc to the STN_UNDEF (0) symbol so that they all match.  */
3836               r_symndx = STN_UNDEF;
3837             }
3838           else if (r_type != R_ALPHA_GOTDTPREL
3839                    && r_type != R_ALPHA_GOTTPREL
3840                    && r_type != R_ALPHA_TLSGD)
3841             continue;
3842         }
3843
3844       /* Get the value of the symbol referred to by the reloc.  */
3845       if (r_symndx < symtab_hdr->sh_info)
3846         {
3847           /* A local symbol.  */
3848           Elf_Internal_Sym *isym;
3849
3850           /* Read this BFD's local symbols.  */
3851           if (isymbuf == NULL)
3852             {
3853               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3854               if (isymbuf == NULL)
3855                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
3856                                                 symtab_hdr->sh_info, 0,
3857                                                 NULL, NULL, NULL);
3858               if (isymbuf == NULL)
3859                 goto error_return;
3860             }
3861
3862           isym = isymbuf + r_symndx;
3863
3864           /* Given the symbol for a TLSLDM reloc is ignored, this also
3865              means forcing the symbol value to the tp base.  */
3866           if (r_type == R_ALPHA_TLSLDM)
3867             {
3868               info.tsec = bfd_abs_section_ptr;
3869               symval = alpha_get_tprel_base (info.link_info);
3870             }
3871           else
3872             {
3873               symval = isym->st_value;
3874               if (isym->st_shndx == SHN_UNDEF)
3875                 continue;
3876               else if (isym->st_shndx == SHN_ABS)
3877                 info.tsec = bfd_abs_section_ptr;
3878               else if (isym->st_shndx == SHN_COMMON)
3879                 info.tsec = bfd_com_section_ptr;
3880               else
3881                 info.tsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3882             }
3883
3884           info.h = NULL;
3885           info.other = isym->st_other;
3886           if (local_got_entries)
3887             info.first_gotent = &local_got_entries[r_symndx];
3888           else
3889             {
3890               info.first_gotent = &info.gotent;
3891               info.gotent = NULL;
3892             }
3893         }
3894       else
3895         {
3896           unsigned long indx;
3897           struct alpha_elf_link_hash_entry *h;
3898
3899           indx = r_symndx - symtab_hdr->sh_info;
3900           h = alpha_elf_sym_hashes (abfd)[indx];
3901           BFD_ASSERT (h != NULL);
3902
3903           while (h->root.root.type == bfd_link_hash_indirect
3904                  || h->root.root.type == bfd_link_hash_warning)
3905             h = (struct alpha_elf_link_hash_entry *)h->root.root.u.i.link;
3906
3907           /* If the symbol is undefined, we can't do anything with it.  */
3908           if (h->root.root.type == bfd_link_hash_undefined)
3909             continue;
3910
3911           /* If the symbol isn't defined in the current module,
3912              again we can't do anything.  */
3913           if (h->root.root.type == bfd_link_hash_undefweak)
3914             {
3915               info.tsec = bfd_abs_section_ptr;
3916               symval = 0;
3917             }
3918           else if (!h->root.def_regular)
3919             {
3920               /* Except for TLSGD relocs, which can sometimes be
3921                  relaxed to GOTTPREL relocs.  */
3922               if (r_type != R_ALPHA_TLSGD)
3923                 continue;
3924               info.tsec = bfd_abs_section_ptr;
3925               symval = 0;
3926             }
3927           else
3928             {
3929               info.tsec = h->root.root.u.def.section;
3930               symval = h->root.root.u.def.value;
3931             }
3932
3933           info.h = h;
3934           info.other = h->root.other;
3935           info.first_gotent = &h->got_entries;
3936         }
3937
3938       /* Search for the got entry to be used by this relocation.  */
3939       for (gotent = *info.first_gotent; gotent ; gotent = gotent->next)
3940         if (gotent->gotobj == info.gotobj
3941             && gotent->reloc_type == r_type
3942             && gotent->addend == irel->r_addend)
3943           break;
3944       info.gotent = gotent;
3945
3946       symval += info.tsec->output_section->vma + info.tsec->output_offset;
3947       symval += irel->r_addend;
3948
3949       switch (r_type)
3950         {
3951         case R_ALPHA_LITERAL:
3952           BFD_ASSERT(info.gotent != NULL);
3953
3954           /* If there exist LITUSE relocations immediately following, this
3955              opens up all sorts of interesting optimizations, because we
3956              now know every location that this address load is used.  */
3957           if (irel+1 < irelend
3958               && ELF64_R_TYPE (irel[1].r_info) == R_ALPHA_LITUSE)
3959             {
3960               if (!elf64_alpha_relax_with_lituse (&info, symval, irel))
3961                 goto error_return;
3962             }
3963           else
3964             {
3965               if (!elf64_alpha_relax_got_load (&info, symval, irel, r_type))
3966                 goto error_return;
3967             }
3968           break;
3969
3970         case R_ALPHA_GOTDTPREL:
3971         case R_ALPHA_GOTTPREL:
3972           BFD_ASSERT(info.gotent != NULL);
3973           if (!elf64_alpha_relax_got_load (&info, symval, irel, r_type))
3974             goto error_return;
3975           break;
3976
3977         case R_ALPHA_TLSGD:
3978         case R_ALPHA_TLSLDM:
3979           BFD_ASSERT(info.gotent != NULL);
3980           if (!elf64_alpha_relax_tls_get_addr (&info, symval, irel,
3981                                                r_type == R_ALPHA_TLSGD))
3982             goto error_return;
3983           break;
3984         }
3985     }
3986
3987   if (isymbuf != NULL
3988       && symtab_hdr->contents != (unsigned char *) isymbuf)
3989     {
3990       if (!link_info->keep_memory)
3991         free (isymbuf);
3992       else
3993         {
3994           /* Cache the symbols for elf_link_input_bfd.  */
3995           symtab_hdr->contents = (unsigned char *) isymbuf;
3996         }
3997     }
3998
3999   if (info.contents != NULL
4000       && elf_section_data (sec)->this_hdr.contents != info.contents)
4001     {
4002       if (!info.changed_contents && !link_info->keep_memory)
4003         free (info.contents);
4004       else
4005         {
4006           /* Cache the section contents for elf_link_input_bfd.  */
4007           elf_section_data (sec)->this_hdr.contents = info.contents;
4008         }
4009     }
4010
4011   if (elf_section_data (sec)->relocs != internal_relocs)
4012     {
4013       if (!info.changed_relocs)
4014         free (internal_relocs);
4015       else
4016         elf_section_data (sec)->relocs = internal_relocs;
4017     }
4018
4019   *again = info.changed_contents || info.changed_relocs;
4020
4021   return TRUE;
4022
4023  error_return:
4024   if (isymbuf != NULL
4025       && symtab_hdr->contents != (unsigned char *) isymbuf)
4026     free (isymbuf);
4027   if (info.contents != NULL
4028       && elf_section_data (sec)->this_hdr.contents != info.contents)
4029     free (info.contents);
4030   if (internal_relocs != NULL
4031       && elf_section_data (sec)->relocs != internal_relocs)
4032     free (internal_relocs);
4033   return FALSE;
4034 }
4035 \f
4036 /* Emit a dynamic relocation for (DYNINDX, RTYPE, ADDEND) at (SEC, OFFSET)
4037    into the next available slot in SREL.  */
4038
4039 static void
4040 elf64_alpha_emit_dynrel (bfd *abfd, struct bfd_link_info *info,
4041                          asection *sec, asection *srel, bfd_vma offset,
4042                          long dynindx, long rtype, bfd_vma addend)
4043 {
4044   Elf_Internal_Rela outrel;
4045   bfd_byte *loc;
4046
4047   BFD_ASSERT (srel != NULL);
4048
4049   outrel.r_info = ELF64_R_INFO (dynindx, rtype);
4050   outrel.r_addend = addend;
4051
4052   offset = _bfd_elf_section_offset (abfd, info, sec, offset);
4053   if ((offset | 1) != (bfd_vma) -1)
4054     outrel.r_offset = sec->output_section->vma + sec->output_offset + offset;
4055   else
4056     memset (&outrel, 0, sizeof (outrel));
4057
4058   loc = srel->contents;
4059   loc += srel->reloc_count++ * sizeof (Elf64_External_Rela);
4060   bfd_elf64_swap_reloca_out (abfd, &outrel, loc);
4061   BFD_ASSERT (sizeof (Elf64_External_Rela) * srel->reloc_count <= srel->size);
4062 }
4063
4064 /* Relocate an Alpha ELF section for a relocatable link.
4065
4066    We don't have to change anything unless the reloc is against a section
4067    symbol, in which case we have to adjust according to where the section
4068    symbol winds up in the output section.  */
4069
4070 static bfd_boolean
4071 elf64_alpha_relocate_section_r (bfd *output_bfd ATTRIBUTE_UNUSED,
4072                                 struct bfd_link_info *info ATTRIBUTE_UNUSED,
4073                                 bfd *input_bfd, asection *input_section,
4074                                 bfd_byte *contents ATTRIBUTE_UNUSED,
4075                                 Elf_Internal_Rela *relocs,
4076                                 Elf_Internal_Sym *local_syms,
4077                                 asection **local_sections)
4078 {
4079   unsigned long symtab_hdr_sh_info;
4080   Elf_Internal_Rela *rel;
4081   Elf_Internal_Rela *relend;
4082   struct elf_link_hash_entry **sym_hashes;
4083   bfd_boolean ret_val = TRUE;
4084
4085   symtab_hdr_sh_info = elf_symtab_hdr (input_bfd).sh_info;
4086   sym_hashes = elf_sym_hashes (input_bfd);
4087
4088   relend = relocs + input_section->reloc_count;
4089   for (rel = relocs; rel < relend; rel++)
4090     {
4091       unsigned long r_symndx;
4092       Elf_Internal_Sym *sym;
4093       asection *sec;
4094       unsigned long r_type;
4095
4096       r_type = ELF64_R_TYPE (rel->r_info);
4097       if (r_type >= R_ALPHA_max)
4098         {
4099           _bfd_error_handler
4100             /* xgettext:c-format */
4101             (_("%pB: unsupported relocation type %#x"),
4102              input_bfd, (int) r_type);
4103           bfd_set_error (bfd_error_bad_value);
4104           ret_val = FALSE;
4105           continue;
4106         }
4107
4108       /* The symbol associated with GPDISP and LITUSE is
4109          immaterial.  Only the addend is significant.  */
4110       if (r_type == R_ALPHA_GPDISP || r_type == R_ALPHA_LITUSE)
4111         continue;
4112
4113       r_symndx = ELF64_R_SYM (rel->r_info);
4114       if (r_symndx < symtab_hdr_sh_info)
4115         {
4116           sym = local_syms + r_symndx;
4117           sec = local_sections[r_symndx];
4118         }
4119       else
4120         {
4121           struct elf_link_hash_entry *h;
4122
4123           h = sym_hashes[r_symndx - symtab_hdr_sh_info];
4124
4125           while (h->root.type == bfd_link_hash_indirect
4126                  || h->root.type == bfd_link_hash_warning)
4127             h = (struct elf_link_hash_entry *) h->root.u.i.link;
4128
4129           if (h->root.type != bfd_link_hash_defined
4130               && h->root.type != bfd_link_hash_defweak)
4131             continue;
4132
4133           sym = NULL;
4134           sec = h->root.u.def.section;
4135         }
4136
4137       if (sec != NULL && discarded_section (sec))
4138         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
4139                                          rel, 1, relend,
4140                                          elf64_alpha_howto_table + r_type, 0,
4141                                          contents);
4142
4143       if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4144         rel->r_addend += sec->output_offset;
4145     }
4146
4147   return ret_val;
4148 }
4149
4150 /* Relocate an Alpha ELF section.  */
4151
4152 static bfd_boolean
4153 elf64_alpha_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
4154                               bfd *input_bfd, asection *input_section,
4155                               bfd_byte *contents, Elf_Internal_Rela *relocs,
4156                               Elf_Internal_Sym *local_syms,
4157                               asection **local_sections)
4158 {
4159   Elf_Internal_Shdr *symtab_hdr;
4160   Elf_Internal_Rela *rel;
4161   Elf_Internal_Rela *relend;
4162   asection *sgot, *srel, *srelgot;
4163   bfd *dynobj, *gotobj;
4164   bfd_vma gp, tp_base, dtp_base;
4165   struct alpha_elf_got_entry **local_got_entries;
4166   bfd_boolean ret_val;
4167
4168   BFD_ASSERT (is_alpha_elf (input_bfd));
4169
4170   /* Handle relocatable links with a smaller loop.  */
4171   if (bfd_link_relocatable (info))
4172     return elf64_alpha_relocate_section_r (output_bfd, info, input_bfd,
4173                                            input_section, contents, relocs,
4174                                            local_syms, local_sections);
4175
4176   /* This is a final link.  */
4177
4178   ret_val = TRUE;
4179
4180   symtab_hdr = &elf_symtab_hdr (input_bfd);
4181
4182   dynobj = elf_hash_table (info)->dynobj;
4183   srelgot = elf_hash_table (info)->srelgot;
4184
4185   if (input_section->flags & SEC_ALLOC)
4186     {
4187       const char *section_name;
4188       section_name = (bfd_elf_string_from_elf_section
4189                       (input_bfd, elf_elfheader(input_bfd)->e_shstrndx,
4190                        _bfd_elf_single_rel_hdr (input_section)->sh_name));
4191       BFD_ASSERT(section_name != NULL);
4192       srel = bfd_get_linker_section (dynobj, section_name);
4193     }
4194   else
4195     srel = NULL;
4196
4197   /* Find the gp value for this input bfd.  */
4198   gotobj = alpha_elf_tdata (input_bfd)->gotobj;
4199   if (gotobj)
4200     {
4201       sgot = alpha_elf_tdata (gotobj)->got;
4202       gp = _bfd_get_gp_value (gotobj);
4203       if (gp == 0)
4204         {
4205           gp = (sgot->output_section->vma
4206                 + sgot->output_offset
4207                 + 0x8000);
4208           _bfd_set_gp_value (gotobj, gp);
4209         }
4210     }
4211   else
4212     {
4213       sgot = NULL;
4214       gp = 0;
4215     }
4216
4217   local_got_entries = alpha_elf_tdata(input_bfd)->local_got_entries;
4218
4219   if (elf_hash_table (info)->tls_sec != NULL)
4220     {
4221       dtp_base = alpha_get_dtprel_base (info);
4222       tp_base = alpha_get_tprel_base (info);
4223     }
4224   else
4225     dtp_base = tp_base = 0;
4226
4227   relend = relocs + input_section->reloc_count;
4228   for (rel = relocs; rel < relend; rel++)
4229     {
4230       struct alpha_elf_link_hash_entry *h = NULL;
4231       struct alpha_elf_got_entry *gotent;
4232       bfd_reloc_status_type r;
4233       reloc_howto_type *howto;
4234       unsigned long r_symndx;
4235       Elf_Internal_Sym *sym = NULL;
4236       asection *sec = NULL;
4237       bfd_vma value;
4238       bfd_vma addend;
4239       bfd_boolean dynamic_symbol_p;
4240       bfd_boolean unresolved_reloc = FALSE;
4241       bfd_boolean undef_weak_ref = FALSE;
4242       unsigned long r_type;
4243
4244       r_type = ELF64_R_TYPE(rel->r_info);
4245       if (r_type >= R_ALPHA_max)
4246         {
4247           _bfd_error_handler
4248             /* xgettext:c-format */
4249             (_("%pB: unsupported relocation type %#x"),
4250              input_bfd, (int) r_type);
4251           bfd_set_error (bfd_error_bad_value);
4252           ret_val = FALSE;
4253           continue;
4254         }
4255
4256       howto = elf64_alpha_howto_table + r_type;
4257       r_symndx = ELF64_R_SYM(rel->r_info);
4258
4259       /* The symbol for a TLSLDM reloc is ignored.  Collapse the
4260          reloc to the STN_UNDEF (0) symbol so that they all match.  */
4261       if (r_type == R_ALPHA_TLSLDM)
4262         r_symndx = STN_UNDEF;
4263
4264       if (r_symndx < symtab_hdr->sh_info)
4265         {
4266           asection *msec;
4267           sym = local_syms + r_symndx;
4268           sec = local_sections[r_symndx];
4269           msec = sec;
4270           value = _bfd_elf_rela_local_sym (output_bfd, sym, &msec, rel);
4271
4272           /* If this is a tp-relative relocation against sym STN_UNDEF (0),
4273              this is hackery from relax_section.  Force the value to
4274              be the tls module base.  */
4275           if (r_symndx == STN_UNDEF
4276               && (r_type == R_ALPHA_TLSLDM
4277                   || r_type == R_ALPHA_GOTTPREL
4278                   || r_type == R_ALPHA_TPREL64
4279                   || r_type == R_ALPHA_TPRELHI
4280                   || r_type == R_ALPHA_TPRELLO
4281                   || r_type == R_ALPHA_TPREL16))
4282             value = dtp_base;
4283
4284           if (local_got_entries)
4285             gotent = local_got_entries[r_symndx];
4286           else
4287             gotent = NULL;
4288
4289           /* Need to adjust local GOT entries' addends for SEC_MERGE
4290              unless it has been done already.  */
4291           if ((sec->flags & SEC_MERGE)
4292               && ELF_ST_TYPE (sym->st_info) == STT_SECTION
4293               && sec->sec_info_type == SEC_INFO_TYPE_MERGE
4294               && gotent
4295               && !gotent->reloc_xlated)
4296             {
4297               struct alpha_elf_got_entry *ent;
4298
4299               for (ent = gotent; ent; ent = ent->next)
4300                 {
4301                   ent->reloc_xlated = 1;
4302                   if (ent->use_count == 0)
4303                     continue;
4304                   msec = sec;
4305                   ent->addend =
4306                     _bfd_merged_section_offset (output_bfd, &msec,
4307                                                 elf_section_data (sec)->
4308                                                   sec_info,
4309                                                 sym->st_value + ent->addend);
4310                   ent->addend -= sym->st_value;
4311                   ent->addend += msec->output_section->vma
4312                                  + msec->output_offset
4313                                  - sec->output_section->vma
4314                                  - sec->output_offset;
4315                 }
4316             }
4317
4318           dynamic_symbol_p = FALSE;
4319         }
4320       else
4321         {
4322           bfd_boolean warned, ignored;
4323           struct elf_link_hash_entry *hh;
4324           struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
4325
4326           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4327                                    r_symndx, symtab_hdr, sym_hashes,
4328                                    hh, sec, value,
4329                                    unresolved_reloc, warned, ignored);
4330
4331           if (warned)
4332             continue;
4333
4334           if (value == 0
4335               && ! unresolved_reloc
4336               && hh->root.type == bfd_link_hash_undefweak)
4337             undef_weak_ref = TRUE;
4338
4339           h = (struct alpha_elf_link_hash_entry *) hh;
4340           dynamic_symbol_p = alpha_elf_dynamic_symbol_p (&h->root, info);
4341           gotent = h->got_entries;
4342         }
4343
4344       if (sec != NULL && discarded_section (sec))
4345         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
4346                                          rel, 1, relend, howto, 0, contents);
4347
4348       addend = rel->r_addend;
4349       value += addend;
4350
4351       /* Search for the proper got entry.  */
4352       for (; gotent ; gotent = gotent->next)
4353         if (gotent->gotobj == gotobj
4354             && gotent->reloc_type == r_type
4355             && gotent->addend == addend)
4356           break;
4357
4358       switch (r_type)
4359         {
4360         case R_ALPHA_GPDISP:
4361           {
4362             bfd_byte *p_ldah, *p_lda;
4363
4364             BFD_ASSERT(gp != 0);
4365
4366             value = (input_section->output_section->vma
4367                      + input_section->output_offset
4368                      + rel->r_offset);
4369
4370             p_ldah = contents + rel->r_offset;
4371             p_lda = p_ldah + rel->r_addend;
4372
4373             r = elf64_alpha_do_reloc_gpdisp (input_bfd, gp - value,
4374                                              p_ldah, p_lda);
4375           }
4376           break;
4377
4378         case R_ALPHA_LITERAL:
4379           BFD_ASSERT(sgot != NULL);
4380           BFD_ASSERT(gp != 0);
4381           BFD_ASSERT(gotent != NULL);
4382           BFD_ASSERT(gotent->use_count >= 1);
4383
4384           if (!gotent->reloc_done)
4385             {
4386               gotent->reloc_done = 1;
4387
4388               bfd_put_64 (output_bfd, value,
4389                           sgot->contents + gotent->got_offset);
4390
4391               /* If the symbol has been forced local, output a
4392                  RELATIVE reloc, otherwise it will be handled in
4393                  finish_dynamic_symbol.  */
4394               if (bfd_link_pic (info)
4395                   && !dynamic_symbol_p
4396                   && !undef_weak_ref)
4397                 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4398                                          gotent->got_offset, 0,
4399                                          R_ALPHA_RELATIVE, value);
4400             }
4401
4402           value = (sgot->output_section->vma
4403                    + sgot->output_offset
4404                    + gotent->got_offset);
4405           value -= gp;
4406           goto default_reloc;
4407
4408         case R_ALPHA_GPREL32:
4409         case R_ALPHA_GPREL16:
4410         case R_ALPHA_GPRELLOW:
4411           if (dynamic_symbol_p)
4412             {
4413               _bfd_error_handler
4414                 /* xgettext:c-format */
4415                 (_("%pB: gp-relative relocation against dynamic symbol %s"),
4416                  input_bfd, h->root.root.root.string);
4417               ret_val = FALSE;
4418             }
4419           BFD_ASSERT(gp != 0);
4420           value -= gp;
4421           goto default_reloc;
4422
4423         case R_ALPHA_GPRELHIGH:
4424           if (dynamic_symbol_p)
4425             {
4426               _bfd_error_handler
4427                 /* xgettext:c-format */
4428                 (_("%pB: gp-relative relocation against dynamic symbol %s"),
4429                  input_bfd, h->root.root.root.string);
4430               ret_val = FALSE;
4431             }
4432           BFD_ASSERT(gp != 0);
4433           value -= gp;
4434           value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4435           goto default_reloc;
4436
4437         case R_ALPHA_HINT:
4438           /* A call to a dynamic symbol is definitely out of range of
4439              the 16-bit displacement.  Don't bother writing anything.  */
4440           if (dynamic_symbol_p)
4441             {
4442               r = bfd_reloc_ok;
4443               break;
4444             }
4445           /* The regular PC-relative stuff measures from the start of
4446              the instruction rather than the end.  */
4447           value -= 4;
4448           goto default_reloc;
4449
4450         case R_ALPHA_BRADDR:
4451           if (dynamic_symbol_p)
4452             {
4453               _bfd_error_handler
4454                 /* xgettext:c-format */
4455                 (_("%pB: pc-relative relocation against dynamic symbol %s"),
4456                  input_bfd, h->root.root.root.string);
4457               ret_val = FALSE;
4458             }
4459           /* The regular PC-relative stuff measures from the start of
4460              the instruction rather than the end.  */
4461           value -= 4;
4462           goto default_reloc;
4463
4464         case R_ALPHA_BRSGP:
4465           {
4466             int other;
4467             const char *name;
4468
4469             /* The regular PC-relative stuff measures from the start of
4470                the instruction rather than the end.  */
4471             value -= 4;
4472
4473             /* The source and destination gp must be the same.  Note that
4474                the source will always have an assigned gp, since we forced
4475                one in check_relocs, but that the destination may not, as
4476                it might not have had any relocations at all.  Also take
4477                care not to crash if H is an undefined symbol.  */
4478             if (h != NULL && sec != NULL
4479                 && alpha_elf_tdata (sec->owner)->gotobj
4480                 && gotobj != alpha_elf_tdata (sec->owner)->gotobj)
4481               {
4482                 _bfd_error_handler
4483                   /* xgettext:c-format */
4484                   (_("%pB: change in gp: BRSGP %s"),
4485                    input_bfd, h->root.root.root.string);
4486                 ret_val = FALSE;
4487               }
4488
4489             /* The symbol should be marked either NOPV or STD_GPLOAD.  */
4490             if (h != NULL)
4491               other = h->root.other;
4492             else
4493               other = sym->st_other;
4494             switch (other & STO_ALPHA_STD_GPLOAD)
4495               {
4496               case STO_ALPHA_NOPV:
4497                 break;
4498               case STO_ALPHA_STD_GPLOAD:
4499                 value += 8;
4500                 break;
4501               default:
4502                 if (h != NULL)
4503                   name = h->root.root.root.string;
4504                 else
4505                   {
4506                     name = (bfd_elf_string_from_elf_section
4507                             (input_bfd, symtab_hdr->sh_link, sym->st_name));
4508                     if (name == NULL)
4509                       name = _("<unknown>");
4510                     else if (name[0] == 0)
4511                       name = bfd_section_name (input_bfd, sec);
4512                   }
4513                 _bfd_error_handler
4514                   /* xgettext:c-format */
4515                   (_("%pB: !samegp reloc against symbol without .prologue: %s"),
4516                    input_bfd, name);
4517                 ret_val = FALSE;
4518                 break;
4519               }
4520
4521             goto default_reloc;
4522           }
4523
4524         case R_ALPHA_REFLONG:
4525         case R_ALPHA_REFQUAD:
4526         case R_ALPHA_DTPREL64:
4527         case R_ALPHA_TPREL64:
4528           {
4529             long dynindx, dyntype = r_type;
4530             bfd_vma dynaddend;
4531
4532             /* Careful here to remember RELATIVE relocations for global
4533                variables for symbolic shared objects.  */
4534
4535             if (dynamic_symbol_p)
4536               {
4537                 BFD_ASSERT(h->root.dynindx != -1);
4538                 dynindx = h->root.dynindx;
4539                 dynaddend = addend;
4540                 addend = 0, value = 0;
4541               }
4542             else if (r_type == R_ALPHA_DTPREL64)
4543               {
4544                 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4545                 value -= dtp_base;
4546                 goto default_reloc;
4547               }
4548             else if (r_type == R_ALPHA_TPREL64)
4549               {
4550                 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4551                 if (!bfd_link_dll (info))
4552                   {
4553                     value -= tp_base;
4554                     goto default_reloc;
4555                   }
4556                 dynindx = 0;
4557                 dynaddend = value - dtp_base;
4558               }
4559             else if (bfd_link_pic (info)
4560                      && r_symndx != STN_UNDEF
4561                      && (input_section->flags & SEC_ALLOC)
4562                      && !undef_weak_ref
4563                      && !(unresolved_reloc
4564                           && (_bfd_elf_section_offset (output_bfd, info,
4565                                                        input_section,
4566                                                        rel->r_offset)
4567                               == (bfd_vma) -1)))
4568               {
4569                 if (r_type == R_ALPHA_REFLONG)
4570                   {
4571                     _bfd_error_handler
4572                       /* xgettext:c-format */
4573                       (_("%pB: unhandled dynamic relocation against %s"),
4574                        input_bfd,
4575                        h->root.root.root.string);
4576                     ret_val = FALSE;
4577                   }
4578                 dynindx = 0;
4579                 dyntype = R_ALPHA_RELATIVE;
4580                 dynaddend = value;
4581               }
4582             else
4583               goto default_reloc;
4584
4585             if (input_section->flags & SEC_ALLOC)
4586               elf64_alpha_emit_dynrel (output_bfd, info, input_section,
4587                                        srel, rel->r_offset, dynindx,
4588                                        dyntype, dynaddend);
4589           }
4590           goto default_reloc;
4591
4592         case R_ALPHA_SREL16:
4593         case R_ALPHA_SREL32:
4594         case R_ALPHA_SREL64:
4595           if (dynamic_symbol_p)
4596             {
4597               _bfd_error_handler
4598                 /* xgettext:c-format */
4599                 (_("%pB: pc-relative relocation against dynamic symbol %s"),
4600                  input_bfd, h->root.root.root.string);
4601               ret_val = FALSE;
4602             }
4603           else if (bfd_link_pic (info)
4604                    && undef_weak_ref)
4605             {
4606               _bfd_error_handler
4607                 /* xgettext:c-format */
4608                 (_("%pB: pc-relative relocation against undefined weak symbol %s"),
4609                  input_bfd, h->root.root.root.string);
4610               ret_val = FALSE;
4611             }
4612
4613
4614           /* ??? .eh_frame references to discarded sections will be smashed
4615              to relocations against SHN_UNDEF.  The .eh_frame format allows
4616              NULL to be encoded as 0 in any format, so this works here.  */
4617           if (r_symndx == STN_UNDEF
4618               || (unresolved_reloc
4619                   && _bfd_elf_section_offset (output_bfd, info,
4620                                               input_section,
4621                                               rel->r_offset) == (bfd_vma) -1))
4622             howto = (elf64_alpha_howto_table
4623                      + (r_type - R_ALPHA_SREL32 + R_ALPHA_REFLONG));
4624           goto default_reloc;
4625
4626         case R_ALPHA_TLSLDM:
4627           /* Ignore the symbol for the relocation.  The result is always
4628              the current module.  */
4629           dynamic_symbol_p = 0;
4630           /* FALLTHRU */
4631
4632         case R_ALPHA_TLSGD:
4633           if (!gotent->reloc_done)
4634             {
4635               gotent->reloc_done = 1;
4636
4637               /* Note that the module index for the main program is 1.  */
4638               bfd_put_64 (output_bfd,
4639                           !bfd_link_pic (info) && !dynamic_symbol_p,
4640                           sgot->contents + gotent->got_offset);
4641
4642               /* If the symbol has been forced local, output a
4643                  DTPMOD64 reloc, otherwise it will be handled in
4644                  finish_dynamic_symbol.  */
4645               if (bfd_link_pic (info) && !dynamic_symbol_p)
4646                 elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4647                                          gotent->got_offset, 0,
4648                                          R_ALPHA_DTPMOD64, 0);
4649
4650               if (dynamic_symbol_p || r_type == R_ALPHA_TLSLDM)
4651                 value = 0;
4652               else
4653                 {
4654                   BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4655                   value -= dtp_base;
4656                 }
4657               bfd_put_64 (output_bfd, value,
4658                           sgot->contents + gotent->got_offset + 8);
4659             }
4660
4661           value = (sgot->output_section->vma
4662                    + sgot->output_offset
4663                    + gotent->got_offset);
4664           value -= gp;
4665           goto default_reloc;
4666
4667         case R_ALPHA_DTPRELHI:
4668         case R_ALPHA_DTPRELLO:
4669         case R_ALPHA_DTPREL16:
4670           if (dynamic_symbol_p)
4671             {
4672               _bfd_error_handler
4673                 /* xgettext:c-format */
4674                 (_("%pB: dtp-relative relocation against dynamic symbol %s"),
4675                  input_bfd, h->root.root.root.string);
4676               ret_val = FALSE;
4677             }
4678           BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4679           value -= dtp_base;
4680           if (r_type == R_ALPHA_DTPRELHI)
4681             value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4682           goto default_reloc;
4683
4684         case R_ALPHA_TPRELHI:
4685         case R_ALPHA_TPRELLO:
4686         case R_ALPHA_TPREL16:
4687           if (bfd_link_dll (info))
4688             {
4689               _bfd_error_handler
4690                 /* xgettext:c-format */
4691                 (_("%pB: TLS local exec code cannot be linked into shared objects"),
4692                 input_bfd);
4693               ret_val = FALSE;
4694             }
4695           else if (dynamic_symbol_p)
4696             {
4697               _bfd_error_handler
4698                 /* xgettext:c-format */
4699                 (_("%pB: tp-relative relocation against dynamic symbol %s"),
4700                  input_bfd, h->root.root.root.string);
4701               ret_val = FALSE;
4702             }
4703           BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4704           value -= tp_base;
4705           if (r_type == R_ALPHA_TPRELHI)
4706             value = ((bfd_signed_vma) value >> 16) + ((value >> 15) & 1);
4707           goto default_reloc;
4708
4709         case R_ALPHA_GOTDTPREL:
4710         case R_ALPHA_GOTTPREL:
4711           BFD_ASSERT(sgot != NULL);
4712           BFD_ASSERT(gp != 0);
4713           BFD_ASSERT(gotent != NULL);
4714           BFD_ASSERT(gotent->use_count >= 1);
4715
4716           if (!gotent->reloc_done)
4717             {
4718               gotent->reloc_done = 1;
4719
4720               if (dynamic_symbol_p)
4721                 value = 0;
4722               else
4723                 {
4724                   BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4725                   if (r_type == R_ALPHA_GOTDTPREL)
4726                     value -= dtp_base;
4727                   else if (!bfd_link_pic (info))
4728                     value -= tp_base;
4729                   else
4730                     {
4731                       elf64_alpha_emit_dynrel (output_bfd, info, sgot, srelgot,
4732                                                gotent->got_offset, 0,
4733                                                R_ALPHA_TPREL64,
4734                                                value - dtp_base);
4735                       value = 0;
4736                     }
4737                 }
4738               bfd_put_64 (output_bfd, value,
4739                           sgot->contents + gotent->got_offset);
4740             }
4741
4742           value = (sgot->output_section->vma
4743                    + sgot->output_offset
4744                    + gotent->got_offset);
4745           value -= gp;
4746           goto default_reloc;
4747
4748         default:
4749         default_reloc:
4750           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4751                                         contents, rel->r_offset, value, 0);
4752           break;
4753         }
4754
4755       switch (r)
4756         {
4757         case bfd_reloc_ok:
4758           break;
4759
4760         case bfd_reloc_overflow:
4761           {
4762             const char *name;
4763
4764             /* Don't warn if the overflow is due to pc relative reloc
4765                against discarded section.  Section optimization code should
4766                handle it.  */
4767
4768             if (r_symndx < symtab_hdr->sh_info
4769                 && sec != NULL && howto->pc_relative
4770                 && discarded_section (sec))
4771               break;
4772
4773             if (h != NULL)
4774               name = NULL;
4775             else
4776               {
4777                 name = (bfd_elf_string_from_elf_section
4778                         (input_bfd, symtab_hdr->sh_link, sym->st_name));
4779                 if (name == NULL)
4780                   return FALSE;
4781                 if (*name == '\0')
4782                   name = bfd_section_name (input_bfd, sec);
4783               }
4784             (*info->callbacks->reloc_overflow)
4785               (info, (h ? &h->root.root : NULL), name, howto->name,
4786                (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
4787           }
4788           break;
4789
4790         default:
4791         case bfd_reloc_outofrange:
4792           abort ();
4793         }
4794     }
4795
4796   return ret_val;
4797 }
4798
4799 /* Finish up dynamic symbol handling.  We set the contents of various
4800    dynamic sections here.  */
4801
4802 static bfd_boolean
4803 elf64_alpha_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info,
4804                                    struct elf_link_hash_entry *h,
4805                                    Elf_Internal_Sym *sym)
4806 {
4807   struct alpha_elf_link_hash_entry *ah = (struct alpha_elf_link_hash_entry *)h;
4808
4809   if (h->needs_plt)
4810     {
4811       /* Fill in the .plt entry for this symbol.  */
4812       asection *splt, *sgot, *srel;
4813       Elf_Internal_Rela outrel;
4814       bfd_byte *loc;
4815       bfd_vma got_addr, plt_addr;
4816       bfd_vma plt_index;
4817       struct alpha_elf_got_entry *gotent;
4818
4819       BFD_ASSERT (h->dynindx != -1);
4820
4821       splt = elf_hash_table (info)->splt;
4822       BFD_ASSERT (splt != NULL);
4823       srel = elf_hash_table (info)->srelplt;
4824       BFD_ASSERT (srel != NULL);
4825
4826       for (gotent = ah->got_entries; gotent ; gotent = gotent->next)
4827         if (gotent->reloc_type == R_ALPHA_LITERAL
4828             && gotent->use_count > 0)
4829           {
4830             unsigned int insn;
4831             int disp;
4832
4833             sgot = alpha_elf_tdata (gotent->gotobj)->got;
4834             BFD_ASSERT (sgot != NULL);
4835
4836             BFD_ASSERT (gotent->got_offset != -1);
4837             BFD_ASSERT (gotent->plt_offset != -1);
4838
4839             got_addr = (sgot->output_section->vma
4840                         + sgot->output_offset
4841                         + gotent->got_offset);
4842             plt_addr = (splt->output_section->vma
4843                         + splt->output_offset
4844                         + gotent->plt_offset);
4845
4846             plt_index = (gotent->plt_offset-PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
4847
4848             /* Fill in the entry in the procedure linkage table.  */
4849             if (elf64_alpha_use_secureplt)
4850               {
4851                 disp = (PLT_HEADER_SIZE - 4) - (gotent->plt_offset + 4);
4852                 insn = INSN_AD (INSN_BR, 31, disp);
4853                 bfd_put_32 (output_bfd, insn,
4854                             splt->contents + gotent->plt_offset);
4855
4856                 plt_index = ((gotent->plt_offset - NEW_PLT_HEADER_SIZE)
4857                              / NEW_PLT_ENTRY_SIZE);
4858               }
4859             else
4860               {
4861                 disp = -(gotent->plt_offset + 4);
4862                 insn = INSN_AD (INSN_BR, 28, disp);
4863                 bfd_put_32 (output_bfd, insn,
4864                             splt->contents + gotent->plt_offset);
4865                 bfd_put_32 (output_bfd, INSN_UNOP,
4866                             splt->contents + gotent->plt_offset + 4);
4867                 bfd_put_32 (output_bfd, INSN_UNOP,
4868                             splt->contents + gotent->plt_offset + 8);
4869
4870                 plt_index = ((gotent->plt_offset - OLD_PLT_HEADER_SIZE)
4871                              / OLD_PLT_ENTRY_SIZE);
4872               }
4873
4874             /* Fill in the entry in the .rela.plt section.  */
4875             outrel.r_offset = got_addr;
4876             outrel.r_info = ELF64_R_INFO(h->dynindx, R_ALPHA_JMP_SLOT);
4877             outrel.r_addend = 0;
4878
4879             loc = srel->contents + plt_index * sizeof (Elf64_External_Rela);
4880             bfd_elf64_swap_reloca_out (output_bfd, &outrel, loc);
4881
4882             /* Fill in the entry in the .got.  */
4883             bfd_put_64 (output_bfd, plt_addr,
4884                         sgot->contents + gotent->got_offset);
4885           }
4886     }
4887   else if (alpha_elf_dynamic_symbol_p (h, info))
4888     {
4889       /* Fill in the dynamic relocations for this symbol's .got entries.  */
4890       asection *srel;
4891       struct alpha_elf_got_entry *gotent;
4892
4893       srel = elf_hash_table (info)->srelgot;
4894       BFD_ASSERT (srel != NULL);
4895
4896       for (gotent = ((struct alpha_elf_link_hash_entry *) h)->got_entries;
4897            gotent != NULL;
4898            gotent = gotent->next)
4899         {
4900           asection *sgot;
4901           long r_type;
4902
4903           if (gotent->use_count == 0)
4904             continue;
4905
4906           sgot = alpha_elf_tdata (gotent->gotobj)->got;
4907
4908           r_type = gotent->reloc_type;
4909           switch (r_type)
4910             {
4911             case R_ALPHA_LITERAL:
4912               r_type = R_ALPHA_GLOB_DAT;
4913               break;
4914             case R_ALPHA_TLSGD:
4915               r_type = R_ALPHA_DTPMOD64;
4916               break;
4917             case R_ALPHA_GOTDTPREL:
4918               r_type = R_ALPHA_DTPREL64;
4919               break;
4920             case R_ALPHA_GOTTPREL:
4921               r_type = R_ALPHA_TPREL64;
4922               break;
4923             case R_ALPHA_TLSLDM:
4924             default:
4925               abort ();
4926             }
4927
4928           elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
4929                                    gotent->got_offset, h->dynindx,
4930                                    r_type, gotent->addend);
4931
4932           if (gotent->reloc_type == R_ALPHA_TLSGD)
4933             elf64_alpha_emit_dynrel (output_bfd, info, sgot, srel,
4934                                      gotent->got_offset + 8, h->dynindx,
4935                                      R_ALPHA_DTPREL64, gotent->addend);
4936         }
4937     }
4938
4939   /* Mark some specially defined symbols as absolute.  */
4940   if (h == elf_hash_table (info)->hdynamic
4941       || h == elf_hash_table (info)->hgot
4942       || h == elf_hash_table (info)->hplt)
4943     sym->st_shndx = SHN_ABS;
4944
4945   return TRUE;
4946 }
4947
4948 /* Finish up the dynamic sections.  */
4949
4950 static bfd_boolean
4951 elf64_alpha_finish_dynamic_sections (bfd *output_bfd,
4952                                      struct bfd_link_info *info)
4953 {
4954   bfd *dynobj;
4955   asection *sdyn;
4956
4957   dynobj = elf_hash_table (info)->dynobj;
4958   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4959
4960   if (elf_hash_table (info)->dynamic_sections_created)
4961     {
4962       asection *splt, *sgotplt, *srelaplt;
4963       Elf64_External_Dyn *dyncon, *dynconend;
4964       bfd_vma plt_vma, gotplt_vma;
4965
4966       splt = elf_hash_table (info)->splt;
4967       srelaplt = elf_hash_table (info)->srelplt;
4968       BFD_ASSERT (splt != NULL && sdyn != NULL);
4969
4970       plt_vma = splt->output_section->vma + splt->output_offset;
4971
4972       gotplt_vma = 0;
4973       if (elf64_alpha_use_secureplt)
4974         {
4975           sgotplt = elf_hash_table (info)->sgotplt;
4976           BFD_ASSERT (sgotplt != NULL);
4977           if (sgotplt->size > 0)
4978             gotplt_vma = sgotplt->output_section->vma + sgotplt->output_offset;
4979         }
4980
4981       dyncon = (Elf64_External_Dyn *) sdyn->contents;
4982       dynconend = (Elf64_External_Dyn *) (sdyn->contents + sdyn->size);
4983       for (; dyncon < dynconend; dyncon++)
4984         {
4985           Elf_Internal_Dyn dyn;
4986
4987           bfd_elf64_swap_dyn_in (dynobj, dyncon, &dyn);
4988
4989           switch (dyn.d_tag)
4990             {
4991             case DT_PLTGOT:
4992               dyn.d_un.d_ptr
4993                 = elf64_alpha_use_secureplt ? gotplt_vma : plt_vma;
4994               break;
4995             case DT_PLTRELSZ:
4996               dyn.d_un.d_val = srelaplt ? srelaplt->size : 0;
4997               break;
4998             case DT_JMPREL:
4999               dyn.d_un.d_ptr = srelaplt ? (srelaplt->output_section->vma
5000                                            + srelaplt->output_offset) : 0;
5001               break;
5002             }
5003
5004           bfd_elf64_swap_dyn_out (output_bfd, &dyn, dyncon);
5005         }
5006
5007       /* Initialize the plt header.  */
5008       if (splt->size > 0)
5009         {
5010           unsigned int insn;
5011           int ofs;
5012
5013           if (elf64_alpha_use_secureplt)
5014             {
5015               ofs = gotplt_vma - (plt_vma + PLT_HEADER_SIZE);
5016
5017               insn = INSN_ABC (INSN_SUBQ, 27, 28, 25);
5018               bfd_put_32 (output_bfd, insn, splt->contents);
5019
5020               insn = INSN_ABO (INSN_LDAH, 28, 28, (ofs + 0x8000) >> 16);
5021               bfd_put_32 (output_bfd, insn, splt->contents + 4);
5022
5023               insn = INSN_ABC (INSN_S4SUBQ, 25, 25, 25);
5024               bfd_put_32 (output_bfd, insn, splt->contents + 8);
5025
5026               insn = INSN_ABO (INSN_LDA, 28, 28, ofs);
5027               bfd_put_32 (output_bfd, insn, splt->contents + 12);
5028
5029               insn = INSN_ABO (INSN_LDQ, 27, 28, 0);
5030               bfd_put_32 (output_bfd, insn, splt->contents + 16);
5031
5032               insn = INSN_ABC (INSN_ADDQ, 25, 25, 25);
5033               bfd_put_32 (output_bfd, insn, splt->contents + 20);
5034
5035               insn = INSN_ABO (INSN_LDQ, 28, 28, 8);
5036               bfd_put_32 (output_bfd, insn, splt->contents + 24);
5037
5038               insn = INSN_AB (INSN_JMP, 31, 27);
5039               bfd_put_32 (output_bfd, insn, splt->contents + 28);
5040
5041               insn = INSN_AD (INSN_BR, 28, -PLT_HEADER_SIZE);
5042               bfd_put_32 (output_bfd, insn, splt->contents + 32);
5043             }
5044           else
5045             {
5046               insn = INSN_AD (INSN_BR, 27, 0);  /* br $27, .+4 */
5047               bfd_put_32 (output_bfd, insn, splt->contents);
5048
5049               insn = INSN_ABO (INSN_LDQ, 27, 27, 12);
5050               bfd_put_32 (output_bfd, insn, splt->contents + 4);
5051
5052               insn = INSN_UNOP;
5053               bfd_put_32 (output_bfd, insn, splt->contents + 8);
5054
5055               insn = INSN_AB (INSN_JMP, 27, 27);
5056               bfd_put_32 (output_bfd, insn, splt->contents + 12);
5057
5058               /* The next two words will be filled in by ld.so.  */
5059               bfd_put_64 (output_bfd, 0, splt->contents + 16);
5060               bfd_put_64 (output_bfd, 0, splt->contents + 24);
5061             }
5062
5063           elf_section_data (splt->output_section)->this_hdr.sh_entsize = 0;
5064         }
5065     }
5066
5067   return TRUE;
5068 }
5069
5070 /* We need to use a special link routine to handle the .mdebug section.
5071    We need to merge all instances of these sections together, not write
5072    them all out sequentially.  */
5073
5074 static bfd_boolean
5075 elf64_alpha_final_link (bfd *abfd, struct bfd_link_info *info)
5076 {
5077   asection *o;
5078   struct bfd_link_order *p;
5079   asection *mdebug_sec;
5080   struct ecoff_debug_info debug;
5081   const struct ecoff_debug_swap *swap
5082     = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
5083   HDRR *symhdr = &debug.symbolic_header;
5084   void * mdebug_handle = NULL;
5085   struct alpha_elf_link_hash_table * htab;
5086
5087   htab = alpha_elf_hash_table (info);
5088   if (htab == NULL)
5089     return FALSE;
5090
5091   /* Go through the sections and collect the mdebug information.  */
5092   mdebug_sec = NULL;
5093   for (o = abfd->sections; o != (asection *) NULL; o = o->next)
5094     {
5095       if (strcmp (o->name, ".mdebug") == 0)
5096         {
5097           struct extsym_info einfo;
5098
5099           /* We have found the .mdebug section in the output file.
5100              Look through all the link_orders comprising it and merge
5101              the information together.  */
5102           symhdr->magic = swap->sym_magic;
5103           /* FIXME: What should the version stamp be?  */
5104           symhdr->vstamp = 0;
5105           symhdr->ilineMax = 0;
5106           symhdr->cbLine = 0;
5107           symhdr->idnMax = 0;
5108           symhdr->ipdMax = 0;
5109           symhdr->isymMax = 0;
5110           symhdr->ioptMax = 0;
5111           symhdr->iauxMax = 0;
5112           symhdr->issMax = 0;
5113           symhdr->issExtMax = 0;
5114           symhdr->ifdMax = 0;
5115           symhdr->crfd = 0;
5116           symhdr->iextMax = 0;
5117
5118           /* We accumulate the debugging information itself in the
5119              debug_info structure.  */
5120           debug.line = NULL;
5121           debug.external_dnr = NULL;
5122           debug.external_pdr = NULL;
5123           debug.external_sym = NULL;
5124           debug.external_opt = NULL;
5125           debug.external_aux = NULL;
5126           debug.ss = NULL;
5127           debug.ssext = debug.ssext_end = NULL;
5128           debug.external_fdr = NULL;
5129           debug.external_rfd = NULL;
5130           debug.external_ext = debug.external_ext_end = NULL;
5131
5132           mdebug_handle = bfd_ecoff_debug_init (abfd, &debug, swap, info);
5133           if (mdebug_handle == NULL)
5134             return FALSE;
5135
5136           if (1)
5137             {
5138               asection *s;
5139               EXTR esym;
5140               bfd_vma last = 0;
5141               unsigned int i;
5142               static const char * const name[] =
5143                 {
5144                   ".text", ".init", ".fini", ".data",
5145                   ".rodata", ".sdata", ".sbss", ".bss"
5146                 };
5147               static const int sc[] = { scText, scInit, scFini, scData,
5148                                           scRData, scSData, scSBss, scBss };
5149
5150               esym.jmptbl = 0;
5151               esym.cobol_main = 0;
5152               esym.weakext = 0;
5153               esym.reserved = 0;
5154               esym.ifd = ifdNil;
5155               esym.asym.iss = issNil;
5156               esym.asym.st = stLocal;
5157               esym.asym.reserved = 0;
5158               esym.asym.index = indexNil;
5159               for (i = 0; i < 8; i++)
5160                 {
5161                   esym.asym.sc = sc[i];
5162                   s = bfd_get_section_by_name (abfd, name[i]);
5163                   if (s != NULL)
5164                     {
5165                       esym.asym.value = s->vma;
5166                       last = s->vma + s->size;
5167                     }
5168                   else
5169                     esym.asym.value = last;
5170
5171                   if (! bfd_ecoff_debug_one_external (abfd, &debug, swap,
5172                                                       name[i], &esym))
5173                     return FALSE;
5174                 }
5175             }
5176
5177           for (p = o->map_head.link_order;
5178                p != (struct bfd_link_order *) NULL;
5179                p = p->next)
5180             {
5181               asection *input_section;
5182               bfd *input_bfd;
5183               const struct ecoff_debug_swap *input_swap;
5184               struct ecoff_debug_info input_debug;
5185               char *eraw_src;
5186               char *eraw_end;
5187
5188               if (p->type != bfd_indirect_link_order)
5189                 {
5190                   if (p->type == bfd_data_link_order)
5191                     continue;
5192                   abort ();
5193                 }
5194
5195               input_section = p->u.indirect.section;
5196               input_bfd = input_section->owner;
5197
5198               if (! is_alpha_elf (input_bfd))
5199                 /* I don't know what a non ALPHA ELF bfd would be
5200                    doing with a .mdebug section, but I don't really
5201                    want to deal with it.  */
5202                 continue;
5203
5204               input_swap = (get_elf_backend_data (input_bfd)
5205                             ->elf_backend_ecoff_debug_swap);
5206
5207               BFD_ASSERT (p->size == input_section->size);
5208
5209               /* The ECOFF linking code expects that we have already
5210                  read in the debugging information and set up an
5211                  ecoff_debug_info structure, so we do that now.  */
5212               if (!elf64_alpha_read_ecoff_info (input_bfd, input_section,
5213                                                 &input_debug))
5214                 return FALSE;
5215
5216               if (! (bfd_ecoff_debug_accumulate
5217                      (mdebug_handle, abfd, &debug, swap, input_bfd,
5218                       &input_debug, input_swap, info)))
5219                 return FALSE;
5220
5221               /* Loop through the external symbols.  For each one with
5222                  interesting information, try to find the symbol in
5223                  the linker global hash table and save the information
5224                  for the output external symbols.  */
5225               eraw_src = (char *) input_debug.external_ext;
5226               eraw_end = (eraw_src
5227                           + (input_debug.symbolic_header.iextMax
5228                              * input_swap->external_ext_size));
5229               for (;
5230                    eraw_src < eraw_end;
5231                    eraw_src += input_swap->external_ext_size)
5232                 {
5233                   EXTR ext;
5234                   const char *name;
5235                   struct alpha_elf_link_hash_entry *h;
5236
5237                   (*input_swap->swap_ext_in) (input_bfd, eraw_src, &ext);
5238                   if (ext.asym.sc == scNil
5239                       || ext.asym.sc == scUndefined
5240                       || ext.asym.sc == scSUndefined)
5241                     continue;
5242
5243                   name = input_debug.ssext + ext.asym.iss;
5244                   h = alpha_elf_link_hash_lookup (htab, name, FALSE, FALSE, TRUE);
5245                   if (h == NULL || h->esym.ifd != -2)
5246                     continue;
5247
5248                   if (ext.ifd != -1)
5249                     {
5250                       BFD_ASSERT (ext.ifd
5251                                   < input_debug.symbolic_header.ifdMax);
5252                       ext.ifd = input_debug.ifdmap[ext.ifd];
5253                     }
5254
5255                   h->esym = ext;
5256                 }
5257
5258               /* Free up the information we just read.  */
5259               free (input_debug.line);
5260               free (input_debug.external_dnr);
5261               free (input_debug.external_pdr);
5262               free (input_debug.external_sym);
5263               free (input_debug.external_opt);
5264               free (input_debug.external_aux);
5265               free (input_debug.ss);
5266               free (input_debug.ssext);
5267               free (input_debug.external_fdr);
5268               free (input_debug.external_rfd);
5269               free (input_debug.external_ext);
5270
5271               /* Hack: reset the SEC_HAS_CONTENTS flag so that
5272                  elf_link_input_bfd ignores this section.  */
5273               input_section->flags &=~ SEC_HAS_CONTENTS;
5274             }
5275
5276           /* Build the external symbol information.  */
5277           einfo.abfd = abfd;
5278           einfo.info = info;
5279           einfo.debug = &debug;
5280           einfo.swap = swap;
5281           einfo.failed = FALSE;
5282           elf_link_hash_traverse (elf_hash_table (info),
5283                                   elf64_alpha_output_extsym,
5284                                   &einfo);
5285           if (einfo.failed)
5286             return FALSE;
5287
5288           /* Set the size of the .mdebug section.  */
5289           o->size = bfd_ecoff_debug_size (abfd, &debug, swap);
5290
5291           /* Skip this section later on (I don't think this currently
5292              matters, but someday it might).  */
5293           o->map_head.link_order = (struct bfd_link_order *) NULL;
5294
5295           mdebug_sec = o;
5296         }
5297     }
5298
5299   /* Invoke the regular ELF backend linker to do all the work.  */
5300   if (! bfd_elf_final_link (abfd, info))
5301     return FALSE;
5302
5303   /* Now write out the computed sections.  */
5304
5305   /* The .got subsections...  */
5306   {
5307     bfd *i, *dynobj = elf_hash_table(info)->dynobj;
5308     for (i = htab->got_list;
5309          i != NULL;
5310          i = alpha_elf_tdata(i)->got_link_next)
5311       {
5312         asection *sgot;
5313
5314         /* elf_bfd_final_link already did everything in dynobj.  */
5315         if (i == dynobj)
5316           continue;
5317
5318         sgot = alpha_elf_tdata(i)->got;
5319         if (! bfd_set_section_contents (abfd, sgot->output_section,
5320                                         sgot->contents,
5321                                         (file_ptr) sgot->output_offset,
5322                                         sgot->size))
5323           return FALSE;
5324       }
5325   }
5326
5327   if (mdebug_sec != (asection *) NULL)
5328     {
5329       BFD_ASSERT (abfd->output_has_begun);
5330       if (! bfd_ecoff_write_accumulated_debug (mdebug_handle, abfd, &debug,
5331                                                swap, info,
5332                                                mdebug_sec->filepos))
5333         return FALSE;
5334
5335       bfd_ecoff_debug_free (mdebug_handle, abfd, &debug, swap, info);
5336     }
5337
5338   return TRUE;
5339 }
5340
5341 static enum elf_reloc_type_class
5342 elf64_alpha_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
5343                               const asection *rel_sec ATTRIBUTE_UNUSED,
5344                               const Elf_Internal_Rela *rela)
5345 {
5346   switch ((int) ELF64_R_TYPE (rela->r_info))
5347     {
5348     case R_ALPHA_RELATIVE:
5349       return reloc_class_relative;
5350     case R_ALPHA_JMP_SLOT:
5351       return reloc_class_plt;
5352     case R_ALPHA_COPY:
5353       return reloc_class_copy;
5354     default:
5355       return reloc_class_normal;
5356     }
5357 }
5358 \f
5359 static const struct bfd_elf_special_section elf64_alpha_special_sections[] =
5360 {
5361   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL },
5362   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_ALPHA_GPREL },
5363   { NULL,                     0,  0, 0,            0 }
5364 };
5365
5366 /* ECOFF swapping routines.  These are used when dealing with the
5367    .mdebug section, which is in the ECOFF debugging format.  Copied
5368    from elf32-mips.c.  */
5369 static const struct ecoff_debug_swap
5370 elf64_alpha_ecoff_debug_swap =
5371 {
5372   /* Symbol table magic number.  */
5373   magicSym2,
5374   /* Alignment of debugging information.  E.g., 4.  */
5375   8,
5376   /* Sizes of external symbolic information.  */
5377   sizeof (struct hdr_ext),
5378   sizeof (struct dnr_ext),
5379   sizeof (struct pdr_ext),
5380   sizeof (struct sym_ext),
5381   sizeof (struct opt_ext),
5382   sizeof (struct fdr_ext),
5383   sizeof (struct rfd_ext),
5384   sizeof (struct ext_ext),
5385   /* Functions to swap in external symbolic data.  */
5386   ecoff_swap_hdr_in,
5387   ecoff_swap_dnr_in,
5388   ecoff_swap_pdr_in,
5389   ecoff_swap_sym_in,
5390   ecoff_swap_opt_in,
5391   ecoff_swap_fdr_in,
5392   ecoff_swap_rfd_in,
5393   ecoff_swap_ext_in,
5394   _bfd_ecoff_swap_tir_in,
5395   _bfd_ecoff_swap_rndx_in,
5396   /* Functions to swap out external symbolic data.  */
5397   ecoff_swap_hdr_out,
5398   ecoff_swap_dnr_out,
5399   ecoff_swap_pdr_out,
5400   ecoff_swap_sym_out,
5401   ecoff_swap_opt_out,
5402   ecoff_swap_fdr_out,
5403   ecoff_swap_rfd_out,
5404   ecoff_swap_ext_out,
5405   _bfd_ecoff_swap_tir_out,
5406   _bfd_ecoff_swap_rndx_out,
5407   /* Function to read in symbolic data.  */
5408   elf64_alpha_read_ecoff_info
5409 };
5410 \f
5411 /* Use a non-standard hash bucket size of 8.  */
5412
5413 static const struct elf_size_info alpha_elf_size_info =
5414 {
5415   sizeof (Elf64_External_Ehdr),
5416   sizeof (Elf64_External_Phdr),
5417   sizeof (Elf64_External_Shdr),
5418   sizeof (Elf64_External_Rel),
5419   sizeof (Elf64_External_Rela),
5420   sizeof (Elf64_External_Sym),
5421   sizeof (Elf64_External_Dyn),
5422   sizeof (Elf_External_Note),
5423   8,
5424   1,
5425   64, 3,
5426   ELFCLASS64, EV_CURRENT,
5427   bfd_elf64_write_out_phdrs,
5428   bfd_elf64_write_shdrs_and_ehdr,
5429   bfd_elf64_checksum_contents,
5430   bfd_elf64_write_relocs,
5431   bfd_elf64_swap_symbol_in,
5432   bfd_elf64_swap_symbol_out,
5433   bfd_elf64_slurp_reloc_table,
5434   bfd_elf64_slurp_symbol_table,
5435   bfd_elf64_swap_dyn_in,
5436   bfd_elf64_swap_dyn_out,
5437   bfd_elf64_swap_reloc_in,
5438   bfd_elf64_swap_reloc_out,
5439   bfd_elf64_swap_reloca_in,
5440   bfd_elf64_swap_reloca_out
5441 };
5442
5443 #define TARGET_LITTLE_SYM       alpha_elf64_vec
5444 #define TARGET_LITTLE_NAME      "elf64-alpha"
5445 #define ELF_ARCH                bfd_arch_alpha
5446 #define ELF_TARGET_ID           ALPHA_ELF_DATA
5447 #define ELF_MACHINE_CODE        EM_ALPHA
5448 #define ELF_MAXPAGESIZE 0x10000
5449 #define ELF_COMMONPAGESIZE      0x2000
5450
5451 #define bfd_elf64_bfd_link_hash_table_create \
5452   elf64_alpha_bfd_link_hash_table_create
5453
5454 #define bfd_elf64_bfd_reloc_type_lookup \
5455   elf64_alpha_bfd_reloc_type_lookup
5456 #define bfd_elf64_bfd_reloc_name_lookup \
5457   elf64_alpha_bfd_reloc_name_lookup
5458 #define elf_info_to_howto \
5459   elf64_alpha_info_to_howto
5460
5461 #define bfd_elf64_mkobject \
5462   elf64_alpha_mkobject
5463 #define elf_backend_object_p \
5464   elf64_alpha_object_p
5465
5466 #define elf_backend_section_from_shdr \
5467   elf64_alpha_section_from_shdr
5468 #define elf_backend_section_flags \
5469   elf64_alpha_section_flags
5470 #define elf_backend_fake_sections \
5471   elf64_alpha_fake_sections
5472
5473 #define bfd_elf64_bfd_is_local_label_name \
5474   elf64_alpha_is_local_label_name
5475 #define bfd_elf64_find_nearest_line \
5476   elf64_alpha_find_nearest_line
5477 #define bfd_elf64_bfd_relax_section \
5478   elf64_alpha_relax_section
5479
5480 #define elf_backend_add_symbol_hook \
5481   elf64_alpha_add_symbol_hook
5482 #define elf_backend_relocs_compatible \
5483   _bfd_elf_relocs_compatible
5484 #define elf_backend_sort_relocs_p \
5485   elf64_alpha_sort_relocs_p
5486 #define elf_backend_check_relocs \
5487   elf64_alpha_check_relocs
5488 #define elf_backend_create_dynamic_sections \
5489   elf64_alpha_create_dynamic_sections
5490 #define elf_backend_adjust_dynamic_symbol \
5491   elf64_alpha_adjust_dynamic_symbol
5492 #define elf_backend_merge_symbol_attribute \
5493   elf64_alpha_merge_symbol_attribute
5494 #define elf_backend_copy_indirect_symbol \
5495   elf64_alpha_copy_indirect_symbol
5496 #define elf_backend_always_size_sections \
5497   elf64_alpha_always_size_sections
5498 #define elf_backend_size_dynamic_sections \
5499   elf64_alpha_size_dynamic_sections
5500 #define elf_backend_omit_section_dynsym \
5501   _bfd_elf_omit_section_dynsym_all
5502 #define elf_backend_relocate_section \
5503   elf64_alpha_relocate_section
5504 #define elf_backend_finish_dynamic_symbol \
5505   elf64_alpha_finish_dynamic_symbol
5506 #define elf_backend_finish_dynamic_sections \
5507   elf64_alpha_finish_dynamic_sections
5508 #define bfd_elf64_bfd_final_link \
5509   elf64_alpha_final_link
5510 #define elf_backend_reloc_type_class \
5511   elf64_alpha_reloc_type_class
5512
5513 #define elf_backend_can_gc_sections     1
5514 #define elf_backend_gc_mark_hook        elf64_alpha_gc_mark_hook
5515
5516 #define elf_backend_ecoff_debug_swap \
5517   &elf64_alpha_ecoff_debug_swap
5518
5519 #define elf_backend_size_info \
5520   alpha_elf_size_info
5521
5522 #define elf_backend_special_sections \
5523   elf64_alpha_special_sections
5524
5525 /* A few constants that determine how the .plt section is set up.  */
5526 #define elf_backend_want_got_plt 0
5527 #define elf_backend_plt_readonly 0
5528 #define elf_backend_want_plt_sym 1
5529 #define elf_backend_got_header_size 0
5530 #define elf_backend_dtrel_excludes_plt 1
5531
5532 #include "elf64-target.h"
5533 \f
5534 /* FreeBSD support.  */
5535
5536 #undef TARGET_LITTLE_SYM
5537 #define TARGET_LITTLE_SYM       alpha_elf64_fbsd_vec
5538 #undef TARGET_LITTLE_NAME
5539 #define TARGET_LITTLE_NAME      "elf64-alpha-freebsd"
5540 #undef  ELF_OSABI
5541 #define ELF_OSABI               ELFOSABI_FREEBSD
5542
5543 /* The kernel recognizes executables as valid only if they carry a
5544    "FreeBSD" label in the ELF header.  So we put this label on all
5545    executables and (for simplicity) also all other object files.  */
5546
5547 static void
5548 elf64_alpha_fbsd_post_process_headers (bfd * abfd,
5549         struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
5550 {
5551   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
5552
5553   i_ehdrp = elf_elfheader (abfd);
5554
5555   /* Put an ABI label supported by FreeBSD >= 4.1.  */
5556   i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
5557 #ifdef OLD_FREEBSD_ABI_LABEL
5558   /* The ABI label supported by FreeBSD <= 4.0 is quite nonstandard.  */
5559   memcpy (&i_ehdrp->e_ident[EI_ABIVERSION], "FreeBSD", 8);
5560 #endif
5561 }
5562
5563 #undef elf_backend_post_process_headers
5564 #define elf_backend_post_process_headers \
5565   elf64_alpha_fbsd_post_process_headers
5566
5567 #undef  elf64_bed
5568 #define elf64_bed elf64_alpha_fbsd_bed
5569
5570 #include "elf64-target.h"